diff --git a/Makefile b/Makefile
new file mode 100644
index 00000000..75b38698
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,278 @@
+ARCH 					= win64
+PREFIX					= gcc
+TARGET_NAME 			= program
+TARGET_EXTENSION 		= exe
+TARGET_LIB_EXTENSION 	= dll
+
+include makefiles/$(ARCH).$(PREFIX).make
+
+ .PHONY: $(ARCH)-$(PREFIX)
+
+BIN_DIR 				+= ./bin
+
+ENGINE_SRC_DIR 			+= ./engine/src
+ENGINE_INC_DIR 			+= ./engine/inc
+ENGINE_LIB_DIR 			+= ./engine/lib
+
+EXT_SRC_DIR 			+= ./ext
+CLIENT_SRC_DIR 			+= ./client
+
+UF_LIBS 				+= 
+EXT_LIBS 				+=
+FLAGS 				  	+= -Wno-pointer-arith
+LIB_NAME 				+= uf
+EXT_LIB_NAME 			+= ext
+
+#VULKAN_SDK_PATH 		+= /c/VulkanSDK/1.2.154.0/
+VULKAN_SDK_PATH 		+= /c/VulkanSDK/1.2.162.0/
+GLSL_VALIDATOR 			+= $(VULKAN_SDK_PATH)/Bin32/glslangValidator
+# Base Engine's DLL
+INC_DIR 				+= $(ENGINE_INC_DIR)/$(ARCH)/$(PREFIX)
+DEPS 					+=
+	
+ifneq (,$(findstring win64,$(ARCH)))
+	REQ_DEPS 			+= vulkan json:nlohmann png openal ogg freetype ncurses curl luajit bullet meshoptimizer # draco discord
+	FLAGS 				+= 
+	DEPS 				+= -lgdi32
+else ifneq (,$(findstring dreamcast,$(ARCH)))
+	REQ_DEPS 			+= opengl gldc json:nlohmann png meshoptimizer bullet freetype # lua ogg openal draco luajit ultralight-ux ncurses curl openvr discord
+	FLAGS 				+= $(KOS_CPPFLAGS) -frtti -DUF_NO_EXCEPTIONS
+	INCS 				+= $(KOS_INC_PATHS) -I/opt/dreamcast/sh-elf/sh-elf/include
+	LIBS 				+= $(KOS_LIB_PATHS) -L/opt/dreamcast/sh-elf/sh-elf/lib
+endif
+ifneq (,$(findstring vulkan,$(REQ_DEPS)))
+	FLAGS 				+= -DVK_USE_PLATFORM_WIN32_KHR -DUF_USE_VULKAN
+	DEPS 				+= -lvulkan -lspirv-cross
+endif
+ifneq (,$(findstring opengl,$(REQ_DEPS)))
+	FLAGS 				+= -DUF_USE_OPENGL -DUF_USE_GLEW -DUF_USE_OPENGL_FIXED_FUNCTION
+	ifneq (,$(findstring dreamcast,$(ARCH)))
+		ifneq (,$(findstring gldc,$(REQ_DEPS)))
+			DEPS 		+= -lGLdc
+			FLAGS 		+= -DUF_USE_OPENGL_GLDC
+		else
+			DEPS 		+= -lGL #-lGLdc
+		endif
+	else
+		DEPS 			+= -lglew32 -lopengl32 -lglu32
+	endif
+endif
+ifneq (,$(findstring json,$(REQ_DEPS)))
+	FLAGS 				+= -DUF_USE_JSON
+	DEPS 				+=
+	ifneq (,$(findstring nlohmann,$(REQ_DEPS)))
+		FLAGS 			+= -DUF_JSON_USE_NLOHMANN
+	endif
+endif
+ifneq (,$(findstring png,$(REQ_DEPS)))
+	FLAGS 				+= -DUF_USE_PNG
+	DEPS 				+= -lpng -lz -lbz2
+endif
+ifneq (,$(findstring openal,$(REQ_DEPS)))
+	FLAGS 				+= -DUF_USE_OPENAL
+	ifneq (,$(findstring dreamcast,$(ARCH)))
+		DEPS 				+= -lAL
+	else
+		FLAGS 				+= -DUF_USE_ALUT
+		DEPS 				+= -lopenal -lalut
+	endif
+endif
+ifneq (,$(findstring ogg,$(REQ_DEPS)))
+	FLAGS 				+= -DUF_USE_VORBIS
+	ifneq (,$(findstring dreamcast,$(ARCH)))
+		DEPS 				+= -lvorbis -logg
+	else
+		DEPS 				+= -lvorbis -lvorbisfile -logg
+	endif
+endif
+ifneq (,$(findstring freetype,$(REQ_DEPS)))
+	FLAGS 				+= -DUF_USE_FREETYPE 
+	DEPS 				+= -lfreetype
+	ifneq (,$(findstring dreamcast,$(ARCH)))
+		DEPS 			+= -lbrotlicommon-static -lbrotlidec-static
+	endif
+endif
+ifneq (,$(findstring ncurses,$(REQ_DEPS)))
+	FLAGS 				+= -DUF_USE_NCURSES
+	DEPS 				+= -lncursesw
+endif
+ifneq (,$(findstring curl,$(REQ_DEPS)))
+	FLAGS 				+= -DUF_USE_CURL
+	DEPS 				+= -lcurl
+endif
+ifneq (,$(findstring discord,$(REQ_DEPS)))
+	FLAGS 				+= -DUF_USE_DISCORD
+	DEPS 				+= -ldiscord_game_sdk
+endif
+ifneq (,$(findstring openvr,$(REQ_DEPS)))
+	FLAGS 				+= -DUF_USE_OPENVR -DUSE_OPENVR_MINGW
+	DEPS 				+= -lopenvr_api 
+endif
+ifneq (,$(findstring lua,$(REQ_DEPS)))
+	FLAGS 				+= -DUF_USE_LUA
+	ifneq (,$(findstring luajit,$(REQ_DEPS)))
+		FLAGS 				+= -DUF_USE_LUAJIT
+		DEPS 				+= -lluajit-5.1
+		INCS 				+= -I/mingw64/include/luajit-2.1
+	else
+		ifneq (,$(findstring dreamcast,$(ARCH)))
+			DEPS 			+= -llua
+			INCS 			+= -I/opt/dreamcast/kos-ports/include/lua
+		endif
+	endif
+endif
+ifneq (,$(findstring ultralight-ux,$(REQ_DEPS)))
+	FLAGS 				+= -DUF_USE_ULTRALIGHT_UX
+	DEPS 				+= -lUltralight -lUltralightCore -lWebCore -lAppCore
+endif
+ifneq (,$(findstring bullet,$(REQ_DEPS)))
+	FLAGS 				+= -DUF_USE_BULLET
+	ifneq (,$(findstring dreamcast,$(ARCH)))
+		DEPS 				+= -lbulletdynamics -lbulletcollision -lbulletlinearmath
+	else
+		DEPS 				+= -lBulletDynamics -lBulletCollision -lLinearMath
+		INCS 				+= -I$(ENGINE_INC_DIR)/bullet/
+	endif
+endif
+ifneq (,$(findstring simd,$(REQ_DEPS)))
+	FLAGS 				+= -DUF_USE_SIMD #-march=native
+
+endif
+ifneq (,$(findstring meshoptimizer,$(REQ_DEPS)))
+	FLAGS 				+= -DUF_USE_MESHOPTIMIZER
+	DEPS 				+= -lmeshoptimizer
+endif
+ifneq (,$(findstring draco,$(REQ_DEPS)))
+	FLAGS 				+= -DUF_USE_DRACO
+	DEPS 				+= -ldraco
+endif
+
+#DEPS 					+= -lvulkan -lncursesw
+LINKS 					+= $(UF_LIBS) $(EXT_LIBS) $(DEPS)
+#-Wl,-subsystem,windows
+
+LIB_DIR 				+= $(ENGINE_LIB_DIR)/$(ARCH)
+INCS 					+= -I$(ENGINE_INC_DIR) -I$(INC_DIR) -I$(VULKAN_SDK_PATH)/include -I/mingw64/include
+LIBS 					+= -L$(ENGINE_LIB_DIR) -L$(LIB_DIR) -L$(LIB_DIR)/$(PREFIX) -L$(VULKAN_SDK_PATH)/Lib
+
+SRCS_DLL 				+= $(wildcard $(ENGINE_SRC_DIR)/*.cpp) $(wildcard $(ENGINE_SRC_DIR)/*/*.cpp) $(wildcard $(ENGINE_SRC_DIR)/*/*/*.cpp) $(wildcard $(ENGINE_SRC_DIR)/*/*/*/*.cpp) $(wildcard $(ENGINE_SRC_DIR)/*/*/*/*/*.cpp)
+OBJS_DLL 				+= $(patsubst %.cpp,%.$(ARCH).$(PREFIX).o,$(SRCS_DLL))
+BASE_DLL 				+= lib$(LIB_NAME)
+IM_DLL 					+= $(ENGINE_LIB_DIR)/$(ARCH)/$(PREFIX)/$(BASE_DLL).$(TARGET_LIB_EXTENSION).a
+EX_DLL 					+= $(BIN_DIR)/exe/lib/$(ARCH)/$(PREFIX)/$(BASE_DLL).$(TARGET_LIB_EXTENSION)
+# External Engine's DLL
+EXT_INC_DIR 			+= $(INC_DIR)
+EXT_LB_FLAGS 			+= $(LIB_DIR)
+EXT_DEPS 				+= -l$(LIB_NAME) $(DEPS)
+EXT_LINKS 				+= $(UF_LIBS) $(EXT_LIBS) $(EXT_DEPS)
+#-Wl,-subsystem,windows
+
+EXT_LIB_DIR 			+= $(ENGINE_LIB_DIR)/$(ARCH)
+EXT_INCS 				+= -I$(ENGINE_INC_DIR) -I$(EXT_INC_DIR) -I$(VULKAN_SDK_PATH)/include -I/mingw64/include
+EXT_LIBS 				+= -L$(ENGINE_LIB_DIR) -L$(EXT_LIB_DIR) -L$(EXT_LIB_DIR)/$(PREFIX) -L$(VULKAN_SDK_PATH)/Lib -L/mingw64/lib
+
+SRCS_EXT_DLL 			+= $(wildcard $(EXT_SRC_DIR)/*.cpp) $(wildcard $(EXT_SRC_DIR)/*/*.cpp) $(wildcard $(EXT_SRC_DIR)/*/*/*.cpp) $(wildcard $(EXT_SRC_DIR)/*/*/*/*.cpp) $(wildcard $(EXT_SRC_DIR)/*/*/*/*/*.cpp)
+OBJS_EXT_DLL 			+= $(patsubst %.cpp,%.$(ARCH).$(PREFIX).o,$(SRCS_EXT_DLL))
+BASE_EXT_DLL 			+= lib$(EXT_LIB_NAME)
+EXT_IM_DLL 				+= $(ENGINE_LIB_DIR)/$(ARCH)/$(PREFIX)/$(BASE_EXT_DLL).$(TARGET_LIB_EXTENSION).a
+EXT_EX_DLL 				+= $(BIN_DIR)/exe/lib/$(ARCH)/$(PREFIX)/$(BASE_EXT_DLL).$(TARGET_LIB_EXTENSION)
+# Client EXE
+SRCS 					+= $(wildcard $(CLIENT_SRC_DIR)/*.cpp) $(wildcard $(CLIENT_SRC_DIR)/*/*.cpp)
+OBJS 					+= $(patsubst %.cpp,%.$(ARCH).$(PREFIX).o,$(SRCS))
+TARGET 					+= $(BIN_DIR)/exe/$(TARGET_NAME).$(PREFIX).$(TARGET_EXTENSION)
+# Shaders
+SRCS_SHADERS 			+= $(wildcard bin/data/shaders/*.glsl) $(wildcard bin/data/shaders/*/*.glsl)
+TARGET_SHADERS 			+= $(patsubst %.glsl,%.spv,$(SRCS_SHADERS))
+
+ifneq (,$(findstring dreamcast,$(ARCH)))
+$(ARCH): $(EX_DLL) $(EXT_EX_DLL) $(TARGET) ./bin/dreamcast/$(TARGET_NAME).cdi
+#$(ARCH): $(TARGET) ./bin/dreamcast/$(TARGET_NAME).cdi
+OBJS = $(patsubst %.cpp,%.$(ARCH).$(PREFIX).o,$(SRCS_DLL)) $(patsubst %.cpp,%.$(ARCH).$(PREFIX).o,$(SRCS_EXT_DLL)) $(patsubst %.cpp,%.$(ARCH).$(PREFIX).o,$(SRCS))
+
+DEPS 					+= -lkallisti -lc -lm -lgcc -lstdc++ # -l$(LIB_NAME) -l$(EXT_LIB_NAME)
+
+%.$(ARCH).$(PREFIX).o: %.cpp
+	$(CC) $(FLAGS) $(INCS) -c $< -o $@
+
+$(EX_DLL): FLAGS += -DUF_EXPORTS -DJSON_DLL_BUILD
+$(EX_DLL): $(OBJS_DLL) 
+	$(KOS_AR) cru $@ $^
+	$(KOS_RANLIB) $@
+	cp $@ $(ENGINE_LIB_DIR)/$(ARCH)/$(PREFIX)/$(BASE_DLL).a
+
+$(EXT_EX_DLL): FLAGS += -DEXT_EXPORTS -DJSON_DLL_BUILD
+$(EXT_EX_DLL): $(OBJS_EXT_DLL) 
+	$(KOS_AR) cru $@ $^
+	$(KOS_RANLIB) $@
+	cp $@ $(ENGINE_LIB_DIR)/$(ARCH)/$(PREFIX)/$(BASE_EXT_DLL).a
+
+./bin/dreamcast/romdisk.img:
+	$(KOS_GENROMFS) -f ./bin/dreamcast/romdisk.img -d ./bin/dreamcast/romdisk/ -v
+
+./bin/dreamcast/romdisk.o: ./bin/dreamcast/romdisk.img
+	$(KOS_BASE)/utils/bin2o/bin2o ./bin/dreamcast/romdisk.img romdisk ./bin/dreamcast/romdisk.o
+
+$(TARGET): $(OBJS) ./bin/dreamcast/romdisk.o
+	$(CC) -O2 -fomit-frame-pointer -ml -m4-single-only -ffunction-sections -fdata-sections  $(KOS_INC_PATHS) $(INCS) -D_arch_dreamcast -D_arch_sub_pristine -Wall -g -fno-builtin  -ml -m4-single-only -Wl,-Ttext=0x8c010000 -Wl,--gc-sections -T/opt/dreamcast/kos/utils/ldscripts/shlelf.xc -nodefaultlibs $(KOS_LIB_PATHS) $(LIBS) -o $(TARGET) $(OBJS) ./bin/dreamcast/romdisk.o -Wl,--start-group $(DEPS) -Wl,--end-group
+
+./bin/dreamcast/$(TARGET_NAME).cdi: $(TARGET)
+	cd ./bin/dreamcast/; ./elf2cdi.sh $(TARGET_NAME)
+
+else
+$(ARCH): $(EX_DLL) $(EXT_EX_DLL) $(TARGET) $(TARGET_SHADERS)
+
+%.$(ARCH).$(PREFIX).o: %.cpp
+	$(CC) $(FLAGS) $(INCS) -c $< -o $@
+
+$(EX_DLL): FLAGS += -DUF_EXPORTS -DJSON_DLL_BUILD
+$(EX_DLL): $(OBJS_DLL) 
+	$(CC) -shared -o $(EX_DLL) -g -Wl,--out-implib=$(IM_DLL) $(OBJS_DLL) $(LIBS) $(INCS) $(LINKS)
+	cp $(ENGINE_LIB_DIR)/$(ARCH)/$(PREFIX)/$(BASE_DLL).$(TARGET_LIB_EXTENSION).a $(ENGINE_LIB_DIR)/$(ARCH)/$(PREFIX)/$(BASE_DLL).a
+
+$(EXT_EX_DLL): FLAGS += -DEXT_EXPORTS -DJSON_DLL_BUILD
+$(EXT_EX_DLL): $(OBJS_EXT_DLL) 
+	$(CC) -shared -o $(EXT_EX_DLL) -g -Wl,--out-implib=$(EXT_IM_DLL) $(OBJS_EXT_DLL) $(EXT_LIBS) $(EXT_INCS) $(EXT_LINKS)
+	cp $(ENGINE_LIB_DIR)/$(ARCH)/$(PREFIX)/$(BASE_EXT_DLL).$(TARGET_LIB_EXTENSION).a $(ENGINE_LIB_DIR)/$(ARCH)/$(PREFIX)/$(BASE_EXT_DLL).a
+
+$(TARGET): $(OBJS)
+	$(CC) $(FLAGS) $(OBJS) $(LIBS) $(INCS) $(LINKS) -l$(LIB_NAME) -l$(EXT_LIB_NAME) -o $(TARGET)
+endif
+
+%.spv: %.glsl
+	$(GLSL_VALIDATOR) -V $< -o $@
+ifneq (,$(findstring dreamcast,$(ARCH)))
+clean:
+	@-rm $(EX_DLL)
+	@-rm $(EXT_EX_DLL)
+	@-rm $(TARGET)
+	
+	@-rm -f $(OBJS_DLL)
+	@-rm -f $(OBJS_EXT_DLL)
+	@-rm -f $(OBJS)
+
+	@-rm ./bin/dreamcast/build/*
+	@-rm ./bin/dreamcast/romdisk.*
+	@-rm ./bin/dreamcast/$(TARGET_NAME).*
+else
+clean:
+	@-rm $(EX_DLL)
+	@-rm $(EXT_EX_DLL)
+	@-rm $(TARGET)
+	
+	@-rm -f $(OBJS_DLL)
+	@-rm -f $(OBJS_EXT_DLL)
+	@-rm -f $(OBJS)
+endif
+clean-uf:
+	@-rm $(EX_DLL)
+	@-rm -f $(OBJS_DLL)
+
+clean-exf:
+	@-rm $(EXT_EX_DLL)
+	@-rm -f $(OBJS_EXT_DLL)
+
+clean-exe:
+	-rm $(EX_DLL)
+	-rm $(EXT_EX_DLL)
+	-rm $(TARGET)
+	-rm $(TARGET_SHADERS)
\ No newline at end of file
diff --git a/bin/data/shaders/base/colored.vert.glsl b/bin/data/shaders/base/colored.vert.glsl
new file mode 100644
index 00000000..f2d96b4a
--- /dev/null
+++ b/bin/data/shaders/base/colored.vert.glsl
@@ -0,0 +1,44 @@
+#version 450
+
+layout (constant_id = 0) const uint PASSES = 6;
+layout (location = 0) in vec3 inPos;
+layout (location = 1) in vec2 inUv;
+layout (location = 2) in vec3 inNormal;
+layout (location = 3) in vec4 inColor;
+
+layout( push_constant ) uniform PushBlock {
+  uint pass;
+  uint draw;
+} PushConstant;
+
+struct Matrices {
+	mat4 model;
+	mat4 view[PASSES];
+	mat4 projection[PASSES];
+};
+
+layout (binding = 0) uniform UBO {
+	Matrices matrices;
+	vec4 color;
+} ubo;
+
+layout (location = 0) out vec2 outUv;
+layout (location = 1) out vec4 outColor;
+layout (location = 2) out vec3 outNormal;
+layout (location = 3) out vec3 outPosition;
+
+out gl_PerVertex {
+    vec4 gl_Position;   
+};
+
+
+void main() {
+	outUv = inUv;
+	outColor = inColor.rgba;
+
+	outPosition = vec3(ubo.matrices.view[PushConstant.pass] * ubo.matrices.model * vec4(inPos.xyz, 1.0));
+	outNormal = vec3(ubo.matrices.view[PushConstant.pass] * ubo.matrices.model * vec4(inNormal.xyz, 0.0));
+	outNormal = normalize(outNormal);
+
+	gl_Position = ubo.matrices.projection[PushConstant.pass] * ubo.matrices.view[PushConstant.pass] * ubo.matrices.model * vec4(inPos.xyz, 1.0);
+}
\ No newline at end of file
diff --git a/bin/data/shaders/base/frag.glsl b/bin/data/shaders/base/frag.glsl
new file mode 100644
index 00000000..177d0217
--- /dev/null
+++ b/bin/data/shaders/base/frag.glsl
@@ -0,0 +1,49 @@
+#version 450
+
+#define UF_DEFERRED_SAMPLING 0
+#define UF_CAN_DISCARD 1
+
+layout (binding = 1) uniform sampler2D samplerTexture;
+
+layout (location = 0) in vec2 inUv;
+layout (location = 1) in vec4 inColor;
+layout (location = 2) in vec3 inNormal;
+layout (location = 3) in vec3 inPosition;
+
+layout (location = 0) out uvec2 outId;
+layout (location = 1) out vec2 outNormals;
+#if UF_DEFERRED_SAMPLING
+	layout (location = 2) out vec2 outUvs;
+#else
+	layout (location = 2) out vec4 outAlbedo;
+#endif
+
+vec2 encodeNormals( vec3 n ) {
+	float p = sqrt(n.z*8+8);
+	return n.xy/p + 0.5;
+}
+float mipLevel( in vec2 uv ) {
+	vec2 dx_vtc = dFdx(uv);
+	vec2 dy_vtc = dFdy(uv);
+	return 0.5 * log2(max(dot(dx_vtc, dx_vtc), dot(dy_vtc, dy_vtc)));
+}
+
+void main() {
+	float mip = mipLevel(inUv.xy);
+	vec2 uv = inUv.xy;
+	vec4 C = vec4(1, 1, 1, 1);
+	vec3 P = inPosition;
+	vec3 N = inNormal;
+#if UF_DEFERRED_SAMPLING
+	outUvs = wrap(inUv.xy);
+	vec4 outAlbedo = vec4(0,0,0,0);
+#endif
+#if !UF_DEFERRED_SAMPLING || UF_CAN_DISCARD
+	C = textureLod( samplerTexture, uv, mip );
+#endif
+#if !UF_DEFERRED_SAMPLING
+	outAlbedo = C * inColor;
+#endif
+	outNormals = encodeNormals( N );
+	//outId = ivec2(0, 0);
+}
\ No newline at end of file
diff --git a/bin/data/shaders/base/vert.glsl b/bin/data/shaders/base/vert.glsl
new file mode 100644
index 00000000..0c83f290
--- /dev/null
+++ b/bin/data/shaders/base/vert.glsl
@@ -0,0 +1,43 @@
+#version 450
+
+layout (constant_id = 0) const uint PASSES = 6;
+layout (location = 0) in vec3 inPos;
+layout (location = 1) in vec2 inUv;
+layout (location = 2) in vec3 inNormal;
+
+layout( push_constant ) uniform PushBlock {
+  uint pass;
+  uint draw;
+} PushConstant;
+
+struct Matrices {
+	mat4 model;
+	mat4 view[PASSES];
+	mat4 projection[PASSES];
+};
+
+layout (binding = 0) uniform UBO {
+	Matrices matrices;
+	vec4 color;
+} ubo;
+
+layout (location = 0) out vec2 outUv;
+layout (location = 1) out vec4 outColor;
+layout (location = 2) out vec3 outNormal;
+layout (location = 3) out vec3 outPosition;
+
+out gl_PerVertex {
+    vec4 gl_Position;   
+};
+
+
+void main() {
+	outUv = inUv;
+	outColor = ubo.color;
+
+	outPosition = vec3(ubo.matrices.view[PushConstant.pass] * ubo.matrices.model * vec4(inPos.xyz, 1.0));
+	outNormal = vec3(ubo.matrices.view[PushConstant.pass] * ubo.matrices.model * vec4(inNormal.xyz, 0.0));
+	outNormal = normalize(outNormal);
+
+	gl_Position = ubo.matrices.projection[PushConstant.pass] * ubo.matrices.view[PushConstant.pass] * ubo.matrices.model * vec4(inPos.xyz, 1.0);
+}
\ No newline at end of file
diff --git a/bin/data/shaders/display/blit.frag.glsl b/bin/data/shaders/display/blit.frag.glsl
new file mode 100644
index 00000000..64e61a6a
--- /dev/null
+++ b/bin/data/shaders/display/blit.frag.glsl
@@ -0,0 +1,23 @@
+#version 450
+#extension GL_EXT_samplerless_texture_functions : require
+
+layout (binding = 1) uniform sampler samp;
+layout (binding = 2) uniform texture2D albedoLeftTexture;
+layout (binding = 3) uniform texture2D albedoRightTexture;
+
+layout (location = 0) in vec2 inUv;
+
+layout (location = 0) out vec4 outAlbedoSpecular;
+
+layout( push_constant ) uniform PushBlock {
+  uint pass;
+} PushConstant;
+
+void main() {
+	if ( PushConstant.pass == 0 ) {
+		outAlbedoSpecular.rgb = texture(sampler2D(albedoLeftTexture, samp), inUv).rgb;
+	} else {
+		outAlbedoSpecular.rgb = texture(sampler2D(albedoRightTexture, samp), inUv).rgb;
+	}
+	outAlbedoSpecular.a = 1;
+}
\ No newline at end of file
diff --git a/bin/data/shaders/display/blit.vert.glsl b/bin/data/shaders/display/blit.vert.glsl
new file mode 100644
index 00000000..e9638741
--- /dev/null
+++ b/bin/data/shaders/display/blit.vert.glsl
@@ -0,0 +1,16 @@
+#version 450
+
+layout (location = 0) in vec2 inPos;
+layout (location = 1) in vec2 inUv;
+
+layout (location = 0) out vec2 outUv;
+
+out gl_PerVertex {
+    vec4 gl_Position;
+};
+
+void main() {
+	outUv = inUv;
+
+	gl_Position = vec4(inPos.xy, 0.0, 1.0);
+}
\ No newline at end of file
diff --git a/bin/data/shaders/display/rendertarget.frag.glsl b/bin/data/shaders/display/rendertarget.frag.glsl
new file mode 100644
index 00000000..c46eec2a
--- /dev/null
+++ b/bin/data/shaders/display/rendertarget.frag.glsl
@@ -0,0 +1,75 @@
+#version 450
+#extension GL_EXT_samplerless_texture_functions : require
+
+#define MULTISAMPLING 1
+#define UF_DEFERRED_SAMPLING 0
+#define UF_CAN_DISCARD 1
+
+#if !MULTISAMPLING
+	layout (binding = 1) uniform usampler2D textureId;
+	layout (binding = 2) uniform sampler2D textureNormals;
+	#if UF_DEFERRED_SAMPLING
+		layout (binding = 3) uniform sampler2D textureUvs;
+	#else
+		layout (binding = 3) uniform sampler2D textureAlbedo;
+	#endif
+#else
+	layout (binding = 1) uniform usampler2DMS textureId;
+	layout (binding = 2) uniform sampler2DMS textureNormals;
+	#if UF_DEFERRED_SAMPLING
+		layout (binding = 3) uniform sampler2DMS textureUvs;
+	#else
+		layout (binding = 3) uniform sampler2DMS textureAlbedo;
+	#endif
+#endif
+
+struct Cursor {
+	vec2 position;
+	vec2 radius;
+	vec4 color;
+};
+
+vec4 resolve( sampler2DMS t, ivec2 uv ) {
+	vec4 resolved = vec4(0);
+	int samples = textureSamples(t);
+	for ( int i = 0; i < samples; ++i ) {
+		resolved += texelFetch(t, uv, i);
+	}
+	resolved /= float(samples);
+	return resolved;
+}
+
+layout (location = 0) in vec2 inUv;
+layout (location = 1) in float inAlpha;
+layout (location = 2) in Cursor inCursor;
+
+layout (location = 0) out vec4 outAlbedo;
+void main() {
+#if !MULTISAMPLING
+	ivec2 screenSize = textureSize(textureId, 0);
+#else
+	ivec2 screenSize = textureSize(textureId);
+#endif
+	ivec2 uv = ivec2(inUv * screenSize);
+	if ( inCursor.radius.x <= 0 || inCursor.radius.y <= 0 ) {
+	#if !MULTISAMPLING
+		outAlbedo = texture(textureAlbedo, uv).rgba;
+	#else
+		outAlbedo = resolve( textureAlbedo, uv );
+	#endif
+		return;
+	}
+	float dist = pow(inUv.x - inCursor.position.x, 2) / pow(inCursor.radius.x, 2) + pow(inUv.y - inCursor.position.y, 2) / pow(inCursor.radius.y, 2);
+
+#if !MULTISAMPLING
+	outAlbedo = texture(textureAlbedo, inUv);
+#else
+	outAlbedo = resolve( textureAlbedo, uv );
+#endif
+
+	if ( dist <= 1 ) {
+		float attenuation = dist;
+		outAlbedo.rgb = mix( inCursor.color.rgb * inCursor.color.a, outAlbedo.rgb, attenuation );
+	}
+	if ( inAlpha < 1.0 ) outAlbedo.a = inAlpha;
+}
\ No newline at end of file
diff --git a/bin/data/shaders/display/rendertarget.vert.glsl b/bin/data/shaders/display/rendertarget.vert.glsl
new file mode 100644
index 00000000..c90a0fb3
--- /dev/null
+++ b/bin/data/shaders/display/rendertarget.vert.glsl
@@ -0,0 +1,41 @@
+#version 450
+
+layout (location = 0) in vec2 inPos;
+layout (location = 1) in vec2 inUv;
+
+struct Cursor {
+	vec2 position;
+	vec2 radius;
+	vec4 color;
+};
+
+layout (location = 0) out vec2 outUv;
+layout (location = 1) out float outAlpha;
+layout (location = 2) out flat Cursor outCursor;
+
+layout( push_constant ) uniform PushBlock {
+  uint pass;
+  uint draw;
+} PushConstant;
+
+out gl_PerVertex {
+    vec4 gl_Position;
+};
+
+struct Matrices {
+	mat4 model[2];
+};
+layout (binding = 0) uniform UBO {
+	Matrices matrices;
+	Cursor cursor;
+//	float alpha;
+//	float padding;
+} ubo;
+
+void main() {
+	outUv = inUv;
+	outCursor = ubo.cursor;
+	outAlpha = 1;
+
+	gl_Position = ubo.matrices.model[PushConstant.pass] * vec4(inPos.xy, 0.0, 1.0);
+}
\ No newline at end of file
diff --git a/bin/data/shaders/display/subpass.frag.glsl b/bin/data/shaders/display/subpass.frag.glsl
new file mode 100644
index 00000000..65c864c8
--- /dev/null
+++ b/bin/data/shaders/display/subpass.frag.glsl
@@ -0,0 +1,741 @@
+#version 450
+#extension GL_EXT_samplerless_texture_functions : require
+
+#define MULTISAMPLING 1
+#define RAY_MARCH_FOG 1
+#define UF_DEFERRED_SAMPLING 0
+
+layout (constant_id = 0) const uint TEXTURES = 256;
+
+struct Matrices {
+	mat4 view[2];
+	mat4 projection[2];
+	mat4 iView[2];
+	mat4 iProjection[2];
+	mat4 iProjectionView[2];
+};
+
+struct Space {
+	vec3 eye;
+	vec3 world;
+} position, normal, view;
+
+struct Fog {
+	vec3 color;
+	float stepScale;
+
+	vec3 offset;
+	float densityScale;
+
+	float densityThreshold;
+	float densityMultiplier;
+	float absorbtion;
+	float padding1;
+
+	vec2 range;
+	float padding2;
+	float padding3;
+};
+
+struct Mode {
+	uint type;
+	uint scalar;
+	vec2 padding;
+	vec4 parameters;
+};
+
+struct Light {
+	vec3 position;
+	float radius;
+	
+	vec3 color;
+	float power;
+	
+	int type;
+	int mapIndex;
+	float depthBias;
+	float padding;
+
+	mat4 view;
+	mat4 projection;
+};
+
+struct Material {
+	vec4 colorBase;
+	vec4 colorEmissive;
+
+	float factorMetallic;
+	float factorRoughness;
+	float factorOcclusion;
+	float factorAlphaCutoff;
+
+	int indexAlbedo;
+	int indexNormal;
+	int indexEmissive;
+	int indexOcclusion;
+	
+	int indexMetallicRoughness;
+	int modeAlpha;
+	int padding1;
+	int padding2;
+};
+struct Texture {
+	int index;
+	int samp;
+	int remap;
+	float blend;
+
+	vec4 lerp;
+};
+struct DrawCall {
+	int materialIndex;
+	uint materials;
+	int textureIndex;
+	uint textures;
+};
+
+#if !MULTISAMPLING
+	layout (input_attachment_index = 0, binding = 0) uniform usubpassInput samplerId;
+	layout (input_attachment_index = 1, binding = 1) uniform subpassInput samplerNormal;
+	#if UF_DEFERRED_SAMPLING
+		layout (input_attachment_index = 2, binding = 2) uniform subpassInput samplerUv;
+	#else
+		layout (input_attachment_index = 2, binding = 2) uniform subpassInput samplerAlbedo;
+	#endif
+	layout (input_attachment_index = 3, binding = 3) uniform subpassInput samplerDepth;
+#else
+	layout (input_attachment_index = 0, binding = 0) uniform usubpassInputMS samplerId;
+	layout (input_attachment_index = 1, binding = 1) uniform subpassInputMS samplerNormal;
+	#if UF_DEFERRED_SAMPLING
+		layout (input_attachment_index = 2, binding = 2) uniform subpassInputMS samplerUv;
+	#else
+		layout (input_attachment_index = 2, binding = 2) uniform subpassInputMS samplerAlbedo;
+	#endif
+	layout (input_attachment_index = 3, binding = 3) uniform subpassInputMS samplerDepth;
+#endif
+layout (binding = 4) uniform sampler3D samplerNoise;
+layout (binding = 5) uniform samplerCube samplerSkybox;
+layout (binding = 6) uniform sampler2D samplerTextures[TEXTURES];
+
+layout (binding = 7) uniform UBO {
+	Matrices matrices;
+	
+	Mode mode;
+	Fog fog;
+
+	uint lights;
+	uint materials;
+	uint textures;
+	uint drawCalls;
+	
+	vec3 ambient;
+	float kexp;
+
+	uint msaa;
+	uint poissonSamples;
+	uint padding1;
+	uint padding2;
+} ubo;
+
+layout (std140, binding = 8) readonly buffer Lights {
+	Light lights[];
+};
+layout (std140, binding = 9) readonly buffer Materials {
+	Material materials[];
+};
+layout (std140, binding = 10) readonly buffer Textures {
+	Texture textures[];
+};
+layout (std140, binding = 11) readonly buffer DrawCalls {
+	DrawCall drawCalls[];
+};
+
+
+layout (location = 0) in vec2 inUv;
+layout (location = 1) in flat uint inPushConstantPass;
+
+layout (location = 0) out vec4 outFragColor;
+
+vec2 poissonDisk[16] = vec2[]( 
+   vec2( -0.94201624, -0.39906216 ), 
+   vec2( 0.94558609, -0.76890725 ), 
+   vec2( -0.094184101, -0.92938870 ), 
+   vec2( 0.34495938, 0.29387760 ), 
+   vec2( -0.91588581, 0.45771432 ), 
+   vec2( -0.81544232, -0.87912464 ), 
+   vec2( -0.38277543, 0.27676845 ), 
+   vec2( 0.97484398, 0.75648379 ), 
+   vec2( 0.44323325, -0.97511554 ), 
+   vec2( 0.53742981, -0.47373420 ), 
+   vec2( -0.26496911, -0.41893023 ), 
+   vec2( 0.79197514, 0.19090188 ), 
+   vec2( -0.24188840, 0.99706507 ), 
+   vec2( -0.81409955, 0.91437590 ), 
+   vec2( 0.19984126, 0.78641367 ), 
+   vec2( 0.14383161, -0.14100790 ) 
+);
+
+void phong( Light light, vec4 albedoSpecular, inout vec3 i ) {
+	vec3 Ls = vec3(1.0, 1.0, 1.0); 		// light specular
+	vec3 Ld = light.color; 				// light color
+	vec3 La = vec3(1.0, 1.0, 1.0);
+
+	vec3 Ks = vec3(albedoSpecular.a); 	// material specular
+	vec3 Kd = albedoSpecular.rgb;		// material diffuse
+	vec3 Ka = vec3(1.0, 1.0, 1.0); 
+
+	float Kexp = ubo.kexp;
+
+	vec3 V = position.eye;
+	vec3 N = normal.eye;
+	vec3 L = light.position.xyz - V;
+	float dist = length(L);
+//	if ( light.radius > 0.001 && light.radius < dist ) return;
+
+	vec3 D = normalize(L);
+	float d_dot = max(dot( D, N ), 0.0);
+
+	vec3 R = reflect( -D, N );
+	vec3 S = normalize(-V);
+	float s_factor = pow( max(dot( R, S ), 0.0), Kexp );
+	if ( Kexp < 0.0001 ) s_factor = 0;
+	
+	float radiance = light.power / (dist * dist);
+
+	vec3 Ia = La * Ka;
+	vec3 Id = Ld * Kd * d_dot * radiance;
+	vec3 Is = Ls * Ks * s_factor * radiance;
+	
+	i += Id + Is;
+}
+
+const float PI = 3.14159265359;
+float DistributionGGX(vec3 N, vec3 H, float roughness) {
+    float a      = roughness*roughness;
+    float a2     = a*a;
+    float NdotH  = max(dot(N, H), 0.0);
+    float NdotH2 = NdotH*NdotH;
+	
+    float num   = a2;
+    float denom = (NdotH2 * (a2 - 1.0) + 1.0);
+    denom = PI * denom * denom;
+	
+    return num / denom;
+}
+
+float GeometrySchlickGGX(float NdotV, float roughness) {
+    float r = (roughness + 1.0);
+    float k = (r*r) / 8.0;
+
+    float num   = NdotV;
+    float denom = NdotV * (1.0 - k) + k;
+	
+    return num / denom;
+}
+float GeometrySmith(vec3 N, vec3 V, vec3 L, float roughness) {
+    float NdotV = max(dot(N, V), 0.0);
+    float NdotL = max(dot(N, L), 0.0);
+    float ggx2  = GeometrySchlickGGX(NdotV, roughness);
+    float ggx1  = GeometrySchlickGGX(NdotL, roughness);
+	
+    return ggx1 * ggx2;
+}
+vec3 fresnelSchlick(float cosTheta, vec3 F0) {
+	return F0 + (1.0 - F0) * pow(1.0 - cosTheta, 5.0);
+}
+
+float random(vec3 seed, int i){
+	vec4 seed4 = vec4(seed,i);
+	float dot_product = dot(seed4, vec4(12.9898,78.233,45.164,94.673));
+	return fract(sin(dot_product) * 43758.5453);
+}
+
+float shadowFactor( Light light, uint shadowMap ) {
+	vec4 positionClip = light.projection * light.view * vec4(position.world, 1.0);
+	positionClip.xyz /= positionClip.w;
+
+	if ( positionClip.x < -1 || positionClip.x >= 1 ) return 0.0;
+	if ( positionClip.y < -1 || positionClip.y >= 1 ) return 0.0;
+	if ( positionClip.z <= 0 || positionClip.z >= 1 ) return 0.0;
+
+	float factor = 1.0;
+
+	// spot light
+	if ( light.type == 2 || light.type == 3 ) {
+		float dist = length( positionClip.xy );
+		if ( dist > 0.5 ) return 0.0;
+		
+		// spot light with attenuation
+		if ( light.type == 3 ) {
+			factor = 1.0 - (pow(dist * 2,2.0));
+		}
+	}
+	
+	vec2 uv = positionClip.xy * 0.5 + 0.5;
+	float bias = light.depthBias;
+/*
+	if ( true ) {
+		float cosTheta = clamp(dot(normal.eye, normalize(light.position.xyz - position.eye)), 0, 1);
+		bias = clamp(bias * tan(acos(cosTheta)), 0, 0.01);
+	} else if ( true ) {
+		bias = max(bias * 10 * (1.0 - dot(normal.eye, normalize(light.position.xyz - position.eye))), bias);
+	}
+*/
+
+	float eyeDepth = positionClip.z;
+
+	int samples = int(ubo.poissonSamples);
+	if ( samples <= 1 ) {
+		return eyeDepth < texture(samplerTextures[shadowMap], uv).r - bias ? 0.0 : factor;
+	}
+	for ( int i = 0; i < samples; ++i ) {
+	//	int index = i;
+	//	int index = int( float(samples) * random(gl_FragCoord.xyy, i) ) % samples;
+		int index = int( float(samples) * random(floor(position.world.xyz * 1000.0), i)) % samples;
+		float lightDepth = texture(samplerTextures[shadowMap], uv + poissonDisk[index] / 700.0 ).r;
+		if ( eyeDepth < lightDepth - bias ) factor -= 1.0 / samples;
+	}
+	return factor;
+}
+vec3 hslToRgb(vec3 HSL) {
+	vec3 RGB; {
+		float H = HSL.x;
+		float R = abs(H * 6 - 3) - 1;
+		float G = 2 - abs(H * 6 - 2);
+		float B = 2 - abs(H * 6 - 4);
+		RGB = clamp(vec3(R,G,B), 0, 1);
+	}
+	float C = (1 - abs(2 * HSL.z - 1)) * HSL.y;
+	return (RGB - 0.5) * C + HSL.z;
+}
+vec3 rgbToHsl(vec3 RGB) {
+	float Epsilon = 1e-10;
+	vec3 HCV; {
+		vec4 P = (RGB.g < RGB.b) ? vec4(RGB.bg, -1.0, 2.0/3.0) : vec4(RGB.gb, 0.0, -1.0/3.0);
+		vec4 Q = (RGB.r < P.x) ? vec4(P.xyw, RGB.r) : vec4(RGB.r, P.yzx);
+		float C = Q.x - min(Q.w, Q.y);
+		float H = abs((Q.w - Q.y) / (6 * C + Epsilon) + Q.z);
+		HCV = vec3(H, C, Q.x);
+	}
+	float L = HCV.z - HCV.y * 0.5;
+	float S = HCV.y / (1 - abs(L * 2 - 1) + Epsilon);
+	return vec3(HCV.x, S, L);
+}
+
+float hueDistance(float h1, float h2) {
+	float diff = abs((h1 - h2));
+	return min(abs((1.0 - diff)), diff);
+}
+const float lightnessSteps = 4.0;
+float lightnessStep(float l) {
+    return floor((0.5 + l * lightnessSteps)) / lightnessSteps;
+}
+const int indexMatrix16x16[256] = int[](0,192, 48,240, 12,204, 60,252,  3,195, 51,243, 15,207, 63,255,
+									 128, 64,176,112,140, 76,188,124,131, 67,179,115,143, 79,191,127,
+									  32,224, 16,208, 44,236, 28,220, 35,227, 19,211, 47,239, 31,223,
+									 160, 96,144, 80,172,108,156, 92,163, 99,147, 83,175,111,159, 95,
+									   8,200, 56,248,  4,196, 52,244, 11,203, 59,251,  7,199, 55,247,
+									 136, 72,184,120,132, 68,180,116,139, 75,187,123,135, 71,183,119,
+									  40,232, 24,216, 36,228, 20,212, 43,235, 27,219, 39,231, 23,215,
+									 168,104,152, 88,164,100,148, 84,171,107,155, 91,167,103,151, 87,
+									   2,194, 50,242, 14,206, 62,254,  1,193, 49,241, 13,205, 61,253,
+									 130, 66,178,114,142, 78,190,126,129, 65,177,113,141, 77,189,125,
+									  34,226, 18,210, 46,238, 30,222, 33,225, 17,209, 45,237, 29,221,
+									 162, 98,146, 82,174,110,158, 94,161, 97,145, 81,173,109,157, 93,
+									  10,202, 58,250,  6,198, 54,246,  9,201, 57,249,  5,197, 53,245,
+									 138, 74,186,122,134, 70,182,118,137, 73,185,121,133, 69,181,117,
+									  42,234, 26,218, 38,230, 22,214, 41,233, 25,217, 37,229, 21,213,
+									 170,106,154, 90,166,102,150, 86,169,105,153, 89,165,101,149, 85);
+float indexValue16x16( float scale ) {
+	int x = int(mod(gl_FragCoord.x * scale, 16));
+	int y = int(mod(gl_FragCoord.y * scale, 16));
+	return indexMatrix16x16[(x + y * 16)] / 256.0;
+}
+const int indexMatrix8x8[64] = int[](0,  32, 8,  40, 2,  34, 10, 42,
+									 48, 16, 56, 24, 50, 18, 58, 26,
+									 12, 44, 4,  36, 14, 46, 6,  38,
+									 60, 28, 52, 20, 62, 30, 54, 22,
+									 3,  35, 11, 43, 1,  33, 9,  41,
+									 51, 19, 59, 27, 49, 17, 57, 25,
+									 15, 47, 7,  39, 13, 45, 5,  37,
+									 63, 31, 55, 23, 61, 29, 53, 21);
+float indexValue8x8( float scale ) {
+	int x = int(mod(gl_FragCoord.x * scale, 8));
+	int y = int(mod(gl_FragCoord.y * scale, 8));
+	return indexMatrix8x8[(x + y * 8)] / 64.0;
+}
+const int indexMatrix4x4[16] = int[](0,  8,  2,  10,
+									 12, 4,  14, 6,
+									 3,  11, 1,  9,
+									 15, 7,  13, 5);
+float indexValue4x4( float scale ) {
+	int x = int(mod(gl_FragCoord.x * scale, 4));
+	int y = int(mod(gl_FragCoord.y * scale, 4));
+	return indexMatrix4x4[(x + y * 4)] / 16.0;
+}
+vec3[2] closestColors(float hue) {
+	vec3 ret[2];
+	vec3 closest = vec3(-2, 0, 0);
+	vec3 secondClosest = vec3(-2, 0, 0);
+	vec3 temp;
+/*
+	for (int i = 0; i < palette.length(); ++i) {
+		temp = rgbToHsl(palette[i].rgb);
+		float tempDistance = hueDistance(temp.x, hue);
+		if (tempDistance < hueDistance(closest.x, hue)) {
+			secondClosest = closest;
+			closest = temp;
+		} else {
+			if (tempDistance < hueDistance(secondClosest.x, hue)) {
+				secondClosest = temp;
+			}
+		}
+	}
+*/
+	ret[0] = closest;
+	ret[1] = secondClosest;
+	return ret;
+}
+float dither(float color) {
+	float closestColor = (color < 0.5) ? 0 : 1;
+	float secondClosestColor = 1 - closestColor;
+	float d = 1; // -0.5 - fract(ubo.mode.parameters.w / 8.0);
+	if ( ubo.mode.scalar == 16 ) {
+	 	d = indexValue16x16(1);
+	} else if ( ubo.mode.scalar == 8 ) {
+	 	d = indexValue8x8(1);
+	} else if ( ubo.mode.scalar == 4 ) {
+	 	d = indexValue4x4(1);
+	}
+	float distance = abs(closestColor - color);
+	return (distance < d) ? closestColor : secondClosestColor;
+}
+void dither(inout vec3 color) { 
+	vec3 hsl = rgbToHsl(color);
+	hsl.x = dither(hsl.x);
+	color = hslToRgb(hsl);
+}
+void dither1(inout vec3 color) { 
+	vec3 hsl = rgbToHsl(color);
+
+	float d = 0;
+	vec3 cs[2] = { hsl, hsl }; // closestColors(hsl.x);
+	float scale = 1;
+	if ( ubo.mode.scalar == 16 ) {
+	 	d = indexValue16x16(scale);
+	} else if ( ubo.mode.scalar == 8 ) {
+	 	d = indexValue8x8(scale);
+	} else if ( ubo.mode.scalar == 4 ) {
+	 	d = indexValue4x4(scale);
+	}
+    float hueDiff = hueDistance(hsl.x, cs[0].x) / hueDistance(cs[1].x, cs[0].x);
+    float l1 = lightnessStep(max((hsl.z - 0.125), 0.0));
+    float l2 = lightnessStep(min((hsl.z + 0.124), 1.0));
+    float lightnessDiff = (hsl.z - l1) / (l2 - l1);
+
+    vec3 resultColor = (hueDiff < d) ? cs[0] : cs[1];
+    resultColor.z = (lightnessDiff < d) ? l1 : l2;
+    color = hslToRgb(resultColor);
+}
+vec3 dither2() {
+	vec3 vDither = dot( vec2( 171.0, 231.0 ), inUv.xy + ubo.mode.parameters.w ).xxx;
+	vDither.rgb = fract( vDither.rgb / vec3( 103.0, 71.0, 97.0 ) ) - vec3( 0.5, 0.5, 0.5 );
+	return ( vDither.rgb / 255.0 ) * 0.375;
+}
+
+float rand2(vec2 co){
+    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 143758.5453);
+}
+float rand3(vec3 co){
+    return fract(sin(dot(co.xyz ,vec3(12.9898,78.233, 37.719))) * 143758.5453);
+}
+void whitenoise(inout vec3 color) {
+	float flicker = ubo.mode.parameters.x;
+	float pieces = ubo.mode.parameters.y;
+	float blend = ubo.mode.parameters.z;
+	float time = ubo.mode.parameters.w;
+	if ( blend < 0.0001 ) return;
+	float freq = sin(pow(mod(time, flicker) + flicker, 1.9));
+//	float whiteNoise = rand3( floor(position.world / pieces) + floor(time * 2) );
+	float whiteNoise = rand2( floor(gl_FragCoord.xy / pieces) + mod(time, freq) );
+	color = mix( color, vec3(whiteNoise), blend );
+}
+
+void pbr( Light light, vec3 albedo, float metallic, float roughness, vec3 lightPositionWorld, inout vec3 i ) {
+	vec3 F0 = vec3(0.04); 
+    F0 = mix(F0, albedo, metallic); 
+
+	vec3 N = normalize(normal.eye);
+	vec3 L = light.position.xyz - position.eye;
+	float dist = length(L);
+
+	L = normalize(L);
+	vec3 V = normalize(-position.eye);
+	vec3 H = normalize(V + L);
+
+	float NdotL = max(dot(N, L), 0.0);
+	float NdotV = max(dot(N, V), 0.0);
+	float attenuation = light.power / (dist * dist);
+	vec3 radiance = light.color.rgb * attenuation;
+
+	// cook-torrance brdf
+	float NDF = DistributionGGX(N, H, roughness);        
+	float G   = GeometrySmith(N, V, L, roughness);      
+	vec3 F    = fresnelSchlick(max(dot(H, V), 0.0), F0);       
+
+	vec3 kD = vec3(1.0) - F;
+	kD *= 1.0 - metallic;
+
+	vec3 numerator    = NDF * G * F;
+	float denominator = 4.0 * NdotV * NdotL;
+	vec3 specular     = numerator / max(denominator, 0.001);  
+
+	// add to outgoing radiance Lo
+	i += (kD * albedo / PI + specular) * radiance * NdotL;
+}
+
+vec2 rayBoxDst( vec3 boundsMin, vec3 boundsMax, vec3 rayO, vec3 rayD ) {
+	vec3 t0 = (boundsMin - rayO) / rayD;
+	vec3 t1 = (boundsMax - rayO) / rayD;
+	vec3 tmin = min(t0, t1);
+	vec3 tmax = max(t0, t1);
+	float dstA = max( max(tmin.x, tmin.y), tmin.z );
+	float dstB = min( tmax.x, min(tmax.y, tmax.z) );
+	float dstToBox = max(0, dstA);
+	float dstInsideBox = max(0, dstB - dstToBox);
+	return vec2(dstToBox, dstInsideBox);
+}
+
+float sampleDensity( vec3 position ) {
+	vec3 uvw = position * ubo.fog.densityScale * 0.001 + ubo.fog.offset * 0.01;
+	return max(0, texture(samplerNoise, uvw).r - ubo.fog.densityThreshold) * ubo.fog.densityMultiplier;
+}
+
+void fog( vec3 rayO, vec3 rayD, inout vec3 i, float scale ) {
+	if ( ubo.fog.stepScale <= 0 ) return;
+	if ( ubo.fog.range.x == 0 || ubo.fog.range.y == 0 ) return;
+
+#if RAY_MARCH_FOG
+	float range = ubo.fog.range.y;
+	vec3 boundsMin = vec3(-range,-range,-range) + rayO;
+	vec3 boundsMax = vec3(range,range,range) + rayO;
+	int numSteps = int(length(boundsMax - boundsMin) * ubo.fog.stepScale );
+
+	vec2 rayBoxInfo = rayBoxDst( boundsMin, boundsMax, rayO, rayD );
+	float dstToBox = rayBoxInfo.x;
+	float dstInsideBox = rayBoxInfo.y;
+	float depth = position.eye.z;
+
+	float lightEnergy = 0;
+	// march
+	if ( 0 <= dstInsideBox && dstToBox <= depth ) {
+		float dstTravelled = 0;
+		float stepSize = dstInsideBox / numSteps;
+		float dstLimit = min( depth - dstToBox, dstInsideBox );
+		float totalDensity = 0;
+		float transmittance = 1;
+		while ( dstTravelled < dstLimit ) {
+			vec3 rayPos = rayO + rayD * (dstToBox + dstTravelled);
+			float density = sampleDensity(rayPos);
+			if ( density > 0 ) {
+				transmittance *= exp(-density * stepSize * ubo.fog.absorbtion);
+				if ( transmittance < 0.01 ) break;
+			}
+			dstTravelled += stepSize;
+		}
+		i.rgb = mix(ubo.fog.color.rgb, i.rgb, transmittance);
+	}
+#endif
+
+	vec3 color = ubo.fog.color.rgb;
+	float inner = ubo.fog.range.x;
+	float outer = ubo.fog.range.y * scale;
+	float distance = length(-position.eye);
+	float factor = (distance - inner) / (outer - inner);
+	factor = clamp( factor, 0.0, 1.0 );
+
+	i.rgb = mix(i.rgb, color, factor);
+}
+
+vec3 decodeNormals( vec2 enc ) {
+	vec2 fenc = enc*4-2;
+	float f = dot(fenc,fenc);
+	float g = sqrt(1-f/4);
+	vec3 n;
+	n.xy = fenc*g;
+	n.z = 1-f/2;
+	return normalize(n);
+}
+float wrap( float i ) {
+	return fract(i);
+}
+vec2 wrap( vec2 uv ) {
+	return vec2( wrap( uv.x ), wrap( uv.y ) );
+}
+float mipLevel( in vec2 uv ) {
+	vec2 dx_vtc = dFdx(uv);
+	vec2 dy_vtc = dFdy(uv);
+	return 0.5 * log2(max(dot(dx_vtc, dx_vtc), dot(dy_vtc, dy_vtc)));
+}
+bool validTextureIndex( int textureIndex ) {
+	return 0 <= textureIndex && textureIndex < ubo.textures;
+}
+vec4 sampleTexture( uint drawId, int textureIndex, in vec2 uv, vec4 base ) {
+	if ( !validTextureIndex( textureIndex ) ) return base;
+	Texture t = textures[textureIndex+1];
+	float mip = mipLevel( uv );
+ 	return texture( samplerTextures[drawId], mix( t.lerp.xy, t.lerp.zw, wrap( uv ) ), mip );
+}
+
+vec4 resolve( subpassInputMS t ) {
+	int samples = int(ubo.msaa);
+	vec4 resolved = vec4(0);
+	for ( int i = 0; i < samples; ++i ) {
+		resolved += subpassLoad(t, i);
+	}
+	resolved /= vec4(samples);
+	return resolved;
+}
+uvec4 resolve( usubpassInputMS t ) {
+	int samples = int(ubo.msaa);
+	uvec4 resolved = uvec4(0);
+	for ( int i = 0; i < samples; ++i ) {
+		resolved += subpassLoad(t, i);
+	}
+	resolved /= uvec4(samples);
+	return resolved;
+}
+
+void main() {
+	vec3 rayO = vec3(0);
+	vec3 rayD = vec3(0);
+	vec3 fragColor = vec3(0);
+
+	{
+	#if !MULTISAMPLING
+		float depth = subpassLoad(samplerDepth).r;
+	#else
+		float depth = resolve( samplerDepth ).r;
+	#endif
+
+		vec4 positionClip = vec4(inUv * 2.0 - 1.0, depth, 1.0);
+		vec4 positionEye = ubo.matrices.iProjection[inPushConstantPass] * positionClip;
+		positionEye /= positionEye.w;
+		position.eye = positionEye.xyz;
+
+		vec4 positionWorld = ubo.matrices.iView[inPushConstantPass] * positionEye;
+		position.world = positionWorld.xyz;
+	}
+	{
+		vec4 near4 = ubo.matrices.iProjectionView[inPushConstantPass] * (vec4(2.0 * inUv - 1.0, -1.0, 1.0));
+		vec4 far4 = ubo.matrices.iProjectionView[inPushConstantPass] * (vec4(2.0 * inUv - 1.0, 1.0, 1.0));
+		vec3 near3 = near4.xyz / near4.w;
+		vec3 far3 = far4.xyz / far4.w;
+
+		rayO = near3;
+	}
+	{
+		mat4 iProjectionView = inverse( ubo.matrices.projection[inPushConstantPass] * mat4(mat3(ubo.matrices.view[inPushConstantPass])) );
+		vec4 near4 = iProjectionView * (vec4(2.0 * inUv - 1.0, -1.0, 1.0));
+		vec4 far4 = iProjectionView * (vec4(2.0 * inUv - 1.0, 1.0, 1.0));
+		vec3 near3 = near4.xyz / near4.w;
+		vec3 far3 = far4.xyz / far4.w;
+
+		rayD = normalize( far3 - near3 );
+	}
+#if !MULTISAMPLING
+	normal.eye = decodeNormals( subpassLoad(samplerNormal).xy );
+	uvec2 ID = subpassLoad(samplerId).xy;
+#else
+	normal.eye = decodeNormals( resolve(samplerNormal).xy );
+	uvec2 ID = resolve(samplerId).xy;
+#endif
+	uint drawId = ID.x;
+	uint materialId = ID.y;
+	if ( drawId == 0 || materialId == 0 ) {
+		fragColor.rgb = texture( samplerSkybox, rayD ).rgb;
+		fog(rayO, rayD, fragColor, 0.0);
+		outFragColor = vec4(fragColor,1);
+		return;
+	}
+	--drawId;
+	--materialId;
+
+	DrawCall drawCall = drawCalls[drawId];
+	materialId += drawCall.materialIndex;
+
+	Material material = materials[materialId];
+	vec4 C = material.colorBase;
+
+#if UF_DEFERRED_SAMPLING
+#if !MULTISAMPLING
+	vec2 uv = subpassLoad(samplerUv).xy;
+#else
+	vec2 uv = resolve(samplerUv).xy;
+#endif
+	C = sampleTexture( drawId, drawCall.textureIndex + material.indexAlbedo, uv, C );
+	// OPAQUE
+ 	if ( material.modeAlpha == 0 ) {
+ 		C.a = 1;
+ 	// BLEND
+ 	} else if ( material.modeAlpha == 1 ) {
+ 	
+ 	// MASK
+ 	} else if ( material.modeAlpha == 2 ) {
+
+ 	}
+#else
+#if !MULTISAMPLING
+	C = subpassLoad(samplerAlbedo);
+#else
+	C = resolve(samplerAlbedo);
+#endif
+#endif
+
+	float M = material.factorMetallic;
+	float R = material.factorRoughness * 4.0;
+	float AO = material.factorOcclusion;
+
+	bool usePbr = true;
+	bool gammaCorrect = false;
+	float litFactor = 1.0;
+	fragColor = C.rgb * ubo.ambient.rgb * AO;
+	for ( uint i = 0; i < ubo.lights; ++i ) {
+		Light light = lights[i];
+		
+		if ( light.power <= 0.001 ) continue;
+		
+		vec3 lightPositionWorld = light.position.xyz;
+		light.position.xyz = vec3(ubo.matrices.view[inPushConstantPass] * vec4(light.position.xyz, 1));
+		
+		if ( 0 <= light.mapIndex && light.mapIndex < TEXTURES  ) {
+			float factor = shadowFactor( light, light.mapIndex );
+		//	if ( factor <= 0.0001 ) continue;
+			light.power *= factor;
+			litFactor += light.power;
+		}
+		if ( light.power <= 0.0001 ) continue;
+
+		if ( usePbr ) {
+			pbr( light, C.rgb, M, R, lightPositionWorld, fragColor );
+		} else
+			phong( light, C, fragColor );
+	}
+	if ( gammaCorrect ) {
+		fragColor = fragColor / (fragColor + vec3(1.0));
+ 		fragColor = pow(fragColor, vec3(1.0/2.2));  
+ 	}
+
+	fog(rayO, rayD, fragColor, litFactor);
+
+/*
+	if ( (ubo.mode.type & (0x1 << 0)) == (0x1 << 0) ) {
+		//dither1(fragColor);
+		fragColor += dither2();
+	}
+*/
+	if ( (ubo.mode.type & (0x1 << 1)) == (0x1 << 1) ) {
+		whitenoise(fragColor);
+	}
+	outFragColor = vec4(fragColor,1);
+}
\ No newline at end of file
diff --git a/bin/data/shaders/display/subpass.old.frag.glsl b/bin/data/shaders/display/subpass.old.frag.glsl
new file mode 100644
index 00000000..705a45d0
--- /dev/null
+++ b/bin/data/shaders/display/subpass.old.frag.glsl
@@ -0,0 +1,559 @@
+#version 450
+#extension GL_EXT_samplerless_texture_functions : require
+
+layout (constant_id = 0) const uint LIGHTS = 256;
+
+layout (input_attachment_index = 0, binding = 1) uniform subpassInput samplerAlbedoMetallic;
+layout (input_attachment_index = 0, binding = 2) uniform subpassInput samplerNormalRoughness;
+layout (input_attachment_index = 0, binding = 3) uniform subpassInput samplerDepth;
+
+layout (binding = 5) uniform sampler3D samplerNoise;
+layout (binding = 6) uniform sampler2D samplerShadows[LIGHTS];
+
+layout (location = 0) in vec2 inUv;
+layout (location = 1) in flat uint inPushConstantPass;
+
+layout (location = 0) out vec4 outFragColor;
+
+/*
+const vec2 poissonDisk[4] = vec2[](
+	vec2( -0.94201624, -0.39906216 ),
+	vec2( 0.94558609, -0.76890725 ),
+	vec2( -0.094184101, -0.92938870 ),
+	vec2( 0.34495938, 0.29387760 )
+);
+*/
+vec2 poissonDisk[16] = vec2[]( 
+   vec2( -0.94201624, -0.39906216 ), 
+   vec2( 0.94558609, -0.76890725 ), 
+   vec2( -0.094184101, -0.92938870 ), 
+   vec2( 0.34495938, 0.29387760 ), 
+   vec2( -0.91588581, 0.45771432 ), 
+   vec2( -0.81544232, -0.87912464 ), 
+   vec2( -0.38277543, 0.27676845 ), 
+   vec2( 0.97484398, 0.75648379 ), 
+   vec2( 0.44323325, -0.97511554 ), 
+   vec2( 0.53742981, -0.47373420 ), 
+   vec2( -0.26496911, -0.41893023 ), 
+   vec2( 0.79197514, 0.19090188 ), 
+   vec2( -0.24188840, 0.99706507 ), 
+   vec2( -0.81409955, 0.91437590 ), 
+   vec2( 0.19984126, 0.78641367 ), 
+   vec2( 0.14383161, -0.14100790 ) 
+);
+
+struct Light {
+	vec3 position;
+	float radius;
+	
+	vec3 color;
+	float power;
+	
+	int type;
+	float depthBias;
+	float padding1;
+	float padding2;
+
+	mat4 view;
+	mat4 projection;
+};
+
+struct Matrices {
+	mat4 view[2];
+	mat4 projection[2];
+};
+
+struct Space {
+	vec3 eye;
+	vec3 world;
+} position, normal, view;
+
+struct Fog {
+	vec3 color;
+	float stepScale;
+
+	vec3 offset;
+	float densityScale;
+
+	float densityThreshold;
+	float densityMultiplier;
+	float absorbtion;
+	float padding1;
+
+	vec2 range;
+	float padding2;
+	float padding3;
+};
+
+struct Mode {
+	uint type;
+	uint scalar;
+	vec2 padding;
+	vec4 parameters;
+};
+
+layout (binding = 0) uniform UBO {
+	Matrices matrices;
+	vec3 ambient;
+	float kexp;
+	Mode mode;
+	Fog fog;
+	Light lights[LIGHTS];
+} ubo;
+
+void phong( Light light, vec4 albedoSpecular, inout vec3 i ) {
+	vec3 Ls = vec3(1.0, 1.0, 1.0); 		// light specular
+	vec3 Ld = light.color; 				// light color
+	vec3 La = vec3(1.0, 1.0, 1.0);
+
+	vec3 Ks = vec3(albedoSpecular.a); 	// material specular
+	vec3 Kd = albedoSpecular.rgb;		// material diffuse
+	vec3 Ka = vec3(1.0, 1.0, 1.0); 
+
+	float Kexp = ubo.kexp;
+
+	vec3 V = position.eye;
+	vec3 N = normal.eye;
+	vec3 L = light.position.xyz - V;
+	float dist = length(L);
+//	if ( light.radius > 0.001 && light.radius < dist ) return;
+
+	vec3 D = normalize(L);
+	float d_dot = max(dot( D, N ), 0.0);
+
+	vec3 R = reflect( -D, N );
+	vec3 S = normalize(-V);
+	float s_factor = pow( max(dot( R, S ), 0.0), Kexp );
+	if ( Kexp < 0.0001 ) s_factor = 0;
+	
+	float radiance = light.power / (dist * dist);
+
+	vec3 Ia = La * Ka;
+	vec3 Id = Ld * Kd * d_dot * radiance;
+	vec3 Is = Ls * Ks * s_factor * radiance;
+	
+	i += Id + Is;
+}
+
+const float PI = 3.14159265359;
+float DistributionGGX(vec3 N, vec3 H, float roughness) {
+    float a      = roughness*roughness;
+    float a2     = a*a;
+    float NdotH  = max(dot(N, H), 0.0);
+    float NdotH2 = NdotH*NdotH;
+	
+    float num   = a2;
+    float denom = (NdotH2 * (a2 - 1.0) + 1.0);
+    denom = PI * denom * denom;
+	
+    return num / denom;
+}
+
+float GeometrySchlickGGX(float NdotV, float roughness) {
+    float r = (roughness + 1.0);
+    float k = (r*r) / 8.0;
+
+    float num   = NdotV;
+    float denom = NdotV * (1.0 - k) + k;
+	
+    return num / denom;
+}
+float GeometrySmith(vec3 N, vec3 V, vec3 L, float roughness) {
+    float NdotV = max(dot(N, V), 0.0);
+    float NdotL = max(dot(N, L), 0.0);
+    float ggx2  = GeometrySchlickGGX(NdotV, roughness);
+    float ggx1  = GeometrySchlickGGX(NdotL, roughness);
+	
+    return ggx1 * ggx2;
+}
+vec3 fresnelSchlick(float cosTheta, vec3 F0) {
+	return F0 + (1.0 - F0) * pow(1.0 - cosTheta, 5.0);
+}
+
+float random(vec3 seed, int i){
+	vec4 seed4 = vec4(seed,i);
+	float dot_product = dot(seed4, vec4(12.9898,78.233,45.164,94.673));
+	return fract(sin(dot_product) * 43758.5453);
+}
+
+float shadowFactor( Light light, uint shadowMap ) {
+	vec4 positionClip = light.projection * light.view * vec4(position.world, 1.0);
+	positionClip.xyz /= positionClip.w;
+
+	if ( positionClip.x < -1 || positionClip.x >= 1 ) return 0.0;
+	if ( positionClip.y < -1 || positionClip.y >= 1 ) return 0.0;
+	if ( positionClip.z <= 0 || positionClip.z >= 1 ) return 0.0;
+
+	float factor = 1.0;
+
+	// spot light
+	if ( light.type == -2 || light.type == -3 ) {
+		float dist = length( positionClip.xy );
+		if ( dist > 0.5 ) return 0.0;
+		
+		// spot light with attenuation
+		if ( light.type == -3 ) {
+			factor = 1.0 - (pow(dist * 2,2.0));
+		}
+	}
+	
+	vec2 uv = positionClip.xy * 0.5 + 0.5;
+	float bias = light.depthBias;
+	if ( !true ) {
+		float cosTheta = clamp(dot(normal.eye, normalize(light.position.xyz - position.eye)), 0, 1);
+		bias = clamp(bias * tan(acos(cosTheta)), 0, 0.01);
+	} else if ( true ) {
+        bias = max(bias * 10 * (1.0 - dot(normal.eye, normalize(light.position.xyz - position.eye))), bias);
+    }
+
+	float eyeDepth = positionClip.z;
+	int samples = poissonDisk.length();
+	if ( samples <= 1 ) {
+		return eyeDepth < texture(samplerShadows[shadowMap], uv).r - bias ? 0.0 : factor;
+	}
+	for ( int i = 0; i < samples; ++i ) {
+	//	int index = i;
+	//	int index = int( float(samples) * random(gl_FragCoord.xyy, i) ) % samples;
+		int index = int( float(samples) * random(floor(position.world.xyz * 1000.0), i)) % samples;
+		float lightDepth = texture(samplerShadows[shadowMap], uv + poissonDisk[index] / 700.0 ).r;
+		if ( eyeDepth < lightDepth - bias ) factor -= 1.0 / samples;
+	}
+	return factor;
+}
+vec3 hslToRgb(vec3 HSL) {
+	vec3 RGB; {
+		float H = HSL.x;
+		float R = abs(H * 6 - 3) - 1;
+		float G = 2 - abs(H * 6 - 2);
+		float B = 2 - abs(H * 6 - 4);
+		RGB = clamp(vec3(R,G,B), 0, 1);
+	}
+	float C = (1 - abs(2 * HSL.z - 1)) * HSL.y;
+	return (RGB - 0.5) * C + HSL.z;
+}
+vec3 rgbToHsl(vec3 RGB) {
+	float Epsilon = 1e-10;
+	vec3 HCV; {
+		vec4 P = (RGB.g < RGB.b) ? vec4(RGB.bg, -1.0, 2.0/3.0) : vec4(RGB.gb, 0.0, -1.0/3.0);
+		vec4 Q = (RGB.r < P.x) ? vec4(P.xyw, RGB.r) : vec4(RGB.r, P.yzx);
+		float C = Q.x - min(Q.w, Q.y);
+		float H = abs((Q.w - Q.y) / (6 * C + Epsilon) + Q.z);
+		HCV = vec3(H, C, Q.x);
+	}
+	float L = HCV.z - HCV.y * 0.5;
+	float S = HCV.y / (1 - abs(L * 2 - 1) + Epsilon);
+	return vec3(HCV.x, S, L);
+}
+
+float hueDistance(float h1, float h2) {
+	float diff = abs((h1 - h2));
+	return min(abs((1.0 - diff)), diff);
+}
+const float lightnessSteps = 4.0;
+float lightnessStep(float l) {
+    return floor((0.5 + l * lightnessSteps)) / lightnessSteps;
+}
+const int indexMatrix16x16[256] = int[](0,192, 48,240, 12,204, 60,252,  3,195, 51,243, 15,207, 63,255,
+									 128, 64,176,112,140, 76,188,124,131, 67,179,115,143, 79,191,127,
+									  32,224, 16,208, 44,236, 28,220, 35,227, 19,211, 47,239, 31,223,
+									 160, 96,144, 80,172,108,156, 92,163, 99,147, 83,175,111,159, 95,
+									   8,200, 56,248,  4,196, 52,244, 11,203, 59,251,  7,199, 55,247,
+									 136, 72,184,120,132, 68,180,116,139, 75,187,123,135, 71,183,119,
+									  40,232, 24,216, 36,228, 20,212, 43,235, 27,219, 39,231, 23,215,
+									 168,104,152, 88,164,100,148, 84,171,107,155, 91,167,103,151, 87,
+									   2,194, 50,242, 14,206, 62,254,  1,193, 49,241, 13,205, 61,253,
+									 130, 66,178,114,142, 78,190,126,129, 65,177,113,141, 77,189,125,
+									  34,226, 18,210, 46,238, 30,222, 33,225, 17,209, 45,237, 29,221,
+									 162, 98,146, 82,174,110,158, 94,161, 97,145, 81,173,109,157, 93,
+									  10,202, 58,250,  6,198, 54,246,  9,201, 57,249,  5,197, 53,245,
+									 138, 74,186,122,134, 70,182,118,137, 73,185,121,133, 69,181,117,
+									  42,234, 26,218, 38,230, 22,214, 41,233, 25,217, 37,229, 21,213,
+									 170,106,154, 90,166,102,150, 86,169,105,153, 89,165,101,149, 85);
+float indexValue16x16( float scale ) {
+	int x = int(mod(gl_FragCoord.x * scale, 16));
+	int y = int(mod(gl_FragCoord.y * scale, 16));
+	return indexMatrix16x16[(x + y * 16)] / 256.0;
+}
+const int indexMatrix8x8[64] = int[](0,  32, 8,  40, 2,  34, 10, 42,
+									 48, 16, 56, 24, 50, 18, 58, 26,
+									 12, 44, 4,  36, 14, 46, 6,  38,
+									 60, 28, 52, 20, 62, 30, 54, 22,
+									 3,  35, 11, 43, 1,  33, 9,  41,
+									 51, 19, 59, 27, 49, 17, 57, 25,
+									 15, 47, 7,  39, 13, 45, 5,  37,
+									 63, 31, 55, 23, 61, 29, 53, 21);
+float indexValue8x8( float scale ) {
+	int x = int(mod(gl_FragCoord.x * scale, 8));
+	int y = int(mod(gl_FragCoord.y * scale, 8));
+	return indexMatrix8x8[(x + y * 8)] / 64.0;
+}
+const int indexMatrix4x4[16] = int[](0,  8,  2,  10,
+									 12, 4,  14, 6,
+									 3,  11, 1,  9,
+									 15, 7,  13, 5);
+float indexValue4x4( float scale ) {
+	int x = int(mod(gl_FragCoord.x * scale, 4));
+	int y = int(mod(gl_FragCoord.y * scale, 4));
+	return indexMatrix4x4[(x + y * 4)] / 16.0;
+}
+vec3[2] closestColors(float hue) {
+	vec3 ret[2];
+	vec3 closest = vec3(-2, 0, 0);
+	vec3 secondClosest = vec3(-2, 0, 0);
+	vec3 temp;
+/*
+	for (int i = 0; i < palette.length(); ++i) {
+		temp = rgbToHsl(palette[i].rgb);
+		float tempDistance = hueDistance(temp.x, hue);
+		if (tempDistance < hueDistance(closest.x, hue)) {
+			secondClosest = closest;
+			closest = temp;
+		} else {
+			if (tempDistance < hueDistance(secondClosest.x, hue)) {
+				secondClosest = temp;
+			}
+		}
+	}
+*/
+	ret[0] = closest;
+	ret[1] = secondClosest;
+	return ret;
+}
+float dither(float color) {
+	float closestColor = (color < 0.5) ? 0 : 1;
+	float secondClosestColor = 1 - closestColor;
+	float d = 1; // -0.5 - fract(ubo.mode.parameters.w / 8.0);
+	if ( ubo.mode.scalar == 16 ) {
+	 	d = indexValue16x16(1);
+	} else if ( ubo.mode.scalar == 8 ) {
+	 	d = indexValue8x8(1);
+	} else if ( ubo.mode.scalar == 4 ) {
+	 	d = indexValue4x4(1);
+	}
+	float distance = abs(closestColor - color);
+	return (distance < d) ? closestColor : secondClosestColor;
+}
+void dither(inout vec3 color) { 
+	vec3 hsl = rgbToHsl(color);
+	hsl.x = dither(hsl.x);
+	color = hslToRgb(hsl);
+}
+void dither1(inout vec3 color) { 
+	vec3 hsl = rgbToHsl(color);
+
+	float d = 0;
+	vec3 cs[2] = { hsl, hsl }; // closestColors(hsl.x);
+	float scale = 1;
+	if ( ubo.mode.scalar == 16 ) {
+	 	d = indexValue16x16(scale);
+	} else if ( ubo.mode.scalar == 8 ) {
+	 	d = indexValue8x8(scale);
+	} else if ( ubo.mode.scalar == 4 ) {
+	 	d = indexValue4x4(scale);
+	}
+    float hueDiff = hueDistance(hsl.x, cs[0].x) / hueDistance(cs[1].x, cs[0].x);
+    float l1 = lightnessStep(max((hsl.z - 0.125), 0.0));
+    float l2 = lightnessStep(min((hsl.z + 0.124), 1.0));
+    float lightnessDiff = (hsl.z - l1) / (l2 - l1);
+
+    vec3 resultColor = (hueDiff < d) ? cs[0] : cs[1];
+    resultColor.z = (lightnessDiff < d) ? l1 : l2;
+    color = hslToRgb(resultColor);
+}
+vec3 dither2() {
+	vec3 vDither = dot( vec2( 171.0, 231.0 ), inUv.xy + ubo.mode.parameters.w ).xxx;
+	vDither.rgb = fract( vDither.rgb / vec3( 103.0, 71.0, 97.0 ) ) - vec3( 0.5, 0.5, 0.5 );
+	return ( vDither.rgb / 255.0 ) * 0.375;
+}
+
+float rand2(vec2 co){
+    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 143758.5453);
+}
+float rand3(vec3 co){
+    return fract(sin(dot(co.xyz ,vec3(12.9898,78.233, 37.719))) * 143758.5453);
+}
+void whitenoise(inout vec3 color) {
+	float flicker = ubo.mode.parameters.x;
+	float pieces = ubo.mode.parameters.y;
+	float blend = ubo.mode.parameters.z;
+	float time = ubo.mode.parameters.w;
+	if ( blend < 0.0001 ) return;
+	float freq = sin(pow(mod(time, flicker) + flicker, 1.9));
+//	float whiteNoise = rand3( floor(position.world / pieces) + floor(time * 2) );
+	float whiteNoise = rand2( floor(gl_FragCoord.xy / pieces) + mod(time, freq) );
+	color = mix( color, vec3(whiteNoise), blend );
+}
+
+void pbr( Light light, vec3 albedo, float metallic, float roughness, vec3 lightPositionWorld, inout vec3 i ) {
+	vec3 F0 = vec3(0.04); 
+    F0 = mix(F0, albedo, metallic); 
+
+	vec3 N = normalize(normal.eye);
+	vec3 L = light.position.xyz - position.eye;
+	float dist = length(L);
+//	if ( light.radius > 0.001 && light.radius < dist ) return;
+
+	vec3 D = normalize(L);
+	vec3 V = normalize(-position.eye);
+	vec3 H = normalize(V + D);
+
+	float NdotD = max(dot(N, D), 0.0);
+	float NdotV = max(dot(N, V), 0.0);
+
+	vec3 radiance = light.color.rgb * light.power / (dist * dist);
+/*
+	if ( light.radius > 0.0001 ) {
+		radiance *= clamp( light.radius / (pow(dist, 2.0) + 1.0), 0.0, 1.0 );
+	} else if ( false ) {
+		radiance /= dist * dist;
+	}
+*/
+
+	// cook-torrance brdf
+	float NDF = DistributionGGX(N, H, roughness);        
+	float G   = GeometrySmith(N, V, D, roughness);      
+	vec3 F    = fresnelSchlick(max(dot(H, V), 0.0), F0);       
+
+	vec3 kS = F;
+	vec3 kD = vec3(1.0) - kS;
+	kD *= 1.0 - metallic;	  
+
+	vec3 numerator    = NDF * G * F;
+	float denominator = 4.0 * NdotV * NdotD;
+	vec3 specular     = numerator / max(denominator, 0.001);  
+
+	// add to outgoing radiance Lo
+	i += (kD * albedo / PI + specular) * radiance * NdotD;
+}
+
+vec2 rayBoxDst( vec3 boundsMin, vec3 boundsMax, vec3 rayOrigin, vec3 rayDir ) {
+	vec3 t0 = (boundsMin - rayOrigin) / rayDir;
+	vec3 t1 = (boundsMax - rayOrigin) / rayDir;
+	vec3 tmin = min(t0, t1);
+	vec3 tmax = max(t0, t1);
+	float dstA = max( max(tmin.x, tmin.y), tmin.z );
+	float dstB = min( tmax.x, min(tmax.y, tmax.z) );
+	float dstToBox = max(0, dstA);
+	float dstInsideBox = max(0, dstB - dstToBox);
+	return vec2(dstToBox, dstInsideBox);
+}
+
+float sampleDensity( vec3 position ) {
+	vec3 uvw = position * ubo.fog.densityScale * 0.001 + ubo.fog.offset * 0.01;
+	return max(0, texture(samplerNoise, uvw).r - ubo.fog.densityThreshold) * ubo.fog.densityMultiplier;
+}
+
+void fog( inout vec3 i, float scale ) {
+	if ( ubo.fog.stepScale <= 0 ) return;
+	if ( ubo.fog.range.x == 0 || ubo.fog.range.y == 0 ) return;
+
+	mat4 iProjView = inverse( ubo.matrices.projection[inPushConstantPass] * ubo.matrices.view[inPushConstantPass] );
+	vec4 near4 = iProjView * (vec4(2.0 * inUv - 1.0, -1.0, 1.0));
+	vec4 far4 = iProjView * (vec4(2.0 * inUv - 1.0, 1.0, 1.0));
+	vec3 near3 = near4.xyz / near4.w;
+	vec3 far3 = far4.xyz / far4.w;
+
+	vec3 rayOrigin = near3;
+	vec3 rayDir = normalize( far3 - near3 );
+
+	float range = ubo.fog.range.y;
+	vec3 boundsMin = vec3(-range,-range,-range) + rayOrigin;
+	vec3 boundsMax = vec3(range,range,range) + rayOrigin;
+	int numSteps = int(length(boundsMax - boundsMin) * ubo.fog.stepScale );
+
+	vec2 rayBoxInfo = rayBoxDst( boundsMin, boundsMax, rayOrigin, rayDir );
+	float dstToBox = rayBoxInfo.x;
+	float dstInsideBox = rayBoxInfo.y;
+	float depth = position.eye.z;
+
+	float lightEnergy = 0;
+	// march
+	if ( 0 <= dstInsideBox && dstToBox <= depth ) {
+		float dstTravelled = 0;
+		float stepSize = dstInsideBox / numSteps;
+		float dstLimit = min( depth - dstToBox, dstInsideBox );
+		float totalDensity = 0;
+		float transmittance = 1;
+		while ( dstTravelled < dstLimit ) {
+			vec3 rayPos = rayOrigin + rayDir * (dstToBox + dstTravelled);
+			float density = sampleDensity(rayPos);
+			if ( density > 0 ) {
+				transmittance *= exp(-density * stepSize * ubo.fog.absorbtion);
+				if ( transmittance < 0.01 ) break;
+			}
+			dstTravelled += stepSize;
+		}
+		i.rgb = mix(ubo.fog.color.rgb, i.rgb, transmittance);
+	}
+
+	vec3 color = ubo.fog.color.rgb;
+	float inner = ubo.fog.range.x;
+	float outer = ubo.fog.range.y * scale;
+	float distance = length(-position.eye);
+	float factor = (distance - inner) / (outer - inner);
+	factor = clamp( factor, 0.0, 1.0 );
+
+	i.rgb = mix(i.rgb, color, factor);
+}
+
+void main() {
+	vec4 albedoMetallic = subpassLoad(samplerAlbedoMetallic);
+	vec4 normalRoughness = subpassLoad(samplerNormalRoughness);
+//	vec4 positionAO = subpassLoad(samplerPositionAO);
+	
+	normal.eye = normalRoughness.rgb;
+	{
+		mat4 iProj = inverse( ubo.matrices.projection[inPushConstantPass] );
+		mat4 iView = inverse( ubo.matrices.view[inPushConstantPass] );
+		float depth = subpassLoad(samplerDepth).r;		
+
+		vec4 positionClip = vec4(inUv * 2.0 - 1.0, depth, 1.0);
+		vec4 positionEye = iProj * positionClip;
+		positionEye /= positionEye.w;
+		position.eye = positionEye.xyz;
+
+		vec4 positionWorld = iView * positionEye;
+		position.world = positionWorld.xyz;
+	}
+
+	bool usePbr = true;
+	bool gammaCorrect = false;
+	float litFactor = 1.0;
+	float ao = 1; // positionAO.a;
+	vec3 fragColor = albedoMetallic.rgb * ubo.ambient.rgb * ao;
+	for ( uint i = 0; i < LIGHTS; ++i ) {
+		Light light = ubo.lights[i];
+		
+		if ( light.power <= 0.001 ) continue;
+		vec3 lightPositionWorld = light.position.xyz;
+		light.position.xyz = vec3(ubo.matrices.view[inPushConstantPass] * vec4(light.position.xyz, 1));
+		if ( light.type < 0 ) {
+			float factor = shadowFactor( light, i );
+			if ( factor <= 0.0001 ) continue;
+			light.power *= factor;
+			litFactor += light.power;
+		}
+		if ( usePbr ) {
+			pbr( light, albedoMetallic.rgb, albedoMetallic.a, normalRoughness.a, lightPositionWorld, fragColor );
+		} else
+			phong( light, albedoMetallic, fragColor );
+	}
+
+	if ( gammaCorrect ) {
+		fragColor = fragColor / (fragColor + vec3(1.0));
+ 		fragColor = pow(fragColor, vec3(1.0/2.2));  
+ 	}
+
+	fog(fragColor, litFactor);
+
+/*
+	if ( (ubo.mode.type & (0x1 << 0)) == (0x1 << 0) ) {
+		//dither1(fragColor);
+		fragColor += dither2();
+	}
+	if ( (ubo.mode.type & (0x1 << 1)) == (0x1 << 1) ) {
+		whitenoise(fragColor);
+	}
+*/
+	outFragColor = vec4(fragColor,1);
+}
\ No newline at end of file
diff --git a/bin/data/shaders/display/subpass.vert.glsl b/bin/data/shaders/display/subpass.vert.glsl
new file mode 100644
index 00000000..72ebf0a1
--- /dev/null
+++ b/bin/data/shaders/display/subpass.vert.glsl
@@ -0,0 +1,24 @@
+#version 450
+
+layout (location = 0) in vec2 inPos;
+layout (location = 1) in vec2 inUv;
+
+layout (location = 0) out vec2 outUv;
+layout (location = 1) out flat uint outPushConstantPass;
+
+layout( push_constant ) uniform PushBlock {
+  uint pass;
+  uint draw;
+} PushConstant;
+
+out gl_PerVertex {
+    vec4 gl_Position;
+};
+
+
+void main() {
+	outUv = inUv;
+	outPushConstantPass = PushConstant.pass;
+	
+	gl_Position = vec4(inPos.xy, 0.0, 1.0);
+}
\ No newline at end of file
diff --git a/bin/data/shaders/display/vert.glsl b/bin/data/shaders/display/vert.glsl
new file mode 100644
index 00000000..9d3a6de8
--- /dev/null
+++ b/bin/data/shaders/display/vert.glsl
@@ -0,0 +1,17 @@
+#version 450
+
+layout (location = 0) in vec2 inPos;
+layout (location = 1) in vec2 inUv;
+
+layout (location = 0) out vec2 outUv;
+
+out gl_PerVertex {
+    vec4 gl_Position;
+};
+
+
+void main() {
+	outUv = inUv;
+
+	gl_Position = vec4(inPos.xy, 0.0, 1.0);
+}
\ No newline at end of file
diff --git a/bin/data/shaders/gltf/frag.glsl b/bin/data/shaders/gltf/frag.glsl
new file mode 100644
index 00000000..d96ffad7
--- /dev/null
+++ b/bin/data/shaders/gltf/frag.glsl
@@ -0,0 +1,138 @@
+#version 450
+
+#define UF_DEFERRED_SAMPLING 0
+#define UF_CAN_DISCARD 1
+
+layout (constant_id = 0) const uint TEXTURES = 1;
+layout (binding = 0) uniform sampler2D samplerTextures[TEXTURES];
+
+struct Material {
+	vec4 colorBase;
+	vec4 colorEmissive;
+
+	float factorMetallic;
+	float factorRoughness;
+	float factorOcclusion;
+	float factorAlphaCutoff;
+
+	int indexAlbedo;
+	int indexNormal;
+	int indexEmissive;
+	int indexOcclusion;
+	
+	int indexMetallicRoughness;
+	int modeAlpha;
+	int padding1;
+	int padding2;
+};
+struct Texture {
+	int index;
+	int samp;
+	int remap;
+	float blend;
+
+	vec4 lerp;
+};
+layout (std140, binding = 1) readonly buffer Materials {
+	Material materials[];
+};
+layout (std140, binding = 2) readonly buffer Textures {
+	Texture textures[];
+};
+
+layout (location = 0) in vec2 inUv;
+layout (location = 1) in vec4 inColor;
+layout (location = 2) in vec3 inNormal;
+layout (location = 3) in mat3 inTBN;
+layout (location = 6) in vec3 inPosition;
+layout (location = 7) flat in ivec4 inId;
+
+layout (location = 0) out uvec2 outId;
+layout (location = 1) out vec2 outNormals;
+#if UF_DEFERRED_SAMPLING
+	layout (location = 2) out vec2 outUvs;
+#else
+	layout (location = 2) out vec4 outAlbedo;
+#endif
+
+vec2 encodeNormals( vec3 n ) {
+	float p = sqrt(n.z*8+8);
+	return n.xy/p + 0.5;
+}
+
+float wrap( float i ) {
+	return fract(i);
+}
+vec2 wrap( vec2 uv ) {
+	return vec2( wrap( uv.x ), wrap( uv.y ) );
+}
+float mipLevel( in vec2 uv ) {
+	vec2 dx_vtc = dFdx(uv);
+	vec2 dy_vtc = dFdy(uv);
+	return 0.5 * log2(max(dot(dx_vtc, dx_vtc), dot(dy_vtc, dy_vtc)));
+}
+bool validTextureIndex( int textureIndex ) {
+	return 0 <= textureIndex && textureIndex < TEXTURES;
+}
+void main() {
+	float mip = mipLevel(inUv.xy);
+	vec2 uv = wrap(inUv.xy);
+	vec4 C = vec4(0, 0, 0, 0);
+	vec3 P = inPosition;
+	vec3 N = inNormal;
+#if UF_DEFERRED_SAMPLING
+	outUvs = wrap(inUv.xy);
+	vec4 outAlbedo = vec4(0,0,0,0);
+#endif
+#if !UF_DEFERRED_SAMPLING || UF_CAN_DISCARD
+	int materialId = int(inId.y);
+	Material material = materials[materialId];
+	
+	float M = material.factorMetallic;
+	float R = material.factorRoughness;
+	float AO = material.factorOcclusion;
+
+	// sample albedo
+	if ( !validTextureIndex( material.indexAlbedo ) ) discard; {
+		Texture t = textures[material.indexAlbedo + 1];
+		C = textureLod( samplerTextures[0], mix( t.lerp.xy, t.lerp.zw, uv ), mip );
+		// alpha mode OPAQUE
+		if ( material.modeAlpha == 0 ) {
+			C.a = 1;
+		// alpha mode BLEND
+		} else if ( material.modeAlpha == 1 ) {
+
+		// alpha mode MASK
+		} else if ( material.modeAlpha == 2 ) {
+			if ( C.a < abs(material.factorAlphaCutoff) ) discard;
+			C.a = 1;
+		}
+		if ( C.a == 0 ) discard;
+	}
+#endif
+#if !UF_DEFERRED_SAMPLING
+	// sample normal
+	if ( validTextureIndex( material.indexNormal ) ) {
+		Texture t = textures[material.indexNormal + 1];
+		N = inTBN * normalize( textureLod( samplerTextures[0], mix( t.lerp.xy, t.lerp.zw, uv ), mip ).xyz * 2.0 - vec3(1.0));
+	}
+	#if 0
+		// sample metallic/roughness
+		if ( validTextureIndex( material.indexMetallicRoughness ) ) {
+			Texture t = textures[material.indexMetallicRoughness + 1];
+			vec4 sampled = texture( samplerTextures[0], mix( t.lerp.xy, t.lerp.zw, uv ), mip );
+			M = sampled.b;
+			R = sampled.g;
+		}
+		// sample ao
+		AO = material.factorOcclusion;
+		if ( validTextureIndex( material.indexOcclusion ) ) {
+			Texture t = textures[material.indexMetallicRoughness + 1];
+			AO = texture( samplerTextures[0], mix( t.lerp.xy, t.lerp.zw, uv ) ).r;
+		}
+	#endif
+	outAlbedo = C * inColor;
+#endif
+	outNormals = encodeNormals( N );
+	outId = ivec2(inId.w+1, inId.y+1);
+}
\ No newline at end of file
diff --git a/bin/data/shaders/gltf/instanced.vert.glsl b/bin/data/shaders/gltf/instanced.vert.glsl
new file mode 100644
index 00000000..8af8a834
--- /dev/null
+++ b/bin/data/shaders/gltf/instanced.vert.glsl
@@ -0,0 +1,62 @@
+#version 450
+
+layout (constant_id = 0) const uint PASSES = 6;
+layout (location = 0) in vec3 inPos;
+layout (location = 1) in vec2 inUv;
+layout (location = 2) in vec3 inNormal;
+layout (location = 3) in vec4 inTangent;
+layout (location = 4) in ivec2 inId;
+
+layout( push_constant ) uniform PushBlock {
+  uint pass;
+  uint draw;
+} PushConstant;
+
+layout (binding = 3) uniform UBO {
+	mat4 view[PASSES];
+	mat4 projection[PASSES];
+} ubo;
+
+layout (std140, binding = 4) readonly buffer Models {
+	mat4 models[];
+};
+
+layout (location = 0) out vec2 outUv;
+layout (location = 1) out vec4 outColor;
+layout (location = 2) out vec3 outNormal;
+layout (location = 3) out mat3 outTBN;
+layout (location = 6) out vec3 outPosition;
+layout (location = 7) out ivec4 outId;
+
+out gl_PerVertex {
+    vec4 gl_Position;
+};
+
+vec4 snap(vec4 vertex, vec2 resolution) {
+    vec4 snappedPos = vertex;
+    snappedPos.xyz = vertex.xyz / vertex.w;
+    snappedPos.xy = floor(resolution * snappedPos.xy) / resolution;
+    snappedPos.xyz *= vertex.w;
+    return snappedPos;
+}
+
+void main() {
+	outUv = inUv;
+	outColor = vec4(1.0);
+	outId = ivec4(inId, PushConstant.pass, PushConstant.draw);
+
+	mat4 model = models.length() <= 0 ? mat4(1.0) : models[int(inId.x)];
+	outPosition = vec3(ubo.view[PushConstant.pass] * model * vec4(inPos.xyz, 1.0));
+	outNormal = vec3(ubo.view[PushConstant.pass] * model * vec4(inNormal.xyz, 0.0));
+	outNormal = normalize(outNormal);
+
+	{
+		vec3 T = vec3(ubo.view[PushConstant.pass] * model * vec4(inTangent.xyz, 0.0));
+		vec3 N = outNormal;
+		vec3 B = cross(N, T) * inTangent.w;
+		outTBN = mat3( T, B, N );
+	}
+
+	gl_Position = ubo.projection[PushConstant.pass] * ubo.view[PushConstant.pass] * model * vec4(inPos.xyz, 1.0);
+//	gl_Position = snap( gl_Position, vec2(256.0, 224.0) );
+}
\ No newline at end of file
diff --git a/bin/data/shaders/gltf/skinned.instanced.vert.glsl b/bin/data/shaders/gltf/skinned.instanced.vert.glsl
new file mode 100644
index 00000000..9b777ee0
--- /dev/null
+++ b/bin/data/shaders/gltf/skinned.instanced.vert.glsl
@@ -0,0 +1,74 @@
+#version 450
+
+layout (constant_id = 0) const uint PASSES = 6;
+layout (location = 0) in vec3 inPos;
+layout (location = 1) in vec2 inUv;
+layout (location = 2) in vec3 inNormal;
+layout (location = 3) in vec4 inTangent;
+layout (location = 4) in ivec2 inId;
+layout (location = 5) in ivec4 inJoints;
+layout (location = 6) in vec4 inWeights;
+
+layout( push_constant ) uniform PushBlock {
+  uint pass;
+  uint draw;
+} PushConstant;
+
+layout (binding = 3) uniform UBO {
+	mat4 view[PASSES];
+	mat4 projection[PASSES];
+} ubo;
+
+layout (std140, binding = 4) readonly buffer Models {
+	mat4 models[];
+};
+
+layout (std140, binding = 5) readonly buffer Joints {
+	mat4 joints[];
+};
+
+layout (location = 0) out vec2 outUv;
+layout (location = 1) out vec4 outColor;
+layout (location = 2) out vec3 outNormal;
+layout (location = 3) out mat3 outTBN;
+layout (location = 6) out vec3 outPosition;
+layout (location = 7) out ivec4 outId;
+
+out gl_PerVertex {
+    vec4 gl_Position;   
+};
+
+vec4 snap(vec4 vertex, vec2 resolution) {
+    vec4 snappedPos = vertex;
+    snappedPos.xyz = vertex.xyz / vertex.w;
+    snappedPos.xy = floor(resolution * snappedPos.xy) / resolution;
+    snappedPos.xyz *= vertex.w;
+    return snappedPos;
+}
+
+void main() {
+	outUv = inUv;
+	outColor = vec4(1.0);
+	outId = ivec4(inId, PushConstant.pass, PushConstant.draw);
+
+	mat4 model = models.length() <= 0 ? mat4(1.0) : models[int(inId.x)];
+	mat4 skinnedMatrix = joints.length() <= 0 ? mat4(1.0) : 
+		inWeights.x * joints[int(inJoints.x)] +
+		inWeights.y * joints[int(inJoints.y)] +
+		inWeights.z * joints[int(inJoints.z)] +
+		inWeights.w * joints[int(inJoints.w)];
+
+	outPosition = vec3(ubo.view[PushConstant.pass] * model * skinnedMatrix * vec4(inPos.xyz, 1.0));
+	outNormal = vec3(ubo.view[PushConstant.pass] * model * vec4(inNormal.xyz, 0.0));
+	outNormal = normalize(outNormal);
+
+
+	{
+		vec3 T = vec3(ubo.view[PushConstant.pass] * model * vec4(inTangent.xyz, 0.0));
+		vec3 N = outNormal;
+		vec3 B = cross(N, T) * inTangent.w;
+		outTBN = mat3( T, B, N );
+	}
+
+	gl_Position = ubo.projection[PushConstant.pass] * ubo.view[PushConstant.pass] * model * skinnedMatrix * vec4(inPos.xyz, 1.0);
+}
\ No newline at end of file
diff --git a/bin/data/shaders/gltf/skinned.vert.glsl b/bin/data/shaders/gltf/skinned.vert.glsl
new file mode 100644
index 00000000..8d03d1ec
--- /dev/null
+++ b/bin/data/shaders/gltf/skinned.vert.glsl
@@ -0,0 +1,78 @@
+#version 450
+
+layout (constant_id = 0) const uint PASSES = 6;
+layout (location = 0) in vec3 inPos;
+layout (location = 1) in vec2 inUv;
+layout (location = 2) in vec3 inNormal;
+layout (location = 3) in vec4 inTangent;
+layout (location = 4) in ivec2 inId;
+layout (location = 5) in ivec4 inJoints;
+layout (location = 6) in vec4 inWeights;
+
+layout( push_constant ) uniform PushBlock {
+  uint pass;
+  uint draw;
+} PushConstant;
+
+struct Matrices {
+	mat4 model;
+	mat4 view[PASSES];
+	mat4 projection[PASSES];
+};
+layout (binding = 3) uniform UBO {
+	Matrices matrices;
+	vec4 color;
+} ubo;
+
+layout (std140, binding = 4) readonly buffer Joints {
+	mat4 joints[];
+};
+
+
+layout (location = 0) out vec2 outUv;
+layout (location = 1) out vec4 outColor;
+layout (location = 2) out vec3 outNormal;
+layout (location = 3) out mat3 outTBN;
+layout (location = 6) out vec3 outPosition;
+layout (location = 7) out ivec4 outId;
+
+out gl_PerVertex {
+    vec4 gl_Position;   
+};
+
+vec4 snap(vec4 vertex, vec2 resolution) {
+    vec4 snappedPos = vertex;
+    snappedPos.xyz = vertex.xyz / vertex.w;
+    snappedPos.xy = floor(resolution * snappedPos.xy) / resolution;
+    snappedPos.xyz *= vertex.w;
+    return snappedPos;
+}
+
+void main() {
+	outUv = inUv;
+	outColor = ubo.color;
+	outId = ivec4(inId, PushConstant.pass, PushConstant.draw);
+
+	mat4 skinnedMatrix = joints.length() <= 0 ? mat4(1.0) : 
+		inWeights.x * joints[int(inJoints.x)] +
+		inWeights.y * joints[int(inJoints.y)] +
+		inWeights.z * joints[int(inJoints.z)] +
+		inWeights.w * joints[int(inJoints.w)];
+
+	outPosition = vec3(ubo.matrices.view[PushConstant.pass] * ubo.matrices.model * skinnedMatrix * vec4(inPos.xyz, 1.0));
+	outNormal = vec3(ubo.matrices.view[PushConstant.pass] * ubo.matrices.model * vec4(inNormal.xyz, 0.0));
+	outNormal = normalize(outNormal);
+
+
+	{
+		vec3 T = vec3(ubo.matrices.view[PushConstant.pass] * ubo.matrices.model * vec4(inTangent.xyz, 0.0));
+		vec3 N = outNormal;
+		vec3 B = cross(N, T) * inTangent.w;
+		outTBN = mat3( T, B, N );
+	}
+
+	gl_Position = ubo.matrices.projection[PushConstant.pass] * ubo.matrices.view[PushConstant.pass] * ubo.matrices.model * skinnedMatrix * vec4(inPos.xyz, 1.0);
+//	gl_Position = snap( gl_Position, vec2(320.0, 240.0) );
+//	gl_Position = snap( gl_Position, vec2(480.0, 270.0) );
+//	gl_Position = snap( gl_Position, vec2(640.0, 480.0) );
+}
\ No newline at end of file
diff --git a/bin/data/shaders/gltf/vert.glsl b/bin/data/shaders/gltf/vert.glsl
new file mode 100644
index 00000000..f868b307
--- /dev/null
+++ b/bin/data/shaders/gltf/vert.glsl
@@ -0,0 +1,64 @@
+#version 450
+
+layout (constant_id = 0) const uint PASSES = 6;
+layout (location = 0) in vec3 inPos;
+layout (location = 1) in vec2 inUv;
+layout (location = 2) in vec3 inNormal;
+layout (location = 3) in vec4 inTangent;
+layout (location = 4) in ivec2 inId;
+
+layout( push_constant ) uniform PushBlock {
+  uint pass;
+  uint draw;
+} PushConstant;
+
+struct Matrices {
+	mat4 model;
+	mat4 view[PASSES];
+	mat4 projection[PASSES];
+};
+
+layout (binding = 3) uniform UBO {
+	Matrices matrices;
+	vec4 color;
+} ubo;
+
+layout (location = 0) out vec2 outUv;
+layout (location = 1) out vec4 outColor;
+layout (location = 2) out vec3 outNormal;
+layout (location = 3) out mat3 outTBN;
+layout (location = 6) out vec3 outPosition;
+layout (location = 7) out ivec4 outId;
+
+out gl_PerVertex {
+    vec4 gl_Position;   
+};
+
+vec4 snap(vec4 vertex, vec2 resolution) {
+    vec4 snappedPos = vertex;
+    snappedPos.xyz = vertex.xyz / vertex.w;
+    snappedPos.xy = floor(resolution * snappedPos.xy) / resolution;
+    snappedPos.xyz *= vertex.w;
+    return snappedPos;
+}
+
+void main() {
+	outUv = inUv;
+	outColor = ubo.color;
+	outId = ivec4(inId, PushConstant.pass, PushConstant.draw);
+
+	outPosition = vec3(ubo.matrices.view[PushConstant.pass] * ubo.matrices.model * vec4(inPos.xyz, 1.0));
+	outNormal = vec3(ubo.matrices.view[PushConstant.pass] * ubo.matrices.model * vec4(inNormal.xyz, 0.0));
+	outNormal = normalize(outNormal);
+
+
+	{
+		vec3 T = vec3(ubo.matrices.view[PushConstant.pass] * ubo.matrices.model * vec4(inTangent.xyz, 0.0));
+		vec3 N = outNormal;
+		vec3 B = cross(N, T) * inTangent.w;
+		outTBN = mat3( T, B, N );
+	}
+
+	gl_Position = ubo.matrices.projection[PushConstant.pass] * ubo.matrices.view[PushConstant.pass] * ubo.matrices.model * vec4(inPos.xyz, 1.0);
+//	gl_Position = snap( gl_Position, vec2(320.0, 240.0) );
+}
\ No newline at end of file
diff --git a/bin/data/shaders/gui/frag.glsl b/bin/data/shaders/gui/frag.glsl
new file mode 100644
index 00000000..1dc5485a
--- /dev/null
+++ b/bin/data/shaders/gui/frag.glsl
@@ -0,0 +1,66 @@
+#version 450
+
+#define UF_DEFERRED_SAMPLING 0
+#define UF_CAN_DISCARD 1
+
+layout (binding = 1) uniform sampler2D samplerTexture;
+
+struct Gui {
+	vec4 offset;
+	vec4 color;
+	int mode;
+	float depth;
+	vec2 padding;
+};
+
+layout (location = 0) in vec2 inUv;
+layout (location = 1) in flat Gui inGui;
+
+layout (location = 0) out uvec2 outId;
+layout (location = 1) out vec2 outNormals;
+#if UF_DEFERRED_SAMPLING
+	layout (location = 2) out vec2 outUvs;
+#else
+	layout (location = 2) out vec4 outAlbedo;
+#endif
+
+vec2 encodeNormals( vec3 n ) {
+	float p = sqrt(n.z*8+8);
+	return n.xy/p + 0.5;
+}
+float mipLevel( in vec2 uv ) {
+	vec2 dx_vtc = dFdx(uv);
+	vec2 dy_vtc = dFdy(uv);
+	return 0.5 * log2(max(dot(dx_vtc, dx_vtc), dot(dy_vtc, dy_vtc)));
+}
+
+void main() {
+	if ( inUv.x < inGui.offset.x ) discard;
+	if ( inUv.y < inGui.offset.y ) discard;
+	if ( inUv.x > inGui.offset.z ) discard;
+	if ( inUv.y > inGui.offset.w ) discard;
+
+	float mip = mipLevel(inUv.xy);
+	vec2 uv = inUv.xy;
+	vec4 C = vec4(1, 1, 1, 1);
+	//vec3 N = inNormal;
+#if UF_DEFERRED_SAMPLING
+	outUvs = wrap(inUv.xy);
+	vec4 outAlbedo = vec4(0,0,0,0);
+#endif
+#if !UF_DEFERRED_SAMPLING || UF_CAN_DISCARD
+	C = textureLod( samplerTexture, uv, mip );
+#endif
+#if !UF_DEFERRED_SAMPLING
+	if ( inGui.mode == 1 ) {
+		C = inGui.color;
+	} else {
+		C *= inGui.color;
+	}
+	outAlbedo = C;
+#endif
+/*
+	outNormals = encodeNormals( N );
+	outId = ivec2(0, 0);
+*/
+}
\ No newline at end of file
diff --git a/bin/data/shaders/gui/text.frag.glsl b/bin/data/shaders/gui/text.frag.glsl
new file mode 100644
index 00000000..520220cd
--- /dev/null
+++ b/bin/data/shaders/gui/text.frag.glsl
@@ -0,0 +1,62 @@
+#version 450
+
+#define UF_DEFERRED_SAMPLING 0
+#define UF_CAN_DISCARD 1
+
+layout (binding = 1) uniform sampler2D samplerTexture;
+
+struct Gui {
+	vec4 offset;
+	vec4 color;
+	int mode;
+	float depth;
+	int sdf;
+	int shadowbox;
+	vec4 stroke;
+	float weight;
+	int spread;
+	float scale;
+	float padding;
+};
+
+layout (location = 0) in vec2 inUv;
+layout (location = 1) in flat Gui inGui;
+
+layout (location = 0) out uvec2 outId;
+layout (location = 1) out vec2 outNormals;
+#if UF_DEFERRED_SAMPLING
+	layout (location = 2) out vec2 outUvs;
+#else
+	layout (location = 2) out vec4 outAlbedo;
+#endif
+
+void main() {
+	if ( inUv.x < inGui.offset.x ) discard;
+	if ( inUv.y < inGui.offset.y ) discard;
+	if ( inUv.x > inGui.offset.z ) discard;
+	if ( inUv.y > inGui.offset.w ) discard;
+
+#if UF_DEFERRED_SAMPLING
+	vec4 outAlbedo = vec4(0,0,0,0);
+#endif
+
+	if ( inGui.shadowbox == 1 ) {
+		outAlbedo = inGui.color;
+		return;
+	}
+	float dist = texture(samplerTexture, inUv).r;
+	if ( inGui.sdf == 1 ) {
+		float smoothing = ( inGui.spread > 0 && inGui.scale > 0 ) ? 0.25 / (inGui.spread * inGui.scale) : 0.25 / (4 * 1.5);
+		float outlining = smoothstep(0.5 - smoothing, 0.5 + smoothing, dist);
+		float alpha = smoothstep(inGui.weight - smoothing, inGui.weight + smoothing, dist);
+		vec4 c = inGui.color;
+		outAlbedo = mix(inGui.stroke, c, outlining);
+		outAlbedo.a = inGui.color.a * alpha;
+		if ( alpha < 0.001 ) discard;
+		if ( alpha > 1 ) discard;
+	} else {
+		outAlbedo = vec4(inGui.color) * dist;
+		if ( dist < 0.001 ) discard;
+		if ( dist > 1 ) discard;
+	}
+}
\ No newline at end of file
diff --git a/bin/data/shaders/gui/text.vert.glsl b/bin/data/shaders/gui/text.vert.glsl
new file mode 100644
index 00000000..487894d2
--- /dev/null
+++ b/bin/data/shaders/gui/text.vert.glsl
@@ -0,0 +1,47 @@
+#version 450
+
+layout (constant_id = 0) const uint PASSES = 6;
+layout (location = 0) in vec2 inPos;
+layout (location = 1) in vec2 inUv;
+
+layout( push_constant ) uniform PushBlock {
+  uint pass;
+  uint draw;
+} PushConstant;
+
+struct Matrices {
+	mat4 model[PASSES];
+};
+struct Gui {
+	vec4 offset;
+	vec4 color;
+	int mode;
+	float depth;
+	int sdf;
+	int shadowbox;
+	vec4 stroke;
+	float weight;
+	int spread;
+	float scale;
+	float padding;
+};
+
+layout (binding = 0) uniform UBO {
+	Matrices matrices;
+	Gui gui;
+} ubo;
+
+layout (location = 0) out vec2 outUv;
+layout (location = 1) out flat Gui outGui;
+
+out gl_PerVertex {
+    vec4 gl_Position;
+};
+
+
+void main() {
+	outUv = inUv;
+	outGui = ubo.gui;
+
+	gl_Position = ubo.matrices.model[PushConstant.pass] * vec4(inPos.xy, ubo.gui.depth, 1.0);
+}
\ No newline at end of file
diff --git a/bin/data/shaders/gui/vert.glsl b/bin/data/shaders/gui/vert.glsl
new file mode 100644
index 00000000..9828ff94
--- /dev/null
+++ b/bin/data/shaders/gui/vert.glsl
@@ -0,0 +1,41 @@
+#version 450
+
+layout (constant_id = 0) const uint PASSES = 6;
+layout (location = 0) in vec2 inPos;
+layout (location = 1) in vec2 inUv;
+
+layout( push_constant ) uniform PushBlock {
+  uint pass;
+  uint draw;
+} PushConstant;
+
+struct Matrices {
+	mat4 model[PASSES];
+};
+struct Gui {
+	vec4 offset;
+	vec4 color;
+	int mode;
+	float depth;
+	vec2 padding;
+};
+
+layout (binding = 0) uniform UBO {
+	Matrices matrices;
+	Gui gui;
+} ubo;
+
+layout (location = 0) out vec2 outUv;
+layout (location = 1) out flat Gui outGui;
+
+out gl_PerVertex {
+    vec4 gl_Position;
+};
+
+
+void main() {
+	outUv = inUv;
+	outGui = ubo.gui;
+
+	gl_Position = ubo.matrices.model[PushConstant.pass] * vec4(inPos.xy, ubo.gui.depth, 1.0);
+}
\ No newline at end of file
diff --git a/bin/data/shaders/heightmap/frag.glsl b/bin/data/shaders/heightmap/frag.glsl
new file mode 100644
index 00000000..7aa5d840
--- /dev/null
+++ b/bin/data/shaders/heightmap/frag.glsl
@@ -0,0 +1,19 @@
+#version 450
+
+layout (binding = 1) uniform sampler2D samplerColor;
+
+layout (location = 0) in vec2 inUv;
+layout (location = 1) in vec3 inNormal;
+layout (location = 2) in vec4 inColor;
+
+layout (location = 0) out vec4 outAlbedoSpecular;
+layout (location = 1) out vec4 outNormal;
+
+void main() {
+	outAlbedoSpecular = texture(samplerColor, inUv);
+	outAlbedoSpecular = vec4(1,1,1,1);
+	outAlbedoSpecular.rgb *= inColor.rgb;
+	outAlbedoSpecular.a = 1;
+//	outPosition = vec4(inPosition, 1.0);
+	outNormal = vec4(normalize(inNormal), 1.0);
+}
\ No newline at end of file
diff --git a/bin/data/shaders/heightmap/vert.glsl b/bin/data/shaders/heightmap/vert.glsl
new file mode 100644
index 00000000..f802c523
--- /dev/null
+++ b/bin/data/shaders/heightmap/vert.glsl
@@ -0,0 +1,52 @@
+#version 450
+
+layout (constant_id = 0) const uint PASSES = 6;
+layout (location = 0) in vec3 inPos;
+layout (location = 1) in vec2 inUv;
+layout (location = 2) in vec3 inNormal;
+layout (location = 3) in uint inColor;
+
+layout( push_constant ) uniform PushBlock {
+  uint pass;
+  uint draw;
+} PushConstant;
+
+struct Matrices {
+	mat4 model;
+	mat4 view[PASSES];
+	mat4 projection[PASSES];
+};
+
+layout (binding = 0) uniform UBO {
+	Matrices matrices;
+	vec4 color;
+} ubo;
+
+layout (location = 0) out vec2 outUv;
+layout (location = 1) out vec3 outNormal;
+layout (location = 2) out vec4 outColor;
+
+out gl_PerVertex {
+    vec4 gl_Position;   
+};
+
+
+void main() {
+	outUv = inUv;
+//	outColor = ubo.color;
+
+//	outPosition = vec3(ubo.matrices.view[PushConstant.pass] * ubo.matrices.model * vec4(inPos.xyz, 1.0));
+	outNormal = vec3(ubo.matrices.view[PushConstant.pass] * ubo.matrices.model * vec4(inNormal.xyz, 0.0));
+
+//	outPosition = vec3(ubo.matrices.model * vec4(inPos.xyz, 1.0));
+//	outNormal = vec3(ubo.matrices.model * vec4(inNormal.xyz, 0.0));
+
+	outColor.a = (inColor >>  24u) & 0xFF;
+	outColor.b = (inColor >>  16u) & 0xFF;
+	outColor.g = (inColor >>   8u) & 0xFF;
+	outColor.r = (inColor        ) & 0xFF;
+	outColor.rgb /= 256.0;
+	outColor.a = 0.5;
+
+	gl_Position = ubo.matrices.projection[PushConstant.pass] * ubo.matrices.view[PushConstant.pass] * ubo.matrices.model * vec4(inPos.xyz, 1.0);
+}
\ No newline at end of file
diff --git a/bin/data/shaders/line/frag.glsl b/bin/data/shaders/line/frag.glsl
new file mode 100644
index 00000000..b996dd27
--- /dev/null
+++ b/bin/data/shaders/line/frag.glsl
@@ -0,0 +1,10 @@
+#version 450
+
+layout (location = 0) in vec3 inColor;
+
+layout (location = 0) out vec4 outAlbedoSpecular;
+
+void main() {
+	outAlbedoSpecular.rgb *= inColor.rgb;
+	outAlbedoSpecular.a = 1;
+}
\ No newline at end of file
diff --git a/bin/data/shaders/line/vert.glsl b/bin/data/shaders/line/vert.glsl
new file mode 100644
index 00000000..215c618f
--- /dev/null
+++ b/bin/data/shaders/line/vert.glsl
@@ -0,0 +1,35 @@
+#version 450
+
+layout (constant_id = 0) const uint PASSES = 6;
+layout (location = 0) in vec3 inPos;
+
+layout( push_constant ) uniform PushBlock {
+  uint pass;
+  uint draw;
+} PushConstant;
+
+struct Matrices {
+	mat4 model;
+	mat4 view[PASSES];
+	mat4 projection[PASSES];
+};
+
+layout (binding = 0) uniform UBO {
+	Matrices matrices;
+	vec4 color;
+} ubo;
+
+layout (location = 0) out vec4 outColor;
+
+out gl_PerVertex {
+    vec4 gl_Position;   
+};
+
+
+void main() {
+	outColor = ubo.color;
+
+//	outPosition = vec3(ubo.matrices.view[PushConstant.pass] * ubo.matrices.model * vec4(inPos.xyz, 1.0));
+
+	gl_Position = ubo.matrices.projection[PushConstant.pass] * ubo.matrices.view[PushConstant.pass] * ubo.matrices.model * vec4(inPos.xyz, 1.0);
+}
\ No newline at end of file
diff --git a/bin/data/shaders/noise/frag.glsl b/bin/data/shaders/noise/frag.glsl
new file mode 100644
index 00000000..2b8bc5da
--- /dev/null
+++ b/bin/data/shaders/noise/frag.glsl
@@ -0,0 +1,23 @@
+#version 450
+
+layout (binding = 1) uniform sampler3D samplerColor;
+
+layout (location = 0) in vec2 inUv;
+layout (location = 1) in vec4 inColor;
+layout (location = 2) in vec3 inNormal;
+layout (location = 3) in vec3 inPosition;
+
+layout (location = 0) out vec4 outAlbedoSpecular;
+layout (location = 1) out vec4 outNormal;
+layout (location = 2) out vec4 outPosition;
+
+layout (binding = 2) uniform UBO {
+	float slice;
+} ubo;
+
+void main() {
+	outAlbedoSpecular.rgb = vec3(texture(samplerColor, vec3(inUv,ubo.slice)).r);
+	outAlbedoSpecular.a = 1;	
+	outNormal = vec4(inNormal,1);
+	outPosition = vec4(inPosition,1);
+}
\ No newline at end of file
diff --git a/bin/data/shaders/raytracing/comp.glsl b/bin/data/shaders/raytracing/comp.glsl
new file mode 100644
index 00000000..dbc8fc79
--- /dev/null
+++ b/bin/data/shaders/raytracing/comp.glsl
@@ -0,0 +1,295 @@
+#version 450
+
+layout (local_size_x = 32, local_size_y = 32) in;
+
+layout (constant_id = 0) const uint LIGHTS = 16;
+layout (constant_id = 1) const uint EYES = 2;
+layout (binding = 0, rgba8) uniform writeonly image2D resultImage[EYES];
+
+#define EPSILON 0.0001
+#define MAXLEN 1000.0
+
+layout( push_constant ) uniform PushBlock {
+	uint marchingSteps;
+	uint rayBounces;
+	float shadowFactor;
+	float reflectionStrength;
+	float reflectionFalloff;
+} PushConstant;
+
+struct Ray {
+	vec3 origin;
+	vec3 direction;
+};
+struct Result {
+	vec3 color;
+	float t;
+	int id;
+};
+struct Light {
+	vec3 position;
+	float radius;
+	vec3 color;
+	float power;
+	vec2 type;
+	vec2 padding;
+	mat4 view;
+	mat4 projection;
+};
+
+struct State {
+	vec3 viewPosition;
+	Ray ray;
+	Result result;
+} state;
+
+struct Fog {
+	vec2 range;
+	vec2 padding;
+	vec4 color;
+};
+
+layout (binding = 1) uniform UBO {
+	mat4 matrices[2];
+	vec4 ambient;
+	Fog fog;
+	Light lights[LIGHTS];
+} ubo;
+
+struct Shape {
+	vec4 values;
+	vec4 albedoSpecular;
+	int type;
+};
+layout (std140, binding = 2) buffer Shapes {
+	Shape shapes[];
+};
+
+void reflectRay(inout vec3 rayD, in vec3 normal) {
+	rayD = rayD + 2.0 * -dot(normal, rayD) * normal;
+}
+// Lighting =========================================================
+float lightDiffuse(vec3 normal, vec3 lightDir) {
+	return clamp(dot(normal, lightDir), 0.1, 1.0);
+}
+float lightSpecular(vec3 normal, vec3 lightDir, float specularFactor) {
+	vec3 viewVec = normalize(state.viewPosition);
+	vec3 halfVec = normalize(lightDir + viewVec);
+	return pow(clamp(dot(normal, halfVec), 0.0, 1.0), specularFactor);
+}
+
+// Sphere ===========================================================
+float sphereIntersect(in vec3 rayO, in vec3 rayD, in Shape shape ) {
+	vec3 oc = rayO - shape.values.xyz;
+	float b = 2.0 * dot(oc, rayD);
+	float c = dot(oc, oc) - shape.values.w * shape.values.w;
+	float h = b*b - 4.0*c;
+	if (h < 0.0) return -1.0;
+	float t = (-b - sqrt(h)) / 2.0;
+	return t;
+}
+vec3 sphereNormal(in vec3 position, in Shape shape) {
+	return (position - shape.values.xyz) / shape.values.w;
+}
+float sphereSDF( vec3 position, in Shape shape ) {
+	return length(position - shape.values.xyz) - shape.values.w;
+}
+// Plane ===========================================================
+float planeIntersect(in vec3 rayO, in vec3 rayD, in Shape shape) {
+	float d = dot(rayD, shape.values.xyz);
+	if (d == 0.0) return 0.0;
+	float t = -(shape.values.w + dot(rayO, shape.values.xyz)) / d;
+	return t < 0.0 ? 0.0 : t;
+}
+vec3 planeNormal(in vec3 position, in Shape shape) {
+	return shape.values.xyz;
+}
+float planeSDF( vec3 position, in Shape shape ) {
+	return dot( position, shape.values.xyz ) + shape.values.w;
+}
+// Generic =========================================================
+float shapeIntersect(in vec3 rayO, in vec3 rayD, in Shape shape) {
+	if ( shape.type == 1 ) return sphereIntersect( rayO, rayD, shape );
+	if ( shape.type == 2 ) return planeIntersect( rayO, rayD, shape );
+	return 0.0;
+}
+vec3 shapeNormal( vec3 position, in Shape shape ) {
+	if ( shape.type == 1 ) return sphereNormal(position, shape);
+	if ( shape.type == 2 ) return planeNormal(position, shape);
+	return vec3(0.0);
+}
+float shapeSDF( vec3 position, in Shape shape ) {
+	if ( shape.type == 1 ) return sphereSDF(position, shape);
+	if ( shape.type == 2 ) return planeSDF(position, shape);
+	return MAXLEN;
+}
+// Intersect =======================================================
+int intersect(in vec3 rayO, in vec3 rayD, inout float resT) {
+	int id = -1;
+	for (int i = 0; i < shapes.length(); i++) {
+		Shape shape = shapes[i];
+		float tShape = shapeIntersect(rayO, rayD, shape);
+		if ((tShape > EPSILON) && (tShape < resT)) {
+			id = i;
+			resT = tShape;
+		}	
+	}
+	return id;
+}
+float calcShadow(in vec3 rayO, in vec3 rayD, in int objectID, inout float resT) {
+	for (int i = 0; i < shapes.length(); i++) {
+		if ( i == objectID ) continue;
+		Shape shape = shapes[i];
+		float tShape = shapeIntersect(rayO, rayD, shape);
+		if ((tShape > EPSILON) && (tShape < resT)) {
+			resT = tShape;
+			return PushConstant.shadowFactor;
+		}
+	}
+	return 1.0;
+}
+// Marching ========================================
+int intersectMarch( in vec3 rayO, in vec3 rayD, inout float resT ) {
+	resT = 0;
+	for (int i = 0; i < PushConstant.marchingSteps; ++i) {
+		vec3 position = resT * rayD + rayO;
+		float tNearest = MAXLEN;
+		int objectID = -1;
+		for ( int j = 0; j < shapes.length(); ++j ) {
+			Shape shape = shapes[j];
+			float tShape = shapeSDF(position, shape);
+		//	if ((tShape > EPSILON) && (tShape < tNearest)) {
+			if ( tShape < tNearest ) {
+				objectID = j;
+				tNearest = tShape;
+			}
+		}
+		if (tNearest < EPSILON) {
+			return objectID;
+		}
+		if (resT > MAXLEN) break;
+		resT += tNearest;
+	}
+	resT = MAXLEN;
+	return -1;
+}
+float calcShadowMarch( in vec3 rayO, in vec3 rayD, in int objectID, inout float resT ) {
+	float distance = resT;
+	resT = 0;
+	for (int i = 0; i < PushConstant.marchingSteps; ++i) {
+		vec3 position = resT * rayD + rayO;
+		float tNearest = distance;
+		int objectID = -1;
+		for ( int j = 0; j < shapes.length(); ++j ) {
+			if ( j == objectID ) continue;
+			Shape shape = shapes[j];
+			float tShape = shapeSDF(position, shape);
+		//	if ((tShape > EPSILON) && (tShape < tNearest)) {
+			if ( tShape < tNearest ) {
+				objectID = j;
+				tNearest = tShape;
+			}
+		}
+		if (tNearest < EPSILON) {
+			return PushConstant.shadowFactor;
+		}
+		if (resT > distance) break;
+		resT += tNearest;
+	}
+	resT = distance;
+	return 1.0;
+}
+
+void fog(inout vec3 i, in float t ) {
+/*
+	vec3 fogColor = ubo.ambient.rgb;
+	i = mix(i, fogColor.rgb, clamp(sqrt(t*t)/20.0, 0.0, 1.0));
+*/
+	if ( ubo.fog.range.x == 0 || ubo.fog.range.y == 0 ) return;
+
+	vec3 color = ubo.fog.color.rgb;
+	float inner = ubo.fog.range.x, outer = ubo.fog.range.y;
+	float factor = (t - inner) / (outer - inner);
+	factor = clamp( factor, 0.0, 1.0 );
+
+	i = mix(i.rgb, color, factor);
+}
+
+Result renderScene(inout vec3 rayO, inout vec3 rayD ) {
+	Result result;
+	result.color = vec3(0.0);
+	result.t = MAXLEN;
+	result.id = PushConstant.marchingSteps > 0 ? intersectMarch(rayO, rayD, result.t) : intersect(rayO, rayD, result.t);
+	if (result.id == -1) return result;
+	
+	Shape shape = shapes[result.id];
+	vec3 position = rayO + result.t * rayD;
+	vec3 normal = shapeNormal( position, shape );
+
+	for ( uint i = 0; i < LIGHTS; ++i ) {
+		Light light = ubo.lights[i];
+		if ( light.radius <= EPSILON ) continue;
+		if ( light.power <= EPSILON ) continue;
+
+		vec3 L = light.position - position;
+		float dist = length(L);
+		vec3 D = normalize(L);
+		float attenuation = light.radius / (pow(dist, 2.0) + 1.0);;
+		attenuation = 1;
+	//	if ( dist > light.radius ) continue;
+		
+		vec4 albedoSpecular = shape.albedoSpecular;
+
+		float d_dot = lightDiffuse(normal, D);
+		float s_factor = lightSpecular(normal, D, albedoSpecular.a);
+		vec3 color = (light.color * albedoSpecular.rgb) * d_dot + s_factor;
+
+		// Shadows
+		float tShadow = dist;
+		float shadowed = 1;
+		if ( PushConstant.shadowFactor < 1.0 )
+			shadowed = PushConstant.marchingSteps > 0 ? calcShadowMarch(position, D, result.id, tShadow) : calcShadow(position, D, result.id, tShadow);
+		result.color += color * light.power * attenuation * shadowed;
+	}
+
+	// Fog
+	// fog(t, result.color);
+
+	// Reflect ray for next render pass
+	reflectRay(rayD, normal);
+	rayO = position;	
+	
+	return result;
+}
+
+void main() {
+	for ( int pass = 0; pass < EYES; ++pass ) {
+		{
+			vec2 uv = vec2(gl_GlobalInvocationID.xy) / imageSize(resultImage[pass]);
+			vec4 near4 = ubo.matrices[pass] * (vec4(2.0 * uv - 1.0, -1.0, 1.0));
+			vec4 far4 = ubo.matrices[pass] * (vec4(2.0 * uv - 1.0, 1.0, 1.0));
+			vec3 near3 = near4.xyz / near4.w;
+			vec3 far3 = far4.xyz / far4.w;
+
+			state.viewPosition = near3;
+			state.ray.origin = near3;
+			state.ray.direction = normalize( far3 - near3 );
+		}
+
+		// Basic color path
+		state.result = renderScene(state.ray.origin, state.ray.direction);
+		vec3 finalColor = state.result.color;
+		
+		// Reflection
+		float reflectionStrength = PushConstant.reflectionStrength;
+		for (int i = 0; i < PushConstant.rayBounces; i++) {
+			Result result = renderScene(state.ray.origin, state.ray.direction);
+			vec3 reflectionColor = result.color;
+
+			finalColor = (1.0 - reflectionStrength) * finalColor + reflectionStrength * mix(reflectionColor, finalColor, 1.0 - reflectionStrength);
+			reflectionStrength *= PushConstant.reflectionFalloff;
+		}
+				
+		imageStore(resultImage[pass], ivec2(gl_GlobalInvocationID.xy), vec4(finalColor, 1.0));
+	}
+}
\ No newline at end of file
diff --git a/bin/data/shaders/terrain/frag.glsl b/bin/data/shaders/terrain/frag.glsl
new file mode 100644
index 00000000..cfe7cd4b
--- /dev/null
+++ b/bin/data/shaders/terrain/frag.glsl
@@ -0,0 +1,20 @@
+#version 450
+
+layout (binding = 1) uniform sampler2D samplerColor;
+
+layout (location = 0) in vec2 inUv;
+layout (location = 1) in vec4 inColor;
+layout (location = 2) in vec3 inNormal;
+layout (location = 3) in vec3 inPosition;
+
+layout (location = 0) out vec4 outAlbedoSpecular;
+layout (location = 1) out vec4 outNormal;
+layout (location = 2) out vec4 outPosition;
+
+void main() {
+	outAlbedoSpecular = texture(samplerColor, inUv);
+	// outAlbedoSpecular.rgb *= inColor.rgb;
+	outAlbedoSpecular.a = 1;
+	outNormal = vec4(inNormal,1);
+	outPosition = vec4(inPosition,1);
+}
\ No newline at end of file
diff --git a/bin/data/shaders/terrain/vert.glsl b/bin/data/shaders/terrain/vert.glsl
new file mode 100644
index 00000000..7c6d8752
--- /dev/null
+++ b/bin/data/shaders/terrain/vert.glsl
@@ -0,0 +1,51 @@
+#version 450
+
+layout (constant_id = 0) const uint PASSES = 6;
+layout (location = 0) in vec3 inPos;
+layout (location = 1) in vec2 inUv;
+layout (location = 2) in vec3 inNormal;
+layout (location = 3) in uint inColor;
+
+layout( push_constant ) uniform PushBlock {
+  uint pass;
+  uint draw;
+} PushConstant;
+
+struct Matrices {
+	mat4 model;
+	mat4 view[PASSES];
+	mat4 projection[PASSES];
+};
+
+layout (binding = 0) uniform UBO {
+	Matrices matrices;
+	vec4 color;
+} ubo;
+
+layout (location = 0) out vec2 outUv;
+layout (location = 1) out vec4 outColor;
+layout (location = 2) out vec3 outNormal;
+layout (location = 3) out vec3 outPosition;
+
+out gl_PerVertex {
+    vec4 gl_Position;   
+};
+
+
+void main() {
+	outUv = inUv;
+//	outColor = ubo.color;
+
+	outPosition = vec3(ubo.matrices.view[PushConstant.pass] * ubo.matrices.model * vec4(inPos.xyz, 1.0));
+	outNormal = vec3(ubo.matrices.view[PushConstant.pass] * ubo.matrices.model * vec4(inNormal.xyz, 0.0));
+	outNormal = normalize(outNormal);
+
+	outColor.a = (inColor >>  24u) & 0xFF;
+	outColor.b = (inColor >>  16u) & 0xFF;
+	outColor.g = (inColor >>   8u) & 0xFF;
+	outColor.r = (inColor        ) & 0xFF;
+	outColor.rgb /= 256.0;
+	outColor.a = 0.5;
+
+	gl_Position = ubo.matrices.projection[PushConstant.pass] * ubo.matrices.view[PushConstant.pass] * ubo.matrices.model * vec4(inPos.xyz, 1.0);
+}
\ No newline at end of file
diff --git a/bin/data/shaders/texture/frag.glsl b/bin/data/shaders/texture/frag.glsl
new file mode 100644
index 00000000..6ebfac38
--- /dev/null
+++ b/bin/data/shaders/texture/frag.glsl
@@ -0,0 +1,11 @@
+#version 450
+
+layout (binding = 0) uniform sampler2D samplerColor;
+layout (location = 0) in vec2 inUV;
+layout (location = 0) out vec4 outFragColor;
+
+void main() {
+	vec4 sampledColor = texture(samplerColor, inUV);
+	if ( sampledColor.r <= 0.000001 && sampledColor.g <= 0.000001 && sampledColor.b <= 0.000001 ) discard;
+	outFragColor = sampledColor;
+}
\ No newline at end of file
diff --git a/bin/data/shaders/texture/vert.glsl b/bin/data/shaders/texture/vert.glsl
new file mode 100644
index 00000000..8e19c440
--- /dev/null
+++ b/bin/data/shaders/texture/vert.glsl
@@ -0,0 +1,14 @@
+#version 450
+
+layout (location = 0) out vec2 outUV;
+
+out gl_PerVertex 
+{
+	vec4 gl_Position;
+};
+
+void main() 
+{
+	outUV = vec2((gl_VertexIndex << 1) & 2, gl_VertexIndex & 2);
+	gl_Position = vec4(outUV * 2.0f + -1.0f, 0.0f, 1.0f);
+}
\ No newline at end of file
diff --git a/client/client/ext.cpp b/client/client/ext.cpp
new file mode 100644
index 00000000..9b96202e
--- /dev/null
+++ b/client/client/ext.cpp
@@ -0,0 +1,266 @@
+#include "../main.h"
+
+#include <uf/utils/window/window.h>
+#include <uf/utils/io/iostream.h>
+#include <uf/utils/image/image.h>
+#include <uf/utils/audio/audio.h>
+#include <uf/spec/terminal/terminal.h>
+#include <uf/utils/hook/hook.h>
+#include <uf/utils/thread/thread.h>
+#include <uf/utils/renderer/renderer.h>
+
+bool client::ready = false;
+bool client::terminated = false;
+uf::Window client::window;
+uf::Serializer client::config;
+
+void client::initialize() {
+	uf::IoStream::ncurses = true;
+	uf::renderer::device.window = &client::window;
+
+	ext::load();
+#if 1
+	client::config = ext::config;
+#else
+	/* Initialize config */ {
+		struct {
+			uf::Serializer ext;
+			uf::Serializer fallback;
+		} config;
+		/* Get configuration */ {
+			config.ext = ext::config.serialize();
+		}
+		/* Merge */ {
+			client::config = config.ext;
+			client::config.merge( config.fallback, true );
+		}
+	}
+#endif
+	/* Initialize window */ {
+		// Window size
+		pod::Vector2i size; {
+			size.x = client::config["window"]["size"]["x"].as<size_t>();
+			size.y = client::config["window"]["size"]["y"].as<size_t>();
+			// request system size
+			if ( size.x <= 0 && size.y <= 0 ) {
+				auto resolution = client::window.getResolution();
+				client::config["window"]["size"]["x"] = (size.x = resolution.x);
+				client::config["window"]["size"]["y"] = (size.y = resolution.y);
+			}
+		}
+		// Window title
+		uf::String title; {
+			title = client::config["window"]["title"].as<std::string>();
+		}
+		// Terminal window;
+		spec::terminal.setVisible( client::config["window"]["terminal"]["visible"].as<bool>() );
+		// Ncurses
+		uf::IoStream::ncurses = client::config["window"]["terminal"]["ncurses"].as<bool>();
+		// Window's context settings
+		uf::renderer::settings::width = size.x;
+		uf::renderer::settings::height = size.y;
+		client::window.create( size, title );
+	#if !UF_ENV_DREAMCAST
+		// Set refresh rate
+		ext::config["window"]["refresh rate"] = client::window.getRefreshRate();
+		// Miscellaneous
+		client::window.setVisible(client::config["window"]["visible"].as<bool>());
+		client::window.setCursorVisible(client::config["window"]["cursor"]["visible"].as<bool>());
+		client::window.setKeyRepeatEnabled(client::config["window"]["keyboard"]["repeat"].as<bool>());
+	//	client::window.centerWindow();
+	//	client::window.setPosition({0, 0});
+	//	client::window.setMouseGrabbed(true);
+
+		/* Set Icon */ if ( client::config["window"]["icon"].is<std::string>() ) {
+			uf::Image icon;
+			icon.open(client::config["window"]["icon"].as<std::string>());
+			client::window.setIcon({(int) icon.getDimensions().x, (int) icon.getDimensions().y}, ((uint8_t*)icon.getPixelsPtr()));
+		}
+		client::window.setTitle(title); {
+			uf::Serializer json;
+			std::string hook = "window:Title.Changed";
+			json["type"] = hook;
+			json["invoker"] = "os";
+			json["window"]["title"] = std::string(title);
+			uf::hooks.call( hook, json );
+		}
+	#endif
+	/*
+		uf::hooks.shouldPreferReadable();
+		if ( client::config["engine"]["hook"]["mode"] == "Readable" ) {
+
+		}
+	*/
+	}
+
+	#if UF_USE_OPENAL
+	/* Initialize OpenAL */ {
+		if ( !ext::oal.initialize() ) {
+			std::cerr << "[ERROR] AL failed to initialize!" << std::endl;
+			std::exit(EXIT_SUCCESS);
+			return;
+		}
+	}
+	#endif
+	
+	/* Initialize hooks */ {
+	//	if ( client::config["engine"]["hook"]["mode"] == "Both" || client::config["engine"]["hook"]["mode"] == "Readable" ) {
+			uf::hooks.addHook( "window:Mouse.CursorVisibility", [&](const ext::json::Value& json){
+				client::window.setCursorVisible(json["state"].as<bool>());
+				client::window.setMouseGrabbed(!json["state"].as<bool>());
+				client::config["mouse"]["visible"] = json["state"].as<bool>();
+				client::config["window"]["mouse"]["center"] = !json["state"].as<bool>();
+			});
+			uf::hooks.addHook( "window:Mouse.Lock", [&](const ext::json::Value& json){
+				if ( client::window.hasFocus() ) {
+					client::window.setMousePosition(client::window.getSize()/2);
+				}
+			});
+			uf::hooks.addHook( "window:Closed", [&](const ext::json::Value& json){
+				client::ready = false;
+			//	std::exit(EXIT_SUCCESS);
+			} );
+			uf::hooks.addHook( "window:Title.Changed", [&](const ext::json::Value& json){
+				if ( json["invoker"] != "os" ) {
+					if ( !ext::json::isObject( json["window"] ) ) return;
+					uf::String title = json["window"]["title"].as<std::string>();
+					client::window.setTitle(title);
+				}
+			} );
+			uf::hooks.addHook( "window:Resized", [&](const ext::json::Value& json){
+				pod::Vector2i size; {
+					size.x = json["window"]["size"]["x"].as<size_t>();
+					size.y = json["window"]["size"]["y"].as<size_t>();
+				}
+				if ( json["invoker"] != "os" ) {
+					client::window.setSize(size);
+				}
+				// Update viewport
+				if ( !ext::json::isArray( client::config["engine"]["ext"]["vulkan"]["framebuffer"]["size"] ) ) {
+					float scale = client::config["engine"]["ext"]["vulkan"]["framebuffer"]["size"].is<double>() ? client::config["engine"]["ext"]["vulkan"]["framebuffer"]["size"].as<float>() : 1;
+					uf::renderer::settings::width = size.x * scale;
+					uf::renderer::settings::height = size.y * scale;
+				}
+
+				uf::renderer::states::resized = true;
+			} );
+	/*
+		}
+		else if ( client::config["engine"]["hook"]["mode"] == "Both" || client::config["engine"]["hook"]["mode"] == "Optimal" ) {
+			uf::hooks.addHook( "window:Closed", [&](const uf::OptimalHook::argument_t& userdata)->uf::OptimalHook::return_t{
+				client::ready = false;
+				std::exit(EXIT_SUCCESS);
+				return NULL;
+			} );
+			uf::hooks.addHook( "window:Title.Changed", [&](const uf::OptimalHook::argument_t& userdata)->uf::OptimalHook::return_t{
+				// Hook information
+				struct Hook {
+					std::string type;
+					std::string invoker;
+					
+					struct {
+						std::string title;
+					} window;
+				};
+				const Hook& hook = uf::userdata::get<Hook>(userdata);
+				if ( hook.invoker != "os" ) {
+					uf::String title = hook.window.title;
+					client::window.setTitle(title);
+				}
+				return NULL;
+			} );
+			uf::hooks.addHook( "window:Resized", [&](const uf::OptimalHook::argument_t& userdata)->uf::OptimalHook::return_t{
+				// Hook information
+				struct Hook {
+					std::string type;
+					std::string invoker;
+					
+					struct {
+						pod::Vector2i size;
+					} window;
+				};
+				const Hook& hook = uf::userdata::get<Hook>(userdata);
+				if ( hook.invoker != "os" ) {
+					client::window.setSize(hook.window.size);
+				}
+				// Update viewport
+				return NULL;
+			} );
+		}
+	*/
+	}
+#if !UF_ENV_DREAMCAST
+	if ( client::config["window"]["mode"].as<std::string>() == "fullscreen" ) client::window.switchToFullscreen();
+	if ( client::config["window"]["mode"].as<std::string>() == "borderless" ) client::window.switchToFullscreen( true );
+#endif
+	client::ready = true;
+}
+void client::tick() {
+//	uf::hooks.call("system:Tick");
+	client::window.pollEvents();
+	// call mouse move
+	// query lock
+	if ( client::window.hasFocus() && client::config["window"]["mouse"]["center"].as<bool>() ) {
+		auto previous = client::window.getMousePosition();
+		client::window.setMousePosition(client::window.getSize()/2);
+		auto current = client::window.getMousePosition();
+
+		auto size = client::window.getSize();
+		uf::Serializer payload;
+		payload["invoker"] = "client";
+		payload["mouse"]["delta"]["x"] = previous.x - current.x;
+		payload["mouse"]["delta"]["y"] = previous.y - current.y;
+		payload["mouse"]["position"]["x"] = current.x;
+		payload["mouse"]["position"]["y"] = current.y;
+		payload["mouse"]["size"]["x"] = size.x;
+		payload["mouse"]["size"]["y"] = size.y;
+		payload["mouse"]["state"] = "???";
+		payload["type"] = "window:Mouse.Moved";
+		uf::hooks.call("window:Mouse.Moved", payload);
+	}
+/*
+{
+        "invoker" : "os",
+        "mouse" :
+        {
+                "delta" :
+                {
+                        "x" : -17,
+                        "y" : -12
+                },
+                "position" :
+                {
+                        "x" : 371,
+                        "y" : 276
+                },
+                "size" :
+                {
+                        "x" : 800,
+                        "y" : 600
+                },
+                "state" : "???"
+        },
+        "type" : "window:Mouse.Moved"
+}
+*/
+}
+
+void client::render() {
+	client::window.display();
+}
+
+void client::terminate() {
+	/* Close Threads */ {
+		uf::thread::terminate();
+	}
+
+	client::window.terminate();
+
+	#if UF_USE_OPENAL
+	if ( !ext::oal.terminate() ) {
+		std::cerr << "[ERROR] AL failed to terminate!" << std::endl;
+		std::exit(EXIT_SUCCESS);
+		return;
+	}
+	#endif
+}
\ No newline at end of file
diff --git a/client/dreamcast.gldc.inl b/client/dreamcast.gldc.inl
new file mode 100644
index 00000000..9ae27a74
--- /dev/null
+++ b/client/dreamcast.gldc.inl
@@ -0,0 +1,87 @@
+#include <GL/gl.h>
+#include <GL/glu.h>
+#include <GL/glkos.h>
+
+/* A general OpenGL initialization function.  Sets all of the initial parameters. */
+void InitGL(int Width, int Height)	        // We call this right after our OpenGL window is created.
+{
+    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);		// This Will Clear The Background Color To Black
+    glClearDepth(1.0);				// Enables Clearing Of The Depth Buffer
+    glDepthFunc(GL_LESS);				// The Type Of Depth Test To Do
+    glEnable(GL_DEPTH_TEST);			// Enables Depth Testing
+    glShadeModel(GL_SMOOTH);			// Enables Smooth Color Shading
+
+    glEnableClientState(GL_VERTEX_ARRAY); // Enable vertex arrays
+
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();				// Reset The Projection Matrix
+
+    gluPerspective(45.0f,(GLfloat)Width/(GLfloat)Height,0.1f,100.0f);	// Calculate The Aspect Ratio Of The Window
+
+    glMatrixMode(GL_MODELVIEW);
+}
+
+/* The function called when our window is resized (which shouldn't happen, because we're fullscreen) */
+void ReSizeGLScene(int Width, int Height)
+{
+    if (Height == 0)				// Prevent A Divide By Zero If The Window Is Too Small
+        Height = 1;
+
+    glViewport(0, 0, Width, Height);		// Reset The Current Viewport And Perspective Transformation
+
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+
+    gluPerspective(45.0f,(GLfloat)Width/(GLfloat)Height,0.1f,100.0f);
+    glMatrixMode(GL_MODELVIEW);
+}
+
+
+/* The main drawing function. */
+void DrawGLScene()
+{
+
+    const GLfloat triangle [] = {
+        0.0f, 1.0f, 0.0f,
+        1.0f, -1.0f, 0.0f,
+        -1.0f, -1.0f, 0.0f
+    };
+
+    const GLfloat square [] = {
+        -1.0f, 1.0f, 0.0f,
+        1.0f, 1.0f, 0.0f,
+        1.0f, -1.0f, 0.0f,
+        -1.0f, -1.0f, 0.0f
+    };
+
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);		// Clear The Screen And The Depth Buffer
+    glLoadIdentity();				// Reset The View
+
+    glTranslatef(-1.5f,0.0f,-6.0f);		// Move Left 1.5 Units And Into The Screen 6.0
+
+    glVertexPointer(3, GL_FLOAT, 0, triangle);
+    glDrawArrays(GL_TRIANGLES, 0, 3);
+
+    glTranslatef(3.0f,0.0f,0.0f);		        // Move Right 3 Units
+
+    glVertexPointer(3, GL_FLOAT, 0, square);
+    glDrawArrays(GL_QUADS, 0, 4);
+
+    // swap buffers to display, since we're double buffered.
+    glKosSwapBuffers();
+}
+
+int main(int argc, char **argv)
+{
+    glKosInit();
+
+    InitGL(640, 480);
+    ReSizeGLScene(640, 480);
+
+    while(1) {
+        UF_DEBUG_PRINT_MARKER();
+        DrawGLScene();
+    }
+
+    return 0;
+}
diff --git a/client/dreamcast.inl b/client/dreamcast.inl
new file mode 100644
index 00000000..f03a2f31
--- /dev/null
+++ b/client/dreamcast.inl
@@ -0,0 +1,82 @@
+/* 
+   KallistiOS 2.0.0
+
+   nehe02.c
+   (c)2014 Josh Pearson
+   (c)2001 Benoit Miller
+   (c)2000 Jeff Molofee
+*/
+
+#include <kos.h>
+
+#include <GL/gl.h>
+#include <GL/glu.h>
+#include <GL/glut.h>
+
+/*
+   The simplest OpenGL example ever!
+
+   Essentially the same thing as NeHe's lesson02 code.
+   To learn more, go to http://nehe.gamedev.net/.
+*/
+
+void draw_gl(void) {
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+    glLoadIdentity();
+    glTranslatef(-1.5f, 0.0f, -6.0f);
+
+    glBegin(GL_TRIANGLES);
+    glVertex3f(0.0f, 1.0f, 0.0f);
+    glVertex3f(-1.0f, -1.0f, 0.0f);
+    glVertex3f(1.0f, -1.0f, 0.0f);
+    glEnd();
+
+    glTranslatef(3.0f, 0.0f, 0.0f);
+
+    glBegin(GL_QUADS);
+    glVertex3f(-1.0f, 1.0f, 0.0f);
+    glVertex3f(1.0f, 1.0f, 0.0f);
+    glVertex3f(1.0f, -1.0f, 0.0f);
+    glVertex3f(-1.0f, -1.0f, 0.0f);
+    glEnd();
+}
+
+int main(int argc, char **argv) {
+    maple_device_t *cont;
+    cont_state_t *state;
+
+    /* Get basic stuff initialized */
+    printf("nehe02 beginning\n");
+    /* Notice we do not init the PVR here, that is handled by OpenGL */
+    glKosInit();
+
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    gluPerspective(45.0f, 640.0f / 480.0f, 0.1f, 100.0f);
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+
+    while(1) {
+        cont = maple_enum_type(0, MAPLE_FUNC_CONTROLLER);
+
+        /* Check key status */
+        state = (cont_state_t *)maple_dev_status(cont);
+
+        if(!state) {
+            printf("Error reading controller\n");
+            break;
+        }
+
+        if(state->buttons & CONT_START)
+            break;
+
+        /* Draw the "scene" */
+        draw_gl();
+
+        /* Finish the frame - Notice there is no glKosBegin/FinshFrame */
+        glutSwapBuffers();
+    }
+
+    return 0;
+}
diff --git a/client/main.cpp b/client/main.cpp
new file mode 100644
index 00000000..d90881e4
--- /dev/null
+++ b/client/main.cpp
@@ -0,0 +1,78 @@
+#include "main.h"
+
+#include <uf/utils/io/iostream.h>
+#include <uf/utils/time/time.h>
+
+#include <uf/utils/mempool/mempool.h>
+
+#if UF_NO_EXCEPTIONS
+	#define HANDLE_EXCEPTIONS 0
+#else
+	#define HANDLE_EXCEPTIONS 0
+#endif
+
+int main(int argc, char** argv){
+	for ( size_t i = 0; i < argc; ++i ) {
+		char* c_str = argv[i];
+		std::string string(argv[i]);
+		ext::arguments.emplace_back(string);
+	}
+
+	std::atexit([]{
+		uf::iostream << "Termination via std::atexit()!" << "\n";
+		client::terminated = !(client::ready = ext::ready = false);
+	});
+
+	client::initialize();
+	ext::initialize();
+
+	// For Multithreaded initialization
+	while ( !client::ready || !ext::ready ) {
+		static uf::Timer<long long> timer(false);
+		static double next = 1;
+		if ( !timer.running() ) timer.start();
+
+		if ( timer.elapsed().asDouble() >= next ) {
+			uf::iostream << "Waiting for " << ( client::ready ? "client" : "extension / engine" ) << " to initialize... Retrying in " << next << " seconds." << "\n";
+			next *= 2;
+		}
+	}
+	while ( client::ready && ext::ready ) {
+	#if HANDLE_EXCEPTIONS
+		try {	
+	#endif
+			static bool first = false; if ( !first ) { first = true;
+				uf::Serializer json;
+				std::string hook = "window:Resized";
+				json["type"] = hook;
+				json["invoker"] = "ext";
+
+				json["window"]["size"]["x"] = client::config["window"]["size"]["x"];
+				json["window"]["size"]["y"] = client::config["window"]["size"]["y"];
+				uf::hooks.call(hook, json);
+			}
+			client::tick();
+			ext::tick();
+			client::render();
+			ext::render();
+	#if HANDLE_EXCEPTIONS
+		} catch ( std::runtime_error& e ) {
+			uf::iostream << "RUNTIME ERROR: " << e.what() << "\n";
+			break;
+		} catch ( std::exception& e ) {
+			uf::iostream << "EXCEPTION ERROR: " << e.what() << "\n";
+			throw e;
+		} catch ( bool handled ) {
+			if (!handled) uf::iostream << "UNHANDLED ERROR: " << "???" << "\n";
+		} catch ( ... ) {
+			uf::iostream << "UNKNOWN ERROR: " << "???" << "\n";
+		}
+	#endif
+	}
+	if ( !client::terminated ) {
+		uf::iostream << "Natural termination!" << "\n";
+	}
+	ext::terminate();
+	client::terminate();
+	return 0;
+}
\ No newline at end of file
diff --git a/client/main.h b/client/main.h
new file mode 100644
index 00000000..2d07cad7
--- /dev/null
+++ b/client/main.h
@@ -0,0 +1,18 @@
+#pragma once
+#include <uf/ext/ext.h>
+
+#include <uf/utils/window/window.h>
+#include <uf/utils/serialize/serializer.h>
+#include <uf/utils/thread/thread.h>
+
+namespace client {
+	extern bool ready;
+	extern bool terminated;
+	extern uf::Window window;
+	extern uf::Serializer config;
+
+	void initialize();
+	void tick();
+	void render();
+	void terminate();
+}
\ No newline at end of file
diff --git a/data/audio/footstep/1.ogg b/data/audio/footstep/1.ogg
deleted file mode 100644
index ac3b6ef2..00000000
Binary files a/data/audio/footstep/1.ogg and /dev/null differ
diff --git a/data/audio/footstep/2.ogg b/data/audio/footstep/2.ogg
deleted file mode 100644
index 3690c438..00000000
Binary files a/data/audio/footstep/2.ogg and /dev/null differ
diff --git a/data/audio/ui/ding.ogg b/data/audio/ui/ding.ogg
deleted file mode 100644
index 7e757622..00000000
Binary files a/data/audio/ui/ding.ogg and /dev/null differ
diff --git a/data/audio/ui/hover.ogg b/data/audio/ui/hover.ogg
deleted file mode 100644
index 9dcc0703..00000000
Binary files a/data/audio/ui/hover.ogg and /dev/null differ
diff --git a/data/audio/ui/invalid select.ogg b/data/audio/ui/invalid select.ogg
deleted file mode 100644
index 725cba97..00000000
Binary files a/data/audio/ui/invalid select.ogg and /dev/null differ
diff --git a/data/audio/ui/main menu.ogg b/data/audio/ui/main menu.ogg
deleted file mode 100644
index 8c9cbf73..00000000
Binary files a/data/audio/ui/main menu.ogg and /dev/null differ
diff --git a/data/audio/ui/menu close.ogg b/data/audio/ui/menu close.ogg
deleted file mode 100644
index 9556d170..00000000
Binary files a/data/audio/ui/menu close.ogg and /dev/null differ
diff --git a/data/audio/ui/menu exit.ogg b/data/audio/ui/menu exit.ogg
deleted file mode 100644
index a813a3ba..00000000
Binary files a/data/audio/ui/menu exit.ogg and /dev/null differ
diff --git a/data/audio/ui/menu flip.ogg b/data/audio/ui/menu flip.ogg
deleted file mode 100644
index 6eab8e6e..00000000
Binary files a/data/audio/ui/menu flip.ogg and /dev/null differ
diff --git a/data/audio/ui/menu open.ogg b/data/audio/ui/menu open.ogg
deleted file mode 100644
index 65a60e65..00000000
Binary files a/data/audio/ui/menu open.ogg and /dev/null differ
diff --git a/data/audio/ui/register.ogg b/data/audio/ui/register.ogg
deleted file mode 100644
index b4861e2d..00000000
Binary files a/data/audio/ui/register.ogg and /dev/null differ
diff --git a/data/audio/ui/select.ogg b/data/audio/ui/select.ogg
deleted file mode 100644
index 7556cf90..00000000
Binary files a/data/audio/ui/select.ogg and /dev/null differ
diff --git a/data/audio/ui/turn.ogg b/data/audio/ui/turn.ogg
deleted file mode 100644
index ccb8f6d3..00000000
Binary files a/data/audio/ui/turn.ogg and /dev/null differ
diff --git a/data/cache/7d1b6aad265422f0b26f5759be9caad42032cf8babb8f24e1d5213310dd05621.png b/data/cache/7d1b6aad265422f0b26f5759be9caad42032cf8babb8f24e1d5213310dd05621.png
deleted file mode 100644
index ea0724d4..00000000
Binary files a/data/cache/7d1b6aad265422f0b26f5759be9caad42032cf8babb8f24e1d5213310dd05621.png and /dev/null differ
diff --git a/data/cache/80fb004ae52fc356c206aec46e7e2c7ee28c83a1cc3bbd015e89d4b279d30e1e.png b/data/cache/80fb004ae52fc356c206aec46e7e2c7ee28c83a1cc3bbd015e89d4b279d30e1e.png
deleted file mode 100644
index f931b692..00000000
Binary files a/data/cache/80fb004ae52fc356c206aec46e7e2c7ee28c83a1cc3bbd015e89d4b279d30e1e.png and /dev/null differ
diff --git a/data/cache/a9e4200047328c32c0f3749c4f1021e6a6a11cd1975f214b1436f0935b8e2a78.png b/data/cache/a9e4200047328c32c0f3749c4f1021e6a6a11cd1975f214b1436f0935b8e2a78.png
deleted file mode 100644
index b410bb84..00000000
Binary files a/data/cache/a9e4200047328c32c0f3749c4f1021e6a6a11cd1975f214b1436f0935b8e2a78.png and /dev/null differ
diff --git a/data/cache/f1613edc9c369861b2061d5d4aa869d4adbf62201ec190b112c0a028aaf5aac8.png b/data/cache/f1613edc9c369861b2061d5d4aa869d4adbf62201ec190b112c0a028aaf5aac8.png
deleted file mode 100644
index ec355c10..00000000
Binary files a/data/cache/f1613edc9c369861b2061d5d4aa869d4adbf62201ec190b112c0a028aaf5aac8.png and /dev/null differ
diff --git a/data/config.json b/data/config.json
deleted file mode 100644
index aac53fce..00000000
--- a/data/config.json
+++ /dev/null
@@ -1,166 +0,0 @@
-{
-	"engine": {
-		"scenes": {
-			"start": "McDonalds",
-			"lights": {
-				"max": 256,
-				"update threshold": 6,
-				"shadow threshold": 20
-			},
-			"textures": {
-				"max": 256
-			}
-		},
-		"ext": {
-			"vulkan": {
-				"validation": {
-					"enabled": false,
-					"filters": [
-						"MessageID = 0x4dae5635", // UNASSIGNED-CoreValidation-DrawState-InvalidImageLayout (false positive for cubemaps)
-						"MessageID = 0x71500fba", // VUID-vkDestroyDevice-device-00378 (don't care about a clean cleanup)
-						"MessageID = 0x609a13b", // UNASSIGNED-CoreValidation-Shader-OutputNotConsumed (from depth-only calls)
-						"MessageID = 0x23e43bb7" // UNASSIGNED-CoreValidation-Shader-InputNotProduced (from depth-only calls)
-					//	"MessageID = 0xe91b58a0" // VUID-vkCmdDrawIndexed-None-02686 (?)
-					]
-				},
-				"framebuffer": {
-					"size": 0.8,
-				//	"size": [ 640, 480, "NEAREST" ],
-				//	"size": [ 256, 224, "NEAREST" ],
-				//	"msaa": 16
-					"msaa": 4
-				},
-				"experimental": {
-					"rebuild on tick begin": false,
-					"wait on render end": false,
-					"individual pipelines": true,
-					"multithreaded command recording": true,
-					"deferred mode": "",
-				//	"deferred mode": "deferredSampling",
-					"deferred reconstruct position": true,
-					"deferred alias output to swapchain": true,
-					"hdr": false
-				},
-				"formats": {
-					"depth": "D32_SFLOAT",
-					"color": "R8G8B8A8_UNORM", // "R32G32B32A32_SFLOAT",
-					"normal": "R16G16B16A16_SFLOAT",
-					"position": "R16G16B16A16_SFLOAT"
-				},
-				"features": [
-					"independentBlend",
-					"deviceCoherentMemory",
-					"robustBufferAccess",
-					"samplerAnisotropy",
-					"sampleRateShading",
-					"nullDescriptor"
-				],
-				"extensions": {
-					"instance": [
-						"VK_KHR_get_physical_device_properties2",
-						"VK_KHR_get_surface_capabilities2"
-					],
-					"device": [
-					]
-				}
-			},
-			"lua": {
-				"main": "/main.lua",
-				"modules": {
-					"json": "/json.lua"
-				}
-			},
-			"vr" :  {
-				"enable" : false,
-				"manifest": "./data/openvr_manifest.json",
-				"swap eyes": false,
-				"dominant eye": 0,
-				"scale": 1
-			},
-			"ultralight": {
-				"enabled": true,
-				"scale": 1.5
-			},
-			"bullet": {
-				"iterations": 1,
-				"substeps": 12,
-				"timescale": 1,
-				"multithreaded": false,
-				"debug draw": {
-					"enabled": false,
-					"rate": 1.0
-				}
-			},
-			"discord": {
-				"enabled": false
-			}
-		},
-		"audio": {
-			"mute": false
-		},
-		"memory pool": {
-			"globalOverride": false,
-			"subPools": true,
-			"size": "512 MiB",
-			"pools": {
-				"entity": "128 MiB",
-				"userdata": "128 MiB",
-				"component": "128 MiB"
-			}
-		},
-		"hook" :  {
-			"mode" : "Readable"
-		},
-		"render modes": {
-			"gui": true,
-			"deferred": true,
-			"stereo deferred": false,
-			"multiview stereo deferred": false
-		},
-		"limiters": {
-			"deltaTime": 10,
-			"framerate": "auto"
-		},
-		"threads": {
-			"workers" : "auto",
-			"frame limiter": "auto"
-		},
-		"debug": {
-			"framerate": {
-				"print": false,
-				"every": 1
-			},
-			"garbage collection": {
-				"enabled": true,
-				"mode": 1,
-				"rate": 16,
-				"announce": true
-			},
-			"entity": {
-				"delete children on destroy": false,
-				"delete components on destroy": false
-			}
-		}
-	},
-	"window" : {
-		"terminal" :  {
-			"ncurses" : false,
-			"visible" : true
-		},
-		"keyboard" :  {
-			"repeat" : false
-		},
-		"cursor" :  {
-			"visible" : true,
-			"center" : false
-		},
-		"mode" : "windowed", // fullscreen, borderless, windowed
-		"icon" : "./data/textures/icon.png",
-		"size" :  {
-			"x" : 960,
-			"y" : 540
-		},
-		"title" : "Grimgram",
-		"visible" : true
-	}
-}
\ No newline at end of file
diff --git a/data/entities/gui.json b/data/entities/gui.json
deleted file mode 100644
index c0a9d77e..00000000
--- a/data/entities/gui.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-	"name": "Gui Manager",
-	"type": "Object",
-	"behaviors": [
-		"GuiManagerBehavior"
-	],
-	"ignore": false
-}
\ No newline at end of file
diff --git a/data/entities/gui/hud/hud.json b/data/entities/gui/hud/hud.json
deleted file mode 100644
index 0e1bf947..00000000
--- a/data/entities/gui/hud/hud.json
+++ /dev/null
@@ -1,23 +0,0 @@
-{
-	"name": "HUD",
-	"type": "Gui",
-	"ignore": false,
-	"assets": [
-		"./scripts/hud.lua"
-	],
-	"system": {
-		"clickable": false,
-		"hoverable": false
-	},
-	"transform": {
-		"position": [ 0, 0, 0 ],
-		"rotation": {
-			"axis": [ 0, 0, 1 ],
-			"angle": 0
-		},
-		"scale": [ 16, 16, 16 ]
-	},
-	"metadata": {
-
-	}
-}
\ No newline at end of file
diff --git a/data/entities/gui/hud/overlay.json b/data/entities/gui/hud/overlay.json
deleted file mode 100644
index 549ace3f..00000000
--- a/data/entities/gui/hud/overlay.json
+++ /dev/null
@@ -1,36 +0,0 @@
-{
-	"name": "HUD Overlay",
-	"type": "Gui",
-	"ignore": false,
-	"assets": [
-		{ "filename": "./textures/mp.png", "hash": "68e7c459f9aecd6815ff7df1e2eefa82db60a23713b0134f0bfc15d82f55453d" }
-	//	{ "filename": "./textures/ss2.png" }
-	],
-	"system": {
-		"clickable": false,
-		"hoverable": false
-	},
-	"transform": {
-		"position": [ 0, 0, 0 ],
-		"rotation": {
-			"axis": [ 0, 0, 1 ],
-			"angle": 0
-		},
-	//	"scale": [ 1.7776, -1, -1 ]
-		"scale": [ 1, 1, 1 ]
-	},
-	"metadata": {
-		"uv": [ 0, 0, 1, 1 ],
-	//	"color": [ 0.8, 0.8, 1, 1 ],
-	//	"color": [ 0.416, 0.573, 0.667, 1 ],
-		"color": [ 1, 1, 1, 1 ],
-		"location": "",
-		"scaling": "relative",
-	//	"depth": 0.1,
-	//	"alpha": 0.5,
-		"alpha": 0.75,
-		"mode": 1,
-		"gui layer": true,
-		"only model": true
-	}
-}
\ No newline at end of file
diff --git a/data/entities/gui/hud/scripts/hud.lua b/data/entities/gui/hud/scripts/hud.lua
deleted file mode 100644
index 17139407..00000000
--- a/data/entities/gui/hud/scripts/hud.lua
+++ /dev/null
@@ -1,154 +0,0 @@
-local scene = entities.currentScene()
-local controller = entities.controller()
-local metadata = ent:getComponent("Metadata")
-local masterdata = scene:getComponent("Metadata")
-
-local visorLayers = 5
-local children = {}
-for i=1, visorLayers do
-	children[i] = ent:loadChild("./overlay.json",true)
-end
-
-local soundEmitter = ent:loadChild("./sound.json",true)
-
-local timer = Timer.new()
-if not timer:running() then timer:start() end
-
-Static = {
-	values = {},
-	get = function( obj )
-		if obj == nil then
-			obj = scene
-		end
-		if Static.values[""..obj:uid()] == nil then
-			Static.values[""..obj:uid()] = {}
-		end
-		return Static.values[""..obj:uid()]
-	end
-}
-
-local lerper = {
-	to = Quaternion(0,0,0,1),
-	from = Quaternion(0,0,0,1),
-	a = 0
-}
-
-local rotate = function( delta )	
-	delta.x = delta.x * 0.1
-	delta.y = delta.y * 0.1
-
-	local transform = ent:getComponent("Transform")
-	local rotation = {
-		x = Quaternion.axisAngle( Vector3f(0, 1, 0), delta.x ),
-		y = Quaternion.axisAngle( Vector3f(1, 0, 0), delta.y )
-	}
-
-	lerper.a = 0
-	lerper.from = Quaternion.multiply( transform.orientation, rotation.x:multiply(rotation.y) )
-	transform.orientation = lerper.from
-	for k, obj in pairs(children) do
-		obj:getComponent("Transform").orientation = transform.orientation
-	end
-end
-
-local windowSize = masterdata["system"]["config"]["window"]["size"];
-local entTransform = ent:getComponent("Transform")
-entTransform.scale.x = entTransform.scale.x * windowSize.x / windowSize.y;
-
-for k, obj in pairs(children) do
-	local transform = obj:getComponent("Transform")
-	transform.scale = entTransform.scale;
-	transform.position.z = -0.5 + ((k-1) * 0.005)
-end
-
-ent:addHook( "window:Resized", function( payload )
-	if entTransform.scale.y == entTransform.scale.z then
-		entTransform.scale.x = entTransform.scale.y * payload["window"]["size"]["x"] / payload["window"]["size"]["y"];
-	end
-
-	for k, obj in pairs(children) do
-		local transform = obj:getComponent("Transform")
-		transform.scale = entTransform.scale;
-	end
-end )
-
-ent:addHook( "controller:Camera.Rotated", function( payload )
-	rotate( {
-		x = -payload.angle.yaw,
-		y = -payload.angle.pitch
-	})
---[[
-	local transform = ent:getComponent("Transform")
-	lerper.a = 0
-	local counterOrientation = Quaternion( payload.delta[1], payload.delta[2], payload.delta[3], payload.delta[4] ):inverse()
-	lerper.from = Quaternion.multiply( transform.orientation, counterOrientation )
-	transform.orientation = lerper.from
-	for k, obj in pairs(children) do
-		obj:getComponent("Transform").orientation = transform.orientation
-	end
-]]
-end )
---[[
-ent:addHook( "window:Mouse.Moved", function( payload )
-	if payload.invoker ~= "client" then return end
-
-	local delta = payload.mouse.delta
-	local size = payload.mouse.size
-
-	if delta == nil or size == nil then return end
-	if delta.x == 0 or delta.y == 0 then return end
-
-	delta.x = -delta.x / size.x 
-	delta.y = -delta.y / size.y 
-
-	rotate( delta )
-end )
-]]
-
-ent:bind( "tick", function(self)
-	for k, obj in pairs(children) do
-		local metadata = obj:getComponent("Metadata")
-		local glow = math.sin(time.current()) * 0.5 + 0.5 -- constrained to [0,1]
-		glow = glow * 0.2 + 0.65 -- constrained to [0.65, 0.85]
-		metadata["alpha"] = glow
-		obj:setComponent("Metadata", metadata)
-	end
-
-	local controllerTransform = controller:getComponent("Transform")
-	local controllerCamera = controller:getComponent("Camera")
-	local controllerCameraTransform = controllerCamera:getTransform()
-	local transform = ent:getComponent("Transform")
-	
-	local speed = 2.5
-	if lerper.a == 1 then return end
-	lerper.a = lerper.a + time.delta() * speed
-	if lerper.a > 1 then lerper.a = 1 end
-
-	transform.orientation = lerper.from:slerp( lerper.to, lerper.a )
-	local orientation = transform.orientation
-	for k, obj in pairs(children) do
-		local transform = obj:getComponent("Transform")
-		transform.orientation = orientation
-		transform.model = controllerCamera:getProjection() * Matrix4f.translate( transform.position ) * transform.orientation:matrix() * Matrix4f.scale( transform.scale ) --Matrix4f.scale( Vector3f( 1.7776 * 2, 2, 2 ) )
-	end
-end )
-
---[[
-	controller:callHook( "object:UpdateMetadata.%UID%", {
-		path = "overlay.position",
-		value = {
-			[1] = position.x,
-			[2] = position.y,
-			[3] = position.z
-		}
-	} )
-	controller:callHook( "object:UpdateMetadata.%UID%", {
-		path = "overlay.orientation",
-		value = {
-			[1] = orientation.x,
-			[2] = orientation.y,
-			[3] = orientation.z,
-			[4] = orientation.w
-		}
-	} )
-]]
\ No newline at end of file
diff --git a/data/entities/gui/hud/sound.json b/data/entities/gui/hud/sound.json
deleted file mode 100644
index 521052cd..00000000
--- a/data/entities/gui/hud/sound.json
+++ /dev/null
@@ -1,38 +0,0 @@
-{
-	"type": "Object",
-	"name": "Sound Emitter",
-	"ignore": false,
-	"assets": [
-	],
-	"behaviors": [
-		"SoundEmitterBehavior"
-	],
-	"transform": {
-		"position": [ 0, 0, 0 ],
-		"rotation": {
-			"axis": [ 0, 1, 0 ],
-			"angle": 0
-		},
-		"scale": [ 1, 1, 1 ]
-	},
-	"system": {
-		"hot reload": {
-			"enabled": true
-		},
-		"defaults": {
-			"render": true,
-			"asset load": true
-		},
-		"load": {
-			"ignore": true
-		}
-	},
-	"metadata": {
-		"audio": {
-			"spatial": false,
-			"loop": false,
-			"volume": "sfx",
-			"rolloffFactor": 2
-		}
-	}
-}
\ No newline at end of file
diff --git a/data/entities/gui/mainmenu/circle-in.json b/data/entities/gui/mainmenu/circle-in.json
deleted file mode 100644
index 2bc77fd8..00000000
--- a/data/entities/gui/mainmenu/circle-in.json
+++ /dev/null
@@ -1,25 +0,0 @@
-{
-	"name": "Menu: Circle Inner",
-	"type": "Gui",
-	"ignore": false,
-	"transform": {
-		"position": [ 0.86, 0.86, 0 ],
-		"rotation": {
-			"axis": [ 1, 0, 0 ],
-			"angle": 0
-		},
-		"scale": [ 1, 1, 1 ]
-	},
-	"clickable": false,
-	"hoverable": false,
-	"metadata": {
-		"uv": [ 0, 0, 1, 1 ],
-		"color": [ 1, 1, 1, 0.8 ],
-		"location": "",
-		"scaling": [ 0.64, 1 ],
-		"mode": "flat"
-	},
-	"assets": [
-		"https://cdn..xyz//unity/Android/sprite/sprite_magiccircle_in2.png"
-	]
-}
\ No newline at end of file
diff --git a/data/entities/gui/mainmenu/circle-out.json b/data/entities/gui/mainmenu/circle-out.json
deleted file mode 100644
index 0fca3b79..00000000
--- a/data/entities/gui/mainmenu/circle-out.json
+++ /dev/null
@@ -1,25 +0,0 @@
-{
-	"name": "Menu: Circle Outer",
-	"type": "Gui",
-	"ignore": false,
-	"transform": {
-		"position": [ 0.86, 0.86, 0 ],
-		"rotation": {
-			"axis": [ 1, 0, 0 ],
-			"angle": 0
-		},
-		"scale": [ 1, 1, 1 ]
-	},
-	"clickable": false,
-	"hoverable": true,
-	"metadata": {
-		"uv": [ 0, 0, 1, 1 ],
-		"color": [ 1, 1, 1, 0.8 ],
-		"location": "",
-		"scaling": [ 0.64, 1 ],
-		"mode": "flat"
-	},
-	"assets": [
-		"https://cdn..xyz//unity/Android/sprite/sprite_magiccircle_out2.png"
-	]
-}
\ No newline at end of file
diff --git a/data/entities/gui/mainmenu/main-text.json b/data/entities/gui/mainmenu/main-text.json
deleted file mode 100644
index a1897789..00000000
--- a/data/entities/gui/mainmenu/main-text.json
+++ /dev/null
@@ -1,26 +0,0 @@
-{
-	"name": "Menu: Main Text",
-	"type": "Gui",
-	"ignore": false,
-	"transform": {
-		"position": [ -0.922623, -0.854923, 0 ],
-		"rotation": {
-			"axis": [ 0, 0, 1 ],
-			"angle": 0
-		},
-		"scale": [ 1, 1, 1 ]
-	},
-	"metadata": {
-		"uv": [ 0, 0, 1, 1 ],
-		"location": "",
-		"scaling": "relative",
-		"debug": {
-			"moveable": false
-		},
-		"text settings": {
-			"scale": 2,
-			"font": "Coolvetica.ttf",
-			"string": "Grimgram"
-		}
-	}
-}
\ No newline at end of file
diff --git a/data/entities/gui/mainmenu/menu.json b/data/entities/gui/mainmenu/menu.json
deleted file mode 100644
index 3556c418..00000000
--- a/data/entities/gui/mainmenu/menu.json
+++ /dev/null
@@ -1,30 +0,0 @@
-{
-	"name": "Gui: Menu",
-	"type": "Gui",
-	"ignore": false,
-	"assets": [
-		"./textures/menu.png",
-		"./scripts/menu.lua"
-	],
-	"system": {
-		"clickable": true,
-		"hoverable": true
-	},
-	"transform": {
-		"position": [ 0, 0, 0 ],
-		"rotation": {
-			"axis": [ 0, 0, 1 ],
-			"angle": 0
-		},
-		"scale": [ 1, 1, 1 ]
-	},
-	"metadata": {
-		"experimental": true,
-		"uv": [ 0, 0, 1, 1 ],
-		"color": [ 1, 1, 1, 1 ],
-		"location": "",
-		"scaling": "relative",
-		"depth": 0.2,
-		"mode": "flat"
-	}
-}
\ No newline at end of file
diff --git a/data/entities/gui/mainmenu/quit.json b/data/entities/gui/mainmenu/quit.json
deleted file mode 100644
index 46d74135..00000000
--- a/data/entities/gui/mainmenu/quit.json
+++ /dev/null
@@ -1,35 +0,0 @@
-{
-	"name": "Menu: Close Option",
-	"type": "Gui",
-	"ignore": false,
-	"transform": {
-		"position": [ -0.75622, 0.638136, 0 ],
-		"rotation": {
-			"axis": [ 0, 0, 1 ],
-			"angle": 0
-		},
-		"scale": [ 1, 1, 1 ]
-	},
-	"clickable": true,
-	"hoverable": true,
-	"metadata": {
-		"uv": [ 0, 0, 1, 1 ],
-		"location": "",
-		"scaling": "relative",
-		"debug": {
-			"moveable": false
-		},
-		"events": {
-			"click": {
-				"name": "system:Quit",
-				"payload": {
-					"scene": "StartMenu"
-				}
-			}
-		},
-		"text settings": {
-			"legacy": false,
-			"string": "Quit"
-		}
-	}
-}
\ No newline at end of file
diff --git a/data/entities/gui/mainmenu/scripts/menu.lua b/data/entities/gui/mainmenu/scripts/menu.lua
deleted file mode 100644
index 30cddf68..00000000
--- a/data/entities/gui/mainmenu/scripts/menu.lua
+++ /dev/null
@@ -1,142 +0,0 @@
-Static = {
-	values = {},
-	get = function( obj )
-		if Static.values[""..obj:uid()] == nil then
-			Static.values[""..obj:uid()] = {}
-		end
-		return Static.values[""..obj:uid()]
-	end
-}
-
-local scene = entities.currentScene()
-local controller = entities.controller()
-local camera = controller:getComponent("Camera")
-local metadata = ent:getComponent("Metadata")
-local masterdata = scene:getComponent("Metadata")
-
-local children = {
-	mainText = ent:loadChild("./main-text.json",true),
-	circleOut = ent:loadChild("./circle-out.json",true),
-	circleIn = ent:loadChild("./circle-in.json",true),
-	start = ent:loadChild("./start.json",true),
-	quit = ent:loadChild("./quit.json",true),
-}
-
-local timer = Timer.new()
-if not timer:running() then timer:start() end
-
-local playSound = function( key )
-	local url = "/ui/" .. key .. ".ogg"
-	local assetLoader = scene:getComponent("Asset")
-	assetLoader:cache(string.resolveURI(url), ent:formatHookName("asset:Load.%UID%"))
-end
-local destination = function( obj, x, y, z )
-	local static = Static.get(obj)
-	local transform = obj:getComponent("Transform")
-	static.from = Vector3f(x or transform.position.x, y or transform.position.y, z or transform.position.z)
-end
-
-pcall( function()
-	local metadata = controller:getComponent("Metadata")
-	local json = json.readFromFile("./data/entities/player.json");
-	controller:callHook("object:UpdateMetadata.%UID%", {
-		overlay = json["metadata"]["overlay"]
-	})
-	camera:update(true);
-end )
-
-destination(children.mainText, nil, -2, 0)
-destination(children.circleOut, nil, -2, 0)
-destination(children.circleIn, nil, 2, 0)
-destination(children.start, -1.5, nil, 0)
-destination(children.quit, -1.5, nil, 0)
-
-ent:addHook("asset:Load.%UID%", function( json )
-	local filename = json["filename"]
-	if filename == "" or string.extension( filename ) ~= "ogg" then return false end
-
-	local sfx = ent:getComponent("Audio")
-	if not sfx:playing() then sfx:stop() end
-	sfx:load( filename )
-	sfx:setVolume( masterdata["volumes"]["sfx"] )
-	sfx:play()
-
-	return true
-end )
-
-ent:bind( "tick", function(self)
-	local static = Static.get(self)
-	if not static.alpha then
-		static.alpha = 0
-	end
-
-	metadata["initialized"] = true;
-	if  static.alpha >= 1.0 then
-		static.alpha = 1.0
-	else
-		static.alpha = static.alpha + time.delta() * 1.5
-	end
-
-	-- make background glow
-	local glow = 1 + math.sin(1.25 * time.current()) * 0.125
-	metadata["color"][1] = glow
-	metadata["color"][2] = glow
-	metadata["color"][3] = glow
-	metadata["alpha"] = static.alpha;
-	self:setComponent("Metadata", metadata)
-
-	camera:update(true);
-
-	-- iterate children in batch
-	for k, v in pairs(children) do
-		if v:uid() <= 0 then goto continue end
-
-		-- set alpha
-		local metadata = v:getComponent("Metadata")
-		metadata["alpha"] = static.alpha
-		v:setComponent("Metadata", metadata)
-
-		local transform = v:getComponent("Transform")
-		local static = Static.get(v)
-		-- translation
-		if not static.from then goto continue end
-		if not static.to then static.to = Vector3f(transform.position) end
-		if not static.delta then static.delta = 0 end
-
-		if static.delta >= 1 then
-			static.delta = 1
-		else
-			static.delta = static.delta + time.delta() * 1.5
-			transform.position = Vector3f.lerp( static.from, static.to, static.delta )
-		end
-
-		::continue::
-	end	
-
-	-- circle in
-	child = children.circleIn
-	if child:uid() > 0 then
-		local static = Static.get( child )
-
-		local transform = child:getComponent("Transform")
-		local metadata = child:getComponent("Metadata")
-
-		-- rotation
-		local speed = metadata["hovered"] and 0.25 or 0.0125
-		static.time = (static.time or 0) + time.delta() * -speed
-		transform.orientation = Quaternion.axisAngle( Vector3f(0, 0, 1), static.time )
-	end
-	-- circle out
-	child = children.circleOut
-	if child:uid() > 0 then
-		local static = Static.get( child )
-
-		local transform = child:getComponent("Transform")
-		local metadata = child:getComponent("Metadata")
-
-		-- rotation
-		local speed = metadata["hovered"] and 0.25 or 0.0125
-		static.time = (static.time or 0) + time.delta() * speed
-		transform.orientation = Quaternion.axisAngle( Vector3f(0, 0, 1), static.time )
-	end
-end )
\ No newline at end of file
diff --git a/data/entities/gui/mainmenu/start.json b/data/entities/gui/mainmenu/start.json
deleted file mode 100644
index 1b3ca801..00000000
--- a/data/entities/gui/mainmenu/start.json
+++ /dev/null
@@ -1,35 +0,0 @@
-{
-	"name": "Menu: Start Option",
-	"type": "Gui",
-	"ignore": false,
-	"transform": {
-		"position": [  -0.75622, 0.446468, 0 ],
-		"rotation": {
-			"axis": [ 0, 0, 1 ],
-			"angle": 0
-		},
-		"scale": [ 1, 1, 1 ]
-	},
-	"clickable": true,
-	"hoverable": true,
-	"metadata": {
-		"uv": [ 0, 0, 1, 1 ],
-		"location": "",
-		"scaling": "relative",
-		"debug": {
-			"moveable": false
-		},
-		"events": {
-			"click": {
-				"name": "game:Scene.Load",
-				"payload": {
-					"scene": "SS2"
-				}
-			}
-		},
-		"text settings": {
-			"string": "Start",
-			"string1": "スタート"
-		}
-	}
-}
\ No newline at end of file
diff --git a/data/entities/gui/mainmenu/textures/menu.png b/data/entities/gui/mainmenu/textures/menu.png
deleted file mode 100644
index 0d74366e..00000000
Binary files a/data/entities/gui/mainmenu/textures/menu.png and /dev/null differ
diff --git a/data/entities/gui/mainmenu/textures/square.png b/data/entities/gui/mainmenu/textures/square.png
deleted file mode 100644
index 3fd47364..00000000
Binary files a/data/entities/gui/mainmenu/textures/square.png and /dev/null differ
diff --git a/data/entities/gui/pause/circle-in.json b/data/entities/gui/pause/circle-in.json
deleted file mode 100644
index 21162ef3..00000000
--- a/data/entities/gui/pause/circle-in.json
+++ /dev/null
@@ -1,23 +0,0 @@
-{
-	"name": "Menu: Circle Inner",
-	"type": "Gui",
-	"ignore": false,
-	"transform": {
-		"position": [ -0.86, 0.86, 0 ],
-		"rotation": {
-			"axis": [ 1, 0, 0 ],
-			"angle": 0
-		},
-		"scale": [ 1, 1, 1 ]
-	},
-	"metadata": {
-		"uv": [ 0, 0, 1, 1 ],
-		"color": [ 1, 1, 1, 0.8 ],
-		"location": "",
-		"scaling": [ 0.64, 1 ],
-		"mode": "flat"
-	},
-	"assets": [
-		"https://cdn..xyz//unity/Android/sprite/sprite_magiccircle_in.png"
-	]
-}
\ No newline at end of file
diff --git a/data/entities/gui/pause/circle-out.json b/data/entities/gui/pause/circle-out.json
deleted file mode 100644
index 9af75d9f..00000000
--- a/data/entities/gui/pause/circle-out.json
+++ /dev/null
@@ -1,25 +0,0 @@
-{
-	"name": "Menu: Circle Outer",
-	"type": "Gui",
-	"ignore": false,
-	"transform": {
-		"position": [ -0.86, 0.86, 0 ],
-		"rotation": {
-			"axis": [ 1, 0, 0 ],
-			"angle": 0
-		},
-		"scale": [ 1, 1, 1 ]
-	},
-	"clickable": false,
-	"hoverable": true,
-	"metadata": {
-		"uv": [ 0, 0, 1, 1 ],
-		"color": [ 1, 1, 1, 0.8 ],
-		"location": "",
-		"scaling": [ 0.64, 1 ],
-		"mode": "flat"
-	},
-	"assets": [
-		"https://cdn..xyz//unity/Android/sprite/sprite_magiccircle_out.png"
-	]
-}
\ No newline at end of file
diff --git a/data/entities/gui/pause/close.json b/data/entities/gui/pause/close.json
deleted file mode 100644
index 2c863137..00000000
--- a/data/entities/gui/pause/close.json
+++ /dev/null
@@ -1,30 +0,0 @@
-{
-	"name": "Menu: Close Option",
-	"type": "Gui",
-	"ignore": false,
-	"transform": {
-		"position": [ -0.65544, -0.339642, 0 ],
-		"rotation": {
-			"axis": [ 0, 0, 1 ],
-			"angle": 0
-		},
-		"scale": [ 0.156407, 0.0788377, 1 ]
-	},
-	"clickable": true,
-	"hoverable": true,
-	"metadata": {
-		"uv": [ 0, 0, 1, 1 ],
-		"location": "",
-		"scaling": "relative",
-		"events": {
-			"click": {
-				"name": "menu:Close.%P-UID%",
-				"payload": {}
-			}
-		},
-		"text settings": {			
-			"string": "Close",
-			"string1": "クローズ"
-		}
-	}
-}
\ No newline at end of file
diff --git a/data/entities/gui/pause/command-text.json b/data/entities/gui/pause/command-text.json
deleted file mode 100644
index 303cd2b1..00000000
--- a/data/entities/gui/pause/command-text.json
+++ /dev/null
@@ -1,25 +0,0 @@
-{
-	"name": "Menu: Command Text",
-	"type": "Gui",
-	"ignore": false,
-	"transform": {
-		"position": [  -0.830591, -0.699509, 0 ],
-		"rotation": {
-			"axis": [ 1, 0, 0 ],
-			"angle": 0
-		},
-		"scale": [ 0.258737, 0.115371, 1 ]
-	},
-	"metadata": {
-		"uv": [ 0, 0, 1, 1 ],
-		"location": "",
-		"scaling": "relative",
-		"text settings": {
-			"stroke": [ 1, 0.749, 0.368, 1 ],
-			"color": [ 1, 0.749, 0.368, 1 ],
-
-			"string": "Menu",
-			"string1": "コマンド"
-		}
-	}
-}
\ No newline at end of file
diff --git a/data/entities/gui/pause/icon.json b/data/entities/gui/pause/icon.json
deleted file mode 100644
index 3176abf4..00000000
--- a/data/entities/gui/pause/icon.json
+++ /dev/null
@@ -1,25 +0,0 @@
-{
-	"name": "Gui: Icon",
-	"type": "Gui",
-	"ignore": false,
-	"transform": {
-		"position": [ 0, 0, 0 ],
-		"rotation": {
-			"axis": [ 0, 0, 1 ],
-			"angle": 0
-		},
-		"scale": [ 1, 1, 1 ]
-	},
-	"metadata": {
-		"gui": {
-			"position": [ -0.875, -0.775, 0 ],
-			"uv": [ 0, 0, 1, 1 ],
-			"color": [ 1, 1, 1, 1 ],
-			"location": "",
-			"scaling": "fixed"
-		}
-	},
-	"assets": [
-		"https://cdn..xyz//unity/Android/icon/icon_agyou01_skin1.png"
-	]
-}
\ No newline at end of file
diff --git a/data/entities/gui/pause/main-text.json b/data/entities/gui/pause/main-text.json
deleted file mode 100644
index 244c0a0f..00000000
--- a/data/entities/gui/pause/main-text.json
+++ /dev/null
@@ -1,23 +0,0 @@
-{
-	"name": "Menu: Main Scroller",
-	"type": "Gui",
-	"ignore": true,
-	"transform": {
-		"position": [ 0.98, -2, 0 ],
-		"rotation": {
-			"axis": [ 0, 0, 1 ],
-			"angle": 1.5707963
-		},
-		"scale": [ 0.16, 1, 1 ]
-	},
-	"hoverable": true,
-	"metadata": {
-		"uv": [ 0, 0, 1, 1 ],
-		"color": [ 0.113, 0.756, 0.988, 0.4 ],
-		"location": "",
-		"scaling": "relative"
-	},
-	"assets": [
-		"./textures/main.png"
-	]
-}
\ No newline at end of file
diff --git a/data/entities/gui/pause/menu.json b/data/entities/gui/pause/menu.json
deleted file mode 100644
index 4c981bf9..00000000
--- a/data/entities/gui/pause/menu.json
+++ /dev/null
@@ -1,29 +0,0 @@
-{
-	"name": "Gui: Menu",
-	"type": "Gui",
-	"behaviors": [
-		"GuiBehavior"
-	],
-	"ignore": false,
-	"transform": {
-		"position": [ 0, 0, 0 ],
-		"rotation": {
-			"axis": [ 0, 0, 1 ],
-			"angle": 0
-		},
-		"scale": [ 1, 1, 1 ]
-	},
-	"metadata": {
-		"uv": [ 0, 0, 1, 1 ],
-		"color": [ 0.1, 0.05, 0.1, 0.5 ],
-		"location": "",
-		"scaling": "relative",
-	//	"depth": 0.2,
-		"alpha": 1,
-		"mode": 1
-	},
-	"assets": [
-	//	"./textures/menu.png",
-		"./scripts/menu.lua"
-	]
-}
\ No newline at end of file
diff --git a/data/entities/gui/pause/quit.json b/data/entities/gui/pause/quit.json
deleted file mode 100644
index 86aa526c..00000000
--- a/data/entities/gui/pause/quit.json
+++ /dev/null
@@ -1,43 +0,0 @@
-{
-	"name": "Menu: Close Option",
-	"type": "Gui",
-	"ignore": false,
-	"transform": {
-		"position": [ -0.65544, -0.157698, 0 ],
-		"rotation": {
-			"axis": [ 0, 0, 1 ],
-			"angle": 0
-		},
-		"scale": [ 0.156407, 0.0788377, 1 ]
-	},
-	"clickable": true,
-	"hoverable": true,
-	"metadata": {
-		"uv": [ 0, 0, 1, 1 ],
-		"location": "",
-		"scaling": "relative",
-		"debug": {
-			"moveable": true
-		},
-		"events": {
-			"click": [
-				{
-					"name": "menu:Close.%P-UID%",
-					"payload": {
-						"callback": {
-							"name": "game:Scene.Load",
-							"payload": {
-								"scene": "StartMenu"
-							},
-							"scope": "scene"
-						}
-					}
-				}
-			]
-		},
-		"text settings": {			
-			"string": "Quit",
-			"string1": "終了�る"
-		}
-	}
-}
\ No newline at end of file
diff --git a/data/entities/gui/pause/scripts/menu.lua b/data/entities/gui/pause/scripts/menu.lua
deleted file mode 100644
index d755af28..00000000
--- a/data/entities/gui/pause/scripts/menu.lua
+++ /dev/null
@@ -1,194 +0,0 @@
-local scene = entities.currentScene()
-local metadata = ent:getComponent("Metadata")
-local masterdata = scene:getComponent("Metadata")
-
-local children = {
-	mainText = ent:loadChild("./main-text.json",true),
-	circleOut = ent:loadChild("./circle-out.json",true),
-	circleIn = ent:loadChild("./circle-in.json",true),
-	coverBar = ent:loadChild("./yellow-box.json",true),
-	commandText = ent:loadChild("./command-text.json",true),
-	tenkouseiOption = ent:loadChild("./tenkousei.json",true),
-	closeOption = ent:loadChild("./close.json",true),
-	quit = ent:loadChild("./quit.json",true),
-}
-
-local soundEmitter = ent:loadChild("./sound.json",true)
-
-local timer = Timer.new()
-if not timer:running() then timer:start() end
-
-Static = {
-	values = {},
-	get = function( obj )
-		if obj == nil then
-			obj = scene
-		end
-		if Static.values[""..obj:uid()] == nil then
-			Static.values[""..obj:uid()] = {}
-		end
-		return Static.values[""..obj:uid()]
-	end
-}
-
-local destination = function( obj, x, y, z )
-	local static = Static.get(obj)
-	local transform = obj:getComponent("Transform")
-	static.from = Vector3f(x or transform.position.x, y or transform.position.y, z or transform.position.z)
-end
--- circleOut
-destination(children.circleOut, nil, -2, 0)
-destination(children.circleIn, nil, 2, 0)
-destination(children.coverBar, -1.5, nil, 0)
-destination(children.commandText, -1.5, nil, 0)
-destination(children.tenkouseiOption, -1.5, nil, 0)
-destination(children.closeOption, -1.5, nil, 0)
-destination(children.quit, -1.5, nil, 0)
-
-local playSound = function( key )
-	local url = "/ui/" .. key .. ".ogg"
-	local assetLoader = scene:getComponent("Asset")
-	assetLoader:cache(string.resolveURI(url), soundEmitter:formatHookName("asset:Load.%UID%"), "")
-end
-
-ent:addHook("menu:Close.%UID%", function( json )
-	playSound("menu close")
-
-	metadata["system"]["hooks"]["onClose"] = json["callback"];
-	metadata["system"]["closing"] = true;
-	ent:setComponent("Metadata", metadata)
-end )
-
---[[
-ent:addHook("asset:Load.%UID%", function( json )
-	local filename = json["filename"]
-	if filename == "" or string.extension( filename ) ~= "ogg" then return false end
-	local sfx = ent:getComponent("Audio")
-	if not sfx:playing() then sfx:stop() end
-	sfx:load( filename )
-	sfx:setVolume( masterdata["volumes"]["sfx"] )
-	sfx:play()
-	return true
-end )
-]]
-playSound("menu open")
-
-ent:bind( "tick", function(self)
-	local static = Static.get(self)
-	if not static.alpha then
-		static.alpha = 0
-	end
-
-	-- handle closing
-	if metadata["system"]["closing"] then
-		if static.alpha <= 0 then
-			static.alpha = 0
-			metadata["system"]["closing"] = false
-			metadata["system"]["closed"] = true
-		else
-			static.alpha = static.alpha - time.delta()
-		end
-	elseif metadata["system"]["closed"] then
-		timer:stop()
-		local callback = metadata["system"]["hooks"]["onClose"]
-		if callback then
-			local payload = callback["payload"]
-			local target = self
-			if callback["scope"] == "parent" then
-				target = ent:getParent()
-			elseif callback["scope"] == "scene" then
-				target = scene
-			end
-
-			if type(callback["delay"]) == "number" and target:uid() ~= self:uid() then
-				target:queueHook( callback["name"], payload, callback["delay"] );
-			else
-				target:callHook( callback["name"], payload );
-			end
-		end
-		entities.destroy(self)
-		-- scene:queueHook("system:Destroy", { uid = self:uid() }, 0)
-		return
-	else
-		if not metadata["initialized"] then
-			static.alpha = 0
-		end
-		metadata["initialized"] = true;
-		if  static.alpha >= 1.0 then
-			static.alpha = 1.0
-		else
-			static.alpha = static.alpha + time.delta() * 1.5
-		end
-	end
-
-	metadata["alpha"] = static.alpha;
-	self:setComponent("Metadata", metadata)
-	-- set alphas
-	for k, v in pairs(children) do
-		if v:uid() <= 0 then goto continue end
-
-		-- set alpha
-		local metadata = v:getComponent("Metadata")
-		metadata["alpha"] = static.alpha
-		v:setComponent("Metadata", metadata)
-
-		local transform = v:getComponent("Transform")
-		local static = Static.get(v)
-		-- translation
-		if not static.from then goto continue end
-		if not static.to then static.to = Vector3f(transform.position) end
-		if not static.delta then static.delta = 0 end
-
-		if static.delta >= 1 then
-			static.delta = 1
-		else
-			static.delta = static.delta + time.delta() * 1.5
-			transform.position = Vector3f.lerp( static.from, static.to, static.delta )
-		end
-
-		::continue::
-	end
-
-	-- main text
-	local child = children.mainText
-	if child:uid() > 0 then
-		local transform = child:getComponent("Transform")
-		local metadata = child:getComponent("Metadata")
-		local speed = metadata["hovered"] and 0.75 or 0.5
-		transform.position.y = transform.position.y + time.delta() * speed
-		if transform.position.y > 2 then
-			transform.position.y = -2
-		end
-	end
-	-- circle in
-	child = children.circleIn
-	if child:uid() > 0 then
-		local static = Static.get( child )
-
-		local transform = child:getComponent("Transform")
-		local metadata = child:getComponent("Metadata")
-
-		-- rotation
-		local speed = metadata["hovered"] and 0.25 or 0.0125
-		static.time = (static.time or 0) + time.delta() * -speed
-		transform.orientation = Quaternion.axisAngle( Vector3f(0, 0, 1), static.time )
-	end
-	-- circle out
-	child = children.circleOut
-	if child:uid() > 0 then
-		local static = Static.get( child )
-
-		local transform = child:getComponent("Transform")
-		local metadata = child:getComponent("Metadata")
-
-		-- rotation
-		local speed = metadata["hovered"] and 0.25 or 0.0125
-		static.time = (static.time or 0) + time.delta() * speed
-		transform.orientation = Quaternion.axisAngle( Vector3f(0, 0, 1), static.time )
-	end
-
-	if window.keyPressed("Escape") and timer:elapsed() >= 1 then
-		timer:reset()
-		self:callHook("menu:Close.%UID%", {})
-	end
-end )
\ No newline at end of file
diff --git a/data/entities/gui/pause/sound.json b/data/entities/gui/pause/sound.json
deleted file mode 100644
index 521052cd..00000000
--- a/data/entities/gui/pause/sound.json
+++ /dev/null
@@ -1,38 +0,0 @@
-{
-	"type": "Object",
-	"name": "Sound Emitter",
-	"ignore": false,
-	"assets": [
-	],
-	"behaviors": [
-		"SoundEmitterBehavior"
-	],
-	"transform": {
-		"position": [ 0, 0, 0 ],
-		"rotation": {
-			"axis": [ 0, 1, 0 ],
-			"angle": 0
-		},
-		"scale": [ 1, 1, 1 ]
-	},
-	"system": {
-		"hot reload": {
-			"enabled": true
-		},
-		"defaults": {
-			"render": true,
-			"asset load": true
-		},
-		"load": {
-			"ignore": true
-		}
-	},
-	"metadata": {
-		"audio": {
-			"spatial": false,
-			"loop": false,
-			"volume": "sfx",
-			"rolloffFactor": 2
-		}
-	}
-}
\ No newline at end of file
diff --git a/data/entities/gui/pause/tenkousei.json b/data/entities/gui/pause/tenkousei.json
deleted file mode 100644
index 373b5f35..00000000
--- a/data/entities/gui/pause/tenkousei.json
+++ /dev/null
@@ -1,24 +0,0 @@
-{
-	"name": "Menu: Tenkousei Option",
-	"type": "Gui",
-	"ignore": true,
-	"transform": {
-		"position": [ -0.65544, -0.52853, 0 ],
-		"rotation": {
-			"axis": [ 0, 0, 1 ],
-			"angle": 0
-		},
-		"scale": [ 0.156407, 0.0788377, 1 ]
-	},
-	"clickable": true,
-	"hoverable": true,
-	"metadata": {
-		"uv": [ 0, 0, 1, 1 ],
-		"location": "",
-		"scaling": "relative",
-		"text settings": {			
-			"string": "",
-			"string1": "「転光生�"
-		}
-	}
-}
\ No newline at end of file
diff --git a/data/entities/gui/pause/textures/menu.png b/data/entities/gui/pause/textures/menu.png
deleted file mode 100644
index 56972c21..00000000
Binary files a/data/entities/gui/pause/textures/menu.png and /dev/null differ
diff --git a/data/entities/gui/pause/textures/square.png b/data/entities/gui/pause/textures/square.png
deleted file mode 100644
index 3fd47364..00000000
Binary files a/data/entities/gui/pause/textures/square.png and /dev/null differ
diff --git a/data/entities/gui/pause/transient-portrait.json b/data/entities/gui/pause/transient-portrait.json
deleted file mode 100644
index 616418ae..00000000
--- a/data/entities/gui/pause/transient-portrait.json
+++ /dev/null
@@ -1,21 +0,0 @@
-{
-	"name": "Menu: Transient Portrait",
-	"type": "Gui",
-	"ignore": true,
-	"transform": {
-		"position": [ 0.76, 0.2, 0 ],
-		"rotation": {
-			"axis": [ 1, 0, 0 ],
-			"angle": 0
-		},
-		"scale": [ 0.43, 1, 1 ]
-	},
-	"clickable": true,
-	"metadata": {
-		"uv": [ 0, 0, 1, 1 ],
-		"color": [ 1, 1, 1, 0 ],
-		"location": "",
-		"scaling": "relative",
-		"depth": 0.1
-	}
-}
\ No newline at end of file
diff --git a/data/entities/gui/pause/transient-shadow.json b/data/entities/gui/pause/transient-shadow.json
deleted file mode 100644
index 908f7c47..00000000
--- a/data/entities/gui/pause/transient-shadow.json
+++ /dev/null
@@ -1,21 +0,0 @@
-{
-	"name": "Menu: Transient Shadow",
-	"type": "Gui",
-	"ignore": true,
-	"transform": {
-		"position": [ 0.46, 0, 0 ],
-		"rotation": {
-			"axis": [ 1, 0, 0 ],
-			"angle": 0
-		},
-		"scale": [ 0.43, 1, 1 ]
-	},
-	"metadata": {
-		"uv": [ 0, 0, 1, 1 ],
-		"color": [ 1, 1, 1, 0 ],
-		"location": "",
-		"scaling": "relative",
-		"shader": 1,
-		"depth": 0.1
-	}
-}
\ No newline at end of file
diff --git a/data/entities/gui/pause/yellow-box.json b/data/entities/gui/pause/yellow-box.json
deleted file mode 100644
index 49d36850..00000000
--- a/data/entities/gui/pause/yellow-box.json
+++ /dev/null
@@ -1,25 +0,0 @@
-{
-	"name": "Menu: Left Rectangle",
-	"type": "Gui",
-	"ignore": false,
-	"transform": {
-		"position": [ -0.933374, 0, 0 ],
-		"rotation": {
-			"axis": [ 1, 0, 0 ],
-			"angle": 0
-		},
-		"scale": [ 0.067, 1, 1 ]
-	},
-	"metadata": {
-		"uv": [ 0, 0, 1, 1 ],
-	//	"color": [ 1, 0.749, 0.368, 1 ],
-		"color": [ 1, 0.749, 0.368, 1 ],
-		"location": "",
-		"scaling": "relative",
-		"shader": 1,
-		"mode": "flat"
-	},
-	"assets": [
-		"./textures/square.png"
-	]
-}
\ No newline at end of file
diff --git a/data/entities/gui/text/letter.json b/data/entities/gui/text/letter.json
deleted file mode 100644
index c4e85168..00000000
--- a/data/entities/gui/text/letter.json
+++ /dev/null
@@ -1,22 +0,0 @@
-{
-	"name": "Gui: Text",
-	"type": "Object",
-	"behaviors": [
-		"GuiBehavior"
-	],
-	"ignore": false,
-	"transform": {
-		"position": [ 0, 0, 0 ],
-		"rotation": {
-			"axis": [ 0, 0, 1 ],
-			"angle": 0
-		},
-		"scale": [ 1, 1, 1 ]
-	},
-	"metadata": {
-		"uv": [ 0, 0, 1, 1 ],
-		"color": [ 1, 1, 1, 1 ],
-		"location": "",
-		"scaling": "relative"
-	}
-}
\ No newline at end of file
diff --git a/data/entities/gui/text/string.json b/data/entities/gui/text/string.json
deleted file mode 100644
index a2556cce..00000000
--- a/data/entities/gui/text/string.json
+++ /dev/null
@@ -1,42 +0,0 @@
-{
-	"name": "Gui: Text",
-	"type": "Gui",
-	"ignore": true,
-	"transform": {
-		"position": [ 0, 0, 0 ],
-		"rotation": {
-			"axis": [ 0, 0, 1 ],
-			"angle": 0
-		},
-		"scale": [ 1, 1, 1 ]
-	},
-	"metadata": {
-		"text settings": {
-			"legacy": false,
-			"padding": [ 4, 4 ],
-			"spread": 4,
-			"weight": 0.48395,
-			"size": 72,
-			"scale": 1.25,
-		//	"size": 112,
-		//	"scale": 1,
-			"sdf": true,
-			"font": "TAZUGANEGOTHICSTDN-BOLD.otf",
-			"kerning": 24,
-		//	"font": "Coolvetica.ttf",
-			
-			"stroke": [ 0, 0, 0, 0 ],
-			"color": [ 1, 1, 1, 1 ],
-
-			"direction": "down",
-			"align": "left",
-			"origin": [ 0, 0 ],
-
-			"string": "",
-
-			"world": false,
-		//	"depth": 0,
-			"wrap": true
-		}
-	}
-}
\ No newline at end of file
diff --git a/data/entities/hands.json b/data/entities/hands.json
deleted file mode 100644
index 45774fbd..00000000
--- a/data/entities/hands.json
+++ /dev/null
@@ -1,76 +0,0 @@
-{
-	"name": "Hands",
-	"type": "Object",
-	"ignore": true,
-	"transform": {
-		"position": [ 0, 0, 0 ],
-		"rotation": {
-			"axis": [ 0, 1, 0 ],
-			"angle": 0.0
-		},
-		"scale": [ 1, 1, 1 ]
-	},
-	"assets":  [
-	],
-	"behaviors": [
-		"PlayerHandBehavior"
-	],
-	"metadata": {
-		"hands": {
-			"left": {
-				"controller": {
-					"model": "{indexcontroller}valve_controller_knu_1_0_left",
-					"color": [ 1, 1, 1, 1 ]
-				},
-				"light": {
-					"should": false,
-					"type": 3,
-					"color": [1, 1, 1],
-					"power": 50,
-					"fov": 80,
-					"shadows": true,
-					"bias": 0.000005,
-					"resolution": 512,
-					"static": false
-				},
-				"pointer": {
-					"color": [ 1, 0, 1, 1 ],
-					"length": 0, //128,
-					"width": 8,
-					"offset": [ 0, 0, 0 ],
-					"orientation": {
-						"axis": [ 1, 0, 0 ],
-						"angle": 0
-					}
-				}
-			},
-			"right": {
-				"controller": {
-					"model": "{indexcontroller}valve_controller_knu_1_0_right",
-					"color": [ 1, 1, 1, 1 ]
-				},
-				"light": {
-					"should": false,
-					"type": 3,
-					"color": [1, 1, 1],
-					"power": 50,
-					"fov": 80,
-					"shadows": true,
-					"bias": 0.000005,
-					"resolution": 512,
-					"static": false
-				},
-				"pointer": {
-					"color": [ 1, 0, 1, 1 ],
-					"length": 0, //128,
-					"width": 8,
-					"offset": [ 0, 0, 0 ],
-					"orientation": {
-						"axis": [ 1, 0, 0 ],
-						"angle": 0
-					}
-				}
-			}
-		}
-	}
-}
\ No newline at end of file
diff --git a/data/entities/hud.json b/data/entities/hud.json
deleted file mode 100644
index 1d99139b..00000000
--- a/data/entities/hud.json
+++ /dev/null
@@ -1,29 +0,0 @@
-{
-	"name": "HUD Text",
-	"type": "Gui",
-	"ignore": false,
-	"transform": {
-		"position": [  -0.830591, -0.899509, 0 ],
-		"rotation": {
-			"axis": [ 1, 0, 0 ],
-			"angle": 0
-		},
-		"scale": [ 0.258737, 0.115371, 1 ]
-	},
-	"system": {
-		"hot reload": {
-			"enabled": true
-		}
-	},
-	"metadata": {
-		"uv": [ 0, 0, 1, 1 ],
-		"location": "",
-		"scaling": "relative",
-		"text settings": {
-			"stroke": [ 1, 0.749, 0.368, 1 ],
-			"color": [ 1, 0.749, 0.368, 1 ],
-			"depth": 0.5,
-			"string": "."
-		}
-	}
-}
\ No newline at end of file
diff --git a/data/entities/light.json b/data/entities/light.json
deleted file mode 100644
index 56646195..00000000
--- a/data/entities/light.json
+++ /dev/null
@@ -1,44 +0,0 @@
-{
-	"type": "Object",
-	"name": "Light",
-	"behaviors": [ "LightBehavior" ],
-	"ignore": false,
-	"transform": {
-		"reference": true
-	},
-	"system": {
-		"renderer": {
-		//	"limiter": 128
-		//	"mode": "round robin"
-		//	"mode": "once"
-			"mode": "in-range"
-		},
-		"behavior-0": {
-			"tick": {
-				"head loop children": true,
-				"forward iteration": false,
-				"multithreading": false
-			},
-			"render": {
-				"multithreading": false
-			}
-		}
-	},
-	"metadata": {
-		"light": {
-			"type": "point",
-			"color": [1, 1, 1],
-			"power": 100,
-			"fov": 90,
-			"bias": {
-				"constant": 1.25,
-				"slope": 1.75,
-				"shader": 0.00005
-			},
-			"radius": [0.05, 0],
-			"resolution": 512,
-			"shadows": true,
-			"static": false
-		}
-	}
-}
\ No newline at end of file
diff --git a/data/entities/player.json b/data/entities/player.json
deleted file mode 100644
index 88c85b2a..00000000
--- a/data/entities/player.json
+++ /dev/null
@@ -1,108 +0,0 @@
-{
-	"name": "Player",
-	"type": "Object",
-	"behaviors": [
-		"PlayerBehavior",
-		"CraetureBehavior"
-	],
-	"ignore": false,
-	"transform": {
-		"position": [ 0, 0, 0 ],
-		"rotation": {
-			"axis": [ 0, 1, 0 ],
-			"angle": 0.0
-		},
-		"scale": [ 1, 1, 1 ]
-	},
-	"assets":  [
-		{ "filename": "./playerModel.json", "delay": 1.0, "single threaded": true },
-		"./hands.json"
-	],
-	"system": {
-		"behavior-0": {
-			"tick": {
-				"head loop children": false,
-				"multithreading": false
-			}
-		},
-		"physics": {
-			"collision": 1.0,
-			"impulse": true,
-			"gravity": [ 0, -9.81, 0 ],
-			"walk": 1,
-			"move": 4,
-			"run": 8,
-			"rotate": 1.25,
-			"crouch": 1,
-			"jump": [ 0, 4, 0 ],
-
-			"type": "Capsule",
-			"radius": 1,
-			"height": 2,
-			"mass": 100,
-			"shared": false
-		}
-	},
-	"metadata": {
-		"overlay": {
-		//	"position": [ 0, 0, -3 ],
-		//	"scale": [ -1.77778, -1, 1 ],
-			"position": [ 0, 0, -3 ],
-			"scale": [ 1.77778, -1, 1 ],
-			"orientation": [ 0, 0, 0, 1 ],
-			"floating": false,
-			"enabled": true,
-			"alpha": 1.0,
-			"cursor": {
-				"type": "mouse",
-				"radius": 0.05,
-				"color": [ 0.2, 0.2, 1.0, 1.0 ],
-				"enabled": false
-			}
-		},
-		"light": {
-			"should": false,
-			"color": [1, 1, 1],
-			"position": [ 0, 2.5, 0 ],
-			"power": 0.1,
-			"radius": [0.001, 32]
-		},
-		"region": {
-			"track": true,
-			"persist": true
-		},
-		"audio": {
-			"footstep": {
-				"volume": 0.5,
-				"list": [
-					"./data/audio/footstep/1.ogg",
-					"./data/audio/footstep/2.ogg"
-				]
-			}
-		},
-		"camera": {
-			"offset": [ 0, 0, 0 ],
-			"position" :  [ 0, 2, 0 ],
-			"scale": [ 1, 1, 1 ],
-			"invert": [ false, false, false ],
-			"limit": {
-			//	"minima": [ null, -1.57079633, null ],
-			//	"maxima": [ null, 1.57079633, null ],
-
-				"minima": [ null, -1.0, null ],
-				"maxima": [ null,  1.0, null ],
-
-				"current": [ null, 0, null ]
-			},
-			"settings": {
-				"fov" : 90,
-				"clip" : { "near" : 0.01, "far" : 512.0 },
-				"size" :  {
-					"auto" : true,
-					"x" : 7680,
-					"y" : 4320
-				}
-			}
-		}
-	}
-}
\ No newline at end of file
diff --git a/data/entities/playerModel.json b/data/entities/playerModel.json
deleted file mode 100644
index bfe6c1ca..00000000
--- a/data/entities/playerModel.json
+++ /dev/null
@@ -1,49 +0,0 @@
-{
-	"type": "Object",
-	"name": "Player: Model",
-	"ignore": false,
-	"assets": [
-		"/player/bear.glb"
-	//	"/player/s.glb"
-	],
-	"behaviors": [
-		"PlayerModelBehavior"
-	],
-	"transform": {
-		"position": [ 0, -2.0, 0 ],
-		"rotation": {
-			"axis": [ 0, 1, 0 ],
-			"angle": 0
-		},
-		"scale": [ 0.16, 0.16, 0.16 ]
-	},
-	"system": {
-		"hot reload": {
-			"enabled": true
-		},
-		"defaults": {
-		//	"render": true,
-			"asset load": true
-		}
-	},
-	"metadata": {
-		"track via reference": true,
-		"track player": true,
-		"hide player model": true,
-		"model": {
-			"animation": "wank",
-			"print animations": true,
-		//	"mesh optimization": 1,
-			"flags": {
-				"RENDER": true,
-				"COLLISION": false,
-				"SEPARATE": true,
-				"NORMALS": false,
-				"LOAD": false,
-				"ATLAS": false,
-				"SKINNED": true,
-				"INVERT": true
-			}
-		}
-	}
-}
\ No newline at end of file
diff --git a/data/entities/portal.json b/data/entities/portal.json
deleted file mode 100644
index 96f12861..00000000
--- a/data/entities/portal.json
+++ /dev/null
@@ -1,31 +0,0 @@
-{
-	"type": "Portals",
-	"ignore": false,
-	"metadata": {
-		"portals": [
-			{
-				"transform": {
-					"position": [ 0, 0, -10 ],
-					"orientation": [ 0, 0, 0, 1 ],
-					"scale": [ 6, 4, 1 ]
-				},
-				"metadata": {
-					
-				}
-			},
-			{
-				"transform": {
-					"position": [ 0, 0, 10 ],
-					"rotation": {
-						"axis": [ 0, 1, 0 ],
-						"angle": 3.14159
-					},
-					"scale": [ 6, 4, 1 ]
-				},
-				"metadata": {
-
-				}
-			}
-		]
-	}
-}
\ No newline at end of file
diff --git a/data/entities/scene.json b/data/entities/scene.json
deleted file mode 100644
index f51551a1..00000000
--- a/data/entities/scene.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-	"name": "Scene",
-	"assets": [
-		"/gui.json"
-	],
-	"behaviors": [
-		"SceneBehavior",
-		"SceneCollisionBehavior",
-		"ExtSceneBehavior"
-	]
-}
\ No newline at end of file
diff --git a/data/entities/scenes/mcdonalds/audio/soundscape/ambience.ogg b/data/entities/scenes/mcdonalds/audio/soundscape/ambience.ogg
deleted file mode 100644
index 8d6a9686..00000000
Binary files a/data/entities/scenes/mcdonalds/audio/soundscape/ambience.ogg and /dev/null differ
diff --git a/data/entities/scenes/mcdonalds/loading.json b/data/entities/scenes/mcdonalds/loading.json
deleted file mode 100644
index 0ec6c59c..00000000
--- a/data/entities/scenes/mcdonalds/loading.json
+++ /dev/null
@@ -1,32 +0,0 @@
-{
-	"name": "Gui: Loading",
-	"type": "Object",
-	"behaviors": [
-	//	"GuiBehavior"
-	],
-	"assets": [
-		{ "filename": "./mcdonalds.json", "delay": 0 }
-	],
-	"ignore": false,
-	"transform": {
-		"position": [  -0.830591, -0.699509, 0 ],
-		"rotation": {
-			"axis": [ 1, 0, 0 ],
-			"angle": 0
-		},
-		"scale": [ 0.258737, 0.115371, 1 ]
-	},
-	"metadata": {
-		"uv": [ 0, 0, 1, 1 ],
-		"color": [ 1, 1, 1, 0.1 ],
-		"location": "",
-		"scaling": "relative",
-		"text settings": {
-			"stroke": [ 1, 0.749, 0.368, 1 ],
-			"color": [ 1, 0.749, 0.368, 1 ],
-
-			"string": "Loading...",
-			"string1": "コマンド"
-		}
-	}
-}
\ No newline at end of file
diff --git a/data/entities/scenes/mcdonalds/marker.json b/data/entities/scenes/mcdonalds/marker.json
deleted file mode 100644
index e724cc23..00000000
--- a/data/entities/scenes/mcdonalds/marker.json
+++ /dev/null
@@ -1,24 +0,0 @@
-{
-	"name": "Marker",
-	"type": "Gui",
-	"ignore": false,
-	"transform": {
-		"position": [ 0, 0, 0 ],
-		"rotation": {
-			"axis": [ 1, 0, 0 ],
-			"angle": 0
-		},
-		"scale": [ 1, 1, 1 ]
-	},
-	"metadata": {
-		"uv": [ 0, 0, 1, 1 ],
-		"color": [ 1, 1, 1, 0.8 ],
-		"location": "",
-		"scaling": [ 1, 1 ],
-		"world": true,
-		"gui layer": false
-	},
-	"assets": [
-		"https://cdn..xyz//unity/Android/sprite/sprite_magiccircle_in2.png"
-	]
-}
\ No newline at end of file
diff --git a/data/entities/scenes/mcdonalds/mcdonalds.json b/data/entities/scenes/mcdonalds/mcdonalds.json
deleted file mode 100644
index 58763206..00000000
--- a/data/entities/scenes/mcdonalds/mcdonalds.json
+++ /dev/null
@@ -1,78 +0,0 @@
-{
-	"type": "Object",
-	"name": "Map",
-	"ignore": false,
-	"assets": [
-		{ "filename": "./models/mcdonalds.glb", "delay": 0, "single threaded": false },
-		{ "filename": "./static.json", "delay": 1 }
-	],
-	"behaviors": [
-		"LoadingBehavior"
-	],
-	"transform": {
-		"position": [ 0, 0, 0 ],
-		"rotation": {
-			"axis": [ 0, 1, 0 ],
-			"angle": 0
-		},
-		"scale": [ 1, 1, 1 ]
-	},
-	"system": {
-		"defaults": {
-			"asset load": true
-		}
-	},
-	"metadata": {
-		"textures": {
-			"map": {
-			//	"22": [ 86, "sin(time)" ],
-			//	"4": [ 88, "sin(time)" ],
-			//	"36": [ 87, 1.0 ]
-			}
-		},
-		"model": {
-		//	"mesh optimization": 0,
-			"cull mode": "auto",
-			"flags": {
-				"RENDER": true,
-				"COLLISION": false,
-				"SEPARATE": false,
-				"NORMALS": false,
-				"LOAD": false,
-				"ATLAS": true,
-				"SKINNED": false,
-				"INVERT": false,
-				"TRANSFORM": false
-			},
-			"lights": {
-			//	"renderMode": { "target": "worldspawn_1" },
-				"shadows": true
-			},
-			"tags": {
-				"worldspawn_1": { "collision": "static mesh" },
-				"worldspawn_2": { "collision": "static mesh" },
-				"info_player_spawn": { "action": "attach", "filename": "./player.json", "preserve orientation": true },
-			/*
-				"light_5752": {
-					"transform": { "offset": true, "position": [ 0, -2.1768, 0 ] },
-					"light": {
-					//	"flicker": { "rate": 0.5, "power": 0, "timeout": 4 },
-						"fade": { "rate": 4, "color": [0, 0, 0], "timeout": 16 },
-						"shadows": false
-					}
-				},
-			*/
-				"func_door_rotating_5243": { "action": "load", "payload": { "assets": ["./scripts/door.lua"], "metadata": { "angle":-1.570795 } } },
-				"func_door_rotating_5444": { "action": "load", "payload": { "assets": ["./scripts/door.lua"], "metadata": { "angle": 1.570795 } } },
-				"func_door_rotating_5495": { "action": "load", "payload": { "assets": ["./scripts/door.lua"], "metadata": { "angle": 1.570795 } } },
-				"func_door_rotating_5220": { "action": "load", "payload": { "assets": ["./scripts/door.lua"], "metadata": { "angle":-1.570795 } } },
-				"func_door_rotating_5556": { "action": "load", "payload": { "assets": ["./scripts/door.lua"], "metadata": { "angle": 1.570795 } } },
-				"func_door_rotating_5689": { "action": "load", "payload": { "assets": ["./scripts/door.lua"], "metadata": { "angle":-1.570795 } } },
-				"func_door_rotating_5712": { "action": "load", "payload": { "assets": ["./scripts/door.lua"], "metadata": { "angle": 1.570795 } } },
-				"func_door_rotating_5576": { "action": "load", "payload": { "assets": ["./scripts/door.lua"], "metadata": { "angle":-1.570795 } } },
-				"func_door_rotating_5584": { "action": "load", "payload": { "assets": ["./scripts/door.lua"], "metadata": { "angle":-1.570795 } } },
-				"func_door_rotating_5568": { "action": "load", "payload": { "assets": ["./scripts/door.lua"], "metadata": { "angle":-1.570795 } } }
-			}		
-		}
-	}
-}
\ No newline at end of file
diff --git a/data/entities/scenes/mcdonalds/player.json b/data/entities/scenes/mcdonalds/player.json
deleted file mode 100644
index dec26007..00000000
--- a/data/entities/scenes/mcdonalds/player.json
+++ /dev/null
@@ -1,19 +0,0 @@
-{
-	"import": "/player.json",
-	"assets": [
-	//	{ "filename": "/gui/hud/hud.json", "delay": 0 }
-	],
-	"metadata": {
-		"overlay": {
-			"floating": true
-		},
-		"collider": true,
-		"light": {
-			"should": false,
-			"color": [1, 1, 1],
-			"position": [ 0, 2.5, 0 ],
-			"power": 1,
-			"radius": [0.001, 32]
-		}
-	}
-}
\ No newline at end of file
diff --git a/data/entities/scenes/mcdonalds/scene.json b/data/entities/scenes/mcdonalds/scene.json
deleted file mode 100644
index 0531f9d8..00000000
--- a/data/entities/scenes/mcdonalds/scene.json
+++ /dev/null
@@ -1,50 +0,0 @@
-{
-	"import": "/scene.json",
-	"assets": [
-		"./audio/soundscape/ambience.ogg",
-		"./loading.json"
-	],
-	"system": {
-		"hot reload": {
-			"enabled": true
-		},
-		"renderer": {
-			"shader": {
-				"mode": 1,
-				"scalar": 16,
-				"parameters": [ 0, 0, 0, 0 ]
-			},
-			"clear values": [
-				[ 1, 1, 1, 0 ]
-			]
-		}
-	},
-	"metadata": {
-		"menus": {
-			"pause": "/gui/pause/menu.json"
-		},
-		"volumes": {
-			"sfx": 0.25,
-			"bgm": 0.75,
-			"voice": 1.0
-		},
-		"light": {
-			"ambient": [ 0.025, 0.025, 0.025 ],
-			"kexp": 0,
-			"fog": {
-				"color": [ 0.25, 0.25, 0.25 ],
-				"range": [ 32, 64 ],
-				"step scale": 4,
-				"absorbtion": 0.07,
-				"density": {
-					"threshold": 0.35,
-					"multiplier": 5.0,
-					"scale": 25.0,
-					"offset": [0, -1, 1],
-					"timescale": 8
-				}
-			},
-			"should": true
-		}
-	}
-}
\ No newline at end of file
diff --git a/data/entities/scenes/mcdonalds/scripts/door.lua b/data/entities/scenes/mcdonalds/scripts/door.lua
deleted file mode 100644
index 33848703..00000000
--- a/data/entities/scenes/mcdonalds/scripts/door.lua
+++ /dev/null
@@ -1,18 +0,0 @@
-local scene = entities.currentScene()
-local controller = entities.controller()
-
-local timer = Timer.new()
-if not timer:running() then
-	timer:start();
-end
-
-local target = Vector3f(0,0,0)
-local transform = ent:getComponent("Transform")
-local metadata = ent:getComponent("Metadata")
-local speed = metadata["speed"] or 1.0 / 3.0
-local starting = Quaternion(transform.orientation)
-local ending = transform.orientation:multiply(Quaternion.axisAngle( Vector3f(0,1,0), metadata["angle"] ))
--- on tick
-ent:bind( "tick", function(self)
-	transform.orientation = starting:slerp( ending, math.cos(time.current() * speed) * 0.5 + 0.5 )
-end )
\ No newline at end of file
diff --git a/data/entities/scenes/mcdonalds/scripts/realign.lua b/data/entities/scenes/mcdonalds/scripts/realign.lua
deleted file mode 100644
index 84527d13..00000000
--- a/data/entities/scenes/mcdonalds/scripts/realign.lua
+++ /dev/null
@@ -1,22 +0,0 @@
-local scene = entities.currentScene()
-local controller = entities.controller()
-
-local timer = Timer.new()
-if not timer:running() then
-	timer:start();
-end
-
-local transform = ent:getComponent("Transform")
--- on tick
-ent:bind( "tick", function(self)
-	local offset = Vector3f(0,0,0)
-	if window.keyPressed("J") then offset.x = offset.x - time.delta() end
-	if window.keyPressed("L") then offset.x = offset.x + time.delta() end
-	if window.keyPressed("N") then offset.y = offset.y - time.delta() end
-	if window.keyPressed("M") then offset.y = offset.y + time.delta() end
-	if window.keyPressed("I") then offset.z = offset.z - time.delta() end
-	if window.keyPressed("K") then offset.z = offset.z + time.delta() end
-	if offset:magnitude() > 0.0001 then
-		transform.position = transform.position + offset
-	end
-end )
\ No newline at end of file
diff --git a/data/entities/scenes/mcdonalds/scripts/static.lua b/data/entities/scenes/mcdonalds/scripts/static.lua
deleted file mode 100644
index d1b3a7a7..00000000
--- a/data/entities/scenes/mcdonalds/scripts/static.lua
+++ /dev/null
@@ -1,90 +0,0 @@
-local scene = entities.currentScene()
-local controller = entities.controller()
-
-local timer = Timer.new()
-if not timer:running() then
-	timer:start();
-end
-
--- release control
-hooks.call("window:Mouse.CursorVisibility", { state = true })
-hooks.call("window:Mouse.Lock", {});
-
--- on tick
-ent:bind( "tick", function(self)
-	-- update static effect
-	local metadatas = {
-		ent = ent:getComponent("Metadata"),
-		scene = scene:getComponent("Metadata")
-	}
-	local transforms = {
-		ent = ent:getComponent("Transform"),
-		controller = controller:getComponent("Transform")
-	}
-	local distanceSquared = transforms.controller.position:distance( transforms.ent.position )
-	distanceSquared = distanceSquared * distanceSquared
-	if type(metadatas.ent["static"]["scale"]) == "number" then
-		distanceSquared = distanceSquared * metadatas.ent["static"]["scale"]
-	end
-	local lo = type(metadatas.ent["static"]["range"][1]) == "number" and metadatas.ent["static"]["range"][1] or 0.1
-	local hi = type(metadatas.ent["static"]["range"][2]) == "number" and metadatas.ent["static"]["range"][2] or 0.5
-	local staticBlend = distanceSquared > 1 and 1.0 / distanceSquared or 1.0
-	staticBlend = math.clamp( staticBlend, lo, hi )
-
-	local flicker = type(metadatas.ent["static"]["flicker"]) == "number" and metadatas.ent["static"]["flicker"] or 0.001
-	local pieces = type(metadatas.ent["static"]["pieces"]) == "number" and metadatas.ent["static"]["pieces"] or 1000
-
-	local payload = {
-		mode = 2,
-		parameters = {
-			[1] = flicker,
-			[2] = pieces,
-			[3] = staticBlend,
-			[4] = "time"
-		}
-	}
-	scene:callHook("shader:Update.%UID%", payload)
-end )
-
-
-local hud = ent:loadChild("/hud.json", true)
-hud:bind( "tick", function(self)
-	-- update distance HUD element
-	if timer:elapsed() <= 0.0125 then return end
-	timer:reset()
-		
-	local metadata = self:getComponent("Metadata")
-	local transforms = {
-		controller = controller:getComponent("Transform"),
-		source = ent:getComponent("Transform")
-	}
-	local distance = transforms.controller.position:distance( transforms.source.position )
-	--distance = string.si( distance, "m" )
-	local maximum = 40
-	local value = math.floor(distance/maximum * 100)
-	if value >= 100 then value = 100 end
-	distance = "Sanity: " .. value .. "%"
-	--distance = math.floor((15-distance)/15 * 100) .. "%"
-	if metadata["text settings"]["string"] ~= distance then
-		self:callHook( "gui:UpdateString.%UID%", {
-			string = distance
-		} )
-	end
-end )
-
---[[
-local marker = ent:loadChild("./marker.json", true)
-marker:bind( "tick", function(self)
-	local transform = marker:getComponent("Transform")
-	local parentTransform = ent:getComponent("Transform")
-	local controllerTransform = controller:getComponent("Transform")
-
-	local controllerCamera = controller:getComponent("Camera")
-	local controllerCameraTransform = controllerCamera:getTransform()
-	
-	transform.position = parentTransform.position + Vector3f(0,3,0)
-	transform.orientation = Quaternion.lookAt( transform.position - controllerTransform.position, Vector3f(0,1,0) )
-	-- transform.orientation = transform.orientation:normalize()
-	-- transform.model = controllerCamera:getProjection() * controllerCamera:getView() * Matrix4f.translate( transform.position ) * transform.orientation:matrix()
-end )
-]]
\ No newline at end of file
diff --git a/data/entities/scenes/mcdonalds/static.json b/data/entities/scenes/mcdonalds/static.json
deleted file mode 100644
index 57ba0254..00000000
--- a/data/entities/scenes/mcdonalds/static.json
+++ /dev/null
@@ -1,47 +0,0 @@
-{
-	"type": "Object",
-	"name": "Static Emitter",
-	"ignore": true,
-	"assets": [
-		"/overworld/static.ogg",
-		"./scripts/static.lua"
-	],
-	"behaviors": [
-		"SoundEmitterBehavior"
-	],
-	"transform": {
-		"position": [ -10.5331, -0.956335, 10.2349 ],
-		"rotation": {
-			"axis": [ 0, 1, 0 ],
-			"angle": 0
-		},
-		"scale": [ 1, 1, 1 ]
-	},
-	"system": {
-		"hot reload": {
-			"enabled": true
-		},
-		"defaults": {
-			"render": true,
-			"asset load": true
-		},
-		"load": {
-			"ignore": true
-		}
-	},
-	"metadata": {
-		"audio": {
-			"spatial": true,
-			"loop": true,
-			"volume": 1.6,
-			"rolloffFactor": 2
-		},
-		"static": {
-			"range": [ 0.0025, 1 ],
-			"flicker": 0.5,
-			"pieces": 16,
-			"scale": 0.4
-		},
-		"distance": false
-	}
-}
\ No newline at end of file
diff --git a/data/entities/scenes/mcdonalds/textures/nggrs.png b/data/entities/scenes/mcdonalds/textures/nggrs.png
deleted file mode 100644
index 786c52d0..00000000
Binary files a/data/entities/scenes/mcdonalds/textures/nggrs.png and /dev/null differ
diff --git a/data/entities/scenes/mcdonalds/textures/window.png b/data/entities/scenes/mcdonalds/textures/window.png
deleted file mode 100644
index 741424c0..00000000
Binary files a/data/entities/scenes/mcdonalds/textures/window.png and /dev/null differ
diff --git a/data/entities/scenes/mcdonalds/textures/wood-blood.png b/data/entities/scenes/mcdonalds/textures/wood-blood.png
deleted file mode 100644
index 9ed51230..00000000
Binary files a/data/entities/scenes/mcdonalds/textures/wood-blood.png and /dev/null differ
diff --git a/data/entities/scenes/raytracing/scene.json b/data/entities/scenes/raytracing/scene.json
deleted file mode 100644
index 421c2b4b..00000000
--- a/data/entities/scenes/raytracing/scene.json
+++ /dev/null
@@ -1,66 +0,0 @@
-{
-	"type": "Scene",
-	"behaviors": [
-		"SceneBehavior",
-		"ExtSceneBehavior",
-		"RayTracingSceneBehavior"
-	],
-	"assets": [
-		"/gui.json",
-		"./light.json",
-		"/player.json"
-	],
-	"system": {
-		"hot reload": {
-			"enabled": true
-		},
-		"renderer": {
-			"clear values": [
-				[ 0.3, 0.3, 0.3, 0 ]
-			]
-		},
-		"physics": {
-			"collision": true,
-			"single threaded": false,
-			"sort": false,
-			"use": {
-				"strongest": false,
-				"worker": true,
-				"queue": false
-			},
-			"optimizations": {
-				"ignore static entities": true,
-				"ignore duplicate tests": true,
-				"entity-local update": true
-			}
-		}
-	},
-	"metadata": {
-		"menus": {
-			"pause": "/gui/pause/menu.json"
-		},
-		"rays": {
-			"marching steps": 0,
-			"ray bounces": 2,
-			"shadow factor": 0.5,
-			"reflection": {
-				"strength": 0.4,
-				"falloff": 0.5
-			}
-		},
-		"volumes": {
-			"sfx": 0.25,
-			"bgm": 0.75,
-			"voice": 1.0
-		},
-		"light": {
-			"ambient": [ 0.1, 0.1, 0.1 ],
-			"kexp": 0,
-			"fog": {
-				"color": [ 0.1, 0.1, 0.1 ],
-				"range": [ 32, 64 ]
-			},
-			"should": true
-		}
-	}
-}
\ No newline at end of file
diff --git a/data/entities/scenes/startmenu/player.json b/data/entities/scenes/startmenu/player.json
deleted file mode 100644
index 255c5ff8..00000000
--- a/data/entities/scenes/startmenu/player.json
+++ /dev/null
@@ -1,16 +0,0 @@
-{
-	"import": "/player.json",
-	"assets": [
-		{ "filename": "/hands.json", "delay": 0 }
-	],
-	"system": {
-		"physics": {
-			"gravity": [ 0, 0, 0 ],
-			"clamp": {
-				"x": [0, 0],
-				"y": [0, 0],
-				"z": [0, 0]
-			}
-		}
-	}
-}
\ No newline at end of file
diff --git a/data/entities/scenes/startmenu/scene.json b/data/entities/scenes/startmenu/scene.json
deleted file mode 100644
index 9e36d917..00000000
--- a/data/entities/scenes/startmenu/scene.json
+++ /dev/null
@@ -1,24 +0,0 @@
-{
-	"type": "Main Menu",
-	"behaviors": [
-		"SceneBehavior",
-		"ExtSceneBehavior"
-	],
-	"assets": [
-		"/gui.json",
-		"./player.json",
-		"/ui/main menu.ogg",
-		"/gui/mainmenu/menu.json"
-	],
-	"hot reload": {
-		"enabled": true
-	},
-	"clear color": [ 0, 0, 0, 1 ],
-	"metadata": {
-		"volumes": {
-			"sfx": 0.25,
-			"bgm": 0.15,
-			"voice": 1.0
-		}
-	}
-}
\ No newline at end of file
diff --git a/data/fonts/Coolvetica.ttf b/data/fonts/Coolvetica.ttf
deleted file mode 100644
index 410ca316..00000000
Binary files a/data/fonts/Coolvetica.ttf and /dev/null differ
diff --git a/data/fonts/TAZUGANEGOTHICSTDN-BOLD.otf b/data/fonts/TAZUGANEGOTHICSTDN-BOLD.otf
deleted file mode 100644
index 1878242d..00000000
Binary files a/data/fonts/TAZUGANEGOTHICSTDN-BOLD.otf and /dev/null differ
diff --git a/data/fonts/consola.ttf b/data/fonts/consola.ttf
deleted file mode 100644
index 07d987e9..00000000
Binary files a/data/fonts/consola.ttf and /dev/null differ
diff --git a/data/openvr_bindings_default.json b/data/openvr_bindings_default.json
deleted file mode 100644
index 767330f3..00000000
--- a/data/openvr_bindings_default.json
+++ /dev/null
@@ -1,261 +0,0 @@
-{
-	"controller_type" : "generic",
-	"description" : "Default bindings",
-	"name" : "Generic Bindings",
-	"bindings": {
-		"/actions/global": {
-			"sources": [
-				{
-					"path": "/user/hand/right/input/a",
-					"mode": "button",
-					"inputs": {
-						"click": {
-							"output": "/actions/global/in/leftA"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/left/input/a",
-					"mode": "button",
-					"inputs": {
-						"click": {
-							"output": "/actions/global/in/rightA"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/left/input/b",
-					"mode": "button",
-					"inputs": {
-						"click": {
-							"output": "/actions/global/in/leftB"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/right/input/b",
-					"mode": "button",
-					"inputs": {
-						"click": {
-							"output": "/actions/global/in/rightB"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/left/input/trackpad",
-					"mode": "trackpad",
-					"inputs": {
-						"position": {
-							"output": "/actions/global/in/leftTrackpad"
-						},
-						"touch": {
-							"output": "/actions/global/in/leftTouchpad"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/right/input/trackpad",
-					"mode": "trackpad",
-					"inputs": {
-						"position": {
-							"output": "/actions/global/in/rightTrackpad"
-						},
-						"touch": {
-							"output": "/actions/global/in/rightTouchpad"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/left/input/trackpad",
-					"mode": "button",
-					"inputs": {
-						"click": {
-							"output": "/actions/global/in/leftClickpad"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/right/input/trackpad",
-					"mode": "button",
-					"inputs": {
-						"click": {
-							"output": "/actions/global/in/right_Clickpad"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/left/input/grip",
-					"mode": "force_sensor",
-					"inputs": {
-						"force": {
-							"output": "/actions/global/in/leftGrip"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/right/input/grip",
-					"mode": "force_sensor",
-					"inputs": {
-						"force": {
-							"output": "/actions/global/in/rightGrip"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/left/input/grip",
-					"mode": "grab",
-					"inputs": {
-						"grab": {
-							"output": "/actions/global/in/leftGrab"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/right/input/grip",
-					"mode": "grab",
-					"inputs": {
-						"grab": {
-							"output": "/actions/global/in/rightGrab"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/left/input/trigger",
-					"mode": "button",
-					"parameters": {
-						"haptic_amplitude": "0"
-					},
-					"inputs": {
-						"click": {
-							"output": "/actions/global/in/leftClick"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/right/input/trigger",
-					"mode": "button",
-					"parameters": {
-						"haptic_amplitude": "0"
-					},
-					"inputs": {
-						"click": {
-							"output": "/actions/global/in/rightClick"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/left/input/trigger",
-					"mode": "button",
-					"inputs": {
-						"click": {
-							"output": "/actions/global/in/leftTrigger"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/right/input/trigger",
-					"mode": "button",
-					"inputs": {
-						"click": {
-							"output": "/actions/global/in/rightTrigger"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/left/input/thumbstick",
-					"mode": "dpad_touch",
-					"parameters": {
-						"deadzone_pct": "85",
-						"overlap_pct": "0",
-						"sticky": "true"
-					},
-					"inputs": {
-						"north": {
-							"output": "/actions/global/in/leftDPadUp"
-						},
-						"south": {
-							"output": "/actions/global/in/leftDPadDown"
-						},
-						"east": {
-							"output": "/actions/global/in/leftDPadRight"
-						},
-						"west": {
-							"output": "/actions/global/in/leftDPadLeft"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/right/input/thumbstick",
-					"mode": "dpad_touch",
-					"parameters": {
-						"deadzone_pct": "85",
-						"overlap_pct": "0",
-						"sticky": "true"
-					},
-					"inputs": {
-						"north": {
-							"output": "/actions/global/in/rightDPadUp"
-						},
-						"south": {
-							"output": "/actions/global/in/rightDPadDown"
-						},
-						"east": {
-							"output": "/actions/global/in/rightDPadRight"
-						},
-						"west": {
-							"output": "/actions/global/in/rightDPadLeft"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/left/input/thumbstick",
-					"mode": "joystick",
-					"inputs": {
-						"position": {
-							"output": "/actions/global/in/leftThumbstick"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/right/input/thumbstick",
-					"mode": "joystick",
-					"inputs": {
-						"position": {
-							"output": "/actions/global/in/rightThumbstick"
-						}
-					}
-				}
-			],
-			"poses": [
-				{
-					"output": "/actions/global/in/leftHandPose",
-					"path": "/user/hand/left/pose/raw"
-				},
-				{
-					"output": "/actions/global/in/rightHandPose",
-					"path": "/user/hand/right/pose/raw"
-				}
-			],
-			"haptics": [
-				{
-					"output": "/actions/global/out/leftHapticVibration",
-					"path": "/user/hand/left/output/haptic"
-				},
-				{
-					"output": "/actions/global/out/rightHapticVibration",
-					"path": "/user/hand/right/output/haptic"
-				}
-			],
-			"skeleton": [
-				{
-					"output": "/actions/global/in/leftHandSkeleton",
-					"path": "/user/hand/left/input/skeleton/left"
-				},
-				{
-					"output": "/actions/global/in/rightHandSkeleton",
-					"path": "/user/hand/right/input/skeleton/right"
-				}
-			]
-		}
-	}
-}
\ No newline at end of file
diff --git a/data/openvr_bindings_knuckles.json b/data/openvr_bindings_knuckles.json
deleted file mode 100644
index 8abec4a3..00000000
--- a/data/openvr_bindings_knuckles.json
+++ /dev/null
@@ -1,275 +0,0 @@
-{
-	"controller_type" : "knuckles",
-	"description" : "Default Index Knuckles bindings",
-	"name" : "Knuckles Bindings",
-	"bindings": {
-		"/actions/global": {
-			"sources": [
-				{
-					"path": "/user/hand/left/input/a",
-					"mode": "button",
-					"inputs": {
-						"click": {
-							"output": "/actions/global/in/a.left"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/right/input/a",
-					"mode": "button",
-					"inputs": {
-						"click": {
-							"output": "/actions/global/in/a.right"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/left/input/b",
-					"mode": "button",
-					"inputs": {
-						"click": {
-							"output": "/actions/global/in/b.left"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/right/input/b",
-					"mode": "button",
-					"inputs": {
-						"click": {
-							"output": "/actions/global/in/b.right"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/left/input/trackpad",
-					"mode": "trackpad",
-					"inputs": {
-						"position": {
-							"output": "/actions/global/in/trackpad.left"
-						},
-						"touch": {
-							"output": "/actions/global/in/touchpad.left"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/right/input/trackpad",
-					"mode": "trackpad",
-					"inputs": {
-						"position": {
-							"output": "/actions/global/in/trackpad.right"
-						},
-						"touch": {
-							"output": "/actions/global/in/touchpad.right"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/left/input/trackpad",
-					"mode": "button",
-					"inputs": {
-						"click": {
-							"output": "/actions/global/in/clickpad.left"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/right/input/trackpad",
-					"mode": "button",
-					"inputs": {
-						"click": {
-							"output": "/actions/global/in/clickpad.right"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/left/input/grip",
-					"mode": "force_sensor",
-					"inputs": {
-						"force": {
-							"output": "/actions/global/in/grip.left"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/right/input/grip",
-					"mode": "force_sensor",
-					"inputs": {
-						"force": {
-							"output": "/actions/global/in/grip.right"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/left/input/grip",
-					"mode": "grab",
-					"inputs": {
-						"grab": {
-							"output": "/actions/global/in/grab.left"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/right/input/grip",
-					"mode": "grab",
-					"inputs": {
-						"grab": {
-							"output": "/actions/global/in/grab.right"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/left/input/trigger",
-					"mode": "button",
-					"parameters": {
-						"haptic_amplitude": "0"
-					},
-					"inputs": {
-						"click": {
-							"output": "/actions/global/in/click.left"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/right/input/trigger",
-					"mode": "button",
-					"parameters": {
-						"haptic_amplitude": "0"
-					},
-					"inputs": {
-						"click": {
-							"output": "/actions/global/in/click.right"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/left/input/trigger",
-					"mode": "trigger",
-					"inputs": {
-						"click": {
-							"output": "/actions/global/in/trigger.left"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/right/input/trigger",
-					"mode": "trigger",
-					"inputs": {
-						"click": {
-							"output": "/actions/global/in/trigger.right"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/left/input/thumbstick",
-					"mode": "dpad_touch",
-					"parameters": {
-						"deadzone_pct": "85",
-						"overlap_pct": "0",
-						"sticky": "true"
-					},
-					"inputs": {
-						"north": {
-							"output": "/actions/global/in/dpadUp.left"
-						},
-						"south": {
-							"output": "/actions/global/in/dpadDown.left"
-						},
-						"east": {
-							"output": "/actions/global/in/dpadRight.left"
-						},
-						"west": {
-							"output": "/actions/global/in/dpadLeft.left"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/right/input/thumbstick",
-					"mode": "dpad_touch",
-					"parameters": {
-						"deadzone_pct": "85",
-						"overlap_pct": "0",
-						"sticky": "true"
-					},
-					"inputs": {
-						"north": {
-							"output": "/actions/global/in/dpadUp.right"
-						},
-						"south": {
-							"output": "/actions/global/in/dpadDown.right"
-						},
-						"east": {
-							"output": "/actions/global/in/dpadRight.right"
-						},
-						"west": {
-							"output": "/actions/global/in/dpadLeft.right"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/left/input/thumbstick",
-					"mode": "joystick",
-					"inputs": {
-						"position": {
-							"output": "/actions/global/in/thumbstick.left"
-						},
-						"click": {
-							"output": "/actions/global/in/thumbclick.left"
-						}
-					}
-				},
-				{
-					"path": "/user/hand/right/input/thumbstick",
-					"mode": "joystick",
-					"inputs": {
-						"position": {
-							"output": "/actions/global/in/thumbstick.right"
-						},
-						"click": {
-							"output": "/actions/global/in/thumbclick.right"
-						}
-					}
-				}
-			],
-			"poses": [
-				{
-					"output": "/actions/global/in/handPose.left",
-					"path": "/user/hand/left/pose/raw"
-				},
-				{
-					"output": "/actions/global/in/handPose.right",
-					"path": "/user/hand/right/pose/raw"
-				},
-				{
-					"output": "/actions/global/in/handTip.left",
-					"path": "/user/hand/left/pose/tip"
-				},
-				{
-					"output": "/actions/global/in/handTip.right",
-					"path": "/user/hand/right/pose/tip"
-				}
-			],
-			"haptics": [
-				{
-					"output": "/actions/global/out/hapticVibration.left",
-					"path": "/user/hand/left/output/haptic"
-				},
-				{
-					"output": "/actions/global/out/hapticVibration.right",
-					"path": "/user/hand/right/output/haptic"
-				}
-			],
-			"skeleton": [
-				{
-					"output": "/actions/global/in/handSkeleton.left",
-					"path": "/user/hand/left/input/skeleton/left"
-				},
-				{
-					"output": "/actions/global/in/handSkeleton.right",
-					"path": "/user/hand/right/input/skeleton/right"
-				}
-			]
-		}
-	}
-}
\ No newline at end of file
diff --git a/data/openvr_manifest.json b/data/openvr_manifest.json
deleted file mode 100644
index 6e2ded5d..00000000
--- a/data/openvr_manifest.json
+++ /dev/null
@@ -1,165 +0,0 @@
-{
-	"default_bindings": [
-	 {
-			"controller_type": "knuckles",
-			"binding_url": "./openvr_bindings_knuckles.json"
-	 }
-	], 
-	"actions": [
-		{
-			"name": "/actions/global/in/a.left",
-			"type": "boolean"
-		},
-		{
-			"name": "/actions/global/in/a.right",
-			"type": "boolean"
-		},
-		{
-			"name": "/actions/global/in/b.left",
-			"type": "boolean"
-		},
-		{
-			"name": "/actions/global/in/b.right",
-			"type": "boolean"
-		},
-		{
-			"name": "/actions/global/in/trackpad.left",
-			"type": "vector2"
-		},
-		{
-			"name": "/actions/global/in/touchpad.left",
-			"type": "vector2"
-		},
-		{
-			"name": "/actions/global/in/trackpad.right",
-			"type": "vector2"
-		},
-		{
-			"name": "/actions/global/in/touchpad.right",
-			"type": "vector2"
-		},
-		{
-			"name": "/actions/global/in/clickpad.left",
-			"type": "boolean"
-		},
-		{
-			"name": "/actions/global/in/clickpad.right",
-			"type": "boolean"
-		},
-		{
-			"name": "/actions/global/in/grip.left",
-			"type": "vector1"
-		},
-		{
-			"name": "/actions/global/in/grip.right",
-			"type": "vector1"
-		},
-		{
-			"name": "/actions/global/in/grab.left",
-			"type": "boolean"
-		},
-		{
-			"name": "/actions/global/in/grab.right",
-			"type": "boolean"
-		},
-		{
-			"name": "/actions/global/in/click.left",
-			"type": "boolean"
-		},
-		{
-			"name": "/actions/global/in/click.right",
-			"type": "boolean"
-		},
-		{
-			"name": "/actions/global/in/trigger.left",
-			"type": "vector1"
-		},
-		{
-			"name": "/actions/global/in/trigger.right",
-			"type": "vector1"
-		},
-		{
-			"name": "/actions/global/in/dpadUp.left",
-			"type": "boolean"
-		},
-		{
-			"name": "/actions/global/in/dpadDown.left",
-			"type": "boolean"
-		},
-		{
-			"name": "/actions/global/in/dpadRight.left",
-			"type": "boolean"
-		},
-		{
-			"name": "/actions/global/in/dpadLeft.left",
-			"type": "boolean"
-		},
-		{
-			"name": "/actions/global/in/dpadUp.right",
-			"type": "boolean"
-		},
-		{
-			"name": "/actions/global/in/dpadDown.right",
-			"type": "boolean"
-		},
-		{
-			"name": "/actions/global/in/dpadRight.right",
-			"type": "boolean"
-		},
-		{
-			"name": "/actions/global/in/dpadLeft.right",
-			"type": "boolean"
-		},
-		{
-			"name": "/actions/global/in/thumbclick.left",
-			"type": "boolean"
-		},
-		{
-			"name": "/actions/global/in/thumbclick.right",
-			"type": "boolean"
-		},
-		{
-			"name": "/actions/global/in/thumbstick.left",
-			"type": "vector2"
-		},
-		{
-			"name": "/actions/global/in/thumbstick.right",
-			"type": "vector2"
-		},
-		{
-			"name": "/actions/global/in/handPose.left",
-			"type": "pose"
-		},
-		{
-			"name": "/actions/global/in/handPose.right",
-			"type": "pose"
-		},
-		{
-			"name": "/actions/global/in/handTip.left",
-			"type": "pose"
-		},
-		{
-			"name": "/actions/global/in/handTip.right",
-			"type": "pose"
-		},
-		{
-			"name": "/actions/global/out/hapticVibration.left",
-			"type": "vibration"
-		},
-		{
-			"name": "/actions/global/out/hapticVibration.right",
-			"type": "vibration"
-		}
-	],
-	"action_sets": [
-		{
-			"name": "/actions/global",
-			"usage": "leftright"
-		}
-	],
-	"localization" : [
-	 {
-			 "language_tag": "en_us"
-		}
-	]
-}
\ No newline at end of file
diff --git a/data/scripts/json.lua b/data/scripts/json.lua
deleted file mode 100644
index a9f78820..00000000
--- a/data/scripts/json.lua
+++ /dev/null
@@ -1,389 +0,0 @@
---
--- json.lua
---
--- Copyright (c) 2020 rxi
---
--- 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.
---
-
-local json = { _version = "0.1.2" }
-
--------------------------------------------------------------------------------
--- Encode
--------------------------------------------------------------------------------
-
-local encode
-
-local escape_char_map = {
-  [ "\\" ] = "\\",
-  [ "\"" ] = "\"",
-  [ "\b" ] = "b",
-  [ "\f" ] = "f",
-  [ "\n" ] = "n",
-  [ "\r" ] = "r",
-  [ "\t" ] = "t",
-}
-
-local escape_char_map_inv = { [ "/" ] = "/" }
-for k, v in pairs(escape_char_map) do
-  escape_char_map_inv[v] = k
-end
-
-
-local function escape_char(c)
-  return "\\" .. (escape_char_map[c] or string.format("u%04x", c:byte()))
-end
-
-
-local function encode_nil(val)
-  return "null"
-end
-
-
-local function encode_table(val, stack)
-  local res = {}
-  stack = stack or {}
-
-  -- Circular reference?
-  if stack[val] then error("circular reference") end
-
-  stack[val] = true
-
-  if rawget(val, 1) ~= nil or next(val) == nil then
-    -- Treat as array -- check keys are valid and it is not sparse
-    local n = 0
-    for k in pairs(val) do
-      if type(k) ~= "number" then
-        error("invalid table: mixed or invalid key types")
-      end
-      n = n + 1
-    end
-    if n ~= #val then
-      error("invalid table: sparse array")
-    end
-    -- Encode
-    for i, v in ipairs(val) do
-      table.insert(res, encode(v, stack))
-    end
-    stack[val] = nil
-    return #res == 0 and "{}" or "[" .. table.concat(res, ",") .. "]"
---  return "[" .. table.concat(res, ",") .. "]"
-
-  else
-    -- Treat as an object
-    for k, v in pairs(val) do
-      if type(k) ~= "string" then
-        error("invalid table: mixed or invalid key types")
-      end
-      table.insert(res, encode(k, stack) .. ":" .. encode(v, stack))
-    end
-    stack[val] = nil
-    return "{" .. table.concat(res, ",") .. "}"
-  end
-end
-
-
-local function encode_string(val)
-  return '"' .. val:gsub('[%z\1-\31\\"]', escape_char) .. '"'
-end
-
-
-local function encode_number(val)
-  -- Check for NaN, -inf and inf
-  if val ~= val or val <= -math.huge or val >= math.huge then
-    error("unexpected number value '" .. tostring(val) .. "'")
-  end
-  return string.format("%.14g", val)
-end
-
-
-local type_func_map = {
-  [ "nil"     ] = encode_nil,
-  [ "table"   ] = encode_table,
-  [ "string"  ] = encode_string,
-  [ "number"  ] = encode_number,
-  [ "boolean" ] = tostring,
-}
-
-
-encode = function(val, stack)
-  local t = type(val)
-  local f = type_func_map[t]
-  if f then
-    return f(val, stack)
-  end
-  error("unexpected type '" .. t .. "'")
-end
-
-
-function json.encode(val)
-  return ( encode(val) )
-end
-
-
--------------------------------------------------------------------------------
--- Decode
--------------------------------------------------------------------------------
-
-local parse
-
-local function create_set(...)
-  local res = {}
-  for i = 1, select("#", ...) do
-    res[ select(i, ...) ] = true
-  end
-  return res
-end
-
-local space_chars   = create_set(" ", "\t", "\r", "\n")
-local delim_chars   = create_set(" ", "\t", "\r", "\n", "]", "}", ",")
-local escape_chars  = create_set("\\", "/", '"', "b", "f", "n", "r", "t", "u")
-local literals      = create_set("true", "false", "null")
-
-local literal_map = {
-  [ "true"  ] = true,
-  [ "false" ] = false,
-  [ "null"  ] = nil,
-}
-
-
-local function next_char(str, idx, set, negate)
-  for i = idx, #str do
-    if set[str:sub(i, i)] ~= negate then
-      return i
-    end
-  end
-  return #str + 1
-end
-
-
-local function decode_error(str, idx, msg)
-  local line_count = 1
-  local col_count = 1
-  for i = 1, idx - 1 do
-    col_count = col_count + 1
-    if str:sub(i, i) == "\n" then
-      line_count = line_count + 1
-      col_count = 1
-    end
-  end
-  error( string.format("%s at line %d col %d", msg, line_count, col_count) )
-end
-
-
-local function codepoint_to_utf8(n)
-  -- http://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&id=iws-appendixa
-  local f = math.floor
-  if n <= 0x7f then
-    return string.char(n)
-  elseif n <= 0x7ff then
-    return string.char(f(n / 64) + 192, n % 64 + 128)
-  elseif n <= 0xffff then
-    return string.char(f(n / 4096) + 224, f(n % 4096 / 64) + 128, n % 64 + 128)
-  elseif n <= 0x10ffff then
-    return string.char(f(n / 262144) + 240, f(n % 262144 / 4096) + 128,
-                       f(n % 4096 / 64) + 128, n % 64 + 128)
-  end
-  error( string.format("invalid unicode codepoint '%x'", n) )
-end
-
-
-local function parse_unicode_escape(s)
-  local n1 = tonumber( s:sub(1, 4),  16 )
-  local n2 = tonumber( s:sub(7, 10), 16 )
-   -- Surrogate pair?
-  if n2 then
-    return codepoint_to_utf8((n1 - 0xd800) * 0x400 + (n2 - 0xdc00) + 0x10000)
-  else
-    return codepoint_to_utf8(n1)
-  end
-end
-
-
-local function parse_string(str, i)
-  local res = ""
-  local j = i + 1
-  local k = j
-
-  while j <= #str do
-    local x = str:byte(j)
-
-    if x < 32 then
-      decode_error(str, j, "control character in string")
-
-    elseif x == 92 then -- `\`: Escape
-      res = res .. str:sub(k, j - 1)
-      j = j + 1
-      local c = str:sub(j, j)
-      if c == "u" then
-        local hex = str:match("^[dD][89aAbB]%x%x\\u%x%x%x%x", j + 1)
-                 or str:match("^%x%x%x%x", j + 1)
-                 or decode_error(str, j - 1, "invalid unicode escape in string")
-        res = res .. parse_unicode_escape(hex)
-        j = j + #hex
-      else
-        if not escape_chars[c] then
-          decode_error(str, j - 1, "invalid escape char '" .. c .. "' in string")
-        end
-        res = res .. escape_char_map_inv[c]
-      end
-      k = j + 1
-
-    elseif x == 34 then -- `"`: End of string
-      res = res .. str:sub(k, j - 1)
-      return res, j + 1
-    end
-
-    j = j + 1
-  end
-
-  decode_error(str, i, "expected closing quote for string")
-end
-
-
-local function parse_number(str, i)
-  local x = next_char(str, i, delim_chars)
-  local s = str:sub(i, x - 1)
-  local n = tonumber(s)
-  if not n then
-    decode_error(str, i, "invalid number '" .. s .. "'")
-  end
-  return n, x
-end
-
-
-local function parse_literal(str, i)
-  local x = next_char(str, i, delim_chars)
-  local word = str:sub(i, x - 1)
-  if not literals[word] then
-    decode_error(str, i, "invalid literal '" .. word .. "'")
-  end
-  return literal_map[word], x
-end
-
-
-local function parse_array(str, i)
-  local res = {}
-  local n = 1
-  i = i + 1
-  while 1 do
-    local x
-    i = next_char(str, i, space_chars, true)
-    -- Empty / end of array?
-    if str:sub(i, i) == "]" then
-      i = i + 1
-      break
-    end
-    -- Read token
-    x, i = parse(str, i)
-    res[n] = x
-    n = n + 1
-    -- Next token
-    i = next_char(str, i, space_chars, true)
-    local chr = str:sub(i, i)
-    i = i + 1
-    if chr == "]" then break end
-    if chr ~= "," then decode_error(str, i, "expected ']' or ','") end
-  end
-  return res, i
-end
-
-
-local function parse_object(str, i)
-  local res = {}
-  i = i + 1
-  while 1 do
-    local key, val
-    i = next_char(str, i, space_chars, true)
-    -- Empty / end of object?
-    if str:sub(i, i) == "}" then
-      i = i + 1
-      break
-    end
-    -- Read key
-    if str:sub(i, i) ~= '"' then
-      decode_error(str, i, "expected string for key")
-    end
-    key, i = parse(str, i)
-    -- Read ':' delimiter
-    i = next_char(str, i, space_chars, true)
-    if str:sub(i, i) ~= ":" then
-      decode_error(str, i, "expected ':' after key")
-    end
-    i = next_char(str, i + 1, space_chars, true)
-    -- Read value
-    val, i = parse(str, i)
-    -- Set
-    res[key] = val
-    -- Next token
-    i = next_char(str, i, space_chars, true)
-    local chr = str:sub(i, i)
-    i = i + 1
-    if chr == "}" then break end
-    if chr ~= "," then decode_error(str, i, "expected '}' or ','") end
-  end
-  return res, i
-end
-
-
-local char_func_map = {
-  [ '"' ] = parse_string,
-  [ "0" ] = parse_number,
-  [ "1" ] = parse_number,
-  [ "2" ] = parse_number,
-  [ "3" ] = parse_number,
-  [ "4" ] = parse_number,
-  [ "5" ] = parse_number,
-  [ "6" ] = parse_number,
-  [ "7" ] = parse_number,
-  [ "8" ] = parse_number,
-  [ "9" ] = parse_number,
-  [ "-" ] = parse_number,
-  [ "t" ] = parse_literal,
-  [ "f" ] = parse_literal,
-  [ "n" ] = parse_literal,
-  [ "[" ] = parse_array,
-  [ "{" ] = parse_object,
-}
-
-
-parse = function(str, idx)
-  local chr = str:sub(idx, idx)
-  local f = char_func_map[chr]
-  if f then
-    return f(str, idx)
-  end
-  decode_error(str, idx, "unexpected character '" .. chr .. "'")
-end
-
-
-function json.decode(str)
-  if type(str) ~= "string" then
-    error("expected argument of type string, got " .. type(str))
-  end
-  local res, idx = parse(str, next_char(str, 1, space_chars, true))
-  idx = next_char(str, idx, space_chars, true)
-  if idx <= #str then
-    decode_error(str, idx, "trailing garbage")
-  end
-  return res
-end
-
-
-return json
\ No newline at end of file
diff --git a/data/textures/icon.png b/data/textures/icon.png
deleted file mode 100644
index cf1a562d..00000000
Binary files a/data/textures/icon.png and /dev/null differ
diff --git a/data/textures/skybox/back.png b/data/textures/skybox/back.png
deleted file mode 100644
index 319ec74b..00000000
Binary files a/data/textures/skybox/back.png and /dev/null differ
diff --git a/data/textures/skybox/down.png b/data/textures/skybox/down.png
deleted file mode 100644
index 45378bfd..00000000
Binary files a/data/textures/skybox/down.png and /dev/null differ
diff --git a/data/textures/skybox/front.png b/data/textures/skybox/front.png
deleted file mode 100644
index 8005011e..00000000
Binary files a/data/textures/skybox/front.png and /dev/null differ
diff --git a/data/textures/skybox/left.png b/data/textures/skybox/left.png
deleted file mode 100644
index dfcc1329..00000000
Binary files a/data/textures/skybox/left.png and /dev/null differ
diff --git a/data/textures/skybox/right.png b/data/textures/skybox/right.png
deleted file mode 100644
index 9ab3fe69..00000000
Binary files a/data/textures/skybox/right.png and /dev/null differ
diff --git a/data/textures/skybox/up.png b/data/textures/skybox/up.png
deleted file mode 100644
index 8a665b3a..00000000
Binary files a/data/textures/skybox/up.png and /dev/null differ
diff --git a/debug.sh b/debug.sh
new file mode 100644
index 00000000..d74a4108
--- /dev/null
+++ b/debug.sh
@@ -0,0 +1,8 @@
+#!/bin/bash
+cd bin
+PREFIX=$(cat ./exe/default.config)
+cp ./exe/lib/win64/*.dll .
+cp ./exe/lib/win64/$PREFIX/*.dll .
+gdb ./exe/program.$PREFIX.exe
+rm *.dll
+
diff --git a/engine/inc/AL/alut.h b/engine/inc/AL/alut.h
new file mode 100644
index 00000000..4b05a3cb
--- /dev/null
+++ b/engine/inc/AL/alut.h
@@ -0,0 +1,126 @@
+#if !defined(AL_ALUT_H)
+#define AL_ALUT_H
+
+#if defined(_MSC_VER)
+#include <alc.h>
+#include <al.h>
+#elif defined(__APPLE__)
+#include <OpenAL/alc.h>
+#include <OpenAL/al.h>
+#else
+#include <AL/al.h>
+#include <AL/alc.h>
+#endif
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#if defined(_WIN32) && !defined(_XBOX)
+ #if defined (ALUT_BUILD_LIBRARY)
+  #define ALUT_API __declspec(dllexport)
+ #else
+  #define ALUT_API __declspec(dllimport)
+ #endif
+#else
+ #if defined(ALUT_BUILD_LIBRARY) && defined(HAVE_GCC_VISIBILITY)
+  #define ALUT_API __attribute__((visibility("default")))
+ #else
+  #define ALUT_API extern
+ #endif
+#endif
+
+#if defined(_WIN32)
+ #define ALUT_APIENTRY __cdecl
+#else
+ #define ALUT_APIENTRY
+#endif
+
+#if defined(__MWERKS_)
+ #pragma export on
+#endif
+
+/* Flag deprecated functions if possible (VisualC++ .NET and GCC >= 3.1.1). */
+#if defined(_MSC_VER) && _MSC_VER >= 1300 && !defined(MIDL_PASS)
+#define ALUT_ATTRIBUTE_DEPRECATED __declspec(deprecated)
+#elif defined(__GNUC__) &&  (__GNUC__ > 3 || (__GNUC__ == 3 && (__GNUC_MINOR__ > 1 || (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ >= 1))))
+#define ALUT_ATTRIBUTE_DEPRECATED __attribute__((deprecated))
+#else
+#define ALUT_ATTRIBUTE_DEPRECATED
+#endif
+
+#define ALUT_API_MAJOR_VERSION                 1
+#define ALUT_API_MINOR_VERSION                 1
+
+#define ALUT_ERROR_NO_ERROR                    0
+#define ALUT_ERROR_OUT_OF_MEMORY               0x200
+#define ALUT_ERROR_INVALID_ENUM                0x201
+#define ALUT_ERROR_INVALID_VALUE               0x202
+#define ALUT_ERROR_INVALID_OPERATION           0x203
+#define ALUT_ERROR_NO_CURRENT_CONTEXT          0x204
+#define ALUT_ERROR_AL_ERROR_ON_ENTRY           0x205
+#define ALUT_ERROR_ALC_ERROR_ON_ENTRY          0x206
+#define ALUT_ERROR_OPEN_DEVICE                 0x207
+#define ALUT_ERROR_CLOSE_DEVICE                0x208
+#define ALUT_ERROR_CREATE_CONTEXT              0x209
+#define ALUT_ERROR_MAKE_CONTEXT_CURRENT        0x20A
+#define ALUT_ERROR_DESTROY_CONTEXT             0x20B
+#define ALUT_ERROR_GEN_BUFFERS                 0x20C
+#define ALUT_ERROR_BUFFER_DATA                 0x20D
+#define ALUT_ERROR_IO_ERROR                    0x20E
+#define ALUT_ERROR_UNSUPPORTED_FILE_TYPE       0x20F
+#define ALUT_ERROR_UNSUPPORTED_FILE_SUBTYPE    0x210
+#define ALUT_ERROR_CORRUPT_OR_TRUNCATED_DATA   0x211
+
+#define ALUT_WAVEFORM_SINE                     0x100
+#define ALUT_WAVEFORM_SQUARE                   0x101
+#define ALUT_WAVEFORM_SAWTOOTH                 0x102
+#define ALUT_WAVEFORM_WHITENOISE               0x103
+#define ALUT_WAVEFORM_IMPULSE                  0x104
+
+#define ALUT_LOADER_BUFFER                     0x300
+#define ALUT_LOADER_MEMORY                     0x301
+
+ALUT_API ALboolean ALUT_APIENTRY alutInit (int *argcp, char **argv);
+ALUT_API ALboolean ALUT_APIENTRY alutInitWithoutContext (int *argcp, char **argv);
+ALUT_API ALboolean ALUT_APIENTRY alutExit (void);
+
+ALUT_API ALenum ALUT_APIENTRY alutGetError (void);
+ALUT_API const char *ALUT_APIENTRY alutGetErrorString (ALenum error);
+
+ALUT_API ALuint ALUT_APIENTRY alutCreateBufferFromFile (const char *fileName);
+ALUT_API ALuint ALUT_APIENTRY alutCreateBufferFromFileImage (const ALvoid *data, ALsizei length);
+ALUT_API ALuint ALUT_APIENTRY alutCreateBufferHelloWorld (void);
+ALUT_API ALuint ALUT_APIENTRY alutCreateBufferWaveform (ALenum waveshape, ALfloat frequency, ALfloat phase, ALfloat duration);
+
+ALUT_API ALvoid *ALUT_APIENTRY alutLoadMemoryFromFile (const char *fileName, ALenum *format, ALsizei *size, ALfloat *frequency);
+ALUT_API ALvoid *ALUT_APIENTRY alutLoadMemoryFromFileImage (const ALvoid *data, ALsizei length, ALenum *format, ALsizei *size, ALfloat *frequency);
+ALUT_API ALvoid *ALUT_APIENTRY alutLoadMemoryHelloWorld (ALenum *format, ALsizei *size, ALfloat *frequency);
+ALUT_API ALvoid *ALUT_APIENTRY alutLoadMemoryWaveform (ALenum waveshape, ALfloat frequency, ALfloat phase, ALfloat duration, ALenum *format, ALsizei *size, ALfloat *freq);
+
+ALUT_API const char *ALUT_APIENTRY alutGetMIMETypes (ALenum loader);
+
+ALUT_API ALint ALUT_APIENTRY alutGetMajorVersion (void);
+ALUT_API ALint ALUT_APIENTRY alutGetMinorVersion (void);
+
+ALUT_API ALboolean ALUT_APIENTRY alutSleep (ALfloat duration);
+
+/* Nasty Compatibility stuff, WARNING: THESE FUNCTIONS ARE STRONGLY DEPRECATED */
+#if defined(__APPLE__)
+ALUT_API ALUT_ATTRIBUTE_DEPRECATED void ALUT_APIENTRY alutLoadWAVFile (ALbyte *fileName, ALenum *format, void **data, ALsizei *size, ALsizei *frequency);
+ALUT_API ALUT_ATTRIBUTE_DEPRECATED void ALUT_APIENTRY alutLoadWAVMemory (ALbyte *buffer, ALenum *format, void **data, ALsizei *size, ALsizei *frequency);
+#else
+ALUT_API ALUT_ATTRIBUTE_DEPRECATED void ALUT_APIENTRY alutLoadWAVFile (ALbyte *fileName, ALenum *format, void **data, ALsizei *size, ALsizei *frequency, ALboolean *loop);
+ALUT_API ALUT_ATTRIBUTE_DEPRECATED void ALUT_APIENTRY alutLoadWAVMemory (ALbyte *buffer, ALenum *format, void **data, ALsizei *size, ALsizei *frequency, ALboolean *loop);
+#endif
+ALUT_API ALUT_ATTRIBUTE_DEPRECATED void ALUT_APIENTRY alutUnloadWAV (ALenum format, ALvoid *data, ALsizei size, ALsizei frequency);
+
+#if defined(__MWERKS_)
+ #pragma export off
+#endif
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif
diff --git a/engine/inc/ActiveSocket.h b/engine/inc/ActiveSocket.h
new file mode 100644
index 00000000..5c2d0df4
--- /dev/null
+++ b/engine/inc/ActiveSocket.h
@@ -0,0 +1,92 @@
+/*---------------------------------------------------------------------------*/
+/*                                                                           */
+/* ActiveSocket.h - Active Socket Decleration                                */
+/*                                                                           */
+/* Author : Mark Carrier (mark@carrierlabs.com)                              */
+/*                                                                           */
+/*---------------------------------------------------------------------------*/
+/* Copyright (c) 2007-2009 CarrierLabs, LLC.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * 4. The name "CarrierLabs" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    mark@carrierlabs.com.
+ *
+ * THIS SOFTWARE IS PROVIDED BY MARK CARRIER ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL MARK CARRIER OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ *----------------------------------------------------------------------------*/
+#ifndef __ACTIVESOCKET_H__
+#define __ACTIVESOCKET_H__
+
+#include "SimpleSocket.h"
+
+class CPassiveSocket;
+
+/// Provides a platform independent class to create an active socket.
+/// An active socket is used to create a socket which connects to a server.
+/// This type of object would be used when an application needs to send/receive
+/// data from a server.
+class CActiveSocket : public CSimpleSocket
+{
+public:
+	friend class CPassiveSocket;
+
+	CActiveSocket(CSocketType type = SocketTypeTcp);
+	virtual ~CActiveSocket()
+	{
+		Close();
+	};
+
+	/// Established a connection to the address specified by pAddr.
+	/// Connection-based protocol sockets (CSocket::SocketTypeTcp) may
+	/// successfully call Open() only once, however; connectionless protocol
+	/// sockets (CSocket::SocketTypeUdp) may use Open() multiple times to
+	/// change their association.
+	///  @param pAddr specifies the destination address to connect.
+	///  @param nPort specifies the destination port.
+	///  @return true if successful connection made, otherwise false.
+	virtual bool Open(const char *pAddr, uint16 nPort);
+
+private:
+	/// Utility function used to create a TCP connection, called from Open().
+	///  @return true if successful connection made, otherwise false.
+	bool ConnectTCP(const char *pAddr, uint16 nPort);
+
+	/// Utility function used to create a UDP connection, called from Open().
+	///  @return true if successful connection made, otherwise false.
+	bool ConnectUDP(const char *pAddr, uint16 nPort);
+
+	/// Utility function used to create a RAW connection, called from Open().
+	///  @return true if successful connection made, otherwise false.
+	bool ConnectRAW(const char *pAddr, uint16 nPort);
+
+private:
+	struct hostent *m_pHE;
+};
+
+#endif /*  __ACTIVESOCKET_H__  */
diff --git a/engine/inc/AppCore/App.h b/engine/inc/AppCore/App.h
new file mode 100644
index 00000000..0236c2de
--- /dev/null
+++ b/engine/inc/AppCore/App.h
@@ -0,0 +1,182 @@
+///
+/// @file App.h
+///
+/// @brief The header for the App class.
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2019 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+#include "Defines.h"
+#include <Ultralight/RefPtr.h>
+#include <Ultralight/Renderer.h>
+#include <Ultralight/platform/Config.h>
+
+namespace ultralight {
+
+class Monitor;
+class Window;
+
+///
+/// Interface for all App-related events. @see App::set_listener
+///
+class AExport AppListener {
+public:
+  virtual ~AppListener() {}
+
+  ///
+  /// Called whenever the App updates. You should update all app logic here.
+  ///
+  /// @note  This event is fired right before the run loop calls
+  ///        Renderer::Update and Renderer::Render.
+  ///
+  virtual void OnUpdate() {}
+};
+
+///
+/// App-specific settings.
+///
+struct AExport Settings {
+  ///
+  /// The name of the developer of this app.
+  ///
+  /// This is used to generate a unique path to store local application data
+  /// on the user's machine.
+  ///
+  String developer_name = "MyCompany";
+
+  ///
+  /// The name of this app.
+  ///
+  /// This is used to generate a unique path to store local application data
+  /// on the user's machine.
+  ///
+  String app_name = "MyApp";
+
+  ///
+  /// The root file path for our file system. You should set this to the
+  /// relative path where all of your app data is.
+  ///
+  /// This will be used to resolve all file URLs, eg file:///page.html
+  ///
+  /// @note  This relative path is resolved using the following logic:
+  ///         - Windows: relative to the executable path
+  ///         - Linux:   relative to the executable path
+  ///         - macOS:   relative to YourApp.app/Contents/Resources/
+  ///
+  String file_system_path = "./assets/";
+
+  ///
+  /// Whether or not we should load and compile shaders from the file system
+  /// (eg, from the /shaders/ path, relative to file_system_path).
+  ///
+  /// If this is false (the default), we will instead load pre-compiled shaders
+  /// from memory which speeds up application startup time.
+  ///
+  bool load_shaders_from_file_system = false;
+
+  ///
+  /// We try to use the GPU renderer when a compatible GPU is detected.
+  ///
+  /// Set this to true to force the engine to always use the CPU renderer.
+  ///
+  bool force_cpu_renderer = false;
+};
+
+///
+/// Main application class.
+///
+class AExport App : public RefCounted {
+public:
+  ///
+  /// Create the App singleton.
+  ///
+  /// @param  settings  Settings to customize App runtime behavior.
+  ///
+  /// @param  config  Config options for the Ultralight renderer.
+  ///
+  /// @return  Returns a ref-pointer to the created App instance.
+  ///
+  /// @note  You should only create one of these per application lifetime.
+  ///
+  /// @note  Certain Config options may be overridden during App creation,
+  ///        most commonly Config::face_winding and Config::device_scale_hint.
+  ///
+  static Ref<App> Create(Settings settings = Settings(), Config config = Config());
+
+  ///
+  /// Get the App singleton.
+  ///
+  static App* instance();
+
+  ///
+  /// Get the settings this App was created with.
+  ///
+  virtual const Settings& settings() const = 0;
+
+  ///
+  /// Set the main window. You must set this before calling Run.
+  ///
+  /// @param  window  The window to use for all rendering.
+  ///
+  /// @note  We currently only support one Window per App, this will change
+  ///        later once we add support for multiple driver instances.
+  ///
+  virtual void set_window(Ref<Window> window) = 0;
+
+  ///
+  /// Get the main window.
+  ///
+  virtual RefPtr<Window> window() = 0;
+
+  ///
+  /// Set an AppListener to receive callbacks for app-related events.
+  ///
+  /// @note  Ownership remains with the caller.
+  ///
+  virtual void set_listener(AppListener* listener) = 0;
+
+  ///
+  /// Get the AppListener, if any.
+  ///
+  virtual AppListener* listener() = 0;
+
+  ///
+  /// Whether or not the App is running.
+  ///
+  virtual bool is_running() const = 0;
+
+  ///
+  /// Get the main monitor (this is never NULL).
+  ///
+  /// @note  We'll add monitor enumeration later.
+  ///
+  virtual Monitor* main_monitor() = 0;
+
+  ///
+  /// Get the underlying Renderer instance.
+  ///
+  virtual Ref<Renderer> renderer() = 0;
+
+  ///
+  /// Run the main loop.
+  ///
+  /// @note  Make sure to call set_window before calling this.
+  ///
+  virtual void Run() = 0;
+
+  ///
+  /// Quit the application.
+  ///
+  virtual void Quit() = 0;
+
+protected:
+  virtual ~App();
+};
+
+}  // namespace ultralight
diff --git a/engine/inc/AppCore/AppCore.h b/engine/inc/AppCore/AppCore.h
new file mode 100644
index 00000000..00fad093
--- /dev/null
+++ b/engine/inc/AppCore/AppCore.h
@@ -0,0 +1,6 @@
+#include <AppCore/App.h>
+#include <AppCore/Monitor.h>
+#include <AppCore/Window.h>
+#include <AppCore/Overlay.h>
+#include <AppCore/JSHelpers.h>
+#include <AppCore/Platform.h>
\ No newline at end of file
diff --git a/engine/inc/AppCore/CAPI.h b/engine/inc/AppCore/CAPI.h
new file mode 100644
index 00000000..e28a43b3
--- /dev/null
+++ b/engine/inc/AppCore/CAPI.h
@@ -0,0 +1,448 @@
+///
+/// @file CAPI.h
+///
+/// @brief The C-language API for AppCore
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+#ifndef APPCORE_CAPI_H
+#define APPCORE_CAPI_H
+
+#include <Ultralight/CAPI.h>
+
+#if defined(__WIN32__) || defined(_WIN32)
+#  if defined(APPCORE_IMPLEMENTATION)
+#    define ACExport __declspec(dllexport)
+#  else
+#    define ACExport __declspec(dllimport)
+#  endif
+#else
+#  define ACExport __attribute__((visibility("default")))
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct C_Settings* ULSettings;
+typedef struct C_App* ULApp;
+typedef struct C_Window* ULWindow;
+typedef struct C_Monitor* ULMonitor;
+typedef struct C_Overlay* ULOverlay;
+
+///
+/// Window creation flags. @see Window::Create
+///
+typedef enum {
+  kWindowFlags_Borderless = 1 << 0,
+  kWindowFlags_Titled = 1 << 1,
+  kWindowFlags_Resizable = 1 << 2,
+  kWindowFlags_Maximizable = 1 << 3,
+} ULWindowFlags;
+
+///
+/// Create settings with default values (see <AppCore/App.h>).
+///
+ACExport ULSettings ulCreateSettings();
+
+///
+/// Destroy settings.
+///
+ACExport void ulDestroySettings(ULSettings settings);
+
+///
+/// Set the name of the developer of this app.
+///
+/// This is used to generate a unique path to store local application data
+/// on the user's machine.
+///
+/// Default is "MyCompany"
+///
+ACExport void ulSettingsSetDeveloperName(ULSettings settings, ULString name);
+
+///
+/// Set the name of this app.
+///
+/// This is used to generate a unique path to store local application data
+/// on the user's machine.
+///
+/// Default is "MyApp"
+///
+ACExport void ulSettingsSetAppName(ULSettings settings, ULString name);
+
+///
+/// Set the root file path for our file system, you should set this to the
+/// relative path where all of your app data is.
+///
+/// This will be used to resolve all file URLs, eg file:///page.html
+///
+/// @note  The default path is "./assets/"
+///        
+///        This relative path is resolved using the following logic:
+///         - Windows: relative to the executable path
+///         - Linux:   relative to the executable path
+///         - macOS:   relative to YourApp.app/Contents/Resources/
+///
+ACExport void ulSettingsSetFileSystemPath(ULSettings settings, ULString path);
+
+///
+/// Set whether or not we should load and compile shaders from the file system
+/// (eg, from the /shaders/ path, relative to file_system_path).
+///
+/// If this is false (the default), we will instead load pre-compiled shaders
+/// from memory which speeds up application startup time.
+///
+ACExport void ulSettingsSetLoadShadersFromFileSystem(ULSettings settings,
+                                                     bool enabled);
+
+///
+/// We try to use the GPU renderer when a compatible GPU is detected.
+///
+/// Set this to true to force the engine to always use the CPU renderer.
+///
+ACExport void ulSettingsSetForceCPURenderer(ULSettings settings,
+                                            bool force_cpu);
+///
+/// Create the App singleton.
+///
+/// @param  settings  Settings to customize App runtime behavior. You can pass
+///                   NULL for this parameter to use default settings.
+///
+/// @param  config  Config options for the Ultralight renderer. You can pass
+///                 NULL for this parameter to use default config.
+///
+/// @note  You should only create one of these per application lifetime.
+///        
+/// @note  Certain Config options may be overridden during App creation,
+///        most commonly Config::face_winding and Config::device_scale_hint.
+///
+ACExport ULApp ulCreateApp(ULSettings settings, ULConfig config);
+
+///
+/// Destroy the App instance.
+///
+ACExport void ulDestroyApp(ULApp app);
+
+///
+/// Set the main window, you must set this before calling ulAppRun.
+///
+/// @param  window  The window to use for all rendering.
+///
+/// @note  We currently only support one Window per App, this will change
+///        later once we add support for multiple driver instances.
+///
+ACExport void ulAppSetWindow(ULApp app, ULWindow window);
+
+///
+/// Get the main window.
+///
+ACExport ULWindow ulAppGetWindow(ULApp app);
+
+typedef void
+(*ULUpdateCallback) (void* user_data);
+
+///
+/// Set a callback for whenever the App updates. You should update all app
+/// logic here.
+///
+/// @note  This event is fired right before the run loop calls
+///        Renderer::Update and Renderer::Render.
+///
+ACExport void ulAppSetUpdateCallback(ULApp app, ULUpdateCallback callback,
+                                     void* user_data);
+
+///
+/// Whether or not the App is running.
+///
+ACExport bool ulAppIsRunning(ULApp app);
+
+///
+/// Get the main monitor (this is never NULL).
+///
+/// @note  We'll add monitor enumeration later.
+///
+ACExport ULMonitor ulAppGetMainMonitor(ULApp app);
+
+///
+/// Get the underlying Renderer instance.
+///
+ACExport ULRenderer ulAppGetRenderer(ULApp app);
+
+///
+/// Run the main loop, make sure to call ulAppSetWindow before calling this.
+///
+ACExport void ulAppRun(ULApp app);
+
+///
+/// Quit the application.
+///
+ACExport void ulAppQuit(ULApp app);
+
+///
+/// Get the monitor's DPI scale (1.0 = 100%).
+///
+ACExport double ulMonitorGetScale(ULMonitor monitor);
+
+///
+/// Get the width of the monitor (in pixels).
+///
+ACExport unsigned int ulMonitorGetWidth(ULMonitor monitor);
+
+///
+/// Get the height of the monitor (in pixels).
+///
+ACExport unsigned int ulMonitorGetHeight(ULMonitor monitor);
+
+///
+/// Create a new Window.
+///
+/// @param  monitor       The monitor to create the Window on.
+///
+/// @param  width         The width (in device coordinates).
+///
+/// @param  height        The height (in device coordinates).
+///
+/// @param  fullscreen    Whether or not the window is fullscreen.
+///
+/// @param  window_flags  Various window flags.
+///
+ACExport ULWindow ulCreateWindow(ULMonitor monitor, unsigned int width,
+	                               unsigned int height, bool fullscreen,
+                                 unsigned int window_flags);
+
+///
+/// Destroy a Window.
+///
+ACExport void ulDestroyWindow(ULWindow window);
+
+typedef void
+(*ULCloseCallback) (void* user_data);
+
+///
+/// Set a callback to be notified when a window closes.
+///
+ACExport void ulWindowSetCloseCallback(ULWindow window,
+                                       ULCloseCallback callback,
+                                       void* user_data);
+
+typedef void
+(*ULResizeCallback) (void* user_data, unsigned int width, unsigned int height);
+
+///
+/// Set a callback to be notified when a window resizes
+/// (parameters are passed back in pixels).
+///
+ACExport void ulWindowSetResizeCallback(ULWindow window,
+                                        ULResizeCallback callback,
+                                        void* user_data);
+
+///
+/// Get window width (in pixels).
+///
+ACExport unsigned int ulWindowGetWidth(ULWindow window);
+
+///
+/// Get window height (in pixels).
+///
+ACExport unsigned int ulWindowGetHeight(ULWindow window);
+
+///
+/// Get whether or not a window is fullscreen.
+///
+ACExport bool ulWindowIsFullscreen(ULWindow window);
+
+///
+/// Get the DPI scale of a window.
+///
+ACExport double ulWindowGetScale(ULWindow window);
+
+///
+/// Set the window title.
+///
+ACExport void ulWindowSetTitle(ULWindow window, const char* title);
+
+///
+/// Set the cursor for a window.
+///
+ACExport void ulWindowSetCursor(ULWindow window, ULCursor cursor);
+
+///
+/// Close a window.
+///
+ACExport void ulWindowClose(ULWindow window);
+
+///
+/// Convert device coordinates to pixels using the current DPI scale.
+///
+ACExport int ulWindowDeviceToPixel(ULWindow window, int val);
+
+///
+/// Convert pixels to device coordinates using the current DPI scale.
+///
+ACExport int ulWindowPixelsToDevice(ULWindow window, int val);
+
+///
+/// Get the underlying native window handle.
+///
+/// @note This is:  - HWND on Windows
+///                 - NSWindow* on macOS
+///                 - GLFWwindow* on Linux
+///
+ACExport void* ulWindowGetNativeHandle(ULWindow window);
+
+///
+/// Create a new Overlay.
+///
+/// @param  window  The window to create the Overlay in. (we currently only
+///                 support one window per application)
+///
+/// @param  width   The width in device coordinates.
+///
+/// @param  height  The height in device coordinates.
+///
+/// @param  x       The x-position (offset from the left of the Window), in
+///                 pixels.
+///
+/// @param  y       The y-position (offset from the top of the Window), in
+///                 pixels.
+///
+/// @note  Each Overlay is essentially a View and an on-screen quad. You should
+///        create the Overlay then load content into the underlying View.
+///
+ACExport ULOverlay ulCreateOverlay(ULWindow window, unsigned int width,
+                                   unsigned int height, int x, int y);
+
+///
+/// Create a new Overlay, wrapping an existing View.
+///
+/// @param  window  The window to create the Overlay in. (we currently only
+///                 support one window per application)
+///
+/// @param  view    The View to wrap (will use its width and height).
+///
+/// @param  x       The x-position (offset from the left of the Window), in
+///                 pixels.
+///
+/// @param  y       The y-position (offset from the top of the Window), in
+///                 pixels.
+///
+/// @note  Each Overlay is essentially a View and an on-screen quad. You should
+///        create the Overlay then load content into the underlying View.
+///
+ACExport ULOverlay ulCreateOverlayWithView(ULWindow window, ULView view, 
+                                           int x, int y);
+
+///
+/// Destroy an overlay.
+///
+ACExport void ulDestroyOverlay(ULOverlay overlay);
+
+///
+/// Get the underlying View.
+///
+ACExport ULView ulOverlayGetView(ULOverlay overlay);
+
+///
+/// Get the width (in pixels).
+///
+ACExport unsigned int ulOverlayGetWidth(ULOverlay overlay);
+
+///
+/// Get the height (in pixels).
+///
+ACExport unsigned int ulOverlayGetHeight(ULOverlay overlay);
+
+///
+/// Get the x-position (offset from the left of the Window), in pixels.
+///
+ACExport int ulOverlayGetX(ULOverlay overlay);
+
+///
+/// Get the y-position (offset from the top of the Window), in pixels.
+///
+ACExport int ulOverlayGetY(ULOverlay overlay);
+
+///
+/// Move the overlay to a new position (in pixels).
+///
+ACExport void ulOverlayMoveTo(ULOverlay overlay, int x, int y);
+
+///
+/// Resize the overlay (and underlying View), dimensions should be
+/// specified in pixels.
+///
+ACExport void ulOverlayResize(ULOverlay overlay, unsigned int width,
+                              unsigned int height);
+
+///
+/// Whether or not the overlay is hidden (not drawn).
+///
+ACExport bool ulOverlayIsHidden(ULOverlay overlay);
+
+///
+/// Hide the overlay (will no longer be drawn).
+///
+ACExport void ulOverlayHide(ULOverlay overlay);
+
+///
+/// Show the overlay.
+///
+ACExport void ulOverlayShow(ULOverlay overlay);
+
+///
+/// Whether or not an overlay has keyboard focus.
+///
+ACExport bool ulOverlayHasFocus(ULOverlay overlay);
+
+///
+/// Grant this overlay exclusive keyboard focus.
+///
+ACExport void ulOverlayFocus(ULOverlay overlay);
+
+///
+/// Remove keyboard focus.
+///
+ACExport void ulOverlayUnfocus(ULOverlay overlay);
+
+/******************************************************************************
+ * Platform
+ *****************************************************************************/
+
+///
+/// This is only needed if you are not calling ulCreateApp().
+///
+/// Initializes the platform font loader and sets it as the current FontLoader.
+///
+ACExport void ulEnablePlatformFontLoader();
+
+///
+/// This is only needed if you are not calling ulCreateApp().
+///
+/// Initializes the platform file system (needed for loading file:/// URLs) and
+/// sets it as the current FileSystem.
+///
+/// You can specify a base directory path to resolve relative paths against.
+///
+ACExport void ulEnablePlatformFileSystem(ULString base_dir);
+
+///
+/// This is only needed if you are not calling ulCreateApp().
+///
+/// Initializes the default logger (writes the log to a file).
+///
+/// You should specify a writable log path to write the log to 
+/// for example "./ultralight.log".
+///
+ACExport void ulEnableDefaultLogger(ULString log_path);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // APPCORE_CAPI_H
diff --git a/engine/inc/AppCore/Defines.h b/engine/inc/AppCore/Defines.h
new file mode 100644
index 00000000..8c2e85eb
--- /dev/null
+++ b/engine/inc/AppCore/Defines.h
@@ -0,0 +1,42 @@
+// Copyright 2018 Ultralight, Inc. All rights reserved.
+#pragma once
+
+// Needed for limit defines, like INTMAX_MAX, which is used by the std C++ library
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS
+#endif
+
+#include <cstdint>
+#include <cstddef>
+#include <limits.h>
+
+#ifdef SWIG
+#define AExport
+#else
+
+// Require C++11 Support
+#if defined(_MSC_VER)
+#   if _MSC_VER < 1800 
+#       error This project needs at least Visual Studio 2013 to build
+#   endif
+#elif __cplusplus <= 199711L
+#   error This project can only be compiled with a compiler that supports C++11
+#endif
+
+
+#if defined(__WIN32__) || defined(_WIN32)
+#  if defined(APPCORE_IMPLEMENTATION)
+#    define AExport __declspec(dllexport)
+#  else
+#    define AExport __declspec(dllimport)
+#  endif
+#define _thread_local __declspec(thread)
+#ifndef _NATIVE_WCHAR_T_DEFINED
+#define DISABLE_NATIVE_WCHAR_T
+#endif
+#else
+#  define AExport __attribute__((visibility("default")))
+#define _thread_local __thread
+#endif
+
+#endif
diff --git a/engine/inc/AppCore/JSHelpers.h b/engine/inc/AppCore/JSHelpers.h
new file mode 100644
index 00000000..29493531
--- /dev/null
+++ b/engine/inc/AppCore/JSHelpers.h
@@ -0,0 +1,554 @@
+#pragma once
+#include <AppCore/Defines.h>
+#include <JavaScriptCore/JavaScript.h>
+#include <JavaScriptCore/JSStringRef.h>
+#include <Ultralight/String.h>
+#include <functional>
+#include <memory>
+
+namespace ultralight {
+
+///
+/// Set the current JSContext.
+///
+/// Most JavaScriptCore C API calls require an active JavaScript execution
+/// context (JSContextRef). You can get the JSContextRef for a page via
+/// `View::LockJSContext()`. This context changes with each page navigation.
+///
+/// **Note**:
+///    You MUST set a JSContext before using most of the C++ API below.
+///
+void AExport SetJSContext(JSContextRef ctx);
+
+///
+/// Get the current JSContext.
+///
+JSContextRef AExport GetJSContext();
+
+///
+/// JavaScript String wrapper that automatically manages JSStringRef lifetime
+/// and provides helpful conversions.
+///
+class AExport JSString {
+public:
+  /// Create empty string
+  JSString();
+
+  /// Create from C-string
+  JSString(const char* str);
+
+  /// Create from Ultralight String
+  JSString(const String& str);
+
+  /// Take ownership of existing JSStringRef (will not increase ref-count)
+  JSString(JSStringRef str);
+
+  /// Copy constructor (will increase ref-count)
+  JSString(const JSString& other);
+
+  /// Destructor
+  ~JSString();
+
+  /// Assignment operator (will increase ref-count)
+  JSString& operator=(const JSString& other);
+
+  /// Cast to String
+  operator String();
+
+  /// Cast to underlying JSStringRef
+  operator JSStringRef() const { return instance_; }
+
+protected:
+  JSStringRef instance_;
+};
+
+class JSArray;
+class JSObject;
+class JSFunction;
+
+/// Tag type used with the JSValue constructor to create "Null" types
+struct AExport JSValueNullTag {};
+
+/// Tag type used with the JSValue constructor to create "Undefined" types
+struct AExport JSValueUndefinedTag {};
+
+///
+/// JavaScript variant value wrapper that automatically manages JSValueRef 
+/// lifetime and provides helpful conversions.
+///
+class AExport JSValue {
+public:
+  /// Create null (empty) JSValue
+  JSValue();
+
+  /// Create null JSValue explicitly
+  JSValue(JSValueNullTag);
+
+  /// Create undefined JSValue
+  JSValue(JSValueUndefinedTag);
+
+  /// Create boolean JSValue
+  JSValue(bool val);
+
+  /// Create unsigned integer JSValue (aka, Number) [will be cast to double]
+  JSValue(uint32_t val);
+
+  /// Create integer JSValue (aka, Number) [will be cast to double]
+  JSValue(int32_t val);
+
+  /// Create unsigned integer JSValue (aka, Number) [will be cast to double]
+  JSValue(uint64_t val);
+
+  /// Create integer JSValue (aka, Number) [will be cast to double]
+  JSValue(int64_t val);
+
+  /// Create double JSValue (aka, Number)
+  JSValue(double val);
+
+  /// Create string JSValue
+  JSValue(const char* val);
+
+  /// Create string JSValue
+  JSValue(const String& val);
+
+  /// Create string JSValue
+  JSValue(JSString val);
+
+  /// Create from existing JSValueRef
+  JSValue(JSValueRef val);
+
+  /// Create object JSValue
+  JSValue(JSObjectRef obj);
+
+  /// Copy constructor, a shallow copy is made, the constructed JSValue will
+  /// point to the same JSValueRef.
+  JSValue(const JSValue& other);
+
+  /// Destructor
+  virtual ~JSValue();
+
+  /// A shallow copy is made, this JSValue will point to the same JSValueRef
+  virtual JSValue& operator=(const JSValue& other);
+
+  /// Whether or not the value is a JavaScript Null type.
+  bool IsNull() const;
+
+  /// Whether or not the value is a JavaScript Undefined type.
+  bool IsUndefined() const;
+
+  /// Whether or not the value is a JavaScript Boolean type.
+  bool IsBoolean() const;
+
+  /// Whether or not the value is a JavaScript Number type.
+  bool IsNumber() const;
+
+  /// Whether or not the value is a JavaScript String type.
+  bool IsString() const;
+
+  /// Whether or not the value is a JavaScript Object type.
+  bool IsObject() const;
+
+  /// Whether or not the value is a JavaScript Array type.
+  bool IsArray() const;
+
+  /// Whether or not the value is a JavaScript Function type.
+  bool IsFunction() const;
+
+  /// Get the value as a Boolean
+  bool ToBoolean() const;
+
+  /// Get the value as a Number (Double)
+  double ToNumber() const;
+
+  /// Get the value as a Number (Integer)
+  int64_t ToInteger() const { return static_cast<int64_t>(ToNumber()); }
+
+  /// Get the value as a String
+  JSString ToString() const;
+
+  /// Get the value as an Object (will debug assert if not an Object)
+  JSObject ToObject() const;
+
+  /// Get the value as an Array (will debug asset if not an Array)
+  JSArray ToArray() const;
+
+  /// Get the value as a Function (will debug asset if not a Function)
+  JSFunction ToFunction() const;
+
+  operator bool() const { return ToBoolean(); }
+
+  operator double() const { return ToNumber(); }
+
+  operator uint32_t() const { return static_cast<uint32_t>(ToNumber()); }
+
+  operator int32_t() const { return static_cast<uint32_t>(ToNumber()); }
+
+  operator uint64_t() const { return static_cast<uint64_t>(ToNumber()); }
+
+  operator int64_t() const { return ToInteger(); }
+
+  operator String() const { return ToString(); }
+
+  operator JSString() const { return ToString(); }
+
+  operator JSObject() const;
+
+  operator JSObjectRef() const;
+
+  operator JSArray() const;
+
+  operator JSFunction() const;
+
+  /// Get the underlying JSValueRef
+  operator JSValueRef() const { return instance(); }
+
+  ///
+  /// Get the bound context for this JSValue (it is cached at creation).
+  ///
+  JSContextRef context() const { return ctx_; }
+
+  ///
+  /// Set the JSContext for this JSValue.
+  ///
+  /// **Note**:
+  ///    JSValues created from within a JSCallback have a temporary JSContext
+  ///    that is destroyed when the callback returns. You will need to "move"
+  ///    any JSValues created within these callbacks to the View's main context
+  ///    (call set_context() with the main context) before using them outside
+  ///    the callback.
+  ///
+  void set_context(JSContextRef context) { ctx_ = context; }
+
+protected:
+  JSValue(JSContextRef ctx);
+  JSValue(JSContextRef ctx, JSValueRef val);
+  virtual JSValueRef instance() const;
+
+  JSContextRef ctx_;
+  JSValueRef instance_ = nullptr;
+  friend class JSFunction;
+};
+
+/// 
+/// A vector of JSValues, used for passing around arguments in JSCallback.
+/// 
+class AExport JSArgs {
+public:
+  /// Create an empty list of JavaScript arguments
+  JSArgs();
+
+  /// Create a list of JavaScript arguments using a C++ initializer list
+  JSArgs(const std::initializer_list<JSValue>& values);
+
+  /// Copy-constructor
+  JSArgs(const JSArgs& other);
+
+  /// Destructor
+  ~JSArgs();
+
+  /// Assignment operator
+  JSArgs& operator=(const JSArgs& other);
+
+  ///
+  /// Access an element of the argument list by index.
+  ///
+  /// **Note**:
+  ///    All JSValues are actually wrappers of JSValueRef instances so even
+  ///    though this function doesn't return a JSValue& you are still operating
+  ///    directly on the underlying JavaScript value instance.
+  ///
+  JSValue operator[](size_t pos);
+
+  ///
+  /// Access an element of the argument list by index. (const overload)
+  ///
+  /// **Note**:
+  ///    All JSValues are actually wrappers of JSValueRef instances so even
+  ///    though this function doesn't return a JSValue& you are still operating
+  ///    directly on the underlying JavaScript value instance.
+  ///
+  const JSValue operator[](size_t pos) const;
+
+  /// Whether or not the argument list is empty.
+  bool empty() const;
+
+  /// The number of elements in the argument list.
+  size_t size() const;
+
+  /// Clear the argument list.
+  void clear();
+
+  /// Add a new argument to the end of the list.
+  void push_back(const JSValue& val);
+
+  /// Remove the last item from the end of the list.
+  void pop_back();
+
+  /// Get the argument list as a C-array of JSValues
+  JSValue* data();
+
+  /// Get the argument list as a C-array of JSValues (const overload)
+  const JSValue* data() const;
+protected:
+  void* instance_;
+};
+
+///
+/// JSCallback typedef used for binding C++ callbacks to JavaScript functions.
+///
+/// Takes two arguments (const JSObject& thisObj, const JSArgs& args) and
+/// returns nothing (void).
+///   
+typedef std::function<void(const JSObject&, const JSArgs&)> JSCallback;
+
+///
+/// JSCallbackWithRetval typedef used for binding C++ callbacks to JavaScript
+/// functions with an optional return value.
+///
+/// Takes two arguments (const JSObject& thisObj, const JSArgs& args) and
+/// returns a JSValue back to JavaScript.
+///   
+typedef std::function<JSValue(const JSObject&, const JSArgs&)> JSCallbackWithRetval;
+
+///
+/// Macro to help bind C++ member functions to a JSCallback
+///
+/// Usage: JSCallback callback = BindJSCallback(&MyClass::MyMemberFunction);
+///
+/// **Note**: Expected to run from within an instance of 'MyClass', note the
+///           'this' keyword in the macro.
+///
+#define BindJSCallback(fn) (JSCallback)std::bind(fn, this, std::placeholders::_1, std::placeholders::_2)
+
+///
+/// Macro to help bind C++ member functions to a JSCallbackWithRetval
+///
+/// Usage: JSCallback callback = BindJSCallback(&MyClass::MyMemberFunction);
+///
+/// **Note**: Expected to run from within an instance of 'MyClass', note the
+///           'this' keyword in the macro.
+///
+#define BindJSCallbackWithRetval(fn) (JSCallbackWithRetval)std::bind(fn, this, std::placeholders::_1, std::placeholders::_2)
+
+/// 
+/// Wrapper for JSObject property value (JSValue subclass). Allows new value assignment
+/// to object property, binding C++ callbacks to object properties via function objects,
+/// as well as value query via the JSValue interface.
+/// 
+class AExport JSPropertyValue : public JSValue {
+public:
+  virtual ~JSPropertyValue();
+
+  /// Assign a new value to the property (internally calls JSObjectSetProperty)
+  virtual JSPropertyValue& operator=(const JSValue& value);
+
+  /// Bind to native C++ callback (creates a Function object that can be called from JS)
+  JSPropertyValue& operator=(const JSCallback& callback);
+
+  /// Bind to native C++ callback with return value (creates a Function object that can be called from JS)
+  JSPropertyValue& operator=(const JSCallbackWithRetval& callback);
+
+protected:
+  virtual JSValueRef instance() const;
+  JSPropertyValue(JSContextRef ctx, JSObjectRef proxy_obj, unsigned idx);
+  JSPropertyValue(JSContextRef ctx, JSObjectRef proxy_obj, JSString idx);
+  JSPropertyValue(const JSPropertyValue&) = default;
+  JSPropertyValue& operator=(const JSPropertyValue&) = delete;
+
+  JSObject* proxyObj_;
+  bool using_numeric_idx_;
+  unsigned numeric_idx_;
+  JSString string_idx_;
+  friend class JSArray;
+  friend class JSObject;
+};
+
+///
+/// JSArray wrapper that automatically manages lifetime and provides
+/// convenient access to indices and Array functions.
+/// 
+class AExport JSArray {
+public:
+  /// Create empty Array
+  JSArray();
+
+  /// Create Array from list of JSValues
+  JSArray(const std::initializer_list<JSValue>& values);
+
+  /// Create Array from existing JSObjectRef (JavaScriptCore C API)
+  JSArray(JSObjectRef array_obj);
+
+  /// Copy constructor (shallow copy, will point to same instance)
+  JSArray(const JSArray& other);
+
+  ~JSArray();
+
+  /// Assignment (shallow assignment, will point to same instance)
+  JSArray& operator=(const JSArray& other);
+
+  /// Get number of elements in the Array
+  unsigned length();
+
+  /// Push an element to back of Array
+  void push(const JSValue& val);
+
+  /// Find the index (location) of a certain value, will return -1 if not found
+  int indexOf(const JSValue& val, int start = 0) const;
+
+  /// Get a property by array index (numbering starts at 0)
+  JSPropertyValue operator[](unsigned idx) const;
+
+  /// Get the underlying JSObjectRef (JavaScriptCore C API)
+  operator JSObjectRef() const { return instance_; }
+
+  ///
+  /// Get the bound context for this JSArray (it is cached at creation).
+  ///
+  JSContextRef context() const { return ctx_; }
+
+  ///
+  /// Set the JSContext for this JSArray.
+  ///
+  /// **Note**:
+  ///    JSArrays created from within a JSCallback have a temporary JSContext
+  ///    that is destroyed when the callback returns. You will need to "move"
+  ///    any JSArrays created within these callbacks to the View's main context
+  ///    (call set_context() with the main context) before using them outside
+  ///    the callback.
+  ///
+  void set_context(JSContextRef context) { ctx_ = context; }
+
+protected:
+  JSArray(JSContextRef ctx, JSValueRef val);
+
+  JSContextRef ctx_;
+  JSObjectRef instance_;
+  friend class JSValue;
+};
+
+///
+/// JSObject wrapper that automatically manages lifetime and provides
+/// convenient access to properties.
+/// 
+class AExport JSObject {
+public:
+  /// Create empty Object
+  JSObject();
+
+  /// Create from existing JSObjectRef from JavaScriptCore C API
+  JSObject(JSObjectRef obj);
+  
+  /// Copy constructor (shallow copy, will point to same instance)
+  JSObject(const JSObject& other);
+
+  ~JSObject();
+
+  /// Assignment (shallow assignment, will point to same instance)
+  JSObject& operator=(const JSObject& other);
+
+  /// Get a property by name
+  JSPropertyValue operator[](JSString propertyName) const;
+
+  /// Check if a property exists
+  bool HasProperty(JSString propertyName) const;
+
+  /// Remove a property
+  bool DeleteProperty(JSString propertyName);
+
+  /// Get the underlying JSObjectRef (JavaScriptCore C API)
+  operator JSObjectRef() const { return instance_; }
+
+  ///
+  /// Get the bound context for this JSObject (it is cached at creation).
+  ///
+  JSContextRef context() const { return ctx_; }
+
+  ///
+  /// Set the JSContext for this JSObject.
+  ///
+  /// **Note**:
+  ///    JSObjects created from within a JSCallback have a temporary JSContext
+  ///    that is destroyed when the callback returns. You will need to "move"
+  ///    any JSObjects created within these callbacks to the View's main context
+  ///    (call set_context() with the main context) before using them outside
+  ///    the callback.
+  ///
+  void set_context(JSContextRef context) { ctx_ = context; }
+
+protected:
+  JSObject(JSContextRef ctx, JSValueRef val);
+  JSObject(JSContextRef ctx, JSObjectRef obj);
+
+  JSContextRef ctx_;
+  JSObjectRef instance_;
+  friend class JSValue;
+  friend class JSPropertyValue;
+};
+
+///
+/// JSFunction wrapper that automatically manages lifetime and provides
+/// convenient function invocation operators.
+///
+class AExport JSFunction {
+public:
+  /// Create an empty Function.
+  /// NOTE: It is OKAY to create this without calling SetJSContext() first.
+  JSFunction();
+
+  /// Copy constructor (shallow copy, will point to same instance)
+  JSFunction(const JSFunction& other);
+
+  ~JSFunction();
+
+  /// Assignment (shallow assignment, will point to same instance)
+  JSFunction& operator=(const JSFunction& other);
+
+  /// Whether or not this is a valid, callable Function object.
+  bool IsValid() const;
+
+  /// Call function (using Global Object for 'this') and return the result.
+  JSValue operator()(const JSArgs& args);
+
+  /// Call function (with explicit object for 'this') and return the result
+  JSValue operator()(const JSObject& thisObject, const JSArgs& args);
+
+  /// Get the underlying JSObjectRef (JavaScriptCore C API)
+  operator JSObjectRef() const { return instance_; }
+
+  ///
+  /// Get the bound context for this JSFunction (it is cached at creation).
+  ///
+  JSContextRef context() const { return ctx_; }
+
+  ///
+  /// Set the JSContext for this JSFunction.
+  ///
+  /// **Note**:
+  ///    JSFunctions created from within a JSCallback have a temporary JSContext
+  ///    that is destroyed when the callback returns. You will need to "move"
+  ///    any JSFunctions created within these callbacks to the View's main context
+  ///    (call set_context() with the main context) before using them outside
+  ///    the callback.
+  ///
+  void set_context(JSContextRef context) { ctx_ = context; }
+
+protected:
+  JSFunction(JSContextRef ctx, JSValueRef val);
+
+  JSContextRef ctx_;
+  JSObjectRef instance_;
+  friend class JSValue;  
+};
+
+///
+/// Get the Global Object for the current JSContext.
+/// In JavaScript, this would be equivalent to the "window" object.
+///
+JSObject AExport JSGlobalObject();
+
+///
+/// Evaluate a string of JavaScript and return a result.
+/// 
+JSValue AExport JSEval(const JSString& str);
+
+}  // namespace ultralight
diff --git a/engine/inc/AppCore/Monitor.h b/engine/inc/AppCore/Monitor.h
new file mode 100644
index 00000000..54951175
--- /dev/null
+++ b/engine/inc/AppCore/Monitor.h
@@ -0,0 +1,41 @@
+///
+/// @file Monitor.h
+///
+/// @brief The header for the Monitor class.
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2019 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+#include "Defines.h"
+
+namespace ultralight {
+
+///
+/// Monitor class, represents a platform monitor.
+///
+class AExport Monitor {
+public:
+  virtual ~Monitor() {}
+
+  ///
+  /// Get the DPI scale (1.0 = 100%)
+  ///
+  virtual double scale() const = 0;
+
+  ///
+  /// Get the width of the monitor.
+  ///
+  virtual uint32_t width() const = 0;
+
+  /// Get the height of the monitor.
+  ///
+  virtual uint32_t height() const = 0;
+};
+
+}  // namespace ultralight
diff --git a/engine/inc/AppCore/Overlay.h b/engine/inc/AppCore/Overlay.h
new file mode 100644
index 00000000..2881dc14
--- /dev/null
+++ b/engine/inc/AppCore/Overlay.h
@@ -0,0 +1,141 @@
+///
+/// @file Overlay.h
+///
+/// @brief The header for the Overlay class.
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2019 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+#include "Window.h"
+#include <Ultralight/View.h>
+
+namespace ultralight {
+
+///
+/// Web-content overlay. Displays a web-page within an area of the main window.
+///
+/// @note  Each Overlay is essentially a View and an on-screen quad. You should
+///        create the Overlay then load content into the underlying View.
+///
+class AExport Overlay : public RefCounted {
+public:
+  ///
+  /// Create a new Overlay.
+  ///
+  /// @param  window  The window to create the Overlay in. (we currently only
+  ///                 support one window per application)
+  ///
+  /// @param  width   The width in pixels.
+  ///
+  /// @param  height  The height in pixels.
+  ///
+  /// @param  x       The x-position (offset from the left of the Window), in
+  ///                 pixels.
+  ///
+  /// @param  y       The y-position (offset from the top of the Window), in
+  ///                 pixels.
+  ///
+  static Ref<Overlay> Create(Ref<Window> window, uint32_t width,
+                             uint32_t height, int x, int y);
+
+  ///
+  /// Create a new Overlay, wrapping an existing View.
+  ///
+  /// @param  window  The window to create the Overlay in. (we currently only
+  ///                 support one window per application)
+  ///
+  /// @param  view    The View to wrap (will use its width and height).
+  ///
+  /// @param  x       The x-position (offset from the left of the Window), in
+  ///                 pixels.
+  ///
+  /// @param  y       The y-position (offset from the top of the Window), in
+  ///                 pixels.
+  ///
+  static Ref<Overlay> Create(Ref<Window> window, Ref<View> view, int x, int y);
+
+  ///
+  /// Get the underlying View.
+  ///
+  virtual ultralight::Ref<ultralight::View> view() = 0;
+
+  ///
+  /// Get the width (in pixels).
+  ///
+  virtual uint32_t width() const = 0;
+
+  ///
+  /// Get the height (in pixels).
+  ///
+  virtual uint32_t height() const = 0;
+  
+  ///
+  /// Get the x-position (offset from the left of the Window), in pixels.
+  ///
+  virtual int x() const = 0;
+
+  ///
+  /// Get the y-position (offset from the top of the Window), in pixels.
+  ///
+  virtual int y() const = 0;
+
+  ///
+  /// Whether or not the overlay is hidden (not drawn).
+  ///
+  virtual bool is_hidden() const = 0;
+
+  ///
+  /// Hide the overlay (will no longer be drawn)
+  ///
+  virtual void Hide() = 0;
+
+  ///
+  /// Show the overlay.
+  ///
+  virtual void Show() = 0;
+
+  ///
+  /// Whether or not this overlay has keyboard focus.
+  ///
+  virtual bool has_focus() const = 0;
+
+  ///
+  /// Grant this overlay exclusive keyboard focus.
+  ///
+  virtual void Focus() = 0;
+
+  ///
+  /// Remove keyboard focus.
+  ///
+  virtual void Unfocus() = 0;
+
+  ///
+  /// Move the overlay to a new position (in pixels).
+  ///
+  virtual void MoveTo(int x, int y) = 0;
+
+  ///
+  /// Resize the overlay (and underlying View), dimensions should be
+  /// specified in pixels.
+  ///
+  virtual void Resize(uint32_t width, uint32_t height) = 0;
+
+  ///
+  /// Whether or not this Overlay needs repaint (either it has moved, resized,
+  /// or the internal View needs repaint).
+  ///
+  virtual bool NeedsRepaint() = 0;
+
+protected:
+  virtual ~Overlay();
+  virtual void Draw() = 0;
+  friend class OverlayManager;
+};
+
+}  // namespace framework
diff --git a/engine/inc/AppCore/Platform.h b/engine/inc/AppCore/Platform.h
new file mode 100644
index 00000000..653f7186
--- /dev/null
+++ b/engine/inc/AppCore/Platform.h
@@ -0,0 +1,53 @@
+///
+/// @file Platform.h
+///
+/// @brief The header for the Platform helpers.
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+#include "Defines.h"
+#include <Ultralight/String.h>
+#include <Ultralight/platform/FontLoader.h>
+#include <Ultralight/platform/FileSystem.h>
+#include <Ultralight/platform/Logger.h>
+
+namespace ultralight {
+
+///
+/// Get the native font loader for the current platform.
+///
+/// @note  This singleton is owned by the library, do not destroy it.
+///
+AExport FontLoader* GetPlatformFontLoader();
+
+///
+/// Get the native file system for the current platform, creating it if it
+/// doesn't exist using the base directory provided.
+///
+/// This is used to load data for file:/// URLs.
+///
+/// @param  baseDir  An base file path that will be used to resolve relative
+///                  file paths. You can optionally specify "@resource_path"
+///                  on macOS to use the app bundle's resource path.
+///
+/// @note  This singleton is owned by the library, do not destroy it.
+///
+AExport FileSystem* GetPlatformFileSystem(const String& baseDir);
+
+///
+/// Get the default logger (writes the log to a file on disk).
+///
+/// @param  logPath  A file path to write the log to.
+///
+/// @note  This singleton is owned by the library, do not destroy it.
+///
+AExport Logger* GetDefaultLogger(const String& logPath);
+
+}  // namespace ultralight
diff --git a/engine/inc/AppCore/Window.h b/engine/inc/AppCore/Window.h
new file mode 100644
index 00000000..13b2a8ae
--- /dev/null
+++ b/engine/inc/AppCore/Window.h
@@ -0,0 +1,157 @@
+///
+/// @file Window.h
+///
+/// @brief The header for the Window class.
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2019 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+#include "Defines.h"
+#include <Ultralight/RefPtr.h>
+#include <Ultralight/Listener.h>
+#include <Ultralight/Bitmap.h>
+
+namespace ultralight {
+
+class Monitor;
+class OverlayManager;
+class Surface;
+
+///
+/// Interface for all Window-related events. @see Window::set_listener
+///
+class WindowListener {
+public:
+  virtual ~WindowListener() {}
+
+  ///
+  /// Called when the Window is closed.
+  ///
+  virtual void OnClose() = 0;
+
+  ///
+  /// Called when the Window is resized.
+  ///
+  /// @param  width   The new width (in pixels).
+  ///
+  /// @param  height  The new height (in pixels).
+  ///
+  virtual void OnResize(uint32_t width, uint32_t height) = 0;
+};
+
+///
+/// Window creation flags. @see Window::Create
+///
+enum WindowFlags : uint8_t {
+  kWindowFlags_Borderless  = 1 << 0,
+  kWindowFlags_Titled      = 1 << 1,
+  kWindowFlags_Resizable   = 1 << 2,
+  kWindowFlags_Maximizable = 1 << 3,
+};
+
+///
+/// Window class, represents a platform window.
+///
+class AExport Window : public RefCounted {
+public:
+  ///
+  /// Create a new Window.
+  ///
+  /// @param  monitor       The monitor to create the Window on.
+  ///
+  /// @param  width         The width (in device coordinates).
+  ///
+  /// @param  height        The height (in device coordinates).
+  ///
+  /// @param  fullscreen    Whether or not the window is fullscreen.
+  ///
+  /// @param  window_flags  Various window flags.
+  ///
+  static Ref<Window> Create(Monitor* monitor, uint32_t width, uint32_t height,
+    bool fullscreen, unsigned int window_flags);
+
+  ///
+  /// Set a WindowListener to receive callbacks for window-related events.
+  ///
+  /// @note  Ownership remains with the caller.
+  ///
+  virtual void set_listener(WindowListener* listener) = 0;
+
+  ///
+  /// Get the WindowListener, if any.
+  ///
+  virtual WindowListener* listener() = 0;
+
+  ///
+  /// Get the window width (in pixels).
+  ///
+  virtual uint32_t width() const = 0;
+
+  ///
+  /// Get the window height (in pixels).
+  ///
+  virtual uint32_t height() const = 0;
+
+  ///
+  /// Whether or not the window is fullscreen.
+  ///
+  virtual bool is_fullscreen() const = 0;
+
+  ///
+  /// The DPI scale of the window.
+  ///
+  virtual double scale() const = 0;
+
+  ///
+  /// Set the window title.
+  ///
+  virtual void SetTitle(const char* title) = 0;
+
+  ///
+  /// Set the cursor.
+  ///
+  virtual void SetCursor(ultralight::Cursor cursor) = 0;
+
+  ///
+  /// Close the window.
+  ///
+  virtual void Close() = 0;
+
+  ///
+  /// Convert device coordinates to pixels using the current DPI scale.
+  ///
+  virtual int DeviceToPixels(int val) const = 0;
+
+  ///
+  /// Convert pixels to device coordinates using the current DPI scale.
+  ///
+  virtual int PixelsToDevice(int val) const = 0;
+
+  ///
+  /// Draw a surface directly to window, used only by CPU renderer
+  ///
+  virtual void DrawSurface(int x, int y, Surface* surface) {}
+
+  ///
+  /// Get the underlying native window handle.
+  ///
+  /// @note This is:  - HWND on Windows
+  ///                 - NSWindow* on macOS
+  ///                 - GLFWwindow* on Linux
+  ///
+  virtual void* native_handle() const = 0;
+
+protected:
+  virtual ~Window();
+  virtual OverlayManager* overlay_manager() const = 0;
+
+  friend class OverlayImpl;
+};
+
+}  // namespace ultralight
diff --git a/engine/inc/GL/glext.h b/engine/inc/GL/glext.h
new file mode 100644
index 00000000..b5b7678b
--- /dev/null
+++ b/engine/inc/GL/glext.h
@@ -0,0 +1,11028 @@
+#ifndef __glext_h_
+#define __glext_h_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2007-2010 The Khronos Group Inc.
+** 
+** Permission is hereby granted, free of charge, to any person obtaining a
+** copy of this software and/or associated documentation files (the
+** "Materials"), to deal in the Materials without restriction, including
+** without limitation the rights to use, copy, modify, merge, publish,
+** distribute, sublicense, and/or sell copies of the Materials, and to
+** permit persons to whom the Materials are 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 Materials.
+** 
+** THE MATERIALS ARE 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
+** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+*/
+
+/* Header file version number, required by OpenGL ABI for Linux */
+/* glext.h last updated $Date: 2010-08-03 01:30:25 -0700 (Tue, 03 Aug 2010) $ */
+/* Current version at http://www.opengl.org/registry/ */
+#define GL_GLEXT_VERSION 64
+/* Function declaration macros - to move into glplatform.h */
+
+#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__)
+#define WIN32_LEAN_AND_MEAN 1
+#include <windows.h>
+#endif
+
+#ifndef APIENTRY
+#define APIENTRY
+#endif
+#ifndef APIENTRYP
+#define APIENTRYP APIENTRY *
+#endif
+#ifndef GLAPI
+#define GLAPI extern
+#endif
+
+/*************************************************************/
+
+#ifndef GL_VERSION_1_2
+#define GL_UNSIGNED_BYTE_3_3_2            0x8032
+#define GL_UNSIGNED_SHORT_4_4_4_4         0x8033
+#define GL_UNSIGNED_SHORT_5_5_5_1         0x8034
+#define GL_UNSIGNED_INT_8_8_8_8           0x8035
+#define GL_UNSIGNED_INT_10_10_10_2        0x8036
+#define GL_TEXTURE_BINDING_3D             0x806A
+#define GL_PACK_SKIP_IMAGES               0x806B
+#define GL_PACK_IMAGE_HEIGHT              0x806C
+#define GL_UNPACK_SKIP_IMAGES             0x806D
+#define GL_UNPACK_IMAGE_HEIGHT            0x806E
+#define GL_TEXTURE_3D                     0x806F
+#define GL_PROXY_TEXTURE_3D               0x8070
+#define GL_TEXTURE_DEPTH                  0x8071
+#define GL_TEXTURE_WRAP_R                 0x8072
+#define GL_MAX_3D_TEXTURE_SIZE            0x8073
+#define GL_UNSIGNED_BYTE_2_3_3_REV        0x8362
+#define GL_UNSIGNED_SHORT_5_6_5           0x8363
+#define GL_UNSIGNED_SHORT_5_6_5_REV       0x8364
+#define GL_UNSIGNED_SHORT_4_4_4_4_REV     0x8365
+#define GL_UNSIGNED_SHORT_1_5_5_5_REV     0x8366
+#define GL_UNSIGNED_INT_8_8_8_8_REV       0x8367
+#define GL_UNSIGNED_INT_2_10_10_10_REV    0x8368
+#define GL_BGR                            0x80E0
+#define GL_BGRA                           0x80E1
+#define GL_MAX_ELEMENTS_VERTICES          0x80E8
+#define GL_MAX_ELEMENTS_INDICES           0x80E9
+#define GL_CLAMP_TO_EDGE                  0x812F
+#define GL_TEXTURE_MIN_LOD                0x813A
+#define GL_TEXTURE_MAX_LOD                0x813B
+#define GL_TEXTURE_BASE_LEVEL             0x813C
+#define GL_TEXTURE_MAX_LEVEL              0x813D
+#define GL_SMOOTH_POINT_SIZE_RANGE        0x0B12
+#define GL_SMOOTH_POINT_SIZE_GRANULARITY  0x0B13
+#define GL_SMOOTH_LINE_WIDTH_RANGE        0x0B22
+#define GL_SMOOTH_LINE_WIDTH_GRANULARITY  0x0B23
+#define GL_ALIASED_LINE_WIDTH_RANGE       0x846E
+#endif
+
+#ifndef GL_VERSION_1_2_DEPRECATED
+#define GL_RESCALE_NORMAL                 0x803A
+#define GL_LIGHT_MODEL_COLOR_CONTROL      0x81F8
+#define GL_SINGLE_COLOR                   0x81F9
+#define GL_SEPARATE_SPECULAR_COLOR        0x81FA
+#define GL_ALIASED_POINT_SIZE_RANGE       0x846D
+#endif
+
+#ifndef GL_ARB_imaging
+#define GL_CONSTANT_COLOR                 0x8001
+#define GL_ONE_MINUS_CONSTANT_COLOR       0x8002
+#define GL_CONSTANT_ALPHA                 0x8003
+#define GL_ONE_MINUS_CONSTANT_ALPHA       0x8004
+#define GL_BLEND_COLOR                    0x8005
+#define GL_FUNC_ADD                       0x8006
+#define GL_MIN                            0x8007
+#define GL_MAX                            0x8008
+#define GL_BLEND_EQUATION                 0x8009
+#define GL_FUNC_SUBTRACT                  0x800A
+#define GL_FUNC_REVERSE_SUBTRACT          0x800B
+#endif
+
+#ifndef GL_ARB_imaging_DEPRECATED
+#define GL_CONVOLUTION_1D                 0x8010
+#define GL_CONVOLUTION_2D                 0x8011
+#define GL_SEPARABLE_2D                   0x8012
+#define GL_CONVOLUTION_BORDER_MODE        0x8013
+#define GL_CONVOLUTION_FILTER_SCALE       0x8014
+#define GL_CONVOLUTION_FILTER_BIAS        0x8015
+#define GL_REDUCE                         0x8016
+#define GL_CONVOLUTION_FORMAT             0x8017
+#define GL_CONVOLUTION_WIDTH              0x8018
+#define GL_CONVOLUTION_HEIGHT             0x8019
+#define GL_MAX_CONVOLUTION_WIDTH          0x801A
+#define GL_MAX_CONVOLUTION_HEIGHT         0x801B
+#define GL_POST_CONVOLUTION_RED_SCALE     0x801C
+#define GL_POST_CONVOLUTION_GREEN_SCALE   0x801D
+#define GL_POST_CONVOLUTION_BLUE_SCALE    0x801E
+#define GL_POST_CONVOLUTION_ALPHA_SCALE   0x801F
+#define GL_POST_CONVOLUTION_RED_BIAS      0x8020
+#define GL_POST_CONVOLUTION_GREEN_BIAS    0x8021
+#define GL_POST_CONVOLUTION_BLUE_BIAS     0x8022
+#define GL_POST_CONVOLUTION_ALPHA_BIAS    0x8023
+#define GL_HISTOGRAM                      0x8024
+#define GL_PROXY_HISTOGRAM                0x8025
+#define GL_HISTOGRAM_WIDTH                0x8026
+#define GL_HISTOGRAM_FORMAT               0x8027
+#define GL_HISTOGRAM_RED_SIZE             0x8028
+#define GL_HISTOGRAM_GREEN_SIZE           0x8029
+#define GL_HISTOGRAM_BLUE_SIZE            0x802A
+#define GL_HISTOGRAM_ALPHA_SIZE           0x802B
+#define GL_HISTOGRAM_LUMINANCE_SIZE       0x802C
+#define GL_HISTOGRAM_SINK                 0x802D
+#define GL_MINMAX                         0x802E
+#define GL_MINMAX_FORMAT                  0x802F
+#define GL_MINMAX_SINK                    0x8030
+#define GL_TABLE_TOO_LARGE                0x8031
+#define GL_COLOR_MATRIX                   0x80B1
+#define GL_COLOR_MATRIX_STACK_DEPTH       0x80B2
+#define GL_MAX_COLOR_MATRIX_STACK_DEPTH   0x80B3
+#define GL_POST_COLOR_MATRIX_RED_SCALE    0x80B4
+#define GL_POST_COLOR_MATRIX_GREEN_SCALE  0x80B5
+#define GL_POST_COLOR_MATRIX_BLUE_SCALE   0x80B6
+#define GL_POST_COLOR_MATRIX_ALPHA_SCALE  0x80B7
+#define GL_POST_COLOR_MATRIX_RED_BIAS     0x80B8
+#define GL_POST_COLOR_MATRIX_GREEN_BIAS   0x80B9
+#define GL_POST_COLOR_MATRIX_BLUE_BIAS    0x80BA
+#define GL_POST_COLOR_MATRIX_ALPHA_BIAS   0x80BB
+#define GL_COLOR_TABLE                    0x80D0
+#define GL_POST_CONVOLUTION_COLOR_TABLE   0x80D1
+#define GL_POST_COLOR_MATRIX_COLOR_TABLE  0x80D2
+#define GL_PROXY_COLOR_TABLE              0x80D3
+#define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE 0x80D4
+#define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE 0x80D5
+#define GL_COLOR_TABLE_SCALE              0x80D6
+#define GL_COLOR_TABLE_BIAS               0x80D7
+#define GL_COLOR_TABLE_FORMAT             0x80D8
+#define GL_COLOR_TABLE_WIDTH              0x80D9
+#define GL_COLOR_TABLE_RED_SIZE           0x80DA
+#define GL_COLOR_TABLE_GREEN_SIZE         0x80DB
+#define GL_COLOR_TABLE_BLUE_SIZE          0x80DC
+#define GL_COLOR_TABLE_ALPHA_SIZE         0x80DD
+#define GL_COLOR_TABLE_LUMINANCE_SIZE     0x80DE
+#define GL_COLOR_TABLE_INTENSITY_SIZE     0x80DF
+#define GL_CONSTANT_BORDER                0x8151
+#define GL_REPLICATE_BORDER               0x8153
+#define GL_CONVOLUTION_BORDER_COLOR       0x8154
+#endif
+
+#ifndef GL_VERSION_1_3
+#define GL_TEXTURE0                       0x84C0
+#define GL_TEXTURE1                       0x84C1
+#define GL_TEXTURE2                       0x84C2
+#define GL_TEXTURE3                       0x84C3
+#define GL_TEXTURE4                       0x84C4
+#define GL_TEXTURE5                       0x84C5
+#define GL_TEXTURE6                       0x84C6
+#define GL_TEXTURE7                       0x84C7
+#define GL_TEXTURE8                       0x84C8
+#define GL_TEXTURE9                       0x84C9
+#define GL_TEXTURE10                      0x84CA
+#define GL_TEXTURE11                      0x84CB
+#define GL_TEXTURE12                      0x84CC
+#define GL_TEXTURE13                      0x84CD
+#define GL_TEXTURE14                      0x84CE
+#define GL_TEXTURE15                      0x84CF
+#define GL_TEXTURE16                      0x84D0
+#define GL_TEXTURE17                      0x84D1
+#define GL_TEXTURE18                      0x84D2
+#define GL_TEXTURE19                      0x84D3
+#define GL_TEXTURE20                      0x84D4
+#define GL_TEXTURE21                      0x84D5
+#define GL_TEXTURE22                      0x84D6
+#define GL_TEXTURE23                      0x84D7
+#define GL_TEXTURE24                      0x84D8
+#define GL_TEXTURE25                      0x84D9
+#define GL_TEXTURE26                      0x84DA
+#define GL_TEXTURE27                      0x84DB
+#define GL_TEXTURE28                      0x84DC
+#define GL_TEXTURE29                      0x84DD
+#define GL_TEXTURE30                      0x84DE
+#define GL_TEXTURE31                      0x84DF
+#define GL_ACTIVE_TEXTURE                 0x84E0
+#define GL_MULTISAMPLE                    0x809D
+#define GL_SAMPLE_ALPHA_TO_COVERAGE       0x809E
+#define GL_SAMPLE_ALPHA_TO_ONE            0x809F
+#define GL_SAMPLE_COVERAGE                0x80A0
+#define GL_SAMPLE_BUFFERS                 0x80A8
+#define GL_SAMPLES                        0x80A9
+#define GL_SAMPLE_COVERAGE_VALUE          0x80AA
+#define GL_SAMPLE_COVERAGE_INVERT         0x80AB
+#define GL_TEXTURE_CUBE_MAP               0x8513
+#define GL_TEXTURE_BINDING_CUBE_MAP       0x8514
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_X    0x8515
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X    0x8516
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y    0x8517
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y    0x8518
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z    0x8519
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z    0x851A
+#define GL_PROXY_TEXTURE_CUBE_MAP         0x851B
+#define GL_MAX_CUBE_MAP_TEXTURE_SIZE      0x851C
+#define GL_COMPRESSED_RGB                 0x84ED
+#define GL_COMPRESSED_RGBA                0x84EE
+#define GL_TEXTURE_COMPRESSION_HINT       0x84EF
+#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE  0x86A0
+#define GL_TEXTURE_COMPRESSED             0x86A1
+#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2
+#define GL_COMPRESSED_TEXTURE_FORMATS     0x86A3
+#define GL_CLAMP_TO_BORDER                0x812D
+#endif
+
+#ifndef GL_VERSION_1_3_DEPRECATED
+#define GL_CLIENT_ACTIVE_TEXTURE          0x84E1
+#define GL_MAX_TEXTURE_UNITS              0x84E2
+#define GL_TRANSPOSE_MODELVIEW_MATRIX     0x84E3
+#define GL_TRANSPOSE_PROJECTION_MATRIX    0x84E4
+#define GL_TRANSPOSE_TEXTURE_MATRIX       0x84E5
+#define GL_TRANSPOSE_COLOR_MATRIX         0x84E6
+#define GL_MULTISAMPLE_BIT                0x20000000
+#define GL_NORMAL_MAP                     0x8511
+#define GL_REFLECTION_MAP                 0x8512
+#define GL_COMPRESSED_ALPHA               0x84E9
+#define GL_COMPRESSED_LUMINANCE           0x84EA
+#define GL_COMPRESSED_LUMINANCE_ALPHA     0x84EB
+#define GL_COMPRESSED_INTENSITY           0x84EC
+#define GL_COMBINE                        0x8570
+#define GL_COMBINE_RGB                    0x8571
+#define GL_COMBINE_ALPHA                  0x8572
+#define GL_SOURCE0_RGB                    0x8580
+#define GL_SOURCE1_RGB                    0x8581
+#define GL_SOURCE2_RGB                    0x8582
+#define GL_SOURCE0_ALPHA                  0x8588
+#define GL_SOURCE1_ALPHA                  0x8589
+#define GL_SOURCE2_ALPHA                  0x858A
+#define GL_OPERAND0_RGB                   0x8590
+#define GL_OPERAND1_RGB                   0x8591
+#define GL_OPERAND2_RGB                   0x8592
+#define GL_OPERAND0_ALPHA                 0x8598
+#define GL_OPERAND1_ALPHA                 0x8599
+#define GL_OPERAND2_ALPHA                 0x859A
+#define GL_RGB_SCALE                      0x8573
+#define GL_ADD_SIGNED                     0x8574
+#define GL_INTERPOLATE                    0x8575
+#define GL_SUBTRACT                       0x84E7
+#define GL_CONSTANT                       0x8576
+#define GL_PRIMARY_COLOR                  0x8577
+#define GL_PREVIOUS                       0x8578
+#define GL_DOT3_RGB                       0x86AE
+#define GL_DOT3_RGBA                      0x86AF
+#endif
+
+#ifndef GL_VERSION_1_4
+#define GL_BLEND_DST_RGB                  0x80C8
+#define GL_BLEND_SRC_RGB                  0x80C9
+#define GL_BLEND_DST_ALPHA                0x80CA
+#define GL_BLEND_SRC_ALPHA                0x80CB
+#define GL_POINT_FADE_THRESHOLD_SIZE      0x8128
+#define GL_DEPTH_COMPONENT16              0x81A5
+#define GL_DEPTH_COMPONENT24              0x81A6
+#define GL_DEPTH_COMPONENT32              0x81A7
+#define GL_MIRRORED_REPEAT                0x8370
+#define GL_MAX_TEXTURE_LOD_BIAS           0x84FD
+#define GL_TEXTURE_LOD_BIAS               0x8501
+#define GL_INCR_WRAP                      0x8507
+#define GL_DECR_WRAP                      0x8508
+#define GL_TEXTURE_DEPTH_SIZE             0x884A
+#define GL_TEXTURE_COMPARE_MODE           0x884C
+#define GL_TEXTURE_COMPARE_FUNC           0x884D
+#endif
+
+#ifndef GL_VERSION_1_4_DEPRECATED
+#define GL_POINT_SIZE_MIN                 0x8126
+#define GL_POINT_SIZE_MAX                 0x8127
+#define GL_POINT_DISTANCE_ATTENUATION     0x8129
+#define GL_GENERATE_MIPMAP                0x8191
+#define GL_GENERATE_MIPMAP_HINT           0x8192
+#define GL_FOG_COORDINATE_SOURCE          0x8450
+#define GL_FOG_COORDINATE                 0x8451
+#define GL_FRAGMENT_DEPTH                 0x8452
+#define GL_CURRENT_FOG_COORDINATE         0x8453
+#define GL_FOG_COORDINATE_ARRAY_TYPE      0x8454
+#define GL_FOG_COORDINATE_ARRAY_STRIDE    0x8455
+#define GL_FOG_COORDINATE_ARRAY_POINTER   0x8456
+#define GL_FOG_COORDINATE_ARRAY           0x8457
+#define GL_COLOR_SUM                      0x8458
+#define GL_CURRENT_SECONDARY_COLOR        0x8459
+#define GL_SECONDARY_COLOR_ARRAY_SIZE     0x845A
+#define GL_SECONDARY_COLOR_ARRAY_TYPE     0x845B
+#define GL_SECONDARY_COLOR_ARRAY_STRIDE   0x845C
+#define GL_SECONDARY_COLOR_ARRAY_POINTER  0x845D
+#define GL_SECONDARY_COLOR_ARRAY          0x845E
+#define GL_TEXTURE_FILTER_CONTROL         0x8500
+#define GL_DEPTH_TEXTURE_MODE             0x884B
+#define GL_COMPARE_R_TO_TEXTURE           0x884E
+#endif
+
+#ifndef GL_VERSION_1_5
+#define GL_BUFFER_SIZE                    0x8764
+#define GL_BUFFER_USAGE                   0x8765
+#define GL_QUERY_COUNTER_BITS             0x8864
+#define GL_CURRENT_QUERY                  0x8865
+#define GL_QUERY_RESULT                   0x8866
+#define GL_QUERY_RESULT_AVAILABLE         0x8867
+#define GL_ARRAY_BUFFER                   0x8892
+#define GL_ELEMENT_ARRAY_BUFFER           0x8893
+#define GL_ARRAY_BUFFER_BINDING           0x8894
+#define GL_ELEMENT_ARRAY_BUFFER_BINDING   0x8895
+#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F
+#define GL_READ_ONLY                      0x88B8
+#define GL_WRITE_ONLY                     0x88B9
+#define GL_READ_WRITE                     0x88BA
+#define GL_BUFFER_ACCESS                  0x88BB
+#define GL_BUFFER_MAPPED                  0x88BC
+#define GL_BUFFER_MAP_POINTER             0x88BD
+#define GL_STREAM_DRAW                    0x88E0
+#define GL_STREAM_READ                    0x88E1
+#define GL_STREAM_COPY                    0x88E2
+#define GL_STATIC_DRAW                    0x88E4
+#define GL_STATIC_READ                    0x88E5
+#define GL_STATIC_COPY                    0x88E6
+#define GL_DYNAMIC_DRAW                   0x88E8
+#define GL_DYNAMIC_READ                   0x88E9
+#define GL_DYNAMIC_COPY                   0x88EA
+#define GL_SAMPLES_PASSED                 0x8914
+#endif
+
+#ifndef GL_VERSION_1_5_DEPRECATED
+#define GL_VERTEX_ARRAY_BUFFER_BINDING    0x8896
+#define GL_NORMAL_ARRAY_BUFFER_BINDING    0x8897
+#define GL_COLOR_ARRAY_BUFFER_BINDING     0x8898
+#define GL_INDEX_ARRAY_BUFFER_BINDING     0x8899
+#define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING 0x889A
+#define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING 0x889B
+#define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING 0x889C
+#define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING 0x889D
+#define GL_WEIGHT_ARRAY_BUFFER_BINDING    0x889E
+#define GL_FOG_COORD_SRC                  0x8450
+#define GL_FOG_COORD                      0x8451
+#define GL_CURRENT_FOG_COORD              0x8453
+#define GL_FOG_COORD_ARRAY_TYPE           0x8454
+#define GL_FOG_COORD_ARRAY_STRIDE         0x8455
+#define GL_FOG_COORD_ARRAY_POINTER        0x8456
+#define GL_FOG_COORD_ARRAY                0x8457
+#define GL_FOG_COORD_ARRAY_BUFFER_BINDING 0x889D
+#define GL_SRC0_RGB                       0x8580
+#define GL_SRC1_RGB                       0x8581
+#define GL_SRC2_RGB                       0x8582
+#define GL_SRC0_ALPHA                     0x8588
+#define GL_SRC1_ALPHA                     0x8589
+#define GL_SRC2_ALPHA                     0x858A
+#endif
+
+#ifndef GL_VERSION_2_0
+#define GL_BLEND_EQUATION_RGB             0x8009
+#define GL_VERTEX_ATTRIB_ARRAY_ENABLED    0x8622
+#define GL_VERTEX_ATTRIB_ARRAY_SIZE       0x8623
+#define GL_VERTEX_ATTRIB_ARRAY_STRIDE     0x8624
+#define GL_VERTEX_ATTRIB_ARRAY_TYPE       0x8625
+#define GL_CURRENT_VERTEX_ATTRIB          0x8626
+#define GL_VERTEX_PROGRAM_POINT_SIZE      0x8642
+#define GL_VERTEX_ATTRIB_ARRAY_POINTER    0x8645
+#define GL_STENCIL_BACK_FUNC              0x8800
+#define GL_STENCIL_BACK_FAIL              0x8801
+#define GL_STENCIL_BACK_PASS_DEPTH_FAIL   0x8802
+#define GL_STENCIL_BACK_PASS_DEPTH_PASS   0x8803
+#define GL_MAX_DRAW_BUFFERS               0x8824
+#define GL_DRAW_BUFFER0                   0x8825
+#define GL_DRAW_BUFFER1                   0x8826
+#define GL_DRAW_BUFFER2                   0x8827
+#define GL_DRAW_BUFFER3                   0x8828
+#define GL_DRAW_BUFFER4                   0x8829
+#define GL_DRAW_BUFFER5                   0x882A
+#define GL_DRAW_BUFFER6                   0x882B
+#define GL_DRAW_BUFFER7                   0x882C
+#define GL_DRAW_BUFFER8                   0x882D
+#define GL_DRAW_BUFFER9                   0x882E
+#define GL_DRAW_BUFFER10                  0x882F
+#define GL_DRAW_BUFFER11                  0x8830
+#define GL_DRAW_BUFFER12                  0x8831
+#define GL_DRAW_BUFFER13                  0x8832
+#define GL_DRAW_BUFFER14                  0x8833
+#define GL_DRAW_BUFFER15                  0x8834
+#define GL_BLEND_EQUATION_ALPHA           0x883D
+#define GL_MAX_VERTEX_ATTRIBS             0x8869
+#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A
+#define GL_MAX_TEXTURE_IMAGE_UNITS        0x8872
+#define GL_FRAGMENT_SHADER                0x8B30
+#define GL_VERTEX_SHADER                  0x8B31
+#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49
+#define GL_MAX_VERTEX_UNIFORM_COMPONENTS  0x8B4A
+#define GL_MAX_VARYING_FLOATS             0x8B4B
+#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C
+#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D
+#define GL_SHADER_TYPE                    0x8B4F
+#define GL_FLOAT_VEC2                     0x8B50
+#define GL_FLOAT_VEC3                     0x8B51
+#define GL_FLOAT_VEC4                     0x8B52
+#define GL_INT_VEC2                       0x8B53
+#define GL_INT_VEC3                       0x8B54
+#define GL_INT_VEC4                       0x8B55
+#define GL_BOOL                           0x8B56
+#define GL_BOOL_VEC2                      0x8B57
+#define GL_BOOL_VEC3                      0x8B58
+#define GL_BOOL_VEC4                      0x8B59
+#define GL_FLOAT_MAT2                     0x8B5A
+#define GL_FLOAT_MAT3                     0x8B5B
+#define GL_FLOAT_MAT4                     0x8B5C
+#define GL_SAMPLER_1D                     0x8B5D
+#define GL_SAMPLER_2D                     0x8B5E
+#define GL_SAMPLER_3D                     0x8B5F
+#define GL_SAMPLER_CUBE                   0x8B60
+#define GL_SAMPLER_1D_SHADOW              0x8B61
+#define GL_SAMPLER_2D_SHADOW              0x8B62
+#define GL_DELETE_STATUS                  0x8B80
+#define GL_COMPILE_STATUS                 0x8B81
+#define GL_LINK_STATUS                    0x8B82
+#define GL_VALIDATE_STATUS                0x8B83
+#define GL_INFO_LOG_LENGTH                0x8B84
+#define GL_ATTACHED_SHADERS               0x8B85
+#define GL_ACTIVE_UNIFORMS                0x8B86
+#define GL_ACTIVE_UNIFORM_MAX_LENGTH      0x8B87
+#define GL_SHADER_SOURCE_LENGTH           0x8B88
+#define GL_ACTIVE_ATTRIBUTES              0x8B89
+#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH    0x8B8A
+#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B
+#define GL_SHADING_LANGUAGE_VERSION       0x8B8C
+#define GL_CURRENT_PROGRAM                0x8B8D
+#define GL_POINT_SPRITE_COORD_ORIGIN      0x8CA0
+#define GL_LOWER_LEFT                     0x8CA1
+#define GL_UPPER_LEFT                     0x8CA2
+#define GL_STENCIL_BACK_REF               0x8CA3
+#define GL_STENCIL_BACK_VALUE_MASK        0x8CA4
+#define GL_STENCIL_BACK_WRITEMASK         0x8CA5
+#endif
+
+#ifndef GL_VERSION_2_0_DEPRECATED
+#define GL_VERTEX_PROGRAM_TWO_SIDE        0x8643
+#define GL_POINT_SPRITE                   0x8861
+#define GL_COORD_REPLACE                  0x8862
+#define GL_MAX_TEXTURE_COORDS             0x8871
+#endif
+
+#ifndef GL_VERSION_2_1
+#define GL_PIXEL_PACK_BUFFER              0x88EB
+#define GL_PIXEL_UNPACK_BUFFER            0x88EC
+#define GL_PIXEL_PACK_BUFFER_BINDING      0x88ED
+#define GL_PIXEL_UNPACK_BUFFER_BINDING    0x88EF
+#define GL_FLOAT_MAT2x3                   0x8B65
+#define GL_FLOAT_MAT2x4                   0x8B66
+#define GL_FLOAT_MAT3x2                   0x8B67
+#define GL_FLOAT_MAT3x4                   0x8B68
+#define GL_FLOAT_MAT4x2                   0x8B69
+#define GL_FLOAT_MAT4x3                   0x8B6A
+#define GL_SRGB                           0x8C40
+#define GL_SRGB8                          0x8C41
+#define GL_SRGB_ALPHA                     0x8C42
+#define GL_SRGB8_ALPHA8                   0x8C43
+#define GL_COMPRESSED_SRGB                0x8C48
+#define GL_COMPRESSED_SRGB_ALPHA          0x8C49
+#endif
+
+#ifndef GL_VERSION_2_1_DEPRECATED
+#define GL_CURRENT_RASTER_SECONDARY_COLOR 0x845F
+#define GL_SLUMINANCE_ALPHA               0x8C44
+#define GL_SLUMINANCE8_ALPHA8             0x8C45
+#define GL_SLUMINANCE                     0x8C46
+#define GL_SLUMINANCE8                    0x8C47
+#define GL_COMPRESSED_SLUMINANCE          0x8C4A
+#define GL_COMPRESSED_SLUMINANCE_ALPHA    0x8C4B
+#endif
+
+#ifndef GL_VERSION_3_0
+#define GL_COMPARE_REF_TO_TEXTURE         0x884E
+#define GL_CLIP_DISTANCE0                 0x3000
+#define GL_CLIP_DISTANCE1                 0x3001
+#define GL_CLIP_DISTANCE2                 0x3002
+#define GL_CLIP_DISTANCE3                 0x3003
+#define GL_CLIP_DISTANCE4                 0x3004
+#define GL_CLIP_DISTANCE5                 0x3005
+#define GL_CLIP_DISTANCE6                 0x3006
+#define GL_CLIP_DISTANCE7                 0x3007
+#define GL_MAX_CLIP_DISTANCES             0x0D32
+#define GL_MAJOR_VERSION                  0x821B
+#define GL_MINOR_VERSION                  0x821C
+#define GL_NUM_EXTENSIONS                 0x821D
+#define GL_CONTEXT_FLAGS                  0x821E
+#define GL_DEPTH_BUFFER                   0x8223
+#define GL_STENCIL_BUFFER                 0x8224
+#define GL_COMPRESSED_RED                 0x8225
+#define GL_COMPRESSED_RG                  0x8226
+#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x0001
+#define GL_RGBA32F                        0x8814
+#define GL_RGB32F                         0x8815
+#define GL_RGBA16F                        0x881A
+#define GL_RGB16F                         0x881B
+#define GL_VERTEX_ATTRIB_ARRAY_INTEGER    0x88FD
+#define GL_MAX_ARRAY_TEXTURE_LAYERS       0x88FF
+#define GL_MIN_PROGRAM_TEXEL_OFFSET       0x8904
+#define GL_MAX_PROGRAM_TEXEL_OFFSET       0x8905
+#define GL_CLAMP_READ_COLOR               0x891C
+#define GL_FIXED_ONLY                     0x891D
+#define GL_MAX_VARYING_COMPONENTS         0x8B4B
+#define GL_TEXTURE_1D_ARRAY               0x8C18
+#define GL_PROXY_TEXTURE_1D_ARRAY         0x8C19
+#define GL_TEXTURE_2D_ARRAY               0x8C1A
+#define GL_PROXY_TEXTURE_2D_ARRAY         0x8C1B
+#define GL_TEXTURE_BINDING_1D_ARRAY       0x8C1C
+#define GL_TEXTURE_BINDING_2D_ARRAY       0x8C1D
+#define GL_R11F_G11F_B10F                 0x8C3A
+#define GL_UNSIGNED_INT_10F_11F_11F_REV   0x8C3B
+#define GL_RGB9_E5                        0x8C3D
+#define GL_UNSIGNED_INT_5_9_9_9_REV       0x8C3E
+#define GL_TEXTURE_SHARED_SIZE            0x8C3F
+#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76
+#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F
+#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80
+#define GL_TRANSFORM_FEEDBACK_VARYINGS    0x8C83
+#define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84
+#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85
+#define GL_PRIMITIVES_GENERATED           0x8C87
+#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88
+#define GL_RASTERIZER_DISCARD             0x8C89
+#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A
+#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B
+#define GL_INTERLEAVED_ATTRIBS            0x8C8C
+#define GL_SEPARATE_ATTRIBS               0x8C8D
+#define GL_TRANSFORM_FEEDBACK_BUFFER      0x8C8E
+#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F
+#define GL_RGBA32UI                       0x8D70
+#define GL_RGB32UI                        0x8D71
+#define GL_RGBA16UI                       0x8D76
+#define GL_RGB16UI                        0x8D77
+#define GL_RGBA8UI                        0x8D7C
+#define GL_RGB8UI                         0x8D7D
+#define GL_RGBA32I                        0x8D82
+#define GL_RGB32I                         0x8D83
+#define GL_RGBA16I                        0x8D88
+#define GL_RGB16I                         0x8D89
+#define GL_RGBA8I                         0x8D8E
+#define GL_RGB8I                          0x8D8F
+#define GL_RED_INTEGER                    0x8D94
+#define GL_GREEN_INTEGER                  0x8D95
+#define GL_BLUE_INTEGER                   0x8D96
+#define GL_RGB_INTEGER                    0x8D98
+#define GL_RGBA_INTEGER                   0x8D99
+#define GL_BGR_INTEGER                    0x8D9A
+#define GL_BGRA_INTEGER                   0x8D9B
+#define GL_SAMPLER_1D_ARRAY               0x8DC0
+#define GL_SAMPLER_2D_ARRAY               0x8DC1
+#define GL_SAMPLER_1D_ARRAY_SHADOW        0x8DC3
+#define GL_SAMPLER_2D_ARRAY_SHADOW        0x8DC4
+#define GL_SAMPLER_CUBE_SHADOW            0x8DC5
+#define GL_UNSIGNED_INT_VEC2              0x8DC6
+#define GL_UNSIGNED_INT_VEC3              0x8DC7
+#define GL_UNSIGNED_INT_VEC4              0x8DC8
+#define GL_INT_SAMPLER_1D                 0x8DC9
+#define GL_INT_SAMPLER_2D                 0x8DCA
+#define GL_INT_SAMPLER_3D                 0x8DCB
+#define GL_INT_SAMPLER_CUBE               0x8DCC
+#define GL_INT_SAMPLER_1D_ARRAY           0x8DCE
+#define GL_INT_SAMPLER_2D_ARRAY           0x8DCF
+#define GL_UNSIGNED_INT_SAMPLER_1D        0x8DD1
+#define GL_UNSIGNED_INT_SAMPLER_2D        0x8DD2
+#define GL_UNSIGNED_INT_SAMPLER_3D        0x8DD3
+#define GL_UNSIGNED_INT_SAMPLER_CUBE      0x8DD4
+#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY  0x8DD6
+#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY  0x8DD7
+#define GL_QUERY_WAIT                     0x8E13
+#define GL_QUERY_NO_WAIT                  0x8E14
+#define GL_QUERY_BY_REGION_WAIT           0x8E15
+#define GL_QUERY_BY_REGION_NO_WAIT        0x8E16
+#define GL_BUFFER_ACCESS_FLAGS            0x911F
+#define GL_BUFFER_MAP_LENGTH              0x9120
+#define GL_BUFFER_MAP_OFFSET              0x9121
+/* Reuse tokens from ARB_depth_buffer_float */
+/* reuse GL_DEPTH_COMPONENT32F */
+/* reuse GL_DEPTH32F_STENCIL8 */
+/* reuse GL_FLOAT_32_UNSIGNED_INT_24_8_REV */
+/* Reuse tokens from ARB_framebuffer_object */
+/* reuse GL_INVALID_FRAMEBUFFER_OPERATION */
+/* reuse GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING */
+/* reuse GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE */
+/* reuse GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE */
+/* reuse GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE */
+/* reuse GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE */
+/* reuse GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE */
+/* reuse GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE */
+/* reuse GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE */
+/* reuse GL_FRAMEBUFFER_DEFAULT */
+/* reuse GL_FRAMEBUFFER_UNDEFINED */
+/* reuse GL_DEPTH_STENCIL_ATTACHMENT */
+/* reuse GL_INDEX */
+/* reuse GL_MAX_RENDERBUFFER_SIZE */
+/* reuse GL_DEPTH_STENCIL */
+/* reuse GL_UNSIGNED_INT_24_8 */
+/* reuse GL_DEPTH24_STENCIL8 */
+/* reuse GL_TEXTURE_STENCIL_SIZE */
+/* reuse GL_TEXTURE_RED_TYPE */
+/* reuse GL_TEXTURE_GREEN_TYPE */
+/* reuse GL_TEXTURE_BLUE_TYPE */
+/* reuse GL_TEXTURE_ALPHA_TYPE */
+/* reuse GL_TEXTURE_DEPTH_TYPE */
+/* reuse GL_UNSIGNED_NORMALIZED */
+/* reuse GL_FRAMEBUFFER_BINDING */
+/* reuse GL_DRAW_FRAMEBUFFER_BINDING */
+/* reuse GL_RENDERBUFFER_BINDING */
+/* reuse GL_READ_FRAMEBUFFER */
+/* reuse GL_DRAW_FRAMEBUFFER */
+/* reuse GL_READ_FRAMEBUFFER_BINDING */
+/* reuse GL_RENDERBUFFER_SAMPLES */
+/* reuse GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE */
+/* reuse GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME */
+/* reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL */
+/* reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE */
+/* reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER */
+/* reuse GL_FRAMEBUFFER_COMPLETE */
+/* reuse GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT */
+/* reuse GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT */
+/* reuse GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER */
+/* reuse GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER */
+/* reuse GL_FRAMEBUFFER_UNSUPPORTED */
+/* reuse GL_MAX_COLOR_ATTACHMENTS */
+/* reuse GL_COLOR_ATTACHMENT0 */
+/* reuse GL_COLOR_ATTACHMENT1 */
+/* reuse GL_COLOR_ATTACHMENT2 */
+/* reuse GL_COLOR_ATTACHMENT3 */
+/* reuse GL_COLOR_ATTACHMENT4 */
+/* reuse GL_COLOR_ATTACHMENT5 */
+/* reuse GL_COLOR_ATTACHMENT6 */
+/* reuse GL_COLOR_ATTACHMENT7 */
+/* reuse GL_COLOR_ATTACHMENT8 */
+/* reuse GL_COLOR_ATTACHMENT9 */
+/* reuse GL_COLOR_ATTACHMENT10 */
+/* reuse GL_COLOR_ATTACHMENT11 */
+/* reuse GL_COLOR_ATTACHMENT12 */
+/* reuse GL_COLOR_ATTACHMENT13 */
+/* reuse GL_COLOR_ATTACHMENT14 */
+/* reuse GL_COLOR_ATTACHMENT15 */
+/* reuse GL_DEPTH_ATTACHMENT */
+/* reuse GL_STENCIL_ATTACHMENT */
+/* reuse GL_FRAMEBUFFER */
+/* reuse GL_RENDERBUFFER */
+/* reuse GL_RENDERBUFFER_WIDTH */
+/* reuse GL_RENDERBUFFER_HEIGHT */
+/* reuse GL_RENDERBUFFER_INTERNAL_FORMAT */
+/* reuse GL_STENCIL_INDEX1 */
+/* reuse GL_STENCIL_INDEX4 */
+/* reuse GL_STENCIL_INDEX8 */
+/* reuse GL_STENCIL_INDEX16 */
+/* reuse GL_RENDERBUFFER_RED_SIZE */
+/* reuse GL_RENDERBUFFER_GREEN_SIZE */
+/* reuse GL_RENDERBUFFER_BLUE_SIZE */
+/* reuse GL_RENDERBUFFER_ALPHA_SIZE */
+/* reuse GL_RENDERBUFFER_DEPTH_SIZE */
+/* reuse GL_RENDERBUFFER_STENCIL_SIZE */
+/* reuse GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE */
+/* reuse GL_MAX_SAMPLES */
+/* Reuse tokens from ARB_framebuffer_sRGB */
+/* reuse GL_FRAMEBUFFER_SRGB */
+/* Reuse tokens from ARB_half_float_vertex */
+/* reuse GL_HALF_FLOAT */
+/* Reuse tokens from ARB_map_buffer_range */
+/* reuse GL_MAP_READ_BIT */
+/* reuse GL_MAP_WRITE_BIT */
+/* reuse GL_MAP_INVALIDATE_RANGE_BIT */
+/* reuse GL_MAP_INVALIDATE_BUFFER_BIT */
+/* reuse GL_MAP_FLUSH_EXPLICIT_BIT */
+/* reuse GL_MAP_UNSYNCHRONIZED_BIT */
+/* Reuse tokens from ARB_texture_compression_rgtc */
+/* reuse GL_COMPRESSED_RED_RGTC1 */
+/* reuse GL_COMPRESSED_SIGNED_RED_RGTC1 */
+/* reuse GL_COMPRESSED_RG_RGTC2 */
+/* reuse GL_COMPRESSED_SIGNED_RG_RGTC2 */
+/* Reuse tokens from ARB_texture_rg */
+/* reuse GL_RG */
+/* reuse GL_RG_INTEGER */
+/* reuse GL_R8 */
+/* reuse GL_R16 */
+/* reuse GL_RG8 */
+/* reuse GL_RG16 */
+/* reuse GL_R16F */
+/* reuse GL_R32F */
+/* reuse GL_RG16F */
+/* reuse GL_RG32F */
+/* reuse GL_R8I */
+/* reuse GL_R8UI */
+/* reuse GL_R16I */
+/* reuse GL_R16UI */
+/* reuse GL_R32I */
+/* reuse GL_R32UI */
+/* reuse GL_RG8I */
+/* reuse GL_RG8UI */
+/* reuse GL_RG16I */
+/* reuse GL_RG16UI */
+/* reuse GL_RG32I */
+/* reuse GL_RG32UI */
+/* Reuse tokens from ARB_vertex_array_object */
+/* reuse GL_VERTEX_ARRAY_BINDING */
+#endif
+
+#ifndef GL_VERSION_3_0_DEPRECATED
+#define GL_CLAMP_VERTEX_COLOR             0x891A
+#define GL_CLAMP_FRAGMENT_COLOR           0x891B
+#define GL_ALPHA_INTEGER                  0x8D97
+/* Reuse tokens from ARB_framebuffer_object */
+/* reuse GL_TEXTURE_LUMINANCE_TYPE */
+/* reuse GL_TEXTURE_INTENSITY_TYPE */
+#endif
+
+#ifndef GL_VERSION_3_1
+#define GL_SAMPLER_2D_RECT                0x8B63
+#define GL_SAMPLER_2D_RECT_SHADOW         0x8B64
+#define GL_SAMPLER_BUFFER                 0x8DC2
+#define GL_INT_SAMPLER_2D_RECT            0x8DCD
+#define GL_INT_SAMPLER_BUFFER             0x8DD0
+#define GL_UNSIGNED_INT_SAMPLER_2D_RECT   0x8DD5
+#define GL_UNSIGNED_INT_SAMPLER_BUFFER    0x8DD8
+#define GL_TEXTURE_BUFFER                 0x8C2A
+#define GL_MAX_TEXTURE_BUFFER_SIZE        0x8C2B
+#define GL_TEXTURE_BINDING_BUFFER         0x8C2C
+#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING 0x8C2D
+#define GL_TEXTURE_BUFFER_FORMAT          0x8C2E
+#define GL_TEXTURE_RECTANGLE              0x84F5
+#define GL_TEXTURE_BINDING_RECTANGLE      0x84F6
+#define GL_PROXY_TEXTURE_RECTANGLE        0x84F7
+#define GL_MAX_RECTANGLE_TEXTURE_SIZE     0x84F8
+#define GL_RED_SNORM                      0x8F90
+#define GL_RG_SNORM                       0x8F91
+#define GL_RGB_SNORM                      0x8F92
+#define GL_RGBA_SNORM                     0x8F93
+#define GL_R8_SNORM                       0x8F94
+#define GL_RG8_SNORM                      0x8F95
+#define GL_RGB8_SNORM                     0x8F96
+#define GL_RGBA8_SNORM                    0x8F97
+#define GL_R16_SNORM                      0x8F98
+#define GL_RG16_SNORM                     0x8F99
+#define GL_RGB16_SNORM                    0x8F9A
+#define GL_RGBA16_SNORM                   0x8F9B
+#define GL_SIGNED_NORMALIZED              0x8F9C
+#define GL_PRIMITIVE_RESTART              0x8F9D
+#define GL_PRIMITIVE_RESTART_INDEX        0x8F9E
+/* Reuse tokens from ARB_copy_buffer */
+/* reuse GL_COPY_READ_BUFFER */
+/* reuse GL_COPY_WRITE_BUFFER */
+/* Reuse tokens from ARB_draw_instanced (none) */
+/* Reuse tokens from ARB_uniform_buffer_object */
+/* reuse GL_UNIFORM_BUFFER */
+/* reuse GL_UNIFORM_BUFFER_BINDING */
+/* reuse GL_UNIFORM_BUFFER_START */
+/* reuse GL_UNIFORM_BUFFER_SIZE */
+/* reuse GL_MAX_VERTEX_UNIFORM_BLOCKS */
+/* reuse GL_MAX_FRAGMENT_UNIFORM_BLOCKS */
+/* reuse GL_MAX_COMBINED_UNIFORM_BLOCKS */
+/* reuse GL_MAX_UNIFORM_BUFFER_BINDINGS */
+/* reuse GL_MAX_UNIFORM_BLOCK_SIZE */
+/* reuse GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS */
+/* reuse GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS */
+/* reuse GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT */
+/* reuse GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH */
+/* reuse GL_ACTIVE_UNIFORM_BLOCKS */
+/* reuse GL_UNIFORM_TYPE */
+/* reuse GL_UNIFORM_SIZE */
+/* reuse GL_UNIFORM_NAME_LENGTH */
+/* reuse GL_UNIFORM_BLOCK_INDEX */
+/* reuse GL_UNIFORM_OFFSET */
+/* reuse GL_UNIFORM_ARRAY_STRIDE */
+/* reuse GL_UNIFORM_MATRIX_STRIDE */
+/* reuse GL_UNIFORM_IS_ROW_MAJOR */
+/* reuse GL_UNIFORM_BLOCK_BINDING */
+/* reuse GL_UNIFORM_BLOCK_DATA_SIZE */
+/* reuse GL_UNIFORM_BLOCK_NAME_LENGTH */
+/* reuse GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS */
+/* reuse GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES */
+/* reuse GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER */
+/* reuse GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER */
+/* reuse GL_INVALID_INDEX */
+#endif
+
+#ifndef GL_VERSION_3_2
+#define GL_CONTEXT_CORE_PROFILE_BIT       0x00000001
+#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002
+#define GL_LINES_ADJACENCY                0x000A
+#define GL_LINE_STRIP_ADJACENCY           0x000B
+#define GL_TRIANGLES_ADJACENCY            0x000C
+#define GL_TRIANGLE_STRIP_ADJACENCY       0x000D
+#define GL_PROGRAM_POINT_SIZE             0x8642
+#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS 0x8C29
+#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED 0x8DA7
+#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS 0x8DA8
+#define GL_GEOMETRY_SHADER                0x8DD9
+#define GL_GEOMETRY_VERTICES_OUT          0x8916
+#define GL_GEOMETRY_INPUT_TYPE            0x8917
+#define GL_GEOMETRY_OUTPUT_TYPE           0x8918
+#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS 0x8DDF
+#define GL_MAX_GEOMETRY_OUTPUT_VERTICES   0x8DE0
+#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS 0x8DE1
+#define GL_MAX_VERTEX_OUTPUT_COMPONENTS   0x9122
+#define GL_MAX_GEOMETRY_INPUT_COMPONENTS  0x9123
+#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS 0x9124
+#define GL_MAX_FRAGMENT_INPUT_COMPONENTS  0x9125
+#define GL_CONTEXT_PROFILE_MASK           0x9126
+/* reuse GL_MAX_VARYING_COMPONENTS */
+/* reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER */
+/* Reuse tokens from ARB_depth_clamp */
+/* reuse GL_DEPTH_CLAMP */
+/* Reuse tokens from ARB_draw_elements_base_vertex (none) */
+/* Reuse tokens from ARB_fragment_coord_conventions (none) */
+/* Reuse tokens from ARB_provoking_vertex */
+/* reuse GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION */
+/* reuse GL_FIRST_VERTEX_CONVENTION */
+/* reuse GL_LAST_VERTEX_CONVENTION */
+/* reuse GL_PROVOKING_VERTEX */
+/* Reuse tokens from ARB_seamless_cube_map */
+/* reuse GL_TEXTURE_CUBE_MAP_SEAMLESS */
+/* Reuse tokens from ARB_sync */
+/* reuse GL_MAX_SERVER_WAIT_TIMEOUT */
+/* reuse GL_OBJECT_TYPE */
+/* reuse GL_SYNC_CONDITION */
+/* reuse GL_SYNC_STATUS */
+/* reuse GL_SYNC_FLAGS */
+/* reuse GL_SYNC_FENCE */
+/* reuse GL_SYNC_GPU_COMMANDS_COMPLETE */
+/* reuse GL_UNSIGNALED */
+/* reuse GL_SIGNALED */
+/* reuse GL_ALREADY_SIGNALED */
+/* reuse GL_TIMEOUT_EXPIRED */
+/* reuse GL_CONDITION_SATISFIED */
+/* reuse GL_WAIT_FAILED */
+/* reuse GL_TIMEOUT_IGNORED */
+/* reuse GL_SYNC_FLUSH_COMMANDS_BIT */
+/* reuse GL_TIMEOUT_IGNORED */
+/* Reuse tokens from ARB_texture_multisample */
+/* reuse GL_SAMPLE_POSITION */
+/* reuse GL_SAMPLE_MASK */
+/* reuse GL_SAMPLE_MASK_VALUE */
+/* reuse GL_MAX_SAMPLE_MASK_WORDS */
+/* reuse GL_TEXTURE_2D_MULTISAMPLE */
+/* reuse GL_PROXY_TEXTURE_2D_MULTISAMPLE */
+/* reuse GL_TEXTURE_2D_MULTISAMPLE_ARRAY */
+/* reuse GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY */
+/* reuse GL_TEXTURE_BINDING_2D_MULTISAMPLE */
+/* reuse GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY */
+/* reuse GL_TEXTURE_SAMPLES */
+/* reuse GL_TEXTURE_FIXED_SAMPLE_LOCATIONS */
+/* reuse GL_SAMPLER_2D_MULTISAMPLE */
+/* reuse GL_INT_SAMPLER_2D_MULTISAMPLE */
+/* reuse GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE */
+/* reuse GL_SAMPLER_2D_MULTISAMPLE_ARRAY */
+/* reuse GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY */
+/* reuse GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY */
+/* reuse GL_MAX_COLOR_TEXTURE_SAMPLES */
+/* reuse GL_MAX_DEPTH_TEXTURE_SAMPLES */
+/* reuse GL_MAX_INTEGER_SAMPLES */
+/* Don't need to reuse tokens from ARB_vertex_array_bgra since they're already in 1.2 core */
+#endif
+
+#ifndef GL_VERSION_3_3
+#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR    0x88FE
+/* Reuse tokens from ARB_blend_func_extended */
+/* reuse GL_SRC1_COLOR */
+/* reuse GL_ONE_MINUS_SRC1_COLOR */
+/* reuse GL_ONE_MINUS_SRC1_ALPHA */
+/* reuse GL_MAX_DUAL_SOURCE_DRAW_BUFFERS */
+/* Reuse tokens from ARB_explicit_attrib_location (none) */
+/* Reuse tokens from ARB_occlusion_query2 */
+/* reuse GL_ANY_SAMPLES_PASSED */
+/* Reuse tokens from ARB_sampler_objects */
+/* reuse GL_SAMPLER_BINDING */
+/* Reuse tokens from ARB_shader_bit_encoding (none) */
+/* Reuse tokens from ARB_texture_rgb10_a2ui */
+/* reuse GL_RGB10_A2UI */
+/* Reuse tokens from ARB_texture_swizzle */
+/* reuse GL_TEXTURE_SWIZZLE_R */
+/* reuse GL_TEXTURE_SWIZZLE_G */
+/* reuse GL_TEXTURE_SWIZZLE_B */
+/* reuse GL_TEXTURE_SWIZZLE_A */
+/* reuse GL_TEXTURE_SWIZZLE_RGBA */
+/* Reuse tokens from ARB_timer_query */
+/* reuse GL_TIME_ELAPSED */
+/* reuse GL_TIMESTAMP */
+/* Reuse tokens from ARB_vertex_type_2_10_10_10_rev */
+/* reuse GL_INT_2_10_10_10_REV */
+#endif
+
+#ifndef GL_VERSION_4_0
+#define GL_SAMPLE_SHADING                 0x8C36
+#define GL_MIN_SAMPLE_SHADING_VALUE       0x8C37
+#define GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET 0x8E5E
+#define GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET 0x8E5F
+#define GL_TEXTURE_CUBE_MAP_ARRAY         0x9009
+#define GL_TEXTURE_BINDING_CUBE_MAP_ARRAY 0x900A
+#define GL_PROXY_TEXTURE_CUBE_MAP_ARRAY   0x900B
+#define GL_SAMPLER_CUBE_MAP_ARRAY         0x900C
+#define GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW  0x900D
+#define GL_INT_SAMPLER_CUBE_MAP_ARRAY     0x900E
+#define GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY 0x900F
+/* Reuse tokens from ARB_texture_query_lod (none) */
+/* Reuse tokens from ARB_draw_buffers_blend (none) */
+/* Reuse tokens from ARB_draw_indirect */
+/* reuse GL_DRAW_INDIRECT_BUFFER */
+/* reuse GL_DRAW_INDIRECT_BUFFER_BINDING */
+/* Reuse tokens from ARB_gpu_shader5 */
+/* reuse GL_GEOMETRY_SHADER_INVOCATIONS */
+/* reuse GL_MAX_GEOMETRY_SHADER_INVOCATIONS */
+/* reuse GL_MIN_FRAGMENT_INTERPOLATION_OFFSET */
+/* reuse GL_MAX_FRAGMENT_INTERPOLATION_OFFSET */
+/* reuse GL_FRAGMENT_INTERPOLATION_OFFSET_BITS */
+/* reuse GL_MAX_VERTEX_STREAMS */
+/* Reuse tokens from ARB_gpu_shader_fp64 */
+/* reuse GL_DOUBLE_VEC2 */
+/* reuse GL_DOUBLE_VEC3 */
+/* reuse GL_DOUBLE_VEC4 */
+/* reuse GL_DOUBLE_MAT2 */
+/* reuse GL_DOUBLE_MAT3 */
+/* reuse GL_DOUBLE_MAT4 */
+/* reuse GL_DOUBLE_MAT2x3 */
+/* reuse GL_DOUBLE_MAT2x4 */
+/* reuse GL_DOUBLE_MAT3x2 */
+/* reuse GL_DOUBLE_MAT3x4 */
+/* reuse GL_DOUBLE_MAT4x2 */
+/* reuse GL_DOUBLE_MAT4x3 */
+/* Reuse tokens from ARB_shader_subroutine */
+/* reuse GL_ACTIVE_SUBROUTINES */
+/* reuse GL_ACTIVE_SUBROUTINE_UNIFORMS */
+/* reuse GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS */
+/* reuse GL_ACTIVE_SUBROUTINE_MAX_LENGTH */
+/* reuse GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH */
+/* reuse GL_MAX_SUBROUTINES */
+/* reuse GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS */
+/* reuse GL_NUM_COMPATIBLE_SUBROUTINES */
+/* reuse GL_COMPATIBLE_SUBROUTINES */
+/* Reuse tokens from ARB_tessellation_shader */
+/* reuse GL_PATCHES */
+/* reuse GL_PATCH_VERTICES */
+/* reuse GL_PATCH_DEFAULT_INNER_LEVEL */
+/* reuse GL_PATCH_DEFAULT_OUTER_LEVEL */
+/* reuse GL_TESS_CONTROL_OUTPUT_VERTICES */
+/* reuse GL_TESS_GEN_MODE */
+/* reuse GL_TESS_GEN_SPACING */
+/* reuse GL_TESS_GEN_VERTEX_ORDER */
+/* reuse GL_TESS_GEN_POINT_MODE */
+/* reuse GL_ISOLINES */
+/* reuse GL_FRACTIONAL_ODD */
+/* reuse GL_FRACTIONAL_EVEN */
+/* reuse GL_MAX_PATCH_VERTICES */
+/* reuse GL_MAX_TESS_GEN_LEVEL */
+/* reuse GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS */
+/* reuse GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS */
+/* reuse GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS */
+/* reuse GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS */
+/* reuse GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS */
+/* reuse GL_MAX_TESS_PATCH_COMPONENTS */
+/* reuse GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS */
+/* reuse GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS */
+/* reuse GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS */
+/* reuse GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS */
+/* reuse GL_MAX_TESS_CONTROL_INPUT_COMPONENTS */
+/* reuse GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS */
+/* reuse GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS */
+/* reuse GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS */
+/* reuse GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER */
+/* reuse GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER */
+/* reuse GL_TESS_EVALUATION_SHADER */
+/* reuse GL_TESS_CONTROL_SHADER */
+/* Reuse tokens from ARB_texture_buffer_object_rgb32 (none) */
+/* Reuse tokens from ARB_transform_feedback2 */
+/* reuse GL_TRANSFORM_FEEDBACK */
+/* reuse GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED */
+/* reuse GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE */
+/* reuse GL_TRANSFORM_FEEDBACK_BINDING */
+/* Reuse tokens from ARB_transform_feedback3 */
+/* reuse GL_MAX_TRANSFORM_FEEDBACK_BUFFERS */
+/* reuse GL_MAX_VERTEX_STREAMS */
+#endif
+
+#ifndef GL_VERSION_4_1
+/* Reuse tokens from ARB_ES2_compatibility */
+/* reuse GL_FIXED */
+/* reuse GL_IMPLEMENTATION_COLOR_READ_TYPE */
+/* reuse GL_IMPLEMENTATION_COLOR_READ_FORMAT */
+/* reuse GL_LOW_FLOAT */
+/* reuse GL_MEDIUM_FLOAT */
+/* reuse GL_HIGH_FLOAT */
+/* reuse GL_LOW_INT */
+/* reuse GL_MEDIUM_INT */
+/* reuse GL_HIGH_INT */
+/* reuse GL_SHADER_COMPILER */
+/* reuse GL_NUM_SHADER_BINARY_FORMATS */
+/* reuse GL_MAX_VERTEX_UNIFORM_VECTORS */
+/* reuse GL_MAX_VARYING_VECTORS */
+/* reuse GL_MAX_FRAGMENT_UNIFORM_VECTORS */
+/* Reuse tokens from ARB_get_program_binary */
+/* reuse GL_PROGRAM_BINARY_RETRIEVABLE_HINT */
+/* reuse GL_PROGRAM_BINARY_LENGTH */
+/* reuse GL_NUM_PROGRAM_BINARY_FORMATS */
+/* reuse GL_PROGRAM_BINARY_FORMATS */
+/* Reuse tokens from ARB_separate_shader_objects */
+/* reuse GL_VERTEX_SHADER_BIT */
+/* reuse GL_FRAGMENT_SHADER_BIT */
+/* reuse GL_GEOMETRY_SHADER_BIT */
+/* reuse GL_TESS_CONTROL_SHADER_BIT */
+/* reuse GL_TESS_EVALUATION_SHADER_BIT */
+/* reuse GL_ALL_SHADER_BITS */
+/* reuse GL_PROGRAM_SEPARABLE */
+/* reuse GL_ACTIVE_PROGRAM */
+/* reuse GL_PROGRAM_PIPELINE_BINDING */
+/* Reuse tokens from ARB_shader_precision (none) */
+/* Reuse tokens from ARB_vertex_attrib_64bit - all are in GL 3.0 and 4.0 already */
+/* Reuse tokens from ARB_viewport_array - some are in GL 1.1 and ARB_provoking_vertex already */
+/* reuse GL_MAX_VIEWPORTS */
+/* reuse GL_VIEWPORT_SUBPIXEL_BITS */
+/* reuse GL_VIEWPORT_BOUNDS_RANGE */
+/* reuse GL_LAYER_PROVOKING_VERTEX */
+/* reuse GL_VIEWPORT_INDEX_PROVOKING_VERTEX */
+/* reuse GL_UNDEFINED_VERTEX */
+#endif
+
+#ifndef GL_ARB_multitexture
+#define GL_TEXTURE0_ARB                   0x84C0
+#define GL_TEXTURE1_ARB                   0x84C1
+#define GL_TEXTURE2_ARB                   0x84C2
+#define GL_TEXTURE3_ARB                   0x84C3
+#define GL_TEXTURE4_ARB                   0x84C4
+#define GL_TEXTURE5_ARB                   0x84C5
+#define GL_TEXTURE6_ARB                   0x84C6
+#define GL_TEXTURE7_ARB                   0x84C7
+#define GL_TEXTURE8_ARB                   0x84C8
+#define GL_TEXTURE9_ARB                   0x84C9
+#define GL_TEXTURE10_ARB                  0x84CA
+#define GL_TEXTURE11_ARB                  0x84CB
+#define GL_TEXTURE12_ARB                  0x84CC
+#define GL_TEXTURE13_ARB                  0x84CD
+#define GL_TEXTURE14_ARB                  0x84CE
+#define GL_TEXTURE15_ARB                  0x84CF
+#define GL_TEXTURE16_ARB                  0x84D0
+#define GL_TEXTURE17_ARB                  0x84D1
+#define GL_TEXTURE18_ARB                  0x84D2
+#define GL_TEXTURE19_ARB                  0x84D3
+#define GL_TEXTURE20_ARB                  0x84D4
+#define GL_TEXTURE21_ARB                  0x84D5
+#define GL_TEXTURE22_ARB                  0x84D6
+#define GL_TEXTURE23_ARB                  0x84D7
+#define GL_TEXTURE24_ARB                  0x84D8
+#define GL_TEXTURE25_ARB                  0x84D9
+#define GL_TEXTURE26_ARB                  0x84DA
+#define GL_TEXTURE27_ARB                  0x84DB
+#define GL_TEXTURE28_ARB                  0x84DC
+#define GL_TEXTURE29_ARB                  0x84DD
+#define GL_TEXTURE30_ARB                  0x84DE
+#define GL_TEXTURE31_ARB                  0x84DF
+#define GL_ACTIVE_TEXTURE_ARB             0x84E0
+#define GL_CLIENT_ACTIVE_TEXTURE_ARB      0x84E1
+#define GL_MAX_TEXTURE_UNITS_ARB          0x84E2
+#endif
+
+#ifndef GL_ARB_transpose_matrix
+#define GL_TRANSPOSE_MODELVIEW_MATRIX_ARB 0x84E3
+#define GL_TRANSPOSE_PROJECTION_MATRIX_ARB 0x84E4
+#define GL_TRANSPOSE_TEXTURE_MATRIX_ARB   0x84E5
+#define GL_TRANSPOSE_COLOR_MATRIX_ARB     0x84E6
+#endif
+
+#ifndef GL_ARB_multisample
+#define GL_MULTISAMPLE_ARB                0x809D
+#define GL_SAMPLE_ALPHA_TO_COVERAGE_ARB   0x809E
+#define GL_SAMPLE_ALPHA_TO_ONE_ARB        0x809F
+#define GL_SAMPLE_COVERAGE_ARB            0x80A0
+#define GL_SAMPLE_BUFFERS_ARB             0x80A8
+#define GL_SAMPLES_ARB                    0x80A9
+#define GL_SAMPLE_COVERAGE_VALUE_ARB      0x80AA
+#define GL_SAMPLE_COVERAGE_INVERT_ARB     0x80AB
+#define GL_MULTISAMPLE_BIT_ARB            0x20000000
+#endif
+
+#ifndef GL_ARB_texture_env_add
+#endif
+
+#ifndef GL_ARB_texture_cube_map
+#define GL_NORMAL_MAP_ARB                 0x8511
+#define GL_REFLECTION_MAP_ARB             0x8512
+#define GL_TEXTURE_CUBE_MAP_ARB           0x8513
+#define GL_TEXTURE_BINDING_CUBE_MAP_ARB   0x8514
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x8515
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x8516
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x8517
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x8518
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x8519
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB 0x851A
+#define GL_PROXY_TEXTURE_CUBE_MAP_ARB     0x851B
+#define GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB  0x851C
+#endif
+
+#ifndef GL_ARB_texture_compression
+#define GL_COMPRESSED_ALPHA_ARB           0x84E9
+#define GL_COMPRESSED_LUMINANCE_ARB       0x84EA
+#define GL_COMPRESSED_LUMINANCE_ALPHA_ARB 0x84EB
+#define GL_COMPRESSED_INTENSITY_ARB       0x84EC
+#define GL_COMPRESSED_RGB_ARB             0x84ED
+#define GL_COMPRESSED_RGBA_ARB            0x84EE
+#define GL_TEXTURE_COMPRESSION_HINT_ARB   0x84EF
+#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB 0x86A0
+#define GL_TEXTURE_COMPRESSED_ARB         0x86A1
+#define GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A2
+#define GL_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A3
+#endif
+
+#ifndef GL_ARB_texture_border_clamp
+#define GL_CLAMP_TO_BORDER_ARB            0x812D
+#endif
+
+#ifndef GL_ARB_point_parameters
+#define GL_POINT_SIZE_MIN_ARB             0x8126
+#define GL_POINT_SIZE_MAX_ARB             0x8127
+#define GL_POINT_FADE_THRESHOLD_SIZE_ARB  0x8128
+#define GL_POINT_DISTANCE_ATTENUATION_ARB 0x8129
+#endif
+
+#ifndef GL_ARB_vertex_blend
+#define GL_MAX_VERTEX_UNITS_ARB           0x86A4
+#define GL_ACTIVE_VERTEX_UNITS_ARB        0x86A5
+#define GL_WEIGHT_SUM_UNITY_ARB           0x86A6
+#define GL_VERTEX_BLEND_ARB               0x86A7
+#define GL_CURRENT_WEIGHT_ARB             0x86A8
+#define GL_WEIGHT_ARRAY_TYPE_ARB          0x86A9
+#define GL_WEIGHT_ARRAY_STRIDE_ARB        0x86AA
+#define GL_WEIGHT_ARRAY_SIZE_ARB          0x86AB
+#define GL_WEIGHT_ARRAY_POINTER_ARB       0x86AC
+#define GL_WEIGHT_ARRAY_ARB               0x86AD
+#define GL_MODELVIEW0_ARB                 0x1700
+#define GL_MODELVIEW1_ARB                 0x850A
+#define GL_MODELVIEW2_ARB                 0x8722
+#define GL_MODELVIEW3_ARB                 0x8723
+#define GL_MODELVIEW4_ARB                 0x8724
+#define GL_MODELVIEW5_ARB                 0x8725
+#define GL_MODELVIEW6_ARB                 0x8726
+#define GL_MODELVIEW7_ARB                 0x8727
+#define GL_MODELVIEW8_ARB                 0x8728
+#define GL_MODELVIEW9_ARB                 0x8729
+#define GL_MODELVIEW10_ARB                0x872A
+#define GL_MODELVIEW11_ARB                0x872B
+#define GL_MODELVIEW12_ARB                0x872C
+#define GL_MODELVIEW13_ARB                0x872D
+#define GL_MODELVIEW14_ARB                0x872E
+#define GL_MODELVIEW15_ARB                0x872F
+#define GL_MODELVIEW16_ARB                0x8730
+#define GL_MODELVIEW17_ARB                0x8731
+#define GL_MODELVIEW18_ARB                0x8732
+#define GL_MODELVIEW19_ARB                0x8733
+#define GL_MODELVIEW20_ARB                0x8734
+#define GL_MODELVIEW21_ARB                0x8735
+#define GL_MODELVIEW22_ARB                0x8736
+#define GL_MODELVIEW23_ARB                0x8737
+#define GL_MODELVIEW24_ARB                0x8738
+#define GL_MODELVIEW25_ARB                0x8739
+#define GL_MODELVIEW26_ARB                0x873A
+#define GL_MODELVIEW27_ARB                0x873B
+#define GL_MODELVIEW28_ARB                0x873C
+#define GL_MODELVIEW29_ARB                0x873D
+#define GL_MODELVIEW30_ARB                0x873E
+#define GL_MODELVIEW31_ARB                0x873F
+#endif
+
+#ifndef GL_ARB_matrix_palette
+#define GL_MATRIX_PALETTE_ARB             0x8840
+#define GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB 0x8841
+#define GL_MAX_PALETTE_MATRICES_ARB       0x8842
+#define GL_CURRENT_PALETTE_MATRIX_ARB     0x8843
+#define GL_MATRIX_INDEX_ARRAY_ARB         0x8844
+#define GL_CURRENT_MATRIX_INDEX_ARB       0x8845
+#define GL_MATRIX_INDEX_ARRAY_SIZE_ARB    0x8846
+#define GL_MATRIX_INDEX_ARRAY_TYPE_ARB    0x8847
+#define GL_MATRIX_INDEX_ARRAY_STRIDE_ARB  0x8848
+#define GL_MATRIX_INDEX_ARRAY_POINTER_ARB 0x8849
+#endif
+
+#ifndef GL_ARB_texture_env_combine
+#define GL_COMBINE_ARB                    0x8570
+#define GL_COMBINE_RGB_ARB                0x8571
+#define GL_COMBINE_ALPHA_ARB              0x8572
+#define GL_SOURCE0_RGB_ARB                0x8580
+#define GL_SOURCE1_RGB_ARB                0x8581
+#define GL_SOURCE2_RGB_ARB                0x8582
+#define GL_SOURCE0_ALPHA_ARB              0x8588
+#define GL_SOURCE1_ALPHA_ARB              0x8589
+#define GL_SOURCE2_ALPHA_ARB              0x858A
+#define GL_OPERAND0_RGB_ARB               0x8590
+#define GL_OPERAND1_RGB_ARB               0x8591
+#define GL_OPERAND2_RGB_ARB               0x8592
+#define GL_OPERAND0_ALPHA_ARB             0x8598
+#define GL_OPERAND1_ALPHA_ARB             0x8599
+#define GL_OPERAND2_ALPHA_ARB             0x859A
+#define GL_RGB_SCALE_ARB                  0x8573
+#define GL_ADD_SIGNED_ARB                 0x8574
+#define GL_INTERPOLATE_ARB                0x8575
+#define GL_SUBTRACT_ARB                   0x84E7
+#define GL_CONSTANT_ARB                   0x8576
+#define GL_PRIMARY_COLOR_ARB              0x8577
+#define GL_PREVIOUS_ARB                   0x8578
+#endif
+
+#ifndef GL_ARB_texture_env_crossbar
+#endif
+
+#ifndef GL_ARB_texture_env_dot3
+#define GL_DOT3_RGB_ARB                   0x86AE
+#define GL_DOT3_RGBA_ARB                  0x86AF
+#endif
+
+#ifndef GL_ARB_texture_mirrored_repeat
+#define GL_MIRRORED_REPEAT_ARB            0x8370
+#endif
+
+#ifndef GL_ARB_depth_texture
+#define GL_DEPTH_COMPONENT16_ARB          0x81A5
+#define GL_DEPTH_COMPONENT24_ARB          0x81A6
+#define GL_DEPTH_COMPONENT32_ARB          0x81A7
+#define GL_TEXTURE_DEPTH_SIZE_ARB         0x884A
+#define GL_DEPTH_TEXTURE_MODE_ARB         0x884B
+#endif
+
+#ifndef GL_ARB_shadow
+#define GL_TEXTURE_COMPARE_MODE_ARB       0x884C
+#define GL_TEXTURE_COMPARE_FUNC_ARB       0x884D
+#define GL_COMPARE_R_TO_TEXTURE_ARB       0x884E
+#endif
+
+#ifndef GL_ARB_shadow_ambient
+#define GL_TEXTURE_COMPARE_FAIL_VALUE_ARB 0x80BF
+#endif
+
+#ifndef GL_ARB_window_pos
+#endif
+
+#ifndef GL_ARB_vertex_program
+#define GL_COLOR_SUM_ARB                  0x8458
+#define GL_VERTEX_PROGRAM_ARB             0x8620
+#define GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB 0x8622
+#define GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB   0x8623
+#define GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB 0x8624
+#define GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB   0x8625
+#define GL_CURRENT_VERTEX_ATTRIB_ARB      0x8626
+#define GL_PROGRAM_LENGTH_ARB             0x8627
+#define GL_PROGRAM_STRING_ARB             0x8628
+#define GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB 0x862E
+#define GL_MAX_PROGRAM_MATRICES_ARB       0x862F
+#define GL_CURRENT_MATRIX_STACK_DEPTH_ARB 0x8640
+#define GL_CURRENT_MATRIX_ARB             0x8641
+#define GL_VERTEX_PROGRAM_POINT_SIZE_ARB  0x8642
+#define GL_VERTEX_PROGRAM_TWO_SIDE_ARB    0x8643
+#define GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB 0x8645
+#define GL_PROGRAM_ERROR_POSITION_ARB     0x864B
+#define GL_PROGRAM_BINDING_ARB            0x8677
+#define GL_MAX_VERTEX_ATTRIBS_ARB         0x8869
+#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB 0x886A
+#define GL_PROGRAM_ERROR_STRING_ARB       0x8874
+#define GL_PROGRAM_FORMAT_ASCII_ARB       0x8875
+#define GL_PROGRAM_FORMAT_ARB             0x8876
+#define GL_PROGRAM_INSTRUCTIONS_ARB       0x88A0
+#define GL_MAX_PROGRAM_INSTRUCTIONS_ARB   0x88A1
+#define GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB 0x88A2
+#define GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB 0x88A3
+#define GL_PROGRAM_TEMPORARIES_ARB        0x88A4
+#define GL_MAX_PROGRAM_TEMPORARIES_ARB    0x88A5
+#define GL_PROGRAM_NATIVE_TEMPORARIES_ARB 0x88A6
+#define GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB 0x88A7
+#define GL_PROGRAM_PARAMETERS_ARB         0x88A8
+#define GL_MAX_PROGRAM_PARAMETERS_ARB     0x88A9
+#define GL_PROGRAM_NATIVE_PARAMETERS_ARB  0x88AA
+#define GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB 0x88AB
+#define GL_PROGRAM_ATTRIBS_ARB            0x88AC
+#define GL_MAX_PROGRAM_ATTRIBS_ARB        0x88AD
+#define GL_PROGRAM_NATIVE_ATTRIBS_ARB     0x88AE
+#define GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB 0x88AF
+#define GL_PROGRAM_ADDRESS_REGISTERS_ARB  0x88B0
+#define GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB 0x88B1
+#define GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB 0x88B2
+#define GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB 0x88B3
+#define GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB 0x88B4
+#define GL_MAX_PROGRAM_ENV_PARAMETERS_ARB 0x88B5
+#define GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB 0x88B6
+#define GL_TRANSPOSE_CURRENT_MATRIX_ARB   0x88B7
+#define GL_MATRIX0_ARB                    0x88C0
+#define GL_MATRIX1_ARB                    0x88C1
+#define GL_MATRIX2_ARB                    0x88C2
+#define GL_MATRIX3_ARB                    0x88C3
+#define GL_MATRIX4_ARB                    0x88C4
+#define GL_MATRIX5_ARB                    0x88C5
+#define GL_MATRIX6_ARB                    0x88C6
+#define GL_MATRIX7_ARB                    0x88C7
+#define GL_MATRIX8_ARB                    0x88C8
+#define GL_MATRIX9_ARB                    0x88C9
+#define GL_MATRIX10_ARB                   0x88CA
+#define GL_MATRIX11_ARB                   0x88CB
+#define GL_MATRIX12_ARB                   0x88CC
+#define GL_MATRIX13_ARB                   0x88CD
+#define GL_MATRIX14_ARB                   0x88CE
+#define GL_MATRIX15_ARB                   0x88CF
+#define GL_MATRIX16_ARB                   0x88D0
+#define GL_MATRIX17_ARB                   0x88D1
+#define GL_MATRIX18_ARB                   0x88D2
+#define GL_MATRIX19_ARB                   0x88D3
+#define GL_MATRIX20_ARB                   0x88D4
+#define GL_MATRIX21_ARB                   0x88D5
+#define GL_MATRIX22_ARB                   0x88D6
+#define GL_MATRIX23_ARB                   0x88D7
+#define GL_MATRIX24_ARB                   0x88D8
+#define GL_MATRIX25_ARB                   0x88D9
+#define GL_MATRIX26_ARB                   0x88DA
+#define GL_MATRIX27_ARB                   0x88DB
+#define GL_MATRIX28_ARB                   0x88DC
+#define GL_MATRIX29_ARB                   0x88DD
+#define GL_MATRIX30_ARB                   0x88DE
+#define GL_MATRIX31_ARB                   0x88DF
+#endif
+
+#ifndef GL_ARB_fragment_program
+#define GL_FRAGMENT_PROGRAM_ARB           0x8804
+#define GL_PROGRAM_ALU_INSTRUCTIONS_ARB   0x8805
+#define GL_PROGRAM_TEX_INSTRUCTIONS_ARB   0x8806
+#define GL_PROGRAM_TEX_INDIRECTIONS_ARB   0x8807
+#define GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB 0x8808
+#define GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB 0x8809
+#define GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB 0x880A
+#define GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB 0x880B
+#define GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB 0x880C
+#define GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB 0x880D
+#define GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB 0x880E
+#define GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB 0x880F
+#define GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB 0x8810
+#define GL_MAX_TEXTURE_COORDS_ARB         0x8871
+#define GL_MAX_TEXTURE_IMAGE_UNITS_ARB    0x8872
+#endif
+
+#ifndef GL_ARB_vertex_buffer_object
+#define GL_BUFFER_SIZE_ARB                0x8764
+#define GL_BUFFER_USAGE_ARB               0x8765
+#define GL_ARRAY_BUFFER_ARB               0x8892
+#define GL_ELEMENT_ARRAY_BUFFER_ARB       0x8893
+#define GL_ARRAY_BUFFER_BINDING_ARB       0x8894
+#define GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB 0x8895
+#define GL_VERTEX_ARRAY_BUFFER_BINDING_ARB 0x8896
+#define GL_NORMAL_ARRAY_BUFFER_BINDING_ARB 0x8897
+#define GL_COLOR_ARRAY_BUFFER_BINDING_ARB 0x8898
+#define GL_INDEX_ARRAY_BUFFER_BINDING_ARB 0x8899
+#define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB 0x889A
+#define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB 0x889B
+#define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB 0x889C
+#define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB 0x889D
+#define GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB 0x889E
+#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB 0x889F
+#define GL_READ_ONLY_ARB                  0x88B8
+#define GL_WRITE_ONLY_ARB                 0x88B9
+#define GL_READ_WRITE_ARB                 0x88BA
+#define GL_BUFFER_ACCESS_ARB              0x88BB
+#define GL_BUFFER_MAPPED_ARB              0x88BC
+#define GL_BUFFER_MAP_POINTER_ARB         0x88BD
+#define GL_STREAM_DRAW_ARB                0x88E0
+#define GL_STREAM_READ_ARB                0x88E1
+#define GL_STREAM_COPY_ARB                0x88E2
+#define GL_STATIC_DRAW_ARB                0x88E4
+#define GL_STATIC_READ_ARB                0x88E5
+#define GL_STATIC_COPY_ARB                0x88E6
+#define GL_DYNAMIC_DRAW_ARB               0x88E8
+#define GL_DYNAMIC_READ_ARB               0x88E9
+#define GL_DYNAMIC_COPY_ARB               0x88EA
+#endif
+
+#ifndef GL_ARB_occlusion_query
+#define GL_QUERY_COUNTER_BITS_ARB         0x8864
+#define GL_CURRENT_QUERY_ARB              0x8865
+#define GL_QUERY_RESULT_ARB               0x8866
+#define GL_QUERY_RESULT_AVAILABLE_ARB     0x8867
+#define GL_SAMPLES_PASSED_ARB             0x8914
+#endif
+
+#ifndef GL_ARB_shader_objects
+#define GL_PROGRAM_OBJECT_ARB             0x8B40
+#define GL_SHADER_OBJECT_ARB              0x8B48
+#define GL_OBJECT_TYPE_ARB                0x8B4E
+#define GL_OBJECT_SUBTYPE_ARB             0x8B4F
+#define GL_FLOAT_VEC2_ARB                 0x8B50
+#define GL_FLOAT_VEC3_ARB                 0x8B51
+#define GL_FLOAT_VEC4_ARB                 0x8B52
+#define GL_INT_VEC2_ARB                   0x8B53
+#define GL_INT_VEC3_ARB                   0x8B54
+#define GL_INT_VEC4_ARB                   0x8B55
+#define GL_BOOL_ARB                       0x8B56
+#define GL_BOOL_VEC2_ARB                  0x8B57
+#define GL_BOOL_VEC3_ARB                  0x8B58
+#define GL_BOOL_VEC4_ARB                  0x8B59
+#define GL_FLOAT_MAT2_ARB                 0x8B5A
+#define GL_FLOAT_MAT3_ARB                 0x8B5B
+#define GL_FLOAT_MAT4_ARB                 0x8B5C
+#define GL_SAMPLER_1D_ARB                 0x8B5D
+#define GL_SAMPLER_2D_ARB                 0x8B5E
+#define GL_SAMPLER_3D_ARB                 0x8B5F
+#define GL_SAMPLER_CUBE_ARB               0x8B60
+#define GL_SAMPLER_1D_SHADOW_ARB          0x8B61
+#define GL_SAMPLER_2D_SHADOW_ARB          0x8B62
+#define GL_SAMPLER_2D_RECT_ARB            0x8B63
+#define GL_SAMPLER_2D_RECT_SHADOW_ARB     0x8B64
+#define GL_OBJECT_DELETE_STATUS_ARB       0x8B80
+#define GL_OBJECT_COMPILE_STATUS_ARB      0x8B81
+#define GL_OBJECT_LINK_STATUS_ARB         0x8B82
+#define GL_OBJECT_VALIDATE_STATUS_ARB     0x8B83
+#define GL_OBJECT_INFO_LOG_LENGTH_ARB     0x8B84
+#define GL_OBJECT_ATTACHED_OBJECTS_ARB    0x8B85
+#define GL_OBJECT_ACTIVE_UNIFORMS_ARB     0x8B86
+#define GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB 0x8B87
+#define GL_OBJECT_SHADER_SOURCE_LENGTH_ARB 0x8B88
+#endif
+
+#ifndef GL_ARB_vertex_shader
+#define GL_VERTEX_SHADER_ARB              0x8B31
+#define GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB 0x8B4A
+#define GL_MAX_VARYING_FLOATS_ARB         0x8B4B
+#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB 0x8B4C
+#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB 0x8B4D
+#define GL_OBJECT_ACTIVE_ATTRIBUTES_ARB   0x8B89
+#define GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB 0x8B8A
+#endif
+
+#ifndef GL_ARB_fragment_shader
+#define GL_FRAGMENT_SHADER_ARB            0x8B30
+#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB 0x8B49
+#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB 0x8B8B
+#endif
+
+#ifndef GL_ARB_shading_language_100
+#define GL_SHADING_LANGUAGE_VERSION_ARB   0x8B8C
+#endif
+
+#ifndef GL_ARB_texture_non_power_of_two
+#endif
+
+#ifndef GL_ARB_point_sprite
+#define GL_POINT_SPRITE_ARB               0x8861
+#define GL_COORD_REPLACE_ARB              0x8862
+#endif
+
+#ifndef GL_ARB_fragment_program_shadow
+#endif
+
+#ifndef GL_ARB_draw_buffers
+#define GL_MAX_DRAW_BUFFERS_ARB           0x8824
+#define GL_DRAW_BUFFER0_ARB               0x8825
+#define GL_DRAW_BUFFER1_ARB               0x8826
+#define GL_DRAW_BUFFER2_ARB               0x8827
+#define GL_DRAW_BUFFER3_ARB               0x8828
+#define GL_DRAW_BUFFER4_ARB               0x8829
+#define GL_DRAW_BUFFER5_ARB               0x882A
+#define GL_DRAW_BUFFER6_ARB               0x882B
+#define GL_DRAW_BUFFER7_ARB               0x882C
+#define GL_DRAW_BUFFER8_ARB               0x882D
+#define GL_DRAW_BUFFER9_ARB               0x882E
+#define GL_DRAW_BUFFER10_ARB              0x882F
+#define GL_DRAW_BUFFER11_ARB              0x8830
+#define GL_DRAW_BUFFER12_ARB              0x8831
+#define GL_DRAW_BUFFER13_ARB              0x8832
+#define GL_DRAW_BUFFER14_ARB              0x8833
+#define GL_DRAW_BUFFER15_ARB              0x8834
+#endif
+
+#ifndef GL_ARB_texture_rectangle
+#define GL_TEXTURE_RECTANGLE_ARB          0x84F5
+#define GL_TEXTURE_BINDING_RECTANGLE_ARB  0x84F6
+#define GL_PROXY_TEXTURE_RECTANGLE_ARB    0x84F7
+#define GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB 0x84F8
+#endif
+
+#ifndef GL_ARB_color_buffer_float
+#define GL_RGBA_FLOAT_MODE_ARB            0x8820
+#define GL_CLAMP_VERTEX_COLOR_ARB         0x891A
+#define GL_CLAMP_FRAGMENT_COLOR_ARB       0x891B
+#define GL_CLAMP_READ_COLOR_ARB           0x891C
+#define GL_FIXED_ONLY_ARB                 0x891D
+#endif
+
+#ifndef GL_ARB_half_float_pixel
+#define GL_HALF_FLOAT_ARB                 0x140B
+#endif
+
+#ifndef GL_ARB_texture_float
+#define GL_TEXTURE_RED_TYPE_ARB           0x8C10
+#define GL_TEXTURE_GREEN_TYPE_ARB         0x8C11
+#define GL_TEXTURE_BLUE_TYPE_ARB          0x8C12
+#define GL_TEXTURE_ALPHA_TYPE_ARB         0x8C13
+#define GL_TEXTURE_LUMINANCE_TYPE_ARB     0x8C14
+#define GL_TEXTURE_INTENSITY_TYPE_ARB     0x8C15
+#define GL_TEXTURE_DEPTH_TYPE_ARB         0x8C16
+#define GL_UNSIGNED_NORMALIZED_ARB        0x8C17
+#define GL_RGBA32F_ARB                    0x8814
+#define GL_RGB32F_ARB                     0x8815
+#define GL_ALPHA32F_ARB                   0x8816
+#define GL_INTENSITY32F_ARB               0x8817
+#define GL_LUMINANCE32F_ARB               0x8818
+#define GL_LUMINANCE_ALPHA32F_ARB         0x8819
+#define GL_RGBA16F_ARB                    0x881A
+#define GL_RGB16F_ARB                     0x881B
+#define GL_ALPHA16F_ARB                   0x881C
+#define GL_INTENSITY16F_ARB               0x881D
+#define GL_LUMINANCE16F_ARB               0x881E
+#define GL_LUMINANCE_ALPHA16F_ARB         0x881F
+#endif
+
+#ifndef GL_ARB_pixel_buffer_object
+#define GL_PIXEL_PACK_BUFFER_ARB          0x88EB
+#define GL_PIXEL_UNPACK_BUFFER_ARB        0x88EC
+#define GL_PIXEL_PACK_BUFFER_BINDING_ARB  0x88ED
+#define GL_PIXEL_UNPACK_BUFFER_BINDING_ARB 0x88EF
+#endif
+
+#ifndef GL_ARB_depth_buffer_float
+#define GL_DEPTH_COMPONENT32F             0x8CAC
+#define GL_DEPTH32F_STENCIL8              0x8CAD
+#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD
+#endif
+
+#ifndef GL_ARB_draw_instanced
+#endif
+
+#ifndef GL_ARB_framebuffer_object
+#define GL_INVALID_FRAMEBUFFER_OPERATION  0x0506
+#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210
+#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211
+#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212
+#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213
+#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214
+#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215
+#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216
+#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217
+#define GL_FRAMEBUFFER_DEFAULT            0x8218
+#define GL_FRAMEBUFFER_UNDEFINED          0x8219
+#define GL_DEPTH_STENCIL_ATTACHMENT       0x821A
+#define GL_MAX_RENDERBUFFER_SIZE          0x84E8
+#define GL_DEPTH_STENCIL                  0x84F9
+#define GL_UNSIGNED_INT_24_8              0x84FA
+#define GL_DEPTH24_STENCIL8               0x88F0
+#define GL_TEXTURE_STENCIL_SIZE           0x88F1
+#define GL_TEXTURE_RED_TYPE               0x8C10
+#define GL_TEXTURE_GREEN_TYPE             0x8C11
+#define GL_TEXTURE_BLUE_TYPE              0x8C12
+#define GL_TEXTURE_ALPHA_TYPE             0x8C13
+#define GL_TEXTURE_DEPTH_TYPE             0x8C16
+#define GL_UNSIGNED_NORMALIZED            0x8C17
+#define GL_FRAMEBUFFER_BINDING            0x8CA6
+#define GL_DRAW_FRAMEBUFFER_BINDING       GL_FRAMEBUFFER_BINDING
+#define GL_RENDERBUFFER_BINDING           0x8CA7
+#define GL_READ_FRAMEBUFFER               0x8CA8
+#define GL_DRAW_FRAMEBUFFER               0x8CA9
+#define GL_READ_FRAMEBUFFER_BINDING       0x8CAA
+#define GL_RENDERBUFFER_SAMPLES           0x8CAB
+#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0
+#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4
+#define GL_FRAMEBUFFER_COMPLETE           0x8CD5
+#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6
+#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7
+#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB
+#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC
+#define GL_FRAMEBUFFER_UNSUPPORTED        0x8CDD
+#define GL_MAX_COLOR_ATTACHMENTS          0x8CDF
+#define GL_COLOR_ATTACHMENT0              0x8CE0
+#define GL_COLOR_ATTACHMENT1              0x8CE1
+#define GL_COLOR_ATTACHMENT2              0x8CE2
+#define GL_COLOR_ATTACHMENT3              0x8CE3
+#define GL_COLOR_ATTACHMENT4              0x8CE4
+#define GL_COLOR_ATTACHMENT5              0x8CE5
+#define GL_COLOR_ATTACHMENT6              0x8CE6
+#define GL_COLOR_ATTACHMENT7              0x8CE7
+#define GL_COLOR_ATTACHMENT8              0x8CE8
+#define GL_COLOR_ATTACHMENT9              0x8CE9
+#define GL_COLOR_ATTACHMENT10             0x8CEA
+#define GL_COLOR_ATTACHMENT11             0x8CEB
+#define GL_COLOR_ATTACHMENT12             0x8CEC
+#define GL_COLOR_ATTACHMENT13             0x8CED
+#define GL_COLOR_ATTACHMENT14             0x8CEE
+#define GL_COLOR_ATTACHMENT15             0x8CEF
+#define GL_DEPTH_ATTACHMENT               0x8D00
+#define GL_STENCIL_ATTACHMENT             0x8D20
+#define GL_FRAMEBUFFER                    0x8D40
+#define GL_RENDERBUFFER                   0x8D41
+#define GL_RENDERBUFFER_WIDTH             0x8D42
+#define GL_RENDERBUFFER_HEIGHT            0x8D43
+#define GL_RENDERBUFFER_INTERNAL_FORMAT   0x8D44
+#define GL_STENCIL_INDEX1                 0x8D46
+#define GL_STENCIL_INDEX4                 0x8D47
+#define GL_STENCIL_INDEX8                 0x8D48
+#define GL_STENCIL_INDEX16                0x8D49
+#define GL_RENDERBUFFER_RED_SIZE          0x8D50
+#define GL_RENDERBUFFER_GREEN_SIZE        0x8D51
+#define GL_RENDERBUFFER_BLUE_SIZE         0x8D52
+#define GL_RENDERBUFFER_ALPHA_SIZE        0x8D53
+#define GL_RENDERBUFFER_DEPTH_SIZE        0x8D54
+#define GL_RENDERBUFFER_STENCIL_SIZE      0x8D55
+#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56
+#define GL_MAX_SAMPLES                    0x8D57
+#endif
+
+#ifndef GL_ARB_framebuffer_object_DEPRECATED
+#define GL_INDEX                          0x8222
+#define GL_TEXTURE_LUMINANCE_TYPE         0x8C14
+#define GL_TEXTURE_INTENSITY_TYPE         0x8C15
+#endif
+
+#ifndef GL_ARB_framebuffer_sRGB
+#define GL_FRAMEBUFFER_SRGB               0x8DB9
+#endif
+
+#ifndef GL_ARB_geometry_shader4
+#define GL_LINES_ADJACENCY_ARB            0x000A
+#define GL_LINE_STRIP_ADJACENCY_ARB       0x000B
+#define GL_TRIANGLES_ADJACENCY_ARB        0x000C
+#define GL_TRIANGLE_STRIP_ADJACENCY_ARB   0x000D
+#define GL_PROGRAM_POINT_SIZE_ARB         0x8642
+#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB 0x8C29
+#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB 0x8DA7
+#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB 0x8DA8
+#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB 0x8DA9
+#define GL_GEOMETRY_SHADER_ARB            0x8DD9
+#define GL_GEOMETRY_VERTICES_OUT_ARB      0x8DDA
+#define GL_GEOMETRY_INPUT_TYPE_ARB        0x8DDB
+#define GL_GEOMETRY_OUTPUT_TYPE_ARB       0x8DDC
+#define GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB 0x8DDD
+#define GL_MAX_VERTEX_VARYING_COMPONENTS_ARB 0x8DDE
+#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB 0x8DDF
+#define GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB 0x8DE0
+#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB 0x8DE1
+/* reuse GL_MAX_VARYING_COMPONENTS */
+/* reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER */
+#endif
+
+#ifndef GL_ARB_half_float_vertex
+#define GL_HALF_FLOAT                     0x140B
+#endif
+
+#ifndef GL_ARB_instanced_arrays
+#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB 0x88FE
+#endif
+
+#ifndef GL_ARB_map_buffer_range
+#define GL_MAP_READ_BIT                   0x0001
+#define GL_MAP_WRITE_BIT                  0x0002
+#define GL_MAP_INVALIDATE_RANGE_BIT       0x0004
+#define GL_MAP_INVALIDATE_BUFFER_BIT      0x0008
+#define GL_MAP_FLUSH_EXPLICIT_BIT         0x0010
+#define GL_MAP_UNSYNCHRONIZED_BIT         0x0020
+#endif
+
+#ifndef GL_ARB_texture_buffer_object
+#define GL_TEXTURE_BUFFER_ARB             0x8C2A
+#define GL_MAX_TEXTURE_BUFFER_SIZE_ARB    0x8C2B
+#define GL_TEXTURE_BINDING_BUFFER_ARB     0x8C2C
+#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB 0x8C2D
+#define GL_TEXTURE_BUFFER_FORMAT_ARB      0x8C2E
+#endif
+
+#ifndef GL_ARB_texture_compression_rgtc
+#define GL_COMPRESSED_RED_RGTC1           0x8DBB
+#define GL_COMPRESSED_SIGNED_RED_RGTC1    0x8DBC
+#define GL_COMPRESSED_RG_RGTC2            0x8DBD
+#define GL_COMPRESSED_SIGNED_RG_RGTC2     0x8DBE
+#endif
+
+#ifndef GL_ARB_texture_rg
+#define GL_RG                             0x8227
+#define GL_RG_INTEGER                     0x8228
+#define GL_R8                             0x8229
+#define GL_R16                            0x822A
+#define GL_RG8                            0x822B
+#define GL_RG16                           0x822C
+#define GL_R16F                           0x822D
+#define GL_R32F                           0x822E
+#define GL_RG16F                          0x822F
+#define GL_RG32F                          0x8230
+#define GL_R8I                            0x8231
+#define GL_R8UI                           0x8232
+#define GL_R16I                           0x8233
+#define GL_R16UI                          0x8234
+#define GL_R32I                           0x8235
+#define GL_R32UI                          0x8236
+#define GL_RG8I                           0x8237
+#define GL_RG8UI                          0x8238
+#define GL_RG16I                          0x8239
+#define GL_RG16UI                         0x823A
+#define GL_RG32I                          0x823B
+#define GL_RG32UI                         0x823C
+#endif
+
+#ifndef GL_ARB_vertex_array_object
+#define GL_VERTEX_ARRAY_BINDING           0x85B5
+#endif
+
+#ifndef GL_ARB_uniform_buffer_object
+#define GL_UNIFORM_BUFFER                 0x8A11
+#define GL_UNIFORM_BUFFER_BINDING         0x8A28
+#define GL_UNIFORM_BUFFER_START           0x8A29
+#define GL_UNIFORM_BUFFER_SIZE            0x8A2A
+#define GL_MAX_VERTEX_UNIFORM_BLOCKS      0x8A2B
+#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS    0x8A2C
+#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS    0x8A2D
+#define GL_MAX_COMBINED_UNIFORM_BLOCKS    0x8A2E
+#define GL_MAX_UNIFORM_BUFFER_BINDINGS    0x8A2F
+#define GL_MAX_UNIFORM_BLOCK_SIZE         0x8A30
+#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31
+#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32
+#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33
+#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34
+#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35
+#define GL_ACTIVE_UNIFORM_BLOCKS          0x8A36
+#define GL_UNIFORM_TYPE                   0x8A37
+#define GL_UNIFORM_SIZE                   0x8A38
+#define GL_UNIFORM_NAME_LENGTH            0x8A39
+#define GL_UNIFORM_BLOCK_INDEX            0x8A3A
+#define GL_UNIFORM_OFFSET                 0x8A3B
+#define GL_UNIFORM_ARRAY_STRIDE           0x8A3C
+#define GL_UNIFORM_MATRIX_STRIDE          0x8A3D
+#define GL_UNIFORM_IS_ROW_MAJOR           0x8A3E
+#define GL_UNIFORM_BLOCK_BINDING          0x8A3F
+#define GL_UNIFORM_BLOCK_DATA_SIZE        0x8A40
+#define GL_UNIFORM_BLOCK_NAME_LENGTH      0x8A41
+#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS  0x8A42
+#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER 0x8A45
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46
+#define GL_INVALID_INDEX                  0xFFFFFFFFu
+#endif
+
+#ifndef GL_ARB_compatibility
+/* ARB_compatibility just defines tokens from core 3.0 */
+#endif
+
+#ifndef GL_ARB_copy_buffer
+#define GL_COPY_READ_BUFFER               0x8F36
+#define GL_COPY_WRITE_BUFFER              0x8F37
+#endif
+
+#ifndef GL_ARB_shader_texture_lod
+#endif
+
+#ifndef GL_ARB_depth_clamp
+#define GL_DEPTH_CLAMP                    0x864F
+#endif
+
+#ifndef GL_ARB_draw_elements_base_vertex
+#endif
+
+#ifndef GL_ARB_fragment_coord_conventions
+#endif
+
+#ifndef GL_ARB_provoking_vertex
+#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION 0x8E4C
+#define GL_FIRST_VERTEX_CONVENTION        0x8E4D
+#define GL_LAST_VERTEX_CONVENTION         0x8E4E
+#define GL_PROVOKING_VERTEX               0x8E4F
+#endif
+
+#ifndef GL_ARB_seamless_cube_map
+#define GL_TEXTURE_CUBE_MAP_SEAMLESS      0x884F
+#endif
+
+#ifndef GL_ARB_sync
+#define GL_MAX_SERVER_WAIT_TIMEOUT        0x9111
+#define GL_OBJECT_TYPE                    0x9112
+#define GL_SYNC_CONDITION                 0x9113
+#define GL_SYNC_STATUS                    0x9114
+#define GL_SYNC_FLAGS                     0x9115
+#define GL_SYNC_FENCE                     0x9116
+#define GL_SYNC_GPU_COMMANDS_COMPLETE     0x9117
+#define GL_UNSIGNALED                     0x9118
+#define GL_SIGNALED                       0x9119
+#define GL_ALREADY_SIGNALED               0x911A
+#define GL_TIMEOUT_EXPIRED                0x911B
+#define GL_CONDITION_SATISFIED            0x911C
+#define GL_WAIT_FAILED                    0x911D
+#define GL_SYNC_FLUSH_COMMANDS_BIT        0x00000001
+#define GL_TIMEOUT_IGNORED                0xFFFFFFFFFFFFFFFFull
+#endif
+
+#ifndef GL_ARB_texture_multisample
+#define GL_SAMPLE_POSITION                0x8E50
+#define GL_SAMPLE_MASK                    0x8E51
+#define GL_SAMPLE_MASK_VALUE              0x8E52
+#define GL_MAX_SAMPLE_MASK_WORDS          0x8E59
+#define GL_TEXTURE_2D_MULTISAMPLE         0x9100
+#define GL_PROXY_TEXTURE_2D_MULTISAMPLE   0x9101
+#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY   0x9102
+#define GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9103
+#define GL_TEXTURE_BINDING_2D_MULTISAMPLE 0x9104
+#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105
+#define GL_TEXTURE_SAMPLES                0x9106
+#define GL_TEXTURE_FIXED_SAMPLE_LOCATIONS 0x9107
+#define GL_SAMPLER_2D_MULTISAMPLE         0x9108
+#define GL_INT_SAMPLER_2D_MULTISAMPLE     0x9109
+#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE 0x910A
+#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY   0x910B
+#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C
+#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D
+#define GL_MAX_COLOR_TEXTURE_SAMPLES      0x910E
+#define GL_MAX_DEPTH_TEXTURE_SAMPLES      0x910F
+#define GL_MAX_INTEGER_SAMPLES            0x9110
+#endif
+
+#ifndef GL_ARB_vertex_array_bgra
+/* reuse GL_BGRA */
+#endif
+
+#ifndef GL_ARB_draw_buffers_blend
+#endif
+
+#ifndef GL_ARB_sample_shading
+#define GL_SAMPLE_SHADING_ARB             0x8C36
+#define GL_MIN_SAMPLE_SHADING_VALUE_ARB   0x8C37
+#endif
+
+#ifndef GL_ARB_texture_cube_map_array
+#define GL_TEXTURE_CUBE_MAP_ARRAY_ARB     0x9009
+#define GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB 0x900A
+#define GL_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB 0x900B
+#define GL_SAMPLER_CUBE_MAP_ARRAY_ARB     0x900C
+#define GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB 0x900D
+#define GL_INT_SAMPLER_CUBE_MAP_ARRAY_ARB 0x900E
+#define GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB 0x900F
+#endif
+
+#ifndef GL_ARB_texture_gather
+#define GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB 0x8E5E
+#define GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB 0x8E5F
+#endif
+
+#ifndef GL_ARB_texture_query_lod
+#endif
+
+#ifndef GL_ARB_shading_language_include
+#define GL_SHADER_INCLUDE_ARB             0x8DAE
+#define GL_NAMED_STRING_LENGTH_ARB        0x8DE9
+#define GL_NAMED_STRING_TYPE_ARB          0x8DEA
+#endif
+
+#ifndef GL_ARB_texture_compression_bptc
+#define GL_COMPRESSED_RGBA_BPTC_UNORM_ARB 0x8E8C
+#define GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB 0x8E8D
+#define GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB 0x8E8E
+#define GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB 0x8E8F
+#endif
+
+#ifndef GL_ARB_blend_func_extended
+#define GL_SRC1_COLOR                     0x88F9
+/* reuse GL_SRC1_ALPHA */
+#define GL_ONE_MINUS_SRC1_COLOR           0x88FA
+#define GL_ONE_MINUS_SRC1_ALPHA           0x88FB
+#define GL_MAX_DUAL_SOURCE_DRAW_BUFFERS   0x88FC
+#endif
+
+#ifndef GL_ARB_explicit_attrib_location
+#endif
+
+#ifndef GL_ARB_occlusion_query2
+#define GL_ANY_SAMPLES_PASSED             0x8C2F
+#endif
+
+#ifndef GL_ARB_sampler_objects
+#define GL_SAMPLER_BINDING                0x8919
+#endif
+
+#ifndef GL_ARB_shader_bit_encoding
+#endif
+
+#ifndef GL_ARB_texture_rgb10_a2ui
+#define GL_RGB10_A2UI                     0x906F
+#endif
+
+#ifndef GL_ARB_texture_swizzle
+#define GL_TEXTURE_SWIZZLE_R              0x8E42
+#define GL_TEXTURE_SWIZZLE_G              0x8E43
+#define GL_TEXTURE_SWIZZLE_B              0x8E44
+#define GL_TEXTURE_SWIZZLE_A              0x8E45
+#define GL_TEXTURE_SWIZZLE_RGBA           0x8E46
+#endif
+
+#ifndef GL_ARB_timer_query
+#define GL_TIME_ELAPSED                   0x88BF
+#define GL_TIMESTAMP                      0x8E28
+#endif
+
+#ifndef GL_ARB_vertex_type_2_10_10_10_rev
+/* reuse GL_UNSIGNED_INT_2_10_10_10_REV */
+#define GL_INT_2_10_10_10_REV             0x8D9F
+#endif
+
+#ifndef GL_ARB_draw_indirect
+#define GL_DRAW_INDIRECT_BUFFER           0x8F3F
+#define GL_DRAW_INDIRECT_BUFFER_BINDING   0x8F43
+#endif
+
+#ifndef GL_ARB_gpu_shader5
+#define GL_GEOMETRY_SHADER_INVOCATIONS    0x887F
+#define GL_MAX_GEOMETRY_SHADER_INVOCATIONS 0x8E5A
+#define GL_MIN_FRAGMENT_INTERPOLATION_OFFSET 0x8E5B
+#define GL_MAX_FRAGMENT_INTERPOLATION_OFFSET 0x8E5C
+#define GL_FRAGMENT_INTERPOLATION_OFFSET_BITS 0x8E5D
+/* reuse GL_MAX_VERTEX_STREAMS */
+#endif
+
+#ifndef GL_ARB_gpu_shader_fp64
+/* reuse GL_DOUBLE */
+#define GL_DOUBLE_VEC2                    0x8FFC
+#define GL_DOUBLE_VEC3                    0x8FFD
+#define GL_DOUBLE_VEC4                    0x8FFE
+#define GL_DOUBLE_MAT2                    0x8F46
+#define GL_DOUBLE_MAT3                    0x8F47
+#define GL_DOUBLE_MAT4                    0x8F48
+#define GL_DOUBLE_MAT2x3                  0x8F49
+#define GL_DOUBLE_MAT2x4                  0x8F4A
+#define GL_DOUBLE_MAT3x2                  0x8F4B
+#define GL_DOUBLE_MAT3x4                  0x8F4C
+#define GL_DOUBLE_MAT4x2                  0x8F4D
+#define GL_DOUBLE_MAT4x3                  0x8F4E
+#endif
+
+#ifndef GL_ARB_shader_subroutine
+#define GL_ACTIVE_SUBROUTINES             0x8DE5
+#define GL_ACTIVE_SUBROUTINE_UNIFORMS     0x8DE6
+#define GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS 0x8E47
+#define GL_ACTIVE_SUBROUTINE_MAX_LENGTH   0x8E48
+#define GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH 0x8E49
+#define GL_MAX_SUBROUTINES                0x8DE7
+#define GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS 0x8DE8
+#define GL_NUM_COMPATIBLE_SUBROUTINES     0x8E4A
+#define GL_COMPATIBLE_SUBROUTINES         0x8E4B
+/* reuse GL_UNIFORM_SIZE */
+/* reuse GL_UNIFORM_NAME_LENGTH */
+#endif
+
+#ifndef GL_ARB_tessellation_shader
+#define GL_PATCHES                        0x000E
+#define GL_PATCH_VERTICES                 0x8E72
+#define GL_PATCH_DEFAULT_INNER_LEVEL      0x8E73
+#define GL_PATCH_DEFAULT_OUTER_LEVEL      0x8E74
+#define GL_TESS_CONTROL_OUTPUT_VERTICES   0x8E75
+#define GL_TESS_GEN_MODE                  0x8E76
+#define GL_TESS_GEN_SPACING               0x8E77
+#define GL_TESS_GEN_VERTEX_ORDER          0x8E78
+#define GL_TESS_GEN_POINT_MODE            0x8E79
+/* reuse GL_TRIANGLES */
+/* reuse GL_QUADS */
+#define GL_ISOLINES                       0x8E7A
+/* reuse GL_EQUAL */
+#define GL_FRACTIONAL_ODD                 0x8E7B
+#define GL_FRACTIONAL_EVEN                0x8E7C
+/* reuse GL_CCW */
+/* reuse GL_CW */
+#define GL_MAX_PATCH_VERTICES             0x8E7D
+#define GL_MAX_TESS_GEN_LEVEL             0x8E7E
+#define GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS 0x8E7F
+#define GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS 0x8E80
+#define GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS 0x8E81
+#define GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS 0x8E82
+#define GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS 0x8E83
+#define GL_MAX_TESS_PATCH_COMPONENTS      0x8E84
+#define GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS 0x8E85
+#define GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS 0x8E86
+#define GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS 0x8E89
+#define GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS 0x8E8A
+#define GL_MAX_TESS_CONTROL_INPUT_COMPONENTS 0x886C
+#define GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS 0x886D
+#define GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS 0x8E1E
+#define GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS 0x8E1F
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER 0x84F0
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER 0x84F1
+#define GL_TESS_EVALUATION_SHADER         0x8E87
+#define GL_TESS_CONTROL_SHADER            0x8E88
+#endif
+
+#ifndef GL_ARB_texture_buffer_object_rgb32
+/* reuse GL_RGB32F */
+/* reuse GL_RGB32UI */
+/* reuse GL_RGB32I */
+#endif
+
+#ifndef GL_ARB_transform_feedback2
+#define GL_TRANSFORM_FEEDBACK             0x8E22
+#define GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED 0x8E23
+#define GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE 0x8E24
+#define GL_TRANSFORM_FEEDBACK_BINDING     0x8E25
+#endif
+
+#ifndef GL_ARB_transform_feedback3
+#define GL_MAX_TRANSFORM_FEEDBACK_BUFFERS 0x8E70
+#define GL_MAX_VERTEX_STREAMS             0x8E71
+#endif
+
+#ifndef GL_ARB_ES2_compatibility
+#define GL_FIXED                          0x140C
+#define GL_IMPLEMENTATION_COLOR_READ_TYPE 0x8B9A
+#define GL_IMPLEMENTATION_COLOR_READ_FORMAT 0x8B9B
+#define GL_LOW_FLOAT                      0x8DF0
+#define GL_MEDIUM_FLOAT                   0x8DF1
+#define GL_HIGH_FLOAT                     0x8DF2
+#define GL_LOW_INT                        0x8DF3
+#define GL_MEDIUM_INT                     0x8DF4
+#define GL_HIGH_INT                       0x8DF5
+#define GL_SHADER_COMPILER                0x8DFA
+#define GL_NUM_SHADER_BINARY_FORMATS      0x8DF9
+#define GL_MAX_VERTEX_UNIFORM_VECTORS     0x8DFB
+#define GL_MAX_VARYING_VECTORS            0x8DFC
+#define GL_MAX_FRAGMENT_UNIFORM_VECTORS   0x8DFD
+#endif
+
+#ifndef GL_ARB_get_program_binary
+#define GL_PROGRAM_BINARY_RETRIEVABLE_HINT 0x8257
+#define GL_PROGRAM_BINARY_LENGTH          0x8741
+#define GL_NUM_PROGRAM_BINARY_FORMATS     0x87FE
+#define GL_PROGRAM_BINARY_FORMATS         0x87FF
+#endif
+
+#ifndef GL_ARB_separate_shader_objects
+#define GL_VERTEX_SHADER_BIT              0x00000001
+#define GL_FRAGMENT_SHADER_BIT            0x00000002
+#define GL_GEOMETRY_SHADER_BIT            0x00000004
+#define GL_TESS_CONTROL_SHADER_BIT        0x00000008
+#define GL_TESS_EVALUATION_SHADER_BIT     0x00000010
+#define GL_ALL_SHADER_BITS                0xFFFFFFFF
+#define GL_PROGRAM_SEPARABLE              0x8258
+#define GL_ACTIVE_PROGRAM                 0x8259
+#define GL_PROGRAM_PIPELINE_BINDING       0x825A
+#endif
+
+#ifndef GL_ARB_shader_precision
+#endif
+
+#ifndef GL_ARB_vertex_attrib_64bit
+/* reuse GL_RGB32I */
+/* reuse GL_DOUBLE_VEC2 */
+/* reuse GL_DOUBLE_VEC3 */
+/* reuse GL_DOUBLE_VEC4 */
+/* reuse GL_DOUBLE_MAT2 */
+/* reuse GL_DOUBLE_MAT3 */
+/* reuse GL_DOUBLE_MAT4 */
+/* reuse GL_DOUBLE_MAT2x3 */
+/* reuse GL_DOUBLE_MAT2x4 */
+/* reuse GL_DOUBLE_MAT3x2 */
+/* reuse GL_DOUBLE_MAT3x4 */
+/* reuse GL_DOUBLE_MAT4x2 */
+/* reuse GL_DOUBLE_MAT4x3 */
+#endif
+
+#ifndef GL_ARB_viewport_array
+/* reuse GL_SCISSOR_BOX */
+/* reuse GL_VIEWPORT */
+/* reuse GL_DEPTH_RANGE */
+/* reuse GL_SCISSOR_TEST */
+#define GL_MAX_VIEWPORTS                  0x825B
+#define GL_VIEWPORT_SUBPIXEL_BITS         0x825C
+#define GL_VIEWPORT_BOUNDS_RANGE          0x825D
+#define GL_LAYER_PROVOKING_VERTEX         0x825E
+#define GL_VIEWPORT_INDEX_PROVOKING_VERTEX 0x825F
+#define GL_UNDEFINED_VERTEX               0x8260
+/* reuse GL_FIRST_VERTEX_CONVENTION */
+/* reuse GL_LAST_VERTEX_CONVENTION */
+/* reuse GL_PROVOKING_VERTEX */
+#endif
+
+#ifndef GL_ARB_cl_event
+#define GL_SYNC_CL_EVENT_ARB              0x8240
+#define GL_SYNC_CL_EVENT_COMPLETE_ARB     0x8241
+#endif
+
+#ifndef GL_ARB_debug_output
+#define GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB   0x8242
+#define GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB 0x8243
+#define GL_DEBUG_CALLBACK_FUNCTION_ARB    0x8244
+#define GL_DEBUG_CALLBACK_USER_PARAM_ARB  0x8245
+#define GL_DEBUG_SOURCE_API_ARB           0x8246
+#define GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB 0x8247
+#define GL_DEBUG_SOURCE_SHADER_COMPILER_ARB 0x8248
+#define GL_DEBUG_SOURCE_THIRD_PARTY_ARB   0x8249
+#define GL_DEBUG_SOURCE_APPLICATION_ARB   0x824A
+#define GL_DEBUG_SOURCE_OTHER_ARB         0x824B
+#define GL_DEBUG_TYPE_ERROR_ARB           0x824C
+#define GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB 0x824D
+#define GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB 0x824E
+#define GL_DEBUG_TYPE_PORTABILITY_ARB     0x824F
+#define GL_DEBUG_TYPE_PERFORMANCE_ARB     0x8250
+#define GL_DEBUG_TYPE_OTHER_ARB           0x8251
+#define GL_MAX_DEBUG_MESSAGE_LENGTH_ARB   0x9143
+#define GL_MAX_DEBUG_LOGGED_MESSAGES_ARB  0x9144
+#define GL_DEBUG_LOGGED_MESSAGES_ARB      0x9145
+#define GL_DEBUG_SEVERITY_HIGH_ARB        0x9146
+#define GL_DEBUG_SEVERITY_MEDIUM_ARB      0x9147
+#define GL_DEBUG_SEVERITY_LOW_ARB         0x9148
+#endif
+
+#ifndef GL_ARB_robustness
+/* reuse GL_NO_ERROR */
+#define GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB 0x00000004
+#define GL_LOSE_CONTEXT_ON_RESET_ARB      0x8252
+#define GL_GUILTY_CONTEXT_RESET_ARB       0x8253
+#define GL_INNOCENT_CONTEXT_RESET_ARB     0x8254
+#define GL_UNKNOWN_CONTEXT_RESET_ARB      0x8255
+#define GL_RESET_NOTIFICATION_STRATEGY_ARB 0x8256
+#define GL_NO_RESET_NOTIFICATION_ARB      0x8261
+#endif
+
+#ifndef GL_ARB_shader_stencil_export
+#endif
+
+#ifndef GL_EXT_abgr
+#define GL_ABGR_EXT                       0x8000
+#endif
+
+#ifndef GL_EXT_blend_color
+#define GL_CONSTANT_COLOR_EXT             0x8001
+#define GL_ONE_MINUS_CONSTANT_COLOR_EXT   0x8002
+#define GL_CONSTANT_ALPHA_EXT             0x8003
+#define GL_ONE_MINUS_CONSTANT_ALPHA_EXT   0x8004
+#define GL_BLEND_COLOR_EXT                0x8005
+#endif
+
+#ifndef GL_EXT_polygon_offset
+#define GL_POLYGON_OFFSET_EXT             0x8037
+#define GL_POLYGON_OFFSET_FACTOR_EXT      0x8038
+#define GL_POLYGON_OFFSET_BIAS_EXT        0x8039
+#endif
+
+#ifndef GL_EXT_texture
+#define GL_ALPHA4_EXT                     0x803B
+#define GL_ALPHA8_EXT                     0x803C
+#define GL_ALPHA12_EXT                    0x803D
+#define GL_ALPHA16_EXT                    0x803E
+#define GL_LUMINANCE4_EXT                 0x803F
+#define GL_LUMINANCE8_EXT                 0x8040
+#define GL_LUMINANCE12_EXT                0x8041
+#define GL_LUMINANCE16_EXT                0x8042
+#define GL_LUMINANCE4_ALPHA4_EXT          0x8043
+#define GL_LUMINANCE6_ALPHA2_EXT          0x8044
+#define GL_LUMINANCE8_ALPHA8_EXT          0x8045
+#define GL_LUMINANCE12_ALPHA4_EXT         0x8046
+#define GL_LUMINANCE12_ALPHA12_EXT        0x8047
+#define GL_LUMINANCE16_ALPHA16_EXT        0x8048
+#define GL_INTENSITY_EXT                  0x8049
+#define GL_INTENSITY4_EXT                 0x804A
+#define GL_INTENSITY8_EXT                 0x804B
+#define GL_INTENSITY12_EXT                0x804C
+#define GL_INTENSITY16_EXT                0x804D
+#define GL_RGB2_EXT                       0x804E
+#define GL_RGB4_EXT                       0x804F
+#define GL_RGB5_EXT                       0x8050
+#define GL_RGB8_EXT                       0x8051
+#define GL_RGB10_EXT                      0x8052
+#define GL_RGB12_EXT                      0x8053
+#define GL_RGB16_EXT                      0x8054
+#define GL_RGBA2_EXT                      0x8055
+#define GL_RGBA4_EXT                      0x8056
+#define GL_RGB5_A1_EXT                    0x8057
+#define GL_RGBA8_EXT                      0x8058
+#define GL_RGB10_A2_EXT                   0x8059
+#define GL_RGBA12_EXT                     0x805A
+#define GL_RGBA16_EXT                     0x805B
+#define GL_TEXTURE_RED_SIZE_EXT           0x805C
+#define GL_TEXTURE_GREEN_SIZE_EXT         0x805D
+#define GL_TEXTURE_BLUE_SIZE_EXT          0x805E
+#define GL_TEXTURE_ALPHA_SIZE_EXT         0x805F
+#define GL_TEXTURE_LUMINANCE_SIZE_EXT     0x8060
+#define GL_TEXTURE_INTENSITY_SIZE_EXT     0x8061
+#define GL_REPLACE_EXT                    0x8062
+#define GL_PROXY_TEXTURE_1D_EXT           0x8063
+#define GL_PROXY_TEXTURE_2D_EXT           0x8064
+#define GL_TEXTURE_TOO_LARGE_EXT          0x8065
+#endif
+
+#ifndef GL_EXT_texture3D
+#define GL_PACK_SKIP_IMAGES_EXT           0x806B
+#define GL_PACK_IMAGE_HEIGHT_EXT          0x806C
+#define GL_UNPACK_SKIP_IMAGES_EXT         0x806D
+#define GL_UNPACK_IMAGE_HEIGHT_EXT        0x806E
+#define GL_TEXTURE_3D_EXT                 0x806F
+#define GL_PROXY_TEXTURE_3D_EXT           0x8070
+#define GL_TEXTURE_DEPTH_EXT              0x8071
+#define GL_TEXTURE_WRAP_R_EXT             0x8072
+#define GL_MAX_3D_TEXTURE_SIZE_EXT        0x8073
+#endif
+
+#ifndef GL_SGIS_texture_filter4
+#define GL_FILTER4_SGIS                   0x8146
+#define GL_TEXTURE_FILTER4_SIZE_SGIS      0x8147
+#endif
+
+#ifndef GL_EXT_subtexture
+#endif
+
+#ifndef GL_EXT_copy_texture
+#endif
+
+#ifndef GL_EXT_histogram
+#define GL_HISTOGRAM_EXT                  0x8024
+#define GL_PROXY_HISTOGRAM_EXT            0x8025
+#define GL_HISTOGRAM_WIDTH_EXT            0x8026
+#define GL_HISTOGRAM_FORMAT_EXT           0x8027
+#define GL_HISTOGRAM_RED_SIZE_EXT         0x8028
+#define GL_HISTOGRAM_GREEN_SIZE_EXT       0x8029
+#define GL_HISTOGRAM_BLUE_SIZE_EXT        0x802A
+#define GL_HISTOGRAM_ALPHA_SIZE_EXT       0x802B
+#define GL_HISTOGRAM_LUMINANCE_SIZE_EXT   0x802C
+#define GL_HISTOGRAM_SINK_EXT             0x802D
+#define GL_MINMAX_EXT                     0x802E
+#define GL_MINMAX_FORMAT_EXT              0x802F
+#define GL_MINMAX_SINK_EXT                0x8030
+#define GL_TABLE_TOO_LARGE_EXT            0x8031
+#endif
+
+#ifndef GL_EXT_convolution
+#define GL_CONVOLUTION_1D_EXT             0x8010
+#define GL_CONVOLUTION_2D_EXT             0x8011
+#define GL_SEPARABLE_2D_EXT               0x8012
+#define GL_CONVOLUTION_BORDER_MODE_EXT    0x8013
+#define GL_CONVOLUTION_FILTER_SCALE_EXT   0x8014
+#define GL_CONVOLUTION_FILTER_BIAS_EXT    0x8015
+#define GL_REDUCE_EXT                     0x8016
+#define GL_CONVOLUTION_FORMAT_EXT         0x8017
+#define GL_CONVOLUTION_WIDTH_EXT          0x8018
+#define GL_CONVOLUTION_HEIGHT_EXT         0x8019
+#define GL_MAX_CONVOLUTION_WIDTH_EXT      0x801A
+#define GL_MAX_CONVOLUTION_HEIGHT_EXT     0x801B
+#define GL_POST_CONVOLUTION_RED_SCALE_EXT 0x801C
+#define GL_POST_CONVOLUTION_GREEN_SCALE_EXT 0x801D
+#define GL_POST_CONVOLUTION_BLUE_SCALE_EXT 0x801E
+#define GL_POST_CONVOLUTION_ALPHA_SCALE_EXT 0x801F
+#define GL_POST_CONVOLUTION_RED_BIAS_EXT  0x8020
+#define GL_POST_CONVOLUTION_GREEN_BIAS_EXT 0x8021
+#define GL_POST_CONVOLUTION_BLUE_BIAS_EXT 0x8022
+#define GL_POST_CONVOLUTION_ALPHA_BIAS_EXT 0x8023
+#endif
+
+#ifndef GL_SGI_color_matrix
+#define GL_COLOR_MATRIX_SGI               0x80B1
+#define GL_COLOR_MATRIX_STACK_DEPTH_SGI   0x80B2
+#define GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI 0x80B3
+#define GL_POST_COLOR_MATRIX_RED_SCALE_SGI 0x80B4
+#define GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI 0x80B5
+#define GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI 0x80B6
+#define GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI 0x80B7
+#define GL_POST_COLOR_MATRIX_RED_BIAS_SGI 0x80B8
+#define GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI 0x80B9
+#define GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI 0x80BA
+#define GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI 0x80BB
+#endif
+
+#ifndef GL_SGI_color_table
+#define GL_COLOR_TABLE_SGI                0x80D0
+#define GL_POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D1
+#define GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D2
+#define GL_PROXY_COLOR_TABLE_SGI          0x80D3
+#define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D4
+#define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D5
+#define GL_COLOR_TABLE_SCALE_SGI          0x80D6
+#define GL_COLOR_TABLE_BIAS_SGI           0x80D7
+#define GL_COLOR_TABLE_FORMAT_SGI         0x80D8
+#define GL_COLOR_TABLE_WIDTH_SGI          0x80D9
+#define GL_COLOR_TABLE_RED_SIZE_SGI       0x80DA
+#define GL_COLOR_TABLE_GREEN_SIZE_SGI     0x80DB
+#define GL_COLOR_TABLE_BLUE_SIZE_SGI      0x80DC
+#define GL_COLOR_TABLE_ALPHA_SIZE_SGI     0x80DD
+#define GL_COLOR_TABLE_LUMINANCE_SIZE_SGI 0x80DE
+#define GL_COLOR_TABLE_INTENSITY_SIZE_SGI 0x80DF
+#endif
+
+#ifndef GL_SGIS_pixel_texture
+#define GL_PIXEL_TEXTURE_SGIS             0x8353
+#define GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS 0x8354
+#define GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS 0x8355
+#define GL_PIXEL_GROUP_COLOR_SGIS         0x8356
+#endif
+
+#ifndef GL_SGIX_pixel_texture
+#define GL_PIXEL_TEX_GEN_SGIX             0x8139
+#define GL_PIXEL_TEX_GEN_MODE_SGIX        0x832B
+#endif
+
+#ifndef GL_SGIS_texture4D
+#define GL_PACK_SKIP_VOLUMES_SGIS         0x8130
+#define GL_PACK_IMAGE_DEPTH_SGIS          0x8131
+#define GL_UNPACK_SKIP_VOLUMES_SGIS       0x8132
+#define GL_UNPACK_IMAGE_DEPTH_SGIS        0x8133
+#define GL_TEXTURE_4D_SGIS                0x8134
+#define GL_PROXY_TEXTURE_4D_SGIS          0x8135
+#define GL_TEXTURE_4DSIZE_SGIS            0x8136
+#define GL_TEXTURE_WRAP_Q_SGIS            0x8137
+#define GL_MAX_4D_TEXTURE_SIZE_SGIS       0x8138
+#define GL_TEXTURE_4D_BINDING_SGIS        0x814F
+#endif
+
+#ifndef GL_SGI_texture_color_table
+#define GL_TEXTURE_COLOR_TABLE_SGI        0x80BC
+#define GL_PROXY_TEXTURE_COLOR_TABLE_SGI  0x80BD
+#endif
+
+#ifndef GL_EXT_cmyka
+#define GL_CMYK_EXT                       0x800C
+#define GL_CMYKA_EXT                      0x800D
+#define GL_PACK_CMYK_HINT_EXT             0x800E
+#define GL_UNPACK_CMYK_HINT_EXT           0x800F
+#endif
+
+#ifndef GL_EXT_texture_object
+#define GL_TEXTURE_PRIORITY_EXT           0x8066
+#define GL_TEXTURE_RESIDENT_EXT           0x8067
+#define GL_TEXTURE_1D_BINDING_EXT         0x8068
+#define GL_TEXTURE_2D_BINDING_EXT         0x8069
+#define GL_TEXTURE_3D_BINDING_EXT         0x806A
+#endif
+
+#ifndef GL_SGIS_detail_texture
+#define GL_DETAIL_TEXTURE_2D_SGIS         0x8095
+#define GL_DETAIL_TEXTURE_2D_BINDING_SGIS 0x8096
+#define GL_LINEAR_DETAIL_SGIS             0x8097
+#define GL_LINEAR_DETAIL_ALPHA_SGIS       0x8098
+#define GL_LINEAR_DETAIL_COLOR_SGIS       0x8099
+#define GL_DETAIL_TEXTURE_LEVEL_SGIS      0x809A
+#define GL_DETAIL_TEXTURE_MODE_SGIS       0x809B
+#define GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS 0x809C
+#endif
+
+#ifndef GL_SGIS_sharpen_texture
+#define GL_LINEAR_SHARPEN_SGIS            0x80AD
+#define GL_LINEAR_SHARPEN_ALPHA_SGIS      0x80AE
+#define GL_LINEAR_SHARPEN_COLOR_SGIS      0x80AF
+#define GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS 0x80B0
+#endif
+
+#ifndef GL_EXT_packed_pixels
+#define GL_UNSIGNED_BYTE_3_3_2_EXT        0x8032
+#define GL_UNSIGNED_SHORT_4_4_4_4_EXT     0x8033
+#define GL_UNSIGNED_SHORT_5_5_5_1_EXT     0x8034
+#define GL_UNSIGNED_INT_8_8_8_8_EXT       0x8035
+#define GL_UNSIGNED_INT_10_10_10_2_EXT    0x8036
+#endif
+
+#ifndef GL_SGIS_texture_lod
+#define GL_TEXTURE_MIN_LOD_SGIS           0x813A
+#define GL_TEXTURE_MAX_LOD_SGIS           0x813B
+#define GL_TEXTURE_BASE_LEVEL_SGIS        0x813C
+#define GL_TEXTURE_MAX_LEVEL_SGIS         0x813D
+#endif
+
+#ifndef GL_SGIS_multisample
+#define GL_MULTISAMPLE_SGIS               0x809D
+#define GL_SAMPLE_ALPHA_TO_MASK_SGIS      0x809E
+#define GL_SAMPLE_ALPHA_TO_ONE_SGIS       0x809F
+#define GL_SAMPLE_MASK_SGIS               0x80A0
+#define GL_1PASS_SGIS                     0x80A1
+#define GL_2PASS_0_SGIS                   0x80A2
+#define GL_2PASS_1_SGIS                   0x80A3
+#define GL_4PASS_0_SGIS                   0x80A4
+#define GL_4PASS_1_SGIS                   0x80A5
+#define GL_4PASS_2_SGIS                   0x80A6
+#define GL_4PASS_3_SGIS                   0x80A7
+#define GL_SAMPLE_BUFFERS_SGIS            0x80A8
+#define GL_SAMPLES_SGIS                   0x80A9
+#define GL_SAMPLE_MASK_VALUE_SGIS         0x80AA
+#define GL_SAMPLE_MASK_INVERT_SGIS        0x80AB
+#define GL_SAMPLE_PATTERN_SGIS            0x80AC
+#endif
+
+#ifndef GL_EXT_rescale_normal
+#define GL_RESCALE_NORMAL_EXT             0x803A
+#endif
+
+#ifndef GL_EXT_vertex_array
+#define GL_VERTEX_ARRAY_EXT               0x8074
+#define GL_NORMAL_ARRAY_EXT               0x8075
+#define GL_COLOR_ARRAY_EXT                0x8076
+#define GL_INDEX_ARRAY_EXT                0x8077
+#define GL_TEXTURE_COORD_ARRAY_EXT        0x8078
+#define GL_EDGE_FLAG_ARRAY_EXT            0x8079
+#define GL_VERTEX_ARRAY_SIZE_EXT          0x807A
+#define GL_VERTEX_ARRAY_TYPE_EXT          0x807B
+#define GL_VERTEX_ARRAY_STRIDE_EXT        0x807C
+#define GL_VERTEX_ARRAY_COUNT_EXT         0x807D
+#define GL_NORMAL_ARRAY_TYPE_EXT          0x807E
+#define GL_NORMAL_ARRAY_STRIDE_EXT        0x807F
+#define GL_NORMAL_ARRAY_COUNT_EXT         0x8080
+#define GL_COLOR_ARRAY_SIZE_EXT           0x8081
+#define GL_COLOR_ARRAY_TYPE_EXT           0x8082
+#define GL_COLOR_ARRAY_STRIDE_EXT         0x8083
+#define GL_COLOR_ARRAY_COUNT_EXT          0x8084
+#define GL_INDEX_ARRAY_TYPE_EXT           0x8085
+#define GL_INDEX_ARRAY_STRIDE_EXT         0x8086
+#define GL_INDEX_ARRAY_COUNT_EXT          0x8087
+#define GL_TEXTURE_COORD_ARRAY_SIZE_EXT   0x8088
+#define GL_TEXTURE_COORD_ARRAY_TYPE_EXT   0x8089
+#define GL_TEXTURE_COORD_ARRAY_STRIDE_EXT 0x808A
+#define GL_TEXTURE_COORD_ARRAY_COUNT_EXT  0x808B
+#define GL_EDGE_FLAG_ARRAY_STRIDE_EXT     0x808C
+#define GL_EDGE_FLAG_ARRAY_COUNT_EXT      0x808D
+#define GL_VERTEX_ARRAY_POINTER_EXT       0x808E
+#define GL_NORMAL_ARRAY_POINTER_EXT       0x808F
+#define GL_COLOR_ARRAY_POINTER_EXT        0x8090
+#define GL_INDEX_ARRAY_POINTER_EXT        0x8091
+#define GL_TEXTURE_COORD_ARRAY_POINTER_EXT 0x8092
+#define GL_EDGE_FLAG_ARRAY_POINTER_EXT    0x8093
+#endif
+
+#ifndef GL_EXT_misc_attribute
+#endif
+
+#ifndef GL_SGIS_generate_mipmap
+#define GL_GENERATE_MIPMAP_SGIS           0x8191
+#define GL_GENERATE_MIPMAP_HINT_SGIS      0x8192
+#endif
+
+#ifndef GL_SGIX_clipmap
+#define GL_LINEAR_CLIPMAP_LINEAR_SGIX     0x8170
+#define GL_TEXTURE_CLIPMAP_CENTER_SGIX    0x8171
+#define GL_TEXTURE_CLIPMAP_FRAME_SGIX     0x8172
+#define GL_TEXTURE_CLIPMAP_OFFSET_SGIX    0x8173
+#define GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX 0x8174
+#define GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX 0x8175
+#define GL_TEXTURE_CLIPMAP_DEPTH_SGIX     0x8176
+#define GL_MAX_CLIPMAP_DEPTH_SGIX         0x8177
+#define GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX 0x8178
+#define GL_NEAREST_CLIPMAP_NEAREST_SGIX   0x844D
+#define GL_NEAREST_CLIPMAP_LINEAR_SGIX    0x844E
+#define GL_LINEAR_CLIPMAP_NEAREST_SGIX    0x844F
+#endif
+
+#ifndef GL_SGIX_shadow
+#define GL_TEXTURE_COMPARE_SGIX           0x819A
+#define GL_TEXTURE_COMPARE_OPERATOR_SGIX  0x819B
+#define GL_TEXTURE_LEQUAL_R_SGIX          0x819C
+#define GL_TEXTURE_GEQUAL_R_SGIX          0x819D
+#endif
+
+#ifndef GL_SGIS_texture_edge_clamp
+#define GL_CLAMP_TO_EDGE_SGIS             0x812F
+#endif
+
+#ifndef GL_SGIS_texture_border_clamp
+#define GL_CLAMP_TO_BORDER_SGIS           0x812D
+#endif
+
+#ifndef GL_EXT_blend_minmax
+#define GL_FUNC_ADD_EXT                   0x8006
+#define GL_MIN_EXT                        0x8007
+#define GL_MAX_EXT                        0x8008
+#define GL_BLEND_EQUATION_EXT             0x8009
+#endif
+
+#ifndef GL_EXT_blend_subtract
+#define GL_FUNC_SUBTRACT_EXT              0x800A
+#define GL_FUNC_REVERSE_SUBTRACT_EXT      0x800B
+#endif
+
+#ifndef GL_EXT_blend_logic_op
+#endif
+
+#ifndef GL_SGIX_interlace
+#define GL_INTERLACE_SGIX                 0x8094
+#endif
+
+#ifndef GL_SGIX_pixel_tiles
+#define GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX 0x813E
+#define GL_PIXEL_TILE_CACHE_INCREMENT_SGIX 0x813F
+#define GL_PIXEL_TILE_WIDTH_SGIX          0x8140
+#define GL_PIXEL_TILE_HEIGHT_SGIX         0x8141
+#define GL_PIXEL_TILE_GRID_WIDTH_SGIX     0x8142
+#define GL_PIXEL_TILE_GRID_HEIGHT_SGIX    0x8143
+#define GL_PIXEL_TILE_GRID_DEPTH_SGIX     0x8144
+#define GL_PIXEL_TILE_CACHE_SIZE_SGIX     0x8145
+#endif
+
+#ifndef GL_SGIS_texture_select
+#define GL_DUAL_ALPHA4_SGIS               0x8110
+#define GL_DUAL_ALPHA8_SGIS               0x8111
+#define GL_DUAL_ALPHA12_SGIS              0x8112
+#define GL_DUAL_ALPHA16_SGIS              0x8113
+#define GL_DUAL_LUMINANCE4_SGIS           0x8114
+#define GL_DUAL_LUMINANCE8_SGIS           0x8115
+#define GL_DUAL_LUMINANCE12_SGIS          0x8116
+#define GL_DUAL_LUMINANCE16_SGIS          0x8117
+#define GL_DUAL_INTENSITY4_SGIS           0x8118
+#define GL_DUAL_INTENSITY8_SGIS           0x8119
+#define GL_DUAL_INTENSITY12_SGIS          0x811A
+#define GL_DUAL_INTENSITY16_SGIS          0x811B
+#define GL_DUAL_LUMINANCE_ALPHA4_SGIS     0x811C
+#define GL_DUAL_LUMINANCE_ALPHA8_SGIS     0x811D
+#define GL_QUAD_ALPHA4_SGIS               0x811E
+#define GL_QUAD_ALPHA8_SGIS               0x811F
+#define GL_QUAD_LUMINANCE4_SGIS           0x8120
+#define GL_QUAD_LUMINANCE8_SGIS           0x8121
+#define GL_QUAD_INTENSITY4_SGIS           0x8122
+#define GL_QUAD_INTENSITY8_SGIS           0x8123
+#define GL_DUAL_TEXTURE_SELECT_SGIS       0x8124
+#define GL_QUAD_TEXTURE_SELECT_SGIS       0x8125
+#endif
+
+#ifndef GL_SGIX_sprite
+#define GL_SPRITE_SGIX                    0x8148
+#define GL_SPRITE_MODE_SGIX               0x8149
+#define GL_SPRITE_AXIS_SGIX               0x814A
+#define GL_SPRITE_TRANSLATION_SGIX        0x814B
+#define GL_SPRITE_AXIAL_SGIX              0x814C
+#define GL_SPRITE_OBJECT_ALIGNED_SGIX     0x814D
+#define GL_SPRITE_EYE_ALIGNED_SGIX        0x814E
+#endif
+
+#ifndef GL_SGIX_texture_multi_buffer
+#define GL_TEXTURE_MULTI_BUFFER_HINT_SGIX 0x812E
+#endif
+
+#ifndef GL_EXT_point_parameters
+#define GL_POINT_SIZE_MIN_EXT             0x8126
+#define GL_POINT_SIZE_MAX_EXT             0x8127
+#define GL_POINT_FADE_THRESHOLD_SIZE_EXT  0x8128
+#define GL_DISTANCE_ATTENUATION_EXT       0x8129
+#endif
+
+#ifndef GL_SGIS_point_parameters
+#define GL_POINT_SIZE_MIN_SGIS            0x8126
+#define GL_POINT_SIZE_MAX_SGIS            0x8127
+#define GL_POINT_FADE_THRESHOLD_SIZE_SGIS 0x8128
+#define GL_DISTANCE_ATTENUATION_SGIS      0x8129
+#endif
+
+#ifndef GL_SGIX_instruments
+#define GL_INSTRUMENT_BUFFER_POINTER_SGIX 0x8180
+#define GL_INSTRUMENT_MEASUREMENTS_SGIX   0x8181
+#endif
+
+#ifndef GL_SGIX_texture_scale_bias
+#define GL_POST_TEXTURE_FILTER_BIAS_SGIX  0x8179
+#define GL_POST_TEXTURE_FILTER_SCALE_SGIX 0x817A
+#define GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX 0x817B
+#define GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX 0x817C
+#endif
+
+#ifndef GL_SGIX_framezoom
+#define GL_FRAMEZOOM_SGIX                 0x818B
+#define GL_FRAMEZOOM_FACTOR_SGIX          0x818C
+#define GL_MAX_FRAMEZOOM_FACTOR_SGIX      0x818D
+#endif
+
+#ifndef GL_SGIX_tag_sample_buffer
+#endif
+
+#ifndef GL_FfdMaskSGIX
+#define GL_TEXTURE_DEFORMATION_BIT_SGIX   0x00000001
+#define GL_GEOMETRY_DEFORMATION_BIT_SGIX  0x00000002
+#endif
+
+#ifndef GL_SGIX_polynomial_ffd
+#define GL_GEOMETRY_DEFORMATION_SGIX      0x8194
+#define GL_TEXTURE_DEFORMATION_SGIX       0x8195
+#define GL_DEFORMATIONS_MASK_SGIX         0x8196
+#define GL_MAX_DEFORMATION_ORDER_SGIX     0x8197
+#endif
+
+#ifndef GL_SGIX_reference_plane
+#define GL_REFERENCE_PLANE_SGIX           0x817D
+#define GL_REFERENCE_PLANE_EQUATION_SGIX  0x817E
+#endif
+
+#ifndef GL_SGIX_flush_raster
+#endif
+
+#ifndef GL_SGIX_depth_texture
+#define GL_DEPTH_COMPONENT16_SGIX         0x81A5
+#define GL_DEPTH_COMPONENT24_SGIX         0x81A6
+#define GL_DEPTH_COMPONENT32_SGIX         0x81A7
+#endif
+
+#ifndef GL_SGIS_fog_function
+#define GL_FOG_FUNC_SGIS                  0x812A
+#define GL_FOG_FUNC_POINTS_SGIS           0x812B
+#define GL_MAX_FOG_FUNC_POINTS_SGIS       0x812C
+#endif
+
+#ifndef GL_SGIX_fog_offset
+#define GL_FOG_OFFSET_SGIX                0x8198
+#define GL_FOG_OFFSET_VALUE_SGIX          0x8199
+#endif
+
+#ifndef GL_HP_image_transform
+#define GL_IMAGE_SCALE_X_HP               0x8155
+#define GL_IMAGE_SCALE_Y_HP               0x8156
+#define GL_IMAGE_TRANSLATE_X_HP           0x8157
+#define GL_IMAGE_TRANSLATE_Y_HP           0x8158
+#define GL_IMAGE_ROTATE_ANGLE_HP          0x8159
+#define GL_IMAGE_ROTATE_ORIGIN_X_HP       0x815A
+#define GL_IMAGE_ROTATE_ORIGIN_Y_HP       0x815B
+#define GL_IMAGE_MAG_FILTER_HP            0x815C
+#define GL_IMAGE_MIN_FILTER_HP            0x815D
+#define GL_IMAGE_CUBIC_WEIGHT_HP          0x815E
+#define GL_CUBIC_HP                       0x815F
+#define GL_AVERAGE_HP                     0x8160
+#define GL_IMAGE_TRANSFORM_2D_HP          0x8161
+#define GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP 0x8162
+#define GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP 0x8163
+#endif
+
+#ifndef GL_HP_convolution_border_modes
+#define GL_IGNORE_BORDER_HP               0x8150
+#define GL_CONSTANT_BORDER_HP             0x8151
+#define GL_REPLICATE_BORDER_HP            0x8153
+#define GL_CONVOLUTION_BORDER_COLOR_HP    0x8154
+#endif
+
+#ifndef GL_INGR_palette_buffer
+#endif
+
+#ifndef GL_SGIX_texture_add_env
+#define GL_TEXTURE_ENV_BIAS_SGIX          0x80BE
+#endif
+
+#ifndef GL_EXT_color_subtable
+#endif
+
+#ifndef GL_PGI_vertex_hints
+#define GL_VERTEX_DATA_HINT_PGI           0x1A22A
+#define GL_VERTEX_CONSISTENT_HINT_PGI     0x1A22B
+#define GL_MATERIAL_SIDE_HINT_PGI         0x1A22C
+#define GL_MAX_VERTEX_HINT_PGI            0x1A22D
+#define GL_COLOR3_BIT_PGI                 0x00010000
+#define GL_COLOR4_BIT_PGI                 0x00020000
+#define GL_EDGEFLAG_BIT_PGI               0x00040000
+#define GL_INDEX_BIT_PGI                  0x00080000
+#define GL_MAT_AMBIENT_BIT_PGI            0x00100000
+#define GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI 0x00200000
+#define GL_MAT_DIFFUSE_BIT_PGI            0x00400000
+#define GL_MAT_EMISSION_BIT_PGI           0x00800000
+#define GL_MAT_COLOR_INDEXES_BIT_PGI      0x01000000
+#define GL_MAT_SHININESS_BIT_PGI          0x02000000
+#define GL_MAT_SPECULAR_BIT_PGI           0x04000000
+#define GL_NORMAL_BIT_PGI                 0x08000000
+#define GL_TEXCOORD1_BIT_PGI              0x10000000
+#define GL_TEXCOORD2_BIT_PGI              0x20000000
+#define GL_TEXCOORD3_BIT_PGI              0x40000000
+#define GL_TEXCOORD4_BIT_PGI              0x80000000
+#define GL_VERTEX23_BIT_PGI               0x00000004
+#define GL_VERTEX4_BIT_PGI                0x00000008
+#endif
+
+#ifndef GL_PGI_misc_hints
+#define GL_PREFER_DOUBLEBUFFER_HINT_PGI   0x1A1F8
+#define GL_CONSERVE_MEMORY_HINT_PGI       0x1A1FD
+#define GL_RECLAIM_MEMORY_HINT_PGI        0x1A1FE
+#define GL_NATIVE_GRAPHICS_HANDLE_PGI     0x1A202
+#define GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI 0x1A203
+#define GL_NATIVE_GRAPHICS_END_HINT_PGI   0x1A204
+#define GL_ALWAYS_FAST_HINT_PGI           0x1A20C
+#define GL_ALWAYS_SOFT_HINT_PGI           0x1A20D
+#define GL_ALLOW_DRAW_OBJ_HINT_PGI        0x1A20E
+#define GL_ALLOW_DRAW_WIN_HINT_PGI        0x1A20F
+#define GL_ALLOW_DRAW_FRG_HINT_PGI        0x1A210
+#define GL_ALLOW_DRAW_MEM_HINT_PGI        0x1A211
+#define GL_STRICT_DEPTHFUNC_HINT_PGI      0x1A216
+#define GL_STRICT_LIGHTING_HINT_PGI       0x1A217
+#define GL_STRICT_SCISSOR_HINT_PGI        0x1A218
+#define GL_FULL_STIPPLE_HINT_PGI          0x1A219
+#define GL_CLIP_NEAR_HINT_PGI             0x1A220
+#define GL_CLIP_FAR_HINT_PGI              0x1A221
+#define GL_WIDE_LINE_HINT_PGI             0x1A222
+#define GL_BACK_NORMALS_HINT_PGI          0x1A223
+#endif
+
+#ifndef GL_EXT_paletted_texture
+#define GL_COLOR_INDEX1_EXT               0x80E2
+#define GL_COLOR_INDEX2_EXT               0x80E3
+#define GL_COLOR_INDEX4_EXT               0x80E4
+#define GL_COLOR_INDEX8_EXT               0x80E5
+#define GL_COLOR_INDEX12_EXT              0x80E6
+#define GL_COLOR_INDEX16_EXT              0x80E7
+#define GL_TEXTURE_INDEX_SIZE_EXT         0x80ED
+#endif
+
+#ifndef GL_EXT_clip_volume_hint
+#define GL_CLIP_VOLUME_CLIPPING_HINT_EXT  0x80F0
+#endif
+
+#ifndef GL_SGIX_list_priority
+#define GL_LIST_PRIORITY_SGIX             0x8182
+#endif
+
+#ifndef GL_SGIX_ir_instrument1
+#define GL_IR_INSTRUMENT1_SGIX            0x817F
+#endif
+
+#ifndef GL_SGIX_calligraphic_fragment
+#define GL_CALLIGRAPHIC_FRAGMENT_SGIX     0x8183
+#endif
+
+#ifndef GL_SGIX_texture_lod_bias
+#define GL_TEXTURE_LOD_BIAS_S_SGIX        0x818E
+#define GL_TEXTURE_LOD_BIAS_T_SGIX        0x818F
+#define GL_TEXTURE_LOD_BIAS_R_SGIX        0x8190
+#endif
+
+#ifndef GL_SGIX_shadow_ambient
+#define GL_SHADOW_AMBIENT_SGIX            0x80BF
+#endif
+
+#ifndef GL_EXT_index_texture
+#endif
+
+#ifndef GL_EXT_index_material
+#define GL_INDEX_MATERIAL_EXT             0x81B8
+#define GL_INDEX_MATERIAL_PARAMETER_EXT   0x81B9
+#define GL_INDEX_MATERIAL_FACE_EXT        0x81BA
+#endif
+
+#ifndef GL_EXT_index_func
+#define GL_INDEX_TEST_EXT                 0x81B5
+#define GL_INDEX_TEST_FUNC_EXT            0x81B6
+#define GL_INDEX_TEST_REF_EXT             0x81B7
+#endif
+
+#ifndef GL_EXT_index_array_formats
+#define GL_IUI_V2F_EXT                    0x81AD
+#define GL_IUI_V3F_EXT                    0x81AE
+#define GL_IUI_N3F_V2F_EXT                0x81AF
+#define GL_IUI_N3F_V3F_EXT                0x81B0
+#define GL_T2F_IUI_V2F_EXT                0x81B1
+#define GL_T2F_IUI_V3F_EXT                0x81B2
+#define GL_T2F_IUI_N3F_V2F_EXT            0x81B3
+#define GL_T2F_IUI_N3F_V3F_EXT            0x81B4
+#endif
+
+#ifndef GL_EXT_compiled_vertex_array
+#define GL_ARRAY_ELEMENT_LOCK_FIRST_EXT   0x81A8
+#define GL_ARRAY_ELEMENT_LOCK_COUNT_EXT   0x81A9
+#endif
+
+#ifndef GL_EXT_cull_vertex
+#define GL_CULL_VERTEX_EXT                0x81AA
+#define GL_CULL_VERTEX_EYE_POSITION_EXT   0x81AB
+#define GL_CULL_VERTEX_OBJECT_POSITION_EXT 0x81AC
+#endif
+
+#ifndef GL_SGIX_ycrcb
+#define GL_YCRCB_422_SGIX                 0x81BB
+#define GL_YCRCB_444_SGIX                 0x81BC
+#endif
+
+#ifndef GL_SGIX_fragment_lighting
+#define GL_FRAGMENT_LIGHTING_SGIX         0x8400
+#define GL_FRAGMENT_COLOR_MATERIAL_SGIX   0x8401
+#define GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX 0x8402
+#define GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX 0x8403
+#define GL_MAX_FRAGMENT_LIGHTS_SGIX       0x8404
+#define GL_MAX_ACTIVE_LIGHTS_SGIX         0x8405
+#define GL_CURRENT_RASTER_NORMAL_SGIX     0x8406
+#define GL_LIGHT_ENV_MODE_SGIX            0x8407
+#define GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX 0x8408
+#define GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX 0x8409
+#define GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX 0x840A
+#define GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX 0x840B
+#define GL_FRAGMENT_LIGHT0_SGIX           0x840C
+#define GL_FRAGMENT_LIGHT1_SGIX           0x840D
+#define GL_FRAGMENT_LIGHT2_SGIX           0x840E
+#define GL_FRAGMENT_LIGHT3_SGIX           0x840F
+#define GL_FRAGMENT_LIGHT4_SGIX           0x8410
+#define GL_FRAGMENT_LIGHT5_SGIX           0x8411
+#define GL_FRAGMENT_LIGHT6_SGIX           0x8412
+#define GL_FRAGMENT_LIGHT7_SGIX           0x8413
+#endif
+
+#ifndef GL_IBM_rasterpos_clip
+#define GL_RASTER_POSITION_UNCLIPPED_IBM  0x19262
+#endif
+
+#ifndef GL_HP_texture_lighting
+#define GL_TEXTURE_LIGHTING_MODE_HP       0x8167
+#define GL_TEXTURE_POST_SPECULAR_HP       0x8168
+#define GL_TEXTURE_PRE_SPECULAR_HP        0x8169
+#endif
+
+#ifndef GL_EXT_draw_range_elements
+#define GL_MAX_ELEMENTS_VERTICES_EXT      0x80E8
+#define GL_MAX_ELEMENTS_INDICES_EXT       0x80E9
+#endif
+
+#ifndef GL_WIN_phong_shading
+#define GL_PHONG_WIN                      0x80EA
+#define GL_PHONG_HINT_WIN                 0x80EB
+#endif
+
+#ifndef GL_WIN_specular_fog
+#define GL_FOG_SPECULAR_TEXTURE_WIN       0x80EC
+#endif
+
+#ifndef GL_EXT_light_texture
+#define GL_FRAGMENT_MATERIAL_EXT          0x8349
+#define GL_FRAGMENT_NORMAL_EXT            0x834A
+#define GL_FRAGMENT_COLOR_EXT             0x834C
+#define GL_ATTENUATION_EXT                0x834D
+#define GL_SHADOW_ATTENUATION_EXT         0x834E
+#define GL_TEXTURE_APPLICATION_MODE_EXT   0x834F
+#define GL_TEXTURE_LIGHT_EXT              0x8350
+#define GL_TEXTURE_MATERIAL_FACE_EXT      0x8351
+#define GL_TEXTURE_MATERIAL_PARAMETER_EXT 0x8352
+/* reuse GL_FRAGMENT_DEPTH_EXT */
+#endif
+
+#ifndef GL_SGIX_blend_alpha_minmax
+#define GL_ALPHA_MIN_SGIX                 0x8320
+#define GL_ALPHA_MAX_SGIX                 0x8321
+#endif
+
+#ifndef GL_SGIX_impact_pixel_texture
+#define GL_PIXEL_TEX_GEN_Q_CEILING_SGIX   0x8184
+#define GL_PIXEL_TEX_GEN_Q_ROUND_SGIX     0x8185
+#define GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX     0x8186
+#define GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX 0x8187
+#define GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX 0x8188
+#define GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX    0x8189
+#define GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX    0x818A
+#endif
+
+#ifndef GL_EXT_bgra
+#define GL_BGR_EXT                        0x80E0
+#define GL_BGRA_EXT                       0x80E1
+#endif
+
+#ifndef GL_SGIX_async
+#define GL_ASYNC_MARKER_SGIX              0x8329
+#endif
+
+#ifndef GL_SGIX_async_pixel
+#define GL_ASYNC_TEX_IMAGE_SGIX           0x835C
+#define GL_ASYNC_DRAW_PIXELS_SGIX         0x835D
+#define GL_ASYNC_READ_PIXELS_SGIX         0x835E
+#define GL_MAX_ASYNC_TEX_IMAGE_SGIX       0x835F
+#define GL_MAX_ASYNC_DRAW_PIXELS_SGIX     0x8360
+#define GL_MAX_ASYNC_READ_PIXELS_SGIX     0x8361
+#endif
+
+#ifndef GL_SGIX_async_histogram
+#define GL_ASYNC_HISTOGRAM_SGIX           0x832C
+#define GL_MAX_ASYNC_HISTOGRAM_SGIX       0x832D
+#endif
+
+#ifndef GL_INTEL_texture_scissor
+#endif
+
+#ifndef GL_INTEL_parallel_arrays
+#define GL_PARALLEL_ARRAYS_INTEL          0x83F4
+#define GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL 0x83F5
+#define GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL 0x83F6
+#define GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL 0x83F7
+#define GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL 0x83F8
+#endif
+
+#ifndef GL_HP_occlusion_test
+#define GL_OCCLUSION_TEST_HP              0x8165
+#define GL_OCCLUSION_TEST_RESULT_HP       0x8166
+#endif
+
+#ifndef GL_EXT_pixel_transform
+#define GL_PIXEL_TRANSFORM_2D_EXT         0x8330
+#define GL_PIXEL_MAG_FILTER_EXT           0x8331
+#define GL_PIXEL_MIN_FILTER_EXT           0x8332
+#define GL_PIXEL_CUBIC_WEIGHT_EXT         0x8333
+#define GL_CUBIC_EXT                      0x8334
+#define GL_AVERAGE_EXT                    0x8335
+#define GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT 0x8336
+#define GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT 0x8337
+#define GL_PIXEL_TRANSFORM_2D_MATRIX_EXT  0x8338
+#endif
+
+#ifndef GL_EXT_pixel_transform_color_table
+#endif
+
+#ifndef GL_EXT_shared_texture_palette
+#define GL_SHARED_TEXTURE_PALETTE_EXT     0x81FB
+#endif
+
+#ifndef GL_EXT_separate_specular_color
+#define GL_LIGHT_MODEL_COLOR_CONTROL_EXT  0x81F8
+#define GL_SINGLE_COLOR_EXT               0x81F9
+#define GL_SEPARATE_SPECULAR_COLOR_EXT    0x81FA
+#endif
+
+#ifndef GL_EXT_secondary_color
+#define GL_COLOR_SUM_EXT                  0x8458
+#define GL_CURRENT_SECONDARY_COLOR_EXT    0x8459
+#define GL_SECONDARY_COLOR_ARRAY_SIZE_EXT 0x845A
+#define GL_SECONDARY_COLOR_ARRAY_TYPE_EXT 0x845B
+#define GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT 0x845C
+#define GL_SECONDARY_COLOR_ARRAY_POINTER_EXT 0x845D
+#define GL_SECONDARY_COLOR_ARRAY_EXT      0x845E
+#endif
+
+#ifndef GL_EXT_texture_perturb_normal
+#define GL_PERTURB_EXT                    0x85AE
+#define GL_TEXTURE_NORMAL_EXT             0x85AF
+#endif
+
+#ifndef GL_EXT_multi_draw_arrays
+#endif
+
+#ifndef GL_EXT_fog_coord
+#define GL_FOG_COORDINATE_SOURCE_EXT      0x8450
+#define GL_FOG_COORDINATE_EXT             0x8451
+#define GL_FRAGMENT_DEPTH_EXT             0x8452
+#define GL_CURRENT_FOG_COORDINATE_EXT     0x8453
+#define GL_FOG_COORDINATE_ARRAY_TYPE_EXT  0x8454
+#define GL_FOG_COORDINATE_ARRAY_STRIDE_EXT 0x8455
+#define GL_FOG_COORDINATE_ARRAY_POINTER_EXT 0x8456
+#define GL_FOG_COORDINATE_ARRAY_EXT       0x8457
+#endif
+
+#ifndef GL_REND_screen_coordinates
+#define GL_SCREEN_COORDINATES_REND        0x8490
+#define GL_INVERTED_SCREEN_W_REND         0x8491
+#endif
+
+#ifndef GL_EXT_coordinate_frame
+#define GL_TANGENT_ARRAY_EXT              0x8439
+#define GL_BINORMAL_ARRAY_EXT             0x843A
+#define GL_CURRENT_TANGENT_EXT            0x843B
+#define GL_CURRENT_BINORMAL_EXT           0x843C
+#define GL_TANGENT_ARRAY_TYPE_EXT         0x843E
+#define GL_TANGENT_ARRAY_STRIDE_EXT       0x843F
+#define GL_BINORMAL_ARRAY_TYPE_EXT        0x8440
+#define GL_BINORMAL_ARRAY_STRIDE_EXT      0x8441
+#define GL_TANGENT_ARRAY_POINTER_EXT      0x8442
+#define GL_BINORMAL_ARRAY_POINTER_EXT     0x8443
+#define GL_MAP1_TANGENT_EXT               0x8444
+#define GL_MAP2_TANGENT_EXT               0x8445
+#define GL_MAP1_BINORMAL_EXT              0x8446
+#define GL_MAP2_BINORMAL_EXT              0x8447
+#endif
+
+#ifndef GL_EXT_texture_env_combine
+#define GL_COMBINE_EXT                    0x8570
+#define GL_COMBINE_RGB_EXT                0x8571
+#define GL_COMBINE_ALPHA_EXT              0x8572
+#define GL_RGB_SCALE_EXT                  0x8573
+#define GL_ADD_SIGNED_EXT                 0x8574
+#define GL_INTERPOLATE_EXT                0x8575
+#define GL_CONSTANT_EXT                   0x8576
+#define GL_PRIMARY_COLOR_EXT              0x8577
+#define GL_PREVIOUS_EXT                   0x8578
+#define GL_SOURCE0_RGB_EXT                0x8580
+#define GL_SOURCE1_RGB_EXT                0x8581
+#define GL_SOURCE2_RGB_EXT                0x8582
+#define GL_SOURCE0_ALPHA_EXT              0x8588
+#define GL_SOURCE1_ALPHA_EXT              0x8589
+#define GL_SOURCE2_ALPHA_EXT              0x858A
+#define GL_OPERAND0_RGB_EXT               0x8590
+#define GL_OPERAND1_RGB_EXT               0x8591
+#define GL_OPERAND2_RGB_EXT               0x8592
+#define GL_OPERAND0_ALPHA_EXT             0x8598
+#define GL_OPERAND1_ALPHA_EXT             0x8599
+#define GL_OPERAND2_ALPHA_EXT             0x859A
+#endif
+
+#ifndef GL_APPLE_specular_vector
+#define GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE 0x85B0
+#endif
+
+#ifndef GL_APPLE_transform_hint
+#define GL_TRANSFORM_HINT_APPLE           0x85B1
+#endif
+
+#ifndef GL_SGIX_fog_scale
+#define GL_FOG_SCALE_SGIX                 0x81FC
+#define GL_FOG_SCALE_VALUE_SGIX           0x81FD
+#endif
+
+#ifndef GL_SUNX_constant_data
+#define GL_UNPACK_CONSTANT_DATA_SUNX      0x81D5
+#define GL_TEXTURE_CONSTANT_DATA_SUNX     0x81D6
+#endif
+
+#ifndef GL_SUN_global_alpha
+#define GL_GLOBAL_ALPHA_SUN               0x81D9
+#define GL_GLOBAL_ALPHA_FACTOR_SUN        0x81DA
+#endif
+
+#ifndef GL_SUN_triangle_list
+#define GL_RESTART_SUN                    0x0001
+#define GL_REPLACE_MIDDLE_SUN             0x0002
+#define GL_REPLACE_OLDEST_SUN             0x0003
+#define GL_TRIANGLE_LIST_SUN              0x81D7
+#define GL_REPLACEMENT_CODE_SUN           0x81D8
+#define GL_REPLACEMENT_CODE_ARRAY_SUN     0x85C0
+#define GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN 0x85C1
+#define GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN 0x85C2
+#define GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN 0x85C3
+#define GL_R1UI_V3F_SUN                   0x85C4
+#define GL_R1UI_C4UB_V3F_SUN              0x85C5
+#define GL_R1UI_C3F_V3F_SUN               0x85C6
+#define GL_R1UI_N3F_V3F_SUN               0x85C7
+#define GL_R1UI_C4F_N3F_V3F_SUN           0x85C8
+#define GL_R1UI_T2F_V3F_SUN               0x85C9
+#define GL_R1UI_T2F_N3F_V3F_SUN           0x85CA
+#define GL_R1UI_T2F_C4F_N3F_V3F_SUN       0x85CB
+#endif
+
+#ifndef GL_SUN_vertex
+#endif
+
+#ifndef GL_EXT_blend_func_separate
+#define GL_BLEND_DST_RGB_EXT              0x80C8
+#define GL_BLEND_SRC_RGB_EXT              0x80C9
+#define GL_BLEND_DST_ALPHA_EXT            0x80CA
+#define GL_BLEND_SRC_ALPHA_EXT            0x80CB
+#endif
+
+#ifndef GL_INGR_color_clamp
+#define GL_RED_MIN_CLAMP_INGR             0x8560
+#define GL_GREEN_MIN_CLAMP_INGR           0x8561
+#define GL_BLUE_MIN_CLAMP_INGR            0x8562
+#define GL_ALPHA_MIN_CLAMP_INGR           0x8563
+#define GL_RED_MAX_CLAMP_INGR             0x8564
+#define GL_GREEN_MAX_CLAMP_INGR           0x8565
+#define GL_BLUE_MAX_CLAMP_INGR            0x8566
+#define GL_ALPHA_MAX_CLAMP_INGR           0x8567
+#endif
+
+#ifndef GL_INGR_interlace_read
+#define GL_INTERLACE_READ_INGR            0x8568
+#endif
+
+#ifndef GL_EXT_stencil_wrap
+#define GL_INCR_WRAP_EXT                  0x8507
+#define GL_DECR_WRAP_EXT                  0x8508
+#endif
+
+#ifndef GL_EXT_422_pixels
+#define GL_422_EXT                        0x80CC
+#define GL_422_REV_EXT                    0x80CD
+#define GL_422_AVERAGE_EXT                0x80CE
+#define GL_422_REV_AVERAGE_EXT            0x80CF
+#endif
+
+#ifndef GL_NV_texgen_reflection
+#define GL_NORMAL_MAP_NV                  0x8511
+#define GL_REFLECTION_MAP_NV              0x8512
+#endif
+
+#ifndef GL_EXT_texture_cube_map
+#define GL_NORMAL_MAP_EXT                 0x8511
+#define GL_REFLECTION_MAP_EXT             0x8512
+#define GL_TEXTURE_CUBE_MAP_EXT           0x8513
+#define GL_TEXTURE_BINDING_CUBE_MAP_EXT   0x8514
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT 0x8515
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT 0x8516
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT 0x8517
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT 0x8518
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT 0x8519
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT 0x851A
+#define GL_PROXY_TEXTURE_CUBE_MAP_EXT     0x851B
+#define GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT  0x851C
+#endif
+
+#ifndef GL_SUN_convolution_border_modes
+#define GL_WRAP_BORDER_SUN                0x81D4
+#endif
+
+#ifndef GL_EXT_texture_env_add
+#endif
+
+#ifndef GL_EXT_texture_lod_bias
+#define GL_MAX_TEXTURE_LOD_BIAS_EXT       0x84FD
+#define GL_TEXTURE_FILTER_CONTROL_EXT     0x8500
+#define GL_TEXTURE_LOD_BIAS_EXT           0x8501
+#endif
+
+#ifndef GL_EXT_texture_filter_anisotropic
+#define GL_TEXTURE_MAX_ANISOTROPY_EXT     0x84FE
+#define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF
+#endif
+
+#ifndef GL_EXT_vertex_weighting
+#define GL_MODELVIEW0_STACK_DEPTH_EXT     GL_MODELVIEW_STACK_DEPTH
+#define GL_MODELVIEW1_STACK_DEPTH_EXT     0x8502
+#define GL_MODELVIEW0_MATRIX_EXT          GL_MODELVIEW_MATRIX
+#define GL_MODELVIEW1_MATRIX_EXT          0x8506
+#define GL_VERTEX_WEIGHTING_EXT           0x8509
+#define GL_MODELVIEW0_EXT                 GL_MODELVIEW
+#define GL_MODELVIEW1_EXT                 0x850A
+#define GL_CURRENT_VERTEX_WEIGHT_EXT      0x850B
+#define GL_VERTEX_WEIGHT_ARRAY_EXT        0x850C
+#define GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT   0x850D
+#define GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT   0x850E
+#define GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT 0x850F
+#define GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT 0x8510
+#endif
+
+#ifndef GL_NV_light_max_exponent
+#define GL_MAX_SHININESS_NV               0x8504
+#define GL_MAX_SPOT_EXPONENT_NV           0x8505
+#endif
+
+#ifndef GL_NV_vertex_array_range
+#define GL_VERTEX_ARRAY_RANGE_NV          0x851D
+#define GL_VERTEX_ARRAY_RANGE_LENGTH_NV   0x851E
+#define GL_VERTEX_ARRAY_RANGE_VALID_NV    0x851F
+#define GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV 0x8520
+#define GL_VERTEX_ARRAY_RANGE_POINTER_NV  0x8521
+#endif
+
+#ifndef GL_NV_register_combiners
+#define GL_REGISTER_COMBINERS_NV          0x8522
+#define GL_VARIABLE_A_NV                  0x8523
+#define GL_VARIABLE_B_NV                  0x8524
+#define GL_VARIABLE_C_NV                  0x8525
+#define GL_VARIABLE_D_NV                  0x8526
+#define GL_VARIABLE_E_NV                  0x8527
+#define GL_VARIABLE_F_NV                  0x8528
+#define GL_VARIABLE_G_NV                  0x8529
+#define GL_CONSTANT_COLOR0_NV             0x852A
+#define GL_CONSTANT_COLOR1_NV             0x852B
+#define GL_PRIMARY_COLOR_NV               0x852C
+#define GL_SECONDARY_COLOR_NV             0x852D
+#define GL_SPARE0_NV                      0x852E
+#define GL_SPARE1_NV                      0x852F
+#define GL_DISCARD_NV                     0x8530
+#define GL_E_TIMES_F_NV                   0x8531
+#define GL_SPARE0_PLUS_SECONDARY_COLOR_NV 0x8532
+#define GL_UNSIGNED_IDENTITY_NV           0x8536
+#define GL_UNSIGNED_INVERT_NV             0x8537
+#define GL_EXPAND_NORMAL_NV               0x8538
+#define GL_EXPAND_NEGATE_NV               0x8539
+#define GL_HALF_BIAS_NORMAL_NV            0x853A
+#define GL_HALF_BIAS_NEGATE_NV            0x853B
+#define GL_SIGNED_IDENTITY_NV             0x853C
+#define GL_SIGNED_NEGATE_NV               0x853D
+#define GL_SCALE_BY_TWO_NV                0x853E
+#define GL_SCALE_BY_FOUR_NV               0x853F
+#define GL_SCALE_BY_ONE_HALF_NV           0x8540
+#define GL_BIAS_BY_NEGATIVE_ONE_HALF_NV   0x8541
+#define GL_COMBINER_INPUT_NV              0x8542
+#define GL_COMBINER_MAPPING_NV            0x8543
+#define GL_COMBINER_COMPONENT_USAGE_NV    0x8544
+#define GL_COMBINER_AB_DOT_PRODUCT_NV     0x8545
+#define GL_COMBINER_CD_DOT_PRODUCT_NV     0x8546
+#define GL_COMBINER_MUX_SUM_NV            0x8547
+#define GL_COMBINER_SCALE_NV              0x8548
+#define GL_COMBINER_BIAS_NV               0x8549
+#define GL_COMBINER_AB_OUTPUT_NV          0x854A
+#define GL_COMBINER_CD_OUTPUT_NV          0x854B
+#define GL_COMBINER_SUM_OUTPUT_NV         0x854C
+#define GL_MAX_GENERAL_COMBINERS_NV       0x854D
+#define GL_NUM_GENERAL_COMBINERS_NV       0x854E
+#define GL_COLOR_SUM_CLAMP_NV             0x854F
+#define GL_COMBINER0_NV                   0x8550
+#define GL_COMBINER1_NV                   0x8551
+#define GL_COMBINER2_NV                   0x8552
+#define GL_COMBINER3_NV                   0x8553
+#define GL_COMBINER4_NV                   0x8554
+#define GL_COMBINER5_NV                   0x8555
+#define GL_COMBINER6_NV                   0x8556
+#define GL_COMBINER7_NV                   0x8557
+/* reuse GL_TEXTURE0_ARB */
+/* reuse GL_TEXTURE1_ARB */
+/* reuse GL_ZERO */
+/* reuse GL_NONE */
+/* reuse GL_FOG */
+#endif
+
+#ifndef GL_NV_fog_distance
+#define GL_FOG_DISTANCE_MODE_NV           0x855A
+#define GL_EYE_RADIAL_NV                  0x855B
+#define GL_EYE_PLANE_ABSOLUTE_NV          0x855C
+/* reuse GL_EYE_PLANE */
+#endif
+
+#ifndef GL_NV_texgen_emboss
+#define GL_EMBOSS_LIGHT_NV                0x855D
+#define GL_EMBOSS_CONSTANT_NV             0x855E
+#define GL_EMBOSS_MAP_NV                  0x855F
+#endif
+
+#ifndef GL_NV_blend_square
+#endif
+
+#ifndef GL_NV_texture_env_combine4
+#define GL_COMBINE4_NV                    0x8503
+#define GL_SOURCE3_RGB_NV                 0x8583
+#define GL_SOURCE3_ALPHA_NV               0x858B
+#define GL_OPERAND3_RGB_NV                0x8593
+#define GL_OPERAND3_ALPHA_NV              0x859B
+#endif
+
+#ifndef GL_MESA_resize_buffers
+#endif
+
+#ifndef GL_MESA_window_pos
+#endif
+
+#ifndef GL_EXT_texture_compression_s3tc
+#define GL_COMPRESSED_RGB_S3TC_DXT1_EXT   0x83F0
+#define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT  0x83F1
+#define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT  0x83F2
+#define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT  0x83F3
+#endif
+
+#ifndef GL_IBM_cull_vertex
+#define GL_CULL_VERTEX_IBM                103050
+#endif
+
+#ifndef GL_IBM_multimode_draw_arrays
+#endif
+
+#ifndef GL_IBM_vertex_array_lists
+#define GL_VERTEX_ARRAY_LIST_IBM          103070
+#define GL_NORMAL_ARRAY_LIST_IBM          103071
+#define GL_COLOR_ARRAY_LIST_IBM           103072
+#define GL_INDEX_ARRAY_LIST_IBM           103073
+#define GL_TEXTURE_COORD_ARRAY_LIST_IBM   103074
+#define GL_EDGE_FLAG_ARRAY_LIST_IBM       103075
+#define GL_FOG_COORDINATE_ARRAY_LIST_IBM  103076
+#define GL_SECONDARY_COLOR_ARRAY_LIST_IBM 103077
+#define GL_VERTEX_ARRAY_LIST_STRIDE_IBM   103080
+#define GL_NORMAL_ARRAY_LIST_STRIDE_IBM   103081
+#define GL_COLOR_ARRAY_LIST_STRIDE_IBM    103082
+#define GL_INDEX_ARRAY_LIST_STRIDE_IBM    103083
+#define GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM 103084
+#define GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM 103085
+#define GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM 103086
+#define GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM 103087
+#endif
+
+#ifndef GL_SGIX_subsample
+#define GL_PACK_SUBSAMPLE_RATE_SGIX       0x85A0
+#define GL_UNPACK_SUBSAMPLE_RATE_SGIX     0x85A1
+#define GL_PIXEL_SUBSAMPLE_4444_SGIX      0x85A2
+#define GL_PIXEL_SUBSAMPLE_2424_SGIX      0x85A3
+#define GL_PIXEL_SUBSAMPLE_4242_SGIX      0x85A4
+#endif
+
+#ifndef GL_SGIX_ycrcb_subsample
+#endif
+
+#ifndef GL_SGIX_ycrcba
+#define GL_YCRCB_SGIX                     0x8318
+#define GL_YCRCBA_SGIX                    0x8319
+#endif
+
+#ifndef GL_SGI_depth_pass_instrument
+#define GL_DEPTH_PASS_INSTRUMENT_SGIX     0x8310
+#define GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX 0x8311
+#define GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX 0x8312
+#endif
+
+#ifndef GL_3DFX_texture_compression_FXT1
+#define GL_COMPRESSED_RGB_FXT1_3DFX       0x86B0
+#define GL_COMPRESSED_RGBA_FXT1_3DFX      0x86B1
+#endif
+
+#ifndef GL_3DFX_multisample
+#define GL_MULTISAMPLE_3DFX               0x86B2
+#define GL_SAMPLE_BUFFERS_3DFX            0x86B3
+#define GL_SAMPLES_3DFX                   0x86B4
+#define GL_MULTISAMPLE_BIT_3DFX           0x20000000
+#endif
+
+#ifndef GL_3DFX_tbuffer
+#endif
+
+#ifndef GL_EXT_multisample
+#define GL_MULTISAMPLE_EXT                0x809D
+#define GL_SAMPLE_ALPHA_TO_MASK_EXT       0x809E
+#define GL_SAMPLE_ALPHA_TO_ONE_EXT        0x809F
+#define GL_SAMPLE_MASK_EXT                0x80A0
+#define GL_1PASS_EXT                      0x80A1
+#define GL_2PASS_0_EXT                    0x80A2
+#define GL_2PASS_1_EXT                    0x80A3
+#define GL_4PASS_0_EXT                    0x80A4
+#define GL_4PASS_1_EXT                    0x80A5
+#define GL_4PASS_2_EXT                    0x80A6
+#define GL_4PASS_3_EXT                    0x80A7
+#define GL_SAMPLE_BUFFERS_EXT             0x80A8
+#define GL_SAMPLES_EXT                    0x80A9
+#define GL_SAMPLE_MASK_VALUE_EXT          0x80AA
+#define GL_SAMPLE_MASK_INVERT_EXT         0x80AB
+#define GL_SAMPLE_PATTERN_EXT             0x80AC
+#define GL_MULTISAMPLE_BIT_EXT            0x20000000
+#endif
+
+#ifndef GL_SGIX_vertex_preclip
+#define GL_VERTEX_PRECLIP_SGIX            0x83EE
+#define GL_VERTEX_PRECLIP_HINT_SGIX       0x83EF
+#endif
+
+#ifndef GL_SGIX_convolution_accuracy
+#define GL_CONVOLUTION_HINT_SGIX          0x8316
+#endif
+
+#ifndef GL_SGIX_resample
+#define GL_PACK_RESAMPLE_SGIX             0x842C
+#define GL_UNPACK_RESAMPLE_SGIX           0x842D
+#define GL_RESAMPLE_REPLICATE_SGIX        0x842E
+#define GL_RESAMPLE_ZERO_FILL_SGIX        0x842F
+#define GL_RESAMPLE_DECIMATE_SGIX         0x8430
+#endif
+
+#ifndef GL_SGIS_point_line_texgen
+#define GL_EYE_DISTANCE_TO_POINT_SGIS     0x81F0
+#define GL_OBJECT_DISTANCE_TO_POINT_SGIS  0x81F1
+#define GL_EYE_DISTANCE_TO_LINE_SGIS      0x81F2
+#define GL_OBJECT_DISTANCE_TO_LINE_SGIS   0x81F3
+#define GL_EYE_POINT_SGIS                 0x81F4
+#define GL_OBJECT_POINT_SGIS              0x81F5
+#define GL_EYE_LINE_SGIS                  0x81F6
+#define GL_OBJECT_LINE_SGIS               0x81F7
+#endif
+
+#ifndef GL_SGIS_texture_color_mask
+#define GL_TEXTURE_COLOR_WRITEMASK_SGIS   0x81EF
+#endif
+
+#ifndef GL_EXT_texture_env_dot3
+#define GL_DOT3_RGB_EXT                   0x8740
+#define GL_DOT3_RGBA_EXT                  0x8741
+#endif
+
+#ifndef GL_ATI_texture_mirror_once
+#define GL_MIRROR_CLAMP_ATI               0x8742
+#define GL_MIRROR_CLAMP_TO_EDGE_ATI       0x8743
+#endif
+
+#ifndef GL_NV_fence
+#define GL_ALL_COMPLETED_NV               0x84F2
+#define GL_FENCE_STATUS_NV                0x84F3
+#define GL_FENCE_CONDITION_NV             0x84F4
+#endif
+
+#ifndef GL_IBM_texture_mirrored_repeat
+#define GL_MIRRORED_REPEAT_IBM            0x8370
+#endif
+
+#ifndef GL_NV_evaluators
+#define GL_EVAL_2D_NV                     0x86C0
+#define GL_EVAL_TRIANGULAR_2D_NV          0x86C1
+#define GL_MAP_TESSELLATION_NV            0x86C2
+#define GL_MAP_ATTRIB_U_ORDER_NV          0x86C3
+#define GL_MAP_ATTRIB_V_ORDER_NV          0x86C4
+#define GL_EVAL_FRACTIONAL_TESSELLATION_NV 0x86C5
+#define GL_EVAL_VERTEX_ATTRIB0_NV         0x86C6
+#define GL_EVAL_VERTEX_ATTRIB1_NV         0x86C7
+#define GL_EVAL_VERTEX_ATTRIB2_NV         0x86C8
+#define GL_EVAL_VERTEX_ATTRIB3_NV         0x86C9
+#define GL_EVAL_VERTEX_ATTRIB4_NV         0x86CA
+#define GL_EVAL_VERTEX_ATTRIB5_NV         0x86CB
+#define GL_EVAL_VERTEX_ATTRIB6_NV         0x86CC
+#define GL_EVAL_VERTEX_ATTRIB7_NV         0x86CD
+#define GL_EVAL_VERTEX_ATTRIB8_NV         0x86CE
+#define GL_EVAL_VERTEX_ATTRIB9_NV         0x86CF
+#define GL_EVAL_VERTEX_ATTRIB10_NV        0x86D0
+#define GL_EVAL_VERTEX_ATTRIB11_NV        0x86D1
+#define GL_EVAL_VERTEX_ATTRIB12_NV        0x86D2
+#define GL_EVAL_VERTEX_ATTRIB13_NV        0x86D3
+#define GL_EVAL_VERTEX_ATTRIB14_NV        0x86D4
+#define GL_EVAL_VERTEX_ATTRIB15_NV        0x86D5
+#define GL_MAX_MAP_TESSELLATION_NV        0x86D6
+#define GL_MAX_RATIONAL_EVAL_ORDER_NV     0x86D7
+#endif
+
+#ifndef GL_NV_packed_depth_stencil
+#define GL_DEPTH_STENCIL_NV               0x84F9
+#define GL_UNSIGNED_INT_24_8_NV           0x84FA
+#endif
+
+#ifndef GL_NV_register_combiners2
+#define GL_PER_STAGE_CONSTANTS_NV         0x8535
+#endif
+
+#ifndef GL_NV_texture_compression_vtc
+#endif
+
+#ifndef GL_NV_texture_rectangle
+#define GL_TEXTURE_RECTANGLE_NV           0x84F5
+#define GL_TEXTURE_BINDING_RECTANGLE_NV   0x84F6
+#define GL_PROXY_TEXTURE_RECTANGLE_NV     0x84F7
+#define GL_MAX_RECTANGLE_TEXTURE_SIZE_NV  0x84F8
+#endif
+
+#ifndef GL_NV_texture_shader
+#define GL_OFFSET_TEXTURE_RECTANGLE_NV    0x864C
+#define GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV 0x864D
+#define GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV 0x864E
+#define GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV 0x86D9
+#define GL_UNSIGNED_INT_S8_S8_8_8_NV      0x86DA
+#define GL_UNSIGNED_INT_8_8_S8_S8_REV_NV  0x86DB
+#define GL_DSDT_MAG_INTENSITY_NV          0x86DC
+#define GL_SHADER_CONSISTENT_NV           0x86DD
+#define GL_TEXTURE_SHADER_NV              0x86DE
+#define GL_SHADER_OPERATION_NV            0x86DF
+#define GL_CULL_MODES_NV                  0x86E0
+#define GL_OFFSET_TEXTURE_MATRIX_NV       0x86E1
+#define GL_OFFSET_TEXTURE_SCALE_NV        0x86E2
+#define GL_OFFSET_TEXTURE_BIAS_NV         0x86E3
+#define GL_OFFSET_TEXTURE_2D_MATRIX_NV    GL_OFFSET_TEXTURE_MATRIX_NV
+#define GL_OFFSET_TEXTURE_2D_SCALE_NV     GL_OFFSET_TEXTURE_SCALE_NV
+#define GL_OFFSET_TEXTURE_2D_BIAS_NV      GL_OFFSET_TEXTURE_BIAS_NV
+#define GL_PREVIOUS_TEXTURE_INPUT_NV      0x86E4
+#define GL_CONST_EYE_NV                   0x86E5
+#define GL_PASS_THROUGH_NV                0x86E6
+#define GL_CULL_FRAGMENT_NV               0x86E7
+#define GL_OFFSET_TEXTURE_2D_NV           0x86E8
+#define GL_DEPENDENT_AR_TEXTURE_2D_NV     0x86E9
+#define GL_DEPENDENT_GB_TEXTURE_2D_NV     0x86EA
+#define GL_DOT_PRODUCT_NV                 0x86EC
+#define GL_DOT_PRODUCT_DEPTH_REPLACE_NV   0x86ED
+#define GL_DOT_PRODUCT_TEXTURE_2D_NV      0x86EE
+#define GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV 0x86F0
+#define GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV 0x86F1
+#define GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV 0x86F2
+#define GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV 0x86F3
+#define GL_HILO_NV                        0x86F4
+#define GL_DSDT_NV                        0x86F5
+#define GL_DSDT_MAG_NV                    0x86F6
+#define GL_DSDT_MAG_VIB_NV                0x86F7
+#define GL_HILO16_NV                      0x86F8
+#define GL_SIGNED_HILO_NV                 0x86F9
+#define GL_SIGNED_HILO16_NV               0x86FA
+#define GL_SIGNED_RGBA_NV                 0x86FB
+#define GL_SIGNED_RGBA8_NV                0x86FC
+#define GL_SIGNED_RGB_NV                  0x86FE
+#define GL_SIGNED_RGB8_NV                 0x86FF
+#define GL_SIGNED_LUMINANCE_NV            0x8701
+#define GL_SIGNED_LUMINANCE8_NV           0x8702
+#define GL_SIGNED_LUMINANCE_ALPHA_NV      0x8703
+#define GL_SIGNED_LUMINANCE8_ALPHA8_NV    0x8704
+#define GL_SIGNED_ALPHA_NV                0x8705
+#define GL_SIGNED_ALPHA8_NV               0x8706
+#define GL_SIGNED_INTENSITY_NV            0x8707
+#define GL_SIGNED_INTENSITY8_NV           0x8708
+#define GL_DSDT8_NV                       0x8709
+#define GL_DSDT8_MAG8_NV                  0x870A
+#define GL_DSDT8_MAG8_INTENSITY8_NV       0x870B
+#define GL_SIGNED_RGB_UNSIGNED_ALPHA_NV   0x870C
+#define GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV 0x870D
+#define GL_HI_SCALE_NV                    0x870E
+#define GL_LO_SCALE_NV                    0x870F
+#define GL_DS_SCALE_NV                    0x8710
+#define GL_DT_SCALE_NV                    0x8711
+#define GL_MAGNITUDE_SCALE_NV             0x8712
+#define GL_VIBRANCE_SCALE_NV              0x8713
+#define GL_HI_BIAS_NV                     0x8714
+#define GL_LO_BIAS_NV                     0x8715
+#define GL_DS_BIAS_NV                     0x8716
+#define GL_DT_BIAS_NV                     0x8717
+#define GL_MAGNITUDE_BIAS_NV              0x8718
+#define GL_VIBRANCE_BIAS_NV               0x8719
+#define GL_TEXTURE_BORDER_VALUES_NV       0x871A
+#define GL_TEXTURE_HI_SIZE_NV             0x871B
+#define GL_TEXTURE_LO_SIZE_NV             0x871C
+#define GL_TEXTURE_DS_SIZE_NV             0x871D
+#define GL_TEXTURE_DT_SIZE_NV             0x871E
+#define GL_TEXTURE_MAG_SIZE_NV            0x871F
+#endif
+
+#ifndef GL_NV_texture_shader2
+#define GL_DOT_PRODUCT_TEXTURE_3D_NV      0x86EF
+#endif
+
+#ifndef GL_NV_vertex_array_range2
+#define GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV 0x8533
+#endif
+
+#ifndef GL_NV_vertex_program
+#define GL_VERTEX_PROGRAM_NV              0x8620
+#define GL_VERTEX_STATE_PROGRAM_NV        0x8621
+#define GL_ATTRIB_ARRAY_SIZE_NV           0x8623
+#define GL_ATTRIB_ARRAY_STRIDE_NV         0x8624
+#define GL_ATTRIB_ARRAY_TYPE_NV           0x8625
+#define GL_CURRENT_ATTRIB_NV              0x8626
+#define GL_PROGRAM_LENGTH_NV              0x8627
+#define GL_PROGRAM_STRING_NV              0x8628
+#define GL_MODELVIEW_PROJECTION_NV        0x8629
+#define GL_IDENTITY_NV                    0x862A
+#define GL_INVERSE_NV                     0x862B
+#define GL_TRANSPOSE_NV                   0x862C
+#define GL_INVERSE_TRANSPOSE_NV           0x862D
+#define GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV 0x862E
+#define GL_MAX_TRACK_MATRICES_NV          0x862F
+#define GL_MATRIX0_NV                     0x8630
+#define GL_MATRIX1_NV                     0x8631
+#define GL_MATRIX2_NV                     0x8632
+#define GL_MATRIX3_NV                     0x8633
+#define GL_MATRIX4_NV                     0x8634
+#define GL_MATRIX5_NV                     0x8635
+#define GL_MATRIX6_NV                     0x8636
+#define GL_MATRIX7_NV                     0x8637
+#define GL_CURRENT_MATRIX_STACK_DEPTH_NV  0x8640
+#define GL_CURRENT_MATRIX_NV              0x8641
+#define GL_VERTEX_PROGRAM_POINT_SIZE_NV   0x8642
+#define GL_VERTEX_PROGRAM_TWO_SIDE_NV     0x8643
+#define GL_PROGRAM_PARAMETER_NV           0x8644
+#define GL_ATTRIB_ARRAY_POINTER_NV        0x8645
+#define GL_PROGRAM_TARGET_NV              0x8646
+#define GL_PROGRAM_RESIDENT_NV            0x8647
+#define GL_TRACK_MATRIX_NV                0x8648
+#define GL_TRACK_MATRIX_TRANSFORM_NV      0x8649
+#define GL_VERTEX_PROGRAM_BINDING_NV      0x864A
+#define GL_PROGRAM_ERROR_POSITION_NV      0x864B
+#define GL_VERTEX_ATTRIB_ARRAY0_NV        0x8650
+#define GL_VERTEX_ATTRIB_ARRAY1_NV        0x8651
+#define GL_VERTEX_ATTRIB_ARRAY2_NV        0x8652
+#define GL_VERTEX_ATTRIB_ARRAY3_NV        0x8653
+#define GL_VERTEX_ATTRIB_ARRAY4_NV        0x8654
+#define GL_VERTEX_ATTRIB_ARRAY5_NV        0x8655
+#define GL_VERTEX_ATTRIB_ARRAY6_NV        0x8656
+#define GL_VERTEX_ATTRIB_ARRAY7_NV        0x8657
+#define GL_VERTEX_ATTRIB_ARRAY8_NV        0x8658
+#define GL_VERTEX_ATTRIB_ARRAY9_NV        0x8659
+#define GL_VERTEX_ATTRIB_ARRAY10_NV       0x865A
+#define GL_VERTEX_ATTRIB_ARRAY11_NV       0x865B
+#define GL_VERTEX_ATTRIB_ARRAY12_NV       0x865C
+#define GL_VERTEX_ATTRIB_ARRAY13_NV       0x865D
+#define GL_VERTEX_ATTRIB_ARRAY14_NV       0x865E
+#define GL_VERTEX_ATTRIB_ARRAY15_NV       0x865F
+#define GL_MAP1_VERTEX_ATTRIB0_4_NV       0x8660
+#define GL_MAP1_VERTEX_ATTRIB1_4_NV       0x8661
+#define GL_MAP1_VERTEX_ATTRIB2_4_NV       0x8662
+#define GL_MAP1_VERTEX_ATTRIB3_4_NV       0x8663
+#define GL_MAP1_VERTEX_ATTRIB4_4_NV       0x8664
+#define GL_MAP1_VERTEX_ATTRIB5_4_NV       0x8665
+#define GL_MAP1_VERTEX_ATTRIB6_4_NV       0x8666
+#define GL_MAP1_VERTEX_ATTRIB7_4_NV       0x8667
+#define GL_MAP1_VERTEX_ATTRIB8_4_NV       0x8668
+#define GL_MAP1_VERTEX_ATTRIB9_4_NV       0x8669
+#define GL_MAP1_VERTEX_ATTRIB10_4_NV      0x866A
+#define GL_MAP1_VERTEX_ATTRIB11_4_NV      0x866B
+#define GL_MAP1_VERTEX_ATTRIB12_4_NV      0x866C
+#define GL_MAP1_VERTEX_ATTRIB13_4_NV      0x866D
+#define GL_MAP1_VERTEX_ATTRIB14_4_NV      0x866E
+#define GL_MAP1_VERTEX_ATTRIB15_4_NV      0x866F
+#define GL_MAP2_VERTEX_ATTRIB0_4_NV       0x8670
+#define GL_MAP2_VERTEX_ATTRIB1_4_NV       0x8671
+#define GL_MAP2_VERTEX_ATTRIB2_4_NV       0x8672
+#define GL_MAP2_VERTEX_ATTRIB3_4_NV       0x8673
+#define GL_MAP2_VERTEX_ATTRIB4_4_NV       0x8674
+#define GL_MAP2_VERTEX_ATTRIB5_4_NV       0x8675
+#define GL_MAP2_VERTEX_ATTRIB6_4_NV       0x8676
+#define GL_MAP2_VERTEX_ATTRIB7_4_NV       0x8677
+#define GL_MAP2_VERTEX_ATTRIB8_4_NV       0x8678
+#define GL_MAP2_VERTEX_ATTRIB9_4_NV       0x8679
+#define GL_MAP2_VERTEX_ATTRIB10_4_NV      0x867A
+#define GL_MAP2_VERTEX_ATTRIB11_4_NV      0x867B
+#define GL_MAP2_VERTEX_ATTRIB12_4_NV      0x867C
+#define GL_MAP2_VERTEX_ATTRIB13_4_NV      0x867D
+#define GL_MAP2_VERTEX_ATTRIB14_4_NV      0x867E
+#define GL_MAP2_VERTEX_ATTRIB15_4_NV      0x867F
+#endif
+
+#ifndef GL_SGIX_texture_coordinate_clamp
+#define GL_TEXTURE_MAX_CLAMP_S_SGIX       0x8369
+#define GL_TEXTURE_MAX_CLAMP_T_SGIX       0x836A
+#define GL_TEXTURE_MAX_CLAMP_R_SGIX       0x836B
+#endif
+
+#ifndef GL_SGIX_scalebias_hint
+#define GL_SCALEBIAS_HINT_SGIX            0x8322
+#endif
+
+#ifndef GL_OML_interlace
+#define GL_INTERLACE_OML                  0x8980
+#define GL_INTERLACE_READ_OML             0x8981
+#endif
+
+#ifndef GL_OML_subsample
+#define GL_FORMAT_SUBSAMPLE_24_24_OML     0x8982
+#define GL_FORMAT_SUBSAMPLE_244_244_OML   0x8983
+#endif
+
+#ifndef GL_OML_resample
+#define GL_PACK_RESAMPLE_OML              0x8984
+#define GL_UNPACK_RESAMPLE_OML            0x8985
+#define GL_RESAMPLE_REPLICATE_OML         0x8986
+#define GL_RESAMPLE_ZERO_FILL_OML         0x8987
+#define GL_RESAMPLE_AVERAGE_OML           0x8988
+#define GL_RESAMPLE_DECIMATE_OML          0x8989
+#endif
+
+#ifndef GL_NV_copy_depth_to_color
+#define GL_DEPTH_STENCIL_TO_RGBA_NV       0x886E
+#define GL_DEPTH_STENCIL_TO_BGRA_NV       0x886F
+#endif
+
+#ifndef GL_ATI_envmap_bumpmap
+#define GL_BUMP_ROT_MATRIX_ATI            0x8775
+#define GL_BUMP_ROT_MATRIX_SIZE_ATI       0x8776
+#define GL_BUMP_NUM_TEX_UNITS_ATI         0x8777
+#define GL_BUMP_TEX_UNITS_ATI             0x8778
+#define GL_DUDV_ATI                       0x8779
+#define GL_DU8DV8_ATI                     0x877A
+#define GL_BUMP_ENVMAP_ATI                0x877B
+#define GL_BUMP_TARGET_ATI                0x877C
+#endif
+
+#ifndef GL_ATI_fragment_shader
+#define GL_FRAGMENT_SHADER_ATI            0x8920
+#define GL_REG_0_ATI                      0x8921
+#define GL_REG_1_ATI                      0x8922
+#define GL_REG_2_ATI                      0x8923
+#define GL_REG_3_ATI                      0x8924
+#define GL_REG_4_ATI                      0x8925
+#define GL_REG_5_ATI                      0x8926
+#define GL_REG_6_ATI                      0x8927
+#define GL_REG_7_ATI                      0x8928
+#define GL_REG_8_ATI                      0x8929
+#define GL_REG_9_ATI                      0x892A
+#define GL_REG_10_ATI                     0x892B
+#define GL_REG_11_ATI                     0x892C
+#define GL_REG_12_ATI                     0x892D
+#define GL_REG_13_ATI                     0x892E
+#define GL_REG_14_ATI                     0x892F
+#define GL_REG_15_ATI                     0x8930
+#define GL_REG_16_ATI                     0x8931
+#define GL_REG_17_ATI                     0x8932
+#define GL_REG_18_ATI                     0x8933
+#define GL_REG_19_ATI                     0x8934
+#define GL_REG_20_ATI                     0x8935
+#define GL_REG_21_ATI                     0x8936
+#define GL_REG_22_ATI                     0x8937
+#define GL_REG_23_ATI                     0x8938
+#define GL_REG_24_ATI                     0x8939
+#define GL_REG_25_ATI                     0x893A
+#define GL_REG_26_ATI                     0x893B
+#define GL_REG_27_ATI                     0x893C
+#define GL_REG_28_ATI                     0x893D
+#define GL_REG_29_ATI                     0x893E
+#define GL_REG_30_ATI                     0x893F
+#define GL_REG_31_ATI                     0x8940
+#define GL_CON_0_ATI                      0x8941
+#define GL_CON_1_ATI                      0x8942
+#define GL_CON_2_ATI                      0x8943
+#define GL_CON_3_ATI                      0x8944
+#define GL_CON_4_ATI                      0x8945
+#define GL_CON_5_ATI                      0x8946
+#define GL_CON_6_ATI                      0x8947
+#define GL_CON_7_ATI                      0x8948
+#define GL_CON_8_ATI                      0x8949
+#define GL_CON_9_ATI                      0x894A
+#define GL_CON_10_ATI                     0x894B
+#define GL_CON_11_ATI                     0x894C
+#define GL_CON_12_ATI                     0x894D
+#define GL_CON_13_ATI                     0x894E
+#define GL_CON_14_ATI                     0x894F
+#define GL_CON_15_ATI                     0x8950
+#define GL_CON_16_ATI                     0x8951
+#define GL_CON_17_ATI                     0x8952
+#define GL_CON_18_ATI                     0x8953
+#define GL_CON_19_ATI                     0x8954
+#define GL_CON_20_ATI                     0x8955
+#define GL_CON_21_ATI                     0x8956
+#define GL_CON_22_ATI                     0x8957
+#define GL_CON_23_ATI                     0x8958
+#define GL_CON_24_ATI                     0x8959
+#define GL_CON_25_ATI                     0x895A
+#define GL_CON_26_ATI                     0x895B
+#define GL_CON_27_ATI                     0x895C
+#define GL_CON_28_ATI                     0x895D
+#define GL_CON_29_ATI                     0x895E
+#define GL_CON_30_ATI                     0x895F
+#define GL_CON_31_ATI                     0x8960
+#define GL_MOV_ATI                        0x8961
+#define GL_ADD_ATI                        0x8963
+#define GL_MUL_ATI                        0x8964
+#define GL_SUB_ATI                        0x8965
+#define GL_DOT3_ATI                       0x8966
+#define GL_DOT4_ATI                       0x8967
+#define GL_MAD_ATI                        0x8968
+#define GL_LERP_ATI                       0x8969
+#define GL_CND_ATI                        0x896A
+#define GL_CND0_ATI                       0x896B
+#define GL_DOT2_ADD_ATI                   0x896C
+#define GL_SECONDARY_INTERPOLATOR_ATI     0x896D
+#define GL_NUM_FRAGMENT_REGISTERS_ATI     0x896E
+#define GL_NUM_FRAGMENT_CONSTANTS_ATI     0x896F
+#define GL_NUM_PASSES_ATI                 0x8970
+#define GL_NUM_INSTRUCTIONS_PER_PASS_ATI  0x8971
+#define GL_NUM_INSTRUCTIONS_TOTAL_ATI     0x8972
+#define GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI 0x8973
+#define GL_NUM_LOOPBACK_COMPONENTS_ATI    0x8974
+#define GL_COLOR_ALPHA_PAIRING_ATI        0x8975
+#define GL_SWIZZLE_STR_ATI                0x8976
+#define GL_SWIZZLE_STQ_ATI                0x8977
+#define GL_SWIZZLE_STR_DR_ATI             0x8978
+#define GL_SWIZZLE_STQ_DQ_ATI             0x8979
+#define GL_SWIZZLE_STRQ_ATI               0x897A
+#define GL_SWIZZLE_STRQ_DQ_ATI            0x897B
+#define GL_RED_BIT_ATI                    0x00000001
+#define GL_GREEN_BIT_ATI                  0x00000002
+#define GL_BLUE_BIT_ATI                   0x00000004
+#define GL_2X_BIT_ATI                     0x00000001
+#define GL_4X_BIT_ATI                     0x00000002
+#define GL_8X_BIT_ATI                     0x00000004
+#define GL_HALF_BIT_ATI                   0x00000008
+#define GL_QUARTER_BIT_ATI                0x00000010
+#define GL_EIGHTH_BIT_ATI                 0x00000020
+#define GL_SATURATE_BIT_ATI               0x00000040
+#define GL_COMP_BIT_ATI                   0x00000002
+#define GL_NEGATE_BIT_ATI                 0x00000004
+#define GL_BIAS_BIT_ATI                   0x00000008
+#endif
+
+#ifndef GL_ATI_pn_triangles
+#define GL_PN_TRIANGLES_ATI               0x87F0
+#define GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI 0x87F1
+#define GL_PN_TRIANGLES_POINT_MODE_ATI    0x87F2
+#define GL_PN_TRIANGLES_NORMAL_MODE_ATI   0x87F3
+#define GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI 0x87F4
+#define GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI 0x87F5
+#define GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI 0x87F6
+#define GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI 0x87F7
+#define GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI 0x87F8
+#endif
+
+#ifndef GL_ATI_vertex_array_object
+#define GL_STATIC_ATI                     0x8760
+#define GL_DYNAMIC_ATI                    0x8761
+#define GL_PRESERVE_ATI                   0x8762
+#define GL_DISCARD_ATI                    0x8763
+#define GL_OBJECT_BUFFER_SIZE_ATI         0x8764
+#define GL_OBJECT_BUFFER_USAGE_ATI        0x8765
+#define GL_ARRAY_OBJECT_BUFFER_ATI        0x8766
+#define GL_ARRAY_OBJECT_OFFSET_ATI        0x8767
+#endif
+
+#ifndef GL_EXT_vertex_shader
+#define GL_VERTEX_SHADER_EXT              0x8780
+#define GL_VERTEX_SHADER_BINDING_EXT      0x8781
+#define GL_OP_INDEX_EXT                   0x8782
+#define GL_OP_NEGATE_EXT                  0x8783
+#define GL_OP_DOT3_EXT                    0x8784
+#define GL_OP_DOT4_EXT                    0x8785
+#define GL_OP_MUL_EXT                     0x8786
+#define GL_OP_ADD_EXT                     0x8787
+#define GL_OP_MADD_EXT                    0x8788
+#define GL_OP_FRAC_EXT                    0x8789
+#define GL_OP_MAX_EXT                     0x878A
+#define GL_OP_MIN_EXT                     0x878B
+#define GL_OP_SET_GE_EXT                  0x878C
+#define GL_OP_SET_LT_EXT                  0x878D
+#define GL_OP_CLAMP_EXT                   0x878E
+#define GL_OP_FLOOR_EXT                   0x878F
+#define GL_OP_ROUND_EXT                   0x8790
+#define GL_OP_EXP_BASE_2_EXT              0x8791
+#define GL_OP_LOG_BASE_2_EXT              0x8792
+#define GL_OP_POWER_EXT                   0x8793
+#define GL_OP_RECIP_EXT                   0x8794
+#define GL_OP_RECIP_SQRT_EXT              0x8795
+#define GL_OP_SUB_EXT                     0x8796
+#define GL_OP_CROSS_PRODUCT_EXT           0x8797
+#define GL_OP_MULTIPLY_MATRIX_EXT         0x8798
+#define GL_OP_MOV_EXT                     0x8799
+#define GL_OUTPUT_VERTEX_EXT              0x879A
+#define GL_OUTPUT_COLOR0_EXT              0x879B
+#define GL_OUTPUT_COLOR1_EXT              0x879C
+#define GL_OUTPUT_TEXTURE_COORD0_EXT      0x879D
+#define GL_OUTPUT_TEXTURE_COORD1_EXT      0x879E
+#define GL_OUTPUT_TEXTURE_COORD2_EXT      0x879F
+#define GL_OUTPUT_TEXTURE_COORD3_EXT      0x87A0
+#define GL_OUTPUT_TEXTURE_COORD4_EXT      0x87A1
+#define GL_OUTPUT_TEXTURE_COORD5_EXT      0x87A2
+#define GL_OUTPUT_TEXTURE_COORD6_EXT      0x87A3
+#define GL_OUTPUT_TEXTURE_COORD7_EXT      0x87A4
+#define GL_OUTPUT_TEXTURE_COORD8_EXT      0x87A5
+#define GL_OUTPUT_TEXTURE_COORD9_EXT      0x87A6
+#define GL_OUTPUT_TEXTURE_COORD10_EXT     0x87A7
+#define GL_OUTPUT_TEXTURE_COORD11_EXT     0x87A8
+#define GL_OUTPUT_TEXTURE_COORD12_EXT     0x87A9
+#define GL_OUTPUT_TEXTURE_COORD13_EXT     0x87AA
+#define GL_OUTPUT_TEXTURE_COORD14_EXT     0x87AB
+#define GL_OUTPUT_TEXTURE_COORD15_EXT     0x87AC
+#define GL_OUTPUT_TEXTURE_COORD16_EXT     0x87AD
+#define GL_OUTPUT_TEXTURE_COORD17_EXT     0x87AE
+#define GL_OUTPUT_TEXTURE_COORD18_EXT     0x87AF
+#define GL_OUTPUT_TEXTURE_COORD19_EXT     0x87B0
+#define GL_OUTPUT_TEXTURE_COORD20_EXT     0x87B1
+#define GL_OUTPUT_TEXTURE_COORD21_EXT     0x87B2
+#define GL_OUTPUT_TEXTURE_COORD22_EXT     0x87B3
+#define GL_OUTPUT_TEXTURE_COORD23_EXT     0x87B4
+#define GL_OUTPUT_TEXTURE_COORD24_EXT     0x87B5
+#define GL_OUTPUT_TEXTURE_COORD25_EXT     0x87B6
+#define GL_OUTPUT_TEXTURE_COORD26_EXT     0x87B7
+#define GL_OUTPUT_TEXTURE_COORD27_EXT     0x87B8
+#define GL_OUTPUT_TEXTURE_COORD28_EXT     0x87B9
+#define GL_OUTPUT_TEXTURE_COORD29_EXT     0x87BA
+#define GL_OUTPUT_TEXTURE_COORD30_EXT     0x87BB
+#define GL_OUTPUT_TEXTURE_COORD31_EXT     0x87BC
+#define GL_OUTPUT_FOG_EXT                 0x87BD
+#define GL_SCALAR_EXT                     0x87BE
+#define GL_VECTOR_EXT                     0x87BF
+#define GL_MATRIX_EXT                     0x87C0
+#define GL_VARIANT_EXT                    0x87C1
+#define GL_INVARIANT_EXT                  0x87C2
+#define GL_LOCAL_CONSTANT_EXT             0x87C3
+#define GL_LOCAL_EXT                      0x87C4
+#define GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT 0x87C5
+#define GL_MAX_VERTEX_SHADER_VARIANTS_EXT 0x87C6
+#define GL_MAX_VERTEX_SHADER_INVARIANTS_EXT 0x87C7
+#define GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT 0x87C8
+#define GL_MAX_VERTEX_SHADER_LOCALS_EXT   0x87C9
+#define GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT 0x87CA
+#define GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT 0x87CB
+#define GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT 0x87CC
+#define GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT 0x87CD
+#define GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT 0x87CE
+#define GL_VERTEX_SHADER_INSTRUCTIONS_EXT 0x87CF
+#define GL_VERTEX_SHADER_VARIANTS_EXT     0x87D0
+#define GL_VERTEX_SHADER_INVARIANTS_EXT   0x87D1
+#define GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT 0x87D2
+#define GL_VERTEX_SHADER_LOCALS_EXT       0x87D3
+#define GL_VERTEX_SHADER_OPTIMIZED_EXT    0x87D4
+#define GL_X_EXT                          0x87D5
+#define GL_Y_EXT                          0x87D6
+#define GL_Z_EXT                          0x87D7
+#define GL_W_EXT                          0x87D8
+#define GL_NEGATIVE_X_EXT                 0x87D9
+#define GL_NEGATIVE_Y_EXT                 0x87DA
+#define GL_NEGATIVE_Z_EXT                 0x87DB
+#define GL_NEGATIVE_W_EXT                 0x87DC
+#define GL_ZERO_EXT                       0x87DD
+#define GL_ONE_EXT                        0x87DE
+#define GL_NEGATIVE_ONE_EXT               0x87DF
+#define GL_NORMALIZED_RANGE_EXT           0x87E0
+#define GL_FULL_RANGE_EXT                 0x87E1
+#define GL_CURRENT_VERTEX_EXT             0x87E2
+#define GL_MVP_MATRIX_EXT                 0x87E3
+#define GL_VARIANT_VALUE_EXT              0x87E4
+#define GL_VARIANT_DATATYPE_EXT           0x87E5
+#define GL_VARIANT_ARRAY_STRIDE_EXT       0x87E6
+#define GL_VARIANT_ARRAY_TYPE_EXT         0x87E7
+#define GL_VARIANT_ARRAY_EXT              0x87E8
+#define GL_VARIANT_ARRAY_POINTER_EXT      0x87E9
+#define GL_INVARIANT_VALUE_EXT            0x87EA
+#define GL_INVARIANT_DATATYPE_EXT         0x87EB
+#define GL_LOCAL_CONSTANT_VALUE_EXT       0x87EC
+#define GL_LOCAL_CONSTANT_DATATYPE_EXT    0x87ED
+#endif
+
+#ifndef GL_ATI_vertex_streams
+#define GL_MAX_VERTEX_STREAMS_ATI         0x876B
+#define GL_VERTEX_STREAM0_ATI             0x876C
+#define GL_VERTEX_STREAM1_ATI             0x876D
+#define GL_VERTEX_STREAM2_ATI             0x876E
+#define GL_VERTEX_STREAM3_ATI             0x876F
+#define GL_VERTEX_STREAM4_ATI             0x8770
+#define GL_VERTEX_STREAM5_ATI             0x8771
+#define GL_VERTEX_STREAM6_ATI             0x8772
+#define GL_VERTEX_STREAM7_ATI             0x8773
+#define GL_VERTEX_SOURCE_ATI              0x8774
+#endif
+
+#ifndef GL_ATI_element_array
+#define GL_ELEMENT_ARRAY_ATI              0x8768
+#define GL_ELEMENT_ARRAY_TYPE_ATI         0x8769
+#define GL_ELEMENT_ARRAY_POINTER_ATI      0x876A
+#endif
+
+#ifndef GL_SUN_mesh_array
+#define GL_QUAD_MESH_SUN                  0x8614
+#define GL_TRIANGLE_MESH_SUN              0x8615
+#endif
+
+#ifndef GL_SUN_slice_accum
+#define GL_SLICE_ACCUM_SUN                0x85CC
+#endif
+
+#ifndef GL_NV_multisample_filter_hint
+#define GL_MULTISAMPLE_FILTER_HINT_NV     0x8534
+#endif
+
+#ifndef GL_NV_depth_clamp
+#define GL_DEPTH_CLAMP_NV                 0x864F
+#endif
+
+#ifndef GL_NV_occlusion_query
+#define GL_PIXEL_COUNTER_BITS_NV          0x8864
+#define GL_CURRENT_OCCLUSION_QUERY_ID_NV  0x8865
+#define GL_PIXEL_COUNT_NV                 0x8866
+#define GL_PIXEL_COUNT_AVAILABLE_NV       0x8867
+#endif
+
+#ifndef GL_NV_point_sprite
+#define GL_POINT_SPRITE_NV                0x8861
+#define GL_COORD_REPLACE_NV               0x8862
+#define GL_POINT_SPRITE_R_MODE_NV         0x8863
+#endif
+
+#ifndef GL_NV_texture_shader3
+#define GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV 0x8850
+#define GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV 0x8851
+#define GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV 0x8852
+#define GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV 0x8853
+#define GL_OFFSET_HILO_TEXTURE_2D_NV      0x8854
+#define GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV 0x8855
+#define GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV 0x8856
+#define GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV 0x8857
+#define GL_DEPENDENT_HILO_TEXTURE_2D_NV   0x8858
+#define GL_DEPENDENT_RGB_TEXTURE_3D_NV    0x8859
+#define GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV 0x885A
+#define GL_DOT_PRODUCT_PASS_THROUGH_NV    0x885B
+#define GL_DOT_PRODUCT_TEXTURE_1D_NV      0x885C
+#define GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV 0x885D
+#define GL_HILO8_NV                       0x885E
+#define GL_SIGNED_HILO8_NV                0x885F
+#define GL_FORCE_BLUE_TO_ONE_NV           0x8860
+#endif
+
+#ifndef GL_NV_vertex_program1_1
+#endif
+
+#ifndef GL_EXT_shadow_funcs
+#endif
+
+#ifndef GL_EXT_stencil_two_side
+#define GL_STENCIL_TEST_TWO_SIDE_EXT      0x8910
+#define GL_ACTIVE_STENCIL_FACE_EXT        0x8911
+#endif
+
+#ifndef GL_ATI_text_fragment_shader
+#define GL_TEXT_FRAGMENT_SHADER_ATI       0x8200
+#endif
+
+#ifndef GL_APPLE_client_storage
+#define GL_UNPACK_CLIENT_STORAGE_APPLE    0x85B2
+#endif
+
+#ifndef GL_APPLE_element_array
+#define GL_ELEMENT_ARRAY_APPLE            0x8A0C
+#define GL_ELEMENT_ARRAY_TYPE_APPLE       0x8A0D
+#define GL_ELEMENT_ARRAY_POINTER_APPLE    0x8A0E
+#endif
+
+#ifndef GL_APPLE_fence
+#define GL_DRAW_PIXELS_APPLE              0x8A0A
+#define GL_FENCE_APPLE                    0x8A0B
+#endif
+
+#ifndef GL_APPLE_vertex_array_object
+#define GL_VERTEX_ARRAY_BINDING_APPLE     0x85B5
+#endif
+
+#ifndef GL_APPLE_vertex_array_range
+#define GL_VERTEX_ARRAY_RANGE_APPLE       0x851D
+#define GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE 0x851E
+#define GL_VERTEX_ARRAY_STORAGE_HINT_APPLE 0x851F
+#define GL_VERTEX_ARRAY_RANGE_POINTER_APPLE 0x8521
+#define GL_STORAGE_CLIENT_APPLE           0x85B4
+#define GL_STORAGE_CACHED_APPLE           0x85BE
+#define GL_STORAGE_SHARED_APPLE           0x85BF
+#endif
+
+#ifndef GL_APPLE_ycbcr_422
+#define GL_YCBCR_422_APPLE                0x85B9
+#define GL_UNSIGNED_SHORT_8_8_APPLE       0x85BA
+#define GL_UNSIGNED_SHORT_8_8_REV_APPLE   0x85BB
+#endif
+
+#ifndef GL_S3_s3tc
+#define GL_RGB_S3TC                       0x83A0
+#define GL_RGB4_S3TC                      0x83A1
+#define GL_RGBA_S3TC                      0x83A2
+#define GL_RGBA4_S3TC                     0x83A3
+#endif
+
+#ifndef GL_ATI_draw_buffers
+#define GL_MAX_DRAW_BUFFERS_ATI           0x8824
+#define GL_DRAW_BUFFER0_ATI               0x8825
+#define GL_DRAW_BUFFER1_ATI               0x8826
+#define GL_DRAW_BUFFER2_ATI               0x8827
+#define GL_DRAW_BUFFER3_ATI               0x8828
+#define GL_DRAW_BUFFER4_ATI               0x8829
+#define GL_DRAW_BUFFER5_ATI               0x882A
+#define GL_DRAW_BUFFER6_ATI               0x882B
+#define GL_DRAW_BUFFER7_ATI               0x882C
+#define GL_DRAW_BUFFER8_ATI               0x882D
+#define GL_DRAW_BUFFER9_ATI               0x882E
+#define GL_DRAW_BUFFER10_ATI              0x882F
+#define GL_DRAW_BUFFER11_ATI              0x8830
+#define GL_DRAW_BUFFER12_ATI              0x8831
+#define GL_DRAW_BUFFER13_ATI              0x8832
+#define GL_DRAW_BUFFER14_ATI              0x8833
+#define GL_DRAW_BUFFER15_ATI              0x8834
+#endif
+
+#ifndef GL_ATI_pixel_format_float
+#define GL_TYPE_RGBA_FLOAT_ATI            0x8820
+#define GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI 0x8835
+#endif
+
+#ifndef GL_ATI_texture_env_combine3
+#define GL_MODULATE_ADD_ATI               0x8744
+#define GL_MODULATE_SIGNED_ADD_ATI        0x8745
+#define GL_MODULATE_SUBTRACT_ATI          0x8746
+#endif
+
+#ifndef GL_ATI_texture_float
+#define GL_RGBA_FLOAT32_ATI               0x8814
+#define GL_RGB_FLOAT32_ATI                0x8815
+#define GL_ALPHA_FLOAT32_ATI              0x8816
+#define GL_INTENSITY_FLOAT32_ATI          0x8817
+#define GL_LUMINANCE_FLOAT32_ATI          0x8818
+#define GL_LUMINANCE_ALPHA_FLOAT32_ATI    0x8819
+#define GL_RGBA_FLOAT16_ATI               0x881A
+#define GL_RGB_FLOAT16_ATI                0x881B
+#define GL_ALPHA_FLOAT16_ATI              0x881C
+#define GL_INTENSITY_FLOAT16_ATI          0x881D
+#define GL_LUMINANCE_FLOAT16_ATI          0x881E
+#define GL_LUMINANCE_ALPHA_FLOAT16_ATI    0x881F
+#endif
+
+#ifndef GL_NV_float_buffer
+#define GL_FLOAT_R_NV                     0x8880
+#define GL_FLOAT_RG_NV                    0x8881
+#define GL_FLOAT_RGB_NV                   0x8882
+#define GL_FLOAT_RGBA_NV                  0x8883
+#define GL_FLOAT_R16_NV                   0x8884
+#define GL_FLOAT_R32_NV                   0x8885
+#define GL_FLOAT_RG16_NV                  0x8886
+#define GL_FLOAT_RG32_NV                  0x8887
+#define GL_FLOAT_RGB16_NV                 0x8888
+#define GL_FLOAT_RGB32_NV                 0x8889
+#define GL_FLOAT_RGBA16_NV                0x888A
+#define GL_FLOAT_RGBA32_NV                0x888B
+#define GL_TEXTURE_FLOAT_COMPONENTS_NV    0x888C
+#define GL_FLOAT_CLEAR_COLOR_VALUE_NV     0x888D
+#define GL_FLOAT_RGBA_MODE_NV             0x888E
+#endif
+
+#ifndef GL_NV_fragment_program
+#define GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV 0x8868
+#define GL_FRAGMENT_PROGRAM_NV            0x8870
+#define GL_MAX_TEXTURE_COORDS_NV          0x8871
+#define GL_MAX_TEXTURE_IMAGE_UNITS_NV     0x8872
+#define GL_FRAGMENT_PROGRAM_BINDING_NV    0x8873
+#define GL_PROGRAM_ERROR_STRING_NV        0x8874
+#endif
+
+#ifndef GL_NV_half_float
+#define GL_HALF_FLOAT_NV                  0x140B
+#endif
+
+#ifndef GL_NV_pixel_data_range
+#define GL_WRITE_PIXEL_DATA_RANGE_NV      0x8878
+#define GL_READ_PIXEL_DATA_RANGE_NV       0x8879
+#define GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV 0x887A
+#define GL_READ_PIXEL_DATA_RANGE_LENGTH_NV 0x887B
+#define GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV 0x887C
+#define GL_READ_PIXEL_DATA_RANGE_POINTER_NV 0x887D
+#endif
+
+#ifndef GL_NV_primitive_restart
+#define GL_PRIMITIVE_RESTART_NV           0x8558
+#define GL_PRIMITIVE_RESTART_INDEX_NV     0x8559
+#endif
+
+#ifndef GL_NV_texture_expand_normal
+#define GL_TEXTURE_UNSIGNED_REMAP_MODE_NV 0x888F
+#endif
+
+#ifndef GL_NV_vertex_program2
+#endif
+
+#ifndef GL_ATI_map_object_buffer
+#endif
+
+#ifndef GL_ATI_separate_stencil
+#define GL_STENCIL_BACK_FUNC_ATI          0x8800
+#define GL_STENCIL_BACK_FAIL_ATI          0x8801
+#define GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI 0x8802
+#define GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI 0x8803
+#endif
+
+#ifndef GL_ATI_vertex_attrib_array_object
+#endif
+
+#ifndef GL_OES_read_format
+#define GL_IMPLEMENTATION_COLOR_READ_TYPE_OES 0x8B9A
+#define GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES 0x8B9B
+#endif
+
+#ifndef GL_EXT_depth_bounds_test
+#define GL_DEPTH_BOUNDS_TEST_EXT          0x8890
+#define GL_DEPTH_BOUNDS_EXT               0x8891
+#endif
+
+#ifndef GL_EXT_texture_mirror_clamp
+#define GL_MIRROR_CLAMP_EXT               0x8742
+#define GL_MIRROR_CLAMP_TO_EDGE_EXT       0x8743
+#define GL_MIRROR_CLAMP_TO_BORDER_EXT     0x8912
+#endif
+
+#ifndef GL_EXT_blend_equation_separate
+#define GL_BLEND_EQUATION_RGB_EXT         0x8009
+#define GL_BLEND_EQUATION_ALPHA_EXT       0x883D
+#endif
+
+#ifndef GL_MESA_pack_invert
+#define GL_PACK_INVERT_MESA               0x8758
+#endif
+
+#ifndef GL_MESA_ycbcr_texture
+#define GL_UNSIGNED_SHORT_8_8_MESA        0x85BA
+#define GL_UNSIGNED_SHORT_8_8_REV_MESA    0x85BB
+#define GL_YCBCR_MESA                     0x8757
+#endif
+
+#ifndef GL_EXT_pixel_buffer_object
+#define GL_PIXEL_PACK_BUFFER_EXT          0x88EB
+#define GL_PIXEL_UNPACK_BUFFER_EXT        0x88EC
+#define GL_PIXEL_PACK_BUFFER_BINDING_EXT  0x88ED
+#define GL_PIXEL_UNPACK_BUFFER_BINDING_EXT 0x88EF
+#endif
+
+#ifndef GL_NV_fragment_program_option
+#endif
+
+#ifndef GL_NV_fragment_program2
+#define GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV 0x88F4
+#define GL_MAX_PROGRAM_CALL_DEPTH_NV      0x88F5
+#define GL_MAX_PROGRAM_IF_DEPTH_NV        0x88F6
+#define GL_MAX_PROGRAM_LOOP_DEPTH_NV      0x88F7
+#define GL_MAX_PROGRAM_LOOP_COUNT_NV      0x88F8
+#endif
+
+#ifndef GL_NV_vertex_program2_option
+/* reuse GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV */
+/* reuse GL_MAX_PROGRAM_CALL_DEPTH_NV */
+#endif
+
+#ifndef GL_NV_vertex_program3
+/* reuse GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB */
+#endif
+
+#ifndef GL_EXT_framebuffer_object
+#define GL_INVALID_FRAMEBUFFER_OPERATION_EXT 0x0506
+#define GL_MAX_RENDERBUFFER_SIZE_EXT      0x84E8
+#define GL_FRAMEBUFFER_BINDING_EXT        0x8CA6
+#define GL_RENDERBUFFER_BINDING_EXT       0x8CA7
+#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT 0x8CD0
+#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT 0x8CD1
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT 0x8CD2
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT 0x8CD3
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT 0x8CD4
+#define GL_FRAMEBUFFER_COMPLETE_EXT       0x8CD5
+#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT 0x8CD6
+#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT 0x8CD7
+#define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT 0x8CD9
+#define GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT 0x8CDA
+#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT 0x8CDB
+#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT 0x8CDC
+#define GL_FRAMEBUFFER_UNSUPPORTED_EXT    0x8CDD
+#define GL_MAX_COLOR_ATTACHMENTS_EXT      0x8CDF
+#define GL_COLOR_ATTACHMENT0_EXT          0x8CE0
+#define GL_COLOR_ATTACHMENT1_EXT          0x8CE1
+#define GL_COLOR_ATTACHMENT2_EXT          0x8CE2
+#define GL_COLOR_ATTACHMENT3_EXT          0x8CE3
+#define GL_COLOR_ATTACHMENT4_EXT          0x8CE4
+#define GL_COLOR_ATTACHMENT5_EXT          0x8CE5
+#define GL_COLOR_ATTACHMENT6_EXT          0x8CE6
+#define GL_COLOR_ATTACHMENT7_EXT          0x8CE7
+#define GL_COLOR_ATTACHMENT8_EXT          0x8CE8
+#define GL_COLOR_ATTACHMENT9_EXT          0x8CE9
+#define GL_COLOR_ATTACHMENT10_EXT         0x8CEA
+#define GL_COLOR_ATTACHMENT11_EXT         0x8CEB
+#define GL_COLOR_ATTACHMENT12_EXT         0x8CEC
+#define GL_COLOR_ATTACHMENT13_EXT         0x8CED
+#define GL_COLOR_ATTACHMENT14_EXT         0x8CEE
+#define GL_COLOR_ATTACHMENT15_EXT         0x8CEF
+#define GL_DEPTH_ATTACHMENT_EXT           0x8D00
+#define GL_STENCIL_ATTACHMENT_EXT         0x8D20
+#define GL_FRAMEBUFFER_EXT                0x8D40
+#define GL_RENDERBUFFER_EXT               0x8D41
+#define GL_RENDERBUFFER_WIDTH_EXT         0x8D42
+#define GL_RENDERBUFFER_HEIGHT_EXT        0x8D43
+#define GL_RENDERBUFFER_INTERNAL_FORMAT_EXT 0x8D44
+#define GL_STENCIL_INDEX1_EXT             0x8D46
+#define GL_STENCIL_INDEX4_EXT             0x8D47
+#define GL_STENCIL_INDEX8_EXT             0x8D48
+#define GL_STENCIL_INDEX16_EXT            0x8D49
+#define GL_RENDERBUFFER_RED_SIZE_EXT      0x8D50
+#define GL_RENDERBUFFER_GREEN_SIZE_EXT    0x8D51
+#define GL_RENDERBUFFER_BLUE_SIZE_EXT     0x8D52
+#define GL_RENDERBUFFER_ALPHA_SIZE_EXT    0x8D53
+#define GL_RENDERBUFFER_DEPTH_SIZE_EXT    0x8D54
+#define GL_RENDERBUFFER_STENCIL_SIZE_EXT  0x8D55
+#endif
+
+#ifndef GL_GREMEDY_string_marker
+#endif
+
+#ifndef GL_EXT_packed_depth_stencil
+#define GL_DEPTH_STENCIL_EXT              0x84F9
+#define GL_UNSIGNED_INT_24_8_EXT          0x84FA
+#define GL_DEPTH24_STENCIL8_EXT           0x88F0
+#define GL_TEXTURE_STENCIL_SIZE_EXT       0x88F1
+#endif
+
+#ifndef GL_EXT_stencil_clear_tag
+#define GL_STENCIL_TAG_BITS_EXT           0x88F2
+#define GL_STENCIL_CLEAR_TAG_VALUE_EXT    0x88F3
+#endif
+
+#ifndef GL_EXT_texture_sRGB
+#define GL_SRGB_EXT                       0x8C40
+#define GL_SRGB8_EXT                      0x8C41
+#define GL_SRGB_ALPHA_EXT                 0x8C42
+#define GL_SRGB8_ALPHA8_EXT               0x8C43
+#define GL_SLUMINANCE_ALPHA_EXT           0x8C44
+#define GL_SLUMINANCE8_ALPHA8_EXT         0x8C45
+#define GL_SLUMINANCE_EXT                 0x8C46
+#define GL_SLUMINANCE8_EXT                0x8C47
+#define GL_COMPRESSED_SRGB_EXT            0x8C48
+#define GL_COMPRESSED_SRGB_ALPHA_EXT      0x8C49
+#define GL_COMPRESSED_SLUMINANCE_EXT      0x8C4A
+#define GL_COMPRESSED_SLUMINANCE_ALPHA_EXT 0x8C4B
+#define GL_COMPRESSED_SRGB_S3TC_DXT1_EXT  0x8C4C
+#define GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT 0x8C4D
+#define GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT 0x8C4E
+#define GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT 0x8C4F
+#endif
+
+#ifndef GL_EXT_framebuffer_blit
+#define GL_READ_FRAMEBUFFER_EXT           0x8CA8
+#define GL_DRAW_FRAMEBUFFER_EXT           0x8CA9
+#define GL_DRAW_FRAMEBUFFER_BINDING_EXT   GL_FRAMEBUFFER_BINDING_EXT
+#define GL_READ_FRAMEBUFFER_BINDING_EXT   0x8CAA
+#endif
+
+#ifndef GL_EXT_framebuffer_multisample
+#define GL_RENDERBUFFER_SAMPLES_EXT       0x8CAB
+#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT 0x8D56
+#define GL_MAX_SAMPLES_EXT                0x8D57
+#endif
+
+#ifndef GL_MESAX_texture_stack
+#define GL_TEXTURE_1D_STACK_MESAX         0x8759
+#define GL_TEXTURE_2D_STACK_MESAX         0x875A
+#define GL_PROXY_TEXTURE_1D_STACK_MESAX   0x875B
+#define GL_PROXY_TEXTURE_2D_STACK_MESAX   0x875C
+#define GL_TEXTURE_1D_STACK_BINDING_MESAX 0x875D
+#define GL_TEXTURE_2D_STACK_BINDING_MESAX 0x875E
+#endif
+
+#ifndef GL_EXT_timer_query
+#define GL_TIME_ELAPSED_EXT               0x88BF
+#endif
+
+#ifndef GL_EXT_gpu_program_parameters
+#endif
+
+#ifndef GL_APPLE_flush_buffer_range
+#define GL_BUFFER_SERIALIZED_MODIFY_APPLE 0x8A12
+#define GL_BUFFER_FLUSHING_UNMAP_APPLE    0x8A13
+#endif
+
+#ifndef GL_NV_gpu_program4
+#define GL_MIN_PROGRAM_TEXEL_OFFSET_NV    0x8904
+#define GL_MAX_PROGRAM_TEXEL_OFFSET_NV    0x8905
+#define GL_PROGRAM_ATTRIB_COMPONENTS_NV   0x8906
+#define GL_PROGRAM_RESULT_COMPONENTS_NV   0x8907
+#define GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV 0x8908
+#define GL_MAX_PROGRAM_RESULT_COMPONENTS_NV 0x8909
+#define GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV 0x8DA5
+#define GL_MAX_PROGRAM_GENERIC_RESULTS_NV 0x8DA6
+#endif
+
+#ifndef GL_NV_geometry_program4
+#define GL_LINES_ADJACENCY_EXT            0x000A
+#define GL_LINE_STRIP_ADJACENCY_EXT       0x000B
+#define GL_TRIANGLES_ADJACENCY_EXT        0x000C
+#define GL_TRIANGLE_STRIP_ADJACENCY_EXT   0x000D
+#define GL_GEOMETRY_PROGRAM_NV            0x8C26
+#define GL_MAX_PROGRAM_OUTPUT_VERTICES_NV 0x8C27
+#define GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV 0x8C28
+#define GL_GEOMETRY_VERTICES_OUT_EXT      0x8DDA
+#define GL_GEOMETRY_INPUT_TYPE_EXT        0x8DDB
+#define GL_GEOMETRY_OUTPUT_TYPE_EXT       0x8DDC
+#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT 0x8C29
+#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT 0x8DA7
+#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT 0x8DA8
+#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT 0x8DA9
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT 0x8CD4
+#define GL_PROGRAM_POINT_SIZE_EXT         0x8642
+#endif
+
+#ifndef GL_EXT_geometry_shader4
+#define GL_GEOMETRY_SHADER_EXT            0x8DD9
+/* reuse GL_GEOMETRY_VERTICES_OUT_EXT */
+/* reuse GL_GEOMETRY_INPUT_TYPE_EXT */
+/* reuse GL_GEOMETRY_OUTPUT_TYPE_EXT */
+/* reuse GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT */
+#define GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT 0x8DDD
+#define GL_MAX_VERTEX_VARYING_COMPONENTS_EXT 0x8DDE
+#define GL_MAX_VARYING_COMPONENTS_EXT     0x8B4B
+#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT 0x8DDF
+#define GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT 0x8DE0
+#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT 0x8DE1
+/* reuse GL_LINES_ADJACENCY_EXT */
+/* reuse GL_LINE_STRIP_ADJACENCY_EXT */
+/* reuse GL_TRIANGLES_ADJACENCY_EXT */
+/* reuse GL_TRIANGLE_STRIP_ADJACENCY_EXT */
+/* reuse GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT */
+/* reuse GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT */
+/* reuse GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT */
+/* reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT */
+/* reuse GL_PROGRAM_POINT_SIZE_EXT */
+#endif
+
+#ifndef GL_NV_vertex_program4
+#define GL_VERTEX_ATTRIB_ARRAY_INTEGER_NV 0x88FD
+#endif
+
+#ifndef GL_EXT_gpu_shader4
+#define GL_SAMPLER_1D_ARRAY_EXT           0x8DC0
+#define GL_SAMPLER_2D_ARRAY_EXT           0x8DC1
+#define GL_SAMPLER_BUFFER_EXT             0x8DC2
+#define GL_SAMPLER_1D_ARRAY_SHADOW_EXT    0x8DC3
+#define GL_SAMPLER_2D_ARRAY_SHADOW_EXT    0x8DC4
+#define GL_SAMPLER_CUBE_SHADOW_EXT        0x8DC5
+#define GL_UNSIGNED_INT_VEC2_EXT          0x8DC6
+#define GL_UNSIGNED_INT_VEC3_EXT          0x8DC7
+#define GL_UNSIGNED_INT_VEC4_EXT          0x8DC8
+#define GL_INT_SAMPLER_1D_EXT             0x8DC9
+#define GL_INT_SAMPLER_2D_EXT             0x8DCA
+#define GL_INT_SAMPLER_3D_EXT             0x8DCB
+#define GL_INT_SAMPLER_CUBE_EXT           0x8DCC
+#define GL_INT_SAMPLER_2D_RECT_EXT        0x8DCD
+#define GL_INT_SAMPLER_1D_ARRAY_EXT       0x8DCE
+#define GL_INT_SAMPLER_2D_ARRAY_EXT       0x8DCF
+#define GL_INT_SAMPLER_BUFFER_EXT         0x8DD0
+#define GL_UNSIGNED_INT_SAMPLER_1D_EXT    0x8DD1
+#define GL_UNSIGNED_INT_SAMPLER_2D_EXT    0x8DD2
+#define GL_UNSIGNED_INT_SAMPLER_3D_EXT    0x8DD3
+#define GL_UNSIGNED_INT_SAMPLER_CUBE_EXT  0x8DD4
+#define GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT 0x8DD5
+#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT 0x8DD6
+#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT 0x8DD7
+#define GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT 0x8DD8
+#endif
+
+#ifndef GL_EXT_draw_instanced
+#endif
+
+#ifndef GL_EXT_packed_float
+#define GL_R11F_G11F_B10F_EXT             0x8C3A
+#define GL_UNSIGNED_INT_10F_11F_11F_REV_EXT 0x8C3B
+#define GL_RGBA_SIGNED_COMPONENTS_EXT     0x8C3C
+#endif
+
+#ifndef GL_EXT_texture_array
+#define GL_TEXTURE_1D_ARRAY_EXT           0x8C18
+#define GL_PROXY_TEXTURE_1D_ARRAY_EXT     0x8C19
+#define GL_TEXTURE_2D_ARRAY_EXT           0x8C1A
+#define GL_PROXY_TEXTURE_2D_ARRAY_EXT     0x8C1B
+#define GL_TEXTURE_BINDING_1D_ARRAY_EXT   0x8C1C
+#define GL_TEXTURE_BINDING_2D_ARRAY_EXT   0x8C1D
+#define GL_MAX_ARRAY_TEXTURE_LAYERS_EXT   0x88FF
+#define GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT 0x884E
+/* reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT */
+#endif
+
+#ifndef GL_EXT_texture_buffer_object
+#define GL_TEXTURE_BUFFER_EXT             0x8C2A
+#define GL_MAX_TEXTURE_BUFFER_SIZE_EXT    0x8C2B
+#define GL_TEXTURE_BINDING_BUFFER_EXT     0x8C2C
+#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT 0x8C2D
+#define GL_TEXTURE_BUFFER_FORMAT_EXT      0x8C2E
+#endif
+
+#ifndef GL_EXT_texture_compression_latc
+#define GL_COMPRESSED_LUMINANCE_LATC1_EXT 0x8C70
+#define GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT 0x8C71
+#define GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT 0x8C72
+#define GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT 0x8C73
+#endif
+
+#ifndef GL_EXT_texture_compression_rgtc
+#define GL_COMPRESSED_RED_RGTC1_EXT       0x8DBB
+#define GL_COMPRESSED_SIGNED_RED_RGTC1_EXT 0x8DBC
+#define GL_COMPRESSED_RED_GREEN_RGTC2_EXT 0x8DBD
+#define GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT 0x8DBE
+#endif
+
+#ifndef GL_EXT_texture_shared_exponent
+#define GL_RGB9_E5_EXT                    0x8C3D
+#define GL_UNSIGNED_INT_5_9_9_9_REV_EXT   0x8C3E
+#define GL_TEXTURE_SHARED_SIZE_EXT        0x8C3F
+#endif
+
+#ifndef GL_NV_depth_buffer_float
+#define GL_DEPTH_COMPONENT32F_NV          0x8DAB
+#define GL_DEPTH32F_STENCIL8_NV           0x8DAC
+#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV 0x8DAD
+#define GL_DEPTH_BUFFER_FLOAT_MODE_NV     0x8DAF
+#endif
+
+#ifndef GL_NV_fragment_program4
+#endif
+
+#ifndef GL_NV_framebuffer_multisample_coverage
+#define GL_RENDERBUFFER_COVERAGE_SAMPLES_NV 0x8CAB
+#define GL_RENDERBUFFER_COLOR_SAMPLES_NV  0x8E10
+#define GL_MAX_MULTISAMPLE_COVERAGE_MODES_NV 0x8E11
+#define GL_MULTISAMPLE_COVERAGE_MODES_NV  0x8E12
+#endif
+
+#ifndef GL_EXT_framebuffer_sRGB
+#define GL_FRAMEBUFFER_SRGB_EXT           0x8DB9
+#define GL_FRAMEBUFFER_SRGB_CAPABLE_EXT   0x8DBA
+#endif
+
+#ifndef GL_NV_geometry_shader4
+#endif
+
+#ifndef GL_NV_parameter_buffer_object
+#define GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV 0x8DA0
+#define GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV 0x8DA1
+#define GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV 0x8DA2
+#define GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV 0x8DA3
+#define GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV 0x8DA4
+#endif
+
+#ifndef GL_EXT_draw_buffers2
+#endif
+
+#ifndef GL_NV_transform_feedback
+#define GL_BACK_PRIMARY_COLOR_NV          0x8C77
+#define GL_BACK_SECONDARY_COLOR_NV        0x8C78
+#define GL_TEXTURE_COORD_NV               0x8C79
+#define GL_CLIP_DISTANCE_NV               0x8C7A
+#define GL_VERTEX_ID_NV                   0x8C7B
+#define GL_PRIMITIVE_ID_NV                0x8C7C
+#define GL_GENERIC_ATTRIB_NV              0x8C7D
+#define GL_TRANSFORM_FEEDBACK_ATTRIBS_NV  0x8C7E
+#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV 0x8C7F
+#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV 0x8C80
+#define GL_ACTIVE_VARYINGS_NV             0x8C81
+#define GL_ACTIVE_VARYING_MAX_LENGTH_NV   0x8C82
+#define GL_TRANSFORM_FEEDBACK_VARYINGS_NV 0x8C83
+#define GL_TRANSFORM_FEEDBACK_BUFFER_START_NV 0x8C84
+#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV 0x8C85
+#define GL_TRANSFORM_FEEDBACK_RECORD_NV   0x8C86
+#define GL_PRIMITIVES_GENERATED_NV        0x8C87
+#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV 0x8C88
+#define GL_RASTERIZER_DISCARD_NV          0x8C89
+#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_ATTRIBS_NV 0x8C8A
+#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV 0x8C8B
+#define GL_INTERLEAVED_ATTRIBS_NV         0x8C8C
+#define GL_SEPARATE_ATTRIBS_NV            0x8C8D
+#define GL_TRANSFORM_FEEDBACK_BUFFER_NV   0x8C8E
+#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV 0x8C8F
+#define GL_LAYER_NV                       0x8DAA
+#define GL_NEXT_BUFFER_NV                 -2
+#define GL_SKIP_COMPONENTS4_NV            -3
+#define GL_SKIP_COMPONENTS3_NV            -4
+#define GL_SKIP_COMPONENTS2_NV            -5
+#define GL_SKIP_COMPONENTS1_NV            -6
+#endif
+
+#ifndef GL_EXT_bindable_uniform
+#define GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT 0x8DE2
+#define GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT 0x8DE3
+#define GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT 0x8DE4
+#define GL_MAX_BINDABLE_UNIFORM_SIZE_EXT  0x8DED
+#define GL_UNIFORM_BUFFER_EXT             0x8DEE
+#define GL_UNIFORM_BUFFER_BINDING_EXT     0x8DEF
+#endif
+
+#ifndef GL_EXT_texture_integer
+#define GL_RGBA32UI_EXT                   0x8D70
+#define GL_RGB32UI_EXT                    0x8D71
+#define GL_ALPHA32UI_EXT                  0x8D72
+#define GL_INTENSITY32UI_EXT              0x8D73
+#define GL_LUMINANCE32UI_EXT              0x8D74
+#define GL_LUMINANCE_ALPHA32UI_EXT        0x8D75
+#define GL_RGBA16UI_EXT                   0x8D76
+#define GL_RGB16UI_EXT                    0x8D77
+#define GL_ALPHA16UI_EXT                  0x8D78
+#define GL_INTENSITY16UI_EXT              0x8D79
+#define GL_LUMINANCE16UI_EXT              0x8D7A
+#define GL_LUMINANCE_ALPHA16UI_EXT        0x8D7B
+#define GL_RGBA8UI_EXT                    0x8D7C
+#define GL_RGB8UI_EXT                     0x8D7D
+#define GL_ALPHA8UI_EXT                   0x8D7E
+#define GL_INTENSITY8UI_EXT               0x8D7F
+#define GL_LUMINANCE8UI_EXT               0x8D80
+#define GL_LUMINANCE_ALPHA8UI_EXT         0x8D81
+#define GL_RGBA32I_EXT                    0x8D82
+#define GL_RGB32I_EXT                     0x8D83
+#define GL_ALPHA32I_EXT                   0x8D84
+#define GL_INTENSITY32I_EXT               0x8D85
+#define GL_LUMINANCE32I_EXT               0x8D86
+#define GL_LUMINANCE_ALPHA32I_EXT         0x8D87
+#define GL_RGBA16I_EXT                    0x8D88
+#define GL_RGB16I_EXT                     0x8D89
+#define GL_ALPHA16I_EXT                   0x8D8A
+#define GL_INTENSITY16I_EXT               0x8D8B
+#define GL_LUMINANCE16I_EXT               0x8D8C
+#define GL_LUMINANCE_ALPHA16I_EXT         0x8D8D
+#define GL_RGBA8I_EXT                     0x8D8E
+#define GL_RGB8I_EXT                      0x8D8F
+#define GL_ALPHA8I_EXT                    0x8D90
+#define GL_INTENSITY8I_EXT                0x8D91
+#define GL_LUMINANCE8I_EXT                0x8D92
+#define GL_LUMINANCE_ALPHA8I_EXT          0x8D93
+#define GL_RED_INTEGER_EXT                0x8D94
+#define GL_GREEN_INTEGER_EXT              0x8D95
+#define GL_BLUE_INTEGER_EXT               0x8D96
+#define GL_ALPHA_INTEGER_EXT              0x8D97
+#define GL_RGB_INTEGER_EXT                0x8D98
+#define GL_RGBA_INTEGER_EXT               0x8D99
+#define GL_BGR_INTEGER_EXT                0x8D9A
+#define GL_BGRA_INTEGER_EXT               0x8D9B
+#define GL_LUMINANCE_INTEGER_EXT          0x8D9C
+#define GL_LUMINANCE_ALPHA_INTEGER_EXT    0x8D9D
+#define GL_RGBA_INTEGER_MODE_EXT          0x8D9E
+#endif
+
+#ifndef GL_GREMEDY_frame_terminator
+#endif
+
+#ifndef GL_NV_conditional_render
+#define GL_QUERY_WAIT_NV                  0x8E13
+#define GL_QUERY_NO_WAIT_NV               0x8E14
+#define GL_QUERY_BY_REGION_WAIT_NV        0x8E15
+#define GL_QUERY_BY_REGION_NO_WAIT_NV     0x8E16
+#endif
+
+#ifndef GL_NV_present_video
+#define GL_FRAME_NV                       0x8E26
+#define GL_FIELDS_NV                      0x8E27
+#define GL_CURRENT_TIME_NV                0x8E28
+#define GL_NUM_FILL_STREAMS_NV            0x8E29
+#define GL_PRESENT_TIME_NV                0x8E2A
+#define GL_PRESENT_DURATION_NV            0x8E2B
+#endif
+
+#ifndef GL_EXT_transform_feedback
+#define GL_TRANSFORM_FEEDBACK_BUFFER_EXT  0x8C8E
+#define GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT 0x8C84
+#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT 0x8C85
+#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT 0x8C8F
+#define GL_INTERLEAVED_ATTRIBS_EXT        0x8C8C
+#define GL_SEPARATE_ATTRIBS_EXT           0x8C8D
+#define GL_PRIMITIVES_GENERATED_EXT       0x8C87
+#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT 0x8C88
+#define GL_RASTERIZER_DISCARD_EXT         0x8C89
+#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT 0x8C8A
+#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT 0x8C8B
+#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT 0x8C80
+#define GL_TRANSFORM_FEEDBACK_VARYINGS_EXT 0x8C83
+#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT 0x8C7F
+#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT 0x8C76
+#endif
+
+#ifndef GL_EXT_direct_state_access
+#define GL_PROGRAM_MATRIX_EXT             0x8E2D
+#define GL_TRANSPOSE_PROGRAM_MATRIX_EXT   0x8E2E
+#define GL_PROGRAM_MATRIX_STACK_DEPTH_EXT 0x8E2F
+#endif
+
+#ifndef GL_EXT_vertex_array_bgra
+/* reuse GL_BGRA */
+#endif
+
+#ifndef GL_EXT_texture_swizzle
+#define GL_TEXTURE_SWIZZLE_R_EXT          0x8E42
+#define GL_TEXTURE_SWIZZLE_G_EXT          0x8E43
+#define GL_TEXTURE_SWIZZLE_B_EXT          0x8E44
+#define GL_TEXTURE_SWIZZLE_A_EXT          0x8E45
+#define GL_TEXTURE_SWIZZLE_RGBA_EXT       0x8E46
+#endif
+
+#ifndef GL_NV_explicit_multisample
+#define GL_SAMPLE_POSITION_NV             0x8E50
+#define GL_SAMPLE_MASK_NV                 0x8E51
+#define GL_SAMPLE_MASK_VALUE_NV           0x8E52
+#define GL_TEXTURE_BINDING_RENDERBUFFER_NV 0x8E53
+#define GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV 0x8E54
+#define GL_TEXTURE_RENDERBUFFER_NV        0x8E55
+#define GL_SAMPLER_RENDERBUFFER_NV        0x8E56
+#define GL_INT_SAMPLER_RENDERBUFFER_NV    0x8E57
+#define GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV 0x8E58
+#define GL_MAX_SAMPLE_MASK_WORDS_NV       0x8E59
+#endif
+
+#ifndef GL_NV_transform_feedback2
+#define GL_TRANSFORM_FEEDBACK_NV          0x8E22
+#define GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV 0x8E23
+#define GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV 0x8E24
+#define GL_TRANSFORM_FEEDBACK_BINDING_NV  0x8E25
+#endif
+
+#ifndef GL_ATI_meminfo
+#define GL_VBO_FREE_MEMORY_ATI            0x87FB
+#define GL_TEXTURE_FREE_MEMORY_ATI        0x87FC
+#define GL_RENDERBUFFER_FREE_MEMORY_ATI   0x87FD
+#endif
+
+#ifndef GL_AMD_performance_monitor
+#define GL_COUNTER_TYPE_AMD               0x8BC0
+#define GL_COUNTER_RANGE_AMD              0x8BC1
+#define GL_UNSIGNED_INT64_AMD             0x8BC2
+#define GL_PERCENTAGE_AMD                 0x8BC3
+#define GL_PERFMON_RESULT_AVAILABLE_AMD   0x8BC4
+#define GL_PERFMON_RESULT_SIZE_AMD        0x8BC5
+#define GL_PERFMON_RESULT_AMD             0x8BC6
+#endif
+
+#ifndef GL_AMD_texture_texture4
+#endif
+
+#ifndef GL_AMD_vertex_shader_tesselator
+#define GL_SAMPLER_BUFFER_AMD             0x9001
+#define GL_INT_SAMPLER_BUFFER_AMD         0x9002
+#define GL_UNSIGNED_INT_SAMPLER_BUFFER_AMD 0x9003
+#define GL_TESSELLATION_MODE_AMD          0x9004
+#define GL_TESSELLATION_FACTOR_AMD        0x9005
+#define GL_DISCRETE_AMD                   0x9006
+#define GL_CONTINUOUS_AMD                 0x9007
+#endif
+
+#ifndef GL_EXT_provoking_vertex
+#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT 0x8E4C
+#define GL_FIRST_VERTEX_CONVENTION_EXT    0x8E4D
+#define GL_LAST_VERTEX_CONVENTION_EXT     0x8E4E
+#define GL_PROVOKING_VERTEX_EXT           0x8E4F
+#endif
+
+#ifndef GL_EXT_texture_snorm
+#define GL_ALPHA_SNORM                    0x9010
+#define GL_LUMINANCE_SNORM                0x9011
+#define GL_LUMINANCE_ALPHA_SNORM          0x9012
+#define GL_INTENSITY_SNORM                0x9013
+#define GL_ALPHA8_SNORM                   0x9014
+#define GL_LUMINANCE8_SNORM               0x9015
+#define GL_LUMINANCE8_ALPHA8_SNORM        0x9016
+#define GL_INTENSITY8_SNORM               0x9017
+#define GL_ALPHA16_SNORM                  0x9018
+#define GL_LUMINANCE16_SNORM              0x9019
+#define GL_LUMINANCE16_ALPHA16_SNORM      0x901A
+#define GL_INTENSITY16_SNORM              0x901B
+/* reuse GL_RED_SNORM */
+/* reuse GL_RG_SNORM */
+/* reuse GL_RGB_SNORM */
+/* reuse GL_RGBA_SNORM */
+/* reuse GL_R8_SNORM */
+/* reuse GL_RG8_SNORM */
+/* reuse GL_RGB8_SNORM */
+/* reuse GL_RGBA8_SNORM */
+/* reuse GL_R16_SNORM */
+/* reuse GL_RG16_SNORM */
+/* reuse GL_RGB16_SNORM */
+/* reuse GL_RGBA16_SNORM */
+/* reuse GL_SIGNED_NORMALIZED */
+#endif
+
+#ifndef GL_AMD_draw_buffers_blend
+#endif
+
+#ifndef GL_APPLE_texture_range
+#define GL_TEXTURE_RANGE_LENGTH_APPLE     0x85B7
+#define GL_TEXTURE_RANGE_POINTER_APPLE    0x85B8
+#define GL_TEXTURE_STORAGE_HINT_APPLE     0x85BC
+#define GL_STORAGE_PRIVATE_APPLE          0x85BD
+/* reuse GL_STORAGE_CACHED_APPLE */
+/* reuse GL_STORAGE_SHARED_APPLE */
+#endif
+
+#ifndef GL_APPLE_float_pixels
+#define GL_HALF_APPLE                     0x140B
+#define GL_RGBA_FLOAT32_APPLE             0x8814
+#define GL_RGB_FLOAT32_APPLE              0x8815
+#define GL_ALPHA_FLOAT32_APPLE            0x8816
+#define GL_INTENSITY_FLOAT32_APPLE        0x8817
+#define GL_LUMINANCE_FLOAT32_APPLE        0x8818
+#define GL_LUMINANCE_ALPHA_FLOAT32_APPLE  0x8819
+#define GL_RGBA_FLOAT16_APPLE             0x881A
+#define GL_RGB_FLOAT16_APPLE              0x881B
+#define GL_ALPHA_FLOAT16_APPLE            0x881C
+#define GL_INTENSITY_FLOAT16_APPLE        0x881D
+#define GL_LUMINANCE_FLOAT16_APPLE        0x881E
+#define GL_LUMINANCE_ALPHA_FLOAT16_APPLE  0x881F
+#define GL_COLOR_FLOAT_APPLE              0x8A0F
+#endif
+
+#ifndef GL_APPLE_vertex_program_evaluators
+#define GL_VERTEX_ATTRIB_MAP1_APPLE       0x8A00
+#define GL_VERTEX_ATTRIB_MAP2_APPLE       0x8A01
+#define GL_VERTEX_ATTRIB_MAP1_SIZE_APPLE  0x8A02
+#define GL_VERTEX_ATTRIB_MAP1_COEFF_APPLE 0x8A03
+#define GL_VERTEX_ATTRIB_MAP1_ORDER_APPLE 0x8A04
+#define GL_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE 0x8A05
+#define GL_VERTEX_ATTRIB_MAP2_SIZE_APPLE  0x8A06
+#define GL_VERTEX_ATTRIB_MAP2_COEFF_APPLE 0x8A07
+#define GL_VERTEX_ATTRIB_MAP2_ORDER_APPLE 0x8A08
+#define GL_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE 0x8A09
+#endif
+
+#ifndef GL_APPLE_aux_depth_stencil
+#define GL_AUX_DEPTH_STENCIL_APPLE        0x8A14
+#endif
+
+#ifndef GL_APPLE_object_purgeable
+#define GL_BUFFER_OBJECT_APPLE            0x85B3
+#define GL_RELEASED_APPLE                 0x8A19
+#define GL_VOLATILE_APPLE                 0x8A1A
+#define GL_RETAINED_APPLE                 0x8A1B
+#define GL_UNDEFINED_APPLE                0x8A1C
+#define GL_PURGEABLE_APPLE                0x8A1D
+#endif
+
+#ifndef GL_APPLE_row_bytes
+#define GL_PACK_ROW_BYTES_APPLE           0x8A15
+#define GL_UNPACK_ROW_BYTES_APPLE         0x8A16
+#endif
+
+#ifndef GL_APPLE_rgb_422
+#define GL_RGB_422_APPLE                  0x8A1F
+/* reuse GL_UNSIGNED_SHORT_8_8_APPLE */
+/* reuse GL_UNSIGNED_SHORT_8_8_REV_APPLE */
+#endif
+
+#ifndef GL_NV_video_capture
+#define GL_VIDEO_BUFFER_NV                0x9020
+#define GL_VIDEO_BUFFER_BINDING_NV        0x9021
+#define GL_FIELD_UPPER_NV                 0x9022
+#define GL_FIELD_LOWER_NV                 0x9023
+#define GL_NUM_VIDEO_CAPTURE_STREAMS_NV   0x9024
+#define GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV 0x9025
+#define GL_VIDEO_CAPTURE_TO_422_SUPPORTED_NV 0x9026
+#define GL_LAST_VIDEO_CAPTURE_STATUS_NV   0x9027
+#define GL_VIDEO_BUFFER_PITCH_NV          0x9028
+#define GL_VIDEO_COLOR_CONVERSION_MATRIX_NV 0x9029
+#define GL_VIDEO_COLOR_CONVERSION_MAX_NV  0x902A
+#define GL_VIDEO_COLOR_CONVERSION_MIN_NV  0x902B
+#define GL_VIDEO_COLOR_CONVERSION_OFFSET_NV 0x902C
+#define GL_VIDEO_BUFFER_INTERNAL_FORMAT_NV 0x902D
+#define GL_PARTIAL_SUCCESS_NV             0x902E
+#define GL_SUCCESS_NV                     0x902F
+#define GL_FAILURE_NV                     0x9030
+#define GL_YCBYCR8_422_NV                 0x9031
+#define GL_YCBAYCR8A_4224_NV              0x9032
+#define GL_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV  0x9033
+#define GL_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV 0x9034
+#define GL_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV  0x9035
+#define GL_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV 0x9036
+#define GL_Z4Y12Z4CB12Z4CR12_444_NV       0x9037
+#define GL_VIDEO_CAPTURE_FRAME_WIDTH_NV   0x9038
+#define GL_VIDEO_CAPTURE_FRAME_HEIGHT_NV  0x9039
+#define GL_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV 0x903A
+#define GL_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV 0x903B
+#define GL_VIDEO_CAPTURE_SURFACE_ORIGIN_NV 0x903C
+#endif
+
+#ifndef GL_NV_copy_image
+#endif
+
+#ifndef GL_EXT_separate_shader_objects
+#define GL_ACTIVE_PROGRAM_EXT             0x8B8D
+#endif
+
+#ifndef GL_NV_parameter_buffer_object2
+#endif
+
+#ifndef GL_NV_shader_buffer_load
+#define GL_BUFFER_GPU_ADDRESS_NV          0x8F1D
+#define GL_GPU_ADDRESS_NV                 0x8F34
+#define GL_MAX_SHADER_BUFFER_ADDRESS_NV   0x8F35
+#endif
+
+#ifndef GL_NV_vertex_buffer_unified_memory
+#define GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV 0x8F1E
+#define GL_ELEMENT_ARRAY_UNIFIED_NV       0x8F1F
+#define GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV 0x8F20
+#define GL_VERTEX_ARRAY_ADDRESS_NV        0x8F21
+#define GL_NORMAL_ARRAY_ADDRESS_NV        0x8F22
+#define GL_COLOR_ARRAY_ADDRESS_NV         0x8F23
+#define GL_INDEX_ARRAY_ADDRESS_NV         0x8F24
+#define GL_TEXTURE_COORD_ARRAY_ADDRESS_NV 0x8F25
+#define GL_EDGE_FLAG_ARRAY_ADDRESS_NV     0x8F26
+#define GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV 0x8F27
+#define GL_FOG_COORD_ARRAY_ADDRESS_NV     0x8F28
+#define GL_ELEMENT_ARRAY_ADDRESS_NV       0x8F29
+#define GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV  0x8F2A
+#define GL_VERTEX_ARRAY_LENGTH_NV         0x8F2B
+#define GL_NORMAL_ARRAY_LENGTH_NV         0x8F2C
+#define GL_COLOR_ARRAY_LENGTH_NV          0x8F2D
+#define GL_INDEX_ARRAY_LENGTH_NV          0x8F2E
+#define GL_TEXTURE_COORD_ARRAY_LENGTH_NV  0x8F2F
+#define GL_EDGE_FLAG_ARRAY_LENGTH_NV      0x8F30
+#define GL_SECONDARY_COLOR_ARRAY_LENGTH_NV 0x8F31
+#define GL_FOG_COORD_ARRAY_LENGTH_NV      0x8F32
+#define GL_ELEMENT_ARRAY_LENGTH_NV        0x8F33
+#define GL_DRAW_INDIRECT_UNIFIED_NV       0x8F40
+#define GL_DRAW_INDIRECT_ADDRESS_NV       0x8F41
+#define GL_DRAW_INDIRECT_LENGTH_NV        0x8F42
+#endif
+
+#ifndef GL_NV_texture_barrier
+#endif
+
+#ifndef GL_AMD_shader_stencil_export
+#endif
+
+#ifndef GL_AMD_seamless_cubemap_per_texture
+/* reuse GL_TEXTURE_CUBE_MAP_SEAMLESS_ARB */
+#endif
+
+#ifndef GL_AMD_conservative_depth
+#endif
+
+#ifndef GL_EXT_shader_image_load_store
+#define GL_MAX_IMAGE_UNITS_EXT            0x8F38
+#define GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT 0x8F39
+#define GL_IMAGE_BINDING_NAME_EXT         0x8F3A
+#define GL_IMAGE_BINDING_LEVEL_EXT        0x8F3B
+#define GL_IMAGE_BINDING_LAYERED_EXT      0x8F3C
+#define GL_IMAGE_BINDING_LAYER_EXT        0x8F3D
+#define GL_IMAGE_BINDING_ACCESS_EXT       0x8F3E
+#define GL_IMAGE_1D_EXT                   0x904C
+#define GL_IMAGE_2D_EXT                   0x904D
+#define GL_IMAGE_3D_EXT                   0x904E
+#define GL_IMAGE_2D_RECT_EXT              0x904F
+#define GL_IMAGE_CUBE_EXT                 0x9050
+#define GL_IMAGE_BUFFER_EXT               0x9051
+#define GL_IMAGE_1D_ARRAY_EXT             0x9052
+#define GL_IMAGE_2D_ARRAY_EXT             0x9053
+#define GL_IMAGE_CUBE_MAP_ARRAY_EXT       0x9054
+#define GL_IMAGE_2D_MULTISAMPLE_EXT       0x9055
+#define GL_IMAGE_2D_MULTISAMPLE_ARRAY_EXT 0x9056
+#define GL_INT_IMAGE_1D_EXT               0x9057
+#define GL_INT_IMAGE_2D_EXT               0x9058
+#define GL_INT_IMAGE_3D_EXT               0x9059
+#define GL_INT_IMAGE_2D_RECT_EXT          0x905A
+#define GL_INT_IMAGE_CUBE_EXT             0x905B
+#define GL_INT_IMAGE_BUFFER_EXT           0x905C
+#define GL_INT_IMAGE_1D_ARRAY_EXT         0x905D
+#define GL_INT_IMAGE_2D_ARRAY_EXT         0x905E
+#define GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT   0x905F
+#define GL_INT_IMAGE_2D_MULTISAMPLE_EXT   0x9060
+#define GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT 0x9061
+#define GL_UNSIGNED_INT_IMAGE_1D_EXT      0x9062
+#define GL_UNSIGNED_INT_IMAGE_2D_EXT      0x9063
+#define GL_UNSIGNED_INT_IMAGE_3D_EXT      0x9064
+#define GL_UNSIGNED_INT_IMAGE_2D_RECT_EXT 0x9065
+#define GL_UNSIGNED_INT_IMAGE_CUBE_EXT    0x9066
+#define GL_UNSIGNED_INT_IMAGE_BUFFER_EXT  0x9067
+#define GL_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT 0x9068
+#define GL_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT 0x9069
+#define GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT 0x906A
+#define GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT 0x906B
+#define GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT 0x906C
+#define GL_MAX_IMAGE_SAMPLES_EXT          0x906D
+#define GL_IMAGE_BINDING_FORMAT_EXT       0x906E
+#define GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT 0x00000001
+#define GL_ELEMENT_ARRAY_BARRIER_BIT_EXT  0x00000002
+#define GL_UNIFORM_BARRIER_BIT_EXT        0x00000004
+#define GL_TEXTURE_FETCH_BARRIER_BIT_EXT  0x00000008
+#define GL_SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT 0x00000020
+#define GL_COMMAND_BARRIER_BIT_EXT        0x00000040
+#define GL_PIXEL_BUFFER_BARRIER_BIT_EXT   0x00000080
+#define GL_TEXTURE_UPDATE_BARRIER_BIT_EXT 0x00000100
+#define GL_BUFFER_UPDATE_BARRIER_BIT_EXT  0x00000200
+#define GL_FRAMEBUFFER_BARRIER_BIT_EXT    0x00000400
+#define GL_TRANSFORM_FEEDBACK_BARRIER_BIT_EXT 0x00000800
+#define GL_ATOMIC_COUNTER_BARRIER_BIT_EXT 0x00001000
+#define GL_ALL_BARRIER_BITS_EXT           0xFFFFFFFF
+#endif
+
+#ifndef GL_EXT_vertex_attrib_64bit
+/* reuse GL_DOUBLE */
+#define GL_DOUBLE_VEC2_EXT                0x8FFC
+#define GL_DOUBLE_VEC3_EXT                0x8FFD
+#define GL_DOUBLE_VEC4_EXT                0x8FFE
+#define GL_DOUBLE_MAT2_EXT                0x8F46
+#define GL_DOUBLE_MAT3_EXT                0x8F47
+#define GL_DOUBLE_MAT4_EXT                0x8F48
+#define GL_DOUBLE_MAT2x3_EXT              0x8F49
+#define GL_DOUBLE_MAT2x4_EXT              0x8F4A
+#define GL_DOUBLE_MAT3x2_EXT              0x8F4B
+#define GL_DOUBLE_MAT3x4_EXT              0x8F4C
+#define GL_DOUBLE_MAT4x2_EXT              0x8F4D
+#define GL_DOUBLE_MAT4x3_EXT              0x8F4E
+#endif
+
+#ifndef GL_NV_gpu_program5
+#define GL_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV 0x8E5A
+#define GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV 0x8E5B
+#define GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV 0x8E5C
+#define GL_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV 0x8E5D
+#define GL_MAX_PROGRAM_SUBROUTINE_PARAMETERS_NV 0x8F44
+#define GL_MAX_PROGRAM_SUBROUTINE_NUM_NV  0x8F45
+#endif
+
+#ifndef GL_NV_gpu_shader5
+#define GL_INT64_NV                       0x140E
+#define GL_UNSIGNED_INT64_NV              0x140F
+#define GL_INT8_NV                        0x8FE0
+#define GL_INT8_VEC2_NV                   0x8FE1
+#define GL_INT8_VEC3_NV                   0x8FE2
+#define GL_INT8_VEC4_NV                   0x8FE3
+#define GL_INT16_NV                       0x8FE4
+#define GL_INT16_VEC2_NV                  0x8FE5
+#define GL_INT16_VEC3_NV                  0x8FE6
+#define GL_INT16_VEC4_NV                  0x8FE7
+#define GL_INT64_VEC2_NV                  0x8FE9
+#define GL_INT64_VEC3_NV                  0x8FEA
+#define GL_INT64_VEC4_NV                  0x8FEB
+#define GL_UNSIGNED_INT8_NV               0x8FEC
+#define GL_UNSIGNED_INT8_VEC2_NV          0x8FED
+#define GL_UNSIGNED_INT8_VEC3_NV          0x8FEE
+#define GL_UNSIGNED_INT8_VEC4_NV          0x8FEF
+#define GL_UNSIGNED_INT16_NV              0x8FF0
+#define GL_UNSIGNED_INT16_VEC2_NV         0x8FF1
+#define GL_UNSIGNED_INT16_VEC3_NV         0x8FF2
+#define GL_UNSIGNED_INT16_VEC4_NV         0x8FF3
+#define GL_UNSIGNED_INT64_VEC2_NV         0x8FF5
+#define GL_UNSIGNED_INT64_VEC3_NV         0x8FF6
+#define GL_UNSIGNED_INT64_VEC4_NV         0x8FF7
+#define GL_FLOAT16_NV                     0x8FF8
+#define GL_FLOAT16_VEC2_NV                0x8FF9
+#define GL_FLOAT16_VEC3_NV                0x8FFA
+#define GL_FLOAT16_VEC4_NV                0x8FFB
+/* reuse GL_PATCHES */
+#endif
+
+#ifndef GL_NV_shader_buffer_store
+#define GL_SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV 0x00000010
+/* reuse GL_READ_WRITE */
+/* reuse GL_WRITE_ONLY */
+#endif
+
+#ifndef GL_NV_tessellation_program5
+#define GL_MAX_PROGRAM_PATCH_ATTRIBS_NV   0x86D8
+#define GL_TESS_CONTROL_PROGRAM_NV        0x891E
+#define GL_TESS_EVALUATION_PROGRAM_NV     0x891F
+#define GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV 0x8C74
+#define GL_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV 0x8C75
+#endif
+
+#ifndef GL_NV_vertex_attrib_integer_64bit
+/* reuse GL_INT64_NV */
+/* reuse GL_UNSIGNED_INT64_NV */
+#endif
+
+#ifndef GL_NV_multisample_coverage
+#define GL_COVERAGE_SAMPLES_NV            0x80A9
+#define GL_COLOR_SAMPLES_NV               0x8E20
+#endif
+
+#ifndef GL_AMD_name_gen_delete
+#define GL_DATA_BUFFER_AMD                0x9151
+#define GL_PERFORMANCE_MONITOR_AMD        0x9152
+#define GL_QUERY_OBJECT_AMD               0x9153
+#define GL_VERTEX_ARRAY_OBJECT_AMD        0x9154
+#define GL_SAMPLER_OBJECT_AMD             0x9155
+#endif
+
+#ifndef GL_AMD_debug_output
+#define GL_MAX_DEBUG_LOGGED_MESSAGES_AMD  0x9144
+#define GL_DEBUG_LOGGED_MESSAGES_AMD      0x9145
+#define GL_DEBUG_SEVERITY_HIGH_AMD        0x9146
+#define GL_DEBUG_SEVERITY_MEDIUM_AMD      0x9147
+#define GL_DEBUG_SEVERITY_LOW_AMD         0x9148
+#define GL_DEBUG_CATEGORY_API_ERROR_AMD   0x9149
+#define GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD 0x914A
+#define GL_DEBUG_CATEGORY_DEPRECATION_AMD 0x914B
+#define GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD 0x914C
+#define GL_DEBUG_CATEGORY_PERFORMANCE_AMD 0x914D
+#define GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD 0x914E
+#define GL_DEBUG_CATEGORY_APPLICATION_AMD 0x914F
+#define GL_DEBUG_CATEGORY_OTHER_AMD       0x9150
+#endif
+
+#ifndef GL_NV_vdpau_interop
+#define GL_SURFACE_STATE_NV               0x86EB
+#define GL_SURFACE_REGISTERED_NV          0x86FD
+#define GL_SURFACE_MAPPED_NV              0x8700
+#define GL_WRITE_DISCARD_NV               0x88BE
+#endif
+
+#ifndef GL_AMD_transform_feedback3_lines_triangles
+#endif
+
+
+/*************************************************************/
+
+#include <stddef.h>
+#ifndef GL_VERSION_2_0
+/* GL type for program/shader text */
+typedef char GLchar;
+#endif
+
+#ifndef GL_VERSION_1_5
+/* GL types for handling large vertex buffer objects */
+typedef ptrdiff_t GLintptr;
+typedef ptrdiff_t GLsizeiptr;
+#endif
+
+#ifndef GL_ARB_vertex_buffer_object
+/* GL types for handling large vertex buffer objects */
+typedef ptrdiff_t GLintptrARB;
+typedef ptrdiff_t GLsizeiptrARB;
+#endif
+
+#ifndef GL_ARB_shader_objects
+/* GL types for program/shader text and shader object handles */
+typedef char GLcharARB;
+typedef unsigned int GLhandleARB;
+#endif
+
+/* GL type for "half" precision (s10e5) float data in host memory */
+#ifndef GL_ARB_half_float_pixel
+typedef unsigned short GLhalfARB;
+#endif
+
+#ifndef GL_NV_half_float
+typedef unsigned short GLhalfNV;
+#endif
+
+#ifndef GLEXT_64_TYPES_DEFINED
+/* This code block is duplicated in glxext.h, so must be protected */
+#define GLEXT_64_TYPES_DEFINED
+/* Define int32_t, int64_t, and uint64_t types for UST/MSC */
+/* (as used in the GL_EXT_timer_query extension). */
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+#include <inttypes.h>
+#elif defined(__sun__) || defined(__digital__)
+#include <inttypes.h>
+#if defined(__STDC__)
+#if defined(__arch64__) || defined(_LP64)
+typedef long int int64_t;
+typedef unsigned long int uint64_t;
+#else
+typedef long long int int64_t;
+typedef unsigned long long int uint64_t;
+#endif /* __arch64__ */
+#endif /* __STDC__ */
+#elif defined( __VMS ) || defined(__sgi)
+#include <inttypes.h>
+#elif defined(__SCO__) || defined(__USLC__)
+#include <stdint.h>
+#elif defined(__UNIXOS2__) || defined(__SOL64__)
+typedef long int int32_t;
+typedef long long int int64_t;
+typedef unsigned long long int uint64_t;
+#elif defined(_WIN32) && defined(__GNUC__)
+#include <stdint.h>
+#elif defined(_WIN32)
+typedef __int32 int32_t;
+typedef __int64 int64_t;
+typedef unsigned __int64 uint64_t;
+#else
+/* Fallback if nothing above works */
+#include <inttypes.h>
+#endif
+#endif
+
+#ifndef GL_EXT_timer_query
+typedef int64_t GLint64EXT;
+typedef uint64_t GLuint64EXT;
+#endif
+
+#ifndef GL_ARB_sync
+typedef int64_t GLint64;
+typedef uint64_t GLuint64;
+typedef struct __GLsync *GLsync;
+#endif
+
+#ifndef GL_ARB_cl_event
+/* These incomplete types let us declare types compatible with OpenCL's cl_context and cl_event */
+struct _cl_context;
+struct _cl_event;
+#endif
+
+#ifndef GL_ARB_debug_output
+typedef void (APIENTRY *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,GLvoid *userParam);
+#endif
+
+#ifndef GL_AMD_debug_output
+typedef void (APIENTRY *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,GLvoid *userParam);
+#endif
+
+#ifndef GL_NV_vdpau_interop
+typedef GLintptr GLvdpauSurfaceNV;
+#endif
+
+#ifndef GL_VERSION_1_2
+#define GL_VERSION_1_2 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBlendColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+GLAPI void APIENTRY glBlendEquation (GLenum mode);
+GLAPI void APIENTRY glDrawRangeElements (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
+GLAPI void APIENTRY glTexImage3D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+GLAPI void APIENTRY glTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
+GLAPI void APIENTRY glCopyTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLBLENDCOLORPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+typedef void (APIENTRYP PFNGLBLENDEQUATIONPROC) (GLenum mode);
+typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
+typedef void (APIENTRYP PFNGLTEXIMAGE3DPROC) (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+typedef void (APIENTRYP PFNGLTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
+typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+#endif
+
+#ifndef GL_VERSION_1_2_DEPRECATED
+#define GL_VERSION_1_2_DEPRECATED 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glColorTable (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
+GLAPI void APIENTRY glColorTableParameterfv (GLenum target, GLenum pname, const GLfloat *params);
+GLAPI void APIENTRY glColorTableParameteriv (GLenum target, GLenum pname, const GLint *params);
+GLAPI void APIENTRY glCopyColorTable (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
+GLAPI void APIENTRY glGetColorTable (GLenum target, GLenum format, GLenum type, GLvoid *table);
+GLAPI void APIENTRY glGetColorTableParameterfv (GLenum target, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetColorTableParameteriv (GLenum target, GLenum pname, GLint *params);
+GLAPI void APIENTRY glColorSubTable (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
+GLAPI void APIENTRY glCopyColorSubTable (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
+GLAPI void APIENTRY glConvolutionFilter1D (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
+GLAPI void APIENTRY glConvolutionFilter2D (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
+GLAPI void APIENTRY glConvolutionParameterf (GLenum target, GLenum pname, GLfloat params);
+GLAPI void APIENTRY glConvolutionParameterfv (GLenum target, GLenum pname, const GLfloat *params);
+GLAPI void APIENTRY glConvolutionParameteri (GLenum target, GLenum pname, GLint params);
+GLAPI void APIENTRY glConvolutionParameteriv (GLenum target, GLenum pname, const GLint *params);
+GLAPI void APIENTRY glCopyConvolutionFilter1D (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
+GLAPI void APIENTRY glCopyConvolutionFilter2D (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
+GLAPI void APIENTRY glGetConvolutionFilter (GLenum target, GLenum format, GLenum type, GLvoid *image);
+GLAPI void APIENTRY glGetConvolutionParameterfv (GLenum target, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetConvolutionParameteriv (GLenum target, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetSeparableFilter (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
+GLAPI void APIENTRY glSeparableFilter2D (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
+GLAPI void APIENTRY glGetHistogram (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
+GLAPI void APIENTRY glGetHistogramParameterfv (GLenum target, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetHistogramParameteriv (GLenum target, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetMinmax (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
+GLAPI void APIENTRY glGetMinmaxParameterfv (GLenum target, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetMinmaxParameteriv (GLenum target, GLenum pname, GLint *params);
+GLAPI void APIENTRY glHistogram (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
+GLAPI void APIENTRY glMinmax (GLenum target, GLenum internalformat, GLboolean sink);
+GLAPI void APIENTRY glResetHistogram (GLenum target);
+GLAPI void APIENTRY glResetMinmax (GLenum target);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLCOLORTABLEPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
+typedef void (APIENTRYP PFNGLCOLORTABLEPARAMETERFVPROC) (GLenum target, GLenum pname, const GLfloat *params);
+typedef void (APIENTRYP PFNGLCOLORTABLEPARAMETERIVPROC) (GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRYP PFNGLCOPYCOLORTABLEPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
+typedef void (APIENTRYP PFNGLGETCOLORTABLEPROC) (GLenum target, GLenum format, GLenum type, GLvoid *table);
+typedef void (APIENTRYP PFNGLGETCOLORTABLEPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETCOLORTABLEPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLCOLORSUBTABLEPROC) (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
+typedef void (APIENTRYP PFNGLCOPYCOLORSUBTABLEPROC) (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
+typedef void (APIENTRYP PFNGLCONVOLUTIONFILTER1DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
+typedef void (APIENTRYP PFNGLCONVOLUTIONFILTER2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
+typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERFPROC) (GLenum target, GLenum pname, GLfloat params);
+typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERFVPROC) (GLenum target, GLenum pname, const GLfloat *params);
+typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERIPROC) (GLenum target, GLenum pname, GLint params);
+typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERIVPROC) (GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRYP PFNGLCOPYCONVOLUTIONFILTER1DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
+typedef void (APIENTRYP PFNGLCOPYCONVOLUTIONFILTER2DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
+typedef void (APIENTRYP PFNGLGETCONVOLUTIONFILTERPROC) (GLenum target, GLenum format, GLenum type, GLvoid *image);
+typedef void (APIENTRYP PFNGLGETCONVOLUTIONPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETCONVOLUTIONPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETSEPARABLEFILTERPROC) (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
+typedef void (APIENTRYP PFNGLSEPARABLEFILTER2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
+typedef void (APIENTRYP PFNGLGETHISTOGRAMPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
+typedef void (APIENTRYP PFNGLGETHISTOGRAMPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETHISTOGRAMPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETMINMAXPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
+typedef void (APIENTRYP PFNGLGETMINMAXPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETMINMAXPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLHISTOGRAMPROC) (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
+typedef void (APIENTRYP PFNGLMINMAXPROC) (GLenum target, GLenum internalformat, GLboolean sink);
+typedef void (APIENTRYP PFNGLRESETHISTOGRAMPROC) (GLenum target);
+typedef void (APIENTRYP PFNGLRESETMINMAXPROC) (GLenum target);
+#endif
+
+#ifndef GL_VERSION_1_3
+#define GL_VERSION_1_3 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glActiveTexture (GLenum texture);
+GLAPI void APIENTRY glSampleCoverage (GLclampf value, GLboolean invert);
+GLAPI void APIENTRY glCompressedTexImage3D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
+GLAPI void APIENTRY glCompressedTexImage2D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
+GLAPI void APIENTRY glCompressedTexImage1D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
+GLAPI void APIENTRY glCompressedTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
+GLAPI void APIENTRY glCompressedTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
+GLAPI void APIENTRY glCompressedTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
+GLAPI void APIENTRY glGetCompressedTexImage (GLenum target, GLint level, GLvoid *img);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC) (GLenum texture);
+typedef void (APIENTRYP PFNGLSAMPLECOVERAGEPROC) (GLclampf value, GLboolean invert);
+typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE3DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE2DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE1DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRYP PFNGLGETCOMPRESSEDTEXIMAGEPROC) (GLenum target, GLint level, GLvoid *img);
+#endif
+
+#ifndef GL_VERSION_1_3_DEPRECATED
+#define GL_VERSION_1_3_DEPRECATED 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glClientActiveTexture (GLenum texture);
+GLAPI void APIENTRY glMultiTexCoord1d (GLenum target, GLdouble s);
+GLAPI void APIENTRY glMultiTexCoord1dv (GLenum target, const GLdouble *v);
+GLAPI void APIENTRY glMultiTexCoord1f (GLenum target, GLfloat s);
+GLAPI void APIENTRY glMultiTexCoord1fv (GLenum target, const GLfloat *v);
+GLAPI void APIENTRY glMultiTexCoord1i (GLenum target, GLint s);
+GLAPI void APIENTRY glMultiTexCoord1iv (GLenum target, const GLint *v);
+GLAPI void APIENTRY glMultiTexCoord1s (GLenum target, GLshort s);
+GLAPI void APIENTRY glMultiTexCoord1sv (GLenum target, const GLshort *v);
+GLAPI void APIENTRY glMultiTexCoord2d (GLenum target, GLdouble s, GLdouble t);
+GLAPI void APIENTRY glMultiTexCoord2dv (GLenum target, const GLdouble *v);
+GLAPI void APIENTRY glMultiTexCoord2f (GLenum target, GLfloat s, GLfloat t);
+GLAPI void APIENTRY glMultiTexCoord2fv (GLenum target, const GLfloat *v);
+GLAPI void APIENTRY glMultiTexCoord2i (GLenum target, GLint s, GLint t);
+GLAPI void APIENTRY glMultiTexCoord2iv (GLenum target, const GLint *v);
+GLAPI void APIENTRY glMultiTexCoord2s (GLenum target, GLshort s, GLshort t);
+GLAPI void APIENTRY glMultiTexCoord2sv (GLenum target, const GLshort *v);
+GLAPI void APIENTRY glMultiTexCoord3d (GLenum target, GLdouble s, GLdouble t, GLdouble r);
+GLAPI void APIENTRY glMultiTexCoord3dv (GLenum target, const GLdouble *v);
+GLAPI void APIENTRY glMultiTexCoord3f (GLenum target, GLfloat s, GLfloat t, GLfloat r);
+GLAPI void APIENTRY glMultiTexCoord3fv (GLenum target, const GLfloat *v);
+GLAPI void APIENTRY glMultiTexCoord3i (GLenum target, GLint s, GLint t, GLint r);
+GLAPI void APIENTRY glMultiTexCoord3iv (GLenum target, const GLint *v);
+GLAPI void APIENTRY glMultiTexCoord3s (GLenum target, GLshort s, GLshort t, GLshort r);
+GLAPI void APIENTRY glMultiTexCoord3sv (GLenum target, const GLshort *v);
+GLAPI void APIENTRY glMultiTexCoord4d (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+GLAPI void APIENTRY glMultiTexCoord4dv (GLenum target, const GLdouble *v);
+GLAPI void APIENTRY glMultiTexCoord4f (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+GLAPI void APIENTRY glMultiTexCoord4fv (GLenum target, const GLfloat *v);
+GLAPI void APIENTRY glMultiTexCoord4i (GLenum target, GLint s, GLint t, GLint r, GLint q);
+GLAPI void APIENTRY glMultiTexCoord4iv (GLenum target, const GLint *v);
+GLAPI void APIENTRY glMultiTexCoord4s (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
+GLAPI void APIENTRY glMultiTexCoord4sv (GLenum target, const GLshort *v);
+GLAPI void APIENTRY glLoadTransposeMatrixf (const GLfloat *m);
+GLAPI void APIENTRY glLoadTransposeMatrixd (const GLdouble *m);
+GLAPI void APIENTRY glMultTransposeMatrixf (const GLfloat *m);
+GLAPI void APIENTRY glMultTransposeMatrixd (const GLdouble *m);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLCLIENTACTIVETEXTUREPROC) (GLenum texture);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD1DPROC) (GLenum target, GLdouble s);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD1DVPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD1FPROC) (GLenum target, GLfloat s);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD1FVPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD1IPROC) (GLenum target, GLint s);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD1IVPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD1SPROC) (GLenum target, GLshort s);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD1SVPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD2DPROC) (GLenum target, GLdouble s, GLdouble t);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD2DVPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD2FPROC) (GLenum target, GLfloat s, GLfloat t);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD2FVPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD2IPROC) (GLenum target, GLint s, GLint t);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD2IVPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD2SPROC) (GLenum target, GLshort s, GLshort t);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD2SVPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD3DPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD3DVPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD3FPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD3FVPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD3IPROC) (GLenum target, GLint s, GLint t, GLint r);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD3IVPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD3SPROC) (GLenum target, GLshort s, GLshort t, GLshort r);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD3SVPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD4DPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD4DVPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD4FPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD4FVPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD4IPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD4IVPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD4SPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD4SVPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRYP PFNGLLOADTRANSPOSEMATRIXFPROC) (const GLfloat *m);
+typedef void (APIENTRYP PFNGLLOADTRANSPOSEMATRIXDPROC) (const GLdouble *m);
+typedef void (APIENTRYP PFNGLMULTTRANSPOSEMATRIXFPROC) (const GLfloat *m);
+typedef void (APIENTRYP PFNGLMULTTRANSPOSEMATRIXDPROC) (const GLdouble *m);
+#endif
+
+#ifndef GL_VERSION_1_4
+#define GL_VERSION_1_4 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBlendFuncSeparate (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+GLAPI void APIENTRY glMultiDrawArrays (GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount);
+GLAPI void APIENTRY glMultiDrawElements (GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount);
+GLAPI void APIENTRY glPointParameterf (GLenum pname, GLfloat param);
+GLAPI void APIENTRY glPointParameterfv (GLenum pname, const GLfloat *params);
+GLAPI void APIENTRY glPointParameteri (GLenum pname, GLint param);
+GLAPI void APIENTRY glPointParameteriv (GLenum pname, const GLint *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+typedef void (APIENTRYP PFNGLMULTIDRAWARRAYSPROC) (GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount);
+typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSPROC) (GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount);
+typedef void (APIENTRYP PFNGLPOINTPARAMETERFPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRYP PFNGLPOINTPARAMETERFVPROC) (GLenum pname, const GLfloat *params);
+typedef void (APIENTRYP PFNGLPOINTPARAMETERIPROC) (GLenum pname, GLint param);
+typedef void (APIENTRYP PFNGLPOINTPARAMETERIVPROC) (GLenum pname, const GLint *params);
+#endif
+
+#ifndef GL_VERSION_1_4_DEPRECATED
+#define GL_VERSION_1_4_DEPRECATED 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glFogCoordf (GLfloat coord);
+GLAPI void APIENTRY glFogCoordfv (const GLfloat *coord);
+GLAPI void APIENTRY glFogCoordd (GLdouble coord);
+GLAPI void APIENTRY glFogCoorddv (const GLdouble *coord);
+GLAPI void APIENTRY glFogCoordPointer (GLenum type, GLsizei stride, const GLvoid *pointer);
+GLAPI void APIENTRY glSecondaryColor3b (GLbyte red, GLbyte green, GLbyte blue);
+GLAPI void APIENTRY glSecondaryColor3bv (const GLbyte *v);
+GLAPI void APIENTRY glSecondaryColor3d (GLdouble red, GLdouble green, GLdouble blue);
+GLAPI void APIENTRY glSecondaryColor3dv (const GLdouble *v);
+GLAPI void APIENTRY glSecondaryColor3f (GLfloat red, GLfloat green, GLfloat blue);
+GLAPI void APIENTRY glSecondaryColor3fv (const GLfloat *v);
+GLAPI void APIENTRY glSecondaryColor3i (GLint red, GLint green, GLint blue);
+GLAPI void APIENTRY glSecondaryColor3iv (const GLint *v);
+GLAPI void APIENTRY glSecondaryColor3s (GLshort red, GLshort green, GLshort blue);
+GLAPI void APIENTRY glSecondaryColor3sv (const GLshort *v);
+GLAPI void APIENTRY glSecondaryColor3ub (GLubyte red, GLubyte green, GLubyte blue);
+GLAPI void APIENTRY glSecondaryColor3ubv (const GLubyte *v);
+GLAPI void APIENTRY glSecondaryColor3ui (GLuint red, GLuint green, GLuint blue);
+GLAPI void APIENTRY glSecondaryColor3uiv (const GLuint *v);
+GLAPI void APIENTRY glSecondaryColor3us (GLushort red, GLushort green, GLushort blue);
+GLAPI void APIENTRY glSecondaryColor3usv (const GLushort *v);
+GLAPI void APIENTRY glSecondaryColorPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+GLAPI void APIENTRY glWindowPos2d (GLdouble x, GLdouble y);
+GLAPI void APIENTRY glWindowPos2dv (const GLdouble *v);
+GLAPI void APIENTRY glWindowPos2f (GLfloat x, GLfloat y);
+GLAPI void APIENTRY glWindowPos2fv (const GLfloat *v);
+GLAPI void APIENTRY glWindowPos2i (GLint x, GLint y);
+GLAPI void APIENTRY glWindowPos2iv (const GLint *v);
+GLAPI void APIENTRY glWindowPos2s (GLshort x, GLshort y);
+GLAPI void APIENTRY glWindowPos2sv (const GLshort *v);
+GLAPI void APIENTRY glWindowPos3d (GLdouble x, GLdouble y, GLdouble z);
+GLAPI void APIENTRY glWindowPos3dv (const GLdouble *v);
+GLAPI void APIENTRY glWindowPos3f (GLfloat x, GLfloat y, GLfloat z);
+GLAPI void APIENTRY glWindowPos3fv (const GLfloat *v);
+GLAPI void APIENTRY glWindowPos3i (GLint x, GLint y, GLint z);
+GLAPI void APIENTRY glWindowPos3iv (const GLint *v);
+GLAPI void APIENTRY glWindowPos3s (GLshort x, GLshort y, GLshort z);
+GLAPI void APIENTRY glWindowPos3sv (const GLshort *v);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLFOGCOORDFPROC) (GLfloat coord);
+typedef void (APIENTRYP PFNGLFOGCOORDFVPROC) (const GLfloat *coord);
+typedef void (APIENTRYP PFNGLFOGCOORDDPROC) (GLdouble coord);
+typedef void (APIENTRYP PFNGLFOGCOORDDVPROC) (const GLdouble *coord);
+typedef void (APIENTRYP PFNGLFOGCOORDPOINTERPROC) (GLenum type, GLsizei stride, const GLvoid *pointer);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3BPROC) (GLbyte red, GLbyte green, GLbyte blue);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3BVPROC) (const GLbyte *v);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3DPROC) (GLdouble red, GLdouble green, GLdouble blue);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3DVPROC) (const GLdouble *v);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3FPROC) (GLfloat red, GLfloat green, GLfloat blue);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3FVPROC) (const GLfloat *v);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3IPROC) (GLint red, GLint green, GLint blue);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3IVPROC) (const GLint *v);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3SPROC) (GLshort red, GLshort green, GLshort blue);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3SVPROC) (const GLshort *v);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UBPROC) (GLubyte red, GLubyte green, GLubyte blue);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UBVPROC) (const GLubyte *v);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UIPROC) (GLuint red, GLuint green, GLuint blue);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UIVPROC) (const GLuint *v);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3USPROC) (GLushort red, GLushort green, GLushort blue);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3USVPROC) (const GLushort *v);
+typedef void (APIENTRYP PFNGLSECONDARYCOLORPOINTERPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+typedef void (APIENTRYP PFNGLWINDOWPOS2DPROC) (GLdouble x, GLdouble y);
+typedef void (APIENTRYP PFNGLWINDOWPOS2DVPROC) (const GLdouble *v);
+typedef void (APIENTRYP PFNGLWINDOWPOS2FPROC) (GLfloat x, GLfloat y);
+typedef void (APIENTRYP PFNGLWINDOWPOS2FVPROC) (const GLfloat *v);
+typedef void (APIENTRYP PFNGLWINDOWPOS2IPROC) (GLint x, GLint y);
+typedef void (APIENTRYP PFNGLWINDOWPOS2IVPROC) (const GLint *v);
+typedef void (APIENTRYP PFNGLWINDOWPOS2SPROC) (GLshort x, GLshort y);
+typedef void (APIENTRYP PFNGLWINDOWPOS2SVPROC) (const GLshort *v);
+typedef void (APIENTRYP PFNGLWINDOWPOS3DPROC) (GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRYP PFNGLWINDOWPOS3DVPROC) (const GLdouble *v);
+typedef void (APIENTRYP PFNGLWINDOWPOS3FPROC) (GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRYP PFNGLWINDOWPOS3FVPROC) (const GLfloat *v);
+typedef void (APIENTRYP PFNGLWINDOWPOS3IPROC) (GLint x, GLint y, GLint z);
+typedef void (APIENTRYP PFNGLWINDOWPOS3IVPROC) (const GLint *v);
+typedef void (APIENTRYP PFNGLWINDOWPOS3SPROC) (GLshort x, GLshort y, GLshort z);
+typedef void (APIENTRYP PFNGLWINDOWPOS3SVPROC) (const GLshort *v);
+#endif
+
+#ifndef GL_VERSION_1_5
+#define GL_VERSION_1_5 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glGenQueries (GLsizei n, GLuint *ids);
+GLAPI void APIENTRY glDeleteQueries (GLsizei n, const GLuint *ids);
+GLAPI GLboolean APIENTRY glIsQuery (GLuint id);
+GLAPI void APIENTRY glBeginQuery (GLenum target, GLuint id);
+GLAPI void APIENTRY glEndQuery (GLenum target);
+GLAPI void APIENTRY glGetQueryiv (GLenum target, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetQueryObjectiv (GLuint id, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetQueryObjectuiv (GLuint id, GLenum pname, GLuint *params);
+GLAPI void APIENTRY glBindBuffer (GLenum target, GLuint buffer);
+GLAPI void APIENTRY glDeleteBuffers (GLsizei n, const GLuint *buffers);
+GLAPI void APIENTRY glGenBuffers (GLsizei n, GLuint *buffers);
+GLAPI GLboolean APIENTRY glIsBuffer (GLuint buffer);
+GLAPI void APIENTRY glBufferData (GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
+GLAPI void APIENTRY glBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data);
+GLAPI void APIENTRY glGetBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data);
+GLAPI GLvoid* APIENTRY glMapBuffer (GLenum target, GLenum access);
+GLAPI GLboolean APIENTRY glUnmapBuffer (GLenum target);
+GLAPI void APIENTRY glGetBufferParameteriv (GLenum target, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetBufferPointerv (GLenum target, GLenum pname, GLvoid* *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLGENQUERIESPROC) (GLsizei n, GLuint *ids);
+typedef void (APIENTRYP PFNGLDELETEQUERIESPROC) (GLsizei n, const GLuint *ids);
+typedef GLboolean (APIENTRYP PFNGLISQUERYPROC) (GLuint id);
+typedef void (APIENTRYP PFNGLBEGINQUERYPROC) (GLenum target, GLuint id);
+typedef void (APIENTRYP PFNGLENDQUERYPROC) (GLenum target);
+typedef void (APIENTRYP PFNGLGETQUERYIVPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETQUERYOBJECTIVPROC) (GLuint id, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETQUERYOBJECTUIVPROC) (GLuint id, GLenum pname, GLuint *params);
+typedef void (APIENTRYP PFNGLBINDBUFFERPROC) (GLenum target, GLuint buffer);
+typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC) (GLsizei n, const GLuint *buffers);
+typedef void (APIENTRYP PFNGLGENBUFFERSPROC) (GLsizei n, GLuint *buffers);
+typedef GLboolean (APIENTRYP PFNGLISBUFFERPROC) (GLuint buffer);
+typedef void (APIENTRYP PFNGLBUFFERDATAPROC) (GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
+typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC) (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data);
+typedef void (APIENTRYP PFNGLGETBUFFERSUBDATAPROC) (GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data);
+typedef GLvoid* (APIENTRYP PFNGLMAPBUFFERPROC) (GLenum target, GLenum access);
+typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERPROC) (GLenum target);
+typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETBUFFERPOINTERVPROC) (GLenum target, GLenum pname, GLvoid* *params);
+#endif
+
+#ifndef GL_VERSION_2_0
+#define GL_VERSION_2_0 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBlendEquationSeparate (GLenum modeRGB, GLenum modeAlpha);
+GLAPI void APIENTRY glDrawBuffers (GLsizei n, const GLenum *bufs);
+GLAPI void APIENTRY glStencilOpSeparate (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
+GLAPI void APIENTRY glStencilFuncSeparate (GLenum face, GLenum func, GLint ref, GLuint mask);
+GLAPI void APIENTRY glStencilMaskSeparate (GLenum face, GLuint mask);
+GLAPI void APIENTRY glAttachShader (GLuint program, GLuint shader);
+GLAPI void APIENTRY glBindAttribLocation (GLuint program, GLuint index, const GLchar *name);
+GLAPI void APIENTRY glCompileShader (GLuint shader);
+GLAPI GLuint APIENTRY glCreateProgram (void);
+GLAPI GLuint APIENTRY glCreateShader (GLenum type);
+GLAPI void APIENTRY glDeleteProgram (GLuint program);
+GLAPI void APIENTRY glDeleteShader (GLuint shader);
+GLAPI void APIENTRY glDetachShader (GLuint program, GLuint shader);
+GLAPI void APIENTRY glDisableVertexAttribArray (GLuint index);
+GLAPI void APIENTRY glEnableVertexAttribArray (GLuint index);
+GLAPI void APIENTRY glGetActiveAttrib (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
+GLAPI void APIENTRY glGetActiveUniform (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
+GLAPI void APIENTRY glGetAttachedShaders (GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj);
+GLAPI GLint APIENTRY glGetAttribLocation (GLuint program, const GLchar *name);
+GLAPI void APIENTRY glGetProgramiv (GLuint program, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetProgramInfoLog (GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+GLAPI void APIENTRY glGetShaderiv (GLuint shader, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetShaderInfoLog (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+GLAPI void APIENTRY glGetShaderSource (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
+GLAPI GLint APIENTRY glGetUniformLocation (GLuint program, const GLchar *name);
+GLAPI void APIENTRY glGetUniformfv (GLuint program, GLint location, GLfloat *params);
+GLAPI void APIENTRY glGetUniformiv (GLuint program, GLint location, GLint *params);
+GLAPI void APIENTRY glGetVertexAttribdv (GLuint index, GLenum pname, GLdouble *params);
+GLAPI void APIENTRY glGetVertexAttribfv (GLuint index, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetVertexAttribiv (GLuint index, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetVertexAttribPointerv (GLuint index, GLenum pname, GLvoid* *pointer);
+GLAPI GLboolean APIENTRY glIsProgram (GLuint program);
+GLAPI GLboolean APIENTRY glIsShader (GLuint shader);
+GLAPI void APIENTRY glLinkProgram (GLuint program);
+GLAPI void APIENTRY glShaderSource (GLuint shader, GLsizei count, const GLchar* *string, const GLint *length);
+GLAPI void APIENTRY glUseProgram (GLuint program);
+GLAPI void APIENTRY glUniform1f (GLint location, GLfloat v0);
+GLAPI void APIENTRY glUniform2f (GLint location, GLfloat v0, GLfloat v1);
+GLAPI void APIENTRY glUniform3f (GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+GLAPI void APIENTRY glUniform4f (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+GLAPI void APIENTRY glUniform1i (GLint location, GLint v0);
+GLAPI void APIENTRY glUniform2i (GLint location, GLint v0, GLint v1);
+GLAPI void APIENTRY glUniform3i (GLint location, GLint v0, GLint v1, GLint v2);
+GLAPI void APIENTRY glUniform4i (GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+GLAPI void APIENTRY glUniform1fv (GLint location, GLsizei count, const GLfloat *value);
+GLAPI void APIENTRY glUniform2fv (GLint location, GLsizei count, const GLfloat *value);
+GLAPI void APIENTRY glUniform3fv (GLint location, GLsizei count, const GLfloat *value);
+GLAPI void APIENTRY glUniform4fv (GLint location, GLsizei count, const GLfloat *value);
+GLAPI void APIENTRY glUniform1iv (GLint location, GLsizei count, const GLint *value);
+GLAPI void APIENTRY glUniform2iv (GLint location, GLsizei count, const GLint *value);
+GLAPI void APIENTRY glUniform3iv (GLint location, GLsizei count, const GLint *value);
+GLAPI void APIENTRY glUniform4iv (GLint location, GLsizei count, const GLint *value);
+GLAPI void APIENTRY glUniformMatrix2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glUniformMatrix3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glUniformMatrix4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glValidateProgram (GLuint program);
+GLAPI void APIENTRY glVertexAttrib1d (GLuint index, GLdouble x);
+GLAPI void APIENTRY glVertexAttrib1dv (GLuint index, const GLdouble *v);
+GLAPI void APIENTRY glVertexAttrib1f (GLuint index, GLfloat x);
+GLAPI void APIENTRY glVertexAttrib1fv (GLuint index, const GLfloat *v);
+GLAPI void APIENTRY glVertexAttrib1s (GLuint index, GLshort x);
+GLAPI void APIENTRY glVertexAttrib1sv (GLuint index, const GLshort *v);
+GLAPI void APIENTRY glVertexAttrib2d (GLuint index, GLdouble x, GLdouble y);
+GLAPI void APIENTRY glVertexAttrib2dv (GLuint index, const GLdouble *v);
+GLAPI void APIENTRY glVertexAttrib2f (GLuint index, GLfloat x, GLfloat y);
+GLAPI void APIENTRY glVertexAttrib2fv (GLuint index, const GLfloat *v);
+GLAPI void APIENTRY glVertexAttrib2s (GLuint index, GLshort x, GLshort y);
+GLAPI void APIENTRY glVertexAttrib2sv (GLuint index, const GLshort *v);
+GLAPI void APIENTRY glVertexAttrib3d (GLuint index, GLdouble x, GLdouble y, GLdouble z);
+GLAPI void APIENTRY glVertexAttrib3dv (GLuint index, const GLdouble *v);
+GLAPI void APIENTRY glVertexAttrib3f (GLuint index, GLfloat x, GLfloat y, GLfloat z);
+GLAPI void APIENTRY glVertexAttrib3fv (GLuint index, const GLfloat *v);
+GLAPI void APIENTRY glVertexAttrib3s (GLuint index, GLshort x, GLshort y, GLshort z);
+GLAPI void APIENTRY glVertexAttrib3sv (GLuint index, const GLshort *v);
+GLAPI void APIENTRY glVertexAttrib4Nbv (GLuint index, const GLbyte *v);
+GLAPI void APIENTRY glVertexAttrib4Niv (GLuint index, const GLint *v);
+GLAPI void APIENTRY glVertexAttrib4Nsv (GLuint index, const GLshort *v);
+GLAPI void APIENTRY glVertexAttrib4Nub (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+GLAPI void APIENTRY glVertexAttrib4Nubv (GLuint index, const GLubyte *v);
+GLAPI void APIENTRY glVertexAttrib4Nuiv (GLuint index, const GLuint *v);
+GLAPI void APIENTRY glVertexAttrib4Nusv (GLuint index, const GLushort *v);
+GLAPI void APIENTRY glVertexAttrib4bv (GLuint index, const GLbyte *v);
+GLAPI void APIENTRY glVertexAttrib4d (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+GLAPI void APIENTRY glVertexAttrib4dv (GLuint index, const GLdouble *v);
+GLAPI void APIENTRY glVertexAttrib4f (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+GLAPI void APIENTRY glVertexAttrib4fv (GLuint index, const GLfloat *v);
+GLAPI void APIENTRY glVertexAttrib4iv (GLuint index, const GLint *v);
+GLAPI void APIENTRY glVertexAttrib4s (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+GLAPI void APIENTRY glVertexAttrib4sv (GLuint index, const GLshort *v);
+GLAPI void APIENTRY glVertexAttrib4ubv (GLuint index, const GLubyte *v);
+GLAPI void APIENTRY glVertexAttrib4uiv (GLuint index, const GLuint *v);
+GLAPI void APIENTRY glVertexAttrib4usv (GLuint index, const GLushort *v);
+GLAPI void APIENTRY glVertexAttribPointer (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEPROC) (GLenum modeRGB, GLenum modeAlpha);
+typedef void (APIENTRYP PFNGLDRAWBUFFERSPROC) (GLsizei n, const GLenum *bufs);
+typedef void (APIENTRYP PFNGLSTENCILOPSEPARATEPROC) (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
+typedef void (APIENTRYP PFNGLSTENCILFUNCSEPARATEPROC) (GLenum face, GLenum func, GLint ref, GLuint mask);
+typedef void (APIENTRYP PFNGLSTENCILMASKSEPARATEPROC) (GLenum face, GLuint mask);
+typedef void (APIENTRYP PFNGLATTACHSHADERPROC) (GLuint program, GLuint shader);
+typedef void (APIENTRYP PFNGLBINDATTRIBLOCATIONPROC) (GLuint program, GLuint index, const GLchar *name);
+typedef void (APIENTRYP PFNGLCOMPILESHADERPROC) (GLuint shader);
+typedef GLuint (APIENTRYP PFNGLCREATEPROGRAMPROC) (void);
+typedef GLuint (APIENTRYP PFNGLCREATESHADERPROC) (GLenum type);
+typedef void (APIENTRYP PFNGLDELETEPROGRAMPROC) (GLuint program);
+typedef void (APIENTRYP PFNGLDELETESHADERPROC) (GLuint shader);
+typedef void (APIENTRYP PFNGLDETACHSHADERPROC) (GLuint program, GLuint shader);
+typedef void (APIENTRYP PFNGLDISABLEVERTEXATTRIBARRAYPROC) (GLuint index);
+typedef void (APIENTRYP PFNGLENABLEVERTEXATTRIBARRAYPROC) (GLuint index);
+typedef void (APIENTRYP PFNGLGETACTIVEATTRIBPROC) (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
+typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMPROC) (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
+typedef void (APIENTRYP PFNGLGETATTACHEDSHADERSPROC) (GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj);
+typedef GLint (APIENTRYP PFNGLGETATTRIBLOCATIONPROC) (GLuint program, const GLchar *name);
+typedef void (APIENTRYP PFNGLGETPROGRAMIVPROC) (GLuint program, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETPROGRAMINFOLOGPROC) (GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+typedef void (APIENTRYP PFNGLGETSHADERIVPROC) (GLuint shader, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETSHADERINFOLOGPROC) (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+typedef void (APIENTRYP PFNGLGETSHADERSOURCEPROC) (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
+typedef GLint (APIENTRYP PFNGLGETUNIFORMLOCATIONPROC) (GLuint program, const GLchar *name);
+typedef void (APIENTRYP PFNGLGETUNIFORMFVPROC) (GLuint program, GLint location, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETUNIFORMIVPROC) (GLuint program, GLint location, GLint *params);
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBDVPROC) (GLuint index, GLenum pname, GLdouble *params);
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBFVPROC) (GLuint index, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVPROC) (GLuint index, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBPOINTERVPROC) (GLuint index, GLenum pname, GLvoid* *pointer);
+typedef GLboolean (APIENTRYP PFNGLISPROGRAMPROC) (GLuint program);
+typedef GLboolean (APIENTRYP PFNGLISSHADERPROC) (GLuint shader);
+typedef void (APIENTRYP PFNGLLINKPROGRAMPROC) (GLuint program);
+typedef void (APIENTRYP PFNGLSHADERSOURCEPROC) (GLuint shader, GLsizei count, const GLchar* *string, const GLint *length);
+typedef void (APIENTRYP PFNGLUSEPROGRAMPROC) (GLuint program);
+typedef void (APIENTRYP PFNGLUNIFORM1FPROC) (GLint location, GLfloat v0);
+typedef void (APIENTRYP PFNGLUNIFORM2FPROC) (GLint location, GLfloat v0, GLfloat v1);
+typedef void (APIENTRYP PFNGLUNIFORM3FPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+typedef void (APIENTRYP PFNGLUNIFORM4FPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+typedef void (APIENTRYP PFNGLUNIFORM1IPROC) (GLint location, GLint v0);
+typedef void (APIENTRYP PFNGLUNIFORM2IPROC) (GLint location, GLint v0, GLint v1);
+typedef void (APIENTRYP PFNGLUNIFORM3IPROC) (GLint location, GLint v0, GLint v1, GLint v2);
+typedef void (APIENTRYP PFNGLUNIFORM4IPROC) (GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+typedef void (APIENTRYP PFNGLUNIFORM1FVPROC) (GLint location, GLsizei count, const GLfloat *value);
+typedef void (APIENTRYP PFNGLUNIFORM2FVPROC) (GLint location, GLsizei count, const GLfloat *value);
+typedef void (APIENTRYP PFNGLUNIFORM3FVPROC) (GLint location, GLsizei count, const GLfloat *value);
+typedef void (APIENTRYP PFNGLUNIFORM4FVPROC) (GLint location, GLsizei count, const GLfloat *value);
+typedef void (APIENTRYP PFNGLUNIFORM1IVPROC) (GLint location, GLsizei count, const GLint *value);
+typedef void (APIENTRYP PFNGLUNIFORM2IVPROC) (GLint location, GLsizei count, const GLint *value);
+typedef void (APIENTRYP PFNGLUNIFORM3IVPROC) (GLint location, GLsizei count, const GLint *value);
+typedef void (APIENTRYP PFNGLUNIFORM4IVPROC) (GLint location, GLsizei count, const GLint *value);
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX2FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX3FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX4FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLVALIDATEPROGRAMPROC) (GLuint program);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB1DPROC) (GLuint index, GLdouble x);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB1DVPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB1FPROC) (GLuint index, GLfloat x);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB1FVPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB1SPROC) (GLuint index, GLshort x);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB1SVPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB2DPROC) (GLuint index, GLdouble x, GLdouble y);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB2DVPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB2FPROC) (GLuint index, GLfloat x, GLfloat y);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB2FVPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB2SPROC) (GLuint index, GLshort x, GLshort y);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB2SVPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB3DPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB3DVPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB3FPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB3FVPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB3SPROC) (GLuint index, GLshort x, GLshort y, GLshort z);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB3SVPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4NBVPROC) (GLuint index, const GLbyte *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4NIVPROC) (GLuint index, const GLint *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4NSVPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBVPROC) (GLuint index, const GLubyte *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUIVPROC) (GLuint index, const GLuint *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUSVPROC) (GLuint index, const GLushort *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4BVPROC) (GLuint index, const GLbyte *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4DPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4DVPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4FPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4FVPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4IVPROC) (GLuint index, const GLint *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4SPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4SVPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBVPROC) (GLuint index, const GLubyte *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4UIVPROC) (GLuint index, const GLuint *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4USVPROC) (GLuint index, const GLushort *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
+#endif
+
+#ifndef GL_VERSION_2_1
+#define GL_VERSION_2_1 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glUniformMatrix2x3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glUniformMatrix3x2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glUniformMatrix2x4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glUniformMatrix4x2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glUniformMatrix3x4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glUniformMatrix4x3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X3FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X2FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X4FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X2FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X4FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X3FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+#endif
+
+#ifndef GL_VERSION_3_0
+#define GL_VERSION_3_0 1
+/* OpenGL 3.0 also reuses entry points from these extensions: */
+/* ARB_framebuffer_object */
+/* ARB_map_buffer_range */
+/* ARB_vertex_array_object */
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glColorMaski (GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
+GLAPI void APIENTRY glGetBooleani_v (GLenum target, GLuint index, GLboolean *data);
+GLAPI void APIENTRY glGetIntegeri_v (GLenum target, GLuint index, GLint *data);
+GLAPI void APIENTRY glEnablei (GLenum target, GLuint index);
+GLAPI void APIENTRY glDisablei (GLenum target, GLuint index);
+GLAPI GLboolean APIENTRY glIsEnabledi (GLenum target, GLuint index);
+GLAPI void APIENTRY glBeginTransformFeedback (GLenum primitiveMode);
+GLAPI void APIENTRY glEndTransformFeedback (void);
+GLAPI void APIENTRY glBindBufferRange (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
+GLAPI void APIENTRY glBindBufferBase (GLenum target, GLuint index, GLuint buffer);
+GLAPI void APIENTRY glTransformFeedbackVaryings (GLuint program, GLsizei count, const GLchar* *varyings, GLenum bufferMode);
+GLAPI void APIENTRY glGetTransformFeedbackVarying (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
+GLAPI void APIENTRY glClampColor (GLenum target, GLenum clamp);
+GLAPI void APIENTRY glBeginConditionalRender (GLuint id, GLenum mode);
+GLAPI void APIENTRY glEndConditionalRender (void);
+GLAPI void APIENTRY glVertexAttribIPointer (GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+GLAPI void APIENTRY glGetVertexAttribIiv (GLuint index, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetVertexAttribIuiv (GLuint index, GLenum pname, GLuint *params);
+GLAPI void APIENTRY glVertexAttribI1i (GLuint index, GLint x);
+GLAPI void APIENTRY glVertexAttribI2i (GLuint index, GLint x, GLint y);
+GLAPI void APIENTRY glVertexAttribI3i (GLuint index, GLint x, GLint y, GLint z);
+GLAPI void APIENTRY glVertexAttribI4i (GLuint index, GLint x, GLint y, GLint z, GLint w);
+GLAPI void APIENTRY glVertexAttribI1ui (GLuint index, GLuint x);
+GLAPI void APIENTRY glVertexAttribI2ui (GLuint index, GLuint x, GLuint y);
+GLAPI void APIENTRY glVertexAttribI3ui (GLuint index, GLuint x, GLuint y, GLuint z);
+GLAPI void APIENTRY glVertexAttribI4ui (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
+GLAPI void APIENTRY glVertexAttribI1iv (GLuint index, const GLint *v);
+GLAPI void APIENTRY glVertexAttribI2iv (GLuint index, const GLint *v);
+GLAPI void APIENTRY glVertexAttribI3iv (GLuint index, const GLint *v);
+GLAPI void APIENTRY glVertexAttribI4iv (GLuint index, const GLint *v);
+GLAPI void APIENTRY glVertexAttribI1uiv (GLuint index, const GLuint *v);
+GLAPI void APIENTRY glVertexAttribI2uiv (GLuint index, const GLuint *v);
+GLAPI void APIENTRY glVertexAttribI3uiv (GLuint index, const GLuint *v);
+GLAPI void APIENTRY glVertexAttribI4uiv (GLuint index, const GLuint *v);
+GLAPI void APIENTRY glVertexAttribI4bv (GLuint index, const GLbyte *v);
+GLAPI void APIENTRY glVertexAttribI4sv (GLuint index, const GLshort *v);
+GLAPI void APIENTRY glVertexAttribI4ubv (GLuint index, const GLubyte *v);
+GLAPI void APIENTRY glVertexAttribI4usv (GLuint index, const GLushort *v);
+GLAPI void APIENTRY glGetUniformuiv (GLuint program, GLint location, GLuint *params);
+GLAPI void APIENTRY glBindFragDataLocation (GLuint program, GLuint color, const GLchar *name);
+GLAPI GLint APIENTRY glGetFragDataLocation (GLuint program, const GLchar *name);
+GLAPI void APIENTRY glUniform1ui (GLint location, GLuint v0);
+GLAPI void APIENTRY glUniform2ui (GLint location, GLuint v0, GLuint v1);
+GLAPI void APIENTRY glUniform3ui (GLint location, GLuint v0, GLuint v1, GLuint v2);
+GLAPI void APIENTRY glUniform4ui (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
+GLAPI void APIENTRY glUniform1uiv (GLint location, GLsizei count, const GLuint *value);
+GLAPI void APIENTRY glUniform2uiv (GLint location, GLsizei count, const GLuint *value);
+GLAPI void APIENTRY glUniform3uiv (GLint location, GLsizei count, const GLuint *value);
+GLAPI void APIENTRY glUniform4uiv (GLint location, GLsizei count, const GLuint *value);
+GLAPI void APIENTRY glTexParameterIiv (GLenum target, GLenum pname, const GLint *params);
+GLAPI void APIENTRY glTexParameterIuiv (GLenum target, GLenum pname, const GLuint *params);
+GLAPI void APIENTRY glGetTexParameterIiv (GLenum target, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetTexParameterIuiv (GLenum target, GLenum pname, GLuint *params);
+GLAPI void APIENTRY glClearBufferiv (GLenum buffer, GLint drawbuffer, const GLint *value);
+GLAPI void APIENTRY glClearBufferuiv (GLenum buffer, GLint drawbuffer, const GLuint *value);
+GLAPI void APIENTRY glClearBufferfv (GLenum buffer, GLint drawbuffer, const GLfloat *value);
+GLAPI void APIENTRY glClearBufferfi (GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
+GLAPI const GLubyte * APIENTRY glGetStringi (GLenum name, GLuint index);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLCOLORMASKIPROC) (GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
+typedef void (APIENTRYP PFNGLGETBOOLEANI_VPROC) (GLenum target, GLuint index, GLboolean *data);
+typedef void (APIENTRYP PFNGLGETINTEGERI_VPROC) (GLenum target, GLuint index, GLint *data);
+typedef void (APIENTRYP PFNGLENABLEIPROC) (GLenum target, GLuint index);
+typedef void (APIENTRYP PFNGLDISABLEIPROC) (GLenum target, GLuint index);
+typedef GLboolean (APIENTRYP PFNGLISENABLEDIPROC) (GLenum target, GLuint index);
+typedef void (APIENTRYP PFNGLBEGINTRANSFORMFEEDBACKPROC) (GLenum primitiveMode);
+typedef void (APIENTRYP PFNGLENDTRANSFORMFEEDBACKPROC) (void);
+typedef void (APIENTRYP PFNGLBINDBUFFERRANGEPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
+typedef void (APIENTRYP PFNGLBINDBUFFERBASEPROC) (GLenum target, GLuint index, GLuint buffer);
+typedef void (APIENTRYP PFNGLTRANSFORMFEEDBACKVARYINGSPROC) (GLuint program, GLsizei count, const GLchar* *varyings, GLenum bufferMode);
+typedef void (APIENTRYP PFNGLGETTRANSFORMFEEDBACKVARYINGPROC) (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
+typedef void (APIENTRYP PFNGLCLAMPCOLORPROC) (GLenum target, GLenum clamp);
+typedef void (APIENTRYP PFNGLBEGINCONDITIONALRENDERPROC) (GLuint id, GLenum mode);
+typedef void (APIENTRYP PFNGLENDCONDITIONALRENDERPROC) (void);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBIPOINTERPROC) (GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIIVPROC) (GLuint index, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIUIVPROC) (GLuint index, GLenum pname, GLuint *params);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IPROC) (GLuint index, GLint x);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IPROC) (GLuint index, GLint x, GLint y);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IPROC) (GLuint index, GLint x, GLint y, GLint z);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IPROC) (GLuint index, GLint x, GLint y, GLint z, GLint w);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIPROC) (GLuint index, GLuint x);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIPROC) (GLuint index, GLuint x, GLuint y);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIPROC) (GLuint index, GLuint x, GLuint y, GLuint z);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIPROC) (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IVPROC) (GLuint index, const GLint *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IVPROC) (GLuint index, const GLint *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IVPROC) (GLuint index, const GLint *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IVPROC) (GLuint index, const GLint *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIVPROC) (GLuint index, const GLuint *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIVPROC) (GLuint index, const GLuint *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIVPROC) (GLuint index, const GLuint *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIVPROC) (GLuint index, const GLuint *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI4BVPROC) (GLuint index, const GLbyte *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI4SVPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UBVPROC) (GLuint index, const GLubyte *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI4USVPROC) (GLuint index, const GLushort *v);
+typedef void (APIENTRYP PFNGLGETUNIFORMUIVPROC) (GLuint program, GLint location, GLuint *params);
+typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONPROC) (GLuint program, GLuint color, const GLchar *name);
+typedef GLint (APIENTRYP PFNGLGETFRAGDATALOCATIONPROC) (GLuint program, const GLchar *name);
+typedef void (APIENTRYP PFNGLUNIFORM1UIPROC) (GLint location, GLuint v0);
+typedef void (APIENTRYP PFNGLUNIFORM2UIPROC) (GLint location, GLuint v0, GLuint v1);
+typedef void (APIENTRYP PFNGLUNIFORM3UIPROC) (GLint location, GLuint v0, GLuint v1, GLuint v2);
+typedef void (APIENTRYP PFNGLUNIFORM4UIPROC) (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
+typedef void (APIENTRYP PFNGLUNIFORM1UIVPROC) (GLint location, GLsizei count, const GLuint *value);
+typedef void (APIENTRYP PFNGLUNIFORM2UIVPROC) (GLint location, GLsizei count, const GLuint *value);
+typedef void (APIENTRYP PFNGLUNIFORM3UIVPROC) (GLint location, GLsizei count, const GLuint *value);
+typedef void (APIENTRYP PFNGLUNIFORM4UIVPROC) (GLint location, GLsizei count, const GLuint *value);
+typedef void (APIENTRYP PFNGLTEXPARAMETERIIVPROC) (GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRYP PFNGLTEXPARAMETERIUIVPROC) (GLenum target, GLenum pname, const GLuint *params);
+typedef void (APIENTRYP PFNGLGETTEXPARAMETERIIVPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETTEXPARAMETERIUIVPROC) (GLenum target, GLenum pname, GLuint *params);
+typedef void (APIENTRYP PFNGLCLEARBUFFERIVPROC) (GLenum buffer, GLint drawbuffer, const GLint *value);
+typedef void (APIENTRYP PFNGLCLEARBUFFERUIVPROC) (GLenum buffer, GLint drawbuffer, const GLuint *value);
+typedef void (APIENTRYP PFNGLCLEARBUFFERFVPROC) (GLenum buffer, GLint drawbuffer, const GLfloat *value);
+typedef void (APIENTRYP PFNGLCLEARBUFFERFIPROC) (GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
+typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGIPROC) (GLenum name, GLuint index);
+#endif
+
+#ifndef GL_VERSION_3_1
+#define GL_VERSION_3_1 1
+/* OpenGL 3.1 also reuses entry points from these extensions: */
+/* ARB_copy_buffer */
+/* ARB_uniform_buffer_object */
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glDrawArraysInstanced (GLenum mode, GLint first, GLsizei count, GLsizei primcount);
+GLAPI void APIENTRY glDrawElementsInstanced (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount);
+GLAPI void APIENTRY glTexBuffer (GLenum target, GLenum internalformat, GLuint buffer);
+GLAPI void APIENTRY glPrimitiveRestartIndex (GLuint index);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLDRAWARRAYSINSTANCEDPROC) (GLenum mode, GLint first, GLsizei count, GLsizei primcount);
+typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDPROC) (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount);
+typedef void (APIENTRYP PFNGLTEXBUFFERPROC) (GLenum target, GLenum internalformat, GLuint buffer);
+typedef void (APIENTRYP PFNGLPRIMITIVERESTARTINDEXPROC) (GLuint index);
+#endif
+
+#ifndef GL_VERSION_3_2
+#define GL_VERSION_3_2 1
+/* OpenGL 3.2 also reuses entry points from these extensions: */
+/* ARB_draw_elements_base_vertex */
+/* ARB_provoking_vertex */
+/* ARB_sync */
+/* ARB_texture_multisample */
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glGetInteger64i_v (GLenum target, GLuint index, GLint64 *data);
+GLAPI void APIENTRY glGetBufferParameteri64v (GLenum target, GLenum pname, GLint64 *params);
+GLAPI void APIENTRY glFramebufferTexture (GLenum target, GLenum attachment, GLuint texture, GLint level);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLGETINTEGER64I_VPROC) (GLenum target, GLuint index, GLint64 *data);
+typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERI64VPROC) (GLenum target, GLenum pname, GLint64 *params);
+typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTUREPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level);
+#endif
+
+#ifndef GL_VERSION_3_3
+#define GL_VERSION_3_3 1
+/* OpenGL 3.3 also reuses entry points from these extensions: */
+/* ARB_blend_func_extended */
+/* ARB_sampler_objects */
+/* ARB_explicit_attrib_location, but it has none */
+/* ARB_occlusion_query2 (no entry points) */
+/* ARB_shader_bit_encoding (no entry points) */
+/* ARB_texture_rgb10_a2ui (no entry points) */
+/* ARB_texture_swizzle (no entry points) */
+/* ARB_timer_query */
+/* ARB_vertex_type_2_10_10_10_rev */
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glVertexAttribDivisor (GLuint index, GLuint divisor);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLVERTEXATTRIBDIVISORPROC) (GLuint index, GLuint divisor);
+#endif
+
+#ifndef GL_VERSION_4_0
+#define GL_VERSION_4_0 1
+/* OpenGL 4.0 also reuses entry points from these extensions: */
+/* ARB_texture_query_lod (no entry points) */
+/* ARB_draw_indirect */
+/* ARB_gpu_shader5 (no entry points) */
+/* ARB_gpu_shader_fp64 */
+/* ARB_shader_subroutine */
+/* ARB_tessellation_shader */
+/* ARB_texture_buffer_object_rgb32 (no entry points) */
+/* ARB_texture_cube_map_array (no entry points) */
+/* ARB_texture_gather (no entry points) */
+/* ARB_transform_feedback2 */
+/* ARB_transform_feedback3 */
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glMinSampleShading (GLclampf value);
+GLAPI void APIENTRY glBlendEquationi (GLuint buf, GLenum mode);
+GLAPI void APIENTRY glBlendEquationSeparatei (GLuint buf, GLenum modeRGB, GLenum modeAlpha);
+GLAPI void APIENTRY glBlendFunci (GLuint buf, GLenum src, GLenum dst);
+GLAPI void APIENTRY glBlendFuncSeparatei (GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLMINSAMPLESHADINGPROC) (GLclampf value);
+typedef void (APIENTRYP PFNGLBLENDEQUATIONIPROC) (GLuint buf, GLenum mode);
+typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEIPROC) (GLuint buf, GLenum modeRGB, GLenum modeAlpha);
+typedef void (APIENTRYP PFNGLBLENDFUNCIPROC) (GLuint buf, GLenum src, GLenum dst);
+typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEIPROC) (GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
+#endif
+
+#ifndef GL_VERSION_4_1
+#define GL_VERSION_4_1 1
+/* OpenGL 4.1 also reuses entry points from these extensions: */
+/* ARB_ES2_compatibility */
+/* ARB_get_program_binary */
+/* ARB_separate_shader_objects */
+/* ARB_shader_precision (no entry points) */
+/* ARB_vertex_attrib_64bit */
+/* ARB_viewport_array */
+#endif
+
+#ifndef GL_ARB_multitexture
+#define GL_ARB_multitexture 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glActiveTextureARB (GLenum texture);
+GLAPI void APIENTRY glClientActiveTextureARB (GLenum texture);
+GLAPI void APIENTRY glMultiTexCoord1dARB (GLenum target, GLdouble s);
+GLAPI void APIENTRY glMultiTexCoord1dvARB (GLenum target, const GLdouble *v);
+GLAPI void APIENTRY glMultiTexCoord1fARB (GLenum target, GLfloat s);
+GLAPI void APIENTRY glMultiTexCoord1fvARB (GLenum target, const GLfloat *v);
+GLAPI void APIENTRY glMultiTexCoord1iARB (GLenum target, GLint s);
+GLAPI void APIENTRY glMultiTexCoord1ivARB (GLenum target, const GLint *v);
+GLAPI void APIENTRY glMultiTexCoord1sARB (GLenum target, GLshort s);
+GLAPI void APIENTRY glMultiTexCoord1svARB (GLenum target, const GLshort *v);
+GLAPI void APIENTRY glMultiTexCoord2dARB (GLenum target, GLdouble s, GLdouble t);
+GLAPI void APIENTRY glMultiTexCoord2dvARB (GLenum target, const GLdouble *v);
+GLAPI void APIENTRY glMultiTexCoord2fARB (GLenum target, GLfloat s, GLfloat t);
+GLAPI void APIENTRY glMultiTexCoord2fvARB (GLenum target, const GLfloat *v);
+GLAPI void APIENTRY glMultiTexCoord2iARB (GLenum target, GLint s, GLint t);
+GLAPI void APIENTRY glMultiTexCoord2ivARB (GLenum target, const GLint *v);
+GLAPI void APIENTRY glMultiTexCoord2sARB (GLenum target, GLshort s, GLshort t);
+GLAPI void APIENTRY glMultiTexCoord2svARB (GLenum target, const GLshort *v);
+GLAPI void APIENTRY glMultiTexCoord3dARB (GLenum target, GLdouble s, GLdouble t, GLdouble r);
+GLAPI void APIENTRY glMultiTexCoord3dvARB (GLenum target, const GLdouble *v);
+GLAPI void APIENTRY glMultiTexCoord3fARB (GLenum target, GLfloat s, GLfloat t, GLfloat r);
+GLAPI void APIENTRY glMultiTexCoord3fvARB (GLenum target, const GLfloat *v);
+GLAPI void APIENTRY glMultiTexCoord3iARB (GLenum target, GLint s, GLint t, GLint r);
+GLAPI void APIENTRY glMultiTexCoord3ivARB (GLenum target, const GLint *v);
+GLAPI void APIENTRY glMultiTexCoord3sARB (GLenum target, GLshort s, GLshort t, GLshort r);
+GLAPI void APIENTRY glMultiTexCoord3svARB (GLenum target, const GLshort *v);
+GLAPI void APIENTRY glMultiTexCoord4dARB (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+GLAPI void APIENTRY glMultiTexCoord4dvARB (GLenum target, const GLdouble *v);
+GLAPI void APIENTRY glMultiTexCoord4fARB (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+GLAPI void APIENTRY glMultiTexCoord4fvARB (GLenum target, const GLfloat *v);
+GLAPI void APIENTRY glMultiTexCoord4iARB (GLenum target, GLint s, GLint t, GLint r, GLint q);
+GLAPI void APIENTRY glMultiTexCoord4ivARB (GLenum target, const GLint *v);
+GLAPI void APIENTRY glMultiTexCoord4sARB (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
+GLAPI void APIENTRY glMultiTexCoord4svARB (GLenum target, const GLshort *v);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLACTIVETEXTUREARBPROC) (GLenum texture);
+typedef void (APIENTRYP PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum texture);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD1DARBPROC) (GLenum target, GLdouble s);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD1DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD1FARBPROC) (GLenum target, GLfloat s);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD1FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD1IARBPROC) (GLenum target, GLint s);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD1IVARBPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD1SARBPROC) (GLenum target, GLshort s);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD1SVARBPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD2DARBPROC) (GLenum target, GLdouble s, GLdouble t);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD2DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLfloat s, GLfloat t);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD2FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD2IARBPROC) (GLenum target, GLint s, GLint t);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD2IVARBPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD2SARBPROC) (GLenum target, GLshort s, GLshort t);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD2SVARBPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD3DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD3DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD3FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD3FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD3IARBPROC) (GLenum target, GLint s, GLint t, GLint r);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD3IVARBPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD3SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD3SVARBPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD4DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD4DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD4FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD4FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD4IARBPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD4IVARBPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD4SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD4SVARBPROC) (GLenum target, const GLshort *v);
+#endif
+
+#ifndef GL_ARB_transpose_matrix
+#define GL_ARB_transpose_matrix 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glLoadTransposeMatrixfARB (const GLfloat *m);
+GLAPI void APIENTRY glLoadTransposeMatrixdARB (const GLdouble *m);
+GLAPI void APIENTRY glMultTransposeMatrixfARB (const GLfloat *m);
+GLAPI void APIENTRY glMultTransposeMatrixdARB (const GLdouble *m);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLLOADTRANSPOSEMATRIXFARBPROC) (const GLfloat *m);
+typedef void (APIENTRYP PFNGLLOADTRANSPOSEMATRIXDARBPROC) (const GLdouble *m);
+typedef void (APIENTRYP PFNGLMULTTRANSPOSEMATRIXFARBPROC) (const GLfloat *m);
+typedef void (APIENTRYP PFNGLMULTTRANSPOSEMATRIXDARBPROC) (const GLdouble *m);
+#endif
+
+#ifndef GL_ARB_multisample
+#define GL_ARB_multisample 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glSampleCoverageARB (GLclampf value, GLboolean invert);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLSAMPLECOVERAGEARBPROC) (GLclampf value, GLboolean invert);
+#endif
+
+#ifndef GL_ARB_texture_env_add
+#define GL_ARB_texture_env_add 1
+#endif
+
+#ifndef GL_ARB_texture_cube_map
+#define GL_ARB_texture_cube_map 1
+#endif
+
+#ifndef GL_ARB_texture_compression
+#define GL_ARB_texture_compression 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glCompressedTexImage3DARB (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
+GLAPI void APIENTRY glCompressedTexImage2DARB (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
+GLAPI void APIENTRY glCompressedTexImage1DARB (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
+GLAPI void APIENTRY glCompressedTexSubImage3DARB (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
+GLAPI void APIENTRY glCompressedTexSubImage2DARB (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
+GLAPI void APIENTRY glCompressedTexSubImage1DARB (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
+GLAPI void APIENTRY glGetCompressedTexImageARB (GLenum target, GLint level, GLvoid *img);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE3DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE2DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE1DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRYP PFNGLGETCOMPRESSEDTEXIMAGEARBPROC) (GLenum target, GLint level, GLvoid *img);
+#endif
+
+#ifndef GL_ARB_texture_border_clamp
+#define GL_ARB_texture_border_clamp 1
+#endif
+
+#ifndef GL_ARB_point_parameters
+#define GL_ARB_point_parameters 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glPointParameterfARB (GLenum pname, GLfloat param);
+GLAPI void APIENTRY glPointParameterfvARB (GLenum pname, const GLfloat *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLPOINTPARAMETERFARBPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRYP PFNGLPOINTPARAMETERFVARBPROC) (GLenum pname, const GLfloat *params);
+#endif
+
+#ifndef GL_ARB_vertex_blend
+#define GL_ARB_vertex_blend 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glWeightbvARB (GLint size, const GLbyte *weights);
+GLAPI void APIENTRY glWeightsvARB (GLint size, const GLshort *weights);
+GLAPI void APIENTRY glWeightivARB (GLint size, const GLint *weights);
+GLAPI void APIENTRY glWeightfvARB (GLint size, const GLfloat *weights);
+GLAPI void APIENTRY glWeightdvARB (GLint size, const GLdouble *weights);
+GLAPI void APIENTRY glWeightubvARB (GLint size, const GLubyte *weights);
+GLAPI void APIENTRY glWeightusvARB (GLint size, const GLushort *weights);
+GLAPI void APIENTRY glWeightuivARB (GLint size, const GLuint *weights);
+GLAPI void APIENTRY glWeightPointerARB (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+GLAPI void APIENTRY glVertexBlendARB (GLint count);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLWEIGHTBVARBPROC) (GLint size, const GLbyte *weights);
+typedef void (APIENTRYP PFNGLWEIGHTSVARBPROC) (GLint size, const GLshort *weights);
+typedef void (APIENTRYP PFNGLWEIGHTIVARBPROC) (GLint size, const GLint *weights);
+typedef void (APIENTRYP PFNGLWEIGHTFVARBPROC) (GLint size, const GLfloat *weights);
+typedef void (APIENTRYP PFNGLWEIGHTDVARBPROC) (GLint size, const GLdouble *weights);
+typedef void (APIENTRYP PFNGLWEIGHTUBVARBPROC) (GLint size, const GLubyte *weights);
+typedef void (APIENTRYP PFNGLWEIGHTUSVARBPROC) (GLint size, const GLushort *weights);
+typedef void (APIENTRYP PFNGLWEIGHTUIVARBPROC) (GLint size, const GLuint *weights);
+typedef void (APIENTRYP PFNGLWEIGHTPOINTERARBPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+typedef void (APIENTRYP PFNGLVERTEXBLENDARBPROC) (GLint count);
+#endif
+
+#ifndef GL_ARB_matrix_palette
+#define GL_ARB_matrix_palette 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glCurrentPaletteMatrixARB (GLint index);
+GLAPI void APIENTRY glMatrixIndexubvARB (GLint size, const GLubyte *indices);
+GLAPI void APIENTRY glMatrixIndexusvARB (GLint size, const GLushort *indices);
+GLAPI void APIENTRY glMatrixIndexuivARB (GLint size, const GLuint *indices);
+GLAPI void APIENTRY glMatrixIndexPointerARB (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLCURRENTPALETTEMATRIXARBPROC) (GLint index);
+typedef void (APIENTRYP PFNGLMATRIXINDEXUBVARBPROC) (GLint size, const GLubyte *indices);
+typedef void (APIENTRYP PFNGLMATRIXINDEXUSVARBPROC) (GLint size, const GLushort *indices);
+typedef void (APIENTRYP PFNGLMATRIXINDEXUIVARBPROC) (GLint size, const GLuint *indices);
+typedef void (APIENTRYP PFNGLMATRIXINDEXPOINTERARBPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+#endif
+
+#ifndef GL_ARB_texture_env_combine
+#define GL_ARB_texture_env_combine 1
+#endif
+
+#ifndef GL_ARB_texture_env_crossbar
+#define GL_ARB_texture_env_crossbar 1
+#endif
+
+#ifndef GL_ARB_texture_env_dot3
+#define GL_ARB_texture_env_dot3 1
+#endif
+
+#ifndef GL_ARB_texture_mirrored_repeat
+#define GL_ARB_texture_mirrored_repeat 1
+#endif
+
+#ifndef GL_ARB_depth_texture
+#define GL_ARB_depth_texture 1
+#endif
+
+#ifndef GL_ARB_shadow
+#define GL_ARB_shadow 1
+#endif
+
+#ifndef GL_ARB_shadow_ambient
+#define GL_ARB_shadow_ambient 1
+#endif
+
+#ifndef GL_ARB_window_pos
+#define GL_ARB_window_pos 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glWindowPos2dARB (GLdouble x, GLdouble y);
+GLAPI void APIENTRY glWindowPos2dvARB (const GLdouble *v);
+GLAPI void APIENTRY glWindowPos2fARB (GLfloat x, GLfloat y);
+GLAPI void APIENTRY glWindowPos2fvARB (const GLfloat *v);
+GLAPI void APIENTRY glWindowPos2iARB (GLint x, GLint y);
+GLAPI void APIENTRY glWindowPos2ivARB (const GLint *v);
+GLAPI void APIENTRY glWindowPos2sARB (GLshort x, GLshort y);
+GLAPI void APIENTRY glWindowPos2svARB (const GLshort *v);
+GLAPI void APIENTRY glWindowPos3dARB (GLdouble x, GLdouble y, GLdouble z);
+GLAPI void APIENTRY glWindowPos3dvARB (const GLdouble *v);
+GLAPI void APIENTRY glWindowPos3fARB (GLfloat x, GLfloat y, GLfloat z);
+GLAPI void APIENTRY glWindowPos3fvARB (const GLfloat *v);
+GLAPI void APIENTRY glWindowPos3iARB (GLint x, GLint y, GLint z);
+GLAPI void APIENTRY glWindowPos3ivARB (const GLint *v);
+GLAPI void APIENTRY glWindowPos3sARB (GLshort x, GLshort y, GLshort z);
+GLAPI void APIENTRY glWindowPos3svARB (const GLshort *v);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLWINDOWPOS2DARBPROC) (GLdouble x, GLdouble y);
+typedef void (APIENTRYP PFNGLWINDOWPOS2DVARBPROC) (const GLdouble *v);
+typedef void (APIENTRYP PFNGLWINDOWPOS2FARBPROC) (GLfloat x, GLfloat y);
+typedef void (APIENTRYP PFNGLWINDOWPOS2FVARBPROC) (const GLfloat *v);
+typedef void (APIENTRYP PFNGLWINDOWPOS2IARBPROC) (GLint x, GLint y);
+typedef void (APIENTRYP PFNGLWINDOWPOS2IVARBPROC) (const GLint *v);
+typedef void (APIENTRYP PFNGLWINDOWPOS2SARBPROC) (GLshort x, GLshort y);
+typedef void (APIENTRYP PFNGLWINDOWPOS2SVARBPROC) (const GLshort *v);
+typedef void (APIENTRYP PFNGLWINDOWPOS3DARBPROC) (GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRYP PFNGLWINDOWPOS3DVARBPROC) (const GLdouble *v);
+typedef void (APIENTRYP PFNGLWINDOWPOS3FARBPROC) (GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRYP PFNGLWINDOWPOS3FVARBPROC) (const GLfloat *v);
+typedef void (APIENTRYP PFNGLWINDOWPOS3IARBPROC) (GLint x, GLint y, GLint z);
+typedef void (APIENTRYP PFNGLWINDOWPOS3IVARBPROC) (const GLint *v);
+typedef void (APIENTRYP PFNGLWINDOWPOS3SARBPROC) (GLshort x, GLshort y, GLshort z);
+typedef void (APIENTRYP PFNGLWINDOWPOS3SVARBPROC) (const GLshort *v);
+#endif
+
+#ifndef GL_ARB_vertex_program
+#define GL_ARB_vertex_program 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glVertexAttrib1dARB (GLuint index, GLdouble x);
+GLAPI void APIENTRY glVertexAttrib1dvARB (GLuint index, const GLdouble *v);
+GLAPI void APIENTRY glVertexAttrib1fARB (GLuint index, GLfloat x);
+GLAPI void APIENTRY glVertexAttrib1fvARB (GLuint index, const GLfloat *v);
+GLAPI void APIENTRY glVertexAttrib1sARB (GLuint index, GLshort x);
+GLAPI void APIENTRY glVertexAttrib1svARB (GLuint index, const GLshort *v);
+GLAPI void APIENTRY glVertexAttrib2dARB (GLuint index, GLdouble x, GLdouble y);
+GLAPI void APIENTRY glVertexAttrib2dvARB (GLuint index, const GLdouble *v);
+GLAPI void APIENTRY glVertexAttrib2fARB (GLuint index, GLfloat x, GLfloat y);
+GLAPI void APIENTRY glVertexAttrib2fvARB (GLuint index, const GLfloat *v);
+GLAPI void APIENTRY glVertexAttrib2sARB (GLuint index, GLshort x, GLshort y);
+GLAPI void APIENTRY glVertexAttrib2svARB (GLuint index, const GLshort *v);
+GLAPI void APIENTRY glVertexAttrib3dARB (GLuint index, GLdouble x, GLdouble y, GLdouble z);
+GLAPI void APIENTRY glVertexAttrib3dvARB (GLuint index, const GLdouble *v);
+GLAPI void APIENTRY glVertexAttrib3fARB (GLuint index, GLfloat x, GLfloat y, GLfloat z);
+GLAPI void APIENTRY glVertexAttrib3fvARB (GLuint index, const GLfloat *v);
+GLAPI void APIENTRY glVertexAttrib3sARB (GLuint index, GLshort x, GLshort y, GLshort z);
+GLAPI void APIENTRY glVertexAttrib3svARB (GLuint index, const GLshort *v);
+GLAPI void APIENTRY glVertexAttrib4NbvARB (GLuint index, const GLbyte *v);
+GLAPI void APIENTRY glVertexAttrib4NivARB (GLuint index, const GLint *v);
+GLAPI void APIENTRY glVertexAttrib4NsvARB (GLuint index, const GLshort *v);
+GLAPI void APIENTRY glVertexAttrib4NubARB (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+GLAPI void APIENTRY glVertexAttrib4NubvARB (GLuint index, const GLubyte *v);
+GLAPI void APIENTRY glVertexAttrib4NuivARB (GLuint index, const GLuint *v);
+GLAPI void APIENTRY glVertexAttrib4NusvARB (GLuint index, const GLushort *v);
+GLAPI void APIENTRY glVertexAttrib4bvARB (GLuint index, const GLbyte *v);
+GLAPI void APIENTRY glVertexAttrib4dARB (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+GLAPI void APIENTRY glVertexAttrib4dvARB (GLuint index, const GLdouble *v);
+GLAPI void APIENTRY glVertexAttrib4fARB (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+GLAPI void APIENTRY glVertexAttrib4fvARB (GLuint index, const GLfloat *v);
+GLAPI void APIENTRY glVertexAttrib4ivARB (GLuint index, const GLint *v);
+GLAPI void APIENTRY glVertexAttrib4sARB (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+GLAPI void APIENTRY glVertexAttrib4svARB (GLuint index, const GLshort *v);
+GLAPI void APIENTRY glVertexAttrib4ubvARB (GLuint index, const GLubyte *v);
+GLAPI void APIENTRY glVertexAttrib4uivARB (GLuint index, const GLuint *v);
+GLAPI void APIENTRY glVertexAttrib4usvARB (GLuint index, const GLushort *v);
+GLAPI void APIENTRY glVertexAttribPointerARB (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
+GLAPI void APIENTRY glEnableVertexAttribArrayARB (GLuint index);
+GLAPI void APIENTRY glDisableVertexAttribArrayARB (GLuint index);
+GLAPI void APIENTRY glProgramStringARB (GLenum target, GLenum format, GLsizei len, const GLvoid *string);
+GLAPI void APIENTRY glBindProgramARB (GLenum target, GLuint program);
+GLAPI void APIENTRY glDeleteProgramsARB (GLsizei n, const GLuint *programs);
+GLAPI void APIENTRY glGenProgramsARB (GLsizei n, GLuint *programs);
+GLAPI void APIENTRY glProgramEnvParameter4dARB (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+GLAPI void APIENTRY glProgramEnvParameter4dvARB (GLenum target, GLuint index, const GLdouble *params);
+GLAPI void APIENTRY glProgramEnvParameter4fARB (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+GLAPI void APIENTRY glProgramEnvParameter4fvARB (GLenum target, GLuint index, const GLfloat *params);
+GLAPI void APIENTRY glProgramLocalParameter4dARB (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+GLAPI void APIENTRY glProgramLocalParameter4dvARB (GLenum target, GLuint index, const GLdouble *params);
+GLAPI void APIENTRY glProgramLocalParameter4fARB (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+GLAPI void APIENTRY glProgramLocalParameter4fvARB (GLenum target, GLuint index, const GLfloat *params);
+GLAPI void APIENTRY glGetProgramEnvParameterdvARB (GLenum target, GLuint index, GLdouble *params);
+GLAPI void APIENTRY glGetProgramEnvParameterfvARB (GLenum target, GLuint index, GLfloat *params);
+GLAPI void APIENTRY glGetProgramLocalParameterdvARB (GLenum target, GLuint index, GLdouble *params);
+GLAPI void APIENTRY glGetProgramLocalParameterfvARB (GLenum target, GLuint index, GLfloat *params);
+GLAPI void APIENTRY glGetProgramivARB (GLenum target, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetProgramStringARB (GLenum target, GLenum pname, GLvoid *string);
+GLAPI void APIENTRY glGetVertexAttribdvARB (GLuint index, GLenum pname, GLdouble *params);
+GLAPI void APIENTRY glGetVertexAttribfvARB (GLuint index, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetVertexAttribivARB (GLuint index, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetVertexAttribPointervARB (GLuint index, GLenum pname, GLvoid* *pointer);
+GLAPI GLboolean APIENTRY glIsProgramARB (GLuint program);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLVERTEXATTRIB1DARBPROC) (GLuint index, GLdouble x);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB1DVARBPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB1FARBPROC) (GLuint index, GLfloat x);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB1FVARBPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB1SARBPROC) (GLuint index, GLshort x);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB1SVARBPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB2DARBPROC) (GLuint index, GLdouble x, GLdouble y);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB2DVARBPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB2FARBPROC) (GLuint index, GLfloat x, GLfloat y);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB2FVARBPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB2SARBPROC) (GLuint index, GLshort x, GLshort y);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB2SVARBPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB3DARBPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB3DVARBPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB3FARBPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB3FVARBPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB3SARBPROC) (GLuint index, GLshort x, GLshort y, GLshort z);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB3SVARBPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4NBVARBPROC) (GLuint index, const GLbyte *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4NIVARBPROC) (GLuint index, const GLint *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4NSVARBPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBARBPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBVARBPROC) (GLuint index, const GLubyte *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUIVARBPROC) (GLuint index, const GLuint *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUSVARBPROC) (GLuint index, const GLushort *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4BVARBPROC) (GLuint index, const GLbyte *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4DARBPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4DVARBPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4FARBPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4FVARBPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4IVARBPROC) (GLuint index, const GLint *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4SARBPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4SVARBPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBVARBPROC) (GLuint index, const GLubyte *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4UIVARBPROC) (GLuint index, const GLuint *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4USVARBPROC) (GLuint index, const GLushort *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERARBPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
+typedef void (APIENTRYP PFNGLENABLEVERTEXATTRIBARRAYARBPROC) (GLuint index);
+typedef void (APIENTRYP PFNGLDISABLEVERTEXATTRIBARRAYARBPROC) (GLuint index);
+typedef void (APIENTRYP PFNGLPROGRAMSTRINGARBPROC) (GLenum target, GLenum format, GLsizei len, const GLvoid *string);
+typedef void (APIENTRYP PFNGLBINDPROGRAMARBPROC) (GLenum target, GLuint program);
+typedef void (APIENTRYP PFNGLDELETEPROGRAMSARBPROC) (GLsizei n, const GLuint *programs);
+typedef void (APIENTRYP PFNGLGENPROGRAMSARBPROC) (GLsizei n, GLuint *programs);
+typedef void (APIENTRYP PFNGLPROGRAMENVPARAMETER4DARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRYP PFNGLPROGRAMENVPARAMETER4DVARBPROC) (GLenum target, GLuint index, const GLdouble *params);
+typedef void (APIENTRYP PFNGLPROGRAMENVPARAMETER4FARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRYP PFNGLPROGRAMENVPARAMETER4FVARBPROC) (GLenum target, GLuint index, const GLfloat *params);
+typedef void (APIENTRYP PFNGLPROGRAMLOCALPARAMETER4DARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRYP PFNGLPROGRAMLOCALPARAMETER4DVARBPROC) (GLenum target, GLuint index, const GLdouble *params);
+typedef void (APIENTRYP PFNGLPROGRAMLOCALPARAMETER4FARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRYP PFNGLPROGRAMLOCALPARAMETER4FVARBPROC) (GLenum target, GLuint index, const GLfloat *params);
+typedef void (APIENTRYP PFNGLGETPROGRAMENVPARAMETERDVARBPROC) (GLenum target, GLuint index, GLdouble *params);
+typedef void (APIENTRYP PFNGLGETPROGRAMENVPARAMETERFVARBPROC) (GLenum target, GLuint index, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC) (GLenum target, GLuint index, GLdouble *params);
+typedef void (APIENTRYP PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC) (GLenum target, GLuint index, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETPROGRAMIVARBPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETPROGRAMSTRINGARBPROC) (GLenum target, GLenum pname, GLvoid *string);
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBDVARBPROC) (GLuint index, GLenum pname, GLdouble *params);
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBFVARBPROC) (GLuint index, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVARBPROC) (GLuint index, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBPOINTERVARBPROC) (GLuint index, GLenum pname, GLvoid* *pointer);
+typedef GLboolean (APIENTRYP PFNGLISPROGRAMARBPROC) (GLuint program);
+#endif
+
+#ifndef GL_ARB_fragment_program
+#define GL_ARB_fragment_program 1
+/* All ARB_fragment_program entry points are shared with ARB_vertex_program. */
+#endif
+
+#ifndef GL_ARB_vertex_buffer_object
+#define GL_ARB_vertex_buffer_object 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBindBufferARB (GLenum target, GLuint buffer);
+GLAPI void APIENTRY glDeleteBuffersARB (GLsizei n, const GLuint *buffers);
+GLAPI void APIENTRY glGenBuffersARB (GLsizei n, GLuint *buffers);
+GLAPI GLboolean APIENTRY glIsBufferARB (GLuint buffer);
+GLAPI void APIENTRY glBufferDataARB (GLenum target, GLsizeiptrARB size, const GLvoid *data, GLenum usage);
+GLAPI void APIENTRY glBufferSubDataARB (GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid *data);
+GLAPI void APIENTRY glGetBufferSubDataARB (GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid *data);
+GLAPI GLvoid* APIENTRY glMapBufferARB (GLenum target, GLenum access);
+GLAPI GLboolean APIENTRY glUnmapBufferARB (GLenum target);
+GLAPI void APIENTRY glGetBufferParameterivARB (GLenum target, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetBufferPointervARB (GLenum target, GLenum pname, GLvoid* *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLBINDBUFFERARBPROC) (GLenum target, GLuint buffer);
+typedef void (APIENTRYP PFNGLDELETEBUFFERSARBPROC) (GLsizei n, const GLuint *buffers);
+typedef void (APIENTRYP PFNGLGENBUFFERSARBPROC) (GLsizei n, GLuint *buffers);
+typedef GLboolean (APIENTRYP PFNGLISBUFFERARBPROC) (GLuint buffer);
+typedef void (APIENTRYP PFNGLBUFFERDATAARBPROC) (GLenum target, GLsizeiptrARB size, const GLvoid *data, GLenum usage);
+typedef void (APIENTRYP PFNGLBUFFERSUBDATAARBPROC) (GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid *data);
+typedef void (APIENTRYP PFNGLGETBUFFERSUBDATAARBPROC) (GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid *data);
+typedef GLvoid* (APIENTRYP PFNGLMAPBUFFERARBPROC) (GLenum target, GLenum access);
+typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERARBPROC) (GLenum target);
+typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERIVARBPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETBUFFERPOINTERVARBPROC) (GLenum target, GLenum pname, GLvoid* *params);
+#endif
+
+#ifndef GL_ARB_occlusion_query
+#define GL_ARB_occlusion_query 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glGenQueriesARB (GLsizei n, GLuint *ids);
+GLAPI void APIENTRY glDeleteQueriesARB (GLsizei n, const GLuint *ids);
+GLAPI GLboolean APIENTRY glIsQueryARB (GLuint id);
+GLAPI void APIENTRY glBeginQueryARB (GLenum target, GLuint id);
+GLAPI void APIENTRY glEndQueryARB (GLenum target);
+GLAPI void APIENTRY glGetQueryivARB (GLenum target, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetQueryObjectivARB (GLuint id, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetQueryObjectuivARB (GLuint id, GLenum pname, GLuint *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLGENQUERIESARBPROC) (GLsizei n, GLuint *ids);
+typedef void (APIENTRYP PFNGLDELETEQUERIESARBPROC) (GLsizei n, const GLuint *ids);
+typedef GLboolean (APIENTRYP PFNGLISQUERYARBPROC) (GLuint id);
+typedef void (APIENTRYP PFNGLBEGINQUERYARBPROC) (GLenum target, GLuint id);
+typedef void (APIENTRYP PFNGLENDQUERYARBPROC) (GLenum target);
+typedef void (APIENTRYP PFNGLGETQUERYIVARBPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETQUERYOBJECTIVARBPROC) (GLuint id, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETQUERYOBJECTUIVARBPROC) (GLuint id, GLenum pname, GLuint *params);
+#endif
+
+#ifndef GL_ARB_shader_objects
+#define GL_ARB_shader_objects 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glDeleteObjectARB (GLhandleARB obj);
+GLAPI GLhandleARB APIENTRY glGetHandleARB (GLenum pname);
+GLAPI void APIENTRY glDetachObjectARB (GLhandleARB containerObj, GLhandleARB attachedObj);
+GLAPI GLhandleARB APIENTRY glCreateShaderObjectARB (GLenum shaderType);
+GLAPI void APIENTRY glShaderSourceARB (GLhandleARB shaderObj, GLsizei count, const GLcharARB* *string, const GLint *length);
+GLAPI void APIENTRY glCompileShaderARB (GLhandleARB shaderObj);
+GLAPI GLhandleARB APIENTRY glCreateProgramObjectARB (void);
+GLAPI void APIENTRY glAttachObjectARB (GLhandleARB containerObj, GLhandleARB obj);
+GLAPI void APIENTRY glLinkProgramARB (GLhandleARB programObj);
+GLAPI void APIENTRY glUseProgramObjectARB (GLhandleARB programObj);
+GLAPI void APIENTRY glValidateProgramARB (GLhandleARB programObj);
+GLAPI void APIENTRY glUniform1fARB (GLint location, GLfloat v0);
+GLAPI void APIENTRY glUniform2fARB (GLint location, GLfloat v0, GLfloat v1);
+GLAPI void APIENTRY glUniform3fARB (GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+GLAPI void APIENTRY glUniform4fARB (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+GLAPI void APIENTRY glUniform1iARB (GLint location, GLint v0);
+GLAPI void APIENTRY glUniform2iARB (GLint location, GLint v0, GLint v1);
+GLAPI void APIENTRY glUniform3iARB (GLint location, GLint v0, GLint v1, GLint v2);
+GLAPI void APIENTRY glUniform4iARB (GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+GLAPI void APIENTRY glUniform1fvARB (GLint location, GLsizei count, const GLfloat *value);
+GLAPI void APIENTRY glUniform2fvARB (GLint location, GLsizei count, const GLfloat *value);
+GLAPI void APIENTRY glUniform3fvARB (GLint location, GLsizei count, const GLfloat *value);
+GLAPI void APIENTRY glUniform4fvARB (GLint location, GLsizei count, const GLfloat *value);
+GLAPI void APIENTRY glUniform1ivARB (GLint location, GLsizei count, const GLint *value);
+GLAPI void APIENTRY glUniform2ivARB (GLint location, GLsizei count, const GLint *value);
+GLAPI void APIENTRY glUniform3ivARB (GLint location, GLsizei count, const GLint *value);
+GLAPI void APIENTRY glUniform4ivARB (GLint location, GLsizei count, const GLint *value);
+GLAPI void APIENTRY glUniformMatrix2fvARB (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glUniformMatrix3fvARB (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glUniformMatrix4fvARB (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glGetObjectParameterfvARB (GLhandleARB obj, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetObjectParameterivARB (GLhandleARB obj, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetInfoLogARB (GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *infoLog);
+GLAPI void APIENTRY glGetAttachedObjectsARB (GLhandleARB containerObj, GLsizei maxCount, GLsizei *count, GLhandleARB *obj);
+GLAPI GLint APIENTRY glGetUniformLocationARB (GLhandleARB programObj, const GLcharARB *name);
+GLAPI void APIENTRY glGetActiveUniformARB (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name);
+GLAPI void APIENTRY glGetUniformfvARB (GLhandleARB programObj, GLint location, GLfloat *params);
+GLAPI void APIENTRY glGetUniformivARB (GLhandleARB programObj, GLint location, GLint *params);
+GLAPI void APIENTRY glGetShaderSourceARB (GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *source);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLDELETEOBJECTARBPROC) (GLhandleARB obj);
+typedef GLhandleARB (APIENTRYP PFNGLGETHANDLEARBPROC) (GLenum pname);
+typedef void (APIENTRYP PFNGLDETACHOBJECTARBPROC) (GLhandleARB containerObj, GLhandleARB attachedObj);
+typedef GLhandleARB (APIENTRYP PFNGLCREATESHADEROBJECTARBPROC) (GLenum shaderType);
+typedef void (APIENTRYP PFNGLSHADERSOURCEARBPROC) (GLhandleARB shaderObj, GLsizei count, const GLcharARB* *string, const GLint *length);
+typedef void (APIENTRYP PFNGLCOMPILESHADERARBPROC) (GLhandleARB shaderObj);
+typedef GLhandleARB (APIENTRYP PFNGLCREATEPROGRAMOBJECTARBPROC) (void);
+typedef void (APIENTRYP PFNGLATTACHOBJECTARBPROC) (GLhandleARB containerObj, GLhandleARB obj);
+typedef void (APIENTRYP PFNGLLINKPROGRAMARBPROC) (GLhandleARB programObj);
+typedef void (APIENTRYP PFNGLUSEPROGRAMOBJECTARBPROC) (GLhandleARB programObj);
+typedef void (APIENTRYP PFNGLVALIDATEPROGRAMARBPROC) (GLhandleARB programObj);
+typedef void (APIENTRYP PFNGLUNIFORM1FARBPROC) (GLint location, GLfloat v0);
+typedef void (APIENTRYP PFNGLUNIFORM2FARBPROC) (GLint location, GLfloat v0, GLfloat v1);
+typedef void (APIENTRYP PFNGLUNIFORM3FARBPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+typedef void (APIENTRYP PFNGLUNIFORM4FARBPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+typedef void (APIENTRYP PFNGLUNIFORM1IARBPROC) (GLint location, GLint v0);
+typedef void (APIENTRYP PFNGLUNIFORM2IARBPROC) (GLint location, GLint v0, GLint v1);
+typedef void (APIENTRYP PFNGLUNIFORM3IARBPROC) (GLint location, GLint v0, GLint v1, GLint v2);
+typedef void (APIENTRYP PFNGLUNIFORM4IARBPROC) (GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+typedef void (APIENTRYP PFNGLUNIFORM1FVARBPROC) (GLint location, GLsizei count, const GLfloat *value);
+typedef void (APIENTRYP PFNGLUNIFORM2FVARBPROC) (GLint location, GLsizei count, const GLfloat *value);
+typedef void (APIENTRYP PFNGLUNIFORM3FVARBPROC) (GLint location, GLsizei count, const GLfloat *value);
+typedef void (APIENTRYP PFNGLUNIFORM4FVARBPROC) (GLint location, GLsizei count, const GLfloat *value);
+typedef void (APIENTRYP PFNGLUNIFORM1IVARBPROC) (GLint location, GLsizei count, const GLint *value);
+typedef void (APIENTRYP PFNGLUNIFORM2IVARBPROC) (GLint location, GLsizei count, const GLint *value);
+typedef void (APIENTRYP PFNGLUNIFORM3IVARBPROC) (GLint location, GLsizei count, const GLint *value);
+typedef void (APIENTRYP PFNGLUNIFORM4IVARBPROC) (GLint location, GLsizei count, const GLint *value);
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX2FVARBPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX3FVARBPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX4FVARBPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLGETOBJECTPARAMETERFVARBPROC) (GLhandleARB obj, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETOBJECTPARAMETERIVARBPROC) (GLhandleARB obj, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETINFOLOGARBPROC) (GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *infoLog);
+typedef void (APIENTRYP PFNGLGETATTACHEDOBJECTSARBPROC) (GLhandleARB containerObj, GLsizei maxCount, GLsizei *count, GLhandleARB *obj);
+typedef GLint (APIENTRYP PFNGLGETUNIFORMLOCATIONARBPROC) (GLhandleARB programObj, const GLcharARB *name);
+typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMARBPROC) (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name);
+typedef void (APIENTRYP PFNGLGETUNIFORMFVARBPROC) (GLhandleARB programObj, GLint location, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETUNIFORMIVARBPROC) (GLhandleARB programObj, GLint location, GLint *params);
+typedef void (APIENTRYP PFNGLGETSHADERSOURCEARBPROC) (GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *source);
+#endif
+
+#ifndef GL_ARB_vertex_shader
+#define GL_ARB_vertex_shader 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBindAttribLocationARB (GLhandleARB programObj, GLuint index, const GLcharARB *name);
+GLAPI void APIENTRY glGetActiveAttribARB (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name);
+GLAPI GLint APIENTRY glGetAttribLocationARB (GLhandleARB programObj, const GLcharARB *name);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLBINDATTRIBLOCATIONARBPROC) (GLhandleARB programObj, GLuint index, const GLcharARB *name);
+typedef void (APIENTRYP PFNGLGETACTIVEATTRIBARBPROC) (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name);
+typedef GLint (APIENTRYP PFNGLGETATTRIBLOCATIONARBPROC) (GLhandleARB programObj, const GLcharARB *name);
+#endif
+
+#ifndef GL_ARB_fragment_shader
+#define GL_ARB_fragment_shader 1
+#endif
+
+#ifndef GL_ARB_shading_language_100
+#define GL_ARB_shading_language_100 1
+#endif
+
+#ifndef GL_ARB_texture_non_power_of_two
+#define GL_ARB_texture_non_power_of_two 1
+#endif
+
+#ifndef GL_ARB_point_sprite
+#define GL_ARB_point_sprite 1
+#endif
+
+#ifndef GL_ARB_fragment_program_shadow
+#define GL_ARB_fragment_program_shadow 1
+#endif
+
+#ifndef GL_ARB_draw_buffers
+#define GL_ARB_draw_buffers 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glDrawBuffersARB (GLsizei n, const GLenum *bufs);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLDRAWBUFFERSARBPROC) (GLsizei n, const GLenum *bufs);
+#endif
+
+#ifndef GL_ARB_texture_rectangle
+#define GL_ARB_texture_rectangle 1
+#endif
+
+#ifndef GL_ARB_color_buffer_float
+#define GL_ARB_color_buffer_float 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glClampColorARB (GLenum target, GLenum clamp);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLCLAMPCOLORARBPROC) (GLenum target, GLenum clamp);
+#endif
+
+#ifndef GL_ARB_half_float_pixel
+#define GL_ARB_half_float_pixel 1
+#endif
+
+#ifndef GL_ARB_texture_float
+#define GL_ARB_texture_float 1
+#endif
+
+#ifndef GL_ARB_pixel_buffer_object
+#define GL_ARB_pixel_buffer_object 1
+#endif
+
+#ifndef GL_ARB_depth_buffer_float
+#define GL_ARB_depth_buffer_float 1
+#endif
+
+#ifndef GL_ARB_draw_instanced
+#define GL_ARB_draw_instanced 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glDrawArraysInstancedARB (GLenum mode, GLint first, GLsizei count, GLsizei primcount);
+GLAPI void APIENTRY glDrawElementsInstancedARB (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLDRAWARRAYSINSTANCEDARBPROC) (GLenum mode, GLint first, GLsizei count, GLsizei primcount);
+typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDARBPROC) (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount);
+#endif
+
+#ifndef GL_ARB_framebuffer_object
+#define GL_ARB_framebuffer_object 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI GLboolean APIENTRY glIsRenderbuffer (GLuint renderbuffer);
+GLAPI void APIENTRY glBindRenderbuffer (GLenum target, GLuint renderbuffer);
+GLAPI void APIENTRY glDeleteRenderbuffers (GLsizei n, const GLuint *renderbuffers);
+GLAPI void APIENTRY glGenRenderbuffers (GLsizei n, GLuint *renderbuffers);
+GLAPI void APIENTRY glRenderbufferStorage (GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
+GLAPI void APIENTRY glGetRenderbufferParameteriv (GLenum target, GLenum pname, GLint *params);
+GLAPI GLboolean APIENTRY glIsFramebuffer (GLuint framebuffer);
+GLAPI void APIENTRY glBindFramebuffer (GLenum target, GLuint framebuffer);
+GLAPI void APIENTRY glDeleteFramebuffers (GLsizei n, const GLuint *framebuffers);
+GLAPI void APIENTRY glGenFramebuffers (GLsizei n, GLuint *framebuffers);
+GLAPI GLenum APIENTRY glCheckFramebufferStatus (GLenum target);
+GLAPI void APIENTRY glFramebufferTexture1D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+GLAPI void APIENTRY glFramebufferTexture2D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+GLAPI void APIENTRY glFramebufferTexture3D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
+GLAPI void APIENTRY glFramebufferRenderbuffer (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
+GLAPI void APIENTRY glGetFramebufferAttachmentParameteriv (GLenum target, GLenum attachment, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGenerateMipmap (GLenum target);
+GLAPI void APIENTRY glBlitFramebuffer (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+GLAPI void APIENTRY glRenderbufferStorageMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+GLAPI void APIENTRY glFramebufferTextureLayer (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef GLboolean (APIENTRYP PFNGLISRENDERBUFFERPROC) (GLuint renderbuffer);
+typedef void (APIENTRYP PFNGLBINDRENDERBUFFERPROC) (GLenum target, GLuint renderbuffer);
+typedef void (APIENTRYP PFNGLDELETERENDERBUFFERSPROC) (GLsizei n, const GLuint *renderbuffers);
+typedef void (APIENTRYP PFNGLGENRENDERBUFFERSPROC) (GLsizei n, GLuint *renderbuffers);
+typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
+typedef void (APIENTRYP PFNGLGETRENDERBUFFERPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params);
+typedef GLboolean (APIENTRYP PFNGLISFRAMEBUFFERPROC) (GLuint framebuffer);
+typedef void (APIENTRYP PFNGLBINDFRAMEBUFFERPROC) (GLenum target, GLuint framebuffer);
+typedef void (APIENTRYP PFNGLDELETEFRAMEBUFFERSPROC) (GLsizei n, const GLuint *framebuffers);
+typedef void (APIENTRYP PFNGLGENFRAMEBUFFERSPROC) (GLsizei n, GLuint *framebuffers);
+typedef GLenum (APIENTRYP PFNGLCHECKFRAMEBUFFERSTATUSPROC) (GLenum target);
+typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE1DPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE2DPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE3DPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
+typedef void (APIENTRYP PFNGLFRAMEBUFFERRENDERBUFFERPROC) (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
+typedef void (APIENTRYP PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC) (GLenum target, GLenum attachment, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGENERATEMIPMAPPROC) (GLenum target);
+typedef void (APIENTRYP PFNGLBLITFRAMEBUFFERPROC) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURELAYERPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
+#endif
+
+#ifndef GL_ARB_framebuffer_sRGB
+#define GL_ARB_framebuffer_sRGB 1
+#endif
+
+#ifndef GL_ARB_geometry_shader4
+#define GL_ARB_geometry_shader4 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glProgramParameteriARB (GLuint program, GLenum pname, GLint value);
+GLAPI void APIENTRY glFramebufferTextureARB (GLenum target, GLenum attachment, GLuint texture, GLint level);
+GLAPI void APIENTRY glFramebufferTextureLayerARB (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
+GLAPI void APIENTRY glFramebufferTextureFaceARB (GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLPROGRAMPARAMETERIARBPROC) (GLuint program, GLenum pname, GLint value);
+typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTUREARBPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level);
+typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURELAYERARBPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
+typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTUREFACEARBPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face);
+#endif
+
+#ifndef GL_ARB_half_float_vertex
+#define GL_ARB_half_float_vertex 1
+#endif
+
+#ifndef GL_ARB_instanced_arrays
+#define GL_ARB_instanced_arrays 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glVertexAttribDivisorARB (GLuint index, GLuint divisor);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLVERTEXATTRIBDIVISORARBPROC) (GLuint index, GLuint divisor);
+#endif
+
+#ifndef GL_ARB_map_buffer_range
+#define GL_ARB_map_buffer_range 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI GLvoid* APIENTRY glMapBufferRange (GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
+GLAPI void APIENTRY glFlushMappedBufferRange (GLenum target, GLintptr offset, GLsizeiptr length);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef GLvoid* (APIENTRYP PFNGLMAPBUFFERRANGEPROC) (GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
+typedef void (APIENTRYP PFNGLFLUSHMAPPEDBUFFERRANGEPROC) (GLenum target, GLintptr offset, GLsizeiptr length);
+#endif
+
+#ifndef GL_ARB_texture_buffer_object
+#define GL_ARB_texture_buffer_object 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glTexBufferARB (GLenum target, GLenum internalformat, GLuint buffer);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLTEXBUFFERARBPROC) (GLenum target, GLenum internalformat, GLuint buffer);
+#endif
+
+#ifndef GL_ARB_texture_compression_rgtc
+#define GL_ARB_texture_compression_rgtc 1
+#endif
+
+#ifndef GL_ARB_texture_rg
+#define GL_ARB_texture_rg 1
+#endif
+
+#ifndef GL_ARB_vertex_array_object
+#define GL_ARB_vertex_array_object 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBindVertexArray (GLuint array);
+GLAPI void APIENTRY glDeleteVertexArrays (GLsizei n, const GLuint *arrays);
+GLAPI void APIENTRY glGenVertexArrays (GLsizei n, GLuint *arrays);
+GLAPI GLboolean APIENTRY glIsVertexArray (GLuint array);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLBINDVERTEXARRAYPROC) (GLuint array);
+typedef void (APIENTRYP PFNGLDELETEVERTEXARRAYSPROC) (GLsizei n, const GLuint *arrays);
+typedef void (APIENTRYP PFNGLGENVERTEXARRAYSPROC) (GLsizei n, GLuint *arrays);
+typedef GLboolean (APIENTRYP PFNGLISVERTEXARRAYPROC) (GLuint array);
+#endif
+
+#ifndef GL_ARB_uniform_buffer_object
+#define GL_ARB_uniform_buffer_object 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glGetUniformIndices (GLuint program, GLsizei uniformCount, const GLchar* *uniformNames, GLuint *uniformIndices);
+GLAPI void APIENTRY glGetActiveUniformsiv (GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetActiveUniformName (GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName);
+GLAPI GLuint APIENTRY glGetUniformBlockIndex (GLuint program, const GLchar *uniformBlockName);
+GLAPI void APIENTRY glGetActiveUniformBlockiv (GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetActiveUniformBlockName (GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
+GLAPI void APIENTRY glUniformBlockBinding (GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLGETUNIFORMINDICESPROC) (GLuint program, GLsizei uniformCount, const GLchar* *uniformNames, GLuint *uniformIndices);
+typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMSIVPROC) (GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMNAMEPROC) (GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName);
+typedef GLuint (APIENTRYP PFNGLGETUNIFORMBLOCKINDEXPROC) (GLuint program, const GLchar *uniformBlockName);
+typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKIVPROC) (GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC) (GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
+typedef void (APIENTRYP PFNGLUNIFORMBLOCKBINDINGPROC) (GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
+#endif
+
+#ifndef GL_ARB_compatibility
+#define GL_ARB_compatibility 1
+#endif
+
+#ifndef GL_ARB_copy_buffer
+#define GL_ARB_copy_buffer 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glCopyBufferSubData (GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLCOPYBUFFERSUBDATAPROC) (GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
+#endif
+
+#ifndef GL_ARB_shader_texture_lod
+#define GL_ARB_shader_texture_lod 1
+#endif
+
+#ifndef GL_ARB_depth_clamp
+#define GL_ARB_depth_clamp 1
+#endif
+
+#ifndef GL_ARB_draw_elements_base_vertex
+#define GL_ARB_draw_elements_base_vertex 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glDrawElementsBaseVertex (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
+GLAPI void APIENTRY glDrawRangeElementsBaseVertex (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
+GLAPI void APIENTRY glDrawElementsInstancedBaseVertex (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount, GLint basevertex);
+GLAPI void APIENTRY glMultiDrawElementsBaseVertex (GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount, const GLint *basevertex);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLDRAWELEMENTSBASEVERTEXPROC) (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
+typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
+typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC) (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount, GLint basevertex);
+typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC) (GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount, const GLint *basevertex);
+#endif
+
+#ifndef GL_ARB_fragment_coord_conventions
+#define GL_ARB_fragment_coord_conventions 1
+#endif
+
+#ifndef GL_ARB_provoking_vertex
+#define GL_ARB_provoking_vertex 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glProvokingVertex (GLenum mode);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLPROVOKINGVERTEXPROC) (GLenum mode);
+#endif
+
+#ifndef GL_ARB_seamless_cube_map
+#define GL_ARB_seamless_cube_map 1
+#endif
+
+#ifndef GL_ARB_sync
+#define GL_ARB_sync 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI GLsync APIENTRY glFenceSync (GLenum condition, GLbitfield flags);
+GLAPI GLboolean APIENTRY glIsSync (GLsync sync);
+GLAPI void APIENTRY glDeleteSync (GLsync sync);
+GLAPI GLenum APIENTRY glClientWaitSync (GLsync sync, GLbitfield flags, GLuint64 timeout);
+GLAPI void APIENTRY glWaitSync (GLsync sync, GLbitfield flags, GLuint64 timeout);
+GLAPI void APIENTRY glGetInteger64v (GLenum pname, GLint64 *params);
+GLAPI void APIENTRY glGetSynciv (GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef GLsync (APIENTRYP PFNGLFENCESYNCPROC) (GLenum condition, GLbitfield flags);
+typedef GLboolean (APIENTRYP PFNGLISSYNCPROC) (GLsync sync);
+typedef void (APIENTRYP PFNGLDELETESYNCPROC) (GLsync sync);
+typedef GLenum (APIENTRYP PFNGLCLIENTWAITSYNCPROC) (GLsync sync, GLbitfield flags, GLuint64 timeout);
+typedef void (APIENTRYP PFNGLWAITSYNCPROC) (GLsync sync, GLbitfield flags, GLuint64 timeout);
+typedef void (APIENTRYP PFNGLGETINTEGER64VPROC) (GLenum pname, GLint64 *params);
+typedef void (APIENTRYP PFNGLGETSYNCIVPROC) (GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
+#endif
+
+#ifndef GL_ARB_texture_multisample
+#define GL_ARB_texture_multisample 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glTexImage2DMultisample (GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
+GLAPI void APIENTRY glTexImage3DMultisample (GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
+GLAPI void APIENTRY glGetMultisamplefv (GLenum pname, GLuint index, GLfloat *val);
+GLAPI void APIENTRY glSampleMaski (GLuint index, GLbitfield mask);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLTEXIMAGE2DMULTISAMPLEPROC) (GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
+typedef void (APIENTRYP PFNGLTEXIMAGE3DMULTISAMPLEPROC) (GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
+typedef void (APIENTRYP PFNGLGETMULTISAMPLEFVPROC) (GLenum pname, GLuint index, GLfloat *val);
+typedef void (APIENTRYP PFNGLSAMPLEMASKIPROC) (GLuint index, GLbitfield mask);
+#endif
+
+#ifndef GL_ARB_vertex_array_bgra
+#define GL_ARB_vertex_array_bgra 1
+#endif
+
+#ifndef GL_ARB_draw_buffers_blend
+#define GL_ARB_draw_buffers_blend 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBlendEquationiARB (GLuint buf, GLenum mode);
+GLAPI void APIENTRY glBlendEquationSeparateiARB (GLuint buf, GLenum modeRGB, GLenum modeAlpha);
+GLAPI void APIENTRY glBlendFunciARB (GLuint buf, GLenum src, GLenum dst);
+GLAPI void APIENTRY glBlendFuncSeparateiARB (GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLBLENDEQUATIONIARBPROC) (GLuint buf, GLenum mode);
+typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEIARBPROC) (GLuint buf, GLenum modeRGB, GLenum modeAlpha);
+typedef void (APIENTRYP PFNGLBLENDFUNCIARBPROC) (GLuint buf, GLenum src, GLenum dst);
+typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEIARBPROC) (GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
+#endif
+
+#ifndef GL_ARB_sample_shading
+#define GL_ARB_sample_shading 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glMinSampleShadingARB (GLclampf value);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLMINSAMPLESHADINGARBPROC) (GLclampf value);
+#endif
+
+#ifndef GL_ARB_texture_cube_map_array
+#define GL_ARB_texture_cube_map_array 1
+#endif
+
+#ifndef GL_ARB_texture_gather
+#define GL_ARB_texture_gather 1
+#endif
+
+#ifndef GL_ARB_texture_query_lod
+#define GL_ARB_texture_query_lod 1
+#endif
+
+#ifndef GL_ARB_shading_language_include
+#define GL_ARB_shading_language_include 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glNamedStringARB (GLenum type, GLint namelen, const GLchar *name, GLint stringlen, const GLchar *string);
+GLAPI void APIENTRY glDeleteNamedStringARB (GLint namelen, const GLchar *name);
+GLAPI void APIENTRY glCompileShaderIncludeARB (GLuint shader, GLsizei count, const GLchar* *path, const GLint *length);
+GLAPI GLboolean APIENTRY glIsNamedStringARB (GLint namelen, const GLchar *name);
+GLAPI void APIENTRY glGetNamedStringARB (GLint namelen, const GLchar *name, GLsizei bufSize, GLint *stringlen, GLchar *string);
+GLAPI void APIENTRY glGetNamedStringivARB (GLint namelen, const GLchar *name, GLenum pname, GLint *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLNAMEDSTRINGARBPROC) (GLenum type, GLint namelen, const GLchar *name, GLint stringlen, const GLchar *string);
+typedef void (APIENTRYP PFNGLDELETENAMEDSTRINGARBPROC) (GLint namelen, const GLchar *name);
+typedef void (APIENTRYP PFNGLCOMPILESHADERINCLUDEARBPROC) (GLuint shader, GLsizei count, const GLchar* *path, const GLint *length);
+typedef GLboolean (APIENTRYP PFNGLISNAMEDSTRINGARBPROC) (GLint namelen, const GLchar *name);
+typedef void (APIENTRYP PFNGLGETNAMEDSTRINGARBPROC) (GLint namelen, const GLchar *name, GLsizei bufSize, GLint *stringlen, GLchar *string);
+typedef void (APIENTRYP PFNGLGETNAMEDSTRINGIVARBPROC) (GLint namelen, const GLchar *name, GLenum pname, GLint *params);
+#endif
+
+#ifndef GL_ARB_texture_compression_bptc
+#define GL_ARB_texture_compression_bptc 1
+#endif
+
+#ifndef GL_ARB_blend_func_extended
+#define GL_ARB_blend_func_extended 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBindFragDataLocationIndexed (GLuint program, GLuint colorNumber, GLuint index, const GLchar *name);
+GLAPI GLint APIENTRY glGetFragDataIndex (GLuint program, const GLchar *name);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONINDEXEDPROC) (GLuint program, GLuint colorNumber, GLuint index, const GLchar *name);
+typedef GLint (APIENTRYP PFNGLGETFRAGDATAINDEXPROC) (GLuint program, const GLchar *name);
+#endif
+
+#ifndef GL_ARB_explicit_attrib_location
+#define GL_ARB_explicit_attrib_location 1
+#endif
+
+#ifndef GL_ARB_occlusion_query2
+#define GL_ARB_occlusion_query2 1
+#endif
+
+#ifndef GL_ARB_sampler_objects
+#define GL_ARB_sampler_objects 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glGenSamplers (GLsizei count, GLuint *samplers);
+GLAPI void APIENTRY glDeleteSamplers (GLsizei count, const GLuint *samplers);
+GLAPI GLboolean APIENTRY glIsSampler (GLuint sampler);
+GLAPI void APIENTRY glBindSampler (GLuint unit, GLuint sampler);
+GLAPI void APIENTRY glSamplerParameteri (GLuint sampler, GLenum pname, GLint param);
+GLAPI void APIENTRY glSamplerParameteriv (GLuint sampler, GLenum pname, const GLint *param);
+GLAPI void APIENTRY glSamplerParameterf (GLuint sampler, GLenum pname, GLfloat param);
+GLAPI void APIENTRY glSamplerParameterfv (GLuint sampler, GLenum pname, const GLfloat *param);
+GLAPI void APIENTRY glSamplerParameterIiv (GLuint sampler, GLenum pname, const GLint *param);
+GLAPI void APIENTRY glSamplerParameterIuiv (GLuint sampler, GLenum pname, const GLuint *param);
+GLAPI void APIENTRY glGetSamplerParameteriv (GLuint sampler, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetSamplerParameterIiv (GLuint sampler, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetSamplerParameterfv (GLuint sampler, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetSamplerParameterIuiv (GLuint sampler, GLenum pname, GLuint *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLGENSAMPLERSPROC) (GLsizei count, GLuint *samplers);
+typedef void (APIENTRYP PFNGLDELETESAMPLERSPROC) (GLsizei count, const GLuint *samplers);
+typedef GLboolean (APIENTRYP PFNGLISSAMPLERPROC) (GLuint sampler);
+typedef void (APIENTRYP PFNGLBINDSAMPLERPROC) (GLuint unit, GLuint sampler);
+typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIPROC) (GLuint sampler, GLenum pname, GLint param);
+typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIVPROC) (GLuint sampler, GLenum pname, const GLint *param);
+typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFPROC) (GLuint sampler, GLenum pname, GLfloat param);
+typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFVPROC) (GLuint sampler, GLenum pname, const GLfloat *param);
+typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIIVPROC) (GLuint sampler, GLenum pname, const GLint *param);
+typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIUIVPROC) (GLuint sampler, GLenum pname, const GLuint *param);
+typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIVPROC) (GLuint sampler, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIIVPROC) (GLuint sampler, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERFVPROC) (GLuint sampler, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIUIVPROC) (GLuint sampler, GLenum pname, GLuint *params);
+#endif
+
+#ifndef GL_ARB_texture_rgb10_a2ui
+#define GL_ARB_texture_rgb10_a2ui 1
+#endif
+
+#ifndef GL_ARB_texture_swizzle
+#define GL_ARB_texture_swizzle 1
+#endif
+
+#ifndef GL_ARB_timer_query
+#define GL_ARB_timer_query 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glQueryCounter (GLuint id, GLenum target);
+GLAPI void APIENTRY glGetQueryObjecti64v (GLuint id, GLenum pname, GLint64 *params);
+GLAPI void APIENTRY glGetQueryObjectui64v (GLuint id, GLenum pname, GLuint64 *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLQUERYCOUNTERPROC) (GLuint id, GLenum target);
+typedef void (APIENTRYP PFNGLGETQUERYOBJECTI64VPROC) (GLuint id, GLenum pname, GLint64 *params);
+typedef void (APIENTRYP PFNGLGETQUERYOBJECTUI64VPROC) (GLuint id, GLenum pname, GLuint64 *params);
+#endif
+
+#ifndef GL_ARB_vertex_type_2_10_10_10_rev
+#define GL_ARB_vertex_type_2_10_10_10_rev 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glVertexP2ui (GLenum type, GLuint value);
+GLAPI void APIENTRY glVertexP2uiv (GLenum type, const GLuint *value);
+GLAPI void APIENTRY glVertexP3ui (GLenum type, GLuint value);
+GLAPI void APIENTRY glVertexP3uiv (GLenum type, const GLuint *value);
+GLAPI void APIENTRY glVertexP4ui (GLenum type, GLuint value);
+GLAPI void APIENTRY glVertexP4uiv (GLenum type, const GLuint *value);
+GLAPI void APIENTRY glTexCoordP1ui (GLenum type, GLuint coords);
+GLAPI void APIENTRY glTexCoordP1uiv (GLenum type, const GLuint *coords);
+GLAPI void APIENTRY glTexCoordP2ui (GLenum type, GLuint coords);
+GLAPI void APIENTRY glTexCoordP2uiv (GLenum type, const GLuint *coords);
+GLAPI void APIENTRY glTexCoordP3ui (GLenum type, GLuint coords);
+GLAPI void APIENTRY glTexCoordP3uiv (GLenum type, const GLuint *coords);
+GLAPI void APIENTRY glTexCoordP4ui (GLenum type, GLuint coords);
+GLAPI void APIENTRY glTexCoordP4uiv (GLenum type, const GLuint *coords);
+GLAPI void APIENTRY glMultiTexCoordP1ui (GLenum texture, GLenum type, GLuint coords);
+GLAPI void APIENTRY glMultiTexCoordP1uiv (GLenum texture, GLenum type, const GLuint *coords);
+GLAPI void APIENTRY glMultiTexCoordP2ui (GLenum texture, GLenum type, GLuint coords);
+GLAPI void APIENTRY glMultiTexCoordP2uiv (GLenum texture, GLenum type, const GLuint *coords);
+GLAPI void APIENTRY glMultiTexCoordP3ui (GLenum texture, GLenum type, GLuint coords);
+GLAPI void APIENTRY glMultiTexCoordP3uiv (GLenum texture, GLenum type, const GLuint *coords);
+GLAPI void APIENTRY glMultiTexCoordP4ui (GLenum texture, GLenum type, GLuint coords);
+GLAPI void APIENTRY glMultiTexCoordP4uiv (GLenum texture, GLenum type, const GLuint *coords);
+GLAPI void APIENTRY glNormalP3ui (GLenum type, GLuint coords);
+GLAPI void APIENTRY glNormalP3uiv (GLenum type, const GLuint *coords);
+GLAPI void APIENTRY glColorP3ui (GLenum type, GLuint color);
+GLAPI void APIENTRY glColorP3uiv (GLenum type, const GLuint *color);
+GLAPI void APIENTRY glColorP4ui (GLenum type, GLuint color);
+GLAPI void APIENTRY glColorP4uiv (GLenum type, const GLuint *color);
+GLAPI void APIENTRY glSecondaryColorP3ui (GLenum type, GLuint color);
+GLAPI void APIENTRY glSecondaryColorP3uiv (GLenum type, const GLuint *color);
+GLAPI void APIENTRY glVertexAttribP1ui (GLuint index, GLenum type, GLboolean normalized, GLuint value);
+GLAPI void APIENTRY glVertexAttribP1uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
+GLAPI void APIENTRY glVertexAttribP2ui (GLuint index, GLenum type, GLboolean normalized, GLuint value);
+GLAPI void APIENTRY glVertexAttribP2uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
+GLAPI void APIENTRY glVertexAttribP3ui (GLuint index, GLenum type, GLboolean normalized, GLuint value);
+GLAPI void APIENTRY glVertexAttribP3uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
+GLAPI void APIENTRY glVertexAttribP4ui (GLuint index, GLenum type, GLboolean normalized, GLuint value);
+GLAPI void APIENTRY glVertexAttribP4uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLVERTEXP2UIPROC) (GLenum type, GLuint value);
+typedef void (APIENTRYP PFNGLVERTEXP2UIVPROC) (GLenum type, const GLuint *value);
+typedef void (APIENTRYP PFNGLVERTEXP3UIPROC) (GLenum type, GLuint value);
+typedef void (APIENTRYP PFNGLVERTEXP3UIVPROC) (GLenum type, const GLuint *value);
+typedef void (APIENTRYP PFNGLVERTEXP4UIPROC) (GLenum type, GLuint value);
+typedef void (APIENTRYP PFNGLVERTEXP4UIVPROC) (GLenum type, const GLuint *value);
+typedef void (APIENTRYP PFNGLTEXCOORDP1UIPROC) (GLenum type, GLuint coords);
+typedef void (APIENTRYP PFNGLTEXCOORDP1UIVPROC) (GLenum type, const GLuint *coords);
+typedef void (APIENTRYP PFNGLTEXCOORDP2UIPROC) (GLenum type, GLuint coords);
+typedef void (APIENTRYP PFNGLTEXCOORDP2UIVPROC) (GLenum type, const GLuint *coords);
+typedef void (APIENTRYP PFNGLTEXCOORDP3UIPROC) (GLenum type, GLuint coords);
+typedef void (APIENTRYP PFNGLTEXCOORDP3UIVPROC) (GLenum type, const GLuint *coords);
+typedef void (APIENTRYP PFNGLTEXCOORDP4UIPROC) (GLenum type, GLuint coords);
+typedef void (APIENTRYP PFNGLTEXCOORDP4UIVPROC) (GLenum type, const GLuint *coords);
+typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIPROC) (GLenum texture, GLenum type, GLuint coords);
+typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIVPROC) (GLenum texture, GLenum type, const GLuint *coords);
+typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIPROC) (GLenum texture, GLenum type, GLuint coords);
+typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIVPROC) (GLenum texture, GLenum type, const GLuint *coords);
+typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIPROC) (GLenum texture, GLenum type, GLuint coords);
+typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIVPROC) (GLenum texture, GLenum type, const GLuint *coords);
+typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIPROC) (GLenum texture, GLenum type, GLuint coords);
+typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIVPROC) (GLenum texture, GLenum type, const GLuint *coords);
+typedef void (APIENTRYP PFNGLNORMALP3UIPROC) (GLenum type, GLuint coords);
+typedef void (APIENTRYP PFNGLNORMALP3UIVPROC) (GLenum type, const GLuint *coords);
+typedef void (APIENTRYP PFNGLCOLORP3UIPROC) (GLenum type, GLuint color);
+typedef void (APIENTRYP PFNGLCOLORP3UIVPROC) (GLenum type, const GLuint *color);
+typedef void (APIENTRYP PFNGLCOLORP4UIPROC) (GLenum type, GLuint color);
+typedef void (APIENTRYP PFNGLCOLORP4UIVPROC) (GLenum type, const GLuint *color);
+typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIPROC) (GLenum type, GLuint color);
+typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIVPROC) (GLenum type, const GLuint *color);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIPROC) (GLuint index, GLenum type, GLboolean normalized, GLuint value);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIVPROC) (GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIPROC) (GLuint index, GLenum type, GLboolean normalized, GLuint value);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIVPROC) (GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIPROC) (GLuint index, GLenum type, GLboolean normalized, GLuint value);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIVPROC) (GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIPROC) (GLuint index, GLenum type, GLboolean normalized, GLuint value);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIVPROC) (GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
+#endif
+
+#ifndef GL_ARB_draw_indirect
+#define GL_ARB_draw_indirect 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glDrawArraysIndirect (GLenum mode, const GLvoid *indirect);
+GLAPI void APIENTRY glDrawElementsIndirect (GLenum mode, GLenum type, const GLvoid *indirect);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLDRAWARRAYSINDIRECTPROC) (GLenum mode, const GLvoid *indirect);
+typedef void (APIENTRYP PFNGLDRAWELEMENTSINDIRECTPROC) (GLenum mode, GLenum type, const GLvoid *indirect);
+#endif
+
+#ifndef GL_ARB_gpu_shader5
+#define GL_ARB_gpu_shader5 1
+#endif
+
+#ifndef GL_ARB_gpu_shader_fp64
+#define GL_ARB_gpu_shader_fp64 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glUniform1d (GLint location, GLdouble x);
+GLAPI void APIENTRY glUniform2d (GLint location, GLdouble x, GLdouble y);
+GLAPI void APIENTRY glUniform3d (GLint location, GLdouble x, GLdouble y, GLdouble z);
+GLAPI void APIENTRY glUniform4d (GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+GLAPI void APIENTRY glUniform1dv (GLint location, GLsizei count, const GLdouble *value);
+GLAPI void APIENTRY glUniform2dv (GLint location, GLsizei count, const GLdouble *value);
+GLAPI void APIENTRY glUniform3dv (GLint location, GLsizei count, const GLdouble *value);
+GLAPI void APIENTRY glUniform4dv (GLint location, GLsizei count, const GLdouble *value);
+GLAPI void APIENTRY glUniformMatrix2dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+GLAPI void APIENTRY glUniformMatrix3dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+GLAPI void APIENTRY glUniformMatrix4dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+GLAPI void APIENTRY glUniformMatrix2x3dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+GLAPI void APIENTRY glUniformMatrix2x4dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+GLAPI void APIENTRY glUniformMatrix3x2dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+GLAPI void APIENTRY glUniformMatrix3x4dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+GLAPI void APIENTRY glUniformMatrix4x2dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+GLAPI void APIENTRY glUniformMatrix4x3dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+GLAPI void APIENTRY glGetUniformdv (GLuint program, GLint location, GLdouble *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLUNIFORM1DPROC) (GLint location, GLdouble x);
+typedef void (APIENTRYP PFNGLUNIFORM2DPROC) (GLint location, GLdouble x, GLdouble y);
+typedef void (APIENTRYP PFNGLUNIFORM3DPROC) (GLint location, GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRYP PFNGLUNIFORM4DPROC) (GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRYP PFNGLUNIFORM1DVPROC) (GLint location, GLsizei count, const GLdouble *value);
+typedef void (APIENTRYP PFNGLUNIFORM2DVPROC) (GLint location, GLsizei count, const GLdouble *value);
+typedef void (APIENTRYP PFNGLUNIFORM3DVPROC) (GLint location, GLsizei count, const GLdouble *value);
+typedef void (APIENTRYP PFNGLUNIFORM4DVPROC) (GLint location, GLsizei count, const GLdouble *value);
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX2DVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX3DVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX4DVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X3DVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X4DVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X2DVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X4DVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X2DVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X3DVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+typedef void (APIENTRYP PFNGLGETUNIFORMDVPROC) (GLuint program, GLint location, GLdouble *params);
+#endif
+
+#ifndef GL_ARB_shader_subroutine
+#define GL_ARB_shader_subroutine 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI GLint APIENTRY glGetSubroutineUniformLocation (GLuint program, GLenum shadertype, const GLchar *name);
+GLAPI GLuint APIENTRY glGetSubroutineIndex (GLuint program, GLenum shadertype, const GLchar *name);
+GLAPI void APIENTRY glGetActiveSubroutineUniformiv (GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values);
+GLAPI void APIENTRY glGetActiveSubroutineUniformName (GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
+GLAPI void APIENTRY glGetActiveSubroutineName (GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
+GLAPI void APIENTRY glUniformSubroutinesuiv (GLenum shadertype, GLsizei count, const GLuint *indices);
+GLAPI void APIENTRY glGetUniformSubroutineuiv (GLenum shadertype, GLint location, GLuint *params);
+GLAPI void APIENTRY glGetProgramStageiv (GLuint program, GLenum shadertype, GLenum pname, GLint *values);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef GLint (APIENTRYP PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC) (GLuint program, GLenum shadertype, const GLchar *name);
+typedef GLuint (APIENTRYP PFNGLGETSUBROUTINEINDEXPROC) (GLuint program, GLenum shadertype, const GLchar *name);
+typedef void (APIENTRYP PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC) (GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values);
+typedef void (APIENTRYP PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC) (GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
+typedef void (APIENTRYP PFNGLGETACTIVESUBROUTINENAMEPROC) (GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
+typedef void (APIENTRYP PFNGLUNIFORMSUBROUTINESUIVPROC) (GLenum shadertype, GLsizei count, const GLuint *indices);
+typedef void (APIENTRYP PFNGLGETUNIFORMSUBROUTINEUIVPROC) (GLenum shadertype, GLint location, GLuint *params);
+typedef void (APIENTRYP PFNGLGETPROGRAMSTAGEIVPROC) (GLuint program, GLenum shadertype, GLenum pname, GLint *values);
+#endif
+
+#ifndef GL_ARB_tessellation_shader
+#define GL_ARB_tessellation_shader 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glPatchParameteri (GLenum pname, GLint value);
+GLAPI void APIENTRY glPatchParameterfv (GLenum pname, const GLfloat *values);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLPATCHPARAMETERIPROC) (GLenum pname, GLint value);
+typedef void (APIENTRYP PFNGLPATCHPARAMETERFVPROC) (GLenum pname, const GLfloat *values);
+#endif
+
+#ifndef GL_ARB_texture_buffer_object_rgb32
+#define GL_ARB_texture_buffer_object_rgb32 1
+#endif
+
+#ifndef GL_ARB_transform_feedback2
+#define GL_ARB_transform_feedback2 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBindTransformFeedback (GLenum target, GLuint id);
+GLAPI void APIENTRY glDeleteTransformFeedbacks (GLsizei n, const GLuint *ids);
+GLAPI void APIENTRY glGenTransformFeedbacks (GLsizei n, GLuint *ids);
+GLAPI GLboolean APIENTRY glIsTransformFeedback (GLuint id);
+GLAPI void APIENTRY glPauseTransformFeedback (void);
+GLAPI void APIENTRY glResumeTransformFeedback (void);
+GLAPI void APIENTRY glDrawTransformFeedback (GLenum mode, GLuint id);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLBINDTRANSFORMFEEDBACKPROC) (GLenum target, GLuint id);
+typedef void (APIENTRYP PFNGLDELETETRANSFORMFEEDBACKSPROC) (GLsizei n, const GLuint *ids);
+typedef void (APIENTRYP PFNGLGENTRANSFORMFEEDBACKSPROC) (GLsizei n, GLuint *ids);
+typedef GLboolean (APIENTRYP PFNGLISTRANSFORMFEEDBACKPROC) (GLuint id);
+typedef void (APIENTRYP PFNGLPAUSETRANSFORMFEEDBACKPROC) (void);
+typedef void (APIENTRYP PFNGLRESUMETRANSFORMFEEDBACKPROC) (void);
+typedef void (APIENTRYP PFNGLDRAWTRANSFORMFEEDBACKPROC) (GLenum mode, GLuint id);
+#endif
+
+#ifndef GL_ARB_transform_feedback3
+#define GL_ARB_transform_feedback3 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glDrawTransformFeedbackStream (GLenum mode, GLuint id, GLuint stream);
+GLAPI void APIENTRY glBeginQueryIndexed (GLenum target, GLuint index, GLuint id);
+GLAPI void APIENTRY glEndQueryIndexed (GLenum target, GLuint index);
+GLAPI void APIENTRY glGetQueryIndexediv (GLenum target, GLuint index, GLenum pname, GLint *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC) (GLenum mode, GLuint id, GLuint stream);
+typedef void (APIENTRYP PFNGLBEGINQUERYINDEXEDPROC) (GLenum target, GLuint index, GLuint id);
+typedef void (APIENTRYP PFNGLENDQUERYINDEXEDPROC) (GLenum target, GLuint index);
+typedef void (APIENTRYP PFNGLGETQUERYINDEXEDIVPROC) (GLenum target, GLuint index, GLenum pname, GLint *params);
+#endif
+
+#ifndef GL_ARB_ES2_compatibility
+#define GL_ARB_ES2_compatibility 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glReleaseShaderCompiler (void);
+GLAPI void APIENTRY glShaderBinary (GLsizei count, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length);
+GLAPI void APIENTRY glGetShaderPrecisionFormat (GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision);
+GLAPI void APIENTRY glDepthRangef (GLclampf n, GLclampf f);
+GLAPI void APIENTRY glClearDepthf (GLclampf d);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLRELEASESHADERCOMPILERPROC) (void);
+typedef void (APIENTRYP PFNGLSHADERBINARYPROC) (GLsizei count, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length);
+typedef void (APIENTRYP PFNGLGETSHADERPRECISIONFORMATPROC) (GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision);
+typedef void (APIENTRYP PFNGLDEPTHRANGEFPROC) (GLclampf n, GLclampf f);
+typedef void (APIENTRYP PFNGLCLEARDEPTHFPROC) (GLclampf d);
+#endif
+
+#ifndef GL_ARB_get_program_binary
+#define GL_ARB_get_program_binary 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glGetProgramBinary (GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary);
+GLAPI void APIENTRY glProgramBinary (GLuint program, GLenum binaryFormat, const GLvoid *binary, GLsizei length);
+GLAPI void APIENTRY glProgramParameteri (GLuint program, GLenum pname, GLint value);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLGETPROGRAMBINARYPROC) (GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary);
+typedef void (APIENTRYP PFNGLPROGRAMBINARYPROC) (GLuint program, GLenum binaryFormat, const GLvoid *binary, GLsizei length);
+typedef void (APIENTRYP PFNGLPROGRAMPARAMETERIPROC) (GLuint program, GLenum pname, GLint value);
+#endif
+
+#ifndef GL_ARB_separate_shader_objects
+#define GL_ARB_separate_shader_objects 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glUseProgramStages (GLuint pipeline, GLbitfield stages, GLuint program);
+GLAPI void APIENTRY glActiveShaderProgram (GLuint pipeline, GLuint program);
+GLAPI GLuint APIENTRY glCreateShaderProgramv (GLenum type, GLsizei count, const GLchar* *strings);
+GLAPI void APIENTRY glBindProgramPipeline (GLuint pipeline);
+GLAPI void APIENTRY glDeleteProgramPipelines (GLsizei n, const GLuint *pipelines);
+GLAPI void APIENTRY glGenProgramPipelines (GLsizei n, GLuint *pipelines);
+GLAPI GLboolean APIENTRY glIsProgramPipeline (GLuint pipeline);
+GLAPI void APIENTRY glGetProgramPipelineiv (GLuint pipeline, GLenum pname, GLint *params);
+GLAPI void APIENTRY glProgramUniform1i (GLuint program, GLint location, GLint v0);
+GLAPI void APIENTRY glProgramUniform1iv (GLuint program, GLint location, GLsizei count, const GLint *value);
+GLAPI void APIENTRY glProgramUniform1f (GLuint program, GLint location, GLfloat v0);
+GLAPI void APIENTRY glProgramUniform1fv (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+GLAPI void APIENTRY glProgramUniform1d (GLuint program, GLint location, GLdouble v0);
+GLAPI void APIENTRY glProgramUniform1dv (GLuint program, GLint location, GLsizei count, const GLdouble *value);
+GLAPI void APIENTRY glProgramUniform1ui (GLuint program, GLint location, GLuint v0);
+GLAPI void APIENTRY glProgramUniform1uiv (GLuint program, GLint location, GLsizei count, const GLuint *value);
+GLAPI void APIENTRY glProgramUniform2i (GLuint program, GLint location, GLint v0, GLint v1);
+GLAPI void APIENTRY glProgramUniform2iv (GLuint program, GLint location, GLsizei count, const GLint *value);
+GLAPI void APIENTRY glProgramUniform2f (GLuint program, GLint location, GLfloat v0, GLfloat v1);
+GLAPI void APIENTRY glProgramUniform2fv (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+GLAPI void APIENTRY glProgramUniform2d (GLuint program, GLint location, GLdouble v0, GLdouble v1);
+GLAPI void APIENTRY glProgramUniform2dv (GLuint program, GLint location, GLsizei count, const GLdouble *value);
+GLAPI void APIENTRY glProgramUniform2ui (GLuint program, GLint location, GLuint v0, GLuint v1);
+GLAPI void APIENTRY glProgramUniform2uiv (GLuint program, GLint location, GLsizei count, const GLuint *value);
+GLAPI void APIENTRY glProgramUniform3i (GLuint program, GLint location, GLint v0, GLint v1, GLint v2);
+GLAPI void APIENTRY glProgramUniform3iv (GLuint program, GLint location, GLsizei count, const GLint *value);
+GLAPI void APIENTRY glProgramUniform3f (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+GLAPI void APIENTRY glProgramUniform3fv (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+GLAPI void APIENTRY glProgramUniform3d (GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2);
+GLAPI void APIENTRY glProgramUniform3dv (GLuint program, GLint location, GLsizei count, const GLdouble *value);
+GLAPI void APIENTRY glProgramUniform3ui (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);
+GLAPI void APIENTRY glProgramUniform3uiv (GLuint program, GLint location, GLsizei count, const GLuint *value);
+GLAPI void APIENTRY glProgramUniform4i (GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+GLAPI void APIENTRY glProgramUniform4iv (GLuint program, GLint location, GLsizei count, const GLint *value);
+GLAPI void APIENTRY glProgramUniform4f (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+GLAPI void APIENTRY glProgramUniform4fv (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+GLAPI void APIENTRY glProgramUniform4d (GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3);
+GLAPI void APIENTRY glProgramUniform4dv (GLuint program, GLint location, GLsizei count, const GLdouble *value);
+GLAPI void APIENTRY glProgramUniform4ui (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
+GLAPI void APIENTRY glProgramUniform4uiv (GLuint program, GLint location, GLsizei count, const GLuint *value);
+GLAPI void APIENTRY glProgramUniformMatrix2fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glProgramUniformMatrix3fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glProgramUniformMatrix4fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glProgramUniformMatrix2dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+GLAPI void APIENTRY glProgramUniformMatrix3dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+GLAPI void APIENTRY glProgramUniformMatrix4dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+GLAPI void APIENTRY glProgramUniformMatrix2x3fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glProgramUniformMatrix3x2fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glProgramUniformMatrix2x4fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glProgramUniformMatrix4x2fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glProgramUniformMatrix3x4fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glProgramUniformMatrix4x3fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glProgramUniformMatrix2x3dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+GLAPI void APIENTRY glProgramUniformMatrix3x2dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+GLAPI void APIENTRY glProgramUniformMatrix2x4dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+GLAPI void APIENTRY glProgramUniformMatrix4x2dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+GLAPI void APIENTRY glProgramUniformMatrix3x4dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+GLAPI void APIENTRY glProgramUniformMatrix4x3dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+GLAPI void APIENTRY glValidateProgramPipeline (GLuint pipeline);
+GLAPI void APIENTRY glGetProgramPipelineInfoLog (GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLUSEPROGRAMSTAGESPROC) (GLuint pipeline, GLbitfield stages, GLuint program);
+typedef void (APIENTRYP PFNGLACTIVESHADERPROGRAMPROC) (GLuint pipeline, GLuint program);
+typedef GLuint (APIENTRYP PFNGLCREATESHADERPROGRAMVPROC) (GLenum type, GLsizei count, const GLchar* *strings);
+typedef void (APIENTRYP PFNGLBINDPROGRAMPIPELINEPROC) (GLuint pipeline);
+typedef void (APIENTRYP PFNGLDELETEPROGRAMPIPELINESPROC) (GLsizei n, const GLuint *pipelines);
+typedef void (APIENTRYP PFNGLGENPROGRAMPIPELINESPROC) (GLsizei n, GLuint *pipelines);
+typedef GLboolean (APIENTRYP PFNGLISPROGRAMPIPELINEPROC) (GLuint pipeline);
+typedef void (APIENTRYP PFNGLGETPROGRAMPIPELINEIVPROC) (GLuint pipeline, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM1IPROC) (GLuint program, GLint location, GLint v0);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM1IVPROC) (GLuint program, GLint location, GLsizei count, const GLint *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM1FPROC) (GLuint program, GLint location, GLfloat v0);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM1FVPROC) (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM1DPROC) (GLuint program, GLint location, GLdouble v0);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM1DVPROC) (GLuint program, GLint location, GLsizei count, const GLdouble *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM1UIPROC) (GLuint program, GLint location, GLuint v0);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM1UIVPROC) (GLuint program, GLint location, GLsizei count, const GLuint *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM2IPROC) (GLuint program, GLint location, GLint v0, GLint v1);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM2IVPROC) (GLuint program, GLint location, GLsizei count, const GLint *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM2FPROC) (GLuint program, GLint location, GLfloat v0, GLfloat v1);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM2FVPROC) (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM2DPROC) (GLuint program, GLint location, GLdouble v0, GLdouble v1);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM2DVPROC) (GLuint program, GLint location, GLsizei count, const GLdouble *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM2UIPROC) (GLuint program, GLint location, GLuint v0, GLuint v1);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM2UIVPROC) (GLuint program, GLint location, GLsizei count, const GLuint *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM3IPROC) (GLuint program, GLint location, GLint v0, GLint v1, GLint v2);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM3IVPROC) (GLuint program, GLint location, GLsizei count, const GLint *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM3FPROC) (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM3FVPROC) (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM3DPROC) (GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM3DVPROC) (GLuint program, GLint location, GLsizei count, const GLdouble *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM3UIPROC) (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM3UIVPROC) (GLuint program, GLint location, GLsizei count, const GLuint *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM4IPROC) (GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM4IVPROC) (GLuint program, GLint location, GLsizei count, const GLint *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM4FPROC) (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM4FVPROC) (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM4DPROC) (GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM4DVPROC) (GLuint program, GLint location, GLsizei count, const GLdouble *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM4UIPROC) (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM4UIVPROC) (GLuint program, GLint location, GLsizei count, const GLuint *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX2FVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX3FVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX4FVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX2DVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX3DVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX4DVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+typedef void (APIENTRYP PFNGLVALIDATEPROGRAMPIPELINEPROC) (GLuint pipeline);
+typedef void (APIENTRYP PFNGLGETPROGRAMPIPELINEINFOLOGPROC) (GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+#endif
+
+#ifndef GL_ARB_vertex_attrib_64bit
+#define GL_ARB_vertex_attrib_64bit 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glVertexAttribL1d (GLuint index, GLdouble x);
+GLAPI void APIENTRY glVertexAttribL2d (GLuint index, GLdouble x, GLdouble y);
+GLAPI void APIENTRY glVertexAttribL3d (GLuint index, GLdouble x, GLdouble y, GLdouble z);
+GLAPI void APIENTRY glVertexAttribL4d (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+GLAPI void APIENTRY glVertexAttribL1dv (GLuint index, const GLdouble *v);
+GLAPI void APIENTRY glVertexAttribL2dv (GLuint index, const GLdouble *v);
+GLAPI void APIENTRY glVertexAttribL3dv (GLuint index, const GLdouble *v);
+GLAPI void APIENTRY glVertexAttribL4dv (GLuint index, const GLdouble *v);
+GLAPI void APIENTRY glVertexAttribLPointer (GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+GLAPI void APIENTRY glGetVertexAttribLdv (GLuint index, GLenum pname, GLdouble *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL1DPROC) (GLuint index, GLdouble x);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL2DPROC) (GLuint index, GLdouble x, GLdouble y);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL3DPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL4DPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL1DVPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL2DVPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL3DVPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL4DVPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBLPOINTERPROC) (GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBLDVPROC) (GLuint index, GLenum pname, GLdouble *params);
+#endif
+
+#ifndef GL_ARB_viewport_array
+#define GL_ARB_viewport_array 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glViewportArrayv (GLuint first, GLsizei count, const GLfloat *v);
+GLAPI void APIENTRY glViewportIndexedf (GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h);
+GLAPI void APIENTRY glViewportIndexedfv (GLuint index, const GLfloat *v);
+GLAPI void APIENTRY glScissorArrayv (GLuint first, GLsizei count, const GLint *v);
+GLAPI void APIENTRY glScissorIndexed (GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height);
+GLAPI void APIENTRY glScissorIndexedv (GLuint index, const GLint *v);
+GLAPI void APIENTRY glDepthRangeArrayv (GLuint first, GLsizei count, const GLclampd *v);
+GLAPI void APIENTRY glDepthRangeIndexed (GLuint index, GLclampd n, GLclampd f);
+GLAPI void APIENTRY glGetFloati_v (GLenum target, GLuint index, GLfloat *data);
+GLAPI void APIENTRY glGetDoublei_v (GLenum target, GLuint index, GLdouble *data);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLVIEWPORTARRAYVPROC) (GLuint first, GLsizei count, const GLfloat *v);
+typedef void (APIENTRYP PFNGLVIEWPORTINDEXEDFPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h);
+typedef void (APIENTRYP PFNGLVIEWPORTINDEXEDFVPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRYP PFNGLSCISSORARRAYVPROC) (GLuint first, GLsizei count, const GLint *v);
+typedef void (APIENTRYP PFNGLSCISSORINDEXEDPROC) (GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height);
+typedef void (APIENTRYP PFNGLSCISSORINDEXEDVPROC) (GLuint index, const GLint *v);
+typedef void (APIENTRYP PFNGLDEPTHRANGEARRAYVPROC) (GLuint first, GLsizei count, const GLclampd *v);
+typedef void (APIENTRYP PFNGLDEPTHRANGEINDEXEDPROC) (GLuint index, GLclampd n, GLclampd f);
+typedef void (APIENTRYP PFNGLGETFLOATI_VPROC) (GLenum target, GLuint index, GLfloat *data);
+typedef void (APIENTRYP PFNGLGETDOUBLEI_VPROC) (GLenum target, GLuint index, GLdouble *data);
+#endif
+
+#ifndef GL_ARB_cl_event
+#define GL_ARB_cl_event 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI GLsync APIENTRY glCreateSyncFromCLeventARB (struct _cl_context * context, struct _cl_event * event, GLbitfield flags);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef GLsync (APIENTRYP PFNGLCREATESYNCFROMCLEVENTARBPROC) (struct _cl_context * context, struct _cl_event * event, GLbitfield flags);
+#endif
+
+#ifndef GL_ARB_debug_output
+#define GL_ARB_debug_output 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glDebugMessageControlARB (GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled);
+GLAPI void APIENTRY glDebugMessageInsertARB (GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf);
+GLAPI void APIENTRY glDebugMessageCallbackARB (GLDEBUGPROCARB callback, const GLvoid *userParam);
+GLAPI GLuint APIENTRY glGetDebugMessageLogARB (GLuint count, GLsizei bufsize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLDEBUGMESSAGECONTROLARBPROC) (GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled);
+typedef void (APIENTRYP PFNGLDEBUGMESSAGEINSERTARBPROC) (GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf);
+typedef void (APIENTRYP PFNGLDEBUGMESSAGECALLBACKARBPROC) (GLDEBUGPROCARB callback, const GLvoid *userParam);
+typedef GLuint (APIENTRYP PFNGLGETDEBUGMESSAGELOGARBPROC) (GLuint count, GLsizei bufsize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog);
+#endif
+
+#ifndef GL_ARB_robustness
+#define GL_ARB_robustness 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI GLenum APIENTRY glGetGraphicsResetStatusARB (void);
+GLAPI void APIENTRY glGetnMapdvARB (GLenum target, GLenum query, GLsizei bufSize, GLdouble *v);
+GLAPI void APIENTRY glGetnMapfvARB (GLenum target, GLenum query, GLsizei bufSize, GLfloat *v);
+GLAPI void APIENTRY glGetnMapivARB (GLenum target, GLenum query, GLsizei bufSize, GLint *v);
+GLAPI void APIENTRY glGetnPixelMapfvARB (GLenum map, GLsizei bufSize, GLfloat *values);
+GLAPI void APIENTRY glGetnPixelMapuivARB (GLenum map, GLsizei bufSize, GLuint *values);
+GLAPI void APIENTRY glGetnPixelMapusvARB (GLenum map, GLsizei bufSize, GLushort *values);
+GLAPI void APIENTRY glGetnPolygonStippleARB (GLsizei bufSize, GLubyte *pattern);
+GLAPI void APIENTRY glGetnColorTableARB (GLenum target, GLenum format, GLenum type, GLsizei bufSize, GLvoid *table);
+GLAPI void APIENTRY glGetnConvolutionFilterARB (GLenum target, GLenum format, GLenum type, GLsizei bufSize, GLvoid *image);
+GLAPI void APIENTRY glGetnSeparableFilterARB (GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, GLvoid *row, GLsizei columnBufSize, GLvoid *column, GLvoid *span);
+GLAPI void APIENTRY glGetnHistogramARB (GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, GLvoid *values);
+GLAPI void APIENTRY glGetnMinmaxARB (GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, GLvoid *values);
+GLAPI void APIENTRY glGetnTexImageARB (GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, GLvoid *img);
+GLAPI void APIENTRY glReadnPixelsARB (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, GLvoid *data);
+GLAPI void APIENTRY glGetnCompressedTexImageARB (GLenum target, GLint lod, GLsizei bufSize, GLvoid *img);
+GLAPI void APIENTRY glGetnUniformfvARB (GLuint program, GLint location, GLsizei bufSize, GLfloat *params);
+GLAPI void APIENTRY glGetnUniformivARB (GLuint program, GLint location, GLsizei bufSize, GLint *params);
+GLAPI void APIENTRY glGetnUniformuivARB (GLuint program, GLint location, GLsizei bufSize, GLuint *params);
+GLAPI void APIENTRY glGetnUniformdvARB (GLuint program, GLint location, GLsizei bufSize, GLdouble *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef GLenum (APIENTRYP PFNGLGETGRAPHICSRESETSTATUSARBPROC) (void);
+typedef void (APIENTRYP PFNGLGETNMAPDVARBPROC) (GLenum target, GLenum query, GLsizei bufSize, GLdouble *v);
+typedef void (APIENTRYP PFNGLGETNMAPFVARBPROC) (GLenum target, GLenum query, GLsizei bufSize, GLfloat *v);
+typedef void (APIENTRYP PFNGLGETNMAPIVARBPROC) (GLenum target, GLenum query, GLsizei bufSize, GLint *v);
+typedef void (APIENTRYP PFNGLGETNPIXELMAPFVARBPROC) (GLenum map, GLsizei bufSize, GLfloat *values);
+typedef void (APIENTRYP PFNGLGETNPIXELMAPUIVARBPROC) (GLenum map, GLsizei bufSize, GLuint *values);
+typedef void (APIENTRYP PFNGLGETNPIXELMAPUSVARBPROC) (GLenum map, GLsizei bufSize, GLushort *values);
+typedef void (APIENTRYP PFNGLGETNPOLYGONSTIPPLEARBPROC) (GLsizei bufSize, GLubyte *pattern);
+typedef void (APIENTRYP PFNGLGETNCOLORTABLEARBPROC) (GLenum target, GLenum format, GLenum type, GLsizei bufSize, GLvoid *table);
+typedef void (APIENTRYP PFNGLGETNCONVOLUTIONFILTERARBPROC) (GLenum target, GLenum format, GLenum type, GLsizei bufSize, GLvoid *image);
+typedef void (APIENTRYP PFNGLGETNSEPARABLEFILTERARBPROC) (GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, GLvoid *row, GLsizei columnBufSize, GLvoid *column, GLvoid *span);
+typedef void (APIENTRYP PFNGLGETNHISTOGRAMARBPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, GLvoid *values);
+typedef void (APIENTRYP PFNGLGETNMINMAXARBPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, GLvoid *values);
+typedef void (APIENTRYP PFNGLGETNTEXIMAGEARBPROC) (GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, GLvoid *img);
+typedef void (APIENTRYP PFNGLREADNPIXELSARBPROC) (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, GLvoid *data);
+typedef void (APIENTRYP PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC) (GLenum target, GLint lod, GLsizei bufSize, GLvoid *img);
+typedef void (APIENTRYP PFNGLGETNUNIFORMFVARBPROC) (GLuint program, GLint location, GLsizei bufSize, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETNUNIFORMIVARBPROC) (GLuint program, GLint location, GLsizei bufSize, GLint *params);
+typedef void (APIENTRYP PFNGLGETNUNIFORMUIVARBPROC) (GLuint program, GLint location, GLsizei bufSize, GLuint *params);
+typedef void (APIENTRYP PFNGLGETNUNIFORMDVARBPROC) (GLuint program, GLint location, GLsizei bufSize, GLdouble *params);
+#endif
+
+#ifndef GL_ARB_shader_stencil_export
+#define GL_ARB_shader_stencil_export 1
+#endif
+
+#ifndef GL_EXT_abgr
+#define GL_EXT_abgr 1
+#endif
+
+#ifndef GL_EXT_blend_color
+#define GL_EXT_blend_color 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBlendColorEXT (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLBLENDCOLOREXTPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+#endif
+
+#ifndef GL_EXT_polygon_offset
+#define GL_EXT_polygon_offset 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glPolygonOffsetEXT (GLfloat factor, GLfloat bias);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLPOLYGONOFFSETEXTPROC) (GLfloat factor, GLfloat bias);
+#endif
+
+#ifndef GL_EXT_texture
+#define GL_EXT_texture 1
+#endif
+
+#ifndef GL_EXT_texture3D
+#define GL_EXT_texture3D 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glTexImage3DEXT (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+GLAPI void APIENTRY glTexSubImage3DEXT (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLTEXIMAGE3DEXTPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+typedef void (APIENTRYP PFNGLTEXSUBIMAGE3DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
+#endif
+
+#ifndef GL_SGIS_texture_filter4
+#define GL_SGIS_texture_filter4 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glGetTexFilterFuncSGIS (GLenum target, GLenum filter, GLfloat *weights);
+GLAPI void APIENTRY glTexFilterFuncSGIS (GLenum target, GLenum filter, GLsizei n, const GLfloat *weights);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLGETTEXFILTERFUNCSGISPROC) (GLenum target, GLenum filter, GLfloat *weights);
+typedef void (APIENTRYP PFNGLTEXFILTERFUNCSGISPROC) (GLenum target, GLenum filter, GLsizei n, const GLfloat *weights);
+#endif
+
+#ifndef GL_EXT_subtexture
+#define GL_EXT_subtexture 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glTexSubImage1DEXT (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
+GLAPI void APIENTRY glTexSubImage2DEXT (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLTEXSUBIMAGE1DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
+typedef void (APIENTRYP PFNGLTEXSUBIMAGE2DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+#endif
+
+#ifndef GL_EXT_copy_texture
+#define GL_EXT_copy_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glCopyTexImage1DEXT (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
+GLAPI void APIENTRY glCopyTexImage2DEXT (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+GLAPI void APIENTRY glCopyTexSubImage1DEXT (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+GLAPI void APIENTRY glCopyTexSubImage2DEXT (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+GLAPI void APIENTRY glCopyTexSubImage3DEXT (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLCOPYTEXIMAGE1DEXTPROC) (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
+typedef void (APIENTRYP PFNGLCOPYTEXIMAGE2DEXTPROC) (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE1DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE2DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE3DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+#endif
+
+#ifndef GL_EXT_histogram
+#define GL_EXT_histogram 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glGetHistogramEXT (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
+GLAPI void APIENTRY glGetHistogramParameterfvEXT (GLenum target, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetHistogramParameterivEXT (GLenum target, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetMinmaxEXT (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
+GLAPI void APIENTRY glGetMinmaxParameterfvEXT (GLenum target, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetMinmaxParameterivEXT (GLenum target, GLenum pname, GLint *params);
+GLAPI void APIENTRY glHistogramEXT (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
+GLAPI void APIENTRY glMinmaxEXT (GLenum target, GLenum internalformat, GLboolean sink);
+GLAPI void APIENTRY glResetHistogramEXT (GLenum target);
+GLAPI void APIENTRY glResetMinmaxEXT (GLenum target);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLGETHISTOGRAMEXTPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
+typedef void (APIENTRYP PFNGLGETHISTOGRAMPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETHISTOGRAMPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETMINMAXEXTPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
+typedef void (APIENTRYP PFNGLGETMINMAXPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETMINMAXPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLHISTOGRAMEXTPROC) (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
+typedef void (APIENTRYP PFNGLMINMAXEXTPROC) (GLenum target, GLenum internalformat, GLboolean sink);
+typedef void (APIENTRYP PFNGLRESETHISTOGRAMEXTPROC) (GLenum target);
+typedef void (APIENTRYP PFNGLRESETMINMAXEXTPROC) (GLenum target);
+#endif
+
+#ifndef GL_EXT_convolution
+#define GL_EXT_convolution 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glConvolutionFilter1DEXT (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
+GLAPI void APIENTRY glConvolutionFilter2DEXT (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
+GLAPI void APIENTRY glConvolutionParameterfEXT (GLenum target, GLenum pname, GLfloat params);
+GLAPI void APIENTRY glConvolutionParameterfvEXT (GLenum target, GLenum pname, const GLfloat *params);
+GLAPI void APIENTRY glConvolutionParameteriEXT (GLenum target, GLenum pname, GLint params);
+GLAPI void APIENTRY glConvolutionParameterivEXT (GLenum target, GLenum pname, const GLint *params);
+GLAPI void APIENTRY glCopyConvolutionFilter1DEXT (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
+GLAPI void APIENTRY glCopyConvolutionFilter2DEXT (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
+GLAPI void APIENTRY glGetConvolutionFilterEXT (GLenum target, GLenum format, GLenum type, GLvoid *image);
+GLAPI void APIENTRY glGetConvolutionParameterfvEXT (GLenum target, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetConvolutionParameterivEXT (GLenum target, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetSeparableFilterEXT (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
+GLAPI void APIENTRY glSeparableFilter2DEXT (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLCONVOLUTIONFILTER1DEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
+typedef void (APIENTRYP PFNGLCONVOLUTIONFILTER2DEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
+typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERFEXTPROC) (GLenum target, GLenum pname, GLfloat params);
+typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERFVEXTPROC) (GLenum target, GLenum pname, const GLfloat *params);
+typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERIEXTPROC) (GLenum target, GLenum pname, GLint params);
+typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERIVEXTPROC) (GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRYP PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
+typedef void (APIENTRYP PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
+typedef void (APIENTRYP PFNGLGETCONVOLUTIONFILTEREXTPROC) (GLenum target, GLenum format, GLenum type, GLvoid *image);
+typedef void (APIENTRYP PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETSEPARABLEFILTEREXTPROC) (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
+typedef void (APIENTRYP PFNGLSEPARABLEFILTER2DEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
+#endif
+
+#ifndef GL_SGI_color_matrix
+#define GL_SGI_color_matrix 1
+#endif
+
+#ifndef GL_SGI_color_table
+#define GL_SGI_color_table 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glColorTableSGI (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
+GLAPI void APIENTRY glColorTableParameterfvSGI (GLenum target, GLenum pname, const GLfloat *params);
+GLAPI void APIENTRY glColorTableParameterivSGI (GLenum target, GLenum pname, const GLint *params);
+GLAPI void APIENTRY glCopyColorTableSGI (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
+GLAPI void APIENTRY glGetColorTableSGI (GLenum target, GLenum format, GLenum type, GLvoid *table);
+GLAPI void APIENTRY glGetColorTableParameterfvSGI (GLenum target, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetColorTableParameterivSGI (GLenum target, GLenum pname, GLint *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLCOLORTABLESGIPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
+typedef void (APIENTRYP PFNGLCOLORTABLEPARAMETERFVSGIPROC) (GLenum target, GLenum pname, const GLfloat *params);
+typedef void (APIENTRYP PFNGLCOLORTABLEPARAMETERIVSGIPROC) (GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRYP PFNGLCOPYCOLORTABLESGIPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
+typedef void (APIENTRYP PFNGLGETCOLORTABLESGIPROC) (GLenum target, GLenum format, GLenum type, GLvoid *table);
+typedef void (APIENTRYP PFNGLGETCOLORTABLEPARAMETERFVSGIPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETCOLORTABLEPARAMETERIVSGIPROC) (GLenum target, GLenum pname, GLint *params);
+#endif
+
+#ifndef GL_SGIX_pixel_texture
+#define GL_SGIX_pixel_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glPixelTexGenSGIX (GLenum mode);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLPIXELTEXGENSGIXPROC) (GLenum mode);
+#endif
+
+#ifndef GL_SGIS_pixel_texture
+#define GL_SGIS_pixel_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glPixelTexGenParameteriSGIS (GLenum pname, GLint param);
+GLAPI void APIENTRY glPixelTexGenParameterivSGIS (GLenum pname, const GLint *params);
+GLAPI void APIENTRY glPixelTexGenParameterfSGIS (GLenum pname, GLfloat param);
+GLAPI void APIENTRY glPixelTexGenParameterfvSGIS (GLenum pname, const GLfloat *params);
+GLAPI void APIENTRY glGetPixelTexGenParameterivSGIS (GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetPixelTexGenParameterfvSGIS (GLenum pname, GLfloat *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLPIXELTEXGENPARAMETERISGISPROC) (GLenum pname, GLint param);
+typedef void (APIENTRYP PFNGLPIXELTEXGENPARAMETERIVSGISPROC) (GLenum pname, const GLint *params);
+typedef void (APIENTRYP PFNGLPIXELTEXGENPARAMETERFSGISPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRYP PFNGLPIXELTEXGENPARAMETERFVSGISPROC) (GLenum pname, const GLfloat *params);
+typedef void (APIENTRYP PFNGLGETPIXELTEXGENPARAMETERIVSGISPROC) (GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETPIXELTEXGENPARAMETERFVSGISPROC) (GLenum pname, GLfloat *params);
+#endif
+
+#ifndef GL_SGIS_texture4D
+#define GL_SGIS_texture4D 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glTexImage4DSGIS (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+GLAPI void APIENTRY glTexSubImage4DSGIS (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenum type, const GLvoid *pixels);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLTEXIMAGE4DSGISPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+typedef void (APIENTRYP PFNGLTEXSUBIMAGE4DSGISPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenum type, const GLvoid *pixels);
+#endif
+
+#ifndef GL_SGI_texture_color_table
+#define GL_SGI_texture_color_table 1
+#endif
+
+#ifndef GL_EXT_cmyka
+#define GL_EXT_cmyka 1
+#endif
+
+#ifndef GL_EXT_texture_object
+#define GL_EXT_texture_object 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI GLboolean APIENTRY glAreTexturesResidentEXT (GLsizei n, const GLuint *textures, GLboolean *residences);
+GLAPI void APIENTRY glBindTextureEXT (GLenum target, GLuint texture);
+GLAPI void APIENTRY glDeleteTexturesEXT (GLsizei n, const GLuint *textures);
+GLAPI void APIENTRY glGenTexturesEXT (GLsizei n, GLuint *textures);
+GLAPI GLboolean APIENTRY glIsTextureEXT (GLuint texture);
+GLAPI void APIENTRY glPrioritizeTexturesEXT (GLsizei n, const GLuint *textures, const GLclampf *priorities);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef GLboolean (APIENTRYP PFNGLARETEXTURESRESIDENTEXTPROC) (GLsizei n, const GLuint *textures, GLboolean *residences);
+typedef void (APIENTRYP PFNGLBINDTEXTUREEXTPROC) (GLenum target, GLuint texture);
+typedef void (APIENTRYP PFNGLDELETETEXTURESEXTPROC) (GLsizei n, const GLuint *textures);
+typedef void (APIENTRYP PFNGLGENTEXTURESEXTPROC) (GLsizei n, GLuint *textures);
+typedef GLboolean (APIENTRYP PFNGLISTEXTUREEXTPROC) (GLuint texture);
+typedef void (APIENTRYP PFNGLPRIORITIZETEXTURESEXTPROC) (GLsizei n, const GLuint *textures, const GLclampf *priorities);
+#endif
+
+#ifndef GL_SGIS_detail_texture
+#define GL_SGIS_detail_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glDetailTexFuncSGIS (GLenum target, GLsizei n, const GLfloat *points);
+GLAPI void APIENTRY glGetDetailTexFuncSGIS (GLenum target, GLfloat *points);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLDETAILTEXFUNCSGISPROC) (GLenum target, GLsizei n, const GLfloat *points);
+typedef void (APIENTRYP PFNGLGETDETAILTEXFUNCSGISPROC) (GLenum target, GLfloat *points);
+#endif
+
+#ifndef GL_SGIS_sharpen_texture
+#define GL_SGIS_sharpen_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glSharpenTexFuncSGIS (GLenum target, GLsizei n, const GLfloat *points);
+GLAPI void APIENTRY glGetSharpenTexFuncSGIS (GLenum target, GLfloat *points);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLSHARPENTEXFUNCSGISPROC) (GLenum target, GLsizei n, const GLfloat *points);
+typedef void (APIENTRYP PFNGLGETSHARPENTEXFUNCSGISPROC) (GLenum target, GLfloat *points);
+#endif
+
+#ifndef GL_EXT_packed_pixels
+#define GL_EXT_packed_pixels 1
+#endif
+
+#ifndef GL_SGIS_texture_lod
+#define GL_SGIS_texture_lod 1
+#endif
+
+#ifndef GL_SGIS_multisample
+#define GL_SGIS_multisample 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glSampleMaskSGIS (GLclampf value, GLboolean invert);
+GLAPI void APIENTRY glSamplePatternSGIS (GLenum pattern);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLSAMPLEMASKSGISPROC) (GLclampf value, GLboolean invert);
+typedef void (APIENTRYP PFNGLSAMPLEPATTERNSGISPROC) (GLenum pattern);
+#endif
+
+#ifndef GL_EXT_rescale_normal
+#define GL_EXT_rescale_normal 1
+#endif
+
+#ifndef GL_EXT_vertex_array
+#define GL_EXT_vertex_array 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glArrayElementEXT (GLint i);
+GLAPI void APIENTRY glColorPointerEXT (GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);
+GLAPI void APIENTRY glDrawArraysEXT (GLenum mode, GLint first, GLsizei count);
+GLAPI void APIENTRY glEdgeFlagPointerEXT (GLsizei stride, GLsizei count, const GLboolean *pointer);
+GLAPI void APIENTRY glGetPointervEXT (GLenum pname, GLvoid* *params);
+GLAPI void APIENTRY glIndexPointerEXT (GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);
+GLAPI void APIENTRY glNormalPointerEXT (GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);
+GLAPI void APIENTRY glTexCoordPointerEXT (GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);
+GLAPI void APIENTRY glVertexPointerEXT (GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLARRAYELEMENTEXTPROC) (GLint i);
+typedef void (APIENTRYP PFNGLCOLORPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);
+typedef void (APIENTRYP PFNGLDRAWARRAYSEXTPROC) (GLenum mode, GLint first, GLsizei count);
+typedef void (APIENTRYP PFNGLEDGEFLAGPOINTEREXTPROC) (GLsizei stride, GLsizei count, const GLboolean *pointer);
+typedef void (APIENTRYP PFNGLGETPOINTERVEXTPROC) (GLenum pname, GLvoid* *params);
+typedef void (APIENTRYP PFNGLINDEXPOINTEREXTPROC) (GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);
+typedef void (APIENTRYP PFNGLNORMALPOINTEREXTPROC) (GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);
+typedef void (APIENTRYP PFNGLTEXCOORDPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);
+typedef void (APIENTRYP PFNGLVERTEXPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);
+#endif
+
+#ifndef GL_EXT_misc_attribute
+#define GL_EXT_misc_attribute 1
+#endif
+
+#ifndef GL_SGIS_generate_mipmap
+#define GL_SGIS_generate_mipmap 1
+#endif
+
+#ifndef GL_SGIX_clipmap
+#define GL_SGIX_clipmap 1
+#endif
+
+#ifndef GL_SGIX_shadow
+#define GL_SGIX_shadow 1
+#endif
+
+#ifndef GL_SGIS_texture_edge_clamp
+#define GL_SGIS_texture_edge_clamp 1
+#endif
+
+#ifndef GL_SGIS_texture_border_clamp
+#define GL_SGIS_texture_border_clamp 1
+#endif
+
+#ifndef GL_EXT_blend_minmax
+#define GL_EXT_blend_minmax 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBlendEquationEXT (GLenum mode);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLBLENDEQUATIONEXTPROC) (GLenum mode);
+#endif
+
+#ifndef GL_EXT_blend_subtract
+#define GL_EXT_blend_subtract 1
+#endif
+
+#ifndef GL_EXT_blend_logic_op
+#define GL_EXT_blend_logic_op 1
+#endif
+
+#ifndef GL_SGIX_interlace
+#define GL_SGIX_interlace 1
+#endif
+
+#ifndef GL_SGIX_pixel_tiles
+#define GL_SGIX_pixel_tiles 1
+#endif
+
+#ifndef GL_SGIX_texture_select
+#define GL_SGIX_texture_select 1
+#endif
+
+#ifndef GL_SGIX_sprite
+#define GL_SGIX_sprite 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glSpriteParameterfSGIX (GLenum pname, GLfloat param);
+GLAPI void APIENTRY glSpriteParameterfvSGIX (GLenum pname, const GLfloat *params);
+GLAPI void APIENTRY glSpriteParameteriSGIX (GLenum pname, GLint param);
+GLAPI void APIENTRY glSpriteParameterivSGIX (GLenum pname, const GLint *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLSPRITEPARAMETERFSGIXPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRYP PFNGLSPRITEPARAMETERFVSGIXPROC) (GLenum pname, const GLfloat *params);
+typedef void (APIENTRYP PFNGLSPRITEPARAMETERISGIXPROC) (GLenum pname, GLint param);
+typedef void (APIENTRYP PFNGLSPRITEPARAMETERIVSGIXPROC) (GLenum pname, const GLint *params);
+#endif
+
+#ifndef GL_SGIX_texture_multi_buffer
+#define GL_SGIX_texture_multi_buffer 1
+#endif
+
+#ifndef GL_EXT_point_parameters
+#define GL_EXT_point_parameters 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glPointParameterfEXT (GLenum pname, GLfloat param);
+GLAPI void APIENTRY glPointParameterfvEXT (GLenum pname, const GLfloat *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLPOINTPARAMETERFEXTPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRYP PFNGLPOINTPARAMETERFVEXTPROC) (GLenum pname, const GLfloat *params);
+#endif
+
+#ifndef GL_SGIS_point_parameters
+#define GL_SGIS_point_parameters 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glPointParameterfSGIS (GLenum pname, GLfloat param);
+GLAPI void APIENTRY glPointParameterfvSGIS (GLenum pname, const GLfloat *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLPOINTPARAMETERFSGISPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRYP PFNGLPOINTPARAMETERFVSGISPROC) (GLenum pname, const GLfloat *params);
+#endif
+
+#ifndef GL_SGIX_instruments
+#define GL_SGIX_instruments 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI GLint APIENTRY glGetInstrumentsSGIX (void);
+GLAPI void APIENTRY glInstrumentsBufferSGIX (GLsizei size, GLint *buffer);
+GLAPI GLint APIENTRY glPollInstrumentsSGIX (GLint *marker_p);
+GLAPI void APIENTRY glReadInstrumentsSGIX (GLint marker);
+GLAPI void APIENTRY glStartInstrumentsSGIX (void);
+GLAPI void APIENTRY glStopInstrumentsSGIX (GLint marker);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef GLint (APIENTRYP PFNGLGETINSTRUMENTSSGIXPROC) (void);
+typedef void (APIENTRYP PFNGLINSTRUMENTSBUFFERSGIXPROC) (GLsizei size, GLint *buffer);
+typedef GLint (APIENTRYP PFNGLPOLLINSTRUMENTSSGIXPROC) (GLint *marker_p);
+typedef void (APIENTRYP PFNGLREADINSTRUMENTSSGIXPROC) (GLint marker);
+typedef void (APIENTRYP PFNGLSTARTINSTRUMENTSSGIXPROC) (void);
+typedef void (APIENTRYP PFNGLSTOPINSTRUMENTSSGIXPROC) (GLint marker);
+#endif
+
+#ifndef GL_SGIX_texture_scale_bias
+#define GL_SGIX_texture_scale_bias 1
+#endif
+
+#ifndef GL_SGIX_framezoom
+#define GL_SGIX_framezoom 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glFrameZoomSGIX (GLint factor);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLFRAMEZOOMSGIXPROC) (GLint factor);
+#endif
+
+#ifndef GL_SGIX_tag_sample_buffer
+#define GL_SGIX_tag_sample_buffer 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glTagSampleBufferSGIX (void);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLTAGSAMPLEBUFFERSGIXPROC) (void);
+#endif
+
+#ifndef GL_SGIX_polynomial_ffd
+#define GL_SGIX_polynomial_ffd 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glDeformationMap3dSGIX (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, const GLdouble *points);
+GLAPI void APIENTRY glDeformationMap3fSGIX (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, const GLfloat *points);
+GLAPI void APIENTRY glDeformSGIX (GLbitfield mask);
+GLAPI void APIENTRY glLoadIdentityDeformationMapSGIX (GLbitfield mask);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLDEFORMATIONMAP3DSGIXPROC) (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, const GLdouble *points);
+typedef void (APIENTRYP PFNGLDEFORMATIONMAP3FSGIXPROC) (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, const GLfloat *points);
+typedef void (APIENTRYP PFNGLDEFORMSGIXPROC) (GLbitfield mask);
+typedef void (APIENTRYP PFNGLLOADIDENTITYDEFORMATIONMAPSGIXPROC) (GLbitfield mask);
+#endif
+
+#ifndef GL_SGIX_reference_plane
+#define GL_SGIX_reference_plane 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glReferencePlaneSGIX (const GLdouble *equation);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLREFERENCEPLANESGIXPROC) (const GLdouble *equation);
+#endif
+
+#ifndef GL_SGIX_flush_raster
+#define GL_SGIX_flush_raster 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glFlushRasterSGIX (void);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLFLUSHRASTERSGIXPROC) (void);
+#endif
+
+#ifndef GL_SGIX_depth_texture
+#define GL_SGIX_depth_texture 1
+#endif
+
+#ifndef GL_SGIS_fog_function
+#define GL_SGIS_fog_function 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glFogFuncSGIS (GLsizei n, const GLfloat *points);
+GLAPI void APIENTRY glGetFogFuncSGIS (GLfloat *points);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLFOGFUNCSGISPROC) (GLsizei n, const GLfloat *points);
+typedef void (APIENTRYP PFNGLGETFOGFUNCSGISPROC) (GLfloat *points);
+#endif
+
+#ifndef GL_SGIX_fog_offset
+#define GL_SGIX_fog_offset 1
+#endif
+
+#ifndef GL_HP_image_transform
+#define GL_HP_image_transform 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glImageTransformParameteriHP (GLenum target, GLenum pname, GLint param);
+GLAPI void APIENTRY glImageTransformParameterfHP (GLenum target, GLenum pname, GLfloat param);
+GLAPI void APIENTRY glImageTransformParameterivHP (GLenum target, GLenum pname, const GLint *params);
+GLAPI void APIENTRY glImageTransformParameterfvHP (GLenum target, GLenum pname, const GLfloat *params);
+GLAPI void APIENTRY glGetImageTransformParameterivHP (GLenum target, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetImageTransformParameterfvHP (GLenum target, GLenum pname, GLfloat *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLIMAGETRANSFORMPARAMETERIHPPROC) (GLenum target, GLenum pname, GLint param);
+typedef void (APIENTRYP PFNGLIMAGETRANSFORMPARAMETERFHPPROC) (GLenum target, GLenum pname, GLfloat param);
+typedef void (APIENTRYP PFNGLIMAGETRANSFORMPARAMETERIVHPPROC) (GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRYP PFNGLIMAGETRANSFORMPARAMETERFVHPPROC) (GLenum target, GLenum pname, const GLfloat *params);
+typedef void (APIENTRYP PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC) (GLenum target, GLenum pname, GLfloat *params);
+#endif
+
+#ifndef GL_HP_convolution_border_modes
+#define GL_HP_convolution_border_modes 1
+#endif
+
+#ifndef GL_SGIX_texture_add_env
+#define GL_SGIX_texture_add_env 1
+#endif
+
+#ifndef GL_EXT_color_subtable
+#define GL_EXT_color_subtable 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glColorSubTableEXT (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
+GLAPI void APIENTRY glCopyColorSubTableEXT (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLCOLORSUBTABLEEXTPROC) (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
+typedef void (APIENTRYP PFNGLCOPYCOLORSUBTABLEEXTPROC) (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
+#endif
+
+#ifndef GL_PGI_vertex_hints
+#define GL_PGI_vertex_hints 1
+#endif
+
+#ifndef GL_PGI_misc_hints
+#define GL_PGI_misc_hints 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glHintPGI (GLenum target, GLint mode);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLHINTPGIPROC) (GLenum target, GLint mode);
+#endif
+
+#ifndef GL_EXT_paletted_texture
+#define GL_EXT_paletted_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glColorTableEXT (GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
+GLAPI void APIENTRY glGetColorTableEXT (GLenum target, GLenum format, GLenum type, GLvoid *data);
+GLAPI void APIENTRY glGetColorTableParameterivEXT (GLenum target, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetColorTableParameterfvEXT (GLenum target, GLenum pname, GLfloat *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLCOLORTABLEEXTPROC) (GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
+typedef void (APIENTRYP PFNGLGETCOLORTABLEEXTPROC) (GLenum target, GLenum format, GLenum type, GLvoid *data);
+typedef void (APIENTRYP PFNGLGETCOLORTABLEPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETCOLORTABLEPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat *params);
+#endif
+
+#ifndef GL_EXT_clip_volume_hint
+#define GL_EXT_clip_volume_hint 1
+#endif
+
+#ifndef GL_SGIX_list_priority
+#define GL_SGIX_list_priority 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glGetListParameterfvSGIX (GLuint list, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetListParameterivSGIX (GLuint list, GLenum pname, GLint *params);
+GLAPI void APIENTRY glListParameterfSGIX (GLuint list, GLenum pname, GLfloat param);
+GLAPI void APIENTRY glListParameterfvSGIX (GLuint list, GLenum pname, const GLfloat *params);
+GLAPI void APIENTRY glListParameteriSGIX (GLuint list, GLenum pname, GLint param);
+GLAPI void APIENTRY glListParameterivSGIX (GLuint list, GLenum pname, const GLint *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLGETLISTPARAMETERFVSGIXPROC) (GLuint list, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETLISTPARAMETERIVSGIXPROC) (GLuint list, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLLISTPARAMETERFSGIXPROC) (GLuint list, GLenum pname, GLfloat param);
+typedef void (APIENTRYP PFNGLLISTPARAMETERFVSGIXPROC) (GLuint list, GLenum pname, const GLfloat *params);
+typedef void (APIENTRYP PFNGLLISTPARAMETERISGIXPROC) (GLuint list, GLenum pname, GLint param);
+typedef void (APIENTRYP PFNGLLISTPARAMETERIVSGIXPROC) (GLuint list, GLenum pname, const GLint *params);
+#endif
+
+#ifndef GL_SGIX_ir_instrument1
+#define GL_SGIX_ir_instrument1 1
+#endif
+
+#ifndef GL_SGIX_calligraphic_fragment
+#define GL_SGIX_calligraphic_fragment 1
+#endif
+
+#ifndef GL_SGIX_texture_lod_bias
+#define GL_SGIX_texture_lod_bias 1
+#endif
+
+#ifndef GL_SGIX_shadow_ambient
+#define GL_SGIX_shadow_ambient 1
+#endif
+
+#ifndef GL_EXT_index_texture
+#define GL_EXT_index_texture 1
+#endif
+
+#ifndef GL_EXT_index_material
+#define GL_EXT_index_material 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glIndexMaterialEXT (GLenum face, GLenum mode);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLINDEXMATERIALEXTPROC) (GLenum face, GLenum mode);
+#endif
+
+#ifndef GL_EXT_index_func
+#define GL_EXT_index_func 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glIndexFuncEXT (GLenum func, GLclampf ref);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLINDEXFUNCEXTPROC) (GLenum func, GLclampf ref);
+#endif
+
+#ifndef GL_EXT_index_array_formats
+#define GL_EXT_index_array_formats 1
+#endif
+
+#ifndef GL_EXT_compiled_vertex_array
+#define GL_EXT_compiled_vertex_array 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glLockArraysEXT (GLint first, GLsizei count);
+GLAPI void APIENTRY glUnlockArraysEXT (void);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLLOCKARRAYSEXTPROC) (GLint first, GLsizei count);
+typedef void (APIENTRYP PFNGLUNLOCKARRAYSEXTPROC) (void);
+#endif
+
+#ifndef GL_EXT_cull_vertex
+#define GL_EXT_cull_vertex 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glCullParameterdvEXT (GLenum pname, GLdouble *params);
+GLAPI void APIENTRY glCullParameterfvEXT (GLenum pname, GLfloat *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLCULLPARAMETERDVEXTPROC) (GLenum pname, GLdouble *params);
+typedef void (APIENTRYP PFNGLCULLPARAMETERFVEXTPROC) (GLenum pname, GLfloat *params);
+#endif
+
+#ifndef GL_SGIX_ycrcb
+#define GL_SGIX_ycrcb 1
+#endif
+
+#ifndef GL_SGIX_fragment_lighting
+#define GL_SGIX_fragment_lighting 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glFragmentColorMaterialSGIX (GLenum face, GLenum mode);
+GLAPI void APIENTRY glFragmentLightfSGIX (GLenum light, GLenum pname, GLfloat param);
+GLAPI void APIENTRY glFragmentLightfvSGIX (GLenum light, GLenum pname, const GLfloat *params);
+GLAPI void APIENTRY glFragmentLightiSGIX (GLenum light, GLenum pname, GLint param);
+GLAPI void APIENTRY glFragmentLightivSGIX (GLenum light, GLenum pname, const GLint *params);
+GLAPI void APIENTRY glFragmentLightModelfSGIX (GLenum pname, GLfloat param);
+GLAPI void APIENTRY glFragmentLightModelfvSGIX (GLenum pname, const GLfloat *params);
+GLAPI void APIENTRY glFragmentLightModeliSGIX (GLenum pname, GLint param);
+GLAPI void APIENTRY glFragmentLightModelivSGIX (GLenum pname, const GLint *params);
+GLAPI void APIENTRY glFragmentMaterialfSGIX (GLenum face, GLenum pname, GLfloat param);
+GLAPI void APIENTRY glFragmentMaterialfvSGIX (GLenum face, GLenum pname, const GLfloat *params);
+GLAPI void APIENTRY glFragmentMaterialiSGIX (GLenum face, GLenum pname, GLint param);
+GLAPI void APIENTRY glFragmentMaterialivSGIX (GLenum face, GLenum pname, const GLint *params);
+GLAPI void APIENTRY glGetFragmentLightfvSGIX (GLenum light, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetFragmentLightivSGIX (GLenum light, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetFragmentMaterialfvSGIX (GLenum face, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetFragmentMaterialivSGIX (GLenum face, GLenum pname, GLint *params);
+GLAPI void APIENTRY glLightEnviSGIX (GLenum pname, GLint param);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLFRAGMENTCOLORMATERIALSGIXPROC) (GLenum face, GLenum mode);
+typedef void (APIENTRYP PFNGLFRAGMENTLIGHTFSGIXPROC) (GLenum light, GLenum pname, GLfloat param);
+typedef void (APIENTRYP PFNGLFRAGMENTLIGHTFVSGIXPROC) (GLenum light, GLenum pname, const GLfloat *params);
+typedef void (APIENTRYP PFNGLFRAGMENTLIGHTISGIXPROC) (GLenum light, GLenum pname, GLint param);
+typedef void (APIENTRYP PFNGLFRAGMENTLIGHTIVSGIXPROC) (GLenum light, GLenum pname, const GLint *params);
+typedef void (APIENTRYP PFNGLFRAGMENTLIGHTMODELFSGIXPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRYP PFNGLFRAGMENTLIGHTMODELFVSGIXPROC) (GLenum pname, const GLfloat *params);
+typedef void (APIENTRYP PFNGLFRAGMENTLIGHTMODELISGIXPROC) (GLenum pname, GLint param);
+typedef void (APIENTRYP PFNGLFRAGMENTLIGHTMODELIVSGIXPROC) (GLenum pname, const GLint *params);
+typedef void (APIENTRYP PFNGLFRAGMENTMATERIALFSGIXPROC) (GLenum face, GLenum pname, GLfloat param);
+typedef void (APIENTRYP PFNGLFRAGMENTMATERIALFVSGIXPROC) (GLenum face, GLenum pname, const GLfloat *params);
+typedef void (APIENTRYP PFNGLFRAGMENTMATERIALISGIXPROC) (GLenum face, GLenum pname, GLint param);
+typedef void (APIENTRYP PFNGLFRAGMENTMATERIALIVSGIXPROC) (GLenum face, GLenum pname, const GLint *params);
+typedef void (APIENTRYP PFNGLGETFRAGMENTLIGHTFVSGIXPROC) (GLenum light, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETFRAGMENTLIGHTIVSGIXPROC) (GLenum light, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETFRAGMENTMATERIALFVSGIXPROC) (GLenum face, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETFRAGMENTMATERIALIVSGIXPROC) (GLenum face, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLLIGHTENVISGIXPROC) (GLenum pname, GLint param);
+#endif
+
+#ifndef GL_IBM_rasterpos_clip
+#define GL_IBM_rasterpos_clip 1
+#endif
+
+#ifndef GL_HP_texture_lighting
+#define GL_HP_texture_lighting 1
+#endif
+
+#ifndef GL_EXT_draw_range_elements
+#define GL_EXT_draw_range_elements 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glDrawRangeElementsEXT (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSEXTPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
+#endif
+
+#ifndef GL_WIN_phong_shading
+#define GL_WIN_phong_shading 1
+#endif
+
+#ifndef GL_WIN_specular_fog
+#define GL_WIN_specular_fog 1
+#endif
+
+#ifndef GL_EXT_light_texture
+#define GL_EXT_light_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glApplyTextureEXT (GLenum mode);
+GLAPI void APIENTRY glTextureLightEXT (GLenum pname);
+GLAPI void APIENTRY glTextureMaterialEXT (GLenum face, GLenum mode);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLAPPLYTEXTUREEXTPROC) (GLenum mode);
+typedef void (APIENTRYP PFNGLTEXTURELIGHTEXTPROC) (GLenum pname);
+typedef void (APIENTRYP PFNGLTEXTUREMATERIALEXTPROC) (GLenum face, GLenum mode);
+#endif
+
+#ifndef GL_SGIX_blend_alpha_minmax
+#define GL_SGIX_blend_alpha_minmax 1
+#endif
+
+#ifndef GL_EXT_bgra
+#define GL_EXT_bgra 1
+#endif
+
+#ifndef GL_SGIX_async
+#define GL_SGIX_async 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glAsyncMarkerSGIX (GLuint marker);
+GLAPI GLint APIENTRY glFinishAsyncSGIX (GLuint *markerp);
+GLAPI GLint APIENTRY glPollAsyncSGIX (GLuint *markerp);
+GLAPI GLuint APIENTRY glGenAsyncMarkersSGIX (GLsizei range);
+GLAPI void APIENTRY glDeleteAsyncMarkersSGIX (GLuint marker, GLsizei range);
+GLAPI GLboolean APIENTRY glIsAsyncMarkerSGIX (GLuint marker);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLASYNCMARKERSGIXPROC) (GLuint marker);
+typedef GLint (APIENTRYP PFNGLFINISHASYNCSGIXPROC) (GLuint *markerp);
+typedef GLint (APIENTRYP PFNGLPOLLASYNCSGIXPROC) (GLuint *markerp);
+typedef GLuint (APIENTRYP PFNGLGENASYNCMARKERSSGIXPROC) (GLsizei range);
+typedef void (APIENTRYP PFNGLDELETEASYNCMARKERSSGIXPROC) (GLuint marker, GLsizei range);
+typedef GLboolean (APIENTRYP PFNGLISASYNCMARKERSGIXPROC) (GLuint marker);
+#endif
+
+#ifndef GL_SGIX_async_pixel
+#define GL_SGIX_async_pixel 1
+#endif
+
+#ifndef GL_SGIX_async_histogram
+#define GL_SGIX_async_histogram 1
+#endif
+
+#ifndef GL_INTEL_parallel_arrays
+#define GL_INTEL_parallel_arrays 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glVertexPointervINTEL (GLint size, GLenum type, const GLvoid* *pointer);
+GLAPI void APIENTRY glNormalPointervINTEL (GLenum type, const GLvoid* *pointer);
+GLAPI void APIENTRY glColorPointervINTEL (GLint size, GLenum type, const GLvoid* *pointer);
+GLAPI void APIENTRY glTexCoordPointervINTEL (GLint size, GLenum type, const GLvoid* *pointer);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLVERTEXPOINTERVINTELPROC) (GLint size, GLenum type, const GLvoid* *pointer);
+typedef void (APIENTRYP PFNGLNORMALPOINTERVINTELPROC) (GLenum type, const GLvoid* *pointer);
+typedef void (APIENTRYP PFNGLCOLORPOINTERVINTELPROC) (GLint size, GLenum type, const GLvoid* *pointer);
+typedef void (APIENTRYP PFNGLTEXCOORDPOINTERVINTELPROC) (GLint size, GLenum type, const GLvoid* *pointer);
+#endif
+
+#ifndef GL_HP_occlusion_test
+#define GL_HP_occlusion_test 1
+#endif
+
+#ifndef GL_EXT_pixel_transform
+#define GL_EXT_pixel_transform 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glPixelTransformParameteriEXT (GLenum target, GLenum pname, GLint param);
+GLAPI void APIENTRY glPixelTransformParameterfEXT (GLenum target, GLenum pname, GLfloat param);
+GLAPI void APIENTRY glPixelTransformParameterivEXT (GLenum target, GLenum pname, const GLint *params);
+GLAPI void APIENTRY glPixelTransformParameterfvEXT (GLenum target, GLenum pname, const GLfloat *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLPIXELTRANSFORMPARAMETERIEXTPROC) (GLenum target, GLenum pname, GLint param);
+typedef void (APIENTRYP PFNGLPIXELTRANSFORMPARAMETERFEXTPROC) (GLenum target, GLenum pname, GLfloat param);
+typedef void (APIENTRYP PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC) (GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRYP PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC) (GLenum target, GLenum pname, const GLfloat *params);
+#endif
+
+#ifndef GL_EXT_pixel_transform_color_table
+#define GL_EXT_pixel_transform_color_table 1
+#endif
+
+#ifndef GL_EXT_shared_texture_palette
+#define GL_EXT_shared_texture_palette 1
+#endif
+
+#ifndef GL_EXT_separate_specular_color
+#define GL_EXT_separate_specular_color 1
+#endif
+
+#ifndef GL_EXT_secondary_color
+#define GL_EXT_secondary_color 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glSecondaryColor3bEXT (GLbyte red, GLbyte green, GLbyte blue);
+GLAPI void APIENTRY glSecondaryColor3bvEXT (const GLbyte *v);
+GLAPI void APIENTRY glSecondaryColor3dEXT (GLdouble red, GLdouble green, GLdouble blue);
+GLAPI void APIENTRY glSecondaryColor3dvEXT (const GLdouble *v);
+GLAPI void APIENTRY glSecondaryColor3fEXT (GLfloat red, GLfloat green, GLfloat blue);
+GLAPI void APIENTRY glSecondaryColor3fvEXT (const GLfloat *v);
+GLAPI void APIENTRY glSecondaryColor3iEXT (GLint red, GLint green, GLint blue);
+GLAPI void APIENTRY glSecondaryColor3ivEXT (const GLint *v);
+GLAPI void APIENTRY glSecondaryColor3sEXT (GLshort red, GLshort green, GLshort blue);
+GLAPI void APIENTRY glSecondaryColor3svEXT (const GLshort *v);
+GLAPI void APIENTRY glSecondaryColor3ubEXT (GLubyte red, GLubyte green, GLubyte blue);
+GLAPI void APIENTRY glSecondaryColor3ubvEXT (const GLubyte *v);
+GLAPI void APIENTRY glSecondaryColor3uiEXT (GLuint red, GLuint green, GLuint blue);
+GLAPI void APIENTRY glSecondaryColor3uivEXT (const GLuint *v);
+GLAPI void APIENTRY glSecondaryColor3usEXT (GLushort red, GLushort green, GLushort blue);
+GLAPI void APIENTRY glSecondaryColor3usvEXT (const GLushort *v);
+GLAPI void APIENTRY glSecondaryColorPointerEXT (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3BEXTPROC) (GLbyte red, GLbyte green, GLbyte blue);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3BVEXTPROC) (const GLbyte *v);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3DEXTPROC) (GLdouble red, GLdouble green, GLdouble blue);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3DVEXTPROC) (const GLdouble *v);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3FEXTPROC) (GLfloat red, GLfloat green, GLfloat blue);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3FVEXTPROC) (const GLfloat *v);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3IEXTPROC) (GLint red, GLint green, GLint blue);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3IVEXTPROC) (const GLint *v);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3SEXTPROC) (GLshort red, GLshort green, GLshort blue);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3SVEXTPROC) (const GLshort *v);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UBEXTPROC) (GLubyte red, GLubyte green, GLubyte blue);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UBVEXTPROC) (const GLubyte *v);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UIEXTPROC) (GLuint red, GLuint green, GLuint blue);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UIVEXTPROC) (const GLuint *v);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3USEXTPROC) (GLushort red, GLushort green, GLushort blue);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3USVEXTPROC) (const GLushort *v);
+typedef void (APIENTRYP PFNGLSECONDARYCOLORPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+#endif
+
+#ifndef GL_EXT_texture_perturb_normal
+#define GL_EXT_texture_perturb_normal 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glTextureNormalEXT (GLenum mode);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLTEXTURENORMALEXTPROC) (GLenum mode);
+#endif
+
+#ifndef GL_EXT_multi_draw_arrays
+#define GL_EXT_multi_draw_arrays 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glMultiDrawArraysEXT (GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount);
+GLAPI void APIENTRY glMultiDrawElementsEXT (GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLMULTIDRAWARRAYSEXTPROC) (GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount);
+typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSEXTPROC) (GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount);
+#endif
+
+#ifndef GL_EXT_fog_coord
+#define GL_EXT_fog_coord 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glFogCoordfEXT (GLfloat coord);
+GLAPI void APIENTRY glFogCoordfvEXT (const GLfloat *coord);
+GLAPI void APIENTRY glFogCoorddEXT (GLdouble coord);
+GLAPI void APIENTRY glFogCoorddvEXT (const GLdouble *coord);
+GLAPI void APIENTRY glFogCoordPointerEXT (GLenum type, GLsizei stride, const GLvoid *pointer);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLFOGCOORDFEXTPROC) (GLfloat coord);
+typedef void (APIENTRYP PFNGLFOGCOORDFVEXTPROC) (const GLfloat *coord);
+typedef void (APIENTRYP PFNGLFOGCOORDDEXTPROC) (GLdouble coord);
+typedef void (APIENTRYP PFNGLFOGCOORDDVEXTPROC) (const GLdouble *coord);
+typedef void (APIENTRYP PFNGLFOGCOORDPOINTEREXTPROC) (GLenum type, GLsizei stride, const GLvoid *pointer);
+#endif
+
+#ifndef GL_REND_screen_coordinates
+#define GL_REND_screen_coordinates 1
+#endif
+
+#ifndef GL_EXT_coordinate_frame
+#define GL_EXT_coordinate_frame 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glTangent3bEXT (GLbyte tx, GLbyte ty, GLbyte tz);
+GLAPI void APIENTRY glTangent3bvEXT (const GLbyte *v);
+GLAPI void APIENTRY glTangent3dEXT (GLdouble tx, GLdouble ty, GLdouble tz);
+GLAPI void APIENTRY glTangent3dvEXT (const GLdouble *v);
+GLAPI void APIENTRY glTangent3fEXT (GLfloat tx, GLfloat ty, GLfloat tz);
+GLAPI void APIENTRY glTangent3fvEXT (const GLfloat *v);
+GLAPI void APIENTRY glTangent3iEXT (GLint tx, GLint ty, GLint tz);
+GLAPI void APIENTRY glTangent3ivEXT (const GLint *v);
+GLAPI void APIENTRY glTangent3sEXT (GLshort tx, GLshort ty, GLshort tz);
+GLAPI void APIENTRY glTangent3svEXT (const GLshort *v);
+GLAPI void APIENTRY glBinormal3bEXT (GLbyte bx, GLbyte by, GLbyte bz);
+GLAPI void APIENTRY glBinormal3bvEXT (const GLbyte *v);
+GLAPI void APIENTRY glBinormal3dEXT (GLdouble bx, GLdouble by, GLdouble bz);
+GLAPI void APIENTRY glBinormal3dvEXT (const GLdouble *v);
+GLAPI void APIENTRY glBinormal3fEXT (GLfloat bx, GLfloat by, GLfloat bz);
+GLAPI void APIENTRY glBinormal3fvEXT (const GLfloat *v);
+GLAPI void APIENTRY glBinormal3iEXT (GLint bx, GLint by, GLint bz);
+GLAPI void APIENTRY glBinormal3ivEXT (const GLint *v);
+GLAPI void APIENTRY glBinormal3sEXT (GLshort bx, GLshort by, GLshort bz);
+GLAPI void APIENTRY glBinormal3svEXT (const GLshort *v);
+GLAPI void APIENTRY glTangentPointerEXT (GLenum type, GLsizei stride, const GLvoid *pointer);
+GLAPI void APIENTRY glBinormalPointerEXT (GLenum type, GLsizei stride, const GLvoid *pointer);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLTANGENT3BEXTPROC) (GLbyte tx, GLbyte ty, GLbyte tz);
+typedef void (APIENTRYP PFNGLTANGENT3BVEXTPROC) (const GLbyte *v);
+typedef void (APIENTRYP PFNGLTANGENT3DEXTPROC) (GLdouble tx, GLdouble ty, GLdouble tz);
+typedef void (APIENTRYP PFNGLTANGENT3DVEXTPROC) (const GLdouble *v);
+typedef void (APIENTRYP PFNGLTANGENT3FEXTPROC) (GLfloat tx, GLfloat ty, GLfloat tz);
+typedef void (APIENTRYP PFNGLTANGENT3FVEXTPROC) (const GLfloat *v);
+typedef void (APIENTRYP PFNGLTANGENT3IEXTPROC) (GLint tx, GLint ty, GLint tz);
+typedef void (APIENTRYP PFNGLTANGENT3IVEXTPROC) (const GLint *v);
+typedef void (APIENTRYP PFNGLTANGENT3SEXTPROC) (GLshort tx, GLshort ty, GLshort tz);
+typedef void (APIENTRYP PFNGLTANGENT3SVEXTPROC) (const GLshort *v);
+typedef void (APIENTRYP PFNGLBINORMAL3BEXTPROC) (GLbyte bx, GLbyte by, GLbyte bz);
+typedef void (APIENTRYP PFNGLBINORMAL3BVEXTPROC) (const GLbyte *v);
+typedef void (APIENTRYP PFNGLBINORMAL3DEXTPROC) (GLdouble bx, GLdouble by, GLdouble bz);
+typedef void (APIENTRYP PFNGLBINORMAL3DVEXTPROC) (const GLdouble *v);
+typedef void (APIENTRYP PFNGLBINORMAL3FEXTPROC) (GLfloat bx, GLfloat by, GLfloat bz);
+typedef void (APIENTRYP PFNGLBINORMAL3FVEXTPROC) (const GLfloat *v);
+typedef void (APIENTRYP PFNGLBINORMAL3IEXTPROC) (GLint bx, GLint by, GLint bz);
+typedef void (APIENTRYP PFNGLBINORMAL3IVEXTPROC) (const GLint *v);
+typedef void (APIENTRYP PFNGLBINORMAL3SEXTPROC) (GLshort bx, GLshort by, GLshort bz);
+typedef void (APIENTRYP PFNGLBINORMAL3SVEXTPROC) (const GLshort *v);
+typedef void (APIENTRYP PFNGLTANGENTPOINTEREXTPROC) (GLenum type, GLsizei stride, const GLvoid *pointer);
+typedef void (APIENTRYP PFNGLBINORMALPOINTEREXTPROC) (GLenum type, GLsizei stride, const GLvoid *pointer);
+#endif
+
+#ifndef GL_EXT_texture_env_combine
+#define GL_EXT_texture_env_combine 1
+#endif
+
+#ifndef GL_APPLE_specular_vector
+#define GL_APPLE_specular_vector 1
+#endif
+
+#ifndef GL_APPLE_transform_hint
+#define GL_APPLE_transform_hint 1
+#endif
+
+#ifndef GL_SGIX_fog_scale
+#define GL_SGIX_fog_scale 1
+#endif
+
+#ifndef GL_SUNX_constant_data
+#define GL_SUNX_constant_data 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glFinishTextureSUNX (void);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLFINISHTEXTURESUNXPROC) (void);
+#endif
+
+#ifndef GL_SUN_global_alpha
+#define GL_SUN_global_alpha 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glGlobalAlphaFactorbSUN (GLbyte factor);
+GLAPI void APIENTRY glGlobalAlphaFactorsSUN (GLshort factor);
+GLAPI void APIENTRY glGlobalAlphaFactoriSUN (GLint factor);
+GLAPI void APIENTRY glGlobalAlphaFactorfSUN (GLfloat factor);
+GLAPI void APIENTRY glGlobalAlphaFactordSUN (GLdouble factor);
+GLAPI void APIENTRY glGlobalAlphaFactorubSUN (GLubyte factor);
+GLAPI void APIENTRY glGlobalAlphaFactorusSUN (GLushort factor);
+GLAPI void APIENTRY glGlobalAlphaFactoruiSUN (GLuint factor);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLGLOBALALPHAFACTORBSUNPROC) (GLbyte factor);
+typedef void (APIENTRYP PFNGLGLOBALALPHAFACTORSSUNPROC) (GLshort factor);
+typedef void (APIENTRYP PFNGLGLOBALALPHAFACTORISUNPROC) (GLint factor);
+typedef void (APIENTRYP PFNGLGLOBALALPHAFACTORFSUNPROC) (GLfloat factor);
+typedef void (APIENTRYP PFNGLGLOBALALPHAFACTORDSUNPROC) (GLdouble factor);
+typedef void (APIENTRYP PFNGLGLOBALALPHAFACTORUBSUNPROC) (GLubyte factor);
+typedef void (APIENTRYP PFNGLGLOBALALPHAFACTORUSSUNPROC) (GLushort factor);
+typedef void (APIENTRYP PFNGLGLOBALALPHAFACTORUISUNPROC) (GLuint factor);
+#endif
+
+#ifndef GL_SUN_triangle_list
+#define GL_SUN_triangle_list 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glReplacementCodeuiSUN (GLuint code);
+GLAPI void APIENTRY glReplacementCodeusSUN (GLushort code);
+GLAPI void APIENTRY glReplacementCodeubSUN (GLubyte code);
+GLAPI void APIENTRY glReplacementCodeuivSUN (const GLuint *code);
+GLAPI void APIENTRY glReplacementCodeusvSUN (const GLushort *code);
+GLAPI void APIENTRY glReplacementCodeubvSUN (const GLubyte *code);
+GLAPI void APIENTRY glReplacementCodePointerSUN (GLenum type, GLsizei stride, const GLvoid* *pointer);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLREPLACEMENTCODEUISUNPROC) (GLuint code);
+typedef void (APIENTRYP PFNGLREPLACEMENTCODEUSSUNPROC) (GLushort code);
+typedef void (APIENTRYP PFNGLREPLACEMENTCODEUBSUNPROC) (GLubyte code);
+typedef void (APIENTRYP PFNGLREPLACEMENTCODEUIVSUNPROC) (const GLuint *code);
+typedef void (APIENTRYP PFNGLREPLACEMENTCODEUSVSUNPROC) (const GLushort *code);
+typedef void (APIENTRYP PFNGLREPLACEMENTCODEUBVSUNPROC) (const GLubyte *code);
+typedef void (APIENTRYP PFNGLREPLACEMENTCODEPOINTERSUNPROC) (GLenum type, GLsizei stride, const GLvoid* *pointer);
+#endif
+
+#ifndef GL_SUN_vertex
+#define GL_SUN_vertex 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glColor4ubVertex2fSUN (GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y);
+GLAPI void APIENTRY glColor4ubVertex2fvSUN (const GLubyte *c, const GLfloat *v);
+GLAPI void APIENTRY glColor4ubVertex3fSUN (GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z);
+GLAPI void APIENTRY glColor4ubVertex3fvSUN (const GLubyte *c, const GLfloat *v);
+GLAPI void APIENTRY glColor3fVertex3fSUN (GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z);
+GLAPI void APIENTRY glColor3fVertex3fvSUN (const GLfloat *c, const GLfloat *v);
+GLAPI void APIENTRY glNormal3fVertex3fSUN (GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+GLAPI void APIENTRY glNormal3fVertex3fvSUN (const GLfloat *n, const GLfloat *v);
+GLAPI void APIENTRY glColor4fNormal3fVertex3fSUN (GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+GLAPI void APIENTRY glColor4fNormal3fVertex3fvSUN (const GLfloat *c, const GLfloat *n, const GLfloat *v);
+GLAPI void APIENTRY glTexCoord2fVertex3fSUN (GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z);
+GLAPI void APIENTRY glTexCoord2fVertex3fvSUN (const GLfloat *tc, const GLfloat *v);
+GLAPI void APIENTRY glTexCoord4fVertex4fSUN (GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+GLAPI void APIENTRY glTexCoord4fVertex4fvSUN (const GLfloat *tc, const GLfloat *v);
+GLAPI void APIENTRY glTexCoord2fColor4ubVertex3fSUN (GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z);
+GLAPI void APIENTRY glTexCoord2fColor4ubVertex3fvSUN (const GLfloat *tc, const GLubyte *c, const GLfloat *v);
+GLAPI void APIENTRY glTexCoord2fColor3fVertex3fSUN (GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z);
+GLAPI void APIENTRY glTexCoord2fColor3fVertex3fvSUN (const GLfloat *tc, const GLfloat *c, const GLfloat *v);
+GLAPI void APIENTRY glTexCoord2fNormal3fVertex3fSUN (GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+GLAPI void APIENTRY glTexCoord2fNormal3fVertex3fvSUN (const GLfloat *tc, const GLfloat *n, const GLfloat *v);
+GLAPI void APIENTRY glTexCoord2fColor4fNormal3fVertex3fSUN (GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+GLAPI void APIENTRY glTexCoord2fColor4fNormal3fVertex3fvSUN (const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v);
+GLAPI void APIENTRY glTexCoord4fColor4fNormal3fVertex4fSUN (GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+GLAPI void APIENTRY glTexCoord4fColor4fNormal3fVertex4fvSUN (const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v);
+GLAPI void APIENTRY glReplacementCodeuiVertex3fSUN (GLuint rc, GLfloat x, GLfloat y, GLfloat z);
+GLAPI void APIENTRY glReplacementCodeuiVertex3fvSUN (const GLuint *rc, const GLfloat *v);
+GLAPI void APIENTRY glReplacementCodeuiColor4ubVertex3fSUN (GLuint rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z);
+GLAPI void APIENTRY glReplacementCodeuiColor4ubVertex3fvSUN (const GLuint *rc, const GLubyte *c, const GLfloat *v);
+GLAPI void APIENTRY glReplacementCodeuiColor3fVertex3fSUN (GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z);
+GLAPI void APIENTRY glReplacementCodeuiColor3fVertex3fvSUN (const GLuint *rc, const GLfloat *c, const GLfloat *v);
+GLAPI void APIENTRY glReplacementCodeuiNormal3fVertex3fSUN (GLuint rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+GLAPI void APIENTRY glReplacementCodeuiNormal3fVertex3fvSUN (const GLuint *rc, const GLfloat *n, const GLfloat *v);
+GLAPI void APIENTRY glReplacementCodeuiColor4fNormal3fVertex3fSUN (GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+GLAPI void APIENTRY glReplacementCodeuiColor4fNormal3fVertex3fvSUN (const GLuint *rc, const GLfloat *c, const GLfloat *n, const GLfloat *v);
+GLAPI void APIENTRY glReplacementCodeuiTexCoord2fVertex3fSUN (GLuint rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z);
+GLAPI void APIENTRY glReplacementCodeuiTexCoord2fVertex3fvSUN (const GLuint *rc, const GLfloat *tc, const GLfloat *v);
+GLAPI void APIENTRY glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN (GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+GLAPI void APIENTRY glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN (const GLuint *rc, const GLfloat *tc, const GLfloat *n, const GLfloat *v);
+GLAPI void APIENTRY glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN (GLuint rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+GLAPI void APIENTRY glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN (const GLuint *rc, const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLCOLOR4UBVERTEX2FSUNPROC) (GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y);
+typedef void (APIENTRYP PFNGLCOLOR4UBVERTEX2FVSUNPROC) (const GLubyte *c, const GLfloat *v);
+typedef void (APIENTRYP PFNGLCOLOR4UBVERTEX3FSUNPROC) (GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRYP PFNGLCOLOR4UBVERTEX3FVSUNPROC) (const GLubyte *c, const GLfloat *v);
+typedef void (APIENTRYP PFNGLCOLOR3FVERTEX3FSUNPROC) (GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRYP PFNGLCOLOR3FVERTEX3FVSUNPROC) (const GLfloat *c, const GLfloat *v);
+typedef void (APIENTRYP PFNGLNORMAL3FVERTEX3FSUNPROC) (GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRYP PFNGLNORMAL3FVERTEX3FVSUNPROC) (const GLfloat *n, const GLfloat *v);
+typedef void (APIENTRYP PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRYP PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLfloat *c, const GLfloat *n, const GLfloat *v);
+typedef void (APIENTRYP PFNGLTEXCOORD2FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRYP PFNGLTEXCOORD2FVERTEX3FVSUNPROC) (const GLfloat *tc, const GLfloat *v);
+typedef void (APIENTRYP PFNGLTEXCOORD4FVERTEX4FSUNPROC) (GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRYP PFNGLTEXCOORD4FVERTEX4FVSUNPROC) (const GLfloat *tc, const GLfloat *v);
+typedef void (APIENTRYP PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRYP PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC) (const GLfloat *tc, const GLubyte *c, const GLfloat *v);
+typedef void (APIENTRYP PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRYP PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC) (const GLfloat *tc, const GLfloat *c, const GLfloat *v);
+typedef void (APIENTRYP PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRYP PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC) (const GLfloat *tc, const GLfloat *n, const GLfloat *v);
+typedef void (APIENTRYP PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRYP PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v);
+typedef void (APIENTRYP PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC) (GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRYP PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC) (const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v);
+typedef void (APIENTRYP PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC) (GLuint rc, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRYP PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC) (const GLuint *rc, const GLfloat *v);
+typedef void (APIENTRYP PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC) (GLuint rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRYP PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC) (const GLuint *rc, const GLubyte *c, const GLfloat *v);
+typedef void (APIENTRYP PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC) (GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRYP PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC) (const GLuint *rc, const GLfloat *c, const GLfloat *v);
+typedef void (APIENTRYP PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC) (GLuint rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRYP PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC) (const GLuint *rc, const GLfloat *n, const GLfloat *v);
+typedef void (APIENTRYP PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRYP PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLuint *rc, const GLfloat *c, const GLfloat *n, const GLfloat *v);
+typedef void (APIENTRYP PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC) (GLuint rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRYP PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC) (const GLuint *rc, const GLfloat *tc, const GLfloat *v);
+typedef void (APIENTRYP PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC) (GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRYP PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC) (const GLuint *rc, const GLfloat *tc, const GLfloat *n, const GLfloat *v);
+typedef void (APIENTRYP PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLuint rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRYP PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLuint *rc, const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v);
+#endif
+
+#ifndef GL_EXT_blend_func_separate
+#define GL_EXT_blend_func_separate 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBlendFuncSeparateEXT (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEEXTPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+#endif
+
+#ifndef GL_INGR_blend_func_separate
+#define GL_INGR_blend_func_separate 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBlendFuncSeparateINGR (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEINGRPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+#endif
+
+#ifndef GL_INGR_color_clamp
+#define GL_INGR_color_clamp 1
+#endif
+
+#ifndef GL_INGR_interlace_read
+#define GL_INGR_interlace_read 1
+#endif
+
+#ifndef GL_EXT_stencil_wrap
+#define GL_EXT_stencil_wrap 1
+#endif
+
+#ifndef GL_EXT_422_pixels
+#define GL_EXT_422_pixels 1
+#endif
+
+#ifndef GL_NV_texgen_reflection
+#define GL_NV_texgen_reflection 1
+#endif
+
+#ifndef GL_SUN_convolution_border_modes
+#define GL_SUN_convolution_border_modes 1
+#endif
+
+#ifndef GL_EXT_texture_env_add
+#define GL_EXT_texture_env_add 1
+#endif
+
+#ifndef GL_EXT_texture_lod_bias
+#define GL_EXT_texture_lod_bias 1
+#endif
+
+#ifndef GL_EXT_texture_filter_anisotropic
+#define GL_EXT_texture_filter_anisotropic 1
+#endif
+
+#ifndef GL_EXT_vertex_weighting
+#define GL_EXT_vertex_weighting 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glVertexWeightfEXT (GLfloat weight);
+GLAPI void APIENTRY glVertexWeightfvEXT (const GLfloat *weight);
+GLAPI void APIENTRY glVertexWeightPointerEXT (GLsizei size, GLenum type, GLsizei stride, const GLvoid *pointer);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLVERTEXWEIGHTFEXTPROC) (GLfloat weight);
+typedef void (APIENTRYP PFNGLVERTEXWEIGHTFVEXTPROC) (const GLfloat *weight);
+typedef void (APIENTRYP PFNGLVERTEXWEIGHTPOINTEREXTPROC) (GLsizei size, GLenum type, GLsizei stride, const GLvoid *pointer);
+#endif
+
+#ifndef GL_NV_light_max_exponent
+#define GL_NV_light_max_exponent 1
+#endif
+
+#ifndef GL_NV_vertex_array_range
+#define GL_NV_vertex_array_range 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glFlushVertexArrayRangeNV (void);
+GLAPI void APIENTRY glVertexArrayRangeNV (GLsizei length, const GLvoid *pointer);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLFLUSHVERTEXARRAYRANGENVPROC) (void);
+typedef void (APIENTRYP PFNGLVERTEXARRAYRANGENVPROC) (GLsizei length, const GLvoid *pointer);
+#endif
+
+#ifndef GL_NV_register_combiners
+#define GL_NV_register_combiners 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glCombinerParameterfvNV (GLenum pname, const GLfloat *params);
+GLAPI void APIENTRY glCombinerParameterfNV (GLenum pname, GLfloat param);
+GLAPI void APIENTRY glCombinerParameterivNV (GLenum pname, const GLint *params);
+GLAPI void APIENTRY glCombinerParameteriNV (GLenum pname, GLint param);
+GLAPI void APIENTRY glCombinerInputNV (GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);
+GLAPI void APIENTRY glCombinerOutputNV (GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum);
+GLAPI void APIENTRY glFinalCombinerInputNV (GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);
+GLAPI void APIENTRY glGetCombinerInputParameterfvNV (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetCombinerInputParameterivNV (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetCombinerOutputParameterfvNV (GLenum stage, GLenum portion, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetCombinerOutputParameterivNV (GLenum stage, GLenum portion, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetFinalCombinerInputParameterfvNV (GLenum variable, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetFinalCombinerInputParameterivNV (GLenum variable, GLenum pname, GLint *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLCOMBINERPARAMETERFVNVPROC) (GLenum pname, const GLfloat *params);
+typedef void (APIENTRYP PFNGLCOMBINERPARAMETERFNVPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRYP PFNGLCOMBINERPARAMETERIVNVPROC) (GLenum pname, const GLint *params);
+typedef void (APIENTRYP PFNGLCOMBINERPARAMETERINVPROC) (GLenum pname, GLint param);
+typedef void (APIENTRYP PFNGLCOMBINERINPUTNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);
+typedef void (APIENTRYP PFNGLCOMBINEROUTPUTNVPROC) (GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum);
+typedef void (APIENTRYP PFNGLFINALCOMBINERINPUTNVPROC) (GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);
+typedef void (APIENTRYP PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC) (GLenum stage, GLenum portion, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC) (GLenum stage, GLenum portion, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC) (GLenum variable, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC) (GLenum variable, GLenum pname, GLint *params);
+#endif
+
+#ifndef GL_NV_fog_distance
+#define GL_NV_fog_distance 1
+#endif
+
+#ifndef GL_NV_texgen_emboss
+#define GL_NV_texgen_emboss 1
+#endif
+
+#ifndef GL_NV_blend_square
+#define GL_NV_blend_square 1
+#endif
+
+#ifndef GL_NV_texture_env_combine4
+#define GL_NV_texture_env_combine4 1
+#endif
+
+#ifndef GL_MESA_resize_buffers
+#define GL_MESA_resize_buffers 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glResizeBuffersMESA (void);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLRESIZEBUFFERSMESAPROC) (void);
+#endif
+
+#ifndef GL_MESA_window_pos
+#define GL_MESA_window_pos 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glWindowPos2dMESA (GLdouble x, GLdouble y);
+GLAPI void APIENTRY glWindowPos2dvMESA (const GLdouble *v);
+GLAPI void APIENTRY glWindowPos2fMESA (GLfloat x, GLfloat y);
+GLAPI void APIENTRY glWindowPos2fvMESA (const GLfloat *v);
+GLAPI void APIENTRY glWindowPos2iMESA (GLint x, GLint y);
+GLAPI void APIENTRY glWindowPos2ivMESA (const GLint *v);
+GLAPI void APIENTRY glWindowPos2sMESA (GLshort x, GLshort y);
+GLAPI void APIENTRY glWindowPos2svMESA (const GLshort *v);
+GLAPI void APIENTRY glWindowPos3dMESA (GLdouble x, GLdouble y, GLdouble z);
+GLAPI void APIENTRY glWindowPos3dvMESA (const GLdouble *v);
+GLAPI void APIENTRY glWindowPos3fMESA (GLfloat x, GLfloat y, GLfloat z);
+GLAPI void APIENTRY glWindowPos3fvMESA (const GLfloat *v);
+GLAPI void APIENTRY glWindowPos3iMESA (GLint x, GLint y, GLint z);
+GLAPI void APIENTRY glWindowPos3ivMESA (const GLint *v);
+GLAPI void APIENTRY glWindowPos3sMESA (GLshort x, GLshort y, GLshort z);
+GLAPI void APIENTRY glWindowPos3svMESA (const GLshort *v);
+GLAPI void APIENTRY glWindowPos4dMESA (GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+GLAPI void APIENTRY glWindowPos4dvMESA (const GLdouble *v);
+GLAPI void APIENTRY glWindowPos4fMESA (GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+GLAPI void APIENTRY glWindowPos4fvMESA (const GLfloat *v);
+GLAPI void APIENTRY glWindowPos4iMESA (GLint x, GLint y, GLint z, GLint w);
+GLAPI void APIENTRY glWindowPos4ivMESA (const GLint *v);
+GLAPI void APIENTRY glWindowPos4sMESA (GLshort x, GLshort y, GLshort z, GLshort w);
+GLAPI void APIENTRY glWindowPos4svMESA (const GLshort *v);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLWINDOWPOS2DMESAPROC) (GLdouble x, GLdouble y);
+typedef void (APIENTRYP PFNGLWINDOWPOS2DVMESAPROC) (const GLdouble *v);
+typedef void (APIENTRYP PFNGLWINDOWPOS2FMESAPROC) (GLfloat x, GLfloat y);
+typedef void (APIENTRYP PFNGLWINDOWPOS2FVMESAPROC) (const GLfloat *v);
+typedef void (APIENTRYP PFNGLWINDOWPOS2IMESAPROC) (GLint x, GLint y);
+typedef void (APIENTRYP PFNGLWINDOWPOS2IVMESAPROC) (const GLint *v);
+typedef void (APIENTRYP PFNGLWINDOWPOS2SMESAPROC) (GLshort x, GLshort y);
+typedef void (APIENTRYP PFNGLWINDOWPOS2SVMESAPROC) (const GLshort *v);
+typedef void (APIENTRYP PFNGLWINDOWPOS3DMESAPROC) (GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRYP PFNGLWINDOWPOS3DVMESAPROC) (const GLdouble *v);
+typedef void (APIENTRYP PFNGLWINDOWPOS3FMESAPROC) (GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRYP PFNGLWINDOWPOS3FVMESAPROC) (const GLfloat *v);
+typedef void (APIENTRYP PFNGLWINDOWPOS3IMESAPROC) (GLint x, GLint y, GLint z);
+typedef void (APIENTRYP PFNGLWINDOWPOS3IVMESAPROC) (const GLint *v);
+typedef void (APIENTRYP PFNGLWINDOWPOS3SMESAPROC) (GLshort x, GLshort y, GLshort z);
+typedef void (APIENTRYP PFNGLWINDOWPOS3SVMESAPROC) (const GLshort *v);
+typedef void (APIENTRYP PFNGLWINDOWPOS4DMESAPROC) (GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRYP PFNGLWINDOWPOS4DVMESAPROC) (const GLdouble *v);
+typedef void (APIENTRYP PFNGLWINDOWPOS4FMESAPROC) (GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRYP PFNGLWINDOWPOS4FVMESAPROC) (const GLfloat *v);
+typedef void (APIENTRYP PFNGLWINDOWPOS4IMESAPROC) (GLint x, GLint y, GLint z, GLint w);
+typedef void (APIENTRYP PFNGLWINDOWPOS4IVMESAPROC) (const GLint *v);
+typedef void (APIENTRYP PFNGLWINDOWPOS4SMESAPROC) (GLshort x, GLshort y, GLshort z, GLshort w);
+typedef void (APIENTRYP PFNGLWINDOWPOS4SVMESAPROC) (const GLshort *v);
+#endif
+
+#ifndef GL_IBM_cull_vertex
+#define GL_IBM_cull_vertex 1
+#endif
+
+#ifndef GL_IBM_multimode_draw_arrays
+#define GL_IBM_multimode_draw_arrays 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glMultiModeDrawArraysIBM (const GLenum *mode, const GLint *first, const GLsizei *count, GLsizei primcount, GLint modestride);
+GLAPI void APIENTRY glMultiModeDrawElementsIBM (const GLenum *mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei primcount, GLint modestride);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLMULTIMODEDRAWARRAYSIBMPROC) (const GLenum *mode, const GLint *first, const GLsizei *count, GLsizei primcount, GLint modestride);
+typedef void (APIENTRYP PFNGLMULTIMODEDRAWELEMENTSIBMPROC) (const GLenum *mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei primcount, GLint modestride);
+#endif
+
+#ifndef GL_IBM_vertex_array_lists
+#define GL_IBM_vertex_array_lists 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glColorPointerListIBM (GLint size, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
+GLAPI void APIENTRY glSecondaryColorPointerListIBM (GLint size, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
+GLAPI void APIENTRY glEdgeFlagPointerListIBM (GLint stride, const GLboolean* *pointer, GLint ptrstride);
+GLAPI void APIENTRY glFogCoordPointerListIBM (GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
+GLAPI void APIENTRY glIndexPointerListIBM (GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
+GLAPI void APIENTRY glNormalPointerListIBM (GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
+GLAPI void APIENTRY glTexCoordPointerListIBM (GLint size, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
+GLAPI void APIENTRY glVertexPointerListIBM (GLint size, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLCOLORPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
+typedef void (APIENTRYP PFNGLSECONDARYCOLORPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
+typedef void (APIENTRYP PFNGLEDGEFLAGPOINTERLISTIBMPROC) (GLint stride, const GLboolean* *pointer, GLint ptrstride);
+typedef void (APIENTRYP PFNGLFOGCOORDPOINTERLISTIBMPROC) (GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
+typedef void (APIENTRYP PFNGLINDEXPOINTERLISTIBMPROC) (GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
+typedef void (APIENTRYP PFNGLNORMALPOINTERLISTIBMPROC) (GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
+typedef void (APIENTRYP PFNGLTEXCOORDPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
+typedef void (APIENTRYP PFNGLVERTEXPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
+#endif
+
+#ifndef GL_SGIX_subsample
+#define GL_SGIX_subsample 1
+#endif
+
+#ifndef GL_SGIX_ycrcba
+#define GL_SGIX_ycrcba 1
+#endif
+
+#ifndef GL_SGIX_ycrcb_subsample
+#define GL_SGIX_ycrcb_subsample 1
+#endif
+
+#ifndef GL_SGIX_depth_pass_instrument
+#define GL_SGIX_depth_pass_instrument 1
+#endif
+
+#ifndef GL_3DFX_texture_compression_FXT1
+#define GL_3DFX_texture_compression_FXT1 1
+#endif
+
+#ifndef GL_3DFX_multisample
+#define GL_3DFX_multisample 1
+#endif
+
+#ifndef GL_3DFX_tbuffer
+#define GL_3DFX_tbuffer 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glTbufferMask3DFX (GLuint mask);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLTBUFFERMASK3DFXPROC) (GLuint mask);
+#endif
+
+#ifndef GL_EXT_multisample
+#define GL_EXT_multisample 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glSampleMaskEXT (GLclampf value, GLboolean invert);
+GLAPI void APIENTRY glSamplePatternEXT (GLenum pattern);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLSAMPLEMASKEXTPROC) (GLclampf value, GLboolean invert);
+typedef void (APIENTRYP PFNGLSAMPLEPATTERNEXTPROC) (GLenum pattern);
+#endif
+
+#ifndef GL_SGIX_vertex_preclip
+#define GL_SGIX_vertex_preclip 1
+#endif
+
+#ifndef GL_SGIX_convolution_accuracy
+#define GL_SGIX_convolution_accuracy 1
+#endif
+
+#ifndef GL_SGIX_resample
+#define GL_SGIX_resample 1
+#endif
+
+#ifndef GL_SGIS_point_line_texgen
+#define GL_SGIS_point_line_texgen 1
+#endif
+
+#ifndef GL_SGIS_texture_color_mask
+#define GL_SGIS_texture_color_mask 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glTextureColorMaskSGIS (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLTEXTURECOLORMASKSGISPROC) (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+#endif
+
+#ifndef GL_SGIX_igloo_interface
+#define GL_SGIX_igloo_interface 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glIglooInterfaceSGIX (GLenum pname, const GLvoid *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLIGLOOINTERFACESGIXPROC) (GLenum pname, const GLvoid *params);
+#endif
+
+#ifndef GL_EXT_texture_env_dot3
+#define GL_EXT_texture_env_dot3 1
+#endif
+
+#ifndef GL_ATI_texture_mirror_once
+#define GL_ATI_texture_mirror_once 1
+#endif
+
+#ifndef GL_NV_fence
+#define GL_NV_fence 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glDeleteFencesNV (GLsizei n, const GLuint *fences);
+GLAPI void APIENTRY glGenFencesNV (GLsizei n, GLuint *fences);
+GLAPI GLboolean APIENTRY glIsFenceNV (GLuint fence);
+GLAPI GLboolean APIENTRY glTestFenceNV (GLuint fence);
+GLAPI void APIENTRY glGetFenceivNV (GLuint fence, GLenum pname, GLint *params);
+GLAPI void APIENTRY glFinishFenceNV (GLuint fence);
+GLAPI void APIENTRY glSetFenceNV (GLuint fence, GLenum condition);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLDELETEFENCESNVPROC) (GLsizei n, const GLuint *fences);
+typedef void (APIENTRYP PFNGLGENFENCESNVPROC) (GLsizei n, GLuint *fences);
+typedef GLboolean (APIENTRYP PFNGLISFENCENVPROC) (GLuint fence);
+typedef GLboolean (APIENTRYP PFNGLTESTFENCENVPROC) (GLuint fence);
+typedef void (APIENTRYP PFNGLGETFENCEIVNVPROC) (GLuint fence, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLFINISHFENCENVPROC) (GLuint fence);
+typedef void (APIENTRYP PFNGLSETFENCENVPROC) (GLuint fence, GLenum condition);
+#endif
+
+#ifndef GL_NV_evaluators
+#define GL_NV_evaluators 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glMapControlPointsNV (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const GLvoid *points);
+GLAPI void APIENTRY glMapParameterivNV (GLenum target, GLenum pname, const GLint *params);
+GLAPI void APIENTRY glMapParameterfvNV (GLenum target, GLenum pname, const GLfloat *params);
+GLAPI void APIENTRY glGetMapControlPointsNV (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, GLvoid *points);
+GLAPI void APIENTRY glGetMapParameterivNV (GLenum target, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetMapParameterfvNV (GLenum target, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetMapAttribParameterivNV (GLenum target, GLuint index, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetMapAttribParameterfvNV (GLenum target, GLuint index, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glEvalMapsNV (GLenum target, GLenum mode);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLMAPCONTROLPOINTSNVPROC) (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const GLvoid *points);
+typedef void (APIENTRYP PFNGLMAPPARAMETERIVNVPROC) (GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRYP PFNGLMAPPARAMETERFVNVPROC) (GLenum target, GLenum pname, const GLfloat *params);
+typedef void (APIENTRYP PFNGLGETMAPCONTROLPOINTSNVPROC) (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, GLvoid *points);
+typedef void (APIENTRYP PFNGLGETMAPPARAMETERIVNVPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETMAPPARAMETERFVNVPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETMAPATTRIBPARAMETERIVNVPROC) (GLenum target, GLuint index, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETMAPATTRIBPARAMETERFVNVPROC) (GLenum target, GLuint index, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLEVALMAPSNVPROC) (GLenum target, GLenum mode);
+#endif
+
+#ifndef GL_NV_packed_depth_stencil
+#define GL_NV_packed_depth_stencil 1
+#endif
+
+#ifndef GL_NV_register_combiners2
+#define GL_NV_register_combiners2 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glCombinerStageParameterfvNV (GLenum stage, GLenum pname, const GLfloat *params);
+GLAPI void APIENTRY glGetCombinerStageParameterfvNV (GLenum stage, GLenum pname, GLfloat *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLCOMBINERSTAGEPARAMETERFVNVPROC) (GLenum stage, GLenum pname, const GLfloat *params);
+typedef void (APIENTRYP PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC) (GLenum stage, GLenum pname, GLfloat *params);
+#endif
+
+#ifndef GL_NV_texture_compression_vtc
+#define GL_NV_texture_compression_vtc 1
+#endif
+
+#ifndef GL_NV_texture_rectangle
+#define GL_NV_texture_rectangle 1
+#endif
+
+#ifndef GL_NV_texture_shader
+#define GL_NV_texture_shader 1
+#endif
+
+#ifndef GL_NV_texture_shader2
+#define GL_NV_texture_shader2 1
+#endif
+
+#ifndef GL_NV_vertex_array_range2
+#define GL_NV_vertex_array_range2 1
+#endif
+
+#ifndef GL_NV_vertex_program
+#define GL_NV_vertex_program 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI GLboolean APIENTRY glAreProgramsResidentNV (GLsizei n, const GLuint *programs, GLboolean *residences);
+GLAPI void APIENTRY glBindProgramNV (GLenum target, GLuint id);
+GLAPI void APIENTRY glDeleteProgramsNV (GLsizei n, const GLuint *programs);
+GLAPI void APIENTRY glExecuteProgramNV (GLenum target, GLuint id, const GLfloat *params);
+GLAPI void APIENTRY glGenProgramsNV (GLsizei n, GLuint *programs);
+GLAPI void APIENTRY glGetProgramParameterdvNV (GLenum target, GLuint index, GLenum pname, GLdouble *params);
+GLAPI void APIENTRY glGetProgramParameterfvNV (GLenum target, GLuint index, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetProgramivNV (GLuint id, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetProgramStringNV (GLuint id, GLenum pname, GLubyte *program);
+GLAPI void APIENTRY glGetTrackMatrixivNV (GLenum target, GLuint address, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetVertexAttribdvNV (GLuint index, GLenum pname, GLdouble *params);
+GLAPI void APIENTRY glGetVertexAttribfvNV (GLuint index, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetVertexAttribivNV (GLuint index, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetVertexAttribPointervNV (GLuint index, GLenum pname, GLvoid* *pointer);
+GLAPI GLboolean APIENTRY glIsProgramNV (GLuint id);
+GLAPI void APIENTRY glLoadProgramNV (GLenum target, GLuint id, GLsizei len, const GLubyte *program);
+GLAPI void APIENTRY glProgramParameter4dNV (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+GLAPI void APIENTRY glProgramParameter4dvNV (GLenum target, GLuint index, const GLdouble *v);
+GLAPI void APIENTRY glProgramParameter4fNV (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+GLAPI void APIENTRY glProgramParameter4fvNV (GLenum target, GLuint index, const GLfloat *v);
+GLAPI void APIENTRY glProgramParameters4dvNV (GLenum target, GLuint index, GLuint count, const GLdouble *v);
+GLAPI void APIENTRY glProgramParameters4fvNV (GLenum target, GLuint index, GLuint count, const GLfloat *v);
+GLAPI void APIENTRY glRequestResidentProgramsNV (GLsizei n, const GLuint *programs);
+GLAPI void APIENTRY glTrackMatrixNV (GLenum target, GLuint address, GLenum matrix, GLenum transform);
+GLAPI void APIENTRY glVertexAttribPointerNV (GLuint index, GLint fsize, GLenum type, GLsizei stride, const GLvoid *pointer);
+GLAPI void APIENTRY glVertexAttrib1dNV (GLuint index, GLdouble x);
+GLAPI void APIENTRY glVertexAttrib1dvNV (GLuint index, const GLdouble *v);
+GLAPI void APIENTRY glVertexAttrib1fNV (GLuint index, GLfloat x);
+GLAPI void APIENTRY glVertexAttrib1fvNV (GLuint index, const GLfloat *v);
+GLAPI void APIENTRY glVertexAttrib1sNV (GLuint index, GLshort x);
+GLAPI void APIENTRY glVertexAttrib1svNV (GLuint index, const GLshort *v);
+GLAPI void APIENTRY glVertexAttrib2dNV (GLuint index, GLdouble x, GLdouble y);
+GLAPI void APIENTRY glVertexAttrib2dvNV (GLuint index, const GLdouble *v);
+GLAPI void APIENTRY glVertexAttrib2fNV (GLuint index, GLfloat x, GLfloat y);
+GLAPI void APIENTRY glVertexAttrib2fvNV (GLuint index, const GLfloat *v);
+GLAPI void APIENTRY glVertexAttrib2sNV (GLuint index, GLshort x, GLshort y);
+GLAPI void APIENTRY glVertexAttrib2svNV (GLuint index, const GLshort *v);
+GLAPI void APIENTRY glVertexAttrib3dNV (GLuint index, GLdouble x, GLdouble y, GLdouble z);
+GLAPI void APIENTRY glVertexAttrib3dvNV (GLuint index, const GLdouble *v);
+GLAPI void APIENTRY glVertexAttrib3fNV (GLuint index, GLfloat x, GLfloat y, GLfloat z);
+GLAPI void APIENTRY glVertexAttrib3fvNV (GLuint index, const GLfloat *v);
+GLAPI void APIENTRY glVertexAttrib3sNV (GLuint index, GLshort x, GLshort y, GLshort z);
+GLAPI void APIENTRY glVertexAttrib3svNV (GLuint index, const GLshort *v);
+GLAPI void APIENTRY glVertexAttrib4dNV (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+GLAPI void APIENTRY glVertexAttrib4dvNV (GLuint index, const GLdouble *v);
+GLAPI void APIENTRY glVertexAttrib4fNV (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+GLAPI void APIENTRY glVertexAttrib4fvNV (GLuint index, const GLfloat *v);
+GLAPI void APIENTRY glVertexAttrib4sNV (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+GLAPI void APIENTRY glVertexAttrib4svNV (GLuint index, const GLshort *v);
+GLAPI void APIENTRY glVertexAttrib4ubNV (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+GLAPI void APIENTRY glVertexAttrib4ubvNV (GLuint index, const GLubyte *v);
+GLAPI void APIENTRY glVertexAttribs1dvNV (GLuint index, GLsizei count, const GLdouble *v);
+GLAPI void APIENTRY glVertexAttribs1fvNV (GLuint index, GLsizei count, const GLfloat *v);
+GLAPI void APIENTRY glVertexAttribs1svNV (GLuint index, GLsizei count, const GLshort *v);
+GLAPI void APIENTRY glVertexAttribs2dvNV (GLuint index, GLsizei count, const GLdouble *v);
+GLAPI void APIENTRY glVertexAttribs2fvNV (GLuint index, GLsizei count, const GLfloat *v);
+GLAPI void APIENTRY glVertexAttribs2svNV (GLuint index, GLsizei count, const GLshort *v);
+GLAPI void APIENTRY glVertexAttribs3dvNV (GLuint index, GLsizei count, const GLdouble *v);
+GLAPI void APIENTRY glVertexAttribs3fvNV (GLuint index, GLsizei count, const GLfloat *v);
+GLAPI void APIENTRY glVertexAttribs3svNV (GLuint index, GLsizei count, const GLshort *v);
+GLAPI void APIENTRY glVertexAttribs4dvNV (GLuint index, GLsizei count, const GLdouble *v);
+GLAPI void APIENTRY glVertexAttribs4fvNV (GLuint index, GLsizei count, const GLfloat *v);
+GLAPI void APIENTRY glVertexAttribs4svNV (GLuint index, GLsizei count, const GLshort *v);
+GLAPI void APIENTRY glVertexAttribs4ubvNV (GLuint index, GLsizei count, const GLubyte *v);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef GLboolean (APIENTRYP PFNGLAREPROGRAMSRESIDENTNVPROC) (GLsizei n, const GLuint *programs, GLboolean *residences);
+typedef void (APIENTRYP PFNGLBINDPROGRAMNVPROC) (GLenum target, GLuint id);
+typedef void (APIENTRYP PFNGLDELETEPROGRAMSNVPROC) (GLsizei n, const GLuint *programs);
+typedef void (APIENTRYP PFNGLEXECUTEPROGRAMNVPROC) (GLenum target, GLuint id, const GLfloat *params);
+typedef void (APIENTRYP PFNGLGENPROGRAMSNVPROC) (GLsizei n, GLuint *programs);
+typedef void (APIENTRYP PFNGLGETPROGRAMPARAMETERDVNVPROC) (GLenum target, GLuint index, GLenum pname, GLdouble *params);
+typedef void (APIENTRYP PFNGLGETPROGRAMPARAMETERFVNVPROC) (GLenum target, GLuint index, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETPROGRAMIVNVPROC) (GLuint id, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETPROGRAMSTRINGNVPROC) (GLuint id, GLenum pname, GLubyte *program);
+typedef void (APIENTRYP PFNGLGETTRACKMATRIXIVNVPROC) (GLenum target, GLuint address, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBDVNVPROC) (GLuint index, GLenum pname, GLdouble *params);
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBFVNVPROC) (GLuint index, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVNVPROC) (GLuint index, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBPOINTERVNVPROC) (GLuint index, GLenum pname, GLvoid* *pointer);
+typedef GLboolean (APIENTRYP PFNGLISPROGRAMNVPROC) (GLuint id);
+typedef void (APIENTRYP PFNGLLOADPROGRAMNVPROC) (GLenum target, GLuint id, GLsizei len, const GLubyte *program);
+typedef void (APIENTRYP PFNGLPROGRAMPARAMETER4DNVPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRYP PFNGLPROGRAMPARAMETER4DVNVPROC) (GLenum target, GLuint index, const GLdouble *v);
+typedef void (APIENTRYP PFNGLPROGRAMPARAMETER4FNVPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRYP PFNGLPROGRAMPARAMETER4FVNVPROC) (GLenum target, GLuint index, const GLfloat *v);
+typedef void (APIENTRYP PFNGLPROGRAMPARAMETERS4DVNVPROC) (GLenum target, GLuint index, GLuint count, const GLdouble *v);
+typedef void (APIENTRYP PFNGLPROGRAMPARAMETERS4FVNVPROC) (GLenum target, GLuint index, GLuint count, const GLfloat *v);
+typedef void (APIENTRYP PFNGLREQUESTRESIDENTPROGRAMSNVPROC) (GLsizei n, const GLuint *programs);
+typedef void (APIENTRYP PFNGLTRACKMATRIXNVPROC) (GLenum target, GLuint address, GLenum matrix, GLenum transform);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERNVPROC) (GLuint index, GLint fsize, GLenum type, GLsizei stride, const GLvoid *pointer);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB1DNVPROC) (GLuint index, GLdouble x);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB1DVNVPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB1FNVPROC) (GLuint index, GLfloat x);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB1FVNVPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB1SNVPROC) (GLuint index, GLshort x);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB1SVNVPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB2DNVPROC) (GLuint index, GLdouble x, GLdouble y);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB2DVNVPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB2FNVPROC) (GLuint index, GLfloat x, GLfloat y);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB2FVNVPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB2SNVPROC) (GLuint index, GLshort x, GLshort y);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB2SVNVPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB3DNVPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB3DVNVPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB3FNVPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB3FVNVPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB3SNVPROC) (GLuint index, GLshort x, GLshort y, GLshort z);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB3SVNVPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4DNVPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4DVNVPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4FNVPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4FVNVPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4SNVPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4SVNVPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBNVPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBVNVPROC) (GLuint index, const GLubyte *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBS1DVNVPROC) (GLuint index, GLsizei count, const GLdouble *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBS1FVNVPROC) (GLuint index, GLsizei count, const GLfloat *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBS1SVNVPROC) (GLuint index, GLsizei count, const GLshort *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBS2DVNVPROC) (GLuint index, GLsizei count, const GLdouble *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBS2FVNVPROC) (GLuint index, GLsizei count, const GLfloat *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBS2SVNVPROC) (GLuint index, GLsizei count, const GLshort *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBS3DVNVPROC) (GLuint index, GLsizei count, const GLdouble *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBS3FVNVPROC) (GLuint index, GLsizei count, const GLfloat *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBS3SVNVPROC) (GLuint index, GLsizei count, const GLshort *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBS4DVNVPROC) (GLuint index, GLsizei count, const GLdouble *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBS4FVNVPROC) (GLuint index, GLsizei count, const GLfloat *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBS4SVNVPROC) (GLuint index, GLsizei count, const GLshort *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBS4UBVNVPROC) (GLuint index, GLsizei count, const GLubyte *v);
+#endif
+
+#ifndef GL_SGIX_texture_coordinate_clamp
+#define GL_SGIX_texture_coordinate_clamp 1
+#endif
+
+#ifndef GL_SGIX_scalebias_hint
+#define GL_SGIX_scalebias_hint 1
+#endif
+
+#ifndef GL_OML_interlace
+#define GL_OML_interlace 1
+#endif
+
+#ifndef GL_OML_subsample
+#define GL_OML_subsample 1
+#endif
+
+#ifndef GL_OML_resample
+#define GL_OML_resample 1
+#endif
+
+#ifndef GL_NV_copy_depth_to_color
+#define GL_NV_copy_depth_to_color 1
+#endif
+
+#ifndef GL_ATI_envmap_bumpmap
+#define GL_ATI_envmap_bumpmap 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glTexBumpParameterivATI (GLenum pname, const GLint *param);
+GLAPI void APIENTRY glTexBumpParameterfvATI (GLenum pname, const GLfloat *param);
+GLAPI void APIENTRY glGetTexBumpParameterivATI (GLenum pname, GLint *param);
+GLAPI void APIENTRY glGetTexBumpParameterfvATI (GLenum pname, GLfloat *param);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLTEXBUMPPARAMETERIVATIPROC) (GLenum pname, const GLint *param);
+typedef void (APIENTRYP PFNGLTEXBUMPPARAMETERFVATIPROC) (GLenum pname, const GLfloat *param);
+typedef void (APIENTRYP PFNGLGETTEXBUMPPARAMETERIVATIPROC) (GLenum pname, GLint *param);
+typedef void (APIENTRYP PFNGLGETTEXBUMPPARAMETERFVATIPROC) (GLenum pname, GLfloat *param);
+#endif
+
+#ifndef GL_ATI_fragment_shader
+#define GL_ATI_fragment_shader 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI GLuint APIENTRY glGenFragmentShadersATI (GLuint range);
+GLAPI void APIENTRY glBindFragmentShaderATI (GLuint id);
+GLAPI void APIENTRY glDeleteFragmentShaderATI (GLuint id);
+GLAPI void APIENTRY glBeginFragmentShaderATI (void);
+GLAPI void APIENTRY glEndFragmentShaderATI (void);
+GLAPI void APIENTRY glPassTexCoordATI (GLuint dst, GLuint coord, GLenum swizzle);
+GLAPI void APIENTRY glSampleMapATI (GLuint dst, GLuint interp, GLenum swizzle);
+GLAPI void APIENTRY glColorFragmentOp1ATI (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod);
+GLAPI void APIENTRY glColorFragmentOp2ATI (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod);
+GLAPI void APIENTRY glColorFragmentOp3ATI (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod);
+GLAPI void APIENTRY glAlphaFragmentOp1ATI (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod);
+GLAPI void APIENTRY glAlphaFragmentOp2ATI (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod);
+GLAPI void APIENTRY glAlphaFragmentOp3ATI (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod);
+GLAPI void APIENTRY glSetFragmentShaderConstantATI (GLuint dst, const GLfloat *value);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef GLuint (APIENTRYP PFNGLGENFRAGMENTSHADERSATIPROC) (GLuint range);
+typedef void (APIENTRYP PFNGLBINDFRAGMENTSHADERATIPROC) (GLuint id);
+typedef void (APIENTRYP PFNGLDELETEFRAGMENTSHADERATIPROC) (GLuint id);
+typedef void (APIENTRYP PFNGLBEGINFRAGMENTSHADERATIPROC) (void);
+typedef void (APIENTRYP PFNGLENDFRAGMENTSHADERATIPROC) (void);
+typedef void (APIENTRYP PFNGLPASSTEXCOORDATIPROC) (GLuint dst, GLuint coord, GLenum swizzle);
+typedef void (APIENTRYP PFNGLSAMPLEMAPATIPROC) (GLuint dst, GLuint interp, GLenum swizzle);
+typedef void (APIENTRYP PFNGLCOLORFRAGMENTOP1ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod);
+typedef void (APIENTRYP PFNGLCOLORFRAGMENTOP2ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod);
+typedef void (APIENTRYP PFNGLCOLORFRAGMENTOP3ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod);
+typedef void (APIENTRYP PFNGLALPHAFRAGMENTOP1ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod);
+typedef void (APIENTRYP PFNGLALPHAFRAGMENTOP2ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod);
+typedef void (APIENTRYP PFNGLALPHAFRAGMENTOP3ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod);
+typedef void (APIENTRYP PFNGLSETFRAGMENTSHADERCONSTANTATIPROC) (GLuint dst, const GLfloat *value);
+#endif
+
+#ifndef GL_ATI_pn_triangles
+#define GL_ATI_pn_triangles 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glPNTrianglesiATI (GLenum pname, GLint param);
+GLAPI void APIENTRY glPNTrianglesfATI (GLenum pname, GLfloat param);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLPNTRIANGLESIATIPROC) (GLenum pname, GLint param);
+typedef void (APIENTRYP PFNGLPNTRIANGLESFATIPROC) (GLenum pname, GLfloat param);
+#endif
+
+#ifndef GL_ATI_vertex_array_object
+#define GL_ATI_vertex_array_object 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI GLuint APIENTRY glNewObjectBufferATI (GLsizei size, const GLvoid *pointer, GLenum usage);
+GLAPI GLboolean APIENTRY glIsObjectBufferATI (GLuint buffer);
+GLAPI void APIENTRY glUpdateObjectBufferATI (GLuint buffer, GLuint offset, GLsizei size, const GLvoid *pointer, GLenum preserve);
+GLAPI void APIENTRY glGetObjectBufferfvATI (GLuint buffer, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetObjectBufferivATI (GLuint buffer, GLenum pname, GLint *params);
+GLAPI void APIENTRY glFreeObjectBufferATI (GLuint buffer);
+GLAPI void APIENTRY glArrayObjectATI (GLenum array, GLint size, GLenum type, GLsizei stride, GLuint buffer, GLuint offset);
+GLAPI void APIENTRY glGetArrayObjectfvATI (GLenum array, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetArrayObjectivATI (GLenum array, GLenum pname, GLint *params);
+GLAPI void APIENTRY glVariantArrayObjectATI (GLuint id, GLenum type, GLsizei stride, GLuint buffer, GLuint offset);
+GLAPI void APIENTRY glGetVariantArrayObjectfvATI (GLuint id, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetVariantArrayObjectivATI (GLuint id, GLenum pname, GLint *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef GLuint (APIENTRYP PFNGLNEWOBJECTBUFFERATIPROC) (GLsizei size, const GLvoid *pointer, GLenum usage);
+typedef GLboolean (APIENTRYP PFNGLISOBJECTBUFFERATIPROC) (GLuint buffer);
+typedef void (APIENTRYP PFNGLUPDATEOBJECTBUFFERATIPROC) (GLuint buffer, GLuint offset, GLsizei size, const GLvoid *pointer, GLenum preserve);
+typedef void (APIENTRYP PFNGLGETOBJECTBUFFERFVATIPROC) (GLuint buffer, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETOBJECTBUFFERIVATIPROC) (GLuint buffer, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLFREEOBJECTBUFFERATIPROC) (GLuint buffer);
+typedef void (APIENTRYP PFNGLARRAYOBJECTATIPROC) (GLenum array, GLint size, GLenum type, GLsizei stride, GLuint buffer, GLuint offset);
+typedef void (APIENTRYP PFNGLGETARRAYOBJECTFVATIPROC) (GLenum array, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETARRAYOBJECTIVATIPROC) (GLenum array, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLVARIANTARRAYOBJECTATIPROC) (GLuint id, GLenum type, GLsizei stride, GLuint buffer, GLuint offset);
+typedef void (APIENTRYP PFNGLGETVARIANTARRAYOBJECTFVATIPROC) (GLuint id, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETVARIANTARRAYOBJECTIVATIPROC) (GLuint id, GLenum pname, GLint *params);
+#endif
+
+#ifndef GL_EXT_vertex_shader
+#define GL_EXT_vertex_shader 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBeginVertexShaderEXT (void);
+GLAPI void APIENTRY glEndVertexShaderEXT (void);
+GLAPI void APIENTRY glBindVertexShaderEXT (GLuint id);
+GLAPI GLuint APIENTRY glGenVertexShadersEXT (GLuint range);
+GLAPI void APIENTRY glDeleteVertexShaderEXT (GLuint id);
+GLAPI void APIENTRY glShaderOp1EXT (GLenum op, GLuint res, GLuint arg1);
+GLAPI void APIENTRY glShaderOp2EXT (GLenum op, GLuint res, GLuint arg1, GLuint arg2);
+GLAPI void APIENTRY glShaderOp3EXT (GLenum op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3);
+GLAPI void APIENTRY glSwizzleEXT (GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW);
+GLAPI void APIENTRY glWriteMaskEXT (GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW);
+GLAPI void APIENTRY glInsertComponentEXT (GLuint res, GLuint src, GLuint num);
+GLAPI void APIENTRY glExtractComponentEXT (GLuint res, GLuint src, GLuint num);
+GLAPI GLuint APIENTRY glGenSymbolsEXT (GLenum datatype, GLenum storagetype, GLenum range, GLuint components);
+GLAPI void APIENTRY glSetInvariantEXT (GLuint id, GLenum type, const GLvoid *addr);
+GLAPI void APIENTRY glSetLocalConstantEXT (GLuint id, GLenum type, const GLvoid *addr);
+GLAPI void APIENTRY glVariantbvEXT (GLuint id, const GLbyte *addr);
+GLAPI void APIENTRY glVariantsvEXT (GLuint id, const GLshort *addr);
+GLAPI void APIENTRY glVariantivEXT (GLuint id, const GLint *addr);
+GLAPI void APIENTRY glVariantfvEXT (GLuint id, const GLfloat *addr);
+GLAPI void APIENTRY glVariantdvEXT (GLuint id, const GLdouble *addr);
+GLAPI void APIENTRY glVariantubvEXT (GLuint id, const GLubyte *addr);
+GLAPI void APIENTRY glVariantusvEXT (GLuint id, const GLushort *addr);
+GLAPI void APIENTRY glVariantuivEXT (GLuint id, const GLuint *addr);
+GLAPI void APIENTRY glVariantPointerEXT (GLuint id, GLenum type, GLuint stride, const GLvoid *addr);
+GLAPI void APIENTRY glEnableVariantClientStateEXT (GLuint id);
+GLAPI void APIENTRY glDisableVariantClientStateEXT (GLuint id);
+GLAPI GLuint APIENTRY glBindLightParameterEXT (GLenum light, GLenum value);
+GLAPI GLuint APIENTRY glBindMaterialParameterEXT (GLenum face, GLenum value);
+GLAPI GLuint APIENTRY glBindTexGenParameterEXT (GLenum unit, GLenum coord, GLenum value);
+GLAPI GLuint APIENTRY glBindTextureUnitParameterEXT (GLenum unit, GLenum value);
+GLAPI GLuint APIENTRY glBindParameterEXT (GLenum value);
+GLAPI GLboolean APIENTRY glIsVariantEnabledEXT (GLuint id, GLenum cap);
+GLAPI void APIENTRY glGetVariantBooleanvEXT (GLuint id, GLenum value, GLboolean *data);
+GLAPI void APIENTRY glGetVariantIntegervEXT (GLuint id, GLenum value, GLint *data);
+GLAPI void APIENTRY glGetVariantFloatvEXT (GLuint id, GLenum value, GLfloat *data);
+GLAPI void APIENTRY glGetVariantPointervEXT (GLuint id, GLenum value, GLvoid* *data);
+GLAPI void APIENTRY glGetInvariantBooleanvEXT (GLuint id, GLenum value, GLboolean *data);
+GLAPI void APIENTRY glGetInvariantIntegervEXT (GLuint id, GLenum value, GLint *data);
+GLAPI void APIENTRY glGetInvariantFloatvEXT (GLuint id, GLenum value, GLfloat *data);
+GLAPI void APIENTRY glGetLocalConstantBooleanvEXT (GLuint id, GLenum value, GLboolean *data);
+GLAPI void APIENTRY glGetLocalConstantIntegervEXT (GLuint id, GLenum value, GLint *data);
+GLAPI void APIENTRY glGetLocalConstantFloatvEXT (GLuint id, GLenum value, GLfloat *data);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLBEGINVERTEXSHADEREXTPROC) (void);
+typedef void (APIENTRYP PFNGLENDVERTEXSHADEREXTPROC) (void);
+typedef void (APIENTRYP PFNGLBINDVERTEXSHADEREXTPROC) (GLuint id);
+typedef GLuint (APIENTRYP PFNGLGENVERTEXSHADERSEXTPROC) (GLuint range);
+typedef void (APIENTRYP PFNGLDELETEVERTEXSHADEREXTPROC) (GLuint id);
+typedef void (APIENTRYP PFNGLSHADEROP1EXTPROC) (GLenum op, GLuint res, GLuint arg1);
+typedef void (APIENTRYP PFNGLSHADEROP2EXTPROC) (GLenum op, GLuint res, GLuint arg1, GLuint arg2);
+typedef void (APIENTRYP PFNGLSHADEROP3EXTPROC) (GLenum op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3);
+typedef void (APIENTRYP PFNGLSWIZZLEEXTPROC) (GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW);
+typedef void (APIENTRYP PFNGLWRITEMASKEXTPROC) (GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW);
+typedef void (APIENTRYP PFNGLINSERTCOMPONENTEXTPROC) (GLuint res, GLuint src, GLuint num);
+typedef void (APIENTRYP PFNGLEXTRACTCOMPONENTEXTPROC) (GLuint res, GLuint src, GLuint num);
+typedef GLuint (APIENTRYP PFNGLGENSYMBOLSEXTPROC) (GLenum datatype, GLenum storagetype, GLenum range, GLuint components);
+typedef void (APIENTRYP PFNGLSETINVARIANTEXTPROC) (GLuint id, GLenum type, const GLvoid *addr);
+typedef void (APIENTRYP PFNGLSETLOCALCONSTANTEXTPROC) (GLuint id, GLenum type, const GLvoid *addr);
+typedef void (APIENTRYP PFNGLVARIANTBVEXTPROC) (GLuint id, const GLbyte *addr);
+typedef void (APIENTRYP PFNGLVARIANTSVEXTPROC) (GLuint id, const GLshort *addr);
+typedef void (APIENTRYP PFNGLVARIANTIVEXTPROC) (GLuint id, const GLint *addr);
+typedef void (APIENTRYP PFNGLVARIANTFVEXTPROC) (GLuint id, const GLfloat *addr);
+typedef void (APIENTRYP PFNGLVARIANTDVEXTPROC) (GLuint id, const GLdouble *addr);
+typedef void (APIENTRYP PFNGLVARIANTUBVEXTPROC) (GLuint id, const GLubyte *addr);
+typedef void (APIENTRYP PFNGLVARIANTUSVEXTPROC) (GLuint id, const GLushort *addr);
+typedef void (APIENTRYP PFNGLVARIANTUIVEXTPROC) (GLuint id, const GLuint *addr);
+typedef void (APIENTRYP PFNGLVARIANTPOINTEREXTPROC) (GLuint id, GLenum type, GLuint stride, const GLvoid *addr);
+typedef void (APIENTRYP PFNGLENABLEVARIANTCLIENTSTATEEXTPROC) (GLuint id);
+typedef void (APIENTRYP PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC) (GLuint id);
+typedef GLuint (APIENTRYP PFNGLBINDLIGHTPARAMETEREXTPROC) (GLenum light, GLenum value);
+typedef GLuint (APIENTRYP PFNGLBINDMATERIALPARAMETEREXTPROC) (GLenum face, GLenum value);
+typedef GLuint (APIENTRYP PFNGLBINDTEXGENPARAMETEREXTPROC) (GLenum unit, GLenum coord, GLenum value);
+typedef GLuint (APIENTRYP PFNGLBINDTEXTUREUNITPARAMETEREXTPROC) (GLenum unit, GLenum value);
+typedef GLuint (APIENTRYP PFNGLBINDPARAMETEREXTPROC) (GLenum value);
+typedef GLboolean (APIENTRYP PFNGLISVARIANTENABLEDEXTPROC) (GLuint id, GLenum cap);
+typedef void (APIENTRYP PFNGLGETVARIANTBOOLEANVEXTPROC) (GLuint id, GLenum value, GLboolean *data);
+typedef void (APIENTRYP PFNGLGETVARIANTINTEGERVEXTPROC) (GLuint id, GLenum value, GLint *data);
+typedef void (APIENTRYP PFNGLGETVARIANTFLOATVEXTPROC) (GLuint id, GLenum value, GLfloat *data);
+typedef void (APIENTRYP PFNGLGETVARIANTPOINTERVEXTPROC) (GLuint id, GLenum value, GLvoid* *data);
+typedef void (APIENTRYP PFNGLGETINVARIANTBOOLEANVEXTPROC) (GLuint id, GLenum value, GLboolean *data);
+typedef void (APIENTRYP PFNGLGETINVARIANTINTEGERVEXTPROC) (GLuint id, GLenum value, GLint *data);
+typedef void (APIENTRYP PFNGLGETINVARIANTFLOATVEXTPROC) (GLuint id, GLenum value, GLfloat *data);
+typedef void (APIENTRYP PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC) (GLuint id, GLenum value, GLboolean *data);
+typedef void (APIENTRYP PFNGLGETLOCALCONSTANTINTEGERVEXTPROC) (GLuint id, GLenum value, GLint *data);
+typedef void (APIENTRYP PFNGLGETLOCALCONSTANTFLOATVEXTPROC) (GLuint id, GLenum value, GLfloat *data);
+#endif
+
+#ifndef GL_ATI_vertex_streams
+#define GL_ATI_vertex_streams 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glVertexStream1sATI (GLenum stream, GLshort x);
+GLAPI void APIENTRY glVertexStream1svATI (GLenum stream, const GLshort *coords);
+GLAPI void APIENTRY glVertexStream1iATI (GLenum stream, GLint x);
+GLAPI void APIENTRY glVertexStream1ivATI (GLenum stream, const GLint *coords);
+GLAPI void APIENTRY glVertexStream1fATI (GLenum stream, GLfloat x);
+GLAPI void APIENTRY glVertexStream1fvATI (GLenum stream, const GLfloat *coords);
+GLAPI void APIENTRY glVertexStream1dATI (GLenum stream, GLdouble x);
+GLAPI void APIENTRY glVertexStream1dvATI (GLenum stream, const GLdouble *coords);
+GLAPI void APIENTRY glVertexStream2sATI (GLenum stream, GLshort x, GLshort y);
+GLAPI void APIENTRY glVertexStream2svATI (GLenum stream, const GLshort *coords);
+GLAPI void APIENTRY glVertexStream2iATI (GLenum stream, GLint x, GLint y);
+GLAPI void APIENTRY glVertexStream2ivATI (GLenum stream, const GLint *coords);
+GLAPI void APIENTRY glVertexStream2fATI (GLenum stream, GLfloat x, GLfloat y);
+GLAPI void APIENTRY glVertexStream2fvATI (GLenum stream, const GLfloat *coords);
+GLAPI void APIENTRY glVertexStream2dATI (GLenum stream, GLdouble x, GLdouble y);
+GLAPI void APIENTRY glVertexStream2dvATI (GLenum stream, const GLdouble *coords);
+GLAPI void APIENTRY glVertexStream3sATI (GLenum stream, GLshort x, GLshort y, GLshort z);
+GLAPI void APIENTRY glVertexStream3svATI (GLenum stream, const GLshort *coords);
+GLAPI void APIENTRY glVertexStream3iATI (GLenum stream, GLint x, GLint y, GLint z);
+GLAPI void APIENTRY glVertexStream3ivATI (GLenum stream, const GLint *coords);
+GLAPI void APIENTRY glVertexStream3fATI (GLenum stream, GLfloat x, GLfloat y, GLfloat z);
+GLAPI void APIENTRY glVertexStream3fvATI (GLenum stream, const GLfloat *coords);
+GLAPI void APIENTRY glVertexStream3dATI (GLenum stream, GLdouble x, GLdouble y, GLdouble z);
+GLAPI void APIENTRY glVertexStream3dvATI (GLenum stream, const GLdouble *coords);
+GLAPI void APIENTRY glVertexStream4sATI (GLenum stream, GLshort x, GLshort y, GLshort z, GLshort w);
+GLAPI void APIENTRY glVertexStream4svATI (GLenum stream, const GLshort *coords);
+GLAPI void APIENTRY glVertexStream4iATI (GLenum stream, GLint x, GLint y, GLint z, GLint w);
+GLAPI void APIENTRY glVertexStream4ivATI (GLenum stream, const GLint *coords);
+GLAPI void APIENTRY glVertexStream4fATI (GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+GLAPI void APIENTRY glVertexStream4fvATI (GLenum stream, const GLfloat *coords);
+GLAPI void APIENTRY glVertexStream4dATI (GLenum stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+GLAPI void APIENTRY glVertexStream4dvATI (GLenum stream, const GLdouble *coords);
+GLAPI void APIENTRY glNormalStream3bATI (GLenum stream, GLbyte nx, GLbyte ny, GLbyte nz);
+GLAPI void APIENTRY glNormalStream3bvATI (GLenum stream, const GLbyte *coords);
+GLAPI void APIENTRY glNormalStream3sATI (GLenum stream, GLshort nx, GLshort ny, GLshort nz);
+GLAPI void APIENTRY glNormalStream3svATI (GLenum stream, const GLshort *coords);
+GLAPI void APIENTRY glNormalStream3iATI (GLenum stream, GLint nx, GLint ny, GLint nz);
+GLAPI void APIENTRY glNormalStream3ivATI (GLenum stream, const GLint *coords);
+GLAPI void APIENTRY glNormalStream3fATI (GLenum stream, GLfloat nx, GLfloat ny, GLfloat nz);
+GLAPI void APIENTRY glNormalStream3fvATI (GLenum stream, const GLfloat *coords);
+GLAPI void APIENTRY glNormalStream3dATI (GLenum stream, GLdouble nx, GLdouble ny, GLdouble nz);
+GLAPI void APIENTRY glNormalStream3dvATI (GLenum stream, const GLdouble *coords);
+GLAPI void APIENTRY glClientActiveVertexStreamATI (GLenum stream);
+GLAPI void APIENTRY glVertexBlendEnviATI (GLenum pname, GLint param);
+GLAPI void APIENTRY glVertexBlendEnvfATI (GLenum pname, GLfloat param);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLVERTEXSTREAM1SATIPROC) (GLenum stream, GLshort x);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM1SVATIPROC) (GLenum stream, const GLshort *coords);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM1IATIPROC) (GLenum stream, GLint x);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM1IVATIPROC) (GLenum stream, const GLint *coords);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM1FATIPROC) (GLenum stream, GLfloat x);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM1FVATIPROC) (GLenum stream, const GLfloat *coords);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM1DATIPROC) (GLenum stream, GLdouble x);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM1DVATIPROC) (GLenum stream, const GLdouble *coords);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM2SATIPROC) (GLenum stream, GLshort x, GLshort y);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM2SVATIPROC) (GLenum stream, const GLshort *coords);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM2IATIPROC) (GLenum stream, GLint x, GLint y);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM2IVATIPROC) (GLenum stream, const GLint *coords);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM2FATIPROC) (GLenum stream, GLfloat x, GLfloat y);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM2FVATIPROC) (GLenum stream, const GLfloat *coords);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM2DATIPROC) (GLenum stream, GLdouble x, GLdouble y);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM2DVATIPROC) (GLenum stream, const GLdouble *coords);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM3SATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM3SVATIPROC) (GLenum stream, const GLshort *coords);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM3IATIPROC) (GLenum stream, GLint x, GLint y, GLint z);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM3IVATIPROC) (GLenum stream, const GLint *coords);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM3FATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM3FVATIPROC) (GLenum stream, const GLfloat *coords);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM3DATIPROC) (GLenum stream, GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM3DVATIPROC) (GLenum stream, const GLdouble *coords);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM4SATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z, GLshort w);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM4SVATIPROC) (GLenum stream, const GLshort *coords);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM4IATIPROC) (GLenum stream, GLint x, GLint y, GLint z, GLint w);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM4IVATIPROC) (GLenum stream, const GLint *coords);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM4FATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM4FVATIPROC) (GLenum stream, const GLfloat *coords);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM4DATIPROC) (GLenum stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRYP PFNGLVERTEXSTREAM4DVATIPROC) (GLenum stream, const GLdouble *coords);
+typedef void (APIENTRYP PFNGLNORMALSTREAM3BATIPROC) (GLenum stream, GLbyte nx, GLbyte ny, GLbyte nz);
+typedef void (APIENTRYP PFNGLNORMALSTREAM3BVATIPROC) (GLenum stream, const GLbyte *coords);
+typedef void (APIENTRYP PFNGLNORMALSTREAM3SATIPROC) (GLenum stream, GLshort nx, GLshort ny, GLshort nz);
+typedef void (APIENTRYP PFNGLNORMALSTREAM3SVATIPROC) (GLenum stream, const GLshort *coords);
+typedef void (APIENTRYP PFNGLNORMALSTREAM3IATIPROC) (GLenum stream, GLint nx, GLint ny, GLint nz);
+typedef void (APIENTRYP PFNGLNORMALSTREAM3IVATIPROC) (GLenum stream, const GLint *coords);
+typedef void (APIENTRYP PFNGLNORMALSTREAM3FATIPROC) (GLenum stream, GLfloat nx, GLfloat ny, GLfloat nz);
+typedef void (APIENTRYP PFNGLNORMALSTREAM3FVATIPROC) (GLenum stream, const GLfloat *coords);
+typedef void (APIENTRYP PFNGLNORMALSTREAM3DATIPROC) (GLenum stream, GLdouble nx, GLdouble ny, GLdouble nz);
+typedef void (APIENTRYP PFNGLNORMALSTREAM3DVATIPROC) (GLenum stream, const GLdouble *coords);
+typedef void (APIENTRYP PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC) (GLenum stream);
+typedef void (APIENTRYP PFNGLVERTEXBLENDENVIATIPROC) (GLenum pname, GLint param);
+typedef void (APIENTRYP PFNGLVERTEXBLENDENVFATIPROC) (GLenum pname, GLfloat param);
+#endif
+
+#ifndef GL_ATI_element_array
+#define GL_ATI_element_array 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glElementPointerATI (GLenum type, const GLvoid *pointer);
+GLAPI void APIENTRY glDrawElementArrayATI (GLenum mode, GLsizei count);
+GLAPI void APIENTRY glDrawRangeElementArrayATI (GLenum mode, GLuint start, GLuint end, GLsizei count);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLELEMENTPOINTERATIPROC) (GLenum type, const GLvoid *pointer);
+typedef void (APIENTRYP PFNGLDRAWELEMENTARRAYATIPROC) (GLenum mode, GLsizei count);
+typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTARRAYATIPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count);
+#endif
+
+#ifndef GL_SUN_mesh_array
+#define GL_SUN_mesh_array 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glDrawMeshArraysSUN (GLenum mode, GLint first, GLsizei count, GLsizei width);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLDRAWMESHARRAYSSUNPROC) (GLenum mode, GLint first, GLsizei count, GLsizei width);
+#endif
+
+#ifndef GL_SUN_slice_accum
+#define GL_SUN_slice_accum 1
+#endif
+
+#ifndef GL_NV_multisample_filter_hint
+#define GL_NV_multisample_filter_hint 1
+#endif
+
+#ifndef GL_NV_depth_clamp
+#define GL_NV_depth_clamp 1
+#endif
+
+#ifndef GL_NV_occlusion_query
+#define GL_NV_occlusion_query 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glGenOcclusionQueriesNV (GLsizei n, GLuint *ids);
+GLAPI void APIENTRY glDeleteOcclusionQueriesNV (GLsizei n, const GLuint *ids);
+GLAPI GLboolean APIENTRY glIsOcclusionQueryNV (GLuint id);
+GLAPI void APIENTRY glBeginOcclusionQueryNV (GLuint id);
+GLAPI void APIENTRY glEndOcclusionQueryNV (void);
+GLAPI void APIENTRY glGetOcclusionQueryivNV (GLuint id, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetOcclusionQueryuivNV (GLuint id, GLenum pname, GLuint *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLGENOCCLUSIONQUERIESNVPROC) (GLsizei n, GLuint *ids);
+typedef void (APIENTRYP PFNGLDELETEOCCLUSIONQUERIESNVPROC) (GLsizei n, const GLuint *ids);
+typedef GLboolean (APIENTRYP PFNGLISOCCLUSIONQUERYNVPROC) (GLuint id);
+typedef void (APIENTRYP PFNGLBEGINOCCLUSIONQUERYNVPROC) (GLuint id);
+typedef void (APIENTRYP PFNGLENDOCCLUSIONQUERYNVPROC) (void);
+typedef void (APIENTRYP PFNGLGETOCCLUSIONQUERYIVNVPROC) (GLuint id, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETOCCLUSIONQUERYUIVNVPROC) (GLuint id, GLenum pname, GLuint *params);
+#endif
+
+#ifndef GL_NV_point_sprite
+#define GL_NV_point_sprite 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glPointParameteriNV (GLenum pname, GLint param);
+GLAPI void APIENTRY glPointParameterivNV (GLenum pname, const GLint *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLPOINTPARAMETERINVPROC) (GLenum pname, GLint param);
+typedef void (APIENTRYP PFNGLPOINTPARAMETERIVNVPROC) (GLenum pname, const GLint *params);
+#endif
+
+#ifndef GL_NV_texture_shader3
+#define GL_NV_texture_shader3 1
+#endif
+
+#ifndef GL_NV_vertex_program1_1
+#define GL_NV_vertex_program1_1 1
+#endif
+
+#ifndef GL_EXT_shadow_funcs
+#define GL_EXT_shadow_funcs 1
+#endif
+
+#ifndef GL_EXT_stencil_two_side
+#define GL_EXT_stencil_two_side 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glActiveStencilFaceEXT (GLenum face);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLACTIVESTENCILFACEEXTPROC) (GLenum face);
+#endif
+
+#ifndef GL_ATI_text_fragment_shader
+#define GL_ATI_text_fragment_shader 1
+#endif
+
+#ifndef GL_APPLE_client_storage
+#define GL_APPLE_client_storage 1
+#endif
+
+#ifndef GL_APPLE_element_array
+#define GL_APPLE_element_array 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glElementPointerAPPLE (GLenum type, const GLvoid *pointer);
+GLAPI void APIENTRY glDrawElementArrayAPPLE (GLenum mode, GLint first, GLsizei count);
+GLAPI void APIENTRY glDrawRangeElementArrayAPPLE (GLenum mode, GLuint start, GLuint end, GLint first, GLsizei count);
+GLAPI void APIENTRY glMultiDrawElementArrayAPPLE (GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount);
+GLAPI void APIENTRY glMultiDrawRangeElementArrayAPPLE (GLenum mode, GLuint start, GLuint end, const GLint *first, const GLsizei *count, GLsizei primcount);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLELEMENTPOINTERAPPLEPROC) (GLenum type, const GLvoid *pointer);
+typedef void (APIENTRYP PFNGLDRAWELEMENTARRAYAPPLEPROC) (GLenum mode, GLint first, GLsizei count);
+typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC) (GLenum mode, GLuint start, GLuint end, GLint first, GLsizei count);
+typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC) (GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount);
+typedef void (APIENTRYP PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC) (GLenum mode, GLuint start, GLuint end, const GLint *first, const GLsizei *count, GLsizei primcount);
+#endif
+
+#ifndef GL_APPLE_fence
+#define GL_APPLE_fence 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glGenFencesAPPLE (GLsizei n, GLuint *fences);
+GLAPI void APIENTRY glDeleteFencesAPPLE (GLsizei n, const GLuint *fences);
+GLAPI void APIENTRY glSetFenceAPPLE (GLuint fence);
+GLAPI GLboolean APIENTRY glIsFenceAPPLE (GLuint fence);
+GLAPI GLboolean APIENTRY glTestFenceAPPLE (GLuint fence);
+GLAPI void APIENTRY glFinishFenceAPPLE (GLuint fence);
+GLAPI GLboolean APIENTRY glTestObjectAPPLE (GLenum object, GLuint name);
+GLAPI void APIENTRY glFinishObjectAPPLE (GLenum object, GLint name);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLGENFENCESAPPLEPROC) (GLsizei n, GLuint *fences);
+typedef void (APIENTRYP PFNGLDELETEFENCESAPPLEPROC) (GLsizei n, const GLuint *fences);
+typedef void (APIENTRYP PFNGLSETFENCEAPPLEPROC) (GLuint fence);
+typedef GLboolean (APIENTRYP PFNGLISFENCEAPPLEPROC) (GLuint fence);
+typedef GLboolean (APIENTRYP PFNGLTESTFENCEAPPLEPROC) (GLuint fence);
+typedef void (APIENTRYP PFNGLFINISHFENCEAPPLEPROC) (GLuint fence);
+typedef GLboolean (APIENTRYP PFNGLTESTOBJECTAPPLEPROC) (GLenum object, GLuint name);
+typedef void (APIENTRYP PFNGLFINISHOBJECTAPPLEPROC) (GLenum object, GLint name);
+#endif
+
+#ifndef GL_APPLE_vertex_array_object
+#define GL_APPLE_vertex_array_object 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBindVertexArrayAPPLE (GLuint array);
+GLAPI void APIENTRY glDeleteVertexArraysAPPLE (GLsizei n, const GLuint *arrays);
+GLAPI void APIENTRY glGenVertexArraysAPPLE (GLsizei n, GLuint *arrays);
+GLAPI GLboolean APIENTRY glIsVertexArrayAPPLE (GLuint array);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLBINDVERTEXARRAYAPPLEPROC) (GLuint array);
+typedef void (APIENTRYP PFNGLDELETEVERTEXARRAYSAPPLEPROC) (GLsizei n, const GLuint *arrays);
+typedef void (APIENTRYP PFNGLGENVERTEXARRAYSAPPLEPROC) (GLsizei n, GLuint *arrays);
+typedef GLboolean (APIENTRYP PFNGLISVERTEXARRAYAPPLEPROC) (GLuint array);
+#endif
+
+#ifndef GL_APPLE_vertex_array_range
+#define GL_APPLE_vertex_array_range 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glVertexArrayRangeAPPLE (GLsizei length, GLvoid *pointer);
+GLAPI void APIENTRY glFlushVertexArrayRangeAPPLE (GLsizei length, GLvoid *pointer);
+GLAPI void APIENTRY glVertexArrayParameteriAPPLE (GLenum pname, GLint param);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLVERTEXARRAYRANGEAPPLEPROC) (GLsizei length, GLvoid *pointer);
+typedef void (APIENTRYP PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC) (GLsizei length, GLvoid *pointer);
+typedef void (APIENTRYP PFNGLVERTEXARRAYPARAMETERIAPPLEPROC) (GLenum pname, GLint param);
+#endif
+
+#ifndef GL_APPLE_ycbcr_422
+#define GL_APPLE_ycbcr_422 1
+#endif
+
+#ifndef GL_S3_s3tc
+#define GL_S3_s3tc 1
+#endif
+
+#ifndef GL_ATI_draw_buffers
+#define GL_ATI_draw_buffers 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glDrawBuffersATI (GLsizei n, const GLenum *bufs);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLDRAWBUFFERSATIPROC) (GLsizei n, const GLenum *bufs);
+#endif
+
+#ifndef GL_ATI_pixel_format_float
+#define GL_ATI_pixel_format_float 1
+/* This is really a WGL extension, but defines some associated GL enums.
+ * ATI does not export "GL_ATI_pixel_format_float" in the GL_EXTENSIONS string.
+ */
+#endif
+
+#ifndef GL_ATI_texture_env_combine3
+#define GL_ATI_texture_env_combine3 1
+#endif
+
+#ifndef GL_ATI_texture_float
+#define GL_ATI_texture_float 1
+#endif
+
+#ifndef GL_NV_float_buffer
+#define GL_NV_float_buffer 1
+#endif
+
+#ifndef GL_NV_fragment_program
+#define GL_NV_fragment_program 1
+/* Some NV_fragment_program entry points are shared with ARB_vertex_program. */
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glProgramNamedParameter4fNV (GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+GLAPI void APIENTRY glProgramNamedParameter4dNV (GLuint id, GLsizei len, const GLubyte *name, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+GLAPI void APIENTRY glProgramNamedParameter4fvNV (GLuint id, GLsizei len, const GLubyte *name, const GLfloat *v);
+GLAPI void APIENTRY glProgramNamedParameter4dvNV (GLuint id, GLsizei len, const GLubyte *name, const GLdouble *v);
+GLAPI void APIENTRY glGetProgramNamedParameterfvNV (GLuint id, GLsizei len, const GLubyte *name, GLfloat *params);
+GLAPI void APIENTRY glGetProgramNamedParameterdvNV (GLuint id, GLsizei len, const GLubyte *name, GLdouble *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLPROGRAMNAMEDPARAMETER4FNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRYP PFNGLPROGRAMNAMEDPARAMETER4DNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRYP PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC) (GLuint id, GLsizei len, const GLubyte *name, const GLfloat *v);
+typedef void (APIENTRYP PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC) (GLuint id, GLsizei len, const GLubyte *name, const GLdouble *v);
+typedef void (APIENTRYP PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLdouble *params);
+#endif
+
+#ifndef GL_NV_half_float
+#define GL_NV_half_float 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glVertex2hNV (GLhalfNV x, GLhalfNV y);
+GLAPI void APIENTRY glVertex2hvNV (const GLhalfNV *v);
+GLAPI void APIENTRY glVertex3hNV (GLhalfNV x, GLhalfNV y, GLhalfNV z);
+GLAPI void APIENTRY glVertex3hvNV (const GLhalfNV *v);
+GLAPI void APIENTRY glVertex4hNV (GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w);
+GLAPI void APIENTRY glVertex4hvNV (const GLhalfNV *v);
+GLAPI void APIENTRY glNormal3hNV (GLhalfNV nx, GLhalfNV ny, GLhalfNV nz);
+GLAPI void APIENTRY glNormal3hvNV (const GLhalfNV *v);
+GLAPI void APIENTRY glColor3hNV (GLhalfNV red, GLhalfNV green, GLhalfNV blue);
+GLAPI void APIENTRY glColor3hvNV (const GLhalfNV *v);
+GLAPI void APIENTRY glColor4hNV (GLhalfNV red, GLhalfNV green, GLhalfNV blue, GLhalfNV alpha);
+GLAPI void APIENTRY glColor4hvNV (const GLhalfNV *v);
+GLAPI void APIENTRY glTexCoord1hNV (GLhalfNV s);
+GLAPI void APIENTRY glTexCoord1hvNV (const GLhalfNV *v);
+GLAPI void APIENTRY glTexCoord2hNV (GLhalfNV s, GLhalfNV t);
+GLAPI void APIENTRY glTexCoord2hvNV (const GLhalfNV *v);
+GLAPI void APIENTRY glTexCoord3hNV (GLhalfNV s, GLhalfNV t, GLhalfNV r);
+GLAPI void APIENTRY glTexCoord3hvNV (const GLhalfNV *v);
+GLAPI void APIENTRY glTexCoord4hNV (GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q);
+GLAPI void APIENTRY glTexCoord4hvNV (const GLhalfNV *v);
+GLAPI void APIENTRY glMultiTexCoord1hNV (GLenum target, GLhalfNV s);
+GLAPI void APIENTRY glMultiTexCoord1hvNV (GLenum target, const GLhalfNV *v);
+GLAPI void APIENTRY glMultiTexCoord2hNV (GLenum target, GLhalfNV s, GLhalfNV t);
+GLAPI void APIENTRY glMultiTexCoord2hvNV (GLenum target, const GLhalfNV *v);
+GLAPI void APIENTRY glMultiTexCoord3hNV (GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r);
+GLAPI void APIENTRY glMultiTexCoord3hvNV (GLenum target, const GLhalfNV *v);
+GLAPI void APIENTRY glMultiTexCoord4hNV (GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q);
+GLAPI void APIENTRY glMultiTexCoord4hvNV (GLenum target, const GLhalfNV *v);
+GLAPI void APIENTRY glFogCoordhNV (GLhalfNV fog);
+GLAPI void APIENTRY glFogCoordhvNV (const GLhalfNV *fog);
+GLAPI void APIENTRY glSecondaryColor3hNV (GLhalfNV red, GLhalfNV green, GLhalfNV blue);
+GLAPI void APIENTRY glSecondaryColor3hvNV (const GLhalfNV *v);
+GLAPI void APIENTRY glVertexWeighthNV (GLhalfNV weight);
+GLAPI void APIENTRY glVertexWeighthvNV (const GLhalfNV *weight);
+GLAPI void APIENTRY glVertexAttrib1hNV (GLuint index, GLhalfNV x);
+GLAPI void APIENTRY glVertexAttrib1hvNV (GLuint index, const GLhalfNV *v);
+GLAPI void APIENTRY glVertexAttrib2hNV (GLuint index, GLhalfNV x, GLhalfNV y);
+GLAPI void APIENTRY glVertexAttrib2hvNV (GLuint index, const GLhalfNV *v);
+GLAPI void APIENTRY glVertexAttrib3hNV (GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z);
+GLAPI void APIENTRY glVertexAttrib3hvNV (GLuint index, const GLhalfNV *v);
+GLAPI void APIENTRY glVertexAttrib4hNV (GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w);
+GLAPI void APIENTRY glVertexAttrib4hvNV (GLuint index, const GLhalfNV *v);
+GLAPI void APIENTRY glVertexAttribs1hvNV (GLuint index, GLsizei n, const GLhalfNV *v);
+GLAPI void APIENTRY glVertexAttribs2hvNV (GLuint index, GLsizei n, const GLhalfNV *v);
+GLAPI void APIENTRY glVertexAttribs3hvNV (GLuint index, GLsizei n, const GLhalfNV *v);
+GLAPI void APIENTRY glVertexAttribs4hvNV (GLuint index, GLsizei n, const GLhalfNV *v);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLVERTEX2HNVPROC) (GLhalfNV x, GLhalfNV y);
+typedef void (APIENTRYP PFNGLVERTEX2HVNVPROC) (const GLhalfNV *v);
+typedef void (APIENTRYP PFNGLVERTEX3HNVPROC) (GLhalfNV x, GLhalfNV y, GLhalfNV z);
+typedef void (APIENTRYP PFNGLVERTEX3HVNVPROC) (const GLhalfNV *v);
+typedef void (APIENTRYP PFNGLVERTEX4HNVPROC) (GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w);
+typedef void (APIENTRYP PFNGLVERTEX4HVNVPROC) (const GLhalfNV *v);
+typedef void (APIENTRYP PFNGLNORMAL3HNVPROC) (GLhalfNV nx, GLhalfNV ny, GLhalfNV nz);
+typedef void (APIENTRYP PFNGLNORMAL3HVNVPROC) (const GLhalfNV *v);
+typedef void (APIENTRYP PFNGLCOLOR3HNVPROC) (GLhalfNV red, GLhalfNV green, GLhalfNV blue);
+typedef void (APIENTRYP PFNGLCOLOR3HVNVPROC) (const GLhalfNV *v);
+typedef void (APIENTRYP PFNGLCOLOR4HNVPROC) (GLhalfNV red, GLhalfNV green, GLhalfNV blue, GLhalfNV alpha);
+typedef void (APIENTRYP PFNGLCOLOR4HVNVPROC) (const GLhalfNV *v);
+typedef void (APIENTRYP PFNGLTEXCOORD1HNVPROC) (GLhalfNV s);
+typedef void (APIENTRYP PFNGLTEXCOORD1HVNVPROC) (const GLhalfNV *v);
+typedef void (APIENTRYP PFNGLTEXCOORD2HNVPROC) (GLhalfNV s, GLhalfNV t);
+typedef void (APIENTRYP PFNGLTEXCOORD2HVNVPROC) (const GLhalfNV *v);
+typedef void (APIENTRYP PFNGLTEXCOORD3HNVPROC) (GLhalfNV s, GLhalfNV t, GLhalfNV r);
+typedef void (APIENTRYP PFNGLTEXCOORD3HVNVPROC) (const GLhalfNV *v);
+typedef void (APIENTRYP PFNGLTEXCOORD4HNVPROC) (GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q);
+typedef void (APIENTRYP PFNGLTEXCOORD4HVNVPROC) (const GLhalfNV *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD1HNVPROC) (GLenum target, GLhalfNV s);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD1HVNVPROC) (GLenum target, const GLhalfNV *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD2HNVPROC) (GLenum target, GLhalfNV s, GLhalfNV t);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD2HVNVPROC) (GLenum target, const GLhalfNV *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD3HNVPROC) (GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD3HVNVPROC) (GLenum target, const GLhalfNV *v);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD4HNVPROC) (GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q);
+typedef void (APIENTRYP PFNGLMULTITEXCOORD4HVNVPROC) (GLenum target, const GLhalfNV *v);
+typedef void (APIENTRYP PFNGLFOGCOORDHNVPROC) (GLhalfNV fog);
+typedef void (APIENTRYP PFNGLFOGCOORDHVNVPROC) (const GLhalfNV *fog);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3HNVPROC) (GLhalfNV red, GLhalfNV green, GLhalfNV blue);
+typedef void (APIENTRYP PFNGLSECONDARYCOLOR3HVNVPROC) (const GLhalfNV *v);
+typedef void (APIENTRYP PFNGLVERTEXWEIGHTHNVPROC) (GLhalfNV weight);
+typedef void (APIENTRYP PFNGLVERTEXWEIGHTHVNVPROC) (const GLhalfNV *weight);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB1HNVPROC) (GLuint index, GLhalfNV x);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB1HVNVPROC) (GLuint index, const GLhalfNV *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB2HNVPROC) (GLuint index, GLhalfNV x, GLhalfNV y);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB2HVNVPROC) (GLuint index, const GLhalfNV *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB3HNVPROC) (GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB3HVNVPROC) (GLuint index, const GLhalfNV *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4HNVPROC) (GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w);
+typedef void (APIENTRYP PFNGLVERTEXATTRIB4HVNVPROC) (GLuint index, const GLhalfNV *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBS1HVNVPROC) (GLuint index, GLsizei n, const GLhalfNV *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBS2HVNVPROC) (GLuint index, GLsizei n, const GLhalfNV *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBS3HVNVPROC) (GLuint index, GLsizei n, const GLhalfNV *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBS4HVNVPROC) (GLuint index, GLsizei n, const GLhalfNV *v);
+#endif
+
+#ifndef GL_NV_pixel_data_range
+#define GL_NV_pixel_data_range 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glPixelDataRangeNV (GLenum target, GLsizei length, GLvoid *pointer);
+GLAPI void APIENTRY glFlushPixelDataRangeNV (GLenum target);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLPIXELDATARANGENVPROC) (GLenum target, GLsizei length, GLvoid *pointer);
+typedef void (APIENTRYP PFNGLFLUSHPIXELDATARANGENVPROC) (GLenum target);
+#endif
+
+#ifndef GL_NV_primitive_restart
+#define GL_NV_primitive_restart 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glPrimitiveRestartNV (void);
+GLAPI void APIENTRY glPrimitiveRestartIndexNV (GLuint index);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLPRIMITIVERESTARTNVPROC) (void);
+typedef void (APIENTRYP PFNGLPRIMITIVERESTARTINDEXNVPROC) (GLuint index);
+#endif
+
+#ifndef GL_NV_texture_expand_normal
+#define GL_NV_texture_expand_normal 1
+#endif
+
+#ifndef GL_NV_vertex_program2
+#define GL_NV_vertex_program2 1
+#endif
+
+#ifndef GL_ATI_map_object_buffer
+#define GL_ATI_map_object_buffer 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI GLvoid* APIENTRY glMapObjectBufferATI (GLuint buffer);
+GLAPI void APIENTRY glUnmapObjectBufferATI (GLuint buffer);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef GLvoid* (APIENTRYP PFNGLMAPOBJECTBUFFERATIPROC) (GLuint buffer);
+typedef void (APIENTRYP PFNGLUNMAPOBJECTBUFFERATIPROC) (GLuint buffer);
+#endif
+
+#ifndef GL_ATI_separate_stencil
+#define GL_ATI_separate_stencil 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glStencilOpSeparateATI (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
+GLAPI void APIENTRY glStencilFuncSeparateATI (GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLSTENCILOPSEPARATEATIPROC) (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
+typedef void (APIENTRYP PFNGLSTENCILFUNCSEPARATEATIPROC) (GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask);
+#endif
+
+#ifndef GL_ATI_vertex_attrib_array_object
+#define GL_ATI_vertex_attrib_array_object 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glVertexAttribArrayObjectATI (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint buffer, GLuint offset);
+GLAPI void APIENTRY glGetVertexAttribArrayObjectfvATI (GLuint index, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetVertexAttribArrayObjectivATI (GLuint index, GLenum pname, GLint *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLVERTEXATTRIBARRAYOBJECTATIPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint buffer, GLuint offset);
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC) (GLuint index, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC) (GLuint index, GLenum pname, GLint *params);
+#endif
+
+#ifndef GL_OES_read_format
+#define GL_OES_read_format 1
+#endif
+
+#ifndef GL_EXT_depth_bounds_test
+#define GL_EXT_depth_bounds_test 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glDepthBoundsEXT (GLclampd zmin, GLclampd zmax);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLDEPTHBOUNDSEXTPROC) (GLclampd zmin, GLclampd zmax);
+#endif
+
+#ifndef GL_EXT_texture_mirror_clamp
+#define GL_EXT_texture_mirror_clamp 1
+#endif
+
+#ifndef GL_EXT_blend_equation_separate
+#define GL_EXT_blend_equation_separate 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBlendEquationSeparateEXT (GLenum modeRGB, GLenum modeAlpha);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEEXTPROC) (GLenum modeRGB, GLenum modeAlpha);
+#endif
+
+#ifndef GL_MESA_pack_invert
+#define GL_MESA_pack_invert 1
+#endif
+
+#ifndef GL_MESA_ycbcr_texture
+#define GL_MESA_ycbcr_texture 1
+#endif
+
+#ifndef GL_EXT_pixel_buffer_object
+#define GL_EXT_pixel_buffer_object 1
+#endif
+
+#ifndef GL_NV_fragment_program_option
+#define GL_NV_fragment_program_option 1
+#endif
+
+#ifndef GL_NV_fragment_program2
+#define GL_NV_fragment_program2 1
+#endif
+
+#ifndef GL_NV_vertex_program2_option
+#define GL_NV_vertex_program2_option 1
+#endif
+
+#ifndef GL_NV_vertex_program3
+#define GL_NV_vertex_program3 1
+#endif
+
+#ifndef GL_EXT_framebuffer_object
+#define GL_EXT_framebuffer_object 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI GLboolean APIENTRY glIsRenderbufferEXT (GLuint renderbuffer);
+GLAPI void APIENTRY glBindRenderbufferEXT (GLenum target, GLuint renderbuffer);
+GLAPI void APIENTRY glDeleteRenderbuffersEXT (GLsizei n, const GLuint *renderbuffers);
+GLAPI void APIENTRY glGenRenderbuffersEXT (GLsizei n, GLuint *renderbuffers);
+GLAPI void APIENTRY glRenderbufferStorageEXT (GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
+GLAPI void APIENTRY glGetRenderbufferParameterivEXT (GLenum target, GLenum pname, GLint *params);
+GLAPI GLboolean APIENTRY glIsFramebufferEXT (GLuint framebuffer);
+GLAPI void APIENTRY glBindFramebufferEXT (GLenum target, GLuint framebuffer);
+GLAPI void APIENTRY glDeleteFramebuffersEXT (GLsizei n, const GLuint *framebuffers);
+GLAPI void APIENTRY glGenFramebuffersEXT (GLsizei n, GLuint *framebuffers);
+GLAPI GLenum APIENTRY glCheckFramebufferStatusEXT (GLenum target);
+GLAPI void APIENTRY glFramebufferTexture1DEXT (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+GLAPI void APIENTRY glFramebufferTexture2DEXT (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+GLAPI void APIENTRY glFramebufferTexture3DEXT (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
+GLAPI void APIENTRY glFramebufferRenderbufferEXT (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
+GLAPI void APIENTRY glGetFramebufferAttachmentParameterivEXT (GLenum target, GLenum attachment, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGenerateMipmapEXT (GLenum target);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef GLboolean (APIENTRYP PFNGLISRENDERBUFFEREXTPROC) (GLuint renderbuffer);
+typedef void (APIENTRYP PFNGLBINDRENDERBUFFEREXTPROC) (GLenum target, GLuint renderbuffer);
+typedef void (APIENTRYP PFNGLDELETERENDERBUFFERSEXTPROC) (GLsizei n, const GLuint *renderbuffers);
+typedef void (APIENTRYP PFNGLGENRENDERBUFFERSEXTPROC) (GLsizei n, GLuint *renderbuffers);
+typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
+typedef void (APIENTRYP PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint *params);
+typedef GLboolean (APIENTRYP PFNGLISFRAMEBUFFEREXTPROC) (GLuint framebuffer);
+typedef void (APIENTRYP PFNGLBINDFRAMEBUFFEREXTPROC) (GLenum target, GLuint framebuffer);
+typedef void (APIENTRYP PFNGLDELETEFRAMEBUFFERSEXTPROC) (GLsizei n, const GLuint *framebuffers);
+typedef void (APIENTRYP PFNGLGENFRAMEBUFFERSEXTPROC) (GLsizei n, GLuint *framebuffers);
+typedef GLenum (APIENTRYP PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC) (GLenum target);
+typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE1DEXTPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE2DEXTPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE3DEXTPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
+typedef void (APIENTRYP PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC) (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
+typedef void (APIENTRYP PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC) (GLenum target, GLenum attachment, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGENERATEMIPMAPEXTPROC) (GLenum target);
+#endif
+
+#ifndef GL_GREMEDY_string_marker
+#define GL_GREMEDY_string_marker 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glStringMarkerGREMEDY (GLsizei len, const GLvoid *string);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLSTRINGMARKERGREMEDYPROC) (GLsizei len, const GLvoid *string);
+#endif
+
+#ifndef GL_EXT_packed_depth_stencil
+#define GL_EXT_packed_depth_stencil 1
+#endif
+
+#ifndef GL_EXT_stencil_clear_tag
+#define GL_EXT_stencil_clear_tag 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glStencilClearTagEXT (GLsizei stencilTagBits, GLuint stencilClearTag);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLSTENCILCLEARTAGEXTPROC) (GLsizei stencilTagBits, GLuint stencilClearTag);
+#endif
+
+#ifndef GL_EXT_texture_sRGB
+#define GL_EXT_texture_sRGB 1
+#endif
+
+#ifndef GL_EXT_framebuffer_blit
+#define GL_EXT_framebuffer_blit 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBlitFramebufferEXT (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLBLITFRAMEBUFFEREXTPROC) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+#endif
+
+#ifndef GL_EXT_framebuffer_multisample
+#define GL_EXT_framebuffer_multisample 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glRenderbufferStorageMultisampleEXT (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+#endif
+
+#ifndef GL_MESAX_texture_stack
+#define GL_MESAX_texture_stack 1
+#endif
+
+#ifndef GL_EXT_timer_query
+#define GL_EXT_timer_query 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glGetQueryObjecti64vEXT (GLuint id, GLenum pname, GLint64EXT *params);
+GLAPI void APIENTRY glGetQueryObjectui64vEXT (GLuint id, GLenum pname, GLuint64EXT *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLGETQUERYOBJECTI64VEXTPROC) (GLuint id, GLenum pname, GLint64EXT *params);
+typedef void (APIENTRYP PFNGLGETQUERYOBJECTUI64VEXTPROC) (GLuint id, GLenum pname, GLuint64EXT *params);
+#endif
+
+#ifndef GL_EXT_gpu_program_parameters
+#define GL_EXT_gpu_program_parameters 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glProgramEnvParameters4fvEXT (GLenum target, GLuint index, GLsizei count, const GLfloat *params);
+GLAPI void APIENTRY glProgramLocalParameters4fvEXT (GLenum target, GLuint index, GLsizei count, const GLfloat *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLPROGRAMENVPARAMETERS4FVEXTPROC) (GLenum target, GLuint index, GLsizei count, const GLfloat *params);
+typedef void (APIENTRYP PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC) (GLenum target, GLuint index, GLsizei count, const GLfloat *params);
+#endif
+
+#ifndef GL_APPLE_flush_buffer_range
+#define GL_APPLE_flush_buffer_range 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBufferParameteriAPPLE (GLenum target, GLenum pname, GLint param);
+GLAPI void APIENTRY glFlushMappedBufferRangeAPPLE (GLenum target, GLintptr offset, GLsizeiptr size);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLBUFFERPARAMETERIAPPLEPROC) (GLenum target, GLenum pname, GLint param);
+typedef void (APIENTRYP PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC) (GLenum target, GLintptr offset, GLsizeiptr size);
+#endif
+
+#ifndef GL_NV_gpu_program4
+#define GL_NV_gpu_program4 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glProgramLocalParameterI4iNV (GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w);
+GLAPI void APIENTRY glProgramLocalParameterI4ivNV (GLenum target, GLuint index, const GLint *params);
+GLAPI void APIENTRY glProgramLocalParametersI4ivNV (GLenum target, GLuint index, GLsizei count, const GLint *params);
+GLAPI void APIENTRY glProgramLocalParameterI4uiNV (GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
+GLAPI void APIENTRY glProgramLocalParameterI4uivNV (GLenum target, GLuint index, const GLuint *params);
+GLAPI void APIENTRY glProgramLocalParametersI4uivNV (GLenum target, GLuint index, GLsizei count, const GLuint *params);
+GLAPI void APIENTRY glProgramEnvParameterI4iNV (GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w);
+GLAPI void APIENTRY glProgramEnvParameterI4ivNV (GLenum target, GLuint index, const GLint *params);
+GLAPI void APIENTRY glProgramEnvParametersI4ivNV (GLenum target, GLuint index, GLsizei count, const GLint *params);
+GLAPI void APIENTRY glProgramEnvParameterI4uiNV (GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
+GLAPI void APIENTRY glProgramEnvParameterI4uivNV (GLenum target, GLuint index, const GLuint *params);
+GLAPI void APIENTRY glProgramEnvParametersI4uivNV (GLenum target, GLuint index, GLsizei count, const GLuint *params);
+GLAPI void APIENTRY glGetProgramLocalParameterIivNV (GLenum target, GLuint index, GLint *params);
+GLAPI void APIENTRY glGetProgramLocalParameterIuivNV (GLenum target, GLuint index, GLuint *params);
+GLAPI void APIENTRY glGetProgramEnvParameterIivNV (GLenum target, GLuint index, GLint *params);
+GLAPI void APIENTRY glGetProgramEnvParameterIuivNV (GLenum target, GLuint index, GLuint *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLPROGRAMLOCALPARAMETERI4INVPROC) (GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w);
+typedef void (APIENTRYP PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC) (GLenum target, GLuint index, const GLint *params);
+typedef void (APIENTRYP PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC) (GLenum target, GLuint index, GLsizei count, const GLint *params);
+typedef void (APIENTRYP PFNGLPROGRAMLOCALPARAMETERI4UINVPROC) (GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
+typedef void (APIENTRYP PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC) (GLenum target, GLuint index, const GLuint *params);
+typedef void (APIENTRYP PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC) (GLenum target, GLuint index, GLsizei count, const GLuint *params);
+typedef void (APIENTRYP PFNGLPROGRAMENVPARAMETERI4INVPROC) (GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w);
+typedef void (APIENTRYP PFNGLPROGRAMENVPARAMETERI4IVNVPROC) (GLenum target, GLuint index, const GLint *params);
+typedef void (APIENTRYP PFNGLPROGRAMENVPARAMETERSI4IVNVPROC) (GLenum target, GLuint index, GLsizei count, const GLint *params);
+typedef void (APIENTRYP PFNGLPROGRAMENVPARAMETERI4UINVPROC) (GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
+typedef void (APIENTRYP PFNGLPROGRAMENVPARAMETERI4UIVNVPROC) (GLenum target, GLuint index, const GLuint *params);
+typedef void (APIENTRYP PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC) (GLenum target, GLuint index, GLsizei count, const GLuint *params);
+typedef void (APIENTRYP PFNGLGETPROGRAMLOCALPARAMETERIIVNVPROC) (GLenum target, GLuint index, GLint *params);
+typedef void (APIENTRYP PFNGLGETPROGRAMLOCALPARAMETERIUIVNVPROC) (GLenum target, GLuint index, GLuint *params);
+typedef void (APIENTRYP PFNGLGETPROGRAMENVPARAMETERIIVNVPROC) (GLenum target, GLuint index, GLint *params);
+typedef void (APIENTRYP PFNGLGETPROGRAMENVPARAMETERIUIVNVPROC) (GLenum target, GLuint index, GLuint *params);
+#endif
+
+#ifndef GL_NV_geometry_program4
+#define GL_NV_geometry_program4 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glProgramVertexLimitNV (GLenum target, GLint limit);
+GLAPI void APIENTRY glFramebufferTextureEXT (GLenum target, GLenum attachment, GLuint texture, GLint level);
+GLAPI void APIENTRY glFramebufferTextureLayerEXT (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
+GLAPI void APIENTRY glFramebufferTextureFaceEXT (GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLPROGRAMVERTEXLIMITNVPROC) (GLenum target, GLint limit);
+typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTUREEXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level);
+typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
+typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face);
+#endif
+
+#ifndef GL_EXT_geometry_shader4
+#define GL_EXT_geometry_shader4 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glProgramParameteriEXT (GLuint program, GLenum pname, GLint value);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLPROGRAMPARAMETERIEXTPROC) (GLuint program, GLenum pname, GLint value);
+#endif
+
+#ifndef GL_NV_vertex_program4
+#define GL_NV_vertex_program4 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glVertexAttribI1iEXT (GLuint index, GLint x);
+GLAPI void APIENTRY glVertexAttribI2iEXT (GLuint index, GLint x, GLint y);
+GLAPI void APIENTRY glVertexAttribI3iEXT (GLuint index, GLint x, GLint y, GLint z);
+GLAPI void APIENTRY glVertexAttribI4iEXT (GLuint index, GLint x, GLint y, GLint z, GLint w);
+GLAPI void APIENTRY glVertexAttribI1uiEXT (GLuint index, GLuint x);
+GLAPI void APIENTRY glVertexAttribI2uiEXT (GLuint index, GLuint x, GLuint y);
+GLAPI void APIENTRY glVertexAttribI3uiEXT (GLuint index, GLuint x, GLuint y, GLuint z);
+GLAPI void APIENTRY glVertexAttribI4uiEXT (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
+GLAPI void APIENTRY glVertexAttribI1ivEXT (GLuint index, const GLint *v);
+GLAPI void APIENTRY glVertexAttribI2ivEXT (GLuint index, const GLint *v);
+GLAPI void APIENTRY glVertexAttribI3ivEXT (GLuint index, const GLint *v);
+GLAPI void APIENTRY glVertexAttribI4ivEXT (GLuint index, const GLint *v);
+GLAPI void APIENTRY glVertexAttribI1uivEXT (GLuint index, const GLuint *v);
+GLAPI void APIENTRY glVertexAttribI2uivEXT (GLuint index, const GLuint *v);
+GLAPI void APIENTRY glVertexAttribI3uivEXT (GLuint index, const GLuint *v);
+GLAPI void APIENTRY glVertexAttribI4uivEXT (GLuint index, const GLuint *v);
+GLAPI void APIENTRY glVertexAttribI4bvEXT (GLuint index, const GLbyte *v);
+GLAPI void APIENTRY glVertexAttribI4svEXT (GLuint index, const GLshort *v);
+GLAPI void APIENTRY glVertexAttribI4ubvEXT (GLuint index, const GLubyte *v);
+GLAPI void APIENTRY glVertexAttribI4usvEXT (GLuint index, const GLushort *v);
+GLAPI void APIENTRY glVertexAttribIPointerEXT (GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+GLAPI void APIENTRY glGetVertexAttribIivEXT (GLuint index, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetVertexAttribIuivEXT (GLuint index, GLenum pname, GLuint *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IEXTPROC) (GLuint index, GLint x);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IEXTPROC) (GLuint index, GLint x, GLint y);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IEXTPROC) (GLuint index, GLint x, GLint y, GLint z);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IEXTPROC) (GLuint index, GLint x, GLint y, GLint z, GLint w);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIEXTPROC) (GLuint index, GLuint x);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIEXTPROC) (GLuint index, GLuint x, GLuint y);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIEXTPROC) (GLuint index, GLuint x, GLuint y, GLuint z);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIEXTPROC) (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IVEXTPROC) (GLuint index, const GLint *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IVEXTPROC) (GLuint index, const GLint *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IVEXTPROC) (GLuint index, const GLint *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IVEXTPROC) (GLuint index, const GLint *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIVEXTPROC) (GLuint index, const GLuint *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIVEXTPROC) (GLuint index, const GLuint *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIVEXTPROC) (GLuint index, const GLuint *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIVEXTPROC) (GLuint index, const GLuint *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI4BVEXTPROC) (GLuint index, const GLbyte *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI4SVEXTPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UBVEXTPROC) (GLuint index, const GLubyte *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBI4USVEXTPROC) (GLuint index, const GLushort *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBIPOINTEREXTPROC) (GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIIVEXTPROC) (GLuint index, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIUIVEXTPROC) (GLuint index, GLenum pname, GLuint *params);
+#endif
+
+#ifndef GL_EXT_gpu_shader4
+#define GL_EXT_gpu_shader4 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glGetUniformuivEXT (GLuint program, GLint location, GLuint *params);
+GLAPI void APIENTRY glBindFragDataLocationEXT (GLuint program, GLuint color, const GLchar *name);
+GLAPI GLint APIENTRY glGetFragDataLocationEXT (GLuint program, const GLchar *name);
+GLAPI void APIENTRY glUniform1uiEXT (GLint location, GLuint v0);
+GLAPI void APIENTRY glUniform2uiEXT (GLint location, GLuint v0, GLuint v1);
+GLAPI void APIENTRY glUniform3uiEXT (GLint location, GLuint v0, GLuint v1, GLuint v2);
+GLAPI void APIENTRY glUniform4uiEXT (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
+GLAPI void APIENTRY glUniform1uivEXT (GLint location, GLsizei count, const GLuint *value);
+GLAPI void APIENTRY glUniform2uivEXT (GLint location, GLsizei count, const GLuint *value);
+GLAPI void APIENTRY glUniform3uivEXT (GLint location, GLsizei count, const GLuint *value);
+GLAPI void APIENTRY glUniform4uivEXT (GLint location, GLsizei count, const GLuint *value);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLGETUNIFORMUIVEXTPROC) (GLuint program, GLint location, GLuint *params);
+typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONEXTPROC) (GLuint program, GLuint color, const GLchar *name);
+typedef GLint (APIENTRYP PFNGLGETFRAGDATALOCATIONEXTPROC) (GLuint program, const GLchar *name);
+typedef void (APIENTRYP PFNGLUNIFORM1UIEXTPROC) (GLint location, GLuint v0);
+typedef void (APIENTRYP PFNGLUNIFORM2UIEXTPROC) (GLint location, GLuint v0, GLuint v1);
+typedef void (APIENTRYP PFNGLUNIFORM3UIEXTPROC) (GLint location, GLuint v0, GLuint v1, GLuint v2);
+typedef void (APIENTRYP PFNGLUNIFORM4UIEXTPROC) (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
+typedef void (APIENTRYP PFNGLUNIFORM1UIVEXTPROC) (GLint location, GLsizei count, const GLuint *value);
+typedef void (APIENTRYP PFNGLUNIFORM2UIVEXTPROC) (GLint location, GLsizei count, const GLuint *value);
+typedef void (APIENTRYP PFNGLUNIFORM3UIVEXTPROC) (GLint location, GLsizei count, const GLuint *value);
+typedef void (APIENTRYP PFNGLUNIFORM4UIVEXTPROC) (GLint location, GLsizei count, const GLuint *value);
+#endif
+
+#ifndef GL_EXT_draw_instanced
+#define GL_EXT_draw_instanced 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glDrawArraysInstancedEXT (GLenum mode, GLint start, GLsizei count, GLsizei primcount);
+GLAPI void APIENTRY glDrawElementsInstancedEXT (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLDRAWARRAYSINSTANCEDEXTPROC) (GLenum mode, GLint start, GLsizei count, GLsizei primcount);
+typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDEXTPROC) (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount);
+#endif
+
+#ifndef GL_EXT_packed_float
+#define GL_EXT_packed_float 1
+#endif
+
+#ifndef GL_EXT_texture_array
+#define GL_EXT_texture_array 1
+#endif
+
+#ifndef GL_EXT_texture_buffer_object
+#define GL_EXT_texture_buffer_object 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glTexBufferEXT (GLenum target, GLenum internalformat, GLuint buffer);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLTEXBUFFEREXTPROC) (GLenum target, GLenum internalformat, GLuint buffer);
+#endif
+
+#ifndef GL_EXT_texture_compression_latc
+#define GL_EXT_texture_compression_latc 1
+#endif
+
+#ifndef GL_EXT_texture_compression_rgtc
+#define GL_EXT_texture_compression_rgtc 1
+#endif
+
+#ifndef GL_EXT_texture_shared_exponent
+#define GL_EXT_texture_shared_exponent 1
+#endif
+
+#ifndef GL_NV_depth_buffer_float
+#define GL_NV_depth_buffer_float 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glDepthRangedNV (GLdouble zNear, GLdouble zFar);
+GLAPI void APIENTRY glClearDepthdNV (GLdouble depth);
+GLAPI void APIENTRY glDepthBoundsdNV (GLdouble zmin, GLdouble zmax);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLDEPTHRANGEDNVPROC) (GLdouble zNear, GLdouble zFar);
+typedef void (APIENTRYP PFNGLCLEARDEPTHDNVPROC) (GLdouble depth);
+typedef void (APIENTRYP PFNGLDEPTHBOUNDSDNVPROC) (GLdouble zmin, GLdouble zmax);
+#endif
+
+#ifndef GL_NV_fragment_program4
+#define GL_NV_fragment_program4 1
+#endif
+
+#ifndef GL_NV_framebuffer_multisample_coverage
+#define GL_NV_framebuffer_multisample_coverage 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glRenderbufferStorageMultisampleCoverageNV (GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC) (GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height);
+#endif
+
+#ifndef GL_EXT_framebuffer_sRGB
+#define GL_EXT_framebuffer_sRGB 1
+#endif
+
+#ifndef GL_NV_geometry_shader4
+#define GL_NV_geometry_shader4 1
+#endif
+
+#ifndef GL_NV_parameter_buffer_object
+#define GL_NV_parameter_buffer_object 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glProgramBufferParametersfvNV (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLfloat *params);
+GLAPI void APIENTRY glProgramBufferParametersIivNV (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLint *params);
+GLAPI void APIENTRY glProgramBufferParametersIuivNV (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLuint *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC) (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLfloat *params);
+typedef void (APIENTRYP PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC) (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLint *params);
+typedef void (APIENTRYP PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC) (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLuint *params);
+#endif
+
+#ifndef GL_EXT_draw_buffers2
+#define GL_EXT_draw_buffers2 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glColorMaskIndexedEXT (GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
+GLAPI void APIENTRY glGetBooleanIndexedvEXT (GLenum target, GLuint index, GLboolean *data);
+GLAPI void APIENTRY glGetIntegerIndexedvEXT (GLenum target, GLuint index, GLint *data);
+GLAPI void APIENTRY glEnableIndexedEXT (GLenum target, GLuint index);
+GLAPI void APIENTRY glDisableIndexedEXT (GLenum target, GLuint index);
+GLAPI GLboolean APIENTRY glIsEnabledIndexedEXT (GLenum target, GLuint index);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLCOLORMASKINDEXEDEXTPROC) (GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
+typedef void (APIENTRYP PFNGLGETBOOLEANINDEXEDVEXTPROC) (GLenum target, GLuint index, GLboolean *data);
+typedef void (APIENTRYP PFNGLGETINTEGERINDEXEDVEXTPROC) (GLenum target, GLuint index, GLint *data);
+typedef void (APIENTRYP PFNGLENABLEINDEXEDEXTPROC) (GLenum target, GLuint index);
+typedef void (APIENTRYP PFNGLDISABLEINDEXEDEXTPROC) (GLenum target, GLuint index);
+typedef GLboolean (APIENTRYP PFNGLISENABLEDINDEXEDEXTPROC) (GLenum target, GLuint index);
+#endif
+
+#ifndef GL_NV_transform_feedback
+#define GL_NV_transform_feedback 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBeginTransformFeedbackNV (GLenum primitiveMode);
+GLAPI void APIENTRY glEndTransformFeedbackNV (void);
+GLAPI void APIENTRY glTransformFeedbackAttribsNV (GLuint count, const GLint *attribs, GLenum bufferMode);
+GLAPI void APIENTRY glBindBufferRangeNV (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
+GLAPI void APIENTRY glBindBufferOffsetNV (GLenum target, GLuint index, GLuint buffer, GLintptr offset);
+GLAPI void APIENTRY glBindBufferBaseNV (GLenum target, GLuint index, GLuint buffer);
+GLAPI void APIENTRY glTransformFeedbackVaryingsNV (GLuint program, GLsizei count, const GLint *locations, GLenum bufferMode);
+GLAPI void APIENTRY glActiveVaryingNV (GLuint program, const GLchar *name);
+GLAPI GLint APIENTRY glGetVaryingLocationNV (GLuint program, const GLchar *name);
+GLAPI void APIENTRY glGetActiveVaryingNV (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
+GLAPI void APIENTRY glGetTransformFeedbackVaryingNV (GLuint program, GLuint index, GLint *location);
+GLAPI void APIENTRY glTransformFeedbackStreamAttribsNV (GLsizei count, const GLint *attribs, GLsizei nbuffers, const GLint *bufstreams, GLenum bufferMode);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLBEGINTRANSFORMFEEDBACKNVPROC) (GLenum primitiveMode);
+typedef void (APIENTRYP PFNGLENDTRANSFORMFEEDBACKNVPROC) (void);
+typedef void (APIENTRYP PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC) (GLuint count, const GLint *attribs, GLenum bufferMode);
+typedef void (APIENTRYP PFNGLBINDBUFFERRANGENVPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
+typedef void (APIENTRYP PFNGLBINDBUFFEROFFSETNVPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset);
+typedef void (APIENTRYP PFNGLBINDBUFFERBASENVPROC) (GLenum target, GLuint index, GLuint buffer);
+typedef void (APIENTRYP PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC) (GLuint program, GLsizei count, const GLint *locations, GLenum bufferMode);
+typedef void (APIENTRYP PFNGLACTIVEVARYINGNVPROC) (GLuint program, const GLchar *name);
+typedef GLint (APIENTRYP PFNGLGETVARYINGLOCATIONNVPROC) (GLuint program, const GLchar *name);
+typedef void (APIENTRYP PFNGLGETACTIVEVARYINGNVPROC) (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
+typedef void (APIENTRYP PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC) (GLuint program, GLuint index, GLint *location);
+typedef void (APIENTRYP PFNGLTRANSFORMFEEDBACKSTREAMATTRIBSNVPROC) (GLsizei count, const GLint *attribs, GLsizei nbuffers, const GLint *bufstreams, GLenum bufferMode);
+#endif
+
+#ifndef GL_EXT_bindable_uniform
+#define GL_EXT_bindable_uniform 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glUniformBufferEXT (GLuint program, GLint location, GLuint buffer);
+GLAPI GLint APIENTRY glGetUniformBufferSizeEXT (GLuint program, GLint location);
+GLAPI GLintptr APIENTRY glGetUniformOffsetEXT (GLuint program, GLint location);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLUNIFORMBUFFEREXTPROC) (GLuint program, GLint location, GLuint buffer);
+typedef GLint (APIENTRYP PFNGLGETUNIFORMBUFFERSIZEEXTPROC) (GLuint program, GLint location);
+typedef GLintptr (APIENTRYP PFNGLGETUNIFORMOFFSETEXTPROC) (GLuint program, GLint location);
+#endif
+
+#ifndef GL_EXT_texture_integer
+#define GL_EXT_texture_integer 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glTexParameterIivEXT (GLenum target, GLenum pname, const GLint *params);
+GLAPI void APIENTRY glTexParameterIuivEXT (GLenum target, GLenum pname, const GLuint *params);
+GLAPI void APIENTRY glGetTexParameterIivEXT (GLenum target, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetTexParameterIuivEXT (GLenum target, GLenum pname, GLuint *params);
+GLAPI void APIENTRY glClearColorIiEXT (GLint red, GLint green, GLint blue, GLint alpha);
+GLAPI void APIENTRY glClearColorIuiEXT (GLuint red, GLuint green, GLuint blue, GLuint alpha);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLTEXPARAMETERIIVEXTPROC) (GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRYP PFNGLTEXPARAMETERIUIVEXTPROC) (GLenum target, GLenum pname, const GLuint *params);
+typedef void (APIENTRYP PFNGLGETTEXPARAMETERIIVEXTPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETTEXPARAMETERIUIVEXTPROC) (GLenum target, GLenum pname, GLuint *params);
+typedef void (APIENTRYP PFNGLCLEARCOLORIIEXTPROC) (GLint red, GLint green, GLint blue, GLint alpha);
+typedef void (APIENTRYP PFNGLCLEARCOLORIUIEXTPROC) (GLuint red, GLuint green, GLuint blue, GLuint alpha);
+#endif
+
+#ifndef GL_GREMEDY_frame_terminator
+#define GL_GREMEDY_frame_terminator 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glFrameTerminatorGREMEDY (void);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLFRAMETERMINATORGREMEDYPROC) (void);
+#endif
+
+#ifndef GL_NV_conditional_render
+#define GL_NV_conditional_render 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBeginConditionalRenderNV (GLuint id, GLenum mode);
+GLAPI void APIENTRY glEndConditionalRenderNV (void);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLBEGINCONDITIONALRENDERNVPROC) (GLuint id, GLenum mode);
+typedef void (APIENTRYP PFNGLENDCONDITIONALRENDERNVPROC) (void);
+#endif
+
+#ifndef GL_NV_present_video
+#define GL_NV_present_video 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glPresentFrameKeyedNV (GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLuint key0, GLenum target1, GLuint fill1, GLuint key1);
+GLAPI void APIENTRY glPresentFrameDualFillNV (GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLenum target1, GLuint fill1, GLenum target2, GLuint fill2, GLenum target3, GLuint fill3);
+GLAPI void APIENTRY glGetVideoivNV (GLuint video_slot, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetVideouivNV (GLuint video_slot, GLenum pname, GLuint *params);
+GLAPI void APIENTRY glGetVideoi64vNV (GLuint video_slot, GLenum pname, GLint64EXT *params);
+GLAPI void APIENTRY glGetVideoui64vNV (GLuint video_slot, GLenum pname, GLuint64EXT *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLPRESENTFRAMEKEYEDNVPROC) (GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLuint key0, GLenum target1, GLuint fill1, GLuint key1);
+typedef void (APIENTRYP PFNGLPRESENTFRAMEDUALFILLNVPROC) (GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLenum target1, GLuint fill1, GLenum target2, GLuint fill2, GLenum target3, GLuint fill3);
+typedef void (APIENTRYP PFNGLGETVIDEOIVNVPROC) (GLuint video_slot, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETVIDEOUIVNVPROC) (GLuint video_slot, GLenum pname, GLuint *params);
+typedef void (APIENTRYP PFNGLGETVIDEOI64VNVPROC) (GLuint video_slot, GLenum pname, GLint64EXT *params);
+typedef void (APIENTRYP PFNGLGETVIDEOUI64VNVPROC) (GLuint video_slot, GLenum pname, GLuint64EXT *params);
+#endif
+
+#ifndef GL_EXT_transform_feedback
+#define GL_EXT_transform_feedback 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBeginTransformFeedbackEXT (GLenum primitiveMode);
+GLAPI void APIENTRY glEndTransformFeedbackEXT (void);
+GLAPI void APIENTRY glBindBufferRangeEXT (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
+GLAPI void APIENTRY glBindBufferOffsetEXT (GLenum target, GLuint index, GLuint buffer, GLintptr offset);
+GLAPI void APIENTRY glBindBufferBaseEXT (GLenum target, GLuint index, GLuint buffer);
+GLAPI void APIENTRY glTransformFeedbackVaryingsEXT (GLuint program, GLsizei count, const GLchar* *varyings, GLenum bufferMode);
+GLAPI void APIENTRY glGetTransformFeedbackVaryingEXT (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLBEGINTRANSFORMFEEDBACKEXTPROC) (GLenum primitiveMode);
+typedef void (APIENTRYP PFNGLENDTRANSFORMFEEDBACKEXTPROC) (void);
+typedef void (APIENTRYP PFNGLBINDBUFFERRANGEEXTPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
+typedef void (APIENTRYP PFNGLBINDBUFFEROFFSETEXTPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset);
+typedef void (APIENTRYP PFNGLBINDBUFFERBASEEXTPROC) (GLenum target, GLuint index, GLuint buffer);
+typedef void (APIENTRYP PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC) (GLuint program, GLsizei count, const GLchar* *varyings, GLenum bufferMode);
+typedef void (APIENTRYP PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC) (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
+#endif
+
+#ifndef GL_EXT_direct_state_access
+#define GL_EXT_direct_state_access 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glClientAttribDefaultEXT (GLbitfield mask);
+GLAPI void APIENTRY glPushClientAttribDefaultEXT (GLbitfield mask);
+GLAPI void APIENTRY glMatrixLoadfEXT (GLenum mode, const GLfloat *m);
+GLAPI void APIENTRY glMatrixLoaddEXT (GLenum mode, const GLdouble *m);
+GLAPI void APIENTRY glMatrixMultfEXT (GLenum mode, const GLfloat *m);
+GLAPI void APIENTRY glMatrixMultdEXT (GLenum mode, const GLdouble *m);
+GLAPI void APIENTRY glMatrixLoadIdentityEXT (GLenum mode);
+GLAPI void APIENTRY glMatrixRotatefEXT (GLenum mode, GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
+GLAPI void APIENTRY glMatrixRotatedEXT (GLenum mode, GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
+GLAPI void APIENTRY glMatrixScalefEXT (GLenum mode, GLfloat x, GLfloat y, GLfloat z);
+GLAPI void APIENTRY glMatrixScaledEXT (GLenum mode, GLdouble x, GLdouble y, GLdouble z);
+GLAPI void APIENTRY glMatrixTranslatefEXT (GLenum mode, GLfloat x, GLfloat y, GLfloat z);
+GLAPI void APIENTRY glMatrixTranslatedEXT (GLenum mode, GLdouble x, GLdouble y, GLdouble z);
+GLAPI void APIENTRY glMatrixFrustumEXT (GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+GLAPI void APIENTRY glMatrixOrthoEXT (GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+GLAPI void APIENTRY glMatrixPopEXT (GLenum mode);
+GLAPI void APIENTRY glMatrixPushEXT (GLenum mode);
+GLAPI void APIENTRY glMatrixLoadTransposefEXT (GLenum mode, const GLfloat *m);
+GLAPI void APIENTRY glMatrixLoadTransposedEXT (GLenum mode, const GLdouble *m);
+GLAPI void APIENTRY glMatrixMultTransposefEXT (GLenum mode, const GLfloat *m);
+GLAPI void APIENTRY glMatrixMultTransposedEXT (GLenum mode, const GLdouble *m);
+GLAPI void APIENTRY glTextureParameterfEXT (GLuint texture, GLenum target, GLenum pname, GLfloat param);
+GLAPI void APIENTRY glTextureParameterfvEXT (GLuint texture, GLenum target, GLenum pname, const GLfloat *params);
+GLAPI void APIENTRY glTextureParameteriEXT (GLuint texture, GLenum target, GLenum pname, GLint param);
+GLAPI void APIENTRY glTextureParameterivEXT (GLuint texture, GLenum target, GLenum pname, const GLint *params);
+GLAPI void APIENTRY glTextureImage1DEXT (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+GLAPI void APIENTRY glTextureImage2DEXT (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+GLAPI void APIENTRY glTextureSubImage1DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
+GLAPI void APIENTRY glTextureSubImage2DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+GLAPI void APIENTRY glCopyTextureImage1DEXT (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
+GLAPI void APIENTRY glCopyTextureImage2DEXT (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+GLAPI void APIENTRY glCopyTextureSubImage1DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+GLAPI void APIENTRY glCopyTextureSubImage2DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+GLAPI void APIENTRY glGetTextureImageEXT (GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
+GLAPI void APIENTRY glGetTextureParameterfvEXT (GLuint texture, GLenum target, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetTextureParameterivEXT (GLuint texture, GLenum target, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetTextureLevelParameterfvEXT (GLuint texture, GLenum target, GLint level, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetTextureLevelParameterivEXT (GLuint texture, GLenum target, GLint level, GLenum pname, GLint *params);
+GLAPI void APIENTRY glTextureImage3DEXT (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+GLAPI void APIENTRY glTextureSubImage3DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
+GLAPI void APIENTRY glCopyTextureSubImage3DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+GLAPI void APIENTRY glMultiTexParameterfEXT (GLenum texunit, GLenum target, GLenum pname, GLfloat param);
+GLAPI void APIENTRY glMultiTexParameterfvEXT (GLenum texunit, GLenum target, GLenum pname, const GLfloat *params);
+GLAPI void APIENTRY glMultiTexParameteriEXT (GLenum texunit, GLenum target, GLenum pname, GLint param);
+GLAPI void APIENTRY glMultiTexParameterivEXT (GLenum texunit, GLenum target, GLenum pname, const GLint *params);
+GLAPI void APIENTRY glMultiTexImage1DEXT (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+GLAPI void APIENTRY glMultiTexImage2DEXT (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+GLAPI void APIENTRY glMultiTexSubImage1DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
+GLAPI void APIENTRY glMultiTexSubImage2DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+GLAPI void APIENTRY glCopyMultiTexImage1DEXT (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
+GLAPI void APIENTRY glCopyMultiTexImage2DEXT (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+GLAPI void APIENTRY glCopyMultiTexSubImage1DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+GLAPI void APIENTRY glCopyMultiTexSubImage2DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+GLAPI void APIENTRY glGetMultiTexImageEXT (GLenum texunit, GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
+GLAPI void APIENTRY glGetMultiTexParameterfvEXT (GLenum texunit, GLenum target, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetMultiTexParameterivEXT (GLenum texunit, GLenum target, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetMultiTexLevelParameterfvEXT (GLenum texunit, GLenum target, GLint level, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetMultiTexLevelParameterivEXT (GLenum texunit, GLenum target, GLint level, GLenum pname, GLint *params);
+GLAPI void APIENTRY glMultiTexImage3DEXT (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+GLAPI void APIENTRY glMultiTexSubImage3DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
+GLAPI void APIENTRY glCopyMultiTexSubImage3DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+GLAPI void APIENTRY glBindMultiTextureEXT (GLenum texunit, GLenum target, GLuint texture);
+GLAPI void APIENTRY glEnableClientStateIndexedEXT (GLenum array, GLuint index);
+GLAPI void APIENTRY glDisableClientStateIndexedEXT (GLenum array, GLuint index);
+GLAPI void APIENTRY glMultiTexCoordPointerEXT (GLenum texunit, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+GLAPI void APIENTRY glMultiTexEnvfEXT (GLenum texunit, GLenum target, GLenum pname, GLfloat param);
+GLAPI void APIENTRY glMultiTexEnvfvEXT (GLenum texunit, GLenum target, GLenum pname, const GLfloat *params);
+GLAPI void APIENTRY glMultiTexEnviEXT (GLenum texunit, GLenum target, GLenum pname, GLint param);
+GLAPI void APIENTRY glMultiTexEnvivEXT (GLenum texunit, GLenum target, GLenum pname, const GLint *params);
+GLAPI void APIENTRY glMultiTexGendEXT (GLenum texunit, GLenum coord, GLenum pname, GLdouble param);
+GLAPI void APIENTRY glMultiTexGendvEXT (GLenum texunit, GLenum coord, GLenum pname, const GLdouble *params);
+GLAPI void APIENTRY glMultiTexGenfEXT (GLenum texunit, GLenum coord, GLenum pname, GLfloat param);
+GLAPI void APIENTRY glMultiTexGenfvEXT (GLenum texunit, GLenum coord, GLenum pname, const GLfloat *params);
+GLAPI void APIENTRY glMultiTexGeniEXT (GLenum texunit, GLenum coord, GLenum pname, GLint param);
+GLAPI void APIENTRY glMultiTexGenivEXT (GLenum texunit, GLenum coord, GLenum pname, const GLint *params);
+GLAPI void APIENTRY glGetMultiTexEnvfvEXT (GLenum texunit, GLenum target, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetMultiTexEnvivEXT (GLenum texunit, GLenum target, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetMultiTexGendvEXT (GLenum texunit, GLenum coord, GLenum pname, GLdouble *params);
+GLAPI void APIENTRY glGetMultiTexGenfvEXT (GLenum texunit, GLenum coord, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetMultiTexGenivEXT (GLenum texunit, GLenum coord, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetFloatIndexedvEXT (GLenum target, GLuint index, GLfloat *data);
+GLAPI void APIENTRY glGetDoubleIndexedvEXT (GLenum target, GLuint index, GLdouble *data);
+GLAPI void APIENTRY glGetPointerIndexedvEXT (GLenum target, GLuint index, GLvoid* *data);
+GLAPI void APIENTRY glCompressedTextureImage3DEXT (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *bits);
+GLAPI void APIENTRY glCompressedTextureImage2DEXT (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *bits);
+GLAPI void APIENTRY glCompressedTextureImage1DEXT (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *bits);
+GLAPI void APIENTRY glCompressedTextureSubImage3DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *bits);
+GLAPI void APIENTRY glCompressedTextureSubImage2DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *bits);
+GLAPI void APIENTRY glCompressedTextureSubImage1DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *bits);
+GLAPI void APIENTRY glGetCompressedTextureImageEXT (GLuint texture, GLenum target, GLint lod, GLvoid *img);
+GLAPI void APIENTRY glCompressedMultiTexImage3DEXT (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *bits);
+GLAPI void APIENTRY glCompressedMultiTexImage2DEXT (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *bits);
+GLAPI void APIENTRY glCompressedMultiTexImage1DEXT (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *bits);
+GLAPI void APIENTRY glCompressedMultiTexSubImage3DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *bits);
+GLAPI void APIENTRY glCompressedMultiTexSubImage2DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *bits);
+GLAPI void APIENTRY glCompressedMultiTexSubImage1DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *bits);
+GLAPI void APIENTRY glGetCompressedMultiTexImageEXT (GLenum texunit, GLenum target, GLint lod, GLvoid *img);
+GLAPI void APIENTRY glNamedProgramStringEXT (GLuint program, GLenum target, GLenum format, GLsizei len, const GLvoid *string);
+GLAPI void APIENTRY glNamedProgramLocalParameter4dEXT (GLuint program, GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+GLAPI void APIENTRY glNamedProgramLocalParameter4dvEXT (GLuint program, GLenum target, GLuint index, const GLdouble *params);
+GLAPI void APIENTRY glNamedProgramLocalParameter4fEXT (GLuint program, GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+GLAPI void APIENTRY glNamedProgramLocalParameter4fvEXT (GLuint program, GLenum target, GLuint index, const GLfloat *params);
+GLAPI void APIENTRY glGetNamedProgramLocalParameterdvEXT (GLuint program, GLenum target, GLuint index, GLdouble *params);
+GLAPI void APIENTRY glGetNamedProgramLocalParameterfvEXT (GLuint program, GLenum target, GLuint index, GLfloat *params);
+GLAPI void APIENTRY glGetNamedProgramivEXT (GLuint program, GLenum target, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetNamedProgramStringEXT (GLuint program, GLenum target, GLenum pname, GLvoid *string);
+GLAPI void APIENTRY glNamedProgramLocalParameters4fvEXT (GLuint program, GLenum target, GLuint index, GLsizei count, const GLfloat *params);
+GLAPI void APIENTRY glNamedProgramLocalParameterI4iEXT (GLuint program, GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w);
+GLAPI void APIENTRY glNamedProgramLocalParameterI4ivEXT (GLuint program, GLenum target, GLuint index, const GLint *params);
+GLAPI void APIENTRY glNamedProgramLocalParametersI4ivEXT (GLuint program, GLenum target, GLuint index, GLsizei count, const GLint *params);
+GLAPI void APIENTRY glNamedProgramLocalParameterI4uiEXT (GLuint program, GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
+GLAPI void APIENTRY glNamedProgramLocalParameterI4uivEXT (GLuint program, GLenum target, GLuint index, const GLuint *params);
+GLAPI void APIENTRY glNamedProgramLocalParametersI4uivEXT (GLuint program, GLenum target, GLuint index, GLsizei count, const GLuint *params);
+GLAPI void APIENTRY glGetNamedProgramLocalParameterIivEXT (GLuint program, GLenum target, GLuint index, GLint *params);
+GLAPI void APIENTRY glGetNamedProgramLocalParameterIuivEXT (GLuint program, GLenum target, GLuint index, GLuint *params);
+GLAPI void APIENTRY glTextureParameterIivEXT (GLuint texture, GLenum target, GLenum pname, const GLint *params);
+GLAPI void APIENTRY glTextureParameterIuivEXT (GLuint texture, GLenum target, GLenum pname, const GLuint *params);
+GLAPI void APIENTRY glGetTextureParameterIivEXT (GLuint texture, GLenum target, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetTextureParameterIuivEXT (GLuint texture, GLenum target, GLenum pname, GLuint *params);
+GLAPI void APIENTRY glMultiTexParameterIivEXT (GLenum texunit, GLenum target, GLenum pname, const GLint *params);
+GLAPI void APIENTRY glMultiTexParameterIuivEXT (GLenum texunit, GLenum target, GLenum pname, const GLuint *params);
+GLAPI void APIENTRY glGetMultiTexParameterIivEXT (GLenum texunit, GLenum target, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetMultiTexParameterIuivEXT (GLenum texunit, GLenum target, GLenum pname, GLuint *params);
+GLAPI void APIENTRY glProgramUniform1fEXT (GLuint program, GLint location, GLfloat v0);
+GLAPI void APIENTRY glProgramUniform2fEXT (GLuint program, GLint location, GLfloat v0, GLfloat v1);
+GLAPI void APIENTRY glProgramUniform3fEXT (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+GLAPI void APIENTRY glProgramUniform4fEXT (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+GLAPI void APIENTRY glProgramUniform1iEXT (GLuint program, GLint location, GLint v0);
+GLAPI void APIENTRY glProgramUniform2iEXT (GLuint program, GLint location, GLint v0, GLint v1);
+GLAPI void APIENTRY glProgramUniform3iEXT (GLuint program, GLint location, GLint v0, GLint v1, GLint v2);
+GLAPI void APIENTRY glProgramUniform4iEXT (GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+GLAPI void APIENTRY glProgramUniform1fvEXT (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+GLAPI void APIENTRY glProgramUniform2fvEXT (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+GLAPI void APIENTRY glProgramUniform3fvEXT (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+GLAPI void APIENTRY glProgramUniform4fvEXT (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+GLAPI void APIENTRY glProgramUniform1ivEXT (GLuint program, GLint location, GLsizei count, const GLint *value);
+GLAPI void APIENTRY glProgramUniform2ivEXT (GLuint program, GLint location, GLsizei count, const GLint *value);
+GLAPI void APIENTRY glProgramUniform3ivEXT (GLuint program, GLint location, GLsizei count, const GLint *value);
+GLAPI void APIENTRY glProgramUniform4ivEXT (GLuint program, GLint location, GLsizei count, const GLint *value);
+GLAPI void APIENTRY glProgramUniformMatrix2fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glProgramUniformMatrix3fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glProgramUniformMatrix4fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glProgramUniformMatrix2x3fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glProgramUniformMatrix3x2fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glProgramUniformMatrix2x4fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glProgramUniformMatrix4x2fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glProgramUniformMatrix3x4fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glProgramUniformMatrix4x3fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glProgramUniform1uiEXT (GLuint program, GLint location, GLuint v0);
+GLAPI void APIENTRY glProgramUniform2uiEXT (GLuint program, GLint location, GLuint v0, GLuint v1);
+GLAPI void APIENTRY glProgramUniform3uiEXT (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);
+GLAPI void APIENTRY glProgramUniform4uiEXT (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
+GLAPI void APIENTRY glProgramUniform1uivEXT (GLuint program, GLint location, GLsizei count, const GLuint *value);
+GLAPI void APIENTRY glProgramUniform2uivEXT (GLuint program, GLint location, GLsizei count, const GLuint *value);
+GLAPI void APIENTRY glProgramUniform3uivEXT (GLuint program, GLint location, GLsizei count, const GLuint *value);
+GLAPI void APIENTRY glProgramUniform4uivEXT (GLuint program, GLint location, GLsizei count, const GLuint *value);
+GLAPI void APIENTRY glNamedBufferDataEXT (GLuint buffer, GLsizeiptr size, const GLvoid *data, GLenum usage);
+GLAPI void APIENTRY glNamedBufferSubDataEXT (GLuint buffer, GLintptr offset, GLsizeiptr size, const GLvoid *data);
+GLAPI GLvoid* APIENTRY glMapNamedBufferEXT (GLuint buffer, GLenum access);
+GLAPI GLboolean APIENTRY glUnmapNamedBufferEXT (GLuint buffer);
+GLAPI GLvoid* APIENTRY glMapNamedBufferRangeEXT (GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access);
+GLAPI void APIENTRY glFlushMappedNamedBufferRangeEXT (GLuint buffer, GLintptr offset, GLsizeiptr length);
+GLAPI void APIENTRY glNamedCopyBufferSubDataEXT (GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
+GLAPI void APIENTRY glGetNamedBufferParameterivEXT (GLuint buffer, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetNamedBufferPointervEXT (GLuint buffer, GLenum pname, GLvoid* *params);
+GLAPI void APIENTRY glGetNamedBufferSubDataEXT (GLuint buffer, GLintptr offset, GLsizeiptr size, GLvoid *data);
+GLAPI void APIENTRY glTextureBufferEXT (GLuint texture, GLenum target, GLenum internalformat, GLuint buffer);
+GLAPI void APIENTRY glMultiTexBufferEXT (GLenum texunit, GLenum target, GLenum internalformat, GLuint buffer);
+GLAPI void APIENTRY glNamedRenderbufferStorageEXT (GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height);
+GLAPI void APIENTRY glGetNamedRenderbufferParameterivEXT (GLuint renderbuffer, GLenum pname, GLint *params);
+GLAPI GLenum APIENTRY glCheckNamedFramebufferStatusEXT (GLuint framebuffer, GLenum target);
+GLAPI void APIENTRY glNamedFramebufferTexture1DEXT (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+GLAPI void APIENTRY glNamedFramebufferTexture2DEXT (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+GLAPI void APIENTRY glNamedFramebufferTexture3DEXT (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
+GLAPI void APIENTRY glNamedFramebufferRenderbufferEXT (GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
+GLAPI void APIENTRY glGetNamedFramebufferAttachmentParameterivEXT (GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGenerateTextureMipmapEXT (GLuint texture, GLenum target);
+GLAPI void APIENTRY glGenerateMultiTexMipmapEXT (GLenum texunit, GLenum target);
+GLAPI void APIENTRY glFramebufferDrawBufferEXT (GLuint framebuffer, GLenum mode);
+GLAPI void APIENTRY glFramebufferDrawBuffersEXT (GLuint framebuffer, GLsizei n, const GLenum *bufs);
+GLAPI void APIENTRY glFramebufferReadBufferEXT (GLuint framebuffer, GLenum mode);
+GLAPI void APIENTRY glGetFramebufferParameterivEXT (GLuint framebuffer, GLenum pname, GLint *params);
+GLAPI void APIENTRY glNamedRenderbufferStorageMultisampleEXT (GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+GLAPI void APIENTRY glNamedRenderbufferStorageMultisampleCoverageEXT (GLuint renderbuffer, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height);
+GLAPI void APIENTRY glNamedFramebufferTextureEXT (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level);
+GLAPI void APIENTRY glNamedFramebufferTextureLayerEXT (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer);
+GLAPI void APIENTRY glNamedFramebufferTextureFaceEXT (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLenum face);
+GLAPI void APIENTRY glTextureRenderbufferEXT (GLuint texture, GLenum target, GLuint renderbuffer);
+GLAPI void APIENTRY glMultiTexRenderbufferEXT (GLenum texunit, GLenum target, GLuint renderbuffer);
+GLAPI void APIENTRY glProgramUniform1dEXT (GLuint program, GLint location, GLdouble x);
+GLAPI void APIENTRY glProgramUniform2dEXT (GLuint program, GLint location, GLdouble x, GLdouble y);
+GLAPI void APIENTRY glProgramUniform3dEXT (GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z);
+GLAPI void APIENTRY glProgramUniform4dEXT (GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+GLAPI void APIENTRY glProgramUniform1dvEXT (GLuint program, GLint location, GLsizei count, const GLdouble *value);
+GLAPI void APIENTRY glProgramUniform2dvEXT (GLuint program, GLint location, GLsizei count, const GLdouble *value);
+GLAPI void APIENTRY glProgramUniform3dvEXT (GLuint program, GLint location, GLsizei count, const GLdouble *value);
+GLAPI void APIENTRY glProgramUniform4dvEXT (GLuint program, GLint location, GLsizei count, const GLdouble *value);
+GLAPI void APIENTRY glProgramUniformMatrix2dvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+GLAPI void APIENTRY glProgramUniformMatrix3dvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+GLAPI void APIENTRY glProgramUniformMatrix4dvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+GLAPI void APIENTRY glProgramUniformMatrix2x3dvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+GLAPI void APIENTRY glProgramUniformMatrix2x4dvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+GLAPI void APIENTRY glProgramUniformMatrix3x2dvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+GLAPI void APIENTRY glProgramUniformMatrix3x4dvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+GLAPI void APIENTRY glProgramUniformMatrix4x2dvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+GLAPI void APIENTRY glProgramUniformMatrix4x3dvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLCLIENTATTRIBDEFAULTEXTPROC) (GLbitfield mask);
+typedef void (APIENTRYP PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC) (GLbitfield mask);
+typedef void (APIENTRYP PFNGLMATRIXLOADFEXTPROC) (GLenum mode, const GLfloat *m);
+typedef void (APIENTRYP PFNGLMATRIXLOADDEXTPROC) (GLenum mode, const GLdouble *m);
+typedef void (APIENTRYP PFNGLMATRIXMULTFEXTPROC) (GLenum mode, const GLfloat *m);
+typedef void (APIENTRYP PFNGLMATRIXMULTDEXTPROC) (GLenum mode, const GLdouble *m);
+typedef void (APIENTRYP PFNGLMATRIXLOADIDENTITYEXTPROC) (GLenum mode);
+typedef void (APIENTRYP PFNGLMATRIXROTATEFEXTPROC) (GLenum mode, GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRYP PFNGLMATRIXROTATEDEXTPROC) (GLenum mode, GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRYP PFNGLMATRIXSCALEFEXTPROC) (GLenum mode, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRYP PFNGLMATRIXSCALEDEXTPROC) (GLenum mode, GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRYP PFNGLMATRIXTRANSLATEFEXTPROC) (GLenum mode, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRYP PFNGLMATRIXTRANSLATEDEXTPROC) (GLenum mode, GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRYP PFNGLMATRIXFRUSTUMEXTPROC) (GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+typedef void (APIENTRYP PFNGLMATRIXORTHOEXTPROC) (GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+typedef void (APIENTRYP PFNGLMATRIXPOPEXTPROC) (GLenum mode);
+typedef void (APIENTRYP PFNGLMATRIXPUSHEXTPROC) (GLenum mode);
+typedef void (APIENTRYP PFNGLMATRIXLOADTRANSPOSEFEXTPROC) (GLenum mode, const GLfloat *m);
+typedef void (APIENTRYP PFNGLMATRIXLOADTRANSPOSEDEXTPROC) (GLenum mode, const GLdouble *m);
+typedef void (APIENTRYP PFNGLMATRIXMULTTRANSPOSEFEXTPROC) (GLenum mode, const GLfloat *m);
+typedef void (APIENTRYP PFNGLMATRIXMULTTRANSPOSEDEXTPROC) (GLenum mode, const GLdouble *m);
+typedef void (APIENTRYP PFNGLTEXTUREPARAMETERFEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLfloat param);
+typedef void (APIENTRYP PFNGLTEXTUREPARAMETERFVEXTPROC) (GLuint texture, GLenum target, GLenum pname, const GLfloat *params);
+typedef void (APIENTRYP PFNGLTEXTUREPARAMETERIEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLint param);
+typedef void (APIENTRYP PFNGLTEXTUREPARAMETERIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRYP PFNGLTEXTUREIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+typedef void (APIENTRYP PFNGLTEXTUREIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+typedef void (APIENTRYP PFNGLTEXTURESUBIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
+typedef void (APIENTRYP PFNGLTEXTURESUBIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+typedef void (APIENTRYP PFNGLCOPYTEXTUREIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
+typedef void (APIENTRYP PFNGLCOPYTEXTUREIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+typedef void (APIENTRYP PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+typedef void (APIENTRYP PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+typedef void (APIENTRYP PFNGLGETTEXTUREIMAGEEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
+typedef void (APIENTRYP PFNGLGETTEXTUREPARAMETERFVEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETTEXTUREPARAMETERIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLTEXTUREIMAGE3DEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+typedef void (APIENTRYP PFNGLTEXTURESUBIMAGE3DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
+typedef void (APIENTRYP PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+typedef void (APIENTRYP PFNGLMULTITEXPARAMETERFEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLfloat param);
+typedef void (APIENTRYP PFNGLMULTITEXPARAMETERFVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, const GLfloat *params);
+typedef void (APIENTRYP PFNGLMULTITEXPARAMETERIEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLint param);
+typedef void (APIENTRYP PFNGLMULTITEXPARAMETERIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRYP PFNGLMULTITEXIMAGE1DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+typedef void (APIENTRYP PFNGLMULTITEXIMAGE2DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+typedef void (APIENTRYP PFNGLMULTITEXSUBIMAGE1DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
+typedef void (APIENTRYP PFNGLMULTITEXSUBIMAGE2DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+typedef void (APIENTRYP PFNGLCOPYMULTITEXIMAGE1DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
+typedef void (APIENTRYP PFNGLCOPYMULTITEXIMAGE2DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+typedef void (APIENTRYP PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+typedef void (APIENTRYP PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+typedef void (APIENTRYP PFNGLGETMULTITEXIMAGEEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
+typedef void (APIENTRYP PFNGLGETMULTITEXPARAMETERFVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETMULTITEXPARAMETERIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLMULTITEXIMAGE3DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+typedef void (APIENTRYP PFNGLMULTITEXSUBIMAGE3DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
+typedef void (APIENTRYP PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+typedef void (APIENTRYP PFNGLBINDMULTITEXTUREEXTPROC) (GLenum texunit, GLenum target, GLuint texture);
+typedef void (APIENTRYP PFNGLENABLECLIENTSTATEINDEXEDEXTPROC) (GLenum array, GLuint index);
+typedef void (APIENTRYP PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC) (GLenum array, GLuint index);
+typedef void (APIENTRYP PFNGLMULTITEXCOORDPOINTEREXTPROC) (GLenum texunit, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+typedef void (APIENTRYP PFNGLMULTITEXENVFEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLfloat param);
+typedef void (APIENTRYP PFNGLMULTITEXENVFVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, const GLfloat *params);
+typedef void (APIENTRYP PFNGLMULTITEXENVIEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLint param);
+typedef void (APIENTRYP PFNGLMULTITEXENVIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRYP PFNGLMULTITEXGENDEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLdouble param);
+typedef void (APIENTRYP PFNGLMULTITEXGENDVEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, const GLdouble *params);
+typedef void (APIENTRYP PFNGLMULTITEXGENFEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLfloat param);
+typedef void (APIENTRYP PFNGLMULTITEXGENFVEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, const GLfloat *params);
+typedef void (APIENTRYP PFNGLMULTITEXGENIEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLint param);
+typedef void (APIENTRYP PFNGLMULTITEXGENIVEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, const GLint *params);
+typedef void (APIENTRYP PFNGLGETMULTITEXENVFVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETMULTITEXENVIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETMULTITEXGENDVEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLdouble *params);
+typedef void (APIENTRYP PFNGLGETMULTITEXGENFVEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETMULTITEXGENIVEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETFLOATINDEXEDVEXTPROC) (GLenum target, GLuint index, GLfloat *data);
+typedef void (APIENTRYP PFNGLGETDOUBLEINDEXEDVEXTPROC) (GLenum target, GLuint index, GLdouble *data);
+typedef void (APIENTRYP PFNGLGETPOINTERINDEXEDVEXTPROC) (GLenum target, GLuint index, GLvoid* *data);
+typedef void (APIENTRYP PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *bits);
+typedef void (APIENTRYP PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *bits);
+typedef void (APIENTRYP PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *bits);
+typedef void (APIENTRYP PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *bits);
+typedef void (APIENTRYP PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *bits);
+typedef void (APIENTRYP PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *bits);
+typedef void (APIENTRYP PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC) (GLuint texture, GLenum target, GLint lod, GLvoid *img);
+typedef void (APIENTRYP PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *bits);
+typedef void (APIENTRYP PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *bits);
+typedef void (APIENTRYP PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *bits);
+typedef void (APIENTRYP PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *bits);
+typedef void (APIENTRYP PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *bits);
+typedef void (APIENTRYP PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *bits);
+typedef void (APIENTRYP PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC) (GLenum texunit, GLenum target, GLint lod, GLvoid *img);
+typedef void (APIENTRYP PFNGLNAMEDPROGRAMSTRINGEXTPROC) (GLuint program, GLenum target, GLenum format, GLsizei len, const GLvoid *string);
+typedef void (APIENTRYP PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC) (GLuint program, GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRYP PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC) (GLuint program, GLenum target, GLuint index, const GLdouble *params);
+typedef void (APIENTRYP PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC) (GLuint program, GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRYP PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC) (GLuint program, GLenum target, GLuint index, const GLfloat *params);
+typedef void (APIENTRYP PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC) (GLuint program, GLenum target, GLuint index, GLdouble *params);
+typedef void (APIENTRYP PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC) (GLuint program, GLenum target, GLuint index, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETNAMEDPROGRAMIVEXTPROC) (GLuint program, GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETNAMEDPROGRAMSTRINGEXTPROC) (GLuint program, GLenum target, GLenum pname, GLvoid *string);
+typedef void (APIENTRYP PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC) (GLuint program, GLenum target, GLuint index, GLsizei count, const GLfloat *params);
+typedef void (APIENTRYP PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC) (GLuint program, GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w);
+typedef void (APIENTRYP PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC) (GLuint program, GLenum target, GLuint index, const GLint *params);
+typedef void (APIENTRYP PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC) (GLuint program, GLenum target, GLuint index, GLsizei count, const GLint *params);
+typedef void (APIENTRYP PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC) (GLuint program, GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
+typedef void (APIENTRYP PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC) (GLuint program, GLenum target, GLuint index, const GLuint *params);
+typedef void (APIENTRYP PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC) (GLuint program, GLenum target, GLuint index, GLsizei count, const GLuint *params);
+typedef void (APIENTRYP PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC) (GLuint program, GLenum target, GLuint index, GLint *params);
+typedef void (APIENTRYP PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC) (GLuint program, GLenum target, GLuint index, GLuint *params);
+typedef void (APIENTRYP PFNGLTEXTUREPARAMETERIIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRYP PFNGLTEXTUREPARAMETERIUIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, const GLuint *params);
+typedef void (APIENTRYP PFNGLGETTEXTUREPARAMETERIIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETTEXTUREPARAMETERIUIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLuint *params);
+typedef void (APIENTRYP PFNGLMULTITEXPARAMETERIIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRYP PFNGLMULTITEXPARAMETERIUIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, const GLuint *params);
+typedef void (APIENTRYP PFNGLGETMULTITEXPARAMETERIIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETMULTITEXPARAMETERIUIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLuint *params);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM1FEXTPROC) (GLuint program, GLint location, GLfloat v0);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM2FEXTPROC) (GLuint program, GLint location, GLfloat v0, GLfloat v1);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM3FEXTPROC) (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM4FEXTPROC) (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM1IEXTPROC) (GLuint program, GLint location, GLint v0);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM2IEXTPROC) (GLuint program, GLint location, GLint v0, GLint v1);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM3IEXTPROC) (GLuint program, GLint location, GLint v0, GLint v1, GLint v2);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM4IEXTPROC) (GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM1FVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM2FVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM3FVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM4FVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM1IVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLint *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM2IVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLint *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM3IVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLint *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM4IVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLint *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM1UIEXTPROC) (GLuint program, GLint location, GLuint v0);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM2UIEXTPROC) (GLuint program, GLint location, GLuint v0, GLuint v1);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM3UIEXTPROC) (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM4UIEXTPROC) (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM1UIVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLuint *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM2UIVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLuint *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM3UIVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLuint *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM4UIVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLuint *value);
+typedef void (APIENTRYP PFNGLNAMEDBUFFERDATAEXTPROC) (GLuint buffer, GLsizeiptr size, const GLvoid *data, GLenum usage);
+typedef void (APIENTRYP PFNGLNAMEDBUFFERSUBDATAEXTPROC) (GLuint buffer, GLintptr offset, GLsizeiptr size, const GLvoid *data);
+typedef GLvoid* (APIENTRYP PFNGLMAPNAMEDBUFFEREXTPROC) (GLuint buffer, GLenum access);
+typedef GLboolean (APIENTRYP PFNGLUNMAPNAMEDBUFFEREXTPROC) (GLuint buffer);
+typedef GLvoid* (APIENTRYP PFNGLMAPNAMEDBUFFERRANGEEXTPROC) (GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access);
+typedef void (APIENTRYP PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC) (GLuint buffer, GLintptr offset, GLsizeiptr length);
+typedef void (APIENTRYP PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC) (GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
+typedef void (APIENTRYP PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC) (GLuint buffer, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETNAMEDBUFFERPOINTERVEXTPROC) (GLuint buffer, GLenum pname, GLvoid* *params);
+typedef void (APIENTRYP PFNGLGETNAMEDBUFFERSUBDATAEXTPROC) (GLuint buffer, GLintptr offset, GLsizeiptr size, GLvoid *data);
+typedef void (APIENTRYP PFNGLTEXTUREBUFFEREXTPROC) (GLuint texture, GLenum target, GLenum internalformat, GLuint buffer);
+typedef void (APIENTRYP PFNGLMULTITEXBUFFEREXTPROC) (GLenum texunit, GLenum target, GLenum internalformat, GLuint buffer);
+typedef void (APIENTRYP PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC) (GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height);
+typedef void (APIENTRYP PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC) (GLuint renderbuffer, GLenum pname, GLint *params);
+typedef GLenum (APIENTRYP PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC) (GLuint framebuffer, GLenum target);
+typedef void (APIENTRYP PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC) (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+typedef void (APIENTRYP PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC) (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+typedef void (APIENTRYP PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC) (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
+typedef void (APIENTRYP PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC) (GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
+typedef void (APIENTRYP PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC) (GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGENERATETEXTUREMIPMAPEXTPROC) (GLuint texture, GLenum target);
+typedef void (APIENTRYP PFNGLGENERATEMULTITEXMIPMAPEXTPROC) (GLenum texunit, GLenum target);
+typedef void (APIENTRYP PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC) (GLuint framebuffer, GLenum mode);
+typedef void (APIENTRYP PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC) (GLuint framebuffer, GLsizei n, const GLenum *bufs);
+typedef void (APIENTRYP PFNGLFRAMEBUFFERREADBUFFEREXTPROC) (GLuint framebuffer, GLenum mode);
+typedef void (APIENTRYP PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC) (GLuint framebuffer, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC) (GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+typedef void (APIENTRYP PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC) (GLuint renderbuffer, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height);
+typedef void (APIENTRYP PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC) (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level);
+typedef void (APIENTRYP PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC) (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer);
+typedef void (APIENTRYP PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC) (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLenum face);
+typedef void (APIENTRYP PFNGLTEXTURERENDERBUFFEREXTPROC) (GLuint texture, GLenum target, GLuint renderbuffer);
+typedef void (APIENTRYP PFNGLMULTITEXRENDERBUFFEREXTPROC) (GLenum texunit, GLenum target, GLuint renderbuffer);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM1DEXTPROC) (GLuint program, GLint location, GLdouble x);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM2DEXTPROC) (GLuint program, GLint location, GLdouble x, GLdouble y);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM3DEXTPROC) (GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM4DEXTPROC) (GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM1DVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLdouble *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM2DVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLdouble *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM3DVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLdouble *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM4DVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLdouble *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX2DVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX3DVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX4DVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX2X3DVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX2X4DVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX3X2DVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX3X4DVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX4X2DVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMMATRIX4X3DVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+#endif
+
+#ifndef GL_EXT_vertex_array_bgra
+#define GL_EXT_vertex_array_bgra 1
+#endif
+
+#ifndef GL_EXT_texture_swizzle
+#define GL_EXT_texture_swizzle 1
+#endif
+
+#ifndef GL_NV_explicit_multisample
+#define GL_NV_explicit_multisample 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glGetMultisamplefvNV (GLenum pname, GLuint index, GLfloat *val);
+GLAPI void APIENTRY glSampleMaskIndexedNV (GLuint index, GLbitfield mask);
+GLAPI void APIENTRY glTexRenderbufferNV (GLenum target, GLuint renderbuffer);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLGETMULTISAMPLEFVNVPROC) (GLenum pname, GLuint index, GLfloat *val);
+typedef void (APIENTRYP PFNGLSAMPLEMASKINDEXEDNVPROC) (GLuint index, GLbitfield mask);
+typedef void (APIENTRYP PFNGLTEXRENDERBUFFERNVPROC) (GLenum target, GLuint renderbuffer);
+#endif
+
+#ifndef GL_NV_transform_feedback2
+#define GL_NV_transform_feedback2 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBindTransformFeedbackNV (GLenum target, GLuint id);
+GLAPI void APIENTRY glDeleteTransformFeedbacksNV (GLsizei n, const GLuint *ids);
+GLAPI void APIENTRY glGenTransformFeedbacksNV (GLsizei n, GLuint *ids);
+GLAPI GLboolean APIENTRY glIsTransformFeedbackNV (GLuint id);
+GLAPI void APIENTRY glPauseTransformFeedbackNV (void);
+GLAPI void APIENTRY glResumeTransformFeedbackNV (void);
+GLAPI void APIENTRY glDrawTransformFeedbackNV (GLenum mode, GLuint id);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLBINDTRANSFORMFEEDBACKNVPROC) (GLenum target, GLuint id);
+typedef void (APIENTRYP PFNGLDELETETRANSFORMFEEDBACKSNVPROC) (GLsizei n, const GLuint *ids);
+typedef void (APIENTRYP PFNGLGENTRANSFORMFEEDBACKSNVPROC) (GLsizei n, GLuint *ids);
+typedef GLboolean (APIENTRYP PFNGLISTRANSFORMFEEDBACKNVPROC) (GLuint id);
+typedef void (APIENTRYP PFNGLPAUSETRANSFORMFEEDBACKNVPROC) (void);
+typedef void (APIENTRYP PFNGLRESUMETRANSFORMFEEDBACKNVPROC) (void);
+typedef void (APIENTRYP PFNGLDRAWTRANSFORMFEEDBACKNVPROC) (GLenum mode, GLuint id);
+#endif
+
+#ifndef GL_ATI_meminfo
+#define GL_ATI_meminfo 1
+#endif
+
+#ifndef GL_AMD_performance_monitor
+#define GL_AMD_performance_monitor 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glGetPerfMonitorGroupsAMD (GLint *numGroups, GLsizei groupsSize, GLuint *groups);
+GLAPI void APIENTRY glGetPerfMonitorCountersAMD (GLuint group, GLint *numCounters, GLint *maxActiveCounters, GLsizei counterSize, GLuint *counters);
+GLAPI void APIENTRY glGetPerfMonitorGroupStringAMD (GLuint group, GLsizei bufSize, GLsizei *length, GLchar *groupString);
+GLAPI void APIENTRY glGetPerfMonitorCounterStringAMD (GLuint group, GLuint counter, GLsizei bufSize, GLsizei *length, GLchar *counterString);
+GLAPI void APIENTRY glGetPerfMonitorCounterInfoAMD (GLuint group, GLuint counter, GLenum pname, GLvoid *data);
+GLAPI void APIENTRY glGenPerfMonitorsAMD (GLsizei n, GLuint *monitors);
+GLAPI void APIENTRY glDeletePerfMonitorsAMD (GLsizei n, GLuint *monitors);
+GLAPI void APIENTRY glSelectPerfMonitorCountersAMD (GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint *counterList);
+GLAPI void APIENTRY glBeginPerfMonitorAMD (GLuint monitor);
+GLAPI void APIENTRY glEndPerfMonitorAMD (GLuint monitor);
+GLAPI void APIENTRY glGetPerfMonitorCounterDataAMD (GLuint monitor, GLenum pname, GLsizei dataSize, GLuint *data, GLint *bytesWritten);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLGETPERFMONITORGROUPSAMDPROC) (GLint *numGroups, GLsizei groupsSize, GLuint *groups);
+typedef void (APIENTRYP PFNGLGETPERFMONITORCOUNTERSAMDPROC) (GLuint group, GLint *numCounters, GLint *maxActiveCounters, GLsizei counterSize, GLuint *counters);
+typedef void (APIENTRYP PFNGLGETPERFMONITORGROUPSTRINGAMDPROC) (GLuint group, GLsizei bufSize, GLsizei *length, GLchar *groupString);
+typedef void (APIENTRYP PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC) (GLuint group, GLuint counter, GLsizei bufSize, GLsizei *length, GLchar *counterString);
+typedef void (APIENTRYP PFNGLGETPERFMONITORCOUNTERINFOAMDPROC) (GLuint group, GLuint counter, GLenum pname, GLvoid *data);
+typedef void (APIENTRYP PFNGLGENPERFMONITORSAMDPROC) (GLsizei n, GLuint *monitors);
+typedef void (APIENTRYP PFNGLDELETEPERFMONITORSAMDPROC) (GLsizei n, GLuint *monitors);
+typedef void (APIENTRYP PFNGLSELECTPERFMONITORCOUNTERSAMDPROC) (GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint *counterList);
+typedef void (APIENTRYP PFNGLBEGINPERFMONITORAMDPROC) (GLuint monitor);
+typedef void (APIENTRYP PFNGLENDPERFMONITORAMDPROC) (GLuint monitor);
+typedef void (APIENTRYP PFNGLGETPERFMONITORCOUNTERDATAAMDPROC) (GLuint monitor, GLenum pname, GLsizei dataSize, GLuint *data, GLint *bytesWritten);
+#endif
+
+#ifndef GL_AMD_texture_texture4
+#define GL_AMD_texture_texture4 1
+#endif
+
+#ifndef GL_AMD_vertex_shader_tesselator
+#define GL_AMD_vertex_shader_tesselator 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glTessellationFactorAMD (GLfloat factor);
+GLAPI void APIENTRY glTessellationModeAMD (GLenum mode);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLTESSELLATIONFACTORAMDPROC) (GLfloat factor);
+typedef void (APIENTRYP PFNGLTESSELLATIONMODEAMDPROC) (GLenum mode);
+#endif
+
+#ifndef GL_EXT_provoking_vertex
+#define GL_EXT_provoking_vertex 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glProvokingVertexEXT (GLenum mode);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLPROVOKINGVERTEXEXTPROC) (GLenum mode);
+#endif
+
+#ifndef GL_EXT_texture_snorm
+#define GL_EXT_texture_snorm 1
+#endif
+
+#ifndef GL_AMD_draw_buffers_blend
+#define GL_AMD_draw_buffers_blend 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBlendFuncIndexedAMD (GLuint buf, GLenum src, GLenum dst);
+GLAPI void APIENTRY glBlendFuncSeparateIndexedAMD (GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
+GLAPI void APIENTRY glBlendEquationIndexedAMD (GLuint buf, GLenum mode);
+GLAPI void APIENTRY glBlendEquationSeparateIndexedAMD (GLuint buf, GLenum modeRGB, GLenum modeAlpha);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLBLENDFUNCINDEXEDAMDPROC) (GLuint buf, GLenum src, GLenum dst);
+typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC) (GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
+typedef void (APIENTRYP PFNGLBLENDEQUATIONINDEXEDAMDPROC) (GLuint buf, GLenum mode);
+typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC) (GLuint buf, GLenum modeRGB, GLenum modeAlpha);
+#endif
+
+#ifndef GL_APPLE_texture_range
+#define GL_APPLE_texture_range 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glTextureRangeAPPLE (GLenum target, GLsizei length, const GLvoid *pointer);
+GLAPI void APIENTRY glGetTexParameterPointervAPPLE (GLenum target, GLenum pname, GLvoid* *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLTEXTURERANGEAPPLEPROC) (GLenum target, GLsizei length, const GLvoid *pointer);
+typedef void (APIENTRYP PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC) (GLenum target, GLenum pname, GLvoid* *params);
+#endif
+
+#ifndef GL_APPLE_float_pixels
+#define GL_APPLE_float_pixels 1
+#endif
+
+#ifndef GL_APPLE_vertex_program_evaluators
+#define GL_APPLE_vertex_program_evaluators 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glEnableVertexAttribAPPLE (GLuint index, GLenum pname);
+GLAPI void APIENTRY glDisableVertexAttribAPPLE (GLuint index, GLenum pname);
+GLAPI GLboolean APIENTRY glIsVertexAttribEnabledAPPLE (GLuint index, GLenum pname);
+GLAPI void APIENTRY glMapVertexAttrib1dAPPLE (GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
+GLAPI void APIENTRY glMapVertexAttrib1fAPPLE (GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
+GLAPI void APIENTRY glMapVertexAttrib2dAPPLE (GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
+GLAPI void APIENTRY glMapVertexAttrib2fAPPLE (GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLENABLEVERTEXATTRIBAPPLEPROC) (GLuint index, GLenum pname);
+typedef void (APIENTRYP PFNGLDISABLEVERTEXATTRIBAPPLEPROC) (GLuint index, GLenum pname);
+typedef GLboolean (APIENTRYP PFNGLISVERTEXATTRIBENABLEDAPPLEPROC) (GLuint index, GLenum pname);
+typedef void (APIENTRYP PFNGLMAPVERTEXATTRIB1DAPPLEPROC) (GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
+typedef void (APIENTRYP PFNGLMAPVERTEXATTRIB1FAPPLEPROC) (GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
+typedef void (APIENTRYP PFNGLMAPVERTEXATTRIB2DAPPLEPROC) (GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
+typedef void (APIENTRYP PFNGLMAPVERTEXATTRIB2FAPPLEPROC) (GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
+#endif
+
+#ifndef GL_APPLE_aux_depth_stencil
+#define GL_APPLE_aux_depth_stencil 1
+#endif
+
+#ifndef GL_APPLE_object_purgeable
+#define GL_APPLE_object_purgeable 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI GLenum APIENTRY glObjectPurgeableAPPLE (GLenum objectType, GLuint name, GLenum option);
+GLAPI GLenum APIENTRY glObjectUnpurgeableAPPLE (GLenum objectType, GLuint name, GLenum option);
+GLAPI void APIENTRY glGetObjectParameterivAPPLE (GLenum objectType, GLuint name, GLenum pname, GLint *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef GLenum (APIENTRYP PFNGLOBJECTPURGEABLEAPPLEPROC) (GLenum objectType, GLuint name, GLenum option);
+typedef GLenum (APIENTRYP PFNGLOBJECTUNPURGEABLEAPPLEPROC) (GLenum objectType, GLuint name, GLenum option);
+typedef void (APIENTRYP PFNGLGETOBJECTPARAMETERIVAPPLEPROC) (GLenum objectType, GLuint name, GLenum pname, GLint *params);
+#endif
+
+#ifndef GL_APPLE_row_bytes
+#define GL_APPLE_row_bytes 1
+#endif
+
+#ifndef GL_APPLE_rgb_422
+#define GL_APPLE_rgb_422 1
+#endif
+
+#ifndef GL_NV_video_capture
+#define GL_NV_video_capture 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBeginVideoCaptureNV (GLuint video_capture_slot);
+GLAPI void APIENTRY glBindVideoCaptureStreamBufferNV (GLuint video_capture_slot, GLuint stream, GLenum frame_region, GLintptrARB offset);
+GLAPI void APIENTRY glBindVideoCaptureStreamTextureNV (GLuint video_capture_slot, GLuint stream, GLenum frame_region, GLenum target, GLuint texture);
+GLAPI void APIENTRY glEndVideoCaptureNV (GLuint video_capture_slot);
+GLAPI void APIENTRY glGetVideoCaptureivNV (GLuint video_capture_slot, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetVideoCaptureStreamivNV (GLuint video_capture_slot, GLuint stream, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetVideoCaptureStreamfvNV (GLuint video_capture_slot, GLuint stream, GLenum pname, GLfloat *params);
+GLAPI void APIENTRY glGetVideoCaptureStreamdvNV (GLuint video_capture_slot, GLuint stream, GLenum pname, GLdouble *params);
+GLAPI GLenum APIENTRY glVideoCaptureNV (GLuint video_capture_slot, GLuint *sequence_num, GLuint64EXT *capture_time);
+GLAPI void APIENTRY glVideoCaptureStreamParameterivNV (GLuint video_capture_slot, GLuint stream, GLenum pname, const GLint *params);
+GLAPI void APIENTRY glVideoCaptureStreamParameterfvNV (GLuint video_capture_slot, GLuint stream, GLenum pname, const GLfloat *params);
+GLAPI void APIENTRY glVideoCaptureStreamParameterdvNV (GLuint video_capture_slot, GLuint stream, GLenum pname, const GLdouble *params);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLBEGINVIDEOCAPTURENVPROC) (GLuint video_capture_slot);
+typedef void (APIENTRYP PFNGLBINDVIDEOCAPTURESTREAMBUFFERNVPROC) (GLuint video_capture_slot, GLuint stream, GLenum frame_region, GLintptrARB offset);
+typedef void (APIENTRYP PFNGLBINDVIDEOCAPTURESTREAMTEXTURENVPROC) (GLuint video_capture_slot, GLuint stream, GLenum frame_region, GLenum target, GLuint texture);
+typedef void (APIENTRYP PFNGLENDVIDEOCAPTURENVPROC) (GLuint video_capture_slot);
+typedef void (APIENTRYP PFNGLGETVIDEOCAPTUREIVNVPROC) (GLuint video_capture_slot, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETVIDEOCAPTURESTREAMIVNVPROC) (GLuint video_capture_slot, GLuint stream, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETVIDEOCAPTURESTREAMFVNVPROC) (GLuint video_capture_slot, GLuint stream, GLenum pname, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETVIDEOCAPTURESTREAMDVNVPROC) (GLuint video_capture_slot, GLuint stream, GLenum pname, GLdouble *params);
+typedef GLenum (APIENTRYP PFNGLVIDEOCAPTURENVPROC) (GLuint video_capture_slot, GLuint *sequence_num, GLuint64EXT *capture_time);
+typedef void (APIENTRYP PFNGLVIDEOCAPTURESTREAMPARAMETERIVNVPROC) (GLuint video_capture_slot, GLuint stream, GLenum pname, const GLint *params);
+typedef void (APIENTRYP PFNGLVIDEOCAPTURESTREAMPARAMETERFVNVPROC) (GLuint video_capture_slot, GLuint stream, GLenum pname, const GLfloat *params);
+typedef void (APIENTRYP PFNGLVIDEOCAPTURESTREAMPARAMETERDVNVPROC) (GLuint video_capture_slot, GLuint stream, GLenum pname, const GLdouble *params);
+#endif
+
+#ifndef GL_NV_copy_image
+#define GL_NV_copy_image 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glCopyImageSubDataNV (GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLCOPYIMAGESUBDATANVPROC) (GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth);
+#endif
+
+#ifndef GL_EXT_separate_shader_objects
+#define GL_EXT_separate_shader_objects 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glUseShaderProgramEXT (GLenum type, GLuint program);
+GLAPI void APIENTRY glActiveProgramEXT (GLuint program);
+GLAPI GLuint APIENTRY glCreateShaderProgramEXT (GLenum type, const GLchar *string);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLUSESHADERPROGRAMEXTPROC) (GLenum type, GLuint program);
+typedef void (APIENTRYP PFNGLACTIVEPROGRAMEXTPROC) (GLuint program);
+typedef GLuint (APIENTRYP PFNGLCREATESHADERPROGRAMEXTPROC) (GLenum type, const GLchar *string);
+#endif
+
+#ifndef GL_NV_parameter_buffer_object2
+#define GL_NV_parameter_buffer_object2 1
+#endif
+
+#ifndef GL_NV_shader_buffer_load
+#define GL_NV_shader_buffer_load 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glMakeBufferResidentNV (GLenum target, GLenum access);
+GLAPI void APIENTRY glMakeBufferNonResidentNV (GLenum target);
+GLAPI GLboolean APIENTRY glIsBufferResidentNV (GLenum target);
+GLAPI void APIENTRY glMakeNamedBufferResidentNV (GLuint buffer, GLenum access);
+GLAPI void APIENTRY glMakeNamedBufferNonResidentNV (GLuint buffer);
+GLAPI GLboolean APIENTRY glIsNamedBufferResidentNV (GLuint buffer);
+GLAPI void APIENTRY glGetBufferParameterui64vNV (GLenum target, GLenum pname, GLuint64EXT *params);
+GLAPI void APIENTRY glGetNamedBufferParameterui64vNV (GLuint buffer, GLenum pname, GLuint64EXT *params);
+GLAPI void APIENTRY glGetIntegerui64vNV (GLenum value, GLuint64EXT *result);
+GLAPI void APIENTRY glUniformui64NV (GLint location, GLuint64EXT value);
+GLAPI void APIENTRY glUniformui64vNV (GLint location, GLsizei count, const GLuint64EXT *value);
+GLAPI void APIENTRY glGetUniformui64vNV (GLuint program, GLint location, GLuint64EXT *params);
+GLAPI void APIENTRY glProgramUniformui64NV (GLuint program, GLint location, GLuint64EXT value);
+GLAPI void APIENTRY glProgramUniformui64vNV (GLuint program, GLint location, GLsizei count, const GLuint64EXT *value);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLMAKEBUFFERRESIDENTNVPROC) (GLenum target, GLenum access);
+typedef void (APIENTRYP PFNGLMAKEBUFFERNONRESIDENTNVPROC) (GLenum target);
+typedef GLboolean (APIENTRYP PFNGLISBUFFERRESIDENTNVPROC) (GLenum target);
+typedef void (APIENTRYP PFNGLMAKENAMEDBUFFERRESIDENTNVPROC) (GLuint buffer, GLenum access);
+typedef void (APIENTRYP PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC) (GLuint buffer);
+typedef GLboolean (APIENTRYP PFNGLISNAMEDBUFFERRESIDENTNVPROC) (GLuint buffer);
+typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERUI64VNVPROC) (GLenum target, GLenum pname, GLuint64EXT *params);
+typedef void (APIENTRYP PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC) (GLuint buffer, GLenum pname, GLuint64EXT *params);
+typedef void (APIENTRYP PFNGLGETINTEGERUI64VNVPROC) (GLenum value, GLuint64EXT *result);
+typedef void (APIENTRYP PFNGLUNIFORMUI64NVPROC) (GLint location, GLuint64EXT value);
+typedef void (APIENTRYP PFNGLUNIFORMUI64VNVPROC) (GLint location, GLsizei count, const GLuint64EXT *value);
+typedef void (APIENTRYP PFNGLGETUNIFORMUI64VNVPROC) (GLuint program, GLint location, GLuint64EXT *params);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMUI64NVPROC) (GLuint program, GLint location, GLuint64EXT value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMUI64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLuint64EXT *value);
+#endif
+
+#ifndef GL_NV_vertex_buffer_unified_memory
+#define GL_NV_vertex_buffer_unified_memory 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBufferAddressRangeNV (GLenum pname, GLuint index, GLuint64EXT address, GLsizeiptr length);
+GLAPI void APIENTRY glVertexFormatNV (GLint size, GLenum type, GLsizei stride);
+GLAPI void APIENTRY glNormalFormatNV (GLenum type, GLsizei stride);
+GLAPI void APIENTRY glColorFormatNV (GLint size, GLenum type, GLsizei stride);
+GLAPI void APIENTRY glIndexFormatNV (GLenum type, GLsizei stride);
+GLAPI void APIENTRY glTexCoordFormatNV (GLint size, GLenum type, GLsizei stride);
+GLAPI void APIENTRY glEdgeFlagFormatNV (GLsizei stride);
+GLAPI void APIENTRY glSecondaryColorFormatNV (GLint size, GLenum type, GLsizei stride);
+GLAPI void APIENTRY glFogCoordFormatNV (GLenum type, GLsizei stride);
+GLAPI void APIENTRY glVertexAttribFormatNV (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride);
+GLAPI void APIENTRY glVertexAttribIFormatNV (GLuint index, GLint size, GLenum type, GLsizei stride);
+GLAPI void APIENTRY glGetIntegerui64i_vNV (GLenum value, GLuint index, GLuint64EXT *result);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLBUFFERADDRESSRANGENVPROC) (GLenum pname, GLuint index, GLuint64EXT address, GLsizeiptr length);
+typedef void (APIENTRYP PFNGLVERTEXFORMATNVPROC) (GLint size, GLenum type, GLsizei stride);
+typedef void (APIENTRYP PFNGLNORMALFORMATNVPROC) (GLenum type, GLsizei stride);
+typedef void (APIENTRYP PFNGLCOLORFORMATNVPROC) (GLint size, GLenum type, GLsizei stride);
+typedef void (APIENTRYP PFNGLINDEXFORMATNVPROC) (GLenum type, GLsizei stride);
+typedef void (APIENTRYP PFNGLTEXCOORDFORMATNVPROC) (GLint size, GLenum type, GLsizei stride);
+typedef void (APIENTRYP PFNGLEDGEFLAGFORMATNVPROC) (GLsizei stride);
+typedef void (APIENTRYP PFNGLSECONDARYCOLORFORMATNVPROC) (GLint size, GLenum type, GLsizei stride);
+typedef void (APIENTRYP PFNGLFOGCOORDFORMATNVPROC) (GLenum type, GLsizei stride);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBFORMATNVPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBIFORMATNVPROC) (GLuint index, GLint size, GLenum type, GLsizei stride);
+typedef void (APIENTRYP PFNGLGETINTEGERUI64I_VNVPROC) (GLenum value, GLuint index, GLuint64EXT *result);
+#endif
+
+#ifndef GL_NV_texture_barrier
+#define GL_NV_texture_barrier 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glTextureBarrierNV (void);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLTEXTUREBARRIERNVPROC) (void);
+#endif
+
+#ifndef GL_AMD_shader_stencil_export
+#define GL_AMD_shader_stencil_export 1
+#endif
+
+#ifndef GL_AMD_seamless_cubemap_per_texture
+#define GL_AMD_seamless_cubemap_per_texture 1
+#endif
+
+#ifndef GL_AMD_conservative_depth
+#define GL_AMD_conservative_depth 1
+#endif
+
+#ifndef GL_EXT_shader_image_load_store
+#define GL_EXT_shader_image_load_store 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBindImageTextureEXT (GLuint index, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLint format);
+GLAPI void APIENTRY glMemoryBarrierEXT (GLbitfield barriers);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLBINDIMAGETEXTUREEXTPROC) (GLuint index, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLint format);
+typedef void (APIENTRYP PFNGLMEMORYBARRIEREXTPROC) (GLbitfield barriers);
+#endif
+
+#ifndef GL_EXT_vertex_attrib_64bit
+#define GL_EXT_vertex_attrib_64bit 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glVertexAttribL1dEXT (GLuint index, GLdouble x);
+GLAPI void APIENTRY glVertexAttribL2dEXT (GLuint index, GLdouble x, GLdouble y);
+GLAPI void APIENTRY glVertexAttribL3dEXT (GLuint index, GLdouble x, GLdouble y, GLdouble z);
+GLAPI void APIENTRY glVertexAttribL4dEXT (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+GLAPI void APIENTRY glVertexAttribL1dvEXT (GLuint index, const GLdouble *v);
+GLAPI void APIENTRY glVertexAttribL2dvEXT (GLuint index, const GLdouble *v);
+GLAPI void APIENTRY glVertexAttribL3dvEXT (GLuint index, const GLdouble *v);
+GLAPI void APIENTRY glVertexAttribL4dvEXT (GLuint index, const GLdouble *v);
+GLAPI void APIENTRY glVertexAttribLPointerEXT (GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+GLAPI void APIENTRY glGetVertexAttribLdvEXT (GLuint index, GLenum pname, GLdouble *params);
+GLAPI void APIENTRY glVertexArrayVertexAttribLOffsetEXT (GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL1DEXTPROC) (GLuint index, GLdouble x);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL2DEXTPROC) (GLuint index, GLdouble x, GLdouble y);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL3DEXTPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL4DEXTPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL1DVEXTPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL2DVEXTPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL3DVEXTPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL4DVEXTPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBLPOINTEREXTPROC) (GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBLDVEXTPROC) (GLuint index, GLenum pname, GLdouble *params);
+typedef void (APIENTRYP PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset);
+#endif
+
+#ifndef GL_NV_gpu_program5
+#define GL_NV_gpu_program5 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glProgramSubroutineParametersuivNV (GLenum target, GLsizei count, const GLuint *params);
+GLAPI void APIENTRY glGetProgramSubroutineParameteruivNV (GLenum target, GLuint index, GLuint *param);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLPROGRAMSUBROUTINEPARAMETERSUIVNVPROC) (GLenum target, GLsizei count, const GLuint *params);
+typedef void (APIENTRYP PFNGLGETPROGRAMSUBROUTINEPARAMETERUIVNVPROC) (GLenum target, GLuint index, GLuint *param);
+#endif
+
+#ifndef GL_NV_gpu_shader5
+#define GL_NV_gpu_shader5 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glUniform1i64NV (GLint location, GLint64EXT x);
+GLAPI void APIENTRY glUniform2i64NV (GLint location, GLint64EXT x, GLint64EXT y);
+GLAPI void APIENTRY glUniform3i64NV (GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z);
+GLAPI void APIENTRY glUniform4i64NV (GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w);
+GLAPI void APIENTRY glUniform1i64vNV (GLint location, GLsizei count, const GLint64EXT *value);
+GLAPI void APIENTRY glUniform2i64vNV (GLint location, GLsizei count, const GLint64EXT *value);
+GLAPI void APIENTRY glUniform3i64vNV (GLint location, GLsizei count, const GLint64EXT *value);
+GLAPI void APIENTRY glUniform4i64vNV (GLint location, GLsizei count, const GLint64EXT *value);
+GLAPI void APIENTRY glUniform1ui64NV (GLint location, GLuint64EXT x);
+GLAPI void APIENTRY glUniform2ui64NV (GLint location, GLuint64EXT x, GLuint64EXT y);
+GLAPI void APIENTRY glUniform3ui64NV (GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z);
+GLAPI void APIENTRY glUniform4ui64NV (GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w);
+GLAPI void APIENTRY glUniform1ui64vNV (GLint location, GLsizei count, const GLuint64EXT *value);
+GLAPI void APIENTRY glUniform2ui64vNV (GLint location, GLsizei count, const GLuint64EXT *value);
+GLAPI void APIENTRY glUniform3ui64vNV (GLint location, GLsizei count, const GLuint64EXT *value);
+GLAPI void APIENTRY glUniform4ui64vNV (GLint location, GLsizei count, const GLuint64EXT *value);
+GLAPI void APIENTRY glGetUniformi64vNV (GLuint program, GLint location, GLint64EXT *params);
+GLAPI void APIENTRY glProgramUniform1i64NV (GLuint program, GLint location, GLint64EXT x);
+GLAPI void APIENTRY glProgramUniform2i64NV (GLuint program, GLint location, GLint64EXT x, GLint64EXT y);
+GLAPI void APIENTRY glProgramUniform3i64NV (GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z);
+GLAPI void APIENTRY glProgramUniform4i64NV (GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w);
+GLAPI void APIENTRY glProgramUniform1i64vNV (GLuint program, GLint location, GLsizei count, const GLint64EXT *value);
+GLAPI void APIENTRY glProgramUniform2i64vNV (GLuint program, GLint location, GLsizei count, const GLint64EXT *value);
+GLAPI void APIENTRY glProgramUniform3i64vNV (GLuint program, GLint location, GLsizei count, const GLint64EXT *value);
+GLAPI void APIENTRY glProgramUniform4i64vNV (GLuint program, GLint location, GLsizei count, const GLint64EXT *value);
+GLAPI void APIENTRY glProgramUniform1ui64NV (GLuint program, GLint location, GLuint64EXT x);
+GLAPI void APIENTRY glProgramUniform2ui64NV (GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y);
+GLAPI void APIENTRY glProgramUniform3ui64NV (GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z);
+GLAPI void APIENTRY glProgramUniform4ui64NV (GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w);
+GLAPI void APIENTRY glProgramUniform1ui64vNV (GLuint program, GLint location, GLsizei count, const GLuint64EXT *value);
+GLAPI void APIENTRY glProgramUniform2ui64vNV (GLuint program, GLint location, GLsizei count, const GLuint64EXT *value);
+GLAPI void APIENTRY glProgramUniform3ui64vNV (GLuint program, GLint location, GLsizei count, const GLuint64EXT *value);
+GLAPI void APIENTRY glProgramUniform4ui64vNV (GLuint program, GLint location, GLsizei count, const GLuint64EXT *value);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLUNIFORM1I64NVPROC) (GLint location, GLint64EXT x);
+typedef void (APIENTRYP PFNGLUNIFORM2I64NVPROC) (GLint location, GLint64EXT x, GLint64EXT y);
+typedef void (APIENTRYP PFNGLUNIFORM3I64NVPROC) (GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z);
+typedef void (APIENTRYP PFNGLUNIFORM4I64NVPROC) (GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w);
+typedef void (APIENTRYP PFNGLUNIFORM1I64VNVPROC) (GLint location, GLsizei count, const GLint64EXT *value);
+typedef void (APIENTRYP PFNGLUNIFORM2I64VNVPROC) (GLint location, GLsizei count, const GLint64EXT *value);
+typedef void (APIENTRYP PFNGLUNIFORM3I64VNVPROC) (GLint location, GLsizei count, const GLint64EXT *value);
+typedef void (APIENTRYP PFNGLUNIFORM4I64VNVPROC) (GLint location, GLsizei count, const GLint64EXT *value);
+typedef void (APIENTRYP PFNGLUNIFORM1UI64NVPROC) (GLint location, GLuint64EXT x);
+typedef void (APIENTRYP PFNGLUNIFORM2UI64NVPROC) (GLint location, GLuint64EXT x, GLuint64EXT y);
+typedef void (APIENTRYP PFNGLUNIFORM3UI64NVPROC) (GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z);
+typedef void (APIENTRYP PFNGLUNIFORM4UI64NVPROC) (GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w);
+typedef void (APIENTRYP PFNGLUNIFORM1UI64VNVPROC) (GLint location, GLsizei count, const GLuint64EXT *value);
+typedef void (APIENTRYP PFNGLUNIFORM2UI64VNVPROC) (GLint location, GLsizei count, const GLuint64EXT *value);
+typedef void (APIENTRYP PFNGLUNIFORM3UI64VNVPROC) (GLint location, GLsizei count, const GLuint64EXT *value);
+typedef void (APIENTRYP PFNGLUNIFORM4UI64VNVPROC) (GLint location, GLsizei count, const GLuint64EXT *value);
+typedef void (APIENTRYP PFNGLGETUNIFORMI64VNVPROC) (GLuint program, GLint location, GLint64EXT *params);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM1I64NVPROC) (GLuint program, GLint location, GLint64EXT x);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM2I64NVPROC) (GLuint program, GLint location, GLint64EXT x, GLint64EXT y);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM3I64NVPROC) (GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM4I64NVPROC) (GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM1I64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLint64EXT *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM2I64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLint64EXT *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM3I64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLint64EXT *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM4I64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLint64EXT *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM1UI64NVPROC) (GLuint program, GLint location, GLuint64EXT x);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM2UI64NVPROC) (GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM3UI64NVPROC) (GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM4UI64NVPROC) (GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM1UI64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLuint64EXT *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM2UI64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLuint64EXT *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM3UI64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLuint64EXT *value);
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORM4UI64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLuint64EXT *value);
+#endif
+
+#ifndef GL_NV_shader_buffer_store
+#define GL_NV_shader_buffer_store 1
+#endif
+
+#ifndef GL_NV_tessellation_program5
+#define GL_NV_tessellation_program5 1
+#endif
+
+#ifndef GL_NV_vertex_attrib_integer_64bit
+#define GL_NV_vertex_attrib_integer_64bit 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glVertexAttribL1i64NV (GLuint index, GLint64EXT x);
+GLAPI void APIENTRY glVertexAttribL2i64NV (GLuint index, GLint64EXT x, GLint64EXT y);
+GLAPI void APIENTRY glVertexAttribL3i64NV (GLuint index, GLint64EXT x, GLint64EXT y, GLint64EXT z);
+GLAPI void APIENTRY glVertexAttribL4i64NV (GLuint index, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w);
+GLAPI void APIENTRY glVertexAttribL1i64vNV (GLuint index, const GLint64EXT *v);
+GLAPI void APIENTRY glVertexAttribL2i64vNV (GLuint index, const GLint64EXT *v);
+GLAPI void APIENTRY glVertexAttribL3i64vNV (GLuint index, const GLint64EXT *v);
+GLAPI void APIENTRY glVertexAttribL4i64vNV (GLuint index, const GLint64EXT *v);
+GLAPI void APIENTRY glVertexAttribL1ui64NV (GLuint index, GLuint64EXT x);
+GLAPI void APIENTRY glVertexAttribL2ui64NV (GLuint index, GLuint64EXT x, GLuint64EXT y);
+GLAPI void APIENTRY glVertexAttribL3ui64NV (GLuint index, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z);
+GLAPI void APIENTRY glVertexAttribL4ui64NV (GLuint index, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w);
+GLAPI void APIENTRY glVertexAttribL1ui64vNV (GLuint index, const GLuint64EXT *v);
+GLAPI void APIENTRY glVertexAttribL2ui64vNV (GLuint index, const GLuint64EXT *v);
+GLAPI void APIENTRY glVertexAttribL3ui64vNV (GLuint index, const GLuint64EXT *v);
+GLAPI void APIENTRY glVertexAttribL4ui64vNV (GLuint index, const GLuint64EXT *v);
+GLAPI void APIENTRY glGetVertexAttribLi64vNV (GLuint index, GLenum pname, GLint64EXT *params);
+GLAPI void APIENTRY glGetVertexAttribLui64vNV (GLuint index, GLenum pname, GLuint64EXT *params);
+GLAPI void APIENTRY glVertexAttribLFormatNV (GLuint index, GLint size, GLenum type, GLsizei stride);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL1I64NVPROC) (GLuint index, GLint64EXT x);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL2I64NVPROC) (GLuint index, GLint64EXT x, GLint64EXT y);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL3I64NVPROC) (GLuint index, GLint64EXT x, GLint64EXT y, GLint64EXT z);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL4I64NVPROC) (GLuint index, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL1I64VNVPROC) (GLuint index, const GLint64EXT *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL2I64VNVPROC) (GLuint index, const GLint64EXT *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL3I64VNVPROC) (GLuint index, const GLint64EXT *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL4I64VNVPROC) (GLuint index, const GLint64EXT *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL1UI64NVPROC) (GLuint index, GLuint64EXT x);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL2UI64NVPROC) (GLuint index, GLuint64EXT x, GLuint64EXT y);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL3UI64NVPROC) (GLuint index, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL4UI64NVPROC) (GLuint index, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL1UI64VNVPROC) (GLuint index, const GLuint64EXT *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL2UI64VNVPROC) (GLuint index, const GLuint64EXT *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL3UI64VNVPROC) (GLuint index, const GLuint64EXT *v);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL4UI64VNVPROC) (GLuint index, const GLuint64EXT *v);
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBLI64VNVPROC) (GLuint index, GLenum pname, GLint64EXT *params);
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBLUI64VNVPROC) (GLuint index, GLenum pname, GLuint64EXT *params);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBLFORMATNVPROC) (GLuint index, GLint size, GLenum type, GLsizei stride);
+#endif
+
+#ifndef GL_NV_multisample_coverage
+#define GL_NV_multisample_coverage 1
+#endif
+
+#ifndef GL_AMD_name_gen_delete
+#define GL_AMD_name_gen_delete 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glGenNamesAMD (GLenum identifier, GLuint num, GLuint *names);
+GLAPI void APIENTRY glDeleteNamesAMD (GLenum identifier, GLuint num, const GLuint *names);
+GLAPI GLboolean APIENTRY glIsNameAMD (GLenum identifier, GLuint name);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLGENNAMESAMDPROC) (GLenum identifier, GLuint num, GLuint *names);
+typedef void (APIENTRYP PFNGLDELETENAMESAMDPROC) (GLenum identifier, GLuint num, const GLuint *names);
+typedef GLboolean (APIENTRYP PFNGLISNAMEAMDPROC) (GLenum identifier, GLuint name);
+#endif
+
+#ifndef GL_AMD_debug_output
+#define GL_AMD_debug_output 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glDebugMessageEnableAMD (GLenum category, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled);
+GLAPI void APIENTRY glDebugMessageInsertAMD (GLenum category, GLenum severity, GLuint id, GLsizei length, const GLchar *buf);
+GLAPI void APIENTRY glDebugMessageCallbackAMD (GLDEBUGPROCAMD callback, GLvoid *userParam);
+GLAPI GLuint APIENTRY glGetDebugMessageLogAMD (GLuint count, GLsizei bufsize, GLenum *categories, GLuint *severities, GLuint *ids, GLsizei *lengths, GLchar *message);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLDEBUGMESSAGEENABLEAMDPROC) (GLenum category, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled);
+typedef void (APIENTRYP PFNGLDEBUGMESSAGEINSERTAMDPROC) (GLenum category, GLenum severity, GLuint id, GLsizei length, const GLchar *buf);
+typedef void (APIENTRYP PFNGLDEBUGMESSAGECALLBACKAMDPROC) (GLDEBUGPROCAMD callback, GLvoid *userParam);
+typedef GLuint (APIENTRYP PFNGLGETDEBUGMESSAGELOGAMDPROC) (GLuint count, GLsizei bufsize, GLenum *categories, GLuint *severities, GLuint *ids, GLsizei *lengths, GLchar *message);
+#endif
+
+#ifndef GL_NV_vdpau_interop
+#define GL_NV_vdpau_interop 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glVDPAUInitNV (const GLvoid *vdpDevice, const GLvoid *getProcAddress);
+GLAPI void APIENTRY glVDPAUFiniNV (void);
+GLAPI GLvdpauSurfaceNV APIENTRY glVDPAURegisterVideoSurfaceNV (GLvoid *vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint *textureNames);
+GLAPI GLvdpauSurfaceNV APIENTRY glVDPAURegisterOutputSurfaceNV (GLvoid *vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint *textureNames);
+GLAPI void APIENTRY glVDPAUIsSurfaceNV (GLvdpauSurfaceNV surface);
+GLAPI void APIENTRY glVDPAUUnregisterSurfaceNV (GLvdpauSurfaceNV surface);
+GLAPI void APIENTRY glVDPAUGetSurfaceivNV (GLvdpauSurfaceNV surface, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
+GLAPI void APIENTRY glVDPAUSurfaceAccessNV (GLvdpauSurfaceNV surface, GLenum access);
+GLAPI void APIENTRY glVDPAUMapSurfacesNV (GLsizei numSurfaces, const GLvdpauSurfaceNV *surfaces);
+GLAPI void APIENTRY glVDPAUUnmapSurfacesNV (GLsizei numSurface, const GLvdpauSurfaceNV *surfaces);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRYP PFNGLVDPAUINITNVPROC) (const GLvoid *vdpDevice, const GLvoid *getProcAddress);
+typedef void (APIENTRYP PFNGLVDPAUFININVPROC) (void);
+typedef GLvdpauSurfaceNV (APIENTRYP PFNGLVDPAUREGISTERVIDEOSURFACENVPROC) (GLvoid *vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint *textureNames);
+typedef GLvdpauSurfaceNV (APIENTRYP PFNGLVDPAUREGISTEROUTPUTSURFACENVPROC) (GLvoid *vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint *textureNames);
+typedef void (APIENTRYP PFNGLVDPAUISSURFACENVPROC) (GLvdpauSurfaceNV surface);
+typedef void (APIENTRYP PFNGLVDPAUUNREGISTERSURFACENVPROC) (GLvdpauSurfaceNV surface);
+typedef void (APIENTRYP PFNGLVDPAUGETSURFACEIVNVPROC) (GLvdpauSurfaceNV surface, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
+typedef void (APIENTRYP PFNGLVDPAUSURFACEACCESSNVPROC) (GLvdpauSurfaceNV surface, GLenum access);
+typedef void (APIENTRYP PFNGLVDPAUMAPSURFACESNVPROC) (GLsizei numSurfaces, const GLvdpauSurfaceNV *surfaces);
+typedef void (APIENTRYP PFNGLVDPAUUNMAPSURFACESNVPROC) (GLsizei numSurface, const GLvdpauSurfaceNV *surfaces);
+#endif
+
+#ifndef GL_AMD_transform_feedback3_lines_triangles
+#define GL_AMD_transform_feedback3_lines_triangles 1
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/engine/inc/GL/wglext.h b/engine/inc/GL/wglext.h
new file mode 100644
index 00000000..22fd372b
--- /dev/null
+++ b/engine/inc/GL/wglext.h
@@ -0,0 +1,901 @@
+#ifndef __wglext_h_
+#define __wglext_h_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2007-2010 The Khronos Group Inc.
+** 
+** Permission is hereby granted, free of charge, to any person obtaining a
+** copy of this software and/or associated documentation files (the
+** "Materials"), to deal in the Materials without restriction, including
+** without limitation the rights to use, copy, modify, merge, publish,
+** distribute, sublicense, and/or sell copies of the Materials, and to
+** permit persons to whom the Materials are 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 Materials.
+** 
+** THE MATERIALS ARE 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
+** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+*/
+
+/* Function declaration macros - to move into glplatform.h */
+
+#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__)
+#define WIN32_LEAN_AND_MEAN 1
+#include <windows.h>
+#endif
+
+#ifndef APIENTRY
+#define APIENTRY
+#endif
+#ifndef APIENTRYP
+#define APIENTRYP APIENTRY *
+#endif
+#ifndef GLAPI
+#define GLAPI extern
+#endif
+
+/*************************************************************/
+
+/* Header file version number */
+/* wglext.h last updated 2010/08/06 */
+/* Current version at http://www.opengl.org/registry/ */
+#define WGL_WGLEXT_VERSION 22
+
+#ifndef WGL_ARB_buffer_region
+#define WGL_FRONT_COLOR_BUFFER_BIT_ARB 0x00000001
+#define WGL_BACK_COLOR_BUFFER_BIT_ARB  0x00000002
+#define WGL_DEPTH_BUFFER_BIT_ARB       0x00000004
+#define WGL_STENCIL_BUFFER_BIT_ARB     0x00000008
+#endif
+
+#ifndef WGL_ARB_multisample
+#define WGL_SAMPLE_BUFFERS_ARB         0x2041
+#define WGL_SAMPLES_ARB                0x2042
+#endif
+
+#ifndef WGL_ARB_extensions_string
+#endif
+
+#ifndef WGL_ARB_pixel_format
+#define WGL_NUMBER_PIXEL_FORMATS_ARB   0x2000
+#define WGL_DRAW_TO_WINDOW_ARB         0x2001
+#define WGL_DRAW_TO_BITMAP_ARB         0x2002
+#define WGL_ACCELERATION_ARB           0x2003
+#define WGL_NEED_PALETTE_ARB           0x2004
+#define WGL_NEED_SYSTEM_PALETTE_ARB    0x2005
+#define WGL_SWAP_LAYER_BUFFERS_ARB     0x2006
+#define WGL_SWAP_METHOD_ARB            0x2007
+#define WGL_NUMBER_OVERLAYS_ARB        0x2008
+#define WGL_NUMBER_UNDERLAYS_ARB       0x2009
+#define WGL_TRANSPARENT_ARB            0x200A
+#define WGL_TRANSPARENT_RED_VALUE_ARB  0x2037
+#define WGL_TRANSPARENT_GREEN_VALUE_ARB 0x2038
+#define WGL_TRANSPARENT_BLUE_VALUE_ARB 0x2039
+#define WGL_TRANSPARENT_ALPHA_VALUE_ARB 0x203A
+#define WGL_TRANSPARENT_INDEX_VALUE_ARB 0x203B
+#define WGL_SHARE_DEPTH_ARB            0x200C
+#define WGL_SHARE_STENCIL_ARB          0x200D
+#define WGL_SHARE_ACCUM_ARB            0x200E
+#define WGL_SUPPORT_GDI_ARB            0x200F
+#define WGL_SUPPORT_OPENGL_ARB         0x2010
+#define WGL_DOUBLE_BUFFER_ARB          0x2011
+#define WGL_STEREO_ARB                 0x2012
+#define WGL_PIXEL_TYPE_ARB             0x2013
+#define WGL_COLOR_BITS_ARB             0x2014
+#define WGL_RED_BITS_ARB               0x2015
+#define WGL_RED_SHIFT_ARB              0x2016
+#define WGL_GREEN_BITS_ARB             0x2017
+#define WGL_GREEN_SHIFT_ARB            0x2018
+#define WGL_BLUE_BITS_ARB              0x2019
+#define WGL_BLUE_SHIFT_ARB             0x201A
+#define WGL_ALPHA_BITS_ARB             0x201B
+#define WGL_ALPHA_SHIFT_ARB            0x201C
+#define WGL_ACCUM_BITS_ARB             0x201D
+#define WGL_ACCUM_RED_BITS_ARB         0x201E
+#define WGL_ACCUM_GREEN_BITS_ARB       0x201F
+#define WGL_ACCUM_BLUE_BITS_ARB        0x2020
+#define WGL_ACCUM_ALPHA_BITS_ARB       0x2021
+#define WGL_DEPTH_BITS_ARB             0x2022
+#define WGL_STENCIL_BITS_ARB           0x2023
+#define WGL_AUX_BUFFERS_ARB            0x2024
+#define WGL_NO_ACCELERATION_ARB        0x2025
+#define WGL_GENERIC_ACCELERATION_ARB   0x2026
+#define WGL_FULL_ACCELERATION_ARB      0x2027
+#define WGL_SWAP_EXCHANGE_ARB          0x2028
+#define WGL_SWAP_COPY_ARB              0x2029
+#define WGL_SWAP_UNDEFINED_ARB         0x202A
+#define WGL_TYPE_RGBA_ARB              0x202B
+#define WGL_TYPE_COLORINDEX_ARB        0x202C
+#endif
+
+#ifndef WGL_ARB_make_current_read
+#define ERROR_INVALID_PIXEL_TYPE_ARB   0x2043
+#define ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB 0x2054
+#endif
+
+#ifndef WGL_ARB_pbuffer
+#define WGL_DRAW_TO_PBUFFER_ARB        0x202D
+#define WGL_MAX_PBUFFER_PIXELS_ARB     0x202E
+#define WGL_MAX_PBUFFER_WIDTH_ARB      0x202F
+#define WGL_MAX_PBUFFER_HEIGHT_ARB     0x2030
+#define WGL_PBUFFER_LARGEST_ARB        0x2033
+#define WGL_PBUFFER_WIDTH_ARB          0x2034
+#define WGL_PBUFFER_HEIGHT_ARB         0x2035
+#define WGL_PBUFFER_LOST_ARB           0x2036
+#endif
+
+#ifndef WGL_ARB_render_texture
+#define WGL_BIND_TO_TEXTURE_RGB_ARB    0x2070
+#define WGL_BIND_TO_TEXTURE_RGBA_ARB   0x2071
+#define WGL_TEXTURE_FORMAT_ARB         0x2072
+#define WGL_TEXTURE_TARGET_ARB         0x2073
+#define WGL_MIPMAP_TEXTURE_ARB         0x2074
+#define WGL_TEXTURE_RGB_ARB            0x2075
+#define WGL_TEXTURE_RGBA_ARB           0x2076
+#define WGL_NO_TEXTURE_ARB             0x2077
+#define WGL_TEXTURE_CUBE_MAP_ARB       0x2078
+#define WGL_TEXTURE_1D_ARB             0x2079
+#define WGL_TEXTURE_2D_ARB             0x207A
+#define WGL_MIPMAP_LEVEL_ARB           0x207B
+#define WGL_CUBE_MAP_FACE_ARB          0x207C
+#define WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x207D
+#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x207E
+#define WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x207F
+#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x2080
+#define WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x2081
+#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB 0x2082
+#define WGL_FRONT_LEFT_ARB             0x2083
+#define WGL_FRONT_RIGHT_ARB            0x2084
+#define WGL_BACK_LEFT_ARB              0x2085
+#define WGL_BACK_RIGHT_ARB             0x2086
+#define WGL_AUX0_ARB                   0x2087
+#define WGL_AUX1_ARB                   0x2088
+#define WGL_AUX2_ARB                   0x2089
+#define WGL_AUX3_ARB                   0x208A
+#define WGL_AUX4_ARB                   0x208B
+#define WGL_AUX5_ARB                   0x208C
+#define WGL_AUX6_ARB                   0x208D
+#define WGL_AUX7_ARB                   0x208E
+#define WGL_AUX8_ARB                   0x208F
+#define WGL_AUX9_ARB                   0x2090
+#endif
+
+#ifndef WGL_ARB_pixel_format_float
+#define WGL_TYPE_RGBA_FLOAT_ARB        0x21A0
+#endif
+
+#ifndef WGL_ARB_framebuffer_sRGB
+#define WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20A9
+#endif
+
+#ifndef WGL_ARB_create_context
+#define WGL_CONTEXT_DEBUG_BIT_ARB      0x00000001
+#define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x00000002
+#define WGL_CONTEXT_MAJOR_VERSION_ARB  0x2091
+#define WGL_CONTEXT_MINOR_VERSION_ARB  0x2092
+#define WGL_CONTEXT_LAYER_PLANE_ARB    0x2093
+#define WGL_CONTEXT_FLAGS_ARB          0x2094
+#define ERROR_INVALID_VERSION_ARB      0x2095
+#endif
+
+#ifndef WGL_ARB_create_context_profile
+#define WGL_CONTEXT_PROFILE_MASK_ARB   0x9126
+#define WGL_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001
+#define WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
+#define ERROR_INVALID_PROFILE_ARB      0x2096
+#endif
+
+#ifndef WGL_ARB_create_context_robustness
+#define WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB 0x00000004
+#define WGL_LOSE_CONTEXT_ON_RESET_ARB  0x8252
+#define WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB 0x8256
+#define WGL_NO_RESET_NOTIFICATION_ARB  0x8261
+#endif
+
+#ifndef WGL_EXT_make_current_read
+#define ERROR_INVALID_PIXEL_TYPE_EXT   0x2043
+#endif
+
+#ifndef WGL_EXT_pixel_format
+#define WGL_NUMBER_PIXEL_FORMATS_EXT   0x2000
+#define WGL_DRAW_TO_WINDOW_EXT         0x2001
+#define WGL_DRAW_TO_BITMAP_EXT         0x2002
+#define WGL_ACCELERATION_EXT           0x2003
+#define WGL_NEED_PALETTE_EXT           0x2004
+#define WGL_NEED_SYSTEM_PALETTE_EXT    0x2005
+#define WGL_SWAP_LAYER_BUFFERS_EXT     0x2006
+#define WGL_SWAP_METHOD_EXT            0x2007
+#define WGL_NUMBER_OVERLAYS_EXT        0x2008
+#define WGL_NUMBER_UNDERLAYS_EXT       0x2009
+#define WGL_TRANSPARENT_EXT            0x200A
+#define WGL_TRANSPARENT_VALUE_EXT      0x200B
+#define WGL_SHARE_DEPTH_EXT            0x200C
+#define WGL_SHARE_STENCIL_EXT          0x200D
+#define WGL_SHARE_ACCUM_EXT            0x200E
+#define WGL_SUPPORT_GDI_EXT            0x200F
+#define WGL_SUPPORT_OPENGL_EXT         0x2010
+#define WGL_DOUBLE_BUFFER_EXT          0x2011
+#define WGL_STEREO_EXT                 0x2012
+#define WGL_PIXEL_TYPE_EXT             0x2013
+#define WGL_COLOR_BITS_EXT             0x2014
+#define WGL_RED_BITS_EXT               0x2015
+#define WGL_RED_SHIFT_EXT              0x2016
+#define WGL_GREEN_BITS_EXT             0x2017
+#define WGL_GREEN_SHIFT_EXT            0x2018
+#define WGL_BLUE_BITS_EXT              0x2019
+#define WGL_BLUE_SHIFT_EXT             0x201A
+#define WGL_ALPHA_BITS_EXT             0x201B
+#define WGL_ALPHA_SHIFT_EXT            0x201C
+#define WGL_ACCUM_BITS_EXT             0x201D
+#define WGL_ACCUM_RED_BITS_EXT         0x201E
+#define WGL_ACCUM_GREEN_BITS_EXT       0x201F
+#define WGL_ACCUM_BLUE_BITS_EXT        0x2020
+#define WGL_ACCUM_ALPHA_BITS_EXT       0x2021
+#define WGL_DEPTH_BITS_EXT             0x2022
+#define WGL_STENCIL_BITS_EXT           0x2023
+#define WGL_AUX_BUFFERS_EXT            0x2024
+#define WGL_NO_ACCELERATION_EXT        0x2025
+#define WGL_GENERIC_ACCELERATION_EXT   0x2026
+#define WGL_FULL_ACCELERATION_EXT      0x2027
+#define WGL_SWAP_EXCHANGE_EXT          0x2028
+#define WGL_SWAP_COPY_EXT              0x2029
+#define WGL_SWAP_UNDEFINED_EXT         0x202A
+#define WGL_TYPE_RGBA_EXT              0x202B
+#define WGL_TYPE_COLORINDEX_EXT        0x202C
+#endif
+
+#ifndef WGL_EXT_pbuffer
+#define WGL_DRAW_TO_PBUFFER_EXT        0x202D
+#define WGL_MAX_PBUFFER_PIXELS_EXT     0x202E
+#define WGL_MAX_PBUFFER_WIDTH_EXT      0x202F
+#define WGL_MAX_PBUFFER_HEIGHT_EXT     0x2030
+#define WGL_OPTIMAL_PBUFFER_WIDTH_EXT  0x2031
+#define WGL_OPTIMAL_PBUFFER_HEIGHT_EXT 0x2032
+#define WGL_PBUFFER_LARGEST_EXT        0x2033
+#define WGL_PBUFFER_WIDTH_EXT          0x2034
+#define WGL_PBUFFER_HEIGHT_EXT         0x2035
+#endif
+
+#ifndef WGL_EXT_depth_float
+#define WGL_DEPTH_FLOAT_EXT            0x2040
+#endif
+
+#ifndef WGL_3DFX_multisample
+#define WGL_SAMPLE_BUFFERS_3DFX        0x2060
+#define WGL_SAMPLES_3DFX               0x2061
+#endif
+
+#ifndef WGL_EXT_multisample
+#define WGL_SAMPLE_BUFFERS_EXT         0x2041
+#define WGL_SAMPLES_EXT                0x2042
+#endif
+
+#ifndef WGL_I3D_digital_video_control
+#define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D 0x2050
+#define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D 0x2051
+#define WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D 0x2052
+#define WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D 0x2053
+#endif
+
+#ifndef WGL_I3D_gamma
+#define WGL_GAMMA_TABLE_SIZE_I3D       0x204E
+#define WGL_GAMMA_EXCLUDE_DESKTOP_I3D  0x204F
+#endif
+
+#ifndef WGL_I3D_genlock
+#define WGL_GENLOCK_SOURCE_MULTIVIEW_I3D 0x2044
+#define WGL_GENLOCK_SOURCE_EXTENAL_SYNC_I3D 0x2045
+#define WGL_GENLOCK_SOURCE_EXTENAL_FIELD_I3D 0x2046
+#define WGL_GENLOCK_SOURCE_EXTENAL_TTL_I3D 0x2047
+#define WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D 0x2048
+#define WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D 0x2049
+#define WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D 0x204A
+#define WGL_GENLOCK_SOURCE_EDGE_RISING_I3D 0x204B
+#define WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D 0x204C
+#endif
+
+#ifndef WGL_I3D_image_buffer
+#define WGL_IMAGE_BUFFER_MIN_ACCESS_I3D 0x00000001
+#define WGL_IMAGE_BUFFER_LOCK_I3D      0x00000002
+#endif
+
+#ifndef WGL_I3D_swap_frame_lock
+#endif
+
+#ifndef WGL_NV_render_depth_texture
+#define WGL_BIND_TO_TEXTURE_DEPTH_NV   0x20A3
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV 0x20A4
+#define WGL_DEPTH_TEXTURE_FORMAT_NV    0x20A5
+#define WGL_TEXTURE_DEPTH_COMPONENT_NV 0x20A6
+#define WGL_DEPTH_COMPONENT_NV         0x20A7
+#endif
+
+#ifndef WGL_NV_render_texture_rectangle
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV 0x20A0
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV 0x20A1
+#define WGL_TEXTURE_RECTANGLE_NV       0x20A2
+#endif
+
+#ifndef WGL_ATI_pixel_format_float
+#define WGL_TYPE_RGBA_FLOAT_ATI        0x21A0
+#endif
+
+#ifndef WGL_NV_float_buffer
+#define WGL_FLOAT_COMPONENTS_NV        0x20B0
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV 0x20B1
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV 0x20B2
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV 0x20B3
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV 0x20B4
+#define WGL_TEXTURE_FLOAT_R_NV         0x20B5
+#define WGL_TEXTURE_FLOAT_RG_NV        0x20B6
+#define WGL_TEXTURE_FLOAT_RGB_NV       0x20B7
+#define WGL_TEXTURE_FLOAT_RGBA_NV      0x20B8
+#endif
+
+#ifndef WGL_3DL_stereo_control
+#define WGL_STEREO_EMITTER_ENABLE_3DL  0x2055
+#define WGL_STEREO_EMITTER_DISABLE_3DL 0x2056
+#define WGL_STEREO_POLARITY_NORMAL_3DL 0x2057
+#define WGL_STEREO_POLARITY_INVERT_3DL 0x2058
+#endif
+
+#ifndef WGL_EXT_pixel_format_packed_float
+#define WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT 0x20A8
+#endif
+
+#ifndef WGL_EXT_framebuffer_sRGB
+#define WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT 0x20A9
+#endif
+
+#ifndef WGL_NV_present_video
+#define WGL_NUM_VIDEO_SLOTS_NV         0x20F0
+#endif
+
+#ifndef WGL_NV_video_out
+#define WGL_BIND_TO_VIDEO_RGB_NV       0x20C0
+#define WGL_BIND_TO_VIDEO_RGBA_NV      0x20C1
+#define WGL_BIND_TO_VIDEO_RGB_AND_DEPTH_NV 0x20C2
+#define WGL_VIDEO_OUT_COLOR_NV         0x20C3
+#define WGL_VIDEO_OUT_ALPHA_NV         0x20C4
+#define WGL_VIDEO_OUT_DEPTH_NV         0x20C5
+#define WGL_VIDEO_OUT_COLOR_AND_ALPHA_NV 0x20C6
+#define WGL_VIDEO_OUT_COLOR_AND_DEPTH_NV 0x20C7
+#define WGL_VIDEO_OUT_FRAME            0x20C8
+#define WGL_VIDEO_OUT_FIELD_1          0x20C9
+#define WGL_VIDEO_OUT_FIELD_2          0x20CA
+#define WGL_VIDEO_OUT_STACKED_FIELDS_1_2 0x20CB
+#define WGL_VIDEO_OUT_STACKED_FIELDS_2_1 0x20CC
+#endif
+
+#ifndef WGL_NV_swap_group
+#endif
+
+#ifndef WGL_NV_gpu_affinity
+#define WGL_ERROR_INCOMPATIBLE_AFFINITY_MASKS_NV 0x20D0
+#define WGL_ERROR_MISSING_AFFINITY_MASK_NV 0x20D1
+#endif
+
+#ifndef WGL_AMD_gpu_association
+#define WGL_GPU_VENDOR_AMD             0x1F00
+#define WGL_GPU_RENDERER_STRING_AMD    0x1F01
+#define WGL_GPU_OPENGL_VERSION_STRING_AMD 0x1F02
+#define WGL_GPU_FASTEST_TARGET_GPUS_AMD 0x21A2
+#define WGL_GPU_RAM_AMD                0x21A3
+#define WGL_GPU_CLOCK_AMD              0x21A4
+#define WGL_GPU_NUM_PIPES_AMD          0x21A5
+#define WGL_GPU_NUM_SIMD_AMD           0x21A6
+#define WGL_GPU_NUM_RB_AMD             0x21A7
+#define WGL_GPU_NUM_SPI_AMD            0x21A8
+#endif
+
+#ifndef WGL_NV_video_capture
+#define WGL_UNIQUE_ID_NV               0x20CE
+#define WGL_NUM_VIDEO_CAPTURE_SLOTS_NV 0x20CF
+#endif
+
+#ifndef WGL_NV_copy_image
+#endif
+
+#ifndef WGL_NV_multisample_coverage
+#define WGL_COVERAGE_SAMPLES_NV        0x2042
+#define WGL_COLOR_SAMPLES_NV           0x20B9
+#endif
+
+#ifndef WGL_EXT_create_context_es2_profile
+#define WGL_CONTEXT_ES2_PROFILE_BIT_EXT 0x00000004
+#endif
+
+
+/*************************************************************/
+
+#ifndef WGL_ARB_pbuffer
+DECLARE_HANDLE(HPBUFFERARB);
+#endif
+#ifndef WGL_EXT_pbuffer
+DECLARE_HANDLE(HPBUFFEREXT);
+#endif
+#ifndef WGL_NV_present_video
+DECLARE_HANDLE(HVIDEOOUTPUTDEVICENV);
+#endif
+#ifndef WGL_NV_video_output
+DECLARE_HANDLE(HPVIDEODEV);
+#endif
+#ifndef WGL_NV_gpu_affinity
+DECLARE_HANDLE(HPGPUNV);
+DECLARE_HANDLE(HGPUNV);
+
+typedef struct _GPU_DEVICE {
+    DWORD  cb;
+    CHAR   DeviceName[32];
+    CHAR   DeviceString[128];
+    DWORD  Flags;
+    RECT   rcVirtualScreen;
+} GPU_DEVICE, *PGPU_DEVICE;
+#endif
+#ifndef WGL_NV_video_capture
+DECLARE_HANDLE(HVIDEOINPUTDEVICENV);
+#endif
+
+#ifndef WGL_ARB_buffer_region
+#define WGL_ARB_buffer_region 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern HANDLE WINAPI wglCreateBufferRegionARB (HDC hDC, int iLayerPlane, UINT uType);
+extern VOID WINAPI wglDeleteBufferRegionARB (HANDLE hRegion);
+extern BOOL WINAPI wglSaveBufferRegionARB (HANDLE hRegion, int x, int y, int width, int height);
+extern BOOL WINAPI wglRestoreBufferRegionARB (HANDLE hRegion, int x, int y, int width, int height, int xSrc, int ySrc);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef HANDLE (WINAPI * PFNWGLCREATEBUFFERREGIONARBPROC) (HDC hDC, int iLayerPlane, UINT uType);
+typedef VOID (WINAPI * PFNWGLDELETEBUFFERREGIONARBPROC) (HANDLE hRegion);
+typedef BOOL (WINAPI * PFNWGLSAVEBUFFERREGIONARBPROC) (HANDLE hRegion, int x, int y, int width, int height);
+typedef BOOL (WINAPI * PFNWGLRESTOREBUFFERREGIONARBPROC) (HANDLE hRegion, int x, int y, int width, int height, int xSrc, int ySrc);
+#endif
+
+#ifndef WGL_ARB_multisample
+#define WGL_ARB_multisample 1
+#endif
+
+#ifndef WGL_ARB_extensions_string
+#define WGL_ARB_extensions_string 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern const char * WINAPI wglGetExtensionsStringARB (HDC hdc);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef const char * (WINAPI * PFNWGLGETEXTENSIONSSTRINGARBPROC) (HDC hdc);
+#endif
+
+#ifndef WGL_ARB_pixel_format
+#define WGL_ARB_pixel_format 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglGetPixelFormatAttribivARB (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues);
+extern BOOL WINAPI wglGetPixelFormatAttribfvARB (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues);
+extern BOOL WINAPI wglChoosePixelFormatARB (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBIVARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues);
+typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBFVARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues);
+typedef BOOL (WINAPI * PFNWGLCHOOSEPIXELFORMATARBPROC) (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
+#endif
+
+#ifndef WGL_ARB_make_current_read
+#define WGL_ARB_make_current_read 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglMakeContextCurrentARB (HDC hDrawDC, HDC hReadDC, HGLRC hglrc);
+extern HDC WINAPI wglGetCurrentReadDCARB (void);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI * PFNWGLMAKECONTEXTCURRENTARBPROC) (HDC hDrawDC, HDC hReadDC, HGLRC hglrc);
+typedef HDC (WINAPI * PFNWGLGETCURRENTREADDCARBPROC) (void);
+#endif
+
+#ifndef WGL_ARB_pbuffer
+#define WGL_ARB_pbuffer 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern HPBUFFERARB WINAPI wglCreatePbufferARB (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
+extern HDC WINAPI wglGetPbufferDCARB (HPBUFFERARB hPbuffer);
+extern int WINAPI wglReleasePbufferDCARB (HPBUFFERARB hPbuffer, HDC hDC);
+extern BOOL WINAPI wglDestroyPbufferARB (HPBUFFERARB hPbuffer);
+extern BOOL WINAPI wglQueryPbufferARB (HPBUFFERARB hPbuffer, int iAttribute, int *piValue);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef HPBUFFERARB (WINAPI * PFNWGLCREATEPBUFFERARBPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
+typedef HDC (WINAPI * PFNWGLGETPBUFFERDCARBPROC) (HPBUFFERARB hPbuffer);
+typedef int (WINAPI * PFNWGLRELEASEPBUFFERDCARBPROC) (HPBUFFERARB hPbuffer, HDC hDC);
+typedef BOOL (WINAPI * PFNWGLDESTROYPBUFFERARBPROC) (HPBUFFERARB hPbuffer);
+typedef BOOL (WINAPI * PFNWGLQUERYPBUFFERARBPROC) (HPBUFFERARB hPbuffer, int iAttribute, int *piValue);
+#endif
+
+#ifndef WGL_ARB_render_texture
+#define WGL_ARB_render_texture 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglBindTexImageARB (HPBUFFERARB hPbuffer, int iBuffer);
+extern BOOL WINAPI wglReleaseTexImageARB (HPBUFFERARB hPbuffer, int iBuffer);
+extern BOOL WINAPI wglSetPbufferAttribARB (HPBUFFERARB hPbuffer, const int *piAttribList);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI * PFNWGLBINDTEXIMAGEARBPROC) (HPBUFFERARB hPbuffer, int iBuffer);
+typedef BOOL (WINAPI * PFNWGLRELEASETEXIMAGEARBPROC) (HPBUFFERARB hPbuffer, int iBuffer);
+typedef BOOL (WINAPI * PFNWGLSETPBUFFERATTRIBARBPROC) (HPBUFFERARB hPbuffer, const int *piAttribList);
+#endif
+
+#ifndef WGL_ARB_pixel_format_float
+#define WGL_ARB_pixel_format_float 1
+#endif
+
+#ifndef WGL_ARB_framebuffer_sRGB
+#define WGL_ARB_framebuffer_sRGB 1
+#endif
+
+#ifndef WGL_ARB_create_context
+#define WGL_ARB_create_context 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern HGLRC WINAPI wglCreateContextAttribsARB (HDC hDC, HGLRC hShareContext, const int *attribList);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef HGLRC (WINAPI * PFNWGLCREATECONTEXTATTRIBSARBPROC) (HDC hDC, HGLRC hShareContext, const int *attribList);
+#endif
+
+#ifndef WGL_ARB_create_context_profile
+#define WGL_ARB_create_context_profile 1
+#endif
+
+#ifndef WGL_ARB_create_context_robustness
+#define WGL_ARB_create_context_robustness 1
+#endif
+
+#ifndef WGL_EXT_display_color_table
+#define WGL_EXT_display_color_table 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern GLboolean WINAPI wglCreateDisplayColorTableEXT (GLushort id);
+extern GLboolean WINAPI wglLoadDisplayColorTableEXT (const GLushort *table, GLuint length);
+extern GLboolean WINAPI wglBindDisplayColorTableEXT (GLushort id);
+extern VOID WINAPI wglDestroyDisplayColorTableEXT (GLushort id);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef GLboolean (WINAPI * PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC) (GLushort id);
+typedef GLboolean (WINAPI * PFNWGLLOADDISPLAYCOLORTABLEEXTPROC) (const GLushort *table, GLuint length);
+typedef GLboolean (WINAPI * PFNWGLBINDDISPLAYCOLORTABLEEXTPROC) (GLushort id);
+typedef VOID (WINAPI * PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC) (GLushort id);
+#endif
+
+#ifndef WGL_EXT_extensions_string
+#define WGL_EXT_extensions_string 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern const char * WINAPI wglGetExtensionsStringEXT (void);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef const char * (WINAPI * PFNWGLGETEXTENSIONSSTRINGEXTPROC) (void);
+#endif
+
+#ifndef WGL_EXT_make_current_read
+#define WGL_EXT_make_current_read 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglMakeContextCurrentEXT (HDC hDrawDC, HDC hReadDC, HGLRC hglrc);
+extern HDC WINAPI wglGetCurrentReadDCEXT (void);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI * PFNWGLMAKECONTEXTCURRENTEXTPROC) (HDC hDrawDC, HDC hReadDC, HGLRC hglrc);
+typedef HDC (WINAPI * PFNWGLGETCURRENTREADDCEXTPROC) (void);
+#endif
+
+#ifndef WGL_EXT_pbuffer
+#define WGL_EXT_pbuffer 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern HPBUFFEREXT WINAPI wglCreatePbufferEXT (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
+extern HDC WINAPI wglGetPbufferDCEXT (HPBUFFEREXT hPbuffer);
+extern int WINAPI wglReleasePbufferDCEXT (HPBUFFEREXT hPbuffer, HDC hDC);
+extern BOOL WINAPI wglDestroyPbufferEXT (HPBUFFEREXT hPbuffer);
+extern BOOL WINAPI wglQueryPbufferEXT (HPBUFFEREXT hPbuffer, int iAttribute, int *piValue);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef HPBUFFEREXT (WINAPI * PFNWGLCREATEPBUFFEREXTPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
+typedef HDC (WINAPI * PFNWGLGETPBUFFERDCEXTPROC) (HPBUFFEREXT hPbuffer);
+typedef int (WINAPI * PFNWGLRELEASEPBUFFERDCEXTPROC) (HPBUFFEREXT hPbuffer, HDC hDC);
+typedef BOOL (WINAPI * PFNWGLDESTROYPBUFFEREXTPROC) (HPBUFFEREXT hPbuffer);
+typedef BOOL (WINAPI * PFNWGLQUERYPBUFFEREXTPROC) (HPBUFFEREXT hPbuffer, int iAttribute, int *piValue);
+#endif
+
+#ifndef WGL_EXT_pixel_format
+#define WGL_EXT_pixel_format 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglGetPixelFormatAttribivEXT (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, int *piValues);
+extern BOOL WINAPI wglGetPixelFormatAttribfvEXT (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, FLOAT *pfValues);
+extern BOOL WINAPI wglChoosePixelFormatEXT (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBIVEXTPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, int *piValues);
+typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBFVEXTPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, FLOAT *pfValues);
+typedef BOOL (WINAPI * PFNWGLCHOOSEPIXELFORMATEXTPROC) (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
+#endif
+
+#ifndef WGL_EXT_swap_control
+#define WGL_EXT_swap_control 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglSwapIntervalEXT (int interval);
+extern int WINAPI wglGetSwapIntervalEXT (void);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI * PFNWGLSWAPINTERVALEXTPROC) (int interval);
+typedef int (WINAPI * PFNWGLGETSWAPINTERVALEXTPROC) (void);
+#endif
+
+#ifndef WGL_EXT_depth_float
+#define WGL_EXT_depth_float 1
+#endif
+
+#ifndef WGL_NV_vertex_array_range
+#define WGL_NV_vertex_array_range 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern void* WINAPI wglAllocateMemoryNV (GLsizei size, GLfloat readfreq, GLfloat writefreq, GLfloat priority);
+extern void WINAPI wglFreeMemoryNV (void *pointer);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef void* (WINAPI * PFNWGLALLOCATEMEMORYNVPROC) (GLsizei size, GLfloat readfreq, GLfloat writefreq, GLfloat priority);
+typedef void (WINAPI * PFNWGLFREEMEMORYNVPROC) (void *pointer);
+#endif
+
+#ifndef WGL_3DFX_multisample
+#define WGL_3DFX_multisample 1
+#endif
+
+#ifndef WGL_EXT_multisample
+#define WGL_EXT_multisample 1
+#endif
+
+#ifndef WGL_OML_sync_control
+#define WGL_OML_sync_control 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglGetSyncValuesOML (HDC hdc, INT64 *ust, INT64 *msc, INT64 *sbc);
+extern BOOL WINAPI wglGetMscRateOML (HDC hdc, INT32 *numerator, INT32 *denominator);
+extern INT64 WINAPI wglSwapBuffersMscOML (HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder);
+extern INT64 WINAPI wglSwapLayerBuffersMscOML (HDC hdc, int fuPlanes, INT64 target_msc, INT64 divisor, INT64 remainder);
+extern BOOL WINAPI wglWaitForMscOML (HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder, INT64 *ust, INT64 *msc, INT64 *sbc);
+extern BOOL WINAPI wglWaitForSbcOML (HDC hdc, INT64 target_sbc, INT64 *ust, INT64 *msc, INT64 *sbc);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI * PFNWGLGETSYNCVALUESOMLPROC) (HDC hdc, INT64 *ust, INT64 *msc, INT64 *sbc);
+typedef BOOL (WINAPI * PFNWGLGETMSCRATEOMLPROC) (HDC hdc, INT32 *numerator, INT32 *denominator);
+typedef INT64 (WINAPI * PFNWGLSWAPBUFFERSMSCOMLPROC) (HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder);
+typedef INT64 (WINAPI * PFNWGLSWAPLAYERBUFFERSMSCOMLPROC) (HDC hdc, int fuPlanes, INT64 target_msc, INT64 divisor, INT64 remainder);
+typedef BOOL (WINAPI * PFNWGLWAITFORMSCOMLPROC) (HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder, INT64 *ust, INT64 *msc, INT64 *sbc);
+typedef BOOL (WINAPI * PFNWGLWAITFORSBCOMLPROC) (HDC hdc, INT64 target_sbc, INT64 *ust, INT64 *msc, INT64 *sbc);
+#endif
+
+#ifndef WGL_I3D_digital_video_control
+#define WGL_I3D_digital_video_control 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglGetDigitalVideoParametersI3D (HDC hDC, int iAttribute, int *piValue);
+extern BOOL WINAPI wglSetDigitalVideoParametersI3D (HDC hDC, int iAttribute, const int *piValue);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI * PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC) (HDC hDC, int iAttribute, int *piValue);
+typedef BOOL (WINAPI * PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC) (HDC hDC, int iAttribute, const int *piValue);
+#endif
+
+#ifndef WGL_I3D_gamma
+#define WGL_I3D_gamma 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglGetGammaTableParametersI3D (HDC hDC, int iAttribute, int *piValue);
+extern BOOL WINAPI wglSetGammaTableParametersI3D (HDC hDC, int iAttribute, const int *piValue);
+extern BOOL WINAPI wglGetGammaTableI3D (HDC hDC, int iEntries, USHORT *puRed, USHORT *puGreen, USHORT *puBlue);
+extern BOOL WINAPI wglSetGammaTableI3D (HDC hDC, int iEntries, const USHORT *puRed, const USHORT *puGreen, const USHORT *puBlue);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI * PFNWGLGETGAMMATABLEPARAMETERSI3DPROC) (HDC hDC, int iAttribute, int *piValue);
+typedef BOOL (WINAPI * PFNWGLSETGAMMATABLEPARAMETERSI3DPROC) (HDC hDC, int iAttribute, const int *piValue);
+typedef BOOL (WINAPI * PFNWGLGETGAMMATABLEI3DPROC) (HDC hDC, int iEntries, USHORT *puRed, USHORT *puGreen, USHORT *puBlue);
+typedef BOOL (WINAPI * PFNWGLSETGAMMATABLEI3DPROC) (HDC hDC, int iEntries, const USHORT *puRed, const USHORT *puGreen, const USHORT *puBlue);
+#endif
+
+#ifndef WGL_I3D_genlock
+#define WGL_I3D_genlock 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglEnableGenlockI3D (HDC hDC);
+extern BOOL WINAPI wglDisableGenlockI3D (HDC hDC);
+extern BOOL WINAPI wglIsEnabledGenlockI3D (HDC hDC, BOOL *pFlag);
+extern BOOL WINAPI wglGenlockSourceI3D (HDC hDC, UINT uSource);
+extern BOOL WINAPI wglGetGenlockSourceI3D (HDC hDC, UINT *uSource);
+extern BOOL WINAPI wglGenlockSourceEdgeI3D (HDC hDC, UINT uEdge);
+extern BOOL WINAPI wglGetGenlockSourceEdgeI3D (HDC hDC, UINT *uEdge);
+extern BOOL WINAPI wglGenlockSampleRateI3D (HDC hDC, UINT uRate);
+extern BOOL WINAPI wglGetGenlockSampleRateI3D (HDC hDC, UINT *uRate);
+extern BOOL WINAPI wglGenlockSourceDelayI3D (HDC hDC, UINT uDelay);
+extern BOOL WINAPI wglGetGenlockSourceDelayI3D (HDC hDC, UINT *uDelay);
+extern BOOL WINAPI wglQueryGenlockMaxSourceDelayI3D (HDC hDC, UINT *uMaxLineDelay, UINT *uMaxPixelDelay);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI * PFNWGLENABLEGENLOCKI3DPROC) (HDC hDC);
+typedef BOOL (WINAPI * PFNWGLDISABLEGENLOCKI3DPROC) (HDC hDC);
+typedef BOOL (WINAPI * PFNWGLISENABLEDGENLOCKI3DPROC) (HDC hDC, BOOL *pFlag);
+typedef BOOL (WINAPI * PFNWGLGENLOCKSOURCEI3DPROC) (HDC hDC, UINT uSource);
+typedef BOOL (WINAPI * PFNWGLGETGENLOCKSOURCEI3DPROC) (HDC hDC, UINT *uSource);
+typedef BOOL (WINAPI * PFNWGLGENLOCKSOURCEEDGEI3DPROC) (HDC hDC, UINT uEdge);
+typedef BOOL (WINAPI * PFNWGLGETGENLOCKSOURCEEDGEI3DPROC) (HDC hDC, UINT *uEdge);
+typedef BOOL (WINAPI * PFNWGLGENLOCKSAMPLERATEI3DPROC) (HDC hDC, UINT uRate);
+typedef BOOL (WINAPI * PFNWGLGETGENLOCKSAMPLERATEI3DPROC) (HDC hDC, UINT *uRate);
+typedef BOOL (WINAPI * PFNWGLGENLOCKSOURCEDELAYI3DPROC) (HDC hDC, UINT uDelay);
+typedef BOOL (WINAPI * PFNWGLGETGENLOCKSOURCEDELAYI3DPROC) (HDC hDC, UINT *uDelay);
+typedef BOOL (WINAPI * PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC) (HDC hDC, UINT *uMaxLineDelay, UINT *uMaxPixelDelay);
+#endif
+
+#ifndef WGL_I3D_image_buffer
+#define WGL_I3D_image_buffer 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern LPVOID WINAPI wglCreateImageBufferI3D (HDC hDC, DWORD dwSize, UINT uFlags);
+extern BOOL WINAPI wglDestroyImageBufferI3D (HDC hDC, LPVOID pAddress);
+extern BOOL WINAPI wglAssociateImageBufferEventsI3D (HDC hDC, const HANDLE *pEvent, const LPVOID *pAddress, const DWORD *pSize, UINT count);
+extern BOOL WINAPI wglReleaseImageBufferEventsI3D (HDC hDC, const LPVOID *pAddress, UINT count);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef LPVOID (WINAPI * PFNWGLCREATEIMAGEBUFFERI3DPROC) (HDC hDC, DWORD dwSize, UINT uFlags);
+typedef BOOL (WINAPI * PFNWGLDESTROYIMAGEBUFFERI3DPROC) (HDC hDC, LPVOID pAddress);
+typedef BOOL (WINAPI * PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC) (HDC hDC, const HANDLE *pEvent, const LPVOID *pAddress, const DWORD *pSize, UINT count);
+typedef BOOL (WINAPI * PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC) (HDC hDC, const LPVOID *pAddress, UINT count);
+#endif
+
+#ifndef WGL_I3D_swap_frame_lock
+#define WGL_I3D_swap_frame_lock 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglEnableFrameLockI3D (void);
+extern BOOL WINAPI wglDisableFrameLockI3D (void);
+extern BOOL WINAPI wglIsEnabledFrameLockI3D (BOOL *pFlag);
+extern BOOL WINAPI wglQueryFrameLockMasterI3D (BOOL *pFlag);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI * PFNWGLENABLEFRAMELOCKI3DPROC) (void);
+typedef BOOL (WINAPI * PFNWGLDISABLEFRAMELOCKI3DPROC) (void);
+typedef BOOL (WINAPI * PFNWGLISENABLEDFRAMELOCKI3DPROC) (BOOL *pFlag);
+typedef BOOL (WINAPI * PFNWGLQUERYFRAMELOCKMASTERI3DPROC) (BOOL *pFlag);
+#endif
+
+#ifndef WGL_I3D_swap_frame_usage
+#define WGL_I3D_swap_frame_usage 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglGetFrameUsageI3D (float *pUsage);
+extern BOOL WINAPI wglBeginFrameTrackingI3D (void);
+extern BOOL WINAPI wglEndFrameTrackingI3D (void);
+extern BOOL WINAPI wglQueryFrameTrackingI3D (DWORD *pFrameCount, DWORD *pMissedFrames, float *pLastMissedUsage);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI * PFNWGLGETFRAMEUSAGEI3DPROC) (float *pUsage);
+typedef BOOL (WINAPI * PFNWGLBEGINFRAMETRACKINGI3DPROC) (void);
+typedef BOOL (WINAPI * PFNWGLENDFRAMETRACKINGI3DPROC) (void);
+typedef BOOL (WINAPI * PFNWGLQUERYFRAMETRACKINGI3DPROC) (DWORD *pFrameCount, DWORD *pMissedFrames, float *pLastMissedUsage);
+#endif
+
+#ifndef WGL_ATI_pixel_format_float
+#define WGL_ATI_pixel_format_float 1
+#endif
+
+#ifndef WGL_NV_float_buffer
+#define WGL_NV_float_buffer 1
+#endif
+
+#ifndef WGL_3DL_stereo_control
+#define WGL_3DL_stereo_control 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglSetStereoEmitterState3DL (HDC hDC, UINT uState);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI * PFNWGLSETSTEREOEMITTERSTATE3DLPROC) (HDC hDC, UINT uState);
+#endif
+
+#ifndef WGL_EXT_pixel_format_packed_float
+#define WGL_EXT_pixel_format_packed_float 1
+#endif
+
+#ifndef WGL_EXT_framebuffer_sRGB
+#define WGL_EXT_framebuffer_sRGB 1
+#endif
+
+#ifndef WGL_NV_present_video
+#define WGL_NV_present_video 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern int WINAPI wglEnumerateVideoDevicesNV (HDC hDC, HVIDEOOUTPUTDEVICENV *phDeviceList);
+extern BOOL WINAPI wglBindVideoDeviceNV (HDC hDC, unsigned int uVideoSlot, HVIDEOOUTPUTDEVICENV hVideoDevice, const int *piAttribList);
+extern BOOL WINAPI wglQueryCurrentContextNV (int iAttribute, int *piValue);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef int (WINAPI * PFNWGLENUMERATEVIDEODEVICESNVPROC) (HDC hDC, HVIDEOOUTPUTDEVICENV *phDeviceList);
+typedef BOOL (WINAPI * PFNWGLBINDVIDEODEVICENVPROC) (HDC hDC, unsigned int uVideoSlot, HVIDEOOUTPUTDEVICENV hVideoDevice, const int *piAttribList);
+typedef BOOL (WINAPI * PFNWGLQUERYCURRENTCONTEXTNVPROC) (int iAttribute, int *piValue);
+#endif
+
+#ifndef WGL_NV_video_output
+#define WGL_NV_video_output 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglGetVideoDeviceNV (HDC hDC, int numDevices, HPVIDEODEV *hVideoDevice);
+extern BOOL WINAPI wglReleaseVideoDeviceNV (HPVIDEODEV hVideoDevice);
+extern BOOL WINAPI wglBindVideoImageNV (HPVIDEODEV hVideoDevice, HPBUFFERARB hPbuffer, int iVideoBuffer);
+extern BOOL WINAPI wglReleaseVideoImageNV (HPBUFFERARB hPbuffer, int iVideoBuffer);
+extern BOOL WINAPI wglSendPbufferToVideoNV (HPBUFFERARB hPbuffer, int iBufferType, unsigned long *pulCounterPbuffer, BOOL bBlock);
+extern BOOL WINAPI wglGetVideoInfoNV (HPVIDEODEV hpVideoDevice, unsigned long *pulCounterOutputPbuffer, unsigned long *pulCounterOutputVideo);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI * PFNWGLGETVIDEODEVICENVPROC) (HDC hDC, int numDevices, HPVIDEODEV *hVideoDevice);
+typedef BOOL (WINAPI * PFNWGLRELEASEVIDEODEVICENVPROC) (HPVIDEODEV hVideoDevice);
+typedef BOOL (WINAPI * PFNWGLBINDVIDEOIMAGENVPROC) (HPVIDEODEV hVideoDevice, HPBUFFERARB hPbuffer, int iVideoBuffer);
+typedef BOOL (WINAPI * PFNWGLRELEASEVIDEOIMAGENVPROC) (HPBUFFERARB hPbuffer, int iVideoBuffer);
+typedef BOOL (WINAPI * PFNWGLSENDPBUFFERTOVIDEONVPROC) (HPBUFFERARB hPbuffer, int iBufferType, unsigned long *pulCounterPbuffer, BOOL bBlock);
+typedef BOOL (WINAPI * PFNWGLGETVIDEOINFONVPROC) (HPVIDEODEV hpVideoDevice, unsigned long *pulCounterOutputPbuffer, unsigned long *pulCounterOutputVideo);
+#endif
+
+#ifndef WGL_NV_swap_group
+#define WGL_NV_swap_group 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglJoinSwapGroupNV (HDC hDC, GLuint group);
+extern BOOL WINAPI wglBindSwapBarrierNV (GLuint group, GLuint barrier);
+extern BOOL WINAPI wglQuerySwapGroupNV (HDC hDC, GLuint *group, GLuint *barrier);
+extern BOOL WINAPI wglQueryMaxSwapGroupsNV (HDC hDC, GLuint *maxGroups, GLuint *maxBarriers);
+extern BOOL WINAPI wglQueryFrameCountNV (HDC hDC, GLuint *count);
+extern BOOL WINAPI wglResetFrameCountNV (HDC hDC);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI * PFNWGLJOINSWAPGROUPNVPROC) (HDC hDC, GLuint group);
+typedef BOOL (WINAPI * PFNWGLBINDSWAPBARRIERNVPROC) (GLuint group, GLuint barrier);
+typedef BOOL (WINAPI * PFNWGLQUERYSWAPGROUPNVPROC) (HDC hDC, GLuint *group, GLuint *barrier);
+typedef BOOL (WINAPI * PFNWGLQUERYMAXSWAPGROUPSNVPROC) (HDC hDC, GLuint *maxGroups, GLuint *maxBarriers);
+typedef BOOL (WINAPI * PFNWGLQUERYFRAMECOUNTNVPROC) (HDC hDC, GLuint *count);
+typedef BOOL (WINAPI * PFNWGLRESETFRAMECOUNTNVPROC) (HDC hDC);
+#endif
+
+#ifndef WGL_NV_gpu_affinity
+#define WGL_NV_gpu_affinity 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglEnumGpusNV (UINT iGpuIndex, HGPUNV *phGpu);
+extern BOOL WINAPI wglEnumGpuDevicesNV (HGPUNV hGpu, UINT iDeviceIndex, PGPU_DEVICE lpGpuDevice);
+extern HDC WINAPI wglCreateAffinityDCNV (const HGPUNV *phGpuList);
+extern BOOL WINAPI wglEnumGpusFromAffinityDCNV (HDC hAffinityDC, UINT iGpuIndex, HGPUNV *hGpu);
+extern BOOL WINAPI wglDeleteDCNV (HDC hdc);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI * PFNWGLENUMGPUSNVPROC) (UINT iGpuIndex, HGPUNV *phGpu);
+typedef BOOL (WINAPI * PFNWGLENUMGPUDEVICESNVPROC) (HGPUNV hGpu, UINT iDeviceIndex, PGPU_DEVICE lpGpuDevice);
+typedef HDC (WINAPI * PFNWGLCREATEAFFINITYDCNVPROC) (const HGPUNV *phGpuList);
+typedef BOOL (WINAPI * PFNWGLENUMGPUSFROMAFFINITYDCNVPROC) (HDC hAffinityDC, UINT iGpuIndex, HGPUNV *hGpu);
+typedef BOOL (WINAPI * PFNWGLDELETEDCNVPROC) (HDC hdc);
+#endif
+
+#ifndef WGL_AMD_gpu_association
+#define WGL_AMD_gpu_association 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern UINT WINAPI wglGetGPUIDsAMD (UINT maxCount, UINT *ids);
+extern INT WINAPI wglGetGPUInfoAMD (UINT id, int property, GLenum dataType, UINT size, void *data);
+extern UINT WINAPI wglGetContextGPUIDAMD (HGLRC hglrc);
+extern HGLRC WINAPI wglCreateAssociatedContextAMD (UINT id);
+extern HGLRC WINAPI wglCreateAssociatedContextAttribsAMD (UINT id, HGLRC hShareContext, const int *attribList);
+extern BOOL WINAPI wglDeleteAssociatedContextAMD (HGLRC hglrc);
+extern BOOL WINAPI wglMakeAssociatedContextCurrentAMD (HGLRC hglrc);
+extern HGLRC WINAPI wglGetCurrentAssociatedContextAMD (void);
+extern VOID WINAPI wglBlitContextFramebufferAMD (HGLRC dstCtx, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef UINT (WINAPI * PFNWGLGETGPUIDSAMDPROC) (UINT maxCount, UINT *ids);
+typedef INT (WINAPI * PFNWGLGETGPUINFOAMDPROC) (UINT id, int property, GLenum dataType, UINT size, void *data);
+typedef UINT (WINAPI * PFNWGLGETCONTEXTGPUIDAMDPROC) (HGLRC hglrc);
+typedef HGLRC (WINAPI * PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC) (UINT id);
+typedef HGLRC (WINAPI * PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC) (UINT id, HGLRC hShareContext, const int *attribList);
+typedef BOOL (WINAPI * PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC) (HGLRC hglrc);
+typedef BOOL (WINAPI * PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC) (HGLRC hglrc);
+typedef HGLRC (WINAPI * PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC) (void);
+typedef VOID (WINAPI * PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC) (HGLRC dstCtx, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+#endif
+
+#ifndef WGL_NV_video_capture
+#define WGL_NV_video_capture 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglBindVideoCaptureDeviceNV (UINT uVideoSlot, HVIDEOINPUTDEVICENV hDevice);
+extern UINT WINAPI wglEnumerateVideoCaptureDevicesNV (HDC hDc, HVIDEOINPUTDEVICENV *phDeviceList);
+extern BOOL WINAPI wglLockVideoCaptureDeviceNV (HDC hDc, HVIDEOINPUTDEVICENV hDevice);
+extern BOOL WINAPI wglQueryVideoCaptureDeviceNV (HDC hDc, HVIDEOINPUTDEVICENV hDevice, int iAttribute, int *piValue);
+extern BOOL WINAPI wglReleaseVideoCaptureDeviceNV (HDC hDc, HVIDEOINPUTDEVICENV hDevice);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI * PFNWGLBINDVIDEOCAPTUREDEVICENVPROC) (UINT uVideoSlot, HVIDEOINPUTDEVICENV hDevice);
+typedef UINT (WINAPI * PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC) (HDC hDc, HVIDEOINPUTDEVICENV *phDeviceList);
+typedef BOOL (WINAPI * PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC) (HDC hDc, HVIDEOINPUTDEVICENV hDevice);
+typedef BOOL (WINAPI * PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC) (HDC hDc, HVIDEOINPUTDEVICENV hDevice, int iAttribute, int *piValue);
+typedef BOOL (WINAPI * PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC) (HDC hDc, HVIDEOINPUTDEVICENV hDevice);
+#endif
+
+#ifndef WGL_NV_copy_image
+#define WGL_NV_copy_image 1
+#ifdef WGL_WGLEXT_PROTOTYPES
+extern BOOL WINAPI wglCopyImageSubDataNV (HGLRC hSrcRC, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, HGLRC hDstRC, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth);
+#endif /* WGL_WGLEXT_PROTOTYPES */
+typedef BOOL (WINAPI * PFNWGLCOPYIMAGESUBDATANVPROC) (HGLRC hSrcRC, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, HGLRC hDstRC, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth);
+#endif
+
+#ifndef WGL_NV_multisample_coverage
+#define WGL_NV_multisample_coverage 1
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/engine/inc/GLFW/glfw3.h b/engine/inc/GLFW/glfw3.h
new file mode 100644
index 00000000..95caa955
--- /dev/null
+++ b/engine/inc/GLFW/glfw3.h
@@ -0,0 +1,4248 @@
+/*************************************************************************
+ * GLFW 3.2 - www.glfw.org
+ * A library for OpenGL, window and input
+ *------------------------------------------------------------------------
+ * Copyright (c) 2002-2006 Marcus Geelnard
+ * Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would
+ *    be appreciated but is not required.
+ *
+ * 2. Altered source versions must be plainly marked as such, and must not
+ *    be misrepresented as being the original software.
+ *
+ * 3. This notice may not be removed or altered from any source
+ *    distribution.
+ *
+ *************************************************************************/
+
+#ifndef _glfw3_h_
+#define _glfw3_h_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*************************************************************************
+ * Doxygen documentation
+ *************************************************************************/
+
+/*! @file glfw3.h
+ *  @brief The header of the GLFW 3 API.
+ *
+ *  This is the header file of the GLFW 3 API.  It defines all its types and
+ *  declares all its functions.
+ *
+ *  For more information about how to use this file, see @ref build_include.
+ */
+/*! @defgroup context Context reference
+ *
+ *  This is the reference documentation for OpenGL and OpenGL ES context related
+ *  functions.  For more task-oriented information, see the @ref context_guide.
+ */
+/*! @defgroup vulkan Vulkan reference
+ *
+ *  This is the reference documentation for Vulkan related functions and types.
+ *  For more task-oriented information, see the @ref vulkan_guide.
+ */
+/*! @defgroup init Initialization, version and error reference
+ *
+ *  This is the reference documentation for initialization and termination of
+ *  the library, version management and error handling.  For more task-oriented
+ *  information, see the @ref intro_guide.
+ */
+/*! @defgroup input Input reference
+ *
+ *  This is the reference documentation for input related functions and types.
+ *  For more task-oriented information, see the @ref input_guide.
+ */
+/*! @defgroup monitor Monitor reference
+ *
+ *  This is the reference documentation for monitor related functions and types.
+ *  For more task-oriented information, see the @ref monitor_guide.
+ */
+/*! @defgroup window Window reference
+ *
+ *  This is the reference documentation for window related functions and types,
+ *  including creation, deletion and event polling.  For more task-oriented
+ *  information, see the @ref window_guide.
+ */
+
+
+/*************************************************************************
+ * Compiler- and platform-specific preprocessor work
+ *************************************************************************/
+
+/* If we are we on Windows, we want a single define for it.
+ */
+#if !defined(_WIN32) && (defined(__WIN32__) || defined(WIN32) || defined(__MINGW32__))
+ #define _WIN32
+#endif /* _WIN32 */
+
+/* It is customary to use APIENTRY for OpenGL function pointer declarations on
+ * all platforms.  Additionally, the Windows OpenGL header needs APIENTRY.
+ */
+#ifndef APIENTRY
+ #ifdef _WIN32
+  #define APIENTRY __stdcall
+ #else
+  #define APIENTRY
+ #endif
+#endif /* APIENTRY */
+
+/* Some Windows OpenGL headers need this.
+ */
+#if !defined(WINGDIAPI) && defined(_WIN32)
+ #define WINGDIAPI __declspec(dllimport)
+ #define GLFW_WINGDIAPI_DEFINED
+#endif /* WINGDIAPI */
+
+/* Some Windows GLU headers need this.
+ */
+#if !defined(CALLBACK) && defined(_WIN32)
+ #define CALLBACK __stdcall
+ #define GLFW_CALLBACK_DEFINED
+#endif /* CALLBACK */
+
+/* Include because most Windows GLU headers need wchar_t and
+ * the OS X OpenGL header blocks the definition of ptrdiff_t by glext.h.
+ * Include it unconditionally to avoid surprising side-effects.
+ */
+#include <stddef.h>
+
+/* Include because it is needed by Vulkan and related functions.
+ */
+#include <stdint.h>
+
+/* Include the chosen client API headers.
+ */
+#if defined(__APPLE__)
+ #if defined(GLFW_INCLUDE_GLCOREARB)
+  #include <OpenGL/gl3.h>
+  #if defined(GLFW_INCLUDE_GLEXT)
+   #include <OpenGL/gl3ext.h>
+  #endif
+ #elif !defined(GLFW_INCLUDE_NONE)
+  #if !defined(GLFW_INCLUDE_GLEXT)
+   #define GL_GLEXT_LEGACY
+  #endif
+  #include <OpenGL/gl.h>
+ #endif
+ #if defined(GLFW_INCLUDE_GLU)
+  #include <OpenGL/glu.h>
+ #endif
+#else
+ #if defined(GLFW_INCLUDE_GLCOREARB)
+  #include <GL/glcorearb.h>
+ #elif defined(GLFW_INCLUDE_ES1)
+  #include <GLES/gl.h>
+  #if defined(GLFW_INCLUDE_GLEXT)
+   #include <GLES/glext.h>
+  #endif
+ #elif defined(GLFW_INCLUDE_ES2)
+  #include <GLES2/gl2.h>
+  #if defined(GLFW_INCLUDE_GLEXT)
+   #include <GLES2/gl2ext.h>
+  #endif
+ #elif defined(GLFW_INCLUDE_ES3)
+  #include <GLES3/gl3.h>
+  #if defined(GLFW_INCLUDE_GLEXT)
+   #include <GLES2/gl2ext.h>
+  #endif
+ #elif defined(GLFW_INCLUDE_ES31)
+  #include <GLES3/gl31.h>
+  #if defined(GLFW_INCLUDE_GLEXT)
+   #include <GLES2/gl2ext.h>
+  #endif
+ #elif defined(GLFW_INCLUDE_VULKAN)
+  #include <vulkan/vulkan.h>
+ #elif !defined(GLFW_INCLUDE_NONE)
+  #include <GL/gl.h>
+  #if defined(GLFW_INCLUDE_GLEXT)
+   #include <GL/glext.h>
+  #endif
+ #endif
+ #if defined(GLFW_INCLUDE_GLU)
+  #include <GL/glu.h>
+ #endif
+#endif
+
+#if defined(GLFW_DLL) && defined(_GLFW_BUILD_DLL)
+ /* GLFW_DLL must be defined by applications that are linking against the DLL
+  * version of the GLFW library.  _GLFW_BUILD_DLL is defined by the GLFW
+  * configuration header when compiling the DLL version of the library.
+  */
+ #error "You must not have both GLFW_DLL and _GLFW_BUILD_DLL defined"
+#endif
+
+/* GLFWAPI is used to declare public API functions for export
+ * from the DLL / shared library / dynamic library.
+ */
+#if defined(_WIN32) && defined(_GLFW_BUILD_DLL)
+ /* We are building GLFW as a Win32 DLL */
+ #define GLFWAPI __declspec(dllexport)
+#elif defined(_WIN32) && defined(GLFW_DLL)
+ /* We are calling GLFW as a Win32 DLL */
+ #define GLFWAPI __declspec(dllimport)
+#elif defined(__GNUC__) && defined(_GLFW_BUILD_DLL)
+ /* We are building GLFW as a shared / dynamic library */
+ #define GLFWAPI __attribute__((visibility("default")))
+#else
+ /* We are building or calling GLFW as a static library */
+ #define GLFWAPI
+#endif
+
+
+/*************************************************************************
+ * GLFW API tokens
+ *************************************************************************/
+
+/*! @name GLFW version macros
+ *  @{ */
+/*! @brief The major version number of the GLFW library.
+ *
+ *  This is incremented when the API is changed in non-compatible ways.
+ *  @ingroup init
+ */
+#define GLFW_VERSION_MAJOR          3
+/*! @brief The minor version number of the GLFW library.
+ *
+ *  This is incremented when features are added to the API but it remains
+ *  backward-compatible.
+ *  @ingroup init
+ */
+#define GLFW_VERSION_MINOR          2
+/*! @brief The revision number of the GLFW library.
+ *
+ *  This is incremented when a bug fix release is made that does not contain any
+ *  API changes.
+ *  @ingroup init
+ */
+#define GLFW_VERSION_REVISION       1
+/*! @} */
+
+/*! @name Boolean values
+ *  @{ */
+/*! @brief One.
+ *
+ *  One.  Seriously.  You don't _need_ to use this symbol in your code.  It's
+ *  just semantic sugar for the number 1.  You can use `1` or `true` or `_True`
+ *  or `GL_TRUE` or whatever you want.
+ */
+#define GLFW_TRUE                   1
+/*! @brief Zero.
+ *
+ *  Zero.  Seriously.  You don't _need_ to use this symbol in your code.  It's
+ *  just just semantic sugar for the number 0.  You can use `0` or `false` or
+ *  `_False` or `GL_FALSE` or whatever you want.
+ */
+#define GLFW_FALSE                  0
+/*! @} */
+
+/*! @name Key and button actions
+ *  @{ */
+/*! @brief The key or mouse button was released.
+ *
+ *  The key or mouse button was released.
+ *
+ *  @ingroup input
+ */
+#define GLFW_RELEASE                0
+/*! @brief The key or mouse button was pressed.
+ *
+ *  The key or mouse button was pressed.
+ *
+ *  @ingroup input
+ */
+#define GLFW_PRESS                  1
+/*! @brief The key was held down until it repeated.
+ *
+ *  The key was held down until it repeated.
+ *
+ *  @ingroup input
+ */
+#define GLFW_REPEAT                 2
+/*! @} */
+
+/*! @defgroup keys Keyboard keys
+ *
+ *  See [key input](@ref input_key) for how these are used.
+ *
+ *  These key codes are inspired by the _USB HID Usage Tables v1.12_ (p. 53-60),
+ *  but re-arranged to map to 7-bit ASCII for printable keys (function keys are
+ *  put in the 256+ range).
+ *
+ *  The naming of the key codes follow these rules:
+ *   - The US keyboard layout is used
+ *   - Names of printable alpha-numeric characters are used (e.g. "A", "R",
+ *     "3", etc.)
+ *   - For non-alphanumeric characters, Unicode:ish names are used (e.g.
+ *     "COMMA", "LEFT_SQUARE_BRACKET", etc.). Note that some names do not
+ *     correspond to the Unicode standard (usually for brevity)
+ *   - Keys that lack a clear US mapping are named "WORLD_x"
+ *   - For non-printable keys, custom names are used (e.g. "F4",
+ *     "BACKSPACE", etc.)
+ *
+ *  @ingroup input
+ *  @{
+ */
+
+/* The unknown key */
+#define GLFW_KEY_UNKNOWN            -1
+
+/* Printable keys */
+#define GLFW_KEY_SPACE              32
+#define GLFW_KEY_APOSTROPHE         39  /* ' */
+#define GLFW_KEY_COMMA              44  /* , */
+#define GLFW_KEY_MINUS              45  /* - */
+#define GLFW_KEY_PERIOD             46  /* . */
+#define GLFW_KEY_SLASH              47  /* / */
+#define GLFW_KEY_0                  48
+#define GLFW_KEY_1                  49
+#define GLFW_KEY_2                  50
+#define GLFW_KEY_3                  51
+#define GLFW_KEY_4                  52
+#define GLFW_KEY_5                  53
+#define GLFW_KEY_6                  54
+#define GLFW_KEY_7                  55
+#define GLFW_KEY_8                  56
+#define GLFW_KEY_9                  57
+#define GLFW_KEY_SEMICOLON          59  /* ; */
+#define GLFW_KEY_EQUAL              61  /* = */
+#define GLFW_KEY_A                  65
+#define GLFW_KEY_B                  66
+#define GLFW_KEY_C                  67
+#define GLFW_KEY_D                  68
+#define GLFW_KEY_E                  69
+#define GLFW_KEY_F                  70
+#define GLFW_KEY_G                  71
+#define GLFW_KEY_H                  72
+#define GLFW_KEY_I                  73
+#define GLFW_KEY_J                  74
+#define GLFW_KEY_K                  75
+#define GLFW_KEY_L                  76
+#define GLFW_KEY_M                  77
+#define GLFW_KEY_N                  78
+#define GLFW_KEY_O                  79
+#define GLFW_KEY_P                  80
+#define GLFW_KEY_Q                  81
+#define GLFW_KEY_R                  82
+#define GLFW_KEY_S                  83
+#define GLFW_KEY_T                  84
+#define GLFW_KEY_U                  85
+#define GLFW_KEY_V                  86
+#define GLFW_KEY_W                  87
+#define GLFW_KEY_X                  88
+#define GLFW_KEY_Y                  89
+#define GLFW_KEY_Z                  90
+#define GLFW_KEY_LEFT_BRACKET       91  /* [ */
+#define GLFW_KEY_BACKSLASH          92  /* \ */
+#define GLFW_KEY_RIGHT_BRACKET      93  /* ] */
+#define GLFW_KEY_GRAVE_ACCENT       96  /* ` */
+#define GLFW_KEY_WORLD_1            161 /* non-US #1 */
+#define GLFW_KEY_WORLD_2            162 /* non-US #2 */
+
+/* Function keys */
+#define GLFW_KEY_ESCAPE             256
+#define GLFW_KEY_ENTER              257
+#define GLFW_KEY_TAB                258
+#define GLFW_KEY_BACKSPACE          259
+#define GLFW_KEY_INSERT             260
+#define GLFW_KEY_DELETE             261
+#define GLFW_KEY_RIGHT              262
+#define GLFW_KEY_LEFT               263
+#define GLFW_KEY_DOWN               264
+#define GLFW_KEY_UP                 265
+#define GLFW_KEY_PAGE_UP            266
+#define GLFW_KEY_PAGE_DOWN          267
+#define GLFW_KEY_HOME               268
+#define GLFW_KEY_END                269
+#define GLFW_KEY_CAPS_LOCK          280
+#define GLFW_KEY_SCROLL_LOCK        281
+#define GLFW_KEY_NUM_LOCK           282
+#define GLFW_KEY_PRINT_SCREEN       283
+#define GLFW_KEY_PAUSE              284
+#define GLFW_KEY_F1                 290
+#define GLFW_KEY_F2                 291
+#define GLFW_KEY_F3                 292
+#define GLFW_KEY_F4                 293
+#define GLFW_KEY_F5                 294
+#define GLFW_KEY_F6                 295
+#define GLFW_KEY_F7                 296
+#define GLFW_KEY_F8                 297
+#define GLFW_KEY_F9                 298
+#define GLFW_KEY_F10                299
+#define GLFW_KEY_F11                300
+#define GLFW_KEY_F12                301
+#define GLFW_KEY_F13                302
+#define GLFW_KEY_F14                303
+#define GLFW_KEY_F15                304
+#define GLFW_KEY_F16                305
+#define GLFW_KEY_F17                306
+#define GLFW_KEY_F18                307
+#define GLFW_KEY_F19                308
+#define GLFW_KEY_F20                309
+#define GLFW_KEY_F21                310
+#define GLFW_KEY_F22                311
+#define GLFW_KEY_F23                312
+#define GLFW_KEY_F24                313
+#define GLFW_KEY_F25                314
+#define GLFW_KEY_KP_0               320
+#define GLFW_KEY_KP_1               321
+#define GLFW_KEY_KP_2               322
+#define GLFW_KEY_KP_3               323
+#define GLFW_KEY_KP_4               324
+#define GLFW_KEY_KP_5               325
+#define GLFW_KEY_KP_6               326
+#define GLFW_KEY_KP_7               327
+#define GLFW_KEY_KP_8               328
+#define GLFW_KEY_KP_9               329
+#define GLFW_KEY_KP_DECIMAL         330
+#define GLFW_KEY_KP_DIVIDE          331
+#define GLFW_KEY_KP_MULTIPLY        332
+#define GLFW_KEY_KP_SUBTRACT        333
+#define GLFW_KEY_KP_ADD             334
+#define GLFW_KEY_KP_ENTER           335
+#define GLFW_KEY_KP_EQUAL           336
+#define GLFW_KEY_LEFT_SHIFT         340
+#define GLFW_KEY_LEFT_CONTROL       341
+#define GLFW_KEY_LEFT_ALT           342
+#define GLFW_KEY_LEFT_SUPER         343
+#define GLFW_KEY_RIGHT_SHIFT        344
+#define GLFW_KEY_RIGHT_CONTROL      345
+#define GLFW_KEY_RIGHT_ALT          346
+#define GLFW_KEY_RIGHT_SUPER        347
+#define GLFW_KEY_MENU               348
+
+#define GLFW_KEY_LAST               GLFW_KEY_MENU
+
+/*! @} */
+
+/*! @defgroup mods Modifier key flags
+ *
+ *  See [key input](@ref input_key) for how these are used.
+ *
+ *  @ingroup input
+ *  @{ */
+
+/*! @brief If this bit is set one or more Shift keys were held down.
+ */
+#define GLFW_MOD_SHIFT           0x0001
+/*! @brief If this bit is set one or more Control keys were held down.
+ */
+#define GLFW_MOD_CONTROL         0x0002
+/*! @brief If this bit is set one or more Alt keys were held down.
+ */
+#define GLFW_MOD_ALT             0x0004
+/*! @brief If this bit is set one or more Super keys were held down.
+ */
+#define GLFW_MOD_SUPER           0x0008
+
+/*! @} */
+
+/*! @defgroup buttons Mouse buttons
+ *
+ *  See [mouse button input](@ref input_mouse_button) for how these are used.
+ *
+ *  @ingroup input
+ *  @{ */
+#define GLFW_MOUSE_BUTTON_1         0
+#define GLFW_MOUSE_BUTTON_2         1
+#define GLFW_MOUSE_BUTTON_3         2
+#define GLFW_MOUSE_BUTTON_4         3
+#define GLFW_MOUSE_BUTTON_5         4
+#define GLFW_MOUSE_BUTTON_6         5
+#define GLFW_MOUSE_BUTTON_7         6
+#define GLFW_MOUSE_BUTTON_8         7
+#define GLFW_MOUSE_BUTTON_LAST      GLFW_MOUSE_BUTTON_8
+#define GLFW_MOUSE_BUTTON_LEFT      GLFW_MOUSE_BUTTON_1
+#define GLFW_MOUSE_BUTTON_RIGHT     GLFW_MOUSE_BUTTON_2
+#define GLFW_MOUSE_BUTTON_MIDDLE    GLFW_MOUSE_BUTTON_3
+/*! @} */
+
+/*! @defgroup joysticks Joysticks
+ *
+ *  See [joystick input](@ref joystick) for how these are used.
+ *
+ *  @ingroup input
+ *  @{ */
+#define GLFW_JOYSTICK_1             0
+#define GLFW_JOYSTICK_2             1
+#define GLFW_JOYSTICK_3             2
+#define GLFW_JOYSTICK_4             3
+#define GLFW_JOYSTICK_5             4
+#define GLFW_JOYSTICK_6             5
+#define GLFW_JOYSTICK_7             6
+#define GLFW_JOYSTICK_8             7
+#define GLFW_JOYSTICK_9             8
+#define GLFW_JOYSTICK_10            9
+#define GLFW_JOYSTICK_11            10
+#define GLFW_JOYSTICK_12            11
+#define GLFW_JOYSTICK_13            12
+#define GLFW_JOYSTICK_14            13
+#define GLFW_JOYSTICK_15            14
+#define GLFW_JOYSTICK_16            15
+#define GLFW_JOYSTICK_LAST          GLFW_JOYSTICK_16
+/*! @} */
+
+/*! @defgroup errors Error codes
+ *
+ *  See [error handling](@ref error_handling) for how these are used.
+ *
+ *  @ingroup init
+ *  @{ */
+/*! @brief GLFW has not been initialized.
+ *
+ *  This occurs if a GLFW function was called that must not be called unless the
+ *  library is [initialized](@ref intro_init).
+ *
+ *  @analysis Application programmer error.  Initialize GLFW before calling any
+ *  function that requires initialization.
+ */
+#define GLFW_NOT_INITIALIZED        0x00010001
+/*! @brief No context is current for this thread.
+ *
+ *  This occurs if a GLFW function was called that needs and operates on the
+ *  current OpenGL or OpenGL ES context but no context is current on the calling
+ *  thread.  One such function is @ref glfwSwapInterval.
+ *
+ *  @analysis Application programmer error.  Ensure a context is current before
+ *  calling functions that require a current context.
+ */
+#define GLFW_NO_CURRENT_CONTEXT     0x00010002
+/*! @brief One of the arguments to the function was an invalid enum value.
+ *
+ *  One of the arguments to the function was an invalid enum value, for example
+ *  requesting [GLFW_RED_BITS](@ref window_hints_fb) with @ref
+ *  glfwGetWindowAttrib.
+ *
+ *  @analysis Application programmer error.  Fix the offending call.
+ */
+#define GLFW_INVALID_ENUM           0x00010003
+/*! @brief One of the arguments to the function was an invalid value.
+ *
+ *  One of the arguments to the function was an invalid value, for example
+ *  requesting a non-existent OpenGL or OpenGL ES version like 2.7.
+ *
+ *  Requesting a valid but unavailable OpenGL or OpenGL ES version will instead
+ *  result in a @ref GLFW_VERSION_UNAVAILABLE error.
+ *
+ *  @analysis Application programmer error.  Fix the offending call.
+ */
+#define GLFW_INVALID_VALUE          0x00010004
+/*! @brief A memory allocation failed.
+ *
+ *  A memory allocation failed.
+ *
+ *  @analysis A bug in GLFW or the underlying operating system.  Report the bug
+ *  to our [issue tracker](https://github.com/glfw/glfw/issues).
+ */
+#define GLFW_OUT_OF_MEMORY          0x00010005
+/*! @brief GLFW could not find support for the requested API on the system.
+ *
+ *  GLFW could not find support for the requested API on the system.
+ *
+ *  @analysis The installed graphics driver does not support the requested
+ *  API, or does not support it via the chosen context creation backend.
+ *  Below are a few examples.
+ *
+ *  @par
+ *  Some pre-installed Windows graphics drivers do not support OpenGL.  AMD only
+ *  supports OpenGL ES via EGL, while Nvidia and Intel only support it via
+ *  a WGL or GLX extension.  OS X does not provide OpenGL ES at all.  The Mesa
+ *  EGL, OpenGL and OpenGL ES libraries do not interface with the Nvidia binary
+ *  driver.  Older graphics drivers do not support Vulkan.
+ */
+#define GLFW_API_UNAVAILABLE        0x00010006
+/*! @brief The requested OpenGL or OpenGL ES version is not available.
+ *
+ *  The requested OpenGL or OpenGL ES version (including any requested context
+ *  or framebuffer hints) is not available on this machine.
+ *
+ *  @analysis The machine does not support your requirements.  If your
+ *  application is sufficiently flexible, downgrade your requirements and try
+ *  again.  Otherwise, inform the user that their machine does not match your
+ *  requirements.
+ *
+ *  @par
+ *  Future invalid OpenGL and OpenGL ES versions, for example OpenGL 4.8 if 5.0
+ *  comes out before the 4.x series gets that far, also fail with this error and
+ *  not @ref GLFW_INVALID_VALUE, because GLFW cannot know what future versions
+ *  will exist.
+ */
+#define GLFW_VERSION_UNAVAILABLE    0x00010007
+/*! @brief A platform-specific error occurred that does not match any of the
+ *  more specific categories.
+ *
+ *  A platform-specific error occurred that does not match any of the more
+ *  specific categories.
+ *
+ *  @analysis A bug or configuration error in GLFW, the underlying operating
+ *  system or its drivers, or a lack of required resources.  Report the issue to
+ *  our [issue tracker](https://github.com/glfw/glfw/issues).
+ */
+#define GLFW_PLATFORM_ERROR         0x00010008
+/*! @brief The requested format is not supported or available.
+ *
+ *  If emitted during window creation, the requested pixel format is not
+ *  supported.
+ *
+ *  If emitted when querying the clipboard, the contents of the clipboard could
+ *  not be converted to the requested format.
+ *
+ *  @analysis If emitted during window creation, one or more
+ *  [hard constraints](@ref window_hints_hard) did not match any of the
+ *  available pixel formats.  If your application is sufficiently flexible,
+ *  downgrade your requirements and try again.  Otherwise, inform the user that
+ *  their machine does not match your requirements.
+ *
+ *  @par
+ *  If emitted when querying the clipboard, ignore the error or report it to
+ *  the user, as appropriate.
+ */
+#define GLFW_FORMAT_UNAVAILABLE     0x00010009
+/*! @brief The specified window does not have an OpenGL or OpenGL ES context.
+ *
+ *  A window that does not have an OpenGL or OpenGL ES context was passed to
+ *  a function that requires it to have one.
+ *
+ *  @analysis Application programmer error.  Fix the offending call.
+ */
+#define GLFW_NO_WINDOW_CONTEXT      0x0001000A
+/*! @} */
+
+#define GLFW_FOCUSED                0x00020001
+#define GLFW_ICONIFIED              0x00020002
+#define GLFW_RESIZABLE              0x00020003
+#define GLFW_VISIBLE                0x00020004
+#define GLFW_DECORATED              0x00020005
+#define GLFW_AUTO_ICONIFY           0x00020006
+#define GLFW_FLOATING               0x00020007
+#define GLFW_MAXIMIZED              0x00020008
+
+#define GLFW_RED_BITS               0x00021001
+#define GLFW_GREEN_BITS             0x00021002
+#define GLFW_BLUE_BITS              0x00021003
+#define GLFW_ALPHA_BITS             0x00021004
+#define GLFW_DEPTH_BITS             0x00021005
+#define GLFW_STENCIL_BITS           0x00021006
+#define GLFW_ACCUM_RED_BITS         0x00021007
+#define GLFW_ACCUM_GREEN_BITS       0x00021008
+#define GLFW_ACCUM_BLUE_BITS        0x00021009
+#define GLFW_ACCUM_ALPHA_BITS       0x0002100A
+#define GLFW_AUX_BUFFERS            0x0002100B
+#define GLFW_STEREO                 0x0002100C
+#define GLFW_SAMPLES                0x0002100D
+#define GLFW_SRGB_CAPABLE           0x0002100E
+#define GLFW_REFRESH_RATE           0x0002100F
+#define GLFW_DOUBLEBUFFER           0x00021010
+
+#define GLFW_CLIENT_API             0x00022001
+#define GLFW_CONTEXT_VERSION_MAJOR  0x00022002
+#define GLFW_CONTEXT_VERSION_MINOR  0x00022003
+#define GLFW_CONTEXT_REVISION       0x00022004
+#define GLFW_CONTEXT_ROBUSTNESS     0x00022005
+#define GLFW_OPENGL_FORWARD_COMPAT  0x00022006
+#define GLFW_OPENGL_DEBUG_CONTEXT   0x00022007
+#define GLFW_OPENGL_PROFILE         0x00022008
+#define GLFW_CONTEXT_RELEASE_BEHAVIOR 0x00022009
+#define GLFW_CONTEXT_NO_ERROR       0x0002200A
+#define GLFW_CONTEXT_CREATION_API   0x0002200B
+
+#define GLFW_NO_API                          0
+#define GLFW_OPENGL_API             0x00030001
+#define GLFW_OPENGL_ES_API          0x00030002
+
+#define GLFW_NO_ROBUSTNESS                   0
+#define GLFW_NO_RESET_NOTIFICATION  0x00031001
+#define GLFW_LOSE_CONTEXT_ON_RESET  0x00031002
+
+#define GLFW_OPENGL_ANY_PROFILE              0
+#define GLFW_OPENGL_CORE_PROFILE    0x00032001
+#define GLFW_OPENGL_COMPAT_PROFILE  0x00032002
+
+#define GLFW_CURSOR                 0x00033001
+#define GLFW_STICKY_KEYS            0x00033002
+#define GLFW_STICKY_MOUSE_BUTTONS   0x00033003
+
+#define GLFW_CURSOR_NORMAL          0x00034001
+#define GLFW_CURSOR_HIDDEN          0x00034002
+#define GLFW_CURSOR_DISABLED        0x00034003
+
+#define GLFW_ANY_RELEASE_BEHAVIOR            0
+#define GLFW_RELEASE_BEHAVIOR_FLUSH 0x00035001
+#define GLFW_RELEASE_BEHAVIOR_NONE  0x00035002
+
+#define GLFW_NATIVE_CONTEXT_API     0x00036001
+#define GLFW_EGL_CONTEXT_API        0x00036002
+
+/*! @defgroup shapes Standard cursor shapes
+ *
+ *  See [standard cursor creation](@ref cursor_standard) for how these are used.
+ *
+ *  @ingroup input
+ *  @{ */
+
+/*! @brief The regular arrow cursor shape.
+ *
+ *  The regular arrow cursor.
+ */
+#define GLFW_ARROW_CURSOR           0x00036001
+/*! @brief The text input I-beam cursor shape.
+ *
+ *  The text input I-beam cursor shape.
+ */
+#define GLFW_IBEAM_CURSOR           0x00036002
+/*! @brief The crosshair shape.
+ *
+ *  The crosshair shape.
+ */
+#define GLFW_CROSSHAIR_CURSOR       0x00036003
+/*! @brief The hand shape.
+ *
+ *  The hand shape.
+ */
+#define GLFW_HAND_CURSOR            0x00036004
+/*! @brief The horizontal resize arrow shape.
+ *
+ *  The horizontal resize arrow shape.
+ */
+#define GLFW_HRESIZE_CURSOR         0x00036005
+/*! @brief The vertical resize arrow shape.
+ *
+ *  The vertical resize arrow shape.
+ */
+#define GLFW_VRESIZE_CURSOR         0x00036006
+/*! @} */
+
+#define GLFW_CONNECTED              0x00040001
+#define GLFW_DISCONNECTED           0x00040002
+
+#define GLFW_DONT_CARE              -1
+
+
+/*************************************************************************
+ * GLFW API types
+ *************************************************************************/
+
+/*! @brief Client API function pointer type.
+ *
+ *  Generic function pointer used for returning client API function pointers
+ *  without forcing a cast from a regular pointer.
+ *
+ *  @sa @ref context_glext
+ *  @sa glfwGetProcAddress
+ *
+ *  @since Added in version 3.0.
+ 
+ *  @ingroup context
+ */
+typedef void (*GLFWglproc)(void);
+
+/*! @brief Vulkan API function pointer type.
+ *
+ *  Generic function pointer used for returning Vulkan API function pointers
+ *  without forcing a cast from a regular pointer.
+ *
+ *  @sa @ref vulkan_proc
+ *  @sa glfwGetInstanceProcAddress
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup vulkan
+ */
+typedef void (*GLFWvkproc)(void);
+
+/*! @brief Opaque monitor object.
+ *
+ *  Opaque monitor object.
+ *
+ *  @see @ref monitor_object
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup monitor
+ */
+typedef struct GLFWmonitor GLFWmonitor;
+
+/*! @brief Opaque window object.
+ *
+ *  Opaque window object.
+ *
+ *  @see @ref window_object
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+typedef struct GLFWwindow GLFWwindow;
+
+/*! @brief Opaque cursor object.
+ *
+ *  Opaque cursor object.
+ *
+ *  @see @ref cursor_object
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup cursor
+ */
+typedef struct GLFWcursor GLFWcursor;
+
+/*! @brief The function signature for error callbacks.
+ *
+ *  This is the function signature for error callback functions.
+ *
+ *  @param[in] error An [error code](@ref errors).
+ *  @param[in] description A UTF-8 encoded string describing the error.
+ *
+ *  @sa @ref error_handling
+ *  @sa glfwSetErrorCallback
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup init
+ */
+typedef void (* GLFWerrorfun)(int,const char*);
+
+/*! @brief The function signature for window position callbacks.
+ *
+ *  This is the function signature for window position callback functions.
+ *
+ *  @param[in] window The window that was moved.
+ *  @param[in] xpos The new x-coordinate, in screen coordinates, of the
+ *  upper-left corner of the client area of the window.
+ *  @param[in] ypos The new y-coordinate, in screen coordinates, of the
+ *  upper-left corner of the client area of the window.
+ *
+ *  @sa @ref window_pos
+ *  @sa glfwSetWindowPosCallback
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+typedef void (* GLFWwindowposfun)(GLFWwindow*,int,int);
+
+/*! @brief The function signature for window resize callbacks.
+ *
+ *  This is the function signature for window size callback functions.
+ *
+ *  @param[in] window The window that was resized.
+ *  @param[in] width The new width, in screen coordinates, of the window.
+ *  @param[in] height The new height, in screen coordinates, of the window.
+ *
+ *  @sa @ref window_size
+ *  @sa glfwSetWindowSizeCallback
+ *
+ *  @since Added in version 1.0.
+ *  @glfw3 Added window handle parameter.
+ *
+ *  @ingroup window
+ */
+typedef void (* GLFWwindowsizefun)(GLFWwindow*,int,int);
+
+/*! @brief The function signature for window close callbacks.
+ *
+ *  This is the function signature for window close callback functions.
+ *
+ *  @param[in] window The window that the user attempted to close.
+ *
+ *  @sa @ref window_close
+ *  @sa glfwSetWindowCloseCallback
+ *
+ *  @since Added in version 2.5.
+ *  @glfw3 Added window handle parameter.
+ *
+ *  @ingroup window
+ */
+typedef void (* GLFWwindowclosefun)(GLFWwindow*);
+
+/*! @brief The function signature for window content refresh callbacks.
+ *
+ *  This is the function signature for window refresh callback functions.
+ *
+ *  @param[in] window The window whose content needs to be refreshed.
+ *
+ *  @sa @ref window_refresh
+ *  @sa glfwSetWindowRefreshCallback
+ *
+ *  @since Added in version 2.5.
+ *  @glfw3 Added window handle parameter.
+ *
+ *  @ingroup window
+ */
+typedef void (* GLFWwindowrefreshfun)(GLFWwindow*);
+
+/*! @brief The function signature for window focus/defocus callbacks.
+ *
+ *  This is the function signature for window focus callback functions.
+ *
+ *  @param[in] window The window that gained or lost input focus.
+ *  @param[in] focused `GLFW_TRUE` if the window was given input focus, or
+ *  `GLFW_FALSE` if it lost it.
+ *
+ *  @sa @ref window_focus
+ *  @sa glfwSetWindowFocusCallback
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+typedef void (* GLFWwindowfocusfun)(GLFWwindow*,int);
+
+/*! @brief The function signature for window iconify/restore callbacks.
+ *
+ *  This is the function signature for window iconify/restore callback
+ *  functions.
+ *
+ *  @param[in] window The window that was iconified or restored.
+ *  @param[in] iconified `GLFW_TRUE` if the window was iconified, or
+ *  `GLFW_FALSE` if it was restored.
+ *
+ *  @sa @ref window_iconify
+ *  @sa glfwSetWindowIconifyCallback
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+typedef void (* GLFWwindowiconifyfun)(GLFWwindow*,int);
+
+/*! @brief The function signature for framebuffer resize callbacks.
+ *
+ *  This is the function signature for framebuffer resize callback
+ *  functions.
+ *
+ *  @param[in] window The window whose framebuffer was resized.
+ *  @param[in] width The new width, in pixels, of the framebuffer.
+ *  @param[in] height The new height, in pixels, of the framebuffer.
+ *
+ *  @sa @ref window_fbsize
+ *  @sa glfwSetFramebufferSizeCallback
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+typedef void (* GLFWframebuffersizefun)(GLFWwindow*,int,int);
+
+/*! @brief The function signature for mouse button callbacks.
+ *
+ *  This is the function signature for mouse button callback functions.
+ *
+ *  @param[in] window The window that received the event.
+ *  @param[in] button The [mouse button](@ref buttons) that was pressed or
+ *  released.
+ *  @param[in] action One of `GLFW_PRESS` or `GLFW_RELEASE`.
+ *  @param[in] mods Bit field describing which [modifier keys](@ref mods) were
+ *  held down.
+ *
+ *  @sa @ref input_mouse_button
+ *  @sa glfwSetMouseButtonCallback
+ *
+ *  @since Added in version 1.0.
+ *  @glfw3 Added window handle and modifier mask parameters.
+ *
+ *  @ingroup input
+ */
+typedef void (* GLFWmousebuttonfun)(GLFWwindow*,int,int,int);
+
+/*! @brief The function signature for cursor position callbacks.
+ *
+ *  This is the function signature for cursor position callback functions.
+ *
+ *  @param[in] window The window that received the event.
+ *  @param[in] xpos The new cursor x-coordinate, relative to the left edge of
+ *  the client area.
+ *  @param[in] ypos The new cursor y-coordinate, relative to the top edge of the
+ *  client area.
+ *
+ *  @sa @ref cursor_pos
+ *  @sa glfwSetCursorPosCallback
+ *
+ *  @since Added in version 3.0.  Replaces `GLFWmouseposfun`.
+ *
+ *  @ingroup input
+ */
+typedef void (* GLFWcursorposfun)(GLFWwindow*,double,double);
+
+/*! @brief The function signature for cursor enter/leave callbacks.
+ *
+ *  This is the function signature for cursor enter/leave callback functions.
+ *
+ *  @param[in] window The window that received the event.
+ *  @param[in] entered `GLFW_TRUE` if the cursor entered the window's client
+ *  area, or `GLFW_FALSE` if it left it.
+ *
+ *  @sa @ref cursor_enter
+ *  @sa glfwSetCursorEnterCallback
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup input
+ */
+typedef void (* GLFWcursorenterfun)(GLFWwindow*,int);
+
+/*! @brief The function signature for scroll callbacks.
+ *
+ *  This is the function signature for scroll callback functions.
+ *
+ *  @param[in] window The window that received the event.
+ *  @param[in] xoffset The scroll offset along the x-axis.
+ *  @param[in] yoffset The scroll offset along the y-axis.
+ *
+ *  @sa @ref scrolling
+ *  @sa glfwSetScrollCallback
+ *
+ *  @since Added in version 3.0.  Replaces `GLFWmousewheelfun`.
+ *
+ *  @ingroup input
+ */
+typedef void (* GLFWscrollfun)(GLFWwindow*,double,double);
+
+/*! @brief The function signature for keyboard key callbacks.
+ *
+ *  This is the function signature for keyboard key callback functions.
+ *
+ *  @param[in] window The window that received the event.
+ *  @param[in] key The [keyboard key](@ref keys) that was pressed or released.
+ *  @param[in] scancode The system-specific scancode of the key.
+ *  @param[in] action `GLFW_PRESS`, `GLFW_RELEASE` or `GLFW_REPEAT`.
+ *  @param[in] mods Bit field describing which [modifier keys](@ref mods) were
+ *  held down.
+ *
+ *  @sa @ref input_key
+ *  @sa glfwSetKeyCallback
+ *
+ *  @since Added in version 1.0.
+ *  @glfw3 Added window handle, scancode and modifier mask parameters.
+ *
+ *  @ingroup input
+ */
+typedef void (* GLFWkeyfun)(GLFWwindow*,int,int,int,int);
+
+/*! @brief The function signature for Unicode character callbacks.
+ *
+ *  This is the function signature for Unicode character callback functions.
+ *
+ *  @param[in] window The window that received the event.
+ *  @param[in] codepoint The Unicode code point of the character.
+ *
+ *  @sa @ref input_char
+ *  @sa glfwSetCharCallback
+ *
+ *  @since Added in version 2.4.
+ *  @glfw3 Added window handle parameter.
+ *
+ *  @ingroup input
+ */
+typedef void (* GLFWcharfun)(GLFWwindow*,unsigned int);
+
+/*! @brief The function signature for Unicode character with modifiers
+ *  callbacks.
+ *
+ *  This is the function signature for Unicode character with modifiers callback
+ *  functions.  It is called for each input character, regardless of what
+ *  modifier keys are held down.
+ *
+ *  @param[in] window The window that received the event.
+ *  @param[in] codepoint The Unicode code point of the character.
+ *  @param[in] mods Bit field describing which [modifier keys](@ref mods) were
+ *  held down.
+ *
+ *  @sa @ref input_char
+ *  @sa glfwSetCharModsCallback
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup input
+ */
+typedef void (* GLFWcharmodsfun)(GLFWwindow*,unsigned int,int);
+
+/*! @brief The function signature for file drop callbacks.
+ *
+ *  This is the function signature for file drop callbacks.
+ *
+ *  @param[in] window The window that received the event.
+ *  @param[in] count The number of dropped files.
+ *  @param[in] paths The UTF-8 encoded file and/or directory path names.
+ *
+ *  @sa @ref path_drop
+ *  @sa glfwSetDropCallback
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup input
+ */
+typedef void (* GLFWdropfun)(GLFWwindow*,int,const char**);
+
+/*! @brief The function signature for monitor configuration callbacks.
+ *
+ *  This is the function signature for monitor configuration callback functions.
+ *
+ *  @param[in] monitor The monitor that was connected or disconnected.
+ *  @param[in] event One of `GLFW_CONNECTED` or `GLFW_DISCONNECTED`.
+ *
+ *  @sa @ref monitor_event
+ *  @sa glfwSetMonitorCallback
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup monitor
+ */
+typedef void (* GLFWmonitorfun)(GLFWmonitor*,int);
+
+/*! @brief The function signature for joystick configuration callbacks.
+ *
+ *  This is the function signature for joystick configuration callback
+ *  functions.
+ *
+ *  @param[in] joy The joystick that was connected or disconnected.
+ *  @param[in] event One of `GLFW_CONNECTED` or `GLFW_DISCONNECTED`.
+ *
+ *  @sa @ref joystick_event
+ *  @sa glfwSetJoystickCallback
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup input
+ */
+typedef void (* GLFWjoystickfun)(int,int);
+
+/*! @brief Video mode type.
+ *
+ *  This describes a single video mode.
+ *
+ *  @sa @ref monitor_modes
+ *  @sa glfwGetVideoMode glfwGetVideoModes
+ *
+ *  @since Added in version 1.0.
+ *  @glfw3 Added refresh rate member.
+ *
+ *  @ingroup monitor
+ */
+typedef struct GLFWvidmode
+{
+    /*! The width, in screen coordinates, of the video mode.
+     */
+    int width;
+    /*! The height, in screen coordinates, of the video mode.
+     */
+    int height;
+    /*! The bit depth of the red channel of the video mode.
+     */
+    int redBits;
+    /*! The bit depth of the green channel of the video mode.
+     */
+    int greenBits;
+    /*! The bit depth of the blue channel of the video mode.
+     */
+    int blueBits;
+    /*! The refresh rate, in Hz, of the video mode.
+     */
+    int refreshRate;
+} GLFWvidmode;
+
+/*! @brief Gamma ramp.
+ *
+ *  This describes the gamma ramp for a monitor.
+ *
+ *  @sa @ref monitor_gamma
+ *  @sa glfwGetGammaRamp glfwSetGammaRamp
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup monitor
+ */
+typedef struct GLFWgammaramp
+{
+    /*! An array of value describing the response of the red channel.
+     */
+    unsigned short* red;
+    /*! An array of value describing the response of the green channel.
+     */
+    unsigned short* green;
+    /*! An array of value describing the response of the blue channel.
+     */
+    unsigned short* blue;
+    /*! The number of elements in each array.
+     */
+    unsigned int size;
+} GLFWgammaramp;
+
+/*! @brief Image data.
+ *
+ *  @sa @ref cursor_custom
+ *  @sa @ref window_icon
+ *
+ *  @since Added in version 2.1.
+ *  @glfw3 Removed format and bytes-per-pixel members.
+ */
+typedef struct GLFWimage
+{
+    /*! The width, in pixels, of this image.
+     */
+    int width;
+    /*! The height, in pixels, of this image.
+     */
+    int height;
+    /*! The pixel data of this image, arranged left-to-right, top-to-bottom.
+     */
+    unsigned char* pixels;
+} GLFWimage;
+
+
+/*************************************************************************
+ * GLFW API functions
+ *************************************************************************/
+
+/*! @brief Initializes the GLFW library.
+ *
+ *  This function initializes the GLFW library.  Before most GLFW functions can
+ *  be used, GLFW must be initialized, and before an application terminates GLFW
+ *  should be terminated in order to free any resources allocated during or
+ *  after initialization.
+ *
+ *  If this function fails, it calls @ref glfwTerminate before returning.  If it
+ *  succeeds, you should call @ref glfwTerminate before the application exits.
+ *
+ *  Additional calls to this function after successful initialization but before
+ *  termination will return `GLFW_TRUE` immediately.
+ *
+ *  @return `GLFW_TRUE` if successful, or `GLFW_FALSE` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @remark @osx This function will change the current directory of the
+ *  application to the `Contents/Resources` subdirectory of the application's
+ *  bundle, if present.  This can be disabled with a
+ *  [compile-time option](@ref compile_options_osx).
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref intro_init
+ *  @sa glfwTerminate
+ *
+ *  @since Added in version 1.0.
+ *
+ *  @ingroup init
+ */
+GLFWAPI int glfwInit(void);
+
+/*! @brief Terminates the GLFW library.
+ *
+ *  This function destroys all remaining windows and cursors, restores any
+ *  modified gamma ramps and frees any other allocated resources.  Once this
+ *  function is called, you must again call @ref glfwInit successfully before
+ *  you will be able to use most GLFW functions.
+ *
+ *  If GLFW has been successfully initialized, this function should be called
+ *  before the application exits.  If initialization fails, there is no need to
+ *  call this function, as it is called by @ref glfwInit before it returns
+ *  failure.
+ *
+ *  @errors Possible errors include @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @remark This function may be called before @ref glfwInit.
+ *
+ *  @warning The contexts of any remaining windows must not be current on any
+ *  other thread when this function is called.
+ *
+ *  @reentrancy This function must not be called from a callback.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref intro_init
+ *  @sa glfwInit
+ *
+ *  @since Added in version 1.0.
+ *
+ *  @ingroup init
+ */
+GLFWAPI void glfwTerminate(void);
+
+/*! @brief Retrieves the version of the GLFW library.
+ *
+ *  This function retrieves the major, minor and revision numbers of the GLFW
+ *  library.  It is intended for when you are using GLFW as a shared library and
+ *  want to ensure that you are using the minimum required version.
+ *
+ *  Any or all of the version arguments may be `NULL`.
+ *
+ *  @param[out] major Where to store the major version number, or `NULL`.
+ *  @param[out] minor Where to store the minor version number, or `NULL`.
+ *  @param[out] rev Where to store the revision number, or `NULL`.
+ *
+ *  @errors None.
+ *
+ *  @remark This function may be called before @ref glfwInit.
+ *
+ *  @thread_safety This function may be called from any thread.
+ *
+ *  @sa @ref intro_version
+ *  @sa glfwGetVersionString
+ *
+ *  @since Added in version 1.0.
+ *
+ *  @ingroup init
+ */
+GLFWAPI void glfwGetVersion(int* major, int* minor, int* rev);
+
+/*! @brief Returns a string describing the compile-time configuration.
+ *
+ *  This function returns the compile-time generated
+ *  [version string](@ref intro_version_string) of the GLFW library binary.  It
+ *  describes the version, platform, compiler and any platform-specific
+ *  compile-time options.  It should not be confused with the OpenGL or OpenGL
+ *  ES version string, queried with `glGetString`.
+ *
+ *  __Do not use the version string__ to parse the GLFW library version.  The
+ *  @ref glfwGetVersion function provides the version of the running library
+ *  binary in numerical format.
+ *
+ *  @return The ASCII encoded GLFW version string.
+ *
+ *  @errors None.
+ *
+ *  @remark This function may be called before @ref glfwInit.
+ *
+ *  @pointer_lifetime The returned string is static and compile-time generated.
+ *
+ *  @thread_safety This function may be called from any thread.
+ *
+ *  @sa @ref intro_version
+ *  @sa glfwGetVersion
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup init
+ */
+GLFWAPI const char* glfwGetVersionString(void);
+
+/*! @brief Sets the error callback.
+ *
+ *  This function sets the error callback, which is called with an error code
+ *  and a human-readable description each time a GLFW error occurs.
+ *
+ *  The error callback is called on the thread where the error occurred.  If you
+ *  are using GLFW from multiple threads, your error callback needs to be
+ *  written accordingly.
+ *
+ *  Because the description string may have been generated specifically for that
+ *  error, it is not guaranteed to be valid after the callback has returned.  If
+ *  you wish to use it after the callback returns, you need to make a copy.
+ *
+ *  Once set, the error callback remains set even after the library has been
+ *  terminated.
+ *
+ *  @param[in] cbfun The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set.
+ *
+ *  @errors None.
+ *
+ *  @remark This function may be called before @ref glfwInit.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref error_handling
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup init
+ */
+GLFWAPI GLFWerrorfun glfwSetErrorCallback(GLFWerrorfun cbfun);
+
+/*! @brief Returns the currently connected monitors.
+ *
+ *  This function returns an array of handles for all currently connected
+ *  monitors.  The primary monitor is always first in the returned array.  If no
+ *  monitors were found, this function returns `NULL`.
+ *
+ *  @param[out] count Where to store the number of monitors in the returned
+ *  array.  This is set to zero if an error occurred.
+ *  @return An array of monitor handles, or `NULL` if no monitors were found or
+ *  if an [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @pointer_lifetime The returned array is allocated and freed by GLFW.  You
+ *  should not free it yourself.  It is guaranteed to be valid only until the
+ *  monitor configuration changes or the library is terminated.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref monitor_monitors
+ *  @sa @ref monitor_event
+ *  @sa glfwGetPrimaryMonitor
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup monitor
+ */
+GLFWAPI GLFWmonitor** glfwGetMonitors(int* count);
+
+/*! @brief Returns the primary monitor.
+ *
+ *  This function returns the primary monitor.  This is usually the monitor
+ *  where elements like the task bar or global menu bar are located.
+ *
+ *  @return The primary monitor, or `NULL` if no monitors were found or if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @remark The primary monitor is always first in the array returned by @ref
+ *  glfwGetMonitors.
+ *
+ *  @sa @ref monitor_monitors
+ *  @sa glfwGetMonitors
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup monitor
+ */
+GLFWAPI GLFWmonitor* glfwGetPrimaryMonitor(void);
+
+/*! @brief Returns the position of the monitor's viewport on the virtual screen.
+ *
+ *  This function returns the position, in screen coordinates, of the upper-left
+ *  corner of the specified monitor.
+ *
+ *  Any or all of the position arguments may be `NULL`.  If an error occurs, all
+ *  non-`NULL` position arguments will be set to zero.
+ *
+ *  @param[in] monitor The monitor to query.
+ *  @param[out] xpos Where to store the monitor x-coordinate, or `NULL`.
+ *  @param[out] ypos Where to store the monitor y-coordinate, or `NULL`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref monitor_properties
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup monitor
+ */
+GLFWAPI void glfwGetMonitorPos(GLFWmonitor* monitor, int* xpos, int* ypos);
+
+/*! @brief Returns the physical size of the monitor.
+ *
+ *  This function returns the size, in millimetres, of the display area of the
+ *  specified monitor.
+ *
+ *  Some systems do not provide accurate monitor size information, either
+ *  because the monitor
+ *  [EDID](https://en.wikipedia.org/wiki/Extended_display_identification_data)
+ *  data is incorrect or because the driver does not report it accurately.
+ *
+ *  Any or all of the size arguments may be `NULL`.  If an error occurs, all
+ *  non-`NULL` size arguments will be set to zero.
+ *
+ *  @param[in] monitor The monitor to query.
+ *  @param[out] widthMM Where to store the width, in millimetres, of the
+ *  monitor's display area, or `NULL`.
+ *  @param[out] heightMM Where to store the height, in millimetres, of the
+ *  monitor's display area, or `NULL`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @remark @win32 calculates the returned physical size from the
+ *  current resolution and system DPI instead of querying the monitor EDID data.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref monitor_properties
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup monitor
+ */
+GLFWAPI void glfwGetMonitorPhysicalSize(GLFWmonitor* monitor, int* widthMM, int* heightMM);
+
+/*! @brief Returns the name of the specified monitor.
+ *
+ *  This function returns a human-readable name, encoded as UTF-8, of the
+ *  specified monitor.  The name typically reflects the make and model of the
+ *  monitor and is not guaranteed to be unique among the connected monitors.
+ *
+ *  @param[in] monitor The monitor to query.
+ *  @return The UTF-8 encoded name of the monitor, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @pointer_lifetime The returned string is allocated and freed by GLFW.  You
+ *  should not free it yourself.  It is valid until the specified monitor is
+ *  disconnected or the library is terminated.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref monitor_properties
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup monitor
+ */
+GLFWAPI const char* glfwGetMonitorName(GLFWmonitor* monitor);
+
+/*! @brief Sets the monitor configuration callback.
+ *
+ *  This function sets the monitor configuration callback, or removes the
+ *  currently set callback.  This is called when a monitor is connected to or
+ *  disconnected from the system.
+ *
+ *  @param[in] cbfun The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref monitor_event
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup monitor
+ */
+GLFWAPI GLFWmonitorfun glfwSetMonitorCallback(GLFWmonitorfun cbfun);
+
+/*! @brief Returns the available video modes for the specified monitor.
+ *
+ *  This function returns an array of all video modes supported by the specified
+ *  monitor.  The returned array is sorted in ascending order, first by color
+ *  bit depth (the sum of all channel depths) and then by resolution area (the
+ *  product of width and height).
+ *
+ *  @param[in] monitor The monitor to query.
+ *  @param[out] count Where to store the number of video modes in the returned
+ *  array.  This is set to zero if an error occurred.
+ *  @return An array of video modes, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @pointer_lifetime The returned array is allocated and freed by GLFW.  You
+ *  should not free it yourself.  It is valid until the specified monitor is
+ *  disconnected, this function is called again for that monitor or the library
+ *  is terminated.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref monitor_modes
+ *  @sa glfwGetVideoMode
+ *
+ *  @since Added in version 1.0.
+ *  @glfw3 Changed to return an array of modes for a specific monitor.
+ *
+ *  @ingroup monitor
+ */
+GLFWAPI const GLFWvidmode* glfwGetVideoModes(GLFWmonitor* monitor, int* count);
+
+/*! @brief Returns the current mode of the specified monitor.
+ *
+ *  This function returns the current video mode of the specified monitor.  If
+ *  you have created a full screen window for that monitor, the return value
+ *  will depend on whether that window is iconified.
+ *
+ *  @param[in] monitor The monitor to query.
+ *  @return The current mode of the monitor, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @pointer_lifetime The returned array is allocated and freed by GLFW.  You
+ *  should not free it yourself.  It is valid until the specified monitor is
+ *  disconnected or the library is terminated.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref monitor_modes
+ *  @sa glfwGetVideoModes
+ *
+ *  @since Added in version 3.0.  Replaces `glfwGetDesktopMode`.
+ *
+ *  @ingroup monitor
+ */
+GLFWAPI const GLFWvidmode* glfwGetVideoMode(GLFWmonitor* monitor);
+
+/*! @brief Generates a gamma ramp and sets it for the specified monitor.
+ *
+ *  This function generates a 256-element gamma ramp from the specified exponent
+ *  and then calls @ref glfwSetGammaRamp with it.  The value must be a finite
+ *  number greater than zero.
+ *
+ *  @param[in] monitor The monitor whose gamma ramp to set.
+ *  @param[in] gamma The desired exponent.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_INVALID_VALUE and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref monitor_gamma
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup monitor
+ */
+GLFWAPI void glfwSetGamma(GLFWmonitor* monitor, float gamma);
+
+/*! @brief Returns the current gamma ramp for the specified monitor.
+ *
+ *  This function returns the current gamma ramp of the specified monitor.
+ *
+ *  @param[in] monitor The monitor to query.
+ *  @return The current gamma ramp, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @pointer_lifetime The returned structure and its arrays are allocated and
+ *  freed by GLFW.  You should not free them yourself.  They are valid until the
+ *  specified monitor is disconnected, this function is called again for that
+ *  monitor or the library is terminated.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref monitor_gamma
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup monitor
+ */
+GLFWAPI const GLFWgammaramp* glfwGetGammaRamp(GLFWmonitor* monitor);
+
+/*! @brief Sets the current gamma ramp for the specified monitor.
+ *
+ *  This function sets the current gamma ramp for the specified monitor.  The
+ *  original gamma ramp for that monitor is saved by GLFW the first time this
+ *  function is called and is restored by @ref glfwTerminate.
+ *
+ *  @param[in] monitor The monitor whose gamma ramp to set.
+ *  @param[in] ramp The gamma ramp to use.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @remark Gamma ramp sizes other than 256 are not supported by all platforms
+ *  or graphics hardware.
+ *
+ *  @remark @win32 The gamma ramp size must be 256.
+ *
+ *  @pointer_lifetime The specified gamma ramp is copied before this function
+ *  returns.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref monitor_gamma
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup monitor
+ */
+GLFWAPI void glfwSetGammaRamp(GLFWmonitor* monitor, const GLFWgammaramp* ramp);
+
+/*! @brief Resets all window hints to their default values.
+ *
+ *  This function resets all window hints to their
+ *  [default values](@ref window_hints_values).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_hints
+ *  @sa glfwWindowHint
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwDefaultWindowHints(void);
+
+/*! @brief Sets the specified window hint to the desired value.
+ *
+ *  This function sets hints for the next call to @ref glfwCreateWindow.  The
+ *  hints, once set, retain their values until changed by a call to @ref
+ *  glfwWindowHint or @ref glfwDefaultWindowHints, or until the library is
+ *  terminated.
+ *
+ *  This function does not check whether the specified hint values are valid.
+ *  If you set hints to invalid values this will instead be reported by the next
+ *  call to @ref glfwCreateWindow.
+ *
+ *  @param[in] hint The [window hint](@ref window_hints) to set.
+ *  @param[in] value The new value of the window hint.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_INVALID_ENUM.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_hints
+ *  @sa glfwDefaultWindowHints
+ *
+ *  @since Added in version 3.0.  Replaces `glfwOpenWindowHint`.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwWindowHint(int hint, int value);
+
+/*! @brief Creates a window and its associated context.
+ *
+ *  This function creates a window and its associated OpenGL or OpenGL ES
+ *  context.  Most of the options controlling how the window and its context
+ *  should be created are specified with [window hints](@ref window_hints).
+ *
+ *  Successful creation does not change which context is current.  Before you
+ *  can use the newly created context, you need to
+ *  [make it current](@ref context_current).  For information about the `share`
+ *  parameter, see @ref context_sharing.
+ *
+ *  The created window, framebuffer and context may differ from what you
+ *  requested, as not all parameters and hints are
+ *  [hard constraints](@ref window_hints_hard).  This includes the size of the
+ *  window, especially for full screen windows.  To query the actual attributes
+ *  of the created window, framebuffer and context, see @ref
+ *  glfwGetWindowAttrib, @ref glfwGetWindowSize and @ref glfwGetFramebufferSize.
+ *
+ *  To create a full screen window, you need to specify the monitor the window
+ *  will cover.  If no monitor is specified, the window will be windowed mode.
+ *  Unless you have a way for the user to choose a specific monitor, it is
+ *  recommended that you pick the primary monitor.  For more information on how
+ *  to query connected monitors, see @ref monitor_monitors.
+ *
+ *  For full screen windows, the specified size becomes the resolution of the
+ *  window's _desired video mode_.  As long as a full screen window is not
+ *  iconified, the supported video mode most closely matching the desired video
+ *  mode is set for the specified monitor.  For more information about full
+ *  screen windows, including the creation of so called _windowed full screen_
+ *  or _borderless full screen_ windows, see @ref window_windowed_full_screen.
+ *
+ *  Once you have created the window, you can switch it between windowed and
+ *  full screen mode with @ref glfwSetWindowMonitor.  If the window has an
+ *  OpenGL or OpenGL ES context, it will be unaffected.
+ *
+ *  By default, newly created windows use the placement recommended by the
+ *  window system.  To create the window at a specific position, make it
+ *  initially invisible using the [GLFW_VISIBLE](@ref window_hints_wnd) window
+ *  hint, set its [position](@ref window_pos) and then [show](@ref window_hide)
+ *  it.
+ *
+ *  As long as at least one full screen window is not iconified, the screensaver
+ *  is prohibited from starting.
+ *
+ *  Window systems put limits on window sizes.  Very large or very small window
+ *  dimensions may be overridden by the window system on creation.  Check the
+ *  actual [size](@ref window_size) after creation.
+ *
+ *  The [swap interval](@ref buffer_swap) is not set during window creation and
+ *  the initial value may vary depending on driver settings and defaults.
+ *
+ *  @param[in] width The desired width, in screen coordinates, of the window.
+ *  This must be greater than zero.
+ *  @param[in] height The desired height, in screen coordinates, of the window.
+ *  This must be greater than zero.
+ *  @param[in] title The initial, UTF-8 encoded window title.
+ *  @param[in] monitor The monitor to use for full screen mode, or `NULL` for
+ *  windowed mode.
+ *  @param[in] share The window whose context to share resources with, or `NULL`
+ *  to not share resources.
+ *  @return The handle of the created window, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_INVALID_ENUM, @ref GLFW_INVALID_VALUE, @ref GLFW_API_UNAVAILABLE, @ref
+ *  GLFW_VERSION_UNAVAILABLE, @ref GLFW_FORMAT_UNAVAILABLE and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @remark @win32 Window creation will fail if the Microsoft GDI software
+ *  OpenGL implementation is the only one available.
+ *
+ *  @remark @win32 If the executable has an icon resource named `GLFW_ICON,` it
+ *  will be set as the initial icon for the window.  If no such icon is present,
+ *  the `IDI_WINLOGO` icon will be used instead.  To set a different icon, see
+ *  @ref glfwSetWindowIcon.
+ *
+ *  @remark @win32 The context to share resources with must not be current on
+ *  any other thread.
+ *
+ *  @remark @osx The GLFW window has no icon, as it is not a document
+ *  window, but the dock icon will be the same as the application bundle's icon.
+ *  For more information on bundles, see the
+ *  [Bundle Programming Guide](https://developer.apple.com/library/mac/documentation/CoreFoundation/Conceptual/CFBundles/)
+ *  in the Mac Developer Library.
+ *
+ *  @remark @osx The first time a window is created the menu bar is populated
+ *  with common commands like Hide, Quit and About.  The About entry opens
+ *  a minimal about dialog with information from the application's bundle.  The
+ *  menu bar can be disabled with a
+ *  [compile-time option](@ref compile_options_osx).
+ *
+ *  @remark @osx On OS X 10.10 and later the window frame will not be rendered
+ *  at full resolution on Retina displays unless the `NSHighResolutionCapable`
+ *  key is enabled in the application bundle's `Info.plist`.  For more
+ *  information, see
+ *  [High Resolution Guidelines for OS X](https://developer.apple.com/library/mac/documentation/GraphicsAnimation/Conceptual/HighResolutionOSX/Explained/Explained.html)
+ *  in the Mac Developer Library.  The GLFW test and example programs use
+ *  a custom `Info.plist` template for this, which can be found as
+ *  `CMake/MacOSXBundleInfo.plist.in` in the source tree.
+ *
+ *  @remark @x11 Some window managers will not respect the placement of
+ *  initially hidden windows.
+ *
+ *  @remark @x11 Due to the asynchronous nature of X11, it may take a moment for
+ *  a window to reach its requested state.  This means you may not be able to
+ *  query the final size, position or other attributes directly after window
+ *  creation.
+ *
+ *  @reentrancy This function must not be called from a callback.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_creation
+ *  @sa glfwDestroyWindow
+ *
+ *  @since Added in version 3.0.  Replaces `glfwOpenWindow`.
+ *
+ *  @ingroup window
+ */
+GLFWAPI GLFWwindow* glfwCreateWindow(int width, int height, const char* title, GLFWmonitor* monitor, GLFWwindow* share);
+
+/*! @brief Destroys the specified window and its context.
+ *
+ *  This function destroys the specified window and its context.  On calling
+ *  this function, no further callbacks will be called for that window.
+ *
+ *  If the context of the specified window is current on the main thread, it is
+ *  detached before being destroyed.
+ *
+ *  @param[in] window The window to destroy.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @note The context of the specified window must not be current on any other
+ *  thread when this function is called.
+ *
+ *  @reentrancy This function must not be called from a callback.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_creation
+ *  @sa glfwCreateWindow
+ *
+ *  @since Added in version 3.0.  Replaces `glfwCloseWindow`.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwDestroyWindow(GLFWwindow* window);
+
+/*! @brief Checks the close flag of the specified window.
+ *
+ *  This function returns the value of the close flag of the specified window.
+ *
+ *  @param[in] window The window to query.
+ *  @return The value of the close flag.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @sa @ref window_close
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+GLFWAPI int glfwWindowShouldClose(GLFWwindow* window);
+
+/*! @brief Sets the close flag of the specified window.
+ *
+ *  This function sets the value of the close flag of the specified window.
+ *  This can be used to override the user's attempt to close the window, or
+ *  to signal that it should be closed.
+ *
+ *  @param[in] window The window whose flag to change.
+ *  @param[in] value The new value.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @sa @ref window_close
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwSetWindowShouldClose(GLFWwindow* window, int value);
+
+/*! @brief Sets the title of the specified window.
+ *
+ *  This function sets the window title, encoded as UTF-8, of the specified
+ *  window.
+ *
+ *  @param[in] window The window whose title to change.
+ *  @param[in] title The UTF-8 encoded window title.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @remark @osx The window title will not be updated until the next time you
+ *  process events.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_title
+ *
+ *  @since Added in version 1.0.
+ *  @glfw3 Added window handle parameter.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwSetWindowTitle(GLFWwindow* window, const char* title);
+
+/*! @brief Sets the icon for the specified window.
+ *
+ *  This function sets the icon of the specified window.  If passed an array of
+ *  candidate images, those of or closest to the sizes desired by the system are
+ *  selected.  If no images are specified, the window reverts to its default
+ *  icon.
+ *
+ *  The desired image sizes varies depending on platform and system settings.
+ *  The selected images will be rescaled as needed.  Good sizes include 16x16,
+ *  32x32 and 48x48.
+ *
+ *  @param[in] window The window whose icon to set.
+ *  @param[in] count The number of images in the specified array, or zero to
+ *  revert to the default window icon.
+ *  @param[in] images The images to create the icon from.  This is ignored if
+ *  count is zero.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @pointer_lifetime The specified image data is copied before this function
+ *  returns.
+ *
+ *  @remark @osx The GLFW window has no icon, as it is not a document
+ *  window, so this function does nothing.  The dock icon will be the same as
+ *  the application bundle's icon.  For more information on bundles, see the
+ *  [Bundle Programming Guide](https://developer.apple.com/library/mac/documentation/CoreFoundation/Conceptual/CFBundles/)
+ *  in the Mac Developer Library.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_icon
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwSetWindowIcon(GLFWwindow* window, int count, const GLFWimage* images);
+
+/*! @brief Retrieves the position of the client area of the specified window.
+ *
+ *  This function retrieves the position, in screen coordinates, of the
+ *  upper-left corner of the client area of the specified window.
+ *
+ *  Any or all of the position arguments may be `NULL`.  If an error occurs, all
+ *  non-`NULL` position arguments will be set to zero.
+ *
+ *  @param[in] window The window to query.
+ *  @param[out] xpos Where to store the x-coordinate of the upper-left corner of
+ *  the client area, or `NULL`.
+ *  @param[out] ypos Where to store the y-coordinate of the upper-left corner of
+ *  the client area, or `NULL`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_pos
+ *  @sa glfwSetWindowPos
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwGetWindowPos(GLFWwindow* window, int* xpos, int* ypos);
+
+/*! @brief Sets the position of the client area of the specified window.
+ *
+ *  This function sets the position, in screen coordinates, of the upper-left
+ *  corner of the client area of the specified windowed mode window.  If the
+ *  window is a full screen window, this function does nothing.
+ *
+ *  __Do not use this function__ to move an already visible window unless you
+ *  have very good reasons for doing so, as it will confuse and annoy the user.
+ *
+ *  The window manager may put limits on what positions are allowed.  GLFW
+ *  cannot and should not override these limits.
+ *
+ *  @param[in] window The window to query.
+ *  @param[in] xpos The x-coordinate of the upper-left corner of the client area.
+ *  @param[in] ypos The y-coordinate of the upper-left corner of the client area.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_pos
+ *  @sa glfwGetWindowPos
+ *
+ *  @since Added in version 1.0.
+ *  @glfw3 Added window handle parameter.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwSetWindowPos(GLFWwindow* window, int xpos, int ypos);
+
+/*! @brief Retrieves the size of the client area of the specified window.
+ *
+ *  This function retrieves the size, in screen coordinates, of the client area
+ *  of the specified window.  If you wish to retrieve the size of the
+ *  framebuffer of the window in pixels, see @ref glfwGetFramebufferSize.
+ *
+ *  Any or all of the size arguments may be `NULL`.  If an error occurs, all
+ *  non-`NULL` size arguments will be set to zero.
+ *
+ *  @param[in] window The window whose size to retrieve.
+ *  @param[out] width Where to store the width, in screen coordinates, of the
+ *  client area, or `NULL`.
+ *  @param[out] height Where to store the height, in screen coordinates, of the
+ *  client area, or `NULL`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_size
+ *  @sa glfwSetWindowSize
+ *
+ *  @since Added in version 1.0.
+ *  @glfw3 Added window handle parameter.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwGetWindowSize(GLFWwindow* window, int* width, int* height);
+
+/*! @brief Sets the size limits of the specified window.
+ *
+ *  This function sets the size limits of the client area of the specified
+ *  window.  If the window is full screen, the size limits only take effect
+ *  once it is made windowed.  If the window is not resizable, this function
+ *  does nothing.
+ *
+ *  The size limits are applied immediately to a windowed mode window and may
+ *  cause it to be resized.
+ *
+ *  The maximum dimensions must be greater than or equal to the minimum
+ *  dimensions and all must be greater than or equal to zero.
+ *
+ *  @param[in] window The window to set limits for.
+ *  @param[in] minwidth The minimum width, in screen coordinates, of the client
+ *  area, or `GLFW_DONT_CARE`.
+ *  @param[in] minheight The minimum height, in screen coordinates, of the
+ *  client area, or `GLFW_DONT_CARE`.
+ *  @param[in] maxwidth The maximum width, in screen coordinates, of the client
+ *  area, or `GLFW_DONT_CARE`.
+ *  @param[in] maxheight The maximum height, in screen coordinates, of the
+ *  client area, or `GLFW_DONT_CARE`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_INVALID_VALUE and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @remark If you set size limits and an aspect ratio that conflict, the
+ *  results are undefined.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_sizelimits
+ *  @sa glfwSetWindowAspectRatio
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwSetWindowSizeLimits(GLFWwindow* window, int minwidth, int minheight, int maxwidth, int maxheight);
+
+/*! @brief Sets the aspect ratio of the specified window.
+ *
+ *  This function sets the required aspect ratio of the client area of the
+ *  specified window.  If the window is full screen, the aspect ratio only takes
+ *  effect once it is made windowed.  If the window is not resizable, this
+ *  function does nothing.
+ *
+ *  The aspect ratio is specified as a numerator and a denominator and both
+ *  values must be greater than zero.  For example, the common 16:9 aspect ratio
+ *  is specified as 16 and 9, respectively.
+ *
+ *  If the numerator and denominator is set to `GLFW_DONT_CARE` then the aspect
+ *  ratio limit is disabled.
+ *
+ *  The aspect ratio is applied immediately to a windowed mode window and may
+ *  cause it to be resized.
+ *
+ *  @param[in] window The window to set limits for.
+ *  @param[in] numer The numerator of the desired aspect ratio, or
+ *  `GLFW_DONT_CARE`.
+ *  @param[in] denom The denominator of the desired aspect ratio, or
+ *  `GLFW_DONT_CARE`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_INVALID_VALUE and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @remark If you set size limits and an aspect ratio that conflict, the
+ *  results are undefined.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_sizelimits
+ *  @sa glfwSetWindowSizeLimits
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwSetWindowAspectRatio(GLFWwindow* window, int numer, int denom);
+
+/*! @brief Sets the size of the client area of the specified window.
+ *
+ *  This function sets the size, in screen coordinates, of the client area of
+ *  the specified window.
+ *
+ *  For full screen windows, this function updates the resolution of its desired
+ *  video mode and switches to the video mode closest to it, without affecting
+ *  the window's context.  As the context is unaffected, the bit depths of the
+ *  framebuffer remain unchanged.
+ *
+ *  If you wish to update the refresh rate of the desired video mode in addition
+ *  to its resolution, see @ref glfwSetWindowMonitor.
+ *
+ *  The window manager may put limits on what sizes are allowed.  GLFW cannot
+ *  and should not override these limits.
+ *
+ *  @param[in] window The window to resize.
+ *  @param[in] width The desired width, in screen coordinates, of the window
+ *  client area.
+ *  @param[in] height The desired height, in screen coordinates, of the window
+ *  client area.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_size
+ *  @sa glfwGetWindowSize
+ *  @sa glfwSetWindowMonitor
+ *
+ *  @since Added in version 1.0.
+ *  @glfw3 Added window handle parameter.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwSetWindowSize(GLFWwindow* window, int width, int height);
+
+/*! @brief Retrieves the size of the framebuffer of the specified window.
+ *
+ *  This function retrieves the size, in pixels, of the framebuffer of the
+ *  specified window.  If you wish to retrieve the size of the window in screen
+ *  coordinates, see @ref glfwGetWindowSize.
+ *
+ *  Any or all of the size arguments may be `NULL`.  If an error occurs, all
+ *  non-`NULL` size arguments will be set to zero.
+ *
+ *  @param[in] window The window whose framebuffer to query.
+ *  @param[out] width Where to store the width, in pixels, of the framebuffer,
+ *  or `NULL`.
+ *  @param[out] height Where to store the height, in pixels, of the framebuffer,
+ *  or `NULL`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_fbsize
+ *  @sa glfwSetFramebufferSizeCallback
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwGetFramebufferSize(GLFWwindow* window, int* width, int* height);
+
+/*! @brief Retrieves the size of the frame of the window.
+ *
+ *  This function retrieves the size, in screen coordinates, of each edge of the
+ *  frame of the specified window.  This size includes the title bar, if the
+ *  window has one.  The size of the frame may vary depending on the
+ *  [window-related hints](@ref window_hints_wnd) used to create it.
+ *
+ *  Because this function retrieves the size of each window frame edge and not
+ *  the offset along a particular coordinate axis, the retrieved values will
+ *  always be zero or positive.
+ *
+ *  Any or all of the size arguments may be `NULL`.  If an error occurs, all
+ *  non-`NULL` size arguments will be set to zero.
+ *
+ *  @param[in] window The window whose frame size to query.
+ *  @param[out] left Where to store the size, in screen coordinates, of the left
+ *  edge of the window frame, or `NULL`.
+ *  @param[out] top Where to store the size, in screen coordinates, of the top
+ *  edge of the window frame, or `NULL`.
+ *  @param[out] right Where to store the size, in screen coordinates, of the
+ *  right edge of the window frame, or `NULL`.
+ *  @param[out] bottom Where to store the size, in screen coordinates, of the
+ *  bottom edge of the window frame, or `NULL`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_size
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwGetWindowFrameSize(GLFWwindow* window, int* left, int* top, int* right, int* bottom);
+
+/*! @brief Iconifies the specified window.
+ *
+ *  This function iconifies (minimizes) the specified window if it was
+ *  previously restored.  If the window is already iconified, this function does
+ *  nothing.
+ *
+ *  If the specified window is a full screen window, the original monitor
+ *  resolution is restored until the window is restored.
+ *
+ *  @param[in] window The window to iconify.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_iconify
+ *  @sa glfwRestoreWindow
+ *  @sa glfwMaximizeWindow
+ *
+ *  @since Added in version 2.1.
+ *  @glfw3 Added window handle parameter.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwIconifyWindow(GLFWwindow* window);
+
+/*! @brief Restores the specified window.
+ *
+ *  This function restores the specified window if it was previously iconified
+ *  (minimized) or maximized.  If the window is already restored, this function
+ *  does nothing.
+ *
+ *  If the specified window is a full screen window, the resolution chosen for
+ *  the window is restored on the selected monitor.
+ *
+ *  @param[in] window The window to restore.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_iconify
+ *  @sa glfwIconifyWindow
+ *  @sa glfwMaximizeWindow
+ *
+ *  @since Added in version 2.1.
+ *  @glfw3 Added window handle parameter.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwRestoreWindow(GLFWwindow* window);
+
+/*! @brief Maximizes the specified window.
+ *
+ *  This function maximizes the specified window if it was previously not
+ *  maximized.  If the window is already maximized, this function does nothing.
+ *
+ *  If the specified window is a full screen window, this function does nothing.
+ *
+ *  @param[in] window The window to maximize.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @par Thread Safety
+ *  This function may only be called from the main thread.
+ *
+ *  @sa @ref window_iconify
+ *  @sa glfwIconifyWindow
+ *  @sa glfwRestoreWindow
+ *
+ *  @since Added in GLFW 3.2.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwMaximizeWindow(GLFWwindow* window);
+
+/*! @brief Makes the specified window visible.
+ *
+ *  This function makes the specified window visible if it was previously
+ *  hidden.  If the window is already visible or is in full screen mode, this
+ *  function does nothing.
+ *
+ *  @param[in] window The window to make visible.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_hide
+ *  @sa glfwHideWindow
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwShowWindow(GLFWwindow* window);
+
+/*! @brief Hides the specified window.
+ *
+ *  This function hides the specified window if it was previously visible.  If
+ *  the window is already hidden or is in full screen mode, this function does
+ *  nothing.
+ *
+ *  @param[in] window The window to hide.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_hide
+ *  @sa glfwShowWindow
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwHideWindow(GLFWwindow* window);
+
+/*! @brief Brings the specified window to front and sets input focus.
+ *
+ *  This function brings the specified window to front and sets input focus.
+ *  The window should already be visible and not iconified.
+ *
+ *  By default, both windowed and full screen mode windows are focused when
+ *  initially created.  Set the [GLFW_FOCUSED](@ref window_hints_wnd) to disable
+ *  this behavior.
+ *
+ *  __Do not use this function__ to steal focus from other applications unless
+ *  you are certain that is what the user wants.  Focus stealing can be
+ *  extremely disruptive.
+ *
+ *  @param[in] window The window to give input focus.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_focus
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwFocusWindow(GLFWwindow* window);
+
+/*! @brief Returns the monitor that the window uses for full screen mode.
+ *
+ *  This function returns the handle of the monitor that the specified window is
+ *  in full screen on.
+ *
+ *  @param[in] window The window to query.
+ *  @return The monitor, or `NULL` if the window is in windowed mode or an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_monitor
+ *  @sa glfwSetWindowMonitor
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+GLFWAPI GLFWmonitor* glfwGetWindowMonitor(GLFWwindow* window);
+
+/*! @brief Sets the mode, monitor, video mode and placement of a window.
+ *
+ *  This function sets the monitor that the window uses for full screen mode or,
+ *  if the monitor is `NULL`, makes it windowed mode.
+ *
+ *  When setting a monitor, this function updates the width, height and refresh
+ *  rate of the desired video mode and switches to the video mode closest to it.
+ *  The window position is ignored when setting a monitor.
+ *
+ *  When the monitor is `NULL`, the position, width and height are used to
+ *  place the window client area.  The refresh rate is ignored when no monitor
+ *  is specified.
+ *
+ *  If you only wish to update the resolution of a full screen window or the
+ *  size of a windowed mode window, see @ref glfwSetWindowSize.
+ *
+ *  When a window transitions from full screen to windowed mode, this function
+ *  restores any previous window settings such as whether it is decorated,
+ *  floating, resizable, has size or aspect ratio limits, etc..
+ *
+ *  @param[in] window The window whose monitor, size or video mode to set.
+ *  @param[in] monitor The desired monitor, or `NULL` to set windowed mode.
+ *  @param[in] xpos The desired x-coordinate of the upper-left corner of the
+ *  client area.
+ *  @param[in] ypos The desired y-coordinate of the upper-left corner of the
+ *  client area.
+ *  @param[in] width The desired with, in screen coordinates, of the client area
+ *  or video mode.
+ *  @param[in] height The desired height, in screen coordinates, of the client
+ *  area or video mode.
+ *  @param[in] refreshRate The desired refresh rate, in Hz, of the video mode,
+ *  or `GLFW_DONT_CARE`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_monitor
+ *  @sa @ref window_full_screen
+ *  @sa glfwGetWindowMonitor
+ *  @sa glfwSetWindowSize
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwSetWindowMonitor(GLFWwindow* window, GLFWmonitor* monitor, int xpos, int ypos, int width, int height, int refreshRate);
+
+/*! @brief Returns an attribute of the specified window.
+ *
+ *  This function returns the value of an attribute of the specified window or
+ *  its OpenGL or OpenGL ES context.
+ *
+ *  @param[in] window The window to query.
+ *  @param[in] attrib The [window attribute](@ref window_attribs) whose value to
+ *  return.
+ *  @return The value of the attribute, or zero if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @remark Framebuffer related hints are not window attributes.  See @ref
+ *  window_attribs_fb for more information.
+ *
+ *  @remark Zero is a valid value for many window and context related
+ *  attributes so you cannot use a return value of zero as an indication of
+ *  errors.  However, this function should not fail as long as it is passed
+ *  valid arguments and the library has been [initialized](@ref intro_init).
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_attribs
+ *
+ *  @since Added in version 3.0.  Replaces `glfwGetWindowParam` and
+ *  `glfwGetGLVersion`.
+ *
+ *  @ingroup window
+ */
+GLFWAPI int glfwGetWindowAttrib(GLFWwindow* window, int attrib);
+
+/*! @brief Sets the user pointer of the specified window.
+ *
+ *  This function sets the user-defined pointer of the specified window.  The
+ *  current value is retained until the window is destroyed.  The initial value
+ *  is `NULL`.
+ *
+ *  @param[in] window The window whose pointer to set.
+ *  @param[in] pointer The new value.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @sa @ref window_userptr
+ *  @sa glfwGetWindowUserPointer
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwSetWindowUserPointer(GLFWwindow* window, void* pointer);
+
+/*! @brief Returns the user pointer of the specified window.
+ *
+ *  This function returns the current value of the user-defined pointer of the
+ *  specified window.  The initial value is `NULL`.
+ *
+ *  @param[in] window The window whose pointer to return.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @sa @ref window_userptr
+ *  @sa glfwSetWindowUserPointer
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void* glfwGetWindowUserPointer(GLFWwindow* window);
+
+/*! @brief Sets the position callback for the specified window.
+ *
+ *  This function sets the position callback of the specified window, which is
+ *  called when the window is moved.  The callback is provided with the screen
+ *  position of the upper-left corner of the client area of the window.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] cbfun The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_pos
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+GLFWAPI GLFWwindowposfun glfwSetWindowPosCallback(GLFWwindow* window, GLFWwindowposfun cbfun);
+
+/*! @brief Sets the size callback for the specified window.
+ *
+ *  This function sets the size callback of the specified window, which is
+ *  called when the window is resized.  The callback is provided with the size,
+ *  in screen coordinates, of the client area of the window.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] cbfun The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_size
+ *
+ *  @since Added in version 1.0.
+ *  @glfw3 Added window handle parameter and return value.
+ *
+ *  @ingroup window
+ */
+GLFWAPI GLFWwindowsizefun glfwSetWindowSizeCallback(GLFWwindow* window, GLFWwindowsizefun cbfun);
+
+/*! @brief Sets the close callback for the specified window.
+ *
+ *  This function sets the close callback of the specified window, which is
+ *  called when the user attempts to close the window, for example by clicking
+ *  the close widget in the title bar.
+ *
+ *  The close flag is set before this callback is called, but you can modify it
+ *  at any time with @ref glfwSetWindowShouldClose.
+ *
+ *  The close callback is not triggered by @ref glfwDestroyWindow.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] cbfun The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @remark @osx Selecting Quit from the application menu will trigger the close
+ *  callback for all windows.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_close
+ *
+ *  @since Added in version 2.5.
+ *  @glfw3 Added window handle parameter and return value.
+ *
+ *  @ingroup window
+ */
+GLFWAPI GLFWwindowclosefun glfwSetWindowCloseCallback(GLFWwindow* window, GLFWwindowclosefun cbfun);
+
+/*! @brief Sets the refresh callback for the specified window.
+ *
+ *  This function sets the refresh callback of the specified window, which is
+ *  called when the client area of the window needs to be redrawn, for example
+ *  if the window has been exposed after having been covered by another window.
+ *
+ *  On compositing window systems such as Aero, Compiz or Aqua, where the window
+ *  contents are saved off-screen, this callback may be called only very
+ *  infrequently or never at all.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] cbfun The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_refresh
+ *
+ *  @since Added in version 2.5.
+ *  @glfw3 Added window handle parameter and return value.
+ *
+ *  @ingroup window
+ */
+GLFWAPI GLFWwindowrefreshfun glfwSetWindowRefreshCallback(GLFWwindow* window, GLFWwindowrefreshfun cbfun);
+
+/*! @brief Sets the focus callback for the specified window.
+ *
+ *  This function sets the focus callback of the specified window, which is
+ *  called when the window gains or loses input focus.
+ *
+ *  After the focus callback is called for a window that lost input focus,
+ *  synthetic key and mouse button release events will be generated for all such
+ *  that had been pressed.  For more information, see @ref glfwSetKeyCallback
+ *  and @ref glfwSetMouseButtonCallback.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] cbfun The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_focus
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+GLFWAPI GLFWwindowfocusfun glfwSetWindowFocusCallback(GLFWwindow* window, GLFWwindowfocusfun cbfun);
+
+/*! @brief Sets the iconify callback for the specified window.
+ *
+ *  This function sets the iconification callback of the specified window, which
+ *  is called when the window is iconified or restored.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] cbfun The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_iconify
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+GLFWAPI GLFWwindowiconifyfun glfwSetWindowIconifyCallback(GLFWwindow* window, GLFWwindowiconifyfun cbfun);
+
+/*! @brief Sets the framebuffer resize callback for the specified window.
+ *
+ *  This function sets the framebuffer resize callback of the specified window,
+ *  which is called when the framebuffer of the specified window is resized.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] cbfun The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_fbsize
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+GLFWAPI GLFWframebuffersizefun glfwSetFramebufferSizeCallback(GLFWwindow* window, GLFWframebuffersizefun cbfun);
+
+/*! @brief Processes all pending events.
+ *
+ *  This function processes only those events that are already in the event
+ *  queue and then returns immediately.  Processing events will cause the window
+ *  and input callbacks associated with those events to be called.
+ *
+ *  On some platforms, a window move, resize or menu operation will cause event
+ *  processing to block.  This is due to how event processing is designed on
+ *  those platforms.  You can use the
+ *  [window refresh callback](@ref window_refresh) to redraw the contents of
+ *  your window when necessary during such operations.
+ *
+ *  On some platforms, certain events are sent directly to the application
+ *  without going through the event queue, causing callbacks to be called
+ *  outside of a call to one of the event processing functions.
+ *
+ *  Event processing is not required for joystick input to work.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @reentrancy This function must not be called from a callback.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref events
+ *  @sa glfwWaitEvents
+ *  @sa glfwWaitEventsTimeout
+ *
+ *  @since Added in version 1.0.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwPollEvents(void);
+
+/*! @brief Waits until events are queued and processes them.
+ *
+ *  This function puts the calling thread to sleep until at least one event is
+ *  available in the event queue.  Once one or more events are available,
+ *  it behaves exactly like @ref glfwPollEvents, i.e. the events in the queue
+ *  are processed and the function then returns immediately.  Processing events
+ *  will cause the window and input callbacks associated with those events to be
+ *  called.
+ *
+ *  Since not all events are associated with callbacks, this function may return
+ *  without a callback having been called even if you are monitoring all
+ *  callbacks.
+ *
+ *  On some platforms, a window move, resize or menu operation will cause event
+ *  processing to block.  This is due to how event processing is designed on
+ *  those platforms.  You can use the
+ *  [window refresh callback](@ref window_refresh) to redraw the contents of
+ *  your window when necessary during such operations.
+ *
+ *  On some platforms, certain callbacks may be called outside of a call to one
+ *  of the event processing functions.
+ *
+ *  If no windows exist, this function returns immediately.  For synchronization
+ *  of threads in applications that do not create windows, use your threading
+ *  library of choice.
+ *
+ *  Event processing is not required for joystick input to work.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @reentrancy This function must not be called from a callback.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref events
+ *  @sa glfwPollEvents
+ *  @sa glfwWaitEventsTimeout
+ *
+ *  @since Added in version 2.5.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwWaitEvents(void);
+
+/*! @brief Waits with timeout until events are queued and processes them.
+ *
+ *  This function puts the calling thread to sleep until at least one event is
+ *  available in the event queue, or until the specified timeout is reached.  If
+ *  one or more events are available, it behaves exactly like @ref
+ *  glfwPollEvents, i.e. the events in the queue are processed and the function
+ *  then returns immediately.  Processing events will cause the window and input
+ *  callbacks associated with those events to be called.
+ *
+ *  The timeout value must be a positive finite number.
+ *
+ *  Since not all events are associated with callbacks, this function may return
+ *  without a callback having been called even if you are monitoring all
+ *  callbacks.
+ *
+ *  On some platforms, a window move, resize or menu operation will cause event
+ *  processing to block.  This is due to how event processing is designed on
+ *  those platforms.  You can use the
+ *  [window refresh callback](@ref window_refresh) to redraw the contents of
+ *  your window when necessary during such operations.
+ *
+ *  On some platforms, certain callbacks may be called outside of a call to one
+ *  of the event processing functions.
+ *
+ *  If no windows exist, this function returns immediately.  For synchronization
+ *  of threads in applications that do not create windows, use your threading
+ *  library of choice.
+ *
+ *  Event processing is not required for joystick input to work.
+ *
+ *  @param[in] timeout The maximum amount of time, in seconds, to wait.
+ *
+ *  @reentrancy This function must not be called from a callback.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref events
+ *  @sa glfwPollEvents
+ *  @sa glfwWaitEvents
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwWaitEventsTimeout(double timeout);
+
+/*! @brief Posts an empty event to the event queue.
+ *
+ *  This function posts an empty event from the current thread to the event
+ *  queue, causing @ref glfwWaitEvents or @ref glfwWaitEventsTimeout to return.
+ *
+ *  If no windows exist, this function returns immediately.  For synchronization
+ *  of threads in applications that do not create windows, use your threading
+ *  library of choice.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function may be called from any thread.
+ *
+ *  @sa @ref events
+ *  @sa glfwWaitEvents
+ *  @sa glfwWaitEventsTimeout
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwPostEmptyEvent(void);
+
+/*! @brief Returns the value of an input option for the specified window.
+ *
+ *  This function returns the value of an input option for the specified window.
+ *  The mode must be one of `GLFW_CURSOR`, `GLFW_STICKY_KEYS` or
+ *  `GLFW_STICKY_MOUSE_BUTTONS`.
+ *
+ *  @param[in] window The window to query.
+ *  @param[in] mode One of `GLFW_CURSOR`, `GLFW_STICKY_KEYS` or
+ *  `GLFW_STICKY_MOUSE_BUTTONS`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_INVALID_ENUM.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa glfwSetInputMode
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup input
+ */
+GLFWAPI int glfwGetInputMode(GLFWwindow* window, int mode);
+
+/*! @brief Sets an input option for the specified window.
+ *
+ *  This function sets an input mode option for the specified window.  The mode
+ *  must be one of `GLFW_CURSOR`, `GLFW_STICKY_KEYS` or
+ *  `GLFW_STICKY_MOUSE_BUTTONS`.
+ *
+ *  If the mode is `GLFW_CURSOR`, the value must be one of the following cursor
+ *  modes:
+ *  - `GLFW_CURSOR_NORMAL` makes the cursor visible and behaving normally.
+ *  - `GLFW_CURSOR_HIDDEN` makes the cursor invisible when it is over the client
+ *    area of the window but does not restrict the cursor from leaving.
+ *  - `GLFW_CURSOR_DISABLED` hides and grabs the cursor, providing virtual
+ *    and unlimited cursor movement.  This is useful for implementing for
+ *    example 3D camera controls.
+ *
+ *  If the mode is `GLFW_STICKY_KEYS`, the value must be either `GLFW_TRUE` to
+ *  enable sticky keys, or `GLFW_FALSE` to disable it.  If sticky keys are
+ *  enabled, a key press will ensure that @ref glfwGetKey returns `GLFW_PRESS`
+ *  the next time it is called even if the key had been released before the
+ *  call.  This is useful when you are only interested in whether keys have been
+ *  pressed but not when or in which order.
+ *
+ *  If the mode is `GLFW_STICKY_MOUSE_BUTTONS`, the value must be either
+ *  `GLFW_TRUE` to enable sticky mouse buttons, or `GLFW_FALSE` to disable it.
+ *  If sticky mouse buttons are enabled, a mouse button press will ensure that
+ *  @ref glfwGetMouseButton returns `GLFW_PRESS` the next time it is called even
+ *  if the mouse button had been released before the call.  This is useful when
+ *  you are only interested in whether mouse buttons have been pressed but not
+ *  when or in which order.
+ *
+ *  @param[in] window The window whose input mode to set.
+ *  @param[in] mode One of `GLFW_CURSOR`, `GLFW_STICKY_KEYS` or
+ *  `GLFW_STICKY_MOUSE_BUTTONS`.
+ *  @param[in] value The new value of the specified input mode.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa glfwGetInputMode
+ *
+ *  @since Added in version 3.0.  Replaces `glfwEnable` and `glfwDisable`.
+ *
+ *  @ingroup input
+ */
+GLFWAPI void glfwSetInputMode(GLFWwindow* window, int mode, int value);
+
+/*! @brief Returns the localized name of the specified printable key.
+ *
+ *  This function returns the localized name of the specified printable key.
+ *  This is intended for displaying key bindings to the user.
+ *
+ *  If the key is `GLFW_KEY_UNKNOWN`, the scancode is used instead, otherwise
+ *  the scancode is ignored.  If a non-printable key or (if the key is
+ *  `GLFW_KEY_UNKNOWN`) a scancode that maps to a non-printable key is
+ *  specified, this function returns `NULL`.          
+ *
+ *  This behavior allows you to pass in the arguments passed to the
+ *  [key callback](@ref input_key) without modification.
+ *
+ *  The printable keys are:
+ *  - `GLFW_KEY_APOSTROPHE`
+ *  - `GLFW_KEY_COMMA`
+ *  - `GLFW_KEY_MINUS`
+ *  - `GLFW_KEY_PERIOD`
+ *  - `GLFW_KEY_SLASH`
+ *  - `GLFW_KEY_SEMICOLON`
+ *  - `GLFW_KEY_EQUAL`
+ *  - `GLFW_KEY_LEFT_BRACKET`
+ *  - `GLFW_KEY_RIGHT_BRACKET`
+ *  - `GLFW_KEY_BACKSLASH`
+ *  - `GLFW_KEY_WORLD_1`
+ *  - `GLFW_KEY_WORLD_2`
+ *  - `GLFW_KEY_0` to `GLFW_KEY_9`
+ *  - `GLFW_KEY_A` to `GLFW_KEY_Z`
+ *  - `GLFW_KEY_KP_0` to `GLFW_KEY_KP_9`
+ *  - `GLFW_KEY_KP_DECIMAL`
+ *  - `GLFW_KEY_KP_DIVIDE`
+ *  - `GLFW_KEY_KP_MULTIPLY`
+ *  - `GLFW_KEY_KP_SUBTRACT`
+ *  - `GLFW_KEY_KP_ADD`
+ *  - `GLFW_KEY_KP_EQUAL`
+ *
+ *  @param[in] key The key to query, or `GLFW_KEY_UNKNOWN`.
+ *  @param[in] scancode The scancode of the key to query.
+ *  @return The localized name of the key, or `NULL`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @pointer_lifetime The returned string is allocated and freed by GLFW.  You
+ *  should not free it yourself.  It is valid until the next call to @ref
+ *  glfwGetKeyName, or until the library is terminated.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref input_key_name
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup input
+ */
+GLFWAPI const char* glfwGetKeyName(int key, int scancode);
+
+/*! @brief Returns the last reported state of a keyboard key for the specified
+ *  window.
+ *
+ *  This function returns the last state reported for the specified key to the
+ *  specified window.  The returned state is one of `GLFW_PRESS` or
+ *  `GLFW_RELEASE`.  The higher-level action `GLFW_REPEAT` is only reported to
+ *  the key callback.
+ *
+ *  If the `GLFW_STICKY_KEYS` input mode is enabled, this function returns
+ *  `GLFW_PRESS` the first time you call it for a key that was pressed, even if
+ *  that key has already been released.
+ *
+ *  The key functions deal with physical keys, with [key tokens](@ref keys)
+ *  named after their use on the standard US keyboard layout.  If you want to
+ *  input text, use the Unicode character callback instead.
+ *
+ *  The [modifier key bit masks](@ref mods) are not key tokens and cannot be
+ *  used with this function.
+ *
+ *  __Do not use this function__ to implement [text input](@ref input_char).
+ *
+ *  @param[in] window The desired window.
+ *  @param[in] key The desired [keyboard key](@ref keys).  `GLFW_KEY_UNKNOWN` is
+ *  not a valid key for this function.
+ *  @return One of `GLFW_PRESS` or `GLFW_RELEASE`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_INVALID_ENUM.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref input_key
+ *
+ *  @since Added in version 1.0.
+ *  @glfw3 Added window handle parameter.
+ *
+ *  @ingroup input
+ */
+GLFWAPI int glfwGetKey(GLFWwindow* window, int key);
+
+/*! @brief Returns the last reported state of a mouse button for the specified
+ *  window.
+ *
+ *  This function returns the last state reported for the specified mouse button
+ *  to the specified window.  The returned state is one of `GLFW_PRESS` or
+ *  `GLFW_RELEASE`.
+ *
+ *  If the `GLFW_STICKY_MOUSE_BUTTONS` input mode is enabled, this function
+ *  `GLFW_PRESS` the first time you call it for a mouse button that was pressed,
+ *  even if that mouse button has already been released.
+ *
+ *  @param[in] window The desired window.
+ *  @param[in] button The desired [mouse button](@ref buttons).
+ *  @return One of `GLFW_PRESS` or `GLFW_RELEASE`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_INVALID_ENUM.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref input_mouse_button
+ *
+ *  @since Added in version 1.0.
+ *  @glfw3 Added window handle parameter.
+ *
+ *  @ingroup input
+ */
+GLFWAPI int glfwGetMouseButton(GLFWwindow* window, int button);
+
+/*! @brief Retrieves the position of the cursor relative to the client area of
+ *  the window.
+ *
+ *  This function returns the position of the cursor, in screen coordinates,
+ *  relative to the upper-left corner of the client area of the specified
+ *  window.
+ *
+ *  If the cursor is disabled (with `GLFW_CURSOR_DISABLED`) then the cursor
+ *  position is unbounded and limited only by the minimum and maximum values of
+ *  a `double`.
+ *
+ *  The coordinate can be converted to their integer equivalents with the
+ *  `floor` function.  Casting directly to an integer type works for positive
+ *  coordinates, but fails for negative ones.
+ *
+ *  Any or all of the position arguments may be `NULL`.  If an error occurs, all
+ *  non-`NULL` position arguments will be set to zero.
+ *
+ *  @param[in] window The desired window.
+ *  @param[out] xpos Where to store the cursor x-coordinate, relative to the
+ *  left edge of the client area, or `NULL`.
+ *  @param[out] ypos Where to store the cursor y-coordinate, relative to the to
+ *  top edge of the client area, or `NULL`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref cursor_pos
+ *  @sa glfwSetCursorPos
+ *
+ *  @since Added in version 3.0.  Replaces `glfwGetMousePos`.
+ *
+ *  @ingroup input
+ */
+GLFWAPI void glfwGetCursorPos(GLFWwindow* window, double* xpos, double* ypos);
+
+/*! @brief Sets the position of the cursor, relative to the client area of the
+ *  window.
+ *
+ *  This function sets the position, in screen coordinates, of the cursor
+ *  relative to the upper-left corner of the client area of the specified
+ *  window.  The window must have input focus.  If the window does not have
+ *  input focus when this function is called, it fails silently.
+ *
+ *  __Do not use this function__ to implement things like camera controls.  GLFW
+ *  already provides the `GLFW_CURSOR_DISABLED` cursor mode that hides the
+ *  cursor, transparently re-centers it and provides unconstrained cursor
+ *  motion.  See @ref glfwSetInputMode for more information.
+ *
+ *  If the cursor mode is `GLFW_CURSOR_DISABLED` then the cursor position is
+ *  unconstrained and limited only by the minimum and maximum values of
+ *  a `double`.
+ *
+ *  @param[in] window The desired window.
+ *  @param[in] xpos The desired x-coordinate, relative to the left edge of the
+ *  client area.
+ *  @param[in] ypos The desired y-coordinate, relative to the top edge of the
+ *  client area.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref cursor_pos
+ *  @sa glfwGetCursorPos
+ *
+ *  @since Added in version 3.0.  Replaces `glfwSetMousePos`.
+ *
+ *  @ingroup input
+ */
+GLFWAPI void glfwSetCursorPos(GLFWwindow* window, double xpos, double ypos);
+
+/*! @brief Creates a custom cursor.
+ *
+ *  Creates a new custom cursor image that can be set for a window with @ref
+ *  glfwSetCursor.  The cursor can be destroyed with @ref glfwDestroyCursor.
+ *  Any remaining cursors are destroyed by @ref glfwTerminate.
+ *
+ *  The pixels are 32-bit, little-endian, non-premultiplied RGBA, i.e. eight
+ *  bits per channel.  They are arranged canonically as packed sequential rows,
+ *  starting from the top-left corner.
+ *
+ *  The cursor hotspot is specified in pixels, relative to the upper-left corner
+ *  of the cursor image.  Like all other coordinate systems in GLFW, the X-axis
+ *  points to the right and the Y-axis points down.
+ *
+ *  @param[in] image The desired cursor image.
+ *  @param[in] xhot The desired x-coordinate, in pixels, of the cursor hotspot.
+ *  @param[in] yhot The desired y-coordinate, in pixels, of the cursor hotspot.
+ *  @return The handle of the created cursor, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @pointer_lifetime The specified image data is copied before this function
+ *  returns.
+ *
+ *  @reentrancy This function must not be called from a callback.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref cursor_object
+ *  @sa glfwDestroyCursor
+ *  @sa glfwCreateStandardCursor
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup input
+ */
+GLFWAPI GLFWcursor* glfwCreateCursor(const GLFWimage* image, int xhot, int yhot);
+
+/*! @brief Creates a cursor with a standard shape.
+ *
+ *  Returns a cursor with a [standard shape](@ref shapes), that can be set for
+ *  a window with @ref glfwSetCursor.
+ *
+ *  @param[in] shape One of the [standard shapes](@ref shapes).
+ *  @return A new cursor ready to use or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @reentrancy This function must not be called from a callback.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref cursor_object
+ *  @sa glfwCreateCursor
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup input
+ */
+GLFWAPI GLFWcursor* glfwCreateStandardCursor(int shape);
+
+/*! @brief Destroys a cursor.
+ *
+ *  This function destroys a cursor previously created with @ref
+ *  glfwCreateCursor.  Any remaining cursors will be destroyed by @ref
+ *  glfwTerminate.
+ *
+ *  @param[in] cursor The cursor object to destroy.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @reentrancy This function must not be called from a callback.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref cursor_object
+ *  @sa glfwCreateCursor
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup input
+ */
+GLFWAPI void glfwDestroyCursor(GLFWcursor* cursor);
+
+/*! @brief Sets the cursor for the window.
+ *
+ *  This function sets the cursor image to be used when the cursor is over the
+ *  client area of the specified window.  The set cursor will only be visible
+ *  when the [cursor mode](@ref cursor_mode) of the window is
+ *  `GLFW_CURSOR_NORMAL`.
+ *
+ *  On some platforms, the set cursor may not be visible unless the window also
+ *  has input focus.
+ *
+ *  @param[in] window The window to set the cursor for.
+ *  @param[in] cursor The cursor to set, or `NULL` to switch back to the default
+ *  arrow cursor.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref cursor_object
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup input
+ */
+GLFWAPI void glfwSetCursor(GLFWwindow* window, GLFWcursor* cursor);
+
+/*! @brief Sets the key callback.
+ *
+ *  This function sets the key callback of the specified window, which is called
+ *  when a key is pressed, repeated or released.
+ *
+ *  The key functions deal with physical keys, with layout independent
+ *  [key tokens](@ref keys) named after their values in the standard US keyboard
+ *  layout.  If you want to input text, use the
+ *  [character callback](@ref glfwSetCharCallback) instead.
+ *
+ *  When a window loses input focus, it will generate synthetic key release
+ *  events for all pressed keys.  You can tell these events from user-generated
+ *  events by the fact that the synthetic ones are generated after the focus
+ *  loss event has been processed, i.e. after the
+ *  [window focus callback](@ref glfwSetWindowFocusCallback) has been called.
+ *
+ *  The scancode of a key is specific to that platform or sometimes even to that
+ *  machine.  Scancodes are intended to allow users to bind keys that don't have
+ *  a GLFW key token.  Such keys have `key` set to `GLFW_KEY_UNKNOWN`, their
+ *  state is not saved and so it cannot be queried with @ref glfwGetKey.
+ *
+ *  Sometimes GLFW needs to generate synthetic key events, in which case the
+ *  scancode may be zero.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] cbfun The new key callback, or `NULL` to remove the currently
+ *  set callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref input_key
+ *
+ *  @since Added in version 1.0.
+ *  @glfw3 Added window handle parameter and return value.
+ *
+ *  @ingroup input
+ */
+GLFWAPI GLFWkeyfun glfwSetKeyCallback(GLFWwindow* window, GLFWkeyfun cbfun);
+
+/*! @brief Sets the Unicode character callback.
+ *
+ *  This function sets the character callback of the specified window, which is
+ *  called when a Unicode character is input.
+ *
+ *  The character callback is intended for Unicode text input.  As it deals with
+ *  characters, it is keyboard layout dependent, whereas the
+ *  [key callback](@ref glfwSetKeyCallback) is not.  Characters do not map 1:1
+ *  to physical keys, as a key may produce zero, one or more characters.  If you
+ *  want to know whether a specific physical key was pressed or released, see
+ *  the key callback instead.
+ *
+ *  The character callback behaves as system text input normally does and will
+ *  not be called if modifier keys are held down that would prevent normal text
+ *  input on that platform, for example a Super (Command) key on OS X or Alt key
+ *  on Windows.  There is a
+ *  [character with modifiers callback](@ref glfwSetCharModsCallback) that
+ *  receives these events.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] cbfun The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref input_char
+ *
+ *  @since Added in version 2.4.
+ *  @glfw3 Added window handle parameter and return value.
+ *
+ *  @ingroup input
+ */
+GLFWAPI GLFWcharfun glfwSetCharCallback(GLFWwindow* window, GLFWcharfun cbfun);
+
+/*! @brief Sets the Unicode character with modifiers callback.
+ *
+ *  This function sets the character with modifiers callback of the specified
+ *  window, which is called when a Unicode character is input regardless of what
+ *  modifier keys are used.
+ *
+ *  The character with modifiers callback is intended for implementing custom
+ *  Unicode character input.  For regular Unicode text input, see the
+ *  [character callback](@ref glfwSetCharCallback).  Like the character
+ *  callback, the character with modifiers callback deals with characters and is
+ *  keyboard layout dependent.  Characters do not map 1:1 to physical keys, as
+ *  a key may produce zero, one or more characters.  If you want to know whether
+ *  a specific physical key was pressed or released, see the
+ *  [key callback](@ref glfwSetKeyCallback) instead.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] cbfun The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref input_char
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup input
+ */
+GLFWAPI GLFWcharmodsfun glfwSetCharModsCallback(GLFWwindow* window, GLFWcharmodsfun cbfun);
+
+/*! @brief Sets the mouse button callback.
+ *
+ *  This function sets the mouse button callback of the specified window, which
+ *  is called when a mouse button is pressed or released.
+ *
+ *  When a window loses input focus, it will generate synthetic mouse button
+ *  release events for all pressed mouse buttons.  You can tell these events
+ *  from user-generated events by the fact that the synthetic ones are generated
+ *  after the focus loss event has been processed, i.e. after the
+ *  [window focus callback](@ref glfwSetWindowFocusCallback) has been called.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] cbfun The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref input_mouse_button
+ *
+ *  @since Added in version 1.0.
+ *  @glfw3 Added window handle parameter and return value.
+ *
+ *  @ingroup input
+ */
+GLFWAPI GLFWmousebuttonfun glfwSetMouseButtonCallback(GLFWwindow* window, GLFWmousebuttonfun cbfun);
+
+/*! @brief Sets the cursor position callback.
+ *
+ *  This function sets the cursor position callback of the specified window,
+ *  which is called when the cursor is moved.  The callback is provided with the
+ *  position, in screen coordinates, relative to the upper-left corner of the
+ *  client area of the window.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] cbfun The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref cursor_pos
+ *
+ *  @since Added in version 3.0.  Replaces `glfwSetMousePosCallback`.
+ *
+ *  @ingroup input
+ */
+GLFWAPI GLFWcursorposfun glfwSetCursorPosCallback(GLFWwindow* window, GLFWcursorposfun cbfun);
+
+/*! @brief Sets the cursor enter/exit callback.
+ *
+ *  This function sets the cursor boundary crossing callback of the specified
+ *  window, which is called when the cursor enters or leaves the client area of
+ *  the window.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] cbfun The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref cursor_enter
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup input
+ */
+GLFWAPI GLFWcursorenterfun glfwSetCursorEnterCallback(GLFWwindow* window, GLFWcursorenterfun cbfun);
+
+/*! @brief Sets the scroll callback.
+ *
+ *  This function sets the scroll callback of the specified window, which is
+ *  called when a scrolling device is used, such as a mouse wheel or scrolling
+ *  area of a touchpad.
+ *
+ *  The scroll callback receives all scrolling input, like that from a mouse
+ *  wheel or a touchpad scrolling area.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] cbfun The new scroll callback, or `NULL` to remove the currently
+ *  set callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref scrolling
+ *
+ *  @since Added in version 3.0.  Replaces `glfwSetMouseWheelCallback`.
+ *
+ *  @ingroup input
+ */
+GLFWAPI GLFWscrollfun glfwSetScrollCallback(GLFWwindow* window, GLFWscrollfun cbfun);
+
+/*! @brief Sets the file drop callback.
+ *
+ *  This function sets the file drop callback of the specified window, which is
+ *  called when one or more dragged files are dropped on the window.
+ *
+ *  Because the path array and its strings may have been generated specifically
+ *  for that event, they are not guaranteed to be valid after the callback has
+ *  returned.  If you wish to use them after the callback returns, you need to
+ *  make a deep copy.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] cbfun The new file drop callback, or `NULL` to remove the
+ *  currently set callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref path_drop
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup input
+ */
+GLFWAPI GLFWdropfun glfwSetDropCallback(GLFWwindow* window, GLFWdropfun cbfun);
+
+/*! @brief Returns whether the specified joystick is present.
+ *
+ *  This function returns whether the specified joystick is present.
+ *
+ *  @param[in] joy The [joystick](@ref joysticks) to query.
+ *  @return `GLFW_TRUE` if the joystick is present, or `GLFW_FALSE` otherwise.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref joystick
+ *
+ *  @since Added in version 3.0.  Replaces `glfwGetJoystickParam`.
+ *
+ *  @ingroup input
+ */
+GLFWAPI int glfwJoystickPresent(int joy);
+
+/*! @brief Returns the values of all axes of the specified joystick.
+ *
+ *  This function returns the values of all axes of the specified joystick.
+ *  Each element in the array is a value between -1.0 and 1.0.
+ *
+ *  Querying a joystick slot with no device present is not an error, but will
+ *  cause this function to return `NULL`.  Call @ref glfwJoystickPresent to
+ *  check device presence.
+ *
+ *  @param[in] joy The [joystick](@ref joysticks) to query.
+ *  @param[out] count Where to store the number of axis values in the returned
+ *  array.  This is set to zero if the joystick is not present or an error
+ *  occurred.
+ *  @return An array of axis values, or `NULL` if the joystick is not present or
+ *  an [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @pointer_lifetime The returned array is allocated and freed by GLFW.  You
+ *  should not free it yourself.  It is valid until the specified joystick is
+ *  disconnected, this function is called again for that joystick or the library
+ *  is terminated.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref joystick_axis
+ *
+ *  @since Added in version 3.0.  Replaces `glfwGetJoystickPos`.
+ *
+ *  @ingroup input
+ */
+GLFWAPI const float* glfwGetJoystickAxes(int joy, int* count);
+
+/*! @brief Returns the state of all buttons of the specified joystick.
+ *
+ *  This function returns the state of all buttons of the specified joystick.
+ *  Each element in the array is either `GLFW_PRESS` or `GLFW_RELEASE`.
+ *
+ *  Querying a joystick slot with no device present is not an error, but will
+ *  cause this function to return `NULL`.  Call @ref glfwJoystickPresent to
+ *  check device presence.
+ *
+ *  @param[in] joy The [joystick](@ref joysticks) to query.
+ *  @param[out] count Where to store the number of button states in the returned
+ *  array.  This is set to zero if the joystick is not present or an error
+ *  occurred.
+ *  @return An array of button states, or `NULL` if the joystick is not present
+ *  or an [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @pointer_lifetime The returned array is allocated and freed by GLFW.  You
+ *  should not free it yourself.  It is valid until the specified joystick is
+ *  disconnected, this function is called again for that joystick or the library
+ *  is terminated.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref joystick_button
+ *
+ *  @since Added in version 2.2.
+ *  @glfw3 Changed to return a dynamic array.
+ *
+ *  @ingroup input
+ */
+GLFWAPI const unsigned char* glfwGetJoystickButtons(int joy, int* count);
+
+/*! @brief Returns the name of the specified joystick.
+ *
+ *  This function returns the name, encoded as UTF-8, of the specified joystick.
+ *  The returned string is allocated and freed by GLFW.  You should not free it
+ *  yourself.
+ *
+ *  Querying a joystick slot with no device present is not an error, but will
+ *  cause this function to return `NULL`.  Call @ref glfwJoystickPresent to
+ *  check device presence.
+ *
+ *  @param[in] joy The [joystick](@ref joysticks) to query.
+ *  @return The UTF-8 encoded name of the joystick, or `NULL` if the joystick
+ *  is not present or an [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @pointer_lifetime The returned string is allocated and freed by GLFW.  You
+ *  should not free it yourself.  It is valid until the specified joystick is
+ *  disconnected, this function is called again for that joystick or the library
+ *  is terminated.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref joystick_name
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup input
+ */
+GLFWAPI const char* glfwGetJoystickName(int joy);
+
+/*! @brief Sets the joystick configuration callback.
+ *
+ *  This function sets the joystick configuration callback, or removes the
+ *  currently set callback.  This is called when a joystick is connected to or
+ *  disconnected from the system.
+ *
+ *  @param[in] cbfun The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref joystick_event
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup input
+ */
+GLFWAPI GLFWjoystickfun glfwSetJoystickCallback(GLFWjoystickfun cbfun);
+
+/*! @brief Sets the clipboard to the specified string.
+ *
+ *  This function sets the system clipboard to the specified, UTF-8 encoded
+ *  string.
+ *
+ *  @param[in] window The window that will own the clipboard contents.
+ *  @param[in] string A UTF-8 encoded string.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @pointer_lifetime The specified string is copied before this function
+ *  returns.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref clipboard
+ *  @sa glfwGetClipboardString
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup input
+ */
+GLFWAPI void glfwSetClipboardString(GLFWwindow* window, const char* string);
+
+/*! @brief Returns the contents of the clipboard as a string.
+ *
+ *  This function returns the contents of the system clipboard, if it contains
+ *  or is convertible to a UTF-8 encoded string.  If the clipboard is empty or
+ *  if its contents cannot be converted, `NULL` is returned and a @ref
+ *  GLFW_FORMAT_UNAVAILABLE error is generated.
+ *
+ *  @param[in] window The window that will request the clipboard contents.
+ *  @return The contents of the clipboard as a UTF-8 encoded string, or `NULL`
+ *  if an [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @pointer_lifetime The returned string is allocated and freed by GLFW.  You
+ *  should not free it yourself.  It is valid until the next call to @ref
+ *  glfwGetClipboardString or @ref glfwSetClipboardString, or until the library
+ *  is terminated.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref clipboard
+ *  @sa glfwSetClipboardString
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup input
+ */
+GLFWAPI const char* glfwGetClipboardString(GLFWwindow* window);
+
+/*! @brief Returns the value of the GLFW timer.
+ *
+ *  This function returns the value of the GLFW timer.  Unless the timer has
+ *  been set using @ref glfwSetTime, the timer measures time elapsed since GLFW
+ *  was initialized.
+ *
+ *  The resolution of the timer is system dependent, but is usually on the order
+ *  of a few micro- or nanoseconds.  It uses the highest-resolution monotonic
+ *  time source on each supported platform.
+ *
+ *  @return The current value, in seconds, or zero if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function may be called from any thread.  Reading and
+ *  writing of the internal timer offset is not atomic, so it needs to be
+ *  externally synchronized with calls to @ref glfwSetTime.
+ *
+ *  @sa @ref time
+ *
+ *  @since Added in version 1.0.
+ *
+ *  @ingroup input
+ */
+GLFWAPI double glfwGetTime(void);
+
+/*! @brief Sets the GLFW timer.
+ *
+ *  This function sets the value of the GLFW timer.  It then continues to count
+ *  up from that value.  The value must be a positive finite number less than
+ *  or equal to 18446744073.0, which is approximately 584.5 years.
+ *
+ *  @param[in] time The new value, in seconds.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_INVALID_VALUE.
+ *
+ *  @remark The upper limit of the timer is calculated as
+ *  floor((2<sup>64</sup> - 1) / 10<sup>9</sup>) and is due to implementations
+ *  storing nanoseconds in 64 bits.  The limit may be increased in the future.
+ *
+ *  @thread_safety This function may be called from any thread.  Reading and
+ *  writing of the internal timer offset is not atomic, so it needs to be
+ *  externally synchronized with calls to @ref glfwGetTime.
+ *
+ *  @sa @ref time
+ *
+ *  @since Added in version 2.2.
+ *
+ *  @ingroup input
+ */
+GLFWAPI void glfwSetTime(double time);
+
+/*! @brief Returns the current value of the raw timer.
+ *
+ *  This function returns the current value of the raw timer, measured in
+ *  1&nbsp;/&nbsp;frequency seconds.  To get the frequency, call @ref
+ *  glfwGetTimerFrequency.
+ *
+ *  @return The value of the timer, or zero if an 
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function may be called from any thread.
+ *
+ *  @sa @ref time
+ *  @sa glfwGetTimerFrequency
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup input
+ */
+GLFWAPI uint64_t glfwGetTimerValue(void);
+
+/*! @brief Returns the frequency, in Hz, of the raw timer.
+ *
+ *  This function returns the frequency, in Hz, of the raw timer.
+ *
+ *  @return The frequency of the timer, in Hz, or zero if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function may be called from any thread.
+ *
+ *  @sa @ref time
+ *  @sa glfwGetTimerValue
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup input
+ */
+GLFWAPI uint64_t glfwGetTimerFrequency(void);
+
+/*! @brief Makes the context of the specified window current for the calling
+ *  thread.
+ *
+ *  This function makes the OpenGL or OpenGL ES context of the specified window
+ *  current on the calling thread.  A context can only be made current on
+ *  a single thread at a time and each thread can have only a single current
+ *  context at a time.
+ *
+ *  By default, making a context non-current implicitly forces a pipeline flush.
+ *  On machines that support `GL_KHR_context_flush_control`, you can control
+ *  whether a context performs this flush by setting the
+ *  [GLFW_CONTEXT_RELEASE_BEHAVIOR](@ref window_hints_ctx) window hint.
+ *
+ *  The specified window must have an OpenGL or OpenGL ES context.  Specifying
+ *  a window without a context will generate a @ref GLFW_NO_WINDOW_CONTEXT
+ *  error.
+ *
+ *  @param[in] window The window whose context to make current, or `NULL` to
+ *  detach the current context.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_NO_WINDOW_CONTEXT and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function may be called from any thread.
+ *
+ *  @sa @ref context_current
+ *  @sa glfwGetCurrentContext
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup context
+ */
+GLFWAPI void glfwMakeContextCurrent(GLFWwindow* window);
+
+/*! @brief Returns the window whose context is current on the calling thread.
+ *
+ *  This function returns the window whose OpenGL or OpenGL ES context is
+ *  current on the calling thread.
+ *
+ *  @return The window whose context is current, or `NULL` if no window's
+ *  context is current.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function may be called from any thread.
+ *
+ *  @sa @ref context_current
+ *  @sa glfwMakeContextCurrent
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup context
+ */
+GLFWAPI GLFWwindow* glfwGetCurrentContext(void);
+
+/*! @brief Swaps the front and back buffers of the specified window.
+ *
+ *  This function swaps the front and back buffers of the specified window when
+ *  rendering with OpenGL or OpenGL ES.  If the swap interval is greater than
+ *  zero, the GPU driver waits the specified number of screen updates before
+ *  swapping the buffers.
+ *
+ *  The specified window must have an OpenGL or OpenGL ES context.  Specifying
+ *  a window without a context will generate a @ref GLFW_NO_WINDOW_CONTEXT
+ *  error.
+ *
+ *  This function does not apply to Vulkan.  If you are rendering with Vulkan,
+ *  see `vkQueuePresentKHR` instead.
+ *
+ *  @param[in] window The window whose buffers to swap.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_NO_WINDOW_CONTEXT and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @remark __EGL:__ The context of the specified window must be current on the
+ *  calling thread.
+ *
+ *  @thread_safety This function may be called from any thread.
+ *
+ *  @sa @ref buffer_swap
+ *  @sa glfwSwapInterval
+ *
+ *  @since Added in version 1.0.
+ *  @glfw3 Added window handle parameter.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwSwapBuffers(GLFWwindow* window);
+
+/*! @brief Sets the swap interval for the current context.
+ *
+ *  This function sets the swap interval for the current OpenGL or OpenGL ES
+ *  context, i.e. the number of screen updates to wait from the time @ref
+ *  glfwSwapBuffers was called before swapping the buffers and returning.  This
+ *  is sometimes called _vertical synchronization_, _vertical retrace
+ *  synchronization_ or just _vsync_.
+ *
+ *  Contexts that support either of the `WGL_EXT_swap_control_tear` and
+ *  `GLX_EXT_swap_control_tear` extensions also accept negative swap intervals,
+ *  which allow the driver to swap even if a frame arrives a little bit late.
+ *  You can check for the presence of these extensions using @ref
+ *  glfwExtensionSupported.  For more information about swap tearing, see the
+ *  extension specifications.
+ *
+ *  A context must be current on the calling thread.  Calling this function
+ *  without a current context will cause a @ref GLFW_NO_CURRENT_CONTEXT error.
+ *
+ *  This function does not apply to Vulkan.  If you are rendering with Vulkan,
+ *  see the present mode of your swapchain instead.
+ *
+ *  @param[in] interval The minimum number of screen updates to wait for
+ *  until the buffers are swapped by @ref glfwSwapBuffers.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_NO_CURRENT_CONTEXT and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @remark This function is not called during context creation, leaving the
+ *  swap interval set to whatever is the default on that platform.  This is done
+ *  because some swap interval extensions used by GLFW do not allow the swap
+ *  interval to be reset to zero once it has been set to a non-zero value.
+ *
+ *  @remark Some GPU drivers do not honor the requested swap interval, either
+ *  because of a user setting that overrides the application's request or due to
+ *  bugs in the driver.
+ *
+ *  @thread_safety This function may be called from any thread.
+ *
+ *  @sa @ref buffer_swap
+ *  @sa glfwSwapBuffers
+ *
+ *  @since Added in version 1.0.
+ *
+ *  @ingroup context
+ */
+GLFWAPI void glfwSwapInterval(int interval);
+
+/*! @brief Returns whether the specified extension is available.
+ *
+ *  This function returns whether the specified
+ *  [API extension](@ref context_glext) is supported by the current OpenGL or
+ *  OpenGL ES context.  It searches both for client API extension and context
+ *  creation API extensions.
+ *
+ *  A context must be current on the calling thread.  Calling this function
+ *  without a current context will cause a @ref GLFW_NO_CURRENT_CONTEXT error.
+ *
+ *  As this functions retrieves and searches one or more extension strings each
+ *  call, it is recommended that you cache its results if it is going to be used
+ *  frequently.  The extension strings will not change during the lifetime of
+ *  a context, so there is no danger in doing this.
+ *
+ *  This function does not apply to Vulkan.  If you are using Vulkan, see @ref
+ *  glfwGetRequiredInstanceExtensions, `vkEnumerateInstanceExtensionProperties`
+ *  and `vkEnumerateDeviceExtensionProperties` instead.
+ *
+ *  @param[in] extension The ASCII encoded name of the extension.
+ *  @return `GLFW_TRUE` if the extension is available, or `GLFW_FALSE`
+ *  otherwise.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_NO_CURRENT_CONTEXT, @ref GLFW_INVALID_VALUE and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function may be called from any thread.
+ *
+ *  @sa @ref context_glext
+ *  @sa glfwGetProcAddress
+ *
+ *  @since Added in version 1.0.
+ *
+ *  @ingroup context
+ */
+GLFWAPI int glfwExtensionSupported(const char* extension);
+
+/*! @brief Returns the address of the specified function for the current
+ *  context.
+ *
+ *  This function returns the address of the specified OpenGL or OpenGL ES
+ *  [core or extension function](@ref context_glext), if it is supported
+ *  by the current context.
+ *
+ *  A context must be current on the calling thread.  Calling this function
+ *  without a current context will cause a @ref GLFW_NO_CURRENT_CONTEXT error.
+ *
+ *  This function does not apply to Vulkan.  If you are rendering with Vulkan,
+ *  see @ref glfwGetInstanceProcAddress, `vkGetInstanceProcAddr` and
+ *  `vkGetDeviceProcAddr` instead.
+ *
+ *  @param[in] procname The ASCII encoded name of the function.
+ *  @return The address of the function, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_NO_CURRENT_CONTEXT and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @remark The address of a given function is not guaranteed to be the same
+ *  between contexts.
+ *
+ *  @remark This function may return a non-`NULL` address despite the
+ *  associated version or extension not being available.  Always check the
+ *  context version or extension string first.
+ *
+ *  @pointer_lifetime The returned function pointer is valid until the context
+ *  is destroyed or the library is terminated.
+ *
+ *  @thread_safety This function may be called from any thread.
+ *
+ *  @sa @ref context_glext
+ *  @sa glfwExtensionSupported
+ *
+ *  @since Added in version 1.0.
+ *
+ *  @ingroup context
+ */
+GLFWAPI GLFWglproc glfwGetProcAddress(const char* procname);
+
+/*! @brief Returns whether the Vulkan loader has been found.
+ *
+ *  This function returns whether the Vulkan loader has been found.  This check
+ *  is performed by @ref glfwInit.
+ *
+ *  The availability of a Vulkan loader does not by itself guarantee that window
+ *  surface creation or even device creation is possible.  Call @ref
+ *  glfwGetRequiredInstanceExtensions to check whether the extensions necessary
+ *  for Vulkan surface creation are available and @ref
+ *  glfwGetPhysicalDevicePresentationSupport to check whether a queue family of
+ *  a physical device supports image presentation.
+ *
+ *  @return `GLFW_TRUE` if Vulkan is available, or `GLFW_FALSE` otherwise.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function may be called from any thread.
+ *
+ *  @sa @ref vulkan_support
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup vulkan
+ */
+GLFWAPI int glfwVulkanSupported(void);
+
+/*! @brief Returns the Vulkan instance extensions required by GLFW.
+ *
+ *  This function returns an array of names of Vulkan instance extensions required
+ *  by GLFW for creating Vulkan surfaces for GLFW windows.  If successful, the
+ *  list will always contains `VK_KHR_surface`, so if you don't require any
+ *  additional extensions you can pass this list directly to the
+ *  `VkInstanceCreateInfo` struct.
+ *
+ *  If Vulkan is not available on the machine, this function returns `NULL` and
+ *  generates a @ref GLFW_API_UNAVAILABLE error.  Call @ref glfwVulkanSupported
+ *  to check whether Vulkan is available.
+ *
+ *  If Vulkan is available but no set of extensions allowing window surface
+ *  creation was found, this function returns `NULL`.  You may still use Vulkan
+ *  for off-screen rendering and compute work.
+ *
+ *  @param[out] count Where to store the number of extensions in the returned
+ *  array.  This is set to zero if an error occurred.
+ *  @return An array of ASCII encoded extension names, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_API_UNAVAILABLE.
+ *
+ *  @remarks Additional extensions may be required by future versions of GLFW.
+ *  You should check if any extensions you wish to enable are already in the
+ *  returned array, as it is an error to specify an extension more than once in
+ *  the `VkInstanceCreateInfo` struct.
+ *
+ *  @pointer_lifetime The returned array is allocated and freed by GLFW.  You
+ *  should not free it yourself.  It is guaranteed to be valid only until the
+ *  library is terminated.
+ *
+ *  @thread_safety This function may be called from any thread.
+ *
+ *  @sa @ref vulkan_ext
+ *  @sa glfwCreateWindowSurface
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup vulkan
+ */
+GLFWAPI const char** glfwGetRequiredInstanceExtensions(uint32_t* count);
+
+#if defined(VK_VERSION_1_0)
+
+/*! @brief Returns the address of the specified Vulkan instance function.
+ *
+ *  This function returns the address of the specified Vulkan core or extension
+ *  function for the specified instance.  If instance is set to `NULL` it can
+ *  return any function exported from the Vulkan loader, including at least the
+ *  following functions:
+ *
+ *  - `vkEnumerateInstanceExtensionProperties`
+ *  - `vkEnumerateInstanceLayerProperties`
+ *  - `vkCreateInstance`
+ *  - `vkGetInstanceProcAddr`
+ *
+ *  If Vulkan is not available on the machine, this function returns `NULL` and
+ *  generates a @ref GLFW_API_UNAVAILABLE error.  Call @ref glfwVulkanSupported
+ *  to check whether Vulkan is available.
+ *
+ *  This function is equivalent to calling `vkGetInstanceProcAddr` with
+ *  a platform-specific query of the Vulkan loader as a fallback.
+ *
+ *  @param[in] instance The Vulkan instance to query, or `NULL` to retrieve
+ *  functions related to instance creation.
+ *  @param[in] procname The ASCII encoded name of the function.
+ *  @return The address of the function, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_API_UNAVAILABLE.
+ *
+ *  @pointer_lifetime The returned function pointer is valid until the library
+ *  is terminated.
+ *
+ *  @thread_safety This function may be called from any thread.
+ *
+ *  @sa @ref vulkan_proc
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup vulkan
+ */
+GLFWAPI GLFWvkproc glfwGetInstanceProcAddress(VkInstance instance, const char* procname);
+
+/*! @brief Returns whether the specified queue family can present images.
+ *
+ *  This function returns whether the specified queue family of the specified
+ *  physical device supports presentation to the platform GLFW was built for.
+ *
+ *  If Vulkan or the required window surface creation instance extensions are
+ *  not available on the machine, or if the specified instance was not created
+ *  with the required extensions, this function returns `GLFW_FALSE` and
+ *  generates a @ref GLFW_API_UNAVAILABLE error.  Call @ref glfwVulkanSupported
+ *  to check whether Vulkan is available and @ref
+ *  glfwGetRequiredInstanceExtensions to check what instance extensions are
+ *  required.
+ *
+ *  @param[in] instance The instance that the physical device belongs to.
+ *  @param[in] device The physical device that the queue family belongs to.
+ *  @param[in] queuefamily The index of the queue family to query.
+ *  @return `GLFW_TRUE` if the queue family supports presentation, or
+ *  `GLFW_FALSE` otherwise.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_API_UNAVAILABLE and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function may be called from any thread.  For
+ *  synchronization details of Vulkan objects, see the Vulkan specification.
+ *
+ *  @sa @ref vulkan_present
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup vulkan
+ */
+GLFWAPI int glfwGetPhysicalDevicePresentationSupport(VkInstance instance, VkPhysicalDevice device, uint32_t queuefamily);
+
+/*! @brief Creates a Vulkan surface for the specified window.
+ *
+ *  This function creates a Vulkan surface for the specified window.
+ *
+ *  If the Vulkan loader was not found at initialization, this function returns
+ *  `VK_ERROR_INITIALIZATION_FAILED` and generates a @ref GLFW_API_UNAVAILABLE
+ *  error.  Call @ref glfwVulkanSupported to check whether the Vulkan loader was
+ *  found.
+ *
+ *  If the required window surface creation instance extensions are not
+ *  available or if the specified instance was not created with these extensions
+ *  enabled, this function returns `VK_ERROR_EXTENSION_NOT_PRESENT` and
+ *  generates a @ref GLFW_API_UNAVAILABLE error.  Call @ref
+ *  glfwGetRequiredInstanceExtensions to check what instance extensions are
+ *  required.
+ *
+ *  The window surface must be destroyed before the specified Vulkan instance.
+ *  It is the responsibility of the caller to destroy the window surface.  GLFW
+ *  does not destroy it for you.  Call `vkDestroySurfaceKHR` to destroy the
+ *  surface.
+ *
+ *  @param[in] instance The Vulkan instance to create the surface in.
+ *  @param[in] window The window to create the surface for.
+ *  @param[in] allocator The allocator to use, or `NULL` to use the default
+ *  allocator.
+ *  @param[out] surface Where to store the handle of the surface.  This is set
+ *  to `VK_NULL_HANDLE` if an error occurred.
+ *  @return `VK_SUCCESS` if successful, or a Vulkan error code if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_API_UNAVAILABLE and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @remarks If an error occurs before the creation call is made, GLFW returns
+ *  the Vulkan error code most appropriate for the error.  Appropriate use of
+ *  @ref glfwVulkanSupported and @ref glfwGetRequiredInstanceExtensions should
+ *  eliminate almost all occurrences of these errors.
+ *
+ *  @thread_safety This function may be called from any thread.  For
+ *  synchronization details of Vulkan objects, see the Vulkan specification.
+ *
+ *  @sa @ref vulkan_surface
+ *  @sa glfwGetRequiredInstanceExtensions
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup vulkan
+ */
+GLFWAPI VkResult glfwCreateWindowSurface(VkInstance instance, GLFWwindow* window, const VkAllocationCallbacks* allocator, VkSurfaceKHR* surface);
+
+#endif /*VK_VERSION_1_0*/
+
+
+/*************************************************************************
+ * Global definition cleanup
+ *************************************************************************/
+
+/* ------------------- BEGIN SYSTEM/COMPILER SPECIFIC -------------------- */
+
+#ifdef GLFW_WINGDIAPI_DEFINED
+ #undef WINGDIAPI
+ #undef GLFW_WINGDIAPI_DEFINED
+#endif
+
+#ifdef GLFW_CALLBACK_DEFINED
+ #undef CALLBACK
+ #undef GLFW_CALLBACK_DEFINED
+#endif
+
+/* -------------------- END SYSTEM/COMPILER SPECIFIC --------------------- */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _glfw3_h_ */
+
diff --git a/engine/inc/GLFW/glfw3native.h b/engine/inc/GLFW/glfw3native.h
new file mode 100644
index 00000000..30e1a570
--- /dev/null
+++ b/engine/inc/GLFW/glfw3native.h
@@ -0,0 +1,456 @@
+/*************************************************************************
+ * GLFW 3.2 - www.glfw.org
+ * A library for OpenGL, window and input
+ *------------------------------------------------------------------------
+ * Copyright (c) 2002-2006 Marcus Geelnard
+ * Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would
+ *    be appreciated but is not required.
+ *
+ * 2. Altered source versions must be plainly marked as such, and must not
+ *    be misrepresented as being the original software.
+ *
+ * 3. This notice may not be removed or altered from any source
+ *    distribution.
+ *
+ *************************************************************************/
+
+#ifndef _glfw3_native_h_
+#define _glfw3_native_h_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*************************************************************************
+ * Doxygen documentation
+ *************************************************************************/
+
+/*! @file glfw3native.h
+ *  @brief The header of the native access functions.
+ *
+ *  This is the header file of the native access functions.  See @ref native for
+ *  more information.
+ */
+/*! @defgroup native Native access
+ *
+ *  **By using the native access functions you assert that you know what you're
+ *  doing and how to fix problems caused by using them.  If you don't, you
+ *  shouldn't be using them.**
+ *
+ *  Before the inclusion of @ref glfw3native.h, you may define exactly one
+ *  window system API macro and zero or more context creation API macros.
+ *
+ *  The chosen backends must match those the library was compiled for.  Failure
+ *  to do this will cause a link-time error.
+ *
+ *  The available window API macros are:
+ *  * `GLFW_EXPOSE_NATIVE_WIN32`
+ *  * `GLFW_EXPOSE_NATIVE_COCOA`
+ *  * `GLFW_EXPOSE_NATIVE_X11`
+ *  * `GLFW_EXPOSE_NATIVE_WAYLAND`
+ *  * `GLFW_EXPOSE_NATIVE_MIR`
+ *
+ *  The available context API macros are:
+ *  * `GLFW_EXPOSE_NATIVE_WGL`
+ *  * `GLFW_EXPOSE_NATIVE_NSGL`
+ *  * `GLFW_EXPOSE_NATIVE_GLX`
+ *  * `GLFW_EXPOSE_NATIVE_EGL`
+ *
+ *  These macros select which of the native access functions that are declared
+ *  and which platform-specific headers to include.  It is then up your (by
+ *  definition platform-specific) code to handle which of these should be
+ *  defined.
+ */
+
+
+/*************************************************************************
+ * System headers and types
+ *************************************************************************/
+
+#if defined(GLFW_EXPOSE_NATIVE_WIN32)
+ // This is a workaround for the fact that glfw3.h needs to export APIENTRY (for
+ // example to allow applications to correctly declare a GL_ARB_debug_output
+ // callback) but windows.h assumes no one will define APIENTRY before it does
+ #undef APIENTRY
+ #include <windows.h>
+#elif defined(GLFW_EXPOSE_NATIVE_COCOA)
+ #include <ApplicationServices/ApplicationServices.h>
+ #if defined(__OBJC__)
+  #import <Cocoa/Cocoa.h>
+ #else
+  typedef void* id;
+ #endif
+#elif defined(GLFW_EXPOSE_NATIVE_X11)
+ #include <X11/Xlib.h>
+ #include <X11/extensions/Xrandr.h>
+#elif defined(GLFW_EXPOSE_NATIVE_WAYLAND)
+ #include <wayland-client.h>
+#elif defined(GLFW_EXPOSE_NATIVE_MIR)
+ #include <mir_toolkit/mir_client_library.h>
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_WGL)
+ /* WGL is declared by windows.h */
+#endif
+#if defined(GLFW_EXPOSE_NATIVE_NSGL)
+ /* NSGL is declared by Cocoa.h */
+#endif
+#if defined(GLFW_EXPOSE_NATIVE_GLX)
+ #include <GL/glx.h>
+#endif
+#if defined(GLFW_EXPOSE_NATIVE_EGL)
+ #include <EGL/egl.h>
+#endif
+
+
+/*************************************************************************
+ * Functions
+ *************************************************************************/
+
+#if defined(GLFW_EXPOSE_NATIVE_WIN32)
+/*! @brief Returns the adapter device name of the specified monitor.
+ *
+ *  @return The UTF-8 encoded adapter device name (for example `\\.\DISPLAY1`)
+ *  of the specified monitor, or `NULL` if an [error](@ref error_handling)
+ *  occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup native
+ */
+GLFWAPI const char* glfwGetWin32Adapter(GLFWmonitor* monitor);
+
+/*! @brief Returns the display device name of the specified monitor.
+ *
+ *  @return The UTF-8 encoded display device name (for example
+ *  `\\.\DISPLAY1\Monitor0`) of the specified monitor, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup native
+ */
+GLFWAPI const char* glfwGetWin32Monitor(GLFWmonitor* monitor);
+
+/*! @brief Returns the `HWND` of the specified window.
+ *
+ *  @return The `HWND` of the specified window, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup native
+ */
+GLFWAPI HWND glfwGetWin32Window(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_WGL)
+/*! @brief Returns the `HGLRC` of the specified window.
+ *
+ *  @return The `HGLRC` of the specified window, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup native
+ */
+GLFWAPI HGLRC glfwGetWGLContext(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_COCOA)
+/*! @brief Returns the `CGDirectDisplayID` of the specified monitor.
+ *
+ *  @return The `CGDirectDisplayID` of the specified monitor, or
+ *  `kCGNullDirectDisplay` if an [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup native
+ */
+GLFWAPI CGDirectDisplayID glfwGetCocoaMonitor(GLFWmonitor* monitor);
+
+/*! @brief Returns the `NSWindow` of the specified window.
+ *
+ *  @return The `NSWindow` of the specified window, or `nil` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup native
+ */
+GLFWAPI id glfwGetCocoaWindow(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_NSGL)
+/*! @brief Returns the `NSOpenGLContext` of the specified window.
+ *
+ *  @return The `NSOpenGLContext` of the specified window, or `nil` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup native
+ */
+GLFWAPI id glfwGetNSGLContext(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_X11)
+/*! @brief Returns the `Display` used by GLFW.
+ *
+ *  @return The `Display` used by GLFW, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup native
+ */
+GLFWAPI Display* glfwGetX11Display(void);
+
+/*! @brief Returns the `RRCrtc` of the specified monitor.
+ *
+ *  @return The `RRCrtc` of the specified monitor, or `None` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup native
+ */
+GLFWAPI RRCrtc glfwGetX11Adapter(GLFWmonitor* monitor);
+
+/*! @brief Returns the `RROutput` of the specified monitor.
+ *
+ *  @return The `RROutput` of the specified monitor, or `None` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup native
+ */
+GLFWAPI RROutput glfwGetX11Monitor(GLFWmonitor* monitor);
+
+/*! @brief Returns the `Window` of the specified window.
+ *
+ *  @return The `Window` of the specified window, or `None` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup native
+ */
+GLFWAPI Window glfwGetX11Window(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_GLX)
+/*! @brief Returns the `GLXContext` of the specified window.
+ *
+ *  @return The `GLXContext` of the specified window, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup native
+ */
+GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow* window);
+
+/*! @brief Returns the `GLXWindow` of the specified window.
+ *
+ *  @return The `GLXWindow` of the specified window, or `None` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup native
+ */
+GLFWAPI GLXWindow glfwGetGLXWindow(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_WAYLAND)
+/*! @brief Returns the `struct wl_display*` used by GLFW.
+ *
+ *  @return The `struct wl_display*` used by GLFW, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup native
+ */
+GLFWAPI struct wl_display* glfwGetWaylandDisplay(void);
+
+/*! @brief Returns the `struct wl_output*` of the specified monitor.
+ *
+ *  @return The `struct wl_output*` of the specified monitor, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup native
+ */
+GLFWAPI struct wl_output* glfwGetWaylandMonitor(GLFWmonitor* monitor);
+
+/*! @brief Returns the main `struct wl_surface*` of the specified window.
+ *
+ *  @return The main `struct wl_surface*` of the specified window, or `NULL` if
+ *  an [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup native
+ */
+GLFWAPI struct wl_surface* glfwGetWaylandWindow(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_MIR)
+/*! @brief Returns the `MirConnection*` used by GLFW.
+ *
+ *  @return The `MirConnection*` used by GLFW, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup native
+ */
+GLFWAPI MirConnection* glfwGetMirDisplay(void);
+
+/*! @brief Returns the Mir output ID of the specified monitor.
+ *
+ *  @return The Mir output ID of the specified monitor, or zero if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup native
+ */
+GLFWAPI int glfwGetMirMonitor(GLFWmonitor* monitor);
+
+/*! @brief Returns the `MirSurface*` of the specified window.
+ *
+ *  @return The `MirSurface*` of the specified window, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup native
+ */
+GLFWAPI MirSurface* glfwGetMirWindow(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_EGL)
+/*! @brief Returns the `EGLDisplay` used by GLFW.
+ *
+ *  @return The `EGLDisplay` used by GLFW, or `EGL_NO_DISPLAY` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup native
+ */
+GLFWAPI EGLDisplay glfwGetEGLDisplay(void);
+
+/*! @brief Returns the `EGLContext` of the specified window.
+ *
+ *  @return The `EGLContext` of the specified window, or `EGL_NO_CONTEXT` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup native
+ */
+GLFWAPI EGLContext glfwGetEGLContext(GLFWwindow* window);
+
+/*! @brief Returns the `EGLSurface` of the specified window.
+ *
+ *  @return The `EGLSurface` of the specified window, or `EGL_NO_SURFACE` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup native
+ */
+GLFWAPI EGLSurface glfwGetEGLSurface(GLFWwindow* window);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _glfw3_native_h_ */
+
diff --git a/engine/inc/Host.h b/engine/inc/Host.h
new file mode 100644
index 00000000..47de25c4
--- /dev/null
+++ b/engine/inc/Host.h
@@ -0,0 +1,254 @@
+/*---------------------------------------------------------------------------*/
+/*                                                                           */
+/* Host.h - Basic header file to provide cross-platform solutions via        */
+/*                   macros, conditional compilation, etc.                   */
+/*                                                                           */
+/* Author : Mark Carrier (mark@carrierlabs.com)                              */
+/*                                                                           */
+/*---------------------------------------------------------------------------*/
+/* Copyright (c) 2007 CarrierLabs, LLC.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * 4. The name "CarrierLabs" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    mark@carrierlabs.com.
+ *
+ * THIS SOFTWARE IS PROVIDED BY MARK CARRIER ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL MARK CARRIER OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ *----------------------------------------------------------------------------*/
+#ifndef __HOST_H__
+#define __HOST_H__
+
+#include <limits.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*---------------------------------------------------------------------------*/
+/*                                                                           */
+/* Type Definition Macros                                                    */
+/*                                                                           */
+/*---------------------------------------------------------------------------*/
+#ifndef __WORDSIZE
+/* Assume 32 */
+#define __WORDSIZE 32
+#endif
+
+#if defined(_LINUX) || defined(_DARWIN) || defined(_BSD)
+	typedef unsigned char uint8;
+	typedef char int8;
+	typedef unsigned short uint16;
+	typedef short int16;
+	typedef unsigned int uint32;
+	typedef int int32;
+	typedef int SOCKET;
+#endif
+
+#ifdef WIN32
+	struct iovec
+	{
+		void *iov_base;
+		size_t iov_len;
+	};
+
+	typedef unsigned char uint8;
+	typedef char int8;
+	typedef unsigned short uint16;
+	typedef short int16;
+	typedef unsigned int uint32;
+	typedef int int32;
+#endif
+
+#ifdef WIN32
+	typedef int socklen_t;
+#endif
+
+#if defined(WIN32)
+	typedef unsigned long long int uint64;
+	typedef long long int int64;
+#elif (__WORDSIZE == 32)
+__extension__ typedef long long int int64;
+__extension__ typedef unsigned long long int uint64;
+#elif (__WORDSIZE == 64)
+typedef unsigned long int uint64;
+typedef long int int64;
+#endif
+
+#ifdef WIN32
+
+#ifndef UINT8_MAX
+#define UINT8_MAX (UCHAR_MAX)
+#endif
+#ifndef UINT16_MAX
+#define UINT16_MAX (USHRT_MAX)
+#endif
+#ifndef UINT32_MAX
+#define UINT32_MAX (ULONG_MAX)
+#endif
+
+#if __WORDSIZE == 64
+#define SIZE_MAX (18446744073709551615UL)
+#else
+#ifndef SIZE_MAX
+#define SIZE_MAX (4294967295U)
+#endif
+#endif
+#endif
+
+#if defined(WIN32)
+#define ssize_t size_t
+#endif
+
+#ifndef TRUE
+#define TRUE 1
+#endif
+
+#ifndef FALSE
+#define FALSE 0
+#endif
+
+#ifndef htonll
+#ifdef _BIG_ENDIAN
+#define htonll(x) (x)
+#define ntohll(x) (x)
+#else
+#define htonll(x) ((((uint64)htonl(x)) << 32) + htonl(x >> 32))
+#define ntohll(x) ((((uint64)ntohl(x)) << 32) + ntohl(x >> 32))
+#endif
+#endif
+
+/*---------------------------------------------------------------------------*/
+/*                                                                           */
+/* Socket Macros                                                             */
+/*                                                                           */
+/*---------------------------------------------------------------------------*/
+#ifdef WIN32
+#define SHUT_RD 0
+#define SHUT_WR 1
+#define SHUT_RDWR 2
+#define ACCEPT(a, b, c) accept(a, b, c)
+#define CONNECT(a, b, c) connect(a, b, c)
+#define CLOSE(a) closesocket(a)
+#define READ(a, b, c) read(a, b, c)
+#define RECV(a, b, c, d) recv(a, (char *)b, c, d)
+#define RECVFROM(a, b, c, d, e, f) recvfrom(a, (char *)b, c, d, (sockaddr *)e, (int *)f)
+#define RECV_FLAGS MSG_WAITALL
+#define SELECT(a, b, c, d, e) select((int32)a, b, c, d, e)
+#define SEND(a, b, c, d) send(a, (const char *)b, (int)c, d)
+#define SENDTO(a, b, c, d, e, f) sendto(a, (const char *)b, (int)c, d, e, f)
+#define SEND_FLAGS 0
+#define SENDFILE(a, b, c, d) sendfile(a, b, c, d)
+#define SET_SOCKET_ERROR(x, y) errno = y
+#define SOCKET_ERROR_INTERUPT EINTR
+#define SOCKET_ERROR_TIMEDOUT EAGAIN
+#define WRITE(a, b, c) write(a, b, c)
+#define WRITEV(a, b, c) Writev(b, c)
+#define GETSOCKOPT(a, b, c, d, e) getsockopt(a, b, c, (char *)d, (int *)e)
+#define SETSOCKOPT(a, b, c, d, e) setsockopt(a, b, c, (char *)d, (int)e)
+#define GETHOSTBYNAME(a) gethostbyname(a)
+#endif
+
+#if defined(_LINUX) || defined(_DARWIN) || defined(_BSD)
+#define ACCEPT(a, b, c) accept(a, b, c)
+#define CONNECT(a, b, c) connect(a, b, c)
+#define CLOSE(a) close(a)
+#define READ(a, b, c) read(a, b, c)
+#define RECV(a, b, c, d) recv(a, (void *)b, c, d)
+#define RECVFROM(a, b, c, d, e, f) recvfrom(a, (char *)b, c, d, (sockaddr *)e, f)
+#define RECV_FLAGS MSG_WAITALL
+#define SELECT(a, b, c, d, e) select(a, b, c, d, e)
+#define SEND(a, b, c, d) send(a, (const int8 *)b, c, d)
+#define SENDTO(a, b, c, d, e, f) sendto(a, (const int8 *)b, c, d, e, f)
+#define SEND_FLAGS 0
+#define SENDFILE(a, b, c, d) sendfile(a, b, c, d)
+#define SET_SOCKET_ERROR(x, y) errno = y
+#define SOCKET_ERROR_INTERUPT EINTR
+#define SOCKET_ERROR_TIMEDOUT EAGAIN
+#define WRITE(a, b, c) write(a, b, c)
+#define WRITEV(a, b, c) writev(a, b, c)
+#define GETSOCKOPT(a, b, c, d, e) getsockopt((int)a, (int)b, (int)c, (void *)d, (socklen_t *)e)
+#define SETSOCKOPT(a, b, c, d, e) setsockopt((int)a, (int)b, (int)c, (const void *)d, (int)e)
+#define GETHOSTBYNAME(a) gethostbyname(a)
+#endif
+
+/*---------------------------------------------------------------------------*/
+/*                                                                           */
+/* File Macros                                                               */
+/*                                                                           */
+/*---------------------------------------------------------------------------*/
+#define STRUCT_STAT struct stat
+#define LSTAT(x, y) lstat(x, y)
+#define FILE_HANDLE FILE *
+#define CLEARERR(x) clearerr(x)
+#define FCLOSE(x) fclose(x)
+#define FEOF(x) feof(x)
+#define FERROR(x) ferror(x)
+#define FFLUSH(x) fflush(x)
+#define FILENO(s) fileno(s)
+#define FOPEN(x, y) fopen(x, y)
+	//#define FREAD(a,b,c,d)      fread(a, b, c, d)
+#define FSTAT(s, st) fstat(FILENO(s), st)
+	//#define FWRITE(a,b,c,d)     fwrite(a, b, c, d)
+#define STAT_BLK_SIZE(x) ((x).st_blksize)
+
+/*---------------------------------------------------------------------------*/
+/*                                                                           */
+/* Misc Macros                                                               */
+/*                                                                           */
+/*---------------------------------------------------------------------------*/
+#if defined(WIN32)
+#define GET_CLOCK_COUNT(x) QueryPerformanceCounter((LARGE_INTEGER *)x)
+#else
+#define GET_CLOCK_COUNT(x) gettimeofday(x, NULL)
+#endif
+
+#if defined(WIN32)
+#define STRTOULL(x) _atoi64(x)
+#else
+#define STRTOULL(x) strtoull(x, NULL, 10)
+#endif
+
+#if defined(WIN32)
+#define SNPRINTF _snprintf
+#define PRINTF printf
+#define VPRINTF vprintf
+#define FPRINTF fprintf
+#else
+#define SNPRINTF snprintf
+#define PRINTF printf
+#define VPRINTF vprintf
+#define FPRINTF fprintf
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __HOST_H__ */
diff --git a/engine/inc/JavaScriptCore/JSBase.h b/engine/inc/JavaScriptCore/JSBase.h
new file mode 100644
index 00000000..7a354dec
--- /dev/null
+++ b/engine/inc/JavaScriptCore/JSBase.h
@@ -0,0 +1,155 @@
+/*
+ * Copyright (C) 2006 Apple Inc.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef JSBase_h
+#define JSBase_h
+
+#ifndef __cplusplus
+#include <stdbool.h>
+#endif
+
+#ifdef __OBJC__
+#import <Foundation/Foundation.h>
+#endif
+
+/* JavaScript engine interface */
+
+/*! @typedef JSContextGroupRef A group that associates JavaScript contexts with one another. Contexts in the same group may share and exchange JavaScript objects. */
+typedef const struct OpaqueJSContextGroup* JSContextGroupRef;
+
+/*! @typedef JSContextRef A JavaScript execution context. Holds the global object and other execution state. */
+typedef const struct OpaqueJSContext* JSContextRef;
+
+/*! @typedef JSGlobalContextRef A global JavaScript execution context. A JSGlobalContext is a JSContext. */
+typedef struct OpaqueJSContext* JSGlobalContextRef;
+
+/*! @typedef JSStringRef A UTF16 character buffer. The fundamental string representation in JavaScript. */
+typedef struct OpaqueJSString* JSStringRef;
+
+/*! @typedef JSClassRef A JavaScript class. Used with JSObjectMake to construct objects with custom behavior. */
+typedef struct OpaqueJSClass* JSClassRef;
+
+/*! @typedef JSPropertyNameArrayRef An array of JavaScript property names. */
+typedef struct OpaqueJSPropertyNameArray* JSPropertyNameArrayRef;
+
+/*! @typedef JSPropertyNameAccumulatorRef An ordered set used to collect the names of a JavaScript object's properties. */
+typedef struct OpaqueJSPropertyNameAccumulator* JSPropertyNameAccumulatorRef;
+
+/*! @typedef JSTypedArrayBytesDeallocator A function used to deallocate bytes passed to a Typed Array constructor. The function should take two arguments. The first is a pointer to the bytes that were originally passed to the Typed Array constructor. The second is a pointer to additional information desired at the time the bytes are to be freed. */
+typedef void (*JSTypedArrayBytesDeallocator)(void* bytes, void* deallocatorContext);
+
+/* JavaScript data types */
+
+/*! @typedef JSValueRef A JavaScript value. The base type for all JavaScript values, and polymorphic functions on them. */
+typedef const struct OpaqueJSValue* JSValueRef;
+
+/*! @typedef JSObjectRef A JavaScript object. A JSObject is a JSValue. */
+typedef struct OpaqueJSValue* JSObjectRef;
+
+/* Clang's __has_declspec_attribute emulation */
+/* https://clang.llvm.org/docs/LanguageExtensions.html#has-declspec-attribute */
+
+#ifndef __has_declspec_attribute
+#define __has_declspec_attribute(x) 0
+#endif
+
+/* JavaScript symbol exports */
+/* These rules should stay the same as in WebKit/Shared/API/c/WKDeclarationSpecifiers.h */
+
+#undef JS_EXPORT
+#if defined(JS_NO_EXPORT)
+#define JS_EXPORT
+#elif defined(WIN32) || defined(_WIN32) || defined(__CC_ARM) || defined(__ARMCC__) || (__has_declspec_attribute(dllimport) && __has_declspec_attribute(dllexport))
+#if defined(BUILDING_JavaScriptCore) || defined(STATICALLY_LINKED_WITH_JavaScriptCore)
+#define JS_EXPORT __declspec(dllexport)
+#else
+#define JS_EXPORT __declspec(dllimport)
+#endif
+#elif defined(__GNUC__)
+#define JS_EXPORT __attribute__((visibility("default")))
+#else /* !defined(JS_NO_EXPORT) */
+#define JS_EXPORT
+#endif /* defined(JS_NO_EXPORT) */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Script Evaluation */
+
+/*!
+@function JSEvaluateScript
+@abstract Evaluates a string of JavaScript.
+@param ctx The execution context to use.
+@param script A JSString containing the script to evaluate.
+@param thisObject The object to use as "this," or NULL to use the global object as "this."
+@param sourceURL A JSString containing a URL for the script's source file. This is used by debuggers and when reporting exceptions. Pass NULL if you do not care to include source file information.
+@param startingLineNumber An integer value specifying the script's starting line number in the file located at sourceURL. This is only used when reporting exceptions. The value is one-based, so the first line is line 1 and invalid values are clamped to 1.
+@param exception A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+@result The JSValue that results from evaluating script, or NULL if an exception is thrown.
+*/
+JS_EXPORT JSValueRef JSEvaluateScript(JSContextRef ctx, JSStringRef script, JSObjectRef thisObject, JSStringRef sourceURL, int startingLineNumber, JSValueRef* exception);
+
+/*!
+@function JSCheckScriptSyntax
+@abstract Checks for syntax errors in a string of JavaScript.
+@param ctx The execution context to use.
+@param script A JSString containing the script to check for syntax errors.
+@param sourceURL A JSString containing a URL for the script's source file. This is only used when reporting exceptions. Pass NULL if you do not care to include source file information in exceptions.
+@param startingLineNumber An integer value specifying the script's starting line number in the file located at sourceURL. This is only used when reporting exceptions. The value is one-based, so the first line is line 1 and invalid values are clamped to 1.
+@param exception A pointer to a JSValueRef in which to store a syntax error exception, if any. Pass NULL if you do not care to store a syntax error exception.
+@result true if the script is syntactically correct, otherwise false.
+*/
+JS_EXPORT bool JSCheckScriptSyntax(JSContextRef ctx, JSStringRef script, JSStringRef sourceURL, int startingLineNumber, JSValueRef* exception);
+
+/*!
+@function JSGarbageCollect
+@abstract Performs a JavaScript garbage collection.
+@param ctx The execution context to use.
+@discussion JavaScript values that are on the machine stack, in a register,
+ protected by JSValueProtect, set as the global object of an execution context,
+ or reachable from any such value will not be collected.
+
+ During JavaScript execution, you are not required to call this function; the
+ JavaScript engine will garbage collect as needed. JavaScript values created
+ within a context group are automatically destroyed when the last reference
+ to the context group is released.
+*/
+JS_EXPORT void JSGarbageCollect(JSContextRef ctx);
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Enable the Objective-C API for platforms with a modern runtime. NOTE: This is duplicated in VM.h. */
+#if !defined(JSC_OBJC_API_ENABLED)
+#if (defined(__clang__) && defined(__APPLE__) && ((defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && !defined(__i386__)) || (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE)))
+#define JSC_OBJC_API_ENABLED 1
+#else
+#define JSC_OBJC_API_ENABLED 0
+#endif
+#endif
+
+#endif /* JSBase_h */
diff --git a/engine/inc/JavaScriptCore/JSContextRef.h b/engine/inc/JavaScriptCore/JSContextRef.h
new file mode 100644
index 00000000..36a41314
--- /dev/null
+++ b/engine/inc/JavaScriptCore/JSContextRef.h
@@ -0,0 +1,163 @@
+/*
+ * Copyright (C) 2006 Apple Inc.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef JSContextRef_h
+#define JSContextRef_h
+
+#include <JavaScriptCore/JSObjectRef.h>
+#include <JavaScriptCore/JSValueRef.h>
+#include <JavaScriptCore/WebKitAvailability.h>
+
+#ifndef __cplusplus
+#include <stdbool.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*!
+@function
+@abstract Creates a JavaScript context group.
+@discussion A JSContextGroup associates JavaScript contexts with one another.
+ Contexts in the same group may share and exchange JavaScript objects. Sharing and/or exchanging
+ JavaScript objects between contexts in different groups will produce undefined behavior.
+ When objects from the same context group are used in multiple threads, explicit
+ synchronization is required.
+
+ A JSContextGroup may need to run deferred tasks on a run loop, such as garbage collection
+ or resolving WebAssembly compilations. By default, calling JSContextGroupCreate will use
+ the run loop of the thread it was called on. Currently, there is no API to change a
+ JSContextGroup's run loop once it has been created.
+@result The created JSContextGroup.
+*/
+JS_EXPORT JSContextGroupRef JSContextGroupCreate(void) JSC_API_AVAILABLE(macos(10.6), ios(7.0));
+
+/*!
+@function
+@abstract Retains a JavaScript context group.
+@param group The JSContextGroup to retain.
+@result A JSContextGroup that is the same as group.
+*/
+JS_EXPORT JSContextGroupRef JSContextGroupRetain(JSContextGroupRef group) JSC_API_AVAILABLE(macos(10.6), ios(7.0));
+
+/*!
+@function
+@abstract Releases a JavaScript context group.
+@param group The JSContextGroup to release.
+*/
+JS_EXPORT void JSContextGroupRelease(JSContextGroupRef group) JSC_API_AVAILABLE(macos(10.6), ios(7.0));
+
+/*!
+@function
+@abstract Creates a global JavaScript execution context.
+@discussion JSGlobalContextCreate allocates a global object and populates it with all the
+ built-in JavaScript objects, such as Object, Function, String, and Array.
+
+ In WebKit version 4.0 and later, the context is created in a unique context group.
+ Therefore, scripts may execute in it concurrently with scripts executing in other contexts.
+ However, you may not use values created in the context in other contexts.
+@param globalObjectClass The class to use when creating the global object. Pass 
+ NULL to use the default object class.
+@result A JSGlobalContext with a global object of class globalObjectClass.
+*/
+JS_EXPORT JSGlobalContextRef JSGlobalContextCreate(JSClassRef globalObjectClass) JSC_API_AVAILABLE(macos(10.5), ios(7.0));
+
+/*!
+@function
+@abstract Creates a global JavaScript execution context in the context group provided.
+@discussion JSGlobalContextCreateInGroup allocates a global object and populates it with
+ all the built-in JavaScript objects, such as Object, Function, String, and Array.
+@param globalObjectClass The class to use when creating the global object. Pass
+ NULL to use the default object class.
+@param group The context group to use. The created global context retains the group.
+ Pass NULL to create a unique group for the context.
+@result A JSGlobalContext with a global object of class globalObjectClass and a context
+ group equal to group.
+*/
+JS_EXPORT JSGlobalContextRef JSGlobalContextCreateInGroup(JSContextGroupRef group, JSClassRef globalObjectClass) JSC_API_AVAILABLE(macos(10.6), ios(7.0));
+
+/*!
+@function
+@abstract Retains a global JavaScript execution context.
+@param ctx The JSGlobalContext to retain.
+@result A JSGlobalContext that is the same as ctx.
+*/
+JS_EXPORT JSGlobalContextRef JSGlobalContextRetain(JSGlobalContextRef ctx);
+
+/*!
+@function
+@abstract Releases a global JavaScript execution context.
+@param ctx The JSGlobalContext to release.
+*/
+JS_EXPORT void JSGlobalContextRelease(JSGlobalContextRef ctx);
+
+/*!
+@function
+@abstract Gets the global object of a JavaScript execution context.
+@param ctx The JSContext whose global object you want to get.
+@result ctx's global object.
+*/
+JS_EXPORT JSObjectRef JSContextGetGlobalObject(JSContextRef ctx);
+
+/*!
+@function
+@abstract Gets the context group to which a JavaScript execution context belongs.
+@param ctx The JSContext whose group you want to get.
+@result ctx's group.
+*/
+JS_EXPORT JSContextGroupRef JSContextGetGroup(JSContextRef ctx) JSC_API_AVAILABLE(macos(10.6), ios(7.0));
+
+/*!
+@function
+@abstract Gets the global context of a JavaScript execution context.
+@param ctx The JSContext whose global context you want to get.
+@result ctx's global context.
+*/
+JS_EXPORT JSGlobalContextRef JSContextGetGlobalContext(JSContextRef ctx) JSC_API_AVAILABLE(macos(10.7), ios(7.0));
+
+/*!
+@function
+@abstract Gets a copy of the name of a context.
+@param ctx The JSGlobalContext whose name you want to get.
+@result The name for ctx.
+@discussion A JSGlobalContext's name is exposed for remote debugging to make it
+easier to identify the context you would like to attach to.
+*/
+JS_EXPORT JSStringRef JSGlobalContextCopyName(JSGlobalContextRef ctx) JSC_API_AVAILABLE(macos(10.10), ios(8.0));
+
+/*!
+@function
+@abstract Sets the remote debugging name for a context.
+@param ctx The JSGlobalContext that you want to name.
+@param name The remote debugging name to set on ctx.
+*/
+JS_EXPORT void JSGlobalContextSetName(JSGlobalContextRef ctx, JSStringRef name) JSC_API_AVAILABLE(macos(10.10), ios(8.0));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* JSContextRef_h */
diff --git a/engine/inc/JavaScriptCore/JSObjectRef.h b/engine/inc/JavaScriptCore/JSObjectRef.h
new file mode 100644
index 00000000..a3e3ffa3
--- /dev/null
+++ b/engine/inc/JavaScriptCore/JSObjectRef.h
@@ -0,0 +1,856 @@
+/*
+ * Copyright (C) 2006-2019 Apple Inc. All rights reserved.
+ * Copyright (C) 2008 Kelvin W Sherlock (ksherlock@gmail.com)
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef JSObjectRef_h
+#define JSObjectRef_h
+
+#include <JavaScriptCore/JSBase.h>
+#include <JavaScriptCore/JSValueRef.h>
+#include <JavaScriptCore/WebKitAvailability.h>
+
+#ifndef __cplusplus
+#include <stdbool.h>
+#endif
+#include <stddef.h> /* for size_t */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*!
+@enum JSPropertyAttribute
+@constant kJSPropertyAttributeNone         Specifies that a property has no special attributes.
+@constant kJSPropertyAttributeReadOnly     Specifies that a property is read-only.
+@constant kJSPropertyAttributeDontEnum     Specifies that a property should not be enumerated by JSPropertyEnumerators and JavaScript for...in loops.
+@constant kJSPropertyAttributeDontDelete   Specifies that the delete operation should fail on a property.
+*/
+enum { 
+    kJSPropertyAttributeNone         = 0,
+    kJSPropertyAttributeReadOnly     = 1 << 1,
+    kJSPropertyAttributeDontEnum     = 1 << 2,
+    kJSPropertyAttributeDontDelete   = 1 << 3
+};
+
+/*! 
+@typedef JSPropertyAttributes
+@abstract A set of JSPropertyAttributes. Combine multiple attributes by logically ORing them together.
+*/
+typedef unsigned JSPropertyAttributes;
+
+/*!
+@enum JSClassAttribute
+@constant kJSClassAttributeNone Specifies that a class has no special attributes.
+@constant kJSClassAttributeNoAutomaticPrototype Specifies that a class should not automatically generate a shared prototype for its instance objects. Use kJSClassAttributeNoAutomaticPrototype in combination with JSObjectSetPrototype to manage prototypes manually.
+*/
+enum { 
+    kJSClassAttributeNone = 0,
+    kJSClassAttributeNoAutomaticPrototype = 1 << 1
+};
+
+/*! 
+@typedef JSClassAttributes
+@abstract A set of JSClassAttributes. Combine multiple attributes by logically ORing them together.
+*/
+typedef unsigned JSClassAttributes;
+
+/*! 
+@typedef JSObjectInitializeCallback
+@abstract The callback invoked when an object is first created.
+@param ctx The execution context to use.
+@param object The JSObject being created.
+@discussion If you named your function Initialize, you would declare it like this:
+
+void Initialize(JSContextRef ctx, JSObjectRef object);
+
+Unlike the other object callbacks, the initialize callback is called on the least
+derived class (the parent class) first, and the most derived class last.
+*/
+typedef void
+(*JSObjectInitializeCallback) (JSContextRef ctx, JSObjectRef object);
+
+/* Extension of the above callback with the class that the method is being invoked for. */
+typedef void
+(*JSObjectInitializeCallbackEx) (JSContextRef ctx, JSClassRef jsClass, JSObjectRef object);
+
+/*! 
+@typedef JSObjectFinalizeCallback
+@abstract The callback invoked when an object is finalized (prepared for garbage collection). An object may be finalized on any thread.
+@param object The JSObject being finalized.
+@discussion If you named your function Finalize, you would declare it like this:
+
+void Finalize(JSObjectRef object);
+
+The finalize callback is called on the most derived class first, and the least 
+derived class (the parent class) last.
+
+You must not call any function that may cause a garbage collection or an allocation
+of a garbage collected object from within a JSObjectFinalizeCallback. This includes
+all functions that have a JSContextRef parameter.
+*/
+typedef void            
+(*JSObjectFinalizeCallback) (JSObjectRef object);
+
+/* Extension of the above callback with the class that the method is being invoked for. */
+typedef void
+(*JSObjectFinalizeCallbackEx) (JSClassRef jsClass, JSObjectRef object);
+
+/*! 
+@typedef JSObjectHasPropertyCallback
+@abstract The callback invoked when determining whether an object has a property.
+@param ctx The execution context to use.
+@param object The JSObject to search for the property.
+@param propertyName A JSString containing the name of the property look up.
+@result true if object has the property, otherwise false.
+@discussion If you named your function HasProperty, you would declare it like this:
+
+bool HasProperty(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName);
+
+If this function returns false, the hasProperty request forwards to object's statically declared properties, then its parent class chain (which includes the default object class), then its prototype chain.
+
+This callback enables optimization in cases where only a property's existence needs to be known, not its value, and computing its value would be expensive.
+
+If this callback is NULL, the getProperty callback will be used to service hasProperty requests.
+*/
+typedef bool
+(*JSObjectHasPropertyCallback) (JSContextRef ctx, JSObjectRef object, JSStringRef propertyName);
+
+/* Extension of the above callback with the class that the method is being invoked for. */
+typedef bool
+(*JSObjectHasPropertyCallbackEx) (JSContextRef ctx, JSClassRef jsClass, JSObjectRef object, JSStringRef propertyName);
+
+/*! 
+@typedef JSObjectGetPropertyCallback
+@abstract The callback invoked when getting a property's value.
+@param ctx The execution context to use.
+@param object The JSObject to search for the property.
+@param propertyName A JSString containing the name of the property to get.
+@param exception A pointer to a JSValueRef in which to return an exception, if any.
+@result The property's value if object has the property, otherwise NULL.
+@discussion If you named your function GetProperty, you would declare it like this:
+
+JSValueRef GetProperty(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception);
+
+If this function returns NULL, the get request forwards to object's statically declared properties, then its parent class chain (which includes the default object class), then its prototype chain.
+*/
+typedef JSValueRef
+(*JSObjectGetPropertyCallback) (JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception);
+
+/* Extension of the above callback with the class that the method is being invoked for. */
+typedef JSValueRef
+(*JSObjectGetPropertyCallbackEx) (JSContextRef ctx, JSClassRef jsClass, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception);
+
+/*! 
+@typedef JSObjectSetPropertyCallback
+@abstract The callback invoked when setting a property's value.
+@param ctx The execution context to use.
+@param object The JSObject on which to set the property's value.
+@param propertyName A JSString containing the name of the property to set.
+@param value A JSValue to use as the property's value.
+@param exception A pointer to a JSValueRef in which to return an exception, if any.
+@result true if the property was set, otherwise false.
+@discussion If you named your function SetProperty, you would declare it like this:
+
+bool SetProperty(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef value, JSValueRef* exception);
+
+If this function returns false, the set request forwards to object's statically declared properties, then its parent class chain (which includes the default object class).
+*/
+typedef bool
+(*JSObjectSetPropertyCallback) (JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef value, JSValueRef* exception);
+
+/* Extension of the above callback with the class that the method is being invoked for. */
+typedef bool
+(*JSObjectSetPropertyCallbackEx) (JSContextRef ctx, JSClassRef jsClass, JSObjectRef object, JSStringRef propertyName, JSValueRef value, JSValueRef* exception);
+
+/*! 
+@typedef JSObjectDeletePropertyCallback
+@abstract The callback invoked when deleting a property.
+@param ctx The execution context to use.
+@param object The JSObject in which to delete the property.
+@param propertyName A JSString containing the name of the property to delete.
+@param exception A pointer to a JSValueRef in which to return an exception, if any.
+@result true if propertyName was successfully deleted, otherwise false.
+@discussion If you named your function DeleteProperty, you would declare it like this:
+
+bool DeleteProperty(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception);
+
+If this function returns false, the delete request forwards to object's statically declared properties, then its parent class chain (which includes the default object class).
+*/
+typedef bool
+(*JSObjectDeletePropertyCallback) (JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception);
+
+/* Extension of the above callback with the class that the method is being invoked for. */
+typedef bool
+(*JSObjectDeletePropertyCallbackEx) (JSContextRef ctx, JSClassRef jsClass, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception);
+
+/*! 
+@typedef JSObjectGetPropertyNamesCallback
+@abstract The callback invoked when collecting the names of an object's properties.
+@param ctx The execution context to use.
+@param object The JSObject whose property names are being collected.
+@param propertyNames A JavaScript property name accumulator in which to accumulate the names of object's properties.
+@discussion If you named your function GetPropertyNames, you would declare it like this:
+
+void GetPropertyNames(JSContextRef ctx, JSObjectRef object, JSPropertyNameAccumulatorRef propertyNames);
+
+Property name accumulators are used by JSObjectCopyPropertyNames and JavaScript for...in loops. 
+
+Use JSPropertyNameAccumulatorAddName to add property names to accumulator. A class's getPropertyNames callback only needs to provide the names of properties that the class vends through a custom getProperty or setProperty callback. Other properties, including statically declared properties, properties vended by other classes, and properties belonging to object's prototype, are added independently.
+*/
+typedef void
+(*JSObjectGetPropertyNamesCallback) (JSContextRef ctx, JSObjectRef object, JSPropertyNameAccumulatorRef propertyNames);
+
+/* Extension of the above callback with the class that the method is being invoked for. */
+typedef void
+(*JSObjectGetPropertyNamesCallbackEx) (JSContextRef ctx, JSClassRef jsClass, JSObjectRef object, JSPropertyNameAccumulatorRef propertyNames);
+
+/*! 
+@typedef JSObjectCallAsFunctionCallback
+@abstract The callback invoked when an object is called as a function.
+@param ctx The execution context to use.
+@param function A JSObject that is the function being called.
+@param thisObject A JSObject that is the 'this' variable in the function's scope.
+@param argumentCount An integer count of the number of arguments in arguments.
+@param arguments A JSValue array of the  arguments passed to the function.
+@param exception A pointer to a JSValueRef in which to return an exception, if any.
+@result A JSValue that is the function's return value.
+@discussion If you named your function CallAsFunction, you would declare it like this:
+
+JSValueRef CallAsFunction(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);
+
+If your callback were invoked by the JavaScript expression 'myObject.myFunction()', function would be set to myFunction, and thisObject would be set to myObject.
+
+If this callback is NULL, calling your object as a function will throw an exception.
+*/
+typedef JSValueRef 
+(*JSObjectCallAsFunctionCallback) (JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);
+
+/* Extension of the above callback with the class and class name of the object being called as a function. 
+@discussion If this is a JSStaticFunctionEx, className will actually be the name of the function.
+*/
+typedef JSValueRef
+(*JSObjectCallAsFunctionCallbackEx) (JSContextRef ctx, JSClassRef jsClass, JSStringRef className, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);
+
+/*! 
+@typedef JSObjectCallAsConstructorCallback
+@abstract The callback invoked when an object is used as a constructor in a 'new' expression.
+@param ctx The execution context to use.
+@param constructor A JSObject that is the constructor being called.
+@param argumentCount An integer count of the number of arguments in arguments.
+@param arguments A JSValue array of the  arguments passed to the function.
+@param exception A pointer to a JSValueRef in which to return an exception, if any.
+@result A JSObject that is the constructor's return value.
+@discussion If you named your function CallAsConstructor, you would declare it like this:
+
+JSObjectRef CallAsConstructor(JSContextRef ctx, JSObjectRef constructor, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);
+
+If your callback were invoked by the JavaScript expression 'new myConstructor()', constructor would be set to myConstructor.
+
+If this callback is NULL, using your object as a constructor in a 'new' expression will throw an exception.
+*/
+typedef JSObjectRef 
+(*JSObjectCallAsConstructorCallback) (JSContextRef ctx, JSObjectRef constructor, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);
+
+/* Extension of the above callback with the class that the method is being invoked for. */
+typedef JSObjectRef
+(*JSObjectCallAsConstructorCallbackEx) (JSContextRef ctx, JSClassRef jsClass, JSObjectRef constructor, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);
+
+/*! 
+@typedef JSObjectHasInstanceCallback
+@abstract hasInstance The callback invoked when an object is used as the target of an 'instanceof' expression.
+@param ctx The execution context to use.
+@param constructor The JSObject that is the target of the 'instanceof' expression.
+@param possibleInstance The JSValue being tested to determine if it is an instance of constructor.
+@param exception A pointer to a JSValueRef in which to return an exception, if any.
+@result true if possibleInstance is an instance of constructor, otherwise false.
+@discussion If you named your function HasInstance, you would declare it like this:
+
+bool HasInstance(JSContextRef ctx, JSObjectRef constructor, JSValueRef possibleInstance, JSValueRef* exception);
+
+If your callback were invoked by the JavaScript expression 'someValue instanceof myObject', constructor would be set to myObject and possibleInstance would be set to someValue.
+
+If this callback is NULL, 'instanceof' expressions that target your object will return false.
+
+Standard JavaScript practice calls for objects that implement the callAsConstructor callback to implement the hasInstance callback as well.
+*/
+typedef bool 
+(*JSObjectHasInstanceCallback)  (JSContextRef ctx, JSObjectRef constructor, JSValueRef possibleInstance, JSValueRef* exception);
+
+/* Extension of the above callback with the class that the method is being invoked for. */
+typedef bool
+(*JSObjectHasInstanceCallbackEx)  (JSContextRef ctx, JSClassRef jsClass, JSObjectRef constructor, JSValueRef possibleInstance, JSValueRef* exception);
+
+/*! 
+@typedef JSObjectConvertToTypeCallback
+@abstract The callback invoked when converting an object to a particular JavaScript type.
+@param ctx The execution context to use.
+@param object The JSObject to convert.
+@param type A JSType specifying the JavaScript type to convert to.
+@param exception A pointer to a JSValueRef in which to return an exception, if any.
+@result The objects's converted value, or NULL if the object was not converted.
+@discussion If you named your function ConvertToType, you would declare it like this:
+
+JSValueRef ConvertToType(JSContextRef ctx, JSObjectRef object, JSType type, JSValueRef* exception);
+
+If this function returns false, the conversion request forwards to object's parent class chain (which includes the default object class).
+
+This function is only invoked when converting an object to number or string. An object converted to boolean is 'true.' An object converted to object is itself.
+*/
+typedef JSValueRef
+(*JSObjectConvertToTypeCallback) (JSContextRef ctx, JSObjectRef object, JSType type, JSValueRef* exception);
+
+/* Extension of the above callback with the class that the method is being invoked for. */
+typedef JSValueRef
+(*JSObjectConvertToTypeCallbackEx) (JSContextRef ctx, JSClassRef jsClass, JSObjectRef object, JSType type, JSValueRef* exception);
+
+/*! 
+@struct JSStaticValue
+@abstract This structure describes a statically declared value property.
+@field name A null-terminated UTF8 string containing the property's name.
+@field getProperty A JSObjectGetPropertyCallback to invoke when getting the property's value.
+@field setProperty A JSObjectSetPropertyCallback to invoke when setting the property's value. May be NULL if the ReadOnly attribute is set.
+@field attributes A logically ORed set of JSPropertyAttributes to give to the property.
+*/
+typedef struct {
+    const char* name;
+    JSObjectGetPropertyCallback getProperty;
+    JSObjectSetPropertyCallback setProperty;
+    JSPropertyAttributes attributes;
+} JSStaticValue;
+
+/* Extension of the above structure for use with class version 1000 */
+typedef struct {
+  const char* name;
+  JSObjectGetPropertyCallbackEx getPropertyEx;
+  JSObjectSetPropertyCallbackEx setPropertyEx;
+  JSPropertyAttributes attributes;
+} JSStaticValueEx;
+
+/*! 
+@struct JSStaticFunction
+@abstract This structure describes a statically declared function property.
+@field name A null-terminated UTF8 string containing the property's name.
+@field callAsFunction A JSObjectCallAsFunctionCallback to invoke when the property is called as a function.
+@field attributes A logically ORed set of JSPropertyAttributes to give to the property.
+*/
+typedef struct {
+    const char* name;
+    JSObjectCallAsFunctionCallback callAsFunction;
+    JSPropertyAttributes attributes;
+} JSStaticFunction;
+
+/* Extension of the above structure for use with class version 1000 */
+typedef struct {
+  const char* name;
+  JSObjectCallAsFunctionCallbackEx callAsFunctionEx;
+  JSPropertyAttributes attributes;
+} JSStaticFunctionEx;
+
+/*!
+@struct JSClassDefinition
+@abstract This structure contains properties and callbacks that define a type of object. All fields other than the version field are optional. Any pointer may be NULL.
+@field version The version number of this structure. The current version is 0.
+@field attributes A logically ORed set of JSClassAttributes to give to the class.
+@field className A null-terminated UTF8 string containing the class's name.
+@field parentClass A JSClass to set as the class's parent class. Pass NULL use the default object class.
+@field staticValues A JSStaticValue array containing the class's statically declared value properties. Pass NULL to specify no statically declared value properties. The array must be terminated by a JSStaticValue whose name field is NULL.
+@field staticFunctions A JSStaticFunction array containing the class's statically declared function properties. Pass NULL to specify no statically declared function properties. The array must be terminated by a JSStaticFunction whose name field is NULL.
+@field initialize The callback invoked when an object is first created. Use this callback to initialize the object.
+@field finalize The callback invoked when an object is finalized (prepared for garbage collection). Use this callback to release resources allocated for the object, and perform other cleanup.
+@field hasProperty The callback invoked when determining whether an object has a property. If this field is NULL, getProperty is called instead. The hasProperty callback enables optimization in cases where only a property's existence needs to be known, not its value, and computing its value is expensive. 
+@field getProperty The callback invoked when getting a property's value.
+@field setProperty The callback invoked when setting a property's value.
+@field deleteProperty The callback invoked when deleting a property.
+@field getPropertyNames The callback invoked when collecting the names of an object's properties.
+@field callAsFunction The callback invoked when an object is called as a function.
+@field hasInstance The callback invoked when an object is used as the target of an 'instanceof' expression.
+@field callAsConstructor The callback invoked when an object is used as a constructor in a 'new' expression.
+@field convertToType The callback invoked when converting an object to a particular JavaScript type.
+@discussion The staticValues and staticFunctions arrays are the simplest and most efficient means for vending custom properties. Statically declared properties autmatically service requests like getProperty, setProperty, and getPropertyNames. Property access callbacks are required only to implement unusual properties, like array indexes, whose names are not known at compile-time.
+
+If you named your getter function "GetX" and your setter function "SetX", you would declare a JSStaticValue array containing "X" like this:
+
+JSStaticValue StaticValueArray[] = {
+    { "X", GetX, SetX, kJSPropertyAttributeNone },
+    { 0, 0, 0, 0 }
+};
+
+Standard JavaScript practice calls for storing function objects in prototypes, so they can be shared. The default JSClass created by JSClassCreate follows this idiom, instantiating objects with a shared, automatically generating prototype containing the class's function objects. The kJSClassAttributeNoAutomaticPrototype attribute specifies that a JSClass should not automatically generate such a prototype. The resulting JSClass instantiates objects with the default object prototype, and gives each instance object its own copy of the class's function objects.
+
+A NULL callback specifies that the default object callback should substitute, except in the case of hasProperty, where it specifies that getProperty should substitute.
+*/
+typedef struct {
+    int                                 version; /* default version is 0, use version 1000 for callbacks with extended class information */
+    JSClassAttributes                   attributes;
+
+    const char*                         className;
+    JSClassRef                          parentClass;
+
+    union {
+        /* version 0 */
+        struct { 
+            const JSStaticValue*                staticValues;
+            const JSStaticFunction*             staticFunctions;
+            JSObjectInitializeCallback          initialize;
+            JSObjectFinalizeCallback            finalize;
+            JSObjectHasPropertyCallback         hasProperty;
+            JSObjectGetPropertyCallback         getProperty;
+            JSObjectSetPropertyCallback         setProperty;
+            JSObjectDeletePropertyCallback      deleteProperty;
+            JSObjectGetPropertyNamesCallback    getPropertyNames;
+            JSObjectCallAsFunctionCallback      callAsFunction;
+            JSObjectCallAsConstructorCallback   callAsConstructor;
+            JSObjectHasInstanceCallback         hasInstance;
+            JSObjectConvertToTypeCallback       convertToType;
+        };
+
+        /* version 1000 */
+        struct {
+            const JSStaticValueEx*                staticValuesEx;
+            const JSStaticFunctionEx*             staticFunctionsEx;
+            JSObjectInitializeCallbackEx          initializeEx;
+            JSObjectFinalizeCallbackEx            finalizeEx;
+            JSObjectHasPropertyCallbackEx         hasPropertyEx;
+            JSObjectGetPropertyCallbackEx         getPropertyEx;
+            JSObjectSetPropertyCallbackEx         setPropertyEx;
+            JSObjectDeletePropertyCallbackEx      deletePropertyEx;
+            JSObjectGetPropertyNamesCallbackEx    getPropertyNamesEx;
+            JSObjectCallAsFunctionCallbackEx      callAsFunctionEx;
+            JSObjectCallAsConstructorCallbackEx   callAsConstructorEx;
+            JSObjectHasInstanceCallbackEx         hasInstanceEx;
+            JSObjectConvertToTypeCallbackEx       convertToTypeEx;
+        };
+    };
+
+    void* privateData; /* version 1000 only */
+} JSClassDefinition;
+
+/*! 
+@const kJSClassDefinitionEmpty 
+@abstract A JSClassDefinition structure of the current version, filled with NULL pointers and having no attributes.
+@discussion Use this constant as a convenience when creating class definitions. For example, to create a class definition with only a finalize method:
+
+JSClassDefinition definition = kJSClassDefinitionEmpty;
+definition.finalize = Finalize;
+*/
+JS_EXPORT extern const JSClassDefinition kJSClassDefinitionEmpty;
+
+/*!
+@function
+@abstract Creates a JavaScript class suitable for use with JSObjectMake.
+@param definition A JSClassDefinition that defines the class.
+@result A JSClass with the given definition. Ownership follows the Create Rule.
+*/
+JS_EXPORT JSClassRef JSClassCreate(const JSClassDefinition* definition);
+
+/*!
+@function
+@abstract Retains a JavaScript class.
+@param jsClass The JSClass to retain.
+@result A JSClass that is the same as jsClass.
+*/
+JS_EXPORT JSClassRef JSClassRetain(JSClassRef jsClass);
+
+/*!
+@function
+@abstract Releases a JavaScript class.
+@param jsClass The JSClass to release.
+*/
+JS_EXPORT void JSClassRelease(JSClassRef jsClass);
+
+/*!
+@function
+@abstract Retrieves the private data from a class reference, only possible with classes created with version 1000 (extended callbacks).
+@param jsClass The class to get the data from
+@result The private data on the class, or NULL, if not set
+@discussion Only classes with version 1000 (extended callbacks) can store private data, for other classes always NULL will always be returned.
+*/
+JS_EXPORT void* JSClassGetPrivate(JSClassRef jsClass);
+
+/*!
+@function
+@abstract Sets the private data on a class, only possible with classes created with version 1000 (extended callbacks).
+@param jsClass The class to set the data on
+@param data A void* to set as the private data for the class
+@result true if the data has been set on the class, false if the class has not been created with version 1000 (extended callbacks)
+@discussion Only classes with version 1000 (extended callbacks) can store private data, for other classes the function always fails. The set pointer is not touched by the engine.
+*/
+JS_EXPORT bool JSClassSetPrivate(JSClassRef jsClass, void* data);
+
+/*!
+@function
+@abstract Creates a JavaScript object.
+@param ctx The execution context to use.
+@param jsClass The JSClass to assign to the object. Pass NULL to use the default object class.
+@param data A void* to set as the object's private data. Pass NULL to specify no private data.
+@result A JSObject with the given class and private data.
+@discussion The default object class does not allocate storage for private data, so you must provide a non-NULL jsClass to JSObjectMake if you want your object to be able to store private data.
+
+data is set on the created object before the intialize methods in its class chain are called. This enables the initialize methods to retrieve and manipulate data through JSObjectGetPrivate.
+*/
+JS_EXPORT JSObjectRef JSObjectMake(JSContextRef ctx, JSClassRef jsClass, void* data);
+
+/*!
+@function
+@abstract Convenience method for creating a JavaScript function with a given callback as its implementation.
+@param ctx The execution context to use.
+@param name A JSString containing the function's name. This will be used when converting the function to string. Pass NULL to create an anonymous function.
+@param callAsFunction The JSObjectCallAsFunctionCallback to invoke when the function is called.
+@result A JSObject that is a function. The object's prototype will be the default function prototype.
+*/
+JS_EXPORT JSObjectRef JSObjectMakeFunctionWithCallback(JSContextRef ctx, JSStringRef name, JSObjectCallAsFunctionCallback callAsFunction);
+
+/*!
+@function
+@abstract Convenience method for creating a JavaScript constructor.
+@param ctx The execution context to use.
+@param jsClass A JSClass that is the class your constructor will assign to the objects its constructs. jsClass will be used to set the constructor's .prototype property, and to evaluate 'instanceof' expressions. Pass NULL to use the default object class.
+@param callAsConstructor A JSObjectCallAsConstructorCallback to invoke when your constructor is used in a 'new' expression. Pass NULL to use the default object constructor.
+@result A JSObject that is a constructor. The object's prototype will be the default object prototype.
+@discussion The default object constructor takes no arguments and constructs an object of class jsClass with no private data.
+*/
+JS_EXPORT JSObjectRef JSObjectMakeConstructor(JSContextRef ctx, JSClassRef jsClass, JSObjectCallAsConstructorCallback callAsConstructor);
+
+/*!
+ @function
+ @abstract Creates a JavaScript Array object.
+ @param ctx The execution context to use.
+ @param argumentCount An integer count of the number of arguments in arguments.
+ @param arguments A JSValue array of data to populate the Array with. Pass NULL if argumentCount is 0.
+ @param exception A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+ @result A JSObject that is an Array.
+ @discussion The behavior of this function does not exactly match the behavior of the built-in Array constructor. Specifically, if one argument 
+ is supplied, this function returns an array with one element.
+ */
+JS_EXPORT JSObjectRef JSObjectMakeArray(JSContextRef ctx, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) JSC_API_AVAILABLE(macos(10.6), ios(7.0));
+
+/*!
+ @function
+ @abstract Creates a JavaScript Date object, as if by invoking the built-in Date constructor.
+ @param ctx The execution context to use.
+ @param argumentCount An integer count of the number of arguments in arguments.
+ @param arguments A JSValue array of arguments to pass to the Date Constructor. Pass NULL if argumentCount is 0.
+ @param exception A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+ @result A JSObject that is a Date.
+ */
+JS_EXPORT JSObjectRef JSObjectMakeDate(JSContextRef ctx, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) JSC_API_AVAILABLE(macos(10.6), ios(7.0));
+
+/*!
+ @function
+ @abstract Creates a JavaScript Error object, as if by invoking the built-in Error constructor.
+ @param ctx The execution context to use.
+ @param argumentCount An integer count of the number of arguments in arguments.
+ @param arguments A JSValue array of arguments to pass to the Error Constructor. Pass NULL if argumentCount is 0.
+ @param exception A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+ @result A JSObject that is a Error.
+ */
+JS_EXPORT JSObjectRef JSObjectMakeError(JSContextRef ctx, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) JSC_API_AVAILABLE(macos(10.6), ios(7.0));
+
+/*!
+ @function
+ @abstract Creates a JavaScript RegExp object, as if by invoking the built-in RegExp constructor.
+ @param ctx The execution context to use.
+ @param argumentCount An integer count of the number of arguments in arguments.
+ @param arguments A JSValue array of arguments to pass to the RegExp Constructor. Pass NULL if argumentCount is 0.
+ @param exception A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+ @result A JSObject that is a RegExp.
+ */
+JS_EXPORT JSObjectRef JSObjectMakeRegExp(JSContextRef ctx, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) JSC_API_AVAILABLE(macos(10.6), ios(7.0));
+
+/*!
+ @function
+ @abstract Creates a JavaScript promise object by invoking the provided executor.
+ @param ctx The execution context to use.
+ @param resolve A pointer to a JSObjectRef in which to store the resolve function for the new promise. Pass NULL if you do not care to store the resolve callback.
+ @param reject A pointer to a JSObjectRef in which to store the reject function for the new promise. Pass NULL if you do not care to store the reject callback.
+ @param exception A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+ @result A JSObject that is a promise or NULL if an exception occurred.
+ */
+JS_EXPORT JSObjectRef JSObjectMakeDeferredPromise(JSContextRef ctx, JSObjectRef* resolve, JSObjectRef* reject, JSValueRef* exception) JSC_API_AVAILABLE(macos(10.15), ios(13.0));
+
+/*!
+@function
+@abstract Creates a function with a given script as its body.
+@param ctx The execution context to use.
+@param name A JSString containing the function's name. This will be used when converting the function to string. Pass NULL to create an anonymous function.
+@param parameterCount An integer count of the number of parameter names in parameterNames.
+@param parameterNames A JSString array containing the names of the function's parameters. Pass NULL if parameterCount is 0.
+@param body A JSString containing the script to use as the function's body.
+@param sourceURL A JSString containing a URL for the script's source file. This is only used when reporting exceptions. Pass NULL if you do not care to include source file information in exceptions.
+@param startingLineNumber An integer value specifying the script's starting line number in the file located at sourceURL. This is only used when reporting exceptions. The value is one-based, so the first line is line 1 and invalid values are clamped to 1.
+@param exception A pointer to a JSValueRef in which to store a syntax error exception, if any. Pass NULL if you do not care to store a syntax error exception.
+@result A JSObject that is a function, or NULL if either body or parameterNames contains a syntax error. The object's prototype will be the default function prototype.
+@discussion Use this method when you want to execute a script repeatedly, to avoid the cost of re-parsing the script before each execution.
+*/
+JS_EXPORT JSObjectRef JSObjectMakeFunction(JSContextRef ctx, JSStringRef name, unsigned parameterCount, const JSStringRef parameterNames[], JSStringRef body, JSStringRef sourceURL, int startingLineNumber, JSValueRef* exception);
+
+/*!
+@function
+@abstract Gets an object's prototype.
+@param ctx  The execution context to use.
+@param object A JSObject whose prototype you want to get.
+@result A JSValue that is the object's prototype.
+*/
+JS_EXPORT JSValueRef JSObjectGetPrototype(JSContextRef ctx, JSObjectRef object);
+
+/*!
+@function
+@abstract Sets an object's prototype.
+@param ctx  The execution context to use.
+@param object The JSObject whose prototype you want to set.
+@param value A JSValue to set as the object's prototype.
+*/
+JS_EXPORT void JSObjectSetPrototype(JSContextRef ctx, JSObjectRef object, JSValueRef value);
+
+/*!
+@function
+@abstract Tests whether an object has a given property.
+@param object The JSObject to test.
+@param propertyName A JSString containing the property's name.
+@result true if the object has a property whose name matches propertyName, otherwise false.
+*/
+JS_EXPORT bool JSObjectHasProperty(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName);
+
+/*!
+@function
+@abstract Gets a property from an object.
+@param ctx The execution context to use.
+@param object The JSObject whose property you want to get.
+@param propertyName A JSString containing the property's name.
+@param exception A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+@result The property's value if object has the property, otherwise the undefined value.
+*/
+JS_EXPORT JSValueRef JSObjectGetProperty(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception);
+
+/*!
+@function
+@abstract Sets a property on an object.
+@param ctx The execution context to use.
+@param object The JSObject whose property you want to set.
+@param propertyName A JSString containing the property's name.
+@param value A JSValueRef to use as the property's value.
+@param attributes A logically ORed set of JSPropertyAttributes to give to the property.
+@param exception A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+*/
+JS_EXPORT void JSObjectSetProperty(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef value, JSPropertyAttributes attributes, JSValueRef* exception);
+
+/*!
+@function
+@abstract Deletes a property from an object.
+@param ctx The execution context to use.
+@param object The JSObject whose property you want to delete.
+@param propertyName A JSString containing the property's name.
+@param exception A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+@result true if the delete operation succeeds, otherwise false (for example, if the property has the kJSPropertyAttributeDontDelete attribute set).
+*/
+JS_EXPORT bool JSObjectDeleteProperty(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception);
+
+/*!
+ @function
+ @abstract Tests whether an object has a given property using a JSValueRef as the property key.
+ @param object The JSObject to test.
+ @param propertyKey A JSValueRef containing the property key to use when looking up the property.
+ @param exception A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+ @result true if the object has a property whose name matches propertyKey, otherwise false.
+ @discussion This function is the same as performing "propertyKey in object" from JavaScript.
+ */
+JS_EXPORT bool JSObjectHasPropertyForKey(JSContextRef ctx, JSObjectRef object, JSValueRef propertyKey, JSValueRef* exception) JSC_API_AVAILABLE(macos(10.15), ios(13.0));
+
+/*!
+ @function
+ @abstract Gets a property from an object using a JSValueRef as the property key.
+ @param ctx The execution context to use.
+ @param object The JSObject whose property you want to get.
+ @param propertyKey A JSValueRef containing the property key to use when looking up the property.
+ @param exception A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+ @result The property's value if object has the property key, otherwise the undefined value.
+ @discussion This function is the same as performing "object[propertyKey]" from JavaScript.
+ */
+JS_EXPORT JSValueRef JSObjectGetPropertyForKey(JSContextRef ctx, JSObjectRef object, JSValueRef propertyKey, JSValueRef* exception) JSC_API_AVAILABLE(macos(10.15), ios(13.0));
+
+/*!
+ @function
+ @abstract Sets a property on an object using a JSValueRef as the property key.
+ @param ctx The execution context to use.
+ @param object The JSObject whose property you want to set.
+ @param propertyKey A JSValueRef containing the property key to use when looking up the property.
+ @param value A JSValueRef to use as the property's value.
+ @param attributes A logically ORed set of JSPropertyAttributes to give to the property.
+ @param exception A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+ @discussion This function is the same as performing "object[propertyKey] = value" from JavaScript.
+ */
+JS_EXPORT void JSObjectSetPropertyForKey(JSContextRef ctx, JSObjectRef object, JSValueRef propertyKey, JSValueRef value, JSPropertyAttributes attributes, JSValueRef* exception) JSC_API_AVAILABLE(macos(10.15), ios(13.0));
+
+/*!
+ @function
+ @abstract Deletes a property from an object using a JSValueRef as the property key.
+ @param ctx The execution context to use.
+ @param object The JSObject whose property you want to delete.
+ @param propertyKey A JSValueRef containing the property key to use when looking up the property.
+ @param exception A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+ @result true if the delete operation succeeds, otherwise false (for example, if the property has the kJSPropertyAttributeDontDelete attribute set).
+ @discussion This function is the same as performing "delete object[propertyKey]" from JavaScript.
+ */
+JS_EXPORT bool JSObjectDeletePropertyForKey(JSContextRef ctx, JSObjectRef object, JSValueRef propertyKey, JSValueRef* exception) JSC_API_AVAILABLE(macos(10.15), ios(13.0));
+
+/*!
+@function
+@abstract Gets a property from an object by numeric index.
+@param ctx The execution context to use.
+@param object The JSObject whose property you want to get.
+@param propertyIndex An integer value that is the property's name.
+@param exception A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+@result The property's value if object has the property, otherwise the undefined value.
+@discussion Calling JSObjectGetPropertyAtIndex is equivalent to calling JSObjectGetProperty with a string containing propertyIndex, but JSObjectGetPropertyAtIndex provides optimized access to numeric properties.
+*/
+JS_EXPORT JSValueRef JSObjectGetPropertyAtIndex(JSContextRef ctx, JSObjectRef object, unsigned propertyIndex, JSValueRef* exception);
+
+/*!
+@function
+@abstract Sets a property on an object by numeric index.
+@param ctx The execution context to use.
+@param object The JSObject whose property you want to set.
+@param propertyIndex The property's name as a number.
+@param value A JSValue to use as the property's value.
+@param exception A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+@discussion Calling JSObjectSetPropertyAtIndex is equivalent to calling JSObjectSetProperty with a string containing propertyIndex, but JSObjectSetPropertyAtIndex provides optimized access to numeric properties.
+*/
+JS_EXPORT void JSObjectSetPropertyAtIndex(JSContextRef ctx, JSObjectRef object, unsigned propertyIndex, JSValueRef value, JSValueRef* exception);
+
+/*!
+@function
+@abstract Gets an object's private data.
+@param object A JSObject whose private data you want to get.
+@result A void* that is the object's private data, if the object has private data, otherwise NULL.
+*/
+JS_EXPORT void* JSObjectGetPrivate(JSObjectRef object);
+
+/*!
+@function
+@abstract Sets a pointer to private data on an object.
+@param object The JSObject whose private data you want to set.
+@param data A void* to set as the object's private data.
+@result true if object can store private data, otherwise false.
+@discussion The default object class does not allocate storage for private data. Only objects created with a non-NULL JSClass can store private data.
+*/
+JS_EXPORT bool JSObjectSetPrivate(JSObjectRef object, void* data);
+
+/*!
+@function
+@abstract Tests whether an object can be called as a function.
+@param ctx  The execution context to use.
+@param object The JSObject to test.
+@result true if the object can be called as a function, otherwise false.
+*/
+JS_EXPORT bool JSObjectIsFunction(JSContextRef ctx, JSObjectRef object);
+
+/*!
+@function
+@abstract Calls an object as a function.
+@param ctx The execution context to use.
+@param object The JSObject to call as a function.
+@param thisObject The object to use as "this," or NULL to use the global object as "this."
+@param argumentCount An integer count of the number of arguments in arguments.
+@param arguments A JSValue array of arguments to pass to the function. Pass NULL if argumentCount is 0.
+@param exception A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+@result The JSValue that results from calling object as a function, or NULL if an exception is thrown or object is not a function.
+*/
+JS_EXPORT JSValueRef JSObjectCallAsFunction(JSContextRef ctx, JSObjectRef object, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);
+
+/*!
+@function
+@abstract Tests whether an object can be called as a constructor.
+@param ctx  The execution context to use.
+@param object The JSObject to test.
+@result true if the object can be called as a constructor, otherwise false.
+*/
+JS_EXPORT bool JSObjectIsConstructor(JSContextRef ctx, JSObjectRef object);
+
+/*!
+@function
+@abstract Calls an object as a constructor.
+@param ctx The execution context to use.
+@param object The JSObject to call as a constructor.
+@param argumentCount An integer count of the number of arguments in arguments.
+@param arguments A JSValue array of arguments to pass to the constructor. Pass NULL if argumentCount is 0.
+@param exception A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+@result The JSObject that results from calling object as a constructor, or NULL if an exception is thrown or object is not a constructor.
+*/
+JS_EXPORT JSObjectRef JSObjectCallAsConstructor(JSContextRef ctx, JSObjectRef object, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);
+
+/*!
+@function
+@abstract Gets the names of an object's enumerable properties.
+@param ctx The execution context to use.
+@param object The object whose property names you want to get.
+@result A JSPropertyNameArray containing the names object's enumerable properties. Ownership follows the Create Rule.
+*/
+JS_EXPORT JSPropertyNameArrayRef JSObjectCopyPropertyNames(JSContextRef ctx, JSObjectRef object);
+
+/*!
+@function
+@abstract Retains a JavaScript property name array.
+@param array The JSPropertyNameArray to retain.
+@result A JSPropertyNameArray that is the same as array.
+*/
+JS_EXPORT JSPropertyNameArrayRef JSPropertyNameArrayRetain(JSPropertyNameArrayRef array);
+
+/*!
+@function
+@abstract Releases a JavaScript property name array.
+@param array The JSPropetyNameArray to release.
+*/
+JS_EXPORT void JSPropertyNameArrayRelease(JSPropertyNameArrayRef array);
+
+/*!
+@function
+@abstract Gets a count of the number of items in a JavaScript property name array.
+@param array The array from which to retrieve the count.
+@result An integer count of the number of names in array.
+*/
+JS_EXPORT size_t JSPropertyNameArrayGetCount(JSPropertyNameArrayRef array);
+
+/*!
+@function
+@abstract Gets a property name at a given index in a JavaScript property name array.
+@param array The array from which to retrieve the property name.
+@param index The index of the property name to retrieve.
+@result A JSStringRef containing the property name.
+*/
+JS_EXPORT JSStringRef JSPropertyNameArrayGetNameAtIndex(JSPropertyNameArrayRef array, size_t index);
+
+/*!
+@function
+@abstract Adds a property name to a JavaScript property name accumulator.
+@param accumulator The accumulator object to which to add the property name.
+@param propertyName The property name to add.
+*/
+JS_EXPORT void JSPropertyNameAccumulatorAddName(JSPropertyNameAccumulatorRef accumulator, JSStringRef propertyName);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* JSObjectRef_h */
diff --git a/engine/inc/JavaScriptCore/JSObjectRefPrivate.h b/engine/inc/JavaScriptCore/JSObjectRefPrivate.h
new file mode 100644
index 00000000..080af870
--- /dev/null
+++ b/engine/inc/JavaScriptCore/JSObjectRefPrivate.h
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2010-2019 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef JSObjectRefPrivate_h
+#define JSObjectRefPrivate_h
+
+#include <JavaScriptCore/JSObjectRef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*!
+ @function
+ @abstract Sets a private property on an object.  This private property cannot be accessed from within JavaScript.
+ @param ctx The execution context to use.
+ @param object The JSObject whose private property you want to set.
+ @param propertyName A JSString containing the property's name.
+ @param value A JSValue to use as the property's value.  This may be NULL.
+ @result true if object can store private data, otherwise false.
+ @discussion This API allows you to store JS values directly an object in a way that will be ensure that they are kept alive without exposing them to JavaScript code and without introducing the reference cycles that may occur when using JSValueProtect.
+
+ The default object class does not allocate storage for private data. Only objects created with a non-NULL JSClass can store private properties.
+ */
+JS_EXPORT bool JSObjectSetPrivateProperty(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef value);
+
+/*!
+ @function
+ @abstract Gets a private property from an object.
+ @param ctx The execution context to use.
+ @param object The JSObject whose private property you want to get.
+ @param propertyName A JSString containing the property's name.
+ @result The property's value if object has the property, otherwise NULL.
+ */
+JS_EXPORT JSValueRef JSObjectGetPrivateProperty(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName);
+
+/*!
+ @function
+ @abstract Deletes a private property from an object.
+ @param ctx The execution context to use.
+ @param object The JSObject whose private property you want to delete.
+ @param propertyName A JSString containing the property's name.
+ @result true if object can store private data, otherwise false.
+ @discussion The default object class does not allocate storage for private data. Only objects created with a non-NULL JSClass can store private data.
+ */
+JS_EXPORT bool JSObjectDeletePrivateProperty(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName);
+
+JS_EXPORT JSObjectRef JSObjectGetProxyTarget(JSObjectRef);
+
+JS_EXPORT JSGlobalContextRef JSObjectGetGlobalContext(JSObjectRef object);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // JSObjectRefPrivate_h
diff --git a/engine/inc/JavaScriptCore/JSRetainPtr.h b/engine/inc/JavaScriptCore/JSRetainPtr.h
new file mode 100644
index 00000000..fdab802d
--- /dev/null
+++ b/engine/inc/JavaScriptCore/JSRetainPtr.h
@@ -0,0 +1,187 @@
+/*
+ * Copyright (C) 2005-2018 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1.  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer. 
+ * 2.  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution. 
+ * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <JavaScriptCore/JSContextRef.h>
+#include <JavaScriptCore/JSStringRef.h>
+#include <algorithm>
+
+#if !defined(WARN_UNUSED_RETURN)
+#define WARN_UNUSED_RETURN
+#endif
+
+inline void JSRetain(JSStringRef string) { JSStringRetain(string); }
+inline void JSRelease(JSStringRef string) { JSStringRelease(string); }
+inline void JSRetain(JSGlobalContextRef context) { JSGlobalContextRetain(context); }
+inline void JSRelease(JSGlobalContextRef context) { JSGlobalContextRelease(context); }
+
+enum AdoptTag { Adopt };
+
+template<typename T> class JSRetainPtr {
+public:
+    JSRetainPtr() = default;
+    JSRetainPtr(T ptr) : m_ptr(ptr) { if (ptr) JSRetain(ptr); }
+    JSRetainPtr(const JSRetainPtr&);
+    JSRetainPtr(JSRetainPtr&&);
+    ~JSRetainPtr();
+    
+    T get() const { return m_ptr; }
+    
+    void clear();
+    T leakRef() WARN_UNUSED_RETURN;
+
+    T operator->() const { return m_ptr; }
+    
+    bool operator!() const { return !m_ptr; }
+    explicit operator bool() const { return m_ptr; }
+
+    JSRetainPtr& operator=(const JSRetainPtr&);
+    JSRetainPtr& operator=(JSRetainPtr&&);
+    JSRetainPtr& operator=(T);
+
+    void swap(JSRetainPtr&);
+
+    friend JSRetainPtr<JSStringRef> adopt(JSStringRef);
+    friend JSRetainPtr<JSGlobalContextRef> adopt(JSGlobalContextRef);
+
+    // FIXME: Make this private once Apple's internal code is updated to not rely on it.
+    // https://bugs.webkit.org/show_bug.cgi?id=189644
+    JSRetainPtr(AdoptTag, T);
+
+private:
+    T m_ptr { nullptr };
+};
+
+JSRetainPtr<JSStringRef> adopt(JSStringRef);
+JSRetainPtr<JSGlobalContextRef> adopt(JSGlobalContextRef);
+
+template<typename T> inline JSRetainPtr<T>::JSRetainPtr(AdoptTag, T ptr)
+    : m_ptr(ptr)
+{
+}
+
+inline JSRetainPtr<JSStringRef> adopt(JSStringRef o)
+{
+    return JSRetainPtr<JSStringRef>(Adopt, o);
+}
+
+inline JSRetainPtr<JSGlobalContextRef> adopt(JSGlobalContextRef o)
+{
+    return JSRetainPtr<JSGlobalContextRef>(Adopt, o);
+}
+
+template<typename T> inline JSRetainPtr<T>::JSRetainPtr(const JSRetainPtr& o)
+    : m_ptr(o.m_ptr)
+{
+    if (m_ptr)
+        JSRetain(m_ptr);
+}
+
+template<typename T> inline JSRetainPtr<T>::JSRetainPtr(JSRetainPtr&& o)
+    : m_ptr(o.leakRef())
+{
+}
+
+template<typename T> inline JSRetainPtr<T>::~JSRetainPtr()
+{
+    if (m_ptr)
+        JSRelease(m_ptr);
+}
+
+template<typename T> inline void JSRetainPtr<T>::clear()
+{
+    if (T ptr = leakRef())
+        JSRelease(ptr);
+}
+
+template<typename T> inline T JSRetainPtr<T>::leakRef()
+{
+    return std::exchange(m_ptr, nullptr);
+}
+
+template<typename T> inline JSRetainPtr<T>& JSRetainPtr<T>::operator=(const JSRetainPtr<T>& o)
+{
+    return operator=(o.get());
+}
+
+template<typename T> inline JSRetainPtr<T>& JSRetainPtr<T>::operator=(JSRetainPtr&& o)
+{
+    if (T ptr = std::exchange(m_ptr, o.leakRef()))
+        JSRelease(ptr);
+    return *this;
+}
+
+template<typename T> inline JSRetainPtr<T>& JSRetainPtr<T>::operator=(T optr)
+{
+    if (optr)
+        JSRetain(optr);
+    if (T ptr = std::exchange(m_ptr, optr))
+        JSRelease(ptr);
+    return *this;
+}
+
+template<typename T> inline void JSRetainPtr<T>::swap(JSRetainPtr<T>& o)
+{
+    std::swap(m_ptr, o.m_ptr);
+}
+
+template<typename T> inline void swap(JSRetainPtr<T>& a, JSRetainPtr<T>& b)
+{
+    a.swap(b);
+}
+
+template<typename T, typename U> inline bool operator==(const JSRetainPtr<T>& a, const JSRetainPtr<U>& b)
+{ 
+    return a.get() == b.get(); 
+}
+
+template<typename T, typename U> inline bool operator==(const JSRetainPtr<T>& a, U* b)
+{ 
+    return a.get() == b; 
+}
+
+template<typename T, typename U> inline bool operator==(T* a, const JSRetainPtr<U>& b) 
+{
+    return a == b.get(); 
+}
+
+template<typename T, typename U> inline bool operator!=(const JSRetainPtr<T>& a, const JSRetainPtr<U>& b)
+{ 
+    return a.get() != b.get(); 
+}
+
+template<typename T, typename U> inline bool operator!=(const JSRetainPtr<T>& a, U* b)
+{
+    return a.get() != b; 
+}
+
+template<typename T, typename U> inline bool operator!=(T* a, const JSRetainPtr<U>& b)
+{ 
+    return a != b.get(); 
+}
diff --git a/engine/inc/JavaScriptCore/JSStringRef.h b/engine/inc/JavaScriptCore/JSStringRef.h
new file mode 100644
index 00000000..9236f05d
--- /dev/null
+++ b/engine/inc/JavaScriptCore/JSStringRef.h
@@ -0,0 +1,148 @@
+/*
+ * Copyright (C) 2006 Apple Inc.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef JSStringRef_h
+#define JSStringRef_h
+
+#include <JavaScriptCore/JSValueRef.h>
+
+#ifndef __cplusplus
+#include <stdbool.h>
+#endif
+#include <stddef.h> /* for size_t */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(_NATIVE_WCHAR_T_DEFINED) /* MSVC */ \
+    && (!defined(__WCHAR_MAX__) || (__WCHAR_MAX__ > 0xffffU)) /* ISO C/C++ */ \
+    && (!defined(WCHAR_MAX) || (WCHAR_MAX > 0xffffU)) /* RVCT */
+/*!
+@typedef JSChar
+@abstract A UTF-16 code unit. One, or a sequence of two, can encode any Unicode
+ character. As with all scalar types, endianness depends on the underlying
+ architecture.
+*/
+    typedef unsigned short JSChar;
+#else
+    typedef wchar_t JSChar;
+#endif
+
+/*!
+@function
+@abstract         Creates a JavaScript string from a buffer of Unicode characters.
+@param chars      The buffer of Unicode characters to copy into the new JSString.
+@param numChars   The number of characters to copy from the buffer pointed to by chars.
+@result           A JSString containing chars. Ownership follows the Create Rule.
+*/
+JS_EXPORT JSStringRef JSStringCreateWithCharacters(const JSChar* chars, size_t numChars);
+/*!
+@function
+@abstract         Creates a JavaScript string from a null-terminated UTF8 string.
+@param string     The null-terminated UTF8 string to copy into the new JSString.
+@result           A JSString containing string. Ownership follows the Create Rule.
+*/
+JS_EXPORT JSStringRef JSStringCreateWithUTF8CString(const char* string);
+
+/*!
+@function
+@abstract         Retains a JavaScript string.
+@param string     The JSString to retain.
+@result           A JSString that is the same as string.
+*/
+JS_EXPORT JSStringRef JSStringRetain(JSStringRef string);
+/*!
+@function
+@abstract         Releases a JavaScript string.
+@param string     The JSString to release.
+*/
+JS_EXPORT void JSStringRelease(JSStringRef string);
+
+/*!
+@function
+@abstract         Returns the number of Unicode characters in a JavaScript string.
+@param string     The JSString whose length (in Unicode characters) you want to know.
+@result           The number of Unicode characters stored in string.
+*/
+JS_EXPORT size_t JSStringGetLength(JSStringRef string);
+/*!
+@function
+@abstract         Returns a pointer to the Unicode character buffer that 
+ serves as the backing store for a JavaScript string.
+@param string     The JSString whose backing store you want to access.
+@result           A pointer to the Unicode character buffer that serves as string's 
+ backing store, which will be deallocated when string is deallocated.
+*/
+JS_EXPORT const JSChar* JSStringGetCharactersPtr(JSStringRef string);
+
+/*!
+@function
+@abstract Returns the maximum number of bytes a JavaScript string will 
+ take up if converted into a null-terminated UTF8 string.
+@param string The JSString whose maximum converted size (in bytes) you 
+ want to know.
+@result The maximum number of bytes that could be required to convert string into a 
+ null-terminated UTF8 string. The number of bytes that the conversion actually ends 
+ up requiring could be less than this, but never more.
+*/
+JS_EXPORT size_t JSStringGetMaximumUTF8CStringSize(JSStringRef string);
+/*!
+@function
+@abstract Converts a JavaScript string into a null-terminated UTF8 string, 
+ and copies the result into an external byte buffer.
+@param string The source JSString.
+@param buffer The destination byte buffer into which to copy a null-terminated 
+ UTF8 representation of string. On return, buffer contains a UTF8 string 
+ representation of string. If bufferSize is too small, buffer will contain only 
+ partial results. If buffer is not at least bufferSize bytes in size, 
+ behavior is undefined. 
+@param bufferSize The size of the external buffer in bytes.
+@result The number of bytes written into buffer (including the null-terminator byte).
+*/
+JS_EXPORT size_t JSStringGetUTF8CString(JSStringRef string, char* buffer, size_t bufferSize);
+
+/*!
+@function
+@abstract     Tests whether two JavaScript strings match.
+@param a      The first JSString to test.
+@param b      The second JSString to test.
+@result       true if the two strings match, otherwise false.
+*/
+JS_EXPORT bool JSStringIsEqual(JSStringRef a, JSStringRef b);
+/*!
+@function
+@abstract     Tests whether a JavaScript string matches a null-terminated UTF8 string.
+@param a      The JSString to test.
+@param b      The null-terminated UTF8 string to test.
+@result       true if the two strings match, otherwise false.
+*/
+JS_EXPORT bool JSStringIsEqualToUTF8CString(JSStringRef a, const char* b);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* JSStringRef_h */
diff --git a/engine/inc/JavaScriptCore/JSTypedArray.h b/engine/inc/JavaScriptCore/JSTypedArray.h
new file mode 100644
index 00000000..aa643ba1
--- /dev/null
+++ b/engine/inc/JavaScriptCore/JSTypedArray.h
@@ -0,0 +1,180 @@
+/*
+ * Copyright (C) 2015 Dominic Szablewski (dominic@phoboslab.org)
+ * Copyright (C) 2015-2016 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef JSTypedArray_h
+#define JSTypedArray_h
+
+#include <JavaScriptCore/JSBase.h>
+#include <JavaScriptCore/JSValueRef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// ------------- Typed Array functions --------------
+
+/*!
+ @function
+ @abstract           Creates a JavaScript Typed Array object with the given number of elements.
+ @param ctx          The execution context to use.
+ @param arrayType    A value identifying the type of array to create. If arrayType is kJSTypedArrayTypeNone or kJSTypedArrayTypeArrayBuffer then NULL will be returned.
+ @param length       The number of elements to be in the new Typed Array.
+ @param exception    A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+ @result             A JSObjectRef that is a Typed Array with all elements set to zero or NULL if there was an error.
+ */
+JS_EXPORT JSObjectRef JSObjectMakeTypedArray(JSContextRef ctx, JSTypedArrayType arrayType, size_t length, JSValueRef* exception) JSC_API_AVAILABLE(macos(10.12), ios(10.0));
+
+/*!
+ @function
+ @abstract                 Creates a JavaScript Typed Array object from an existing pointer.
+ @param ctx                The execution context to use.
+ @param arrayType          A value identifying the type of array to create. If arrayType is kJSTypedArrayTypeNone or kJSTypedArrayTypeArrayBuffer then NULL will be returned.
+ @param bytes              A pointer to the byte buffer to be used as the backing store of the Typed Array object.
+ @param byteLength         The number of bytes pointed to by the parameter bytes.
+ @param bytesDeallocator   The allocator to use to deallocate the external buffer when the JSTypedArrayData object is deallocated.
+ @param deallocatorContext A pointer to pass back to the deallocator.
+ @param exception          A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+ @result                   A JSObjectRef Typed Array whose backing store is the same as the one pointed to by bytes or NULL if there was an error.
+ @discussion               If an exception is thrown during this function the bytesDeallocator will always be called.
+ */
+JS_EXPORT JSObjectRef JSObjectMakeTypedArrayWithBytesNoCopy(JSContextRef ctx, JSTypedArrayType arrayType, void* bytes, size_t byteLength, JSTypedArrayBytesDeallocator bytesDeallocator, void* deallocatorContext, JSValueRef* exception) JSC_API_AVAILABLE(macos(10.12), ios(10.0));
+
+/*!
+ @function
+ @abstract           Creates a JavaScript Typed Array object from an existing JavaScript Array Buffer object.
+ @param ctx          The execution context to use.
+ @param arrayType    A value identifying the type of array to create. If arrayType is kJSTypedArrayTypeNone or kJSTypedArrayTypeArrayBuffer then NULL will be returned.
+ @param buffer       An Array Buffer object that should be used as the backing store for the created JavaScript Typed Array object.
+ @param exception    A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+ @result             A JSObjectRef that is a Typed Array or NULL if there was an error. The backing store of the Typed Array will be buffer.
+ */
+JS_EXPORT JSObjectRef JSObjectMakeTypedArrayWithArrayBuffer(JSContextRef ctx, JSTypedArrayType arrayType, JSObjectRef buffer, JSValueRef* exception) JSC_API_AVAILABLE(macos(10.12), ios(10.0));
+
+/*!
+ @function
+ @abstract           Creates a JavaScript Typed Array object from an existing JavaScript Array Buffer object with the given offset and length.
+ @param ctx          The execution context to use.
+ @param arrayType    A value identifying the type of array to create. If arrayType is kJSTypedArrayTypeNone or kJSTypedArrayTypeArrayBuffer then NULL will be returned.
+ @param buffer       An Array Buffer object that should be used as the backing store for the created JavaScript Typed Array object.
+ @param byteOffset   The byte offset for the created Typed Array. byteOffset should aligned with the element size of arrayType.
+ @param length       The number of elements to include in the Typed Array.
+ @param exception    A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+ @result             A JSObjectRef that is a Typed Array or NULL if there was an error. The backing store of the Typed Array will be buffer.
+ */
+JS_EXPORT JSObjectRef JSObjectMakeTypedArrayWithArrayBufferAndOffset(JSContextRef ctx, JSTypedArrayType arrayType, JSObjectRef buffer, size_t byteOffset, size_t length, JSValueRef* exception) JSC_API_AVAILABLE(macos(10.12), ios(10.0));
+
+/*!
+ @function
+ @abstract           Returns a temporary pointer to the backing store of a JavaScript Typed Array object.
+ @param ctx          The execution context to use.
+ @param object       The Typed Array object whose backing store pointer to return.
+ @param exception    A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+ @result             A pointer to the raw data buffer that serves as object's backing store or NULL if object is not a Typed Array object.
+ @discussion         The pointer returned by this function is temporary and is not guaranteed to remain valid across JavaScriptCore API calls.
+ */
+JS_EXPORT void* JSObjectGetTypedArrayBytesPtr(JSContextRef ctx, JSObjectRef object, JSValueRef* exception) JSC_API_AVAILABLE(macos(10.12), ios(10.0));
+
+/*!
+ @function
+ @abstract           Returns the length of a JavaScript Typed Array object.
+ @param ctx          The execution context to use.
+ @param object       The Typed Array object whose length to return.
+ @param exception    A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+ @result             The length of the Typed Array object or 0 if the object is not a Typed Array object.
+ */
+JS_EXPORT size_t JSObjectGetTypedArrayLength(JSContextRef ctx, JSObjectRef object, JSValueRef* exception) JSC_API_AVAILABLE(macos(10.12), ios(10.0));
+
+/*!
+ @function
+ @abstract           Returns the byte length of a JavaScript Typed Array object.
+ @param ctx          The execution context to use.
+ @param object       The Typed Array object whose byte length to return.
+ @param exception    A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+ @result             The byte length of the Typed Array object or 0 if the object is not a Typed Array object.
+ */
+JS_EXPORT size_t JSObjectGetTypedArrayByteLength(JSContextRef ctx, JSObjectRef object, JSValueRef* exception) JSC_API_AVAILABLE(macos(10.12), ios(10.0));
+
+/*!
+ @function
+ @abstract           Returns the byte offset of a JavaScript Typed Array object.
+ @param ctx          The execution context to use.
+ @param object       The Typed Array object whose byte offset to return.
+ @param exception    A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+ @result             The byte offset of the Typed Array object or 0 if the object is not a Typed Array object.
+ */
+JS_EXPORT size_t JSObjectGetTypedArrayByteOffset(JSContextRef ctx, JSObjectRef object, JSValueRef* exception) JSC_API_AVAILABLE(macos(10.12), ios(10.0));
+
+/*!
+ @function
+ @abstract           Returns the JavaScript Array Buffer object that is used as the backing of a JavaScript Typed Array object.
+ @param ctx          The execution context to use.
+ @param object       The JSObjectRef whose Typed Array type data pointer to obtain.
+ @param exception    A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+ @result             A JSObjectRef with a JSTypedArrayType of kJSTypedArrayTypeArrayBuffer or NULL if object is not a Typed Array.
+ */
+JS_EXPORT JSObjectRef JSObjectGetTypedArrayBuffer(JSContextRef ctx, JSObjectRef object, JSValueRef* exception) JSC_API_AVAILABLE(macos(10.12), ios(10.0));
+
+// ------------- Array Buffer functions -------------
+
+/*!
+ @function
+ @abstract                 Creates a JavaScript Array Buffer object from an existing pointer.
+ @param ctx                The execution context to use.
+ @param bytes              A pointer to the byte buffer to be used as the backing store of the Typed Array object.
+ @param byteLength         The number of bytes pointed to by the parameter bytes.
+ @param bytesDeallocator   The allocator to use to deallocate the external buffer when the Typed Array data object is deallocated.
+ @param deallocatorContext A pointer to pass back to the deallocator.
+ @param exception          A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+ @result                   A JSObjectRef Array Buffer whose backing store is the same as the one pointed to by bytes or NULL if there was an error.
+ @discussion               If an exception is thrown during this function the bytesDeallocator will always be called.
+ */
+JS_EXPORT JSObjectRef JSObjectMakeArrayBufferWithBytesNoCopy(JSContextRef ctx, void* bytes, size_t byteLength, JSTypedArrayBytesDeallocator bytesDeallocator, void* deallocatorContext, JSValueRef* exception) JSC_API_AVAILABLE(macos(10.12), ios(10.0));
+
+/*!
+ @function
+ @abstract         Returns a pointer to the data buffer that serves as the backing store for a JavaScript Typed Array object.
+ @param object     The Array Buffer object whose internal backing store pointer to return.
+ @param exception  A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+ @result           A pointer to the raw data buffer that serves as object's backing store or NULL if object is not an Array Buffer object.
+ @discussion       The pointer returned by this function is temporary and is not guaranteed to remain valid across JavaScriptCore API calls.
+ */
+JS_EXPORT void* JSObjectGetArrayBufferBytesPtr(JSContextRef ctx, JSObjectRef object, JSValueRef* exception) JSC_API_AVAILABLE(macos(10.12), ios(10.0));
+
+/*!
+ @function
+ @abstract         Returns the number of bytes in a JavaScript data object.
+ @param ctx        The execution context to use.
+ @param object     The JS Arary Buffer object whose length in bytes to return.
+ @param exception  A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+ @result           The number of bytes stored in the data object.
+ */
+JS_EXPORT size_t JSObjectGetArrayBufferByteLength(JSContextRef ctx, JSObjectRef object, JSValueRef* exception) JSC_API_AVAILABLE(macos(10.12), ios(10.0));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* JSTypedArray_h */
diff --git a/engine/inc/JavaScriptCore/JSValueRef.h b/engine/inc/JavaScriptCore/JSValueRef.h
new file mode 100644
index 00000000..852a6fa2
--- /dev/null
+++ b/engine/inc/JavaScriptCore/JSValueRef.h
@@ -0,0 +1,380 @@
+/*
+ * Copyright (C) 2006-2019 Apple Inc.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef JSValueRef_h
+#define JSValueRef_h
+
+#include <JavaScriptCore/JSBase.h>
+#include <JavaScriptCore/WebKitAvailability.h>
+
+#ifndef __cplusplus
+#include <stdbool.h>
+#endif
+
+/*!
+@enum JSType
+@abstract     A constant identifying the type of a JSValue.
+@constant     kJSTypeUndefined  The unique undefined value.
+@constant     kJSTypeNull       The unique null value.
+@constant     kJSTypeBoolean    A primitive boolean value, one of true or false.
+@constant     kJSTypeNumber     A primitive number value.
+@constant     kJSTypeString     A primitive string value.
+@constant     kJSTypeObject     An object value (meaning that this JSValueRef is a JSObjectRef).
+@constant     kJSTypeSymbol     A primitive symbol value.
+*/
+typedef enum {
+    kJSTypeUndefined,
+    kJSTypeNull,
+    kJSTypeBoolean,
+    kJSTypeNumber,
+    kJSTypeString,
+    kJSTypeObject,
+    kJSTypeSymbol JSC_API_AVAILABLE(macos(10.15), ios(13.0))
+} JSType;
+
+/*!
+ @enum JSTypedArrayType
+ @abstract     A constant identifying the Typed Array type of a JSObjectRef.
+ @constant     kJSTypedArrayTypeInt8Array            Int8Array
+ @constant     kJSTypedArrayTypeInt16Array           Int16Array
+ @constant     kJSTypedArrayTypeInt32Array           Int32Array
+ @constant     kJSTypedArrayTypeUint8Array           Uint8Array
+ @constant     kJSTypedArrayTypeUint8ClampedArray    Uint8ClampedArray
+ @constant     kJSTypedArrayTypeUint16Array          Uint16Array
+ @constant     kJSTypedArrayTypeUint32Array          Uint32Array
+ @constant     kJSTypedArrayTypeFloat32Array         Float32Array
+ @constant     kJSTypedArrayTypeFloat64Array         Float64Array
+ @constant     kJSTypedArrayTypeArrayBuffer          ArrayBuffer
+ @constant     kJSTypedArrayTypeNone                 Not a Typed Array
+
+ */
+typedef enum {
+    kJSTypedArrayTypeInt8Array,
+    kJSTypedArrayTypeInt16Array,
+    kJSTypedArrayTypeInt32Array,
+    kJSTypedArrayTypeUint8Array,
+    kJSTypedArrayTypeUint8ClampedArray,
+    kJSTypedArrayTypeUint16Array,
+    kJSTypedArrayTypeUint32Array,
+    kJSTypedArrayTypeFloat32Array,
+    kJSTypedArrayTypeFloat64Array,
+    kJSTypedArrayTypeArrayBuffer,
+    kJSTypedArrayTypeNone,
+} JSTypedArrayType JSC_API_AVAILABLE(macos(10.12), ios(10.0));
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*!
+@function
+@abstract       Returns a JavaScript value's type.
+@param ctx  The execution context to use.
+@param value    The JSValue whose type you want to obtain.
+@result         A value of type JSType that identifies value's type.
+*/
+JS_EXPORT JSType JSValueGetType(JSContextRef ctx, JSValueRef value);
+
+/*!
+@function
+@abstract       Tests whether a JavaScript value's type is the undefined type.
+@param ctx  The execution context to use.
+@param value    The JSValue to test.
+@result         true if value's type is the undefined type, otherwise false.
+*/
+JS_EXPORT bool JSValueIsUndefined(JSContextRef ctx, JSValueRef value);
+
+/*!
+@function
+@abstract       Tests whether a JavaScript value's type is the null type.
+@param ctx  The execution context to use.
+@param value    The JSValue to test.
+@result         true if value's type is the null type, otherwise false.
+*/
+JS_EXPORT bool JSValueIsNull(JSContextRef ctx, JSValueRef value);
+
+/*!
+@function
+@abstract       Tests whether a JavaScript value's type is the boolean type.
+@param ctx  The execution context to use.
+@param value    The JSValue to test.
+@result         true if value's type is the boolean type, otherwise false.
+*/
+JS_EXPORT bool JSValueIsBoolean(JSContextRef ctx, JSValueRef value);
+
+/*!
+@function
+@abstract       Tests whether a JavaScript value's type is the number type.
+@param ctx  The execution context to use.
+@param value    The JSValue to test.
+@result         true if value's type is the number type, otherwise false.
+*/
+JS_EXPORT bool JSValueIsNumber(JSContextRef ctx, JSValueRef value);
+
+/*!
+@function
+@abstract       Tests whether a JavaScript value's type is the string type.
+@param ctx  The execution context to use.
+@param value    The JSValue to test.
+@result         true if value's type is the string type, otherwise false.
+*/
+JS_EXPORT bool JSValueIsString(JSContextRef ctx, JSValueRef value);
+
+/*!
+@function
+@abstract       Tests whether a JavaScript value's type is the symbol type.
+@param ctx      The execution context to use.
+@param value    The JSValue to test.
+@result         true if value's type is the symbol type, otherwise false.
+*/
+JS_EXPORT bool JSValueIsSymbol(JSContextRef ctx, JSValueRef value) JSC_API_AVAILABLE(macos(10.15), ios(13.0));
+
+/*!
+@function
+@abstract       Tests whether a JavaScript value's type is the object type.
+@param ctx  The execution context to use.
+@param value    The JSValue to test.
+@result         true if value's type is the object type, otherwise false.
+*/
+JS_EXPORT bool JSValueIsObject(JSContextRef ctx, JSValueRef value);
+
+
+/*!
+@function
+@abstract Tests whether a JavaScript value is an object with a given class in its class chain.
+@param ctx The execution context to use.
+@param value The JSValue to test.
+@param jsClass The JSClass to test against.
+@result true if value is an object and has jsClass in its class chain, otherwise false.
+*/
+JS_EXPORT bool JSValueIsObjectOfClass(JSContextRef ctx, JSValueRef value, JSClassRef jsClass);
+
+/*!
+@function
+@abstract       Tests whether a JavaScript value is an array.
+@param ctx      The execution context to use.
+@param value    The JSValue to test.
+@result         true if value is an array, otherwise false.
+*/
+JS_EXPORT bool JSValueIsArray(JSContextRef ctx, JSValueRef value) JSC_API_AVAILABLE(macos(10.11), ios(9.0));
+
+/*!
+@function
+@abstract       Tests whether a JavaScript value is a date.
+@param ctx      The execution context to use.
+@param value    The JSValue to test.
+@result         true if value is a date, otherwise false.
+*/
+JS_EXPORT bool JSValueIsDate(JSContextRef ctx, JSValueRef value) JSC_API_AVAILABLE(macos(10.11), ios(9.0));
+
+/*!
+@function
+@abstract           Returns a JavaScript value's Typed Array type.
+@param ctx          The execution context to use.
+@param value        The JSValue whose Typed Array type to return.
+@param exception    A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+@result             A value of type JSTypedArrayType that identifies value's Typed Array type, or kJSTypedArrayTypeNone if the value is not a Typed Array object.
+ */
+JS_EXPORT JSTypedArrayType JSValueGetTypedArrayType(JSContextRef ctx, JSValueRef value, JSValueRef* exception) JSC_API_AVAILABLE(macos(10.12), ios(10.0));
+
+/* Comparing values */
+
+/*!
+@function
+@abstract Tests whether two JavaScript values are equal, as compared by the JS == operator.
+@param ctx The execution context to use.
+@param a The first value to test.
+@param b The second value to test.
+@param exception A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+@result true if the two values are equal, false if they are not equal or an exception is thrown.
+*/
+JS_EXPORT bool JSValueIsEqual(JSContextRef ctx, JSValueRef a, JSValueRef b, JSValueRef* exception);
+
+/*!
+@function
+@abstract       Tests whether two JavaScript values are strict equal, as compared by the JS === operator.
+@param ctx  The execution context to use.
+@param a        The first value to test.
+@param b        The second value to test.
+@result         true if the two values are strict equal, otherwise false.
+*/
+JS_EXPORT bool JSValueIsStrictEqual(JSContextRef ctx, JSValueRef a, JSValueRef b);
+
+/*!
+@function
+@abstract Tests whether a JavaScript value is an object constructed by a given constructor, as compared by the JS instanceof operator.
+@param ctx The execution context to use.
+@param value The JSValue to test.
+@param constructor The constructor to test against.
+@param exception A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+@result true if value is an object constructed by constructor, as compared by the JS instanceof operator, otherwise false.
+*/
+JS_EXPORT bool JSValueIsInstanceOfConstructor(JSContextRef ctx, JSValueRef value, JSObjectRef constructor, JSValueRef* exception);
+
+/* Creating values */
+
+/*!
+@function
+@abstract       Creates a JavaScript value of the undefined type.
+@param ctx  The execution context to use.
+@result         The unique undefined value.
+*/
+JS_EXPORT JSValueRef JSValueMakeUndefined(JSContextRef ctx);
+
+/*!
+@function
+@abstract       Creates a JavaScript value of the null type.
+@param ctx  The execution context to use.
+@result         The unique null value.
+*/
+JS_EXPORT JSValueRef JSValueMakeNull(JSContextRef ctx);
+
+/*!
+@function
+@abstract       Creates a JavaScript value of the boolean type.
+@param ctx  The execution context to use.
+@param boolean  The bool to assign to the newly created JSValue.
+@result         A JSValue of the boolean type, representing the value of boolean.
+*/
+JS_EXPORT JSValueRef JSValueMakeBoolean(JSContextRef ctx, bool boolean);
+
+/*!
+@function
+@abstract       Creates a JavaScript value of the number type.
+@param ctx  The execution context to use.
+@param number   The double to assign to the newly created JSValue.
+@result         A JSValue of the number type, representing the value of number.
+*/
+JS_EXPORT JSValueRef JSValueMakeNumber(JSContextRef ctx, double number);
+
+/*!
+@function
+@abstract       Creates a JavaScript value of the string type.
+@param ctx  The execution context to use.
+@param string   The JSString to assign to the newly created JSValue. The
+ newly created JSValue retains string, and releases it upon garbage collection.
+@result         A JSValue of the string type, representing the value of string.
+*/
+JS_EXPORT JSValueRef JSValueMakeString(JSContextRef ctx, JSStringRef string);
+
+/*!
+ @function
+ @abstract            Creates a JavaScript value of the symbol type.
+ @param ctx           The execution context to use.
+ @param description   A description of the newly created symbol value.
+ @result              A unique JSValue of the symbol type, whose description matches the one provided.
+ */
+JS_EXPORT JSValueRef JSValueMakeSymbol(JSContextRef ctx, JSStringRef description) JSC_API_AVAILABLE(macos(10.15), ios(13.0));
+
+/* Converting to and from JSON formatted strings */
+
+/*!
+ @function
+ @abstract       Creates a JavaScript value from a JSON formatted string.
+ @param ctx      The execution context to use.
+ @param string   The JSString containing the JSON string to be parsed.
+ @result         A JSValue containing the parsed value, or NULL if the input is invalid.
+ */
+JS_EXPORT JSValueRef JSValueMakeFromJSONString(JSContextRef ctx, JSStringRef string) JSC_API_AVAILABLE(macos(10.7), ios(7.0));
+
+/*!
+ @function
+ @abstract       Creates a JavaScript string containing the JSON serialized representation of a JS value.
+ @param ctx      The execution context to use.
+ @param value    The value to serialize.
+ @param indent   The number of spaces to indent when nesting.  If 0, the resulting JSON will not contains newlines.  The size of the indent is clamped to 10 spaces.
+ @param exception A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+ @result         A JSString with the result of serialization, or NULL if an exception is thrown.
+ */
+JS_EXPORT JSStringRef JSValueCreateJSONString(JSContextRef ctx, JSValueRef value, unsigned indent, JSValueRef* exception) JSC_API_AVAILABLE(macos(10.7), ios(7.0));
+
+/* Converting to primitive values */
+
+/*!
+@function
+@abstract       Converts a JavaScript value to boolean and returns the resulting boolean.
+@param ctx  The execution context to use.
+@param value    The JSValue to convert.
+@result         The boolean result of conversion.
+*/
+JS_EXPORT bool JSValueToBoolean(JSContextRef ctx, JSValueRef value);
+
+/*!
+@function
+@abstract       Converts a JavaScript value to number and returns the resulting number.
+@param ctx  The execution context to use.
+@param value    The JSValue to convert.
+@param exception A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+@result         The numeric result of conversion, or NaN if an exception is thrown.
+*/
+JS_EXPORT double JSValueToNumber(JSContextRef ctx, JSValueRef value, JSValueRef* exception);
+
+/*!
+@function
+@abstract       Converts a JavaScript value to string and copies the result into a JavaScript string.
+@param ctx  The execution context to use.
+@param value    The JSValue to convert.
+@param exception A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+@result         A JSString with the result of conversion, or NULL if an exception is thrown. Ownership follows the Create Rule.
+*/
+JS_EXPORT JSStringRef JSValueToStringCopy(JSContextRef ctx, JSValueRef value, JSValueRef* exception);
+
+/*!
+@function
+@abstract Converts a JavaScript value to object and returns the resulting object.
+@param ctx  The execution context to use.
+@param value    The JSValue to convert.
+@param exception A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
+@result         The JSObject result of conversion, or NULL if an exception is thrown.
+*/
+JS_EXPORT JSObjectRef JSValueToObject(JSContextRef ctx, JSValueRef value, JSValueRef* exception);
+
+/* Garbage collection */
+/*!
+@function
+@abstract Protects a JavaScript value from garbage collection.
+@param ctx The execution context to use.
+@param value The JSValue to protect.
+@discussion Use this method when you want to store a JSValue in a global or on the heap, where the garbage collector will not be able to discover your reference to it.
+ 
+A value may be protected multiple times and must be unprotected an equal number of times before becoming eligible for garbage collection.
+*/
+JS_EXPORT void JSValueProtect(JSContextRef ctx, JSValueRef value);
+
+/*!
+@function
+@abstract       Unprotects a JavaScript value from garbage collection.
+@param ctx      The execution context to use.
+@param value    The JSValue to unprotect.
+@discussion     A value may be protected multiple times and must be unprotected an 
+ equal number of times before becoming eligible for garbage collection.
+*/
+JS_EXPORT void JSValueUnprotect(JSContextRef ctx, JSValueRef value);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* JSValueRef_h */
diff --git a/engine/inc/JavaScriptCore/JavaScript.h b/engine/inc/JavaScriptCore/JavaScript.h
new file mode 100644
index 00000000..76c52d6e
--- /dev/null
+++ b/engine/inc/JavaScriptCore/JavaScript.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2006 Apple Inc. All rights reserved.
+ * Copyright (C) 2008 Alp Toker <alp@atoker.com>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#ifndef JavaScript_h
+#define JavaScript_h
+
+#include <JavaScriptCore/JSBase.h>
+#include <JavaScriptCore/JSContextRef.h>
+#include <JavaScriptCore/JSStringRef.h>
+#include <JavaScriptCore/JSObjectRef.h>
+#include <JavaScriptCore/JSTypedArray.h>
+#include <JavaScriptCore/JSValueRef.h>
+
+#endif /* JavaScript_h */
diff --git a/engine/inc/JavaScriptCore/WebKitAvailability.h b/engine/inc/JavaScriptCore/WebKitAvailability.h
new file mode 100644
index 00000000..9d39648e
--- /dev/null
+++ b/engine/inc/JavaScriptCore/WebKitAvailability.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2008, 2009, 2010, 2014 Apple Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __WebKitAvailability__
+#define __WebKitAvailability__
+
+#if defined(__APPLE__) && defined(DEFINE_AVAILABILITY_MACROS)
+
+#include <AvailabilityMacros.h>
+#include <CoreFoundation/CoreFoundation.h>
+
+#if !TARGET_OS_IPHONE && __MAC_OS_X_VERSION_MIN_REQUIRED < 101100
+/* To support availability macros that mention newer OS X versions when building on older OS X versions,
+   we provide our own definitions of the underlying macros that the availability macros expand to. We're
+   free to expand the macros as no-ops since frameworks built on older OS X versions only ship bundled with
+   an application rather than as part of the system.
+*/
+
+#ifndef __NSi_10_10 // Building from trunk rather than SDK.
+#define __NSi_10_10 introduced=10.0 // Use 10.0 to indicate that everything is available.
+#endif
+
+#ifndef __NSi_10_11 // Building from trunk rather than SDK.
+#define __NSi_10_11 introduced=10.0 // Use 10.0 to indicate that everything is available.
+#endif
+
+#ifndef __NSi_10_12 // Building from trunk rather than SDK.
+#define __NSi_10_12 introduced=10.0 // Use 10.0 to indicate that everything is available.
+#endif
+
+#ifndef __AVAILABILITY_INTERNAL__MAC_10_9
+#define __AVAILABILITY_INTERNAL__MAC_10_9
+#endif
+
+#ifndef __AVAILABILITY_INTERNAL__MAC_10_10
+#define __AVAILABILITY_INTERNAL__MAC_10_10
+#endif
+
+#ifndef AVAILABLE_MAC_OS_X_VERSION_10_9_AND_LATER
+#define AVAILABLE_MAC_OS_X_VERSION_10_9_AND_LATER
+#endif
+
+#ifndef AVAILABLE_MAC_OS_X_VERSION_10_10_AND_LATER
+#define AVAILABLE_MAC_OS_X_VERSION_10_10_AND_LATER
+#endif
+
+#endif /* !TARGET_OS_IPHONE && __MAC_OS_X_VERSION_MIN_REQUIRED < 101100 */
+
+#if defined(BUILDING_GTK__)
+#undef JSC_API_AVAILABLE
+#define JSC_API_AVAILABLE(...)
+#endif
+
+#else
+#define JSC_API_AVAILABLE(...)
+#endif
+
+#endif /* __WebKitAvailability__ */
diff --git a/engine/inc/PassiveSocket.h b/engine/inc/PassiveSocket.h
new file mode 100644
index 00000000..0dbf069b
--- /dev/null
+++ b/engine/inc/PassiveSocket.h
@@ -0,0 +1,120 @@
+/*---------------------------------------------------------------------------*/
+/*                                                                           */
+/* Socket.h - Passive Socket Decleration.                                    */
+/*                                                                           */
+/* Author : Mark Carrier (mark@carrierlabs.com)                              */
+/*                                                                           */
+/*---------------------------------------------------------------------------*/
+/* Copyright (c) 2007-2009 CarrierLabs, LLC.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * 4. The name "CarrierLabs" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    mark@carrierlabs.com.
+ *
+ * THIS SOFTWARE IS PROVIDED BY MARK CARRIER ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL MARK CARRIER OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ *----------------------------------------------------------------------------*/
+#ifndef __PASSIVESOCKET_H__
+#define __PASSIVESOCKET_H__
+#include "ActiveSocket.h"
+
+/// Provides a platform independent class to create a passive socket.
+/// A passive socket is used to create a "listening" socket.  This type
+/// of object would be used when an application needs to wait for
+/// inbound connections.  Support for CSimpleSocket::SocketTypeTcp,
+/// CSimpleSocket::SocketTypeUdp, and CSimpleSocket::SocketTypeRaw is handled
+/// in a similar fashion.  The big difference is that the method
+/// CPassiveSocket::Accept should not be called on the latter two socket
+/// types.
+class CPassiveSocket : public CSimpleSocket
+{
+public:
+	CPassiveSocket(CSocketType type = SocketTypeTcp);
+	virtual ~CPassiveSocket()
+	{
+		Close();
+	};
+
+	/// Extracts the first connection request on the queue of pending
+	/// connections and creates a newly connected socket.  Used with
+	/// CSocketType CSimpleSocket::SocketTypeTcp.  It is the responsibility of
+	/// the caller to delete the returned object when finished.
+	///  @return if successful a pointer to a newly created CActiveSocket object
+	///          will be returned and the internal error condition of the CPassiveSocket
+	///          object will be CPassiveSocket::SocketSuccess.  If an error condition was encountered
+	///          the NULL will be returned and one of the following error conditions will be set:
+	///    CPassiveSocket::SocketEwouldblock, CPassiveSocket::SocketInvalidSocket,
+	///    CPassiveSocket::SocketConnectionAborted, CPassiveSocket::SocketInterrupted
+	///    CPassiveSocket::SocketProtocolError, CPassiveSocket::SocketFirewallError
+	virtual CActiveSocket *Accept(void);
+
+	/// Bind to a multicast group on  a specified interface, multicast group, and port
+	///
+	///  @param pInterface - interface on which to bind.
+	///  @param pGroup - multicast group address to bind.
+	///  @param nPort - port on which multicast
+	///  @return true if able to bind to interface and multicast group.
+	///      If not successful, the false is returned and one of the following error
+	///      condiitions will be set: CPassiveSocket::SocketAddressInUse, CPassiveSocket::SocketProtocolError,
+	///      CPassiveSocket::SocketInvalidSocket.  The following socket errors are for Linux/Unix
+	///      derived systems only: CPassiveSocket::SocketInvalidSocketBuffer
+	bool BindMulticast(const char *pInterface, const char *pGroup, uint16 nPort);
+
+	/// Create a listening socket at local ip address 'x.x.x.x' or 'localhost'
+	/// if pAddr is NULL on port nPort.
+	///
+	///  @param pAddr specifies the IP address on which to listen.
+	///  @param nPort specifies the port on which to listen.
+	///  @param nConnectionBacklog specifies connection queue backlog (default 30,000)
+	///  @return true if a listening socket was created.
+	///      If not successful, the false is returned and one of the following error
+	///      conditions will be set: CPassiveSocket::SocketAddressInUse, CPassiveSocket::SocketProtocolError,
+	///      CPassiveSocket::SocketInvalidSocket.  The following socket errors are for Linux/Unix
+	///      derived systems only: CPassiveSocket::SocketInvalidSocketBuffer
+	virtual bool Listen(const char *pAddr, uint16 nPort, int32 nConnectionBacklog = 30000);
+
+	/// Attempts to send a block of data on an established connection.
+	/// @param pBuf block of data to be sent.
+	/// @param bytesToSend size of data block to be sent.
+	/// @return number of bytes actually sent, return of zero means the
+	/// connection has been shutdown on the other side, and a return of -1
+	/// means that an error has occurred.  If an error was signaled then one
+	/// of the following error codes will be set: CPassiveSocket::SocketInvalidSocket,
+	/// CPassiveSocket::SocketEwouldblock, SimpleSocket::SocketConnectionReset,
+	/// CPassiveSocket::SocketInvalidSocketBuffer, CPassiveSocket::SocketInterrupted,
+	/// CPassiveSocket::SocketProtocolError, CPassiveSocket::SocketNotconnected
+	/// <br>\b Note: This function is used only for a socket of type
+	/// CSimpleSocket::SocketTypeUdp
+	virtual int32 Send(const uint8 *pBuf, size_t bytesToSend);
+
+private:
+	struct ip_mreq m_stMulticastRequest;  /// group address for multicast
+};
+
+#endif  // __PASSIVESOCKET_H__
diff --git a/engine/inc/SimpleSocket.h b/engine/inc/SimpleSocket.h
new file mode 100644
index 00000000..99cd2e1b
--- /dev/null
+++ b/engine/inc/SimpleSocket.h
@@ -0,0 +1,617 @@
+/*---------------------------------------------------------------------------*/
+/*                                                                           */
+/* SimpleSocket.h - Simple Socket base class decleration.                    */
+/*                                                                           */
+/* Author : Mark Carrier (mark@carrierlabs.com)                              */
+/*                                                                           */
+/*---------------------------------------------------------------------------*/
+/* Copyright (c) 2007-2009 CarrierLabs, LLC.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * 4. The name "CarrierLabs" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    mark@carrierlabs.com.
+ *
+ * THIS SOFTWARE IS PROVIDED BY MARK CARRIER ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL MARK CARRIER OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ *----------------------------------------------------------------------------*/
+#ifndef __SOCKET_H__
+#define __SOCKET_H__
+
+#include <sys/stat.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <errno.h>
+
+#if defined(_LINUX) || defined(_DARWIN) || defined(_BSD)
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netinet/tcp.h>
+#include <netinet/ip.h>
+#include <netdb.h>
+#endif
+#ifdef _LINUX
+#include <linux/if_packet.h>
+#include <linux/if_ether.h>
+#include <linux/if.h>
+#include <sys/sendfile.h>
+#endif
+#ifdef _DARWIN
+#include <net/if.h>
+#endif
+#if defined(_LINUX) || defined(_DARWIN) || defined(_BSD)
+#include <sys/time.h>
+#include <sys/uio.h>
+#include <unistd.h>
+#include <fcntl.h>
+#endif
+
+#ifdef _WIN32
+#include <io.h>
+#include <winsock2.h>
+#include <ws2tcpip.h>
+
+#define IPTOS_LOWDELAY 0x10
+
+#endif
+#include "Host.h"
+#include "StatTimer.h"
+
+//-----------------------------------------------------------------------------
+// General class macro definitions and typedefs
+//-----------------------------------------------------------------------------
+#ifndef INVALID_SOCKET
+#define INVALID_SOCKET ~(0)
+#endif
+
+#define SOCKET_SENDFILE_BLOCKSIZE 8192
+
+/// Provides a platform independent class to for socket development.
+/// This class is designed to abstract socket communication development in a
+/// platform independent manner.
+/// - Socket types
+///  -# CActiveSocket Class
+///  -# CPassiveSocket Class
+class CSimpleSocket
+{
+public:
+	/// Defines the three possible states for shuting down a socket.
+	typedef enum
+	{
+		Receives = SHUT_RD,  ///< Shutdown passive socket.
+		Sends = SHUT_WR,     ///< Shutdown active socket.
+		Both = SHUT_RDWR     ///< Shutdown both active and passive sockets.
+	} CShutdownMode;
+
+	/// Defines the socket types defined by CSimpleSocket class.
+	typedef enum
+	{
+		SocketTypeInvalid,  ///< Invalid socket type.
+		SocketTypeTcp,      ///< Defines socket as TCP socket.
+		SocketTypeUdp,      ///< Defines socket as UDP socket.
+		SocketTypeTcp6,     ///< Defines socket as IPv6 TCP socket.
+		SocketTypeUdp6,     ///< Defines socket as IPv6 UDP socket.
+		SocketTypeRaw       ///< Provides raw network protocol access.
+	} CSocketType;
+
+	/// Defines all error codes handled by the CSimpleSocket class.
+	typedef enum
+	{
+		SocketError = -1,           ///< Generic socket error translates to error below.
+		SocketSuccess = 0,          ///< No socket error.
+		SocketInvalidSocket,        ///< Invalid socket handle.
+		SocketInvalidAddress,       ///< Invalid destination address specified.
+		SocketInvalidPort,          ///< Invalid destination port specified.
+		SocketConnectionRefused,    ///< No server is listening at remote address.
+		SocketTimedout,             ///< Timed out while attempting operation.
+		SocketEwouldblock,          ///< Operation would block if socket were blocking.
+		SocketNotconnected,         ///< Currently not connected.
+		SocketEinprogress,          ///< Socket is non-blocking and the connection cannot be completed immediately
+		SocketInterrupted,          ///< Call was interrupted by a signal that was caught before a valid connection arrived.
+		SocketConnectionAborted,    ///< The connection has been aborted.
+		SocketProtocolError,        ///< Invalid protocol for operation.
+		SocketFirewallError,        ///< Firewall rules forbid connection.
+		SocketInvalidSocketBuffer,  ///< The receive buffer point outside the process's address space.
+		SocketConnectionReset,      ///< Connection was forcibly closed by the remote host.
+		SocketAddressInUse,         ///< Address already in use.
+		SocketInvalidPointer,       ///< Pointer type supplied as argument is invalid.
+		SocketEunknown              ///< Unknown error please report to mark@carrierlabs.com
+	} CSocketError;
+
+public:
+	CSimpleSocket(CSocketType type = SocketTypeTcp);
+	CSimpleSocket(CSimpleSocket &socket);
+
+	virtual ~CSimpleSocket()
+	{
+		if (m_pBuffer != NULL)
+		{
+			delete[] m_pBuffer;
+			m_pBuffer = NULL;
+		}
+	};
+
+	/// Initialize instance of CSocket.  This method MUST be called before an
+	/// object can be used. Errors : CSocket::SocketProtocolError,
+	/// CSocket::SocketInvalidSocket,
+	/// @return true if properly initialized.
+	virtual bool Initialize(void);
+
+	/// Close socket
+	/// @return true if successfully closed otherwise returns false.
+	virtual bool Close(void);
+
+	/// Shutdown shut down socket send and receive operations
+	///    CShutdownMode::Receives - Disables further receive operations.
+	///    CShutdownMode::Sends    - Disables further send operations.
+	///    CShutdownBoth::         - Disables further send and receive operations.
+	/// @param nShutdown specifies the type of shutdown.
+	/// @return true if successfully shutdown otherwise returns false.
+	virtual bool Shutdown(CShutdownMode nShutdown);
+
+	/// Examine the socket descriptor sets currently owned by the instance of
+	/// the socket class (the readfds, writefds, and errorfds parameters) to
+	/// see whether some of their descriptors are ready for reading, are ready
+	/// for writing, or have an exceptional condition pending, respectively.
+	/// Block until an event happens on the specified file descriptors.
+	/// @return true if socket has data ready, or false if not ready or timed out.
+	virtual bool Select(void)
+	{
+		return Select(0, 0);
+	};
+
+	/// Examine the socket descriptor sets currently owned by the instance of
+	/// the socket class (the readfds, writefds, and errorfds parameters) to
+	/// see whether some of their descriptors are ready for reading, are ready
+	/// for writing, or have an exceptional condition pending, respectively.
+	/// @param nTimeoutSec timeout in seconds for select.
+	/// @param nTimeoutUSec timeout in micro seconds for select.
+	/// @return true if socket has data ready, or false if not ready or timed out.
+	virtual bool Select(int32 nTimeoutSec, int32 nTimeoutUSec);
+
+	/// Does the current instance of the socket object contain a valid socket
+	/// descriptor.
+	///  @return true if the socket object contains a valid socket descriptor.
+	virtual bool IsSocketValid(void)
+	{
+		return (m_socket != SocketError);
+	};
+
+	/// Provides a standard error code for cross platform development by
+	/// mapping the operating system error to an error defined by the CSocket
+	/// class.
+	void TranslateSocketError(void);
+
+	/// Returns a human-readable description of the given error code
+	/// or the last error code of a socket
+	static const char *DescribeError(CSocketError err);
+	inline const char *DescribeError()
+	{
+		return DescribeError(m_socketErrno);
+	};
+
+	/// Attempts to receive a block of data on an established connection.
+	/// @param nMaxBytes maximum number of bytes to receive.
+	/// @param pBuffer, memory where to receive the data,
+	///        NULL receives to internal buffer returned with GetData()
+	///        Non-NULL receives directly there, but GetData() will return WRONG ptr!
+	/// @return number of bytes actually received.
+	/// @return of zero means the connection has been shutdown on the other side.
+	/// @return of -1 means that an error has occurred.
+	virtual int32 Receive(int32 nMaxBytes = 1, uint8 *pBuffer = 0);
+
+	/// Attempts to send a block of data on an established connection.
+	/// @param pBuf block of data to be sent.
+	/// @param bytesToSend size of data block to be sent.
+	/// @return number of bytes actually sent.
+	/// @return of zero means the connection has been shutdown on the other side.
+	/// @return of -1 means that an error has occurred.
+	virtual int32 Send(const uint8 *pBuf, size_t bytesToSend);
+
+	/// Attempts to send at most nNumItem blocks described by sendVector
+	/// to the socket descriptor associated with the socket object.
+	/// @param sendVector pointer to an array of iovec structures
+	/// @param nNumItems number of items in the vector to process
+	/// <br>\b NOTE: Buffers are processed in the order specified.
+	/// @return number of bytes actually sent, return of zero means the
+	/// connection has been shutdown on the other side, and a return of -1
+	/// means that an error has occurred.
+	virtual int32 Send(const struct iovec *sendVector, int32 nNumItems);
+
+	/// Copies data between one file descriptor and another.
+	/// On some systems this copying is done within the kernel, and thus is
+	/// more efficient than the combination of CSimpleSocket::Send and
+	/// CSimpleSocket::Receive, which would require transferring data to and
+	/// from user space.
+	/// <br>\b Note: This is available on all implementations, but the kernel
+	/// implementation is only available on Unix type systems.
+	/// @param nOutFd descriptor opened for writing.
+	/// @param nInFd descriptor opened for reading.
+	/// @param pOffset from which to start reading data from input file.
+	/// @param nCount number of bytes to copy between file descriptors.
+	/// @return number of bytes written to the out socket descriptor.
+	virtual int32 SendFile(int32 nOutFd, int32 nInFd, off_t *pOffset, int32 nCount);
+
+	/// Returns blocking/non-blocking state of socket.
+	/// @return true if the socket is non-blocking, else return false.
+	bool IsNonblocking(void)
+	{
+		return (m_bIsBlocking == false);
+	};
+
+	/// Set the socket to blocking.
+	/// @return true if successful set to blocking, else return false;
+	bool SetBlocking(void);
+
+	/// Set the socket as non-blocking.
+	/// @return true if successful set to non-blocking, else return false;
+	bool SetNonblocking(void);
+
+	/// Get a pointer to internal receive buffer.  The user MUST not free this
+	/// pointer when finished.  This memory is managed internally by the CSocket
+	/// class.
+	/// @return pointer to data if valid, else returns NULL.
+	uint8 *GetData(void)
+	{
+		return m_pBuffer;
+	};
+
+	/// Returns the number of bytes received on the last call to
+	/// CSocket::Receive().
+	/// @return number of bytes received.
+	int32 GetBytesReceived(void)
+	{
+		return m_nBytesReceived;
+	};
+
+	/// Returns the number of bytes sent on the last call to
+	/// CSocket::Send().
+	/// @return number of bytes sent.
+	int32 GetBytesSent(void)
+	{
+		return m_nBytesSent;
+	};
+
+	/// Controls the actions taken when CSimpleSocket::Close is executed on a
+	/// socket object that has unsent data.  The default value for this option
+	/// is \b off.
+	/// - Following are the three possible scenarios.
+	///  -# \b bEnable is false, CSimpleSocket::Close returns immediately, but
+	///  any unset data is transmitted (after CSimpleSocket::Close returns)
+	///  -# \b bEnable is true and \b nTime is zero, CSimpleSocket::Close return
+	/// immediately and any unsent data is discarded.
+	///  -# \b bEnable is true and \b nTime is nonzero, CSimpleSocket::Close does
+	///  not return until all unsent data is transmitted (or the connection is
+	///  Closed by the remote system).
+	/// <br><p>
+	/// @param bEnable true to enable option false to disable option.
+	/// @param nTime time in seconds to linger.
+	/// @return true if option successfully set
+	bool SetOptionLinger(bool bEnable, uint16 nTime);
+
+	/// Tells the kernel that even if this port is busy (in the TIME_WAIT state),
+	/// go ahead and reuse it anyway.  If it is busy, but with another state,
+	/// you will still get an address already in use error.
+	/// @return true if option successfully set
+	bool SetOptionReuseAddr();
+
+	/// Gets the timeout value that specifies the maximum number of seconds a
+	/// call to CSimpleSocket::Open waits until it completes.
+	/// @return the length of time in seconds
+	int32 GetConnectTimeoutSec(void)
+	{
+		return m_stConnectTimeout.tv_sec;
+	};
+
+	/// Gets the timeout value that specifies the maximum number of microseconds
+	/// a call to CSimpleSocket::Open waits until it completes.
+	/// @return the length of time in microseconds
+	int32 GetConnectTimeoutUSec(void)
+	{
+		return m_stConnectTimeout.tv_usec;
+	};
+
+	/// Sets the timeout value that specifies the maximum amount of time a call
+	/// to CSimpleSocket::Receive waits until it completes. Use the method
+	/// CSimpleSocket::SetReceiveTimeout to specify the number of seconds to wait.
+	/// If a call to CSimpleSocket::Receive has blocked for the specified length of
+	/// time without receiving additional data, it returns with a partial count
+	/// or CSimpleSocket::GetSocketError set to CSimpleSocket::SocketEwouldblock if no data
+	/// were received.
+	/// @param nConnectTimeoutSec of timeout in seconds.
+	/// @param nConnectTimeoutUsec of timeout in microseconds.
+	/// @return true if socket connection timeout was successfully set.
+	void SetConnectTimeout(int32 nConnectTimeoutSec, int32 nConnectTimeoutUsec = 0)
+	{
+		m_stConnectTimeout.tv_sec = nConnectTimeoutSec;
+		m_stConnectTimeout.tv_usec = nConnectTimeoutUsec;
+	};
+
+	/// Gets the timeout value that specifies the maximum number of seconds a
+	/// a call to CSimpleSocket::Receive waits until it completes.
+	/// @return the length of time in seconds
+	int32 GetReceiveTimeoutSec(void)
+	{
+		return m_stRecvTimeout.tv_sec;
+	};
+
+	/// Gets the timeout value that specifies the maximum number of microseconds
+	/// a call to CSimpleSocket::Receive waits until it completes.
+	/// @return the length of time in microseconds
+	int32 GetReceiveTimeoutUSec(void)
+	{
+		return m_stRecvTimeout.tv_usec;
+	};
+
+	/// Sets the timeout value that specifies the maximum amount of time a call
+	/// to CSimpleSocket::Receive waits until it completes. Use the method
+	/// CSimpleSocket::SetReceiveTimeout to specify the number of seconds to wait.
+	/// If a call to CSimpleSocket::Receive has blocked for the specified length of
+	/// time without receiving additional data, it returns with a partial count
+	/// or CSimpleSocket::GetSocketError set to CSimpleSocket::SocketEwouldblock if no data
+	/// were received.
+	///  @param nRecvTimeoutSec of timeout in seconds.
+	///  @param nRecvTimeoutUsec of timeout in microseconds.
+	///  @return true if socket timeout was successfully set.
+	bool SetReceiveTimeout(int32 nRecvTimeoutSec, int32 nRecvTimeoutUsec = 0);
+
+	/// Enable/disable multicast for a socket.  This options is only valid for
+	/// socket descriptors of type CSimpleSocket::SocketTypeUdp.
+	/// @return true if multicast was enabled or false if socket type is not
+	/// CSimpleSocket::SocketTypeUdp and the error will be set to
+	/// CSimpleSocket::SocketProtocolError
+	bool SetMulticast(bool bEnable, uint8 multicastTTL = 1);
+
+	/// Return true if socket is multicast or false is socket is unicast
+	/// @return true if multicast is enabled
+	bool GetMulticast()
+	{
+		return m_bIsMulticast;
+	};
+
+	/// Bind socket to a specific interface when using multicast.
+	/// @return true if successfully bound to interface
+	bool BindInterface(const char *pInterface);
+
+	/// Gets the timeout value that specifies the maximum number of seconds a
+	/// a call to CSimpleSocket::Send waits until it completes.
+	/// @return the length of time in seconds
+	int32 GetSendTimeoutSec(void)
+	{
+		return m_stSendTimeout.tv_sec;
+	};
+
+	/// Gets the timeout value that specifies the maximum number of microseconds
+	/// a call to CSimpleSocket::Send waits until it completes.
+	/// @return the length of time in microseconds
+	int32 GetSendTimeoutUSec(void)
+	{
+		return m_stSendTimeout.tv_usec;
+	};
+
+	/// Gets the timeout value that specifies the maximum amount of time a call
+	/// to CSimpleSocket::Send waits until it completes.
+	/// @return the length of time in seconds
+	bool SetSendTimeout(int32 nSendTimeoutSec, int32 nSendTimeoutUsec = 0);
+
+	/// Returns the last error that occured for the instace of the CSimpleSocket
+	/// instance.  This method should be called immediately to retrieve the
+	/// error code for the failing mehtod call.
+	///  @return last error that occured.
+	CSocketError GetSocketError(void)
+	{
+		return m_socketErrno;
+	};
+	/*
+     CSocketError GetSocketError(void) {
+     CSocketError err = m_socketErrno;
+     m_socketErrno = SocketSuccess;
+     return err;
+     
+     };
+     */
+
+	/// Get the total time the of the last operation in milliseconds.
+	///  @return number of milliseconds of last operation.
+	uint32 GetTotalTimeMs()
+	{
+		return m_timer.GetMilliSeconds();
+	};
+
+	/// Get the total time the of the last operation in microseconds.
+	///  @return number of microseconds or last operation.
+	uint32 GetTotalTimeUsec()
+	{
+		return m_timer.GetMicroSeconds();
+	};
+
+	/// Return Differentiated Services Code Point (DSCP) value currently set on the socket object.
+	/// @return DSCP for current socket object.
+	/// <br><br> \b NOTE: Windows special notes http://support.microsoft.com/kb/248611.
+	int GetSocketDscp(void);
+
+	/// Set Differentiated Services Code Point (DSCP) for socket object.
+	///  @param nDscp value of TOS setting which will be converted to DSCP
+	///  @return true if DSCP value was properly set
+	/// <br><br> \b NOTE: Windows special notes http://support.microsoft.com/kb/248611.
+	bool SetSocketDscp(int nDscp);
+
+	/// Return socket descriptor
+	///  @return socket descriptor which is a signed 32 bit integer.
+	SOCKET GetSocketDescriptor()
+	{
+		return m_socket;
+	};
+
+	/// Return socket descriptor
+	///  @return socket descriptor which is a signed 32 bit integer.
+	CSocketType GetSocketType()
+	{
+		return m_nSocketType;
+	};
+
+	/// Returns clients Internet host address as a string in standard numbers-and-dots notation.
+	///  @return NULL if invalid
+	const char *GetClientAddr()
+	{
+		return inet_ntoa(m_stClientSockaddr.sin_addr);
+	};
+
+	/// Returns the port number on which the client is connected.
+	///  @return client port number.
+	uint16 GetClientPort()
+	{
+		return m_stClientSockaddr.sin_port;
+	};
+
+	/// Returns server Internet host address as a string in standard numbers-and-dots notation.
+	///  @return NULL if invalid
+	const char *GetServerAddr()
+	{
+		return inet_ntoa(m_stServerSockaddr.sin_addr);
+	};
+
+	/// Returns the port number on which the server is connected.
+	///  @return server port number.
+	uint16 GetServerPort()
+	{
+		return ntohs(m_stServerSockaddr.sin_port);
+	};
+
+	/// Get the TCP receive buffer window size for the current socket object.
+	/// <br><br>\b NOTE: Linux will set the receive buffer to twice the value passed.
+	///  @return zero on failure else the number of bytes of the TCP receive buffer window size if successful.
+	uint32 GetReceiveWindowSize()
+	{
+		return GetWindowSize(SO_RCVBUF);
+	};
+
+	/// Get the TCP send buffer window size for the current socket object.
+	/// <br><br>\b NOTE: Linux will set the send buffer to twice the value passed.
+	///  @return zero on failure else the number of bytes of the TCP receive buffer window size if successful.
+	uint32 GetSendWindowSize()
+	{
+		return GetWindowSize(SO_SNDBUF);
+	};
+
+	/// Set the TCP receive buffer window size for the current socket object.
+	/// <br><br>\b NOTE: Linux will set the receive buffer to twice the value passed.
+	///  @return zero on failure else the number of bytes of the TCP send buffer window size if successful.
+	uint32 SetReceiveWindowSize(uint32 nWindowSize)
+	{
+		return SetWindowSize(SO_RCVBUF, nWindowSize);
+	};
+
+	/// Set the TCP send buffer window size for the current socket object.
+	/// <br><br>\b NOTE: Linux will set the send buffer to twice the value passed.
+	///  @return zero on failure else the number of bytes of the TCP send buffer window size if successful.
+	uint32 SetSendWindowSize(uint32 nWindowSize)
+	{
+		return SetWindowSize(SO_SNDBUF, nWindowSize);
+	};
+
+	/// Disable the Nagle algorithm (Set TCP_NODELAY to true)
+	/// @return false if failed to set socket option otherwise return true;
+	bool DisableNagleAlgoritm();
+
+	/// Enable the Nagle algorithm (Set TCP_NODELAY to false)
+	/// @return false if failed to set socket option otherwise return true;
+	bool EnableNagleAlgoritm();
+
+protected:
+	/// Set internal socket error to that specified error
+	///  @param error type of error
+	void SetSocketError(CSimpleSocket::CSocketError error)
+	{
+		m_socketErrno = error;
+	};
+
+	/// Set object socket handle to that specified as parameter
+	///  @param socket value of socket descriptor
+	void SetSocketHandle(SOCKET socket)
+	{
+		m_socket = socket;
+	};
+
+private:
+	/// Generic function used to get the send/receive window size
+	///  @return zero on failure else the number of bytes of the TCP window size if successful.
+	uint32 GetWindowSize(uint32 nOptionName);
+
+	/// Generic function used to set the send/receive window size
+	///  @return zero on failure else the number of bytes of the TCP window size if successful.
+	uint32 SetWindowSize(uint32 nOptionName, uint32 nWindowSize);
+
+	/// Attempts to send at most nNumItem blocks described by sendVector
+	/// to the socket descriptor associated with the socket object.
+	/// @param sendVector pointer to an array of iovec structures
+	/// @param nNumItems number of items in the vector to process
+	/// <br>\b Note: This implementation is for systems that don't natively
+	/// support this functionality.
+	/// @return number of bytes actually sent, return of zero means the
+	/// connection has been shutdown on the other side, and a return of -1
+	/// means that an error has occurred.
+	int32 Writev(const struct iovec *pVector, size_t nCount);
+
+	/// Flush the socket descriptor owned by the object.
+	/// @return true data was successfully sent, else return false;
+	bool Flush();
+
+	CSimpleSocket *operator=(CSimpleSocket &socket);
+
+protected:
+	SOCKET m_socket;                        /// socket handle
+	CSocketError m_socketErrno;             /// number of last error
+	uint8 *m_pBuffer;                       /// internal send/receive buffer
+	int32 m_nBufferSize;                    /// size of internal send/receive buffer
+	int32 m_nSocketDomain;                  /// socket type PF_INET, PF_INET6
+	CSocketType m_nSocketType;              /// socket type - UDP, TCP or RAW
+	int32 m_nBytesReceived;                 /// number of bytes received
+	int32 m_nBytesSent;                     /// number of bytes sent
+	uint32 m_nFlags;                        /// socket flags
+	bool m_bIsBlocking;                     /// is socket blocking
+	bool m_bIsMulticast;                    /// is the UDP socket multicast;
+	struct timeval m_stConnectTimeout;      /// connection timeout
+	struct timeval m_stRecvTimeout;         /// receive timeout
+	struct timeval m_stSendTimeout;         /// send timeout
+	struct sockaddr_in m_stServerSockaddr;  /// server address
+	struct sockaddr_in m_stClientSockaddr;  /// client address
+	struct sockaddr_in m_stMulticastGroup;  /// multicast group to bind to
+	struct linger m_stLinger;               /// linger flag
+	CStatTimer m_timer;                     /// internal statistics.
+#ifdef WIN32
+	WSADATA m_hWSAData;  /// Windows
+#endif
+	fd_set m_writeFds;  /// write file descriptor set
+	fd_set m_readFds;   /// read file descriptor set
+	fd_set m_errorFds;  /// error file descriptor set
+};
+
+#endif /*  __SOCKET_H__  */
diff --git a/engine/inc/StatTimer.h b/engine/inc/StatTimer.h
new file mode 100644
index 00000000..89d4cfa8
--- /dev/null
+++ b/engine/inc/StatTimer.h
@@ -0,0 +1,110 @@
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/* StatTimer.h: interface for the CStatTimer class.                           */
+/*                                                                            */
+/* Author: Mark Carrier (mark@carrierlabs.com)                                */
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+/* Copyright (c) 2006 CarrierLabs, LLC.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * 4. The name "CarrierLabs" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    mark@carrierlabs.com.
+ *
+ * THIS SOFTWARE IS PROVIDED BY MARK CARRIER ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL MARK CARRIER OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ *----------------------------------------------------------------------------*/
+#ifndef __CSTATTIMER_H__
+#define __CSTATTIMER_H__
+
+#include <string.h>
+
+#ifdef WIN32
+#include <winsock2.h>
+#include <time.h>
+#endif
+
+#ifdef _LINUX
+#include <stdio.h>
+#include <sys/time.h>
+#endif
+
+#include "Host.h"
+
+#if defined(WIN32)
+#define GET_CLOCK_COUNT(x) QueryPerformanceCounter((LARGE_INTEGER *)x)
+#else
+#define GET_CLOCK_COUNT(x) gettimeofday(x, NULL)
+#endif
+
+#define MILLISECONDS_CONVERSION 1000
+#define MICROSECONDS_CONVERSION 1000000
+
+/// Class to abstract socket communications in a cross platform manner.
+/// This class is designed
+class CStatTimer
+{
+public:
+	CStatTimer(){};
+
+	~CStatTimer(){};
+
+	void Initialize()
+	{
+		memset(&m_startTime, 0, sizeof(struct timeval));
+		memset(&m_endTime, 0, sizeof(struct timeval));
+	};
+
+	struct timeval GetStartTime() { return m_startTime; };
+	void SetStartTime() { GET_CLOCK_COUNT(&m_startTime); };
+
+	struct timeval GetEndTime() { return m_endTime; };
+	void SetEndTime() { GET_CLOCK_COUNT(&m_endTime); };
+
+	uint32 GetMilliSeconds() { return (CalcTotalUSec() / MILLISECONDS_CONVERSION); };
+	uint32 GetMicroSeconds() { return (CalcTotalUSec()); };
+	uint32 GetSeconds() { return (CalcTotalUSec() / MICROSECONDS_CONVERSION); };
+
+	uint32 GetCurrentTime()
+	{
+		struct timeval tmpTime;
+		GET_CLOCK_COUNT(&tmpTime);
+		return ((tmpTime.tv_sec * MICROSECONDS_CONVERSION) + tmpTime.tv_usec);
+	};
+
+private:
+	uint32 CalcTotalUSec() { return (((m_endTime.tv_sec - m_startTime.tv_sec) * MICROSECONDS_CONVERSION) +
+									 (m_endTime.tv_usec - m_startTime.tv_usec)); };
+
+private:
+	struct timeval m_startTime;
+	struct timeval m_endTime;
+};
+
+#endif  // __CSTATTIMER_H__
diff --git a/engine/inc/Ultralight/Bitmap.h b/engine/inc/Ultralight/Bitmap.h
new file mode 100644
index 00000000..8be71119
--- /dev/null
+++ b/engine/inc/Ultralight/Bitmap.h
@@ -0,0 +1,279 @@
+///
+/// @file Bitmap.h
+///
+/// @brief The header for the Bitmap class.
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+#include <Ultralight/Defines.h>
+#include <Ultralight/RefPtr.h>
+#include <Ultralight/Geometry.h>
+
+namespace ultralight {
+
+#pragma pack(push, 1)
+
+///
+/// The various Bitmap formats.
+///
+enum UExport BitmapFormat {
+  /**
+   * Alpha channel only, 8-bits per pixel.
+   *
+   * Encoding: 8-bits per channel, unsigned normalized.
+   *
+   * Color-space: Linear (no gamma), alpha-coverage only.
+   */
+  kBitmapFormat_A8_UNORM,
+
+  /**
+   * Blue Green Red Alpha channels, 32-bits per pixel.
+   *
+   * Encoding: 8-bits per channel, unsigned normalized.
+   *
+   * Color-space: sRGB gamma with premultiplied linear alpha channel.
+   *
+   * NOTE: Alpha is premultiplied with BGR channels _before_ sRGB gamma is
+   *       applied so we can use sRGB conversion hardware and perform all
+   *       blending in linear space on GPU.
+   */
+  kBitmapFormat_BGRA8_UNORM_SRGB,
+};
+
+///
+/// Macro to get the bytes per pixel from a BitmapFormat
+///
+#define GetBytesPerPixel(x) (x == kBitmapFormat_A8_UNORM? 1 : 4)
+
+///
+/// @brief  Bitmap container with basic blitting and conversion routines.
+///
+class UExport Bitmap : public RefCounted {
+ public:
+  ///
+  /// Create an empty Bitmap. No pixels will be allocated.
+  ///
+  static Ref<Bitmap> Create();
+
+  ///
+  /// Create a Bitmap with a certain configuration. Pixels will be allocated
+  /// but not initialized.
+  ///
+  /// @param  width   The width in pixels.
+  ///
+  /// @param  height  The height in pixels.
+  ///
+  /// @param  format  The pixel format to use.
+  ///
+  /// @return  A ref-pointer to a new Bitmap instance.
+  ///
+  static Ref<Bitmap> Create(uint32_t width, uint32_t height,
+                            BitmapFormat format);
+
+  ///
+  /// Create a Bitmap with existing pixels and configuration.
+  ///
+  /// @param  width        The width in pixels.
+  ///
+  /// @param  height       The height in pixels.
+  ///
+  /// @param  format       The pixel format to use.
+  ///
+  /// @param  row_bytes    The number of bytes between each row (note that this
+  ///                      value should be >= width * bytes_per_pixel).
+  ///
+  /// @param  pixels       Pointer to raw pixel buffer.
+  ///
+  /// @param  size         Size of the raw pixel buffer.
+  ///
+  /// @param  should_copy  Whether or not a copy should be made of the pixels.
+  ///                      If this is false, the returned Bitmap will use the
+  ///                      raw pixels passed in as its own, but you are still
+  ///                      responsible for destroying your buffer afterwards.
+  ///
+  /// @param  fixup_gamma  Whether or not we should reinterpret the source
+  ///                      as an sRGB bitmap with premultiplied alpha applied
+  ///                      after the gamma function (typical of PNGs). We
+  ///                      expect all premultiplication to be applied before
+  ///                      the gamma function so we can blend properly in
+  ///                      linear space. Only valid for
+  ///                      kBitmapFormat_BGRA8_UNORM_SRGB.
+  ///
+  /// @return  A ref-pointer to a new Bitmap instance.
+  ///
+  static Ref<Bitmap> Create(uint32_t width, uint32_t height,
+                            BitmapFormat format, uint32_t row_bytes,
+                            const void* pixels, size_t size,
+                            bool should_copy = true, bool fixup_gamma = false);
+
+  ///
+  /// Create a bitmap from a deep copy of another Bitmap.
+  ///
+  static Ref<Bitmap> Create(const Bitmap& bitmap);
+
+  ///
+  /// Get the width in pixels.
+  ///
+  virtual uint32_t width() const = 0;
+
+  ///
+  /// Get the height in pixels.
+  ///
+  virtual uint32_t height() const = 0;
+
+  ///
+  /// Get the bounds as an IntRect
+  ///
+  virtual IntRect bounds() const = 0;
+
+  ///
+  /// Get the pixel format.
+  ///
+  virtual BitmapFormat format() const = 0;
+
+  ///
+  /// Get the number of bytes per pixel.
+  ///
+  virtual uint32_t bpp() const = 0;
+
+  ///
+  /// Get the number of bytes between each row of pixels.
+  ///
+  /// @note  This value is usually calculated as width * bytes_per_pixel (bpp) 
+  ///        but it may be larger due to alignment rules in the allocator.
+  ///
+  virtual uint32_t row_bytes() const = 0;
+
+  ///
+  /// Get the size in bytes of the pixel buffer.
+  ///
+  /// @note  Size is calculated as row_bytes() * height().
+  ///
+  virtual size_t size() const = 0;
+
+  ///
+  /// Whether or not this Bitmap owns the pixel buffer and will destroy it
+  /// at the end of its lifetime.
+  ///
+  virtual bool owns_pixels() const = 0;
+
+  ///
+  /// Lock the pixel buffer for reading/writing. 
+  ///
+  /// @return  A pointer to the pixel buffer.
+  ///
+  virtual void* LockPixels() = 0;
+
+  ///
+  /// Unlock the pixel buffer.
+  ///
+  virtual void UnlockPixels() = 0;
+
+  ///
+  /// Lock the pixel buffer for reading/writing. (const)
+  ///
+  /// @return  A const pointer to the pixel buffer.
+  ///
+  virtual const void* LockPixels() const = 0;
+
+  ///
+  /// Unlock the pixel buffer. (const)
+  ///
+  virtual void UnlockPixels() const = 0;
+
+  ///
+  /// Get the raw pixel buffer.
+  ///
+  /// @note  You should only call this if pixels are already locked.
+  ///
+  virtual void* raw_pixels() = 0;
+
+  ///
+  /// Whether or not this Bitmap is empty (no pixels allocated).
+  ///
+  virtual bool IsEmpty() const = 0;
+
+  ///
+  /// Erase the Bitmap (set all pixels to 0).
+  ///
+  virtual void Erase() = 0;
+
+  ///
+  /// Assign another bitmap to this one.
+  ///
+  /// @param  bitmap  The bitmap to copy from.
+  ///
+  virtual void Set(Ref<Bitmap> bitmap) = 0;
+
+  ///
+  /// Draw another bitmap to this bitmap.
+  ///
+  /// @note  Formats do not need to match. Bitmap formats will be converted
+  ///        to one another automatically. Note that when converting from
+  ///        BGRA8 to A8, only the Blue channel will be used.
+  ///
+  /// @param  src_rect    The source rectangle, relative to src bitmap.
+  ///
+  /// @param  dest_rect   The destination rectangle, relative to this bitmap.
+  /// 
+  /// @param  src         The source bitmap.
+  /// 
+  /// @param  pad_repeat  Whether or not we should pad the drawn bitmap by one
+  ///                     pixel of repeated edge pixels from the source bitmap.
+  ///
+  /// @return  Whether or not the operation succeeded (this can fail if the
+  ///          src_rect and/or dest_rect are invalid, or if their total
+  ///          dimensions do not match).
+  ///
+  virtual bool DrawBitmap(IntRect src_rect, IntRect dest_rect,
+    Ref<Bitmap> src, bool pad_repeat) = 0;
+
+  ///
+  /// Write this Bitmap out to a PNG image. (mainly used for Debug)
+  ///
+  /// @param  path  The filepath to write to (opened with fopen())
+  ///
+  /// @return  Whether or not the operation succeeded.
+  ///
+  virtual bool WritePNG(const char* path) = 0;
+
+  ///
+  /// Make a resized copy of this bitmap by writing to a pre-allocated
+  /// destination bitmap.
+  ///
+  /// @param  destination  The bitmap to store the result in, the width and
+  ///                      height of the destination will be used.
+  ///
+  /// @param  high_quality  Whether or not a high quality resampling will be
+  ///                       used during the resize. (Otherwise, just uses fast
+  ///                       nearest-neighbor sampling)
+  ///
+  /// @return  Whether or not the operation succeeded. This operation is only
+  ///          valid if both formats are kBitmapFormat_BGRA8_UNORM_SRGB and
+  ///          both the source and destination are non-empty.
+  ///
+  virtual bool Resample(Ref<Bitmap> destination, bool high_quality) = 0;
+
+  ///
+  /// This converts a BGRA bitmap to RGBA bitmap and vice-versa by swapping
+  /// the red and blue channels.
+  ///
+  virtual void SwapRedBlueChannels() = 0;
+
+protected:
+  Bitmap();
+  virtual ~Bitmap();
+  Bitmap(const Bitmap&);
+  void operator=(const Bitmap&);
+};
+
+#pragma pack(pop)
+
+}  // namespace ultralight
diff --git a/engine/inc/Ultralight/Buffer.h b/engine/inc/Ultralight/Buffer.h
new file mode 100644
index 00000000..68d2de6e
--- /dev/null
+++ b/engine/inc/Ultralight/Buffer.h
@@ -0,0 +1,47 @@
+///
+/// @file Buffer.h
+///
+/// @brief The header for the Buffer class.
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+#include <Ultralight/Defines.h>
+#include <Ultralight/RefPtr.h>
+
+namespace ultralight {
+
+///
+/// A fixed-size byte container for passing data around.
+///
+class UExport Buffer : public RefCounted {
+public:
+  ///
+  /// Create a Buffer, a copy of data is made.
+  ///
+  static Ref<Buffer> Create(const void* data, size_t size);
+
+  ///
+  /// Get a pointer to raw byte data.
+  ///
+  virtual void* data() = 0;
+
+  ///
+  /// Get the size in bytes.
+  ///
+  virtual size_t size() const = 0;
+
+protected:
+  Buffer();
+  virtual ~Buffer();
+  Buffer(const Buffer&);
+  void operator=(const Buffer&);
+};
+
+}  // namespace ultralight
diff --git a/engine/inc/Ultralight/CAPI.h b/engine/inc/Ultralight/CAPI.h
new file mode 100644
index 00000000..ff13bbd9
--- /dev/null
+++ b/engine/inc/Ultralight/CAPI.h
@@ -0,0 +1,1936 @@
+///
+/// @file CAPI.h
+///
+/// @brief The C-language API for Ultralight
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+#ifndef ULTRALIGHT_CAPI_H
+#define ULTRALIGHT_CAPI_H
+
+#ifndef __cplusplus
+//#include <stdbool.h>
+#endif
+
+#include <stddef.h>
+#include <JavaScriptCore/JavaScript.h>
+#ifdef __OBJC__
+#import <AppKit/NSEvent.h>
+#endif
+
+#if defined(__WIN32__) || defined(_WIN32)
+#  if defined(ULTRALIGHT_IMPLEMENTATION)
+#    define ULExport __declspec(dllexport)
+#  else
+#    define ULExport __declspec(dllimport)
+#  endif
+#define _thread_local __declspec(thread)
+#ifndef _NATIVE_WCHAR_T_DEFINED
+#define DISABLE_NATIVE_WCHAR_T
+typedef unsigned short ULChar16;
+#else
+typedef wchar_t ULChar16;
+#endif
+#else
+#  define ULExport __attribute__((visibility("default")))
+#define _thread_local __thread
+typedef unsigned short ULChar16;
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct C_Config* ULConfig;
+typedef struct C_Renderer* ULRenderer;
+typedef struct C_Session* ULSession;
+typedef struct C_View* ULView;
+typedef struct C_Bitmap* ULBitmap;
+typedef struct C_String* ULString;
+typedef struct C_Buffer* ULBuffer;
+typedef struct C_KeyEvent* ULKeyEvent;
+typedef struct C_MouseEvent* ULMouseEvent;
+typedef struct C_ScrollEvent* ULScrollEvent;
+typedef struct C_Surface* ULSurface;
+typedef struct C_Surface* ULBitmapSurface;
+
+typedef enum {
+  kMessageSource_XML = 0,
+  kMessageSource_JS,
+  kMessageSource_Network,
+  kMessageSource_ConsoleAPI,
+  kMessageSource_Storage,
+  kMessageSource_AppCache,
+  kMessageSource_Rendering,
+  kMessageSource_CSS,
+  kMessageSource_Security,
+  kMessageSource_ContentBlocker,
+  kMessageSource_Other,
+} ULMessageSource;
+
+typedef enum {
+  kMessageLevel_Log = 1,
+  kMessageLevel_Warning = 2,
+  kMessageLevel_Error = 3,
+  kMessageLevel_Debug = 4,
+  kMessageLevel_Info = 5,
+} ULMessageLevel;
+
+typedef enum {
+  kCursor_Pointer = 0,
+  kCursor_Cross,
+  kCursor_Hand,
+  kCursor_IBeam,
+  kCursor_Wait,
+  kCursor_Help,
+  kCursor_EastResize,
+  kCursor_NorthResize,
+  kCursor_NorthEastResize,
+  kCursor_NorthWestResize,
+  kCursor_SouthResize,
+  kCursor_SouthEastResize,
+  kCursor_SouthWestResize,
+  kCursor_WestResize,
+  kCursor_NorthSouthResize,
+  kCursor_EastWestResize,
+  kCursor_NorthEastSouthWestResize,
+  kCursor_NorthWestSouthEastResize,
+  kCursor_ColumnResize,
+  kCursor_RowResize,
+  kCursor_MiddlePanning,
+  kCursor_EastPanning,
+  kCursor_NorthPanning,
+  kCursor_NorthEastPanning,
+  kCursor_NorthWestPanning,
+  kCursor_SouthPanning,
+  kCursor_SouthEastPanning,
+  kCursor_SouthWestPanning,
+  kCursor_WestPanning,
+  kCursor_Move,
+  kCursor_VerticalText,
+  kCursor_Cell,
+  kCursor_ContextMenu,
+  kCursor_Alias,
+  kCursor_Progress,
+  kCursor_NoDrop,
+  kCursor_Copy,
+  kCursor_None,
+  kCursor_NotAllowed,
+  kCursor_ZoomIn,
+  kCursor_ZoomOut,
+  kCursor_Grab,
+  kCursor_Grabbing,
+  kCursor_Custom
+} ULCursor;
+
+typedef enum {
+  ///
+  /// Alpha channel only, 8-bits per pixel.
+  ///
+  /// Encoding: 8-bits per channel, unsigned normalized.
+  ///
+  /// Color-space: Linear (no gamma), alpha-coverage only.
+  ///
+  kBitmapFormat_A8_UNORM,
+
+  ///
+  /// Blue Green Red Alpha channels, 32-bits per pixel.
+  /// 
+  /// Encoding: 8-bits per channel, unsigned normalized.
+  ///
+  /// Color-space: sRGB gamma with premultiplied linear alpha channel.
+  ///
+  kBitmapFormat_BGRA8_UNORM_SRGB
+} ULBitmapFormat;
+
+typedef enum {
+  ///
+  /// Key-Down event type. (Does not trigger accelerator commands in WebCore)
+  ///
+  /// @NOTE: You should probably use RawKeyDown instead when a physical key
+  ///        is pressed. This member is only here for historic compatibility
+  ///        with WebCore's key event types.
+  ///
+  kKeyEventType_KeyDown,
+
+  ///
+  /// Key-Up event type. Use this when a physical key is released.
+  ///
+  kKeyEventType_KeyUp,
+
+  ///
+  /// Raw Key-Down type. Use this when a physical key is pressed.
+  ///
+  /// @NOTE: You should use RawKeyDown for physical key presses since it
+  ///        allows WebCore to do additional command translation.
+  ///
+  kKeyEventType_RawKeyDown,
+
+  ///
+  /// Character input event type. Use this when the OS generates text from
+  /// a physical key being pressed (eg, WM_CHAR on Windows).
+  ///
+  kKeyEventType_Char,
+} ULKeyEventType;
+
+typedef enum {
+  kMouseEventType_MouseMoved,
+  kMouseEventType_MouseDown,
+  kMouseEventType_MouseUp,
+} ULMouseEventType;
+
+typedef enum {
+  kMouseButton_None = 0,
+  kMouseButton_Left,
+  kMouseButton_Middle,
+  kMouseButton_Right,
+} ULMouseButton;
+
+typedef enum {
+  kScrollEventType_ScrollByPixel,
+  kScrollEventType_ScrollByPage,
+} ULScrollEventType;
+
+typedef enum {
+  kFaceWinding_Clockwise,
+  kFaceWindow_CounterClockwise,
+} ULFaceWinding;
+
+typedef enum {
+  ///
+  /// Lighter hinting algorithm-- glyphs are slightly fuzzier but better
+  /// resemble their original shape. This is achieved by snapping glyphs to the
+  /// pixel grid only vertically which better preserves inter-glyph spacing.
+  ///
+  kFontHinting_Smooth,
+
+  ///
+  /// Default hinting algorithm-- offers a good balance between sharpness and
+  /// shape at smaller font sizes.
+  ///
+  kFontHinting_Normal,
+
+  ///
+  /// Strongest hinting algorithm-- outputs only black/white glyphs. The result
+  /// is usually unpleasant if the underlying TTF does not contain hints for
+  /// this type of rendering.
+  ///
+  kFontHinting_Monochrome,
+} ULFontHinting;
+
+typedef struct {
+  float left;
+  float top;
+  float right;
+  float bottom;
+} ULRect;
+
+typedef struct {
+  int left;
+  int top;
+  int right;
+  int bottom;
+} ULIntRect;
+
+typedef struct {
+  bool is_empty;
+  unsigned int width;
+  unsigned int height;
+  unsigned int texture_id;
+  unsigned int texture_width;
+  unsigned int texture_height;
+  ULBitmapFormat texture_format;
+  ULRect uv_coords;
+  unsigned int render_buffer_id;
+} ULRenderTarget;
+
+
+/******************************************************************************
+ * API Note:
+ *
+ * You should only destroy objects that you explicitly create. Do not destroy
+ * any objects returned from the API or callbacks unless otherwise noted.
+ *****************************************************************************/
+
+/******************************************************************************
+ * Version
+ *****************************************************************************/
+
+///
+/// Get the version string of the library in MAJOR.MINOR.PATCH format.
+///
+ULExport const char* ulVersionString();
+
+///
+/// Get the numeric major version of the library.
+///
+ULExport unsigned int ulVersionMajor();
+
+///
+/// Get the numeric minor version of the library.
+///
+ULExport unsigned int ulVersionMinor();
+
+///
+/// Get the numeric patch version of the library.
+///
+ULExport unsigned int ulVersionPatch();
+
+/******************************************************************************
+ * Config
+ *****************************************************************************/
+
+///
+/// Create config with default values (see <Ultralight/platform/Config.h>).
+///
+ULExport ULConfig ulCreateConfig();
+
+///
+/// Destroy config.
+///
+ULExport void ulDestroyConfig(ULConfig config);
+
+///
+/// Set the file path to the directory that contains Ultralight's bundled
+/// resources (eg, cacert.pem and other localized resources). 
+///
+ULExport void ulConfigSetResourcePath(ULConfig config, ULString resource_path);
+
+///
+/// Set the file path to a writable directory that will be used to store
+/// cookies, cached resources, and other persistent data.
+///
+ULExport void ulConfigSetCachePath(ULConfig config, ULString cache_path);
+
+///
+/// When enabled, each View will be rendered to an offscreen GPU texture
+/// using the GPU driver set in ulPlatformSetGPUDriver. You can fetch
+/// details for the texture via ulViewGetRenderTarget.
+///
+/// When disabled (the default), each View will be rendered to an offscreen
+/// pixel buffer. This pixel buffer can optionally be provided by the user--
+/// for more info see ulViewGetSurface.
+///
+ULExport void ulConfigSetUseGPURenderer(ULConfig config, bool use_gpu);
+
+///
+/// Set the amount that the application DPI has been scaled, used for
+/// scaling device coordinates to pixels and oversampling raster shapes
+/// (Default = 1.0).
+///
+ULExport void ulConfigSetDeviceScale(ULConfig config, double value);
+
+///
+/// The winding order for front-facing triangles. @see FaceWinding
+///
+/// Note: This is only used with custom GPUDrivers
+///
+ULExport void ulConfigSetFaceWinding(ULConfig config, ULFaceWinding winding);
+
+///
+/// Set whether images should be enabled (Default = True).
+///
+ULExport void ulConfigSetEnableImages(ULConfig config, bool enabled);
+
+///
+/// Set whether JavaScript should be eanbled (Default = True).
+///
+ULExport void ulConfigSetEnableJavaScript(ULConfig config, bool enabled);
+
+///
+/// The hinting algorithm to use when rendering fonts. (Default = kFontHinting_Normal)
+/// @see ULFontHinting
+///
+ULExport void ulConfigSetFontHinting(ULConfig config, ULFontHinting font_hinting);
+
+///
+/// The gamma to use when compositing font glyphs, change this value to
+/// adjust contrast (Adobe and Apple prefer 1.8, others may prefer 2.2).
+/// (Default = 1.8)
+///
+ULExport void ulConfigSetFontGamma(ULConfig config, double font_gamma);
+
+///
+/// Set default font-family to use (Default = Times New Roman).
+///
+ULExport void ulConfigSetFontFamilyStandard(ULConfig config,
+                                            ULString font_name);
+
+///
+/// Set default font-family to use for fixed fonts, eg <pre> and <code>
+/// (Default = Courier New).
+///
+ULExport void ulConfigSetFontFamilyFixed(ULConfig config, ULString font_name);
+
+///
+/// Set default font-family to use for serif fonts (Default = Times New Roman).
+///
+ULExport void ulConfigSetFontFamilySerif(ULConfig config, ULString font_name);
+
+///
+/// Set default font-family to use for sans-serif fonts (Default = Arial).
+///
+ULExport void ulConfigSetFontFamilySansSerif(ULConfig config,
+                                             ULString font_name);
+
+///
+/// Set user agent string (See <Ultralight/platform/Config.h> for the default).
+///
+ULExport void ulConfigSetUserAgent(ULConfig config, ULString agent_string);
+
+///
+/// Set user stylesheet (CSS) (Default = Empty).
+///
+ULExport void ulConfigSetUserStylesheet(ULConfig config, ULString css_string);
+
+///
+/// Set whether or not we should continuously repaint any Views or compositor
+/// layers, regardless if they are dirty or not. This is mainly used to
+/// diagnose painting/shader issues. (Default = False)
+///
+ULExport void ulConfigSetForceRepaint(ULConfig config, bool enabled);
+
+///
+/// Set the amount of time to wait before triggering another repaint when a
+/// CSS animation is active. (Default = 1.0 / 60.0)
+///
+ULExport void ulConfigSetAnimationTimerDelay(ULConfig config, double delay);
+
+///
+/// When a smooth scroll animation is active, the amount of time (in seconds)
+/// to wait before triggering another repaint. Default is 60 Hz.
+///
+ULExport void ulConfigSetScrollTimerDelay(ULConfig config, double delay);
+
+///
+/// The amount of time (in seconds) to wait before running the recycler (will
+/// attempt to return excess memory back to the system). (Default = 4.0)
+///
+ULExport void ulConfigSetRecycleDelay(ULConfig config, double delay);
+
+///
+/// Set the size of WebCore's memory cache for decoded images, scripts, and
+/// other assets in bytes. (Default = 64 * 1024 * 1024)
+///
+ULExport void ulConfigSetMemoryCacheSize(ULConfig config, unsigned int size);
+
+///
+/// Set the number of pages to keep in the cache. (Default = 0)
+///
+ULExport void ulConfigSetPageCacheSize(ULConfig config, unsigned int size);
+
+///
+/// JavaScriptCore tries to detect the system's physical RAM size to set
+/// reasonable allocation limits. Set this to anything other than 0 to
+/// override the detected value. Size is in bytes.
+///
+/// This can be used to force JavaScriptCore to be more conservative with
+/// its allocation strategy (at the cost of some performance).
+///
+ULExport void ulConfigSetOverrideRAMSize(ULConfig config, unsigned int size);
+
+///
+/// The minimum size of large VM heaps in JavaScriptCore. Set this to a
+/// lower value to make these heaps start with a smaller initial value.
+///
+ULExport void ulConfigSetMinLargeHeapSize(ULConfig config, unsigned int size);
+
+///
+/// The minimum size of small VM heaps in JavaScriptCore. Set this to a
+/// lower value to make these heaps start with a smaller initial value.
+///
+ULExport void ulConfigSetMinSmallHeapSize(ULConfig config, unsigned int size);
+
+/******************************************************************************
+ * Renderer
+ *****************************************************************************/
+
+///
+/// Create the Ultralight Renderer directly.
+///
+/// Unlike ulCreateApp(), this does not use any native windows for drawing
+/// and allows you to manage your own runloop and painting. This method is
+/// recommended for those wishing to integrate the library into a game.
+///
+/// This singleton manages the lifetime of all Views and coordinates all
+/// painting, rendering, network requests, and event dispatch.
+///
+/// You should only call this once per process lifetime.
+///
+/// You shoud set up your platform handlers (eg, ulPlatformSetLogger,
+/// ulPlatformSetFileSystem, etc.) before calling this.
+///
+/// You will also need to define a font loader before calling this-- 
+/// as of this writing (v1.2) the only way to do this in C API is by calling
+/// ulEnablePlatformFontLoader() (available in <AppCore/CAPI.h>).
+///
+/// @NOTE:  You should not call this if you are using ulCreateApp(), it
+///         creates its own renderer and provides default implementations for
+///         various platform handlers automatically.
+///
+ULExport ULRenderer ulCreateRenderer(ULConfig config);
+
+///
+/// Destroy the renderer.
+///
+ULExport void ulDestroyRenderer(ULRenderer renderer);
+
+///
+/// Update timers and dispatch internal callbacks (JavaScript and network).
+///
+ULExport void ulUpdate(ULRenderer renderer);
+
+///
+/// Render all active Views.
+///
+ULExport void ulRender(ULRenderer renderer);
+
+///
+/// Attempt to release as much memory as possible. Don't call this from any
+/// callbacks or driver code.
+///
+ULExport void ulPurgeMemory(ULRenderer renderer);
+
+///
+/// Print detailed memory usage statistics to the log.
+/// (@see ulPlatformSetLogger)
+///
+ULExport void ulLogMemoryUsage(ULRenderer renderer);
+
+/******************************************************************************
+ * Session
+ *****************************************************************************/
+
+///
+/// Create a Session to store local data in (such as cookies, local storage,
+/// application cache, indexed db, etc).
+///
+ULExport ULSession ulCreateSession(ULRenderer renderer, bool is_persistent,
+                                   ULString name);
+
+///
+/// Destroy a Session.
+///
+ULExport void ulDestroySession(ULSession session);
+
+///
+/// Get the default session (persistent session named "default").
+///
+/// @note  This session is owned by the Renderer, you shouldn't destroy it.
+///
+ULExport ULSession ulDefaultSession(ULRenderer renderer);
+
+///
+/// Whether or not is persistent (backed to disk).
+///
+ULExport bool ulSessionIsPersistent(ULSession session);
+
+///
+/// Unique name identifying the session (used for unique disk path).
+///
+ULExport ULString ulSessionGetName(ULSession session);
+
+///
+/// Unique numeric Id for the session.
+///
+ULExport unsigned long long ulSessionGetId(ULSession session);
+
+///
+/// The disk path to write to (used by persistent sessions only).
+///
+ULExport ULString ulSessionGetDiskPath(ULSession session);
+
+/******************************************************************************
+ * View
+ *****************************************************************************/
+
+///
+/// Create a View with certain size (in pixels).
+///
+/// @note  You can pass null to 'session' to use the default session.
+///
+ULExport ULView ulCreateView(ULRenderer renderer, unsigned int width,
+                             unsigned int height, bool transparent,
+                             ULSession session, bool force_cpu_renderer);
+
+///
+/// Destroy a View.
+///
+ULExport void ulDestroyView(ULView view);
+
+///
+/// Get current URL.
+///
+/// @note Don't destroy the returned string, it is owned by the View.
+///
+ULExport ULString ulViewGetURL(ULView view);
+
+///
+/// Get current title.
+///
+/// @note Don't destroy the returned string, it is owned by the View.
+///
+ULExport ULString ulViewGetTitle(ULView view);
+
+///
+/// Get the width, in pixels.
+///
+ULExport unsigned int ulViewGetWidth(ULView view);
+
+///
+/// Get the height, in pixels.
+///
+ULExport unsigned int ulViewGetHeight(ULView view);
+
+///
+/// Check if main frame is loading.
+///
+ULExport bool ulViewIsLoading(ULView view);
+
+///
+/// Get the RenderTarget for the View.
+///
+/// @note  Only valid when the GPU renderer is enabled in Config.
+///
+ULExport ULRenderTarget ulViewGetRenderTarget(ULView view);
+
+///
+/// Get the Surface for the View (native pixel buffer container).
+///
+/// @note  Only valid when the GPU renderer is disabled in Config.
+///
+///        (Will return a nullptr when the GPU renderer is enabled.)
+///
+///        The default Surface is BitmapSurface but you can provide your
+///        own Surface implementation via ulPlatformSetSurfaceDefinition.
+///
+///        When using the default Surface, you can retrieve the underlying
+///        bitmap by casting ULSurface to ULBitmapSurface and calling
+///        ulBitmapSurfaceGetBitmap().
+///
+ULExport ULSurface ulViewGetSurface(ULView view);
+
+///
+/// Load a raw string of HTML.
+///
+ULExport void ulViewLoadHTML(ULView view, ULString html_string);
+
+///
+/// Load a URL into main frame.
+///
+ULExport void ulViewLoadURL(ULView view, ULString url_string);
+
+///
+/// Resize view to a certain width and height (in pixels).
+///
+ULExport void ulViewResize(ULView view, unsigned int width,
+                           unsigned int height);
+
+///
+/// Acquire the page's JSContext for use with JavaScriptCore API.
+/// 
+/// @note  This call locks the context for the current thread. You should
+///        call ulViewUnlockJSContext() after using the context so other
+///        worker threads can modify JavaScript state.
+///
+/// @note  The lock is recusive, it's okay to call this multiple times as long
+///        as you call ulViewUnlockJSContext() the same number of times.
+///
+ULExport JSContextRef ulViewLockJSContext(ULView view);
+
+///
+/// Unlock the page's JSContext after a previous call to ulViewLockJSContext().
+///
+ULExport void ulViewUnlockJSContext(ULView view);
+
+///
+/// Evaluate a string of JavaScript and return result.
+///
+/// @param  js_string  The string of JavaScript to evaluate.
+///
+/// @param  exception  The address of a ULString to store a description of the
+///                    last exception. Pass NULL to ignore this. Don't destroy
+///                    the exception string returned, it's owned by the View.
+///
+/// @note Don't destroy the returned string, it's owned by the View. This value
+///       is reset with every call-- if you want to retain it you should copy
+///       the result to a new string via ulCreateStringFromCopy().
+///
+/// @note An example of using this API:
+///       <pre>
+///         ULString script = ulCreateString("1 + 1");
+///         ULString exception;
+///         ULString result = ulViewEvaluateScript(view, script, &exception);
+///         /* Use the result ("2") and exception description (if any) here. */
+///         ulDestroyString(script);
+///       </pre>
+///
+ULExport ULString ulViewEvaluateScript(ULView view, ULString js_string, ULString* exception);
+
+///
+/// Check if can navigate backwards in history.
+///
+ULExport bool ulViewCanGoBack(ULView view);
+
+///
+/// Check if can navigate forwards in history.
+///
+ULExport bool ulViewCanGoForward(ULView view);
+
+///
+/// Navigate backwards in history.
+///
+ULExport void ulViewGoBack(ULView view);
+
+///
+/// Navigate forwards in history.
+///
+ULExport void ulViewGoForward(ULView view);
+
+///
+/// Navigate to arbitrary offset in history.
+///
+ULExport void ulViewGoToHistoryOffset(ULView view, int offset);
+
+///
+/// Reload current page.
+///
+ULExport void ulViewReload(ULView view);
+
+///
+/// Stop all page loads.
+///
+ULExport void ulViewStop(ULView view);
+
+///
+/// Give focus to the View.
+///
+/// You should call this to give visual indication that the View has input
+/// focus (changes active text selection colors, for example).
+///
+ULExport void ulViewFocus(ULView view);
+
+///
+/// Remove focus from the View and unfocus any focused input elements.
+///
+/// You should call this to give visual indication that the View has lost
+/// input focus.
+///
+ULExport void ulViewUnfocus(ULView view);
+
+///
+/// Whether or not the View has focus.
+///
+ULExport bool ulViewHasFocus(ULView view);
+
+///
+/// Whether or not the View has an input element with visible keyboard focus
+/// (indicated by a blinking caret).
+///
+/// You can use this to decide whether or not the View should consume
+/// keyboard input events (useful in games with mixed UI and key handling).
+///
+ULExport bool ulViewHasInputFocus(ULView view);
+
+///
+/// Fire a keyboard event.
+///
+ULExport void ulViewFireKeyEvent(ULView view, ULKeyEvent key_event);
+
+///
+/// Fire a mouse event.
+///
+ULExport void ulViewFireMouseEvent(ULView view, ULMouseEvent mouse_event);
+
+///
+/// Fire a scroll event.
+///
+ULExport void ulViewFireScrollEvent(ULView view, ULScrollEvent scroll_event);
+
+typedef void
+(*ULChangeTitleCallback) (void* user_data, ULView caller, ULString title);
+
+///
+/// Set callback for when the page title changes.
+///
+ULExport void ulViewSetChangeTitleCallback(ULView view,
+                                           ULChangeTitleCallback callback,
+                                           void* user_data);
+
+typedef void
+(*ULChangeURLCallback) (void* user_data, ULView caller, ULString url);
+
+///
+/// Set callback for when the page URL changes.
+///
+ULExport void ulViewSetChangeURLCallback(ULView view,
+                                         ULChangeURLCallback callback,
+                                         void* user_data);
+
+typedef void
+(*ULChangeTooltipCallback) (void* user_data, ULView caller, ULString tooltip);
+
+///
+/// Set callback for when the tooltip changes (usually result of a mouse hover).
+///
+ULExport void ulViewSetChangeTooltipCallback(ULView view,
+                                             ULChangeTooltipCallback callback,
+                                             void* user_data);
+
+typedef void
+(*ULChangeCursorCallback) (void* user_data, ULView caller, ULCursor cursor);
+
+///
+/// Set callback for when the mouse cursor changes.
+///
+ULExport void ulViewSetChangeCursorCallback(ULView view,
+                                            ULChangeCursorCallback callback,
+                                            void* user_data);
+
+typedef void
+(*ULAddConsoleMessageCallback) (void* user_data, ULView caller,
+                                ULMessageSource source, ULMessageLevel level,
+                                ULString message, unsigned int line_number,
+                                unsigned int column_number,
+                                ULString source_id);
+
+///
+/// Set callback for when a message is added to the console (useful for
+/// JavaScript / network errors and debugging).
+///
+ULExport void ulViewSetAddConsoleMessageCallback(ULView view,
+                                          ULAddConsoleMessageCallback callback,
+                                          void* user_data);
+
+typedef ULView
+(*ULCreateChildViewCallback) (void* user_data, ULView caller,
+  ULString opener_url, ULString target_url, bool is_popup,
+  ULIntRect popup_rect);
+
+///
+/// Set callback for when the page wants to create a new View.
+///
+/// This is usually the result of a user clicking a link with target="_blank"
+/// or by JavaScript calling window.open(url).
+///
+/// To allow creation of these new Views, you should create a new View in
+/// this callback, resize it to your container,
+/// and return it. You are responsible for displaying the returned View.
+///
+/// You should return NULL if you want to block the action.
+///
+ULExport void ulViewSetCreateChildViewCallback(ULView view,
+                                            ULCreateChildViewCallback callback,
+                                            void* user_data);
+
+typedef void
+(*ULBeginLoadingCallback) (void* user_data, ULView caller,
+  unsigned long long frame_id, bool is_main_frame, ULString url);
+
+///
+/// Set callback for when the page begins loading a new URL into a frame.
+///
+ULExport void ulViewSetBeginLoadingCallback(ULView view,
+                                            ULBeginLoadingCallback callback,
+                                            void* user_data);
+
+typedef void
+(*ULFinishLoadingCallback) (void* user_data, ULView caller,
+  unsigned long long frame_id, bool is_main_frame, ULString url);
+
+///
+/// Set callback for when the page finishes loading a URL into a frame.
+///
+ULExport void ulViewSetFinishLoadingCallback(ULView view,
+                                             ULFinishLoadingCallback callback,
+                                             void* user_data);
+
+typedef void
+(*ULFailLoadingCallback) (void* user_data, ULView caller,
+  unsigned long long frame_id, bool is_main_frame, ULString url,
+  ULString description, ULString error_domain, int error_code);
+
+///
+/// Set callback for when an error occurs while loading a URL into a frame.
+///
+ULExport void ulViewSetFailLoadingCallback(ULView view,
+                                           ULFailLoadingCallback callback,
+                                           void* user_data);
+
+typedef void
+(*ULWindowObjectReadyCallback) (void* user_data, ULView caller,
+  unsigned long long frame_id, bool is_main_frame, ULString url);
+
+///
+/// Set callback for when the JavaScript window object is reset for a new
+/// page load.
+///
+/// This is called before any scripts are executed on the page and is the
+/// earliest time to setup any initial JavaScript state or bindings.
+///
+/// The document is not guaranteed to be loaded/parsed at this point. If
+/// you need to make any JavaScript calls that are dependent on DOM elements
+/// or scripts on the page, use DOMReady instead.
+///
+/// The window object is lazily initialized (this will not be called on pages
+/// with no scripts).
+///
+ULExport void ulViewSetWindowObjectReadyCallback(ULView view,
+                                          ULWindowObjectReadyCallback callback,
+                                          void* user_data);
+
+typedef void
+(*ULDOMReadyCallback) (void* user_data, ULView caller,
+  unsigned long long frame_id, bool is_main_frame, ULString url);
+
+///
+/// Set callback for when all JavaScript has been parsed and the document is
+/// ready.
+///
+/// This is the best time to make any JavaScript calls that are dependent on
+/// DOM elements or scripts on the page.
+///
+ULExport void ulViewSetDOMReadyCallback(ULView view,
+                                        ULDOMReadyCallback callback,
+                                        void* user_data);
+
+typedef void
+(*ULUpdateHistoryCallback) (void* user_data, ULView caller);
+
+///
+/// Set callback for when the history (back/forward state) is modified.
+///
+ULExport void ulViewSetUpdateHistoryCallback(ULView view,
+                                             ULUpdateHistoryCallback callback,
+                                             void* user_data);
+
+///
+/// Set whether or not a view should be repainted during the next call to
+/// ulRender.
+///
+/// @note  This flag is automatically set whenever the page content changes
+///        but you can set it directly in case you need to force a repaint.
+///
+ULExport void ulViewSetNeedsPaint(ULView view, bool needs_paint);
+
+///
+/// Whether or not a view should be painted during the next call to ulRender.
+///
+ULExport bool ulViewGetNeedsPaint(ULView view);
+
+///
+/// Create an inspector for this View, this is useful for debugging and
+/// inspecting pages locally. This will only succeed if you have the
+/// inspector assets in your filesystem-- the inspector will look for
+/// file:///inspector/Main.html when it loads.
+///
+/// @note  The initial dimensions of the returned View are 10x10, you should
+///        call ulViewResize on the returned View to resize it to your desired
+///        dimensions.
+///
+/// @note  You will need to call ulDestroyView on the returned instance
+///        when you're done using it.
+///
+ULExport ULView ulViewCreateInspectorView(ULView view);
+
+/******************************************************************************
+ * String
+ *****************************************************************************/
+
+///
+/// Create string from null-terminated ASCII C-string.
+///
+ULExport ULString ulCreateString(const char* str);
+
+///
+/// Create string from UTF-8 buffer.
+///
+ULExport ULString ulCreateStringUTF8(const char* str, size_t len);
+
+///
+/// Create string from UTF-16 buffer.
+///
+ULExport ULString ulCreateStringUTF16(ULChar16* str, size_t len);
+
+///
+/// Create string from copy of existing string.
+///
+ULExport ULString ulCreateStringFromCopy(ULString str);
+
+///
+/// Destroy string (you should destroy any strings you explicitly Create).
+///
+ULExport void ulDestroyString(ULString str);
+
+///
+/// Get internal UTF-16 buffer data.
+///
+ULExport ULChar16* ulStringGetData(ULString str);
+
+///
+/// Get length in UTF-16 characters.
+///
+ULExport size_t ulStringGetLength(ULString str);
+
+///
+/// Whether this string is empty or not.
+///
+ULExport bool ulStringIsEmpty(ULString str);
+
+///
+/// Replaces the contents of 'str' with the contents of 'new_str'
+///
+ULExport void ulStringAssignString(ULString str, ULString new_str);
+
+///
+/// Replaces the contents of 'str' with the contents of a C-string.
+///
+ULExport void ulStringAssignCString(ULString str, const char* c_str);
+
+/******************************************************************************
+ * Bitmap
+ *****************************************************************************/
+
+///
+/// Create empty bitmap.
+///
+ULExport ULBitmap ulCreateEmptyBitmap();
+
+///
+/// Create bitmap with certain dimensions and pixel format.
+///
+ULExport ULBitmap ulCreateBitmap(unsigned int width, unsigned int height,
+                                 ULBitmapFormat format);
+
+///
+/// Create bitmap from existing pixel buffer. @see Bitmap for help using
+/// this function.
+///
+ULExport ULBitmap ulCreateBitmapFromPixels(unsigned int width,
+                                           unsigned int height,
+                                           ULBitmapFormat format, 
+                                           unsigned int row_bytes,
+                                           const void* pixels, size_t size,
+                                           bool should_copy);
+
+///
+/// Create bitmap from copy.
+///
+ULExport ULBitmap ulCreateBitmapFromCopy(ULBitmap existing_bitmap);
+
+///
+/// Destroy a bitmap (you should only destroy Bitmaps you have explicitly
+/// created via one of the creation functions above.
+///
+ULExport void ulDestroyBitmap(ULBitmap bitmap);
+
+///
+/// Get the width in pixels.
+///
+ULExport unsigned int ulBitmapGetWidth(ULBitmap bitmap);
+
+///
+/// Get the height in pixels.
+///
+ULExport unsigned int ulBitmapGetHeight(ULBitmap bitmap);
+
+///
+/// Get the pixel format.
+///
+ULExport ULBitmapFormat ulBitmapGetFormat(ULBitmap bitmap);
+
+///
+/// Get the bytes per pixel.
+///
+ULExport unsigned int ulBitmapGetBpp(ULBitmap bitmap);
+
+///
+/// Get the number of bytes per row.
+///
+ULExport unsigned int ulBitmapGetRowBytes(ULBitmap bitmap);
+
+///
+/// Get the size in bytes of the underlying pixel buffer.
+///
+ULExport size_t ulBitmapGetSize(ULBitmap bitmap);
+
+///
+/// Whether or not this bitmap owns its own pixel buffer.
+///
+ULExport bool ulBitmapOwnsPixels(ULBitmap bitmap);
+
+///
+/// Lock pixels for reading/writing, returns pointer to pixel buffer.
+///
+ULExport void* ulBitmapLockPixels(ULBitmap bitmap);
+
+///
+/// Unlock pixels after locking.
+///
+ULExport void ulBitmapUnlockPixels(ULBitmap bitmap);
+
+///
+/// Get raw pixel buffer-- you should only call this if Bitmap is already
+/// locked.
+///
+ULExport void* ulBitmapRawPixels(ULBitmap bitmap);
+
+///
+/// Whether or not this bitmap is empty.
+///
+ULExport bool ulBitmapIsEmpty(ULBitmap bitmap);
+
+///
+/// Reset bitmap pixels to 0.
+///
+ULExport void ulBitmapErase(ULBitmap bitmap);
+
+///
+/// Write bitmap to a PNG on disk.
+///
+ULExport bool ulBitmapWritePNG(ULBitmap bitmap, const char* path);
+
+///
+/// This converts a BGRA bitmap to RGBA bitmap and vice-versa by swapping
+/// the red and blue channels.
+///
+ULExport void ulBitmapSwapRedBlueChannels(ULBitmap bitmap);
+
+/******************************************************************************
+* Key Event
+******************************************************************************/
+
+///
+/// Create a key event, @see KeyEvent for help with the following parameters.
+///
+ULExport ULKeyEvent ulCreateKeyEvent(ULKeyEventType type,
+                                     unsigned int modifiers,
+                                     int virtual_key_code, int native_key_code,
+                                     ULString text, ULString unmodified_text,
+                                     bool is_keypad, bool is_auto_repeat,
+                                     bool is_system_key);
+
+#ifdef _WIN32
+///
+/// Create a key event from native Windows event.
+///
+ULExport ULKeyEvent ulCreateKeyEventWindows(ULKeyEventType type,
+                                            uintptr_t wparam, intptr_t lparam,
+                                            bool is_system_key);
+#endif
+
+#ifdef __OBJC__
+///
+/// Create a key event from native macOS event.
+///
+ULExport ULKeyEvent ulCreateKeyEventMacOS(NSEvent* evt);
+#endif
+
+///
+/// Destroy a key event.
+///
+ULExport void ulDestroyKeyEvent(ULKeyEvent evt);
+
+/******************************************************************************
+ * Mouse Event
+ *****************************************************************************/
+
+///
+/// Create a mouse event, @see MouseEvent for help using this function.
+///
+ULExport ULMouseEvent ulCreateMouseEvent(ULMouseEventType type, int x, int y,
+                                         ULMouseButton button);
+
+///
+/// Destroy a mouse event.
+///
+ULExport void ulDestroyMouseEvent(ULMouseEvent evt);
+
+/******************************************************************************
+ * Scroll Event
+ *****************************************************************************/
+
+///
+/// Create a scroll event, @see ScrollEvent for help using this function.
+///
+ULExport ULScrollEvent ulCreateScrollEvent(ULScrollEventType type, int delta_x,
+                                           int delta_y);
+
+///
+/// Destroy a scroll event.
+///
+ULExport void ulDestroyScrollEvent(ULScrollEvent evt);
+
+/******************************************************************************
+ * Rect
+ *****************************************************************************/
+
+///
+/// Whether or not a ULRect is empty (all members equal to 0)
+///
+ULExport bool ulRectIsEmpty(ULRect rect);
+
+///
+/// Create an empty ULRect (all members equal to 0)
+///
+ULExport ULRect ulRectMakeEmpty();
+
+/******************************************************************************
+ * IntRect
+ *****************************************************************************/
+
+ ///
+ /// Whether or not a ULIntRect is empty (all members equal to 0)
+ ///
+ULExport bool ulIntRectIsEmpty(ULIntRect rect);
+
+///
+/// Create an empty ULIntRect (all members equal to 0)
+///
+ULExport ULIntRect ulIntRectMakeEmpty();
+
+/******************************************************************************
+ * Surface
+ *****************************************************************************/
+
+///
+/// Width (in pixels).
+///
+ULExport unsigned int ulSurfaceGetWidth(ULSurface surface);
+
+///
+/// Height (in pixels).
+///
+ULExport unsigned int ulSurfaceGetHeight(ULSurface surface);
+
+///
+/// Number of bytes between rows (usually width * 4)
+///
+ULExport unsigned int ulSurfaceGetRowBytes(ULSurface surface);
+
+///
+/// Size in bytes.
+///
+ULExport size_t ulSurfaceGetSize(ULSurface surface);
+
+///
+/// Lock the pixel buffer and get a pointer to the beginning of the data
+/// for reading/writing.
+///
+/// Native pixel format is premultiplied BGRA 32-bit (8 bits per channel).
+///
+ULExport void* ulSurfaceLockPixels(ULSurface surface);
+
+///
+/// Unlock the pixel buffer.
+///
+ULExport void ulSurfaceUnlockPixels(ULSurface surface);
+
+///
+/// Resize the pixel buffer to a certain width and height (both in pixels).
+///
+/// This should never be called while pixels are locked. 
+///
+ULExport void ulSurfaceResize(ULSurface surface, unsigned int width, unsigned int height);
+
+///
+/// Set the dirty bounds to a certain value.
+///
+/// This is called after the Renderer paints to an area of the pixel buffer.
+/// (The new value will be joined with the existing dirty_bounds())
+///
+ULExport void ulSurfaceSetDirtyBounds(ULSurface surface, ULIntRect bounds);
+
+///
+/// Get the dirty bounds.
+///
+/// This value can be used to determine which portion of the pixel buffer has
+/// been updated since the last call to ulSurfaceClearDirtyBounds().
+///
+/// The general algorithm to determine if a Surface needs display is:
+/// <pre>
+///   if (!ulIntRectIsEmpty(ulSurfaceGetDirtyBounds(surface))) {
+///       // Surface pixels are dirty and needs display.
+///       // Cast Surface to native Surface and use it here (pseudo code)
+///       DisplaySurface(surface);
+///
+///       // Once you're done, clear the dirty bounds:
+///       ulSurfaceClearDirtyBounds(surface);
+///  }
+///  </pre>
+///
+ULExport ULIntRect ulSurfaceGetDirtyBounds(ULSurface surface);
+
+///
+/// Clear the dirty bounds.
+///
+/// You should call this after you're done displaying the Surface.
+///
+ULExport void ulSurfaceClearDirtyBounds(ULSurface surface);
+
+///
+/// Get the underlying user data pointer (this is only valid if you have
+/// set a custom surface implementation via ulPlatformSetSurfaceDefinition).
+///
+/// This will return nullptr if this surface is the default ULBitmapSurface.
+///
+ULExport void* ulSurfaceGetUserData(ULSurface surface);
+
+/******************************************************************************
+ * BitmapSurface
+ *****************************************************************************/
+
+///
+/// Get the underlying Bitmap from the default Surface.
+///
+/// @note  Do not call ulDestroyBitmap() on the returned value, it is owned
+///        by the surface.
+///
+ULExport ULBitmap ulBitmapSurfaceGetBitmap(ULBitmapSurface surface);
+
+/******************************************************************************
+ * Surface Definition
+ *****************************************************************************/
+
+///
+/// The callback invoked when a Surface is created.
+///
+/// @param  width  The width in pixels.
+/// @param  height  The height in pixels.
+///
+/// @return  This callback should return a pointer to user-defined data for the
+///          instance. This user data pointer will be passed to all other
+///          callbacks when operating on the instance.
+///
+typedef void*
+(*ULSurfaceDefinitionCreateCallback) (unsigned int width, unsigned int height);
+
+///
+/// The callback invoked when a Surface is destroyed.
+///
+/// @param  user_data  User data pointer uniquely identifying the surface.
+///
+typedef void
+(*ULSurfaceDefinitionDestroyCallback) (void* user_data);
+
+///
+/// The callback invoked when a Surface's width (in pixels) is requested.
+///
+/// @param  user_data  User data pointer uniquely identifying the surface.
+///
+typedef unsigned int
+(*ULSurfaceDefinitionGetWidthCallback) (void* user_data);
+
+///
+/// The callback invoked when a Surface's height (in pixels) is requested.
+///
+/// @param  user_data  User data pointer uniquely identifying the surface.
+///
+typedef unsigned int
+(*ULSurfaceDefinitionGetHeightCallback) (void* user_data);
+
+///
+/// The callback invoked when a Surface's row bytes is requested.
+///
+/// @note  This value is also known as "stride". Usually width * 4.
+///
+/// @param  user_data  User data pointer uniquely identifying the surface.
+///
+typedef unsigned int
+(*ULSurfaceDefinitionGetRowBytesCallback) (void* user_data);
+
+///
+/// The callback invoked when a Surface's size (in bytes) is requested.
+///
+/// @param  user_data  User data pointer uniquely identifying the surface.
+///
+typedef size_t
+(*ULSurfaceDefinitionGetSizeCallback) (void* user_data);
+
+///
+/// The callback invoked when a Surface's pixel buffer is requested to be
+/// locked for reading/writing (should return a pointer to locked bytes).
+///
+/// @param  user_data  User data pointer uniquely identifying the surface.
+///
+typedef void*
+(*ULSurfaceDefinitionLockPixelsCallback) (void* user_data);
+
+///
+/// The callback invoked when a Surface's pixel buffer is requested to be
+/// unlocked after previously being locked.
+///
+/// @param  user_data  User data pointer uniquely identifying the surface.
+///
+typedef void
+(*ULSurfaceDefinitionUnlockPixelsCallback) (void* user_data);
+
+///
+/// The callback invoked when a Surface is requested to be resized to a
+/// certain width/height.
+///
+/// @param  user_data  User data pointer uniquely identifying the surface.
+/// @param  width      Width in pixels.
+/// @param  height     Height in pixels.
+///
+typedef void
+(*ULSurfaceDefinitionResizeCallback) (void* user_data, unsigned int width, unsigned int height);
+
+typedef struct {
+  ULSurfaceDefinitionCreateCallback create;
+  ULSurfaceDefinitionDestroyCallback destroy;
+  ULSurfaceDefinitionGetWidthCallback get_width;
+  ULSurfaceDefinitionGetHeightCallback get_height;
+  ULSurfaceDefinitionGetRowBytesCallback get_row_bytes;
+  ULSurfaceDefinitionGetSizeCallback get_size;
+  ULSurfaceDefinitionLockPixelsCallback lock_pixels;
+  ULSurfaceDefinitionUnlockPixelsCallback unlock_pixels;
+  ULSurfaceDefinitionResizeCallback resize;
+} ULSurfaceDefinition;
+
+/******************************************************************************
+ * File System
+ *****************************************************************************/
+
+///
+/// File Handle type used as unique ID for opened files.
+///
+#if defined(__WIN32__) || defined(_WIN32)
+typedef size_t ULFileHandle;
+#else
+typedef int ULFileHandle;
+#endif
+
+///
+/// Handle used to denote an invalid file.
+///
+const ULFileHandle ULInvalidFileHandle = (ULFileHandle)-1;
+
+///
+/// The callback invoked when the FileSystem wants to check if a file path
+/// exists, return true if it exists.
+///
+typedef bool
+(*ULFileSystemFileExistsCallback) (ULString path);
+
+///
+/// The callback invoked when the FileSystem wants to get the file size of a
+/// previously opened file, store result in 'result'. Return true on success.
+///
+typedef bool
+(*ULFileSystemGetFileSizeCallback) (ULFileHandle handle, long long* result);
+
+///
+/// The callback invoked when the FileSystem wants to get the mime type of a
+/// file (eg "text/html"), store result in 'result'. Return true on success.
+///
+typedef bool
+(*ULFileSystemGetFileMimeTypeCallback) (ULString path, ULString result);
+
+///
+/// The callback invoked when the FileSystem wants to open a file path for
+/// reading or writing. Return file handle on success, or ULInvalidFileHandle
+/// on failure.
+///
+/// @NOTE:  As of this writing (v1.2), this function is only used for reading.
+///
+typedef ULFileHandle
+(*ULFileSystemOpenFileCallback) (ULString path, bool open_for_writing);
+
+///
+/// The callback invoked when the FileSystem wants to close a previously-opened
+/// file.
+///
+typedef void
+(*ULFileSystemCloseFileCallback) (ULFileHandle handle);
+
+///
+/// The callback invoked when the FileSystem wants to read from a
+/// currently-opened file, return number of bytes read or -1 on failure.
+///
+typedef long long
+(*ULFileSystemReadFromFileCallback) (ULFileHandle handle, char* data, long long length);
+
+typedef struct {
+  ULFileSystemFileExistsCallback file_exists;
+  ULFileSystemGetFileSizeCallback get_file_size;
+  ULFileSystemGetFileMimeTypeCallback get_file_mime_type;
+  ULFileSystemOpenFileCallback open_file;
+  ULFileSystemCloseFileCallback close_file;
+  ULFileSystemReadFromFileCallback read_from_file;
+} ULFileSystem;
+
+/******************************************************************************
+ * Logger
+ *****************************************************************************/
+
+typedef enum {
+  kLogLevel_Error = 0,
+  kLogLevel_Warning,
+  kLogLevel_Info
+} ULLogLevel;
+
+///
+/// The callback invoked when the library wants to print a message to the log.
+///
+typedef void
+(*ULLoggerLogMessageCallback) (ULLogLevel log_level, ULString message);
+
+typedef struct {
+  ULLoggerLogMessageCallback log_message;
+} ULLogger;
+
+
+/******************************************************************************
+ * GPUDriver
+ *****************************************************************************/
+
+///
+/// Render buffer description.
+///
+typedef struct {
+  unsigned int texture_id;  // The backing texture for this RenderBuffer
+  unsigned int width;       // The width of the RenderBuffer texture
+  unsigned int height;      // The height of the RenderBuffer texture
+  bool has_stencil_buffer;  // Currently unused, always false.
+  bool has_depth_buffer;    // Currently unsued, always false.
+} ULRenderBuffer;
+
+///
+/// @note  This pragma pack(push, 1) command is important! Vertex layouts
+///	       should not be padded with any bytes.
+///
+#pragma pack(push, 1)
+
+///
+/// Vertex layout for path vertices.
+///
+/// (this struct's members aligned on single-byte boundaries)
+///
+typedef struct {
+  float pos[2];
+  unsigned char color[4];
+  float obj[2];
+} ULVertex_2f_4ub_2f;
+
+///
+/// Vertex layout for quad vertices.
+///
+/// (this struct's members aligned on single-byte boundaries)
+///
+typedef struct {
+  float pos[2];
+  unsigned char color[4];
+  float tex[2];
+  float obj[2];
+  float data0[4];
+  float data1[4];
+  float data2[4];
+  float data3[4];
+  float data4[4];
+  float data5[4];
+  float data6[4];
+} ULVertex_2f_4ub_2f_2f_28f;
+
+///
+/// End single-byte alignment.
+///
+#pragma pack(pop)
+
+///
+/// Vertex formats.
+///
+typedef enum {
+  kVertexBufferFormat_2f_4ub_2f,
+  kVertexBufferFormat_2f_4ub_2f_2f_28f,
+} ULVertexBufferFormat;
+
+///
+/// Vertex buffer data.
+///
+typedef struct {
+  ULVertexBufferFormat format;
+  unsigned int size;
+  unsigned char* data;
+} ULVertexBuffer;
+
+///
+/// Vertex index type.
+///
+typedef unsigned int ULIndexType;
+
+///
+/// Vertex index buffer data.
+///
+typedef struct {
+  unsigned int size;
+  unsigned char* data;
+} ULIndexBuffer;
+
+///
+/// Shader types, used with ULGPUState::shader_type
+///
+/// Each of these correspond to a vertex/pixel shader pair. You can find
+/// stock shader code for these in the `shaders` folder of the AppCore repo.
+///
+typedef enum {
+  kShaderType_Fill,      // Shader program for quad geometry
+  kShaderType_FillPath,  // Shader program for path geometry
+} ULShaderType;
+
+///
+/// Raw 4x4 matrix as an array of floats
+///
+typedef struct {
+  float data[16];
+} ULMatrix4x4;
+
+///
+/// 4-component float vector
+///
+typedef struct {
+  float value[4];
+} ULvec4;
+
+///
+/// GPU State description.
+///
+typedef struct {
+  /// Viewport width in pixels
+  unsigned int viewport_width;
+
+  /// Viewport height in pixels
+  unsigned int viewport_height;
+
+  /// Transform matrix-- you should multiply this with the screen-space
+  /// orthographic projection matrix then pass to the vertex shader.
+  ULMatrix4x4 transform;
+
+  /// Whether or not we should enable texturing for the current draw command.
+  bool enable_texturing;
+
+  /// Whether or not we should enable blending for the current draw command.
+  /// If blending is disabled, any drawn pixels should overwrite existing.
+  /// Mainly used so we can modify alpha values of the RenderBuffer during
+  /// scissored clears.
+  bool enable_blend;
+
+  /// The vertex/pixel shader program pair to use for the current draw command.
+  /// You should cast this to ShaderType to get the corresponding enum.
+  unsigned char shader_type;
+
+  /// The render buffer to use for the current draw command.
+  unsigned int render_buffer_id;
+
+  /// The texture id to bind to slot #1. (Will be 0 if none)
+  unsigned int texture_1_id;
+
+  /// The texture id to bind to slot #2. (Will be 0 if none)
+  unsigned int texture_2_id;
+
+  /// The texture id to bind to slot #3. (Will be 0 if none)
+  unsigned int texture_3_id;
+
+  /// The following four members are passed to the pixel shader via uniforms.
+  float uniform_scalar[8];
+  ULvec4 uniform_vector[8];
+  unsigned char clip_size;
+  ULMatrix4x4 clip[8];
+
+  /// Whether or not scissor testing should be used for the current draw
+  /// command.
+  bool enable_scissor;
+
+  /// The scissor rect to use for scissor testing (units in pixels)
+  ULIntRect scissor_rect;
+} ULGPUState;
+
+///
+/// Command types, used with ULCommand::command_type
+///
+typedef enum {
+  kCommandType_ClearRenderBuffer,
+  kCommandType_DrawGeometry,
+} ULCommandType;
+
+///
+/// Command description.
+///
+typedef struct {
+  unsigned char command_type;    // The type of command to dispatch.
+  ULGPUState gpu_state;          // GPU state parameters for current command.
+
+  /// The following members are only used with kCommandType_DrawGeometry
+  unsigned int geometry_id;    // The geometry ID to bind
+  unsigned int indices_count;  // The number of indices
+  unsigned int indices_offset; // The index to start from
+} ULCommand;
+
+///
+/// Command list, @see ULGPUDriverUpdateCommandList
+typedef struct {
+  unsigned int size;
+  ULCommand* commands;
+} ULCommandList;
+
+///
+/// The callback invoked when the GPUDriver will begin dispatching commands
+/// (such as CreateTexture and UpdateCommandList) during the current call to
+/// ulRender().
+///
+typedef void
+(*ULGPUDriverBeginSynchronizeCallback) ();
+
+///
+/// The callback invoked when the GPUDriver has finished dispatching commands.
+/// during the current call to ulRender().
+///
+typedef void
+(*ULGPUDriverEndSynchronizeCallback) ();
+
+///
+/// The callback invoked when the GPUDriver wants to get the next available
+/// texture ID.
+///
+typedef unsigned int
+(*ULGPUDriverNextTextureIdCallback) ();
+
+///
+/// The callback invoked when the GPUDriver wants to create a texture with a
+/// certain ID and optional bitmap.
+///
+/// **NOTE**: If the Bitmap is empty (ulBitmapIsEmpty), then a RTT Texture
+///           should be created instead. This will be used as a backing
+///           texture for a new RenderBuffer.
+///
+typedef void
+(*ULGPUDriverCreateTextureCallback) (unsigned int texture_id,
+                                     ULBitmap bitmap);
+
+///
+/// The callback invoked when the GPUDriver wants to update an existing non-RTT
+/// texture with new bitmap data.
+///
+typedef void
+(*ULGPUDriverUpdateTextureCallback) (unsigned int texture_id,
+                                     ULBitmap bitmap);
+
+///
+/// The callback invoked when the GPUDriver wants to destroy a texture.
+///
+typedef void
+(*ULGPUDriverDestroyTextureCallback) (unsigned int texture_id);
+
+///
+/// The callback invoked when the GPUDriver wants to generate the next
+/// available render buffer ID.
+///
+typedef unsigned int
+(*ULGPUDriverNextRenderBufferIdCallback) ();
+
+///
+/// The callback invoked when the GPUDriver wants to create a render buffer
+/// with certain ID and buffer description.
+///
+typedef void
+(*ULGPUDriverCreateRenderBufferCallback) (unsigned int render_buffer_id,
+                                          ULRenderBuffer buffer);
+
+///
+/// The callback invoked when the GPUDriver wants to destroy a render buffer
+///
+typedef void
+(*ULGPUDriverDestroyRenderBufferCallback) (unsigned int render_buffer_id);
+
+///
+/// The callback invoked when the GPUDriver wants to generate the next
+/// available geometry ID.
+///
+typedef unsigned int
+(*ULGPUDriverNextGeometryIdCallback) ();
+
+///
+/// The callback invoked when the GPUDriver wants to create geometry with
+/// certain ID and vertex/index data.
+///
+typedef void
+(*ULGPUDriverCreateGeometryCallback) (unsigned int geometry_id,
+                                      ULVertexBuffer vertices,
+                                      ULIndexBuffer indices);
+
+///
+/// The callback invoked when the GPUDriver wants to update existing geometry
+/// with new vertex/index data.
+///
+typedef void
+(*ULGPUDriverUpdateGeometryCallback) (unsigned int geometry_id,
+                                      ULVertexBuffer vertices,
+                                      ULIndexBuffer indices);
+
+///
+/// The callback invoked when the GPUDriver wants to destroy geometry.
+///
+typedef void
+(*ULGPUDriverDestroyGeometryCallback) (unsigned int geometry_id);
+
+///
+/// The callback invoked when the GPUDriver wants to update the command list
+/// (you should copy the commands to your own structure).
+///
+typedef void
+(*ULGPUDriverUpdateCommandListCallback) (ULCommandList list);
+
+typedef struct {
+  ULGPUDriverBeginSynchronizeCallback begin_synchronize;
+  ULGPUDriverEndSynchronizeCallback end_synchronize;
+  ULGPUDriverNextTextureIdCallback next_texture_id;
+  ULGPUDriverCreateTextureCallback create_texture;
+  ULGPUDriverUpdateTextureCallback update_texture;
+  ULGPUDriverDestroyTextureCallback destroy_texture;
+  ULGPUDriverNextRenderBufferIdCallback next_render_buffer_id;
+  ULGPUDriverCreateRenderBufferCallback create_render_buffer;
+  ULGPUDriverDestroyRenderBufferCallback destroy_render_buffer;
+  ULGPUDriverNextGeometryIdCallback next_geometry_id;
+  ULGPUDriverCreateGeometryCallback create_geometry;
+  ULGPUDriverUpdateGeometryCallback update_geometry;
+  ULGPUDriverDestroyGeometryCallback destroy_geometry;
+  ULGPUDriverUpdateCommandListCallback update_command_list;
+} ULGPUDriver;
+
+///
+/// Sets up an orthographic projection matrix with a certain viewport width
+/// and height, multiplies it by 'transform', and returns the result.
+///
+/// This should be used to calculate the model-view projection matrix for the
+/// vertex shaders using the current ULGPUState.
+///
+/// The 'flip_y' can be optionally used to flip the Y coordinate-space.
+/// (Usually flip_y == true for OpenGL)
+///
+ULExport ULMatrix4x4 ulApplyProjection(ULMatrix4x4 transform,
+                                       float viewport_width,
+                                       float viewport_height,
+                                       bool flip_y);
+
+/******************************************************************************
+ * Clipboard
+ *****************************************************************************/
+
+///
+/// The callback invoked when the library wants to clear the system's
+/// clipboard.
+///
+typedef void
+(*ULClipboardClearCallback) ();
+
+///
+/// The callback invoked when the library wants to read from the system's
+/// clipboard.
+///
+/// You should store the result (if any) in 'result'.
+///
+typedef void
+(*ULClipboardReadPlainTextCallback) (ULString result);
+
+///
+/// The callback invoked when the library wants to write to the system's
+/// clipboard.
+///
+typedef void
+(*ULClipboardWritePlainTextCallback) (ULString text);
+
+typedef struct {
+  ULClipboardClearCallback clear;
+  ULClipboardReadPlainTextCallback read_plain_text;
+  ULClipboardWritePlainTextCallback write_plain_text;
+} ULClipboard;
+
+/******************************************************************************
+ * Platform
+ *****************************************************************************/
+
+///
+/// Set a custom Logger implementation.
+///
+/// This is used to log debug messages to the console or to a log file.
+///
+/// You should call this before ulCreateRenderer() or ulCreateApp().
+///
+/// @note  ulCreateApp() will use the default logger if you never call this.
+///
+/// @note  If you're not using ulCreateApp(), (eg, using ulCreateRenderer())
+///        you can still use the default logger by calling
+///        ulEnableDefaultLogger() (@see <AppCore/CAPI.h>)
+///
+ULExport void ulPlatformSetLogger(ULLogger logger);
+
+///
+/// Set a custom FileSystem implementation.
+///          
+/// This is used for loading File URLs (eg, <file:///page.html>). If you don't
+/// call this, and are not using ulCreateApp() or ulEnablePlatformFileSystem(), 
+/// you will not be able to load any File URLs.
+///
+/// You should call this before ulCreateRenderer() or ulCreateApp().
+///
+/// @note  ulCreateApp() will use the default platform file system if you never
+///        call this.
+///
+/// @note  If you're not using ulCreateApp(), (eg, using ulCreateRenderer())
+///        you can still use the default platform file system by calling
+///        ulEnablePlatformFileSystem() (@see <AppCore/CAPI.h>)
+///
+ULExport void ulPlatformSetFileSystem(ULFileSystem file_system);
+
+///
+/// Set a custom Surface implementation.
+///
+/// This can be used to wrap a platform-specific GPU texture, Windows DIB,
+/// macOS CGImage, or any other pixel buffer target for display on screen.
+///
+/// By default, the library uses a bitmap surface for all surfaces but you can
+/// override this by providing your own surface definition here.
+///
+/// You should call this before ulCreateRenderer() or ulCreateApp().
+///
+ULExport void ulPlatformSetSurfaceDefinition(ULSurfaceDefinition surface_definition);
+
+///
+/// Set a custom GPUDriver implementation.
+///
+/// This should be used if you have enabled the GPU renderer in the Config and
+/// are using ulCreateRenderer() (which does not provide its own GPUDriver
+/// implementation).
+///
+/// The GPUDriver interface is used by the library to dispatch GPU calls to
+/// your native GPU context (eg, D3D11, Metal, OpenGL, Vulkan, etc.) There
+/// are reference implementations for this interface in the AppCore repo.
+///
+/// You should call this before ulCreateRenderer().
+///
+ULExport void ulPlatformSetGPUDriver(ULGPUDriver gpu_driver);
+
+///
+/// Set a custom Clipboard implementation.
+///
+/// This should be used if you are using ulCreateRenderer() (which does not
+/// provide its own clipboard implementation).
+///
+/// The Clipboard interface is used by the library to make calls to the
+/// system's native clipboard (eg, cut, copy, paste).
+///
+/// You should call this before ulCreateRenderer().
+///
+ULExport void ulPlatformSetClipboard(ULClipboard clipboard);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // ULTRALIGHT_CAPI_H
diff --git a/engine/inc/Ultralight/Defines.h b/engine/inc/Ultralight/Defines.h
new file mode 100644
index 00000000..055b4ac0
--- /dev/null
+++ b/engine/inc/Ultralight/Defines.h
@@ -0,0 +1,95 @@
+///
+/// @file Defines.h
+///
+/// @brief Common platform definitions
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+
+// Needed for limit defines, like INTMAX_MAX, which is used by the std C++ library
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS
+#endif
+
+#include <cstdint>
+#include <cstddef>
+#include <limits.h>
+
+#ifdef SWIG
+#define UExport
+#else
+
+// Require C++11 Support
+#if defined(_MSC_VER)
+#   if _MSC_VER < 1800 
+#       error This project needs at least Visual Studio 2013 to build
+#   endif
+#elif __cplusplus <= 199711L
+#   error This project can only be compiled with a compiler that supports C++11
+#endif
+
+
+#if defined(__WIN32__) || defined(_WIN32)
+#  if defined(ULTRALIGHT_IMPLEMENTATION)
+#    define UExport __declspec(dllexport)
+#  else
+#    define UExport __declspec(dllimport)
+#  endif
+#define _thread_local __declspec(thread)
+#ifndef _NATIVE_WCHAR_T_DEFINED
+#define DISABLE_NATIVE_WCHAR_T
+#endif
+#else
+#  define UExport __attribute__((visibility("default")))
+#define _thread_local __thread
+#endif
+
+#endif
+
+#define ULTRALIGHT_VERSION "1.2.0"
+#define ULTRALIGHT_VERSION_MAJOR 1
+#define ULTRALIGHT_VERSION_MINOR 2
+#define ULTRALIGHT_VERSION_PATCH 0
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+UExport const char* UltralightVersionString();
+UExport uint32_t UltralightVersionMajor();
+UExport uint32_t UltralightVersionMinor();
+UExport uint32_t UltralightVersionPatch();
+
+#ifdef __cplusplus
+}
+#endif
+
+///
+/// @mainpage Ultralight C++ API Reference
+///
+/// @section intro_sec Introduction
+///
+/// Hi there, welcome to the C++ API Reference for Ultralight!
+///
+/// Ultralight is a fast, lightweight HTML UI engine for desktop apps and games.
+///
+/// If this is your first time exploring the API, we recommend
+/// starting with ultralight::Renderer and ultralight::View.
+///
+///
+/// @section usefullinks_sec Useful Links
+/// - Home:     <https://ultralig.ht> -- Get the latest binaries
+/// - Docs:     <https://docs.ultralig.ht> -- API overview, code snippets, tutorials and more!
+/// - Discord:  <http://chat.ultralig.ht/> -- Stuck? Have questions? Come chat with us!
+/// - GitHub:   <https://github.com/ultralight-ux/ultralight> -- Report issues and browse code
+///
+/// @section copyright_sec Copyright
+/// Documentation is Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
diff --git a/engine/inc/Ultralight/Geometry.h b/engine/inc/Ultralight/Geometry.h
new file mode 100644
index 00000000..6616bd3e
--- /dev/null
+++ b/engine/inc/Ultralight/Geometry.h
@@ -0,0 +1,677 @@
+///
+/// @file Geometry.h
+///
+/// @brief The header for various geometry definitions and helpers
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+#include <Ultralight/Defines.h>
+#include <memory.h>
+#include <cmath>
+#include <cstring>
+#include <algorithm>
+
+namespace ultralight {
+
+///
+/// 2D Vector Helper
+///
+struct UExport vec2 {
+  union {
+    float value[2];
+    struct { float x, y; };
+  };
+
+  inline vec2() {}
+
+  inline vec2(float x, float y) : x(x), y(y) {}
+
+  inline vec2(float x) : x(x), y(x) {}
+
+  inline vec2 yx() const { return { y, x }; }
+
+  inline vec2 xx() const { return { x, x }; }
+
+  inline vec2 yy() const { return { y, y }; }
+
+  inline friend vec2 operator+(vec2 lhs, const vec2& rhs) { lhs += rhs; return lhs; }
+
+  inline friend vec2 operator-(vec2 lhs, const vec2& rhs) { lhs -= rhs; return lhs; }
+
+  inline friend vec2 operator*(vec2 lhs, const vec2& rhs) { lhs *= rhs; return lhs; }
+
+  inline friend vec2 operator/(vec2 lhs, const vec2& rhs) { lhs /= rhs; return lhs; }
+
+  inline friend vec2 operator+(vec2 lhs, float rhs) { lhs += rhs; return lhs; }
+
+  inline friend vec2 operator-(vec2 lhs, float rhs) { lhs -= rhs; return lhs; }
+
+  inline friend vec2 operator*(vec2 lhs, float rhs) { lhs *= rhs; return lhs; }
+
+  inline friend vec2 operator/(vec2 lhs, float rhs) { lhs /= rhs; return lhs; }
+
+  inline vec2& operator+=(const vec2& rhs) {
+    value[0] += rhs.value[0];
+    value[1] += rhs.value[1];
+    return *this;
+  }
+
+  inline vec2& operator-=(const vec2& rhs) {
+    value[0] -= rhs.value[0];
+    value[1] -= rhs.value[1];
+    return *this;
+  }
+
+  inline vec2& operator*=(const vec2& rhs) {
+    value[0] *= rhs.value[0];
+    value[1] *= rhs.value[1];
+    return *this;
+  }
+
+  inline vec2& operator/=(const vec2& rhs) {
+    value[0] /= rhs.value[0];
+    value[1] /= rhs.value[1];
+    return *this;
+  }
+
+  inline vec2& operator+=(float rhs) {
+    value[0] += rhs;
+    value[1] += rhs;
+    return *this;
+  }
+
+  inline vec2& operator-=(float rhs) {
+    value[0] -= rhs;
+    value[1] -= rhs;
+    return *this;
+  }
+
+  inline vec2& operator*=(float rhs) {
+    value[0] *= rhs;
+    value[1] *= rhs;
+    return *this;
+  }
+
+  inline vec2& operator/=(float rhs) {
+    value[0] /= rhs;
+    value[1] /= rhs;
+    return *this;
+  }
+
+  inline friend bool operator==(const vec2& a, const vec2& b) {
+    return !memcmp(&a, &b, sizeof(a));
+  }
+
+  inline friend bool operator!=(const vec2& a, const vec2& b) {
+    return !(a == b);
+  }
+
+  inline friend vec2 min_(const vec2& a, const vec2& b) {
+    return{ (b.x < a.x) ? b.x : a.x, 
+            (b.y < a.y) ? b.y : a.y };
+  }
+
+  inline friend vec2 max_(const vec2& a, const vec2& b) {
+    return{ (a.x < b.x) ? b.x : a.x, 
+            (a.y < b.y) ? b.y : a.y };
+  }
+
+  inline friend vec2 clamp(const vec2& x, const vec2& minVal, const vec2& maxVal) {
+    return min_(max_(x, minVal), maxVal);
+  }
+
+  inline friend vec2 mix(const vec2& a, const vec2& b, float t) {
+    return a * (1.0f - t) + b * t;
+  }
+
+  inline friend float length(const vec2& a) {
+    return sqrtf(a.x * a.x + a.y * a.y);
+  }
+
+  // squared length
+  inline friend float length2(const vec2& a) {
+    return dot(a, a);
+  }
+
+  inline friend float distance(const vec2& a, const vec2& b) {
+    return length(a - b);
+  }
+
+  // squared distance
+  inline friend float distance2(const vec2& a, const vec2& b) {
+    return length2(a - b);
+  }
+
+  inline friend vec2 normalize(const vec2& a) {
+    return a / length(a);
+  }
+
+  inline friend float dot(const vec2& a, const vec2& b) {
+    return a.x * b.x + a.y * b.y;
+  }
+};
+
+///
+/// 3D Vector Helper
+///
+struct UExport vec3 {
+  union {
+    float value[3];
+    struct { float x, y, z; };
+  };
+
+  inline vec3() {}
+
+  inline vec3(float x, float y, float z) : x(x), y(y), z(z) {}
+
+  inline vec3(float x) : x(x), y(x), z(x) {}
+
+  inline friend vec3 operator+(vec3 lhs, const vec3& rhs) { lhs += rhs; return lhs; }
+
+  inline friend vec3 operator-(vec3 lhs, const vec3& rhs) { lhs -= rhs; return lhs; }
+
+  inline friend vec3 operator*(vec3 lhs, const vec3& rhs) { lhs *= rhs; return lhs; }
+
+  inline friend vec3 operator/(vec3 lhs, const vec3& rhs) { lhs /= rhs; return lhs; }
+
+  inline friend vec3 operator+(vec3 lhs, float rhs) { lhs += rhs; return lhs; }
+
+  inline friend vec3 operator-(vec3 lhs, float rhs) { lhs -= rhs; return lhs; }
+
+  inline friend vec3 operator*(vec3 lhs, float rhs) { lhs *= rhs; return lhs; }
+
+  inline friend vec3 operator/(vec3 lhs, float rhs) { lhs /= rhs; return lhs; }
+
+  inline vec3& operator+=(const vec3& rhs) {
+    value[0] += rhs.value[0];
+    value[1] += rhs.value[1];
+    value[2] += rhs.value[2];
+    return *this;
+  }
+
+  inline vec3& operator-=(const vec3& rhs) {
+    value[0] -= rhs.value[0];
+    value[1] -= rhs.value[1];
+    value[2] -= rhs.value[2];
+    return *this;
+  }
+
+  inline vec3& operator*=(const vec3& rhs) {
+    value[0] *= rhs.value[0];
+    value[1] *= rhs.value[1];
+    value[2] *= rhs.value[2];
+    return *this;
+  }
+
+  inline vec3& operator/=(const vec3& rhs) {
+    value[0] /= rhs.value[0];
+    value[1] /= rhs.value[1];
+    value[2] /= rhs.value[2];
+    return *this;
+  }
+
+  inline vec3& operator+=(float rhs) {
+    value[0] += rhs;
+    value[1] += rhs;
+    value[2] += rhs;
+    return *this;
+  }
+
+  inline vec3& operator-=(float rhs) {
+    value[0] -= rhs;
+    value[1] -= rhs;
+    value[2] -= rhs;
+    return *this;
+  }
+
+  inline vec3& operator*=(float rhs) {
+    value[0] *= rhs;
+    value[1] *= rhs;
+    value[2] *= rhs;
+    return *this;
+  }
+
+  inline vec3& operator/=(float rhs) {
+    value[0] /= rhs;
+    value[1] /= rhs;
+    value[2] /= rhs;
+    return *this;
+  }
+
+  inline friend bool operator==(const vec3& a, const vec3& b) {
+    return !memcmp(&a, &b, sizeof(a));
+  }
+
+  inline friend bool operator!=(const vec3& a, const vec3& b) {
+    return !(a == b);
+  }
+
+  inline friend vec3 min_(const vec3& a, const vec3& b) {
+    return{ (b.x < a.x) ? b.x : a.x,
+            (b.y < a.y) ? b.y : a.y,
+            (b.z < a.z) ? b.z : a.z };
+  }
+
+  inline friend vec3 max_(const vec3& a, const vec3& b) {
+    return{ (a.x < b.x) ? b.x : a.x,
+            (a.y < b.y) ? b.y : a.y,
+            (a.z < b.z) ? b.z : a.z };
+  }
+  inline friend vec3 clamp(const vec3& x, const vec3& minVal, const vec3& maxVal) {
+    return min_(max_(x, minVal), maxVal);
+  }
+
+  inline friend vec3 mix(const vec3& a, const vec3& b, float t) {
+    return a * (1.0f - t) + b * t;
+  }
+
+  inline friend float length(const vec3& a) {
+    return sqrtf(a.x * a.x + a.y * a.y + a.z * a.z);
+  }
+
+  inline friend float distance(const vec3& a, const vec3& b) {
+    return length(a - b);
+  }
+
+  inline friend vec3 normalize(const vec3& a) {
+    return a / length(a);
+  }
+
+  inline friend float dot(const vec3& a, const vec3& b) {
+    return a.x * b.x + a.y * b.y + a.z * b.z;
+  }
+};
+
+///
+/// 4D Vector Helper
+///
+struct UExport vec4 {
+  union {
+    float value[4];
+    struct { float x, y, z, w; };
+  };
+
+  inline vec4() {}
+
+  inline vec4(float x, float y, float z, float w) : x(x), y(y), z(z), w(w) {}
+
+  inline vec4(float x) : x(x), y(x), z(x), w(x) {}
+
+  inline vec4(const float x[4]) { memcpy(value, x, sizeof(value)); }
+
+  inline friend bool operator==(const vec4& a, const vec4& b) {
+    return !memcmp(&a, &b, sizeof(a));
+  }
+
+  inline friend bool operator!=(const vec4& a, const vec4& b) {
+    return !(a == b);
+  }
+
+  inline friend vec4 operator+(vec4 lhs, const vec4& rhs) { lhs += rhs; return lhs; }
+
+  inline friend vec4 operator-(vec4 lhs, const vec4& rhs) { lhs -= rhs; return lhs; }
+
+  inline friend vec4 operator*(vec4 lhs, const vec4& rhs) { lhs *= rhs; return lhs; }
+
+  inline friend vec4 operator/(vec4 lhs, const vec4& rhs) { lhs /= rhs; return lhs; }
+
+  inline friend vec4 operator+(vec4 lhs, float rhs) { lhs += rhs; return lhs; }
+
+  inline friend vec4 operator-(vec4 lhs, float rhs) { lhs -= rhs; return lhs; }
+
+  inline friend vec4 operator*(vec4 lhs, float rhs) { lhs *= rhs; return lhs; }
+
+  inline friend vec4 operator/(vec4 lhs, float rhs) { lhs /= rhs; return lhs; }
+
+  inline vec4& operator+=(const vec4& rhs) {
+    value[0] += rhs.value[0];
+    value[1] += rhs.value[1];
+    value[2] += rhs.value[2];
+    value[3] += rhs.value[3];
+    return *this;
+  }
+
+  inline vec4& operator-=(const vec4& rhs) {
+    value[0] -= rhs.value[0];
+    value[1] -= rhs.value[1];
+    value[2] -= rhs.value[2];
+    value[3] -= rhs.value[3];
+    return *this;
+  }
+
+  inline vec4& operator*=(const vec4& rhs) {
+    value[0] *= rhs.value[0];
+    value[1] *= rhs.value[1];
+    value[2] *= rhs.value[2];
+    value[3] *= rhs.value[3];
+    return *this;
+  }
+
+  inline vec4& operator/=(const vec4& rhs) {
+    value[0] /= rhs.value[0];
+    value[1] /= rhs.value[1];
+    value[2] /= rhs.value[2];
+    value[3] /= rhs.value[3];
+    return *this;
+  }
+
+  inline vec4& operator+=(float rhs) {
+    value[0] += rhs;
+    value[1] += rhs;
+    value[2] += rhs;
+    value[3] += rhs;
+    return *this;
+  }
+
+  inline vec4& operator-=(float rhs) {
+    value[0] -= rhs;
+    value[1] -= rhs;
+    value[2] -= rhs;
+    value[3] -= rhs;
+    return *this;
+  }
+
+  inline vec4& operator*=(float rhs) {
+    value[0] *= rhs;
+    value[1] *= rhs;
+    value[2] *= rhs;
+    value[3] *= rhs;
+    return *this;
+  }
+
+  inline vec4& operator/=(float rhs) {
+    value[0] /= rhs;
+    value[1] /= rhs;
+    value[2] /= rhs;
+    value[3] /= rhs;
+    return *this;
+  }
+
+  inline friend vec4 min_(const vec4& a, const vec4& b) {
+    return{ (b.x < a.x) ? b.x : a.x,
+            (b.y < a.y) ? b.y : a.y,
+            (b.z < a.z) ? b.z : a.z,
+            (b.w < a.w) ? b.w : a.w };
+  }
+
+  inline friend vec4 max_(const vec4& a, const vec4& b) {
+    return{ (a.x < b.x) ? b.x : a.x,
+            (a.y < b.y) ? b.y : a.y,
+            (a.z < b.z) ? b.z : a.z,
+            (a.w < b.w) ? b.w : a.w };
+  }
+};
+
+///
+/// Point is typedef'd to a 2D vector
+///
+typedef vec2 Point;
+
+///
+/// Float Rectangle Helper
+///
+struct UExport Rect {
+  union {
+    float value[4];
+    struct { float left, top, right, bottom; };
+  };
+
+  static inline Rect MakeEmpty() {
+    Rect result;
+    result.SetEmpty();
+    return result;
+  }
+
+  inline float width() const { return right - left; }
+  inline float height() const { return bottom - top; }
+  inline float x() const { return left; }
+  inline float y() const { return top; }
+  inline float center_x() const { return (left + right) * 0.5f; }
+  inline float center_y() const { return (top + bottom) * 0.5f; }
+
+  inline Point origin() const { return { left, top }; }
+
+  inline void SetEmpty() {
+    memset(this, 0, sizeof(*this));
+  }
+
+  inline bool IsEmpty() const {
+    return *this == MakeEmpty();
+  }
+
+  inline bool IsValid() const {
+    return width() > 0 && height() > 0;
+  }
+
+  inline void Inset(float dx, float dy) {
+    value[0] += dx;
+    value[1] += dy;
+    value[2] -= dx;
+    value[3] -= dy;
+  }
+
+  inline void Outset(float dx, float dy) {
+    Inset(-dx, -dy);
+  }
+
+  inline void Move(float dx, float dy) {
+    value[0] += dx;
+    value[1] += dy;
+    value[2] += dx;
+    value[3] += dy;
+  }
+
+  inline float area() const {
+    return width() * height();
+  }
+
+  inline void Join(const Rect& rhs) {
+    // if we are empty, just assign
+    if (IsEmpty()) {
+      *this = rhs;
+    }
+    else {
+      if (rhs.value[0] < value[0]) value[0] = rhs.value[0];
+      if (rhs.value[1] < value[1]) value[1] = rhs.value[1];
+      if (rhs.value[2] > value[2]) value[2] = rhs.value[2];
+      if (rhs.value[3] > value[3]) value[3] = rhs.value[3];
+    }
+  }
+
+  inline void Join(const Point& p) {
+    // if we are empty, just assign
+    if (IsEmpty()) {
+      *this = { p.x, p.y, p.x, p.y };
+    }
+    else {
+      if (p.x < value[0]) value[0] = p.x;
+      if (p.y < value[1]) value[1] = p.y;
+      if (p.x > value[2]) value[2] = p.x;
+      if (p.y > value[3]) value[3] = p.y;
+    }
+  }
+
+  inline bool Contains(const Point& p) const {
+    return p.x >= left && p.x <= right &&
+           p.y >= top && p.y <= bottom;
+  }
+
+  inline bool Contains(const Rect& r) const {
+    return left <= r.left && top <= r.top &&
+           right >= r.right && bottom >= r.bottom;
+  }
+
+  inline bool Intersects(const Rect& rhs) const {
+    return !(rhs.left > right ||
+             rhs.right < left ||
+             rhs.top > bottom ||
+             rhs.bottom < top);
+  }
+
+  inline Rect Intersect(const Rect& other) const {
+    return{ (left         < other.left) ? other.left   : left,
+            (top          < other.top)  ? other.top    : top,
+            (other.right  < right)      ? other.right  : right,
+            (other.bottom < bottom)     ? other.bottom : bottom };
+  }
+
+  friend inline bool operator==(const Rect& a, const Rect& b) {
+    return !memcmp(&a, &b, sizeof(a));
+  }
+
+  friend inline bool operator!=(const Rect& a, const Rect& b) {
+    return !(a == b);
+  }
+};
+
+///
+/// Integer Rectangle Helper
+///
+struct UExport IntRect {
+  union {
+    int value[4];
+    struct { int left, top, right, bottom; };
+  };
+
+  static inline IntRect MakeEmpty() {
+    IntRect result;
+    result.SetEmpty();
+    return result;
+  }
+
+  inline int width() const { return right - left; }
+  inline int height() const { return bottom - top; }
+  inline int x() const { return left; }
+  inline int y() const { return top; }
+  inline int center_x() const { return (int)std::round((left + right) * 0.5f); }
+  inline int center_y() const { return (int)std::round((top + bottom) * 0.5f); }
+
+  inline Point origin() const { return{ (float)left, (float)top }; }
+
+  inline void SetEmpty() {
+    memset(this, 0, sizeof(*this));
+  }
+
+  inline bool IsEmpty() const {
+    return *this == MakeEmpty();
+  }
+
+  inline bool IsValid() const {
+    return width() > 0 && height() > 0;
+  }
+
+  inline void Inset(int dx, int dy) {
+    value[0] += dx;
+    value[1] += dy;
+    value[2] -= dx;
+    value[3] -= dy;
+  }
+
+  inline void Outset(int dx, int dy) {
+    Inset(-dx, -dy);
+  }
+
+  inline void Move(int dx, int dy) {
+    value[0] += dx;
+    value[1] += dy;
+    value[2] += dx;
+    value[3] += dy;
+  }
+
+  inline int area() const {
+    return width() * height();
+  }
+
+  inline void Join(const IntRect& rhs) {
+    // if we are empty, just assign
+    if (IsEmpty()) {
+      *this = rhs;
+    }
+    else {
+      if (rhs.value[0] < value[0]) value[0] = rhs.value[0];
+      if (rhs.value[1] < value[1]) value[1] = rhs.value[1];
+      if (rhs.value[2] > value[2]) value[2] = rhs.value[2];
+      if (rhs.value[3] > value[3]) value[3] = rhs.value[3];
+    }
+  }
+
+  inline void Join(const Point& p) {
+    // if we are empty, just assign
+    if (IsEmpty()) {
+      *this = { (int)std::floor(p.x), (int)std::floor(p.y), (int)std::ceil(p.x), (int)std::ceil(p.y) };
+    }
+    else {
+      if ((int)std::floor(p.x) < value[0]) value[0] = (int)std::floor(p.x);
+      if ((int)std::floor(p.y) < value[1]) value[1] = (int)std::floor(p.y);
+      if ((int)std::ceil(p.x) > value[2]) value[2] = (int)std::ceil(p.x);
+      if ((int)std::ceil(p.y) > value[3]) value[3] = (int)std::ceil(p.y);
+    }
+  }
+
+  inline bool Contains(const Point& p) const {
+    return p.x >= left && p.x <= right &&
+      p.y >= top && p.y <= bottom;
+  }
+
+  inline bool Contains(const IntRect& r) const {
+    return left <= r.left && top <= r.top &&
+      right >= r.right && bottom >= r.bottom;
+  }
+
+  inline bool Intersects(const IntRect& rhs) const {
+    // Since this is mostly used for pixel operations, we only count
+    // intersections that have width and height >= 1.
+    return !(rhs.left > right - 1 ||
+             rhs.right < left ||
+             rhs.top > bottom - 1 ||
+             rhs.bottom < top);
+  }
+
+  inline IntRect Intersect(const IntRect& other) const {
+    return{ (left         < other.left) ? other.left   : left,
+            (top          < other.top)  ? other.top    : top,
+            (other.right  < right)      ? other.right  : right,
+            (other.bottom < bottom)     ? other.bottom : bottom };
+  }
+
+  friend inline bool operator==(const IntRect& a, const IntRect& b) {
+    return !memcmp(&a, &b, sizeof(a));
+  }
+
+  friend inline bool operator!=(const IntRect& a, const IntRect& b) {
+    return !(a == b);
+  }
+};
+
+///
+/// Rounded Rectangle Helper
+///
+struct UExport RoundedRect {
+  Rect rect;
+  float radii_x[4];
+  float radii_y[4];
+
+  void SetEmpty();
+
+  bool IsRounded() const;
+
+  // Negative is inside, positive is outside.
+  float GetSignedDistance(const Point& p) const;
+
+  // Returns whether or not intersection is found. Can fail if the resulting
+  // geometry is not a rounded rectangle.
+  bool Intersect(const RoundedRect& other, RoundedRect& result) const;
+
+  void SnapToPixels();
+
+  Rect CalculateInterior() const;
+};
+
+}  // namespace ultralight
diff --git a/engine/inc/Ultralight/JavaScript.h b/engine/inc/Ultralight/JavaScript.h
new file mode 100644
index 00000000..bf6faedd
--- /dev/null
+++ b/engine/inc/Ultralight/JavaScript.h
@@ -0,0 +1,39 @@
+///
+/// @file View.h
+///
+/// @brief The header for the View class.
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+#include <JavaScriptCore/JavaScript.h>
+#include <Ultralight/Defines.h>
+#include <Ultralight/RefPtr.h>
+#include <Ultralight/String.h>
+
+namespace ultralight {
+
+///
+/// This class wraps a JSContextRef (a JavaScript execution context for use
+/// with JavaScriptCore) and locks the context on the current thread for the
+/// duration of its lifetime.
+///
+class UExport JSContext : public RefCounted {
+public:
+  /// Get the underlying JSContextRef for use with JavaScriptCore C API
+  virtual JSContextRef ctx() = 0;
+
+  /// Typecast to a JSContextRef for use with JavaScriptCore C API
+  operator JSContextRef();
+
+protected:
+  virtual ~JSContext();
+};
+
+}  // namespace ultralight
diff --git a/engine/inc/Ultralight/KeyCodes.h b/engine/inc/Ultralight/KeyCodes.h
new file mode 100644
index 00000000..3a4a7451
--- /dev/null
+++ b/engine/inc/Ultralight/KeyCodes.h
@@ -0,0 +1,527 @@
+///
+/// @file KeyCodes.h
+///
+/// @brief The header for the KeyCodes definitions.
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+
+namespace ultralight {
+
+///
+/// Namespace containing all the key-code definitions for KeyboardEvent.
+/// Most of these correspond directly to the key-code values on Windows.
+  ///
+namespace KeyCodes {
+
+  // GK_BACK (08) BACKSPACE key
+  const int GK_BACK = 0x08;
+
+  // GK_TAB (09) TAB key
+  const int GK_TAB = 0x09;
+
+  // GK_CLEAR (0C) CLEAR key
+  const int GK_CLEAR = 0x0C;
+
+  // GK_RETURN (0D)
+  const int GK_RETURN = 0x0D;
+
+  // GK_SHIFT (10) SHIFT key
+  const int GK_SHIFT = 0x10;
+
+  // GK_CONTROL (11) CTRL key
+  const int GK_CONTROL = 0x11;
+
+  // GK_MENU (12) ALT key
+  const int GK_MENU = 0x12;
+
+  // GK_PAUSE (13) PAUSE key
+  const int GK_PAUSE = 0x13;
+
+  // GK_CAPITAL (14) CAPS LOCK key
+  const int GK_CAPITAL = 0x14;
+
+  // GK_KANA (15) Input Method Editor (IME) Kana mode
+  const int GK_KANA = 0x15;
+
+  // GK_HANGUEL (15) IME Hanguel mode (maintained for compatibility; use GK_HANGUL)
+  // GK_HANGUL (15) IME Hangul mode
+  const int GK_HANGUL = 0x15;
+
+  // GK_JUNJA (17) IME Junja mode
+  const int GK_JUNJA = 0x17;
+
+  // GK_FINAL (18) IME final mode
+  const int GK_FINAL = 0x18;
+
+  // GK_HANJA (19) IME Hanja mode
+  const int GK_HANJA = 0x19;
+
+  // GK_KANJI (19) IME Kanji mode
+  const int GK_KANJI = 0x19;
+
+  // GK_ESCAPE (1B) ESC key
+  const int GK_ESCAPE = 0x1B;
+
+  // GK_CONVERT (1C) IME convert
+  const int GK_CONVERT = 0x1C;
+
+  // GK_NONCONVERT (1D) IME nonconvert
+  const int GK_NONCONVERT = 0x1D;
+
+  // GK_ACCEPT (1E) IME accept
+  const int GK_ACCEPT = 0x1E;
+
+  // GK_MODECHANGE (1F) IME mode change request
+  const int GK_MODECHANGE = 0x1F;
+
+  // GK_SPACE (20) SPACEBAR
+  const int GK_SPACE = 0x20;
+
+  // GK_PRIOR (21) PAGE UP key
+  const int GK_PRIOR = 0x21;
+
+  // GK_NEXT (22) PAGE DOWN key
+  const int GK_NEXT = 0x22;
+
+  // GK_END (23) END key
+  const int GK_END = 0x23;
+
+  // GK_HOME (24) HOME key
+  const int GK_HOME = 0x24;
+
+  // GK_LEFT (25) LEFT ARROW key
+  const int GK_LEFT = 0x25;
+
+  // GK_UP (26) UP ARROW key
+  const int GK_UP = 0x26;
+
+  // GK_RIGHT (27) RIGHT ARROW key
+  const int GK_RIGHT = 0x27;
+
+  // GK_DOWN (28) DOWN ARROW key
+  const int GK_DOWN = 0x28;
+
+  // GK_SELECT (29) SELECT key
+  const int GK_SELECT = 0x29;
+
+  // GK_PRINT (2A) PRINT key
+  const int GK_PRINT = 0x2A;
+
+  // GK_EXECUTE (2B) EXECUTE key
+  const int GK_EXECUTE = 0x2B;
+
+  // GK_SNAPSHOT (2C) PRINT SCREEN key
+  const int GK_SNAPSHOT = 0x2C;
+
+  // GK_INSERT (2D) INS key
+  const int GK_INSERT = 0x2D;
+
+  // GK_DELETE (2E) DEL key
+  const int GK_DELETE = 0x2E;
+
+  // GK_HELP (2F) HELP key
+  const int GK_HELP = 0x2F;
+
+  // (30) 0 key
+  const int GK_0 = 0x30;
+
+  // (31) 1 key
+  const int GK_1 = 0x31;
+
+  // (32) 2 key
+  const int GK_2 = 0x32;
+
+  // (33) 3 key
+  const int GK_3 = 0x33;
+
+  // (34) 4 key
+  const int GK_4 = 0x34;
+
+  // (35) 5 key;
+  const int GK_5 = 0x35;
+
+  // (36) 6 key
+  const int GK_6 = 0x36;
+
+  // (37) 7 key
+  const int GK_7 = 0x37;
+
+  // (38) 8 key
+  const int GK_8 = 0x38;
+
+  // (39) 9 key
+  const int GK_9 = 0x39;
+
+  // (41) A key
+  const int GK_A = 0x41;
+
+  // (42) B key
+  const int GK_B = 0x42;
+
+  // (43) C key
+  const int GK_C = 0x43;
+
+  // (44) D key
+  const int GK_D = 0x44;
+
+  // (45) E key
+  const int GK_E = 0x45;
+
+  // (46) F key
+  const int GK_F = 0x46;
+
+  // (47) G key
+  const int GK_G = 0x47;
+
+  // (48) H key
+  const int GK_H = 0x48;
+
+  // (49) I key
+  const int GK_I = 0x49;
+
+  // (4A) J key
+  const int GK_J = 0x4A;
+
+  // (4B) K key
+  const int GK_K = 0x4B;
+
+  // (4C) L key
+  const int GK_L = 0x4C;
+
+  // (4D) M key
+  const int GK_M = 0x4D;
+
+  // (4E) N key
+  const int GK_N = 0x4E;
+
+  // (4F) O key
+  const int GK_O = 0x4F;
+
+  // (50) P key
+  const int GK_P = 0x50;
+
+  // (51) Q key
+  const int GK_Q = 0x51;
+
+  // (52) R key
+  const int GK_R = 0x52;
+
+  // (53) S key
+  const int GK_S = 0x53;
+
+  // (54) T key
+  const int GK_T = 0x54;
+
+  // (55) U key
+  const int GK_U = 0x55;
+
+  // (56) V key
+  const int GK_V = 0x56;
+
+  // (57) W key
+  const int GK_W = 0x57;
+
+  // (58) X key
+  const int GK_X = 0x58;
+
+  // (59) Y key
+  const int GK_Y = 0x59;
+
+  // (5A) Z key
+  const int GK_Z = 0x5A;
+
+  // GK_LWIN (5B) Left Windows key (Microsoft Natural keyboard)
+  const int GK_LWIN = 0x5B;
+
+  // GK_RWIN (5C) Right Windows key (Natural keyboard)
+  const int GK_RWIN = 0x5C;
+
+  // GK_APPS (5D) Applications key (Natural keyboard)
+  const int GK_APPS = 0x5D;
+
+  // GK_SLEEP (5F) Computer Sleep key
+  const int GK_SLEEP = 0x5F;
+
+  // GK_NUMPAD0 (60) Numeric keypad 0 key
+  const int GK_NUMPAD0 = 0x60;
+
+  // GK_NUMPAD1 (61) Numeric keypad 1 key
+  const int GK_NUMPAD1 = 0x61;
+
+  // GK_NUMPAD2 (62) Numeric keypad 2 key
+  const int GK_NUMPAD2 = 0x62;
+
+  // GK_NUMPAD3 (63) Numeric keypad 3 key
+  const int GK_NUMPAD3 = 0x63;
+
+  // GK_NUMPAD4 (64) Numeric keypad 4 key
+  const int GK_NUMPAD4 = 0x64;
+
+  // GK_NUMPAD5 (65) Numeric keypad 5 key
+  const int GK_NUMPAD5 = 0x65;
+
+  // GK_NUMPAD6 (66) Numeric keypad 6 key
+  const int GK_NUMPAD6 = 0x66;
+
+  // GK_NUMPAD7 (67) Numeric keypad 7 key
+  const int GK_NUMPAD7 = 0x67;
+
+  // GK_NUMPAD8 (68) Numeric keypad 8 key
+  const int GK_NUMPAD8 = 0x68;
+
+  // GK_NUMPAD9 (69) Numeric keypad 9 key
+  const int GK_NUMPAD9 = 0x69;
+
+  // GK_MULTIPLY (6A) Multiply key
+  const int GK_MULTIPLY = 0x6A;
+
+  // GK_ADD (6B) Add key
+  const int GK_ADD = 0x6B;
+
+  // GK_SEPARATOR (6C) Separator key
+  const int GK_SEPARATOR = 0x6C;
+
+  // GK_SUBTRACT (6D) Subtract key
+  const int GK_SUBTRACT = 0x6D;
+
+  // GK_DECIMAL (6E) Decimal key
+  const int GK_DECIMAL = 0x6E;
+
+  // GK_DIVIDE (6F) Divide key
+  const int GK_DIVIDE = 0x6F;
+
+  // GK_F1 (70) F1 key
+  const int GK_F1 = 0x70;
+
+  // GK_F2 (71) F2 key
+  const int GK_F2 = 0x71;
+
+  // GK_F3 (72) F3 key
+  const int GK_F3 = 0x72;
+
+  // GK_F4 (73) F4 key
+  const int GK_F4 = 0x73;
+
+  // GK_F5 (74) F5 key
+  const int GK_F5 = 0x74;
+
+  // GK_F6 (75) F6 key
+  const int GK_F6 = 0x75;
+
+  // GK_F7 (76) F7 key
+  const int GK_F7 = 0x76;
+
+  // GK_F8 (77) F8 key
+  const int GK_F8 = 0x77;
+
+  // GK_F9 (78) F9 key
+  const int GK_F9 = 0x78;
+
+  // GK_F10 (79) F10 key
+  const int GK_F10 = 0x79;
+
+  // GK_F11 (7A) F11 key
+  const int GK_F11 = 0x7A;
+
+  // GK_F12 (7B) F12 key
+  const int GK_F12 = 0x7B;
+
+  // GK_F13 (7C) F13 key
+  const int GK_F13 = 0x7C;
+
+  // GK_F14 (7D) F14 key
+  const int GK_F14 = 0x7D;
+
+  // GK_F15 (7E) F15 key
+  const int GK_F15 = 0x7E;
+
+  // GK_F16 (7F) F16 key
+  const int GK_F16 = 0x7F;
+
+  // GK_F17 (80H) F17 key
+  const int GK_F17 = 0x80;
+
+  // GK_F18 (81H) F18 key
+  const int GK_F18 = 0x81;
+
+  // GK_F19 (82H) F19 key
+  const int GK_F19 = 0x82;
+
+  // GK_F20 (83H) F20 key
+  const int GK_F20 = 0x83;
+
+  // GK_F21 (84H) F21 key
+  const int GK_F21 = 0x84;
+
+  // GK_F22 (85H) F22 key
+  const int GK_F22 = 0x85;
+
+  // GK_F23 (86H) F23 key
+  const int GK_F23 = 0x86;
+
+  // GK_F24 (87H) F24 key
+  const int GK_F24 = 0x87;
+
+  // GK_NUMLOCK (90) NUM LOCK key
+  const int GK_NUMLOCK = 0x90;
+
+  // GK_SCROLL (91) SCROLL LOCK key
+  const int GK_SCROLL = 0x91;
+
+  // GK_LSHIFT (A0) Left SHIFT key
+  const int GK_LSHIFT = 0xA0;
+
+  // GK_RSHIFT (A1) Right SHIFT key
+  const int GK_RSHIFT = 0xA1;
+
+  // GK_LCONTROL (A2) Left CONTROL key
+  const int GK_LCONTROL = 0xA2;
+
+  // GK_RCONTROL (A3) Right CONTROL key
+  const int GK_RCONTROL = 0xA3;
+
+  // GK_LMENU (A4) Left MENU key
+  const int GK_LMENU = 0xA4;
+
+  // GK_RMENU (A5) Right MENU key
+  const int GK_RMENU = 0xA5;
+
+  // GK_BROWSER_BACK (A6) Windows 2000/XP: Browser Back key
+  const int GK_BROWSER_BACK = 0xA6;
+
+  // GK_BROWSER_FORWARD (A7) Windows 2000/XP: Browser Forward key
+  const int GK_BROWSER_FORWARD = 0xA7;
+
+  // GK_BROWSER_REFRESH (A8) Windows 2000/XP: Browser Refresh key
+  const int GK_BROWSER_REFRESH = 0xA8;
+
+  // GK_BROWSER_STOP (A9) Windows 2000/XP: Browser Stop key
+  const int GK_BROWSER_STOP = 0xA9;
+
+  // GK_BROWSER_SEARCH (AA) Windows 2000/XP: Browser Search key
+  const int GK_BROWSER_SEARCH = 0xAA;
+
+  // GK_BROWSER_FAVORITES (AB) Windows 2000/XP: Browser Favorites key
+  const int GK_BROWSER_FAVORITES = 0xAB;
+
+  // GK_BROWSER_HOME (AC) Windows 2000/XP: Browser Start and Home key
+  const int GK_BROWSER_HOME = 0xAC;
+
+  // GK_VOLUME_MUTE (AD) Windows 2000/XP: Volume Mute key
+  const int GK_VOLUME_MUTE = 0xAD;
+
+  // GK_VOLUME_DOWN (AE) Windows 2000/XP: Volume Down key
+  const int GK_VOLUME_DOWN = 0xAE;
+
+  // GK_VOLUME_UP (AF) Windows 2000/XP: Volume Up key
+  const int GK_VOLUME_UP = 0xAF;
+
+  // GK_MEDIA_NEXT_TRACK (B0) Windows 2000/XP: Next Track key
+  const int GK_MEDIA_NEXT_TRACK = 0xB0;
+
+  // GK_MEDIA_PREV_TRACK (B1) Windows 2000/XP: Previous Track key
+  const int GK_MEDIA_PREV_TRACK = 0xB1;
+
+  // GK_MEDIA_STOP (B2) Windows 2000/XP: Stop Media key
+  const int GK_MEDIA_STOP = 0xB2;
+
+  // GK_MEDIA_PLAY_PAUSE (B3) Windows 2000/XP: Play/Pause Media key
+  const int GK_MEDIA_PLAY_PAUSE = 0xB3;
+
+  // GK_LAUNCH_MAIL (B4) Windows 2000/XP: Start Mail key
+  const int GK_MEDIA_LAUNCH_MAIL = 0xB4;
+
+  // GK_LAUNCH_MEDIA_SELECT (B5) Windows 2000/XP: Select Media key
+  const int GK_MEDIA_LAUNCH_MEDIA_SELECT = 0xB5;
+
+  // GK_LAUNCH_APP1 (B6) Windows 2000/XP: Start Application 1 key
+  const int GK_MEDIA_LAUNCH_APP1 = 0xB6;
+
+  // GK_LAUNCH_APP2 (B7) Windows 2000/XP: Start Application 2 key
+  const int GK_MEDIA_LAUNCH_APP2 = 0xB7;
+
+  // GK_OEM_1 (BA) Used for miscellaneous characters; it can vary by keyboard. Windows 2000/XP: For the US standard keyboard, the ';:' key
+  const int GK_OEM_1 = 0xBA;
+
+  // GK_OEM_PLUS (BB) Windows 2000/XP: For any country/region, the '+' key
+  const int GK_OEM_PLUS = 0xBB;
+
+  // GK_OEM_COMMA (BC) Windows 2000/XP: For any country/region, the ',' key
+  const int GK_OEM_COMMA = 0xBC;
+
+  // GK_OEM_MINUS (BD) Windows 2000/XP: For any country/region, the '-' key
+  const int GK_OEM_MINUS = 0xBD;
+
+  // GK_OEM_PERIOD (BE) Windows 2000/XP: For any country/region, the '.' key
+  const int GK_OEM_PERIOD = 0xBE;
+
+  // GK_OEM_2 (BF) Used for miscellaneous characters; it can vary by keyboard. Windows 2000/XP: For the US standard keyboard, the '/?' key
+  const int GK_OEM_2 = 0xBF;
+
+  // GK_OEM_3 (C0) Used for miscellaneous characters; it can vary by keyboard. Windows 2000/XP: For the US standard keyboard, the '`~' key
+  const int GK_OEM_3 = 0xC0;
+
+  // GK_OEM_4 (DB) Used for miscellaneous characters; it can vary by keyboard. Windows 2000/XP: For the US standard keyboard, the '[{' key
+  const int GK_OEM_4 = 0xDB;
+
+  // GK_OEM_5 (DC) Used for miscellaneous characters; it can vary by keyboard. Windows 2000/XP: For the US standard keyboard, the '\|' key
+  const int GK_OEM_5 = 0xDC;
+
+  // GK_OEM_6 (DD) Used for miscellaneous characters; it can vary by keyboard. Windows 2000/XP: For the US standard keyboard, the ']}' key
+  const int GK_OEM_6 = 0xDD;
+
+  // GK_OEM_7 (DE) Used for miscellaneous characters; it can vary by keyboard. Windows 2000/XP: For the US standard keyboard, the 'single-quote/double-quote' key
+  const int GK_OEM_7 = 0xDE;
+
+  // GK_OEM_8 (DF) Used for miscellaneous characters; it can vary by keyboard.
+  const int GK_OEM_8 = 0xDF;
+
+  // GK_OEM_102 (E2) Windows 2000/XP: Either the angle bracket key or the backslash key on the RT 102-key keyboard
+  const int GK_OEM_102 = 0xE2;
+
+  // GK_PROCESSKEY (E5) Windows 95/98/Me, Windows NT 4.0, Windows 2000/XP: IME PROCESS key
+  const int GK_PROCESSKEY = 0xE5;
+
+  // GK_PACKET (E7) Windows 2000/XP: Used to pass Unicode characters as if they were keystrokes. The GK_PACKET key is the low word of a 32-bit Virtual Key value used for non-keyboard input methods. For more information, see Remark in KEYBDINPUT,SendInput, WM_KEYDOWN, and WM_KEYUP
+  const int GK_PACKET = 0xE7;
+
+  // GK_ATTN (F6) Attn key
+  const int GK_ATTN = 0xF6;
+
+  // GK_CRSEL (F7) CrSel key
+  const int GK_CRSEL = 0xF7;
+
+  // GK_EXSEL (F8) ExSel key
+  const int GK_EXSEL = 0xF8;
+
+  // GK_EREOF (F9) Erase EOF key
+  const int GK_EREOF = 0xF9;
+
+  // GK_PLAY (FA) Play key
+  const int GK_PLAY = 0xFA;
+
+  // GK_ZOOM (FB) Zoom key
+  const int GK_ZOOM = 0xFB;
+
+  // GK_NONAME (FC) Reserved for future use
+  const int GK_NONAME = 0xFC;
+
+  // GK_PA1 (FD) PA1 key
+  const int GK_PA1 = 0xFD;
+
+  // GK_OEM_CLEAR (FE) Clear key
+  const int GK_OEM_CLEAR = 0xFE;
+
+  const int GK_UNKNOWN = 0;
+
+} // namespace KeyCodes
+
+} // namespace ultralight
diff --git a/engine/inc/Ultralight/KeyEvent.h b/engine/inc/Ultralight/KeyEvent.h
new file mode 100644
index 00000000..ce8e8073
--- /dev/null
+++ b/engine/inc/Ultralight/KeyEvent.h
@@ -0,0 +1,180 @@
+///
+/// @file KeyEvent.h
+///
+/// @brief The header for the KeyEvent class.
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+#include <Ultralight/Defines.h>
+#include <Ultralight/KeyCodes.h>
+#include <Ultralight/String.h>
+#ifdef __OBJC__
+#import <AppKit/NSEvent.h>
+#endif
+
+namespace ultralight {
+
+///
+/// @brief  A generic keyboard event that can be created from a platform event
+///         or synthesized from scratch.
+///
+/// @see    View::FireKeyEvent
+///
+class UExport KeyEvent {
+public:
+  ///
+  /// The various KeyEvent types.
+  ///
+  enum Type {
+    ///
+    /// Key-Down event type. (Does not trigger accelerator commands in WebCore)
+    ///
+    /// @NOTE: You should probably use RawKeyDown instead when a physical key
+    ///        is pressed. This member is only here for historic compatibility
+    ///        with WebCore's key event types.
+    ///
+    kType_KeyDown,
+
+    ///
+    /// Key-Up event type. Use this when a physical key is released.
+    ///
+    kType_KeyUp,
+
+    ///
+    /// Raw Key-Down type. Use this when a physical key is pressed.
+    ///
+    /// @NOTE: You should use RawKeyDown for physical key presses since it
+    ///        allows WebCore to do additional command translation.
+    ///
+    kType_RawKeyDown,
+
+    ///
+    /// Character input event type. Use this when the OS generates text from
+    /// a physical key being pressed (eg, WM_CHAR on Windows).
+    ///
+    kType_Char,
+  };
+
+  ///
+  /// Creates an empty KeyEvent, you will need to initialize its members
+  /// yourself. This is useful for synthesizing your own keyboard events.
+  ///
+  KeyEvent();
+
+#ifdef _WIN32
+  ///
+  /// Create a KeyEvent directly from a Windows keyboard event.
+  ///
+  KeyEvent(Type type, uintptr_t wparam, intptr_t lparam, bool is_system_key);
+#endif
+
+#ifdef __OBJC__
+  ///
+  /// Create a KeyEvent directly from a macOS NSEvent.
+  ///
+  KeyEvent(NSEvent* evt);
+#endif
+
+  ///
+  /// An enumeration of the different keyboard modifiers.
+  ///
+  enum Modifiers : uint8_t {
+    /// Whether or not an ALT key is down
+    kMod_AltKey = 1 << 0,
+
+    /// Whether or not a Control key is down
+    kMod_CtrlKey = 1 << 1,
+
+    /// Whether or not a meta key (Command-key on Mac, Windows-key on Win) is down
+    kMod_MetaKey = 1 << 2,
+
+    /// Whether or not a Shift key is down
+    kMod_ShiftKey = 1 << 3,
+  };
+
+  ///
+  // The type of this KeyEvent
+  ///
+  Type type;
+
+  ///
+  /// The current state of the keyboard. Modifiers may be OR'd together to
+  /// represent multiple values.
+  ///
+  unsigned modifiers;
+
+  ///
+  // The virtual key-code associated with this keyboard event. This is either
+  // directly from the event (ie, WPARAM on Windows) or via a mapping function.
+  // You can see a full list of the possible virtual key-codes in
+  // KeyboardCodes.h
+  ///
+  int virtual_key_code;
+
+  ///
+  /// The actual key-code generated by the platform. The DOM spec primarily
+  /// uses Windows-equivalent codes (hence virtualKeyCode above) but it helps to
+  /// also specify the platform-specific key-code as well.
+  ///
+  int native_key_code;
+
+  ///
+  /// This is a string identifying the key that was pressed. This can be
+  /// generated from the virtual_key_code via the GetKeyIdentifierFromVirtualKeyCode()
+  /// utility function. You can find the full list of key identifiers at:
+  ///   <https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/keyset.html>
+  ///
+  String key_identifier;
+
+  ///
+  /// The actual text generated by this keyboard event. This is usually only a
+  /// single character.
+  ///
+  String text;
+
+  ///
+  /// The text generated by this keyboard event before all modifiers except
+  /// shift are applied. This is used internally for working out shortcut keys.
+  /// This is usually only a single character.
+  ///
+  String unmodified_text;
+
+  ///
+  /// Whether or not this is a keypad event.
+  ///
+  bool is_keypad;
+
+  ///
+  /// Whether or not this was generated as the result of an auto-repeat
+  /// (eg, holding down a key).
+  ///
+  bool is_auto_repeat;
+
+  ///
+  /// Whether or not the pressed key is a "system key". This is a Windows-only
+  /// concept and should be "false" for all non-Windows platforms. For more
+  /// information, see the following link:
+  ///   <http://msdn.microsoft.com/en-us/library/ms646286(VS.85).aspx>
+  bool is_system_key;
+};
+
+///
+/// Utility function for generating a key identifier string from a virtual
+/// key-code.
+///
+/// @param  virtual_key_code       The virtual key-code to generate the key
+///                                identifier from.
+///
+/// @param  key_identifier_result  The string to store the result in.
+///
+void UExport GetKeyIdentifierFromVirtualKeyCode(int virtual_key_code,
+  String& key_identifier_result);
+
+}  // namespace ultralight
diff --git a/engine/inc/Ultralight/Listener.h b/engine/inc/Ultralight/Listener.h
new file mode 100644
index 00000000..a6464633
--- /dev/null
+++ b/engine/inc/Ultralight/Listener.h
@@ -0,0 +1,287 @@
+///
+/// @file Listener.h
+///
+/// @brief The header for View listener interfaces.
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+#include <Ultralight/Defines.h>
+#include <Ultralight/String.h>
+#include <Ultralight/RefPtr.h>
+#include <Ultralight/Geometry.h>
+
+namespace ultralight {
+
+class View;
+
+///
+/// MessageSource types, @see ViewListener::OnAddConsoleMessage
+///
+enum MessageSource {
+  kMessageSource_XML = 0,
+  kMessageSource_JS,
+  kMessageSource_Network,
+  kMessageSource_ConsoleAPI,
+  kMessageSource_Storage,
+  kMessageSource_AppCache,
+  kMessageSource_Rendering,
+  kMessageSource_CSS,
+  kMessageSource_Security,
+  kMessageSource_ContentBlocker,
+  kMessageSource_Other,
+};
+
+///
+/// MessageLevel types, @see ViewListener::OnAddConsoleMessage
+///
+enum MessageLevel {
+  kMessageLevel_Log = 1,
+  kMessageLevel_Warning = 2,
+  kMessageLevel_Error = 3,
+  kMessageLevel_Debug = 4,
+  kMessageLevel_Info = 5,
+};
+
+///
+/// Cursor types, @see ViewListener::OnChangeCursor
+///
+enum Cursor {
+  kCursor_Pointer = 0,
+  kCursor_Cross,
+  kCursor_Hand,
+  kCursor_IBeam,
+  kCursor_Wait,
+  kCursor_Help,
+  kCursor_EastResize,
+  kCursor_NorthResize,
+  kCursor_NorthEastResize,
+  kCursor_NorthWestResize,
+  kCursor_SouthResize,
+  kCursor_SouthEastResize,
+  kCursor_SouthWestResize,
+  kCursor_WestResize,
+  kCursor_NorthSouthResize,
+  kCursor_EastWestResize,
+  kCursor_NorthEastSouthWestResize,
+  kCursor_NorthWestSouthEastResize,
+  kCursor_ColumnResize,
+  kCursor_RowResize,
+  kCursor_MiddlePanning,
+  kCursor_EastPanning,
+  kCursor_NorthPanning,
+  kCursor_NorthEastPanning,
+  kCursor_NorthWestPanning,
+  kCursor_SouthPanning,
+  kCursor_SouthEastPanning,
+  kCursor_SouthWestPanning,
+  kCursor_WestPanning,
+  kCursor_Move,
+  kCursor_VerticalText,
+  kCursor_Cell,
+  kCursor_ContextMenu,
+  kCursor_Alias,
+  kCursor_Progress,
+  kCursor_NoDrop,
+  kCursor_Copy,
+  kCursor_None,
+  kCursor_NotAllowed,
+  kCursor_ZoomIn,
+  kCursor_ZoomOut,
+  kCursor_Grab,
+  kCursor_Grabbing,
+  kCursor_Custom
+};
+
+///
+/// @brief  Interface for View-related events
+///
+/// @note   For more info @see View::set_view_listener
+///
+class UExport ViewListener {
+public:
+  virtual ~ViewListener() {}
+
+  ///
+  /// Called when the page title changes
+  ///
+  virtual void OnChangeTitle(ultralight::View* caller,
+                             const String& title) {}
+
+  ///
+  /// Called when the page URL changes
+  ///
+  virtual void OnChangeURL(ultralight::View* caller,
+                           const String& url) {}
+
+  ///
+  /// Called when the tooltip changes (usually as result of a mouse hover)
+  ///
+  virtual void OnChangeTooltip(ultralight::View* caller,
+                               const String& tooltip) {}
+
+  ///
+  /// Called when the mouse cursor changes
+  ///
+  virtual void OnChangeCursor(ultralight::View* caller,
+                              Cursor cursor) {}
+
+  ///
+  /// Called when a message is added to the console (useful for errors / debug)
+  ///
+  virtual void OnAddConsoleMessage(ultralight::View* caller,
+                                   MessageSource source,
+                                   MessageLevel level,
+                                   const String& message,
+                                   uint32_t line_number,
+                                   uint32_t column_number,
+                                   const String& source_id) {}
+
+  ///
+  /// Called when the page wants to create a new View.
+  ///
+  /// This is usually the result of a user clicking a link with target="_blank"
+  /// or by JavaScript calling window.open(url).
+  ///
+  /// To allow creation of these new Views, you should create a new View in
+  /// this callback (eg, Renderer::CreateView()), resize it to your container,
+  /// and return it. You are responsible for displaying the returned View.
+  ///
+  /// @param  caller      The View that called this event.
+  ///
+  /// @param  opener_url  The URL of the page that initiated this request.
+  ///
+  /// @param  target_url  The URL that the new View will navigate to.
+  ///
+  /// @param  is_popup    Whether or not this was triggered by window.open().
+  ///
+  /// @param  popup_rect  Popups can optionally request certain dimensions and
+  ///                     coordinates via window.open(). You can choose to
+  ///                     respect these or not by resizing/moving the View to
+  ///                     this rect.
+  ///
+  /// @return  Returns a RefPtr<> to a created View to use to satisfy the
+  ///          the request (or return nullptr if you want to block the action).
+  ///
+  virtual RefPtr<View> OnCreateChildView(ultralight::View* caller,
+                                         const String& opener_url,
+                                         const String& target_url,
+                                         bool is_popup,
+                                         const IntRect& popup_rect);
+};
+
+///
+/// @brief  Interface for Load-related events
+///
+/// @note   For more info @see View::set_load_listener
+///
+class UExport LoadListener {
+public:
+  virtual ~LoadListener() {}
+
+  ///
+  /// Called when the page begins loading a new URL into a frame.
+  ///
+  /// @param  frame_id       A unique ID for the frame.
+  ///
+  /// @param  is_main_frame  Whether or not this is the main frame.
+  ///
+  /// @param  url            The URL for the load.
+  ///
+  virtual void OnBeginLoading(ultralight::View* caller,
+                              uint64_t frame_id,
+                              bool is_main_frame,
+                              const String& url) {}
+
+  ///
+  /// Called when the page finishes loading a URL into a frame.
+  ///
+  /// @param  frame_id       A unique ID for the frame.
+  ///
+  /// @param  is_main_frame  Whether or not this is the main frame.
+  ///
+  /// @param  url            The URL for the load.
+  ///
+  virtual void OnFinishLoading(ultralight::View* caller,
+                               uint64_t frame_id,
+                               bool is_main_frame,
+                               const String& url) {}
+
+  ///
+  /// Called when an error occurs while loading a URL into a frame.
+  ///
+  /// @param  frame_id       A unique ID for the frame.
+  ///
+  /// @param  is_main_frame  Whether or not this is the main frame.
+  ///
+  /// @param  url            The URL for the load.
+  ///
+  /// @param  description    A human-readable description of the error.
+  ///
+  /// @param  error_domain   The name of the module that triggered the error.
+  ///
+  /// @param  error_code     Internal error code generated by the module.
+  ///
+  virtual void OnFailLoading(ultralight::View* caller,
+                             uint64_t frame_id,
+                             bool is_main_frame,
+                             const String& url,
+                             const String& description,
+                             const String& error_domain,
+                             int error_code) {}
+
+  ///
+  /// Called when the JavaScript window object is reset for a new page load.
+  ///
+  /// This is called before any scripts are executed on the page and is the
+  /// earliest time to setup any initial JavaScript state or bindings.
+  ///
+  /// The document is not guaranteed to be loaded/parsed at this point. If
+  /// you need to make any JavaScript calls that are dependent on DOM elements
+  /// or scripts on the page, use OnDOMReady instead.
+  ///
+  /// The window object is lazily initialized (this will not be called on pages
+  /// with no scripts).
+  ///
+  /// @param  frame_id       A unique ID for the frame.
+  ///
+  /// @param  is_main_frame  Whether or not this is the main frame.
+  ///
+  /// @param  url            The URL for the load.
+  ///
+  virtual void OnWindowObjectReady(ultralight::View* caller,
+                                   uint64_t frame_id,
+                                   bool is_main_frame,
+                                   const String& url) {}
+
+  ///
+  /// Called when all JavaScript has been parsed and the document is ready.
+  ///
+  /// This is the best time to make any JavaScript calls that are dependent on
+  /// DOM elements or scripts on the page.
+  ///
+  /// @param  frame_id       A unique ID for the frame.
+  ///
+  /// @param  is_main_frame  Whether or not this is the main frame.
+  ///
+  /// @param  url            The URL for the load.
+  ///
+  virtual void OnDOMReady(ultralight::View* caller,
+                          uint64_t frame_id,
+                          bool is_main_frame,
+                          const String& url) {}
+
+  ///
+  /// Called when the session history (back/forward state) is modified.
+  ///
+  virtual void OnUpdateHistory(ultralight::View* caller) {}
+
+};
+
+}  // namespace ultralight
diff --git a/engine/inc/Ultralight/Matrix.h b/engine/inc/Ultralight/Matrix.h
new file mode 100644
index 00000000..f3292ada
--- /dev/null
+++ b/engine/inc/Ultralight/Matrix.h
@@ -0,0 +1,190 @@
+///
+/// @file Matrix.h
+///
+/// @brief The header for Matrix helpers
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+#include <Ultralight/Defines.h>
+#include <Ultralight/RefPtr.h>
+#include <Ultralight/Geometry.h>
+
+namespace ultralight {
+
+///
+/// 4x4 Matrix Helper
+///
+struct UExport Matrix4x4 {
+  ///
+  /// Raw 4x4 matrix as an array
+  ///
+  float data[16];
+
+  ///
+  /// Set to identity matrix.
+  ///
+  void SetIdentity();
+};
+
+///
+/// Transformation Matrix helper
+///
+struct UExport Matrix {
+#if defined(__x86_64__) || defined(_M_X64)
+#if defined(_MSC_VER)
+  __declspec(align(16)) typedef double Aligned4x4[4][4];
+#else
+  typedef double Aligned4x4[4][4] __attribute__((aligned(16)));
+#endif
+#else
+  typedef double Aligned4x4[4][4];
+#endif
+
+  Aligned4x4 data;
+
+  ///
+  /// Set to identity matrix.
+  ///
+  void SetIdentity();
+
+  ///
+  /// Set to an orthographic projection matrix suitable for use with our
+  /// vertex shaders. Optionally flip the y-coordinate space (eg, for OpenGL).
+  ///
+  void SetOrthographicProjection(double screen_width, double screen_height,
+    bool flip_y);
+
+  ///
+  /// Set to another matrix.
+  ///
+  void Set(const Matrix& other);
+
+  ///
+  /// Set to another matrix.
+  ///
+  void Set(const Matrix4x4& other);
+  
+  ///
+  /// Set from raw affine members.
+  ///
+  void Set(double a, double b, double c, double d, double e, double f);
+
+  ///
+  /// Set from raw 4x4 components.
+  ///
+  void Set(double m11, double m12, double m13, double m14,
+           double m21, double m22, double m23, double m24,
+           double m31, double m32, double m33, double m34,
+           double m41, double m42, double m43, double m44);
+
+  inline double m11() const { return data[0][0]; }
+  inline double m12() const { return data[0][1]; }
+  inline double m13() const { return data[0][2]; }
+  inline double m14() const { return data[0][3]; }
+  inline double m21() const { return data[1][0]; }
+  inline double m22() const { return data[1][1]; }
+  inline double m23() const { return data[1][2]; }
+  inline double m24() const { return data[1][3]; }
+  inline double m31() const { return data[2][0]; }
+  inline double m32() const { return data[2][1]; }
+  inline double m33() const { return data[2][2]; }
+  inline double m34() const { return data[2][3]; }
+  inline double m41() const { return data[3][0]; }
+  inline double m42() const { return data[3][1]; }
+  inline double m43() const { return data[3][2]; }
+  inline double m44() const { return data[3][3]; }
+
+  inline double a() const { return data[0][0]; }
+  inline double b() const { return data[0][1]; }
+  inline double c() const { return data[1][0]; }
+  inline double d() const { return data[1][1]; }
+  inline double e() const { return data[3][0]; }
+  inline double f() const { return data[3][1]; }
+
+  ///
+  /// Whether or not this is an identity matrix.
+  ///
+  bool IsIdentity() const;
+
+  ///
+  /// Whether or not this is an identity matrix or translation.
+  ///
+  bool IsIdentityOrTranslation() const;
+
+  ///
+  /// Whether or not this matrix uses only affine transformations.
+  ///
+  bool IsAffine() const;
+
+  ///
+  /// Whether or not this is an identity, translation, or non-negative
+  /// uniform scale.
+  ///
+  bool IsSimple() const;
+
+  ///
+  /// Translate by x and y.
+  ///
+  void Translate(double x, double y);
+
+  ///
+  /// Scale by x and y.
+  ///
+  void Scale(double x, double y);
+
+  /// 
+  /// Rotate matrix by theta (in degrees)
+  ///
+  void Rotate(double theta);
+
+  ///
+  /// Rotate matrix by x and y
+  ///
+  void Rotate(double x, double y);
+
+  ///
+  /// Transform (multiply) by another Matrix
+  ///
+  void Transform(const Matrix& other);
+
+  ///
+  /// Get the inverse of this matrix. May return false if not invertible.
+  ///
+  bool GetInverse(Matrix& result) const;
+
+  ///
+  /// Transform point by this matrix and get the result.
+  ///
+  Point Apply(const Point& p) const;
+
+  ///
+  /// Transform rect by this matrix and get the result as an axis-aligned rect.
+  ///
+  Rect Apply(const Rect& r) const;
+
+  ///
+  /// Get an integer hash of this matrix's members.
+  ///
+  uint32_t Hash() const;
+
+  ///
+  /// Get this matrix as unaligned 4x4 float components (for use passing to
+  /// GPU driver APIs). 
+  ///
+  Matrix4x4 GetMatrix4x4() const;
+};
+
+bool UExport operator==(const Matrix& a, const Matrix& b);
+bool UExport operator!=(const Matrix& a, const Matrix& b);
+
+bool UExport operator==(const Matrix4x4& a, const Matrix4x4& b);
+bool UExport operator!=(const Matrix4x4& a, const Matrix4x4& b);
+
+}  // namespace ultralight
diff --git a/engine/inc/Ultralight/MouseEvent.h b/engine/inc/Ultralight/MouseEvent.h
new file mode 100644
index 00000000..9b92f3d0
--- /dev/null
+++ b/engine/inc/Ultralight/MouseEvent.h
@@ -0,0 +1,77 @@
+///
+/// @file MouseEvent.h
+///
+/// @brief The header for the MouseEvent class.
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+#include <Ultralight/Defines.h>
+
+namespace ultralight {
+
+///
+/// @brief  A generic mouse event.
+///
+/// @note   @see View::FireMouseEvent
+///
+class MouseEvent {
+public:
+  ///
+  /// The various MouseEvent types.
+  ///
+  enum Type {
+	  ///
+    /// Mouse moved type
+	  ///
+    kType_MouseMoved,
+
+	  ///
+    /// Mouse button pressed type
+	  ///
+    kType_MouseDown,
+
+	  ///
+    /// Mouse button released type
+	  ///
+    kType_MouseUp,
+  };
+
+  ///
+  /// The various mouse button types.
+  ///
+  enum Button {
+    kButton_None = 0,
+    kButton_Left,
+    kButton_Middle,
+    kButton_Right,
+  };
+
+  ///
+  /// The type of this MouseEvent
+  ///
+  Type type;
+
+  ///
+  /// The current x-position of the mouse, relative to the View
+  ///
+  int x;
+
+  ///
+  /// The current y-position of the mouse, relative to the View
+  ///
+  int y;
+
+  ///
+  /// The mouse button that was pressed/released, if any.
+  ///
+  Button button;
+};
+
+}  // namespace ultralight
diff --git a/engine/inc/Ultralight/RefPtr.h b/engine/inc/Ultralight/RefPtr.h
new file mode 100644
index 00000000..1859b2aa
--- /dev/null
+++ b/engine/inc/Ultralight/RefPtr.h
@@ -0,0 +1,538 @@
+///
+/// @file RefPtr.h
+///
+/// @brief The header for all ref-counting utilities.
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+/*
+* Portions of the below code are derived from 'RefPtr.h' from Apple's WTF,
+* with the following license header:
+*
+* Copyright (C) 2013-2014 Apple Inc. All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions
+* are met:
+* 1. Redistributions of source code must retain the above copyright
+*    notice, this list of conditions and the following disclaimer.
+* 2. Redistributions in binary form must reproduce the above copyright
+*    notice, this list of conditions and the following disclaimer in the
+*    documentation and/or other materials provided with the distribution.
+*
+* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+* THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#pragma once
+#include <Ultralight/Defines.h>
+#include <assert.h>
+#include <utility>
+
+namespace ultralight {
+  
+///
+/// @brief  Interface for all ref-counted objects that will be managed using
+///         the Ref<> and RefPtr<> smart pointers.
+///
+class UExport RefCounted {
+ public:
+  virtual void AddRef() const = 0;
+  virtual void Release() const = 0;
+  virtual int ref_count() const = 0;
+ protected:
+  virtual ~RefCounted();
+};
+
+inline void adopted(const void*) { }
+
+template<typename T> class Ref;
+template<typename T> class RefPtr;
+
+///
+/// @brief  Helper for wrapping new objects with the Ref smart pointer.
+///
+/// All ref-counted object are created with an initial ref-count of '1'.
+/// The AdoptRef() helper returns a Ref<T> without calling AddRef().
+/// This is used for creating new objects, like so:
+///
+///   Ref<Object> ref = AdoptRef(*new ObjectImpl());
+///
+template<typename T> Ref<T> AdoptRef(T&);
+
+///
+/// @brief  A non-nullable smart pointer.
+///
+/// This smart pointer automatically manages the lifetime of a RefCounted
+/// object. Also guarantees that the managed instance is not NULL.
+///
+template<typename T> class Ref {
+public:
+  ///
+  /// Destroy Ref (wll decrement ref-count by one)
+  ///
+  ~Ref()
+  {
+    if (instance_)
+      instance_->Release();
+  }
+
+  ///
+  /// Construct Ref from a reference. (Will increment ref-count by one)
+  ///
+  Ref(T& object)
+    : instance_(&object)
+  {
+    instance_->AddRef();
+  }
+
+  ///
+  /// Copy constructor.
+  ///
+  Ref(const Ref& other)
+    : instance_(other.instance_)
+  {
+    instance_->AddRef();
+  }
+
+  ///
+  /// Copy constructor with internal type conversion.
+  ///
+  template<typename U>
+  Ref(Ref<U>& other)
+    : instance_(other.ptr())
+  {
+    instance_->AddRef();
+  }
+
+  ///
+  /// Copy constructor with internal type conversion.
+  ///
+  template<typename U>
+  Ref(const Ref<U>& other)
+    : instance_(other.ptr())
+  {
+    instance_->AddRef();
+  }
+
+  ///
+  /// Move constructor.
+  ///
+  Ref(Ref&& other)
+    : instance_(&other.LeakRef())
+  {
+    assert(instance_);
+  }
+
+  ///
+  /// Move constructor.
+  ///
+  template<typename U>
+  Ref(Ref<U>&& other)
+    : instance_(&other.LeakRef())
+  {
+    assert(instance_);
+  }
+
+  Ref& operator=(T& object)
+  {
+    assert(instance_);
+    object.AddRef();
+    instance_->Release();
+    instance_ = &object;
+    assert(instance_);
+    return *this;
+  }
+
+  Ref& operator=(const Ref& other)
+  {
+    assert(instance_);
+    other.instance_->AddRef();
+    instance_->Release();
+    instance_ = other.instance_;
+    assert(instance_);
+    return *this;
+  }
+
+  template<typename U>
+  Ref& operator=(const Ref<U>& other)
+  {
+    assert(instance_);
+    other.instance_->AddRef();
+    instance_->Release();
+    instance_ = other.instance_;
+    assert(instance_);
+    return *this;
+  }
+
+  Ref& operator=(Ref&& reference)
+  {
+    assert(instance_);
+    instance_->Release();
+    instance_ = &reference.LeakRef();
+    assert(instance_);
+    return *this;
+  }
+
+  template<typename U> Ref& operator=(Ref<U>&& reference)
+  {
+    assert(instance_);
+    instance_->Release();
+    instance_ = &reference.LeakRef();
+    assert(instance_);
+    return *this;
+  }
+
+  const T* operator->() const { assert(instance_); return instance_; }
+  T* operator->() { assert(instance_); return instance_; }
+
+  ///
+  /// Get a pointer to wrapped object.
+  ///
+  const T* ptr() const { assert(instance_); return instance_; }
+
+  ///
+  /// Get a pointer to wrapped object.
+  ///
+  T* ptr() { assert(instance_); return instance_; }
+
+  ///
+  /// Get a reference to wrapped object.
+  ///
+  const T& get() const { assert(instance_); return *instance_; }
+
+  ///
+  /// Get a reference to wrapped object.
+  ///
+  T& get() { assert(instance_); return *instance_; }
+
+  operator T&() { assert(instance_); return *instance_; }
+  operator const T&() const { assert(instance_); return *instance_; }
+
+  template<typename U> Ref<T> Replace(Ref<U>&&);
+
+  T& LeakRef() {
+    assert(instance_);
+
+    T* result = std::move(instance_);
+    instance_ = std::forward<T*>(nullptr);
+    return *result;
+  }
+
+  friend inline bool operator==(const Ref& a, const Ref& b) {
+    return a.instance_ == b.instance_;
+  }
+
+  friend inline bool operator!=(const Ref& a, const Ref& b) {
+    return a.instance_ != b.instance_;
+  }
+
+  friend inline bool operator<(const Ref& a, const Ref& b) {
+    return a.instance_ < b.instance_;
+  }
+
+protected:
+  friend Ref AdoptRef<T>(T&);
+  template<typename U> friend class RefPtr;
+
+  enum AdoptTag { Adopt };
+  Ref(T& object, AdoptTag)
+    : instance_(&object)
+  {
+  }
+
+  T* instance_;
+};
+
+template<typename T> template<typename U> Ref<T> Ref<T>::Replace(Ref<U>&& reference)
+{
+  auto oldReference = AdoptRef(*instance_);
+  instance_ = &reference.LeakRef();
+  return oldReference;
+}
+
+template<typename T>
+Ref<T> AdoptRef(T& reference)
+{
+  adopted(&reference);
+  return Ref<T>(reference, Ref<T>::Adopt);
+}
+
+///
+/// @brief  A nullable smart pointer.
+///
+/// This smart pointer automatically manages the lifetime of a RefCounted
+/// object. The managed instance may be NULL.
+///
+template<typename T> class RefPtr {
+ public:
+  ///
+  /// Construct a NULL ref-pointer.
+  ///
+  RefPtr() 
+    : instance_(nullptr)
+  {
+  }
+
+  ///
+  /// Construct a NULL ref-pointer.
+  ///
+  RefPtr(std::nullptr_t)
+    : instance_(nullptr)
+  {
+  }
+
+  ///
+  /// Construct from a pointer. (Will increment ref-count by one)
+  ///
+  RefPtr(T* other)
+    : instance_(other)
+  {
+    if (instance_)
+      instance_->AddRef();
+  }
+
+  ///
+  /// Copy constructor.
+  ///
+  RefPtr(const RefPtr& other) 
+    : instance_(other.instance_) 
+  {
+    if (instance_)
+      instance_->AddRef();
+  }
+
+  ///
+  /// Copy constructor with internal type conversion.
+  ///
+  template<typename U>
+  RefPtr(const RefPtr<U>& other) 
+    : instance_(other.instance_) 
+  {
+    if (instance_)
+      instance_->AddRef();
+  }
+
+  ///
+  /// Move constructor.
+  ///
+  RefPtr(RefPtr&& other) 
+    : instance_(other.LeakRef())
+  {
+  }
+
+  ///
+  /// Move constructor.
+  ///
+  template<typename U>
+  RefPtr(RefPtr<U>&& other) 
+    : instance_(other.LeakRef())
+  {
+  }
+
+  ///
+  /// Construct from a Ref
+  ///
+  template<typename U>
+  RefPtr(const Ref<U>& other)
+    : instance_(other.instance_)
+  {
+    if (instance_)
+      instance_->AddRef();
+  }
+
+  ///
+  /// Construct by moving from a Ref
+  ///
+  template<typename U>
+  RefPtr(Ref<U>&& other);
+
+  ///
+  /// Destroy RefPtr (wll decrement ref-count by one)
+  ///
+  ~RefPtr()
+  {
+    T* old_value = std::move(instance_);
+    instance_ = std::forward<T*>(nullptr);
+    if (old_value)
+      old_value->Release();
+  }
+
+  ///
+  /// Get a pointer to wrapped object.
+  ///
+  T* get() const { return instance_; }
+
+  T* LeakRef() {
+    T* result = std::move(instance_);
+    instance_ = std::forward<T*>(nullptr);
+    return result;
+  }
+
+  T& operator*() const { assert(instance_); return *instance_; }
+  T* operator->() const { return instance_; }
+
+  bool operator!() const { return !instance_; }
+
+  // This conversion operator allows implicit conversion to bool but not to other integer types.
+  typedef T* (RefPtr::*UnspecifiedBoolType);
+  operator UnspecifiedBoolType() const { return instance_ ? &RefPtr::instance_ : nullptr; }
+
+  RefPtr& operator=(const RefPtr&);
+  RefPtr& operator=(T*);
+  RefPtr& operator=(std::nullptr_t);
+  template<typename U> RefPtr& operator=(const RefPtr<U>&);
+  RefPtr& operator=(RefPtr&&);
+  template<typename U> RefPtr& operator=(RefPtr<U>&&);
+  template<typename U> RefPtr& operator=(Ref<U>&&);
+
+  friend inline bool operator==(const RefPtr& a, const RefPtr& b) {
+    return a.instance_ == b.instance_;
+  }
+
+  friend inline bool operator!=(const RefPtr& a, const RefPtr& b) {
+    return a.instance_ != b.instance_;
+  }
+
+  friend inline bool operator<(const RefPtr& a, const RefPtr& b) {
+    return a.instance_ < b.instance_;
+  }
+
+  void Swap(RefPtr&);
+
+private:
+  T* instance_;
+};
+
+template<typename T>
+template<typename U>
+RefPtr<T>::RefPtr(Ref<U>&& reference)
+  : instance_(&reference.LeakRef())
+{
+}
+
+template<typename T>
+RefPtr<T>& RefPtr<T>::operator=(const RefPtr& other)
+{
+  RefPtr ptr = other;
+  Swap(ptr);
+  return *this;
+}
+
+template<typename T>
+template<typename U>
+RefPtr<T>& RefPtr<T>::operator=(const RefPtr<U>& other)
+{
+  RefPtr ptr = other;
+  Swap(ptr);
+  return *this;
+}
+
+template<typename T>
+RefPtr<T>& RefPtr<T>::operator=(T* object)
+{
+  RefPtr ptr = object;
+  Swap(ptr);
+  return *this;
+}
+
+template<typename T>
+RefPtr<T>& RefPtr<T>::operator=(std::nullptr_t)
+{
+  T* old_instance = std::move(instance_);
+  instance_ = std::forward<T*>(nullptr);
+  if (old_instance)
+    old_instance->Release();
+  return *this;
+}
+
+template<typename T>
+RefPtr<T>& RefPtr<T>::operator=(RefPtr&& other)
+{
+  RefPtr ptr = std::move(other);
+  Swap(ptr);
+  return *this;
+}
+
+template<typename T>
+template<typename U>
+RefPtr<T>& RefPtr<T>::operator=(RefPtr<U>&& other)
+{
+  RefPtr ptr = std::move(other);
+  Swap(ptr);
+  return *this;
+}
+
+template<typename T>
+template<typename U>
+RefPtr<T>& RefPtr<T>::operator=(Ref<U>&& other)
+{
+  RefPtr ptr = std::move(other);
+  Swap(ptr);
+  return *this;
+}
+
+template<typename T>
+void RefPtr<T>::Swap(RefPtr& other)
+{
+  std::swap(instance_, other.instance_);
+}
+
+template<class T>
+void Swap(RefPtr<T>& a, RefPtr<T>& b)
+{
+  a.Swap(b);
+}
+
+template<typename T, typename U>
+bool operator==(const RefPtr<T>& a, const RefPtr<U>& b)
+{
+  return a.get() == b.get();
+}
+
+template<typename T, typename U>
+bool operator==(const RefPtr<T>& a, U* b)
+{
+  return a.get() == b;
+}
+
+template<typename T, typename U>
+bool operator==(T* a, const RefPtr<U>& b)
+{
+  return a == b.get();
+}
+
+template<typename T, typename U>
+bool operator!=(const RefPtr<T>& a, const RefPtr<U>& b)
+{
+  return a.get() != b.get();
+}
+
+template<typename T, typename U>
+bool operator!=(const RefPtr<T>& a, U* b)
+{
+  return a.get() != b;
+}
+
+template<typename T, typename U>
+bool operator!=(T* a, const RefPtr<U>& b)
+{
+  return a != b.get();
+}
+
+}  // namespace ultralight
diff --git a/engine/inc/Ultralight/RenderTarget.h b/engine/inc/Ultralight/RenderTarget.h
new file mode 100644
index 00000000..842f0592
--- /dev/null
+++ b/engine/inc/Ultralight/RenderTarget.h
@@ -0,0 +1,84 @@
+///
+/// @file RenderTarget.h
+///
+/// @brief The header for the RenderTarget struct.
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+#include <Ultralight/Defines.h>
+#include <Ultralight/Bitmap.h>
+#include <Ultralight/Geometry.h>
+
+namespace ultralight {
+
+#pragma pack(push, 1)
+
+///
+/// @brief  Rendering details for a View, to be used with your own GPUDriver
+///
+/// When using your own GPUDriver, each View is rendered to an offscreen
+/// texture that you can display on a 3D quad in your application. This struct
+/// provides all the details you need to display the corresponding texture in
+/// your application.
+///
+struct UExport RenderTarget {
+  ///
+  /// Whether this target is empty (null texture)
+  ///
+  bool is_empty;
+
+  ///
+  /// The viewport width (in device coordinates).
+  ///
+  uint32_t width;
+
+  ///
+  /// The viewport height (in device coordinates).
+  ///
+  uint32_t height;
+
+  ///
+  /// The GPUDriver-specific texture ID (you should bind the texture using
+  /// your implementation of GPUDriver::BindTexture before drawing a quad).
+  ///
+  uint32_t texture_id;
+
+  ///
+  /// The texture width (in pixels). This may be padded.
+  ///
+  uint32_t texture_width;
+
+  ///
+  /// The texture height (in pixels). This may be padded.
+  ///
+  uint32_t texture_height;
+
+  ///
+  /// The pixel format of the texture.
+  ///
+  BitmapFormat texture_format;
+
+  ///
+  /// UV coordinates of the texture (this is needed because the texture may
+  /// be padded).
+  ///
+  Rect uv_coords;
+
+  ///
+  /// The GPUDriver-specific render buffer ID.
+  ///
+  uint32_t render_buffer_id;
+
+  RenderTarget();
+};
+
+#pragma pack(pop)
+
+}  // namespace ultralight
diff --git a/engine/inc/Ultralight/Renderer.h b/engine/inc/Ultralight/Renderer.h
new file mode 100644
index 00000000..9e6de5a7
--- /dev/null
+++ b/engine/inc/Ultralight/Renderer.h
@@ -0,0 +1,137 @@
+///
+/// @file Renderer.h
+///
+/// @brief The header for the Renderer class.
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+#include <Ultralight/Defines.h>
+#include <Ultralight/RefPtr.h>
+#include <Ultralight/Session.h>
+#include <Ultralight/View.h>
+
+namespace ultralight {
+
+///
+/// @brief  This singleton manages the lifetime of all Views (@see View) and
+///         coordinates painting, network requests, and event dispatch.
+///
+/// @note  You don't have to create this instance directly if you use the
+///        AppCore API. The App class will automatically create a Renderer and
+///        perform all rendering within its run loop. @see App::Create
+///
+class UExport Renderer : public RefCounted {
+public:
+  ///
+  /// Create the Ultralight Renderer directly.
+  ///
+  /// Unlike App::Create(), this does not use any native windows for drawing
+  /// and allows you to manage your own runloop and painting. This method is
+  /// recommended for those wishing to integrate the library into a game.
+  ///
+  /// You should set up your Platform config, file-system, font loader, 
+  /// and surface-factories/gpu-drivers before calling this function. 
+  /// (@see <Ultralight/Platform.h>)
+  ///
+  /// At a minimum, you will need to define a FontLoader ahead of time or this
+  /// call will fail. You can use the platform's native FontLoader by calling:
+  /// <pre>
+  ///   /// This function is defined in <AppCore/Platform.h>
+  ///   Platform::instance().set_font_loader(GetPlatformFontLoader());
+  /// </pre>
+  ///
+  /// @note  You should only create one Renderer per application lifetime.
+  ///
+  /// @note: You should not call this if you are using App::Create(), it
+  ///        creates its own renderer and provides default implementations for
+  ///        various platform handlers automatically.
+  ///
+  /// @return  Renderer is ref-counted. This method returns a ref-pointer
+  ///          to a new instance, you should store it in a RefPtr<> to keep
+  ///          the instance alive.
+  ///
+  static Ref<Renderer> Create();
+
+  ///
+  /// Create a Session to store local data in (such as cookies, local storage,
+  /// application cache, indexed db, etc).
+  ///
+  /// @note  A default, persistent Session is already created for you. You
+  ///        only need to call this if you want to create private, in-memory
+  ///        session or use a separate session for each View.
+  ///
+  /// @param  is_persistent  Whether or not to store the session on disk.
+  ///                        Persistent sessions will be written to the path
+  ///                        set in Config::cache_path
+  ///
+  /// @param  name  A unique name for this session, this will be used to
+  ///               generate a unique disk path for persistent sessions.
+  ///
+  virtual Ref<Session> CreateSession(bool is_persistent, const String& name) = 0;
+  
+  ///
+  /// Get the default Session. This session is persistent (backed to disk) and
+  /// has the name "default".
+  ///
+  virtual Ref<Session> default_session() = 0;
+
+  ///
+  /// Create a new View.
+  ///
+  /// @param  width   The initial width, in pixels.
+  /// 
+  /// @param  height  The initial height, in pixels.
+  ///
+  /// @param  transparent  Whether or not the view background is transparent.
+  ///
+  /// @param  session  The session to store local data in. Pass a nullptr to
+  ///                  use the default session.
+  ///
+  /// @return  Returns a ref-pointer to a new View instance. You should assign
+  ///          it to either a Ref<View> (non-nullable) or RefPtr<View>
+  ///          (nullable).
+  ///
+  virtual Ref<View> CreateView(uint32_t width, uint32_t height,
+	                             bool transparent, RefPtr<Session> session,
+                               bool force_cpu_renderer = false) = 0;
+
+  ///
+  /// Update timers and dispatch internal callbacks. You should call this often
+  /// from your main application loop.
+  ///
+  virtual void Update() = 0;
+
+  ///
+  /// Render all active views to their respective render-targets/surfaces.
+  ///
+  /// You should call this once per frame (usually in synchrony with the
+  /// monitor's refresh rate).
+  ///
+  /// @note  Views are only repainted if they actually need painting.
+  ///
+  virtual void Render() = 0;
+
+  ///
+  /// Attempt to release as much memory as possible. Don't call this from any
+  /// callbacks or driver code.
+  ///
+  virtual void PurgeMemory() = 0;
+
+  ///
+  /// Print detailed memory usage statistics to the log.
+  /// (@see Platform::set_logger())
+  ///
+  virtual void LogMemoryUsage() = 0;
+
+protected:
+  virtual ~Renderer();
+};
+
+} // namespace ultralight
diff --git a/data/entities/gui/mainmenu/sound.json b/engine/inc/Ultralight/RequestHandler.h
similarity index 100%
rename from data/entities/gui/mainmenu/sound.json
rename to engine/inc/Ultralight/RequestHandler.h
diff --git a/engine/inc/Ultralight/ScrollEvent.h b/engine/inc/Ultralight/ScrollEvent.h
new file mode 100644
index 00000000..a48bea5d
--- /dev/null
+++ b/engine/inc/Ultralight/ScrollEvent.h
@@ -0,0 +1,53 @@
+///
+/// @file ScrollEvent.h
+///
+/// @brief The header for the ScrollEvent class.
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+#include <Ultralight/Defines.h>
+
+namespace ultralight {
+
+///
+/// @brief  A generic scroll event.
+///
+/// @note   @see View::FireScrollEvent
+///
+class ScrollEvent {
+public:
+  ///
+  /// The scroll event granularity type
+  ///
+  enum Type {
+	  /// The delta value is interpreted as number of pixels
+    kType_ScrollByPixel,
+
+	  /// The delta value is interpreted as number of pages
+    kType_ScrollByPage,
+  };
+
+  ///
+  /// Scroll granularity type
+  ///
+  Type type;
+
+  ///
+  /// Horizontal scroll amount
+  ///
+  int delta_x;
+
+  ///
+  /// Vertical scroll amount
+  ///
+  int delta_y;
+};
+
+}  // namespace ultralight
diff --git a/engine/inc/Ultralight/Session.h b/engine/inc/Ultralight/Session.h
new file mode 100644
index 00000000..68819f2d
--- /dev/null
+++ b/engine/inc/Ultralight/Session.h
@@ -0,0 +1,53 @@
+///
+/// @file Session.h
+///
+/// @brief The header for the Session class.
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+#include <Ultralight/Defines.h>
+#include <Ultralight/RefPtr.h>
+#include <Ultralight/String.h>
+
+namespace ultralight {
+
+///
+/// @brief A Session stores local data such as cookies, local storage,
+///        and application cache for one or more Views. 
+///
+/// @see   Renderer::CreateSession
+///
+class UExport Session : public RefCounted {
+public:
+  ///
+  /// Whether or not this session is written to disk.
+  ///
+  virtual bool is_persistent() const = 0;
+
+  ///
+  /// A unique name identifying this session.
+  ///
+  virtual String name() const = 0;
+
+  ///
+  /// A unique numeric ID identifying this session.
+  ///
+  virtual uint64_t id() const = 0;
+
+  ///
+  /// The disk path of this session (only valid for persistent sessions).
+  ///
+  virtual String disk_path() const = 0;
+
+protected:
+  virtual ~Session();
+};
+
+}  // namespace ultralight
diff --git a/engine/inc/Ultralight/String.h b/engine/inc/Ultralight/String.h
new file mode 100644
index 00000000..0362a91c
--- /dev/null
+++ b/engine/inc/Ultralight/String.h
@@ -0,0 +1,120 @@
+///
+/// @file String.h
+///
+/// @brief The header for the String class.
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+#include <Ultralight/Defines.h>
+#include <Ultralight/String8.h>
+#include <Ultralight/String16.h>
+#include <Ultralight/String32.h>
+
+namespace ultralight {
+
+///
+/// @brief  UTF-16 String container with conversions for UTF-8 and UTF-32.
+///
+/// @note   Internally, all strings are represented as UTF-16.
+///
+class UExport String {
+public:
+  ///
+  /// Create empty string
+  ///
+  String();
+
+  ///
+  /// Create from null-terminated, ASCII C-string
+  ///
+  String(const char* str);
+
+  ///
+  /// Create from raw, UTF-8 string with certain length
+  ///
+  String(const char* str, size_t len);
+
+  ///
+  /// Create from existing String8 (UTF-8).
+  ///
+  String(const String8& str);
+
+  ///
+  /// Create from raw UTF-16 string with certain length
+  ///
+  String(const Char16* str, size_t len);
+
+  ///
+  /// Create from existing String16 (UTF-16)
+  ///
+  String(const String16& str);
+
+  ///
+  /// Create from existing String32 (UTF-32)
+  ///
+  String(const String32& str);
+
+  ///
+  /// Copy constructor
+  ///
+  String(const String& other);
+
+  ///
+  /// Destructor
+  ///
+  ~String();
+
+  ///
+  /// Assign string from another, copy is made
+  ///
+  String& operator=(const String& other);
+
+  ///
+  /// Append string with another
+  ///
+  String& operator+=(const String& other);
+  
+  ///
+  /// Concatenation operator
+  ///
+  inline friend String operator+(String lhs, const String& rhs) { lhs += rhs; return lhs; }
+
+  ///
+  /// Get native UTF-16 string
+  ///
+  String16& utf16() { return str_; }
+
+  ///
+  /// Get native UTF-16 string
+  ///
+  const String16& utf16() const { return str_; }
+
+  ///
+  /// Convert to UTF-8 string
+  ///
+  String8 utf8() const;
+
+  ///
+  /// Convert to UTF-32 string
+  ///
+  String32 utf32() const;
+
+  ///
+  /// Check if string is empty or not
+  ///
+  bool empty() const { return utf16().empty(); }
+
+private:
+  String16 str_;
+};
+
+
+}  // namespace ultralight
+
diff --git a/engine/inc/Ultralight/String16.h b/engine/inc/Ultralight/String16.h
new file mode 100644
index 00000000..9de8405c
--- /dev/null
+++ b/engine/inc/Ultralight/String16.h
@@ -0,0 +1,130 @@
+///
+/// @file String16.h
+///
+/// @brief The header for the String16 class.
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+#include <Ultralight/Defines.h>
+#include <Ultralight/RefPtr.h>
+#include <stddef.h>
+
+namespace ultralight {
+
+namespace detail {
+  template<int> struct selector;
+  template<> struct selector<4> { typedef char16_t Char16; };
+  template<> struct selector<2> { typedef wchar_t Char16; };
+}
+
+#ifdef DISABLE_NATIVE_WCHAR_T
+// Force Char16 type to use char16_t, used on Windows when native wchar_t support is disabled.
+typedef char16_t Char16;
+#else
+// We use wchar_t if size == 2, otherwise use char16_t
+typedef detail::selector<sizeof(wchar_t)>::Char16 Char16;
+#endif
+
+///
+/// @brief  A UTF-16 string container.
+///
+class UExport String16 {
+public:
+  // Make an empty String16
+  String16();
+
+  // Make a String16 from null-terminated ASCII C-string
+  String16(const char* c_str);
+
+  // Make a String16 from ASCII C-string with certain length
+  String16(const char* c_str, size_t len);
+
+  // Make a String16 from raw UTF-16 buffer with certain length
+  String16(const Char16* str, size_t len);
+
+  // Make a String16 from raw unsigned short UTF-16 buffer with certain length. Useful on Windows
+  // when native support for wchar_t is disabled (eg, /Zc:wchar_t-).
+  String16(const unsigned short* str, size_t len);
+
+  // Make a deep copy of String16
+  String16(const String16& other);
+
+  ~String16();
+
+  // Assign a String16 to this one, deep copy is made
+  String16& operator=(const String16& other);
+
+  // Append a String16 to this one.
+  String16& operator+=(const String16& other);
+
+  // Concatenation operator
+  inline friend String16 operator+(String16 lhs, const String16& rhs) { lhs += rhs; return lhs; }
+
+  // Get raw UTF-16 data
+  Char16* data() { return data_; }
+
+  // Get raw UTF-16 data (const)
+  const Char16* data() const { return data_; }
+
+  // Get raw UTF-16 data as unsigned short. This is useful on Windows if you compile without native
+  // support for wchar_t (eg, /Zc:wchar_t-)
+  unsigned short* udata() { return reinterpret_cast<unsigned short*>(data_); }
+
+  // Get raw UTF-16 data as unsigned short (const).
+  const unsigned short* udata() const { return reinterpret_cast<const unsigned short*>(data_); }
+
+  // Get length in characters.
+  size_t length() const { return length_; }
+
+  // Get size in characters (synonym for length)
+  size_t size() const { return length_; }
+
+  // Check if string is empty.
+  bool empty() const { return !data_ || length_ == 0; }
+
+  // Get character at specific position
+  Char16& operator[](size_t pos) { return data_[pos]; }
+
+  // Get character at specific position (const)
+  const Char16& operator[](size_t pos) const { return data_[pos]; }
+
+private:
+  Char16* data_;
+  size_t length_;
+};
+
+///
+/// @brief  A UTF-16 string vector.
+///
+class UExport String16Vector : public RefCounted {
+public:
+  // Create an empty string vector
+  static Ref<String16Vector> Create();
+
+  // Create a string vector from an existing array (a deep copy is made)
+  static Ref<String16Vector> Create(const String16* stringArray, size_t len);
+
+  // Add an element to the back of the string vector
+  virtual void push_back(const String16& val) = 0;
+
+  // Get raw String16 vector array
+  virtual String16* data() = 0;
+
+  // Get the number of elements in vector
+  virtual size_t size() const = 0;
+
+protected:
+  String16Vector();
+  virtual ~String16Vector();
+  String16Vector(const String16Vector&);
+  void operator=(const String16Vector&);
+};
+
+}  // namespace ultralight
diff --git a/engine/inc/Ultralight/String32.h b/engine/inc/Ultralight/String32.h
new file mode 100644
index 00000000..21738264
--- /dev/null
+++ b/engine/inc/Ultralight/String32.h
@@ -0,0 +1,71 @@
+///
+/// @file String32.h
+///
+/// @brief The header for the String32 class.
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+#include <Ultralight/Defines.h>
+#include <stddef.h>
+
+namespace ultralight {
+
+///
+/// @brief  A UTF-32 string container.
+///
+class UExport String32 {
+public:
+  // Make an empty String32
+  String32();
+
+  // Make a String32 from raw UTF-32 string with certain length
+  String32(const char32_t* c_str, size_t len);
+
+  // Make a deep copy of String32
+  String32(const String32& other);
+
+  ~String32();
+
+  // Assign a String32 to this one, deep copy is made
+  String32& operator=(const String32& other);
+
+  // Append a String32 to this one.
+  String32& operator+=(const String32& other);
+
+  // Concatenation operator
+  inline friend String32 operator+(String32 lhs, const String32& rhs) { lhs += rhs; return lhs; }
+
+  // Get raw UTF-32 data
+  char32_t* data() { return data_; }
+
+  // Get raw UTF-32 data (const)
+  const char32_t* data() const { return data_; }
+
+  // Get length in characters.
+  size_t length() const { return length_; }
+
+  // Get size in characters (synonym for length)
+  size_t size() const { return length_; }
+
+  // Check if string is empty.
+  bool empty() const { return !data_ || length_ == 0; }
+
+  // Get character at specific position
+  char32_t& operator[](size_t pos) { return data_[pos]; }
+
+  // Get character at specific position (const)
+  const char32_t& operator[](size_t pos) const { return data_[pos]; }
+
+private:
+  char32_t* data_;
+  size_t length_;
+};
+
+}  // namespace ultralight
diff --git a/engine/inc/Ultralight/String8.h b/engine/inc/Ultralight/String8.h
new file mode 100644
index 00000000..f83d75b2
--- /dev/null
+++ b/engine/inc/Ultralight/String8.h
@@ -0,0 +1,74 @@
+///
+/// @file String8.h
+///
+/// @brief The header for the String8 class.
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+#include <Ultralight/Defines.h>
+#include <stddef.h>
+
+namespace ultralight {
+
+///
+/// @brief  A UTF-8 string container.
+//
+class UExport String8 {
+public:
+  // Make an empty String8
+  String8();
+
+  // Make a String8 from raw, null-terminated UTF-8 string
+  String8(const char* c_str);
+
+  // Make a String8 from raw UTF-8 string with certain length
+  String8(const char* c_str, size_t len);
+
+  // Make a deep copy of String8
+  String8(const String8& other);
+
+  ~String8();
+
+  // Assign a String8 to this one, deep copy is made
+  String8& operator=(const String8& other);
+
+  // Append a String8 to this one.
+  String8& operator+=(const String8& other);
+
+  // Concatenation operator
+  inline friend String8 operator+(String8 lhs, const String8& rhs) { lhs += rhs; return lhs; }
+
+  // Get raw UTF-8 data
+  char* data() { return data_; }
+
+  // Get raw UTF-8 data (const)
+  const char* data() const { return data_; }
+
+  // Get length in characters.
+  size_t length() const { return length_; }
+
+  // Get size in characters (synonym for length)
+  size_t size() const { return length_; }
+
+  // Check if string is empty.
+  bool empty() const { return !data_ || length_ == 0; }
+
+  // Get character at specific position
+  char& operator[](size_t pos) { return data_[pos]; }
+
+  // Get character at specific position (const)
+  const char& operator[](size_t pos) const { return data_[pos]; }
+
+private:
+  char* data_;
+  size_t length_;
+};
+
+}  // namespace ultralight
diff --git a/engine/inc/Ultralight/Ultralight.h b/engine/inc/Ultralight/Ultralight.h
new file mode 100644
index 00000000..6db2c6e1
--- /dev/null
+++ b/engine/inc/Ultralight/Ultralight.h
@@ -0,0 +1,29 @@
+// Copyright 2020 Ultralight, Inc. All rights reserved.
+#pragma once
+#include <Ultralight/Defines.h>
+#include <Ultralight/RefPtr.h>
+#include <Ultralight/String8.h>
+#include <Ultralight/String16.h>
+#include <Ultralight/String32.h>
+#include <Ultralight/String.h>
+#include <Ultralight/Bitmap.h>
+#include <Ultralight/Buffer.h>
+#include <Ultralight/View.h>
+#include <Ultralight/Session.h>
+#include <Ultralight/KeyCodes.h>
+#include <Ultralight/KeyEvent.h>
+#include <Ultralight/Listener.h>
+#include <Ultralight/Matrix.h>
+#include <Ultralight/MouseEvent.h>
+#include <Ultralight/Renderer.h>
+#include <Ultralight/Geometry.h>
+#include <Ultralight/RenderTarget.h>
+#include <Ultralight/ScrollEvent.h>
+#include <Ultralight/platform/Platform.h>
+#include <Ultralight/platform/Config.h>
+#include <Ultralight/platform/GPUDriver.h>
+#include <Ultralight/platform/FileSystem.h>
+#include <Ultralight/platform/FontLoader.h>
+#include <Ultralight/platform/Surface.h>
+#include <Ultralight/platform/Clipboard.h>
+#include <Ultralight/platform/Logger.h>
diff --git a/engine/inc/Ultralight/View.h b/engine/inc/Ultralight/View.h
new file mode 100644
index 00000000..c56c5b8e
--- /dev/null
+++ b/engine/inc/Ultralight/View.h
@@ -0,0 +1,307 @@
+///
+/// @file View.h
+///
+/// @brief The header for the View class.
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+#include <Ultralight/Defines.h>
+#include <Ultralight/RefPtr.h>
+#include <Ultralight/KeyEvent.h>
+#include <Ultralight/JavaScript.h>
+#include <Ultralight/MouseEvent.h>
+#include <Ultralight/ScrollEvent.h>
+#include <Ultralight/RenderTarget.h>
+#include <Ultralight/Bitmap.h>
+#include <Ultralight/Listener.h>
+#include <Ultralight/platform/Surface.h>
+
+namespace ultralight {
+
+///
+/// @brief The View class is used to load and display web content.
+///
+/// View is an offscreen web-page container that can be used to display
+/// web-content in your application.
+///
+/// You can load content into a View via View::LoadURL() or View::LoadHTML()
+/// and interact with it via View::FireMouseEvent() and similar API.
+///
+/// When displaying a View, the API is different depending on whether you
+/// are using the CPU renderer or the GPU renderer:
+///
+/// When using the CPU renderer, you would get the underlying pixel-buffer
+/// surface for a View via View::surface().
+///
+/// When using the GPU renderer, you would get the underlying render target
+/// and texture information via View::render_target().
+///
+/// @note  The API is not currently thread-safe, all calls must be made on the
+///        same thread that the Renderer/App was created on.
+///
+class UExport View : public RefCounted {
+public:
+  ///
+  /// Get the URL of the current page loaded into this View, if any.
+  ///
+  virtual String url() = 0;
+
+  ///
+  /// Get the title of the current page loaded into this View, if any.
+  ///
+  virtual String title() = 0;
+
+  ///
+  /// Get the width of the View, in pixels.
+  ///
+  virtual uint32_t width() const = 0;
+
+  ///
+  /// Get the height of the View, in pixels.
+  ///
+  virtual uint32_t height() const = 0;
+
+  ///
+  /// Check if the main frame of the page is currently loading.
+  ///
+  virtual bool is_loading() = 0;
+
+  ///
+  /// Get the offscreen RenderTarget for the View.
+  ///
+  /// @note  Only valid when the GPU renderer is enabled in Config.
+  ///
+  ///        You can use this with your GPUDriver implementation to bind
+  ///        and display the corresponding texture in your application.
+  ///
+  virtual RenderTarget render_target() = 0;
+
+  ///
+  /// Get the offscreen Surface for the View (pixel-buffer container).
+  ///
+  /// @note  Only valid when the CPU is enabled (will return a nullptr
+  ///        otherwise)
+  ///
+  ///        The default Surface is BitmapSurface but you can provide your
+  ///        own Surface implementation via Platform::set_surface_factory.
+  ///
+  virtual Surface* surface() = 0;
+
+  ///
+  /// Load a raw string of HTML, the View will navigate to it as a new page.
+  ///
+  /// @param  html  The raw HTML string to load.
+  ///
+  /// @param  url   An optional URL for this load (to make it appear as if we
+  ///               we loaded this HTML from a certain URL). Can be used for
+  ///               resolving relative URLs and cross-origin rules.
+  ///
+  /// @param  add_to_history  Whether or not this load should be added to the
+  ///                         session's history (back/forward list).
+  ///
+  virtual void LoadHTML(const String& html,
+    const String& url = "", 
+    bool add_to_history = false) = 0;
+
+  ///
+  /// Load a URL, the View will navigate to it as a new page.
+  ///
+  /// @note  You can use File URLs (eg, file:///page.html) but you must define
+  ///        your own FileSystem implementation if you are not using AppCore.
+  ///        @see Platform::set_file_system
+  ///
+  virtual void LoadURL(const String& url) = 0;
+
+  ///
+  /// Resize View to a certain size.
+  ///
+  /// @param  width   The initial width, in pixels.
+  /// 
+  /// @param  height  The initial height, in pixels.
+  ///
+  ///
+  virtual void Resize(uint32_t width, uint32_t height) = 0;
+
+  ///
+  /// Acquire the page's JSContext for use with the JavaScriptCore API
+  ///
+  /// @note  You can use the underlying JSContextRef with the JavaScriptCore
+  ///        C API. This allows you to marshall C/C++ objects to/from
+  ///        JavaScript, bind callbacks, and call JS functions directly.
+  ///
+  /// @note  The JSContextRef gets reset after each page navigation. You
+  ///        should initialize your JavaScript state within the
+  ///        OnWindowObjectReady and OnDOMReady events, @see ViewListener.
+  ///
+  /// @note  This call locks the internal context for the current thread.
+  ///        It will be unlocked when the returned JSContext's ref-count goes
+  ///        to zero. The lock is recursive, you can call this multiple times.
+  ///
+  virtual Ref<JSContext> LockJSContext() = 0;
+
+  ///
+  /// Helper function to evaluate a raw string of JavaScript and return the
+  /// result as a String.
+  ///
+  /// @param  script     A string of JavaScript to evaluate in the main frame.
+  ///
+  /// @param  exception  A string to store the exception in, if any. Pass a
+  ///                    nullptr if you don't care about exceptions.
+  ///
+  /// @return  Returns the JavaScript result typecast to a String.
+  ///
+  ///
+  /// @note  You do not need to lock the JS context, it is done automatically.
+  ///
+  /// @note  If you need lower-level access to native JavaScript values, you
+  ///        should instead lock the JS context and call JSEvaluateScript() in
+  ///        the JavaScriptCore C API. @see <JavaScriptCore/JSBase.h>
+  ///
+  virtual String EvaluateScript(const String& script, String* exception = nullptr) = 0;
+
+  ///
+  /// Whether or not we can navigate backwards in history
+  ///
+  virtual bool CanGoBack() = 0;
+
+  ///
+  /// Whether or not we can navigate forwards in history
+  ///
+  virtual bool CanGoForward() = 0;
+
+  ///
+  /// Navigate backwards in history
+  ///
+  virtual void GoBack() = 0;
+
+  ///
+  /// Navigate forwards in history
+  ///
+  virtual void GoForward() = 0;
+
+  ///
+  /// Navigate to an arbitrary offset in history
+  ///
+  virtual void GoToHistoryOffset(int offset) = 0;
+
+  ///
+  /// Reload current page
+  ///
+  virtual void Reload() = 0;
+
+  ///
+  /// Stop all page loads
+  ///
+  virtual void Stop() = 0;
+
+  ///
+  /// Give focus to the View.
+  ///
+  /// You should call this to give visual indication that the View has input
+  /// focus (changes active text selection colors, for example).
+  ///
+  virtual void Focus() = 0;
+
+  ///
+  /// Remove focus from the View and unfocus any focused input elements.
+  ///
+  /// You should call this to give visual indication that the View has lost
+  /// input focus.
+  ///
+  virtual void Unfocus() = 0;
+
+  ///
+  /// Whether or not the View has focus.
+  ///
+  virtual bool HasFocus() = 0;
+
+  ///
+  /// Whether or not the View has an input element with visible keyboard focus
+  /// (indicated by a blinking caret).
+  ///
+  /// You can use this to decide whether or not the View should consume
+  /// keyboard input events (useful in games with mixed UI and key handling).
+  ///
+  virtual bool HasInputFocus() = 0;
+  
+  ///
+  /// Fire a keyboard event
+  ///
+  /// @note  Only 'Char' events actually generate text in input fields.
+  ///
+  virtual void FireKeyEvent(const KeyEvent& evt) = 0;
+
+  ///
+  /// Fire a mouse event
+  ///
+  virtual void FireMouseEvent(const MouseEvent& evt) = 0;
+
+  ///
+  /// Fire a scroll event
+  ///
+  virtual void FireScrollEvent(const ScrollEvent& evt) = 0;
+
+  ///
+  /// Set a ViewListener to receive callbacks for View-related events.
+  ///
+  /// @note  Ownership remains with the caller.
+  ///
+  virtual void set_view_listener(ViewListener* listener) = 0;
+  
+  ///
+  /// Get the active ViewListener, if any
+  ///
+  virtual ViewListener* view_listener() const = 0;
+
+  ///
+  /// Set a LoadListener to receive callbacks for Load-related events.
+  ///
+  /// @note  Ownership remains with the caller.
+  ///
+  virtual void set_load_listener(LoadListener* listener) = 0;
+
+  ///
+  /// Get the active LoadListener, if any
+  ///
+  virtual LoadListener* load_listener() const = 0;
+
+  ///
+  /// Set whether or not this View should be repainted during the next
+  /// call to Renderer::Render
+  ///
+  /// @note  This flag is automatically set whenever the page content changes
+  ///        but you can set it directly in case you need to force a repaint.
+  ///
+  virtual void set_needs_paint(bool needs_paint) = 0;
+
+  ///
+  /// Whether or not this View should be repainted during the next call to
+  /// Renderer::Render.
+  ///
+  virtual bool needs_paint() const = 0;
+
+  ///
+  /// Get the inspector for this View, this is useful for debugging and
+  /// inspecting pages locally. This will only succeed if you have the
+  /// inspector assets in your filesystem-- the inspector will look for
+  /// file:///inspector/Main.html when it first loads.
+  ///
+  /// @note  The inspector View is owned by the View and lazily-created on
+  ///        first call. The initial dimensions are 10x10, you should call
+  ///        View::Resize() on the returned View to resize it to your desired
+  ///        dimensions.
+  ///
+  virtual RefPtr<View> inspector() = 0;
+
+protected:
+  virtual ~View();
+};
+
+}  // namespace ultralight
diff --git a/engine/inc/Ultralight/platform/Clipboard.h b/engine/inc/Ultralight/platform/Clipboard.h
new file mode 100644
index 00000000..a5a35cc0
--- /dev/null
+++ b/engine/inc/Ultralight/platform/Clipboard.h
@@ -0,0 +1,51 @@
+///
+/// @file Clipboard.h
+///
+/// @brief The header for the Clipboard interface.
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+#include <Ultralight/Defines.h>
+#include <Ultralight/String16.h>
+
+namespace ultralight {
+
+///
+/// @brief  Clipboard interface.
+///          
+/// This is used for reading and writing data to the platform Clipboard.
+///
+/// AppCore automatically provides a platform-specific implementation of this
+/// that cuts/copies/pastes to the OS clipboard when you call App::Create().
+///
+/// If you are using Renderer::Create() instead, you will need to provide your
+/// own implementation of this. @see Platform::set_clipboard().
+///
+class UExport Clipboard {
+public:
+  virtual ~Clipboard();
+
+  ///
+  /// Clear the clipboard.
+  ///
+  virtual void Clear() = 0;
+
+  ///
+  /// Read plain text from the clipboard
+  ///
+  virtual String16 ReadPlainText() = 0;
+
+  ///
+  /// Write plain text to the clipboard.
+  ///
+  virtual void WritePlainText(const String16& text) = 0;
+};
+
+}  // namespace ultralight
diff --git a/engine/inc/Ultralight/platform/Config.h b/engine/inc/Ultralight/platform/Config.h
new file mode 100644
index 00000000..b5c2f9a3
--- /dev/null
+++ b/engine/inc/Ultralight/platform/Config.h
@@ -0,0 +1,230 @@
+///
+/// @file Config.h
+///
+/// @brief The header for the Config struct.
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+#include <Ultralight/Defines.h>
+#include <Ultralight/String16.h>
+
+namespace ultralight {
+
+///
+/// The winding order for front-facing triangles. (This is only used when the
+/// GPU renderer is enabled)
+///
+/// @note  In most 3D engines, there is the concept that triangles have a
+///        a "front" and a "back". All the front-facing triangles (eg, those
+///        that are facing the camera) are rendered, and all back-facing
+///        triangles are culled (ignored). The winding-order of the triangle's
+///        vertices is used to determine which side is front and back. You
+///        should tell Ultralight which winding-order your 3D engine uses.
+///
+enum FaceWinding {
+  ///
+  /// Clockwise Winding (Direct3D, etc.)
+  ///
+  kFaceWinding_Clockwise,
+
+  ///
+  /// Counter-Clockwise Winding (OpenGL, etc.)
+  ///
+  kFaceWinding_CounterClockwise,
+};
+
+enum FontHinting {
+  ///
+  /// Lighter hinting algorithm-- glyphs are slightly fuzzier but better
+  /// resemble their original shape. This is achieved by snapping glyphs to the
+  /// pixel grid only vertically which better preserves inter-glyph spacing.
+  ///
+  kFontHinting_Smooth,
+
+  ///
+  /// Default hinting algorithm-- offers a good balance between sharpness and
+  /// shape at smaller font sizes.
+  ///
+  kFontHinting_Normal,
+
+  ///
+  /// Strongest hinting algorithm-- outputs only black/white glyphs. The result
+  /// is usually unpleasant if the underlying TTF does not contain hints for
+  /// this type of rendering.
+  ///
+  kFontHinting_Monochrome,
+};
+
+///
+/// @brief  Configuration settings for Ultralight.         
+///
+/// This is intended to be implemented by users and defined before creating the
+/// Renderer. @see Platform::set_config.
+///
+struct UExport Config {
+  ///
+  /// The file path to the directory that contains Ultralight's bundled
+  /// resources (eg, cacert.pem and other localized resources). 
+  ///
+  String16 resource_path;
+
+  ///
+  /// The file path to a writable directory that will be used to store cookies,
+  /// cached resources, and other persistent data.
+  ///
+  String16 cache_path;
+
+  ///
+  /// When enabled, each View will be rendered to an offscreen GPU texture
+  /// using the GPU driver set in Platform::set_gpu_driver. You can fetch
+  /// details for the texture via View::render_target.
+  ///
+  /// When disabled (the default), each View will be rendered to an offscreen
+  /// pixel buffer. This pixel buffer can optionally be provided by the user--
+  /// for more info see <Ultralight/platform/Surface.h> and View::surface.
+  ///
+  bool use_gpu_renderer = false;
+
+  ///
+  /// The amount that the application DPI has been scaled (200% = 2.0).
+  /// This should match the device scale set for the current monitor.
+  ///
+  /// Note: Device scales are rounded to nearest 1/8th (eg, 0.125).
+  ///
+  double device_scale = 1.0;
+
+  ///
+  /// The winding order for front-facing triangles. @see FaceWinding
+  ///
+  /// Note: This is only used when the GPU renderer is enabled.
+  ///
+  FaceWinding face_winding = kFaceWinding_CounterClockwise;
+
+  ///
+  /// Whether or not images should be enabled.
+  ///
+  bool enable_images = true;
+
+  ///
+  /// Whether or not JavaScript should be enabled.
+  ///
+  bool enable_javascript = true;
+
+  ///
+  /// The hinting algorithm to use when rendering fonts. @see FontHinting
+  ///
+  FontHinting font_hinting = kFontHinting_Normal;
+
+  ///
+  /// The gamma to use when compositing font glyphs, change this value to
+  /// adjust contrast (Adobe and Apple prefer 1.8, others may prefer 2.2).
+  ///
+  double font_gamma = 1.8;
+
+  ///
+  /// Default font-family to use.
+  ///
+  String16 font_family_standard = "Times New Roman";
+
+  ///
+  /// Default font-family to use for fixed fonts. (pre/code)
+  ///
+  String16 font_family_fixed = "Courier New";
+
+  ///
+  /// Default font-family to use for serif fonts.
+  ///
+  String16 font_family_serif = "Times New Roman";
+
+  ///
+  /// Default font-family to use for sans-serif fonts.
+  ///
+  String16 font_family_sans_serif = "Arial";
+
+  ///
+  /// Default user-agent string.
+  ///
+  String16 user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+                          "AppleWebKit/608.3.10 (KHTML, like Gecko) "
+                          "Ultralight/1.2.0 Safari/608.3.10";
+
+  ///
+  /// Default user stylesheet. You should set this to your own custom CSS
+  /// string to define default styles for various DOM elements, scrollbars,
+  /// and platform input widgets.
+  ///
+  String16 user_stylesheet;
+
+  ///
+  /// Whether or not we should continuously repaint any Views or compositor
+  /// layers, regardless if they are dirty or not. This is mainly used to
+  /// diagnose painting/shader issues.
+  ///
+  bool force_repaint = false;
+
+  ///
+  /// When a CSS animation is active, the amount of time (in seconds) to wait
+  /// before triggering another repaint. Default is 60 Hz.
+  ///
+  double animation_timer_delay = 1.0 / 60.0;
+
+  ///
+  /// When a smooth scroll animation is active, the amount of time (in seconds)
+  /// to wait before triggering another repaint. Default is 60 Hz.
+  ///
+  double scroll_timer_delay = 1.0 / 60.0;
+
+  ///
+  /// The amount of time (in seconds) to wait before running the recycler (will
+  /// attempt to return excess memory back to the system).
+  ///
+  double recycle_delay = 4.0;
+
+  ///
+  /// Size of WebCore's memory cache in bytes. 
+  ///
+  /// @note  You should increase this if you anticipate handling pages with
+  ///        large resources, Safari typically uses 128+ MiB for its cache.
+  ///
+  uint32_t memory_cache_size = 64 * 1024 * 1024;
+
+  ///
+  /// Number of pages to keep in the cache. Defaults to 0 (none).
+  ///
+  /// @note  Safari typically caches about 5 pages and maintains an on-disk
+  ///        cache to support typical web-browsing activities. If you increase
+  ///        this, you should probably increase the memory cache size as well.
+  ///
+  uint32_t page_cache_size = 0;
+
+  ///
+  /// JavaScriptCore tries to detect the system's physical RAM size to set
+  /// reasonable allocation limits. Set this to anything other than 0 to
+  /// override the detected value. Size is in bytes.
+  ///
+  /// This can be used to force JavaScriptCore to be more conservative with
+  /// its allocation strategy (at the cost of some performance).
+  ///
+  uint32_t override_ram_size = 0;
+
+  ///
+  /// The minimum size of large VM heaps in JavaScriptCore. Set this to a
+  /// lower value to make these heaps start with a smaller initial value.
+  ///
+  uint32_t min_large_heap_size = 32 * 1024 * 1024;
+
+  ///
+  /// The minimum size of small VM heaps in JavaScriptCore. Set this to a
+  /// lower value to make these heaps start with a smaller initial value.
+  ///
+  uint32_t min_small_heap_size = 1 * 1024 * 1024;
+};
+
+}  // namespace ultralight
diff --git a/engine/inc/Ultralight/platform/FileSystem.h b/engine/inc/Ultralight/platform/FileSystem.h
new file mode 100644
index 00000000..19b6d9a2
--- /dev/null
+++ b/engine/inc/Ultralight/platform/FileSystem.h
@@ -0,0 +1,93 @@
+///
+/// @file FileSystem.h
+///
+/// @brief The header for the FileSystem interface.
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+#include <Ultralight/Defines.h>
+#include <Ultralight/String16.h>
+
+namespace ultralight {
+
+///
+/// File Handle type used as unique ID for opened files.
+///
+#if defined(__WIN32__) || defined(_WIN32)
+typedef size_t FileHandle;
+#else
+typedef int FileHandle;
+#endif
+
+///
+/// Handle used to denote an invalid file.
+///
+const FileHandle invalidFileHandle = (FileHandle)-1;
+
+///
+/// @brief  FileSystem interface.
+///          
+/// This is used for loading File URLs (eg, <file:///page.html>).
+///
+/// You can provide the library with your own FileSystem implementation so that
+/// file assets are loaded from your own pipeline (useful if you would like
+/// to encrypt/compress your file assets or ship it in a custom format).
+///
+/// AppCore automatically provides a platform-specific implementation of this
+/// that loads files from a local directory when you call App::Create().
+///
+/// If you are using Renderer::Create() instead, you will need to provide your
+/// own implementation via `Platform::instance().set_file_system(). For
+/// convenience, you can still use AppCore's file system implementation--
+/// see the helper functions defined in <AppCore/Platform.h>.
+///
+/// To provide your own custom FileSystem implementation, you should inherit
+/// from this class, handle the virtual member functions, and then pass an
+/// instance of your class to `Platform::instance().set_file_system()` before
+/// calling Renderer::Create() or App::Create().
+///
+class UExport FileSystem {
+public:
+  virtual ~FileSystem();
+
+  ///
+  /// Check if file path exists, return true if exists.
+  ///
+  virtual bool FileExists(const String16& path) = 0;
+
+  ///
+  /// Get file size of previously opened file, store result in 'result'. Return true on success.
+  ///
+  virtual bool GetFileSize(FileHandle handle, int64_t& result) = 0;
+
+  ///
+  /// Get file mime type (eg "text/html"), store result in 'result'. Return true on success.
+  ///
+  virtual bool GetFileMimeType(const String16& path, String16& result) = 0;
+
+  ///
+  /// Open file path for reading or writing. Return file handle on success, or invalidFileHandle on failure.
+  ///
+  /// @NOTE:  As of this writing (v1.2), this function is only used for reading.
+  ///
+  virtual FileHandle OpenFile(const String16& path, bool open_for_writing) = 0;
+
+  ///
+  /// Close previously-opened file.
+  ///
+  virtual void CloseFile(FileHandle& handle) = 0;
+
+  ///
+  /// Read from currently-opened file, return number of bytes read or -1 on failure.
+  ///
+  virtual int64_t ReadFromFile(FileHandle handle, char* data, int64_t length) = 0;
+};
+
+}  // namespace ultralight
diff --git a/engine/inc/Ultralight/platform/FontLoader.h b/engine/inc/Ultralight/platform/FontLoader.h
new file mode 100644
index 00000000..ccda81d9
--- /dev/null
+++ b/engine/inc/Ultralight/platform/FontLoader.h
@@ -0,0 +1,132 @@
+///
+/// @file FontLoader.h
+///
+/// @brief The header for the FontLoader interface.
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+#include <Ultralight/Defines.h>
+#include <Ultralight/String16.h>
+#include <Ultralight/Buffer.h>
+
+namespace ultralight {
+
+///
+/// Represents a font file, either on-disk path or in-memory file contents.
+///
+class UExport FontFile : public RefCounted {
+public:
+  ///
+  /// Create a font file from an on-disk file path.
+  ///
+  /// @note  The file path should already exist.
+  ///
+  static Ref<FontFile> Create(const String16& filepath);
+
+  ///
+  /// Create a font file from an in-memory buffer.
+  ///
+  static Ref<FontFile> Create(Ref<Buffer> buffer);
+
+  ///
+  /// Whether or not this font file was created from an in-memory buffer.
+  ///
+  virtual bool is_in_memory() const = 0;
+
+  ///
+  /// The file path (if any).
+  ///
+  virtual String16 filepath() const = 0;
+
+  ///
+  /// The in-memory buffer (if any).
+  ///
+  virtual RefPtr<Buffer> buffer() const = 0;
+
+  ///
+  /// Unique hash (if this is a filepath, only the path string is hashed).
+  ///
+  virtual uint32_t hash() const = 0;
+
+protected:
+  FontFile();
+  virtual ~FontFile();
+  FontFile(const FontFile&);
+  void operator=(const FontFile&);
+};
+
+///
+/// @brief  Font Loader interface, used for all font lookup operations.
+///
+/// Every operating system has its own library of installed system fonts. The
+/// FontLoader interface is used to lookup these fonts and fetch the actual
+/// font data (raw TTF/OTF file data) for a given a certain font description.
+///
+/// AppCore automatically provides a platform-specific implementation of this
+/// that loads installed fonts from the OS when you call App::Create().
+///
+/// If you are using Renderer::Create() instead, you will need to provide your
+/// own implementation via `Platform::instance().set_font_loader(). For
+/// convenience, you can still use AppCore's font loader implementation--
+/// see the helper functions defined in <AppCore/Platform.h>.
+///
+/// To provide your own custom FontLoader implementation, you should inherit
+/// from this class, handle the virtual member functions, and then pass an
+/// instance of your class to `Platform::instance().set_font_loader()` before
+/// calling Renderer::Create() or App::Create().
+///
+class UExport FontLoader {
+public:
+  virtual ~FontLoader();
+
+  ///
+  /// Fallback font family name. Will be used if all other fonts fail to load.
+  ///
+  /// @note  This font should be guaranteed to exist (eg, FontLoader::Load
+  ///        won't fail when passed this font family name).
+  ///
+  virtual String16 fallback_font() const = 0;
+
+  ///
+  /// Fallback font family name that can render the specified characters. This
+  /// is mainly used to support CJK (Chinese, Japanese, Korean) text display.
+  ///
+  /// @param  characters  One or more UTF-16 characters. This is almost always
+  ///                     a single character.
+  ///
+  /// @param  weight      Font weight.
+  ///
+  /// @param  italic      Whether or not italic is requested.
+  ///
+  /// @return  Should return a font family name that can render the text.
+  ///
+  virtual String16 fallback_font_for_characters(const String16& characters,
+                                                int weight,
+                                                bool italic) const = 0;
+
+  ///
+  /// Get the actual font file data (TTF/OTF) for a given font description.
+  /// 
+  /// @param  family  Font family name.
+  ///
+  /// @param  weight  Font weight. 
+  ///
+  /// @param  italic  Whether or not italic is requested.
+  ///
+  /// @return  A font file matching the given description (either an on-disk
+  ///          font filepath or an in-memory file contents). You can return
+  ///          NULL here and the loader will fallback to another font.
+  ///
+  virtual RefPtr<FontFile> Load(const String16& family,
+                                int weight,
+                                bool italic) = 0;
+};
+
+}  // namespace ultralight
diff --git a/engine/inc/Ultralight/platform/GPUDriver.h b/engine/inc/Ultralight/platform/GPUDriver.h
new file mode 100644
index 00000000..902f8925
--- /dev/null
+++ b/engine/inc/Ultralight/platform/GPUDriver.h
@@ -0,0 +1,288 @@
+///
+/// @file GPUDriver.h
+///
+/// @brief The header for the GPUDriver interface.
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+#pragma warning(disable: 4251)
+#include <Ultralight/Defines.h>
+#include <Ultralight/Geometry.h>
+#include <Ultralight/Matrix.h>
+#include <Ultralight/Bitmap.h>
+
+namespace ultralight {
+
+///
+/// @note  This pragma pack(push, 1) command is important! Vertex layouts
+///	       should not be padded with any bytes.
+///
+#pragma pack(push, 1)
+
+///
+/// RenderBuffer description, @see GPUDriver::CreateRenderBuffer.
+///
+struct UExport RenderBuffer {
+  uint32_t texture_id;      // The backing texture for this RenderBuffer
+  uint32_t width;           // The width of the RenderBuffer texture
+  uint32_t height;          // The height of the RenderBuffer texture
+  bool has_stencil_buffer;  // Currently unused, always false.
+  bool has_depth_buffer;    // Currently unsued, always false.
+};
+
+///
+/// Vertex layout for path vertices, useful for synthesizing or modifying
+/// vertex data.
+///
+struct Vertex_2f_4ub_2f {
+  float pos[2];
+  unsigned char color[4];
+  float obj[2];
+};
+
+///
+/// Vertex layout for quad vertices, useful for synthesizing or modifying
+/// vertex data.
+///
+struct Vertex_2f_4ub_2f_2f_28f {
+  float pos[2];
+  unsigned char color[4];
+  float tex[2];
+  float obj[2];
+  float data0[4];
+  float data1[4];
+  float data2[4];
+  float data3[4];
+  float data4[4];
+  float data5[4];
+  float data6[4];
+};
+
+///
+/// Vertex formats
+///
+enum UExport VertexBufferFormat {
+  kVertexBufferFormat_2f_4ub_2f,
+  kVertexBufferFormat_2f_4ub_2f_2f_28f,
+};
+
+///
+/// Vertex buffer, @see GPUDriver::CreateGeometry
+///
+struct UExport VertexBuffer {
+  VertexBufferFormat format;
+  uint32_t size;
+  uint8_t* data;
+};
+
+///
+/// Vertex index type
+///
+typedef uint32_t IndexType;
+
+///
+/// Vertex index buffer, @see GPUDriver::CreateGeometry
+///
+struct UExport IndexBuffer {
+  uint32_t size;
+  uint8_t* data;
+};
+
+///
+/// Shader types, used by GPUState::shader_type
+///
+/// Each of these correspond to a vertex/pixel shader pair. You can find
+/// stock shader code for these in the `shaders` folder of the AppCore repo.
+///
+enum UExport ShaderType {
+  kShaderType_Fill,      // Shader program for quad geometry
+  kShaderType_FillPath,  // Shader program for path geometry
+};
+
+///
+/// GPU state description.
+///
+struct UExport GPUState {
+  /// Viewport width in pixels
+  uint32_t viewport_width;
+  
+  /// Viewport height in pixels
+  uint32_t viewport_height;
+  
+  /// Transform matrix-- you should multiply this with the screen-space
+  /// orthographic projection matrix then pass to the vertex shader.
+  Matrix4x4 transform;
+  
+  /// Whether or not we should enable texturing for the current draw command.
+  bool enable_texturing;
+  
+  /// Whether or not we should enable blending for the current draw command.
+  /// If blending is disabled, any drawn pixels should overwrite existing.
+  /// Mainly used so we can modify alpha values of the RenderBuffer during
+  /// scissored clears.
+  bool enable_blend;
+  
+  /// The vertex/pixel shader program pair to use for the current draw command.
+  /// You should cast this to ShaderType to get the corresponding enum.
+  uint8_t shader_type;
+  
+  /// The render buffer to use for the current draw command.
+  uint32_t render_buffer_id;
+  
+  /// The texture id to bind to slot #1. (Will be 0 if none)
+  uint32_t texture_1_id;
+  
+  /// The texture id to bind to slot #2. (Will be 0 if none)
+  uint32_t texture_2_id;
+  
+  /// The texture id to bind to slot #3. (Will be 0 if none)
+  uint32_t texture_3_id;
+  
+  /// The following four members are passed to the pixel shader via uniforms.
+  float uniform_scalar[8];
+  vec4 uniform_vector[8];
+  uint8_t clip_size;
+  Matrix4x4 clip[8];
+  
+  /// Whether or not scissor testing should be used for the current draw command.
+  bool enable_scissor;
+  
+  /// The scissor rect to use for scissor testing (units in pixels)
+  IntRect scissor_rect;
+};
+
+///
+/// Command types, used by Command::command_type
+///
+enum UExport CommandType {
+  kCommandType_ClearRenderBuffer,
+  kCommandType_DrawGeometry,
+};
+
+///
+/// Command description.
+///
+struct UExport Command {
+  uint8_t command_type;    // The type of command to dispatch.
+  GPUState gpu_state;      // GPU state parameters for current command.
+
+  /// The following members are only used with kCommandType_DrawGeometry
+  uint32_t geometry_id;    // The geometry ID to bind
+  uint32_t indices_count;  // The number of indices
+  uint32_t indices_offset; // The index to start from
+};
+
+///
+/// Command list, @see GPUDriver::UpdateCommandList
+///
+struct UExport CommandList {
+  uint32_t size;
+  Command* commands;
+};
+
+#pragma pack(pop)
+
+///
+/// @brief  GPUDriver interface, dispatches GPU calls to the native driver.
+///
+/// This is automatically provided for you when you use App::Create(), AppCore
+/// provides platform-specific implementations of GPUDriver for each OS.
+///
+/// If you are using Renderer::Create(), you will need to provide your own
+/// implementation of this class if you have enabled the GPU renderer in the
+/// Config. @see Platform::set_gpu_driver
+///
+class UExport GPUDriver {
+public:
+  virtual ~GPUDriver();
+
+  ///
+  /// Called before any commands are dispatched during a frame.
+  ///
+  virtual void BeginSynchronize() = 0;
+
+  ///
+  /// Called after any commands are dispatched during a frame.
+  ///
+  virtual void EndSynchronize() = 0;
+
+  ///
+  /// Get the next available texture ID.
+  ///
+  virtual uint32_t NextTextureId() = 0;
+
+  ///
+  /// Create a texture with a certain ID and optional bitmap.
+  ///
+  /// **NOTE**: If the Bitmap is empty (Bitmap::IsEmpty), then a RTT Texture
+  ///           should be created instead. This will be used as a backing
+  ///           texture for a new RenderBuffer.
+  ///
+  virtual void CreateTexture(uint32_t texture_id,
+                             Ref<Bitmap> bitmap) = 0;
+
+  ///
+  /// Update an existing non-RTT texture with new bitmap data.
+  ///
+  virtual void UpdateTexture(uint32_t texture_id,
+                             Ref<Bitmap> bitmap) = 0;
+
+  ///
+  /// Destroy a texture.
+  ///
+  virtual void DestroyTexture(uint32_t texture_id) = 0;
+
+  ///
+  /// Generate the next available render buffer ID.
+  ///
+  virtual uint32_t NextRenderBufferId() = 0;
+
+  ///
+  /// Create a render buffer with certain ID and buffer description.
+  ///
+  virtual void CreateRenderBuffer(uint32_t render_buffer_id,
+                                  const RenderBuffer& buffer) = 0;
+
+  ///
+  /// Destroy a render buffer
+  ///
+  virtual void DestroyRenderBuffer(uint32_t render_buffer_id) = 0;
+
+  ///
+  /// Generate the next available geometry ID.
+  ///
+  virtual uint32_t NextGeometryId() = 0;
+
+  ///
+  /// Create geometry with certain ID and vertex/index data.
+  ///
+  virtual void CreateGeometry(uint32_t geometry_id,
+                              const VertexBuffer& vertices,
+                              const IndexBuffer& indices) = 0;
+
+  ///
+  /// Update existing geometry with new vertex/index data.
+  ///
+  virtual void UpdateGeometry(uint32_t geometry_id,
+                              const VertexBuffer& vertices,
+                              const IndexBuffer& indices) = 0;
+
+  ///
+  /// Destroy geometry.
+  ///
+  virtual void DestroyGeometry(uint32_t geometry_id) = 0;
+
+  ///
+  /// Update command list (you should copy the commands to your own structure).
+  ///
+  virtual void UpdateCommandList(const CommandList& list) = 0;
+};
+
+}  // namespace ultralight
diff --git a/engine/inc/Ultralight/platform/Logger.h b/engine/inc/Ultralight/platform/Logger.h
new file mode 100644
index 00000000..4aa0603e
--- /dev/null
+++ b/engine/inc/Ultralight/platform/Logger.h
@@ -0,0 +1,47 @@
+///
+/// @file Logger.h
+///
+/// @brief The header for the Logger interface.
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+#include <Ultralight/Defines.h>
+#include <Ultralight/String16.h>
+
+namespace ultralight {
+
+///
+/// Log levels, used with Logger::LogMessage
+///
+enum LogLevel {
+  kLogLevel_Error = 0,
+  kLogLevel_Warning,
+  kLogLevel_Info
+};
+
+///
+/// @brief  Logger interface.
+///          
+/// This can be used to log debug messages to the console or to a log file.
+///
+/// This is intended to be implemented by users and defined before creating the
+/// Renderer. @see Platform::set_file_system.
+///
+class UExport Logger {
+public:
+  virtual ~Logger();
+
+  ///
+  /// Called when the library wants to print a message to the log.
+  ///
+  virtual void LogMessage(LogLevel log_level, const String16& message) = 0;
+};
+
+}  // namespace ultralight
diff --git a/engine/inc/Ultralight/platform/Platform.h b/engine/inc/Ultralight/platform/Platform.h
new file mode 100644
index 00000000..ad92ba9e
--- /dev/null
+++ b/engine/inc/Ultralight/platform/Platform.h
@@ -0,0 +1,141 @@
+///
+/// @file Platform.h
+///
+/// @brief The header for the Platform singleton.
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+#include <Ultralight/Defines.h>
+
+namespace ultralight {
+
+struct Config;
+class Logger;
+class GPUDriver;
+class FontLoader;
+class FileSystem;
+class Clipboard;
+class SurfaceFactory;
+
+///
+/// @brief  Platform singleton to configure Ultralight and provide user-defined
+///         implementations for various platform operations.
+///
+/// @note  All of these settings and user-defined interfaces should be set
+///        BEFORE creating the Renderer.
+///
+class UExport Platform {
+ public:
+  ///
+  /// Get the Platform singleton
+  ///
+  static Platform& instance();
+
+  virtual ~Platform();
+
+  ///
+  /// Set the Config
+  ///
+  virtual void set_config(const Config& config) = 0;
+
+  ///
+  /// Get the Config
+  ///
+  virtual const Config& config() const = 0;
+
+  ///
+  /// Set the Logger (to handle error messages and debug output).
+  ///
+  /// @param  logger  A user-defined Logger implementation, ownership remains
+  ///                 with the caller.
+  ///
+  virtual void set_logger(Logger* logger) = 0;
+
+  ///
+  /// Get the Logger
+  ///
+  virtual Logger* logger() const = 0;
+
+  ///
+  /// Set the GPU Driver (will handle all rendering)
+  ///
+  /// @param  gpu_driver  A user-defined GPUDriver implementation, ownership
+  ///                     remains with the caller.
+  ///
+  virtual void set_gpu_driver(GPUDriver* gpu_driver) = 0;
+
+  ///
+  /// Get the GPU Driver
+  ///
+  virtual GPUDriver* gpu_driver() const = 0;
+
+  ///
+  /// Set the Font Loader (will be used to map font families to actual fonts)
+  ///
+  /// @param  font_loader  A user-defined FontLoader implementation, ownership
+  ///                      remains with the caller.
+  ///
+  virtual void set_font_loader(FontLoader* font_loader) = 0;
+
+  ///
+  /// Get the Font Loader
+  ///
+  virtual FontLoader* font_loader() const = 0;
+
+  ///
+  /// Set the File System (will be used for all file system operations)
+  ///
+  /// @param  file_system  A user-defined FileSystem implementation, ownership
+  ///                      remains with the caller.
+  ///
+  virtual void set_file_system(FileSystem* file_system) = 0;
+
+  ///
+  /// Get the File System
+  ///
+  virtual FileSystem* file_system() const = 0;
+
+  ///
+  /// Set the Clipboard (will be used for all clipboard operations)
+  ///
+  /// @param  clipboard  A user-defined Clipboard implementation, ownership
+  ///                    remains with the caller.
+  ///
+  virtual void set_clipboard(Clipboard* clipboard) = 0;
+
+  ///
+  /// Get the Clipboard
+  ///
+  virtual Clipboard* clipboard() const = 0;
+
+  ///
+  /// Set the SurfaceFactory
+  ///
+  /// This can be used to provide a platform-specific bitmap surface for View
+  /// to paint into when the CPU renderer is enabled. See View::surface().
+  ///
+  /// @param  surface_factory  A user-defined SurfaceFactory implementation,
+  ///                          ownership remains with the caller.
+  ///
+  /// @note  A default BitmapSurfaceFactory is defined if you never call this,
+  ///        View::surface() can be safely cast to BitmapSurface.
+  ///
+  virtual void set_surface_factory(SurfaceFactory* surface_factory) = 0;
+
+  ///
+  /// Get the SurfaceFactory
+  ///
+  /// @note  A default BitmapSurfaceFactory is set by default, View::surface()
+  ///        can be safely cast to BitmapSurface if you don't define your own.
+  ///
+  virtual SurfaceFactory* surface_factory() const = 0;
+};
+
+}  // namespace ultralight
diff --git a/engine/inc/Ultralight/platform/Surface.h b/engine/inc/Ultralight/platform/Surface.h
new file mode 100644
index 00000000..6d2af244
--- /dev/null
+++ b/engine/inc/Ultralight/platform/Surface.h
@@ -0,0 +1,191 @@
+///
+/// @file Surface.h
+///
+/// @brief The header for the Surface and SurfaceFactory interfaces.
+///
+/// @author
+///
+/// This file is a part of Ultralight, a fast, lightweight, HTML UI engine
+///
+/// Website: <http://ultralig.ht>
+///
+/// Copyright (C) 2020 Ultralight, Inc. All rights reserved.
+///
+#pragma once
+#include <Ultralight/Defines.h>
+#include <Ultralight/RefPtr.h>
+#include <Ultralight/Bitmap.h>
+#include <Ultralight/Geometry.h>
+
+namespace ultralight {
+
+///
+/// Offscreen pixel buffer surface. (Premultiplied BGRA 32-bit format)
+///
+/// When using the CPU renderer, each View is painted to its own Surface.
+///
+/// You can provide your own Surface implementation to make the renderer
+/// paint directly to a block of memory controlled by you (this is useful for
+/// lower-latency uploads to GPU memory or other platform-specific bitmaps).
+///
+/// A default Surface implementation, BitmapSurface, is automatically
+/// provided by the library when you call Renderer::Create() without defining
+/// a custom SurfaceFactory.
+///
+/// To provide your own custom Surface implementation, you should inherit
+/// from this class, handle the virtual member functions, and then define a
+/// custom SurfaceFactory that creates/destroys an instance of your class.
+/// After that, you should pass an instance of your custom SurfaceFactory class
+/// to `Platform::instance().set_font_loader()` before calling App::Create()
+/// or Renderer::Create().
+///
+class UExport Surface {
+public:
+  virtual ~Surface();
+
+  ///
+  /// Width (in pixels).
+  ///
+  virtual uint32_t width() const = 0;
+
+  ///
+  /// Height (in pixels).
+  ///
+  virtual uint32_t height() const = 0;
+
+  ///
+  /// Number of bytes between rows (usually width * 4)
+  ///
+  virtual uint32_t row_bytes() const = 0;
+
+  ///
+  /// Size in bytes.
+  ///
+  virtual size_t size() const = 0;
+
+  ///
+  /// Lock the pixel buffer and get a pointer to the beginning of the data
+  /// for reading/writing.
+  ///
+  /// Native pixel format is premultiplied BGRA 32-bit (8 bits per channel).
+  ///
+  virtual void* LockPixels() = 0;
+
+  ///
+  /// Unlock the pixel buffer.
+  ///
+  virtual void UnlockPixels() = 0;
+
+  ///
+  /// Resize the pixel buffer to a certain width and height (both in pixels).
+  ///
+  /// This should never be called while pixels are locked. 
+  ///
+  virtual void Resize(uint32_t width, uint32_t height) = 0;
+
+  ///
+  /// Set the dirty bounds to a certain value.
+  ///
+  /// This is called after the Renderer paints to an area of the pixel buffer.
+  /// (The new value will be joined with the existing dirty_bounds())
+  ///
+  virtual void set_dirty_bounds(const IntRect& bounds);
+
+  ///
+  /// Get the dirty bounds.
+  ///
+  /// This value can be used to determine which portion of the pixel buffer has
+  /// been updated since the last call to ClearDirtyBounds().
+  ///
+  /// The general algorithm to determine if a Surface needs display is:
+  /// <pre>
+  ///   if (!surface.dirty_bounds().IsEmpty()) {
+  ///       // Surface pixels are dirty and needs display.
+  ///       // Cast Surface to native Surface and use it here (pseudo code)
+  ///       DisplaySurface(surface);
+  ///
+  ///       // Once you're done, clear the dirty bounds:
+  ///       surface.ClearDirtyBounds();
+  ///  }
+  ///  </pre>
+  ///
+  virtual IntRect dirty_bounds() const;
+
+  ///
+  /// Clear the dirty bounds.
+  ///
+  /// You should call this after you're done displaying the Surface.
+  ///
+  virtual void ClearDirtyBounds();
+
+protected:
+  Surface();
+
+  IntRect dirty_bounds_;
+};
+
+///
+/// SurfaceFactory can be used to provide your own native Surface implementation.
+///
+/// This can be used to wrap a platform-specific GPU texture, Windows DIB,
+/// macOS CGImage, or any other pixel buffer target for display on screen.
+///
+/// The default factory creates/destroys a BitmapSurface but you can override
+/// this by providing your own factory to Platform::set_surface_factory.
+///
+class UExport SurfaceFactory {
+public:
+  virtual ~SurfaceFactory();
+
+  ///
+  /// Create a native Surface with a certain width and height (in pixels).
+  ///
+  virtual Surface* CreateSurface(uint32_t width, uint32_t height) = 0;
+
+  ///
+  /// Destroy a native Surface previously created by CreateSurface().
+  ///
+  virtual void DestroySurface(Surface* surface) = 0;
+};
+
+///
+/// The default Surface implementation, backed by a Bitmap.
+///
+class UExport BitmapSurface : public Surface {
+public:
+  virtual uint32_t width() const override;
+
+  virtual uint32_t height() const override;
+
+  virtual uint32_t row_bytes() const override;
+
+  virtual size_t size() const override;
+
+  virtual void* LockPixels() override;
+
+  virtual void UnlockPixels() override;
+
+  virtual void Resize(uint32_t width, uint32_t height) override;
+
+  ///
+  /// Get the underlying Bitmap.
+  ///
+  RefPtr<Bitmap> bitmap();
+
+protected:
+  BitmapSurface(uint32_t width, uint32_t height);
+  virtual ~BitmapSurface();
+  BitmapSurface(const BitmapSurface&) = delete;
+  void operator=(const BitmapSurface&) = delete;
+  friend class BitmapSurfaceFactory;
+
+  void* impl_;
+};
+
+///
+/// Get the default Bitmap Surface Factory singleton. (Do not destroy this,
+/// this singleton is owned by the library).
+///
+UExport SurfaceFactory* GetBitmapSurfaceFactory();
+
+}  // namespace ultralight
diff --git a/engine/inc/Ultralight/private/PlatformFileSystem.h b/engine/inc/Ultralight/private/PlatformFileSystem.h
new file mode 100644
index 00000000..9b5a98a3
--- /dev/null
+++ b/engine/inc/Ultralight/private/PlatformFileSystem.h
@@ -0,0 +1,17 @@
+#pragma once
+#include <Ultralight/Defines.h>
+#include <Ultralight/String.h>
+
+namespace ultralight {
+namespace PlatformFileSystem {
+
+bool UExport FileExists(const String& path);
+bool UExport IsDirectory(const String& path, bool follow_symbolic_links);
+String UExport AppendPath(const String& path, const String& component);
+bool UExport MakeAllDirectories(const String& path);
+String UExport GetFileName(const String& path);
+String UExport GetDirectoryName(const String& path);
+String UExport RealFilePath(const String& path);
+
+}  // PlatformFileSystem
+}  // ultralight
diff --git a/engine/inc/assimp/.editorconfig b/engine/inc/assimp/.editorconfig
new file mode 100644
index 00000000..9ea66423
--- /dev/null
+++ b/engine/inc/assimp/.editorconfig
@@ -0,0 +1,8 @@
+# See <http://EditorConfig.org> for details
+
+[*.{h,hpp,inl}]
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_size = 4
+indent_style = space
diff --git a/engine/inc/assimp/BaseImporter.h b/engine/inc/assimp/BaseImporter.h
new file mode 100644
index 00000000..0c0fd110
--- /dev/null
+++ b/engine/inc/assimp/BaseImporter.h
@@ -0,0 +1,362 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file Definition of the base class for all importer worker classes. */
+#ifndef INCLUDED_AI_BASEIMPORTER_H
+#define INCLUDED_AI_BASEIMPORTER_H
+
+#include "Exceptional.h"
+
+#include <vector>
+#include <set>
+#include <assimp/types.h>
+#include <assimp/ProgressHandler.hpp>
+
+struct aiScene;
+struct aiImporterDesc;
+
+namespace Assimp    {
+
+class Importer;
+class IOSystem;
+class BaseProcess;
+class SharedPostProcessInfo;
+class IOStream;
+
+// utility to do char4 to uint32 in a portable manner
+#define AI_MAKE_MAGIC(string) ((uint32_t)((string[0] << 24) + \
+    (string[1] << 16) + (string[2] << 8) + string[3]))
+
+
+// ---------------------------------------------------------------------------
+/** FOR IMPORTER PLUGINS ONLY: The BaseImporter defines a common interface
+ *  for all importer worker classes.
+ *
+ * The interface defines two functions: CanRead() is used to check if the
+ * importer can handle the format of the given file. If an implementation of
+ * this function returns true, the importer then calls ReadFile() which
+ * imports the given file. ReadFile is not overridable, it just calls
+ * InternReadFile() and catches any ImportErrorException that might occur.
+ */
+class ASSIMP_API BaseImporter
+{
+    friend class Importer;
+
+public:
+
+    /** Constructor to be privately used by #Importer */
+    BaseImporter();
+
+    /** Destructor, private as well */
+    virtual ~BaseImporter();
+
+public:
+    // -------------------------------------------------------------------
+    /** Returns whether the class can handle the format of the given file.
+     *
+     * The implementation should be as quick as possible. A check for
+     * the file extension is enough. If no suitable loader is found with
+     * this strategy, CanRead() is called again, the 'checkSig' parameter
+     * set to true this time. Now the implementation is expected to
+     * perform a full check of the file structure, possibly searching the
+     * first bytes of the file for magic identifiers or keywords.
+     *
+     * @param pFile Path and file name of the file to be examined.
+     * @param pIOHandler The IO handler to use for accessing any file.
+     * @param checkSig Set to true if this method is called a second time.
+     *   This time, the implementation may take more time to examine the
+     *   contents of the file to be loaded for magic bytes, keywords, etc
+     *   to be able to load files with unknown/not existent file extensions.
+     * @return true if the class can read this file, false if not.
+     */
+    virtual bool CanRead(
+        const std::string& pFile,
+        IOSystem* pIOHandler,
+        bool checkSig
+        ) const = 0;
+
+    // -------------------------------------------------------------------
+    /** Imports the given file and returns the imported data.
+     * If the import succeeds, ownership of the data is transferred to
+     * the caller. If the import fails, NULL is returned. The function
+     * takes care that any partially constructed data is destroyed
+     * beforehand.
+     *
+     * @param pImp #Importer object hosting this loader.
+     * @param pFile Path of the file to be imported.
+     * @param pIOHandler IO-Handler used to open this and possible other files.
+     * @return The imported data or NULL if failed. If it failed a
+     * human-readable error description can be retrieved by calling
+     * GetErrorText()
+     *
+     * @note This function is not intended to be overridden. Implement
+     * InternReadFile() to do the import. If an exception is thrown somewhere
+     * in InternReadFile(), this function will catch it and transform it into
+     *  a suitable response to the caller.
+     */
+    aiScene* ReadFile(
+        const Importer* pImp,
+        const std::string& pFile,
+        IOSystem* pIOHandler
+        );
+
+    // -------------------------------------------------------------------
+    /** Returns the error description of the last error that occurred.
+     * @return A description of the last error that occurred. An empty
+     * string if there was no error.
+     */
+    const std::string& GetErrorText() const {
+        return m_ErrorText;
+    }
+
+    // -------------------------------------------------------------------
+    /** Called prior to ReadFile().
+     * The function is a request to the importer to update its configuration
+     * basing on the Importer's configuration property list.
+     * @param pImp Importer instance
+     */
+    virtual void SetupProperties(
+        const Importer* pImp
+        );
+
+    // -------------------------------------------------------------------
+    /** Called by #Importer::GetImporterInfo to get a description of
+     *  some loader features. Importers must provide this information. */
+    virtual const aiImporterDesc* GetInfo() const = 0;
+
+    // -------------------------------------------------------------------
+    /** Called by #Importer::GetExtensionList for each loaded importer.
+     *  Take the extension list contained in the structure returned by
+     *  #GetInfo and insert all file extensions into the given set.
+     *  @param extension set to collect file extensions in*/
+    void GetExtensionList(std::set<std::string>& extensions);
+
+protected:
+
+    // -------------------------------------------------------------------
+    /** Imports the given file into the given scene structure. The
+     * function is expected to throw an ImportErrorException if there is
+     * an error. If it terminates normally, the data in aiScene is
+     * expected to be correct. Override this function to implement the
+     * actual importing.
+     * <br>
+     *  The output scene must meet the following requirements:<br>
+     * <ul>
+     * <li>At least a root node must be there, even if its only purpose
+     *     is to reference one mesh.</li>
+     * <li>aiMesh::mPrimitiveTypes may be 0. The types of primitives
+     *   in the mesh are determined automatically in this case.</li>
+     * <li>the vertex data is stored in a pseudo-indexed "verbose" format.
+     *   In fact this means that every vertex that is referenced by
+     *   a face is unique. Or the other way round: a vertex index may
+     *   not occur twice in a single aiMesh.</li>
+     * <li>aiAnimation::mDuration may be -1. Assimp determines the length
+     *   of the animation automatically in this case as the length of
+     *   the longest animation channel.</li>
+     * <li>aiMesh::mBitangents may be NULL if tangents and normals are
+     *   given. In this case bitangents are computed as the cross product
+     *   between normal and tangent.</li>
+     * <li>There needn't be a material. If none is there a default material
+     *   is generated. However, it is recommended practice for loaders
+     *   to generate a default material for yourself that matches the
+     *   default material setting for the file format better than Assimp's
+     *   generic default material. Note that default materials *should*
+     *   be named AI_DEFAULT_MATERIAL_NAME if they're just color-shaded
+     *   or AI_DEFAULT_TEXTURED_MATERIAL_NAME if they define a (dummy)
+     *   texture. </li>
+     * </ul>
+     * If the AI_SCENE_FLAGS_INCOMPLETE-Flag is <b>not</b> set:<ul>
+     * <li> at least one mesh must be there</li>
+     * <li> there may be no meshes with 0 vertices or faces</li>
+     * </ul>
+     * This won't be checked (except by the validation step): Assimp will
+     * crash if one of the conditions is not met!
+     *
+     * @param pFile Path of the file to be imported.
+     * @param pScene The scene object to hold the imported data.
+     * NULL is not a valid parameter.
+     * @param pIOHandler The IO handler to use for any file access.
+     * NULL is not a valid parameter. */
+    virtual void InternReadFile(
+        const std::string& pFile,
+        aiScene* pScene,
+        IOSystem* pIOHandler
+        ) = 0;
+
+public: // static utilities
+
+    // -------------------------------------------------------------------
+    /** A utility for CanRead().
+     *
+     *  The function searches the header of a file for a specific token
+     *  and returns true if this token is found. This works for text
+     *  files only. There is a rudimentary handling of UNICODE files.
+     *  The comparison is case independent.
+     *
+     *  @param pIOSystem IO System to work with
+     *  @param file File name of the file
+     *  @param tokens List of tokens to search for
+     *  @param numTokens Size of the token array
+     *  @param searchBytes Number of bytes to be searched for the tokens.
+     */
+    static bool SearchFileHeaderForToken(
+        IOSystem* pIOSystem,
+        const std::string&  file,
+        const char** tokens,
+        unsigned int numTokens,
+        unsigned int searchBytes = 200,
+        bool tokensSol = false);
+
+    // -------------------------------------------------------------------
+    /** @brief Check whether a file has a specific file extension
+     *  @param pFile Input file
+     *  @param ext0 Extension to check for. Lowercase characters only, no dot!
+     *  @param ext1 Optional second extension
+     *  @param ext2 Optional third extension
+     *  @note Case-insensitive
+     */
+    static bool SimpleExtensionCheck (
+        const std::string& pFile,
+        const char* ext0,
+        const char* ext1 = NULL,
+        const char* ext2 = NULL);
+
+    // -------------------------------------------------------------------
+    /** @brief Extract file extension from a string
+     *  @param pFile Input file
+     *  @return Extension without trailing dot, all lowercase
+     */
+    static std::string GetExtension (
+        const std::string& pFile);
+
+    // -------------------------------------------------------------------
+    /** @brief Check whether a file starts with one or more magic tokens
+     *  @param pFile Input file
+     *  @param pIOHandler IO system to be used
+     *  @param magic n magic tokens
+     *  @params num Size of magic
+     *  @param offset Offset from file start where tokens are located
+     *  @param Size of one token, in bytes. Maximally 16 bytes.
+     *  @return true if one of the given tokens was found
+     *
+     *  @note For convenience, the check is also performed for the
+     *  byte-swapped variant of all tokens (big endian). Only for
+     *  tokens of size 2,4.
+     */
+    static bool CheckMagicToken(
+        IOSystem* pIOHandler,
+        const std::string& pFile,
+        const void* magic,
+        unsigned int num,
+        unsigned int offset = 0,
+        unsigned int size   = 4);
+
+    // -------------------------------------------------------------------
+    /** An utility for all text file loaders. It converts a file to our
+     *   UTF8 character set. Errors are reported, but ignored.
+     *
+     *  @param data File buffer to be converted to UTF8 data. The buffer
+     *  is resized as appropriate. */
+    static void ConvertToUTF8(
+        std::vector<char>& data);
+
+    // -------------------------------------------------------------------
+    /** An utility for all text file loaders. It converts a file from our
+     *   UTF8 character set back to ISO-8859-1. Errors are reported, but ignored.
+     *
+     *  @param data File buffer to be converted from UTF8 to ISO-8859-1. The buffer
+     *  is resized as appropriate. */
+    static void ConvertUTF8toISO8859_1(
+        std::string& data);
+
+    // -------------------------------------------------------------------
+    /// @brief  Enum to define, if empty files are ok or not.
+    enum TextFileMode { 
+        ALLOW_EMPTY,
+        FORBID_EMPTY 
+    };
+
+    // -------------------------------------------------------------------
+    /** Utility for text file loaders which copies the contents of the
+     *  file into a memory buffer and converts it to our UTF8
+     *  representation.
+     *  @param stream Stream to read from.
+     *  @param data Output buffer to be resized and filled with the
+     *   converted text file data. The buffer is terminated with
+     *   a binary 0.
+     *  @param mode Whether it is OK to load empty text files. */
+    static void TextFileToBuffer(
+        IOStream* stream,
+        std::vector<char>& data,
+        TextFileMode mode = FORBID_EMPTY);
+
+    // -------------------------------------------------------------------
+    /** Utility function to move a std::vector into a aiScene array
+    *  @param vec The vector to be moved
+    *  @param out The output pointer to the allocated array.
+    *  @param numOut The output count of elements copied. */
+    template<typename T>
+    AI_FORCE_INLINE
+    static void CopyVector(
+        std::vector<T>& vec,
+        T*& out,
+        unsigned int& outLength)
+    {
+        outLength = unsigned(vec.size());
+        if (outLength) {
+            out = new T[outLength];
+            std::swap_ranges(vec.begin(), vec.end(), out);
+        }
+    }
+
+protected:
+    /// Error description in case there was one.
+    std::string m_ErrorText;
+    /// Currently set progress handler.
+    ProgressHandler* m_progress;
+};
+
+
+
+} // end of namespace Assimp
+
+#endif // AI_BASEIMPORTER_H_INC
diff --git a/engine/inc/assimp/Bitmap.h b/engine/inc/assimp/Bitmap.h
new file mode 100644
index 00000000..20911686
--- /dev/null
+++ b/engine/inc/assimp/Bitmap.h
@@ -0,0 +1,125 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file Bitmap.h
+ *  @brief Defines bitmap format helper for textures
+ *
+ * Used for file formats which embed their textures into the model file.
+ */
+
+#ifndef AI_BITMAP_H_INC
+#define AI_BITMAP_H_INC
+
+#include "defs.h"
+#include <stdint.h>
+#include <cstddef>
+
+struct aiTexture;
+
+namespace Assimp {
+
+class IOStream;
+
+class ASSIMP_API Bitmap {
+protected:
+
+    struct Header {
+        uint16_t type;
+        uint32_t size;
+        uint16_t reserved1;
+        uint16_t reserved2;
+        uint32_t offset;
+
+        // We define the struct size because sizeof(Header) might return a wrong result because of structure padding.
+        // Moreover, we must use this ugly and error prone syntax because Visual Studio neither support constexpr or sizeof(name_of_field).
+        static const std::size_t header_size =
+            sizeof(uint16_t) + // type
+            sizeof(uint32_t) + // size
+            sizeof(uint16_t) + // reserved1
+            sizeof(uint16_t) + // reserved2
+            sizeof(uint32_t);  // offset
+    };
+
+    struct DIB {
+        uint32_t size;
+        int32_t width;
+        int32_t height;
+        uint16_t planes;
+        uint16_t bits_per_pixel;
+        uint32_t compression;
+        uint32_t image_size;
+        int32_t x_resolution;
+        int32_t y_resolution;
+        uint32_t nb_colors;
+        uint32_t nb_important_colors;
+
+        // We define the struct size because sizeof(DIB) might return a wrong result because of structure padding.
+        // Moreover, we must use this ugly and error prone syntax because Visual Studio neither support constexpr or sizeof(name_of_field).
+        static const std::size_t dib_size =
+            sizeof(uint32_t) + // size
+            sizeof(int32_t) +  // width
+            sizeof(int32_t) +  // height
+            sizeof(uint16_t) + // planes
+            sizeof(uint16_t) + // bits_per_pixel
+            sizeof(uint32_t) + // compression
+            sizeof(uint32_t) + // image_size
+            sizeof(int32_t) +  // x_resolution
+            sizeof(int32_t) +  // y_resolution
+            sizeof(uint32_t) + // nb_colors
+            sizeof(uint32_t);  // nb_important_colors
+    };
+
+    static const std::size_t mBytesPerPixel = 4;
+
+public:
+    static void Save(aiTexture* texture, IOStream* file);
+
+protected:
+    static void WriteHeader(Header& header, IOStream* file);
+    static void WriteDIB(DIB& dib, IOStream* file);
+    static void WriteData(aiTexture* texture, IOStream* file);
+};
+
+}
+
+#endif // AI_BITMAP_H_INC
diff --git a/engine/inc/assimp/BlobIOSystem.h b/engine/inc/assimp/BlobIOSystem.h
new file mode 100644
index 00000000..3c1691d5
--- /dev/null
+++ b/engine/inc/assimp/BlobIOSystem.h
@@ -0,0 +1,338 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file Provides cheat implementations for IOSystem and IOStream to
+ *  redirect exporter output to a blob chain.*/
+
+#ifndef AI_BLOBIOSYSTEM_H_INCLUDED
+#define AI_BLOBIOSYSTEM_H_INCLUDED
+
+#include <assimp/IOStream.hpp>
+#include <assimp/cexport.h>
+#include <assimp/IOSystem.hpp>
+#include <assimp/DefaultLogger.hpp>
+#include <stdint.h>
+#include <set>
+#include <vector>
+
+namespace Assimp    {
+    class BlobIOSystem;
+
+// --------------------------------------------------------------------------------------------
+/** Redirect IOStream to a blob */
+// --------------------------------------------------------------------------------------------
+class BlobIOStream : public IOStream
+{
+public:
+
+    BlobIOStream(BlobIOSystem* creator, const std::string& file, size_t initial = 4096)
+        : buffer()
+        , cur_size()
+        , file_size()
+        , cursor()
+        , initial(initial)
+        , file(file)
+        , creator(creator)
+    {
+    }
+
+
+    virtual ~BlobIOStream();
+
+public:
+
+    // -------------------------------------------------------------------
+    aiExportDataBlob* GetBlob()
+    {
+        aiExportDataBlob* blob = new aiExportDataBlob();
+        blob->size = file_size;
+        blob->data = buffer;
+
+        buffer = NULL;
+
+        return blob;
+    }
+
+
+public:
+
+
+    // -------------------------------------------------------------------
+    virtual size_t Read( void *,
+        size_t,
+        size_t )
+    {
+        return 0;
+    }
+
+    // -------------------------------------------------------------------
+    virtual size_t Write(const void* pvBuffer,
+        size_t pSize,
+        size_t pCount)
+    {
+        pSize *= pCount;
+        if (cursor + pSize > cur_size) {
+            Grow(cursor + pSize);
+        }
+
+        memcpy(buffer+cursor, pvBuffer, pSize);
+        cursor += pSize;
+
+        file_size = std::max(file_size,cursor);
+        return pCount;
+    }
+
+    // -------------------------------------------------------------------
+    virtual aiReturn Seek(size_t pOffset,
+        aiOrigin pOrigin)
+    {
+        switch(pOrigin)
+        {
+        case aiOrigin_CUR:
+            cursor += pOffset;
+            break;
+
+        case aiOrigin_END:
+            cursor = file_size - pOffset;
+            break;
+
+        case aiOrigin_SET:
+            cursor = pOffset;
+            break;
+
+        default:
+            return AI_FAILURE;
+        }
+
+        if (cursor > file_size) {
+            Grow(cursor);
+        }
+
+        file_size = std::max(cursor,file_size);
+        return AI_SUCCESS;
+    }
+
+    // -------------------------------------------------------------------
+    virtual size_t Tell() const
+    {
+        return cursor;
+    }
+
+    // -------------------------------------------------------------------
+    virtual size_t FileSize() const
+    {
+        return file_size;
+    }
+
+    // -------------------------------------------------------------------
+    virtual void Flush()
+    {
+        // ignore
+    }
+
+
+
+private:
+
+    // -------------------------------------------------------------------
+    void Grow(size_t need = 0)
+    {
+        // 1.5 and phi are very heap-friendly growth factors (the first
+        // allows for frequent re-use of heap blocks, the second
+        // forms a fibonacci sequence with similar characteristics -
+        // since this heavily depends on the heap implementation
+        // and other factors as well, i'll just go with 1.5 since
+        // it is quicker to compute).
+        size_t new_size = std::max(initial, std::max( need, cur_size+(cur_size>>1) ));
+
+        const uint8_t* const old = buffer;
+        buffer = new uint8_t[new_size];
+
+        if (old) {
+            memcpy(buffer,old,cur_size);
+            delete[] old;
+        }
+
+        cur_size = new_size;
+    }
+
+private:
+
+    uint8_t* buffer;
+    size_t cur_size,file_size, cursor, initial;
+
+    const std::string file;
+    BlobIOSystem* const creator;
+};
+
+
+#define AI_BLOBIO_MAGIC "$blobfile"
+
+// --------------------------------------------------------------------------------------------
+/** Redirect IOSystem to a blob */
+// --------------------------------------------------------------------------------------------
+class BlobIOSystem : public IOSystem
+{
+
+    friend class BlobIOStream;
+    typedef std::pair<std::string, aiExportDataBlob*> BlobEntry;
+
+public:
+
+    BlobIOSystem()
+    {
+    }
+
+    virtual ~BlobIOSystem()
+    {
+        for(BlobEntry& blobby : blobs) {
+            delete blobby.second;
+        }
+    }
+
+public:
+
+    // -------------------------------------------------------------------
+    const char* GetMagicFileName() const
+    {
+        return AI_BLOBIO_MAGIC;
+    }
+
+
+    // -------------------------------------------------------------------
+    aiExportDataBlob* GetBlobChain()
+    {
+        // one must be the master
+        aiExportDataBlob* master = NULL, *cur;
+        for(const BlobEntry& blobby : blobs) {
+            if (blobby.first == AI_BLOBIO_MAGIC) {
+                master = blobby.second;
+                break;
+            }
+        }
+        if (!master) {
+            DefaultLogger::get()->error("BlobIOSystem: no data written or master file was not closed properly.");
+            return NULL;
+        }
+
+        master->name.Set("");
+
+        cur = master;
+        for(const BlobEntry& blobby : blobs) {
+            if (blobby.second == master) {
+                continue;
+            }
+
+            cur->next = blobby.second;
+            cur = cur->next;
+
+            // extract the file extension from the file written
+            const std::string::size_type s = blobby.first.find_first_of('.');
+            cur->name.Set(s == std::string::npos ? blobby.first : blobby.first.substr(s+1));
+        }
+
+        // give up blob ownership
+        blobs.clear();
+        return master;
+    }
+
+public:
+
+    // -------------------------------------------------------------------
+    virtual bool Exists( const char* pFile) const {
+        return created.find(std::string(pFile)) != created.end();
+    }
+
+
+    // -------------------------------------------------------------------
+    virtual char getOsSeparator() const {
+        return '/';
+    }
+
+
+    // -------------------------------------------------------------------
+    virtual IOStream* Open(const char* pFile,
+        const char* pMode)
+    {
+        if (pMode[0] != 'w') {
+            return NULL;
+        }
+
+        created.insert(std::string(pFile));
+        return new BlobIOStream(this,std::string(pFile));
+    }
+
+    // -------------------------------------------------------------------
+    virtual void Close( IOStream* pFile)
+    {
+        delete pFile;
+    }
+
+private:
+
+    // -------------------------------------------------------------------
+    void OnDestruct(const std::string& filename, BlobIOStream* child)
+    {
+        // we don't know in which the files are closed, so we
+        // can't reliably say that the first must be the master
+        // file ...
+        blobs.push_back( BlobEntry(filename,child->GetBlob()) );
+    }
+
+private:
+    std::set<std::string> created;
+    std::vector< BlobEntry > blobs;
+};
+
+
+// --------------------------------------------------------------------------------------------
+BlobIOStream :: ~BlobIOStream()
+{
+    creator->OnDestruct(file,this);
+    delete[] buffer;
+}
+
+
+} // end Assimp
+
+#endif
diff --git a/engine/inc/assimp/ByteSwapper.h b/engine/inc/assimp/ByteSwapper.h
new file mode 100644
index 00000000..136944f2
--- /dev/null
+++ b/engine/inc/assimp/ByteSwapper.h
@@ -0,0 +1,288 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file Helper class tp perform various byte oder swappings
+   (e.g. little to big endian) */
+#ifndef AI_BYTESWAPPER_H_INC
+#define AI_BYTESWAPPER_H_INC
+
+#include <assimp/ai_assert.h>
+#include <assimp/types.h>
+#include <stdint.h>
+
+#if _MSC_VER >= 1400
+#include <stdlib.h>
+#endif
+
+namespace Assimp    {
+// --------------------------------------------------------------------------------------
+/** Defines some useful byte order swap routines.
+ *
+ * This is required to read big-endian model formats on little-endian machines,
+ * and vice versa. Direct use of this class is DEPRECATED. Use #StreamReader instead. */
+// --------------------------------------------------------------------------------------
+class ByteSwap
+{
+    ByteSwap() {}
+
+public:
+
+    // ----------------------------------------------------------------------
+    /** Swap two bytes of data
+     *  @param[inout] _szOut A void* to save the reintcasts for the caller. */
+    static inline void Swap2(void* _szOut)
+    {
+        ai_assert(_szOut);
+
+#if _MSC_VER >= 1400
+        uint16_t* const szOut = reinterpret_cast<uint16_t*>(_szOut);
+        *szOut = _byteswap_ushort(*szOut);
+#else
+        uint8_t* const szOut = reinterpret_cast<uint8_t*>(_szOut);
+        std::swap(szOut[0],szOut[1]);
+#endif
+    }
+
+    // ----------------------------------------------------------------------
+    /** Swap four bytes of data
+     *  @param[inout] _szOut A void* to save the reintcasts for the caller. */
+    static inline void Swap4(void* _szOut)
+    {
+        ai_assert(_szOut);
+
+#if _MSC_VER >= 1400
+        uint32_t* const szOut = reinterpret_cast<uint32_t*>(_szOut);
+        *szOut = _byteswap_ulong(*szOut);
+#else
+        uint8_t* const szOut = reinterpret_cast<uint8_t*>(_szOut);
+        std::swap(szOut[0],szOut[3]);
+        std::swap(szOut[1],szOut[2]);
+#endif
+    }
+
+    // ----------------------------------------------------------------------
+    /** Swap eight bytes of data
+     *  @param[inout] _szOut A void* to save the reintcasts for the caller. */
+    static inline void Swap8(void* _szOut)
+    {
+    ai_assert(_szOut);
+
+#if _MSC_VER >= 1400
+        uint64_t* const szOut = reinterpret_cast<uint64_t*>(_szOut);
+        *szOut = _byteswap_uint64(*szOut);
+#else
+        uint8_t* const szOut = reinterpret_cast<uint8_t*>(_szOut);
+        std::swap(szOut[0],szOut[7]);
+        std::swap(szOut[1],szOut[6]);
+        std::swap(szOut[2],szOut[5]);
+        std::swap(szOut[3],szOut[4]);
+#endif
+    }
+
+    // ----------------------------------------------------------------------
+    /** ByteSwap a float. Not a joke.
+     *  @param[inout] fOut ehm. .. */
+    static inline void Swap(float* fOut) {
+        Swap4(fOut);
+    }
+
+    // ----------------------------------------------------------------------
+    /** ByteSwap a double. Not a joke.
+     *  @param[inout] fOut ehm. .. */
+    static inline void Swap(double* fOut) {
+        Swap8(fOut);
+    }
+
+
+    // ----------------------------------------------------------------------
+    /** ByteSwap an int16t. Not a joke.
+     *  @param[inout] fOut ehm. .. */
+    static inline void Swap(int16_t* fOut) {
+        Swap2(fOut);
+    }
+
+    static inline void Swap(uint16_t* fOut) {
+        Swap2(fOut);
+    }
+
+    // ----------------------------------------------------------------------
+    /** ByteSwap an int32t. Not a joke.
+     *  @param[inout] fOut ehm. .. */
+    static inline void Swap(int32_t* fOut){
+        Swap4(fOut);
+    }
+
+    static inline void Swap(uint32_t* fOut){
+        Swap4(fOut);
+    }
+
+    // ----------------------------------------------------------------------
+    /** ByteSwap an int64t. Not a joke.
+     *  @param[inout] fOut ehm. .. */
+    static inline void Swap(int64_t* fOut) {
+        Swap8(fOut);
+    }
+
+    static inline void Swap(uint64_t* fOut) {
+        Swap8(fOut);
+    }
+
+    // ----------------------------------------------------------------------
+    //! Templatized ByteSwap
+    //! \returns param tOut as swapped
+    template<typename Type>
+    static inline Type Swapped(Type tOut)
+    {
+        return _swapper<Type,sizeof(Type)>()(tOut);
+    }
+
+private:
+
+    template <typename T, size_t size> struct _swapper;
+};
+
+template <typename T> struct ByteSwap::_swapper<T,2> {
+    T operator() (T tOut) {
+        Swap2(&tOut);
+        return tOut;
+    }
+};
+
+template <typename T> struct ByteSwap::_swapper<T,4> {
+    T operator() (T tOut) {
+        Swap4(&tOut);
+        return tOut;
+    }
+};
+
+template <typename T> struct ByteSwap::_swapper<T,8> {
+    T operator() (T tOut) {
+        Swap8(&tOut);
+        return tOut;
+    }
+};
+
+
+// --------------------------------------------------------------------------------------
+// ByteSwap macros for BigEndian/LittleEndian support
+// --------------------------------------------------------------------------------------
+#if (defined AI_BUILD_BIG_ENDIAN)
+#   define AI_LE(t) (t)
+#   define AI_BE(t) ByteSwap::Swapped(t)
+#   define AI_LSWAP2(p)
+#   define AI_LSWAP4(p)
+#   define AI_LSWAP8(p)
+#   define AI_LSWAP2P(p)
+#   define AI_LSWAP4P(p)
+#   define AI_LSWAP8P(p)
+#   define LE_NCONST const
+#   define AI_SWAP2(p) ByteSwap::Swap2(&(p))
+#   define AI_SWAP4(p) ByteSwap::Swap4(&(p))
+#   define AI_SWAP8(p) ByteSwap::Swap8(&(p))
+#   define AI_SWAP2P(p) ByteSwap::Swap2((p))
+#   define AI_SWAP4P(p) ByteSwap::Swap4((p))
+#   define AI_SWAP8P(p) ByteSwap::Swap8((p))
+#   define BE_NCONST
+#else
+#   define AI_BE(t) (t)
+#   define AI_LE(t) ByteSwap::Swapped(t)
+#   define AI_SWAP2(p)
+#   define AI_SWAP4(p)
+#   define AI_SWAP8(p)
+#   define AI_SWAP2P(p)
+#   define AI_SWAP4P(p)
+#   define AI_SWAP8P(p)
+#   define BE_NCONST const
+#   define AI_LSWAP2(p)     ByteSwap::Swap2(&(p))
+#   define AI_LSWAP4(p)     ByteSwap::Swap4(&(p))
+#   define AI_LSWAP8(p)     ByteSwap::Swap8(&(p))
+#   define AI_LSWAP2P(p)    ByteSwap::Swap2((p))
+#   define AI_LSWAP4P(p)    ByteSwap::Swap4((p))
+#   define AI_LSWAP8P(p)    ByteSwap::Swap8((p))
+#   define LE_NCONST
+#endif
+
+
+namespace Intern {
+
+// --------------------------------------------------------------------------------------------
+template <typename T, bool doit>
+struct ByteSwapper  {
+    void operator() (T* inout) {
+        ByteSwap::Swap(inout);
+    }
+};
+
+template <typename T>
+struct ByteSwapper<T,false> {
+    void operator() (T*) {
+    }
+};
+
+// --------------------------------------------------------------------------------------------
+template <bool SwapEndianess, typename T, bool RuntimeSwitch>
+struct Getter {
+    void operator() (T* inout, bool le) {
+#ifdef AI_BUILD_BIG_ENDIAN
+        le =  le;
+#else
+        le =  !le;
+#endif
+        if (le) {
+            ByteSwapper<T,(sizeof(T)>1?true:false)> () (inout);
+        }
+        else ByteSwapper<T,false> () (inout);
+    }
+};
+
+template <bool SwapEndianess, typename T>
+struct Getter<SwapEndianess,T,false> {
+
+    void operator() (T* inout, bool /*le*/) {
+        // static branch
+        ByteSwapper<T,(SwapEndianess && sizeof(T)>1)> () (inout);
+    }
+};
+} // end Intern
+} // end Assimp
+
+#endif //!! AI_BYTESWAPPER_H_INC
diff --git a/engine/inc/assimp/Compiler/poppack1.h b/engine/inc/assimp/Compiler/poppack1.h
new file mode 100644
index 00000000..e033bc14
--- /dev/null
+++ b/engine/inc/assimp/Compiler/poppack1.h
@@ -0,0 +1,22 @@
+
+// ===============================================================================
+// May be included multiple times - resets structure packing to the defaults 
+// for all supported compilers. Reverts the changes made by #include <pushpack1.h> 
+//
+// Currently this works on the following compilers:
+// MSVC 7,8,9
+// GCC
+// BORLAND (complains about 'pack state changed but not reverted', but works)
+// ===============================================================================
+
+#ifndef AI_PUSHPACK_IS_DEFINED
+#	error pushpack1.h must be included after poppack1.h
+#endif
+
+// reset packing to the original value
+#if defined(_MSC_VER) ||  defined(__BORLANDC__) || defined (__BCPLUSPLUS__)
+#	pragma pack( pop )
+#endif
+#undef PACK_STRUCT
+
+#undef AI_PUSHPACK_IS_DEFINED
diff --git a/engine/inc/assimp/Compiler/pstdint.h b/engine/inc/assimp/Compiler/pstdint.h
new file mode 100644
index 00000000..4de4ce2a
--- /dev/null
+++ b/engine/inc/assimp/Compiler/pstdint.h
@@ -0,0 +1,912 @@
+/*  A portable stdint.h
+ ****************************************************************************
+ *  BSD License:
+ ****************************************************************************
+ *
+ *  Copyright (c) 2005-2016 Paul Hsieh
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *  3. The name of the author may not be used to endorse or promote products
+ *     derived from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ *  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ *  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ ****************************************************************************
+ *
+ *  Version 0.1.15.4
+ *
+ *  The ANSI C standard committee, for the C99 standard, specified the
+ *  inclusion of a new standard include file called stdint.h.  This is
+ *  a very useful and long desired include file which contains several
+ *  very precise definitions for integer scalar types that is
+ *  critically important for making portable several classes of
+ *  applications including cryptography, hashing, variable length
+ *  integer libraries and so on.  But for most developers its likely
+ *  useful just for programming sanity.
+ *
+ *  The problem is that some compiler vendors chose to ignore the C99
+ *  standard and some older compilers have no opportunity to be updated.
+ *  Because of this situation, simply including stdint.h in your code
+ *  makes it unportable.
+ *
+ *  So that's what this file is all about.  Its an attempt to build a
+ *  single universal include file that works on as many platforms as
+ *  possible to deliver what stdint.h is supposed to.  Even compilers
+ *  that already come with stdint.h can use this file instead without
+ *  any loss of functionality.  A few things that should be noted about
+ *  this file:
+ *
+ *    1) It is not guaranteed to be portable and/or present an identical
+ *       interface on all platforms.  The extreme variability of the
+ *       ANSI C standard makes this an impossibility right from the
+ *       very get go. Its really only meant to be useful for the vast
+ *       majority of platforms that possess the capability of
+ *       implementing usefully and precisely defined, standard sized
+ *       integer scalars.  Systems which are not intrinsically 2s
+ *       complement may produce invalid constants.
+ *
+ *    2) There is an unavoidable use of non-reserved symbols.
+ *
+ *    3) Other standard include files are invoked.
+ *
+ *    4) This file may come in conflict with future platforms that do
+ *       include stdint.h.  The hope is that one or the other can be
+ *       used with no real difference.
+ *
+ *    5) In the current version, if your platform can't represent
+ *       int32_t, int16_t and int8_t, it just dumps out with a compiler
+ *       error.
+ *
+ *    6) 64 bit integers may or may not be defined.  Test for their
+ *       presence with the test: #ifdef INT64_MAX or #ifdef UINT64_MAX.
+ *       Note that this is different from the C99 specification which
+ *       requires the existence of 64 bit support in the compiler.  If
+ *       this is not defined for your platform, yet it is capable of
+ *       dealing with 64 bits then it is because this file has not yet
+ *       been extended to cover all of your system's capabilities.
+ *
+ *    7) (u)intptr_t may or may not be defined.  Test for its presence
+ *       with the test: #ifdef PTRDIFF_MAX.  If this is not defined
+ *       for your platform, then it is because this file has not yet
+ *       been extended to cover all of your system's capabilities, not
+ *       because its optional.
+ *
+ *    8) The following might not been defined even if your platform is
+ *       capable of defining it:
+ *
+ *       WCHAR_MIN
+ *       WCHAR_MAX
+ *       (u)int64_t
+ *       PTRDIFF_MIN
+ *       PTRDIFF_MAX
+ *       (u)intptr_t
+ *
+ *    9) The following have not been defined:
+ *
+ *       WINT_MIN
+ *       WINT_MAX
+ *
+ *   10) The criteria for defining (u)int_least(*)_t isn't clear,
+ *       except for systems which don't have a type that precisely
+ *       defined 8, 16, or 32 bit types (which this include file does
+ *       not support anyways). Default definitions have been given.
+ *
+ *   11) The criteria for defining (u)int_fast(*)_t isn't something I
+ *       would trust to any particular compiler vendor or the ANSI C
+ *       committee.  It is well known that "compatible systems" are
+ *       commonly created that have very different performance
+ *       characteristics from the systems they are compatible with,
+ *       especially those whose vendors make both the compiler and the
+ *       system.  Default definitions have been given, but its strongly
+ *       recommended that users never use these definitions for any
+ *       reason (they do *NOT* deliver any serious guarantee of
+ *       improved performance -- not in this file, nor any vendor's
+ *       stdint.h).
+ *
+ *   12) The following macros:
+ *
+ *       PRINTF_INTMAX_MODIFIER
+ *       PRINTF_INT64_MODIFIER
+ *       PRINTF_INT32_MODIFIER
+ *       PRINTF_INT16_MODIFIER
+ *       PRINTF_LEAST64_MODIFIER
+ *       PRINTF_LEAST32_MODIFIER
+ *       PRINTF_LEAST16_MODIFIER
+ *       PRINTF_INTPTR_MODIFIER
+ *
+ *       are strings which have been defined as the modifiers required
+ *       for the "d", "u" and "x" printf formats to correctly output
+ *       (u)intmax_t, (u)int64_t, (u)int32_t, (u)int16_t, (u)least64_t,
+ *       (u)least32_t, (u)least16_t and (u)intptr_t types respectively.
+ *       PRINTF_INTPTR_MODIFIER is not defined for some systems which
+ *       provide their own stdint.h.  PRINTF_INT64_MODIFIER is not
+ *       defined if INT64_MAX is not defined.  These are an extension
+ *       beyond what C99 specifies must be in stdint.h.
+ *
+ *       In addition, the following macros are defined:
+ *
+ *       PRINTF_INTMAX_HEX_WIDTH
+ *       PRINTF_INT64_HEX_WIDTH
+ *       PRINTF_INT32_HEX_WIDTH
+ *       PRINTF_INT16_HEX_WIDTH
+ *       PRINTF_INT8_HEX_WIDTH
+ *       PRINTF_INTMAX_DEC_WIDTH
+ *       PRINTF_INT64_DEC_WIDTH
+ *       PRINTF_INT32_DEC_WIDTH
+ *       PRINTF_INT16_DEC_WIDTH
+ *       PRINTF_UINT8_DEC_WIDTH
+ *       PRINTF_UINTMAX_DEC_WIDTH
+ *       PRINTF_UINT64_DEC_WIDTH
+ *       PRINTF_UINT32_DEC_WIDTH
+ *       PRINTF_UINT16_DEC_WIDTH
+ *       PRINTF_UINT8_DEC_WIDTH
+ *
+ *       Which specifies the maximum number of characters required to
+ *       print the number of that type in either hexadecimal or decimal.
+ *       These are an extension beyond what C99 specifies must be in
+ *       stdint.h.
+ *
+ *  Compilers tested (all with 0 warnings at their highest respective
+ *  settings): Borland Turbo C 2.0, WATCOM C/C++ 11.0 (16 bits and 32
+ *  bits), Microsoft Visual C++ 6.0 (32 bit), Microsoft Visual Studio
+ *  .net (VC7), Intel C++ 4.0, GNU gcc v3.3.3
+ *
+ *  This file should be considered a work in progress.  Suggestions for
+ *  improvements, especially those which increase coverage are strongly
+ *  encouraged.
+ *
+ *  Acknowledgements
+ *
+ *  The following people have made significant contributions to the
+ *  development and testing of this file:
+ *
+ *  Chris Howie
+ *  John Steele Scott
+ *  Dave Thorup
+ *  John Dill
+ *  Florian Wobbe
+ *  Christopher Sean Morrison
+ *  Mikkel Fahnoe Jorgensen
+ *
+ */
+
+#include <stddef.h>
+#include <limits.h>
+#include <signal.h>
+
+/*
+ *  For gcc with _STDINT_H, fill in the PRINTF_INT*_MODIFIER macros, and
+ *  do nothing else.  On the Mac OS X version of gcc this is _STDINT_H_.
+ */
+
+#if ((defined(__SUNPRO_C) && __SUNPRO_C >= 0x570) || (defined(_MSC_VER) && _MSC_VER >= 1600) || (defined(__STDC__) && __STDC__ && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || (defined (__WATCOMC__) && (defined (_STDINT_H_INCLUDED) || __WATCOMC__ >= 1250)) || (defined(__GNUC__) && (__GNUC__ > 3 || defined(_STDINT_H) || defined(_STDINT_H_) || defined (__UINT_FAST64_TYPE__)) )) && !defined (_PSTDINT_H_INCLUDED)
+#include <stdint.h>
+#define _PSTDINT_H_INCLUDED
+# if defined(__GNUC__) && (defined(__x86_64__) || defined(__ppc64__)) && !(defined(__APPLE__) && defined(__MACH__))
+#  ifndef PRINTF_INT64_MODIFIER
+#   define PRINTF_INT64_MODIFIER "l"
+#  endif
+#  ifndef PRINTF_INT32_MODIFIER
+#   define PRINTF_INT32_MODIFIER ""
+#  endif
+# else
+#  ifndef PRINTF_INT64_MODIFIER
+#   define PRINTF_INT64_MODIFIER "ll"
+#  endif
+#  ifndef PRINTF_INT32_MODIFIER
+#   if (UINT_MAX == UINT32_MAX)
+#    define PRINTF_INT32_MODIFIER ""
+#   else
+#    define PRINTF_INT32_MODIFIER "l"
+#   endif
+#  endif
+# endif
+# ifndef PRINTF_INT16_MODIFIER
+#  define PRINTF_INT16_MODIFIER "h"
+# endif
+# ifndef PRINTF_INTMAX_MODIFIER
+#  define PRINTF_INTMAX_MODIFIER PRINTF_INT64_MODIFIER
+# endif
+# ifndef PRINTF_INT64_HEX_WIDTH
+#  define PRINTF_INT64_HEX_WIDTH "16"
+# endif
+# ifndef PRINTF_UINT64_HEX_WIDTH
+#  define PRINTF_UINT64_HEX_WIDTH "16"
+# endif
+# ifndef PRINTF_INT32_HEX_WIDTH
+#  define PRINTF_INT32_HEX_WIDTH "8"
+# endif
+# ifndef PRINTF_UINT32_HEX_WIDTH
+#  define PRINTF_UINT32_HEX_WIDTH "8"
+# endif
+# ifndef PRINTF_INT16_HEX_WIDTH
+#  define PRINTF_INT16_HEX_WIDTH "4"
+# endif
+# ifndef PRINTF_UINT16_HEX_WIDTH
+#  define PRINTF_UINT16_HEX_WIDTH "4"
+# endif
+# ifndef PRINTF_INT8_HEX_WIDTH
+#  define PRINTF_INT8_HEX_WIDTH "2"
+# endif
+# ifndef PRINTF_UINT8_HEX_WIDTH
+#  define PRINTF_UINT8_HEX_WIDTH "2"
+# endif
+# ifndef PRINTF_INT64_DEC_WIDTH
+#  define PRINTF_INT64_DEC_WIDTH "19"
+# endif
+# ifndef PRINTF_UINT64_DEC_WIDTH
+#  define PRINTF_UINT64_DEC_WIDTH "20"
+# endif
+# ifndef PRINTF_INT32_DEC_WIDTH
+#  define PRINTF_INT32_DEC_WIDTH "10"
+# endif
+# ifndef PRINTF_UINT32_DEC_WIDTH
+#  define PRINTF_UINT32_DEC_WIDTH "10"
+# endif
+# ifndef PRINTF_INT16_DEC_WIDTH
+#  define PRINTF_INT16_DEC_WIDTH "5"
+# endif
+# ifndef PRINTF_UINT16_DEC_WIDTH
+#  define PRINTF_UINT16_DEC_WIDTH "5"
+# endif
+# ifndef PRINTF_INT8_DEC_WIDTH
+#  define PRINTF_INT8_DEC_WIDTH "3"
+# endif
+# ifndef PRINTF_UINT8_DEC_WIDTH
+#  define PRINTF_UINT8_DEC_WIDTH "3"
+# endif
+# ifndef PRINTF_INTMAX_HEX_WIDTH
+#  define PRINTF_INTMAX_HEX_WIDTH PRINTF_UINT64_HEX_WIDTH
+# endif
+# ifndef PRINTF_UINTMAX_HEX_WIDTH
+#  define PRINTF_UINTMAX_HEX_WIDTH PRINTF_UINT64_HEX_WIDTH
+# endif
+# ifndef PRINTF_INTMAX_DEC_WIDTH
+#  define PRINTF_INTMAX_DEC_WIDTH PRINTF_UINT64_DEC_WIDTH
+# endif
+# ifndef PRINTF_UINTMAX_DEC_WIDTH
+#  define PRINTF_UINTMAX_DEC_WIDTH PRINTF_UINT64_DEC_WIDTH
+# endif
+
+/*
+ *  Something really weird is going on with Open Watcom.  Just pull some of
+ *  these duplicated definitions from Open Watcom's stdint.h file for now.
+ */
+
+# if defined (__WATCOMC__) && __WATCOMC__ >= 1250
+#  if !defined (INT64_C)
+#   define INT64_C(x)   (x + (INT64_MAX - INT64_MAX))
+#  endif
+#  if !defined (UINT64_C)
+#   define UINT64_C(x)  (x + (UINT64_MAX - UINT64_MAX))
+#  endif
+#  if !defined (INT32_C)
+#   define INT32_C(x)   (x + (INT32_MAX - INT32_MAX))
+#  endif
+#  if !defined (UINT32_C)
+#   define UINT32_C(x)  (x + (UINT32_MAX - UINT32_MAX))
+#  endif
+#  if !defined (INT16_C)
+#   define INT16_C(x)   (x)
+#  endif
+#  if !defined (UINT16_C)
+#   define UINT16_C(x)  (x)
+#  endif
+#  if !defined (INT8_C)
+#   define INT8_C(x)   (x)
+#  endif
+#  if !defined (UINT8_C)
+#   define UINT8_C(x)  (x)
+#  endif
+#  if !defined (UINT64_MAX)
+#   define UINT64_MAX  18446744073709551615ULL
+#  endif
+#  if !defined (INT64_MAX)
+#   define INT64_MAX  9223372036854775807LL
+#  endif
+#  if !defined (UINT32_MAX)
+#   define UINT32_MAX  4294967295UL
+#  endif
+#  if !defined (INT32_MAX)
+#   define INT32_MAX  2147483647L
+#  endif
+#  if !defined (INTMAX_MAX)
+#   define INTMAX_MAX INT64_MAX
+#  endif
+#  if !defined (INTMAX_MIN)
+#   define INTMAX_MIN INT64_MIN
+#  endif
+# endif
+#endif
+
+/*
+ *  I have no idea what is the truly correct thing to do on older Solaris.
+ *  From some online discussions, this seems to be what is being
+ *  recommended.  For people who actually are developing on older Solaris,
+ *  what I would like to know is, does this define all of the relevant
+ *  macros of a complete stdint.h?  Remember, in pstdint.h 64 bit is
+ *  considered optional.
+ */
+
+#if (defined(__SUNPRO_C) && __SUNPRO_C >= 0x420) && !defined(_PSTDINT_H_INCLUDED)
+#include <sys/inttypes.h>
+#define _PSTDINT_H_INCLUDED
+#endif
+
+#ifndef _PSTDINT_H_INCLUDED
+#define _PSTDINT_H_INCLUDED
+
+#ifndef SIZE_MAX
+# define SIZE_MAX (~(size_t)0)
+#endif
+
+/*
+ *  Deduce the type assignments from limits.h under the assumption that
+ *  integer sizes in bits are powers of 2, and follow the ANSI
+ *  definitions.
+ */
+
+#ifndef UINT8_MAX
+# define UINT8_MAX 0xff
+#endif
+#if !defined(uint8_t) && !defined(_UINT8_T) && !defined(vxWorks)
+# if (UCHAR_MAX == UINT8_MAX) || defined (S_SPLINT_S)
+    typedef unsigned char uint8_t;
+#   define UINT8_C(v) ((uint8_t) v)
+# else
+#   error "Platform not supported"
+# endif
+#endif
+
+#ifndef INT8_MAX
+# define INT8_MAX 0x7f
+#endif
+#ifndef INT8_MIN
+# define INT8_MIN INT8_C(0x80)
+#endif
+#if !defined(int8_t) && !defined(_INT8_T) && !defined(vxWorks)
+# if (SCHAR_MAX == INT8_MAX) || defined (S_SPLINT_S)
+    typedef signed char int8_t;
+#   define INT8_C(v) ((int8_t) v)
+# else
+#   error "Platform not supported"
+# endif
+#endif
+
+#ifndef UINT16_MAX
+# define UINT16_MAX 0xffff
+#endif
+#if !defined(uint16_t) && !defined(_UINT16_T) && !defined(vxWorks)
+#if (UINT_MAX == UINT16_MAX) || defined (S_SPLINT_S)
+  typedef unsigned int uint16_t;
+# ifndef PRINTF_INT16_MODIFIER
+#  define PRINTF_INT16_MODIFIER ""
+# endif
+# define UINT16_C(v) ((uint16_t) (v))
+#elif (USHRT_MAX == UINT16_MAX)
+  typedef unsigned short uint16_t;
+# define UINT16_C(v) ((uint16_t) (v))
+# ifndef PRINTF_INT16_MODIFIER
+#  define PRINTF_INT16_MODIFIER "h"
+# endif
+#else
+#error "Platform not supported"
+#endif
+#endif
+
+#ifndef INT16_MAX
+# define INT16_MAX 0x7fff
+#endif
+#ifndef INT16_MIN
+# define INT16_MIN INT16_C(0x8000)
+#endif
+#if !defined(int16_t) && !defined(_INT16_T) && !defined(vxWorks)
+#if (INT_MAX == INT16_MAX) || defined (S_SPLINT_S)
+  typedef signed int int16_t;
+# define INT16_C(v) ((int16_t) (v))
+# ifndef PRINTF_INT16_MODIFIER
+#  define PRINTF_INT16_MODIFIER ""
+# endif
+#elif (SHRT_MAX == INT16_MAX)
+  typedef signed short int16_t;
+# define INT16_C(v) ((int16_t) (v))
+# ifndef PRINTF_INT16_MODIFIER
+#  define PRINTF_INT16_MODIFIER "h"
+# endif
+#else
+#error "Platform not supported"
+#endif
+#endif
+
+#ifndef UINT32_MAX
+# define UINT32_MAX (0xffffffffUL)
+#endif
+#if !defined(uint32_t) && !defined(_UINT32_T) && !defined(vxWorks)
+#if (ULONG_MAX == UINT32_MAX) || defined (S_SPLINT_S)
+  typedef unsigned long uint32_t;
+# define UINT32_C(v) v ## UL
+# ifndef PRINTF_INT32_MODIFIER
+#  define PRINTF_INT32_MODIFIER "l"
+# endif
+#elif (UINT_MAX == UINT32_MAX)
+  typedef unsigned int uint32_t;
+# ifndef PRINTF_INT32_MODIFIER
+#  define PRINTF_INT32_MODIFIER ""
+# endif
+# define UINT32_C(v) v ## U
+#elif (USHRT_MAX == UINT32_MAX)
+  typedef unsigned short uint32_t;
+# define UINT32_C(v) ((unsigned short) (v))
+# ifndef PRINTF_INT32_MODIFIER
+#  define PRINTF_INT32_MODIFIER ""
+# endif
+#else
+#error "Platform not supported"
+#endif
+#endif
+
+#ifndef INT32_MAX
+# define INT32_MAX (0x7fffffffL)
+#endif
+#ifndef INT32_MIN
+# define INT32_MIN INT32_C(0x80000000)
+#endif
+#if !defined(int32_t) && !defined(_INT32_T) && !defined(vxWorks)
+#if (LONG_MAX == INT32_MAX) || defined (S_SPLINT_S)
+  typedef signed long int32_t;
+# define INT32_C(v) v ## L
+# ifndef PRINTF_INT32_MODIFIER
+#  define PRINTF_INT32_MODIFIER "l"
+# endif
+#elif (INT_MAX == INT32_MAX)
+  typedef signed int int32_t;
+# define INT32_C(v) v
+# ifndef PRINTF_INT32_MODIFIER
+#  define PRINTF_INT32_MODIFIER ""
+# endif
+#elif (SHRT_MAX == INT32_MAX)
+  typedef signed short int32_t;
+# define INT32_C(v) ((short) (v))
+# ifndef PRINTF_INT32_MODIFIER
+#  define PRINTF_INT32_MODIFIER ""
+# endif
+#else
+#error "Platform not supported"
+#endif
+#endif
+
+/*
+ *  The macro stdint_int64_defined is temporarily used to record
+ *  whether or not 64 integer support is available.  It must be
+ *  defined for any 64 integer extensions for new platforms that are
+ *  added.
+ */
+
+#undef stdint_int64_defined
+#if (defined(__STDC__) && defined(__STDC_VERSION__)) || defined (S_SPLINT_S)
+# if (__STDC__ && __STDC_VERSION__ >= 199901L) || defined (S_SPLINT_S)
+#  define stdint_int64_defined
+   typedef long long int64_t;
+   typedef unsigned long long uint64_t;
+#  define UINT64_C(v) v ## ULL
+#  define  INT64_C(v) v ## LL
+#  ifndef PRINTF_INT64_MODIFIER
+#   define PRINTF_INT64_MODIFIER "ll"
+#  endif
+# endif
+#endif
+
+#if !defined (stdint_int64_defined)
+# if defined(__GNUC__) && !defined(vxWorks)
+#  define stdint_int64_defined
+   __extension__ typedef long long int64_t;
+   __extension__ typedef unsigned long long uint64_t;
+#  define UINT64_C(v) v ## ULL
+#  define  INT64_C(v) v ## LL
+#  ifndef PRINTF_INT64_MODIFIER
+#   define PRINTF_INT64_MODIFIER "ll"
+#  endif
+# elif defined(__MWERKS__) || defined (__SUNPRO_C) || defined (__SUNPRO_CC) || defined (__APPLE_CC__) || defined (_LONG_LONG) || defined (_CRAYC) || defined (S_SPLINT_S)
+#  define stdint_int64_defined
+   typedef long long int64_t;
+   typedef unsigned long long uint64_t;
+#  define UINT64_C(v) v ## ULL
+#  define  INT64_C(v) v ## LL
+#  ifndef PRINTF_INT64_MODIFIER
+#   define PRINTF_INT64_MODIFIER "ll"
+#  endif
+# elif (defined(__WATCOMC__) && defined(__WATCOM_INT64__)) || (defined(_MSC_VER) && _INTEGRAL_MAX_BITS >= 64) || (defined (__BORLANDC__) && __BORLANDC__ > 0x460) || defined (__alpha) || defined (__DECC)
+#  define stdint_int64_defined
+   typedef __int64 int64_t;
+   typedef unsigned __int64 uint64_t;
+#  define UINT64_C(v) v ## UI64
+#  define  INT64_C(v) v ## I64
+#  ifndef PRINTF_INT64_MODIFIER
+#   define PRINTF_INT64_MODIFIER "I64"
+#  endif
+# endif
+#endif
+
+#if !defined (LONG_LONG_MAX) && defined (INT64_C)
+# define LONG_LONG_MAX INT64_C (9223372036854775807)
+#endif
+#ifndef ULONG_LONG_MAX
+# define ULONG_LONG_MAX UINT64_C (18446744073709551615)
+#endif
+
+#if !defined (INT64_MAX) && defined (INT64_C)
+# define INT64_MAX INT64_C (9223372036854775807)
+#endif
+#if !defined (INT64_MIN) && defined (INT64_C)
+# define INT64_MIN INT64_C (-9223372036854775808)
+#endif
+#if !defined (UINT64_MAX) && defined (INT64_C)
+# define UINT64_MAX UINT64_C (18446744073709551615)
+#endif
+
+/*
+ *  Width of hexadecimal for number field.
+ */
+
+#ifndef PRINTF_INT64_HEX_WIDTH
+# define PRINTF_INT64_HEX_WIDTH "16"
+#endif
+#ifndef PRINTF_INT32_HEX_WIDTH
+# define PRINTF_INT32_HEX_WIDTH "8"
+#endif
+#ifndef PRINTF_INT16_HEX_WIDTH
+# define PRINTF_INT16_HEX_WIDTH "4"
+#endif
+#ifndef PRINTF_INT8_HEX_WIDTH
+# define PRINTF_INT8_HEX_WIDTH "2"
+#endif
+#ifndef PRINTF_INT64_DEC_WIDTH
+# define PRINTF_INT64_DEC_WIDTH "19"
+#endif
+#ifndef PRINTF_INT32_DEC_WIDTH
+# define PRINTF_INT32_DEC_WIDTH "10"
+#endif
+#ifndef PRINTF_INT16_DEC_WIDTH
+# define PRINTF_INT16_DEC_WIDTH "5"
+#endif
+#ifndef PRINTF_INT8_DEC_WIDTH
+# define PRINTF_INT8_DEC_WIDTH "3"
+#endif
+#ifndef PRINTF_UINT64_DEC_WIDTH
+# define PRINTF_UINT64_DEC_WIDTH "20"
+#endif
+#ifndef PRINTF_UINT32_DEC_WIDTH
+# define PRINTF_UINT32_DEC_WIDTH "10"
+#endif
+#ifndef PRINTF_UINT16_DEC_WIDTH
+# define PRINTF_UINT16_DEC_WIDTH "5"
+#endif
+#ifndef PRINTF_UINT8_DEC_WIDTH
+# define PRINTF_UINT8_DEC_WIDTH "3"
+#endif
+
+/*
+ *  Ok, lets not worry about 128 bit integers for now.  Moore's law says
+ *  we don't need to worry about that until about 2040 at which point
+ *  we'll have bigger things to worry about.
+ */
+
+#ifdef stdint_int64_defined
+  typedef int64_t intmax_t;
+  typedef uint64_t uintmax_t;
+# define  INTMAX_MAX   INT64_MAX
+# define  INTMAX_MIN   INT64_MIN
+# define UINTMAX_MAX  UINT64_MAX
+# define UINTMAX_C(v) UINT64_C(v)
+# define  INTMAX_C(v)  INT64_C(v)
+# ifndef PRINTF_INTMAX_MODIFIER
+#   define PRINTF_INTMAX_MODIFIER PRINTF_INT64_MODIFIER
+# endif
+# ifndef PRINTF_INTMAX_HEX_WIDTH
+#  define PRINTF_INTMAX_HEX_WIDTH PRINTF_INT64_HEX_WIDTH
+# endif
+# ifndef PRINTF_INTMAX_DEC_WIDTH
+#  define PRINTF_INTMAX_DEC_WIDTH PRINTF_INT64_DEC_WIDTH
+# endif
+#else
+  typedef int32_t intmax_t;
+  typedef uint32_t uintmax_t;
+# define  INTMAX_MAX   INT32_MAX
+# define UINTMAX_MAX  UINT32_MAX
+# define UINTMAX_C(v) UINT32_C(v)
+# define  INTMAX_C(v)  INT32_C(v)
+# ifndef PRINTF_INTMAX_MODIFIER
+#   define PRINTF_INTMAX_MODIFIER PRINTF_INT32_MODIFIER
+# endif
+# ifndef PRINTF_INTMAX_HEX_WIDTH
+#  define PRINTF_INTMAX_HEX_WIDTH PRINTF_INT32_HEX_WIDTH
+# endif
+# ifndef PRINTF_INTMAX_DEC_WIDTH
+#  define PRINTF_INTMAX_DEC_WIDTH PRINTF_INT32_DEC_WIDTH
+# endif
+#endif
+
+/*
+ *  Because this file currently only supports platforms which have
+ *  precise powers of 2 as bit sizes for the default integers, the
+ *  least definitions are all trivial.  Its possible that a future
+ *  version of this file could have different definitions.
+ */
+
+#ifndef stdint_least_defined
+  typedef   int8_t   int_least8_t;
+  typedef  uint8_t  uint_least8_t;
+  typedef  int16_t  int_least16_t;
+  typedef uint16_t uint_least16_t;
+  typedef  int32_t  int_least32_t;
+  typedef uint32_t uint_least32_t;
+# define PRINTF_LEAST32_MODIFIER PRINTF_INT32_MODIFIER
+# define PRINTF_LEAST16_MODIFIER PRINTF_INT16_MODIFIER
+# define  UINT_LEAST8_MAX  UINT8_MAX
+# define   INT_LEAST8_MAX   INT8_MAX
+# define UINT_LEAST16_MAX UINT16_MAX
+# define  INT_LEAST16_MAX  INT16_MAX
+# define UINT_LEAST32_MAX UINT32_MAX
+# define  INT_LEAST32_MAX  INT32_MAX
+# define   INT_LEAST8_MIN   INT8_MIN
+# define  INT_LEAST16_MIN  INT16_MIN
+# define  INT_LEAST32_MIN  INT32_MIN
+# ifdef stdint_int64_defined
+    typedef  int64_t  int_least64_t;
+    typedef uint64_t uint_least64_t;
+#   define PRINTF_LEAST64_MODIFIER PRINTF_INT64_MODIFIER
+#   define UINT_LEAST64_MAX UINT64_MAX
+#   define  INT_LEAST64_MAX  INT64_MAX
+#   define  INT_LEAST64_MIN  INT64_MIN
+# endif
+#endif
+#undef stdint_least_defined
+
+/*
+ *  The ANSI C committee pretending to know or specify anything about
+ *  performance is the epitome of misguided arrogance.  The mandate of
+ *  this file is to *ONLY* ever support that absolute minimum
+ *  definition of the fast integer types, for compatibility purposes.
+ *  No extensions, and no attempt to suggest what may or may not be a
+ *  faster integer type will ever be made in this file.  Developers are
+ *  warned to stay away from these types when using this or any other
+ *  stdint.h.
+ */
+
+typedef   int_least8_t   int_fast8_t;
+typedef  uint_least8_t  uint_fast8_t;
+typedef  int_least16_t  int_fast16_t;
+typedef uint_least16_t uint_fast16_t;
+typedef  int_least32_t  int_fast32_t;
+typedef uint_least32_t uint_fast32_t;
+#define  UINT_FAST8_MAX  UINT_LEAST8_MAX
+#define   INT_FAST8_MAX   INT_LEAST8_MAX
+#define UINT_FAST16_MAX UINT_LEAST16_MAX
+#define  INT_FAST16_MAX  INT_LEAST16_MAX
+#define UINT_FAST32_MAX UINT_LEAST32_MAX
+#define  INT_FAST32_MAX  INT_LEAST32_MAX
+#define   INT_FAST8_MIN   INT_LEAST8_MIN
+#define  INT_FAST16_MIN  INT_LEAST16_MIN
+#define  INT_FAST32_MIN  INT_LEAST32_MIN
+#ifdef stdint_int64_defined
+  typedef  int_least64_t  int_fast64_t;
+  typedef uint_least64_t uint_fast64_t;
+# define UINT_FAST64_MAX UINT_LEAST64_MAX
+# define  INT_FAST64_MAX  INT_LEAST64_MAX
+# define  INT_FAST64_MIN  INT_LEAST64_MIN
+#endif
+
+#undef stdint_int64_defined
+
+/*
+ *  Whatever piecemeal, per compiler thing we can do about the wchar_t
+ *  type limits.
+ */
+
+#if defined(__WATCOMC__) || defined(_MSC_VER) || defined (__GNUC__) && !defined(vxWorks)
+# include <wchar.h>
+# ifndef WCHAR_MIN
+#  define WCHAR_MIN 0
+# endif
+# ifndef WCHAR_MAX
+#  define WCHAR_MAX ((wchar_t)-1)
+# endif
+#endif
+
+/*
+ *  Whatever piecemeal, per compiler/platform thing we can do about the
+ *  (u)intptr_t types and limits.
+ */
+
+#if (defined (_MSC_VER) && defined (_UINTPTR_T_DEFINED)) || defined (_UINTPTR_T)
+# define STDINT_H_UINTPTR_T_DEFINED
+#endif
+
+#ifndef STDINT_H_UINTPTR_T_DEFINED
+# if defined (__alpha__) || defined (__ia64__) || defined (__x86_64__) || defined (_WIN64) || defined (__ppc64__)
+#  define stdint_intptr_bits 64
+# elif defined (__WATCOMC__) || defined (__TURBOC__)
+#  if defined(__TINY__) || defined(__SMALL__) || defined(__MEDIUM__)
+#    define stdint_intptr_bits 16
+#  else
+#    define stdint_intptr_bits 32
+#  endif
+# elif defined (__i386__) || defined (_WIN32) || defined (WIN32) || defined (__ppc64__)
+#  define stdint_intptr_bits 32
+# elif defined (__INTEL_COMPILER)
+/* TODO -- what did Intel do about x86-64? */
+# else
+/* #error "This platform might not be supported yet" */
+# endif
+
+# ifdef stdint_intptr_bits
+#  define stdint_intptr_glue3_i(a,b,c)  a##b##c
+#  define stdint_intptr_glue3(a,b,c)    stdint_intptr_glue3_i(a,b,c)
+#  ifndef PRINTF_INTPTR_MODIFIER
+#    define PRINTF_INTPTR_MODIFIER      stdint_intptr_glue3(PRINTF_INT,stdint_intptr_bits,_MODIFIER)
+#  endif
+#  ifndef PTRDIFF_MAX
+#    define PTRDIFF_MAX                 stdint_intptr_glue3(INT,stdint_intptr_bits,_MAX)
+#  endif
+#  ifndef PTRDIFF_MIN
+#    define PTRDIFF_MIN                 stdint_intptr_glue3(INT,stdint_intptr_bits,_MIN)
+#  endif
+#  ifndef UINTPTR_MAX
+#    define UINTPTR_MAX                 stdint_intptr_glue3(UINT,stdint_intptr_bits,_MAX)
+#  endif
+#  ifndef INTPTR_MAX
+#    define INTPTR_MAX                  stdint_intptr_glue3(INT,stdint_intptr_bits,_MAX)
+#  endif
+#  ifndef INTPTR_MIN
+#    define INTPTR_MIN                  stdint_intptr_glue3(INT,stdint_intptr_bits,_MIN)
+#  endif
+#  ifndef INTPTR_C
+#    define INTPTR_C(x)                 stdint_intptr_glue3(INT,stdint_intptr_bits,_C)(x)
+#  endif
+#  ifndef UINTPTR_C
+#    define UINTPTR_C(x)                stdint_intptr_glue3(UINT,stdint_intptr_bits,_C)(x)
+#  endif
+  typedef stdint_intptr_glue3(uint,stdint_intptr_bits,_t) uintptr_t;
+  typedef stdint_intptr_glue3( int,stdint_intptr_bits,_t)  intptr_t;
+# else
+/* TODO -- This following is likely wrong for some platforms, and does
+   nothing for the definition of uintptr_t. */
+  typedef ptrdiff_t intptr_t;
+# endif
+# define STDINT_H_UINTPTR_T_DEFINED
+#endif
+
+/*
+ *  Assumes sig_atomic_t is signed and we have a 2s complement machine.
+ */
+
+#ifndef SIG_ATOMIC_MAX
+# define SIG_ATOMIC_MAX ((((sig_atomic_t) 1) << (sizeof (sig_atomic_t)*CHAR_BIT-1)) - 1)
+#endif
+
+#endif
+
+#if defined (__TEST_PSTDINT_FOR_CORRECTNESS)
+
+/*
+ *  Please compile with the maximum warning settings to make sure macros are
+ *  not defined more than once.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#define glue3_aux(x,y,z) x ## y ## z
+#define glue3(x,y,z) glue3_aux(x,y,z)
+
+#define DECLU(bits) glue3(uint,bits,_t) glue3(u,bits,) = glue3(UINT,bits,_C) (0);
+#define DECLI(bits) glue3(int,bits,_t) glue3(i,bits,) = glue3(INT,bits,_C) (0);
+
+#define DECL(us,bits) glue3(DECL,us,) (bits)
+
+#define TESTUMAX(bits) glue3(u,bits,) = ~glue3(u,bits,); if (glue3(UINT,bits,_MAX) != glue3(u,bits,)) printf ("Something wrong with UINT%d_MAX\n", bits)
+
+#define REPORTERROR(msg) { err_n++; if (err_first <= 0) err_first = __LINE__; printf msg; }
+
+int main () {
+	int err_n = 0;
+	int err_first = 0;
+	DECL(I,8)
+	DECL(U,8)
+	DECL(I,16)
+	DECL(U,16)
+	DECL(I,32)
+	DECL(U,32)
+#ifdef INT64_MAX
+	DECL(I,64)
+	DECL(U,64)
+#endif
+	intmax_t imax = INTMAX_C(0);
+	uintmax_t umax = UINTMAX_C(0);
+	char str0[256], str1[256];
+
+	sprintf (str0, "%" PRINTF_INT32_MODIFIER "d", INT32_C(2147483647));
+	if (0 != strcmp (str0, "2147483647")) REPORTERROR (("Something wrong with PRINTF_INT32_MODIFIER : %s\n", str0));
+	if (atoi(PRINTF_INT32_DEC_WIDTH) != (int) strlen(str0)) REPORTERROR (("Something wrong with PRINTF_INT32_DEC_WIDTH : %s\n", PRINTF_INT32_DEC_WIDTH));
+	sprintf (str0, "%" PRINTF_INT32_MODIFIER "u", UINT32_C(4294967295));
+	if (0 != strcmp (str0, "4294967295")) REPORTERROR (("Something wrong with PRINTF_INT32_MODIFIER : %s\n", str0));
+	if (atoi(PRINTF_UINT32_DEC_WIDTH) != (int) strlen(str0)) REPORTERROR (("Something wrong with PRINTF_UINT32_DEC_WIDTH : %s\n", PRINTF_UINT32_DEC_WIDTH));
+#ifdef INT64_MAX
+	sprintf (str1, "%" PRINTF_INT64_MODIFIER "d", INT64_C(9223372036854775807));
+	if (0 != strcmp (str1, "9223372036854775807")) REPORTERROR (("Something wrong with PRINTF_INT32_MODIFIER : %s\n", str1));
+	if (atoi(PRINTF_INT64_DEC_WIDTH) != (int) strlen(str1)) REPORTERROR (("Something wrong with PRINTF_INT64_DEC_WIDTH : %s, %d\n", PRINTF_INT64_DEC_WIDTH, (int) strlen(str1)));
+	sprintf (str1, "%" PRINTF_INT64_MODIFIER "u", UINT64_C(18446744073709550591));
+	if (0 != strcmp (str1, "18446744073709550591")) REPORTERROR (("Something wrong with PRINTF_INT32_MODIFIER : %s\n", str1));
+	if (atoi(PRINTF_UINT64_DEC_WIDTH) != (int) strlen(str1)) REPORTERROR (("Something wrong with PRINTF_UINT64_DEC_WIDTH : %s, %d\n", PRINTF_UINT64_DEC_WIDTH, (int) strlen(str1)));
+#endif
+
+	sprintf (str0, "%d %x\n", 0, ~0);
+
+	sprintf (str1, "%d %x\n",  i8, ~0);
+	if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with i8 : %s\n", str1));
+	sprintf (str1, "%u %x\n",  u8, ~0);
+	if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with u8 : %s\n", str1));
+	sprintf (str1, "%d %x\n",  i16, ~0);
+	if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with i16 : %s\n", str1));
+	sprintf (str1, "%u %x\n",  u16, ~0);
+	if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with u16 : %s\n", str1));
+	sprintf (str1, "%" PRINTF_INT32_MODIFIER "d %x\n",  i32, ~0);
+	if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with i32 : %s\n", str1));
+	sprintf (str1, "%" PRINTF_INT32_MODIFIER "u %x\n",  u32, ~0);
+	if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with u32 : %s\n", str1));
+#ifdef INT64_MAX
+	sprintf (str1, "%" PRINTF_INT64_MODIFIER "d %x\n",  i64, ~0);
+	if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with i64 : %s\n", str1));
+#endif
+	sprintf (str1, "%" PRINTF_INTMAX_MODIFIER "d %x\n",  imax, ~0);
+	if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with imax : %s\n", str1));
+	sprintf (str1, "%" PRINTF_INTMAX_MODIFIER "u %x\n",  umax, ~0);
+	if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with umax : %s\n", str1));
+
+	TESTUMAX(8);
+	TESTUMAX(16);
+	TESTUMAX(32);
+#ifdef INT64_MAX
+	TESTUMAX(64);
+#endif
+
+#define STR(v) #v
+#define Q(v) printf ("sizeof " STR(v) " = %u\n", (unsigned) sizeof (v));
+	if (err_n) {
+		printf ("pstdint.h is not correct.  Please use sizes below to correct it:\n");
+	}
+
+	Q(int)
+	Q(unsigned)
+	Q(long int)
+	Q(short int)
+	Q(int8_t)
+	Q(int16_t)
+	Q(int32_t)
+#ifdef INT64_MAX
+	Q(int64_t)
+#endif
+
+	return EXIT_SUCCESS;
+}
+
+#endif
diff --git a/engine/inc/assimp/Compiler/pushpack1.h b/engine/inc/assimp/Compiler/pushpack1.h
new file mode 100644
index 00000000..94ee1e47
--- /dev/null
+++ b/engine/inc/assimp/Compiler/pushpack1.h
@@ -0,0 +1,43 @@
+
+
+// ===============================================================================
+// May be included multiple times - sets structure packing to 1 
+// for all supported compilers. #include <poppack1.h> reverts the changes.
+//
+// Currently this works on the following compilers:
+// MSVC 7,8,9
+// GCC
+// BORLAND (complains about 'pack state changed but not reverted', but works)
+// Clang
+//
+//
+// USAGE:
+//
+// struct StructToBePacked {
+// } PACK_STRUCT;
+//
+// ===============================================================================
+
+#ifdef AI_PUSHPACK_IS_DEFINED
+#	error poppack1.h must be included after pushpack1.h
+#endif
+
+#if defined(_MSC_VER) ||  defined(__BORLANDC__) ||	defined (__BCPLUSPLUS__)
+#	pragma pack(push,1)
+#	define PACK_STRUCT
+#elif defined( __GNUC__ )
+#	if !defined(HOST_MINGW)
+#		define PACK_STRUCT	__attribute__((__packed__))
+#	else
+#		define PACK_STRUCT	__attribute__((gcc_struct, __packed__))
+#	endif
+#else
+#	error Compiler not supported
+#endif
+
+#if defined(_MSC_VER)
+// C4103: Packing was changed after the inclusion of the header, probably missing #pragma pop
+#	pragma warning (disable : 4103) 
+#endif
+
+#define AI_PUSHPACK_IS_DEFINED
diff --git a/engine/inc/assimp/CreateAnimMesh.h b/engine/inc/assimp/CreateAnimMesh.h
new file mode 100644
index 00000000..ad625cb9
--- /dev/null
+++ b/engine/inc/assimp/CreateAnimMesh.h
@@ -0,0 +1,58 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file CreateAnimMesh.h
+ *  Create AnimMesh from Mesh
+ */
+#ifndef INCLUDED_AI_CREATE_ANIM_MESH_H
+#define INCLUDED_AI_CREATE_ANIM_MESH_H
+
+#include <assimp/mesh.h>
+
+namespace Assimp    {
+
+/** Create aiAnimMesh from aiMesh. */
+ASSIMP_API aiAnimMesh *aiCreateAnimMesh(const aiMesh *mesh);
+
+} // end of namespace Assimp
+#endif // INCLUDED_AI_CREATE_ANIM_MESH_H
+
diff --git a/engine/inc/assimp/DefaultIOStream.h b/engine/inc/assimp/DefaultIOStream.h
new file mode 100644
index 00000000..fcd6061b
--- /dev/null
+++ b/engine/inc/assimp/DefaultIOStream.h
@@ -0,0 +1,142 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file Default file I/O using fXXX()-family of functions */
+#ifndef AI_DEFAULTIOSTREAM_H_INC
+#define AI_DEFAULTIOSTREAM_H_INC
+
+#include <stdio.h>
+#include <assimp/IOStream.hpp>
+#include <assimp/importerdesc.h>
+#include <assimp/Defines.h>
+
+namespace Assimp    {
+
+// ----------------------------------------------------------------------------------
+//! @class  DefaultIOStream
+//! @brief  Default IO implementation, use standard IO operations
+//! @note   An instance of this class can exist without a valid file handle
+//!         attached to it. All calls fail, but the instance can nevertheless be
+//!         used with no restrictions.
+class ASSIMP_API DefaultIOStream : public IOStream
+{
+    friend class DefaultIOSystem;
+#if __ANDROID__
+# if __ANDROID_API__ > 9
+#  if defined(AI_CONFIG_ANDROID_JNI_ASSIMP_MANAGER_SUPPORT)
+    friend class AndroidJNIIOSystem;
+#  endif // defined(AI_CONFIG_ANDROID_JNI_ASSIMP_MANAGER_SUPPORT)
+# endif // __ANDROID_API__ > 9
+#endif // __ANDROID__
+
+protected:
+    DefaultIOStream();
+    DefaultIOStream(FILE* pFile, const std::string &strFilename);
+
+public:
+    /** Destructor public to allow simple deletion to close the file. */
+    ~DefaultIOStream ();
+
+    // -------------------------------------------------------------------
+    /// Read from stream
+    size_t Read(void* pvBuffer,
+        size_t pSize,
+        size_t pCount);
+
+
+    // -------------------------------------------------------------------
+    /// Write to stream
+    size_t Write(const void* pvBuffer,
+        size_t pSize,
+        size_t pCount);
+
+    // -------------------------------------------------------------------
+    /// Seek specific position
+    aiReturn Seek(size_t pOffset,
+        aiOrigin pOrigin);
+
+    // -------------------------------------------------------------------
+    /// Get current seek position
+    size_t Tell() const;
+
+    // -------------------------------------------------------------------
+    /// Get size of file
+    size_t FileSize() const;
+
+    // -------------------------------------------------------------------
+    /// Flush file contents
+    void Flush();
+
+private:
+    //  File data-structure, using clib
+    FILE* mFile;
+    //  Filename
+    std::string mFilename;
+
+    // Cached file size
+    mutable size_t mCachedSize;
+};
+
+// ----------------------------------------------------------------------------------
+inline DefaultIOStream::DefaultIOStream () :
+    mFile       (NULL),
+    mFilename   (""),
+    mCachedSize(SIZE_MAX)
+{
+    // empty
+}
+
+// ----------------------------------------------------------------------------------
+inline DefaultIOStream::DefaultIOStream (FILE* pFile,
+        const std::string &strFilename) :
+    mFile(pFile),
+    mFilename(strFilename),
+    mCachedSize(SIZE_MAX)
+{
+    // empty
+}
+// ----------------------------------------------------------------------------------
+
+} // ns assimp
+
+#endif //!!AI_DEFAULTIOSTREAM_H_INC
+
diff --git a/engine/inc/assimp/DefaultIOSystem.h b/engine/inc/assimp/DefaultIOSystem.h
new file mode 100644
index 00000000..23471d25
--- /dev/null
+++ b/engine/inc/assimp/DefaultIOSystem.h
@@ -0,0 +1,94 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file Default implementation of IOSystem using the standard C file functions */
+#ifndef AI_DEFAULTIOSYSTEM_H_INC
+#define AI_DEFAULTIOSYSTEM_H_INC
+
+#include <assimp/IOSystem.hpp>
+
+namespace Assimp    {
+
+// ---------------------------------------------------------------------------
+/** Default implementation of IOSystem using the standard C file functions */
+class ASSIMP_API DefaultIOSystem : public IOSystem
+{
+public:
+    // -------------------------------------------------------------------
+    /** Tests for the existence of a file at the given path. */
+    bool Exists( const char* pFile) const;
+
+    // -------------------------------------------------------------------
+    /** Returns the directory separator. */
+    char getOsSeparator() const;
+
+    // -------------------------------------------------------------------
+    /** Open a new file with a given path. */
+    IOStream* Open( const char* pFile, const char* pMode = "rb");
+
+    // -------------------------------------------------------------------
+    /** Closes the given file and releases all resources associated with it. */
+    void Close( IOStream* pFile);
+
+    // -------------------------------------------------------------------
+    /** Compare two paths */
+    bool ComparePaths (const char* one, const char* second) const;
+
+    /** @brief get the file name of a full filepath
+     * example: /tmp/archive.tar.gz -> archive.tar.gz
+     */
+    static std::string fileName( const std::string &path );
+
+    /** @brief get the complete base name of a full filepath
+     * example: /tmp/archive.tar.gz -> archive.tar
+     */
+    static std::string completeBaseName( const std::string &path);
+
+    /** @brief get the path of a full filepath
+     * example: /tmp/archive.tar.gz -> /tmp/
+     */
+    static std::string absolutePath( const std::string &path);
+};
+
+} //!ns Assimp
+
+#endif //AI_DEFAULTIOSYSTEM_H_INC
diff --git a/engine/inc/assimp/DefaultLogger.hpp b/engine/inc/assimp/DefaultLogger.hpp
new file mode 100644
index 00000000..1f0c899b
--- /dev/null
+++ b/engine/inc/assimp/DefaultLogger.hpp
@@ -0,0 +1,188 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+/** @file DefaultLogger.hpp
+*/
+
+#ifndef INCLUDED_AI_DEFAULTLOGGER
+#define INCLUDED_AI_DEFAULTLOGGER
+
+#include "Logger.hpp"
+#include "LogStream.hpp"
+#include "NullLogger.hpp"
+#include <vector>
+
+namespace Assimp    {
+// ------------------------------------------------------------------------------------
+class IOStream;
+struct LogStreamInfo;
+
+/** default name of logfile */
+#define ASSIMP_DEFAULT_LOG_NAME "AssimpLog.txt"
+
+// ------------------------------------------------------------------------------------
+/** @brief CPP-API: Primary logging facility of Assimp.
+ *
+ *  The library stores its primary #Logger as a static member of this class.
+ *  #get() returns this primary logger. By default the underlying implementation is
+ *  just a #NullLogger which rejects all log messages. By calling #create(), logging
+ *  is turned on. To capture the log output multiple log streams (#LogStream) can be
+ *  attach to the logger. Some default streams for common streaming locations (such as
+ *  a file, std::cout, OutputDebugString()) are also provided.
+ *
+ *  If you wish to customize the logging at an even deeper level supply your own
+ *  implementation of #Logger to #set().
+ *  @note The whole logging stuff causes a small extra overhead for all imports. */
+class ASSIMP_API DefaultLogger :
+    public Logger   {
+
+public:
+
+    // ----------------------------------------------------------------------
+    /** @brief Creates a logging instance.
+     *  @param name Name for log file. Only valid in combination
+     *    with the aiDefaultLogStream_FILE flag.
+     *  @param severity Log severity, VERBOSE turns on debug messages
+     *  @param defStreams  Default log streams to be attached. Any bitwise
+     *    combination of the aiDefaultLogStream enumerated values.
+     *    If #aiDefaultLogStream_FILE is specified but an empty string is
+     *    passed for 'name', no log file is created at all.
+     *  @param  io IOSystem to be used to open external files (such as the
+     *   log file). Pass NULL to rely on the default implementation.
+     *  This replaces the default #NullLogger with a #DefaultLogger instance. */
+    static Logger *create(const char* name = ASSIMP_DEFAULT_LOG_NAME,
+        LogSeverity severity    = NORMAL,
+        unsigned int defStreams = aiDefaultLogStream_DEBUGGER | aiDefaultLogStream_FILE,
+        IOSystem* io            = NULL);
+
+    // ----------------------------------------------------------------------
+    /** @brief Setup a custom #Logger implementation.
+     *
+     *  Use this if the provided #DefaultLogger class doesn't fit into
+     *  your needs. If the provided message formatting is OK for you,
+     *  it's much easier to use #create() and to attach your own custom
+     *  output streams to it.
+     *  @param logger Pass NULL to setup a default NullLogger*/
+    static void set (Logger *logger);
+
+    // ----------------------------------------------------------------------
+    /** @brief  Getter for singleton instance
+     *   @return Only instance. This is never null, but it could be a
+     *  NullLogger. Use isNullLogger to check this.*/
+    static Logger *get();
+
+    // ----------------------------------------------------------------------
+    /** @brief  Return whether a #NullLogger is currently active
+     *  @return true if the current logger is a #NullLogger.
+     *  Use create() or set() to setup a logger that does actually do
+     *  something else than just rejecting all log messages. */
+    static bool isNullLogger();
+
+    // ----------------------------------------------------------------------
+    /** @brief  Kills the current singleton logger and replaces it with a
+     *  #NullLogger instance. */
+    static void kill();
+
+    // ----------------------------------------------------------------------
+    /** @copydoc Logger::attachStream   */
+    bool attachStream(LogStream *pStream,
+        unsigned int severity);
+
+    // ----------------------------------------------------------------------
+    /** @copydoc Logger::detatchStream */
+    bool detatchStream(LogStream *pStream,
+        unsigned int severity);
+
+private:
+    // ----------------------------------------------------------------------
+    /** @briefPrivate construction for internal use by create().
+     *  @param severity Logging granularity  */
+    explicit DefaultLogger(LogSeverity severity);
+
+    // ----------------------------------------------------------------------
+    /** @briefDestructor    */
+    ~DefaultLogger();
+
+    /** @brief  Logs debug infos, only been written when severity level VERBOSE is set */
+    void OnDebug(const char* message);
+
+    /** @brief  Logs an info message */
+    void OnInfo(const char*  message);
+
+    /** @brief  Logs a warning message */
+    void OnWarn(const char*  message);
+
+    /** @brief  Logs an error message */
+    void OnError(const char* message);
+
+    // ----------------------------------------------------------------------
+    /** @brief Writes a message to all streams */
+    void WriteToStreams(const char* message, ErrorSeverity ErrorSev );
+
+    // ----------------------------------------------------------------------
+    /** @brief Returns the thread id.
+     *  @note This is an OS specific feature, if not supported, a
+     *    zero will be returned.
+     */
+    unsigned int GetThreadID();
+
+private:
+    //  Aliases for stream container
+    typedef std::vector<LogStreamInfo*> StreamArray;
+    typedef std::vector<LogStreamInfo*>::iterator StreamIt;
+    typedef std::vector<LogStreamInfo*>::const_iterator ConstStreamIt;
+
+    //! only logging instance
+    static Logger *m_pLogger;
+    static NullLogger s_pNullLogger;
+
+    //! Attached streams
+    StreamArray m_StreamArray;
+
+    bool noRepeatMsg;
+    char lastMsg[MAX_LOG_MESSAGE_LENGTH*2];
+    size_t lastLen;
+};
+// ------------------------------------------------------------------------------------
+
+} // Namespace Assimp
+
+#endif // !! INCLUDED_AI_DEFAULTLOGGER
diff --git a/engine/inc/assimp/Defines.h b/engine/inc/assimp/Defines.h
new file mode 100644
index 00000000..15e1d83c
--- /dev/null
+++ b/engine/inc/assimp/Defines.h
@@ -0,0 +1,49 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2012, assimp team
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+// We need those constants, workaround for any platforms where nobody defined them yet
+#if (!defined SIZE_MAX)
+#   define SIZE_MAX (~((size_t)0))
+#endif
+
+#if (!defined UINT_MAX)
+#   define UINT_MAX (~((unsigned int)0))
+#endif
+
diff --git a/engine/inc/assimp/Exceptional.h b/engine/inc/assimp/Exceptional.h
new file mode 100644
index 00000000..5109b8f0
--- /dev/null
+++ b/engine/inc/assimp/Exceptional.h
@@ -0,0 +1,125 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2008, assimp team
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#ifndef INCLUDED_EXCEPTIONAL_H
+#define INCLUDED_EXCEPTIONAL_H
+
+#include <stdexcept>
+#include <assimp/DefaultIOStream.h>
+using std::runtime_error;
+
+#ifdef _MSC_VER
+#   pragma warning(disable : 4275)
+#endif
+
+// ---------------------------------------------------------------------------
+/** FOR IMPORTER PLUGINS ONLY: Simple exception class to be thrown if an
+ *  unrecoverable error occurs while importing. Loading APIs return
+ *  NULL instead of a valid aiScene then.  */
+class DeadlyImportError
+    : public runtime_error
+{
+public:
+    /** Constructor with arguments */
+    explicit DeadlyImportError( const std::string& errorText)
+        : runtime_error(errorText)
+    {
+    }
+
+private:
+};
+
+typedef DeadlyImportError DeadlyExportError;
+
+#ifdef _MSC_VER
+#   pragma warning(default : 4275)
+#endif
+
+// ---------------------------------------------------------------------------
+template <typename T>
+struct ExceptionSwallower   {
+    T operator ()() const {
+        return T();
+    }
+};
+
+// ---------------------------------------------------------------------------
+template <typename T>
+struct ExceptionSwallower<T*>   {
+    T* operator ()() const {
+        return NULL;
+    }
+};
+
+// ---------------------------------------------------------------------------
+template <>
+struct ExceptionSwallower<aiReturn> {
+    aiReturn operator ()() const {
+        try {
+            throw;
+        }
+        catch (std::bad_alloc&) {
+            return aiReturn_OUTOFMEMORY;
+        }
+        catch (...) {
+            return aiReturn_FAILURE;
+        }
+    }
+};
+
+// ---------------------------------------------------------------------------
+template <>
+struct ExceptionSwallower<void> {
+    void operator ()() const {
+        return;
+    }
+};
+
+#define ASSIMP_BEGIN_EXCEPTION_REGION()\
+{\
+    try {
+
+#define ASSIMP_END_EXCEPTION_REGION(type)\
+    } catch(...) {\
+        return ExceptionSwallower<type>()();\
+    }\
+}
+
+#endif // INCLUDED_EXCEPTIONAL_H
diff --git a/engine/inc/assimp/Exporter.hpp b/engine/inc/assimp/Exporter.hpp
new file mode 100644
index 00000000..e7e43d8b
--- /dev/null
+++ b/engine/inc/assimp/Exporter.hpp
@@ -0,0 +1,484 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file  Exporter.hpp
+*  @brief Defines the CPP-API for the Assimp export interface
+*/
+#pragma once
+#ifndef AI_EXPORT_HPP_INC
+#define AI_EXPORT_HPP_INC
+
+#ifndef ASSIMP_BUILD_NO_EXPORT
+
+#include "cexport.h"
+#include <map>
+
+namespace Assimp {
+    
+class ExporterPimpl;
+class IOSystem;
+
+// ----------------------------------------------------------------------------------
+/** CPP-API: The Exporter class forms an C++ interface to the export functionality
+ * of the Open Asset Import Library. Note that the export interface is available
+ * only if Assimp has been built with ASSIMP_BUILD_NO_EXPORT not defined.
+ *
+ * The interface is modeled after the importer interface and mostly
+ * symmetric. The same rules for threading etc. apply.
+ *
+ * In a nutshell, there are two export interfaces: #Export, which writes the
+ * output file(s) either to the regular file system or to a user-supplied
+ * #IOSystem, and #ExportToBlob which returns a linked list of memory
+ * buffers (blob), each referring to one output file (in most cases
+ * there will be only one output file of course, but this extra complexity is
+ * needed since Assimp aims at supporting a wide range of file formats).
+ *
+ * #ExportToBlob is especially useful if you intend to work
+ * with the data in-memory.
+*/
+class ASSIMP_API ExportProperties;
+
+class ASSIMP_API Exporter {
+public:
+    /** Function pointer type of a Export worker function */
+    typedef void (*fpExportFunc)(const char*, IOSystem*, const aiScene*, const ExportProperties*);
+
+    /** Internal description of an Assimp export format option */
+    struct ExportFormatEntry
+    {
+        /// Public description structure to be returned by aiGetExportFormatDescription()
+        aiExportFormatDesc mDescription;
+
+        // Worker function to do the actual exporting
+        fpExportFunc mExportFunction;
+
+        // Post-processing steps to be executed PRIOR to invoking mExportFunction
+        unsigned int mEnforcePP;
+
+        // Constructor to fill all entries
+        ExportFormatEntry( const char* pId, const char* pDesc, const char* pExtension, fpExportFunc pFunction, unsigned int pEnforcePP = 0u)
+        {
+            mDescription.id = pId;
+            mDescription.description = pDesc;
+            mDescription.fileExtension = pExtension;
+            mExportFunction = pFunction;
+            mEnforcePP = pEnforcePP;
+        }
+
+        ExportFormatEntry() :
+            mExportFunction()
+          , mEnforcePP()
+        {
+            mDescription.id = NULL;
+            mDescription.description = NULL;
+            mDescription.fileExtension = NULL;
+        }
+    };
+
+
+public:
+    Exporter();
+    ~Exporter();
+
+public:
+    // -------------------------------------------------------------------
+    /** Supplies a custom IO handler to the exporter to use to open and
+     * access files.
+     *
+     * If you need #Export to use custom IO logic to access the files,
+     * you need to supply a custom implementation of IOSystem and
+     * IOFile to the exporter.
+     *
+     * #Exporter takes ownership of the object and will destroy it
+     * afterwards. The previously assigned handler will be deleted.
+     * Pass NULL to take again ownership of your IOSystem and reset Assimp
+     * to use its default implementation, which uses plain file IO.
+     *
+     * @param pIOHandler The IO handler to be used in all file accesses
+     *   of the Importer. */
+    void SetIOHandler( IOSystem* pIOHandler);
+
+    // -------------------------------------------------------------------
+    /** Retrieves the IO handler that is currently set.
+     * You can use #IsDefaultIOHandler() to check whether the returned
+     * interface is the default IO handler provided by ASSIMP. The default
+     * handler is active as long the application doesn't supply its own
+     * custom IO handler via #SetIOHandler().
+     * @return A valid IOSystem interface, never NULL. */
+    IOSystem* GetIOHandler() const;
+
+    // -------------------------------------------------------------------
+    /** Checks whether a default IO handler is active
+     * A default handler is active as long the application doesn't
+     * supply its own custom IO handler via #SetIOHandler().
+     * @return true by default */
+    bool IsDefaultIOHandler() const;
+
+    // -------------------------------------------------------------------
+    /** Exports the given scene to a chosen file format. Returns the exported
+    * data as a binary blob which you can write into a file or something.
+    * When you're done with the data, simply let the #Exporter instance go
+    * out of scope to have it released automatically.
+    * @param pScene The scene to export. Stays in possession of the caller,
+    *   is not changed by the function.
+    * @param pFormatId ID string to specify to which format you want to
+    *   export to. Use
+    * #GetExportFormatCount / #GetExportFormatDescription to learn which
+    *   export formats are available.
+    * @param pPreprocessing See the documentation for #Export
+    * @return the exported data or NULL in case of error.
+    * @note If the Exporter instance did already hold a blob from
+    *   a previous call to #ExportToBlob, it will be disposed.
+    *   Any IO handlers set via #SetIOHandler are ignored here.
+    * @note Use aiCopyScene() to get a modifiable copy of a previously
+    *   imported scene. */
+    const aiExportDataBlob* ExportToBlob(const aiScene* pScene, const char* pFormatId, unsigned int pPreprocessing = 0u, const ExportProperties* = NULL);
+    const aiExportDataBlob* ExportToBlob(  const aiScene* pScene, const std::string& pFormatId, unsigned int pPreprocessing = 0u, const ExportProperties* pProperties = NULL);
+
+    // -------------------------------------------------------------------
+    /** Convenience function to export directly to a file. Use
+     *  #SetIOSystem to supply a custom IOSystem to gain fine-grained control
+     *  about the output data flow of the export process.
+     * @param pBlob A data blob obtained from a previous call to #aiExportScene. Must not be NULL.
+     * @param pPath Full target file name. Target must be accessible.
+     * @param pPreprocessing Accepts any choice of the #aiPostProcessSteps enumerated
+     *   flags, but in reality only a subset of them makes sense here. Specifying
+     *   'preprocessing' flags is useful if the input scene does not conform to
+     *   Assimp's default conventions as specified in the @link data Data Structures Page @endlink.
+     *   In short, this means the geometry data should use a right-handed coordinate systems, face
+     *   winding should be counter-clockwise and the UV coordinate origin is assumed to be in
+     *   the upper left. The #aiProcess_MakeLeftHanded, #aiProcess_FlipUVs and
+     *   #aiProcess_FlipWindingOrder flags are used in the import side to allow users
+     *   to have those defaults automatically adapted to their conventions. Specifying those flags
+     *   for exporting has the opposite effect, respectively. Some other of the
+     *   #aiPostProcessSteps enumerated values may be useful as well, but you'll need
+     *   to try out what their effect on the exported file is. Many formats impose
+     *   their own restrictions on the structure of the geometry stored therein,
+     *   so some preprocessing may have little or no effect at all, or may be
+     *   redundant as exporters would apply them anyhow. A good example
+     *   is triangulation - whilst you can enforce it by specifying
+     *   the #aiProcess_Triangulate flag, most export formats support only
+     *   triangulate data so they would run the step even if it wasn't requested.
+     *
+     *   If assimp detects that the input scene was directly taken from the importer side of
+     *   the library (i.e. not copied using aiCopyScene and potentially modified afterwards),
+     *   any post-processing steps already applied to the scene will not be applied again, unless
+     *   they show non-idempotent behavior (#aiProcess_MakeLeftHanded, #aiProcess_FlipUVs and
+     *   #aiProcess_FlipWindingOrder).
+     * @return AI_SUCCESS if everything was fine.
+     * @note Use aiCopyScene() to get a modifiable copy of a previously
+     *   imported scene.*/
+    aiReturn Export( const aiScene* pScene, const char* pFormatId, const char* pPath, unsigned int pPreprocessing = 0u, const ExportProperties* pProperties = NULL);
+    aiReturn Export( const aiScene* pScene, const std::string& pFormatId, const std::string& pPath,  unsigned int pPreprocessing = 0u, const ExportProperties* pProperties = NULL);
+
+    // -------------------------------------------------------------------
+    /** Returns an error description of an error that occurred in #Export
+     *    or #ExportToBlob
+     *
+     * Returns an empty string if no error occurred.
+     * @return A description of the last error, an empty string if no
+     *   error occurred. The string is never NULL.
+     *
+     * @note The returned function remains valid until one of the
+     * following methods is called: #Export, #ExportToBlob, #FreeBlob */
+    const char* GetErrorString() const;
+
+    // -------------------------------------------------------------------
+    /** Return the blob obtained from the last call to #ExportToBlob */
+    const aiExportDataBlob* GetBlob() const;
+
+    // -------------------------------------------------------------------
+    /** Orphan the blob from the last call to #ExportToBlob. This means
+     *  the caller takes ownership and is thus responsible for calling
+     *  the C API function #aiReleaseExportBlob to release it. */
+    const aiExportDataBlob* GetOrphanedBlob() const;
+
+    // -------------------------------------------------------------------
+    /** Frees the current blob.
+     *
+     *  The function does nothing if no blob has previously been
+     *  previously produced via #ExportToBlob. #FreeBlob is called
+     *  automatically by the destructor. The only reason to call
+     *  it manually would be to reclaim as much storage as possible
+     *  without giving up the #Exporter instance yet. */
+    void FreeBlob( );
+
+    // -------------------------------------------------------------------
+    /** Returns the number of export file formats available in the current
+     *  Assimp build. Use #Exporter::GetExportFormatDescription to
+     *  retrieve infos of a specific export format.
+     *
+     *  This includes built-in exporters as well as exporters registered
+     *  using #RegisterExporter.
+     **/
+    size_t GetExportFormatCount() const;
+
+    // -------------------------------------------------------------------
+    /** Returns a description of the nth export file format. Use #
+     *  #Exporter::GetExportFormatCount to learn how many export
+     *  formats are supported.
+     *
+     * The returned pointer is of static storage duration if the
+     * pIndex pertains to a built-in exporter (i.e. one not registered
+     * via #RegistrerExporter). It is restricted to the life-time of the
+     * #Exporter instance otherwise.
+     *
+     * @param pIndex Index of the export format to retrieve information
+     *  for. Valid range is 0 to #Exporter::GetExportFormatCount
+     * @return A description of that specific export format.
+     *  NULL if pIndex is out of range. */
+    const aiExportFormatDesc* GetExportFormatDescription( size_t pIndex ) const;
+
+    // -------------------------------------------------------------------
+    /** Register a custom exporter. Custom export formats are limited to
+     *    to the current #Exporter instance and do not affect the
+     *    library globally. The indexes under which the format's
+     *    export format description can be queried are assigned
+     *    monotonously.
+     *  @param desc Exporter description.
+     *  @return aiReturn_SUCCESS if the export format was successfully
+     *    registered. A common cause that would prevent an exporter
+     *    from being registered is that its format id is already
+     *    occupied by another format. */
+    aiReturn RegisterExporter(const ExportFormatEntry& desc);
+
+    // -------------------------------------------------------------------
+    /** Remove an export format previously registered with #RegisterExporter
+     *  from the #Exporter instance (this can also be used to drop
+     *  built-in exporters because those are implicitly registered
+     *  using #RegisterExporter).
+     *  @param id Format id to be unregistered, this refers to the
+     *    'id' field of #aiExportFormatDesc.
+     *  @note Calling this method on a format description not yet registered
+     *    has no effect.*/
+    void UnregisterExporter(const char* id);
+
+protected:
+    // Just because we don't want you to know how we're hacking around.
+    ExporterPimpl* pimpl;
+};
+
+class ASSIMP_API ExportProperties {
+public:
+    // Data type to store the key hash
+    typedef unsigned int KeyType;
+
+    // typedefs for our four configuration maps.
+    // We don't need more, so there is no need for a generic solution
+    typedef std::map<KeyType, int> IntPropertyMap;
+    typedef std::map<KeyType, ai_real> FloatPropertyMap;
+    typedef std::map<KeyType, std::string> StringPropertyMap;
+    typedef std::map<KeyType, aiMatrix4x4> MatrixPropertyMap;
+
+public:
+    /** Standard constructor
+    * @see ExportProperties()
+    */
+    ExportProperties();
+
+    // -------------------------------------------------------------------
+    /** Copy constructor.
+     *
+     * This copies the configuration properties of another ExportProperties.
+     * @see ExportProperties(const ExportProperties& other)
+     */
+    ExportProperties(const ExportProperties& other);
+
+    // -------------------------------------------------------------------
+    /** Set an integer configuration property.
+     * @param szName Name of the property. All supported properties
+     *   are defined in the aiConfig.g header (all constants share the
+     *   prefix AI_CONFIG_XXX and are simple strings).
+     * @param iValue New value of the property
+     * @return true if the property was set before. The new value replaces
+     *   the previous value in this case.
+     * @note Property of different types (float, int, string ..) are kept
+     *   on different stacks, so calling SetPropertyInteger() for a
+     *   floating-point property has no effect - the loader will call
+     *   GetPropertyFloat() to read the property, but it won't be there.
+     */
+    bool SetPropertyInteger(const char* szName, int iValue);
+
+    // -------------------------------------------------------------------
+    /** Set a boolean configuration property. Boolean properties
+     *  are stored on the integer stack internally so it's possible
+     *  to set them via #SetPropertyBool and query them with
+     *  #GetPropertyBool and vice versa.
+     * @see SetPropertyInteger()
+     */
+    bool SetPropertyBool(const char* szName, bool value)    {
+        return SetPropertyInteger(szName,value);
+    }
+
+    // -------------------------------------------------------------------
+    /** Set a floating-point configuration property.
+     * @see SetPropertyInteger()
+     */
+    bool SetPropertyFloat(const char* szName, ai_real fValue);
+
+    // -------------------------------------------------------------------
+    /** Set a string configuration property.
+     * @see SetPropertyInteger()
+     */
+    bool SetPropertyString(const char* szName, const std::string& sValue);
+
+    // -------------------------------------------------------------------
+    /** Set a matrix configuration property.
+     * @see SetPropertyInteger()
+     */
+    bool SetPropertyMatrix(const char* szName, const aiMatrix4x4& sValue);
+
+    // -------------------------------------------------------------------
+    /** Get a configuration property.
+     * @param szName Name of the property. All supported properties
+     *   are defined in the aiConfig.g header (all constants share the
+     *   prefix AI_CONFIG_XXX).
+     * @param iErrorReturn Value that is returned if the property
+     *   is not found.
+     * @return Current value of the property
+     * @note Property of different types (float, int, string ..) are kept
+     *   on different lists, so calling SetPropertyInteger() for a
+     *   floating-point property has no effect - the loader will call
+     *   GetPropertyFloat() to read the property, but it won't be there.
+     */
+    int GetPropertyInteger(const char* szName,
+        int iErrorReturn = 0xffffffff) const;
+
+    // -------------------------------------------------------------------
+    /** Get a boolean configuration property. Boolean properties
+     *  are stored on the integer stack internally so it's possible
+     *  to set them via #SetPropertyBool and query them with
+     *  #GetPropertyBool and vice versa.
+     * @see GetPropertyInteger()
+     */
+    bool GetPropertyBool(const char* szName, bool bErrorReturn = false) const {
+        return GetPropertyInteger(szName,bErrorReturn)!=0;
+    }
+
+    // -------------------------------------------------------------------
+    /** Get a floating-point configuration property
+     * @see GetPropertyInteger()
+     */
+    ai_real GetPropertyFloat(const char* szName,
+        ai_real fErrorReturn = 10e10f) const;
+
+    // -------------------------------------------------------------------
+    /** Get a string configuration property
+     *
+     *  The return value remains valid until the property is modified.
+     * @see GetPropertyInteger()
+     */
+    const std::string GetPropertyString(const char* szName,
+        const std::string& sErrorReturn = "") const;
+
+    // -------------------------------------------------------------------
+    /** Get a matrix configuration property
+     *
+     *  The return value remains valid until the property is modified.
+     * @see GetPropertyInteger()
+     */
+    const aiMatrix4x4 GetPropertyMatrix(const char* szName,
+        const aiMatrix4x4& sErrorReturn = aiMatrix4x4()) const;
+
+    // -------------------------------------------------------------------
+    /** Determine a integer configuration property has been set.
+    * @see HasPropertyInteger()
+     */
+    bool HasPropertyInteger(const char* szName) const;
+
+    /** Determine a boolean configuration property has been set.
+    * @see HasPropertyBool()
+     */
+    bool HasPropertyBool(const char* szName) const;
+
+    /** Determine a boolean configuration property has been set.
+    * @see HasPropertyFloat()
+     */
+    bool HasPropertyFloat(const char* szName) const;
+
+    /** Determine a String configuration property has been set.
+    * @see HasPropertyString()
+     */
+    bool HasPropertyString(const char* szName) const;
+
+    /** Determine a Matrix configuration property has been set.
+    * @see HasPropertyMatrix()
+     */
+    bool HasPropertyMatrix(const char* szName) const;
+
+protected:
+
+    /** List of integer properties */
+    IntPropertyMap mIntProperties;
+
+    /** List of floating-point properties */
+    FloatPropertyMap mFloatProperties;
+
+    /** List of string properties */
+    StringPropertyMap mStringProperties;
+
+    /** List of Matrix properties */
+    MatrixPropertyMap mMatrixProperties;
+};
+
+// ----------------------------------------------------------------------------------
+inline 
+const aiExportDataBlob* Exporter::ExportToBlob(  const aiScene* pScene, const std::string& pFormatId,
+                                                 unsigned int pPreprocessing, const ExportProperties* pProperties)
+{
+    return ExportToBlob(pScene,pFormatId.c_str(),pPreprocessing, pProperties);
+}
+
+// ----------------------------------------------------------------------------------
+inline
+aiReturn Exporter :: Export( const aiScene* pScene, const std::string& pFormatId, 
+                                    const std::string& pPath, unsigned int pPreprocessing, 
+                                    const ExportProperties* pProperties)
+{
+    return Export(pScene,pFormatId.c_str(),pPath.c_str(),pPreprocessing, pProperties);
+}
+
+} // namespace Assimp
+
+#endif // ASSIMP_BUILD_NO_EXPORT
+#endif // AI_EXPORT_HPP_INC
diff --git a/engine/inc/assimp/GenericProperty.h b/engine/inc/assimp/GenericProperty.h
new file mode 100644
index 00000000..96c74b4c
--- /dev/null
+++ b/engine/inc/assimp/GenericProperty.h
@@ -0,0 +1,127 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#ifndef AI_GENERIC_PROPERTY_H_INCLUDED
+#define AI_GENERIC_PROPERTY_H_INCLUDED
+
+#include <assimp/Importer.hpp>
+#include <assimp/ai_assert.h>
+#include "Hash.h"
+#include <map>
+
+
+// ------------------------------------------------------------------------------------------------
+template <class T>
+inline bool SetGenericProperty(std::map< unsigned int, T >& list,
+    const char* szName, const T& value)
+{
+    ai_assert(NULL != szName);
+    const uint32_t hash = SuperFastHash(szName);
+
+    typename std::map<unsigned int, T>::iterator it = list.find(hash);
+    if (it == list.end())   {
+        list.insert(std::pair<unsigned int, T>( hash, value ));
+        return false;
+    }
+    (*it).second = value;
+    return true;
+}
+
+// ------------------------------------------------------------------------------------------------
+template <class T>
+inline const T& GetGenericProperty(const std::map< unsigned int, T >& list,
+    const char* szName, const T& errorReturn)
+{
+    ai_assert(NULL != szName);
+    const uint32_t hash = SuperFastHash(szName);
+
+    typename std::map<unsigned int, T>::const_iterator it = list.find(hash);
+    if (it == list.end())
+        return errorReturn;
+
+    return (*it).second;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Special version for pointer types - they will be deleted when replaced with another value
+// passing NULL removes the whole property
+template <class T>
+inline void SetGenericPropertyPtr(std::map< unsigned int, T* >& list,
+    const char* szName, T* value, bool* bWasExisting = NULL)
+{
+    ai_assert(NULL != szName);
+    const uint32_t hash = SuperFastHash(szName);
+
+    typename std::map<unsigned int, T*>::iterator it = list.find(hash);
+    if (it == list.end())   {
+        if (bWasExisting)
+            *bWasExisting = false;
+
+        list.insert(std::pair<unsigned int,T*>( hash, value ));
+        return;
+    }
+    if ((*it).second != value)  {
+        delete (*it).second;
+        (*it).second = value;
+    }
+    if (!value) {
+        list.erase(it);
+    }
+    if (bWasExisting)
+        *bWasExisting = true;
+}
+
+// ------------------------------------------------------------------------------------------------
+template <class T>
+inline bool HasGenericProperty(const std::map< unsigned int, T >& list,
+    const char* szName)
+{
+    ai_assert(NULL != szName);
+    const uint32_t hash = SuperFastHash(szName);
+
+    typename std::map<unsigned int, T>::const_iterator it = list.find(hash);
+    if (it == list.end()) return false;
+
+    return true;
+}
+
+#endif // !! AI_GENERIC_PROPERTY_H_INCLUDED
diff --git a/engine/inc/assimp/Hash.h b/engine/inc/assimp/Hash.h
new file mode 100644
index 00000000..eb5df757
--- /dev/null
+++ b/engine/inc/assimp/Hash.h
@@ -0,0 +1,118 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#ifndef AI_HASH_H_INCLUDED
+#define AI_HASH_H_INCLUDED
+
+#include <stdint.h>
+#include <string.h>
+
+// ------------------------------------------------------------------------------------------------
+// Hashing function taken from
+// http://www.azillionmonkeys.com/qed/hash.html
+// (incremental version)
+//
+// This code is Copyright 2004-2008 by Paul Hsieh. It is used here in the belief that
+// Assimp's license is considered compatible with Pauls's derivative license as specified
+// on his web page.
+//
+// (stdint.h should have been been included here)
+// ------------------------------------------------------------------------------------------------
+#undef get16bits
+#if (defined(__GNUC__) && defined(__i386__)) || defined(__WATCOMC__) \
+  || defined(_MSC_VER) || defined (__BORLANDC__) || defined (__TURBOC__)
+#define get16bits(d) (*((const uint16_t *) (d)))
+#endif
+
+#if !defined (get16bits)
+#define get16bits(d) ((((uint32_t)(((const uint8_t *)(d))[1])) << 8)\
+                       +(uint32_t)(((const uint8_t *)(d))[0]) )
+#endif
+
+// ------------------------------------------------------------------------------------------------
+inline uint32_t SuperFastHash (const char * data, uint32_t len = 0, uint32_t hash = 0) {
+uint32_t tmp;
+int rem;
+
+    if (!data) return 0;
+    if (!len)len = (uint32_t)::strlen(data);
+
+    rem = len & 3;
+    len >>= 2;
+
+    /* Main loop */
+    for (;len > 0; len--) {
+        hash  += get16bits (data);
+        tmp    = (get16bits (data+2) << 11) ^ hash;
+        hash   = (hash << 16) ^ tmp;
+        data  += 2*sizeof (uint16_t);
+        hash  += hash >> 11;
+    }
+
+    /* Handle end cases */
+    switch (rem) {
+        case 3: hash += get16bits (data);
+                hash ^= hash << 16;
+                hash ^= data[sizeof (uint16_t)] << 18;
+                hash += hash >> 11;
+                break;
+        case 2: hash += get16bits (data);
+                hash ^= hash << 11;
+                hash += hash >> 17;
+                break;
+        case 1: hash += *data;
+                hash ^= hash << 10;
+                hash += hash >> 1;
+    }
+
+    /* Force "avalanching" of final 127 bits */
+    hash ^= hash << 3;
+    hash += hash >> 5;
+    hash ^= hash << 4;
+    hash += hash >> 17;
+    hash ^= hash << 25;
+    hash += hash >> 6;
+
+    return hash;
+}
+
+#endif // !! AI_HASH_H_INCLUDED
diff --git a/engine/inc/assimp/IOStream.hpp b/engine/inc/assimp/IOStream.hpp
new file mode 100644
index 00000000..eb2a0f21
--- /dev/null
+++ b/engine/inc/assimp/IOStream.hpp
@@ -0,0 +1,142 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+/** @file IOStream.hpp
+ *  @brief File I/O wrappers for C++.
+ */
+
+#pragma once
+#ifndef AI_IOSTREAM_H_INC
+#define AI_IOSTREAM_H_INC
+
+#include "types.h"
+
+#ifndef __cplusplus
+#   error This header requires C++ to be used. aiFileIO.h is the \
+    corresponding C interface.
+#endif
+
+namespace Assimp    {
+
+// ----------------------------------------------------------------------------------
+/** @brief CPP-API: Class to handle file I/O for C++
+ *
+ *  Derive an own implementation from this interface to provide custom IO handling
+ *  to the Importer. If you implement this interface, be sure to also provide an
+ *  implementation for IOSystem that creates instances of your custom IO class.
+*/
+class ASSIMP_API IOStream
+#ifndef SWIG
+    : public Intern::AllocateFromAssimpHeap
+#endif
+{
+protected:
+    /** Constructor protected, use IOSystem::Open() to create an instance. */
+    IOStream();
+
+public:
+    // -------------------------------------------------------------------
+    /** @brief Destructor. Deleting the object closes the underlying file,
+     * alternatively you may use IOSystem::Close() to release the file.
+     */
+    virtual ~IOStream();
+
+    // -------------------------------------------------------------------
+    /** @brief Read from the file
+     *
+     * See fread() for more details
+     * This fails for write-only files */
+    virtual size_t Read(void* pvBuffer,
+        size_t pSize,
+        size_t pCount) = 0;
+
+    // -------------------------------------------------------------------
+    /** @brief Write to the file
+    *
+    * See fwrite() for more details
+    * This fails for read-only files */
+    virtual size_t Write(const void* pvBuffer,
+        size_t pSize,
+        size_t pCount) = 0;
+
+    // -------------------------------------------------------------------
+    /** @brief Set the read/write cursor of the file
+     *
+     * Note that the offset is _negative_ for aiOrigin_END.
+     * See fseek() for more details */
+    virtual aiReturn Seek(size_t pOffset,
+        aiOrigin pOrigin) = 0;
+
+    // -------------------------------------------------------------------
+    /** @brief Get the current position of the read/write cursor
+     *
+     * See ftell() for more details */
+    virtual size_t Tell() const = 0;
+
+    // -------------------------------------------------------------------
+    /** @brief Returns filesize
+     *  Returns the filesize. */
+    virtual size_t FileSize() const = 0;
+
+    // -------------------------------------------------------------------
+    /** @brief Flush the contents of the file buffer (for writers)
+     *  See fflush() for more details.
+     */
+    virtual void Flush() = 0;
+}; //! class IOStream
+
+// ----------------------------------------------------------------------------------
+inline
+IOStream::IOStream() {
+    // empty
+}
+
+// ----------------------------------------------------------------------------------
+inline
+IOStream::~IOStream() {
+    // empty
+}
+// ----------------------------------------------------------------------------------
+
+} //!namespace Assimp
+
+#endif //!!AI_IOSTREAM_H_INC
diff --git a/engine/inc/assimp/IOStreamBuffer.h b/engine/inc/assimp/IOStreamBuffer.h
new file mode 100644
index 00000000..c93a191d
--- /dev/null
+++ b/engine/inc/assimp/IOStreamBuffer.h
@@ -0,0 +1,352 @@
+#pragma once
+
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#include <assimp/types.h>
+#include <assimp/IOStream.hpp>
+
+#include "ParsingUtils.h"
+
+#include <vector>
+
+namespace Assimp {
+
+// ---------------------------------------------------------------------------
+/**
+ *  Implementation of a cached stream buffer.
+ */
+template<class T>
+class IOStreamBuffer {
+public:
+    /// @brief  The class constructor.
+    IOStreamBuffer( size_t cache = 4096 * 4096 );
+
+    /// @brief  The class destructor.
+    ~IOStreamBuffer();
+
+    /// @brief  Will open the cached access for a given stream.
+    /// @param  stream      The stream to cache.
+    /// @return true if successful.
+    bool open( IOStream *stream );
+
+    /// @brief  Will close the cached access.
+    /// @return true if successful.
+    bool close();
+
+    /// @brief  Returns the file-size.
+    /// @return The file-size.
+    size_t size() const;
+    
+    /// @brief  Returns the cache size.
+    /// @return The cache size.
+    size_t cacheSize() const;
+
+    /// @brief  Will read the next block.
+    /// @return true if successful.
+    bool readNextBlock();
+
+    /// @brief  Returns the number of blocks to read.
+    /// @return The number of blocks.
+    size_t getNumBlocks() const;
+
+    /// @brief  Returns the current block index.
+    /// @return The current block index.
+    size_t getCurrentBlockIndex() const;
+
+    /// @brief  Returns the current file pos.
+    /// @return The current file pos.
+    size_t getFilePos() const;
+
+    /// @brief  Will read the next line.
+    /// @param  buffer      The buffer for the next line.
+    /// @return true if successful.
+    bool getNextDataLine( std::vector<T> &buffer, T continuationToken );
+
+    /// @brief  Will read the next line ascii or binary end line char.
+    /// @param  buffer      The buffer for the next line.
+    /// @return true if successful.
+    bool getNextLine(std::vector<T> &buffer);
+
+    /// @brief  Will read the next block.
+    /// @param  buffer      The buffer for the next block.
+    /// @return true if successful.
+    bool getNextBlock( std::vector<T> &buffer );
+
+private:
+    IOStream *m_stream;
+    size_t m_filesize;
+    size_t m_cacheSize;
+    size_t m_numBlocks;
+    size_t m_blockIdx;
+    std::vector<T> m_cache;
+    size_t m_cachePos;
+    size_t m_filePos;
+};
+
+template<class T>
+inline
+IOStreamBuffer<T>::IOStreamBuffer( size_t cache )
+: m_stream( nullptr )
+, m_filesize( 0 )
+, m_cacheSize( cache )
+, m_numBlocks( 0 )
+, m_blockIdx( 0 )
+, m_cachePos( 0 )
+, m_filePos( 0 ) {
+    m_cache.resize( cache );
+    std::fill( m_cache.begin(), m_cache.end(), '\n' );
+}
+
+template<class T>
+inline
+IOStreamBuffer<T>::~IOStreamBuffer() {
+    // empty
+}
+
+template<class T>
+inline
+bool IOStreamBuffer<T>::open( IOStream *stream ) {
+    //  file still opened!
+    if ( nullptr != m_stream ) {
+        return false;
+    }
+
+    //  Invalid stream pointer
+    if ( nullptr == stream ) {
+        return false;
+    }
+
+    m_stream = stream;
+    m_filesize = m_stream->FileSize();
+    if ( m_filesize == 0 ) {
+        return false;
+    }
+    if ( m_filesize < m_cacheSize ) {
+        m_cacheSize = m_filesize;
+    }
+
+    m_numBlocks = m_filesize / m_cacheSize;
+    if ( ( m_filesize % m_cacheSize ) > 0 ) {
+        m_numBlocks++;
+    }
+
+    return true;
+}
+
+template<class T>
+inline
+bool IOStreamBuffer<T>::close() {
+    if ( nullptr == m_stream ) {
+        return false;
+    }
+
+    // init counters and state vars
+    m_stream    = nullptr;
+    m_filesize  = 0;
+    m_numBlocks = 0;
+    m_blockIdx  = 0;
+    m_cachePos  = 0;
+    m_filePos   = 0;
+
+    return true;
+}
+
+template<class T>
+inline
+size_t IOStreamBuffer<T>::size() const {
+    return m_filesize;
+}
+
+template<class T>
+inline
+size_t IOStreamBuffer<T>::cacheSize() const {
+    return m_cacheSize;
+}
+
+template<class T>
+inline
+bool IOStreamBuffer<T>::readNextBlock() {
+    m_stream->Seek( m_filePos, aiOrigin_SET );
+    size_t readLen = m_stream->Read( &m_cache[ 0 ], sizeof( T ), m_cacheSize );
+    if ( readLen == 0 ) {
+        return false;
+    }
+    if ( readLen < m_cacheSize ) {
+        m_cacheSize = readLen;
+    }
+    m_filePos += m_cacheSize;
+    m_cachePos = 0;
+    m_blockIdx++;
+
+    return true;
+}
+
+template<class T>
+inline
+size_t IOStreamBuffer<T>::getNumBlocks() const {
+    return m_numBlocks;
+}
+
+template<class T>
+inline
+size_t IOStreamBuffer<T>::getCurrentBlockIndex() const {
+    return m_blockIdx;
+}
+
+template<class T>
+inline
+size_t IOStreamBuffer<T>::getFilePos() const {
+    return m_filePos;
+}
+
+template<class T>
+inline
+bool IOStreamBuffer<T>::getNextDataLine( std::vector<T> &buffer, T continuationToken ) {
+    buffer.resize( m_cacheSize );
+    if ( m_cachePos == m_cacheSize || 0 == m_filePos ) {
+        if ( !readNextBlock() ) {
+            return false;
+        }
+    }
+
+    bool continuationFound( false );
+    size_t i = 0;
+    for( ;; ) {
+        if ( continuationToken == m_cache[ m_cachePos ] ) {
+            continuationFound = true;
+            ++m_cachePos;
+        }
+        if ( IsLineEnd( m_cache[ m_cachePos ] ) ) {
+            if ( !continuationFound ) {
+                // the end of the data line
+                break;
+            } else {
+                // skip line end
+                while ( m_cache[m_cachePos] != '\n') {
+                    ++m_cachePos;
+                }
+                ++m_cachePos;
+                continuationFound = false;
+            }
+        }
+
+        buffer[ i ] = m_cache[ m_cachePos ];
+        ++m_cachePos;
+        ++i;
+        if ( m_cachePos >= m_cacheSize ) {
+            if ( !readNextBlock() ) {
+                return false;
+            }
+        }
+    }
+    
+    buffer[ i ] = '\n';
+    ++m_cachePos;
+
+    return true;
+}
+
+static inline
+bool isEndOfCache( size_t pos, size_t cacheSize ) {
+    return ( pos == cacheSize );
+}
+
+template<class T>
+inline
+bool IOStreamBuffer<T>::getNextLine(std::vector<T> &buffer) {
+    buffer.resize(m_cacheSize);
+    if ( isEndOfCache( m_cachePos, m_cacheSize ) || 0 == m_filePos) {
+       if (!readNextBlock()) {
+          return false;
+       }
+      }
+
+    if (IsLineEnd(m_cache[m_cachePos])) {
+        // skip line end
+        while (m_cache[m_cachePos] != '\n') {
+            ++m_cachePos;
+        }
+        ++m_cachePos;
+        if ( isEndOfCache( m_cachePos, m_cacheSize ) ) {
+            if ( !readNextBlock() ) {
+                return false;
+            }
+        }
+    }
+
+    size_t i( 0 );
+    while (!IsLineEnd(m_cache[ m_cachePos ])) {
+        buffer[i] = m_cache[ m_cachePos ];
+        ++m_cachePos;
+        ++i;
+        if (m_cachePos >= m_cacheSize) {
+            if (!readNextBlock()) {
+                return false;
+            }
+        }
+    }
+    buffer[i] = '\n';
+    ++m_cachePos;
+
+    return true;
+}
+
+template<class T>
+inline
+bool IOStreamBuffer<T>::getNextBlock( std::vector<T> &buffer) {
+    // Return the last block-value if getNextLine was used before
+    if ( 0 != m_cachePos ) {      
+        buffer = std::vector<T>( m_cache.begin() + m_cachePos, m_cache.end() );
+        m_cachePos = 0;
+    } else {
+        if ( !readNextBlock() ) {
+            return false;
+        }
+
+        buffer = std::vector<T>(m_cache.begin(), m_cache.end());
+    }
+
+    return true;
+}
+
+} // !ns Assimp
diff --git a/engine/inc/assimp/IOSystem.hpp b/engine/inc/assimp/IOSystem.hpp
new file mode 100644
index 00000000..1530492c
--- /dev/null
+++ b/engine/inc/assimp/IOSystem.hpp
@@ -0,0 +1,360 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file IOSystem.hpp
+ *  @brief File system wrapper for C++. Inherit this class to supply
+ *  custom file handling logic to the Import library.
+*/
+
+#pragma once
+#ifndef AI_IOSYSTEM_H_INC
+#define AI_IOSYSTEM_H_INC
+
+#ifndef __cplusplus
+#   error This header requires C++ to be used. aiFileIO.h is the \
+    corresponding C interface.
+#endif
+
+#include "types.h"
+
+#ifdef _WIN32
+#   include <direct.h>  
+#   include <stdlib.h>  
+#   include <stdio.h>  
+#else
+#   include <sys/stat.h>
+#   include <sys/types.h>
+#   include <unistd.h>
+#endif // _WIN32
+
+#include <vector>
+
+namespace Assimp    {
+
+    class IOStream;
+
+// ---------------------------------------------------------------------------
+/** @brief CPP-API: Interface to the file system.
+ *
+ *  Derive an own implementation from this interface to supply custom file handling
+ *  to the importer library. If you implement this interface, you also want to
+ *  supply a custom implementation for IOStream.
+ *
+ *  @see Importer::SetIOHandler() 
+ */
+class ASSIMP_API IOSystem
+#ifndef SWIG
+    : public Intern::AllocateFromAssimpHeap
+#endif
+{
+public:
+
+    // -------------------------------------------------------------------
+    /** @brief Default constructor.
+     *
+     *  Create an instance of your derived class and assign it to an
+     *  #Assimp::Importer instance by calling Importer::SetIOHandler().
+     */
+    IOSystem();
+
+    // -------------------------------------------------------------------
+    /** @brief Virtual destructor.
+     *
+     *  It is safe to be called from within DLL Assimp, we're constructed
+     *  on Assimp's heap.
+     */
+    virtual ~IOSystem();
+
+
+public:
+
+    // -------------------------------------------------------------------
+    /** @brief For backward compatibility
+     *  @see Exists(const char*)
+     */
+    AI_FORCE_INLINE bool Exists( const std::string& pFile) const;
+
+    // -------------------------------------------------------------------
+    /** @brief Tests for the existence of a file at the given path.
+     *
+     * @param pFile Path to the file
+     * @return true if there is a file with this path, else false.
+     */
+    virtual bool Exists( const char* pFile) const = 0;
+
+    // -------------------------------------------------------------------
+    /** @brief Returns the system specific directory separator
+     *  @return System specific directory separator
+     */
+    virtual char getOsSeparator() const = 0;
+
+    // -------------------------------------------------------------------
+    /** @brief Open a new file with a given path.
+     *
+     *  When the access to the file is finished, call Close() to release
+     *  all associated resources (or the virtual dtor of the IOStream).
+     *
+     *  @param pFile Path to the file
+     *  @param pMode Desired file I/O mode. Required are: "wb", "w", "wt",
+     *         "rb", "r", "rt".
+     *
+     *  @return New IOStream interface allowing the lib to access
+     *         the underlying file.
+     *  @note When implementing this class to provide custom IO handling,
+     *  you probably have to supply an own implementation of IOStream as well.
+     */
+    virtual IOStream* Open(const char* pFile,
+        const char* pMode = "rb") = 0;
+
+    // -------------------------------------------------------------------
+    /** @brief For backward compatibility
+     *  @see Open(const char*, const char*)
+     */
+    inline IOStream* Open(const std::string& pFile,
+        const std::string& pMode = std::string("rb"));
+
+    // -------------------------------------------------------------------
+    /** @brief Closes the given file and releases all resources
+     *    associated with it.
+     *  @param pFile The file instance previously created by Open().
+     */
+    virtual void Close( IOStream* pFile) = 0;
+
+    // -------------------------------------------------------------------
+    /** @brief Compares two paths and check whether the point to
+     *         identical files.
+     *
+     * The dummy implementation of this virtual member performs a
+     * case-insensitive comparison of the given strings. The default IO
+     * system implementation uses OS mechanisms to convert relative into
+     * absolute paths, so the result can be trusted.
+     * @param one First file
+     * @param second Second file
+     * @return true if the paths point to the same file. The file needn't
+     *   be existing, however.
+     */
+    virtual bool ComparePaths (const char* one,
+        const char* second) const;
+
+    // -------------------------------------------------------------------
+    /** @brief For backward compatibility
+     *  @see ComparePaths(const char*, const char*)
+     */
+    inline bool ComparePaths (const std::string& one,
+        const std::string& second) const;
+
+    // -------------------------------------------------------------------
+    /** @brief Pushes a new directory onto the directory stack.
+     *  @param path Path to push onto the stack.
+     *  @return True, when push was successful, false if path is empty.
+     */
+    virtual bool PushDirectory( const std::string &path );
+
+    // -------------------------------------------------------------------
+    /** @brief Returns the top directory from the stack.
+     *  @return The directory on the top of the stack.
+     *          Returns empty when no directory was pushed to the stack.
+     */
+    virtual const std::string &CurrentDirectory() const;
+
+    // -------------------------------------------------------------------
+    /** @brief Returns the number of directories stored on the stack.
+     *  @return The number of directories of the stack.
+     */
+    virtual size_t StackSize() const;
+
+    // -------------------------------------------------------------------
+    /** @brief Pops the top directory from the stack.
+     *  @return True, when a directory was on the stack. False if no
+     *          directory was on the stack.
+     */
+    virtual bool PopDirectory();
+
+    // -------------------------------------------------------------------
+    /** @brief CReates an new directory at the given path.
+     *  @param  path    [in] The path to create.
+     *  @return True, when a directory was created. False if the directory
+     *           cannot be created.
+     */
+    virtual bool CreateDirectory( const std::string &path );
+
+    // -------------------------------------------------------------------
+    /** @brief Will change the current directory to the given path.
+     *  @param path     [in] The path to change to.
+     *  @return True, when the directory has changed successfully.
+     */
+    virtual bool ChangeDirectory( const std::string &path );
+
+    virtual bool DeleteFile( const std::string &file );
+
+private:
+    std::vector<std::string> m_pathStack;
+};
+
+// ----------------------------------------------------------------------------
+AI_FORCE_INLINE
+IOSystem::IOSystem()
+: m_pathStack() {
+    // empty
+}
+
+// ----------------------------------------------------------------------------
+AI_FORCE_INLINE
+IOSystem::~IOSystem() {
+    // empty
+}
+
+// ----------------------------------------------------------------------------
+// For compatibility, the interface of some functions taking a std::string was
+// changed to const char* to avoid crashes between binary incompatible STL
+// versions. This code her is inlined,  so it shouldn't cause any problems.
+// ----------------------------------------------------------------------------
+
+// ----------------------------------------------------------------------------
+AI_FORCE_INLINE
+IOStream* IOSystem::Open(const std::string& pFile, const std::string& pMode) {
+    // NOTE:
+    // For compatibility, interface was changed to const char* to
+    // avoid crashes between binary incompatible STL versions
+    return Open(pFile.c_str(),pMode.c_str());
+}
+
+// ----------------------------------------------------------------------------
+AI_FORCE_INLINE
+bool IOSystem::Exists( const std::string& pFile) const {
+    // NOTE:
+    // For compatibility, interface was changed to const char* to
+    // avoid crashes between binary incompatible STL versions
+    return Exists(pFile.c_str());
+}
+
+// ----------------------------------------------------------------------------
+AI_FORCE_INLINE
+bool IOSystem::ComparePaths (const std::string& one, const std::string& second) const {
+    // NOTE:
+    // For compatibility, interface was changed to const char* to
+    // avoid crashes between binary incompatible STL versions
+    return ComparePaths(one.c_str(),second.c_str());
+}
+
+// ----------------------------------------------------------------------------
+AI_FORCE_INLINE
+bool IOSystem::PushDirectory( const std::string &path ) {
+    if ( path.empty() ) {
+        return false;
+    }
+
+    m_pathStack.push_back( path );
+
+    return true;
+}
+
+// ----------------------------------------------------------------------------
+AI_FORCE_INLINE
+const std::string &IOSystem::CurrentDirectory() const {
+    if ( m_pathStack.empty() ) {
+        static const std::string Dummy("");
+        return Dummy;
+    }
+    return m_pathStack[ m_pathStack.size()-1 ];
+}
+
+// ----------------------------------------------------------------------------
+AI_FORCE_INLINE
+size_t IOSystem::StackSize() const {
+    return m_pathStack.size();
+}
+
+// ----------------------------------------------------------------------------
+AI_FORCE_INLINE
+bool IOSystem::PopDirectory() {
+    if ( m_pathStack.empty() ) {
+        return false;
+    }
+
+    m_pathStack.pop_back();
+
+    return true;
+}
+
+// ----------------------------------------------------------------------------
+AI_FORCE_INLINE
+bool IOSystem::CreateDirectory( const std::string &path ) {
+    if ( path.empty() ) {
+        return false;
+    }
+
+#ifdef _WIN32
+    return 0 != ::_mkdir( path.c_str() );
+#else
+    return 0 != ::mkdir( path.c_str(), 0777 );
+#endif // _WIN32
+}
+
+// ----------------------------------------------------------------------------
+AI_FORCE_INLINE
+bool IOSystem::ChangeDirectory( const std::string &path ) {
+    if ( path.empty() ) {
+        return false;
+    }
+
+#ifdef _WIN32
+    return 0 != ::_chdir( path.c_str() );
+#else
+    return 0 != ::chdir( path.c_str() );
+#endif // _WIN32
+}
+
+
+// ----------------------------------------------------------------------------
+AI_FORCE_INLINE
+bool IOSystem::DeleteFile( const std::string &file ) {
+    if ( file.empty() ) {
+        return false;
+    }
+    const int retCode( ::remove( file.c_str() ) );
+    return ( 0 == retCode );
+}
+} //!ns Assimp
+
+#endif //AI_IOSYSTEM_H_INC
diff --git a/engine/inc/assimp/Importer.hpp b/engine/inc/assimp/Importer.hpp
new file mode 100644
index 00000000..7445c979
--- /dev/null
+++ b/engine/inc/assimp/Importer.hpp
@@ -0,0 +1,659 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file  Importer.hpp
+ *  @brief Defines the C++-API to the Open Asset Import Library.
+ */
+#pragma once
+#ifndef AI_ASSIMP_HPP_INC
+#define AI_ASSIMP_HPP_INC
+
+#ifndef __cplusplus
+#   error This header requires C++ to be used. Use assimp.h for plain C.
+#endif // __cplusplus
+
+// Public ASSIMP data structures
+#include <assimp/types.h>
+
+namespace Assimp    {
+    // =======================================================================
+    // Public interface to Assimp
+    class Importer;
+    class IOStream;
+    class IOSystem;
+    class ProgressHandler;
+
+    // =======================================================================
+    // Plugin development
+    //
+    // Include the following headers for the declarations:
+    // BaseImporter.h
+    // BaseProcess.h
+    class BaseImporter;
+    class BaseProcess;
+    class SharedPostProcessInfo;
+    class BatchLoader;
+
+    // =======================================================================
+    // Holy stuff, only for members of the high council of the Jedi.
+    class ImporterPimpl;
+} //! namespace Assimp
+
+#define AI_PROPERTY_WAS_NOT_EXISTING 0xffffffff
+
+struct aiScene;
+
+// importerdesc.h
+struct aiImporterDesc;
+
+/** @namespace Assimp Assimp's CPP-API and all internal APIs */
+namespace Assimp    {
+
+// ----------------------------------------------------------------------------------
+/** CPP-API: The Importer class forms an C++ interface to the functionality of the
+*   Open Asset Import Library.
+*
+* Create an object of this class and call ReadFile() to import a file.
+* If the import succeeds, the function returns a pointer to the imported data.
+* The data remains property of the object, it is intended to be accessed
+* read-only. The imported data will be destroyed along with the Importer
+* object. If the import fails, ReadFile() returns a NULL pointer. In this
+* case you can retrieve a human-readable error description be calling
+* GetErrorString(). You can call ReadFile() multiple times with a single Importer
+* instance. Actually, constructing Importer objects involves quite many
+* allocations and may take some time, so it's better to reuse them as often as
+* possible.
+*
+* If you need the Importer to do custom file handling to access the files,
+* implement IOSystem and IOStream and supply an instance of your custom
+* IOSystem implementation by calling SetIOHandler() before calling ReadFile().
+* If you do not assign a custion IO handler, a default handler using the
+* standard C++ IO logic will be used.
+*
+* @note One Importer instance is not thread-safe. If you use multiple
+* threads for loading, each thread should maintain its own Importer instance.
+*/
+class ASSIMP_API Importer   {
+public:
+    /**
+     *  @brief The upper limit for hints.
+     */
+    static const unsigned int MaxLenHint = 200;
+
+public:
+
+    // -------------------------------------------------------------------
+    /** Constructor. Creates an empty importer object.
+     *
+     * Call ReadFile() to start the import process. The configuration
+     * property table is initially empty.
+     */
+    Importer();
+
+    // -------------------------------------------------------------------
+    /** Copy constructor.
+     *
+     * This copies the configuration properties of another Importer.
+     * If this Importer owns a scene it won't be copied.
+     * Call ReadFile() to start the import process.
+     */
+    Importer(const Importer& other)=delete;
+
+    // -------------------------------------------------------------------
+    /** Assignment operator has been deleted
+     */
+    Importer &operator=(const Importer &) = delete;
+
+    // -------------------------------------------------------------------
+    /** Destructor. The object kept ownership of the imported data,
+     * which now will be destroyed along with the object.
+     */
+    ~Importer();
+
+
+    // -------------------------------------------------------------------
+    /** Registers a new loader.
+     *
+     * @param pImp Importer to be added. The Importer instance takes
+     *   ownership of the pointer, so it will be automatically deleted
+     *   with the Importer instance.
+     * @return AI_SUCCESS if the loader has been added. The registration
+     *   fails if there is already a loader for a specific file extension.
+     */
+    aiReturn RegisterLoader(BaseImporter* pImp);
+
+    // -------------------------------------------------------------------
+    /** Unregisters a loader.
+     *
+     * @param pImp Importer to be unregistered.
+     * @return AI_SUCCESS if the loader has been removed. The function
+     *   fails if the loader is currently in use (this could happen
+     *   if the #Importer instance is used by more than one thread) or
+     *   if it has not yet been registered.
+     */
+    aiReturn UnregisterLoader(BaseImporter* pImp);
+
+    // -------------------------------------------------------------------
+    /** Registers a new post-process step.
+     *
+     * At the moment, there's a small limitation: new post processing
+     * steps are added to end of the list, or in other words, executed
+     * last, after all built-in steps.
+     * @param pImp Post-process step to be added. The Importer instance
+     *   takes ownership of the pointer, so it will be automatically
+     *   deleted with the Importer instance.
+     * @return AI_SUCCESS if the step has been added correctly.
+     */
+    aiReturn RegisterPPStep(BaseProcess* pImp);
+
+    // -------------------------------------------------------------------
+    /** Unregisters a post-process step.
+     *
+     * @param pImp Step to be unregistered.
+     * @return AI_SUCCESS if the step has been removed. The function
+     *   fails if the step is currently in use (this could happen
+     *   if the #Importer instance is used by more than one thread) or
+     *   if it has not yet been registered.
+     */
+    aiReturn UnregisterPPStep(BaseProcess* pImp);
+
+    // -------------------------------------------------------------------
+    /** Set an integer configuration property.
+     * @param szName Name of the property. All supported properties
+     *   are defined in the aiConfig.g header (all constants share the
+     *   prefix AI_CONFIG_XXX and are simple strings).
+     * @param iValue New value of the property
+     * @return true if the property was set before. The new value replaces
+     *   the previous value in this case.
+     * @note Property of different types (float, int, string ..) are kept
+     *   on different stacks, so calling SetPropertyInteger() for a
+     *   floating-point property has no effect - the loader will call
+     *   GetPropertyFloat() to read the property, but it won't be there.
+     */
+    bool SetPropertyInteger(const char* szName, int iValue);
+
+    // -------------------------------------------------------------------
+    /** Set a boolean configuration property. Boolean properties
+     *  are stored on the integer stack internally so it's possible
+     *  to set them via #SetPropertyBool and query them with
+     *  #GetPropertyBool and vice versa.
+     * @see SetPropertyInteger()
+     */
+    bool SetPropertyBool(const char* szName, bool value)    {
+        return SetPropertyInteger(szName,value);
+    }
+
+    // -------------------------------------------------------------------
+    /** Set a floating-point configuration property.
+     * @see SetPropertyInteger()
+     */
+    bool SetPropertyFloat(const char* szName, ai_real fValue);
+
+    // -------------------------------------------------------------------
+    /** Set a string configuration property.
+     * @see SetPropertyInteger()
+     */
+    bool SetPropertyString(const char* szName, const std::string& sValue);
+
+    // -------------------------------------------------------------------
+    /** Set a matrix configuration property.
+     * @see SetPropertyInteger()
+     */
+    bool SetPropertyMatrix(const char* szName, const aiMatrix4x4& sValue);
+
+    // -------------------------------------------------------------------
+    /** Get a configuration property.
+     * @param szName Name of the property. All supported properties
+     *   are defined in the aiConfig.g header (all constants share the
+     *   prefix AI_CONFIG_XXX).
+     * @param iErrorReturn Value that is returned if the property
+     *   is not found.
+     * @return Current value of the property
+     * @note Property of different types (float, int, string ..) are kept
+     *   on different lists, so calling SetPropertyInteger() for a
+     *   floating-point property has no effect - the loader will call
+     *   GetPropertyFloat() to read the property, but it won't be there.
+     */
+    int GetPropertyInteger(const char* szName,
+        int iErrorReturn = 0xffffffff) const;
+
+    // -------------------------------------------------------------------
+    /** Get a boolean configuration property. Boolean properties
+     *  are stored on the integer stack internally so it's possible
+     *  to set them via #SetPropertyBool and query them with
+     *  #GetPropertyBool and vice versa.
+     * @see GetPropertyInteger()
+     */
+    bool GetPropertyBool(const char* szName, bool bErrorReturn = false) const {
+        return GetPropertyInteger(szName,bErrorReturn)!=0;
+    }
+
+    // -------------------------------------------------------------------
+    /** Get a floating-point configuration property
+     * @see GetPropertyInteger()
+     */
+    ai_real GetPropertyFloat(const char* szName,
+        ai_real fErrorReturn = 10e10) const;
+
+    // -------------------------------------------------------------------
+    /** Get a string configuration property
+     *
+     *  The return value remains valid until the property is modified.
+     * @see GetPropertyInteger()
+     */
+    const std::string GetPropertyString(const char* szName,
+        const std::string& sErrorReturn = "") const;
+
+    // -------------------------------------------------------------------
+    /** Get a matrix configuration property
+     *
+     *  The return value remains valid until the property is modified.
+     * @see GetPropertyInteger()
+     */
+    const aiMatrix4x4 GetPropertyMatrix(const char* szName,
+        const aiMatrix4x4& sErrorReturn = aiMatrix4x4()) const;
+
+    // -------------------------------------------------------------------
+    /** Supplies a custom IO handler to the importer to use to open and
+     * access files. If you need the importer to use custom IO logic to
+     * access the files, you need to provide a custom implementation of
+     * IOSystem and IOFile to the importer. Then create an instance of
+     * your custom IOSystem implementation and supply it by this function.
+     *
+     * The Importer takes ownership of the object and will destroy it
+     * afterwards. The previously assigned handler will be deleted.
+     * Pass NULL to take again ownership of your IOSystem and reset Assimp
+     * to use its default implementation.
+     *
+     * @param pIOHandler The IO handler to be used in all file accesses
+     *   of the Importer.
+     */
+    void SetIOHandler( IOSystem* pIOHandler);
+
+    // -------------------------------------------------------------------
+    /** Retrieves the IO handler that is currently set.
+     * You can use #IsDefaultIOHandler() to check whether the returned
+     * interface is the default IO handler provided by ASSIMP. The default
+     * handler is active as long the application doesn't supply its own
+     * custom IO handler via #SetIOHandler().
+     * @return A valid IOSystem interface, never NULL.
+     */
+    IOSystem* GetIOHandler() const;
+
+    // -------------------------------------------------------------------
+    /** Checks whether a default IO handler is active
+     * A default handler is active as long the application doesn't
+     * supply its own custom IO handler via #SetIOHandler().
+     * @return true by default
+     */
+    bool IsDefaultIOHandler() const;
+
+    // -------------------------------------------------------------------
+    /** Supplies a custom progress handler to the importer. This
+     *  interface exposes a #Update() callback, which is called
+     *  more or less periodically (please don't sue us if it
+     *  isn't as periodically as you'd like it to have ...).
+     *  This can be used to implement progress bars and loading
+     *  timeouts.
+     *  @param pHandler Progress callback interface. Pass NULL to
+     *    disable progress reporting.
+     *  @note Progress handlers can be used to abort the loading
+     *    at almost any time.*/
+    void SetProgressHandler ( ProgressHandler* pHandler );
+
+    // -------------------------------------------------------------------
+    /** Retrieves the progress handler that is currently set.
+     * You can use #IsDefaultProgressHandler() to check whether the returned
+     * interface is the default handler provided by ASSIMP. The default
+     * handler is active as long the application doesn't supply its own
+     * custom handler via #SetProgressHandler().
+     * @return A valid ProgressHandler interface, never NULL.
+     */
+    ProgressHandler* GetProgressHandler() const;
+
+    // -------------------------------------------------------------------
+    /** Checks whether a default progress handler is active
+     * A default handler is active as long the application doesn't
+     * supply its own custom progress handler via #SetProgressHandler().
+     * @return true by default
+     */
+    bool IsDefaultProgressHandler() const;
+
+    // -------------------------------------------------------------------
+    /** @brief Check whether a given set of post-processing flags
+     *  is supported.
+     *
+     *  Some flags are mutually exclusive, others are probably
+     *  not available because your excluded them from your
+     *  Assimp builds. Calling this function is recommended if
+     *  you're unsure.
+     *
+     *  @param pFlags Bitwise combination of the aiPostProcess flags.
+     *  @return true if this flag combination is fine.
+     */
+    bool ValidateFlags(unsigned int pFlags) const;
+
+    // -------------------------------------------------------------------
+    /** Reads the given file and returns its contents if successful.
+     *
+     * If the call succeeds, the contents of the file are returned as a
+     * pointer to an aiScene object. The returned data is intended to be
+     * read-only, the importer object keeps ownership of the data and will
+     * destroy it upon destruction. If the import fails, NULL is returned.
+     * A human-readable error description can be retrieved by calling
+     * GetErrorString(). The previous scene will be deleted during this call.
+     * @param pFile Path and filename to the file to be imported.
+     * @param pFlags Optional post processing steps to be executed after
+     *   a successful import. Provide a bitwise combination of the
+     *   #aiPostProcessSteps flags. If you wish to inspect the imported
+     *   scene first in order to fine-tune your post-processing setup,
+     *   consider to use #ApplyPostProcessing().
+     * @return A pointer to the imported data, NULL if the import failed.
+     *   The pointer to the scene remains in possession of the Importer
+     *   instance. Use GetOrphanedScene() to take ownership of it.
+     *
+     * @note Assimp is able to determine the file format of a file
+     * automatically.
+     */
+    const aiScene* ReadFile(
+        const char* pFile,
+        unsigned int pFlags);
+
+    // -------------------------------------------------------------------
+    /** Reads the given file from a memory buffer and returns its
+     *  contents if successful.
+     *
+     * If the call succeeds, the contents of the file are returned as a
+     * pointer to an aiScene object. The returned data is intended to be
+     * read-only, the importer object keeps ownership of the data and will
+     * destroy it upon destruction. If the import fails, NULL is returned.
+     * A human-readable error description can be retrieved by calling
+     * GetErrorString(). The previous scene will be deleted during this call.
+     * Calling this method doesn't affect the active IOSystem.
+     * @param pBuffer Pointer to the file data
+     * @param pLength Length of pBuffer, in bytes
+     * @param pFlags Optional post processing steps to be executed after
+     *   a successful import. Provide a bitwise combination of the
+     *   #aiPostProcessSteps flags. If you wish to inspect the imported
+     *   scene first in order to fine-tune your post-processing setup,
+     *   consider to use #ApplyPostProcessing().
+     * @param pHint An additional hint to the library. If this is a non
+     *   empty string, the library looks for a loader to support
+     *   the file extension specified by pHint and passes the file to
+     *   the first matching loader. If this loader is unable to completely
+     *   the request, the library continues and tries to determine the
+     *   file format on its own, a task that may or may not be successful.
+     *   Check the return value, and you'll know ...
+     * @return A pointer to the imported data, NULL if the import failed.
+     *   The pointer to the scene remains in possession of the Importer
+     *   instance. Use GetOrphanedScene() to take ownership of it.
+     *
+     * @note This is a straightforward way to decode models from memory
+     * buffers, but it doesn't handle model formats that spread their
+     * data across multiple files or even directories. Examples include
+     * OBJ or MD3, which outsource parts of their material info into
+     * external scripts. If you need full functionality, provide
+     * a custom IOSystem to make Assimp find these files and use
+     * the regular ReadFile() API.
+     */
+    const aiScene* ReadFileFromMemory(
+        const void* pBuffer,
+        size_t pLength,
+        unsigned int pFlags,
+        const char* pHint = "");
+
+    // -------------------------------------------------------------------
+    /** Apply post-processing to an already-imported scene.
+     *
+     *  This is strictly equivalent to calling #ReadFile() with the same
+     *  flags. However, you can use this separate function to inspect
+     *  the imported scene first to fine-tune your post-processing setup.
+     *  @param pFlags Provide a bitwise combination of the
+     *   #aiPostProcessSteps flags.
+     *  @return A pointer to the post-processed data. This is still the
+     *   same as the pointer returned by #ReadFile(). However, if
+     *   post-processing fails, the scene could now be NULL.
+     *   That's quite a rare case, post processing steps are not really
+     *   designed to 'fail'. To be exact, the #aiProcess_ValidateDS
+     *   flag is currently the only post processing step which can actually
+     *   cause the scene to be reset to NULL.
+     *
+     *  @note The method does nothing if no scene is currently bound
+     *    to the #Importer instance.  */
+    const aiScene* ApplyPostProcessing(unsigned int pFlags);
+
+    const aiScene* ApplyCustomizedPostProcessing( BaseProcess *rootProcess, bool requestValidation );
+
+    // -------------------------------------------------------------------
+    /** @brief Reads the given file and returns its contents if successful.
+     *
+     * This function is provided for backward compatibility.
+     * See the const char* version for detailed docs.
+     * @see ReadFile(const char*, pFlags)  */
+    const aiScene* ReadFile(
+        const std::string& pFile,
+        unsigned int pFlags);
+
+    // -------------------------------------------------------------------
+    /** Frees the current scene.
+     *
+     *  The function does nothing if no scene has previously been
+     *  read via ReadFile(). FreeScene() is called automatically by the
+     *  destructor and ReadFile() itself.  */
+    void FreeScene( );
+
+    // -------------------------------------------------------------------
+    /** Returns an error description of an error that occurred in ReadFile().
+     *
+     * Returns an empty string if no error occurred.
+     * @return A description of the last error, an empty string if no
+     *   error occurred. The string is never NULL.
+     *
+     * @note The returned function remains valid until one of the
+     * following methods is called: #ReadFile(), #FreeScene(). */
+    const char* GetErrorString() const;
+
+    // -------------------------------------------------------------------
+    /** Returns the scene loaded by the last successful call to ReadFile()
+     *
+     * @return Current scene or NULL if there is currently no scene loaded */
+    const aiScene* GetScene() const;
+
+    // -------------------------------------------------------------------
+    /** Returns the scene loaded by the last successful call to ReadFile()
+     *  and releases the scene from the ownership of the Importer
+     *  instance. The application is now responsible for deleting the
+     *  scene. Any further calls to GetScene() or GetOrphanedScene()
+     *  will return NULL - until a new scene has been loaded via ReadFile().
+     *
+     * @return Current scene or NULL if there is currently no scene loaded
+     * @note Use this method with maximal caution, and only if you have to.
+     *   By design, aiScene's are exclusively maintained, allocated and
+     *   deallocated by Assimp and no one else. The reasoning behind this
+     *   is the golden rule that deallocations should always be done
+     *   by the module that did the original allocation because heaps
+     *   are not necessarily shared. GetOrphanedScene() enforces you
+     *   to delete the returned scene by yourself, but this will only
+     *   be fine if and only if you're using the same heap as assimp.
+     *   On Windows, it's typically fine provided everything is linked
+     *   against the multithreaded-dll version of the runtime library.
+     *   It will work as well for static linkage with Assimp.*/
+    aiScene* GetOrphanedScene();
+
+    // -------------------------------------------------------------------
+    /** Returns whether a given file extension is supported by ASSIMP.
+     *
+     * @param szExtension Extension to be checked.
+     *   Must include a trailing dot '.'. Example: ".3ds", ".md3".
+     *   Cases-insensitive.
+     * @return true if the extension is supported, false otherwise */
+    bool IsExtensionSupported(const char* szExtension) const;
+
+    // -------------------------------------------------------------------
+    /** @brief Returns whether a given file extension is supported by ASSIMP.
+     *
+     * This function is provided for backward compatibility.
+     * See the const char* version for detailed and up-to-date docs.
+     * @see IsExtensionSupported(const char*) */
+    inline bool IsExtensionSupported(const std::string& szExtension) const;
+
+    // -------------------------------------------------------------------
+    /** Get a full list of all file extensions supported by ASSIMP.
+     *
+     * If a file extension is contained in the list this does of course not
+     * mean that ASSIMP is able to load all files with this extension ---
+     * it simply means there is an importer loaded which claims to handle
+     * files with this file extension.
+     * @param szOut String to receive the extension list.
+     *   Format of the list: "*.3ds;*.obj;*.dae". This is useful for
+     *   use with the WinAPI call GetOpenFileName(Ex). */
+    void GetExtensionList(aiString& szOut) const;
+
+    // -------------------------------------------------------------------
+    /** @brief Get a full list of all file extensions supported by ASSIMP.
+     *
+     * This function is provided for backward compatibility.
+     * See the aiString version for detailed and up-to-date docs.
+     * @see GetExtensionList(aiString&)*/
+    inline void GetExtensionList(std::string& szOut) const;
+
+    // -------------------------------------------------------------------
+    /** Get the number of importers currently registered with Assimp. */
+    size_t GetImporterCount() const;
+
+    // -------------------------------------------------------------------
+    /** Get meta data for the importer corresponding to a specific index..
+    *
+    *  For the declaration of #aiImporterDesc, include <assimp/importerdesc.h>.
+    *  @param index Index to query, must be within [0,GetImporterCount())
+    *  @return Importer meta data structure, NULL if the index does not
+    *     exist or if the importer doesn't offer meta information (
+    *     importers may do this at the cost of being hated by their peers).*/
+    const aiImporterDesc* GetImporterInfo(size_t index) const;
+
+    // -------------------------------------------------------------------
+    /** Find the importer corresponding to a specific index.
+    *
+    *  @param index Index to query, must be within [0,GetImporterCount())
+    *  @return Importer instance. NULL if the index does not
+    *     exist. */
+    BaseImporter* GetImporter(size_t index) const;
+
+    // -------------------------------------------------------------------
+    /** Find the importer corresponding to a specific file extension.
+    *
+    *  This is quite similar to #IsExtensionSupported except a
+    *  BaseImporter instance is returned.
+    *  @param szExtension Extension to check for. The following formats
+    *    are recognized (BAH being the file extension): "BAH" (comparison
+    *    is case-insensitive), ".bah", "*.bah" (wild card and dot
+    *    characters at the beginning of the extension are skipped).
+    *  @return NULL if no importer is found*/
+    BaseImporter* GetImporter (const char* szExtension) const;
+
+    // -------------------------------------------------------------------
+    /** Find the importer index corresponding to a specific file extension.
+    *
+    *  @param szExtension Extension to check for. The following formats
+    *    are recognized (BAH being the file extension): "BAH" (comparison
+    *    is case-insensitive), ".bah", "*.bah" (wild card and dot
+    *    characters at the beginning of the extension are skipped).
+    *  @return (size_t)-1 if no importer is found */
+    size_t GetImporterIndex (const char* szExtension) const;
+
+    // -------------------------------------------------------------------
+    /** Returns the storage allocated by ASSIMP to hold the scene data
+     * in memory.
+     *
+     * This refers to the currently loaded file, see #ReadFile().
+     * @param in Data structure to be filled.
+     * @note The returned memory statistics refer to the actual
+     *   size of the use data of the aiScene. Heap-related overhead
+     *   is (naturally) not included.*/
+    void GetMemoryRequirements(aiMemoryInfo& in) const;
+
+    // -------------------------------------------------------------------
+    /** Enables "extra verbose" mode.
+     *
+     * 'Extra verbose' means the data structure is validated after *every*
+     * single post processing step to make sure everyone modifies the data
+     * structure in a well-defined manner. This is a debug feature and not
+     * intended for use in production environments. */
+    void SetExtraVerbose(bool bDo);
+
+    // -------------------------------------------------------------------
+    /** Private, do not use. */
+    ImporterPimpl* Pimpl() { return pimpl; }
+    const ImporterPimpl* Pimpl() const { return pimpl; }
+
+protected:
+
+    // Just because we don't want you to know how we're hacking around.
+    ImporterPimpl* pimpl;
+}; //! class Importer
+
+
+// ----------------------------------------------------------------------------
+// For compatibility, the interface of some functions taking a std::string was
+// changed to const char* to avoid crashes between binary incompatible STL
+// versions. This code her is inlined,  so it shouldn't cause any problems.
+// ----------------------------------------------------------------------------
+
+// ----------------------------------------------------------------------------
+AI_FORCE_INLINE const aiScene* Importer::ReadFile( const std::string& pFile,unsigned int pFlags){
+    return ReadFile(pFile.c_str(),pFlags);
+}
+// ----------------------------------------------------------------------------
+AI_FORCE_INLINE void Importer::GetExtensionList(std::string& szOut) const   {
+    aiString s;
+    GetExtensionList(s);
+    szOut = s.data;
+}
+// ----------------------------------------------------------------------------
+AI_FORCE_INLINE bool Importer::IsExtensionSupported(const std::string& szExtension) const   {
+    return IsExtensionSupported(szExtension.c_str());
+}
+
+} // !namespace Assimp
+
+#endif // AI_ASSIMP_HPP_INC
diff --git a/engine/inc/assimp/LineSplitter.h b/engine/inc/assimp/LineSplitter.h
new file mode 100644
index 00000000..e5ac98d8
--- /dev/null
+++ b/engine/inc/assimp/LineSplitter.h
@@ -0,0 +1,244 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file  LineSplitter.h
+ *  @brief LineSplitter, a helper class to iterate through all lines
+ *    of a file easily. Works with StreamReader.
+ */
+#ifndef INCLUDED_LINE_SPLITTER_H
+#define INCLUDED_LINE_SPLITTER_H
+
+#include <stdexcept>
+
+#include "StreamReader.h"
+#include "ParsingUtils.h"
+
+namespace Assimp {
+
+// ------------------------------------------------------------------------------------------------
+/** Usage:
+@code
+for(LineSplitter splitter(stream);splitter;++splitter) {
+
+    if (*splitter == "hi!") {
+       ...
+    }
+    else if (splitter->substr(0,5) == "hello") {
+       ...
+       // access the third token in the line (tokens are space-separated)
+       if (strtol(splitter[2]) > 5) { .. }
+    }
+
+    std::cout << "Current line is: " << splitter.get_index() << std::endl;
+}
+@endcode
+*/
+// ------------------------------------------------------------------------------------------------
+class LineSplitter {
+public:
+    typedef size_t line_idx;
+
+    // -----------------------------------------
+    /** construct from existing stream reader
+    note: trim is *always* assumed true if skyp_empty_lines==true
+    */
+    LineSplitter(StreamReaderLE& stream, bool skip_empty_lines = true, bool trim = true)
+    : idx( 0 )
+    , stream(stream)
+    , swallow()
+    , skip_empty_lines(skip_empty_lines)
+    , trim(trim) {
+        cur.reserve(1024);
+        operator++();
+
+        idx = 0;
+    }
+
+    ~LineSplitter() {
+        // empty
+    }
+
+public:
+
+    // -----------------------------------------
+    /** pseudo-iterator increment */
+    LineSplitter& operator++() {
+        if(swallow) {
+            swallow = false;
+            return *this;
+        }
+        if (!*this) {
+            throw std::logic_error("End of file, no more lines to be retrieved.");
+        }
+        char s;
+        cur.clear();
+        while(stream.GetRemainingSize() && (s = stream.GetI1(),1)) {
+            if (s == '\n' || s == '\r') {
+                if (skip_empty_lines) {
+                    while (stream.GetRemainingSize() && ((s = stream.GetI1()) == ' ' || s == '\r' || s == '\n'));
+                    if (stream.GetRemainingSize()) {
+                        stream.IncPtr(-1);
+                    }
+                }
+                else {
+                    // skip both potential line terminators but don't read past this line.
+                    if (stream.GetRemainingSize() && (s == '\r' && stream.GetI1() != '\n')) {
+                        stream.IncPtr(-1);
+                    }
+                    if (trim) {
+                        while (stream.GetRemainingSize() && ((s = stream.GetI1()) == ' ' || s == '\t'));
+                        if (stream.GetRemainingSize()) {
+                            stream.IncPtr(-1);
+                        }
+                    }
+                }
+                break;
+            }
+            cur += s;
+        }
+        ++idx;
+        return *this;
+    }
+
+    // -----------------------------------------
+    LineSplitter& operator++(int) {
+        return ++(*this);
+    }
+
+    // -----------------------------------------
+    /** get a pointer to the beginning of a particular token */
+    const char* operator[] (size_t idx) const {
+        const char* s = operator->()->c_str();
+
+        SkipSpaces(&s);
+        for(size_t i = 0; i < idx; ++i) {
+
+            for(;!IsSpace(*s); ++s) {
+                if(IsLineEnd(*s)) {
+                    throw std::range_error("Token index out of range, EOL reached");
+                }
+            }
+            SkipSpaces(&s);
+        }
+        return s;
+    }
+
+    // -----------------------------------------
+    /** extract the start positions of N tokens from the current line*/
+    template <size_t N>
+    void get_tokens(const char* (&tokens)[N]) const {
+        const char* s = operator->()->c_str();
+
+        SkipSpaces(&s);
+        for(size_t i = 0; i < N; ++i) {
+            if(IsLineEnd(*s)) {
+
+                throw std::range_error("Token count out of range, EOL reached");
+
+            }
+            tokens[i] = s;
+
+            for(;*s && !IsSpace(*s); ++s);
+            SkipSpaces(&s);
+        }
+    }
+
+    // -----------------------------------------
+    /** member access */
+    const std::string* operator -> () const {
+        return &cur;
+    }
+
+    std::string operator* () const {
+        return cur;
+    }
+
+    // -----------------------------------------
+    /** boolean context */
+    operator bool() const {
+        return stream.GetRemainingSize()>0;
+    }
+
+    // -----------------------------------------
+    /** line indices are zero-based, empty lines are included */
+    operator line_idx() const {
+        return idx;
+    }
+
+    line_idx get_index() const {
+        return idx;
+    }
+
+    // -----------------------------------------
+    /** access the underlying stream object */
+    StreamReaderLE& get_stream() {
+        return stream;
+    }
+
+    // -----------------------------------------
+    /** !strcmp((*this)->substr(0,strlen(check)),check) */
+    bool match_start(const char* check) {
+        const size_t len = strlen(check);
+
+        return len <= cur.length() && std::equal(check,check+len,cur.begin());
+    }
+
+
+    // -----------------------------------------
+    /** swallow the next call to ++, return the previous value. */
+    void swallow_next_increment() {
+        swallow = true;
+    }
+
+private:
+    LineSplitter( const LineSplitter & );
+    LineSplitter &operator = ( const LineSplitter & );
+
+private:
+    line_idx idx;
+    std::string cur;
+    StreamReaderLE& stream;
+    bool swallow, skip_empty_lines, trim;
+};
+
+}
+#endif // INCLUDED_LINE_SPLITTER_H
diff --git a/engine/inc/assimp/LogAux.h b/engine/inc/assimp/LogAux.h
new file mode 100644
index 00000000..b8aa2e2d
--- /dev/null
+++ b/engine/inc/assimp/LogAux.h
@@ -0,0 +1,131 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file  LogAux.h
+ *  @brief Common logging usage patterns for importer implementations
+ */
+#ifndef INCLUDED_AI_LOGAUX_H
+#define INCLUDED_AI_LOGAUX_H
+
+#include <assimp/TinyFormatter.h>
+#include <assimp/Exceptional.h>
+#include <assimp/DefaultLogger.hpp>
+
+namespace Assimp {
+
+template<class TDeriving>
+class LogFunctions {
+public:
+    // ------------------------------------------------------------------------------------------------
+    static void ThrowException(const std::string& msg)
+    {
+        throw DeadlyImportError(Prefix()+msg);
+    }
+
+    // ------------------------------------------------------------------------------------------------
+    static void LogWarn(const Formatter::format& message)   {
+        if (!DefaultLogger::isNullLogger()) {
+            DefaultLogger::get()->warn(Prefix()+(std::string)message);
+        }
+    }
+
+    // ------------------------------------------------------------------------------------------------
+    static void LogError(const Formatter::format& message)  {
+        if (!DefaultLogger::isNullLogger()) {
+            DefaultLogger::get()->error(Prefix()+(std::string)message);
+        }
+    }
+
+    // ------------------------------------------------------------------------------------------------
+    static void LogInfo(const Formatter::format& message)   {
+        if (!DefaultLogger::isNullLogger()) {
+            DefaultLogger::get()->info(Prefix()+(std::string)message);
+        }
+    }
+
+    // ------------------------------------------------------------------------------------------------
+    static void LogDebug(const Formatter::format& message)  {
+        if (!DefaultLogger::isNullLogger()) {
+            DefaultLogger::get()->debug(Prefix()+(std::string)message);
+        }
+    }
+
+    // https://sourceforge.net/tracker/?func=detail&atid=1067632&aid=3358562&group_id=226462
+#if !defined(__GNUC__) || !defined(__APPLE__) || __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
+
+    // ------------------------------------------------------------------------------------------------
+    static void LogWarn  (const char* message) {
+        if (!DefaultLogger::isNullLogger()) {
+            LogWarn(Formatter::format(message));
+        }
+    }
+
+    // ------------------------------------------------------------------------------------------------
+    static void LogError  (const char* message) {
+        if (!DefaultLogger::isNullLogger()) {
+            LogError(Formatter::format(message));
+        }
+    }
+
+    // ------------------------------------------------------------------------------------------------
+    static void LogInfo  (const char* message) {
+        if (!DefaultLogger::isNullLogger()) {
+            LogInfo(Formatter::format(message));
+        }
+    }
+
+    // ------------------------------------------------------------------------------------------------
+    static void LogDebug  (const char* message) {
+        if (!DefaultLogger::isNullLogger()) {
+            LogDebug(Formatter::format(message));
+        }
+    }
+
+#endif
+
+private:
+    static const char* Prefix();
+
+};
+
+} // ! Assimp
+#endif
diff --git a/engine/inc/assimp/LogStream.hpp b/engine/inc/assimp/LogStream.hpp
new file mode 100644
index 00000000..00a979da
--- /dev/null
+++ b/engine/inc/assimp/LogStream.hpp
@@ -0,0 +1,111 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file LogStream.hpp
+ *  @brief Abstract base class 'LogStream', representing an output log stream.
+ */
+#ifndef INCLUDED_AI_LOGSTREAM_H
+#define INCLUDED_AI_LOGSTREAM_H
+
+#include "types.h"
+
+namespace Assimp    {
+
+class IOSystem;
+
+// ------------------------------------------------------------------------------------
+/** @brief CPP-API: Abstract interface for log stream implementations.
+ *
+ *  Several default implementations are provided, see #aiDefaultLogStream for more
+ *  details. Writing your own implementation of LogStream is just necessary if these
+ *  are not enough for your purpose. */
+class ASSIMP_API LogStream
+#ifndef SWIG
+    : public Intern::AllocateFromAssimpHeap
+#endif
+{
+protected:
+    /** @brief  Default constructor */
+    LogStream();
+
+public:
+    /** @brief  Virtual destructor  */
+    virtual ~LogStream();
+
+    // -------------------------------------------------------------------
+    /** @brief  Overwrite this for your own output methods
+     *
+     *  Log messages *may* consist of multiple lines and you shouldn't
+     *  expect a consistent formatting. If you want custom formatting
+     *  (e.g. generate HTML), supply a custom instance of Logger to
+     *  #DefaultLogger:set(). Usually you can *expect* that a log message
+     *  is exactly one line and terminated with a single \n character.
+     *  @param message Message to be written */
+    virtual void write(const char* message) = 0;
+
+    // -------------------------------------------------------------------
+    /** @brief Creates a default log stream
+     *  @param streams Type of the default stream
+     *  @param name For aiDefaultLogStream_FILE: name of the output file
+     *  @param io For aiDefaultLogStream_FILE: IOSystem to be used to open the output
+     *   file. Pass NULL for the default implementation.
+     *  @return New LogStream instance.  */
+    static LogStream* createDefaultStream(aiDefaultLogStream stream,
+        const char* name = "AssimpLog.txt",
+        IOSystem* io = NULL);
+
+}; // !class LogStream
+
+inline
+LogStream::LogStream() {
+    // empty
+}
+
+inline
+LogStream::~LogStream() {
+    // empty
+}
+
+// ------------------------------------------------------------------------------------
+} // Namespace Assimp
+
+#endif
diff --git a/engine/inc/assimp/Logger.hpp b/engine/inc/assimp/Logger.hpp
new file mode 100644
index 00000000..56516ca4
--- /dev/null
+++ b/engine/inc/assimp/Logger.hpp
@@ -0,0 +1,269 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file Logger.hpp
+ *  @brief Abstract base class 'Logger', base of the logging system.
+ */
+#ifndef INCLUDED_AI_LOGGER_H
+#define INCLUDED_AI_LOGGER_H
+
+#include "types.h"
+
+namespace Assimp {
+
+class LogStream;
+
+// Maximum length of a log message. Longer messages are rejected.
+#define MAX_LOG_MESSAGE_LENGTH 1024u
+
+// ----------------------------------------------------------------------------------
+/** @brief CPP-API: Abstract interface for logger implementations.
+ *  Assimp provides a default implementation and uses it for almost all
+ *  logging stuff ('DefaultLogger'). This class defines just basic logging
+ *  behaviour and is not of interest for you. Instead, take a look at #DefaultLogger. */
+class ASSIMP_API Logger
+#ifndef SWIG
+    : public Intern::AllocateFromAssimpHeap
+#endif
+{
+public:
+
+    // ----------------------------------------------------------------------
+    /** @enum   LogSeverity
+     *  @brief  Log severity to describe the granularity of logging.
+     */
+    enum LogSeverity
+    {
+        NORMAL,     //!< Normal granularity of logging
+        VERBOSE     //!< Debug infos will be logged, too
+    };
+
+    // ----------------------------------------------------------------------
+    /** @enum   ErrorSeverity
+     *  @brief  Description for severity of a log message.
+     *
+     *  Every LogStream has a bitwise combination of these flags.
+     *  A LogStream doesn't receive any messages of a specific type
+     *  if it doesn't specify the corresponding ErrorSeverity flag.
+     */
+    enum ErrorSeverity
+    {
+        Debugging   = 1,    //!< Debug log message
+        Info        = 2,    //!< Info log message
+        Warn        = 4,    //!< Warn log message
+        Err         = 8     //!< Error log message
+    };
+
+public:
+
+    /** @brief  Virtual destructor */
+    virtual ~Logger();
+
+    // ----------------------------------------------------------------------
+    /** @brief  Writes a debug message
+     *   @param message Debug message*/
+    void debug(const char* message);
+    inline void debug(const std::string &message);
+
+    // ----------------------------------------------------------------------
+    /** @brief  Writes a info message
+     *  @param  message Info message*/
+    void info(const char* message);
+    inline void info(const std::string &message);
+
+    // ----------------------------------------------------------------------
+    /** @brief  Writes a warning message
+     *  @param  message Warn message*/
+    void warn(const char* message);
+    inline void warn(const std::string &message);
+
+    // ----------------------------------------------------------------------
+    /** @brief  Writes an error message
+     *  @param  message Error message*/
+    void error(const char* message);
+    inline void error(const std::string &message);
+
+    // ----------------------------------------------------------------------
+    /** @brief  Set a new log severity.
+     *  @param  log_severity New severity for logging*/
+    void setLogSeverity(LogSeverity log_severity);
+
+    // ----------------------------------------------------------------------
+    /** @brief Get the current log severity*/
+    LogSeverity getLogSeverity() const;
+
+    // ----------------------------------------------------------------------
+    /** @brief  Attach a new log-stream
+     *
+     *  The logger takes ownership of the stream and is responsible
+     *  for its destruction (which is done using ::delete when the logger
+     *  itself is destroyed). Call detachStream to detach a stream and to
+     *  gain ownership of it again.
+     *   @param pStream  Log-stream to attach
+     *  @param severity  Message filter, specified which types of log
+     *    messages are dispatched to the stream. Provide a bitwise
+     *    combination of the ErrorSeverity flags.
+     *  @return true if the stream has been attached, false otherwise.*/
+    virtual bool attachStream(LogStream *pStream,
+        unsigned int severity = Debugging | Err | Warn | Info) = 0;
+
+    // ----------------------------------------------------------------------
+    /** @brief  Detach a still attached stream from the logger (or
+     *          modify the filter flags bits)
+     *   @param pStream Log-stream instance for detaching
+     *  @param severity Provide a bitwise combination of the ErrorSeverity
+     *    flags. This value is &~ed with the current flags of the stream,
+     *    if the result is 0 the stream is detached from the Logger and
+     *    the caller retakes the possession of the stream.
+     *  @return true if the stream has been detached, false otherwise.*/
+    virtual bool detatchStream(LogStream *pStream,
+        unsigned int severity = Debugging | Err | Warn | Info) = 0;
+
+protected:
+
+    /** Default constructor */
+    Logger();
+
+    /** Construction with a given log severity */
+    explicit Logger(LogSeverity severity);
+
+    // ----------------------------------------------------------------------
+    /** @brief Called as a request to write a specific debug message
+     *  @param  message Debug message. Never longer than
+     *    MAX_LOG_MESSAGE_LENGTH characters (excluding the '0').
+     *  @note  The message string is only valid until the scope of
+     *    the function is left.
+     */
+    virtual void OnDebug(const char* message)= 0;
+
+    // ----------------------------------------------------------------------
+    /** @brief Called as a request to write a specific info message
+     *  @param  message Info message. Never longer than
+     *    MAX_LOG_MESSAGE_LENGTH characters (ecxluding the '0').
+     *  @note  The message string is only valid until the scope of
+     *    the function is left.
+     */
+    virtual void OnInfo(const char* message) = 0;
+
+    // ----------------------------------------------------------------------
+    /** @brief Called as a request to write a specific warn message
+     *  @param  message Warn message. Never longer than
+     *    MAX_LOG_MESSAGE_LENGTH characters (exluding the '0').
+     *  @note  The message string is only valid until the scope of
+     *    the function is left.
+     */
+    virtual void OnWarn(const char* essage) = 0;
+
+    // ----------------------------------------------------------------------
+    /** @brief Called as a request to write a specific error message
+     *  @param  message Error message. Never longer than
+     *    MAX_LOG_MESSAGE_LENGTH characters (exluding the '0').
+     *  @note  The message string is only valid until the scope of
+     *    the function is left.
+     */
+    virtual void OnError(const char* message) = 0;
+
+protected:
+
+    //! Logger severity
+    LogSeverity m_Severity;
+};
+
+// ----------------------------------------------------------------------------------
+//  Default constructor
+inline Logger::Logger() {
+    setLogSeverity(NORMAL);
+}
+
+// ----------------------------------------------------------------------------------
+//  Virtual destructor
+inline  Logger::~Logger()
+{
+}
+
+// ----------------------------------------------------------------------------------
+// Construction with given logging severity
+inline Logger::Logger(LogSeverity severity) {
+    setLogSeverity(severity);
+}
+
+// ----------------------------------------------------------------------------------
+// Log severity setter
+inline void Logger::setLogSeverity(LogSeverity log_severity){
+    m_Severity = log_severity;
+}
+
+// ----------------------------------------------------------------------------------
+// Log severity getter
+inline Logger::LogSeverity Logger::getLogSeverity() const {
+    return m_Severity;
+}
+
+// ----------------------------------------------------------------------------------
+inline void Logger::debug(const std::string &message)
+{
+    return debug(message.c_str());
+}
+
+// ----------------------------------------------------------------------------------
+inline void Logger::error(const std::string &message)
+{
+    return error(message.c_str());
+}
+
+// ----------------------------------------------------------------------------------
+inline void Logger::warn(const std::string &message)
+{
+    return warn(message.c_str());
+}
+
+// ----------------------------------------------------------------------------------
+inline void Logger::info(const std::string &message)
+{
+    return info(message.c_str());
+}
+
+// ----------------------------------------------------------------------------------
+
+} // Namespace Assimp
+
+#endif // !! INCLUDED_AI_LOGGER_H
diff --git a/engine/inc/assimp/Macros.h b/engine/inc/assimp/Macros.h
new file mode 100644
index 00000000..4a2d0756
--- /dev/null
+++ b/engine/inc/assimp/Macros.h
@@ -0,0 +1,49 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2012, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/* Helper macro to set a pointer to NULL in debug builds
+ */
+#if (defined ASSIMP_BUILD_DEBUG)
+#   define AI_DEBUG_INVALIDATE_PTR(x) x = NULL;
+#else
+#   define AI_DEBUG_INVALIDATE_PTR(x)
+#endif
+
diff --git a/engine/inc/assimp/MathFunctions.h b/engine/inc/assimp/MathFunctions.h
new file mode 100644
index 00000000..cb3b6960
--- /dev/null
+++ b/engine/inc/assimp/MathFunctions.h
@@ -0,0 +1,77 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2016, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file  MathFunctions.h
+ *  @brief Implementation of the math functions (gcd and lcm)
+ *
+ *  Copied from BoostWorkaround/math
+ */
+
+namespace Assimp {
+namespace Math {
+
+// TODO: use binary GCD for unsigned integers ....
+template < typename IntegerType >
+IntegerType  gcd( IntegerType a, IntegerType b )
+{
+	const IntegerType zero = (IntegerType)0;
+	while ( true )
+	{
+		if ( a == zero )
+			return b;
+		b %= a;
+
+		if ( b == zero )
+			return a;
+		a %= b;
+	}
+}
+
+template < typename IntegerType >
+IntegerType  lcm( IntegerType a, IntegerType b )
+{
+	const IntegerType t = gcd (a,b);
+	if (!t)return t;
+	return a / t * b;
+}
+
+}
+}
diff --git a/engine/inc/assimp/MemoryIOWrapper.h b/engine/inc/assimp/MemoryIOWrapper.h
new file mode 100644
index 00000000..bfcfff9c
--- /dev/null
+++ b/engine/inc/assimp/MemoryIOWrapper.h
@@ -0,0 +1,199 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file MemoryIOWrapper.h
+ *  Handy IOStream/IOSystem implemetation to read directly from a memory buffer */
+#ifndef AI_MEMORYIOSTREAM_H_INC
+#define AI_MEMORYIOSTREAM_H_INC
+
+#include <assimp/IOStream.hpp>
+#include <assimp/IOSystem.hpp>
+#include <assimp/ai_assert.h>
+#include <stdint.h>
+
+namespace Assimp    {
+#define AI_MEMORYIO_MAGIC_FILENAME "$$$___magic___$$$"
+#define AI_MEMORYIO_MAGIC_FILENAME_LENGTH 17
+
+// ----------------------------------------------------------------------------------
+/** Implementation of IOStream to read directly from a memory buffer */
+// ----------------------------------------------------------------------------------
+class MemoryIOStream : public IOStream
+{
+    //friend class MemoryIOSystem;
+public:
+    MemoryIOStream (const uint8_t* buff, size_t len, bool own = false)
+        : buffer (buff)
+        , length(len)
+        , pos((size_t)0)
+        , own(own)
+    {
+    }
+
+public:
+
+    ~MemoryIOStream ()  {
+        if(own) {
+            delete[] buffer;
+        }
+    }
+
+    // -------------------------------------------------------------------
+    // Read from stream
+    size_t Read(void* pvBuffer, size_t pSize, size_t pCount)    {
+        const size_t cnt = std::min(pCount,(length-pos)/pSize),ofs = pSize*cnt;
+
+        memcpy(pvBuffer,buffer+pos,ofs);
+        pos += ofs;
+
+        return cnt;
+    }
+
+    // -------------------------------------------------------------------
+    // Write to stream
+    size_t Write(const void* /*pvBuffer*/, size_t /*pSize*/,size_t /*pCount*/)  {
+        ai_assert(false); // won't be needed
+        return 0;
+    }
+
+    // -------------------------------------------------------------------
+    // Seek specific position
+    aiReturn Seek(size_t pOffset, aiOrigin pOrigin) {
+        if (aiOrigin_SET == pOrigin) {
+            if (pOffset > length) {
+                return AI_FAILURE;
+            }
+            pos = pOffset;
+        }
+        else if (aiOrigin_END == pOrigin) {
+            if (pOffset > length) {
+                return AI_FAILURE;
+            }
+            pos = length-pOffset;
+        }
+        else {
+            if (pOffset+pos > length) {
+                return AI_FAILURE;
+            }
+            pos += pOffset;
+        }
+        return AI_SUCCESS;
+    }
+
+    // -------------------------------------------------------------------
+    // Get current seek position
+    size_t Tell() const {
+        return pos;
+    }
+
+    // -------------------------------------------------------------------
+    // Get size of file
+    size_t FileSize() const {
+        return length;
+    }
+
+    // -------------------------------------------------------------------
+    // Flush file contents
+    void Flush() {
+        ai_assert(false); // won't be needed
+    }
+
+private:
+    const uint8_t* buffer;
+    size_t length,pos;
+    bool own;
+};
+
+// ---------------------------------------------------------------------------
+/** Dummy IO system to read from a memory buffer */
+class MemoryIOSystem : public IOSystem
+{
+public:
+    /** Constructor. */
+    MemoryIOSystem (const uint8_t* buff, size_t len)
+        : buffer (buff), length(len) {
+    }
+
+    /** Destructor. */
+    ~MemoryIOSystem() {
+    }
+
+    // -------------------------------------------------------------------
+    /** Tests for the existence of a file at the given path. */
+    bool Exists( const char* pFile) const {
+        return !strncmp(pFile,AI_MEMORYIO_MAGIC_FILENAME,AI_MEMORYIO_MAGIC_FILENAME_LENGTH);
+    }
+
+    // -------------------------------------------------------------------
+    /** Returns the directory separator. */
+    char getOsSeparator() const {
+        return '/'; // why not? it doesn't care
+    }
+
+    // -------------------------------------------------------------------
+    /** Open a new file with a given path. */
+    IOStream* Open( const char* pFile, const char* /*pMode*/ = "rb") {
+        if (strncmp(pFile,AI_MEMORYIO_MAGIC_FILENAME,AI_MEMORYIO_MAGIC_FILENAME_LENGTH)) {
+            return NULL;
+        }
+        return new MemoryIOStream(buffer,length);
+    }
+
+    // -------------------------------------------------------------------
+    /** Closes the given file and releases all resources associated with it. */
+    void Close( IOStream* pFile) {
+    	delete pFile;
+    }
+
+    // -------------------------------------------------------------------
+    /** Compare two paths */
+    bool ComparePaths (const char* /*one*/, const char* /*second*/) const {
+        return false;
+    }
+
+private:
+    const uint8_t* buffer;
+    size_t length;
+};
+} // end namespace Assimp
+
+#endif
diff --git a/engine/inc/assimp/NullLogger.hpp b/engine/inc/assimp/NullLogger.hpp
new file mode 100644
index 00000000..776f301a
--- /dev/null
+++ b/engine/inc/assimp/NullLogger.hpp
@@ -0,0 +1,99 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file  NullLogger.hpp
+ *  @brief Dummy logger
+*/
+
+#ifndef INCLUDED_AI_NULLLOGGER_H
+#define INCLUDED_AI_NULLLOGGER_H
+
+#include "Logger.hpp"
+
+namespace Assimp {
+
+// ---------------------------------------------------------------------------
+/** @brief CPP-API: Empty logging implementation.
+ *
+ * Does nothing! Used by default if the application hasn't requested a
+ * custom logger via #DefaultLogger::set() or #DefaultLogger::create(); */
+class ASSIMP_API NullLogger
+    : public Logger {
+
+public:
+
+    /** @brief  Logs a debug message */
+    void OnDebug(const char* message) {
+        (void)message; //this avoids compiler warnings
+    }
+
+    /** @brief  Logs an info message */
+    void OnInfo(const char* message) {
+        (void)message; //this avoids compiler warnings
+    }
+
+    /** @brief  Logs a warning message */
+    void OnWarn(const char* message) {
+        (void)message; //this avoids compiler warnings
+    }
+
+    /** @brief  Logs an error message */
+    void OnError(const char* message) {
+        (void)message; //this avoids compiler warnings
+    }
+
+    /** @brief  Detach a still attached stream from logger */
+    bool attachStream(LogStream *pStream, unsigned int severity) {
+        (void)pStream; (void)severity; //this avoids compiler warnings
+        return false;
+    }
+
+    /** @brief  Detach a still attached stream from logger */
+    bool detatchStream(LogStream *pStream, unsigned int severity) {
+        (void)pStream; (void)severity; //this avoids compiler warnings
+        return false;
+    }
+
+private:
+};
+}
+#endif // !! AI_NULLLOGGER_H_INCLUDED
diff --git a/engine/inc/assimp/ParsingUtils.h b/engine/inc/assimp/ParsingUtils.h
new file mode 100644
index 00000000..4553072d
--- /dev/null
+++ b/engine/inc/assimp/ParsingUtils.h
@@ -0,0 +1,260 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+
+/** @file ParsingUtils.h
+ *  @brief Defines helper functions for text parsing
+ */
+#ifndef AI_PARSING_UTILS_H_INC
+#define AI_PARSING_UTILS_H_INC
+
+#include "StringComparison.h"
+#include "StringUtils.h"
+#include <assimp/defs.h>
+
+namespace Assimp {
+
+// NOTE: the functions below are mostly intended as replacement for
+// std::upper, std::lower, std::isupper, std::islower, std::isspace.
+// we don't bother of locales. We don't want them. We want reliable
+// (i.e. identical) results across all locales.
+
+// The functions below accept any character type, but know only
+// about ASCII. However, UTF-32 is the only safe ASCII superset to
+// use since it doesn't have multi-byte sequences.
+
+static const unsigned int BufferSize = 4096;
+
+// ---------------------------------------------------------------------------------
+template <class char_t>
+AI_FORCE_INLINE
+char_t ToLower( char_t in ) {
+    return (in >= (char_t)'A' && in <= (char_t)'Z') ? (char_t)(in+0x20) : in;
+}
+
+// ---------------------------------------------------------------------------------
+template <class char_t>
+AI_FORCE_INLINE
+char_t ToUpper( char_t in) {
+    return (in >= (char_t)'a' && in <= (char_t)'z') ? (char_t)(in-0x20) : in;
+}
+
+// ---------------------------------------------------------------------------------
+template <class char_t>
+AI_FORCE_INLINE
+bool IsUpper( char_t in) {
+    return (in >= (char_t)'A' && in <= (char_t)'Z');
+}
+
+// ---------------------------------------------------------------------------------
+template <class char_t>
+AI_FORCE_INLINE
+bool IsLower( char_t in) {
+    return (in >= (char_t)'a' && in <= (char_t)'z');
+}
+
+// ---------------------------------------------------------------------------------
+template <class char_t>
+AI_FORCE_INLINE
+bool IsSpace( char_t in) {
+    return (in == (char_t)' ' || in == (char_t)'\t');
+}
+
+// ---------------------------------------------------------------------------------
+template <class char_t>
+AI_FORCE_INLINE
+bool IsLineEnd( char_t in) {
+    return (in==(char_t)'\r'||in==(char_t)'\n'||in==(char_t)'\0'||in==(char_t)'\f');
+}
+
+// ---------------------------------------------------------------------------------
+template <class char_t>
+AI_FORCE_INLINE
+bool IsSpaceOrNewLine( char_t in) {
+    return IsSpace<char_t>(in) || IsLineEnd<char_t>(in);
+}
+
+// ---------------------------------------------------------------------------------
+template <class char_t>
+AI_FORCE_INLINE
+bool SkipSpaces( const char_t* in, const char_t** out) {
+    while( *in == ( char_t )' ' || *in == ( char_t )'\t' ) {
+        ++in;
+    }
+    *out = in;
+    return !IsLineEnd<char_t>(*in);
+}
+
+// ---------------------------------------------------------------------------------
+template <class char_t>
+AI_FORCE_INLINE
+bool SkipSpaces( const char_t** inout) {
+    return SkipSpaces<char_t>(*inout,inout);
+}
+
+// ---------------------------------------------------------------------------------
+template <class char_t>
+AI_FORCE_INLINE
+bool SkipLine( const char_t* in, const char_t** out) {
+    while( *in != ( char_t )'\r' && *in != ( char_t )'\n' && *in != ( char_t )'\0' ) {
+        ++in;
+    }
+
+    // files are opened in binary mode. Ergo there are both NL and CR
+    while( *in == ( char_t )'\r' || *in == ( char_t )'\n' ) {
+        ++in;
+    }
+    *out = in;
+    return *in != (char_t)'\0';
+}
+
+// ---------------------------------------------------------------------------------
+template <class char_t>
+AI_FORCE_INLINE
+bool SkipLine( const char_t** inout) {
+    return SkipLine<char_t>(*inout,inout);
+}
+
+// ---------------------------------------------------------------------------------
+template <class char_t>
+AI_FORCE_INLINE
+bool SkipSpacesAndLineEnd( const char_t* in, const char_t** out) {
+    while( *in == ( char_t )' ' || *in == ( char_t )'\t' || *in == ( char_t )'\r' || *in == ( char_t )'\n' ) {
+        ++in;
+    }
+    *out = in;
+    return *in != '\0';
+}
+
+// ---------------------------------------------------------------------------------
+template <class char_t>
+AI_FORCE_INLINE
+bool SkipSpacesAndLineEnd( const char_t** inout) {
+    return SkipSpacesAndLineEnd<char_t>(*inout,inout);
+}
+
+// ---------------------------------------------------------------------------------
+template <class char_t>
+AI_FORCE_INLINE
+bool GetNextLine( const char_t*& buffer, char_t out[ BufferSize ] ) {
+    if( ( char_t )'\0' == *buffer ) {
+        return false;
+    }
+
+    char* _out = out;
+    char* const end = _out + BufferSize;
+    while( !IsLineEnd( *buffer ) && _out < end ) {
+        *_out++ = *buffer++;
+    }
+    *_out = (char_t)'\0';
+
+    while( IsLineEnd( *buffer ) && '\0' != *buffer ) {
+        ++buffer;
+    }
+
+    return true;
+}
+
+// ---------------------------------------------------------------------------------
+template <class char_t>
+AI_FORCE_INLINE bool IsNumeric( char_t in)
+{
+    return ( in >= '0' && in <= '9' ) || '-' == in || '+' == in;
+}
+
+// ---------------------------------------------------------------------------------
+template <class char_t>
+AI_FORCE_INLINE
+bool TokenMatch(char_t*& in, const char* token, unsigned int len)
+{
+    if (!::strncmp(token,in,len) && IsSpaceOrNewLine(in[len])) {
+        if (in[len] != '\0') {
+            in += len+1;
+        } else {
+            // If EOF after the token make sure we don't go past end of buffer
+            in += len;
+        }
+        return true;
+    }
+
+    return false;
+}
+// ---------------------------------------------------------------------------------
+/** @brief Case-ignoring version of TokenMatch
+ *  @param in Input
+ *  @param token Token to check for
+ *  @param len Number of characters to check
+ */
+AI_FORCE_INLINE
+bool TokenMatchI(const char*& in, const char* token, unsigned int len) {
+    if (!ASSIMP_strincmp(token,in,len) && IsSpaceOrNewLine(in[len])) {
+        in += len+1;
+        return true;
+    }
+    return false;
+}
+
+// ---------------------------------------------------------------------------------
+AI_FORCE_INLINE
+void SkipToken(const char*& in) {
+    SkipSpaces(&in);
+    while ( !IsSpaceOrNewLine( *in ) ) {
+        ++in;
+    }
+}
+
+// ---------------------------------------------------------------------------------
+AI_FORCE_INLINE
+std::string GetNextToken(const char*& in) {
+    SkipSpacesAndLineEnd(&in);
+    const char* cur = in;
+    while ( !IsSpaceOrNewLine( *in ) ) {
+        ++in;
+    }
+    return std::string(cur,(size_t)(in-cur));
+}
+
+// ---------------------------------------------------------------------------------
+
+} // ! namespace Assimp
+
+#endif // ! AI_PARSING_UTILS_H_INC
diff --git a/engine/inc/assimp/Profiler.h b/engine/inc/assimp/Profiler.h
new file mode 100644
index 00000000..272085ea
--- /dev/null
+++ b/engine/inc/assimp/Profiler.h
@@ -0,0 +1,99 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file Profiler.h
+ *  @brief Utility to measure the respective runtime of each import step
+ */
+#ifndef INCLUDED_PROFILER_H
+#define INCLUDED_PROFILER_H
+
+#include <chrono>
+#include <assimp/DefaultLogger.hpp>
+#include "TinyFormatter.h"
+
+#include <map>
+
+namespace Assimp {
+namespace Profiling {
+
+using namespace Formatter;
+
+// ------------------------------------------------------------------------------------------------
+/** Simple wrapper around boost::timer to simplify reporting. Timings are automatically
+ *  dumped to the log file.
+ */
+class Profiler {
+public:
+    Profiler() {
+        // empty
+    }
+
+public:
+
+    /** Start a named timer */
+    void BeginRegion(const std::string& region) {
+        regions[region] = std::chrono::system_clock::now();
+        DefaultLogger::get()->debug((format("START `"),region,"`"));
+    }
+
+
+    /** End a specific named timer and write its end time to the log */
+    void EndRegion(const std::string& region) {
+        RegionMap::const_iterator it = regions.find(region);
+        if (it == regions.end()) {
+            return;
+        }
+
+        std::chrono::duration<double> elapsedSeconds = std::chrono::system_clock::now() - regions[region];
+        DefaultLogger::get()->debug((format("END   `"),region,"`, dt= ", elapsedSeconds.count()," s"));
+    }
+
+private:
+    typedef std::map<std::string,std::chrono::time_point<std::chrono::system_clock>> RegionMap;
+    RegionMap regions;
+};
+
+}
+}
+
+#endif
+
diff --git a/engine/inc/assimp/ProgressHandler.hpp b/engine/inc/assimp/ProgressHandler.hpp
new file mode 100644
index 00000000..b1d095b7
--- /dev/null
+++ b/engine/inc/assimp/ProgressHandler.hpp
@@ -0,0 +1,127 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file ProgressHandler.hpp
+ *  @brief Abstract base class 'ProgressHandler'.
+ */
+#pragma once
+#ifndef AI_PROGRESSHANDLER_H_INC
+#define AI_PROGRESSHANDLER_H_INC
+
+#include "types.h"
+
+namespace Assimp    {
+
+// ------------------------------------------------------------------------------------
+/** @brief CPP-API: Abstract interface for custom progress report receivers.
+ *
+ *  Each #Importer instance maintains its own #ProgressHandler. The default
+ *  implementation provided by Assimp doesn't do anything at all. */
+class ASSIMP_API ProgressHandler
+#ifndef SWIG
+    : public Intern::AllocateFromAssimpHeap
+#endif
+{
+protected:
+    /** @brief  Default constructor */
+    ProgressHandler () {
+    }
+public:
+    /** @brief  Virtual destructor  */
+    virtual ~ProgressHandler () {
+    }
+
+    // -------------------------------------------------------------------
+    /** @brief Progress callback.
+     *  @param percentage An estimate of the current loading progress,
+     *    in percent. Or -1.f if such an estimate is not available.
+     *
+     *  There are restriction on what you may do from within your
+     *  implementation of this method: no exceptions may be thrown and no
+     *  non-const #Importer methods may be called. It is
+     *  not generally possible to predict the number of callbacks
+     *  fired during a single import.
+     *
+     *  @return Return false to abort loading at the next possible
+     *   occasion (loaders and Assimp are generally allowed to perform
+     *   all needed cleanup tasks prior to returning control to the
+     *   caller). If the loading is aborted, #Importer::ReadFile()
+     *   returns always NULL.
+     *   */
+    virtual bool Update(float percentage = -1.f) = 0;
+
+    // -------------------------------------------------------------------
+    /** @brief Progress callback for file loading steps
+     *  @param numberOfSteps The number of total post-processing
+     *   steps
+     *  @param currentStep The index of the current post-processing
+     *   step that will run, or equal to numberOfSteps if all of
+     *   them has finished. This number is always strictly monotone
+     *   increasing, although not necessarily linearly.
+     *
+     *  @note This is currently only used at the start and the end
+     *   of the file parsing.
+     *   */
+    virtual void UpdateFileRead(int currentStep /*= 0*/, int numberOfSteps /*= 0*/) {
+        float f = numberOfSteps ? currentStep / (float)numberOfSteps : 1.0f;
+        Update( f * 0.5f );
+    }
+
+    // -------------------------------------------------------------------
+    /** @brief Progress callback for post-processing steps
+     *  @param numberOfSteps The number of total post-processing
+     *   steps
+     *  @param currentStep The index of the current post-processing
+     *   step that will run, or equal to numberOfSteps if all of
+     *   them has finished. This number is always strictly monotone
+     *   increasing, although not necessarily linearly.
+     *   */
+    virtual void UpdatePostProcess(int currentStep /*= 0*/, int numberOfSteps /*= 0*/) {
+        float f = numberOfSteps ? currentStep / (float)numberOfSteps : 1.0f;
+        Update( f * 0.5f + 0.5f );
+    }
+
+}; // !class ProgressHandler
+// ------------------------------------------------------------------------------------
+} // Namespace Assimp
+
+#endif // AI_PROGRESSHANDLER_H_INC
diff --git a/engine/inc/assimp/RemoveComments.h b/engine/inc/assimp/RemoveComments.h
new file mode 100644
index 00000000..08299f22
--- /dev/null
+++ b/engine/inc/assimp/RemoveComments.h
@@ -0,0 +1,91 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file Declares a helper class, "CommentRemover", which can be
+ *  used to remove comments (single and multi line) from a text file.
+ */
+#ifndef AI_REMOVE_COMMENTS_H_INC
+#define AI_REMOVE_COMMENTS_H_INC
+
+
+#include <assimp/defs.h>
+
+namespace Assimp    {
+
+// ---------------------------------------------------------------------------
+/** \brief Helper class to remove single and multi line comments from a file
+ *
+ *  Some mesh formats like MD5 have comments that are quite similar
+ *  to those in C or C++ so this code has been moved to a separate
+ *  module.
+ */
+class ASSIMP_API CommentRemover
+{
+    // class cannot be instanced
+    CommentRemover() {}
+
+public:
+
+    //! Remove single-line comments. The end of a line is
+    //! expected to be either NL or CR or NLCR.
+    //! \param szComment The start sequence of the comment, e.g. "//"
+    //! \param szBuffer Buffer to work with
+    //! \param chReplacement Character to be used as replacement
+    //! for commented lines. By default this is ' '
+    static void RemoveLineComments(const char* szComment,
+        char* szBuffer, char chReplacement = ' ');
+
+    //! Remove multi-line comments. The end of a line is
+    //! expected to be either NL or CR or NLCR. Multi-line comments
+    //! may not be nested (as in C).
+    //! \param szCommentStart The start sequence of the comment, e.g. "/*"
+    //! \param szCommentEnd The end sequence of the comment, e.g. "*/"
+    //! \param szBuffer Buffer to work with
+    //! \param chReplacement Character to be used as replacement
+    //! for commented lines. By default this is ' '
+    static void RemoveMultiLineComments(const char* szCommentStart,
+        const char* szCommentEnd,char* szBuffer,
+        char chReplacement = ' ');
+};
+} // ! Assimp
+
+#endif // !! AI_REMOVE_COMMENTS_H_INC
diff --git a/engine/inc/assimp/SGSpatialSort.h b/engine/inc/assimp/SGSpatialSort.h
new file mode 100644
index 00000000..203e3251
--- /dev/null
+++ b/engine/inc/assimp/SGSpatialSort.h
@@ -0,0 +1,142 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** Small helper classes to optimize finding vertices close to a given location
+ */
+#ifndef AI_D3DSSPATIALSORT_H_INC
+#define AI_D3DSSPATIALSORT_H_INC
+
+#include <assimp/types.h>
+#include <vector>
+#include <stdint.h>
+
+namespace Assimp    {
+
+// ----------------------------------------------------------------------------------
+/** Specialized version of SpatialSort to support smoothing groups
+ *  This is used in by the 3DS, ASE and LWO loaders. 3DS and ASE share their
+ *  normal computation code in SmoothingGroups.inl, the LWO loader has its own
+ *  implementation to handle all details of its file format correctly.
+ */
+// ----------------------------------------------------------------------------------
+class ASSIMP_API SGSpatialSort
+{
+public:
+
+    SGSpatialSort();
+
+    // -------------------------------------------------------------------
+    /** Construction from a given face array, handling smoothing groups
+     *  properly
+     */
+    explicit SGSpatialSort(const std::vector<aiVector3D>& vPositions);
+
+    // -------------------------------------------------------------------
+    /** Add a vertex to the spatial sort
+     * @param vPosition Vertex position to be added
+     * @param index Index of the vrtex
+     * @param smoothingGroup SmoothingGroup for this vertex
+     */
+    void Add(const aiVector3D& vPosition, unsigned int index,
+        unsigned int smoothingGroup);
+
+    // -------------------------------------------------------------------
+    /** Prepare the spatial sorter for use. This step runs in O(logn)
+     */
+    void Prepare();
+
+    /** Destructor */
+    ~SGSpatialSort();
+
+    // -------------------------------------------------------------------
+    /** Returns an iterator for all positions close to the given position.
+     * @param pPosition The position to look for vertices.
+     * @param pSG Only included vertices with at least one shared smooth group
+     * @param pRadius Maximal distance from the position a vertex may have
+     *   to be counted in.
+     * @param poResults The container to store the indices of the found
+     *   positions. Will be emptied by the call so it may contain anything.
+     * @param exactMatch Specifies whether smoothing groups are bit masks
+     *   (false) or integral values (true). In the latter case, a vertex
+     *   cannot belong to more than one smoothing group.
+     * @return An iterator to iterate over all vertices in the given area.
+     */
+    // -------------------------------------------------------------------
+    void FindPositions( const aiVector3D& pPosition, uint32_t pSG,
+        float pRadius, std::vector<unsigned int>& poResults,
+        bool exactMatch = false) const;
+
+protected:
+    /** Normal of the sorting plane, normalized. The center is always at (0, 0, 0) */
+    aiVector3D mPlaneNormal;
+
+    // -------------------------------------------------------------------
+    /** An entry in a spatially sorted position array. Consists of a
+     *  vertex index, its position and its precalculated distance from
+     *  the reference plane */
+    // -------------------------------------------------------------------
+    struct Entry
+    {
+        unsigned int mIndex;    ///< The vertex referred by this entry
+        aiVector3D mPosition;   ///< Position
+        uint32_t mSmoothGroups;
+        float mDistance;        ///< Distance of this vertex to the sorting plane
+
+        Entry() { /** intentionally not initialized.*/ }
+        Entry( unsigned int pIndex, const aiVector3D& pPosition, float pDistance,uint32_t pSG)
+        :
+            mIndex( pIndex),
+            mPosition( pPosition),
+            mSmoothGroups (pSG),
+            mDistance( pDistance)
+            {   }
+
+        bool operator < (const Entry& e) const { return mDistance < e.mDistance; }
+    };
+
+    // all positions, sorted by distance to the sorting plane
+    std::vector<Entry> mPositions;
+};
+
+} // end of namespace Assimp
+
+#endif // AI_SPATIALSORT_H_INC
diff --git a/engine/inc/assimp/SceneCombiner.h b/engine/inc/assimp/SceneCombiner.h
new file mode 100644
index 00000000..ec278824
--- /dev/null
+++ b/engine/inc/assimp/SceneCombiner.h
@@ -0,0 +1,401 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file Declares a helper class, "SceneCombiner" providing various
+ *  utilities to merge scenes.
+ */
+#ifndef AI_SCENE_COMBINER_H_INC
+#define AI_SCENE_COMBINER_H_INC
+
+#include <assimp/ai_assert.h>
+#include <assimp/types.h>
+#include <assimp/Defines.h>
+#include <stddef.h>
+#include <set>
+#include <list>
+#include <stdint.h>
+
+#include <vector>
+
+struct aiScene;
+struct aiNode;
+struct aiMaterial;
+struct aiTexture;
+struct aiCamera;
+struct aiLight;
+struct aiMetadata;
+struct aiBone;
+struct aiMesh;
+struct aiAnimation;
+struct aiNodeAnim;
+
+namespace Assimp    {
+
+// ---------------------------------------------------------------------------
+/** \brief Helper data structure for SceneCombiner.
+ *
+ *  Describes to which node a scene must be attached to.
+ */
+struct AttachmentInfo
+{
+    AttachmentInfo()
+        :   scene           (NULL)
+        ,   attachToNode    (NULL)
+    {}
+
+    AttachmentInfo(aiScene* _scene, aiNode* _attachToNode)
+        :   scene           (_scene)
+        ,   attachToNode    (_attachToNode)
+    {}
+
+    aiScene* scene;
+    aiNode*  attachToNode;
+};
+
+// ---------------------------------------------------------------------------
+struct NodeAttachmentInfo
+{
+    NodeAttachmentInfo()
+        :   node            (NULL)
+        ,   attachToNode    (NULL)
+        ,   resolved        (false)
+        ,   src_idx         (SIZE_MAX)
+    {}
+
+    NodeAttachmentInfo(aiNode* _scene, aiNode* _attachToNode,size_t idx)
+        :   node            (_scene)
+        ,   attachToNode    (_attachToNode)
+        ,   resolved        (false)
+        ,   src_idx         (idx)
+    {}
+
+    aiNode*  node;
+    aiNode*  attachToNode;
+    bool     resolved;
+    size_t   src_idx;
+};
+
+// ---------------------------------------------------------------------------
+/** @def AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES
+ *  Generate unique names for all named scene items
+ */
+#define AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES      0x1
+
+/** @def AI_INT_MERGE_SCENE_GEN_UNIQUE_MATNAMES
+ *  Generate unique names for materials, too.
+ *  This is not absolutely required to pass the validation.
+ */
+#define AI_INT_MERGE_SCENE_GEN_UNIQUE_MATNAMES   0x2
+
+/** @def AI_INT_MERGE_SCENE_DUPLICATES_DEEP_CPY
+ * Use deep copies of duplicate scenes
+ */
+#define AI_INT_MERGE_SCENE_DUPLICATES_DEEP_CPY   0x4
+
+/** @def AI_INT_MERGE_SCENE_RESOLVE_CROSS_ATTACHMENTS
+ * If attachment nodes are not found in the given master scene,
+ * search the other imported scenes for them in an any order.
+ */
+#define AI_INT_MERGE_SCENE_RESOLVE_CROSS_ATTACHMENTS 0x8
+
+/** @def AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY
+ * Can be combined with AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES.
+ * Unique names are generated, but only if this is absolutely
+ * required to avoid name conflicts.
+ */
+#define AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY 0x10
+
+typedef std::pair<aiBone*,unsigned int> BoneSrcIndex;
+
+// ---------------------------------------------------------------------------
+/** @brief Helper data structure for SceneCombiner::MergeBones.
+ */
+struct BoneWithHash : public std::pair<uint32_t,aiString*>  {
+    std::vector<BoneSrcIndex> pSrcBones;
+};
+
+// ---------------------------------------------------------------------------
+/** @brief Utility for SceneCombiner
+ */
+struct SceneHelper
+{
+    SceneHelper ()
+        : scene     (NULL)
+        , idlen     (0)
+    {
+        id[0] = 0;
+    }
+
+    explicit SceneHelper (aiScene* _scene)
+        : scene     (_scene)
+        , idlen     (0)
+    {
+        id[0] = 0;
+    }
+
+    AI_FORCE_INLINE aiScene* operator-> () const
+    {
+        return scene;
+    }
+
+    // scene we're working on
+    aiScene* scene;
+
+    // prefix to be added to all identifiers in the scene ...
+    char id [32];
+
+    // and its strlen()
+    unsigned int idlen;
+
+    // hash table to quickly check whether a name is contained in the scene
+    std::set<unsigned int> hashes;
+};
+
+// ---------------------------------------------------------------------------
+/** \brief Static helper class providing various utilities to merge two
+ *    scenes. It is intended as internal utility and NOT for use by
+ *    applications.
+ *
+ * The class is currently being used by various postprocessing steps
+ * and loaders (ie. LWS).
+ */
+class ASSIMP_API SceneCombiner {
+    // class cannot be instanced
+    SceneCombiner() {
+        // empty
+    }
+
+    ~SceneCombiner() {
+        // empty
+    }
+
+public:
+    // -------------------------------------------------------------------
+    /** Merges two or more scenes.
+     *
+     *  @param dest  Receives a pointer to the destination scene. If the
+     *    pointer doesn't point to NULL when the function is called, the
+     *    existing scene is cleared and refilled.
+     *  @param src Non-empty list of scenes to be merged. The function
+     *    deletes the input scenes afterwards. There may be duplicate scenes.
+     *  @param flags Combination of the AI_INT_MERGE_SCENE flags defined above
+     */
+    static void MergeScenes(aiScene** dest,std::vector<aiScene*>& src,
+        unsigned int flags = 0);
+
+    // -------------------------------------------------------------------
+    /** Merges two or more scenes and attaches all scenes to a specific
+     *  position in the node graph of the master scene.
+     *
+     *  @param dest Receives a pointer to the destination scene. If the
+     *    pointer doesn't point to NULL when the function is called, the
+     *    existing scene is cleared and refilled.
+     *  @param master Master scene. It will be deleted afterwards. All
+     *    other scenes will be inserted in its node graph.
+     *  @param src Non-empty list of scenes to be merged along with their
+     *    corresponding attachment points in the master scene. The function
+     *    deletes the input scenes afterwards. There may be duplicate scenes.
+     *  @param flags Combination of the AI_INT_MERGE_SCENE flags defined above
+     */
+    static void MergeScenes(aiScene** dest, aiScene* master,
+        std::vector<AttachmentInfo>& src,
+        unsigned int flags = 0);
+
+    // -------------------------------------------------------------------
+    /** Merges two or more meshes
+     *
+     *  The meshes should have equal vertex formats. Only components
+     *  that are provided by ALL meshes will be present in the output mesh.
+     *  An exception is made for VColors - they are set to black. The
+     *  meshes should have the same material indices, too. The output
+     *  material index is always the material index of the first mesh.
+     *
+     *  @param dest Destination mesh. Must be empty.
+     *  @param flags Currently no parameters
+     *  @param begin First mesh to be processed
+     *  @param end Points to the mesh after the last mesh to be processed
+     */
+    static void MergeMeshes(aiMesh** dest,unsigned int flags,
+        std::vector<aiMesh*>::const_iterator begin,
+        std::vector<aiMesh*>::const_iterator end);
+
+    // -------------------------------------------------------------------
+    /** Merges two or more bones
+     *
+     *  @param out Mesh to receive the output bone list
+     *  @param flags Currently no parameters
+     *  @param begin First mesh to be processed
+     *  @param end Points to the mesh after the last mesh to be processed
+     */
+    static void MergeBones(aiMesh* out,std::vector<aiMesh*>::const_iterator it,
+        std::vector<aiMesh*>::const_iterator end);
+
+    // -------------------------------------------------------------------
+    /** Merges two or more materials
+     *
+     *  The materials should be complementary as much as possible. In case
+     *  of a property present in different materials, the first occurrence
+     *  is used.
+     *
+     *  @param dest Destination material. Must be empty.
+     *  @param begin First material to be processed
+     *  @param end Points to the material after the last material to be processed
+     */
+    static void MergeMaterials(aiMaterial** dest,
+        std::vector<aiMaterial*>::const_iterator begin,
+        std::vector<aiMaterial*>::const_iterator end);
+
+    // -------------------------------------------------------------------
+    /** Builds a list of uniquely named bones in a mesh list
+     *
+     *  @param asBones Receives the output list
+     *  @param it First mesh to be processed
+     *  @param end Last mesh to be processed
+     */
+    static void BuildUniqueBoneList(std::list<BoneWithHash>& asBones,
+        std::vector<aiMesh*>::const_iterator it,
+        std::vector<aiMesh*>::const_iterator end);
+
+    // -------------------------------------------------------------------
+    /** Add a name prefix to all nodes in a scene.
+     *
+     *  @param Current node. This function is called recursively.
+     *  @param prefix Prefix to be added to all nodes
+     *  @param len STring length
+     */
+    static void AddNodePrefixes(aiNode* node, const char* prefix,
+        unsigned int len);
+
+    // -------------------------------------------------------------------
+    /** Add an offset to all mesh indices in a node graph
+     *
+     *  @param Current node. This function is called recursively.
+     *  @param offset Offset to be added to all mesh indices
+     */
+    static void OffsetNodeMeshIndices (aiNode* node, unsigned int offset);
+
+    // -------------------------------------------------------------------
+    /** Attach a list of node graphs to well-defined nodes in a master
+     *  graph. This is a helper for MergeScenes()
+     *
+     *  @param master Master scene
+     *  @param srcList List of source scenes along with their attachment
+     *    points. If an attachment point is NULL (or does not exist in
+     *    the master graph), a scene is attached to the root of the master
+     *    graph (as an additional child node)
+     *  @duplicates List of duplicates. If elem[n] == n the scene is not
+     *    a duplicate. Otherwise elem[n] links scene n to its first occurrence.
+     */
+    static void AttachToGraph ( aiScene* master,
+        std::vector<NodeAttachmentInfo>& srcList);
+
+    static void AttachToGraph (aiNode* attach,
+        std::vector<NodeAttachmentInfo>& srcList);
+
+
+    // -------------------------------------------------------------------
+    /** Get a deep copy of a scene
+     *
+     *  @param dest Receives a pointer to the destination scene
+     *  @param src Source scene - remains unmodified.
+     */
+    static void CopyScene(aiScene** dest,const aiScene* source,bool allocate = true);
+
+
+    // -------------------------------------------------------------------
+    /** Get a flat copy of a scene
+     *
+     *  Only the first hierarchy layer is copied. All pointer members of
+     *  aiScene are shared by source and destination scene.  If the
+     *    pointer doesn't point to NULL when the function is called, the
+     *    existing scene is cleared and refilled.
+     *  @param dest Receives a pointer to the destination scene
+     *  @param src Source scene - remains unmodified.
+     */
+    static void CopySceneFlat(aiScene** dest,const aiScene* source);
+
+
+    // -------------------------------------------------------------------
+    /** Get a deep copy of a mesh
+     *
+     *  @param dest Receives a pointer to the destination mesh
+     *  @param src Source mesh - remains unmodified.
+     */
+    static void Copy     (aiMesh** dest, const aiMesh* src);
+
+    // similar to Copy():
+    static void Copy  (aiMaterial** dest, const aiMaterial* src);
+    static void Copy  (aiTexture** dest, const aiTexture* src);
+    static void Copy  (aiAnimation** dest, const aiAnimation* src);
+    static void Copy  (aiCamera** dest, const aiCamera* src);
+    static void Copy  (aiBone** dest, const aiBone* src);
+    static void Copy  (aiLight** dest, const aiLight* src);
+    static void Copy  (aiNodeAnim** dest, const aiNodeAnim* src);
+    static void Copy  (aiMetadata** dest, const aiMetadata* src);
+
+    // recursive, of course
+    static void Copy     (aiNode** dest, const aiNode* src);
+
+
+private:
+
+    // -------------------------------------------------------------------
+    // Same as AddNodePrefixes, but with an additional check
+    static void AddNodePrefixesChecked(aiNode* node, const char* prefix,
+        unsigned int len,
+        std::vector<SceneHelper>& input,
+        unsigned int cur);
+
+    // -------------------------------------------------------------------
+    // Add node identifiers to a hashing set
+    static void AddNodeHashes(aiNode* node, std::set<unsigned int>& hashes);
+
+
+    // -------------------------------------------------------------------
+    // Search for duplicate names
+    static bool FindNameMatch(const aiString& name,
+        std::vector<SceneHelper>& input, unsigned int cur);
+};
+
+}
+
+#endif // !! AI_SCENE_COMBINER_H_INC
diff --git a/engine/inc/assimp/SkeletonMeshBuilder.h b/engine/inc/assimp/SkeletonMeshBuilder.h
new file mode 100644
index 00000000..993d9c84
--- /dev/null
+++ b/engine/inc/assimp/SkeletonMeshBuilder.h
@@ -0,0 +1,125 @@
+/** Helper class to construct a dummy mesh for file formats containing only motion data */
+
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file SkeletonMeshBuilder.h
+ *  Declares SkeletonMeshBuilder, a tiny utility to build dummy meshes
+ *  for animation skeletons.
+ */
+
+#ifndef AI_SKELETONMESHBUILDER_H_INC
+#define AI_SKELETONMESHBUILDER_H_INC
+
+#include <vector>
+#include <assimp/mesh.h>
+
+struct aiMaterial;
+struct aiScene;
+struct aiNode;
+
+namespace Assimp    {
+
+// ---------------------------------------------------------------------------
+/**
+ * This little helper class constructs a dummy mesh for a given scene
+ * the resembles the node hierarchy. This is useful for file formats
+ * that don't carry any mesh data but only animation data.
+ */
+class ASSIMP_API SkeletonMeshBuilder
+{
+public:
+
+    // -------------------------------------------------------------------
+    /** The constructor processes the given scene and adds a mesh there.
+     *
+     * Does nothing if the scene already has mesh data.
+     * @param pScene The scene for which a skeleton mesh should be constructed.
+     * @param root The node to start with. NULL is the scene root
+     * @param bKnobsOnly Set this to true if you don't want the connectors
+     *   between the knobs representing the nodes.
+     */
+    SkeletonMeshBuilder( aiScene* pScene, aiNode* root = NULL,
+        bool bKnobsOnly = false);
+
+protected:
+
+    // -------------------------------------------------------------------
+    /** Recursively builds a simple mesh representation for the given node
+     * and also creates a joint for the node that affects this part of
+     * the mesh.
+     * @param pNode The node to build geometry for.
+     */
+    void CreateGeometry( const aiNode* pNode);
+
+    // -------------------------------------------------------------------
+    /** Creates the mesh from the internally accumulated stuff and returns it.
+     */
+    aiMesh* CreateMesh();
+
+    // -------------------------------------------------------------------
+    /** Creates a dummy material and returns it. */
+    aiMaterial* CreateMaterial();
+
+protected:
+    /** space to assemble the mesh data: points */
+    std::vector<aiVector3D> mVertices;
+
+    /** faces */
+    struct Face
+    {
+        unsigned int mIndices[3];
+        Face();
+        Face( unsigned int p0, unsigned int p1, unsigned int p2)
+        { mIndices[0] = p0; mIndices[1] = p1; mIndices[2] = p2; }
+    };
+    std::vector<Face> mFaces;
+
+    /** bones */
+    std::vector<aiBone*> mBones;
+
+    bool mKnobsOnly;
+};
+
+} // end of namespace Assimp
+
+#endif // AI_SKELETONMESHBUILDER_H_INC
diff --git a/engine/inc/assimp/SmoothingGroups.h b/engine/inc/assimp/SmoothingGroups.h
new file mode 100644
index 00000000..cdae578d
--- /dev/null
+++ b/engine/inc/assimp/SmoothingGroups.h
@@ -0,0 +1,110 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file Defines the helper data structures for importing 3DS files.
+http://www.jalix.org/ressources/graphics/3DS/_unofficials/3ds-unofficial.txt */
+
+#ifndef AI_SMOOTHINGGROUPS_H_INC
+#define AI_SMOOTHINGGROUPS_H_INC
+
+#include <assimp/vector3.h>
+#include <stdint.h>
+#include <vector>
+
+// ---------------------------------------------------------------------------
+/** Helper structure representing a face with smoothing groups assigned */
+struct FaceWithSmoothingGroup
+{
+    FaceWithSmoothingGroup()
+        : mIndices(),
+        iSmoothGroup(0)
+    {
+        // in debug builds set all indices to a common magic value
+#ifdef ASSIMP_BUILD_DEBUG
+        this->mIndices[0] = 0xffffffff;
+        this->mIndices[1] = 0xffffffff;
+        this->mIndices[2] = 0xffffffff;
+#endif
+    }
+
+
+    //! Indices. .3ds is using uint16. However, after
+    //! an unique vertex set has been generated,
+    //! individual index values might exceed 2^16
+    uint32_t mIndices[3];
+
+    //! specifies to which smoothing group the face belongs to
+    uint32_t iSmoothGroup;
+};
+
+// ---------------------------------------------------------------------------
+/** Helper structure representing a mesh whose faces have smoothing
+    groups assigned. This allows us to reuse the code for normal computations
+    from smoothings groups for several loaders (3DS, ASE). All of them
+    use face structures which inherit from #FaceWithSmoothingGroup,
+    but as they add extra members and need to be copied by value we
+    need to use a template here.
+    */
+template <class T>
+struct MeshWithSmoothingGroups
+{
+    //! Vertex positions
+    std::vector<aiVector3D> mPositions;
+
+    //! Face lists
+    std::vector<T> mFaces;
+
+    //! List of normal vectors
+    std::vector<aiVector3D> mNormals;
+};
+
+// ---------------------------------------------------------------------------
+/** Computes normal vectors for the mesh
+ */
+template <class T>
+void ComputeNormalsWithSmoothingsGroups(MeshWithSmoothingGroups<T>& sMesh);
+
+
+// include implementations
+#include "SmoothingGroups.inl"
+
+#endif // !! AI_SMOOTHINGGROUPS_H_INC
diff --git a/engine/inc/assimp/SmoothingGroups.inl b/engine/inc/assimp/SmoothingGroups.inl
new file mode 100644
index 00000000..84ea4a1b
--- /dev/null
+++ b/engine/inc/assimp/SmoothingGroups.inl
@@ -0,0 +1,138 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2012, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms, 
+with or without modification, are permitted provided that the following 
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file Generation of normal vectors basing on smoothing groups */
+
+#ifndef AI_SMOOTHINGGROUPS_INL_INCLUDED
+#define AI_SMOOTHINGGROUPS_INL_INCLUDED
+
+// internal headers
+#include <assimp/SGSpatialSort.h>
+
+// CRT header
+#include <algorithm>
+
+using namespace Assimp;
+
+// ------------------------------------------------------------------------------------------------
+template <class T>
+void ComputeNormalsWithSmoothingsGroups(MeshWithSmoothingGroups<T>& sMesh)
+{
+    // First generate face normals
+    sMesh.mNormals.resize(sMesh.mPositions.size(),aiVector3D());
+    for( unsigned int a = 0; a < sMesh.mFaces.size(); a++)
+    {
+        T& face = sMesh.mFaces[a];
+
+        aiVector3D* pV1 = &sMesh.mPositions[face.mIndices[0]];
+        aiVector3D* pV2 = &sMesh.mPositions[face.mIndices[1]];
+        aiVector3D* pV3 = &sMesh.mPositions[face.mIndices[2]];
+
+        aiVector3D pDelta1 = *pV2 - *pV1;
+        aiVector3D pDelta2 = *pV3 - *pV1;
+        aiVector3D vNor = pDelta1 ^ pDelta2;
+
+        for (unsigned int c = 0; c < 3;++c)
+            sMesh.mNormals[face.mIndices[c]] = vNor;
+    }
+
+    // calculate the position bounds so we have a reliable epsilon to check position differences against 
+    aiVector3D minVec( 1e10f, 1e10f, 1e10f), maxVec( -1e10f, -1e10f, -1e10f);
+    for( unsigned int a = 0; a < sMesh.mPositions.size(); a++)
+    {
+        minVec.x = std::min( minVec.x, sMesh.mPositions[a].x);
+        minVec.y = std::min( minVec.y, sMesh.mPositions[a].y);
+        minVec.z = std::min( minVec.z, sMesh.mPositions[a].z);
+        maxVec.x = std::max( maxVec.x, sMesh.mPositions[a].x);
+        maxVec.y = std::max( maxVec.y, sMesh.mPositions[a].y);
+        maxVec.z = std::max( maxVec.z, sMesh.mPositions[a].z);
+    }
+    const float posEpsilon = (maxVec - minVec).Length() * 1e-5f;
+    std::vector<aiVector3D> avNormals;
+    avNormals.resize(sMesh.mNormals.size());
+    
+    // now generate the spatial sort tree
+    SGSpatialSort sSort;
+    for( typename std::vector<T>::iterator i =  sMesh.mFaces.begin();
+        i != sMesh.mFaces.end();++i)
+    {
+        for (unsigned int c = 0; c < 3;++c)
+            sSort.Add(sMesh.mPositions[(*i).mIndices[c]],(*i).mIndices[c],(*i).iSmoothGroup);
+    }
+    sSort.Prepare();
+
+    std::vector<bool> vertexDone(sMesh.mPositions.size(),false);
+    for( typename std::vector<T>::iterator i =  sMesh.mFaces.begin();
+        i != sMesh.mFaces.end();++i)
+    {
+        std::vector<unsigned int> poResult;
+        for (unsigned int c = 0; c < 3;++c)
+        {
+            unsigned int idx = (*i).mIndices[c];
+            if (vertexDone[idx])continue;
+
+            sSort.FindPositions(sMesh.mPositions[idx],(*i).iSmoothGroup,
+                posEpsilon,poResult);
+
+            aiVector3D vNormals;
+            for (std::vector<unsigned int>::const_iterator
+                a =  poResult.begin();
+                a != poResult.end();++a)
+            {
+                vNormals += sMesh.mNormals[(*a)];
+            }
+            vNormals.NormalizeSafe();
+
+            // write back into all affected normals
+            for (std::vector<unsigned int>::const_iterator
+                a =  poResult.begin();
+                a != poResult.end();++a)
+            {
+                idx = *a;
+                avNormals [idx] = vNormals;
+                vertexDone[idx] = true;
+            }
+        }
+    }
+    sMesh.mNormals = avNormals;
+}
+
+#endif // !! AI_SMOOTHINGGROUPS_INL_INCLUDED
diff --git a/engine/inc/assimp/SpatialSort.h b/engine/inc/assimp/SpatialSort.h
new file mode 100644
index 00000000..4c45e95a
--- /dev/null
+++ b/engine/inc/assimp/SpatialSort.h
@@ -0,0 +1,174 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** Small helper classes to optimise finding vertizes close to a given location */
+#ifndef AI_SPATIALSORT_H_INC
+#define AI_SPATIALSORT_H_INC
+
+#include <vector>
+#include <assimp/types.h>
+
+namespace Assimp {
+
+// ------------------------------------------------------------------------------------------------
+/** A little helper class to quickly find all vertices in the epsilon environment of a given
+ * position. Construct an instance with an array of positions. The class stores the given positions
+ * by their indices and sorts them by their distance to an arbitrary chosen plane.
+ * You can then query the instance for all vertices close to a given position in an average O(log n)
+ * time, with O(n) worst case complexity when all vertices lay on the plane. The plane is chosen
+ * so that it avoids common planes in usual data sets. */
+// ------------------------------------------------------------------------------------------------
+class ASSIMP_API SpatialSort
+{
+public:
+
+    SpatialSort();
+
+    // ------------------------------------------------------------------------------------
+    /** Constructs a spatially sorted representation from the given position array.
+     * Supply the positions in its layout in memory, the class will only refer to them
+     * by index.
+     * @param pPositions Pointer to the first position vector of the array.
+     * @param pNumPositions Number of vectors to expect in that array.
+     * @param pElementOffset Offset in bytes from the beginning of one vector in memory
+     *   to the beginning of the next vector. */
+    SpatialSort( const aiVector3D* pPositions, unsigned int pNumPositions,
+        unsigned int pElementOffset);
+
+    /** Destructor */
+    ~SpatialSort();
+
+public:
+
+    // ------------------------------------------------------------------------------------
+    /** Sets the input data for the SpatialSort. This replaces existing data, if any.
+     *  The new data receives new indices in ascending order.
+     *
+     * @param pPositions Pointer to the first position vector of the array.
+     * @param pNumPositions Number of vectors to expect in that array.
+     * @param pElementOffset Offset in bytes from the beginning of one vector in memory
+     *   to the beginning of the next vector.
+     * @param pFinalize Specifies whether the SpatialSort's internal representation
+     *   is finalized after the new data has been added. Finalization is
+     *   required in order to use #FindPosition() or #GenerateMappingTable().
+     *   If you don't finalize yet, you can use #Append() to add data from
+     *   other sources.*/
+    void Fill( const aiVector3D* pPositions, unsigned int pNumPositions,
+        unsigned int pElementOffset,
+        bool pFinalize = true);
+
+
+    // ------------------------------------------------------------------------------------
+    /** Same as #Fill(), except the method appends to existing data in the #SpatialSort. */
+    void Append( const aiVector3D* pPositions, unsigned int pNumPositions,
+        unsigned int pElementOffset,
+        bool pFinalize = true);
+
+
+    // ------------------------------------------------------------------------------------
+    /** Finalize the spatial hash data structure. This can be useful after
+     *  multiple calls to #Append() with the pFinalize parameter set to false.
+     *  This is finally required before one of #FindPositions() and #GenerateMappingTable()
+     *  can be called to query the spatial sort.*/
+    void Finalize();
+
+    // ------------------------------------------------------------------------------------
+    /** Returns an iterator for all positions close to the given position.
+     * @param pPosition The position to look for vertices.
+     * @param pRadius Maximal distance from the position a vertex may have to be counted in.
+     * @param poResults The container to store the indices of the found positions.
+     *   Will be emptied by the call so it may contain anything.
+     * @return An iterator to iterate over all vertices in the given area.*/
+    void FindPositions( const aiVector3D& pPosition, ai_real pRadius,
+        std::vector<unsigned int>& poResults) const;
+
+    // ------------------------------------------------------------------------------------
+    /** Fills an array with indices of all positions identical to the given position. In
+     *  opposite to FindPositions(), not an epsilon is used but a (very low) tolerance of
+     *  four floating-point units.
+     * @param pPosition The position to look for vertices.
+     * @param poResults The container to store the indices of the found positions.
+     *   Will be emptied by the call so it may contain anything.*/
+    void FindIdenticalPositions( const aiVector3D& pPosition,
+        std::vector<unsigned int>& poResults) const;
+
+    // ------------------------------------------------------------------------------------
+    /** Compute a table that maps each vertex ID referring to a spatially close
+     *  enough position to the same output ID. Output IDs are assigned in ascending order
+     *  from 0...n.
+     * @param fill Will be filled with numPositions entries.
+     * @param pRadius Maximal distance from the position a vertex may have to
+     *   be counted in.
+     *  @return Number of unique vertices (n).  */
+    unsigned int GenerateMappingTable(std::vector<unsigned int>& fill,
+        ai_real pRadius) const;
+
+protected:
+    /** Normal of the sorting plane, normalized. The center is always at (0, 0, 0) */
+    aiVector3D mPlaneNormal;
+
+    /** An entry in a spatially sorted position array. Consists of a vertex index,
+     * its position and its pre-calculated distance from the reference plane */
+    struct Entry {
+        unsigned int mIndex; ///< The vertex referred by this entry
+        aiVector3D mPosition; ///< Position
+        ai_real mDistance; ///< Distance of this vertex to the sorting plane
+
+        Entry()
+        : mIndex( 999999999 ), mPosition(), mDistance( 99999. ) {
+            // empty        
+        }
+        Entry( unsigned int pIndex, const aiVector3D& pPosition, ai_real pDistance)
+        : mIndex( pIndex), mPosition( pPosition), mDistance( pDistance) {
+            // empty
+        }
+
+        bool operator < (const Entry& e) const { return mDistance < e.mDistance; }
+    };
+
+    // all positions, sorted by distance to the sorting plane
+    std::vector<Entry> mPositions;
+};
+
+} // end of namespace Assimp
+
+#endif // AI_SPATIALSORT_H_INC
diff --git a/engine/inc/assimp/StandardShapes.h b/engine/inc/assimp/StandardShapes.h
new file mode 100644
index 00000000..fdf1b034
--- /dev/null
+++ b/engine/inc/assimp/StandardShapes.h
@@ -0,0 +1,200 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file Declares a helper class, "StandardShapes" which generates
+ *  vertices for standard shapes, such as cylnders, cones, spheres ..
+ */
+#ifndef AI_STANDARD_SHAPES_H_INC
+#define AI_STANDARD_SHAPES_H_INC
+
+#include <assimp/vector3.h>
+#include <vector>
+
+struct aiMesh;
+
+namespace Assimp    {
+
+// ---------------------------------------------------------------------------
+/** \brief Helper class to generate vertex buffers for standard geometric
+ *  shapes, such as cylinders, cones, boxes, spheres, elipsoids ... .
+ */
+class ASSIMP_API StandardShapes
+{
+    // class cannot be instanced
+    StandardShapes() {}
+
+public:
+
+
+    // ----------------------------------------------------------------
+    /** Generates a mesh from an array of vertex positions.
+     *
+     *  @param positions List of vertex positions
+     *  @param numIndices Number of indices per primitive
+     *  @return Output mesh
+     */
+    static aiMesh* MakeMesh(const std::vector<aiVector3D>& positions,
+        unsigned int numIndices);
+
+
+    static aiMesh* MakeMesh ( unsigned int (*GenerateFunc)
+        (std::vector<aiVector3D>&));
+
+    static aiMesh* MakeMesh ( unsigned int (*GenerateFunc)
+        (std::vector<aiVector3D>&, bool));
+
+    static aiMesh* MakeMesh ( unsigned int n,  void (*GenerateFunc)
+        (unsigned int,std::vector<aiVector3D>&));
+
+    // ----------------------------------------------------------------
+    /** @brief Generates a hexahedron (cube)
+     *
+     *  Hexahedrons can be scaled on all axes.
+     *  @param positions Receives output triangles.
+     *  @param polygons If you pass true here quads will be returned
+     *  @return Number of vertices per face
+     */
+    static unsigned int MakeHexahedron(
+        std::vector<aiVector3D>& positions,
+        bool polygons = false);
+
+    // ----------------------------------------------------------------
+    /** @brief Generates an icosahedron
+     *
+     *  @param positions Receives output triangles.
+     *  @return Number of vertices per face
+     */
+    static unsigned int MakeIcosahedron(
+        std::vector<aiVector3D>& positions);
+
+
+    // ----------------------------------------------------------------
+    /** @brief Generates a dodecahedron
+     *
+     *  @param positions Receives output triangles
+     *  @param polygons If you pass true here pentagons will be returned
+     *  @return Number of vertices per face
+     */
+    static unsigned int MakeDodecahedron(
+        std::vector<aiVector3D>& positions,
+        bool polygons = false);
+
+
+    // ----------------------------------------------------------------
+    /** @brief Generates an octahedron
+     *
+     *  @param positions Receives output triangles.
+     *  @return Number of vertices per face
+     */
+    static unsigned int MakeOctahedron(
+        std::vector<aiVector3D>& positions);
+
+
+    // ----------------------------------------------------------------
+    /** @brief Generates a tetrahedron
+     *
+     *  @param positions Receives output triangles.
+     *  @return Number of vertices per face
+     */
+    static unsigned int MakeTetrahedron(
+        std::vector<aiVector3D>& positions);
+
+
+
+    // ----------------------------------------------------------------
+    /** @brief Generates a sphere
+     *
+     *  @param tess Number of subdivions - 0 generates a octahedron
+     *  @param positions Receives output triangles.
+     */
+    static void MakeSphere(unsigned int tess,
+        std::vector<aiVector3D>& positions);
+
+
+    // ----------------------------------------------------------------
+    /** @brief Generates a cone or a cylinder, either open or closed.
+     *
+     *  @code
+     *
+     *       |-----|       <- radius 1
+     *
+     *        __x__        <- ]               ^
+     *       /     \          | height        |
+     *      /       \         |               Y
+     *     /         \        |
+     *    /           \       |
+     *   /______x______\   <- ] <- end cap
+     *
+     *   |-------------|   <- radius 2
+     *
+     *  @endcode
+     *
+     *  @param height Height of the cone
+     *  @param radius1 First radius
+     *  @param radius2 Second radius
+     *  @param tess Number of triangles.
+     *  @param bOpened true for an open cone/cylinder. An open shape has
+     *    no 'end caps'
+     *  @param positions Receives output triangles
+     */
+    static void MakeCone(ai_real height,ai_real radius1,
+        ai_real radius2,unsigned int tess,
+        std::vector<aiVector3D>& positions,bool bOpen= false);
+
+
+    // ----------------------------------------------------------------
+    /** @brief Generates a flat circle
+     *
+     *  The circle is constructed in the planned formed by the x,z
+     *  axes of the cartesian coordinate system.
+     *
+     *  @param radius Radius of the circle
+     *  @param tess Number of segments.
+     *  @param positions Receives output triangles.
+     */
+    static void MakeCircle(ai_real radius, unsigned int tess,
+        std::vector<aiVector3D>& positions);
+
+};
+} // ! Assimp
+
+#endif // !! AI_STANDARD_SHAPES_H_INC
diff --git a/engine/inc/assimp/StreamReader.h b/engine/inc/assimp/StreamReader.h
new file mode 100644
index 00000000..3fab00ad
--- /dev/null
+++ b/engine/inc/assimp/StreamReader.h
@@ -0,0 +1,348 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file Defines the StreamReader class which reads data from
+ *  a binary stream with a well-defined endianness.
+ */
+
+#ifndef AI_STREAMREADER_H_INCLUDED
+#define AI_STREAMREADER_H_INCLUDED
+
+#include "ByteSwapper.h"
+#include "Exceptional.h"
+#include <memory>
+#include <assimp/IOStream.hpp>
+#include <assimp/Defines.h>
+
+namespace Assimp {
+
+// --------------------------------------------------------------------------------------------
+/** Wrapper class around IOStream to allow for consistent reading of binary data in both
+ *  little and big endian format. Don't attempt to instance the template directly. Use
+ *  StreamReaderLE to read from a little-endian stream and StreamReaderBE to read from a
+ *  BE stream. The class expects that the endianness of any input data is known at
+ *  compile-time, which should usually be true (#BaseImporter::ConvertToUTF8 implements
+ *  runtime endianness conversions for text files).
+ *
+ *  XXX switch from unsigned int for size types to size_t? or ptrdiff_t?*/
+// --------------------------------------------------------------------------------------------
+template <bool SwapEndianess = false, bool RuntimeSwitch = false>
+class StreamReader
+{
+public:
+    // FIXME: use these data types throughout the whole library,
+    // then change them to 64 bit values :-)
+
+    typedef int diff;
+    typedef unsigned int pos;
+
+public:
+    // ---------------------------------------------------------------------
+    /** Construction from a given stream with a well-defined endianness.
+     *
+     *  The StreamReader holds a permanent strong reference to the
+     *  stream, which is released upon destruction.
+     *  @param stream Input stream. The stream is not restarted if
+     *    its file pointer is not at 0. Instead, the stream reader
+     *    reads from the current position to the end of the stream.
+     *  @param le If @c RuntimeSwitch is true: specifies whether the
+     *    stream is in little endian byte order. Otherwise the
+     *    endianness information is contained in the @c SwapEndianess
+     *    template parameter and this parameter is meaningless.  */
+    StreamReader(std::shared_ptr<IOStream> stream, bool le = false)
+        : stream(stream)
+        , le(le)
+    {
+        ai_assert(stream);
+        InternBegin();
+    }
+
+    // ---------------------------------------------------------------------
+    StreamReader(IOStream* stream, bool le = false)
+        : stream(std::shared_ptr<IOStream>(stream))
+        , le(le)
+    {
+        ai_assert(stream);
+        InternBegin();
+    }
+
+    // ---------------------------------------------------------------------
+    ~StreamReader() {
+        delete[] buffer;
+    }
+
+public:
+
+    // deprecated, use overloaded operator>> instead
+
+    // ---------------------------------------------------------------------
+    /** Read a float from the stream  */
+    float GetF4()
+    {
+        return Get<float>();
+    }
+
+    // ---------------------------------------------------------------------
+    /** Read a double from the stream  */
+    double GetF8()  {
+        return Get<double>();
+    }
+
+    // ---------------------------------------------------------------------
+    /** Read a signed 16 bit integer from the stream */
+    int16_t GetI2() {
+        return Get<int16_t>();
+    }
+
+    // ---------------------------------------------------------------------
+    /** Read a signed 8 bit integer from the stream */
+    int8_t GetI1()  {
+        return Get<int8_t>();
+    }
+
+    // ---------------------------------------------------------------------
+    /** Read an signed 32 bit integer from the stream */
+    int32_t GetI4() {
+        return Get<int32_t>();
+    }
+
+    // ---------------------------------------------------------------------
+    /** Read a signed 64 bit integer from the stream */
+    int64_t GetI8() {
+        return Get<int64_t>();
+    }
+
+    // ---------------------------------------------------------------------
+    /** Read a unsigned 16 bit integer from the stream */
+    uint16_t GetU2()    {
+        return Get<uint16_t>();
+    }
+
+    // ---------------------------------------------------------------------
+    /** Read a unsigned 8 bit integer from the stream */
+    uint8_t GetU1() {
+        return Get<uint8_t>();
+    }
+
+    // ---------------------------------------------------------------------
+    /** Read an unsigned 32 bit integer from the stream */
+    uint32_t GetU4()    {
+        return Get<uint32_t>();
+    }
+
+    // ---------------------------------------------------------------------
+    /** Read a unsigned 64 bit integer from the stream */
+    uint64_t GetU8()    {
+        return Get<uint64_t>();
+    }
+
+public:
+    // ---------------------------------------------------------------------
+    /** Get the remaining stream size (to the end of the stream) */
+    unsigned int GetRemainingSize() const {
+        return (unsigned int)(end - current);
+    }
+
+    // ---------------------------------------------------------------------
+    /** Get the remaining stream size (to the current read limit). The
+     *  return value is the remaining size of the stream if no custom
+     *  read limit has been set. */
+    unsigned int GetRemainingSizeToLimit() const {
+        return (unsigned int)(limit - current);
+    }
+
+    // ---------------------------------------------------------------------
+    /** Increase the file pointer (relative seeking)  */
+    void IncPtr(intptr_t plus)    {
+        current += plus;
+        if (current > limit) {
+            throw DeadlyImportError("End of file or read limit was reached");
+        }
+    }
+
+    // ---------------------------------------------------------------------
+    /** Get the current file pointer */
+    int8_t* GetPtr() const  {
+        return current;
+    }
+
+    // ---------------------------------------------------------------------
+    /** Set current file pointer (Get it from #GetPtr). This is if you
+     *  prefer to do pointer arithmetics on your own or want to copy
+     *  large chunks of data at once.
+     *  @param p The new pointer, which is validated against the size
+     *    limit and buffer boundaries. */
+    void SetPtr(int8_t* p)  {
+        current = p;
+        if (current > limit || current < buffer) {
+            throw DeadlyImportError("End of file or read limit was reached");
+        }
+    }
+
+    // ---------------------------------------------------------------------
+    /** Copy n bytes to an external buffer
+     *  @param out Destination for copying
+     *  @param bytes Number of bytes to copy */
+    void CopyAndAdvance(void* out, size_t bytes)    {
+        int8_t* ur = GetPtr();
+        SetPtr(ur+bytes); // fire exception if eof
+
+        ::memcpy(out,ur,bytes);
+    }
+
+    // ---------------------------------------------------------------------
+    /** Get the current offset from the beginning of the file */
+    int GetCurrentPos() const   {
+        return (unsigned int)(current - buffer);
+    }
+
+    void SetCurrentPos(size_t pos) {
+        SetPtr(buffer + pos);
+    }
+
+    // ---------------------------------------------------------------------
+    /** Setup a temporary read limit
+     *
+     *  @param limit Maximum number of bytes to be read from
+     *    the beginning of the file. Specifying UINT_MAX
+     *    resets the limit to the original end of the stream.
+     *  Returns the previously set limit. */
+    unsigned int SetReadLimit(unsigned int _limit)  {
+        unsigned int prev = GetReadLimit();
+        if (UINT_MAX == _limit) {
+            limit = end;
+            return prev;
+        }
+
+        limit = buffer + _limit;
+        if (limit > end) {
+            throw DeadlyImportError("StreamReader: Invalid read limit");
+        }
+        return prev;
+    }
+
+    // ---------------------------------------------------------------------
+    /** Get the current read limit in bytes. Reading over this limit
+     *  accidentally raises an exception.  */
+    unsigned int GetReadLimit() const    {
+        return (unsigned int)(limit - buffer);
+    }
+
+    // ---------------------------------------------------------------------
+    /** Skip to the read limit in bytes. Reading over this limit
+     *  accidentally raises an exception. */
+    void SkipToReadLimit()  {
+        current = limit;
+    }
+
+    // ---------------------------------------------------------------------
+    /** overload operator>> and allow chaining of >> ops. */
+    template <typename T>
+    StreamReader& operator >> (T& f) {
+        f = Get<T>();
+        return *this;
+    }
+
+    // ---------------------------------------------------------------------
+    /** Generic read method. ByteSwap::Swap(T*) *must* be defined */
+    template <typename T>
+    T Get() {
+        if ( current + sizeof(T) > limit) {
+            throw DeadlyImportError("End of file or stream limit was reached");
+        }
+
+        T f;
+        ::memcpy (&f, current, sizeof(T));
+        Intern::Getter<SwapEndianess,T,RuntimeSwitch>() (&f,le);
+        current += sizeof(T);
+
+        return f;
+    }
+
+private:
+    // ---------------------------------------------------------------------
+    void InternBegin() {
+        if (!stream) {
+            // in case someone wonders: StreamReader is frequently invoked with
+            // no prior validation whether the input stream is valid. Since
+            // no one bothers changing the error message, this message here
+            // is passed down to the caller and 'unable to open file'
+            // simply describes best what happened.
+            throw DeadlyImportError("StreamReader: Unable to open file");
+        }
+
+        const size_t s = stream->FileSize() - stream->Tell();
+        if (!s) {
+            throw DeadlyImportError("StreamReader: File is empty or EOF is already reached");
+        }
+
+        current = buffer = new int8_t[s];
+        const size_t read = stream->Read(current,1,s);
+        // (read < s) can only happen if the stream was opened in text mode, in which case FileSize() is not reliable
+        ai_assert(read <= s);
+        end = limit = &buffer[read];
+    }
+
+private:
+    std::shared_ptr<IOStream> stream;
+    int8_t *buffer, *current, *end, *limit;
+    bool le;
+};
+
+// --------------------------------------------------------------------------------------------
+// `static` StreamReaders. Their byte order is fixed and they might be a little bit faster.
+#ifdef AI_BUILD_BIG_ENDIAN
+    typedef StreamReader<true>  StreamReaderLE;
+    typedef StreamReader<false> StreamReaderBE;
+#else
+    typedef StreamReader<true>  StreamReaderBE;
+    typedef StreamReader<false> StreamReaderLE;
+#endif
+
+// `dynamic` StreamReader. The byte order of the input data is specified in the
+// c'tor. This involves runtime branching and might be a little bit slower.
+typedef StreamReader<true,true> StreamReaderAny;
+
+} // end namespace Assimp
+
+#endif // !! AI_STREAMREADER_H_INCLUDED
diff --git a/engine/inc/assimp/StreamWriter.h b/engine/inc/assimp/StreamWriter.h
new file mode 100644
index 00000000..deb35fb4
--- /dev/null
+++ b/engine/inc/assimp/StreamWriter.h
@@ -0,0 +1,303 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file Defines the StreamWriter class which writes data to
+ *  a binary stream with a well-defined endianness. */
+
+#ifndef AI_STREAMWRITER_H_INCLUDED
+#define AI_STREAMWRITER_H_INCLUDED
+
+#include "ByteSwapper.h"
+#include <assimp/IOStream.hpp>
+
+#include <memory>
+#include <vector>
+
+namespace Assimp {
+
+// --------------------------------------------------------------------------------------------
+/** Wrapper class around IOStream to allow for consistent writing of binary data in both
+ *  little and big endian format. Don't attempt to instance the template directly. Use
+ *  StreamWriterLE to write to a little-endian stream and StreamWriterBE to write to a
+ *  BE stream. Alternatively, there is StreamWriterAny if the endianness of the output
+ *  stream is to be determined at runtime.
+ */
+// --------------------------------------------------------------------------------------------
+template <bool SwapEndianess = false, bool RuntimeSwitch = false>
+class StreamWriter
+{
+    enum {
+        INITIAL_CAPACITY = 1024
+    };
+
+public:
+
+    // ---------------------------------------------------------------------
+    /** Construction from a given stream with a well-defined endianness.
+     *
+     *  The StreamReader holds a permanent strong reference to the
+     *  stream, which is released upon destruction.
+     *  @param stream Input stream. The stream is not re-seeked and writing
+          continues at the current position of the stream cursor.
+     *  @param le If @c RuntimeSwitch is true: specifies whether the
+     *    stream is in little endian byte order. Otherwise the
+     *    endianness information is defined by the @c SwapEndianess
+     *    template parameter and this parameter is meaningless.  */
+    StreamWriter(std::shared_ptr<IOStream> stream, bool le = false)
+        : stream(stream)
+        , le(le)
+        , cursor()
+    {
+        ai_assert(stream);
+        buffer.reserve(INITIAL_CAPACITY);
+    }
+
+    // ---------------------------------------------------------------------
+    StreamWriter(IOStream* stream, bool le = false)
+        : stream(std::shared_ptr<IOStream>(stream))
+        , le(le)
+        , cursor()
+    {
+        ai_assert(stream);
+        buffer.reserve(INITIAL_CAPACITY);
+    }
+
+    // ---------------------------------------------------------------------
+    ~StreamWriter() {
+        stream->Write(buffer.data(), 1, buffer.size());
+        stream->Flush();
+    }
+
+public:
+
+    // ---------------------------------------------------------------------
+    /** Flush the contents of the internal buffer, and the output IOStream */
+    void Flush()
+    {
+        stream->Write(buffer.data(), 1, buffer.size());
+        stream->Flush();
+        buffer.clear();
+        cursor = 0;
+    }
+
+    // ---------------------------------------------------------------------
+    /** Seek to the given offset / origin in the output IOStream.
+     *
+     *  Flushes the internal buffer and the output IOStream prior to seeking. */
+    aiReturn Seek(size_t pOffset, aiOrigin pOrigin=aiOrigin_SET)
+    {
+        Flush();
+        return stream->Seek(pOffset, pOrigin);
+    }
+
+    // ---------------------------------------------------------------------
+    /** Tell the current position in the output IOStream.
+     *
+     *  First flushes the internal buffer and the output IOStream. */
+    size_t Tell()
+    {
+        Flush();
+        return stream->Tell();
+    }
+
+public:
+
+    // ---------------------------------------------------------------------
+    /** Write a float to the stream  */
+    void PutF4(float f)
+    {
+        Put(f);
+    }
+
+    // ---------------------------------------------------------------------
+    /** Write a double to the stream  */
+    void PutF8(double d)    {
+        Put(d);
+    }
+
+    // ---------------------------------------------------------------------
+    /** Write a signed 16 bit integer to the stream */
+    void PutI2(int16_t n)   {
+        Put(n);
+    }
+
+    // ---------------------------------------------------------------------
+    /** Write a signed 8 bit integer to the stream */
+    void PutI1(int8_t n)    {
+        Put(n);
+    }
+
+    // ---------------------------------------------------------------------
+    /** Write an signed 32 bit integer to the stream */
+    void PutI4(int32_t n)   {
+        Put(n);
+    }
+
+    // ---------------------------------------------------------------------
+    /** Write a signed 64 bit integer to the stream */
+    void PutI8(int64_t n)   {
+        Put(n);
+    }
+
+    // ---------------------------------------------------------------------
+    /** Write a unsigned 16 bit integer to the stream */
+    void PutU2(uint16_t n)  {
+        Put(n);
+    }
+
+    // ---------------------------------------------------------------------
+    /** Write a unsigned 8 bit integer to the stream */
+    void PutU1(uint8_t n)   {
+        Put(n);
+    }
+
+    // ---------------------------------------------------------------------
+    /** Write an unsigned 32 bit integer to the stream */
+    void PutU4(uint32_t n)  {
+        Put(n);
+    }
+
+    // ---------------------------------------------------------------------
+    /** Write a unsigned 64 bit integer to the stream */
+    void PutU8(uint64_t n)  {
+        Put(n);
+    }
+
+    // ---------------------------------------------------------------------
+    /** Write a single character to the stream */
+    void PutChar(char c)    {
+        Put(c);
+    }
+
+    // ---------------------------------------------------------------------
+    /** Write an aiString to the stream */
+    void PutString(const aiString& s)
+    {
+        // as Put(T f) below
+        if (cursor + s.length >= buffer.size()) {
+            buffer.resize(cursor + s.length);
+        }
+        void* dest = &buffer[cursor];
+        ::memcpy(dest, s.C_Str(), s.length);
+        cursor += s.length;
+    }
+
+    // ---------------------------------------------------------------------
+    /** Write a std::string to the stream */
+    void PutString(const std::string& s)
+    {
+        // as Put(T f) below
+        if (cursor + s.size() >= buffer.size()) {
+            buffer.resize(cursor + s.size());
+        }
+        void* dest = &buffer[cursor];
+        ::memcpy(dest, s.c_str(), s.size());
+        cursor += s.size();
+    }
+
+public:
+
+    // ---------------------------------------------------------------------
+    /** overload operator<< and allow chaining of MM ops. */
+    template <typename T>
+    StreamWriter& operator << (T f) {
+        Put(f);
+        return *this;
+    }
+
+    // ---------------------------------------------------------------------
+    std::size_t GetCurrentPos() const {
+        return cursor;
+    }
+
+    // ---------------------------------------------------------------------
+    void SetCurrentPos(std::size_t new_cursor) {
+        cursor = new_cursor;
+    }
+
+    // ---------------------------------------------------------------------
+    /** Generic write method. ByteSwap::Swap(T*) *must* be defined */
+    template <typename T>
+    void Put(T f)   {
+        Intern :: Getter<SwapEndianess,T,RuntimeSwitch>() (&f, le);
+
+        if (cursor + sizeof(T) >= buffer.size()) {
+            buffer.resize(cursor + sizeof(T));
+        }
+
+        void* dest = &buffer[cursor];
+
+        // reinterpret_cast + assignment breaks strict aliasing rules
+        // and generally causes trouble on platforms such as ARM that
+        // do not silently ignore alignment faults.
+        ::memcpy(dest, &f, sizeof(T));
+        cursor += sizeof(T);
+    }
+
+private:
+
+    std::shared_ptr<IOStream> stream;
+    bool le;
+
+    std::vector<uint8_t> buffer;
+    std::size_t cursor;
+};
+
+
+// --------------------------------------------------------------------------------------------
+// `static` StreamWriter. Their byte order is fixed and they might be a little bit faster.
+#ifdef AI_BUILD_BIG_ENDIAN
+    typedef StreamWriter<true>  StreamWriterLE;
+    typedef StreamWriter<false> StreamWriterBE;
+#else
+    typedef StreamWriter<true>  StreamWriterBE;
+    typedef StreamWriter<false> StreamWriterLE;
+#endif
+
+// `dynamic` StreamWriter. The byte order of the input data is specified in the
+// c'tor. This involves runtime branching and might be a little bit slower.
+typedef StreamWriter<true,true> StreamWriterAny;
+
+} // end namespace Assimp
+
+#endif // !! AI_STREAMWriter_H_INCLUDED
diff --git a/engine/inc/assimp/StringComparison.h b/engine/inc/assimp/StringComparison.h
new file mode 100644
index 00000000..aea7f001
--- /dev/null
+++ b/engine/inc/assimp/StringComparison.h
@@ -0,0 +1,233 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file Definition of platform independent string workers:
+
+   ASSIMP_itoa10
+   ASSIMP_stricmp
+   ASSIMP_strincmp
+
+   These functions are not consistently available on all platforms,
+   or the provided implementations behave too differently.
+*/
+#ifndef INCLUDED_AI_STRING_WORKERS_H
+#define INCLUDED_AI_STRING_WORKERS_H
+
+#include <assimp/ai_assert.h>
+#include <assimp/defs.h>
+#include "StringComparison.h"
+
+#include <string.h>
+#include <stdint.h>
+#include <string>
+
+namespace Assimp    {
+
+// -------------------------------------------------------------------------------
+/** @brief itoa with a fixed base 10
+ * 'itoa' is not consistently available on all platforms so it is quite useful
+ * to have a small replacement function here. No need to use a full sprintf()
+ * if we just want to print a number ...
+ * @param out Output buffer
+ * @param max Maximum number of characters to be written, including '\0'.
+ *   This parameter may not be 0.
+ * @param number Number to be written
+ * @return Length of the output string, excluding the '\0'
+ */
+AI_FORCE_INLINE
+unsigned int ASSIMP_itoa10( char* out, unsigned int max, int32_t number) {
+    ai_assert(NULL != out);
+
+    // write the unary minus to indicate we have a negative number
+    unsigned int written = 1u;
+    if (number < 0 && written < max)    {
+        *out++ = '-';
+        ++written;
+        number = -number;
+    }
+
+    // We begin with the largest number that is not zero.
+    int32_t cur = 1000000000; // 2147483648
+    bool mustPrint = false;
+    while (written < max)   {
+
+        const unsigned int digit = number / cur;
+        if (mustPrint || digit > 0 || 1 == cur) {
+            // print all future zeroe's from now
+            mustPrint = true;
+
+            *out++ = '0'+static_cast<char>(digit);
+
+            ++written;
+            number -= digit*cur;
+            if (1 == cur) {
+                break;
+            }
+        }
+        cur /= 10;
+    }
+
+    // append a terminal zero
+    *out++ = '\0';
+    return written-1;
+}
+
+// -------------------------------------------------------------------------------
+/** @brief itoa with a fixed base 10 (Secure template overload)
+ *  The compiler should choose this function if he or she is able to determine the
+ *  size of the array automatically.
+ */
+template <size_t length>
+AI_FORCE_INLINE
+unsigned int ASSIMP_itoa10( char(& out)[length], int32_t number) {
+    return ASSIMP_itoa10(out,length,number);
+}
+
+// -------------------------------------------------------------------------------
+/** @brief Helper function to do platform independent string comparison.
+ *
+ *  This is required since stricmp() is not consistently available on
+ *  all platforms. Some platforms use the '_' prefix, others don't even
+ *  have such a function.
+ *
+ *  @param s1 First input string
+ *  @param s2 Second input string
+ *  @return 0 if the given strings are identical
+ */
+AI_FORCE_INLINE
+int ASSIMP_stricmp(const char *s1, const char *s2) {
+    ai_assert( NULL != s1 );
+    ai_assert( NULL != s2 );
+
+#if (defined _MSC_VER)
+
+    return ::_stricmp(s1,s2);
+#elif defined( __GNUC__ )
+
+    return ::strcasecmp(s1,s2);
+#else
+
+    char c1, c2;
+    do  {
+        c1 = tolower(*s1++);
+        c2 = tolower(*s2++);
+    }
+    while ( c1 && (c1 == c2) );
+    return c1 - c2;
+#endif
+}
+
+// -------------------------------------------------------------------------------
+/** @brief Case independent comparison of two std::strings
+ *
+ *  @param a First  string
+ *  @param b Second string
+ *  @return 0 if a == b
+ */
+AI_FORCE_INLINE
+int ASSIMP_stricmp(const std::string& a, const std::string& b) {
+    int i = (int)b.length()-(int)a.length();
+    return (i ? i : ASSIMP_stricmp(a.c_str(),b.c_str()));
+}
+
+// -------------------------------------------------------------------------------
+/** @brief Helper function to do platform independent string comparison.
+ *
+ *  This is required since strincmp() is not consistently available on
+ *  all platforms. Some platforms use the '_' prefix, others don't even
+ *  have such a function.
+ *
+ *  @param s1 First input string
+ *  @param s2 Second input string
+ *  @param n Macimum number of characters to compare
+ *  @return 0 if the given strings are identical
+ */
+AI_FORCE_INLINE
+int ASSIMP_strincmp(const char *s1, const char *s2, unsigned int n) {
+    ai_assert( NULL != s1 );
+    ai_assert( NULL != s2 );
+    if ( !n ) {
+        return 0;
+    }
+
+#if (defined _MSC_VER)
+
+    return ::_strnicmp(s1,s2,n);
+
+#elif defined( __GNUC__ )
+
+    return ::strncasecmp(s1,s2, n);
+
+#else
+    char c1, c2;
+    unsigned int p = 0;
+    do
+    {
+        if (p++ >= n)return 0;
+        c1 = tolower(*s1++);
+        c2 = tolower(*s2++);
+    }
+    while ( c1 && (c1 == c2) );
+
+    return c1 - c2;
+#endif
+}
+
+
+// -------------------------------------------------------------------------------
+/** @brief Evaluates an integer power
+ *
+ * todo: move somewhere where it fits better in than here
+ */
+AI_FORCE_INLINE
+unsigned int integer_pow( unsigned int base, unsigned int power ) {
+    unsigned int res = 1;
+    for ( unsigned int i = 0; i < power; ++i ) {
+        res *= base;
+    }
+
+    return res;
+}
+
+} // end of namespace
+
+#endif // !  AI_STRINGCOMPARISON_H_INC
diff --git a/engine/inc/assimp/StringUtils.h b/engine/inc/assimp/StringUtils.h
new file mode 100644
index 00000000..906898b5
--- /dev/null
+++ b/engine/inc/assimp/StringUtils.h
@@ -0,0 +1,143 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+#ifndef INCLUDED_AI_STRINGUTILS_H
+#define INCLUDED_AI_STRINGUTILS_H
+
+#include <assimp/defs.h>
+
+#include <sstream>
+#include <stdarg.h>
+#include <cstdlib>
+
+///	@fn		ai_snprintf
+///	@brief	The portable version of the function snprintf ( C99 standard ), which works on visual studio compilers 2013 and earlier.
+///	@param	outBuf		The buffer to write in
+///	@param	size		The buffer size
+///	@param	format		The format string
+///	@param	ap			The additional arguments.
+///	@return	The number of written characters if the buffer size was big enough. If an encoding error occurs, a negative number is returned.
+#if defined(_MSC_VER) && _MSC_VER < 1900
+
+    AI_FORCE_INLINE
+    int c99_ai_vsnprintf(char *outBuf, size_t size, const char *format, va_list ap) {
+		int count(-1);
+		if (0 != size) {
+			count = _vsnprintf_s(outBuf, size, _TRUNCATE, format, ap);
+		}
+		if (count == -1) {
+			count = _vscprintf(format, ap);
+		}
+
+		return count;
+	}
+
+    AI_FORCE_INLINE
+    int ai_snprintf(char *outBuf, size_t size, const char *format, ...) {
+		int count;
+		va_list ap;
+
+		va_start(ap, format);
+		count = c99_ai_vsnprintf(outBuf, size, format, ap);
+		va_end(ap);
+
+		return count;
+	}
+
+#else
+#   define ai_snprintf snprintf
+#endif
+
+///	@fn		to_string
+///	@brief	The portable version of to_string ( some gcc-versions on embedded devices are not supporting this).
+///	@param	value   The value to write into the std::string.
+///	@return	The value as a std::string
+template <typename T>
+AI_FORCE_INLINE
+std::string to_string( T value ) {
+    std::ostringstream os;
+    os << value;
+
+    return os.str();
+}
+
+///	@fn		ai_strtof
+///	@brief	The portable version of strtof.
+///	@param	begin   The first character of the string.
+/// @param  end     The last character
+///	@return	The float value, 0.0f in cas of an error.
+AI_FORCE_INLINE
+float ai_strtof( const char *begin, const char *end ) {
+    if ( nullptr == begin ) {
+        return 0.0f;
+    }
+    float val( 0.0f );
+    if ( nullptr == end ) {
+        val = static_cast< float >( ::atof( begin ) );
+    } else {
+        std::string::size_type len( end - begin );
+        std::string token( begin, len );
+        val = static_cast< float >( ::atof( token.c_str() ) );
+    }
+
+    return val;
+}
+
+///	@fn		DecimalToHexa
+///	@brief	The portable to convert a decimal value into a hexadecimal string.
+///	@param	toConvert   Value to convert
+///	@return	The hexadecimal string, is empty in case of an error.
+template<class T>
+AI_FORCE_INLINE
+std::string DecimalToHexa( T toConvert ) {
+    std::string result;
+    std::stringstream ss;
+    ss << std::hex << toConvert;
+    ss >> result;
+
+    for ( size_t i = 0; i < result.size(); ++i ) {
+        result[ i ] = toupper( result[ i ] );
+    }
+
+    return result;
+}
+
+#endif // INCLUDED_AI_STRINGUTILS_H
diff --git a/engine/inc/assimp/Subdivision.h b/engine/inc/assimp/Subdivision.h
new file mode 100644
index 00000000..84aff68f
--- /dev/null
+++ b/engine/inc/assimp/Subdivision.h
@@ -0,0 +1,131 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file Defines a helper class to evaluate subdivision surfaces.*/
+#pragma once
+#ifndef AI_SUBDISIVION_H_INC
+#define AI_SUBDISIVION_H_INC
+
+#include <cstddef>
+#include <assimp/types.h>
+
+struct aiMesh;
+
+namespace Assimp    {
+
+// ------------------------------------------------------------------------------
+/** Helper class to evaluate subdivision surfaces. Different algorithms
+ *  are provided for choice. */
+// ------------------------------------------------------------------------------
+class ASSIMP_API Subdivider {
+public:
+
+    /** Enumerates all supported subvidision algorithms */
+    enum Algorithm  {
+        CATMULL_CLARKE = 0x1
+    };
+
+    virtual ~Subdivider();
+
+    // ---------------------------------------------------------------
+    /** Create a subdivider of a specific type
+     *
+     *  @param algo Algorithm to be used for subdivision
+     *  @return Subdivider instance. */
+    static Subdivider* Create (Algorithm algo);
+
+    // ---------------------------------------------------------------
+    /** Subdivide a mesh using the selected algorithm
+     *
+     *  @param mesh First mesh to be subdivided. Must be in verbose
+     *    format.
+     *  @param out Receives the output mesh, allocated by me.
+     *  @param num Number of subdivisions to perform.
+     *  @param discard_input If true is passed, the input mesh is
+     *    deleted after the subdivision is complete. This can
+     *    improve performance because it allows the optimization
+     *    to reuse the existing mesh for intermediate results.
+     *  @pre out!=mesh*/
+    virtual void Subdivide ( aiMesh* mesh,
+        aiMesh*& out, unsigned int num,
+        bool discard_input = false) = 0;
+
+    // ---------------------------------------------------------------
+    /** Subdivide multiple meshes using the selected algorithm. This
+     *  avoids erroneous smoothing on objects consisting of multiple
+     *  per-material meshes. Usually, most 3d modellers smooth on a
+     *  per-object base, regardless the materials assigned to the
+     *  meshes.
+     *
+     *  @param smesh Array of meshes to be subdivided. Must be in
+     *    verbose format.
+     *  @param nmesh Number of meshes in smesh.
+     *  @param out Receives the output meshes. The array must be
+     *    sufficiently large (at least @c nmesh elements) and may not
+     *    overlap the input array. Output meshes map one-to-one to
+     *    their corresponding input meshes. The meshes are allocated
+     *    by the function.
+     *  @param discard_input If true is passed, input meshes are
+     *    deleted after the subdivision is complete. This can
+     *    improve performance because it allows the optimization
+     *    of reusing existing meshes for intermediate results.
+     *  @param num Number of subdivisions to perform.
+     *  @pre nmesh != 0, smesh and out may not overlap*/
+    virtual void Subdivide (
+        aiMesh** smesh,
+        size_t nmesh,
+        aiMesh** out,
+        unsigned int num,
+        bool discard_input = false) = 0;
+
+};
+
+inline
+Subdivider::~Subdivider() {
+    // empty
+}
+
+} // end namespace Assimp
+
+
+#endif // !!  AI_SUBDISIVION_H_INC
+
diff --git a/engine/inc/assimp/TinyFormatter.h b/engine/inc/assimp/TinyFormatter.h
new file mode 100644
index 00000000..2ddc227e
--- /dev/null
+++ b/engine/inc/assimp/TinyFormatter.h
@@ -0,0 +1,166 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file  TinyFormatter.h
+ *  @brief Utility to format log messages more easily. Introduced
+ *    to get rid of the boost::format dependency. Much slinker,
+ *    basically just extends stringstream.
+ */
+#ifndef INCLUDED_TINY_FORMATTER_H
+#define INCLUDED_TINY_FORMATTER_H
+
+#include <sstream>
+
+namespace Assimp {
+namespace Formatter {
+
+// ------------------------------------------------------------------------------------------------
+/** stringstream utility. Usage:
+ *  @code
+ *  void writelog(const std::string&s);
+ *  void writelog(const std::wstring&s);
+ *  ...
+ *  writelog(format()<< "hi! this is a number: " << 4);
+ *  writelog(wformat()<< L"hi! this is a number: " << 4);
+ *
+ *  @endcode */
+template < typename T,
+    typename CharTraits = std::char_traits<T>,
+    typename Allocator  = std::allocator<T>
+>
+class basic_formatter
+{
+
+public:
+
+    typedef class std::basic_string<
+        T,CharTraits,Allocator
+    > string;
+
+    typedef class std::basic_ostringstream<
+        T,CharTraits,Allocator
+    > stringstream;
+
+public:
+
+    basic_formatter() {}
+
+    /* Allow basic_formatter<T>'s to be used almost interchangeably
+     * with std::(w)string or const (w)char* arguments because the
+     * conversion c'tor is called implicitly. */
+    template <typename TT>
+    basic_formatter(const TT& sin)  {
+        underlying << sin;
+    }
+
+
+    // The problem described here:
+    // https://sourceforge.net/tracker/?func=detail&atid=1067632&aid=3358562&group_id=226462
+    // can also cause trouble here. Apparently, older gcc versions sometimes copy temporaries
+    // being bound to const ref& function parameters. Copying streams is not permitted, though.
+    // This workaround avoids this by manually specifying a copy ctor.
+#if !defined(__GNUC__) || !defined(__APPLE__) || __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
+    explicit basic_formatter(const basic_formatter& other) {
+        underlying << (string)other;
+    }
+#endif
+
+
+public:
+
+    operator string () const {
+        return underlying.str();
+    }
+
+
+    /* note - this is declared const because binding temporaries does only
+     * work for const references, so many function prototypes will
+     * include const basic_formatter<T>& s but might still want to
+     * modify the formatted string without the need for a full copy.*/
+    template <typename TToken>
+    const basic_formatter& operator << (const TToken& s) const {
+        underlying << s;
+        return *this;
+    }
+
+    template <typename TToken>
+    basic_formatter& operator << (const TToken& s) {
+        underlying << s;
+        return *this;
+    }
+
+
+    // comma operator overloaded as well, choose your preferred way.
+    template <typename TToken>
+    const basic_formatter& operator, (const TToken& s) const {
+        underlying << s;
+        return *this;
+    }
+
+    template <typename TToken>
+    basic_formatter& operator, (const TToken& s) {
+        underlying << s;
+        return *this;
+    }
+
+    // Fix for MSVC8
+    // See https://sourceforge.net/projects/assimp/forums/forum/817654/topic/4372824
+    template <typename TToken>
+    basic_formatter& operator, (TToken& s) {
+        underlying << s;
+        return *this;
+    }
+
+
+private:
+    mutable stringstream underlying;
+};
+
+
+typedef basic_formatter< char > format;
+typedef basic_formatter< wchar_t > wformat;
+
+} // ! namespace Formatter
+
+} // ! namespace Assimp
+
+#endif
diff --git a/engine/inc/assimp/Vertex.h b/engine/inc/assimp/Vertex.h
new file mode 100644
index 00000000..02ae3c0f
--- /dev/null
+++ b/engine/inc/assimp/Vertex.h
@@ -0,0 +1,324 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+/** @file Defines a helper class to represent an interleaved vertex
+  along with arithmetic operations to support vertex operations
+  such as subdivision, smoothing etc.
+
+  While the code is kept as general as possible, arithmetic operations
+  that are not currently well-defined (and would cause compile errors
+  due to missing operators in the math library), are commented.
+  */
+#ifndef AI_VERTEX_H_INC
+#define AI_VERTEX_H_INC
+
+#include <assimp/vector3.h>
+#include <assimp/mesh.h>
+#include <assimp/ai_assert.h>
+#include <functional>
+
+namespace Assimp    {
+
+    ///////////////////////////////////////////////////////////////////////////
+    // std::plus-family operates on operands with identical types - we need to
+    // support all the (vectype op float) combinations in vector maths.
+    // Providing T(float) would open the way to endless implicit conversions.
+    ///////////////////////////////////////////////////////////////////////////
+    namespace Intern {
+        template <typename T0, typename T1, typename TRES = T0> struct plus {
+            TRES operator() (const T0& t0, const T1& t1) const {
+                return t0+t1;
+            }
+        };
+        template <typename T0, typename T1, typename TRES = T0> struct minus {
+            TRES operator() (const T0& t0, const T1& t1) const {
+                return t0-t1;
+            }
+        };
+        template <typename T0, typename T1, typename TRES = T0> struct multiplies {
+            TRES operator() (const T0& t0, const T1& t1) const {
+                return t0*t1;
+            }
+        };
+        template <typename T0, typename T1, typename TRES = T0> struct divides {
+            TRES operator() (const T0& t0, const T1& t1) const {
+                return t0/t1;
+            }
+        };
+    }
+
+// ------------------------------------------------------------------------------------------------
+/** Intermediate description a vertex with all possible components. Defines a full set of
+ *  operators, so you may use such a 'Vertex' in basic arithmetics. All operators are applied
+ *  to *all* vertex components equally. This is useful for stuff like interpolation
+ *  or subdivision, but won't work if special handling is required for some vertex components. */
+// ------------------------------------------------------------------------------------------------
+class Vertex
+{
+    friend Vertex operator + (const Vertex&,const Vertex&);
+    friend Vertex operator - (const Vertex&,const Vertex&);
+
+//  friend Vertex operator + (const Vertex&,ai_real);
+//  friend Vertex operator - (const Vertex&,ai_real);
+    friend Vertex operator * (const Vertex&,ai_real);
+    friend Vertex operator / (const Vertex&,ai_real);
+
+//  friend Vertex operator + (ai_real, const Vertex&);
+//  friend Vertex operator - (ai_real, const Vertex&);
+    friend Vertex operator * (ai_real, const Vertex&);
+//  friend Vertex operator / (ai_real, const Vertex&);
+
+public:
+
+    Vertex() {}
+
+    // ----------------------------------------------------------------------------
+    /** Extract a particular vertex from a mesh and interleave all components */
+    explicit Vertex(const aiMesh* msh, unsigned int idx) {
+        ai_assert(idx < msh->mNumVertices);
+        position = msh->mVertices[idx];
+
+        if (msh->HasNormals()) {
+            normal = msh->mNormals[idx];
+        }
+
+        if (msh->HasTangentsAndBitangents()) {
+            tangent = msh->mTangents[idx];
+            bitangent = msh->mBitangents[idx];
+        }
+
+        for (unsigned int i = 0; msh->HasTextureCoords(i); ++i) {
+            texcoords[i] = msh->mTextureCoords[i][idx];
+        }
+
+        for (unsigned int i = 0; msh->HasVertexColors(i); ++i) {
+            colors[i] = msh->mColors[i][idx];
+        }
+    }
+
+public:
+
+    Vertex& operator += (const Vertex& v) {
+        *this = *this+v;
+        return *this;
+    }
+
+    Vertex& operator -= (const Vertex& v) {
+        *this = *this-v;
+        return *this;
+    }
+
+
+/*
+    Vertex& operator += (ai_real v) {
+        *this = *this+v;
+        return *this;
+    }
+
+    Vertex& operator -= (ai_real v) {
+        *this = *this-v;
+        return *this;
+    }
+*/
+    Vertex& operator *= (ai_real v) {
+        *this = *this*v;
+        return *this;
+    }
+
+    Vertex& operator /= (ai_real v) {
+        *this = *this/v;
+        return *this;
+    }
+
+public:
+
+    // ----------------------------------------------------------------------------
+    /** Convert back to non-interleaved storage */
+    void SortBack(aiMesh* out, unsigned int idx) const {
+
+        ai_assert(idx<out->mNumVertices);
+        out->mVertices[idx] = position;
+
+        if (out->HasNormals()) {
+            out->mNormals[idx] = normal;
+        }
+
+        if (out->HasTangentsAndBitangents()) {
+            out->mTangents[idx] = tangent;
+            out->mBitangents[idx] = bitangent;
+        }
+
+        for(unsigned int i = 0; out->HasTextureCoords(i); ++i) {
+            out->mTextureCoords[i][idx] = texcoords[i];
+        }
+
+        for(unsigned int i = 0; out->HasVertexColors(i); ++i) {
+            out->mColors[i][idx] = colors[i];
+        }
+    }
+
+private:
+
+    // ----------------------------------------------------------------------------
+    /** Construct from two operands and a binary operation to combine them */
+    template <template <typename t> class op> static Vertex BinaryOp(const Vertex& v0, const Vertex& v1) {
+        // this is a heavy task for the compiler to optimize ... *pray*
+
+        Vertex res;
+        res.position  = op<aiVector3D>()(v0.position,v1.position);
+        res.normal    = op<aiVector3D>()(v0.normal,v1.normal);
+        res.tangent   = op<aiVector3D>()(v0.tangent,v1.tangent);
+        res.bitangent = op<aiVector3D>()(v0.bitangent,v1.bitangent);
+
+        for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
+            res.texcoords[i] = op<aiVector3D>()(v0.texcoords[i],v1.texcoords[i]);
+        }
+        for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_COLOR_SETS; ++i) {
+            res.colors[i] = op<aiColor4D>()(v0.colors[i],v1.colors[i]);
+        }
+        return res;
+    }
+
+    // ----------------------------------------------------------------------------
+    /** This time binary arithmetics of v0 with a floating-point number */
+    template <template <typename, typename, typename> class op> static Vertex BinaryOp(const Vertex& v0, ai_real f) {
+        // this is a heavy task for the compiler to optimize ... *pray*
+
+        Vertex res;
+        res.position  = op<aiVector3D,ai_real,aiVector3D>()(v0.position,f);
+        res.normal    = op<aiVector3D,ai_real,aiVector3D>()(v0.normal,f);
+        res.tangent   = op<aiVector3D,ai_real,aiVector3D>()(v0.tangent,f);
+        res.bitangent = op<aiVector3D,ai_real,aiVector3D>()(v0.bitangent,f);
+
+        for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
+            res.texcoords[i] = op<aiVector3D,ai_real,aiVector3D>()(v0.texcoords[i],f);
+        }
+        for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_COLOR_SETS; ++i) {
+            res.colors[i] = op<aiColor4D,ai_real,aiColor4D>()(v0.colors[i],f);
+        }
+        return res;
+    }
+
+    // ----------------------------------------------------------------------------
+    /** This time binary arithmetics of v0 with a floating-point number */
+    template <template <typename, typename, typename> class op> static Vertex BinaryOp(ai_real f, const Vertex& v0) {
+        // this is a heavy task for the compiler to optimize ... *pray*
+
+        Vertex res;
+        res.position  = op<ai_real,aiVector3D,aiVector3D>()(f,v0.position);
+        res.normal    = op<ai_real,aiVector3D,aiVector3D>()(f,v0.normal);
+        res.tangent   = op<ai_real,aiVector3D,aiVector3D>()(f,v0.tangent);
+        res.bitangent = op<ai_real,aiVector3D,aiVector3D>()(f,v0.bitangent);
+
+        for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
+            res.texcoords[i] = op<ai_real,aiVector3D,aiVector3D>()(f,v0.texcoords[i]);
+        }
+        for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_COLOR_SETS; ++i) {
+            res.colors[i] = op<ai_real,aiColor4D,aiColor4D>()(f,v0.colors[i]);
+        }
+        return res;
+    }
+
+public:
+
+    aiVector3D position;
+    aiVector3D normal;
+    aiVector3D tangent, bitangent;
+
+    aiVector3D texcoords[AI_MAX_NUMBER_OF_TEXTURECOORDS];
+    aiColor4D colors[AI_MAX_NUMBER_OF_COLOR_SETS];
+};
+
+
+
+// ------------------------------------------------------------------------------------------------
+AI_FORCE_INLINE Vertex operator + (const Vertex& v0,const Vertex& v1) {
+    return Vertex::BinaryOp<std::plus>(v0,v1);
+}
+
+AI_FORCE_INLINE Vertex operator - (const Vertex& v0,const Vertex& v1) {
+    return Vertex::BinaryOp<std::minus>(v0,v1);
+}
+
+
+// ------------------------------------------------------------------------------------------------
+/*
+AI_FORCE_INLINE Vertex operator + (const Vertex& v0,ai_real f) {
+    return Vertex::BinaryOp<Intern::plus>(v0,f);
+}
+
+AI_FORCE_INLINE Vertex operator - (const Vertex& v0,ai_real f) {
+    return Vertex::BinaryOp<Intern::minus>(v0,f);
+}
+
+*/
+
+AI_FORCE_INLINE Vertex operator * (const Vertex& v0,ai_real f) {
+    return Vertex::BinaryOp<Intern::multiplies>(v0,f);
+}
+
+AI_FORCE_INLINE Vertex operator / (const Vertex& v0,ai_real f) {
+    return Vertex::BinaryOp<Intern::multiplies>(v0,1.f/f);
+}
+
+// ------------------------------------------------------------------------------------------------
+/*
+AI_FORCE_INLINE Vertex operator + (ai_real f,const Vertex& v0) {
+    return Vertex::BinaryOp<Intern::plus>(f,v0);
+}
+
+AI_FORCE_INLINE Vertex operator - (ai_real f,const Vertex& v0) {
+    return Vertex::BinaryOp<Intern::minus>(f,v0);
+}
+*/
+
+AI_FORCE_INLINE Vertex operator * (ai_real f,const Vertex& v0) {
+    return Vertex::BinaryOp<Intern::multiplies>(f,v0);
+}
+
+/*
+AI_FORCE_INLINE Vertex operator / (ai_real f,const Vertex& v0) {
+    return Vertex::BinaryOp<Intern::divides>(f,v0);
+}
+*/
+
+}
+#endif
diff --git a/engine/inc/assimp/XMLTools.h b/engine/inc/assimp/XMLTools.h
new file mode 100644
index 00000000..4b76c448
--- /dev/null
+++ b/engine/inc/assimp/XMLTools.h
@@ -0,0 +1,83 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#ifndef INCLUDED_ASSIMP_XML_TOOLS_H
+#define INCLUDED_ASSIMP_XML_TOOLS_H
+
+#include <string>
+
+namespace Assimp {
+    // XML escape the 5 XML special characters (",',<,> and &) in |data|
+    // Based on http://stackoverflow.com/questions/5665231
+    std::string XMLEscape(const std::string& data) {
+        std::string buffer;
+
+        const size_t size = data.size();
+        buffer.reserve(size + size / 8);
+        for(size_t i = 0; i < size; ++i) {
+            const char c = data[i];
+            switch(c) {
+                case '&' :
+                    buffer.append("&amp;");
+                    break;
+                case '\"':
+                    buffer.append("&quot;");
+                    break;
+                case '\'':
+                    buffer.append("&apos;");
+                    break;
+                case '<' :
+                    buffer.append("&lt;");
+                    break;
+                case '>' :
+                    buffer.append("&gt;");
+                    break;
+                default:
+                    buffer.append(&c, 1);
+                    break;
+            }
+        }
+        return buffer;
+    }
+}
+
+#endif // INCLUDED_ASSIMP_XML_TOOLS_H
diff --git a/engine/inc/assimp/ai_assert.h b/engine/inc/assimp/ai_assert.h
new file mode 100644
index 00000000..7752763d
--- /dev/null
+++ b/engine/inc/assimp/ai_assert.h
@@ -0,0 +1,54 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+#pragma once
+#ifndef AI_ASSERT_H_INC
+#define AI_ASSERT_H_INC
+
+#ifdef ASSIMP_BUILD_DEBUG
+#   include <assert.h>
+#   define  ai_assert(expression) assert(expression)
+#else
+#   define  ai_assert(expression)
+#endif // 
+
+#endif // AI_ASSERT_H_INC
diff --git a/engine/inc/assimp/anim.h b/engine/inc/assimp/anim.h
new file mode 100644
index 00000000..1a2c1104
--- /dev/null
+++ b/engine/inc/assimp/anim.h
@@ -0,0 +1,576 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** 
+  * @file   anim.h
+  * @brief  Defines the data structures in which the imported animations
+  *         are returned.
+  */
+#pragma once
+#ifndef AI_ANIM_H_INC
+#define AI_ANIM_H_INC
+
+#include <assimp/types.h>
+#include <assimp/quaternion.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// ---------------------------------------------------------------------------
+/** A time-value pair specifying a certain 3D vector for the given time. */
+struct aiVectorKey
+{
+    /** The time of this key */
+    double mTime;
+
+    /** The value of this key */
+    C_STRUCT aiVector3D mValue;
+
+#ifdef __cplusplus
+
+    /// @brief  The default constructor.
+    aiVectorKey() 
+    : mTime( 0.0 )
+    , mValue() {
+        // empty
+    }
+
+    /// @brief  Construction from a given time and key value.
+
+    aiVectorKey(double time, const aiVector3D& value)
+        :   mTime   (time)
+        ,   mValue  (value)
+    {}
+
+    typedef aiVector3D elem_type;
+
+    // Comparison operators. For use with std::find();
+    bool operator == (const aiVectorKey& o) const {
+        return o.mValue == this->mValue;
+    }
+    bool operator != (const aiVectorKey& o) const {
+        return o.mValue != this->mValue;
+    }
+
+    // Relational operators. For use with std::sort();
+    bool operator < (const aiVectorKey& o) const {
+        return mTime < o.mTime;
+    }
+    bool operator > (const aiVectorKey& o) const {
+        return mTime > o.mTime;
+    }
+#endif // __cplusplus
+};
+
+// ---------------------------------------------------------------------------
+/** A time-value pair specifying a rotation for the given time.
+ *  Rotations are expressed with quaternions. */
+struct aiQuatKey
+{
+    /** The time of this key */
+    double mTime;
+
+    /** The value of this key */
+    C_STRUCT aiQuaternion mValue;
+
+#ifdef __cplusplus
+    aiQuatKey()
+    : mTime( 0.0 )
+    , mValue() {
+        // empty
+    }
+
+    /** Construction from a given time and key value */
+    aiQuatKey(double time, const aiQuaternion& value)
+        :   mTime   (time)
+        ,   mValue  (value)
+    {}
+
+    typedef aiQuaternion elem_type;
+
+    // Comparison operators. For use with std::find();
+    bool operator == (const aiQuatKey& o) const {
+        return o.mValue == this->mValue;
+    }
+    bool operator != (const aiQuatKey& o) const {
+        return o.mValue != this->mValue;
+    }
+
+    // Relational operators. For use with std::sort();
+    bool operator < (const aiQuatKey& o) const {
+        return mTime < o.mTime;
+    }
+    bool operator > (const aiQuatKey& o) const {
+        return mTime > o.mTime;
+    }
+#endif
+};
+
+// ---------------------------------------------------------------------------
+/** Binds a anim mesh to a specific point in time. */
+struct aiMeshKey
+{
+    /** The time of this key */
+    double mTime;
+
+    /** Index into the aiMesh::mAnimMeshes array of the
+     *  mesh corresponding to the #aiMeshAnim hosting this
+     *  key frame. The referenced anim mesh is evaluated
+     *  according to the rules defined in the docs for #aiAnimMesh.*/
+    unsigned int mValue;
+
+#ifdef __cplusplus
+
+    aiMeshKey()
+    : mTime(0.0)
+    , mValue(0)
+    {
+    }
+
+    /** Construction from a given time and key value */
+    aiMeshKey(double time, const unsigned int value)
+        :   mTime   (time)
+        ,   mValue  (value)
+    {}
+
+    typedef unsigned int elem_type;
+
+    // Comparison operators. For use with std::find();
+    bool operator == (const aiMeshKey& o) const {
+        return o.mValue == this->mValue;
+    }
+    bool operator != (const aiMeshKey& o) const {
+        return o.mValue != this->mValue;
+    }
+
+    // Relational operators. For use with std::sort();
+    bool operator < (const aiMeshKey& o) const {
+        return mTime < o.mTime;
+    }
+    bool operator > (const aiMeshKey& o) const {
+        return mTime > o.mTime;
+    }
+
+#endif
+};
+
+// ---------------------------------------------------------------------------
+/** Binds a morph anim mesh to a specific point in time. */
+struct aiMeshMorphKey
+{
+    /** The time of this key */
+    double mTime;
+
+    /** The values and weights at the time of this key */
+    unsigned int *mValues;
+    double *mWeights;
+
+    /** The number of values and weights */
+    unsigned int mNumValuesAndWeights;
+#ifdef __cplusplus
+	aiMeshMorphKey()
+		: mTime(0.0)
+		, mValues(NULL)
+		, mWeights(NULL)
+		, mNumValuesAndWeights(0)
+	{
+
+	}
+
+    ~aiMeshMorphKey()
+    {
+        if (mNumValuesAndWeights && mValues && mWeights) {
+            delete [] mValues;
+            delete [] mWeights;
+        }
+    }
+#endif
+};
+
+// ---------------------------------------------------------------------------
+/** Defines how an animation channel behaves outside the defined time
+ *  range. This corresponds to aiNodeAnim::mPreState and
+ *  aiNodeAnim::mPostState.*/
+enum aiAnimBehaviour
+{
+    /** The value from the default node transformation is taken*/
+    aiAnimBehaviour_DEFAULT  = 0x0,
+
+    /** The nearest key value is used without interpolation */
+    aiAnimBehaviour_CONSTANT = 0x1,
+
+    /** The value of the nearest two keys is linearly
+     *  extrapolated for the current time value.*/
+    aiAnimBehaviour_LINEAR   = 0x2,
+
+    /** The animation is repeated.
+     *
+     *  If the animation key go from n to m and the current
+     *  time is t, use the value at (t-n) % (|m-n|).*/
+    aiAnimBehaviour_REPEAT   = 0x3,
+
+    /** This value is not used, it is just here to force the
+     *  the compiler to map this enum to a 32 Bit integer  */
+#ifndef SWIG
+    _aiAnimBehaviour_Force32Bit = INT_MAX
+#endif
+};
+
+// ---------------------------------------------------------------------------
+/** Describes the animation of a single node. The name specifies the
+ *  bone/node which is affected by this animation channel. The keyframes
+ *  are given in three separate series of values, one each for position,
+ *  rotation and scaling. The transformation matrix computed from these
+ *  values replaces the node's original transformation matrix at a
+ *  specific time.
+ *  This means all keys are absolute and not relative to the bone default pose.
+ *  The order in which the transformations are applied is
+ *  - as usual - scaling, rotation, translation.
+ *
+ *  @note All keys are returned in their correct, chronological order.
+ *  Duplicate keys don't pass the validation step. Most likely there
+ *  will be no negative time values, but they are not forbidden also ( so
+ *  implementations need to cope with them! ) */
+struct aiNodeAnim {
+    /** The name of the node affected by this animation. The node
+     *  must exist and it must be unique.*/
+    C_STRUCT aiString mNodeName;
+
+    /** The number of position keys */
+    unsigned int mNumPositionKeys;
+
+    /** The position keys of this animation channel. Positions are
+     * specified as 3D vector. The array is mNumPositionKeys in size.
+     *
+     * If there are position keys, there will also be at least one
+     * scaling and one rotation key.*/
+    C_STRUCT aiVectorKey* mPositionKeys;
+
+    /** The number of rotation keys */
+    unsigned int mNumRotationKeys;
+
+    /** The rotation keys of this animation channel. Rotations are
+     *  given as quaternions,  which are 4D vectors. The array is
+     *  mNumRotationKeys in size.
+     *
+     * If there are rotation keys, there will also be at least one
+     * scaling and one position key. */
+    C_STRUCT aiQuatKey* mRotationKeys;
+
+    /** The number of scaling keys */
+    unsigned int mNumScalingKeys;
+
+    /** The scaling keys of this animation channel. Scalings are
+     *  specified as 3D vector. The array is mNumScalingKeys in size.
+     *
+     * If there are scaling keys, there will also be at least one
+     * position and one rotation key.*/
+    C_STRUCT aiVectorKey* mScalingKeys;
+
+    /** Defines how the animation behaves before the first
+     *  key is encountered.
+     *
+     *  The default value is aiAnimBehaviour_DEFAULT (the original
+     *  transformation matrix of the affected node is used).*/
+    C_ENUM aiAnimBehaviour mPreState;
+
+    /** Defines how the animation behaves after the last
+     *  key was processed.
+     *
+     *  The default value is aiAnimBehaviour_DEFAULT (the original
+     *  transformation matrix of the affected node is taken).*/
+    C_ENUM aiAnimBehaviour mPostState;
+
+#ifdef __cplusplus
+    aiNodeAnim() 
+    : mNumPositionKeys( 0 )
+    , mPositionKeys( NULL )
+    , mNumRotationKeys( 0 )
+    , mRotationKeys( NULL )
+    , mNumScalingKeys( 0 )
+    , mScalingKeys( NULL )
+    , mPreState( aiAnimBehaviour_DEFAULT )
+    , mPostState( aiAnimBehaviour_DEFAULT ) {
+         // empty
+    }
+
+    ~aiNodeAnim() {
+        delete [] mPositionKeys;
+        delete [] mRotationKeys;
+        delete [] mScalingKeys;
+    }
+#endif // __cplusplus
+};
+
+// ---------------------------------------------------------------------------
+/** Describes vertex-based animations for a single mesh or a group of
+ *  meshes. Meshes carry the animation data for each frame in their
+ *  aiMesh::mAnimMeshes array. The purpose of aiMeshAnim is to
+ *  define keyframes linking each mesh attachment to a particular
+ *  point in time. */
+struct aiMeshAnim
+{
+    /** Name of the mesh to be animated. An empty string is not allowed,
+     *  animated meshes need to be named (not necessarily uniquely,
+     *  the name can basically serve as wild-card to select a group
+     *  of meshes with similar animation setup)*/
+    C_STRUCT aiString mName;
+
+    /** Size of the #mKeys array. Must be 1, at least. */
+    unsigned int mNumKeys;
+
+    /** Key frames of the animation. May not be NULL. */
+    C_STRUCT aiMeshKey* mKeys;
+
+#ifdef __cplusplus
+
+    aiMeshAnim()
+        : mNumKeys()
+        , mKeys()
+    {}
+
+    ~aiMeshAnim()
+    {
+        delete[] mKeys;
+    }
+
+#endif
+};
+
+// ---------------------------------------------------------------------------
+/** Describes a morphing animation of a given mesh. */
+struct aiMeshMorphAnim
+{
+    /** Name of the mesh to be animated. An empty string is not allowed,
+     *  animated meshes need to be named (not necessarily uniquely,
+     *  the name can basically serve as wildcard to select a group
+     *  of meshes with similar animation setup)*/
+    C_STRUCT aiString mName;
+
+    /** Size of the #mKeys array. Must be 1, at least. */
+    unsigned int mNumKeys;
+
+    /** Key frames of the animation. May not be NULL. */
+    C_STRUCT aiMeshMorphKey* mKeys;
+
+#ifdef __cplusplus
+
+    aiMeshMorphAnim()
+        : mNumKeys()
+        , mKeys()
+    {}
+
+    ~aiMeshMorphAnim()
+    {
+        delete[] mKeys;
+    }
+
+#endif
+};
+
+// ---------------------------------------------------------------------------
+/** An animation consists of key-frame data for a number of nodes. For
+ *  each node affected by the animation a separate series of data is given.*/
+struct aiAnimation {
+    /** The name of the animation. If the modeling package this data was
+     *  exported from does support only a single animation channel, this
+     *  name is usually empty (length is zero). */
+    C_STRUCT aiString mName;
+
+    /** Duration of the animation in ticks.  */
+    double mDuration;
+
+    /** Ticks per second. 0 if not specified in the imported file */
+    double mTicksPerSecond;
+
+    /** The number of bone animation channels. Each channel affects
+     *  a single node. */
+    unsigned int mNumChannels;
+
+    /** The node animation channels. Each channel affects a single node.
+     *  The array is mNumChannels in size. */
+    C_STRUCT aiNodeAnim** mChannels;
+
+
+    /** The number of mesh animation channels. Each channel affects
+     *  a single mesh and defines vertex-based animation. */
+    unsigned int mNumMeshChannels;
+
+    /** The mesh animation channels. Each channel affects a single mesh.
+     *  The array is mNumMeshChannels in size. */
+    C_STRUCT aiMeshAnim** mMeshChannels;
+
+    /** The number of mesh animation channels. Each channel affects
+     *  a single mesh and defines morphing animation. */
+    unsigned int mNumMorphMeshChannels;
+
+    /** The morph mesh animation channels. Each channel affects a single mesh.
+     *  The array is mNumMorphMeshChannels in size. */
+    C_STRUCT aiMeshMorphAnim **mMorphMeshChannels;
+
+#ifdef __cplusplus
+    aiAnimation()
+    : mDuration(-1.)
+    , mTicksPerSecond(0.)
+    , mNumChannels(0)
+    , mChannels(NULL)
+    , mNumMeshChannels(0)
+    , mMeshChannels(NULL)
+    , mNumMorphMeshChannels(0)
+    , mMorphMeshChannels(NULL) {
+        // empty
+    }
+
+    ~aiAnimation() {
+        // DO NOT REMOVE THIS ADDITIONAL CHECK
+        if ( mNumChannels && mChannels )  {
+            for( unsigned int a = 0; a < mNumChannels; a++) {
+                delete mChannels[ a ];
+            }
+
+            delete [] mChannels;
+        }
+        if (mNumMeshChannels && mMeshChannels)  {
+            for( unsigned int a = 0; a < mNumMeshChannels; a++) {
+                delete mMeshChannels[a];
+            }
+
+            delete [] mMeshChannels;
+        }
+        if (mNumMorphMeshChannels && mMorphMeshChannels) {
+                for( unsigned int a = 0; a < mNumMorphMeshChannels; a++) {
+                        delete mMorphMeshChannels[a];
+                }
+            
+            delete [] mMorphMeshChannels;
+        }
+    }
+#endif // __cplusplus
+};
+
+#ifdef __cplusplus
+
+}
+
+/// @brief  Some C++ utilities for inter- and extrapolation
+namespace Assimp {
+
+// ---------------------------------------------------------------------------
+/** 
+  * @brief CPP-API: Utility class to simplify interpolations of various data types.
+  *
+  *  The type of interpolation is chosen automatically depending on the
+  *  types of the arguments. 
+  */
+template <typename T>
+struct Interpolator
+{
+    // ------------------------------------------------------------------
+    /** @brief Get the result of the interpolation between a,b.
+     *
+     *  The interpolation algorithm depends on the type of the operands.
+     *  aiQuaternion's and aiQuatKey's SLERP, the rest does a simple
+     *  linear interpolation. */
+    void operator () (T& out,const T& a, const T& b, ai_real d) const {
+        out = a + (b-a)*d;
+    }
+}; // ! Interpolator <T>
+
+//! @cond Never
+
+template <>
+struct Interpolator <aiQuaternion>  {
+    void operator () (aiQuaternion& out,const aiQuaternion& a,
+        const aiQuaternion& b, ai_real d) const
+    {
+        aiQuaternion::Interpolate(out,a,b,d);
+    }
+}; // ! Interpolator <aiQuaternion>
+
+template <>
+struct Interpolator <unsigned int>  {
+    void operator () (unsigned int& out,unsigned int a,
+        unsigned int b, ai_real d) const
+    {
+        out = d>0.5f ? b : a;
+    }
+}; // ! Interpolator <aiQuaternion>
+
+template <>
+struct Interpolator<aiVectorKey>  {
+    void operator () (aiVector3D& out,const aiVectorKey& a,
+        const aiVectorKey& b, ai_real d) const
+    {
+        Interpolator<aiVector3D> ipl;
+        ipl(out,a.mValue,b.mValue,d);
+    }
+}; // ! Interpolator <aiVectorKey>
+
+template <>
+struct Interpolator<aiQuatKey>  {
+    void operator () (aiQuaternion& out, const aiQuatKey& a,
+        const aiQuatKey& b, ai_real d) const
+    {
+        Interpolator<aiQuaternion> ipl;
+        ipl(out,a.mValue,b.mValue,d);
+    }
+}; // ! Interpolator <aiQuatKey>
+
+template <>
+struct Interpolator<aiMeshKey>     {
+    void operator () (unsigned int& out, const aiMeshKey& a,
+        const aiMeshKey& b, ai_real d) const
+    {
+        Interpolator<unsigned int> ipl;
+        ipl(out,a.mValue,b.mValue,d);
+    }
+}; // ! Interpolator <aiQuatKey>
+
+//! @endcond
+
+} //  ! end namespace Assimp
+
+#endif // __cplusplus
+
+#endif // AI_ANIM_H_INC
diff --git a/engine/inc/assimp/camera.h b/engine/inc/assimp/camera.h
new file mode 100644
index 00000000..8073d84a
--- /dev/null
+++ b/engine/inc/assimp/camera.h
@@ -0,0 +1,226 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file camera.h
+ *  @brief Defines the aiCamera data structure
+ */
+
+#pragma once
+#ifndef AI_CAMERA_H_INC
+#define AI_CAMERA_H_INC
+
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// ---------------------------------------------------------------------------
+/** Helper structure to describe a virtual camera.
+ *
+ * Cameras have a representation in the node graph and can be animated.
+ * An important aspect is that the camera itself is also part of the
+ * scenegraph. This means, any values such as the look-at vector are not
+ * *absolute*, they're <b>relative</b> to the coordinate system defined
+ * by the node which corresponds to the camera. This allows for camera
+ * animations. For static cameras parameters like the 'look-at' or 'up' vectors
+ * are usually specified directly in aiCamera, but beware, they could also
+ * be encoded in the node transformation. The following (pseudo)code sample
+ * shows how to do it: <br><br>
+ * @code
+ * // Get the camera matrix for a camera at a specific time
+ * // if the node hierarchy for the camera does not contain
+ * // at least one animated node this is a static computation
+ * get-camera-matrix (node sceneRoot, camera cam) : matrix
+ * {
+ *    node   cnd = find-node-for-camera(cam)
+ *    matrix cmt = identity()
+ *
+ *    // as usual - get the absolute camera transformation for this frame
+ *    for each node nd in hierarchy from sceneRoot to cnd
+ *      matrix cur
+ *      if (is-animated(nd))
+ *         cur = eval-animation(nd)
+ *      else cur = nd->mTransformation;
+ *      cmt = mult-matrices( cmt, cur )
+ *    end for
+ *
+ *    // now multiply with the camera's own local transform
+ *    cam = mult-matrices (cam, get-camera-matrix(cmt) )
+ * }
+ * @endcode
+ *
+ * @note some file formats (such as 3DS, ASE) export a "target point" -
+ * the point the camera is looking at (it can even be animated). Assimp
+ * writes the target point as a subnode of the camera's main node,
+ * called "<camName>.Target". However this is just additional information
+ * then the transformation tracks of the camera main node make the
+ * camera already look in the right direction.
+ *
+*/
+struct aiCamera
+{
+    /** The name of the camera.
+     *
+     *  There must be a node in the scenegraph with the same name.
+     *  This node specifies the position of the camera in the scene
+     *  hierarchy and can be animated.
+     */
+    C_STRUCT aiString mName;
+
+    /** Position of the camera relative to the coordinate space
+     *  defined by the corresponding node.
+     *
+     *  The default value is 0|0|0.
+     */
+    C_STRUCT aiVector3D mPosition;
+
+
+    /** 'Up' - vector of the camera coordinate system relative to
+     *  the coordinate space defined by the corresponding node.
+     *
+     *  The 'right' vector of the camera coordinate system is
+     *  the cross product of  the up and lookAt vectors.
+     *  The default value is 0|1|0. The vector
+     *  may be normalized, but it needn't.
+     */
+    C_STRUCT aiVector3D mUp;
+
+
+    /** 'LookAt' - vector of the camera coordinate system relative to
+     *  the coordinate space defined by the corresponding node.
+     *
+     *  This is the viewing direction of the user.
+     *  The default value is 0|0|1. The vector
+     *  may be normalized, but it needn't.
+     */
+    C_STRUCT aiVector3D mLookAt;
+
+
+    /** Half horizontal field of view angle, in radians.
+     *
+     *  The field of view angle is the angle between the center
+     *  line of the screen and the left or right border.
+     *  The default value is 1/4PI.
+     */
+    float mHorizontalFOV;
+
+    /** Distance of the near clipping plane from the camera.
+     *
+     * The value may not be 0.f (for arithmetic reasons to prevent
+     * a division through zero). The default value is 0.1f.
+     */
+    float mClipPlaneNear;
+
+    /** Distance of the far clipping plane from the camera.
+     *
+     * The far clipping plane must, of course, be further away than the
+     * near clipping plane. The default value is 1000.f. The ratio
+     * between the near and the far plane should not be too
+     * large (between 1000-10000 should be ok) to avoid floating-point
+     * inaccuracies which could lead to z-fighting.
+     */
+    float mClipPlaneFar;
+
+
+    /** Screen aspect ratio.
+     *
+     * This is the ration between the width and the height of the
+     * screen. Typical values are 4/3, 1/2 or 1/1. This value is
+     * 0 if the aspect ratio is not defined in the source file.
+     * 0 is also the default value.
+     */
+    float mAspect;
+
+#ifdef __cplusplus
+
+    aiCamera()
+        : mUp               (0.f,1.f,0.f)
+        , mLookAt           (0.f,0.f,1.f)
+        , mHorizontalFOV    (0.25f * (float)AI_MATH_PI)
+        , mClipPlaneNear    (0.1f)
+        , mClipPlaneFar     (1000.f)
+        , mAspect           (0.f)
+    {}
+
+    /** @brief Get a *right-handed* camera matrix from me
+     *  @param out Camera matrix to be filled
+     */
+    void GetCameraMatrix (aiMatrix4x4& out) const
+    {
+        /** todo: test ... should work, but i'm not absolutely sure */
+
+        /** We don't know whether these vectors are already normalized ...*/
+        aiVector3D zaxis = mLookAt;     zaxis.Normalize();
+        aiVector3D yaxis = mUp;         yaxis.Normalize();
+        aiVector3D xaxis = mUp^mLookAt; xaxis.Normalize();
+
+        out.a4 = -(xaxis * mPosition);
+        out.b4 = -(yaxis * mPosition);
+        out.c4 = -(zaxis * mPosition);
+
+        out.a1 = xaxis.x;
+        out.a2 = xaxis.y;
+        out.a3 = xaxis.z;
+
+        out.b1 = yaxis.x;
+        out.b2 = yaxis.y;
+        out.b3 = yaxis.z;
+
+        out.c1 = zaxis.x;
+        out.c2 = zaxis.y;
+        out.c3 = zaxis.z;
+
+        out.d1 = out.d2 = out.d3 = 0.f;
+        out.d4 = 1.f;
+    }
+
+#endif
+};
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // AI_CAMERA_H_INC
diff --git a/engine/inc/assimp/cexport.h b/engine/inc/assimp/cexport.h
new file mode 100644
index 00000000..44b06fb3
--- /dev/null
+++ b/engine/inc/assimp/cexport.h
@@ -0,0 +1,263 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2011, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file  cexport.h
+*  @brief Defines the C-API for the Assimp export interface
+*/
+#pragma once
+#ifndef AI_EXPORT_H_INC
+#define AI_EXPORT_H_INC
+
+#ifndef ASSIMP_BUILD_NO_EXPORT
+
+// Public ASSIMP data structures
+#include <assimp/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct aiScene;  // aiScene.h
+struct aiFileIO; // aiFileIO.h
+
+// --------------------------------------------------------------------------------
+/** Describes an file format which Assimp can export to. Use #aiGetExportFormatCount() to
+* learn how many export formats the current Assimp build supports and #aiGetExportFormatDescription()
+* to retrieve a description of an export format option.
+*/
+struct aiExportFormatDesc
+{
+    /// a short string ID to uniquely identify the export format. Use this ID string to
+    /// specify which file format you want to export to when calling #aiExportScene().
+    /// Example: "dae" or "obj"
+    const char* id;
+
+    /// A short description of the file format to present to users. Useful if you want
+    /// to allow the user to select an export format.
+    const char* description;
+
+    /// Recommended file extension for the exported file in lower case.
+    const char* fileExtension;
+};
+
+
+// --------------------------------------------------------------------------------
+/** Returns the number of export file formats available in the current Assimp build.
+ * Use aiGetExportFormatDescription() to retrieve infos of a specific export format.
+ */
+ASSIMP_API size_t aiGetExportFormatCount(void);
+
+
+// --------------------------------------------------------------------------------
+/** Returns a description of the nth export file format. Use #aiGetExportFormatCount()
+ * to learn how many export formats are supported. The description must be released by
+ * calling aiReleaseExportFormatDescription afterwards.
+ * @param pIndex Index of the export format to retrieve information for. Valid range is
+ *    0 to #aiGetExportFormatCount()
+ * @return A description of that specific export format. NULL if pIndex is out of range.
+ */
+ASSIMP_API const C_STRUCT aiExportFormatDesc* aiGetExportFormatDescription( size_t pIndex);
+
+// --------------------------------------------------------------------------------
+/** Release a description of the nth export file format. Must be returned by
+* aiGetExportFormatDescription
+* @param desc Pointer to the description
+*/
+ASSIMP_API void aiReleaseExportFormatDescription( const C_STRUCT aiExportFormatDesc *desc );
+
+// --------------------------------------------------------------------------------
+/** Create a modifiable copy of a scene.
+ *  This is useful to import files via Assimp, change their topology and
+ *  export them again. Since the scene returned by the various importer functions
+ *  is const, a modifiable copy is needed.
+ *  @param pIn Valid scene to be copied
+ *  @param pOut Receives a modifyable copy of the scene. Use aiFreeScene() to
+ *    delete it again.
+ */
+ASSIMP_API void aiCopyScene(const C_STRUCT aiScene* pIn,
+    C_STRUCT aiScene** pOut);
+
+
+// --------------------------------------------------------------------------------
+/** Frees a scene copy created using aiCopyScene() */
+ASSIMP_API void aiFreeScene(const C_STRUCT aiScene* pIn);
+
+// --------------------------------------------------------------------------------
+/** Exports the given scene to a chosen file format and writes the result file(s) to disk.
+* @param pScene The scene to export. Stays in possession of the caller, is not changed by the function.
+*   The scene is expected to conform to Assimp's Importer output format as specified
+*   in the @link data Data Structures Page @endlink. In short, this means the model data
+*   should use a right-handed coordinate systems, face winding should be counter-clockwise
+*   and the UV coordinate origin is assumed to be in the upper left. If your input data
+*   uses different conventions, have a look at the last parameter.
+* @param pFormatId ID string to specify to which format you want to export to. Use
+* aiGetExportFormatCount() / aiGetExportFormatDescription() to learn which export formats are available.
+* @param pFileName Output file to write
+* @param pPreprocessing Accepts any choice of the #aiPostProcessSteps enumerated
+*   flags, but in reality only a subset of them makes sense here. Specifying
+*   'preprocessing' flags is useful if the input scene does not conform to
+*   Assimp's default conventions as specified in the @link data Data Structures Page @endlink.
+*   In short, this means the geometry data should use a right-handed coordinate systems, face
+*   winding should be counter-clockwise and the UV coordinate origin is assumed to be in
+*   the upper left. The #aiProcess_MakeLeftHanded, #aiProcess_FlipUVs and
+*   #aiProcess_FlipWindingOrder flags are used in the import side to allow users
+*   to have those defaults automatically adapted to their conventions. Specifying those flags
+*   for exporting has the opposite effect, respectively. Some other of the
+*   #aiPostProcessSteps enumerated values may be useful as well, but you'll need
+*   to try out what their effect on the exported file is. Many formats impose
+*   their own restrictions on the structure of the geometry stored therein,
+*   so some preprocessing may have little or no effect at all, or may be
+*   redundant as exporters would apply them anyhow. A good example
+*   is triangulation - whilst you can enforce it by specifying
+*   the #aiProcess_Triangulate flag, most export formats support only
+*   triangulate data so they would run the step anyway.
+*
+*   If assimp detects that the input scene was directly taken from the importer side of
+*   the library (i.e. not copied using aiCopyScene and potetially modified afterwards),
+*   any postprocessing steps already applied to the scene will not be applied again, unless
+*   they show non-idempotent behaviour (#aiProcess_MakeLeftHanded, #aiProcess_FlipUVs and
+*   #aiProcess_FlipWindingOrder).
+* @return a status code indicating the result of the export
+* @note Use aiCopyScene() to get a modifiable copy of a previously
+*   imported scene.
+*/
+ASSIMP_API aiReturn aiExportScene( const C_STRUCT aiScene* pScene,
+    const char* pFormatId,
+    const char* pFileName,
+    unsigned int pPreprocessing);
+
+
+// --------------------------------------------------------------------------------
+/** Exports the given scene to a chosen file format using custom IO logic supplied by you.
+* @param pScene The scene to export. Stays in possession of the caller, is not changed by the function.
+* @param pFormatId ID string to specify to which format you want to export to. Use
+* aiGetExportFormatCount() / aiGetExportFormatDescription() to learn which export formats are available.
+* @param pFileName Output file to write
+* @param pIO custom IO implementation to be used. Use this if you use your own storage methods.
+*   If none is supplied, a default implementation using standard file IO is used. Note that
+*   #aiExportSceneToBlob is provided as convenience function to export to memory buffers.
+* @param pPreprocessing Please see the documentation for #aiExportScene
+* @return a status code indicating the result of the export
+* @note Include <aiFileIO.h> for the definition of #aiFileIO.
+* @note Use aiCopyScene() to get a modifiable copy of a previously
+*   imported scene.
+*/
+ASSIMP_API aiReturn aiExportSceneEx( const C_STRUCT aiScene* pScene,
+    const char* pFormatId,
+    const char* pFileName,
+    C_STRUCT aiFileIO* pIO,
+    unsigned int pPreprocessing );
+
+
+// --------------------------------------------------------------------------------
+/** Describes a blob of exported scene data. Use #aiExportSceneToBlob() to create a blob containing an
+* exported scene. The memory referred by this structure is owned by Assimp.
+* to free its resources. Don't try to free the memory on your side - it will crash for most build configurations
+* due to conflicting heaps.
+*
+* Blobs can be nested - each blob may reference another blob, which may in turn reference another blob and so on.
+* This is used when exporters write more than one output file for a given #aiScene. See the remarks for
+* #aiExportDataBlob::name for more information.
+*/
+struct aiExportDataBlob
+{
+    /// Size of the data in bytes
+    size_t size;
+
+    /// The data.
+    void* data;
+
+    /** Name of the blob. An empty string always
+        indicates the first (and primary) blob,
+        which contains the actual file data.
+        Any other blobs are auxiliary files produced
+        by exporters (i.e. material files). Existence
+        of such files depends on the file format. Most
+        formats don't split assets across multiple files.
+
+        If used, blob names usually contain the file
+        extension that should be used when writing
+        the data to disc.
+     */
+    C_STRUCT aiString name;
+
+    /** Pointer to the next blob in the chain or NULL if there is none. */
+    C_STRUCT aiExportDataBlob * next;
+
+#ifdef __cplusplus
+    /// Default constructor
+    aiExportDataBlob() { size = 0; data = next = NULL; }
+    /// Releases the data
+    ~aiExportDataBlob() { delete [] static_cast<unsigned char*>( data ); delete next; }
+
+private:
+    // no copying
+    aiExportDataBlob(const aiExportDataBlob& );
+    aiExportDataBlob& operator= (const aiExportDataBlob& );
+#endif // __cplusplus
+};
+
+// --------------------------------------------------------------------------------
+/** Exports the given scene to a chosen file format. Returns the exported data as a binary blob which
+* you can write into a file or something. When you're done with the data, use #aiReleaseExportBlob()
+* to free the resources associated with the export.
+* @param pScene The scene to export. Stays in possession of the caller, is not changed by the function.
+* @param pFormatId ID string to specify to which format you want to export to. Use
+* #aiGetExportFormatCount() / #aiGetExportFormatDescription() to learn which export formats are available.
+* @param pPreprocessing Please see the documentation for #aiExportScene
+* @return the exported data or NULL in case of error
+*/
+ASSIMP_API const C_STRUCT aiExportDataBlob* aiExportSceneToBlob( const C_STRUCT aiScene* pScene, const char* pFormatId,  unsigned int pPreprocessing );
+
+
+// --------------------------------------------------------------------------------
+/** Releases the memory associated with the given exported data. Use this function to free a data blob
+* returned by aiExportScene().
+* @param pData the data blob returned by #aiExportSceneToBlob
+*/
+ASSIMP_API void aiReleaseExportBlob( const C_STRUCT aiExportDataBlob* pData );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // ASSIMP_BUILD_NO_EXPORT
+#endif // AI_EXPORT_H_INC
diff --git a/engine/inc/assimp/cfileio.h b/engine/inc/assimp/cfileio.h
new file mode 100644
index 00000000..a7a56f81
--- /dev/null
+++ b/engine/inc/assimp/cfileio.h
@@ -0,0 +1,138 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file cfileio.h
+ *  @brief Defines generic C routines to access memory-mapped files
+ */
+#pragma once
+#ifndef AI_FILEIO_H_INC
+#define AI_FILEIO_H_INC
+
+#include <assimp/types.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+struct aiFileIO;
+struct aiFile;
+
+// aiFile callbacks
+typedef size_t          (*aiFileWriteProc) (C_STRUCT aiFile*,   const char*, size_t, size_t);
+typedef size_t          (*aiFileReadProc)  (C_STRUCT aiFile*,   char*, size_t,size_t);
+typedef size_t          (*aiFileTellProc)  (C_STRUCT aiFile*);
+typedef void            (*aiFileFlushProc) (C_STRUCT aiFile*);
+typedef C_ENUM aiReturn (*aiFileSeek)      (C_STRUCT aiFile*, size_t, C_ENUM aiOrigin);
+
+// aiFileIO callbacks
+typedef C_STRUCT aiFile* (*aiFileOpenProc)  (C_STRUCT aiFileIO*, const char*, const char*);
+typedef void             (*aiFileCloseProc) (C_STRUCT aiFileIO*, C_STRUCT aiFile*);
+
+// Represents user-defined data
+typedef char* aiUserData;
+
+// ----------------------------------------------------------------------------------
+/** @brief C-API: File system callbacks
+ *
+ *  Provided are functions to open and close files. Supply a custom structure to
+ *  the import function. If you don't, a default implementation is used. Use custom
+ *  file systems to enable reading from other sources, such as ZIPs
+ *  or memory locations. */
+struct aiFileIO
+{
+    /** Function used to open a new file
+     */
+    aiFileOpenProc OpenProc;
+
+    /** Function used to close an existing file
+     */
+    aiFileCloseProc CloseProc;
+
+    /** User-defined, opaque data */
+    aiUserData UserData;
+};
+
+// ----------------------------------------------------------------------------------
+/** @brief C-API: File callbacks
+ *
+ *  Actually, it's a data structure to wrap a set of fXXXX (e.g fopen)
+ *  replacement functions.
+ *
+ *  The default implementation of the functions utilizes the fXXX functions from
+ *  the CRT. However, you can supply a custom implementation to Assimp by
+ *  delivering a custom aiFileIO. Use this to enable reading from other sources,
+ *  such as ZIP archives or memory locations. */
+struct aiFile
+{
+    /** Callback to read from a file */
+    aiFileReadProc ReadProc;
+
+    /** Callback to write to a file */
+    aiFileWriteProc WriteProc;
+
+    /** Callback to retrieve the current position of
+     *  the file cursor (ftell())
+     */
+    aiFileTellProc TellProc;
+
+    /** Callback to retrieve the size of the file,
+     *  in bytes
+     */
+    aiFileTellProc FileSizeProc;
+
+    /** Callback to set the current position
+     * of the file cursor (fseek())
+     */
+    aiFileSeek SeekProc;
+
+    /** Callback to flush the file contents
+     */
+    aiFileFlushProc FlushProc;
+
+    /** User-defined, opaque data
+     */
+    aiUserData UserData;
+};
+
+#ifdef __cplusplus
+}
+#endif
+#endif // AI_FILEIO_H_INC
diff --git a/engine/inc/assimp/cimport.h b/engine/inc/assimp/cimport.h
new file mode 100644
index 00000000..eb1e6e0d
--- /dev/null
+++ b/engine/inc/assimp/cimport.h
@@ -0,0 +1,565 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file  cimport.h
+ *  @brief Defines the C-API to the Open Asset Import Library.
+ */
+#pragma once
+#ifndef AI_ASSIMP_H_INC
+#define AI_ASSIMP_H_INC
+
+#include <assimp/types.h>
+#include "importerdesc.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct aiScene;  // aiScene.h
+struct aiFileIO; // aiFileIO.h
+typedef void (*aiLogStreamCallback)(const char* /* message */, char* /* user */);
+
+// --------------------------------------------------------------------------------
+/** C-API: Represents a log stream. A log stream receives all log messages and
+ *  streams them _somewhere_.
+ *  @see aiGetPredefinedLogStream
+ *  @see aiAttachLogStream
+ *  @see aiDetachLogStream */
+// --------------------------------------------------------------------------------
+struct aiLogStream
+{
+    /** callback to be called */
+    aiLogStreamCallback callback;
+
+    /** user data to be passed to the callback */
+    char* user;
+};
+
+
+// --------------------------------------------------------------------------------
+/** C-API: Represents an opaque set of settings to be used during importing.
+ *  @see aiCreatePropertyStore
+ *  @see aiReleasePropertyStore
+ *  @see aiImportFileExWithProperties
+ *  @see aiSetPropertyInteger
+ *  @see aiSetPropertyFloat
+ *  @see aiSetPropertyString
+ *  @see aiSetPropertyMatrix
+ */
+// --------------------------------------------------------------------------------
+struct aiPropertyStore { char sentinel; };
+
+/** Our own C boolean type */
+typedef int aiBool;
+
+#define AI_FALSE 0
+#define AI_TRUE 1
+
+// --------------------------------------------------------------------------------
+/** Reads the given file and returns its content.
+ *
+ * If the call succeeds, the imported data is returned in an aiScene structure.
+ * The data is intended to be read-only, it stays property of the ASSIMP
+ * library and will be stable until aiReleaseImport() is called. After you're
+ * done with it, call aiReleaseImport() to free the resources associated with
+ * this file. If the import fails, NULL is returned instead. Call
+ * aiGetErrorString() to retrieve a human-readable error text.
+ * @param pFile Path and filename of the file to be imported,
+ *   expected to be a null-terminated c-string. NULL is not a valid value.
+ * @param pFlags Optional post processing steps to be executed after
+ *   a successful import. Provide a bitwise combination of the
+ *   #aiPostProcessSteps flags.
+ * @return Pointer to the imported data or NULL if the import failed.
+ */
+ASSIMP_API const C_STRUCT aiScene* aiImportFile(
+    const char* pFile,
+    unsigned int pFlags);
+
+// --------------------------------------------------------------------------------
+/** Reads the given file using user-defined I/O functions and returns
+ *   its content.
+ *
+ * If the call succeeds, the imported data is returned in an aiScene structure.
+ * The data is intended to be read-only, it stays property of the ASSIMP
+ * library and will be stable until aiReleaseImport() is called. After you're
+ * done with it, call aiReleaseImport() to free the resources associated with
+ * this file. If the import fails, NULL is returned instead. Call
+ * aiGetErrorString() to retrieve a human-readable error text.
+ * @param pFile Path and filename of the file to be imported,
+ *   expected to be a null-terminated c-string. NULL is not a valid value.
+ * @param pFlags Optional post processing steps to be executed after
+ *   a successful import. Provide a bitwise combination of the
+ *   #aiPostProcessSteps flags.
+ * @param pFS aiFileIO structure. Will be used to open the model file itself
+ *   and any other files the loader needs to open.  Pass NULL to use the default
+ *   implementation.
+ * @return Pointer to the imported data or NULL if the import failed.
+ * @note Include <aiFileIO.h> for the definition of #aiFileIO.
+ */
+ASSIMP_API const C_STRUCT aiScene* aiImportFileEx(
+    const char* pFile,
+    unsigned int pFlags,
+    C_STRUCT aiFileIO* pFS);
+
+// --------------------------------------------------------------------------------
+/** Same as #aiImportFileEx, but adds an extra parameter containing importer settings.
+ *
+ * @param pFile Path and filename of the file to be imported,
+ *   expected to be a null-terminated c-string. NULL is not a valid value.
+ * @param pFlags Optional post processing steps to be executed after
+ *   a successful import. Provide a bitwise combination of the
+ *   #aiPostProcessSteps flags.
+ * @param pFS aiFileIO structure. Will be used to open the model file itself
+ *   and any other files the loader needs to open.  Pass NULL to use the default
+ *   implementation.
+ * @param pProps #aiPropertyStore instance containing import settings.
+ * @return Pointer to the imported data or NULL if the import failed.
+ * @note Include <aiFileIO.h> for the definition of #aiFileIO.
+ * @see aiImportFileEx
+ */
+ASSIMP_API const C_STRUCT aiScene* aiImportFileExWithProperties(
+    const char* pFile,
+    unsigned int pFlags,
+    C_STRUCT aiFileIO* pFS,
+    const C_STRUCT aiPropertyStore* pProps);
+
+// --------------------------------------------------------------------------------
+/** Reads the given file from a given memory buffer,
+ *
+ * If the call succeeds, the contents of the file are returned as a pointer to an
+ * aiScene object. The returned data is intended to be read-only, the importer keeps
+ * ownership of the data and will destroy it upon destruction. If the import fails,
+ * NULL is returned.
+ * A human-readable error description can be retrieved by calling aiGetErrorString().
+ * @param pBuffer Pointer to the file data
+ * @param pLength Length of pBuffer, in bytes
+ * @param pFlags Optional post processing steps to be executed after
+ *   a successful import. Provide a bitwise combination of the
+ *   #aiPostProcessSteps flags. If you wish to inspect the imported
+ *   scene first in order to fine-tune your post-processing setup,
+ *   consider to use #aiApplyPostProcessing().
+ * @param pHint An additional hint to the library. If this is a non empty string,
+ *   the library looks for a loader to support the file extension specified by pHint
+ *   and passes the file to the first matching loader. If this loader is unable to
+ *   completely the request, the library continues and tries to determine the file
+ *   format on its own, a task that may or may not be successful.
+ *   Check the return value, and you'll know ...
+ * @return A pointer to the imported data, NULL if the import failed.
+ *
+ * @note This is a straightforward way to decode models from memory
+ * buffers, but it doesn't handle model formats that spread their
+ * data across multiple files or even directories. Examples include
+ * OBJ or MD3, which outsource parts of their material info into
+ * external scripts. If you need full functionality, provide
+ * a custom IOSystem to make Assimp find these files and use
+ * the regular aiImportFileEx()/aiImportFileExWithProperties() API.
+ */
+ASSIMP_API const C_STRUCT aiScene* aiImportFileFromMemory(
+    const char* pBuffer,
+    unsigned int pLength,
+    unsigned int pFlags,
+    const char* pHint);
+
+// --------------------------------------------------------------------------------
+/** Same as #aiImportFileFromMemory, but adds an extra parameter containing importer settings.
+ *
+ * @param pBuffer Pointer to the file data
+ * @param pLength Length of pBuffer, in bytes
+ * @param pFlags Optional post processing steps to be executed after
+ *   a successful import. Provide a bitwise combination of the
+ *   #aiPostProcessSteps flags. If you wish to inspect the imported
+ *   scene first in order to fine-tune your post-processing setup,
+ *   consider to use #aiApplyPostProcessing().
+ * @param pHint An additional hint to the library. If this is a non empty string,
+ *   the library looks for a loader to support the file extension specified by pHint
+ *   and passes the file to the first matching loader. If this loader is unable to
+ *   completely the request, the library continues and tries to determine the file
+ *   format on its own, a task that may or may not be successful.
+ *   Check the return value, and you'll know ...
+ * @param pProps #aiPropertyStore instance containing import settings.
+ * @return A pointer to the imported data, NULL if the import failed.
+ *
+ * @note This is a straightforward way to decode models from memory
+ * buffers, but it doesn't handle model formats that spread their
+ * data across multiple files or even directories. Examples include
+ * OBJ or MD3, which outsource parts of their material info into
+ * external scripts. If you need full functionality, provide
+ * a custom IOSystem to make Assimp find these files and use
+ * the regular aiImportFileEx()/aiImportFileExWithProperties() API.
+ * @see aiImportFileFromMemory
+ */
+ASSIMP_API const C_STRUCT aiScene* aiImportFileFromMemoryWithProperties(
+    const char* pBuffer,
+    unsigned int pLength,
+    unsigned int pFlags,
+    const char* pHint,
+    const C_STRUCT aiPropertyStore* pProps);
+
+// --------------------------------------------------------------------------------
+/** Apply post-processing to an already-imported scene.
+ *
+ * This is strictly equivalent to calling #aiImportFile()/#aiImportFileEx with the
+ * same flags. However, you can use this separate function to inspect the imported
+ * scene first to fine-tune your post-processing setup.
+ * @param pScene Scene to work on.
+ * @param pFlags Provide a bitwise combination of the #aiPostProcessSteps flags.
+ * @return A pointer to the post-processed data. Post processing is done in-place,
+ *   meaning this is still the same #aiScene which you passed for pScene. However,
+ *   _if_ post-processing failed, the scene could now be NULL. That's quite a rare
+ *   case, post processing steps are not really designed to 'fail'. To be exact,
+ *   the #aiProcess_ValidateDataStructure flag is currently the only post processing step
+ *   which can actually cause the scene to be reset to NULL.
+ */
+ASSIMP_API const C_STRUCT aiScene* aiApplyPostProcessing(
+    const C_STRUCT aiScene* pScene,
+    unsigned int pFlags);
+
+// --------------------------------------------------------------------------------
+/** Get one of the predefine log streams. This is the quick'n'easy solution to
+ *  access Assimp's log system. Attaching a log stream can slightly reduce Assimp's
+ *  overall import performance.
+ *
+ *  Usage is rather simple (this will stream the log to a file, named log.txt, and
+ *  the stdout stream of the process:
+ *  @code
+ *    struct aiLogStream c;
+ *    c = aiGetPredefinedLogStream(aiDefaultLogStream_FILE,"log.txt");
+ *    aiAttachLogStream(&c);
+ *    c = aiGetPredefinedLogStream(aiDefaultLogStream_STDOUT,NULL);
+ *    aiAttachLogStream(&c);
+ *  @endcode
+ *
+ *  @param pStreams One of the #aiDefaultLogStream enumerated values.
+ *  @param file Solely for the #aiDefaultLogStream_FILE flag: specifies the file to write to.
+ *    Pass NULL for all other flags.
+ *  @return The log stream. callback is set to NULL if something went wrong.
+ */
+ASSIMP_API C_STRUCT aiLogStream aiGetPredefinedLogStream(
+    C_ENUM aiDefaultLogStream pStreams,
+    const char* file);
+
+// --------------------------------------------------------------------------------
+/** Attach a custom log stream to the libraries' logging system.
+ *
+ *  Attaching a log stream can slightly reduce Assimp's overall import
+ *  performance. Multiple log-streams can be attached.
+ *  @param stream Describes the new log stream.
+ *  @note To ensure proper destruction of the logging system, you need to manually
+ *    call aiDetachLogStream() on every single log stream you attach.
+ *    Alternatively (for the lazy folks) #aiDetachAllLogStreams is provided.
+ */
+ASSIMP_API void aiAttachLogStream(
+    const C_STRUCT aiLogStream* stream);
+
+// --------------------------------------------------------------------------------
+/** Enable verbose logging. Verbose logging includes debug-related stuff and
+ *  detailed import statistics. This can have severe impact on import performance
+ *  and memory consumption. However, it might be useful to find out why a file
+ *  didn't read correctly.
+ *  @param d AI_TRUE or AI_FALSE, your decision.
+ */
+ASSIMP_API void aiEnableVerboseLogging(aiBool d);
+
+// --------------------------------------------------------------------------------
+/** Detach a custom log stream from the libraries' logging system.
+ *
+ *  This is the counterpart of #aiAttachLogStream. If you attached a stream,
+ *  don't forget to detach it again.
+ *  @param stream The log stream to be detached.
+ *  @return AI_SUCCESS if the log stream has been detached successfully.
+ *  @see aiDetachAllLogStreams
+ */
+ASSIMP_API C_ENUM aiReturn aiDetachLogStream(
+    const C_STRUCT aiLogStream* stream);
+
+// --------------------------------------------------------------------------------
+/** Detach all active log streams from the libraries' logging system.
+ *  This ensures that the logging system is terminated properly and all
+ *  resources allocated by it are actually freed. If you attached a stream,
+ *  don't forget to detach it again.
+ *  @see aiAttachLogStream
+ *  @see aiDetachLogStream
+ */
+ASSIMP_API void aiDetachAllLogStreams(void);
+
+// --------------------------------------------------------------------------------
+/** Releases all resources associated with the given import process.
+ *
+ * Call this function after you're done with the imported data.
+ * @param pScene The imported data to release. NULL is a valid value.
+ */
+ASSIMP_API void aiReleaseImport(
+    const C_STRUCT aiScene* pScene);
+
+// --------------------------------------------------------------------------------
+/** Returns the error text of the last failed import process.
+ *
+ * @return A textual description of the error that occurred at the last
+ * import process. NULL if there was no error. There can't be an error if you
+ * got a non-NULL #aiScene from #aiImportFile/#aiImportFileEx/#aiApplyPostProcessing.
+ */
+ASSIMP_API const char* aiGetErrorString(void);
+
+// --------------------------------------------------------------------------------
+/** Returns whether a given file extension is supported by ASSIMP
+ *
+ * @param szExtension Extension for which the function queries support for.
+ * Must include a leading dot '.'. Example: ".3ds", ".md3"
+ * @return AI_TRUE if the file extension is supported.
+ */
+ASSIMP_API aiBool aiIsExtensionSupported(
+    const char* szExtension);
+
+// --------------------------------------------------------------------------------
+/** Get a list of all file extensions supported by ASSIMP.
+ *
+ * If a file extension is contained in the list this does, of course, not
+ * mean that ASSIMP is able to load all files with this extension.
+ * @param szOut String to receive the extension list.
+ * Format of the list: "*.3ds;*.obj;*.dae". NULL is not a valid parameter.
+ */
+ASSIMP_API void aiGetExtensionList(
+    C_STRUCT aiString* szOut);
+
+// --------------------------------------------------------------------------------
+/** Get the approximated storage required by an imported asset
+ * @param pIn Input asset.
+ * @param in Data structure to be filled.
+ */
+ASSIMP_API void aiGetMemoryRequirements(
+    const C_STRUCT aiScene* pIn,
+    C_STRUCT aiMemoryInfo* in);
+
+
+
+// --------------------------------------------------------------------------------
+/** Create an empty property store. Property stores are used to collect import
+ *  settings.
+ * @return New property store. Property stores need to be manually destroyed using
+ *   the #aiReleasePropertyStore API function.
+ */
+ASSIMP_API C_STRUCT aiPropertyStore* aiCreatePropertyStore(void);
+
+// --------------------------------------------------------------------------------
+/** Delete a property store.
+ * @param p Property store to be deleted.
+ */
+ASSIMP_API void aiReleasePropertyStore(C_STRUCT aiPropertyStore* p);
+
+// --------------------------------------------------------------------------------
+/** Set an integer property.
+ *
+ *  This is the C-version of #Assimp::Importer::SetPropertyInteger(). In the C
+ *  interface, properties are always shared by all imports. It is not possible to
+ *  specify them per import.
+ *
+ * @param store Store to modify. Use #aiCreatePropertyStore to obtain a store.
+ * @param szName Name of the configuration property to be set. All supported
+ *   public properties are defined in the config.h header file (AI_CONFIG_XXX).
+ * @param value New value for the property
+ */
+ASSIMP_API void aiSetImportPropertyInteger(
+    C_STRUCT aiPropertyStore* store,
+    const char* szName,
+    int value);
+
+// --------------------------------------------------------------------------------
+/** Set a floating-point property.
+ *
+ *  This is the C-version of #Assimp::Importer::SetPropertyFloat(). In the C
+ *  interface, properties are always shared by all imports. It is not possible to
+ *  specify them per import.
+ *
+ * @param store Store to modify. Use #aiCreatePropertyStore to obtain a store.
+ * @param szName Name of the configuration property to be set. All supported
+ *   public properties are defined in the config.h header file (AI_CONFIG_XXX).
+ * @param value New value for the property
+ */
+ASSIMP_API void aiSetImportPropertyFloat(
+    C_STRUCT aiPropertyStore* store,
+    const char* szName,
+    ai_real value);
+
+// --------------------------------------------------------------------------------
+/** Set a string property.
+ *
+ *  This is the C-version of #Assimp::Importer::SetPropertyString(). In the C
+ *  interface, properties are always shared by all imports. It is not possible to
+ *  specify them per import.
+ *
+ * @param store Store to modify. Use #aiCreatePropertyStore to obtain a store.
+ * @param szName Name of the configuration property to be set. All supported
+ *   public properties are defined in the config.h header file (AI_CONFIG_XXX).
+ * @param st New value for the property
+ */
+ASSIMP_API void aiSetImportPropertyString(
+    C_STRUCT aiPropertyStore* store,
+    const char* szName,
+    const C_STRUCT aiString* st);
+
+// --------------------------------------------------------------------------------
+/** Set a matrix property.
+ *
+ *  This is the C-version of #Assimp::Importer::SetPropertyMatrix(). In the C
+ *  interface, properties are always shared by all imports. It is not possible to
+ *  specify them per import.
+ *
+ * @param store Store to modify. Use #aiCreatePropertyStore to obtain a store.
+ * @param szName Name of the configuration property to be set. All supported
+ *   public properties are defined in the config.h header file (AI_CONFIG_XXX).
+ * @param mat New value for the property
+ */
+ASSIMP_API void aiSetImportPropertyMatrix(
+    C_STRUCT aiPropertyStore* store,
+    const char* szName,
+    const C_STRUCT aiMatrix4x4* mat);
+
+// --------------------------------------------------------------------------------
+/** Construct a quaternion from a 3x3 rotation matrix.
+ *  @param quat Receives the output quaternion.
+ *  @param mat Matrix to 'quaternionize'.
+ *  @see aiQuaternion(const aiMatrix3x3& pRotMatrix)
+ */
+ASSIMP_API void aiCreateQuaternionFromMatrix(
+    C_STRUCT aiQuaternion* quat,
+    const C_STRUCT aiMatrix3x3* mat);
+
+// --------------------------------------------------------------------------------
+/** Decompose a transformation matrix into its rotational, translational and
+ *  scaling components.
+ *
+ * @param mat Matrix to decompose
+ * @param scaling Receives the scaling component
+ * @param rotation Receives the rotational component
+ * @param position Receives the translational component.
+ * @see aiMatrix4x4::Decompose (aiVector3D&, aiQuaternion&, aiVector3D&) const;
+ */
+ASSIMP_API void aiDecomposeMatrix(
+    const C_STRUCT aiMatrix4x4* mat,
+    C_STRUCT aiVector3D* scaling,
+    C_STRUCT aiQuaternion* rotation,
+    C_STRUCT aiVector3D* position);
+
+// --------------------------------------------------------------------------------
+/** Transpose a 4x4 matrix.
+ *  @param mat Pointer to the matrix to be transposed
+ */
+ASSIMP_API void aiTransposeMatrix4(
+    C_STRUCT aiMatrix4x4* mat);
+
+// --------------------------------------------------------------------------------
+/** Transpose a 3x3 matrix.
+ *  @param mat Pointer to the matrix to be transposed
+ */
+ASSIMP_API void aiTransposeMatrix3(
+    C_STRUCT aiMatrix3x3* mat);
+
+// --------------------------------------------------------------------------------
+/** Transform a vector by a 3x3 matrix
+ *  @param vec Vector to be transformed.
+ *  @param mat Matrix to transform the vector with.
+ */
+ASSIMP_API void aiTransformVecByMatrix3(
+    C_STRUCT aiVector3D* vec,
+    const C_STRUCT aiMatrix3x3* mat);
+
+// --------------------------------------------------------------------------------
+/** Transform a vector by a 4x4 matrix
+ *  @param vec Vector to be transformed.
+ *  @param mat Matrix to transform the vector with.
+ */
+ASSIMP_API void aiTransformVecByMatrix4(
+    C_STRUCT aiVector3D* vec,
+    const C_STRUCT aiMatrix4x4* mat);
+
+// --------------------------------------------------------------------------------
+/** Multiply two 4x4 matrices.
+ *  @param dst First factor, receives result.
+ *  @param src Matrix to be multiplied with 'dst'.
+ */
+ASSIMP_API void aiMultiplyMatrix4(
+    C_STRUCT aiMatrix4x4* dst,
+    const C_STRUCT aiMatrix4x4* src);
+
+// --------------------------------------------------------------------------------
+/** Multiply two 3x3 matrices.
+ *  @param dst First factor, receives result.
+ *  @param src Matrix to be multiplied with 'dst'.
+ */
+ASSIMP_API void aiMultiplyMatrix3(
+    C_STRUCT aiMatrix3x3* dst,
+    const C_STRUCT aiMatrix3x3* src);
+
+// --------------------------------------------------------------------------------
+/** Get a 3x3 identity matrix.
+ *  @param mat Matrix to receive its personal identity
+ */
+ASSIMP_API void aiIdentityMatrix3(
+    C_STRUCT aiMatrix3x3* mat);
+
+// --------------------------------------------------------------------------------
+/** Get a 4x4 identity matrix.
+ *  @param mat Matrix to receive its personal identity
+ */
+ASSIMP_API void aiIdentityMatrix4(
+    C_STRUCT aiMatrix4x4* mat);
+
+// --------------------------------------------------------------------------------
+/** Returns the number of import file formats available in the current Assimp build.
+ * Use aiGetImportFormatDescription() to retrieve infos of a specific import format.
+ */
+ASSIMP_API size_t aiGetImportFormatCount(void);
+
+// --------------------------------------------------------------------------------
+/** Returns a description of the nth import file format. Use #aiGetImportFormatCount()
+ * to learn how many import formats are supported.
+ * @param pIndex Index of the import format to retrieve information for. Valid range is
+ *    0 to #aiGetImportFormatCount()
+ * @return A description of that specific import format. NULL if pIndex is out of range.
+ */
+ASSIMP_API const C_STRUCT aiImporterDesc* aiGetImportFormatDescription( size_t pIndex);
+#ifdef __cplusplus
+}
+#endif
+
+#endif // AI_ASSIMP_H_INC
diff --git a/engine/inc/assimp/color4.h b/engine/inc/assimp/color4.h
new file mode 100644
index 00000000..ced470b2
--- /dev/null
+++ b/engine/inc/assimp/color4.h
@@ -0,0 +1,105 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+/** @file color4.h
+ *  @brief RGBA color structure, including operators when compiling in C++
+ */
+#pragma once
+#ifndef AI_COLOR4D_H_INC
+#define AI_COLOR4D_H_INC
+
+#include "defs.h"
+
+#ifdef __cplusplus
+
+// ----------------------------------------------------------------------------------
+/** Represents a color in Red-Green-Blue space including an
+*   alpha component. Color values range from 0 to 1. */
+// ----------------------------------------------------------------------------------
+template <typename TReal>
+class aiColor4t
+{
+public:
+    aiColor4t () : r(), g(), b(), a() {}
+    aiColor4t (TReal _r, TReal _g, TReal _b, TReal _a)
+        : r(_r), g(_g), b(_b), a(_a) {}
+    explicit aiColor4t (TReal _r) : r(_r), g(_r), b(_r), a(_r) {}
+    aiColor4t (const aiColor4t& o)
+        : r(o.r), g(o.g), b(o.b), a(o.a) {}
+
+public:
+    // combined operators
+    const aiColor4t& operator += (const aiColor4t& o);
+    const aiColor4t& operator -= (const aiColor4t& o);
+    const aiColor4t& operator *= (TReal f);
+    const aiColor4t& operator /= (TReal f);
+
+public:
+    // comparison
+    bool operator == (const aiColor4t& other) const;
+    bool operator != (const aiColor4t& other) const;
+    bool operator <  (const aiColor4t& other) const;
+
+    // color tuple access, rgba order
+    inline TReal operator[](unsigned int i) const;
+    inline TReal& operator[](unsigned int i);
+
+    /** check whether a color is (close to) black */
+    inline bool IsBlack() const;
+
+public:
+
+    // Red, green, blue and alpha color values
+    TReal r, g, b, a;
+};  // !struct aiColor4D
+
+typedef aiColor4t<ai_real> aiColor4D;
+
+#else
+
+struct aiColor4D {
+    ai_real r, g, b, a;
+};
+
+#endif // __cplusplus
+
+#endif // AI_COLOR4D_H_INC
diff --git a/engine/inc/assimp/color4.inl b/engine/inc/assimp/color4.inl
new file mode 100644
index 00000000..6e27292b
--- /dev/null
+++ b/engine/inc/assimp/color4.inl
@@ -0,0 +1,205 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file  color4.inl
+ *  @brief Inline implementation of aiColor4t<TReal> operators
+ */
+#pragma once
+#ifndef AI_COLOR4D_INL_INC
+#define AI_COLOR4D_INL_INC
+
+#ifdef __cplusplus
+#include "color4.h"
+
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE const aiColor4t<TReal>& aiColor4t<TReal>::operator += (const aiColor4t<TReal>& o) {
+    r += o.r; g += o.g; b += o.b; a += o.a;
+    return *this;
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE const aiColor4t<TReal>& aiColor4t<TReal>::operator -= (const aiColor4t<TReal>& o) {
+    r -= o.r; g -= o.g; b -= o.b; a -= o.a;
+    return *this;
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE const aiColor4t<TReal>& aiColor4t<TReal>::operator *= (TReal f) {
+    r *= f; g *= f; b *= f; a *= f;
+    return *this;
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE const aiColor4t<TReal>& aiColor4t<TReal>::operator /= (TReal f) {
+    r /= f; g /= f; b /= f; a /= f;
+    return *this;
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE TReal aiColor4t<TReal>::operator[](unsigned int i) const {
+    switch ( i ) {
+        case 0:
+            return r;
+        case 1:
+            return g;
+        case 2:
+            return b;
+        default:
+            break;
+    }
+    return r;
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE TReal& aiColor4t<TReal>::operator[](unsigned int i) {
+    switch ( i ) {
+        case 0:
+            return r;
+        case 1:
+            return g;
+        case 2:
+            return b;
+        default:
+            break;
+    }
+    return r;
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE bool aiColor4t<TReal>::operator== (const aiColor4t<TReal>& other) const {
+    return r == other.r && g == other.g && b == other.b && a == other.a;
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE bool aiColor4t<TReal>::operator!= (const aiColor4t<TReal>& other) const {
+    return r != other.r || g != other.g || b != other.b || a != other.a;
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE bool aiColor4t<TReal>::operator< (const aiColor4t<TReal>& other) const {
+    return r < other.r || (
+        r == other.r && (
+            g < other.g || (
+                g == other.g && (
+                    b < other.b || (
+                        b == other.b && (
+                            a < other.a
+                        )
+                    )
+                )
+            )
+        )
+    );
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE aiColor4t<TReal> operator + (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2)    {
+    return aiColor4t<TReal>( v1.r + v2.r, v1.g + v2.g, v1.b + v2.b, v1.a + v2.a);
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE aiColor4t<TReal> operator - (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2)    {
+    return aiColor4t<TReal>( v1.r - v2.r, v1.g - v2.g, v1.b - v2.b, v1.a - v2.a);
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE aiColor4t<TReal> operator * (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2)    {
+    return aiColor4t<TReal>( v1.r * v2.r, v1.g * v2.g, v1.b * v2.b, v1.a * v2.a);
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE aiColor4t<TReal> operator / (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2)    {
+    return aiColor4t<TReal>( v1.r / v2.r, v1.g / v2.g, v1.b / v2.b, v1.a / v2.a);
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE aiColor4t<TReal> operator * ( TReal f, const aiColor4t<TReal>& v)   {
+    return aiColor4t<TReal>( f*v.r, f*v.g, f*v.b, f*v.a);
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE  aiColor4t<TReal> operator * ( const aiColor4t<TReal>& v, TReal f)  {
+    return aiColor4t<TReal>( f*v.r, f*v.g, f*v.b, f*v.a);
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE  aiColor4t<TReal> operator / ( const aiColor4t<TReal>& v, TReal f)  {
+    return v * (1/f);
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE  aiColor4t<TReal> operator / ( TReal f,const aiColor4t<TReal>& v)   {
+    return aiColor4t<TReal>(f,f,f,f)/v;
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE  aiColor4t<TReal> operator + ( const aiColor4t<TReal>& v, TReal f)  {
+    return aiColor4t<TReal>( f+v.r, f+v.g, f+v.b, f+v.a);
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE  aiColor4t<TReal> operator - ( const aiColor4t<TReal>& v, TReal f)  {
+    return aiColor4t<TReal>( v.r-f, v.g-f, v.b-f, v.a-f);
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE  aiColor4t<TReal> operator + ( TReal f, const aiColor4t<TReal>& v)  {
+    return aiColor4t<TReal>( f+v.r, f+v.g, f+v.b, f+v.a);
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE  aiColor4t<TReal> operator - ( TReal f, const aiColor4t<TReal>& v)  {
+    return aiColor4t<TReal>( f-v.r, f-v.g, f-v.b, f-v.a);
+}
+
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+inline bool aiColor4t<TReal> :: IsBlack() const {
+    // The alpha component doesn't care here. black is black.
+    static const TReal epsilon = 10e-3f;
+    return std::fabs( r ) < epsilon && std::fabs( g ) < epsilon && std::fabs( b ) < epsilon;
+}
+
+#endif // __cplusplus
+#endif // AI_VECTOR3D_INL_INC
diff --git a/engine/inc/assimp/config.h b/engine/inc/assimp/config.h
new file mode 100644
index 00000000..e3da4483
--- /dev/null
+++ b/engine/inc/assimp/config.h
@@ -0,0 +1,974 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file config.h
+ *  @brief Defines constants for configurable properties for the library
+ *
+ *  Typically these properties are set via
+ *  #Assimp::Importer::SetPropertyFloat,
+ *  #Assimp::Importer::SetPropertyInteger or
+ *  #Assimp::Importer::SetPropertyString,
+ *  depending on the data type of a property. All properties have a
+ *  default value. See the doc for the mentioned methods for more details.
+ *
+ *  <br><br>
+ *  The corresponding functions for use with the plain-c API are:
+ *  #aiSetImportPropertyInteger,
+ *  #aiSetImportPropertyFloat,
+ *  #aiSetImportPropertyString
+ */
+#pragma once
+#ifndef AI_CONFIG_H_INC
+#define AI_CONFIG_H_INC
+
+
+// ###########################################################################
+// LIBRARY SETTINGS
+// General, global settings
+// ###########################################################################
+
+// ---------------------------------------------------------------------------
+/** @brief Enables time measurements.
+ *
+ *  If enabled, measures the time needed for each part of the loading
+ *  process (i.e. IO time, importing, postprocessing, ..) and dumps
+ *  these timings to the DefaultLogger. See the @link perf Performance
+ *  Page@endlink for more information on this topic.
+ *
+ * Property type: bool. Default value: false.
+ */
+#define AI_CONFIG_GLOB_MEASURE_TIME  \
+    "GLOB_MEASURE_TIME"
+
+
+// ---------------------------------------------------------------------------
+/** @brief Global setting to disable generation of skeleton dummy meshes
+ *
+ * Skeleton dummy meshes are generated as a visualization aid in cases which
+ * the input data contains no geometry, but only animation data.
+ * Property data type: bool. Default value: false
+ */
+// ---------------------------------------------------------------------------
+#define AI_CONFIG_IMPORT_NO_SKELETON_MESHES \
+    "IMPORT_NO_SKELETON_MESHES"
+
+
+
+# if 0 // not implemented yet
+// ---------------------------------------------------------------------------
+/** @brief Set Assimp's multithreading policy.
+ *
+ * This setting is ignored if Assimp was built without boost.thread
+ * support (ASSIMP_BUILD_NO_THREADING, which is implied by ASSIMP_BUILD_BOOST_WORKAROUND).
+ * Possible values are: -1 to let Assimp decide what to do, 0 to disable
+ * multithreading entirely and any number larger than 0 to force a specific
+ * number of threads. Assimp is always free to ignore this settings, which is
+ * merely a hint. Usually, the default value (-1) will be fine. However, if
+ * Assimp is used concurrently from multiple user threads, it might be useful
+ * to limit each Importer instance to a specific number of cores.
+ *
+ * For more information, see the @link threading Threading page@endlink.
+ * Property type: int, default value: -1.
+ */
+#define AI_CONFIG_GLOB_MULTITHREADING  \
+    "GLOB_MULTITHREADING"
+#endif
+
+// ###########################################################################
+// POST PROCESSING SETTINGS
+// Various stuff to fine-tune the behavior of a specific post processing step.
+// ###########################################################################
+
+
+// ---------------------------------------------------------------------------
+/** @brief Maximum bone count per mesh for the SplitbyBoneCount step.
+ *
+ * Meshes are split until the maximum number of bones is reached. The default
+ * value is AI_SBBC_DEFAULT_MAX_BONES, which may be altered at
+ * compile-time.
+ * Property data type: integer.
+ */
+// ---------------------------------------------------------------------------
+#define AI_CONFIG_PP_SBBC_MAX_BONES \
+    "PP_SBBC_MAX_BONES"
+
+
+// default limit for bone count
+#if (!defined AI_SBBC_DEFAULT_MAX_BONES)
+#   define AI_SBBC_DEFAULT_MAX_BONES        60
+#endif
+
+
+// ---------------------------------------------------------------------------
+/** @brief  Specifies the maximum angle that may be between two vertex tangents
+ *         that their tangents and bi-tangents are smoothed.
+ *
+ * This applies to the CalcTangentSpace-Step. The angle is specified
+ * in degrees. The maximum value is 175.
+ * Property type: float. Default value: 45 degrees
+ */
+#define AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE \
+    "PP_CT_MAX_SMOOTHING_ANGLE"
+
+// ---------------------------------------------------------------------------
+/** @brief Source UV channel for tangent space computation.
+ *
+ * The specified channel must exist or an error will be raised.
+ * Property type: integer. Default value: 0
+ */
+// ---------------------------------------------------------------------------
+#define AI_CONFIG_PP_CT_TEXTURE_CHANNEL_INDEX \
+    "PP_CT_TEXTURE_CHANNEL_INDEX"
+
+// ---------------------------------------------------------------------------
+/** @brief  Specifies the maximum angle that may be between two face normals
+ *          at the same vertex position that their are smoothed together.
+ *
+ * Sometimes referred to as 'crease angle'.
+ * This applies to the GenSmoothNormals-Step. The angle is specified
+ * in degrees, so 180 is PI. The default value is 175 degrees (all vertex
+ * normals are smoothed). The maximum value is 175, too. Property type: float.
+ * Warning: setting this option may cause a severe loss of performance. The
+ * performance is unaffected if the #AI_CONFIG_FAVOUR_SPEED flag is set but
+ * the output quality may be reduced.
+ */
+#define AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE \
+    "PP_GSN_MAX_SMOOTHING_ANGLE"
+
+
+// ---------------------------------------------------------------------------
+/** @brief Sets the colormap (= palette) to be used to decode embedded
+ *         textures in MDL (Quake or 3DGS) files.
+ *
+ * This must be a valid path to a file. The file is 768 (256*3) bytes
+ * large and contains RGB triplets for each of the 256 palette entries.
+ * The default value is colormap.lmp. If the file is not found,
+ * a default palette (from Quake 1) is used.
+ * Property type: string.
+ */
+#define AI_CONFIG_IMPORT_MDL_COLORMAP       \
+    "IMPORT_MDL_COLORMAP"
+
+// ---------------------------------------------------------------------------
+/** @brief Configures the #aiProcess_RemoveRedundantMaterials step to
+ *  keep materials matching a name in a given list.
+ *
+ * This is a list of 1 to n strings, ' ' serves as delimiter character.
+ * Identifiers containing whitespaces must be enclosed in *single*
+ * quotation marks. For example:<tt>
+ * "keep-me and_me_to anotherMaterialToBeKept \'name with whitespace\'"</tt>.
+ * If a material matches on of these names, it will not be modified or
+ * removed by the postprocessing step nor will other materials be replaced
+ * by a reference to it. <br>
+ * This option might be useful if you are using some magic material names
+ * to pass additional semantics through the content pipeline. This ensures
+ * they won't be optimized away, but a general optimization is still
+ * performed for materials not contained in the list.
+ * Property type: String. Default value: n/a
+ * @note Linefeeds, tabs or carriage returns are treated as whitespace.
+ *   Material names are case sensitive.
+ */
+#define AI_CONFIG_PP_RRM_EXCLUDE_LIST   \
+    "PP_RRM_EXCLUDE_LIST"
+
+// ---------------------------------------------------------------------------
+/** @brief Configures the #aiProcess_PreTransformVertices step to
+ *  keep the scene hierarchy. Meshes are moved to worldspace, but
+ *  no optimization is performed (read: meshes with equal materials are not
+ *  joined. The total number of meshes won't change).
+ *
+ * This option could be of use for you if the scene hierarchy contains
+ * important additional information which you intend to parse.
+ * For rendering, you can still render all meshes in the scene without
+ * any transformations.
+ * Property type: bool. Default value: false.
+ */
+#define AI_CONFIG_PP_PTV_KEEP_HIERARCHY     \
+    "PP_PTV_KEEP_HIERARCHY"
+
+// ---------------------------------------------------------------------------
+/** @brief Configures the #aiProcess_PreTransformVertices step to normalize
+ *  all vertex components into the [-1,1] range. That is, a bounding box
+ *  for the whole scene is computed, the maximum component is taken and all
+ *  meshes are scaled appropriately (uniformly of course!).
+ *  This might be useful if you don't know the spatial dimension of the input
+ *  data*/
+#define AI_CONFIG_PP_PTV_NORMALIZE  \
+    "PP_PTV_NORMALIZE"
+
+// ---------------------------------------------------------------------------
+/** @brief Configures the #aiProcess_PreTransformVertices step to use
+ *  a users defined matrix as the scene root node transformation before
+ *  transforming vertices.
+ *  Property type: bool. Default value: false.
+ */
+#define AI_CONFIG_PP_PTV_ADD_ROOT_TRANSFORMATION    \
+    "PP_PTV_ADD_ROOT_TRANSFORMATION"
+
+// ---------------------------------------------------------------------------
+/** @brief Configures the #aiProcess_PreTransformVertices step to use
+ *  a users defined matrix as the scene root node transformation before
+ *  transforming vertices. This property correspond to the 'a1' component
+ *  of the transformation matrix.
+ *  Property type: aiMatrix4x4.
+ */
+#define AI_CONFIG_PP_PTV_ROOT_TRANSFORMATION    \
+    "PP_PTV_ROOT_TRANSFORMATION"
+
+// ---------------------------------------------------------------------------
+/** @brief Configures the #aiProcess_FindDegenerates step to
+ *  remove degenerated primitives from the import - immediately.
+ *
+ * The default behaviour converts degenerated triangles to lines and
+ * degenerated lines to points. See the documentation to the
+ * #aiProcess_FindDegenerates step for a detailed example of the various ways
+ * to get rid of these lines and points if you don't want them.
+ * Property type: bool. Default value: false.
+ */
+#define AI_CONFIG_PP_FD_REMOVE \
+    "PP_FD_REMOVE"
+
+// ---------------------------------------------------------------------------
+/**
+ *  @brief  Configures the #aiProcess_FindDegenerates to check the area of a
+ *  trinagle to be greates than e-6. If this is not the case the triangle will
+ *  be removed if #AI_CONFIG_PP_FD_REMOVE is set to true.
+ */
+#define AI_CONFIG_PP_FD_CHECKAREA \
+    "PP_FD_CHECKAREA"
+
+// ---------------------------------------------------------------------------
+/** @brief Configures the #aiProcess_OptimizeGraph step to preserve nodes
+ * matching a name in a given list.
+ *
+ * This is a list of 1 to n strings, ' ' serves as delimiter character.
+ * Identifiers containing whitespaces must be enclosed in *single*
+ * quotation marks. For example:<tt>
+ * "keep-me and_me_to anotherNodeToBeKept \'name with whitespace\'"</tt>.
+ * If a node matches on of these names, it will not be modified or
+ * removed by the postprocessing step.<br>
+ * This option might be useful if you are using some magic node names
+ * to pass additional semantics through the content pipeline. This ensures
+ * they won't be optimized away, but a general optimization is still
+ * performed for nodes not contained in the list.
+ * Property type: String. Default value: n/a
+ * @note Linefeeds, tabs or carriage returns are treated as whitespace.
+ *   Node names are case sensitive.
+ */
+#define AI_CONFIG_PP_OG_EXCLUDE_LIST    \
+    "PP_OG_EXCLUDE_LIST"
+
+// ---------------------------------------------------------------------------
+/** @brief  Set the maximum number of triangles in a mesh.
+ *
+ * This is used by the "SplitLargeMeshes" PostProcess-Step to determine
+ * whether a mesh must be split or not.
+ * @note The default value is AI_SLM_DEFAULT_MAX_TRIANGLES
+ * Property type: integer.
+ */
+#define AI_CONFIG_PP_SLM_TRIANGLE_LIMIT \
+    "PP_SLM_TRIANGLE_LIMIT"
+
+// default value for AI_CONFIG_PP_SLM_TRIANGLE_LIMIT
+#if (!defined AI_SLM_DEFAULT_MAX_TRIANGLES)
+#   define AI_SLM_DEFAULT_MAX_TRIANGLES     1000000
+#endif
+
+// ---------------------------------------------------------------------------
+/** @brief  Set the maximum number of vertices in a mesh.
+ *
+ * This is used by the "SplitLargeMeshes" PostProcess-Step to determine
+ * whether a mesh must be split or not.
+ * @note The default value is AI_SLM_DEFAULT_MAX_VERTICES
+ * Property type: integer.
+ */
+#define AI_CONFIG_PP_SLM_VERTEX_LIMIT \
+    "PP_SLM_VERTEX_LIMIT"
+
+// default value for AI_CONFIG_PP_SLM_VERTEX_LIMIT
+#if (!defined AI_SLM_DEFAULT_MAX_VERTICES)
+#   define AI_SLM_DEFAULT_MAX_VERTICES      1000000
+#endif
+
+// ---------------------------------------------------------------------------
+/** @brief Set the maximum number of bones affecting a single vertex
+ *
+ * This is used by the #aiProcess_LimitBoneWeights PostProcess-Step.
+ * @note The default value is AI_LMW_MAX_WEIGHTS
+ * Property type: integer.*/
+#define AI_CONFIG_PP_LBW_MAX_WEIGHTS    \
+    "PP_LBW_MAX_WEIGHTS"
+
+// default value for AI_CONFIG_PP_LBW_MAX_WEIGHTS
+#if (!defined AI_LMW_MAX_WEIGHTS)
+#   define AI_LMW_MAX_WEIGHTS   0x4
+#endif // !! AI_LMW_MAX_WEIGHTS
+
+// ---------------------------------------------------------------------------
+/** @brief Lower the deboning threshold in order to remove more bones.
+ *
+ * This is used by the #aiProcess_Debone PostProcess-Step.
+ * @note The default value is AI_DEBONE_THRESHOLD
+ * Property type: float.*/
+#define AI_CONFIG_PP_DB_THRESHOLD \
+    "PP_DB_THRESHOLD"
+
+// default value for AI_CONFIG_PP_LBW_MAX_WEIGHTS
+#if (!defined AI_DEBONE_THRESHOLD)
+#   define AI_DEBONE_THRESHOLD  1.0f
+#endif // !! AI_DEBONE_THRESHOLD
+
+// ---------------------------------------------------------------------------
+/** @brief Require all bones qualify for deboning before removing any
+ *
+ * This is used by the #aiProcess_Debone PostProcess-Step.
+ * @note The default value is 0
+ * Property type: bool.*/
+#define AI_CONFIG_PP_DB_ALL_OR_NONE \
+    "PP_DB_ALL_OR_NONE"
+
+/** @brief Default value for the #AI_CONFIG_PP_ICL_PTCACHE_SIZE property
+ */
+#ifndef PP_ICL_PTCACHE_SIZE
+#   define PP_ICL_PTCACHE_SIZE 12
+#endif
+
+// ---------------------------------------------------------------------------
+/** @brief Set the size of the post-transform vertex cache to optimize the
+ *    vertices for. This configures the #aiProcess_ImproveCacheLocality step.
+ *
+ * The size is given in vertices. Of course you can't know how the vertex
+ * format will exactly look like after the import returns, but you can still
+ * guess what your meshes will probably have.
+ * @note The default value is #PP_ICL_PTCACHE_SIZE. That results in slight
+ * performance improvements for most nVidia/AMD cards since 2002.
+ * Property type: integer.
+ */
+#define AI_CONFIG_PP_ICL_PTCACHE_SIZE   "PP_ICL_PTCACHE_SIZE"
+
+// ---------------------------------------------------------------------------
+/** @brief Enumerates components of the aiScene and aiMesh data structures
+ *  that can be excluded from the import using the #aiProcess_RemoveComponent step.
+ *
+ *  See the documentation to #aiProcess_RemoveComponent for more details.
+ */
+enum aiComponent
+{
+    /** Normal vectors */
+#ifdef SWIG
+    aiComponent_NORMALS = 0x2,
+#else
+    aiComponent_NORMALS = 0x2u,
+#endif
+
+    /** Tangents and bitangents go always together ... */
+#ifdef SWIG
+    aiComponent_TANGENTS_AND_BITANGENTS = 0x4,
+#else
+    aiComponent_TANGENTS_AND_BITANGENTS = 0x4u,
+#endif
+
+    /** ALL color sets
+     * Use aiComponent_COLORn(N) to specify the N'th set */
+    aiComponent_COLORS = 0x8,
+
+    /** ALL texture UV sets
+     * aiComponent_TEXCOORDn(N) to specify the N'th set  */
+    aiComponent_TEXCOORDS = 0x10,
+
+    /** Removes all bone weights from all meshes.
+     * The scenegraph nodes corresponding to the bones are NOT removed.
+     * use the #aiProcess_OptimizeGraph step to do this */
+    aiComponent_BONEWEIGHTS = 0x20,
+
+    /** Removes all node animations (aiScene::mAnimations).
+     * The corresponding scenegraph nodes are NOT removed.
+     * use the #aiProcess_OptimizeGraph step to do this */
+    aiComponent_ANIMATIONS = 0x40,
+
+    /** Removes all embedded textures (aiScene::mTextures) */
+    aiComponent_TEXTURES = 0x80,
+
+    /** Removes all light sources (aiScene::mLights).
+     * The corresponding scenegraph nodes are NOT removed.
+     * use the #aiProcess_OptimizeGraph step to do this */
+    aiComponent_LIGHTS = 0x100,
+
+    /** Removes all cameras (aiScene::mCameras).
+     * The corresponding scenegraph nodes are NOT removed.
+     * use the #aiProcess_OptimizeGraph step to do this */
+    aiComponent_CAMERAS = 0x200,
+
+    /** Removes all meshes (aiScene::mMeshes). */
+    aiComponent_MESHES = 0x400,
+
+    /** Removes all materials. One default material will
+     * be generated, so aiScene::mNumMaterials will be 1. */
+    aiComponent_MATERIALS = 0x800,
+
+
+    /** This value is not used. It is just there to force the
+     *  compiler to map this enum to a 32 Bit integer. */
+#ifndef SWIG
+    _aiComponent_Force32Bit = 0x9fffffff
+#endif
+};
+
+// Remove a specific color channel 'n'
+#define aiComponent_COLORSn(n) (1u << (n+20u))
+
+// Remove a specific UV channel 'n'
+#define aiComponent_TEXCOORDSn(n) (1u << (n+25u))
+
+// ---------------------------------------------------------------------------
+/** @brief Input parameter to the #aiProcess_RemoveComponent step:
+ *  Specifies the parts of the data structure to be removed.
+ *
+ * See the documentation to this step for further details. The property
+ * is expected to be an integer, a bitwise combination of the
+ * #aiComponent flags defined above in this header. The default
+ * value is 0. Important: if no valid mesh is remaining after the
+ * step has been executed (e.g you thought it was funny to specify ALL
+ * of the flags defined above) the import FAILS. Mainly because there is
+ * no data to work on anymore ...
+ */
+#define AI_CONFIG_PP_RVC_FLAGS              \
+    "PP_RVC_FLAGS"
+
+// ---------------------------------------------------------------------------
+/** @brief Input parameter to the #aiProcess_SortByPType step:
+ *  Specifies which primitive types are removed by the step.
+ *
+ *  This is a bitwise combination of the aiPrimitiveType flags.
+ *  Specifying all of them is illegal, of course. A typical use would
+ *  be to exclude all line and point meshes from the import. This
+ *  is an integer property, its default value is 0.
+ */
+#define AI_CONFIG_PP_SBP_REMOVE             \
+    "PP_SBP_REMOVE"
+
+// ---------------------------------------------------------------------------
+/** @brief Input parameter to the #aiProcess_FindInvalidData step:
+ *  Specifies the floating-point accuracy for animation values. The step
+ *  checks for animation tracks where all frame values are absolutely equal
+ *  and removes them. This tweakable controls the epsilon for floating-point
+ *  comparisons - two keys are considered equal if the invariant
+ *  abs(n0-n1)>epsilon holds true for all vector respectively quaternion
+ *  components. The default value is 0.f - comparisons are exact then.
+ */
+#define AI_CONFIG_PP_FID_ANIM_ACCURACY              \
+    "PP_FID_ANIM_ACCURACY"
+
+
+// TransformUVCoords evaluates UV scalings
+#define AI_UVTRAFO_SCALING 0x1
+
+// TransformUVCoords evaluates UV rotations
+#define AI_UVTRAFO_ROTATION 0x2
+
+// TransformUVCoords evaluates UV translation
+#define AI_UVTRAFO_TRANSLATION 0x4
+
+// Everything baked together -> default value
+#define AI_UVTRAFO_ALL (AI_UVTRAFO_SCALING | AI_UVTRAFO_ROTATION | AI_UVTRAFO_TRANSLATION)
+
+// ---------------------------------------------------------------------------
+/** @brief Input parameter to the #aiProcess_TransformUVCoords step:
+ *  Specifies which UV transformations are evaluated.
+ *
+ *  This is a bitwise combination of the AI_UVTRAFO_XXX flags (integer
+ *  property, of course). By default all transformations are enabled
+ * (AI_UVTRAFO_ALL).
+ */
+#define AI_CONFIG_PP_TUV_EVALUATE               \
+    "PP_TUV_EVALUATE"
+
+// ---------------------------------------------------------------------------
+/** @brief A hint to assimp to favour speed against import quality.
+ *
+ * Enabling this option may result in faster loading, but it needn't.
+ * It represents just a hint to loaders and post-processing steps to use
+ * faster code paths, if possible.
+ * This property is expected to be an integer, != 0 stands for true.
+ * The default value is 0.
+ */
+#define AI_CONFIG_FAVOUR_SPEED              \
+ "FAVOUR_SPEED"
+
+
+// ###########################################################################
+// IMPORTER SETTINGS
+// Various stuff to fine-tune the behaviour of specific importer plugins.
+// ###########################################################################
+
+
+// ---------------------------------------------------------------------------
+/** @brief Set whether the fbx importer will merge all geometry layers present
+ *    in the source file or take only the first.
+ *
+ * The default value is true (1)
+ * Property type: bool
+ */
+#define AI_CONFIG_IMPORT_FBX_READ_ALL_GEOMETRY_LAYERS \
+    "IMPORT_FBX_READ_ALL_GEOMETRY_LAYERS"
+
+// ---------------------------------------------------------------------------
+/** @brief Set whether the fbx importer will read all materials present in the
+ *    source file or take only the referenced materials.
+ *
+ * This is void unless IMPORT_FBX_READ_MATERIALS=1.
+ *
+ * The default value is false (0)
+ * Property type: bool
+ */
+#define AI_CONFIG_IMPORT_FBX_READ_ALL_MATERIALS \
+    "IMPORT_FBX_READ_ALL_MATERIALS"
+
+// ---------------------------------------------------------------------------
+/** @brief Set whether the fbx importer will read materials.
+ *
+ * The default value is true (1)
+ * Property type: bool
+ */
+#define AI_CONFIG_IMPORT_FBX_READ_MATERIALS \
+    "IMPORT_FBX_READ_MATERIALS"
+
+// ---------------------------------------------------------------------------
+/** @brief Set whether the fbx importer will read embedded textures.
+ *
+ * The default value is true (1)
+ * Property type: bool
+ */
+#define AI_CONFIG_IMPORT_FBX_READ_TEXTURES \
+    "IMPORT_FBX_READ_TEXTURES"
+
+// ---------------------------------------------------------------------------
+/** @brief Set whether the fbx importer will read cameras.
+ *
+ * The default value is true (1)
+ * Property type: bool
+ */
+#define AI_CONFIG_IMPORT_FBX_READ_CAMERAS \
+    "IMPORT_FBX_READ_CAMERAS"
+
+// ---------------------------------------------------------------------------
+/** @brief Set whether the fbx importer will read light sources.
+ *
+ * The default value is true (1)
+ * Property type: bool
+ */
+#define AI_CONFIG_IMPORT_FBX_READ_LIGHTS \
+    "IMPORT_FBX_READ_LIGHTS"
+
+// ---------------------------------------------------------------------------
+/** @brief Set whether the fbx importer will read animations.
+ *
+ * The default value is true (1)
+ * Property type: bool
+ */
+#define AI_CONFIG_IMPORT_FBX_READ_ANIMATIONS \
+    "IMPORT_FBX_READ_ANIMATIONS"
+
+// ---------------------------------------------------------------------------
+/** @brief Set whether the fbx importer will act in strict mode in which only
+ *    FBX 2013 is supported and any other sub formats are rejected. FBX 2013
+ *    is the primary target for the importer, so this format is best
+ *    supported and well-tested.
+ *
+ * The default value is false (0)
+ * Property type: bool
+ */
+#define AI_CONFIG_IMPORT_FBX_STRICT_MODE \
+    "IMPORT_FBX_STRICT_MODE"
+
+// ---------------------------------------------------------------------------
+/** @brief Set whether the fbx importer will preserve pivot points for
+ *    transformations (as extra nodes). If set to false, pivots and offsets
+ *    will be evaluated whenever possible.
+ *
+ * The default value is true (1)
+ * Property type: bool
+ */
+#define AI_CONFIG_IMPORT_FBX_PRESERVE_PIVOTS \
+    "IMPORT_FBX_PRESERVE_PIVOTS"
+
+// ---------------------------------------------------------------------------
+/** @brief Specifies whether the importer will drop empty animation curves or
+ *    animation curves which match the bind pose transformation over their
+ *    entire defined range.
+ *
+ * The default value is true (1)
+ * Property type: bool
+ */
+#define AI_CONFIG_IMPORT_FBX_OPTIMIZE_EMPTY_ANIMATION_CURVES \
+    "IMPORT_FBX_OPTIMIZE_EMPTY_ANIMATION_CURVES"
+
+// ---------------------------------------------------------------------------
+/** @brief Set whether the fbx importer will use the legacy embedded texture naming.
+*
+* The default value is false (0)
+* Property type: bool
+*/
+#define AI_CONFIG_IMPORT_FBX_EMBEDDED_TEXTURES_LEGACY_NAMING \
+	"AI_CONFIG_IMPORT_FBX_EMBEDDED_TEXTURES_LEGACY_NAMING"
+	
+// ---------------------------------------------------------------------------
+/** @brief  Set the vertex animation keyframe to be imported
+ *
+ * ASSIMP does not support vertex keyframes (only bone animation is supported).
+ * The library reads only one frame of models with vertex animations.
+ * By default this is the first frame.
+ * \note The default value is 0. This option applies to all importers.
+ *   However, it is also possible to override the global setting
+ *   for a specific loader. You can use the AI_CONFIG_IMPORT_XXX_KEYFRAME
+ *   options (where XXX is a placeholder for the file format for which you
+ *   want to override the global setting).
+ * Property type: integer.
+ */
+#define AI_CONFIG_IMPORT_GLOBAL_KEYFRAME    "IMPORT_GLOBAL_KEYFRAME"
+
+#define AI_CONFIG_IMPORT_MD3_KEYFRAME       "IMPORT_MD3_KEYFRAME"
+#define AI_CONFIG_IMPORT_MD2_KEYFRAME       "IMPORT_MD2_KEYFRAME"
+#define AI_CONFIG_IMPORT_MDL_KEYFRAME       "IMPORT_MDL_KEYFRAME"
+#define AI_CONFIG_IMPORT_MDC_KEYFRAME       "IMPORT_MDC_KEYFRAME"
+#define AI_CONFIG_IMPORT_SMD_KEYFRAME       "IMPORT_SMD_KEYFRAME"
+#define AI_CONFIG_IMPORT_UNREAL_KEYFRAME    "IMPORT_UNREAL_KEYFRAME"
+
+
+// ---------------------------------------------------------------------------
+/** @brief  Configures the AC loader to collect all surfaces which have the
+ *    "Backface cull" flag set in separate meshes.
+ *
+ *  Property type: bool. Default value: true.
+ */
+#define AI_CONFIG_IMPORT_AC_SEPARATE_BFCULL \
+    "IMPORT_AC_SEPARATE_BFCULL"
+
+// ---------------------------------------------------------------------------
+/** @brief  Configures whether the AC loader evaluates subdivision surfaces (
+ *  indicated by the presence of the 'subdiv' attribute in the file). By
+ *  default, Assimp performs the subdivision using the standard
+ *  Catmull-Clark algorithm
+ *
+ * * Property type: bool. Default value: true.
+ */
+#define AI_CONFIG_IMPORT_AC_EVAL_SUBDIVISION    \
+    "IMPORT_AC_EVAL_SUBDIVISION"
+
+// ---------------------------------------------------------------------------
+/** @brief  Configures the UNREAL 3D loader to separate faces with different
+ *    surface flags (e.g. two-sided vs. single-sided).
+ *
+ * * Property type: bool. Default value: true.
+ */
+#define AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS \
+    "UNREAL_HANDLE_FLAGS"
+
+// ---------------------------------------------------------------------------
+/** @brief Configures the terragen import plugin to compute uv's for
+ *  terrains, if not given. Furthermore a default texture is assigned.
+ *
+ * UV coordinates for terrains are so simple to compute that you'll usually
+ * want to compute them on your own, if you need them. This option is intended
+ * for model viewers which want to offer an easy way to apply textures to
+ * terrains.
+ * * Property type: bool. Default value: false.
+ */
+#define AI_CONFIG_IMPORT_TER_MAKE_UVS \
+    "IMPORT_TER_MAKE_UVS"
+
+// ---------------------------------------------------------------------------
+/** @brief  Configures the ASE loader to always reconstruct normal vectors
+ *  basing on the smoothing groups loaded from the file.
+ *
+ * Some ASE files have carry invalid normals, other don't.
+ * * Property type: bool. Default value: true.
+ */
+#define AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS    \
+    "IMPORT_ASE_RECONSTRUCT_NORMALS"
+
+// ---------------------------------------------------------------------------
+/** @brief  Configures the M3D loader to detect and process multi-part
+ *    Quake player models.
+ *
+ * These models usually consist of 3 files, lower.md3, upper.md3 and
+ * head.md3. If this property is set to true, Assimp will try to load and
+ * combine all three files if one of them is loaded.
+ * Property type: bool. Default value: true.
+ */
+#define AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART \
+    "IMPORT_MD3_HANDLE_MULTIPART"
+
+// ---------------------------------------------------------------------------
+/** @brief  Tells the MD3 loader which skin files to load.
+ *
+ * When loading MD3 files, Assimp checks whether a file
+ * [md3_file_name]_[skin_name].skin is existing. These files are used by
+ * Quake III to be able to assign different skins (e.g. red and blue team)
+ * to models. 'default', 'red', 'blue' are typical skin names.
+ * Property type: String. Default value: "default".
+ */
+#define AI_CONFIG_IMPORT_MD3_SKIN_NAME \
+    "IMPORT_MD3_SKIN_NAME"
+
+// ---------------------------------------------------------------------------
+/** @brief  Specify the Quake 3 shader file to be used for a particular
+ *  MD3 file. This can also be a search path.
+ *
+ * By default Assimp's behaviour is as follows: If a MD3 file
+ * <tt>any_path/models/any_q3_subdir/model_name/file_name.md3</tt> is
+ * loaded, the library tries to locate the corresponding shader file in
+ * <tt>any_path/scripts/model_name.shader</tt>. This property overrides this
+ * behaviour. It can either specify a full path to the shader to be loaded
+ * or alternatively the path (relative or absolute) to the directory where
+ * the shaders for all MD3s to be loaded reside. Assimp attempts to open
+ * <tt>IMPORT_MD3_SHADER_SRC/model_name.shader</tt> first, <tt>IMPORT_MD3_SHADER_SRC/file_name.shader</tt>
+ * is the fallback file. Note that IMPORT_MD3_SHADER_SRC should have a terminal (back)slash.
+ * Property type: String. Default value: n/a.
+ */
+#define AI_CONFIG_IMPORT_MD3_SHADER_SRC \
+    "IMPORT_MD3_SHADER_SRC"
+
+// ---------------------------------------------------------------------------
+/** @brief  Configures the LWO loader to load just one layer from the model.
+ *
+ * LWO files consist of layers and in some cases it could be useful to load
+ * only one of them. This property can be either a string - which specifies
+ * the name of the layer - or an integer - the index of the layer. If the
+ * property is not set the whole LWO model is loaded. Loading fails if the
+ * requested layer is not available. The layer index is zero-based and the
+ * layer name may not be empty.<br>
+ * Property type: Integer. Default value: all layers are loaded.
+ */
+#define AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY         \
+    "IMPORT_LWO_ONE_LAYER_ONLY"
+
+// ---------------------------------------------------------------------------
+/** @brief  Configures the MD5 loader to not load the MD5ANIM file for
+ *  a MD5MESH file automatically.
+ *
+ * The default strategy is to look for a file with the same name but the
+ * MD5ANIM extension in the same directory. If it is found, it is loaded
+ * and combined with the MD5MESH file. This configuration option can be
+ * used to disable this behaviour.
+ *
+ * * Property type: bool. Default value: false.
+ */
+#define AI_CONFIG_IMPORT_MD5_NO_ANIM_AUTOLOAD           \
+    "IMPORT_MD5_NO_ANIM_AUTOLOAD"
+
+// ---------------------------------------------------------------------------
+/** @brief Defines the begin of the time range for which the LWS loader
+ *    evaluates animations and computes aiNodeAnim's.
+ *
+ * Assimp provides full conversion of LightWave's envelope system, including
+ * pre and post conditions. The loader computes linearly subsampled animation
+ * chanels with the frame rate given in the LWS file. This property defines
+ * the start time. Note: animation channels are only generated if a node
+ * has at least one envelope with more tan one key assigned. This property.
+ * is given in frames, '0' is the first frame. By default, if this property
+ * is not set, the importer takes the animation start from the input LWS
+ * file ('FirstFrame' line)<br>
+ * Property type: Integer. Default value: taken from file.
+ *
+ * @see AI_CONFIG_IMPORT_LWS_ANIM_END - end of the imported time range
+ */
+#define AI_CONFIG_IMPORT_LWS_ANIM_START         \
+    "IMPORT_LWS_ANIM_START"
+#define AI_CONFIG_IMPORT_LWS_ANIM_END           \
+    "IMPORT_LWS_ANIM_END"
+
+// ---------------------------------------------------------------------------
+/** @brief Defines the output frame rate of the IRR loader.
+ *
+ * IRR animations are difficult to convert for Assimp and there will
+ * always be a loss of quality. This setting defines how many keys per second
+ * are returned by the converter.<br>
+ * Property type: integer. Default value: 100
+ */
+#define AI_CONFIG_IMPORT_IRR_ANIM_FPS               \
+    "IMPORT_IRR_ANIM_FPS"
+
+// ---------------------------------------------------------------------------
+/** @brief Ogre Importer will try to find referenced materials from this file.
+ *
+ * Ogre meshes reference with material names, this does not tell Assimp the file
+ * where it is located in. Assimp will try to find the source file in the following
+ * order: <material-name>.material, <mesh-filename-base>.material and
+ * lastly the material name defined by this config property.
+ * <br>
+ * Property type: String. Default value: Scene.material.
+ */
+#define AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE \
+    "IMPORT_OGRE_MATERIAL_FILE"
+
+// ---------------------------------------------------------------------------
+/** @brief Ogre Importer detect the texture usage from its filename.
+ *
+ * Ogre material texture units do not define texture type, the textures usage
+ * depends on the used shader or Ogre's fixed pipeline. If this config property
+ * is true Assimp will try to detect the type from the textures filename postfix:
+ * _n, _nrm, _nrml, _normal, _normals and _normalmap for normal map, _s, _spec,
+ * _specular and _specularmap for specular map, _l, _light, _lightmap, _occ
+ * and _occlusion for light map, _disp and _displacement for displacement map.
+ * The matching is case insensitive. Post fix is taken between the last
+ * underscore and the last period.
+ * Default behavior is to detect type from lower cased texture unit name by
+ * matching against: normalmap, specularmap, lightmap and displacementmap.
+ * For both cases if no match is found aiTextureType_DIFFUSE is used.
+ * <br>
+ * Property type: Bool. Default value: false.
+ */
+#define AI_CONFIG_IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME \
+    "IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME"
+
+ /** @brief Specifies whether the Android JNI asset extraction is supported.
+  *
+  * Turn on this option if you want to manage assets in native
+  * Android application without having to keep the internal directory and asset
+  * manager pointer.
+  */
+ #define AI_CONFIG_ANDROID_JNI_ASSIMP_MANAGER_SUPPORT "AI_CONFIG_ANDROID_JNI_ASSIMP_MANAGER_SUPPORT"
+
+// ---------------------------------------------------------------------------
+/** @brief Specifies whether the IFC loader skips over IfcSpace elements.
+ *
+ * IfcSpace elements (and their geometric representations) are used to
+ * represent, well, free space in a building storey.<br>
+ * Property type: Bool. Default value: true.
+ */
+#define AI_CONFIG_IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS "IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS"
+
+// ---------------------------------------------------------------------------
+/** @brief Specifies whether the IFC loader will use its own, custom triangulation
+ *   algorithm to triangulate wall and floor meshes.
+ *
+ * If this property is set to false, walls will be either triangulated by
+ * #aiProcess_Triangulate or will be passed through as huge polygons with
+ * faked holes (i.e. holes that are connected with the outer boundary using
+ * a dummy edge). It is highly recommended to set this property to true
+ * if you want triangulated data because #aiProcess_Triangulate is known to
+ * have problems with the kind of polygons that the IFC loader spits out for
+ * complicated meshes.
+ * Property type: Bool. Default value: true.
+ */
+#define AI_CONFIG_IMPORT_IFC_CUSTOM_TRIANGULATION "IMPORT_IFC_CUSTOM_TRIANGULATION"
+
+// ---------------------------------------------------------------------------
+/** @brief  Set the tessellation conic angle for IFC smoothing curves.
+ *
+ * This is used by the IFC importer to determine the tessellation parameter
+ * for smoothing curves.
+ * @note The default value is AI_IMPORT_IFC_DEFAULT_SMOOTHING_ANGLE and the
+ * accepted values are in range [5.0, 120.0].
+ * Property type: Float.
+ */
+#define AI_CONFIG_IMPORT_IFC_SMOOTHING_ANGLE "IMPORT_IFC_SMOOTHING_ANGLE"
+
+// default value for AI_CONFIG_IMPORT_IFC_SMOOTHING_ANGLE
+#if (!defined AI_IMPORT_IFC_DEFAULT_SMOOTHING_ANGLE)
+#   define AI_IMPORT_IFC_DEFAULT_SMOOTHING_ANGLE 10.0f
+#endif
+
+// ---------------------------------------------------------------------------
+/** @brief  Set the tessellation for IFC cylindrical shapes.
+ *
+ * This is used by the IFC importer to determine the tessellation parameter
+ * for cylindrical shapes, i.e. the number of segments used to approximate a circle.
+ * @note The default value is AI_IMPORT_IFC_DEFAULT_CYLINDRICAL_TESSELLATION and the
+ * accepted values are in range [3, 180].
+ * Property type: Integer.
+ */
+#define AI_CONFIG_IMPORT_IFC_CYLINDRICAL_TESSELLATION "IMPORT_IFC_CYLINDRICAL_TESSELLATION"
+
+// default value for AI_CONFIG_IMPORT_IFC_CYLINDRICAL_TESSELLATION
+#if (!defined AI_IMPORT_IFC_DEFAULT_CYLINDRICAL_TESSELLATION)
+#   define AI_IMPORT_IFC_DEFAULT_CYLINDRICAL_TESSELLATION 32
+#endif
+
+// ---------------------------------------------------------------------------
+/** @brief Specifies whether the Collada loader will ignore the provided up direction.
+ *
+ * If this property is set to true, the up direction provided in the file header will
+ * be ignored and the file will be loaded as is.
+ * Property type: Bool. Default value: false.
+ */
+#define AI_CONFIG_IMPORT_COLLADA_IGNORE_UP_DIRECTION "IMPORT_COLLADA_IGNORE_UP_DIRECTION"
+
+// ---------------------------------------------------------------------------
+/** @brief Specifies whether the Collada loader should use Collada names as node names.
+ *
+ * If this property is set to true, the Collada names will be used as the
+ * node name. The default is to use the id tag (resp. sid tag, if no id tag is present)
+ * instead.
+ * Property type: Bool. Default value: false.
+ */
+#define AI_CONFIG_IMPORT_COLLADA_USE_COLLADA_NAMES "IMPORT_COLLADA_USE_COLLADA_NAMES"
+
+// ---------- All the Export defines ------------
+
+/** @brief Specifies the xfile use double for real values of float
+ *
+ * Property type: Bool. Default value: false.
+ */
+
+#define AI_CONFIG_EXPORT_XFILE_64BIT "EXPORT_XFILE_64BIT"
+
+/**
+ *  @brief  Specifies a gobal key factor for scale, float value
+ */
+#define AI_CONFIG_GLOBAL_SCALE_FACTOR_KEY "GLOBAL_SCALE_FACTOR"
+
+#if (!defined AI_CONFIG_GLOBAL_SCALE_FACTOR_DEFAULT)
+#   define AI_CONFIG_GLOBAL_SCALE_FACTOR_DEFAULT  1.0f
+#endif // !! AI_DEBONE_THRESHOLD
+
+// ---------- All the Build/Compile-time defines ------------
+
+/** @brief Specifies if double precision is supported inside assimp
+ *
+ * Property type: Bool. Default value: undefined.
+ */
+
+/* #undef ASSIMP_DOUBLE_PRECISION */
+
+#endif // !! AI_CONFIG_H_INC
diff --git a/engine/inc/assimp/config.h.in b/engine/inc/assimp/config.h.in
new file mode 100644
index 00000000..c9555fb3
--- /dev/null
+++ b/engine/inc/assimp/config.h.in
@@ -0,0 +1,974 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file config.h
+ *  @brief Defines constants for configurable properties for the library
+ *
+ *  Typically these properties are set via
+ *  #Assimp::Importer::SetPropertyFloat,
+ *  #Assimp::Importer::SetPropertyInteger or
+ *  #Assimp::Importer::SetPropertyString,
+ *  depending on the data type of a property. All properties have a
+ *  default value. See the doc for the mentioned methods for more details.
+ *
+ *  <br><br>
+ *  The corresponding functions for use with the plain-c API are:
+ *  #aiSetImportPropertyInteger,
+ *  #aiSetImportPropertyFloat,
+ *  #aiSetImportPropertyString
+ */
+#pragma once
+#ifndef AI_CONFIG_H_INC
+#define AI_CONFIG_H_INC
+
+
+// ###########################################################################
+// LIBRARY SETTINGS
+// General, global settings
+// ###########################################################################
+
+// ---------------------------------------------------------------------------
+/** @brief Enables time measurements.
+ *
+ *  If enabled, measures the time needed for each part of the loading
+ *  process (i.e. IO time, importing, postprocessing, ..) and dumps
+ *  these timings to the DefaultLogger. See the @link perf Performance
+ *  Page@endlink for more information on this topic.
+ *
+ * Property type: bool. Default value: false.
+ */
+#define AI_CONFIG_GLOB_MEASURE_TIME  \
+    "GLOB_MEASURE_TIME"
+
+
+// ---------------------------------------------------------------------------
+/** @brief Global setting to disable generation of skeleton dummy meshes
+ *
+ * Skeleton dummy meshes are generated as a visualization aid in cases which
+ * the input data contains no geometry, but only animation data.
+ * Property data type: bool. Default value: false
+ */
+// ---------------------------------------------------------------------------
+#define AI_CONFIG_IMPORT_NO_SKELETON_MESHES \
+    "IMPORT_NO_SKELETON_MESHES"
+
+
+
+# if 0 // not implemented yet
+// ---------------------------------------------------------------------------
+/** @brief Set Assimp's multithreading policy.
+ *
+ * This setting is ignored if Assimp was built without boost.thread
+ * support (ASSIMP_BUILD_NO_THREADING, which is implied by ASSIMP_BUILD_BOOST_WORKAROUND).
+ * Possible values are: -1 to let Assimp decide what to do, 0 to disable
+ * multithreading entirely and any number larger than 0 to force a specific
+ * number of threads. Assimp is always free to ignore this settings, which is
+ * merely a hint. Usually, the default value (-1) will be fine. However, if
+ * Assimp is used concurrently from multiple user threads, it might be useful
+ * to limit each Importer instance to a specific number of cores.
+ *
+ * For more information, see the @link threading Threading page@endlink.
+ * Property type: int, default value: -1.
+ */
+#define AI_CONFIG_GLOB_MULTITHREADING  \
+    "GLOB_MULTITHREADING"
+#endif
+
+// ###########################################################################
+// POST PROCESSING SETTINGS
+// Various stuff to fine-tune the behavior of a specific post processing step.
+// ###########################################################################
+
+
+// ---------------------------------------------------------------------------
+/** @brief Maximum bone count per mesh for the SplitbyBoneCount step.
+ *
+ * Meshes are split until the maximum number of bones is reached. The default
+ * value is AI_SBBC_DEFAULT_MAX_BONES, which may be altered at
+ * compile-time.
+ * Property data type: integer.
+ */
+// ---------------------------------------------------------------------------
+#define AI_CONFIG_PP_SBBC_MAX_BONES \
+    "PP_SBBC_MAX_BONES"
+
+
+// default limit for bone count
+#if (!defined AI_SBBC_DEFAULT_MAX_BONES)
+#   define AI_SBBC_DEFAULT_MAX_BONES        60
+#endif
+
+
+// ---------------------------------------------------------------------------
+/** @brief  Specifies the maximum angle that may be between two vertex tangents
+ *         that their tangents and bi-tangents are smoothed.
+ *
+ * This applies to the CalcTangentSpace-Step. The angle is specified
+ * in degrees. The maximum value is 175.
+ * Property type: float. Default value: 45 degrees
+ */
+#define AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE \
+    "PP_CT_MAX_SMOOTHING_ANGLE"
+
+// ---------------------------------------------------------------------------
+/** @brief Source UV channel for tangent space computation.
+ *
+ * The specified channel must exist or an error will be raised.
+ * Property type: integer. Default value: 0
+ */
+// ---------------------------------------------------------------------------
+#define AI_CONFIG_PP_CT_TEXTURE_CHANNEL_INDEX \
+    "PP_CT_TEXTURE_CHANNEL_INDEX"
+
+// ---------------------------------------------------------------------------
+/** @brief  Specifies the maximum angle that may be between two face normals
+ *          at the same vertex position that their are smoothed together.
+ *
+ * Sometimes referred to as 'crease angle'.
+ * This applies to the GenSmoothNormals-Step. The angle is specified
+ * in degrees, so 180 is PI. The default value is 175 degrees (all vertex
+ * normals are smoothed). The maximum value is 175, too. Property type: float.
+ * Warning: setting this option may cause a severe loss of performance. The
+ * performance is unaffected if the #AI_CONFIG_FAVOUR_SPEED flag is set but
+ * the output quality may be reduced.
+ */
+#define AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE \
+    "PP_GSN_MAX_SMOOTHING_ANGLE"
+
+
+// ---------------------------------------------------------------------------
+/** @brief Sets the colormap (= palette) to be used to decode embedded
+ *         textures in MDL (Quake or 3DGS) files.
+ *
+ * This must be a valid path to a file. The file is 768 (256*3) bytes
+ * large and contains RGB triplets for each of the 256 palette entries.
+ * The default value is colormap.lmp. If the file is not found,
+ * a default palette (from Quake 1) is used.
+ * Property type: string.
+ */
+#define AI_CONFIG_IMPORT_MDL_COLORMAP       \
+    "IMPORT_MDL_COLORMAP"
+
+// ---------------------------------------------------------------------------
+/** @brief Configures the #aiProcess_RemoveRedundantMaterials step to
+ *  keep materials matching a name in a given list.
+ *
+ * This is a list of 1 to n strings, ' ' serves as delimiter character.
+ * Identifiers containing whitespaces must be enclosed in *single*
+ * quotation marks. For example:<tt>
+ * "keep-me and_me_to anotherMaterialToBeKept \'name with whitespace\'"</tt>.
+ * If a material matches on of these names, it will not be modified or
+ * removed by the postprocessing step nor will other materials be replaced
+ * by a reference to it. <br>
+ * This option might be useful if you are using some magic material names
+ * to pass additional semantics through the content pipeline. This ensures
+ * they won't be optimized away, but a general optimization is still
+ * performed for materials not contained in the list.
+ * Property type: String. Default value: n/a
+ * @note Linefeeds, tabs or carriage returns are treated as whitespace.
+ *   Material names are case sensitive.
+ */
+#define AI_CONFIG_PP_RRM_EXCLUDE_LIST   \
+    "PP_RRM_EXCLUDE_LIST"
+
+// ---------------------------------------------------------------------------
+/** @brief Configures the #aiProcess_PreTransformVertices step to
+ *  keep the scene hierarchy. Meshes are moved to worldspace, but
+ *  no optimization is performed (read: meshes with equal materials are not
+ *  joined. The total number of meshes won't change).
+ *
+ * This option could be of use for you if the scene hierarchy contains
+ * important additional information which you intend to parse.
+ * For rendering, you can still render all meshes in the scene without
+ * any transformations.
+ * Property type: bool. Default value: false.
+ */
+#define AI_CONFIG_PP_PTV_KEEP_HIERARCHY     \
+    "PP_PTV_KEEP_HIERARCHY"
+
+// ---------------------------------------------------------------------------
+/** @brief Configures the #aiProcess_PreTransformVertices step to normalize
+ *  all vertex components into the [-1,1] range. That is, a bounding box
+ *  for the whole scene is computed, the maximum component is taken and all
+ *  meshes are scaled appropriately (uniformly of course!).
+ *  This might be useful if you don't know the spatial dimension of the input
+ *  data*/
+#define AI_CONFIG_PP_PTV_NORMALIZE  \
+    "PP_PTV_NORMALIZE"
+
+// ---------------------------------------------------------------------------
+/** @brief Configures the #aiProcess_PreTransformVertices step to use
+ *  a users defined matrix as the scene root node transformation before
+ *  transforming vertices.
+ *  Property type: bool. Default value: false.
+ */
+#define AI_CONFIG_PP_PTV_ADD_ROOT_TRANSFORMATION    \
+    "PP_PTV_ADD_ROOT_TRANSFORMATION"
+
+// ---------------------------------------------------------------------------
+/** @brief Configures the #aiProcess_PreTransformVertices step to use
+ *  a users defined matrix as the scene root node transformation before
+ *  transforming vertices. This property correspond to the 'a1' component
+ *  of the transformation matrix.
+ *  Property type: aiMatrix4x4.
+ */
+#define AI_CONFIG_PP_PTV_ROOT_TRANSFORMATION    \
+    "PP_PTV_ROOT_TRANSFORMATION"
+
+// ---------------------------------------------------------------------------
+/** @brief Configures the #aiProcess_FindDegenerates step to
+ *  remove degenerated primitives from the import - immediately.
+ *
+ * The default behaviour converts degenerated triangles to lines and
+ * degenerated lines to points. See the documentation to the
+ * #aiProcess_FindDegenerates step for a detailed example of the various ways
+ * to get rid of these lines and points if you don't want them.
+ * Property type: bool. Default value: false.
+ */
+#define AI_CONFIG_PP_FD_REMOVE \
+    "PP_FD_REMOVE"
+
+// ---------------------------------------------------------------------------
+/**
+ *  @brief  Configures the #aiProcess_FindDegenerates to check the area of a
+ *  trinagle to be greates than e-6. If this is not the case the triangle will
+ *  be removed if #AI_CONFIG_PP_FD_REMOVE is set to true.
+ */
+#define AI_CONFIG_PP_FD_CHECKAREA \
+    "PP_FD_CHECKAREA"
+
+// ---------------------------------------------------------------------------
+/** @brief Configures the #aiProcess_OptimizeGraph step to preserve nodes
+ * matching a name in a given list.
+ *
+ * This is a list of 1 to n strings, ' ' serves as delimiter character.
+ * Identifiers containing whitespaces must be enclosed in *single*
+ * quotation marks. For example:<tt>
+ * "keep-me and_me_to anotherNodeToBeKept \'name with whitespace\'"</tt>.
+ * If a node matches on of these names, it will not be modified or
+ * removed by the postprocessing step.<br>
+ * This option might be useful if you are using some magic node names
+ * to pass additional semantics through the content pipeline. This ensures
+ * they won't be optimized away, but a general optimization is still
+ * performed for nodes not contained in the list.
+ * Property type: String. Default value: n/a
+ * @note Linefeeds, tabs or carriage returns are treated as whitespace.
+ *   Node names are case sensitive.
+ */
+#define AI_CONFIG_PP_OG_EXCLUDE_LIST    \
+    "PP_OG_EXCLUDE_LIST"
+
+// ---------------------------------------------------------------------------
+/** @brief  Set the maximum number of triangles in a mesh.
+ *
+ * This is used by the "SplitLargeMeshes" PostProcess-Step to determine
+ * whether a mesh must be split or not.
+ * @note The default value is AI_SLM_DEFAULT_MAX_TRIANGLES
+ * Property type: integer.
+ */
+#define AI_CONFIG_PP_SLM_TRIANGLE_LIMIT \
+    "PP_SLM_TRIANGLE_LIMIT"
+
+// default value for AI_CONFIG_PP_SLM_TRIANGLE_LIMIT
+#if (!defined AI_SLM_DEFAULT_MAX_TRIANGLES)
+#   define AI_SLM_DEFAULT_MAX_TRIANGLES     1000000
+#endif
+
+// ---------------------------------------------------------------------------
+/** @brief  Set the maximum number of vertices in a mesh.
+ *
+ * This is used by the "SplitLargeMeshes" PostProcess-Step to determine
+ * whether a mesh must be split or not.
+ * @note The default value is AI_SLM_DEFAULT_MAX_VERTICES
+ * Property type: integer.
+ */
+#define AI_CONFIG_PP_SLM_VERTEX_LIMIT \
+    "PP_SLM_VERTEX_LIMIT"
+
+// default value for AI_CONFIG_PP_SLM_VERTEX_LIMIT
+#if (!defined AI_SLM_DEFAULT_MAX_VERTICES)
+#   define AI_SLM_DEFAULT_MAX_VERTICES      1000000
+#endif
+
+// ---------------------------------------------------------------------------
+/** @brief Set the maximum number of bones affecting a single vertex
+ *
+ * This is used by the #aiProcess_LimitBoneWeights PostProcess-Step.
+ * @note The default value is AI_LMW_MAX_WEIGHTS
+ * Property type: integer.*/
+#define AI_CONFIG_PP_LBW_MAX_WEIGHTS    \
+    "PP_LBW_MAX_WEIGHTS"
+
+// default value for AI_CONFIG_PP_LBW_MAX_WEIGHTS
+#if (!defined AI_LMW_MAX_WEIGHTS)
+#   define AI_LMW_MAX_WEIGHTS   0x4
+#endif // !! AI_LMW_MAX_WEIGHTS
+
+// ---------------------------------------------------------------------------
+/** @brief Lower the deboning threshold in order to remove more bones.
+ *
+ * This is used by the #aiProcess_Debone PostProcess-Step.
+ * @note The default value is AI_DEBONE_THRESHOLD
+ * Property type: float.*/
+#define AI_CONFIG_PP_DB_THRESHOLD \
+    "PP_DB_THRESHOLD"
+
+// default value for AI_CONFIG_PP_LBW_MAX_WEIGHTS
+#if (!defined AI_DEBONE_THRESHOLD)
+#   define AI_DEBONE_THRESHOLD  1.0f
+#endif // !! AI_DEBONE_THRESHOLD
+
+// ---------------------------------------------------------------------------
+/** @brief Require all bones qualify for deboning before removing any
+ *
+ * This is used by the #aiProcess_Debone PostProcess-Step.
+ * @note The default value is 0
+ * Property type: bool.*/
+#define AI_CONFIG_PP_DB_ALL_OR_NONE \
+    "PP_DB_ALL_OR_NONE"
+
+/** @brief Default value for the #AI_CONFIG_PP_ICL_PTCACHE_SIZE property
+ */
+#ifndef PP_ICL_PTCACHE_SIZE
+#   define PP_ICL_PTCACHE_SIZE 12
+#endif
+
+// ---------------------------------------------------------------------------
+/** @brief Set the size of the post-transform vertex cache to optimize the
+ *    vertices for. This configures the #aiProcess_ImproveCacheLocality step.
+ *
+ * The size is given in vertices. Of course you can't know how the vertex
+ * format will exactly look like after the import returns, but you can still
+ * guess what your meshes will probably have.
+ * @note The default value is #PP_ICL_PTCACHE_SIZE. That results in slight
+ * performance improvements for most nVidia/AMD cards since 2002.
+ * Property type: integer.
+ */
+#define AI_CONFIG_PP_ICL_PTCACHE_SIZE   "PP_ICL_PTCACHE_SIZE"
+
+// ---------------------------------------------------------------------------
+/** @brief Enumerates components of the aiScene and aiMesh data structures
+ *  that can be excluded from the import using the #aiProcess_RemoveComponent step.
+ *
+ *  See the documentation to #aiProcess_RemoveComponent for more details.
+ */
+enum aiComponent
+{
+    /** Normal vectors */
+#ifdef SWIG
+    aiComponent_NORMALS = 0x2,
+#else
+    aiComponent_NORMALS = 0x2u,
+#endif
+
+    /** Tangents and bitangents go always together ... */
+#ifdef SWIG
+    aiComponent_TANGENTS_AND_BITANGENTS = 0x4,
+#else
+    aiComponent_TANGENTS_AND_BITANGENTS = 0x4u,
+#endif
+
+    /** ALL color sets
+     * Use aiComponent_COLORn(N) to specify the N'th set */
+    aiComponent_COLORS = 0x8,
+
+    /** ALL texture UV sets
+     * aiComponent_TEXCOORDn(N) to specify the N'th set  */
+    aiComponent_TEXCOORDS = 0x10,
+
+    /** Removes all bone weights from all meshes.
+     * The scenegraph nodes corresponding to the bones are NOT removed.
+     * use the #aiProcess_OptimizeGraph step to do this */
+    aiComponent_BONEWEIGHTS = 0x20,
+
+    /** Removes all node animations (aiScene::mAnimations).
+     * The corresponding scenegraph nodes are NOT removed.
+     * use the #aiProcess_OptimizeGraph step to do this */
+    aiComponent_ANIMATIONS = 0x40,
+
+    /** Removes all embedded textures (aiScene::mTextures) */
+    aiComponent_TEXTURES = 0x80,
+
+    /** Removes all light sources (aiScene::mLights).
+     * The corresponding scenegraph nodes are NOT removed.
+     * use the #aiProcess_OptimizeGraph step to do this */
+    aiComponent_LIGHTS = 0x100,
+
+    /** Removes all cameras (aiScene::mCameras).
+     * The corresponding scenegraph nodes are NOT removed.
+     * use the #aiProcess_OptimizeGraph step to do this */
+    aiComponent_CAMERAS = 0x200,
+
+    /** Removes all meshes (aiScene::mMeshes). */
+    aiComponent_MESHES = 0x400,
+
+    /** Removes all materials. One default material will
+     * be generated, so aiScene::mNumMaterials will be 1. */
+    aiComponent_MATERIALS = 0x800,
+
+
+    /** This value is not used. It is just there to force the
+     *  compiler to map this enum to a 32 Bit integer. */
+#ifndef SWIG
+    _aiComponent_Force32Bit = 0x9fffffff
+#endif
+};
+
+// Remove a specific color channel 'n'
+#define aiComponent_COLORSn(n) (1u << (n+20u))
+
+// Remove a specific UV channel 'n'
+#define aiComponent_TEXCOORDSn(n) (1u << (n+25u))
+
+// ---------------------------------------------------------------------------
+/** @brief Input parameter to the #aiProcess_RemoveComponent step:
+ *  Specifies the parts of the data structure to be removed.
+ *
+ * See the documentation to this step for further details. The property
+ * is expected to be an integer, a bitwise combination of the
+ * #aiComponent flags defined above in this header. The default
+ * value is 0. Important: if no valid mesh is remaining after the
+ * step has been executed (e.g you thought it was funny to specify ALL
+ * of the flags defined above) the import FAILS. Mainly because there is
+ * no data to work on anymore ...
+ */
+#define AI_CONFIG_PP_RVC_FLAGS              \
+    "PP_RVC_FLAGS"
+
+// ---------------------------------------------------------------------------
+/** @brief Input parameter to the #aiProcess_SortByPType step:
+ *  Specifies which primitive types are removed by the step.
+ *
+ *  This is a bitwise combination of the aiPrimitiveType flags.
+ *  Specifying all of them is illegal, of course. A typical use would
+ *  be to exclude all line and point meshes from the import. This
+ *  is an integer property, its default value is 0.
+ */
+#define AI_CONFIG_PP_SBP_REMOVE             \
+    "PP_SBP_REMOVE"
+
+// ---------------------------------------------------------------------------
+/** @brief Input parameter to the #aiProcess_FindInvalidData step:
+ *  Specifies the floating-point accuracy for animation values. The step
+ *  checks for animation tracks where all frame values are absolutely equal
+ *  and removes them. This tweakable controls the epsilon for floating-point
+ *  comparisons - two keys are considered equal if the invariant
+ *  abs(n0-n1)>epsilon holds true for all vector respectively quaternion
+ *  components. The default value is 0.f - comparisons are exact then.
+ */
+#define AI_CONFIG_PP_FID_ANIM_ACCURACY              \
+    "PP_FID_ANIM_ACCURACY"
+
+
+// TransformUVCoords evaluates UV scalings
+#define AI_UVTRAFO_SCALING 0x1
+
+// TransformUVCoords evaluates UV rotations
+#define AI_UVTRAFO_ROTATION 0x2
+
+// TransformUVCoords evaluates UV translation
+#define AI_UVTRAFO_TRANSLATION 0x4
+
+// Everything baked together -> default value
+#define AI_UVTRAFO_ALL (AI_UVTRAFO_SCALING | AI_UVTRAFO_ROTATION | AI_UVTRAFO_TRANSLATION)
+
+// ---------------------------------------------------------------------------
+/** @brief Input parameter to the #aiProcess_TransformUVCoords step:
+ *  Specifies which UV transformations are evaluated.
+ *
+ *  This is a bitwise combination of the AI_UVTRAFO_XXX flags (integer
+ *  property, of course). By default all transformations are enabled
+ * (AI_UVTRAFO_ALL).
+ */
+#define AI_CONFIG_PP_TUV_EVALUATE               \
+    "PP_TUV_EVALUATE"
+
+// ---------------------------------------------------------------------------
+/** @brief A hint to assimp to favour speed against import quality.
+ *
+ * Enabling this option may result in faster loading, but it needn't.
+ * It represents just a hint to loaders and post-processing steps to use
+ * faster code paths, if possible.
+ * This property is expected to be an integer, != 0 stands for true.
+ * The default value is 0.
+ */
+#define AI_CONFIG_FAVOUR_SPEED              \
+ "FAVOUR_SPEED"
+
+
+// ###########################################################################
+// IMPORTER SETTINGS
+// Various stuff to fine-tune the behaviour of specific importer plugins.
+// ###########################################################################
+
+
+// ---------------------------------------------------------------------------
+/** @brief Set whether the fbx importer will merge all geometry layers present
+ *    in the source file or take only the first.
+ *
+ * The default value is true (1)
+ * Property type: bool
+ */
+#define AI_CONFIG_IMPORT_FBX_READ_ALL_GEOMETRY_LAYERS \
+    "IMPORT_FBX_READ_ALL_GEOMETRY_LAYERS"
+
+// ---------------------------------------------------------------------------
+/** @brief Set whether the fbx importer will read all materials present in the
+ *    source file or take only the referenced materials.
+ *
+ * This is void unless IMPORT_FBX_READ_MATERIALS=1.
+ *
+ * The default value is false (0)
+ * Property type: bool
+ */
+#define AI_CONFIG_IMPORT_FBX_READ_ALL_MATERIALS \
+    "IMPORT_FBX_READ_ALL_MATERIALS"
+
+// ---------------------------------------------------------------------------
+/** @brief Set whether the fbx importer will read materials.
+ *
+ * The default value is true (1)
+ * Property type: bool
+ */
+#define AI_CONFIG_IMPORT_FBX_READ_MATERIALS \
+    "IMPORT_FBX_READ_MATERIALS"
+
+// ---------------------------------------------------------------------------
+/** @brief Set whether the fbx importer will read embedded textures.
+ *
+ * The default value is true (1)
+ * Property type: bool
+ */
+#define AI_CONFIG_IMPORT_FBX_READ_TEXTURES \
+    "IMPORT_FBX_READ_TEXTURES"
+
+// ---------------------------------------------------------------------------
+/** @brief Set whether the fbx importer will read cameras.
+ *
+ * The default value is true (1)
+ * Property type: bool
+ */
+#define AI_CONFIG_IMPORT_FBX_READ_CAMERAS \
+    "IMPORT_FBX_READ_CAMERAS"
+
+// ---------------------------------------------------------------------------
+/** @brief Set whether the fbx importer will read light sources.
+ *
+ * The default value is true (1)
+ * Property type: bool
+ */
+#define AI_CONFIG_IMPORT_FBX_READ_LIGHTS \
+    "IMPORT_FBX_READ_LIGHTS"
+
+// ---------------------------------------------------------------------------
+/** @brief Set whether the fbx importer will read animations.
+ *
+ * The default value is true (1)
+ * Property type: bool
+ */
+#define AI_CONFIG_IMPORT_FBX_READ_ANIMATIONS \
+    "IMPORT_FBX_READ_ANIMATIONS"
+
+// ---------------------------------------------------------------------------
+/** @brief Set whether the fbx importer will act in strict mode in which only
+ *    FBX 2013 is supported and any other sub formats are rejected. FBX 2013
+ *    is the primary target for the importer, so this format is best
+ *    supported and well-tested.
+ *
+ * The default value is false (0)
+ * Property type: bool
+ */
+#define AI_CONFIG_IMPORT_FBX_STRICT_MODE \
+    "IMPORT_FBX_STRICT_MODE"
+
+// ---------------------------------------------------------------------------
+/** @brief Set whether the fbx importer will preserve pivot points for
+ *    transformations (as extra nodes). If set to false, pivots and offsets
+ *    will be evaluated whenever possible.
+ *
+ * The default value is true (1)
+ * Property type: bool
+ */
+#define AI_CONFIG_IMPORT_FBX_PRESERVE_PIVOTS \
+    "IMPORT_FBX_PRESERVE_PIVOTS"
+
+// ---------------------------------------------------------------------------
+/** @brief Specifies whether the importer will drop empty animation curves or
+ *    animation curves which match the bind pose transformation over their
+ *    entire defined range.
+ *
+ * The default value is true (1)
+ * Property type: bool
+ */
+#define AI_CONFIG_IMPORT_FBX_OPTIMIZE_EMPTY_ANIMATION_CURVES \
+    "IMPORT_FBX_OPTIMIZE_EMPTY_ANIMATION_CURVES"
+
+// ---------------------------------------------------------------------------
+/** @brief Set whether the fbx importer will use the legacy embedded texture naming.
+*
+* The default value is false (0)
+* Property type: bool
+*/
+#define AI_CONFIG_IMPORT_FBX_EMBEDDED_TEXTURES_LEGACY_NAMING \
+	"AI_CONFIG_IMPORT_FBX_EMBEDDED_TEXTURES_LEGACY_NAMING"
+	
+// ---------------------------------------------------------------------------
+/** @brief  Set the vertex animation keyframe to be imported
+ *
+ * ASSIMP does not support vertex keyframes (only bone animation is supported).
+ * The library reads only one frame of models with vertex animations.
+ * By default this is the first frame.
+ * \note The default value is 0. This option applies to all importers.
+ *   However, it is also possible to override the global setting
+ *   for a specific loader. You can use the AI_CONFIG_IMPORT_XXX_KEYFRAME
+ *   options (where XXX is a placeholder for the file format for which you
+ *   want to override the global setting).
+ * Property type: integer.
+ */
+#define AI_CONFIG_IMPORT_GLOBAL_KEYFRAME    "IMPORT_GLOBAL_KEYFRAME"
+
+#define AI_CONFIG_IMPORT_MD3_KEYFRAME       "IMPORT_MD3_KEYFRAME"
+#define AI_CONFIG_IMPORT_MD2_KEYFRAME       "IMPORT_MD2_KEYFRAME"
+#define AI_CONFIG_IMPORT_MDL_KEYFRAME       "IMPORT_MDL_KEYFRAME"
+#define AI_CONFIG_IMPORT_MDC_KEYFRAME       "IMPORT_MDC_KEYFRAME"
+#define AI_CONFIG_IMPORT_SMD_KEYFRAME       "IMPORT_SMD_KEYFRAME"
+#define AI_CONFIG_IMPORT_UNREAL_KEYFRAME    "IMPORT_UNREAL_KEYFRAME"
+
+
+// ---------------------------------------------------------------------------
+/** @brief  Configures the AC loader to collect all surfaces which have the
+ *    "Backface cull" flag set in separate meshes.
+ *
+ *  Property type: bool. Default value: true.
+ */
+#define AI_CONFIG_IMPORT_AC_SEPARATE_BFCULL \
+    "IMPORT_AC_SEPARATE_BFCULL"
+
+// ---------------------------------------------------------------------------
+/** @brief  Configures whether the AC loader evaluates subdivision surfaces (
+ *  indicated by the presence of the 'subdiv' attribute in the file). By
+ *  default, Assimp performs the subdivision using the standard
+ *  Catmull-Clark algorithm
+ *
+ * * Property type: bool. Default value: true.
+ */
+#define AI_CONFIG_IMPORT_AC_EVAL_SUBDIVISION    \
+    "IMPORT_AC_EVAL_SUBDIVISION"
+
+// ---------------------------------------------------------------------------
+/** @brief  Configures the UNREAL 3D loader to separate faces with different
+ *    surface flags (e.g. two-sided vs. single-sided).
+ *
+ * * Property type: bool. Default value: true.
+ */
+#define AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS \
+    "UNREAL_HANDLE_FLAGS"
+
+// ---------------------------------------------------------------------------
+/** @brief Configures the terragen import plugin to compute uv's for
+ *  terrains, if not given. Furthermore a default texture is assigned.
+ *
+ * UV coordinates for terrains are so simple to compute that you'll usually
+ * want to compute them on your own, if you need them. This option is intended
+ * for model viewers which want to offer an easy way to apply textures to
+ * terrains.
+ * * Property type: bool. Default value: false.
+ */
+#define AI_CONFIG_IMPORT_TER_MAKE_UVS \
+    "IMPORT_TER_MAKE_UVS"
+
+// ---------------------------------------------------------------------------
+/** @brief  Configures the ASE loader to always reconstruct normal vectors
+ *  basing on the smoothing groups loaded from the file.
+ *
+ * Some ASE files have carry invalid normals, other don't.
+ * * Property type: bool. Default value: true.
+ */
+#define AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS    \
+    "IMPORT_ASE_RECONSTRUCT_NORMALS"
+
+// ---------------------------------------------------------------------------
+/** @brief  Configures the M3D loader to detect and process multi-part
+ *    Quake player models.
+ *
+ * These models usually consist of 3 files, lower.md3, upper.md3 and
+ * head.md3. If this property is set to true, Assimp will try to load and
+ * combine all three files if one of them is loaded.
+ * Property type: bool. Default value: true.
+ */
+#define AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART \
+    "IMPORT_MD3_HANDLE_MULTIPART"
+
+// ---------------------------------------------------------------------------
+/** @brief  Tells the MD3 loader which skin files to load.
+ *
+ * When loading MD3 files, Assimp checks whether a file
+ * [md3_file_name]_[skin_name].skin is existing. These files are used by
+ * Quake III to be able to assign different skins (e.g. red and blue team)
+ * to models. 'default', 'red', 'blue' are typical skin names.
+ * Property type: String. Default value: "default".
+ */
+#define AI_CONFIG_IMPORT_MD3_SKIN_NAME \
+    "IMPORT_MD3_SKIN_NAME"
+
+// ---------------------------------------------------------------------------
+/** @brief  Specify the Quake 3 shader file to be used for a particular
+ *  MD3 file. This can also be a search path.
+ *
+ * By default Assimp's behaviour is as follows: If a MD3 file
+ * <tt>any_path/models/any_q3_subdir/model_name/file_name.md3</tt> is
+ * loaded, the library tries to locate the corresponding shader file in
+ * <tt>any_path/scripts/model_name.shader</tt>. This property overrides this
+ * behaviour. It can either specify a full path to the shader to be loaded
+ * or alternatively the path (relative or absolute) to the directory where
+ * the shaders for all MD3s to be loaded reside. Assimp attempts to open
+ * <tt>IMPORT_MD3_SHADER_SRC/model_name.shader</tt> first, <tt>IMPORT_MD3_SHADER_SRC/file_name.shader</tt>
+ * is the fallback file. Note that IMPORT_MD3_SHADER_SRC should have a terminal (back)slash.
+ * Property type: String. Default value: n/a.
+ */
+#define AI_CONFIG_IMPORT_MD3_SHADER_SRC \
+    "IMPORT_MD3_SHADER_SRC"
+
+// ---------------------------------------------------------------------------
+/** @brief  Configures the LWO loader to load just one layer from the model.
+ *
+ * LWO files consist of layers and in some cases it could be useful to load
+ * only one of them. This property can be either a string - which specifies
+ * the name of the layer - or an integer - the index of the layer. If the
+ * property is not set the whole LWO model is loaded. Loading fails if the
+ * requested layer is not available. The layer index is zero-based and the
+ * layer name may not be empty.<br>
+ * Property type: Integer. Default value: all layers are loaded.
+ */
+#define AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY         \
+    "IMPORT_LWO_ONE_LAYER_ONLY"
+
+// ---------------------------------------------------------------------------
+/** @brief  Configures the MD5 loader to not load the MD5ANIM file for
+ *  a MD5MESH file automatically.
+ *
+ * The default strategy is to look for a file with the same name but the
+ * MD5ANIM extension in the same directory. If it is found, it is loaded
+ * and combined with the MD5MESH file. This configuration option can be
+ * used to disable this behaviour.
+ *
+ * * Property type: bool. Default value: false.
+ */
+#define AI_CONFIG_IMPORT_MD5_NO_ANIM_AUTOLOAD           \
+    "IMPORT_MD5_NO_ANIM_AUTOLOAD"
+
+// ---------------------------------------------------------------------------
+/** @brief Defines the begin of the time range for which the LWS loader
+ *    evaluates animations and computes aiNodeAnim's.
+ *
+ * Assimp provides full conversion of LightWave's envelope system, including
+ * pre and post conditions. The loader computes linearly subsampled animation
+ * chanels with the frame rate given in the LWS file. This property defines
+ * the start time. Note: animation channels are only generated if a node
+ * has at least one envelope with more tan one key assigned. This property.
+ * is given in frames, '0' is the first frame. By default, if this property
+ * is not set, the importer takes the animation start from the input LWS
+ * file ('FirstFrame' line)<br>
+ * Property type: Integer. Default value: taken from file.
+ *
+ * @see AI_CONFIG_IMPORT_LWS_ANIM_END - end of the imported time range
+ */
+#define AI_CONFIG_IMPORT_LWS_ANIM_START         \
+    "IMPORT_LWS_ANIM_START"
+#define AI_CONFIG_IMPORT_LWS_ANIM_END           \
+    "IMPORT_LWS_ANIM_END"
+
+// ---------------------------------------------------------------------------
+/** @brief Defines the output frame rate of the IRR loader.
+ *
+ * IRR animations are difficult to convert for Assimp and there will
+ * always be a loss of quality. This setting defines how many keys per second
+ * are returned by the converter.<br>
+ * Property type: integer. Default value: 100
+ */
+#define AI_CONFIG_IMPORT_IRR_ANIM_FPS               \
+    "IMPORT_IRR_ANIM_FPS"
+
+// ---------------------------------------------------------------------------
+/** @brief Ogre Importer will try to find referenced materials from this file.
+ *
+ * Ogre meshes reference with material names, this does not tell Assimp the file
+ * where it is located in. Assimp will try to find the source file in the following
+ * order: <material-name>.material, <mesh-filename-base>.material and
+ * lastly the material name defined by this config property.
+ * <br>
+ * Property type: String. Default value: Scene.material.
+ */
+#define AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE \
+    "IMPORT_OGRE_MATERIAL_FILE"
+
+// ---------------------------------------------------------------------------
+/** @brief Ogre Importer detect the texture usage from its filename.
+ *
+ * Ogre material texture units do not define texture type, the textures usage
+ * depends on the used shader or Ogre's fixed pipeline. If this config property
+ * is true Assimp will try to detect the type from the textures filename postfix:
+ * _n, _nrm, _nrml, _normal, _normals and _normalmap for normal map, _s, _spec,
+ * _specular and _specularmap for specular map, _l, _light, _lightmap, _occ
+ * and _occlusion for light map, _disp and _displacement for displacement map.
+ * The matching is case insensitive. Post fix is taken between the last
+ * underscore and the last period.
+ * Default behavior is to detect type from lower cased texture unit name by
+ * matching against: normalmap, specularmap, lightmap and displacementmap.
+ * For both cases if no match is found aiTextureType_DIFFUSE is used.
+ * <br>
+ * Property type: Bool. Default value: false.
+ */
+#define AI_CONFIG_IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME \
+    "IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME"
+
+ /** @brief Specifies whether the Android JNI asset extraction is supported.
+  *
+  * Turn on this option if you want to manage assets in native
+  * Android application without having to keep the internal directory and asset
+  * manager pointer.
+  */
+ #define AI_CONFIG_ANDROID_JNI_ASSIMP_MANAGER_SUPPORT "AI_CONFIG_ANDROID_JNI_ASSIMP_MANAGER_SUPPORT"
+
+// ---------------------------------------------------------------------------
+/** @brief Specifies whether the IFC loader skips over IfcSpace elements.
+ *
+ * IfcSpace elements (and their geometric representations) are used to
+ * represent, well, free space in a building storey.<br>
+ * Property type: Bool. Default value: true.
+ */
+#define AI_CONFIG_IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS "IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS"
+
+// ---------------------------------------------------------------------------
+/** @brief Specifies whether the IFC loader will use its own, custom triangulation
+ *   algorithm to triangulate wall and floor meshes.
+ *
+ * If this property is set to false, walls will be either triangulated by
+ * #aiProcess_Triangulate or will be passed through as huge polygons with
+ * faked holes (i.e. holes that are connected with the outer boundary using
+ * a dummy edge). It is highly recommended to set this property to true
+ * if you want triangulated data because #aiProcess_Triangulate is known to
+ * have problems with the kind of polygons that the IFC loader spits out for
+ * complicated meshes.
+ * Property type: Bool. Default value: true.
+ */
+#define AI_CONFIG_IMPORT_IFC_CUSTOM_TRIANGULATION "IMPORT_IFC_CUSTOM_TRIANGULATION"
+
+// ---------------------------------------------------------------------------
+/** @brief  Set the tessellation conic angle for IFC smoothing curves.
+ *
+ * This is used by the IFC importer to determine the tessellation parameter
+ * for smoothing curves.
+ * @note The default value is AI_IMPORT_IFC_DEFAULT_SMOOTHING_ANGLE and the
+ * accepted values are in range [5.0, 120.0].
+ * Property type: Float.
+ */
+#define AI_CONFIG_IMPORT_IFC_SMOOTHING_ANGLE "IMPORT_IFC_SMOOTHING_ANGLE"
+
+// default value for AI_CONFIG_IMPORT_IFC_SMOOTHING_ANGLE
+#if (!defined AI_IMPORT_IFC_DEFAULT_SMOOTHING_ANGLE)
+#   define AI_IMPORT_IFC_DEFAULT_SMOOTHING_ANGLE 10.0f
+#endif
+
+// ---------------------------------------------------------------------------
+/** @brief  Set the tessellation for IFC cylindrical shapes.
+ *
+ * This is used by the IFC importer to determine the tessellation parameter
+ * for cylindrical shapes, i.e. the number of segments used to approximate a circle.
+ * @note The default value is AI_IMPORT_IFC_DEFAULT_CYLINDRICAL_TESSELLATION and the
+ * accepted values are in range [3, 180].
+ * Property type: Integer.
+ */
+#define AI_CONFIG_IMPORT_IFC_CYLINDRICAL_TESSELLATION "IMPORT_IFC_CYLINDRICAL_TESSELLATION"
+
+// default value for AI_CONFIG_IMPORT_IFC_CYLINDRICAL_TESSELLATION
+#if (!defined AI_IMPORT_IFC_DEFAULT_CYLINDRICAL_TESSELLATION)
+#   define AI_IMPORT_IFC_DEFAULT_CYLINDRICAL_TESSELLATION 32
+#endif
+
+// ---------------------------------------------------------------------------
+/** @brief Specifies whether the Collada loader will ignore the provided up direction.
+ *
+ * If this property is set to true, the up direction provided in the file header will
+ * be ignored and the file will be loaded as is.
+ * Property type: Bool. Default value: false.
+ */
+#define AI_CONFIG_IMPORT_COLLADA_IGNORE_UP_DIRECTION "IMPORT_COLLADA_IGNORE_UP_DIRECTION"
+
+// ---------------------------------------------------------------------------
+/** @brief Specifies whether the Collada loader should use Collada names as node names.
+ *
+ * If this property is set to true, the Collada names will be used as the
+ * node name. The default is to use the id tag (resp. sid tag, if no id tag is present)
+ * instead.
+ * Property type: Bool. Default value: false.
+ */
+#define AI_CONFIG_IMPORT_COLLADA_USE_COLLADA_NAMES "IMPORT_COLLADA_USE_COLLADA_NAMES"
+
+// ---------- All the Export defines ------------
+
+/** @brief Specifies the xfile use double for real values of float
+ *
+ * Property type: Bool. Default value: false.
+ */
+
+#define AI_CONFIG_EXPORT_XFILE_64BIT "EXPORT_XFILE_64BIT"
+
+/**
+ *  @brief  Specifies a gobal key factor for scale, float value
+ */
+#define AI_CONFIG_GLOBAL_SCALE_FACTOR_KEY "GLOBAL_SCALE_FACTOR"
+
+#if (!defined AI_CONFIG_GLOBAL_SCALE_FACTOR_DEFAULT)
+#   define AI_CONFIG_GLOBAL_SCALE_FACTOR_DEFAULT  1.0f
+#endif // !! AI_DEBONE_THRESHOLD
+
+// ---------- All the Build/Compile-time defines ------------
+
+/** @brief Specifies if double precision is supported inside assimp
+ *
+ * Property type: Bool. Default value: undefined.
+ */
+
+#cmakedefine ASSIMP_DOUBLE_PRECISION 1
+
+#endif // !! AI_CONFIG_H_INC
diff --git a/engine/inc/assimp/defs.h b/engine/inc/assimp/defs.h
new file mode 100644
index 00000000..b587396b
--- /dev/null
+++ b/engine/inc/assimp/defs.h
@@ -0,0 +1,292 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file defs.h
+ *  @brief Assimp build configuration setup. See the notes in the comment
+ *  blocks to find out how to customize _your_ Assimp build.
+ */
+
+#pragma once
+#ifndef AI_DEFINES_H_INC
+#define AI_DEFINES_H_INC
+
+#include <assimp/config.h>
+
+//////////////////////////////////////////////////////////////////////////
+/* Define ASSIMP_BUILD_NO_XX_IMPORTER to disable a specific
+ * file format loader. The loader is be excluded from the
+ * build in this case. 'XX' stands for the most common file
+ * extension of the file format. E.g.:
+ * ASSIMP_BUILD_NO_X_IMPORTER disables the X loader.
+ *
+ * If you're unsure about that, take a look at the implementation of the
+ * import plugin you wish to disable. You'll find the right define in the
+ * first lines of the corresponding unit.
+ *
+ * Other (mixed) configuration switches are listed here:
+ *    ASSIMP_BUILD_NO_COMPRESSED_X
+ *      - Disable support for compressed X files (zip)
+ *    ASSIMP_BUILD_NO_COMPRESSED_BLEND
+ *      - Disable support for compressed Blender files (zip)
+ *    ASSIMP_BUILD_NO_COMPRESSED_IFC
+ *      - Disable support for IFCZIP files (unzip)
+ */
+//////////////////////////////////////////////////////////////////////////
+
+#ifndef ASSIMP_BUILD_NO_COMPRESSED_X
+#   define ASSIMP_BUILD_NEED_Z_INFLATE
+#endif
+
+#ifndef ASSIMP_BUILD_NO_COMPRESSED_BLEND
+#   define ASSIMP_BUILD_NEED_Z_INFLATE
+#endif
+
+#ifndef ASSIMP_BUILD_NO_COMPRESSED_IFC
+#   define ASSIMP_BUILD_NEED_Z_INFLATE
+#   define ASSIMP_BUILD_NEED_UNZIP
+#endif
+
+#ifndef ASSIMP_BUILD_NO_Q3BSP_IMPORTER
+#   define ASSIMP_BUILD_NEED_Z_INFLATE
+#   define ASSIMP_BUILD_NEED_UNZIP
+#endif
+
+//////////////////////////////////////////////////////////////////////////
+/* Define ASSIMP_BUILD_NO_XX_PROCESS to disable a specific
+ * post processing step. This is the current list of process names ('XX'):
+ * CALCTANGENTS
+ * JOINVERTICES
+ * TRIANGULATE
+ * GENFACENORMALS
+ * GENVERTEXNORMALS
+ * REMOVEVC
+ * SPLITLARGEMESHES
+ * PRETRANSFORMVERTICES
+ * LIMITBONEWEIGHTS
+ * VALIDATEDS
+ * IMPROVECACHELOCALITY
+ * FIXINFACINGNORMALS
+ * REMOVE_REDUNDANTMATERIALS
+ * OPTIMIZEGRAPH
+ * SORTBYPTYPE
+ * FINDINVALIDDATA
+ * TRANSFORMTEXCOORDS
+ * GENUVCOORDS
+ * ENTITYMESHBUILDER
+ * EMBEDTEXTURES
+ * MAKELEFTHANDED
+ * FLIPUVS
+ * FLIPWINDINGORDER
+ * OPTIMIZEMESHES
+ * OPTIMIZEANIMS
+ * OPTIMIZEGRAPH
+ * GENENTITYMESHES
+ * FIXTEXTUREPATHS */
+//////////////////////////////////////////////////////////////////////////
+
+#ifdef _MSC_VER
+#   undef ASSIMP_API
+
+    //////////////////////////////////////////////////////////////////////////
+    /* Define 'ASSIMP_BUILD_DLL_EXPORT' to build a DLL of the library */
+    //////////////////////////////////////////////////////////////////////////
+#   ifdef ASSIMP_BUILD_DLL_EXPORT
+#       define ASSIMP_API __declspec(dllexport)
+#       define ASSIMP_API_WINONLY __declspec(dllexport)
+#       pragma warning (disable : 4251)
+
+    //////////////////////////////////////////////////////////////////////////
+    /* Define 'ASSIMP_DLL' before including Assimp to link to ASSIMP in
+     * an external DLL under Windows. Default is static linkage. */
+    //////////////////////////////////////////////////////////////////////////
+#   elif (defined ASSIMP_DLL)
+#       define ASSIMP_API __declspec(dllimport)
+#       define ASSIMP_API_WINONLY __declspec(dllimport)
+#   else
+#       define ASSIMP_API
+#       define ASSIMP_API_WINONLY
+#   endif
+
+    /* Force the compiler to inline a function, if possible
+     */
+#   define AI_FORCE_INLINE __forceinline
+
+    /* Tells the compiler that a function never returns. Used in code analysis
+     * to skip dead paths (e.g. after an assertion evaluated to false). */
+#   define AI_WONT_RETURN __declspec(noreturn)
+
+#elif defined(SWIG)
+
+    /* Do nothing, the relevant defines are all in AssimpSwigPort.i */
+
+#else
+
+#   define AI_WONT_RETURN
+
+#   define ASSIMP_API __attribute__ ((visibility("default")))
+#   define ASSIMP_API_WINONLY
+#   define AI_FORCE_INLINE inline
+#endif // (defined _MSC_VER)
+
+#ifdef __GNUC__
+#   define AI_WONT_RETURN_SUFFIX  __attribute__((noreturn))
+#else
+#   define AI_WONT_RETURN_SUFFIX
+#endif // (defined __clang__)
+
+#ifdef __cplusplus
+    /* No explicit 'struct' and 'enum' tags for C++, this keeps showing up
+     * in doxydocs.
+     */
+#   define C_STRUCT
+#   define C_ENUM
+#else
+    //////////////////////////////////////////////////////////////////////////
+    /* To build the documentation, make sure ASSIMP_DOXYGEN_BUILD
+     * is defined by Doxygen's preprocessor. The corresponding
+     * entries in the DOXYFILE are: */
+    //////////////////////////////////////////////////////////////////////////
+#if 0
+    ENABLE_PREPROCESSING   = YES
+    MACRO_EXPANSION        = YES
+    EXPAND_ONLY_PREDEF     = YES
+    SEARCH_INCLUDES        = YES
+    INCLUDE_PATH           =
+    INCLUDE_FILE_PATTERNS  =
+    PREDEFINED             = ASSIMP_DOXYGEN_BUILD=1
+    EXPAND_AS_DEFINED      = C_STRUCT C_ENUM
+    SKIP_FUNCTION_MACROS   = YES
+#endif
+    //////////////////////////////////////////////////////////////////////////
+    /* Doxygen gets confused if we use c-struct typedefs to avoid
+     * the explicit 'struct' notation. This trick here has the same
+     * effect as the TYPEDEF_HIDES_STRUCT option, but we don't need
+     * to typedef all structs/enums. */
+     //////////////////////////////////////////////////////////////////////////
+#   if (defined ASSIMP_DOXYGEN_BUILD)
+#       define C_STRUCT
+#       define C_ENUM
+#   else
+#       define C_STRUCT struct
+#       define C_ENUM   enum
+#   endif
+#endif
+
+#if (defined(__BORLANDC__) || defined (__BCPLUSPLUS__))
+#error Currently, Borland is unsupported. Feel free to port Assimp.
+
+// "W8059 Packgröße der Struktur geändert"
+
+#endif
+
+
+    //////////////////////////////////////////////////////////////////////////
+    /* Define ASSIMP_BUILD_SINGLETHREADED to compile assimp
+     * without threading support. The library doesn't utilize
+     * threads then and is itself not threadsafe. */
+    //////////////////////////////////////////////////////////////////////////
+#ifndef ASSIMP_BUILD_SINGLETHREADED
+#   define ASSIMP_BUILD_SINGLETHREADED
+#endif
+
+#if defined(_DEBUG) || ! defined(NDEBUG)
+#   define ASSIMP_BUILD_DEBUG
+#endif
+
+    //////////////////////////////////////////////////////////////////////////
+    /* Define ASSIMP_DOUBLE_PRECISION to compile assimp
+     * with double precision support (64-bit). */
+    //////////////////////////////////////////////////////////////////////////
+
+#ifdef ASSIMP_DOUBLE_PRECISION
+    typedef double ai_real;
+    typedef signed long long int ai_int;
+    typedef unsigned long long int ai_uint;
+#else // ASSIMP_DOUBLE_PRECISION
+    typedef float ai_real;
+    typedef signed int ai_int;
+    typedef unsigned int ai_uint;
+#endif // ASSIMP_DOUBLE_PRECISION
+
+    //////////////////////////////////////////////////////////////////////////
+    /* Useful constants */
+    //////////////////////////////////////////////////////////////////////////
+
+/* This is PI. Hi PI. */
+#define AI_MATH_PI          (3.141592653589793238462643383279 )
+#define AI_MATH_TWO_PI      (AI_MATH_PI * 2.0)
+#define AI_MATH_HALF_PI     (AI_MATH_PI * 0.5)
+
+/* And this is to avoid endless casts to float */
+#define AI_MATH_PI_F        (3.1415926538f)
+#define AI_MATH_TWO_PI_F    (AI_MATH_PI_F * 2.0f)
+#define AI_MATH_HALF_PI_F   (AI_MATH_PI_F * 0.5f)
+
+/* Tiny macro to convert from radians to degrees and back */
+#define AI_DEG_TO_RAD(x) ((x)*(ai_real)0.0174532925)
+#define AI_RAD_TO_DEG(x) ((x)*(ai_real)57.2957795)
+
+/* Support for big-endian builds */
+#if defined(__BYTE_ORDER__)
+#   if (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+#       if !defined(__BIG_ENDIAN__)
+#           define __BIG_ENDIAN__
+#       endif
+#   else /* little endian */
+#       if defined (__BIG_ENDIAN__)
+#           undef __BIG_ENDIAN__
+#       endif
+#   endif
+#endif
+#if defined(__BIG_ENDIAN__)
+#   define AI_BUILD_BIG_ENDIAN
+#endif
+
+
+/* To avoid running out of memory
+ * This can be adjusted for specific use cases
+ * It's NOT a total limit, just a limit for individual allocations
+ */
+#define AI_MAX_ALLOC(type) ((256U * 1024 * 1024) / sizeof(type))
+
+#endif // !! AI_DEFINES_H_INC
diff --git a/engine/inc/assimp/fast_atof.h b/engine/inc/assimp/fast_atof.h
new file mode 100644
index 00000000..e66f1b37
--- /dev/null
+++ b/engine/inc/assimp/fast_atof.h
@@ -0,0 +1,373 @@
+#pragma once
+
+// Copyright (C) 2002-2007 Nikolaus Gebhardt
+// This file is part of the "Irrlicht Engine" and the "irrXML" project.
+// For conditions of distribution and use, see copyright notice in irrlicht.h and irrXML.h
+
+// ------------------------------------------------------------------------------------
+// Original description: (Schrompf)
+// Adapted to the ASSIMP library because the builtin atof indeed takes AGES to parse a
+// float inside a large string. Before parsing, it does a strlen on the given point.
+// Changes:
+//  22nd October 08 (Aramis_acg): Added temporary cast to double, added strtoul10_64
+//     to ensure long numbers are handled correctly
+// ------------------------------------------------------------------------------------
+
+
+#ifndef FAST_A_TO_F_H_INCLUDED
+#define FAST_A_TO_F_H_INCLUDED
+
+#include <cmath>
+#include <limits>
+#include <stdint.h>
+#include <stdexcept>
+#include <assimp/defs.h>
+
+#include "StringComparison.h"
+#include <assimp/DefaultLogger.hpp>
+
+#ifdef _MSC_VER
+#  include <stdint.h>
+#else
+#  include <assimp/Compiler/pstdint.h>
+#endif
+
+namespace Assimp {
+
+const double fast_atof_table[16] =  {  // we write [16] here instead of [] to work around a swig bug
+    0.0,
+    0.1,
+    0.01,
+    0.001,
+    0.0001,
+    0.00001,
+    0.000001,
+    0.0000001,
+    0.00000001,
+    0.000000001,
+    0.0000000001,
+    0.00000000001,
+    0.000000000001,
+    0.0000000000001,
+    0.00000000000001,
+    0.000000000000001
+};
+
+
+// ------------------------------------------------------------------------------------
+// Convert a string in decimal format to a number
+// ------------------------------------------------------------------------------------
+inline
+unsigned int strtoul10( const char* in, const char** out=0) {
+    unsigned int value = 0;
+
+    for ( ;; ) {
+        if ( *in < '0' || *in > '9' ) {
+            break;
+        }
+
+        value = ( value * 10 ) + ( *in - '0' );
+        ++in;
+    }
+    if ( out ) {
+        *out = in;
+    }
+    return value;
+}
+
+// ------------------------------------------------------------------------------------
+// Convert a string in octal format to a number
+// ------------------------------------------------------------------------------------
+inline
+unsigned int strtoul8( const char* in, const char** out=0) {
+    unsigned int value( 0 );
+    for ( ;; ) {
+        if ( *in < '0' || *in > '7' ) {
+            break;
+        }
+
+        value = ( value << 3 ) + ( *in - '0' );
+        ++in;
+    }
+    if ( out ) {
+        *out = in;
+    }
+    return value;
+}
+
+// ------------------------------------------------------------------------------------
+// Convert a string in hex format to a number
+// ------------------------------------------------------------------------------------
+inline
+unsigned int strtoul16( const char* in, const char** out=0) {
+    unsigned int value( 0 );
+    for ( ;; ) {
+        if ( *in >= '0' && *in <= '9' ) {
+            value = ( value << 4u ) + ( *in - '0' );
+        } else if (*in >= 'A' && *in <= 'F') {
+            value = ( value << 4u ) + ( *in - 'A' ) + 10;
+        } else if (*in >= 'a' && *in <= 'f') {
+            value = ( value << 4u ) + ( *in - 'a' ) + 10;
+        } else {
+            break;
+        }
+        ++in;
+    }
+    if ( out ) {
+        *out = in;
+    }
+    return value;
+}
+
+// ------------------------------------------------------------------------------------
+// Convert just one hex digit
+// Return value is UINT_MAX if the input character is not a hex digit.
+// ------------------------------------------------------------------------------------
+inline
+unsigned int HexDigitToDecimal(char in) {
+    unsigned int out( UINT_MAX );
+    if ( in >= '0' && in <= '9' ) {
+        out = in - '0';
+    } else if ( in >= 'a' && in <= 'f' ) {
+        out = 10u + in - 'a';
+    } else if ( in >= 'A' && in <= 'F' ) {
+        out = 10u + in - 'A';
+    }
+
+    // return value is UINT_MAX if the input is not a hex digit
+    return out;
+}
+
+// ------------------------------------------------------------------------------------
+// Convert a hex-encoded octet (2 characters, i.e. df or 1a).
+// ------------------------------------------------------------------------------------
+inline
+uint8_t HexOctetToDecimal(const char* in) {
+    return ((uint8_t)HexDigitToDecimal(in[0])<<4)+(uint8_t)HexDigitToDecimal(in[1]);
+}
+
+// ------------------------------------------------------------------------------------
+// signed variant of strtoul10
+// ------------------------------------------------------------------------------------
+inline
+int strtol10( const char* in, const char** out=0) {
+    bool inv = (*in=='-');
+    if ( inv || *in == '+' ) {
+        ++in;
+    }
+
+    int value = strtoul10(in,out);
+    if (inv) {
+        value = -value;
+    }
+    return value;
+}
+
+// ------------------------------------------------------------------------------------
+// Parse a C++-like integer literal - hex and oct prefixes.
+// 0xNNNN - hex
+// 0NNN   - oct
+// NNN    - dec
+// ------------------------------------------------------------------------------------
+inline
+unsigned int strtoul_cppstyle( const char* in, const char** out=0) {
+    if ('0' == in[0]) {
+        return 'x' == in[1] ? strtoul16(in+2,out) : strtoul8(in+1,out);
+    }
+    return strtoul10(in, out);
+}
+
+// ------------------------------------------------------------------------------------
+// Special version of the function, providing higher accuracy and safety
+// It is mainly used by fast_atof to prevent ugly and unwanted integer overflows.
+// ------------------------------------------------------------------------------------
+inline
+uint64_t strtoul10_64( const char* in, const char** out=0, unsigned int* max_inout=0) {
+    unsigned int cur = 0;
+    uint64_t value = 0;
+
+    if ( *in < '0' || *in > '9' ) {
+        throw std::invalid_argument( std::string( "The string \"" ) + in + "\" cannot be converted into a value." );
+    }
+
+    for ( ;; ) {
+        if ( *in < '0' || *in > '9' ) {
+            break;
+        }
+
+        const uint64_t new_value = ( value * 10 ) + ( *in - '0' );
+
+        // numeric overflow, we rely on you
+        if ( new_value < value ) {
+            DefaultLogger::get()->warn( std::string( "Converting the string \"" ) + in + "\" into a value resulted in overflow." );
+            return 0;
+        }
+
+        value = new_value;
+
+        ++in;
+        ++cur;
+
+        if (max_inout && *max_inout == cur) {
+            if (out) { /* skip to end */
+                while ( *in >= '0' && *in <= '9' ) {
+                    ++in;
+                }
+                *out = in;
+            }
+
+            return value;
+        }
+    }
+    if ( out ) {
+        *out = in;
+    }
+
+    if ( max_inout ) {
+        *max_inout = cur;
+    }
+
+    return value;
+}
+
+// ------------------------------------------------------------------------------------
+// signed variant of strtoul10_64
+// ------------------------------------------------------------------------------------
+inline
+int64_t strtol10_64(const char* in, const char** out = 0, unsigned int* max_inout = 0) {
+    bool inv = (*in == '-');
+    if ( inv || *in == '+' ) {
+        ++in;
+    }
+
+    int64_t value = strtoul10_64(in, out, max_inout);
+    if (inv) {
+        value = -value;
+    }
+    return value;
+}
+
+// Number of relevant decimals for floating-point parsing.
+#define AI_FAST_ATOF_RELAVANT_DECIMALS 15
+
+// ------------------------------------------------------------------------------------
+//! Provides a fast function for converting a string into a float,
+//! about 6 times faster than atof in win32.
+// If you find any bugs, please send them to me, niko (at) irrlicht3d.org.
+// ------------------------------------------------------------------------------------
+template<typename Real>
+inline
+const char* fast_atoreal_move(const char* c, Real& out, bool check_comma = true) {
+    Real f = 0;
+
+    bool inv = (*c == '-');
+    if (inv || *c == '+') {
+        ++c;
+    }
+
+    if ((c[0] == 'N' || c[0] == 'n') && ASSIMP_strincmp(c, "nan", 3) == 0) {
+        out = std::numeric_limits<Real>::quiet_NaN();
+        c += 3;
+        return c;
+    }
+
+    if ((c[0] == 'I' || c[0] == 'i') && ASSIMP_strincmp(c, "inf", 3) == 0) {
+        out = std::numeric_limits<Real>::infinity();
+        if (inv) {
+            out = -out;
+        }
+        c += 3;
+        if ((c[0] == 'I' || c[0] == 'i') && ASSIMP_strincmp(c, "inity", 5) == 0) {
+            c += 5;
+        }
+        return c;
+     }
+
+    if (!(c[0] >= '0' && c[0] <= '9') &&
+            !((c[0] == '.' || (check_comma && c[0] == ',')) && c[1] >= '0' && c[1] <= '9')) {
+        throw std::invalid_argument("Cannot parse string "
+                                    "as real number: does not start with digit "
+                                    "or decimal point followed by digit.");
+    }
+
+    if (*c != '.' && (! check_comma || c[0] != ',')) {
+        f = static_cast<Real>( strtoul10_64 ( c, &c) );
+    }
+
+    if ((*c == '.' || (check_comma && c[0] == ',')) && c[1] >= '0' && c[1] <= '9') {
+        ++c;
+
+        // NOTE: The original implementation is highly inaccurate here. The precision of a single
+        // IEEE 754 float is not high enough, everything behind the 6th digit tends to be more
+        // inaccurate than it would need to be. Casting to double seems to solve the problem.
+        // strtol_64 is used to prevent integer overflow.
+
+        // Another fix: this tends to become 0 for long numbers if we don't limit the maximum
+        // number of digits to be read. AI_FAST_ATOF_RELAVANT_DECIMALS can be a value between
+        // 1 and 15.
+        unsigned int diff = AI_FAST_ATOF_RELAVANT_DECIMALS;
+        double pl = static_cast<double>( strtoul10_64 ( c, &c, &diff ));
+
+        pl *= fast_atof_table[diff];
+        f += static_cast<Real>( pl );
+    }
+    // For backwards compatibility: eat trailing dots, but not trailing commas.
+    else if (*c == '.') {
+        ++c;
+    }
+
+    // A major 'E' must be allowed. Necessary for proper reading of some DXF files.
+    // Thanks to Zhao Lei to point out that this if() must be outside the if (*c == '.' ..)
+    if (*c == 'e' || *c == 'E') {
+        ++c;
+        const bool einv = (*c=='-');
+        if (einv || *c=='+') {
+            ++c;
+        }
+
+        // The reason float constants are used here is that we've seen cases where compilers
+        // would perform such casts on compile-time constants at runtime, which would be
+        // bad considering how frequently fast_atoreal_move<float> is called in Assimp.
+        Real exp = static_cast<Real>( strtoul10_64(c, &c) );
+        if (einv) {
+            exp = -exp;
+        }
+        f *= std::pow(static_cast<Real>(10.0), exp);
+    }
+
+    if (inv) {
+        f = -f;
+    }
+    out = f;
+    return c;
+}
+
+// ------------------------------------------------------------------------------------
+// The same but more human.
+inline
+ai_real fast_atof(const char* c) {
+    ai_real ret(0.0);
+    fast_atoreal_move<ai_real>(c, ret);
+
+    return ret;
+}
+
+inline
+ai_real fast_atof( const char* c, const char** cout) {
+    ai_real ret(0.0);
+    *cout = fast_atoreal_move<ai_real>(c, ret);
+
+    return ret;
+}
+
+inline
+ai_real fast_atof( const char** inout) {
+    ai_real ret(0.0);
+    *inout = fast_atoreal_move<ai_real>(*inout, ret);
+
+    return ret;
+}
+
+} //! namespace Assimp
+
+#endif // FAST_A_TO_F_H_INCLUDED
diff --git a/engine/inc/assimp/importerdesc.h b/engine/inc/assimp/importerdesc.h
new file mode 100644
index 00000000..36b773e4
--- /dev/null
+++ b/engine/inc/assimp/importerdesc.h
@@ -0,0 +1,146 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file importerdesc.h
+ *  @brief #aiImporterFlags, aiImporterDesc implementation.
+ */
+#pragma once
+#ifndef AI_IMPORTER_DESC_H_INC
+#define AI_IMPORTER_DESC_H_INC
+
+
+/** Mixed set of flags for #aiImporterDesc, indicating some features
+  *  common to many importers*/
+enum aiImporterFlags
+{
+    /** Indicates that there is a textual encoding of the
+     *  file format; and that it is supported.*/
+    aiImporterFlags_SupportTextFlavour = 0x1,
+
+    /** Indicates that there is a binary encoding of the
+     *  file format; and that it is supported.*/
+    aiImporterFlags_SupportBinaryFlavour = 0x2,
+
+    /** Indicates that there is a compressed encoding of the
+     *  file format; and that it is supported.*/
+    aiImporterFlags_SupportCompressedFlavour = 0x4,
+
+    /** Indicates that the importer reads only a very particular
+      * subset of the file format. This happens commonly for
+      * declarative or procedural formats which cannot easily
+      * be mapped to #aiScene */
+    aiImporterFlags_LimitedSupport = 0x8,
+
+    /** Indicates that the importer is highly experimental and
+      * should be used with care. This only happens for trunk
+      * (i.e. SVN) versions, experimental code is not included
+      * in releases. */
+    aiImporterFlags_Experimental = 0x10
+};
+
+
+/** Meta information about a particular importer. Importers need to fill
+ *  this structure, but they can freely decide how talkative they are.
+ *  A common use case for loader meta info is a user interface
+ *  in which the user can choose between various import/export file
+ *  formats. Building such an UI by hand means a lot of maintenance
+ *  as importers/exporters are added to Assimp, so it might be useful
+ *  to have a common mechanism to query some rough importer
+ *  characteristics. */
+struct aiImporterDesc
+{
+    /** Full name of the importer (i.e. Blender3D importer)*/
+    const char* mName;
+
+    /** Original author (left blank if unknown or whole assimp team) */
+    const char* mAuthor;
+
+    /** Current maintainer, left blank if the author maintains */
+    const char* mMaintainer;
+
+    /** Implementation comments, i.e. unimplemented features*/
+    const char* mComments;
+
+    /** These flags indicate some characteristics common to many
+        importers. */
+    unsigned int mFlags;
+
+    /** Minimum format version that can be loaded im major.minor format,
+        both are set to 0 if there is either no version scheme
+        or if the loader doesn't care. */
+    unsigned int mMinMajor;
+    unsigned int mMinMinor;
+
+    /** Maximum format version that can be loaded im major.minor format,
+        both are set to 0 if there is either no version scheme
+        or if the loader doesn't care. Loaders that expect to be
+        forward-compatible to potential future format versions should
+        indicate  zero, otherwise they should specify the current
+        maximum version.*/
+    unsigned int mMaxMajor;
+    unsigned int mMaxMinor;
+
+    /** List of file extensions this importer can handle.
+        List entries are separated by space characters.
+        All entries are lower case without a leading dot (i.e.
+        "xml dae" would be a valid value. Note that multiple
+        importers may respond to the same file extension -
+        assimp calls all importers in the order in which they
+        are registered and each importer gets the opportunity
+        to load the file until one importer "claims" the file. Apart
+        from file extension checks, importers typically use
+        other methods to quickly reject files (i.e. magic
+        words) so this does not mean that common or generic
+        file extensions such as XML would be tediously slow. */
+    const char* mFileExtensions;
+};
+
+/** \brief  Returns the Importer description for a given extension.
+
+Will return a NULL-pointer if no assigned importer desc. was found for the given extension
+    \param  extension   [in] The extension to look for
+    \return A pointer showing to the ImporterDesc, \see aiImporterDesc.
+*/
+ASSIMP_API const C_STRUCT aiImporterDesc* aiGetImporterDesc( const char *extension );
+
+#endif // AI_IMPORTER_DESC_H_INC
diff --git a/engine/inc/assimp/irrXMLWrapper.h b/engine/inc/assimp/irrXMLWrapper.h
new file mode 100644
index 00000000..70b20ebd
--- /dev/null
+++ b/engine/inc/assimp/irrXMLWrapper.h
@@ -0,0 +1,144 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#ifndef INCLUDED_AI_IRRXML_WRAPPER
+#define INCLUDED_AI_IRRXML_WRAPPER
+
+// some long includes ....
+#include <irrXML.h>
+#include "./../include/assimp/IOStream.hpp"
+#include "BaseImporter.h"
+#include <vector>
+
+namespace Assimp    {
+
+// ---------------------------------------------------------------------------------
+/** @brief Utility class to make IrrXML work together with our custom IO system
+ *  See the IrrXML docs for more details.
+ *
+ *  Construct IrrXML-Reader in BaseImporter::InternReadFile():
+ *  @code
+ * // open the file
+ * std::unique_ptr<IOStream> file( pIOHandler->Open( pFile));
+ * if( file.get() == NULL) {
+ *    throw DeadlyImportError( "Failed to open file " + pFile + ".");
+ * }
+ *
+ * // generate a XML reader for it
+ * std::unique_ptr<CIrrXML_IOStreamReader> mIOWrapper( new CIrrXML_IOStreamReader( file.get()));
+ * mReader = irr::io::createIrrXMLReader( mIOWrapper.get());
+ * if( !mReader) {
+ *    ThrowException( "xxxx: Unable to open file.");
+ * }
+ * @endcode
+ **/
+class CIrrXML_IOStreamReader : public irr::io::IFileReadCallBack {
+public:
+
+    // ----------------------------------------------------------------------------------
+    //! Construction from an existing IOStream
+    explicit CIrrXML_IOStreamReader(IOStream* _stream)
+        : stream (_stream)
+        , t (0)
+    {
+
+        // Map the buffer into memory and convert it to UTF8. IrrXML provides its
+        // own conversion, which is merely a cast from uintNN_t to uint8_t. Thus,
+        // it is not suitable for our purposes and we have to do it BEFORE IrrXML
+        // gets the buffer. Sadly, this forces us to map the whole file into
+        // memory.
+
+        data.resize(stream->FileSize());
+        stream->Read(&data[0],data.size(),1);
+
+        // Remove null characters from the input sequence otherwise the parsing will utterly fail
+        unsigned int size = 0;
+        unsigned int size_max = static_cast<unsigned int>(data.size());
+        for(unsigned int i = 0; i < size_max; i++) {
+            if(data[i] != '\0') {
+                data[size++] = data[i];
+            }
+        }
+        data.resize(size);
+
+        BaseImporter::ConvertToUTF8(data);
+    }
+
+    // ----------------------------------------------------------------------------------
+    //! Virtual destructor
+    virtual ~CIrrXML_IOStreamReader() {}
+
+    // ----------------------------------------------------------------------------------
+    //!   Reads an amount of bytes from the file.
+    /**  @param buffer:       Pointer to output buffer.
+     *   @param sizeToRead:   Amount of bytes to read
+     *   @return              Returns how much bytes were read.  */
+    virtual int read(void* buffer, int sizeToRead)  {
+        if(sizeToRead<0) {
+            return 0;
+        }
+        if(t+sizeToRead>data.size()) {
+            sizeToRead = static_cast<int>(data.size()-t);
+        }
+
+        memcpy(buffer,&data.front()+t,sizeToRead);
+
+        t += sizeToRead;
+        return sizeToRead;
+    }
+
+    // ----------------------------------------------------------------------------------
+    //! Returns size of file in bytes
+    virtual int getSize()   {
+        return (int)data.size();
+    }
+
+private:
+    IOStream* stream;
+    std::vector<char> data;
+    size_t t;
+
+}; // ! class CIrrXML_IOStreamReader
+
+} // ! Assimp
+
+#endif // !! INCLUDED_AI_IRRXML_WRAPPER
diff --git a/engine/inc/assimp/light.h b/engine/inc/assimp/light.h
new file mode 100644
index 00000000..8a306009
--- /dev/null
+++ b/engine/inc/assimp/light.h
@@ -0,0 +1,259 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file light.h
+ *  @brief Defines the aiLight data structure
+ */
+
+#pragma once
+#ifndef AI_LIGHT_H_INC
+#define AI_LIGHT_H_INC
+
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// ---------------------------------------------------------------------------
+/** Enumerates all supported types of light sources.
+ */
+enum aiLightSourceType
+{
+    aiLightSource_UNDEFINED     = 0x0,
+
+    //! A directional light source has a well-defined direction
+    //! but is infinitely far away. That's quite a good
+    //! approximation for sun light.
+    aiLightSource_DIRECTIONAL   = 0x1,
+
+    //! A point light source has a well-defined position
+    //! in space but no direction - it emits light in all
+    //! directions. A normal bulb is a point light.
+    aiLightSource_POINT         = 0x2,
+
+    //! A spot light source emits light in a specific
+    //! angle. It has a position and a direction it is pointing to.
+    //! A good example for a spot light is a light spot in
+    //! sport arenas.
+    aiLightSource_SPOT          = 0x3,
+
+    //! The generic light level of the world, including the bounces
+    //! of all other light sources.
+    //! Typically, there's at most one ambient light in a scene.
+    //! This light type doesn't have a valid position, direction, or
+    //! other properties, just a color.
+    aiLightSource_AMBIENT       = 0x4,
+
+    //! An area light is a rectangle with predefined size that uniformly
+    //! emits light from one of its sides. The position is center of the
+    //! rectangle and direction is its normal vector.
+    aiLightSource_AREA          = 0x5,
+
+    /** This value is not used. It is just there to force the
+     *  compiler to map this enum to a 32 Bit integer.
+     */
+#ifndef SWIG
+    _aiLightSource_Force32Bit = INT_MAX
+#endif
+};
+
+// ---------------------------------------------------------------------------
+/** Helper structure to describe a light source.
+ *
+ *  Assimp supports multiple sorts of light sources, including
+ *  directional, point and spot lights. All of them are defined with just
+ *  a single structure and distinguished by their parameters.
+ *  Note - some file formats (such as 3DS, ASE) export a "target point" -
+ *  the point a spot light is looking at (it can even be animated). Assimp
+ *  writes the target point as a subnode of a spotlights's main node,
+ *  called "<spotName>.Target". However, this is just additional information
+ *  then, the transformation tracks of the main node make the
+ *  spot light already point in the right direction.
+*/
+struct aiLight
+{
+    /** The name of the light source.
+     *
+     *  There must be a node in the scenegraph with the same name.
+     *  This node specifies the position of the light in the scene
+     *  hierarchy and can be animated.
+     */
+    C_STRUCT aiString mName;
+
+    /** The type of the light source.
+     *
+     * aiLightSource_UNDEFINED is not a valid value for this member.
+     */
+    C_ENUM aiLightSourceType mType;
+
+    /** Position of the light source in space. Relative to the
+     *  transformation of the node corresponding to the light.
+     *
+     *  The position is undefined for directional lights.
+     */
+    C_STRUCT aiVector3D mPosition;
+
+    /** Direction of the light source in space. Relative to the
+     *  transformation of the node corresponding to the light.
+     *
+     *  The direction is undefined for point lights. The vector
+     *  may be normalized, but it needn't.
+     */
+    C_STRUCT aiVector3D mDirection;
+
+    /** Up direction of the light source in space. Relative to the
+     *  transformation of the node corresponding to the light.
+     *
+     *  The direction is undefined for point lights. The vector
+     *  may be normalized, but it needn't.
+     */
+    C_STRUCT aiVector3D mUp;
+
+    /** Constant light attenuation factor.
+     *
+     *  The intensity of the light source at a given distance 'd' from
+     *  the light's position is
+     *  @code
+     *  Atten = 1/( att0 + att1 * d + att2 * d*d)
+     *  @endcode
+     *  This member corresponds to the att0 variable in the equation.
+     *  Naturally undefined for directional lights.
+     */
+    float mAttenuationConstant;
+
+    /** Linear light attenuation factor.
+     *
+     *  The intensity of the light source at a given distance 'd' from
+     *  the light's position is
+     *  @code
+     *  Atten = 1/( att0 + att1 * d + att2 * d*d)
+     *  @endcode
+     *  This member corresponds to the att1 variable in the equation.
+     *  Naturally undefined for directional lights.
+     */
+    float mAttenuationLinear;
+
+    /** Quadratic light attenuation factor.
+     *
+     *  The intensity of the light source at a given distance 'd' from
+     *  the light's position is
+     *  @code
+     *  Atten = 1/( att0 + att1 * d + att2 * d*d)
+     *  @endcode
+     *  This member corresponds to the att2 variable in the equation.
+     *  Naturally undefined for directional lights.
+     */
+    float mAttenuationQuadratic;
+
+    /** Diffuse color of the light source
+     *
+     *  The diffuse light color is multiplied with the diffuse
+     *  material color to obtain the final color that contributes
+     *  to the diffuse shading term.
+     */
+    C_STRUCT aiColor3D mColorDiffuse;
+
+    /** Specular color of the light source
+     *
+     *  The specular light color is multiplied with the specular
+     *  material color to obtain the final color that contributes
+     *  to the specular shading term.
+     */
+    C_STRUCT aiColor3D mColorSpecular;
+
+    /** Ambient color of the light source
+     *
+     *  The ambient light color is multiplied with the ambient
+     *  material color to obtain the final color that contributes
+     *  to the ambient shading term. Most renderers will ignore
+     *  this value it, is just a remaining of the fixed-function pipeline
+     *  that is still supported by quite many file formats.
+     */
+    C_STRUCT aiColor3D mColorAmbient;
+
+    /** Inner angle of a spot light's light cone.
+     *
+     *  The spot light has maximum influence on objects inside this
+     *  angle. The angle is given in radians. It is 2PI for point
+     *  lights and undefined for directional lights.
+     */
+    float mAngleInnerCone;
+
+    /** Outer angle of a spot light's light cone.
+     *
+     *  The spot light does not affect objects outside this angle.
+     *  The angle is given in radians. It is 2PI for point lights and
+     *  undefined for directional lights. The outer angle must be
+     *  greater than or equal to the inner angle.
+     *  It is assumed that the application uses a smooth
+     *  interpolation between the inner and the outer cone of the
+     *  spot light.
+     */
+    float mAngleOuterCone;
+
+    /** Size of area light source. */
+    C_STRUCT aiVector2D mSize;
+
+#ifdef __cplusplus
+
+    aiLight()
+        :   mType                 (aiLightSource_UNDEFINED)
+        ,   mAttenuationConstant  (0.f)
+        ,   mAttenuationLinear    (1.f)
+        ,   mAttenuationQuadratic (0.f)
+        ,   mAngleInnerCone       ((float)AI_MATH_TWO_PI)
+        ,   mAngleOuterCone       ((float)AI_MATH_TWO_PI)
+        ,   mSize                 (0.f, 0.f)
+    {
+    }
+
+#endif
+};
+
+#ifdef __cplusplus
+}
+#endif 
+
+
+#endif // !! AI_LIGHT_H_INC
diff --git a/engine/inc/assimp/material.h b/engine/inc/assimp/material.h
new file mode 100644
index 00000000..83244af3
--- /dev/null
+++ b/engine/inc/assimp/material.h
@@ -0,0 +1,1565 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file material.h
+ *  @brief Defines the material system of the library
+ */
+#pragma once
+#ifndef AI_MATERIAL_H_INC
+#define AI_MATERIAL_H_INC
+
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Name for default materials (2nd is used if meshes have UV coords)
+#define AI_DEFAULT_MATERIAL_NAME          "DefaultMaterial"
+
+// ---------------------------------------------------------------------------
+/** @brief Defines how the Nth texture of a specific type is combined with
+ *  the result of all previous layers.
+ *
+ *  Example (left: key, right: value): <br>
+ *  @code
+ *  DiffColor0     - gray
+ *  DiffTextureOp0 - aiTextureOpMultiply
+ *  DiffTexture0   - tex1.png
+ *  DiffTextureOp0 - aiTextureOpAdd
+ *  DiffTexture1   - tex2.png
+ *  @endcode
+ *  Written as equation, the final diffuse term for a specific pixel would be:
+ *  @code
+ *  diffFinal = DiffColor0 * sampleTex(DiffTexture0,UV0) +
+ *     sampleTex(DiffTexture1,UV0) * diffContrib;
+ *  @endcode
+ *  where 'diffContrib' is the intensity of the incoming light for that pixel.
+ */
+enum aiTextureOp
+{
+    /** T = T1 * T2 */
+    aiTextureOp_Multiply = 0x0,
+
+    /** T = T1 + T2 */
+    aiTextureOp_Add = 0x1,
+
+    /** T = T1 - T2 */
+    aiTextureOp_Subtract = 0x2,
+
+    /** T = T1 / T2 */
+    aiTextureOp_Divide = 0x3,
+
+    /** T = (T1 + T2) - (T1 * T2) */
+    aiTextureOp_SmoothAdd = 0x4,
+
+    /** T = T1 + (T2-0.5) */
+    aiTextureOp_SignedAdd = 0x5,
+
+
+#ifndef SWIG
+    _aiTextureOp_Force32Bit = INT_MAX
+#endif
+};
+
+// ---------------------------------------------------------------------------
+/** @brief Defines how UV coordinates outside the [0...1] range are handled.
+ *
+ *  Commonly referred to as 'wrapping mode'.
+ */
+enum aiTextureMapMode
+{
+    /** A texture coordinate u|v is translated to u%1|v%1
+     */
+    aiTextureMapMode_Wrap = 0x0,
+
+    /** Texture coordinates outside [0...1]
+     *  are clamped to the nearest valid value.
+     */
+    aiTextureMapMode_Clamp = 0x1,
+
+    /** If the texture coordinates for a pixel are outside [0...1]
+     *  the texture is not applied to that pixel
+     */
+    aiTextureMapMode_Decal = 0x3,
+
+    /** A texture coordinate u|v becomes u%1|v%1 if (u-(u%1))%2 is zero and
+     *  1-(u%1)|1-(v%1) otherwise
+     */
+    aiTextureMapMode_Mirror = 0x2,
+
+#ifndef SWIG
+    _aiTextureMapMode_Force32Bit = INT_MAX
+#endif
+};
+
+// ---------------------------------------------------------------------------
+/** @brief Defines how the mapping coords for a texture are generated.
+ *
+ *  Real-time applications typically require full UV coordinates, so the use of
+ *  the aiProcess_GenUVCoords step is highly recommended. It generates proper
+ *  UV channels for non-UV mapped objects, as long as an accurate description
+ *  how the mapping should look like (e.g spherical) is given.
+ *  See the #AI_MATKEY_MAPPING property for more details.
+ */
+enum aiTextureMapping
+{
+    /** The mapping coordinates are taken from an UV channel.
+     *
+     *  The #AI_MATKEY_UVWSRC key specifies from which UV channel
+     *  the texture coordinates are to be taken from (remember,
+     *  meshes can have more than one UV channel).
+    */
+    aiTextureMapping_UV = 0x0,
+
+     /** Spherical mapping */
+    aiTextureMapping_SPHERE = 0x1,
+
+     /** Cylindrical mapping */
+    aiTextureMapping_CYLINDER = 0x2,
+
+     /** Cubic mapping */
+    aiTextureMapping_BOX = 0x3,
+
+     /** Planar mapping */
+    aiTextureMapping_PLANE = 0x4,
+
+     /** Undefined mapping. Have fun. */
+    aiTextureMapping_OTHER = 0x5,
+
+
+#ifndef SWIG
+    _aiTextureMapping_Force32Bit = INT_MAX
+#endif
+};
+
+// ---------------------------------------------------------------------------
+/** @brief Defines the purpose of a texture
+ *
+ *  This is a very difficult topic. Different 3D packages support different
+ *  kinds of textures. For very common texture types, such as bumpmaps, the
+ *  rendering results depend on implementation details in the rendering
+ *  pipelines of these applications. Assimp loads all texture references from
+ *  the model file and tries to determine which of the predefined texture
+ *  types below is the best choice to match the original use of the texture
+ *  as closely as possible.<br>
+ *
+ *  In content pipelines you'll usually define how textures have to be handled,
+ *  and the artists working on models have to conform to this specification,
+ *  regardless which 3D tool they're using.
+ */
+enum aiTextureType
+{
+    /** Dummy value.
+     *
+     *  No texture, but the value to be used as 'texture semantic'
+     *  (#aiMaterialProperty::mSemantic) for all material properties
+     *  *not* related to textures.
+     */
+    aiTextureType_NONE = 0x0,
+
+
+
+    /** The texture is combined with the result of the diffuse
+     *  lighting equation.
+     */
+    aiTextureType_DIFFUSE = 0x1,
+
+    /** The texture is combined with the result of the specular
+     *  lighting equation.
+     */
+    aiTextureType_SPECULAR = 0x2,
+
+    /** The texture is combined with the result of the ambient
+     *  lighting equation.
+     */
+    aiTextureType_AMBIENT = 0x3,
+
+    /** The texture is added to the result of the lighting
+     *  calculation. It isn't influenced by incoming light.
+     */
+    aiTextureType_EMISSIVE = 0x4,
+
+    /** The texture is a height map.
+     *
+     *  By convention, higher gray-scale values stand for
+     *  higher elevations from the base height.
+     */
+    aiTextureType_HEIGHT = 0x5,
+
+    /** The texture is a (tangent space) normal-map.
+     *
+     *  Again, there are several conventions for tangent-space
+     *  normal maps. Assimp does (intentionally) not
+     *  distinguish here.
+     */
+    aiTextureType_NORMALS = 0x6,
+
+    /** The texture defines the glossiness of the material.
+     *
+     *  The glossiness is in fact the exponent of the specular
+     *  (phong) lighting equation. Usually there is a conversion
+     *  function defined to map the linear color values in the
+     *  texture to a suitable exponent. Have fun.
+    */
+    aiTextureType_SHININESS = 0x7,
+
+    /** The texture defines per-pixel opacity.
+     *
+     *  Usually 'white' means opaque and 'black' means
+     *  'transparency'. Or quite the opposite. Have fun.
+    */
+    aiTextureType_OPACITY = 0x8,
+
+    /** Displacement texture
+     *
+     *  The exact purpose and format is application-dependent.
+     *  Higher color values stand for higher vertex displacements.
+    */
+    aiTextureType_DISPLACEMENT = 0x9,
+
+    /** Lightmap texture (aka Ambient Occlusion)
+     *
+     *  Both 'Lightmaps' and dedicated 'ambient occlusion maps' are
+     *  covered by this material property. The texture contains a
+     *  scaling value for the final color value of a pixel. Its
+     *  intensity is not affected by incoming light.
+    */
+    aiTextureType_LIGHTMAP = 0xA,
+
+    /** Reflection texture
+     *
+     * Contains the color of a perfect mirror reflection.
+     * Rarely used, almost never for real-time applications.
+    */
+    aiTextureType_REFLECTION = 0xB,
+
+    /** Unknown texture
+     *
+     *  A texture reference that does not match any of the definitions
+     *  above is considered to be 'unknown'. It is still imported,
+     *  but is excluded from any further postprocessing.
+    */
+    aiTextureType_UNKNOWN = 0xC,
+
+
+#ifndef SWIG
+    _aiTextureType_Force32Bit = INT_MAX
+#endif
+};
+
+#define AI_TEXTURE_TYPE_MAX  aiTextureType_UNKNOWN
+
+// ---------------------------------------------------------------------------
+/** @brief Defines all shading models supported by the library
+ *
+ *  The list of shading modes has been taken from Blender.
+ *  See Blender documentation for more information. The API does
+ *  not distinguish between "specular" and "diffuse" shaders (thus the
+ *  specular term for diffuse shading models like Oren-Nayar remains
+ *  undefined). <br>
+ *  Again, this value is just a hint. Assimp tries to select the shader whose
+ *  most common implementation matches the original rendering results of the
+ *  3D modeller which wrote a particular model as closely as possible.
+ */
+enum aiShadingMode
+{
+    /** Flat shading. Shading is done on per-face base,
+     *  diffuse only. Also known as 'faceted shading'.
+     */
+    aiShadingMode_Flat = 0x1,
+
+    /** Simple Gouraud shading.
+     */
+    aiShadingMode_Gouraud = 0x2,
+
+    /** Phong-Shading -
+     */
+    aiShadingMode_Phong = 0x3,
+
+    /** Phong-Blinn-Shading
+     */
+    aiShadingMode_Blinn = 0x4,
+
+    /** Toon-Shading per pixel
+     *
+     *  Also known as 'comic' shader.
+     */
+    aiShadingMode_Toon = 0x5,
+
+    /** OrenNayar-Shading per pixel
+     *
+     *  Extension to standard Lambertian shading, taking the
+     *  roughness of the material into account
+     */
+    aiShadingMode_OrenNayar = 0x6,
+
+    /** Minnaert-Shading per pixel
+     *
+     *  Extension to standard Lambertian shading, taking the
+     *  "darkness" of the material into account
+     */
+    aiShadingMode_Minnaert = 0x7,
+
+    /** CookTorrance-Shading per pixel
+     *
+     *  Special shader for metallic surfaces.
+     */
+    aiShadingMode_CookTorrance = 0x8,
+
+    /** No shading at all. Constant light influence of 1.0.
+    */
+    aiShadingMode_NoShading = 0x9,
+
+     /** Fresnel shading
+     */
+    aiShadingMode_Fresnel = 0xa,
+
+
+#ifndef SWIG
+    _aiShadingMode_Force32Bit = INT_MAX
+#endif
+};
+
+
+// ---------------------------------------------------------------------------
+/** @brief Defines some mixed flags for a particular texture.
+ *
+ *  Usually you'll instruct your cg artists how textures have to look like ...
+ *  and how they will be processed in your application. However, if you use
+ *  Assimp for completely generic loading purposes you might also need to
+ *  process these flags in order to display as many 'unknown' 3D models as
+ *  possible correctly.
+ *
+ *  This corresponds to the #AI_MATKEY_TEXFLAGS property.
+*/
+enum aiTextureFlags
+{
+    /** The texture's color values have to be inverted (componentwise 1-n)
+     */
+    aiTextureFlags_Invert = 0x1,
+
+    /** Explicit request to the application to process the alpha channel
+     *  of the texture.
+     *
+     *  Mutually exclusive with #aiTextureFlags_IgnoreAlpha. These
+     *  flags are set if the library can say for sure that the alpha
+     *  channel is used/is not used. If the model format does not
+     *  define this, it is left to the application to decide whether
+     *  the texture alpha channel - if any - is evaluated or not.
+     */
+    aiTextureFlags_UseAlpha = 0x2,
+
+    /** Explicit request to the application to ignore the alpha channel
+     *  of the texture.
+     *
+     *  Mutually exclusive with #aiTextureFlags_UseAlpha.
+     */
+    aiTextureFlags_IgnoreAlpha = 0x4,
+
+#ifndef SWIG
+      _aiTextureFlags_Force32Bit = INT_MAX
+#endif
+};
+
+
+// ---------------------------------------------------------------------------
+/** @brief Defines alpha-blend flags.
+ *
+ *  If you're familiar with OpenGL or D3D, these flags aren't new to you.
+ *  They define *how* the final color value of a pixel is computed, basing
+ *  on the previous color at that pixel and the new color value from the
+ *  material.
+ *  The blend formula is:
+ *  @code
+ *    SourceColor * SourceBlend + DestColor * DestBlend
+ *  @endcode
+ *  where DestColor is the previous color in the framebuffer at this
+ *  position and SourceColor is the material color before the transparency
+ *  calculation.<br>
+ *  This corresponds to the #AI_MATKEY_BLEND_FUNC property.
+*/
+enum aiBlendMode
+{
+    /**
+     *  Formula:
+     *  @code
+     *  SourceColor*SourceAlpha + DestColor*(1-SourceAlpha)
+     *  @endcode
+     */
+    aiBlendMode_Default = 0x0,
+
+    /** Additive blending
+     *
+     *  Formula:
+     *  @code
+     *  SourceColor*1 + DestColor*1
+     *  @endcode
+     */
+    aiBlendMode_Additive = 0x1,
+
+    // we don't need more for the moment, but we might need them
+    // in future versions ...
+
+#ifndef SWIG
+    _aiBlendMode_Force32Bit = INT_MAX
+#endif
+};
+
+
+#include "./Compiler/pushpack1.h"
+
+// ---------------------------------------------------------------------------
+/** @brief Defines how an UV channel is transformed.
+ *
+ *  This is just a helper structure for the #AI_MATKEY_UVTRANSFORM key.
+ *  See its documentation for more details.
+ *
+ *  Typically you'll want to build a matrix of this information. However,
+ *  we keep separate scaling/translation/rotation values to make it
+ *  easier to process and optimize UV transformations internally.
+ */
+struct aiUVTransform
+{
+    /** Translation on the u and v axes.
+     *
+     *  The default value is (0|0).
+     */
+    C_STRUCT aiVector2D mTranslation;
+
+    /** Scaling on the u and v axes.
+     *
+     *  The default value is (1|1).
+     */
+    C_STRUCT aiVector2D mScaling;
+
+    /** Rotation - in counter-clockwise direction.
+     *
+     *  The rotation angle is specified in radians. The
+     *  rotation center is 0.5f|0.5f. The default value
+     *  0.f.
+     */
+    ai_real mRotation;
+
+
+#ifdef __cplusplus
+    aiUVTransform()
+        :   mTranslation (0.0,0.0)
+        ,   mScaling    (1.0,1.0)
+        ,   mRotation   (0.0)
+    {
+        // nothing to be done here ...
+    }
+#endif
+
+};
+
+#include "./Compiler/poppack1.h"
+
+//! @cond AI_DOX_INCLUDE_INTERNAL
+// ---------------------------------------------------------------------------
+/** @brief A very primitive RTTI system for the contents of material
+ *  properties.
+ */
+enum aiPropertyTypeInfo
+{
+    /** Array of single-precision (32 Bit) floats
+     *
+     *  It is possible to use aiGetMaterialInteger[Array]() (or the C++-API
+     *  aiMaterial::Get()) to query properties stored in floating-point format.
+     *  The material system performs the type conversion automatically.
+    */
+    aiPTI_Float   = 0x1,
+
+    /** Array of double-precision (64 Bit) floats
+     *
+     *  It is possible to use aiGetMaterialInteger[Array]() (or the C++-API
+     *  aiMaterial::Get()) to query properties stored in floating-point format.
+     *  The material system performs the type conversion automatically.
+    */
+    aiPTI_Double   = 0x2,
+
+    /** The material property is an aiString.
+     *
+     *  Arrays of strings aren't possible, aiGetMaterialString() (or the
+     *  C++-API aiMaterial::Get()) *must* be used to query a string property.
+    */
+    aiPTI_String  = 0x3,
+
+    /** Array of (32 Bit) integers
+     *
+     *  It is possible to use aiGetMaterialFloat[Array]() (or the C++-API
+     *  aiMaterial::Get()) to query properties stored in integer format.
+     *  The material system performs the type conversion automatically.
+    */
+    aiPTI_Integer = 0x4,
+
+
+    /** Simple binary buffer, content undefined. Not convertible to anything.
+    */
+    aiPTI_Buffer  = 0x5,
+
+
+     /** This value is not used. It is just there to force the
+     *  compiler to map this enum to a 32 Bit integer.
+     */
+#ifndef SWIG
+     _aiPTI_Force32Bit = INT_MAX
+#endif
+};
+
+// ---------------------------------------------------------------------------
+/** @brief Data structure for a single material property
+ *
+ *  As an user, you'll probably never need to deal with this data structure.
+ *  Just use the provided aiGetMaterialXXX() or aiMaterial::Get() family
+ *  of functions to query material properties easily. Processing them
+ *  manually is faster, but it is not the recommended way. It isn't worth
+ *  the effort. <br>
+ *  Material property names follow a simple scheme:
+ *  @code
+ *    $<name>
+ *    ?<name>
+ *       A public property, there must be corresponding AI_MATKEY_XXX define
+ *       2nd: Public, but ignored by the #aiProcess_RemoveRedundantMaterials
+ *       post-processing step.
+ *    ~<name>
+ *       A temporary property for internal use.
+ *  @endcode
+ *  @see aiMaterial
+ */
+struct aiMaterialProperty
+{
+    /** Specifies the name of the property (key)
+     *  Keys are generally case insensitive.
+     */
+    C_STRUCT aiString mKey;
+
+    /** Textures: Specifies their exact usage semantic.
+     * For non-texture properties, this member is always 0
+     * (or, better-said, #aiTextureType_NONE).
+     */
+    unsigned int mSemantic;
+
+    /** Textures: Specifies the index of the texture.
+     *  For non-texture properties, this member is always 0.
+     */
+    unsigned int mIndex;
+
+    /** Size of the buffer mData is pointing to, in bytes.
+     *  This value may not be 0.
+     */
+    unsigned int mDataLength;
+
+    /** Type information for the property.
+     *
+     * Defines the data layout inside the data buffer. This is used
+     * by the library internally to perform debug checks and to
+     * utilize proper type conversions.
+     * (It's probably a hacky solution, but it works.)
+     */
+    C_ENUM aiPropertyTypeInfo mType;
+
+    /** Binary buffer to hold the property's value.
+     * The size of the buffer is always mDataLength.
+     */
+    char* mData;
+
+#ifdef __cplusplus
+
+    aiMaterialProperty()
+        : mSemantic( 0 )
+        , mIndex( 0 )
+        , mDataLength( 0 )
+        , mType( aiPTI_Float )
+        , mData( NULL )
+    {
+    }
+
+    ~aiMaterialProperty()   {
+        delete[] mData;
+    }
+
+#endif
+};
+//! @endcond
+
+#ifdef __cplusplus
+} // We need to leave the "C" block here to allow template member functions
+#endif
+
+// ---------------------------------------------------------------------------
+/** @brief Data structure for a material
+*
+*  Material data is stored using a key-value structure. A single key-value
+*  pair is called a 'material property'. C++ users should use the provided
+*  member functions of aiMaterial to process material properties, C users
+*  have to stick with the aiMaterialGetXXX family of unbound functions.
+*  The library defines a set of standard keys (AI_MATKEY_XXX).
+*/
+#ifdef __cplusplus
+struct ASSIMP_API aiMaterial
+#else
+struct aiMaterial
+#endif
+{
+
+#ifdef __cplusplus
+
+public:
+
+    aiMaterial();
+    ~aiMaterial();
+
+    // -------------------------------------------------------------------
+    /** @brief Retrieve an array of Type values with a specific key
+     *  from the material
+     *
+     * @param pKey Key to search for. One of the AI_MATKEY_XXX constants.
+     * @param type .. set by AI_MATKEY_XXX
+     * @param idx .. set by AI_MATKEY_XXX
+     * @param pOut Pointer to a buffer to receive the result.
+     * @param pMax Specifies the size of the given buffer, in Type's.
+     * Receives the number of values (not bytes!) read.
+     * NULL is a valid value for this parameter.
+     */
+    template <typename Type>
+    aiReturn Get(const char* pKey,unsigned int type,
+        unsigned int idx, Type* pOut, unsigned int* pMax) const;
+
+    aiReturn Get(const char* pKey,unsigned int type,
+        unsigned int idx, int* pOut, unsigned int* pMax) const;
+
+    aiReturn Get(const char* pKey,unsigned int type,
+        unsigned int idx, ai_real* pOut, unsigned int* pMax) const;
+
+    // -------------------------------------------------------------------
+    /** @brief Retrieve a Type value with a specific key
+     *  from the material
+     *
+     * @param pKey Key to search for. One of the AI_MATKEY_XXX constants.
+    * @param type Specifies the type of the texture to be retrieved (
+    *    e.g. diffuse, specular, height map ...)
+    * @param idx Index of the texture to be retrieved.
+     * @param pOut Reference to receive the output value
+     */
+    template <typename Type>
+    aiReturn Get(const char* pKey,unsigned int type,
+        unsigned int idx,Type& pOut) const;
+
+
+    aiReturn Get(const char* pKey,unsigned int type,
+        unsigned int idx, int& pOut) const;
+
+    aiReturn Get(const char* pKey,unsigned int type,
+        unsigned int idx, ai_real& pOut) const;
+
+    aiReturn Get(const char* pKey,unsigned int type,
+        unsigned int idx, aiString& pOut) const;
+
+    aiReturn Get(const char* pKey,unsigned int type,
+        unsigned int idx, aiColor3D& pOut) const;
+
+    aiReturn Get(const char* pKey,unsigned int type,
+        unsigned int idx, aiColor4D& pOut) const;
+
+    aiReturn Get(const char* pKey,unsigned int type,
+        unsigned int idx, aiUVTransform& pOut) const;
+
+    // -------------------------------------------------------------------
+    /** Get the number of textures for a particular texture type.
+     *  @param type Texture type to check for
+     *  @return Number of textures for this type.
+     *  @note A texture can be easily queried using #GetTexture() */
+    unsigned int GetTextureCount(aiTextureType type) const;
+
+    // -------------------------------------------------------------------
+    /** Helper function to get all parameters pertaining to a
+     *  particular texture slot from a material.
+     *
+     *  This function is provided just for convenience, you could also
+     *  read the single material properties manually.
+     *  @param type Specifies the type of the texture to be retrieved (
+     *    e.g. diffuse, specular, height map ...)
+     *  @param index Index of the texture to be retrieved. The function fails
+     *    if there is no texture of that type with this index.
+     *    #GetTextureCount() can be used to determine the number of textures
+     *    per texture type.
+     *  @param path Receives the path to the texture.
+     *    If the texture is embedded, receives a '*' followed by the id of
+     *    the texture (for the textures stored in the corresponding scene) which
+     *    can be converted to an int using a function like atoi.
+     *    NULL is a valid value.
+     *  @param mapping The texture mapping.
+     *    NULL is allowed as value.
+     *  @param uvindex Receives the UV index of the texture.
+     *    NULL is a valid value.
+     *  @param blend Receives the blend factor for the texture
+     *    NULL is a valid value.
+     *  @param op Receives the texture operation to be performed between
+     *    this texture and the previous texture. NULL is allowed as value.
+     *  @param mapmode Receives the mapping modes to be used for the texture.
+     *    The parameter may be NULL but if it is a valid pointer it MUST
+     *    point to an array of 3 aiTextureMapMode's (one for each
+     *    axis: UVW order (=XYZ)).
+     */
+    // -------------------------------------------------------------------
+    aiReturn GetTexture(aiTextureType type,
+        unsigned int  index,
+        C_STRUCT aiString* path,
+        aiTextureMapping* mapping   = NULL,
+        unsigned int* uvindex       = NULL,
+        ai_real* blend              = NULL,
+        aiTextureOp* op             = NULL,
+        aiTextureMapMode* mapmode   = NULL) const;
+
+
+    // Setters
+
+
+    // ------------------------------------------------------------------------------
+    /** @brief Add a property with a given key and type info to the material
+     *  structure
+     *
+     *  @param pInput Pointer to input data
+     *  @param pSizeInBytes Size of input data
+     *  @param pKey Key/Usage of the property (AI_MATKEY_XXX)
+     *  @param type Set by the AI_MATKEY_XXX macro
+     *  @param index Set by the AI_MATKEY_XXX macro
+     *  @param pType Type information hint */
+    aiReturn AddBinaryProperty (const void* pInput,
+        unsigned int pSizeInBytes,
+        const char* pKey,
+        unsigned int type ,
+        unsigned int index ,
+        aiPropertyTypeInfo pType);
+
+    // ------------------------------------------------------------------------------
+    /** @brief Add a string property with a given key and type info to the
+     *  material structure
+     *
+     *  @param pInput Input string
+     *  @param pKey Key/Usage of the property (AI_MATKEY_XXX)
+     *  @param type Set by the AI_MATKEY_XXX macro
+     *  @param index Set by the AI_MATKEY_XXX macro */
+    aiReturn AddProperty (const aiString* pInput,
+        const char* pKey,
+        unsigned int type  = 0,
+        unsigned int index = 0);
+
+    // ------------------------------------------------------------------------------
+    /** @brief Add a property with a given key to the material structure
+     *  @param pInput Pointer to the input data
+     *  @param pNumValues Number of values in the array
+     *  @param pKey Key/Usage of the property (AI_MATKEY_XXX)
+     *  @param type Set by the AI_MATKEY_XXX macro
+     *  @param index Set by the AI_MATKEY_XXX macro  */
+    template<class TYPE>
+    aiReturn AddProperty (const TYPE* pInput,
+        unsigned int pNumValues,
+        const char* pKey,
+        unsigned int type  = 0,
+        unsigned int index = 0);
+
+    aiReturn AddProperty (const aiVector3D* pInput,
+        unsigned int pNumValues,
+        const char* pKey,
+        unsigned int type  = 0,
+        unsigned int index = 0);
+
+    aiReturn AddProperty (const aiColor3D* pInput,
+        unsigned int pNumValues,
+        const char* pKey,
+        unsigned int type  = 0,
+        unsigned int index = 0);
+
+    aiReturn AddProperty (const aiColor4D* pInput,
+        unsigned int pNumValues,
+        const char* pKey,
+        unsigned int type  = 0,
+        unsigned int index = 0);
+
+    aiReturn AddProperty (const int* pInput,
+        unsigned int pNumValues,
+        const char* pKey,
+        unsigned int type  = 0,
+        unsigned int index = 0);
+
+    aiReturn AddProperty (const float* pInput,
+        unsigned int pNumValues,
+        const char* pKey,
+        unsigned int type  = 0,
+        unsigned int index = 0);
+
+    aiReturn AddProperty (const double* pInput,
+        unsigned int pNumValues,
+        const char* pKey,
+        unsigned int type  = 0,
+        unsigned int index = 0);
+
+    aiReturn AddProperty (const aiUVTransform* pInput,
+        unsigned int pNumValues,
+        const char* pKey,
+        unsigned int type  = 0,
+        unsigned int index = 0);
+
+    // ------------------------------------------------------------------------------
+    /** @brief Remove a given key from the list.
+     *
+     *  The function fails if the key isn't found
+     *  @param pKey Key to be deleted
+     *  @param type Set by the AI_MATKEY_XXX macro
+     *  @param index Set by the AI_MATKEY_XXX macro  */
+    aiReturn RemoveProperty (const char* pKey,
+        unsigned int type  = 0,
+        unsigned int index = 0);
+
+    // ------------------------------------------------------------------------------
+    /** @brief Removes all properties from the material.
+     *
+     *  The data array remains allocated so adding new properties is quite fast.  */
+    void Clear();
+
+    // ------------------------------------------------------------------------------
+    /** Copy the property list of a material
+     *  @param pcDest Destination material
+     *  @param pcSrc Source material
+     */
+    static void CopyPropertyList(aiMaterial* pcDest,
+        const aiMaterial* pcSrc);
+
+
+#endif
+
+    /** List of all material properties loaded. */
+    C_STRUCT aiMaterialProperty** mProperties;
+
+    /** Number of properties in the data base */
+    unsigned int mNumProperties;
+
+     /** Storage allocated */
+    unsigned int mNumAllocated;
+};
+
+// Go back to extern "C" again
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// ---------------------------------------------------------------------------
+#define AI_MATKEY_NAME "?mat.name",0,0
+#define AI_MATKEY_TWOSIDED "$mat.twosided",0,0
+#define AI_MATKEY_SHADING_MODEL "$mat.shadingm",0,0
+#define AI_MATKEY_ENABLE_WIREFRAME "$mat.wireframe",0,0
+#define AI_MATKEY_BLEND_FUNC "$mat.blend",0,0
+#define AI_MATKEY_OPACITY "$mat.opacity",0,0
+#define AI_MATKEY_BUMPSCALING "$mat.bumpscaling",0,0
+#define AI_MATKEY_SHININESS "$mat.shininess",0,0
+#define AI_MATKEY_REFLECTIVITY "$mat.reflectivity",0,0
+#define AI_MATKEY_SHININESS_STRENGTH "$mat.shinpercent",0,0
+#define AI_MATKEY_REFRACTI "$mat.refracti",0,0
+#define AI_MATKEY_COLOR_DIFFUSE "$clr.diffuse",0,0
+#define AI_MATKEY_COLOR_AMBIENT "$clr.ambient",0,0
+#define AI_MATKEY_COLOR_SPECULAR "$clr.specular",0,0
+#define AI_MATKEY_COLOR_EMISSIVE "$clr.emissive",0,0
+#define AI_MATKEY_COLOR_TRANSPARENT "$clr.transparent",0,0
+#define AI_MATKEY_COLOR_REFLECTIVE "$clr.reflective",0,0
+#define AI_MATKEY_GLOBAL_BACKGROUND_IMAGE "?bg.global",0,0
+
+// ---------------------------------------------------------------------------
+// Pure key names for all texture-related properties
+//! @cond MATS_DOC_FULL
+#define _AI_MATKEY_TEXTURE_BASE         "$tex.file"
+#define _AI_MATKEY_UVWSRC_BASE          "$tex.uvwsrc"
+#define _AI_MATKEY_TEXOP_BASE           "$tex.op"
+#define _AI_MATKEY_MAPPING_BASE         "$tex.mapping"
+#define _AI_MATKEY_TEXBLEND_BASE        "$tex.blend"
+#define _AI_MATKEY_MAPPINGMODE_U_BASE   "$tex.mapmodeu"
+#define _AI_MATKEY_MAPPINGMODE_V_BASE   "$tex.mapmodev"
+#define _AI_MATKEY_TEXMAP_AXIS_BASE     "$tex.mapaxis"
+#define _AI_MATKEY_UVTRANSFORM_BASE     "$tex.uvtrafo"
+#define _AI_MATKEY_TEXFLAGS_BASE        "$tex.flags"
+//! @endcond
+
+// ---------------------------------------------------------------------------
+#define AI_MATKEY_TEXTURE(type, N) _AI_MATKEY_TEXTURE_BASE,type,N
+
+// For backward compatibility and simplicity
+//! @cond MATS_DOC_FULL
+#define AI_MATKEY_TEXTURE_DIFFUSE(N)    \
+    AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE,N)
+
+#define AI_MATKEY_TEXTURE_SPECULAR(N)   \
+    AI_MATKEY_TEXTURE(aiTextureType_SPECULAR,N)
+
+#define AI_MATKEY_TEXTURE_AMBIENT(N)    \
+    AI_MATKEY_TEXTURE(aiTextureType_AMBIENT,N)
+
+#define AI_MATKEY_TEXTURE_EMISSIVE(N)   \
+    AI_MATKEY_TEXTURE(aiTextureType_EMISSIVE,N)
+
+#define AI_MATKEY_TEXTURE_NORMALS(N)    \
+    AI_MATKEY_TEXTURE(aiTextureType_NORMALS,N)
+
+#define AI_MATKEY_TEXTURE_HEIGHT(N) \
+    AI_MATKEY_TEXTURE(aiTextureType_HEIGHT,N)
+
+#define AI_MATKEY_TEXTURE_SHININESS(N)  \
+    AI_MATKEY_TEXTURE(aiTextureType_SHININESS,N)
+
+#define AI_MATKEY_TEXTURE_OPACITY(N)    \
+    AI_MATKEY_TEXTURE(aiTextureType_OPACITY,N)
+
+#define AI_MATKEY_TEXTURE_DISPLACEMENT(N)   \
+    AI_MATKEY_TEXTURE(aiTextureType_DISPLACEMENT,N)
+
+#define AI_MATKEY_TEXTURE_LIGHTMAP(N)   \
+    AI_MATKEY_TEXTURE(aiTextureType_LIGHTMAP,N)
+
+#define AI_MATKEY_TEXTURE_REFLECTION(N) \
+    AI_MATKEY_TEXTURE(aiTextureType_REFLECTION,N)
+
+//! @endcond
+
+// ---------------------------------------------------------------------------
+#define AI_MATKEY_UVWSRC(type, N) _AI_MATKEY_UVWSRC_BASE,type,N
+
+// For backward compatibility and simplicity
+//! @cond MATS_DOC_FULL
+#define AI_MATKEY_UVWSRC_DIFFUSE(N) \
+    AI_MATKEY_UVWSRC(aiTextureType_DIFFUSE,N)
+
+#define AI_MATKEY_UVWSRC_SPECULAR(N)    \
+    AI_MATKEY_UVWSRC(aiTextureType_SPECULAR,N)
+
+#define AI_MATKEY_UVWSRC_AMBIENT(N) \
+    AI_MATKEY_UVWSRC(aiTextureType_AMBIENT,N)
+
+#define AI_MATKEY_UVWSRC_EMISSIVE(N)    \
+    AI_MATKEY_UVWSRC(aiTextureType_EMISSIVE,N)
+
+#define AI_MATKEY_UVWSRC_NORMALS(N) \
+    AI_MATKEY_UVWSRC(aiTextureType_NORMALS,N)
+
+#define AI_MATKEY_UVWSRC_HEIGHT(N)  \
+    AI_MATKEY_UVWSRC(aiTextureType_HEIGHT,N)
+
+#define AI_MATKEY_UVWSRC_SHININESS(N)   \
+    AI_MATKEY_UVWSRC(aiTextureType_SHININESS,N)
+
+#define AI_MATKEY_UVWSRC_OPACITY(N) \
+    AI_MATKEY_UVWSRC(aiTextureType_OPACITY,N)
+
+#define AI_MATKEY_UVWSRC_DISPLACEMENT(N)    \
+    AI_MATKEY_UVWSRC(aiTextureType_DISPLACEMENT,N)
+
+#define AI_MATKEY_UVWSRC_LIGHTMAP(N)    \
+    AI_MATKEY_UVWSRC(aiTextureType_LIGHTMAP,N)
+
+#define AI_MATKEY_UVWSRC_REFLECTION(N)  \
+    AI_MATKEY_UVWSRC(aiTextureType_REFLECTION,N)
+
+//! @endcond
+// ---------------------------------------------------------------------------
+#define AI_MATKEY_TEXOP(type, N) _AI_MATKEY_TEXOP_BASE,type,N
+
+// For backward compatibility and simplicity
+//! @cond MATS_DOC_FULL
+#define AI_MATKEY_TEXOP_DIFFUSE(N)  \
+    AI_MATKEY_TEXOP(aiTextureType_DIFFUSE,N)
+
+#define AI_MATKEY_TEXOP_SPECULAR(N) \
+    AI_MATKEY_TEXOP(aiTextureType_SPECULAR,N)
+
+#define AI_MATKEY_TEXOP_AMBIENT(N)  \
+    AI_MATKEY_TEXOP(aiTextureType_AMBIENT,N)
+
+#define AI_MATKEY_TEXOP_EMISSIVE(N) \
+    AI_MATKEY_TEXOP(aiTextureType_EMISSIVE,N)
+
+#define AI_MATKEY_TEXOP_NORMALS(N)  \
+    AI_MATKEY_TEXOP(aiTextureType_NORMALS,N)
+
+#define AI_MATKEY_TEXOP_HEIGHT(N)   \
+    AI_MATKEY_TEXOP(aiTextureType_HEIGHT,N)
+
+#define AI_MATKEY_TEXOP_SHININESS(N)    \
+    AI_MATKEY_TEXOP(aiTextureType_SHININESS,N)
+
+#define AI_MATKEY_TEXOP_OPACITY(N)  \
+    AI_MATKEY_TEXOP(aiTextureType_OPACITY,N)
+
+#define AI_MATKEY_TEXOP_DISPLACEMENT(N) \
+    AI_MATKEY_TEXOP(aiTextureType_DISPLACEMENT,N)
+
+#define AI_MATKEY_TEXOP_LIGHTMAP(N) \
+    AI_MATKEY_TEXOP(aiTextureType_LIGHTMAP,N)
+
+#define AI_MATKEY_TEXOP_REFLECTION(N)   \
+    AI_MATKEY_TEXOP(aiTextureType_REFLECTION,N)
+
+//! @endcond
+// ---------------------------------------------------------------------------
+#define AI_MATKEY_MAPPING(type, N) _AI_MATKEY_MAPPING_BASE,type,N
+
+// For backward compatibility and simplicity
+//! @cond MATS_DOC_FULL
+#define AI_MATKEY_MAPPING_DIFFUSE(N)    \
+    AI_MATKEY_MAPPING(aiTextureType_DIFFUSE,N)
+
+#define AI_MATKEY_MAPPING_SPECULAR(N)   \
+    AI_MATKEY_MAPPING(aiTextureType_SPECULAR,N)
+
+#define AI_MATKEY_MAPPING_AMBIENT(N)    \
+    AI_MATKEY_MAPPING(aiTextureType_AMBIENT,N)
+
+#define AI_MATKEY_MAPPING_EMISSIVE(N)   \
+    AI_MATKEY_MAPPING(aiTextureType_EMISSIVE,N)
+
+#define AI_MATKEY_MAPPING_NORMALS(N)    \
+    AI_MATKEY_MAPPING(aiTextureType_NORMALS,N)
+
+#define AI_MATKEY_MAPPING_HEIGHT(N) \
+    AI_MATKEY_MAPPING(aiTextureType_HEIGHT,N)
+
+#define AI_MATKEY_MAPPING_SHININESS(N)  \
+    AI_MATKEY_MAPPING(aiTextureType_SHININESS,N)
+
+#define AI_MATKEY_MAPPING_OPACITY(N)    \
+    AI_MATKEY_MAPPING(aiTextureType_OPACITY,N)
+
+#define AI_MATKEY_MAPPING_DISPLACEMENT(N)   \
+    AI_MATKEY_MAPPING(aiTextureType_DISPLACEMENT,N)
+
+#define AI_MATKEY_MAPPING_LIGHTMAP(N)   \
+    AI_MATKEY_MAPPING(aiTextureType_LIGHTMAP,N)
+
+#define AI_MATKEY_MAPPING_REFLECTION(N) \
+    AI_MATKEY_MAPPING(aiTextureType_REFLECTION,N)
+
+//! @endcond
+// ---------------------------------------------------------------------------
+#define AI_MATKEY_TEXBLEND(type, N) _AI_MATKEY_TEXBLEND_BASE,type,N
+
+// For backward compatibility and simplicity
+//! @cond MATS_DOC_FULL
+#define AI_MATKEY_TEXBLEND_DIFFUSE(N)   \
+    AI_MATKEY_TEXBLEND(aiTextureType_DIFFUSE,N)
+
+#define AI_MATKEY_TEXBLEND_SPECULAR(N)  \
+    AI_MATKEY_TEXBLEND(aiTextureType_SPECULAR,N)
+
+#define AI_MATKEY_TEXBLEND_AMBIENT(N)   \
+    AI_MATKEY_TEXBLEND(aiTextureType_AMBIENT,N)
+
+#define AI_MATKEY_TEXBLEND_EMISSIVE(N)  \
+    AI_MATKEY_TEXBLEND(aiTextureType_EMISSIVE,N)
+
+#define AI_MATKEY_TEXBLEND_NORMALS(N)   \
+    AI_MATKEY_TEXBLEND(aiTextureType_NORMALS,N)
+
+#define AI_MATKEY_TEXBLEND_HEIGHT(N)    \
+    AI_MATKEY_TEXBLEND(aiTextureType_HEIGHT,N)
+
+#define AI_MATKEY_TEXBLEND_SHININESS(N) \
+    AI_MATKEY_TEXBLEND(aiTextureType_SHININESS,N)
+
+#define AI_MATKEY_TEXBLEND_OPACITY(N)   \
+    AI_MATKEY_TEXBLEND(aiTextureType_OPACITY,N)
+
+#define AI_MATKEY_TEXBLEND_DISPLACEMENT(N)  \
+    AI_MATKEY_TEXBLEND(aiTextureType_DISPLACEMENT,N)
+
+#define AI_MATKEY_TEXBLEND_LIGHTMAP(N)  \
+    AI_MATKEY_TEXBLEND(aiTextureType_LIGHTMAP,N)
+
+#define AI_MATKEY_TEXBLEND_REFLECTION(N)    \
+    AI_MATKEY_TEXBLEND(aiTextureType_REFLECTION,N)
+
+//! @endcond
+// ---------------------------------------------------------------------------
+#define AI_MATKEY_MAPPINGMODE_U(type, N) _AI_MATKEY_MAPPINGMODE_U_BASE,type,N
+
+// For backward compatibility and simplicity
+//! @cond MATS_DOC_FULL
+#define AI_MATKEY_MAPPINGMODE_U_DIFFUSE(N)  \
+    AI_MATKEY_MAPPINGMODE_U(aiTextureType_DIFFUSE,N)
+
+#define AI_MATKEY_MAPPINGMODE_U_SPECULAR(N) \
+    AI_MATKEY_MAPPINGMODE_U(aiTextureType_SPECULAR,N)
+
+#define AI_MATKEY_MAPPINGMODE_U_AMBIENT(N)  \
+    AI_MATKEY_MAPPINGMODE_U(aiTextureType_AMBIENT,N)
+
+#define AI_MATKEY_MAPPINGMODE_U_EMISSIVE(N) \
+    AI_MATKEY_MAPPINGMODE_U(aiTextureType_EMISSIVE,N)
+
+#define AI_MATKEY_MAPPINGMODE_U_NORMALS(N)  \
+    AI_MATKEY_MAPPINGMODE_U(aiTextureType_NORMALS,N)
+
+#define AI_MATKEY_MAPPINGMODE_U_HEIGHT(N)   \
+    AI_MATKEY_MAPPINGMODE_U(aiTextureType_HEIGHT,N)
+
+#define AI_MATKEY_MAPPINGMODE_U_SHININESS(N)    \
+    AI_MATKEY_MAPPINGMODE_U(aiTextureType_SHININESS,N)
+
+#define AI_MATKEY_MAPPINGMODE_U_OPACITY(N)  \
+    AI_MATKEY_MAPPINGMODE_U(aiTextureType_OPACITY,N)
+
+#define AI_MATKEY_MAPPINGMODE_U_DISPLACEMENT(N) \
+    AI_MATKEY_MAPPINGMODE_U(aiTextureType_DISPLACEMENT,N)
+
+#define AI_MATKEY_MAPPINGMODE_U_LIGHTMAP(N) \
+    AI_MATKEY_MAPPINGMODE_U(aiTextureType_LIGHTMAP,N)
+
+#define AI_MATKEY_MAPPINGMODE_U_REFLECTION(N)   \
+    AI_MATKEY_MAPPINGMODE_U(aiTextureType_REFLECTION,N)
+
+//! @endcond
+// ---------------------------------------------------------------------------
+#define AI_MATKEY_MAPPINGMODE_V(type, N) _AI_MATKEY_MAPPINGMODE_V_BASE,type,N
+
+// For backward compatibility and simplicity
+//! @cond MATS_DOC_FULL
+#define AI_MATKEY_MAPPINGMODE_V_DIFFUSE(N)  \
+    AI_MATKEY_MAPPINGMODE_V(aiTextureType_DIFFUSE,N)
+
+#define AI_MATKEY_MAPPINGMODE_V_SPECULAR(N) \
+    AI_MATKEY_MAPPINGMODE_V(aiTextureType_SPECULAR,N)
+
+#define AI_MATKEY_MAPPINGMODE_V_AMBIENT(N)  \
+    AI_MATKEY_MAPPINGMODE_V(aiTextureType_AMBIENT,N)
+
+#define AI_MATKEY_MAPPINGMODE_V_EMISSIVE(N) \
+    AI_MATKEY_MAPPINGMODE_V(aiTextureType_EMISSIVE,N)
+
+#define AI_MATKEY_MAPPINGMODE_V_NORMALS(N)  \
+    AI_MATKEY_MAPPINGMODE_V(aiTextureType_NORMALS,N)
+
+#define AI_MATKEY_MAPPINGMODE_V_HEIGHT(N)   \
+    AI_MATKEY_MAPPINGMODE_V(aiTextureType_HEIGHT,N)
+
+#define AI_MATKEY_MAPPINGMODE_V_SHININESS(N)    \
+    AI_MATKEY_MAPPINGMODE_V(aiTextureType_SHININESS,N)
+
+#define AI_MATKEY_MAPPINGMODE_V_OPACITY(N)  \
+    AI_MATKEY_MAPPINGMODE_V(aiTextureType_OPACITY,N)
+
+#define AI_MATKEY_MAPPINGMODE_V_DISPLACEMENT(N) \
+    AI_MATKEY_MAPPINGMODE_V(aiTextureType_DISPLACEMENT,N)
+
+#define AI_MATKEY_MAPPINGMODE_V_LIGHTMAP(N) \
+    AI_MATKEY_MAPPINGMODE_V(aiTextureType_LIGHTMAP,N)
+
+#define AI_MATKEY_MAPPINGMODE_V_REFLECTION(N)   \
+    AI_MATKEY_MAPPINGMODE_V(aiTextureType_REFLECTION,N)
+
+//! @endcond
+// ---------------------------------------------------------------------------
+#define AI_MATKEY_TEXMAP_AXIS(type, N) _AI_MATKEY_TEXMAP_AXIS_BASE,type,N
+
+// For backward compatibility and simplicity
+//! @cond MATS_DOC_FULL
+#define AI_MATKEY_TEXMAP_AXIS_DIFFUSE(N)    \
+    AI_MATKEY_TEXMAP_AXIS(aiTextureType_DIFFUSE,N)
+
+#define AI_MATKEY_TEXMAP_AXIS_SPECULAR(N)   \
+    AI_MATKEY_TEXMAP_AXIS(aiTextureType_SPECULAR,N)
+
+#define AI_MATKEY_TEXMAP_AXIS_AMBIENT(N)    \
+    AI_MATKEY_TEXMAP_AXIS(aiTextureType_AMBIENT,N)
+
+#define AI_MATKEY_TEXMAP_AXIS_EMISSIVE(N)   \
+    AI_MATKEY_TEXMAP_AXIS(aiTextureType_EMISSIVE,N)
+
+#define AI_MATKEY_TEXMAP_AXIS_NORMALS(N)    \
+    AI_MATKEY_TEXMAP_AXIS(aiTextureType_NORMALS,N)
+
+#define AI_MATKEY_TEXMAP_AXIS_HEIGHT(N) \
+    AI_MATKEY_TEXMAP_AXIS(aiTextureType_HEIGHT,N)
+
+#define AI_MATKEY_TEXMAP_AXIS_SHININESS(N)  \
+    AI_MATKEY_TEXMAP_AXIS(aiTextureType_SHININESS,N)
+
+#define AI_MATKEY_TEXMAP_AXIS_OPACITY(N)    \
+    AI_MATKEY_TEXMAP_AXIS(aiTextureType_OPACITY,N)
+
+#define AI_MATKEY_TEXMAP_AXIS_DISPLACEMENT(N)   \
+    AI_MATKEY_TEXMAP_AXIS(aiTextureType_DISPLACEMENT,N)
+
+#define AI_MATKEY_TEXMAP_AXIS_LIGHTMAP(N)   \
+    AI_MATKEY_TEXMAP_AXIS(aiTextureType_LIGHTMAP,N)
+
+#define AI_MATKEY_TEXMAP_AXIS_REFLECTION(N) \
+    AI_MATKEY_TEXMAP_AXIS(aiTextureType_REFLECTION,N)
+
+//! @endcond
+// ---------------------------------------------------------------------------
+#define AI_MATKEY_UVTRANSFORM(type, N) _AI_MATKEY_UVTRANSFORM_BASE,type,N
+
+// For backward compatibility and simplicity
+//! @cond MATS_DOC_FULL
+#define AI_MATKEY_UVTRANSFORM_DIFFUSE(N)    \
+    AI_MATKEY_UVTRANSFORM(aiTextureType_DIFFUSE,N)
+
+#define AI_MATKEY_UVTRANSFORM_SPECULAR(N)   \
+    AI_MATKEY_UVTRANSFORM(aiTextureType_SPECULAR,N)
+
+#define AI_MATKEY_UVTRANSFORM_AMBIENT(N)    \
+    AI_MATKEY_UVTRANSFORM(aiTextureType_AMBIENT,N)
+
+#define AI_MATKEY_UVTRANSFORM_EMISSIVE(N)   \
+    AI_MATKEY_UVTRANSFORM(aiTextureType_EMISSIVE,N)
+
+#define AI_MATKEY_UVTRANSFORM_NORMALS(N)    \
+    AI_MATKEY_UVTRANSFORM(aiTextureType_NORMALS,N)
+
+#define AI_MATKEY_UVTRANSFORM_HEIGHT(N) \
+    AI_MATKEY_UVTRANSFORM(aiTextureType_HEIGHT,N)
+
+#define AI_MATKEY_UVTRANSFORM_SHININESS(N)  \
+    AI_MATKEY_UVTRANSFORM(aiTextureType_SHININESS,N)
+
+#define AI_MATKEY_UVTRANSFORM_OPACITY(N)    \
+    AI_MATKEY_UVTRANSFORM(aiTextureType_OPACITY,N)
+
+#define AI_MATKEY_UVTRANSFORM_DISPLACEMENT(N)   \
+    AI_MATKEY_UVTRANSFORM(aiTextureType_DISPLACEMENT,N)
+
+#define AI_MATKEY_UVTRANSFORM_LIGHTMAP(N)   \
+    AI_MATKEY_UVTRANSFORM(aiTextureType_LIGHTMAP,N)
+
+#define AI_MATKEY_UVTRANSFORM_REFLECTION(N) \
+    AI_MATKEY_UVTRANSFORM(aiTextureType_REFLECTION,N)
+
+#define AI_MATKEY_UVTRANSFORM_UNKNOWN(N)    \
+    AI_MATKEY_UVTRANSFORM(aiTextureType_UNKNOWN,N)
+
+//! @endcond
+// ---------------------------------------------------------------------------
+#define AI_MATKEY_TEXFLAGS(type, N) _AI_MATKEY_TEXFLAGS_BASE,type,N
+
+// For backward compatibility and simplicity
+//! @cond MATS_DOC_FULL
+#define AI_MATKEY_TEXFLAGS_DIFFUSE(N)   \
+    AI_MATKEY_TEXFLAGS(aiTextureType_DIFFUSE,N)
+
+#define AI_MATKEY_TEXFLAGS_SPECULAR(N)  \
+    AI_MATKEY_TEXFLAGS(aiTextureType_SPECULAR,N)
+
+#define AI_MATKEY_TEXFLAGS_AMBIENT(N)   \
+    AI_MATKEY_TEXFLAGS(aiTextureType_AMBIENT,N)
+
+#define AI_MATKEY_TEXFLAGS_EMISSIVE(N)  \
+    AI_MATKEY_TEXFLAGS(aiTextureType_EMISSIVE,N)
+
+#define AI_MATKEY_TEXFLAGS_NORMALS(N)   \
+    AI_MATKEY_TEXFLAGS(aiTextureType_NORMALS,N)
+
+#define AI_MATKEY_TEXFLAGS_HEIGHT(N)    \
+    AI_MATKEY_TEXFLAGS(aiTextureType_HEIGHT,N)
+
+#define AI_MATKEY_TEXFLAGS_SHININESS(N) \
+    AI_MATKEY_TEXFLAGS(aiTextureType_SHININESS,N)
+
+#define AI_MATKEY_TEXFLAGS_OPACITY(N)   \
+    AI_MATKEY_TEXFLAGS(aiTextureType_OPACITY,N)
+
+#define AI_MATKEY_TEXFLAGS_DISPLACEMENT(N)  \
+    AI_MATKEY_TEXFLAGS(aiTextureType_DISPLACEMENT,N)
+
+#define AI_MATKEY_TEXFLAGS_LIGHTMAP(N)  \
+    AI_MATKEY_TEXFLAGS(aiTextureType_LIGHTMAP,N)
+
+#define AI_MATKEY_TEXFLAGS_REFLECTION(N)    \
+    AI_MATKEY_TEXFLAGS(aiTextureType_REFLECTION,N)
+
+#define AI_MATKEY_TEXFLAGS_UNKNOWN(N)   \
+    AI_MATKEY_TEXFLAGS(aiTextureType_UNKNOWN,N)
+
+//! @endcond
+//!
+// ---------------------------------------------------------------------------
+/** @brief Retrieve a material property with a specific key from the material
+ *
+ * @param pMat Pointer to the input material. May not be NULL
+ * @param pKey Key to search for. One of the AI_MATKEY_XXX constants.
+ * @param type Specifies the type of the texture to be retrieved (
+ *    e.g. diffuse, specular, height map ...)
+ * @param index Index of the texture to be retrieved.
+ * @param pPropOut Pointer to receive a pointer to a valid aiMaterialProperty
+ *        structure or NULL if the key has not been found. */
+// ---------------------------------------------------------------------------
+ASSIMP_API C_ENUM aiReturn aiGetMaterialProperty(
+    const C_STRUCT aiMaterial* pMat,
+    const char* pKey,
+    unsigned int type,
+    unsigned int  index,
+    const C_STRUCT aiMaterialProperty** pPropOut);
+
+// ---------------------------------------------------------------------------
+/** @brief Retrieve an array of float values with a specific key
+ *  from the material
+ *
+ * Pass one of the AI_MATKEY_XXX constants for the last three parameters (the
+ * example reads the #AI_MATKEY_UVTRANSFORM property of the first diffuse texture)
+ * @code
+ * aiUVTransform trafo;
+ * unsigned int max = sizeof(aiUVTransform);
+ * if (AI_SUCCESS != aiGetMaterialFloatArray(mat, AI_MATKEY_UVTRANSFORM(aiTextureType_DIFFUSE,0),
+ *    (float*)&trafo, &max) || sizeof(aiUVTransform) != max)
+ * {
+ *   // error handling
+ * }
+ * @endcode
+ *
+ * @param pMat Pointer to the input material. May not be NULL
+ * @param pKey Key to search for. One of the AI_MATKEY_XXX constants.
+ * @param pOut Pointer to a buffer to receive the result.
+ * @param pMax Specifies the size of the given buffer, in float's.
+ *        Receives the number of values (not bytes!) read.
+ * @param type (see the code sample above)
+ * @param index (see the code sample above)
+ * @return Specifies whether the key has been found. If not, the output
+ *   arrays remains unmodified and pMax is set to 0.*/
+// ---------------------------------------------------------------------------
+ASSIMP_API C_ENUM aiReturn aiGetMaterialFloatArray(
+    const C_STRUCT aiMaterial* pMat,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index,
+    ai_real* pOut,
+    unsigned int* pMax);
+
+
+#ifdef __cplusplus
+
+// ---------------------------------------------------------------------------
+/** @brief Retrieve a single float property with a specific key from the material.
+*
+* Pass one of the AI_MATKEY_XXX constants for the last three parameters (the
+* example reads the #AI_MATKEY_SHININESS_STRENGTH property of the first diffuse texture)
+* @code
+* float specStrength = 1.f; // default value, remains unmodified if we fail.
+* aiGetMaterialFloat(mat, AI_MATKEY_SHININESS_STRENGTH,
+*    (float*)&specStrength);
+* @endcode
+*
+* @param pMat Pointer to the input material. May not be NULL
+* @param pKey Key to search for. One of the AI_MATKEY_XXX constants.
+* @param pOut Receives the output float.
+* @param type (see the code sample above)
+* @param index (see the code sample above)
+* @return Specifies whether the key has been found. If not, the output
+*   float remains unmodified.*/
+// ---------------------------------------------------------------------------
+inline aiReturn aiGetMaterialFloat(const aiMaterial* pMat,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index,
+    ai_real* pOut)
+{
+    return aiGetMaterialFloatArray(pMat,pKey,type,index,pOut,(unsigned int*)0x0);
+}
+
+#else
+
+// Use our friend, the C preprocessor
+#define aiGetMaterialFloat (pMat, type, index, pKey, pOut) \
+    aiGetMaterialFloatArray(pMat, type, index, pKey, pOut, NULL)
+
+#endif //!__cplusplus
+
+
+// ---------------------------------------------------------------------------
+/** @brief Retrieve an array of integer values with a specific key
+ *  from a material
+ *
+ * See the sample for aiGetMaterialFloatArray for more information.*/
+ASSIMP_API C_ENUM aiReturn aiGetMaterialIntegerArray(const C_STRUCT aiMaterial* pMat,
+     const char* pKey,
+     unsigned int  type,
+     unsigned int  index,
+     int* pOut,
+     unsigned int* pMax);
+
+
+#ifdef __cplusplus
+
+// ---------------------------------------------------------------------------
+/** @brief Retrieve an integer property with a specific key from a material
+ *
+ * See the sample for aiGetMaterialFloat for more information.*/
+// ---------------------------------------------------------------------------
+inline aiReturn aiGetMaterialInteger(const C_STRUCT aiMaterial* pMat,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index,
+    int* pOut)
+{
+    return aiGetMaterialIntegerArray(pMat,pKey,type,index,pOut,(unsigned int*)0x0);
+}
+
+#else
+
+// use our friend, the C preprocessor
+#define aiGetMaterialInteger (pMat, type, index, pKey, pOut) \
+    aiGetMaterialIntegerArray(pMat, type, index, pKey, pOut, NULL)
+
+#endif //!__cplusplus
+
+
+
+// ---------------------------------------------------------------------------
+/** @brief Retrieve a color value from the material property table
+*
+* See the sample for aiGetMaterialFloat for more information*/
+// ---------------------------------------------------------------------------
+ASSIMP_API C_ENUM aiReturn aiGetMaterialColor(const C_STRUCT aiMaterial* pMat,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index,
+    C_STRUCT aiColor4D* pOut);
+
+
+// ---------------------------------------------------------------------------
+/** @brief Retrieve a aiUVTransform value from the material property table
+*
+* See the sample for aiGetMaterialFloat for more information*/
+// ---------------------------------------------------------------------------
+ASSIMP_API C_ENUM aiReturn aiGetMaterialUVTransform(const C_STRUCT aiMaterial* pMat,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index,
+    C_STRUCT aiUVTransform* pOut);
+
+
+// ---------------------------------------------------------------------------
+/** @brief Retrieve a string from the material property table
+*
+* See the sample for aiGetMaterialFloat for more information.*/
+// ---------------------------------------------------------------------------
+ASSIMP_API C_ENUM aiReturn aiGetMaterialString(const C_STRUCT aiMaterial* pMat,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index,
+    C_STRUCT aiString* pOut);
+
+// ---------------------------------------------------------------------------
+/** Get the number of textures for a particular texture type.
+ *  @param[in] pMat Pointer to the input material. May not be NULL
+ *  @param type Texture type to check for
+ *  @return Number of textures for this type.
+ *  @note A texture can be easily queried using #aiGetMaterialTexture() */
+// ---------------------------------------------------------------------------
+ASSIMP_API unsigned int aiGetMaterialTextureCount(const C_STRUCT aiMaterial* pMat,
+    C_ENUM aiTextureType type);
+
+// ---------------------------------------------------------------------------
+/** @brief Helper function to get all values pertaining to a particular
+ *  texture slot from a material structure.
+ *
+ *  This function is provided just for convenience. You could also read the
+ *  texture by parsing all of its properties manually. This function bundles
+ *  all of them in a huge function monster.
+ *
+ *  @param[in] mat Pointer to the input material. May not be NULL
+ *  @param[in] type Specifies the texture stack to read from (e.g. diffuse,
+ *     specular, height map ...).
+ *  @param[in] index Index of the texture. The function fails if the
+ *     requested index is not available for this texture type.
+ *     #aiGetMaterialTextureCount() can be used to determine the number of
+ *     textures in a particular texture stack.
+ *  @param[out] path Receives the output path
+ *     If the texture is embedded, receives a '*' followed by the id of
+ *     the texture (for the textures stored in the corresponding scene) which
+ *     can be converted to an int using a function like atoi.
+ *     This parameter must be non-null.
+ *  @param mapping The texture mapping mode to be used.
+ *      Pass NULL if you're not interested in this information.
+ *  @param[out] uvindex For UV-mapped textures: receives the index of the UV
+ *      source channel. Unmodified otherwise.
+ *      Pass NULL if you're not interested in this information.
+ *  @param[out] blend Receives the blend factor for the texture
+ *      Pass NULL if you're not interested in this information.
+ *  @param[out] op Receives the texture blend operation to be perform between
+ *      this texture and the previous texture.
+ *      Pass NULL if you're not interested in this information.
+ *  @param[out] mapmode Receives the mapping modes to be used for the texture.
+ *      Pass NULL if you're not interested in this information. Otherwise,
+ *      pass a pointer to an array of two aiTextureMapMode's (one for each
+ *      axis, UV order).
+ *  @param[out] flags Receives the the texture flags.
+ *  @return AI_SUCCESS on success, otherwise something else. Have fun.*/
+// ---------------------------------------------------------------------------
+#ifdef __cplusplus
+ASSIMP_API aiReturn aiGetMaterialTexture(const C_STRUCT aiMaterial* mat,
+    aiTextureType type,
+    unsigned int  index,
+    aiString* path,
+    aiTextureMapping* mapping   = NULL,
+    unsigned int* uvindex       = NULL,
+    ai_real* blend              = NULL,
+    aiTextureOp* op             = NULL,
+    aiTextureMapMode* mapmode   = NULL,
+    unsigned int* flags         = NULL);
+#else
+C_ENUM aiReturn aiGetMaterialTexture(const C_STRUCT aiMaterial* mat,
+    C_ENUM aiTextureType type,
+    unsigned int  index,
+    C_STRUCT aiString* path,
+    C_ENUM aiTextureMapping* mapping    /*= NULL*/,
+    unsigned int* uvindex               /*= NULL*/,
+    ai_real* blend                      /*= NULL*/,
+    C_ENUM aiTextureOp* op              /*= NULL*/,
+    C_ENUM aiTextureMapMode* mapmode    /*= NULL*/,
+    unsigned int* flags                 /*= NULL*/);
+#endif // !#ifdef __cplusplus
+
+#ifdef __cplusplus
+}
+
+#include "material.inl"
+
+#endif //!__cplusplus
+#endif //!!AI_MATERIAL_H_INC
diff --git a/engine/inc/assimp/material.inl b/engine/inc/assimp/material.inl
new file mode 100644
index 00000000..b52b9bef
--- /dev/null
+++ b/engine/inc/assimp/material.inl
@@ -0,0 +1,390 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file material.inl
+ *  @brief Defines the C++ getters for the material system
+ */
+
+#pragma once
+#ifndef AI_MATERIAL_INL_INC
+#define AI_MATERIAL_INL_INC
+
+// ---------------------------------------------------------------------------
+inline aiPropertyTypeInfo ai_real_to_property_type_info(float)
+{
+	return aiPTI_Float;
+}
+
+inline aiPropertyTypeInfo ai_real_to_property_type_info(double)
+{
+	return aiPTI_Double;
+}
+// ---------------------------------------------------------------------------
+
+//! @cond never
+
+// ---------------------------------------------------------------------------
+inline aiReturn aiMaterial::GetTexture( aiTextureType type,
+   unsigned int  index,
+   C_STRUCT aiString* path,
+   aiTextureMapping* mapping    /*= NULL*/,
+   unsigned int* uvindex        /*= NULL*/,
+   ai_real* blend               /*= NULL*/,
+   aiTextureOp* op              /*= NULL*/,
+   aiTextureMapMode* mapmode    /*= NULL*/) const
+{
+    return ::aiGetMaterialTexture(this,type,index,path,mapping,uvindex,blend,op,mapmode);
+}
+
+// ---------------------------------------------------------------------------
+inline unsigned int aiMaterial::GetTextureCount(aiTextureType type) const
+{
+    return ::aiGetMaterialTextureCount(this,type);
+}
+
+// ---------------------------------------------------------------------------
+template <typename Type>
+inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+    unsigned int idx, Type* pOut,
+    unsigned int* pMax) const
+{
+    unsigned int iNum = pMax ? *pMax : 1;
+
+    const aiMaterialProperty* prop;
+    const aiReturn ret = ::aiGetMaterialProperty(this,pKey,type,idx,
+        (const aiMaterialProperty**)&prop);
+    if ( AI_SUCCESS == ret )    {
+
+        if (prop->mDataLength < sizeof(Type)*iNum) {
+            return AI_FAILURE;
+        }
+
+        if (prop->mType != aiPTI_Buffer) {
+            return AI_FAILURE;
+        }
+
+        iNum = std::min((size_t)iNum,prop->mDataLength / sizeof(Type));
+        ::memcpy(pOut,prop->mData,iNum * sizeof(Type));
+        if (pMax) {
+            *pMax = iNum;
+        }
+    }
+    return ret;
+}
+
+// ---------------------------------------------------------------------------
+template <typename Type>
+inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+    unsigned int idx,Type& pOut) const
+{
+    const aiMaterialProperty* prop;
+    const aiReturn ret = ::aiGetMaterialProperty(this,pKey,type,idx,
+        (const aiMaterialProperty**)&prop);
+    if ( AI_SUCCESS == ret )    {
+
+        if (prop->mDataLength < sizeof(Type)) {
+            return AI_FAILURE;
+        }
+
+        if (prop->mType != aiPTI_Buffer) {
+            return AI_FAILURE;
+        }
+
+        ::memcpy(&pOut,prop->mData,sizeof(Type));
+    }
+    return ret;
+}
+
+// ---------------------------------------------------------------------------
+inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+    unsigned int idx,ai_real* pOut,
+    unsigned int* pMax) const
+{
+    return ::aiGetMaterialFloatArray(this,pKey,type,idx,pOut,pMax);
+}
+// ---------------------------------------------------------------------------
+inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+    unsigned int idx,int* pOut,
+    unsigned int* pMax) const
+{
+    return ::aiGetMaterialIntegerArray(this,pKey,type,idx,pOut,pMax);
+}
+// ---------------------------------------------------------------------------
+inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+    unsigned int idx,ai_real& pOut) const
+{
+    return aiGetMaterialFloat(this,pKey,type,idx,&pOut);
+}
+// ---------------------------------------------------------------------------
+inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+    unsigned int idx,int& pOut) const
+{
+    return aiGetMaterialInteger(this,pKey,type,idx,&pOut);
+}
+// ---------------------------------------------------------------------------
+inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+    unsigned int idx,aiColor4D& pOut) const
+{
+    return aiGetMaterialColor(this,pKey,type,idx,&pOut);
+}
+// ---------------------------------------------------------------------------
+inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+    unsigned int idx,aiColor3D& pOut) const
+{
+    aiColor4D c;
+    const aiReturn ret = aiGetMaterialColor(this,pKey,type,idx,&c);
+    pOut = aiColor3D(c.r,c.g,c.b);
+    return ret;
+}
+// ---------------------------------------------------------------------------
+inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+    unsigned int idx,aiString& pOut) const
+{
+    return aiGetMaterialString(this,pKey,type,idx,&pOut);
+}
+// ---------------------------------------------------------------------------
+inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
+    unsigned int idx,aiUVTransform& pOut) const
+{
+    return aiGetMaterialUVTransform(this,pKey,type,idx,&pOut);
+}
+
+
+// ---------------------------------------------------------------------------
+template<class TYPE>
+aiReturn aiMaterial::AddProperty (const TYPE* pInput,
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
+{
+    return AddBinaryProperty((const void*)pInput,
+        pNumValues * sizeof(TYPE),
+        pKey,type,index,aiPTI_Buffer);
+}
+
+// ---------------------------------------------------------------------------
+inline aiReturn aiMaterial::AddProperty(const float* pInput,
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
+{
+    return AddBinaryProperty((const void*)pInput,
+        pNumValues * sizeof(float),
+        pKey,type,index,aiPTI_Float);
+}
+
+// ---------------------------------------------------------------------------
+inline aiReturn aiMaterial::AddProperty(const double* pInput,
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
+{
+    return AddBinaryProperty((const void*)pInput,
+        pNumValues * sizeof(double),
+        pKey,type,index,aiPTI_Double);
+}
+
+// ---------------------------------------------------------------------------
+inline aiReturn aiMaterial::AddProperty(const aiUVTransform* pInput,
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
+{
+    return AddBinaryProperty((const void*)pInput,
+        pNumValues * sizeof(aiUVTransform),
+        pKey,type,index,ai_real_to_property_type_info(pInput->mRotation));
+}
+
+// ---------------------------------------------------------------------------
+inline aiReturn aiMaterial::AddProperty(const aiColor4D* pInput,
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
+{
+    return AddBinaryProperty((const void*)pInput,
+        pNumValues * sizeof(aiColor4D),
+        pKey,type,index,ai_real_to_property_type_info(pInput->a));
+}
+
+// ---------------------------------------------------------------------------
+inline aiReturn aiMaterial::AddProperty(const aiColor3D* pInput,
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
+{
+    return AddBinaryProperty((const void*)pInput,
+        pNumValues * sizeof(aiColor3D),
+        pKey,type,index,ai_real_to_property_type_info(pInput->b));
+}
+
+// ---------------------------------------------------------------------------
+inline aiReturn aiMaterial::AddProperty(const aiVector3D* pInput,
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
+{
+    return AddBinaryProperty((const void*)pInput,
+        pNumValues * sizeof(aiVector3D),
+        pKey,type,index,ai_real_to_property_type_info(pInput->x));
+}
+
+// ---------------------------------------------------------------------------
+inline aiReturn aiMaterial::AddProperty(const int* pInput,
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
+{
+    return AddBinaryProperty((const void*)pInput,
+        pNumValues * sizeof(int),
+        pKey,type,index,aiPTI_Integer);
+}
+
+
+// ---------------------------------------------------------------------------
+// The template specializations below are for backwards compatibility.
+// The recommended way to add material properties is using the non-template
+// overloads.
+// ---------------------------------------------------------------------------
+
+// ---------------------------------------------------------------------------
+template<>
+inline aiReturn aiMaterial::AddProperty<float>(const float* pInput,
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
+{
+    return AddBinaryProperty((const void*)pInput,
+        pNumValues * sizeof(float),
+        pKey,type,index,aiPTI_Float);
+}
+
+// ---------------------------------------------------------------------------
+template<>
+inline aiReturn aiMaterial::AddProperty<double>(const double* pInput,
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
+{
+    return AddBinaryProperty((const void*)pInput,
+        pNumValues * sizeof(double),
+        pKey,type,index,aiPTI_Double);
+}
+
+// ---------------------------------------------------------------------------
+template<>
+inline aiReturn aiMaterial::AddProperty<aiUVTransform>(const aiUVTransform* pInput,
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
+{
+    return AddBinaryProperty((const void*)pInput,
+        pNumValues * sizeof(aiUVTransform),
+        pKey,type,index,aiPTI_Float);
+}
+
+// ---------------------------------------------------------------------------
+template<>
+inline aiReturn aiMaterial::AddProperty<aiColor4D>(const aiColor4D* pInput,
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
+{
+    return AddBinaryProperty((const void*)pInput,
+        pNumValues * sizeof(aiColor4D),
+        pKey,type,index,aiPTI_Float);
+}
+
+// ---------------------------------------------------------------------------
+template<>
+inline aiReturn aiMaterial::AddProperty<aiColor3D>(const aiColor3D* pInput,
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
+{
+    return AddBinaryProperty((const void*)pInput,
+        pNumValues * sizeof(aiColor3D),
+        pKey,type,index,aiPTI_Float);
+}
+
+// ---------------------------------------------------------------------------
+template<>
+inline aiReturn aiMaterial::AddProperty<aiVector3D>(const aiVector3D* pInput,
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
+{
+    return AddBinaryProperty((const void*)pInput,
+        pNumValues * sizeof(aiVector3D),
+        pKey,type,index,aiPTI_Float);
+}
+
+// ---------------------------------------------------------------------------
+template<>
+inline aiReturn aiMaterial::AddProperty<int>(const int* pInput,
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
+{
+    return AddBinaryProperty((const void*)pInput,
+        pNumValues * sizeof(int),
+        pKey,type,index,aiPTI_Integer);
+}
+
+//! @endcond
+
+#endif //! AI_MATERIAL_INL_INC
diff --git a/engine/inc/assimp/matrix3x3.h b/engine/inc/assimp/matrix3x3.h
new file mode 100644
index 00000000..3f50a0bc
--- /dev/null
+++ b/engine/inc/assimp/matrix3x3.h
@@ -0,0 +1,183 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file matrix3x3.h
+ *  @brief Definition of a 3x3 matrix, including operators when compiling in C++
+ */
+#pragma once
+#ifndef AI_MATRIX3X3_H_INC
+#define AI_MATRIX3X3_H_INC
+
+#include "defs.h"
+
+#ifdef __cplusplus
+
+template <typename T> class aiMatrix4x4t;
+template <typename T> class aiVector2t;
+
+// ---------------------------------------------------------------------------
+/** @brief Represents a row-major 3x3 matrix
+ *
+ *  There's much confusion about matrix layouts (column vs. row order).
+ *  This is *always* a row-major matrix. Not even with the
+ *  #aiProcess_ConvertToLeftHanded flag, which absolutely does not affect
+ *  matrix order - it just affects the handedness of the coordinate system
+ *  defined thereby.
+ */
+template <typename TReal>
+class aiMatrix3x3t
+{
+public:
+
+    aiMatrix3x3t () :
+        a1(static_cast<TReal>(1.0f)), a2(), a3(),
+        b1(), b2(static_cast<TReal>(1.0f)), b3(),
+        c1(), c2(), c3(static_cast<TReal>(1.0f)) {}
+
+    aiMatrix3x3t (  TReal _a1, TReal _a2, TReal _a3,
+                    TReal _b1, TReal _b2, TReal _b3,
+                    TReal _c1, TReal _c2, TReal _c3) :
+        a1(_a1), a2(_a2), a3(_a3),
+        b1(_b1), b2(_b2), b3(_b3),
+        c1(_c1), c2(_c2), c3(_c3)
+    {}
+
+public:
+
+    // matrix multiplication.
+    aiMatrix3x3t& operator *= (const aiMatrix3x3t& m);
+    aiMatrix3x3t  operator  * (const aiMatrix3x3t& m) const;
+
+    // array access operators
+    TReal* operator[]       (unsigned int p_iIndex);
+    const TReal* operator[] (unsigned int p_iIndex) const;
+
+    // comparison operators
+    bool operator== (const aiMatrix4x4t<TReal>& m) const;
+    bool operator!= (const aiMatrix4x4t<TReal>& m) const;
+
+    bool Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon = 1e-6) const;
+
+    template <typename TOther>
+    operator aiMatrix3x3t<TOther> () const;
+
+public:
+
+    // -------------------------------------------------------------------
+    /** @brief Construction from a 4x4 matrix. The remaining parts
+     *  of the matrix are ignored.
+     */
+    explicit aiMatrix3x3t( const aiMatrix4x4t<TReal>& pMatrix);
+
+    // -------------------------------------------------------------------
+    /** @brief Transpose the matrix
+     */
+    aiMatrix3x3t& Transpose();
+
+    // -------------------------------------------------------------------
+    /** @brief Invert the matrix.
+     *  If the matrix is not invertible all elements are set to qnan.
+     *  Beware, use (f != f) to check whether a TReal f is qnan.
+     */
+    aiMatrix3x3t& Inverse();
+    TReal Determinant() const;
+
+public:
+    // -------------------------------------------------------------------
+    /** @brief Returns a rotation matrix for a rotation around z
+     *  @param a Rotation angle, in radians
+     *  @param out Receives the output matrix
+     *  @return Reference to the output matrix
+     */
+    static aiMatrix3x3t& RotationZ(TReal a, aiMatrix3x3t& out);
+
+    // -------------------------------------------------------------------
+    /** @brief Returns a rotation matrix for a rotation around
+     *    an arbitrary axis.
+     *
+     *  @param a Rotation angle, in radians
+     *  @param axis Axis to rotate around
+     *  @param out To be filled
+     */
+    static aiMatrix3x3t& Rotation( TReal a,
+        const aiVector3t<TReal>& axis, aiMatrix3x3t& out);
+
+    // -------------------------------------------------------------------
+    /** @brief Returns a translation matrix
+     *  @param v Translation vector
+     *  @param out Receives the output matrix
+     *  @return Reference to the output matrix
+     */
+    static aiMatrix3x3t& Translation( const aiVector2t<TReal>& v, aiMatrix3x3t& out);
+
+    // -------------------------------------------------------------------
+    /** @brief A function for creating a rotation matrix that rotates a
+     *  vector called "from" into another vector called "to".
+     * Input : from[3], to[3] which both must be *normalized* non-zero vectors
+     * Output: mtx[3][3] -- a 3x3 matrix in column-major form
+     * Authors: Tomas Möller, John Hughes
+     *          "Efficiently Building a Matrix to Rotate One Vector to Another"
+     *          Journal of Graphics Tools, 4(4):1-4, 1999
+     */
+    static aiMatrix3x3t& FromToMatrix(const aiVector3t<TReal>& from,
+        const aiVector3t<TReal>& to, aiMatrix3x3t& out);
+
+public:
+    TReal a1, a2, a3;
+    TReal b1, b2, b3;
+    TReal c1, c2, c3;
+};
+
+typedef aiMatrix3x3t<ai_real> aiMatrix3x3;
+
+#else
+
+struct aiMatrix3x3 {
+    ai_real a1, a2, a3;
+    ai_real b1, b2, b3;
+    ai_real c1, c2, c3;
+};
+
+#endif // __cplusplus
+
+#endif // AI_MATRIX3X3_H_INC
diff --git a/engine/inc/assimp/matrix3x3.inl b/engine/inc/assimp/matrix3x3.inl
new file mode 100644
index 00000000..ab2cc410
--- /dev/null
+++ b/engine/inc/assimp/matrix3x3.inl
@@ -0,0 +1,357 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file matrix3x3.inl
+ *  @brief Inline implementation of the 3x3 matrix operators
+ */
+#pragma once
+#ifndef AI_MATRIX3X3_INL_INC
+#define AI_MATRIX3X3_INL_INC
+
+#ifdef __cplusplus
+#include "matrix3x3.h"
+
+#include "matrix4x4.h"
+#include <algorithm>
+#include <cmath>
+#include <limits>
+
+// ------------------------------------------------------------------------------------------------
+// Construction from a 4x4 matrix. The remaining parts of the matrix are ignored.
+template <typename TReal>
+inline aiMatrix3x3t<TReal>::aiMatrix3x3t( const aiMatrix4x4t<TReal>& pMatrix)
+{
+    a1 = pMatrix.a1; a2 = pMatrix.a2; a3 = pMatrix.a3;
+    b1 = pMatrix.b1; b2 = pMatrix.b2; b3 = pMatrix.b3;
+    c1 = pMatrix.c1; c2 = pMatrix.c2; c3 = pMatrix.c3;
+}
+
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::operator *= (const aiMatrix3x3t<TReal>& m)
+{
+    *this = aiMatrix3x3t<TReal>(m.a1 * a1 + m.b1 * a2 + m.c1 * a3,
+        m.a2 * a1 + m.b2 * a2 + m.c2 * a3,
+        m.a3 * a1 + m.b3 * a2 + m.c3 * a3,
+        m.a1 * b1 + m.b1 * b2 + m.c1 * b3,
+        m.a2 * b1 + m.b2 * b2 + m.c2 * b3,
+        m.a3 * b1 + m.b3 * b2 + m.c3 * b3,
+        m.a1 * c1 + m.b1 * c2 + m.c1 * c3,
+        m.a2 * c1 + m.b2 * c2 + m.c2 * c3,
+        m.a3 * c1 + m.b3 * c2 + m.c3 * c3);
+    return *this;
+}
+
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+template <typename TOther>
+aiMatrix3x3t<TReal>::operator aiMatrix3x3t<TOther> () const
+{
+    return aiMatrix3x3t<TOther>(static_cast<TOther>(a1),static_cast<TOther>(a2),static_cast<TOther>(a3),
+        static_cast<TOther>(b1),static_cast<TOther>(b2),static_cast<TOther>(b3),
+        static_cast<TOther>(c1),static_cast<TOther>(c2),static_cast<TOther>(c3));
+}
+
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+inline aiMatrix3x3t<TReal> aiMatrix3x3t<TReal>::operator* (const aiMatrix3x3t<TReal>& m) const
+{
+    aiMatrix3x3t<TReal> temp( *this);
+    temp *= m;
+    return temp;
+}
+
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+inline TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex) {
+    switch ( p_iIndex ) {
+        case 0:
+            return &a1;
+        case 1:
+            return &b1;
+        case 2:
+            return &c1;
+        default:
+            break;
+    }
+    return &a1;
+}
+
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+inline const TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex) const {
+    switch ( p_iIndex ) {
+        case 0:
+            return &a1;
+        case 1:
+            return &b1;
+        case 2:
+            return &c1;
+        default:
+            break;
+    }
+    return &a1;
+}
+
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+inline bool aiMatrix3x3t<TReal>::operator== (const aiMatrix4x4t<TReal>& m) const
+{
+    return a1 == m.a1 && a2 == m.a2 && a3 == m.a3 &&
+           b1 == m.b1 && b2 == m.b2 && b3 == m.b3 &&
+           c1 == m.c1 && c2 == m.c2 && c3 == m.c3;
+}
+
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+inline bool aiMatrix3x3t<TReal>::operator!= (const aiMatrix4x4t<TReal>& m) const
+{
+    return !(*this == m);
+}
+
+// ---------------------------------------------------------------------------
+template<typename TReal>
+inline bool aiMatrix3x3t<TReal>::Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon) const {
+    return
+        std::abs(a1 - m.a1) <= epsilon &&
+        std::abs(a2 - m.a2) <= epsilon &&
+        std::abs(a3 - m.a3) <= epsilon &&
+        std::abs(b1 - m.b1) <= epsilon &&
+        std::abs(b2 - m.b2) <= epsilon &&
+        std::abs(b3 - m.b3) <= epsilon &&
+        std::abs(c1 - m.c1) <= epsilon &&
+        std::abs(c2 - m.c2) <= epsilon &&
+        std::abs(c3 - m.c3) <= epsilon;
+}
+
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Transpose()
+{
+    // (TReal&) don't remove, GCC complains cause of packed fields
+    std::swap( (TReal&)a2, (TReal&)b1);
+    std::swap( (TReal&)a3, (TReal&)c1);
+    std::swap( (TReal&)b3, (TReal&)c2);
+    return *this;
+}
+
+// ----------------------------------------------------------------------------------------
+template <typename TReal>
+inline TReal aiMatrix3x3t<TReal>::Determinant() const
+{
+    return a1*b2*c3 - a1*b3*c2 + a2*b3*c1 - a2*b1*c3 + a3*b1*c2 - a3*b2*c1;
+}
+
+// ----------------------------------------------------------------------------------------
+template <typename TReal>
+inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Inverse()
+{
+    // Compute the reciprocal determinant
+    TReal det = Determinant();
+    if(det == static_cast<TReal>(0.0))
+    {
+        // Matrix not invertible. Setting all elements to nan is not really
+        // correct in a mathematical sense; but at least qnans are easy to
+        // spot. XXX we might throw an exception instead, which would
+        // be even much better to spot :/.
+        const TReal nan = std::numeric_limits<TReal>::quiet_NaN();
+        *this = aiMatrix3x3t<TReal>( nan,nan,nan,nan,nan,nan,nan,nan,nan);
+
+        return *this;
+    }
+
+    TReal invdet = static_cast<TReal>(1.0) / det;
+
+    aiMatrix3x3t<TReal> res;
+    res.a1 = invdet  * (b2 * c3 - b3 * c2);
+    res.a2 = -invdet * (a2 * c3 - a3 * c2);
+    res.a3 = invdet  * (a2 * b3 - a3 * b2);
+    res.b1 = -invdet * (b1 * c3 - b3 * c1);
+    res.b2 = invdet  * (a1 * c3 - a3 * c1);
+    res.b3 = -invdet * (a1 * b3 - a3 * b1);
+    res.c1 = invdet  * (b1 * c2 - b2 * c1);
+    res.c2 = -invdet * (a1 * c2 - a2 * c1);
+    res.c3 = invdet  * (a1 * b2 - a2 * b1);
+    *this = res;
+
+    return *this;
+}
+
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::RotationZ(TReal a, aiMatrix3x3t<TReal>& out)
+{
+    out.a1 = out.b2 = std::cos(a);
+    out.b1 = std::sin(a);
+    out.a2 = - out.b1;
+
+    out.a3 = out.b3 = out.c1 = out.c2 = 0.f;
+    out.c3 = 1.f;
+
+    return out;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Returns a rotation matrix for a rotation around an arbitrary axis.
+template <typename TReal>
+inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Rotation( TReal a, const aiVector3t<TReal>& axis, aiMatrix3x3t<TReal>& out)
+{
+  TReal c = std::cos( a), s = std::sin( a), t = 1 - c;
+  TReal x = axis.x, y = axis.y, z = axis.z;
+
+  // Many thanks to MathWorld and Wikipedia
+  out.a1 = t*x*x + c;   out.a2 = t*x*y - s*z; out.a3 = t*x*z + s*y;
+  out.b1 = t*x*y + s*z; out.b2 = t*y*y + c;   out.b3 = t*y*z - s*x;
+  out.c1 = t*x*z - s*y; out.c2 = t*y*z + s*x; out.c3 = t*z*z + c;
+
+  return out;
+}
+
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Translation( const aiVector2t<TReal>& v, aiMatrix3x3t<TReal>& out)
+{
+    out = aiMatrix3x3t<TReal>();
+    out.a3 = v.x;
+    out.b3 = v.y;
+    return out;
+}
+
+// ----------------------------------------------------------------------------------------
+/** A function for creating a rotation matrix that rotates a vector called
+ * "from" into another vector called "to".
+ * Input : from[3], to[3] which both must be *normalized* non-zero vectors
+ * Output: mtx[3][3] -- a 3x3 matrix in colum-major form
+ * Authors: Tomas Möller, John Hughes
+ *          "Efficiently Building a Matrix to Rotate One Vector to Another"
+ *          Journal of Graphics Tools, 4(4):1-4, 1999
+ */
+// ----------------------------------------------------------------------------------------
+template <typename TReal>
+inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::FromToMatrix(const aiVector3t<TReal>& from,
+    const aiVector3t<TReal>& to, aiMatrix3x3t<TReal>& mtx)
+{
+    const TReal e = from * to;
+    const TReal f = (e < 0)? -e:e;
+
+    if (f > static_cast<TReal>(1.0) - static_cast<TReal>(0.00001))     /* "from" and "to"-vector almost parallel */
+    {
+        aiVector3D u,v;     /* temporary storage vectors */
+        aiVector3D x;       /* vector most nearly orthogonal to "from" */
+
+        x.x = (from.x > 0.0)? from.x : -from.x;
+        x.y = (from.y > 0.0)? from.y : -from.y;
+        x.z = (from.z > 0.0)? from.z : -from.z;
+
+        if (x.x < x.y)
+        {
+            if (x.x < x.z)
+            {
+                x.x = static_cast<TReal>(1.0);
+                x.y = x.z = static_cast<TReal>(0.0);
+            }
+            else
+            {
+                x.z = static_cast<TReal>(1.0);
+                x.x = x.y = static_cast<TReal>(0.0);
+            }
+        }
+        else
+        {
+            if (x.y < x.z)
+            {
+                x.y = static_cast<TReal>(1.0);
+                x.x = x.z = static_cast<TReal>(0.0);
+            }
+            else
+            {
+                x.z = static_cast<TReal>(1.0);
+                x.x = x.y = static_cast<TReal>(0.0);
+            }
+        }
+
+        u.x = x.x - from.x; u.y = x.y - from.y; u.z = x.z - from.z;
+        v.x = x.x - to.x;   v.y = x.y - to.y;   v.z = x.z - to.z;
+
+        const TReal c1_ = static_cast<TReal>(2.0) / (u * u);
+        const TReal c2_ = static_cast<TReal>(2.0) / (v * v);
+        const TReal c3_ = c1_ * c2_  * (u * v);
+
+        for (unsigned int i = 0; i < 3; i++)
+        {
+            for (unsigned int j = 0; j < 3; j++)
+            {
+                mtx[i][j] =  - c1_ * u[i] * u[j] - c2_ * v[i] * v[j]
+                    + c3_ * v[i] * u[j];
+            }
+            mtx[i][i] += static_cast<TReal>(1.0);
+        }
+    }
+    else  /* the most common case, unless "from"="to", or "from"=-"to" */
+    {
+        const aiVector3D v = from ^ to;
+        /* ... use this hand optimized version (9 mults less) */
+        const TReal h = static_cast<TReal>(1.0)/(static_cast<TReal>(1.0) + e);      /* optimization by Gottfried Chen */
+        const TReal hvx = h * v.x;
+        const TReal hvz = h * v.z;
+        const TReal hvxy = hvx * v.y;
+        const TReal hvxz = hvx * v.z;
+        const TReal hvyz = hvz * v.y;
+        mtx[0][0] = e + hvx * v.x;
+        mtx[0][1] = hvxy - v.z;
+        mtx[0][2] = hvxz + v.y;
+
+        mtx[1][0] = hvxy + v.z;
+        mtx[1][1] = e + h * v.y * v.y;
+        mtx[1][2] = hvyz - v.x;
+
+        mtx[2][0] = hvxz - v.y;
+        mtx[2][1] = hvyz + v.x;
+        mtx[2][2] = e + hvz * v.z;
+    }
+    return mtx;
+}
+
+
+#endif // __cplusplus
+#endif // AI_MATRIX3X3_INL_INC
diff --git a/engine/inc/assimp/matrix4x4.h b/engine/inc/assimp/matrix4x4.h
new file mode 100644
index 00000000..85105031
--- /dev/null
+++ b/engine/inc/assimp/matrix4x4.h
@@ -0,0 +1,280 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+/** @file matrix4x4.h
+ *  @brief 4x4 matrix structure, including operators when compiling in C++
+ */
+#pragma once
+#ifndef AI_MATRIX4X4_H_INC
+#define AI_MATRIX4X4_H_INC
+
+#include "vector3.h"
+#include "defs.h"
+
+#ifdef __cplusplus
+
+template<typename TReal> class aiMatrix3x3t;
+template<typename TReal> class aiQuaterniont;
+
+// ---------------------------------------------------------------------------
+/** @brief Represents a row-major 4x4 matrix, use this for homogeneous
+ *   coordinates.
+ *
+ *  There's much confusion about matrix layouts (column vs. row order).
+ *  This is *always* a row-major matrix. Not even with the
+ *  #aiProcess_ConvertToLeftHanded flag, which absolutely does not affect
+ *  matrix order - it just affects the handedness of the coordinate system
+ *  defined thereby.
+ */
+template<typename TReal>
+class aiMatrix4x4t
+{
+public:
+
+    /** set to identity */
+    aiMatrix4x4t ();
+
+    /** construction from single values */
+    aiMatrix4x4t (  TReal _a1, TReal _a2, TReal _a3, TReal _a4,
+                    TReal _b1, TReal _b2, TReal _b3, TReal _b4,
+                    TReal _c1, TReal _c2, TReal _c3, TReal _c4,
+                    TReal _d1, TReal _d2, TReal _d3, TReal _d4);
+
+
+    /** construction from 3x3 matrix, remaining elements are set to identity */
+    explicit aiMatrix4x4t( const aiMatrix3x3t<TReal>& m);
+
+    /** construction from position, rotation and scaling components
+     * @param scaling The scaling for the x,y,z axes
+     * @param rotation The rotation as a hamilton quaternion
+     * @param position The position for the x,y,z axes
+     */
+    aiMatrix4x4t(const aiVector3t<TReal>& scaling, const aiQuaterniont<TReal>& rotation,
+        const aiVector3t<TReal>& position);
+
+public:
+
+    // array access operators
+	/** @fn TReal* operator[] (unsigned int p_iIndex)
+	 *  @param [in] p_iIndex - index of the row.
+	 *  @return pointer to pointed row.
+	 */
+    TReal* operator[]       (unsigned int p_iIndex);
+
+	/** @fn const TReal* operator[] (unsigned int p_iIndex) const
+	 *  @overload TReal* operator[] (unsigned int p_iIndex)
+	 */
+    const TReal* operator[] (unsigned int p_iIndex) const;
+
+    // comparison operators
+    bool operator== (const aiMatrix4x4t& m) const;
+    bool operator!= (const aiMatrix4x4t& m) const;
+
+    bool Equal(const aiMatrix4x4t& m, TReal epsilon = 1e-6) const;
+
+    // matrix multiplication.
+    aiMatrix4x4t& operator *= (const aiMatrix4x4t& m);
+    aiMatrix4x4t  operator *  (const aiMatrix4x4t& m) const;
+    aiMatrix4x4t operator * (const TReal& aFloat) const;
+    aiMatrix4x4t operator + (const aiMatrix4x4t& aMatrix) const;
+
+    template <typename TOther>
+    operator aiMatrix4x4t<TOther> () const;
+
+public:
+
+    // -------------------------------------------------------------------
+    /** @brief Transpose the matrix */
+    aiMatrix4x4t& Transpose();
+
+    // -------------------------------------------------------------------
+    /** @brief Invert the matrix.
+     *  If the matrix is not invertible all elements are set to qnan.
+     *  Beware, use (f != f) to check whether a TReal f is qnan.
+     */
+    aiMatrix4x4t& Inverse();
+    TReal Determinant() const;
+
+
+    // -------------------------------------------------------------------
+    /** @brief Returns true of the matrix is the identity matrix.
+     *  The check is performed against a not so small epsilon.
+     */
+    inline bool IsIdentity() const;
+
+    // -------------------------------------------------------------------
+    /** @brief Decompose a trafo matrix into its original components
+     *  @param scaling Receives the output scaling for the x,y,z axes
+     *  @param rotation Receives the output rotation as a hamilton
+     *   quaternion
+     *  @param position Receives the output position for the x,y,z axes
+     */
+    void Decompose (aiVector3t<TReal>& scaling, aiQuaterniont<TReal>& rotation,
+        aiVector3t<TReal>& position) const;
+
+	// -------------------------------------------------------------------
+	/** @fn void Decompose(aiVector3t<TReal>& pScaling, aiVector3t<TReal>& pRotation, aiVector3t<TReal>& pPosition) const
+     *  @brief Decompose a trafo matrix into its original components.
+     * Thx to good FAQ at http://www.gamedev.ru/code/articles/faq_matrix_quat
+     *  @param [out] pScaling - Receives the output scaling for the x,y,z axes.
+     *  @param [out] pRotation - Receives the output rotation as a Euler angles.
+     *  @param [out] pPosition - Receives the output position for the x,y,z axes.
+     */
+    void Decompose(aiVector3t<TReal>& pScaling, aiVector3t<TReal>& pRotation, aiVector3t<TReal>& pPosition) const;
+
+	// -------------------------------------------------------------------
+	/** @fn void Decompose(aiVector3t<TReal>& pScaling, aiVector3t<TReal>& pRotationAxis, TReal& pRotationAngle, aiVector3t<TReal>& pPosition) const
+     *  @brief Decompose a trafo matrix into its original components
+	 * Thx to good FAQ at http://www.gamedev.ru/code/articles/faq_matrix_quat
+     *  @param [out] pScaling - Receives the output scaling for the x,y,z axes.
+     *  @param [out] pRotationAxis - Receives the output rotation axis.
+	 *  @param [out] pRotationAngle - Receives the output rotation angle for @ref pRotationAxis.
+     *  @param [out] pPosition - Receives the output position for the x,y,z axes.
+     */
+    void Decompose(aiVector3t<TReal>& pScaling, aiVector3t<TReal>& pRotationAxis, TReal& pRotationAngle, aiVector3t<TReal>& pPosition) const;
+
+    // -------------------------------------------------------------------
+    /** @brief Decompose a trafo matrix with no scaling into its
+     *    original components
+     *  @param rotation Receives the output rotation as a hamilton
+     *    quaternion
+     *  @param position Receives the output position for the x,y,z axes
+     */
+    void DecomposeNoScaling (aiQuaterniont<TReal>& rotation,
+        aiVector3t<TReal>& position) const;
+
+
+    // -------------------------------------------------------------------
+    /** @brief Creates a trafo matrix from a set of euler angles
+     *  @param x Rotation angle for the x-axis, in radians
+     *  @param y Rotation angle for the y-axis, in radians
+     *  @param z Rotation angle for the z-axis, in radians
+     */
+    aiMatrix4x4t& FromEulerAnglesXYZ(TReal x, TReal y, TReal z);
+    aiMatrix4x4t& FromEulerAnglesXYZ(const aiVector3t<TReal>& blubb);
+
+public:
+    // -------------------------------------------------------------------
+    /** @brief Returns a rotation matrix for a rotation around the x axis
+     *  @param a Rotation angle, in radians
+     *  @param out Receives the output matrix
+     *  @return Reference to the output matrix
+     */
+    static aiMatrix4x4t& RotationX(TReal a, aiMatrix4x4t& out);
+
+    // -------------------------------------------------------------------
+    /** @brief Returns a rotation matrix for a rotation around the y axis
+     *  @param a Rotation angle, in radians
+     *  @param out Receives the output matrix
+     *  @return Reference to the output matrix
+     */
+    static aiMatrix4x4t& RotationY(TReal a, aiMatrix4x4t& out);
+
+    // -------------------------------------------------------------------
+    /** @brief Returns a rotation matrix for a rotation around the z axis
+     *  @param a Rotation angle, in radians
+     *  @param out Receives the output matrix
+     *  @return Reference to the output matrix
+     */
+    static aiMatrix4x4t& RotationZ(TReal a, aiMatrix4x4t& out);
+
+    // -------------------------------------------------------------------
+    /** Returns a rotation matrix for a rotation around an arbitrary axis.
+     *  @param a Rotation angle, in radians
+     *  @param axis Rotation axis, should be a normalized vector.
+     *  @param out Receives the output matrix
+     *  @return Reference to the output matrix
+     */
+    static aiMatrix4x4t& Rotation(TReal a, const aiVector3t<TReal>& axis,
+            aiMatrix4x4t& out);
+
+    // -------------------------------------------------------------------
+    /** @brief Returns a translation matrix
+     *  @param v Translation vector
+     *  @param out Receives the output matrix
+     *  @return Reference to the output matrix
+     */
+    static aiMatrix4x4t& Translation( const aiVector3t<TReal>& v, 
+            aiMatrix4x4t& out);
+
+    // -------------------------------------------------------------------
+    /** @brief Returns a scaling matrix
+     *  @param v Scaling vector
+     *  @param out Receives the output matrix
+     *  @return Reference to the output matrix
+     */
+    static aiMatrix4x4t& Scaling( const aiVector3t<TReal>& v, aiMatrix4x4t& out);
+
+    // -------------------------------------------------------------------
+    /** @brief A function for creating a rotation matrix that rotates a
+     *  vector called "from" into another vector called "to".
+     * Input : from[3], to[3] which both must be *normalized* non-zero vectors
+     * Output: mtx[3][3] -- a 3x3 matrix in column-major form
+     * Authors: Tomas Mueller, John Hughes
+     *          "Efficiently Building a Matrix to Rotate One Vector to Another"
+     *          Journal of Graphics Tools, 4(4):1-4, 1999
+     */
+    static aiMatrix4x4t& FromToMatrix(const aiVector3t<TReal>& from,
+            const aiVector3t<TReal>& to, aiMatrix4x4t& out);
+
+public:
+    TReal a1, a2, a3, a4;
+    TReal b1, b2, b3, b4;
+    TReal c1, c2, c3, c4;
+    TReal d1, d2, d3, d4;
+};
+
+typedef aiMatrix4x4t<ai_real> aiMatrix4x4;
+
+#else
+
+struct aiMatrix4x4 {
+    ai_real a1, a2, a3, a4;
+    ai_real b1, b2, b3, b4;
+    ai_real c1, c2, c3, c4;
+    ai_real d1, d2, d3, d4;
+};
+
+
+#endif // __cplusplus
+
+#endif // AI_MATRIX4X4_H_INC
diff --git a/engine/inc/assimp/matrix4x4.inl b/engine/inc/assimp/matrix4x4.inl
new file mode 100644
index 00000000..6f96d5a6
--- /dev/null
+++ b/engine/inc/assimp/matrix4x4.inl
@@ -0,0 +1,688 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file matrix4x4.inl
+ *  @brief Inline implementation of the 4x4 matrix operators
+ */
+#pragma once
+#ifndef AI_MATRIX4X4_INL_INC
+#define AI_MATRIX4X4_INL_INC
+
+#ifdef __cplusplus
+
+#include "matrix4x4.h"
+#include "matrix3x3.h"
+#include "quaternion.h"
+
+#include <algorithm>
+#include <limits>
+#include <cmath>
+
+// ----------------------------------------------------------------------------------------
+template <typename TReal>
+aiMatrix4x4t<TReal> ::aiMatrix4x4t () :
+    a1(1.0f), a2(), a3(), a4(),
+    b1(), b2(1.0f), b3(), b4(),
+    c1(), c2(), c3(1.0f), c4(),
+    d1(), d2(), d3(), d4(1.0f)
+{
+
+}
+
+// ----------------------------------------------------------------------------------------
+template <typename TReal>
+aiMatrix4x4t<TReal> ::aiMatrix4x4t (TReal _a1, TReal _a2, TReal _a3, TReal _a4,
+              TReal _b1, TReal _b2, TReal _b3, TReal _b4,
+              TReal _c1, TReal _c2, TReal _c3, TReal _c4,
+              TReal _d1, TReal _d2, TReal _d3, TReal _d4) :
+    a1(_a1), a2(_a2), a3(_a3), a4(_a4),
+    b1(_b1), b2(_b2), b3(_b3), b4(_b4),
+    c1(_c1), c2(_c2), c3(_c3), c4(_c4),
+    d1(_d1), d2(_d2), d3(_d3), d4(_d4)
+{
+
+}
+
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+template <typename TOther>
+aiMatrix4x4t<TReal>::operator aiMatrix4x4t<TOther> () const
+{
+    return aiMatrix4x4t<TOther>(static_cast<TOther>(a1),static_cast<TOther>(a2),static_cast<TOther>(a3),static_cast<TOther>(a4),
+        static_cast<TOther>(b1),static_cast<TOther>(b2),static_cast<TOther>(b3),static_cast<TOther>(b4),
+        static_cast<TOther>(c1),static_cast<TOther>(c2),static_cast<TOther>(c3),static_cast<TOther>(c4),
+        static_cast<TOther>(d1),static_cast<TOther>(d2),static_cast<TOther>(d3),static_cast<TOther>(d4));
+}
+
+
+// ----------------------------------------------------------------------------------------
+template <typename TReal>
+inline aiMatrix4x4t<TReal>::aiMatrix4x4t (const aiMatrix3x3t<TReal>& m)
+{
+    a1 = m.a1; a2 = m.a2; a3 = m.a3; a4 = static_cast<TReal>(0.0);
+    b1 = m.b1; b2 = m.b2; b3 = m.b3; b4 = static_cast<TReal>(0.0);
+    c1 = m.c1; c2 = m.c2; c3 = m.c3; c4 = static_cast<TReal>(0.0);
+    d1 = static_cast<TReal>(0.0); d2 = static_cast<TReal>(0.0); d3 = static_cast<TReal>(0.0); d4 = static_cast<TReal>(1.0);
+}
+
+// ----------------------------------------------------------------------------------------
+template <typename TReal>
+inline aiMatrix4x4t<TReal>::aiMatrix4x4t (const aiVector3t<TReal>& scaling, const aiQuaterniont<TReal>& rotation, const aiVector3t<TReal>& position)
+{
+    // build a 3x3 rotation matrix
+    aiMatrix3x3t<TReal> m = rotation.GetMatrix();
+
+    a1 = m.a1 * scaling.x;
+    a2 = m.a2 * scaling.x;
+    a3 = m.a3 * scaling.x;
+    a4 = position.x;
+
+    b1 = m.b1 * scaling.y;
+    b2 = m.b2 * scaling.y;
+    b3 = m.b3 * scaling.y;
+    b4 = position.y;
+
+    c1 = m.c1 * scaling.z;
+    c2 = m.c2 * scaling.z;
+    c3 = m.c3 * scaling.z;
+    c4= position.z;
+
+    d1 = static_cast<TReal>(0.0);
+    d2 = static_cast<TReal>(0.0);
+    d3 = static_cast<TReal>(0.0);
+    d4 = static_cast<TReal>(1.0);
+}
+
+// ----------------------------------------------------------------------------------------
+template <typename TReal>
+inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::operator *= (const aiMatrix4x4t<TReal>& m)
+{
+    *this = aiMatrix4x4t<TReal>(
+        m.a1 * a1 + m.b1 * a2 + m.c1 * a3 + m.d1 * a4,
+        m.a2 * a1 + m.b2 * a2 + m.c2 * a3 + m.d2 * a4,
+        m.a3 * a1 + m.b3 * a2 + m.c3 * a3 + m.d3 * a4,
+        m.a4 * a1 + m.b4 * a2 + m.c4 * a3 + m.d4 * a4,
+        m.a1 * b1 + m.b1 * b2 + m.c1 * b3 + m.d1 * b4,
+        m.a2 * b1 + m.b2 * b2 + m.c2 * b3 + m.d2 * b4,
+        m.a3 * b1 + m.b3 * b2 + m.c3 * b3 + m.d3 * b4,
+        m.a4 * b1 + m.b4 * b2 + m.c4 * b3 + m.d4 * b4,
+        m.a1 * c1 + m.b1 * c2 + m.c1 * c3 + m.d1 * c4,
+        m.a2 * c1 + m.b2 * c2 + m.c2 * c3 + m.d2 * c4,
+        m.a3 * c1 + m.b3 * c2 + m.c3 * c3 + m.d3 * c4,
+        m.a4 * c1 + m.b4 * c2 + m.c4 * c3 + m.d4 * c4,
+        m.a1 * d1 + m.b1 * d2 + m.c1 * d3 + m.d1 * d4,
+        m.a2 * d1 + m.b2 * d2 + m.c2 * d3 + m.d2 * d4,
+        m.a3 * d1 + m.b3 * d2 + m.c3 * d3 + m.d3 * d4,
+        m.a4 * d1 + m.b4 * d2 + m.c4 * d3 + m.d4 * d4);
+    return *this;
+}
+
+// ----------------------------------------------------------------------------------------
+template <typename TReal>
+inline aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator* (const TReal& aFloat) const
+{
+    aiMatrix4x4t<TReal> temp(
+        a1 * aFloat,
+        a2 * aFloat,
+        a3 * aFloat,
+        a4 * aFloat,
+        b1 * aFloat,
+        b2 * aFloat,
+        b3 * aFloat,
+        b4 * aFloat,
+        c1 * aFloat,
+        c2 * aFloat,
+        c3 * aFloat,
+        c4 * aFloat,
+        d1 * aFloat,
+        d2 * aFloat,
+        d3 * aFloat,
+        d4 * aFloat);
+    return temp;
+}
+
+// ----------------------------------------------------------------------------------------
+template <typename TReal>
+inline aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator+ (const aiMatrix4x4t<TReal>& m) const
+{
+    aiMatrix4x4t<TReal> temp(
+        m.a1 + a1,
+        m.a2 + a2,
+        m.a3 + a3,
+        m.a4 + a4,
+        m.b1 + b1,
+        m.b2 + b2,
+        m.b3 + b3,
+        m.b4 + b4,
+        m.c1 + c1,
+        m.c2 + c2,
+        m.c3 + c3,
+        m.c4 + c4,
+        m.d1 + d1,
+        m.d2 + d2,
+        m.d3 + d3,
+        m.d4 + d4);
+    return temp;
+}
+
+// ----------------------------------------------------------------------------------------
+template <typename TReal>
+inline aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator* (const aiMatrix4x4t<TReal>& m) const
+{
+    aiMatrix4x4t<TReal> temp( *this);
+    temp *= m;
+    return temp;
+}
+
+
+// ----------------------------------------------------------------------------------------
+template <typename TReal>
+inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Transpose()
+{
+    // (TReal&) don't remove, GCC complains cause of packed fields
+    std::swap( (TReal&)b1, (TReal&)a2);
+    std::swap( (TReal&)c1, (TReal&)a3);
+    std::swap( (TReal&)c2, (TReal&)b3);
+    std::swap( (TReal&)d1, (TReal&)a4);
+    std::swap( (TReal&)d2, (TReal&)b4);
+    std::swap( (TReal&)d3, (TReal&)c4);
+    return *this;
+}
+
+
+// ----------------------------------------------------------------------------------------
+template <typename TReal>
+inline TReal aiMatrix4x4t<TReal>::Determinant() const
+{
+    return a1*b2*c3*d4 - a1*b2*c4*d3 + a1*b3*c4*d2 - a1*b3*c2*d4
+        + a1*b4*c2*d3 - a1*b4*c3*d2 - a2*b3*c4*d1 + a2*b3*c1*d4
+        - a2*b4*c1*d3 + a2*b4*c3*d1 - a2*b1*c3*d4 + a2*b1*c4*d3
+        + a3*b4*c1*d2 - a3*b4*c2*d1 + a3*b1*c2*d4 - a3*b1*c4*d2
+        + a3*b2*c4*d1 - a3*b2*c1*d4 - a4*b1*c2*d3 + a4*b1*c3*d2
+        - a4*b2*c3*d1 + a4*b2*c1*d3 - a4*b3*c1*d2 + a4*b3*c2*d1;
+}
+
+// ----------------------------------------------------------------------------------------
+template <typename TReal>
+inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Inverse()
+{
+    // Compute the reciprocal determinant
+    const TReal det = Determinant();
+    if(det == static_cast<TReal>(0.0))
+    {
+        // Matrix not invertible. Setting all elements to nan is not really
+        // correct in a mathematical sense but it is easy to debug for the
+        // programmer.
+        const TReal nan = std::numeric_limits<TReal>::quiet_NaN();
+        *this = aiMatrix4x4t<TReal>(
+            nan,nan,nan,nan,
+            nan,nan,nan,nan,
+            nan,nan,nan,nan,
+            nan,nan,nan,nan);
+
+        return *this;
+    }
+
+    const TReal invdet = static_cast<TReal>(1.0) / det;
+
+    aiMatrix4x4t<TReal> res;
+    res.a1 = invdet  * (b2 * (c3 * d4 - c4 * d3) + b3 * (c4 * d2 - c2 * d4) + b4 * (c2 * d3 - c3 * d2));
+    res.a2 = -invdet * (a2 * (c3 * d4 - c4 * d3) + a3 * (c4 * d2 - c2 * d4) + a4 * (c2 * d3 - c3 * d2));
+    res.a3 = invdet  * (a2 * (b3 * d4 - b4 * d3) + a3 * (b4 * d2 - b2 * d4) + a4 * (b2 * d3 - b3 * d2));
+    res.a4 = -invdet * (a2 * (b3 * c4 - b4 * c3) + a3 * (b4 * c2 - b2 * c4) + a4 * (b2 * c3 - b3 * c2));
+    res.b1 = -invdet * (b1 * (c3 * d4 - c4 * d3) + b3 * (c4 * d1 - c1 * d4) + b4 * (c1 * d3 - c3 * d1));
+    res.b2 = invdet  * (a1 * (c3 * d4 - c4 * d3) + a3 * (c4 * d1 - c1 * d4) + a4 * (c1 * d3 - c3 * d1));
+    res.b3 = -invdet * (a1 * (b3 * d4 - b4 * d3) + a3 * (b4 * d1 - b1 * d4) + a4 * (b1 * d3 - b3 * d1));
+    res.b4 = invdet  * (a1 * (b3 * c4 - b4 * c3) + a3 * (b4 * c1 - b1 * c4) + a4 * (b1 * c3 - b3 * c1));
+    res.c1 = invdet  * (b1 * (c2 * d4 - c4 * d2) + b2 * (c4 * d1 - c1 * d4) + b4 * (c1 * d2 - c2 * d1));
+    res.c2 = -invdet * (a1 * (c2 * d4 - c4 * d2) + a2 * (c4 * d1 - c1 * d4) + a4 * (c1 * d2 - c2 * d1));
+    res.c3 = invdet  * (a1 * (b2 * d4 - b4 * d2) + a2 * (b4 * d1 - b1 * d4) + a4 * (b1 * d2 - b2 * d1));
+    res.c4 = -invdet * (a1 * (b2 * c4 - b4 * c2) + a2 * (b4 * c1 - b1 * c4) + a4 * (b1 * c2 - b2 * c1));
+    res.d1 = -invdet * (b1 * (c2 * d3 - c3 * d2) + b2 * (c3 * d1 - c1 * d3) + b3 * (c1 * d2 - c2 * d1));
+    res.d2 = invdet  * (a1 * (c2 * d3 - c3 * d2) + a2 * (c3 * d1 - c1 * d3) + a3 * (c1 * d2 - c2 * d1));
+    res.d3 = -invdet * (a1 * (b2 * d3 - b3 * d2) + a2 * (b3 * d1 - b1 * d3) + a3 * (b1 * d2 - b2 * d1));
+    res.d4 = invdet  * (a1 * (b2 * c3 - b3 * c2) + a2 * (b3 * c1 - b1 * c3) + a3 * (b1 * c2 - b2 * c1));
+    *this = res;
+
+    return *this;
+}
+
+// ----------------------------------------------------------------------------------------
+template <typename TReal>
+inline TReal* aiMatrix4x4t<TReal>::operator[](unsigned int p_iIndex) {
+    if (p_iIndex > 3) {
+        return NULL;
+    }
+    switch ( p_iIndex ) {
+        case 0:
+            return &a1;
+        case 1:
+            return &b1;
+        case 2:
+            return &c1;
+        case 3:
+            return &d1;
+        default:
+            break;
+    }
+    return &a1;
+}
+
+// ----------------------------------------------------------------------------------------
+template <typename TReal>
+inline const TReal* aiMatrix4x4t<TReal>::operator[](unsigned int p_iIndex) const {
+    if (p_iIndex > 3) {
+        return NULL;
+    }
+
+    switch ( p_iIndex ) {
+        case 0:
+            return &a1;
+        case 1:
+            return &b1;
+        case 2:
+            return &c1;
+        case 3:
+            return &d1;
+        default:
+            break;
+    }
+    return &a1;
+}
+
+// ----------------------------------------------------------------------------------------
+template <typename TReal>
+inline bool aiMatrix4x4t<TReal>::operator== (const aiMatrix4x4t<TReal>& m) const
+{
+    return (a1 == m.a1 && a2 == m.a2 && a3 == m.a3 && a4 == m.a4 &&
+            b1 == m.b1 && b2 == m.b2 && b3 == m.b3 && b4 == m.b4 &&
+            c1 == m.c1 && c2 == m.c2 && c3 == m.c3 && c4 == m.c4 &&
+            d1 == m.d1 && d2 == m.d2 && d3 == m.d3 && d4 == m.d4);
+}
+
+// ----------------------------------------------------------------------------------------
+template <typename TReal>
+inline bool aiMatrix4x4t<TReal>::operator!= (const aiMatrix4x4t<TReal>& m) const
+{
+    return !(*this == m);
+}
+
+// ---------------------------------------------------------------------------
+template<typename TReal>
+inline bool aiMatrix4x4t<TReal>::Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon) const {
+    return
+        std::abs(a1 - m.a1) <= epsilon &&
+        std::abs(a2 - m.a2) <= epsilon &&
+        std::abs(a3 - m.a3) <= epsilon &&
+        std::abs(a4 - m.a4) <= epsilon &&
+        std::abs(b1 - m.b1) <= epsilon &&
+        std::abs(b2 - m.b2) <= epsilon &&
+        std::abs(b3 - m.b3) <= epsilon &&
+        std::abs(b4 - m.b4) <= epsilon &&
+        std::abs(c1 - m.c1) <= epsilon &&
+        std::abs(c2 - m.c2) <= epsilon &&
+        std::abs(c3 - m.c3) <= epsilon &&
+        std::abs(c4 - m.c4) <= epsilon &&
+        std::abs(d1 - m.d1) <= epsilon &&
+        std::abs(d2 - m.d2) <= epsilon &&
+        std::abs(d3 - m.d3) <= epsilon &&
+        std::abs(d4 - m.d4) <= epsilon;
+}
+
+// ----------------------------------------------------------------------------------------
+
+#define ASSIMP_MATRIX4_4_DECOMPOSE_PART		\
+	const aiMatrix4x4t<TReal>& _this = *this;/* Create alias for conveniance. */ \
+	\
+	/* extract translation */ \
+	pPosition.x = _this[0][3]; \
+	pPosition.y = _this[1][3]; \
+	pPosition.z = _this[2][3]; \
+	\
+	/* extract the columns of the matrix. */ \
+	aiVector3t<TReal> vCols[3] = { \
+		aiVector3t<TReal>(_this[0][0],_this[1][0],_this[2][0]), \
+		aiVector3t<TReal>(_this[0][1],_this[1][1],_this[2][1]), \
+		aiVector3t<TReal>(_this[0][2],_this[1][2],_this[2][2]) \
+	}; \
+	\
+	/* extract the scaling factors */ \
+	pScaling.x = vCols[0].Length(); \
+	pScaling.y = vCols[1].Length(); \
+	pScaling.z = vCols[2].Length(); \
+	\
+	/* and the sign of the scaling */ \
+	if (Determinant() < 0) pScaling = -pScaling; \
+	\
+	/* and remove all scaling from the matrix */ \
+	if(pScaling.x) vCols[0] /= pScaling.x; \
+	if(pScaling.y) vCols[1] /= pScaling.y; \
+	if(pScaling.z) vCols[2] /= pScaling.z; \
+	\
+	do {} while(false)
+
+
+
+
+template <typename TReal>
+inline void aiMatrix4x4t<TReal>::Decompose (aiVector3t<TReal>& pScaling, aiQuaterniont<TReal>& pRotation,
+    aiVector3t<TReal>& pPosition) const
+{
+	ASSIMP_MATRIX4_4_DECOMPOSE_PART;
+
+    // build a 3x3 rotation matrix
+    aiMatrix3x3t<TReal> m(vCols[0].x,vCols[1].x,vCols[2].x,
+        vCols[0].y,vCols[1].y,vCols[2].y,
+        vCols[0].z,vCols[1].z,vCols[2].z);
+
+    // and generate the rotation quaternion from it
+    pRotation = aiQuaterniont<TReal>(m);
+}
+
+template <typename TReal>
+inline void aiMatrix4x4t<TReal>::Decompose(aiVector3t<TReal>& pScaling, aiVector3t<TReal>& pRotation, aiVector3t<TReal>& pPosition) const
+{
+	ASSIMP_MATRIX4_4_DECOMPOSE_PART;
+
+    /*
+    assuming a right-handed coordinate system
+    and post-multiplication of column vectors,
+    the rotation matrix for an euler XYZ rotation is M = Rz * Ry * Rx.
+    combining gives:
+    
+        |  CE  BDE-AF  ADE+BF  0  |
+    M = |  CF  BDF+AE  ADF-BE  0  |
+        |  -D    CB      AC    0  |
+        |   0     0       0    1  |
+
+    where
+	A = cos(angle_x), B = sin(angle_x);
+	C = cos(angle_y), D = sin(angle_y);
+	E = cos(angle_z), F = sin(angle_z);
+	*/
+
+	// Use a small epsilon to solve floating-point inaccuracies
+    const TReal epsilon = 10e-3f;
+
+	pRotation.y  = std::asin(-vCols[0].z);// D. Angle around oY.
+
+	TReal C = std::cos(pRotation.y);
+
+	if(std::fabs(C) > epsilon)
+	{
+		// Finding angle around oX.
+		TReal tan_x = vCols[2].z / C;// A
+		TReal tan_y = vCols[1].z / C;// B
+
+		pRotation.x = std::atan2(tan_y, tan_x);
+		// Finding angle around oZ.
+		tan_x = vCols[0].x / C;// E
+		tan_y = vCols[0].y / C;// F
+		pRotation.z = std::atan2(tan_y, tan_x);
+	}
+	else
+	{// oY is fixed.
+		pRotation.x = 0;// Set angle around oX to 0. => A == 1, B == 0, C == 0, D == 1.
+
+		// And finding angle around oZ.
+		TReal tan_x =  vCols[1].y;// BDF+AE => E
+		TReal tan_y = -vCols[1].x;// BDE-AF => F
+
+		pRotation.z = std::atan2(tan_y, tan_x);
+	}
+}
+
+#undef ASSIMP_MATRIX4_4_DECOMPOSE_PART
+
+template <typename TReal>
+inline void aiMatrix4x4t<TReal>::Decompose(aiVector3t<TReal>& pScaling, aiVector3t<TReal>& pRotationAxis, TReal& pRotationAngle,
+											aiVector3t<TReal>& pPosition) const
+{
+aiQuaterniont<TReal> pRotation;
+
+	Decompose(pScaling, pRotation, pPosition);
+	pRotation.Normalize();
+
+	TReal angle_cos = pRotation.w;
+	TReal angle_sin = std::sqrt(1.0f - angle_cos * angle_cos);
+
+	pRotationAngle = std::acos(angle_cos) * 2;
+
+	// Use a small epsilon to solve floating-point inaccuracies
+    const TReal epsilon = 10e-3f;
+
+	if(std::fabs(angle_sin) < epsilon) angle_sin = 1;
+
+	pRotationAxis.x = pRotation.x / angle_sin;
+	pRotationAxis.y = pRotation.y / angle_sin;
+	pRotationAxis.z = pRotation.z / angle_sin;
+}
+
+// ----------------------------------------------------------------------------------------
+template <typename TReal>
+inline void aiMatrix4x4t<TReal>::DecomposeNoScaling (aiQuaterniont<TReal>& rotation,
+    aiVector3t<TReal>& position) const
+{
+    const aiMatrix4x4t<TReal>& _this = *this;
+
+    // extract translation
+    position.x = _this[0][3];
+    position.y = _this[1][3];
+    position.z = _this[2][3];
+
+    // extract rotation
+    rotation = aiQuaterniont<TReal>((aiMatrix3x3t<TReal>)_this);
+}
+
+// ----------------------------------------------------------------------------------------
+template <typename TReal>
+inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromEulerAnglesXYZ(const aiVector3t<TReal>& blubb)
+{
+    return FromEulerAnglesXYZ(blubb.x,blubb.y,blubb.z);
+}
+
+// ----------------------------------------------------------------------------------------
+template <typename TReal>
+inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromEulerAnglesXYZ(TReal x, TReal y, TReal z)
+{
+    aiMatrix4x4t<TReal>& _this = *this;
+
+    TReal cr = std::cos( x );
+    TReal sr = std::sin( x );
+    TReal cp = std::cos( y );
+    TReal sp = std::sin( y );
+    TReal cy = std::cos( z );
+    TReal sy = std::sin( z );
+
+    _this.a1 = cp*cy ;
+    _this.a2 = cp*sy;
+    _this.a3 = -sp ;
+
+    TReal srsp = sr*sp;
+    TReal crsp = cr*sp;
+
+    _this.b1 = srsp*cy-cr*sy ;
+    _this.b2 = srsp*sy+cr*cy ;
+    _this.b3 = sr*cp ;
+
+    _this.c1 =  crsp*cy+sr*sy ;
+    _this.c2 =  crsp*sy-sr*cy ;
+    _this.c3 = cr*cp ;
+
+    return *this;
+}
+
+// ----------------------------------------------------------------------------------------
+template <typename TReal>
+inline bool aiMatrix4x4t<TReal>::IsIdentity() const
+{
+    // Use a small epsilon to solve floating-point inaccuracies
+    const static TReal epsilon = 10e-3f;
+
+    return (a2 <= epsilon && a2 >= -epsilon &&
+            a3 <= epsilon && a3 >= -epsilon &&
+            a4 <= epsilon && a4 >= -epsilon &&
+            b1 <= epsilon && b1 >= -epsilon &&
+            b3 <= epsilon && b3 >= -epsilon &&
+            b4 <= epsilon && b4 >= -epsilon &&
+            c1 <= epsilon && c1 >= -epsilon &&
+            c2 <= epsilon && c2 >= -epsilon &&
+            c4 <= epsilon && c4 >= -epsilon &&
+            d1 <= epsilon && d1 >= -epsilon &&
+            d2 <= epsilon && d2 >= -epsilon &&
+            d3 <= epsilon && d3 >= -epsilon &&
+            a1 <= 1.f+epsilon && a1 >= 1.f-epsilon &&
+            b2 <= 1.f+epsilon && b2 >= 1.f-epsilon &&
+            c3 <= 1.f+epsilon && c3 >= 1.f-epsilon &&
+            d4 <= 1.f+epsilon && d4 >= 1.f-epsilon);
+}
+
+// ----------------------------------------------------------------------------------------
+template <typename TReal>
+inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationX(TReal a, aiMatrix4x4t<TReal>& out)
+{
+    /*
+         |  1  0       0       0 |
+     M = |  0  cos(A) -sin(A)  0 |
+         |  0  sin(A)  cos(A)  0 |
+         |  0  0       0       1 |  */
+    out = aiMatrix4x4t<TReal>();
+    out.b2 = out.c3 = std::cos(a);
+    out.b3 = -(out.c2 = std::sin(a));
+    return out;
+}
+
+// ----------------------------------------------------------------------------------------
+template <typename TReal>
+inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationY(TReal a, aiMatrix4x4t<TReal>& out)
+{
+    /*
+         |  cos(A)  0   sin(A)  0 |
+     M = |  0       1   0       0 |
+         | -sin(A)  0   cos(A)  0 |
+         |  0       0   0       1 |
+        */
+    out = aiMatrix4x4t<TReal>();
+    out.a1 = out.c3 = std::cos(a);
+    out.c1 = -(out.a3 = std::sin(a));
+    return out;
+}
+
+// ----------------------------------------------------------------------------------------
+template <typename TReal>
+inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationZ(TReal a, aiMatrix4x4t<TReal>& out)
+{
+    /*
+         |  cos(A)  -sin(A)   0   0 |
+     M = |  sin(A)   cos(A)   0   0 |
+         |  0        0        1   0 |
+         |  0        0        0   1 |   */
+    out = aiMatrix4x4t<TReal>();
+    out.a1 = out.b2 = std::cos(a);
+    out.a2 = -(out.b1 = std::sin(a));
+    return out;
+}
+
+// ----------------------------------------------------------------------------------------
+// Returns a rotation matrix for a rotation around an arbitrary axis.
+template <typename TReal>
+inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Rotation( TReal a, const aiVector3t<TReal>& axis, aiMatrix4x4t<TReal>& out)
+{
+  TReal c = std::cos( a), s = std::sin( a), t = 1 - c;
+  TReal x = axis.x, y = axis.y, z = axis.z;
+
+  // Many thanks to MathWorld and Wikipedia
+  out.a1 = t*x*x + c;   out.a2 = t*x*y - s*z; out.a3 = t*x*z + s*y;
+  out.b1 = t*x*y + s*z; out.b2 = t*y*y + c;   out.b3 = t*y*z - s*x;
+  out.c1 = t*x*z - s*y; out.c2 = t*y*z + s*x; out.c3 = t*z*z + c;
+  out.a4 = out.b4 = out.c4 = static_cast<TReal>(0.0);
+  out.d1 = out.d2 = out.d3 = static_cast<TReal>(0.0);
+  out.d4 = static_cast<TReal>(1.0);
+
+  return out;
+}
+
+// ----------------------------------------------------------------------------------------
+template <typename TReal>
+inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Translation( const aiVector3t<TReal>& v, aiMatrix4x4t<TReal>& out)
+{
+    out = aiMatrix4x4t<TReal>();
+    out.a4 = v.x;
+    out.b4 = v.y;
+    out.c4 = v.z;
+    return out;
+}
+
+// ----------------------------------------------------------------------------------------
+template <typename TReal>
+inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Scaling( const aiVector3t<TReal>& v, aiMatrix4x4t<TReal>& out)
+{
+    out = aiMatrix4x4t<TReal>();
+    out.a1 = v.x;
+    out.b2 = v.y;
+    out.c3 = v.z;
+    return out;
+}
+
+// ----------------------------------------------------------------------------------------
+/** A function for creating a rotation matrix that rotates a vector called
+ * "from" into another vector called "to".
+ * Input : from[3], to[3] which both must be *normalized* non-zero vectors
+ * Output: mtx[3][3] -- a 3x3 matrix in colum-major form
+ * Authors: Tomas Möller, John Hughes
+ *          "Efficiently Building a Matrix to Rotate One Vector to Another"
+ *          Journal of Graphics Tools, 4(4):1-4, 1999
+ */
+// ----------------------------------------------------------------------------------------
+template <typename TReal>
+inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromToMatrix(const aiVector3t<TReal>& from,
+    const aiVector3t<TReal>& to, aiMatrix4x4t<TReal>& mtx)
+{
+    aiMatrix3x3t<TReal> m3;
+    aiMatrix3x3t<TReal>::FromToMatrix(from,to,m3);
+    mtx = aiMatrix4x4t<TReal>(m3);
+    return mtx;
+}
+
+#endif // __cplusplus
+#endif // AI_MATRIX4X4_INL_INC
diff --git a/engine/inc/assimp/mesh.h b/engine/inc/assimp/mesh.h
new file mode 100644
index 00000000..73105361
--- /dev/null
+++ b/engine/inc/assimp/mesh.h
@@ -0,0 +1,835 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file mesh.h
+ *  @brief Declares the data structures in which the imported geometry is
+    returned by ASSIMP: aiMesh, aiFace and aiBone data structures.
+ */
+#pragma once
+#ifndef AI_MESH_H_INC
+#define AI_MESH_H_INC
+
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// ---------------------------------------------------------------------------
+// Limits. These values are required to match the settings Assimp was
+// compiled against. Therefore, do not redefine them unless you build the
+// library from source using the same definitions.
+// ---------------------------------------------------------------------------
+
+/** @def AI_MAX_FACE_INDICES
+ *  Maximum number of indices per face (polygon). */
+
+#ifndef AI_MAX_FACE_INDICES
+#   define AI_MAX_FACE_INDICES 0x7fff
+#endif
+
+/** @def AI_MAX_BONE_WEIGHTS
+ *  Maximum number of indices per face (polygon). */
+
+#ifndef AI_MAX_BONE_WEIGHTS
+#   define AI_MAX_BONE_WEIGHTS 0x7fffffff
+#endif
+
+/** @def AI_MAX_VERTICES
+ *  Maximum number of vertices per mesh.  */
+
+#ifndef AI_MAX_VERTICES
+#   define AI_MAX_VERTICES 0x7fffffff
+#endif
+
+/** @def AI_MAX_FACES
+ *  Maximum number of faces per mesh. */
+
+#ifndef AI_MAX_FACES
+#   define AI_MAX_FACES 0x7fffffff
+#endif
+
+/** @def AI_MAX_NUMBER_OF_COLOR_SETS
+ *  Supported number of vertex color sets per mesh. */
+
+#ifndef AI_MAX_NUMBER_OF_COLOR_SETS
+#   define AI_MAX_NUMBER_OF_COLOR_SETS 0x8
+#endif // !! AI_MAX_NUMBER_OF_COLOR_SETS
+
+/** @def AI_MAX_NUMBER_OF_TEXTURECOORDS
+ *  Supported number of texture coord sets (UV(W) channels) per mesh */
+
+#ifndef AI_MAX_NUMBER_OF_TEXTURECOORDS
+#   define AI_MAX_NUMBER_OF_TEXTURECOORDS 0x8
+#endif // !! AI_MAX_NUMBER_OF_TEXTURECOORDS
+
+// ---------------------------------------------------------------------------
+/** @brief A single face in a mesh, referring to multiple vertices.
+ *
+ * If mNumIndices is 3, we call the face 'triangle', for mNumIndices > 3
+ * it's called 'polygon' (hey, that's just a definition!).
+ * <br>
+ * aiMesh::mPrimitiveTypes can be queried to quickly examine which types of
+ * primitive are actually present in a mesh. The #aiProcess_SortByPType flag
+ * executes a special post-processing algorithm which splits meshes with
+ * *different* primitive types mixed up (e.g. lines and triangles) in several
+ * 'clean' submeshes. Furthermore there is a configuration option (
+ * #AI_CONFIG_PP_SBP_REMOVE) to force #aiProcess_SortByPType to remove
+ * specific kinds of primitives from the imported scene, completely and forever.
+ * In many cases you'll probably want to set this setting to
+ * @code
+ * aiPrimitiveType_LINE|aiPrimitiveType_POINT
+ * @endcode
+ * Together with the #aiProcess_Triangulate flag you can then be sure that
+ * #aiFace::mNumIndices is always 3.
+ * @note Take a look at the @link data Data Structures page @endlink for
+ * more information on the layout and winding order of a face.
+ */
+struct aiFace
+{
+    //! Number of indices defining this face.
+    //! The maximum value for this member is #AI_MAX_FACE_INDICES.
+    unsigned int mNumIndices;
+
+    //! Pointer to the indices array. Size of the array is given in numIndices.
+    unsigned int* mIndices;
+
+#ifdef __cplusplus
+
+    //! Default constructor
+    aiFace()
+      : mNumIndices( 0 )
+      , mIndices( NULL )
+    {
+    }
+
+    //! Default destructor. Delete the index array
+    ~aiFace()
+    {
+        delete [] mIndices;
+    }
+
+    //! Copy constructor. Copy the index array
+    aiFace( const aiFace& o)
+      : mIndices( NULL )
+    {
+        *this = o;
+    }
+
+    //! Assignment operator. Copy the index array
+    aiFace& operator = ( const aiFace& o)
+    {
+        if (&o == this)
+            return *this;
+
+        delete[] mIndices;
+        mNumIndices = o.mNumIndices;
+        if (mNumIndices) {
+            mIndices = new unsigned int[mNumIndices];
+            ::memcpy( mIndices, o.mIndices, mNumIndices * sizeof( unsigned int));
+        }
+        else {
+            mIndices = NULL;
+        }
+        return *this;
+    }
+
+    //! Comparison operator. Checks whether the index array
+    //! of two faces is identical
+    bool operator== (const aiFace& o) const
+    {
+        if (mIndices == o.mIndices)return true;
+        else if (mIndices && mNumIndices == o.mNumIndices)
+        {
+            for (unsigned int i = 0;i < this->mNumIndices;++i)
+                if (mIndices[i] != o.mIndices[i])return false;
+            return true;
+        }
+        return false;
+    }
+
+    //! Inverse comparison operator. Checks whether the index
+    //! array of two faces is NOT identical
+    bool operator != (const aiFace& o) const
+    {
+        return !(*this == o);
+    }
+#endif // __cplusplus
+}; // struct aiFace
+
+
+// ---------------------------------------------------------------------------
+/** @brief A single influence of a bone on a vertex.
+ */
+struct aiVertexWeight {
+    //! Index of the vertex which is influenced by the bone.
+    unsigned int mVertexId;
+
+    //! The strength of the influence in the range (0...1).
+    //! The influence from all bones at one vertex amounts to 1.
+    float mWeight;
+
+#ifdef __cplusplus
+
+    //! Default constructor
+    aiVertexWeight()
+    : mVertexId(0)
+    , mWeight(0.0f) {
+        // empty
+    }
+
+    //! Initialisation from a given index and vertex weight factor
+    //! \param pID ID
+    //! \param pWeight Vertex weight factor
+    aiVertexWeight( unsigned int pID, float pWeight )
+    : mVertexId( pID )
+    , mWeight( pWeight ) {
+        // empty
+    }
+
+    bool operator == ( const aiVertexWeight &rhs ) const {
+        return ( mVertexId == rhs.mVertexId && mWeight == rhs.mWeight );
+    }
+
+    bool operator != ( const aiVertexWeight &rhs ) const {
+        return ( *this == rhs );
+    }
+
+#endif // __cplusplus
+};
+
+
+// ---------------------------------------------------------------------------
+/** @brief A single bone of a mesh.
+ *
+ *  A bone has a name by which it can be found in the frame hierarchy and by
+ *  which it can be addressed by animations. In addition it has a number of
+ *  influences on vertices, and a matrix relating the mesh position to the
+ *  position of the bone at the time of binding.
+ */
+struct aiBone {
+    //! The name of the bone.
+    C_STRUCT aiString mName;
+
+    //! The number of vertices affected by this bone.
+    //! The maximum value for this member is #AI_MAX_BONE_WEIGHTS.
+    unsigned int mNumWeights;
+
+    //! The influence weights of this bone, by vertex index.
+    C_STRUCT aiVertexWeight* mWeights;
+
+    /** Matrix that transforms from bone space to mesh space in bind pose.
+     *
+     * This matrix describes the position of the mesh
+     * in the local space of this bone when the skeleton was bound.
+     * Thus it can be used directly to determine a desired vertex position,
+     * given the world-space transform of the bone when animated,
+     * and the position of the vertex in mesh space.
+     *
+     * It is sometimes called an inverse-bind matrix,
+     * or inverse bind pose matrix.
+     */
+    C_STRUCT aiMatrix4x4 mOffsetMatrix;
+
+#ifdef __cplusplus
+
+    //! Default constructor
+    aiBone()
+    : mName()
+    , mNumWeights( 0 )
+    , mWeights( nullptr ) {
+        // empty
+    }
+
+    //! Copy constructor
+    aiBone(const aiBone& other)
+      : mName( other.mName )
+      , mNumWeights( other.mNumWeights )
+      , mOffsetMatrix( other.mOffsetMatrix )
+    {
+        if (other.mWeights && other.mNumWeights)
+        {
+            mWeights = new aiVertexWeight[mNumWeights];
+            ::memcpy(mWeights,other.mWeights,mNumWeights * sizeof(aiVertexWeight));
+        }
+    }
+
+
+    //! Assignment operator
+    aiBone &operator=(const aiBone& other)
+    {
+        if (this == &other) {
+            return *this;
+        }
+
+        mName         = other.mName;
+        mNumWeights   = other.mNumWeights;
+        mOffsetMatrix = other.mOffsetMatrix;
+
+        if (other.mWeights && other.mNumWeights)
+        {
+            if (mWeights) {
+                delete[] mWeights;
+            }
+
+            mWeights = new aiVertexWeight[mNumWeights];
+            ::memcpy(mWeights,other.mWeights,mNumWeights * sizeof(aiVertexWeight));
+        }
+
+        return *this;
+    }
+
+    bool operator == ( const aiBone &rhs ) const {
+        if ( mName != rhs.mName || mNumWeights != rhs.mNumWeights ) {
+            return false;
+        }
+
+        for ( size_t i = 0; i < mNumWeights; ++i ) {
+            if ( mWeights[ i ] != rhs.mWeights[ i ] ) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+    //! Destructor - deletes the array of vertex weights
+    ~aiBone()
+    {
+        delete [] mWeights;
+    }
+#endif // __cplusplus
+};
+
+
+// ---------------------------------------------------------------------------
+/** @brief Enumerates the types of geometric primitives supported by Assimp.
+ *
+ *  @see aiFace Face data structure
+ *  @see aiProcess_SortByPType Per-primitive sorting of meshes
+ *  @see aiProcess_Triangulate Automatic triangulation
+ *  @see AI_CONFIG_PP_SBP_REMOVE Removal of specific primitive types.
+ */
+enum aiPrimitiveType
+{
+    /** A point primitive.
+     *
+     * This is just a single vertex in the virtual world,
+     * #aiFace contains just one index for such a primitive.
+     */
+    aiPrimitiveType_POINT       = 0x1,
+
+    /** A line primitive.
+     *
+     * This is a line defined through a start and an end position.
+     * #aiFace contains exactly two indices for such a primitive.
+     */
+    aiPrimitiveType_LINE        = 0x2,
+
+    /** A triangular primitive.
+     *
+     * A triangle consists of three indices.
+     */
+    aiPrimitiveType_TRIANGLE    = 0x4,
+
+    /** A higher-level polygon with more than 3 edges.
+     *
+     * A triangle is a polygon, but polygon in this context means
+     * "all polygons that are not triangles". The "Triangulate"-Step
+     * is provided for your convenience, it splits all polygons in
+     * triangles (which are much easier to handle).
+     */
+    aiPrimitiveType_POLYGON     = 0x8,
+
+
+    /** This value is not used. It is just here to force the
+     *  compiler to map this enum to a 32 Bit integer.
+     */
+#ifndef SWIG
+    _aiPrimitiveType_Force32Bit = INT_MAX
+#endif
+}; //! enum aiPrimitiveType
+
+// Get the #aiPrimitiveType flag for a specific number of face indices
+#define AI_PRIMITIVE_TYPE_FOR_N_INDICES(n) \
+    ((n) > 3 ? aiPrimitiveType_POLYGON : (aiPrimitiveType)(1u << ((n)-1)))
+
+
+
+// ---------------------------------------------------------------------------
+/** @brief NOT CURRENTLY IN USE. An AnimMesh is an attachment to an #aiMesh stores per-vertex
+ *  animations for a particular frame.
+ *
+ *  You may think of an #aiAnimMesh as a `patch` for the host mesh, which
+ *  replaces only certain vertex data streams at a particular time.
+ *  Each mesh stores n attached attached meshes (#aiMesh::mAnimMeshes).
+ *  The actual relationship between the time line and anim meshes is
+ *  established by #aiMeshAnim, which references singular mesh attachments
+ *  by their ID and binds them to a time offset.
+*/
+struct aiAnimMesh
+{
+    /** Replacement for aiMesh::mVertices. If this array is non-NULL,
+     *  it *must* contain mNumVertices entries. The corresponding
+     *  array in the host mesh must be non-NULL as well - animation
+     *  meshes may neither add or nor remove vertex components (if
+     *  a replacement array is NULL and the corresponding source
+     *  array is not, the source data is taken instead)*/
+    C_STRUCT aiVector3D* mVertices;
+
+    /** Replacement for aiMesh::mNormals.  */
+    C_STRUCT aiVector3D* mNormals;
+
+    /** Replacement for aiMesh::mTangents. */
+    C_STRUCT aiVector3D* mTangents;
+
+    /** Replacement for aiMesh::mBitangents. */
+    C_STRUCT aiVector3D* mBitangents;
+
+    /** Replacement for aiMesh::mColors */
+    C_STRUCT aiColor4D* mColors[AI_MAX_NUMBER_OF_COLOR_SETS];
+
+    /** Replacement for aiMesh::mTextureCoords */
+    C_STRUCT aiVector3D* mTextureCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS];
+
+    /** The number of vertices in the aiAnimMesh, and thus the length of all
+     * the member arrays.
+     *
+     * This has always the same value as the mNumVertices property in the
+     * corresponding aiMesh. It is duplicated here merely to make the length
+     * of the member arrays accessible even if the aiMesh is not known, e.g.
+     * from language bindings.
+     */
+    unsigned int mNumVertices;
+    
+    /** 
+     * Weight of the AnimMesh. 
+     */
+    float mWeight;
+
+#ifdef __cplusplus
+
+    aiAnimMesh()
+        : mVertices( NULL )
+        , mNormals( NULL )
+        , mTangents( NULL )
+        , mBitangents( NULL )
+        , mNumVertices( 0 )
+        , mWeight( 0.0f )
+    {
+        // fixme consider moving this to the ctor initializer list as well
+        for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; a++){
+            mTextureCoords[a] = NULL;
+        }
+        for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; a++) {
+            mColors[a] = NULL;
+        }
+    }
+
+    ~aiAnimMesh()
+    {
+        delete [] mVertices;
+        delete [] mNormals;
+        delete [] mTangents;
+        delete [] mBitangents;
+        for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; a++) {
+            delete [] mTextureCoords[a];
+        }
+        for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; a++) {
+            delete [] mColors[a];
+        }
+    }
+
+    /** Check whether the anim mesh overrides the vertex positions
+     *  of its host mesh*/
+    bool HasPositions() const {
+        return mVertices != NULL;
+    }
+
+    /** Check whether the anim mesh overrides the vertex normals
+     *  of its host mesh*/
+    bool HasNormals() const {
+        return mNormals != NULL;
+    }
+
+    /** Check whether the anim mesh overrides the vertex tangents
+     *  and bitangents of its host mesh. As for aiMesh,
+     *  tangents and bitangents always go together. */
+    bool HasTangentsAndBitangents() const {
+        return mTangents != NULL;
+    }
+
+    /** Check whether the anim mesh overrides a particular
+     * set of vertex colors on his host mesh.
+     *  @param pIndex 0<index<AI_MAX_NUMBER_OF_COLOR_SETS */
+    bool HasVertexColors( unsigned int pIndex) const    {
+        return pIndex >= AI_MAX_NUMBER_OF_COLOR_SETS ? false : mColors[pIndex] != NULL;
+    }
+
+    /** Check whether the anim mesh overrides a particular
+     * set of texture coordinates on his host mesh.
+     *  @param pIndex 0<index<AI_MAX_NUMBER_OF_TEXTURECOORDS */
+    bool HasTextureCoords( unsigned int pIndex) const   {
+        return pIndex >= AI_MAX_NUMBER_OF_TEXTURECOORDS ? false : mTextureCoords[pIndex] != NULL;
+    }
+
+#endif
+};
+
+// ---------------------------------------------------------------------------
+/** @brief Enumerates the methods of mesh morphing supported by Assimp.
+ */
+enum aiMorphingMethod
+{
+    /** Interpolation between morph targets */
+    aiMorphingMethod_VERTEX_BLEND       = 0x1,
+
+    /** Normalized morphing between morph targets  */
+    aiMorphingMethod_MORPH_NORMALIZED   = 0x2,
+
+    /** Relative morphing between morph targets  */
+    aiMorphingMethod_MORPH_RELATIVE     = 0x3,
+
+    /** This value is not used. It is just here to force the
+     *  compiler to map this enum to a 32 Bit integer.
+     */
+#ifndef SWIG
+    _aiMorphingMethod_Force32Bit = INT_MAX
+#endif
+}; //! enum aiMorphingMethod
+
+// ---------------------------------------------------------------------------
+/** @brief A mesh represents a geometry or model with a single material.
+*
+* It usually consists of a number of vertices and a series of primitives/faces
+* referencing the vertices. In addition there might be a series of bones, each
+* of them addressing a number of vertices with a certain weight. Vertex data
+* is presented in channels with each channel containing a single per-vertex
+* information such as a set of texture coords or a normal vector.
+* If a data pointer is non-null, the corresponding data stream is present.
+* From C++-programs you can also use the comfort functions Has*() to
+* test for the presence of various data streams.
+*
+* A Mesh uses only a single material which is referenced by a material ID.
+* @note The mPositions member is usually not optional. However, vertex positions
+* *could* be missing if the #AI_SCENE_FLAGS_INCOMPLETE flag is set in
+* @code
+* aiScene::mFlags
+* @endcode
+*/
+struct aiMesh
+{
+    /** Bitwise combination of the members of the #aiPrimitiveType enum.
+     * This specifies which types of primitives are present in the mesh.
+     * The "SortByPrimitiveType"-Step can be used to make sure the
+     * output meshes consist of one primitive type each.
+     */
+    unsigned int mPrimitiveTypes;
+
+    /** The number of vertices in this mesh.
+    * This is also the size of all of the per-vertex data arrays.
+    * The maximum value for this member is #AI_MAX_VERTICES.
+    */
+    unsigned int mNumVertices;
+
+    /** The number of primitives (triangles, polygons, lines) in this  mesh.
+    * This is also the size of the mFaces array.
+    * The maximum value for this member is #AI_MAX_FACES.
+    */
+    unsigned int mNumFaces;
+
+    /** Vertex positions.
+    * This array is always present in a mesh. The array is
+    * mNumVertices in size.
+    */
+    C_STRUCT aiVector3D* mVertices;
+
+    /** Vertex normals.
+    * The array contains normalized vectors, NULL if not present.
+    * The array is mNumVertices in size. Normals are undefined for
+    * point and line primitives. A mesh consisting of points and
+    * lines only may not have normal vectors. Meshes with mixed
+    * primitive types (i.e. lines and triangles) may have normals,
+    * but the normals for vertices that are only referenced by
+    * point or line primitives are undefined and set to QNaN (WARN:
+    * qNaN compares to inequal to *everything*, even to qNaN itself.
+    * Using code like this to check whether a field is qnan is:
+    * @code
+    * #define IS_QNAN(f) (f != f)
+    * @endcode
+    * still dangerous because even 1.f == 1.f could evaluate to false! (
+    * remember the subtleties of IEEE754 artithmetics). Use stuff like
+    * @c fpclassify instead.
+    * @note Normal vectors computed by Assimp are always unit-length.
+    * However, this needn't apply for normals that have been taken
+    *   directly from the model file.
+    */
+    C_STRUCT aiVector3D* mNormals;
+
+    /** Vertex tangents.
+    * The tangent of a vertex points in the direction of the positive
+    * X texture axis. The array contains normalized vectors, NULL if
+    * not present. The array is mNumVertices in size. A mesh consisting
+    * of points and lines only may not have normal vectors. Meshes with
+    * mixed primitive types (i.e. lines and triangles) may have
+    * normals, but the normals for vertices that are only referenced by
+    * point or line primitives are undefined and set to qNaN.  See
+    * the #mNormals member for a detailed discussion of qNaNs.
+    * @note If the mesh contains tangents, it automatically also
+    * contains bitangents.
+    */
+    C_STRUCT aiVector3D* mTangents;
+
+    /** Vertex bitangents.
+    * The bitangent of a vertex points in the direction of the positive
+    * Y texture axis. The array contains normalized vectors, NULL if not
+    * present. The array is mNumVertices in size.
+    * @note If the mesh contains tangents, it automatically also contains
+    * bitangents.
+    */
+    C_STRUCT aiVector3D* mBitangents;
+
+    /** Vertex color sets.
+    * A mesh may contain 0 to #AI_MAX_NUMBER_OF_COLOR_SETS vertex
+    * colors per vertex. NULL if not present. Each array is
+    * mNumVertices in size if present.
+    */
+    C_STRUCT aiColor4D* mColors[AI_MAX_NUMBER_OF_COLOR_SETS];
+
+    /** Vertex texture coords, also known as UV channels.
+    * A mesh may contain 0 to AI_MAX_NUMBER_OF_TEXTURECOORDS per
+    * vertex. NULL if not present. The array is mNumVertices in size.
+    */
+    C_STRUCT aiVector3D* mTextureCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS];
+
+    /** Specifies the number of components for a given UV channel.
+    * Up to three channels are supported (UVW, for accessing volume
+    * or cube maps). If the value is 2 for a given channel n, the
+    * component p.z of mTextureCoords[n][p] is set to 0.0f.
+    * If the value is 1 for a given channel, p.y is set to 0.0f, too.
+    * @note 4D coords are not supported
+    */
+    unsigned int mNumUVComponents[AI_MAX_NUMBER_OF_TEXTURECOORDS];
+
+    /** The faces the mesh is constructed from.
+    * Each face refers to a number of vertices by their indices.
+    * This array is always present in a mesh, its size is given
+    * in mNumFaces. If the #AI_SCENE_FLAGS_NON_VERBOSE_FORMAT
+    * is NOT set each face references an unique set of vertices.
+    */
+    C_STRUCT aiFace* mFaces;
+
+    /** The number of bones this mesh contains.
+    * Can be 0, in which case the mBones array is NULL.
+    */
+    unsigned int mNumBones;
+
+    /** The bones of this mesh.
+    * A bone consists of a name by which it can be found in the
+    * frame hierarchy and a set of vertex weights.
+    */
+    C_STRUCT aiBone** mBones;
+
+    /** The material used by this mesh.
+     * A mesh uses only a single material. If an imported model uses
+     * multiple materials, the import splits up the mesh. Use this value
+     * as index into the scene's material list.
+     */
+    unsigned int mMaterialIndex;
+
+    /** Name of the mesh. Meshes can be named, but this is not a
+     *  requirement and leaving this field empty is totally fine.
+     *  There are mainly three uses for mesh names:
+     *   - some formats name nodes and meshes independently.
+     *   - importers tend to split meshes up to meet the
+     *      one-material-per-mesh requirement. Assigning
+     *      the same (dummy) name to each of the result meshes
+     *      aids the caller at recovering the original mesh
+     *      partitioning.
+     *   - Vertex animations refer to meshes by their names.
+     **/
+    C_STRUCT aiString mName;
+
+
+    /** The number of attachment meshes. Note! Currently only works with Collada loader. */
+    unsigned int mNumAnimMeshes;
+
+    /** Attachment meshes for this mesh, for vertex-based animation.
+     *  Attachment meshes carry replacement data for some of the
+     *  mesh'es vertex components (usually positions, normals).
+     *  Note! Currently only works with Collada loader.*/
+    C_STRUCT aiAnimMesh** mAnimMeshes;
+
+    /** 
+     *  Method of morphing when animeshes are specified. 
+     */
+    unsigned int mMethod;
+	
+#ifdef __cplusplus
+
+    //! Default constructor. Initializes all members to 0
+    aiMesh()
+        : mPrimitiveTypes( 0 )
+        , mNumVertices( 0 )
+        , mNumFaces( 0 )
+        , mVertices( NULL )
+        , mNormals( NULL )
+        , mTangents( NULL )
+        , mBitangents( NULL )
+        , mFaces( NULL )
+        , mNumBones( 0 )
+        , mBones( NULL )
+        , mMaterialIndex( 0 )
+        , mNumAnimMeshes( 0 )
+        , mAnimMeshes( NULL )
+        , mMethod( 0 )
+    {
+        for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; a++)
+        {
+            mNumUVComponents[a] = 0;
+            mTextureCoords[a] = NULL;
+        }
+
+        for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; a++)
+            mColors[a] = NULL;
+    }
+
+    //! Deletes all storage allocated for the mesh
+    ~aiMesh()
+    {
+        delete [] mVertices;
+        delete [] mNormals;
+        delete [] mTangents;
+        delete [] mBitangents;
+        for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; a++) {
+            delete [] mTextureCoords[a];
+        }
+        for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; a++) {
+            delete [] mColors[a];
+        }
+
+        // DO NOT REMOVE THIS ADDITIONAL CHECK
+        if (mNumBones && mBones)    {
+            for( unsigned int a = 0; a < mNumBones; a++) {
+                delete mBones[a];
+            }
+            delete [] mBones;
+        }
+
+        if (mNumAnimMeshes && mAnimMeshes)  {
+            for( unsigned int a = 0; a < mNumAnimMeshes; a++) {
+                delete mAnimMeshes[a];
+            }
+            delete [] mAnimMeshes;
+        }
+
+        delete [] mFaces;
+    }
+
+    //! Check whether the mesh contains positions. Provided no special
+    //! scene flags are set, this will always be true
+    bool HasPositions() const
+        { return mVertices != NULL && mNumVertices > 0; }
+
+    //! Check whether the mesh contains faces. If no special scene flags
+    //! are set this should always return true
+    bool HasFaces() const
+        { return mFaces != NULL && mNumFaces > 0; }
+
+    //! Check whether the mesh contains normal vectors
+    bool HasNormals() const
+        { return mNormals != NULL && mNumVertices > 0; }
+
+    //! Check whether the mesh contains tangent and bitangent vectors
+    //! It is not possible that it contains tangents and no bitangents
+    //! (or the other way round). The existence of one of them
+    //! implies that the second is there, too.
+    bool HasTangentsAndBitangents() const
+        { return mTangents != NULL && mBitangents != NULL && mNumVertices > 0; }
+
+    //! Check whether the mesh contains a vertex color set
+    //! \param pIndex Index of the vertex color set
+    bool HasVertexColors( unsigned int pIndex) const
+    {
+        if( pIndex >= AI_MAX_NUMBER_OF_COLOR_SETS)
+            return false;
+        else
+            return mColors[pIndex] != NULL && mNumVertices > 0;
+    }
+
+    //! Check whether the mesh contains a texture coordinate set
+    //! \param pIndex Index of the texture coordinates set
+    bool HasTextureCoords( unsigned int pIndex) const
+    {
+        if( pIndex >= AI_MAX_NUMBER_OF_TEXTURECOORDS)
+            return false;
+        else
+            return mTextureCoords[pIndex] != NULL && mNumVertices > 0;
+    }
+
+    //! Get the number of UV channels the mesh contains
+    unsigned int GetNumUVChannels() const
+    {
+        unsigned int n = 0;
+        while (n < AI_MAX_NUMBER_OF_TEXTURECOORDS && mTextureCoords[n])++n;
+        return n;
+    }
+
+    //! Get the number of vertex color channels the mesh contains
+    unsigned int GetNumColorChannels() const
+    {
+        unsigned int n = 0;
+        while (n < AI_MAX_NUMBER_OF_COLOR_SETS && mColors[n])++n;
+        return n;
+    }
+
+    //! Check whether the mesh contains bones
+    inline bool HasBones() const
+        { return mBones != NULL && mNumBones > 0; }
+
+#endif // __cplusplus
+};
+
+#ifdef __cplusplus
+}
+#endif //! extern "C"
+#endif // AI_MESH_H_INC
+
diff --git a/engine/inc/assimp/metadata.h b/engine/inc/assimp/metadata.h
new file mode 100644
index 00000000..70a604de
--- /dev/null
+++ b/engine/inc/assimp/metadata.h
@@ -0,0 +1,379 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file metadata.h
+ *  @brief Defines the data structures for holding node meta information.
+ */
+#pragma once
+#ifndef AI_METADATA_H_INC
+#define AI_METADATA_H_INC
+
+#if defined(_MSC_VER) && (_MSC_VER <= 1500)
+#  include "Compiler/pstdint.h"
+#else
+#  include <stdint.h>
+#endif
+
+// -------------------------------------------------------------------------------
+/**
+  * Enum used to distinguish data types
+  */
+ // -------------------------------------------------------------------------------
+typedef enum aiMetadataType {
+    AI_BOOL       = 0,
+    AI_INT32      = 1,
+    AI_UINT64     = 2,
+    AI_FLOAT      = 3,
+    AI_DOUBLE     = 4,
+    AI_AISTRING   = 5,
+    AI_AIVECTOR3D = 6,
+    AI_META_MAX   = 7,
+
+#ifndef SWIG
+    FORCE_32BIT = INT_MAX
+#endif
+} aiMetadataType;
+
+// -------------------------------------------------------------------------------
+/**
+  * Metadata entry
+  *
+  * The type field uniquely identifies the underlying type of the data field
+  */
+ // -------------------------------------------------------------------------------
+struct aiMetadataEntry {
+    aiMetadataType mType;
+    void* mData;
+};
+
+#ifdef __cplusplus
+
+#include <string>
+
+// -------------------------------------------------------------------------------
+/**
+  * Helper functions to get the aiType enum entry for a type
+  */
+ // -------------------------------------------------------------------------------
+
+inline aiMetadataType GetAiType( bool )       { return AI_BOOL; }
+inline aiMetadataType GetAiType( int32_t )    { return AI_INT32; }
+inline aiMetadataType GetAiType( uint64_t )   { return AI_UINT64; }
+inline aiMetadataType GetAiType( float )      { return AI_FLOAT; }
+inline aiMetadataType GetAiType( double )     { return AI_DOUBLE; }
+inline aiMetadataType GetAiType( const aiString & )   { return AI_AISTRING; }
+inline aiMetadataType GetAiType( const aiVector3D & ) { return AI_AIVECTOR3D; }
+
+#endif // __cplusplus
+
+// -------------------------------------------------------------------------------
+/**
+  * Container for holding metadata.
+  *
+  * Metadata is a key-value store using string keys and values.
+  */
+ // -------------------------------------------------------------------------------
+struct aiMetadata {
+    /** Length of the mKeys and mValues arrays, respectively */
+    unsigned int mNumProperties;
+
+    /** Arrays of keys, may not be NULL. Entries in this array may not be NULL as well. */
+    C_STRUCT aiString* mKeys;
+
+    /** Arrays of values, may not be NULL. Entries in this array may be NULL if the
+      * corresponding property key has no assigned value. */
+    C_STRUCT aiMetadataEntry* mValues;
+
+#ifdef __cplusplus
+
+    /** 
+     *  @brief  The default constructor, set all members to zero by default.
+     */
+    aiMetadata()
+    : mNumProperties(0)
+    , mKeys(nullptr)
+    , mValues(nullptr) {
+        // empty
+    }
+
+    aiMetadata( const aiMetadata &rhs )
+    : mNumProperties( rhs.mNumProperties )
+    , mKeys( nullptr )
+    , mValues( nullptr ) {
+        mKeys = new aiString[ mNumProperties ];
+        for ( unsigned int i = 0; i < mNumProperties; ++i ) {
+            mKeys[ i ] = rhs.mKeys[ i ];
+        }
+        mValues = new aiMetadataEntry[ mNumProperties ];
+        for ( unsigned int i = 0; i < mNumProperties; ++i ) {
+            mValues[ i ].mType = rhs.mValues[ i ].mType;
+            switch ( rhs.mValues[ i ].mType ) {
+            case AI_BOOL:
+                mValues[ i ].mData = new bool( rhs.mValues[i].mData );
+                break;
+            case AI_INT32: {
+                int32_t v;
+                ::memcpy( &v, rhs.mValues[ i ].mData, sizeof( int32_t ) );
+                mValues[ i ].mData = new int32_t( v );
+                }
+                break;
+            case AI_UINT64: {
+                    uint64_t v;
+                    ::memcpy( &v, rhs.mValues[ i ].mData, sizeof( uint64_t ) );
+                    mValues[ i ].mData = new  uint64_t( v );
+                }
+                break;
+            case AI_FLOAT: {
+                    float v;
+                    ::memcpy( &v, rhs.mValues[ i ].mData, sizeof( float ) );
+                    mValues[ i ].mData = new float( v );
+                }
+                break;
+            case AI_DOUBLE: {
+                    double v;
+                    ::memcpy( &v, rhs.mValues[ i ].mData, sizeof( double ) );
+                    mValues[ i ].mData = new double( v );
+                }
+                break;
+            case AI_AISTRING: {
+                    aiString v;
+                    rhs.Get<aiString>( mKeys[ i ], v );
+                    mValues[ i ].mData = new aiString( v );
+                }
+                break;
+            case AI_AIVECTOR3D: {
+                    aiVector3D v;
+                    rhs.Get<aiVector3D>( mKeys[ i ], v );
+                    mValues[ i ].mData = new aiVector3D( v );
+                }
+                break;
+#ifndef SWIG
+            case FORCE_32BIT:
+#endif
+            default:
+                break;
+            }
+
+        }
+    }
+
+    /** 
+     *  @brief The destructor.
+     */
+    ~aiMetadata() {
+        delete [] mKeys;
+        mKeys = nullptr;
+        if (mValues) {
+            // Delete each metadata entry
+            for (unsigned i=0; i<mNumProperties; ++i) {
+                void* data = mValues[i].mData;
+                switch (mValues[i].mType) {
+                case AI_BOOL:
+                    delete static_cast< bool* >( data );
+                    break;
+                case AI_INT32:
+                    delete static_cast< int32_t* >( data );
+                    break;
+                case AI_UINT64:
+                    delete static_cast< uint64_t* >( data );
+                    break;
+                case AI_FLOAT:
+                    delete static_cast< float* >( data );
+                    break;
+                case AI_DOUBLE:
+                    delete static_cast< double* >( data );
+                    break;
+                case AI_AISTRING:
+                    delete static_cast< aiString* >( data );
+                    break;
+                case AI_AIVECTOR3D:
+                    delete static_cast< aiVector3D* >( data );
+                    break;
+#ifndef SWIG
+                case FORCE_32BIT:
+#endif
+                default:
+                    break;
+                }
+            }
+
+            // Delete the metadata array
+            delete [] mValues;
+            mValues = nullptr;
+        }
+    }
+
+    /**
+     *  @brief Allocates property fields + keys.
+     *  @param  numProperties   Number of requested properties.
+     */
+    static inline
+    aiMetadata *Alloc( unsigned int numProperties ) {
+        if ( 0 == numProperties ) {
+            return nullptr;
+        }
+
+        aiMetadata *data = new aiMetadata;
+        data->mNumProperties = numProperties;
+        data->mKeys = new aiString[ data->mNumProperties ]();
+        data->mValues = new aiMetadataEntry[ data->mNumProperties ]();
+
+        return data;
+    }
+
+    /**
+     *  @brief Deallocates property fields + keys.
+     */
+    static inline
+    void Dealloc( aiMetadata *metadata ) {
+        delete metadata;
+    }
+
+	template<typename T>
+	inline
+    void Add(const std::string& key, const T& value) {
+		aiString* new_keys = new aiString[mNumProperties + 1];
+		aiMetadataEntry* new_values = new aiMetadataEntry[mNumProperties + 1];
+
+		for(unsigned int i = 0; i < mNumProperties; ++i)
+		{
+			new_keys[i] = mKeys[i];
+			new_values[i] = mValues[i];
+		}
+
+		delete mKeys;
+		delete mValues;
+
+		mKeys = new_keys;
+		mValues = new_values;
+
+		mNumProperties++;
+
+		Set(mNumProperties - 1, key, value);
+	}
+
+    template<typename T>
+    inline 
+    bool Set( unsigned index, const std::string& key, const T& value ) {
+        // In range assertion
+        if ( index >= mNumProperties ) {
+            return false;
+        }
+
+        // Ensure that we have a valid key.
+        if ( key.empty() ) {
+            return false;
+        }
+
+        // Set metadata key
+        mKeys[index] = key;
+
+        // Set metadata type
+        mValues[index].mType = GetAiType(value);
+        // Copy the given value to the dynamic storage
+        mValues[index].mData = new T(value);
+
+        return true;
+    }
+
+    template<typename T>
+    inline 
+    bool Get( unsigned index, T& value ) const {
+        // In range assertion
+        if ( index >= mNumProperties ) {
+            return false;
+        }
+
+        // Return false if the output data type does
+        // not match the found value's data type
+        if ( GetAiType( value ) != mValues[ index ].mType ) {
+            return false;
+        }
+
+        // Otherwise, output the found value and
+        // return true
+        value = *static_cast<T*>(mValues[index].mData);
+
+        return true;
+    }
+
+    template<typename T>
+    inline 
+    bool Get( const aiString& key, T& value ) const {
+        // Search for the given key
+        for ( unsigned int i = 0; i < mNumProperties; ++i ) {
+            if ( mKeys[ i ] == key ) {
+                return Get( i, value );
+            }
+        }
+        return false;
+    }
+
+    template<typename T>
+    inline
+    bool Get( const std::string& key, T& value ) const {
+        return Get(aiString(key), value);
+    }
+
+	/// Return metadata entry for analyzing it by user.
+	/// \param [in] pIndex - index of the entry.
+	/// \param [out] pKey - pointer to the key value.
+	/// \param [out] pEntry - pointer to the entry: type and value.
+	/// \return false - if pIndex is out of range, else - true.
+	inline
+    bool Get(size_t index, const aiString*& key, const aiMetadataEntry*& entry) const {
+        if ( index >= mNumProperties ) {
+            return false;
+        }
+
+		key = &mKeys[index];
+		entry = &mValues[index];
+
+		return true;
+	}
+
+#endif // __cplusplus
+
+};
+
+#endif // AI_METADATA_H_INC
diff --git a/engine/inc/assimp/pbrmaterial.h b/engine/inc/assimp/pbrmaterial.h
new file mode 100644
index 00000000..cd9b5e2b
--- /dev/null
+++ b/engine/inc/assimp/pbrmaterial.h
@@ -0,0 +1,76 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file pbrmaterial.h
+ *  @brief Defines the material system of the library
+ */
+#ifndef AI_PBRMATERIAL_H_INC
+#define AI_PBRMATERIAL_H_INC
+
+#define AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_BASE_COLOR_FACTOR "$mat.gltf.pbrMetallicRoughness.baseColorFactor", 0, 0
+#define AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_METALLIC_FACTOR "$mat.gltf.pbrMetallicRoughness.metallicFactor", 0, 0
+#define AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_ROUGHNESS_FACTOR "$mat.gltf.pbrMetallicRoughness.roughnessFactor", 0, 0
+#define AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_BASE_COLOR_TEXTURE aiTextureType_DIFFUSE, 1
+#define AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_METALLICROUGHNESS_TEXTURE aiTextureType_UNKNOWN, 0
+#define AI_MATKEY_GLTF_ALPHAMODE "$mat.gltf.alphaMode", 0, 0
+#define AI_MATKEY_GLTF_ALPHACUTOFF "$mat.gltf.alphaCutoff", 0, 0
+#define AI_MATKEY_GLTF_PBRSPECULARGLOSSINESS "$mat.gltf.pbrSpecularGlossiness", 0, 0
+#define AI_MATKEY_GLTF_PBRSPECULARGLOSSINESS_GLOSSINESS_FACTOR "$mat.gltf.pbrMetallicRoughness.glossinessFactor", 0, 0
+
+#define _AI_MATKEY_GLTF_TEXTURE_TEXCOORD_BASE "$tex.file.texCoord"
+#define _AI_MATKEY_GLTF_MAPPINGNAME_BASE "$tex.mappingname"
+#define _AI_MATKEY_GLTF_MAPPINGID_BASE "$tex.mappingid"
+#define _AI_MATKEY_GLTF_MAPPINGFILTER_MAG_BASE "$tex.mappingfiltermag"
+#define _AI_MATKEY_GLTF_MAPPINGFILTER_MIN_BASE "$tex.mappingfiltermin"
+#define _AI_MATKEY_GLTF_SCALE_BASE "$tex.scale"
+#define _AI_MATKEY_GLTF_STRENGTH_BASE "$tex.strength"
+
+#define AI_MATKEY_GLTF_TEXTURE_TEXCOORD(type, N) _AI_MATKEY_GLTF_TEXTURE_TEXCOORD_BASE, type, N
+#define AI_MATKEY_GLTF_MAPPINGNAME(type, N) _AI_MATKEY_GLTF_MAPPINGNAME_BASE, type, N
+#define AI_MATKEY_GLTF_MAPPINGID(type, N) _AI_MATKEY_GLTF_MAPPINGID_BASE, type, N
+#define AI_MATKEY_GLTF_MAPPINGFILTER_MAG(type, N) _AI_MATKEY_GLTF_MAPPINGFILTER_MAG_BASE, type, N
+#define AI_MATKEY_GLTF_MAPPINGFILTER_MIN(type, N) _AI_MATKEY_GLTF_MAPPINGFILTER_MIN_BASE, type, N
+#define AI_MATKEY_GLTF_TEXTURE_SCALE(type, N) _AI_MATKEY_GLTF_SCALE_BASE, type, N
+#define AI_MATKEY_GLTF_TEXTURE_STRENGTH(type, N) _AI_MATKEY_GLTF_STRENGTH_BASE, type, N
+
+#endif //!!AI_PBRMATERIAL_H_INC
diff --git a/engine/inc/assimp/port/AndroidJNI/AndroidJNIIOSystem.h b/engine/inc/assimp/port/AndroidJNI/AndroidJNIIOSystem.h
new file mode 100644
index 00000000..41d80048
--- /dev/null
+++ b/engine/inc/assimp/port/AndroidJNI/AndroidJNIIOSystem.h
@@ -0,0 +1,92 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2016, assimp team
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file Android implementation of IOSystem using the standard C file functions.
+ * Aimed to ease the access to android assets */
+
+#if __ANDROID__ and __ANDROID_API__ > 9 and defined(AI_CONFIG_ANDROID_JNI_ASSIMP_MANAGER_SUPPORT)
+#ifndef AI_ANDROIDJNIIOSYSTEM_H_INC
+#define AI_ANDROIDJNIIOSYSTEM_H_INC
+
+#include <assimp/DefaultIOSystem.h>
+#include <android/asset_manager.h>
+#include <android/asset_manager_jni.h>
+#include <android/native_activity.h>
+
+namespace Assimp	{
+
+// ---------------------------------------------------------------------------
+/** Android extension to DefaultIOSystem using the standard C file functions */
+class ASSIMP_API AndroidJNIIOSystem : public DefaultIOSystem
+{
+public:
+
+	/** Initialize android activity data */
+	std::string mApkWorkspacePath;
+	AAssetManager* mApkAssetManager;
+
+	/** Constructor. */
+	AndroidJNIIOSystem(ANativeActivity* activity);
+
+	/** Destructor. */
+	~AndroidJNIIOSystem();
+
+	// -------------------------------------------------------------------
+	/** Tests for the existence of a file at the given path. */
+	bool Exists( const char* pFile) const;
+
+	// -------------------------------------------------------------------
+	/** Opens a file at the given path, with given mode */
+	IOStream* Open( const char* strFile, const char* strMode);
+
+	// ------------------------------------------------------------------------------------------------
+	// Inits Android extractor
+	void AndroidActivityInit(ANativeActivity* activity);
+
+	// ------------------------------------------------------------------------------------------------
+	// Extracts android asset
+	bool AndroidExtractAsset(std::string name);
+
+};
+
+} //!ns Assimp
+
+#endif //AI_ANDROIDJNIIOSYSTEM_H_INC
+#endif //__ANDROID__ and __ANDROID_API__ > 9 and defined(AI_CONFIG_ANDROID_JNI_ASSIMP_MANAGER_SUPPORT)
diff --git a/engine/inc/assimp/postprocess.h b/engine/inc/assimp/postprocess.h
new file mode 100644
index 00000000..f6c0833e
--- /dev/null
+++ b/engine/inc/assimp/postprocess.h
@@ -0,0 +1,664 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file postprocess.h
+ *  @brief Definitions for import post processing steps
+ */
+#pragma once
+#ifndef AI_POSTPROCESS_H_INC
+#define AI_POSTPROCESS_H_INC
+
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// -----------------------------------------------------------------------------------
+/** @enum  aiPostProcessSteps
+ *  @brief Defines the flags for all possible post processing steps.
+ *
+ *  @note Some steps are influenced by properties set on the Assimp::Importer itself
+ *
+ *  @see Assimp::Importer::ReadFile()
+ *  @see Assimp::Importer::SetPropertyInteger()
+ *  @see aiImportFile
+ *  @see aiImportFileEx
+ */
+// -----------------------------------------------------------------------------------
+enum aiPostProcessSteps
+{
+
+    // -------------------------------------------------------------------------
+    /** <hr>Calculates the tangents and bitangents for the imported meshes.
+     *
+     * Does nothing if a mesh does not have normals. You might want this post
+     * processing step to be executed if you plan to use tangent space calculations
+     * such as normal mapping  applied to the meshes. There's an importer property,
+     * <tt>#AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE</tt>, which allows you to specify
+     * a maximum smoothing angle for the algorithm. However, usually you'll
+     * want to leave it at the default value.
+     */
+    aiProcess_CalcTangentSpace = 0x1,
+
+    // -------------------------------------------------------------------------
+    /** <hr>Identifies and joins identical vertex data sets within all
+     *  imported meshes.
+     *
+     * After this step is run, each mesh contains unique vertices,
+     * so a vertex may be used by multiple faces. You usually want
+     * to use this post processing step. If your application deals with
+     * indexed geometry, this step is compulsory or you'll just waste rendering
+     * time. <b>If this flag is not specified</b>, no vertices are referenced by
+     * more than one face and <b>no index buffer is required</b> for rendering.
+     */
+    aiProcess_JoinIdenticalVertices = 0x2,
+
+    // -------------------------------------------------------------------------
+    /** <hr>Converts all the imported data to a left-handed coordinate space.
+     *
+     * By default the data is returned in a right-handed coordinate space (which
+     * OpenGL prefers). In this space, +X points to the right,
+     * +Z points towards the viewer, and +Y points upwards. In the DirectX
+     * coordinate space +X points to the right, +Y points upwards, and +Z points
+     * away from the viewer.
+     *
+     * You'll probably want to consider this flag if you use Direct3D for
+     * rendering. The #aiProcess_ConvertToLeftHanded flag supersedes this
+     * setting and bundles all conversions typically required for D3D-based
+     * applications.
+     */
+    aiProcess_MakeLeftHanded = 0x4,
+
+    // -------------------------------------------------------------------------
+    /** <hr>Triangulates all faces of all meshes.
+     *
+     * By default the imported mesh data might contain faces with more than 3
+     * indices. For rendering you'll usually want all faces to be triangles.
+     * This post processing step splits up faces with more than 3 indices into
+     * triangles. Line and point primitives are *not* modified! If you want
+     * 'triangles only' with no other kinds of primitives, try the following
+     * solution:
+     * <ul>
+     * <li>Specify both #aiProcess_Triangulate and #aiProcess_SortByPType </li>
+     * <li>Ignore all point and line meshes when you process assimp's output</li>
+     * </ul>
+     */
+    aiProcess_Triangulate = 0x8,
+
+    // -------------------------------------------------------------------------
+    /** <hr>Removes some parts of the data structure (animations, materials,
+     *  light sources, cameras, textures, vertex components).
+     *
+     * The  components to be removed are specified in a separate
+     * importer property, <tt>#AI_CONFIG_PP_RVC_FLAGS</tt>. This is quite useful
+     * if you don't need all parts of the output structure. Vertex colors
+     * are rarely used today for example... Calling this step to remove unneeded
+     * data from the pipeline as early as possible results in increased
+     * performance and a more optimized output data structure.
+     * This step is also useful if you want to force Assimp to recompute
+     * normals or tangents. The corresponding steps don't recompute them if
+     * they're already there (loaded from the source asset). By using this
+     * step you can make sure they are NOT there.
+     *
+     * This flag is a poor one, mainly because its purpose is usually
+     * misunderstood. Consider the following case: a 3D model has been exported
+     * from a CAD app, and it has per-face vertex colors. Vertex positions can't be
+     * shared, thus the #aiProcess_JoinIdenticalVertices step fails to
+     * optimize the data because of these nasty little vertex colors.
+     * Most apps don't even process them, so it's all for nothing. By using
+     * this step, unneeded components are excluded as early as possible
+     * thus opening more room for internal optimizations.
+     */
+    aiProcess_RemoveComponent = 0x10,
+
+    // -------------------------------------------------------------------------
+    /** <hr>Generates normals for all faces of all meshes.
+     *
+     * This is ignored if normals are already there at the time this flag
+     * is evaluated. Model importers try to load them from the source file, so
+     * they're usually already there. Face normals are shared between all points
+     * of a single face, so a single point can have multiple normals, which
+     * forces the library to duplicate vertices in some cases.
+     * #aiProcess_JoinIdenticalVertices is *senseless* then.
+     *
+     * This flag may not be specified together with #aiProcess_GenSmoothNormals.
+     */
+    aiProcess_GenNormals = 0x20,
+
+    // -------------------------------------------------------------------------
+    /** <hr>Generates smooth normals for all vertices in the mesh.
+    *
+    * This is ignored if normals are already there at the time this flag
+    * is evaluated. Model importers try to load them from the source file, so
+    * they're usually already there.
+    *
+    * This flag may not be specified together with
+    * #aiProcess_GenNormals. There's a importer property,
+    * <tt>#AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE</tt> which allows you to specify
+    * an angle maximum for the normal smoothing algorithm. Normals exceeding
+    * this limit are not smoothed, resulting in a 'hard' seam between two faces.
+    * Using a decent angle here (e.g. 80 degrees) results in very good visual
+    * appearance.
+    */
+    aiProcess_GenSmoothNormals = 0x40,
+
+    // -------------------------------------------------------------------------
+    /** <hr>Splits large meshes into smaller sub-meshes.
+    *
+    * This is quite useful for real-time rendering, where the number of triangles
+    * which can be maximally processed in a single draw-call is limited
+    * by the video driver/hardware. The maximum vertex buffer is usually limited
+    * too. Both requirements can be met with this step: you may specify both a
+    * triangle and vertex limit for a single mesh.
+    *
+    * The split limits can (and should!) be set through the
+    * <tt>#AI_CONFIG_PP_SLM_VERTEX_LIMIT</tt> and <tt>#AI_CONFIG_PP_SLM_TRIANGLE_LIMIT</tt>
+    * importer properties. The default values are <tt>#AI_SLM_DEFAULT_MAX_VERTICES</tt> and
+    * <tt>#AI_SLM_DEFAULT_MAX_TRIANGLES</tt>.
+    *
+    * Note that splitting is generally a time-consuming task, but only if there's
+    * something to split. The use of this step is recommended for most users.
+    */
+    aiProcess_SplitLargeMeshes = 0x80,
+
+    // -------------------------------------------------------------------------
+    /** <hr>Removes the node graph and pre-transforms all vertices with
+    * the local transformation matrices of their nodes.
+    *
+    * The output scene still contains nodes, however there is only a
+    * root node with children, each one referencing only one mesh,
+    * and each mesh referencing one material. For rendering, you can
+    * simply render all meshes in order - you don't need to pay
+    * attention to local transformations and the node hierarchy.
+    * Animations are removed during this step.
+    * This step is intended for applications without a scenegraph.
+    * The step CAN cause some problems: if e.g. a mesh of the asset
+    * contains normals and another, using the same material index, does not,
+    * they will be brought together, but the first meshes's part of
+    * the normal list is zeroed. However, these artifacts are rare.
+    * @note The <tt>#AI_CONFIG_PP_PTV_NORMALIZE</tt> configuration property
+    * can be set to normalize the scene's spatial dimension to the -1...1
+    * range.
+    */
+    aiProcess_PreTransformVertices = 0x100,
+
+    // -------------------------------------------------------------------------
+    /** <hr>Limits the number of bones simultaneously affecting a single vertex
+    *  to a maximum value.
+    *
+    * If any vertex is affected by more than the maximum number of bones, the least
+    * important vertex weights are removed and the remaining vertex weights are
+    * renormalized so that the weights still sum up to 1.
+    * The default bone weight limit is 4 (defined as <tt>#AI_LMW_MAX_WEIGHTS</tt> in
+    * config.h), but you can use the <tt>#AI_CONFIG_PP_LBW_MAX_WEIGHTS</tt> importer
+    * property to supply your own limit to the post processing step.
+    *
+    * If you intend to perform the skinning in hardware, this post processing
+    * step might be of interest to you.
+    */
+    aiProcess_LimitBoneWeights = 0x200,
+
+    // -------------------------------------------------------------------------
+    /** <hr>Validates the imported scene data structure.
+     * This makes sure that all indices are valid, all animations and
+     * bones are linked correctly, all material references are correct .. etc.
+     *
+     * It is recommended that you capture Assimp's log output if you use this flag,
+     * so you can easily find out what's wrong if a file fails the
+     * validation. The validator is quite strict and will find *all*
+     * inconsistencies in the data structure... It is recommended that plugin
+     * developers use it to debug their loaders. There are two types of
+     * validation failures:
+     * <ul>
+     * <li>Error: There's something wrong with the imported data. Further
+     *   postprocessing is not possible and the data is not usable at all.
+     *   The import fails. #Importer::GetErrorString() or #aiGetErrorString()
+     *   carry the error message around.</li>
+     * <li>Warning: There are some minor issues (e.g. 1000000 animation
+     *   keyframes with the same time), but further postprocessing and use
+     *   of the data structure is still safe. Warning details are written
+     *   to the log file, <tt>#AI_SCENE_FLAGS_VALIDATION_WARNING</tt> is set
+     *   in #aiScene::mFlags</li>
+     * </ul>
+     *
+     * This post-processing step is not time-consuming. Its use is not
+     * compulsory, but recommended.
+    */
+    aiProcess_ValidateDataStructure = 0x400,
+
+    // -------------------------------------------------------------------------
+    /** <hr>Reorders triangles for better vertex cache locality.
+     *
+     * The step tries to improve the ACMR (average post-transform vertex cache
+     * miss ratio) for all meshes. The implementation runs in O(n) and is
+     * roughly based on the 'tipsify' algorithm (see <a href="
+     * http://www.cs.princeton.edu/gfx/pubs/Sander_2007_%3ETR/tipsy.pdf">this
+     * paper</a>).
+     *
+     * If you intend to render huge models in hardware, this step might
+     * be of interest to you. The <tt>#AI_CONFIG_PP_ICL_PTCACHE_SIZE</tt>
+     * importer property can be used to fine-tune the cache optimization.
+     */
+    aiProcess_ImproveCacheLocality = 0x800,
+
+    // -------------------------------------------------------------------------
+    /** <hr>Searches for redundant/unreferenced materials and removes them.
+     *
+     * This is especially useful in combination with the
+     * #aiProcess_PreTransformVertices and #aiProcess_OptimizeMeshes flags.
+     * Both join small meshes with equal characteristics, but they can't do
+     * their work if two meshes have different materials. Because several
+     * material settings are lost during Assimp's import filters,
+     * (and because many exporters don't check for redundant materials), huge
+     * models often have materials which are are defined several times with
+     * exactly the same settings.
+     *
+     * Several material settings not contributing to the final appearance of
+     * a surface are ignored in all comparisons (e.g. the material name).
+     * So, if you're passing additional information through the
+     * content pipeline (probably using *magic* material names), don't
+     * specify this flag. Alternatively take a look at the
+     * <tt>#AI_CONFIG_PP_RRM_EXCLUDE_LIST</tt> importer property.
+     */
+    aiProcess_RemoveRedundantMaterials = 0x1000,
+
+    // -------------------------------------------------------------------------
+    /** <hr>This step tries to determine which meshes have normal vectors
+     * that are facing inwards and inverts them.
+     *
+     * The algorithm is simple but effective:
+     * the bounding box of all vertices + their normals is compared against
+     * the volume of the bounding box of all vertices without their normals.
+     * This works well for most objects, problems might occur with planar
+     * surfaces. However, the step tries to filter such cases.
+     * The step inverts all in-facing normals. Generally it is recommended
+     * to enable this step, although the result is not always correct.
+    */
+    aiProcess_FixInfacingNormals = 0x2000,
+
+    // -------------------------------------------------------------------------
+    /** <hr>This step splits meshes with more than one primitive type in
+     *  homogeneous sub-meshes.
+     *
+     *  The step is executed after the triangulation step. After the step
+     *  returns, just one bit is set in aiMesh::mPrimitiveTypes. This is
+     *  especially useful for real-time rendering where point and line
+     *  primitives are often ignored or rendered separately.
+     *  You can use the <tt>#AI_CONFIG_PP_SBP_REMOVE</tt> importer property to
+     *  specify which primitive types you need. This can be used to easily
+     *  exclude lines and points, which are rarely used, from the import.
+    */
+    aiProcess_SortByPType = 0x8000,
+
+    // -------------------------------------------------------------------------
+    /** <hr>This step searches all meshes for degenerate primitives and
+     *  converts them to proper lines or points.
+     *
+     * A face is 'degenerate' if one or more of its points are identical.
+     * To have the degenerate stuff not only detected and collapsed but
+     * removed, try one of the following procedures:
+     * <br><b>1.</b> (if you support lines and points for rendering but don't
+     *    want the degenerates)<br>
+     * <ul>
+     *   <li>Specify the #aiProcess_FindDegenerates flag.
+     *   </li>
+     *   <li>Set the <tt>#AI_CONFIG_PP_FD_REMOVE</tt> importer property to
+     *       1. This will cause the step to remove degenerate triangles from the
+     *       import as soon as they're detected. They won't pass any further
+     *       pipeline steps.
+     *   </li>
+     * </ul>
+     * <br><b>2.</b>(if you don't support lines and points at all)<br>
+     * <ul>
+     *   <li>Specify the #aiProcess_FindDegenerates flag.
+     *   </li>
+     *   <li>Specify the #aiProcess_SortByPType flag. This moves line and
+     *     point primitives to separate meshes.
+     *   </li>
+     *   <li>Set the <tt>#AI_CONFIG_PP_SBP_REMOVE</tt> importer property to
+     *       @code aiPrimitiveType_POINTS | aiPrimitiveType_LINES
+     *       @endcode to cause SortByPType to reject point
+     *       and line meshes from the scene.
+     *   </li>
+     * </ul>
+     *
+     * This step also removes very small triangles with a surface area smaller
+     * than 10^-6. If you rely on having these small triangles, or notice holes
+     * in your model, set the property <tt>#AI_CONFIG_PP_FD_CHECKAREA</tt> to
+     * false.
+     * @note Degenerate polygons are not necessarily evil and that's why
+     * they're not removed by default. There are several file formats which
+     * don't support lines or points, and some exporters bypass the
+     * format specification and write them as degenerate triangles instead.
+    */
+    aiProcess_FindDegenerates = 0x10000,
+
+    // -------------------------------------------------------------------------
+    /** <hr>This step searches all meshes for invalid data, such as zeroed
+     *  normal vectors or invalid UV coords and removes/fixes them. This is
+     *  intended to get rid of some common exporter errors.
+     *
+     * This is especially useful for normals. If they are invalid, and
+     * the step recognizes this, they will be removed and can later
+     * be recomputed, i.e. by the #aiProcess_GenSmoothNormals flag.<br>
+     * The step will also remove meshes that are infinitely small and reduce
+     * animation tracks consisting of hundreds if redundant keys to a single
+     * key. The <tt>AI_CONFIG_PP_FID_ANIM_ACCURACY</tt> config property decides
+     * the accuracy of the check for duplicate animation tracks.
+    */
+    aiProcess_FindInvalidData = 0x20000,
+
+    // -------------------------------------------------------------------------
+    /** <hr>This step converts non-UV mappings (such as spherical or
+     *  cylindrical mapping) to proper texture coordinate channels.
+     *
+     * Most applications will support UV mapping only, so you will
+     * probably want to specify this step in every case. Note that Assimp is not
+     * always able to match the original mapping implementation of the
+     * 3D app which produced a model perfectly. It's always better to let the
+     * modelling app compute the UV channels - 3ds max, Maya, Blender,
+     * LightWave, and Modo do this for example.
+     *
+     * @note If this step is not requested, you'll need to process the
+     * <tt>#AI_MATKEY_MAPPING</tt> material property in order to display all assets
+     * properly.
+     */
+    aiProcess_GenUVCoords = 0x40000,
+
+    // -------------------------------------------------------------------------
+    /** <hr>This step applies per-texture UV transformations and bakes
+     *  them into stand-alone vtexture coordinate channels.
+     *
+     * UV transformations are specified per-texture - see the
+     * <tt>#AI_MATKEY_UVTRANSFORM</tt> material key for more information.
+     * This step processes all textures with
+     * transformed input UV coordinates and generates a new (pre-transformed) UV channel
+     * which replaces the old channel. Most applications won't support UV
+     * transformations, so you will probably want to specify this step.
+     *
+     * @note UV transformations are usually implemented in real-time apps by
+     * transforming texture coordinates at vertex shader stage with a 3x3
+     * (homogenous) transformation matrix.
+    */
+    aiProcess_TransformUVCoords = 0x80000,
+
+    // -------------------------------------------------------------------------
+    /** <hr>This step searches for duplicate meshes and replaces them
+     *  with references to the first mesh.
+     *
+     *  This step takes a while, so don't use it if speed is a concern.
+     *  Its main purpose is to workaround the fact that many export
+     *  file formats don't support instanced meshes, so exporters need to
+     *  duplicate meshes. This step removes the duplicates again. Please
+     *  note that Assimp does not currently support per-node material
+     *  assignment to meshes, which means that identical meshes with
+     *  different materials are currently *not* joined, although this is
+     *  planned for future versions.
+     */
+    aiProcess_FindInstances = 0x100000,
+
+    // -------------------------------------------------------------------------
+    /** <hr>A postprocessing step to reduce the number of meshes.
+     *
+     *  This will, in fact, reduce the number of draw calls.
+     *
+     *  This is a very effective optimization and is recommended to be used
+     *  together with #aiProcess_OptimizeGraph, if possible. The flag is fully
+     *  compatible with both #aiProcess_SplitLargeMeshes and #aiProcess_SortByPType.
+    */
+    aiProcess_OptimizeMeshes  = 0x200000,
+
+
+    // -------------------------------------------------------------------------
+    /** <hr>A postprocessing step to optimize the scene hierarchy.
+     *
+     *  Nodes without animations, bones, lights or cameras assigned are
+     *  collapsed and joined.
+     *
+     *  Node names can be lost during this step. If you use special 'tag nodes'
+     *  to pass additional information through your content pipeline, use the
+     *  <tt>#AI_CONFIG_PP_OG_EXCLUDE_LIST</tt> importer property to specify a
+     *  list of node names you want to be kept. Nodes matching one of the names
+     *  in this list won't be touched or modified.
+     *
+     *  Use this flag with caution. Most simple files will be collapsed to a
+     *  single node, so complex hierarchies are usually completely lost. This is not
+     *  useful for editor environments, but probably a very effective
+     *  optimization if you just want to get the model data, convert it to your
+     *  own format, and render it as fast as possible.
+     *
+     *  This flag is designed to be used with #aiProcess_OptimizeMeshes for best
+     *  results.
+     *
+     *  @note 'Crappy' scenes with thousands of extremely small meshes packed
+     *  in deeply nested nodes exist for almost all file formats.
+     *  #aiProcess_OptimizeMeshes in combination with #aiProcess_OptimizeGraph
+     *  usually fixes them all and makes them renderable.
+    */
+    aiProcess_OptimizeGraph  = 0x400000,
+
+    // -------------------------------------------------------------------------
+    /** <hr>This step flips all UV coordinates along the y-axis and adjusts
+     * material settings and bitangents accordingly.
+     *
+     * <b>Output UV coordinate system:</b>
+     * @code
+     * 0y|0y ---------- 1x|0y
+     * |                 |
+     * |                 |
+     * |                 |
+     * 0x|1y ---------- 1x|1y
+     * @endcode
+     *
+     * You'll probably want to consider this flag if you use Direct3D for
+     * rendering. The #aiProcess_ConvertToLeftHanded flag supersedes this
+     * setting and bundles all conversions typically required for D3D-based
+     * applications.
+    */
+    aiProcess_FlipUVs = 0x800000,
+
+    // -------------------------------------------------------------------------
+    /** <hr>This step adjusts the output face winding order to be CW.
+     *
+     * The default face winding order is counter clockwise (CCW).
+     *
+     * <b>Output face order:</b>
+     * @code
+     *       x2
+     *
+     *                         x0
+     *  x1
+     * @endcode
+    */
+    aiProcess_FlipWindingOrder  = 0x1000000,
+
+    // -------------------------------------------------------------------------
+    /** <hr>This step splits meshes with many bones into sub-meshes so that each
+     * su-bmesh has fewer or as many bones as a given limit.
+    */
+    aiProcess_SplitByBoneCount  = 0x2000000,
+
+    // -------------------------------------------------------------------------
+    /** <hr>This step removes bones losslessly or according to some threshold.
+     *
+     *  In some cases (i.e. formats that require it) exporters are forced to
+     *  assign dummy bone weights to otherwise static meshes assigned to
+     *  animated meshes. Full, weight-based skinning is expensive while
+     *  animating nodes is extremely cheap, so this step is offered to clean up
+     *  the data in that regard.
+     *
+     *  Use <tt>#AI_CONFIG_PP_DB_THRESHOLD</tt> to control this.
+     *  Use <tt>#AI_CONFIG_PP_DB_ALL_OR_NONE</tt> if you want bones removed if and
+     *  only if all bones within the scene qualify for removal.
+    */
+    aiProcess_Debone  = 0x4000000,
+
+    // -------------------------------------------------------------------------
+    /** <hr>This step will perform a global scale of the model.
+    *
+    *  Some importers are providing a mechanism to define a scaling unit for the
+    *  model. This post processing step can be used to do so. You need to get the
+    *  global scaling from your importer settings like in FBX. Use the flag
+    *  AI_CONFIG_GLOBAL_SCALE_FACTOR_KEY from the global property table to configure this.
+    *
+    *  Use <tt>#AI_CONFIG_GLOBAL_SCALE_FACTOR_KEY</tt> to setup the global scaing factor.
+    */
+    aiProcess_GlobalScale = 0x8000000,
+
+    // -------------------------------------------------------------------------
+    /** <hr>A postprocessing step to embed of textures.
+     *
+     *  This will remove external data dependencies for textures.
+     *  If a texture's file does not exist at the specified path
+     *  (due, for instance, to an absolute path generated on another system),
+     *  it will check if a file with the same name exists at the root folder
+     *  of the imported model. And if so, it uses that.
+     */
+    aiProcess_EmbedTextures  = 0x10000000,
+
+    // aiProcess_GenEntityMeshes = 0x100000,
+    // aiProcess_OptimizeAnimations = 0x200000
+    // aiProcess_FixTexturePaths = 0x200000
+};
+
+
+// ---------------------------------------------------------------------------------------
+/** @def aiProcess_ConvertToLeftHanded
+ *  @brief Shortcut flag for Direct3D-based applications.
+ *
+ *  Supersedes the #aiProcess_MakeLeftHanded and #aiProcess_FlipUVs and
+ *  #aiProcess_FlipWindingOrder flags.
+ *  The output data matches Direct3D's conventions: left-handed geometry, upper-left
+ *  origin for UV coordinates and finally clockwise face order, suitable for CCW culling.
+ *
+ *  @deprecated
+ */
+#define aiProcess_ConvertToLeftHanded ( \
+    aiProcess_MakeLeftHanded     | \
+    aiProcess_FlipUVs            | \
+    aiProcess_FlipWindingOrder   | \
+    0 )
+
+
+// ---------------------------------------------------------------------------------------
+/** @def aiProcessPreset_TargetRealtime_Fast
+ *  @brief Default postprocess configuration optimizing the data for real-time rendering.
+ *
+ *  Applications would want to use this preset to load models on end-user PCs,
+ *  maybe for direct use in game.
+ *
+ * If you're using DirectX, don't forget to combine this value with
+ * the #aiProcess_ConvertToLeftHanded step. If you don't support UV transformations
+ * in your application apply the #aiProcess_TransformUVCoords step, too.
+ *  @note Please take the time to read the docs for the steps enabled by this preset.
+ *  Some of them offer further configurable properties, while some of them might not be of
+ *  use for you so it might be better to not specify them.
+ */
+#define aiProcessPreset_TargetRealtime_Fast ( \
+    aiProcess_CalcTangentSpace      |  \
+    aiProcess_GenNormals            |  \
+    aiProcess_JoinIdenticalVertices |  \
+    aiProcess_Triangulate           |  \
+    aiProcess_GenUVCoords           |  \
+    aiProcess_SortByPType           |  \
+    0 )
+
+ // ---------------------------------------------------------------------------------------
+ /** @def aiProcessPreset_TargetRealtime_Quality
+  *  @brief Default postprocess configuration optimizing the data for real-time rendering.
+  *
+  *  Unlike #aiProcessPreset_TargetRealtime_Fast, this configuration
+  *  performs some extra optimizations to improve rendering speed and
+  *  to minimize memory usage. It could be a good choice for a level editor
+  *  environment where import speed is not so important.
+  *
+  *  If you're using DirectX, don't forget to combine this value with
+  *  the #aiProcess_ConvertToLeftHanded step. If you don't support UV transformations
+  *  in your application apply the #aiProcess_TransformUVCoords step, too.
+  *  @note Please take the time to read the docs for the steps enabled by this preset.
+  *  Some of them offer further configurable properties, while some of them might not be
+  *  of use for you so it might be better to not specify them.
+  */
+#define aiProcessPreset_TargetRealtime_Quality ( \
+    aiProcess_CalcTangentSpace              |  \
+    aiProcess_GenSmoothNormals              |  \
+    aiProcess_JoinIdenticalVertices         |  \
+    aiProcess_ImproveCacheLocality          |  \
+    aiProcess_LimitBoneWeights              |  \
+    aiProcess_RemoveRedundantMaterials      |  \
+    aiProcess_SplitLargeMeshes              |  \
+    aiProcess_Triangulate                   |  \
+    aiProcess_GenUVCoords                   |  \
+    aiProcess_SortByPType                   |  \
+    aiProcess_FindDegenerates               |  \
+    aiProcess_FindInvalidData               |  \
+    0 )
+
+ // ---------------------------------------------------------------------------------------
+ /** @def aiProcessPreset_TargetRealtime_MaxQuality
+  *  @brief Default postprocess configuration optimizing the data for real-time rendering.
+  *
+  *  This preset enables almost every optimization step to achieve perfectly
+  *  optimized data. It's your choice for level editor environments where import speed
+  *  is not important.
+  *
+  *  If you're using DirectX, don't forget to combine this value with
+  *  the #aiProcess_ConvertToLeftHanded step. If you don't support UV transformations
+  *  in your application, apply the #aiProcess_TransformUVCoords step, too.
+  *  @note Please take the time to read the docs for the steps enabled by this preset.
+  *  Some of them offer further configurable properties, while some of them might not be
+  *  of use for you so it might be better to not specify them.
+  */
+#define aiProcessPreset_TargetRealtime_MaxQuality ( \
+    aiProcessPreset_TargetRealtime_Quality   |  \
+    aiProcess_FindInstances                  |  \
+    aiProcess_ValidateDataStructure          |  \
+    aiProcess_OptimizeMeshes                 |  \
+    0 )
+
+
+#ifdef __cplusplus
+} // end of extern "C"
+#endif
+
+#endif // AI_POSTPROCESS_H_INC
diff --git a/engine/inc/assimp/qnan.h b/engine/inc/assimp/qnan.h
new file mode 100644
index 00000000..6ee3b7ce
--- /dev/null
+++ b/engine/inc/assimp/qnan.h
@@ -0,0 +1,157 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/**  @file  qnan.h
+ *   @brief Some utilities for our dealings with qnans.
+ *
+ *   @note Some loaders use qnans to mark invalid values tempoarily, also
+ *     Assimp explicitly enforces undefined normals to be set to qnan.
+ *     qnan utilities are available in standard libraries (C99 for example)
+ *     but last time I checked compiler coverage was so bad that I decided
+ *     to reinvent the wheel.
+ */
+
+#ifndef AI_QNAN_H_INCLUDED
+#define AI_QNAN_H_INCLUDED
+
+#include <assimp/defs.h>
+#include <limits>
+#include <stdint.h>
+
+// ---------------------------------------------------------------------------
+/** Data structure to represent the bit pattern of a 32 Bit
+ *         IEEE 754 floating-point number. */
+union _IEEESingle
+{
+    float Float;
+    struct
+    {
+        uint32_t Frac : 23;
+        uint32_t Exp  : 8;
+        uint32_t Sign : 1;
+    } IEEE;
+};
+
+// ---------------------------------------------------------------------------
+/** Data structure to represent the bit pattern of a 64 Bit
+ *         IEEE 754 floating-point number. */
+union _IEEEDouble
+{
+    double Double;
+    struct
+    {
+        uint64_t Frac : 52;
+        uint64_t Exp  : 11;
+        uint64_t Sign : 1;
+    } IEEE;
+};
+
+// ---------------------------------------------------------------------------
+/** Check whether a given float is qNaN.
+ *  @param in Input value */
+AI_FORCE_INLINE bool is_qnan(float in)
+{
+    // the straightforward solution does not work:
+    //   return (in != in);
+    // compiler generates code like this
+    //   load <in> to <register-with-different-width>
+    //   compare <register-with-different-width> against <in>
+
+    // FIXME: Use <float> stuff instead? I think fpclassify needs C99
+    return (reinterpret_cast<_IEEESingle*>(&in)->IEEE.Exp == (1u << 8)-1 &&
+        reinterpret_cast<_IEEESingle*>(&in)->IEEE.Frac);
+}
+
+// ---------------------------------------------------------------------------
+/** Check whether a given double is qNaN.
+ *  @param in Input value */
+AI_FORCE_INLINE bool is_qnan(double in)
+{
+    // the straightforward solution does not work:
+    //   return (in != in);
+    // compiler generates code like this
+    //   load <in> to <register-with-different-width>
+    //   compare <register-with-different-width> against <in>
+
+    // FIXME: Use <float> stuff instead? I think fpclassify needs C99
+    return (reinterpret_cast<_IEEEDouble*>(&in)->IEEE.Exp == (1u << 11)-1 &&
+        reinterpret_cast<_IEEEDouble*>(&in)->IEEE.Frac);
+}
+
+// ---------------------------------------------------------------------------
+/** @brief check whether a float is either NaN or (+/-) INF.
+ *
+ *  Denorms return false, they're treated like normal values.
+ *  @param in Input value */
+AI_FORCE_INLINE bool is_special_float(float in)
+{
+    return (reinterpret_cast<_IEEESingle*>(&in)->IEEE.Exp == (1u << 8)-1);
+}
+
+// ---------------------------------------------------------------------------
+/** @brief check whether a double is either NaN or (+/-) INF.
+ *
+ *  Denorms return false, they're treated like normal values.
+ *  @param in Input value */
+AI_FORCE_INLINE bool is_special_float(double in)
+{
+    return (reinterpret_cast<_IEEEDouble*>(&in)->IEEE.Exp == (1u << 11)-1);
+}
+
+// ---------------------------------------------------------------------------
+/** Check whether a float is NOT qNaN.
+ *  @param in Input value */
+template<class TReal>
+AI_FORCE_INLINE bool is_not_qnan(TReal in)
+{
+    return !is_qnan(in);
+}
+
+// ---------------------------------------------------------------------------
+/** @brief Get a fresh qnan.  */
+AI_FORCE_INLINE ai_real get_qnan()
+{
+    return std::numeric_limits<ai_real>::quiet_NaN();
+}
+
+#endif // !! AI_QNAN_H_INCLUDED
diff --git a/engine/inc/assimp/quaternion.h b/engine/inc/assimp/quaternion.h
new file mode 100644
index 00000000..3c8ab50a
--- /dev/null
+++ b/engine/inc/assimp/quaternion.h
@@ -0,0 +1,130 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file quaternion.h
+ *  @brief Quaternion structure, including operators when compiling in C++
+ */
+#pragma once
+#ifndef AI_QUATERNION_H_INC
+#define AI_QUATERNION_H_INC
+
+#ifdef __cplusplus
+
+#include "defs.h"
+
+template <typename TReal> class aiVector3t;
+template <typename TReal> class aiMatrix3x3t;
+
+// ---------------------------------------------------------------------------
+/** Represents a quaternion in a 4D vector. */
+template <typename TReal>
+class aiQuaterniont
+{
+public:
+    aiQuaterniont() : w(1.0), x(), y(), z() {}
+    aiQuaterniont(TReal pw, TReal px, TReal py, TReal pz)
+        : w(pw), x(px), y(py), z(pz) {}
+
+    /** Construct from rotation matrix. Result is undefined if the matrix is not orthonormal. */
+    explicit aiQuaterniont( const aiMatrix3x3t<TReal>& pRotMatrix);
+
+    /** Construct from euler angles */
+    aiQuaterniont( TReal rotx, TReal roty, TReal rotz);
+
+    /** Construct from an axis-angle pair */
+    aiQuaterniont( aiVector3t<TReal> axis, TReal angle);
+
+    /** Construct from a normalized quaternion stored in a vec3 */
+    explicit aiQuaterniont( aiVector3t<TReal> normalized);
+
+    /** Returns a matrix representation of the quaternion */
+    aiMatrix3x3t<TReal> GetMatrix() const;
+
+public:
+
+    bool operator== (const aiQuaterniont& o) const;
+    bool operator!= (const aiQuaterniont& o) const;
+
+    bool Equal(const aiQuaterniont& o, TReal epsilon = 1e-6) const;
+
+public:
+
+    /** Normalize the quaternion */
+    aiQuaterniont& Normalize();
+
+    /** Compute quaternion conjugate */
+    aiQuaterniont& Conjugate ();
+
+    /** Rotate a point by this quaternion */
+    aiVector3t<TReal> Rotate (const aiVector3t<TReal>& in);
+
+    /** Multiply two quaternions */
+    aiQuaterniont operator* (const aiQuaterniont& two) const;
+
+public:
+
+    /** Performs a spherical interpolation between two quaternions and writes the result into the third.
+     * @param pOut Target object to received the interpolated rotation.
+     * @param pStart Start rotation of the interpolation at factor == 0.
+     * @param pEnd End rotation, factor == 1.
+     * @param pFactor Interpolation factor between 0 and 1. Values outside of this range yield undefined results.
+     */
+    static void Interpolate( aiQuaterniont& pOut, const aiQuaterniont& pStart,
+        const aiQuaterniont& pEnd, TReal pFactor);
+
+public:
+
+    //! w,x,y,z components of the quaternion
+    TReal w, x, y, z;
+} ;
+
+typedef aiQuaterniont<ai_real> aiQuaternion;
+
+#else
+
+struct aiQuaternion {
+    ai_real w, x, y, z;
+};
+
+#endif
+
+#endif // AI_QUATERNION_H_INC
diff --git a/engine/inc/assimp/quaternion.inl b/engine/inc/assimp/quaternion.inl
new file mode 100644
index 00000000..0a2c9293
--- /dev/null
+++ b/engine/inc/assimp/quaternion.inl
@@ -0,0 +1,286 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file  quaternion.inl
+ *  @brief Inline implementation of aiQuaterniont<TReal> operators
+ */
+#pragma once
+#ifndef AI_QUATERNION_INL_INC
+#define AI_QUATERNION_INL_INC
+
+#ifdef __cplusplus
+#include "quaternion.h"
+
+#include <cmath>
+
+// ---------------------------------------------------------------------------
+template<typename TReal>
+bool aiQuaterniont<TReal>::operator== (const aiQuaterniont& o) const
+{
+    return x == o.x && y == o.y && z == o.z && w == o.w;
+}
+
+// ---------------------------------------------------------------------------
+template<typename TReal>
+bool aiQuaterniont<TReal>::operator!= (const aiQuaterniont& o) const
+{
+    return !(*this == o);
+}
+
+// ---------------------------------------------------------------------------
+template<typename TReal>
+inline bool aiQuaterniont<TReal>::Equal(const aiQuaterniont& o, TReal epsilon) const {
+    return
+        std::abs(x - o.x) <= epsilon &&
+        std::abs(y - o.y) <= epsilon &&
+        std::abs(z - o.z) <= epsilon &&
+        std::abs(w - o.w) <= epsilon;
+}
+
+// ---------------------------------------------------------------------------
+// Constructs a quaternion from a rotation matrix
+template<typename TReal>
+inline aiQuaterniont<TReal>::aiQuaterniont( const aiMatrix3x3t<TReal> &pRotMatrix)
+{
+    TReal t = pRotMatrix.a1 + pRotMatrix.b2 + pRotMatrix.c3;
+
+    // large enough
+    if( t > static_cast<TReal>(0))
+    {
+        TReal s = std::sqrt(1 + t) * static_cast<TReal>(2.0);
+        x = (pRotMatrix.c2 - pRotMatrix.b3) / s;
+        y = (pRotMatrix.a3 - pRotMatrix.c1) / s;
+        z = (pRotMatrix.b1 - pRotMatrix.a2) / s;
+        w = static_cast<TReal>(0.25) * s;
+    } // else we have to check several cases
+    else if( pRotMatrix.a1 > pRotMatrix.b2 && pRotMatrix.a1 > pRotMatrix.c3 )
+    {
+        // Column 0:
+        TReal s = std::sqrt( static_cast<TReal>(1.0) + pRotMatrix.a1 - pRotMatrix.b2 - pRotMatrix.c3) * static_cast<TReal>(2.0);
+        x = static_cast<TReal>(0.25) * s;
+        y = (pRotMatrix.b1 + pRotMatrix.a2) / s;
+        z = (pRotMatrix.a3 + pRotMatrix.c1) / s;
+        w = (pRotMatrix.c2 - pRotMatrix.b3) / s;
+    }
+    else if( pRotMatrix.b2 > pRotMatrix.c3)
+    {
+        // Column 1:
+        TReal s = std::sqrt( static_cast<TReal>(1.0) + pRotMatrix.b2 - pRotMatrix.a1 - pRotMatrix.c3) * static_cast<TReal>(2.0);
+        x = (pRotMatrix.b1 + pRotMatrix.a2) / s;
+        y = static_cast<TReal>(0.25) * s;
+        z = (pRotMatrix.c2 + pRotMatrix.b3) / s;
+        w = (pRotMatrix.a3 - pRotMatrix.c1) / s;
+    } else
+    {
+        // Column 2:
+        TReal s = std::sqrt( static_cast<TReal>(1.0) + pRotMatrix.c3 - pRotMatrix.a1 - pRotMatrix.b2) * static_cast<TReal>(2.0);
+        x = (pRotMatrix.a3 + pRotMatrix.c1) / s;
+        y = (pRotMatrix.c2 + pRotMatrix.b3) / s;
+        z = static_cast<TReal>(0.25) * s;
+        w = (pRotMatrix.b1 - pRotMatrix.a2) / s;
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Construction from euler angles
+template<typename TReal>
+inline aiQuaterniont<TReal>::aiQuaterniont( TReal fPitch, TReal fYaw, TReal fRoll )
+{
+    const TReal fSinPitch(std::sin(fPitch*static_cast<TReal>(0.5)));
+    const TReal fCosPitch(std::cos(fPitch*static_cast<TReal>(0.5)));
+    const TReal fSinYaw(std::sin(fYaw*static_cast<TReal>(0.5)));
+    const TReal fCosYaw(std::cos(fYaw*static_cast<TReal>(0.5)));
+    const TReal fSinRoll(std::sin(fRoll*static_cast<TReal>(0.5)));
+    const TReal fCosRoll(std::cos(fRoll*static_cast<TReal>(0.5)));
+    const TReal fCosPitchCosYaw(fCosPitch*fCosYaw);
+    const TReal fSinPitchSinYaw(fSinPitch*fSinYaw);
+    x = fSinRoll * fCosPitchCosYaw     - fCosRoll * fSinPitchSinYaw;
+    y = fCosRoll * fSinPitch * fCosYaw + fSinRoll * fCosPitch * fSinYaw;
+    z = fCosRoll * fCosPitch * fSinYaw - fSinRoll * fSinPitch * fCosYaw;
+    w = fCosRoll * fCosPitchCosYaw     + fSinRoll * fSinPitchSinYaw;
+}
+
+// ---------------------------------------------------------------------------
+// Returns a matrix representation of the quaternion
+template<typename TReal>
+inline aiMatrix3x3t<TReal> aiQuaterniont<TReal>::GetMatrix() const
+{
+    aiMatrix3x3t<TReal> resMatrix;
+    resMatrix.a1 = static_cast<TReal>(1.0) - static_cast<TReal>(2.0) * (y * y + z * z);
+    resMatrix.a2 = static_cast<TReal>(2.0) * (x * y - z * w);
+    resMatrix.a3 = static_cast<TReal>(2.0) * (x * z + y * w);
+    resMatrix.b1 = static_cast<TReal>(2.0) * (x * y + z * w);
+    resMatrix.b2 = static_cast<TReal>(1.0) - static_cast<TReal>(2.0) * (x * x + z * z);
+    resMatrix.b3 = static_cast<TReal>(2.0) * (y * z - x * w);
+    resMatrix.c1 = static_cast<TReal>(2.0) * (x * z - y * w);
+    resMatrix.c2 = static_cast<TReal>(2.0) * (y * z + x * w);
+    resMatrix.c3 = static_cast<TReal>(1.0) - static_cast<TReal>(2.0) * (x * x + y * y);
+
+    return resMatrix;
+}
+
+// ---------------------------------------------------------------------------
+// Construction from an axis-angle pair
+template<typename TReal>
+inline aiQuaterniont<TReal>::aiQuaterniont( aiVector3t<TReal> axis, TReal angle)
+{
+    axis.Normalize();
+
+    const TReal sin_a = std::sin( angle / 2 );
+    const TReal cos_a = std::cos( angle / 2 );
+    x    = axis.x * sin_a;
+    y    = axis.y * sin_a;
+    z    = axis.z * sin_a;
+    w    = cos_a;
+}
+// ---------------------------------------------------------------------------
+// Construction from am existing, normalized quaternion
+template<typename TReal>
+inline aiQuaterniont<TReal>::aiQuaterniont( aiVector3t<TReal> normalized)
+{
+    x = normalized.x;
+    y = normalized.y;
+    z = normalized.z;
+
+    const TReal t = static_cast<TReal>(1.0) - (x*x) - (y*y) - (z*z);
+
+    if (t < static_cast<TReal>(0.0)) {
+        w = static_cast<TReal>(0.0);
+    }
+    else w = std::sqrt (t);
+}
+
+// ---------------------------------------------------------------------------
+// Performs a spherical interpolation between two quaternions
+// Implementation adopted from the gmtl project. All others I found on the net fail in some cases.
+// Congrats, gmtl!
+template<typename TReal>
+inline void aiQuaterniont<TReal>::Interpolate( aiQuaterniont& pOut, const aiQuaterniont& pStart, const aiQuaterniont& pEnd, TReal pFactor)
+{
+    // calc cosine theta
+    TReal cosom = pStart.x * pEnd.x + pStart.y * pEnd.y + pStart.z * pEnd.z + pStart.w * pEnd.w;
+
+    // adjust signs (if necessary)
+    aiQuaterniont end = pEnd;
+    if( cosom < static_cast<TReal>(0.0))
+    {
+        cosom = -cosom;
+        end.x = -end.x;   // Reverse all signs
+        end.y = -end.y;
+        end.z = -end.z;
+        end.w = -end.w;
+    }
+
+    // Calculate coefficients
+    TReal sclp, sclq;
+    if( (static_cast<TReal>(1.0) - cosom) > static_cast<TReal>(0.0001)) // 0.0001 -> some epsillon
+    {
+        // Standard case (slerp)
+        TReal omega, sinom;
+        omega = std::acos( cosom); // extract theta from dot product's cos theta
+        sinom = std::sin( omega);
+        sclp  = std::sin( (static_cast<TReal>(1.0) - pFactor) * omega) / sinom;
+        sclq  = std::sin( pFactor * omega) / sinom;
+    } else
+    {
+        // Very close, do linear interp (because it's faster)
+        sclp = static_cast<TReal>(1.0) - pFactor;
+        sclq = pFactor;
+    }
+
+    pOut.x = sclp * pStart.x + sclq * end.x;
+    pOut.y = sclp * pStart.y + sclq * end.y;
+    pOut.z = sclp * pStart.z + sclq * end.z;
+    pOut.w = sclp * pStart.w + sclq * end.w;
+}
+
+// ---------------------------------------------------------------------------
+template<typename TReal>
+inline aiQuaterniont<TReal>& aiQuaterniont<TReal>::Normalize()
+{
+    // compute the magnitude and divide through it
+    const TReal mag = std::sqrt(x*x + y*y + z*z + w*w);
+    if (mag)
+    {
+        const TReal invMag = static_cast<TReal>(1.0)/mag;
+        x *= invMag;
+        y *= invMag;
+        z *= invMag;
+        w *= invMag;
+    }
+    return *this;
+}
+
+// ---------------------------------------------------------------------------
+template<typename TReal>
+inline aiQuaterniont<TReal> aiQuaterniont<TReal>::operator* (const aiQuaterniont& t) const
+{
+    return aiQuaterniont(w*t.w - x*t.x - y*t.y - z*t.z,
+        w*t.x + x*t.w + y*t.z - z*t.y,
+        w*t.y + y*t.w + z*t.x - x*t.z,
+        w*t.z + z*t.w + x*t.y - y*t.x);
+}
+
+// ---------------------------------------------------------------------------
+template<typename TReal>
+inline aiQuaterniont<TReal>& aiQuaterniont<TReal>::Conjugate ()
+{
+    x = -x;
+    y = -y;
+    z = -z;
+    return *this;
+}
+
+// ---------------------------------------------------------------------------
+template<typename TReal>
+inline aiVector3t<TReal> aiQuaterniont<TReal>::Rotate (const aiVector3t<TReal>& v)
+{
+    aiQuaterniont q2(0.f,v.x,v.y,v.z), q = *this, qinv = q;
+    qinv.Conjugate();
+
+    q = q*q2*qinv;
+    return aiVector3t<TReal>(q.x,q.y,q.z);
+}
+
+#endif
+#endif // AI_QUATERNION_INL_INC
diff --git a/engine/inc/assimp/scene.h b/engine/inc/assimp/scene.h
new file mode 100644
index 00000000..867e87de
--- /dev/null
+++ b/engine/inc/assimp/scene.h
@@ -0,0 +1,416 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file scene.h
+ *  @brief Defines the data structures in which the imported scene is returned.
+ */
+#pragma once
+#ifndef AI_SCENE_H_INC
+#define AI_SCENE_H_INC
+
+#include "types.h"
+#include "texture.h"
+#include "mesh.h"
+#include "light.h"
+#include "camera.h"
+#include "material.h"
+#include "anim.h"
+#include "metadata.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wattributes"
+#endif
+
+// -------------------------------------------------------------------------------
+/** 
+ * A node in the imported hierarchy.
+ *
+ * Each node has name, a parent node (except for the root node),
+ * a transformation relative to its parent and possibly several child nodes.
+ * Simple file formats don't support hierarchical structures - for these formats
+ * the imported scene does consist of only a single root node without children.
+ */
+// -------------------------------------------------------------------------------
+struct ASSIMP_API aiNode
+{
+    /** The name of the node.
+     *
+     * The name might be empty (length of zero) but all nodes which
+     * need to be referenced by either bones or animations are named.
+     * Multiple nodes may have the same name, except for nodes which are referenced
+     * by bones (see #aiBone and #aiMesh::mBones). Their names *must* be unique.
+     *
+     * Cameras and lights reference a specific node by name - if there
+     * are multiple nodes with this name, they are assigned to each of them.
+     * <br>
+     * There are no limitations with regard to the characters contained in
+     * the name string as it is usually taken directly from the source file.
+     *
+     * Implementations should be able to handle tokens such as whitespace, tabs,
+     * line feeds, quotation marks, ampersands etc.
+     *
+     * Sometimes assimp introduces new nodes not present in the source file
+     * into the hierarchy (usually out of necessity because sometimes the
+     * source hierarchy format is simply not compatible). Their names are
+     * surrounded by @verbatim <> @endverbatim e.g.
+     *  @verbatim<DummyRootNode> @endverbatim.
+     */
+    C_STRUCT aiString mName;
+
+    /** The transformation relative to the node's parent. */
+    C_STRUCT aiMatrix4x4 mTransformation;
+
+    /** Parent node. NULL if this node is the root node. */
+    C_STRUCT aiNode* mParent;
+
+    /** The number of child nodes of this node. */
+    unsigned int mNumChildren;
+
+    /** The child nodes of this node. NULL if mNumChildren is 0. */
+    C_STRUCT aiNode** mChildren;
+
+    /** The number of meshes of this node. */
+    unsigned int mNumMeshes;
+
+    /** The meshes of this node. Each entry is an index into the
+      * mesh list of the #aiScene.
+      */
+    unsigned int* mMeshes;
+
+    /** Metadata associated with this node or NULL if there is no metadata.
+      *  Whether any metadata is generated depends on the source file format. See the
+      * @link importer_notes @endlink page for more information on every source file
+      * format. Importers that don't document any metadata don't write any.
+      */
+    C_STRUCT aiMetadata* mMetaData;
+
+#ifdef __cplusplus
+    /** Constructor */
+    aiNode();
+
+    /** Construction from a specific name */
+    explicit aiNode(const std::string& name);
+
+    /** Destructor */
+    ~aiNode();
+
+    /** Searches for a node with a specific name, beginning at this
+     *  nodes. Normally you will call this method on the root node
+     *  of the scene.
+     *
+     *  @param name Name to search for
+     *  @return NULL or a valid Node if the search was successful.
+     */
+    inline 
+    const aiNode* FindNode(const aiString& name) const {
+        return FindNode(name.data);
+    }
+
+    inline 
+    aiNode* FindNode(const aiString& name) {
+        return FindNode(name.data);
+    }
+
+    const aiNode* FindNode(const char* name) const;
+
+    aiNode* FindNode(const char* name);
+
+    /**
+     * @brief   Will add new children.
+     * @param   numChildren  Number of children to add.
+     * @param   children     The array with pointers showing to the children.
+     */
+    void addChildren(unsigned int numChildren, aiNode **children);
+#endif // __cplusplus
+};
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
+// -------------------------------------------------------------------------------
+/**
+ * Specifies that the scene data structure that was imported is not complete.
+ * This flag bypasses some internal validations and allows the import
+ * of animation skeletons, material libraries or camera animation paths
+ * using Assimp. Most applications won't support such data.
+ */
+#define AI_SCENE_FLAGS_INCOMPLETE   0x1
+
+/**
+ * This flag is set by the validation postprocess-step (aiPostProcess_ValidateDS)
+ * if the validation is successful. In a validated scene you can be sure that
+ * any cross references in the data structure (e.g. vertex indices) are valid.
+ */
+#define AI_SCENE_FLAGS_VALIDATED    0x2
+
+/**
+ * This flag is set by the validation postprocess-step (aiPostProcess_ValidateDS)
+ * if the validation is successful but some issues have been found.
+ * This can for example mean that a texture that does not exist is referenced
+ * by a material or that the bone weights for a vertex don't sum to 1.0 ... .
+ * In most cases you should still be able to use the import. This flag could
+ * be useful for applications which don't capture Assimp's log output.
+ */
+#define AI_SCENE_FLAGS_VALIDATION_WARNING   0x4
+
+/**
+ * This flag is currently only set by the aiProcess_JoinIdenticalVertices step.
+ * It indicates that the vertices of the output meshes aren't in the internal
+ * verbose format anymore. In the verbose format all vertices are unique,
+ * no vertex is ever referenced by more than one face.
+ */
+#define AI_SCENE_FLAGS_NON_VERBOSE_FORMAT   0x8
+
+ /**
+ * Denotes pure height-map terrain data. Pure terrains usually consist of quads,
+ * sometimes triangles, in a regular grid. The x,y coordinates of all vertex
+ * positions refer to the x,y coordinates on the terrain height map, the z-axis
+ * stores the elevation at a specific point.
+ *
+ * TER (Terragen) and HMP (3D Game Studio) are height map formats.
+ * @note Assimp is probably not the best choice for loading *huge* terrains -
+ * fully triangulated data takes extremely much free store and should be avoided
+ * as long as possible (typically you'll do the triangulation when you actually
+ * need to render it).
+ */
+#define AI_SCENE_FLAGS_TERRAIN 0x10
+
+ /**
+ * Specifies that the scene data can be shared between structures. For example:
+ * one vertex in few faces. \ref AI_SCENE_FLAGS_NON_VERBOSE_FORMAT can not be
+ * used for this because \ref AI_SCENE_FLAGS_NON_VERBOSE_FORMAT has internal
+ * meaning about postprocessing steps.
+ */
+#define AI_SCENE_FLAGS_ALLOW_SHARED			0x20
+
+// -------------------------------------------------------------------------------
+/** The root structure of the imported data.
+ *
+ *  Everything that was imported from the given file can be accessed from here.
+ *  Objects of this class are generally maintained and owned by Assimp, not
+ *  by the caller. You shouldn't want to instance it, nor should you ever try to
+ *  delete a given scene on your own.
+ */
+// -------------------------------------------------------------------------------
+struct aiScene
+{
+    /** Any combination of the AI_SCENE_FLAGS_XXX flags. By default
+    * this value is 0, no flags are set. Most applications will
+    * want to reject all scenes with the AI_SCENE_FLAGS_INCOMPLETE
+    * bit set.
+    */
+    unsigned int mFlags;
+
+    /** The root node of the hierarchy.
+    *
+    * There will always be at least the root node if the import
+    * was successful (and no special flags have been set).
+    * Presence of further nodes depends on the format and content
+    * of the imported file.
+    */
+    C_STRUCT aiNode* mRootNode;
+
+    /** The number of meshes in the scene. */
+    unsigned int mNumMeshes;
+
+    /** The array of meshes.
+    *
+    * Use the indices given in the aiNode structure to access
+    * this array. The array is mNumMeshes in size. If the
+    * AI_SCENE_FLAGS_INCOMPLETE flag is not set there will always
+    * be at least ONE material.
+    */
+    C_STRUCT aiMesh** mMeshes;
+
+    /** The number of materials in the scene. */
+    unsigned int mNumMaterials;
+
+    /** The array of materials.
+    *
+    * Use the index given in each aiMesh structure to access this
+    * array. The array is mNumMaterials in size. If the
+    * AI_SCENE_FLAGS_INCOMPLETE flag is not set there will always
+    * be at least ONE material.
+    */
+    C_STRUCT aiMaterial** mMaterials;
+
+    /** The number of animations in the scene. */
+    unsigned int mNumAnimations;
+
+    /** The array of animations.
+    *
+    * All animations imported from the given file are listed here.
+    * The array is mNumAnimations in size.
+    */
+    C_STRUCT aiAnimation** mAnimations;
+
+    /** The number of textures embedded into the file */
+    unsigned int mNumTextures;
+
+    /** The array of embedded textures.
+    *
+    * Not many file formats embed their textures into the file.
+    * An example is Quake's MDL format (which is also used by
+    * some GameStudio versions)
+    */
+    C_STRUCT aiTexture** mTextures;
+
+    /** The number of light sources in the scene. Light sources
+    * are fully optional, in most cases this attribute will be 0
+        */
+    unsigned int mNumLights;
+
+    /** The array of light sources.
+    *
+    * All light sources imported from the given file are
+    * listed here. The array is mNumLights in size.
+    */
+    C_STRUCT aiLight** mLights;
+
+    /** The number of cameras in the scene. Cameras
+    * are fully optional, in most cases this attribute will be 0
+        */
+    unsigned int mNumCameras;
+
+    /** The array of cameras.
+    *
+    * All cameras imported from the given file are listed here.
+    * The array is mNumCameras in size. The first camera in the
+    * array (if existing) is the default camera view into
+    * the scene.
+    */
+    C_STRUCT aiCamera** mCameras;
+
+    /**
+     *  @brief  The global metadata assigned to the scene itself.
+     *
+     *  This data contains global metadata which belongs to the scene like 
+     *  unit-conversions, versions, vendors or other model-specific data. This 
+     *  can be used to store format-specific metadata as well.
+     */
+    C_STRUCT aiMetadata* mMetaData;
+
+
+#ifdef __cplusplus
+
+    //! Default constructor - set everything to 0/NULL
+    ASSIMP_API aiScene();
+
+    //! Destructor
+    ASSIMP_API ~aiScene();
+
+    //! Check whether the scene contains meshes
+    //! Unless no special scene flags are set this will always be true.
+    inline bool HasMeshes() const { 
+        return mMeshes != NULL && mNumMeshes > 0; 
+    }
+
+    //! Check whether the scene contains materials
+    //! Unless no special scene flags are set this will always be true.
+    inline bool HasMaterials() const { 
+        return mMaterials != NULL && mNumMaterials > 0; 
+    }
+
+    //! Check whether the scene contains lights
+    inline bool HasLights() const { 
+        return mLights != NULL && mNumLights > 0; 
+    }
+
+    //! Check whether the scene contains textures
+    inline bool HasTextures() const {
+        return mTextures != NULL && mNumTextures > 0; 
+    }
+
+    //! Check whether the scene contains cameras
+    inline bool HasCameras() const {
+        return mCameras != NULL && mNumCameras > 0; 
+    }
+
+    //! Check whether the scene contains animations
+    inline bool HasAnimations() const { 
+        return mAnimations != NULL && mNumAnimations > 0; 
+    }
+
+    //! Returns a short filename from a full path
+    static const char* GetShortFilename(const char* filename) {
+        const char* lastSlash = strrchr(filename, '/');
+        if (lastSlash == nullptr) {
+            lastSlash = strrchr(filename, '\\');
+        }
+        const char* shortFilename = lastSlash != nullptr ? lastSlash + 1 : filename;
+        return shortFilename;
+    }
+
+    //! Returns an embedded texture
+    const aiTexture* GetEmbeddedTexture(const char* filename) const {
+        const char* shortFilename = GetShortFilename(filename);
+        for (unsigned int i = 0; i < mNumTextures; i++) {
+            const char* shortTextureFilename = GetShortFilename(mTextures[i]->mFilename.C_Str());
+            if (strcmp(shortTextureFilename, shortFilename) == 0) {
+                return mTextures[i];
+            }
+        }
+        return nullptr;
+    }
+#endif // __cplusplus
+
+    /**  Internal data, do not touch */
+#ifdef __cplusplus
+    void* mPrivate;
+#else
+    char* mPrivate;
+#endif
+
+};
+
+#ifdef __cplusplus
+} //! namespace Assimp
+#endif
+
+#endif // AI_SCENE_H_INC
diff --git a/engine/inc/assimp/texture.h b/engine/inc/assimp/texture.h
new file mode 100644
index 00000000..e55c8bc4
--- /dev/null
+++ b/engine/inc/assimp/texture.h
@@ -0,0 +1,224 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file texture.h
+ *  @brief Defines texture helper structures for the library
+ *
+ * Used for file formats which embed their textures into the model file.
+ * Supported are both normal textures, which are stored as uncompressed
+ * pixels, and "compressed" textures, which are stored in a file format
+ * such as PNG or TGA.
+ */
+#pragma once
+#ifndef AI_TEXTURE_H_INC
+#define AI_TEXTURE_H_INC
+
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+// --------------------------------------------------------------------------------
+
+/** \def AI_EMBEDDED_TEXNAME_PREFIX
+ * \ref AI_MAKE_EMBEDDED_TEXNAME
+ */
+#ifndef AI_EMBEDDED_TEXNAME_PREFIX
+#   define AI_EMBEDDED_TEXNAME_PREFIX	"*"
+#endif
+
+/** @def AI_MAKE_EMBEDDED_TEXNAME
+ *  Used to build the reserved path name used by the material system to
+ *  reference textures that are embedded into their corresponding
+ *  model files. The parameter specifies the index of the texture
+ *  (zero-based, in the aiScene::mTextures array)
+ */
+#if (!defined AI_MAKE_EMBEDDED_TEXNAME)
+#   define AI_MAKE_EMBEDDED_TEXNAME(_n_) AI_EMBEDDED_TEXNAME_PREFIX # _n_
+#endif
+
+
+#include "./Compiler/pushpack1.h"
+
+// --------------------------------------------------------------------------------
+/** @brief Helper structure to represent a texel in a ARGB8888 format
+*
+*  Used by aiTexture.
+*/
+struct aiTexel
+{
+    unsigned char b,g,r,a;
+
+#ifdef __cplusplus
+    //! Comparison operator
+    bool operator== (const aiTexel& other) const
+    {
+        return b == other.b && r == other.r &&
+               g == other.g && a == other.a;
+    }
+
+    //! Inverse comparison operator
+    bool operator!= (const aiTexel& other) const
+    {
+        return b != other.b || r != other.r ||
+               g != other.g || a != other.a;
+    }
+
+    //! Conversion to a floating-point 4d color
+    operator aiColor4D() const
+    {
+        return aiColor4D(r/255.f,g/255.f,b/255.f,a/255.f);
+    }
+#endif // __cplusplus
+
+} PACK_STRUCT;
+
+#include "./Compiler/poppack1.h"
+
+// --------------------------------------------------------------------------------
+/** Helper structure to describe an embedded texture
+ *
+ * Normally textures are contained in external files but some file formats embed
+ * them directly in the model file. There are two types of embedded textures:
+ * 1. Uncompressed textures. The color data is given in an uncompressed format.
+ * 2. Compressed textures stored in a file format like png or jpg. The raw file
+ * bytes are given so the application must utilize an image decoder (e.g. DevIL) to
+ * get access to the actual color data.
+ *
+ * Embedded textures are referenced from materials using strings like "*0", "*1", etc.
+ * as the texture paths (a single asterisk character followed by the
+ * zero-based index of the texture in the aiScene::mTextures array).
+ */
+struct aiTexture
+{
+    /** Width of the texture, in pixels
+     *
+     * If mHeight is zero the texture is compressed in a format
+     * like JPEG. In this case mWidth specifies the size of the
+     * memory area pcData is pointing to, in bytes.
+     */
+    unsigned int mWidth;
+
+    /** Height of the texture, in pixels
+     *
+     * If this value is zero, pcData points to an compressed texture
+     * in any format (e.g. JPEG).
+     */
+    unsigned int mHeight;
+
+    /** A hint from the loader to make it easier for applications
+     *  to determine the type of embedded textures.
+     *
+     * If mHeight != 0 this member is show how data is packed. Hint will consist of
+     * two parts: channel order and channel bitness (count of the bits for every
+     * color channel). For simple parsing by the viewer it's better to not omit
+     * absent color channel and just use 0 for bitness. For example:
+     * 1. Image contain RGBA and 8 bit per channel, achFormatHint == "rgba8888";
+     * 2. Image contain ARGB and 8 bit per channel, achFormatHint == "argb8888";
+     * 3. Image contain RGB and 5 bit for R and B channels and 6 bit for G channel, achFormatHint == "rgba5650";
+     * 4. One color image with B channel and 1 bit for it, achFormatHint == "rgba0010";
+     * If mHeight == 0 then achFormatHint is set set to '\\0\\0\\0\\0' if the loader has no additional
+     * information about the texture file format used OR the
+     * file extension of the format without a trailing dot. If there
+     * are multiple file extensions for a format, the shortest
+     * extension is chosen (JPEG maps to 'jpg', not to 'jpeg').
+     * E.g. 'dds\\0', 'pcx\\0', 'jpg\\0'.  All characters are lower-case.
+     * The fourth character will always be '\\0'.
+     */
+    char achFormatHint[9];// 8 for string + 1 for terminator.
+
+    /** Data of the texture.
+     *
+     * Points to an array of mWidth * mHeight aiTexel's.
+     * The format of the texture data is always ARGB8888 to
+     * make the implementation for user of the library as easy
+     * as possible. If mHeight = 0 this is a pointer to a memory
+     * buffer of size mWidth containing the compressed texture
+     * data. Good luck, have fun!
+     */
+    C_STRUCT aiTexel* pcData;
+
+    /** Texture original filename
+    *
+    * Used to get the texture reference
+    */
+    C_STRUCT aiString mFilename;
+
+#ifdef __cplusplus
+
+    //! For compressed textures (mHeight == 0): compare the
+    //! format hint against a given string.
+    //! @param s Input string. 3 characters are maximally processed.
+    //!        Example values: "jpg", "png"
+    //! @return true if the given string matches the format hint
+    bool CheckFormat(const char* s) const
+    {
+		return (0 == ::strncmp(achFormatHint, s, sizeof(achFormatHint)));
+    }
+
+    // Construction
+    aiTexture ()
+        : mWidth  (0)
+        , mHeight (0)
+        , pcData  (NULL)
+    {
+        achFormatHint[0] = achFormatHint[1] = 0;
+        achFormatHint[2] = achFormatHint[3] = 0;
+    }
+
+    // Destruction
+    ~aiTexture ()
+    {
+        delete[] pcData;
+    }
+#endif
+};
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // AI_TEXTURE_H_INC
diff --git a/engine/inc/assimp/types.h b/engine/inc/assimp/types.h
new file mode 100644
index 00000000..9868f657
--- /dev/null
+++ b/engine/inc/assimp/types.h
@@ -0,0 +1,532 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file types.h
+ *  Basic data types and primitives, such as vectors or colors.
+ */
+#pragma once
+#ifndef AI_TYPES_H_INC
+#define AI_TYPES_H_INC
+
+// Some runtime headers
+#include <sys/types.h>
+#include <stddef.h>
+#include <string.h>
+#include <limits.h>
+
+// Our compile configuration
+#include "defs.h"
+
+// Some types moved to separate header due to size of operators
+#include "vector3.h"
+#include "vector2.h"
+#include "color4.h"
+#include "matrix3x3.h"
+#include "matrix4x4.h"
+#include "quaternion.h"
+
+#ifdef __cplusplus
+#include <cstring>
+#include <new>      // for std::nothrow_t
+#include <string>   // for aiString::Set(const std::string&)
+
+namespace Assimp    {
+    //! @cond never
+namespace Intern        {
+    // --------------------------------------------------------------------
+    /** @brief Internal helper class to utilize our internal new/delete
+     *    routines for allocating object of this and derived classes.
+     *
+     * By doing this you can safely share class objects between Assimp
+     * and the application - it works even over DLL boundaries. A good
+     * example is the #IOSystem where the application allocates its custom
+     * #IOSystem, then calls #Importer::SetIOSystem(). When the Importer
+     * destructs, Assimp calls operator delete on the stored #IOSystem.
+     * If it lies on a different heap than Assimp is working with,
+     * the application is determined to crash.
+     */
+    // --------------------------------------------------------------------
+#ifndef SWIG
+    struct ASSIMP_API AllocateFromAssimpHeap    {
+        // http://www.gotw.ca/publications/mill15.htm
+
+        // new/delete overload
+        void *operator new    ( size_t num_bytes) /* throw( std::bad_alloc ) */;
+        void *operator new    ( size_t num_bytes, const std::nothrow_t& ) throw();
+        void  operator delete ( void* data);
+
+        // array new/delete overload
+        void *operator new[]    ( size_t num_bytes) /* throw( std::bad_alloc ) */;
+        void *operator new[]    ( size_t num_bytes, const std::nothrow_t& )  throw();
+        void  operator delete[] ( void* data);
+
+    }; // struct AllocateFromAssimpHeap
+#endif
+} // namespace Intern
+    //! @endcond
+} // namespace Assimp
+
+extern "C" {
+#endif
+
+/** Maximum dimension for strings, ASSIMP strings are zero terminated. */
+#ifdef __cplusplus
+    static const size_t MAXLEN = 1024;
+#else
+#   define MAXLEN 1024
+#endif
+
+// ----------------------------------------------------------------------------------
+/** Represents a plane in a three-dimensional, euclidean space
+*/
+struct aiPlane
+{
+#ifdef __cplusplus
+    aiPlane () : a(0.f), b(0.f), c(0.f), d(0.f) {}
+    aiPlane (ai_real _a, ai_real _b, ai_real _c, ai_real _d)
+        : a(_a), b(_b), c(_c), d(_d) {}
+
+    aiPlane (const aiPlane& o) : a(o.a), b(o.b), c(o.c), d(o.d) {}
+
+#endif // !__cplusplus
+
+    //! Plane equation
+    ai_real a,b,c,d;
+}; // !struct aiPlane
+
+// ----------------------------------------------------------------------------------
+/** Represents a ray
+*/
+struct aiRay
+{
+#ifdef __cplusplus
+    aiRay () {}
+    aiRay (const aiVector3D& _pos, const aiVector3D& _dir)
+        : pos(_pos), dir(_dir) {}
+
+    aiRay (const aiRay& o) : pos (o.pos), dir (o.dir) {}
+
+#endif // !__cplusplus
+
+    //! Position and direction of the ray
+    C_STRUCT aiVector3D pos, dir;
+}; // !struct aiRay
+
+// ----------------------------------------------------------------------------------
+/** Represents a color in Red-Green-Blue space.
+*/
+struct aiColor3D
+{
+#ifdef __cplusplus
+    aiColor3D () : r(0.0f), g(0.0f), b(0.0f) {}
+    aiColor3D (ai_real _r, ai_real _g, ai_real _b) : r(_r), g(_g), b(_b) {}
+    explicit aiColor3D (ai_real _r) : r(_r), g(_r), b(_r) {}
+    aiColor3D (const aiColor3D& o) : r(o.r), g(o.g), b(o.b) {}
+
+    /** Component-wise comparison */
+    // TODO: add epsilon?
+    bool operator == (const aiColor3D& other) const
+        {return r == other.r && g == other.g && b == other.b;}
+
+    /** Component-wise inverse comparison */
+    // TODO: add epsilon?
+    bool operator != (const aiColor3D& other) const
+        {return r != other.r || g != other.g || b != other.b;}
+
+    /** Component-wise comparison */
+    // TODO: add epsilon?
+    bool operator < (const aiColor3D& other) const {
+        return r < other.r || ( r == other.r && (g < other.g || (g == other.g && b < other.b ) ) );
+    }
+
+    /** Component-wise addition */
+    aiColor3D operator+(const aiColor3D& c) const {
+        return aiColor3D(r+c.r,g+c.g,b+c.b);
+    }
+
+    /** Component-wise subtraction */
+    aiColor3D operator-(const aiColor3D& c) const {
+        return aiColor3D(r-c.r,g-c.g,b-c.b);
+    }
+
+    /** Component-wise multiplication */
+    aiColor3D operator*(const aiColor3D& c) const {
+        return aiColor3D(r*c.r,g*c.g,b*c.b);
+    }
+
+    /** Multiply with a scalar */
+    aiColor3D operator*(ai_real f) const {
+        return aiColor3D(r*f,g*f,b*f);
+    }
+
+    /** Access a specific color component */
+    ai_real operator[](unsigned int i) const {
+        return *(&r + i);
+    }
+
+    /** Access a specific color component */
+    ai_real& operator[](unsigned int i) {
+        if ( 0 == i ) {
+            return r;
+        } else if ( 1 == i ) {
+            return g;
+        } else if ( 2 == i ) {
+            return b;
+        }
+        return r;
+    }
+
+    /** Check whether a color is black */
+    bool IsBlack() const {
+        static const ai_real epsilon = ai_real(10e-3);
+        return std::fabs( r ) < epsilon && std::fabs( g ) < epsilon && std::fabs( b ) < epsilon;
+    }
+
+#endif // !__cplusplus
+
+    //! Red, green and blue color values
+    ai_real r, g, b;
+};  // !struct aiColor3D
+
+// ----------------------------------------------------------------------------------
+/** Represents an UTF-8 string, zero byte terminated.
+ *
+ *  The character set of an aiString is explicitly defined to be UTF-8. This Unicode
+ *  transformation was chosen in the belief that most strings in 3d files are limited
+ *  to ASCII, thus the character set needed to be strictly ASCII compatible.
+ *
+ *  Most text file loaders provide proper Unicode input file handling, special unicode
+ *  characters are correctly transcoded to UTF8 and are kept throughout the libraries'
+ *  import pipeline.
+ *
+ *  For most applications, it will be absolutely sufficient to interpret the
+ *  aiString as ASCII data and work with it as one would work with a plain char*.
+ *  Windows users in need of proper support for i.e asian characters can use the
+ *  MultiByteToWideChar(), WideCharToMultiByte() WinAPI functionality to convert the
+ *  UTF-8 strings to their working character set (i.e. MBCS, WideChar).
+ *
+ *  We use this representation instead of std::string to be C-compatible. The
+ *  (binary) length of such a string is limited to MAXLEN characters (including the
+ *  the terminating zero).
+*/
+struct aiString
+{
+#ifdef __cplusplus
+    /** Default constructor, the string is set to have zero length */
+    aiString() :
+        length(0)
+    {
+        data[0] = '\0';
+
+#ifdef ASSIMP_BUILD_DEBUG
+        // Debug build: overwrite the string on its full length with ESC (27)
+        memset(data+1,27,MAXLEN-1);
+#endif
+    }
+
+    /** Copy constructor */
+    aiString(const aiString& rOther) :
+        length(rOther.length)
+    {
+        // Crop the string to the maximum length
+        length = length>=MAXLEN?MAXLEN-1:length;
+        memcpy( data, rOther.data, length);
+        data[length] = '\0';
+    }
+
+    /** Constructor from std::string */
+    explicit aiString(const std::string& pString) :
+        length(pString.length())
+    {
+        length = length>=MAXLEN?MAXLEN-1:length;
+        memcpy( data, pString.c_str(), length);
+        data[length] = '\0';
+    }
+
+    /** Copy a std::string to the aiString */
+    void Set( const std::string& pString) {
+        if( pString.length() > MAXLEN - 1) {
+            return;
+        }
+        length = pString.length();
+        memcpy( data, pString.c_str(), length);
+        data[length] = 0;
+    }
+
+    /** Copy a const char* to the aiString */
+    void Set( const char* sz) {
+        const size_t len = ::strlen(sz);
+        if( len > MAXLEN - 1) {
+            return;
+        }
+        length = len;
+        memcpy( data, sz, len);
+        data[len] = 0;
+    }
+
+
+    /** Assigment operator */
+    aiString& operator = (const aiString &rOther) {
+        if (this == &rOther) {
+            return *this;
+        }
+
+        length = rOther.length;;
+        memcpy( data, rOther.data, length);
+        data[length] = '\0';
+        return *this;
+    }
+
+
+    /** Assign a const char* to the string */
+    aiString& operator = (const char* sz) {
+        Set(sz);
+        return *this;
+    }
+
+    /** Assign a cstd::string to the string */
+    aiString& operator = ( const std::string& pString) {
+        Set(pString);
+        return *this;
+    }
+
+    /** Comparison operator */
+    bool operator==(const aiString& other) const {
+        return  (length == other.length && 0 == memcmp(data,other.data,length));
+    }
+
+    /** Inverse comparison operator */
+    bool operator!=(const aiString& other) const {
+        return  (length != other.length || 0 != memcmp(data,other.data,length));
+    }
+
+    /** Append a string to the string */
+    void Append (const char* app)   {
+        const size_t len = ::strlen(app);
+        if (!len) {
+            return;
+        }
+        if (length + len >= MAXLEN) {
+            return;
+        }
+
+        memcpy(&data[length],app,len+1);
+        length += len;
+    }
+
+    /** Clear the string - reset its length to zero */
+    void Clear ()   {
+        length  = 0;
+        data[0] = '\0';
+
+#ifdef ASSIMP_BUILD_DEBUG
+        // Debug build: overwrite the string on its full length with ESC (27)
+        memset(data+1,27,MAXLEN-1);
+#endif
+    }
+
+    /** Returns a pointer to the underlying zero-terminated array of characters */
+    const char* C_Str() const {
+        return data;
+    }
+
+#endif // !__cplusplus
+
+    /** Binary length of the string excluding the terminal 0. This is NOT the
+     *  logical length of strings containing UTF-8 multibyte sequences! It's
+     *  the number of bytes from the beginning of the string to its end.*/
+    size_t length;
+
+    /** String buffer. Size limit is MAXLEN */
+    char data[MAXLEN];
+} ;  // !struct aiString
+
+
+// ----------------------------------------------------------------------------------
+/** Standard return type for some library functions.
+ * Rarely used, and if, mostly in the C API.
+ */
+typedef enum aiReturn
+{
+    /** Indicates that a function was successful */
+    aiReturn_SUCCESS = 0x0,
+
+    /** Indicates that a function failed */
+    aiReturn_FAILURE = -0x1,
+
+    /** Indicates that not enough memory was available
+     * to perform the requested operation
+     */
+    aiReturn_OUTOFMEMORY = -0x3,
+
+    /** @cond never
+     *  Force 32-bit size enum
+     */
+    _AI_ENFORCE_ENUM_SIZE = 0x7fffffff
+
+    /// @endcond
+} aiReturn;  // !enum aiReturn
+
+// just for backwards compatibility, don't use these constants anymore
+#define AI_SUCCESS     aiReturn_SUCCESS
+#define AI_FAILURE     aiReturn_FAILURE
+#define AI_OUTOFMEMORY aiReturn_OUTOFMEMORY
+
+// ----------------------------------------------------------------------------------
+/** Seek origins (for the virtual file system API).
+ *  Much cooler than using SEEK_SET, SEEK_CUR or SEEK_END.
+ */
+enum aiOrigin
+{
+    /** Beginning of the file */
+    aiOrigin_SET = 0x0,
+
+    /** Current position of the file pointer */
+    aiOrigin_CUR = 0x1,
+
+    /** End of the file, offsets must be negative */
+    aiOrigin_END = 0x2,
+
+    /**  @cond never
+     *   Force 32-bit size enum
+     */
+    _AI_ORIGIN_ENFORCE_ENUM_SIZE = 0x7fffffff
+
+    /// @endcond
+}; // !enum aiOrigin
+
+// ----------------------------------------------------------------------------------
+/** @brief Enumerates predefined log streaming destinations.
+ *  Logging to these streams can be enabled with a single call to
+ *   #LogStream::createDefaultStream.
+ */
+enum aiDefaultLogStream
+{
+    /** Stream the log to a file */
+    aiDefaultLogStream_FILE = 0x1,
+
+    /** Stream the log to std::cout */
+    aiDefaultLogStream_STDOUT = 0x2,
+
+    /** Stream the log to std::cerr */
+    aiDefaultLogStream_STDERR = 0x4,
+
+    /** MSVC only: Stream the log the the debugger
+     * (this relies on OutputDebugString from the Win32 SDK)
+     */
+    aiDefaultLogStream_DEBUGGER = 0x8,
+
+    /** @cond never
+     *  Force 32-bit size enum
+     */
+    _AI_DLS_ENFORCE_ENUM_SIZE = 0x7fffffff
+    /// @endcond
+}; // !enum aiDefaultLogStream
+
+// just for backwards compatibility, don't use these constants anymore
+#define DLS_FILE     aiDefaultLogStream_FILE
+#define DLS_STDOUT   aiDefaultLogStream_STDOUT
+#define DLS_STDERR   aiDefaultLogStream_STDERR
+#define DLS_DEBUGGER aiDefaultLogStream_DEBUGGER
+
+// ----------------------------------------------------------------------------------
+/** Stores the memory requirements for different components (e.g. meshes, materials,
+ *  animations) of an import. All sizes are in bytes.
+ *  @see Importer::GetMemoryRequirements()
+*/
+struct aiMemoryInfo
+{
+#ifdef __cplusplus
+
+    /** Default constructor */
+    aiMemoryInfo()
+        : textures   (0)
+        , materials  (0)
+        , meshes     (0)
+        , nodes      (0)
+        , animations (0)
+        , cameras    (0)
+        , lights     (0)
+        , total      (0)
+    {}
+
+#endif
+
+    /** Storage allocated for texture data */
+    unsigned int textures;
+
+    /** Storage allocated for material data  */
+    unsigned int materials;
+
+    /** Storage allocated for mesh data */
+    unsigned int meshes;
+
+    /** Storage allocated for node data */
+    unsigned int nodes;
+
+    /** Storage allocated for animation data */
+    unsigned int animations;
+
+    /** Storage allocated for camera data */
+    unsigned int cameras;
+
+    /** Storage allocated for light data */
+    unsigned int lights;
+
+    /** Total storage allocated for the full import. */
+    unsigned int total;
+}; // !struct aiMemoryInfo
+
+#ifdef __cplusplus
+}
+#endif //!  __cplusplus
+
+// Include implementation files
+#include "vector2.inl"
+#include "vector3.inl"
+#include "color4.inl"
+#include "quaternion.inl"
+#include "matrix3x3.inl"
+#include "matrix4x4.inl"
+
+#endif // AI_TYPES_H_INC
diff --git a/engine/inc/assimp/vector2.h b/engine/inc/assimp/vector2.h
new file mode 100644
index 00000000..d290945c
--- /dev/null
+++ b/engine/inc/assimp/vector2.h
@@ -0,0 +1,116 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+/** @file vector2.h
+ *  @brief 2D vector structure, including operators when compiling in C++
+ */
+#pragma once
+#ifndef AI_VECTOR2D_H_INC
+#define AI_VECTOR2D_H_INC
+
+#ifdef __cplusplus
+#   include <cmath>
+#else
+#   include <math.h>
+#endif
+
+#include "./Compiler/pushpack1.h"
+#include "defs.h"
+
+// ----------------------------------------------------------------------------------
+/** Represents a two-dimensional vector.
+ */
+
+#ifdef __cplusplus
+template <typename TReal>
+class aiVector2t
+{
+public:
+
+    aiVector2t () : x(), y() {}
+    aiVector2t (TReal _x, TReal _y) : x(_x), y(_y) {}
+    explicit aiVector2t (TReal _xyz) : x(_xyz), y(_xyz) {}
+    aiVector2t (const aiVector2t& o) : x(o.x), y(o.y) {}
+
+public:
+
+    void Set( TReal pX, TReal pY);
+    TReal SquareLength() const ;
+    TReal Length() const ;
+    aiVector2t& Normalize();
+
+public:
+
+    const aiVector2t& operator += (const aiVector2t& o);
+    const aiVector2t& operator -= (const aiVector2t& o);
+    const aiVector2t& operator *= (TReal f);
+    const aiVector2t& operator /= (TReal f);
+
+    TReal operator[](unsigned int i) const;
+
+    bool operator== (const aiVector2t& other) const;
+    bool operator!= (const aiVector2t& other) const;
+
+    bool Equal(const aiVector2t& other, TReal epsilon = 1e-6) const;
+
+    aiVector2t& operator= (TReal f);
+    const aiVector2t SymMul(const aiVector2t& o);
+
+    template <typename TOther>
+    operator aiVector2t<TOther> () const;
+
+    TReal x, y;
+};
+
+typedef aiVector2t<ai_real> aiVector2D;
+
+#else
+
+struct aiVector2D {
+    ai_real x, y;
+};
+
+#endif // __cplusplus
+
+#include "./Compiler/poppack1.h"
+
+#endif // AI_VECTOR2D_H_INC
diff --git a/engine/inc/assimp/vector2.inl b/engine/inc/assimp/vector2.inl
new file mode 100644
index 00000000..46c6c9d2
--- /dev/null
+++ b/engine/inc/assimp/vector2.inl
@@ -0,0 +1,244 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file  vector2.inl
+ *  @brief Inline implementation of aiVector2t<TReal> operators
+ */
+#pragma once
+#ifndef AI_VECTOR2D_INL_INC
+#define AI_VECTOR2D_INL_INC
+
+#ifdef __cplusplus
+#include "vector2.h"
+
+#include <cmath>
+
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+template <typename TOther>
+aiVector2t<TReal>::operator aiVector2t<TOther> () const {
+    return aiVector2t<TOther>(static_cast<TOther>(x),static_cast<TOther>(y));
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+inline
+void aiVector2t<TReal>::Set( TReal pX, TReal pY) {
+    x = pX; y = pY;
+}
+
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+inline
+TReal aiVector2t<TReal>::SquareLength() const {
+    return x*x + y*y;
+}
+
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+inline
+TReal aiVector2t<TReal>::Length() const {
+    return std::sqrt( SquareLength());
+}
+
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+inline
+aiVector2t<TReal>& aiVector2t<TReal>::Normalize() {
+    *this /= Length();
+    return *this;
+}
+
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+inline
+const aiVector2t<TReal>& aiVector2t<TReal>::operator += (const aiVector2t& o) {
+    x += o.x; y += o.y;
+    return *this;
+}
+
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+inline
+const aiVector2t<TReal>& aiVector2t<TReal>::operator -= (const aiVector2t& o) {
+    x -= o.x; y -= o.y;
+    return *this;
+}
+
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+inline
+const aiVector2t<TReal>& aiVector2t<TReal>::operator *= (TReal f) {
+    x *= f; y *= f;
+    return *this;
+}
+
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+inline
+const aiVector2t<TReal>& aiVector2t<TReal>::operator /= (TReal f) {
+    x /= f; y /= f;
+    return *this;
+}
+
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+inline
+TReal aiVector2t<TReal>::operator[](unsigned int i) const {
+	switch (i) {
+		case 0:
+			return x;
+		case 1:
+			return y;
+		default:
+			break;
+
+    }
+    return x;
+}
+
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+inline
+bool aiVector2t<TReal>::operator== (const aiVector2t& other) const {
+    return x == other.x && y == other.y;
+}
+
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+inline
+bool aiVector2t<TReal>::operator!= (const aiVector2t& other) const {
+    return x != other.x || y != other.y;
+}
+
+// ---------------------------------------------------------------------------
+template<typename TReal>
+inline
+bool aiVector2t<TReal>::Equal(const aiVector2t& other, TReal epsilon) const {
+    return
+        std::abs(x - other.x) <= epsilon &&
+        std::abs(y - other.y) <= epsilon;
+}
+
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+inline
+aiVector2t<TReal>& aiVector2t<TReal>::operator= (TReal f)   {
+    x = y = f;
+    return *this;
+}
+
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+inline
+const aiVector2t<TReal> aiVector2t<TReal>::SymMul(const aiVector2t& o) {
+    return aiVector2t(x*o.x,y*o.y);
+}
+
+
+// ------------------------------------------------------------------------------------------------
+// symmetric addition
+template <typename TReal>
+inline
+aiVector2t<TReal> operator + (const aiVector2t<TReal>& v1, const aiVector2t<TReal>& v2) {
+    return aiVector2t<TReal>( v1.x + v2.x, v1.y + v2.y);
+}
+
+// ------------------------------------------------------------------------------------------------
+// symmetric subtraction
+template <typename TReal>
+inline 
+aiVector2t<TReal> operator - (const aiVector2t<TReal>& v1, const aiVector2t<TReal>& v2) {
+    return aiVector2t<TReal>( v1.x - v2.x, v1.y - v2.y);
+}
+
+// ------------------------------------------------------------------------------------------------
+// scalar product
+template <typename TReal>
+inline 
+TReal operator * (const aiVector2t<TReal>& v1, const aiVector2t<TReal>& v2) {
+    return v1.x*v2.x + v1.y*v2.y;
+}
+
+// ------------------------------------------------------------------------------------------------
+// scalar multiplication
+template <typename TReal>
+inline 
+aiVector2t<TReal> operator * ( TReal f, const aiVector2t<TReal>& v) {
+    return aiVector2t<TReal>( f*v.x, f*v.y);
+}
+
+// ------------------------------------------------------------------------------------------------
+// and the other way around
+template <typename TReal>
+inline 
+aiVector2t<TReal> operator * ( const aiVector2t<TReal>& v, TReal f) {
+    return aiVector2t<TReal>( f*v.x, f*v.y);
+}
+
+// ------------------------------------------------------------------------------------------------
+// scalar division
+template <typename TReal>
+inline 
+aiVector2t<TReal> operator / ( const aiVector2t<TReal>& v, TReal f) {
+    return v * (1/f);
+}
+
+// ------------------------------------------------------------------------------------------------
+// vector division
+template <typename TReal>
+inline 
+aiVector2t<TReal> operator / ( const aiVector2t<TReal>& v, const aiVector2t<TReal>& v2) {
+    return aiVector2t<TReal>(v.x / v2.x,v.y / v2.y);
+}
+
+// ------------------------------------------------------------------------------------------------
+// vector negation
+template <typename TReal>
+inline 
+aiVector2t<TReal> operator - ( const aiVector2t<TReal>& v) {
+    return aiVector2t<TReal>( -v.x, -v.y);
+}
+
+#endif
+
+#endif // AI_VECTOR2D_INL_INC
diff --git a/engine/inc/assimp/vector3.h b/engine/inc/assimp/vector3.h
new file mode 100644
index 00000000..292da824
--- /dev/null
+++ b/engine/inc/assimp/vector3.h
@@ -0,0 +1,146 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+/** @file vector3.h
+ *  @brief 3D vector structure, including operators when compiling in C++
+ */
+#pragma once
+#ifndef AI_VECTOR3D_H_INC
+#define AI_VECTOR3D_H_INC
+
+#ifdef __cplusplus
+#   include <cmath>
+#else
+#   include <math.h>
+#endif
+
+#include "defs.h"
+
+#ifdef __cplusplus
+
+template<typename TReal> class aiMatrix3x3t;
+template<typename TReal> class aiMatrix4x4t;
+
+// ---------------------------------------------------------------------------
+/** Represents a three-dimensional vector. */
+template <typename TReal>
+class aiVector3t
+{
+public:
+    aiVector3t() : x(), y(), z() {}
+    aiVector3t(TReal _x, TReal _y, TReal _z) : x(_x), y(_y), z(_z) {}
+    explicit aiVector3t (TReal _xyz ) : x(_xyz), y(_xyz), z(_xyz) {}
+    aiVector3t( const aiVector3t& o ) : x(o.x), y(o.y), z(o.z) {}
+
+public:
+
+    // combined operators
+    const aiVector3t& operator += (const aiVector3t& o);
+    const aiVector3t& operator -= (const aiVector3t& o);
+    const aiVector3t& operator *= (TReal f);
+    const aiVector3t& operator /= (TReal f);
+
+    // transform vector by matrix
+    aiVector3t& operator *= (const aiMatrix3x3t<TReal>& mat);
+    aiVector3t& operator *= (const aiMatrix4x4t<TReal>& mat);
+
+    // access a single element
+    TReal operator[](unsigned int i) const;
+    TReal& operator[](unsigned int i);
+
+    // comparison
+    bool operator== (const aiVector3t& other) const;
+    bool operator!= (const aiVector3t& other) const;
+    bool operator < (const aiVector3t& other) const;
+
+    bool Equal(const aiVector3t& other, TReal epsilon = 1e-6) const;
+
+    template <typename TOther>
+    operator aiVector3t<TOther> () const;
+
+public:
+    /** @brief Set the components of a vector
+     *  @param pX X component
+     *  @param pY Y component
+     *  @param pZ Z component  */
+    void Set( TReal pX, TReal pY, TReal pZ);
+
+    /** @brief Get the squared length of the vector
+     *  @return Square length */
+    TReal SquareLength() const;
+
+    /** @brief Get the length of the vector
+     *  @return length */
+    TReal Length() const;
+
+
+    /** @brief Normalize the vector */
+    aiVector3t& Normalize();
+
+    /** @brief Normalize the vector with extra check for zero vectors */
+    aiVector3t& NormalizeSafe();
+
+    /** @brief Componentwise multiplication of two vectors
+     *
+     *  Note that vec*vec yields the dot product.
+     *  @param o Second factor */
+    const aiVector3t SymMul(const aiVector3t& o);
+
+    TReal x, y, z;
+};
+
+
+typedef aiVector3t<ai_real> aiVector3D;
+
+#else
+
+struct aiVector3D {
+    ai_real x, y, z;
+};
+
+#endif // __cplusplus
+
+#ifdef __cplusplus
+
+#endif // __cplusplus
+
+#endif // AI_VECTOR3D_H_INC
diff --git a/engine/inc/assimp/vector3.inl b/engine/inc/assimp/vector3.inl
new file mode 100644
index 00000000..ebe2f82e
--- /dev/null
+++ b/engine/inc/assimp/vector3.inl
@@ -0,0 +1,309 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file  vector3.inl
+ *  @brief Inline implementation of aiVector3t<TReal> operators
+ */
+#pragma once
+#ifndef AI_VECTOR3D_INL_INC
+#define AI_VECTOR3D_INL_INC
+
+#ifdef __cplusplus
+#include "vector3.h"
+
+#include <cmath>
+
+// ------------------------------------------------------------------------------------------------
+/** Transformation of a vector by a 3x3 matrix */
+template <typename TReal>
+AI_FORCE_INLINE
+aiVector3t<TReal> operator * (const aiMatrix3x3t<TReal>& pMatrix, const aiVector3t<TReal>& pVector) {
+    aiVector3t<TReal> res;
+    res.x = pMatrix.a1 * pVector.x + pMatrix.a2 * pVector.y + pMatrix.a3 * pVector.z;
+    res.y = pMatrix.b1 * pVector.x + pMatrix.b2 * pVector.y + pMatrix.b3 * pVector.z;
+    res.z = pMatrix.c1 * pVector.x + pMatrix.c2 * pVector.y + pMatrix.c3 * pVector.z;
+    return res;
+}
+
+// ------------------------------------------------------------------------------------------------
+/** Transformation of a vector by a 4x4 matrix */
+template <typename TReal>
+AI_FORCE_INLINE
+aiVector3t<TReal> operator * (const aiMatrix4x4t<TReal>& pMatrix, const aiVector3t<TReal>& pVector) {
+    aiVector3t<TReal> res;
+    res.x = pMatrix.a1 * pVector.x + pMatrix.a2 * pVector.y + pMatrix.a3 * pVector.z + pMatrix.a4;
+    res.y = pMatrix.b1 * pVector.x + pMatrix.b2 * pVector.y + pMatrix.b3 * pVector.z + pMatrix.b4;
+    res.z = pMatrix.c1 * pVector.x + pMatrix.c2 * pVector.y + pMatrix.c3 * pVector.z + pMatrix.c4;
+    return res;
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+template <typename TOther>
+aiVector3t<TReal>::operator aiVector3t<TOther> () const {
+    return aiVector3t<TOther>(static_cast<TOther>(x),static_cast<TOther>(y),static_cast<TOther>(z));
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE
+void aiVector3t<TReal>::Set( TReal pX, TReal pY, TReal pZ) {
+    x = pX;
+    y = pY;
+    z = pZ;
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE
+TReal aiVector3t<TReal>::SquareLength() const {
+    return x*x + y*y + z*z;
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE
+TReal aiVector3t<TReal>::Length() const {
+    return std::sqrt( SquareLength());
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE
+aiVector3t<TReal>& aiVector3t<TReal>::Normalize() {
+    *this /= Length();
+
+    return *this;
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE
+aiVector3t<TReal>& aiVector3t<TReal>::NormalizeSafe() {
+    TReal len = Length();
+    if ( len > static_cast< TReal >( 0 ) ) {
+        *this /= len;
+    }
+    return *this;
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE
+const aiVector3t<TReal>& aiVector3t<TReal>::operator += (const aiVector3t<TReal>& o) {
+    x += o.x;
+    y += o.y;
+    z += o.z;
+
+    return *this;
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE
+const aiVector3t<TReal>& aiVector3t<TReal>::operator -= (const aiVector3t<TReal>& o) {
+    x -= o.x;
+    y -= o.y;
+    z -= o.z;
+
+    return *this;
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE
+const aiVector3t<TReal>& aiVector3t<TReal>::operator *= (TReal f) {
+    x *= f;
+    y *= f;
+    z *= f;
+
+    return *this;
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE
+const aiVector3t<TReal>& aiVector3t<TReal>::operator /= (TReal f) {
+    const TReal invF = (TReal) 1.0 / f;
+    x *= invF;
+    y *= invF;
+    z *= invF;
+
+    return *this;
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE
+aiVector3t<TReal>& aiVector3t<TReal>::operator *= (const aiMatrix3x3t<TReal>& mat){
+    return (*this =  mat * (*this));
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE
+aiVector3t<TReal>& aiVector3t<TReal>::operator *= (const aiMatrix4x4t<TReal>& mat){
+    return (*this = mat * (*this));
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE
+TReal aiVector3t<TReal>::operator[](unsigned int i) const {
+    switch (i) {
+        case 0:
+            return x;
+        case 1:
+            return y;
+        case 2:
+            return z;
+        default:
+            break;
+    }
+    return x;
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE
+TReal& aiVector3t<TReal>::operator[](unsigned int i) {
+//    return *(&x + i);
+    switch (i) {
+        case 0:
+            return x;
+        case 1:
+            return y;
+        case 2:
+            return z;
+        default:
+            break;
+    }
+    return x;
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE
+bool aiVector3t<TReal>::operator== (const aiVector3t<TReal>& other) const {
+    return x == other.x && y == other.y && z == other.z;
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE
+bool aiVector3t<TReal>::operator!= (const aiVector3t<TReal>& other) const {
+    return x != other.x || y != other.y || z != other.z;
+}
+// ---------------------------------------------------------------------------
+template<typename TReal>
+AI_FORCE_INLINE
+bool aiVector3t<TReal>::Equal(const aiVector3t<TReal>& other, TReal epsilon) const {
+    return
+        std::abs(x - other.x) <= epsilon &&
+        std::abs(y - other.y) <= epsilon &&
+        std::abs(z - other.z) <= epsilon;
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE
+bool aiVector3t<TReal>::operator < (const aiVector3t<TReal>& other) const {
+    return x != other.x ? x < other.x : y != other.y ? y < other.y : z < other.z;
+}
+// ------------------------------------------------------------------------------------------------
+template <typename TReal>
+AI_FORCE_INLINE
+const aiVector3t<TReal> aiVector3t<TReal>::SymMul(const aiVector3t<TReal>& o) {
+    return aiVector3t<TReal>(x*o.x,y*o.y,z*o.z);
+}
+// ------------------------------------------------------------------------------------------------
+// symmetric addition
+template <typename TReal>
+AI_FORCE_INLINE
+aiVector3t<TReal> operator + (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
+    return aiVector3t<TReal>( v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
+}
+// ------------------------------------------------------------------------------------------------
+// symmetric subtraction
+template <typename TReal>
+AI_FORCE_INLINE
+aiVector3t<TReal> operator - (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
+    return aiVector3t<TReal>( v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
+}
+// ------------------------------------------------------------------------------------------------
+// scalar product
+template <typename TReal>
+AI_FORCE_INLINE
+TReal operator * (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
+    return v1.x*v2.x + v1.y*v2.y + v1.z*v2.z;
+}
+// ------------------------------------------------------------------------------------------------
+// scalar multiplication
+template <typename TReal>
+AI_FORCE_INLINE
+aiVector3t<TReal> operator * ( TReal f, const aiVector3t<TReal>& v) {
+    return aiVector3t<TReal>( f*v.x, f*v.y, f*v.z);
+}
+// ------------------------------------------------------------------------------------------------
+// and the other way around
+template <typename TReal>
+AI_FORCE_INLINE
+aiVector3t<TReal> operator * ( const aiVector3t<TReal>& v, TReal f) {
+    return aiVector3t<TReal>( f*v.x, f*v.y, f*v.z);
+}
+// ------------------------------------------------------------------------------------------------
+// scalar division
+template <typename TReal>
+AI_FORCE_INLINE
+aiVector3t<TReal> operator / ( const aiVector3t<TReal>& v, TReal f) {
+    return v * (1/f);
+}
+// ------------------------------------------------------------------------------------------------
+// vector division
+template <typename TReal>
+AI_FORCE_INLINE
+aiVector3t<TReal> operator / ( const aiVector3t<TReal>& v, const aiVector3t<TReal>& v2) {
+    return aiVector3t<TReal>(v.x / v2.x,v.y / v2.y,v.z / v2.z);
+}
+// ------------------------------------------------------------------------------------------------
+// cross product
+template<typename TReal>
+AI_FORCE_INLINE
+aiVector3t<TReal> operator ^ ( const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
+    return aiVector3t<TReal>( v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x);
+}
+// ------------------------------------------------------------------------------------------------
+// vector negation
+template<typename TReal>
+AI_FORCE_INLINE
+aiVector3t<TReal> operator - ( const aiVector3t<TReal>& v) {
+    return aiVector3t<TReal>( -v.x, -v.y, -v.z);
+}
+
+// ------------------------------------------------------------------------------------------------
+
+#endif // __cplusplus
+#endif // AI_VECTOR3D_INL_INC
diff --git a/engine/inc/assimp/version.h b/engine/inc/assimp/version.h
new file mode 100644
index 00000000..470166ed
--- /dev/null
+++ b/engine/inc/assimp/version.h
@@ -0,0 +1,115 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file  version.h
+ *  @brief Functions to query the version of the Assimp runtime, check
+ *    compile flags, ...
+ */
+#pragma once
+#ifndef AI_VERSION_H_INC
+#define AI_VERSION_H_INC
+
+#include "defs.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// ---------------------------------------------------------------------------
+/** @brief Returns a string with legal copyright and licensing information
+ *  about Assimp. The string may include multiple lines.
+ *  @return Pointer to static string.
+ */
+ASSIMP_API const char*  aiGetLegalString  (void);
+
+// ---------------------------------------------------------------------------
+/** @brief Returns the current minor version number of Assimp.
+ *  @return Minor version of the Assimp runtime the application was
+ *    linked/built against
+ */
+ASSIMP_API unsigned int aiGetVersionMinor (void);
+
+// ---------------------------------------------------------------------------
+/** @brief Returns the current major version number of Assimp.
+ *  @return Major version of the Assimp runtime the application was
+ *    linked/built against
+ */
+ASSIMP_API unsigned int aiGetVersionMajor (void);
+
+// ---------------------------------------------------------------------------
+/** @brief Returns the repository revision of the Assimp runtime.
+ *  @return SVN Repository revision number of the Assimp runtime the
+ *          application was linked/built against.
+ */
+ASSIMP_API unsigned int aiGetVersionRevision (void);
+
+// ---------------------------------------------------------------------------
+/** @brief Returns the branchname of the Assimp runtime.
+ *  @return The current branch name.
+ */
+ASSIMP_API const char *aiGetBranchName();
+
+//! Assimp was compiled as a shared object (Windows: DLL)
+#define ASSIMP_CFLAGS_SHARED  0x1
+//! Assimp was compiled against STLport
+#define ASSIMP_CFLAGS_STLPORT 0x2
+//! Assimp was compiled as a debug build
+#define ASSIMP_CFLAGS_DEBUG   0x4
+
+//! Assimp was compiled with ASSIMP_BUILD_BOOST_WORKAROUND defined
+#define ASSIMP_CFLAGS_NOBOOST           0x8
+//! Assimp was compiled with ASSIMP_BUILD_SINGLETHREADED defined
+#define ASSIMP_CFLAGS_SINGLETHREADED    0x10
+
+// ---------------------------------------------------------------------------
+/** @brief Returns assimp's compile flags
+ *  @return Any bitwise combination of the ASSIMP_CFLAGS_xxx constants.
+ */
+ASSIMP_API unsigned int aiGetCompileFlags (void);
+
+#ifdef __cplusplus
+} // end extern "C"
+#endif
+
+#endif // !! #ifndef AI_VERSION_H_INC
+
diff --git a/engine/inc/binpack2d/binpack2d.hpp b/engine/inc/binpack2d/binpack2d.hpp
new file mode 100644
index 00000000..c79c05a3
--- /dev/null
+++ b/engine/inc/binpack2d/binpack2d.hpp
@@ -0,0 +1,595 @@
+/**
+ * BinPack2D is a 2 dimensional, multi-bin, bin-packer. ( Texture Atlas Array! )
+ * It supports an arbitrary number of bins, at arbitrary sizes.
+ * rectangles can be added one at a time, chunks at a time, or all at once.
+ * rectangles that dont fit are reported back.
+ * Data can be associated to rectangles before processing via a template, and recalled after processing.
+ * 
+ * There is no documentation, See ExampleProgram() below for a taste.
+ * 
+ * Instead of tracking 'free rectangles' like other solutions I've found online,
+ * this algorithm tracks free 'top lefts', keeps them sorted by closest to origin, and puts new rectangles into
+ * the first free top left that doesnt collide. Consuming a top left creates 2 new top lefts (x+w,y) and (x,y+h).
+ * If a rectangle doesnt fit into a bin, before condisering the next bin, the current bin is re-tried with the rectangle rotated.
+ * This SOMTIMES helps... but not always.. i might disable this in future !?
+ * 
+ * This Header was origonally part of my rh_texture_packer program.
+ * A program I wrote to take advantage of my nexus-7's GL_EXT_texture_array extension.
+ * I wanted to be able to render out whole scenes with a single glDraw* 
+ * blah blah blah...
+ */
+
+
+/** ***** EXAMPLE CODE **************************************
+ 
+ // Your data - whatever you want to associate with 'rectangle'
+ class MyContent {
+  public:
+  std::string str;
+  MyContent() : str("default string") {}
+  MyContent(const std::string &str) : str(str) {}
+  };
+ 
+ int ExampleProgram() {
+   
+  srandom(0x69);
+    
+  // Create some 'content' to work on.
+  BinPack2D::ContentAccumulator<MyContent> inputContent;
+  
+  for(int i=0;i<20;i++) {
+   
+    // random size for this content
+    int width  = ((random() % 32)+1) * ((random() % 10)+1);
+    int height = ((random() % 32)+1) * ((random() % 10)+1);
+    
+    // whatever data you want to associate with this content
+    std::stringstream ss;
+    ss << "box " << i;
+    MyContent mycontent( ss.str().c_str() );
+    
+    // Add it
+    inputContent += BinPack2D::Content<MyContent>(mycontent, BinPack2D::Coord(), BinPack2D::Size(width, height), false );
+  }
+  
+  // Sort the input content by size... usually packs better.
+  inputContent.Sort();
+  
+  // Create some bins! ( 2 bins, 128x128 in this example )
+  BinPack2D::CanvasArray<MyContent> canvasArray = 
+    BinPack2D::UniformCanvasArrayBuilder<MyContent>(128,128,2).Build();
+    
+  // A place to store content that didnt fit into the canvas array.
+  BinPack2D::ContentAccumulator<MyContent> remainder;
+  
+  // try to pack content into the bins.
+  bool success = canvasArray.Place( inputContent, remainder );
+  
+  // A place to store packed content.
+  BinPack2D::ContentAccumulator<MyContent> outputContent;
+  
+  // Read all placed content.
+  canvasArray.CollectContent( outputContent );
+  
+  // parse output.
+  typedef BinPack2D::Content<MyContent>::Vector::iterator binpack2d_iterator;
+  printf("PLACED:\n");
+  for( binpack2d_iterator itor = outputContent.Get().begin(); itor != outputContent.Get().end(); itor++ ) {
+   
+    const BinPack2D::Content<MyContent> &content = *itor;
+    
+    // retreive your data.
+    const MyContent &myContent = content.content;
+  
+    printf("\t%9s of size %3dx%3d at position %3d,%3d,%2d rotated=%s\n",
+	   myContent.str.c_str(), 
+	   content.size.w, 
+	   content.size.h, 
+	   content.coord.x, 
+	   content.coord.y, 
+	   content.coord.z, 
+	   (content.rotated ? "yes":" no"));
+  }
+  
+  printf("NOT PLACED:\n");
+  for( binpack2d_iterator itor = remainder.Get().begin(); itor != remainder.Get().end(); itor++ ) {
+   
+    const BinPack2D::Content<MyContent> &content = *itor;
+    
+    const MyContent &myContent = content.content;
+  
+    printf("\t%9s of size %3dx%3d\n",
+	   myContent.str.c_str(), 
+	   content.size.w, 
+	   content.size.h);
+  }
+  
+  exit(0);
+}
+*/
+
+
+
+#pragma once
+
+#include<vector>
+#include<map>
+#include<list>
+#include<algorithm>
+#include<math.h>
+#include<sstream>
+
+namespace BinPack2D {
+
+class Size {
+  
+public:
+  
+  /*const*/ int w;
+  /*const*/ int h;
+  
+  Size(int w, int h)
+    : w(w),
+      h(h)
+  {}
+  
+  bool operator < ( const Size &that ) const {
+    
+    if(this->w != that.w) return this->w < that.w;
+    if(this->h != that.h) return this->h < that.h;
+    return false;
+  }
+};
+
+class Coord {
+ 
+public:
+  
+  typedef std::vector<Coord> Vector;
+  typedef std::list<Coord>   List;
+  
+  /*const*/ int x;
+  /*const*/ int y;
+  /*const*/ int z;
+  
+  Coord()
+    : x(0),
+      y(0),
+      z(0)
+  {}
+  
+  Coord(int x, int y)
+    : x(x),
+      y(y),
+      z(0)
+  {}
+  
+  Coord(int x, int y, int z)
+    : x(x),
+      y(y),
+      z(z)
+  {}
+  
+  bool operator < ( const Coord &that ) const {
+    
+    if(this->x != that.x) return this->x < that.x;
+    if(this->y != that.y) return this->y < that.y;
+    if(this->z != that.z) return this->z < that.z;
+    return false;
+  }
+};
+
+template<typename _T> class Content {
+  
+public:
+  
+  typedef std::vector<Content<_T> > Vector;
+  
+  /*const*/ bool rotated;
+  /*const*/ Coord coord;
+  /*const*/ Size  size;
+  /*const*/ _T content;
+  
+  Content( const Content<_T> &src )
+    : rotated(src.rotated),
+      coord(src.coord),
+      size(src.size),
+      content(src.content)
+  {}
+  
+  Content( const _T &content, const Coord &coord, const Size &size, bool rotated )
+    : 
+      content(content),
+      coord(coord),
+      size(size),
+      rotated(rotated)
+  {}
+  
+  void Rotate() {
+   
+    rotated = !rotated;
+    size = Size( size.h, size.w );
+  }
+  
+  bool intersects(const Content<_T> &that) const {
+    
+    if(this->coord.x >= (that.coord.x + that.size.w))
+      return false;
+    
+    if(this->coord.y >= (that.coord.y + that.size.h))
+      return false;
+    
+    if(that.coord.x >= (this->coord.x + this->size.w))
+      return false;
+    
+    if(that.coord.y >= (this->coord.y + this->size.h))
+      return false;
+    
+    return true;
+  }
+};
+
+template<typename _T> class Canvas {
+  
+  Coord::List topLefts;
+  typename Content<_T>::Vector contentVector;
+  
+  bool needToSort;
+  
+public:
+  
+  typedef Canvas<_T> CanvasT;
+  typedef typename std::vector<CanvasT> Vector;
+  
+  static bool Place( Vector &canvasVector, const typename Content<_T>::Vector &contentVector, typename Content<_T>::Vector &remainder ) {
+    
+    typename Content<_T>::Vector todo = contentVector;
+        
+    for( typename Vector::iterator itor = canvasVector.begin(); itor != canvasVector.end(); itor++ ) {
+     
+      Canvas <_T> &canvas = *itor;
+      
+      remainder.clear();
+      canvas.Place(todo, remainder);
+      todo = remainder;
+    }
+    
+    if(remainder.size()==0)
+      return true;
+    
+    return false;
+  }
+  
+  static bool Place( Vector &canvasVector, const typename Content<_T>::Vector &contentVector ) {
+    
+    typename Content<_T>::Vector remainder;
+    
+    return Place( canvasVector, contentVector, remainder );
+  }
+  
+  static bool Place( Vector &canvasVector, const Content<_T> &content ) {
+    
+    typename Content<_T>::Vector contentVector(1, content);
+    
+    return Place( canvasVector, contentVector );
+  }
+  
+  const int w;
+  const int h;
+   
+  Canvas(int w, int h)
+    : needToSort(false),
+      w(w),
+      h(h)
+  {  
+    topLefts.push_back( Coord(0,0) );
+  }
+  
+  bool HasContent() const {
+   
+    return ( contentVector.size() > 0) ;
+  }
+  
+  const typename Content<_T>::Vector &GetContents( ) const {
+   
+    return contentVector;
+  }
+  
+  bool operator < ( const Canvas &that ) const {
+    
+    if(this->w != that.w) return this->w < that.w;
+    if(this->h != that.h) return this->h < that.h;
+    return false;
+  }
+
+  bool Place(const typename Content<_T>::Vector &contentVector, typename Content<_T>::Vector &remainder) {
+    
+    bool placedAll = true;
+    
+    for( typename Content<_T>::Vector::const_iterator itor = contentVector.begin(); itor != contentVector.end(); itor++ ) {
+      
+      const Content<_T> & content = *itor;
+      
+      if( Place( content ) == false ) {
+	
+	placedAll = false;
+	remainder.push_back( content );
+      }
+    }
+    
+    return placedAll;
+  }
+  
+  bool Place(Content<_T> content) {
+     
+    Sort();
+    
+    for( Coord::List::iterator itor = topLefts.begin(); itor != topLefts.end(); itor++ ) {
+      
+      content.coord = *itor;
+      
+      if( Fits( content ) ) {
+	
+	Use( content );
+	topLefts.erase( itor );
+	return true;
+      }
+    }
+    
+    // EXPERIMENTAL - TRY ROTATED?
+    content.Rotate();
+    for( Coord::List::iterator itor = topLefts.begin(); itor != topLefts.end(); itor++ ) {
+      
+      content.coord = *itor;
+      
+      if( Fits( content ) ) {
+	
+	Use( content );
+	topLefts.erase( itor );
+	return true;
+      }
+    }
+    ////////////////////////////////
+    
+    
+    return false;
+  }
+  
+private:
+  
+  bool Fits( const Content<_T> &content ) const {
+   
+    if( (content.coord.x + content.size.w) > w )
+      return false;
+    
+    if( (content.coord.y + content.size.h) > h )
+      return false;
+    
+    for( typename Content<_T>::Vector::const_iterator itor = contentVector.begin(); itor != contentVector.end(); itor++ )  
+      if( content.intersects( *itor ) )
+	return false;
+    
+    return true;
+  }
+  
+  bool Use(const Content<_T> &content) {
+   
+    const Size  &size = content.size;
+    const Coord &coord = content.coord;
+    
+    topLefts.push_front	( Coord( coord.x + size.w, coord.y          ) );
+    topLefts.push_back	( Coord( coord.x         , coord.y + size.h ) );
+    
+    contentVector.push_back( content );
+    
+    needToSort = true;
+    
+    return true;
+  }
+  
+private:
+  
+  struct TopToBottomLeftToRightSort {
+    
+    bool operator()(const Coord &a, const Coord &b) const {
+     
+      return ( a.x * a.x + a.y * a.y ) < ( b.x * b.x + b.y * b.y );
+    }
+  };
+  
+public:
+  
+  void Sort() {
+    
+    if(!needToSort)
+      return;
+  
+    topLefts.sort(TopToBottomLeftToRightSort());
+    
+    needToSort = false;
+  }
+};
+
+template <typename _T> class ContentAccumulator {
+  
+  typename Content<_T>::Vector contentVector;
+ 
+  
+public:
+  
+  ContentAccumulator()
+  {}
+  
+  const typename Content<_T>::Vector &Get() const {
+   
+    return contentVector;
+  }
+  
+  typename Content<_T>::Vector &Get() {
+   
+    return contentVector;
+  }
+  
+  ContentAccumulator<_T>& operator += ( const Content<_T> & content ) {
+   
+    contentVector.push_back( content );
+   
+    
+    return *this;
+  }
+  
+  ContentAccumulator<_T>& operator += ( const typename Content<_T>::Vector & content ) {
+   
+    contentVector.insert( contentVector.end(), content.begin(), content.end() );
+   
+    
+    return *this;
+  }
+  
+  ContentAccumulator<_T> operator + ( const Content<_T> & content ) {
+   
+    ContentAccumulator<_T> temp = *this;
+    
+    temp += content;
+    
+    return temp;
+  }
+  
+  ContentAccumulator<_T> operator + ( const typename Content<_T>::Vector & content ) {
+   
+    ContentAccumulator<_T> temp = *this;
+    
+    temp += content;
+    
+    return temp;
+  }
+ 
+ 
+ 
+private:
+  
+  struct GreatestWidthThenGreatestHeightSort {
+    
+    bool operator()(const Content<_T> &a, const Content<_T> &b) const {
+      
+      const Size &sa = a.size; 
+      const Size &sb = b.size;
+      
+//      return( sa.w * sa.h > sb.w * sb.h );
+      
+      if(sa.w != sb.w)
+	  return sa.w > sb.w;    
+      return sa.h > sb.h;
+    }
+  };
+  
+  struct MakeHorizontal {
+   
+    Content<_T> operator()( const Content<_T> &elem) {
+      
+      if(elem.size.h > elem.size.w) 
+      {
+	Content<_T> r = elem;
+	
+	r.size.w = elem.size.h;
+	r.size.h = elem.size.w;
+	r.rotated = !elem.rotated;
+	
+	return r;
+      }
+      
+      return elem;
+    }
+  };
+  
+public:
+  
+  void Sort() {
+   
+//  if(allow_rotation)
+//    std::transform(contentVector.begin(), contentVector.end(), contentVector.begin(), MakeHorizontal());
+    
+    std::sort( contentVector.begin(), contentVector.end(), GreatestWidthThenGreatestHeightSort() );
+  }
+};
+
+template <typename _T> class UniformCanvasArrayBuilder {
+  
+  int w;
+  int h;
+  int d;
+  
+public:
+  
+  UniformCanvasArrayBuilder( int w, int h, int d )
+    : w(w),
+      h(h),
+      d(d)
+  {}
+  
+  typename Canvas<_T>::Vector Build() {
+   
+    return typename Canvas<_T>::Vector(d, Canvas<_T>(w, h) );
+  }  
+};
+
+template<typename _T> class CanvasArray {
+  
+  typename Canvas<_T>::Vector canvasArray;
+  
+public:  
+  CanvasArray() {
+    
+  }
+  CanvasArray( const typename Canvas<_T>::Vector &canvasArray )
+    : canvasArray( canvasArray )
+  {}
+
+  bool Place(const typename Content<_T>::Vector &contentVector, typename Content<_T>::Vector &remainder) {
+   
+    return Canvas<_T>::Place( canvasArray, contentVector, remainder );
+  }
+  
+  bool Place(const ContentAccumulator<_T> &content, ContentAccumulator<_T> &remainder) {
+    
+    return Place( content.Get(), remainder.Get() );
+  }
+  
+  bool Place(const typename Content<_T>::Vector &contentVector) {
+   
+    return Canvas<_T>::Place( canvasArray, contentVector );
+  }
+  
+  bool Place(const ContentAccumulator<_T> &content) {
+    
+    return Place( content.Get() );
+  }
+  
+  bool CollectContent( typename Content<_T>::Vector &contentVector ) const {
+    
+    int z = 0;
+    
+    for( typename Canvas<_T>::Vector::const_iterator itor = canvasArray.begin(); itor != canvasArray.end(); itor++ ) {
+      
+      const typename Content<_T>::Vector &contents = itor->GetContents();
+      
+      for( typename Content<_T>::Vector::const_iterator itor = contents.begin(); itor != contents.end(); itor++ ) {
+	
+	Content<_T> content = *itor;
+	
+	content.coord.z = z;
+		
+	contentVector.push_back( content );
+      }
+      z++;
+    }
+    return true;
+  }
+  
+  bool CollectContent( ContentAccumulator<_T> &content) const {
+    
+    return CollectContent( content.Get() );
+  }
+};
+
+} /*** BinPack2D ***/
\ No newline at end of file
diff --git a/engine/inc/bullet/BasicDemo/BasicExample.h b/engine/inc/bullet/BasicDemo/BasicExample.h
new file mode 100644
index 00000000..8fb1aa06
--- /dev/null
+++ b/engine/inc/bullet/BasicDemo/BasicExample.h
@@ -0,0 +1,21 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2015 Google Inc. http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BASIC_EXAMPLE_H
+#define BASIC_EXAMPLE_H
+
+class CommonExampleInterface* BasicExampleCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //BASIC_DEMO_PHYSICS_SETUP_H
diff --git a/engine/inc/bullet/Benchmarks/BenchmarkDemo.h b/engine/inc/bullet/Benchmarks/BenchmarkDemo.h
new file mode 100644
index 00000000..3bac4964
--- /dev/null
+++ b/engine/inc/bullet/Benchmarks/BenchmarkDemo.h
@@ -0,0 +1,20 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef BENCHMARK_EXAMPLE_H
+#define BENCHMARK_EXAMPLE_H
+
+class CommonExampleInterface* BenchmarkCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //BENCHMARK_EXAMPLE_H
diff --git a/engine/inc/bullet/Benchmarks/HaltonData.h b/engine/inc/bullet/Benchmarks/HaltonData.h
new file mode 100644
index 00000000..1f6c6a44
--- /dev/null
+++ b/engine/inc/bullet/Benchmarks/HaltonData.h
@@ -0,0 +1,647 @@
+// Generated by ./Tools/mksrc.py
+
+// h00
+const int h00_numv = 14;
+const float h00_volu = 0.105869;
+const float h00_pos[3] = { -0.801161,-0.825905,-0.503586 };
+const float h00_verts[ h00_numv * 3 ] = {
+  -0.198839,-0.174095,-0.496414, -0.198839,-0.073069,-0.496414, 0.355754,-0.174095,0.317906, 0.266263,0.078525,-0.113353, -0.198839,0.418138,0.148658, -0.198839,0.151957,0.285583, -0.004749,-0.165186,-0.496414, -0.198839,0.342511,-0.068863, -0.198839,-0.174095,0.341490, 0.030157,-0.174095,0.397398, -0.005096,-0.174095,-0.496414, 0.428901,-0.174095,0.139324, -0.198839,0.419530,0.145078, -0.111897,0.386202,0.018538, 
+};
+// h01
+const int h01_numv = 16;
+const float h01_volu = 0.123003;
+const float h01_pos[3] = { -0.669502,-0.555335,-0.800913 };
+const float h01_verts[ h01_numv * 3 ] = {
+  0.137874,0.266251,0.316069, -0.136407,-0.435756,-0.199087, -0.330498,0.127352,-0.199087, 0.378917,-0.091301,0.019367, 0.437409,0.033623,-0.016334, 0.038469,0.311615,0.180723, -0.330498,-0.343638,-0.199087, 0.193689,-0.157234,0.188948, 0.276656,-0.200503,-0.199087, 0.399981,0.033623,-0.199087, -0.039317,0.311615,-0.199087, -0.330498,0.071941,0.228464, 0.134604,-0.192045,0.183974, -0.243556,0.115632,0.315865, 0.128360,0.261346,0.324519, -0.053858,0.233367,0.333678, 
+};
+// h02
+const int h02_numv = 22;
+const float h02_volu = 0.069699;
+const float h02_pos[3] = { -0.226726,-0.554920,-0.490680 };
+const float h02_verts[ h02_numv * 3 ] = {
+  0.092179,-0.226103,0.260087, -0.296734,0.272195,0.041665, -0.063859,-0.091716,-0.290866, 0.291800,-0.116083,-0.104671, -0.005367,0.033207,-0.326567, 0.057499,0.071569,-0.315604, -0.314416,0.260931,0.014286, 0.001987,-0.310858,0.106391, 0.200664,0.041526,0.249449, -0.249087,-0.157649,-0.121285, 0.164143,-0.213455,-0.116915, 0.086533,-0.112211,0.311781, 0.301609,-0.100599,-0.031006, -0.013037,0.041374,0.269240, 0.214238,-0.145305,0.159971, -0.177599,0.337949,0.022880, -0.304902,0.265836,0.005836, 0.151444,0.029502,0.298046, 0.226514,0.065723,0.196331, -0.078156,0.329100,-0.024159, 0.053890,0.084483,0.272741, -0.198047,0.327898,0.050872, 
+};
+// h03
+const int h03_numv = 18;
+const float h03_volu = 0.069585;
+const float h03_pos[3] = { -0.013871,-0.718833,-0.869565 };
+const float h03_verts[ h03_numv * 3 ] = {
+  -0.207492,-0.281167,-0.130435, 0.113468,0.049972,0.264160, -0.007999,0.353837,-0.130435, 0.078945,0.047830,0.274214, -0.003048,-0.281167,0.119131, -0.048711,-0.049541,0.261970, -0.155356,0.235482,0.063281, 0.163083,-0.281167,0.065052, -0.378975,-0.037005,-0.130435, -0.276714,0.072197,0.088019, 0.263172,-0.281167,-0.130435, 0.247851,0.256254,-0.130435, 0.308871,0.008019,-0.130435, 0.268707,0.210552,0.010520, 0.116203,0.335344,-0.130435, 0.263499,0.226082,-0.009852, -0.255650,0.197121,-0.130435, -0.218222,0.197121,0.052318, 
+};
+// h04
+const int h04_numv = 18;
+const float h04_volu = 0.049776;
+const float h04_pos[3] = { 0.037853,-0.892026,-0.431971 };
+const float h04_verts[ h04_numv * 3 ] = {
+  -0.100436,0.123651,-0.175624, 0.353999,-0.060233,0.083056, 0.061744,0.223165,-0.173434, -0.054772,-0.107974,-0.318463, 0.079577,0.232813,-0.134685, 0.365414,-0.107974,0.061633, 0.111359,-0.107974,-0.372542, -0.262592,0.026248,0.047682, -0.327682,-0.107974,0.107959, -0.050341,0.191801,0.101262, -0.248632,-0.107974,0.379486, -0.172400,0.111003,0.201378, 0.324182,-0.074827,0.146980, 0.312271,-0.107974,0.174077, -0.248842,-0.086035,0.364515, -0.264984,-0.107974,0.352871, 0.027221,0.221023,-0.163380, 0.037030,0.236507,-0.089715, 
+};
+// h05
+const int h05_numv = 12;
+const float h05_volu = 0.060052;
+const float h05_pos[3] = { -0.361440,-0.882680,-0.728709 };
+const float h05_verts[ h05_numv * 3 ] = {
+  -0.444817,-0.117320,-0.271291, 0.140076,-0.117320,-0.271291, 0.136701,0.016901,0.344420, -0.031407,0.126842,-0.271291, 0.070855,0.236044,-0.052837, -0.114373,0.170111,0.116744, 0.344521,-0.117320,-0.021725, 0.298857,0.114305,0.121114, -0.444469,-0.108411,-0.271291, 0.071611,-0.117320,0.404697, -0.173458,0.135300,0.111770, -0.010820,-0.117320,0.364447, 
+};
+// h06
+const int h06_numv = 16;
+const float h06_volu = 0.067458;
+const float h06_pos[3] = { 0.885250,-0.616510,-0.689541 };
+const float h06_verts[ h06_numv * 3 ] = {
+  -0.230633,-0.043361,0.025874, -0.001305,-0.383490,-0.079103, 0.114750,-0.383490,0.055891, 0.114750,0.141993,-0.310459, 0.042572,0.157183,0.322917, 0.114750,0.349093,0.009138, 0.114750,-0.209139,-0.310459, 0.114750,-0.383490,-0.220772, 0.114750,0.143660,0.326163, -0.023969,0.120047,-0.310459, -0.230634,0.218132,-0.108639, -0.072958,0.349093,0.054965, -0.138827,-0.119612,0.199579, 0.020027,-0.383490,0.025057, -0.041036,-0.038390,0.301047, 0.114750,-0.091790,0.305977, 
+};
+// h07
+const int h07_numv = 18;
+const float h07_volu = 0.100040;
+const float h07_pos[3] = { 0.439796,-0.816642,-0.690430 };
+const float h07_verts[ h07_numv * 3 ] = {
+  -0.290584,-0.183358,-0.114083, 0.444149,-0.183358,-0.078214, -0.340199,0.147781,0.085025, -0.036530,-0.183358,0.320092, -0.047944,-0.135617,0.341515, 0.306627,0.080520,0.200468, -0.322367,0.157429,0.123774, 0.465481,-0.183358,0.025945, 0.214820,0.156771,0.026763, -0.144796,0.105827,-0.309570, 0.159858,-0.183358,-0.309570, -0.190496,-0.183358,-0.309570, -0.155412,0.298926,0.091748, -0.184960,0.308361,-0.168615, -0.134267,0.332806,-0.106403, 0.196572,0.110989,0.274357, -0.157992,0.325768,-0.131745, -0.142419,0.333870,-0.095406, 
+};
+// h08
+const int h08_numv = 22;
+const float h08_volu = 0.095115;
+const float h08_pos[3] = { 0.582909,-0.382310,-0.514785 };
+const float h08_verts[ h08_numv * 3 ] = {
+  0.039696,0.333763,-0.114253, -0.040720,0.073975,-0.343437, -0.281418,0.194479,0.107755, 0.071707,-0.016068,-0.283395, 0.071707,-0.277561,-0.148882, 0.163514,-0.353812,0.024824, 0.072380,0.310495,-0.182078, 0.344912,-0.077018,0.148161, 0.229382,0.114893,-0.119790, 0.056106,0.251986,0.176207, 0.261304,-0.272590,0.126291, 0.053460,-0.323343,0.098712, -0.280479,0.198156,0.096008, -0.285532,-0.100462,-0.271051, 0.094134,-0.250952,0.200497, -0.277380,-0.101526,-0.282048, -0.010614,0.002589,0.315575, -0.026292,0.211375,0.249710, 0.146296,0.123570,0.286302, 0.056041,0.119791,0.321947, -0.290185,0.102104,0.127875, -0.298525,-0.135406,-0.083897, 
+};
+// h09
+const int h09_numv = 16;
+const float h09_volu = 0.059582;
+const float h09_pos[3] = { 0.627742,-0.657906,-0.898694 };
+const float h09_verts[ h09_numv * 3 ] = {
+  -0.028087,-0.342094,-0.101306, 0.372258,-0.342094,-0.101306, 0.233539,0.161443,-0.101306, 0.372258,-0.167743,-0.101306, 0.256203,-0.342094,0.130050, 0.372258,-0.342094,-0.011619, -0.322212,0.174071,0.101861, 0.026875,-0.001965,0.235027, -0.098160,0.388838,-0.101306, 0.026875,0.259528,0.100514, -0.332742,-0.052909,-0.101306, -0.085552,0.349571,0.040471, -0.393762,0.195327,-0.101306, -0.372906,0.149626,0.039648, -0.378114,0.165155,0.019276, -0.345937,0.167033,0.076519, 
+};
+// h10
+const int h10_numv = 18;
+const float h10_volu = 0.082139;
+const float h10_pos[3] = { -0.348593,-0.203405,-0.827574 };
+const float h10_verts[ h10_numv * 3 ] = {
+  0.351136,-0.038001,-0.172426, 0.318157,0.110282,-0.172426, -0.183035,-0.085679,0.342730, -0.360226,-0.040315,-0.172426, 0.190400,0.248876,-0.172426, 0.296736,0.161596,-0.025823, 0.116500,-0.318307,0.010327, -0.282440,-0.040315,0.207384, -0.155944,0.334915,-0.140051, -0.055732,-0.013566,0.359774, 0.296359,0.169251,-0.045236, -0.155944,0.347503,-0.172426, 0.079072,-0.318307,-0.172426, 0.043711,-0.022416,0.312735, 0.326723,-0.161591,-0.172426, 0.179366,-0.279946,0.021290, 0.100706,0.105108,0.263039, 0.042697,0.111008,0.290353, 
+};
+// h11
+const int h11_numv = 18;
+const float h11_volu = 0.058443;
+const float h11_pos[3] = { -0.902277,0.042835,-0.283464 };
+const float h11_verts[ h11_numv * 3 ] = {
+  0.065494,-0.341848,-0.057123, 0.194525,0.153131,-0.091230, -0.097723,-0.350111,0.163707, 0.194525,-0.144351,0.061796, 0.065493,0.122511,-0.295991, -0.097723,-0.183345,0.306682, -0.097723,0.152153,0.335446, -0.097723,-0.428001,-0.052654, 0.107269,-0.156775,0.196004, -0.097723,0.199975,-0.375687, 0.037223,0.358435,0.033582, -0.097723,0.406471,-0.057020, -0.067761,-0.416891,-0.051054, -0.040073,-0.340339,0.134552, 0.056142,-0.350169,-0.055126, 0.004412,-0.376327,-0.008857, 0.025793,-0.108438,0.290488, -0.096343,0.152412,0.335215, 
+};
+// h12
+const int h12_numv = 22;
+const float h12_volu = 0.106128;
+const float h12_pos[3] = { -0.838340,-0.076123,-0.758521 };
+const float h12_verts[ h12_numv * 3 ] = {
+  0.207307,-0.167597,0.138331, 0.129521,-0.167597,-0.241479, -0.161660,0.318933,0.099371, 0.312802,0.272050,-0.241479, -0.161660,-0.330252,0.400013, -0.074718,-0.363580,0.273473, 0.001556,0.241469,0.179066, -0.161660,-0.309043,0.422403, -0.161660,-0.407271,0.186072, -0.161660,-0.351860,-0.241479, -0.007794,-0.231211,0.419931, 0.001557,-0.222890,0.417934, 0.309084,0.269226,-0.210613, -0.161660,0.422173,-0.241479, 0.072963,0.309250,0.057032, -0.161660,0.392766,-0.014569, -0.131698,-0.297933,0.424004, -0.161660,-0.327468,0.404309, 0.114980,-0.245845,0.291286, 0.009169,-0.227496,0.411012, 0.333803,0.207633,-0.209104, 0.333803,0.220221,-0.241479, 
+};
+// h13
+const int h13_numv = 22;
+const float h13_volu = 0.080573;
+const float h13_pos[3] = { -0.579196,0.019592,-0.524795 };
+const float h13_verts[ h13_numv * 3 ] = {
+  -0.186181,0.213535,-0.176694, 0.154423,-0.034973,0.266436, 0.105286,0.335497,0.021835, 0.055737,-0.302317,0.075780, -0.128556,-0.121108,0.303127, 0.252786,0.058395,0.170378, -0.257588,0.145754,-0.054660, 0.097995,0.334920,0.024505, 0.093556,-0.038093,0.287537, 0.074659,0.111918,-0.442830, -0.051837,-0.263312,-0.095394, -0.257587,-0.318605,0.184208, 0.273300,-0.111989,-0.012426, 0.049940,0.173511,-0.444339, -0.026589,0.239892,0.129875, -0.128556,0.176374,0.150102, 0.038054,-0.313581,0.048402, 0.047568,-0.308676,0.039952, -0.249976,-0.323211,0.177286, -0.144164,-0.341560,0.057561, 0.174871,-0.236563,0.056995, 0.154423,-0.246614,0.084987, 
+};
+// h14
+const int h14_numv = 24;
+const float h14_volu = 0.092625;
+const float h14_pos[3] = { 0.037294,-0.326434,-0.629340 };
+const float h14_verts[ h14_numv * 3 ] = {
+  0.244511,-0.164440,-0.192835, -0.034752,0.085028,-0.370660, -0.037506,-0.162763,0.334991, -0.206521,-0.156917,-0.176944, 0.151340,0.267484,0.166363, 0.265137,0.142280,0.210563, 0.260084,-0.156338,-0.156496, -0.285181,0.228137,0.064806, 0.037588,-0.329085,0.107655, -0.342176,0.100614,0.114501, 0.027780,-0.344569,0.033990, -0.089151,0.284625,-0.224057, -0.059164,-0.038562,-0.370660, 0.065038,-0.057055,-0.370660, 0.036995,0.362842,0.085406, 0.062303,-0.342427,0.023935, 0.217542,-0.181847,-0.229705, 0.212334,-0.166317,-0.250077, 0.224212,0.171137,0.236256, 0.080136,-0.332779,0.062684, 0.146779,-0.002116,0.303773, 0.264198,0.138603,0.222310, 0.247091,-0.191282,0.030659, 0.255431,0.046228,0.242430, 
+};
+// h15
+const int h15_numv = 16;
+const float h15_volu = 0.047330;
+const float h15_pos[3] = { 0.221274,0.213040,-0.893886 };
+const float h15_verts[ h15_numv * 3 ] = {
+  -0.273508,-0.247194,0.021075, -0.214206,0.249387,-0.106114, -0.394680,0.092354,-0.106114, 0.468273,-0.026582,-0.106114, -0.379467,-0.167569,-0.106114, -0.251710,-0.306163,-0.106114, -0.130453,-0.090301,0.212222, 0.215618,0.100683,0.162583, 0.108399,0.111587,0.216806, 0.543500,0.089559,-0.106114, 0.556660,0.080198,-0.106114, 0.496376,0.018888,-0.040935, 0.000444,-0.021162,0.246756, 0.322381,0.024676,0.097420, 0.541635,0.087788,-0.096097, 0.556215,0.081512,-0.106114, 
+};
+// h16
+const int h16_numv = 24;
+const float h16_volu = 0.105221;
+const float h16_pos[3] = { -0.230932,0.200668,-0.677519 };
+const float h16_verts[ h16_numv * 3 ] = {
+  0.072738,-0.155197,-0.322481, 0.178698,-0.234822,-0.195293, -0.074965,-0.293065,0.140297, -0.273605,-0.069158,-0.290106, -0.242978,0.154421,0.174559, 0.321753,-0.077929,-0.004145, 0.331656,-0.130769,0.158361, -0.234281,0.105965,-0.322481, 0.057526,0.104725,-0.322481, -0.070916,0.357222,-0.022485, 0.179075,-0.242477,-0.175878, 0.305221,-0.164260,0.133584, 0.289986,0.017556,0.326217, -0.205442,0.224195,0.181431, -0.273605,-0.056571,-0.322481, -0.016955,-0.298965,0.112984, -0.012263,0.183238,-0.322481, -0.122870,0.351842,-0.002882, -0.294606,-0.004741,-0.322481, -0.298324,-0.007565,-0.291615, 0.354068,-0.072999,0.110530, 0.306083,0.044665,0.287425, 0.072223,0.006072,0.394149, -0.095479,-0.122681,0.323101, 
+};
+// h17
+const int h17_numv = 26;
+const float h17_volu = 0.108916;
+const float h17_pos[3] = { 0.335926,-0.094685,-0.795267 };
+const float h17_verts[ h17_numv * 3 ] = {
+  0.319363,0.022871,0.098404, -0.388160,0.060531,-0.077543, 0.353621,0.281144,-0.204733, 0.207729,0.332401,-0.001198, 0.193656,-0.174383,-0.204733, -0.101947,-0.367894,-0.204733, -0.366362,0.001562,-0.204733, -0.261637,0.131093,0.251333, 0.356211,0.239639,0.008049, -0.212790,0.222354,0.228279, -0.038549,-0.388087,0.009431, -0.033495,-0.089469,0.376490, -0.054122,-0.396189,-0.026907, 0.286680,0.046139,0.166229, 0.206263,-0.213650,-0.062955, -0.030396,-0.389151,-0.001566, -0.086298,-0.398066,-0.084150, -0.233594,-0.288804,-0.204733, -0.114208,0.286563,0.148137, -0.245105,0.217424,0.113603, 0.376946,0.258587,-0.036908, 0.381724,0.326613,-0.139554, -0.147292,0.035735,0.332290, -0.235202,0.164584,0.276109, -0.333383,-0.146721,-0.204733, -0.387783,0.052876,-0.058130, 
+};
+// h18
+const int h18_numv = 18;
+const float h18_volu = 0.081077;
+const float h18_pos[3] = { 0.870716,-0.039183,-0.528244 };
+const float h18_verts[ h18_numv * 3 ] = {
+  -0.102809,0.184137,0.110997, 0.129284,0.393063,-0.471756, 0.129284,0.325763,0.151471, 0.124364,0.395398,-0.471756, -0.058424,-0.228234,-0.106332, 0.057106,-0.420144,0.161620, -0.248110,-0.009363,-0.100794, -0.231701,-0.091141,0.189666, 0.129284,-0.228234,-0.152159, 0.129284,-0.433667,0.164866, 0.129284,-0.166980,0.404939, -0.141510,-0.219557,0.299761, 0.129284,0.397646,-0.471756, -0.215427,-0.032631,-0.168619, 0.102902,0.388713,-0.463077, 0.129284,0.404181,-0.453605, -0.178579,0.184137,-0.258974, -0.157844,0.203085,-0.303931, 
+};
+// h19
+const int h19_numv = 16;
+const float h19_volu = 0.057269;
+const float h19_pos[3] = { 0.808301,-0.134672,-0.879100 };
+const float h19_verts[ h19_numv * 3 ] = {
+  0.052980,-0.361791,-0.120900, 0.191699,-0.339845,-0.120900, -0.030366,0.427910,-0.120900, 0.191699,0.488552,-0.120900, -0.118754,0.321131,-0.120900, 0.191699,-0.132745,0.198697, 0.186779,0.490887,-0.120900, 0.003992,-0.132745,0.244524, -0.153012,0.062857,0.182237, -0.153685,-0.263706,0.080920, -0.278719,-0.134396,-0.120900, -0.266112,-0.173663,0.020877, -0.090651,0.366600,-0.055721, -0.095429,0.298574,0.046924, -0.012422,0.433588,-0.120900, 0.165316,0.484202,-0.112221, 
+};
+// h20
+const int h20_numv = 30;
+const float h20_volu = 0.107509;
+const float h20_pos[3] = { 0.402458,0.140897,-0.404353 };
+const float h20_verts[ h20_numv * 3 ] = {
+  -0.100408,0.282050,-0.142576, 0.065914,0.236686,0.319509, -0.125820,0.203801,0.337118, 0.365449,0.004057,-0.012894, 0.056400,0.231781,0.327959, 0.034434,0.172826,-0.326950, -0.072786,0.183730,-0.272727, -0.247229,0.030507,0.295489, 0.136546,-0.281738,0.161639, 0.289679,0.004057,-0.382865, 0.141197,0.096819,-0.392113, -0.100966,-0.328728,-0.002677, -0.140953,-0.296194,0.011269, -0.180740,0.050981,-0.242777, -0.253566,0.024492,0.286206, -0.033492,0.282050,0.184162, 0.236557,-0.271221,0.065774, 0.154159,-0.311832,0.139278, -0.301735,-0.070997,-0.114805, -0.213824,-0.199847,-0.058625, -0.310451,0.100424,0.233258, -0.241567,0.131963,0.326249, -0.062874,0.247232,-0.227963, -0.327109,0.098788,0.164544, -0.279322,-0.013228,-0.162635, -0.343405,0.077327,0.053051, -0.313038,0.127071,0.015013, -0.327307,0.104436,0.014259, -0.100027,-0.325051,-0.014425, 0.220147,-0.189444,-0.224685, 
+};
+// h21
+const int h21_numv = 20;
+const float h21_volu = 0.107886;
+const float h21_pos[3] = { -0.701261,0.516623,-0.734170 };
+const float h21_verts[ h21_numv * 3 ] = {
+  0.220060,-0.162111,0.233880, -0.071194,0.139979,-0.265830, 0.326350,0.086982,0.076961, 0.175723,-0.320696,-0.265830, -0.194481,0.286846,0.262411, 0.236048,-0.209990,-0.265830, -0.298739,0.200252,0.166960, 0.264887,-0.091760,0.238083, 0.347459,0.035887,0.053770, -0.298739,0.031984,-0.265830, -0.298739,-0.199980,-0.038920, -0.298739,-0.170573,-0.265830, -0.064116,-0.283496,0.032682, 0.172005,-0.323520,-0.234964, 0.067327,0.317485,0.021628, 0.227351,-0.161534,0.231210, 0.015724,0.286846,0.365050, -0.065674,0.367082,0.311546, 0.153155,0.171345,0.362933, 0.139764,0.180879,0.371107, 
+};
+// h22
+const int h22_numv = 14;
+const float h22_volu = 0.065276;
+const float h22_pos[3] = { -0.383570,0.726249,-0.891974 };
+const float h22_verts[ h22_numv * 3 ] = {
+  0.403835,0.273751,-0.108026, -0.250365,0.107859,0.179431, -0.224444,0.273751,-0.108026, 0.311631,-0.076337,-0.108026, -0.388885,-0.069647,-0.108026, 0.349740,0.107545,0.033083, 0.400677,0.273751,-0.064850, -0.189576,0.273751,0.079255, 0.008658,-0.122644,0.234765, -0.081643,-0.419616,-0.108026, 0.029768,-0.173739,0.211573, 0.125191,-0.098941,0.194122, 0.140375,-0.342343,-0.108026, 0.081722,-0.168359,0.191970, 
+};
+// h23
+const int h23_numv = 16;
+const float h23_volu = 0.051599;
+const float h23_pos[3] = { -0.800668,0.450995,-0.472891 };
+const float h23_verts[ h23_numv * 3 ] = {
+  0.035291,-0.217869,-0.228598, -0.199332,-0.134353,-0.300199, -0.199332,0.265879,-0.094319, -0.095074,0.352473,0.001132, -0.199332,-0.001690,0.132407, -0.199332,-0.208186,-0.186260, 0.189555,0.299490,0.167366, -0.199332,0.309177,-0.027504, -0.064385,-0.049725,0.223009, -0.036116,-0.285650,-0.106564, 0.116475,0.143410,0.211970, 0.319467,-0.096483,-0.027399, 0.092916,-0.255030,0.098198, 0.194883,-0.191512,0.077971, 0.239171,0.246507,0.109828, 0.115131,0.352473,0.103771, 
+};
+// h24
+const int h24_numv = 12;
+const float h24_volu = 0.050770;
+const float h24_pos[3] = { -0.845297,0.862613,-0.757515 };
+const float h24_verts[ h24_numv * 3 ] = {
+  0.078361,0.021092,0.334891, -0.154703,-0.145738,0.190305, -0.154703,0.137387,-0.242485, -0.154703,-0.314006,-0.242485, 0.072842,-0.206011,-0.242485, 0.237283,0.137387,-0.242485, -0.154703,-0.102441,0.257120, -0.050445,-0.059144,0.285756, 0.211362,-0.028505,0.044972, -0.154703,0.137387,0.380489, 0.272151,0.137387,-0.055204, 0.060041,0.137387,0.393596, 
+};
+// h25
+const int h25_numv = 16;
+const float h25_volu = 0.064196;
+const float h25_pos[3] = { 0.265380,0.609017,-0.859766 };
+const float h25_verts[ h25_numv * 3 ] = {
+  0.171512,-0.295294,0.128463, -0.112864,0.390983,-0.140234, -0.179972,0.258217,0.163631, -0.171482,0.390983,0.031499, -0.146465,0.312621,0.159756, 0.063572,-0.117444,0.267684, -0.245115,0.390983,-0.140234, -0.337319,0.040895,-0.140234, 0.499394,-0.306418,-0.140234, 0.112578,-0.021086,0.259138, 0.074204,-0.220888,0.227450, 0.064293,-0.284390,0.182686, -0.258312,-0.146590,-0.140234, 0.497529,-0.308188,-0.130217, -0.299210,0.224777,0.000875, -0.248273,0.390983,-0.097058, 
+};
+// h26
+const int h26_numv = 24;
+const float h26_volu = 0.101687;
+const float h26_pos[3] = { -0.341007,0.877992,-0.537072 };
+const float h26_verts[ h26_numv * 3 ] = {
+  0.358114,0.122008,-0.419752, -0.168425,-0.052359,0.397165, -0.220490,-0.180490,0.174009, 0.459922,0.043646,-0.162938, 0.324251,-0.109249,-0.070985, -0.202046,0.011183,0.424477, 0.252084,0.007514,0.202105, -0.286958,0.122008,0.388199, 0.307177,-0.044198,-0.321819, 0.426415,-0.010758,-0.159063, 0.082627,-0.250684,-0.160780, -0.033904,-0.274387,-0.120138, -0.232139,0.122008,-0.275647, -0.292928,-0.043884,-0.175471, -0.344531,-0.074523,0.167952, -0.207099,-0.190024,0.165835, -0.444249,0.122008,0.173153, -0.425929,0.005713,0.114448, 0.327136,0.122008,0.185091, -0.202046,0.122008,0.443480, 0.434905,0.122008,-0.291195, 0.483509,0.122008,-0.120325, -0.187210,-0.038985,0.408631, -0.270106,-0.127507,0.231547, 
+};
+// h27
+const int h27_numv = 24;
+const float h27_volu = 0.100588;
+const float h27_pos[3] = { 0.167088,0.649940,-0.364014 };
+const float h27_verts[ h27_numv * 3 ] = {
+  -0.183844,0.118803,-0.244043, -0.044353,-0.266136,0.405236, -0.256011,0.235567,0.029047, 0.161864,-0.158366,-0.228068, 0.300539,0.065664,-0.127155, -0.024586,0.350060,-0.293383, -0.048173,0.271698,-0.335996, -0.180959,0.350060,0.012033, -0.081680,0.217294,-0.332121, -0.044357,0.350060,0.088262, -0.006196,-0.377080,0.285910, 0.201878,-0.226993,0.143823, -0.003872,-0.277036,0.420726, 0.210870,-0.062009,-0.236614, -0.003871,0.350060,0.098146, 0.183618,0.350060,-0.130723, -0.165155,-0.254165,0.331667, -0.075081,-0.408619,0.192919, -0.091738,-0.410255,0.124205, 0.005721,-0.287236,0.414262, -0.077668,-0.381972,-0.025325, -0.102748,-0.401170,0.182332, 0.134962,-0.226993,-0.182915, 0.109551,-0.305242,0.296779, 
+};
+// h28
+const int h28_numv = 18;
+const float h28_volu = 0.075441;
+const float h28_pos[3] = { 0.013616,0.472900,-0.719797 };
+const float h28_verts[ h28_numv * 3 ] = {
+  -0.187022,-0.167506,-0.280203, 0.109520,-0.345231,0.152809, -0.085555,0.177012,-0.280203, -0.271995,0.154408,0.021945, -0.030372,0.295843,0.111740, 0.061535,-0.227567,0.329703, 0.075804,-0.204932,0.330457, 0.071792,0.394334,0.023662, 0.208102,-0.281022,0.072668, -0.047446,0.360894,-0.139094, 0.077205,-0.350161,0.038133, -0.006548,-0.010473,-0.280203, 0.288434,-0.049953,0.172868, 0.315336,0.018674,0.127715, 0.316057,-0.148273,0.042717, 0.325968,-0.084770,0.087482, -0.256811,-0.088994,-0.280203, -0.315464,0.084990,0.019794, 
+};
+// h29
+const int h29_numv = 20;
+const float h29_volu = 0.090754;
+const float h29_pos[3] = { -0.195482,0.549508,-0.348926 };
+const float h29_verts[ h29_numv * 3 ] = {
+  -0.062897,0.077801,-0.348926, 0.254536,-0.331284,-0.002375, -0.179429,0.054098,-0.308283, 0.178726,0.219235,-0.259131, -0.352624,0.138460,-0.022310, 0.259822,-0.300738,0.167244, 0.197415,-0.153733,0.316579, 0.065987,-0.327570,0.133724, 0.114982,-0.134660,0.333685, 0.270633,-0.304175,-0.041168, -0.106366,0.008382,-0.351078, 0.106560,0.335999,0.013959, -0.240892,-0.124645,-0.147161, -0.313950,0.276125,0.209019, -0.158320,0.003002,-0.331475, 0.036774,-0.342768,0.065557, 0.284902,-0.281540,-0.040413, 0.270832,-0.309823,0.109117, 0.013405,-0.084041,0.336165, 0.046528,-0.137097,0.329090, 
+};
+// h30
+const int h30_numv = 26;
+const float h30_volu = 0.141813;
+const float h30_pos[3] = { 0.709749,0.432546,-0.520590 };
+const float h30_verts[ h30_numv * 3 ] = {
+  0.086130,-0.133630,-0.479410, 0.290251,-0.067548,-0.461259, 0.290251,0.254276,-0.130163, -0.166094,-0.194830,-0.275875, -0.114073,0.017151,0.452790, 0.263868,-0.083016,-0.470730, -0.015645,0.141724,0.383369, -0.170984,0.316821,0.046789, -0.242122,0.283058,0.029421, 0.290251,0.110614,0.239339, -0.340783,-0.009598,0.300399, 0.290251,-0.018830,0.261535, 0.067740,-0.137994,-0.479410, -0.241377,-0.054963,0.435747, 0.058158,-0.287592,0.103343, 0.290251,-0.145966,0.143817, 0.068185,-0.139308,-0.479410, -0.017612,-0.287592,-0.266628, 0.053160,-0.131717,-0.469392, -0.272857,-0.118823,-0.210712, 0.007901,-0.200618,-0.414231, 0.003123,-0.268644,-0.311584, -0.331791,0.155385,-0.080037, -0.407699,-0.009598,-0.026339, -0.380797,0.059028,-0.071491, -0.370165,-0.044416,-0.111725, 
+};
+// h31
+const int h31_numv = 20;
+const float h31_volu = 0.145607;
+const float h31_pos[3] = { 0.628702,0.773411,-0.793457 };
+const float h31_verts[ h31_numv * 3 ] = {
+  -0.189575,0.226589,0.317223, 0.371298,-0.414948,-0.206543, -0.476185,0.226589,-0.206543, 0.371298,0.226589,-0.206543, -0.250744,-0.185480,0.192828, 0.148787,-0.478859,-0.206543, -0.509787,0.148227,0.093447, -0.534804,0.226589,-0.034811, -0.277996,0.226589,0.298719, -0.486200,0.226589,0.136059, 0.371298,-0.408413,-0.188392, 0.167177,-0.474495,-0.206543, 0.366378,-0.417196,-0.206543, 0.344915,-0.423881,-0.197864, 0.371298,-0.086589,0.142703, 0.371298,0.226589,0.089002, -0.161075,-0.057807,0.302287, -0.089936,-0.024044,0.319655, 0.134207,-0.472582,-0.196526, 0.136072,-0.470812,-0.206543, 
+};
+// h32
+const int h32_numv = 22;
+const float h32_volu = 0.092552;
+const float h32_pos[3] = { -0.648077,-0.694629,-0.055690 };
+const float h32_verts[ h32_numv * 3 ] = {
+  -0.351923,0.020682,-0.162313, -0.351923,0.291038,-0.298522, 0.116588,0.074450,0.304425, 0.180292,0.145010,-0.063690, -0.351923,0.286862,-0.299238, 0.082653,-0.305371,0.200452, 0.444715,-0.214767,0.086986, 0.440565,-0.305371,0.060643, 0.437298,-0.305371,0.003205, 0.441236,-0.180086,0.007980, 0.202670,-0.305371,-0.129990, -0.122926,-0.305371,-0.050498, -0.351923,0.343433,0.003710, 0.034975,0.067995,0.334312, -0.249787,0.361137,-0.236631, 0.059834,0.222599,0.089656, 0.420946,-0.305371,-0.023410, 0.437088,-0.283432,-0.011766, -0.351923,0.387353,-0.064067, -0.294272,0.397125,-0.093222, -0.351923,0.309463,-0.280428, -0.321961,0.320573,-0.278827, 
+};
+// h33
+const int h33_numv = 18;
+const float h33_volu = 0.056945;
+const float h33_pos[3] = { -0.288352,-0.547292,0.050646 };
+const float h33_verts[ h33_numv * 3 ] = {
+  0.084990,-0.362104,-0.019350, -0.079434,0.021164,0.334816, 0.019488,-0.072734,0.262363, 0.115516,0.076855,-0.268585, 0.213070,0.021874,-0.243280, 0.274323,0.089944,-0.132397, 0.019789,0.332949,0.053313, 0.257211,0.025988,-0.078610, 0.131191,0.288888,-0.060012, 0.118204,-0.320377,0.031687, 0.081511,-0.327423,-0.098356, -0.243137,-0.072887,0.198089, -0.179433,-0.002327,-0.170026, -0.299891,0.075262,-0.016680, -0.055817,0.322184,0.088384, -0.038680,0.277450,0.153234, 0.148159,-0.119839,-0.229545, 0.048588,0.033746,-0.272086, 
+};
+// h34
+const int h34_numv = 24;
+const float h34_volu = 0.086482;
+const float h34_pos[3] = { -0.499709,-0.643458,-0.327986 };
+const float h34_verts[ h34_numv * 3 ] = {
+  -0.500291,0.235691,-0.026942, -0.413349,0.203755,-0.157062, -0.223651,0.321490,-0.139249, 0.209880,-0.356542,0.003973, 0.365162,-0.137565,0.097393, 0.292868,-0.231257,0.280276, 0.359516,-0.023673,0.149087, -0.329463,0.339839,-0.019523, -0.041433,0.349469,-0.148408, 0.054302,-0.356542,0.142306, 0.272578,-0.356542,0.248886, 0.288720,-0.334603,0.260530, 0.023896,-0.069111,-0.283979, 0.274970,-0.222320,-0.056303, 0.127449,-0.356542,-0.036276, -0.035189,-0.103922,-0.288953, -0.023751,0.360733,-0.121029, -0.500291,0.237083,-0.030523, -0.346425,0.336124,-0.010604, 0.259945,0.129913,0.106546, -0.500291,0.239867,-0.026226, -0.470329,0.269402,-0.006532, -0.398155,0.309966,0.035665, 0.031924,0.093839,0.208606, 
+};
+// h35
+const int h35_numv = 12;
+const float h35_volu = 0.072358;
+const float h35_pos[3] = { -0.852811,-0.781078,0.150064 };
+const float h35_verts[ h35_numv * 3 ] = {
+  -0.147189,-0.218922,0.332047, 0.103613,-0.074924,0.288589, -0.147189,0.429882,-0.202044, -0.147189,-0.218922,-0.312160, 0.239709,0.154443,0.128558, 0.287386,-0.218922,-0.005301, -0.043492,-0.218922,0.344705, 0.074717,-0.218922,0.306226, -0.147189,0.402063,0.012610, 0.208223,0.167113,0.176854, -0.147189,0.107130,-0.368067, 0.081807,-0.218922,-0.256252, 
+};
+// h36
+const int h36_numv = 18;
+const float h36_volu = 0.076715;
+const float h36_pos[3] = { 0.330903,-0.599381,-0.308448 };
+const float h36_verts[ h36_numv * 3 ] = {
+  0.235744,-0.093981,0.208985, 0.157036,0.091360,0.296934, -0.213473,-0.059832,-0.258208, 0.131366,0.084254,0.304768, 0.060949,-0.352878,-0.040467, 0.031132,-0.367472,0.023458, -0.038178,0.319175,-0.078462, 0.346140,-0.033881,-0.005840, 0.305466,-0.106272,-0.107625, -0.256020,-0.056138,-0.213238, -0.331115,0.110184,0.014099, -0.356965,0.085987,0.067218, 0.185622,-0.147504,0.212044, 0.241393,0.219660,0.109239, -0.343391,-0.100844,-0.022261, -0.046519,0.081665,-0.290234, -0.272849,0.156195,0.144404, -0.146830,0.270831,-0.017119, 
+};
+// h37
+const int h37_numv = 18;
+const float h37_volu = 0.098217;
+const float h37_pos[3] = { 0.055330,-0.588368,0.333127 };
+const float h37_verts[ h37_numv * 3 ] = {
+  -0.107417,0.016721,0.347927, 0.283844,-0.036335,0.197820, 0.129290,0.324988,-0.064466, -0.012100,0.128834,-0.356552, 0.344968,0.171444,-0.038138, -0.270436,0.127441,0.395275, -0.130084,-0.375511,-0.154724, 0.001812,-0.380727,-0.087638, -0.247911,0.142505,0.383526, 0.360906,0.133475,0.137346, 0.062042,-0.352141,-0.072933, 0.261216,0.073240,-0.194499, 0.127844,0.325300,-0.059106, 0.361773,0.137946,0.130076, -0.225478,-0.279302,-0.250794, -0.324194,-0.031659,-0.020118, -0.297963,0.086614,0.328910, -0.086471,0.067064,-0.361091, 
+};
+// h38
+const int h38_numv = 28;
+const float h38_volu = 0.093559;
+const float h38_pos[3] = { 0.133166,-0.773583,-0.050905 };
+const float h38_verts[ h38_numv * 3 ] = {
+  -0.076024,-0.195512,0.296394, 0.264846,-0.226417,0.026836, 0.183380,0.258456,0.189533, -0.015793,-0.166926,0.311098, -0.267713,-0.007440,-0.179688, -0.159228,0.260189,-0.190326, -0.343945,-0.226417,-0.001580, -0.273359,0.106452,-0.127994, 0.216958,-0.226417,-0.206989, 0.383359,0.026697,-0.045499, 0.329103,0.258456,0.047225, -0.089936,0.314049,0.027481, -0.145654,0.073358,-0.279804, 0.228869,-0.193270,-0.234086, -0.131382,0.326289,-0.026485, -0.075112,0.330397,-0.113139, -0.208448,0.248166,-0.141729, -0.011151,-0.226417,0.296364, -0.211663,-0.226417,0.216210, -0.072038,-0.226417,0.288931, -0.336528,-0.135813,0.082201, -0.147195,0.316236,-0.030846, -0.340678,-0.226417,0.055858, -0.164307,0.252279,0.022941, -0.344155,-0.204478,-0.016551, -0.340007,-0.101132,0.003195, -0.207920,-0.190296,0.229308, -0.303314,-0.094086,0.133238, 
+};
+// h39
+const int h39_numv = 32;
+const float h39_volu = 0.060173;
+const float h39_pos[3] = { -0.130993,-0.349156,0.297470 };
+const float h39_verts[ h39_numv * 3 ] = {
+  0.132777,-0.098138,-0.374861, 0.174223,-0.110378,-0.320895, -0.236793,-0.176972,0.087992, 0.120090,0.163784,-0.274197, -0.036262,0.126682,-0.293283, -0.239846,-0.040235,0.342234, -0.196039,0.079314,-0.093590, -0.026168,0.090752,-0.306837, -0.084113,-0.111771,0.430932, -0.132771,0.138527,-0.197817, -0.061588,-0.096707,0.419183, -0.167047,-0.030107,0.457226, 0.314167,0.086089,-0.023449, 0.140527,0.255266,-0.004320, -0.137571,0.134813,-0.193511, 0.315613,0.085777,-0.028809, 0.116964,-0.108191,-0.379221, 0.099852,-0.172148,-0.325434, -0.176687,-0.026318,0.447418, -0.168971,-0.023213,0.453768, -0.137871,-0.270870,0.015539, -0.111640,-0.152598,0.364567, -0.122362,-0.092357,0.456223, -0.127730,-0.079472,0.460978, -0.243030,-0.080780,0.324741, -0.136583,-0.114124,0.420896, -0.241856,-0.054541,0.348612, -0.178625,-0.028253,0.445248, -0.171209,-0.024409,0.453290, -0.169333,-0.024798,0.455225, 0.224076,0.244621,-0.088171, 0.213513,0.251212,-0.061379, 
+};
+// h40
+const int h40_numv = 24;
+const float h40_volu = 0.115424;
+const float h40_pos[3] = { 0.492476,-0.748212,0.263785 };
+const float h40_verts[ h40_numv * 3 ] = {
+  -0.375103,-0.192297,-0.003592, 0.259307,0.208511,0.137583, 0.097667,-0.251788,0.295436, 0.264741,-0.251788,-0.112461, -0.092178,0.331289,0.031204, 0.024049,0.001327,-0.360189, 0.074171,0.054850,-0.363248, 0.312772,-0.115013,-0.159366, -0.175930,0.233085,-0.125157, -0.094464,-0.251788,-0.287854, -0.004537,0.240191,-0.275299, -0.030207,0.233085,-0.267465, -0.370461,-0.251788,-0.018326, 0.056736,-0.251788,0.315422, -0.153302,0.123509,0.267162, -0.068302,0.078845,0.319783, 0.171724,0.348803,0.156293, 0.053571,0.367605,-0.023060, -0.075373,0.297791,0.199418, 0.109457,0.331072,0.189737, -0.005042,0.303901,0.226077, 0.014996,0.282164,0.244247, -0.076239,0.293319,0.206688, -0.068649,0.297216,0.207331, 
+};
+// h41
+const int h41_numv = 18;
+const float h41_volu = 0.076473;
+const float h41_pos[3] = { 0.741085,-0.876917,-0.246261 };
+const float h41_verts[ h41_numv * 3 ] = {
+  0.005338,0.140795,-0.243701, -0.174437,0.183555,0.146798, 0.258916,-0.123083,-0.387389, 0.103129,0.222017,-0.142233, 0.164192,-0.123083,-0.418224, 0.016133,-0.123083,0.397585, 0.258916,0.168617,-0.137303, 0.258916,-0.123083,0.279039, -0.343073,-0.123083,0.222192, -0.064041,0.243655,-0.068027, -0.104715,0.171264,-0.169812, -0.390960,-0.123083,-0.011633, -0.224559,0.130032,0.149857, -0.379049,-0.089936,-0.038730, -0.349233,-0.075342,-0.102654, -0.337817,-0.123083,-0.124077, 0.258916,-0.009416,0.259549, 0.064164,0.013692,0.350680, 
+};
+// h42
+const int h42_numv = 26;
+const float h42_volu = 0.137951;
+const float h42_pos[3] = { 0.814994,-0.482932,0.027418 };
+const float h42_verts[ h42_numv * 3 ] = {
+  -0.063211,-0.056769,0.373950, 0.185005,0.097851,0.415613, -0.248347,-0.210430,-0.126881, 0.112828,0.023604,-0.394042, -0.108847,0.115253,0.400661, -0.327055,-0.025089,-0.038931, -0.085789,0.224192,-0.255901, 0.185005,-0.403401,-0.014130, 0.185005,-0.225368,-0.410982, -0.009747,-0.380293,0.077002, -0.175394,0.222730,-0.208732, 0.002670,0.221670,0.389944, -0.150794,0.083523,0.392660, 0.160182,0.229752,0.436714, 0.133897,0.345057,0.231744, -0.006362,0.255606,0.329122, 0.185005,0.234054,0.438967, 0.185005,0.352490,0.238788, 0.029219,-0.171968,-0.415912, -0.137952,-0.150330,-0.341706, 0.185005,0.276769,-0.150723, 0.185005,0.010082,-0.390796, -0.176045,0.220413,-0.220256, -0.242698,0.103211,-0.226628, -0.268948,0.102325,0.213307, -0.248100,0.136462,0.190657, 
+};
+// h43
+const int h43_numv = 26;
+const float h43_volu = 0.091347;
+const float h43_pos[3] = { -0.439313,0.395062,-0.161996 };
+const float h43_verts[ h43_numv * 3 ] = {
+  -0.171800,0.355423,-0.143529, -0.041887,-0.040549,-0.338294, -0.088904,0.443945,0.033555, -0.050746,0.256028,0.267789, -0.120718,0.085236,0.331241, 0.112903,-0.317075,-0.192421, -0.024680,-0.380539,0.081401, 0.014540,-0.410443,-0.096363, -0.166472,-0.135578,-0.232924, -0.179653,0.199344,0.219565, 0.056744,-0.387608,-0.004660, -0.088904,0.425462,0.081094, -0.046327,-0.413563,-0.075262, -0.024725,0.299814,0.247575, -0.150602,0.151087,0.286944, -0.050613,-0.134365,0.334664, -0.244880,0.199344,-0.098926, -0.122184,0.302440,-0.201067, -0.108793,0.292906,-0.209241, -0.034597,-0.039973,-0.340964, 0.309817,-0.173124,-0.053206, -0.070119,0.430571,0.022089, 0.002939,0.029802,-0.334091, 0.280604,-0.188322,-0.121373, 0.290359,0.017349,0.142160, 0.257236,0.070405,0.149235, 
+};
+// h44
+const int h44_numv = 26;
+const float h44_volu = 0.104111;
+const float h44_pos[3] = { -0.656166,-0.300748,0.215302 };
+const float h44_verts[ h44_numv * 3 ] = {
+  -0.220317,0.235145,-0.208278, 0.078796,0.351295,-0.102059, 0.283317,-0.102949,0.430780, 0.285327,-0.088643,0.424402, 0.201177,0.226255,-0.138992, 0.124677,-0.319431,0.033433, 0.117727,0.304230,-0.184196, 0.043064,-0.325887,0.063320, -0.138842,0.186808,-0.302762, 0.311997,0.075640,-0.076273, 0.067923,-0.171282,-0.181336, -0.343834,-0.050448,-0.267282, -0.343834,-0.078267,-0.052628, -0.343834,0.035932,0.053112, 0.088073,0.239020,0.159535, 0.282143,-0.129188,0.406909, -0.286183,0.003244,-0.364214, -0.343834,0.054532,0.043544, 0.011578,-0.313217,0.111616, 0.329134,0.030906,-0.011422, 0.089881,-0.140507,0.355648, 0.092412,-0.225203,0.279944, 0.288380,-0.225380,0.170160, 0.101854,0.336248,-0.130909, -0.343834,-0.006528,-0.335059, -0.343834,0.160238,-0.192084, 
+};
+// h45
+const int h45_numv = 22;
+const float h45_volu = 0.073607;
+const float h45_pos[3] = { -0.692003,0.228592,-0.074767 };
+const float h45_verts[ h45_numv * 3 ] = {
+  0.206363,-0.247093,-0.162491, 0.114633,-0.178045,0.188010, 0.007810,0.365814,-0.186155, -0.306616,-0.033345,0.126518, -0.055718,0.198405,0.254002, 0.153565,-0.225110,0.105873, -0.184480,-0.294195,0.081791, 0.073037,0.365814,0.132336, 0.155930,-0.080562,0.225951, -0.173050,0.172678,-0.175116, -0.103005,-0.342532,-0.012694, -0.015749,-0.330108,-0.146901, 0.086218,0.030892,-0.320153, -0.015750,-0.032626,-0.299926, 0.228010,-0.214069,-0.005829, 0.104078,0.176805,0.286842, 0.137691,-0.193092,0.159160, 0.102087,0.317557,0.199715, -0.062260,0.197254,0.252076, 0.131971,0.251706,0.244012, 0.186972,0.021095,0.262581, 0.202077,0.032105,0.247435, 
+};
+// h46
+const int h46_numv = 24;
+const float h46_volu = 0.077166;
+const float h46_pos[3] = { -0.506861,-0.263372,-0.148064 };
+const float h46_verts[ h46_numv * 3 ] = {
+  -0.435488,-0.034132,-0.000849, 0.039076,-0.286247,0.028683, -0.031577,0.266854,0.179170, 0.042868,0.277895,0.067468, 0.334025,-0.207064,-0.069876, -0.200891,0.161856,-0.073604, -0.329922,-0.035641,-0.192524, -0.391003,-0.070120,-0.144257, 0.124292,0.270826,-0.018593, -0.288147,0.149432,0.060603, 0.051872,0.188879,0.224374, -0.081382,-0.208658,0.182030, 0.243097,0.052743,0.247717, 0.267097,-0.250173,-0.073376, 0.162691,0.038264,0.287094, 0.339607,0.040898,0.152251, 0.238297,0.049029,0.252023, 0.349700,0.004968,0.138697, 0.021220,0.244871,-0.089194, -0.322311,-0.040247,-0.199445, -0.016599,-0.019353,-0.300951, 0.082088,0.247991,-0.110295, -0.339273,-0.043963,-0.190526, 0.082087,0.036350,-0.291745, 
+};
+// h47
+const int h47_numv = 36;
+const float h47_volu = 0.096745;
+const float h47_pos[3] = { -0.132135,0.108975,0.072319 };
+const float h47_verts[ h47_numv * 3 ] = {
+  0.298509,0.263511,-0.009995, -0.406303,-0.105494,-0.041213, 0.295351,0.263929,-0.015607, -0.362255,0.123840,0.142831, -0.016819,0.303436,-0.092155, 0.214655,-0.206919,0.163772, 0.119596,0.038081,0.333996, -0.357791,0.151721,0.100349, 0.141669,-0.202865,0.220831, -0.322854,-0.183468,0.003991, -0.422177,-0.073475,0.012073, 0.248529,0.277838,-0.020262, -0.331858,-0.094452,-0.152914, -0.250434,-0.101521,-0.238975, -0.131628,-0.319604,0.027334, 0.281027,0.056414,-0.190466, 0.134068,0.286800,-0.104666, 0.293847,0.266235,0.003176, -0.403938,0.039055,0.078865, -0.372896,0.140712,0.115495, -0.035119,-0.331449,-0.068132, 0.121232,-0.294347,-0.049046, 0.051634,0.305873,-0.087560, 0.254870,0.274829,-0.031097, 0.196475,0.139795,-0.254001, 0.002640,0.112963,-0.287521, 0.198447,0.073853,0.288417, 0.224142,0.132346,-0.243414, 0.225218,-0.213510,0.136980, 0.298178,-0.027388,0.023425, 0.292448,0.199019,0.106734, 0.304944,0.253729,-0.022071, 0.308556,0.186869,0.065231, 0.305066,0.254217,-0.020526, 0.293027,0.163885,-0.150423, 0.287364,0.062429,-0.181183, 
+};
+// h48
+const int h48_numv = 24;
+const float h48_volu = 0.097516;
+const float h48_pos[3] = { 0.292729,-0.243911,-0.041409 };
+const float h48_verts[ h48_numv * 3 ] = {
+  -0.303632,0.058539,0.064682, -0.108656,-0.084639,-0.284158, 0.263889,0.072976,-0.223666, 0.274166,-0.102559,0.259484, 0.253318,-0.136696,0.282134, 0.346872,-0.016291,-0.139905, -0.290945,-0.203383,-0.035982, 0.008763,0.056080,-0.365621, 0.246275,0.103070,-0.201305, 0.107569,-0.173012,0.336398, -0.249499,-0.215623,0.017984, -0.234675,-0.199275,-0.122635, 0.023817,-0.271216,0.180037, 0.169540,-0.271216,0.037729, -0.126686,0.325499,0.137154, 0.195210,-0.264110,0.029895, 0.346221,-0.018608,-0.151429, 0.279567,-0.135810,-0.157801, -0.143837,0.409300,-0.076739, -0.137500,0.415315,-0.067456, -0.031223,0.088614,-0.351675, -0.000004,-0.036295,-0.345501, -0.199646,0.139376,0.250708, -0.108109,-0.019468,0.310070, 
+};
+// h49
+const int h49_numv = 30;
+const float h49_volu = 0.103417;
+const float h49_pos[3] = { -0.082648,-0.117151,-0.277803 };
+const float h49_verts[ h49_numv * 3 ] = {
+  0.344154,-0.038146,-0.115281, -0.165239,0.018854,-0.286732, -0.342125,0.101770,0.019444, -0.222234,-0.108669,-0.237036, -0.321677,-0.099820,-0.189997, 0.084432,-0.330143,0.200412, -0.076061,0.323891,-0.005566, -0.299921,0.124605,0.111147, -0.223248,0.024754,-0.259418, 0.141702,0.335375,-0.073499, 0.231540,0.282540,0.159656, 0.156937,0.153559,-0.266131, -0.243762,0.195138,-0.076614, -0.084607,-0.105324,0.281990, 0.266721,-0.211399,-0.047765, 0.071745,-0.068221,0.301076, -0.090188,-0.353285,0.059864, -0.342125,-0.109871,-0.162005, -0.074513,-0.141253,0.268436, 0.140702,-0.326035,0.113759, 0.082436,-0.372046,-0.016546, 0.056586,-0.396243,0.036572, 0.007365,-0.408266,0.085169, 0.068619,-0.340196,0.196052, 0.183372,0.187050,-0.241355, 0.271282,0.058201,-0.185174, 0.174655,0.358472,0.106708, -0.046848,0.339089,0.062601, 0.146988,0.365921,0.096121, 0.157998,0.356836,0.037994, 
+};
+// h50
+const int h50_numv = 20;
+const float h50_volu = 0.069183;
+const float h50_pos[3] = { -0.304007,-0.060848,0.383791 };
+const float h50_verts[ h50_numv * 3 ] = {
+  0.035443,-0.153495,-0.279832, 0.291468,0.207904,0.022524, -0.264086,-0.000880,-0.008953, -0.190383,0.293663,-0.168640, 0.004043,-0.311521,0.367447, -0.001962,-0.311376,0.364440, -0.150982,-0.013645,-0.307481, -0.250305,0.096348,-0.299398, 0.040243,-0.149781,-0.284138, -0.040162,-0.164260,-0.244761, -0.228192,0.064423,0.060664, 0.001805,-0.312717,0.366969, -0.232066,0.208878,-0.232607, -0.273363,0.111395,-0.270548, 0.313541,-0.033043,-0.090641, -0.003673,-0.314626,0.361097, -0.023025,-0.208994,-0.179911, -0.066832,-0.328543,0.255913, -0.170020,0.271491,-0.017447, 0.190786,0.198102,0.196479, 
+};
+// h51
+const int h51_numv = 20;
+const float h51_volu = 0.097496;
+const float h51_pos[3] = { 0.796238,0.092236,-0.101631 };
+const float h51_verts[ h51_numv * 3 ] = {
+  -0.221011,0.347408,0.061823, -0.319697,0.291705,0.052616, 0.203762,-0.222678,0.367837, -0.200562,0.357460,0.033830, 0.203762,0.194344,-0.275142, -0.239620,-0.263171,-0.163444, 0.152653,-0.230111,0.360793, 0.203762,0.321480,-0.157424, -0.337380,0.280442,0.025237, -0.327866,0.285347,0.016786, -0.028332,0.052718,-0.315616, 0.203762,-0.298399,-0.021674, -0.257234,-0.233077,-0.141083, -0.157288,-0.354755,-0.091207, 0.203762,0.006585,0.328526, -0.156637,-0.352438,-0.079683, 0.030926,0.103995,0.283692, -0.036002,0.060886,0.280191, -0.157223,-0.222560,-0.236947, -0.067033,-0.350976,-0.126852, 
+};
+// h52
+const int h52_numv = 16;
+const float h52_volu = 0.084293;
+const float h52_pos[3] = { 0.513157,0.018456,0.067444 };
+const float h52_verts[ h52_numv * 3 ] = {
+  -0.347114,0.063132,0.028301, -0.352265,0.254404,-0.145548, 0.247079,0.134666,0.111116, -0.336736,0.277388,0.070106, 0.126444,-0.278658,-0.248758, -0.340226,0.344736,-0.015651, 0.295476,-0.245782,0.289096, -0.054299,0.354222,-0.143838, 0.053738,-0.364926,0.150631, -0.036616,0.365485,-0.116459, 0.025847,-0.159297,-0.310158, -0.357928,0.152948,-0.176308, 0.019058,0.098592,0.213176, 0.435734,-0.156331,0.191718, -0.340348,0.344248,-0.017196, -0.236518,0.326242,-0.134679, 
+};
+// h53
+const int h53_numv = 16;
+const float h53_volu = 0.086476;
+const float h53_pos[3] = { -0.781555,0.807509,0.197497 };
+const float h53_verts[ h53_numv * 3 ] = {
+  0.291496,-0.156419,-0.091704, -0.218445,0.192491,0.461269, -0.218445,0.192491,-0.255541, -0.218445,-0.397567,0.047987, 0.027292,-0.381663,-0.020188, -0.218445,-0.373860,0.169935, 0.033835,-0.380512,-0.018262, 0.352556,0.192491,0.043056, 0.162589,-0.213103,-0.139928, 0.191640,-0.261360,-0.072549, 0.238502,0.192491,-0.291089, 0.253338,0.013015,-0.278399, 0.326334,-0.087525,-0.081781, 0.317517,-0.112633,-0.111918, 0.238502,0.081667,-0.310092, 0.153590,0.192491,-0.346370, 
+};
+// h54
+const int h54_numv = 20;
+const float h54_volu = 0.089003;
+const float h54_pos[3] = { -0.845912,0.679404,-0.140778 };
+const float h54_verts[ h54_numv * 3 ] = {
+  0.317695,0.141120,0.059877, 0.091649,-0.253558,0.318087, -0.154088,0.080768,-0.359617, -0.152707,-0.484157,0.192529, -0.154088,0.320596,0.082735, 0.078976,0.204301,-0.281846, -0.154088,-0.269462,0.386262, -0.154088,0.320596,-0.236248, -0.154088,-0.484416,0.192760, 0.226946,-0.084997,0.198347, 0.060656,0.320596,-0.223141, 0.161719,-0.084997,-0.120143, 0.217947,0.320596,-0.008094, -0.049829,0.124065,-0.330981, -0.154088,-0.230098,-0.199706, -0.019141,-0.278134,-0.109104, 0.160374,0.124065,-0.228342, 0.234799,0.071081,-0.164747, 0.302859,0.209772,0.028184, 0.317695,0.159603,0.012337, 
+};
+// h55
+const int h55_numv = 16;
+const float h55_volu = 0.055290;
+const float h55_pos[3] = { 0.087136,0.788999,0.139771 };
+const float h55_verts[ h55_numv * 3 ] = {
+  0.076080,-0.416095,-0.083059, -0.323951,0.211001,0.286715, 0.205112,0.211001,-0.185127, 0.076081,0.211001,-0.405639, -0.148237,0.211001,0.332473, 0.101171,-0.226374,0.192117, -0.006832,-0.085411,0.277812, 0.205111,-0.223849,0.038561, -0.274823,0.078877,0.258729, 0.035595,0.211001,-0.415523, 0.074576,-0.413789,-0.064275, 0.079238,-0.416513,-0.077447, 0.107256,-0.249478,0.168347, 0.117855,-0.236273,0.172768, 0.029258,-0.402186,-0.087713, 0.035598,-0.405195,-0.098549, 
+};
+// h56
+const int h56_numv = 20;
+const float h56_volu = 0.096963;
+const float h56_pos[3] = { -0.186579,0.800379,0.005269 };
+const float h56_verts[ h56_numv * 3 ] = {
+  0.004502,-0.334912,-0.018030, 0.302973,-0.413566,0.046788, 0.309310,0.199621,-0.281021, -0.242420,0.199621,0.235284, -0.121421,0.199621,0.412527, 0.172708,0.199621,-0.357250, -0.050236,0.199621,0.421217, -0.341638,0.020145,-0.086171, -0.356474,0.199621,-0.098861, 0.097656,0.085128,-0.340236, -0.001108,0.067497,0.393231, -0.356474,0.088797,-0.117864, -0.277459,-0.105503,0.080310, 0.309314,-0.416575,0.035953, 0.106078,-0.385531,-0.020510, 0.188512,-0.404604,-0.037617, -0.268642,-0.080395,0.110447, -0.118494,0.123210,0.393231, -0.341638,0.038628,-0.133710, -0.322853,0.025254,-0.145176, 
+};
+// h57
+const int h57_numv = 16;
+const float h57_volu = 0.081294;
+const float h57_pos[3] = { 0.851151,0.533342,0.098902 };
+const float h57_verts[ h57_numv * 3 ] = {
+  -0.184097,0.265595,0.004922, 0.148849,0.009818,-0.380153, 0.148849,-0.049459,0.325702, -0.275924,-0.093697,-0.138710, 0.148849,-0.119626,-0.357957, -0.275924,0.137573,0.059567, -0.112901,0.343928,0.059438, -0.249462,0.157589,0.121951, 0.148849,-0.434521,0.127992, 0.148849,0.447452,0.070089, 0.148849,-0.343521,0.212252, -0.023987,-0.337111,0.083159, -0.018406,-0.089149,0.305285, -0.008312,-0.125079,0.291731, -0.255475,-0.083645,-0.166703, -0.157047,0.040928,-0.236124, 
+};
+// h58
+const int h58_numv = 20;
+const float h58_volu = 0.077812;
+const float h58_pos[3] = { 0.374418,0.849026,0.291935 };
+const float h58_verts[ h58_numv * 3 ] = {
+  -0.082171,-0.283876,-0.113603, 0.200809,-0.178111,-0.133466, -0.082170,0.150974,-0.337291, 0.089508,-0.034332,0.259248, 0.146093,0.150974,0.326019, 0.410849,0.150974,-0.104898, -0.435519,0.150974,0.180309, -0.294114,-0.145438,0.125648, 0.292636,-0.050089,-0.188111, 0.183309,0.150974,-0.304884, 0.227271,-0.158095,-0.071082, 0.363832,0.028244,-0.133595, -0.169427,-0.296300,0.020604, 0.087144,-0.178878,0.139171, 0.071270,-0.146859,0.192458, -0.429747,0.150974,0.185433, -0.186111,-0.286401,0.039952, 0.048213,-0.131812,0.221308, -0.268420,-0.171352,0.132706, -0.212551,-0.233071,0.128708, 
+};
+// h59
+const int h59_numv = 12;
+const float h59_volu = 0.098632;
+const float h59_pos[3] = { 0.795288,0.838821,-0.270144 };
+const float h59_verts[ h59_numv * 3 ] = {
+  -0.010021,0.161179,0.457181, -0.356162,0.161179,-0.206090, 0.204712,-0.152000,-0.380610, 0.204712,0.161179,-0.434310, -0.057037,0.038449,0.428484, -0.237561,0.161179,0.257195, -0.256523,-0.089455,-0.203657, -0.128234,-0.039885,0.373968, 0.204712,-0.295661,-0.011106, -0.101183,-0.264551,0.132922, 0.204712,0.141973,0.439135, 0.204712,0.161179,0.444075, 
+};
+// h60
+const int h60_numv = 22;
+const float h60_volu = 0.091310;
+const float h60_pos[3] = { 0.415485,0.715407,-0.130668 };
+const float h60_verts[ h60_numv * 3 ] = {
+  -0.064779,0.284593,-0.364069, 0.142242,0.284593,0.117719, -0.242554,-0.352215,0.182461, 0.061056,-0.331466,0.081653, 0.180191,-0.265711,0.062868, 0.251569,0.083531,0.234492, -0.123237,0.284593,0.085312, -0.123238,-0.150257,0.309000, 0.159742,-0.044491,0.289138, 0.278619,-0.141137,-0.006553, -0.252268,0.284593,-0.135200, 0.123280,0.033960,-0.343133, 0.052142,0.000197,-0.360501, 0.023641,0.284593,-0.345566, 0.159742,-0.275763,0.090860, -0.138846,-0.370709,0.063434, -0.249111,-0.342921,0.192992, -0.046519,-0.292460,-0.089523, -0.252269,-0.342503,0.187380, -0.242676,-0.352703,0.180916, 0.052887,-0.337824,0.045824, 0.043373,-0.342729,0.054274, 
+};
+// h61
+const int h61_numv = 24;
+const float h61_volu = 0.075853;
+const float h61_pos[3] = { 0.499694,0.403970,0.252554 };
+const float h61_verts[ h61_numv * 3 ] = {
+  0.101994,0.286961,-0.031701, -0.294704,0.148756,0.059985, -0.023153,-0.020028,-0.301569, 0.156136,0.037589,0.286475, -0.323273,-0.108125,-0.115004, 0.032521,-0.286922,0.028066, -0.038132,0.266178,0.178552, 0.260541,-0.250848,-0.073994, 0.327470,-0.207739,-0.070493, 0.075532,0.266945,-0.094084, 0.075532,0.035675,-0.292362, 0.343145,0.004293,0.138079, 0.231743,0.048354,0.251404, 0.045317,0.188205,0.223756, -0.087937,-0.209333,0.181412, -0.330859,-0.089605,0.055955, 0.333052,0.040223,0.151633, 0.236542,0.052068,0.247099, -0.339382,-0.095975,-0.073501, -0.326763,-0.040778,-0.200761, -0.207448,0.161180,-0.074222, -0.333320,-0.031483,-0.190230, -0.305302,0.135551,0.055565, -0.337982,-0.028760,-0.177059, 
+};
+// h62
+const int h62_numv = 18;
+const float h62_volu = 0.089635;
+const float h62_pos[3] = { -0.412607,-0.798932,0.393221 };
+const float h62_verts[ h62_numv * 3 ] = {
+  0.143743,0.178906,-0.080212, -0.336591,-0.057070,0.045432, -0.365487,-0.201068,0.063069, -0.043446,-0.201068,0.325146, -0.118881,0.178753,-0.144486, -0.152818,-0.201068,-0.248459, 0.205095,-0.201068,-0.388268, 0.337853,-0.164947,-0.214818, 0.038585,0.368996,0.228990, 0.242459,-0.068737,-0.310888, -0.200495,0.172297,-0.114599, -0.231981,0.184967,-0.066303, 0.334110,-0.201068,-0.227916, 0.209245,-0.110463,-0.361925, 0.145031,0.335652,0.325145, 0.169974,0.297178,0.268816, -0.151147,0.272981,0.102025, 0.044821,0.272804,-0.007759, 
+};
+// h63
+const int h63_numv = 20;
+const float h63_volu = 0.065070;
+const float h63_pos[3] = { -0.683722,-0.408459,0.881106 };
+const float h63_verts[ h63_numv * 3 ] = {
+  0.408763,0.050375,-0.050997, 0.001643,0.372246,0.104787, -0.316278,-0.373443,0.118894, -0.000569,0.379463,0.118894, -0.316278,-0.303582,-0.012874, 0.413107,-0.090210,0.118894, 0.072977,-0.026465,-0.250457, -0.316278,0.104758,0.118894, -0.133134,0.036421,-0.232486, -0.316278,-0.061367,-0.137470, 0.406500,0.014459,-0.083368, 0.416439,0.055265,0.118894, 0.411396,0.069115,-0.001513, 0.370009,0.144956,0.118894, 0.377753,0.036235,-0.132875, 0.381520,0.034894,-0.130346, 0.374104,0.031050,-0.138388, 0.376042,0.032985,-0.136218, 0.383396,0.034505,-0.128411, 0.385682,0.029196,-0.126410, 
+};
+// h64
+const int h64_numv = 14;
+const float h64_volu = 0.063334;
+const float h64_pos[3] = { -0.862240,-0.589074,0.504780 };
+const float h64_verts[ h64_numv * 3 ] = {
+  -0.034062,-0.410926,-0.010011, 0.045384,0.217035,0.143840, 0.295955,0.147819,0.066170, 0.251495,0.154150,0.125869, -0.137760,-0.410926,0.116573, -0.137760,0.324258,-0.236366, -0.137760,0.210059,-0.342106, -0.137760,-0.122967,0.363452, -0.137760,-0.410926,-0.022669, 0.298486,0.063123,-0.009534, -0.137760,0.298525,-0.037806, 0.113042,-0.266928,-0.066127, -0.137760,0.119248,0.238856, 0.217652,-0.024891,-0.177862, 
+};
+// h65
+const int h65_numv = 22;
+const float h65_volu = 0.115639;
+const float h65_pos[3] = { -0.632833,-0.759826,0.781144 };
+const float h65_verts[ h65_numv * 3 ] = {
+  -0.367167,-0.022076,0.218856, 0.176779,-0.240174,-0.062777, -0.145261,-0.240174,-0.324854, -0.367167,-0.240174,-0.159791, -0.367167,-0.240174,0.218856, 0.229214,-0.240174,0.218856, -0.367167,0.047785,0.087088, 0.379478,0.318313,-0.027451, 0.258810,0.329890,-0.158933, 0.022088,0.324902,-0.150495, -0.263470,-0.240174,-0.286375, -0.116365,-0.096176,-0.342491, 0.384007,0.200623,0.218856, 0.365257,0.296546,-0.062778, 0.323215,0.382417,-0.038426, 0.362218,0.261157,0.218856, 0.374110,0.331198,-0.022696, 0.069079,0.233875,-0.285898, 0.066548,0.318571,-0.210194, 0.259984,0.356129,-0.135062, 0.334793,0.380563,-0.026448, 0.355611,0.365826,0.016594, 
+};
+// h66
+const int h66_numv = 12;
+const float h66_volu = 0.090843;
+const float h66_pos[3] = { 0.194452,-0.846656,0.702344 };
+const float h66_verts[ h66_numv * 3 ] = {
+  0.144722,0.221953,-0.171396, 0.354760,-0.153344,-0.123136, 0.229722,0.177289,-0.118776, -0.077080,-0.093853,-0.442151, -0.263367,-0.153344,0.297656, 0.293204,-0.153344,0.297656, -0.291202,0.163722,0.297656, 0.229722,0.015381,0.297656, -0.072437,-0.153344,-0.456885, -0.246539,0.275009,-0.021290, -0.133324,-0.153344,-0.464317, -0.137311,-0.122439,-0.456854, 
+};
+// h67
+const int h67_numv = 14;
+const float h67_volu = 0.073139;
+const float h67_pos[3] = { -0.182450,-0.819619,0.699488 };
+const float h67_verts[ h67_numv * 3 ] = {
+  0.085699,0.136685,0.300512, -0.221169,-0.180381,0.300512, -0.273604,-0.180381,0.018878, 0.130363,0.247972,-0.018435, -0.085126,0.356339,0.018877, 0.113535,-0.180381,0.300512, -0.066376,0.260416,0.300512, -0.060183,0.317865,-0.037452, 0.103953,-0.180381,-0.534183, 0.107696,-0.144260,-0.521085, 0.239592,-0.149476,-0.453999, 0.243578,-0.180381,-0.461462, -0.070905,0.378106,0.054205, -0.032656,0.358692,0.028913, 
+};
+// h68
+const int h68_numv = 24;
+const float h68_volu = 0.110178;
+const float h68_pos[3] = { 0.194790,-0.476753,0.823942 };
+const float h68_verts[ h68_numv * 3 ] = {
+  -0.387371,0.030890,-0.107289, 0.221446,0.021860,-0.353469, -0.465405,-0.021917,0.176058, -0.291540,-0.206181,0.176058, 0.076464,0.334736,-0.007133, 0.229384,-0.354523,0.176058, 0.292644,0.032441,-0.334080, -0.452945,0.146290,0.025179, 0.246219,0.093034,-0.297244, 0.229037,0.025757,-0.352826, 0.107091,0.321655,0.176058, 0.390186,-0.018723,0.176058, 0.312682,0.010704,-0.315910, 0.229384,-0.192615,-0.240374, 0.144384,-0.147950,-0.292995, -0.246877,-0.094895,-0.142888, -0.409896,0.015825,-0.095540, -0.443616,-0.082450,0.176058, -0.462073,0.123559,0.176058, -0.472012,0.082753,-0.026204, -0.453513,0.048124,-0.065494, -0.448145,0.035240,-0.070249, -0.469749,0.118668,0.006167, -0.467116,0.137408,0.055651, 
+};
+// h69
+const int h69_numv = 18;
+const float h69_volu = 0.150904;
+const float h69_pos[3] = { 0.751581,-0.668854,0.749549 };
+const float h69_verts[ h69_numv * 3 ] = {
+  0.248419,0.357221,0.250451, -0.263925,-0.331146,0.250451, 0.248419,0.283773,-0.306518, 0.248419,-0.331146,0.009798, 0.000203,0.129153,-0.348181, 0.248419,-0.331146,0.250451, -0.202369,-0.331146,-0.170342, -0.161439,-0.331146,-0.190328, 0.248419,0.424683,-0.270088, -0.087381,0.269445,-0.329471, -0.149648,0.251714,-0.296027, -0.327407,-0.162422,0.250451, -0.166605,0.173379,0.250451, -0.045433,0.301175,-0.321470, -0.327407,-0.000512,-0.165981, -0.244109,0.202806,-0.241517, 0.223596,0.415674,-0.285417, 0.248419,0.419976,-0.283164, 
+};
+// h70
+const int h70_numv = 8;
+const float h70_volu = 0.052841;
+const float h70_pos[3] = { 0.870032,-0.820199,0.384721 };
+const float h70_verts[ h70_numv * 3 ] = {
+  0.129968,-0.179801,0.374626, 0.129968,-0.179801,-0.351943, -0.279890,-0.179801,0.174500, 0.129968,0.435118,0.058310, -0.112815,-0.179801,-0.233397, -0.118249,0.280498,0.016648, 0.129968,-0.066134,-0.371433, -0.064784,-0.043027,-0.280302, 
+};
+// h71
+const int h71_numv = 16;
+const float h71_volu = 0.078575;
+const float h71_pos[3] = { -0.715618,-0.146967,0.614144 };
+const float h71_verts[ h71_numv * 3 ] = {
+  -0.284382,-0.099249,-0.355298, 0.407938,-0.228507,0.130744, -0.284382,-0.117849,-0.345730, 0.406000,-0.230442,0.128574, 0.033539,0.110754,0.371749, 0.104873,-0.287957,0.016505, -0.197952,0.422046,0.249299, -0.284382,0.237452,0.048837, -0.101238,-0.225072,0.034476, -0.284382,-0.143582,-0.147170, 0.149333,-0.294288,-0.043194, 0.409649,-0.225257,0.134087, 0.147525,0.085239,-0.239307, 0.183419,0.150542,-0.169689, 0.342769,-0.256730,0.031938, 0.344779,-0.242424,0.025560, 
+};
+// h72
+const int h72_numv = 24;
+const float h72_volu = 0.135103;
+const float h72_pos[3] = { -0.469590,0.119774,0.755853 };
+const float h72_verts[ h72_numv * 3 ] = {
+  -0.212489,-0.155987,0.230040, -0.214701,-0.148769,0.244147, -0.443980,0.155306,0.107590, 0.375305,0.040715,-0.139275, -0.004437,0.090870,-0.389509, 0.311360,0.156806,0.046426, -0.480672,0.247962,0.244147, -0.005314,0.363706,-0.137567, 0.163621,-0.491997,-0.007622, 0.213688,0.055724,0.244147, -0.495580,0.247143,0.161130, -0.499540,0.269230,0.219387, 0.144703,0.290282,-0.088352, 0.355676,0.140088,-0.062598, -0.062609,-0.116199,-0.311398, -0.088334,0.254773,-0.303291, 0.356369,0.017480,-0.175583, 0.155877,-0.383277,0.244147, 0.169264,-0.493727,-0.003158, 0.197264,-0.459118,0.123740, 0.194631,-0.477857,0.074256, 0.211435,-0.450236,0.093267, 0.167388,-0.493339,-0.005093, 0.169626,-0.492143,-0.004615, 
+};
+// h73
+const int h73_numv = 16;
+const float h73_volu = 0.036032;
+const float h73_pos[3] = { -0.912743,-0.085439,0.831075 };
+const float h73_verts[ h73_numv * 3 ] = {
+  0.095887,-0.286600,-0.182455, -0.087257,0.175924,-0.168094, -0.087257,-0.205110,-0.364101, 0.230664,0.049226,0.154818, -0.037519,0.453174,0.168925, 0.228452,0.056443,0.168925, -0.087257,0.484247,0.168925, -0.000826,0.360518,0.032367, -0.087257,-0.218262,0.168925, -0.087257,-0.384387,-0.087440, -0.087257,0.485343,0.150329, -0.064760,0.476158,0.168925, -0.052427,0.452355,0.085908, -0.087257,0.457669,0.073457, -0.056387,0.474442,0.144165, -0.056885,0.474757,0.144652, 
+};
+// h74
+const int h74_numv = 22;
+const float h74_volu = 0.115647;
+const float h74_pos[3] = { -0.806688,0.162223,0.365754 };
+const float h74_verts[ h74_numv * 3 ] = {
+  -0.106882,0.112856,0.497689, -0.158482,0.204693,0.551229, 0.218764,0.243174,-0.153679, 0.270615,-0.014193,-0.214570, -0.193312,-0.071737,0.297227, 0.312298,0.070592,-0.150604, -0.069795,-0.227826,-0.358730, 0.248765,0.212323,0.086808, -0.193312,-0.408439,-0.106908, -0.193312,0.210007,0.538778, 0.301657,0.087464,-0.177940, -0.191931,0.033024,-0.314003, -0.193312,0.271426,0.001678, 0.058968,0.264774,-0.186519, -0.193312,0.247719,-0.120270, 0.052425,0.263623,-0.188445, 0.332661,0.048420,0.000590, 0.274489,-0.158648,0.078702, 0.238595,-0.223951,0.009084, 0.229318,-0.111676,-0.252511, -0.193312,-0.302733,-0.342536, -0.193312,0.032765,-0.313772, 
+};
+// h75
+const int h75_numv = 18;
+const float h75_volu = 0.089620;
+const float h75_pos[3] = { 0.052817,0.072055,0.868740 };
+const float h75_verts[ h75_numv * 3 ] = {
+  0.433734,0.123433,0.131260, 0.005775,0.176863,-0.278988, 0.218437,-0.214071,-0.051932, -0.366530,-0.335558,0.131260, -0.308719,0.103443,0.131260, -0.147102,0.088434,-0.252162, -0.310972,-0.402518,-0.019619, -0.003079,0.231496,-0.237914, 0.112171,0.347564,-0.006639, 0.302595,-0.019353,-0.141822, 0.235603,0.353295,0.131260, 0.077918,0.377107,0.131260, 0.249063,-0.227153,0.131260, -0.166731,0.187806,-0.175486, -0.093909,0.310921,0.131260, -0.211047,0.204525,-0.066461, -0.325143,-0.411399,0.010853, -0.320100,-0.425249,0.131260, 
+};
+// h76
+const int h76_numv = 24;
+const float h76_volu = 0.095138;
+const float h76_pos[3] = { 0.088788,-0.142804,0.576459 };
+const float h76_verts[ h76_numv * 3 ] = {
+  0.352221,-0.240915,-0.049761, -0.386828,-0.236459,0.178237, 0.182466,0.000788,0.240349, -0.006268,0.044860,-0.340368, 0.298110,0.182836,0.102163, -0.389114,-0.231150,0.176236, -0.030195,0.391722,0.013292, -0.363747,-0.215280,0.253650, -0.388752,-0.229565,0.174779, -0.101327,0.289860,-0.170144, 0.328315,-0.307617,-0.113256, -0.079254,0.048914,-0.283309, 0.094387,-0.120263,-0.302438, -0.281369,-0.303059,0.140194, 0.335039,-0.308192,-0.105343, 0.327448,-0.312089,-0.105986, 0.022142,0.379302,-0.133650, -0.346943,-0.187659,0.272661, -0.202009,0.280058,0.003811, -0.183073,0.303293,0.040119, 0.266624,0.195506,0.150459, -0.022476,0.325632,-0.215723, -0.347511,-0.285824,0.181989, -0.366010,-0.251196,0.221279, 
+};
+// h77
+const int h77_numv = 26;
+const float h77_volu = 0.087804;
+const float h77_pos[3] = { 0.390778,-0.073451,0.362494 };
+const float h77_verts[ h77_numv * 3 ] = {
+  -0.003880,0.113483,0.316128, 0.315369,-0.294228,0.065585, -0.206158,-0.189928,-0.093832, 0.020979,0.268088,0.071472, -0.324466,0.256279,-0.001758, -0.230465,0.381445,-0.183441, 0.426887,-0.187811,0.054869, 0.211155,-0.343689,0.091028, -0.224735,0.155039,-0.266749, 0.077733,0.119939,0.286241, 0.026325,-0.376970,0.100709, -0.297695,-0.031084,-0.153195, 0.009520,-0.343472,-0.067504, 0.155269,-0.307156,-0.121769, -0.207604,-0.189616,-0.088472, -0.308258,-0.024493,-0.126403, 0.050231,-0.310268,0.164204, 0.176117,-0.273019,-0.144419, 0.417855,-0.153875,-0.005953, 0.273422,-0.325958,0.057585, 0.096656,-0.370860,0.127368, 0.033049,-0.377545,0.108622, -0.214357,0.369295,-0.224944, 0.141437,0.190499,-0.081874, -0.279848,0.309949,0.080316, -0.221943,0.387815,-0.053985, 
+};
+// h78
+const int h78_numv = 20;
+const float h78_volu = 0.126407;
+const float h78_pos[3] = { 0.652845,-0.171711,0.785711 };
+const float h78_verts[ h78_numv * 3 ] = {
+  -0.350965,0.016612,0.214289, 0.347155,-0.072460,-0.306250, -0.381591,0.029695,0.031097, 0.347155,-0.139922,0.214289, 0.322332,-0.081469,-0.321579, -0.265947,0.211743,-0.107089, -0.020631,0.312250,-0.000249, 0.347155,0.151286,0.214289, 0.347155,-0.036860,-0.269624, -0.184333,0.218199,-0.136976, -0.297433,0.224413,-0.058793, -0.211836,-0.212008,-0.259013, -0.050911,-0.245429,-0.332189, -0.067869,-0.323764,0.214289, -0.166294,0.367199,0.214289, -0.026282,0.399418,0.214289, -0.145373,-0.294337,-0.277679, -0.165410,-0.272600,-0.295849, 0.053302,-0.195968,-0.357632, 0.164820,-0.089551,-0.368349, 
+};
+// h79
+const int h79_numv = 20;
+const float h79_volu = 0.069132;
+const float h79_pos[3] = { 0.747670,0.086302,0.441993 };
+const float h79_verts[ h79_numv * 3 ] = {
+  0.252330,0.012519,-0.215098, 0.012566,0.066820,-0.263433, 0.201221,-0.224177,-0.182831, 0.095169,0.321961,-0.051360, -0.091840,0.355257,0.097036, -0.215455,0.030746,-0.161373, -0.279159,-0.039814,0.206742, 0.060963,-0.313628,-0.085453, -0.115456,0.054238,0.343469, 0.252330,-0.294873,0.074094, -0.016233,0.366022,0.061965, -0.074702,0.310522,0.161887, 0.252330,0.103519,-0.130839, 0.252330,-0.216744,-0.175787, -0.335913,0.108335,-0.008027, 0.079494,0.109929,-0.259932, 0.069995,-0.347564,-0.024631, 0.252330,-0.330473,0.037468, 0.252330,-0.335180,0.024392, 0.227507,-0.339482,0.022139, 
+};
+// h80
+const int h80_numv = 14;
+const float h80_volu = 0.076324;
+const float h80_pos[3] = { 0.872729,0.237609,0.718600 };
+const float h80_verts[ h80_numv * 3 ] = {
+  0.127271,0.331095,-0.032200, 0.127271,-0.258034,0.281400, 0.127271,-0.446180,-0.202512, -0.199761,0.159215,-0.114719, -0.141292,0.214715,-0.214641, -0.136492,0.218429,-0.218946, -0.240515,-0.097070,0.066863, -0.246166,-0.009903,0.281400, -0.239577,0.050556,0.281400, 0.127271,0.263358,0.281400, 0.127271,0.246274,-0.293996, 0.127271,-0.047788,-0.407445, -0.039983,0.206584,-0.314412, -0.029889,0.170654,-0.327966, 
+};
+// h81
+const int h81_numv = 10;
+const float h81_volu = 0.092471;
+const float h81_pos[3] = { -0.647649,0.823554,0.820209 };
+const float h81_verts[ h81_numv * 3 ] = {
+  0.457657,0.176446,0.179791, -0.352351,-0.423650,0.161195, -0.352351,0.176446,-0.147497, -0.352351,-0.424746,0.179791, -0.352351,0.176446,0.179791, 0.395926,0.059255,0.179791, 0.203225,-0.169390,-0.173056, 0.338792,0.176446,-0.400601, -0.321979,-0.434236,0.155518, -0.329854,-0.432835,0.179791, 
+};
+// h82
+const int h82_numv = 22;
+const float h82_volu = 0.133984;
+const float h82_pos[3] = { -0.704013,0.655334,0.510913 };
+const float h82_verts[ h82_numv * 3 ] = {
+  -0.295987,0.344666,0.147853, 0.143982,-0.175036,-0.341668, -0.295987,-0.255430,0.470491, 0.398940,0.268255,-0.112413, -0.265615,-0.266016,0.464814, -0.043708,-0.228337,-0.331678, 0.395156,0.344666,-0.091306, 0.146090,-0.280788,-0.058352, 0.259589,-0.001170,0.136240, -0.295987,0.344666,0.161799, 0.268488,-0.087750,0.102566, -0.295987,-0.221685,-0.143481, -0.265117,-0.266331,0.464327, 0.229109,-0.171854,0.107373, -0.295987,-0.283104,0.393619, -0.261157,-0.288418,0.406070, 0.116089,-0.249937,-0.298838, 0.396013,0.344666,-0.093117, 0.248792,0.064649,-0.395197, 0.275014,0.344666,-0.270360, 0.114098,-0.109185,-0.385965, 0.213954,-0.004245,-0.405120, 
+};
+// h83
+const int h83_numv = 12;
+const float h83_volu = 0.056796;
+const float h83_pos[3] = { -0.429347,0.488254,0.882979 };
+const float h83_verts[ h83_numv * 3 ] = {
+  -0.006178,0.079330,-0.269501, -0.548156,-0.097535,0.117020, -0.015077,0.165910,-0.235826, -0.540281,-0.098936,0.092747, 0.104460,-0.078198,-0.215479, 0.388255,-0.105278,0.117020, 0.173445,-0.312756,0.117020, 0.177624,0.394555,0.117020, -0.045557,-0.004774,-0.264694, 0.271117,-0.211674,-0.080700, -0.539783,-0.099251,0.092261, -0.520915,-0.120519,0.117020, 
+};
+// h84
+const int h84_numv = 22;
+const float h84_volu = 0.109330;
+const float h84_pos[3] = { -0.121674,0.670783,0.713170 };
+const float h84_verts[ h84_numv * 3 ] = {
+  -0.313851,-0.103198,-0.099691, -0.010109,0.329217,0.286830, 0.252410,-0.221620,0.286830, -0.068318,0.329217,0.286830, 0.080582,-0.287807,0.286830, 0.201978,0.032805,-0.295587, -0.187183,0.329217,-0.293562, 0.227672,0.006891,-0.288529, -0.130049,0.212026,0.286830, -0.322750,-0.016619,-0.066017, -0.036556,-0.394202,0.089109, 0.171412,-0.367231,-0.082344, -0.203213,-0.260726,-0.045669, 0.007760,-0.410921,-0.019916, 0.265234,-0.083360,-0.251274, 0.286662,-0.251163,0.148930, -0.115141,0.329217,-0.286684, -0.066013,0.197094,-0.314670, -0.183399,0.252807,-0.314670, -0.186326,0.329217,-0.295374, 0.060573,0.329217,-0.240926, 0.066345,0.329217,-0.235802, 
+};
+// h85
+const int h85_numv = 36;
+const float h85_volu = 0.148789;
+const float h85_pos[3] = { -0.198763,0.456116,0.345386 };
+const float h85_verts[ h85_numv * 3 ] = {
+  0.248501,-0.152565,0.285440, 0.011075,0.411760,0.053114, 0.304761,0.221558,0.079254, 0.360475,-0.080906,-0.269891, -0.389161,-0.050719,-0.133311, 0.279067,0.247472,0.072197, 0.342323,0.131307,0.116509, -0.236762,0.111468,0.268093, 0.084849,-0.196255,0.347868, 0.186224,-0.309060,0.060929, -0.295627,-0.223301,-0.130236, 0.016686,0.009351,-0.358147, 0.315157,-0.069303,-0.293328, -0.106311,0.467473,0.053114, 0.257356,-0.207198,0.244366, 0.367598,-0.141752,-0.036878, 0.104478,-0.295627,0.271192, -0.126124,-0.046060,0.322115, -0.256458,0.263868,-0.229670, 0.085542,-0.318862,0.234884, -0.291296,0.194974,-0.239593, -0.265275,0.238760,-0.259807, -0.361268,0.024182,-0.176141, -0.291163,-0.195420,-0.172718, -0.276141,0.027364,0.272900, -0.306268,-0.206429,-0.157572, -0.275264,-0.245473,0.020958, -0.359160,-0.081570,0.107176, 0.360630,0.159839,0.075257, 0.387070,0.106509,-0.013499, 0.393155,0.083405,-0.037268, 0.359076,-0.148122,-0.166333, 0.309693,-0.219618,0.097423, 0.265075,-0.273288,0.015350, 0.118262,-0.041268,-0.360627, 0.049809,-0.043705,-0.365222, 
+};
+// h86
+const int h86_numv = 14;
+const float h86_volu = 0.108919;
+const float h86_pos[3] = { 0.238541,0.789776,0.775739 };
+const float h86_verts[ h86_numv * 3 ] = {
+  -0.094981,-0.202353,-0.313843, -0.370325,0.210224,0.224261, -0.076674,-0.173821,-0.355096, 0.281969,0.210224,-0.157785, 0.225385,0.024918,-0.224556, 0.374020,0.210224,0.224261, 0.316487,0.210224,-0.084750, -0.107806,-0.340614,0.224261, 0.201351,-0.281476,0.224261, 0.184090,-0.072562,-0.262496, -0.073553,-0.370157,0.086361, 0.049879,-0.364426,0.224261, -0.132543,-0.112102,-0.351098, -0.293871,0.210224,-0.298371, 
+};
+// h87
+const int h87_numv = 16;
+const float h87_volu = 0.089360;
+const float h87_pos[3] = { 0.798384,0.791714,0.481127 };
+const float h87_verts[ h87_numv * 3 ] = {
+  -0.277873,0.208286,0.136827, -0.253373,-0.199539,-0.004817, 0.201616,0.208286,-0.307196, 0.201616,0.189080,-0.312136, 0.201616,-0.223010,0.205272, 0.201616,0.208286,0.427133, 0.201616,-0.307831,-0.056523, -0.352696,-0.089547,0.003266, -0.060134,0.085556,-0.322787, -0.013117,0.208286,-0.294090, -0.336822,-0.121565,-0.050021, -0.196695,-0.100782,-0.260274, -0.062147,-0.335676,0.018525, 0.034362,-0.347521,-0.076940, -0.334458,0.022980,0.070056, -0.243356,0.208286,0.209862, 
+};
+// h88
+const int h88_numv = 26;
+const float h88_volu = 0.102785;
+const float h88_pos[3] = { 0.372790,0.365732,0.656967 };
+const float h88_verts[ h88_numv * 3 ] = {
+  -0.084370,0.059618,0.343033, 0.095722,-0.319244,-0.008232, 0.172221,0.226443,-0.180656, 0.300178,0.031092,-0.053086, 0.259424,-0.225193,0.128495, 0.253773,-0.138025,0.343033, -0.207802,0.053887,0.205134, 0.072899,0.336435,-0.172573, -0.203955,-0.051368,-0.348458, 0.260362,-0.077566,0.343033, 0.038967,-0.171095,-0.223000, 0.088772,0.304416,-0.225861, 0.113761,-0.170244,0.343033, 0.067103,0.142568,0.343033, -0.229230,0.221691,-0.195070, -0.323052,-0.062181,-0.026140, 0.014109,-0.325700,0.021656, -0.261860,-0.129234,-0.214158, -0.017378,-0.313030,0.069951, -0.314197,-0.116814,-0.067215, 0.049841,0.351482,-0.143724, -0.178398,0.173789,-0.348849, -0.210923,0.250223,-0.236324, 0.283040,0.075827,-0.117937, -0.184483,0.196893,-0.325078, -0.167799,0.186994,-0.344427, 
+};
+// h89
+const int h89_numv = 16;
+const float h89_volu = 0.098811;
+const float h89_pos[3] = { 0.713605,0.673779,0.814484 };
+const float h89_verts[ h89_numv * 3 ] = {
+  -0.273713,-0.165479,0.185516, -0.080453,-0.385613,0.185516, 0.286395,-0.172812,0.185516, 0.286395,0.326221,0.093776, -0.101044,0.326221,0.185516, 0.286395,0.326221,0.185516, 0.017832,-0.221455,-0.310526, 0.286395,-0.105074,-0.128085, -0.040637,-0.276955,-0.210604, -0.057774,-0.232220,-0.275455, -0.158577,0.326221,-0.123495, -0.267917,0.028388,-0.330091, -0.290974,0.043435,-0.301241, -0.249679,0.140915,-0.263301, -0.168594,-0.081604,-0.338174, 0.022632,-0.217741,-0.314831, 
+};
+
+//Aggregate of all cells.
+const int halton_numc = 90;
+const int halton_numv[ halton_numc ] = {
+  h00_numv,h01_numv,h02_numv,h03_numv,h04_numv,h05_numv,h06_numv,h07_numv,h08_numv,h09_numv,h10_numv,h11_numv,h12_numv,h13_numv,h14_numv,h15_numv,h16_numv,h17_numv,h18_numv,h19_numv,h20_numv,h21_numv,h22_numv,h23_numv,h24_numv,h25_numv,h26_numv,h27_numv,h28_numv,h29_numv,h30_numv,h31_numv,h32_numv,h33_numv,h34_numv,h35_numv,h36_numv,h37_numv,h38_numv,h39_numv,h40_numv,h41_numv,h42_numv,h43_numv,h44_numv,h45_numv,h46_numv,h47_numv,h48_numv,h49_numv,h50_numv,h51_numv,h52_numv,h53_numv,h54_numv,h55_numv,h56_numv,h57_numv,h58_numv,h59_numv,h60_numv,h61_numv,h62_numv,h63_numv,h64_numv,h65_numv,h66_numv,h67_numv,h68_numv,h69_numv,h70_numv,h71_numv,h72_numv,h73_numv,h74_numv,h75_numv,h76_numv,h77_numv,h78_numv,h79_numv,h80_numv,h81_numv,h82_numv,h83_numv,h84_numv,h85_numv,h86_numv,h87_numv,h88_numv,h89_numv,
+};
+const float halton_volu[ halton_numc ] = {
+  h00_volu,h01_volu,h02_volu,h03_volu,h04_volu,h05_volu,h06_volu,h07_volu,h08_volu,h09_volu,h10_volu,h11_volu,h12_volu,h13_volu,h14_volu,h15_volu,h16_volu,h17_volu,h18_volu,h19_volu,h20_volu,h21_volu,h22_volu,h23_volu,h24_volu,h25_volu,h26_volu,h27_volu,h28_volu,h29_volu,h30_volu,h31_volu,h32_volu,h33_volu,h34_volu,h35_volu,h36_volu,h37_volu,h38_volu,h39_volu,h40_volu,h41_volu,h42_volu,h43_volu,h44_volu,h45_volu,h46_volu,h47_volu,h48_volu,h49_volu,h50_volu,h51_volu,h52_volu,h53_volu,h54_volu,h55_volu,h56_volu,h57_volu,h58_volu,h59_volu,h60_volu,h61_volu,h62_volu,h63_volu,h64_volu,h65_volu,h66_volu,h67_volu,h68_volu,h69_volu,h70_volu,h71_volu,h72_volu,h73_volu,h74_volu,h75_volu,h76_volu,h77_volu,h78_volu,h79_volu,h80_volu,h81_volu,h82_volu,h83_volu,h84_volu,h85_volu,h86_volu,h87_volu,h88_volu,h89_volu,
+};
+const float* halton_pos[ halton_numc ] = {
+  h00_pos,h01_pos,h02_pos,h03_pos,h04_pos,h05_pos,h06_pos,h07_pos,h08_pos,h09_pos,h10_pos,h11_pos,h12_pos,h13_pos,h14_pos,h15_pos,h16_pos,h17_pos,h18_pos,h19_pos,h20_pos,h21_pos,h22_pos,h23_pos,h24_pos,h25_pos,h26_pos,h27_pos,h28_pos,h29_pos,h30_pos,h31_pos,h32_pos,h33_pos,h34_pos,h35_pos,h36_pos,h37_pos,h38_pos,h39_pos,h40_pos,h41_pos,h42_pos,h43_pos,h44_pos,h45_pos,h46_pos,h47_pos,h48_pos,h49_pos,h50_pos,h51_pos,h52_pos,h53_pos,h54_pos,h55_pos,h56_pos,h57_pos,h58_pos,h59_pos,h60_pos,h61_pos,h62_pos,h63_pos,h64_pos,h65_pos,h66_pos,h67_pos,h68_pos,h69_pos,h70_pos,h71_pos,h72_pos,h73_pos,h74_pos,h75_pos,h76_pos,h77_pos,h78_pos,h79_pos,h80_pos,h81_pos,h82_pos,h83_pos,h84_pos,h85_pos,h86_pos,h87_pos,h88_pos,h89_pos,
+};
+const float* halton_verts[ halton_numc ] = {
+  h00_verts,h01_verts,h02_verts,h03_verts,h04_verts,h05_verts,h06_verts,h07_verts,h08_verts,h09_verts,h10_verts,h11_verts,h12_verts,h13_verts,h14_verts,h15_verts,h16_verts,h17_verts,h18_verts,h19_verts,h20_verts,h21_verts,h22_verts,h23_verts,h24_verts,h25_verts,h26_verts,h27_verts,h28_verts,h29_verts,h30_verts,h31_verts,h32_verts,h33_verts,h34_verts,h35_verts,h36_verts,h37_verts,h38_verts,h39_verts,h40_verts,h41_verts,h42_verts,h43_verts,h44_verts,h45_verts,h46_verts,h47_verts,h48_verts,h49_verts,h50_verts,h51_verts,h52_verts,h53_verts,h54_verts,h55_verts,h56_verts,h57_verts,h58_verts,h59_verts,h60_verts,h61_verts,h62_verts,h63_verts,h64_verts,h65_verts,h66_verts,h67_verts,h68_verts,h69_verts,h70_verts,h71_verts,h72_verts,h73_verts,h74_verts,h75_verts,h76_verts,h77_verts,h78_verts,h79_verts,h80_verts,h81_verts,h82_verts,h83_verts,h84_verts,h85_verts,h86_verts,h87_verts,h88_verts,h89_verts,
+};
diff --git a/engine/inc/bullet/Benchmarks/TaruData.h b/engine/inc/bullet/Benchmarks/TaruData.h
new file mode 100644
index 00000000..d7847898
--- /dev/null
+++ b/engine/inc/bullet/Benchmarks/TaruData.h
@@ -0,0 +1,134 @@
+#define TaruVtxCount 43
+#define TaruIdxCount 132
+
+static float TaruVtx[] = {
+	1.08664f,
+	-1.99237f,
+	0.0f,
+	0.768369f,
+	-1.99237f,
+	-0.768369f,
+	1.28852f,
+	1.34412e-007f,
+	-1.28852f,
+	1.82224f,
+	1.90735e-007f,
+	0.0f,
+	0.0f,
+	-1.99237f,
+	-1.08664f,
+	0.0f,
+	0.0f,
+	-1.82224f,
+	0.0f,
+	-1.99237f,
+	-1.08664f,
+	-0.768369f,
+	-1.99237f,
+	-0.768369f,
+	-1.28852f,
+	1.34412e-007f,
+	-1.28852f,
+	0.0f,
+	0.0f,
+	-1.82224f,
+	-1.08664f,
+	-1.99237f,
+	1.82086e-007f,
+	-1.82224f,
+	1.90735e-007f,
+	1.59305e-007f,
+	-0.768369f,
+	-1.99237f,
+	0.76837f,
+	-1.28852f,
+	2.47058e-007f,
+	1.28852f,
+	1.42495e-007f,
+	-1.99237f,
+	1.08664f,
+	2.38958e-007f,
+	2.70388e-007f,
+	1.82224f,
+	0.768369f,
+	-1.99237f,
+	0.768369f,
+	1.28852f,
+	2.47058e-007f,
+	1.28852f,
+	0.768369f,
+	1.99237f,
+	-0.768369f,
+	1.08664f,
+	1.99237f,
+	0.0f,
+	0.0f,
+	1.99237f,
+	-1.08664f,
+	-0.768369f,
+	1.99237f,
+	-0.768369f,
+	0.0f,
+	1.99237f,
+	-1.08664f,
+	-1.08664f,
+	1.99237f,
+	0.0f,
+	-0.768369f,
+	1.99237f,
+	0.768369f,
+	1.42495e-007f,
+	1.99237f,
+	1.08664f,
+	0.768369f,
+	1.99237f,
+	0.768369f,
+	1.42495e-007f,
+	-1.99237f,
+	1.08664f,
+	-0.768369f,
+	-1.99237f,
+	0.76837f,
+	-1.08664f,
+	-1.99237f,
+	1.82086e-007f,
+	-0.768369f,
+	-1.99237f,
+	-0.768369f,
+	0.0f,
+	-1.99237f,
+	-1.08664f,
+	0.768369f,
+	-1.99237f,
+	-0.768369f,
+	1.08664f,
+	-1.99237f,
+	0.0f,
+	0.768369f,
+	-1.99237f,
+	0.768369f,
+	0.768369f,
+	1.99237f,
+	-0.768369f,
+	0.0f,
+	1.99237f,
+	-1.08664f,
+	-0.768369f,
+	1.99237f,
+	-0.768369f,
+	-1.08664f,
+	1.99237f,
+	0.0f,
+	-0.768369f,
+	1.99237f,
+	0.768369f,
+	1.42495e-007f,
+	1.99237f,
+	1.08664f,
+	0.768369f,
+	1.99237f,
+	0.768369f,
+	1.08664f,
+	1.99237f,
+	0.0f,
+};
diff --git a/engine/inc/bullet/Benchmarks/landscapeData.h b/engine/inc/bullet/Benchmarks/landscapeData.h
new file mode 100644
index 00000000..6005026e
--- /dev/null
+++ b/engine/inc/bullet/Benchmarks/landscapeData.h
@@ -0,0 +1,235704 @@
+#define Landscape02VtxCount 1980
+#define Landscape02IdxCount 11310
+#include "LinearMath/btScalar.h"
+
+btScalar Landscape02Vtx[] = {
+	-250.0f,
+	2.99192f,
+	113.281f,
+	-250.0f,
+	2.18397f,
+	117.188f,
+	-246.094f,
+	1.62262f,
+	113.281f,
+	-246.094f,
+	1.51628f,
+	117.188f,
+	-242.188f,
+	0.847411f,
+	113.281f,
+	-242.188f,
+	0.628327f,
+	117.188f,
+	-238.281f,
+	-0.697436f,
+	113.281f,
+	-238.281f,
+	-0.567933f,
+	117.188f,
+	-234.375f,
+	-2.65115f,
+	113.281f,
+	-234.375f,
+	-2.01568f,
+	117.188f,
+	-230.469f,
+	-3.82201f,
+	113.281f,
+	-230.469f,
+	-3.41089f,
+	117.188f,
+	-226.563f,
+	-3.99138f,
+	113.281f,
+	-226.563f,
+	-3.82758f,
+	117.188f,
+	-222.656f,
+	-5.51066f,
+	113.281f,
+	-222.656f,
+	-5.01586f,
+	117.188f,
+	-218.75f,
+	-5.62904f,
+	113.281f,
+	-218.75f,
+	-4.74822f,
+	117.188f,
+	-214.844f,
+	-4.90514f,
+	113.281f,
+	-214.844f,
+	-3.30853f,
+	117.188f,
+	-210.938f,
+	-2.9572f,
+	113.281f,
+	-210.938f,
+	-2.32499f,
+	117.188f,
+	-207.031f,
+	-2.44242f,
+	113.281f,
+	-207.031f,
+	-1.71509f,
+	117.188f,
+	-203.125f,
+	-1.5086f,
+	113.281f,
+	-203.125f,
+	-1.19203f,
+	117.188f,
+	-199.219f,
+	-0.130838f,
+	113.281f,
+	-199.219f,
+	0.219498f,
+	117.188f,
+	-195.313f,
+	0.985417f,
+	113.281f,
+	-195.313f,
+	1.66304f,
+	117.188f,
+	-191.406f,
+	3.20064f,
+	113.281f,
+	-191.406f,
+	4.35105f,
+	117.188f,
+	-187.5f,
+	4.6779f,
+	113.281f,
+	-187.5f,
+	6.33228f,
+	117.188f,
+	-183.594f,
+	6.16902f,
+	113.281f,
+	-183.594f,
+	8.00972f,
+	117.188f,
+	-179.688f,
+	8.18835f,
+	113.281f,
+	-179.688f,
+	9.71486f,
+	117.188f,
+	-175.781f,
+	9.35082f,
+	113.281f,
+	-175.781f,
+	10.7727f,
+	117.188f,
+	-171.875f,
+	9.50665f,
+	113.281f,
+	-171.875f,
+	11.358f,
+	117.188f,
+	-167.969f,
+	12.1301f,
+	113.281f,
+	-167.969f,
+	12.5239f,
+	117.188f,
+	-164.063f,
+	14.8728f,
+	113.281f,
+	-164.063f,
+	14.6278f,
+	117.188f,
+	-160.156f,
+	16.3761f,
+	113.281f,
+	-160.156f,
+	17.2069f,
+	117.188f,
+	-156.25f,
+	18.5367f,
+	113.281f,
+	-156.25f,
+	19.9779f,
+	117.188f,
+	-152.344f,
+	22.4636f,
+	113.281f,
+	-152.344f,
+	23.4607f,
+	117.188f,
+	-148.438f,
+	26.1459f,
+	113.281f,
+	-148.438f,
+	26.6108f,
+	117.188f,
+	-144.531f,
+	28.6071f,
+	113.281f,
+	-144.531f,
+	28.4635f,
+	117.188f,
+	-140.625f,
+	30.2795f,
+	113.281f,
+	-140.625f,
+	29.7705f,
+	117.188f,
+	-136.719f,
+	32.2229f,
+	113.281f,
+	-136.719f,
+	31.0684f,
+	117.188f,
+	-132.813f,
+	32.8919f,
+	113.281f,
+	-132.813f,
+	31.8395f,
+	117.188f,
+	-128.906f,
+	33.5143f,
+	113.281f,
+	-128.906f,
+	32.1658f,
+	117.188f,
+	-125.0f,
+	34.6963f,
+	113.281f,
+	-125.0f,
+	34.7478f,
+	117.188f,
+	-121.094f,
+	37.3995f,
+	113.281f,
+	-121.094f,
+	36.0624f,
+	117.188f,
+	-117.188f,
+	38.0464f,
+	113.281f,
+	-117.188f,
+	37.2702f,
+	117.188f,
+	-113.281f,
+	37.8506f,
+	113.281f,
+	-113.281f,
+	37.3474f,
+	117.188f,
+	-109.375f,
+	37.8984f,
+	113.281f,
+	-109.375f,
+	37.242f,
+	117.188f,
+	-105.469f,
+	36.0464f,
+	113.281f,
+	-105.469f,
+	36.1544f,
+	117.188f,
+	-101.563f,
+	34.1136f,
+	113.281f,
+	-101.563f,
+	33.403f,
+	117.188f,
+	-97.6563f,
+	32.0925f,
+	113.281f,
+	-97.6563f,
+	31.294f,
+	117.188f,
+	-93.75f,
+	29.8306f,
+	113.281f,
+	-93.75f,
+	29.4961f,
+	117.188f,
+	-89.8438f,
+	30.1499f,
+	113.281f,
+	-89.8438f,
+	29.0556f,
+	117.188f,
+	-85.9375f,
+	28.8377f,
+	113.281f,
+	-85.9375f,
+	28.2757f,
+	117.188f,
+	-82.0313f,
+	26.9726f,
+	113.281f,
+	-82.0313f,
+	26.6322f,
+	117.188f,
+	-78.125f,
+	25.4597f,
+	113.281f,
+	-78.125f,
+	24.8286f,
+	117.188f,
+	-74.2188f,
+	23.3572f,
+	113.281f,
+	-74.2188f,
+	22.7019f,
+	117.188f,
+	-70.3125f,
+	21.1615f,
+	113.281f,
+	-70.3125f,
+	20.4725f,
+	117.188f,
+	-66.4063f,
+	18.1212f,
+	113.281f,
+	-66.4063f,
+	17.984f,
+	117.188f,
+	-62.5f,
+	16.3411f,
+	113.281f,
+	-62.5f,
+	16.3033f,
+	117.188f,
+	-58.5938f,
+	15.075f,
+	113.281f,
+	-58.5938f,
+	14.2087f,
+	117.188f,
+	-54.6875f,
+	14.2482f,
+	113.281f,
+	-54.6875f,
+	12.8086f,
+	117.188f,
+	-50.7813f,
+	13.7945f,
+	113.281f,
+	-50.7813f,
+	12.5463f,
+	117.188f,
+	-46.875f,
+	12.7086f,
+	113.281f,
+	-46.875f,
+	12.1781f,
+	117.188f,
+	-42.9688f,
+	10.5756f,
+	113.281f,
+	-42.9688f,
+	11.1391f,
+	117.188f,
+	-39.0625f,
+	9.99343f,
+	113.281f,
+	-39.0625f,
+	10.4623f,
+	117.188f,
+	-35.1563f,
+	11.0936f,
+	113.281f,
+	-35.1563f,
+	11.0528f,
+	117.188f,
+	-31.25f,
+	11.9553f,
+	113.281f,
+	-31.25f,
+	11.454f,
+	117.188f,
+	-27.3438f,
+	11.5734f,
+	113.281f,
+	-27.3438f,
+	10.5577f,
+	117.188f,
+	-23.4375f,
+	11.0397f,
+	113.281f,
+	-23.4375f,
+	10.6328f,
+	117.188f,
+	-19.5313f,
+	12.5166f,
+	113.281f,
+	-19.5313f,
+	12.5569f,
+	117.188f,
+	-15.625f,
+	13.856f,
+	113.281f,
+	-15.625f,
+	13.5389f,
+	117.188f,
+	-11.7188f,
+	14.525f,
+	113.281f,
+	-11.7188f,
+	14.3792f,
+	117.188f,
+	-7.8125f,
+	14.7554f,
+	113.281f,
+	-7.8125f,
+	15.4809f,
+	117.188f,
+	-3.90625f,
+	15.9168f,
+	113.281f,
+	-3.90625f,
+	16.1008f,
+	117.188f,
+	0.0f,
+	17.0728f,
+	113.281f,
+	0.0f,
+	17.3675f,
+	117.188f,
+	3.90625f,
+	18.3498f,
+	113.281f,
+	3.90625f,
+	18.919f,
+	117.188f,
+	-250.0f,
+	4.66213f,
+	109.375f,
+	-246.094f,
+	2.25542f,
+	109.375f,
+	-242.188f,
+	0.972654f,
+	109.375f,
+	-238.281f,
+	-1.95429f,
+	109.375f,
+	-234.375f,
+	-2.74128f,
+	109.375f,
+	-230.469f,
+	-3.62525f,
+	109.375f,
+	-226.563f,
+	-4.55305f,
+	109.375f,
+	-222.656f,
+	-6.4124f,
+	109.375f,
+	-218.75f,
+	-6.73329f,
+	109.375f,
+	-214.844f,
+	-5.91703f,
+	109.375f,
+	-210.938f,
+	-4.73996f,
+	109.375f,
+	-207.031f,
+	-3.31105f,
+	109.375f,
+	-203.125f,
+	-2.06764f,
+	109.375f,
+	-199.219f,
+	-0.969242f,
+	109.375f,
+	-195.313f,
+	0.268778f,
+	109.375f,
+	-191.406f,
+	1.94799f,
+	109.375f,
+	-187.5f,
+	2.80754f,
+	109.375f,
+	-183.594f,
+	4.22131f,
+	109.375f,
+	-179.688f,
+	5.20723f,
+	109.375f,
+	-175.781f,
+	7.47197f,
+	109.375f,
+	-171.875f,
+	9.45267f,
+	109.375f,
+	-167.969f,
+	12.6425f,
+	109.375f,
+	-164.063f,
+	14.9382f,
+	109.375f,
+	-160.156f,
+	16.7967f,
+	109.375f,
+	-156.25f,
+	19.5153f,
+	109.375f,
+	-152.344f,
+	21.4005f,
+	109.375f,
+	-148.438f,
+	25.1259f,
+	109.375f,
+	-144.531f,
+	28.4102f,
+	109.375f,
+	-140.625f,
+	30.7572f,
+	109.375f,
+	-136.719f,
+	33.0194f,
+	109.375f,
+	-132.813f,
+	33.072f,
+	109.375f,
+	-128.906f,
+	33.1358f,
+	109.375f,
+	-125.0f,
+	35.0549f,
+	109.375f,
+	-121.094f,
+	36.4427f,
+	109.375f,
+	-117.188f,
+	38.3265f,
+	109.375f,
+	-113.281f,
+	38.5339f,
+	109.375f,
+	-109.375f,
+	37.0126f,
+	109.375f,
+	-105.469f,
+	34.9063f,
+	109.375f,
+	-101.563f,
+	32.9886f,
+	109.375f,
+	-97.6563f,
+	30.8964f,
+	109.375f,
+	-93.75f,
+	30.5048f,
+	109.375f,
+	-89.8438f,
+	30.4943f,
+	109.375f,
+	-85.9375f,
+	28.8782f,
+	109.375f,
+	-82.0313f,
+	28.1966f,
+	109.375f,
+	-78.125f,
+	25.9164f,
+	109.375f,
+	-74.2188f,
+	23.3428f,
+	109.375f,
+	-70.3125f,
+	20.9839f,
+	109.375f,
+	-66.4063f,
+	18.3885f,
+	109.375f,
+	-62.5f,
+	16.9034f,
+	109.375f,
+	-58.5938f,
+	15.2602f,
+	109.375f,
+	-54.6875f,
+	14.3223f,
+	109.375f,
+	-50.7813f,
+	13.3767f,
+	109.375f,
+	-46.875f,
+	12.5798f,
+	109.375f,
+	-42.9688f,
+	11.3276f,
+	109.375f,
+	-39.0625f,
+	11.0169f,
+	109.375f,
+	-35.1563f,
+	11.7482f,
+	109.375f,
+	-31.25f,
+	12.5037f,
+	109.375f,
+	-27.3438f,
+	12.3832f,
+	109.375f,
+	-23.4375f,
+	12.3097f,
+	109.375f,
+	-19.5313f,
+	12.6165f,
+	109.375f,
+	-15.625f,
+	13.7744f,
+	109.375f,
+	-11.7188f,
+	14.363f,
+	109.375f,
+	-7.8125f,
+	14.828f,
+	109.375f,
+	-3.90625f,
+	15.599f,
+	109.375f,
+	0.0f,
+	16.3885f,
+	109.375f,
+	3.90625f,
+	18.0017f,
+	109.375f,
+	-250.0f,
+	5.23892f,
+	105.469f,
+	-246.094f,
+	2.90481f,
+	105.469f,
+	-242.188f,
+	0.264647f,
+	105.469f,
+	-238.281f,
+	-0.288927f,
+	105.469f,
+	-234.375f,
+	-0.910295f,
+	105.469f,
+	-230.469f,
+	-2.20742f,
+	105.469f,
+	-226.563f,
+	-3.6968f,
+	105.469f,
+	-222.656f,
+	-5.2145f,
+	105.469f,
+	-218.75f,
+	-6.07198f,
+	105.469f,
+	-214.844f,
+	-5.42535f,
+	105.469f,
+	-210.938f,
+	-4.82182f,
+	105.469f,
+	-207.031f,
+	-3.22017f,
+	105.469f,
+	-203.125f,
+	-2.28037f,
+	105.469f,
+	-199.219f,
+	-1.51966f,
+	105.469f,
+	-195.313f,
+	-0.0464115f,
+	105.469f,
+	-191.406f,
+	1.73523f,
+	105.469f,
+	-187.5f,
+	2.72489f,
+	105.469f,
+	-183.594f,
+	4.39996f,
+	105.469f,
+	-179.688f,
+	5.48007f,
+	105.469f,
+	-175.781f,
+	7.27769f,
+	105.469f,
+	-171.875f,
+	10.1115f,
+	105.469f,
+	-167.969f,
+	13.0557f,
+	105.469f,
+	-164.063f,
+	15.7105f,
+	105.469f,
+	-160.156f,
+	17.8448f,
+	105.469f,
+	-156.25f,
+	19.8398f,
+	105.469f,
+	-152.344f,
+	21.6672f,
+	105.469f,
+	-148.438f,
+	24.1475f,
+	105.469f,
+	-144.531f,
+	28.4217f,
+	105.469f,
+	-140.625f,
+	31.6921f,
+	105.469f,
+	-136.719f,
+	34.3814f,
+	105.469f,
+	-132.813f,
+	34.9011f,
+	105.469f,
+	-128.906f,
+	33.8056f,
+	105.469f,
+	-125.0f,
+	34.3226f,
+	105.469f,
+	-121.094f,
+	35.6061f,
+	105.469f,
+	-117.188f,
+	37.9636f,
+	105.469f,
+	-113.281f,
+	38.6673f,
+	105.469f,
+	-109.375f,
+	36.8831f,
+	105.469f,
+	-105.469f,
+	34.5846f,
+	105.469f,
+	-101.563f,
+	32.2221f,
+	105.469f,
+	-97.6563f,
+	30.3826f,
+	105.469f,
+	-93.75f,
+	30.4243f,
+	105.469f,
+	-89.8438f,
+	30.7761f,
+	105.469f,
+	-85.9375f,
+	29.8335f,
+	105.469f,
+	-82.0313f,
+	28.0208f,
+	105.469f,
+	-78.125f,
+	25.7215f,
+	105.469f,
+	-74.2188f,
+	22.9019f,
+	105.469f,
+	-70.3125f,
+	20.9096f,
+	105.469f,
+	-66.4063f,
+	18.2558f,
+	105.469f,
+	-62.5f,
+	16.689f,
+	105.469f,
+	-58.5938f,
+	15.8032f,
+	105.469f,
+	-54.6875f,
+	14.8311f,
+	105.469f,
+	-50.7813f,
+	13.7628f,
+	105.469f,
+	-46.875f,
+	13.0048f,
+	105.469f,
+	-42.9688f,
+	11.9222f,
+	105.469f,
+	-39.0625f,
+	12.021f,
+	105.469f,
+	-35.1563f,
+	12.2727f,
+	105.469f,
+	-31.25f,
+	12.6336f,
+	105.469f,
+	-27.3438f,
+	12.6865f,
+	105.469f,
+	-23.4375f,
+	12.3758f,
+	105.469f,
+	-19.5313f,
+	13.0149f,
+	105.469f,
+	-15.625f,
+	14.0448f,
+	105.469f,
+	-11.7188f,
+	14.6064f,
+	105.469f,
+	-7.8125f,
+	15.1105f,
+	105.469f,
+	-3.90625f,
+	15.8367f,
+	105.469f,
+	0.0f,
+	16.822f,
+	105.469f,
+	3.90625f,
+	17.9608f,
+	105.469f,
+	-250.0f,
+	4.27755f,
+	101.563f,
+	-246.094f,
+	2.84639f,
+	101.563f,
+	-242.188f,
+	2.00001f,
+	101.563f,
+	-238.281f,
+	1.59426f,
+	101.563f,
+	-234.375f,
+	0.494548f,
+	101.563f,
+	-230.469f,
+	-1.78619f,
+	101.563f,
+	-226.563f,
+	-2.8668f,
+	101.563f,
+	-222.656f,
+	-5.00406f,
+	101.563f,
+	-218.75f,
+	-6.01721f,
+	101.563f,
+	-214.844f,
+	-5.29731f,
+	101.563f,
+	-210.938f,
+	-4.08939f,
+	101.563f,
+	-207.031f,
+	-3.76734f,
+	101.563f,
+	-203.125f,
+	-2.53974f,
+	101.563f,
+	-199.219f,
+	-1.06933f,
+	101.563f,
+	-195.313f,
+	-0.447271f,
+	101.563f,
+	-191.406f,
+	1.52362f,
+	101.563f,
+	-187.5f,
+	3.40783f,
+	101.563f,
+	-183.594f,
+	4.48418f,
+	101.563f,
+	-179.688f,
+	6.791f,
+	101.563f,
+	-175.781f,
+	8.68642f,
+	101.563f,
+	-171.875f,
+	11.1511f,
+	101.563f,
+	-167.969f,
+	14.4536f,
+	101.563f,
+	-164.063f,
+	17.5923f,
+	101.563f,
+	-160.156f,
+	19.4108f,
+	101.563f,
+	-156.25f,
+	20.7669f,
+	101.563f,
+	-152.344f,
+	22.2683f,
+	101.563f,
+	-148.438f,
+	24.0251f,
+	101.563f,
+	-144.531f,
+	27.7431f,
+	101.563f,
+	-140.625f,
+	31.4827f,
+	101.563f,
+	-136.719f,
+	34.3945f,
+	101.563f,
+	-132.813f,
+	35.3451f,
+	101.563f,
+	-128.906f,
+	34.9912f,
+	101.563f,
+	-125.0f,
+	34.2253f,
+	101.563f,
+	-121.094f,
+	35.1765f,
+	101.563f,
+	-117.188f,
+	37.3095f,
+	101.563f,
+	-113.281f,
+	37.7256f,
+	101.563f,
+	-109.375f,
+	36.2331f,
+	101.563f,
+	-105.469f,
+	34.435f,
+	101.563f,
+	-101.563f,
+	32.1021f,
+	101.563f,
+	-97.6563f,
+	31.0728f,
+	101.563f,
+	-93.75f,
+	30.7462f,
+	101.563f,
+	-89.8438f,
+	30.8125f,
+	101.563f,
+	-85.9375f,
+	29.6802f,
+	101.563f,
+	-82.0313f,
+	27.3023f,
+	101.563f,
+	-78.125f,
+	25.1113f,
+	101.563f,
+	-74.2188f,
+	22.6475f,
+	101.563f,
+	-70.3125f,
+	20.1315f,
+	101.563f,
+	-66.4063f,
+	18.0132f,
+	101.563f,
+	-62.5f,
+	17.1414f,
+	101.563f,
+	-58.5938f,
+	16.7884f,
+	101.563f,
+	-54.6875f,
+	15.7107f,
+	101.563f,
+	-50.7813f,
+	14.6855f,
+	101.563f,
+	-46.875f,
+	13.3626f,
+	101.563f,
+	-42.9688f,
+	11.6073f,
+	101.563f,
+	-39.0625f,
+	11.3359f,
+	101.563f,
+	-35.1563f,
+	12.4227f,
+	101.563f,
+	-31.25f,
+	13.068f,
+	101.563f,
+	-27.3438f,
+	12.4485f,
+	101.563f,
+	-23.4375f,
+	11.8491f,
+	101.563f,
+	-19.5313f,
+	13.6925f,
+	101.563f,
+	-15.625f,
+	14.7114f,
+	101.563f,
+	-11.7188f,
+	14.963f,
+	101.563f,
+	-7.8125f,
+	15.0631f,
+	101.563f,
+	-3.90625f,
+	16.1214f,
+	101.563f,
+	0.0f,
+	17.0818f,
+	101.563f,
+	3.90625f,
+	17.7074f,
+	101.563f,
+	-250.0f,
+	4.24758f,
+	97.6563f,
+	-246.094f,
+	3.92716f,
+	97.6563f,
+	-242.188f,
+	3.12473f,
+	97.6563f,
+	-238.281f,
+	2.07357f,
+	97.6563f,
+	-234.375f,
+	0.407895f,
+	97.6563f,
+	-230.469f,
+	-0.904646f,
+	97.6563f,
+	-226.563f,
+	-2.62182f,
+	97.6563f,
+	-222.656f,
+	-3.89204f,
+	97.6563f,
+	-218.75f,
+	-5.61944f,
+	97.6563f,
+	-214.844f,
+	-4.00077f,
+	97.6563f,
+	-210.938f,
+	-2.40041f,
+	97.6563f,
+	-207.031f,
+	-2.40061f,
+	97.6563f,
+	-203.125f,
+	-1.96286f,
+	97.6563f,
+	-199.219f,
+	-1.48062f,
+	97.6563f,
+	-195.313f,
+	-0.101653f,
+	97.6563f,
+	-191.406f,
+	1.73583f,
+	97.6563f,
+	-187.5f,
+	3.67572f,
+	97.6563f,
+	-183.594f,
+	5.12213f,
+	97.6563f,
+	-179.688f,
+	7.63637f,
+	97.6563f,
+	-175.781f,
+	10.1724f,
+	97.6563f,
+	-171.875f,
+	12.2812f,
+	97.6563f,
+	-167.969f,
+	15.2851f,
+	97.6563f,
+	-164.063f,
+	18.2233f,
+	97.6563f,
+	-160.156f,
+	20.4971f,
+	97.6563f,
+	-156.25f,
+	21.878f,
+	97.6563f,
+	-152.344f,
+	23.2306f,
+	97.6563f,
+	-148.438f,
+	24.2686f,
+	97.6563f,
+	-144.531f,
+	28.1874f,
+	97.6563f,
+	-140.625f,
+	31.2597f,
+	97.6563f,
+	-136.719f,
+	33.3133f,
+	97.6563f,
+	-132.813f,
+	35.319f,
+	97.6563f,
+	-128.906f,
+	35.1009f,
+	97.6563f,
+	-125.0f,
+	34.8265f,
+	97.6563f,
+	-121.094f,
+	34.2935f,
+	97.6563f,
+	-117.188f,
+	36.4908f,
+	97.6563f,
+	-113.281f,
+	37.1964f,
+	97.6563f,
+	-109.375f,
+	36.1354f,
+	97.6563f,
+	-105.469f,
+	34.3852f,
+	97.6563f,
+	-101.563f,
+	30.8829f,
+	97.6563f,
+	-97.6563f,
+	30.1091f,
+	97.6563f,
+	-93.75f,
+	30.9329f,
+	97.6563f,
+	-89.8438f,
+	30.8751f,
+	97.6563f,
+	-85.9375f,
+	29.018f,
+	97.6563f,
+	-82.0313f,
+	27.3105f,
+	97.6563f,
+	-78.125f,
+	25.0087f,
+	97.6563f,
+	-74.2188f,
+	21.6466f,
+	97.6563f,
+	-70.3125f,
+	18.5043f,
+	97.6563f,
+	-66.4063f,
+	18.66f,
+	97.6563f,
+	-62.5f,
+	18.1592f,
+	97.6563f,
+	-58.5938f,
+	17.521f,
+	97.6563f,
+	-54.6875f,
+	16.3389f,
+	97.6563f,
+	-50.7813f,
+	14.8664f,
+	97.6563f,
+	-46.875f,
+	13.5991f,
+	97.6563f,
+	-42.9688f,
+	11.873f,
+	97.6563f,
+	-39.0625f,
+	11.498f,
+	97.6563f,
+	-35.1563f,
+	11.5171f,
+	97.6563f,
+	-31.25f,
+	12.5588f,
+	97.6563f,
+	-27.3438f,
+	12.2172f,
+	97.6563f,
+	-23.4375f,
+	11.2491f,
+	97.6563f,
+	-19.5313f,
+	13.2373f,
+	97.6563f,
+	-15.625f,
+	13.5683f,
+	97.6563f,
+	-11.7188f,
+	14.0875f,
+	97.6563f,
+	-7.8125f,
+	14.6591f,
+	97.6563f,
+	-3.90625f,
+	15.1275f,
+	97.6563f,
+	0.0f,
+	15.8243f,
+	97.6563f,
+	3.90625f,
+	18.0176f,
+	97.6563f,
+	-250.0f,
+	4.93619f,
+	93.75f,
+	-246.094f,
+	3.50077f,
+	93.75f,
+	-242.188f,
+	2.88532f,
+	93.75f,
+	-238.281f,
+	2.19691f,
+	93.75f,
+	-234.375f,
+	1.45343f,
+	93.75f,
+	-230.469f,
+	-0.151238f,
+	93.75f,
+	-226.563f,
+	-1.0856f,
+	93.75f,
+	-222.656f,
+	-2.29205f,
+	93.75f,
+	-218.75f,
+	-3.83678f,
+	93.75f,
+	-214.844f,
+	-2.73856f,
+	93.75f,
+	-210.938f,
+	-2.19574f,
+	93.75f,
+	-207.031f,
+	-0.222008f,
+	93.75f,
+	-203.125f,
+	-0.117961f,
+	93.75f,
+	-199.219f,
+	-0.17607f,
+	93.75f,
+	-195.313f,
+	1.32212f,
+	93.75f,
+	-191.406f,
+	2.64292f,
+	93.75f,
+	-187.5f,
+	3.72678f,
+	93.75f,
+	-183.594f,
+	5.78729f,
+	93.75f,
+	-179.688f,
+	9.09616f,
+	93.75f,
+	-175.781f,
+	11.4833f,
+	93.75f,
+	-171.875f,
+	13.1923f,
+	93.75f,
+	-167.969f,
+	15.68f,
+	93.75f,
+	-164.063f,
+	17.9844f,
+	93.75f,
+	-160.156f,
+	20.7688f,
+	93.75f,
+	-156.25f,
+	23.4925f,
+	93.75f,
+	-152.344f,
+	25.2252f,
+	93.75f,
+	-148.438f,
+	25.9373f,
+	93.75f,
+	-144.531f,
+	28.1941f,
+	93.75f,
+	-140.625f,
+	31.9896f,
+	93.75f,
+	-136.719f,
+	33.5688f,
+	93.75f,
+	-132.813f,
+	34.7177f,
+	93.75f,
+	-128.906f,
+	35.1459f,
+	93.75f,
+	-125.0f,
+	34.9785f,
+	93.75f,
+	-121.094f,
+	34.3971f,
+	93.75f,
+	-117.188f,
+	35.2455f,
+	93.75f,
+	-113.281f,
+	36.0209f,
+	93.75f,
+	-109.375f,
+	35.244f,
+	93.75f,
+	-105.469f,
+	33.4542f,
+	93.75f,
+	-101.563f,
+	30.3707f,
+	93.75f,
+	-97.6563f,
+	30.709f,
+	93.75f,
+	-93.75f,
+	31.2489f,
+	93.75f,
+	-89.8438f,
+	30.5476f,
+	93.75f,
+	-85.9375f,
+	28.5982f,
+	93.75f,
+	-82.0313f,
+	26.6838f,
+	93.75f,
+	-78.125f,
+	24.1646f,
+	93.75f,
+	-74.2188f,
+	21.261f,
+	93.75f,
+	-70.3125f,
+	19.8206f,
+	93.75f,
+	-66.4063f,
+	19.4952f,
+	93.75f,
+	-62.5f,
+	18.3276f,
+	93.75f,
+	-58.5938f,
+	18.1028f,
+	93.75f,
+	-54.6875f,
+	17.0878f,
+	93.75f,
+	-50.7813f,
+	15.0144f,
+	93.75f,
+	-46.875f,
+	13.5565f,
+	93.75f,
+	-42.9688f,
+	11.0211f,
+	93.75f,
+	-39.0625f,
+	11.1986f,
+	93.75f,
+	-35.1563f,
+	10.4097f,
+	93.75f,
+	-31.25f,
+	11.2207f,
+	93.75f,
+	-27.3438f,
+	11.4539f,
+	93.75f,
+	-23.4375f,
+	11.4014f,
+	93.75f,
+	-19.5313f,
+	12.2344f,
+	93.75f,
+	-15.625f,
+	13.5348f,
+	93.75f,
+	-11.7188f,
+	14.2772f,
+	93.75f,
+	-7.8125f,
+	14.0447f,
+	93.75f,
+	-3.90625f,
+	14.1587f,
+	93.75f,
+	0.0f,
+	15.3266f,
+	93.75f,
+	3.90625f,
+	17.1671f,
+	93.75f,
+	-250.0f,
+	5.40499f,
+	89.8438f,
+	-246.094f,
+	3.9236f,
+	89.8438f,
+	-242.188f,
+	2.78029f,
+	89.8438f,
+	-238.281f,
+	2.337f,
+	89.8438f,
+	-234.375f,
+	1.45614f,
+	89.8438f,
+	-230.469f,
+	0.487402f,
+	89.8438f,
+	-226.563f,
+	0.814658f,
+	89.8438f,
+	-222.656f,
+	-0.244101f,
+	89.8438f,
+	-218.75f,
+	-2.09422f,
+	89.8438f,
+	-214.844f,
+	-1.48441f,
+	89.8438f,
+	-210.938f,
+	-0.695794f,
+	89.8438f,
+	-207.031f,
+	0.742314f,
+	89.8438f,
+	-203.125f,
+	1.30594f,
+	89.8438f,
+	-199.219f,
+	1.49011f,
+	89.8438f,
+	-195.313f,
+	2.5687f,
+	89.8438f,
+	-191.406f,
+	3.72318f,
+	89.8438f,
+	-187.5f,
+	4.658f,
+	89.8438f,
+	-183.594f,
+	7.20615f,
+	89.8438f,
+	-179.688f,
+	9.85211f,
+	89.8438f,
+	-175.781f,
+	12.8482f,
+	89.8438f,
+	-171.875f,
+	14.6361f,
+	89.8438f,
+	-167.969f,
+	16.6036f,
+	89.8438f,
+	-164.063f,
+	19.7308f,
+	89.8438f,
+	-160.156f,
+	22.7068f,
+	89.8438f,
+	-156.25f,
+	24.421f,
+	89.8438f,
+	-152.344f,
+	25.8961f,
+	89.8438f,
+	-148.438f,
+	27.1249f,
+	89.8438f,
+	-144.531f,
+	29.0138f,
+	89.8438f,
+	-140.625f,
+	31.6384f,
+	89.8438f,
+	-136.719f,
+	33.9142f,
+	89.8438f,
+	-132.813f,
+	34.3317f,
+	89.8438f,
+	-128.906f,
+	36.0856f,
+	89.8438f,
+	-125.0f,
+	35.5134f,
+	89.8438f,
+	-121.094f,
+	34.7035f,
+	89.8438f,
+	-117.188f,
+	33.6847f,
+	89.8438f,
+	-113.281f,
+	34.2624f,
+	89.8438f,
+	-109.375f,
+	34.2147f,
+	89.8438f,
+	-105.469f,
+	32.2925f,
+	89.8438f,
+	-101.563f,
+	30.4889f,
+	89.8438f,
+	-97.6563f,
+	30.8562f,
+	89.8438f,
+	-93.75f,
+	31.4717f,
+	89.8438f,
+	-89.8438f,
+	30.2623f,
+	89.8438f,
+	-85.9375f,
+	28.4623f,
+	89.8438f,
+	-82.0313f,
+	26.6117f,
+	89.8438f,
+	-78.125f,
+	24.1755f,
+	89.8438f,
+	-74.2188f,
+	22.4752f,
+	89.8438f,
+	-70.3125f,
+	20.3246f,
+	89.8438f,
+	-66.4063f,
+	19.488f,
+	89.8438f,
+	-62.5f,
+	18.6447f,
+	89.8438f,
+	-58.5938f,
+	17.8933f,
+	89.8438f,
+	-54.6875f,
+	16.177f,
+	89.8438f,
+	-50.7813f,
+	15.2537f,
+	89.8438f,
+	-46.875f,
+	13.5232f,
+	89.8438f,
+	-42.9688f,
+	11.842f,
+	89.8438f,
+	-39.0625f,
+	10.223f,
+	89.8438f,
+	-35.1563f,
+	9.54441f,
+	89.8438f,
+	-31.25f,
+	9.73488f,
+	89.8438f,
+	-27.3438f,
+	10.7057f,
+	89.8438f,
+	-23.4375f,
+	11.9185f,
+	89.8438f,
+	-19.5313f,
+	13.2106f,
+	89.8438f,
+	-15.625f,
+	13.0807f,
+	89.8438f,
+	-11.7188f,
+	12.8112f,
+	89.8438f,
+	-7.8125f,
+	12.7972f,
+	89.8438f,
+	-3.90625f,
+	14.1049f,
+	89.8438f,
+	0.0f,
+	14.9674f,
+	89.8438f,
+	3.90625f,
+	15.6427f,
+	89.8438f,
+	-250.0f,
+	6.21462f,
+	85.9375f,
+	-246.094f,
+	4.66025f,
+	85.9375f,
+	-242.188f,
+	3.36279f,
+	85.9375f,
+	-238.281f,
+	1.97426f,
+	85.9375f,
+	-234.375f,
+	0.590897f,
+	85.9375f,
+	-230.469f,
+	2.01222f,
+	85.9375f,
+	-226.563f,
+	2.15192f,
+	85.9375f,
+	-222.656f,
+	0.78006f,
+	85.9375f,
+	-218.75f,
+	-0.424968f,
+	85.9375f,
+	-214.844f,
+	-0.512869f,
+	85.9375f,
+	-210.938f,
+	0.00319427f,
+	85.9375f,
+	-207.031f,
+	1.05715f,
+	85.9375f,
+	-203.125f,
+	2.11926f,
+	85.9375f,
+	-199.219f,
+	2.48862f,
+	85.9375f,
+	-195.313f,
+	3.89944f,
+	85.9375f,
+	-191.406f,
+	5.71899f,
+	85.9375f,
+	-187.5f,
+	6.41674f,
+	85.9375f,
+	-183.594f,
+	7.94295f,
+	85.9375f,
+	-179.688f,
+	10.9562f,
+	85.9375f,
+	-175.781f,
+	13.1951f,
+	85.9375f,
+	-171.875f,
+	15.7827f,
+	85.9375f,
+	-167.969f,
+	17.6951f,
+	85.9375f,
+	-164.063f,
+	20.2261f,
+	85.9375f,
+	-160.156f,
+	22.5211f,
+	85.9375f,
+	-156.25f,
+	24.8103f,
+	85.9375f,
+	-152.344f,
+	26.6666f,
+	85.9375f,
+	-148.438f,
+	27.7052f,
+	85.9375f,
+	-144.531f,
+	29.2234f,
+	85.9375f,
+	-140.625f,
+	31.4629f,
+	85.9375f,
+	-136.719f,
+	34.0955f,
+	85.9375f,
+	-132.813f,
+	34.7124f,
+	85.9375f,
+	-128.906f,
+	36.1712f,
+	85.9375f,
+	-125.0f,
+	36.4743f,
+	85.9375f,
+	-121.094f,
+	35.3967f,
+	85.9375f,
+	-117.188f,
+	34.3505f,
+	85.9375f,
+	-113.281f,
+	33.5175f,
+	85.9375f,
+	-109.375f,
+	32.9976f,
+	85.9375f,
+	-105.469f,
+	31.7882f,
+	85.9375f,
+	-101.563f,
+	31.1746f,
+	85.9375f,
+	-97.6563f,
+	31.0271f,
+	85.9375f,
+	-93.75f,
+	31.5303f,
+	85.9375f,
+	-89.8438f,
+	30.8744f,
+	85.9375f,
+	-85.9375f,
+	28.1434f,
+	85.9375f,
+	-82.0313f,
+	25.9196f,
+	85.9375f,
+	-78.125f,
+	24.4044f,
+	85.9375f,
+	-74.2188f,
+	21.9984f,
+	85.9375f,
+	-70.3125f,
+	20.0411f,
+	85.9375f,
+	-66.4063f,
+	19.9449f,
+	85.9375f,
+	-62.5f,
+	18.3893f,
+	85.9375f,
+	-58.5938f,
+	16.9846f,
+	85.9375f,
+	-54.6875f,
+	15.6155f,
+	85.9375f,
+	-50.7813f,
+	14.6152f,
+	85.9375f,
+	-46.875f,
+	12.7358f,
+	85.9375f,
+	-42.9688f,
+	12.1599f,
+	85.9375f,
+	-39.0625f,
+	10.1045f,
+	85.9375f,
+	-35.1563f,
+	9.61416f,
+	85.9375f,
+	-31.25f,
+	10.0784f,
+	85.9375f,
+	-27.3438f,
+	10.2188f,
+	85.9375f,
+	-23.4375f,
+	11.574f,
+	85.9375f,
+	-19.5313f,
+	11.8712f,
+	85.9375f,
+	-15.625f,
+	11.9109f,
+	85.9375f,
+	-11.7188f,
+	11.509f,
+	85.9375f,
+	-7.8125f,
+	13.9979f,
+	85.9375f,
+	-3.90625f,
+	14.8453f,
+	85.9375f,
+	0.0f,
+	14.7941f,
+	85.9375f,
+	3.90625f,
+	15.5916f,
+	85.9375f,
+	-250.0f,
+	6.94324f,
+	82.0313f,
+	-246.094f,
+	4.77131f,
+	82.0313f,
+	-242.188f,
+	3.62143f,
+	82.0313f,
+	-238.281f,
+	2.50324f,
+	82.0313f,
+	-234.375f,
+	1.40345f,
+	82.0313f,
+	-230.469f,
+	2.05881f,
+	82.0313f,
+	-226.563f,
+	2.41769f,
+	82.0313f,
+	-222.656f,
+	1.23736f,
+	82.0313f,
+	-218.75f,
+	1.59545f,
+	82.0313f,
+	-214.844f,
+	1.25313f,
+	82.0313f,
+	-210.938f,
+	1.53594f,
+	82.0313f,
+	-207.031f,
+	2.33073f,
+	82.0313f,
+	-203.125f,
+	2.59696f,
+	82.0313f,
+	-199.219f,
+	4.25487f,
+	82.0313f,
+	-195.313f,
+	5.86136f,
+	82.0313f,
+	-191.406f,
+	7.54631f,
+	82.0313f,
+	-187.5f,
+	8.7315f,
+	82.0313f,
+	-183.594f,
+	9.65737f,
+	82.0313f,
+	-179.688f,
+	11.5328f,
+	82.0313f,
+	-175.781f,
+	14.3069f,
+	82.0313f,
+	-171.875f,
+	16.2889f,
+	82.0313f,
+	-167.969f,
+	17.6379f,
+	82.0313f,
+	-164.063f,
+	20.4422f,
+	82.0313f,
+	-160.156f,
+	22.9557f,
+	82.0313f,
+	-156.25f,
+	25.0731f,
+	82.0313f,
+	-152.344f,
+	27.3881f,
+	82.0313f,
+	-148.438f,
+	28.7955f,
+	82.0313f,
+	-144.531f,
+	30.2575f,
+	82.0313f,
+	-140.625f,
+	32.5888f,
+	82.0313f,
+	-136.719f,
+	33.9884f,
+	82.0313f,
+	-132.813f,
+	34.4838f,
+	82.0313f,
+	-128.906f,
+	35.7672f,
+	82.0313f,
+	-125.0f,
+	36.1002f,
+	82.0313f,
+	-121.094f,
+	35.9318f,
+	82.0313f,
+	-117.188f,
+	34.9715f,
+	82.0313f,
+	-113.281f,
+	33.3187f,
+	82.0313f,
+	-109.375f,
+	31.9477f,
+	82.0313f,
+	-105.469f,
+	31.4437f,
+	82.0313f,
+	-101.563f,
+	31.2817f,
+	82.0313f,
+	-97.6563f,
+	32.08f,
+	82.0313f,
+	-93.75f,
+	31.4037f,
+	82.0313f,
+	-89.8438f,
+	30.2769f,
+	82.0313f,
+	-85.9375f,
+	28.1374f,
+	82.0313f,
+	-82.0313f,
+	25.4814f,
+	82.0313f,
+	-78.125f,
+	24.1831f,
+	82.0313f,
+	-74.2188f,
+	22.6148f,
+	82.0313f,
+	-70.3125f,
+	19.2585f,
+	82.0313f,
+	-66.4063f,
+	18.6785f,
+	82.0313f,
+	-62.5f,
+	17.7889f,
+	82.0313f,
+	-58.5938f,
+	16.5855f,
+	82.0313f,
+	-54.6875f,
+	14.6918f,
+	82.0313f,
+	-50.7813f,
+	12.9532f,
+	82.0313f,
+	-46.875f,
+	12.1502f,
+	82.0313f,
+	-42.9688f,
+	11.3533f,
+	82.0313f,
+	-39.0625f,
+	9.8302f,
+	82.0313f,
+	-35.1563f,
+	9.95311f,
+	82.0313f,
+	-31.25f,
+	10.7631f,
+	82.0313f,
+	-27.3438f,
+	10.2187f,
+	82.0313f,
+	-23.4375f,
+	10.1072f,
+	82.0313f,
+	-19.5313f,
+	11.299f,
+	82.0313f,
+	-15.625f,
+	11.5563f,
+	82.0313f,
+	-11.7188f,
+	13.9188f,
+	82.0313f,
+	-7.8125f,
+	15.247f,
+	82.0313f,
+	-3.90625f,
+	15.6866f,
+	82.0313f,
+	0.0f,
+	15.9694f,
+	82.0313f,
+	3.90625f,
+	16.9644f,
+	82.0313f,
+	-250.0f,
+	6.39735f,
+	78.125f,
+	-246.094f,
+	5.09353f,
+	78.125f,
+	-242.188f,
+	4.53503f,
+	78.125f,
+	-238.281f,
+	3.72522f,
+	78.125f,
+	-234.375f,
+	3.02648f,
+	78.125f,
+	-230.469f,
+	3.02057f,
+	78.125f,
+	-226.563f,
+	3.8807f,
+	78.125f,
+	-222.656f,
+	4.47382f,
+	78.125f,
+	-218.75f,
+	3.84005f,
+	78.125f,
+	-214.844f,
+	2.7347f,
+	78.125f,
+	-210.938f,
+	4.55018f,
+	78.125f,
+	-207.031f,
+	5.04579f,
+	78.125f,
+	-203.125f,
+	4.45937f,
+	78.125f,
+	-199.219f,
+	5.32656f,
+	78.125f,
+	-195.313f,
+	7.13791f,
+	78.125f,
+	-191.406f,
+	8.89822f,
+	78.125f,
+	-187.5f,
+	10.3911f,
+	78.125f,
+	-183.594f,
+	11.3679f,
+	78.125f,
+	-179.688f,
+	13.4068f,
+	78.125f,
+	-175.781f,
+	16.3393f,
+	78.125f,
+	-171.875f,
+	17.801f,
+	78.125f,
+	-167.969f,
+	19.0455f,
+	78.125f,
+	-164.063f,
+	21.4178f,
+	78.125f,
+	-160.156f,
+	23.555f,
+	78.125f,
+	-156.25f,
+	25.3953f,
+	78.125f,
+	-152.344f,
+	26.9657f,
+	78.125f,
+	-148.438f,
+	28.8194f,
+	78.125f,
+	-144.531f,
+	31.456f,
+	78.125f,
+	-140.625f,
+	33.3499f,
+	78.125f,
+	-136.719f,
+	34.2296f,
+	78.125f,
+	-132.813f,
+	34.5964f,
+	78.125f,
+	-128.906f,
+	35.7399f,
+	78.125f,
+	-125.0f,
+	35.4576f,
+	78.125f,
+	-121.094f,
+	35.7986f,
+	78.125f,
+	-117.188f,
+	34.4641f,
+	78.125f,
+	-113.281f,
+	33.925f,
+	78.125f,
+	-109.375f,
+	32.0574f,
+	78.125f,
+	-105.469f,
+	31.6743f,
+	78.125f,
+	-101.563f,
+	31.65f,
+	78.125f,
+	-97.6563f,
+	31.9461f,
+	78.125f,
+	-93.75f,
+	31.2261f,
+	78.125f,
+	-89.8438f,
+	30.4701f,
+	78.125f,
+	-85.9375f,
+	27.7569f,
+	78.125f,
+	-82.0313f,
+	25.4553f,
+	78.125f,
+	-78.125f,
+	23.3917f,
+	78.125f,
+	-74.2188f,
+	21.6944f,
+	78.125f,
+	-70.3125f,
+	18.6818f,
+	78.125f,
+	-66.4063f,
+	17.4066f,
+	78.125f,
+	-62.5f,
+	17.1317f,
+	78.125f,
+	-58.5938f,
+	16.5093f,
+	78.125f,
+	-54.6875f,
+	14.9512f,
+	78.125f,
+	-50.7813f,
+	13.228f,
+	78.125f,
+	-46.875f,
+	11.4638f,
+	78.125f,
+	-42.9688f,
+	10.3877f,
+	78.125f,
+	-39.0625f,
+	9.7131f,
+	78.125f,
+	-35.1563f,
+	10.0477f,
+	78.125f,
+	-31.25f,
+	10.325f,
+	78.125f,
+	-27.3438f,
+	10.317f,
+	78.125f,
+	-23.4375f,
+	10.9076f,
+	78.125f,
+	-19.5313f,
+	11.7808f,
+	78.125f,
+	-15.625f,
+	14.1905f,
+	78.125f,
+	-11.7188f,
+	15.6035f,
+	78.125f,
+	-7.8125f,
+	16.0979f,
+	78.125f,
+	-3.90625f,
+	16.6425f,
+	78.125f,
+	0.0f,
+	17.2837f,
+	78.125f,
+	3.90625f,
+	18.8244f,
+	78.125f,
+	-250.0f,
+	6.03592f,
+	74.2188f,
+	-246.094f,
+	5.17606f,
+	74.2188f,
+	-242.188f,
+	3.7036f,
+	74.2188f,
+	-238.281f,
+	3.69f,
+	74.2188f,
+	-234.375f,
+	4.60611f,
+	74.2188f,
+	-230.469f,
+	4.52682f,
+	74.2188f,
+	-226.563f,
+	5.59937f,
+	74.2188f,
+	-222.656f,
+	6.25837f,
+	74.2188f,
+	-218.75f,
+	5.11517f,
+	74.2188f,
+	-214.844f,
+	4.67242f,
+	74.2188f,
+	-210.938f,
+	5.76173f,
+	74.2188f,
+	-207.031f,
+	6.80461f,
+	74.2188f,
+	-203.125f,
+	6.95083f,
+	74.2188f,
+	-199.219f,
+	7.35893f,
+	74.2188f,
+	-195.313f,
+	8.63949f,
+	74.2188f,
+	-191.406f,
+	10.4144f,
+	74.2188f,
+	-187.5f,
+	11.8105f,
+	74.2188f,
+	-183.594f,
+	13.4583f,
+	74.2188f,
+	-179.688f,
+	15.5665f,
+	74.2188f,
+	-175.781f,
+	18.2568f,
+	74.2188f,
+	-171.875f,
+	19.1732f,
+	74.2188f,
+	-167.969f,
+	21.3098f,
+	74.2188f,
+	-164.063f,
+	23.6359f,
+	74.2188f,
+	-160.156f,
+	25.3154f,
+	74.2188f,
+	-156.25f,
+	27.6289f,
+	74.2188f,
+	-152.344f,
+	28.8953f,
+	74.2188f,
+	-148.438f,
+	30.5098f,
+	74.2188f,
+	-144.531f,
+	32.3942f,
+	74.2188f,
+	-140.625f,
+	33.3325f,
+	74.2188f,
+	-136.719f,
+	33.8009f,
+	74.2188f,
+	-132.813f,
+	35.0803f,
+	74.2188f,
+	-128.906f,
+	34.737f,
+	74.2188f,
+	-125.0f,
+	34.3656f,
+	74.2188f,
+	-121.094f,
+	34.2107f,
+	74.2188f,
+	-117.188f,
+	33.1645f,
+	74.2188f,
+	-113.281f,
+	32.0615f,
+	74.2188f,
+	-109.375f,
+	32.0827f,
+	74.2188f,
+	-105.469f,
+	32.4658f,
+	74.2188f,
+	-101.563f,
+	31.6315f,
+	74.2188f,
+	-97.6563f,
+	30.9698f,
+	74.2188f,
+	-93.75f,
+	30.6464f,
+	74.2188f,
+	-89.8438f,
+	29.9645f,
+	74.2188f,
+	-85.9375f,
+	27.4393f,
+	74.2188f,
+	-82.0313f,
+	25.2807f,
+	74.2188f,
+	-78.125f,
+	23.57f,
+	74.2188f,
+	-74.2188f,
+	20.653f,
+	74.2188f,
+	-70.3125f,
+	18.1395f,
+	74.2188f,
+	-66.4063f,
+	17.6585f,
+	74.2188f,
+	-62.5f,
+	17.2798f,
+	74.2188f,
+	-58.5938f,
+	16.6041f,
+	74.2188f,
+	-54.6875f,
+	14.6913f,
+	74.2188f,
+	-50.7813f,
+	13.1416f,
+	74.2188f,
+	-46.875f,
+	10.9374f,
+	74.2188f,
+	-42.9688f,
+	9.39485f,
+	74.2188f,
+	-39.0625f,
+	9.21956f,
+	74.2188f,
+	-35.1563f,
+	9.74875f,
+	74.2188f,
+	-31.25f,
+	10.3932f,
+	74.2188f,
+	-27.3438f,
+	10.7996f,
+	74.2188f,
+	-23.4375f,
+	11.5538f,
+	74.2188f,
+	-19.5313f,
+	13.5418f,
+	74.2188f,
+	-15.625f,
+	15.6336f,
+	74.2188f,
+	-11.7188f,
+	16.3846f,
+	74.2188f,
+	-7.8125f,
+	17.738f,
+	74.2188f,
+	-3.90625f,
+	17.98f,
+	74.2188f,
+	0.0f,
+	19.1669f,
+	74.2188f,
+	3.90625f,
+	20.6829f,
+	74.2188f,
+	-250.0f,
+	5.45149f,
+	70.3125f,
+	-246.094f,
+	4.83779f,
+	70.3125f,
+	-242.188f,
+	3.60093f,
+	70.3125f,
+	-238.281f,
+	3.26469f,
+	70.3125f,
+	-234.375f,
+	4.06145f,
+	70.3125f,
+	-230.469f,
+	5.31565f,
+	70.3125f,
+	-226.563f,
+	6.65809f,
+	70.3125f,
+	-222.656f,
+	6.70538f,
+	70.3125f,
+	-218.75f,
+	6.93258f,
+	70.3125f,
+	-214.844f,
+	6.84841f,
+	70.3125f,
+	-210.938f,
+	6.9662f,
+	70.3125f,
+	-207.031f,
+	7.74003f,
+	70.3125f,
+	-203.125f,
+	8.68749f,
+	70.3125f,
+	-199.219f,
+	9.06225f,
+	70.3125f,
+	-195.313f,
+	10.0803f,
+	70.3125f,
+	-191.406f,
+	12.202f,
+	70.3125f,
+	-187.5f,
+	14.063f,
+	70.3125f,
+	-183.594f,
+	15.732f,
+	70.3125f,
+	-179.688f,
+	18.3972f,
+	70.3125f,
+	-175.781f,
+	19.5054f,
+	70.3125f,
+	-171.875f,
+	20.8927f,
+	70.3125f,
+	-167.969f,
+	23.3843f,
+	70.3125f,
+	-164.063f,
+	25.5894f,
+	70.3125f,
+	-160.156f,
+	27.0506f,
+	70.3125f,
+	-156.25f,
+	28.6483f,
+	70.3125f,
+	-152.344f,
+	31.3986f,
+	70.3125f,
+	-148.438f,
+	32.5255f,
+	70.3125f,
+	-144.531f,
+	33.0315f,
+	70.3125f,
+	-140.625f,
+	33.0927f,
+	70.3125f,
+	-136.719f,
+	33.7595f,
+	70.3125f,
+	-132.813f,
+	34.1872f,
+	70.3125f,
+	-128.906f,
+	33.4924f,
+	70.3125f,
+	-125.0f,
+	34.1817f,
+	70.3125f,
+	-121.094f,
+	33.4642f,
+	70.3125f,
+	-117.188f,
+	32.3231f,
+	70.3125f,
+	-113.281f,
+	32.1235f,
+	70.3125f,
+	-109.375f,
+	32.674f,
+	70.3125f,
+	-105.469f,
+	32.7558f,
+	70.3125f,
+	-101.563f,
+	32.4896f,
+	70.3125f,
+	-97.6563f,
+	30.7945f,
+	70.3125f,
+	-93.75f,
+	30.1182f,
+	70.3125f,
+	-89.8438f,
+	28.6969f,
+	70.3125f,
+	-85.9375f,
+	26.606f,
+	70.3125f,
+	-82.0313f,
+	24.8053f,
+	70.3125f,
+	-78.125f,
+	23.3599f,
+	70.3125f,
+	-74.2188f,
+	20.5363f,
+	70.3125f,
+	-70.3125f,
+	18.2858f,
+	70.3125f,
+	-66.4063f,
+	17.647f,
+	70.3125f,
+	-62.5f,
+	17.3761f,
+	70.3125f,
+	-58.5938f,
+	16.3124f,
+	70.3125f,
+	-54.6875f,
+	14.016f,
+	70.3125f,
+	-50.7813f,
+	11.6317f,
+	70.3125f,
+	-46.875f,
+	9.68832f,
+	70.3125f,
+	-42.9688f,
+	8.63692f,
+	70.3125f,
+	-39.0625f,
+	8.52412f,
+	70.3125f,
+	-35.1563f,
+	10.3549f,
+	70.3125f,
+	-31.25f,
+	11.1185f,
+	70.3125f,
+	-27.3438f,
+	12.8223f,
+	70.3125f,
+	-23.4375f,
+	14.2548f,
+	70.3125f,
+	-19.5313f,
+	15.4066f,
+	70.3125f,
+	-15.625f,
+	16.875f,
+	70.3125f,
+	-11.7188f,
+	17.7202f,
+	70.3125f,
+	-7.8125f,
+	18.6716f,
+	70.3125f,
+	-3.90625f,
+	19.72f,
+	70.3125f,
+	0.0f,
+	21.3086f,
+	70.3125f,
+	3.90625f,
+	22.948f,
+	70.3125f,
+	-250.0f,
+	4.53118f,
+	66.4063f,
+	-246.094f,
+	3.73568f,
+	66.4063f,
+	-242.188f,
+	3.80679f,
+	66.4063f,
+	-238.281f,
+	4.42509f,
+	66.4063f,
+	-234.375f,
+	5.0317f,
+	66.4063f,
+	-230.469f,
+	6.63484f,
+	66.4063f,
+	-226.563f,
+	7.65599f,
+	66.4063f,
+	-222.656f,
+	8.55305f,
+	66.4063f,
+	-218.75f,
+	8.71866f,
+	66.4063f,
+	-214.844f,
+	7.68897f,
+	66.4063f,
+	-210.938f,
+	8.59141f,
+	66.4063f,
+	-207.031f,
+	9.73811f,
+	66.4063f,
+	-203.125f,
+	10.1348f,
+	66.4063f,
+	-199.219f,
+	10.1075f,
+	66.4063f,
+	-195.313f,
+	11.1394f,
+	66.4063f,
+	-191.406f,
+	13.5829f,
+	66.4063f,
+	-187.5f,
+	15.4951f,
+	66.4063f,
+	-183.594f,
+	17.5574f,
+	66.4063f,
+	-179.688f,
+	19.9291f,
+	66.4063f,
+	-175.781f,
+	21.0567f,
+	66.4063f,
+	-171.875f,
+	22.5003f,
+	66.4063f,
+	-167.969f,
+	25.5993f,
+	66.4063f,
+	-164.063f,
+	27.0097f,
+	66.4063f,
+	-160.156f,
+	27.9166f,
+	66.4063f,
+	-156.25f,
+	29.8989f,
+	66.4063f,
+	-152.344f,
+	32.1785f,
+	66.4063f,
+	-148.438f,
+	34.0669f,
+	66.4063f,
+	-144.531f,
+	34.5129f,
+	66.4063f,
+	-140.625f,
+	34.1795f,
+	66.4063f,
+	-136.719f,
+	33.3311f,
+	66.4063f,
+	-132.813f,
+	32.969f,
+	66.4063f,
+	-128.906f,
+	32.9477f,
+	66.4063f,
+	-125.0f,
+	33.5186f,
+	66.4063f,
+	-121.094f,
+	32.9715f,
+	66.4063f,
+	-117.188f,
+	32.4898f,
+	66.4063f,
+	-113.281f,
+	33.0858f,
+	66.4063f,
+	-109.375f,
+	32.6501f,
+	66.4063f,
+	-105.469f,
+	32.847f,
+	66.4063f,
+	-101.563f,
+	32.8074f,
+	66.4063f,
+	-97.6563f,
+	31.5661f,
+	66.4063f,
+	-93.75f,
+	29.4807f,
+	66.4063f,
+	-89.8438f,
+	28.6706f,
+	66.4063f,
+	-85.9375f,
+	26.408f,
+	66.4063f,
+	-82.0313f,
+	24.3989f,
+	66.4063f,
+	-78.125f,
+	22.4069f,
+	66.4063f,
+	-74.2188f,
+	20.2026f,
+	66.4063f,
+	-70.3125f,
+	18.5513f,
+	66.4063f,
+	-66.4063f,
+	17.0548f,
+	66.4063f,
+	-62.5f,
+	17.0623f,
+	66.4063f,
+	-58.5938f,
+	15.9909f,
+	66.4063f,
+	-54.6875f,
+	13.3885f,
+	66.4063f,
+	-50.7813f,
+	11.8657f,
+	66.4063f,
+	-46.875f,
+	9.02652f,
+	66.4063f,
+	-42.9688f,
+	8.99046f,
+	66.4063f,
+	-39.0625f,
+	10.0543f,
+	66.4063f,
+	-35.1563f,
+	11.7078f,
+	66.4063f,
+	-31.25f,
+	12.4956f,
+	66.4063f,
+	-27.3438f,
+	14.0575f,
+	66.4063f,
+	-23.4375f,
+	15.2147f,
+	66.4063f,
+	-19.5313f,
+	16.7089f,
+	66.4063f,
+	-15.625f,
+	17.8009f,
+	66.4063f,
+	-11.7188f,
+	19.0086f,
+	66.4063f,
+	-7.8125f,
+	20.9864f,
+	66.4063f,
+	-3.90625f,
+	22.6943f,
+	66.4063f,
+	0.0f,
+	23.9641f,
+	66.4063f,
+	3.90625f,
+	25.5564f,
+	66.4063f,
+	-250.0f,
+	4.6779f,
+	62.5f,
+	-246.094f,
+	4.41735f,
+	62.5f,
+	-242.188f,
+	3.93647f,
+	62.5f,
+	-238.281f,
+	4.50648f,
+	62.5f,
+	-234.375f,
+	5.52163f,
+	62.5f,
+	-230.469f,
+	7.10395f,
+	62.5f,
+	-226.563f,
+	8.10257f,
+	62.5f,
+	-222.656f,
+	8.36726f,
+	62.5f,
+	-218.75f,
+	8.58321f,
+	62.5f,
+	-214.844f,
+	8.56809f,
+	62.5f,
+	-210.938f,
+	9.95321f,
+	62.5f,
+	-207.031f,
+	10.4904f,
+	62.5f,
+	-203.125f,
+	10.812f,
+	62.5f,
+	-199.219f,
+	11.5942f,
+	62.5f,
+	-195.313f,
+	13.0371f,
+	62.5f,
+	-191.406f,
+	14.6432f,
+	62.5f,
+	-187.5f,
+	16.7375f,
+	62.5f,
+	-183.594f,
+	18.4129f,
+	62.5f,
+	-179.688f,
+	20.9534f,
+	62.5f,
+	-175.781f,
+	23.1161f,
+	62.5f,
+	-171.875f,
+	25.0267f,
+	62.5f,
+	-167.969f,
+	26.7355f,
+	62.5f,
+	-164.063f,
+	27.6983f,
+	62.5f,
+	-160.156f,
+	29.1111f,
+	62.5f,
+	-156.25f,
+	31.1905f,
+	62.5f,
+	-152.344f,
+	32.9766f,
+	62.5f,
+	-148.438f,
+	33.4703f,
+	62.5f,
+	-144.531f,
+	33.714f,
+	62.5f,
+	-140.625f,
+	33.649f,
+	62.5f,
+	-136.719f,
+	33.0246f,
+	62.5f,
+	-132.813f,
+	32.7386f,
+	62.5f,
+	-128.906f,
+	32.6069f,
+	62.5f,
+	-125.0f,
+	32.6579f,
+	62.5f,
+	-121.094f,
+	31.5955f,
+	62.5f,
+	-117.188f,
+	31.8589f,
+	62.5f,
+	-113.281f,
+	32.7188f,
+	62.5f,
+	-109.375f,
+	32.889f,
+	62.5f,
+	-105.469f,
+	32.7317f,
+	62.5f,
+	-101.563f,
+	32.4229f,
+	62.5f,
+	-97.6563f,
+	31.2118f,
+	62.5f,
+	-93.75f,
+	30.6824f,
+	62.5f,
+	-89.8438f,
+	28.584f,
+	62.5f,
+	-85.9375f,
+	26.1183f,
+	62.5f,
+	-82.0313f,
+	23.8148f,
+	62.5f,
+	-78.125f,
+	22.0333f,
+	62.5f,
+	-74.2188f,
+	20.178f,
+	62.5f,
+	-70.3125f,
+	18.704f,
+	62.5f,
+	-66.4063f,
+	16.8036f,
+	62.5f,
+	-62.5f,
+	15.7173f,
+	62.5f,
+	-58.5938f,
+	13.9284f,
+	62.5f,
+	-54.6875f,
+	13.0731f,
+	62.5f,
+	-50.7813f,
+	11.8974f,
+	62.5f,
+	-46.875f,
+	9.91347f,
+	62.5f,
+	-42.9688f,
+	10.1439f,
+	62.5f,
+	-39.0625f,
+	11.304f,
+	62.5f,
+	-35.1563f,
+	12.5111f,
+	62.5f,
+	-31.25f,
+	14.112f,
+	62.5f,
+	-27.3438f,
+	15.3325f,
+	62.5f,
+	-23.4375f,
+	16.6214f,
+	62.5f,
+	-19.5313f,
+	17.8469f,
+	62.5f,
+	-15.625f,
+	19.2987f,
+	62.5f,
+	-11.7188f,
+	20.9518f,
+	62.5f,
+	-7.8125f,
+	23.4289f,
+	62.5f,
+	-3.90625f,
+	24.9379f,
+	62.5f,
+	0.0f,
+	26.156f,
+	62.5f,
+	3.90625f,
+	27.1929f,
+	62.5f,
+	-250.0f,
+	4.23938f,
+	58.5938f,
+	-246.094f,
+	4.819f,
+	58.5938f,
+	-242.188f,
+	4.63067f,
+	58.5938f,
+	-238.281f,
+	5.29023f,
+	58.5938f,
+	-234.375f,
+	6.48193f,
+	58.5938f,
+	-230.469f,
+	6.85856f,
+	58.5938f,
+	-226.563f,
+	8.4748f,
+	58.5938f,
+	-222.656f,
+	8.76416f,
+	58.5938f,
+	-218.75f,
+	9.24425f,
+	58.5938f,
+	-214.844f,
+	9.67654f,
+	58.5938f,
+	-210.938f,
+	10.8063f,
+	58.5938f,
+	-207.031f,
+	12.3237f,
+	58.5938f,
+	-203.125f,
+	12.7409f,
+	58.5938f,
+	-199.219f,
+	12.7587f,
+	58.5938f,
+	-195.313f,
+	14.3653f,
+	58.5938f,
+	-191.406f,
+	16.1467f,
+	58.5938f,
+	-187.5f,
+	17.0489f,
+	58.5938f,
+	-183.594f,
+	19.2091f,
+	58.5938f,
+	-179.688f,
+	21.7856f,
+	58.5938f,
+	-175.781f,
+	24.7829f,
+	58.5938f,
+	-171.875f,
+	26.2396f,
+	58.5938f,
+	-167.969f,
+	27.2756f,
+	58.5938f,
+	-164.063f,
+	28.2919f,
+	58.5938f,
+	-160.156f,
+	30.5945f,
+	58.5938f,
+	-156.25f,
+	32.2617f,
+	58.5938f,
+	-152.344f,
+	32.9049f,
+	58.5938f,
+	-148.438f,
+	32.8002f,
+	58.5938f,
+	-144.531f,
+	32.4751f,
+	58.5938f,
+	-140.625f,
+	32.4049f,
+	58.5938f,
+	-136.719f,
+	33.5631f,
+	58.5938f,
+	-132.813f,
+	33.3828f,
+	58.5938f,
+	-128.906f,
+	33.1064f,
+	58.5938f,
+	-125.0f,
+	32.3054f,
+	58.5938f,
+	-121.094f,
+	32.5047f,
+	58.5938f,
+	-117.188f,
+	32.3246f,
+	58.5938f,
+	-113.281f,
+	32.4393f,
+	58.5938f,
+	-109.375f,
+	32.553f,
+	58.5938f,
+	-105.469f,
+	32.9281f,
+	58.5938f,
+	-101.563f,
+	31.8539f,
+	58.5938f,
+	-97.6563f,
+	30.9253f,
+	58.5938f,
+	-93.75f,
+	30.4328f,
+	58.5938f,
+	-89.8438f,
+	28.3295f,
+	58.5938f,
+	-85.9375f,
+	25.5393f,
+	58.5938f,
+	-82.0313f,
+	23.0691f,
+	58.5938f,
+	-78.125f,
+	21.505f,
+	58.5938f,
+	-74.2188f,
+	21.0748f,
+	58.5938f,
+	-70.3125f,
+	19.1186f,
+	58.5938f,
+	-66.4063f,
+	16.7814f,
+	58.5938f,
+	-62.5f,
+	15.2179f,
+	58.5938f,
+	-58.5938f,
+	14.1291f,
+	58.5938f,
+	-54.6875f,
+	13.2351f,
+	58.5938f,
+	-50.7813f,
+	11.896f,
+	58.5938f,
+	-46.875f,
+	11.0911f,
+	58.5938f,
+	-42.9688f,
+	12.7485f,
+	58.5938f,
+	-39.0625f,
+	13.7045f,
+	58.5938f,
+	-35.1563f,
+	14.6128f,
+	58.5938f,
+	-31.25f,
+	15.546f,
+	58.5938f,
+	-27.3438f,
+	16.7828f,
+	58.5938f,
+	-23.4375f,
+	18.7578f,
+	58.5938f,
+	-19.5313f,
+	19.7951f,
+	58.5938f,
+	-15.625f,
+	21.8594f,
+	58.5938f,
+	-11.7188f,
+	22.7269f,
+	58.5938f,
+	-7.8125f,
+	24.983f,
+	58.5938f,
+	-3.90625f,
+	26.43f,
+	58.5938f,
+	0.0f,
+	27.4466f,
+	58.5938f,
+	3.90625f,
+	28.3495f,
+	58.5938f,
+	-250.0f,
+	3.62748f,
+	54.6875f,
+	-246.094f,
+	3.83329f,
+	54.6875f,
+	-242.188f,
+	4.44022f,
+	54.6875f,
+	-238.281f,
+	5.27514f,
+	54.6875f,
+	-234.375f,
+	7.43995f,
+	54.6875f,
+	-230.469f,
+	7.59176f,
+	54.6875f,
+	-226.563f,
+	8.28985f,
+	54.6875f,
+	-222.656f,
+	9.62184f,
+	54.6875f,
+	-218.75f,
+	10.6613f,
+	54.6875f,
+	-214.844f,
+	11.0914f,
+	54.6875f,
+	-210.938f,
+	12.2186f,
+	54.6875f,
+	-207.031f,
+	13.1985f,
+	54.6875f,
+	-203.125f,
+	13.9982f,
+	54.6875f,
+	-199.219f,
+	14.3187f,
+	54.6875f,
+	-195.313f,
+	14.8791f,
+	54.6875f,
+	-191.406f,
+	16.5829f,
+	54.6875f,
+	-187.5f,
+	18.231f,
+	54.6875f,
+	-183.594f,
+	20.0621f,
+	54.6875f,
+	-179.688f,
+	22.8941f,
+	54.6875f,
+	-175.781f,
+	25.0841f,
+	54.6875f,
+	-171.875f,
+	26.5655f,
+	54.6875f,
+	-167.969f,
+	27.3542f,
+	54.6875f,
+	-164.063f,
+	29.2247f,
+	54.6875f,
+	-160.156f,
+	30.91f,
+	54.6875f,
+	-156.25f,
+	33.3376f,
+	54.6875f,
+	-152.344f,
+	32.8808f,
+	54.6875f,
+	-148.438f,
+	32.5783f,
+	54.6875f,
+	-144.531f,
+	32.6138f,
+	54.6875f,
+	-140.625f,
+	32.9002f,
+	54.6875f,
+	-136.719f,
+	34.2312f,
+	54.6875f,
+	-132.813f,
+	33.8335f,
+	54.6875f,
+	-128.906f,
+	32.8545f,
+	54.6875f,
+	-125.0f,
+	33.6683f,
+	54.6875f,
+	-121.094f,
+	32.9953f,
+	54.6875f,
+	-117.188f,
+	32.5096f,
+	54.6875f,
+	-113.281f,
+	32.4307f,
+	54.6875f,
+	-109.375f,
+	31.8214f,
+	54.6875f,
+	-105.469f,
+	31.851f,
+	54.6875f,
+	-101.563f,
+	31.6383f,
+	54.6875f,
+	-97.6563f,
+	30.4359f,
+	54.6875f,
+	-93.75f,
+	28.9306f,
+	54.6875f,
+	-89.8438f,
+	26.5955f,
+	54.6875f,
+	-85.9375f,
+	24.7234f,
+	54.6875f,
+	-82.0313f,
+	23.0595f,
+	54.6875f,
+	-78.125f,
+	21.3558f,
+	54.6875f,
+	-74.2188f,
+	20.3788f,
+	54.6875f,
+	-70.3125f,
+	19.3201f,
+	54.6875f,
+	-66.4063f,
+	16.9597f,
+	54.6875f,
+	-62.5f,
+	14.6652f,
+	54.6875f,
+	-58.5938f,
+	14.4899f,
+	54.6875f,
+	-54.6875f,
+	13.3432f,
+	54.6875f,
+	-50.7813f,
+	12.3286f,
+	54.6875f,
+	-46.875f,
+	12.6498f,
+	54.6875f,
+	-42.9688f,
+	14.2651f,
+	54.6875f,
+	-39.0625f,
+	15.6887f,
+	54.6875f,
+	-35.1563f,
+	16.2038f,
+	54.6875f,
+	-31.25f,
+	17.2337f,
+	54.6875f,
+	-27.3438f,
+	18.7628f,
+	54.6875f,
+	-23.4375f,
+	20.2472f,
+	54.6875f,
+	-19.5313f,
+	21.6809f,
+	54.6875f,
+	-15.625f,
+	24.084f,
+	54.6875f,
+	-11.7188f,
+	25.1582f,
+	54.6875f,
+	-7.8125f,
+	26.7f,
+	54.6875f,
+	-3.90625f,
+	27.5421f,
+	54.6875f,
+	0.0f,
+	28.3244f,
+	54.6875f,
+	3.90625f,
+	29.2057f,
+	54.6875f,
+	-250.0f,
+	3.74657f,
+	50.7813f,
+	-246.094f,
+	3.89172f,
+	50.7813f,
+	-242.188f,
+	4.12295f,
+	50.7813f,
+	-238.281f,
+	5.16915f,
+	50.7813f,
+	-234.375f,
+	6.30394f,
+	50.7813f,
+	-230.469f,
+	7.21975f,
+	50.7813f,
+	-226.563f,
+	8.61249f,
+	50.7813f,
+	-222.656f,
+	10.1295f,
+	50.7813f,
+	-218.75f,
+	12.2813f,
+	50.7813f,
+	-214.844f,
+	12.3309f,
+	50.7813f,
+	-210.938f,
+	13.3907f,
+	50.7813f,
+	-207.031f,
+	14.1528f,
+	50.7813f,
+	-203.125f,
+	14.0334f,
+	50.7813f,
+	-199.219f,
+	14.814f,
+	50.7813f,
+	-195.313f,
+	16.69f,
+	50.7813f,
+	-191.406f,
+	17.639f,
+	50.7813f,
+	-187.5f,
+	19.261f,
+	50.7813f,
+	-183.594f,
+	20.748f,
+	50.7813f,
+	-179.688f,
+	23.3343f,
+	50.7813f,
+	-175.781f,
+	25.4837f,
+	50.7813f,
+	-171.875f,
+	26.8456f,
+	50.7813f,
+	-167.969f,
+	27.7788f,
+	50.7813f,
+	-164.063f,
+	30.0174f,
+	50.7813f,
+	-160.156f,
+	31.0689f,
+	50.7813f,
+	-156.25f,
+	32.5898f,
+	50.7813f,
+	-152.344f,
+	32.5672f,
+	50.7813f,
+	-148.438f,
+	32.4654f,
+	50.7813f,
+	-144.531f,
+	33.702f,
+	50.7813f,
+	-140.625f,
+	34.7593f,
+	50.7813f,
+	-136.719f,
+	33.9086f,
+	50.7813f,
+	-132.813f,
+	33.681f,
+	50.7813f,
+	-128.906f,
+	33.6369f,
+	50.7813f,
+	-125.0f,
+	34.0371f,
+	50.7813f,
+	-121.094f,
+	34.0479f,
+	50.7813f,
+	-117.188f,
+	34.513f,
+	50.7813f,
+	-113.281f,
+	33.7072f,
+	50.7813f,
+	-109.375f,
+	32.2763f,
+	50.7813f,
+	-105.469f,
+	32.0608f,
+	50.7813f,
+	-101.563f,
+	31.0833f,
+	50.7813f,
+	-97.6563f,
+	29.9168f,
+	50.7813f,
+	-93.75f,
+	28.7604f,
+	50.7813f,
+	-89.8438f,
+	26.9563f,
+	50.7813f,
+	-85.9375f,
+	24.7908f,
+	50.7813f,
+	-82.0313f,
+	23.7925f,
+	50.7813f,
+	-78.125f,
+	21.7037f,
+	50.7813f,
+	-74.2188f,
+	19.5308f,
+	50.7813f,
+	-70.3125f,
+	19.3367f,
+	50.7813f,
+	-66.4063f,
+	17.8482f,
+	50.7813f,
+	-62.5f,
+	14.2491f,
+	50.7813f,
+	-58.5938f,
+	14.7414f,
+	50.7813f,
+	-54.6875f,
+	14.0395f,
+	50.7813f,
+	-50.7813f,
+	12.9738f,
+	50.7813f,
+	-46.875f,
+	13.9471f,
+	50.7813f,
+	-42.9688f,
+	15.8319f,
+	50.7813f,
+	-39.0625f,
+	16.6566f,
+	50.7813f,
+	-35.1563f,
+	17.1252f,
+	50.7813f,
+	-31.25f,
+	18.6998f,
+	50.7813f,
+	-27.3438f,
+	20.877f,
+	50.7813f,
+	-23.4375f,
+	22.0249f,
+	50.7813f,
+	-19.5313f,
+	22.9369f,
+	50.7813f,
+	-15.625f,
+	25.686f,
+	50.7813f,
+	-11.7188f,
+	26.1758f,
+	50.7813f,
+	-7.8125f,
+	28.3828f,
+	50.7813f,
+	-3.90625f,
+	28.7973f,
+	50.7813f,
+	0.0f,
+	29.7276f,
+	50.7813f,
+	3.90625f,
+	30.4306f,
+	50.7813f,
+	-250.0f,
+	3.69244f,
+	46.875f,
+	-246.094f,
+	3.88583f,
+	46.875f,
+	-242.188f,
+	3.98468f,
+	46.875f,
+	-238.281f,
+	5.01772f,
+	46.875f,
+	-234.375f,
+	7.23791f,
+	46.875f,
+	-230.469f,
+	7.78117f,
+	46.875f,
+	-226.563f,
+	8.55298f,
+	46.875f,
+	-222.656f,
+	10.2684f,
+	46.875f,
+	-218.75f,
+	11.1917f,
+	46.875f,
+	-214.844f,
+	12.411f,
+	46.875f,
+	-210.938f,
+	13.7214f,
+	46.875f,
+	-207.031f,
+	14.4662f,
+	46.875f,
+	-203.125f,
+	15.536f,
+	46.875f,
+	-199.219f,
+	15.6035f,
+	46.875f,
+	-195.313f,
+	16.8456f,
+	46.875f,
+	-191.406f,
+	18.4656f,
+	46.875f,
+	-187.5f,
+	19.415f,
+	46.875f,
+	-183.594f,
+	20.8504f,
+	46.875f,
+	-179.688f,
+	23.9388f,
+	46.875f,
+	-175.781f,
+	26.2956f,
+	46.875f,
+	-171.875f,
+	27.6728f,
+	46.875f,
+	-167.969f,
+	28.2497f,
+	46.875f,
+	-164.063f,
+	29.6503f,
+	46.875f,
+	-160.156f,
+	31.9344f,
+	46.875f,
+	-156.25f,
+	33.4163f,
+	46.875f,
+	-152.344f,
+	33.428f,
+	46.875f,
+	-148.438f,
+	33.3157f,
+	46.875f,
+	-144.531f,
+	33.6261f,
+	46.875f,
+	-140.625f,
+	35.1888f,
+	46.875f,
+	-136.719f,
+	34.8434f,
+	46.875f,
+	-132.813f,
+	34.1219f,
+	46.875f,
+	-128.906f,
+	34.4564f,
+	46.875f,
+	-125.0f,
+	34.9729f,
+	46.875f,
+	-121.094f,
+	34.8811f,
+	46.875f,
+	-117.188f,
+	35.185f,
+	46.875f,
+	-113.281f,
+	34.138f,
+	46.875f,
+	-109.375f,
+	32.7077f,
+	46.875f,
+	-105.469f,
+	32.2219f,
+	46.875f,
+	-101.563f,
+	31.2475f,
+	46.875f,
+	-97.6563f,
+	29.9637f,
+	46.875f,
+	-93.75f,
+	28.1214f,
+	46.875f,
+	-89.8438f,
+	27.0889f,
+	46.875f,
+	-85.9375f,
+	25.092f,
+	46.875f,
+	-82.0313f,
+	23.3983f,
+	46.875f,
+	-78.125f,
+	22.275f,
+	46.875f,
+	-74.2188f,
+	19.8598f,
+	46.875f,
+	-70.3125f,
+	18.8797f,
+	46.875f,
+	-66.4063f,
+	17.2468f,
+	46.875f,
+	-62.5f,
+	15.4985f,
+	46.875f,
+	-58.5938f,
+	14.5357f,
+	46.875f,
+	-54.6875f,
+	14.6964f,
+	46.875f,
+	-50.7813f,
+	13.3496f,
+	46.875f,
+	-46.875f,
+	15.6354f,
+	46.875f,
+	-42.9688f,
+	16.7177f,
+	46.875f,
+	-39.0625f,
+	17.4527f,
+	46.875f,
+	-35.1563f,
+	18.2826f,
+	46.875f,
+	-31.25f,
+	20.3293f,
+	46.875f,
+	-27.3438f,
+	22.684f,
+	46.875f,
+	-23.4375f,
+	23.538f,
+	46.875f,
+	-19.5313f,
+	24.3046f,
+	46.875f,
+	-15.625f,
+	26.1113f,
+	46.875f,
+	-11.7188f,
+	27.4881f,
+	46.875f,
+	-7.8125f,
+	29.3572f,
+	46.875f,
+	-3.90625f,
+	29.786f,
+	46.875f,
+	0.0f,
+	30.3637f,
+	46.875f,
+	3.90625f,
+	30.8772f,
+	46.875f,
+	-250.0f,
+	4.08083f,
+	42.9688f,
+	-246.094f,
+	4.09778f,
+	42.9688f,
+	-242.188f,
+	3.87631f,
+	42.9688f,
+	-238.281f,
+	5.12214f,
+	42.9688f,
+	-234.375f,
+	6.70993f,
+	42.9688f,
+	-230.469f,
+	7.75806f,
+	42.9688f,
+	-226.563f,
+	8.13676f,
+	42.9688f,
+	-222.656f,
+	8.85151f,
+	42.9688f,
+	-218.75f,
+	10.9378f,
+	42.9688f,
+	-214.844f,
+	12.4043f,
+	42.9688f,
+	-210.938f,
+	13.4636f,
+	42.9688f,
+	-207.031f,
+	14.7352f,
+	42.9688f,
+	-203.125f,
+	15.605f,
+	42.9688f,
+	-199.219f,
+	15.7497f,
+	42.9688f,
+	-195.313f,
+	17.184f,
+	42.9688f,
+	-191.406f,
+	19.3679f,
+	42.9688f,
+	-187.5f,
+	21.1701f,
+	42.9688f,
+	-183.594f,
+	22.7204f,
+	42.9688f,
+	-179.688f,
+	24.8128f,
+	42.9688f,
+	-175.781f,
+	26.7707f,
+	42.9688f,
+	-171.875f,
+	27.7521f,
+	42.9688f,
+	-167.969f,
+	28.8689f,
+	42.9688f,
+	-164.063f,
+	31.1205f,
+	42.9688f,
+	-160.156f,
+	33.289f,
+	42.9688f,
+	-156.25f,
+	34.2815f,
+	42.9688f,
+	-152.344f,
+	33.9797f,
+	42.9688f,
+	-148.438f,
+	34.2527f,
+	42.9688f,
+	-144.531f,
+	34.1886f,
+	42.9688f,
+	-140.625f,
+	34.868f,
+	42.9688f,
+	-136.719f,
+	35.6569f,
+	42.9688f,
+	-132.813f,
+	35.4999f,
+	42.9688f,
+	-128.906f,
+	35.4373f,
+	42.9688f,
+	-125.0f,
+	36.373f,
+	42.9688f,
+	-121.094f,
+	35.4304f,
+	42.9688f,
+	-117.188f,
+	34.3543f,
+	42.9688f,
+	-113.281f,
+	35.0651f,
+	42.9688f,
+	-109.375f,
+	33.5051f,
+	42.9688f,
+	-105.469f,
+	32.471f,
+	42.9688f,
+	-101.563f,
+	31.2764f,
+	42.9688f,
+	-97.6563f,
+	29.7633f,
+	42.9688f,
+	-93.75f,
+	27.9107f,
+	42.9688f,
+	-89.8438f,
+	26.5273f,
+	42.9688f,
+	-85.9375f,
+	25.2444f,
+	42.9688f,
+	-82.0313f,
+	23.6093f,
+	42.9688f,
+	-78.125f,
+	21.9684f,
+	42.9688f,
+	-74.2188f,
+	19.4992f,
+	42.9688f,
+	-70.3125f,
+	17.8231f,
+	42.9688f,
+	-66.4063f,
+	17.4082f,
+	42.9688f,
+	-62.5f,
+	17.0938f,
+	42.9688f,
+	-58.5938f,
+	15.3348f,
+	42.9688f,
+	-54.6875f,
+	14.7964f,
+	42.9688f,
+	-50.7813f,
+	14.9948f,
+	42.9688f,
+	-46.875f,
+	17.1807f,
+	42.9688f,
+	-42.9688f,
+	18.118f,
+	42.9688f,
+	-39.0625f,
+	19.0809f,
+	42.9688f,
+	-35.1563f,
+	19.6971f,
+	42.9688f,
+	-31.25f,
+	21.652f,
+	42.9688f,
+	-27.3438f,
+	23.4343f,
+	42.9688f,
+	-23.4375f,
+	24.5708f,
+	42.9688f,
+	-19.5313f,
+	25.2003f,
+	42.9688f,
+	-15.625f,
+	26.8391f,
+	42.9688f,
+	-11.7188f,
+	28.9343f,
+	42.9688f,
+	-7.8125f,
+	29.9079f,
+	42.9688f,
+	-3.90625f,
+	31.268f,
+	42.9688f,
+	0.0f,
+	31.3916f,
+	42.9688f,
+	3.90625f,
+	31.8945f,
+	42.9688f,
+	-250.0f,
+	4.27976f,
+	39.0625f,
+	-246.094f,
+	4.20341f,
+	39.0625f,
+	-242.188f,
+	3.80298f,
+	39.0625f,
+	-238.281f,
+	4.79243f,
+	39.0625f,
+	-234.375f,
+	5.51846f,
+	39.0625f,
+	-230.469f,
+	6.91597f,
+	39.0625f,
+	-226.563f,
+	8.25726f,
+	39.0625f,
+	-222.656f,
+	8.85037f,
+	39.0625f,
+	-218.75f,
+	9.57429f,
+	39.0625f,
+	-214.844f,
+	11.3899f,
+	39.0625f,
+	-210.938f,
+	12.5806f,
+	39.0625f,
+	-207.031f,
+	14.2509f,
+	39.0625f,
+	-203.125f,
+	14.7828f,
+	39.0625f,
+	-199.219f,
+	15.9801f,
+	39.0625f,
+	-195.313f,
+	17.4225f,
+	39.0625f,
+	-191.406f,
+	19.6018f,
+	39.0625f,
+	-187.5f,
+	22.1095f,
+	39.0625f,
+	-183.594f,
+	23.8333f,
+	39.0625f,
+	-179.688f,
+	25.0671f,
+	39.0625f,
+	-175.781f,
+	27.1067f,
+	39.0625f,
+	-171.875f,
+	28.5f,
+	39.0625f,
+	-167.969f,
+	29.9625f,
+	39.0625f,
+	-164.063f,
+	32.3895f,
+	39.0625f,
+	-160.156f,
+	33.8224f,
+	39.0625f,
+	-156.25f,
+	34.3349f,
+	39.0625f,
+	-152.344f,
+	34.4661f,
+	39.0625f,
+	-148.438f,
+	34.7236f,
+	39.0625f,
+	-144.531f,
+	34.1129f,
+	39.0625f,
+	-140.625f,
+	34.9033f,
+	39.0625f,
+	-136.719f,
+	35.6229f,
+	39.0625f,
+	-132.813f,
+	35.7143f,
+	39.0625f,
+	-128.906f,
+	36.7151f,
+	39.0625f,
+	-125.0f,
+	36.9574f,
+	39.0625f,
+	-121.094f,
+	36.0729f,
+	39.0625f,
+	-117.188f,
+	35.2171f,
+	39.0625f,
+	-113.281f,
+	34.9343f,
+	39.0625f,
+	-109.375f,
+	34.5707f,
+	39.0625f,
+	-105.469f,
+	33.5046f,
+	39.0625f,
+	-101.563f,
+	31.353f,
+	39.0625f,
+	-97.6563f,
+	30.0283f,
+	39.0625f,
+	-93.75f,
+	28.6272f,
+	39.0625f,
+	-89.8438f,
+	26.4389f,
+	39.0625f,
+	-85.9375f,
+	24.8159f,
+	39.0625f,
+	-82.0313f,
+	23.0295f,
+	39.0625f,
+	-78.125f,
+	21.1082f,
+	39.0625f,
+	-74.2188f,
+	19.1239f,
+	39.0625f,
+	-70.3125f,
+	18.0914f,
+	39.0625f,
+	-66.4063f,
+	17.3227f,
+	39.0625f,
+	-62.5f,
+	17.1022f,
+	39.0625f,
+	-58.5938f,
+	16.4298f,
+	39.0625f,
+	-54.6875f,
+	15.6704f,
+	39.0625f,
+	-50.7813f,
+	16.5664f,
+	39.0625f,
+	-46.875f,
+	18.478f,
+	39.0625f,
+	-42.9688f,
+	19.4144f,
+	39.0625f,
+	-39.0625f,
+	19.9351f,
+	39.0625f,
+	-35.1563f,
+	20.3447f,
+	39.0625f,
+	-31.25f,
+	22.4348f,
+	39.0625f,
+	-27.3438f,
+	24.5713f,
+	39.0625f,
+	-23.4375f,
+	25.5465f,
+	39.0625f,
+	-19.5313f,
+	26.485f,
+	39.0625f,
+	-15.625f,
+	28.292f,
+	39.0625f,
+	-11.7188f,
+	30.0016f,
+	39.0625f,
+	-7.8125f,
+	32.2532f,
+	39.0625f,
+	-3.90625f,
+	33.6327f,
+	39.0625f,
+	0.0f,
+	33.835f,
+	39.0625f,
+	3.90625f,
+	34.9171f,
+	39.0625f,
+	-250.0f,
+	3.91889f,
+	35.1563f,
+	-246.094f,
+	3.38127f,
+	35.1563f,
+	-242.188f,
+	3.26935f,
+	35.1563f,
+	-238.281f,
+	4.06778f,
+	35.1563f,
+	-234.375f,
+	4.87411f,
+	35.1563f,
+	-230.469f,
+	6.48873f,
+	35.1563f,
+	-226.563f,
+	7.17326f,
+	35.1563f,
+	-222.656f,
+	8.21235f,
+	35.1563f,
+	-218.75f,
+	8.21965f,
+	35.1563f,
+	-214.844f,
+	10.417f,
+	35.1563f,
+	-210.938f,
+	11.9497f,
+	35.1563f,
+	-207.031f,
+	13.4145f,
+	35.1563f,
+	-203.125f,
+	14.0876f,
+	35.1563f,
+	-199.219f,
+	15.5077f,
+	35.1563f,
+	-195.313f,
+	16.9011f,
+	35.1563f,
+	-191.406f,
+	20.4395f,
+	35.1563f,
+	-187.5f,
+	23.001f,
+	35.1563f,
+	-183.594f,
+	24.0199f,
+	35.1563f,
+	-179.688f,
+	25.7082f,
+	35.1563f,
+	-175.781f,
+	27.3018f,
+	35.1563f,
+	-171.875f,
+	28.9584f,
+	35.1563f,
+	-167.969f,
+	31.1478f,
+	35.1563f,
+	-164.063f,
+	32.8635f,
+	35.1563f,
+	-160.156f,
+	33.5517f,
+	35.1563f,
+	-156.25f,
+	34.5761f,
+	35.1563f,
+	-152.344f,
+	34.5761f,
+	35.1563f,
+	-148.438f,
+	34.2002f,
+	35.1563f,
+	-144.531f,
+	34.7177f,
+	35.1563f,
+	-140.625f,
+	35.5653f,
+	35.1563f,
+	-136.719f,
+	35.7993f,
+	35.1563f,
+	-132.813f,
+	37.1127f,
+	35.1563f,
+	-128.906f,
+	37.2477f,
+	35.1563f,
+	-125.0f,
+	36.8734f,
+	35.1563f,
+	-121.094f,
+	35.4154f,
+	35.1563f,
+	-117.188f,
+	34.8545f,
+	35.1563f,
+	-113.281f,
+	35.4317f,
+	35.1563f,
+	-109.375f,
+	34.9205f,
+	35.1563f,
+	-105.469f,
+	33.5115f,
+	35.1563f,
+	-101.563f,
+	32.2368f,
+	35.1563f,
+	-97.6563f,
+	30.3601f,
+	35.1563f,
+	-93.75f,
+	29.2913f,
+	35.1563f,
+	-89.8438f,
+	27.4791f,
+	35.1563f,
+	-85.9375f,
+	24.811f,
+	35.1563f,
+	-82.0313f,
+	23.4984f,
+	35.1563f,
+	-78.125f,
+	21.456f,
+	35.1563f,
+	-74.2188f,
+	19.8992f,
+	35.1563f,
+	-70.3125f,
+	17.7354f,
+	35.1563f,
+	-66.4063f,
+	17.3066f,
+	35.1563f,
+	-62.5f,
+	17.1745f,
+	35.1563f,
+	-58.5938f,
+	16.5285f,
+	35.1563f,
+	-54.6875f,
+	17.2826f,
+	35.1563f,
+	-50.7813f,
+	18.6936f,
+	35.1563f,
+	-46.875f,
+	19.4228f,
+	35.1563f,
+	-42.9688f,
+	20.2022f,
+	35.1563f,
+	-39.0625f,
+	21.4261f,
+	35.1563f,
+	-35.1563f,
+	21.5779f,
+	35.1563f,
+	-31.25f,
+	24.0097f,
+	35.1563f,
+	-27.3438f,
+	25.4481f,
+	35.1563f,
+	-23.4375f,
+	26.0036f,
+	35.1563f,
+	-19.5313f,
+	27.4346f,
+	35.1563f,
+	-15.625f,
+	30.2459f,
+	35.1563f,
+	-11.7188f,
+	32.81f,
+	35.1563f,
+	-7.8125f,
+	34.7924f,
+	35.1563f,
+	-3.90625f,
+	35.8907f,
+	35.1563f,
+	0.0f,
+	36.9755f,
+	35.1563f,
+	3.90625f,
+	38.5427f,
+	35.1563f,
+	-250.0f,
+	2.28536f,
+	31.25f,
+	-246.094f,
+	1.63842f,
+	31.25f,
+	-242.188f,
+	2.40273f,
+	31.25f,
+	-238.281f,
+	3.19518f,
+	31.25f,
+	-234.375f,
+	3.99394f,
+	31.25f,
+	-230.469f,
+	4.99674f,
+	31.25f,
+	-226.563f,
+	5.63235f,
+	31.25f,
+	-222.656f,
+	6.86331f,
+	31.25f,
+	-218.75f,
+	7.37515f,
+	31.25f,
+	-214.844f,
+	9.34737f,
+	31.25f,
+	-210.938f,
+	11.7034f,
+	31.25f,
+	-207.031f,
+	13.4309f,
+	31.25f,
+	-203.125f,
+	14.4474f,
+	31.25f,
+	-199.219f,
+	15.8817f,
+	31.25f,
+	-195.313f,
+	17.87f,
+	31.25f,
+	-191.406f,
+	20.9938f,
+	31.25f,
+	-187.5f,
+	23.5333f,
+	31.25f,
+	-183.594f,
+	24.4107f,
+	31.25f,
+	-179.688f,
+	26.0811f,
+	31.25f,
+	-175.781f,
+	27.9797f,
+	31.25f,
+	-171.875f,
+	29.4813f,
+	31.25f,
+	-167.969f,
+	31.7071f,
+	31.25f,
+	-164.063f,
+	33.0836f,
+	31.25f,
+	-160.156f,
+	33.5998f,
+	31.25f,
+	-156.25f,
+	33.5304f,
+	31.25f,
+	-152.344f,
+	33.9929f,
+	31.25f,
+	-148.438f,
+	35.4297f,
+	31.25f,
+	-144.531f,
+	36.4531f,
+	31.25f,
+	-140.625f,
+	35.9197f,
+	31.25f,
+	-136.719f,
+	36.6849f,
+	31.25f,
+	-132.813f,
+	37.8161f,
+	31.25f,
+	-128.906f,
+	37.6166f,
+	31.25f,
+	-125.0f,
+	36.9426f,
+	31.25f,
+	-121.094f,
+	35.6388f,
+	31.25f,
+	-117.188f,
+	35.0026f,
+	31.25f,
+	-113.281f,
+	35.386f,
+	31.25f,
+	-109.375f,
+	34.6287f,
+	31.25f,
+	-105.469f,
+	33.8962f,
+	31.25f,
+	-101.563f,
+	32.1844f,
+	31.25f,
+	-97.6563f,
+	30.7868f,
+	31.25f,
+	-93.75f,
+	29.267f,
+	31.25f,
+	-89.8438f,
+	27.2585f,
+	31.25f,
+	-85.9375f,
+	25.4236f,
+	31.25f,
+	-82.0313f,
+	23.0281f,
+	31.25f,
+	-78.125f,
+	21.4593f,
+	31.25f,
+	-74.2188f,
+	19.4556f,
+	31.25f,
+	-70.3125f,
+	18.0982f,
+	31.25f,
+	-66.4063f,
+	17.1214f,
+	31.25f,
+	-62.5f,
+	17.1751f,
+	31.25f,
+	-58.5938f,
+	17.1429f,
+	31.25f,
+	-54.6875f,
+	18.4434f,
+	31.25f,
+	-50.7813f,
+	19.9422f,
+	31.25f,
+	-46.875f,
+	21.2124f,
+	31.25f,
+	-42.9688f,
+	21.2106f,
+	31.25f,
+	-39.0625f,
+	22.1346f,
+	31.25f,
+	-35.1563f,
+	23.3082f,
+	31.25f,
+	-31.25f,
+	24.7044f,
+	31.25f,
+	-27.3438f,
+	26.2688f,
+	31.25f,
+	-23.4375f,
+	27.5692f,
+	31.25f,
+	-19.5313f,
+	30.4099f,
+	31.25f,
+	-15.625f,
+	33.0453f,
+	31.25f,
+	-11.7188f,
+	34.9857f,
+	31.25f,
+	-7.8125f,
+	37.0727f,
+	31.25f,
+	-3.90625f,
+	39.2219f,
+	31.25f,
+	0.0f,
+	40.3658f,
+	31.25f,
+	3.90625f,
+	41.4381f,
+	31.25f,
+	-250.0f,
+	0.4773f,
+	27.3438f,
+	-246.094f,
+	0.631847f,
+	27.3438f,
+	-242.188f,
+	1.21449f,
+	27.3438f,
+	-238.281f,
+	1.52728f,
+	27.3438f,
+	-234.375f,
+	2.73146f,
+	27.3438f,
+	-230.469f,
+	3.65375f,
+	27.3438f,
+	-226.563f,
+	5.03467f,
+	27.3438f,
+	-222.656f,
+	6.27065f,
+	27.3438f,
+	-218.75f,
+	7.56964f,
+	27.3438f,
+	-214.844f,
+	9.63719f,
+	27.3438f,
+	-210.938f,
+	11.4022f,
+	27.3438f,
+	-207.031f,
+	12.7085f,
+	27.3438f,
+	-203.125f,
+	14.3808f,
+	27.3438f,
+	-199.219f,
+	15.9121f,
+	27.3438f,
+	-195.313f,
+	17.8953f,
+	27.3438f,
+	-191.406f,
+	20.8456f,
+	27.3438f,
+	-187.5f,
+	22.7705f,
+	27.3438f,
+	-183.594f,
+	24.5794f,
+	27.3437f,
+	-179.688f,
+	27.055f,
+	27.3438f,
+	-175.781f,
+	29.3548f,
+	27.3437f,
+	-171.875f,
+	30.4534f,
+	27.3438f,
+	-167.969f,
+	32.4366f,
+	27.3437f,
+	-164.063f,
+	34.4967f,
+	27.3438f,
+	-160.156f,
+	34.9614f,
+	27.3437f,
+	-156.25f,
+	34.9405f,
+	27.3438f,
+	-152.344f,
+	35.7165f,
+	27.3437f,
+	-148.438f,
+	37.0387f,
+	27.3438f,
+	-144.531f,
+	38.0934f,
+	27.3437f,
+	-140.625f,
+	37.3872f,
+	27.3438f,
+	-136.719f,
+	36.4336f,
+	27.3437f,
+	-132.813f,
+	37.0365f,
+	27.3438f,
+	-128.906f,
+	37.2591f,
+	27.3437f,
+	-125.0f,
+	36.5502f,
+	27.3438f,
+	-121.094f,
+	35.4814f,
+	27.3437f,
+	-117.188f,
+	35.3267f,
+	27.3438f,
+	-113.281f,
+	34.3757f,
+	27.3437f,
+	-109.375f,
+	34.2455f,
+	27.3438f,
+	-105.469f,
+	33.6851f,
+	27.3437f,
+	-101.563f,
+	32.3527f,
+	27.3438f,
+	-97.6563f,
+	30.111f,
+	27.3437f,
+	-93.75f,
+	28.4912f,
+	27.3438f,
+	-89.8438f,
+	27.0398f,
+	27.3437f,
+	-85.9375f,
+	24.9699f,
+	27.3438f,
+	-82.0313f,
+	22.9703f,
+	27.3437f,
+	-78.125f,
+	21.7502f,
+	27.3438f,
+	-74.2188f,
+	18.8537f,
+	27.3438f,
+	-70.3125f,
+	18.2353f,
+	27.3438f,
+	-66.4063f,
+	18.3708f,
+	27.3438f,
+	-62.5f,
+	18.6738f,
+	27.3438f,
+	-58.5938f,
+	18.5559f,
+	27.3438f,
+	-54.6875f,
+	19.1603f,
+	27.3438f,
+	-50.7813f,
+	20.8349f,
+	27.3438f,
+	-46.875f,
+	21.6092f,
+	27.3438f,
+	-42.9688f,
+	21.9317f,
+	27.3437f,
+	-39.0625f,
+	23.0486f,
+	27.3438f,
+	-35.1563f,
+	24.8675f,
+	27.3437f,
+	-31.25f,
+	25.6906f,
+	27.3438f,
+	-27.3438f,
+	27.9695f,
+	27.3437f,
+	-23.4375f,
+	30.3105f,
+	27.3438f,
+	-19.5313f,
+	33.9897f,
+	27.3437f,
+	-15.625f,
+	35.6988f,
+	27.3438f,
+	-11.7188f,
+	37.9213f,
+	27.3437f,
+	-7.8125f,
+	40.1355f,
+	27.3438f,
+	-3.90625f,
+	41.6062f,
+	27.3437f,
+	0.0f,
+	42.273f,
+	27.3438f,
+	3.90625f,
+	42.7334f,
+	27.3437f,
+	-250.0f,
+	0.178144f,
+	23.4375f,
+	-246.094f,
+	1.07943f,
+	23.4375f,
+	-242.188f,
+	1.52473f,
+	23.4375f,
+	-238.281f,
+	2.58652f,
+	23.4375f,
+	-234.375f,
+	3.51451f,
+	23.4375f,
+	-230.469f,
+	4.23103f,
+	23.4375f,
+	-226.563f,
+	5.80506f,
+	23.4375f,
+	-222.656f,
+	7.26086f,
+	23.4375f,
+	-218.75f,
+	8.85201f,
+	23.4375f,
+	-214.844f,
+	10.9029f,
+	23.4375f,
+	-210.938f,
+	12.7138f,
+	23.4375f,
+	-207.031f,
+	14.9249f,
+	23.4375f,
+	-203.125f,
+	15.6506f,
+	23.4375f,
+	-199.219f,
+	16.529f,
+	23.4375f,
+	-195.313f,
+	17.1535f,
+	23.4375f,
+	-191.406f,
+	20.5632f,
+	23.4375f,
+	-187.5f,
+	23.1009f,
+	23.4375f,
+	-183.594f,
+	24.7859f,
+	23.4375f,
+	-179.688f,
+	26.8635f,
+	23.4375f,
+	-175.781f,
+	28.5723f,
+	23.4375f,
+	-171.875f,
+	30.2918f,
+	23.4375f,
+	-167.969f,
+	32.7768f,
+	23.4375f,
+	-164.063f,
+	34.6199f,
+	23.4375f,
+	-160.156f,
+	35.6902f,
+	23.4375f,
+	-156.25f,
+	37.1166f,
+	23.4375f,
+	-152.344f,
+	37.0816f,
+	23.4375f,
+	-148.438f,
+	37.9995f,
+	23.4375f,
+	-144.531f,
+	38.687f,
+	23.4375f,
+	-140.625f,
+	37.9261f,
+	23.4375f,
+	-136.719f,
+	36.7476f,
+	23.4375f,
+	-132.813f,
+	37.1839f,
+	23.4375f,
+	-128.906f,
+	36.8682f,
+	23.4375f,
+	-125.0f,
+	36.2555f,
+	23.4375f,
+	-121.094f,
+	34.8461f,
+	23.4375f,
+	-117.188f,
+	34.5757f,
+	23.4375f,
+	-113.281f,
+	33.8965f,
+	23.4375f,
+	-109.375f,
+	33.4987f,
+	23.4375f,
+	-105.469f,
+	33.02f,
+	23.4375f,
+	-101.563f,
+	31.4543f,
+	23.4375f,
+	-97.6563f,
+	29.5899f,
+	23.4375f,
+	-93.75f,
+	27.8808f,
+	23.4375f,
+	-89.8438f,
+	26.4886f,
+	23.4375f,
+	-85.9375f,
+	24.5413f,
+	23.4375f,
+	-82.0313f,
+	22.6097f,
+	23.4375f,
+	-78.125f,
+	21.38f,
+	23.4375f,
+	-74.2188f,
+	19.2574f,
+	23.4375f,
+	-70.3125f,
+	19.6862f,
+	23.4375f,
+	-66.4063f,
+	19.3283f,
+	23.4375f,
+	-62.5f,
+	20.3608f,
+	23.4375f,
+	-58.5938f,
+	20.9969f,
+	23.4375f,
+	-54.6875f,
+	20.5645f,
+	23.4375f,
+	-50.7813f,
+	21.6338f,
+	23.4375f,
+	-46.875f,
+	22.0705f,
+	23.4375f,
+	-42.9688f,
+	23.2924f,
+	23.4375f,
+	-39.0625f,
+	24.8627f,
+	23.4375f,
+	-35.1563f,
+	25.9292f,
+	23.4375f,
+	-31.25f,
+	27.2133f,
+	23.4375f,
+	-27.3438f,
+	29.7296f,
+	23.4375f,
+	-23.4375f,
+	32.8149f,
+	23.4375f,
+	-19.5313f,
+	35.5321f,
+	23.4375f,
+	-15.625f,
+	38.2144f,
+	23.4375f,
+	-11.7188f,
+	40.2421f,
+	23.4375f,
+	-7.8125f,
+	41.7479f,
+	23.4375f,
+	-3.90625f,
+	43.372f,
+	23.4375f,
+	0.0f,
+	43.7526f,
+	23.4375f,
+	3.90625f,
+	44.6783f,
+	23.4375f,
+	-250.0f,
+	0.138221f,
+	19.5313f,
+	-246.094f,
+	1.4004f,
+	19.5313f,
+	-242.188f,
+	3.26515f,
+	19.5313f,
+	-238.281f,
+	3.65276f,
+	19.5313f,
+	-234.375f,
+	4.90602f,
+	19.5313f,
+	-230.469f,
+	6.03349f,
+	19.5313f,
+	-226.563f,
+	7.99773f,
+	19.5313f,
+	-222.656f,
+	9.41728f,
+	19.5313f,
+	-218.75f,
+	10.0435f,
+	19.5313f,
+	-214.844f,
+	12.1613f,
+	19.5313f,
+	-210.938f,
+	13.6999f,
+	19.5313f,
+	-207.031f,
+	15.7603f,
+	19.5313f,
+	-203.125f,
+	16.1549f,
+	19.5313f,
+	-199.219f,
+	17.1021f,
+	19.5313f,
+	-195.313f,
+	18.1867f,
+	19.5313f,
+	-191.406f,
+	20.6836f,
+	19.5313f,
+	-187.5f,
+	23.0865f,
+	19.5312f,
+	-183.594f,
+	24.3015f,
+	19.5313f,
+	-179.688f,
+	26.6623f,
+	19.5312f,
+	-175.781f,
+	28.232f,
+	19.5313f,
+	-171.875f,
+	30.6454f,
+	19.5312f,
+	-167.969f,
+	32.8674f,
+	19.5313f,
+	-164.063f,
+	35.0881f,
+	19.5312f,
+	-160.156f,
+	37.2715f,
+	19.5313f,
+	-156.25f,
+	38.6025f,
+	19.5312f,
+	-152.344f,
+	38.2781f,
+	19.5313f,
+	-148.438f,
+	38.4813f,
+	19.5312f,
+	-144.531f,
+	38.3281f,
+	19.5313f,
+	-140.625f,
+	38.1441f,
+	19.5312f,
+	-136.719f,
+	37.6066f,
+	19.5312f,
+	-132.813f,
+	37.2097f,
+	19.5312f,
+	-128.906f,
+	36.5694f,
+	19.5312f,
+	-125.0f,
+	36.2416f,
+	19.5312f,
+	-121.094f,
+	34.5305f,
+	19.5312f,
+	-117.188f,
+	33.3684f,
+	19.5312f,
+	-113.281f,
+	32.7805f,
+	19.5312f,
+	-109.375f,
+	31.8563f,
+	19.5312f,
+	-105.469f,
+	31.3398f,
+	19.5312f,
+	-101.563f,
+	29.7387f,
+	19.5312f,
+	-97.6563f,
+	28.7121f,
+	19.5312f,
+	-93.75f,
+	27.8904f,
+	19.5312f,
+	-89.8438f,
+	26.0256f,
+	19.5312f,
+	-85.9375f,
+	24.5469f,
+	19.5312f,
+	-82.0313f,
+	23.3531f,
+	19.5312f,
+	-78.125f,
+	21.4621f,
+	19.5313f,
+	-74.2188f,
+	20.3507f,
+	19.5313f,
+	-70.3125f,
+	20.1879f,
+	19.5313f,
+	-66.4063f,
+	20.9838f,
+	19.5313f,
+	-62.5f,
+	22.229f,
+	19.5312f,
+	-58.5938f,
+	22.355f,
+	19.5312f,
+	-54.6875f,
+	22.7659f,
+	19.5312f,
+	-50.7813f,
+	22.9258f,
+	19.5312f,
+	-46.875f,
+	23.554f,
+	19.5312f,
+	-42.9688f,
+	24.3861f,
+	19.5312f,
+	-39.0625f,
+	25.5112f,
+	19.5312f,
+	-35.1563f,
+	26.8691f,
+	19.5312f,
+	-31.25f,
+	28.968f,
+	19.5312f,
+	-27.3438f,
+	31.0124f,
+	19.5312f,
+	-23.4375f,
+	34.8357f,
+	19.5312f,
+	-19.5313f,
+	37.2362f,
+	19.5312f,
+	-15.625f,
+	39.5924f,
+	19.5312f,
+	-11.7188f,
+	41.5691f,
+	19.5312f,
+	-7.8125f,
+	43.2441f,
+	19.5312f,
+	-3.90625f,
+	45.1168f,
+	19.5312f,
+	0.0f,
+	45.7555f,
+	19.5312f,
+	3.90625f,
+	46.9055f,
+	19.5312f,
+	-250.0f,
+	0.462936f,
+	15.625f,
+	-246.094f,
+	2.15489f,
+	15.625f,
+	-242.188f,
+	3.69232f,
+	15.625f,
+	-238.281f,
+	4.89361f,
+	15.625f,
+	-234.375f,
+	6.95706f,
+	15.625f,
+	-230.469f,
+	8.37916f,
+	15.625f,
+	-226.563f,
+	9.21515f,
+	15.625f,
+	-222.656f,
+	10.0624f,
+	15.625f,
+	-218.75f,
+	11.6477f,
+	15.625f,
+	-214.844f,
+	13.257f,
+	15.625f,
+	-210.938f,
+	14.8699f,
+	15.625f,
+	-207.031f,
+	15.9852f,
+	15.625f,
+	-203.125f,
+	17.025f,
+	15.625f,
+	-199.219f,
+	17.8511f,
+	15.625f,
+	-195.313f,
+	20.3581f,
+	15.625f,
+	-191.406f,
+	22.0829f,
+	15.625f,
+	-187.5f,
+	24.4216f,
+	15.625f,
+	-183.594f,
+	25.5625f,
+	15.625f,
+	-179.688f,
+	27.0961f,
+	15.625f,
+	-175.781f,
+	30.0958f,
+	15.625f,
+	-171.875f,
+	31.7977f,
+	15.625f,
+	-167.969f,
+	34.7043f,
+	15.625f,
+	-164.063f,
+	37.1655f,
+	15.625f,
+	-160.156f,
+	37.6823f,
+	15.625f,
+	-156.25f,
+	37.6204f,
+	15.625f,
+	-152.344f,
+	37.8037f,
+	15.625f,
+	-148.438f,
+	37.8555f,
+	15.625f,
+	-144.531f,
+	37.9638f,
+	15.625f,
+	-140.625f,
+	37.4821f,
+	15.625f,
+	-136.719f,
+	37.0202f,
+	15.625f,
+	-132.813f,
+	36.4604f,
+	15.625f,
+	-128.906f,
+	36.1575f,
+	15.625f,
+	-125.0f,
+	35.4218f,
+	15.625f,
+	-121.094f,
+	33.5202f,
+	15.625f,
+	-117.188f,
+	32.116f,
+	15.625f,
+	-113.281f,
+	30.9352f,
+	15.625f,
+	-109.375f,
+	29.8297f,
+	15.625f,
+	-105.469f,
+	29.9146f,
+	15.625f,
+	-101.563f,
+	28.7245f,
+	15.625f,
+	-97.6563f,
+	27.7205f,
+	15.625f,
+	-93.75f,
+	27.4217f,
+	15.625f,
+	-89.8438f,
+	25.8557f,
+	15.625f,
+	-85.9375f,
+	24.0609f,
+	15.625f,
+	-82.0313f,
+	22.7869f,
+	15.625f,
+	-78.125f,
+	20.4923f,
+	15.625f,
+	-74.2188f,
+	21.0025f,
+	15.625f,
+	-70.3125f,
+	21.2985f,
+	15.625f,
+	-66.4063f,
+	22.5717f,
+	15.625f,
+	-62.5f,
+	23.0569f,
+	15.625f,
+	-58.5938f,
+	23.2123f,
+	15.625f,
+	-54.6875f,
+	24.1861f,
+	15.625f,
+	-50.7813f,
+	24.5626f,
+	15.625f,
+	-46.875f,
+	25.1259f,
+	15.625f,
+	-42.9688f,
+	25.9995f,
+	15.625f,
+	-39.0625f,
+	26.8682f,
+	15.625f,
+	-35.1563f,
+	27.8593f,
+	15.625f,
+	-31.25f,
+	29.8924f,
+	15.625f,
+	-27.3438f,
+	32.8894f,
+	15.625f,
+	-23.4375f,
+	36.2901f,
+	15.625f,
+	-19.5313f,
+	38.2475f,
+	15.625f,
+	-15.625f,
+	40.593f,
+	15.625f,
+	-11.7188f,
+	42.2973f,
+	15.625f,
+	-7.8125f,
+	45.3308f,
+	15.625f,
+	-3.90625f,
+	47.345f,
+	15.625f,
+	0.0f,
+	48.9808f,
+	15.625f,
+	3.90625f,
+	49.2295f,
+	15.625f,
+	-250.0f,
+	1.16646f,
+	11.7188f,
+	-246.094f,
+	2.99331f,
+	11.7188f,
+	-242.188f,
+	4.37829f,
+	11.7188f,
+	-238.281f,
+	5.21593f,
+	11.7188f,
+	-234.375f,
+	6.84374f,
+	11.7188f,
+	-230.469f,
+	8.34616f,
+	11.7188f,
+	-226.563f,
+	9.2826f,
+	11.7188f,
+	-222.656f,
+	9.90104f,
+	11.7188f,
+	-218.75f,
+	10.9211f,
+	11.7187f,
+	-214.844f,
+	13.6881f,
+	11.7187f,
+	-210.938f,
+	15.7745f,
+	11.7187f,
+	-207.031f,
+	16.2325f,
+	11.7187f,
+	-203.125f,
+	17.2525f,
+	11.7187f,
+	-199.219f,
+	19.1108f,
+	11.7187f,
+	-195.313f,
+	21.4743f,
+	11.7187f,
+	-191.406f,
+	24.021f,
+	11.7187f,
+	-187.5f,
+	25.8676f,
+	11.7187f,
+	-183.594f,
+	27.021f,
+	11.7187f,
+	-179.688f,
+	28.254f,
+	11.7187f,
+	-175.781f,
+	31.6036f,
+	11.7187f,
+	-171.875f,
+	32.629f,
+	11.7187f,
+	-167.969f,
+	34.9526f,
+	11.7187f,
+	-164.063f,
+	36.8236f,
+	11.7187f,
+	-160.156f,
+	37.152f,
+	11.7187f,
+	-156.25f,
+	37.6659f,
+	11.7187f,
+	-152.344f,
+	37.4102f,
+	11.7187f,
+	-148.438f,
+	37.0806f,
+	11.7187f,
+	-144.531f,
+	37.6299f,
+	11.7187f,
+	-140.625f,
+	36.7269f,
+	11.7187f,
+	-136.719f,
+	36.4841f,
+	11.7187f,
+	-132.813f,
+	35.2557f,
+	11.7187f,
+	-128.906f,
+	34.7066f,
+	11.7187f,
+	-125.0f,
+	34.0947f,
+	11.7187f,
+	-121.094f,
+	32.7343f,
+	11.7187f,
+	-117.188f,
+	31.5605f,
+	11.7187f,
+	-113.281f,
+	30.7492f,
+	11.7187f,
+	-109.375f,
+	30.1608f,
+	11.7187f,
+	-105.469f,
+	29.9144f,
+	11.7187f,
+	-101.563f,
+	28.5532f,
+	11.7187f,
+	-97.6563f,
+	26.2051f,
+	11.7187f,
+	-93.75f,
+	26.0432f,
+	11.7187f,
+	-89.8438f,
+	25.1831f,
+	11.7187f,
+	-85.9375f,
+	23.7935f,
+	11.7187f,
+	-82.0313f,
+	22.6952f,
+	11.7187f,
+	-78.125f,
+	21.9812f,
+	11.7187f,
+	-74.2188f,
+	22.3423f,
+	11.7187f,
+	-70.3125f,
+	22.4959f,
+	11.7187f,
+	-66.4063f,
+	22.9438f,
+	11.7187f,
+	-62.5f,
+	23.6591f,
+	11.7187f,
+	-58.5938f,
+	24.1634f,
+	11.7187f,
+	-54.6875f,
+	24.8781f,
+	11.7187f,
+	-50.7813f,
+	25.3471f,
+	11.7187f,
+	-46.875f,
+	25.7599f,
+	11.7187f,
+	-42.9688f,
+	26.61f,
+	11.7187f,
+	-39.0625f,
+	27.5033f,
+	11.7187f,
+	-35.1563f,
+	29.2751f,
+	11.7187f,
+	-31.25f,
+	31.9147f,
+	11.7187f,
+	-27.3438f,
+	34.1964f,
+	11.7187f,
+	-23.4375f,
+	36.7734f,
+	11.7187f,
+	-19.5313f,
+	39.2441f,
+	11.7187f,
+	-15.625f,
+	41.3269f,
+	11.7187f,
+	-11.7188f,
+	44.2682f,
+	11.7187f,
+	-7.8125f,
+	47.2458f,
+	11.7187f,
+	-3.90625f,
+	49.2199f,
+	11.7187f,
+	0.0f,
+	50.2546f,
+	11.7187f,
+	3.90625f,
+	51.1233f,
+	11.7187f,
+	-250.0f,
+	1.52698f,
+	7.8125f,
+	-246.094f,
+	2.97227f,
+	7.8125f,
+	-242.188f,
+	3.77319f,
+	7.8125f,
+	-238.281f,
+	4.81095f,
+	7.8125f,
+	-234.375f,
+	5.94458f,
+	7.8125f,
+	-230.469f,
+	7.45352f,
+	7.8125f,
+	-226.563f,
+	8.9683f,
+	7.8125f,
+	-222.656f,
+	9.37348f,
+	7.8125f,
+	-218.75f,
+	10.3818f,
+	7.8125f,
+	-214.844f,
+	13.0632f,
+	7.8125f,
+	-210.938f,
+	15.5836f,
+	7.8125f,
+	-207.031f,
+	17.1532f,
+	7.8125f,
+	-203.125f,
+	19.3065f,
+	7.8125f,
+	-199.219f,
+	21.746f,
+	7.8125f,
+	-195.313f,
+	23.0026f,
+	7.8125f,
+	-191.406f,
+	25.1876f,
+	7.8125f,
+	-187.5f,
+	27.4911f,
+	7.8125f,
+	-183.594f,
+	28.651f,
+	7.8125f,
+	-179.688f,
+	28.9685f,
+	7.8125f,
+	-175.781f,
+	31.1275f,
+	7.8125f,
+	-171.875f,
+	32.457f,
+	7.8125f,
+	-167.969f,
+	34.4336f,
+	7.8125f,
+	-164.063f,
+	35.9124f,
+	7.8125f,
+	-160.156f,
+	36.5078f,
+	7.8125f,
+	-156.25f,
+	36.9999f,
+	7.8125f,
+	-152.344f,
+	36.9517f,
+	7.8125f,
+	-148.438f,
+	37.9713f,
+	7.8125f,
+	-144.531f,
+	37.929f,
+	7.8125f,
+	-140.625f,
+	37.5334f,
+	7.8125f,
+	-136.719f,
+	36.2798f,
+	7.8125f,
+	-132.813f,
+	35.1904f,
+	7.8125f,
+	-128.906f,
+	33.7356f,
+	7.8125f,
+	-125.0f,
+	34.0968f,
+	7.8125f,
+	-121.094f,
+	33.5838f,
+	7.8125f,
+	-117.188f,
+	32.9371f,
+	7.8125f,
+	-113.281f,
+	32.0353f,
+	7.8125f,
+	-109.375f,
+	31.4623f,
+	7.8125f,
+	-105.469f,
+	30.5184f,
+	7.8125f,
+	-101.563f,
+	28.7396f,
+	7.8125f,
+	-97.6563f,
+	27.2715f,
+	7.8125f,
+	-93.75f,
+	26.1242f,
+	7.8125f,
+	-89.8438f,
+	24.5691f,
+	7.8125f,
+	-85.9375f,
+	23.931f,
+	7.8125f,
+	-82.0313f,
+	23.7643f,
+	7.8125f,
+	-78.125f,
+	22.4588f,
+	7.8125f,
+	-74.2188f,
+	22.5395f,
+	7.8125f,
+	-70.3125f,
+	22.9322f,
+	7.8125f,
+	-66.4063f,
+	23.4361f,
+	7.8125f,
+	-62.5f,
+	24.2733f,
+	7.8125f,
+	-58.5938f,
+	24.1873f,
+	7.8125f,
+	-54.6875f,
+	24.2666f,
+	7.8125f,
+	-50.7813f,
+	25.2522f,
+	7.8125f,
+	-46.875f,
+	26.3494f,
+	7.8125f,
+	-42.9688f,
+	26.8365f,
+	7.8125f,
+	-39.0625f,
+	27.5515f,
+	7.8125f,
+	-35.1563f,
+	30.4441f,
+	7.8125f,
+	-31.25f,
+	33.5547f,
+	7.8125f,
+	-27.3438f,
+	36.1409f,
+	7.8125f,
+	-23.4375f,
+	38.1103f,
+	7.8125f,
+	-19.5313f,
+	39.8171f,
+	7.8125f,
+	-15.625f,
+	42.1146f,
+	7.8125f,
+	-11.7188f,
+	45.3603f,
+	7.8125f,
+	-7.8125f,
+	47.6602f,
+	7.8125f,
+	-3.90625f,
+	49.963f,
+	7.8125f,
+	0.0f,
+	51.8119f,
+	7.8125f,
+	3.90625f,
+	52.2527f,
+	7.8125f,
+	-250.0f,
+	0.139875f,
+	3.90625f,
+	-246.094f,
+	1.72995f,
+	3.90625f,
+	-242.188f,
+	2.60122f,
+	3.90625f,
+	-238.281f,
+	4.01346f,
+	3.90625f,
+	-234.375f,
+	5.13654f,
+	3.90625f,
+	-230.469f,
+	6.69665f,
+	3.90625f,
+	-226.563f,
+	8.43203f,
+	3.90625f,
+	-222.656f,
+	9.83442f,
+	3.90625f,
+	-218.75f,
+	11.3645f,
+	3.90625f,
+	-214.844f,
+	14.222f,
+	3.90625f,
+	-210.938f,
+	16.1758f,
+	3.90625f,
+	-207.031f,
+	18.9127f,
+	3.90625f,
+	-203.125f,
+	21.2478f,
+	3.90625f,
+	-199.219f,
+	23.0589f,
+	3.90625f,
+	-195.313f,
+	24.6025f,
+	3.90625f,
+	-191.406f,
+	25.8143f,
+	3.90625f,
+	-187.5f,
+	27.5696f,
+	3.90625f,
+	-183.594f,
+	29.2176f,
+	3.90625f,
+	-179.688f,
+	29.6835f,
+	3.90625f,
+	-175.781f,
+	30.7416f,
+	3.90625f,
+	-171.875f,
+	31.4405f,
+	3.90625f,
+	-167.969f,
+	33.0831f,
+	3.90625f,
+	-164.063f,
+	34.6225f,
+	3.90625f,
+	-160.156f,
+	35.4992f,
+	3.90625f,
+	-156.25f,
+	37.4126f,
+	3.90625f,
+	-152.344f,
+	38.453f,
+	3.90625f,
+	-148.438f,
+	38.9974f,
+	3.90625f,
+	-144.531f,
+	38.7871f,
+	3.90625f,
+	-140.625f,
+	37.6021f,
+	3.90625f,
+	-136.719f,
+	36.1797f,
+	3.90625f,
+	-132.813f,
+	34.9906f,
+	3.90625f,
+	-128.906f,
+	34.1304f,
+	3.90625f,
+	-125.0f,
+	34.3517f,
+	3.90625f,
+	-121.094f,
+	33.6612f,
+	3.90625f,
+	-117.188f,
+	32.7047f,
+	3.90625f,
+	-113.281f,
+	32.3958f,
+	3.90625f,
+	-109.375f,
+	31.0818f,
+	3.90625f,
+	-105.469f,
+	30.9536f,
+	3.90625f,
+	-101.563f,
+	29.8205f,
+	3.90625f,
+	-97.6563f,
+	28.4796f,
+	3.90625f,
+	-93.75f,
+	27.6494f,
+	3.90625f,
+	-89.8438f,
+	25.5721f,
+	3.90625f,
+	-85.9375f,
+	24.227f,
+	3.90625f,
+	-82.0313f,
+	23.2611f,
+	3.90625f,
+	-78.125f,
+	22.4589f,
+	3.90625f,
+	-74.2188f,
+	23.2261f,
+	3.90625f,
+	-70.3125f,
+	23.5025f,
+	3.90625f,
+	-66.4063f,
+	23.6913f,
+	3.90625f,
+	-62.5f,
+	24.6785f,
+	3.90625f,
+	-58.5938f,
+	25.4946f,
+	3.90625f,
+	-54.6875f,
+	25.9722f,
+	3.90625f,
+	-50.7813f,
+	26.1977f,
+	3.90625f,
+	-46.875f,
+	26.8539f,
+	3.90625f,
+	-42.9688f,
+	27.7268f,
+	3.90625f,
+	-39.0625f,
+	29.2046f,
+	3.90625f,
+	-35.1563f,
+	31.79f,
+	3.90625f,
+	-31.25f,
+	34.2658f,
+	3.90625f,
+	-27.3438f,
+	35.9914f,
+	3.90625f,
+	-23.4375f,
+	38.3776f,
+	3.90625f,
+	-19.5313f,
+	39.8852f,
+	3.90625f,
+	-15.625f,
+	43.1455f,
+	3.90625f,
+	-11.7188f,
+	45.5059f,
+	3.90625f,
+	-7.8125f,
+	47.4257f,
+	3.90625f,
+	-3.90625f,
+	49.9032f,
+	3.90625f,
+	0.0f,
+	52.0322f,
+	3.90625f,
+	3.90625f,
+	52.6186f,
+	3.90625f,
+};
+
+btScalar Landscape02Nml[] = {
+	0.376889f,
+	0.897995f,
+	0.227068f,
+	0.251083f,
+	0.961355f,
+	0.112931f,
+	0.256071f,
+	0.961946f,
+	0.0953332f,
+	0.188246f,
+	0.981544f,
+	0.0336933f,
+	0.321782f,
+	0.946812f,
+	0.00191405f,
+	0.277829f,
+	0.960055f,
+	0.0332431f,
+	0.366908f,
+	0.922321f,
+	-0.121252f,
+	0.346681f,
+	0.936118f,
+	-0.0591191f,
+	0.34598f,
+	0.936023f,
+	-0.0644918f,
+	0.326882f,
+	0.934733f,
+	-0.139364f,
+	0.195537f,
+	0.979014f,
+	-0.0574119f,
+	0.208421f,
+	0.974173f,
+	-0.0868766f,
+	0.220158f,
+	0.96963f,
+	-0.106528f,
+	0.21764f,
+	0.974169f,
+	-0.0602246f,
+	0.194781f,
+	0.966032f,
+	-0.169831f,
+	0.137923f,
+	0.97923f,
+	-0.148611f,
+	-0.0890295f,
+	0.968844f,
+	-0.231118f,
+	-0.164208f,
+	0.952108f,
+	-0.257926f,
+	-0.299547f,
+	0.905883f,
+	-0.299413f,
+	-0.331781f,
+	0.892916f,
+	-0.304338f,
+	-0.275234f,
+	0.921181f,
+	-0.275086f,
+	-0.190055f,
+	0.968186f,
+	-0.162776f,
+	-0.191147f,
+	0.964101f,
+	-0.184313f,
+	-0.167051f,
+	0.973656f,
+	-0.155201f,
+	-0.260549f,
+	0.956867f,
+	-0.128527f,
+	-0.236175f,
+	0.968373f,
+	-0.080466f,
+	-0.305083f,
+	0.942279f,
+	-0.137969f,
+	-0.32302f,
+	0.940678f,
+	-0.103844f,
+	-0.376654f,
+	0.91108f,
+	-0.167524f,
+	-0.43665f,
+	0.882087f,
+	-0.176802f,
+	-0.404697f,
+	0.87224f,
+	-0.274621f,
+	-0.461396f,
+	0.842558f,
+	-0.277868f,
+	-0.340534f,
+	0.861872f,
+	-0.375783f,
+	-0.381498f,
+	0.847049f,
+	-0.370091f,
+	-0.349262f,
+	0.83292f,
+	-0.429255f,
+	-0.383821f,
+	0.842401f,
+	-0.378209f,
+	-0.350717f,
+	0.827302f,
+	-0.438826f,
+	-0.312636f,
+	0.886963f,
+	-0.339934f,
+	-0.202637f,
+	0.921293f,
+	-0.331899f,
+	-0.164853f,
+	0.917655f,
+	-0.361571f,
+	-0.320762f,
+	0.929092f,
+	-0.184116f,
+	-0.291289f,
+	0.89543f,
+	-0.336684f,
+	-0.523923f,
+	0.850919f,
+	-0.0379686f,
+	-0.415222f,
+	0.907809f,
+	-0.0589323f,
+	-0.464751f,
+	0.884928f,
+	0.030152f,
+	-0.464228f,
+	0.885715f,
+	0.00114487f,
+	-0.460666f,
+	0.887573f,
+	-0.00119475f,
+	-0.527574f,
+	0.824073f,
+	-0.206324f,
+	-0.569463f,
+	0.819886f,
+	-0.0591577f,
+	-0.624043f,
+	0.739025f,
+	-0.253797f,
+	-0.677912f,
+	0.708815f,
+	-0.19498f,
+	-0.654991f,
+	0.737431f,
+	-0.164874f,
+	-0.612102f,
+	0.778841f,
+	-0.136883f,
+	-0.555251f,
+	0.829082f,
+	-0.0657209f,
+	-0.466796f,
+	0.884362f,
+	-0.00238444f,
+	-0.393172f,
+	0.917844f,
+	0.0545768f,
+	-0.415266f,
+	0.902781f,
+	0.111985f,
+	-0.346174f,
+	0.92512f,
+	0.155936f,
+	-0.270143f,
+	0.942251f,
+	0.197955f,
+	-0.242693f,
+	0.931939f,
+	0.269424f,
+	-0.146828f,
+	0.979561f,
+	0.137484f,
+	-0.151815f,
+	0.949716f,
+	0.273847f,
+	-0.23746f,
+	0.962635f,
+	0.130183f,
+	-0.242269f,
+	0.936807f,
+	0.252385f,
+	-0.439066f,
+	0.897439f,
+	0.0427119f,
+	-0.506925f,
+	0.859633f,
+	0.0637107f,
+	-0.369534f,
+	0.927612f,
+	0.0545955f,
+	-0.266432f,
+	0.921234f,
+	0.283447f,
+	-0.0849634f,
+	0.983229f,
+	0.161377f,
+	-0.142422f,
+	0.97399f,
+	0.176238f,
+	0.059987f,
+	0.992193f,
+	0.109333f,
+	-0.00609097f,
+	0.990503f,
+	0.137353f,
+	0.218751f,
+	0.975042f,
+	-0.0379662f,
+	0.195675f,
+	0.973574f,
+	0.117747f,
+	0.412438f,
+	0.903178f,
+	-0.119012f,
+	0.389829f,
+	0.920771f,
+	0.01463f,
+	0.471887f,
+	0.878868f,
+	-0.0700914f,
+	0.512637f,
+	0.843878f,
+	0.158344f,
+	0.438398f,
+	0.898776f,
+	-0.0028899f,
+	0.463505f,
+	0.872879f,
+	0.152466f,
+	0.213581f,
+	0.96879f,
+	0.125817f,
+	0.217949f,
+	0.966902f,
+	0.132661f,
+	0.150053f,
+	0.978231f,
+	0.143348f,
+	0.183142f,
+	0.954792f,
+	0.234161f,
+	0.324547f,
+	0.937949f,
+	0.122152f,
+	0.305949f,
+	0.944044f,
+	0.123194f,
+	0.404781f,
+	0.90011f,
+	0.161105f,
+	0.386685f,
+	0.917163f,
+	0.0963685f,
+	0.43511f,
+	0.894378f,
+	0.103764f,
+	0.444378f,
+	0.884165f,
+	0.144156f,
+	0.485066f,
+	0.871945f,
+	0.0665013f,
+	0.480511f,
+	0.864609f,
+	0.146835f,
+	0.542329f,
+	0.83784f,
+	0.0624783f,
+	0.538258f,
+	0.834152f,
+	0.120286f,
+	0.497652f,
+	0.86488f,
+	0.0657686f,
+	0.471897f,
+	0.881288f,
+	0.0253797f,
+	0.368509f,
+	0.927548f,
+	0.0620863f,
+	0.391828f,
+	0.918428f,
+	0.0544149f,
+	0.284879f,
+	0.953389f,
+	0.0994662f,
+	0.359932f,
+	0.902669f,
+	0.235877f,
+	0.19297f,
+	0.969614f,
+	0.150374f,
+	0.198191f,
+	0.923716f,
+	0.327825f,
+	0.174784f,
+	0.978101f,
+	0.113003f,
+	0.121688f,
+	0.95783f,
+	0.260297f,
+	0.3291f,
+	0.939598f,
+	0.094074f,
+	0.241925f,
+	0.967997f,
+	0.066744f,
+	0.275982f,
+	0.959352f,
+	0.0589789f,
+	0.207349f,
+	0.969048f,
+	-0.133986f,
+	-0.048418f,
+	0.997403f,
+	0.0533214f,
+	-0.0214229f,
+	0.995947f,
+	-0.0873486f,
+	-0.224808f,
+	0.97209f,
+	0.0671032f,
+	-0.154526f,
+	0.98721f,
+	0.0392114f,
+	-0.0539424f,
+	0.990401f,
+	0.127262f,
+	0.0294265f,
+	0.986864f,
+	0.158851f,
+	0.115045f,
+	0.967726f,
+	0.224212f,
+	0.135755f,
+	0.967813f,
+	0.211917f,
+	-0.0987201f,
+	0.976534f,
+	0.191406f,
+	-0.208734f,
+	0.974954f,
+	0.0767793f,
+	-0.346094f,
+	0.938088f,
+	0.0144628f,
+	-0.364883f,
+	0.930977f,
+	0.0119327f,
+	-0.234075f,
+	0.972082f,
+	0.0162811f,
+	-0.216489f,
+	0.973875f,
+	0.0685516f,
+	-0.126585f,
+	0.991898f,
+	0.0107448f,
+	-0.188432f,
+	0.981937f,
+	-0.0171439f,
+	-0.186728f,
+	0.980312f,
+	-0.0641921f,
+	-0.243763f,
+	0.959118f,
+	-0.14378f,
+	-0.256453f,
+	0.962392f,
+	-0.0896326f,
+	-0.227009f,
+	0.972481f,
+	-0.0524148f,
+	-0.308642f,
+	0.945388f,
+	-0.104794f,
+	-0.322884f,
+	0.94242f,
+	-0.0871231f,
+	-0.32494f,
+	0.940988f,
+	-0.0946312f,
+	-0.365791f,
+	0.920972f,
+	-0.134189f,
+	0.507209f,
+	0.830952f,
+	0.228598f,
+	0.427157f,
+	0.893788f,
+	0.136676f,
+	0.390358f,
+	0.920644f,
+	0.00595094f,
+	0.357f,
+	0.931227f,
+	0.0732586f,
+	0.253669f,
+	0.95455f,
+	0.156478f,
+	0.247974f,
+	0.954291f,
+	0.166849f,
+	0.303694f,
+	0.950352f,
+	0.0678299f,
+	0.260247f,
+	0.965246f,
+	0.0238949f,
+	-0.0615746f,
+	0.996768f,
+	-0.0515863f,
+	-0.225111f,
+	0.970921f,
+	-0.0814727f,
+	-0.33579f,
+	0.924057f,
+	-0.18266f,
+	-0.286567f,
+	0.949099f,
+	-0.13073f,
+	-0.266283f,
+	0.957101f,
+	-0.114241f,
+	-0.297972f,
+	0.942451f,
+	-0.151651f,
+	-0.345158f,
+	0.930403f,
+	-0.123358f,
+	-0.323606f,
+	0.933615f,
+	-0.153759f,
+	-0.295216f,
+	0.935234f,
+	-0.195409f,
+	-0.294262f,
+	0.935546f,
+	-0.195355f,
+	-0.367877f,
+	0.896699f,
+	-0.246165f,
+	-0.460611f,
+	0.856308f,
+	-0.233612f,
+	-0.493615f,
+	0.869663f,
+	0.00556421f,
+	-0.56572f,
+	0.819247f,
+	0.0937815f,
+	-0.482796f,
+	0.868728f,
+	0.110547f,
+	-0.473443f,
+	0.870107f,
+	0.136985f,
+	-0.486628f,
+	0.863931f,
+	0.12968f,
+	-0.584612f,
+	0.809918f,
+	-0.0475519f,
+	-0.673803f,
+	0.720247f,
+	-0.165027f,
+	-0.584438f,
+	0.811258f,
+	-0.0171189f,
+	-0.49626f,
+	0.855798f,
+	0.146063f,
+	-0.266763f,
+	0.927018f,
+	0.26358f,
+	-0.000318467f,
+	0.974136f,
+	0.225963f,
+	-0.2098f,
+	0.977621f,
+	0.015525f,
+	-0.363964f,
+	0.929076f,
+	-0.0659462f,
+	-0.427799f,
+	0.890708f,
+	-0.153708f,
+	-0.226888f,
+	0.973494f,
+	-0.0288381f,
+	0.176474f,
+	0.981f,
+	0.080593f,
+	0.382766f,
+	0.920418f,
+	-0.0794987f,
+	0.4558f,
+	0.874041f,
+	-0.16822f,
+	0.44168f,
+	0.87342f,
+	-0.205075f,
+	0.269141f,
+	0.944688f,
+	-0.187422f,
+	0.0983269f,
+	0.994746f,
+	0.0285051f,
+	0.164874f,
+	0.980231f,
+	0.10938f,
+	0.300398f,
+	0.949423f,
+	0.0914149f,
+	0.370498f,
+	0.925363f,
+	0.0802133f,
+	0.51325f,
+	0.857062f,
+	0.0449297f,
+	0.515688f,
+	0.85628f,
+	-0.0291725f,
+	0.532902f,
+	0.845818f,
+	-0.0246416f,
+	0.470584f,
+	0.882352f,
+	0.00224652f,
+	0.358364f,
+	0.932053f,
+	0.0534101f,
+	0.299916f,
+	0.948938f,
+	0.0978121f,
+	0.234125f,
+	0.96956f,
+	0.0716857f,
+	0.201429f,
+	0.97943f,
+	0.0119968f,
+	0.257021f,
+	0.965839f,
+	0.0330825f,
+	0.205585f,
+	0.966488f,
+	0.153741f,
+	-0.0291083f,
+	0.972977f,
+	0.22906f,
+	-0.183781f,
+	0.97216f,
+	0.145362f,
+	-0.0880966f,
+	0.991634f,
+	0.0943445f,
+	0.0404056f,
+	0.991359f,
+	0.124796f,
+	-0.0259416f,
+	0.986408f,
+	0.162256f,
+	-0.213262f,
+	0.97241f,
+	0.0945471f,
+	-0.221976f,
+	0.974645f,
+	0.0281856f,
+	-0.137418f,
+	0.990413f,
+	0.014064f,
+	-0.147111f,
+	0.988464f,
+	0.0360112f,
+	-0.213681f,
+	0.97687f,
+	0.00813376f,
+	-0.286716f,
+	0.957516f,
+	-0.0309366f,
+	-0.362687f,
+	0.929548f,
+	-0.0663186f,
+	0.471826f,
+	0.881687f,
+	0.00273101f,
+	0.493844f,
+	0.862721f,
+	0.108764f,
+	0.305852f,
+	0.940961f,
+	0.145073f,
+	0.225186f,
+	0.91763f,
+	0.327484f,
+	0.255894f,
+	0.905552f,
+	0.33837f,
+	0.302798f,
+	0.922674f,
+	0.238719f,
+	0.353759f,
+	0.914443f,
+	0.196594f,
+	0.301669f,
+	0.941039f,
+	0.153105f,
+	0.00675732f,
+	0.993813f,
+	0.110864f,
+	-0.180673f,
+	0.978312f,
+	0.101302f,
+	-0.247784f,
+	0.966857f,
+	0.0615767f,
+	-0.309703f,
+	0.949482f,
+	-0.0506691f,
+	-0.243038f,
+	0.969623f,
+	-0.0276337f,
+	-0.257234f,
+	0.966017f,
+	-0.0253295f,
+	-0.381367f,
+	0.920413f,
+	-0.0860151f,
+	-0.354157f,
+	0.93479f,
+	-0.027217f,
+	-0.299485f,
+	0.952671f,
+	0.0522246f,
+	-0.356888f,
+	0.9323f,
+	0.0587106f,
+	-0.335176f,
+	0.924244f,
+	0.182839f,
+	-0.500593f,
+	0.855036f,
+	0.135351f,
+	-0.576428f,
+	0.801243f,
+	0.160441f,
+	-0.583679f,
+	0.788168f,
+	0.195218f,
+	-0.491918f,
+	0.829821f,
+	0.263465f,
+	-0.431671f,
+	0.862042f,
+	0.2656f,
+	-0.443518f,
+	0.883408f,
+	0.151265f,
+	-0.464317f,
+	0.881859f,
+	0.0820666f,
+	-0.652068f,
+	0.753609f,
+	-0.0829502f,
+	-0.681939f,
+	0.728217f,
+	-0.068254f,
+	-0.591161f,
+	0.804152f,
+	0.0621953f,
+	-0.352647f,
+	0.921747f,
+	0.161318f,
+	0.0545396f,
+	0.95959f,
+	0.276065f,
+	0.0694942f,
+	0.971972f,
+	0.224591f,
+	-0.253858f,
+	0.964902f,
+	-0.0672354f,
+	-0.408551f,
+	0.900688f,
+	-0.147807f,
+	-0.327666f,
+	0.933936f,
+	-0.142825f,
+	0.129878f,
+	0.985787f,
+	-0.106564f,
+	0.442239f,
+	0.89421f,
+	-0.0693695f,
+	0.506959f,
+	0.860716f,
+	-0.0464834f,
+	0.440087f,
+	0.895465f,
+	-0.0668225f,
+	0.226441f,
+	0.974021f,
+	0.00265329f,
+	-0.0272959f,
+	0.999596f,
+	0.00787303f,
+	0.0903893f,
+	0.995643f,
+	0.0228958f,
+	0.359925f,
+	0.931179f,
+	0.0579615f,
+	0.431266f,
+	0.899788f,
+	-0.0662666f,
+	0.53735f,
+	0.839722f,
+	-0.0782406f,
+	0.525898f,
+	0.846474f,
+	-0.0831443f,
+	0.503404f,
+	0.859213f,
+	-0.0913118f,
+	0.450901f,
+	0.892319f,
+	-0.0213084f,
+	0.278054f,
+	0.959353f,
+	0.048252f,
+	0.254295f,
+	0.953824f,
+	0.159853f,
+	0.246692f,
+	0.953779f,
+	0.171608f,
+	0.237766f,
+	0.960301f,
+	0.145908f,
+	0.249319f,
+	0.965473f,
+	0.0755121f,
+	0.140552f,
+	0.989905f,
+	0.0182753f,
+	-0.0589195f,
+	0.996842f,
+	0.0532477f,
+	-0.101426f,
+	0.988847f,
+	0.109061f,
+	-0.043669f,
+	0.99706f,
+	0.0629708f,
+	0.0474685f,
+	0.998853f,
+	-0.0063145f,
+	-0.0867729f,
+	0.996136f,
+	-0.0135299f,
+	-0.196161f,
+	0.972844f,
+	0.12286f,
+	-0.192413f,
+	0.974994f,
+	0.111196f,
+	-0.123107f,
+	0.990318f,
+	0.0641543f,
+	-0.164426f,
+	0.985628f,
+	0.0387435f,
+	-0.213922f,
+	0.974633f,
+	0.0657922f,
+	-0.241049f,
+	0.968373f,
+	0.0644173f,
+	-0.307154f,
+	0.951627f,
+	-0.00792363f,
+	0.280771f,
+	0.958227f,
+	-0.0544817f,
+	0.299035f,
+	0.949091f,
+	0.0990176f,
+	0.225174f,
+	0.937279f,
+	0.266091f,
+	0.201765f,
+	0.945847f,
+	0.254291f,
+	0.341377f,
+	0.920786f,
+	0.18872f,
+	0.3743f,
+	0.913661f,
+	0.158502f,
+	0.359138f,
+	0.923211f,
+	0.136755f,
+	0.36518f,
+	0.919296f,
+	0.146759f,
+	0.0046348f,
+	0.996002f,
+	0.0892048f,
+	-0.241229f,
+	0.954179f,
+	0.177061f,
+	-0.158349f,
+	0.951157f,
+	0.265002f,
+	-0.207545f,
+	0.971279f,
+	0.116375f,
+	-0.289845f,
+	0.957072f,
+	0.00156201f,
+	-0.257416f,
+	0.96626f,
+	0.00885102f,
+	-0.326801f,
+	0.944936f,
+	0.0172234f,
+	-0.439204f,
+	0.898379f,
+	-0.00377194f,
+	-0.336537f,
+	0.936282f,
+	0.100589f,
+	-0.407285f,
+	0.907139f,
+	0.105914f,
+	-0.44858f,
+	0.865076f,
+	0.224543f,
+	-0.454994f,
+	0.838311f,
+	0.300358f,
+	-0.578424f,
+	0.785375f,
+	0.220483f,
+	-0.613986f,
+	0.761879f,
+	0.206302f,
+	-0.509143f,
+	0.819763f,
+	0.262226f,
+	-0.364105f,
+	0.879908f,
+	0.30527f,
+	-0.344494f,
+	0.905138f,
+	0.249097f,
+	-0.369295f,
+	0.913195f,
+	0.172323f,
+	-0.574832f,
+	0.817482f,
+	0.0359178f,
+	-0.689125f,
+	0.724332f,
+	-0.0212343f,
+	-0.619919f,
+	0.781232f,
+	-0.0733212f,
+	-0.441345f,
+	0.892835f,
+	-0.0897783f,
+	-0.0649595f,
+	0.996915f,
+	0.0440505f,
+	0.146397f,
+	0.977716f,
+	0.150467f,
+	-0.0177868f,
+	0.998167f,
+	0.0578468f,
+	-0.37006f,
+	0.91802f,
+	-0.14246f,
+	-0.30849f,
+	0.937533f,
+	-0.160828f,
+	0.107382f,
+	0.980696f,
+	-0.163415f,
+	0.392635f,
+	0.914926f,
+	-0.093533f,
+	0.501877f,
+	0.862749f,
+	-0.0615151f,
+	0.381618f,
+	0.912204f,
+	-0.14917f,
+	0.160415f,
+	0.986769f,
+	-0.0235493f,
+	0.0253729f,
+	0.99703f,
+	0.0727145f,
+	0.144484f,
+	0.989507f,
+	0.000443305f,
+	0.379228f,
+	0.922372f,
+	-0.073601f,
+	0.493599f,
+	0.867009f,
+	-0.0682314f,
+	0.529895f,
+	0.842151f,
+	-0.099967f,
+	0.549367f,
+	0.821638f,
+	-0.152008f,
+	0.439412f,
+	0.876451f,
+	-0.196851f,
+	0.349224f,
+	0.935858f,
+	0.0470259f,
+	0.182079f,
+	0.971589f,
+	0.151205f,
+	0.194383f,
+	0.962201f,
+	0.190749f,
+	0.266182f,
+	0.94835f,
+	0.172569f,
+	0.284034f,
+	0.949535f,
+	0.133071f,
+	0.347472f,
+	0.93345f,
+	0.089069f,
+	0.226103f,
+	0.974059f,
+	0.00925465f,
+	-0.0773561f,
+	0.993257f,
+	-0.0863519f,
+	-0.200366f,
+	0.974099f,
+	-0.104811f,
+	-0.00292133f,
+	0.99995f,
+	-0.00953497f,
+	0.144264f,
+	0.988303f,
+	-0.0494442f,
+	-0.155865f,
+	0.979469f,
+	-0.127857f,
+	-0.286146f,
+	0.957784f,
+	-0.0277406f,
+	-0.165259f,
+	0.985103f,
+	-0.0475661f,
+	-0.069504f,
+	0.996782f,
+	-0.0399387f,
+	-0.139315f,
+	0.988254f,
+	-0.0628056f,
+	-0.230813f,
+	0.967463f,
+	-0.103639f,
+	-0.24543f,
+	0.966984f,
+	-0.0686046f,
+	-0.189537f,
+	0.981091f,
+	0.0391957f,
+	0.151487f,
+	0.988375f,
+	0.0128779f,
+	0.16936f,
+	0.984329f,
+	0.0491336f,
+	0.218781f,
+	0.968894f,
+	0.115672f,
+	0.279098f,
+	0.952669f,
+	0.120523f,
+	0.344688f,
+	0.931221f,
+	0.118397f,
+	0.359727f,
+	0.914297f,
+	0.186165f,
+	0.326371f,
+	0.918389f,
+	0.223703f,
+	0.361839f,
+	0.886899f,
+	0.287197f,
+	-0.000924981f,
+	0.965442f,
+	0.260617f,
+	-0.321168f,
+	0.914653f,
+	0.24548f,
+	-0.23578f,
+	0.933549f,
+	0.269988f,
+	-0.0519805f,
+	0.910912f,
+	0.409313f,
+	-0.120702f,
+	0.947306f,
+	0.296721f,
+	-0.257649f,
+	0.956241f,
+	0.138637f,
+	-0.340179f,
+	0.924947f,
+	0.169564f,
+	-0.415425f,
+	0.90289f,
+	0.110507f,
+	-0.41038f,
+	0.91038f,
+	0.0528755f,
+	-0.447459f,
+	0.881081f,
+	0.153222f,
+	-0.521314f,
+	0.820871f,
+	0.233245f,
+	-0.470597f,
+	0.83806f,
+	0.27603f,
+	-0.530303f,
+	0.820989f,
+	0.211554f,
+	-0.59428f,
+	0.795918f,
+	0.11552f,
+	-0.564828f,
+	0.823165f,
+	0.0580397f,
+	-0.435129f,
+	0.882511f,
+	0.17843f,
+	-0.320859f,
+	0.891866f,
+	0.318787f,
+	-0.272192f,
+	0.902535f,
+	0.33368f,
+	-0.476067f,
+	0.856837f,
+	0.197967f,
+	-0.671403f,
+	0.739101f,
+	0.0543033f,
+	-0.548598f,
+	0.834125f,
+	0.0572312f,
+	-0.459373f,
+	0.883769f,
+	-0.0890421f,
+	-0.194341f,
+	0.977153f,
+	-0.0860449f,
+	0.0638196f,
+	0.997784f,
+	0.0188364f,
+	0.119241f,
+	0.989813f,
+	0.0777976f,
+	-0.189205f,
+	0.978439f,
+	-0.0828203f,
+	-0.328042f,
+	0.913868f,
+	-0.239234f,
+	0.0439005f,
+	0.976566f,
+	-0.210694f,
+	0.345392f,
+	0.929362f,
+	-0.130351f,
+	0.531991f,
+	0.841029f,
+	-0.0982628f,
+	0.385958f,
+	0.912021f,
+	-0.13876f,
+	0.00996624f,
+	0.998173f,
+	-0.059598f,
+	-0.0397997f,
+	0.999182f,
+	0.00710574f,
+	0.22423f,
+	0.974041f,
+	-0.0310806f,
+	0.399529f,
+	0.909843f,
+	-0.112084f,
+	0.472825f,
+	0.876316f,
+	-0.0922302f,
+	0.567959f,
+	0.818431f,
+	-0.0871407f,
+	0.591097f,
+	0.802347f,
+	-0.0827227f,
+	0.294969f,
+	0.954774f,
+	-0.0374031f,
+	0.136562f,
+	0.986139f,
+	0.0942395f,
+	0.140836f,
+	0.978895f,
+	0.148089f,
+	0.208743f,
+	0.962024f,
+	0.175889f,
+	0.331657f,
+	0.931412f,
+	0.149918f,
+	0.32318f,
+	0.945148f,
+	0.0474422f,
+	0.378499f,
+	0.925602f,
+	0.000447487f,
+	0.240237f,
+	0.969087f,
+	-0.0561752f,
+	0.0676245f,
+	0.996927f,
+	-0.0395359f,
+	-0.154966f,
+	0.962822f,
+	-0.221268f,
+	-0.087338f,
+	0.971663f,
+	-0.219642f,
+	0.144581f,
+	0.983839f,
+	-0.105631f,
+	-0.0884322f,
+	0.993076f,
+	-0.0773351f,
+	-0.293638f,
+	0.94457f,
+	-0.146848f,
+	-0.135408f,
+	0.983934f,
+	-0.116358f,
+	-0.103543f,
+	0.987494f,
+	-0.11889f,
+	-0.104597f,
+	0.98248f,
+	-0.15425f,
+	-0.176622f,
+	0.962045f,
+	-0.208023f,
+	-0.325467f,
+	0.923065f,
+	-0.204992f,
+	-0.403927f,
+	0.903415f,
+	-0.143824f,
+	0.344389f,
+	0.929213f,
+	0.134014f,
+	0.233815f,
+	0.972165f,
+	0.0150206f,
+	0.162621f,
+	0.985815f,
+	-0.0415186f,
+	0.195602f,
+	0.980526f,
+	0.0175561f,
+	0.28987f,
+	0.950331f,
+	0.113346f,
+	0.255987f,
+	0.942074f,
+	0.216718f,
+	0.263495f,
+	0.890351f,
+	0.371275f,
+	0.315069f,
+	0.864416f,
+	0.391812f,
+	0.0646003f,
+	0.916859f,
+	0.39395f,
+	-0.213657f,
+	0.9234f,
+	0.318877f,
+	-0.307635f,
+	0.926495f,
+	0.216719f,
+	-0.201977f,
+	0.923807f,
+	0.325246f,
+	-0.0210673f,
+	0.916391f,
+	0.399731f,
+	-0.17042f,
+	0.919713f,
+	0.353674f,
+	-0.316748f,
+	0.899919f,
+	0.299695f,
+	-0.294061f,
+	0.92391f,
+	0.244781f,
+	-0.396636f,
+	0.905857f,
+	0.14867f,
+	-0.523471f,
+	0.83043f,
+	0.190696f,
+	-0.568887f,
+	0.791598f,
+	0.223024f,
+	-0.446362f,
+	0.844948f,
+	0.294659f,
+	-0.453253f,
+	0.853996f,
+	0.255447f,
+	-0.541011f,
+	0.824142f,
+	0.167623f,
+	-0.550736f,
+	0.81694f,
+	0.171169f,
+	-0.53915f,
+	0.819657f,
+	0.193597f,
+	-0.444412f,
+	0.862352f,
+	0.242584f,
+	-0.285315f,
+	0.907749f,
+	0.30755f,
+	-0.329395f,
+	0.886574f,
+	0.324786f,
+	-0.610599f,
+	0.78547f,
+	0.101022f,
+	-0.543486f,
+	0.838015f,
+	0.0485148f,
+	-0.319704f,
+	0.945394f,
+	0.0634074f,
+	-0.262212f,
+	0.963421f,
+	-0.055354f,
+	0.000253525f,
+	0.995852f,
+	0.0909893f,
+	0.105619f,
+	0.991464f,
+	0.0764441f,
+	0.0245363f,
+	0.999682f,
+	-0.00586488f,
+	-0.22917f,
+	0.926966f,
+	-0.29701f,
+	-0.0159754f,
+	0.943632f,
+	-0.33061f,
+	0.309925f,
+	0.920539f,
+	-0.237812f,
+	0.48714f,
+	0.850311f,
+	-0.199165f,
+	0.288684f,
+	0.955866f,
+	-0.0546085f,
+	-0.0787222f,
+	0.994967f,
+	0.0619939f,
+	0.0273777f,
+	0.99772f,
+	0.0616831f,
+	0.291481f,
+	0.955243f,
+	-0.0505022f,
+	0.438727f,
+	0.89664f,
+	-0.0596253f,
+	0.485213f,
+	0.871546f,
+	-0.0705428f,
+	0.5406f,
+	0.839608f,
+	-0.0530067f,
+	0.49511f,
+	0.866937f,
+	0.0573254f,
+	0.280189f,
+	0.947413f,
+	0.154605f,
+	0.158816f,
+	0.979113f,
+	0.126949f,
+	0.168625f,
+	0.983554f,
+	0.0647105f,
+	0.187616f,
+	0.98216f,
+	0.0127302f,
+	0.334023f,
+	0.942557f,
+	0.00379923f,
+	0.401318f,
+	0.914355f,
+	0.0538517f,
+	0.424638f,
+	0.905172f,
+	0.0185914f,
+	0.289448f,
+	0.956081f,
+	-0.0461475f,
+	0.0899479f,
+	0.980871f,
+	-0.172633f,
+	-0.00560791f,
+	0.970967f,
+	-0.23915f,
+	-0.153691f,
+	0.938842f,
+	-0.308149f,
+	-0.0450622f,
+	0.984719f,
+	-0.168219f,
+	-0.0818032f,
+	0.994271f,
+	0.0687937f,
+	-0.254478f,
+	0.967062f,
+	-0.0056871f,
+	-0.190127f,
+	0.974114f,
+	-0.122284f,
+	-0.0615121f,
+	0.986397f,
+	-0.152435f,
+	-0.0478084f,
+	0.984317f,
+	-0.169808f,
+	-0.157882f,
+	0.979732f,
+	-0.123284f,
+	-0.307356f,
+	0.93941f,
+	-0.151791f,
+	-0.432596f,
+	0.869844f,
+	-0.237133f,
+	0.35469f,
+	0.923204f,
+	0.147951f,
+	0.317903f,
+	0.938384f,
+	0.135547f,
+	0.209784f,
+	0.976723f,
+	0.0447562f,
+	0.188401f,
+	0.980806f,
+	-0.0502544f,
+	0.153267f,
+	0.987748f,
+	-0.0293859f,
+	0.102074f,
+	0.966336f,
+	0.236167f,
+	0.128463f,
+	0.933972f,
+	0.333456f,
+	0.308207f,
+	0.882627f,
+	0.354934f,
+	0.141883f,
+	0.91146f,
+	0.386148f,
+	-0.174863f,
+	0.945456f,
+	0.274837f,
+	-0.248524f,
+	0.937312f,
+	0.244299f,
+	-0.268339f,
+	0.945888f,
+	0.182456f,
+	-0.0843285f,
+	0.960488f,
+	0.265238f,
+	-0.151825f,
+	0.934815f,
+	0.321045f,
+	-0.286064f,
+	0.900967f,
+	0.326231f,
+	-0.240679f,
+	0.904695f,
+	0.351568f,
+	-0.362345f,
+	0.88785f,
+	0.2836f,
+	-0.538142f,
+	0.813225f,
+	0.221511f,
+	-0.57294f,
+	0.797677f,
+	0.188284f,
+	-0.51091f,
+	0.838129f,
+	0.191079f,
+	-0.412611f,
+	0.865658f,
+	0.283528f,
+	-0.528395f,
+	0.821979f,
+	0.212483f,
+	-0.579097f,
+	0.792111f,
+	0.192891f,
+	-0.502268f,
+	0.843036f,
+	0.192398f,
+	-0.402738f,
+	0.896524f,
+	0.184518f,
+	-0.323371f,
+	0.930281f,
+	0.173231f,
+	-0.341027f,
+	0.92193f,
+	0.183699f,
+	-0.49586f,
+	0.861123f,
+	0.112209f,
+	-0.562176f,
+	0.82675f,
+	-0.0210484f,
+	-0.29935f,
+	0.952705f,
+	0.0523715f,
+	-0.273263f,
+	0.96182f,
+	0.0151701f,
+	-0.127856f,
+	0.984802f,
+	0.117552f,
+	0.16681f,
+	0.967622f,
+	0.189425f,
+	0.219885f,
+	0.966852f,
+	0.1298f,
+	0.0444925f,
+	0.994595f,
+	-0.093817f,
+	-0.0559771f,
+	0.948894f,
+	-0.31059f,
+	0.229668f,
+	0.93439f,
+	-0.272337f,
+	0.391338f,
+	0.907289f,
+	-0.153889f,
+	0.215699f,
+	0.975228f,
+	0.0490428f,
+	-0.1202f,
+	0.992098f,
+	0.0359644f,
+	0.0568932f,
+	0.997098f,
+	0.0505773f,
+	0.369571f,
+	0.928802f,
+	0.0272646f,
+	0.435039f,
+	0.898005f,
+	-0.0657877f,
+	0.45866f,
+	0.886154f,
+	-0.0660444f,
+	0.484136f,
+	0.874975f,
+	0.00559808f,
+	0.464546f,
+	0.884206f,
+	0.0487577f,
+	0.311084f,
+	0.947795f,
+	0.0700806f,
+	0.215922f,
+	0.975139f,
+	0.0498078f,
+	0.229266f,
+	0.973122f,
+	-0.0216826f,
+	0.269391f,
+	0.956816f,
+	-0.109228f,
+	0.297276f,
+	0.941247f,
+	-0.160256f,
+	0.352506f,
+	0.931874f,
+	-0.0857318f,
+	0.363875f,
+	0.92958f,
+	-0.0589632f,
+	0.421372f,
+	0.901903f,
+	0.094954f,
+	0.220959f,
+	0.972251f,
+	-0.0768509f,
+	0.0552433f,
+	0.994093f,
+	-0.0934223f,
+	-0.134577f,
+	0.980922f,
+	-0.140288f,
+	-0.247593f,
+	0.953903f,
+	-0.169607f,
+	-0.238891f,
+	0.96987f,
+	-0.0477791f,
+	-0.130123f,
+	0.990325f,
+	-0.0482061f,
+	0.00814361f,
+	0.986901f,
+	-0.161119f,
+	-0.0740374f,
+	0.970051f,
+	-0.231345f,
+	-0.135238f,
+	0.990526f,
+	-0.0238593f,
+	-0.204897f,
+	0.978574f,
+	0.0202582f,
+	-0.205889f,
+	0.977122f,
+	-0.0533174f,
+	-0.236999f,
+	0.963982f,
+	-0.120711f,
+	0.399314f,
+	0.905653f,
+	0.142621f,
+	0.334882f,
+	0.936094f,
+	0.107618f,
+	0.310789f,
+	0.943606f,
+	0.114093f,
+	0.298988f,
+	0.952609f,
+	0.0560503f,
+	0.00373107f,
+	0.999894f,
+	-0.0140921f,
+	-0.127729f,
+	0.983543f,
+	0.12778f,
+	0.134365f,
+	0.969696f,
+	0.204046f,
+	0.250753f,
+	0.938877f,
+	0.235867f,
+	0.172971f,
+	0.901933f,
+	0.395725f,
+	-0.0661635f,
+	0.938085f,
+	0.340027f,
+	-0.190026f,
+	0.944561f,
+	0.267758f,
+	-0.246469f,
+	0.952194f,
+	0.180498f,
+	-0.199636f,
+	0.962622f,
+	0.183041f,
+	-0.204824f,
+	0.924659f,
+	0.321019f,
+	-0.345906f,
+	0.869848f,
+	0.351729f,
+	-0.272906f,
+	0.86539f,
+	0.420265f,
+	-0.23738f,
+	0.86577f,
+	0.44056f,
+	-0.476597f,
+	0.838274f,
+	0.264863f,
+	-0.549692f,
+	0.815624f,
+	0.180542f,
+	-0.521659f,
+	0.837826f,
+	0.160993f,
+	-0.461012f,
+	0.874551f,
+	0.150426f,
+	-0.498406f,
+	0.858536f,
+	0.120447f,
+	-0.538861f,
+	0.837113f,
+	0.0941878f,
+	-0.51696f,
+	0.855065f,
+	0.0401927f,
+	-0.464195f,
+	0.882878f,
+	0.0710582f,
+	-0.339798f,
+	0.923706f,
+	0.176929f,
+	-0.307071f,
+	0.929998f,
+	0.202016f,
+	-0.435636f,
+	0.887155f,
+	0.152245f,
+	-0.50925f,
+	0.856289f,
+	0.0862179f,
+	-0.352613f,
+	0.935762f,
+	-0.00363908f,
+	-0.24432f,
+	0.969666f,
+	0.0074465f,
+	-0.223693f,
+	0.974193f,
+	-0.0301471f,
+	0.0924619f,
+	0.993171f,
+	0.071143f,
+	0.248444f,
+	0.955155f,
+	0.161104f,
+	0.25541f,
+	0.957577f,
+	0.133462f,
+	0.152224f,
+	0.983188f,
+	-0.100846f,
+	0.175485f,
+	0.954332f,
+	-0.241774f,
+	0.229817f,
+	0.96697f,
+	-0.110245f,
+	0.104087f,
+	0.990176f,
+	0.0933667f,
+	-0.0251916f,
+	0.99085f,
+	0.132593f,
+	0.0299952f,
+	0.999356f,
+	-0.0197015f,
+	0.374506f,
+	0.927216f,
+	-0.00387803f,
+	0.523769f,
+	0.851516f,
+	-0.0242066f,
+	0.412003f,
+	0.903869f,
+	-0.115217f,
+	0.44751f,
+	0.89427f,
+	-0.00401492f,
+	0.502351f,
+	0.864643f,
+	-0.0060566f,
+	0.261187f,
+	0.953407f,
+	-0.150988f,
+	0.201827f,
+	0.974066f,
+	-0.102283f,
+	0.328474f,
+	0.941424f,
+	-0.0763319f,
+	0.327281f,
+	0.932573f,
+	-0.152297f,
+	0.312159f,
+	0.927432f,
+	-0.205977f,
+	0.304739f,
+	0.922289f,
+	-0.237734f,
+	0.291399f,
+	0.941708f,
+	-0.168142f,
+	0.325323f,
+	0.94222f,
+	-0.0799213f,
+	0.270502f,
+	0.962573f,
+	-0.0167793f,
+	-0.00135827f,
+	0.998382f,
+	0.0568385f,
+	-0.0464612f,
+	0.993882f,
+	0.100202f,
+	-0.163616f,
+	0.983349f,
+	-0.0790802f,
+	-0.219372f,
+	0.956704f,
+	-0.191292f,
+	-0.0798083f,
+	0.976764f,
+	-0.198904f,
+	-0.0362508f,
+	0.993161f,
+	-0.11098f,
+	-0.194493f,
+	0.976824f,
+	0.0893684f,
+	-0.303508f,
+	0.929002f,
+	0.211751f,
+	-0.120982f,
+	0.967912f,
+	0.220249f,
+	-0.126864f,
+	0.979558f,
+	0.156117f,
+	-0.190168f,
+	0.969475f,
+	0.154773f,
+	0.442277f,
+	0.894635f,
+	0.0633978f,
+	0.351901f,
+	0.932017f,
+	0.0866602f,
+	0.271089f,
+	0.951246f,
+	0.147111f,
+	0.263373f,
+	0.940704f,
+	0.2138f,
+	0.0780789f,
+	0.961317f,
+	0.264145f,
+	-0.165165f,
+	0.972713f,
+	0.162944f,
+	0.054241f,
+	0.96435f,
+	0.259011f,
+	0.119009f,
+	0.928226f,
+	0.352467f,
+	0.062551f,
+	0.905107f,
+	0.420558f,
+	-0.0376962f,
+	0.903166f,
+	0.427633f,
+	-0.119235f,
+	0.864868f,
+	0.487634f,
+	-0.107099f,
+	0.89512f,
+	0.43277f,
+	-0.228241f,
+	0.933808f,
+	0.275515f,
+	-0.34367f,
+	0.891778f,
+	0.294319f,
+	-0.360994f,
+	0.863066f,
+	0.353271f,
+	-0.329935f,
+	0.870805f,
+	0.364474f,
+	-0.225803f,
+	0.873787f,
+	0.430708f,
+	-0.324138f,
+	0.85889f,
+	0.396537f,
+	-0.511071f,
+	0.812187f,
+	0.281352f,
+	-0.475013f,
+	0.824987f,
+	0.306202f,
+	-0.392033f,
+	0.887928f,
+	0.240612f,
+	-0.45534f,
+	0.876633f,
+	0.155499f,
+	-0.547025f,
+	0.829694f,
+	0.111226f,
+	-0.496064f,
+	0.862275f,
+	0.101992f,
+	-0.479515f,
+	0.87606f,
+	0.0508306f,
+	-0.424535f,
+	0.90465f,
+	0.0371277f,
+	-0.362147f,
+	0.919497f,
+	0.152886f,
+	-0.412742f,
+	0.878092f,
+	0.24207f,
+	-0.402299f,
+	0.893898f,
+	0.197745f,
+	-0.26297f,
+	0.963672f,
+	0.0467231f,
+	-0.219075f,
+	0.975598f,
+	-0.0146319f,
+	-0.186267f,
+	0.980099f,
+	-0.0686323f,
+	-0.0357984f,
+	0.992879f,
+	-0.113625f,
+	0.180598f,
+	0.983509f,
+	0.00973344f,
+	0.28459f,
+	0.957748f,
+	0.0415635f,
+	0.350884f,
+	0.934731f,
+	0.0561944f,
+	0.201029f,
+	0.975728f,
+	-0.0868401f,
+	0.10163f,
+	0.994331f,
+	-0.0312587f,
+	-0.0498772f,
+	0.998294f,
+	0.0303674f,
+	0.0144565f,
+	0.996475f,
+	0.082632f,
+	0.17671f,
+	0.984206f,
+	0.0105968f,
+	0.384098f,
+	0.921983f,
+	-0.049144f,
+	0.526508f,
+	0.848767f,
+	-0.048829f,
+	0.451141f,
+	0.890087f,
+	-0.0649363f,
+	0.349978f,
+	0.927792f,
+	-0.129298f,
+	0.525028f,
+	0.849511f,
+	-0.051734f,
+	0.403316f,
+	0.902994f,
+	-0.148114f,
+	0.146493f,
+	0.950082f,
+	-0.275472f,
+	0.257494f,
+	0.953663f,
+	-0.155639f,
+	0.363336f,
+	0.930153f,
+	-0.0529431f,
+	0.407301f,
+	0.911128f,
+	-0.0628641f,
+	0.309341f,
+	0.935596f,
+	-0.170201f,
+	0.234661f,
+	0.952473f,
+	-0.194238f,
+	0.248922f,
+	0.950735f,
+	-0.18477f,
+	0.176271f,
+	0.982701f,
+	-0.0568089f,
+	-0.0817466f,
+	0.996475f,
+	0.0188703f,
+	-0.0390696f,
+	0.99855f,
+	0.0370285f,
+	0.0392849f,
+	0.997614f,
+	0.0567754f,
+	-0.165147f,
+	0.985538f,
+	-0.0379532f,
+	-0.216905f,
+	0.97598f,
+	0.020392f,
+	-0.25871f,
+	0.942954f,
+	0.209538f,
+	-0.318314f,
+	0.87576f,
+	0.362933f,
+	-0.238112f,
+	0.92993f,
+	0.280235f,
+	-0.11178f,
+	0.963059f,
+	0.244995f,
+	-0.156033f,
+	0.939968f,
+	0.303502f,
+	-0.219558f,
+	0.904757f,
+	0.364977f,
+	0.29059f,
+	0.953077f,
+	-0.0848643f,
+	0.282679f,
+	0.959209f,
+	-0.00326087f,
+	0.165956f,
+	0.986031f,
+	0.0141778f,
+	0.145774f,
+	0.971701f,
+	0.185869f,
+	0.0971539f,
+	0.92606f,
+	0.364656f,
+	-0.126893f,
+	0.938591f,
+	0.320851f,
+	-0.158756f,
+	0.918948f,
+	0.361014f,
+	0.0576791f,
+	0.877286f,
+	0.47649f,
+	0.151465f,
+	0.884095f,
+	0.442079f,
+	-0.0842052f,
+	0.912347f,
+	0.400665f,
+	-0.236928f,
+	0.870703f,
+	0.430978f,
+	-0.0173538f,
+	0.858153f,
+	0.513101f,
+	-0.0453547f,
+	0.868839f,
+	0.493013f,
+	-0.308698f,
+	0.88215f,
+	0.355692f,
+	-0.391959f,
+	0.868398f,
+	0.303732f,
+	-0.360504f,
+	0.877037f,
+	0.317558f,
+	-0.289644f,
+	0.88703f,
+	0.359561f,
+	-0.323579f,
+	0.85156f,
+	0.412484f,
+	-0.483914f,
+	0.781191f,
+	0.39442f,
+	-0.428744f,
+	0.813324f,
+	0.393297f,
+	-0.337017f,
+	0.871068f,
+	0.357294f,
+	-0.382215f,
+	0.837599f,
+	0.390306f,
+	-0.472752f,
+	0.816976f,
+	0.330237f,
+	-0.454132f,
+	0.848356f,
+	0.272131f,
+	-0.386129f,
+	0.879637f,
+	0.277745f,
+	-0.408175f,
+	0.895196f,
+	0.178931f,
+	-0.461039f,
+	0.873474f,
+	0.15648f,
+	-0.444429f,
+	0.876284f,
+	0.186035f,
+	-0.324725f,
+	0.941951f,
+	0.085336f,
+	-0.200261f,
+	0.979518f,
+	0.0209972f,
+	-0.146655f,
+	0.98862f,
+	0.0335086f,
+	-0.105669f,
+	0.986512f,
+	-0.125016f,
+	-0.0113758f,
+	0.977088f,
+	-0.21253f,
+	0.125756f,
+	0.969156f,
+	-0.211948f,
+	0.231535f,
+	0.947003f,
+	-0.222657f,
+	0.267937f,
+	0.954488f,
+	-0.131005f,
+	0.231299f,
+	0.971277f,
+	0.055871f,
+	0.0809071f,
+	0.991774f,
+	0.0991925f,
+	0.000207679f,
+	0.999953f,
+	0.00973996f,
+	0.0247831f,
+	0.993578f,
+	-0.110402f,
+	0.181304f,
+	0.979201f,
+	-0.0910725f,
+	0.390907f,
+	0.919373f,
+	-0.0441033f,
+	0.523664f,
+	0.849877f,
+	-0.0590321f,
+	0.487061f,
+	0.873094f,
+	-0.0218679f,
+	0.442794f,
+	0.892691f,
+	-0.0838822f,
+	0.486459f,
+	0.850567f,
+	-0.199735f,
+	0.449595f,
+	0.886474f,
+	-0.10967f,
+	0.172841f,
+	0.979158f,
+	-0.106661f,
+	0.134151f,
+	0.987388f,
+	-0.084069f,
+	0.292984f,
+	0.955775f,
+	-0.0255695f,
+	0.391346f,
+	0.920229f,
+	-0.00512785f,
+	0.418943f,
+	0.907957f,
+	0.00999318f,
+	0.324262f,
+	0.936698f,
+	-0.1321f,
+	0.190686f,
+	0.957473f,
+	-0.216527f,
+	0.0619887f,
+	0.993289f,
+	-0.097645f,
+	-0.0829846f,
+	0.99633f,
+	-0.0209901f,
+	-0.0646754f,
+	0.997763f,
+	-0.0169202f,
+	-0.0614217f,
+	0.996217f,
+	0.0614677f,
+	-0.189778f,
+	0.963623f,
+	0.188191f,
+	-0.363861f,
+	0.896503f,
+	0.25276f,
+	-0.348308f,
+	0.859996f,
+	0.372945f,
+	-0.264506f,
+	0.906439f,
+	0.329249f,
+	-0.140762f,
+	0.939057f,
+	0.31362f,
+	-0.154941f,
+	0.944783f,
+	0.288752f,
+	-0.237481f,
+	0.904164f,
+	0.355093f,
+	-0.314839f,
+	0.867723f,
+	0.38462f,
+	0.199283f,
+	0.97456f,
+	-0.102566f,
+	0.290362f,
+	0.956152f,
+	-0.0382605f,
+	0.163603f,
+	0.98144f,
+	-0.10005f,
+	-0.0845537f,
+	0.992536f,
+	-0.0878854f,
+	-0.0995819f,
+	0.988025f,
+	0.117859f,
+	-0.128698f,
+	0.94862f,
+	0.289062f,
+	-0.181988f,
+	0.934999f,
+	0.304396f,
+	0.0121717f,
+	0.953274f,
+	0.301863f,
+	0.15771f,
+	0.909532f,
+	0.384551f,
+	-0.030083f,
+	0.904525f,
+	0.425359f,
+	-0.262213f,
+	0.918561f,
+	0.295788f,
+	-0.150427f,
+	0.932893f,
+	0.327234f,
+	-0.0433771f,
+	0.888915f,
+	0.456013f,
+	-0.194904f,
+	0.882492f,
+	0.428042f,
+	-0.359771f,
+	0.865678f,
+	0.348089f,
+	-0.358104f,
+	0.856009f,
+	0.37284f,
+	-0.334766f,
+	0.853069f,
+	0.400257f,
+	-0.382047f,
+	0.809514f,
+	0.445788f,
+	-0.440041f,
+	0.772384f,
+	0.458024f,
+	-0.392897f,
+	0.847233f,
+	0.357532f,
+	-0.352962f,
+	0.862399f,
+	0.362885f,
+	-0.432462f,
+	0.797784f,
+	0.42014f,
+	-0.40741f,
+	0.807767f,
+	0.426063f,
+	-0.417686f,
+	0.831448f,
+	0.366378f,
+	-0.406533f,
+	0.835025f,
+	0.370761f,
+	-0.302917f,
+	0.831265f,
+	0.466089f,
+	-0.354465f,
+	0.85583f,
+	0.376708f,
+	-0.320875f,
+	0.930472f,
+	0.17681f,
+	-0.210666f,
+	0.977556f,
+	0.00208309f,
+	-0.202152f,
+	0.976764f,
+	-0.0711849f,
+	-0.0734606f,
+	0.993473f,
+	-0.0872598f,
+	0.0104554f,
+	0.979699f,
+	-0.2002f,
+	0.0812548f,
+	0.981491f,
+	-0.173417f,
+	0.133484f,
+	0.953074f,
+	-0.271721f,
+	0.239226f,
+	0.941558f,
+	-0.23715f,
+	0.0986638f,
+	0.979162f,
+	-0.177504f,
+	0.0167662f,
+	0.999807f,
+	0.0102821f,
+	0.0608252f,
+	0.989728f,
+	0.129377f,
+	0.193478f,
+	0.976369f,
+	0.0962839f,
+	0.105893f,
+	0.986391f,
+	-0.125774f,
+	0.159018f,
+	0.972139f,
+	-0.17222f,
+	0.348199f,
+	0.916375f,
+	-0.197521f,
+	0.506641f,
+	0.853561f,
+	-0.121441f,
+	0.438954f,
+	0.895697f,
+	-0.0710352f,
+	0.508211f,
+	0.861156f,
+	-0.0114456f,
+	0.538629f,
+	0.837641f,
+	-0.0907543f,
+	0.350973f,
+	0.934296f,
+	-0.0625226f,
+	0.130826f,
+	0.991364f,
+	0.00901604f,
+	0.142249f,
+	0.989581f,
+	0.0222434f,
+	0.314713f,
+	0.948656f,
+	-0.0317428f,
+	0.413134f,
+	0.902882f,
+	-0.118849f,
+	0.421178f,
+	0.889709f,
+	-0.176143f,
+	0.40304f,
+	0.897538f,
+	-0.178843f,
+	0.190553f,
+	0.961133f,
+	-0.199782f,
+	-0.0704956f,
+	0.989551f,
+	-0.125772f,
+	-0.145721f,
+	0.988685f,
+	0.035603f,
+	-0.158165f,
+	0.979549f,
+	0.124366f,
+	-0.141884f,
+	0.945197f,
+	0.294061f,
+	-0.282634f,
+	0.89813f,
+	0.336869f,
+	-0.398539f,
+	0.847577f,
+	0.350398f,
+	-0.326007f,
+	0.891199f,
+	0.31541f,
+	-0.257935f,
+	0.930645f,
+	0.259558f,
+	-0.189362f,
+	0.933131f,
+	0.305628f,
+	-0.181998f,
+	0.908713f,
+	0.375656f,
+	-0.284451f,
+	0.857477f,
+	0.428743f,
+	-0.324962f,
+	0.834267f,
+	0.445419f,
+	0.162722f,
+	0.967013f,
+	-0.19598f,
+	0.196801f,
+	0.96943f,
+	-0.146541f,
+	0.171798f,
+	0.98444f,
+	0.0369126f,
+	-0.0614366f,
+	0.993745f,
+	0.0932502f,
+	-0.263807f,
+	0.962515f,
+	0.063023f,
+	-0.262644f,
+	0.943232f,
+	0.203304f,
+	-0.183229f,
+	0.945939f,
+	0.267632f,
+	-0.0512022f,
+	0.955564f,
+	0.290302f,
+	0.0500709f,
+	0.932925f,
+	0.356571f,
+	-0.017607f,
+	0.930336f,
+	0.366286f,
+	-0.141345f,
+	0.917863f,
+	0.370876f,
+	-0.196664f,
+	0.921785f,
+	0.334121f,
+	-0.123639f,
+	0.931227f,
+	0.342826f,
+	-0.166673f,
+	0.929929f,
+	0.327799f,
+	-0.365314f,
+	0.882118f,
+	0.297345f,
+	-0.422119f,
+	0.842584f,
+	0.334465f,
+	-0.378137f,
+	0.838603f,
+	0.392119f,
+	-0.433991f,
+	0.800503f,
+	0.413336f,
+	-0.373446f,
+	0.819157f,
+	0.435339f,
+	-0.321191f,
+	0.877582f,
+	0.35593f,
+	-0.410179f,
+	0.839146f,
+	0.357194f,
+	-0.450466f,
+	0.792998f,
+	0.410164f,
+	-0.383405f,
+	0.853385f,
+	0.353178f,
+	-0.361072f,
+	0.88078f,
+	0.306355f,
+	-0.471517f,
+	0.844691f,
+	0.253315f,
+	-0.399349f,
+	0.852332f,
+	0.337713f,
+	-0.193735f,
+	0.889811f,
+	0.413163f,
+	-0.0964184f,
+	0.953204f,
+	0.28654f,
+	-0.0731968f,
+	0.993583f,
+	0.0862245f,
+	-0.107213f,
+	0.990087f,
+	-0.0907379f,
+	-0.0139207f,
+	0.976637f,
+	-0.214443f,
+	-0.00517032f,
+	0.976967f,
+	-0.213328f,
+	0.032564f,
+	0.990278f,
+	-0.135238f,
+	0.193406f,
+	0.974103f,
+	-0.117123f,
+	0.137302f,
+	0.989014f,
+	-0.0547632f,
+	0.0149454f,
+	0.997504f,
+	0.06901f,
+	-0.0673257f,
+	0.995987f,
+	0.0589639f,
+	0.00671915f,
+	0.997834f,
+	0.0654375f,
+	0.236496f,
+	0.961793f,
+	0.137925f,
+	0.296243f,
+	0.953456f,
+	0.0562338f,
+	0.227931f,
+	0.966806f,
+	-0.11547f,
+	0.392626f,
+	0.909868f,
+	-0.134105f,
+	0.455312f,
+	0.880641f,
+	-0.131003f,
+	0.402519f,
+	0.906647f,
+	-0.126375f,
+	0.459051f,
+	0.879656f,
+	-0.124406f,
+	0.531911f,
+	0.846049f,
+	-0.0356662f,
+	0.366681f,
+	0.930218f,
+	0.0155094f,
+	0.101768f,
+	0.992829f,
+	-0.0627213f,
+	0.169781f,
+	0.984995f,
+	-0.0309622f,
+	0.383193f,
+	0.921183f,
+	-0.0677109f,
+	0.483652f,
+	0.86784f,
+	-0.113728f,
+	0.481548f,
+	0.864447f,
+	-0.144373f,
+	0.322376f,
+	0.925659f,
+	-0.198063f,
+	0.121084f,
+	0.992307f,
+	-0.0257868f,
+	-0.189201f,
+	0.97803f,
+	0.0875253f,
+	-0.272481f,
+	0.941614f,
+	0.197779f,
+	-0.28107f,
+	0.929157f,
+	0.240138f,
+	-0.316277f,
+	0.890261f,
+	0.327726f,
+	-0.284096f,
+	0.875896f,
+	0.389994f,
+	-0.304764f,
+	0.879665f,
+	0.365114f,
+	-0.295018f,
+	0.913863f,
+	0.278959f,
+	-0.233864f,
+	0.913909f,
+	0.331779f,
+	-0.25276f,
+	0.886942f,
+	0.386584f,
+	-0.254968f,
+	0.846261f,
+	0.467797f,
+	-0.324913f,
+	0.811645f,
+	0.485452f,
+	-0.330966f,
+	0.801562f,
+	0.497956f,
+	0.166281f,
+	0.984047f,
+	-0.0632562f,
+	0.102172f,
+	0.992786f,
+	-0.0627485f,
+	-0.0446214f,
+	0.999004f,
+	-0.000325965f,
+	-0.137659f,
+	0.980871f,
+	0.13763f,
+	-0.270041f,
+	0.94552f,
+	0.18185f,
+	-0.300503f,
+	0.932348f,
+	0.201063f,
+	-0.224552f,
+	0.960314f,
+	0.165452f,
+	-0.109331f,
+	0.978965f,
+	0.17226f,
+	0.0684226f,
+	0.972288f,
+	0.223551f,
+	-0.0281009f,
+	0.965962f,
+	0.257154f,
+	-0.203983f,
+	0.927334f,
+	0.313757f,
+	-0.170837f,
+	0.935943f,
+	0.307937f,
+	-0.0844776f,
+	0.951083f,
+	0.29716f,
+	-0.140439f,
+	0.935294f,
+	0.32481f,
+	-0.360713f,
+	0.879742f,
+	0.309743f,
+	-0.466354f,
+	0.845167f,
+	0.261162f,
+	-0.425659f,
+	0.859392f,
+	0.283303f,
+	-0.470194f,
+	0.836884f,
+	0.280256f,
+	-0.410878f,
+	0.856359f,
+	0.312777f,
+	-0.293557f,
+	0.864483f,
+	0.408036f,
+	-0.429097f,
+	0.81157f,
+	0.396523f,
+	-0.438172f,
+	0.837036f,
+	0.327683f,
+	-0.303084f,
+	0.911643f,
+	0.277574f,
+	-0.346895f,
+	0.902405f,
+	0.255594f,
+	-0.444307f,
+	0.857916f,
+	0.258015f,
+	-0.440123f,
+	0.885255f,
+	0.150386f,
+	-0.246442f,
+	0.965625f,
+	0.0826743f,
+	-0.0242341f,
+	0.995753f,
+	0.0888192f,
+	0.128537f,
+	0.987977f,
+	0.085905f,
+	0.10291f,
+	0.993755f,
+	-0.0431449f,
+	0.0280177f,
+	0.986869f,
+	-0.159076f,
+	-0.0318503f,
+	0.988236f,
+	-0.149584f,
+	0.00777626f,
+	0.97932f,
+	-0.202168f,
+	0.111085f,
+	0.970769f,
+	-0.212762f,
+	-0.00220326f,
+	0.997417f,
+	-0.0718009f,
+	-0.0152092f,
+	0.997571f,
+	0.0679693f,
+	0.0100591f,
+	0.998816f,
+	0.0476033f,
+	-0.00783919f,
+	0.999851f,
+	-0.0153546f,
+	0.1632f,
+	0.986482f,
+	-0.0148045f,
+	0.356551f,
+	0.93118f,
+	0.0760001f,
+	0.33409f,
+	0.940767f,
+	0.0578066f,
+	0.378555f,
+	0.924836f,
+	-0.0370621f,
+	0.481573f,
+	0.874509f,
+	-0.0576253f,
+	0.443664f,
+	0.890369f,
+	-0.102011f,
+	0.449245f,
+	0.88434f,
+	-0.126968f,
+	0.449063f,
+	0.892098f,
+	-0.05003f,
+	0.400085f,
+	0.916232f,
+	0.0212355f,
+	0.189459f,
+	0.975149f,
+	-0.114846f,
+	0.154225f,
+	0.96178f,
+	-0.226258f,
+	0.36559f,
+	0.902984f,
+	-0.225751f,
+	0.443305f,
+	0.891814f,
+	-0.0902669f,
+	0.481296f,
+	0.876165f,
+	0.0262584f,
+	0.274557f,
+	0.96003f,
+	0.0544047f,
+	-0.0951468f,
+	0.983236f,
+	0.155547f,
+	-0.272231f,
+	0.920302f,
+	0.280953f,
+	-0.309095f,
+	0.909629f,
+	0.277553f,
+	-0.260629f,
+	0.904898f,
+	0.336501f,
+	-0.319906f,
+	0.899874f,
+	0.296456f,
+	-0.309019f,
+	0.910231f,
+	0.275658f,
+	-0.301457f,
+	0.909911f,
+	0.284931f,
+	-0.289244f,
+	0.908198f,
+	0.302514f,
+	-0.349317f,
+	0.867088f,
+	0.355157f,
+	-0.355035f,
+	0.811266f,
+	0.46454f,
+	-0.291879f,
+	0.804435f,
+	0.517388f,
+	-0.292737f,
+	0.815956f,
+	0.498519f,
+	-0.341117f,
+	0.83204f,
+	0.437434f,
+	0.012939f,
+	0.999781f,
+	0.0164623f,
+	0.101117f,
+	0.986501f,
+	0.12881f,
+	-0.0315137f,
+	0.991787f,
+	0.123953f,
+	-0.202813f,
+	0.972667f,
+	0.113078f,
+	-0.267039f,
+	0.954882f,
+	0.129964f,
+	-0.329248f,
+	0.943109f,
+	0.0462825f,
+	-0.158801f,
+	0.981787f,
+	0.104294f,
+	-0.0896983f,
+	0.994441f,
+	0.0551561f,
+	-0.03797f,
+	0.996172f,
+	0.0787436f,
+	-0.124773f,
+	0.970658f,
+	0.205561f,
+	-0.242396f,
+	0.92942f,
+	0.278248f,
+	-0.1236f,
+	0.936757f,
+	0.327428f,
+	-0.115597f,
+	0.950099f,
+	0.289742f,
+	-0.242269f,
+	0.924532f,
+	0.294187f,
+	-0.335063f,
+	0.873272f,
+	0.353736f,
+	-0.402827f,
+	0.872268f,
+	0.27727f,
+	-0.433494f,
+	0.882428f,
+	0.182769f,
+	-0.472347f,
+	0.860126f,
+	0.192541f,
+	-0.516304f,
+	0.829671f,
+	0.212311f,
+	-0.401557f,
+	0.840095f,
+	0.364681f,
+	-0.365647f,
+	0.853697f,
+	0.370816f,
+	-0.342203f,
+	0.911984f,
+	0.226234f,
+	-0.319568f,
+	0.928553f,
+	0.188855f,
+	-0.368607f,
+	0.886665f,
+	0.279203f,
+	-0.401013f,
+	0.885839f,
+	0.233406f,
+	-0.263462f,
+	0.961384f,
+	0.0795548f,
+	-0.119336f,
+	0.983737f,
+	-0.134243f,
+	-0.028348f,
+	0.969034f,
+	-0.245295f,
+	0.0404463f,
+	0.983879f,
+	-0.174201f,
+	0.11875f,
+	0.992593f,
+	0.0256534f,
+	0.0602272f,
+	0.997166f,
+	0.0450923f,
+	0.0340291f,
+	0.999414f,
+	-0.00366965f,
+	0.0708792f,
+	0.992684f,
+	-0.097743f,
+	0.0958935f,
+	0.99395f,
+	-0.0535485f,
+	-0.0943801f,
+	0.993296f,
+	-0.0667466f,
+	-0.119267f,
+	0.988594f,
+	-0.0919588f,
+	0.000759128f,
+	0.999891f,
+	-0.0147216f,
+	0.0724665f,
+	0.997368f,
+	-0.00256206f,
+	0.170906f,
+	0.979948f,
+	-0.10244f,
+	0.214916f,
+	0.97339f,
+	-0.079521f,
+	0.347938f,
+	0.935698f,
+	0.0583811f,
+	0.479062f,
+	0.877734f,
+	-0.00909944f,
+	0.517939f,
+	0.850313f,
+	-0.0933121f,
+	0.446396f,
+	0.884197f,
+	-0.137574f,
+	0.389313f,
+	0.918353f,
+	-0.0711587f,
+	0.410982f,
+	0.908412f,
+	0.0766878f,
+	0.41147f,
+	0.910096f,
+	0.0491837f,
+	0.356411f,
+	0.933637f,
+	-0.0359751f,
+	0.291892f,
+	0.941315f,
+	-0.169483f,
+	0.292525f,
+	0.936947f,
+	-0.191205f,
+	0.303478f,
+	0.950202f,
+	-0.0708325f,
+	0.350076f,
+	0.936333f,
+	0.0269695f,
+	0.186651f,
+	0.94527f,
+	0.26763f,
+	-0.145022f,
+	0.9031f,
+	0.404201f,
+	-0.257588f,
+	0.88179f,
+	0.395088f,
+	-0.316433f,
+	0.892435f,
+	0.321607f,
+	-0.301856f,
+	0.895088f,
+	0.328177f,
+	-0.311714f,
+	0.888624f,
+	0.336427f,
+	-0.275146f,
+	0.879635f,
+	0.387991f,
+	-0.320358f,
+	0.874704f,
+	0.363681f,
+	-0.312957f,
+	0.856468f,
+	0.410514f,
+	-0.417707f,
+	0.826376f,
+	0.377656f,
+	-0.402058f,
+	0.821773f,
+	0.403779f,
+	-0.299174f,
+	0.86271f,
+	0.407708f,
+	-0.252864f,
+	0.886408f,
+	0.387737f,
+	-0.266831f,
+	0.899401f,
+	0.346235f,
+	-0.121912f,
+	0.980245f,
+	-0.155747f,
+	-0.0467045f,
+	0.996241f,
+	-0.0729522f,
+	-0.0560423f,
+	0.996609f,
+	0.0602479f,
+	-0.253613f,
+	0.959854f,
+	0.119832f,
+	-0.17852f,
+	0.958289f,
+	0.223189f,
+	-0.25091f,
+	0.965294f,
+	0.0724672f,
+	-0.244405f,
+	0.968888f,
+	0.0390022f,
+	-0.111828f,
+	0.978686f,
+	0.172245f,
+	-0.104286f,
+	0.963728f,
+	0.245667f,
+	-0.172657f,
+	0.941673f,
+	0.288863f,
+	-0.302965f,
+	0.917419f,
+	0.257981f,
+	-0.21274f,
+	0.929075f,
+	0.302592f,
+	-0.0577232f,
+	0.923128f,
+	0.380136f,
+	-0.183983f,
+	0.930078f,
+	0.31797f,
+	-0.384056f,
+	0.900387f,
+	0.204463f,
+	-0.327378f,
+	0.913703f,
+	0.240771f,
+	-0.374063f,
+	0.905896f,
+	0.198566f,
+	-0.504219f,
+	0.846296f,
+	0.17189f,
+	-0.555467f,
+	0.810974f,
+	0.183786f,
+	-0.456478f,
+	0.86757f,
+	0.197356f,
+	-0.300554f,
+	0.935674f,
+	0.184881f,
+	-0.295051f,
+	0.948068f,
+	0.118792f,
+	-0.362387f,
+	0.917821f,
+	0.162113f,
+	-0.440667f,
+	0.875232f,
+	0.199453f,
+	-0.248631f,
+	0.939944f,
+	0.233854f,
+	-0.0966352f,
+	0.995188f,
+	0.0161918f,
+	0.0243217f,
+	0.996259f,
+	-0.0829196f,
+	0.0213875f,
+	0.994057f,
+	-0.106741f,
+	-0.13683f,
+	0.98707f,
+	-0.0834831f,
+	-0.0593385f,
+	0.994125f,
+	0.0905282f,
+	0.0836318f,
+	0.990077f,
+	0.112932f,
+	0.079675f,
+	0.993049f,
+	0.0866394f,
+	0.0726138f,
+	0.990126f,
+	0.119908f,
+	0.0468689f,
+	0.990824f,
+	0.126776f,
+	0.00048966f,
+	0.99587f,
+	0.0907856f,
+	-0.0299455f,
+	0.998898f,
+	-0.0361395f,
+	-0.0528047f,
+	0.988171f,
+	-0.143981f,
+	0.0771474f,
+	0.992034f,
+	-0.0995875f,
+	0.233f,
+	0.968973f,
+	-0.0824758f,
+	0.215078f,
+	0.967265f,
+	-0.134683f,
+	0.299646f,
+	0.93128f,
+	-0.207193f,
+	0.500666f,
+	0.844143f,
+	-0.191721f,
+	0.5316f,
+	0.838001f,
+	-0.123112f,
+	0.45137f,
+	0.888237f,
+	-0.0854371f,
+	0.26295f,
+	0.958984f,
+	-0.105862f,
+	0.297072f,
+	0.954855f,
+	-0.000735176f,
+	0.467586f,
+	0.880091f,
+	0.0824758f,
+	0.451683f,
+	0.892137f,
+	0.00862833f,
+	0.280097f,
+	0.955995f,
+	-0.0872873f,
+	0.27353f,
+	0.961001f,
+	0.0407195f,
+	0.263182f,
+	0.963734f,
+	0.044184f,
+	0.22357f,
+	0.970136f,
+	0.0940863f,
+	-0.055048f,
+	0.955137f,
+	0.291002f,
+	-0.267739f,
+	0.863744f,
+	0.426921f,
+	-0.199104f,
+	0.857693f,
+	0.474046f,
+	-0.21681f,
+	0.879018f,
+	0.424642f,
+	-0.270209f,
+	0.885026f,
+	0.379098f,
+	-0.341336f,
+	0.865644f,
+	0.366267f,
+	-0.32372f,
+	0.861174f,
+	0.391898f,
+	-0.34092f,
+	0.838889f,
+	0.42431f,
+	-0.295898f,
+	0.818794f,
+	0.491956f,
+	-0.331f,
+	0.829823f,
+	0.449258f,
+	-0.389842f,
+	0.853312f,
+	0.34624f,
+	-0.281201f,
+	0.9123f,
+	0.297716f,
+	-0.234572f,
+	0.935622f,
+	0.263795f,
+	-0.225355f,
+	0.942001f,
+	0.248696f,
+	-0.0486057f,
+	0.996635f,
+	-0.0660014f,
+	-0.101682f,
+	0.988174f,
+	-0.114771f,
+	-0.162649f,
+	0.983215f,
+	-0.0826606f,
+	-0.318288f,
+	0.946728f,
+	-0.048975f,
+	-0.258454f,
+	0.965864f,
+	-0.0175802f,
+	-0.136613f,
+	0.987862f,
+	0.0739351f,
+	-0.281595f,
+	0.958211f,
+	0.0503573f,
+	-0.28706f,
+	0.943479f,
+	0.165663f,
+	-0.148179f,
+	0.930819f,
+	0.334095f,
+	-0.182832f,
+	0.931383f,
+	0.314798f,
+	-0.242578f,
+	0.923022f,
+	0.298642f,
+	-0.204404f,
+	0.955935f,
+	0.21073f,
+	-0.142784f,
+	0.976536f,
+	0.161212f,
+	-0.136962f,
+	0.950722f,
+	0.278153f,
+	-0.274249f,
+	0.920019f,
+	0.279915f,
+	-0.389723f,
+	0.904453f,
+	0.173436f,
+	-0.370261f,
+	0.901011f,
+	0.226022f,
+	-0.50377f,
+	0.847021f,
+	0.169619f,
+	-0.52553f,
+	0.835875f,
+	0.158529f,
+	-0.435894f,
+	0.894864f,
+	0.0959897f,
+	-0.279872f,
+	0.956869f,
+	0.07793f,
+	-0.331658f,
+	0.940229f,
+	0.0772765f,
+	-0.372127f,
+	0.91403f,
+	0.161461f,
+	-0.456876f,
+	0.888328f,
+	0.0462339f,
+	-0.204408f,
+	0.978272f,
+	0.0346564f,
+	0.0554954f,
+	0.998458f,
+	-0.00157713f,
+	-0.0102256f,
+	0.999947f,
+	0.00149442f,
+	-0.0507499f,
+	0.985345f,
+	0.162848f,
+	-0.124313f,
+	0.970082f,
+	0.208536f,
+	-0.111836f,
+	0.992788f,
+	0.0431796f,
+	0.135986f,
+	0.987999f,
+	0.0732526f,
+	0.00980425f,
+	0.997155f,
+	0.0747439f,
+	0.00734776f,
+	0.982792f,
+	0.184568f,
+	0.0872171f,
+	0.965097f,
+	0.246944f,
+	0.0795152f,
+	0.966423f,
+	0.244345f,
+	0.106439f,
+	0.984803f,
+	0.137237f,
+	0.0584187f,
+	0.998092f,
+	-0.0199996f,
+	0.0370568f,
+	0.991888f,
+	-0.121591f,
+	0.199554f,
+	0.972297f,
+	-0.121727f,
+	0.308311f,
+	0.945569f,
+	-0.104131f,
+	0.399439f,
+	0.904394f,
+	-0.150064f,
+	0.468199f,
+	0.870932f,
+	-0.149223f,
+	0.412212f,
+	0.907025f,
+	-0.0859413f,
+	0.425915f,
+	0.903304f,
+	0.0513667f,
+	0.351639f,
+	0.936099f,
+	-0.00832492f,
+	0.20857f,
+	0.966693f,
+	-0.148333f,
+	0.395551f,
+	0.918183f,
+	0.0219088f,
+	0.538432f,
+	0.838724f,
+	0.0814483f,
+	0.24402f,
+	0.966591f,
+	-0.0784634f,
+	0.178953f,
+	0.981938f,
+	0.0614245f,
+	0.258979f,
+	0.960241f,
+	0.104243f,
+	0.0759782f,
+	0.986383f,
+	0.145865f,
+	-0.19655f,
+	0.929601f,
+	0.311786f,
+	-0.328358f,
+	0.883678f,
+	0.333607f,
+	-0.21216f,
+	0.920721f,
+	0.327507f,
+	-0.208125f,
+	0.923292f,
+	0.322823f,
+	-0.300181f,
+	0.87973f,
+	0.368737f,
+	-0.312111f,
+	0.847974f,
+	0.428401f,
+	-0.324858f,
+	0.873038f,
+	0.363693f,
+	-0.410275f,
+	0.846963f,
+	0.338124f,
+	-0.346514f,
+	0.853308f,
+	0.389607f,
+	-0.303825f,
+	0.86928f,
+	0.389926f,
+	-0.270707f,
+	0.881074f,
+	0.387848f,
+	-0.213937f,
+	0.928705f,
+	0.302885f,
+	-0.20202f,
+	0.939889f,
+	0.275312f,
+	-0.214102f,
+	0.943299f,
+	0.253667f,
+	-0.0402111f,
+	0.999126f,
+	0.011392f,
+	-0.0458289f,
+	0.99894f,
+	0.00442323f,
+	-0.170695f,
+	0.984267f,
+	-0.0456311f,
+	-0.29333f,
+	0.955986f,
+	-0.00691228f,
+	-0.274679f,
+	0.961535f,
+	-0.00118788f,
+	-0.240876f,
+	0.970372f,
+	-0.0188751f,
+	-0.335158f,
+	0.942005f,
+	0.0172014f,
+	-0.387782f,
+	0.921031f,
+	0.0364391f,
+	-0.254694f,
+	0.964339f,
+	0.0719752f,
+	-0.156383f,
+	0.970864f,
+	0.181569f,
+	-0.223749f,
+	0.957301f,
+	0.183063f,
+	-0.122594f,
+	0.972034f,
+	0.200303f,
+	-0.0910709f,
+	0.976799f,
+	0.193828f,
+	-0.28429f,
+	0.950625f,
+	0.124466f,
+	-0.315477f,
+	0.924742f,
+	0.212902f,
+	-0.305454f,
+	0.925312f,
+	0.224713f,
+	-0.365063f,
+	0.920836f,
+	0.137077f,
+	-0.474911f,
+	0.873286f,
+	0.108772f,
+	-0.523018f,
+	0.843362f,
+	0.123259f,
+	-0.405348f,
+	0.903149f,
+	0.141474f,
+	-0.272593f,
+	0.953587f,
+	0.127925f,
+	-0.342778f,
+	0.935924f,
+	0.0809316f,
+	-0.402631f,
+	0.912044f,
+	0.0778773f,
+	-0.324862f,
+	0.935409f,
+	0.139553f,
+	-0.213356f,
+	0.97623f,
+	0.0381383f,
+	0.0301299f,
+	0.998064f,
+	0.0544045f,
+	-0.104927f,
+	0.992798f,
+	0.0578138f,
+	-0.261101f,
+	0.959724f,
+	0.103713f,
+	-0.0217785f,
+	0.964552f,
+	0.262994f,
+	0.0803134f,
+	0.988499f,
+	0.128142f,
+	0.028164f,
+	0.998669f,
+	0.043203f,
+	-0.0183001f,
+	0.984341f,
+	0.175323f,
+	-0.0612635f,
+	0.982917f,
+	0.173556f,
+	-0.0331225f,
+	0.977326f,
+	0.209135f,
+	0.0728156f,
+	0.957515f,
+	0.279039f,
+	0.245559f,
+	0.942697f,
+	0.225881f,
+	0.183786f,
+	0.974714f,
+	0.127102f,
+	0.141547f,
+	0.988409f,
+	0.0548866f,
+	0.245636f,
+	0.968932f,
+	-0.0288843f,
+	0.304552f,
+	0.94926f,
+	-0.0784495f,
+	0.340339f,
+	0.936344f,
+	-0.0861948f,
+	0.460805f,
+	0.886321f,
+	0.0457651f,
+	0.380493f,
+	0.924294f,
+	0.030084f,
+	0.352595f,
+	0.93478f,
+	0.0431689f,
+	0.472573f,
+	0.87479f,
+	0.106851f,
+	0.264087f,
+	0.962772f,
+	-0.057695f,
+	0.234368f,
+	0.968348f,
+	-0.0858683f,
+	0.503248f,
+	0.863251f,
+	0.0392276f,
+	0.302957f,
+	0.950423f,
+	0.0700943f,
+	0.0199528f,
+	0.999731f,
+	0.0118377f,
+	0.239816f,
+	0.960125f,
+	0.143695f,
+	-0.0259597f,
+	0.9852f,
+	0.16943f,
+	-0.288371f,
+	0.907451f,
+	0.305574f,
+	-0.301113f,
+	0.913287f,
+	0.274296f,
+	-0.184882f,
+	0.952263f,
+	0.242927f,
+	-0.251998f,
+	0.931999f,
+	0.260528f,
+	-0.398011f,
+	0.856633f,
+	0.32828f,
+	-0.335641f,
+	0.851294f,
+	0.403292f,
+	-0.239383f,
+	0.893387f,
+	0.380205f,
+	-0.388171f,
+	0.875539f,
+	0.287671f,
+	-0.364652f,
+	0.897686f,
+	0.247364f,
+	-0.31107f,
+	0.908317f,
+	0.279636f,
+	-0.277708f,
+	0.915298f,
+	0.291733f,
+	-0.164862f,
+	0.947448f,
+	0.274159f,
+	-0.18884f,
+	0.953184f,
+	0.236178f,
+	-0.183001f,
+	0.960107f,
+	0.211435f,
+	-0.0382166f,
+	0.998778f,
+	0.0313295f,
+	-0.025601f,
+	0.999566f,
+	0.0145695f,
+	-0.151993f,
+	0.98817f,
+	-0.0204673f,
+	-0.361566f,
+	0.932093f,
+	-0.021731f,
+	-0.304279f,
+	0.951825f,
+	0.0379804f,
+	-0.164708f,
+	0.984119f,
+	0.0661845f,
+	-0.289794f,
+	0.954555f,
+	-0.0695987f,
+	-0.339732f,
+	0.933497f,
+	-0.114741f,
+	-0.304944f,
+	0.945342f,
+	-0.115492f,
+	-0.266385f,
+	0.963249f,
+	-0.0345067f,
+	-0.261205f,
+	0.96511f,
+	0.0183122f,
+	-0.220073f,
+	0.973176f,
+	0.06706f,
+	-0.108437f,
+	0.981443f,
+	0.158152f,
+	-0.188668f,
+	0.971426f,
+	0.143996f,
+	-0.373149f,
+	0.923277f,
+	0.0912126f,
+	-0.308957f,
+	0.927563f,
+	0.210174f,
+	-0.302984f,
+	0.922237f,
+	0.240167f,
+	-0.457665f,
+	0.867903f,
+	0.193102f,
+	-0.548023f,
+	0.825328f,
+	0.136032f,
+	-0.407198f,
+	0.903776f,
+	0.131829f,
+	-0.253292f,
+	0.959077f,
+	0.126545f,
+	-0.271541f,
+	0.948088f,
+	0.165511f,
+	-0.43428f,
+	0.889355f,
+	0.142997f,
+	-0.382973f,
+	0.89965f,
+	0.20967f,
+	-0.169509f,
+	0.965022f,
+	0.199998f,
+	0.00160887f,
+	0.982078f,
+	0.188467f,
+	-0.0137168f,
+	0.977172f,
+	0.212005f,
+	-0.230009f,
+	0.971053f,
+	0.0644371f,
+	-0.165502f,
+	0.985539f,
+	0.036359f,
+	0.129892f,
+	0.967237f,
+	0.218131f,
+	0.0422409f,
+	0.973374f,
+	0.225299f,
+	-0.105762f,
+	0.968925f,
+	0.223604f,
+	-0.0226547f,
+	0.965849f,
+	0.258115f,
+	0.0138374f,
+	0.990856f,
+	0.134211f,
+	0.0309349f,
+	0.998739f,
+	0.0395399f,
+	0.294589f,
+	0.940971f,
+	0.166706f,
+	0.248856f,
+	0.959421f,
+	0.132596f,
+	0.181153f,
+	0.982002f,
+	0.053445f,
+	0.283788f,
+	0.958737f,
+	0.0169453f,
+	0.366617f,
+	0.930251f,
+	-0.0149969f,
+	0.332578f,
+	0.93839f,
+	-0.0938972f,
+	0.358957f,
+	0.931691f,
+	-0.0557027f,
+	0.429022f,
+	0.901938f,
+	0.0494683f,
+	0.332897f,
+	0.942781f,
+	-0.0185381f,
+	0.429131f,
+	0.903242f,
+	-0.000810457f,
+	0.405301f,
+	0.91403f,
+	-0.0167607f,
+	0.256936f,
+	0.958211f,
+	-0.12576f,
+	0.354456f,
+	0.935063f,
+	-0.00433271f,
+	0.385431f,
+	0.888673f,
+	0.248403f,
+	0.0742527f,
+	0.992531f,
+	0.0967874f,
+	0.121836f,
+	0.985927f,
+	0.11447f,
+	-0.100545f,
+	0.965192f,
+	0.241444f,
+	-0.337975f,
+	0.881899f,
+	0.328674f,
+	-0.242866f,
+	0.922974f,
+	0.298555f,
+	-0.185171f,
+	0.940279f,
+	0.285633f,
+	-0.313033f,
+	0.906226f,
+	0.28419f,
+	-0.448562f,
+	0.843983f,
+	0.294082f,
+	-0.356046f,
+	0.888609f,
+	0.289144f,
+	-0.196811f,
+	0.931399f,
+	0.306206f,
+	-0.298585f,
+	0.916744f,
+	0.265384f,
+	-0.410663f,
+	0.894937f,
+	0.17448f,
+	-0.325435f,
+	0.90586f,
+	0.271126f,
+	-0.301755f,
+	0.928362f,
+	0.216998f,
+	-0.109278f,
+	0.952007f,
+	0.285903f,
+	-0.14523f,
+	0.965578f,
+	0.215795f,
+	-0.139372f,
+	0.971047f,
+	0.194018f,
+	0.00163448f,
+	0.997617f,
+	0.0689798f,
+	0.026224f,
+	0.998835f,
+	0.04051f,
+	-0.128032f,
+	0.991559f,
+	-0.0204567f,
+	-0.309968f,
+	0.948873f,
+	-0.0596736f,
+	-0.340105f,
+	0.924291f,
+	-0.173245f,
+	-0.190965f,
+	0.977348f,
+	-0.0912302f,
+	-0.146645f,
+	0.988782f,
+	-0.028384f,
+	-0.31072f,
+	0.935549f,
+	-0.167929f,
+	-0.380234f,
+	0.90209f,
+	-0.204096f,
+	-0.300275f,
+	0.945729f,
+	-0.124224f,
+	-0.302914f,
+	0.945705f,
+	-0.117837f,
+	-0.237161f,
+	0.970049f,
+	-0.0525309f,
+	-0.165718f,
+	0.984724f,
+	-0.0534418f,
+	-0.190643f,
+	0.98063f,
+	0.0449474f,
+	-0.411915f,
+	0.909141f,
+	0.0615588f,
+	-0.453396f,
+	0.88136f,
+	0.1328f,
+	-0.362905f,
+	0.886473f,
+	0.287169f,
+	-0.380477f,
+	0.872742f,
+	0.305874f,
+	-0.476636f,
+	0.866585f,
+	0.147809f,
+	-0.366115f,
+	0.923073f,
+	0.117878f,
+	-0.278065f,
+	0.952821f,
+	0.121709f,
+	-0.370509f,
+	0.910147f,
+	0.18535f,
+	-0.442894f,
+	0.857435f,
+	0.26201f,
+	-0.347292f,
+	0.915122f,
+	0.204794f,
+	-0.111317f,
+	0.983727f,
+	0.141034f,
+	-0.00583658f,
+	0.989977f,
+	0.14111f,
+	0.00293304f,
+	0.989031f,
+	0.147679f,
+	-0.0932614f,
+	0.992658f,
+	0.0770272f,
+	-0.209442f,
+	0.977765f,
+	-0.0104574f,
+	-0.0521744f,
+	0.996134f,
+	0.0706788f,
+	0.0111918f,
+	0.977173f,
+	0.21215f,
+	-0.0985288f,
+	0.958328f,
+	0.268141f,
+	0.0097532f,
+	0.972945f,
+	0.23083f,
+	0.214151f,
+	0.960047f,
+	0.180136f,
+	0.0316331f,
+	0.999392f,
+	0.014672f,
+	0.114623f,
+	0.990459f,
+	0.0765015f,
+	0.302992f,
+	0.926463f,
+	0.223298f,
+	0.283203f,
+	0.948444f,
+	0.142303f,
+	0.315435f,
+	0.948621f,
+	0.0248881f,
+	0.37741f,
+	0.92565f,
+	0.0270755f,
+	0.401819f,
+	0.915069f,
+	0.0345122f,
+	0.321768f,
+	0.943567f,
+	-0.0784028f,
+	0.371664f,
+	0.926589f,
+	-0.0574381f,
+	0.394659f,
+	0.917373f,
+	-0.0516908f,
+	0.434962f,
+	0.894125f,
+	-0.106531f,
+	0.447382f,
+	0.892016f,
+	-0.0644733f,
+	0.241542f,
+	0.966428f,
+	-0.0876093f,
+	0.127706f,
+	0.991493f,
+	-0.0251536f,
+	0.250404f,
+	0.953051f,
+	0.170269f,
+	0.250954f,
+	0.937023f,
+	0.242919f,
+	-0.000559693f,
+	0.986358f,
+	0.164614f,
+	-0.211006f,
+	0.922632f,
+	0.32284f,
+	-0.34675f,
+	0.881023f,
+	0.321811f,
+	-0.216454f,
+	0.925604f,
+	0.310492f,
+	-0.177379f,
+	0.942447f,
+	0.283426f,
+	-0.307121f,
+	0.917748f,
+	0.251824f,
+	-0.427987f,
+	0.86998f,
+	0.244872f,
+	-0.348579f,
+	0.908707f,
+	0.229659f,
+	-0.214211f,
+	0.945769f,
+	0.244201f,
+	-0.272299f,
+	0.924949f,
+	0.265184f,
+	-0.413173f,
+	0.878684f,
+	0.239168f,
+	-0.359354f,
+	0.883418f,
+	0.300728f,
+	-0.292273f,
+	0.892332f,
+	0.343978f,
+	-0.146355f,
+	0.897543f,
+	0.415929f,
+	-0.0984727f,
+	0.903088f,
+	0.418013f,
+	-0.114958f,
+	0.888054f,
+	0.445134f,
+	0.0486539f,
+	0.997583f,
+	-0.0496084f,
+	0.0486095f,
+	0.995772f,
+	-0.0779487f,
+	-0.0727955f,
+	0.994312f,
+	-0.0777426f,
+	-0.222675f,
+	0.967501f,
+	-0.119823f,
+	-0.286744f,
+	0.93984f,
+	-0.185682f,
+	-0.296641f,
+	0.937378f,
+	-0.182555f,
+	-0.219022f,
+	0.967026f,
+	-0.12996f,
+	-0.147314f,
+	0.984117f,
+	-0.0990538f,
+	-0.3428f,
+	0.902622f,
+	-0.26031f,
+	-0.347893f,
+	0.908635f,
+	-0.230983f,
+	-0.327008f,
+	0.925901f,
+	-0.189136f,
+	-0.254527f,
+	0.952486f,
+	-0.167289f,
+	-0.228332f,
+	0.958887f,
+	-0.168522f,
+	-0.287734f,
+	0.955666f,
+	-0.0625468f,
+	-0.451431f,
+	0.892304f,
+	0.00185963f,
+	-0.510909f,
+	0.851571f,
+	0.11747f,
+	-0.434919f,
+	0.884052f,
+	0.171166f,
+	-0.355658f,
+	0.920763f,
+	0.16032f,
+	-0.392075f,
+	0.91242f,
+	0.117331f,
+	-0.40418f,
+	0.912194f,
+	0.0673793f,
+	-0.347001f,
+	0.925636f,
+	0.15096f,
+	-0.406528f,
+	0.883834f,
+	0.231457f,
+	-0.406378f,
+	0.897555f,
+	0.171031f,
+	-0.271349f,
+	0.960134f,
+	0.0671726f,
+	-0.0926357f,
+	0.994526f,
+	0.0483373f,
+	-0.0156467f,
+	0.998994f,
+	0.0420269f,
+	0.00801384f,
+	0.999533f,
+	0.0295044f,
+	-0.0412004f,
+	0.995482f,
+	0.0855485f,
+	-0.171347f,
+	0.982792f,
+	0.068987f,
+	-0.142796f,
+	0.988044f,
+	0.0581328f,
+	-0.101871f,
+	0.981247f,
+	0.163632f,
+	-0.103189f,
+	0.979569f,
+	0.172615f,
+	0.0761964f,
+	0.994828f,
+	0.0671726f,
+	0.210538f,
+	0.977574f,
+	0.00485915f,
+	0.123577f,
+	0.988892f,
+	0.0825912f,
+	0.0553491f,
+	0.995759f,
+	0.0734865f,
+	0.223203f,
+	0.966768f,
+	0.124662f,
+	0.344575f,
+	0.927512f,
+	0.144881f,
+	0.388873f,
+	0.91351f,
+	0.119485f,
+	0.324349f,
+	0.942843f,
+	0.0764535f,
+	0.411999f,
+	0.8978f,
+	0.155603f,
+	0.440079f,
+	0.892774f,
+	0.0963553f,
+	0.378616f,
+	0.925121f,
+	-0.0283174f,
+	0.428515f,
+	0.90345f,
+	-0.0123871f,
+	0.429626f,
+	0.902172f,
+	-0.0388249f,
+	0.396609f,
+	0.917987f,
+	-0.000717735f,
+	0.233551f,
+	0.972137f,
+	-0.020091f,
+	0.111169f,
+	0.993801f,
+	0.000982701f,
+	0.115357f,
+	0.993291f,
+	0.00809163f,
+	0.164275f,
+	0.973308f,
+	0.160266f,
+	-0.0349159f,
+	0.947849f,
+	0.316803f,
+	-0.267423f,
+	0.890391f,
+	0.368361f,
+	-0.327503f,
+	0.90805f,
+	0.261125f,
+	-0.196107f,
+	0.942247f,
+	0.271499f,
+	-0.118776f,
+	0.949723f,
+	0.289686f,
+	-0.296931f,
+	0.925681f,
+	0.234405f,
+	-0.445051f,
+	0.862967f,
+	0.239201f,
+	-0.335704f,
+	0.917243f,
+	0.2144f,
+	-0.25181f,
+	0.948438f,
+	0.1925f,
+	-0.329983f,
+	0.903347f,
+	0.274f,
+	-0.391867f,
+	0.838521f,
+	0.378579f,
+	-0.417038f,
+	0.817641f,
+	0.396917f,
+	-0.341558f,
+	0.812981f,
+	0.471594f,
+	-0.188106f,
+	0.834488f,
+	0.517925f,
+	-0.137025f,
+	0.804598f,
+	0.577794f,
+	-0.18711f,
+	0.76127f,
+	0.620852f,
+	0.138194f,
+	0.960364f,
+	-0.242082f,
+	0.0401358f,
+	0.96162f,
+	-0.271434f,
+	-0.076195f,
+	0.979732f,
+	-0.185256f,
+	-0.203103f,
+	0.960439f,
+	-0.190543f,
+	-0.267864f,
+	0.941416f,
+	-0.2049f,
+	-0.261748f,
+	0.936741f,
+	-0.232388f,
+	-0.231434f,
+	0.930091f,
+	-0.285254f,
+	-0.126583f,
+	0.962607f,
+	-0.239509f,
+	-0.258776f,
+	0.934905f,
+	-0.242872f,
+	-0.430322f,
+	0.876496f,
+	-0.215819f,
+	-0.353956f,
+	0.929119f,
+	-0.107016f,
+	-0.27861f,
+	0.956787f,
+	-0.0832819f,
+	-0.250796f,
+	0.967007f,
+	-0.0447179f,
+	-0.348257f,
+	0.937394f,
+	-0.0030026f,
+	-0.497787f,
+	0.866258f,
+	0.0424905f,
+	-0.584411f,
+	0.803193f,
+	0.115522f,
+	-0.394257f,
+	0.905213f,
+	0.158588f,
+	-0.343138f,
+	0.935038f,
+	0.0892179f,
+	-0.380878f,
+	0.917442f,
+	0.115034f,
+	-0.389256f,
+	0.914513f,
+	0.11021f,
+	-0.431967f,
+	0.895633f,
+	0.10605f,
+	-0.414636f,
+	0.893675f,
+	0.171528f,
+	-0.300214f,
+	0.948969f,
+	0.0965901f,
+	-0.20281f,
+	0.978452f,
+	-0.0387339f,
+	-0.123855f,
+	0.987388f,
+	-0.098611f,
+	-0.0140563f,
+	0.999899f,
+	0.0019046f,
+	-0.052066f,
+	0.991601f,
+	0.118388f,
+	-0.0936165f,
+	0.973604f,
+	0.208163f,
+	-0.149626f,
+	0.978491f,
+	0.142013f,
+	-0.198198f,
+	0.970011f,
+	0.140699f,
+	-0.130637f,
+	0.968649f,
+	0.211313f,
+	0.013631f,
+	0.991214f,
+	0.131563f,
+	0.20118f,
+	0.979295f,
+	0.0225449f,
+	0.231889f,
+	0.971935f,
+	-0.0396138f,
+	0.0131145f,
+	0.999014f,
+	-0.0424166f,
+	0.0264969f,
+	0.999403f,
+	0.0221517f,
+	0.210411f,
+	0.977103f,
+	0.0315571f,
+	0.327081f,
+	0.943965f,
+	0.0441437f,
+	0.381166f,
+	0.920813f,
+	0.0825546f,
+	0.346088f,
+	0.933621f,
+	0.0925967f,
+	0.356105f,
+	0.932513f,
+	0.0600724f,
+	0.479238f,
+	0.87232f,
+	0.0968908f,
+	0.446186f,
+	0.89276f,
+	0.062428f,
+	0.391504f,
+	0.920172f,
+	-0.00287489f,
+	0.426134f,
+	0.9041f,
+	0.0318405f,
+	0.417296f,
+	0.907685f,
+	0.0444148f,
+	0.286592f,
+	0.957965f,
+	0.012947f,
+	0.07628f,
+	0.996621f,
+	-0.030475f,
+	0.0820652f,
+	0.99629f,
+	0.0259114f,
+	-0.0280556f,
+	0.994071f,
+	0.105053f,
+	-0.213977f,
+	0.933546f,
+	0.287585f,
+	-0.245374f,
+	0.890565f,
+	0.382995f,
+	-0.189692f,
+	0.923736f,
+	0.332759f,
+	-0.238316f,
+	0.94737f,
+	0.213765f,
+	-0.176209f,
+	0.945132f,
+	0.275092f,
+	-0.265622f,
+	0.907592f,
+	0.32515f,
+	-0.420635f,
+	0.873046f,
+	0.246691f,
+	-0.275407f,
+	0.930254f,
+	0.242441f,
+	-0.273955f,
+	0.921146f,
+	0.276474f,
+	-0.415501f,
+	0.828882f,
+	0.374585f,
+	-0.488833f,
+	0.76092f,
+	0.426664f,
+	-0.43149f,
+	0.76785f,
+	0.473522f,
+	-0.33634f,
+	0.787599f,
+	0.516297f,
+	-0.228347f,
+	0.790629f,
+	0.568123f,
+	-0.231089f,
+	0.763668f,
+	0.602835f,
+	-0.28515f,
+	0.752352f,
+	0.593849f,
+	0.109283f,
+	0.926796f,
+	-0.359314f,
+	-0.0105223f,
+	0.944186f,
+	-0.329244f,
+	-0.147017f,
+	0.945286f,
+	-0.29124f,
+	-0.202823f,
+	0.935685f,
+	-0.288714f,
+	-0.214861f,
+	0.941374f,
+	-0.260095f,
+	-0.2356f,
+	0.926477f,
+	-0.293483f,
+	-0.224333f,
+	0.941495f,
+	-0.251519f,
+	-0.230404f,
+	0.948768f,
+	-0.216226f,
+	-0.277442f,
+	0.956386f,
+	-0.0913908f,
+	-0.472179f,
+	0.876647f,
+	-0.0923929f,
+	-0.428177f,
+	0.898465f,
+	-0.0970806f,
+	-0.3387f,
+	0.938243f,
+	-0.0705803f,
+	-0.291725f,
+	0.956079f,
+	0.0284457f,
+	-0.399526f,
+	0.915525f,
+	0.0468393f,
+	-0.527082f,
+	0.845186f,
+	0.0885769f,
+	-0.577694f,
+	0.815576f,
+	0.0332458f,
+	-0.408723f,
+	0.912647f,
+	0.00457497f,
+	-0.331162f,
+	0.938989f,
+	0.0929031f,
+	-0.4185f,
+	0.893481f,
+	0.162938f,
+	-0.372755f,
+	0.902119f,
+	0.217335f,
+	-0.419905f,
+	0.891761f,
+	0.168648f,
+	-0.426162f,
+	0.889671f,
+	0.163929f,
+	-0.238048f,
+	0.949403f,
+	0.20486f,
+	-0.0631417f,
+	0.981494f,
+	0.180781f,
+	-0.0934621f,
+	0.991987f,
+	0.0850084f,
+	-0.209815f,
+	0.971464f,
+	0.110612f,
+	-0.239382f,
+	0.928806f,
+	0.282871f,
+	-0.0385152f,
+	0.924665f,
+	0.378829f,
+	-0.0229585f,
+	0.976683f,
+	0.213458f,
+	-0.204415f,
+	0.977814f,
+	0.0457583f,
+	-0.131276f,
+	0.991302f,
+	0.00937849f,
+	0.100844f,
+	0.99484f,
+	0.0110965f,
+	0.227419f,
+	0.973508f,
+	-0.0237273f,
+	0.22975f,
+	0.97307f,
+	0.0187244f,
+	0.0718328f,
+	0.997222f,
+	0.0197173f,
+	0.0214849f,
+	0.994143f,
+	-0.105917f,
+	0.174121f,
+	0.982096f,
+	-0.0718949f,
+	0.303053f,
+	0.952921f,
+	0.010044f,
+	0.38012f,
+	0.924935f,
+	0.00218727f,
+	0.364895f,
+	0.929903f,
+	-0.0461611f,
+	0.383009f,
+	0.921386f,
+	-0.0659776f,
+	0.441676f,
+	0.895702f,
+	-0.0513817f,
+	0.484548f,
+	0.87476f,
+	0.00284626f,
+	0.413676f,
+	0.910113f,
+	-0.0237944f,
+	0.449057f,
+	0.893501f,
+	-0.00212143f,
+	0.360983f,
+	0.928147f,
+	-0.090746f,
+	0.274993f,
+	0.958661f,
+	0.0731286f,
+	0.0881261f,
+	0.984394f,
+	0.15232f,
+	0.00584658f,
+	0.984704f,
+	0.174138f,
+	-0.113749f,
+	0.971528f,
+	0.207834f,
+	-0.320112f,
+	0.923512f,
+	0.211313f,
+	-0.308899f,
+	0.921582f,
+	0.23509f,
+	-0.147069f,
+	0.956187f,
+	0.253135f,
+	-0.14137f,
+	0.959806f,
+	0.242461f,
+	-0.277438f,
+	0.935166f,
+	0.220209f,
+	-0.254545f,
+	0.906523f,
+	0.336782f,
+	-0.385464f,
+	0.89189f,
+	0.236535f,
+	-0.346902f,
+	0.887297f,
+	0.303913f,
+	-0.404152f,
+	0.809818f,
+	0.425271f,
+	-0.45263f,
+	0.705418f,
+	0.545446f,
+	-0.436346f,
+	0.733679f,
+	0.520882f,
+	-0.40606f,
+	0.758487f,
+	0.509719f,
+	-0.399991f,
+	0.76519f,
+	0.504471f,
+	-0.29927f,
+	0.789873f,
+	0.535292f,
+	-0.216265f,
+	0.823324f,
+	0.524754f,
+	-0.25441f,
+	0.854784f,
+	0.452349f,
+	-0.0876585f,
+	0.974972f,
+	-0.204317f,
+	-0.064531f,
+	0.993199f,
+	-0.096908f,
+	-0.142906f,
+	0.98657f,
+	-0.0790982f,
+	-0.190225f,
+	0.979959f,
+	-0.0591132f,
+	-0.245075f,
+	0.966633f,
+	-0.0745641f,
+	-0.286525f,
+	0.954682f,
+	-0.0805399f,
+	-0.302328f,
+	0.953201f,
+	0.00253574f,
+	-0.315251f,
+	0.947498f,
+	0.0535207f,
+	-0.363913f,
+	0.92013f,
+	0.144666f,
+	-0.433014f,
+	0.884677f,
+	0.172759f,
+	-0.39903f,
+	0.904384f,
+	0.151207f,
+	-0.340877f,
+	0.927749f,
+	0.15194f,
+	-0.34367f,
+	0.933336f,
+	0.103799f,
+	-0.371228f,
+	0.927804f,
+	0.0370044f,
+	-0.540653f,
+	0.838686f,
+	-0.0655789f,
+	-0.541683f,
+	0.840171f,
+	-0.0263209f,
+	-0.443789f,
+	0.895468f,
+	-0.0344719f,
+	-0.446175f,
+	0.894923f,
+	0.00646964f,
+	-0.489716f,
+	0.870366f,
+	0.0513954f,
+	-0.393228f,
+	0.91623f,
+	0.0767741f,
+	-0.386844f,
+	0.914535f,
+	0.118231f,
+	-0.456614f,
+	0.881467f,
+	0.1205f,
+	-0.291641f,
+	0.939064f,
+	0.181947f,
+	-0.0983466f,
+	0.949337f,
+	0.298474f,
+	-0.0663966f,
+	0.917799f,
+	0.391455f,
+	-0.225097f,
+	0.912905f,
+	0.340494f,
+	-0.270333f,
+	0.917625f,
+	0.291349f,
+	-0.0378823f,
+	0.963845f,
+	0.263756f,
+	0.203246f,
+	0.94956f,
+	0.238803f,
+	-0.00658121f,
+	0.998329f,
+	0.057403f,
+	-0.104339f,
+	0.991332f,
+	-0.0798442f,
+	0.0714998f,
+	0.99184f,
+	-0.105548f,
+	0.229254f,
+	0.968801f,
+	-0.0941692f,
+	0.162963f,
+	0.980447f,
+	-0.110304f,
+	0.144794f,
+	0.987619f,
+	-0.0603599f,
+	0.1028f,
+	0.982727f,
+	-0.153883f,
+	0.103742f,
+	0.981824f,
+	-0.158931f,
+	0.242509f,
+	0.962807f,
+	-0.119129f,
+	0.409757f,
+	0.908112f,
+	-0.0862081f,
+	0.420763f,
+	0.899369f,
+	-0.118717f,
+	0.356993f,
+	0.920491f,
+	-0.158908f,
+	0.417923f,
+	0.902816f,
+	-0.101306f,
+	0.45294f,
+	0.886743f,
+	-0.0923743f,
+	0.388277f,
+	0.919595f,
+	-0.0598771f,
+	0.442705f,
+	0.896663f,
+	-0.00260706f,
+	0.330753f,
+	0.943188f,
+	0.0316099f,
+	0.0976556f,
+	0.983098f,
+	0.154858f,
+	-0.0408134f,
+	0.964902f,
+	0.259421f,
+	-0.0353778f,
+	0.920067f,
+	0.39016f,
+	-0.0336634f,
+	0.909873f,
+	0.413518f,
+	-0.27131f,
+	0.928078f,
+	0.255075f,
+	-0.276299f,
+	0.942343f,
+	0.188808f,
+	-0.178846f,
+	0.97249f,
+	0.149254f,
+	-0.173925f,
+	0.95192f,
+	0.252185f,
+	-0.312455f,
+	0.905292f,
+	0.287781f,
+	-0.299358f,
+	0.905887f,
+	0.299588f,
+	-0.361522f,
+	0.88183f,
+	0.302783f,
+	-0.474485f,
+	0.805519f,
+	0.35497f,
+	-0.514467f,
+	0.728892f,
+	0.451708f,
+	-0.495653f,
+	0.729457f,
+	0.471404f,
+	-0.395267f,
+	0.75904f,
+	0.517322f,
+	-0.414244f,
+	0.765988f,
+	0.491594f,
+	-0.375453f,
+	0.800102f,
+	0.467837f,
+	-0.23686f,
+	0.857078f,
+	0.457509f,
+	-0.153599f,
+	0.897001f,
+	0.414483f,
+	-0.139778f,
+	0.900978f,
+	0.410733f,
+	-0.246424f,
+	0.968956f,
+	-0.0200009f,
+	-0.187575f,
+	0.975459f,
+	0.115309f,
+	-0.169324f,
+	0.958565f,
+	0.229092f,
+	-0.227196f,
+	0.942917f,
+	0.243495f,
+	-0.216356f,
+	0.935609f,
+	0.278972f,
+	-0.279085f,
+	0.916546f,
+	0.286453f,
+	-0.337088f,
+	0.885038f,
+	0.32106f,
+	-0.317388f,
+	0.891504f,
+	0.323242f,
+	-0.400555f,
+	0.875243f,
+	0.271117f,
+	-0.420396f,
+	0.865286f,
+	0.273034f,
+	-0.438864f,
+	0.863369f,
+	0.248983f,
+	-0.296161f,
+	0.903481f,
+	0.309855f,
+	-0.22181f,
+	0.945018f,
+	0.240296f,
+	-0.217483f,
+	0.959525f,
+	0.178924f,
+	-0.432196f,
+	0.899705f,
+	0.0611361f,
+	-0.592514f,
+	0.805005f,
+	-0.029893f,
+	-0.445437f,
+	0.89528f,
+	0.00770123f,
+	-0.444106f,
+	0.895735f,
+	-0.0207082f,
+	-0.441178f,
+	0.89658f,
+	-0.0387967f,
+	-0.433316f,
+	0.896401f,
+	-0.0932815f,
+	-0.448061f,
+	0.893999f,
+	-0.00273746f,
+	-0.479681f,
+	0.876222f,
+	0.046264f,
+	-0.38049f,
+	0.918735f,
+	0.105607f,
+	-0.274091f,
+	0.928692f,
+	0.249812f,
+	-0.115693f,
+	0.919238f,
+	0.37632f,
+	-0.109076f,
+	0.943601f,
+	0.312601f,
+	-0.183297f,
+	0.969532f,
+	0.162513f,
+	-0.0200265f,
+	0.998099f,
+	0.0582807f,
+	0.217564f,
+	0.969248f,
+	0.114995f,
+	0.107422f,
+	0.986137f,
+	0.126469f,
+	-0.0101958f,
+	0.999802f,
+	0.0170616f,
+	0.0917708f,
+	0.993871f,
+	-0.0616322f,
+	0.259886f,
+	0.964354f,
+	-0.049807f,
+	0.22181f,
+	0.965636f,
+	-0.135454f,
+	0.11068f,
+	0.965795f,
+	-0.234499f,
+	0.156396f,
+	0.962982f,
+	-0.219561f,
+	0.0996902f,
+	0.954613f,
+	-0.28067f,
+	0.240821f,
+	0.930419f,
+	-0.276271f,
+	0.362585f,
+	0.892287f,
+	-0.268992f,
+	0.39828f,
+	0.905306f,
+	-0.147629f,
+	0.377219f,
+	0.92249f,
+	-0.0819651f,
+	0.379471f,
+	0.918832f,
+	-0.108391f,
+	0.428571f,
+	0.902988f,
+	-0.0306522f,
+	0.390587f,
+	0.920304f,
+	0.0219829f,
+	0.365451f,
+	0.930816f,
+	-0.00527733f,
+	0.226127f,
+	0.963781f,
+	0.141399f,
+	-0.014879f,
+	0.969939f,
+	0.242893f,
+	-0.0990439f,
+	0.938525f,
+	0.330697f,
+	-0.160986f,
+	0.911469f,
+	0.37856f,
+	-0.0311141f,
+	0.900531f,
+	0.433676f,
+	-0.0818559f,
+	0.904519f,
+	0.418503f,
+	-0.202897f,
+	0.939947f,
+	0.274469f,
+	-0.199596f,
+	0.951915f,
+	0.232421f,
+	-0.290928f,
+	0.922977f,
+	0.251942f,
+	-0.30301f,
+	0.91121f,
+	0.279072f,
+	-0.315746f,
+	0.908229f,
+	0.274635f,
+	-0.386173f,
+	0.858884f,
+	0.336435f,
+	-0.56045f,
+	0.768828f,
+	0.307894f,
+	-0.529456f,
+	0.742805f,
+	0.409776f,
+	-0.545227f,
+	0.770059f,
+	0.331265f,
+	-0.460487f,
+	0.804404f,
+	0.375346f,
+	-0.384041f,
+	0.835484f,
+	0.393038f,
+	-0.366328f,
+	0.856374f,
+	0.363907f,
+	-0.227066f,
+	0.886912f,
+	0.40228f,
+	-0.162423f,
+	0.896635f,
+	0.411903f,
+	-0.18398f,
+	0.877261f,
+	0.443356f,
+	-0.33059f,
+	0.941987f,
+	0.0580528f,
+	-0.349053f,
+	0.930827f,
+	0.108275f,
+	-0.250298f,
+	0.937413f,
+	0.242089f,
+	-0.231173f,
+	0.921233f,
+	0.312871f,
+	-0.267366f,
+	0.883285f,
+	0.385127f,
+	-0.300638f,
+	0.858727f,
+	0.414975f,
+	-0.348846f,
+	0.869854f,
+	0.348799f,
+	-0.262698f,
+	0.902187f,
+	0.342122f,
+	-0.319043f,
+	0.887638f,
+	0.33213f,
+	-0.407631f,
+	0.874264f,
+	0.263628f,
+	-0.391131f,
+	0.891388f,
+	0.229006f,
+	-0.306387f,
+	0.939971f,
+	0.150271f,
+	-0.172289f,
+	0.969062f,
+	0.176734f,
+	-0.280735f,
+	0.939942f,
+	0.194158f,
+	-0.35822f,
+	0.876748f,
+	0.320922f,
+	-0.540223f,
+	0.822439f,
+	0.178196f,
+	-0.415201f,
+	0.897062f,
+	0.151285f,
+	-0.398489f,
+	0.913332f,
+	0.0838552f,
+	-0.47388f,
+	0.879024f,
+	0.052479f,
+	-0.430994f,
+	0.889287f,
+	0.153011f,
+	-0.501585f,
+	0.850518f,
+	0.158213f,
+	-0.493115f,
+	0.843586f,
+	0.212601f,
+	-0.437044f,
+	0.869936f,
+	0.228482f,
+	-0.335665f,
+	0.928238f,
+	0.160321f,
+	-0.135997f,
+	0.987913f,
+	0.0743886f,
+	0.0115105f,
+	0.995614f,
+	0.0928467f,
+	-0.0367985f,
+	0.999249f,
+	0.0121783f,
+	0.0254956f,
+	0.996874f,
+	-0.0747791f,
+	0.107382f,
+	0.991622f,
+	-0.0717932f,
+	0.144184f,
+	0.989518f,
+	0.00810907f,
+	0.0943487f,
+	0.994079f,
+	-0.0539027f,
+	0.124876f,
+	0.987862f,
+	-0.0923827f,
+	0.25534f,
+	0.960035f,
+	-0.114602f,
+	0.339105f,
+	0.927956f,
+	-0.154613f,
+	0.200588f,
+	0.937015f,
+	-0.285951f,
+	0.184172f,
+	0.917658f,
+	-0.352115f,
+	0.137125f,
+	0.909076f,
+	-0.393417f,
+	0.231522f,
+	0.90798f,
+	-0.349242f,
+	0.299652f,
+	0.902049f,
+	-0.310671f,
+	0.23061f,
+	0.944613f,
+	-0.233507f,
+	0.336481f,
+	0.938772f,
+	-0.0740748f,
+	0.38792f,
+	0.918977f,
+	-0.070704f,
+	0.337723f,
+	0.938393f,
+	-0.073227f,
+	0.392706f,
+	0.919584f,
+	-0.012147f,
+	0.294051f,
+	0.954956f,
+	-0.0399037f,
+	0.173344f,
+	0.964432f,
+	0.199555f,
+	-0.108669f,
+	0.967119f,
+	0.22994f,
+	-0.18728f,
+	0.925976f,
+	0.327863f,
+	-0.156223f,
+	0.937505f,
+	0.310931f,
+	-0.0961609f,
+	0.948752f,
+	0.301037f,
+	-0.051031f,
+	0.914222f,
+	0.401987f,
+	-0.116652f,
+	0.921592f,
+	0.370216f,
+	-0.16747f,
+	0.919727f,
+	0.355044f,
+	-0.233888f,
+	0.917713f,
+	0.321092f,
+	-0.296558f,
+	0.924646f,
+	0.23892f,
+	-0.384099f,
+	0.898594f,
+	0.212122f,
+	-0.451252f,
+	0.843433f,
+	0.291535f,
+	-0.561019f,
+	0.766309f,
+	0.313095f,
+	-0.56702f,
+	0.761029f,
+	0.315156f,
+	-0.502958f,
+	0.815049f,
+	0.287624f,
+	-0.46769f,
+	0.845823f,
+	0.256612f,
+	-0.438846f,
+	0.860082f,
+	0.260142f,
+	-0.380472f,
+	0.841841f,
+	0.382812f,
+	-0.286801f,
+	0.84573f,
+	0.449984f,
+	-0.166497f,
+	0.837941f,
+	0.519744f,
+	-0.237954f,
+	0.844014f,
+	0.480644f,
+	-0.400938f,
+	0.907575f,
+	0.124721f,
+	-0.36178f,
+	0.91645f,
+	0.170983f,
+	-0.326178f,
+	0.936068f,
+	0.131852f,
+	-0.348093f,
+	0.925471f,
+	0.149445f,
+	-0.380521f,
+	0.903785f,
+	0.195901f,
+	-0.261965f,
+	0.932138f,
+	0.249988f,
+	-0.229009f,
+	0.957451f,
+	0.175621f,
+	-0.296226f,
+	0.953377f,
+	0.0576446f,
+	-0.385007f,
+	0.916429f,
+	0.109216f,
+	-0.396898f,
+	0.895963f,
+	0.199304f,
+	-0.30002f,
+	0.927264f,
+	0.223985f,
+	-0.290512f,
+	0.953204f,
+	0.083697f,
+	-0.240862f,
+	0.959505f,
+	0.146069f,
+	-0.368638f,
+	0.900621f,
+	0.230189f,
+	-0.437205f,
+	0.833732f,
+	0.337256f,
+	-0.435531f,
+	0.825298f,
+	0.359438f,
+	-0.382764f,
+	0.869714f,
+	0.311593f,
+	-0.302351f,
+	0.902083f,
+	0.307944f,
+	-0.504704f,
+	0.84016f,
+	0.198507f,
+	-0.44412f,
+	0.839306f,
+	0.313565f,
+	-0.494888f,
+	0.841296f,
+	0.217503f,
+	-0.530329f,
+	0.827106f,
+	0.186138f,
+	-0.314084f,
+	0.933199f,
+	0.174614f,
+	-0.124034f,
+	0.990967f,
+	0.050983f,
+	-0.0452003f,
+	0.995178f,
+	-0.0870557f,
+	-0.00182424f,
+	0.990385f,
+	-0.138326f,
+	-0.0388611f,
+	0.986686f,
+	-0.157927f,
+	0.0684221f,
+	0.991564f,
+	-0.11009f,
+	0.102533f,
+	0.981475f,
+	-0.161848f,
+	0.149983f,
+	0.975213f,
+	-0.162681f,
+	0.108711f,
+	0.963953f,
+	-0.24285f,
+	0.134579f,
+	0.963238f,
+	-0.232511f,
+	0.280754f,
+	0.932346f,
+	-0.227832f,
+	0.370391f,
+	0.907723f,
+	-0.197103f,
+	0.290987f,
+	0.936165f,
+	-0.197286f,
+	0.244643f,
+	0.947659f,
+	-0.205165f,
+	0.12819f,
+	0.972148f,
+	-0.196204f,
+	0.159014f,
+	0.967422f,
+	-0.197002f,
+	0.312607f,
+	0.930748f,
+	-0.189697f,
+	0.153027f,
+	0.941997f,
+	-0.298704f,
+	0.218578f,
+	0.950985f,
+	-0.218748f,
+	0.390534f,
+	0.915543f,
+	-0.0962525f,
+	0.350134f,
+	0.933592f,
+	-0.0762398f,
+	0.369694f,
+	0.928637f,
+	-0.030973f,
+	0.182224f,
+	0.981373f,
+	0.0608345f,
+	-0.0452136f,
+	0.980467f,
+	0.191416f,
+	-0.152401f,
+	0.95767f,
+	0.244216f,
+	-0.205784f,
+	0.951891f,
+	0.22706f,
+	-0.112228f,
+	0.971017f,
+	0.211022f,
+	-0.130106f,
+	0.967854f,
+	0.215247f,
+	-0.151633f,
+	0.958079f,
+	0.243087f,
+	-0.104162f,
+	0.953804f,
+	0.281796f,
+	-0.17561f,
+	0.947845f,
+	0.265989f,
+	-0.209606f,
+	0.941523f,
+	0.263816f,
+	-0.251275f,
+	0.930745f,
+	0.265659f,
+	-0.361f,
+	0.884718f,
+	0.294879f,
+	-0.50281f,
+	0.813876f,
+	0.291185f,
+	-0.583247f,
+	0.763934f,
+	0.276094f,
+	-0.556622f,
+	0.802134f,
+	0.216224f,
+	-0.473532f,
+	0.851987f,
+	0.223352f,
+	-0.473757f,
+	0.85285f,
+	0.219548f,
+	-0.491496f,
+	0.823107f,
+	0.284477f,
+	-0.477559f,
+	0.793154f,
+	0.377946f,
+	-0.368868f,
+	0.830921f,
+	0.416542f,
+	-0.202419f,
+	0.861608f,
+	0.465466f,
+	-0.095407f,
+	0.855544f,
+	0.508864f,
+	-0.40239f,
+	0.909528f,
+	0.104118f,
+	-0.357524f,
+	0.930915f,
+	0.0746555f,
+	-0.280797f,
+	0.959558f,
+	0.0200349f,
+	-0.296463f,
+	0.954936f,
+	-0.0143765f,
+	-0.381172f,
+	0.918388f,
+	-0.106166f,
+	-0.308734f,
+	0.946435f,
+	-0.094572f,
+	-0.184864f,
+	0.981918f,
+	-0.0407667f,
+	-0.211096f,
+	0.97426f,
+	-0.0790985f,
+	-0.431269f,
+	0.892976f,
+	-0.128847f,
+	-0.508723f,
+	0.860224f,
+	-0.0348507f,
+	-0.315588f,
+	0.942693f,
+	0.108326f,
+	-0.229963f,
+	0.954167f,
+	0.191527f,
+	-0.338476f,
+	0.90391f,
+	0.261495f,
+	-0.399866f,
+	0.843393f,
+	0.358882f,
+	-0.508212f,
+	0.817205f,
+	0.271838f,
+	-0.45663f,
+	0.829465f,
+	0.321678f,
+	-0.343829f,
+	0.869846f,
+	0.353765f,
+	-0.25214f,
+	0.908629f,
+	0.332893f,
+	-0.465924f,
+	0.864347f,
+	0.189262f,
+	-0.451321f,
+	0.885092f,
+	0.11367f,
+	-0.398038f,
+	0.913426f,
+	0.0849568f,
+	-0.473433f,
+	0.880353f,
+	-0.0289816f,
+	-0.282123f,
+	0.951018f,
+	-0.126376f,
+	-0.111297f,
+	0.983512f,
+	-0.142537f,
+	-0.0203568f,
+	0.995748f,
+	-0.089847f,
+	0.0177076f,
+	0.998505f,
+	-0.0517153f,
+	-0.0210973f,
+	0.999746f,
+	0.00787929f,
+	0.0422415f,
+	0.999104f,
+	-0.00245387f,
+	0.162083f,
+	0.986673f,
+	-0.0143034f,
+	0.184873f,
+	0.978111f,
+	-0.0954998f,
+	0.225836f,
+	0.960454f,
+	-0.162869f,
+	0.105652f,
+	0.960265f,
+	-0.25832f,
+	0.22096f,
+	0.965567f,
+	-0.137321f,
+	0.306187f,
+	0.951906f,
+	0.0111556f,
+	0.252563f,
+	0.963728f,
+	0.0862585f,
+	0.185211f,
+	0.975091f,
+	0.122044f,
+	0.141716f,
+	0.976503f,
+	0.162355f,
+	0.200688f,
+	0.976886f,
+	0.0736112f,
+	0.398894f,
+	0.916482f,
+	0.0307355f,
+	0.27456f,
+	0.96012f,
+	-0.0527967f,
+	0.152825f,
+	0.971043f,
+	-0.183632f,
+	0.271211f,
+	0.950001f,
+	-0.154736f,
+	0.286301f,
+	0.958137f,
+	0.00244849f,
+	0.246502f,
+	0.96458f,
+	0.0939299f,
+	0.102065f,
+	0.977178f,
+	0.186298f,
+	-0.0761105f,
+	0.976837f,
+	0.19999f,
+	-0.0810786f,
+	0.974651f,
+	0.208524f,
+	-0.174214f,
+	0.975155f,
+	0.136831f,
+	-0.127689f,
+	0.983595f,
+	0.127422f,
+	-0.123239f,
+	0.988203f,
+	0.0909257f,
+	-0.173027f,
+	0.984333f,
+	0.033919f,
+	-0.13019f,
+	0.985916f,
+	0.104975f,
+	-0.151236f,
+	0.977557f,
+	0.146665f,
+	-0.212082f,
+	0.972216f,
+	0.0990861f,
+	-0.346196f,
+	0.93167f,
+	0.110181f,
+	-0.461867f,
+	0.845088f,
+	0.269268f,
+	-0.491314f,
+	0.790968f,
+	0.364663f,
+	-0.499721f,
+	0.798886f,
+	0.334753f,
+	-0.533877f,
+	0.823302f,
+	0.192741f,
+	-0.489959f,
+	0.855912f,
+	0.165393f,
+	-0.540105f,
+	0.823669f,
+	0.172786f,
+	-0.55174f,
+	0.789596f,
+	0.268553f,
+	-0.518837f,
+	0.818462f,
+	0.246838f,
+	-0.35793f,
+	0.879679f,
+	0.31313f,
+	-0.226645f,
+	0.914368f,
+	0.335505f,
+	-0.174062f,
+	0.93173f,
+	0.31872f,
+	-0.352372f,
+	0.928926f,
+	-0.113715f,
+	-0.283164f,
+	0.949292f,
+	-0.13661f,
+	-0.253833f,
+	0.949289f,
+	-0.185523f,
+	-0.258433f,
+	0.953837f,
+	-0.152994f,
+	-0.329686f,
+	0.925665f,
+	-0.185613f,
+	-0.360482f,
+	0.913899f,
+	-0.186657f,
+	-0.246398f,
+	0.964945f,
+	-0.0903879f,
+	-0.197613f,
+	0.98019f,
+	0.013309f,
+	-0.409684f,
+	0.910684f,
+	0.0530475f,
+	-0.545574f,
+	0.83677f,
+	0.0465257f,
+	-0.477964f,
+	0.876264f,
+	0.060934f,
+	-0.386247f,
+	0.882258f,
+	0.269135f,
+	-0.437443f,
+	0.816448f,
+	0.376904f,
+	-0.381546f,
+	0.830459f,
+	0.405906f,
+	-0.378931f,
+	0.857772f,
+	0.347329f,
+	-0.484349f,
+	0.854204f,
+	0.189053f,
+	-0.391934f,
+	0.899277f,
+	0.194136f,
+	-0.180618f,
+	0.947297f,
+	0.264585f,
+	-0.285059f,
+	0.943094f,
+	0.171219f,
+	-0.41449f,
+	0.905591f,
+	-0.0900102f,
+	-0.367364f,
+	0.916679f,
+	-0.157298f,
+	-0.4046f,
+	0.892318f,
+	-0.200168f,
+	-0.265207f,
+	0.933534f,
+	-0.241204f,
+	-0.171437f,
+	0.970625f,
+	-0.168809f,
+	-0.091648f,
+	0.995789f,
+	0.00231266f,
+	-0.0988725f,
+	0.989781f,
+	0.102747f,
+	-0.0749525f,
+	0.978356f,
+	0.192877f,
+	0.0618361f,
+	0.988236f,
+	0.139875f,
+	0.222758f,
+	0.971067f,
+	0.0860673f,
+	0.260459f,
+	0.965435f,
+	-0.00983276f,
+	0.296216f,
+	0.954928f,
+	-0.0191894f,
+	0.108089f,
+	0.992937f,
+	-0.0489145f,
+	0.0559635f,
+	0.998425f,
+	-0.00391097f,
+	0.182072f,
+	0.980129f,
+	0.0787236f,
+	0.189029f,
+	0.972269f,
+	0.137697f,
+	0.20292f,
+	0.962368f,
+	0.180751f,
+	0.162611f,
+	0.977583f,
+	0.133749f,
+	0.283117f,
+	0.944546f,
+	0.166365f,
+	0.362781f,
+	0.917623f,
+	0.162352f,
+	0.322808f,
+	0.912852f,
+	0.249991f,
+	0.306817f,
+	0.930382f,
+	0.200629f,
+	0.265368f,
+	0.963264f,
+	0.0412725f,
+	0.150516f,
+	0.988588f,
+	0.00624705f,
+	0.192187f,
+	0.980013f,
+	0.0513622f,
+	0.111093f,
+	0.98864f,
+	0.101236f,
+	-0.0652663f,
+	0.990994f,
+	0.116922f,
+	-0.0960853f,
+	0.989279f,
+	0.109972f,
+	-0.171018f,
+	0.980514f,
+	0.0966674f,
+	-0.118023f,
+	0.981194f,
+	0.152737f,
+	-0.0297124f,
+	0.980668f,
+	0.19341f,
+	-0.130364f,
+	0.983461f,
+	0.125733f,
+	-0.228583f,
+	0.970632f,
+	0.0749913f,
+	-0.187681f,
+	0.973906f,
+	0.127608f,
+	-0.18184f,
+	0.968481f,
+	0.170233f,
+	-0.382626f,
+	0.904754f,
+	0.187128f,
+	-0.565004f,
+	0.795638f,
+	0.218473f,
+	-0.54964f,
+	0.808473f,
+	0.210397f,
+	-0.494188f,
+	0.848001f,
+	0.191501f,
+	-0.42417f,
+	0.88632f,
+	0.185785f,
+	-0.490729f,
+	0.864039f,
+	0.112346f,
+	-0.547278f,
+	0.819965f,
+	0.167765f,
+	-0.555649f,
+	0.823683f,
+	0.113141f,
+	-0.525063f,
+	0.850181f,
+	0.0387426f,
+	-0.465555f,
+	0.881687f,
+	0.0767294f,
+	-0.25104f,
+	0.948586f,
+	0.19278f,
+	-0.134177f,
+	0.968986f,
+	0.207515f,
+	-0.358148f,
+	0.879839f,
+	-0.31243f,
+	-0.281248f,
+	0.911984f,
+	-0.298639f,
+	-0.261128f,
+	0.923339f,
+	-0.281526f,
+	-0.281121f,
+	0.935581f,
+	-0.213678f,
+	-0.316696f,
+	0.928992f,
+	-0.191515f,
+	-0.378661f,
+	0.908066f,
+	-0.178974f,
+	-0.357733f,
+	0.923356f,
+	-0.139433f,
+	-0.295419f,
+	0.953886f,
+	0.0531873f,
+	-0.456379f,
+	0.869265f,
+	0.18999f,
+	-0.492836f,
+	0.836159f,
+	0.240731f,
+	-0.533039f,
+	0.832034f,
+	0.153586f,
+	-0.471339f,
+	0.822176f,
+	0.319166f,
+	-0.417097f,
+	0.817012f,
+	0.398149f,
+	-0.397475f,
+	0.860419f,
+	0.318894f,
+	-0.295585f,
+	0.889222f,
+	0.349162f,
+	-0.397825f,
+	0.896297f,
+	0.195927f,
+	-0.426121f,
+	0.903442f,
+	0.0470364f,
+	-0.225108f,
+	0.967792f,
+	0.11272f,
+	-0.180332f,
+	0.969123f,
+	0.168172f,
+	-0.283694f,
+	0.958436f,
+	-0.0303046f,
+	-0.31011f,
+	0.929142f,
+	-0.201316f,
+	-0.379988f,
+	0.880118f,
+	-0.284609f,
+	-0.280631f,
+	0.91033f,
+	-0.304213f,
+	-0.299273f,
+	0.919298f,
+	-0.255591f,
+	-0.271669f,
+	0.962178f,
+	0.0202533f,
+	-0.127278f,
+	0.946024f,
+	0.298058f,
+	-0.0668081f,
+	0.957542f,
+	0.280447f,
+	0.156177f,
+	0.962373f,
+	0.222366f,
+	0.269377f,
+	0.960799f,
+	0.0655824f,
+	0.307217f,
+	0.951527f,
+	-0.0146071f,
+	0.247019f,
+	0.968029f,
+	-0.0436127f,
+	0.117286f,
+	0.99106f,
+	0.0635867f,
+	0.0498813f,
+	0.996011f,
+	0.0739844f,
+	0.194956f,
+	0.980335f,
+	0.0305971f,
+	0.139483f,
+	0.989424f,
+	-0.0398183f,
+	0.235447f,
+	0.970519f,
+	0.0515568f,
+	0.132445f,
+	0.989845f,
+	-0.05162f,
+	0.206421f,
+	0.976844f,
+	0.0562743f,
+	0.330371f,
+	0.919083f,
+	0.214804f,
+	0.266375f,
+	0.922982f,
+	0.277756f,
+	0.331232f,
+	0.885792f,
+	0.325049f,
+	0.36267f,
+	0.895106f,
+	0.259337f,
+	0.240431f,
+	0.963714f,
+	0.115964f,
+	0.171746f,
+	0.982113f,
+	-0.0771883f,
+	0.0351621f,
+	0.99889f,
+	-0.0313443f,
+	-0.0882653f,
+	0.987488f,
+	0.130674f,
+	-0.0658856f,
+	0.986287f,
+	0.151318f,
+	-0.167193f,
+	0.982329f,
+	0.0841182f,
+	-0.21476f,
+	0.97234f,
+	0.0918338f,
+	-0.104496f,
+	0.958461f,
+	0.265392f,
+	-0.0605561f,
+	0.923444f,
+	0.378926f,
+	-0.152497f,
+	0.949101f,
+	0.275594f,
+	-0.216118f,
+	0.964594f,
+	0.151167f,
+	-0.26219f,
+	0.945639f,
+	0.192413f,
+	-0.408309f,
+	0.854572f,
+	0.320922f,
+	-0.530012f,
+	0.797788f,
+	0.28744f,
+	-0.48417f,
+	0.855541f,
+	0.183383f,
+	-0.504616f,
+	0.863257f,
+	0.012294f,
+	-0.421367f,
+	0.905956f,
+	0.0411587f,
+	-0.517653f,
+	0.855189f,
+	0.0262018f,
+	-0.533316f,
+	0.826853f,
+	0.178574f,
+	-0.514944f,
+	0.854185f,
+	0.0721125f,
+	-0.506113f,
+	0.861889f,
+	-0.0315744f,
+	-0.499639f,
+	0.865958f,
+	-0.0218358f,
+	-0.302149f,
+	0.952465f,
+	0.038937f,
+	-0.129933f,
+	0.988738f,
+	0.0742583f,
+};
+
+btScalar Landscape02Tex[] = {
+	0.0f,
+	0.273438f,
+	0.0f,
+	0.265625f,
+	0.0078125f,
+	0.273438f,
+	0.0078125f,
+	0.265625f,
+	0.015625f,
+	0.273438f,
+	0.015625f,
+	0.265625f,
+	0.0234375f,
+	0.273438f,
+	0.0234375f,
+	0.265625f,
+	0.03125f,
+	0.273438f,
+	0.03125f,
+	0.265625f,
+	0.0390625f,
+	0.273438f,
+	0.0390625f,
+	0.265625f,
+	0.046875f,
+	0.273438f,
+	0.046875f,
+	0.265625f,
+	0.0546875f,
+	0.273438f,
+	0.0546875f,
+	0.265625f,
+	0.0625f,
+	0.273438f,
+	0.0625f,
+	0.265625f,
+	0.0703125f,
+	0.273438f,
+	0.0703125f,
+	0.265625f,
+	0.078125f,
+	0.273438f,
+	0.078125f,
+	0.265625f,
+	0.0859375f,
+	0.273438f,
+	0.0859375f,
+	0.265625f,
+	0.09375f,
+	0.273438f,
+	0.09375f,
+	0.265625f,
+	0.101563f,
+	0.273438f,
+	0.101563f,
+	0.265625f,
+	0.109375f,
+	0.273438f,
+	0.109375f,
+	0.265625f,
+	0.117188f,
+	0.273438f,
+	0.117188f,
+	0.265625f,
+	0.125f,
+	0.273438f,
+	0.125f,
+	0.265625f,
+	0.132813f,
+	0.273438f,
+	0.132813f,
+	0.265625f,
+	0.140625f,
+	0.273438f,
+	0.140625f,
+	0.265625f,
+	0.148438f,
+	0.273438f,
+	0.148438f,
+	0.265625f,
+	0.15625f,
+	0.273438f,
+	0.15625f,
+	0.265625f,
+	0.164063f,
+	0.273438f,
+	0.164063f,
+	0.265625f,
+	0.171875f,
+	0.273438f,
+	0.171875f,
+	0.265625f,
+	0.179688f,
+	0.273438f,
+	0.179688f,
+	0.265625f,
+	0.1875f,
+	0.273438f,
+	0.1875f,
+	0.265625f,
+	0.195313f,
+	0.273438f,
+	0.195313f,
+	0.265625f,
+	0.203125f,
+	0.273438f,
+	0.203125f,
+	0.265625f,
+	0.210938f,
+	0.273438f,
+	0.210938f,
+	0.265625f,
+	0.21875f,
+	0.273438f,
+	0.21875f,
+	0.265625f,
+	0.226563f,
+	0.273438f,
+	0.226563f,
+	0.265625f,
+	0.234375f,
+	0.273438f,
+	0.234375f,
+	0.265625f,
+	0.242188f,
+	0.273438f,
+	0.242188f,
+	0.265625f,
+	0.25f,
+	0.273438f,
+	0.25f,
+	0.265625f,
+	0.257813f,
+	0.273438f,
+	0.257813f,
+	0.265625f,
+	0.265625f,
+	0.273438f,
+	0.265625f,
+	0.265625f,
+	0.273438f,
+	0.273438f,
+	0.273438f,
+	0.265625f,
+	0.28125f,
+	0.273438f,
+	0.28125f,
+	0.265625f,
+	0.289063f,
+	0.273438f,
+	0.289063f,
+	0.265625f,
+	0.296875f,
+	0.273438f,
+	0.296875f,
+	0.265625f,
+	0.304688f,
+	0.273438f,
+	0.304688f,
+	0.265625f,
+	0.3125f,
+	0.273438f,
+	0.3125f,
+	0.265625f,
+	0.320313f,
+	0.273438f,
+	0.320313f,
+	0.265625f,
+	0.328125f,
+	0.273438f,
+	0.328125f,
+	0.265625f,
+	0.335938f,
+	0.273438f,
+	0.335938f,
+	0.265625f,
+	0.34375f,
+	0.273438f,
+	0.34375f,
+	0.265625f,
+	0.351563f,
+	0.273438f,
+	0.351563f,
+	0.265625f,
+	0.359375f,
+	0.273438f,
+	0.359375f,
+	0.265625f,
+	0.367188f,
+	0.273438f,
+	0.367188f,
+	0.265625f,
+	0.375f,
+	0.273438f,
+	0.375f,
+	0.265625f,
+	0.382813f,
+	0.273438f,
+	0.382813f,
+	0.265625f,
+	0.390625f,
+	0.273438f,
+	0.390625f,
+	0.265625f,
+	0.398438f,
+	0.273438f,
+	0.398438f,
+	0.265625f,
+	0.40625f,
+	0.273438f,
+	0.40625f,
+	0.265625f,
+	0.414063f,
+	0.273438f,
+	0.414063f,
+	0.265625f,
+	0.421875f,
+	0.273438f,
+	0.421875f,
+	0.265625f,
+	0.429688f,
+	0.273438f,
+	0.429688f,
+	0.265625f,
+	0.4375f,
+	0.273438f,
+	0.4375f,
+	0.265625f,
+	0.445313f,
+	0.273438f,
+	0.445313f,
+	0.265625f,
+	0.453125f,
+	0.273438f,
+	0.453125f,
+	0.265625f,
+	0.460938f,
+	0.273438f,
+	0.460938f,
+	0.265625f,
+	0.46875f,
+	0.273438f,
+	0.46875f,
+	0.265625f,
+	0.476563f,
+	0.273438f,
+	0.476563f,
+	0.265625f,
+	0.484375f,
+	0.273438f,
+	0.484375f,
+	0.265625f,
+	0.492188f,
+	0.273438f,
+	0.492188f,
+	0.265625f,
+	0.5f,
+	0.273438f,
+	0.5f,
+	0.265625f,
+	0.507813f,
+	0.273438f,
+	0.507813f,
+	0.265625f,
+	0.0f,
+	0.28125f,
+	0.0078125f,
+	0.28125f,
+	0.015625f,
+	0.28125f,
+	0.0234375f,
+	0.28125f,
+	0.03125f,
+	0.28125f,
+	0.0390625f,
+	0.28125f,
+	0.046875f,
+	0.28125f,
+	0.0546875f,
+	0.28125f,
+	0.0625f,
+	0.28125f,
+	0.0703125f,
+	0.28125f,
+	0.078125f,
+	0.28125f,
+	0.0859375f,
+	0.28125f,
+	0.09375f,
+	0.28125f,
+	0.101563f,
+	0.28125f,
+	0.109375f,
+	0.28125f,
+	0.117188f,
+	0.28125f,
+	0.125f,
+	0.28125f,
+	0.132813f,
+	0.28125f,
+	0.140625f,
+	0.28125f,
+	0.148438f,
+	0.28125f,
+	0.15625f,
+	0.28125f,
+	0.164063f,
+	0.28125f,
+	0.171875f,
+	0.28125f,
+	0.179688f,
+	0.28125f,
+	0.1875f,
+	0.28125f,
+	0.195313f,
+	0.28125f,
+	0.203125f,
+	0.28125f,
+	0.210938f,
+	0.28125f,
+	0.21875f,
+	0.28125f,
+	0.226563f,
+	0.28125f,
+	0.234375f,
+	0.28125f,
+	0.242188f,
+	0.28125f,
+	0.25f,
+	0.28125f,
+	0.257813f,
+	0.28125f,
+	0.265625f,
+	0.28125f,
+	0.273438f,
+	0.28125f,
+	0.28125f,
+	0.28125f,
+	0.289063f,
+	0.28125f,
+	0.296875f,
+	0.28125f,
+	0.304688f,
+	0.28125f,
+	0.3125f,
+	0.28125f,
+	0.320313f,
+	0.28125f,
+	0.328125f,
+	0.28125f,
+	0.335938f,
+	0.28125f,
+	0.34375f,
+	0.28125f,
+	0.351563f,
+	0.28125f,
+	0.359375f,
+	0.28125f,
+	0.367188f,
+	0.28125f,
+	0.375f,
+	0.28125f,
+	0.382813f,
+	0.28125f,
+	0.390625f,
+	0.28125f,
+	0.398438f,
+	0.28125f,
+	0.40625f,
+	0.28125f,
+	0.414063f,
+	0.28125f,
+	0.421875f,
+	0.28125f,
+	0.429688f,
+	0.28125f,
+	0.4375f,
+	0.28125f,
+	0.445313f,
+	0.28125f,
+	0.453125f,
+	0.28125f,
+	0.460938f,
+	0.28125f,
+	0.46875f,
+	0.28125f,
+	0.476563f,
+	0.28125f,
+	0.484375f,
+	0.28125f,
+	0.492188f,
+	0.28125f,
+	0.5f,
+	0.28125f,
+	0.507813f,
+	0.28125f,
+	0.0f,
+	0.289063f,
+	0.0078125f,
+	0.289063f,
+	0.015625f,
+	0.289063f,
+	0.0234375f,
+	0.289063f,
+	0.03125f,
+	0.289063f,
+	0.0390625f,
+	0.289063f,
+	0.046875f,
+	0.289063f,
+	0.0546875f,
+	0.289063f,
+	0.0625f,
+	0.289063f,
+	0.0703125f,
+	0.289063f,
+	0.078125f,
+	0.289063f,
+	0.0859375f,
+	0.289063f,
+	0.09375f,
+	0.289063f,
+	0.101563f,
+	0.289063f,
+	0.109375f,
+	0.289063f,
+	0.117188f,
+	0.289063f,
+	0.125f,
+	0.289063f,
+	0.132813f,
+	0.289063f,
+	0.140625f,
+	0.289063f,
+	0.148438f,
+	0.289063f,
+	0.15625f,
+	0.289063f,
+	0.164063f,
+	0.289063f,
+	0.171875f,
+	0.289063f,
+	0.179688f,
+	0.289063f,
+	0.1875f,
+	0.289063f,
+	0.195313f,
+	0.289063f,
+	0.203125f,
+	0.289063f,
+	0.210938f,
+	0.289063f,
+	0.21875f,
+	0.289063f,
+	0.226563f,
+	0.289063f,
+	0.234375f,
+	0.289063f,
+	0.242188f,
+	0.289063f,
+	0.25f,
+	0.289063f,
+	0.257813f,
+	0.289063f,
+	0.265625f,
+	0.289063f,
+	0.273438f,
+	0.289063f,
+	0.28125f,
+	0.289063f,
+	0.289063f,
+	0.289063f,
+	0.296875f,
+	0.289063f,
+	0.304688f,
+	0.289063f,
+	0.3125f,
+	0.289063f,
+	0.320313f,
+	0.289063f,
+	0.328125f,
+	0.289063f,
+	0.335938f,
+	0.289063f,
+	0.34375f,
+	0.289063f,
+	0.351563f,
+	0.289063f,
+	0.359375f,
+	0.289063f,
+	0.367188f,
+	0.289063f,
+	0.375f,
+	0.289063f,
+	0.382813f,
+	0.289063f,
+	0.390625f,
+	0.289063f,
+	0.398438f,
+	0.289063f,
+	0.40625f,
+	0.289063f,
+	0.414063f,
+	0.289063f,
+	0.421875f,
+	0.289063f,
+	0.429688f,
+	0.289063f,
+	0.4375f,
+	0.289063f,
+	0.445313f,
+	0.289063f,
+	0.453125f,
+	0.289063f,
+	0.460938f,
+	0.289063f,
+	0.46875f,
+	0.289063f,
+	0.476563f,
+	0.289063f,
+	0.484375f,
+	0.289063f,
+	0.492188f,
+	0.289063f,
+	0.5f,
+	0.289063f,
+	0.507813f,
+	0.289063f,
+	0.0f,
+	0.296875f,
+	0.0078125f,
+	0.296875f,
+	0.015625f,
+	0.296875f,
+	0.0234375f,
+	0.296875f,
+	0.03125f,
+	0.296875f,
+	0.0390625f,
+	0.296875f,
+	0.046875f,
+	0.296875f,
+	0.0546875f,
+	0.296875f,
+	0.0625f,
+	0.296875f,
+	0.0703125f,
+	0.296875f,
+	0.078125f,
+	0.296875f,
+	0.0859375f,
+	0.296875f,
+	0.09375f,
+	0.296875f,
+	0.101563f,
+	0.296875f,
+	0.109375f,
+	0.296875f,
+	0.117188f,
+	0.296875f,
+	0.125f,
+	0.296875f,
+	0.132813f,
+	0.296875f,
+	0.140625f,
+	0.296875f,
+	0.148438f,
+	0.296875f,
+	0.15625f,
+	0.296875f,
+	0.164063f,
+	0.296875f,
+	0.171875f,
+	0.296875f,
+	0.179688f,
+	0.296875f,
+	0.1875f,
+	0.296875f,
+	0.195313f,
+	0.296875f,
+	0.203125f,
+	0.296875f,
+	0.210938f,
+	0.296875f,
+	0.21875f,
+	0.296875f,
+	0.226563f,
+	0.296875f,
+	0.234375f,
+	0.296875f,
+	0.242188f,
+	0.296875f,
+	0.25f,
+	0.296875f,
+	0.257813f,
+	0.296875f,
+	0.265625f,
+	0.296875f,
+	0.273438f,
+	0.296875f,
+	0.28125f,
+	0.296875f,
+	0.289063f,
+	0.296875f,
+	0.296875f,
+	0.296875f,
+	0.304688f,
+	0.296875f,
+	0.3125f,
+	0.296875f,
+	0.320313f,
+	0.296875f,
+	0.328125f,
+	0.296875f,
+	0.335938f,
+	0.296875f,
+	0.34375f,
+	0.296875f,
+	0.351563f,
+	0.296875f,
+	0.359375f,
+	0.296875f,
+	0.367188f,
+	0.296875f,
+	0.375f,
+	0.296875f,
+	0.382813f,
+	0.296875f,
+	0.390625f,
+	0.296875f,
+	0.398438f,
+	0.296875f,
+	0.40625f,
+	0.296875f,
+	0.414063f,
+	0.296875f,
+	0.421875f,
+	0.296875f,
+	0.429688f,
+	0.296875f,
+	0.4375f,
+	0.296875f,
+	0.445313f,
+	0.296875f,
+	0.453125f,
+	0.296875f,
+	0.460938f,
+	0.296875f,
+	0.46875f,
+	0.296875f,
+	0.476563f,
+	0.296875f,
+	0.484375f,
+	0.296875f,
+	0.492188f,
+	0.296875f,
+	0.5f,
+	0.296875f,
+	0.507813f,
+	0.296875f,
+	0.0f,
+	0.304688f,
+	0.0078125f,
+	0.304688f,
+	0.015625f,
+	0.304688f,
+	0.0234375f,
+	0.304688f,
+	0.03125f,
+	0.304688f,
+	0.0390625f,
+	0.304688f,
+	0.046875f,
+	0.304688f,
+	0.0546875f,
+	0.304688f,
+	0.0625f,
+	0.304688f,
+	0.0703125f,
+	0.304688f,
+	0.078125f,
+	0.304688f,
+	0.0859375f,
+	0.304688f,
+	0.09375f,
+	0.304688f,
+	0.101563f,
+	0.304688f,
+	0.109375f,
+	0.304688f,
+	0.117188f,
+	0.304688f,
+	0.125f,
+	0.304688f,
+	0.132813f,
+	0.304688f,
+	0.140625f,
+	0.304688f,
+	0.148438f,
+	0.304688f,
+	0.15625f,
+	0.304688f,
+	0.164063f,
+	0.304688f,
+	0.171875f,
+	0.304688f,
+	0.179688f,
+	0.304688f,
+	0.1875f,
+	0.304688f,
+	0.195313f,
+	0.304688f,
+	0.203125f,
+	0.304688f,
+	0.210938f,
+	0.304688f,
+	0.21875f,
+	0.304688f,
+	0.226563f,
+	0.304688f,
+	0.234375f,
+	0.304688f,
+	0.242188f,
+	0.304688f,
+	0.25f,
+	0.304688f,
+	0.257813f,
+	0.304688f,
+	0.265625f,
+	0.304688f,
+	0.273438f,
+	0.304688f,
+	0.28125f,
+	0.304688f,
+	0.289063f,
+	0.304688f,
+	0.296875f,
+	0.304688f,
+	0.304688f,
+	0.304688f,
+	0.3125f,
+	0.304688f,
+	0.320313f,
+	0.304688f,
+	0.328125f,
+	0.304688f,
+	0.335938f,
+	0.304688f,
+	0.34375f,
+	0.304688f,
+	0.351563f,
+	0.304688f,
+	0.359375f,
+	0.304688f,
+	0.367188f,
+	0.304688f,
+	0.375f,
+	0.304688f,
+	0.382813f,
+	0.304688f,
+	0.390625f,
+	0.304688f,
+	0.398438f,
+	0.304688f,
+	0.40625f,
+	0.304688f,
+	0.414063f,
+	0.304688f,
+	0.421875f,
+	0.304688f,
+	0.429688f,
+	0.304688f,
+	0.4375f,
+	0.304688f,
+	0.445313f,
+	0.304688f,
+	0.453125f,
+	0.304688f,
+	0.460938f,
+	0.304688f,
+	0.46875f,
+	0.304688f,
+	0.476563f,
+	0.304688f,
+	0.484375f,
+	0.304688f,
+	0.492188f,
+	0.304688f,
+	0.5f,
+	0.304688f,
+	0.507813f,
+	0.304688f,
+	0.0f,
+	0.3125f,
+	0.0078125f,
+	0.3125f,
+	0.015625f,
+	0.3125f,
+	0.0234375f,
+	0.3125f,
+	0.03125f,
+	0.3125f,
+	0.0390625f,
+	0.3125f,
+	0.046875f,
+	0.3125f,
+	0.0546875f,
+	0.3125f,
+	0.0625f,
+	0.3125f,
+	0.0703125f,
+	0.3125f,
+	0.078125f,
+	0.3125f,
+	0.0859375f,
+	0.3125f,
+	0.09375f,
+	0.3125f,
+	0.101563f,
+	0.3125f,
+	0.109375f,
+	0.3125f,
+	0.117188f,
+	0.3125f,
+	0.125f,
+	0.3125f,
+	0.132813f,
+	0.3125f,
+	0.140625f,
+	0.3125f,
+	0.148438f,
+	0.3125f,
+	0.15625f,
+	0.3125f,
+	0.164063f,
+	0.3125f,
+	0.171875f,
+	0.3125f,
+	0.179688f,
+	0.3125f,
+	0.1875f,
+	0.3125f,
+	0.195313f,
+	0.3125f,
+	0.203125f,
+	0.3125f,
+	0.210938f,
+	0.3125f,
+	0.21875f,
+	0.3125f,
+	0.226563f,
+	0.3125f,
+	0.234375f,
+	0.3125f,
+	0.242188f,
+	0.3125f,
+	0.25f,
+	0.3125f,
+	0.257813f,
+	0.3125f,
+	0.265625f,
+	0.3125f,
+	0.273438f,
+	0.3125f,
+	0.28125f,
+	0.3125f,
+	0.289063f,
+	0.3125f,
+	0.296875f,
+	0.3125f,
+	0.304688f,
+	0.3125f,
+	0.3125f,
+	0.3125f,
+	0.320313f,
+	0.3125f,
+	0.328125f,
+	0.3125f,
+	0.335938f,
+	0.3125f,
+	0.34375f,
+	0.3125f,
+	0.351563f,
+	0.3125f,
+	0.359375f,
+	0.3125f,
+	0.367188f,
+	0.3125f,
+	0.375f,
+	0.3125f,
+	0.382813f,
+	0.3125f,
+	0.390625f,
+	0.3125f,
+	0.398438f,
+	0.3125f,
+	0.40625f,
+	0.3125f,
+	0.414063f,
+	0.3125f,
+	0.421875f,
+	0.3125f,
+	0.429688f,
+	0.3125f,
+	0.4375f,
+	0.3125f,
+	0.445313f,
+	0.3125f,
+	0.453125f,
+	0.3125f,
+	0.460938f,
+	0.3125f,
+	0.46875f,
+	0.3125f,
+	0.476563f,
+	0.3125f,
+	0.484375f,
+	0.3125f,
+	0.492188f,
+	0.3125f,
+	0.5f,
+	0.3125f,
+	0.507813f,
+	0.3125f,
+	0.0f,
+	0.320313f,
+	0.0078125f,
+	0.320313f,
+	0.015625f,
+	0.320313f,
+	0.0234375f,
+	0.320313f,
+	0.03125f,
+	0.320313f,
+	0.0390625f,
+	0.320313f,
+	0.046875f,
+	0.320313f,
+	0.0546875f,
+	0.320313f,
+	0.0625f,
+	0.320313f,
+	0.0703125f,
+	0.320313f,
+	0.078125f,
+	0.320313f,
+	0.0859375f,
+	0.320313f,
+	0.09375f,
+	0.320313f,
+	0.101563f,
+	0.320313f,
+	0.109375f,
+	0.320313f,
+	0.117188f,
+	0.320313f,
+	0.125f,
+	0.320313f,
+	0.132813f,
+	0.320313f,
+	0.140625f,
+	0.320313f,
+	0.148438f,
+	0.320313f,
+	0.15625f,
+	0.320313f,
+	0.164063f,
+	0.320313f,
+	0.171875f,
+	0.320313f,
+	0.179688f,
+	0.320313f,
+	0.1875f,
+	0.320313f,
+	0.195313f,
+	0.320313f,
+	0.203125f,
+	0.320313f,
+	0.210938f,
+	0.320313f,
+	0.21875f,
+	0.320313f,
+	0.226563f,
+	0.320313f,
+	0.234375f,
+	0.320313f,
+	0.242188f,
+	0.320313f,
+	0.25f,
+	0.320313f,
+	0.257813f,
+	0.320313f,
+	0.265625f,
+	0.320313f,
+	0.273438f,
+	0.320313f,
+	0.28125f,
+	0.320313f,
+	0.289063f,
+	0.320313f,
+	0.296875f,
+	0.320313f,
+	0.304688f,
+	0.320313f,
+	0.3125f,
+	0.320313f,
+	0.320313f,
+	0.320313f,
+	0.328125f,
+	0.320313f,
+	0.335938f,
+	0.320313f,
+	0.34375f,
+	0.320313f,
+	0.351563f,
+	0.320313f,
+	0.359375f,
+	0.320313f,
+	0.367188f,
+	0.320313f,
+	0.375f,
+	0.320313f,
+	0.382813f,
+	0.320313f,
+	0.390625f,
+	0.320313f,
+	0.398438f,
+	0.320313f,
+	0.40625f,
+	0.320313f,
+	0.414063f,
+	0.320313f,
+	0.421875f,
+	0.320313f,
+	0.429688f,
+	0.320313f,
+	0.4375f,
+	0.320313f,
+	0.445313f,
+	0.320313f,
+	0.453125f,
+	0.320313f,
+	0.460938f,
+	0.320313f,
+	0.46875f,
+	0.320313f,
+	0.476563f,
+	0.320313f,
+	0.484375f,
+	0.320313f,
+	0.492188f,
+	0.320313f,
+	0.5f,
+	0.320313f,
+	0.507813f,
+	0.320313f,
+	0.0f,
+	0.328125f,
+	0.0078125f,
+	0.328125f,
+	0.015625f,
+	0.328125f,
+	0.0234375f,
+	0.328125f,
+	0.03125f,
+	0.328125f,
+	0.0390625f,
+	0.328125f,
+	0.046875f,
+	0.328125f,
+	0.0546875f,
+	0.328125f,
+	0.0625f,
+	0.328125f,
+	0.0703125f,
+	0.328125f,
+	0.078125f,
+	0.328125f,
+	0.0859375f,
+	0.328125f,
+	0.09375f,
+	0.328125f,
+	0.101563f,
+	0.328125f,
+	0.109375f,
+	0.328125f,
+	0.117188f,
+	0.328125f,
+	0.125f,
+	0.328125f,
+	0.132813f,
+	0.328125f,
+	0.140625f,
+	0.328125f,
+	0.148438f,
+	0.328125f,
+	0.15625f,
+	0.328125f,
+	0.164063f,
+	0.328125f,
+	0.171875f,
+	0.328125f,
+	0.179688f,
+	0.328125f,
+	0.1875f,
+	0.328125f,
+	0.195313f,
+	0.328125f,
+	0.203125f,
+	0.328125f,
+	0.210938f,
+	0.328125f,
+	0.21875f,
+	0.328125f,
+	0.226563f,
+	0.328125f,
+	0.234375f,
+	0.328125f,
+	0.242188f,
+	0.328125f,
+	0.25f,
+	0.328125f,
+	0.257813f,
+	0.328125f,
+	0.265625f,
+	0.328125f,
+	0.273438f,
+	0.328125f,
+	0.28125f,
+	0.328125f,
+	0.289063f,
+	0.328125f,
+	0.296875f,
+	0.328125f,
+	0.304688f,
+	0.328125f,
+	0.3125f,
+	0.328125f,
+	0.320313f,
+	0.328125f,
+	0.328125f,
+	0.328125f,
+	0.335938f,
+	0.328125f,
+	0.34375f,
+	0.328125f,
+	0.351563f,
+	0.328125f,
+	0.359375f,
+	0.328125f,
+	0.367188f,
+	0.328125f,
+	0.375f,
+	0.328125f,
+	0.382813f,
+	0.328125f,
+	0.390625f,
+	0.328125f,
+	0.398438f,
+	0.328125f,
+	0.40625f,
+	0.328125f,
+	0.414063f,
+	0.328125f,
+	0.421875f,
+	0.328125f,
+	0.429688f,
+	0.328125f,
+	0.4375f,
+	0.328125f,
+	0.445313f,
+	0.328125f,
+	0.453125f,
+	0.328125f,
+	0.460938f,
+	0.328125f,
+	0.46875f,
+	0.328125f,
+	0.476563f,
+	0.328125f,
+	0.484375f,
+	0.328125f,
+	0.492188f,
+	0.328125f,
+	0.5f,
+	0.328125f,
+	0.507813f,
+	0.328125f,
+	0.0f,
+	0.335938f,
+	0.0078125f,
+	0.335938f,
+	0.015625f,
+	0.335938f,
+	0.0234375f,
+	0.335938f,
+	0.03125f,
+	0.335938f,
+	0.0390625f,
+	0.335938f,
+	0.046875f,
+	0.335938f,
+	0.0546875f,
+	0.335938f,
+	0.0625f,
+	0.335938f,
+	0.0703125f,
+	0.335938f,
+	0.078125f,
+	0.335938f,
+	0.0859375f,
+	0.335938f,
+	0.09375f,
+	0.335938f,
+	0.101563f,
+	0.335938f,
+	0.109375f,
+	0.335938f,
+	0.117188f,
+	0.335938f,
+	0.125f,
+	0.335938f,
+	0.132813f,
+	0.335938f,
+	0.140625f,
+	0.335938f,
+	0.148438f,
+	0.335938f,
+	0.15625f,
+	0.335938f,
+	0.164063f,
+	0.335938f,
+	0.171875f,
+	0.335938f,
+	0.179688f,
+	0.335938f,
+	0.1875f,
+	0.335938f,
+	0.195313f,
+	0.335938f,
+	0.203125f,
+	0.335938f,
+	0.210938f,
+	0.335938f,
+	0.21875f,
+	0.335938f,
+	0.226563f,
+	0.335938f,
+	0.234375f,
+	0.335938f,
+	0.242188f,
+	0.335938f,
+	0.25f,
+	0.335938f,
+	0.257813f,
+	0.335938f,
+	0.265625f,
+	0.335938f,
+	0.273438f,
+	0.335938f,
+	0.28125f,
+	0.335938f,
+	0.289063f,
+	0.335938f,
+	0.296875f,
+	0.335938f,
+	0.304688f,
+	0.335938f,
+	0.3125f,
+	0.335938f,
+	0.320313f,
+	0.335938f,
+	0.328125f,
+	0.335938f,
+	0.335938f,
+	0.335938f,
+	0.34375f,
+	0.335938f,
+	0.351563f,
+	0.335938f,
+	0.359375f,
+	0.335938f,
+	0.367188f,
+	0.335938f,
+	0.375f,
+	0.335938f,
+	0.382813f,
+	0.335938f,
+	0.390625f,
+	0.335938f,
+	0.398438f,
+	0.335938f,
+	0.40625f,
+	0.335938f,
+	0.414063f,
+	0.335938f,
+	0.421875f,
+	0.335938f,
+	0.429688f,
+	0.335938f,
+	0.4375f,
+	0.335938f,
+	0.445313f,
+	0.335938f,
+	0.453125f,
+	0.335938f,
+	0.460938f,
+	0.335938f,
+	0.46875f,
+	0.335938f,
+	0.476563f,
+	0.335938f,
+	0.484375f,
+	0.335938f,
+	0.492188f,
+	0.335938f,
+	0.5f,
+	0.335938f,
+	0.507813f,
+	0.335938f,
+	0.0f,
+	0.34375f,
+	0.0078125f,
+	0.34375f,
+	0.015625f,
+	0.34375f,
+	0.0234375f,
+	0.34375f,
+	0.03125f,
+	0.34375f,
+	0.0390625f,
+	0.34375f,
+	0.046875f,
+	0.34375f,
+	0.0546875f,
+	0.34375f,
+	0.0625f,
+	0.34375f,
+	0.0703125f,
+	0.34375f,
+	0.078125f,
+	0.34375f,
+	0.0859375f,
+	0.34375f,
+	0.09375f,
+	0.34375f,
+	0.101563f,
+	0.34375f,
+	0.109375f,
+	0.34375f,
+	0.117188f,
+	0.34375f,
+	0.125f,
+	0.34375f,
+	0.132813f,
+	0.34375f,
+	0.140625f,
+	0.34375f,
+	0.148438f,
+	0.34375f,
+	0.15625f,
+	0.34375f,
+	0.164063f,
+	0.34375f,
+	0.171875f,
+	0.34375f,
+	0.179688f,
+	0.34375f,
+	0.1875f,
+	0.34375f,
+	0.195313f,
+	0.34375f,
+	0.203125f,
+	0.34375f,
+	0.210938f,
+	0.34375f,
+	0.21875f,
+	0.34375f,
+	0.226563f,
+	0.34375f,
+	0.234375f,
+	0.34375f,
+	0.242188f,
+	0.34375f,
+	0.25f,
+	0.34375f,
+	0.257813f,
+	0.34375f,
+	0.265625f,
+	0.34375f,
+	0.273438f,
+	0.34375f,
+	0.28125f,
+	0.34375f,
+	0.289063f,
+	0.34375f,
+	0.296875f,
+	0.34375f,
+	0.304688f,
+	0.34375f,
+	0.3125f,
+	0.34375f,
+	0.320313f,
+	0.34375f,
+	0.328125f,
+	0.34375f,
+	0.335938f,
+	0.34375f,
+	0.34375f,
+	0.34375f,
+	0.351563f,
+	0.34375f,
+	0.359375f,
+	0.34375f,
+	0.367188f,
+	0.34375f,
+	0.375f,
+	0.34375f,
+	0.382813f,
+	0.34375f,
+	0.390625f,
+	0.34375f,
+	0.398438f,
+	0.34375f,
+	0.40625f,
+	0.34375f,
+	0.414063f,
+	0.34375f,
+	0.421875f,
+	0.34375f,
+	0.429688f,
+	0.34375f,
+	0.4375f,
+	0.34375f,
+	0.445313f,
+	0.34375f,
+	0.453125f,
+	0.34375f,
+	0.460938f,
+	0.34375f,
+	0.46875f,
+	0.34375f,
+	0.476563f,
+	0.34375f,
+	0.484375f,
+	0.34375f,
+	0.492188f,
+	0.34375f,
+	0.5f,
+	0.34375f,
+	0.507813f,
+	0.34375f,
+	0.0f,
+	0.351563f,
+	0.0078125f,
+	0.351563f,
+	0.015625f,
+	0.351563f,
+	0.0234375f,
+	0.351563f,
+	0.03125f,
+	0.351563f,
+	0.0390625f,
+	0.351563f,
+	0.046875f,
+	0.351563f,
+	0.0546875f,
+	0.351563f,
+	0.0625f,
+	0.351563f,
+	0.0703125f,
+	0.351563f,
+	0.078125f,
+	0.351563f,
+	0.0859375f,
+	0.351563f,
+	0.09375f,
+	0.351563f,
+	0.101563f,
+	0.351563f,
+	0.109375f,
+	0.351563f,
+	0.117188f,
+	0.351563f,
+	0.125f,
+	0.351563f,
+	0.132813f,
+	0.351563f,
+	0.140625f,
+	0.351563f,
+	0.148438f,
+	0.351563f,
+	0.15625f,
+	0.351563f,
+	0.164063f,
+	0.351563f,
+	0.171875f,
+	0.351563f,
+	0.179688f,
+	0.351563f,
+	0.1875f,
+	0.351563f,
+	0.195313f,
+	0.351563f,
+	0.203125f,
+	0.351563f,
+	0.210938f,
+	0.351563f,
+	0.21875f,
+	0.351563f,
+	0.226563f,
+	0.351563f,
+	0.234375f,
+	0.351563f,
+	0.242188f,
+	0.351563f,
+	0.25f,
+	0.351563f,
+	0.257813f,
+	0.351563f,
+	0.265625f,
+	0.351563f,
+	0.273438f,
+	0.351563f,
+	0.28125f,
+	0.351563f,
+	0.289063f,
+	0.351563f,
+	0.296875f,
+	0.351563f,
+	0.304688f,
+	0.351563f,
+	0.3125f,
+	0.351563f,
+	0.320313f,
+	0.351563f,
+	0.328125f,
+	0.351563f,
+	0.335938f,
+	0.351563f,
+	0.34375f,
+	0.351563f,
+	0.351563f,
+	0.351563f,
+	0.359375f,
+	0.351563f,
+	0.367188f,
+	0.351563f,
+	0.375f,
+	0.351563f,
+	0.382813f,
+	0.351563f,
+	0.390625f,
+	0.351563f,
+	0.398438f,
+	0.351563f,
+	0.40625f,
+	0.351563f,
+	0.414063f,
+	0.351563f,
+	0.421875f,
+	0.351563f,
+	0.429688f,
+	0.351563f,
+	0.4375f,
+	0.351563f,
+	0.445313f,
+	0.351563f,
+	0.453125f,
+	0.351563f,
+	0.460938f,
+	0.351563f,
+	0.46875f,
+	0.351563f,
+	0.476563f,
+	0.351563f,
+	0.484375f,
+	0.351563f,
+	0.492188f,
+	0.351563f,
+	0.5f,
+	0.351563f,
+	0.507813f,
+	0.351563f,
+	0.0f,
+	0.359375f,
+	0.0078125f,
+	0.359375f,
+	0.015625f,
+	0.359375f,
+	0.0234375f,
+	0.359375f,
+	0.03125f,
+	0.359375f,
+	0.0390625f,
+	0.359375f,
+	0.046875f,
+	0.359375f,
+	0.0546875f,
+	0.359375f,
+	0.0625f,
+	0.359375f,
+	0.0703125f,
+	0.359375f,
+	0.078125f,
+	0.359375f,
+	0.0859375f,
+	0.359375f,
+	0.09375f,
+	0.359375f,
+	0.101563f,
+	0.359375f,
+	0.109375f,
+	0.359375f,
+	0.117188f,
+	0.359375f,
+	0.125f,
+	0.359375f,
+	0.132813f,
+	0.359375f,
+	0.140625f,
+	0.359375f,
+	0.148438f,
+	0.359375f,
+	0.15625f,
+	0.359375f,
+	0.164063f,
+	0.359375f,
+	0.171875f,
+	0.359375f,
+	0.179688f,
+	0.359375f,
+	0.1875f,
+	0.359375f,
+	0.195313f,
+	0.359375f,
+	0.203125f,
+	0.359375f,
+	0.210938f,
+	0.359375f,
+	0.21875f,
+	0.359375f,
+	0.226563f,
+	0.359375f,
+	0.234375f,
+	0.359375f,
+	0.242188f,
+	0.359375f,
+	0.25f,
+	0.359375f,
+	0.257813f,
+	0.359375f,
+	0.265625f,
+	0.359375f,
+	0.273438f,
+	0.359375f,
+	0.28125f,
+	0.359375f,
+	0.289063f,
+	0.359375f,
+	0.296875f,
+	0.359375f,
+	0.304688f,
+	0.359375f,
+	0.3125f,
+	0.359375f,
+	0.320313f,
+	0.359375f,
+	0.328125f,
+	0.359375f,
+	0.335938f,
+	0.359375f,
+	0.34375f,
+	0.359375f,
+	0.351563f,
+	0.359375f,
+	0.359375f,
+	0.359375f,
+	0.367188f,
+	0.359375f,
+	0.375f,
+	0.359375f,
+	0.382813f,
+	0.359375f,
+	0.390625f,
+	0.359375f,
+	0.398438f,
+	0.359375f,
+	0.40625f,
+	0.359375f,
+	0.414063f,
+	0.359375f,
+	0.421875f,
+	0.359375f,
+	0.429688f,
+	0.359375f,
+	0.4375f,
+	0.359375f,
+	0.445313f,
+	0.359375f,
+	0.453125f,
+	0.359375f,
+	0.460938f,
+	0.359375f,
+	0.46875f,
+	0.359375f,
+	0.476563f,
+	0.359375f,
+	0.484375f,
+	0.359375f,
+	0.492188f,
+	0.359375f,
+	0.5f,
+	0.359375f,
+	0.507813f,
+	0.359375f,
+	0.0f,
+	0.367188f,
+	0.0078125f,
+	0.367188f,
+	0.015625f,
+	0.367188f,
+	0.0234375f,
+	0.367188f,
+	0.03125f,
+	0.367188f,
+	0.0390625f,
+	0.367188f,
+	0.046875f,
+	0.367188f,
+	0.0546875f,
+	0.367188f,
+	0.0625f,
+	0.367188f,
+	0.0703125f,
+	0.367188f,
+	0.078125f,
+	0.367188f,
+	0.0859375f,
+	0.367188f,
+	0.09375f,
+	0.367188f,
+	0.101563f,
+	0.367188f,
+	0.109375f,
+	0.367188f,
+	0.117188f,
+	0.367188f,
+	0.125f,
+	0.367188f,
+	0.132813f,
+	0.367188f,
+	0.140625f,
+	0.367188f,
+	0.148438f,
+	0.367188f,
+	0.15625f,
+	0.367188f,
+	0.164063f,
+	0.367188f,
+	0.171875f,
+	0.367188f,
+	0.179688f,
+	0.367188f,
+	0.1875f,
+	0.367188f,
+	0.195313f,
+	0.367188f,
+	0.203125f,
+	0.367188f,
+	0.210938f,
+	0.367188f,
+	0.21875f,
+	0.367188f,
+	0.226563f,
+	0.367188f,
+	0.234375f,
+	0.367188f,
+	0.242188f,
+	0.367188f,
+	0.25f,
+	0.367188f,
+	0.257813f,
+	0.367188f,
+	0.265625f,
+	0.367188f,
+	0.273438f,
+	0.367188f,
+	0.28125f,
+	0.367188f,
+	0.289063f,
+	0.367188f,
+	0.296875f,
+	0.367188f,
+	0.304688f,
+	0.367188f,
+	0.3125f,
+	0.367188f,
+	0.320313f,
+	0.367188f,
+	0.328125f,
+	0.367188f,
+	0.335938f,
+	0.367188f,
+	0.34375f,
+	0.367188f,
+	0.351563f,
+	0.367188f,
+	0.359375f,
+	0.367188f,
+	0.367188f,
+	0.367188f,
+	0.375f,
+	0.367188f,
+	0.382813f,
+	0.367188f,
+	0.390625f,
+	0.367188f,
+	0.398438f,
+	0.367188f,
+	0.40625f,
+	0.367188f,
+	0.414063f,
+	0.367188f,
+	0.421875f,
+	0.367188f,
+	0.429688f,
+	0.367188f,
+	0.4375f,
+	0.367188f,
+	0.445313f,
+	0.367188f,
+	0.453125f,
+	0.367188f,
+	0.460938f,
+	0.367188f,
+	0.46875f,
+	0.367188f,
+	0.476563f,
+	0.367188f,
+	0.484375f,
+	0.367188f,
+	0.492188f,
+	0.367188f,
+	0.5f,
+	0.367188f,
+	0.507813f,
+	0.367188f,
+	0.0f,
+	0.375f,
+	0.0078125f,
+	0.375f,
+	0.015625f,
+	0.375f,
+	0.0234375f,
+	0.375f,
+	0.03125f,
+	0.375f,
+	0.0390625f,
+	0.375f,
+	0.046875f,
+	0.375f,
+	0.0546875f,
+	0.375f,
+	0.0625f,
+	0.375f,
+	0.0703125f,
+	0.375f,
+	0.078125f,
+	0.375f,
+	0.0859375f,
+	0.375f,
+	0.09375f,
+	0.375f,
+	0.101563f,
+	0.375f,
+	0.109375f,
+	0.375f,
+	0.117188f,
+	0.375f,
+	0.125f,
+	0.375f,
+	0.132813f,
+	0.375f,
+	0.140625f,
+	0.375f,
+	0.148438f,
+	0.375f,
+	0.15625f,
+	0.375f,
+	0.164063f,
+	0.375f,
+	0.171875f,
+	0.375f,
+	0.179688f,
+	0.375f,
+	0.1875f,
+	0.375f,
+	0.195313f,
+	0.375f,
+	0.203125f,
+	0.375f,
+	0.210938f,
+	0.375f,
+	0.21875f,
+	0.375f,
+	0.226563f,
+	0.375f,
+	0.234375f,
+	0.375f,
+	0.242188f,
+	0.375f,
+	0.25f,
+	0.375f,
+	0.257813f,
+	0.375f,
+	0.265625f,
+	0.375f,
+	0.273438f,
+	0.375f,
+	0.28125f,
+	0.375f,
+	0.289063f,
+	0.375f,
+	0.296875f,
+	0.375f,
+	0.304688f,
+	0.375f,
+	0.3125f,
+	0.375f,
+	0.320313f,
+	0.375f,
+	0.328125f,
+	0.375f,
+	0.335938f,
+	0.375f,
+	0.34375f,
+	0.375f,
+	0.351563f,
+	0.375f,
+	0.359375f,
+	0.375f,
+	0.367188f,
+	0.375f,
+	0.375f,
+	0.375f,
+	0.382813f,
+	0.375f,
+	0.390625f,
+	0.375f,
+	0.398438f,
+	0.375f,
+	0.40625f,
+	0.375f,
+	0.414063f,
+	0.375f,
+	0.421875f,
+	0.375f,
+	0.429688f,
+	0.375f,
+	0.4375f,
+	0.375f,
+	0.445313f,
+	0.375f,
+	0.453125f,
+	0.375f,
+	0.460938f,
+	0.375f,
+	0.46875f,
+	0.375f,
+	0.476563f,
+	0.375f,
+	0.484375f,
+	0.375f,
+	0.492188f,
+	0.375f,
+	0.5f,
+	0.375f,
+	0.507813f,
+	0.375f,
+	0.0f,
+	0.382813f,
+	0.0078125f,
+	0.382813f,
+	0.015625f,
+	0.382813f,
+	0.0234375f,
+	0.382813f,
+	0.03125f,
+	0.382813f,
+	0.0390625f,
+	0.382813f,
+	0.046875f,
+	0.382813f,
+	0.0546875f,
+	0.382813f,
+	0.0625f,
+	0.382813f,
+	0.0703125f,
+	0.382813f,
+	0.078125f,
+	0.382813f,
+	0.0859375f,
+	0.382813f,
+	0.09375f,
+	0.382813f,
+	0.101563f,
+	0.382813f,
+	0.109375f,
+	0.382813f,
+	0.117188f,
+	0.382813f,
+	0.125f,
+	0.382813f,
+	0.132813f,
+	0.382813f,
+	0.140625f,
+	0.382813f,
+	0.148438f,
+	0.382813f,
+	0.15625f,
+	0.382813f,
+	0.164063f,
+	0.382813f,
+	0.171875f,
+	0.382813f,
+	0.179688f,
+	0.382813f,
+	0.1875f,
+	0.382813f,
+	0.195313f,
+	0.382813f,
+	0.203125f,
+	0.382813f,
+	0.210938f,
+	0.382813f,
+	0.21875f,
+	0.382813f,
+	0.226563f,
+	0.382813f,
+	0.234375f,
+	0.382813f,
+	0.242188f,
+	0.382813f,
+	0.25f,
+	0.382813f,
+	0.257813f,
+	0.382813f,
+	0.265625f,
+	0.382813f,
+	0.273438f,
+	0.382813f,
+	0.28125f,
+	0.382813f,
+	0.289063f,
+	0.382813f,
+	0.296875f,
+	0.382813f,
+	0.304688f,
+	0.382813f,
+	0.3125f,
+	0.382813f,
+	0.320313f,
+	0.382813f,
+	0.328125f,
+	0.382813f,
+	0.335938f,
+	0.382813f,
+	0.34375f,
+	0.382813f,
+	0.351563f,
+	0.382813f,
+	0.359375f,
+	0.382813f,
+	0.367188f,
+	0.382813f,
+	0.375f,
+	0.382813f,
+	0.382813f,
+	0.382813f,
+	0.390625f,
+	0.382813f,
+	0.398438f,
+	0.382813f,
+	0.40625f,
+	0.382813f,
+	0.414063f,
+	0.382813f,
+	0.421875f,
+	0.382813f,
+	0.429688f,
+	0.382813f,
+	0.4375f,
+	0.382813f,
+	0.445313f,
+	0.382813f,
+	0.453125f,
+	0.382813f,
+	0.460938f,
+	0.382813f,
+	0.46875f,
+	0.382813f,
+	0.476563f,
+	0.382813f,
+	0.484375f,
+	0.382813f,
+	0.492188f,
+	0.382813f,
+	0.5f,
+	0.382813f,
+	0.507813f,
+	0.382813f,
+	0.0f,
+	0.390625f,
+	0.0078125f,
+	0.390625f,
+	0.015625f,
+	0.390625f,
+	0.0234375f,
+	0.390625f,
+	0.03125f,
+	0.390625f,
+	0.0390625f,
+	0.390625f,
+	0.046875f,
+	0.390625f,
+	0.0546875f,
+	0.390625f,
+	0.0625f,
+	0.390625f,
+	0.0703125f,
+	0.390625f,
+	0.078125f,
+	0.390625f,
+	0.0859375f,
+	0.390625f,
+	0.09375f,
+	0.390625f,
+	0.101563f,
+	0.390625f,
+	0.109375f,
+	0.390625f,
+	0.117188f,
+	0.390625f,
+	0.125f,
+	0.390625f,
+	0.132813f,
+	0.390625f,
+	0.140625f,
+	0.390625f,
+	0.148438f,
+	0.390625f,
+	0.15625f,
+	0.390625f,
+	0.164063f,
+	0.390625f,
+	0.171875f,
+	0.390625f,
+	0.179688f,
+	0.390625f,
+	0.1875f,
+	0.390625f,
+	0.195313f,
+	0.390625f,
+	0.203125f,
+	0.390625f,
+	0.210938f,
+	0.390625f,
+	0.21875f,
+	0.390625f,
+	0.226563f,
+	0.390625f,
+	0.234375f,
+	0.390625f,
+	0.242188f,
+	0.390625f,
+	0.25f,
+	0.390625f,
+	0.257813f,
+	0.390625f,
+	0.265625f,
+	0.390625f,
+	0.273438f,
+	0.390625f,
+	0.28125f,
+	0.390625f,
+	0.289063f,
+	0.390625f,
+	0.296875f,
+	0.390625f,
+	0.304688f,
+	0.390625f,
+	0.3125f,
+	0.390625f,
+	0.320313f,
+	0.390625f,
+	0.328125f,
+	0.390625f,
+	0.335938f,
+	0.390625f,
+	0.34375f,
+	0.390625f,
+	0.351563f,
+	0.390625f,
+	0.359375f,
+	0.390625f,
+	0.367188f,
+	0.390625f,
+	0.375f,
+	0.390625f,
+	0.382813f,
+	0.390625f,
+	0.390625f,
+	0.390625f,
+	0.398438f,
+	0.390625f,
+	0.40625f,
+	0.390625f,
+	0.414063f,
+	0.390625f,
+	0.421875f,
+	0.390625f,
+	0.429688f,
+	0.390625f,
+	0.4375f,
+	0.390625f,
+	0.445313f,
+	0.390625f,
+	0.453125f,
+	0.390625f,
+	0.460938f,
+	0.390625f,
+	0.46875f,
+	0.390625f,
+	0.476563f,
+	0.390625f,
+	0.484375f,
+	0.390625f,
+	0.492188f,
+	0.390625f,
+	0.5f,
+	0.390625f,
+	0.507813f,
+	0.390625f,
+	0.0f,
+	0.398438f,
+	0.0078125f,
+	0.398438f,
+	0.015625f,
+	0.398438f,
+	0.0234375f,
+	0.398438f,
+	0.03125f,
+	0.398438f,
+	0.0390625f,
+	0.398438f,
+	0.046875f,
+	0.398438f,
+	0.0546875f,
+	0.398438f,
+	0.0625f,
+	0.398438f,
+	0.0703125f,
+	0.398438f,
+	0.078125f,
+	0.398438f,
+	0.0859375f,
+	0.398438f,
+	0.09375f,
+	0.398438f,
+	0.101563f,
+	0.398438f,
+	0.109375f,
+	0.398438f,
+	0.117188f,
+	0.398438f,
+	0.125f,
+	0.398438f,
+	0.132813f,
+	0.398438f,
+	0.140625f,
+	0.398438f,
+	0.148438f,
+	0.398438f,
+	0.15625f,
+	0.398438f,
+	0.164063f,
+	0.398438f,
+	0.171875f,
+	0.398438f,
+	0.179688f,
+	0.398438f,
+	0.1875f,
+	0.398438f,
+	0.195313f,
+	0.398438f,
+	0.203125f,
+	0.398438f,
+	0.210938f,
+	0.398438f,
+	0.21875f,
+	0.398438f,
+	0.226563f,
+	0.398438f,
+	0.234375f,
+	0.398438f,
+	0.242188f,
+	0.398438f,
+	0.25f,
+	0.398438f,
+	0.257813f,
+	0.398438f,
+	0.265625f,
+	0.398438f,
+	0.273438f,
+	0.398438f,
+	0.28125f,
+	0.398438f,
+	0.289063f,
+	0.398438f,
+	0.296875f,
+	0.398438f,
+	0.304688f,
+	0.398438f,
+	0.3125f,
+	0.398438f,
+	0.320313f,
+	0.398438f,
+	0.328125f,
+	0.398438f,
+	0.335938f,
+	0.398438f,
+	0.34375f,
+	0.398438f,
+	0.351563f,
+	0.398438f,
+	0.359375f,
+	0.398438f,
+	0.367188f,
+	0.398438f,
+	0.375f,
+	0.398438f,
+	0.382813f,
+	0.398438f,
+	0.390625f,
+	0.398438f,
+	0.398438f,
+	0.398438f,
+	0.40625f,
+	0.398438f,
+	0.414063f,
+	0.398438f,
+	0.421875f,
+	0.398438f,
+	0.429688f,
+	0.398438f,
+	0.4375f,
+	0.398438f,
+	0.445313f,
+	0.398438f,
+	0.453125f,
+	0.398438f,
+	0.460938f,
+	0.398438f,
+	0.46875f,
+	0.398438f,
+	0.476563f,
+	0.398438f,
+	0.484375f,
+	0.398438f,
+	0.492188f,
+	0.398438f,
+	0.5f,
+	0.398438f,
+	0.507813f,
+	0.398438f,
+	0.0f,
+	0.40625f,
+	0.0078125f,
+	0.40625f,
+	0.015625f,
+	0.40625f,
+	0.0234375f,
+	0.40625f,
+	0.03125f,
+	0.40625f,
+	0.0390625f,
+	0.40625f,
+	0.046875f,
+	0.40625f,
+	0.0546875f,
+	0.40625f,
+	0.0625f,
+	0.40625f,
+	0.0703125f,
+	0.40625f,
+	0.078125f,
+	0.40625f,
+	0.0859375f,
+	0.40625f,
+	0.09375f,
+	0.40625f,
+	0.101563f,
+	0.40625f,
+	0.109375f,
+	0.40625f,
+	0.117188f,
+	0.40625f,
+	0.125f,
+	0.40625f,
+	0.132813f,
+	0.40625f,
+	0.140625f,
+	0.40625f,
+	0.148438f,
+	0.40625f,
+	0.15625f,
+	0.40625f,
+	0.164063f,
+	0.40625f,
+	0.171875f,
+	0.40625f,
+	0.179688f,
+	0.40625f,
+	0.1875f,
+	0.40625f,
+	0.195313f,
+	0.40625f,
+	0.203125f,
+	0.40625f,
+	0.210938f,
+	0.40625f,
+	0.21875f,
+	0.40625f,
+	0.226563f,
+	0.40625f,
+	0.234375f,
+	0.40625f,
+	0.242188f,
+	0.40625f,
+	0.25f,
+	0.40625f,
+	0.257813f,
+	0.40625f,
+	0.265625f,
+	0.40625f,
+	0.273438f,
+	0.40625f,
+	0.28125f,
+	0.40625f,
+	0.289063f,
+	0.40625f,
+	0.296875f,
+	0.40625f,
+	0.304688f,
+	0.40625f,
+	0.3125f,
+	0.40625f,
+	0.320313f,
+	0.40625f,
+	0.328125f,
+	0.40625f,
+	0.335938f,
+	0.40625f,
+	0.34375f,
+	0.40625f,
+	0.351563f,
+	0.40625f,
+	0.359375f,
+	0.40625f,
+	0.367188f,
+	0.40625f,
+	0.375f,
+	0.40625f,
+	0.382813f,
+	0.40625f,
+	0.390625f,
+	0.40625f,
+	0.398438f,
+	0.40625f,
+	0.40625f,
+	0.40625f,
+	0.414063f,
+	0.40625f,
+	0.421875f,
+	0.40625f,
+	0.429688f,
+	0.40625f,
+	0.4375f,
+	0.40625f,
+	0.445313f,
+	0.40625f,
+	0.453125f,
+	0.40625f,
+	0.460938f,
+	0.40625f,
+	0.46875f,
+	0.40625f,
+	0.476563f,
+	0.40625f,
+	0.484375f,
+	0.40625f,
+	0.492188f,
+	0.40625f,
+	0.5f,
+	0.40625f,
+	0.507813f,
+	0.40625f,
+	0.0f,
+	0.414063f,
+	0.0078125f,
+	0.414063f,
+	0.015625f,
+	0.414063f,
+	0.0234375f,
+	0.414063f,
+	0.03125f,
+	0.414063f,
+	0.0390625f,
+	0.414063f,
+	0.046875f,
+	0.414063f,
+	0.0546875f,
+	0.414063f,
+	0.0625f,
+	0.414063f,
+	0.0703125f,
+	0.414063f,
+	0.078125f,
+	0.414063f,
+	0.0859375f,
+	0.414063f,
+	0.09375f,
+	0.414063f,
+	0.101563f,
+	0.414063f,
+	0.109375f,
+	0.414063f,
+	0.117188f,
+	0.414063f,
+	0.125f,
+	0.414063f,
+	0.132813f,
+	0.414063f,
+	0.140625f,
+	0.414063f,
+	0.148438f,
+	0.414063f,
+	0.15625f,
+	0.414063f,
+	0.164063f,
+	0.414063f,
+	0.171875f,
+	0.414063f,
+	0.179688f,
+	0.414063f,
+	0.1875f,
+	0.414063f,
+	0.195313f,
+	0.414063f,
+	0.203125f,
+	0.414063f,
+	0.210938f,
+	0.414063f,
+	0.21875f,
+	0.414063f,
+	0.226563f,
+	0.414063f,
+	0.234375f,
+	0.414063f,
+	0.242188f,
+	0.414063f,
+	0.25f,
+	0.414063f,
+	0.257813f,
+	0.414063f,
+	0.265625f,
+	0.414063f,
+	0.273438f,
+	0.414063f,
+	0.28125f,
+	0.414063f,
+	0.289063f,
+	0.414063f,
+	0.296875f,
+	0.414063f,
+	0.304688f,
+	0.414063f,
+	0.3125f,
+	0.414063f,
+	0.320313f,
+	0.414063f,
+	0.328125f,
+	0.414063f,
+	0.335938f,
+	0.414063f,
+	0.34375f,
+	0.414063f,
+	0.351563f,
+	0.414063f,
+	0.359375f,
+	0.414063f,
+	0.367188f,
+	0.414063f,
+	0.375f,
+	0.414063f,
+	0.382813f,
+	0.414063f,
+	0.390625f,
+	0.414063f,
+	0.398438f,
+	0.414063f,
+	0.40625f,
+	0.414063f,
+	0.414063f,
+	0.414063f,
+	0.421875f,
+	0.414063f,
+	0.429688f,
+	0.414063f,
+	0.4375f,
+	0.414063f,
+	0.445313f,
+	0.414063f,
+	0.453125f,
+	0.414063f,
+	0.460938f,
+	0.414063f,
+	0.46875f,
+	0.414063f,
+	0.476563f,
+	0.414063f,
+	0.484375f,
+	0.414063f,
+	0.492188f,
+	0.414063f,
+	0.5f,
+	0.414063f,
+	0.507813f,
+	0.414063f,
+	0.0f,
+	0.421875f,
+	0.0078125f,
+	0.421875f,
+	0.015625f,
+	0.421875f,
+	0.0234375f,
+	0.421875f,
+	0.03125f,
+	0.421875f,
+	0.0390625f,
+	0.421875f,
+	0.046875f,
+	0.421875f,
+	0.0546875f,
+	0.421875f,
+	0.0625f,
+	0.421875f,
+	0.0703125f,
+	0.421875f,
+	0.078125f,
+	0.421875f,
+	0.0859375f,
+	0.421875f,
+	0.09375f,
+	0.421875f,
+	0.101563f,
+	0.421875f,
+	0.109375f,
+	0.421875f,
+	0.117188f,
+	0.421875f,
+	0.125f,
+	0.421875f,
+	0.132813f,
+	0.421875f,
+	0.140625f,
+	0.421875f,
+	0.148438f,
+	0.421875f,
+	0.15625f,
+	0.421875f,
+	0.164063f,
+	0.421875f,
+	0.171875f,
+	0.421875f,
+	0.179688f,
+	0.421875f,
+	0.1875f,
+	0.421875f,
+	0.195313f,
+	0.421875f,
+	0.203125f,
+	0.421875f,
+	0.210938f,
+	0.421875f,
+	0.21875f,
+	0.421875f,
+	0.226563f,
+	0.421875f,
+	0.234375f,
+	0.421875f,
+	0.242188f,
+	0.421875f,
+	0.25f,
+	0.421875f,
+	0.257813f,
+	0.421875f,
+	0.265625f,
+	0.421875f,
+	0.273438f,
+	0.421875f,
+	0.28125f,
+	0.421875f,
+	0.289063f,
+	0.421875f,
+	0.296875f,
+	0.421875f,
+	0.304688f,
+	0.421875f,
+	0.3125f,
+	0.421875f,
+	0.320313f,
+	0.421875f,
+	0.328125f,
+	0.421875f,
+	0.335938f,
+	0.421875f,
+	0.34375f,
+	0.421875f,
+	0.351563f,
+	0.421875f,
+	0.359375f,
+	0.421875f,
+	0.367188f,
+	0.421875f,
+	0.375f,
+	0.421875f,
+	0.382813f,
+	0.421875f,
+	0.390625f,
+	0.421875f,
+	0.398438f,
+	0.421875f,
+	0.40625f,
+	0.421875f,
+	0.414063f,
+	0.421875f,
+	0.421875f,
+	0.421875f,
+	0.429688f,
+	0.421875f,
+	0.4375f,
+	0.421875f,
+	0.445313f,
+	0.421875f,
+	0.453125f,
+	0.421875f,
+	0.460938f,
+	0.421875f,
+	0.46875f,
+	0.421875f,
+	0.476563f,
+	0.421875f,
+	0.484375f,
+	0.421875f,
+	0.492188f,
+	0.421875f,
+	0.5f,
+	0.421875f,
+	0.507813f,
+	0.421875f,
+	0.0f,
+	0.429688f,
+	0.0078125f,
+	0.429688f,
+	0.015625f,
+	0.429688f,
+	0.0234375f,
+	0.429688f,
+	0.03125f,
+	0.429688f,
+	0.0390625f,
+	0.429688f,
+	0.046875f,
+	0.429688f,
+	0.0546875f,
+	0.429688f,
+	0.0625f,
+	0.429688f,
+	0.0703125f,
+	0.429688f,
+	0.078125f,
+	0.429688f,
+	0.0859375f,
+	0.429688f,
+	0.09375f,
+	0.429688f,
+	0.101563f,
+	0.429688f,
+	0.109375f,
+	0.429688f,
+	0.117188f,
+	0.429688f,
+	0.125f,
+	0.429688f,
+	0.132813f,
+	0.429688f,
+	0.140625f,
+	0.429688f,
+	0.148438f,
+	0.429688f,
+	0.15625f,
+	0.429688f,
+	0.164063f,
+	0.429688f,
+	0.171875f,
+	0.429688f,
+	0.179688f,
+	0.429688f,
+	0.1875f,
+	0.429688f,
+	0.195313f,
+	0.429688f,
+	0.203125f,
+	0.429688f,
+	0.210938f,
+	0.429688f,
+	0.21875f,
+	0.429688f,
+	0.226563f,
+	0.429688f,
+	0.234375f,
+	0.429688f,
+	0.242188f,
+	0.429688f,
+	0.25f,
+	0.429688f,
+	0.257813f,
+	0.429688f,
+	0.265625f,
+	0.429688f,
+	0.273438f,
+	0.429688f,
+	0.28125f,
+	0.429688f,
+	0.289063f,
+	0.429688f,
+	0.296875f,
+	0.429688f,
+	0.304688f,
+	0.429688f,
+	0.3125f,
+	0.429688f,
+	0.320313f,
+	0.429688f,
+	0.328125f,
+	0.429688f,
+	0.335938f,
+	0.429688f,
+	0.34375f,
+	0.429688f,
+	0.351563f,
+	0.429688f,
+	0.359375f,
+	0.429688f,
+	0.367188f,
+	0.429688f,
+	0.375f,
+	0.429688f,
+	0.382813f,
+	0.429688f,
+	0.390625f,
+	0.429688f,
+	0.398438f,
+	0.429688f,
+	0.40625f,
+	0.429688f,
+	0.414063f,
+	0.429688f,
+	0.421875f,
+	0.429688f,
+	0.429688f,
+	0.429688f,
+	0.4375f,
+	0.429688f,
+	0.445313f,
+	0.429688f,
+	0.453125f,
+	0.429688f,
+	0.460938f,
+	0.429688f,
+	0.46875f,
+	0.429688f,
+	0.476563f,
+	0.429688f,
+	0.484375f,
+	0.429688f,
+	0.492188f,
+	0.429688f,
+	0.5f,
+	0.429688f,
+	0.507813f,
+	0.429688f,
+	0.0f,
+	0.4375f,
+	0.0078125f,
+	0.4375f,
+	0.015625f,
+	0.4375f,
+	0.0234375f,
+	0.4375f,
+	0.03125f,
+	0.4375f,
+	0.0390625f,
+	0.4375f,
+	0.046875f,
+	0.4375f,
+	0.0546875f,
+	0.4375f,
+	0.0625f,
+	0.4375f,
+	0.0703125f,
+	0.4375f,
+	0.078125f,
+	0.4375f,
+	0.0859375f,
+	0.4375f,
+	0.09375f,
+	0.4375f,
+	0.101563f,
+	0.4375f,
+	0.109375f,
+	0.4375f,
+	0.117188f,
+	0.4375f,
+	0.125f,
+	0.4375f,
+	0.132813f,
+	0.4375f,
+	0.140625f,
+	0.4375f,
+	0.148438f,
+	0.4375f,
+	0.15625f,
+	0.4375f,
+	0.164063f,
+	0.4375f,
+	0.171875f,
+	0.4375f,
+	0.179688f,
+	0.4375f,
+	0.1875f,
+	0.4375f,
+	0.195313f,
+	0.4375f,
+	0.203125f,
+	0.4375f,
+	0.210938f,
+	0.4375f,
+	0.21875f,
+	0.4375f,
+	0.226563f,
+	0.4375f,
+	0.234375f,
+	0.4375f,
+	0.242188f,
+	0.4375f,
+	0.25f,
+	0.4375f,
+	0.257813f,
+	0.4375f,
+	0.265625f,
+	0.4375f,
+	0.273438f,
+	0.4375f,
+	0.28125f,
+	0.4375f,
+	0.289063f,
+	0.4375f,
+	0.296875f,
+	0.4375f,
+	0.304688f,
+	0.4375f,
+	0.3125f,
+	0.4375f,
+	0.320313f,
+	0.4375f,
+	0.328125f,
+	0.4375f,
+	0.335938f,
+	0.4375f,
+	0.34375f,
+	0.4375f,
+	0.351563f,
+	0.4375f,
+	0.359375f,
+	0.4375f,
+	0.367188f,
+	0.4375f,
+	0.375f,
+	0.4375f,
+	0.382813f,
+	0.4375f,
+	0.390625f,
+	0.4375f,
+	0.398438f,
+	0.4375f,
+	0.40625f,
+	0.4375f,
+	0.414063f,
+	0.4375f,
+	0.421875f,
+	0.4375f,
+	0.429688f,
+	0.4375f,
+	0.4375f,
+	0.4375f,
+	0.445313f,
+	0.4375f,
+	0.453125f,
+	0.4375f,
+	0.460938f,
+	0.4375f,
+	0.46875f,
+	0.4375f,
+	0.476563f,
+	0.4375f,
+	0.484375f,
+	0.4375f,
+	0.492188f,
+	0.4375f,
+	0.5f,
+	0.4375f,
+	0.507813f,
+	0.4375f,
+	0.0f,
+	0.445313f,
+	0.0078125f,
+	0.445313f,
+	0.015625f,
+	0.445313f,
+	0.0234375f,
+	0.445313f,
+	0.03125f,
+	0.445313f,
+	0.0390625f,
+	0.445313f,
+	0.046875f,
+	0.445313f,
+	0.0546875f,
+	0.445313f,
+	0.0625f,
+	0.445313f,
+	0.0703125f,
+	0.445313f,
+	0.078125f,
+	0.445313f,
+	0.0859375f,
+	0.445313f,
+	0.09375f,
+	0.445313f,
+	0.101563f,
+	0.445313f,
+	0.109375f,
+	0.445313f,
+	0.117188f,
+	0.445313f,
+	0.125f,
+	0.445313f,
+	0.132813f,
+	0.445313f,
+	0.140625f,
+	0.445313f,
+	0.148438f,
+	0.445313f,
+	0.15625f,
+	0.445313f,
+	0.164063f,
+	0.445313f,
+	0.171875f,
+	0.445313f,
+	0.179688f,
+	0.445313f,
+	0.1875f,
+	0.445313f,
+	0.195313f,
+	0.445313f,
+	0.203125f,
+	0.445313f,
+	0.210938f,
+	0.445313f,
+	0.21875f,
+	0.445313f,
+	0.226563f,
+	0.445313f,
+	0.234375f,
+	0.445313f,
+	0.242188f,
+	0.445313f,
+	0.25f,
+	0.445313f,
+	0.257813f,
+	0.445313f,
+	0.265625f,
+	0.445313f,
+	0.273438f,
+	0.445313f,
+	0.28125f,
+	0.445313f,
+	0.289063f,
+	0.445313f,
+	0.296875f,
+	0.445313f,
+	0.304688f,
+	0.445313f,
+	0.3125f,
+	0.445313f,
+	0.320313f,
+	0.445313f,
+	0.328125f,
+	0.445313f,
+	0.335938f,
+	0.445313f,
+	0.34375f,
+	0.445313f,
+	0.351563f,
+	0.445313f,
+	0.359375f,
+	0.445313f,
+	0.367188f,
+	0.445313f,
+	0.375f,
+	0.445313f,
+	0.382813f,
+	0.445313f,
+	0.390625f,
+	0.445313f,
+	0.398438f,
+	0.445313f,
+	0.40625f,
+	0.445313f,
+	0.414063f,
+	0.445313f,
+	0.421875f,
+	0.445313f,
+	0.429688f,
+	0.445313f,
+	0.4375f,
+	0.445313f,
+	0.445313f,
+	0.445313f,
+	0.453125f,
+	0.445313f,
+	0.460938f,
+	0.445313f,
+	0.46875f,
+	0.445313f,
+	0.476563f,
+	0.445313f,
+	0.484375f,
+	0.445313f,
+	0.492188f,
+	0.445313f,
+	0.5f,
+	0.445313f,
+	0.507813f,
+	0.445313f,
+	0.0f,
+	0.453125f,
+	0.0078125f,
+	0.453125f,
+	0.015625f,
+	0.453125f,
+	0.0234375f,
+	0.453125f,
+	0.03125f,
+	0.453125f,
+	0.0390625f,
+	0.453125f,
+	0.046875f,
+	0.453125f,
+	0.0546875f,
+	0.453125f,
+	0.0625f,
+	0.453125f,
+	0.0703125f,
+	0.453125f,
+	0.078125f,
+	0.453125f,
+	0.0859375f,
+	0.453125f,
+	0.09375f,
+	0.453125f,
+	0.101563f,
+	0.453125f,
+	0.109375f,
+	0.453125f,
+	0.117188f,
+	0.453125f,
+	0.125f,
+	0.453125f,
+	0.132813f,
+	0.453125f,
+	0.140625f,
+	0.453125f,
+	0.148438f,
+	0.453125f,
+	0.15625f,
+	0.453125f,
+	0.164063f,
+	0.453125f,
+	0.171875f,
+	0.453125f,
+	0.179688f,
+	0.453125f,
+	0.1875f,
+	0.453125f,
+	0.195313f,
+	0.453125f,
+	0.203125f,
+	0.453125f,
+	0.210938f,
+	0.453125f,
+	0.21875f,
+	0.453125f,
+	0.226563f,
+	0.453125f,
+	0.234375f,
+	0.453125f,
+	0.242188f,
+	0.453125f,
+	0.25f,
+	0.453125f,
+	0.257813f,
+	0.453125f,
+	0.265625f,
+	0.453125f,
+	0.273438f,
+	0.453125f,
+	0.28125f,
+	0.453125f,
+	0.289063f,
+	0.453125f,
+	0.296875f,
+	0.453125f,
+	0.304688f,
+	0.453125f,
+	0.3125f,
+	0.453125f,
+	0.320313f,
+	0.453125f,
+	0.328125f,
+	0.453125f,
+	0.335938f,
+	0.453125f,
+	0.34375f,
+	0.453125f,
+	0.351563f,
+	0.453125f,
+	0.359375f,
+	0.453125f,
+	0.367188f,
+	0.453125f,
+	0.375f,
+	0.453125f,
+	0.382813f,
+	0.453125f,
+	0.390625f,
+	0.453125f,
+	0.398438f,
+	0.453125f,
+	0.40625f,
+	0.453125f,
+	0.414063f,
+	0.453125f,
+	0.421875f,
+	0.453125f,
+	0.429688f,
+	0.453125f,
+	0.4375f,
+	0.453125f,
+	0.445313f,
+	0.453125f,
+	0.453125f,
+	0.453125f,
+	0.460938f,
+	0.453125f,
+	0.46875f,
+	0.453125f,
+	0.476563f,
+	0.453125f,
+	0.484375f,
+	0.453125f,
+	0.492188f,
+	0.453125f,
+	0.5f,
+	0.453125f,
+	0.507813f,
+	0.453125f,
+	0.0f,
+	0.460938f,
+	0.0078125f,
+	0.460938f,
+	0.015625f,
+	0.460938f,
+	0.0234375f,
+	0.460938f,
+	0.03125f,
+	0.460938f,
+	0.0390625f,
+	0.460938f,
+	0.046875f,
+	0.460938f,
+	0.0546875f,
+	0.460938f,
+	0.0625f,
+	0.460938f,
+	0.0703125f,
+	0.460938f,
+	0.078125f,
+	0.460938f,
+	0.0859375f,
+	0.460938f,
+	0.09375f,
+	0.460938f,
+	0.101563f,
+	0.460938f,
+	0.109375f,
+	0.460938f,
+	0.117188f,
+	0.460938f,
+	0.125f,
+	0.460938f,
+	0.132813f,
+	0.460938f,
+	0.140625f,
+	0.460938f,
+	0.148438f,
+	0.460938f,
+	0.15625f,
+	0.460938f,
+	0.164063f,
+	0.460938f,
+	0.171875f,
+	0.460938f,
+	0.179688f,
+	0.460938f,
+	0.1875f,
+	0.460938f,
+	0.195313f,
+	0.460938f,
+	0.203125f,
+	0.460938f,
+	0.210938f,
+	0.460938f,
+	0.21875f,
+	0.460938f,
+	0.226563f,
+	0.460938f,
+	0.234375f,
+	0.460938f,
+	0.242188f,
+	0.460938f,
+	0.25f,
+	0.460938f,
+	0.257813f,
+	0.460938f,
+	0.265625f,
+	0.460938f,
+	0.273438f,
+	0.460938f,
+	0.28125f,
+	0.460938f,
+	0.289063f,
+	0.460938f,
+	0.296875f,
+	0.460938f,
+	0.304688f,
+	0.460938f,
+	0.3125f,
+	0.460938f,
+	0.320313f,
+	0.460938f,
+	0.328125f,
+	0.460938f,
+	0.335938f,
+	0.460938f,
+	0.34375f,
+	0.460938f,
+	0.351563f,
+	0.460938f,
+	0.359375f,
+	0.460938f,
+	0.367188f,
+	0.460938f,
+	0.375f,
+	0.460938f,
+	0.382813f,
+	0.460938f,
+	0.390625f,
+	0.460938f,
+	0.398438f,
+	0.460938f,
+	0.40625f,
+	0.460938f,
+	0.414063f,
+	0.460938f,
+	0.421875f,
+	0.460938f,
+	0.429688f,
+	0.460938f,
+	0.4375f,
+	0.460938f,
+	0.445313f,
+	0.460938f,
+	0.453125f,
+	0.460938f,
+	0.460938f,
+	0.460938f,
+	0.46875f,
+	0.460938f,
+	0.476563f,
+	0.460938f,
+	0.484375f,
+	0.460938f,
+	0.492188f,
+	0.460938f,
+	0.5f,
+	0.460938f,
+	0.507813f,
+	0.460938f,
+	0.0f,
+	0.46875f,
+	0.0078125f,
+	0.46875f,
+	0.015625f,
+	0.46875f,
+	0.0234375f,
+	0.46875f,
+	0.03125f,
+	0.46875f,
+	0.0390625f,
+	0.46875f,
+	0.046875f,
+	0.46875f,
+	0.0546875f,
+	0.46875f,
+	0.0625f,
+	0.46875f,
+	0.0703125f,
+	0.46875f,
+	0.078125f,
+	0.46875f,
+	0.0859375f,
+	0.46875f,
+	0.09375f,
+	0.46875f,
+	0.101563f,
+	0.46875f,
+	0.109375f,
+	0.46875f,
+	0.117188f,
+	0.46875f,
+	0.125f,
+	0.46875f,
+	0.132813f,
+	0.46875f,
+	0.140625f,
+	0.46875f,
+	0.148438f,
+	0.46875f,
+	0.15625f,
+	0.46875f,
+	0.164063f,
+	0.46875f,
+	0.171875f,
+	0.46875f,
+	0.179688f,
+	0.46875f,
+	0.1875f,
+	0.46875f,
+	0.195313f,
+	0.46875f,
+	0.203125f,
+	0.46875f,
+	0.210938f,
+	0.46875f,
+	0.21875f,
+	0.46875f,
+	0.226563f,
+	0.46875f,
+	0.234375f,
+	0.46875f,
+	0.242188f,
+	0.46875f,
+	0.25f,
+	0.46875f,
+	0.257813f,
+	0.46875f,
+	0.265625f,
+	0.46875f,
+	0.273438f,
+	0.46875f,
+	0.28125f,
+	0.46875f,
+	0.289063f,
+	0.46875f,
+	0.296875f,
+	0.46875f,
+	0.304688f,
+	0.46875f,
+	0.3125f,
+	0.46875f,
+	0.320313f,
+	0.46875f,
+	0.328125f,
+	0.46875f,
+	0.335938f,
+	0.46875f,
+	0.34375f,
+	0.46875f,
+	0.351563f,
+	0.46875f,
+	0.359375f,
+	0.46875f,
+	0.367188f,
+	0.46875f,
+	0.375f,
+	0.46875f,
+	0.382813f,
+	0.46875f,
+	0.390625f,
+	0.46875f,
+	0.398438f,
+	0.46875f,
+	0.40625f,
+	0.46875f,
+	0.414063f,
+	0.46875f,
+	0.421875f,
+	0.46875f,
+	0.429688f,
+	0.46875f,
+	0.4375f,
+	0.46875f,
+	0.445313f,
+	0.46875f,
+	0.453125f,
+	0.46875f,
+	0.460938f,
+	0.46875f,
+	0.46875f,
+	0.46875f,
+	0.476563f,
+	0.46875f,
+	0.484375f,
+	0.46875f,
+	0.492188f,
+	0.46875f,
+	0.5f,
+	0.46875f,
+	0.507813f,
+	0.46875f,
+	0.0f,
+	0.476563f,
+	0.0078125f,
+	0.476563f,
+	0.015625f,
+	0.476563f,
+	0.0234375f,
+	0.476563f,
+	0.03125f,
+	0.476563f,
+	0.0390625f,
+	0.476563f,
+	0.046875f,
+	0.476563f,
+	0.0546875f,
+	0.476563f,
+	0.0625f,
+	0.476563f,
+	0.0703125f,
+	0.476563f,
+	0.078125f,
+	0.476563f,
+	0.0859375f,
+	0.476563f,
+	0.09375f,
+	0.476563f,
+	0.101563f,
+	0.476563f,
+	0.109375f,
+	0.476563f,
+	0.117188f,
+	0.476563f,
+	0.125f,
+	0.476563f,
+	0.132813f,
+	0.476563f,
+	0.140625f,
+	0.476563f,
+	0.148438f,
+	0.476563f,
+	0.15625f,
+	0.476563f,
+	0.164063f,
+	0.476563f,
+	0.171875f,
+	0.476563f,
+	0.179688f,
+	0.476563f,
+	0.1875f,
+	0.476563f,
+	0.195313f,
+	0.476563f,
+	0.203125f,
+	0.476563f,
+	0.210938f,
+	0.476563f,
+	0.21875f,
+	0.476563f,
+	0.226563f,
+	0.476563f,
+	0.234375f,
+	0.476563f,
+	0.242188f,
+	0.476563f,
+	0.25f,
+	0.476563f,
+	0.257813f,
+	0.476563f,
+	0.265625f,
+	0.476563f,
+	0.273438f,
+	0.476563f,
+	0.28125f,
+	0.476563f,
+	0.289063f,
+	0.476563f,
+	0.296875f,
+	0.476563f,
+	0.304688f,
+	0.476563f,
+	0.3125f,
+	0.476563f,
+	0.320313f,
+	0.476563f,
+	0.328125f,
+	0.476563f,
+	0.335938f,
+	0.476563f,
+	0.34375f,
+	0.476563f,
+	0.351563f,
+	0.476563f,
+	0.359375f,
+	0.476563f,
+	0.367188f,
+	0.476563f,
+	0.375f,
+	0.476563f,
+	0.382813f,
+	0.476563f,
+	0.390625f,
+	0.476563f,
+	0.398438f,
+	0.476563f,
+	0.40625f,
+	0.476563f,
+	0.414063f,
+	0.476563f,
+	0.421875f,
+	0.476563f,
+	0.429688f,
+	0.476563f,
+	0.4375f,
+	0.476563f,
+	0.445313f,
+	0.476563f,
+	0.453125f,
+	0.476563f,
+	0.460938f,
+	0.476563f,
+	0.46875f,
+	0.476563f,
+	0.476563f,
+	0.476563f,
+	0.484375f,
+	0.476563f,
+	0.492188f,
+	0.476563f,
+	0.5f,
+	0.476563f,
+	0.507813f,
+	0.476563f,
+	0.0f,
+	0.484375f,
+	0.0078125f,
+	0.484375f,
+	0.015625f,
+	0.484375f,
+	0.0234375f,
+	0.484375f,
+	0.03125f,
+	0.484375f,
+	0.0390625f,
+	0.484375f,
+	0.046875f,
+	0.484375f,
+	0.0546875f,
+	0.484375f,
+	0.0625f,
+	0.484375f,
+	0.0703125f,
+	0.484375f,
+	0.078125f,
+	0.484375f,
+	0.0859375f,
+	0.484375f,
+	0.09375f,
+	0.484375f,
+	0.101563f,
+	0.484375f,
+	0.109375f,
+	0.484375f,
+	0.117188f,
+	0.484375f,
+	0.125f,
+	0.484375f,
+	0.132813f,
+	0.484375f,
+	0.140625f,
+	0.484375f,
+	0.148438f,
+	0.484375f,
+	0.15625f,
+	0.484375f,
+	0.164063f,
+	0.484375f,
+	0.171875f,
+	0.484375f,
+	0.179688f,
+	0.484375f,
+	0.1875f,
+	0.484375f,
+	0.195313f,
+	0.484375f,
+	0.203125f,
+	0.484375f,
+	0.210938f,
+	0.484375f,
+	0.21875f,
+	0.484375f,
+	0.226563f,
+	0.484375f,
+	0.234375f,
+	0.484375f,
+	0.242188f,
+	0.484375f,
+	0.25f,
+	0.484375f,
+	0.257813f,
+	0.484375f,
+	0.265625f,
+	0.484375f,
+	0.273438f,
+	0.484375f,
+	0.28125f,
+	0.484375f,
+	0.289063f,
+	0.484375f,
+	0.296875f,
+	0.484375f,
+	0.304688f,
+	0.484375f,
+	0.3125f,
+	0.484375f,
+	0.320313f,
+	0.484375f,
+	0.328125f,
+	0.484375f,
+	0.335938f,
+	0.484375f,
+	0.34375f,
+	0.484375f,
+	0.351563f,
+	0.484375f,
+	0.359375f,
+	0.484375f,
+	0.367188f,
+	0.484375f,
+	0.375f,
+	0.484375f,
+	0.382813f,
+	0.484375f,
+	0.390625f,
+	0.484375f,
+	0.398438f,
+	0.484375f,
+	0.40625f,
+	0.484375f,
+	0.414063f,
+	0.484375f,
+	0.421875f,
+	0.484375f,
+	0.429688f,
+	0.484375f,
+	0.4375f,
+	0.484375f,
+	0.445313f,
+	0.484375f,
+	0.453125f,
+	0.484375f,
+	0.460938f,
+	0.484375f,
+	0.46875f,
+	0.484375f,
+	0.476563f,
+	0.484375f,
+	0.484375f,
+	0.484375f,
+	0.492188f,
+	0.484375f,
+	0.5f,
+	0.484375f,
+	0.507813f,
+	0.484375f,
+	0.0f,
+	0.492188f,
+	0.0078125f,
+	0.492188f,
+	0.015625f,
+	0.492188f,
+	0.0234375f,
+	0.492188f,
+	0.03125f,
+	0.492188f,
+	0.0390625f,
+	0.492188f,
+	0.046875f,
+	0.492188f,
+	0.0546875f,
+	0.492188f,
+	0.0625f,
+	0.492188f,
+	0.0703125f,
+	0.492188f,
+	0.078125f,
+	0.492188f,
+	0.0859375f,
+	0.492188f,
+	0.09375f,
+	0.492188f,
+	0.101563f,
+	0.492188f,
+	0.109375f,
+	0.492188f,
+	0.117188f,
+	0.492188f,
+	0.125f,
+	0.492188f,
+	0.132813f,
+	0.492188f,
+	0.140625f,
+	0.492188f,
+	0.148438f,
+	0.492188f,
+	0.15625f,
+	0.492188f,
+	0.164063f,
+	0.492188f,
+	0.171875f,
+	0.492188f,
+	0.179688f,
+	0.492188f,
+	0.1875f,
+	0.492188f,
+	0.195313f,
+	0.492188f,
+	0.203125f,
+	0.492188f,
+	0.210938f,
+	0.492188f,
+	0.21875f,
+	0.492188f,
+	0.226563f,
+	0.492188f,
+	0.234375f,
+	0.492188f,
+	0.242188f,
+	0.492188f,
+	0.25f,
+	0.492188f,
+	0.257813f,
+	0.492188f,
+	0.265625f,
+	0.492188f,
+	0.273438f,
+	0.492188f,
+	0.28125f,
+	0.492188f,
+	0.289063f,
+	0.492188f,
+	0.296875f,
+	0.492188f,
+	0.304688f,
+	0.492188f,
+	0.3125f,
+	0.492188f,
+	0.320313f,
+	0.492188f,
+	0.328125f,
+	0.492188f,
+	0.335938f,
+	0.492188f,
+	0.34375f,
+	0.492188f,
+	0.351563f,
+	0.492188f,
+	0.359375f,
+	0.492188f,
+	0.367188f,
+	0.492188f,
+	0.375f,
+	0.492188f,
+	0.382813f,
+	0.492188f,
+	0.390625f,
+	0.492188f,
+	0.398438f,
+	0.492188f,
+	0.40625f,
+	0.492188f,
+	0.414063f,
+	0.492188f,
+	0.421875f,
+	0.492188f,
+	0.429688f,
+	0.492188f,
+	0.4375f,
+	0.492188f,
+	0.445313f,
+	0.492188f,
+	0.453125f,
+	0.492188f,
+	0.460938f,
+	0.492188f,
+	0.46875f,
+	0.492188f,
+	0.476563f,
+	0.492188f,
+	0.484375f,
+	0.492188f,
+	0.492188f,
+	0.492188f,
+	0.5f,
+	0.492188f,
+	0.507813f,
+	0.492188f,
+};
+
+unsigned short Landscape02Idx[] = {
+	0,
+	1,
+	2,
+	3,
+	2,
+	1,
+	2,
+	3,
+	4,
+	5,
+	4,
+	3,
+	4,
+	5,
+	6,
+	7,
+	6,
+	5,
+	6,
+	7,
+	8,
+	9,
+	8,
+	7,
+	8,
+	9,
+	10,
+	11,
+	10,
+	9,
+	10,
+	11,
+	12,
+	13,
+	12,
+	11,
+	12,
+	13,
+	14,
+	15,
+	14,
+	13,
+	14,
+	15,
+	16,
+	17,
+	16,
+	15,
+	16,
+	17,
+	18,
+	19,
+	18,
+	17,
+	18,
+	19,
+	20,
+	21,
+	20,
+	19,
+	20,
+	21,
+	22,
+	23,
+	22,
+	21,
+	22,
+	23,
+	24,
+	25,
+	24,
+	23,
+	24,
+	25,
+	26,
+	27,
+	26,
+	25,
+	26,
+	27,
+	28,
+	29,
+	28,
+	27,
+	28,
+	29,
+	30,
+	31,
+	30,
+	29,
+	30,
+	31,
+	32,
+	33,
+	32,
+	31,
+	32,
+	33,
+	34,
+	35,
+	34,
+	33,
+	34,
+	35,
+	36,
+	37,
+	36,
+	35,
+	36,
+	37,
+	38,
+	39,
+	38,
+	37,
+	38,
+	39,
+	40,
+	41,
+	40,
+	39,
+	40,
+	41,
+	42,
+	43,
+	42,
+	41,
+	42,
+	43,
+	44,
+	45,
+	44,
+	43,
+	44,
+	45,
+	46,
+	47,
+	46,
+	45,
+	46,
+	47,
+	48,
+	49,
+	48,
+	47,
+	48,
+	49,
+	50,
+	51,
+	50,
+	49,
+	50,
+	51,
+	52,
+	53,
+	52,
+	51,
+	52,
+	53,
+	54,
+	55,
+	54,
+	53,
+	54,
+	55,
+	56,
+	57,
+	56,
+	55,
+	56,
+	57,
+	58,
+	59,
+	58,
+	57,
+	58,
+	59,
+	60,
+	61,
+	60,
+	59,
+	60,
+	61,
+	62,
+	63,
+	62,
+	61,
+	62,
+	63,
+	64,
+	65,
+	64,
+	63,
+	64,
+	65,
+	66,
+	67,
+	66,
+	65,
+	66,
+	67,
+	68,
+	69,
+	68,
+	67,
+	68,
+	69,
+	70,
+	71,
+	70,
+	69,
+	70,
+	71,
+	72,
+	73,
+	72,
+	71,
+	72,
+	73,
+	74,
+	75,
+	74,
+	73,
+	74,
+	75,
+	76,
+	77,
+	76,
+	75,
+	76,
+	77,
+	78,
+	79,
+	78,
+	77,
+	78,
+	79,
+	80,
+	81,
+	80,
+	79,
+	80,
+	81,
+	82,
+	83,
+	82,
+	81,
+	82,
+	83,
+	84,
+	85,
+	84,
+	83,
+	84,
+	85,
+	86,
+	87,
+	86,
+	85,
+	86,
+	87,
+	88,
+	89,
+	88,
+	87,
+	88,
+	89,
+	90,
+	91,
+	90,
+	89,
+	90,
+	91,
+	92,
+	93,
+	92,
+	91,
+	92,
+	93,
+	94,
+	95,
+	94,
+	93,
+	94,
+	95,
+	96,
+	97,
+	96,
+	95,
+	96,
+	97,
+	98,
+	99,
+	98,
+	97,
+	98,
+	99,
+	100,
+	101,
+	100,
+	99,
+	100,
+	101,
+	102,
+	103,
+	102,
+	101,
+	102,
+	103,
+	104,
+	105,
+	104,
+	103,
+	104,
+	105,
+	106,
+	107,
+	106,
+	105,
+	106,
+	107,
+	108,
+	109,
+	108,
+	107,
+	108,
+	109,
+	110,
+	111,
+	110,
+	109,
+	110,
+	111,
+	112,
+	113,
+	112,
+	111,
+	112,
+	113,
+	114,
+	115,
+	114,
+	113,
+	114,
+	115,
+	116,
+	117,
+	116,
+	115,
+	116,
+	117,
+	118,
+	119,
+	118,
+	117,
+	118,
+	119,
+	120,
+	121,
+	120,
+	119,
+	120,
+	121,
+	122,
+	123,
+	122,
+	121,
+	122,
+	123,
+	124,
+	125,
+	124,
+	123,
+	124,
+	125,
+	126,
+	127,
+	126,
+	125,
+	126,
+	127,
+	128,
+	129,
+	128,
+	127,
+	128,
+	129,
+	130,
+	131,
+	130,
+	129,
+	132,
+	0,
+	133,
+	2,
+	133,
+	0,
+	133,
+	2,
+	134,
+	4,
+	134,
+	2,
+	134,
+	4,
+	135,
+	6,
+	135,
+	4,
+	135,
+	6,
+	136,
+	8,
+	136,
+	6,
+	136,
+	8,
+	137,
+	10,
+	137,
+	8,
+	137,
+	10,
+	138,
+	12,
+	138,
+	10,
+	138,
+	12,
+	139,
+	14,
+	139,
+	12,
+	139,
+	14,
+	140,
+	16,
+	140,
+	14,
+	140,
+	16,
+	141,
+	18,
+	141,
+	16,
+	141,
+	18,
+	142,
+	20,
+	142,
+	18,
+	142,
+	20,
+	143,
+	22,
+	143,
+	20,
+	143,
+	22,
+	144,
+	24,
+	144,
+	22,
+	144,
+	24,
+	145,
+	26,
+	145,
+	24,
+	145,
+	26,
+	146,
+	28,
+	146,
+	26,
+	146,
+	28,
+	147,
+	30,
+	147,
+	28,
+	147,
+	30,
+	148,
+	32,
+	148,
+	30,
+	148,
+	32,
+	149,
+	34,
+	149,
+	32,
+	149,
+	34,
+	150,
+	36,
+	150,
+	34,
+	150,
+	36,
+	151,
+	38,
+	151,
+	36,
+	151,
+	38,
+	152,
+	40,
+	152,
+	38,
+	152,
+	40,
+	153,
+	42,
+	153,
+	40,
+	153,
+	42,
+	154,
+	44,
+	154,
+	42,
+	154,
+	44,
+	155,
+	46,
+	155,
+	44,
+	155,
+	46,
+	156,
+	48,
+	156,
+	46,
+	156,
+	48,
+	157,
+	50,
+	157,
+	48,
+	157,
+	50,
+	158,
+	52,
+	158,
+	50,
+	158,
+	52,
+	159,
+	54,
+	159,
+	52,
+	159,
+	54,
+	160,
+	56,
+	160,
+	54,
+	160,
+	56,
+	161,
+	58,
+	161,
+	56,
+	161,
+	58,
+	162,
+	60,
+	162,
+	58,
+	162,
+	60,
+	163,
+	62,
+	163,
+	60,
+	163,
+	62,
+	164,
+	64,
+	164,
+	62,
+	164,
+	64,
+	165,
+	66,
+	165,
+	64,
+	165,
+	66,
+	166,
+	68,
+	166,
+	66,
+	166,
+	68,
+	167,
+	70,
+	167,
+	68,
+	167,
+	70,
+	168,
+	72,
+	168,
+	70,
+	168,
+	72,
+	169,
+	74,
+	169,
+	72,
+	169,
+	74,
+	170,
+	76,
+	170,
+	74,
+	170,
+	76,
+	171,
+	78,
+	171,
+	76,
+	171,
+	78,
+	172,
+	80,
+	172,
+	78,
+	172,
+	80,
+	173,
+	82,
+	173,
+	80,
+	173,
+	82,
+	174,
+	84,
+	174,
+	82,
+	174,
+	84,
+	175,
+	86,
+	175,
+	84,
+	175,
+	86,
+	176,
+	88,
+	176,
+	86,
+	176,
+	88,
+	177,
+	90,
+	177,
+	88,
+	177,
+	90,
+	178,
+	92,
+	178,
+	90,
+	178,
+	92,
+	179,
+	94,
+	179,
+	92,
+	179,
+	94,
+	180,
+	96,
+	180,
+	94,
+	180,
+	96,
+	181,
+	98,
+	181,
+	96,
+	181,
+	98,
+	182,
+	100,
+	182,
+	98,
+	182,
+	100,
+	183,
+	102,
+	183,
+	100,
+	183,
+	102,
+	184,
+	104,
+	184,
+	102,
+	184,
+	104,
+	185,
+	106,
+	185,
+	104,
+	185,
+	106,
+	186,
+	108,
+	186,
+	106,
+	186,
+	108,
+	187,
+	110,
+	187,
+	108,
+	187,
+	110,
+	188,
+	112,
+	188,
+	110,
+	188,
+	112,
+	189,
+	114,
+	189,
+	112,
+	189,
+	114,
+	190,
+	116,
+	190,
+	114,
+	190,
+	116,
+	191,
+	118,
+	191,
+	116,
+	191,
+	118,
+	192,
+	120,
+	192,
+	118,
+	192,
+	120,
+	193,
+	122,
+	193,
+	120,
+	193,
+	122,
+	194,
+	124,
+	194,
+	122,
+	194,
+	124,
+	195,
+	126,
+	195,
+	124,
+	195,
+	126,
+	196,
+	128,
+	196,
+	126,
+	196,
+	128,
+	197,
+	130,
+	197,
+	128,
+	198,
+	132,
+	199,
+	133,
+	199,
+	132,
+	199,
+	133,
+	200,
+	134,
+	200,
+	133,
+	200,
+	134,
+	201,
+	135,
+	201,
+	134,
+	201,
+	135,
+	202,
+	136,
+	202,
+	135,
+	202,
+	136,
+	203,
+	137,
+	203,
+	136,
+	203,
+	137,
+	204,
+	138,
+	204,
+	137,
+	204,
+	138,
+	205,
+	139,
+	205,
+	138,
+	205,
+	139,
+	206,
+	140,
+	206,
+	139,
+	206,
+	140,
+	207,
+	141,
+	207,
+	140,
+	207,
+	141,
+	208,
+	142,
+	208,
+	141,
+	208,
+	142,
+	209,
+	143,
+	209,
+	142,
+	209,
+	143,
+	210,
+	144,
+	210,
+	143,
+	210,
+	144,
+	211,
+	145,
+	211,
+	144,
+	211,
+	145,
+	212,
+	146,
+	212,
+	145,
+	212,
+	146,
+	213,
+	147,
+	213,
+	146,
+	213,
+	147,
+	214,
+	148,
+	214,
+	147,
+	214,
+	148,
+	215,
+	149,
+	215,
+	148,
+	215,
+	149,
+	216,
+	150,
+	216,
+	149,
+	216,
+	150,
+	217,
+	151,
+	217,
+	150,
+	217,
+	151,
+	218,
+	152,
+	218,
+	151,
+	218,
+	152,
+	219,
+	153,
+	219,
+	152,
+	219,
+	153,
+	220,
+	154,
+	220,
+	153,
+	220,
+	154,
+	221,
+	155,
+	221,
+	154,
+	221,
+	155,
+	222,
+	156,
+	222,
+	155,
+	222,
+	156,
+	223,
+	157,
+	223,
+	156,
+	223,
+	157,
+	224,
+	158,
+	224,
+	157,
+	224,
+	158,
+	225,
+	159,
+	225,
+	158,
+	225,
+	159,
+	226,
+	160,
+	226,
+	159,
+	226,
+	160,
+	227,
+	161,
+	227,
+	160,
+	227,
+	161,
+	228,
+	162,
+	228,
+	161,
+	228,
+	162,
+	229,
+	163,
+	229,
+	162,
+	229,
+	163,
+	230,
+	164,
+	230,
+	163,
+	230,
+	164,
+	231,
+	165,
+	231,
+	164,
+	231,
+	165,
+	232,
+	166,
+	232,
+	165,
+	232,
+	166,
+	233,
+	167,
+	233,
+	166,
+	233,
+	167,
+	234,
+	168,
+	234,
+	167,
+	234,
+	168,
+	235,
+	169,
+	235,
+	168,
+	235,
+	169,
+	236,
+	170,
+	236,
+	169,
+	236,
+	170,
+	237,
+	171,
+	237,
+	170,
+	237,
+	171,
+	238,
+	172,
+	238,
+	171,
+	238,
+	172,
+	239,
+	173,
+	239,
+	172,
+	239,
+	173,
+	240,
+	174,
+	240,
+	173,
+	240,
+	174,
+	241,
+	175,
+	241,
+	174,
+	241,
+	175,
+	242,
+	176,
+	242,
+	175,
+	242,
+	176,
+	243,
+	177,
+	243,
+	176,
+	243,
+	177,
+	244,
+	178,
+	244,
+	177,
+	244,
+	178,
+	245,
+	179,
+	245,
+	178,
+	245,
+	179,
+	246,
+	180,
+	246,
+	179,
+	246,
+	180,
+	247,
+	181,
+	247,
+	180,
+	247,
+	181,
+	248,
+	182,
+	248,
+	181,
+	248,
+	182,
+	249,
+	183,
+	249,
+	182,
+	249,
+	183,
+	250,
+	184,
+	250,
+	183,
+	250,
+	184,
+	251,
+	185,
+	251,
+	184,
+	251,
+	185,
+	252,
+	186,
+	252,
+	185,
+	252,
+	186,
+	253,
+	187,
+	253,
+	186,
+	253,
+	187,
+	254,
+	188,
+	254,
+	187,
+	254,
+	188,
+	255,
+	189,
+	255,
+	188,
+	255,
+	189,
+	256,
+	190,
+	256,
+	189,
+	256,
+	190,
+	257,
+	191,
+	257,
+	190,
+	257,
+	191,
+	258,
+	192,
+	258,
+	191,
+	258,
+	192,
+	259,
+	193,
+	259,
+	192,
+	259,
+	193,
+	260,
+	194,
+	260,
+	193,
+	260,
+	194,
+	261,
+	195,
+	261,
+	194,
+	261,
+	195,
+	262,
+	196,
+	262,
+	195,
+	262,
+	196,
+	263,
+	197,
+	263,
+	196,
+	264,
+	198,
+	265,
+	199,
+	265,
+	198,
+	265,
+	199,
+	266,
+	200,
+	266,
+	199,
+	266,
+	200,
+	267,
+	201,
+	267,
+	200,
+	267,
+	201,
+	268,
+	202,
+	268,
+	201,
+	268,
+	202,
+	269,
+	203,
+	269,
+	202,
+	269,
+	203,
+	270,
+	204,
+	270,
+	203,
+	270,
+	204,
+	271,
+	205,
+	271,
+	204,
+	271,
+	205,
+	272,
+	206,
+	272,
+	205,
+	272,
+	206,
+	273,
+	207,
+	273,
+	206,
+	273,
+	207,
+	274,
+	208,
+	274,
+	207,
+	274,
+	208,
+	275,
+	209,
+	275,
+	208,
+	275,
+	209,
+	276,
+	210,
+	276,
+	209,
+	276,
+	210,
+	277,
+	211,
+	277,
+	210,
+	277,
+	211,
+	278,
+	212,
+	278,
+	211,
+	278,
+	212,
+	279,
+	213,
+	279,
+	212,
+	279,
+	213,
+	280,
+	214,
+	280,
+	213,
+	280,
+	214,
+	281,
+	215,
+	281,
+	214,
+	281,
+	215,
+	282,
+	216,
+	282,
+	215,
+	282,
+	216,
+	283,
+	217,
+	283,
+	216,
+	283,
+	217,
+	284,
+	218,
+	284,
+	217,
+	284,
+	218,
+	285,
+	219,
+	285,
+	218,
+	285,
+	219,
+	286,
+	220,
+	286,
+	219,
+	286,
+	220,
+	287,
+	221,
+	287,
+	220,
+	287,
+	221,
+	288,
+	222,
+	288,
+	221,
+	288,
+	222,
+	289,
+	223,
+	289,
+	222,
+	289,
+	223,
+	290,
+	224,
+	290,
+	223,
+	290,
+	224,
+	291,
+	225,
+	291,
+	224,
+	291,
+	225,
+	292,
+	226,
+	292,
+	225,
+	292,
+	226,
+	293,
+	227,
+	293,
+	226,
+	293,
+	227,
+	294,
+	228,
+	294,
+	227,
+	294,
+	228,
+	295,
+	229,
+	295,
+	228,
+	295,
+	229,
+	296,
+	230,
+	296,
+	229,
+	296,
+	230,
+	297,
+	231,
+	297,
+	230,
+	297,
+	231,
+	298,
+	232,
+	298,
+	231,
+	298,
+	232,
+	299,
+	233,
+	299,
+	232,
+	299,
+	233,
+	300,
+	234,
+	300,
+	233,
+	300,
+	234,
+	301,
+	235,
+	301,
+	234,
+	301,
+	235,
+	302,
+	236,
+	302,
+	235,
+	302,
+	236,
+	303,
+	237,
+	303,
+	236,
+	303,
+	237,
+	304,
+	238,
+	304,
+	237,
+	304,
+	238,
+	305,
+	239,
+	305,
+	238,
+	305,
+	239,
+	306,
+	240,
+	306,
+	239,
+	306,
+	240,
+	307,
+	241,
+	307,
+	240,
+	307,
+	241,
+	308,
+	242,
+	308,
+	241,
+	308,
+	242,
+	309,
+	243,
+	309,
+	242,
+	309,
+	243,
+	310,
+	244,
+	310,
+	243,
+	310,
+	244,
+	311,
+	245,
+	311,
+	244,
+	311,
+	245,
+	312,
+	246,
+	312,
+	245,
+	312,
+	246,
+	313,
+	247,
+	313,
+	246,
+	313,
+	247,
+	314,
+	248,
+	314,
+	247,
+	314,
+	248,
+	315,
+	249,
+	315,
+	248,
+	315,
+	249,
+	316,
+	250,
+	316,
+	249,
+	316,
+	250,
+	317,
+	251,
+	317,
+	250,
+	317,
+	251,
+	318,
+	252,
+	318,
+	251,
+	318,
+	252,
+	319,
+	253,
+	319,
+	252,
+	319,
+	253,
+	320,
+	254,
+	320,
+	253,
+	320,
+	254,
+	321,
+	255,
+	321,
+	254,
+	321,
+	255,
+	322,
+	256,
+	322,
+	255,
+	322,
+	256,
+	323,
+	257,
+	323,
+	256,
+	323,
+	257,
+	324,
+	258,
+	324,
+	257,
+	324,
+	258,
+	325,
+	259,
+	325,
+	258,
+	325,
+	259,
+	326,
+	260,
+	326,
+	259,
+	326,
+	260,
+	327,
+	261,
+	327,
+	260,
+	327,
+	261,
+	328,
+	262,
+	328,
+	261,
+	328,
+	262,
+	329,
+	263,
+	329,
+	262,
+	330,
+	264,
+	331,
+	265,
+	331,
+	264,
+	331,
+	265,
+	332,
+	266,
+	332,
+	265,
+	332,
+	266,
+	333,
+	267,
+	333,
+	266,
+	333,
+	267,
+	334,
+	268,
+	334,
+	267,
+	334,
+	268,
+	335,
+	269,
+	335,
+	268,
+	335,
+	269,
+	336,
+	270,
+	336,
+	269,
+	336,
+	270,
+	337,
+	271,
+	337,
+	270,
+	337,
+	271,
+	338,
+	272,
+	338,
+	271,
+	338,
+	272,
+	339,
+	273,
+	339,
+	272,
+	339,
+	273,
+	340,
+	274,
+	340,
+	273,
+	340,
+	274,
+	341,
+	275,
+	341,
+	274,
+	341,
+	275,
+	342,
+	276,
+	342,
+	275,
+	342,
+	276,
+	343,
+	277,
+	343,
+	276,
+	343,
+	277,
+	344,
+	278,
+	344,
+	277,
+	344,
+	278,
+	345,
+	279,
+	345,
+	278,
+	345,
+	279,
+	346,
+	280,
+	346,
+	279,
+	346,
+	280,
+	347,
+	281,
+	347,
+	280,
+	347,
+	281,
+	348,
+	282,
+	348,
+	281,
+	348,
+	282,
+	349,
+	283,
+	349,
+	282,
+	349,
+	283,
+	350,
+	284,
+	350,
+	283,
+	350,
+	284,
+	351,
+	285,
+	351,
+	284,
+	351,
+	285,
+	352,
+	286,
+	352,
+	285,
+	352,
+	286,
+	353,
+	287,
+	353,
+	286,
+	353,
+	287,
+	354,
+	288,
+	354,
+	287,
+	354,
+	288,
+	355,
+	289,
+	355,
+	288,
+	355,
+	289,
+	356,
+	290,
+	356,
+	289,
+	356,
+	290,
+	357,
+	291,
+	357,
+	290,
+	357,
+	291,
+	358,
+	292,
+	358,
+	291,
+	358,
+	292,
+	359,
+	293,
+	359,
+	292,
+	359,
+	293,
+	360,
+	294,
+	360,
+	293,
+	360,
+	294,
+	361,
+	295,
+	361,
+	294,
+	361,
+	295,
+	362,
+	296,
+	362,
+	295,
+	362,
+	296,
+	363,
+	297,
+	363,
+	296,
+	363,
+	297,
+	364,
+	298,
+	364,
+	297,
+	364,
+	298,
+	365,
+	299,
+	365,
+	298,
+	365,
+	299,
+	366,
+	300,
+	366,
+	299,
+	366,
+	300,
+	367,
+	301,
+	367,
+	300,
+	367,
+	301,
+	368,
+	302,
+	368,
+	301,
+	368,
+	302,
+	369,
+	303,
+	369,
+	302,
+	369,
+	303,
+	370,
+	304,
+	370,
+	303,
+	370,
+	304,
+	371,
+	305,
+	371,
+	304,
+	371,
+	305,
+	372,
+	306,
+	372,
+	305,
+	372,
+	306,
+	373,
+	307,
+	373,
+	306,
+	373,
+	307,
+	374,
+	308,
+	374,
+	307,
+	374,
+	308,
+	375,
+	309,
+	375,
+	308,
+	375,
+	309,
+	376,
+	310,
+	376,
+	309,
+	376,
+	310,
+	377,
+	311,
+	377,
+	310,
+	377,
+	311,
+	378,
+	312,
+	378,
+	311,
+	378,
+	312,
+	379,
+	313,
+	379,
+	312,
+	379,
+	313,
+	380,
+	314,
+	380,
+	313,
+	380,
+	314,
+	381,
+	315,
+	381,
+	314,
+	381,
+	315,
+	382,
+	316,
+	382,
+	315,
+	382,
+	316,
+	383,
+	317,
+	383,
+	316,
+	383,
+	317,
+	384,
+	318,
+	384,
+	317,
+	384,
+	318,
+	385,
+	319,
+	385,
+	318,
+	385,
+	319,
+	386,
+	320,
+	386,
+	319,
+	386,
+	320,
+	387,
+	321,
+	387,
+	320,
+	387,
+	321,
+	388,
+	322,
+	388,
+	321,
+	388,
+	322,
+	389,
+	323,
+	389,
+	322,
+	389,
+	323,
+	390,
+	324,
+	390,
+	323,
+	390,
+	324,
+	391,
+	325,
+	391,
+	324,
+	391,
+	325,
+	392,
+	326,
+	392,
+	325,
+	392,
+	326,
+	393,
+	327,
+	393,
+	326,
+	393,
+	327,
+	394,
+	328,
+	394,
+	327,
+	394,
+	328,
+	395,
+	329,
+	395,
+	328,
+	396,
+	330,
+	397,
+	331,
+	397,
+	330,
+	397,
+	331,
+	398,
+	332,
+	398,
+	331,
+	398,
+	332,
+	399,
+	333,
+	399,
+	332,
+	399,
+	333,
+	400,
+	334,
+	400,
+	333,
+	400,
+	334,
+	401,
+	335,
+	401,
+	334,
+	401,
+	335,
+	402,
+	336,
+	402,
+	335,
+	402,
+	336,
+	403,
+	337,
+	403,
+	336,
+	403,
+	337,
+	404,
+	338,
+	404,
+	337,
+	404,
+	338,
+	405,
+	339,
+	405,
+	338,
+	405,
+	339,
+	406,
+	340,
+	406,
+	339,
+	406,
+	340,
+	407,
+	341,
+	407,
+	340,
+	407,
+	341,
+	408,
+	342,
+	408,
+	341,
+	408,
+	342,
+	409,
+	343,
+	409,
+	342,
+	409,
+	343,
+	410,
+	344,
+	410,
+	343,
+	410,
+	344,
+	411,
+	345,
+	411,
+	344,
+	411,
+	345,
+	412,
+	346,
+	412,
+	345,
+	412,
+	346,
+	413,
+	347,
+	413,
+	346,
+	413,
+	347,
+	414,
+	348,
+	414,
+	347,
+	414,
+	348,
+	415,
+	349,
+	415,
+	348,
+	415,
+	349,
+	416,
+	350,
+	416,
+	349,
+	416,
+	350,
+	417,
+	351,
+	417,
+	350,
+	417,
+	351,
+	418,
+	352,
+	418,
+	351,
+	418,
+	352,
+	419,
+	353,
+	419,
+	352,
+	419,
+	353,
+	420,
+	354,
+	420,
+	353,
+	420,
+	354,
+	421,
+	355,
+	421,
+	354,
+	421,
+	355,
+	422,
+	356,
+	422,
+	355,
+	422,
+	356,
+	423,
+	357,
+	423,
+	356,
+	423,
+	357,
+	424,
+	358,
+	424,
+	357,
+	424,
+	358,
+	425,
+	359,
+	425,
+	358,
+	425,
+	359,
+	426,
+	360,
+	426,
+	359,
+	426,
+	360,
+	427,
+	361,
+	427,
+	360,
+	427,
+	361,
+	428,
+	362,
+	428,
+	361,
+	428,
+	362,
+	429,
+	363,
+	429,
+	362,
+	429,
+	363,
+	430,
+	364,
+	430,
+	363,
+	430,
+	364,
+	431,
+	365,
+	431,
+	364,
+	431,
+	365,
+	432,
+	366,
+	432,
+	365,
+	432,
+	366,
+	433,
+	367,
+	433,
+	366,
+	433,
+	367,
+	434,
+	368,
+	434,
+	367,
+	434,
+	368,
+	435,
+	369,
+	435,
+	368,
+	435,
+	369,
+	436,
+	370,
+	436,
+	369,
+	436,
+	370,
+	437,
+	371,
+	437,
+	370,
+	437,
+	371,
+	438,
+	372,
+	438,
+	371,
+	438,
+	372,
+	439,
+	373,
+	439,
+	372,
+	439,
+	373,
+	440,
+	374,
+	440,
+	373,
+	440,
+	374,
+	441,
+	375,
+	441,
+	374,
+	441,
+	375,
+	442,
+	376,
+	442,
+	375,
+	442,
+	376,
+	443,
+	377,
+	443,
+	376,
+	443,
+	377,
+	444,
+	378,
+	444,
+	377,
+	444,
+	378,
+	445,
+	379,
+	445,
+	378,
+	445,
+	379,
+	446,
+	380,
+	446,
+	379,
+	446,
+	380,
+	447,
+	381,
+	447,
+	380,
+	447,
+	381,
+	448,
+	382,
+	448,
+	381,
+	448,
+	382,
+	449,
+	383,
+	449,
+	382,
+	449,
+	383,
+	450,
+	384,
+	450,
+	383,
+	450,
+	384,
+	451,
+	385,
+	451,
+	384,
+	451,
+	385,
+	452,
+	386,
+	452,
+	385,
+	452,
+	386,
+	453,
+	387,
+	453,
+	386,
+	453,
+	387,
+	454,
+	388,
+	454,
+	387,
+	454,
+	388,
+	455,
+	389,
+	455,
+	388,
+	455,
+	389,
+	456,
+	390,
+	456,
+	389,
+	456,
+	390,
+	457,
+	391,
+	457,
+	390,
+	457,
+	391,
+	458,
+	392,
+	458,
+	391,
+	458,
+	392,
+	459,
+	393,
+	459,
+	392,
+	459,
+	393,
+	460,
+	394,
+	460,
+	393,
+	460,
+	394,
+	461,
+	395,
+	461,
+	394,
+	462,
+	396,
+	463,
+	397,
+	463,
+	396,
+	463,
+	397,
+	464,
+	398,
+	464,
+	397,
+	464,
+	398,
+	465,
+	399,
+	465,
+	398,
+	465,
+	399,
+	466,
+	400,
+	466,
+	399,
+	466,
+	400,
+	467,
+	401,
+	467,
+	400,
+	467,
+	401,
+	468,
+	402,
+	468,
+	401,
+	468,
+	402,
+	469,
+	403,
+	469,
+	402,
+	469,
+	403,
+	470,
+	404,
+	470,
+	403,
+	470,
+	404,
+	471,
+	405,
+	471,
+	404,
+	471,
+	405,
+	472,
+	406,
+	472,
+	405,
+	472,
+	406,
+	473,
+	407,
+	473,
+	406,
+	473,
+	407,
+	474,
+	408,
+	474,
+	407,
+	474,
+	408,
+	475,
+	409,
+	475,
+	408,
+	475,
+	409,
+	476,
+	410,
+	476,
+	409,
+	476,
+	410,
+	477,
+	411,
+	477,
+	410,
+	477,
+	411,
+	478,
+	412,
+	478,
+	411,
+	478,
+	412,
+	479,
+	413,
+	479,
+	412,
+	479,
+	413,
+	480,
+	414,
+	480,
+	413,
+	480,
+	414,
+	481,
+	415,
+	481,
+	414,
+	481,
+	415,
+	482,
+	416,
+	482,
+	415,
+	482,
+	416,
+	483,
+	417,
+	483,
+	416,
+	483,
+	417,
+	484,
+	418,
+	484,
+	417,
+	484,
+	418,
+	485,
+	419,
+	485,
+	418,
+	485,
+	419,
+	486,
+	420,
+	486,
+	419,
+	486,
+	420,
+	487,
+	421,
+	487,
+	420,
+	487,
+	421,
+	488,
+	422,
+	488,
+	421,
+	488,
+	422,
+	489,
+	423,
+	489,
+	422,
+	489,
+	423,
+	490,
+	424,
+	490,
+	423,
+	490,
+	424,
+	491,
+	425,
+	491,
+	424,
+	491,
+	425,
+	492,
+	426,
+	492,
+	425,
+	492,
+	426,
+	493,
+	427,
+	493,
+	426,
+	493,
+	427,
+	494,
+	428,
+	494,
+	427,
+	494,
+	428,
+	495,
+	429,
+	495,
+	428,
+	495,
+	429,
+	496,
+	430,
+	496,
+	429,
+	496,
+	430,
+	497,
+	431,
+	497,
+	430,
+	497,
+	431,
+	498,
+	432,
+	498,
+	431,
+	498,
+	432,
+	499,
+	433,
+	499,
+	432,
+	499,
+	433,
+	500,
+	434,
+	500,
+	433,
+	500,
+	434,
+	501,
+	435,
+	501,
+	434,
+	501,
+	435,
+	502,
+	436,
+	502,
+	435,
+	502,
+	436,
+	503,
+	437,
+	503,
+	436,
+	503,
+	437,
+	504,
+	438,
+	504,
+	437,
+	504,
+	438,
+	505,
+	439,
+	505,
+	438,
+	505,
+	439,
+	506,
+	440,
+	506,
+	439,
+	506,
+	440,
+	507,
+	441,
+	507,
+	440,
+	507,
+	441,
+	508,
+	442,
+	508,
+	441,
+	508,
+	442,
+	509,
+	443,
+	509,
+	442,
+	509,
+	443,
+	510,
+	444,
+	510,
+	443,
+	510,
+	444,
+	511,
+	445,
+	511,
+	444,
+	511,
+	445,
+	512,
+	446,
+	512,
+	445,
+	512,
+	446,
+	513,
+	447,
+	513,
+	446,
+	513,
+	447,
+	514,
+	448,
+	514,
+	447,
+	514,
+	448,
+	515,
+	449,
+	515,
+	448,
+	515,
+	449,
+	516,
+	450,
+	516,
+	449,
+	516,
+	450,
+	517,
+	451,
+	517,
+	450,
+	517,
+	451,
+	518,
+	452,
+	518,
+	451,
+	518,
+	452,
+	519,
+	453,
+	519,
+	452,
+	519,
+	453,
+	520,
+	454,
+	520,
+	453,
+	520,
+	454,
+	521,
+	455,
+	521,
+	454,
+	521,
+	455,
+	522,
+	456,
+	522,
+	455,
+	522,
+	456,
+	523,
+	457,
+	523,
+	456,
+	523,
+	457,
+	524,
+	458,
+	524,
+	457,
+	524,
+	458,
+	525,
+	459,
+	525,
+	458,
+	525,
+	459,
+	526,
+	460,
+	526,
+	459,
+	526,
+	460,
+	527,
+	461,
+	527,
+	460,
+	528,
+	462,
+	529,
+	463,
+	529,
+	462,
+	529,
+	463,
+	530,
+	464,
+	530,
+	463,
+	530,
+	464,
+	531,
+	465,
+	531,
+	464,
+	531,
+	465,
+	532,
+	466,
+	532,
+	465,
+	532,
+	466,
+	533,
+	467,
+	533,
+	466,
+	533,
+	467,
+	534,
+	468,
+	534,
+	467,
+	534,
+	468,
+	535,
+	469,
+	535,
+	468,
+	535,
+	469,
+	536,
+	470,
+	536,
+	469,
+	536,
+	470,
+	537,
+	471,
+	537,
+	470,
+	537,
+	471,
+	538,
+	472,
+	538,
+	471,
+	538,
+	472,
+	539,
+	473,
+	539,
+	472,
+	539,
+	473,
+	540,
+	474,
+	540,
+	473,
+	540,
+	474,
+	541,
+	475,
+	541,
+	474,
+	541,
+	475,
+	542,
+	476,
+	542,
+	475,
+	542,
+	476,
+	543,
+	477,
+	543,
+	476,
+	543,
+	477,
+	544,
+	478,
+	544,
+	477,
+	544,
+	478,
+	545,
+	479,
+	545,
+	478,
+	545,
+	479,
+	546,
+	480,
+	546,
+	479,
+	546,
+	480,
+	547,
+	481,
+	547,
+	480,
+	547,
+	481,
+	548,
+	482,
+	548,
+	481,
+	548,
+	482,
+	549,
+	483,
+	549,
+	482,
+	549,
+	483,
+	550,
+	484,
+	550,
+	483,
+	550,
+	484,
+	551,
+	485,
+	551,
+	484,
+	551,
+	485,
+	552,
+	486,
+	552,
+	485,
+	552,
+	486,
+	553,
+	487,
+	553,
+	486,
+	553,
+	487,
+	554,
+	488,
+	554,
+	487,
+	554,
+	488,
+	555,
+	489,
+	555,
+	488,
+	555,
+	489,
+	556,
+	490,
+	556,
+	489,
+	556,
+	490,
+	557,
+	491,
+	557,
+	490,
+	557,
+	491,
+	558,
+	492,
+	558,
+	491,
+	558,
+	492,
+	559,
+	493,
+	559,
+	492,
+	559,
+	493,
+	560,
+	494,
+	560,
+	493,
+	560,
+	494,
+	561,
+	495,
+	561,
+	494,
+	561,
+	495,
+	562,
+	496,
+	562,
+	495,
+	562,
+	496,
+	563,
+	497,
+	563,
+	496,
+	563,
+	497,
+	564,
+	498,
+	564,
+	497,
+	564,
+	498,
+	565,
+	499,
+	565,
+	498,
+	565,
+	499,
+	566,
+	500,
+	566,
+	499,
+	566,
+	500,
+	567,
+	501,
+	567,
+	500,
+	567,
+	501,
+	568,
+	502,
+	568,
+	501,
+	568,
+	502,
+	569,
+	503,
+	569,
+	502,
+	569,
+	503,
+	570,
+	504,
+	570,
+	503,
+	570,
+	504,
+	571,
+	505,
+	571,
+	504,
+	571,
+	505,
+	572,
+	506,
+	572,
+	505,
+	572,
+	506,
+	573,
+	507,
+	573,
+	506,
+	573,
+	507,
+	574,
+	508,
+	574,
+	507,
+	574,
+	508,
+	575,
+	509,
+	575,
+	508,
+	575,
+	509,
+	576,
+	510,
+	576,
+	509,
+	576,
+	510,
+	577,
+	511,
+	577,
+	510,
+	577,
+	511,
+	578,
+	512,
+	578,
+	511,
+	578,
+	512,
+	579,
+	513,
+	579,
+	512,
+	579,
+	513,
+	580,
+	514,
+	580,
+	513,
+	580,
+	514,
+	581,
+	515,
+	581,
+	514,
+	581,
+	515,
+	582,
+	516,
+	582,
+	515,
+	582,
+	516,
+	583,
+	517,
+	583,
+	516,
+	583,
+	517,
+	584,
+	518,
+	584,
+	517,
+	584,
+	518,
+	585,
+	519,
+	585,
+	518,
+	585,
+	519,
+	586,
+	520,
+	586,
+	519,
+	586,
+	520,
+	587,
+	521,
+	587,
+	520,
+	587,
+	521,
+	588,
+	522,
+	588,
+	521,
+	588,
+	522,
+	589,
+	523,
+	589,
+	522,
+	589,
+	523,
+	590,
+	524,
+	590,
+	523,
+	590,
+	524,
+	591,
+	525,
+	591,
+	524,
+	591,
+	525,
+	592,
+	526,
+	592,
+	525,
+	592,
+	526,
+	593,
+	527,
+	593,
+	526,
+	594,
+	528,
+	595,
+	529,
+	595,
+	528,
+	595,
+	529,
+	596,
+	530,
+	596,
+	529,
+	596,
+	530,
+	597,
+	531,
+	597,
+	530,
+	597,
+	531,
+	598,
+	532,
+	598,
+	531,
+	598,
+	532,
+	599,
+	533,
+	599,
+	532,
+	599,
+	533,
+	600,
+	534,
+	600,
+	533,
+	600,
+	534,
+	601,
+	535,
+	601,
+	534,
+	601,
+	535,
+	602,
+	536,
+	602,
+	535,
+	602,
+	536,
+	603,
+	537,
+	603,
+	536,
+	603,
+	537,
+	604,
+	538,
+	604,
+	537,
+	604,
+	538,
+	605,
+	539,
+	605,
+	538,
+	605,
+	539,
+	606,
+	540,
+	606,
+	539,
+	606,
+	540,
+	607,
+	541,
+	607,
+	540,
+	607,
+	541,
+	608,
+	542,
+	608,
+	541,
+	608,
+	542,
+	609,
+	543,
+	609,
+	542,
+	609,
+	543,
+	610,
+	544,
+	610,
+	543,
+	610,
+	544,
+	611,
+	545,
+	611,
+	544,
+	611,
+	545,
+	612,
+	546,
+	612,
+	545,
+	612,
+	546,
+	613,
+	547,
+	613,
+	546,
+	613,
+	547,
+	614,
+	548,
+	614,
+	547,
+	614,
+	548,
+	615,
+	549,
+	615,
+	548,
+	615,
+	549,
+	616,
+	550,
+	616,
+	549,
+	616,
+	550,
+	617,
+	551,
+	617,
+	550,
+	617,
+	551,
+	618,
+	552,
+	618,
+	551,
+	618,
+	552,
+	619,
+	553,
+	619,
+	552,
+	619,
+	553,
+	620,
+	554,
+	620,
+	553,
+	620,
+	554,
+	621,
+	555,
+	621,
+	554,
+	621,
+	555,
+	622,
+	556,
+	622,
+	555,
+	622,
+	556,
+	623,
+	557,
+	623,
+	556,
+	623,
+	557,
+	624,
+	558,
+	624,
+	557,
+	624,
+	558,
+	625,
+	559,
+	625,
+	558,
+	625,
+	559,
+	626,
+	560,
+	626,
+	559,
+	626,
+	560,
+	627,
+	561,
+	627,
+	560,
+	627,
+	561,
+	628,
+	562,
+	628,
+	561,
+	628,
+	562,
+	629,
+	563,
+	629,
+	562,
+	629,
+	563,
+	630,
+	564,
+	630,
+	563,
+	630,
+	564,
+	631,
+	565,
+	631,
+	564,
+	631,
+	565,
+	632,
+	566,
+	632,
+	565,
+	632,
+	566,
+	633,
+	567,
+	633,
+	566,
+	633,
+	567,
+	634,
+	568,
+	634,
+	567,
+	634,
+	568,
+	635,
+	569,
+	635,
+	568,
+	635,
+	569,
+	636,
+	570,
+	636,
+	569,
+	636,
+	570,
+	637,
+	571,
+	637,
+	570,
+	637,
+	571,
+	638,
+	572,
+	638,
+	571,
+	638,
+	572,
+	639,
+	573,
+	639,
+	572,
+	639,
+	573,
+	640,
+	574,
+	640,
+	573,
+	640,
+	574,
+	641,
+	575,
+	641,
+	574,
+	641,
+	575,
+	642,
+	576,
+	642,
+	575,
+	642,
+	576,
+	643,
+	577,
+	643,
+	576,
+	643,
+	577,
+	644,
+	578,
+	644,
+	577,
+	644,
+	578,
+	645,
+	579,
+	645,
+	578,
+	645,
+	579,
+	646,
+	580,
+	646,
+	579,
+	646,
+	580,
+	647,
+	581,
+	647,
+	580,
+	647,
+	581,
+	648,
+	582,
+	648,
+	581,
+	648,
+	582,
+	649,
+	583,
+	649,
+	582,
+	649,
+	583,
+	650,
+	584,
+	650,
+	583,
+	650,
+	584,
+	651,
+	585,
+	651,
+	584,
+	651,
+	585,
+	652,
+	586,
+	652,
+	585,
+	652,
+	586,
+	653,
+	587,
+	653,
+	586,
+	653,
+	587,
+	654,
+	588,
+	654,
+	587,
+	654,
+	588,
+	655,
+	589,
+	655,
+	588,
+	655,
+	589,
+	656,
+	590,
+	656,
+	589,
+	656,
+	590,
+	657,
+	591,
+	657,
+	590,
+	657,
+	591,
+	658,
+	592,
+	658,
+	591,
+	658,
+	592,
+	659,
+	593,
+	659,
+	592,
+	660,
+	594,
+	661,
+	595,
+	661,
+	594,
+	661,
+	595,
+	662,
+	596,
+	662,
+	595,
+	662,
+	596,
+	663,
+	597,
+	663,
+	596,
+	663,
+	597,
+	664,
+	598,
+	664,
+	597,
+	664,
+	598,
+	665,
+	599,
+	665,
+	598,
+	665,
+	599,
+	666,
+	600,
+	666,
+	599,
+	666,
+	600,
+	667,
+	601,
+	667,
+	600,
+	667,
+	601,
+	668,
+	602,
+	668,
+	601,
+	668,
+	602,
+	669,
+	603,
+	669,
+	602,
+	669,
+	603,
+	670,
+	604,
+	670,
+	603,
+	670,
+	604,
+	671,
+	605,
+	671,
+	604,
+	671,
+	605,
+	672,
+	606,
+	672,
+	605,
+	672,
+	606,
+	673,
+	607,
+	673,
+	606,
+	673,
+	607,
+	674,
+	608,
+	674,
+	607,
+	674,
+	608,
+	675,
+	609,
+	675,
+	608,
+	675,
+	609,
+	676,
+	610,
+	676,
+	609,
+	676,
+	610,
+	677,
+	611,
+	677,
+	610,
+	677,
+	611,
+	678,
+	612,
+	678,
+	611,
+	678,
+	612,
+	679,
+	613,
+	679,
+	612,
+	679,
+	613,
+	680,
+	614,
+	680,
+	613,
+	680,
+	614,
+	681,
+	615,
+	681,
+	614,
+	681,
+	615,
+	682,
+	616,
+	682,
+	615,
+	682,
+	616,
+	683,
+	617,
+	683,
+	616,
+	683,
+	617,
+	684,
+	618,
+	684,
+	617,
+	684,
+	618,
+	685,
+	619,
+	685,
+	618,
+	685,
+	619,
+	686,
+	620,
+	686,
+	619,
+	686,
+	620,
+	687,
+	621,
+	687,
+	620,
+	687,
+	621,
+	688,
+	622,
+	688,
+	621,
+	688,
+	622,
+	689,
+	623,
+	689,
+	622,
+	689,
+	623,
+	690,
+	624,
+	690,
+	623,
+	690,
+	624,
+	691,
+	625,
+	691,
+	624,
+	691,
+	625,
+	692,
+	626,
+	692,
+	625,
+	692,
+	626,
+	693,
+	627,
+	693,
+	626,
+	693,
+	627,
+	694,
+	628,
+	694,
+	627,
+	694,
+	628,
+	695,
+	629,
+	695,
+	628,
+	695,
+	629,
+	696,
+	630,
+	696,
+	629,
+	696,
+	630,
+	697,
+	631,
+	697,
+	630,
+	697,
+	631,
+	698,
+	632,
+	698,
+	631,
+	698,
+	632,
+	699,
+	633,
+	699,
+	632,
+	699,
+	633,
+	700,
+	634,
+	700,
+	633,
+	700,
+	634,
+	701,
+	635,
+	701,
+	634,
+	701,
+	635,
+	702,
+	636,
+	702,
+	635,
+	702,
+	636,
+	703,
+	637,
+	703,
+	636,
+	703,
+	637,
+	704,
+	638,
+	704,
+	637,
+	704,
+	638,
+	705,
+	639,
+	705,
+	638,
+	705,
+	639,
+	706,
+	640,
+	706,
+	639,
+	706,
+	640,
+	707,
+	641,
+	707,
+	640,
+	707,
+	641,
+	708,
+	642,
+	708,
+	641,
+	708,
+	642,
+	709,
+	643,
+	709,
+	642,
+	709,
+	643,
+	710,
+	644,
+	710,
+	643,
+	710,
+	644,
+	711,
+	645,
+	711,
+	644,
+	711,
+	645,
+	712,
+	646,
+	712,
+	645,
+	712,
+	646,
+	713,
+	647,
+	713,
+	646,
+	713,
+	647,
+	714,
+	648,
+	714,
+	647,
+	714,
+	648,
+	715,
+	649,
+	715,
+	648,
+	715,
+	649,
+	716,
+	650,
+	716,
+	649,
+	716,
+	650,
+	717,
+	651,
+	717,
+	650,
+	717,
+	651,
+	718,
+	652,
+	718,
+	651,
+	718,
+	652,
+	719,
+	653,
+	719,
+	652,
+	719,
+	653,
+	720,
+	654,
+	720,
+	653,
+	720,
+	654,
+	721,
+	655,
+	721,
+	654,
+	721,
+	655,
+	722,
+	656,
+	722,
+	655,
+	722,
+	656,
+	723,
+	657,
+	723,
+	656,
+	723,
+	657,
+	724,
+	658,
+	724,
+	657,
+	724,
+	658,
+	725,
+	659,
+	725,
+	658,
+	726,
+	660,
+	727,
+	661,
+	727,
+	660,
+	727,
+	661,
+	728,
+	662,
+	728,
+	661,
+	728,
+	662,
+	729,
+	663,
+	729,
+	662,
+	729,
+	663,
+	730,
+	664,
+	730,
+	663,
+	730,
+	664,
+	731,
+	665,
+	731,
+	664,
+	731,
+	665,
+	732,
+	666,
+	732,
+	665,
+	732,
+	666,
+	733,
+	667,
+	733,
+	666,
+	733,
+	667,
+	734,
+	668,
+	734,
+	667,
+	734,
+	668,
+	735,
+	669,
+	735,
+	668,
+	735,
+	669,
+	736,
+	670,
+	736,
+	669,
+	736,
+	670,
+	737,
+	671,
+	737,
+	670,
+	737,
+	671,
+	738,
+	672,
+	738,
+	671,
+	738,
+	672,
+	739,
+	673,
+	739,
+	672,
+	739,
+	673,
+	740,
+	674,
+	740,
+	673,
+	740,
+	674,
+	741,
+	675,
+	741,
+	674,
+	741,
+	675,
+	742,
+	676,
+	742,
+	675,
+	742,
+	676,
+	743,
+	677,
+	743,
+	676,
+	743,
+	677,
+	744,
+	678,
+	744,
+	677,
+	744,
+	678,
+	745,
+	679,
+	745,
+	678,
+	745,
+	679,
+	746,
+	680,
+	746,
+	679,
+	746,
+	680,
+	747,
+	681,
+	747,
+	680,
+	747,
+	681,
+	748,
+	682,
+	748,
+	681,
+	748,
+	682,
+	749,
+	683,
+	749,
+	682,
+	749,
+	683,
+	750,
+	684,
+	750,
+	683,
+	750,
+	684,
+	751,
+	685,
+	751,
+	684,
+	751,
+	685,
+	752,
+	686,
+	752,
+	685,
+	752,
+	686,
+	753,
+	687,
+	753,
+	686,
+	753,
+	687,
+	754,
+	688,
+	754,
+	687,
+	754,
+	688,
+	755,
+	689,
+	755,
+	688,
+	755,
+	689,
+	756,
+	690,
+	756,
+	689,
+	756,
+	690,
+	757,
+	691,
+	757,
+	690,
+	757,
+	691,
+	758,
+	692,
+	758,
+	691,
+	758,
+	692,
+	759,
+	693,
+	759,
+	692,
+	759,
+	693,
+	760,
+	694,
+	760,
+	693,
+	760,
+	694,
+	761,
+	695,
+	761,
+	694,
+	761,
+	695,
+	762,
+	696,
+	762,
+	695,
+	762,
+	696,
+	763,
+	697,
+	763,
+	696,
+	763,
+	697,
+	764,
+	698,
+	764,
+	697,
+	764,
+	698,
+	765,
+	699,
+	765,
+	698,
+	765,
+	699,
+	766,
+	700,
+	766,
+	699,
+	766,
+	700,
+	767,
+	701,
+	767,
+	700,
+	767,
+	701,
+	768,
+	702,
+	768,
+	701,
+	768,
+	702,
+	769,
+	703,
+	769,
+	702,
+	769,
+	703,
+	770,
+	704,
+	770,
+	703,
+	770,
+	704,
+	771,
+	705,
+	771,
+	704,
+	771,
+	705,
+	772,
+	706,
+	772,
+	705,
+	772,
+	706,
+	773,
+	707,
+	773,
+	706,
+	773,
+	707,
+	774,
+	708,
+	774,
+	707,
+	774,
+	708,
+	775,
+	709,
+	775,
+	708,
+	775,
+	709,
+	776,
+	710,
+	776,
+	709,
+	776,
+	710,
+	777,
+	711,
+	777,
+	710,
+	777,
+	711,
+	778,
+	712,
+	778,
+	711,
+	778,
+	712,
+	779,
+	713,
+	779,
+	712,
+	779,
+	713,
+	780,
+	714,
+	780,
+	713,
+	780,
+	714,
+	781,
+	715,
+	781,
+	714,
+	781,
+	715,
+	782,
+	716,
+	782,
+	715,
+	782,
+	716,
+	783,
+	717,
+	783,
+	716,
+	783,
+	717,
+	784,
+	718,
+	784,
+	717,
+	784,
+	718,
+	785,
+	719,
+	785,
+	718,
+	785,
+	719,
+	786,
+	720,
+	786,
+	719,
+	786,
+	720,
+	787,
+	721,
+	787,
+	720,
+	787,
+	721,
+	788,
+	722,
+	788,
+	721,
+	788,
+	722,
+	789,
+	723,
+	789,
+	722,
+	789,
+	723,
+	790,
+	724,
+	790,
+	723,
+	790,
+	724,
+	791,
+	725,
+	791,
+	724,
+	792,
+	726,
+	793,
+	727,
+	793,
+	726,
+	793,
+	727,
+	794,
+	728,
+	794,
+	727,
+	794,
+	728,
+	795,
+	729,
+	795,
+	728,
+	795,
+	729,
+	796,
+	730,
+	796,
+	729,
+	796,
+	730,
+	797,
+	731,
+	797,
+	730,
+	797,
+	731,
+	798,
+	732,
+	798,
+	731,
+	798,
+	732,
+	799,
+	733,
+	799,
+	732,
+	799,
+	733,
+	800,
+	734,
+	800,
+	733,
+	800,
+	734,
+	801,
+	735,
+	801,
+	734,
+	801,
+	735,
+	802,
+	736,
+	802,
+	735,
+	802,
+	736,
+	803,
+	737,
+	803,
+	736,
+	803,
+	737,
+	804,
+	738,
+	804,
+	737,
+	804,
+	738,
+	805,
+	739,
+	805,
+	738,
+	805,
+	739,
+	806,
+	740,
+	806,
+	739,
+	806,
+	740,
+	807,
+	741,
+	807,
+	740,
+	807,
+	741,
+	808,
+	742,
+	808,
+	741,
+	808,
+	742,
+	809,
+	743,
+	809,
+	742,
+	809,
+	743,
+	810,
+	744,
+	810,
+	743,
+	810,
+	744,
+	811,
+	745,
+	811,
+	744,
+	811,
+	745,
+	812,
+	746,
+	812,
+	745,
+	812,
+	746,
+	813,
+	747,
+	813,
+	746,
+	813,
+	747,
+	814,
+	748,
+	814,
+	747,
+	814,
+	748,
+	815,
+	749,
+	815,
+	748,
+	815,
+	749,
+	816,
+	750,
+	816,
+	749,
+	816,
+	750,
+	817,
+	751,
+	817,
+	750,
+	817,
+	751,
+	818,
+	752,
+	818,
+	751,
+	818,
+	752,
+	819,
+	753,
+	819,
+	752,
+	819,
+	753,
+	820,
+	754,
+	820,
+	753,
+	820,
+	754,
+	821,
+	755,
+	821,
+	754,
+	821,
+	755,
+	822,
+	756,
+	822,
+	755,
+	822,
+	756,
+	823,
+	757,
+	823,
+	756,
+	823,
+	757,
+	824,
+	758,
+	824,
+	757,
+	824,
+	758,
+	825,
+	759,
+	825,
+	758,
+	825,
+	759,
+	826,
+	760,
+	826,
+	759,
+	826,
+	760,
+	827,
+	761,
+	827,
+	760,
+	827,
+	761,
+	828,
+	762,
+	828,
+	761,
+	828,
+	762,
+	829,
+	763,
+	829,
+	762,
+	829,
+	763,
+	830,
+	764,
+	830,
+	763,
+	830,
+	764,
+	831,
+	765,
+	831,
+	764,
+	831,
+	765,
+	832,
+	766,
+	832,
+	765,
+	832,
+	766,
+	833,
+	767,
+	833,
+	766,
+	833,
+	767,
+	834,
+	768,
+	834,
+	767,
+	834,
+	768,
+	835,
+	769,
+	835,
+	768,
+	835,
+	769,
+	836,
+	770,
+	836,
+	769,
+	836,
+	770,
+	837,
+	771,
+	837,
+	770,
+	837,
+	771,
+	838,
+	772,
+	838,
+	771,
+	838,
+	772,
+	839,
+	773,
+	839,
+	772,
+	839,
+	773,
+	840,
+	774,
+	840,
+	773,
+	840,
+	774,
+	841,
+	775,
+	841,
+	774,
+	841,
+	775,
+	842,
+	776,
+	842,
+	775,
+	842,
+	776,
+	843,
+	777,
+	843,
+	776,
+	843,
+	777,
+	844,
+	778,
+	844,
+	777,
+	844,
+	778,
+	845,
+	779,
+	845,
+	778,
+	845,
+	779,
+	846,
+	780,
+	846,
+	779,
+	846,
+	780,
+	847,
+	781,
+	847,
+	780,
+	847,
+	781,
+	848,
+	782,
+	848,
+	781,
+	848,
+	782,
+	849,
+	783,
+	849,
+	782,
+	849,
+	783,
+	850,
+	784,
+	850,
+	783,
+	850,
+	784,
+	851,
+	785,
+	851,
+	784,
+	851,
+	785,
+	852,
+	786,
+	852,
+	785,
+	852,
+	786,
+	853,
+	787,
+	853,
+	786,
+	853,
+	787,
+	854,
+	788,
+	854,
+	787,
+	854,
+	788,
+	855,
+	789,
+	855,
+	788,
+	855,
+	789,
+	856,
+	790,
+	856,
+	789,
+	856,
+	790,
+	857,
+	791,
+	857,
+	790,
+	858,
+	792,
+	859,
+	793,
+	859,
+	792,
+	859,
+	793,
+	860,
+	794,
+	860,
+	793,
+	860,
+	794,
+	861,
+	795,
+	861,
+	794,
+	861,
+	795,
+	862,
+	796,
+	862,
+	795,
+	862,
+	796,
+	863,
+	797,
+	863,
+	796,
+	863,
+	797,
+	864,
+	798,
+	864,
+	797,
+	864,
+	798,
+	865,
+	799,
+	865,
+	798,
+	865,
+	799,
+	866,
+	800,
+	866,
+	799,
+	866,
+	800,
+	867,
+	801,
+	867,
+	800,
+	867,
+	801,
+	868,
+	802,
+	868,
+	801,
+	868,
+	802,
+	869,
+	803,
+	869,
+	802,
+	869,
+	803,
+	870,
+	804,
+	870,
+	803,
+	870,
+	804,
+	871,
+	805,
+	871,
+	804,
+	871,
+	805,
+	872,
+	806,
+	872,
+	805,
+	872,
+	806,
+	873,
+	807,
+	873,
+	806,
+	873,
+	807,
+	874,
+	808,
+	874,
+	807,
+	874,
+	808,
+	875,
+	809,
+	875,
+	808,
+	875,
+	809,
+	876,
+	810,
+	876,
+	809,
+	876,
+	810,
+	877,
+	811,
+	877,
+	810,
+	877,
+	811,
+	878,
+	812,
+	878,
+	811,
+	878,
+	812,
+	879,
+	813,
+	879,
+	812,
+	879,
+	813,
+	880,
+	814,
+	880,
+	813,
+	880,
+	814,
+	881,
+	815,
+	881,
+	814,
+	881,
+	815,
+	882,
+	816,
+	882,
+	815,
+	882,
+	816,
+	883,
+	817,
+	883,
+	816,
+	883,
+	817,
+	884,
+	818,
+	884,
+	817,
+	884,
+	818,
+	885,
+	819,
+	885,
+	818,
+	885,
+	819,
+	886,
+	820,
+	886,
+	819,
+	886,
+	820,
+	887,
+	821,
+	887,
+	820,
+	887,
+	821,
+	888,
+	822,
+	888,
+	821,
+	888,
+	822,
+	889,
+	823,
+	889,
+	822,
+	889,
+	823,
+	890,
+	824,
+	890,
+	823,
+	890,
+	824,
+	891,
+	825,
+	891,
+	824,
+	891,
+	825,
+	892,
+	826,
+	892,
+	825,
+	892,
+	826,
+	893,
+	827,
+	893,
+	826,
+	893,
+	827,
+	894,
+	828,
+	894,
+	827,
+	894,
+	828,
+	895,
+	829,
+	895,
+	828,
+	895,
+	829,
+	896,
+	830,
+	896,
+	829,
+	896,
+	830,
+	897,
+	831,
+	897,
+	830,
+	897,
+	831,
+	898,
+	832,
+	898,
+	831,
+	898,
+	832,
+	899,
+	833,
+	899,
+	832,
+	899,
+	833,
+	900,
+	834,
+	900,
+	833,
+	900,
+	834,
+	901,
+	835,
+	901,
+	834,
+	901,
+	835,
+	902,
+	836,
+	902,
+	835,
+	902,
+	836,
+	903,
+	837,
+	903,
+	836,
+	903,
+	837,
+	904,
+	838,
+	904,
+	837,
+	904,
+	838,
+	905,
+	839,
+	905,
+	838,
+	905,
+	839,
+	906,
+	840,
+	906,
+	839,
+	906,
+	840,
+	907,
+	841,
+	907,
+	840,
+	907,
+	841,
+	908,
+	842,
+	908,
+	841,
+	908,
+	842,
+	909,
+	843,
+	909,
+	842,
+	909,
+	843,
+	910,
+	844,
+	910,
+	843,
+	910,
+	844,
+	911,
+	845,
+	911,
+	844,
+	911,
+	845,
+	912,
+	846,
+	912,
+	845,
+	912,
+	846,
+	913,
+	847,
+	913,
+	846,
+	913,
+	847,
+	914,
+	848,
+	914,
+	847,
+	914,
+	848,
+	915,
+	849,
+	915,
+	848,
+	915,
+	849,
+	916,
+	850,
+	916,
+	849,
+	916,
+	850,
+	917,
+	851,
+	917,
+	850,
+	917,
+	851,
+	918,
+	852,
+	918,
+	851,
+	918,
+	852,
+	919,
+	853,
+	919,
+	852,
+	919,
+	853,
+	920,
+	854,
+	920,
+	853,
+	920,
+	854,
+	921,
+	855,
+	921,
+	854,
+	921,
+	855,
+	922,
+	856,
+	922,
+	855,
+	922,
+	856,
+	923,
+	857,
+	923,
+	856,
+	924,
+	858,
+	925,
+	859,
+	925,
+	858,
+	925,
+	859,
+	926,
+	860,
+	926,
+	859,
+	926,
+	860,
+	927,
+	861,
+	927,
+	860,
+	927,
+	861,
+	928,
+	862,
+	928,
+	861,
+	928,
+	862,
+	929,
+	863,
+	929,
+	862,
+	929,
+	863,
+	930,
+	864,
+	930,
+	863,
+	930,
+	864,
+	931,
+	865,
+	931,
+	864,
+	931,
+	865,
+	932,
+	866,
+	932,
+	865,
+	932,
+	866,
+	933,
+	867,
+	933,
+	866,
+	933,
+	867,
+	934,
+	868,
+	934,
+	867,
+	934,
+	868,
+	935,
+	869,
+	935,
+	868,
+	935,
+	869,
+	936,
+	870,
+	936,
+	869,
+	936,
+	870,
+	937,
+	871,
+	937,
+	870,
+	937,
+	871,
+	938,
+	872,
+	938,
+	871,
+	938,
+	872,
+	939,
+	873,
+	939,
+	872,
+	939,
+	873,
+	940,
+	874,
+	940,
+	873,
+	940,
+	874,
+	941,
+	875,
+	941,
+	874,
+	941,
+	875,
+	942,
+	876,
+	942,
+	875,
+	942,
+	876,
+	943,
+	877,
+	943,
+	876,
+	943,
+	877,
+	944,
+	878,
+	944,
+	877,
+	944,
+	878,
+	945,
+	879,
+	945,
+	878,
+	945,
+	879,
+	946,
+	880,
+	946,
+	879,
+	946,
+	880,
+	947,
+	881,
+	947,
+	880,
+	947,
+	881,
+	948,
+	882,
+	948,
+	881,
+	948,
+	882,
+	949,
+	883,
+	949,
+	882,
+	949,
+	883,
+	950,
+	884,
+	950,
+	883,
+	950,
+	884,
+	951,
+	885,
+	951,
+	884,
+	951,
+	885,
+	952,
+	886,
+	952,
+	885,
+	952,
+	886,
+	953,
+	887,
+	953,
+	886,
+	953,
+	887,
+	954,
+	888,
+	954,
+	887,
+	954,
+	888,
+	955,
+	889,
+	955,
+	888,
+	955,
+	889,
+	956,
+	890,
+	956,
+	889,
+	956,
+	890,
+	957,
+	891,
+	957,
+	890,
+	957,
+	891,
+	958,
+	892,
+	958,
+	891,
+	958,
+	892,
+	959,
+	893,
+	959,
+	892,
+	959,
+	893,
+	960,
+	894,
+	960,
+	893,
+	960,
+	894,
+	961,
+	895,
+	961,
+	894,
+	961,
+	895,
+	962,
+	896,
+	962,
+	895,
+	962,
+	896,
+	963,
+	897,
+	963,
+	896,
+	963,
+	897,
+	964,
+	898,
+	964,
+	897,
+	964,
+	898,
+	965,
+	899,
+	965,
+	898,
+	965,
+	899,
+	966,
+	900,
+	966,
+	899,
+	966,
+	900,
+	967,
+	901,
+	967,
+	900,
+	967,
+	901,
+	968,
+	902,
+	968,
+	901,
+	968,
+	902,
+	969,
+	903,
+	969,
+	902,
+	969,
+	903,
+	970,
+	904,
+	970,
+	903,
+	970,
+	904,
+	971,
+	905,
+	971,
+	904,
+	971,
+	905,
+	972,
+	906,
+	972,
+	905,
+	972,
+	906,
+	973,
+	907,
+	973,
+	906,
+	973,
+	907,
+	974,
+	908,
+	974,
+	907,
+	974,
+	908,
+	975,
+	909,
+	975,
+	908,
+	975,
+	909,
+	976,
+	910,
+	976,
+	909,
+	976,
+	910,
+	977,
+	911,
+	977,
+	910,
+	977,
+	911,
+	978,
+	912,
+	978,
+	911,
+	978,
+	912,
+	979,
+	913,
+	979,
+	912,
+	979,
+	913,
+	980,
+	914,
+	980,
+	913,
+	980,
+	914,
+	981,
+	915,
+	981,
+	914,
+	981,
+	915,
+	982,
+	916,
+	982,
+	915,
+	982,
+	916,
+	983,
+	917,
+	983,
+	916,
+	983,
+	917,
+	984,
+	918,
+	984,
+	917,
+	984,
+	918,
+	985,
+	919,
+	985,
+	918,
+	985,
+	919,
+	986,
+	920,
+	986,
+	919,
+	986,
+	920,
+	987,
+	921,
+	987,
+	920,
+	987,
+	921,
+	988,
+	922,
+	988,
+	921,
+	988,
+	922,
+	989,
+	923,
+	989,
+	922,
+	990,
+	924,
+	991,
+	925,
+	991,
+	924,
+	991,
+	925,
+	992,
+	926,
+	992,
+	925,
+	992,
+	926,
+	993,
+	927,
+	993,
+	926,
+	993,
+	927,
+	994,
+	928,
+	994,
+	927,
+	994,
+	928,
+	995,
+	929,
+	995,
+	928,
+	995,
+	929,
+	996,
+	930,
+	996,
+	929,
+	996,
+	930,
+	997,
+	931,
+	997,
+	930,
+	997,
+	931,
+	998,
+	932,
+	998,
+	931,
+	998,
+	932,
+	999,
+	933,
+	999,
+	932,
+	999,
+	933,
+	1000,
+	934,
+	1000,
+	933,
+	1000,
+	934,
+	1001,
+	935,
+	1001,
+	934,
+	1001,
+	935,
+	1002,
+	936,
+	1002,
+	935,
+	1002,
+	936,
+	1003,
+	937,
+	1003,
+	936,
+	1003,
+	937,
+	1004,
+	938,
+	1004,
+	937,
+	1004,
+	938,
+	1005,
+	939,
+	1005,
+	938,
+	1005,
+	939,
+	1006,
+	940,
+	1006,
+	939,
+	1006,
+	940,
+	1007,
+	941,
+	1007,
+	940,
+	1007,
+	941,
+	1008,
+	942,
+	1008,
+	941,
+	1008,
+	942,
+	1009,
+	943,
+	1009,
+	942,
+	1009,
+	943,
+	1010,
+	944,
+	1010,
+	943,
+	1010,
+	944,
+	1011,
+	945,
+	1011,
+	944,
+	1011,
+	945,
+	1012,
+	946,
+	1012,
+	945,
+	1012,
+	946,
+	1013,
+	947,
+	1013,
+	946,
+	1013,
+	947,
+	1014,
+	948,
+	1014,
+	947,
+	1014,
+	948,
+	1015,
+	949,
+	1015,
+	948,
+	1015,
+	949,
+	1016,
+	950,
+	1016,
+	949,
+	1016,
+	950,
+	1017,
+	951,
+	1017,
+	950,
+	1017,
+	951,
+	1018,
+	952,
+	1018,
+	951,
+	1018,
+	952,
+	1019,
+	953,
+	1019,
+	952,
+	1019,
+	953,
+	1020,
+	954,
+	1020,
+	953,
+	1020,
+	954,
+	1021,
+	955,
+	1021,
+	954,
+	1021,
+	955,
+	1022,
+	956,
+	1022,
+	955,
+	1022,
+	956,
+	1023,
+	957,
+	1023,
+	956,
+	1023,
+	957,
+	1024,
+	958,
+	1024,
+	957,
+	1024,
+	958,
+	1025,
+	959,
+	1025,
+	958,
+	1025,
+	959,
+	1026,
+	960,
+	1026,
+	959,
+	1026,
+	960,
+	1027,
+	961,
+	1027,
+	960,
+	1027,
+	961,
+	1028,
+	962,
+	1028,
+	961,
+	1028,
+	962,
+	1029,
+	963,
+	1029,
+	962,
+	1029,
+	963,
+	1030,
+	964,
+	1030,
+	963,
+	1030,
+	964,
+	1031,
+	965,
+	1031,
+	964,
+	1031,
+	965,
+	1032,
+	966,
+	1032,
+	965,
+	1032,
+	966,
+	1033,
+	967,
+	1033,
+	966,
+	1033,
+	967,
+	1034,
+	968,
+	1034,
+	967,
+	1034,
+	968,
+	1035,
+	969,
+	1035,
+	968,
+	1035,
+	969,
+	1036,
+	970,
+	1036,
+	969,
+	1036,
+	970,
+	1037,
+	971,
+	1037,
+	970,
+	1037,
+	971,
+	1038,
+	972,
+	1038,
+	971,
+	1038,
+	972,
+	1039,
+	973,
+	1039,
+	972,
+	1039,
+	973,
+	1040,
+	974,
+	1040,
+	973,
+	1040,
+	974,
+	1041,
+	975,
+	1041,
+	974,
+	1041,
+	975,
+	1042,
+	976,
+	1042,
+	975,
+	1042,
+	976,
+	1043,
+	977,
+	1043,
+	976,
+	1043,
+	977,
+	1044,
+	978,
+	1044,
+	977,
+	1044,
+	978,
+	1045,
+	979,
+	1045,
+	978,
+	1045,
+	979,
+	1046,
+	980,
+	1046,
+	979,
+	1046,
+	980,
+	1047,
+	981,
+	1047,
+	980,
+	1047,
+	981,
+	1048,
+	982,
+	1048,
+	981,
+	1048,
+	982,
+	1049,
+	983,
+	1049,
+	982,
+	1049,
+	983,
+	1050,
+	984,
+	1050,
+	983,
+	1050,
+	984,
+	1051,
+	985,
+	1051,
+	984,
+	1051,
+	985,
+	1052,
+	986,
+	1052,
+	985,
+	1052,
+	986,
+	1053,
+	987,
+	1053,
+	986,
+	1053,
+	987,
+	1054,
+	988,
+	1054,
+	987,
+	1054,
+	988,
+	1055,
+	989,
+	1055,
+	988,
+	1056,
+	990,
+	1057,
+	991,
+	1057,
+	990,
+	1057,
+	991,
+	1058,
+	992,
+	1058,
+	991,
+	1058,
+	992,
+	1059,
+	993,
+	1059,
+	992,
+	1059,
+	993,
+	1060,
+	994,
+	1060,
+	993,
+	1060,
+	994,
+	1061,
+	995,
+	1061,
+	994,
+	1061,
+	995,
+	1062,
+	996,
+	1062,
+	995,
+	1062,
+	996,
+	1063,
+	997,
+	1063,
+	996,
+	1063,
+	997,
+	1064,
+	998,
+	1064,
+	997,
+	1064,
+	998,
+	1065,
+	999,
+	1065,
+	998,
+	1065,
+	999,
+	1066,
+	1000,
+	1066,
+	999,
+	1066,
+	1000,
+	1067,
+	1001,
+	1067,
+	1000,
+	1067,
+	1001,
+	1068,
+	1002,
+	1068,
+	1001,
+	1068,
+	1002,
+	1069,
+	1003,
+	1069,
+	1002,
+	1069,
+	1003,
+	1070,
+	1004,
+	1070,
+	1003,
+	1070,
+	1004,
+	1071,
+	1005,
+	1071,
+	1004,
+	1071,
+	1005,
+	1072,
+	1006,
+	1072,
+	1005,
+	1072,
+	1006,
+	1073,
+	1007,
+	1073,
+	1006,
+	1073,
+	1007,
+	1074,
+	1008,
+	1074,
+	1007,
+	1074,
+	1008,
+	1075,
+	1009,
+	1075,
+	1008,
+	1075,
+	1009,
+	1076,
+	1010,
+	1076,
+	1009,
+	1076,
+	1010,
+	1077,
+	1011,
+	1077,
+	1010,
+	1077,
+	1011,
+	1078,
+	1012,
+	1078,
+	1011,
+	1078,
+	1012,
+	1079,
+	1013,
+	1079,
+	1012,
+	1079,
+	1013,
+	1080,
+	1014,
+	1080,
+	1013,
+	1080,
+	1014,
+	1081,
+	1015,
+	1081,
+	1014,
+	1081,
+	1015,
+	1082,
+	1016,
+	1082,
+	1015,
+	1082,
+	1016,
+	1083,
+	1017,
+	1083,
+	1016,
+	1083,
+	1017,
+	1084,
+	1018,
+	1084,
+	1017,
+	1084,
+	1018,
+	1085,
+	1019,
+	1085,
+	1018,
+	1085,
+	1019,
+	1086,
+	1020,
+	1086,
+	1019,
+	1086,
+	1020,
+	1087,
+	1021,
+	1087,
+	1020,
+	1087,
+	1021,
+	1088,
+	1022,
+	1088,
+	1021,
+	1088,
+	1022,
+	1089,
+	1023,
+	1089,
+	1022,
+	1089,
+	1023,
+	1090,
+	1024,
+	1090,
+	1023,
+	1090,
+	1024,
+	1091,
+	1025,
+	1091,
+	1024,
+	1091,
+	1025,
+	1092,
+	1026,
+	1092,
+	1025,
+	1092,
+	1026,
+	1093,
+	1027,
+	1093,
+	1026,
+	1093,
+	1027,
+	1094,
+	1028,
+	1094,
+	1027,
+	1094,
+	1028,
+	1095,
+	1029,
+	1095,
+	1028,
+	1095,
+	1029,
+	1096,
+	1030,
+	1096,
+	1029,
+	1096,
+	1030,
+	1097,
+	1031,
+	1097,
+	1030,
+	1097,
+	1031,
+	1098,
+	1032,
+	1098,
+	1031,
+	1098,
+	1032,
+	1099,
+	1033,
+	1099,
+	1032,
+	1099,
+	1033,
+	1100,
+	1034,
+	1100,
+	1033,
+	1100,
+	1034,
+	1101,
+	1035,
+	1101,
+	1034,
+	1101,
+	1035,
+	1102,
+	1036,
+	1102,
+	1035,
+	1102,
+	1036,
+	1103,
+	1037,
+	1103,
+	1036,
+	1103,
+	1037,
+	1104,
+	1038,
+	1104,
+	1037,
+	1104,
+	1038,
+	1105,
+	1039,
+	1105,
+	1038,
+	1105,
+	1039,
+	1106,
+	1040,
+	1106,
+	1039,
+	1106,
+	1040,
+	1107,
+	1041,
+	1107,
+	1040,
+	1107,
+	1041,
+	1108,
+	1042,
+	1108,
+	1041,
+	1108,
+	1042,
+	1109,
+	1043,
+	1109,
+	1042,
+	1109,
+	1043,
+	1110,
+	1044,
+	1110,
+	1043,
+	1110,
+	1044,
+	1111,
+	1045,
+	1111,
+	1044,
+	1111,
+	1045,
+	1112,
+	1046,
+	1112,
+	1045,
+	1112,
+	1046,
+	1113,
+	1047,
+	1113,
+	1046,
+	1113,
+	1047,
+	1114,
+	1048,
+	1114,
+	1047,
+	1114,
+	1048,
+	1115,
+	1049,
+	1115,
+	1048,
+	1115,
+	1049,
+	1116,
+	1050,
+	1116,
+	1049,
+	1116,
+	1050,
+	1117,
+	1051,
+	1117,
+	1050,
+	1117,
+	1051,
+	1118,
+	1052,
+	1118,
+	1051,
+	1118,
+	1052,
+	1119,
+	1053,
+	1119,
+	1052,
+	1119,
+	1053,
+	1120,
+	1054,
+	1120,
+	1053,
+	1120,
+	1054,
+	1121,
+	1055,
+	1121,
+	1054,
+	1122,
+	1056,
+	1123,
+	1057,
+	1123,
+	1056,
+	1123,
+	1057,
+	1124,
+	1058,
+	1124,
+	1057,
+	1124,
+	1058,
+	1125,
+	1059,
+	1125,
+	1058,
+	1125,
+	1059,
+	1126,
+	1060,
+	1126,
+	1059,
+	1126,
+	1060,
+	1127,
+	1061,
+	1127,
+	1060,
+	1127,
+	1061,
+	1128,
+	1062,
+	1128,
+	1061,
+	1128,
+	1062,
+	1129,
+	1063,
+	1129,
+	1062,
+	1129,
+	1063,
+	1130,
+	1064,
+	1130,
+	1063,
+	1130,
+	1064,
+	1131,
+	1065,
+	1131,
+	1064,
+	1131,
+	1065,
+	1132,
+	1066,
+	1132,
+	1065,
+	1132,
+	1066,
+	1133,
+	1067,
+	1133,
+	1066,
+	1133,
+	1067,
+	1134,
+	1068,
+	1134,
+	1067,
+	1134,
+	1068,
+	1135,
+	1069,
+	1135,
+	1068,
+	1135,
+	1069,
+	1136,
+	1070,
+	1136,
+	1069,
+	1136,
+	1070,
+	1137,
+	1071,
+	1137,
+	1070,
+	1137,
+	1071,
+	1138,
+	1072,
+	1138,
+	1071,
+	1138,
+	1072,
+	1139,
+	1073,
+	1139,
+	1072,
+	1139,
+	1073,
+	1140,
+	1074,
+	1140,
+	1073,
+	1140,
+	1074,
+	1141,
+	1075,
+	1141,
+	1074,
+	1141,
+	1075,
+	1142,
+	1076,
+	1142,
+	1075,
+	1142,
+	1076,
+	1143,
+	1077,
+	1143,
+	1076,
+	1143,
+	1077,
+	1144,
+	1078,
+	1144,
+	1077,
+	1144,
+	1078,
+	1145,
+	1079,
+	1145,
+	1078,
+	1145,
+	1079,
+	1146,
+	1080,
+	1146,
+	1079,
+	1146,
+	1080,
+	1147,
+	1081,
+	1147,
+	1080,
+	1147,
+	1081,
+	1148,
+	1082,
+	1148,
+	1081,
+	1148,
+	1082,
+	1149,
+	1083,
+	1149,
+	1082,
+	1149,
+	1083,
+	1150,
+	1084,
+	1150,
+	1083,
+	1150,
+	1084,
+	1151,
+	1085,
+	1151,
+	1084,
+	1151,
+	1085,
+	1152,
+	1086,
+	1152,
+	1085,
+	1152,
+	1086,
+	1153,
+	1087,
+	1153,
+	1086,
+	1153,
+	1087,
+	1154,
+	1088,
+	1154,
+	1087,
+	1154,
+	1088,
+	1155,
+	1089,
+	1155,
+	1088,
+	1155,
+	1089,
+	1156,
+	1090,
+	1156,
+	1089,
+	1156,
+	1090,
+	1157,
+	1091,
+	1157,
+	1090,
+	1157,
+	1091,
+	1158,
+	1092,
+	1158,
+	1091,
+	1158,
+	1092,
+	1159,
+	1093,
+	1159,
+	1092,
+	1159,
+	1093,
+	1160,
+	1094,
+	1160,
+	1093,
+	1160,
+	1094,
+	1161,
+	1095,
+	1161,
+	1094,
+	1161,
+	1095,
+	1162,
+	1096,
+	1162,
+	1095,
+	1162,
+	1096,
+	1163,
+	1097,
+	1163,
+	1096,
+	1163,
+	1097,
+	1164,
+	1098,
+	1164,
+	1097,
+	1164,
+	1098,
+	1165,
+	1099,
+	1165,
+	1098,
+	1165,
+	1099,
+	1166,
+	1100,
+	1166,
+	1099,
+	1166,
+	1100,
+	1167,
+	1101,
+	1167,
+	1100,
+	1167,
+	1101,
+	1168,
+	1102,
+	1168,
+	1101,
+	1168,
+	1102,
+	1169,
+	1103,
+	1169,
+	1102,
+	1169,
+	1103,
+	1170,
+	1104,
+	1170,
+	1103,
+	1170,
+	1104,
+	1171,
+	1105,
+	1171,
+	1104,
+	1171,
+	1105,
+	1172,
+	1106,
+	1172,
+	1105,
+	1172,
+	1106,
+	1173,
+	1107,
+	1173,
+	1106,
+	1173,
+	1107,
+	1174,
+	1108,
+	1174,
+	1107,
+	1174,
+	1108,
+	1175,
+	1109,
+	1175,
+	1108,
+	1175,
+	1109,
+	1176,
+	1110,
+	1176,
+	1109,
+	1176,
+	1110,
+	1177,
+	1111,
+	1177,
+	1110,
+	1177,
+	1111,
+	1178,
+	1112,
+	1178,
+	1111,
+	1178,
+	1112,
+	1179,
+	1113,
+	1179,
+	1112,
+	1179,
+	1113,
+	1180,
+	1114,
+	1180,
+	1113,
+	1180,
+	1114,
+	1181,
+	1115,
+	1181,
+	1114,
+	1181,
+	1115,
+	1182,
+	1116,
+	1182,
+	1115,
+	1182,
+	1116,
+	1183,
+	1117,
+	1183,
+	1116,
+	1183,
+	1117,
+	1184,
+	1118,
+	1184,
+	1117,
+	1184,
+	1118,
+	1185,
+	1119,
+	1185,
+	1118,
+	1185,
+	1119,
+	1186,
+	1120,
+	1186,
+	1119,
+	1186,
+	1120,
+	1187,
+	1121,
+	1187,
+	1120,
+	1188,
+	1122,
+	1189,
+	1123,
+	1189,
+	1122,
+	1189,
+	1123,
+	1190,
+	1124,
+	1190,
+	1123,
+	1190,
+	1124,
+	1191,
+	1125,
+	1191,
+	1124,
+	1191,
+	1125,
+	1192,
+	1126,
+	1192,
+	1125,
+	1192,
+	1126,
+	1193,
+	1127,
+	1193,
+	1126,
+	1193,
+	1127,
+	1194,
+	1128,
+	1194,
+	1127,
+	1194,
+	1128,
+	1195,
+	1129,
+	1195,
+	1128,
+	1195,
+	1129,
+	1196,
+	1130,
+	1196,
+	1129,
+	1196,
+	1130,
+	1197,
+	1131,
+	1197,
+	1130,
+	1197,
+	1131,
+	1198,
+	1132,
+	1198,
+	1131,
+	1198,
+	1132,
+	1199,
+	1133,
+	1199,
+	1132,
+	1199,
+	1133,
+	1200,
+	1134,
+	1200,
+	1133,
+	1200,
+	1134,
+	1201,
+	1135,
+	1201,
+	1134,
+	1201,
+	1135,
+	1202,
+	1136,
+	1202,
+	1135,
+	1202,
+	1136,
+	1203,
+	1137,
+	1203,
+	1136,
+	1203,
+	1137,
+	1204,
+	1138,
+	1204,
+	1137,
+	1204,
+	1138,
+	1205,
+	1139,
+	1205,
+	1138,
+	1205,
+	1139,
+	1206,
+	1140,
+	1206,
+	1139,
+	1206,
+	1140,
+	1207,
+	1141,
+	1207,
+	1140,
+	1207,
+	1141,
+	1208,
+	1142,
+	1208,
+	1141,
+	1208,
+	1142,
+	1209,
+	1143,
+	1209,
+	1142,
+	1209,
+	1143,
+	1210,
+	1144,
+	1210,
+	1143,
+	1210,
+	1144,
+	1211,
+	1145,
+	1211,
+	1144,
+	1211,
+	1145,
+	1212,
+	1146,
+	1212,
+	1145,
+	1212,
+	1146,
+	1213,
+	1147,
+	1213,
+	1146,
+	1213,
+	1147,
+	1214,
+	1148,
+	1214,
+	1147,
+	1214,
+	1148,
+	1215,
+	1149,
+	1215,
+	1148,
+	1215,
+	1149,
+	1216,
+	1150,
+	1216,
+	1149,
+	1216,
+	1150,
+	1217,
+	1151,
+	1217,
+	1150,
+	1217,
+	1151,
+	1218,
+	1152,
+	1218,
+	1151,
+	1218,
+	1152,
+	1219,
+	1153,
+	1219,
+	1152,
+	1219,
+	1153,
+	1220,
+	1154,
+	1220,
+	1153,
+	1220,
+	1154,
+	1221,
+	1155,
+	1221,
+	1154,
+	1221,
+	1155,
+	1222,
+	1156,
+	1222,
+	1155,
+	1222,
+	1156,
+	1223,
+	1157,
+	1223,
+	1156,
+	1223,
+	1157,
+	1224,
+	1158,
+	1224,
+	1157,
+	1224,
+	1158,
+	1225,
+	1159,
+	1225,
+	1158,
+	1225,
+	1159,
+	1226,
+	1160,
+	1226,
+	1159,
+	1226,
+	1160,
+	1227,
+	1161,
+	1227,
+	1160,
+	1227,
+	1161,
+	1228,
+	1162,
+	1228,
+	1161,
+	1228,
+	1162,
+	1229,
+	1163,
+	1229,
+	1162,
+	1229,
+	1163,
+	1230,
+	1164,
+	1230,
+	1163,
+	1230,
+	1164,
+	1231,
+	1165,
+	1231,
+	1164,
+	1231,
+	1165,
+	1232,
+	1166,
+	1232,
+	1165,
+	1232,
+	1166,
+	1233,
+	1167,
+	1233,
+	1166,
+	1233,
+	1167,
+	1234,
+	1168,
+	1234,
+	1167,
+	1234,
+	1168,
+	1235,
+	1169,
+	1235,
+	1168,
+	1235,
+	1169,
+	1236,
+	1170,
+	1236,
+	1169,
+	1236,
+	1170,
+	1237,
+	1171,
+	1237,
+	1170,
+	1237,
+	1171,
+	1238,
+	1172,
+	1238,
+	1171,
+	1238,
+	1172,
+	1239,
+	1173,
+	1239,
+	1172,
+	1239,
+	1173,
+	1240,
+	1174,
+	1240,
+	1173,
+	1240,
+	1174,
+	1241,
+	1175,
+	1241,
+	1174,
+	1241,
+	1175,
+	1242,
+	1176,
+	1242,
+	1175,
+	1242,
+	1176,
+	1243,
+	1177,
+	1243,
+	1176,
+	1243,
+	1177,
+	1244,
+	1178,
+	1244,
+	1177,
+	1244,
+	1178,
+	1245,
+	1179,
+	1245,
+	1178,
+	1245,
+	1179,
+	1246,
+	1180,
+	1246,
+	1179,
+	1246,
+	1180,
+	1247,
+	1181,
+	1247,
+	1180,
+	1247,
+	1181,
+	1248,
+	1182,
+	1248,
+	1181,
+	1248,
+	1182,
+	1249,
+	1183,
+	1249,
+	1182,
+	1249,
+	1183,
+	1250,
+	1184,
+	1250,
+	1183,
+	1250,
+	1184,
+	1251,
+	1185,
+	1251,
+	1184,
+	1251,
+	1185,
+	1252,
+	1186,
+	1252,
+	1185,
+	1252,
+	1186,
+	1253,
+	1187,
+	1253,
+	1186,
+	1254,
+	1188,
+	1255,
+	1189,
+	1255,
+	1188,
+	1255,
+	1189,
+	1256,
+	1190,
+	1256,
+	1189,
+	1256,
+	1190,
+	1257,
+	1191,
+	1257,
+	1190,
+	1257,
+	1191,
+	1258,
+	1192,
+	1258,
+	1191,
+	1258,
+	1192,
+	1259,
+	1193,
+	1259,
+	1192,
+	1259,
+	1193,
+	1260,
+	1194,
+	1260,
+	1193,
+	1260,
+	1194,
+	1261,
+	1195,
+	1261,
+	1194,
+	1261,
+	1195,
+	1262,
+	1196,
+	1262,
+	1195,
+	1262,
+	1196,
+	1263,
+	1197,
+	1263,
+	1196,
+	1263,
+	1197,
+	1264,
+	1198,
+	1264,
+	1197,
+	1264,
+	1198,
+	1265,
+	1199,
+	1265,
+	1198,
+	1265,
+	1199,
+	1266,
+	1200,
+	1266,
+	1199,
+	1266,
+	1200,
+	1267,
+	1201,
+	1267,
+	1200,
+	1267,
+	1201,
+	1268,
+	1202,
+	1268,
+	1201,
+	1268,
+	1202,
+	1269,
+	1203,
+	1269,
+	1202,
+	1269,
+	1203,
+	1270,
+	1204,
+	1270,
+	1203,
+	1270,
+	1204,
+	1271,
+	1205,
+	1271,
+	1204,
+	1271,
+	1205,
+	1272,
+	1206,
+	1272,
+	1205,
+	1272,
+	1206,
+	1273,
+	1207,
+	1273,
+	1206,
+	1273,
+	1207,
+	1274,
+	1208,
+	1274,
+	1207,
+	1274,
+	1208,
+	1275,
+	1209,
+	1275,
+	1208,
+	1275,
+	1209,
+	1276,
+	1210,
+	1276,
+	1209,
+	1276,
+	1210,
+	1277,
+	1211,
+	1277,
+	1210,
+	1277,
+	1211,
+	1278,
+	1212,
+	1278,
+	1211,
+	1278,
+	1212,
+	1279,
+	1213,
+	1279,
+	1212,
+	1279,
+	1213,
+	1280,
+	1214,
+	1280,
+	1213,
+	1280,
+	1214,
+	1281,
+	1215,
+	1281,
+	1214,
+	1281,
+	1215,
+	1282,
+	1216,
+	1282,
+	1215,
+	1282,
+	1216,
+	1283,
+	1217,
+	1283,
+	1216,
+	1283,
+	1217,
+	1284,
+	1218,
+	1284,
+	1217,
+	1284,
+	1218,
+	1285,
+	1219,
+	1285,
+	1218,
+	1285,
+	1219,
+	1286,
+	1220,
+	1286,
+	1219,
+	1286,
+	1220,
+	1287,
+	1221,
+	1287,
+	1220,
+	1287,
+	1221,
+	1288,
+	1222,
+	1288,
+	1221,
+	1288,
+	1222,
+	1289,
+	1223,
+	1289,
+	1222,
+	1289,
+	1223,
+	1290,
+	1224,
+	1290,
+	1223,
+	1290,
+	1224,
+	1291,
+	1225,
+	1291,
+	1224,
+	1291,
+	1225,
+	1292,
+	1226,
+	1292,
+	1225,
+	1292,
+	1226,
+	1293,
+	1227,
+	1293,
+	1226,
+	1293,
+	1227,
+	1294,
+	1228,
+	1294,
+	1227,
+	1294,
+	1228,
+	1295,
+	1229,
+	1295,
+	1228,
+	1295,
+	1229,
+	1296,
+	1230,
+	1296,
+	1229,
+	1296,
+	1230,
+	1297,
+	1231,
+	1297,
+	1230,
+	1297,
+	1231,
+	1298,
+	1232,
+	1298,
+	1231,
+	1298,
+	1232,
+	1299,
+	1233,
+	1299,
+	1232,
+	1299,
+	1233,
+	1300,
+	1234,
+	1300,
+	1233,
+	1300,
+	1234,
+	1301,
+	1235,
+	1301,
+	1234,
+	1301,
+	1235,
+	1302,
+	1236,
+	1302,
+	1235,
+	1302,
+	1236,
+	1303,
+	1237,
+	1303,
+	1236,
+	1303,
+	1237,
+	1304,
+	1238,
+	1304,
+	1237,
+	1304,
+	1238,
+	1305,
+	1239,
+	1305,
+	1238,
+	1305,
+	1239,
+	1306,
+	1240,
+	1306,
+	1239,
+	1306,
+	1240,
+	1307,
+	1241,
+	1307,
+	1240,
+	1307,
+	1241,
+	1308,
+	1242,
+	1308,
+	1241,
+	1308,
+	1242,
+	1309,
+	1243,
+	1309,
+	1242,
+	1309,
+	1243,
+	1310,
+	1244,
+	1310,
+	1243,
+	1310,
+	1244,
+	1311,
+	1245,
+	1311,
+	1244,
+	1311,
+	1245,
+	1312,
+	1246,
+	1312,
+	1245,
+	1312,
+	1246,
+	1313,
+	1247,
+	1313,
+	1246,
+	1313,
+	1247,
+	1314,
+	1248,
+	1314,
+	1247,
+	1314,
+	1248,
+	1315,
+	1249,
+	1315,
+	1248,
+	1315,
+	1249,
+	1316,
+	1250,
+	1316,
+	1249,
+	1316,
+	1250,
+	1317,
+	1251,
+	1317,
+	1250,
+	1317,
+	1251,
+	1318,
+	1252,
+	1318,
+	1251,
+	1318,
+	1252,
+	1319,
+	1253,
+	1319,
+	1252,
+	1320,
+	1254,
+	1321,
+	1255,
+	1321,
+	1254,
+	1321,
+	1255,
+	1322,
+	1256,
+	1322,
+	1255,
+	1322,
+	1256,
+	1323,
+	1257,
+	1323,
+	1256,
+	1323,
+	1257,
+	1324,
+	1258,
+	1324,
+	1257,
+	1324,
+	1258,
+	1325,
+	1259,
+	1325,
+	1258,
+	1325,
+	1259,
+	1326,
+	1260,
+	1326,
+	1259,
+	1326,
+	1260,
+	1327,
+	1261,
+	1327,
+	1260,
+	1327,
+	1261,
+	1328,
+	1262,
+	1328,
+	1261,
+	1328,
+	1262,
+	1329,
+	1263,
+	1329,
+	1262,
+	1329,
+	1263,
+	1330,
+	1264,
+	1330,
+	1263,
+	1330,
+	1264,
+	1331,
+	1265,
+	1331,
+	1264,
+	1331,
+	1265,
+	1332,
+	1266,
+	1332,
+	1265,
+	1332,
+	1266,
+	1333,
+	1267,
+	1333,
+	1266,
+	1333,
+	1267,
+	1334,
+	1268,
+	1334,
+	1267,
+	1334,
+	1268,
+	1335,
+	1269,
+	1335,
+	1268,
+	1335,
+	1269,
+	1336,
+	1270,
+	1336,
+	1269,
+	1336,
+	1270,
+	1337,
+	1271,
+	1337,
+	1270,
+	1337,
+	1271,
+	1338,
+	1272,
+	1338,
+	1271,
+	1338,
+	1272,
+	1339,
+	1273,
+	1339,
+	1272,
+	1339,
+	1273,
+	1340,
+	1274,
+	1340,
+	1273,
+	1340,
+	1274,
+	1341,
+	1275,
+	1341,
+	1274,
+	1341,
+	1275,
+	1342,
+	1276,
+	1342,
+	1275,
+	1342,
+	1276,
+	1343,
+	1277,
+	1343,
+	1276,
+	1343,
+	1277,
+	1344,
+	1278,
+	1344,
+	1277,
+	1344,
+	1278,
+	1345,
+	1279,
+	1345,
+	1278,
+	1345,
+	1279,
+	1346,
+	1280,
+	1346,
+	1279,
+	1346,
+	1280,
+	1347,
+	1281,
+	1347,
+	1280,
+	1347,
+	1281,
+	1348,
+	1282,
+	1348,
+	1281,
+	1348,
+	1282,
+	1349,
+	1283,
+	1349,
+	1282,
+	1349,
+	1283,
+	1350,
+	1284,
+	1350,
+	1283,
+	1350,
+	1284,
+	1351,
+	1285,
+	1351,
+	1284,
+	1351,
+	1285,
+	1352,
+	1286,
+	1352,
+	1285,
+	1352,
+	1286,
+	1353,
+	1287,
+	1353,
+	1286,
+	1353,
+	1287,
+	1354,
+	1288,
+	1354,
+	1287,
+	1354,
+	1288,
+	1355,
+	1289,
+	1355,
+	1288,
+	1355,
+	1289,
+	1356,
+	1290,
+	1356,
+	1289,
+	1356,
+	1290,
+	1357,
+	1291,
+	1357,
+	1290,
+	1357,
+	1291,
+	1358,
+	1292,
+	1358,
+	1291,
+	1358,
+	1292,
+	1359,
+	1293,
+	1359,
+	1292,
+	1359,
+	1293,
+	1360,
+	1294,
+	1360,
+	1293,
+	1360,
+	1294,
+	1361,
+	1295,
+	1361,
+	1294,
+	1361,
+	1295,
+	1362,
+	1296,
+	1362,
+	1295,
+	1362,
+	1296,
+	1363,
+	1297,
+	1363,
+	1296,
+	1363,
+	1297,
+	1364,
+	1298,
+	1364,
+	1297,
+	1364,
+	1298,
+	1365,
+	1299,
+	1365,
+	1298,
+	1365,
+	1299,
+	1366,
+	1300,
+	1366,
+	1299,
+	1366,
+	1300,
+	1367,
+	1301,
+	1367,
+	1300,
+	1367,
+	1301,
+	1368,
+	1302,
+	1368,
+	1301,
+	1368,
+	1302,
+	1369,
+	1303,
+	1369,
+	1302,
+	1369,
+	1303,
+	1370,
+	1304,
+	1370,
+	1303,
+	1370,
+	1304,
+	1371,
+	1305,
+	1371,
+	1304,
+	1371,
+	1305,
+	1372,
+	1306,
+	1372,
+	1305,
+	1372,
+	1306,
+	1373,
+	1307,
+	1373,
+	1306,
+	1373,
+	1307,
+	1374,
+	1308,
+	1374,
+	1307,
+	1374,
+	1308,
+	1375,
+	1309,
+	1375,
+	1308,
+	1375,
+	1309,
+	1376,
+	1310,
+	1376,
+	1309,
+	1376,
+	1310,
+	1377,
+	1311,
+	1377,
+	1310,
+	1377,
+	1311,
+	1378,
+	1312,
+	1378,
+	1311,
+	1378,
+	1312,
+	1379,
+	1313,
+	1379,
+	1312,
+	1379,
+	1313,
+	1380,
+	1314,
+	1380,
+	1313,
+	1380,
+	1314,
+	1381,
+	1315,
+	1381,
+	1314,
+	1381,
+	1315,
+	1382,
+	1316,
+	1382,
+	1315,
+	1382,
+	1316,
+	1383,
+	1317,
+	1383,
+	1316,
+	1383,
+	1317,
+	1384,
+	1318,
+	1384,
+	1317,
+	1384,
+	1318,
+	1385,
+	1319,
+	1385,
+	1318,
+	1386,
+	1320,
+	1387,
+	1321,
+	1387,
+	1320,
+	1387,
+	1321,
+	1388,
+	1322,
+	1388,
+	1321,
+	1388,
+	1322,
+	1389,
+	1323,
+	1389,
+	1322,
+	1389,
+	1323,
+	1390,
+	1324,
+	1390,
+	1323,
+	1390,
+	1324,
+	1391,
+	1325,
+	1391,
+	1324,
+	1391,
+	1325,
+	1392,
+	1326,
+	1392,
+	1325,
+	1392,
+	1326,
+	1393,
+	1327,
+	1393,
+	1326,
+	1393,
+	1327,
+	1394,
+	1328,
+	1394,
+	1327,
+	1394,
+	1328,
+	1395,
+	1329,
+	1395,
+	1328,
+	1395,
+	1329,
+	1396,
+	1330,
+	1396,
+	1329,
+	1396,
+	1330,
+	1397,
+	1331,
+	1397,
+	1330,
+	1397,
+	1331,
+	1398,
+	1332,
+	1398,
+	1331,
+	1398,
+	1332,
+	1399,
+	1333,
+	1399,
+	1332,
+	1399,
+	1333,
+	1400,
+	1334,
+	1400,
+	1333,
+	1400,
+	1334,
+	1401,
+	1335,
+	1401,
+	1334,
+	1401,
+	1335,
+	1402,
+	1336,
+	1402,
+	1335,
+	1402,
+	1336,
+	1403,
+	1337,
+	1403,
+	1336,
+	1403,
+	1337,
+	1404,
+	1338,
+	1404,
+	1337,
+	1404,
+	1338,
+	1405,
+	1339,
+	1405,
+	1338,
+	1405,
+	1339,
+	1406,
+	1340,
+	1406,
+	1339,
+	1406,
+	1340,
+	1407,
+	1341,
+	1407,
+	1340,
+	1407,
+	1341,
+	1408,
+	1342,
+	1408,
+	1341,
+	1408,
+	1342,
+	1409,
+	1343,
+	1409,
+	1342,
+	1409,
+	1343,
+	1410,
+	1344,
+	1410,
+	1343,
+	1410,
+	1344,
+	1411,
+	1345,
+	1411,
+	1344,
+	1411,
+	1345,
+	1412,
+	1346,
+	1412,
+	1345,
+	1412,
+	1346,
+	1413,
+	1347,
+	1413,
+	1346,
+	1413,
+	1347,
+	1414,
+	1348,
+	1414,
+	1347,
+	1414,
+	1348,
+	1415,
+	1349,
+	1415,
+	1348,
+	1415,
+	1349,
+	1416,
+	1350,
+	1416,
+	1349,
+	1416,
+	1350,
+	1417,
+	1351,
+	1417,
+	1350,
+	1417,
+	1351,
+	1418,
+	1352,
+	1418,
+	1351,
+	1418,
+	1352,
+	1419,
+	1353,
+	1419,
+	1352,
+	1419,
+	1353,
+	1420,
+	1354,
+	1420,
+	1353,
+	1420,
+	1354,
+	1421,
+	1355,
+	1421,
+	1354,
+	1421,
+	1355,
+	1422,
+	1356,
+	1422,
+	1355,
+	1422,
+	1356,
+	1423,
+	1357,
+	1423,
+	1356,
+	1423,
+	1357,
+	1424,
+	1358,
+	1424,
+	1357,
+	1424,
+	1358,
+	1425,
+	1359,
+	1425,
+	1358,
+	1425,
+	1359,
+	1426,
+	1360,
+	1426,
+	1359,
+	1426,
+	1360,
+	1427,
+	1361,
+	1427,
+	1360,
+	1427,
+	1361,
+	1428,
+	1362,
+	1428,
+	1361,
+	1428,
+	1362,
+	1429,
+	1363,
+	1429,
+	1362,
+	1429,
+	1363,
+	1430,
+	1364,
+	1430,
+	1363,
+	1430,
+	1364,
+	1431,
+	1365,
+	1431,
+	1364,
+	1431,
+	1365,
+	1432,
+	1366,
+	1432,
+	1365,
+	1432,
+	1366,
+	1433,
+	1367,
+	1433,
+	1366,
+	1433,
+	1367,
+	1434,
+	1368,
+	1434,
+	1367,
+	1434,
+	1368,
+	1435,
+	1369,
+	1435,
+	1368,
+	1435,
+	1369,
+	1436,
+	1370,
+	1436,
+	1369,
+	1436,
+	1370,
+	1437,
+	1371,
+	1437,
+	1370,
+	1437,
+	1371,
+	1438,
+	1372,
+	1438,
+	1371,
+	1438,
+	1372,
+	1439,
+	1373,
+	1439,
+	1372,
+	1439,
+	1373,
+	1440,
+	1374,
+	1440,
+	1373,
+	1440,
+	1374,
+	1441,
+	1375,
+	1441,
+	1374,
+	1441,
+	1375,
+	1442,
+	1376,
+	1442,
+	1375,
+	1442,
+	1376,
+	1443,
+	1377,
+	1443,
+	1376,
+	1443,
+	1377,
+	1444,
+	1378,
+	1444,
+	1377,
+	1444,
+	1378,
+	1445,
+	1379,
+	1445,
+	1378,
+	1445,
+	1379,
+	1446,
+	1380,
+	1446,
+	1379,
+	1446,
+	1380,
+	1447,
+	1381,
+	1447,
+	1380,
+	1447,
+	1381,
+	1448,
+	1382,
+	1448,
+	1381,
+	1448,
+	1382,
+	1449,
+	1383,
+	1449,
+	1382,
+	1449,
+	1383,
+	1450,
+	1384,
+	1450,
+	1383,
+	1450,
+	1384,
+	1451,
+	1385,
+	1451,
+	1384,
+	1452,
+	1386,
+	1453,
+	1387,
+	1453,
+	1386,
+	1453,
+	1387,
+	1454,
+	1388,
+	1454,
+	1387,
+	1454,
+	1388,
+	1455,
+	1389,
+	1455,
+	1388,
+	1455,
+	1389,
+	1456,
+	1390,
+	1456,
+	1389,
+	1456,
+	1390,
+	1457,
+	1391,
+	1457,
+	1390,
+	1457,
+	1391,
+	1458,
+	1392,
+	1458,
+	1391,
+	1458,
+	1392,
+	1459,
+	1393,
+	1459,
+	1392,
+	1459,
+	1393,
+	1460,
+	1394,
+	1460,
+	1393,
+	1460,
+	1394,
+	1461,
+	1395,
+	1461,
+	1394,
+	1461,
+	1395,
+	1462,
+	1396,
+	1462,
+	1395,
+	1462,
+	1396,
+	1463,
+	1397,
+	1463,
+	1396,
+	1463,
+	1397,
+	1464,
+	1398,
+	1464,
+	1397,
+	1464,
+	1398,
+	1465,
+	1399,
+	1465,
+	1398,
+	1465,
+	1399,
+	1466,
+	1400,
+	1466,
+	1399,
+	1466,
+	1400,
+	1467,
+	1401,
+	1467,
+	1400,
+	1467,
+	1401,
+	1468,
+	1402,
+	1468,
+	1401,
+	1468,
+	1402,
+	1469,
+	1403,
+	1469,
+	1402,
+	1469,
+	1403,
+	1470,
+	1404,
+	1470,
+	1403,
+	1470,
+	1404,
+	1471,
+	1405,
+	1471,
+	1404,
+	1471,
+	1405,
+	1472,
+	1406,
+	1472,
+	1405,
+	1472,
+	1406,
+	1473,
+	1407,
+	1473,
+	1406,
+	1473,
+	1407,
+	1474,
+	1408,
+	1474,
+	1407,
+	1474,
+	1408,
+	1475,
+	1409,
+	1475,
+	1408,
+	1475,
+	1409,
+	1476,
+	1410,
+	1476,
+	1409,
+	1476,
+	1410,
+	1477,
+	1411,
+	1477,
+	1410,
+	1477,
+	1411,
+	1478,
+	1412,
+	1478,
+	1411,
+	1478,
+	1412,
+	1479,
+	1413,
+	1479,
+	1412,
+	1479,
+	1413,
+	1480,
+	1414,
+	1480,
+	1413,
+	1480,
+	1414,
+	1481,
+	1415,
+	1481,
+	1414,
+	1481,
+	1415,
+	1482,
+	1416,
+	1482,
+	1415,
+	1482,
+	1416,
+	1483,
+	1417,
+	1483,
+	1416,
+	1483,
+	1417,
+	1484,
+	1418,
+	1484,
+	1417,
+	1484,
+	1418,
+	1485,
+	1419,
+	1485,
+	1418,
+	1485,
+	1419,
+	1486,
+	1420,
+	1486,
+	1419,
+	1486,
+	1420,
+	1487,
+	1421,
+	1487,
+	1420,
+	1487,
+	1421,
+	1488,
+	1422,
+	1488,
+	1421,
+	1488,
+	1422,
+	1489,
+	1423,
+	1489,
+	1422,
+	1489,
+	1423,
+	1490,
+	1424,
+	1490,
+	1423,
+	1490,
+	1424,
+	1491,
+	1425,
+	1491,
+	1424,
+	1491,
+	1425,
+	1492,
+	1426,
+	1492,
+	1425,
+	1492,
+	1426,
+	1493,
+	1427,
+	1493,
+	1426,
+	1493,
+	1427,
+	1494,
+	1428,
+	1494,
+	1427,
+	1494,
+	1428,
+	1495,
+	1429,
+	1495,
+	1428,
+	1495,
+	1429,
+	1496,
+	1430,
+	1496,
+	1429,
+	1496,
+	1430,
+	1497,
+	1431,
+	1497,
+	1430,
+	1497,
+	1431,
+	1498,
+	1432,
+	1498,
+	1431,
+	1498,
+	1432,
+	1499,
+	1433,
+	1499,
+	1432,
+	1499,
+	1433,
+	1500,
+	1434,
+	1500,
+	1433,
+	1500,
+	1434,
+	1501,
+	1435,
+	1501,
+	1434,
+	1501,
+	1435,
+	1502,
+	1436,
+	1502,
+	1435,
+	1502,
+	1436,
+	1503,
+	1437,
+	1503,
+	1436,
+	1503,
+	1437,
+	1504,
+	1438,
+	1504,
+	1437,
+	1504,
+	1438,
+	1505,
+	1439,
+	1505,
+	1438,
+	1505,
+	1439,
+	1506,
+	1440,
+	1506,
+	1439,
+	1506,
+	1440,
+	1507,
+	1441,
+	1507,
+	1440,
+	1507,
+	1441,
+	1508,
+	1442,
+	1508,
+	1441,
+	1508,
+	1442,
+	1509,
+	1443,
+	1509,
+	1442,
+	1509,
+	1443,
+	1510,
+	1444,
+	1510,
+	1443,
+	1510,
+	1444,
+	1511,
+	1445,
+	1511,
+	1444,
+	1511,
+	1445,
+	1512,
+	1446,
+	1512,
+	1445,
+	1512,
+	1446,
+	1513,
+	1447,
+	1513,
+	1446,
+	1513,
+	1447,
+	1514,
+	1448,
+	1514,
+	1447,
+	1514,
+	1448,
+	1515,
+	1449,
+	1515,
+	1448,
+	1515,
+	1449,
+	1516,
+	1450,
+	1516,
+	1449,
+	1516,
+	1450,
+	1517,
+	1451,
+	1517,
+	1450,
+	1518,
+	1452,
+	1519,
+	1453,
+	1519,
+	1452,
+	1519,
+	1453,
+	1520,
+	1454,
+	1520,
+	1453,
+	1520,
+	1454,
+	1521,
+	1455,
+	1521,
+	1454,
+	1521,
+	1455,
+	1522,
+	1456,
+	1522,
+	1455,
+	1522,
+	1456,
+	1523,
+	1457,
+	1523,
+	1456,
+	1523,
+	1457,
+	1524,
+	1458,
+	1524,
+	1457,
+	1524,
+	1458,
+	1525,
+	1459,
+	1525,
+	1458,
+	1525,
+	1459,
+	1526,
+	1460,
+	1526,
+	1459,
+	1526,
+	1460,
+	1527,
+	1461,
+	1527,
+	1460,
+	1527,
+	1461,
+	1528,
+	1462,
+	1528,
+	1461,
+	1528,
+	1462,
+	1529,
+	1463,
+	1529,
+	1462,
+	1529,
+	1463,
+	1530,
+	1464,
+	1530,
+	1463,
+	1530,
+	1464,
+	1531,
+	1465,
+	1531,
+	1464,
+	1531,
+	1465,
+	1532,
+	1466,
+	1532,
+	1465,
+	1532,
+	1466,
+	1533,
+	1467,
+	1533,
+	1466,
+	1533,
+	1467,
+	1534,
+	1468,
+	1534,
+	1467,
+	1534,
+	1468,
+	1535,
+	1469,
+	1535,
+	1468,
+	1535,
+	1469,
+	1536,
+	1470,
+	1536,
+	1469,
+	1536,
+	1470,
+	1537,
+	1471,
+	1537,
+	1470,
+	1537,
+	1471,
+	1538,
+	1472,
+	1538,
+	1471,
+	1538,
+	1472,
+	1539,
+	1473,
+	1539,
+	1472,
+	1539,
+	1473,
+	1540,
+	1474,
+	1540,
+	1473,
+	1540,
+	1474,
+	1541,
+	1475,
+	1541,
+	1474,
+	1541,
+	1475,
+	1542,
+	1476,
+	1542,
+	1475,
+	1542,
+	1476,
+	1543,
+	1477,
+	1543,
+	1476,
+	1543,
+	1477,
+	1544,
+	1478,
+	1544,
+	1477,
+	1544,
+	1478,
+	1545,
+	1479,
+	1545,
+	1478,
+	1545,
+	1479,
+	1546,
+	1480,
+	1546,
+	1479,
+	1546,
+	1480,
+	1547,
+	1481,
+	1547,
+	1480,
+	1547,
+	1481,
+	1548,
+	1482,
+	1548,
+	1481,
+	1548,
+	1482,
+	1549,
+	1483,
+	1549,
+	1482,
+	1549,
+	1483,
+	1550,
+	1484,
+	1550,
+	1483,
+	1550,
+	1484,
+	1551,
+	1485,
+	1551,
+	1484,
+	1551,
+	1485,
+	1552,
+	1486,
+	1552,
+	1485,
+	1552,
+	1486,
+	1553,
+	1487,
+	1553,
+	1486,
+	1553,
+	1487,
+	1554,
+	1488,
+	1554,
+	1487,
+	1554,
+	1488,
+	1555,
+	1489,
+	1555,
+	1488,
+	1555,
+	1489,
+	1556,
+	1490,
+	1556,
+	1489,
+	1556,
+	1490,
+	1557,
+	1491,
+	1557,
+	1490,
+	1557,
+	1491,
+	1558,
+	1492,
+	1558,
+	1491,
+	1558,
+	1492,
+	1559,
+	1493,
+	1559,
+	1492,
+	1559,
+	1493,
+	1560,
+	1494,
+	1560,
+	1493,
+	1560,
+	1494,
+	1561,
+	1495,
+	1561,
+	1494,
+	1561,
+	1495,
+	1562,
+	1496,
+	1562,
+	1495,
+	1562,
+	1496,
+	1563,
+	1497,
+	1563,
+	1496,
+	1563,
+	1497,
+	1564,
+	1498,
+	1564,
+	1497,
+	1564,
+	1498,
+	1565,
+	1499,
+	1565,
+	1498,
+	1565,
+	1499,
+	1566,
+	1500,
+	1566,
+	1499,
+	1566,
+	1500,
+	1567,
+	1501,
+	1567,
+	1500,
+	1567,
+	1501,
+	1568,
+	1502,
+	1568,
+	1501,
+	1568,
+	1502,
+	1569,
+	1503,
+	1569,
+	1502,
+	1569,
+	1503,
+	1570,
+	1504,
+	1570,
+	1503,
+	1570,
+	1504,
+	1571,
+	1505,
+	1571,
+	1504,
+	1571,
+	1505,
+	1572,
+	1506,
+	1572,
+	1505,
+	1572,
+	1506,
+	1573,
+	1507,
+	1573,
+	1506,
+	1573,
+	1507,
+	1574,
+	1508,
+	1574,
+	1507,
+	1574,
+	1508,
+	1575,
+	1509,
+	1575,
+	1508,
+	1575,
+	1509,
+	1576,
+	1510,
+	1576,
+	1509,
+	1576,
+	1510,
+	1577,
+	1511,
+	1577,
+	1510,
+	1577,
+	1511,
+	1578,
+	1512,
+	1578,
+	1511,
+	1578,
+	1512,
+	1579,
+	1513,
+	1579,
+	1512,
+	1579,
+	1513,
+	1580,
+	1514,
+	1580,
+	1513,
+	1580,
+	1514,
+	1581,
+	1515,
+	1581,
+	1514,
+	1581,
+	1515,
+	1582,
+	1516,
+	1582,
+	1515,
+	1582,
+	1516,
+	1583,
+	1517,
+	1583,
+	1516,
+	1584,
+	1518,
+	1585,
+	1519,
+	1585,
+	1518,
+	1585,
+	1519,
+	1586,
+	1520,
+	1586,
+	1519,
+	1586,
+	1520,
+	1587,
+	1521,
+	1587,
+	1520,
+	1587,
+	1521,
+	1588,
+	1522,
+	1588,
+	1521,
+	1588,
+	1522,
+	1589,
+	1523,
+	1589,
+	1522,
+	1589,
+	1523,
+	1590,
+	1524,
+	1590,
+	1523,
+	1590,
+	1524,
+	1591,
+	1525,
+	1591,
+	1524,
+	1591,
+	1525,
+	1592,
+	1526,
+	1592,
+	1525,
+	1592,
+	1526,
+	1593,
+	1527,
+	1593,
+	1526,
+	1593,
+	1527,
+	1594,
+	1528,
+	1594,
+	1527,
+	1594,
+	1528,
+	1595,
+	1529,
+	1595,
+	1528,
+	1595,
+	1529,
+	1596,
+	1530,
+	1596,
+	1529,
+	1596,
+	1530,
+	1597,
+	1531,
+	1597,
+	1530,
+	1597,
+	1531,
+	1598,
+	1532,
+	1598,
+	1531,
+	1598,
+	1532,
+	1599,
+	1533,
+	1599,
+	1532,
+	1599,
+	1533,
+	1600,
+	1534,
+	1600,
+	1533,
+	1600,
+	1534,
+	1601,
+	1535,
+	1601,
+	1534,
+	1601,
+	1535,
+	1602,
+	1536,
+	1602,
+	1535,
+	1602,
+	1536,
+	1603,
+	1537,
+	1603,
+	1536,
+	1603,
+	1537,
+	1604,
+	1538,
+	1604,
+	1537,
+	1604,
+	1538,
+	1605,
+	1539,
+	1605,
+	1538,
+	1605,
+	1539,
+	1606,
+	1540,
+	1606,
+	1539,
+	1606,
+	1540,
+	1607,
+	1541,
+	1607,
+	1540,
+	1607,
+	1541,
+	1608,
+	1542,
+	1608,
+	1541,
+	1608,
+	1542,
+	1609,
+	1543,
+	1609,
+	1542,
+	1609,
+	1543,
+	1610,
+	1544,
+	1610,
+	1543,
+	1610,
+	1544,
+	1611,
+	1545,
+	1611,
+	1544,
+	1611,
+	1545,
+	1612,
+	1546,
+	1612,
+	1545,
+	1612,
+	1546,
+	1613,
+	1547,
+	1613,
+	1546,
+	1613,
+	1547,
+	1614,
+	1548,
+	1614,
+	1547,
+	1614,
+	1548,
+	1615,
+	1549,
+	1615,
+	1548,
+	1615,
+	1549,
+	1616,
+	1550,
+	1616,
+	1549,
+	1616,
+	1550,
+	1617,
+	1551,
+	1617,
+	1550,
+	1617,
+	1551,
+	1618,
+	1552,
+	1618,
+	1551,
+	1618,
+	1552,
+	1619,
+	1553,
+	1619,
+	1552,
+	1619,
+	1553,
+	1620,
+	1554,
+	1620,
+	1553,
+	1620,
+	1554,
+	1621,
+	1555,
+	1621,
+	1554,
+	1621,
+	1555,
+	1622,
+	1556,
+	1622,
+	1555,
+	1622,
+	1556,
+	1623,
+	1557,
+	1623,
+	1556,
+	1623,
+	1557,
+	1624,
+	1558,
+	1624,
+	1557,
+	1624,
+	1558,
+	1625,
+	1559,
+	1625,
+	1558,
+	1625,
+	1559,
+	1626,
+	1560,
+	1626,
+	1559,
+	1626,
+	1560,
+	1627,
+	1561,
+	1627,
+	1560,
+	1627,
+	1561,
+	1628,
+	1562,
+	1628,
+	1561,
+	1628,
+	1562,
+	1629,
+	1563,
+	1629,
+	1562,
+	1629,
+	1563,
+	1630,
+	1564,
+	1630,
+	1563,
+	1630,
+	1564,
+	1631,
+	1565,
+	1631,
+	1564,
+	1631,
+	1565,
+	1632,
+	1566,
+	1632,
+	1565,
+	1632,
+	1566,
+	1633,
+	1567,
+	1633,
+	1566,
+	1633,
+	1567,
+	1634,
+	1568,
+	1634,
+	1567,
+	1634,
+	1568,
+	1635,
+	1569,
+	1635,
+	1568,
+	1635,
+	1569,
+	1636,
+	1570,
+	1636,
+	1569,
+	1636,
+	1570,
+	1637,
+	1571,
+	1637,
+	1570,
+	1637,
+	1571,
+	1638,
+	1572,
+	1638,
+	1571,
+	1638,
+	1572,
+	1639,
+	1573,
+	1639,
+	1572,
+	1639,
+	1573,
+	1640,
+	1574,
+	1640,
+	1573,
+	1640,
+	1574,
+	1641,
+	1575,
+	1641,
+	1574,
+	1641,
+	1575,
+	1642,
+	1576,
+	1642,
+	1575,
+	1642,
+	1576,
+	1643,
+	1577,
+	1643,
+	1576,
+	1643,
+	1577,
+	1644,
+	1578,
+	1644,
+	1577,
+	1644,
+	1578,
+	1645,
+	1579,
+	1645,
+	1578,
+	1645,
+	1579,
+	1646,
+	1580,
+	1646,
+	1579,
+	1646,
+	1580,
+	1647,
+	1581,
+	1647,
+	1580,
+	1647,
+	1581,
+	1648,
+	1582,
+	1648,
+	1581,
+	1648,
+	1582,
+	1649,
+	1583,
+	1649,
+	1582,
+	1650,
+	1584,
+	1651,
+	1585,
+	1651,
+	1584,
+	1651,
+	1585,
+	1652,
+	1586,
+	1652,
+	1585,
+	1652,
+	1586,
+	1653,
+	1587,
+	1653,
+	1586,
+	1653,
+	1587,
+	1654,
+	1588,
+	1654,
+	1587,
+	1654,
+	1588,
+	1655,
+	1589,
+	1655,
+	1588,
+	1655,
+	1589,
+	1656,
+	1590,
+	1656,
+	1589,
+	1656,
+	1590,
+	1657,
+	1591,
+	1657,
+	1590,
+	1657,
+	1591,
+	1658,
+	1592,
+	1658,
+	1591,
+	1658,
+	1592,
+	1659,
+	1593,
+	1659,
+	1592,
+	1659,
+	1593,
+	1660,
+	1594,
+	1660,
+	1593,
+	1660,
+	1594,
+	1661,
+	1595,
+	1661,
+	1594,
+	1661,
+	1595,
+	1662,
+	1596,
+	1662,
+	1595,
+	1662,
+	1596,
+	1663,
+	1597,
+	1663,
+	1596,
+	1663,
+	1597,
+	1664,
+	1598,
+	1664,
+	1597,
+	1664,
+	1598,
+	1665,
+	1599,
+	1665,
+	1598,
+	1665,
+	1599,
+	1666,
+	1600,
+	1666,
+	1599,
+	1666,
+	1600,
+	1667,
+	1601,
+	1667,
+	1600,
+	1667,
+	1601,
+	1668,
+	1602,
+	1668,
+	1601,
+	1668,
+	1602,
+	1669,
+	1603,
+	1669,
+	1602,
+	1669,
+	1603,
+	1670,
+	1604,
+	1670,
+	1603,
+	1670,
+	1604,
+	1671,
+	1605,
+	1671,
+	1604,
+	1671,
+	1605,
+	1672,
+	1606,
+	1672,
+	1605,
+	1672,
+	1606,
+	1673,
+	1607,
+	1673,
+	1606,
+	1673,
+	1607,
+	1674,
+	1608,
+	1674,
+	1607,
+	1674,
+	1608,
+	1675,
+	1609,
+	1675,
+	1608,
+	1675,
+	1609,
+	1676,
+	1610,
+	1676,
+	1609,
+	1676,
+	1610,
+	1677,
+	1611,
+	1677,
+	1610,
+	1677,
+	1611,
+	1678,
+	1612,
+	1678,
+	1611,
+	1678,
+	1612,
+	1679,
+	1613,
+	1679,
+	1612,
+	1679,
+	1613,
+	1680,
+	1614,
+	1680,
+	1613,
+	1680,
+	1614,
+	1681,
+	1615,
+	1681,
+	1614,
+	1681,
+	1615,
+	1682,
+	1616,
+	1682,
+	1615,
+	1682,
+	1616,
+	1683,
+	1617,
+	1683,
+	1616,
+	1683,
+	1617,
+	1684,
+	1618,
+	1684,
+	1617,
+	1684,
+	1618,
+	1685,
+	1619,
+	1685,
+	1618,
+	1685,
+	1619,
+	1686,
+	1620,
+	1686,
+	1619,
+	1686,
+	1620,
+	1687,
+	1621,
+	1687,
+	1620,
+	1687,
+	1621,
+	1688,
+	1622,
+	1688,
+	1621,
+	1688,
+	1622,
+	1689,
+	1623,
+	1689,
+	1622,
+	1689,
+	1623,
+	1690,
+	1624,
+	1690,
+	1623,
+	1690,
+	1624,
+	1691,
+	1625,
+	1691,
+	1624,
+	1691,
+	1625,
+	1692,
+	1626,
+	1692,
+	1625,
+	1692,
+	1626,
+	1693,
+	1627,
+	1693,
+	1626,
+	1693,
+	1627,
+	1694,
+	1628,
+	1694,
+	1627,
+	1694,
+	1628,
+	1695,
+	1629,
+	1695,
+	1628,
+	1695,
+	1629,
+	1696,
+	1630,
+	1696,
+	1629,
+	1696,
+	1630,
+	1697,
+	1631,
+	1697,
+	1630,
+	1697,
+	1631,
+	1698,
+	1632,
+	1698,
+	1631,
+	1698,
+	1632,
+	1699,
+	1633,
+	1699,
+	1632,
+	1699,
+	1633,
+	1700,
+	1634,
+	1700,
+	1633,
+	1700,
+	1634,
+	1701,
+	1635,
+	1701,
+	1634,
+	1701,
+	1635,
+	1702,
+	1636,
+	1702,
+	1635,
+	1702,
+	1636,
+	1703,
+	1637,
+	1703,
+	1636,
+	1703,
+	1637,
+	1704,
+	1638,
+	1704,
+	1637,
+	1704,
+	1638,
+	1705,
+	1639,
+	1705,
+	1638,
+	1705,
+	1639,
+	1706,
+	1640,
+	1706,
+	1639,
+	1706,
+	1640,
+	1707,
+	1641,
+	1707,
+	1640,
+	1707,
+	1641,
+	1708,
+	1642,
+	1708,
+	1641,
+	1708,
+	1642,
+	1709,
+	1643,
+	1709,
+	1642,
+	1709,
+	1643,
+	1710,
+	1644,
+	1710,
+	1643,
+	1710,
+	1644,
+	1711,
+	1645,
+	1711,
+	1644,
+	1711,
+	1645,
+	1712,
+	1646,
+	1712,
+	1645,
+	1712,
+	1646,
+	1713,
+	1647,
+	1713,
+	1646,
+	1713,
+	1647,
+	1714,
+	1648,
+	1714,
+	1647,
+	1714,
+	1648,
+	1715,
+	1649,
+	1715,
+	1648,
+	1716,
+	1650,
+	1717,
+	1651,
+	1717,
+	1650,
+	1717,
+	1651,
+	1718,
+	1652,
+	1718,
+	1651,
+	1718,
+	1652,
+	1719,
+	1653,
+	1719,
+	1652,
+	1719,
+	1653,
+	1720,
+	1654,
+	1720,
+	1653,
+	1720,
+	1654,
+	1721,
+	1655,
+	1721,
+	1654,
+	1721,
+	1655,
+	1722,
+	1656,
+	1722,
+	1655,
+	1722,
+	1656,
+	1723,
+	1657,
+	1723,
+	1656,
+	1723,
+	1657,
+	1724,
+	1658,
+	1724,
+	1657,
+	1724,
+	1658,
+	1725,
+	1659,
+	1725,
+	1658,
+	1725,
+	1659,
+	1726,
+	1660,
+	1726,
+	1659,
+	1726,
+	1660,
+	1727,
+	1661,
+	1727,
+	1660,
+	1727,
+	1661,
+	1728,
+	1662,
+	1728,
+	1661,
+	1728,
+	1662,
+	1729,
+	1663,
+	1729,
+	1662,
+	1729,
+	1663,
+	1730,
+	1664,
+	1730,
+	1663,
+	1730,
+	1664,
+	1731,
+	1665,
+	1731,
+	1664,
+	1731,
+	1665,
+	1732,
+	1666,
+	1732,
+	1665,
+	1732,
+	1666,
+	1733,
+	1667,
+	1733,
+	1666,
+	1733,
+	1667,
+	1734,
+	1668,
+	1734,
+	1667,
+	1734,
+	1668,
+	1735,
+	1669,
+	1735,
+	1668,
+	1735,
+	1669,
+	1736,
+	1670,
+	1736,
+	1669,
+	1736,
+	1670,
+	1737,
+	1671,
+	1737,
+	1670,
+	1737,
+	1671,
+	1738,
+	1672,
+	1738,
+	1671,
+	1738,
+	1672,
+	1739,
+	1673,
+	1739,
+	1672,
+	1739,
+	1673,
+	1740,
+	1674,
+	1740,
+	1673,
+	1740,
+	1674,
+	1741,
+	1675,
+	1741,
+	1674,
+	1741,
+	1675,
+	1742,
+	1676,
+	1742,
+	1675,
+	1742,
+	1676,
+	1743,
+	1677,
+	1743,
+	1676,
+	1743,
+	1677,
+	1744,
+	1678,
+	1744,
+	1677,
+	1744,
+	1678,
+	1745,
+	1679,
+	1745,
+	1678,
+	1745,
+	1679,
+	1746,
+	1680,
+	1746,
+	1679,
+	1746,
+	1680,
+	1747,
+	1681,
+	1747,
+	1680,
+	1747,
+	1681,
+	1748,
+	1682,
+	1748,
+	1681,
+	1748,
+	1682,
+	1749,
+	1683,
+	1749,
+	1682,
+	1749,
+	1683,
+	1750,
+	1684,
+	1750,
+	1683,
+	1750,
+	1684,
+	1751,
+	1685,
+	1751,
+	1684,
+	1751,
+	1685,
+	1752,
+	1686,
+	1752,
+	1685,
+	1752,
+	1686,
+	1753,
+	1687,
+	1753,
+	1686,
+	1753,
+	1687,
+	1754,
+	1688,
+	1754,
+	1687,
+	1754,
+	1688,
+	1755,
+	1689,
+	1755,
+	1688,
+	1755,
+	1689,
+	1756,
+	1690,
+	1756,
+	1689,
+	1756,
+	1690,
+	1757,
+	1691,
+	1757,
+	1690,
+	1757,
+	1691,
+	1758,
+	1692,
+	1758,
+	1691,
+	1758,
+	1692,
+	1759,
+	1693,
+	1759,
+	1692,
+	1759,
+	1693,
+	1760,
+	1694,
+	1760,
+	1693,
+	1760,
+	1694,
+	1761,
+	1695,
+	1761,
+	1694,
+	1761,
+	1695,
+	1762,
+	1696,
+	1762,
+	1695,
+	1762,
+	1696,
+	1763,
+	1697,
+	1763,
+	1696,
+	1763,
+	1697,
+	1764,
+	1698,
+	1764,
+	1697,
+	1764,
+	1698,
+	1765,
+	1699,
+	1765,
+	1698,
+	1765,
+	1699,
+	1766,
+	1700,
+	1766,
+	1699,
+	1766,
+	1700,
+	1767,
+	1701,
+	1767,
+	1700,
+	1767,
+	1701,
+	1768,
+	1702,
+	1768,
+	1701,
+	1768,
+	1702,
+	1769,
+	1703,
+	1769,
+	1702,
+	1769,
+	1703,
+	1770,
+	1704,
+	1770,
+	1703,
+	1770,
+	1704,
+	1771,
+	1705,
+	1771,
+	1704,
+	1771,
+	1705,
+	1772,
+	1706,
+	1772,
+	1705,
+	1772,
+	1706,
+	1773,
+	1707,
+	1773,
+	1706,
+	1773,
+	1707,
+	1774,
+	1708,
+	1774,
+	1707,
+	1774,
+	1708,
+	1775,
+	1709,
+	1775,
+	1708,
+	1775,
+	1709,
+	1776,
+	1710,
+	1776,
+	1709,
+	1776,
+	1710,
+	1777,
+	1711,
+	1777,
+	1710,
+	1777,
+	1711,
+	1778,
+	1712,
+	1778,
+	1711,
+	1778,
+	1712,
+	1779,
+	1713,
+	1779,
+	1712,
+	1779,
+	1713,
+	1780,
+	1714,
+	1780,
+	1713,
+	1780,
+	1714,
+	1781,
+	1715,
+	1781,
+	1714,
+	1782,
+	1716,
+	1783,
+	1717,
+	1783,
+	1716,
+	1783,
+	1717,
+	1784,
+	1718,
+	1784,
+	1717,
+	1784,
+	1718,
+	1785,
+	1719,
+	1785,
+	1718,
+	1785,
+	1719,
+	1786,
+	1720,
+	1786,
+	1719,
+	1786,
+	1720,
+	1787,
+	1721,
+	1787,
+	1720,
+	1787,
+	1721,
+	1788,
+	1722,
+	1788,
+	1721,
+	1788,
+	1722,
+	1789,
+	1723,
+	1789,
+	1722,
+	1789,
+	1723,
+	1790,
+	1724,
+	1790,
+	1723,
+	1790,
+	1724,
+	1791,
+	1725,
+	1791,
+	1724,
+	1791,
+	1725,
+	1792,
+	1726,
+	1792,
+	1725,
+	1792,
+	1726,
+	1793,
+	1727,
+	1793,
+	1726,
+	1793,
+	1727,
+	1794,
+	1728,
+	1794,
+	1727,
+	1794,
+	1728,
+	1795,
+	1729,
+	1795,
+	1728,
+	1795,
+	1729,
+	1796,
+	1730,
+	1796,
+	1729,
+	1796,
+	1730,
+	1797,
+	1731,
+	1797,
+	1730,
+	1797,
+	1731,
+	1798,
+	1732,
+	1798,
+	1731,
+	1798,
+	1732,
+	1799,
+	1733,
+	1799,
+	1732,
+	1799,
+	1733,
+	1800,
+	1734,
+	1800,
+	1733,
+	1800,
+	1734,
+	1801,
+	1735,
+	1801,
+	1734,
+	1801,
+	1735,
+	1802,
+	1736,
+	1802,
+	1735,
+	1802,
+	1736,
+	1803,
+	1737,
+	1803,
+	1736,
+	1803,
+	1737,
+	1804,
+	1738,
+	1804,
+	1737,
+	1804,
+	1738,
+	1805,
+	1739,
+	1805,
+	1738,
+	1805,
+	1739,
+	1806,
+	1740,
+	1806,
+	1739,
+	1806,
+	1740,
+	1807,
+	1741,
+	1807,
+	1740,
+	1807,
+	1741,
+	1808,
+	1742,
+	1808,
+	1741,
+	1808,
+	1742,
+	1809,
+	1743,
+	1809,
+	1742,
+	1809,
+	1743,
+	1810,
+	1744,
+	1810,
+	1743,
+	1810,
+	1744,
+	1811,
+	1745,
+	1811,
+	1744,
+	1811,
+	1745,
+	1812,
+	1746,
+	1812,
+	1745,
+	1812,
+	1746,
+	1813,
+	1747,
+	1813,
+	1746,
+	1813,
+	1747,
+	1814,
+	1748,
+	1814,
+	1747,
+	1814,
+	1748,
+	1815,
+	1749,
+	1815,
+	1748,
+	1815,
+	1749,
+	1816,
+	1750,
+	1816,
+	1749,
+	1816,
+	1750,
+	1817,
+	1751,
+	1817,
+	1750,
+	1817,
+	1751,
+	1818,
+	1752,
+	1818,
+	1751,
+	1818,
+	1752,
+	1819,
+	1753,
+	1819,
+	1752,
+	1819,
+	1753,
+	1820,
+	1754,
+	1820,
+	1753,
+	1820,
+	1754,
+	1821,
+	1755,
+	1821,
+	1754,
+	1821,
+	1755,
+	1822,
+	1756,
+	1822,
+	1755,
+	1822,
+	1756,
+	1823,
+	1757,
+	1823,
+	1756,
+	1823,
+	1757,
+	1824,
+	1758,
+	1824,
+	1757,
+	1824,
+	1758,
+	1825,
+	1759,
+	1825,
+	1758,
+	1825,
+	1759,
+	1826,
+	1760,
+	1826,
+	1759,
+	1826,
+	1760,
+	1827,
+	1761,
+	1827,
+	1760,
+	1827,
+	1761,
+	1828,
+	1762,
+	1828,
+	1761,
+	1828,
+	1762,
+	1829,
+	1763,
+	1829,
+	1762,
+	1829,
+	1763,
+	1830,
+	1764,
+	1830,
+	1763,
+	1830,
+	1764,
+	1831,
+	1765,
+	1831,
+	1764,
+	1831,
+	1765,
+	1832,
+	1766,
+	1832,
+	1765,
+	1832,
+	1766,
+	1833,
+	1767,
+	1833,
+	1766,
+	1833,
+	1767,
+	1834,
+	1768,
+	1834,
+	1767,
+	1834,
+	1768,
+	1835,
+	1769,
+	1835,
+	1768,
+	1835,
+	1769,
+	1836,
+	1770,
+	1836,
+	1769,
+	1836,
+	1770,
+	1837,
+	1771,
+	1837,
+	1770,
+	1837,
+	1771,
+	1838,
+	1772,
+	1838,
+	1771,
+	1838,
+	1772,
+	1839,
+	1773,
+	1839,
+	1772,
+	1839,
+	1773,
+	1840,
+	1774,
+	1840,
+	1773,
+	1840,
+	1774,
+	1841,
+	1775,
+	1841,
+	1774,
+	1841,
+	1775,
+	1842,
+	1776,
+	1842,
+	1775,
+	1842,
+	1776,
+	1843,
+	1777,
+	1843,
+	1776,
+	1843,
+	1777,
+	1844,
+	1778,
+	1844,
+	1777,
+	1844,
+	1778,
+	1845,
+	1779,
+	1845,
+	1778,
+	1845,
+	1779,
+	1846,
+	1780,
+	1846,
+	1779,
+	1846,
+	1780,
+	1847,
+	1781,
+	1847,
+	1780,
+	1848,
+	1782,
+	1849,
+	1783,
+	1849,
+	1782,
+	1849,
+	1783,
+	1850,
+	1784,
+	1850,
+	1783,
+	1850,
+	1784,
+	1851,
+	1785,
+	1851,
+	1784,
+	1851,
+	1785,
+	1852,
+	1786,
+	1852,
+	1785,
+	1852,
+	1786,
+	1853,
+	1787,
+	1853,
+	1786,
+	1853,
+	1787,
+	1854,
+	1788,
+	1854,
+	1787,
+	1854,
+	1788,
+	1855,
+	1789,
+	1855,
+	1788,
+	1855,
+	1789,
+	1856,
+	1790,
+	1856,
+	1789,
+	1856,
+	1790,
+	1857,
+	1791,
+	1857,
+	1790,
+	1857,
+	1791,
+	1858,
+	1792,
+	1858,
+	1791,
+	1858,
+	1792,
+	1859,
+	1793,
+	1859,
+	1792,
+	1859,
+	1793,
+	1860,
+	1794,
+	1860,
+	1793,
+	1860,
+	1794,
+	1861,
+	1795,
+	1861,
+	1794,
+	1861,
+	1795,
+	1862,
+	1796,
+	1862,
+	1795,
+	1862,
+	1796,
+	1863,
+	1797,
+	1863,
+	1796,
+	1863,
+	1797,
+	1864,
+	1798,
+	1864,
+	1797,
+	1864,
+	1798,
+	1865,
+	1799,
+	1865,
+	1798,
+	1865,
+	1799,
+	1866,
+	1800,
+	1866,
+	1799,
+	1866,
+	1800,
+	1867,
+	1801,
+	1867,
+	1800,
+	1867,
+	1801,
+	1868,
+	1802,
+	1868,
+	1801,
+	1868,
+	1802,
+	1869,
+	1803,
+	1869,
+	1802,
+	1869,
+	1803,
+	1870,
+	1804,
+	1870,
+	1803,
+	1870,
+	1804,
+	1871,
+	1805,
+	1871,
+	1804,
+	1871,
+	1805,
+	1872,
+	1806,
+	1872,
+	1805,
+	1872,
+	1806,
+	1873,
+	1807,
+	1873,
+	1806,
+	1873,
+	1807,
+	1874,
+	1808,
+	1874,
+	1807,
+	1874,
+	1808,
+	1875,
+	1809,
+	1875,
+	1808,
+	1875,
+	1809,
+	1876,
+	1810,
+	1876,
+	1809,
+	1876,
+	1810,
+	1877,
+	1811,
+	1877,
+	1810,
+	1877,
+	1811,
+	1878,
+	1812,
+	1878,
+	1811,
+	1878,
+	1812,
+	1879,
+	1813,
+	1879,
+	1812,
+	1879,
+	1813,
+	1880,
+	1814,
+	1880,
+	1813,
+	1880,
+	1814,
+	1881,
+	1815,
+	1881,
+	1814,
+	1881,
+	1815,
+	1882,
+	1816,
+	1882,
+	1815,
+	1882,
+	1816,
+	1883,
+	1817,
+	1883,
+	1816,
+	1883,
+	1817,
+	1884,
+	1818,
+	1884,
+	1817,
+	1884,
+	1818,
+	1885,
+	1819,
+	1885,
+	1818,
+	1885,
+	1819,
+	1886,
+	1820,
+	1886,
+	1819,
+	1886,
+	1820,
+	1887,
+	1821,
+	1887,
+	1820,
+	1887,
+	1821,
+	1888,
+	1822,
+	1888,
+	1821,
+	1888,
+	1822,
+	1889,
+	1823,
+	1889,
+	1822,
+	1889,
+	1823,
+	1890,
+	1824,
+	1890,
+	1823,
+	1890,
+	1824,
+	1891,
+	1825,
+	1891,
+	1824,
+	1891,
+	1825,
+	1892,
+	1826,
+	1892,
+	1825,
+	1892,
+	1826,
+	1893,
+	1827,
+	1893,
+	1826,
+	1893,
+	1827,
+	1894,
+	1828,
+	1894,
+	1827,
+	1894,
+	1828,
+	1895,
+	1829,
+	1895,
+	1828,
+	1895,
+	1829,
+	1896,
+	1830,
+	1896,
+	1829,
+	1896,
+	1830,
+	1897,
+	1831,
+	1897,
+	1830,
+	1897,
+	1831,
+	1898,
+	1832,
+	1898,
+	1831,
+	1898,
+	1832,
+	1899,
+	1833,
+	1899,
+	1832,
+	1899,
+	1833,
+	1900,
+	1834,
+	1900,
+	1833,
+	1900,
+	1834,
+	1901,
+	1835,
+	1901,
+	1834,
+	1901,
+	1835,
+	1902,
+	1836,
+	1902,
+	1835,
+	1902,
+	1836,
+	1903,
+	1837,
+	1903,
+	1836,
+	1903,
+	1837,
+	1904,
+	1838,
+	1904,
+	1837,
+	1904,
+	1838,
+	1905,
+	1839,
+	1905,
+	1838,
+	1905,
+	1839,
+	1906,
+	1840,
+	1906,
+	1839,
+	1906,
+	1840,
+	1907,
+	1841,
+	1907,
+	1840,
+	1907,
+	1841,
+	1908,
+	1842,
+	1908,
+	1841,
+	1908,
+	1842,
+	1909,
+	1843,
+	1909,
+	1842,
+	1909,
+	1843,
+	1910,
+	1844,
+	1910,
+	1843,
+	1910,
+	1844,
+	1911,
+	1845,
+	1911,
+	1844,
+	1911,
+	1845,
+	1912,
+	1846,
+	1912,
+	1845,
+	1912,
+	1846,
+	1913,
+	1847,
+	1913,
+	1846,
+	1914,
+	1848,
+	1915,
+	1849,
+	1915,
+	1848,
+	1915,
+	1849,
+	1916,
+	1850,
+	1916,
+	1849,
+	1916,
+	1850,
+	1917,
+	1851,
+	1917,
+	1850,
+	1917,
+	1851,
+	1918,
+	1852,
+	1918,
+	1851,
+	1918,
+	1852,
+	1919,
+	1853,
+	1919,
+	1852,
+	1919,
+	1853,
+	1920,
+	1854,
+	1920,
+	1853,
+	1920,
+	1854,
+	1921,
+	1855,
+	1921,
+	1854,
+	1921,
+	1855,
+	1922,
+	1856,
+	1922,
+	1855,
+	1922,
+	1856,
+	1923,
+	1857,
+	1923,
+	1856,
+	1923,
+	1857,
+	1924,
+	1858,
+	1924,
+	1857,
+	1924,
+	1858,
+	1925,
+	1859,
+	1925,
+	1858,
+	1925,
+	1859,
+	1926,
+	1860,
+	1926,
+	1859,
+	1926,
+	1860,
+	1927,
+	1861,
+	1927,
+	1860,
+	1927,
+	1861,
+	1928,
+	1862,
+	1928,
+	1861,
+	1928,
+	1862,
+	1929,
+	1863,
+	1929,
+	1862,
+	1929,
+	1863,
+	1930,
+	1864,
+	1930,
+	1863,
+	1930,
+	1864,
+	1931,
+	1865,
+	1931,
+	1864,
+	1931,
+	1865,
+	1932,
+	1866,
+	1932,
+	1865,
+	1932,
+	1866,
+	1933,
+	1867,
+	1933,
+	1866,
+	1933,
+	1867,
+	1934,
+	1868,
+	1934,
+	1867,
+	1934,
+	1868,
+	1935,
+	1869,
+	1935,
+	1868,
+	1935,
+	1869,
+	1936,
+	1870,
+	1936,
+	1869,
+	1936,
+	1870,
+	1937,
+	1871,
+	1937,
+	1870,
+	1937,
+	1871,
+	1938,
+	1872,
+	1938,
+	1871,
+	1938,
+	1872,
+	1939,
+	1873,
+	1939,
+	1872,
+	1939,
+	1873,
+	1940,
+	1874,
+	1940,
+	1873,
+	1940,
+	1874,
+	1941,
+	1875,
+	1941,
+	1874,
+	1941,
+	1875,
+	1942,
+	1876,
+	1942,
+	1875,
+	1942,
+	1876,
+	1943,
+	1877,
+	1943,
+	1876,
+	1943,
+	1877,
+	1944,
+	1878,
+	1944,
+	1877,
+	1944,
+	1878,
+	1945,
+	1879,
+	1945,
+	1878,
+	1945,
+	1879,
+	1946,
+	1880,
+	1946,
+	1879,
+	1946,
+	1880,
+	1947,
+	1881,
+	1947,
+	1880,
+	1947,
+	1881,
+	1948,
+	1882,
+	1948,
+	1881,
+	1948,
+	1882,
+	1949,
+	1883,
+	1949,
+	1882,
+	1949,
+	1883,
+	1950,
+	1884,
+	1950,
+	1883,
+	1950,
+	1884,
+	1951,
+	1885,
+	1951,
+	1884,
+	1951,
+	1885,
+	1952,
+	1886,
+	1952,
+	1885,
+	1952,
+	1886,
+	1953,
+	1887,
+	1953,
+	1886,
+	1953,
+	1887,
+	1954,
+	1888,
+	1954,
+	1887,
+	1954,
+	1888,
+	1955,
+	1889,
+	1955,
+	1888,
+	1955,
+	1889,
+	1956,
+	1890,
+	1956,
+	1889,
+	1956,
+	1890,
+	1957,
+	1891,
+	1957,
+	1890,
+	1957,
+	1891,
+	1958,
+	1892,
+	1958,
+	1891,
+	1958,
+	1892,
+	1959,
+	1893,
+	1959,
+	1892,
+	1959,
+	1893,
+	1960,
+	1894,
+	1960,
+	1893,
+	1960,
+	1894,
+	1961,
+	1895,
+	1961,
+	1894,
+	1961,
+	1895,
+	1962,
+	1896,
+	1962,
+	1895,
+	1962,
+	1896,
+	1963,
+	1897,
+	1963,
+	1896,
+	1963,
+	1897,
+	1964,
+	1898,
+	1964,
+	1897,
+	1964,
+	1898,
+	1965,
+	1899,
+	1965,
+	1898,
+	1965,
+	1899,
+	1966,
+	1900,
+	1966,
+	1899,
+	1966,
+	1900,
+	1967,
+	1901,
+	1967,
+	1900,
+	1967,
+	1901,
+	1968,
+	1902,
+	1968,
+	1901,
+	1968,
+	1902,
+	1969,
+	1903,
+	1969,
+	1902,
+	1969,
+	1903,
+	1970,
+	1904,
+	1970,
+	1903,
+	1970,
+	1904,
+	1971,
+	1905,
+	1971,
+	1904,
+	1971,
+	1905,
+	1972,
+	1906,
+	1972,
+	1905,
+	1972,
+	1906,
+	1973,
+	1907,
+	1973,
+	1906,
+	1973,
+	1907,
+	1974,
+	1908,
+	1974,
+	1907,
+	1974,
+	1908,
+	1975,
+	1909,
+	1975,
+	1908,
+	1975,
+	1909,
+	1976,
+	1910,
+	1976,
+	1909,
+	1976,
+	1910,
+	1977,
+	1911,
+	1977,
+	1910,
+	1977,
+	1911,
+	1978,
+	1912,
+	1978,
+	1911,
+	1978,
+	1912,
+	1979,
+	1913,
+	1979,
+	1912,
+};
+
+#define Landscape03VtxCount 2048
+#define Landscape03IdxCount 11718
+
+btScalar Landscape03Vtx[] = {
+	3.90625f,
+	50.3865f,
+	-2.20246e-006f,
+	3.90625f,
+	52.6186f,
+	3.90625f,
+	7.8125f,
+	50.3905f,
+	-2.20264e-006f,
+	7.8125f,
+	51.8648f,
+	3.90625f,
+	11.7188f,
+	49.8171f,
+	-2.17758e-006f,
+	11.7188f,
+	51.1949f,
+	3.90625f,
+	15.625f,
+	50.595f,
+	-2.21158e-006f,
+	15.625f,
+	50.2102f,
+	3.90625f,
+	19.5313f,
+	50.405f,
+	-2.20327e-006f,
+	19.5313f,
+	50.6058f,
+	3.90625f,
+	23.4375f,
+	50.9679f,
+	-2.22788e-006f,
+	23.4375f,
+	50.7008f,
+	3.90625f,
+	27.3438f,
+	52.4635f,
+	-2.29325e-006f,
+	27.3438f,
+	51.2163f,
+	3.90625f,
+	31.25f,
+	53.1505f,
+	-2.32328e-006f,
+	31.25f,
+	51.4263f,
+	3.90625f,
+	35.1563f,
+	53.061f,
+	-2.31937e-006f,
+	35.1563f,
+	52.1968f,
+	3.90625f,
+	39.0625f,
+	53.6772f,
+	-2.34631e-006f,
+	39.0625f,
+	53.9783f,
+	3.90625f,
+	42.9688f,
+	54.3062f,
+	-2.3738e-006f,
+	42.9688f,
+	53.8927f,
+	3.90625f,
+	46.875f,
+	54.6795f,
+	-2.39012e-006f,
+	46.875f,
+	53.3266f,
+	3.90625f,
+	50.7813f,
+	55.3188f,
+	-2.41806e-006f,
+	50.7813f,
+	53.5901f,
+	3.90625f,
+	54.6875f,
+	56.913f,
+	-2.48775e-006f,
+	54.6875f,
+	55.5679f,
+	3.90625f,
+	58.5938f,
+	57.4575f,
+	-2.51155e-006f,
+	58.5938f,
+	55.1819f,
+	3.90625f,
+	62.5f,
+	56.5398f,
+	-2.47143e-006f,
+	62.5f,
+	53.6891f,
+	3.90625f,
+	66.4063f,
+	55.8786f,
+	-2.44253e-006f,
+	66.4063f,
+	53.0541f,
+	3.90625f,
+	70.3125f,
+	53.6497f,
+	-2.3451e-006f,
+	70.3125f,
+	51.6665f,
+	3.90625f,
+	74.2188f,
+	51.6447f,
+	-2.25746e-006f,
+	74.2188f,
+	51.4469f,
+	3.90625f,
+	78.125f,
+	51.8145f,
+	-2.26488e-006f,
+	78.125f,
+	51.9591f,
+	3.90625f,
+	82.0313f,
+	51.335f,
+	-2.24392e-006f,
+	82.0313f,
+	51.0418f,
+	3.90625f,
+	85.9375f,
+	50.1836f,
+	-2.1936e-006f,
+	85.9375f,
+	49.7513f,
+	3.90625f,
+	89.8438f,
+	49.0536f,
+	-2.1442e-006f,
+	89.8438f,
+	48.7329f,
+	3.90625f,
+	93.75f,
+	47.3968f,
+	-2.07178e-006f,
+	93.75f,
+	46.8713f,
+	3.90625f,
+	97.6563f,
+	45.8014f,
+	-2.00204e-006f,
+	97.6563f,
+	46.3905f,
+	3.90625f,
+	101.563f,
+	45.2347f,
+	-1.97727e-006f,
+	101.563f,
+	45.4241f,
+	3.90625f,
+	105.469f,
+	44.6501f,
+	-1.95172e-006f,
+	105.469f,
+	45.6811f,
+	3.90625f,
+	109.375f,
+	44.3569f,
+	-1.9389e-006f,
+	109.375f,
+	45.3238f,
+	3.90625f,
+	113.281f,
+	44.1147f,
+	-1.92831e-006f,
+	113.281f,
+	43.6112f,
+	3.90625f,
+	117.188f,
+	43.4037f,
+	-1.89723e-006f,
+	117.188f,
+	42.1291f,
+	3.90625f,
+	121.094f,
+	41.1606f,
+	-1.79919e-006f,
+	121.094f,
+	40.4747f,
+	3.90625f,
+	125.0f,
+	40.195f,
+	-1.75698e-006f,
+	125.0f,
+	39.3351f,
+	3.90625f,
+	128.906f,
+	39.5659f,
+	-1.72948e-006f,
+	128.906f,
+	38.0742f,
+	3.90625f,
+	132.813f,
+	38.2592f,
+	-1.67236e-006f,
+	132.813f,
+	36.7758f,
+	3.90625f,
+	136.719f,
+	36.4337f,
+	-1.59257e-006f,
+	136.719f,
+	34.9213f,
+	3.90625f,
+	140.625f,
+	34.1507f,
+	-1.49277e-006f,
+	140.625f,
+	32.3643f,
+	3.90625f,
+	144.531f,
+	31.5531f,
+	-1.37923e-006f,
+	144.531f,
+	31.7157f,
+	3.90625f,
+	148.438f,
+	29.9056f,
+	-1.30722e-006f,
+	148.438f,
+	30.6005f,
+	3.90625f,
+	152.344f,
+	30.5219f,
+	-1.33416e-006f,
+	152.344f,
+	31.6034f,
+	3.90625f,
+	156.25f,
+	31.1254f,
+	-1.36053e-006f,
+	156.25f,
+	32.6503f,
+	3.90625f,
+	160.156f,
+	31.8976f,
+	-1.39429e-006f,
+	160.156f,
+	33.3131f,
+	3.90625f,
+	164.063f,
+	31.5364f,
+	-1.3785e-006f,
+	164.063f,
+	32.5745f,
+	3.90625f,
+	167.969f,
+	30.5585f,
+	-1.33575e-006f,
+	167.969f,
+	31.5017f,
+	3.90625f,
+	171.875f,
+	30.0528f,
+	-1.31365e-006f,
+	171.875f,
+	30.6842f,
+	3.90625f,
+	175.781f,
+	29.2833f,
+	-1.28002e-006f,
+	175.781f,
+	29.8734f,
+	3.90625f,
+	179.688f,
+	28.3316f,
+	-1.23841e-006f,
+	179.688f,
+	28.6537f,
+	3.90625f,
+	183.594f,
+	27.0177f,
+	-1.18098e-006f,
+	183.594f,
+	27.2073f,
+	3.90625f,
+	187.5f,
+	24.7626f,
+	-1.08241e-006f,
+	187.5f,
+	25.4367f,
+	3.90625f,
+	191.406f,
+	22.7371f,
+	-9.9387e-007f,
+	191.406f,
+	24.1609f,
+	3.90625f,
+	195.313f,
+	21.6497f,
+	-9.46338e-007f,
+	195.313f,
+	23.9724f,
+	3.90625f,
+	199.219f,
+	21.3313f,
+	-9.32422e-007f,
+	199.219f,
+	23.7702f,
+	3.90625f,
+	203.125f,
+	20.9148f,
+	-9.14215e-007f,
+	203.125f,
+	22.4031f,
+	3.90625f,
+	207.031f,
+	19.4875f,
+	-8.51826e-007f,
+	207.031f,
+	22.1587f,
+	3.90625f,
+	210.938f,
+	19.0037f,
+	-8.30679e-007f,
+	210.938f,
+	21.6154f,
+	3.90625f,
+	214.844f,
+	18.408f,
+	-8.0464e-007f,
+	214.844f,
+	21.8202f,
+	3.90625f,
+	218.75f,
+	18.7855f,
+	-8.2114e-007f,
+	218.75f,
+	21.017f,
+	3.90625f,
+	222.656f,
+	18.1497f,
+	-7.9335e-007f,
+	222.656f,
+	19.3736f,
+	3.90625f,
+	226.563f,
+	17.6889f,
+	-7.73205e-007f,
+	226.563f,
+	18.2127f,
+	3.90625f,
+	230.469f,
+	16.8429f,
+	-7.36228e-007f,
+	230.469f,
+	17.2263f,
+	3.90625f,
+	234.375f,
+	16.3712f,
+	-7.15609e-007f,
+	234.375f,
+	16.2938f,
+	3.90625f,
+	238.281f,
+	14.3259f,
+	-6.26204e-007f,
+	238.281f,
+	14.4518f,
+	3.90625f,
+	242.188f,
+	12.4394f,
+	-5.43742e-007f,
+	242.188f,
+	13.6398f,
+	3.90625f,
+	246.094f,
+	12.3876f,
+	-5.41479e-007f,
+	246.094f,
+	13.2404f,
+	3.90625f,
+	250.0f,
+	11.9236f,
+	-5.21196e-007f,
+	250.0f,
+	12.7102f,
+	3.90625f,
+	3.90625f,
+	48.8559f,
+	-3.90625f,
+	7.8125f,
+	49.3575f,
+	-3.90625f,
+	11.7188f,
+	49.963f,
+	-3.90625f,
+	15.625f,
+	50.1126f,
+	-3.90625f,
+	19.5313f,
+	51.6247f,
+	-3.90625f,
+	23.4375f,
+	52.1716f,
+	-3.90625f,
+	27.3438f,
+	52.8679f,
+	-3.90625f,
+	31.25f,
+	53.978f,
+	-3.90625f,
+	35.1563f,
+	53.8948f,
+	-3.90625f,
+	39.0625f,
+	54.8492f,
+	-3.90625f,
+	42.9688f,
+	56.1714f,
+	-3.90625f,
+	46.875f,
+	56.4915f,
+	-3.90625f,
+	50.7813f,
+	56.5729f,
+	-3.90625f,
+	54.6875f,
+	57.9767f,
+	-3.90625f,
+	58.5938f,
+	58.6125f,
+	-3.90625f,
+	62.5f,
+	58.0023f,
+	-3.90625f,
+	66.4063f,
+	57.5742f,
+	-3.90625f,
+	70.3125f,
+	55.4949f,
+	-3.90625f,
+	74.2188f,
+	53.7219f,
+	-3.90625f,
+	78.125f,
+	53.233f,
+	-3.90625f,
+	82.0313f,
+	52.5499f,
+	-3.90625f,
+	85.9375f,
+	51.1842f,
+	-3.90625f,
+	89.8438f,
+	49.6534f,
+	-3.90625f,
+	93.75f,
+	47.6829f,
+	-3.90625f,
+	97.6563f,
+	45.813f,
+	-3.90625f,
+	101.563f,
+	44.7099f,
+	-3.90625f,
+	105.469f,
+	45.0932f,
+	-3.90625f,
+	109.375f,
+	44.8326f,
+	-3.90625f,
+	113.281f,
+	44.5197f,
+	-3.90625f,
+	117.188f,
+	43.7399f,
+	-3.90625f,
+	121.094f,
+	42.3088f,
+	-3.90625f,
+	125.0f,
+	40.4224f,
+	-3.90625f,
+	128.906f,
+	39.437f,
+	-3.90625f,
+	132.813f,
+	39.825f,
+	-3.90625f,
+	136.719f,
+	38.2979f,
+	-3.90625f,
+	140.625f,
+	35.2095f,
+	-3.90625f,
+	144.531f,
+	32.0692f,
+	-3.90625f,
+	148.438f,
+	31.1765f,
+	-3.90625f,
+	152.344f,
+	32.2065f,
+	-3.90625f,
+	156.25f,
+	31.4774f,
+	-3.90625f,
+	160.156f,
+	31.7166f,
+	-3.90625f,
+	164.063f,
+	31.7667f,
+	-3.90625f,
+	167.969f,
+	31.1742f,
+	-3.90625f,
+	171.875f,
+	29.6515f,
+	-3.90625f,
+	175.781f,
+	28.7845f,
+	-3.90625f,
+	179.688f,
+	28.3154f,
+	-3.90625f,
+	183.594f,
+	26.6187f,
+	-3.90625f,
+	187.5f,
+	24.7363f,
+	-3.90625f,
+	191.406f,
+	22.9162f,
+	-3.90625f,
+	195.313f,
+	21.5211f,
+	-3.90625f,
+	199.219f,
+	19.7693f,
+	-3.90625f,
+	203.125f,
+	18.9792f,
+	-3.90625f,
+	207.031f,
+	18.8399f,
+	-3.90625f,
+	210.938f,
+	18.8797f,
+	-3.90625f,
+	214.844f,
+	18.8123f,
+	-3.90625f,
+	218.75f,
+	18.5136f,
+	-3.90625f,
+	222.656f,
+	18.5607f,
+	-3.90625f,
+	226.563f,
+	17.5053f,
+	-3.90625f,
+	230.469f,
+	17.4838f,
+	-3.90625f,
+	234.375f,
+	16.6728f,
+	-3.90625f,
+	238.281f,
+	14.8594f,
+	-3.90625f,
+	242.188f,
+	12.9613f,
+	-3.90625f,
+	246.094f,
+	12.8624f,
+	-3.90625f,
+	250.0f,
+	11.5894f,
+	-3.90625f,
+	3.90625f,
+	48.7225f,
+	-7.8125f,
+	7.8125f,
+	49.1281f,
+	-7.8125f,
+	11.7188f,
+	50.0005f,
+	-7.8125f,
+	15.625f,
+	50.5896f,
+	-7.8125f,
+	19.5313f,
+	51.5499f,
+	-7.8125f,
+	23.4375f,
+	52.9511f,
+	-7.8125f,
+	27.3438f,
+	53.117f,
+	-7.8125f,
+	31.25f,
+	54.0682f,
+	-7.8125f,
+	35.1563f,
+	55.2353f,
+	-7.8125f,
+	39.0625f,
+	57.2741f,
+	-7.8125f,
+	42.9688f,
+	57.4338f,
+	-7.8125f,
+	46.875f,
+	57.766f,
+	-7.8125f,
+	50.7813f,
+	57.2724f,
+	-7.8125f,
+	54.6875f,
+	58.0147f,
+	-7.8125f,
+	58.5938f,
+	58.764f,
+	-7.8125f,
+	62.5f,
+	58.6375f,
+	-7.8125f,
+	66.4063f,
+	57.2699f,
+	-7.8125f,
+	70.3125f,
+	55.9883f,
+	-7.8125f,
+	74.2188f,
+	54.8767f,
+	-7.8125f,
+	78.125f,
+	54.5266f,
+	-7.8125f,
+	82.0313f,
+	53.7148f,
+	-7.8125f,
+	85.9375f,
+	52.3735f,
+	-7.8125f,
+	89.8438f,
+	50.9637f,
+	-7.8125f,
+	93.75f,
+	48.4983f,
+	-7.8125f,
+	97.6563f,
+	45.9034f,
+	-7.8125f,
+	101.563f,
+	45.0863f,
+	-7.8125f,
+	105.469f,
+	44.2432f,
+	-7.8125f,
+	109.375f,
+	43.9561f,
+	-7.8125f,
+	113.281f,
+	43.3015f,
+	-7.8125f,
+	117.188f,
+	43.254f,
+	-7.8125f,
+	121.094f,
+	42.7388f,
+	-7.8125f,
+	125.0f,
+	41.1851f,
+	-7.8125f,
+	128.906f,
+	39.7522f,
+	-7.8125f,
+	132.813f,
+	39.8116f,
+	-7.8125f,
+	136.719f,
+	38.7148f,
+	-7.8125f,
+	140.625f,
+	36.0845f,
+	-7.8125f,
+	144.531f,
+	34.0308f,
+	-7.8125f,
+	148.438f,
+	33.0368f,
+	-7.8125f,
+	152.344f,
+	32.5867f,
+	-7.8125f,
+	156.25f,
+	32.8758f,
+	-7.8125f,
+	160.156f,
+	32.65f,
+	-7.8125f,
+	164.063f,
+	32.6826f,
+	-7.8125f,
+	167.969f,
+	31.5243f,
+	-7.8125f,
+	171.875f,
+	30.4061f,
+	-7.8125f,
+	175.781f,
+	29.2721f,
+	-7.8125f,
+	179.688f,
+	28.0417f,
+	-7.8125f,
+	183.594f,
+	26.2041f,
+	-7.8125f,
+	187.5f,
+	24.2168f,
+	-7.8125f,
+	191.406f,
+	22.7847f,
+	-7.8125f,
+	195.313f,
+	20.5069f,
+	-7.8125f,
+	199.219f,
+	18.6189f,
+	-7.8125f,
+	203.125f,
+	17.5296f,
+	-7.8125f,
+	207.031f,
+	18.0846f,
+	-7.8125f,
+	210.938f,
+	18.4802f,
+	-7.8125f,
+	214.844f,
+	18.5436f,
+	-7.8125f,
+	218.75f,
+	18.3296f,
+	-7.8125f,
+	222.656f,
+	17.9158f,
+	-7.8125f,
+	226.563f,
+	17.0318f,
+	-7.8125f,
+	230.469f,
+	16.2818f,
+	-7.8125f,
+	234.375f,
+	15.4949f,
+	-7.8125f,
+	238.281f,
+	13.4891f,
+	-7.8125f,
+	242.188f,
+	13.3349f,
+	-7.8125f,
+	246.094f,
+	12.2716f,
+	-7.8125f,
+	250.0f,
+	10.9901f,
+	-7.8125f,
+	3.90625f,
+	49.6298f,
+	-11.7188f,
+	7.8125f,
+	50.0683f,
+	-11.7188f,
+	11.7188f,
+	50.6295f,
+	-11.7188f,
+	15.625f,
+	51.0495f,
+	-11.7188f,
+	19.5313f,
+	52.4884f,
+	-11.7188f,
+	23.4375f,
+	53.3147f,
+	-11.7188f,
+	27.3438f,
+	54.4311f,
+	-11.7188f,
+	31.25f,
+	55.2874f,
+	-11.7188f,
+	35.1563f,
+	56.5549f,
+	-11.7188f,
+	39.0625f,
+	57.9376f,
+	-11.7188f,
+	42.9688f,
+	58.2302f,
+	-11.7188f,
+	46.875f,
+	59.1419f,
+	-11.7188f,
+	50.7813f,
+	58.8724f,
+	-11.7188f,
+	54.6875f,
+	58.5393f,
+	-11.7188f,
+	58.5938f,
+	58.6416f,
+	-11.7188f,
+	62.5f,
+	58.1973f,
+	-11.7188f,
+	66.4063f,
+	57.9168f,
+	-11.7188f,
+	70.3125f,
+	56.4347f,
+	-11.7188f,
+	74.2188f,
+	55.7911f,
+	-11.7188f,
+	78.125f,
+	55.946f,
+	-11.7188f,
+	82.0313f,
+	54.9033f,
+	-11.7188f,
+	85.9375f,
+	53.0954f,
+	-11.7188f,
+	89.8438f,
+	51.7428f,
+	-11.7188f,
+	93.75f,
+	49.2198f,
+	-11.7188f,
+	97.6563f,
+	46.1127f,
+	-11.7188f,
+	101.563f,
+	43.9953f,
+	-11.7188f,
+	105.469f,
+	43.5777f,
+	-11.7188f,
+	109.375f,
+	43.3284f,
+	-11.7188f,
+	113.281f,
+	43.5152f,
+	-11.7188f,
+	117.188f,
+	43.6687f,
+	-11.7188f,
+	121.094f,
+	42.5477f,
+	-11.7188f,
+	125.0f,
+	41.4079f,
+	-11.7188f,
+	128.906f,
+	39.4512f,
+	-11.7188f,
+	132.813f,
+	39.5183f,
+	-11.7188f,
+	136.719f,
+	37.8068f,
+	-11.7188f,
+	140.625f,
+	36.5652f,
+	-11.7188f,
+	144.531f,
+	34.8202f,
+	-11.7188f,
+	148.438f,
+	34.0166f,
+	-11.7188f,
+	152.344f,
+	33.5311f,
+	-11.7188f,
+	156.25f,
+	34.1672f,
+	-11.7188f,
+	160.156f,
+	33.8602f,
+	-11.7188f,
+	164.063f,
+	33.8717f,
+	-11.7188f,
+	167.969f,
+	33.1703f,
+	-11.7188f,
+	171.875f,
+	31.0241f,
+	-11.7188f,
+	175.781f,
+	30.2798f,
+	-11.7188f,
+	179.688f,
+	28.3241f,
+	-11.7188f,
+	183.594f,
+	26.4432f,
+	-11.7188f,
+	187.5f,
+	24.9758f,
+	-11.7188f,
+	191.406f,
+	22.2834f,
+	-11.7188f,
+	195.313f,
+	19.3875f,
+	-11.7188f,
+	199.219f,
+	18.4079f,
+	-11.7188f,
+	203.125f,
+	16.6498f,
+	-11.7188f,
+	207.031f,
+	16.1235f,
+	-11.7188f,
+	210.938f,
+	16.9462f,
+	-11.7188f,
+	214.844f,
+	17.2638f,
+	-11.7188f,
+	218.75f,
+	17.0386f,
+	-11.7188f,
+	222.656f,
+	16.7666f,
+	-11.7188f,
+	226.563f,
+	15.3591f,
+	-11.7188f,
+	230.469f,
+	14.4048f,
+	-11.7188f,
+	234.375f,
+	13.3079f,
+	-11.7188f,
+	238.281f,
+	13.0895f,
+	-11.7188f,
+	242.188f,
+	12.8462f,
+	-11.7188f,
+	246.094f,
+	12.6287f,
+	-11.7188f,
+	250.0f,
+	11.4682f,
+	-11.7188f,
+	3.90625f,
+	50.6915f,
+	-15.625f,
+	7.8125f,
+	51.2382f,
+	-15.625f,
+	11.7188f,
+	52.3659f,
+	-15.625f,
+	15.625f,
+	52.3873f,
+	-15.625f,
+	19.5313f,
+	53.1083f,
+	-15.625f,
+	23.4375f,
+	54.652f,
+	-15.625f,
+	27.3438f,
+	56.0359f,
+	-15.625f,
+	31.25f,
+	56.4398f,
+	-15.625f,
+	35.1563f,
+	57.3156f,
+	-15.625f,
+	39.0625f,
+	58.2355f,
+	-15.625f,
+	42.9688f,
+	59.4547f,
+	-15.625f,
+	46.875f,
+	59.9176f,
+	-15.625f,
+	50.7813f,
+	60.0789f,
+	-15.625f,
+	54.6875f,
+	59.004f,
+	-15.625f,
+	58.5938f,
+	59.3361f,
+	-15.625f,
+	62.5f,
+	59.2681f,
+	-15.625f,
+	66.4063f,
+	58.5571f,
+	-15.625f,
+	70.3125f,
+	57.1801f,
+	-15.625f,
+	74.2188f,
+	56.2048f,
+	-15.625f,
+	78.125f,
+	56.9427f,
+	-15.625f,
+	82.0313f,
+	55.401f,
+	-15.625f,
+	85.9375f,
+	53.0457f,
+	-15.625f,
+	89.8438f,
+	51.6378f,
+	-15.625f,
+	93.75f,
+	49.1297f,
+	-15.625f,
+	97.6563f,
+	46.6267f,
+	-15.625f,
+	101.563f,
+	44.7255f,
+	-15.625f,
+	105.469f,
+	43.3819f,
+	-15.625f,
+	109.375f,
+	42.8703f,
+	-15.625f,
+	113.281f,
+	42.7636f,
+	-15.625f,
+	117.188f,
+	42.1897f,
+	-15.625f,
+	121.094f,
+	41.9269f,
+	-15.625f,
+	125.0f,
+	41.5365f,
+	-15.625f,
+	128.906f,
+	39.5408f,
+	-15.625f,
+	132.813f,
+	38.9178f,
+	-15.625f,
+	136.719f,
+	38.1447f,
+	-15.625f,
+	140.625f,
+	36.5145f,
+	-15.625f,
+	144.531f,
+	34.8696f,
+	-15.625f,
+	148.438f,
+	34.8203f,
+	-15.625f,
+	152.344f,
+	34.409f,
+	-15.625f,
+	156.25f,
+	35.1394f,
+	-15.625f,
+	160.156f,
+	35.619f,
+	-15.625f,
+	164.063f,
+	34.7784f,
+	-15.625f,
+	167.969f,
+	33.6548f,
+	-15.625f,
+	171.875f,
+	32.1822f,
+	-15.625f,
+	175.781f,
+	31.1666f,
+	-15.625f,
+	179.688f,
+	28.9574f,
+	-15.625f,
+	183.594f,
+	27.3989f,
+	-15.625f,
+	187.5f,
+	24.7201f,
+	-15.625f,
+	191.406f,
+	21.7859f,
+	-15.625f,
+	195.313f,
+	19.2508f,
+	-15.625f,
+	199.219f,
+	18.0209f,
+	-15.625f,
+	203.125f,
+	16.8441f,
+	-15.625f,
+	207.031f,
+	15.8846f,
+	-15.625f,
+	210.938f,
+	15.6902f,
+	-15.625f,
+	214.844f,
+	15.3143f,
+	-15.625f,
+	218.75f,
+	15.3862f,
+	-15.625f,
+	222.656f,
+	14.2743f,
+	-15.625f,
+	226.563f,
+	13.5791f,
+	-15.625f,
+	230.469f,
+	13.4953f,
+	-15.625f,
+	234.375f,
+	13.3484f,
+	-15.625f,
+	238.281f,
+	13.2722f,
+	-15.625f,
+	242.188f,
+	13.4455f,
+	-15.625f,
+	246.094f,
+	13.0725f,
+	-15.625f,
+	250.0f,
+	11.5558f,
+	-15.625f,
+	3.90625f,
+	52.1028f,
+	-19.5313f,
+	7.8125f,
+	52.877f,
+	-19.5313f,
+	11.7188f,
+	54.5397f,
+	-19.5313f,
+	15.625f,
+	54.8941f,
+	-19.5313f,
+	19.5313f,
+	54.9009f,
+	-19.5313f,
+	23.4375f,
+	56.1681f,
+	-19.5313f,
+	27.3438f,
+	56.5579f,
+	-19.5313f,
+	31.25f,
+	57.7962f,
+	-19.5313f,
+	35.1563f,
+	58.728f,
+	-19.5313f,
+	39.0625f,
+	59.4794f,
+	-19.5313f,
+	42.9688f,
+	60.2636f,
+	-19.5313f,
+	46.875f,
+	61.2139f,
+	-19.5313f,
+	50.7813f,
+	60.4636f,
+	-19.5313f,
+	54.6875f,
+	59.681f,
+	-19.5313f,
+	58.5938f,
+	60.2068f,
+	-19.5313f,
+	62.5f,
+	59.1055f,
+	-19.5313f,
+	66.4063f,
+	57.6126f,
+	-19.5313f,
+	70.3125f,
+	56.6416f,
+	-19.5313f,
+	74.2188f,
+	56.4864f,
+	-19.5313f,
+	78.125f,
+	56.1784f,
+	-19.5313f,
+	82.0313f,
+	54.8451f,
+	-19.5313f,
+	85.9375f,
+	53.4094f,
+	-19.5313f,
+	89.8438f,
+	51.7161f,
+	-19.5313f,
+	93.75f,
+	48.9933f,
+	-19.5313f,
+	97.6563f,
+	47.5116f,
+	-19.5313f,
+	101.563f,
+	45.7701f,
+	-19.5313f,
+	105.469f,
+	44.0377f,
+	-19.5313f,
+	109.375f,
+	43.0918f,
+	-19.5313f,
+	113.281f,
+	42.3992f,
+	-19.5313f,
+	117.188f,
+	42.0928f,
+	-19.5313f,
+	121.094f,
+	42.0543f,
+	-19.5313f,
+	125.0f,
+	41.793f,
+	-19.5313f,
+	128.906f,
+	39.3232f,
+	-19.5313f,
+	132.813f,
+	39.1149f,
+	-19.5313f,
+	136.719f,
+	38.2381f,
+	-19.5313f,
+	140.625f,
+	36.1019f,
+	-19.5313f,
+	144.531f,
+	36.4503f,
+	-19.5313f,
+	148.438f,
+	35.6809f,
+	-19.5313f,
+	152.344f,
+	35.8022f,
+	-19.5313f,
+	156.25f,
+	36.4955f,
+	-19.5313f,
+	160.156f,
+	36.3187f,
+	-19.5313f,
+	164.063f,
+	35.0268f,
+	-19.5313f,
+	167.969f,
+	34.0134f,
+	-19.5313f,
+	171.875f,
+	33.6455f,
+	-19.5313f,
+	175.781f,
+	31.5932f,
+	-19.5313f,
+	179.688f,
+	30.0326f,
+	-19.5313f,
+	183.594f,
+	28.3453f,
+	-19.5313f,
+	187.5f,
+	25.3719f,
+	-19.5313f,
+	191.406f,
+	22.0833f,
+	-19.5313f,
+	195.313f,
+	18.7475f,
+	-19.5313f,
+	199.219f,
+	17.5517f,
+	-19.5313f,
+	203.125f,
+	16.1528f,
+	-19.5313f,
+	207.031f,
+	15.6144f,
+	-19.5313f,
+	210.938f,
+	14.9281f,
+	-19.5313f,
+	214.844f,
+	14.5711f,
+	-19.5313f,
+	218.75f,
+	13.8446f,
+	-19.5313f,
+	222.656f,
+	13.6892f,
+	-19.5313f,
+	226.563f,
+	13.1595f,
+	-19.5313f,
+	230.469f,
+	13.2872f,
+	-19.5313f,
+	234.375f,
+	13.6153f,
+	-19.5313f,
+	238.281f,
+	12.8725f,
+	-19.5313f,
+	242.188f,
+	12.7128f,
+	-19.5313f,
+	246.094f,
+	13.0658f,
+	-19.5313f,
+	250.0f,
+	11.5414f,
+	-19.5313f,
+	3.90625f,
+	54.332f,
+	-23.4375f,
+	7.8125f,
+	55.636f,
+	-23.4375f,
+	11.7188f,
+	56.3899f,
+	-23.4375f,
+	15.625f,
+	56.3763f,
+	-23.4375f,
+	19.5313f,
+	56.9523f,
+	-23.4375f,
+	23.4375f,
+	57.5593f,
+	-23.4375f,
+	27.3438f,
+	57.8056f,
+	-23.4375f,
+	31.25f,
+	58.5489f,
+	-23.4375f,
+	35.1563f,
+	59.2321f,
+	-23.4375f,
+	39.0625f,
+	60.5971f,
+	-23.4375f,
+	42.9688f,
+	60.1728f,
+	-23.4375f,
+	46.875f,
+	60.9341f,
+	-23.4375f,
+	50.7813f,
+	59.5118f,
+	-23.4375f,
+	54.6875f,
+	59.7552f,
+	-23.4375f,
+	58.5938f,
+	59.9126f,
+	-23.4375f,
+	62.5f,
+	58.501f,
+	-23.4375f,
+	66.4063f,
+	57.8539f,
+	-23.4375f,
+	70.3125f,
+	56.8693f,
+	-23.4375f,
+	74.2188f,
+	56.0687f,
+	-23.4375f,
+	78.125f,
+	55.4392f,
+	-23.4375f,
+	82.0313f,
+	53.7167f,
+	-23.4375f,
+	85.9375f,
+	52.1078f,
+	-23.4375f,
+	89.8438f,
+	50.8869f,
+	-23.4375f,
+	93.75f,
+	49.9812f,
+	-23.4375f,
+	97.6563f,
+	47.9233f,
+	-23.4375f,
+	101.563f,
+	46.1166f,
+	-23.4375f,
+	105.469f,
+	44.4826f,
+	-23.4375f,
+	109.375f,
+	42.8924f,
+	-23.4375f,
+	113.281f,
+	41.9991f,
+	-23.4375f,
+	117.188f,
+	41.1759f,
+	-23.4375f,
+	121.094f,
+	41.1189f,
+	-23.4375f,
+	125.0f,
+	39.9128f,
+	-23.4375f,
+	128.906f,
+	39.8641f,
+	-23.4375f,
+	132.813f,
+	39.8777f,
+	-23.4375f,
+	136.719f,
+	38.3567f,
+	-23.4375f,
+	140.625f,
+	37.4926f,
+	-23.4375f,
+	144.531f,
+	37.0275f,
+	-23.4375f,
+	148.438f,
+	36.7211f,
+	-23.4375f,
+	152.344f,
+	36.9355f,
+	-23.4375f,
+	156.25f,
+	37.7455f,
+	-23.4375f,
+	160.156f,
+	37.3585f,
+	-23.4375f,
+	164.063f,
+	36.1837f,
+	-23.4375f,
+	167.969f,
+	34.768f,
+	-23.4375f,
+	171.875f,
+	33.2179f,
+	-23.4375f,
+	175.781f,
+	31.6883f,
+	-23.4375f,
+	179.688f,
+	30.1136f,
+	-23.4375f,
+	183.594f,
+	28.1155f,
+	-23.4375f,
+	187.5f,
+	25.4881f,
+	-23.4375f,
+	191.406f,
+	22.8498f,
+	-23.4375f,
+	195.313f,
+	19.4425f,
+	-23.4375f,
+	199.219f,
+	17.1253f,
+	-23.4375f,
+	203.125f,
+	14.8354f,
+	-23.4375f,
+	207.031f,
+	14.1771f,
+	-23.4375f,
+	210.938f,
+	13.9227f,
+	-23.4375f,
+	214.844f,
+	13.3404f,
+	-23.4375f,
+	218.75f,
+	13.0525f,
+	-23.4375f,
+	222.656f,
+	13.0744f,
+	-23.4375f,
+	226.563f,
+	13.0432f,
+	-23.4375f,
+	230.469f,
+	13.3341f,
+	-23.4375f,
+	234.375f,
+	13.6022f,
+	-23.4375f,
+	238.281f,
+	13.3878f,
+	-23.4375f,
+	242.188f,
+	12.5812f,
+	-23.4375f,
+	246.094f,
+	11.8699f,
+	-23.4375f,
+	250.0f,
+	11.3395f,
+	-23.4375f,
+	3.90625f,
+	57.5273f,
+	-27.3438f,
+	7.8125f,
+	57.8217f,
+	-27.3438f,
+	11.7188f,
+	57.5626f,
+	-27.3438f,
+	15.625f,
+	57.7794f,
+	-27.3438f,
+	19.5313f,
+	58.7949f,
+	-27.3438f,
+	23.4375f,
+	59.3547f,
+	-27.3438f,
+	27.3438f,
+	59.2359f,
+	-27.3438f,
+	31.25f,
+	58.8772f,
+	-27.3438f,
+	35.1563f,
+	58.7149f,
+	-27.3438f,
+	39.0625f,
+	59.7221f,
+	-27.3438f,
+	42.9688f,
+	60.0457f,
+	-27.3438f,
+	46.875f,
+	59.6559f,
+	-27.3438f,
+	50.7813f,
+	59.9346f,
+	-27.3438f,
+	54.6875f,
+	60.4095f,
+	-27.3438f,
+	58.5938f,
+	59.3107f,
+	-27.3438f,
+	62.5f,
+	57.9086f,
+	-27.3438f,
+	66.4063f,
+	57.3034f,
+	-27.3438f,
+	70.3125f,
+	55.5758f,
+	-27.3438f,
+	74.2188f,
+	54.7167f,
+	-27.3438f,
+	78.125f,
+	54.405f,
+	-27.3438f,
+	82.0313f,
+	53.0644f,
+	-27.3438f,
+	85.9375f,
+	50.9689f,
+	-27.3438f,
+	89.8438f,
+	49.5959f,
+	-27.3438f,
+	93.75f,
+	49.2817f,
+	-27.3438f,
+	97.6563f,
+	48.9188f,
+	-27.3438f,
+	101.563f,
+	47.0066f,
+	-27.3438f,
+	105.469f,
+	44.4266f,
+	-27.3438f,
+	109.375f,
+	42.4539f,
+	-27.3438f,
+	113.281f,
+	41.5486f,
+	-27.3438f,
+	117.188f,
+	41.4419f,
+	-27.3438f,
+	121.094f,
+	41.2039f,
+	-27.3438f,
+	125.0f,
+	40.188f,
+	-27.3438f,
+	128.906f,
+	40.4744f,
+	-27.3438f,
+	132.813f,
+	40.1187f,
+	-27.3438f,
+	136.719f,
+	38.8055f,
+	-27.3438f,
+	140.625f,
+	38.024f,
+	-27.3438f,
+	144.531f,
+	37.5255f,
+	-27.3438f,
+	148.438f,
+	36.8676f,
+	-27.3438f,
+	152.344f,
+	37.8967f,
+	-27.3438f,
+	156.25f,
+	38.4708f,
+	-27.3438f,
+	160.156f,
+	37.8284f,
+	-27.3438f,
+	164.063f,
+	36.6094f,
+	-27.3438f,
+	167.969f,
+	34.4523f,
+	-27.3438f,
+	171.875f,
+	32.2936f,
+	-27.3438f,
+	175.781f,
+	31.7467f,
+	-27.3438f,
+	179.688f,
+	29.9455f,
+	-27.3438f,
+	183.594f,
+	27.7546f,
+	-27.3438f,
+	187.5f,
+	25.1902f,
+	-27.3438f,
+	191.406f,
+	22.537f,
+	-27.3438f,
+	195.313f,
+	19.5657f,
+	-27.3438f,
+	199.219f,
+	17.4406f,
+	-27.3438f,
+	203.125f,
+	15.5459f,
+	-27.3438f,
+	207.031f,
+	14.92f,
+	-27.3438f,
+	210.938f,
+	13.472f,
+	-27.3438f,
+	214.844f,
+	12.9933f,
+	-27.3438f,
+	218.75f,
+	13.2849f,
+	-27.3438f,
+	222.656f,
+	12.3375f,
+	-27.3438f,
+	226.563f,
+	12.0553f,
+	-27.3438f,
+	230.469f,
+	12.4756f,
+	-27.3438f,
+	234.375f,
+	12.0857f,
+	-27.3438f,
+	238.281f,
+	12.1988f,
+	-27.3438f,
+	242.188f,
+	11.9091f,
+	-27.3438f,
+	246.094f,
+	10.7301f,
+	-27.3438f,
+	250.0f,
+	10.1068f,
+	-27.3438f,
+	3.90625f,
+	59.4204f,
+	-31.25f,
+	7.8125f,
+	59.5424f,
+	-31.25f,
+	11.7188f,
+	58.7785f,
+	-31.25f,
+	15.625f,
+	59.7851f,
+	-31.25f,
+	19.5313f,
+	60.4897f,
+	-31.25f,
+	23.4375f,
+	60.6095f,
+	-31.25f,
+	27.3438f,
+	60.3384f,
+	-31.25f,
+	31.25f,
+	59.5445f,
+	-31.25f,
+	35.1563f,
+	58.6838f,
+	-31.25f,
+	39.0625f,
+	58.847f,
+	-31.25f,
+	42.9688f,
+	59.3885f,
+	-31.25f,
+	46.875f,
+	59.447f,
+	-31.25f,
+	50.7813f,
+	59.5998f,
+	-31.25f,
+	54.6875f,
+	58.9947f,
+	-31.25f,
+	58.5938f,
+	58.7482f,
+	-31.25f,
+	62.5f,
+	56.5947f,
+	-31.25f,
+	66.4063f,
+	56.2941f,
+	-31.25f,
+	70.3125f,
+	54.6423f,
+	-31.25f,
+	74.2188f,
+	53.7392f,
+	-31.25f,
+	78.125f,
+	53.2955f,
+	-31.25f,
+	82.0313f,
+	52.8233f,
+	-31.25f,
+	85.9375f,
+	52.1194f,
+	-31.25f,
+	89.8438f,
+	51.3335f,
+	-31.25f,
+	93.75f,
+	49.9201f,
+	-31.25f,
+	97.6563f,
+	49.1642f,
+	-31.25f,
+	101.563f,
+	47.4466f,
+	-31.25f,
+	105.469f,
+	44.6086f,
+	-31.25f,
+	109.375f,
+	42.885f,
+	-31.25f,
+	113.281f,
+	42.947f,
+	-31.25f,
+	117.188f,
+	42.2436f,
+	-31.25f,
+	121.094f,
+	41.6479f,
+	-31.25f,
+	125.0f,
+	41.6151f,
+	-31.25f,
+	128.906f,
+	41.2079f,
+	-31.25f,
+	132.813f,
+	40.7975f,
+	-31.25f,
+	136.719f,
+	39.8341f,
+	-31.25f,
+	140.625f,
+	38.7649f,
+	-31.25f,
+	144.531f,
+	37.7387f,
+	-31.25f,
+	148.438f,
+	37.2112f,
+	-31.25f,
+	152.344f,
+	38.3278f,
+	-31.25f,
+	156.25f,
+	38.7659f,
+	-31.25f,
+	160.156f,
+	37.5608f,
+	-31.25f,
+	164.063f,
+	35.9966f,
+	-31.25f,
+	167.969f,
+	33.737f,
+	-31.25f,
+	171.875f,
+	32.0109f,
+	-31.25f,
+	175.781f,
+	31.1169f,
+	-31.25f,
+	179.688f,
+	30.0211f,
+	-31.25f,
+	183.594f,
+	27.5633f,
+	-31.25f,
+	187.5f,
+	25.0292f,
+	-31.25f,
+	191.406f,
+	22.8265f,
+	-31.25f,
+	195.313f,
+	19.8972f,
+	-31.25f,
+	199.219f,
+	17.6714f,
+	-31.25f,
+	203.125f,
+	16.2679f,
+	-31.25f,
+	207.031f,
+	15.0546f,
+	-31.25f,
+	210.938f,
+	14.037f,
+	-31.25f,
+	214.844f,
+	12.5501f,
+	-31.25f,
+	218.75f,
+	12.1528f,
+	-31.25f,
+	222.656f,
+	12.0576f,
+	-31.25f,
+	226.563f,
+	11.2847f,
+	-31.25f,
+	230.469f,
+	11.5946f,
+	-31.25f,
+	234.375f,
+	10.9216f,
+	-31.25f,
+	238.281f,
+	10.9182f,
+	-31.25f,
+	242.188f,
+	11.2826f,
+	-31.25f,
+	246.094f,
+	11.5781f,
+	-31.25f,
+	250.0f,
+	11.536f,
+	-31.25f,
+	3.90625f,
+	60.2212f,
+	-35.1563f,
+	7.8125f,
+	59.3731f,
+	-35.1563f,
+	11.7188f,
+	58.5327f,
+	-35.1563f,
+	15.625f,
+	59.5785f,
+	-35.1563f,
+	19.5313f,
+	60.1491f,
+	-35.1563f,
+	23.4375f,
+	60.5297f,
+	-35.1563f,
+	27.3438f,
+	60.5336f,
+	-35.1563f,
+	31.25f,
+	60.162f,
+	-35.1563f,
+	35.1563f,
+	58.5927f,
+	-35.1563f,
+	39.0625f,
+	57.9369f,
+	-35.1563f,
+	42.9688f,
+	58.4405f,
+	-35.1563f,
+	46.875f,
+	58.7374f,
+	-35.1563f,
+	50.7813f,
+	57.6198f,
+	-35.1563f,
+	54.6875f,
+	57.3277f,
+	-35.1563f,
+	58.5938f,
+	56.6423f,
+	-35.1563f,
+	62.5f,
+	56.2444f,
+	-35.1563f,
+	66.4063f,
+	56.132f,
+	-35.1563f,
+	70.3125f,
+	54.6673f,
+	-35.1563f,
+	74.2188f,
+	53.2924f,
+	-35.1563f,
+	78.125f,
+	53.2569f,
+	-35.1563f,
+	82.0313f,
+	52.0828f,
+	-35.1563f,
+	85.9375f,
+	51.9661f,
+	-35.1563f,
+	89.8438f,
+	50.9045f,
+	-35.1563f,
+	93.75f,
+	49.4997f,
+	-35.1563f,
+	97.6563f,
+	48.0748f,
+	-35.1563f,
+	101.563f,
+	46.3182f,
+	-35.1563f,
+	105.469f,
+	44.0878f,
+	-35.1563f,
+	109.375f,
+	42.863f,
+	-35.1563f,
+	113.281f,
+	42.8044f,
+	-35.1563f,
+	117.188f,
+	42.9648f,
+	-35.1563f,
+	121.094f,
+	42.3221f,
+	-35.1563f,
+	125.0f,
+	41.6576f,
+	-35.1563f,
+	128.906f,
+	41.1606f,
+	-35.1563f,
+	132.813f,
+	39.59f,
+	-35.1563f,
+	136.719f,
+	38.5602f,
+	-35.1563f,
+	140.625f,
+	37.9389f,
+	-35.1563f,
+	144.531f,
+	37.2602f,
+	-35.1563f,
+	148.438f,
+	37.3784f,
+	-35.1563f,
+	152.344f,
+	37.8906f,
+	-35.1563f,
+	156.25f,
+	37.8221f,
+	-35.1563f,
+	160.156f,
+	36.3088f,
+	-35.1563f,
+	164.063f,
+	35.1881f,
+	-35.1563f,
+	167.969f,
+	33.2601f,
+	-35.1563f,
+	171.875f,
+	31.8157f,
+	-35.1563f,
+	175.781f,
+	31.3416f,
+	-35.1563f,
+	179.688f,
+	30.0265f,
+	-35.1563f,
+	183.594f,
+	27.3943f,
+	-35.1563f,
+	187.5f,
+	24.641f,
+	-35.1563f,
+	191.406f,
+	22.2525f,
+	-35.1563f,
+	195.313f,
+	20.2011f,
+	-35.1563f,
+	199.219f,
+	18.7104f,
+	-35.1563f,
+	203.125f,
+	17.3459f,
+	-35.1563f,
+	207.031f,
+	15.2838f,
+	-35.1563f,
+	210.938f,
+	13.6157f,
+	-35.1563f,
+	214.844f,
+	13.3893f,
+	-35.1563f,
+	218.75f,
+	12.9319f,
+	-35.1563f,
+	222.656f,
+	11.5191f,
+	-35.1563f,
+	226.563f,
+	10.4878f,
+	-35.1563f,
+	230.469f,
+	9.83031f,
+	-35.1563f,
+	234.375f,
+	9.91945f,
+	-35.1563f,
+	238.281f,
+	10.9647f,
+	-35.1563f,
+	242.188f,
+	11.5866f,
+	-35.1563f,
+	246.094f,
+	11.8313f,
+	-35.1563f,
+	250.0f,
+	11.9419f,
+	-35.1563f,
+	3.90625f,
+	59.9094f,
+	-39.0625f,
+	7.8125f,
+	58.6207f,
+	-39.0625f,
+	11.7188f,
+	57.735f,
+	-39.0625f,
+	15.625f,
+	58.9909f,
+	-39.0625f,
+	19.5313f,
+	60.0678f,
+	-39.0625f,
+	23.4375f,
+	60.5419f,
+	-39.0625f,
+	27.3438f,
+	60.4672f,
+	-39.0625f,
+	31.25f,
+	59.5824f,
+	-39.0625f,
+	35.1563f,
+	58.4068f,
+	-39.0625f,
+	39.0625f,
+	57.5098f,
+	-39.0625f,
+	42.9688f,
+	57.6631f,
+	-39.0625f,
+	46.875f,
+	57.8211f,
+	-39.0625f,
+	50.7813f,
+	57.1897f,
+	-39.0625f,
+	54.6875f,
+	55.6789f,
+	-39.0625f,
+	58.5938f,
+	55.3212f,
+	-39.0625f,
+	62.5f,
+	55.2941f,
+	-39.0625f,
+	66.4063f,
+	55.8101f,
+	-39.0625f,
+	70.3125f,
+	54.309f,
+	-39.0625f,
+	74.2188f,
+	53.6313f,
+	-39.0625f,
+	78.125f,
+	52.7246f,
+	-39.0625f,
+	82.0313f,
+	51.5473f,
+	-39.0625f,
+	85.9375f,
+	51.5315f,
+	-39.0625f,
+	89.8438f,
+	50.6121f,
+	-39.0625f,
+	93.75f,
+	50.3734f,
+	-39.0625f,
+	97.6563f,
+	48.8877f,
+	-39.0625f,
+	101.563f,
+	47.0081f,
+	-39.0625f,
+	105.469f,
+	44.4827f,
+	-39.0625f,
+	109.375f,
+	43.5851f,
+	-39.0625f,
+	113.281f,
+	43.2668f,
+	-39.0625f,
+	117.188f,
+	43.4016f,
+	-39.0625f,
+	121.094f,
+	41.962f,
+	-39.0625f,
+	125.0f,
+	41.4641f,
+	-39.0625f,
+	128.906f,
+	40.2221f,
+	-39.0625f,
+	132.813f,
+	38.9234f,
+	-39.0625f,
+	136.719f,
+	37.7062f,
+	-39.0625f,
+	140.625f,
+	37.6455f,
+	-39.0625f,
+	144.531f,
+	37.8691f,
+	-39.0625f,
+	148.438f,
+	37.4139f,
+	-39.0625f,
+	152.344f,
+	37.204f,
+	-39.0625f,
+	156.25f,
+	36.7774f,
+	-39.0625f,
+	160.156f,
+	35.8962f,
+	-39.0625f,
+	164.063f,
+	34.5247f,
+	-39.0625f,
+	167.969f,
+	32.7322f,
+	-39.0625f,
+	171.875f,
+	32.1044f,
+	-39.0625f,
+	175.781f,
+	31.321f,
+	-39.0625f,
+	179.688f,
+	29.7775f,
+	-39.0625f,
+	183.594f,
+	26.7381f,
+	-39.0625f,
+	187.5f,
+	24.0216f,
+	-39.0625f,
+	191.406f,
+	22.277f,
+	-39.0625f,
+	195.313f,
+	21.2497f,
+	-39.0625f,
+	199.219f,
+	19.9529f,
+	-39.0625f,
+	203.125f,
+	18.3349f,
+	-39.0625f,
+	207.031f,
+	16.7961f,
+	-39.0625f,
+	210.938f,
+	15.071f,
+	-39.0625f,
+	214.844f,
+	13.5616f,
+	-39.0625f,
+	218.75f,
+	13.1679f,
+	-39.0625f,
+	222.656f,
+	11.2729f,
+	-39.0625f,
+	226.563f,
+	10.5025f,
+	-39.0625f,
+	230.469f,
+	9.72086f,
+	-39.0625f,
+	234.375f,
+	9.90489f,
+	-39.0625f,
+	238.281f,
+	10.7231f,
+	-39.0625f,
+	242.188f,
+	11.2573f,
+	-39.0625f,
+	246.094f,
+	12.0761f,
+	-39.0625f,
+	250.0f,
+	11.902f,
+	-39.0625f,
+	3.90625f,
+	59.5207f,
+	-42.9688f,
+	7.8125f,
+	58.2483f,
+	-42.9688f,
+	11.7188f,
+	58.069f,
+	-42.9688f,
+	15.625f,
+	59.4248f,
+	-42.9688f,
+	19.5313f,
+	60.5261f,
+	-42.9688f,
+	23.4375f,
+	60.668f,
+	-42.9688f,
+	27.3438f,
+	60.0252f,
+	-42.9688f,
+	31.25f,
+	58.0523f,
+	-42.9688f,
+	35.1563f,
+	56.7426f,
+	-42.9688f,
+	39.0625f,
+	57.2045f,
+	-42.9688f,
+	42.9688f,
+	57.166f,
+	-42.9688f,
+	46.875f,
+	56.9465f,
+	-42.9688f,
+	50.7813f,
+	55.7381f,
+	-42.9688f,
+	54.6875f,
+	55.2924f,
+	-42.9688f,
+	58.5938f,
+	54.6074f,
+	-42.9688f,
+	62.5f,
+	54.1882f,
+	-42.9688f,
+	66.4063f,
+	53.672f,
+	-42.9688f,
+	70.3125f,
+	53.3122f,
+	-42.9688f,
+	74.2188f,
+	53.0852f,
+	-42.9688f,
+	78.125f,
+	52.6173f,
+	-42.9688f,
+	82.0313f,
+	51.616f,
+	-42.9688f,
+	85.9375f,
+	50.148f,
+	-42.9688f,
+	89.8438f,
+	49.4823f,
+	-42.9688f,
+	93.75f,
+	50.0221f,
+	-42.9688f,
+	97.6563f,
+	48.9931f,
+	-42.9688f,
+	101.563f,
+	47.1045f,
+	-42.9688f,
+	105.469f,
+	44.442f,
+	-42.9688f,
+	109.375f,
+	44.5071f,
+	-42.9688f,
+	113.281f,
+	44.1005f,
+	-42.9688f,
+	117.188f,
+	42.8414f,
+	-42.9688f,
+	121.094f,
+	42.5419f,
+	-42.9688f,
+	125.0f,
+	41.5451f,
+	-42.9688f,
+	128.906f,
+	39.4272f,
+	-42.9688f,
+	132.813f,
+	39.8815f,
+	-42.9688f,
+	136.719f,
+	39.1366f,
+	-42.9688f,
+	140.625f,
+	38.7457f,
+	-42.9688f,
+	144.531f,
+	38.4257f,
+	-42.9688f,
+	148.438f,
+	37.9899f,
+	-42.9688f,
+	152.344f,
+	37.1716f,
+	-42.9688f,
+	156.25f,
+	36.0431f,
+	-42.9688f,
+	160.156f,
+	35.0784f,
+	-42.9688f,
+	164.063f,
+	33.3564f,
+	-42.9688f,
+	167.969f,
+	32.1522f,
+	-42.9688f,
+	171.875f,
+	30.9698f,
+	-42.9688f,
+	175.781f,
+	29.7186f,
+	-42.9688f,
+	179.688f,
+	28.0509f,
+	-42.9688f,
+	183.594f,
+	25.8254f,
+	-42.9688f,
+	187.5f,
+	24.8502f,
+	-42.9688f,
+	191.406f,
+	22.9031f,
+	-42.9688f,
+	195.313f,
+	20.8135f,
+	-42.9688f,
+	199.219f,
+	19.6651f,
+	-42.9688f,
+	203.125f,
+	18.4753f,
+	-42.9688f,
+	207.031f,
+	17.2259f,
+	-42.9688f,
+	210.938f,
+	15.6171f,
+	-42.9688f,
+	214.844f,
+	13.2953f,
+	-42.9688f,
+	218.75f,
+	13.1679f,
+	-42.9688f,
+	222.656f,
+	10.7772f,
+	-42.9688f,
+	226.563f,
+	9.62294f,
+	-42.9688f,
+	230.469f,
+	9.27609f,
+	-42.9688f,
+	234.375f,
+	9.47241f,
+	-42.9688f,
+	238.281f,
+	10.2411f,
+	-42.9688f,
+	242.188f,
+	11.3745f,
+	-42.9688f,
+	246.094f,
+	10.981f,
+	-42.9688f,
+	250.0f,
+	9.93179f,
+	-42.9688f,
+	3.90625f,
+	58.9086f,
+	-46.875f,
+	7.8125f,
+	58.895f,
+	-46.875f,
+	11.7188f,
+	59.1807f,
+	-46.875f,
+	15.625f,
+	60.2442f,
+	-46.875f,
+	19.5313f,
+	60.6114f,
+	-46.875f,
+	23.4375f,
+	59.9439f,
+	-46.875f,
+	27.3438f,
+	58.704f,
+	-46.875f,
+	31.25f,
+	58.3729f,
+	-46.875f,
+	35.1563f,
+	57.0256f,
+	-46.875f,
+	39.0625f,
+	57.069f,
+	-46.875f,
+	42.9688f,
+	57.0536f,
+	-46.875f,
+	46.875f,
+	55.7912f,
+	-46.875f,
+	50.7813f,
+	54.8674f,
+	-46.875f,
+	54.6875f,
+	53.8265f,
+	-46.875f,
+	58.5938f,
+	53.563f,
+	-46.875f,
+	62.5f,
+	52.5979f,
+	-46.875f,
+	66.4063f,
+	52.3986f,
+	-46.875f,
+	70.3125f,
+	52.1891f,
+	-46.875f,
+	74.2188f,
+	52.2468f,
+	-46.875f,
+	78.125f,
+	52.3398f,
+	-46.875f,
+	82.0313f,
+	50.9875f,
+	-46.875f,
+	85.9375f,
+	49.4072f,
+	-46.875f,
+	89.8438f,
+	48.3295f,
+	-46.875f,
+	93.75f,
+	48.9009f,
+	-46.875f,
+	97.6563f,
+	47.6633f,
+	-46.875f,
+	101.563f,
+	44.4101f,
+	-46.875f,
+	105.469f,
+	44.0249f,
+	-46.875f,
+	109.375f,
+	43.7395f,
+	-46.875f,
+	113.281f,
+	44.0967f,
+	-46.875f,
+	117.188f,
+	43.3593f,
+	-46.875f,
+	121.094f,
+	42.11f,
+	-46.875f,
+	125.0f,
+	40.8903f,
+	-46.875f,
+	128.906f,
+	40.3861f,
+	-46.875f,
+	132.813f,
+	40.075f,
+	-46.875f,
+	136.719f,
+	39.6347f,
+	-46.875f,
+	140.625f,
+	38.7369f,
+	-46.875f,
+	144.531f,
+	37.9042f,
+	-46.875f,
+	148.438f,
+	36.8546f,
+	-46.875f,
+	152.344f,
+	36.4012f,
+	-46.875f,
+	156.25f,
+	35.3977f,
+	-46.875f,
+	160.156f,
+	34.0947f,
+	-46.875f,
+	164.063f,
+	32.2545f,
+	-46.875f,
+	167.969f,
+	30.0086f,
+	-46.875f,
+	171.875f,
+	29.202f,
+	-46.875f,
+	175.781f,
+	28.0362f,
+	-46.875f,
+	179.688f,
+	26.7114f,
+	-46.875f,
+	183.594f,
+	25.9577f,
+	-46.875f,
+	187.5f,
+	25.3242f,
+	-46.875f,
+	191.406f,
+	23.8586f,
+	-46.875f,
+	195.313f,
+	20.6056f,
+	-46.875f,
+	199.219f,
+	19.3835f,
+	-46.875f,
+	203.125f,
+	17.4503f,
+	-46.875f,
+	207.031f,
+	16.5736f,
+	-46.875f,
+	210.938f,
+	14.945f,
+	-46.875f,
+	214.844f,
+	12.5914f,
+	-46.875f,
+	218.75f,
+	11.835f,
+	-46.875f,
+	222.656f,
+	10.1636f,
+	-46.875f,
+	226.563f,
+	9.71281f,
+	-46.875f,
+	230.469f,
+	9.27988f,
+	-46.875f,
+	234.375f,
+	8.50394f,
+	-46.875f,
+	238.281f,
+	9.20978f,
+	-46.875f,
+	242.188f,
+	9.21707f,
+	-46.875f,
+	246.094f,
+	9.40089f,
+	-46.875f,
+	250.0f,
+	8.55411f,
+	-46.875f,
+	3.90625f,
+	59.8509f,
+	-50.7813f,
+	7.8125f,
+	59.6141f,
+	-50.7813f,
+	11.7188f,
+	59.7453f,
+	-50.7813f,
+	15.625f,
+	60.4259f,
+	-50.7813f,
+	19.5313f,
+	59.4314f,
+	-50.7813f,
+	23.4375f,
+	59.033f,
+	-50.7813f,
+	27.3438f,
+	57.561f,
+	-50.7813f,
+	31.25f,
+	57.9511f,
+	-50.7813f,
+	35.1563f,
+	57.0088f,
+	-50.7813f,
+	39.0625f,
+	56.2469f,
+	-50.7813f,
+	42.9688f,
+	55.8604f,
+	-50.7813f,
+	46.875f,
+	55.2326f,
+	-50.7813f,
+	50.7813f,
+	54.8965f,
+	-50.7813f,
+	54.6875f,
+	53.1713f,
+	-50.7813f,
+	58.5938f,
+	52.6122f,
+	-50.7813f,
+	62.5f,
+	50.9097f,
+	-50.7813f,
+	66.4063f,
+	50.8144f,
+	-50.7813f,
+	70.3125f,
+	50.2702f,
+	-50.7813f,
+	74.2188f,
+	51.4962f,
+	-50.7813f,
+	78.125f,
+	50.7879f,
+	-50.7813f,
+	82.0313f,
+	49.5502f,
+	-50.7813f,
+	85.9375f,
+	48.3386f,
+	-50.7813f,
+	89.8438f,
+	48.0143f,
+	-50.7813f,
+	93.75f,
+	46.7527f,
+	-50.7813f,
+	97.6563f,
+	45.5374f,
+	-50.7813f,
+	101.563f,
+	44.3542f,
+	-50.7813f,
+	105.469f,
+	44.8366f,
+	-50.7813f,
+	109.375f,
+	45.0192f,
+	-50.7813f,
+	113.281f,
+	44.4763f,
+	-50.7813f,
+	117.188f,
+	43.4751f,
+	-50.7813f,
+	121.094f,
+	42.029f,
+	-50.7813f,
+	125.0f,
+	40.9708f,
+	-50.7813f,
+	128.906f,
+	40.3658f,
+	-50.7813f,
+	132.813f,
+	40.0768f,
+	-50.7813f,
+	136.719f,
+	40.0333f,
+	-50.7813f,
+	140.625f,
+	38.2667f,
+	-50.7813f,
+	144.531f,
+	36.5326f,
+	-50.7813f,
+	148.438f,
+	35.8183f,
+	-50.7813f,
+	152.344f,
+	35.3934f,
+	-50.7813f,
+	156.25f,
+	34.9787f,
+	-50.7813f,
+	160.156f,
+	33.4969f,
+	-50.7813f,
+	164.063f,
+	31.7517f,
+	-50.7813f,
+	167.969f,
+	29.499f,
+	-50.7813f,
+	171.875f,
+	27.1729f,
+	-50.7813f,
+	175.781f,
+	25.4931f,
+	-50.7813f,
+	179.688f,
+	25.2745f,
+	-50.7813f,
+	183.594f,
+	25.2315f,
+	-50.7813f,
+	187.5f,
+	24.531f,
+	-50.7813f,
+	191.406f,
+	23.4387f,
+	-50.7813f,
+	195.313f,
+	21.3665f,
+	-50.7813f,
+	199.219f,
+	19.2834f,
+	-50.7813f,
+	203.125f,
+	17.7694f,
+	-50.7813f,
+	207.031f,
+	16.0247f,
+	-50.7813f,
+	210.938f,
+	13.9451f,
+	-50.7813f,
+	214.844f,
+	12.3369f,
+	-50.7813f,
+	218.75f,
+	10.9033f,
+	-50.7813f,
+	222.656f,
+	10.0734f,
+	-50.7813f,
+	226.563f,
+	9.08212f,
+	-50.7813f,
+	230.469f,
+	9.04527f,
+	-50.7813f,
+	234.375f,
+	8.83458f,
+	-50.7813f,
+	238.281f,
+	9.03578f,
+	-50.7813f,
+	242.188f,
+	9.06782f,
+	-50.7813f,
+	246.094f,
+	9.03068f,
+	-50.7813f,
+	250.0f,
+	9.66685f,
+	-50.7813f,
+	3.90625f,
+	60.3928f,
+	-54.6875f,
+	7.8125f,
+	60.9235f,
+	-54.6875f,
+	11.7188f,
+	60.8946f,
+	-54.6875f,
+	15.625f,
+	60.5131f,
+	-54.6875f,
+	19.5313f,
+	58.455f,
+	-54.6875f,
+	23.4375f,
+	57.9712f,
+	-54.6875f,
+	27.3438f,
+	57.0716f,
+	-54.6875f,
+	31.25f,
+	56.9372f,
+	-54.6875f,
+	35.1563f,
+	57.5607f,
+	-54.6875f,
+	39.0625f,
+	56.6778f,
+	-54.6875f,
+	42.9688f,
+	56.24f,
+	-54.6875f,
+	46.875f,
+	55.0661f,
+	-54.6875f,
+	50.7813f,
+	54.3546f,
+	-54.6875f,
+	54.6875f,
+	52.1641f,
+	-54.6875f,
+	58.5938f,
+	51.2643f,
+	-54.6875f,
+	62.5f,
+	49.4484f,
+	-54.6875f,
+	66.4063f,
+	48.4401f,
+	-54.6875f,
+	70.3125f,
+	48.0181f,
+	-54.6875f,
+	74.2188f,
+	48.8036f,
+	-54.6875f,
+	78.125f,
+	48.2106f,
+	-54.6875f,
+	82.0313f,
+	47.8181f,
+	-54.6875f,
+	85.9375f,
+	47.3982f,
+	-54.6875f,
+	89.8438f,
+	46.4776f,
+	-54.6875f,
+	93.75f,
+	45.3848f,
+	-54.6875f,
+	97.6563f,
+	44.5336f,
+	-54.6875f,
+	101.563f,
+	45.1445f,
+	-54.6875f,
+	105.469f,
+	45.5775f,
+	-54.6875f,
+	109.375f,
+	45.4274f,
+	-54.6875f,
+	113.281f,
+	44.4184f,
+	-54.6875f,
+	117.188f,
+	43.6208f,
+	-54.6875f,
+	121.094f,
+	43.0133f,
+	-54.6875f,
+	125.0f,
+	41.2193f,
+	-54.6875f,
+	128.906f,
+	40.0465f,
+	-54.6875f,
+	132.813f,
+	40.3451f,
+	-54.6875f,
+	136.719f,
+	39.4272f,
+	-54.6875f,
+	140.625f,
+	37.2935f,
+	-54.6875f,
+	144.531f,
+	35.9597f,
+	-54.6875f,
+	148.438f,
+	34.766f,
+	-54.6875f,
+	152.344f,
+	33.3503f,
+	-54.6875f,
+	156.25f,
+	33.6732f,
+	-54.6875f,
+	160.156f,
+	32.5764f,
+	-54.6875f,
+	164.063f,
+	30.6942f,
+	-54.6875f,
+	167.969f,
+	28.8727f,
+	-54.6875f,
+	171.875f,
+	26.8203f,
+	-54.6875f,
+	175.781f,
+	24.7162f,
+	-54.6875f,
+	179.688f,
+	23.5533f,
+	-54.6875f,
+	183.594f,
+	23.5154f,
+	-54.6875f,
+	187.5f,
+	23.3554f,
+	-54.6875f,
+	191.406f,
+	22.7735f,
+	-54.6875f,
+	195.313f,
+	22.2741f,
+	-54.6875f,
+	199.219f,
+	20.9717f,
+	-54.6875f,
+	203.125f,
+	18.5469f,
+	-54.6875f,
+	207.031f,
+	16.0531f,
+	-54.6875f,
+	210.938f,
+	13.6058f,
+	-54.6875f,
+	214.844f,
+	11.0674f,
+	-54.6875f,
+	218.75f,
+	9.89862f,
+	-54.6875f,
+	222.656f,
+	9.6172f,
+	-54.6875f,
+	226.563f,
+	8.63026f,
+	-54.6875f,
+	230.469f,
+	8.95799f,
+	-54.6875f,
+	234.375f,
+	8.84522f,
+	-54.6875f,
+	238.281f,
+	8.9176f,
+	-54.6875f,
+	242.188f,
+	9.19248f,
+	-54.6875f,
+	246.094f,
+	9.16691f,
+	-54.6875f,
+	250.0f,
+	9.42022f,
+	-54.6875f,
+	3.90625f,
+	61.5747f,
+	-58.5938f,
+	7.8125f,
+	61.244f,
+	-58.5938f,
+	11.7188f,
+	60.3982f,
+	-58.5938f,
+	15.625f,
+	59.4267f,
+	-58.5938f,
+	19.5313f,
+	58.5294f,
+	-58.5938f,
+	23.4375f,
+	56.6412f,
+	-58.5938f,
+	27.3438f,
+	56.0648f,
+	-58.5938f,
+	31.25f,
+	56.4883f,
+	-58.5938f,
+	35.1563f,
+	56.5562f,
+	-58.5938f,
+	39.0625f,
+	56.745f,
+	-58.5938f,
+	42.9688f,
+	55.6505f,
+	-58.5938f,
+	46.875f,
+	54.6622f,
+	-58.5938f,
+	50.7813f,
+	53.7206f,
+	-58.5938f,
+	54.6875f,
+	51.9309f,
+	-58.5938f,
+	58.5938f,
+	50.4214f,
+	-58.5938f,
+	62.5f,
+	48.4353f,
+	-58.5938f,
+	66.4063f,
+	47.1373f,
+	-58.5938f,
+	70.3125f,
+	46.0037f,
+	-58.5938f,
+	74.2188f,
+	45.9795f,
+	-58.5938f,
+	78.125f,
+	45.2396f,
+	-58.5938f,
+	82.0313f,
+	45.264f,
+	-58.5938f,
+	85.9375f,
+	45.2603f,
+	-58.5938f,
+	89.8438f,
+	45.3076f,
+	-58.5938f,
+	93.75f,
+	44.8744f,
+	-58.5938f,
+	97.6563f,
+	44.3646f,
+	-58.5938f,
+	101.563f,
+	45.1043f,
+	-58.5938f,
+	105.469f,
+	45.6336f,
+	-58.5938f,
+	109.375f,
+	44.6129f,
+	-58.5938f,
+	113.281f,
+	44.3333f,
+	-58.5938f,
+	117.188f,
+	44.3267f,
+	-58.5938f,
+	121.094f,
+	42.9064f,
+	-58.5938f,
+	125.0f,
+	40.63f,
+	-58.5938f,
+	128.906f,
+	41.2828f,
+	-58.5938f,
+	132.813f,
+	40.2801f,
+	-58.5938f,
+	136.719f,
+	39.4089f,
+	-58.5938f,
+	140.625f,
+	37.0919f,
+	-58.5938f,
+	144.531f,
+	34.889f,
+	-58.5938f,
+	148.438f,
+	32.5161f,
+	-58.5938f,
+	152.344f,
+	31.9597f,
+	-58.5938f,
+	156.25f,
+	31.5986f,
+	-58.5938f,
+	160.156f,
+	31.1966f,
+	-58.5938f,
+	164.063f,
+	30.4149f,
+	-58.5938f,
+	167.969f,
+	29.0304f,
+	-58.5938f,
+	171.875f,
+	27.2929f,
+	-58.5938f,
+	175.781f,
+	26.0835f,
+	-58.5938f,
+	179.688f,
+	24.7373f,
+	-58.5938f,
+	183.594f,
+	23.6409f,
+	-58.5938f,
+	187.5f,
+	23.3059f,
+	-58.5938f,
+	191.406f,
+	22.8781f,
+	-58.5938f,
+	195.313f,
+	22.319f,
+	-58.5938f,
+	199.219f,
+	21.2986f,
+	-58.5938f,
+	203.125f,
+	19.8613f,
+	-58.5938f,
+	207.031f,
+	16.8941f,
+	-58.5938f,
+	210.938f,
+	13.7519f,
+	-58.5938f,
+	214.844f,
+	11.895f,
+	-58.5938f,
+	218.75f,
+	9.64673f,
+	-58.5938f,
+	222.656f,
+	9.27102f,
+	-58.5938f,
+	226.563f,
+	9.40316f,
+	-58.5938f,
+	230.469f,
+	8.90628f,
+	-58.5938f,
+	234.375f,
+	8.63691f,
+	-58.5938f,
+	238.281f,
+	9.10736f,
+	-58.5938f,
+	242.188f,
+	9.6506f,
+	-58.5938f,
+	246.094f,
+	9.20945f,
+	-58.5938f,
+	250.0f,
+	10.1973f,
+	-58.5938f,
+	3.90625f,
+	62.1111f,
+	-62.5f,
+	7.8125f,
+	60.6401f,
+	-62.5f,
+	11.7188f,
+	59.5734f,
+	-62.5f,
+	15.625f,
+	59.219f,
+	-62.5f,
+	19.5313f,
+	57.489f,
+	-62.5f,
+	23.4375f,
+	55.7813f,
+	-62.5f,
+	27.3438f,
+	55.9775f,
+	-62.5f,
+	31.25f,
+	55.9857f,
+	-62.5f,
+	35.1563f,
+	55.7053f,
+	-62.5f,
+	39.0625f,
+	55.9712f,
+	-62.5f,
+	42.9688f,
+	54.6904f,
+	-62.5f,
+	46.875f,
+	53.8065f,
+	-62.5f,
+	50.7813f,
+	52.4182f,
+	-62.5f,
+	54.6875f,
+	50.8531f,
+	-62.5f,
+	58.5938f,
+	49.1994f,
+	-62.5f,
+	62.5f,
+	47.7017f,
+	-62.5f,
+	66.4063f,
+	45.469f,
+	-62.5f,
+	70.3125f,
+	44.3384f,
+	-62.5f,
+	74.2188f,
+	43.2272f,
+	-62.5f,
+	78.125f,
+	43.8591f,
+	-62.5f,
+	82.0313f,
+	44.3452f,
+	-62.5f,
+	85.9375f,
+	44.3048f,
+	-62.5f,
+	89.8438f,
+	44.2242f,
+	-62.5f,
+	93.75f,
+	44.0587f,
+	-62.5f,
+	97.6563f,
+	43.7317f,
+	-62.5f,
+	101.563f,
+	44.5392f,
+	-62.5f,
+	105.469f,
+	44.5257f,
+	-62.5f,
+	109.375f,
+	43.5595f,
+	-62.5f,
+	113.281f,
+	44.5114f,
+	-62.5f,
+	117.188f,
+	43.2895f,
+	-62.5f,
+	121.094f,
+	41.6188f,
+	-62.5f,
+	125.0f,
+	39.9989f,
+	-62.5f,
+	128.906f,
+	40.9613f,
+	-62.5f,
+	132.813f,
+	39.8454f,
+	-62.5f,
+	136.719f,
+	38.9499f,
+	-62.5f,
+	140.625f,
+	36.7405f,
+	-62.5f,
+	144.531f,
+	34.8983f,
+	-62.5f,
+	148.438f,
+	33.5172f,
+	-62.5f,
+	152.344f,
+	31.5497f,
+	-62.5f,
+	156.25f,
+	31.3001f,
+	-62.5f,
+	160.156f,
+	30.8035f,
+	-62.5f,
+	164.063f,
+	30.3361f,
+	-62.5f,
+	167.969f,
+	29.7129f,
+	-62.5f,
+	171.875f,
+	28.9356f,
+	-62.5f,
+	175.781f,
+	27.3605f,
+	-62.5f,
+	179.688f,
+	26.5354f,
+	-62.5f,
+	183.594f,
+	25.1923f,
+	-62.5f,
+	187.5f,
+	23.8745f,
+	-62.5f,
+	191.406f,
+	22.6444f,
+	-62.5f,
+	195.313f,
+	22.0412f,
+	-62.5f,
+	199.219f,
+	20.9675f,
+	-62.5f,
+	203.125f,
+	18.5243f,
+	-62.5f,
+	207.031f,
+	15.5154f,
+	-62.5f,
+	210.938f,
+	13.2419f,
+	-62.5f,
+	214.844f,
+	11.0082f,
+	-62.5f,
+	218.75f,
+	9.92645f,
+	-62.5f,
+	222.656f,
+	9.66787f,
+	-62.5f,
+	226.563f,
+	10.141f,
+	-62.5f,
+	230.469f,
+	9.5559f,
+	-62.5f,
+	234.375f,
+	8.93799f,
+	-62.5f,
+	238.281f,
+	9.36179f,
+	-62.5f,
+	242.188f,
+	9.32325f,
+	-62.5f,
+	246.094f,
+	9.89448f,
+	-62.5f,
+	250.0f,
+	11.3062f,
+	-62.5f,
+	3.90625f,
+	60.8569f,
+	-66.4063f,
+	7.8125f,
+	59.3087f,
+	-66.4063f,
+	11.7188f,
+	58.6192f,
+	-66.4063f,
+	15.625f,
+	57.567f,
+	-66.4063f,
+	19.5313f,
+	54.6351f,
+	-66.4063f,
+	23.4375f,
+	53.6183f,
+	-66.4063f,
+	27.3438f,
+	54.0844f,
+	-66.4063f,
+	31.25f,
+	54.4962f,
+	-66.4063f,
+	35.1563f,
+	53.9539f,
+	-66.4063f,
+	39.0625f,
+	53.4324f,
+	-66.4063f,
+	42.9688f,
+	52.6655f,
+	-66.4063f,
+	46.875f,
+	51.9681f,
+	-66.4063f,
+	50.7813f,
+	51.1623f,
+	-66.4063f,
+	54.6875f,
+	50.0114f,
+	-66.4063f,
+	58.5938f,
+	47.9598f,
+	-66.4063f,
+	62.5f,
+	46.2999f,
+	-66.4063f,
+	66.4063f,
+	44.4466f,
+	-66.4063f,
+	70.3125f,
+	42.2001f,
+	-66.4063f,
+	74.2188f,
+	41.2192f,
+	-66.4063f,
+	78.125f,
+	41.7209f,
+	-66.4063f,
+	82.0313f,
+	42.7363f,
+	-66.4063f,
+	85.9375f,
+	42.9552f,
+	-66.4063f,
+	89.8438f,
+	43.0346f,
+	-66.4063f,
+	93.75f,
+	43.4604f,
+	-66.4063f,
+	97.6563f,
+	42.6437f,
+	-66.4063f,
+	101.563f,
+	42.6894f,
+	-66.4063f,
+	105.469f,
+	43.1054f,
+	-66.4063f,
+	109.375f,
+	42.7138f,
+	-66.4063f,
+	113.281f,
+	42.4744f,
+	-66.4063f,
+	117.188f,
+	42.2299f,
+	-66.4063f,
+	121.094f,
+	41.2421f,
+	-66.4063f,
+	125.0f,
+	40.3737f,
+	-66.4063f,
+	128.906f,
+	40.1758f,
+	-66.4063f,
+	132.813f,
+	39.5421f,
+	-66.4063f,
+	136.719f,
+	39.0437f,
+	-66.4063f,
+	140.625f,
+	37.1531f,
+	-66.4063f,
+	144.531f,
+	34.9841f,
+	-66.4063f,
+	148.438f,
+	33.2713f,
+	-66.4063f,
+	152.344f,
+	32.4185f,
+	-66.4063f,
+	156.25f,
+	31.779f,
+	-66.4063f,
+	160.156f,
+	30.7377f,
+	-66.4063f,
+	164.063f,
+	30.5524f,
+	-66.4063f,
+	167.969f,
+	29.5693f,
+	-66.4063f,
+	171.875f,
+	28.9756f,
+	-66.4063f,
+	175.781f,
+	27.4499f,
+	-66.4063f,
+	179.688f,
+	26.7907f,
+	-66.4063f,
+	183.594f,
+	25.5886f,
+	-66.4063f,
+	187.5f,
+	24.2807f,
+	-66.4063f,
+	191.406f,
+	22.1754f,
+	-66.4063f,
+	195.313f,
+	20.7766f,
+	-66.4063f,
+	199.219f,
+	19.914f,
+	-66.4063f,
+	203.125f,
+	17.149f,
+	-66.4063f,
+	207.031f,
+	14.0043f,
+	-66.4063f,
+	210.938f,
+	11.404f,
+	-66.4063f,
+	214.844f,
+	10.0012f,
+	-66.4063f,
+	218.75f,
+	8.65109f,
+	-66.4063f,
+	222.656f,
+	9.38897f,
+	-66.4063f,
+	226.563f,
+	9.4612f,
+	-66.4063f,
+	230.469f,
+	8.86613f,
+	-66.4063f,
+	234.375f,
+	8.68429f,
+	-66.4063f,
+	238.281f,
+	9.75985f,
+	-66.4063f,
+	242.188f,
+	10.3807f,
+	-66.4063f,
+	246.094f,
+	10.966f,
+	-66.4063f,
+	250.0f,
+	11.4354f,
+	-66.4063f,
+	3.90625f,
+	59.1482f,
+	-70.3125f,
+	7.8125f,
+	57.7892f,
+	-70.3125f,
+	11.7188f,
+	55.5839f,
+	-70.3125f,
+	15.625f,
+	54.3451f,
+	-70.3125f,
+	19.5313f,
+	52.0576f,
+	-70.3125f,
+	23.4375f,
+	50.5935f,
+	-70.3125f,
+	27.3438f,
+	50.8648f,
+	-70.3125f,
+	31.25f,
+	51.3182f,
+	-70.3125f,
+	35.1563f,
+	51.6726f,
+	-70.3125f,
+	39.0625f,
+	51.1264f,
+	-70.3125f,
+	42.9688f,
+	51.6239f,
+	-70.3125f,
+	46.875f,
+	49.728f,
+	-70.3125f,
+	50.7813f,
+	48.7924f,
+	-70.3125f,
+	54.6875f,
+	47.3884f,
+	-70.3125f,
+	58.5938f,
+	46.4477f,
+	-70.3125f,
+	62.5f,
+	45.2447f,
+	-70.3125f,
+	66.4063f,
+	42.8677f,
+	-70.3125f,
+	70.3125f,
+	40.9023f,
+	-70.3125f,
+	74.2188f,
+	39.5284f,
+	-70.3125f,
+	78.125f,
+	39.6524f,
+	-70.3125f,
+	82.0313f,
+	40.5173f,
+	-70.3125f,
+	85.9375f,
+	41.0204f,
+	-70.3125f,
+	89.8438f,
+	41.9366f,
+	-70.3125f,
+	93.75f,
+	42.1341f,
+	-70.3125f,
+	97.6563f,
+	41.4699f,
+	-70.3125f,
+	101.563f,
+	40.6754f,
+	-70.3125f,
+	105.469f,
+	41.2206f,
+	-70.3125f,
+	109.375f,
+	40.9668f,
+	-70.3125f,
+	113.281f,
+	41.1079f,
+	-70.3125f,
+	117.188f,
+	40.7056f,
+	-70.3125f,
+	121.094f,
+	39.8305f,
+	-70.3125f,
+	125.0f,
+	40.959f,
+	-70.3125f,
+	128.906f,
+	41.7481f,
+	-70.3125f,
+	132.813f,
+	41.1255f,
+	-70.3125f,
+	136.719f,
+	39.8634f,
+	-70.3125f,
+	140.625f,
+	37.8454f,
+	-70.3125f,
+	144.531f,
+	35.3914f,
+	-70.3125f,
+	148.438f,
+	33.8462f,
+	-70.3125f,
+	152.344f,
+	33.0994f,
+	-70.3125f,
+	156.25f,
+	32.4757f,
+	-70.3125f,
+	160.156f,
+	31.4779f,
+	-70.3125f,
+	164.063f,
+	29.4211f,
+	-70.3125f,
+	167.969f,
+	28.0779f,
+	-70.3125f,
+	171.875f,
+	27.802f,
+	-70.3125f,
+	175.781f,
+	26.7406f,
+	-70.3125f,
+	179.688f,
+	25.4777f,
+	-70.3125f,
+	183.594f,
+	24.7569f,
+	-70.3125f,
+	187.5f,
+	22.9331f,
+	-70.3125f,
+	191.406f,
+	21.2419f,
+	-70.3125f,
+	195.313f,
+	19.5082f,
+	-70.3125f,
+	199.219f,
+	17.6022f,
+	-70.3125f,
+	203.125f,
+	15.316f,
+	-70.3125f,
+	207.031f,
+	12.7546f,
+	-70.3125f,
+	210.938f,
+	10.3646f,
+	-70.3125f,
+	214.844f,
+	8.2502f,
+	-70.3125f,
+	218.75f,
+	8.14317f,
+	-70.3125f,
+	222.656f,
+	8.65089f,
+	-70.3125f,
+	226.563f,
+	8.60005f,
+	-70.3125f,
+	230.469f,
+	8.58165f,
+	-70.3125f,
+	234.375f,
+	9.40162f,
+	-70.3125f,
+	238.281f,
+	9.96281f,
+	-70.3125f,
+	242.188f,
+	9.81934f,
+	-70.3125f,
+	246.094f,
+	10.3078f,
+	-70.3125f,
+	250.0f,
+	10.4404f,
+	-70.3125f,
+	3.90625f,
+	56.5167f,
+	-74.2188f,
+	7.8125f,
+	55.7237f,
+	-74.2188f,
+	11.7188f,
+	53.4039f,
+	-74.2188f,
+	15.625f,
+	51.0313f,
+	-74.2188f,
+	19.5313f,
+	49.1141f,
+	-74.2188f,
+	23.4375f,
+	47.8398f,
+	-74.2188f,
+	27.3438f,
+	47.778f,
+	-74.2188f,
+	31.25f,
+	48.3917f,
+	-74.2188f,
+	35.1563f,
+	48.2503f,
+	-74.2188f,
+	39.0625f,
+	49.1497f,
+	-74.2188f,
+	42.9688f,
+	48.8224f,
+	-74.2188f,
+	46.875f,
+	47.4358f,
+	-74.2188f,
+	50.7813f,
+	47.051f,
+	-74.2188f,
+	54.6875f,
+	45.4218f,
+	-74.2188f,
+	58.5938f,
+	44.3385f,
+	-74.2188f,
+	62.5f,
+	42.9758f,
+	-74.2188f,
+	66.4063f,
+	41.4743f,
+	-74.2188f,
+	70.3125f,
+	39.4251f,
+	-74.2188f,
+	74.2188f,
+	37.5972f,
+	-74.2188f,
+	78.125f,
+	37.8246f,
+	-74.2188f,
+	82.0313f,
+	38.9578f,
+	-74.2188f,
+	85.9375f,
+	40.148f,
+	-74.2188f,
+	89.8438f,
+	41.1035f,
+	-74.2188f,
+	93.75f,
+	40.631f,
+	-74.2188f,
+	97.6563f,
+	40.0863f,
+	-74.2188f,
+	101.563f,
+	40.3273f,
+	-74.2188f,
+	105.469f,
+	40.0413f,
+	-74.2188f,
+	109.375f,
+	40.0514f,
+	-74.2188f,
+	113.281f,
+	39.4849f,
+	-74.2188f,
+	117.188f,
+	39.5903f,
+	-74.2188f,
+	121.094f,
+	40.1543f,
+	-74.2188f,
+	125.0f,
+	40.3424f,
+	-74.2188f,
+	128.906f,
+	41.779f,
+	-74.2188f,
+	132.813f,
+	41.4976f,
+	-74.2188f,
+	136.719f,
+	41.1475f,
+	-74.2188f,
+	140.625f,
+	38.8105f,
+	-74.2188f,
+	144.531f,
+	35.834f,
+	-74.2188f,
+	148.438f,
+	34.6385f,
+	-74.2188f,
+	152.344f,
+	33.7088f,
+	-74.2188f,
+	156.25f,
+	32.7137f,
+	-74.2188f,
+	160.156f,
+	30.7745f,
+	-74.2188f,
+	164.063f,
+	28.172f,
+	-74.2188f,
+	167.969f,
+	27.1433f,
+	-74.2188f,
+	171.875f,
+	26.7248f,
+	-74.2188f,
+	175.781f,
+	25.7807f,
+	-74.2188f,
+	179.688f,
+	24.8758f,
+	-74.2188f,
+	183.594f,
+	23.4994f,
+	-74.2188f,
+	187.5f,
+	23.3209f,
+	-74.2188f,
+	191.406f,
+	22.3523f,
+	-74.2188f,
+	195.313f,
+	20.3275f,
+	-74.2188f,
+	199.219f,
+	17.2927f,
+	-74.2188f,
+	203.125f,
+	15.0486f,
+	-74.2188f,
+	207.031f,
+	12.2721f,
+	-74.2188f,
+	210.938f,
+	9.60109f,
+	-74.2188f,
+	214.844f,
+	7.36411f,
+	-74.2188f,
+	218.75f,
+	7.27514f,
+	-74.2188f,
+	222.656f,
+	8.35951f,
+	-74.2188f,
+	226.563f,
+	8.18334f,
+	-74.2188f,
+	230.469f,
+	8.98708f,
+	-74.2188f,
+	234.375f,
+	8.98011f,
+	-74.2188f,
+	238.281f,
+	9.03329f,
+	-74.2188f,
+	242.188f,
+	8.88664f,
+	-74.2188f,
+	246.094f,
+	8.62938f,
+	-74.2188f,
+	250.0f,
+	9.6823f,
+	-74.2188f,
+	3.90625f,
+	54.4402f,
+	-78.125f,
+	7.8125f,
+	53.0525f,
+	-78.125f,
+	11.7188f,
+	51.2204f,
+	-78.125f,
+	15.625f,
+	48.7251f,
+	-78.125f,
+	19.5313f,
+	45.9841f,
+	-78.125f,
+	23.4375f,
+	45.0227f,
+	-78.125f,
+	27.3438f,
+	45.3099f,
+	-78.125f,
+	31.25f,
+	45.9225f,
+	-78.125f,
+	35.1563f,
+	46.8025f,
+	-78.125f,
+	39.0625f,
+	46.8434f,
+	-78.125f,
+	42.9688f,
+	46.0024f,
+	-78.125f,
+	46.875f,
+	45.6669f,
+	-78.125f,
+	50.7813f,
+	45.4624f,
+	-78.125f,
+	54.6875f,
+	43.4573f,
+	-78.125f,
+	58.5938f,
+	42.1273f,
+	-78.125f,
+	62.5f,
+	41.0088f,
+	-78.125f,
+	66.4063f,
+	38.8967f,
+	-78.125f,
+	70.3125f,
+	38.002f,
+	-78.125f,
+	74.2188f,
+	36.5282f,
+	-78.125f,
+	78.125f,
+	37.0499f,
+	-78.125f,
+	82.0313f,
+	37.3419f,
+	-78.125f,
+	85.9375f,
+	38.6056f,
+	-78.125f,
+	89.8438f,
+	39.7527f,
+	-78.125f,
+	93.75f,
+	40.3513f,
+	-78.125f,
+	97.6563f,
+	40.6919f,
+	-78.125f,
+	101.563f,
+	40.7736f,
+	-78.125f,
+	105.469f,
+	40.3007f,
+	-78.125f,
+	109.375f,
+	39.3023f,
+	-78.125f,
+	113.281f,
+	39.1369f,
+	-78.125f,
+	117.188f,
+	39.884f,
+	-78.125f,
+	121.094f,
+	40.5674f,
+	-78.125f,
+	125.0f,
+	40.8192f,
+	-78.125f,
+	128.906f,
+	41.893f,
+	-78.125f,
+	132.813f,
+	42.3647f,
+	-78.125f,
+	136.719f,
+	41.2455f,
+	-78.125f,
+	140.625f,
+	38.7064f,
+	-78.125f,
+	144.531f,
+	36.9679f,
+	-78.125f,
+	148.438f,
+	36.03f,
+	-78.125f,
+	152.344f,
+	33.9946f,
+	-78.125f,
+	156.25f,
+	32.2274f,
+	-78.125f,
+	160.156f,
+	30.474f,
+	-78.125f,
+	164.063f,
+	28.4739f,
+	-78.125f,
+	167.969f,
+	27.222f,
+	-78.125f,
+	171.875f,
+	26.6935f,
+	-78.125f,
+	175.781f,
+	25.0624f,
+	-78.125f,
+	179.688f,
+	24.162f,
+	-78.125f,
+	183.594f,
+	24.0176f,
+	-78.125f,
+	187.5f,
+	24.0379f,
+	-78.125f,
+	191.406f,
+	22.4301f,
+	-78.125f,
+	195.313f,
+	19.7078f,
+	-78.125f,
+	199.219f,
+	17.0911f,
+	-78.125f,
+	203.125f,
+	14.784f,
+	-78.125f,
+	207.031f,
+	11.8835f,
+	-78.125f,
+	210.938f,
+	9.34715f,
+	-78.125f,
+	214.844f,
+	7.23075f,
+	-78.125f,
+	218.75f,
+	7.91637f,
+	-78.125f,
+	222.656f,
+	8.69702f,
+	-78.125f,
+	226.563f,
+	8.56112f,
+	-78.125f,
+	230.469f,
+	9.86446f,
+	-78.125f,
+	234.375f,
+	9.26431f,
+	-78.125f,
+	238.281f,
+	8.47473f,
+	-78.125f,
+	242.188f,
+	7.8386f,
+	-78.125f,
+	246.094f,
+	7.82236f,
+	-78.125f,
+	250.0f,
+	8.68625f,
+	-78.125f,
+	3.90625f,
+	51.949f,
+	-82.0313f,
+	7.8125f,
+	50.1159f,
+	-82.0313f,
+	11.7188f,
+	48.9067f,
+	-82.0313f,
+	15.625f,
+	46.6417f,
+	-82.0313f,
+	19.5313f,
+	44.5725f,
+	-82.0313f,
+	23.4375f,
+	43.435f,
+	-82.0313f,
+	27.3438f,
+	43.6749f,
+	-82.0313f,
+	31.25f,
+	44.8399f,
+	-82.0313f,
+	35.1563f,
+	45.0253f,
+	-82.0313f,
+	39.0625f,
+	44.7335f,
+	-82.0313f,
+	42.9688f,
+	44.4485f,
+	-82.0313f,
+	46.875f,
+	44.8284f,
+	-82.0313f,
+	50.7813f,
+	43.5547f,
+	-82.0313f,
+	54.6875f,
+	41.2266f,
+	-82.0313f,
+	58.5938f,
+	40.4716f,
+	-82.0313f,
+	62.5f,
+	38.4361f,
+	-82.0313f,
+	66.4063f,
+	36.3554f,
+	-82.0313f,
+	70.3125f,
+	35.5722f,
+	-82.0313f,
+	74.2188f,
+	35.0069f,
+	-82.0313f,
+	78.125f,
+	35.8289f,
+	-82.0313f,
+	82.0313f,
+	37.0933f,
+	-82.0313f,
+	85.9375f,
+	38.1008f,
+	-82.0313f,
+	89.8438f,
+	38.9582f,
+	-82.0313f,
+	93.75f,
+	40.0751f,
+	-82.0313f,
+	97.6563f,
+	40.3989f,
+	-82.0313f,
+	101.563f,
+	40.2487f,
+	-82.0313f,
+	105.469f,
+	39.9234f,
+	-82.0313f,
+	109.375f,
+	40.0277f,
+	-82.0313f,
+	113.281f,
+	40.6647f,
+	-82.0313f,
+	117.188f,
+	40.69f,
+	-82.0313f,
+	121.094f,
+	40.7857f,
+	-82.0313f,
+	125.0f,
+	41.5688f,
+	-82.0313f,
+	128.906f,
+	41.836f,
+	-82.0313f,
+	132.813f,
+	41.6054f,
+	-82.0313f,
+	136.719f,
+	39.6237f,
+	-82.0313f,
+	140.625f,
+	38.6765f,
+	-82.0313f,
+	144.531f,
+	36.9959f,
+	-82.0313f,
+	148.438f,
+	35.8215f,
+	-82.0313f,
+	152.344f,
+	34.799f,
+	-82.0313f,
+	156.25f,
+	33.2398f,
+	-82.0313f,
+	160.156f,
+	30.7864f,
+	-82.0313f,
+	164.063f,
+	28.6776f,
+	-82.0313f,
+	167.969f,
+	26.6558f,
+	-82.0313f,
+	171.875f,
+	25.8282f,
+	-82.0313f,
+	175.781f,
+	24.7932f,
+	-82.0313f,
+	179.688f,
+	22.3283f,
+	-82.0313f,
+	183.594f,
+	23.1666f,
+	-82.0313f,
+	187.5f,
+	23.1721f,
+	-82.0313f,
+	191.406f,
+	21.3358f,
+	-82.0313f,
+	195.313f,
+	18.8226f,
+	-82.0313f,
+	199.219f,
+	16.5471f,
+	-82.0313f,
+	203.125f,
+	14.4667f,
+	-82.0313f,
+	207.031f,
+	11.1533f,
+	-82.0313f,
+	210.938f,
+	8.28389f,
+	-82.0313f,
+	214.844f,
+	8.02411f,
+	-82.0313f,
+	218.75f,
+	8.03784f,
+	-82.0313f,
+	222.656f,
+	8.27638f,
+	-82.0313f,
+	226.563f,
+	8.14824f,
+	-82.0313f,
+	230.469f,
+	8.45286f,
+	-82.0313f,
+	234.375f,
+	8.21959f,
+	-82.0313f,
+	238.281f,
+	8.25224f,
+	-82.0313f,
+	242.188f,
+	7.67129f,
+	-82.0313f,
+	246.094f,
+	8.04143f,
+	-82.0313f,
+	250.0f,
+	8.6199f,
+	-82.0313f,
+	3.90625f,
+	50.007f,
+	-85.9375f,
+	7.8125f,
+	48.4593f,
+	-85.9375f,
+	11.7188f,
+	46.0233f,
+	-85.9375f,
+	15.625f,
+	44.0556f,
+	-85.9375f,
+	19.5313f,
+	42.3324f,
+	-85.9375f,
+	23.4375f,
+	41.8982f,
+	-85.9375f,
+	27.3438f,
+	42.3931f,
+	-85.9375f,
+	31.25f,
+	43.1153f,
+	-85.9375f,
+	35.1563f,
+	43.1285f,
+	-85.9375f,
+	39.0625f,
+	43.422f,
+	-85.9375f,
+	42.9688f,
+	43.5417f,
+	-85.9375f,
+	46.875f,
+	42.2294f,
+	-85.9375f,
+	50.7813f,
+	40.9068f,
+	-85.9375f,
+	54.6875f,
+	39.4177f,
+	-85.9375f,
+	58.5938f,
+	37.2575f,
+	-85.9375f,
+	62.5f,
+	35.2254f,
+	-85.9375f,
+	66.4063f,
+	33.8821f,
+	-85.9375f,
+	70.3125f,
+	33.1531f,
+	-85.9375f,
+	74.2188f,
+	34.2747f,
+	-85.9375f,
+	78.125f,
+	35.599f,
+	-85.9375f,
+	82.0313f,
+	37.007f,
+	-85.9375f,
+	85.9375f,
+	37.5018f,
+	-85.9375f,
+	89.8438f,
+	38.1376f,
+	-85.9375f,
+	93.75f,
+	38.9449f,
+	-85.9375f,
+	97.6563f,
+	38.9221f,
+	-85.9375f,
+	101.563f,
+	38.8555f,
+	-85.9375f,
+	105.469f,
+	39.5572f,
+	-85.9375f,
+	109.375f,
+	40.1231f,
+	-85.9375f,
+	113.281f,
+	40.7416f,
+	-85.9375f,
+	117.188f,
+	40.3888f,
+	-85.9375f,
+	121.094f,
+	40.6715f,
+	-85.9375f,
+	125.0f,
+	40.7246f,
+	-85.9375f,
+	128.906f,
+	40.6124f,
+	-85.9375f,
+	132.813f,
+	39.685f,
+	-85.9375f,
+	136.719f,
+	39.2043f,
+	-85.9375f,
+	140.625f,
+	38.1816f,
+	-85.9375f,
+	144.531f,
+	36.598f,
+	-85.9375f,
+	148.438f,
+	36.2907f,
+	-85.9375f,
+	152.344f,
+	34.8832f,
+	-85.9375f,
+	156.25f,
+	33.4024f,
+	-85.9375f,
+	160.156f,
+	31.2463f,
+	-85.9375f,
+	164.063f,
+	29.1669f,
+	-85.9375f,
+	167.969f,
+	26.7298f,
+	-85.9375f,
+	171.875f,
+	24.3407f,
+	-85.9375f,
+	175.781f,
+	23.4854f,
+	-85.9375f,
+	179.688f,
+	21.3474f,
+	-85.9375f,
+	183.594f,
+	21.2953f,
+	-85.9375f,
+	187.5f,
+	21.7398f,
+	-85.9375f,
+	191.406f,
+	20.4218f,
+	-85.9375f,
+	195.313f,
+	17.9433f,
+	-85.9375f,
+	199.219f,
+	15.3133f,
+	-85.9375f,
+	203.125f,
+	13.0586f,
+	-85.9375f,
+	207.031f,
+	9.24996f,
+	-85.9375f,
+	210.938f,
+	7.18408f,
+	-85.9375f,
+	214.844f,
+	7.59758f,
+	-85.9375f,
+	218.75f,
+	8.04641f,
+	-85.9375f,
+	222.656f,
+	8.01634f,
+	-85.9375f,
+	226.563f,
+	7.95015f,
+	-85.9375f,
+	230.469f,
+	7.86343f,
+	-85.9375f,
+	234.375f,
+	6.21751f,
+	-85.9375f,
+	238.281f,
+	7.40112f,
+	-85.9375f,
+	242.188f,
+	7.60481f,
+	-85.9375f,
+	246.094f,
+	6.77129f,
+	-85.9375f,
+	250.0f,
+	7.87753f,
+	-85.9375f,
+	3.90625f,
+	47.6596f,
+	-89.8438f,
+	7.8125f,
+	45.9136f,
+	-89.8438f,
+	11.7188f,
+	44.0495f,
+	-89.8438f,
+	15.625f,
+	42.5127f,
+	-89.8438f,
+	19.5313f,
+	41.5996f,
+	-89.8438f,
+	23.4375f,
+	41.2638f,
+	-89.8438f,
+	27.3438f,
+	41.2672f,
+	-89.8438f,
+	31.25f,
+	41.5402f,
+	-89.8438f,
+	35.1563f,
+	42.558f,
+	-89.8438f,
+	39.0625f,
+	42.49f,
+	-89.8438f,
+	42.9688f,
+	42.2839f,
+	-89.8438f,
+	46.875f,
+	40.9401f,
+	-89.8438f,
+	50.7813f,
+	38.7346f,
+	-89.8438f,
+	54.6875f,
+	36.624f,
+	-89.8438f,
+	58.5938f,
+	35.1978f,
+	-89.8438f,
+	62.5f,
+	34.9272f,
+	-89.8438f,
+	66.4063f,
+	32.893f,
+	-89.8438f,
+	70.3125f,
+	32.4101f,
+	-89.8438f,
+	74.2188f,
+	33.9814f,
+	-89.8438f,
+	78.125f,
+	35.8825f,
+	-89.8438f,
+	82.0313f,
+	37.1245f,
+	-89.8438f,
+	85.9375f,
+	37.3954f,
+	-89.8438f,
+	89.8438f,
+	38.0118f,
+	-89.8438f,
+	93.75f,
+	37.5426f,
+	-89.8438f,
+	97.6563f,
+	38.0776f,
+	-89.8438f,
+	101.563f,
+	37.9785f,
+	-89.8438f,
+	105.469f,
+	38.6389f,
+	-89.8438f,
+	109.375f,
+	39.284f,
+	-89.8438f,
+	113.281f,
+	40.0027f,
+	-89.8438f,
+	117.188f,
+	41.2412f,
+	-89.8438f,
+	121.094f,
+	41.2301f,
+	-89.8438f,
+	125.0f,
+	40.7611f,
+	-89.8438f,
+	128.906f,
+	39.7426f,
+	-89.8438f,
+	132.813f,
+	39.1387f,
+	-89.8438f,
+	136.719f,
+	38.499f,
+	-89.8438f,
+	140.625f,
+	37.714f,
+	-89.8438f,
+	144.531f,
+	36.6379f,
+	-89.8438f,
+	148.438f,
+	36.1196f,
+	-89.8438f,
+	152.344f,
+	35.7001f,
+	-89.8438f,
+	156.25f,
+	33.9038f,
+	-89.8438f,
+	160.156f,
+	32.0706f,
+	-89.8438f,
+	164.063f,
+	29.746f,
+	-89.8438f,
+	167.969f,
+	26.4482f,
+	-89.8438f,
+	171.875f,
+	23.8046f,
+	-89.8438f,
+	175.781f,
+	21.9675f,
+	-89.8438f,
+	179.688f,
+	20.7011f,
+	-89.8438f,
+	183.594f,
+	20.6699f,
+	-89.8438f,
+	187.5f,
+	20.1508f,
+	-89.8438f,
+	191.406f,
+	17.8245f,
+	-89.8438f,
+	195.313f,
+	16.2785f,
+	-89.8438f,
+	199.219f,
+	13.4596f,
+	-89.8438f,
+	203.125f,
+	9.54647f,
+	-89.8438f,
+	207.031f,
+	6.02727f,
+	-89.8438f,
+	210.938f,
+	5.88903f,
+	-89.8438f,
+	214.844f,
+	6.47568f,
+	-89.8438f,
+	218.75f,
+	6.20004f,
+	-89.8438f,
+	222.656f,
+	6.0849f,
+	-89.8438f,
+	226.563f,
+	6.84648f,
+	-89.8438f,
+	230.469f,
+	6.3424f,
+	-89.8438f,
+	234.375f,
+	5.81853f,
+	-89.8438f,
+	238.281f,
+	5.89205f,
+	-89.8438f,
+	242.188f,
+	6.84078f,
+	-89.8438f,
+	246.094f,
+	6.32426f,
+	-89.8438f,
+	250.0f,
+	6.29368f,
+	-89.8438f,
+	3.90625f,
+	45.4182f,
+	-93.75f,
+	7.8125f,
+	44.5664f,
+	-93.75f,
+	11.7188f,
+	44.0207f,
+	-93.75f,
+	15.625f,
+	42.2553f,
+	-93.75f,
+	19.5313f,
+	40.8951f,
+	-93.75f,
+	23.4375f,
+	40.7665f,
+	-93.75f,
+	27.3438f,
+	40.5756f,
+	-93.75f,
+	31.25f,
+	41.2988f,
+	-93.75f,
+	35.1563f,
+	40.6862f,
+	-93.75f,
+	39.0625f,
+	40.6007f,
+	-93.75f,
+	42.9688f,
+	39.5329f,
+	-93.75f,
+	46.875f,
+	38.2364f,
+	-93.75f,
+	50.7813f,
+	36.1442f,
+	-93.75f,
+	54.6875f,
+	34.7353f,
+	-93.75f,
+	58.5938f,
+	34.4214f,
+	-93.75f,
+	62.5f,
+	33.9528f,
+	-93.75f,
+	66.4063f,
+	32.4931f,
+	-93.75f,
+	70.3125f,
+	32.5145f,
+	-93.75f,
+	74.2188f,
+	33.393f,
+	-93.75f,
+	78.125f,
+	34.9658f,
+	-93.75f,
+	82.0313f,
+	36.3611f,
+	-93.75f,
+	85.9375f,
+	37.568f,
+	-93.75f,
+	89.8438f,
+	37.012f,
+	-93.75f,
+	93.75f,
+	37.6392f,
+	-93.75f,
+	97.6563f,
+	38.4371f,
+	-93.75f,
+	101.563f,
+	38.3719f,
+	-93.75f,
+	105.469f,
+	39.1179f,
+	-93.75f,
+	109.375f,
+	38.5168f,
+	-93.75f,
+	113.281f,
+	40.0403f,
+	-93.75f,
+	117.188f,
+	40.2277f,
+	-93.75f,
+	121.094f,
+	40.8985f,
+	-93.75f,
+	125.0f,
+	40.189f,
+	-93.75f,
+	128.906f,
+	39.9435f,
+	-93.75f,
+	132.813f,
+	39.6824f,
+	-93.75f,
+	136.719f,
+	38.844f,
+	-93.75f,
+	140.625f,
+	37.4579f,
+	-93.75f,
+	144.531f,
+	36.8375f,
+	-93.75f,
+	148.438f,
+	36.2601f,
+	-93.75f,
+	152.344f,
+	35.6484f,
+	-93.75f,
+	156.25f,
+	34.179f,
+	-93.75f,
+	160.156f,
+	32.0651f,
+	-93.75f,
+	164.063f,
+	28.6431f,
+	-93.75f,
+	167.969f,
+	25.1239f,
+	-93.75f,
+	171.875f,
+	22.4459f,
+	-93.75f,
+	175.781f,
+	19.5301f,
+	-93.75f,
+	179.688f,
+	18.4371f,
+	-93.75f,
+	183.594f,
+	18.6076f,
+	-93.75f,
+	187.5f,
+	17.488f,
+	-93.75f,
+	191.406f,
+	15.1604f,
+	-93.75f,
+	195.313f,
+	13.0197f,
+	-93.75f,
+	199.219f,
+	9.4702f,
+	-93.75f,
+	203.125f,
+	5.597f,
+	-93.75f,
+	207.031f,
+	3.59409f,
+	-93.75f,
+	210.938f,
+	4.28966f,
+	-93.75f,
+	214.844f,
+	4.21811f,
+	-93.75f,
+	218.75f,
+	4.11546f,
+	-93.75f,
+	222.656f,
+	5.40815f,
+	-93.75f,
+	226.563f,
+	5.56249f,
+	-93.75f,
+	230.469f,
+	5.35075f,
+	-93.75f,
+	234.375f,
+	5.24306f,
+	-93.75f,
+	238.281f,
+	4.85548f,
+	-93.75f,
+	242.188f,
+	5.02825f,
+	-93.75f,
+	246.094f,
+	5.32318f,
+	-93.75f,
+	250.0f,
+	5.59512f,
+	-93.75f,
+	3.90625f,
+	44.9637f,
+	-97.6563f,
+	7.8125f,
+	44.7813f,
+	-97.6563f,
+	11.7188f,
+	43.457f,
+	-97.6563f,
+	15.625f,
+	42.5329f,
+	-97.6563f,
+	19.5313f,
+	40.506f,
+	-97.6563f,
+	23.4375f,
+	39.8146f,
+	-97.6563f,
+	27.3438f,
+	40.2245f,
+	-97.6563f,
+	31.25f,
+	39.497f,
+	-97.6563f,
+	35.1563f,
+	38.8152f,
+	-97.6563f,
+	39.0625f,
+	38.3406f,
+	-97.6563f,
+	42.9688f,
+	37.57f,
+	-97.6563f,
+	46.875f,
+	36.3128f,
+	-97.6563f,
+	50.7813f,
+	34.2277f,
+	-97.6563f,
+	54.6875f,
+	33.3395f,
+	-97.6563f,
+	58.5938f,
+	32.972f,
+	-97.6563f,
+	62.5f,
+	32.6315f,
+	-97.6563f,
+	66.4063f,
+	32.4796f,
+	-97.6563f,
+	70.3125f,
+	31.6472f,
+	-97.6563f,
+	74.2188f,
+	32.2256f,
+	-97.6563f,
+	78.125f,
+	33.8073f,
+	-97.6563f,
+	82.0313f,
+	35.7591f,
+	-97.6563f,
+	85.9375f,
+	36.5001f,
+	-97.6563f,
+	89.8438f,
+	36.9113f,
+	-97.6563f,
+	93.75f,
+	37.6902f,
+	-97.6563f,
+	97.6563f,
+	37.9643f,
+	-97.6563f,
+	101.563f,
+	38.9556f,
+	-97.6563f,
+	105.469f,
+	39.6823f,
+	-97.6563f,
+	109.375f,
+	38.9917f,
+	-97.6563f,
+	113.281f,
+	40.0872f,
+	-97.6563f,
+	117.188f,
+	40.44f,
+	-97.6563f,
+	121.094f,
+	39.6877f,
+	-97.6563f,
+	125.0f,
+	39.0011f,
+	-97.6563f,
+	128.906f,
+	39.8735f,
+	-97.6563f,
+	132.813f,
+	39.5503f,
+	-97.6563f,
+	136.719f,
+	37.743f,
+	-97.6563f,
+	140.625f,
+	36.4691f,
+	-97.6563f,
+	144.531f,
+	36.1765f,
+	-97.6563f,
+	148.438f,
+	35.9476f,
+	-97.6563f,
+	152.344f,
+	35.1141f,
+	-97.6563f,
+	156.25f,
+	33.2516f,
+	-97.6563f,
+	160.156f,
+	30.654f,
+	-97.6563f,
+	164.063f,
+	27.2318f,
+	-97.6563f,
+	167.969f,
+	23.3975f,
+	-97.6563f,
+	171.875f,
+	20.6722f,
+	-97.6563f,
+	175.781f,
+	18.394f,
+	-97.6563f,
+	179.688f,
+	17.6475f,
+	-97.6563f,
+	183.594f,
+	16.1037f,
+	-97.6563f,
+	187.5f,
+	14.761f,
+	-97.6563f,
+	191.406f,
+	12.2456f,
+	-97.6563f,
+	195.313f,
+	9.43327f,
+	-97.6563f,
+	199.219f,
+	6.9118f,
+	-97.6563f,
+	203.125f,
+	4.26334f,
+	-97.6563f,
+	207.031f,
+	3.47413f,
+	-97.6563f,
+	210.938f,
+	3.74872f,
+	-97.6563f,
+	214.844f,
+	3.7631f,
+	-97.6563f,
+	218.75f,
+	3.80513f,
+	-97.6563f,
+	222.656f,
+	4.23443f,
+	-97.6563f,
+	226.563f,
+	3.71016f,
+	-97.6563f,
+	230.469f,
+	3.772f,
+	-97.6563f,
+	234.375f,
+	3.80374f,
+	-97.6563f,
+	238.281f,
+	3.70762f,
+	-97.6563f,
+	242.188f,
+	4.23931f,
+	-97.6563f,
+	246.094f,
+	4.40519f,
+	-97.6563f,
+	250.0f,
+	4.5119f,
+	-97.6563f,
+	3.90625f,
+	44.5311f,
+	-101.563f,
+	7.8125f,
+	44.4181f,
+	-101.563f,
+	11.7188f,
+	43.4864f,
+	-101.563f,
+	15.625f,
+	42.259f,
+	-101.563f,
+	19.5313f,
+	41.0558f,
+	-101.563f,
+	23.4375f,
+	39.9996f,
+	-101.563f,
+	27.3438f,
+	39.3917f,
+	-101.563f,
+	31.25f,
+	39.5691f,
+	-101.563f,
+	35.1563f,
+	37.0889f,
+	-101.563f,
+	39.0625f,
+	36.4296f,
+	-101.563f,
+	42.9688f,
+	36.543f,
+	-101.563f,
+	46.875f,
+	35.4365f,
+	-101.563f,
+	50.7813f,
+	33.3641f,
+	-101.563f,
+	54.6875f,
+	32.0629f,
+	-101.563f,
+	58.5938f,
+	32.175f,
+	-101.563f,
+	62.5f,
+	32.775f,
+	-101.563f,
+	66.4063f,
+	31.6335f,
+	-101.563f,
+	70.3125f,
+	32.1001f,
+	-101.563f,
+	74.2188f,
+	32.5906f,
+	-101.563f,
+	78.125f,
+	33.1502f,
+	-101.563f,
+	82.0313f,
+	35.1972f,
+	-101.563f,
+	85.9375f,
+	36.0132f,
+	-101.563f,
+	89.8438f,
+	37.3442f,
+	-101.563f,
+	93.75f,
+	37.6109f,
+	-101.563f,
+	97.6563f,
+	38.1601f,
+	-101.563f,
+	101.563f,
+	39.77f,
+	-101.563f,
+	105.469f,
+	39.6862f,
+	-101.563f,
+	109.375f,
+	39.4829f,
+	-101.563f,
+	113.281f,
+	40.1383f,
+	-101.563f,
+	117.188f,
+	40.8908f,
+	-101.563f,
+	121.094f,
+	39.3517f,
+	-101.563f,
+	125.0f,
+	38.9321f,
+	-101.563f,
+	128.906f,
+	39.2537f,
+	-101.563f,
+	132.813f,
+	38.4876f,
+	-101.563f,
+	136.719f,
+	36.6755f,
+	-101.563f,
+	140.625f,
+	35.2803f,
+	-101.563f,
+	144.531f,
+	35.8754f,
+	-101.563f,
+	148.438f,
+	36.2761f,
+	-101.563f,
+	152.344f,
+	34.7815f,
+	-101.563f,
+	156.25f,
+	32.2662f,
+	-101.563f,
+	160.156f,
+	29.8191f,
+	-101.563f,
+	164.063f,
+	25.8929f,
+	-101.563f,
+	167.969f,
+	22.552f,
+	-101.563f,
+	171.875f,
+	20.3186f,
+	-101.563f,
+	175.781f,
+	17.2917f,
+	-101.563f,
+	179.688f,
+	16.8305f,
+	-101.563f,
+	183.594f,
+	14.7168f,
+	-101.563f,
+	187.5f,
+	12.0609f,
+	-101.563f,
+	191.406f,
+	9.91022f,
+	-101.563f,
+	195.313f,
+	7.22029f,
+	-101.563f,
+	199.219f,
+	5.48379f,
+	-101.563f,
+	203.125f,
+	3.03759f,
+	-101.563f,
+	207.031f,
+	3.02148f,
+	-101.563f,
+	210.938f,
+	2.88667f,
+	-101.563f,
+	214.844f,
+	3.08795f,
+	-101.563f,
+	218.75f,
+	3.43814f,
+	-101.563f,
+	222.656f,
+	3.58591f,
+	-101.563f,
+	226.563f,
+	3.17855f,
+	-101.563f,
+	230.469f,
+	2.48711f,
+	-101.563f,
+	234.375f,
+	2.66471f,
+	-101.563f,
+	238.281f,
+	2.06432f,
+	-101.563f,
+	242.188f,
+	2.49704f,
+	-101.563f,
+	246.094f,
+	3.05219f,
+	-101.563f,
+	250.0f,
+	3.69155f,
+	-101.563f,
+	3.90625f,
+	44.8466f,
+	-105.469f,
+	7.8125f,
+	44.3102f,
+	-105.469f,
+	11.7188f,
+	43.8936f,
+	-105.469f,
+	15.625f,
+	43.2285f,
+	-105.469f,
+	19.5313f,
+	42.7384f,
+	-105.469f,
+	23.4375f,
+	41.2954f,
+	-105.469f,
+	27.3438f,
+	39.4813f,
+	-105.469f,
+	31.25f,
+	38.4483f,
+	-105.469f,
+	35.1563f,
+	35.8264f,
+	-105.469f,
+	39.0625f,
+	35.0991f,
+	-105.469f,
+	42.9688f,
+	35.1929f,
+	-105.469f,
+	46.875f,
+	34.3044f,
+	-105.469f,
+	50.7813f,
+	31.4169f,
+	-105.469f,
+	54.6875f,
+	30.8206f,
+	-105.469f,
+	58.5938f,
+	31.2902f,
+	-105.469f,
+	62.5f,
+	32.2869f,
+	-105.469f,
+	66.4063f,
+	32.5121f,
+	-105.469f,
+	70.3125f,
+	32.772f,
+	-105.469f,
+	74.2188f,
+	32.5422f,
+	-105.469f,
+	78.125f,
+	34.0506f,
+	-105.469f,
+	82.0313f,
+	35.4894f,
+	-105.469f,
+	85.9375f,
+	36.753f,
+	-105.469f,
+	89.8438f,
+	37.6901f,
+	-105.469f,
+	93.75f,
+	37.848f,
+	-105.469f,
+	97.6563f,
+	38.9724f,
+	-105.469f,
+	101.563f,
+	40.0724f,
+	-105.469f,
+	105.469f,
+	39.7381f,
+	-105.469f,
+	109.375f,
+	39.3905f,
+	-105.469f,
+	113.281f,
+	39.8577f,
+	-105.469f,
+	117.188f,
+	40.4957f,
+	-105.469f,
+	121.094f,
+	39.554f,
+	-105.469f,
+	125.0f,
+	39.0384f,
+	-105.469f,
+	128.906f,
+	38.2112f,
+	-105.469f,
+	132.813f,
+	36.7141f,
+	-105.469f,
+	136.719f,
+	34.736f,
+	-105.469f,
+	140.625f,
+	34.2236f,
+	-105.469f,
+	144.531f,
+	35.4181f,
+	-105.469f,
+	148.438f,
+	35.4456f,
+	-105.469f,
+	152.344f,
+	33.4389f,
+	-105.469f,
+	156.25f,
+	29.9708f,
+	-105.469f,
+	160.156f,
+	27.2392f,
+	-105.469f,
+	164.063f,
+	24.3409f,
+	-105.469f,
+	167.969f,
+	22.4438f,
+	-105.469f,
+	171.875f,
+	19.5326f,
+	-105.469f,
+	175.781f,
+	16.9951f,
+	-105.469f,
+	179.688f,
+	14.77f,
+	-105.469f,
+	183.594f,
+	13.1816f,
+	-105.469f,
+	187.5f,
+	10.3711f,
+	-105.469f,
+	191.406f,
+	7.10511f,
+	-105.469f,
+	195.313f,
+	5.43711f,
+	-105.469f,
+	199.219f,
+	3.35463f,
+	-105.469f,
+	203.125f,
+	2.41276f,
+	-105.469f,
+	207.031f,
+	2.35357f,
+	-105.469f,
+	210.938f,
+	2.28627f,
+	-105.469f,
+	214.844f,
+	1.61561f,
+	-105.469f,
+	218.75f,
+	2.61087f,
+	-105.469f,
+	222.656f,
+	2.34638f,
+	-105.469f,
+	226.563f,
+	1.47074f,
+	-105.469f,
+	230.469f,
+	0.63025f,
+	-105.469f,
+	234.375f,
+	0.847991f,
+	-105.469f,
+	238.281f,
+	1.35199f,
+	-105.469f,
+	242.188f,
+	2.21032f,
+	-105.469f,
+	246.094f,
+	3.01323f,
+	-105.469f,
+	250.0f,
+	3.12713f,
+	-105.469f,
+	3.90625f,
+	45.3987f,
+	-109.375f,
+	7.8125f,
+	44.6273f,
+	-109.375f,
+	11.7188f,
+	44.5674f,
+	-109.375f,
+	15.625f,
+	44.2998f,
+	-109.375f,
+	19.5313f,
+	43.5383f,
+	-109.375f,
+	23.4375f,
+	42.0306f,
+	-109.375f,
+	27.3438f,
+	40.7068f,
+	-109.375f,
+	31.25f,
+	39.6497f,
+	-109.375f,
+	35.1563f,
+	36.2161f,
+	-109.375f,
+	39.0625f,
+	34.8769f,
+	-109.375f,
+	42.9688f,
+	35.1989f,
+	-109.375f,
+	46.875f,
+	33.9714f,
+	-109.375f,
+	50.7813f,
+	30.9979f,
+	-109.375f,
+	54.6875f,
+	31.9366f,
+	-109.375f,
+	58.5938f,
+	31.5755f,
+	-109.375f,
+	62.5f,
+	31.572f,
+	-109.375f,
+	66.4063f,
+	33.0668f,
+	-109.375f,
+	70.3125f,
+	33.6444f,
+	-109.375f,
+	74.2188f,
+	32.5467f,
+	-109.375f,
+	78.125f,
+	34.2686f,
+	-109.375f,
+	82.0313f,
+	36.0633f,
+	-109.375f,
+	85.9375f,
+	37.5569f,
+	-109.375f,
+	89.8438f,
+	38.5599f,
+	-109.375f,
+	93.75f,
+	38.6708f,
+	-109.375f,
+	97.6563f,
+	39.2558f,
+	-109.375f,
+	101.563f,
+	39.9111f,
+	-109.375f,
+	105.469f,
+	39.9236f,
+	-109.375f,
+	109.375f,
+	39.5666f,
+	-109.375f,
+	113.281f,
+	40.1532f,
+	-109.375f,
+	117.188f,
+	40.8773f,
+	-109.375f,
+	121.094f,
+	40.133f,
+	-109.375f,
+	125.0f,
+	38.348f,
+	-109.375f,
+	128.906f,
+	36.9174f,
+	-109.375f,
+	132.813f,
+	34.8975f,
+	-109.375f,
+	136.719f,
+	32.9097f,
+	-109.375f,
+	140.625f,
+	32.6666f,
+	-109.375f,
+	144.531f,
+	33.1207f,
+	-109.375f,
+	148.438f,
+	32.6024f,
+	-109.375f,
+	152.344f,
+	31.1149f,
+	-109.375f,
+	156.25f,
+	27.7885f,
+	-109.375f,
+	160.156f,
+	24.9665f,
+	-109.375f,
+	164.063f,
+	22.789f,
+	-109.375f,
+	167.969f,
+	20.4907f,
+	-109.375f,
+	171.875f,
+	18.2402f,
+	-109.375f,
+	175.781f,
+	15.9409f,
+	-109.375f,
+	179.688f,
+	12.7122f,
+	-109.375f,
+	183.594f,
+	10.9582f,
+	-109.375f,
+	187.5f,
+	7.47226f,
+	-109.375f,
+	191.406f,
+	4.87747f,
+	-109.375f,
+	195.313f,
+	2.78589f,
+	-109.375f,
+	199.219f,
+	1.53429f,
+	-109.375f,
+	203.125f,
+	1.61775f,
+	-109.375f,
+	207.031f,
+	1.772f,
+	-109.375f,
+	210.938f,
+	1.15444f,
+	-109.375f,
+	214.844f,
+	0.342505f,
+	-109.375f,
+	218.75f,
+	0.510183f,
+	-109.375f,
+	222.656f,
+	0.254977f,
+	-109.375f,
+	226.563f,
+	-0.22727f,
+	-109.375f,
+	230.469f,
+	-0.840625f,
+	-109.375f,
+	234.375f,
+	-0.282154f,
+	-109.375f,
+	238.281f,
+	0.424945f,
+	-109.375f,
+	242.188f,
+	1.73577f,
+	-109.375f,
+	246.094f,
+	1.80217f,
+	-109.375f,
+	250.0f,
+	1.60105f,
+	-109.375f,
+	3.90625f,
+	47.4869f,
+	-113.281f,
+	7.8125f,
+	46.3185f,
+	-113.281f,
+	11.7188f,
+	46.4911f,
+	-113.281f,
+	15.625f,
+	45.2506f,
+	-113.281f,
+	19.5313f,
+	43.7939f,
+	-113.281f,
+	23.4375f,
+	42.6062f,
+	-113.281f,
+	27.3438f,
+	41.6674f,
+	-113.281f,
+	31.25f,
+	39.5196f,
+	-113.281f,
+	35.1563f,
+	36.6784f,
+	-113.281f,
+	39.0625f,
+	35.8546f,
+	-113.281f,
+	42.9688f,
+	35.2647f,
+	-113.281f,
+	46.875f,
+	33.0882f,
+	-113.281f,
+	50.7813f,
+	31.1331f,
+	-113.281f,
+	54.6875f,
+	31.9095f,
+	-113.281f,
+	58.5938f,
+	31.5715f,
+	-113.281f,
+	62.5f,
+	32.3642f,
+	-113.281f,
+	66.4063f,
+	33.2578f,
+	-113.281f,
+	70.3125f,
+	33.1847f,
+	-113.281f,
+	74.2188f,
+	33.6624f,
+	-113.281f,
+	78.125f,
+	35.6582f,
+	-113.281f,
+	82.0313f,
+	36.7989f,
+	-113.281f,
+	85.9375f,
+	37.9951f,
+	-113.281f,
+	89.8438f,
+	38.7063f,
+	-113.281f,
+	93.75f,
+	39.9727f,
+	-113.281f,
+	97.6563f,
+	39.641f,
+	-113.281f,
+	101.563f,
+	40.1318f,
+	-113.281f,
+	105.469f,
+	40.117f,
+	-113.281f,
+	109.375f,
+	40.0678f,
+	-113.281f,
+	113.281f,
+	40.1534f,
+	-113.281f,
+	117.188f,
+	40.7841f,
+	-113.281f,
+	121.094f,
+	39.3312f,
+	-113.281f,
+	125.0f,
+	38.1823f,
+	-113.281f,
+	128.906f,
+	37.0921f,
+	-113.281f,
+	132.813f,
+	34.9687f,
+	-113.281f,
+	136.719f,
+	32.6631f,
+	-113.281f,
+	140.625f,
+	30.9601f,
+	-113.281f,
+	144.531f,
+	31.0644f,
+	-113.281f,
+	148.438f,
+	29.6495f,
+	-113.281f,
+	152.344f,
+	27.5095f,
+	-113.281f,
+	156.25f,
+	24.9361f,
+	-113.281f,
+	160.156f,
+	22.6206f,
+	-113.281f,
+	164.063f,
+	20.1136f,
+	-113.281f,
+	167.969f,
+	17.9862f,
+	-113.281f,
+	171.875f,
+	16.1252f,
+	-113.281f,
+	175.781f,
+	14.2991f,
+	-113.281f,
+	179.688f,
+	11.4262f,
+	-113.281f,
+	183.594f,
+	8.55749f,
+	-113.281f,
+	187.5f,
+	6.02067f,
+	-113.281f,
+	191.406f,
+	3.1883f,
+	-113.281f,
+	195.313f,
+	1.54808f,
+	-113.281f,
+	199.219f,
+	0.0223479f,
+	-113.281f,
+	203.125f,
+	-0.0807506f,
+	-113.281f,
+	207.031f,
+	-0.420855f,
+	-113.281f,
+	210.938f,
+	-0.531322f,
+	-113.281f,
+	214.844f,
+	-1.34393f,
+	-113.281f,
+	218.75f,
+	-2.28346f,
+	-113.281f,
+	222.656f,
+	-2.245f,
+	-113.281f,
+	226.563f,
+	-2.22932f,
+	-113.281f,
+	230.469f,
+	-1.47268f,
+	-113.281f,
+	234.375f,
+	-0.543695f,
+	-113.281f,
+	238.281f,
+	-0.391948f,
+	-113.281f,
+	242.188f,
+	-0.270077f,
+	-113.281f,
+	246.094f,
+	-0.650629f,
+	-113.281f,
+	250.0f,
+	0.111517f,
+	-113.281f,
+	3.90625f,
+	48.3887f,
+	-117.188f,
+	7.8125f,
+	48.004f,
+	-117.188f,
+	11.7188f,
+	46.8723f,
+	-117.188f,
+	15.625f,
+	45.5005f,
+	-117.188f,
+	19.5313f,
+	43.3644f,
+	-117.188f,
+	23.4375f,
+	42.3352f,
+	-117.188f,
+	27.3438f,
+	41.1562f,
+	-117.188f,
+	31.25f,
+	39.1736f,
+	-117.188f,
+	35.1563f,
+	38.0627f,
+	-117.188f,
+	39.0625f,
+	36.4728f,
+	-117.188f,
+	42.9688f,
+	34.8001f,
+	-117.188f,
+	46.875f,
+	32.5103f,
+	-117.188f,
+	50.7813f,
+	31.6328f,
+	-117.188f,
+	54.6875f,
+	31.6106f,
+	-117.188f,
+	58.5938f,
+	32.3004f,
+	-117.188f,
+	62.5f,
+	32.696f,
+	-117.188f,
+	66.4063f,
+	33.3795f,
+	-117.188f,
+	70.3125f,
+	33.9696f,
+	-117.188f,
+	74.2188f,
+	34.9211f,
+	-117.188f,
+	78.125f,
+	36.7686f,
+	-117.188f,
+	82.0313f,
+	37.7676f,
+	-117.188f,
+	85.9375f,
+	37.8174f,
+	-117.188f,
+	89.8438f,
+	38.2878f,
+	-117.188f,
+	93.75f,
+	39.6151f,
+	-117.188f,
+	97.6563f,
+	39.7422f,
+	-117.188f,
+	101.563f,
+	40.9611f,
+	-117.188f,
+	105.469f,
+	40.8932f,
+	-117.188f,
+	109.375f,
+	40.6603f,
+	-117.188f,
+	113.281f,
+	40.2935f,
+	-117.188f,
+	117.188f,
+	39.8681f,
+	-117.188f,
+	121.094f,
+	39.0965f,
+	-117.188f,
+	125.0f,
+	37.1333f,
+	-117.188f,
+	128.906f,
+	35.5222f,
+	-117.188f,
+	132.813f,
+	33.9068f,
+	-117.188f,
+	136.719f,
+	32.2618f,
+	-117.188f,
+	140.625f,
+	29.8657f,
+	-117.188f,
+	144.531f,
+	28.1704f,
+	-117.188f,
+	148.438f,
+	27.1495f,
+	-117.188f,
+	152.344f,
+	24.5217f,
+	-117.188f,
+	156.25f,
+	22.0419f,
+	-117.188f,
+	160.156f,
+	19.9238f,
+	-117.188f,
+	164.063f,
+	17.6875f,
+	-117.188f,
+	167.969f,
+	15.5636f,
+	-117.188f,
+	171.875f,
+	13.5497f,
+	-117.188f,
+	175.781f,
+	11.2761f,
+	-117.188f,
+	179.688f,
+	8.95864f,
+	-117.188f,
+	183.594f,
+	7.04623f,
+	-117.188f,
+	187.5f,
+	4.83635f,
+	-117.188f,
+	191.406f,
+	2.76046f,
+	-117.188f,
+	195.313f,
+	0.190119f,
+	-117.188f,
+	199.219f,
+	-0.558379f,
+	-117.188f,
+	203.125f,
+	-1.03303f,
+	-117.188f,
+	207.031f,
+	-2.17563f,
+	-117.188f,
+	210.938f,
+	-1.91155f,
+	-117.188f,
+	214.844f,
+	-3.00018f,
+	-117.188f,
+	218.75f,
+	-4.26691f,
+	-117.188f,
+	222.656f,
+	-5.15855f,
+	-117.188f,
+	226.563f,
+	-3.46348f,
+	-117.188f,
+	230.469f,
+	-2.16077f,
+	-117.188f,
+	234.375f,
+	-1.47785f,
+	-117.188f,
+	238.281f,
+	-1.78424f,
+	-117.188f,
+	242.188f,
+	-1.00317f,
+	-117.188f,
+	246.094f,
+	-1.97981f,
+	-117.188f,
+	250.0f,
+	-2.29372f,
+	-117.188f,
+};
+
+btScalar Landscape03Nml[] = {
+	-0.0301669f,
+	0.913898f,
+	-0.404822f,
+	0.0925944f,
+	0.901922f,
+	-0.421856f,
+	0.0550338f,
+	0.955133f,
+	-0.291019f,
+	0.163554f,
+	0.924847f,
+	-0.343379f,
+	-0.00160556f,
+	0.985516f,
+	-0.169577f,
+	0.0975687f,
+	0.967908f,
+	-0.23159f,
+	-0.0718641f,
+	0.997324f,
+	-0.0134097f,
+	0.108884f,
+	0.992259f,
+	0.0597208f,
+	-0.0649193f,
+	0.987727f,
+	0.142057f,
+	-0.0923076f,
+	0.995503f,
+	-0.0212622f,
+	-0.212176f,
+	0.966905f,
+	0.141687f,
+	-0.135924f,
+	0.982555f,
+	0.126925f,
+	-0.248136f,
+	0.950917f,
+	0.184892f,
+	-0.114969f,
+	0.937595f,
+	0.328173f,
+	-0.0596382f,
+	0.954355f,
+	0.292661f,
+	-0.0673134f,
+	0.931098f,
+	0.358506f,
+	-0.100514f,
+	0.963905f,
+	0.246544f,
+	-0.237357f,
+	0.960335f,
+	0.146353f,
+	-0.210275f,
+	0.964506f,
+	0.159726f,
+	-0.243879f,
+	0.969407f,
+	-0.027797f,
+	-0.0995316f,
+	0.963559f,
+	0.248291f,
+	0.0232774f,
+	0.986211f,
+	0.163848f,
+	-0.0780955f,
+	0.939808f,
+	0.33266f,
+	0.0143543f,
+	0.937354f,
+	0.348083f,
+	-0.242603f,
+	0.911487f,
+	0.332166f,
+	-0.217791f,
+	0.899583f,
+	0.378572f,
+	-0.259297f,
+	0.919695f,
+	0.294833f,
+	-0.235372f,
+	0.900382f,
+	0.365939f,
+	0.0548314f,
+	0.924698f,
+	0.376733f,
+	0.17577f,
+	0.83537f,
+	0.520828f,
+	0.183628f,
+	0.8685f,
+	0.460423f,
+	0.206319f,
+	0.791195f,
+	0.57571f,
+	0.291585f,
+	0.831097f,
+	0.473557f,
+	0.258977f,
+	0.806104f,
+	0.532097f,
+	0.406441f,
+	0.807616f,
+	0.427274f,
+	0.279416f,
+	0.89888f,
+	0.337552f,
+	0.161449f,
+	0.944511f,
+	0.286064f,
+	-0.0153595f,
+	0.999467f,
+	0.0288015f,
+	0.0344442f,
+	0.986316f,
+	0.16123f,
+	0.0228147f,
+	0.999694f,
+	-0.00950936f,
+	0.221267f,
+	0.961345f,
+	0.163882f,
+	0.262982f,
+	0.961437f,
+	0.0804904f,
+	0.292545f,
+	0.943495f,
+	0.155677f,
+	0.287728f,
+	0.952627f,
+	0.0985627f,
+	0.338791f,
+	0.935036f,
+	0.104535f,
+	0.332042f,
+	0.939101f,
+	0.0885263f,
+	0.395865f,
+	0.914692f,
+	0.0814219f,
+	0.342439f,
+	0.937891f,
+	0.0556409f,
+	0.24643f,
+	0.967531f,
+	-0.0561722f,
+	0.155524f,
+	0.980084f,
+	-0.12348f,
+	0.12756f,
+	0.989194f,
+	-0.0722747f,
+	0.141529f,
+	0.984734f,
+	-0.10133f,
+	0.0842668f,
+	0.99539f,
+	-0.0458028f,
+	0.00840046f,
+	0.967846f,
+	-0.251403f,
+	0.0723924f,
+	0.995277f,
+	-0.0646756f,
+	0.161395f,
+	0.974624f,
+	-0.155111f,
+	0.168526f,
+	0.983485f,
+	0.0660013f,
+	0.32936f,
+	0.929371f,
+	0.166709f,
+	0.334018f,
+	0.924548f,
+	0.18342f,
+	0.39263f,
+	0.883836f,
+	0.254313f,
+	0.373683f,
+	0.906029f,
+	0.198675f,
+	0.318503f,
+	0.931732f,
+	0.174444f,
+	0.214891f,
+	0.969497f,
+	0.117891f,
+	0.248914f,
+	0.936934f,
+	0.245348f,
+	0.199074f,
+	0.96113f,
+	0.19131f,
+	0.293417f,
+	0.893252f,
+	0.340597f,
+	0.339667f,
+	0.873015f,
+	0.349959f,
+	0.354613f,
+	0.873548f,
+	0.333412f,
+	0.457963f,
+	0.824157f,
+	0.333219f,
+	0.455319f,
+	0.825254f,
+	0.334127f,
+	0.52695f,
+	0.805593f,
+	0.270821f,
+	0.439193f,
+	0.858556f,
+	0.264557f,
+	0.401282f,
+	0.908751f,
+	0.114652f,
+	0.249111f,
+	0.965853f,
+	-0.0712114f,
+	0.0897089f,
+	0.991664f,
+	0.0924929f,
+	0.0376765f,
+	0.979393f,
+	-0.19842f,
+	-0.126991f,
+	0.990951f,
+	0.0434627f,
+	-0.217753f,
+	0.933113f,
+	-0.286154f,
+	-0.167574f,
+	0.97576f,
+	-0.140749f,
+	-0.203937f,
+	0.914317f,
+	-0.349907f,
+	-0.0608955f,
+	0.980207f,
+	-0.188379f,
+	-0.0120075f,
+	0.947447f,
+	-0.319686f,
+	0.167601f,
+	0.980952f,
+	-0.0982003f,
+	0.212052f,
+	0.945824f,
+	-0.245868f,
+	0.218606f,
+	0.972968f,
+	-0.0744646f,
+	0.212851f,
+	0.953898f,
+	-0.211596f,
+	0.171647f,
+	0.974969f,
+	-0.141323f,
+	0.199197f,
+	0.967793f,
+	-0.153938f,
+	0.200412f,
+	0.972091f,
+	-0.121957f,
+	0.23265f,
+	0.963849f,
+	-0.129883f,
+	0.296235f,
+	0.953212f,
+	-0.060261f,
+	0.314311f,
+	0.946698f,
+	-0.0705058f,
+	0.404868f,
+	0.912189f,
+	-0.0631982f,
+	0.403087f,
+	0.912504f,
+	-0.0696997f,
+	0.463227f,
+	0.884095f,
+	-0.0616207f,
+	0.39479f,
+	0.897802f,
+	-0.195171f,
+	0.35121f,
+	0.926619f,
+	-0.13427f,
+	0.220773f,
+	0.898508f,
+	-0.379398f,
+	0.189824f,
+	0.93595f,
+	-0.296589f,
+	0.0483901f,
+	0.855509f,
+	-0.515522f,
+	0.0904515f,
+	0.884685f,
+	-0.457329f,
+	0.120283f,
+	0.865017f,
+	-0.487112f,
+	0.203986f,
+	0.900002f,
+	-0.385209f,
+	0.248454f,
+	0.881227f,
+	-0.402131f,
+	0.178575f,
+	0.929214f,
+	-0.323532f,
+	0.0792679f,
+	0.824417f,
+	-0.560404f,
+	0.115378f,
+	0.950213f,
+	-0.289454f,
+	0.0725597f,
+	0.807744f,
+	-0.585051f,
+	0.0327706f,
+	0.953791f,
+	-0.298679f,
+	0.0099385f,
+	0.78612f,
+	-0.617994f,
+	0.0403637f,
+	0.952173f,
+	-0.302881f,
+	0.215114f,
+	0.87002f,
+	-0.443611f,
+	0.182967f,
+	0.972742f,
+	-0.142465f,
+	0.292542f,
+	0.923312f,
+	-0.248827f,
+	0.159782f,
+	0.983577f,
+	-0.0839386f,
+	0.255356f,
+	0.959339f,
+	-0.120256f,
+	0.180088f,
+	0.983508f,
+	0.0167535f,
+	0.210595f,
+	0.975243f,
+	-0.0674566f,
+	0.305089f,
+	0.951559f,
+	0.0381592f,
+	0.342154f,
+	0.939613f,
+	0.00764387f,
+	0.44387f,
+	0.894627f,
+	0.0512048f,
+	0.377004f,
+	0.921573f,
+	-0.0925792f,
+	0.197535f,
+	0.978807f,
+	-0.0540106f,
+	0.128094f,
+	0.953819f,
+	-0.271702f,
+	0.10228f,
+	0.991256f,
+	-0.0833686f,
+	0.111348f,
+	0.971755f,
+	-0.208074f,
+	0.120727f,
+	0.982203f,
+	-0.143886f,
+	0.131919f,
+	0.971754f,
+	-0.195681f,
+	-0.118481f,
+	0.971727f,
+	-0.204228f,
+	-0.131824f,
+	0.977685f,
+	-0.163569f,
+	-0.0725384f,
+	0.997366f,
+	-0.000133281f,
+	-0.204047f,
+	0.978951f,
+	0.00446862f,
+	-0.227431f,
+	0.966677f,
+	0.117515f,
+	-0.137601f,
+	0.963906f,
+	0.227929f,
+	-0.242399f,
+	0.965055f,
+	0.0995586f,
+	-0.153062f,
+	0.97808f,
+	0.141178f,
+	-0.129415f,
+	0.948353f,
+	0.289617f,
+	-0.22442f,
+	0.902886f,
+	0.366649f,
+	-0.173979f,
+	0.92147f,
+	0.34731f,
+	-0.0318649f,
+	0.93595f,
+	0.350687f,
+	-0.176397f,
+	0.955508f,
+	0.236408f,
+	-0.254551f,
+	0.956811f,
+	0.140418f,
+	-0.0162894f,
+	0.984782f,
+	0.173032f,
+	0.167302f,
+	0.961803f,
+	0.216667f,
+	0.267797f,
+	0.948626f,
+	0.168505f,
+	0.412955f,
+	0.869957f,
+	0.269525f,
+	0.258065f,
+	0.893814f,
+	0.366742f,
+	0.124905f,
+	0.932115f,
+	0.339941f,
+	0.234805f,
+	0.927845f,
+	0.289777f,
+	0.325979f,
+	0.90761f,
+	0.264542f,
+	0.401458f,
+	0.890435f,
+	0.214374f,
+	0.44845f,
+	0.886659f,
+	0.112823f,
+	0.337292f,
+	0.940965f,
+	0.0286028f,
+	0.110729f,
+	0.992952f,
+	-0.0422648f,
+	0.0165495f,
+	0.996512f,
+	-0.0817925f,
+	0.0843804f,
+	0.994583f,
+	-0.0606957f,
+	0.1131f,
+	0.990749f,
+	-0.0749933f,
+	0.241223f,
+	0.970417f,
+	0.0100747f,
+	0.396578f,
+	0.902933f,
+	0.165644f,
+	0.324808f,
+	0.936808f,
+	0.129963f,
+	0.0728626f,
+	0.997053f,
+	0.0240034f,
+	0.167633f,
+	0.975741f,
+	0.140815f,
+	0.474631f,
+	0.846984f,
+	0.239465f,
+	0.567824f,
+	0.786908f,
+	0.24156f,
+	0.402496f,
+	0.873451f,
+	0.274008f,
+	0.0459982f,
+	0.950641f,
+	0.306865f,
+	-0.0582337f,
+	0.962437f,
+	0.265188f,
+	0.030037f,
+	0.970181f,
+	0.240514f,
+	-0.0533502f,
+	0.992438f,
+	0.110548f,
+	0.0995416f,
+	0.988544f,
+	0.11346f,
+	0.255626f,
+	0.959556f,
+	0.11793f,
+	0.26735f,
+	0.961569f,
+	0.0625254f,
+	0.18836f,
+	0.981833f,
+	-0.0228855f,
+	0.278864f,
+	0.958778f,
+	-0.0545789f,
+	0.407529f,
+	0.909061f,
+	-0.086769f,
+	0.427129f,
+	0.902011f,
+	-0.0627458f,
+	0.408272f,
+	0.912551f,
+	-0.0237565f,
+	0.36375f,
+	0.922794f,
+	-0.127037f,
+	0.266363f,
+	0.919721f,
+	-0.28838f,
+	0.0788795f,
+	0.927162f,
+	-0.366263f,
+	0.0391177f,
+	0.978258f,
+	-0.20367f,
+	0.0160429f,
+	0.996725f,
+	-0.0792609f,
+	0.0608773f,
+	0.998141f,
+	0.00292939f,
+	0.025245f,
+	0.998361f,
+	-0.0513526f,
+	0.140845f,
+	0.988959f,
+	-0.046063f,
+	0.138979f,
+	0.986427f,
+	-0.0874468f,
+	0.128983f,
+	0.987322f,
+	-0.0925141f,
+	0.303074f,
+	0.948227f,
+	-0.0949297f,
+	0.392011f,
+	0.918105f,
+	-0.0584085f,
+	0.26566f,
+	0.960779f,
+	0.0795528f,
+	0.166068f,
+	0.98603f,
+	-0.0129125f,
+	0.262845f,
+	0.962536f,
+	-0.0666132f,
+	-0.104783f,
+	0.989703f,
+	0.0975085f,
+	-0.153604f,
+	0.984769f,
+	0.0814646f,
+	-0.17021f,
+	0.98292f,
+	0.0699758f,
+	-0.192965f,
+	0.974203f,
+	0.117018f,
+	-0.286836f,
+	0.952199f,
+	0.105086f,
+	-0.195248f,
+	0.969752f,
+	0.146488f,
+	-0.150662f,
+	0.967412f,
+	0.203504f,
+	-0.264752f,
+	0.950334f,
+	0.163619f,
+	-0.315905f,
+	0.913283f,
+	0.257134f,
+	-0.224744f,
+	0.91965f,
+	0.322078f,
+	-0.108929f,
+	0.947464f,
+	0.300743f,
+	0.0128823f,
+	0.944776f,
+	0.327463f,
+	-0.0190359f,
+	0.964202f,
+	0.264485f,
+	-0.187346f,
+	0.97974f,
+	0.0707926f,
+	-0.0647113f,
+	0.997854f,
+	-0.0100069f,
+	0.163923f,
+	0.98566f,
+	0.0400324f,
+	0.299244f,
+	0.952147f,
+	0.0622031f,
+	0.300231f,
+	0.948028f,
+	0.105378f,
+	0.182306f,
+	0.951449f,
+	0.248009f,
+	0.15023f,
+	0.937487f,
+	0.313924f,
+	0.264855f,
+	0.926023f,
+	0.268948f,
+	0.322593f,
+	0.919374f,
+	0.225135f,
+	0.43093f,
+	0.873406f,
+	0.22685f,
+	0.536094f,
+	0.828094f,
+	0.163899f,
+	0.40435f,
+	0.914491f,
+	0.0144028f,
+	0.203744f,
+	0.975451f,
+	-0.0835749f,
+	0.102706f,
+	0.983162f,
+	-0.151145f,
+	0.0912494f,
+	0.98262f,
+	-0.161654f,
+	0.0714052f,
+	0.991795f,
+	-0.106042f,
+	0.113839f,
+	0.992199f,
+	-0.0508211f,
+	0.266818f,
+	0.963676f,
+	0.0116937f,
+	0.379059f,
+	0.920849f,
+	0.091386f,
+	0.155245f,
+	0.98775f,
+	0.0158058f,
+	0.135484f,
+	0.989724f,
+	-0.0457313f,
+	0.394833f,
+	0.917954f,
+	-0.0383045f,
+	0.510875f,
+	0.847518f,
+	0.143943f,
+	0.369724f,
+	0.884704f,
+	0.283906f,
+	0.16927f,
+	0.926331f,
+	0.336538f,
+	-0.0368298f,
+	0.974452f,
+	0.221557f,
+	0.0247064f,
+	0.955492f,
+	0.293981f,
+	0.0101397f,
+	0.960739f,
+	0.27727f,
+	0.120365f,
+	0.954563f,
+	0.272621f,
+	0.285189f,
+	0.933274f,
+	0.218327f,
+	0.27356f,
+	0.947401f,
+	0.16612f,
+	0.298803f,
+	0.939862f,
+	0.165455f,
+	0.344494f,
+	0.938521f,
+	0.0223999f,
+	0.423232f,
+	0.90602f,
+	-0.00171397f,
+	0.428479f,
+	0.903517f,
+	-0.00795118f,
+	0.445837f,
+	0.889867f,
+	-0.0967762f,
+	0.420806f,
+	0.885752f,
+	-0.195872f,
+	0.361482f,
+	0.916002f,
+	-0.173987f,
+	0.0888846f,
+	0.94798f,
+	-0.305668f,
+	-0.104291f,
+	0.938663f,
+	-0.328687f,
+	-0.0525896f,
+	0.969771f,
+	-0.238281f,
+	0.0233793f,
+	0.980465f,
+	-0.1953f,
+	0.0772242f,
+	0.980658f,
+	-0.179852f,
+	0.158397f,
+	0.962723f,
+	-0.219259f,
+	0.207852f,
+	0.94171f,
+	-0.264536f,
+	0.167471f,
+	0.922973f,
+	-0.346518f,
+	0.273321f,
+	0.900673f,
+	-0.337764f,
+	0.244245f,
+	0.947327f,
+	-0.207161f,
+	0.179974f,
+	0.982676f,
+	-0.0442354f,
+	0.256056f,
+	0.966655f,
+	0.00369743f,
+	0.311224f,
+	0.950239f,
+	-0.0136096f,
+	-0.114346f,
+	0.96184f,
+	0.248574f,
+	-0.136601f,
+	0.952445f,
+	0.272377f,
+	-0.118024f,
+	0.9521f,
+	0.282091f,
+	-0.208962f,
+	0.956737f,
+	0.20246f,
+	-0.278994f,
+	0.940284f,
+	0.195009f,
+	-0.257672f,
+	0.939434f,
+	0.225986f,
+	-0.195307f,
+	0.931658f,
+	0.306381f,
+	-0.244185f,
+	0.930201f,
+	0.274044f,
+	-0.297894f,
+	0.926606f,
+	0.229479f,
+	-0.247712f,
+	0.954952f,
+	0.163421f,
+	-0.130651f,
+	0.964187f,
+	0.230812f,
+	-0.0752954f,
+	0.962878f,
+	0.259223f,
+	0.102408f,
+	0.945859f,
+	0.308f,
+	-0.0116154f,
+	0.986031f,
+	0.166158f,
+	0.0110135f,
+	0.994405f,
+	0.105056f,
+	0.0951503f,
+	0.992756f,
+	0.0733669f,
+	0.243797f,
+	0.961487f,
+	0.12691f,
+	0.260872f,
+	0.955085f,
+	0.140567f,
+	0.0581113f,
+	0.983556f,
+	0.170998f,
+	0.136043f,
+	0.955475f,
+	0.261839f,
+	0.341254f,
+	0.920705f,
+	0.189336f,
+	0.362462f,
+	0.927476f,
+	0.0917096f,
+	0.434756f,
+	0.897441f,
+	0.0747436f,
+	0.56712f,
+	0.819757f,
+	0.0798336f,
+	0.532941f,
+	0.840799f,
+	0.0950342f,
+	0.285812f,
+	0.957415f,
+	-0.0408404f,
+	0.105292f,
+	0.985973f,
+	-0.129498f,
+	0.0183827f,
+	0.988838f,
+	-0.147857f,
+	0.00614806f,
+	0.993133f,
+	-0.116825f,
+	0.099955f,
+	0.989102f,
+	-0.108098f,
+	0.238003f,
+	0.969438f,
+	-0.0595305f,
+	0.37769f,
+	0.925502f,
+	0.0282058f,
+	0.22782f,
+	0.973089f,
+	-0.0345812f,
+	0.169707f,
+	0.981804f,
+	-0.085208f,
+	0.345833f,
+	0.936168f,
+	-0.0631539f,
+	0.390375f,
+	0.920563f,
+	0.0130624f,
+	0.292594f,
+	0.949139f,
+	0.116291f,
+	0.162356f,
+	0.962761f,
+	0.216174f,
+	-0.0222207f,
+	0.972687f,
+	0.231055f,
+	-0.0543181f,
+	0.955402f,
+	0.290271f,
+	0.0573363f,
+	0.941579f,
+	0.331875f,
+	0.0971816f,
+	0.964596f,
+	0.245172f,
+	0.31345f,
+	0.917083f,
+	0.246388f,
+	0.307384f,
+	0.923753f,
+	0.228463f,
+	0.331585f,
+	0.921188f,
+	0.203628f,
+	0.40966f,
+	0.902178f,
+	0.135106f,
+	0.421265f,
+	0.901117f,
+	0.102585f,
+	0.477285f,
+	0.878068f,
+	0.0345826f,
+	0.547818f,
+	0.833857f,
+	-0.0676607f,
+	0.41388f,
+	0.899953f,
+	-0.13707f,
+	0.336726f,
+	0.938017f,
+	-0.0820957f,
+	0.267129f,
+	0.960427f,
+	-0.0788775f,
+	-0.0301028f,
+	0.966021f,
+	-0.256704f,
+	-0.102361f,
+	0.925067f,
+	-0.36575f,
+	-0.0109209f,
+	0.925593f,
+	-0.378364f,
+	0.0802595f,
+	0.925005f,
+	-0.371381f,
+	0.178475f,
+	0.901809f,
+	-0.393558f,
+	0.234643f,
+	0.9031f,
+	-0.359657f,
+	0.21073f,
+	0.932522f,
+	-0.29325f,
+	0.145492f,
+	0.962309f,
+	-0.22977f,
+	0.0986234f,
+	0.992893f,
+	-0.0666048f,
+	0.0609779f,
+	0.998071f,
+	0.0116837f,
+	0.208222f,
+	0.976086f,
+	0.0624398f,
+	0.291247f,
+	0.954621f,
+	0.0622453f,
+	-0.144182f,
+	0.940028f,
+	0.309126f,
+	-0.205006f,
+	0.91833f,
+	0.33859f,
+	-0.12423f,
+	0.88968f,
+	0.43936f,
+	-0.080186f,
+	0.900963f,
+	0.426423f,
+	-0.276852f,
+	0.915664f,
+	0.291398f,
+	-0.294009f,
+	0.912157f,
+	0.285532f,
+	-0.229314f,
+	0.935643f,
+	0.268306f,
+	-0.167187f,
+	0.934278f,
+	0.314918f,
+	-0.22242f,
+	0.937858f,
+	0.266367f,
+	-0.260643f,
+	0.947201f,
+	0.186748f,
+	-0.191964f,
+	0.952786f,
+	0.235261f,
+	-0.0626162f,
+	0.968356f,
+	0.24159f,
+	0.113658f,
+	0.975135f,
+	0.190246f,
+	0.0609991f,
+	0.983083f,
+	0.172707f,
+	0.00661942f,
+	0.987494f,
+	0.157516f,
+	0.132957f,
+	0.988179f,
+	0.0763221f,
+	0.229975f,
+	0.973129f,
+	-0.011475f,
+	0.267568f,
+	0.962445f,
+	0.0458956f,
+	0.0512446f,
+	0.996521f,
+	0.0657221f,
+	0.10251f,
+	0.994623f,
+	0.0147167f,
+	0.405413f,
+	0.913613f,
+	0.0308412f,
+	0.422693f,
+	0.905322f,
+	0.0415123f,
+	0.446493f,
+	0.894763f,
+	-0.00665318f,
+	0.517619f,
+	0.855611f,
+	0.00103599f,
+	0.493254f,
+	0.857934f,
+	0.143698f,
+	0.391227f,
+	0.901201f,
+	0.186488f,
+	0.212519f,
+	0.97466f,
+	0.0698119f,
+	0.0889638f,
+	0.99521f,
+	-0.0405254f,
+	0.0684633f,
+	0.989971f,
+	-0.123576f,
+	0.0764325f,
+	0.983592f,
+	-0.163418f,
+	0.104882f,
+	0.990961f,
+	-0.0836475f,
+	0.31755f,
+	0.948184f,
+	0.0104726f,
+	0.297752f,
+	0.954642f,
+	-0.00148102f,
+	0.157954f,
+	0.986909f,
+	-0.0325777f,
+	0.331713f,
+	0.943333f,
+	0.00940707f,
+	0.320973f,
+	0.946975f,
+	0.014661f,
+	0.220471f,
+	0.961455f,
+	0.164306f,
+	0.0647366f,
+	0.977455f,
+	0.200976f,
+	-0.0349474f,
+	0.961311f,
+	0.273238f,
+	-0.125874f,
+	0.956852f,
+	0.261896f,
+	0.0785055f,
+	0.963364f,
+	0.256449f,
+	0.211427f,
+	0.962249f,
+	0.171395f,
+	0.267083f,
+	0.952021f,
+	0.149409f,
+	0.340455f,
+	0.905998f,
+	0.251512f,
+	0.343062f,
+	0.921876f,
+	0.180149f,
+	0.420249f,
+	0.886024f,
+	0.195835f,
+	0.477229f,
+	0.85754f,
+	0.192034f,
+	0.564804f,
+	0.822942f,
+	0.0613434f,
+	0.583206f,
+	0.811559f,
+	-0.0352364f,
+	0.433319f,
+	0.897576f,
+	-0.0811897f,
+	0.291913f,
+	0.950865f,
+	-0.103166f,
+	0.268144f,
+	0.961121f,
+	-0.065914f,
+	0.14681f,
+	0.986926f,
+	-0.0665068f,
+	0.0393351f,
+	0.975019f,
+	-0.218612f,
+	0.042722f,
+	0.945279f,
+	-0.323454f,
+	0.104892f,
+	0.926937f,
+	-0.360257f,
+	0.188153f,
+	0.928382f,
+	-0.320477f,
+	0.104479f,
+	0.956869f,
+	-0.271082f,
+	0.039684f,
+	0.98773f,
+	-0.151046f,
+	0.0798596f,
+	0.996734f,
+	-0.0120106f,
+	0.0027229f,
+	0.999081f,
+	-0.0427778f,
+	0.0156228f,
+	0.999853f,
+	-0.00700924f,
+	0.224664f,
+	0.97266f,
+	0.058815f,
+	0.342188f,
+	0.939164f,
+	0.029646f,
+	-0.199093f,
+	0.881081f,
+	0.429019f,
+	-0.240385f,
+	0.861587f,
+	0.447083f,
+	-0.200309f,
+	0.881599f,
+	0.427386f,
+	-0.0492643f,
+	0.888913f,
+	0.455419f,
+	-0.146605f,
+	0.886582f,
+	0.438724f,
+	-0.194932f,
+	0.91844f,
+	0.344193f,
+	-0.212452f,
+	0.949737f,
+	0.229922f,
+	-0.231229f,
+	0.946978f,
+	0.223083f,
+	-0.22018f,
+	0.943947f,
+	0.245937f,
+	-0.155384f,
+	0.954263f,
+	0.255419f,
+	-0.222552f,
+	0.970336f,
+	0.0944332f,
+	0.0103498f,
+	0.996133f,
+	0.0872447f,
+	0.133012f,
+	0.991064f,
+	-0.00997971f,
+	0.0530236f,
+	0.995787f,
+	0.0748093f,
+	0.0840279f,
+	0.994917f,
+	0.0554967f,
+	0.25995f,
+	0.964887f,
+	-0.0376792f,
+	0.277109f,
+	0.958722f,
+	-0.0637373f,
+	0.172083f,
+	0.982525f,
+	-0.0709421f,
+	0.0951551f,
+	0.994032f,
+	-0.0533466f,
+	0.177084f,
+	0.970483f,
+	-0.163718f,
+	0.336303f,
+	0.91861f,
+	-0.207499f,
+	0.381503f,
+	0.916211f,
+	-0.122527f,
+	0.437128f,
+	0.898759f,
+	-0.0339342f,
+	0.471093f,
+	0.8784f,
+	0.0805223f,
+	0.407138f,
+	0.905658f,
+	0.118413f,
+	0.402844f,
+	0.901612f,
+	0.157519f,
+	0.327464f,
+	0.936685f,
+	0.124046f,
+	0.19809f,
+	0.980129f,
+	0.0103207f,
+	0.123868f,
+	0.987803f,
+	-0.0943524f,
+	0.0527864f,
+	0.989238f,
+	-0.136459f,
+	0.072462f,
+	0.988213f,
+	-0.134849f,
+	0.248671f,
+	0.959688f,
+	-0.131005f,
+	0.280617f,
+	0.958078f,
+	0.0577984f,
+	0.169552f,
+	0.981657f,
+	0.0871871f,
+	0.315169f,
+	0.946806f,
+	0.0650122f,
+	0.205308f,
+	0.973708f,
+	0.0986977f,
+	0.0950386f,
+	0.972165f,
+	0.214158f,
+	0.053629f,
+	0.964124f,
+	0.259978f,
+	-0.0859535f,
+	0.951705f,
+	0.294738f,
+	-0.0564482f,
+	0.948883f,
+	0.31054f,
+	0.154105f,
+	0.958817f,
+	0.238582f,
+	0.276457f,
+	0.946116f,
+	0.168629f,
+	0.211552f,
+	0.972531f,
+	0.0971047f,
+	0.294402f,
+	0.951062f,
+	0.0938527f,
+	0.390766f,
+	0.916003f,
+	0.0907783f,
+	0.406836f,
+	0.907458f,
+	0.104904f,
+	0.487803f,
+	0.868421f,
+	0.0888414f,
+	0.60401f,
+	0.790886f,
+	0.0983406f,
+	0.637938f,
+	0.762279f,
+	0.109387f,
+	0.4874f,
+	0.873178f,
+	0.00117935f,
+	0.336067f,
+	0.93258f,
+	-0.131735f,
+	0.229766f,
+	0.943375f,
+	-0.239272f,
+	0.152224f,
+	0.966237f,
+	-0.207882f,
+	0.121199f,
+	0.969969f,
+	-0.210883f,
+	0.121425f,
+	0.965511f,
+	-0.230314f,
+	0.0800447f,
+	0.963578f,
+	-0.255166f,
+	0.0996944f,
+	0.981315f,
+	-0.164563f,
+	0.0506382f,
+	0.996401f,
+	-0.0679735f,
+	-0.049503f,
+	0.998346f,
+	-0.0292297f,
+	0.050214f,
+	0.998168f,
+	0.0337586f,
+	0.113307f,
+	0.993459f,
+	0.014176f,
+	-0.000723347f,
+	0.991208f,
+	-0.132313f,
+	0.134265f,
+	0.980729f,
+	-0.141929f,
+	0.363008f,
+	0.931437f,
+	-0.0254801f,
+	-0.23486f,
+	0.827656f,
+	0.509732f,
+	-0.18483f,
+	0.851106f,
+	0.491383f,
+	-0.113579f,
+	0.917253f,
+	0.381767f,
+	-0.0885467f,
+	0.926234f,
+	0.366401f,
+	-0.119506f,
+	0.895756f,
+	0.428181f,
+	-0.107176f,
+	0.917761f,
+	0.382398f,
+	-0.0925542f,
+	0.950614f,
+	0.296253f,
+	-0.166069f,
+	0.978511f,
+	0.12222f,
+	-0.250375f,
+	0.968134f,
+	-0.00545859f,
+	-0.116612f,
+	0.99254f,
+	0.0355817f,
+	-0.0441586f,
+	0.99869f,
+	-0.0258397f,
+	0.0237183f,
+	0.990591f,
+	-0.134786f,
+	0.114156f,
+	0.992737f,
+	-0.0379611f,
+	0.0216237f,
+	0.999568f,
+	0.0199155f,
+	0.13918f,
+	0.98521f,
+	-0.0999564f,
+	0.240654f,
+	0.960885f,
+	-0.137059f,
+	0.249305f,
+	0.964708f,
+	-0.0847689f,
+	0.222546f,
+	0.966381f,
+	-0.128771f,
+	0.148234f,
+	0.971026f,
+	-0.187443f,
+	0.258813f,
+	0.946284f,
+	-0.193812f,
+	0.386195f,
+	0.898799f,
+	-0.207397f,
+	0.325896f,
+	0.902531f,
+	-0.281478f,
+	0.250321f,
+	0.93543f,
+	-0.249621f,
+	0.351402f,
+	0.936022f,
+	0.01949f,
+	0.42413f,
+	0.889134f,
+	0.171914f,
+	0.422963f,
+	0.898638f,
+	0.116411f,
+	0.393976f,
+	0.918547f,
+	0.0324739f,
+	0.283361f,
+	0.957155f,
+	-0.0596804f,
+	0.186222f,
+	0.979389f,
+	-0.0782236f,
+	0.100294f,
+	0.99243f,
+	-0.0708823f,
+	0.151138f,
+	0.983442f,
+	-0.0999959f,
+	0.115742f,
+	0.982035f,
+	-0.149033f,
+	0.0920961f,
+	0.993962f,
+	0.0596489f,
+	0.180728f,
+	0.97583f,
+	0.122852f,
+	0.267575f,
+	0.959234f,
+	0.0909572f,
+	0.204025f,
+	0.959594f,
+	0.193785f,
+	0.0830398f,
+	0.98516f,
+	0.150214f,
+	0.000808908f,
+	0.987078f,
+	0.160239f,
+	-0.115905f,
+	0.961815f,
+	0.247948f,
+	-0.0397732f,
+	0.972025f,
+	0.231484f,
+	0.185186f,
+	0.964166f,
+	0.189976f,
+	0.333936f,
+	0.928543f,
+	0.162155f,
+	0.358439f,
+	0.932281f,
+	0.0487095f,
+	0.30639f,
+	0.946624f,
+	-0.100142f,
+	0.389119f,
+	0.921183f,
+	-0.00273847f,
+	0.418957f,
+	0.907889f,
+	-0.0145855f,
+	0.498018f,
+	0.86538f,
+	-0.05563f,
+	0.565975f,
+	0.823958f,
+	-0.0276542f,
+	0.61235f,
+	0.789736f,
+	0.0366549f,
+	0.580326f,
+	0.809292f,
+	0.0909313f,
+	0.472624f,
+	0.880866f,
+	0.0264734f,
+	0.31167f,
+	0.948991f,
+	-0.0477351f,
+	0.149242f,
+	0.981946f,
+	-0.116226f,
+	0.114121f,
+	0.974963f,
+	-0.190851f,
+	0.0836789f,
+	0.981905f,
+	-0.169884f,
+	0.0779767f,
+	0.990421f,
+	-0.113957f,
+	0.0144442f,
+	0.982901f,
+	-0.183565f,
+	-0.021091f,
+	0.988398f,
+	-0.150415f,
+	-0.0454971f,
+	0.990828f,
+	-0.127242f,
+	-0.0180398f,
+	0.984723f,
+	-0.173189f,
+	0.129331f,
+	0.988095f,
+	-0.0833159f,
+	0.183553f,
+	0.978578f,
+	-0.0932403f,
+	0.123107f,
+	0.958699f,
+	-0.256402f,
+	0.189949f,
+	0.953063f,
+	-0.235775f,
+	-0.0544616f,
+	0.84489f,
+	0.53216f,
+	-0.0113297f,
+	0.890886f,
+	0.454085f,
+	-0.0462225f,
+	0.938549f,
+	0.342038f,
+	-0.128436f,
+	0.915911f,
+	0.380277f,
+	-0.159132f,
+	0.90887f,
+	0.385529f,
+	-0.0486608f,
+	0.932565f,
+	0.357708f,
+	0.0612592f,
+	0.9505f,
+	0.304627f,
+	0.0533898f,
+	0.988914f,
+	0.138559f,
+	-0.104607f,
+	0.992177f,
+	-0.0681298f,
+	-0.180998f,
+	0.963403f,
+	-0.197725f,
+	0.0184775f,
+	0.993878f,
+	-0.108929f,
+	-0.0166014f,
+	0.988229f,
+	-0.152078f,
+	-0.0077365f,
+	0.996975f,
+	-0.0773314f,
+	0.0579939f,
+	0.995726f,
+	-0.071872f,
+	0.284878f,
+	0.950639f,
+	-0.123003f,
+	0.233331f,
+	0.946766f,
+	-0.221789f,
+	0.274724f,
+	0.943287f,
+	-0.186374f,
+	0.284827f,
+	0.926731f,
+	-0.245036f,
+	0.143673f,
+	0.947988f,
+	-0.284037f,
+	0.183874f,
+	0.951741f,
+	-0.245725f,
+	0.373811f,
+	0.924384f,
+	-0.0760214f,
+	0.370847f,
+	0.928183f,
+	0.0307872f,
+	0.230777f,
+	0.972874f,
+	0.0160428f,
+	0.116854f,
+	0.992434f,
+	-0.0376857f,
+	0.311514f,
+	0.945104f,
+	0.0986779f,
+	0.493623f,
+	0.85792f,
+	0.14251f,
+	0.47336f,
+	0.879733f,
+	0.0447334f,
+	0.299829f,
+	0.953139f,
+	0.0403417f,
+	0.142324f,
+	0.985386f,
+	0.0935816f,
+	0.0780161f,
+	0.991843f,
+	0.100799f,
+	0.120483f,
+	0.987279f,
+	0.10375f,
+	0.113666f,
+	0.977351f,
+	0.178507f,
+	0.020827f,
+	0.987302f,
+	0.157484f,
+	0.18308f,
+	0.973453f,
+	0.137371f,
+	0.268344f,
+	0.949436f,
+	0.162981f,
+	0.178652f,
+	0.97403f,
+	0.139099f,
+	0.140521f,
+	0.985536f,
+	0.0947243f,
+	-0.0588959f,
+	0.995353f,
+	0.0761881f,
+	-0.17043f,
+	0.974748f,
+	0.144293f,
+	0.0194468f,
+	0.992819f,
+	0.118038f,
+	0.23167f,
+	0.972512f,
+	0.0234243f,
+	0.390625f,
+	0.920274f,
+	-0.0225152f,
+	0.45457f,
+	0.886543f,
+	-0.086066f,
+	0.307368f,
+	0.941264f,
+	-0.13981f,
+	0.289942f,
+	0.953608f,
+	-0.0810322f,
+	0.455218f,
+	0.890309f,
+	-0.0112281f,
+	0.513837f,
+	0.856124f,
+	-0.0549855f,
+	0.546925f,
+	0.836241f,
+	-0.0396788f,
+	0.583367f,
+	0.812208f,
+	-0.00110721f,
+	0.552934f,
+	0.832422f,
+	0.0365798f,
+	0.448406f,
+	0.891004f,
+	0.0710176f,
+	0.325547f,
+	0.934833f,
+	0.141795f,
+	0.239603f,
+	0.963586f,
+	0.118709f,
+	0.230453f,
+	0.97295f,
+	0.0160981f,
+	0.0486317f,
+	0.9909f,
+	-0.125509f,
+	0.0743177f,
+	0.991871f,
+	-0.103291f,
+	0.139517f,
+	0.9837f,
+	-0.11344f,
+	-0.0210587f,
+	0.976395f,
+	-0.214963f,
+	0.00854959f,
+	0.97326f,
+	-0.229548f,
+	0.0184659f,
+	0.95097f,
+	-0.308733f,
+	0.0120962f,
+	0.95636f,
+	-0.291939f,
+	0.153044f,
+	0.979201f,
+	-0.1332f,
+	0.190748f,
+	0.981634f,
+	-0.00308124f,
+	0.151842f,
+	0.988041f,
+	0.0268087f,
+	0.0319983f,
+	0.964154f,
+	0.263409f,
+	0.0761375f,
+	0.979983f,
+	0.183946f,
+	-0.0471561f,
+	0.98918f,
+	0.13892f,
+	-0.184804f,
+	0.965808f,
+	0.181831f,
+	-0.118202f,
+	0.977652f,
+	0.173852f,
+	-0.00263192f,
+	0.986244f,
+	0.165277f,
+	0.113935f,
+	0.977488f,
+	0.177586f,
+	0.213178f,
+	0.965311f,
+	0.150764f,
+	0.0917926f,
+	0.995582f,
+	-0.0197448f,
+	-0.112968f,
+	0.973922f,
+	-0.196759f,
+	-0.0750323f,
+	0.977001f,
+	-0.199598f,
+	0.0257774f,
+	0.985322f,
+	-0.168747f,
+	0.042721f,
+	0.964979f,
+	-0.258825f,
+	0.0821835f,
+	0.934135f,
+	-0.34733f,
+	0.254423f,
+	0.923351f,
+	-0.287563f,
+	0.255965f,
+	0.951062f,
+	-0.173101f,
+	0.240055f,
+	0.959513f,
+	-0.147338f,
+	0.319995f,
+	0.939284f,
+	-0.123892f,
+	0.15271f,
+	0.974885f,
+	-0.162111f,
+	0.132954f,
+	0.978157f,
+	-0.159787f,
+	0.156062f,
+	0.978958f,
+	-0.131476f,
+	0.237325f,
+	0.969005f,
+	0.0685979f,
+	0.280555f,
+	0.951122f,
+	0.129056f,
+	0.254605f,
+	0.966124f,
+	0.0421956f,
+	0.282663f,
+	0.955227f,
+	-0.087427f,
+	0.484968f,
+	0.871846f,
+	-0.0684877f,
+	0.483506f,
+	0.87515f,
+	-0.0182894f,
+	0.210764f,
+	0.97671f,
+	0.0402119f,
+	0.0804806f,
+	0.985666f,
+	0.148275f,
+	0.143859f,
+	0.967897f,
+	0.206108f,
+	0.0874346f,
+	0.987357f,
+	0.132215f,
+	0.0878227f,
+	0.985433f,
+	0.145635f,
+	0.118466f,
+	0.990277f,
+	0.0729134f,
+	0.170426f,
+	0.983396f,
+	-0.0623508f,
+	0.249461f,
+	0.967984f,
+	-0.0278496f,
+	0.240586f,
+	0.970589f,
+	0.00866192f,
+	0.158755f,
+	0.987312f,
+	0.00339798f,
+	-0.0496588f,
+	0.997869f,
+	0.0423253f,
+	-0.174436f,
+	0.984473f,
+	-0.0196346f,
+	0.0953847f,
+	0.991998f,
+	-0.0827112f,
+	0.301757f,
+	0.941321f,
+	-0.151184f,
+	0.416386f,
+	0.897492f,
+	-0.145363f,
+	0.439988f,
+	0.889223f,
+	-0.125274f,
+	0.313047f,
+	0.948071f,
+	-0.0562344f,
+	0.243151f,
+	0.96888f,
+	-0.0463665f,
+	0.428373f,
+	0.903467f,
+	-0.0156432f,
+	0.536849f,
+	0.842847f,
+	-0.0374461f,
+	0.521753f,
+	0.850621f,
+	-0.0649361f,
+	0.537565f,
+	0.842885f,
+	-0.02384f,
+	0.530522f,
+	0.843125f,
+	0.087673f,
+	0.408082f,
+	0.90082f,
+	0.148295f,
+	0.350282f,
+	0.920762f,
+	0.171756f,
+	0.275878f,
+	0.960222f,
+	0.0431791f,
+	0.279727f,
+	0.959242f,
+	0.0400889f,
+	0.199403f,
+	0.977085f,
+	0.0744484f,
+	0.0837631f,
+	0.994427f,
+	-0.0640234f,
+	0.142714f,
+	0.98022f,
+	-0.137117f,
+	0.0724844f,
+	0.974795f,
+	-0.211f,
+	0.0199047f,
+	0.956284f,
+	-0.29176f,
+	0.0419923f,
+	0.973015f,
+	-0.226887f,
+	-0.0571486f,
+	0.988577f,
+	-0.139464f,
+	-0.0620153f,
+	0.996095f,
+	-0.0628396f,
+	0.00941635f,
+	0.995205f,
+	0.097359f,
+	0.0452536f,
+	0.980521f,
+	0.191132f,
+	0.238692f,
+	0.970551f,
+	0.032497f,
+	0.18188f,
+	0.979621f,
+	-0.0852148f,
+	-0.0338772f,
+	0.991689f,
+	-0.124115f,
+	-0.215207f,
+	0.972977f,
+	-0.0836781f,
+	-0.127875f,
+	0.990711f,
+	-0.0462653f,
+	-0.0382254f,
+	0.999079f,
+	-0.0194842f,
+	0.0717625f,
+	0.997386f,
+	-0.00848587f,
+	0.235337f,
+	0.971913f,
+	0.00129577f,
+	0.258073f,
+	0.965901f,
+	-0.0208375f,
+	0.00563659f,
+	0.988134f,
+	-0.153488f,
+	-0.0963466f,
+	0.971245f,
+	-0.217715f,
+	0.0933449f,
+	0.976181f,
+	-0.19585f,
+	0.172697f,
+	0.943118f,
+	-0.284084f,
+	0.114064f,
+	0.91464f,
+	-0.387844f,
+	0.105309f,
+	0.920749f,
+	-0.375675f,
+	0.0952503f,
+	0.976152f,
+	-0.195075f,
+	0.198665f,
+	0.977736f,
+	-0.0675672f,
+	0.327274f,
+	0.944589f,
+	-0.0253815f,
+	0.185125f,
+	0.982311f,
+	-0.0281882f,
+	0.161734f,
+	0.983206f,
+	-0.0845435f,
+	0.135269f,
+	0.981463f,
+	-0.135765f,
+	0.160555f,
+	0.98307f,
+	-0.0882893f,
+	0.258909f,
+	0.96483f,
+	-0.0454967f,
+	0.342126f,
+	0.938267f,
+	0.0510447f,
+	0.36458f,
+	0.930989f,
+	-0.0184394f,
+	0.461971f,
+	0.885156f,
+	-0.0555142f,
+	0.401049f,
+	0.915892f,
+	-0.0173601f,
+	0.179695f,
+	0.981649f,
+	0.0638365f,
+	-0.0160491f,
+	0.998918f,
+	0.0436388f,
+	0.112643f,
+	0.989219f,
+	0.093583f,
+	0.158223f,
+	0.986353f,
+	0.0455405f,
+	0.150051f,
+	0.988439f,
+	-0.0217303f,
+	0.238384f,
+	0.964999f,
+	-0.10932f,
+	0.283357f,
+	0.938433f,
+	-0.197616f,
+	0.1814f,
+	0.953903f,
+	-0.239086f,
+	0.147672f,
+	0.981223f,
+	-0.124073f,
+	0.0988803f,
+	0.99502f,
+	-0.0125399f,
+	-0.0367309f,
+	0.999167f,
+	-0.0177995f,
+	-0.0641669f,
+	0.988893f,
+	-0.134067f,
+	0.155868f,
+	0.964972f,
+	-0.211032f,
+	0.311449f,
+	0.929937f,
+	-0.195488f,
+	0.363438f,
+	0.913854f,
+	-0.181064f,
+	0.379108f,
+	0.919625f,
+	-0.102794f,
+	0.251516f,
+	0.967833f,
+	-0.00624272f,
+	0.239964f,
+	0.970767f,
+	0.0053561f,
+	0.444229f,
+	0.895407f,
+	-0.0301255f,
+	0.561208f,
+	0.823627f,
+	-0.0817525f,
+	0.529532f,
+	0.843694f,
+	-0.0881851f,
+	0.463417f,
+	0.885698f,
+	-0.0280076f,
+	0.42264f,
+	0.895689f,
+	0.138263f,
+	0.360725f,
+	0.902736f,
+	0.234403f,
+	0.374064f,
+	0.893088f,
+	0.249939f,
+	0.398158f,
+	0.891769f,
+	0.214982f,
+	0.241834f,
+	0.965676f,
+	0.0947983f,
+	0.124224f,
+	0.988267f,
+	0.0888664f,
+	0.239364f,
+	0.964398f,
+	0.112437f,
+	0.252174f,
+	0.966402f,
+	-0.0497516f,
+	0.205848f,
+	0.974166f,
+	-0.0928869f,
+	0.0402048f,
+	0.980488f,
+	-0.192421f,
+	-0.109787f,
+	0.981783f,
+	-0.155076f,
+	-0.172809f,
+	0.983136f,
+	-0.0598348f,
+	-0.119927f,
+	0.992756f,
+	0.00723519f,
+	-0.0378691f,
+	0.997707f,
+	0.0560999f,
+	-0.018583f,
+	0.999146f,
+	0.0369096f,
+	0.311296f,
+	0.946614f,
+	-0.0837655f,
+	0.23235f,
+	0.967065f,
+	-0.103921f,
+	-0.0472012f,
+	0.997512f,
+	-0.0523709f,
+	-0.280913f,
+	0.95942f,
+	-0.0245033f,
+	-0.168558f,
+	0.985462f,
+	0.0212842f,
+	-0.0297654f,
+	0.999551f,
+	-0.00345095f,
+	0.14783f,
+	0.984722f,
+	-0.0920209f,
+	0.234818f,
+	0.942556f,
+	-0.23759f,
+	0.226f,
+	0.954601f,
+	-0.194065f,
+	0.0915505f,
+	0.991576f,
+	-0.0916283f,
+	-0.0384295f,
+	0.986109f,
+	-0.161594f,
+	0.0699749f,
+	0.969463f,
+	-0.235043f,
+	0.242042f,
+	0.947128f,
+	-0.210628f,
+	0.200696f,
+	0.954776f,
+	-0.21937f,
+	0.0684629f,
+	0.960296f,
+	-0.270452f,
+	-0.0178037f,
+	0.955193f,
+	-0.295449f,
+	0.106419f,
+	0.956511f,
+	-0.271592f,
+	0.250177f,
+	0.956337f,
+	-0.151101f,
+	0.206468f,
+	0.977841f,
+	-0.0346042f,
+	0.226301f,
+	0.972897f,
+	-0.047521f,
+	0.19172f,
+	0.975927f,
+	-0.103973f,
+	0.110286f,
+	0.969903f,
+	-0.217085f,
+	0.124805f,
+	0.979571f,
+	-0.157684f,
+	0.230362f,
+	0.972377f,
+	0.0376307f,
+	0.390327f,
+	0.9143f,
+	0.108165f,
+	0.486088f,
+	0.869528f,
+	0.0874049f,
+	0.355552f,
+	0.931184f,
+	0.0804947f,
+	0.162837f,
+	0.968115f,
+	0.190362f,
+	0.0587916f,
+	0.990094f,
+	0.127507f,
+	0.122084f,
+	0.99234f,
+	0.0189101f,
+	0.227899f,
+	0.973107f,
+	0.0335246f,
+	0.245712f,
+	0.968327f,
+	-0.0443735f,
+	0.235392f,
+	0.962107f,
+	-0.137626f,
+	0.299512f,
+	0.953154f,
+	0.0423112f,
+	0.158421f,
+	0.985528f,
+	0.0603087f,
+	0.0139537f,
+	0.99778f,
+	0.0651181f,
+	0.05695f,
+	0.991196f,
+	0.119526f,
+	0.0853993f,
+	0.993434f,
+	0.0761332f,
+	0.0800124f,
+	0.992698f,
+	-0.0902652f,
+	0.152744f,
+	0.965412f,
+	-0.211303f,
+	0.298303f,
+	0.938225f,
+	-0.175354f,
+	0.346617f,
+	0.918158f,
+	-0.191946f,
+	0.306791f,
+	0.939305f,
+	-0.153575f,
+	0.213668f,
+	0.966817f,
+	-0.140039f,
+	0.269123f,
+	0.94608f,
+	-0.180294f,
+	0.462084f,
+	0.866259f,
+	-0.189928f,
+	0.547323f,
+	0.828917f,
+	-0.11547f,
+	0.492713f,
+	0.870051f,
+	0.0156307f,
+	0.377637f,
+	0.925543f,
+	0.0275792f,
+	0.309374f,
+	0.94993f,
+	0.0438272f,
+	0.339128f,
+	0.933648f,
+	0.115296f,
+	0.355844f,
+	0.92275f,
+	0.148012f,
+	0.387104f,
+	0.898496f,
+	0.207015f,
+	0.394935f,
+	0.895155f,
+	0.206698f,
+	0.187014f,
+	0.981688f,
+	0.0362499f,
+	0.286474f,
+	0.957988f,
+	0.0138101f,
+	0.315633f,
+	0.944806f,
+	-0.0878444f,
+	0.189054f,
+	0.976628f,
+	-0.102261f,
+	0.071001f,
+	0.995263f,
+	-0.066411f,
+	-0.121993f,
+	0.990638f,
+	-0.0612738f,
+	-0.195423f,
+	0.978588f,
+	-0.0646113f,
+	-0.134933f,
+	0.988908f,
+	-0.0620808f,
+	-0.0362027f,
+	0.9885f,
+	-0.146822f,
+	0.0247852f,
+	0.975168f,
+	-0.220074f,
+	0.236634f,
+	0.970435f,
+	-0.0475491f,
+	0.163622f,
+	0.985347f,
+	0.0481553f,
+	-0.110204f,
+	0.98299f,
+	0.146921f,
+	-0.274076f,
+	0.953125f,
+	0.128197f,
+	-0.127913f,
+	0.990913f,
+	0.0415925f,
+	0.0693505f,
+	0.994264f,
+	-0.081428f,
+	0.246728f,
+	0.957329f,
+	-0.15049f,
+	0.356012f,
+	0.927656f,
+	-0.112735f,
+	0.108926f,
+	0.979602f,
+	-0.168863f,
+	-0.0117435f,
+	0.995074f,
+	-0.0984399f,
+	0.0591802f,
+	0.992813f,
+	-0.104017f,
+	0.152983f,
+	0.961405f,
+	-0.228683f,
+	0.199436f,
+	0.939216f,
+	-0.279462f,
+	0.158919f,
+	0.956661f,
+	-0.244017f,
+	0.142246f,
+	0.964436f,
+	-0.222776f,
+	0.0928224f,
+	0.948092f,
+	-0.304146f,
+	0.072096f,
+	0.927878f,
+	-0.365849f,
+	0.0949024f,
+	0.954182f,
+	-0.28378f,
+	0.0839904f,
+	0.981792f,
+	-0.17038f,
+	0.207123f,
+	0.975655f,
+	-0.0720922f,
+	0.306863f,
+	0.948734f,
+	-0.075756f,
+	0.227677f,
+	0.946857f,
+	-0.22721f,
+	0.0209281f,
+	0.957849f,
+	-0.28651f,
+	0.0889558f,
+	0.973432f,
+	-0.210993f,
+	0.377519f,
+	0.908654f,
+	-0.178401f,
+	0.444767f,
+	0.867771f,
+	-0.22171f,
+	0.296477f,
+	0.952876f,
+	-0.0642486f,
+	0.049587f,
+	0.998699f,
+	0.0118749f,
+	0.185088f,
+	0.975344f,
+	0.120192f,
+	0.179316f,
+	0.983776f,
+	0.00553586f,
+	0.203508f,
+	0.978758f,
+	-0.0248474f,
+	0.30632f,
+	0.951877f,
+	-0.00993344f,
+	0.182507f,
+	0.983075f,
+	0.0159703f,
+	0.0804506f,
+	0.991985f,
+	0.0974322f,
+	0.170994f,
+	0.963788f,
+	0.204629f,
+	0.0962731f,
+	0.986887f,
+	0.12956f,
+	0.097797f,
+	0.995201f,
+	0.00337759f,
+	0.147003f,
+	0.987459f,
+	-0.0575677f,
+	0.218112f,
+	0.972969f,
+	-0.0758899f,
+	0.244949f,
+	0.956598f,
+	-0.157862f,
+	0.315584f,
+	0.924587f,
+	-0.213415f,
+	0.352441f,
+	0.893692f,
+	-0.277668f,
+	0.28482f,
+	0.905458f,
+	-0.31468f,
+	0.265138f,
+	0.910445f,
+	-0.317477f,
+	0.308383f,
+	0.884493f,
+	-0.350102f,
+	0.390084f,
+	0.870652f,
+	-0.299665f,
+	0.373263f,
+	0.922794f,
+	-0.0955261f,
+	0.378781f,
+	0.918384f,
+	0.114439f,
+	0.476669f,
+	0.866105f,
+	0.150494f,
+	0.353048f,
+	0.93424f,
+	-0.0505168f,
+	0.309942f,
+	0.946077f,
+	-0.0942048f,
+	0.298518f,
+	0.948219f,
+	-0.108479f,
+	0.350416f,
+	0.935917f,
+	-0.0356219f,
+	0.447907f,
+	0.893892f,
+	-0.0183155f,
+	0.280155f,
+	0.95286f,
+	-0.116492f,
+	0.270748f,
+	0.951225f,
+	-0.147871f,
+	0.374052f,
+	0.922269f,
+	-0.0974917f,
+	0.176754f,
+	0.980223f,
+	-0.0889943f,
+	0.0634799f,
+	0.992926f,
+	-0.100339f,
+	-0.11806f,
+	0.977045f,
+	-0.177329f,
+	-0.199746f,
+	0.955239f,
+	-0.218219f,
+	-0.0812223f,
+	0.969857f,
+	-0.229739f,
+	0.130179f,
+	0.951543f,
+	-0.278602f,
+	0.200559f,
+	0.919086f,
+	-0.339202f,
+	0.0174361f,
+	0.999489f,
+	0.0268061f,
+	0.0105554f,
+	0.991703f,
+	0.128113f,
+	-0.141198f,
+	0.973013f,
+	0.182506f,
+	-0.142313f,
+	0.985833f,
+	0.0887713f,
+	0.00597934f,
+	0.99465f,
+	-0.103131f,
+	0.213448f,
+	0.959986f,
+	-0.181295f,
+	0.150446f,
+	0.953754f,
+	-0.260228f,
+	0.244008f,
+	0.968351f,
+	-0.0525036f,
+	0.184758f,
+	0.982743f,
+	0.00893989f,
+	-0.00567918f,
+	0.992902f,
+	-0.118797f,
+	0.138037f,
+	0.98016f,
+	-0.142241f,
+	0.21929f,
+	0.962205f,
+	-0.16147f,
+	0.269703f,
+	0.95408f,
+	-0.13035f,
+	0.150911f,
+	0.956731f,
+	-0.24878f,
+	0.180021f,
+	0.944452f,
+	-0.27496f,
+	0.119147f,
+	0.92214f,
+	-0.368051f,
+	0.0669033f,
+	0.930661f,
+	-0.359714f,
+	-0.0113587f,
+	0.942765f,
+	-0.333265f,
+	0.0142182f,
+	0.972628f,
+	-0.231934f,
+	0.163413f,
+	0.959027f,
+	-0.231437f,
+	0.324001f,
+	0.919871f,
+	-0.221046f,
+	0.291919f,
+	0.93701f,
+	-0.19182f,
+	0.107512f,
+	0.968299f,
+	-0.225473f,
+	0.0749887f,
+	0.923898f,
+	-0.375218f,
+	0.415609f,
+	0.849812f,
+	-0.324172f,
+	0.314994f,
+	0.92041f,
+	-0.231569f,
+	0.136459f,
+	0.990645f,
+	0.000905767f,
+	0.00734966f,
+	0.998995f,
+	0.0442195f,
+	0.0805668f,
+	0.996634f,
+	0.0151596f,
+	0.266119f,
+	0.962333f,
+	0.0556322f,
+	0.269187f,
+	0.962624f,
+	-0.0298845f,
+	0.209195f,
+	0.975524f,
+	-0.0677535f,
+	0.153299f,
+	0.985902f,
+	0.0670637f,
+	0.0587395f,
+	0.996349f,
+	0.0619523f,
+	0.20348f,
+	0.97612f,
+	0.0760684f,
+	0.225978f,
+	0.971688f,
+	-0.0689656f,
+	0.204562f,
+	0.957442f,
+	-0.203617f,
+	0.164418f,
+	0.955123f,
+	-0.246386f,
+	0.1725f,
+	0.961839f,
+	-0.212392f,
+	0.288653f,
+	0.947463f,
+	-0.137816f,
+	0.355829f,
+	0.918236f,
+	-0.173863f,
+	0.453757f,
+	0.873536f,
+	-0.176182f,
+	0.355645f,
+	0.881401f,
+	-0.310884f,
+	0.238917f,
+	0.864251f,
+	-0.442706f,
+	0.251593f,
+	0.863453f,
+	-0.437206f,
+	0.231383f,
+	0.92049f,
+	-0.314896f,
+	0.219172f,
+	0.968344f,
+	-0.119471f,
+	0.254773f,
+	0.966196f,
+	-0.0394394f,
+	0.482542f,
+	0.873342f,
+	0.0665443f,
+	0.470019f,
+	0.880685f,
+	0.0589576f,
+	0.359563f,
+	0.932576f,
+	-0.0318683f,
+	0.336062f,
+	0.937393f,
+	-0.0914179f,
+	0.320744f,
+	0.932455f,
+	-0.166285f,
+	0.428106f,
+	0.887361f,
+	-0.171217f,
+	0.372336f,
+	0.918652f,
+	-0.132074f,
+	0.247289f,
+	0.941171f,
+	-0.230314f,
+	0.287477f,
+	0.950239f,
+	-0.120008f,
+	0.121799f,
+	0.989487f,
+	-0.0779795f,
+	0.132326f,
+	0.991166f,
+	-0.00888466f,
+	-0.00459516f,
+	0.997934f,
+	-0.0640824f,
+	-0.0924696f,
+	0.984613f,
+	-0.148277f,
+	-0.0479758f,
+	0.968834f,
+	-0.243019f,
+	0.052427f,
+	0.976364f,
+	-0.209677f,
+	0.223214f,
+	0.97397f,
+	-0.0394671f,
+	0.0112214f,
+	0.972418f,
+	0.232975f,
+	0.0106355f,
+	0.967748f,
+	0.251694f,
+	-0.0743183f,
+	0.979789f,
+	0.185717f,
+	0.0581795f,
+	0.9982f,
+	0.01459f,
+	0.133434f,
+	0.964693f,
+	-0.227076f,
+	0.215981f,
+	0.948544f,
+	-0.231554f,
+	0.137408f,
+	0.968029f,
+	-0.209856f,
+	0.0442022f,
+	0.987042f,
+	-0.154256f,
+	0.228305f,
+	0.972284f,
+	0.0504f,
+	0.121617f,
+	0.992241f,
+	-0.0258404f,
+	0.134527f,
+	0.985242f,
+	-0.105833f,
+	0.151618f,
+	0.980953f,
+	-0.121423f,
+	0.275183f,
+	0.956894f,
+	-0.092891f,
+	0.263324f,
+	0.945384f,
+	-0.192117f,
+	0.25647f,
+	0.929449f,
+	-0.26523f,
+	0.21073f,
+	0.904026f,
+	-0.371926f,
+	0.0728135f,
+	0.89169f,
+	-0.446751f,
+	-0.0691284f,
+	0.877831f,
+	-0.473955f,
+	-0.019884f,
+	0.913569f,
+	-0.406197f,
+	0.178205f,
+	0.891525f,
+	-0.416444f,
+	0.263993f,
+	0.900279f,
+	-0.34613f,
+	0.210305f,
+	0.939702f,
+	-0.269689f,
+	0.208408f,
+	0.948624f,
+	-0.238074f,
+	0.229275f,
+	0.910156f,
+	-0.345036f,
+	0.227512f,
+	0.924458f,
+	-0.305966f,
+	0.142229f,
+	0.989234f,
+	0.0344507f,
+	-0.0464441f,
+	0.986357f,
+	0.157934f,
+	0.073391f,
+	0.981122f,
+	0.178921f,
+	0.158555f,
+	0.984472f,
+	0.0753311f,
+	0.265489f,
+	0.961878f,
+	0.0656237f,
+	0.318063f,
+	0.94383f,
+	0.0895592f,
+	0.229589f,
+	0.973115f,
+	0.0183382f,
+	0.0918017f,
+	0.995548f,
+	-0.0213497f,
+	0.0710209f,
+	0.997458f,
+	0.00582691f,
+	0.234172f,
+	0.971044f,
+	-0.0473045f,
+	0.373198f,
+	0.918081f,
+	-0.133603f,
+	0.27855f,
+	0.93462f,
+	-0.221124f,
+	0.174681f,
+	0.94082f,
+	-0.290421f,
+	0.0816739f,
+	0.936818f,
+	-0.34015f,
+	0.233666f,
+	0.948403f,
+	-0.214319f,
+	0.373882f,
+	0.91082f,
+	-0.174984f,
+	0.44036f,
+	0.88198f,
+	-0.16791f,
+	0.496092f,
+	0.86017f,
+	-0.118324f,
+	0.420226f,
+	0.875748f,
+	-0.237645f,
+	0.228936f,
+	0.896528f,
+	-0.379243f,
+	0.0594423f,
+	0.913794f,
+	-0.401806f,
+	0.0971839f,
+	0.949435f,
+	-0.298544f,
+	0.201575f,
+	0.953775f,
+	-0.222894f,
+	0.339139f,
+	0.935667f,
+	-0.0975326f,
+	0.471026f,
+	0.864094f,
+	0.177416f,
+	0.409402f,
+	0.896788f,
+	0.167814f,
+	0.414181f,
+	0.90532f,
+	0.0940739f,
+	0.426161f,
+	0.903473f,
+	-0.0460849f,
+	0.431652f,
+	0.886771f,
+	-0.165266f,
+	0.36903f,
+	0.909898f,
+	-0.189479f,
+	0.237762f,
+	0.950577f,
+	-0.199683f,
+	0.250405f,
+	0.963718f,
+	-0.0924377f,
+	0.100123f,
+	0.989034f,
+	-0.108572f,
+	0.0410755f,
+	0.997876f,
+	-0.0505615f,
+	0.0233843f,
+	0.999496f,
+	0.0214792f,
+	-0.0536722f,
+	0.998467f,
+	-0.0135057f,
+	0.00107433f,
+	0.999993f,
+	-0.00356525f,
+	-0.0705196f,
+	0.996911f,
+	-0.0345704f,
+	-0.0688919f,
+	0.997514f,
+	0.0148223f,
+	-0.0812179f,
+	0.983535f,
+	0.161436f,
+	-0.0138011f,
+	0.988231f,
+	0.152344f,
+	0.0655184f,
+	0.995642f,
+	0.0663652f,
+	0.220598f,
+	0.973784f,
+	-0.0554998f,
+	0.309629f,
+	0.942731f,
+	-0.124049f,
+	0.155774f,
+	0.947975f,
+	-0.27763f,
+	0.127196f,
+	0.974249f,
+	-0.186174f,
+	-0.058769f,
+	0.981296f,
+	-0.183314f,
+	0.0497615f,
+	0.99612f,
+	-0.0725919f,
+	0.182926f,
+	0.98205f,
+	0.0460018f,
+	0.19209f,
+	0.981195f,
+	-0.0189005f,
+	0.224403f,
+	0.972569f,
+	-0.0612647f,
+	0.315645f,
+	0.941316f,
+	-0.119552f,
+	0.360736f,
+	0.920207f,
+	-0.151949f,
+	0.310465f,
+	0.916626f,
+	-0.251809f,
+	0.327403f,
+	0.899549f,
+	-0.28917f,
+	0.161725f,
+	0.896729f,
+	-0.411973f,
+	-0.0141039f,
+	0.865769f,
+	-0.500245f,
+	-0.0292484f,
+	0.82172f,
+	-0.56914f,
+	0.0961328f,
+	0.815723f,
+	-0.570398f,
+	0.101793f,
+	0.868026f,
+	-0.485972f,
+	0.156302f,
+	0.922247f,
+	-0.353597f,
+	0.205267f,
+	0.935719f,
+	-0.286871f,
+	0.229076f,
+	0.948515f,
+	-0.218729f,
+	0.0347356f,
+	0.987904f,
+	-0.151126f,
+	-0.079026f,
+	0.996018f,
+	0.0412683f,
+	-0.00943989f,
+	0.997185f,
+	0.0743796f,
+	0.111542f,
+	0.993598f,
+	-0.0179121f,
+	0.186771f,
+	0.982172f,
+	0.0213291f,
+	0.207496f,
+	0.975443f,
+	0.0738717f,
+	0.321818f,
+	0.944637f,
+	0.0639911f,
+	0.281397f,
+	0.958917f,
+	0.0359716f,
+	0.126766f,
+	0.988281f,
+	0.0850327f,
+	0.0940702f,
+	0.995531f,
+	0.0082479f,
+	0.338235f,
+	0.93955f,
+	-0.0533163f,
+	0.410978f,
+	0.899199f,
+	-0.150126f,
+	0.338008f,
+	0.912085f,
+	-0.232059f,
+	0.265939f,
+	0.902685f,
+	-0.338284f,
+	0.120839f,
+	0.912428f,
+	-0.39099f,
+	0.0943411f,
+	0.91428f,
+	-0.393944f,
+	0.326367f,
+	0.911608f,
+	-0.24991f,
+	0.410002f,
+	0.90171f,
+	-0.137175f,
+	0.446036f,
+	0.89335f,
+	-0.054576f,
+	0.453415f,
+	0.890674f,
+	0.0333893f,
+	0.369882f,
+	0.926554f,
+	0.0684487f,
+	0.15305f,
+	0.985829f,
+	-0.0686756f,
+	0.0307343f,
+	0.980172f,
+	-0.195752f,
+	0.104404f,
+	0.981192f,
+	-0.162361f,
+	0.153412f,
+	0.984343f,
+	-0.086793f,
+	0.259868f,
+	0.962798f,
+	0.0740869f,
+	0.405239f,
+	0.886729f,
+	0.222469f,
+	0.507863f,
+	0.829218f,
+	0.233395f,
+	0.530784f,
+	0.842353f,
+	0.0933228f,
+	0.515092f,
+	0.857118f,
+	0.0053912f,
+	0.421652f,
+	0.904509f,
+	-0.0638277f,
+	0.186762f,
+	0.968676f,
+	-0.16367f,
+	0.141357f,
+	0.986443f,
+	-0.0833539f,
+	0.10637f,
+	0.994244f,
+	0.0127965f,
+	-0.010764f,
+	0.999348f,
+	-0.0344492f,
+	-0.00443345f,
+	0.999867f,
+	-0.0156939f,
+	-0.0569297f,
+	0.998142f,
+	0.0217125f,
+	-0.0108274f,
+	0.998516f,
+	0.0533776f,
+	-0.0518054f,
+	0.997615f,
+	0.0456197f,
+	-0.08879f,
+	0.991878f,
+	0.0910736f,
+	0.15627f,
+	0.9777f,
+	0.14029f,
+	0.127078f,
+	0.991794f,
+	-0.0140045f,
+	0.182153f,
+	0.975854f,
+	-0.12054f,
+	0.236919f,
+	0.957374f,
+	-0.165238f,
+	0.354425f,
+	0.924081f,
+	-0.143031f,
+	0.22947f,
+	0.95204f,
+	-0.202395f,
+	0.0414456f,
+	0.986576f,
+	-0.157956f,
+	-0.0334694f,
+	0.988237f,
+	-0.149222f,
+	-0.0516418f,
+	0.976013f,
+	-0.2115f,
+	0.149794f,
+	0.980531f,
+	-0.126967f,
+	0.232135f,
+	0.958309f,
+	-0.166606f,
+	0.253821f,
+	0.951991f,
+	-0.171138f,
+	0.306434f,
+	0.927336f,
+	-0.214818f,
+	0.397399f,
+	0.902704f,
+	-0.164923f,
+	0.371523f,
+	0.904625f,
+	-0.208864f,
+	0.394746f,
+	0.892045f,
+	-0.220071f,
+	0.272791f,
+	0.90211f,
+	-0.334339f,
+	0.143123f,
+	0.890975f,
+	-0.430905f,
+	0.0302622f,
+	0.843122f,
+	-0.53687f,
+	0.0628652f,
+	0.888185f,
+	-0.455165f,
+	0.00848379f,
+	0.914478f,
+	-0.404546f,
+	0.009201f,
+	0.926788f,
+	-0.375473f,
+	0.0671766f,
+	0.952807f,
+	-0.296052f,
+	0.132209f,
+	0.974746f,
+	-0.179973f,
+	-0.0203291f,
+	0.99362f,
+	-0.110936f,
+	-0.138553f,
+	0.985569f,
+	-0.0972441f,
+	0.0605753f,
+	0.989699f,
+	-0.129717f,
+	0.0968295f,
+	0.980926f,
+	-0.168548f,
+	0.0979519f,
+	0.993956f,
+	-0.0495753f,
+	0.201443f,
+	0.976928f,
+	-0.0709446f,
+	0.381986f,
+	0.916436f,
+	-0.119294f,
+	0.157625f,
+	0.97891f,
+	-0.12996f,
+	0.10065f,
+	0.993729f,
+	0.0486956f,
+	0.194299f,
+	0.980695f,
+	-0.0220253f,
+	0.364962f,
+	0.929379f,
+	-0.0552881f,
+	0.487949f,
+	0.871552f,
+	-0.0479875f,
+	0.462417f,
+	0.883871f,
+	-0.0702998f,
+	0.341292f,
+	0.927621f,
+	-0.151788f,
+	0.13195f,
+	0.962323f,
+	-0.237746f,
+	0.0784249f,
+	0.961522f,
+	-0.263298f,
+	0.155522f,
+	0.961843f,
+	-0.225101f,
+	0.275269f,
+	0.959916f,
+	-0.0528088f,
+	0.354301f,
+	0.927858f,
+	0.116403f,
+	0.359914f,
+	0.906647f,
+	0.22012f,
+	0.307706f,
+	0.904557f,
+	0.295117f,
+	0.281691f,
+	0.897787f,
+	0.338569f,
+	0.169122f,
+	0.964903f,
+	0.200898f,
+	0.116857f,
+	0.992098f,
+	0.045666f,
+	0.131422f,
+	0.991068f,
+	-0.0226175f,
+	0.19688f,
+	0.980005f,
+	-0.0287978f,
+	0.332698f,
+	0.942383f,
+	-0.0350149f,
+	0.49437f,
+	0.868541f,
+	-0.0351363f,
+	0.591151f,
+	0.806162f,
+	-0.0253575f,
+	0.528595f,
+	0.848271f,
+	-0.0319893f,
+	0.452945f,
+	0.891538f,
+	3.96151e-005f,
+	0.269718f,
+	0.962267f,
+	0.0359679f,
+	0.0172075f,
+	0.99965f,
+	0.0201157f,
+	0.0836306f,
+	0.98488f,
+	0.151715f,
+	0.0817519f,
+	0.992549f,
+	0.0903531f,
+	-0.0289252f,
+	0.999464f,
+	0.015311f,
+	-0.0977995f,
+	0.99488f,
+	0.0254794f,
+	-0.0368101f,
+	0.998502f,
+	0.0404932f,
+	-0.0917396f,
+	0.988968f,
+	0.116306f,
+	-0.19824f,
+	0.961924f,
+	0.188156f,
+	0.355147f,
+	0.931267f,
+	-0.0813196f,
+	0.261709f,
+	0.946669f,
+	-0.187953f,
+	0.187089f,
+	0.954576f,
+	-0.23191f,
+	0.281523f,
+	0.925027f,
+	-0.255086f,
+	0.340665f,
+	0.862289f,
+	-0.374707f,
+	0.168991f,
+	0.920317f,
+	-0.352786f,
+	-0.0114217f,
+	0.969014f,
+	-0.246743f,
+	0.0275027f,
+	0.971061f,
+	-0.237244f,
+	0.0127748f,
+	0.945787f,
+	-0.324537f,
+	0.106685f,
+	0.927276f,
+	-0.358857f,
+	0.242554f,
+	0.910981f,
+	-0.333589f,
+	0.254201f,
+	0.919334f,
+	-0.300346f,
+	0.319051f,
+	0.907348f,
+	-0.273727f,
+	0.384836f,
+	0.892504f,
+	-0.235241f,
+	0.359386f,
+	0.889916f,
+	-0.280877f,
+	0.418755f,
+	0.87516f,
+	-0.242361f,
+	0.378513f,
+	0.873068f,
+	-0.307377f,
+	0.247447f,
+	0.872868f,
+	-0.420561f,
+	0.0334574f,
+	0.868028f,
+	-0.495387f,
+	-0.104393f,
+	0.897693f,
+	-0.428077f,
+	-0.0466408f,
+	0.949283f,
+	-0.310944f,
+	0.00907853f,
+	0.960916f,
+	-0.276691f,
+	0.00868667f,
+	0.966036f,
+	-0.258261f,
+	0.0845957f,
+	0.976098f,
+	-0.200192f,
+	-0.0296926f,
+	0.969375f,
+	-0.243785f,
+	-0.104852f,
+	0.955765f,
+	-0.274807f,
+	0.0855702f,
+	0.957819f,
+	-0.274336f,
+	0.0411396f,
+	0.961225f,
+	-0.272681f,
+	0.0481708f,
+	0.973933f,
+	-0.221661f,
+	0.28909f,
+	0.93695f,
+	-0.196346f,
+	0.356766f,
+	0.919532f,
+	-0.164859f,
+	0.126757f,
+	0.9882f,
+	-0.0859897f,
+	0.0144124f,
+	0.990867f,
+	-0.134068f,
+	0.233251f,
+	0.969449f,
+	-0.075909f,
+	0.354937f,
+	0.93426f,
+	-0.034317f,
+	0.469402f,
+	0.882971f,
+	-0.00493066f,
+	0.398385f,
+	0.917184f,
+	-0.00790304f,
+	0.386606f,
+	0.918227f,
+	0.0859925f,
+	0.228789f,
+	0.970147f,
+	0.0804364f,
+	0.115903f,
+	0.993259f,
+	0.0019484f,
+	0.110471f,
+	0.992802f,
+	-0.0462595f,
+	0.159257f,
+	0.98723f,
+	-0.00373461f,
+	0.193831f,
+	0.979844f,
+	0.0483161f,
+	0.304703f,
+	0.938233f,
+	0.163935f,
+	0.27363f,
+	0.944953f,
+	0.179417f,
+	0.268196f,
+	0.936861f,
+	0.224416f,
+	0.306571f,
+	0.922686f,
+	0.233806f,
+	0.304362f,
+	0.944561f,
+	0.123164f,
+	0.226364f,
+	0.97021f,
+	-0.0863264f,
+	0.198019f,
+	0.963611f,
+	-0.179562f,
+	0.39862f,
+	0.902547f,
+	-0.162819f,
+	0.534677f,
+	0.804719f,
+	-0.257967f,
+	0.537872f,
+	0.788638f,
+	-0.297899f,
+	0.486148f,
+	0.837034f,
+	-0.251066f,
+	0.374822f,
+	0.901369f,
+	-0.216893f,
+	0.171725f,
+	0.976903f,
+	-0.127168f,
+	-0.0108013f,
+	0.999941f,
+	-0.00151679f,
+	0.0247265f,
+	0.999687f,
+	-0.00377037f,
+	0.135958f,
+	0.990654f,
+	0.0109791f,
+	-0.00717425f,
+	0.999252f,
+	0.0379956f,
+	-0.0710711f,
+	0.991911f,
+	0.105175f,
+	-0.0859239f,
+	0.990395f,
+	0.108328f,
+	-0.18335f,
+	0.97033f,
+	0.157612f,
+	-0.315275f,
+	0.941315f,
+	0.120535f,
+	0.340669f,
+	0.883831f,
+	-0.320605f,
+	0.289176f,
+	0.886429f,
+	-0.361416f,
+	0.20883f,
+	0.874721f,
+	-0.437325f,
+	0.364068f,
+	0.812937f,
+	-0.454519f,
+	0.367133f,
+	0.769647f,
+	-0.522357f,
+	0.0748495f,
+	0.818621f,
+	-0.569436f,
+	-0.0872921f,
+	0.835085f,
+	-0.543151f,
+	0.00846427f,
+	0.872897f,
+	-0.48783f,
+	0.114223f,
+	0.886407f,
+	-0.448593f,
+	0.0920189f,
+	0.872463f,
+	-0.479939f,
+	0.2125f,
+	0.893929f,
+	-0.394633f,
+	0.175058f,
+	0.869572f,
+	-0.461735f,
+	0.23988f,
+	0.874417f,
+	-0.421725f,
+	0.3397f,
+	0.869601f,
+	-0.358326f,
+	0.392151f,
+	0.874231f,
+	-0.286248f,
+	0.401032f,
+	0.871377f,
+	-0.282622f,
+	0.447169f,
+	0.847971f,
+	-0.28458f,
+	0.337548f,
+	0.868339f,
+	-0.363386f,
+	0.0674983f,
+	0.896564f,
+	-0.437742f,
+	-0.167145f,
+	0.867884f,
+	-0.467804f,
+	-0.130341f,
+	0.888597f,
+	-0.43978f,
+	-0.0513088f,
+	0.927515f,
+	-0.370248f,
+	-0.0499693f,
+	0.955154f,
+	-0.291861f,
+	0.0619562f,
+	0.966501f,
+	-0.249073f,
+	0.104114f,
+	0.952328f,
+	-0.28676f,
+	-0.0782617f,
+	0.904542f,
+	-0.419141f,
+	0.00654125f,
+	0.918336f,
+	-0.395747f,
+	0.0825819f,
+	0.944757f,
+	-0.317199f,
+	0.028702f,
+	0.9283f,
+	-0.370722f,
+	0.170752f,
+	0.927761f,
+	-0.331819f,
+	0.188742f,
+	0.965638f,
+	-0.178664f,
+	0.126613f,
+	0.983535f,
+	0.12895f,
+	0.0677004f,
+	0.989289f,
+	0.129321f,
+	0.179931f,
+	0.977134f,
+	0.113286f,
+	0.301628f,
+	0.94869f,
+	0.0949132f,
+	0.473083f,
+	0.874439f,
+	0.107469f,
+	0.430087f,
+	0.900068f,
+	0.0700241f,
+	0.294529f,
+	0.954232f,
+	0.0519033f,
+	0.218538f,
+	0.963065f,
+	0.157309f,
+	0.194139f,
+	0.967934f,
+	0.159416f,
+	0.193754f,
+	0.980213f,
+	0.0405318f,
+	0.162395f,
+	0.97825f,
+	-0.129057f,
+	0.175319f,
+	0.968352f,
+	-0.177646f,
+	0.248014f,
+	0.960103f,
+	-0.129196f,
+	0.28568f,
+	0.95369f,
+	-0.0941428f,
+	0.21993f,
+	0.968315f,
+	-0.118312f,
+	0.322085f,
+	0.944206f,
+	-0.068818f,
+	0.382868f,
+	0.918715f,
+	-0.0968289f,
+	0.390317f,
+	0.908769f,
+	-0.147618f,
+	0.269935f,
+	0.914207f,
+	-0.30226f,
+	0.374262f,
+	0.856519f,
+	-0.355391f,
+	0.561588f,
+	0.771614f,
+	-0.298716f,
+	0.563679f,
+	0.781086f,
+	-0.268646f,
+	0.435393f,
+	0.841674f,
+	-0.319402f,
+	0.305805f,
+	0.901875f,
+	-0.305133f,
+	0.0714141f,
+	0.973517f,
+	-0.217175f,
+	-0.0655193f,
+	0.984454f,
+	-0.162963f,
+	0.0352485f,
+	0.985949f,
+	-0.163286f,
+	0.0657594f,
+	0.9937f,
+	-0.0907542f,
+	-0.080707f,
+	0.996331f,
+	0.0284757f,
+	-0.168129f,
+	0.985261f,
+	0.0315202f,
+	-0.129479f,
+	0.990858f,
+	0.0378905f,
+	-0.12231f,
+	0.991737f,
+	0.0387141f,
+	-0.178343f,
+	0.98279f,
+	-0.0481504f,
+	0.273318f,
+	0.858026f,
+	-0.434843f,
+	0.385091f,
+	0.836836f,
+	-0.389114f,
+	0.340339f,
+	0.786413f,
+	-0.515483f,
+	0.318221f,
+	0.733035f,
+	-0.601161f,
+	0.367621f,
+	0.755443f,
+	-0.542366f,
+	0.119455f,
+	0.799665f,
+	-0.588444f,
+	-0.0802011f,
+	0.78091f,
+	-0.619473f,
+	-0.0688818f,
+	0.778398f,
+	-0.623981f,
+	0.0140135f,
+	0.818686f,
+	-0.574071f,
+	0.0274992f,
+	0.866697f,
+	-0.498077f,
+	0.177071f,
+	0.88196f,
+	-0.436797f,
+	0.265217f,
+	0.852958f,
+	-0.449581f,
+	0.257768f,
+	0.854407f,
+	-0.45116f,
+	0.248846f,
+	0.837431f,
+	-0.486605f,
+	0.267639f,
+	0.861569f,
+	-0.431356f,
+	0.378672f,
+	0.856274f,
+	-0.351288f,
+	0.453357f,
+	0.836299f,
+	-0.308337f,
+	0.386424f,
+	0.863215f,
+	-0.324865f,
+	0.128686f,
+	0.904609f,
+	-0.406352f,
+	-0.130252f,
+	0.895612f,
+	-0.425338f,
+	-0.18148f,
+	0.896143f,
+	-0.40496f,
+	-0.161324f,
+	0.928509f,
+	-0.334435f,
+	-0.0897102f,
+	0.95467f,
+	-0.283825f,
+	0.0454642f,
+	0.942898f,
+	-0.329963f,
+	0.150896f,
+	0.947175f,
+	-0.283f,
+	0.0358472f,
+	0.960013f,
+	-0.277651f,
+	-0.0385071f,
+	0.932002f,
+	-0.360402f,
+	0.0386813f,
+	0.938718f,
+	-0.342507f,
+	0.0283698f,
+	0.934985f,
+	-0.353551f,
+	0.108122f,
+	0.956069f,
+	-0.272473f,
+	0.00374271f,
+	0.987226f,
+	-0.159284f,
+	-0.196358f,
+	0.979545f,
+	-0.0439957f,
+	-0.00408304f,
+	0.984849f,
+	0.173364f,
+	0.19648f,
+	0.945984f,
+	0.257896f,
+	0.360526f,
+	0.896905f,
+	0.256092f,
+	0.497904f,
+	0.850304f,
+	0.170515f,
+	0.432778f,
+	0.894142f,
+	0.114953f,
+	0.285493f,
+	0.945844f,
+	0.154508f,
+	0.185631f,
+	0.971794f,
+	0.145459f,
+	0.230083f,
+	0.969236f,
+	0.0874248f,
+	0.368311f,
+	0.929659f,
+	-0.00905859f,
+	0.334163f,
+	0.916764f,
+	-0.218814f,
+	0.186339f,
+	0.940464f,
+	-0.284262f,
+	0.166871f,
+	0.945707f,
+	-0.278912f,
+	0.282007f,
+	0.937612f,
+	-0.20336f,
+	0.24104f,
+	0.942322f,
+	-0.232226f,
+	0.269154f,
+	0.937876f,
+	-0.218962f,
+	0.376707f,
+	0.923358f,
+	-0.0741695f,
+	0.419282f,
+	0.907855f,
+	0.00132882f,
+	0.443207f,
+	0.893334f,
+	-0.0743096f,
+	0.437794f,
+	0.862232f,
+	-0.254741f,
+	0.526311f,
+	0.818963f,
+	-0.228685f,
+	0.539618f,
+	0.818293f,
+	-0.198015f,
+	0.495179f,
+	0.844909f,
+	-0.202303f,
+	0.231134f,
+	0.928947f,
+	-0.289195f,
+	-0.0315579f,
+	0.980647f,
+	-0.193222f,
+	-0.0610949f,
+	0.990009f,
+	-0.12708f,
+	-0.0213691f,
+	0.991115f,
+	-0.131279f,
+	-0.0564833f,
+	0.997988f,
+	-0.0288065f,
+	-0.126885f,
+	0.991868f,
+	-0.0099403f,
+	-0.0683923f,
+	0.994887f,
+	-0.0743097f,
+	-0.0443491f,
+	0.981445f,
+	-0.186542f,
+	-0.106156f,
+	0.962217f,
+	-0.250737f,
+	-0.0540242f,
+	0.978674f,
+	-0.198191f,
+	0.194886f,
+	0.824241f,
+	-0.531645f,
+	0.320074f,
+	0.809438f,
+	-0.492303f,
+	0.464438f,
+	0.773143f,
+	-0.431911f,
+	0.405677f,
+	0.746051f,
+	-0.528047f,
+	0.305674f,
+	0.751501f,
+	-0.584645f,
+	0.130892f,
+	0.809782f,
+	-0.571944f,
+	-0.0644176f,
+	0.819769f,
+	-0.56906f,
+	-0.0714323f,
+	0.833301f,
+	-0.548185f,
+	-0.0643631f,
+	0.853923f,
+	-0.516404f,
+	-0.0107306f,
+	0.851684f,
+	-0.523946f,
+	0.13746f,
+	0.827954f,
+	-0.543688f,
+	0.198685f,
+	0.868523f,
+	-0.454084f,
+	0.246871f,
+	0.881894f,
+	-0.401644f,
+	0.296117f,
+	0.852853f,
+	-0.430066f,
+	0.256816f,
+	0.850031f,
+	-0.459883f,
+	0.314177f,
+	0.830121f,
+	-0.460643f,
+	0.37334f,
+	0.830673f,
+	-0.413038f,
+	0.413553f,
+	0.857071f,
+	-0.30725f,
+	0.158679f,
+	0.931259f,
+	-0.327989f,
+	-0.130088f,
+	0.933779f,
+	-0.333368f,
+	-0.259668f,
+	0.892475f,
+	-0.368866f,
+	-0.237565f,
+	0.924215f,
+	-0.298981f,
+	-0.0871208f,
+	0.968004f,
+	-0.235327f,
+	0.0797031f,
+	0.982117f,
+	-0.17057f,
+	0.0461708f,
+	0.99392f,
+	-0.0999594f,
+	0.0445161f,
+	0.998669f,
+	-0.0260401f,
+	0.0420509f,
+	0.9919f,
+	-0.119856f,
+	0.0652827f,
+	0.976809f,
+	-0.203917f,
+	0.0163117f,
+	0.980129f,
+	-0.197692f,
+	-0.0727832f,
+	0.991022f,
+	-0.112154f,
+	-0.0519999f,
+	0.997388f,
+	0.0501216f,
+	-0.215497f,
+	0.976498f,
+	0.00360735f,
+	-0.144793f,
+	0.989191f,
+	0.023161f,
+	0.11495f,
+	0.986032f,
+	0.120527f,
+	0.332155f,
+	0.934954f,
+	0.124633f,
+	0.520936f,
+	0.843883f,
+	0.128405f,
+	0.426058f,
+	0.883139f,
+	0.196317f,
+	0.297882f,
+	0.930389f,
+	0.213643f,
+	0.255462f,
+	0.962333f,
+	0.0930293f,
+	0.330201f,
+	0.94382f,
+	-0.0130553f,
+	0.464814f,
+	0.88236f,
+	-0.0734001f,
+	0.396624f,
+	0.912293f,
+	-0.10203f,
+	0.190826f,
+	0.974675f,
+	-0.116592f,
+	0.186045f,
+	0.970537f,
+	-0.153119f,
+	0.228366f,
+	0.951236f,
+	-0.207361f,
+	0.252282f,
+	0.958154f,
+	-0.135261f,
+	0.163352f,
+	0.984522f,
+	-0.0635096f,
+	0.214627f,
+	0.974395f,
+	0.066997f,
+	0.385854f,
+	0.917468f,
+	0.096793f,
+	0.519216f,
+	0.853803f,
+	0.0378886f,
+	0.535665f,
+	0.843867f,
+	-0.0308472f,
+	0.541689f,
+	0.838373f,
+	-0.060851f,
+	0.563197f,
+	0.822059f,
+	-0.0838289f,
+	0.51966f,
+	0.848391f,
+	-0.100928f,
+	0.236369f,
+	0.967062f,
+	-0.0944536f,
+	-0.111969f,
+	0.993037f,
+	-0.0366171f,
+	-0.0968965f,
+	0.995233f,
+	-0.011032f,
+	-0.0970566f,
+	0.995182f,
+	0.013894f,
+	-0.0559363f,
+	0.991458f,
+	0.117821f,
+	-0.00538008f,
+	0.999824f,
+	-0.0179674f,
+	0.0108998f,
+	0.982438f,
+	-0.186268f,
+	0.0427996f,
+	0.970253f,
+	-0.238279f,
+	-0.10823f,
+	0.95386f,
+	-0.280066f,
+	-0.196538f,
+	0.942983f,
+	-0.26862f,
+	0.307908f,
+	0.814842f,
+	-0.491147f,
+	0.299308f,
+	0.78907f,
+	-0.536455f,
+	0.435133f,
+	0.777699f,
+	-0.453699f,
+	0.495126f,
+	0.764316f,
+	-0.413124f,
+	0.362871f,
+	0.81835f,
+	-0.445676f,
+	0.0803271f,
+	0.871076f,
+	-0.484534f,
+	-0.110099f,
+	0.885293f,
+	-0.451812f,
+	-0.149245f,
+	0.895891f,
+	-0.418456f,
+	-0.0670569f,
+	0.907151f,
+	-0.415428f,
+	0.0527044f,
+	0.88691f,
+	-0.458926f,
+	0.100471f,
+	0.888224f,
+	-0.448291f,
+	0.121208f,
+	0.922825f,
+	-0.365653f,
+	0.249787f,
+	0.879883f,
+	-0.404243f,
+	0.334334f,
+	0.839973f,
+	-0.427396f,
+	0.283757f,
+	0.852792f,
+	-0.438437f,
+	0.337422f,
+	0.812854f,
+	-0.474778f,
+	0.291967f,
+	0.807546f,
+	-0.512469f,
+	0.269633f,
+	0.862064f,
+	-0.429119f,
+	0.108203f,
+	0.943068f,
+	-0.314506f,
+	-0.121343f,
+	0.966872f,
+	-0.224575f,
+	-0.202731f,
+	0.95836f,
+	-0.201115f,
+	-0.275106f,
+	0.928104f,
+	-0.25088f,
+	-0.220959f,
+	0.943196f,
+	-0.248108f,
+	-0.0845259f,
+	0.990859f,
+	-0.105139f,
+	-0.0183112f,
+	0.999824f,
+	0.00404228f,
+	0.0398541f,
+	0.999205f,
+	-0.000234289f,
+	0.144105f,
+	0.989245f,
+	0.0250549f,
+	0.0887732f,
+	0.994681f,
+	0.052239f,
+	-0.0385311f,
+	0.993554f,
+	0.106613f,
+	-0.141743f,
+	0.984863f,
+	0.099766f,
+	-0.130913f,
+	0.987043f,
+	0.0927824f,
+	-0.138468f,
+	0.982136f,
+	0.12742f,
+	-0.181593f,
+	0.983362f,
+	-0.00473479f,
+	0.124018f,
+	0.991703f,
+	-0.0338209f,
+	0.350394f,
+	0.929846f,
+	-0.112294f,
+	0.471172f,
+	0.881999f,
+	-0.00866642f,
+	0.362692f,
+	0.927143f,
+	0.0941279f,
+	0.321547f,
+	0.934446f,
+	0.153031f,
+	0.39706f,
+	0.903274f,
+	0.162601f,
+	0.408629f,
+	0.910814f,
+	0.0586596f,
+	0.440544f,
+	0.897708f,
+	-0.00641084f,
+	0.417743f,
+	0.90832f,
+	0.0210971f,
+	0.223429f,
+	0.972702f,
+	-0.0626924f,
+	0.239878f,
+	0.966667f,
+	-0.0895152f,
+	0.326998f,
+	0.934073f,
+	-0.143454f,
+	0.0984577f,
+	0.955256f,
+	-0.278913f,
+	0.055814f,
+	0.995135f,
+	-0.081185f,
+	0.198837f,
+	0.979583f,
+	-0.0296926f,
+	0.452343f,
+	0.887429f,
+	-0.0886289f,
+	0.538988f,
+	0.831253f,
+	-0.136052f,
+	0.534759f,
+	0.840783f,
+	-0.084361f,
+	0.557911f,
+	0.827063f,
+	-0.0685738f,
+	0.570718f,
+	0.812258f,
+	-0.120488f,
+	0.469437f,
+	0.877038f,
+	-0.102147f,
+	0.179725f,
+	0.982175f,
+	0.0550563f,
+	-0.143773f,
+	0.988083f,
+	0.054972f,
+	-0.0900032f,
+	0.995941f,
+	-0.00107895f,
+	-0.112639f,
+	0.992937f,
+	-0.0372634f,
+	-0.0770822f,
+	0.995012f,
+	-0.0633234f,
+	0.131283f,
+	0.990073f,
+	-0.0501953f,
+	0.151552f,
+	0.985928f,
+	-0.0705498f,
+	0.0547644f,
+	0.990744f,
+	-0.124209f,
+	-0.0889999f,
+	0.992043f,
+	-0.0890439f,
+	-0.225525f,
+	0.966809f,
+	-0.120075f,
+	0.367815f,
+	0.812209f,
+	-0.4528f,
+	0.333749f,
+	0.806687f,
+	-0.487716f,
+	0.350467f,
+	0.776679f,
+	-0.523395f,
+	0.428661f,
+	0.776887f,
+	-0.461189f,
+	0.344028f,
+	0.851962f,
+	-0.394722f,
+	0.0917588f,
+	0.929121f,
+	-0.35821f,
+	-0.151193f,
+	0.922445f,
+	-0.355297f,
+	-0.135334f,
+	0.926245f,
+	-0.351788f,
+	-0.0236046f,
+	0.919658f,
+	-0.39201f,
+	0.0475929f,
+	0.924342f,
+	-0.378586f,
+	0.0534474f,
+	0.931533f,
+	-0.359707f,
+	0.122967f,
+	0.908442f,
+	-0.399514f,
+	0.333531f,
+	0.836829f,
+	-0.434137f,
+	0.345062f,
+	0.821786f,
+	-0.45343f,
+	0.298405f,
+	0.81077f,
+	-0.503594f,
+	0.369796f,
+	0.765054f,
+	-0.527202f,
+	0.289381f,
+	0.806079f,
+	-0.516232f,
+	0.106326f,
+	0.866117f,
+	-0.488402f,
+	-0.0247184f,
+	0.959589f,
+	-0.280318f,
+	-0.247885f,
+	0.952117f,
+	-0.178958f,
+	-0.233969f,
+	0.968302f,
+	-0.0874651f,
+	-0.230973f,
+	0.963517f,
+	-0.135224f,
+	-0.23946f,
+	0.950685f,
+	-0.197121f,
+	-0.148981f,
+	0.968772f,
+	-0.198205f,
+	-0.0244446f,
+	0.976892f,
+	-0.212332f,
+	0.0214143f,
+	0.979888f,
+	-0.198397f,
+	0.0179015f,
+	0.996249f,
+	-0.084666f,
+	-0.0584671f,
+	0.995927f,
+	0.0686411f,
+	-0.0472317f,
+	0.986168f,
+	0.158874f,
+	-0.0434315f,
+	0.994906f,
+	0.0909663f,
+	-0.106857f,
+	0.994237f,
+	0.00858694f,
+	-0.103595f,
+	0.993848f,
+	-0.0391609f,
+	-0.0110181f,
+	0.988269f,
+	-0.152323f,
+	0.194953f,
+	0.947451f,
+	-0.253632f,
+	0.318956f,
+	0.92262f,
+	-0.216885f,
+	0.355303f,
+	0.928796f,
+	-0.105349f,
+	0.319482f,
+	0.947371f,
+	-0.0204796f,
+	0.274811f,
+	0.961125f,
+	0.0267891f,
+	0.33758f,
+	0.938163f,
+	0.0767414f,
+	0.445225f,
+	0.885597f,
+	0.132261f,
+	0.483843f,
+	0.868855f,
+	0.104815f,
+	0.473616f,
+	0.877987f,
+	0.069475f,
+	0.358094f,
+	0.929841f,
+	-0.0846442f,
+	0.209896f,
+	0.940516f,
+	-0.267156f,
+	0.398687f,
+	0.89746f,
+	-0.188715f,
+	0.164362f,
+	0.933368f,
+	-0.319075f,
+	-0.0806345f,
+	0.937721f,
+	-0.337901f,
+	0.19678f,
+	0.945117f,
+	-0.26083f,
+	0.467829f,
+	0.857531f,
+	-0.213953f,
+	0.522616f,
+	0.828828f,
+	-0.199792f,
+	0.48751f,
+	0.848849f,
+	-0.204424f,
+	0.559553f,
+	0.806974f,
+	-0.18893f,
+	0.585339f,
+	0.775984f,
+	-0.235006f,
+	0.309037f,
+	0.923705f,
+	-0.22642f,
+	0.0763335f,
+	0.997082f,
+	0.00115348f,
+	-0.0450053f,
+	0.998556f,
+	0.0293498f,
+	-0.0333568f,
+	0.997154f,
+	-0.0676115f,
+	-0.00964185f,
+	0.995848f,
+	-0.0905243f,
+	0.000956175f,
+	0.96601f,
+	-0.258503f,
+	0.00169255f,
+	0.940578f,
+	-0.339574f,
+	0.0710047f,
+	0.988076f,
+	-0.136617f,
+	0.0666563f,
+	0.995318f,
+	-0.0699874f,
+	-0.123764f,
+	0.98454f,
+	-0.123946f,
+	-0.163961f,
+	0.983022f,
+	-0.0823738f,
+	0.335205f,
+	0.824436f,
+	-0.456008f,
+	0.40434f,
+	0.809075f,
+	-0.426506f,
+	0.410475f,
+	0.791681f,
+	-0.452494f,
+	0.374361f,
+	0.829194f,
+	-0.41508f,
+	0.245781f,
+	0.909811f,
+	-0.33442f,
+	0.0263815f,
+	0.954919f,
+	-0.295693f,
+	-0.125325f,
+	0.941665f,
+	-0.312348f,
+	-0.129375f,
+	0.929134f,
+	-0.346369f,
+	-0.0304152f,
+	0.953686f,
+	-0.299263f,
+	-0.0235504f,
+	0.953092f,
+	-0.301762f,
+	0.153775f,
+	0.94901f,
+	-0.275197f,
+	0.274986f,
+	0.871191f,
+	-0.406705f,
+	0.301999f,
+	0.805469f,
+	-0.509919f,
+	0.376419f,
+	0.798039f,
+	-0.470576f,
+	0.361388f,
+	0.809968f,
+	-0.461899f,
+	0.38255f,
+	0.848875f,
+	-0.364783f,
+	0.240129f,
+	0.889938f,
+	-0.387747f,
+	-0.0576931f,
+	0.937865f,
+	-0.342172f,
+	-0.263371f,
+	0.95113f,
+	-0.161204f,
+	-0.310954f,
+	0.950327f,
+	-0.0136276f,
+	-0.223147f,
+	0.974756f,
+	-0.00746382f,
+	-0.15809f,
+	0.984734f,
+	-0.0728478f,
+	-0.146587f,
+	0.977645f,
+	-0.150739f,
+	-0.120405f,
+	0.952352f,
+	-0.280228f,
+	0.00186508f,
+	0.961595f,
+	-0.274467f,
+	-0.0732237f,
+	0.95724f,
+	-0.279876f,
+	-0.12777f,
+	0.973556f,
+	-0.189377f,
+	-0.137722f,
+	0.985013f,
+	-0.103834f,
+	-0.0840689f,
+	0.995964f,
+	-0.0314252f,
+	0.00572333f,
+	0.997438f,
+	0.0713008f,
+	-0.0203309f,
+	0.999218f,
+	0.033924f,
+	0.0131655f,
+	0.994107f,
+	-0.107599f,
+	0.106442f,
+	0.965608f,
+	-0.237214f,
+	0.156613f,
+	0.948157f,
+	-0.276534f,
+	0.221784f,
+	0.959186f,
+	-0.175425f,
+	0.297839f,
+	0.94933f,
+	-0.100322f,
+	0.237415f,
+	0.96993f,
+	-0.0535752f,
+	0.206724f,
+	0.977649f,
+	0.0383141f,
+	0.342833f,
+	0.933108f,
+	0.108513f,
+	0.413098f,
+	0.906827f,
+	0.0837554f,
+	0.485601f,
+	0.86482f,
+	0.127586f,
+	0.517433f,
+	0.850444f,
+	0.0949105f,
+	0.521609f,
+	0.853001f,
+	-0.0177076f,
+	0.35462f,
+	0.907818f,
+	-0.223854f,
+	0.320255f,
+	0.896065f,
+	-0.307417f,
+	0.254422f,
+	0.945666f,
+	-0.202447f,
+	-0.0420832f,
+	0.95285f,
+	-0.300511f,
+	0.132146f,
+	0.911038f,
+	-0.390572f,
+	0.397135f,
+	0.84337f,
+	-0.361954f,
+	0.530962f,
+	0.805014f,
+	-0.264634f,
+	0.518015f,
+	0.788476f,
+	-0.331612f,
+	0.536794f,
+	0.726368f,
+	-0.429234f,
+	0.499189f,
+	0.748129f,
+	-0.437165f,
+	0.193048f,
+	0.933972f,
+	-0.300713f,
+	-0.0642143f,
+	0.969885f,
+	-0.234947f,
+	-0.0349143f,
+	0.97216f,
+	-0.231701f,
+	-0.020308f,
+	0.973327f,
+	-0.22852f,
+	0.0335645f,
+	0.983758f,
+	-0.176336f,
+	0.162495f,
+	0.963807f,
+	-0.211356f,
+	0.0549435f,
+	0.960153f,
+	-0.274021f,
+	-0.150243f,
+	0.943756f,
+	-0.294538f,
+	0.093877f,
+	0.988384f,
+	-0.119518f,
+	-0.0288967f,
+	0.977445f,
+	-0.209205f,
+	-0.228292f,
+	0.925763f,
+	-0.301406f,
+	0.329933f,
+	0.832357f,
+	-0.445339f,
+	0.354113f,
+	0.855807f,
+	-0.377092f,
+	0.402588f,
+	0.885182f,
+	-0.233185f,
+	0.310305f,
+	0.922327f,
+	-0.23027f,
+	0.169674f,
+	0.966179f,
+	-0.194188f,
+	0.0510686f,
+	0.987038f,
+	-0.152145f,
+	-0.0638218f,
+	0.978386f,
+	-0.196689f,
+	-0.116946f,
+	0.960297f,
+	-0.253286f,
+	-0.0788814f,
+	0.945056f,
+	-0.317249f,
+	0.0429532f,
+	0.937478f,
+	-0.345383f,
+	0.160798f,
+	0.890341f,
+	-0.425953f,
+	0.370061f,
+	0.833359f,
+	-0.410569f,
+	0.405144f,
+	0.796477f,
+	-0.448867f,
+	0.330775f,
+	0.831238f,
+	-0.446802f,
+	0.214187f,
+	0.914592f,
+	-0.342995f,
+	0.302956f,
+	0.933789f,
+	-0.190409f,
+	0.260411f,
+	0.956162f,
+	-0.13394f,
+	-0.0987797f,
+	0.989363f,
+	-0.106786f,
+	-0.381946f,
+	0.915584f,
+	-0.125788f,
+	-0.356892f,
+	0.930397f,
+	-0.0835967f,
+	-0.219462f,
+	0.974624f,
+	-0.0441002f,
+	-0.0826206f,
+	0.996346f,
+	-0.0216629f,
+	-0.0522166f,
+	0.993096f,
+	-0.10504f,
+	-0.0544454f,
+	0.992373f,
+	-0.110596f,
+	-0.0392289f,
+	0.996233f,
+	-0.0773398f,
+	-0.0738534f,
+	0.995703f,
+	-0.0558676f,
+	-0.126249f,
+	0.987782f,
+	-0.0913672f,
+	-0.191576f,
+	0.965578f,
+	-0.17595f,
+	-0.204819f,
+	0.971278f,
+	-0.121116f,
+	-0.121301f,
+	0.991656f,
+	-0.0436452f,
+	0.0591737f,
+	0.997785f,
+	0.0303762f,
+	0.146031f,
+	0.988908f,
+	-0.0271181f,
+	0.164489f,
+	0.985353f,
+	-0.0449734f,
+	0.1732f,
+	0.984753f,
+	-0.0162076f,
+	0.192999f,
+	0.97944f,
+	-0.0587201f,
+	0.224284f,
+	0.970976f,
+	-0.0830781f,
+	0.215597f,
+	0.976395f,
+	0.0130766f,
+	0.11857f,
+	0.99294f,
+	-0.00337615f,
+	0.283009f,
+	0.956652f,
+	0.0687283f,
+	0.418445f,
+	0.903636f,
+	0.0913547f,
+	0.498249f,
+	0.865176f,
+	0.0567366f,
+	0.572218f,
+	0.818628f,
+	-0.0491444f,
+	0.584595f,
+	0.798602f,
+	-0.143119f,
+	0.499999f,
+	0.838004f,
+	-0.218521f,
+	0.312173f,
+	0.860973f,
+	-0.401589f,
+	0.169015f,
+	0.918853f,
+	-0.356571f,
+	0.0805256f,
+	0.94115f,
+	-0.328258f,
+	0.268694f,
+	0.864193f,
+	-0.42541f,
+	0.373719f,
+	0.773399f,
+	-0.512044f,
+	0.442856f,
+	0.749728f,
+	-0.491717f,
+	0.564815f,
+	0.671761f,
+	-0.479293f,
+	0.549235f,
+	0.627986f,
+	-0.551338f,
+	0.305274f,
+	0.788247f,
+	-0.534298f,
+	0.0146963f,
+	0.910216f,
+	-0.413874f,
+	-0.0347141f,
+	0.920746f,
+	-0.388614f,
+	-0.0142092f,
+	0.918584f,
+	-0.394971f,
+	-0.0593092f,
+	0.944757f,
+	-0.32236f,
+	-0.0129026f,
+	0.951456f,
+	-0.307515f,
+	0.101136f,
+	0.954598f,
+	-0.280203f,
+	0.103786f,
+	0.979836f,
+	-0.170731f,
+	-0.130724f,
+	0.946294f,
+	-0.2957f,
+	-0.0475497f,
+	0.951312f,
+	-0.30454f,
+	0.068843f,
+	0.980898f,
+	-0.181933f,
+	-0.0601749f,
+	0.975587f,
+	-0.21121f,
+	0.164088f,
+	0.946673f,
+	-0.277283f,
+	0.219167f,
+	0.958752f,
+	-0.180996f,
+	0.292116f,
+	0.952214f,
+	-0.0892046f,
+	0.382294f,
+	0.923975f,
+	-0.0110254f,
+	0.185963f,
+	0.972429f,
+	-0.140709f,
+	0.0282036f,
+	0.98507f,
+	-0.16983f,
+	-0.0260978f,
+	0.984942f,
+	-0.170904f,
+	0.00347731f,
+	0.966818f,
+	-0.255444f,
+	0.046523f,
+	0.915606f,
+	-0.399376f,
+	0.121249f,
+	0.881024f,
+	-0.457269f,
+	0.234655f,
+	0.843553f,
+	-0.483069f,
+	0.349259f,
+	0.806387f,
+	-0.47724f,
+	0.352024f,
+	0.817545f,
+	-0.455741f,
+	0.21f,
+	0.895765f,
+	-0.391796f,
+	0.123731f,
+	0.946466f,
+	-0.298149f,
+	0.189246f,
+	0.953263f,
+	-0.235533f,
+	0.21574f,
+	0.971887f,
+	-0.0943018f,
+	-0.0878709f,
+	0.988681f,
+	-0.12161f,
+	-0.31365f,
+	0.930831f,
+	-0.187554f,
+	-0.370884f,
+	0.90378f,
+	-0.213602f,
+	-0.292833f,
+	0.938489f,
+	-0.182993f,
+	-0.076513f,
+	0.991298f,
+	-0.107116f,
+	-0.0492348f,
+	0.994225f,
+	-0.0953508f,
+	-0.128831f,
+	0.991129f,
+	-0.0326479f,
+	-0.117178f,
+	0.99304f,
+	0.0118732f,
+	-0.0834857f,
+	0.989043f,
+	0.12175f,
+	-0.0124631f,
+	0.991817f,
+	0.127061f,
+	-0.133134f,
+	0.991073f,
+	-0.00703918f,
+	-0.190067f,
+	0.981738f,
+	-0.00811131f,
+	-0.0950662f,
+	0.989352f,
+	-0.110206f,
+	0.0262188f,
+	0.977376f,
+	-0.209877f,
+	0.0774906f,
+	0.981033f,
+	-0.177679f,
+	0.0911686f,
+	0.995787f,
+	-0.00982619f,
+	0.177517f,
+	0.984043f,
+	0.0121696f,
+	0.260966f,
+	0.962001f,
+	-0.0803208f,
+	0.219093f,
+	0.96759f,
+	-0.12557f,
+	0.15488f,
+	0.986019f,
+	-0.06147f,
+	0.155325f,
+	0.987507f,
+	-0.0265508f,
+	0.257438f,
+	0.9633f,
+	-0.0760109f,
+	0.429699f,
+	0.898131f,
+	-0.0933795f,
+	0.553938f,
+	0.821258f,
+	-0.136702f,
+	0.635333f,
+	0.740056f,
+	-0.220611f,
+	0.590775f,
+	0.752696f,
+	-0.290577f,
+	0.544721f,
+	0.782975f,
+	-0.300381f,
+	0.386007f,
+	0.854199f,
+	-0.348343f,
+	0.159868f,
+	0.903698f,
+	-0.397205f,
+	0.111475f,
+	0.854344f,
+	-0.507613f,
+	0.32886f,
+	0.783243f,
+	-0.527619f,
+	0.428722f,
+	0.729381f,
+	-0.533105f,
+	0.463071f,
+	0.680849f,
+	-0.567459f,
+	0.578683f,
+	0.643078f,
+	-0.501575f,
+	0.498776f,
+	0.750313f,
+	-0.433881f,
+	0.172367f,
+	0.935224f,
+	-0.309265f,
+	-0.0549105f,
+	0.957697f,
+	-0.282492f,
+	-0.000989137f,
+	0.955961f,
+	-0.293491f,
+	-0.105185f,
+	0.947134f,
+	-0.303107f,
+	-0.108598f,
+	0.951252f,
+	-0.288662f,
+	-0.0192021f,
+	0.937992f,
+	-0.346125f,
+	0.0434621f,
+	0.947915f,
+	-0.315545f,
+	0.0658084f,
+	0.965866f,
+	-0.250542f,
+	0.00168367f,
+	0.969468f,
+	-0.245211f,
+	-0.0752902f,
+	0.953259f,
+	-0.292624f,
+	-0.0406571f,
+	0.962797f,
+	-0.267151f,
+	-0.0486067f,
+	0.969651f,
+	-0.239615f,
+	0.0419974f,
+	0.993223f,
+	-0.108371f,
+	0.194169f,
+	0.980548f,
+	-0.0286949f,
+	0.261981f,
+	0.963651f,
+	-0.0523696f,
+	0.349136f,
+	0.937066f,
+	-0.00343362f,
+	0.31121f,
+	0.950026f,
+	0.0244779f,
+	0.0510089f,
+	0.992585f,
+	-0.110335f,
+	0.0314098f,
+	0.989653f,
+	-0.140003f,
+	0.185979f,
+	0.958236f,
+	-0.217244f,
+	0.136104f,
+	0.898638f,
+	-0.417044f,
+	0.108771f,
+	0.892335f,
+	-0.438072f,
+	0.238757f,
+	0.906785f,
+	-0.34747f,
+	0.373646f,
+	0.87379f,
+	-0.311256f,
+	0.340425f,
+	0.883999f,
+	-0.320402f,
+	0.14853f,
+	0.93597f,
+	-0.319217f,
+	0.0564088f,
+	0.968057f,
+	-0.244304f,
+	0.0971116f,
+	0.979187f,
+	-0.17822f,
+	0.12449f,
+	0.986246f,
+	-0.108724f,
+	0.00791995f,
+	0.999591f,
+	-0.0274806f,
+	-0.236925f,
+	0.964883f,
+	-0.113439f,
+	-0.404549f,
+	0.891486f,
+	-0.203944f,
+	-0.302952f,
+	0.940514f,
+	-0.153798f,
+	-0.187243f,
+	0.970939f,
+	-0.149055f,
+	-0.103813f,
+	0.994585f,
+	-0.00480558f,
+	-0.136945f,
+	0.990579f,
+	0.00047278f,
+	-0.192386f,
+	0.981319f,
+	0.000301484f,
+	-0.157118f,
+	0.980577f,
+	0.117404f,
+	-0.0205849f,
+	0.995936f,
+	0.0876826f,
+	-0.0389376f,
+	0.992928f,
+	0.112147f,
+	-0.205589f,
+	0.977918f,
+	0.0375515f,
+	0.0799477f,
+	0.995293f,
+	0.0547661f,
+	0.128711f,
+	0.981689f,
+	-0.140426f,
+	-0.00377139f,
+	0.985264f,
+	-0.170999f,
+	-0.0186288f,
+	0.990563f,
+	-0.135788f,
+	0.247861f,
+	0.95847f,
+	-0.141069f,
+	0.335397f,
+	0.913398f,
+	-0.230679f,
+	0.164127f,
+	0.956335f,
+	-0.241837f,
+	0.0560549f,
+	0.992155f,
+	-0.111746f,
+	0.165621f,
+	0.985752f,
+	-0.0293729f,
+	0.329655f,
+	0.93718f,
+	-0.114108f,
+	0.47188f,
+	0.859421f,
+	-0.196784f,
+	0.593068f,
+	0.774119f,
+	-0.22138f,
+	0.65363f,
+	0.716422f,
+	-0.24394f,
+	0.606788f,
+	0.760352f,
+	-0.231675f,
+	0.536399f,
+	0.810894f,
+	-0.23394f,
+	0.343135f,
+	0.901586f,
+	-0.263439f,
+	0.295862f,
+	0.930397f,
+	-0.216396f,
+	0.307346f,
+	0.85762f,
+	-0.412342f,
+	0.36437f,
+	0.770675f,
+	-0.522776f,
+	0.48977f,
+	0.726784f,
+	-0.481571f,
+	0.467664f,
+	0.727396f,
+	-0.50218f,
+	0.516451f,
+	0.759976f,
+	-0.394608f,
+	0.369408f,
+	0.883578f,
+	-0.287798f,
+	0.11272f,
+	0.986131f,
+	-0.121821f,
+	-0.0556185f,
+	0.985996f,
+	-0.157218f,
+	-0.0141506f,
+	0.99059f,
+	-0.13613f,
+	-0.0462718f,
+	0.993931f,
+	-0.099801f,
+	-0.0190733f,
+	0.9801f,
+	-0.197584f,
+	0.0617351f,
+	0.955747f,
+	-0.287639f,
+	-0.00791345f,
+	0.937814f,
+	-0.347049f,
+	0.0263533f,
+	0.943249f,
+	-0.331038f,
+	-0.0408223f,
+	0.937006f,
+	-0.34692f,
+	-0.0840519f,
+	0.9495f,
+	-0.302299f,
+	-0.0536227f,
+	0.964498f,
+	-0.25859f,
+	-0.0366453f,
+	0.973297f,
+	-0.226607f,
+	0.0559372f,
+	0.997556f,
+	-0.0418806f,
+	0.117658f,
+	0.99199f,
+	-0.0459629f,
+	0.260816f,
+	0.963552f,
+	0.059517f,
+	0.265721f,
+	0.95723f,
+	0.114473f,
+	0.305022f,
+	0.92568f,
+	0.223781f,
+	0.229311f,
+	0.961539f,
+	0.151192f,
+	0.0614828f,
+	0.993074f,
+	-0.10012f,
+	0.279787f,
+	0.947394f,
+	-0.15545f,
+	0.307005f,
+	0.902601f,
+	-0.301762f,
+	0.0599313f,
+	0.924785f,
+	-0.375741f,
+	0.138459f,
+	0.941623f,
+	-0.306881f,
+	0.380474f,
+	0.890209f,
+	-0.250536f,
+	0.362157f,
+	0.883362f,
+	-0.297512f,
+	0.118666f,
+	0.951617f,
+	-0.283449f,
+	-0.0864913f,
+	0.973386f,
+	-0.212226f,
+	0.0535968f,
+	0.99807f,
+	-0.0313783f,
+	0.0571748f,
+	0.998014f,
+	0.026449f,
+	-0.0576417f,
+	0.995225f,
+	0.0787756f,
+	-0.164671f,
+	0.983729f,
+	0.0718444f,
+	-0.317398f,
+	0.947117f,
+	0.0472105f,
+	-0.350813f,
+	0.936189f,
+	-0.0219157f,
+	-0.249283f,
+	0.968275f,
+	0.0173648f,
+	-0.166219f,
+	0.983818f,
+	0.0668861f,
+	-0.137263f,
+	0.989074f,
+	0.0537794f,
+	-0.237615f,
+	0.966132f,
+	0.100634f,
+	-0.156805f,
+	0.98112f,
+	0.113207f,
+	0.0155394f,
+	0.999476f,
+	0.0283817f,
+	-0.0358194f,
+	0.998926f,
+	0.0293752f,
+	-0.187269f,
+	0.982125f,
+	-0.01898f,
+	0.0856923f,
+	0.996255f,
+	0.0114998f,
+	0.21812f,
+	0.975918f,
+	0.00295422f,
+	0.0575266f,
+	0.997525f,
+	-0.0404377f,
+	0.0557844f,
+	0.976324f,
+	-0.208997f,
+	0.282723f,
+	0.906166f,
+	-0.314533f,
+	0.34017f,
+	0.885713f,
+	-0.315906f,
+	0.0703654f,
+	0.964786f,
+	-0.253451f,
+	-0.0857039f,
+	0.987005f,
+	-0.135924f,
+	0.161068f,
+	0.982423f,
+	-0.0943491f,
+	0.439921f,
+	0.879468f,
+	-0.181673f,
+	0.499341f,
+	0.805071f,
+	-0.320185f,
+	0.581376f,
+	0.752639f,
+	-0.309089f,
+	0.634744f,
+	0.735927f,
+	-0.235609f,
+	0.590228f,
+	0.797974f,
+	-0.121932f,
+	0.552123f,
+	0.824777f,
+	-0.122079f,
+	0.403254f,
+	0.893687f,
+	-0.196749f,
+	0.282279f,
+	0.904426f,
+	-0.319896f,
+	0.487441f,
+	0.821419f,
+	-0.296095f,
+	0.471414f,
+	0.771013f,
+	-0.428146f,
+	0.452383f,
+	0.750947f,
+	-0.48107f,
+	0.453351f,
+	0.789814f,
+	-0.413117f,
+	0.426317f,
+	0.829282f,
+	-0.361311f,
+	0.274227f,
+	0.935292f,
+	-0.223671f,
+	0.0409647f,
+	0.985686f,
+	-0.16354f,
+	0.00611451f,
+	0.980211f,
+	-0.19786f,
+	-0.0818346f,
+	0.965065f,
+	-0.248905f,
+	-0.0402149f,
+	0.984168f,
+	-0.172615f,
+	0.0358772f,
+	0.970818f,
+	-0.237119f,
+	0.140843f,
+	0.951316f,
+	-0.274156f,
+	0.0386407f,
+	0.935491f,
+	-0.351232f,
+	0.02521f,
+	0.945244f,
+	-0.325388f,
+	-0.00704123f,
+	0.966541f,
+	-0.256414f,
+	-0.132543f,
+	0.963814f,
+	-0.231288f,
+	-0.120001f,
+	0.972985f,
+	-0.197233f,
+	-0.125856f,
+	0.970406f,
+	-0.20609f,
+	0.150068f,
+	0.984139f,
+	0.0946078f,
+	0.0962514f,
+	0.994035f,
+	0.0512922f,
+	0.139768f,
+	0.98134f,
+	0.132051f,
+	0.167943f,
+	0.959948f,
+	0.224265f,
+	0.248876f,
+	0.931236f,
+	0.266197f,
+	0.347088f,
+	0.901338f,
+	0.259075f,
+	0.298327f,
+	0.935934f,
+	0.187161f,
+	0.410224f,
+	0.911771f,
+	0.0197232f,
+	0.382392f,
+	0.916875f,
+	-0.11453f,
+	0.0687189f,
+	0.981224f,
+	-0.180215f,
+	0.109108f,
+	0.978331f,
+	-0.175964f,
+	0.423091f,
+	0.889035f,
+	-0.17496f,
+	0.308023f,
+	0.9305f,
+	-0.198221f,
+	0.0610242f,
+	0.996399f,
+	-0.0588678f,
+	-0.139679f,
+	0.983461f,
+	-0.1153f,
+	-0.178862f,
+	0.976278f,
+	-0.122024f,
+	-0.0279755f,
+	0.98865f,
+	0.147609f,
+	0.0175582f,
+	0.984678f,
+	0.173494f,
+	-0.182965f,
+	0.982824f,
+	0.0240987f,
+	-0.334982f,
+	0.934918f,
+	0.117109f,
+	-0.346361f,
+	0.929574f,
+	0.126201f,
+	-0.256073f,
+	0.950373f,
+	0.176686f,
+	-0.14622f,
+	0.975847f,
+	0.162306f,
+	-0.145894f,
+	0.982033f,
+	0.119692f,
+	-0.243091f,
+	0.96438f,
+	0.104295f,
+	-0.119399f,
+	0.991881f,
+	0.0437603f,
+	0.0792305f,
+	0.996134f,
+	0.0379462f,
+	-0.0234512f,
+	0.999544f,
+	0.0190445f,
+	-0.148416f,
+	0.988869f,
+	0.0105176f,
+	0.0279419f,
+	0.999576f,
+	0.00824062f,
+	0.239276f,
+	0.970159f,
+	0.0392311f,
+	0.182184f,
+	0.979477f,
+	-0.086222f,
+	0.251919f,
+	0.933495f,
+	-0.255194f,
+	0.359782f,
+	0.855042f,
+	-0.373444f,
+	0.260041f,
+	0.87469f,
+	-0.409017f,
+	-0.0332083f,
+	0.931159f,
+	-0.363099f,
+	-0.108678f,
+	0.933514f,
+	-0.341673f,
+	0.191287f,
+	0.909011f,
+	-0.370282f,
+	0.516055f,
+	0.783319f,
+	-0.346553f,
+	0.557568f,
+	0.726461f,
+	-0.401711f,
+	0.511814f,
+	0.738467f,
+	-0.438991f,
+	0.509794f,
+	0.789775f,
+	-0.341125f,
+	0.522098f,
+	0.819729f,
+	-0.235496f,
+	0.54438f,
+	0.815602f,
+	-0.196071f,
+	0.540927f,
+	0.823066f,
+	-0.173089f,
+	0.36892f,
+	0.838043f,
+	-0.401972f,
+	0.461826f,
+	0.790802f,
+	-0.401684f,
+	0.549439f,
+	0.728653f,
+	-0.408878f,
+	0.455853f,
+	0.753497f,
+	-0.473751f,
+	0.389397f,
+	0.799772f,
+	-0.456875f,
+	0.293181f,
+	0.868874f,
+	-0.398878f,
+	0.155589f,
+	0.965139f,
+	-0.210473f,
+	0.031565f,
+	0.984349f,
+	-0.173382f,
+	0.0970165f,
+	0.970686f,
+	-0.219901f,
+	-0.0352366f,
+	0.943342f,
+	-0.329946f,
+	-0.0636858f,
+	0.931929f,
+	-0.357006f,
+	0.111555f,
+	0.924517f,
+	-0.364451f,
+	0.180963f,
+	0.908751f,
+	-0.376064f,
+	0.0582409f,
+	0.924666f,
+	-0.376299f,
+	-0.091325f,
+	0.934476f,
+	-0.344113f,
+	-0.148498f,
+	0.963415f,
+	-0.223113f,
+	-0.170646f,
+	0.976481f,
+	-0.131776f,
+	-0.0961794f,
+	0.980781f,
+	-0.169761f,
+	-0.06221f,
+	0.973089f,
+	-0.221874f,
+	0.206636f,
+	0.934831f,
+	0.288777f,
+	0.0869406f,
+	0.963592f,
+	0.252847f,
+	0.0799701f,
+	0.959241f,
+	0.271038f,
+	0.160525f,
+	0.963414f,
+	0.21463f,
+	0.255681f,
+	0.955661f,
+	0.146082f,
+	0.323027f,
+	0.93103f,
+	0.169812f,
+	0.330118f,
+	0.920313f,
+	0.209873f,
+	0.447578f,
+	0.884885f,
+	0.12904f,
+	0.467368f,
+	0.874534f,
+	0.129448f,
+	0.130174f,
+	0.988207f,
+	0.0806387f,
+	0.145402f,
+	0.989036f,
+	-0.0258009f,
+	0.425216f,
+	0.898822f,
+	-0.106345f,
+	0.205136f,
+	0.977985f,
+	-0.0382811f,
+	-0.0258123f,
+	0.995757f,
+	0.0883314f,
+	-0.00518813f,
+	0.996132f,
+	0.0877124f,
+	-0.192412f,
+	0.980974f,
+	0.0258233f,
+	-0.196114f,
+	0.979963f,
+	0.0348015f,
+	0.0217983f,
+	0.995754f,
+	0.0894399f,
+	-0.10216f,
+	0.980256f,
+	0.169296f,
+	-0.384424f,
+	0.908881f,
+	0.161723f,
+	-0.367551f,
+	0.91996f,
+	0.136309f,
+	-0.285788f,
+	0.948719f,
+	0.135118f,
+	-0.171256f,
+	0.972185f,
+	0.159771f,
+	-0.0605854f,
+	0.969905f,
+	0.235826f,
+	-0.167372f,
+	0.981266f,
+	0.0954134f,
+	-0.0977838f,
+	0.994994f,
+	0.0206294f,
+	0.0451608f,
+	0.997867f,
+	0.0471292f,
+	-0.0136124f,
+	0.997411f,
+	0.0706177f,
+	-0.158818f,
+	0.986831f,
+	0.0306748f,
+	0.0267005f,
+	0.99957f,
+	0.0121357f,
+	0.289361f,
+	0.957076f,
+	-0.0166175f,
+	0.336393f,
+	0.939976f,
+	-0.0573177f,
+	0.390118f,
+	0.913466f,
+	-0.115702f,
+	0.445853f,
+	0.875576f,
+	-0.185959f,
+	0.293335f,
+	0.914816f,
+	-0.277609f,
+	-0.00739937f,
+	0.915657f,
+	-0.401893f,
+	0.00533725f,
+	0.872492f,
+	-0.488599f,
+	0.197734f,
+	0.788261f,
+	-0.582705f,
+	0.43334f,
+	0.722538f,
+	-0.53866f,
+	0.548408f,
+	0.706281f,
+	-0.447678f,
+	0.484095f,
+	0.751007f,
+	-0.449045f,
+	0.458828f,
+	0.77804f,
+	-0.429103f,
+	0.441245f,
+	0.787203f,
+	-0.430829f,
+	0.474553f,
+	0.805707f,
+	-0.354451f,
+	0.550933f,
+	0.789486f,
+	-0.270526f,
+	0.502032f,
+	0.792798f,
+	-0.345594f,
+	0.478273f,
+	0.764634f,
+	-0.43196f,
+	0.556872f,
+	0.730832f,
+	-0.394687f,
+	0.471855f,
+	0.788619f,
+	-0.394251f,
+	0.354943f,
+	0.841801f,
+	-0.406677f,
+	0.154029f,
+	0.899791f,
+	-0.40823f,
+	0.0155123f,
+	0.938951f,
+	-0.343701f,
+	0.0497714f,
+	0.948037f,
+	-0.314243f,
+	0.154285f,
+	0.935402f,
+	-0.31815f,
+	0.101927f,
+	0.920411f,
+	-0.377432f,
+	-0.0203862f,
+	0.864666f,
+	-0.501933f,
+	0.070179f,
+	0.866621f,
+	-0.494007f,
+	0.100294f,
+	0.910674f,
+	-0.400766f,
+	0.000402101f,
+	0.968295f,
+	-0.249809f,
+	-0.128961f,
+	0.971456f,
+	-0.199105f,
+	-0.199723f,
+	0.946207f,
+	-0.254564f,
+	-0.134113f,
+	0.940975f,
+	-0.310772f,
+	-0.0316747f,
+	0.927512f,
+	-0.372449f,
+	0.0302907f,
+	0.938917f,
+	-0.342807f,
+	0.218976f,
+	0.899032f,
+	0.379198f,
+	0.139079f,
+	0.919337f,
+	0.368072f,
+	0.135024f,
+	0.957047f,
+	0.256573f,
+	0.313512f,
+	0.936875f,
+	0.154838f,
+	0.29644f,
+	0.95504f,
+	0.00476296f,
+	0.279277f,
+	0.959996f,
+	0.0202722f,
+	0.3625f,
+	0.931007f,
+	0.0426625f,
+	0.472022f,
+	0.881367f,
+	0.0196857f,
+	0.429567f,
+	0.887347f,
+	0.167594f,
+	0.224991f,
+	0.963227f,
+	0.146879f,
+	0.296133f,
+	0.954919f,
+	-0.0208476f,
+	0.415966f,
+	0.902166f,
+	-0.114319f,
+	0.183129f,
+	0.982743f,
+	0.0260829f,
+	-0.0925135f,
+	0.995706f,
+	-0.00325499f,
+	-0.0437431f,
+	0.995986f,
+	0.0780946f,
+	-0.179713f,
+	0.977607f,
+	0.109486f,
+	-0.141385f,
+	0.986823f,
+	0.0786845f,
+	-0.085949f,
+	0.993479f,
+	0.0749198f,
+	-0.233157f,
+	0.944593f,
+	0.231044f,
+	-0.345216f,
+	0.897121f,
+	0.275681f,
+	-0.266518f,
+	0.944857f,
+	0.190296f,
+	-0.236509f,
+	0.971079f,
+	0.032684f,
+	-0.255527f,
+	0.96653f,
+	-0.0229239f,
+	-0.0941044f,
+	0.991025f,
+	0.0949427f,
+	-0.0715158f,
+	0.990946f,
+	0.113625f,
+	-0.0636481f,
+	0.988651f,
+	0.136079f,
+	0.0130078f,
+	0.992968f,
+	0.11767f,
+	0.0194535f,
+	0.99321f,
+	0.114698f,
+	-0.0733749f,
+	0.997304f,
+	0.000320173f,
+	0.0745089f,
+	0.991949f,
+	-0.102398f,
+	0.316045f,
+	0.940065f,
+	-0.128038f,
+	0.302503f,
+	0.936628f,
+	-0.176692f,
+	0.365578f,
+	0.917629f,
+	-0.155918f,
+	0.474055f,
+	0.875706f,
+	-0.091714f,
+	0.462666f,
+	0.882661f,
+	-0.0827679f,
+	0.197672f,
+	0.918824f,
+	-0.341598f,
+	0.1211f,
+	0.851979f,
+	-0.509379f,
+	0.340562f,
+	0.776445f,
+	-0.530237f,
+	0.411588f,
+	0.704014f,
+	-0.578756f,
+	0.454493f,
+	0.713166f,
+	-0.533695f,
+	0.463114f,
+	0.742631f,
+	-0.483761f,
+	0.44079f,
+	0.754688f,
+	-0.485953f,
+	0.400302f,
+	0.772025f,
+	-0.493696f,
+	0.38659f,
+	0.783016f,
+	-0.487272f,
+	0.457033f,
+	0.766931f,
+	-0.450487f,
+	0.547084f,
+	0.759757f,
+	-0.351382f,
+	0.508566f,
+	0.782012f,
+	-0.360303f,
+	0.54699f,
+	0.792915f,
+	-0.268492f,
+	0.489855f,
+	0.837224f,
+	-0.243102f,
+	0.350988f,
+	0.891534f,
+	-0.286312f,
+	0.195385f,
+	0.947495f,
+	-0.253137f,
+	0.0709694f,
+	0.939176f,
+	-0.336023f,
+	0.0288377f,
+	0.903143f,
+	-0.42837f,
+	0.128806f,
+	0.91498f,
+	-0.382389f,
+	0.209123f,
+	0.895775f,
+	-0.392243f,
+	0.0981301f,
+	0.852621f,
+	-0.513233f,
+	-0.0414306f,
+	0.841347f,
+	-0.538906f,
+	-0.0951984f,
+	0.922571f,
+	-0.373899f,
+	-0.157973f,
+	0.963972f,
+	-0.214014f,
+	-0.107909f,
+	0.978829f,
+	-0.173926f,
+	-0.0713291f,
+	0.969594f,
+	-0.234092f,
+	0.0141898f,
+	0.950434f,
+	-0.310602f,
+	-0.0202439f,
+	0.895649f,
+	-0.4443f,
+	-0.114151f,
+	0.867225f,
+	-0.484655f,
+	0.0955354f,
+	0.969912f,
+	0.223927f,
+	0.218114f,
+	0.913651f,
+	0.343028f,
+	0.223104f,
+	0.958808f,
+	0.175816f,
+	0.39761f,
+	0.915149f,
+	0.0663907f,
+	0.332649f,
+	0.940641f,
+	-0.0673772f,
+	0.280455f,
+	0.956871f,
+	-0.0757854f,
+	0.359446f,
+	0.926985f,
+	-0.107225f,
+	0.369482f,
+	0.924827f,
+	-0.0904272f,
+	0.410746f,
+	0.887001f,
+	0.210991f,
+	0.335823f,
+	0.922126f,
+	0.192112f,
+	0.395669f,
+	0.917218f,
+	-0.0464346f,
+	0.353697f,
+	0.926083f,
+	-0.131407f,
+	0.179534f,
+	0.981887f,
+	0.0605388f,
+	-0.13479f,
+	0.99057f,
+	-0.0245515f,
+	-0.0725996f,
+	0.990136f,
+	0.119831f,
+	-0.160567f,
+	0.981095f,
+	0.108036f,
+	-0.173547f,
+	0.983858f,
+	0.0436428f,
+	-0.151709f,
+	0.976244f,
+	0.154697f,
+	-0.302597f,
+	0.914896f,
+	0.267208f,
+	-0.328732f,
+	0.906446f,
+	0.265123f,
+	-0.132663f,
+	0.960039f,
+	0.246424f,
+	-0.138673f,
+	0.989957f,
+	0.0274833f,
+	-0.234284f,
+	0.968151f,
+	-0.0882923f,
+	-0.176173f,
+	0.979923f,
+	-0.0933525f,
+	-0.138089f,
+	0.990412f,
+	-0.00402308f,
+	-0.0957719f,
+	0.981754f,
+	0.164279f,
+	0.0343111f,
+	0.979592f,
+	0.198047f,
+	0.0638942f,
+	0.984862f,
+	0.161133f,
+	0.0719687f,
+	0.995312f,
+	0.0646062f,
+	0.0847007f,
+	0.982914f,
+	-0.163422f,
+	0.363247f,
+	0.926697f,
+	-0.0963506f,
+	0.36667f,
+	0.908341f,
+	-0.201173f,
+	0.337169f,
+	0.882657f,
+	-0.327465f,
+	0.394509f,
+	0.879929f,
+	-0.264742f,
+	0.48646f,
+	0.864989f,
+	-0.123088f,
+	0.417344f,
+	0.883151f,
+	-0.21417f,
+	0.20086f,
+	0.830272f,
+	-0.519907f,
+	0.38892f,
+	0.767179f,
+	-0.510077f,
+	0.449414f,
+	0.718324f,
+	-0.531072f,
+	0.423477f,
+	0.726204f,
+	-0.541567f,
+	0.422958f,
+	0.74196f,
+	-0.520194f,
+	0.433204f,
+	0.760712f,
+	-0.483374f,
+	0.409051f,
+	0.775415f,
+	-0.481049f,
+	0.416047f,
+	0.762178f,
+	-0.495973f,
+	0.412818f,
+	0.728929f,
+	-0.546117f,
+	0.422596f,
+	0.756339f,
+	-0.499363f,
+	0.473538f,
+	0.806572f,
+	-0.353841f,
+	0.474731f,
+	0.838081f,
+	-0.268794f,
+	0.539079f,
+	0.832631f,
+	-0.126962f,
+	0.311124f,
+	0.910644f,
+	-0.271898f,
+	0.195648f,
+	0.962321f,
+	-0.18884f,
+	0.177086f,
+	0.961235f,
+	-0.211349f,
+	0.0559264f,
+	0.927874f,
+	-0.368677f,
+	0.121016f,
+	0.928529f,
+	-0.350982f,
+	0.256538f,
+	0.895264f,
+	-0.364269f,
+	0.222607f,
+	0.876269f,
+	-0.427317f,
+	-0.106542f,
+	0.82471f,
+	-0.55543f,
+	-0.245122f,
+	0.890501f,
+	-0.383305f,
+	-0.209725f,
+	0.956698f,
+	-0.201855f,
+	-0.0624605f,
+	0.97406f,
+	-0.2175f,
+	-0.0812465f,
+	0.947824f,
+	-0.308266f,
+	0.0649824f,
+	0.972455f,
+	-0.223851f,
+	0.119957f,
+	0.950206f,
+	-0.287609f,
+	-0.0414767f,
+	0.905483f,
+	-0.422351f,
+};
+
+btScalar Landscape03Tex[] = {
+	0.507813f,
+	0.5f,
+	0.507813f,
+	0.492188f,
+	0.515625f,
+	0.5f,
+	0.515625f,
+	0.492188f,
+	0.523438f,
+	0.5f,
+	0.523438f,
+	0.492188f,
+	0.53125f,
+	0.5f,
+	0.53125f,
+	0.492188f,
+	0.539063f,
+	0.5f,
+	0.539063f,
+	0.492188f,
+	0.546875f,
+	0.5f,
+	0.546875f,
+	0.492188f,
+	0.554688f,
+	0.5f,
+	0.554688f,
+	0.492188f,
+	0.5625f,
+	0.5f,
+	0.5625f,
+	0.492188f,
+	0.570313f,
+	0.5f,
+	0.570313f,
+	0.492188f,
+	0.578125f,
+	0.5f,
+	0.578125f,
+	0.492188f,
+	0.585938f,
+	0.5f,
+	0.585938f,
+	0.492188f,
+	0.59375f,
+	0.5f,
+	0.59375f,
+	0.492188f,
+	0.601563f,
+	0.5f,
+	0.601563f,
+	0.492188f,
+	0.609375f,
+	0.5f,
+	0.609375f,
+	0.492188f,
+	0.617188f,
+	0.5f,
+	0.617188f,
+	0.492188f,
+	0.625f,
+	0.5f,
+	0.625f,
+	0.492188f,
+	0.632813f,
+	0.5f,
+	0.632813f,
+	0.492188f,
+	0.640625f,
+	0.5f,
+	0.640625f,
+	0.492188f,
+	0.648438f,
+	0.5f,
+	0.648438f,
+	0.492188f,
+	0.65625f,
+	0.5f,
+	0.65625f,
+	0.492188f,
+	0.664063f,
+	0.5f,
+	0.664063f,
+	0.492188f,
+	0.671875f,
+	0.5f,
+	0.671875f,
+	0.492188f,
+	0.679688f,
+	0.5f,
+	0.679688f,
+	0.492188f,
+	0.6875f,
+	0.5f,
+	0.6875f,
+	0.492188f,
+	0.695313f,
+	0.5f,
+	0.695313f,
+	0.492188f,
+	0.703125f,
+	0.5f,
+	0.703125f,
+	0.492188f,
+	0.710938f,
+	0.5f,
+	0.710938f,
+	0.492188f,
+	0.71875f,
+	0.5f,
+	0.71875f,
+	0.492188f,
+	0.726563f,
+	0.5f,
+	0.726563f,
+	0.492188f,
+	0.734375f,
+	0.5f,
+	0.734375f,
+	0.492188f,
+	0.742188f,
+	0.5f,
+	0.742188f,
+	0.492188f,
+	0.75f,
+	0.5f,
+	0.75f,
+	0.492188f,
+	0.757813f,
+	0.5f,
+	0.757813f,
+	0.492188f,
+	0.765625f,
+	0.5f,
+	0.765625f,
+	0.492188f,
+	0.773438f,
+	0.5f,
+	0.773438f,
+	0.492188f,
+	0.78125f,
+	0.5f,
+	0.78125f,
+	0.492188f,
+	0.789063f,
+	0.5f,
+	0.789063f,
+	0.492188f,
+	0.796875f,
+	0.5f,
+	0.796875f,
+	0.492188f,
+	0.804688f,
+	0.5f,
+	0.804688f,
+	0.492188f,
+	0.8125f,
+	0.5f,
+	0.8125f,
+	0.492188f,
+	0.820313f,
+	0.5f,
+	0.820313f,
+	0.492188f,
+	0.828125f,
+	0.5f,
+	0.828125f,
+	0.492188f,
+	0.835938f,
+	0.5f,
+	0.835938f,
+	0.492188f,
+	0.84375f,
+	0.5f,
+	0.84375f,
+	0.492188f,
+	0.851563f,
+	0.5f,
+	0.851563f,
+	0.492188f,
+	0.859375f,
+	0.5f,
+	0.859375f,
+	0.492188f,
+	0.867188f,
+	0.5f,
+	0.867188f,
+	0.492188f,
+	0.875f,
+	0.5f,
+	0.875f,
+	0.492188f,
+	0.882813f,
+	0.5f,
+	0.882813f,
+	0.492188f,
+	0.890625f,
+	0.5f,
+	0.890625f,
+	0.492188f,
+	0.898438f,
+	0.5f,
+	0.898438f,
+	0.492188f,
+	0.90625f,
+	0.5f,
+	0.90625f,
+	0.492188f,
+	0.914063f,
+	0.5f,
+	0.914063f,
+	0.492188f,
+	0.921875f,
+	0.5f,
+	0.921875f,
+	0.492188f,
+	0.929688f,
+	0.5f,
+	0.929688f,
+	0.492188f,
+	0.9375f,
+	0.5f,
+	0.9375f,
+	0.492188f,
+	0.945313f,
+	0.5f,
+	0.945313f,
+	0.492188f,
+	0.953125f,
+	0.5f,
+	0.953125f,
+	0.492188f,
+	0.960938f,
+	0.5f,
+	0.960938f,
+	0.492188f,
+	0.96875f,
+	0.5f,
+	0.96875f,
+	0.492188f,
+	0.976563f,
+	0.5f,
+	0.976563f,
+	0.492188f,
+	0.984375f,
+	0.5f,
+	0.984375f,
+	0.492188f,
+	0.992188f,
+	0.5f,
+	0.992188f,
+	0.492188f,
+	1.0f,
+	0.5f,
+	1.0f,
+	0.492188f,
+	0.507813f,
+	0.507813f,
+	0.515625f,
+	0.507813f,
+	0.523438f,
+	0.507813f,
+	0.53125f,
+	0.507813f,
+	0.539063f,
+	0.507813f,
+	0.546875f,
+	0.507813f,
+	0.554688f,
+	0.507813f,
+	0.5625f,
+	0.507813f,
+	0.570313f,
+	0.507813f,
+	0.578125f,
+	0.507813f,
+	0.585938f,
+	0.507813f,
+	0.59375f,
+	0.507813f,
+	0.601563f,
+	0.507813f,
+	0.609375f,
+	0.507813f,
+	0.617188f,
+	0.507813f,
+	0.625f,
+	0.507813f,
+	0.632813f,
+	0.507813f,
+	0.640625f,
+	0.507813f,
+	0.648438f,
+	0.507813f,
+	0.65625f,
+	0.507813f,
+	0.664063f,
+	0.507813f,
+	0.671875f,
+	0.507813f,
+	0.679688f,
+	0.507813f,
+	0.6875f,
+	0.507813f,
+	0.695313f,
+	0.507813f,
+	0.703125f,
+	0.507813f,
+	0.710938f,
+	0.507813f,
+	0.71875f,
+	0.507813f,
+	0.726563f,
+	0.507813f,
+	0.734375f,
+	0.507813f,
+	0.742188f,
+	0.507813f,
+	0.75f,
+	0.507813f,
+	0.757813f,
+	0.507813f,
+	0.765625f,
+	0.507813f,
+	0.773438f,
+	0.507813f,
+	0.78125f,
+	0.507813f,
+	0.789063f,
+	0.507813f,
+	0.796875f,
+	0.507813f,
+	0.804688f,
+	0.507813f,
+	0.8125f,
+	0.507813f,
+	0.820313f,
+	0.507813f,
+	0.828125f,
+	0.507813f,
+	0.835938f,
+	0.507813f,
+	0.84375f,
+	0.507813f,
+	0.851563f,
+	0.507813f,
+	0.859375f,
+	0.507813f,
+	0.867188f,
+	0.507813f,
+	0.875f,
+	0.507813f,
+	0.882813f,
+	0.507813f,
+	0.890625f,
+	0.507813f,
+	0.898438f,
+	0.507813f,
+	0.90625f,
+	0.507813f,
+	0.914063f,
+	0.507813f,
+	0.921875f,
+	0.507813f,
+	0.929688f,
+	0.507813f,
+	0.9375f,
+	0.507813f,
+	0.945313f,
+	0.507813f,
+	0.953125f,
+	0.507813f,
+	0.960938f,
+	0.507813f,
+	0.96875f,
+	0.507813f,
+	0.976563f,
+	0.507813f,
+	0.984375f,
+	0.507813f,
+	0.992188f,
+	0.507813f,
+	1.0f,
+	0.507813f,
+	0.507813f,
+	0.515625f,
+	0.515625f,
+	0.515625f,
+	0.523438f,
+	0.515625f,
+	0.53125f,
+	0.515625f,
+	0.539063f,
+	0.515625f,
+	0.546875f,
+	0.515625f,
+	0.554688f,
+	0.515625f,
+	0.5625f,
+	0.515625f,
+	0.570313f,
+	0.515625f,
+	0.578125f,
+	0.515625f,
+	0.585938f,
+	0.515625f,
+	0.59375f,
+	0.515625f,
+	0.601563f,
+	0.515625f,
+	0.609375f,
+	0.515625f,
+	0.617188f,
+	0.515625f,
+	0.625f,
+	0.515625f,
+	0.632813f,
+	0.515625f,
+	0.640625f,
+	0.515625f,
+	0.648438f,
+	0.515625f,
+	0.65625f,
+	0.515625f,
+	0.664063f,
+	0.515625f,
+	0.671875f,
+	0.515625f,
+	0.679688f,
+	0.515625f,
+	0.6875f,
+	0.515625f,
+	0.695313f,
+	0.515625f,
+	0.703125f,
+	0.515625f,
+	0.710938f,
+	0.515625f,
+	0.71875f,
+	0.515625f,
+	0.726563f,
+	0.515625f,
+	0.734375f,
+	0.515625f,
+	0.742188f,
+	0.515625f,
+	0.75f,
+	0.515625f,
+	0.757813f,
+	0.515625f,
+	0.765625f,
+	0.515625f,
+	0.773438f,
+	0.515625f,
+	0.78125f,
+	0.515625f,
+	0.789063f,
+	0.515625f,
+	0.796875f,
+	0.515625f,
+	0.804688f,
+	0.515625f,
+	0.8125f,
+	0.515625f,
+	0.820313f,
+	0.515625f,
+	0.828125f,
+	0.515625f,
+	0.835938f,
+	0.515625f,
+	0.84375f,
+	0.515625f,
+	0.851563f,
+	0.515625f,
+	0.859375f,
+	0.515625f,
+	0.867188f,
+	0.515625f,
+	0.875f,
+	0.515625f,
+	0.882813f,
+	0.515625f,
+	0.890625f,
+	0.515625f,
+	0.898438f,
+	0.515625f,
+	0.90625f,
+	0.515625f,
+	0.914063f,
+	0.515625f,
+	0.921875f,
+	0.515625f,
+	0.929688f,
+	0.515625f,
+	0.9375f,
+	0.515625f,
+	0.945313f,
+	0.515625f,
+	0.953125f,
+	0.515625f,
+	0.960938f,
+	0.515625f,
+	0.96875f,
+	0.515625f,
+	0.976563f,
+	0.515625f,
+	0.984375f,
+	0.515625f,
+	0.992188f,
+	0.515625f,
+	1.0f,
+	0.515625f,
+	0.507813f,
+	0.523438f,
+	0.515625f,
+	0.523438f,
+	0.523438f,
+	0.523438f,
+	0.53125f,
+	0.523438f,
+	0.539063f,
+	0.523438f,
+	0.546875f,
+	0.523438f,
+	0.554688f,
+	0.523438f,
+	0.5625f,
+	0.523438f,
+	0.570313f,
+	0.523438f,
+	0.578125f,
+	0.523438f,
+	0.585938f,
+	0.523438f,
+	0.59375f,
+	0.523438f,
+	0.601563f,
+	0.523438f,
+	0.609375f,
+	0.523438f,
+	0.617188f,
+	0.523438f,
+	0.625f,
+	0.523438f,
+	0.632813f,
+	0.523438f,
+	0.640625f,
+	0.523438f,
+	0.648438f,
+	0.523438f,
+	0.65625f,
+	0.523438f,
+	0.664063f,
+	0.523438f,
+	0.671875f,
+	0.523438f,
+	0.679688f,
+	0.523438f,
+	0.6875f,
+	0.523438f,
+	0.695313f,
+	0.523438f,
+	0.703125f,
+	0.523438f,
+	0.710938f,
+	0.523438f,
+	0.71875f,
+	0.523438f,
+	0.726563f,
+	0.523438f,
+	0.734375f,
+	0.523438f,
+	0.742188f,
+	0.523438f,
+	0.75f,
+	0.523438f,
+	0.757813f,
+	0.523438f,
+	0.765625f,
+	0.523438f,
+	0.773438f,
+	0.523438f,
+	0.78125f,
+	0.523438f,
+	0.789063f,
+	0.523438f,
+	0.796875f,
+	0.523438f,
+	0.804688f,
+	0.523438f,
+	0.8125f,
+	0.523438f,
+	0.820313f,
+	0.523438f,
+	0.828125f,
+	0.523438f,
+	0.835938f,
+	0.523438f,
+	0.84375f,
+	0.523438f,
+	0.851563f,
+	0.523438f,
+	0.859375f,
+	0.523438f,
+	0.867188f,
+	0.523438f,
+	0.875f,
+	0.523438f,
+	0.882813f,
+	0.523438f,
+	0.890625f,
+	0.523438f,
+	0.898438f,
+	0.523438f,
+	0.90625f,
+	0.523438f,
+	0.914063f,
+	0.523438f,
+	0.921875f,
+	0.523438f,
+	0.929688f,
+	0.523438f,
+	0.9375f,
+	0.523438f,
+	0.945313f,
+	0.523438f,
+	0.953125f,
+	0.523438f,
+	0.960938f,
+	0.523438f,
+	0.96875f,
+	0.523438f,
+	0.976563f,
+	0.523438f,
+	0.984375f,
+	0.523438f,
+	0.992188f,
+	0.523438f,
+	1.0f,
+	0.523438f,
+	0.507813f,
+	0.53125f,
+	0.515625f,
+	0.53125f,
+	0.523438f,
+	0.53125f,
+	0.53125f,
+	0.53125f,
+	0.539063f,
+	0.53125f,
+	0.546875f,
+	0.53125f,
+	0.554688f,
+	0.53125f,
+	0.5625f,
+	0.53125f,
+	0.570313f,
+	0.53125f,
+	0.578125f,
+	0.53125f,
+	0.585938f,
+	0.53125f,
+	0.59375f,
+	0.53125f,
+	0.601563f,
+	0.53125f,
+	0.609375f,
+	0.53125f,
+	0.617188f,
+	0.53125f,
+	0.625f,
+	0.53125f,
+	0.632813f,
+	0.53125f,
+	0.640625f,
+	0.53125f,
+	0.648438f,
+	0.53125f,
+	0.65625f,
+	0.53125f,
+	0.664063f,
+	0.53125f,
+	0.671875f,
+	0.53125f,
+	0.679688f,
+	0.53125f,
+	0.6875f,
+	0.53125f,
+	0.695313f,
+	0.53125f,
+	0.703125f,
+	0.53125f,
+	0.710938f,
+	0.53125f,
+	0.71875f,
+	0.53125f,
+	0.726563f,
+	0.53125f,
+	0.734375f,
+	0.53125f,
+	0.742188f,
+	0.53125f,
+	0.75f,
+	0.53125f,
+	0.757813f,
+	0.53125f,
+	0.765625f,
+	0.53125f,
+	0.773438f,
+	0.53125f,
+	0.78125f,
+	0.53125f,
+	0.789063f,
+	0.53125f,
+	0.796875f,
+	0.53125f,
+	0.804688f,
+	0.53125f,
+	0.8125f,
+	0.53125f,
+	0.820313f,
+	0.53125f,
+	0.828125f,
+	0.53125f,
+	0.835938f,
+	0.53125f,
+	0.84375f,
+	0.53125f,
+	0.851563f,
+	0.53125f,
+	0.859375f,
+	0.53125f,
+	0.867188f,
+	0.53125f,
+	0.875f,
+	0.53125f,
+	0.882813f,
+	0.53125f,
+	0.890625f,
+	0.53125f,
+	0.898438f,
+	0.53125f,
+	0.90625f,
+	0.53125f,
+	0.914063f,
+	0.53125f,
+	0.921875f,
+	0.53125f,
+	0.929688f,
+	0.53125f,
+	0.9375f,
+	0.53125f,
+	0.945313f,
+	0.53125f,
+	0.953125f,
+	0.53125f,
+	0.960938f,
+	0.53125f,
+	0.96875f,
+	0.53125f,
+	0.976563f,
+	0.53125f,
+	0.984375f,
+	0.53125f,
+	0.992188f,
+	0.53125f,
+	1.0f,
+	0.53125f,
+	0.507813f,
+	0.539063f,
+	0.515625f,
+	0.539063f,
+	0.523438f,
+	0.539063f,
+	0.53125f,
+	0.539063f,
+	0.539063f,
+	0.539063f,
+	0.546875f,
+	0.539063f,
+	0.554688f,
+	0.539063f,
+	0.5625f,
+	0.539063f,
+	0.570313f,
+	0.539063f,
+	0.578125f,
+	0.539063f,
+	0.585938f,
+	0.539063f,
+	0.59375f,
+	0.539063f,
+	0.601563f,
+	0.539063f,
+	0.609375f,
+	0.539063f,
+	0.617188f,
+	0.539063f,
+	0.625f,
+	0.539063f,
+	0.632813f,
+	0.539063f,
+	0.640625f,
+	0.539063f,
+	0.648438f,
+	0.539063f,
+	0.65625f,
+	0.539063f,
+	0.664063f,
+	0.539063f,
+	0.671875f,
+	0.539063f,
+	0.679688f,
+	0.539063f,
+	0.6875f,
+	0.539063f,
+	0.695313f,
+	0.539063f,
+	0.703125f,
+	0.539063f,
+	0.710938f,
+	0.539063f,
+	0.71875f,
+	0.539063f,
+	0.726563f,
+	0.539063f,
+	0.734375f,
+	0.539063f,
+	0.742188f,
+	0.539063f,
+	0.75f,
+	0.539063f,
+	0.757813f,
+	0.539063f,
+	0.765625f,
+	0.539063f,
+	0.773438f,
+	0.539063f,
+	0.78125f,
+	0.539063f,
+	0.789063f,
+	0.539063f,
+	0.796875f,
+	0.539063f,
+	0.804688f,
+	0.539063f,
+	0.8125f,
+	0.539063f,
+	0.820313f,
+	0.539063f,
+	0.828125f,
+	0.539063f,
+	0.835938f,
+	0.539063f,
+	0.84375f,
+	0.539063f,
+	0.851563f,
+	0.539063f,
+	0.859375f,
+	0.539063f,
+	0.867188f,
+	0.539063f,
+	0.875f,
+	0.539063f,
+	0.882813f,
+	0.539063f,
+	0.890625f,
+	0.539063f,
+	0.898438f,
+	0.539063f,
+	0.90625f,
+	0.539063f,
+	0.914063f,
+	0.539063f,
+	0.921875f,
+	0.539063f,
+	0.929688f,
+	0.539063f,
+	0.9375f,
+	0.539063f,
+	0.945313f,
+	0.539063f,
+	0.953125f,
+	0.539063f,
+	0.960938f,
+	0.539063f,
+	0.96875f,
+	0.539063f,
+	0.976563f,
+	0.539063f,
+	0.984375f,
+	0.539063f,
+	0.992188f,
+	0.539063f,
+	1.0f,
+	0.539063f,
+	0.507813f,
+	0.546875f,
+	0.515625f,
+	0.546875f,
+	0.523438f,
+	0.546875f,
+	0.53125f,
+	0.546875f,
+	0.539063f,
+	0.546875f,
+	0.546875f,
+	0.546875f,
+	0.554688f,
+	0.546875f,
+	0.5625f,
+	0.546875f,
+	0.570313f,
+	0.546875f,
+	0.578125f,
+	0.546875f,
+	0.585938f,
+	0.546875f,
+	0.59375f,
+	0.546875f,
+	0.601563f,
+	0.546875f,
+	0.609375f,
+	0.546875f,
+	0.617188f,
+	0.546875f,
+	0.625f,
+	0.546875f,
+	0.632813f,
+	0.546875f,
+	0.640625f,
+	0.546875f,
+	0.648438f,
+	0.546875f,
+	0.65625f,
+	0.546875f,
+	0.664063f,
+	0.546875f,
+	0.671875f,
+	0.546875f,
+	0.679688f,
+	0.546875f,
+	0.6875f,
+	0.546875f,
+	0.695313f,
+	0.546875f,
+	0.703125f,
+	0.546875f,
+	0.710938f,
+	0.546875f,
+	0.71875f,
+	0.546875f,
+	0.726563f,
+	0.546875f,
+	0.734375f,
+	0.546875f,
+	0.742188f,
+	0.546875f,
+	0.75f,
+	0.546875f,
+	0.757813f,
+	0.546875f,
+	0.765625f,
+	0.546875f,
+	0.773438f,
+	0.546875f,
+	0.78125f,
+	0.546875f,
+	0.789063f,
+	0.546875f,
+	0.796875f,
+	0.546875f,
+	0.804688f,
+	0.546875f,
+	0.8125f,
+	0.546875f,
+	0.820313f,
+	0.546875f,
+	0.828125f,
+	0.546875f,
+	0.835938f,
+	0.546875f,
+	0.84375f,
+	0.546875f,
+	0.851563f,
+	0.546875f,
+	0.859375f,
+	0.546875f,
+	0.867188f,
+	0.546875f,
+	0.875f,
+	0.546875f,
+	0.882813f,
+	0.546875f,
+	0.890625f,
+	0.546875f,
+	0.898438f,
+	0.546875f,
+	0.90625f,
+	0.546875f,
+	0.914063f,
+	0.546875f,
+	0.921875f,
+	0.546875f,
+	0.929688f,
+	0.546875f,
+	0.9375f,
+	0.546875f,
+	0.945313f,
+	0.546875f,
+	0.953125f,
+	0.546875f,
+	0.960938f,
+	0.546875f,
+	0.96875f,
+	0.546875f,
+	0.976563f,
+	0.546875f,
+	0.984375f,
+	0.546875f,
+	0.992188f,
+	0.546875f,
+	1.0f,
+	0.546875f,
+	0.507813f,
+	0.554688f,
+	0.515625f,
+	0.554688f,
+	0.523438f,
+	0.554688f,
+	0.53125f,
+	0.554688f,
+	0.539063f,
+	0.554688f,
+	0.546875f,
+	0.554688f,
+	0.554688f,
+	0.554688f,
+	0.5625f,
+	0.554688f,
+	0.570313f,
+	0.554688f,
+	0.578125f,
+	0.554688f,
+	0.585938f,
+	0.554688f,
+	0.59375f,
+	0.554688f,
+	0.601563f,
+	0.554688f,
+	0.609375f,
+	0.554688f,
+	0.617188f,
+	0.554688f,
+	0.625f,
+	0.554688f,
+	0.632813f,
+	0.554688f,
+	0.640625f,
+	0.554688f,
+	0.648438f,
+	0.554688f,
+	0.65625f,
+	0.554688f,
+	0.664063f,
+	0.554688f,
+	0.671875f,
+	0.554688f,
+	0.679688f,
+	0.554688f,
+	0.6875f,
+	0.554688f,
+	0.695313f,
+	0.554688f,
+	0.703125f,
+	0.554688f,
+	0.710938f,
+	0.554688f,
+	0.71875f,
+	0.554688f,
+	0.726563f,
+	0.554688f,
+	0.734375f,
+	0.554688f,
+	0.742188f,
+	0.554688f,
+	0.75f,
+	0.554688f,
+	0.757813f,
+	0.554688f,
+	0.765625f,
+	0.554688f,
+	0.773438f,
+	0.554688f,
+	0.78125f,
+	0.554688f,
+	0.789063f,
+	0.554688f,
+	0.796875f,
+	0.554688f,
+	0.804688f,
+	0.554688f,
+	0.8125f,
+	0.554688f,
+	0.820313f,
+	0.554688f,
+	0.828125f,
+	0.554688f,
+	0.835938f,
+	0.554688f,
+	0.84375f,
+	0.554688f,
+	0.851563f,
+	0.554688f,
+	0.859375f,
+	0.554688f,
+	0.867188f,
+	0.554688f,
+	0.875f,
+	0.554688f,
+	0.882813f,
+	0.554688f,
+	0.890625f,
+	0.554688f,
+	0.898438f,
+	0.554688f,
+	0.90625f,
+	0.554688f,
+	0.914063f,
+	0.554688f,
+	0.921875f,
+	0.554688f,
+	0.929688f,
+	0.554688f,
+	0.9375f,
+	0.554688f,
+	0.945313f,
+	0.554688f,
+	0.953125f,
+	0.554688f,
+	0.960938f,
+	0.554688f,
+	0.96875f,
+	0.554688f,
+	0.976563f,
+	0.554688f,
+	0.984375f,
+	0.554688f,
+	0.992188f,
+	0.554688f,
+	1.0f,
+	0.554688f,
+	0.507813f,
+	0.5625f,
+	0.515625f,
+	0.5625f,
+	0.523438f,
+	0.5625f,
+	0.53125f,
+	0.5625f,
+	0.539063f,
+	0.5625f,
+	0.546875f,
+	0.5625f,
+	0.554688f,
+	0.5625f,
+	0.5625f,
+	0.5625f,
+	0.570313f,
+	0.5625f,
+	0.578125f,
+	0.5625f,
+	0.585938f,
+	0.5625f,
+	0.59375f,
+	0.5625f,
+	0.601563f,
+	0.5625f,
+	0.609375f,
+	0.5625f,
+	0.617188f,
+	0.5625f,
+	0.625f,
+	0.5625f,
+	0.632813f,
+	0.5625f,
+	0.640625f,
+	0.5625f,
+	0.648438f,
+	0.5625f,
+	0.65625f,
+	0.5625f,
+	0.664063f,
+	0.5625f,
+	0.671875f,
+	0.5625f,
+	0.679688f,
+	0.5625f,
+	0.6875f,
+	0.5625f,
+	0.695313f,
+	0.5625f,
+	0.703125f,
+	0.5625f,
+	0.710938f,
+	0.5625f,
+	0.71875f,
+	0.5625f,
+	0.726563f,
+	0.5625f,
+	0.734375f,
+	0.5625f,
+	0.742188f,
+	0.5625f,
+	0.75f,
+	0.5625f,
+	0.757813f,
+	0.5625f,
+	0.765625f,
+	0.5625f,
+	0.773438f,
+	0.5625f,
+	0.78125f,
+	0.5625f,
+	0.789063f,
+	0.5625f,
+	0.796875f,
+	0.5625f,
+	0.804688f,
+	0.5625f,
+	0.8125f,
+	0.5625f,
+	0.820313f,
+	0.5625f,
+	0.828125f,
+	0.5625f,
+	0.835938f,
+	0.5625f,
+	0.84375f,
+	0.5625f,
+	0.851563f,
+	0.5625f,
+	0.859375f,
+	0.5625f,
+	0.867188f,
+	0.5625f,
+	0.875f,
+	0.5625f,
+	0.882813f,
+	0.5625f,
+	0.890625f,
+	0.5625f,
+	0.898438f,
+	0.5625f,
+	0.90625f,
+	0.5625f,
+	0.914063f,
+	0.5625f,
+	0.921875f,
+	0.5625f,
+	0.929688f,
+	0.5625f,
+	0.9375f,
+	0.5625f,
+	0.945313f,
+	0.5625f,
+	0.953125f,
+	0.5625f,
+	0.960938f,
+	0.5625f,
+	0.96875f,
+	0.5625f,
+	0.976563f,
+	0.5625f,
+	0.984375f,
+	0.5625f,
+	0.992188f,
+	0.5625f,
+	1.0f,
+	0.5625f,
+	0.507813f,
+	0.570313f,
+	0.515625f,
+	0.570313f,
+	0.523438f,
+	0.570313f,
+	0.53125f,
+	0.570313f,
+	0.539063f,
+	0.570313f,
+	0.546875f,
+	0.570313f,
+	0.554688f,
+	0.570313f,
+	0.5625f,
+	0.570313f,
+	0.570313f,
+	0.570313f,
+	0.578125f,
+	0.570313f,
+	0.585938f,
+	0.570313f,
+	0.59375f,
+	0.570313f,
+	0.601563f,
+	0.570313f,
+	0.609375f,
+	0.570313f,
+	0.617188f,
+	0.570313f,
+	0.625f,
+	0.570313f,
+	0.632813f,
+	0.570313f,
+	0.640625f,
+	0.570313f,
+	0.648438f,
+	0.570313f,
+	0.65625f,
+	0.570313f,
+	0.664063f,
+	0.570313f,
+	0.671875f,
+	0.570313f,
+	0.679688f,
+	0.570313f,
+	0.6875f,
+	0.570313f,
+	0.695313f,
+	0.570313f,
+	0.703125f,
+	0.570313f,
+	0.710938f,
+	0.570313f,
+	0.71875f,
+	0.570313f,
+	0.726563f,
+	0.570313f,
+	0.734375f,
+	0.570313f,
+	0.742188f,
+	0.570313f,
+	0.75f,
+	0.570313f,
+	0.757813f,
+	0.570313f,
+	0.765625f,
+	0.570313f,
+	0.773438f,
+	0.570313f,
+	0.78125f,
+	0.570313f,
+	0.789063f,
+	0.570313f,
+	0.796875f,
+	0.570313f,
+	0.804688f,
+	0.570313f,
+	0.8125f,
+	0.570313f,
+	0.820313f,
+	0.570313f,
+	0.828125f,
+	0.570313f,
+	0.835938f,
+	0.570313f,
+	0.84375f,
+	0.570313f,
+	0.851563f,
+	0.570313f,
+	0.859375f,
+	0.570313f,
+	0.867188f,
+	0.570313f,
+	0.875f,
+	0.570313f,
+	0.882813f,
+	0.570313f,
+	0.890625f,
+	0.570313f,
+	0.898438f,
+	0.570313f,
+	0.90625f,
+	0.570313f,
+	0.914063f,
+	0.570313f,
+	0.921875f,
+	0.570313f,
+	0.929688f,
+	0.570313f,
+	0.9375f,
+	0.570313f,
+	0.945313f,
+	0.570313f,
+	0.953125f,
+	0.570313f,
+	0.960938f,
+	0.570313f,
+	0.96875f,
+	0.570313f,
+	0.976563f,
+	0.570313f,
+	0.984375f,
+	0.570313f,
+	0.992188f,
+	0.570313f,
+	1.0f,
+	0.570313f,
+	0.507813f,
+	0.578125f,
+	0.515625f,
+	0.578125f,
+	0.523438f,
+	0.578125f,
+	0.53125f,
+	0.578125f,
+	0.539063f,
+	0.578125f,
+	0.546875f,
+	0.578125f,
+	0.554688f,
+	0.578125f,
+	0.5625f,
+	0.578125f,
+	0.570313f,
+	0.578125f,
+	0.578125f,
+	0.578125f,
+	0.585938f,
+	0.578125f,
+	0.59375f,
+	0.578125f,
+	0.601563f,
+	0.578125f,
+	0.609375f,
+	0.578125f,
+	0.617188f,
+	0.578125f,
+	0.625f,
+	0.578125f,
+	0.632813f,
+	0.578125f,
+	0.640625f,
+	0.578125f,
+	0.648438f,
+	0.578125f,
+	0.65625f,
+	0.578125f,
+	0.664063f,
+	0.578125f,
+	0.671875f,
+	0.578125f,
+	0.679688f,
+	0.578125f,
+	0.6875f,
+	0.578125f,
+	0.695313f,
+	0.578125f,
+	0.703125f,
+	0.578125f,
+	0.710938f,
+	0.578125f,
+	0.71875f,
+	0.578125f,
+	0.726563f,
+	0.578125f,
+	0.734375f,
+	0.578125f,
+	0.742188f,
+	0.578125f,
+	0.75f,
+	0.578125f,
+	0.757813f,
+	0.578125f,
+	0.765625f,
+	0.578125f,
+	0.773438f,
+	0.578125f,
+	0.78125f,
+	0.578125f,
+	0.789063f,
+	0.578125f,
+	0.796875f,
+	0.578125f,
+	0.804688f,
+	0.578125f,
+	0.8125f,
+	0.578125f,
+	0.820313f,
+	0.578125f,
+	0.828125f,
+	0.578125f,
+	0.835938f,
+	0.578125f,
+	0.84375f,
+	0.578125f,
+	0.851563f,
+	0.578125f,
+	0.859375f,
+	0.578125f,
+	0.867188f,
+	0.578125f,
+	0.875f,
+	0.578125f,
+	0.882813f,
+	0.578125f,
+	0.890625f,
+	0.578125f,
+	0.898438f,
+	0.578125f,
+	0.90625f,
+	0.578125f,
+	0.914063f,
+	0.578125f,
+	0.921875f,
+	0.578125f,
+	0.929688f,
+	0.578125f,
+	0.9375f,
+	0.578125f,
+	0.945313f,
+	0.578125f,
+	0.953125f,
+	0.578125f,
+	0.960938f,
+	0.578125f,
+	0.96875f,
+	0.578125f,
+	0.976563f,
+	0.578125f,
+	0.984375f,
+	0.578125f,
+	0.992188f,
+	0.578125f,
+	1.0f,
+	0.578125f,
+	0.507813f,
+	0.585938f,
+	0.515625f,
+	0.585938f,
+	0.523438f,
+	0.585938f,
+	0.53125f,
+	0.585938f,
+	0.539063f,
+	0.585938f,
+	0.546875f,
+	0.585938f,
+	0.554688f,
+	0.585938f,
+	0.5625f,
+	0.585938f,
+	0.570313f,
+	0.585938f,
+	0.578125f,
+	0.585938f,
+	0.585938f,
+	0.585938f,
+	0.59375f,
+	0.585938f,
+	0.601563f,
+	0.585938f,
+	0.609375f,
+	0.585938f,
+	0.617188f,
+	0.585938f,
+	0.625f,
+	0.585938f,
+	0.632813f,
+	0.585938f,
+	0.640625f,
+	0.585938f,
+	0.648438f,
+	0.585938f,
+	0.65625f,
+	0.585938f,
+	0.664063f,
+	0.585938f,
+	0.671875f,
+	0.585938f,
+	0.679688f,
+	0.585938f,
+	0.6875f,
+	0.585938f,
+	0.695313f,
+	0.585938f,
+	0.703125f,
+	0.585938f,
+	0.710938f,
+	0.585938f,
+	0.71875f,
+	0.585938f,
+	0.726563f,
+	0.585938f,
+	0.734375f,
+	0.585938f,
+	0.742188f,
+	0.585938f,
+	0.75f,
+	0.585938f,
+	0.757813f,
+	0.585938f,
+	0.765625f,
+	0.585938f,
+	0.773438f,
+	0.585938f,
+	0.78125f,
+	0.585938f,
+	0.789063f,
+	0.585938f,
+	0.796875f,
+	0.585938f,
+	0.804688f,
+	0.585938f,
+	0.8125f,
+	0.585938f,
+	0.820313f,
+	0.585938f,
+	0.828125f,
+	0.585938f,
+	0.835938f,
+	0.585938f,
+	0.84375f,
+	0.585938f,
+	0.851563f,
+	0.585938f,
+	0.859375f,
+	0.585938f,
+	0.867188f,
+	0.585938f,
+	0.875f,
+	0.585938f,
+	0.882813f,
+	0.585938f,
+	0.890625f,
+	0.585938f,
+	0.898438f,
+	0.585938f,
+	0.90625f,
+	0.585938f,
+	0.914063f,
+	0.585938f,
+	0.921875f,
+	0.585938f,
+	0.929688f,
+	0.585938f,
+	0.9375f,
+	0.585938f,
+	0.945313f,
+	0.585938f,
+	0.953125f,
+	0.585938f,
+	0.960938f,
+	0.585938f,
+	0.96875f,
+	0.585938f,
+	0.976563f,
+	0.585938f,
+	0.984375f,
+	0.585938f,
+	0.992188f,
+	0.585938f,
+	1.0f,
+	0.585938f,
+	0.507813f,
+	0.59375f,
+	0.515625f,
+	0.59375f,
+	0.523438f,
+	0.59375f,
+	0.53125f,
+	0.59375f,
+	0.539063f,
+	0.59375f,
+	0.546875f,
+	0.59375f,
+	0.554688f,
+	0.59375f,
+	0.5625f,
+	0.59375f,
+	0.570313f,
+	0.59375f,
+	0.578125f,
+	0.59375f,
+	0.585938f,
+	0.59375f,
+	0.59375f,
+	0.59375f,
+	0.601563f,
+	0.59375f,
+	0.609375f,
+	0.59375f,
+	0.617188f,
+	0.59375f,
+	0.625f,
+	0.59375f,
+	0.632813f,
+	0.59375f,
+	0.640625f,
+	0.59375f,
+	0.648438f,
+	0.59375f,
+	0.65625f,
+	0.59375f,
+	0.664063f,
+	0.59375f,
+	0.671875f,
+	0.59375f,
+	0.679688f,
+	0.59375f,
+	0.6875f,
+	0.59375f,
+	0.695313f,
+	0.59375f,
+	0.703125f,
+	0.59375f,
+	0.710938f,
+	0.59375f,
+	0.71875f,
+	0.59375f,
+	0.726563f,
+	0.59375f,
+	0.734375f,
+	0.59375f,
+	0.742188f,
+	0.59375f,
+	0.75f,
+	0.59375f,
+	0.757813f,
+	0.59375f,
+	0.765625f,
+	0.59375f,
+	0.773438f,
+	0.59375f,
+	0.78125f,
+	0.59375f,
+	0.789063f,
+	0.59375f,
+	0.796875f,
+	0.59375f,
+	0.804688f,
+	0.59375f,
+	0.8125f,
+	0.59375f,
+	0.820313f,
+	0.59375f,
+	0.828125f,
+	0.59375f,
+	0.835938f,
+	0.59375f,
+	0.84375f,
+	0.59375f,
+	0.851563f,
+	0.59375f,
+	0.859375f,
+	0.59375f,
+	0.867188f,
+	0.59375f,
+	0.875f,
+	0.59375f,
+	0.882813f,
+	0.59375f,
+	0.890625f,
+	0.59375f,
+	0.898438f,
+	0.59375f,
+	0.90625f,
+	0.59375f,
+	0.914063f,
+	0.59375f,
+	0.921875f,
+	0.59375f,
+	0.929688f,
+	0.59375f,
+	0.9375f,
+	0.59375f,
+	0.945313f,
+	0.59375f,
+	0.953125f,
+	0.59375f,
+	0.960938f,
+	0.59375f,
+	0.96875f,
+	0.59375f,
+	0.976563f,
+	0.59375f,
+	0.984375f,
+	0.59375f,
+	0.992188f,
+	0.59375f,
+	1.0f,
+	0.59375f,
+	0.507813f,
+	0.601563f,
+	0.515625f,
+	0.601563f,
+	0.523438f,
+	0.601563f,
+	0.53125f,
+	0.601563f,
+	0.539063f,
+	0.601563f,
+	0.546875f,
+	0.601563f,
+	0.554688f,
+	0.601563f,
+	0.5625f,
+	0.601563f,
+	0.570313f,
+	0.601563f,
+	0.578125f,
+	0.601563f,
+	0.585938f,
+	0.601563f,
+	0.59375f,
+	0.601563f,
+	0.601563f,
+	0.601563f,
+	0.609375f,
+	0.601563f,
+	0.617188f,
+	0.601563f,
+	0.625f,
+	0.601563f,
+	0.632813f,
+	0.601563f,
+	0.640625f,
+	0.601563f,
+	0.648438f,
+	0.601563f,
+	0.65625f,
+	0.601563f,
+	0.664063f,
+	0.601563f,
+	0.671875f,
+	0.601563f,
+	0.679688f,
+	0.601563f,
+	0.6875f,
+	0.601563f,
+	0.695313f,
+	0.601563f,
+	0.703125f,
+	0.601563f,
+	0.710938f,
+	0.601563f,
+	0.71875f,
+	0.601563f,
+	0.726563f,
+	0.601563f,
+	0.734375f,
+	0.601563f,
+	0.742188f,
+	0.601563f,
+	0.75f,
+	0.601563f,
+	0.757813f,
+	0.601563f,
+	0.765625f,
+	0.601563f,
+	0.773438f,
+	0.601563f,
+	0.78125f,
+	0.601563f,
+	0.789063f,
+	0.601563f,
+	0.796875f,
+	0.601563f,
+	0.804688f,
+	0.601563f,
+	0.8125f,
+	0.601563f,
+	0.820313f,
+	0.601563f,
+	0.828125f,
+	0.601563f,
+	0.835938f,
+	0.601563f,
+	0.84375f,
+	0.601563f,
+	0.851563f,
+	0.601563f,
+	0.859375f,
+	0.601563f,
+	0.867188f,
+	0.601563f,
+	0.875f,
+	0.601563f,
+	0.882813f,
+	0.601563f,
+	0.890625f,
+	0.601563f,
+	0.898438f,
+	0.601563f,
+	0.90625f,
+	0.601563f,
+	0.914063f,
+	0.601563f,
+	0.921875f,
+	0.601563f,
+	0.929688f,
+	0.601563f,
+	0.9375f,
+	0.601563f,
+	0.945313f,
+	0.601563f,
+	0.953125f,
+	0.601563f,
+	0.960938f,
+	0.601563f,
+	0.96875f,
+	0.601563f,
+	0.976563f,
+	0.601563f,
+	0.984375f,
+	0.601563f,
+	0.992188f,
+	0.601563f,
+	1.0f,
+	0.601563f,
+	0.507813f,
+	0.609375f,
+	0.515625f,
+	0.609375f,
+	0.523438f,
+	0.609375f,
+	0.53125f,
+	0.609375f,
+	0.539063f,
+	0.609375f,
+	0.546875f,
+	0.609375f,
+	0.554688f,
+	0.609375f,
+	0.5625f,
+	0.609375f,
+	0.570313f,
+	0.609375f,
+	0.578125f,
+	0.609375f,
+	0.585938f,
+	0.609375f,
+	0.59375f,
+	0.609375f,
+	0.601563f,
+	0.609375f,
+	0.609375f,
+	0.609375f,
+	0.617188f,
+	0.609375f,
+	0.625f,
+	0.609375f,
+	0.632813f,
+	0.609375f,
+	0.640625f,
+	0.609375f,
+	0.648438f,
+	0.609375f,
+	0.65625f,
+	0.609375f,
+	0.664063f,
+	0.609375f,
+	0.671875f,
+	0.609375f,
+	0.679688f,
+	0.609375f,
+	0.6875f,
+	0.609375f,
+	0.695313f,
+	0.609375f,
+	0.703125f,
+	0.609375f,
+	0.710938f,
+	0.609375f,
+	0.71875f,
+	0.609375f,
+	0.726563f,
+	0.609375f,
+	0.734375f,
+	0.609375f,
+	0.742188f,
+	0.609375f,
+	0.75f,
+	0.609375f,
+	0.757813f,
+	0.609375f,
+	0.765625f,
+	0.609375f,
+	0.773438f,
+	0.609375f,
+	0.78125f,
+	0.609375f,
+	0.789063f,
+	0.609375f,
+	0.796875f,
+	0.609375f,
+	0.804688f,
+	0.609375f,
+	0.8125f,
+	0.609375f,
+	0.820313f,
+	0.609375f,
+	0.828125f,
+	0.609375f,
+	0.835938f,
+	0.609375f,
+	0.84375f,
+	0.609375f,
+	0.851563f,
+	0.609375f,
+	0.859375f,
+	0.609375f,
+	0.867188f,
+	0.609375f,
+	0.875f,
+	0.609375f,
+	0.882813f,
+	0.609375f,
+	0.890625f,
+	0.609375f,
+	0.898438f,
+	0.609375f,
+	0.90625f,
+	0.609375f,
+	0.914063f,
+	0.609375f,
+	0.921875f,
+	0.609375f,
+	0.929688f,
+	0.609375f,
+	0.9375f,
+	0.609375f,
+	0.945313f,
+	0.609375f,
+	0.953125f,
+	0.609375f,
+	0.960938f,
+	0.609375f,
+	0.96875f,
+	0.609375f,
+	0.976563f,
+	0.609375f,
+	0.984375f,
+	0.609375f,
+	0.992188f,
+	0.609375f,
+	1.0f,
+	0.609375f,
+	0.507813f,
+	0.617188f,
+	0.515625f,
+	0.617188f,
+	0.523438f,
+	0.617188f,
+	0.53125f,
+	0.617188f,
+	0.539063f,
+	0.617188f,
+	0.546875f,
+	0.617188f,
+	0.554688f,
+	0.617188f,
+	0.5625f,
+	0.617188f,
+	0.570313f,
+	0.617188f,
+	0.578125f,
+	0.617188f,
+	0.585938f,
+	0.617188f,
+	0.59375f,
+	0.617188f,
+	0.601563f,
+	0.617188f,
+	0.609375f,
+	0.617188f,
+	0.617188f,
+	0.617188f,
+	0.625f,
+	0.617188f,
+	0.632813f,
+	0.617188f,
+	0.640625f,
+	0.617188f,
+	0.648438f,
+	0.617188f,
+	0.65625f,
+	0.617188f,
+	0.664063f,
+	0.617188f,
+	0.671875f,
+	0.617188f,
+	0.679688f,
+	0.617188f,
+	0.6875f,
+	0.617188f,
+	0.695313f,
+	0.617188f,
+	0.703125f,
+	0.617188f,
+	0.710938f,
+	0.617188f,
+	0.71875f,
+	0.617188f,
+	0.726563f,
+	0.617188f,
+	0.734375f,
+	0.617188f,
+	0.742188f,
+	0.617188f,
+	0.75f,
+	0.617188f,
+	0.757813f,
+	0.617188f,
+	0.765625f,
+	0.617188f,
+	0.773438f,
+	0.617188f,
+	0.78125f,
+	0.617188f,
+	0.789063f,
+	0.617188f,
+	0.796875f,
+	0.617188f,
+	0.804688f,
+	0.617188f,
+	0.8125f,
+	0.617188f,
+	0.820313f,
+	0.617188f,
+	0.828125f,
+	0.617188f,
+	0.835938f,
+	0.617188f,
+	0.84375f,
+	0.617188f,
+	0.851563f,
+	0.617188f,
+	0.859375f,
+	0.617188f,
+	0.867188f,
+	0.617188f,
+	0.875f,
+	0.617188f,
+	0.882813f,
+	0.617188f,
+	0.890625f,
+	0.617188f,
+	0.898438f,
+	0.617188f,
+	0.90625f,
+	0.617188f,
+	0.914063f,
+	0.617188f,
+	0.921875f,
+	0.617188f,
+	0.929688f,
+	0.617188f,
+	0.9375f,
+	0.617188f,
+	0.945313f,
+	0.617188f,
+	0.953125f,
+	0.617188f,
+	0.960938f,
+	0.617188f,
+	0.96875f,
+	0.617188f,
+	0.976563f,
+	0.617188f,
+	0.984375f,
+	0.617188f,
+	0.992188f,
+	0.617188f,
+	1.0f,
+	0.617188f,
+	0.507813f,
+	0.625f,
+	0.515625f,
+	0.625f,
+	0.523438f,
+	0.625f,
+	0.53125f,
+	0.625f,
+	0.539063f,
+	0.625f,
+	0.546875f,
+	0.625f,
+	0.554688f,
+	0.625f,
+	0.5625f,
+	0.625f,
+	0.570313f,
+	0.625f,
+	0.578125f,
+	0.625f,
+	0.585938f,
+	0.625f,
+	0.59375f,
+	0.625f,
+	0.601563f,
+	0.625f,
+	0.609375f,
+	0.625f,
+	0.617188f,
+	0.625f,
+	0.625f,
+	0.625f,
+	0.632813f,
+	0.625f,
+	0.640625f,
+	0.625f,
+	0.648438f,
+	0.625f,
+	0.65625f,
+	0.625f,
+	0.664063f,
+	0.625f,
+	0.671875f,
+	0.625f,
+	0.679688f,
+	0.625f,
+	0.6875f,
+	0.625f,
+	0.695313f,
+	0.625f,
+	0.703125f,
+	0.625f,
+	0.710938f,
+	0.625f,
+	0.71875f,
+	0.625f,
+	0.726563f,
+	0.625f,
+	0.734375f,
+	0.625f,
+	0.742188f,
+	0.625f,
+	0.75f,
+	0.625f,
+	0.757813f,
+	0.625f,
+	0.765625f,
+	0.625f,
+	0.773438f,
+	0.625f,
+	0.78125f,
+	0.625f,
+	0.789063f,
+	0.625f,
+	0.796875f,
+	0.625f,
+	0.804688f,
+	0.625f,
+	0.8125f,
+	0.625f,
+	0.820313f,
+	0.625f,
+	0.828125f,
+	0.625f,
+	0.835938f,
+	0.625f,
+	0.84375f,
+	0.625f,
+	0.851563f,
+	0.625f,
+	0.859375f,
+	0.625f,
+	0.867188f,
+	0.625f,
+	0.875f,
+	0.625f,
+	0.882813f,
+	0.625f,
+	0.890625f,
+	0.625f,
+	0.898438f,
+	0.625f,
+	0.90625f,
+	0.625f,
+	0.914063f,
+	0.625f,
+	0.921875f,
+	0.625f,
+	0.929688f,
+	0.625f,
+	0.9375f,
+	0.625f,
+	0.945313f,
+	0.625f,
+	0.953125f,
+	0.625f,
+	0.960938f,
+	0.625f,
+	0.96875f,
+	0.625f,
+	0.976563f,
+	0.625f,
+	0.984375f,
+	0.625f,
+	0.992188f,
+	0.625f,
+	1.0f,
+	0.625f,
+	0.507813f,
+	0.632813f,
+	0.515625f,
+	0.632813f,
+	0.523438f,
+	0.632813f,
+	0.53125f,
+	0.632813f,
+	0.539063f,
+	0.632813f,
+	0.546875f,
+	0.632813f,
+	0.554688f,
+	0.632813f,
+	0.5625f,
+	0.632813f,
+	0.570313f,
+	0.632813f,
+	0.578125f,
+	0.632813f,
+	0.585938f,
+	0.632813f,
+	0.59375f,
+	0.632813f,
+	0.601563f,
+	0.632813f,
+	0.609375f,
+	0.632813f,
+	0.617188f,
+	0.632813f,
+	0.625f,
+	0.632813f,
+	0.632813f,
+	0.632813f,
+	0.640625f,
+	0.632813f,
+	0.648438f,
+	0.632813f,
+	0.65625f,
+	0.632813f,
+	0.664063f,
+	0.632813f,
+	0.671875f,
+	0.632813f,
+	0.679688f,
+	0.632813f,
+	0.6875f,
+	0.632813f,
+	0.695313f,
+	0.632813f,
+	0.703125f,
+	0.632813f,
+	0.710938f,
+	0.632813f,
+	0.71875f,
+	0.632813f,
+	0.726563f,
+	0.632813f,
+	0.734375f,
+	0.632813f,
+	0.742188f,
+	0.632813f,
+	0.75f,
+	0.632813f,
+	0.757813f,
+	0.632813f,
+	0.765625f,
+	0.632813f,
+	0.773438f,
+	0.632813f,
+	0.78125f,
+	0.632813f,
+	0.789063f,
+	0.632813f,
+	0.796875f,
+	0.632813f,
+	0.804688f,
+	0.632813f,
+	0.8125f,
+	0.632813f,
+	0.820313f,
+	0.632813f,
+	0.828125f,
+	0.632813f,
+	0.835938f,
+	0.632813f,
+	0.84375f,
+	0.632813f,
+	0.851563f,
+	0.632813f,
+	0.859375f,
+	0.632813f,
+	0.867188f,
+	0.632813f,
+	0.875f,
+	0.632813f,
+	0.882813f,
+	0.632813f,
+	0.890625f,
+	0.632813f,
+	0.898438f,
+	0.632813f,
+	0.90625f,
+	0.632813f,
+	0.914063f,
+	0.632813f,
+	0.921875f,
+	0.632813f,
+	0.929688f,
+	0.632813f,
+	0.9375f,
+	0.632813f,
+	0.945313f,
+	0.632813f,
+	0.953125f,
+	0.632813f,
+	0.960938f,
+	0.632813f,
+	0.96875f,
+	0.632813f,
+	0.976563f,
+	0.632813f,
+	0.984375f,
+	0.632813f,
+	0.992188f,
+	0.632813f,
+	1.0f,
+	0.632813f,
+	0.507813f,
+	0.640625f,
+	0.515625f,
+	0.640625f,
+	0.523438f,
+	0.640625f,
+	0.53125f,
+	0.640625f,
+	0.539063f,
+	0.640625f,
+	0.546875f,
+	0.640625f,
+	0.554688f,
+	0.640625f,
+	0.5625f,
+	0.640625f,
+	0.570313f,
+	0.640625f,
+	0.578125f,
+	0.640625f,
+	0.585938f,
+	0.640625f,
+	0.59375f,
+	0.640625f,
+	0.601563f,
+	0.640625f,
+	0.609375f,
+	0.640625f,
+	0.617188f,
+	0.640625f,
+	0.625f,
+	0.640625f,
+	0.632813f,
+	0.640625f,
+	0.640625f,
+	0.640625f,
+	0.648438f,
+	0.640625f,
+	0.65625f,
+	0.640625f,
+	0.664063f,
+	0.640625f,
+	0.671875f,
+	0.640625f,
+	0.679688f,
+	0.640625f,
+	0.6875f,
+	0.640625f,
+	0.695313f,
+	0.640625f,
+	0.703125f,
+	0.640625f,
+	0.710938f,
+	0.640625f,
+	0.71875f,
+	0.640625f,
+	0.726563f,
+	0.640625f,
+	0.734375f,
+	0.640625f,
+	0.742188f,
+	0.640625f,
+	0.75f,
+	0.640625f,
+	0.757813f,
+	0.640625f,
+	0.765625f,
+	0.640625f,
+	0.773438f,
+	0.640625f,
+	0.78125f,
+	0.640625f,
+	0.789063f,
+	0.640625f,
+	0.796875f,
+	0.640625f,
+	0.804688f,
+	0.640625f,
+	0.8125f,
+	0.640625f,
+	0.820313f,
+	0.640625f,
+	0.828125f,
+	0.640625f,
+	0.835938f,
+	0.640625f,
+	0.84375f,
+	0.640625f,
+	0.851563f,
+	0.640625f,
+	0.859375f,
+	0.640625f,
+	0.867188f,
+	0.640625f,
+	0.875f,
+	0.640625f,
+	0.882813f,
+	0.640625f,
+	0.890625f,
+	0.640625f,
+	0.898438f,
+	0.640625f,
+	0.90625f,
+	0.640625f,
+	0.914063f,
+	0.640625f,
+	0.921875f,
+	0.640625f,
+	0.929688f,
+	0.640625f,
+	0.9375f,
+	0.640625f,
+	0.945313f,
+	0.640625f,
+	0.953125f,
+	0.640625f,
+	0.960938f,
+	0.640625f,
+	0.96875f,
+	0.640625f,
+	0.976563f,
+	0.640625f,
+	0.984375f,
+	0.640625f,
+	0.992188f,
+	0.640625f,
+	1.0f,
+	0.640625f,
+	0.507813f,
+	0.648438f,
+	0.515625f,
+	0.648438f,
+	0.523438f,
+	0.648438f,
+	0.53125f,
+	0.648438f,
+	0.539063f,
+	0.648438f,
+	0.546875f,
+	0.648438f,
+	0.554688f,
+	0.648438f,
+	0.5625f,
+	0.648438f,
+	0.570313f,
+	0.648438f,
+	0.578125f,
+	0.648438f,
+	0.585938f,
+	0.648438f,
+	0.59375f,
+	0.648438f,
+	0.601563f,
+	0.648438f,
+	0.609375f,
+	0.648438f,
+	0.617188f,
+	0.648438f,
+	0.625f,
+	0.648438f,
+	0.632813f,
+	0.648438f,
+	0.640625f,
+	0.648438f,
+	0.648438f,
+	0.648438f,
+	0.65625f,
+	0.648438f,
+	0.664063f,
+	0.648438f,
+	0.671875f,
+	0.648438f,
+	0.679688f,
+	0.648438f,
+	0.6875f,
+	0.648438f,
+	0.695313f,
+	0.648438f,
+	0.703125f,
+	0.648438f,
+	0.710938f,
+	0.648438f,
+	0.71875f,
+	0.648438f,
+	0.726563f,
+	0.648438f,
+	0.734375f,
+	0.648438f,
+	0.742188f,
+	0.648438f,
+	0.75f,
+	0.648438f,
+	0.757813f,
+	0.648438f,
+	0.765625f,
+	0.648438f,
+	0.773438f,
+	0.648438f,
+	0.78125f,
+	0.648438f,
+	0.789063f,
+	0.648438f,
+	0.796875f,
+	0.648438f,
+	0.804688f,
+	0.648438f,
+	0.8125f,
+	0.648438f,
+	0.820313f,
+	0.648438f,
+	0.828125f,
+	0.648438f,
+	0.835938f,
+	0.648438f,
+	0.84375f,
+	0.648438f,
+	0.851563f,
+	0.648438f,
+	0.859375f,
+	0.648438f,
+	0.867188f,
+	0.648438f,
+	0.875f,
+	0.648438f,
+	0.882813f,
+	0.648438f,
+	0.890625f,
+	0.648438f,
+	0.898438f,
+	0.648438f,
+	0.90625f,
+	0.648438f,
+	0.914063f,
+	0.648438f,
+	0.921875f,
+	0.648438f,
+	0.929688f,
+	0.648438f,
+	0.9375f,
+	0.648438f,
+	0.945313f,
+	0.648438f,
+	0.953125f,
+	0.648438f,
+	0.960938f,
+	0.648438f,
+	0.96875f,
+	0.648438f,
+	0.976563f,
+	0.648438f,
+	0.984375f,
+	0.648438f,
+	0.992188f,
+	0.648438f,
+	1.0f,
+	0.648438f,
+	0.507813f,
+	0.65625f,
+	0.515625f,
+	0.65625f,
+	0.523438f,
+	0.65625f,
+	0.53125f,
+	0.65625f,
+	0.539063f,
+	0.65625f,
+	0.546875f,
+	0.65625f,
+	0.554688f,
+	0.65625f,
+	0.5625f,
+	0.65625f,
+	0.570313f,
+	0.65625f,
+	0.578125f,
+	0.65625f,
+	0.585938f,
+	0.65625f,
+	0.59375f,
+	0.65625f,
+	0.601563f,
+	0.65625f,
+	0.609375f,
+	0.65625f,
+	0.617188f,
+	0.65625f,
+	0.625f,
+	0.65625f,
+	0.632813f,
+	0.65625f,
+	0.640625f,
+	0.65625f,
+	0.648438f,
+	0.65625f,
+	0.65625f,
+	0.65625f,
+	0.664063f,
+	0.65625f,
+	0.671875f,
+	0.65625f,
+	0.679688f,
+	0.65625f,
+	0.6875f,
+	0.65625f,
+	0.695313f,
+	0.65625f,
+	0.703125f,
+	0.65625f,
+	0.710938f,
+	0.65625f,
+	0.71875f,
+	0.65625f,
+	0.726563f,
+	0.65625f,
+	0.734375f,
+	0.65625f,
+	0.742188f,
+	0.65625f,
+	0.75f,
+	0.65625f,
+	0.757813f,
+	0.65625f,
+	0.765625f,
+	0.65625f,
+	0.773438f,
+	0.65625f,
+	0.78125f,
+	0.65625f,
+	0.789063f,
+	0.65625f,
+	0.796875f,
+	0.65625f,
+	0.804688f,
+	0.65625f,
+	0.8125f,
+	0.65625f,
+	0.820313f,
+	0.65625f,
+	0.828125f,
+	0.65625f,
+	0.835938f,
+	0.65625f,
+	0.84375f,
+	0.65625f,
+	0.851563f,
+	0.65625f,
+	0.859375f,
+	0.65625f,
+	0.867188f,
+	0.65625f,
+	0.875f,
+	0.65625f,
+	0.882813f,
+	0.65625f,
+	0.890625f,
+	0.65625f,
+	0.898438f,
+	0.65625f,
+	0.90625f,
+	0.65625f,
+	0.914063f,
+	0.65625f,
+	0.921875f,
+	0.65625f,
+	0.929688f,
+	0.65625f,
+	0.9375f,
+	0.65625f,
+	0.945313f,
+	0.65625f,
+	0.953125f,
+	0.65625f,
+	0.960938f,
+	0.65625f,
+	0.96875f,
+	0.65625f,
+	0.976563f,
+	0.65625f,
+	0.984375f,
+	0.65625f,
+	0.992188f,
+	0.65625f,
+	1.0f,
+	0.65625f,
+	0.507813f,
+	0.664063f,
+	0.515625f,
+	0.664063f,
+	0.523438f,
+	0.664063f,
+	0.53125f,
+	0.664063f,
+	0.539063f,
+	0.664063f,
+	0.546875f,
+	0.664063f,
+	0.554688f,
+	0.664063f,
+	0.5625f,
+	0.664063f,
+	0.570313f,
+	0.664063f,
+	0.578125f,
+	0.664063f,
+	0.585938f,
+	0.664063f,
+	0.59375f,
+	0.664063f,
+	0.601563f,
+	0.664063f,
+	0.609375f,
+	0.664063f,
+	0.617188f,
+	0.664063f,
+	0.625f,
+	0.664063f,
+	0.632813f,
+	0.664063f,
+	0.640625f,
+	0.664063f,
+	0.648438f,
+	0.664063f,
+	0.65625f,
+	0.664063f,
+	0.664063f,
+	0.664063f,
+	0.671875f,
+	0.664063f,
+	0.679688f,
+	0.664063f,
+	0.6875f,
+	0.664063f,
+	0.695313f,
+	0.664063f,
+	0.703125f,
+	0.664063f,
+	0.710938f,
+	0.664063f,
+	0.71875f,
+	0.664063f,
+	0.726563f,
+	0.664063f,
+	0.734375f,
+	0.664063f,
+	0.742188f,
+	0.664063f,
+	0.75f,
+	0.664063f,
+	0.757813f,
+	0.664063f,
+	0.765625f,
+	0.664063f,
+	0.773438f,
+	0.664063f,
+	0.78125f,
+	0.664063f,
+	0.789063f,
+	0.664063f,
+	0.796875f,
+	0.664063f,
+	0.804688f,
+	0.664063f,
+	0.8125f,
+	0.664063f,
+	0.820313f,
+	0.664063f,
+	0.828125f,
+	0.664063f,
+	0.835938f,
+	0.664063f,
+	0.84375f,
+	0.664063f,
+	0.851563f,
+	0.664063f,
+	0.859375f,
+	0.664063f,
+	0.867188f,
+	0.664063f,
+	0.875f,
+	0.664063f,
+	0.882813f,
+	0.664063f,
+	0.890625f,
+	0.664063f,
+	0.898438f,
+	0.664063f,
+	0.90625f,
+	0.664063f,
+	0.914063f,
+	0.664063f,
+	0.921875f,
+	0.664063f,
+	0.929688f,
+	0.664063f,
+	0.9375f,
+	0.664063f,
+	0.945313f,
+	0.664063f,
+	0.953125f,
+	0.664063f,
+	0.960938f,
+	0.664063f,
+	0.96875f,
+	0.664063f,
+	0.976563f,
+	0.664063f,
+	0.984375f,
+	0.664063f,
+	0.992188f,
+	0.664063f,
+	1.0f,
+	0.664063f,
+	0.507813f,
+	0.671875f,
+	0.515625f,
+	0.671875f,
+	0.523438f,
+	0.671875f,
+	0.53125f,
+	0.671875f,
+	0.539063f,
+	0.671875f,
+	0.546875f,
+	0.671875f,
+	0.554688f,
+	0.671875f,
+	0.5625f,
+	0.671875f,
+	0.570313f,
+	0.671875f,
+	0.578125f,
+	0.671875f,
+	0.585938f,
+	0.671875f,
+	0.59375f,
+	0.671875f,
+	0.601563f,
+	0.671875f,
+	0.609375f,
+	0.671875f,
+	0.617188f,
+	0.671875f,
+	0.625f,
+	0.671875f,
+	0.632813f,
+	0.671875f,
+	0.640625f,
+	0.671875f,
+	0.648438f,
+	0.671875f,
+	0.65625f,
+	0.671875f,
+	0.664063f,
+	0.671875f,
+	0.671875f,
+	0.671875f,
+	0.679688f,
+	0.671875f,
+	0.6875f,
+	0.671875f,
+	0.695313f,
+	0.671875f,
+	0.703125f,
+	0.671875f,
+	0.710938f,
+	0.671875f,
+	0.71875f,
+	0.671875f,
+	0.726563f,
+	0.671875f,
+	0.734375f,
+	0.671875f,
+	0.742188f,
+	0.671875f,
+	0.75f,
+	0.671875f,
+	0.757813f,
+	0.671875f,
+	0.765625f,
+	0.671875f,
+	0.773438f,
+	0.671875f,
+	0.78125f,
+	0.671875f,
+	0.789063f,
+	0.671875f,
+	0.796875f,
+	0.671875f,
+	0.804688f,
+	0.671875f,
+	0.8125f,
+	0.671875f,
+	0.820313f,
+	0.671875f,
+	0.828125f,
+	0.671875f,
+	0.835938f,
+	0.671875f,
+	0.84375f,
+	0.671875f,
+	0.851563f,
+	0.671875f,
+	0.859375f,
+	0.671875f,
+	0.867188f,
+	0.671875f,
+	0.875f,
+	0.671875f,
+	0.882813f,
+	0.671875f,
+	0.890625f,
+	0.671875f,
+	0.898438f,
+	0.671875f,
+	0.90625f,
+	0.671875f,
+	0.914063f,
+	0.671875f,
+	0.921875f,
+	0.671875f,
+	0.929688f,
+	0.671875f,
+	0.9375f,
+	0.671875f,
+	0.945313f,
+	0.671875f,
+	0.953125f,
+	0.671875f,
+	0.960938f,
+	0.671875f,
+	0.96875f,
+	0.671875f,
+	0.976563f,
+	0.671875f,
+	0.984375f,
+	0.671875f,
+	0.992188f,
+	0.671875f,
+	1.0f,
+	0.671875f,
+	0.507813f,
+	0.679688f,
+	0.515625f,
+	0.679688f,
+	0.523438f,
+	0.679688f,
+	0.53125f,
+	0.679688f,
+	0.539063f,
+	0.679688f,
+	0.546875f,
+	0.679688f,
+	0.554688f,
+	0.679688f,
+	0.5625f,
+	0.679688f,
+	0.570313f,
+	0.679688f,
+	0.578125f,
+	0.679688f,
+	0.585938f,
+	0.679688f,
+	0.59375f,
+	0.679688f,
+	0.601563f,
+	0.679688f,
+	0.609375f,
+	0.679688f,
+	0.617188f,
+	0.679688f,
+	0.625f,
+	0.679688f,
+	0.632813f,
+	0.679688f,
+	0.640625f,
+	0.679688f,
+	0.648438f,
+	0.679688f,
+	0.65625f,
+	0.679688f,
+	0.664063f,
+	0.679688f,
+	0.671875f,
+	0.679688f,
+	0.679688f,
+	0.679688f,
+	0.6875f,
+	0.679688f,
+	0.695313f,
+	0.679688f,
+	0.703125f,
+	0.679688f,
+	0.710938f,
+	0.679688f,
+	0.71875f,
+	0.679688f,
+	0.726563f,
+	0.679688f,
+	0.734375f,
+	0.679688f,
+	0.742188f,
+	0.679688f,
+	0.75f,
+	0.679688f,
+	0.757813f,
+	0.679688f,
+	0.765625f,
+	0.679688f,
+	0.773438f,
+	0.679688f,
+	0.78125f,
+	0.679688f,
+	0.789063f,
+	0.679688f,
+	0.796875f,
+	0.679688f,
+	0.804688f,
+	0.679688f,
+	0.8125f,
+	0.679688f,
+	0.820313f,
+	0.679688f,
+	0.828125f,
+	0.679688f,
+	0.835938f,
+	0.679688f,
+	0.84375f,
+	0.679688f,
+	0.851563f,
+	0.679688f,
+	0.859375f,
+	0.679688f,
+	0.867188f,
+	0.679688f,
+	0.875f,
+	0.679688f,
+	0.882813f,
+	0.679688f,
+	0.890625f,
+	0.679688f,
+	0.898438f,
+	0.679688f,
+	0.90625f,
+	0.679688f,
+	0.914063f,
+	0.679688f,
+	0.921875f,
+	0.679688f,
+	0.929688f,
+	0.679688f,
+	0.9375f,
+	0.679688f,
+	0.945313f,
+	0.679688f,
+	0.953125f,
+	0.679688f,
+	0.960938f,
+	0.679688f,
+	0.96875f,
+	0.679688f,
+	0.976563f,
+	0.679688f,
+	0.984375f,
+	0.679688f,
+	0.992188f,
+	0.679688f,
+	1.0f,
+	0.679688f,
+	0.507813f,
+	0.6875f,
+	0.515625f,
+	0.6875f,
+	0.523438f,
+	0.6875f,
+	0.53125f,
+	0.6875f,
+	0.539063f,
+	0.6875f,
+	0.546875f,
+	0.6875f,
+	0.554688f,
+	0.6875f,
+	0.5625f,
+	0.6875f,
+	0.570313f,
+	0.6875f,
+	0.578125f,
+	0.6875f,
+	0.585938f,
+	0.6875f,
+	0.59375f,
+	0.6875f,
+	0.601563f,
+	0.6875f,
+	0.609375f,
+	0.6875f,
+	0.617188f,
+	0.6875f,
+	0.625f,
+	0.6875f,
+	0.632813f,
+	0.6875f,
+	0.640625f,
+	0.6875f,
+	0.648438f,
+	0.6875f,
+	0.65625f,
+	0.6875f,
+	0.664063f,
+	0.6875f,
+	0.671875f,
+	0.6875f,
+	0.679688f,
+	0.6875f,
+	0.6875f,
+	0.6875f,
+	0.695313f,
+	0.6875f,
+	0.703125f,
+	0.6875f,
+	0.710938f,
+	0.6875f,
+	0.71875f,
+	0.6875f,
+	0.726563f,
+	0.6875f,
+	0.734375f,
+	0.6875f,
+	0.742188f,
+	0.6875f,
+	0.75f,
+	0.6875f,
+	0.757813f,
+	0.6875f,
+	0.765625f,
+	0.6875f,
+	0.773438f,
+	0.6875f,
+	0.78125f,
+	0.6875f,
+	0.789063f,
+	0.6875f,
+	0.796875f,
+	0.6875f,
+	0.804688f,
+	0.6875f,
+	0.8125f,
+	0.6875f,
+	0.820313f,
+	0.6875f,
+	0.828125f,
+	0.6875f,
+	0.835938f,
+	0.6875f,
+	0.84375f,
+	0.6875f,
+	0.851563f,
+	0.6875f,
+	0.859375f,
+	0.6875f,
+	0.867188f,
+	0.6875f,
+	0.875f,
+	0.6875f,
+	0.882813f,
+	0.6875f,
+	0.890625f,
+	0.6875f,
+	0.898438f,
+	0.6875f,
+	0.90625f,
+	0.6875f,
+	0.914063f,
+	0.6875f,
+	0.921875f,
+	0.6875f,
+	0.929688f,
+	0.6875f,
+	0.9375f,
+	0.6875f,
+	0.945313f,
+	0.6875f,
+	0.953125f,
+	0.6875f,
+	0.960938f,
+	0.6875f,
+	0.96875f,
+	0.6875f,
+	0.976563f,
+	0.6875f,
+	0.984375f,
+	0.6875f,
+	0.992188f,
+	0.6875f,
+	1.0f,
+	0.6875f,
+	0.507813f,
+	0.695313f,
+	0.515625f,
+	0.695313f,
+	0.523438f,
+	0.695313f,
+	0.53125f,
+	0.695313f,
+	0.539063f,
+	0.695313f,
+	0.546875f,
+	0.695313f,
+	0.554688f,
+	0.695313f,
+	0.5625f,
+	0.695313f,
+	0.570313f,
+	0.695313f,
+	0.578125f,
+	0.695313f,
+	0.585938f,
+	0.695313f,
+	0.59375f,
+	0.695313f,
+	0.601563f,
+	0.695313f,
+	0.609375f,
+	0.695313f,
+	0.617188f,
+	0.695313f,
+	0.625f,
+	0.695313f,
+	0.632813f,
+	0.695313f,
+	0.640625f,
+	0.695313f,
+	0.648438f,
+	0.695313f,
+	0.65625f,
+	0.695313f,
+	0.664063f,
+	0.695313f,
+	0.671875f,
+	0.695313f,
+	0.679688f,
+	0.695313f,
+	0.6875f,
+	0.695313f,
+	0.695313f,
+	0.695313f,
+	0.703125f,
+	0.695313f,
+	0.710938f,
+	0.695313f,
+	0.71875f,
+	0.695313f,
+	0.726563f,
+	0.695313f,
+	0.734375f,
+	0.695313f,
+	0.742188f,
+	0.695313f,
+	0.75f,
+	0.695313f,
+	0.757813f,
+	0.695313f,
+	0.765625f,
+	0.695313f,
+	0.773438f,
+	0.695313f,
+	0.78125f,
+	0.695313f,
+	0.789063f,
+	0.695313f,
+	0.796875f,
+	0.695313f,
+	0.804688f,
+	0.695313f,
+	0.8125f,
+	0.695313f,
+	0.820313f,
+	0.695313f,
+	0.828125f,
+	0.695313f,
+	0.835938f,
+	0.695313f,
+	0.84375f,
+	0.695313f,
+	0.851563f,
+	0.695313f,
+	0.859375f,
+	0.695313f,
+	0.867188f,
+	0.695313f,
+	0.875f,
+	0.695313f,
+	0.882813f,
+	0.695313f,
+	0.890625f,
+	0.695313f,
+	0.898438f,
+	0.695313f,
+	0.90625f,
+	0.695313f,
+	0.914063f,
+	0.695313f,
+	0.921875f,
+	0.695313f,
+	0.929688f,
+	0.695313f,
+	0.9375f,
+	0.695313f,
+	0.945313f,
+	0.695313f,
+	0.953125f,
+	0.695313f,
+	0.960938f,
+	0.695313f,
+	0.96875f,
+	0.695313f,
+	0.976563f,
+	0.695313f,
+	0.984375f,
+	0.695313f,
+	0.992188f,
+	0.695313f,
+	1.0f,
+	0.695313f,
+	0.507813f,
+	0.703125f,
+	0.515625f,
+	0.703125f,
+	0.523438f,
+	0.703125f,
+	0.53125f,
+	0.703125f,
+	0.539063f,
+	0.703125f,
+	0.546875f,
+	0.703125f,
+	0.554688f,
+	0.703125f,
+	0.5625f,
+	0.703125f,
+	0.570313f,
+	0.703125f,
+	0.578125f,
+	0.703125f,
+	0.585938f,
+	0.703125f,
+	0.59375f,
+	0.703125f,
+	0.601563f,
+	0.703125f,
+	0.609375f,
+	0.703125f,
+	0.617188f,
+	0.703125f,
+	0.625f,
+	0.703125f,
+	0.632813f,
+	0.703125f,
+	0.640625f,
+	0.703125f,
+	0.648438f,
+	0.703125f,
+	0.65625f,
+	0.703125f,
+	0.664063f,
+	0.703125f,
+	0.671875f,
+	0.703125f,
+	0.679688f,
+	0.703125f,
+	0.6875f,
+	0.703125f,
+	0.695313f,
+	0.703125f,
+	0.703125f,
+	0.703125f,
+	0.710938f,
+	0.703125f,
+	0.71875f,
+	0.703125f,
+	0.726563f,
+	0.703125f,
+	0.734375f,
+	0.703125f,
+	0.742188f,
+	0.703125f,
+	0.75f,
+	0.703125f,
+	0.757813f,
+	0.703125f,
+	0.765625f,
+	0.703125f,
+	0.773438f,
+	0.703125f,
+	0.78125f,
+	0.703125f,
+	0.789063f,
+	0.703125f,
+	0.796875f,
+	0.703125f,
+	0.804688f,
+	0.703125f,
+	0.8125f,
+	0.703125f,
+	0.820313f,
+	0.703125f,
+	0.828125f,
+	0.703125f,
+	0.835938f,
+	0.703125f,
+	0.84375f,
+	0.703125f,
+	0.851563f,
+	0.703125f,
+	0.859375f,
+	0.703125f,
+	0.867188f,
+	0.703125f,
+	0.875f,
+	0.703125f,
+	0.882813f,
+	0.703125f,
+	0.890625f,
+	0.703125f,
+	0.898438f,
+	0.703125f,
+	0.90625f,
+	0.703125f,
+	0.914063f,
+	0.703125f,
+	0.921875f,
+	0.703125f,
+	0.929688f,
+	0.703125f,
+	0.9375f,
+	0.703125f,
+	0.945313f,
+	0.703125f,
+	0.953125f,
+	0.703125f,
+	0.960938f,
+	0.703125f,
+	0.96875f,
+	0.703125f,
+	0.976563f,
+	0.703125f,
+	0.984375f,
+	0.703125f,
+	0.992188f,
+	0.703125f,
+	1.0f,
+	0.703125f,
+	0.507813f,
+	0.710938f,
+	0.515625f,
+	0.710938f,
+	0.523438f,
+	0.710938f,
+	0.53125f,
+	0.710938f,
+	0.539063f,
+	0.710938f,
+	0.546875f,
+	0.710938f,
+	0.554688f,
+	0.710938f,
+	0.5625f,
+	0.710938f,
+	0.570313f,
+	0.710938f,
+	0.578125f,
+	0.710938f,
+	0.585938f,
+	0.710938f,
+	0.59375f,
+	0.710938f,
+	0.601563f,
+	0.710938f,
+	0.609375f,
+	0.710938f,
+	0.617188f,
+	0.710938f,
+	0.625f,
+	0.710938f,
+	0.632813f,
+	0.710938f,
+	0.640625f,
+	0.710938f,
+	0.648438f,
+	0.710938f,
+	0.65625f,
+	0.710938f,
+	0.664063f,
+	0.710938f,
+	0.671875f,
+	0.710938f,
+	0.679688f,
+	0.710938f,
+	0.6875f,
+	0.710938f,
+	0.695313f,
+	0.710938f,
+	0.703125f,
+	0.710938f,
+	0.710938f,
+	0.710938f,
+	0.71875f,
+	0.710938f,
+	0.726563f,
+	0.710938f,
+	0.734375f,
+	0.710938f,
+	0.742188f,
+	0.710938f,
+	0.75f,
+	0.710938f,
+	0.757813f,
+	0.710938f,
+	0.765625f,
+	0.710938f,
+	0.773438f,
+	0.710938f,
+	0.78125f,
+	0.710938f,
+	0.789063f,
+	0.710938f,
+	0.796875f,
+	0.710938f,
+	0.804688f,
+	0.710938f,
+	0.8125f,
+	0.710938f,
+	0.820313f,
+	0.710938f,
+	0.828125f,
+	0.710938f,
+	0.835938f,
+	0.710938f,
+	0.84375f,
+	0.710938f,
+	0.851563f,
+	0.710938f,
+	0.859375f,
+	0.710938f,
+	0.867188f,
+	0.710938f,
+	0.875f,
+	0.710938f,
+	0.882813f,
+	0.710938f,
+	0.890625f,
+	0.710938f,
+	0.898438f,
+	0.710938f,
+	0.90625f,
+	0.710938f,
+	0.914063f,
+	0.710938f,
+	0.921875f,
+	0.710938f,
+	0.929688f,
+	0.710938f,
+	0.9375f,
+	0.710938f,
+	0.945313f,
+	0.710938f,
+	0.953125f,
+	0.710938f,
+	0.960938f,
+	0.710938f,
+	0.96875f,
+	0.710938f,
+	0.976563f,
+	0.710938f,
+	0.984375f,
+	0.710938f,
+	0.992188f,
+	0.710938f,
+	1.0f,
+	0.710938f,
+	0.507813f,
+	0.71875f,
+	0.515625f,
+	0.71875f,
+	0.523438f,
+	0.71875f,
+	0.53125f,
+	0.71875f,
+	0.539063f,
+	0.71875f,
+	0.546875f,
+	0.71875f,
+	0.554688f,
+	0.71875f,
+	0.5625f,
+	0.71875f,
+	0.570313f,
+	0.71875f,
+	0.578125f,
+	0.71875f,
+	0.585938f,
+	0.71875f,
+	0.59375f,
+	0.71875f,
+	0.601563f,
+	0.71875f,
+	0.609375f,
+	0.71875f,
+	0.617188f,
+	0.71875f,
+	0.625f,
+	0.71875f,
+	0.632813f,
+	0.71875f,
+	0.640625f,
+	0.71875f,
+	0.648438f,
+	0.71875f,
+	0.65625f,
+	0.71875f,
+	0.664063f,
+	0.71875f,
+	0.671875f,
+	0.71875f,
+	0.679688f,
+	0.71875f,
+	0.6875f,
+	0.71875f,
+	0.695313f,
+	0.71875f,
+	0.703125f,
+	0.71875f,
+	0.710938f,
+	0.71875f,
+	0.71875f,
+	0.71875f,
+	0.726563f,
+	0.71875f,
+	0.734375f,
+	0.71875f,
+	0.742188f,
+	0.71875f,
+	0.75f,
+	0.71875f,
+	0.757813f,
+	0.71875f,
+	0.765625f,
+	0.71875f,
+	0.773438f,
+	0.71875f,
+	0.78125f,
+	0.71875f,
+	0.789063f,
+	0.71875f,
+	0.796875f,
+	0.71875f,
+	0.804688f,
+	0.71875f,
+	0.8125f,
+	0.71875f,
+	0.820313f,
+	0.71875f,
+	0.828125f,
+	0.71875f,
+	0.835938f,
+	0.71875f,
+	0.84375f,
+	0.71875f,
+	0.851563f,
+	0.71875f,
+	0.859375f,
+	0.71875f,
+	0.867188f,
+	0.71875f,
+	0.875f,
+	0.71875f,
+	0.882813f,
+	0.71875f,
+	0.890625f,
+	0.71875f,
+	0.898438f,
+	0.71875f,
+	0.90625f,
+	0.71875f,
+	0.914063f,
+	0.71875f,
+	0.921875f,
+	0.71875f,
+	0.929688f,
+	0.71875f,
+	0.9375f,
+	0.71875f,
+	0.945313f,
+	0.71875f,
+	0.953125f,
+	0.71875f,
+	0.960938f,
+	0.71875f,
+	0.96875f,
+	0.71875f,
+	0.976563f,
+	0.71875f,
+	0.984375f,
+	0.71875f,
+	0.992188f,
+	0.71875f,
+	1.0f,
+	0.71875f,
+	0.507813f,
+	0.726563f,
+	0.515625f,
+	0.726563f,
+	0.523438f,
+	0.726563f,
+	0.53125f,
+	0.726563f,
+	0.539063f,
+	0.726563f,
+	0.546875f,
+	0.726563f,
+	0.554688f,
+	0.726563f,
+	0.5625f,
+	0.726563f,
+	0.570313f,
+	0.726563f,
+	0.578125f,
+	0.726563f,
+	0.585938f,
+	0.726563f,
+	0.59375f,
+	0.726563f,
+	0.601563f,
+	0.726563f,
+	0.609375f,
+	0.726563f,
+	0.617188f,
+	0.726563f,
+	0.625f,
+	0.726563f,
+	0.632813f,
+	0.726563f,
+	0.640625f,
+	0.726563f,
+	0.648438f,
+	0.726563f,
+	0.65625f,
+	0.726563f,
+	0.664063f,
+	0.726563f,
+	0.671875f,
+	0.726563f,
+	0.679688f,
+	0.726563f,
+	0.6875f,
+	0.726563f,
+	0.695313f,
+	0.726563f,
+	0.703125f,
+	0.726563f,
+	0.710938f,
+	0.726563f,
+	0.71875f,
+	0.726563f,
+	0.726563f,
+	0.726563f,
+	0.734375f,
+	0.726563f,
+	0.742188f,
+	0.726563f,
+	0.75f,
+	0.726563f,
+	0.757813f,
+	0.726563f,
+	0.765625f,
+	0.726563f,
+	0.773438f,
+	0.726563f,
+	0.78125f,
+	0.726563f,
+	0.789063f,
+	0.726563f,
+	0.796875f,
+	0.726563f,
+	0.804688f,
+	0.726563f,
+	0.8125f,
+	0.726563f,
+	0.820313f,
+	0.726563f,
+	0.828125f,
+	0.726563f,
+	0.835938f,
+	0.726563f,
+	0.84375f,
+	0.726563f,
+	0.851563f,
+	0.726563f,
+	0.859375f,
+	0.726563f,
+	0.867188f,
+	0.726563f,
+	0.875f,
+	0.726563f,
+	0.882813f,
+	0.726563f,
+	0.890625f,
+	0.726563f,
+	0.898438f,
+	0.726563f,
+	0.90625f,
+	0.726563f,
+	0.914063f,
+	0.726563f,
+	0.921875f,
+	0.726563f,
+	0.929688f,
+	0.726563f,
+	0.9375f,
+	0.726563f,
+	0.945313f,
+	0.726563f,
+	0.953125f,
+	0.726563f,
+	0.960938f,
+	0.726563f,
+	0.96875f,
+	0.726563f,
+	0.976563f,
+	0.726563f,
+	0.984375f,
+	0.726563f,
+	0.992188f,
+	0.726563f,
+	1.0f,
+	0.726563f,
+	0.507813f,
+	0.734375f,
+	0.515625f,
+	0.734375f,
+	0.523438f,
+	0.734375f,
+	0.53125f,
+	0.734375f,
+	0.539063f,
+	0.734375f,
+	0.546875f,
+	0.734375f,
+	0.554688f,
+	0.734375f,
+	0.5625f,
+	0.734375f,
+	0.570313f,
+	0.734375f,
+	0.578125f,
+	0.734375f,
+	0.585938f,
+	0.734375f,
+	0.59375f,
+	0.734375f,
+	0.601563f,
+	0.734375f,
+	0.609375f,
+	0.734375f,
+	0.617188f,
+	0.734375f,
+	0.625f,
+	0.734375f,
+	0.632813f,
+	0.734375f,
+	0.640625f,
+	0.734375f,
+	0.648438f,
+	0.734375f,
+	0.65625f,
+	0.734375f,
+	0.664063f,
+	0.734375f,
+	0.671875f,
+	0.734375f,
+	0.679688f,
+	0.734375f,
+	0.6875f,
+	0.734375f,
+	0.695313f,
+	0.734375f,
+	0.703125f,
+	0.734375f,
+	0.710938f,
+	0.734375f,
+	0.71875f,
+	0.734375f,
+	0.726563f,
+	0.734375f,
+	0.734375f,
+	0.734375f,
+	0.742188f,
+	0.734375f,
+	0.75f,
+	0.734375f,
+	0.757813f,
+	0.734375f,
+	0.765625f,
+	0.734375f,
+	0.773438f,
+	0.734375f,
+	0.78125f,
+	0.734375f,
+	0.789063f,
+	0.734375f,
+	0.796875f,
+	0.734375f,
+	0.804688f,
+	0.734375f,
+	0.8125f,
+	0.734375f,
+	0.820313f,
+	0.734375f,
+	0.828125f,
+	0.734375f,
+	0.835938f,
+	0.734375f,
+	0.84375f,
+	0.734375f,
+	0.851563f,
+	0.734375f,
+	0.859375f,
+	0.734375f,
+	0.867188f,
+	0.734375f,
+	0.875f,
+	0.734375f,
+	0.882813f,
+	0.734375f,
+	0.890625f,
+	0.734375f,
+	0.898438f,
+	0.734375f,
+	0.90625f,
+	0.734375f,
+	0.914063f,
+	0.734375f,
+	0.921875f,
+	0.734375f,
+	0.929688f,
+	0.734375f,
+	0.9375f,
+	0.734375f,
+	0.945313f,
+	0.734375f,
+	0.953125f,
+	0.734375f,
+	0.960938f,
+	0.734375f,
+	0.96875f,
+	0.734375f,
+	0.976563f,
+	0.734375f,
+	0.984375f,
+	0.734375f,
+	0.992188f,
+	0.734375f,
+	1.0f,
+	0.734375f,
+};
+
+unsigned short Landscape03Idx[] = {
+	0,
+	1,
+	2,
+	3,
+	2,
+	1,
+	2,
+	3,
+	4,
+	5,
+	4,
+	3,
+	4,
+	5,
+	6,
+	7,
+	6,
+	5,
+	6,
+	7,
+	8,
+	9,
+	8,
+	7,
+	8,
+	9,
+	10,
+	11,
+	10,
+	9,
+	10,
+	11,
+	12,
+	13,
+	12,
+	11,
+	12,
+	13,
+	14,
+	15,
+	14,
+	13,
+	14,
+	15,
+	16,
+	17,
+	16,
+	15,
+	16,
+	17,
+	18,
+	19,
+	18,
+	17,
+	18,
+	19,
+	20,
+	21,
+	20,
+	19,
+	20,
+	21,
+	22,
+	23,
+	22,
+	21,
+	22,
+	23,
+	24,
+	25,
+	24,
+	23,
+	24,
+	25,
+	26,
+	27,
+	26,
+	25,
+	26,
+	27,
+	28,
+	29,
+	28,
+	27,
+	28,
+	29,
+	30,
+	31,
+	30,
+	29,
+	30,
+	31,
+	32,
+	33,
+	32,
+	31,
+	32,
+	33,
+	34,
+	35,
+	34,
+	33,
+	34,
+	35,
+	36,
+	37,
+	36,
+	35,
+	36,
+	37,
+	38,
+	39,
+	38,
+	37,
+	38,
+	39,
+	40,
+	41,
+	40,
+	39,
+	40,
+	41,
+	42,
+	43,
+	42,
+	41,
+	42,
+	43,
+	44,
+	45,
+	44,
+	43,
+	44,
+	45,
+	46,
+	47,
+	46,
+	45,
+	46,
+	47,
+	48,
+	49,
+	48,
+	47,
+	48,
+	49,
+	50,
+	51,
+	50,
+	49,
+	50,
+	51,
+	52,
+	53,
+	52,
+	51,
+	52,
+	53,
+	54,
+	55,
+	54,
+	53,
+	54,
+	55,
+	56,
+	57,
+	56,
+	55,
+	56,
+	57,
+	58,
+	59,
+	58,
+	57,
+	58,
+	59,
+	60,
+	61,
+	60,
+	59,
+	60,
+	61,
+	62,
+	63,
+	62,
+	61,
+	62,
+	63,
+	64,
+	65,
+	64,
+	63,
+	64,
+	65,
+	66,
+	67,
+	66,
+	65,
+	66,
+	67,
+	68,
+	69,
+	68,
+	67,
+	68,
+	69,
+	70,
+	71,
+	70,
+	69,
+	70,
+	71,
+	72,
+	73,
+	72,
+	71,
+	72,
+	73,
+	74,
+	75,
+	74,
+	73,
+	74,
+	75,
+	76,
+	77,
+	76,
+	75,
+	76,
+	77,
+	78,
+	79,
+	78,
+	77,
+	78,
+	79,
+	80,
+	81,
+	80,
+	79,
+	80,
+	81,
+	82,
+	83,
+	82,
+	81,
+	82,
+	83,
+	84,
+	85,
+	84,
+	83,
+	84,
+	85,
+	86,
+	87,
+	86,
+	85,
+	86,
+	87,
+	88,
+	89,
+	88,
+	87,
+	88,
+	89,
+	90,
+	91,
+	90,
+	89,
+	90,
+	91,
+	92,
+	93,
+	92,
+	91,
+	92,
+	93,
+	94,
+	95,
+	94,
+	93,
+	94,
+	95,
+	96,
+	97,
+	96,
+	95,
+	96,
+	97,
+	98,
+	99,
+	98,
+	97,
+	98,
+	99,
+	100,
+	101,
+	100,
+	99,
+	100,
+	101,
+	102,
+	103,
+	102,
+	101,
+	102,
+	103,
+	104,
+	105,
+	104,
+	103,
+	104,
+	105,
+	106,
+	107,
+	106,
+	105,
+	106,
+	107,
+	108,
+	109,
+	108,
+	107,
+	108,
+	109,
+	110,
+	111,
+	110,
+	109,
+	110,
+	111,
+	112,
+	113,
+	112,
+	111,
+	112,
+	113,
+	114,
+	115,
+	114,
+	113,
+	114,
+	115,
+	116,
+	117,
+	116,
+	115,
+	116,
+	117,
+	118,
+	119,
+	118,
+	117,
+	118,
+	119,
+	120,
+	121,
+	120,
+	119,
+	120,
+	121,
+	122,
+	123,
+	122,
+	121,
+	122,
+	123,
+	124,
+	125,
+	124,
+	123,
+	124,
+	125,
+	126,
+	127,
+	126,
+	125,
+	128,
+	0,
+	129,
+	2,
+	129,
+	0,
+	129,
+	2,
+	130,
+	4,
+	130,
+	2,
+	130,
+	4,
+	131,
+	6,
+	131,
+	4,
+	131,
+	6,
+	132,
+	8,
+	132,
+	6,
+	132,
+	8,
+	133,
+	10,
+	133,
+	8,
+	133,
+	10,
+	134,
+	12,
+	134,
+	10,
+	134,
+	12,
+	135,
+	14,
+	135,
+	12,
+	135,
+	14,
+	136,
+	16,
+	136,
+	14,
+	136,
+	16,
+	137,
+	18,
+	137,
+	16,
+	137,
+	18,
+	138,
+	20,
+	138,
+	18,
+	138,
+	20,
+	139,
+	22,
+	139,
+	20,
+	139,
+	22,
+	140,
+	24,
+	140,
+	22,
+	140,
+	24,
+	141,
+	26,
+	141,
+	24,
+	141,
+	26,
+	142,
+	28,
+	142,
+	26,
+	142,
+	28,
+	143,
+	30,
+	143,
+	28,
+	143,
+	30,
+	144,
+	32,
+	144,
+	30,
+	144,
+	32,
+	145,
+	34,
+	145,
+	32,
+	145,
+	34,
+	146,
+	36,
+	146,
+	34,
+	146,
+	36,
+	147,
+	38,
+	147,
+	36,
+	147,
+	38,
+	148,
+	40,
+	148,
+	38,
+	148,
+	40,
+	149,
+	42,
+	149,
+	40,
+	149,
+	42,
+	150,
+	44,
+	150,
+	42,
+	150,
+	44,
+	151,
+	46,
+	151,
+	44,
+	151,
+	46,
+	152,
+	48,
+	152,
+	46,
+	152,
+	48,
+	153,
+	50,
+	153,
+	48,
+	153,
+	50,
+	154,
+	52,
+	154,
+	50,
+	154,
+	52,
+	155,
+	54,
+	155,
+	52,
+	155,
+	54,
+	156,
+	56,
+	156,
+	54,
+	156,
+	56,
+	157,
+	58,
+	157,
+	56,
+	157,
+	58,
+	158,
+	60,
+	158,
+	58,
+	158,
+	60,
+	159,
+	62,
+	159,
+	60,
+	159,
+	62,
+	160,
+	64,
+	160,
+	62,
+	160,
+	64,
+	161,
+	66,
+	161,
+	64,
+	161,
+	66,
+	162,
+	68,
+	162,
+	66,
+	162,
+	68,
+	163,
+	70,
+	163,
+	68,
+	163,
+	70,
+	164,
+	72,
+	164,
+	70,
+	164,
+	72,
+	165,
+	74,
+	165,
+	72,
+	165,
+	74,
+	166,
+	76,
+	166,
+	74,
+	166,
+	76,
+	167,
+	78,
+	167,
+	76,
+	167,
+	78,
+	168,
+	80,
+	168,
+	78,
+	168,
+	80,
+	169,
+	82,
+	169,
+	80,
+	169,
+	82,
+	170,
+	84,
+	170,
+	82,
+	170,
+	84,
+	171,
+	86,
+	171,
+	84,
+	171,
+	86,
+	172,
+	88,
+	172,
+	86,
+	172,
+	88,
+	173,
+	90,
+	173,
+	88,
+	173,
+	90,
+	174,
+	92,
+	174,
+	90,
+	174,
+	92,
+	175,
+	94,
+	175,
+	92,
+	175,
+	94,
+	176,
+	96,
+	176,
+	94,
+	176,
+	96,
+	177,
+	98,
+	177,
+	96,
+	177,
+	98,
+	178,
+	100,
+	178,
+	98,
+	178,
+	100,
+	179,
+	102,
+	179,
+	100,
+	179,
+	102,
+	180,
+	104,
+	180,
+	102,
+	180,
+	104,
+	181,
+	106,
+	181,
+	104,
+	181,
+	106,
+	182,
+	108,
+	182,
+	106,
+	182,
+	108,
+	183,
+	110,
+	183,
+	108,
+	183,
+	110,
+	184,
+	112,
+	184,
+	110,
+	184,
+	112,
+	185,
+	114,
+	185,
+	112,
+	185,
+	114,
+	186,
+	116,
+	186,
+	114,
+	186,
+	116,
+	187,
+	118,
+	187,
+	116,
+	187,
+	118,
+	188,
+	120,
+	188,
+	118,
+	188,
+	120,
+	189,
+	122,
+	189,
+	120,
+	189,
+	122,
+	190,
+	124,
+	190,
+	122,
+	190,
+	124,
+	191,
+	126,
+	191,
+	124,
+	192,
+	128,
+	193,
+	129,
+	193,
+	128,
+	193,
+	129,
+	194,
+	130,
+	194,
+	129,
+	194,
+	130,
+	195,
+	131,
+	195,
+	130,
+	195,
+	131,
+	196,
+	132,
+	196,
+	131,
+	196,
+	132,
+	197,
+	133,
+	197,
+	132,
+	197,
+	133,
+	198,
+	134,
+	198,
+	133,
+	198,
+	134,
+	199,
+	135,
+	199,
+	134,
+	199,
+	135,
+	200,
+	136,
+	200,
+	135,
+	200,
+	136,
+	201,
+	137,
+	201,
+	136,
+	201,
+	137,
+	202,
+	138,
+	202,
+	137,
+	202,
+	138,
+	203,
+	139,
+	203,
+	138,
+	203,
+	139,
+	204,
+	140,
+	204,
+	139,
+	204,
+	140,
+	205,
+	141,
+	205,
+	140,
+	205,
+	141,
+	206,
+	142,
+	206,
+	141,
+	206,
+	142,
+	207,
+	143,
+	207,
+	142,
+	207,
+	143,
+	208,
+	144,
+	208,
+	143,
+	208,
+	144,
+	209,
+	145,
+	209,
+	144,
+	209,
+	145,
+	210,
+	146,
+	210,
+	145,
+	210,
+	146,
+	211,
+	147,
+	211,
+	146,
+	211,
+	147,
+	212,
+	148,
+	212,
+	147,
+	212,
+	148,
+	213,
+	149,
+	213,
+	148,
+	213,
+	149,
+	214,
+	150,
+	214,
+	149,
+	214,
+	150,
+	215,
+	151,
+	215,
+	150,
+	215,
+	151,
+	216,
+	152,
+	216,
+	151,
+	216,
+	152,
+	217,
+	153,
+	217,
+	152,
+	217,
+	153,
+	218,
+	154,
+	218,
+	153,
+	218,
+	154,
+	219,
+	155,
+	219,
+	154,
+	219,
+	155,
+	220,
+	156,
+	220,
+	155,
+	220,
+	156,
+	221,
+	157,
+	221,
+	156,
+	221,
+	157,
+	222,
+	158,
+	222,
+	157,
+	222,
+	158,
+	223,
+	159,
+	223,
+	158,
+	223,
+	159,
+	224,
+	160,
+	224,
+	159,
+	224,
+	160,
+	225,
+	161,
+	225,
+	160,
+	225,
+	161,
+	226,
+	162,
+	226,
+	161,
+	226,
+	162,
+	227,
+	163,
+	227,
+	162,
+	227,
+	163,
+	228,
+	164,
+	228,
+	163,
+	228,
+	164,
+	229,
+	165,
+	229,
+	164,
+	229,
+	165,
+	230,
+	166,
+	230,
+	165,
+	230,
+	166,
+	231,
+	167,
+	231,
+	166,
+	231,
+	167,
+	232,
+	168,
+	232,
+	167,
+	232,
+	168,
+	233,
+	169,
+	233,
+	168,
+	233,
+	169,
+	234,
+	170,
+	234,
+	169,
+	234,
+	170,
+	235,
+	171,
+	235,
+	170,
+	235,
+	171,
+	236,
+	172,
+	236,
+	171,
+	236,
+	172,
+	237,
+	173,
+	237,
+	172,
+	237,
+	173,
+	238,
+	174,
+	238,
+	173,
+	238,
+	174,
+	239,
+	175,
+	239,
+	174,
+	239,
+	175,
+	240,
+	176,
+	240,
+	175,
+	240,
+	176,
+	241,
+	177,
+	241,
+	176,
+	241,
+	177,
+	242,
+	178,
+	242,
+	177,
+	242,
+	178,
+	243,
+	179,
+	243,
+	178,
+	243,
+	179,
+	244,
+	180,
+	244,
+	179,
+	244,
+	180,
+	245,
+	181,
+	245,
+	180,
+	245,
+	181,
+	246,
+	182,
+	246,
+	181,
+	246,
+	182,
+	247,
+	183,
+	247,
+	182,
+	247,
+	183,
+	248,
+	184,
+	248,
+	183,
+	248,
+	184,
+	249,
+	185,
+	249,
+	184,
+	249,
+	185,
+	250,
+	186,
+	250,
+	185,
+	250,
+	186,
+	251,
+	187,
+	251,
+	186,
+	251,
+	187,
+	252,
+	188,
+	252,
+	187,
+	252,
+	188,
+	253,
+	189,
+	253,
+	188,
+	253,
+	189,
+	254,
+	190,
+	254,
+	189,
+	254,
+	190,
+	255,
+	191,
+	255,
+	190,
+	256,
+	192,
+	257,
+	193,
+	257,
+	192,
+	257,
+	193,
+	258,
+	194,
+	258,
+	193,
+	258,
+	194,
+	259,
+	195,
+	259,
+	194,
+	259,
+	195,
+	260,
+	196,
+	260,
+	195,
+	260,
+	196,
+	261,
+	197,
+	261,
+	196,
+	261,
+	197,
+	262,
+	198,
+	262,
+	197,
+	262,
+	198,
+	263,
+	199,
+	263,
+	198,
+	263,
+	199,
+	264,
+	200,
+	264,
+	199,
+	264,
+	200,
+	265,
+	201,
+	265,
+	200,
+	265,
+	201,
+	266,
+	202,
+	266,
+	201,
+	266,
+	202,
+	267,
+	203,
+	267,
+	202,
+	267,
+	203,
+	268,
+	204,
+	268,
+	203,
+	268,
+	204,
+	269,
+	205,
+	269,
+	204,
+	269,
+	205,
+	270,
+	206,
+	270,
+	205,
+	270,
+	206,
+	271,
+	207,
+	271,
+	206,
+	271,
+	207,
+	272,
+	208,
+	272,
+	207,
+	272,
+	208,
+	273,
+	209,
+	273,
+	208,
+	273,
+	209,
+	274,
+	210,
+	274,
+	209,
+	274,
+	210,
+	275,
+	211,
+	275,
+	210,
+	275,
+	211,
+	276,
+	212,
+	276,
+	211,
+	276,
+	212,
+	277,
+	213,
+	277,
+	212,
+	277,
+	213,
+	278,
+	214,
+	278,
+	213,
+	278,
+	214,
+	279,
+	215,
+	279,
+	214,
+	279,
+	215,
+	280,
+	216,
+	280,
+	215,
+	280,
+	216,
+	281,
+	217,
+	281,
+	216,
+	281,
+	217,
+	282,
+	218,
+	282,
+	217,
+	282,
+	218,
+	283,
+	219,
+	283,
+	218,
+	283,
+	219,
+	284,
+	220,
+	284,
+	219,
+	284,
+	220,
+	285,
+	221,
+	285,
+	220,
+	285,
+	221,
+	286,
+	222,
+	286,
+	221,
+	286,
+	222,
+	287,
+	223,
+	287,
+	222,
+	287,
+	223,
+	288,
+	224,
+	288,
+	223,
+	288,
+	224,
+	289,
+	225,
+	289,
+	224,
+	289,
+	225,
+	290,
+	226,
+	290,
+	225,
+	290,
+	226,
+	291,
+	227,
+	291,
+	226,
+	291,
+	227,
+	292,
+	228,
+	292,
+	227,
+	292,
+	228,
+	293,
+	229,
+	293,
+	228,
+	293,
+	229,
+	294,
+	230,
+	294,
+	229,
+	294,
+	230,
+	295,
+	231,
+	295,
+	230,
+	295,
+	231,
+	296,
+	232,
+	296,
+	231,
+	296,
+	232,
+	297,
+	233,
+	297,
+	232,
+	297,
+	233,
+	298,
+	234,
+	298,
+	233,
+	298,
+	234,
+	299,
+	235,
+	299,
+	234,
+	299,
+	235,
+	300,
+	236,
+	300,
+	235,
+	300,
+	236,
+	301,
+	237,
+	301,
+	236,
+	301,
+	237,
+	302,
+	238,
+	302,
+	237,
+	302,
+	238,
+	303,
+	239,
+	303,
+	238,
+	303,
+	239,
+	304,
+	240,
+	304,
+	239,
+	304,
+	240,
+	305,
+	241,
+	305,
+	240,
+	305,
+	241,
+	306,
+	242,
+	306,
+	241,
+	306,
+	242,
+	307,
+	243,
+	307,
+	242,
+	307,
+	243,
+	308,
+	244,
+	308,
+	243,
+	308,
+	244,
+	309,
+	245,
+	309,
+	244,
+	309,
+	245,
+	310,
+	246,
+	310,
+	245,
+	310,
+	246,
+	311,
+	247,
+	311,
+	246,
+	311,
+	247,
+	312,
+	248,
+	312,
+	247,
+	312,
+	248,
+	313,
+	249,
+	313,
+	248,
+	313,
+	249,
+	314,
+	250,
+	314,
+	249,
+	314,
+	250,
+	315,
+	251,
+	315,
+	250,
+	315,
+	251,
+	316,
+	252,
+	316,
+	251,
+	316,
+	252,
+	317,
+	253,
+	317,
+	252,
+	317,
+	253,
+	318,
+	254,
+	318,
+	253,
+	318,
+	254,
+	319,
+	255,
+	319,
+	254,
+	320,
+	256,
+	321,
+	257,
+	321,
+	256,
+	321,
+	257,
+	322,
+	258,
+	322,
+	257,
+	322,
+	258,
+	323,
+	259,
+	323,
+	258,
+	323,
+	259,
+	324,
+	260,
+	324,
+	259,
+	324,
+	260,
+	325,
+	261,
+	325,
+	260,
+	325,
+	261,
+	326,
+	262,
+	326,
+	261,
+	326,
+	262,
+	327,
+	263,
+	327,
+	262,
+	327,
+	263,
+	328,
+	264,
+	328,
+	263,
+	328,
+	264,
+	329,
+	265,
+	329,
+	264,
+	329,
+	265,
+	330,
+	266,
+	330,
+	265,
+	330,
+	266,
+	331,
+	267,
+	331,
+	266,
+	331,
+	267,
+	332,
+	268,
+	332,
+	267,
+	332,
+	268,
+	333,
+	269,
+	333,
+	268,
+	333,
+	269,
+	334,
+	270,
+	334,
+	269,
+	334,
+	270,
+	335,
+	271,
+	335,
+	270,
+	335,
+	271,
+	336,
+	272,
+	336,
+	271,
+	336,
+	272,
+	337,
+	273,
+	337,
+	272,
+	337,
+	273,
+	338,
+	274,
+	338,
+	273,
+	338,
+	274,
+	339,
+	275,
+	339,
+	274,
+	339,
+	275,
+	340,
+	276,
+	340,
+	275,
+	340,
+	276,
+	341,
+	277,
+	341,
+	276,
+	341,
+	277,
+	342,
+	278,
+	342,
+	277,
+	342,
+	278,
+	343,
+	279,
+	343,
+	278,
+	343,
+	279,
+	344,
+	280,
+	344,
+	279,
+	344,
+	280,
+	345,
+	281,
+	345,
+	280,
+	345,
+	281,
+	346,
+	282,
+	346,
+	281,
+	346,
+	282,
+	347,
+	283,
+	347,
+	282,
+	347,
+	283,
+	348,
+	284,
+	348,
+	283,
+	348,
+	284,
+	349,
+	285,
+	349,
+	284,
+	349,
+	285,
+	350,
+	286,
+	350,
+	285,
+	350,
+	286,
+	351,
+	287,
+	351,
+	286,
+	351,
+	287,
+	352,
+	288,
+	352,
+	287,
+	352,
+	288,
+	353,
+	289,
+	353,
+	288,
+	353,
+	289,
+	354,
+	290,
+	354,
+	289,
+	354,
+	290,
+	355,
+	291,
+	355,
+	290,
+	355,
+	291,
+	356,
+	292,
+	356,
+	291,
+	356,
+	292,
+	357,
+	293,
+	357,
+	292,
+	357,
+	293,
+	358,
+	294,
+	358,
+	293,
+	358,
+	294,
+	359,
+	295,
+	359,
+	294,
+	359,
+	295,
+	360,
+	296,
+	360,
+	295,
+	360,
+	296,
+	361,
+	297,
+	361,
+	296,
+	361,
+	297,
+	362,
+	298,
+	362,
+	297,
+	362,
+	298,
+	363,
+	299,
+	363,
+	298,
+	363,
+	299,
+	364,
+	300,
+	364,
+	299,
+	364,
+	300,
+	365,
+	301,
+	365,
+	300,
+	365,
+	301,
+	366,
+	302,
+	366,
+	301,
+	366,
+	302,
+	367,
+	303,
+	367,
+	302,
+	367,
+	303,
+	368,
+	304,
+	368,
+	303,
+	368,
+	304,
+	369,
+	305,
+	369,
+	304,
+	369,
+	305,
+	370,
+	306,
+	370,
+	305,
+	370,
+	306,
+	371,
+	307,
+	371,
+	306,
+	371,
+	307,
+	372,
+	308,
+	372,
+	307,
+	372,
+	308,
+	373,
+	309,
+	373,
+	308,
+	373,
+	309,
+	374,
+	310,
+	374,
+	309,
+	374,
+	310,
+	375,
+	311,
+	375,
+	310,
+	375,
+	311,
+	376,
+	312,
+	376,
+	311,
+	376,
+	312,
+	377,
+	313,
+	377,
+	312,
+	377,
+	313,
+	378,
+	314,
+	378,
+	313,
+	378,
+	314,
+	379,
+	315,
+	379,
+	314,
+	379,
+	315,
+	380,
+	316,
+	380,
+	315,
+	380,
+	316,
+	381,
+	317,
+	381,
+	316,
+	381,
+	317,
+	382,
+	318,
+	382,
+	317,
+	382,
+	318,
+	383,
+	319,
+	383,
+	318,
+	384,
+	320,
+	385,
+	321,
+	385,
+	320,
+	385,
+	321,
+	386,
+	322,
+	386,
+	321,
+	386,
+	322,
+	387,
+	323,
+	387,
+	322,
+	387,
+	323,
+	388,
+	324,
+	388,
+	323,
+	388,
+	324,
+	389,
+	325,
+	389,
+	324,
+	389,
+	325,
+	390,
+	326,
+	390,
+	325,
+	390,
+	326,
+	391,
+	327,
+	391,
+	326,
+	391,
+	327,
+	392,
+	328,
+	392,
+	327,
+	392,
+	328,
+	393,
+	329,
+	393,
+	328,
+	393,
+	329,
+	394,
+	330,
+	394,
+	329,
+	394,
+	330,
+	395,
+	331,
+	395,
+	330,
+	395,
+	331,
+	396,
+	332,
+	396,
+	331,
+	396,
+	332,
+	397,
+	333,
+	397,
+	332,
+	397,
+	333,
+	398,
+	334,
+	398,
+	333,
+	398,
+	334,
+	399,
+	335,
+	399,
+	334,
+	399,
+	335,
+	400,
+	336,
+	400,
+	335,
+	400,
+	336,
+	401,
+	337,
+	401,
+	336,
+	401,
+	337,
+	402,
+	338,
+	402,
+	337,
+	402,
+	338,
+	403,
+	339,
+	403,
+	338,
+	403,
+	339,
+	404,
+	340,
+	404,
+	339,
+	404,
+	340,
+	405,
+	341,
+	405,
+	340,
+	405,
+	341,
+	406,
+	342,
+	406,
+	341,
+	406,
+	342,
+	407,
+	343,
+	407,
+	342,
+	407,
+	343,
+	408,
+	344,
+	408,
+	343,
+	408,
+	344,
+	409,
+	345,
+	409,
+	344,
+	409,
+	345,
+	410,
+	346,
+	410,
+	345,
+	410,
+	346,
+	411,
+	347,
+	411,
+	346,
+	411,
+	347,
+	412,
+	348,
+	412,
+	347,
+	412,
+	348,
+	413,
+	349,
+	413,
+	348,
+	413,
+	349,
+	414,
+	350,
+	414,
+	349,
+	414,
+	350,
+	415,
+	351,
+	415,
+	350,
+	415,
+	351,
+	416,
+	352,
+	416,
+	351,
+	416,
+	352,
+	417,
+	353,
+	417,
+	352,
+	417,
+	353,
+	418,
+	354,
+	418,
+	353,
+	418,
+	354,
+	419,
+	355,
+	419,
+	354,
+	419,
+	355,
+	420,
+	356,
+	420,
+	355,
+	420,
+	356,
+	421,
+	357,
+	421,
+	356,
+	421,
+	357,
+	422,
+	358,
+	422,
+	357,
+	422,
+	358,
+	423,
+	359,
+	423,
+	358,
+	423,
+	359,
+	424,
+	360,
+	424,
+	359,
+	424,
+	360,
+	425,
+	361,
+	425,
+	360,
+	425,
+	361,
+	426,
+	362,
+	426,
+	361,
+	426,
+	362,
+	427,
+	363,
+	427,
+	362,
+	427,
+	363,
+	428,
+	364,
+	428,
+	363,
+	428,
+	364,
+	429,
+	365,
+	429,
+	364,
+	429,
+	365,
+	430,
+	366,
+	430,
+	365,
+	430,
+	366,
+	431,
+	367,
+	431,
+	366,
+	431,
+	367,
+	432,
+	368,
+	432,
+	367,
+	432,
+	368,
+	433,
+	369,
+	433,
+	368,
+	433,
+	369,
+	434,
+	370,
+	434,
+	369,
+	434,
+	370,
+	435,
+	371,
+	435,
+	370,
+	435,
+	371,
+	436,
+	372,
+	436,
+	371,
+	436,
+	372,
+	437,
+	373,
+	437,
+	372,
+	437,
+	373,
+	438,
+	374,
+	438,
+	373,
+	438,
+	374,
+	439,
+	375,
+	439,
+	374,
+	439,
+	375,
+	440,
+	376,
+	440,
+	375,
+	440,
+	376,
+	441,
+	377,
+	441,
+	376,
+	441,
+	377,
+	442,
+	378,
+	442,
+	377,
+	442,
+	378,
+	443,
+	379,
+	443,
+	378,
+	443,
+	379,
+	444,
+	380,
+	444,
+	379,
+	444,
+	380,
+	445,
+	381,
+	445,
+	380,
+	445,
+	381,
+	446,
+	382,
+	446,
+	381,
+	446,
+	382,
+	447,
+	383,
+	447,
+	382,
+	448,
+	384,
+	449,
+	385,
+	449,
+	384,
+	449,
+	385,
+	450,
+	386,
+	450,
+	385,
+	450,
+	386,
+	451,
+	387,
+	451,
+	386,
+	451,
+	387,
+	452,
+	388,
+	452,
+	387,
+	452,
+	388,
+	453,
+	389,
+	453,
+	388,
+	453,
+	389,
+	454,
+	390,
+	454,
+	389,
+	454,
+	390,
+	455,
+	391,
+	455,
+	390,
+	455,
+	391,
+	456,
+	392,
+	456,
+	391,
+	456,
+	392,
+	457,
+	393,
+	457,
+	392,
+	457,
+	393,
+	458,
+	394,
+	458,
+	393,
+	458,
+	394,
+	459,
+	395,
+	459,
+	394,
+	459,
+	395,
+	460,
+	396,
+	460,
+	395,
+	460,
+	396,
+	461,
+	397,
+	461,
+	396,
+	461,
+	397,
+	462,
+	398,
+	462,
+	397,
+	462,
+	398,
+	463,
+	399,
+	463,
+	398,
+	463,
+	399,
+	464,
+	400,
+	464,
+	399,
+	464,
+	400,
+	465,
+	401,
+	465,
+	400,
+	465,
+	401,
+	466,
+	402,
+	466,
+	401,
+	466,
+	402,
+	467,
+	403,
+	467,
+	402,
+	467,
+	403,
+	468,
+	404,
+	468,
+	403,
+	468,
+	404,
+	469,
+	405,
+	469,
+	404,
+	469,
+	405,
+	470,
+	406,
+	470,
+	405,
+	470,
+	406,
+	471,
+	407,
+	471,
+	406,
+	471,
+	407,
+	472,
+	408,
+	472,
+	407,
+	472,
+	408,
+	473,
+	409,
+	473,
+	408,
+	473,
+	409,
+	474,
+	410,
+	474,
+	409,
+	474,
+	410,
+	475,
+	411,
+	475,
+	410,
+	475,
+	411,
+	476,
+	412,
+	476,
+	411,
+	476,
+	412,
+	477,
+	413,
+	477,
+	412,
+	477,
+	413,
+	478,
+	414,
+	478,
+	413,
+	478,
+	414,
+	479,
+	415,
+	479,
+	414,
+	479,
+	415,
+	480,
+	416,
+	480,
+	415,
+	480,
+	416,
+	481,
+	417,
+	481,
+	416,
+	481,
+	417,
+	482,
+	418,
+	482,
+	417,
+	482,
+	418,
+	483,
+	419,
+	483,
+	418,
+	483,
+	419,
+	484,
+	420,
+	484,
+	419,
+	484,
+	420,
+	485,
+	421,
+	485,
+	420,
+	485,
+	421,
+	486,
+	422,
+	486,
+	421,
+	486,
+	422,
+	487,
+	423,
+	487,
+	422,
+	487,
+	423,
+	488,
+	424,
+	488,
+	423,
+	488,
+	424,
+	489,
+	425,
+	489,
+	424,
+	489,
+	425,
+	490,
+	426,
+	490,
+	425,
+	490,
+	426,
+	491,
+	427,
+	491,
+	426,
+	491,
+	427,
+	492,
+	428,
+	492,
+	427,
+	492,
+	428,
+	493,
+	429,
+	493,
+	428,
+	493,
+	429,
+	494,
+	430,
+	494,
+	429,
+	494,
+	430,
+	495,
+	431,
+	495,
+	430,
+	495,
+	431,
+	496,
+	432,
+	496,
+	431,
+	496,
+	432,
+	497,
+	433,
+	497,
+	432,
+	497,
+	433,
+	498,
+	434,
+	498,
+	433,
+	498,
+	434,
+	499,
+	435,
+	499,
+	434,
+	499,
+	435,
+	500,
+	436,
+	500,
+	435,
+	500,
+	436,
+	501,
+	437,
+	501,
+	436,
+	501,
+	437,
+	502,
+	438,
+	502,
+	437,
+	502,
+	438,
+	503,
+	439,
+	503,
+	438,
+	503,
+	439,
+	504,
+	440,
+	504,
+	439,
+	504,
+	440,
+	505,
+	441,
+	505,
+	440,
+	505,
+	441,
+	506,
+	442,
+	506,
+	441,
+	506,
+	442,
+	507,
+	443,
+	507,
+	442,
+	507,
+	443,
+	508,
+	444,
+	508,
+	443,
+	508,
+	444,
+	509,
+	445,
+	509,
+	444,
+	509,
+	445,
+	510,
+	446,
+	510,
+	445,
+	510,
+	446,
+	511,
+	447,
+	511,
+	446,
+	512,
+	448,
+	513,
+	449,
+	513,
+	448,
+	513,
+	449,
+	514,
+	450,
+	514,
+	449,
+	514,
+	450,
+	515,
+	451,
+	515,
+	450,
+	515,
+	451,
+	516,
+	452,
+	516,
+	451,
+	516,
+	452,
+	517,
+	453,
+	517,
+	452,
+	517,
+	453,
+	518,
+	454,
+	518,
+	453,
+	518,
+	454,
+	519,
+	455,
+	519,
+	454,
+	519,
+	455,
+	520,
+	456,
+	520,
+	455,
+	520,
+	456,
+	521,
+	457,
+	521,
+	456,
+	521,
+	457,
+	522,
+	458,
+	522,
+	457,
+	522,
+	458,
+	523,
+	459,
+	523,
+	458,
+	523,
+	459,
+	524,
+	460,
+	524,
+	459,
+	524,
+	460,
+	525,
+	461,
+	525,
+	460,
+	525,
+	461,
+	526,
+	462,
+	526,
+	461,
+	526,
+	462,
+	527,
+	463,
+	527,
+	462,
+	527,
+	463,
+	528,
+	464,
+	528,
+	463,
+	528,
+	464,
+	529,
+	465,
+	529,
+	464,
+	529,
+	465,
+	530,
+	466,
+	530,
+	465,
+	530,
+	466,
+	531,
+	467,
+	531,
+	466,
+	531,
+	467,
+	532,
+	468,
+	532,
+	467,
+	532,
+	468,
+	533,
+	469,
+	533,
+	468,
+	533,
+	469,
+	534,
+	470,
+	534,
+	469,
+	534,
+	470,
+	535,
+	471,
+	535,
+	470,
+	535,
+	471,
+	536,
+	472,
+	536,
+	471,
+	536,
+	472,
+	537,
+	473,
+	537,
+	472,
+	537,
+	473,
+	538,
+	474,
+	538,
+	473,
+	538,
+	474,
+	539,
+	475,
+	539,
+	474,
+	539,
+	475,
+	540,
+	476,
+	540,
+	475,
+	540,
+	476,
+	541,
+	477,
+	541,
+	476,
+	541,
+	477,
+	542,
+	478,
+	542,
+	477,
+	542,
+	478,
+	543,
+	479,
+	543,
+	478,
+	543,
+	479,
+	544,
+	480,
+	544,
+	479,
+	544,
+	480,
+	545,
+	481,
+	545,
+	480,
+	545,
+	481,
+	546,
+	482,
+	546,
+	481,
+	546,
+	482,
+	547,
+	483,
+	547,
+	482,
+	547,
+	483,
+	548,
+	484,
+	548,
+	483,
+	548,
+	484,
+	549,
+	485,
+	549,
+	484,
+	549,
+	485,
+	550,
+	486,
+	550,
+	485,
+	550,
+	486,
+	551,
+	487,
+	551,
+	486,
+	551,
+	487,
+	552,
+	488,
+	552,
+	487,
+	552,
+	488,
+	553,
+	489,
+	553,
+	488,
+	553,
+	489,
+	554,
+	490,
+	554,
+	489,
+	554,
+	490,
+	555,
+	491,
+	555,
+	490,
+	555,
+	491,
+	556,
+	492,
+	556,
+	491,
+	556,
+	492,
+	557,
+	493,
+	557,
+	492,
+	557,
+	493,
+	558,
+	494,
+	558,
+	493,
+	558,
+	494,
+	559,
+	495,
+	559,
+	494,
+	559,
+	495,
+	560,
+	496,
+	560,
+	495,
+	560,
+	496,
+	561,
+	497,
+	561,
+	496,
+	561,
+	497,
+	562,
+	498,
+	562,
+	497,
+	562,
+	498,
+	563,
+	499,
+	563,
+	498,
+	563,
+	499,
+	564,
+	500,
+	564,
+	499,
+	564,
+	500,
+	565,
+	501,
+	565,
+	500,
+	565,
+	501,
+	566,
+	502,
+	566,
+	501,
+	566,
+	502,
+	567,
+	503,
+	567,
+	502,
+	567,
+	503,
+	568,
+	504,
+	568,
+	503,
+	568,
+	504,
+	569,
+	505,
+	569,
+	504,
+	569,
+	505,
+	570,
+	506,
+	570,
+	505,
+	570,
+	506,
+	571,
+	507,
+	571,
+	506,
+	571,
+	507,
+	572,
+	508,
+	572,
+	507,
+	572,
+	508,
+	573,
+	509,
+	573,
+	508,
+	573,
+	509,
+	574,
+	510,
+	574,
+	509,
+	574,
+	510,
+	575,
+	511,
+	575,
+	510,
+	576,
+	512,
+	577,
+	513,
+	577,
+	512,
+	577,
+	513,
+	578,
+	514,
+	578,
+	513,
+	578,
+	514,
+	579,
+	515,
+	579,
+	514,
+	579,
+	515,
+	580,
+	516,
+	580,
+	515,
+	580,
+	516,
+	581,
+	517,
+	581,
+	516,
+	581,
+	517,
+	582,
+	518,
+	582,
+	517,
+	582,
+	518,
+	583,
+	519,
+	583,
+	518,
+	583,
+	519,
+	584,
+	520,
+	584,
+	519,
+	584,
+	520,
+	585,
+	521,
+	585,
+	520,
+	585,
+	521,
+	586,
+	522,
+	586,
+	521,
+	586,
+	522,
+	587,
+	523,
+	587,
+	522,
+	587,
+	523,
+	588,
+	524,
+	588,
+	523,
+	588,
+	524,
+	589,
+	525,
+	589,
+	524,
+	589,
+	525,
+	590,
+	526,
+	590,
+	525,
+	590,
+	526,
+	591,
+	527,
+	591,
+	526,
+	591,
+	527,
+	592,
+	528,
+	592,
+	527,
+	592,
+	528,
+	593,
+	529,
+	593,
+	528,
+	593,
+	529,
+	594,
+	530,
+	594,
+	529,
+	594,
+	530,
+	595,
+	531,
+	595,
+	530,
+	595,
+	531,
+	596,
+	532,
+	596,
+	531,
+	596,
+	532,
+	597,
+	533,
+	597,
+	532,
+	597,
+	533,
+	598,
+	534,
+	598,
+	533,
+	598,
+	534,
+	599,
+	535,
+	599,
+	534,
+	599,
+	535,
+	600,
+	536,
+	600,
+	535,
+	600,
+	536,
+	601,
+	537,
+	601,
+	536,
+	601,
+	537,
+	602,
+	538,
+	602,
+	537,
+	602,
+	538,
+	603,
+	539,
+	603,
+	538,
+	603,
+	539,
+	604,
+	540,
+	604,
+	539,
+	604,
+	540,
+	605,
+	541,
+	605,
+	540,
+	605,
+	541,
+	606,
+	542,
+	606,
+	541,
+	606,
+	542,
+	607,
+	543,
+	607,
+	542,
+	607,
+	543,
+	608,
+	544,
+	608,
+	543,
+	608,
+	544,
+	609,
+	545,
+	609,
+	544,
+	609,
+	545,
+	610,
+	546,
+	610,
+	545,
+	610,
+	546,
+	611,
+	547,
+	611,
+	546,
+	611,
+	547,
+	612,
+	548,
+	612,
+	547,
+	612,
+	548,
+	613,
+	549,
+	613,
+	548,
+	613,
+	549,
+	614,
+	550,
+	614,
+	549,
+	614,
+	550,
+	615,
+	551,
+	615,
+	550,
+	615,
+	551,
+	616,
+	552,
+	616,
+	551,
+	616,
+	552,
+	617,
+	553,
+	617,
+	552,
+	617,
+	553,
+	618,
+	554,
+	618,
+	553,
+	618,
+	554,
+	619,
+	555,
+	619,
+	554,
+	619,
+	555,
+	620,
+	556,
+	620,
+	555,
+	620,
+	556,
+	621,
+	557,
+	621,
+	556,
+	621,
+	557,
+	622,
+	558,
+	622,
+	557,
+	622,
+	558,
+	623,
+	559,
+	623,
+	558,
+	623,
+	559,
+	624,
+	560,
+	624,
+	559,
+	624,
+	560,
+	625,
+	561,
+	625,
+	560,
+	625,
+	561,
+	626,
+	562,
+	626,
+	561,
+	626,
+	562,
+	627,
+	563,
+	627,
+	562,
+	627,
+	563,
+	628,
+	564,
+	628,
+	563,
+	628,
+	564,
+	629,
+	565,
+	629,
+	564,
+	629,
+	565,
+	630,
+	566,
+	630,
+	565,
+	630,
+	566,
+	631,
+	567,
+	631,
+	566,
+	631,
+	567,
+	632,
+	568,
+	632,
+	567,
+	632,
+	568,
+	633,
+	569,
+	633,
+	568,
+	633,
+	569,
+	634,
+	570,
+	634,
+	569,
+	634,
+	570,
+	635,
+	571,
+	635,
+	570,
+	635,
+	571,
+	636,
+	572,
+	636,
+	571,
+	636,
+	572,
+	637,
+	573,
+	637,
+	572,
+	637,
+	573,
+	638,
+	574,
+	638,
+	573,
+	638,
+	574,
+	639,
+	575,
+	639,
+	574,
+	640,
+	576,
+	641,
+	577,
+	641,
+	576,
+	641,
+	577,
+	642,
+	578,
+	642,
+	577,
+	642,
+	578,
+	643,
+	579,
+	643,
+	578,
+	643,
+	579,
+	644,
+	580,
+	644,
+	579,
+	644,
+	580,
+	645,
+	581,
+	645,
+	580,
+	645,
+	581,
+	646,
+	582,
+	646,
+	581,
+	646,
+	582,
+	647,
+	583,
+	647,
+	582,
+	647,
+	583,
+	648,
+	584,
+	648,
+	583,
+	648,
+	584,
+	649,
+	585,
+	649,
+	584,
+	649,
+	585,
+	650,
+	586,
+	650,
+	585,
+	650,
+	586,
+	651,
+	587,
+	651,
+	586,
+	651,
+	587,
+	652,
+	588,
+	652,
+	587,
+	652,
+	588,
+	653,
+	589,
+	653,
+	588,
+	653,
+	589,
+	654,
+	590,
+	654,
+	589,
+	654,
+	590,
+	655,
+	591,
+	655,
+	590,
+	655,
+	591,
+	656,
+	592,
+	656,
+	591,
+	656,
+	592,
+	657,
+	593,
+	657,
+	592,
+	657,
+	593,
+	658,
+	594,
+	658,
+	593,
+	658,
+	594,
+	659,
+	595,
+	659,
+	594,
+	659,
+	595,
+	660,
+	596,
+	660,
+	595,
+	660,
+	596,
+	661,
+	597,
+	661,
+	596,
+	661,
+	597,
+	662,
+	598,
+	662,
+	597,
+	662,
+	598,
+	663,
+	599,
+	663,
+	598,
+	663,
+	599,
+	664,
+	600,
+	664,
+	599,
+	664,
+	600,
+	665,
+	601,
+	665,
+	600,
+	665,
+	601,
+	666,
+	602,
+	666,
+	601,
+	666,
+	602,
+	667,
+	603,
+	667,
+	602,
+	667,
+	603,
+	668,
+	604,
+	668,
+	603,
+	668,
+	604,
+	669,
+	605,
+	669,
+	604,
+	669,
+	605,
+	670,
+	606,
+	670,
+	605,
+	670,
+	606,
+	671,
+	607,
+	671,
+	606,
+	671,
+	607,
+	672,
+	608,
+	672,
+	607,
+	672,
+	608,
+	673,
+	609,
+	673,
+	608,
+	673,
+	609,
+	674,
+	610,
+	674,
+	609,
+	674,
+	610,
+	675,
+	611,
+	675,
+	610,
+	675,
+	611,
+	676,
+	612,
+	676,
+	611,
+	676,
+	612,
+	677,
+	613,
+	677,
+	612,
+	677,
+	613,
+	678,
+	614,
+	678,
+	613,
+	678,
+	614,
+	679,
+	615,
+	679,
+	614,
+	679,
+	615,
+	680,
+	616,
+	680,
+	615,
+	680,
+	616,
+	681,
+	617,
+	681,
+	616,
+	681,
+	617,
+	682,
+	618,
+	682,
+	617,
+	682,
+	618,
+	683,
+	619,
+	683,
+	618,
+	683,
+	619,
+	684,
+	620,
+	684,
+	619,
+	684,
+	620,
+	685,
+	621,
+	685,
+	620,
+	685,
+	621,
+	686,
+	622,
+	686,
+	621,
+	686,
+	622,
+	687,
+	623,
+	687,
+	622,
+	687,
+	623,
+	688,
+	624,
+	688,
+	623,
+	688,
+	624,
+	689,
+	625,
+	689,
+	624,
+	689,
+	625,
+	690,
+	626,
+	690,
+	625,
+	690,
+	626,
+	691,
+	627,
+	691,
+	626,
+	691,
+	627,
+	692,
+	628,
+	692,
+	627,
+	692,
+	628,
+	693,
+	629,
+	693,
+	628,
+	693,
+	629,
+	694,
+	630,
+	694,
+	629,
+	694,
+	630,
+	695,
+	631,
+	695,
+	630,
+	695,
+	631,
+	696,
+	632,
+	696,
+	631,
+	696,
+	632,
+	697,
+	633,
+	697,
+	632,
+	697,
+	633,
+	698,
+	634,
+	698,
+	633,
+	698,
+	634,
+	699,
+	635,
+	699,
+	634,
+	699,
+	635,
+	700,
+	636,
+	700,
+	635,
+	700,
+	636,
+	701,
+	637,
+	701,
+	636,
+	701,
+	637,
+	702,
+	638,
+	702,
+	637,
+	702,
+	638,
+	703,
+	639,
+	703,
+	638,
+	704,
+	640,
+	705,
+	641,
+	705,
+	640,
+	705,
+	641,
+	706,
+	642,
+	706,
+	641,
+	706,
+	642,
+	707,
+	643,
+	707,
+	642,
+	707,
+	643,
+	708,
+	644,
+	708,
+	643,
+	708,
+	644,
+	709,
+	645,
+	709,
+	644,
+	709,
+	645,
+	710,
+	646,
+	710,
+	645,
+	710,
+	646,
+	711,
+	647,
+	711,
+	646,
+	711,
+	647,
+	712,
+	648,
+	712,
+	647,
+	712,
+	648,
+	713,
+	649,
+	713,
+	648,
+	713,
+	649,
+	714,
+	650,
+	714,
+	649,
+	714,
+	650,
+	715,
+	651,
+	715,
+	650,
+	715,
+	651,
+	716,
+	652,
+	716,
+	651,
+	716,
+	652,
+	717,
+	653,
+	717,
+	652,
+	717,
+	653,
+	718,
+	654,
+	718,
+	653,
+	718,
+	654,
+	719,
+	655,
+	719,
+	654,
+	719,
+	655,
+	720,
+	656,
+	720,
+	655,
+	720,
+	656,
+	721,
+	657,
+	721,
+	656,
+	721,
+	657,
+	722,
+	658,
+	722,
+	657,
+	722,
+	658,
+	723,
+	659,
+	723,
+	658,
+	723,
+	659,
+	724,
+	660,
+	724,
+	659,
+	724,
+	660,
+	725,
+	661,
+	725,
+	660,
+	725,
+	661,
+	726,
+	662,
+	726,
+	661,
+	726,
+	662,
+	727,
+	663,
+	727,
+	662,
+	727,
+	663,
+	728,
+	664,
+	728,
+	663,
+	728,
+	664,
+	729,
+	665,
+	729,
+	664,
+	729,
+	665,
+	730,
+	666,
+	730,
+	665,
+	730,
+	666,
+	731,
+	667,
+	731,
+	666,
+	731,
+	667,
+	732,
+	668,
+	732,
+	667,
+	732,
+	668,
+	733,
+	669,
+	733,
+	668,
+	733,
+	669,
+	734,
+	670,
+	734,
+	669,
+	734,
+	670,
+	735,
+	671,
+	735,
+	670,
+	735,
+	671,
+	736,
+	672,
+	736,
+	671,
+	736,
+	672,
+	737,
+	673,
+	737,
+	672,
+	737,
+	673,
+	738,
+	674,
+	738,
+	673,
+	738,
+	674,
+	739,
+	675,
+	739,
+	674,
+	739,
+	675,
+	740,
+	676,
+	740,
+	675,
+	740,
+	676,
+	741,
+	677,
+	741,
+	676,
+	741,
+	677,
+	742,
+	678,
+	742,
+	677,
+	742,
+	678,
+	743,
+	679,
+	743,
+	678,
+	743,
+	679,
+	744,
+	680,
+	744,
+	679,
+	744,
+	680,
+	745,
+	681,
+	745,
+	680,
+	745,
+	681,
+	746,
+	682,
+	746,
+	681,
+	746,
+	682,
+	747,
+	683,
+	747,
+	682,
+	747,
+	683,
+	748,
+	684,
+	748,
+	683,
+	748,
+	684,
+	749,
+	685,
+	749,
+	684,
+	749,
+	685,
+	750,
+	686,
+	750,
+	685,
+	750,
+	686,
+	751,
+	687,
+	751,
+	686,
+	751,
+	687,
+	752,
+	688,
+	752,
+	687,
+	752,
+	688,
+	753,
+	689,
+	753,
+	688,
+	753,
+	689,
+	754,
+	690,
+	754,
+	689,
+	754,
+	690,
+	755,
+	691,
+	755,
+	690,
+	755,
+	691,
+	756,
+	692,
+	756,
+	691,
+	756,
+	692,
+	757,
+	693,
+	757,
+	692,
+	757,
+	693,
+	758,
+	694,
+	758,
+	693,
+	758,
+	694,
+	759,
+	695,
+	759,
+	694,
+	759,
+	695,
+	760,
+	696,
+	760,
+	695,
+	760,
+	696,
+	761,
+	697,
+	761,
+	696,
+	761,
+	697,
+	762,
+	698,
+	762,
+	697,
+	762,
+	698,
+	763,
+	699,
+	763,
+	698,
+	763,
+	699,
+	764,
+	700,
+	764,
+	699,
+	764,
+	700,
+	765,
+	701,
+	765,
+	700,
+	765,
+	701,
+	766,
+	702,
+	766,
+	701,
+	766,
+	702,
+	767,
+	703,
+	767,
+	702,
+	768,
+	704,
+	769,
+	705,
+	769,
+	704,
+	769,
+	705,
+	770,
+	706,
+	770,
+	705,
+	770,
+	706,
+	771,
+	707,
+	771,
+	706,
+	771,
+	707,
+	772,
+	708,
+	772,
+	707,
+	772,
+	708,
+	773,
+	709,
+	773,
+	708,
+	773,
+	709,
+	774,
+	710,
+	774,
+	709,
+	774,
+	710,
+	775,
+	711,
+	775,
+	710,
+	775,
+	711,
+	776,
+	712,
+	776,
+	711,
+	776,
+	712,
+	777,
+	713,
+	777,
+	712,
+	777,
+	713,
+	778,
+	714,
+	778,
+	713,
+	778,
+	714,
+	779,
+	715,
+	779,
+	714,
+	779,
+	715,
+	780,
+	716,
+	780,
+	715,
+	780,
+	716,
+	781,
+	717,
+	781,
+	716,
+	781,
+	717,
+	782,
+	718,
+	782,
+	717,
+	782,
+	718,
+	783,
+	719,
+	783,
+	718,
+	783,
+	719,
+	784,
+	720,
+	784,
+	719,
+	784,
+	720,
+	785,
+	721,
+	785,
+	720,
+	785,
+	721,
+	786,
+	722,
+	786,
+	721,
+	786,
+	722,
+	787,
+	723,
+	787,
+	722,
+	787,
+	723,
+	788,
+	724,
+	788,
+	723,
+	788,
+	724,
+	789,
+	725,
+	789,
+	724,
+	789,
+	725,
+	790,
+	726,
+	790,
+	725,
+	790,
+	726,
+	791,
+	727,
+	791,
+	726,
+	791,
+	727,
+	792,
+	728,
+	792,
+	727,
+	792,
+	728,
+	793,
+	729,
+	793,
+	728,
+	793,
+	729,
+	794,
+	730,
+	794,
+	729,
+	794,
+	730,
+	795,
+	731,
+	795,
+	730,
+	795,
+	731,
+	796,
+	732,
+	796,
+	731,
+	796,
+	732,
+	797,
+	733,
+	797,
+	732,
+	797,
+	733,
+	798,
+	734,
+	798,
+	733,
+	798,
+	734,
+	799,
+	735,
+	799,
+	734,
+	799,
+	735,
+	800,
+	736,
+	800,
+	735,
+	800,
+	736,
+	801,
+	737,
+	801,
+	736,
+	801,
+	737,
+	802,
+	738,
+	802,
+	737,
+	802,
+	738,
+	803,
+	739,
+	803,
+	738,
+	803,
+	739,
+	804,
+	740,
+	804,
+	739,
+	804,
+	740,
+	805,
+	741,
+	805,
+	740,
+	805,
+	741,
+	806,
+	742,
+	806,
+	741,
+	806,
+	742,
+	807,
+	743,
+	807,
+	742,
+	807,
+	743,
+	808,
+	744,
+	808,
+	743,
+	808,
+	744,
+	809,
+	745,
+	809,
+	744,
+	809,
+	745,
+	810,
+	746,
+	810,
+	745,
+	810,
+	746,
+	811,
+	747,
+	811,
+	746,
+	811,
+	747,
+	812,
+	748,
+	812,
+	747,
+	812,
+	748,
+	813,
+	749,
+	813,
+	748,
+	813,
+	749,
+	814,
+	750,
+	814,
+	749,
+	814,
+	750,
+	815,
+	751,
+	815,
+	750,
+	815,
+	751,
+	816,
+	752,
+	816,
+	751,
+	816,
+	752,
+	817,
+	753,
+	817,
+	752,
+	817,
+	753,
+	818,
+	754,
+	818,
+	753,
+	818,
+	754,
+	819,
+	755,
+	819,
+	754,
+	819,
+	755,
+	820,
+	756,
+	820,
+	755,
+	820,
+	756,
+	821,
+	757,
+	821,
+	756,
+	821,
+	757,
+	822,
+	758,
+	822,
+	757,
+	822,
+	758,
+	823,
+	759,
+	823,
+	758,
+	823,
+	759,
+	824,
+	760,
+	824,
+	759,
+	824,
+	760,
+	825,
+	761,
+	825,
+	760,
+	825,
+	761,
+	826,
+	762,
+	826,
+	761,
+	826,
+	762,
+	827,
+	763,
+	827,
+	762,
+	827,
+	763,
+	828,
+	764,
+	828,
+	763,
+	828,
+	764,
+	829,
+	765,
+	829,
+	764,
+	829,
+	765,
+	830,
+	766,
+	830,
+	765,
+	830,
+	766,
+	831,
+	767,
+	831,
+	766,
+	832,
+	768,
+	833,
+	769,
+	833,
+	768,
+	833,
+	769,
+	834,
+	770,
+	834,
+	769,
+	834,
+	770,
+	835,
+	771,
+	835,
+	770,
+	835,
+	771,
+	836,
+	772,
+	836,
+	771,
+	836,
+	772,
+	837,
+	773,
+	837,
+	772,
+	837,
+	773,
+	838,
+	774,
+	838,
+	773,
+	838,
+	774,
+	839,
+	775,
+	839,
+	774,
+	839,
+	775,
+	840,
+	776,
+	840,
+	775,
+	840,
+	776,
+	841,
+	777,
+	841,
+	776,
+	841,
+	777,
+	842,
+	778,
+	842,
+	777,
+	842,
+	778,
+	843,
+	779,
+	843,
+	778,
+	843,
+	779,
+	844,
+	780,
+	844,
+	779,
+	844,
+	780,
+	845,
+	781,
+	845,
+	780,
+	845,
+	781,
+	846,
+	782,
+	846,
+	781,
+	846,
+	782,
+	847,
+	783,
+	847,
+	782,
+	847,
+	783,
+	848,
+	784,
+	848,
+	783,
+	848,
+	784,
+	849,
+	785,
+	849,
+	784,
+	849,
+	785,
+	850,
+	786,
+	850,
+	785,
+	850,
+	786,
+	851,
+	787,
+	851,
+	786,
+	851,
+	787,
+	852,
+	788,
+	852,
+	787,
+	852,
+	788,
+	853,
+	789,
+	853,
+	788,
+	853,
+	789,
+	854,
+	790,
+	854,
+	789,
+	854,
+	790,
+	855,
+	791,
+	855,
+	790,
+	855,
+	791,
+	856,
+	792,
+	856,
+	791,
+	856,
+	792,
+	857,
+	793,
+	857,
+	792,
+	857,
+	793,
+	858,
+	794,
+	858,
+	793,
+	858,
+	794,
+	859,
+	795,
+	859,
+	794,
+	859,
+	795,
+	860,
+	796,
+	860,
+	795,
+	860,
+	796,
+	861,
+	797,
+	861,
+	796,
+	861,
+	797,
+	862,
+	798,
+	862,
+	797,
+	862,
+	798,
+	863,
+	799,
+	863,
+	798,
+	863,
+	799,
+	864,
+	800,
+	864,
+	799,
+	864,
+	800,
+	865,
+	801,
+	865,
+	800,
+	865,
+	801,
+	866,
+	802,
+	866,
+	801,
+	866,
+	802,
+	867,
+	803,
+	867,
+	802,
+	867,
+	803,
+	868,
+	804,
+	868,
+	803,
+	868,
+	804,
+	869,
+	805,
+	869,
+	804,
+	869,
+	805,
+	870,
+	806,
+	870,
+	805,
+	870,
+	806,
+	871,
+	807,
+	871,
+	806,
+	871,
+	807,
+	872,
+	808,
+	872,
+	807,
+	872,
+	808,
+	873,
+	809,
+	873,
+	808,
+	873,
+	809,
+	874,
+	810,
+	874,
+	809,
+	874,
+	810,
+	875,
+	811,
+	875,
+	810,
+	875,
+	811,
+	876,
+	812,
+	876,
+	811,
+	876,
+	812,
+	877,
+	813,
+	877,
+	812,
+	877,
+	813,
+	878,
+	814,
+	878,
+	813,
+	878,
+	814,
+	879,
+	815,
+	879,
+	814,
+	879,
+	815,
+	880,
+	816,
+	880,
+	815,
+	880,
+	816,
+	881,
+	817,
+	881,
+	816,
+	881,
+	817,
+	882,
+	818,
+	882,
+	817,
+	882,
+	818,
+	883,
+	819,
+	883,
+	818,
+	883,
+	819,
+	884,
+	820,
+	884,
+	819,
+	884,
+	820,
+	885,
+	821,
+	885,
+	820,
+	885,
+	821,
+	886,
+	822,
+	886,
+	821,
+	886,
+	822,
+	887,
+	823,
+	887,
+	822,
+	887,
+	823,
+	888,
+	824,
+	888,
+	823,
+	888,
+	824,
+	889,
+	825,
+	889,
+	824,
+	889,
+	825,
+	890,
+	826,
+	890,
+	825,
+	890,
+	826,
+	891,
+	827,
+	891,
+	826,
+	891,
+	827,
+	892,
+	828,
+	892,
+	827,
+	892,
+	828,
+	893,
+	829,
+	893,
+	828,
+	893,
+	829,
+	894,
+	830,
+	894,
+	829,
+	894,
+	830,
+	895,
+	831,
+	895,
+	830,
+	896,
+	832,
+	897,
+	833,
+	897,
+	832,
+	897,
+	833,
+	898,
+	834,
+	898,
+	833,
+	898,
+	834,
+	899,
+	835,
+	899,
+	834,
+	899,
+	835,
+	900,
+	836,
+	900,
+	835,
+	900,
+	836,
+	901,
+	837,
+	901,
+	836,
+	901,
+	837,
+	902,
+	838,
+	902,
+	837,
+	902,
+	838,
+	903,
+	839,
+	903,
+	838,
+	903,
+	839,
+	904,
+	840,
+	904,
+	839,
+	904,
+	840,
+	905,
+	841,
+	905,
+	840,
+	905,
+	841,
+	906,
+	842,
+	906,
+	841,
+	906,
+	842,
+	907,
+	843,
+	907,
+	842,
+	907,
+	843,
+	908,
+	844,
+	908,
+	843,
+	908,
+	844,
+	909,
+	845,
+	909,
+	844,
+	909,
+	845,
+	910,
+	846,
+	910,
+	845,
+	910,
+	846,
+	911,
+	847,
+	911,
+	846,
+	911,
+	847,
+	912,
+	848,
+	912,
+	847,
+	912,
+	848,
+	913,
+	849,
+	913,
+	848,
+	913,
+	849,
+	914,
+	850,
+	914,
+	849,
+	914,
+	850,
+	915,
+	851,
+	915,
+	850,
+	915,
+	851,
+	916,
+	852,
+	916,
+	851,
+	916,
+	852,
+	917,
+	853,
+	917,
+	852,
+	917,
+	853,
+	918,
+	854,
+	918,
+	853,
+	918,
+	854,
+	919,
+	855,
+	919,
+	854,
+	919,
+	855,
+	920,
+	856,
+	920,
+	855,
+	920,
+	856,
+	921,
+	857,
+	921,
+	856,
+	921,
+	857,
+	922,
+	858,
+	922,
+	857,
+	922,
+	858,
+	923,
+	859,
+	923,
+	858,
+	923,
+	859,
+	924,
+	860,
+	924,
+	859,
+	924,
+	860,
+	925,
+	861,
+	925,
+	860,
+	925,
+	861,
+	926,
+	862,
+	926,
+	861,
+	926,
+	862,
+	927,
+	863,
+	927,
+	862,
+	927,
+	863,
+	928,
+	864,
+	928,
+	863,
+	928,
+	864,
+	929,
+	865,
+	929,
+	864,
+	929,
+	865,
+	930,
+	866,
+	930,
+	865,
+	930,
+	866,
+	931,
+	867,
+	931,
+	866,
+	931,
+	867,
+	932,
+	868,
+	932,
+	867,
+	932,
+	868,
+	933,
+	869,
+	933,
+	868,
+	933,
+	869,
+	934,
+	870,
+	934,
+	869,
+	934,
+	870,
+	935,
+	871,
+	935,
+	870,
+	935,
+	871,
+	936,
+	872,
+	936,
+	871,
+	936,
+	872,
+	937,
+	873,
+	937,
+	872,
+	937,
+	873,
+	938,
+	874,
+	938,
+	873,
+	938,
+	874,
+	939,
+	875,
+	939,
+	874,
+	939,
+	875,
+	940,
+	876,
+	940,
+	875,
+	940,
+	876,
+	941,
+	877,
+	941,
+	876,
+	941,
+	877,
+	942,
+	878,
+	942,
+	877,
+	942,
+	878,
+	943,
+	879,
+	943,
+	878,
+	943,
+	879,
+	944,
+	880,
+	944,
+	879,
+	944,
+	880,
+	945,
+	881,
+	945,
+	880,
+	945,
+	881,
+	946,
+	882,
+	946,
+	881,
+	946,
+	882,
+	947,
+	883,
+	947,
+	882,
+	947,
+	883,
+	948,
+	884,
+	948,
+	883,
+	948,
+	884,
+	949,
+	885,
+	949,
+	884,
+	949,
+	885,
+	950,
+	886,
+	950,
+	885,
+	950,
+	886,
+	951,
+	887,
+	951,
+	886,
+	951,
+	887,
+	952,
+	888,
+	952,
+	887,
+	952,
+	888,
+	953,
+	889,
+	953,
+	888,
+	953,
+	889,
+	954,
+	890,
+	954,
+	889,
+	954,
+	890,
+	955,
+	891,
+	955,
+	890,
+	955,
+	891,
+	956,
+	892,
+	956,
+	891,
+	956,
+	892,
+	957,
+	893,
+	957,
+	892,
+	957,
+	893,
+	958,
+	894,
+	958,
+	893,
+	958,
+	894,
+	959,
+	895,
+	959,
+	894,
+	960,
+	896,
+	961,
+	897,
+	961,
+	896,
+	961,
+	897,
+	962,
+	898,
+	962,
+	897,
+	962,
+	898,
+	963,
+	899,
+	963,
+	898,
+	963,
+	899,
+	964,
+	900,
+	964,
+	899,
+	964,
+	900,
+	965,
+	901,
+	965,
+	900,
+	965,
+	901,
+	966,
+	902,
+	966,
+	901,
+	966,
+	902,
+	967,
+	903,
+	967,
+	902,
+	967,
+	903,
+	968,
+	904,
+	968,
+	903,
+	968,
+	904,
+	969,
+	905,
+	969,
+	904,
+	969,
+	905,
+	970,
+	906,
+	970,
+	905,
+	970,
+	906,
+	971,
+	907,
+	971,
+	906,
+	971,
+	907,
+	972,
+	908,
+	972,
+	907,
+	972,
+	908,
+	973,
+	909,
+	973,
+	908,
+	973,
+	909,
+	974,
+	910,
+	974,
+	909,
+	974,
+	910,
+	975,
+	911,
+	975,
+	910,
+	975,
+	911,
+	976,
+	912,
+	976,
+	911,
+	976,
+	912,
+	977,
+	913,
+	977,
+	912,
+	977,
+	913,
+	978,
+	914,
+	978,
+	913,
+	978,
+	914,
+	979,
+	915,
+	979,
+	914,
+	979,
+	915,
+	980,
+	916,
+	980,
+	915,
+	980,
+	916,
+	981,
+	917,
+	981,
+	916,
+	981,
+	917,
+	982,
+	918,
+	982,
+	917,
+	982,
+	918,
+	983,
+	919,
+	983,
+	918,
+	983,
+	919,
+	984,
+	920,
+	984,
+	919,
+	984,
+	920,
+	985,
+	921,
+	985,
+	920,
+	985,
+	921,
+	986,
+	922,
+	986,
+	921,
+	986,
+	922,
+	987,
+	923,
+	987,
+	922,
+	987,
+	923,
+	988,
+	924,
+	988,
+	923,
+	988,
+	924,
+	989,
+	925,
+	989,
+	924,
+	989,
+	925,
+	990,
+	926,
+	990,
+	925,
+	990,
+	926,
+	991,
+	927,
+	991,
+	926,
+	991,
+	927,
+	992,
+	928,
+	992,
+	927,
+	992,
+	928,
+	993,
+	929,
+	993,
+	928,
+	993,
+	929,
+	994,
+	930,
+	994,
+	929,
+	994,
+	930,
+	995,
+	931,
+	995,
+	930,
+	995,
+	931,
+	996,
+	932,
+	996,
+	931,
+	996,
+	932,
+	997,
+	933,
+	997,
+	932,
+	997,
+	933,
+	998,
+	934,
+	998,
+	933,
+	998,
+	934,
+	999,
+	935,
+	999,
+	934,
+	999,
+	935,
+	1000,
+	936,
+	1000,
+	935,
+	1000,
+	936,
+	1001,
+	937,
+	1001,
+	936,
+	1001,
+	937,
+	1002,
+	938,
+	1002,
+	937,
+	1002,
+	938,
+	1003,
+	939,
+	1003,
+	938,
+	1003,
+	939,
+	1004,
+	940,
+	1004,
+	939,
+	1004,
+	940,
+	1005,
+	941,
+	1005,
+	940,
+	1005,
+	941,
+	1006,
+	942,
+	1006,
+	941,
+	1006,
+	942,
+	1007,
+	943,
+	1007,
+	942,
+	1007,
+	943,
+	1008,
+	944,
+	1008,
+	943,
+	1008,
+	944,
+	1009,
+	945,
+	1009,
+	944,
+	1009,
+	945,
+	1010,
+	946,
+	1010,
+	945,
+	1010,
+	946,
+	1011,
+	947,
+	1011,
+	946,
+	1011,
+	947,
+	1012,
+	948,
+	1012,
+	947,
+	1012,
+	948,
+	1013,
+	949,
+	1013,
+	948,
+	1013,
+	949,
+	1014,
+	950,
+	1014,
+	949,
+	1014,
+	950,
+	1015,
+	951,
+	1015,
+	950,
+	1015,
+	951,
+	1016,
+	952,
+	1016,
+	951,
+	1016,
+	952,
+	1017,
+	953,
+	1017,
+	952,
+	1017,
+	953,
+	1018,
+	954,
+	1018,
+	953,
+	1018,
+	954,
+	1019,
+	955,
+	1019,
+	954,
+	1019,
+	955,
+	1020,
+	956,
+	1020,
+	955,
+	1020,
+	956,
+	1021,
+	957,
+	1021,
+	956,
+	1021,
+	957,
+	1022,
+	958,
+	1022,
+	957,
+	1022,
+	958,
+	1023,
+	959,
+	1023,
+	958,
+	1024,
+	960,
+	1025,
+	961,
+	1025,
+	960,
+	1025,
+	961,
+	1026,
+	962,
+	1026,
+	961,
+	1026,
+	962,
+	1027,
+	963,
+	1027,
+	962,
+	1027,
+	963,
+	1028,
+	964,
+	1028,
+	963,
+	1028,
+	964,
+	1029,
+	965,
+	1029,
+	964,
+	1029,
+	965,
+	1030,
+	966,
+	1030,
+	965,
+	1030,
+	966,
+	1031,
+	967,
+	1031,
+	966,
+	1031,
+	967,
+	1032,
+	968,
+	1032,
+	967,
+	1032,
+	968,
+	1033,
+	969,
+	1033,
+	968,
+	1033,
+	969,
+	1034,
+	970,
+	1034,
+	969,
+	1034,
+	970,
+	1035,
+	971,
+	1035,
+	970,
+	1035,
+	971,
+	1036,
+	972,
+	1036,
+	971,
+	1036,
+	972,
+	1037,
+	973,
+	1037,
+	972,
+	1037,
+	973,
+	1038,
+	974,
+	1038,
+	973,
+	1038,
+	974,
+	1039,
+	975,
+	1039,
+	974,
+	1039,
+	975,
+	1040,
+	976,
+	1040,
+	975,
+	1040,
+	976,
+	1041,
+	977,
+	1041,
+	976,
+	1041,
+	977,
+	1042,
+	978,
+	1042,
+	977,
+	1042,
+	978,
+	1043,
+	979,
+	1043,
+	978,
+	1043,
+	979,
+	1044,
+	980,
+	1044,
+	979,
+	1044,
+	980,
+	1045,
+	981,
+	1045,
+	980,
+	1045,
+	981,
+	1046,
+	982,
+	1046,
+	981,
+	1046,
+	982,
+	1047,
+	983,
+	1047,
+	982,
+	1047,
+	983,
+	1048,
+	984,
+	1048,
+	983,
+	1048,
+	984,
+	1049,
+	985,
+	1049,
+	984,
+	1049,
+	985,
+	1050,
+	986,
+	1050,
+	985,
+	1050,
+	986,
+	1051,
+	987,
+	1051,
+	986,
+	1051,
+	987,
+	1052,
+	988,
+	1052,
+	987,
+	1052,
+	988,
+	1053,
+	989,
+	1053,
+	988,
+	1053,
+	989,
+	1054,
+	990,
+	1054,
+	989,
+	1054,
+	990,
+	1055,
+	991,
+	1055,
+	990,
+	1055,
+	991,
+	1056,
+	992,
+	1056,
+	991,
+	1056,
+	992,
+	1057,
+	993,
+	1057,
+	992,
+	1057,
+	993,
+	1058,
+	994,
+	1058,
+	993,
+	1058,
+	994,
+	1059,
+	995,
+	1059,
+	994,
+	1059,
+	995,
+	1060,
+	996,
+	1060,
+	995,
+	1060,
+	996,
+	1061,
+	997,
+	1061,
+	996,
+	1061,
+	997,
+	1062,
+	998,
+	1062,
+	997,
+	1062,
+	998,
+	1063,
+	999,
+	1063,
+	998,
+	1063,
+	999,
+	1064,
+	1000,
+	1064,
+	999,
+	1064,
+	1000,
+	1065,
+	1001,
+	1065,
+	1000,
+	1065,
+	1001,
+	1066,
+	1002,
+	1066,
+	1001,
+	1066,
+	1002,
+	1067,
+	1003,
+	1067,
+	1002,
+	1067,
+	1003,
+	1068,
+	1004,
+	1068,
+	1003,
+	1068,
+	1004,
+	1069,
+	1005,
+	1069,
+	1004,
+	1069,
+	1005,
+	1070,
+	1006,
+	1070,
+	1005,
+	1070,
+	1006,
+	1071,
+	1007,
+	1071,
+	1006,
+	1071,
+	1007,
+	1072,
+	1008,
+	1072,
+	1007,
+	1072,
+	1008,
+	1073,
+	1009,
+	1073,
+	1008,
+	1073,
+	1009,
+	1074,
+	1010,
+	1074,
+	1009,
+	1074,
+	1010,
+	1075,
+	1011,
+	1075,
+	1010,
+	1075,
+	1011,
+	1076,
+	1012,
+	1076,
+	1011,
+	1076,
+	1012,
+	1077,
+	1013,
+	1077,
+	1012,
+	1077,
+	1013,
+	1078,
+	1014,
+	1078,
+	1013,
+	1078,
+	1014,
+	1079,
+	1015,
+	1079,
+	1014,
+	1079,
+	1015,
+	1080,
+	1016,
+	1080,
+	1015,
+	1080,
+	1016,
+	1081,
+	1017,
+	1081,
+	1016,
+	1081,
+	1017,
+	1082,
+	1018,
+	1082,
+	1017,
+	1082,
+	1018,
+	1083,
+	1019,
+	1083,
+	1018,
+	1083,
+	1019,
+	1084,
+	1020,
+	1084,
+	1019,
+	1084,
+	1020,
+	1085,
+	1021,
+	1085,
+	1020,
+	1085,
+	1021,
+	1086,
+	1022,
+	1086,
+	1021,
+	1086,
+	1022,
+	1087,
+	1023,
+	1087,
+	1022,
+	1088,
+	1024,
+	1089,
+	1025,
+	1089,
+	1024,
+	1089,
+	1025,
+	1090,
+	1026,
+	1090,
+	1025,
+	1090,
+	1026,
+	1091,
+	1027,
+	1091,
+	1026,
+	1091,
+	1027,
+	1092,
+	1028,
+	1092,
+	1027,
+	1092,
+	1028,
+	1093,
+	1029,
+	1093,
+	1028,
+	1093,
+	1029,
+	1094,
+	1030,
+	1094,
+	1029,
+	1094,
+	1030,
+	1095,
+	1031,
+	1095,
+	1030,
+	1095,
+	1031,
+	1096,
+	1032,
+	1096,
+	1031,
+	1096,
+	1032,
+	1097,
+	1033,
+	1097,
+	1032,
+	1097,
+	1033,
+	1098,
+	1034,
+	1098,
+	1033,
+	1098,
+	1034,
+	1099,
+	1035,
+	1099,
+	1034,
+	1099,
+	1035,
+	1100,
+	1036,
+	1100,
+	1035,
+	1100,
+	1036,
+	1101,
+	1037,
+	1101,
+	1036,
+	1101,
+	1037,
+	1102,
+	1038,
+	1102,
+	1037,
+	1102,
+	1038,
+	1103,
+	1039,
+	1103,
+	1038,
+	1103,
+	1039,
+	1104,
+	1040,
+	1104,
+	1039,
+	1104,
+	1040,
+	1105,
+	1041,
+	1105,
+	1040,
+	1105,
+	1041,
+	1106,
+	1042,
+	1106,
+	1041,
+	1106,
+	1042,
+	1107,
+	1043,
+	1107,
+	1042,
+	1107,
+	1043,
+	1108,
+	1044,
+	1108,
+	1043,
+	1108,
+	1044,
+	1109,
+	1045,
+	1109,
+	1044,
+	1109,
+	1045,
+	1110,
+	1046,
+	1110,
+	1045,
+	1110,
+	1046,
+	1111,
+	1047,
+	1111,
+	1046,
+	1111,
+	1047,
+	1112,
+	1048,
+	1112,
+	1047,
+	1112,
+	1048,
+	1113,
+	1049,
+	1113,
+	1048,
+	1113,
+	1049,
+	1114,
+	1050,
+	1114,
+	1049,
+	1114,
+	1050,
+	1115,
+	1051,
+	1115,
+	1050,
+	1115,
+	1051,
+	1116,
+	1052,
+	1116,
+	1051,
+	1116,
+	1052,
+	1117,
+	1053,
+	1117,
+	1052,
+	1117,
+	1053,
+	1118,
+	1054,
+	1118,
+	1053,
+	1118,
+	1054,
+	1119,
+	1055,
+	1119,
+	1054,
+	1119,
+	1055,
+	1120,
+	1056,
+	1120,
+	1055,
+	1120,
+	1056,
+	1121,
+	1057,
+	1121,
+	1056,
+	1121,
+	1057,
+	1122,
+	1058,
+	1122,
+	1057,
+	1122,
+	1058,
+	1123,
+	1059,
+	1123,
+	1058,
+	1123,
+	1059,
+	1124,
+	1060,
+	1124,
+	1059,
+	1124,
+	1060,
+	1125,
+	1061,
+	1125,
+	1060,
+	1125,
+	1061,
+	1126,
+	1062,
+	1126,
+	1061,
+	1126,
+	1062,
+	1127,
+	1063,
+	1127,
+	1062,
+	1127,
+	1063,
+	1128,
+	1064,
+	1128,
+	1063,
+	1128,
+	1064,
+	1129,
+	1065,
+	1129,
+	1064,
+	1129,
+	1065,
+	1130,
+	1066,
+	1130,
+	1065,
+	1130,
+	1066,
+	1131,
+	1067,
+	1131,
+	1066,
+	1131,
+	1067,
+	1132,
+	1068,
+	1132,
+	1067,
+	1132,
+	1068,
+	1133,
+	1069,
+	1133,
+	1068,
+	1133,
+	1069,
+	1134,
+	1070,
+	1134,
+	1069,
+	1134,
+	1070,
+	1135,
+	1071,
+	1135,
+	1070,
+	1135,
+	1071,
+	1136,
+	1072,
+	1136,
+	1071,
+	1136,
+	1072,
+	1137,
+	1073,
+	1137,
+	1072,
+	1137,
+	1073,
+	1138,
+	1074,
+	1138,
+	1073,
+	1138,
+	1074,
+	1139,
+	1075,
+	1139,
+	1074,
+	1139,
+	1075,
+	1140,
+	1076,
+	1140,
+	1075,
+	1140,
+	1076,
+	1141,
+	1077,
+	1141,
+	1076,
+	1141,
+	1077,
+	1142,
+	1078,
+	1142,
+	1077,
+	1142,
+	1078,
+	1143,
+	1079,
+	1143,
+	1078,
+	1143,
+	1079,
+	1144,
+	1080,
+	1144,
+	1079,
+	1144,
+	1080,
+	1145,
+	1081,
+	1145,
+	1080,
+	1145,
+	1081,
+	1146,
+	1082,
+	1146,
+	1081,
+	1146,
+	1082,
+	1147,
+	1083,
+	1147,
+	1082,
+	1147,
+	1083,
+	1148,
+	1084,
+	1148,
+	1083,
+	1148,
+	1084,
+	1149,
+	1085,
+	1149,
+	1084,
+	1149,
+	1085,
+	1150,
+	1086,
+	1150,
+	1085,
+	1150,
+	1086,
+	1151,
+	1087,
+	1151,
+	1086,
+	1152,
+	1088,
+	1153,
+	1089,
+	1153,
+	1088,
+	1153,
+	1089,
+	1154,
+	1090,
+	1154,
+	1089,
+	1154,
+	1090,
+	1155,
+	1091,
+	1155,
+	1090,
+	1155,
+	1091,
+	1156,
+	1092,
+	1156,
+	1091,
+	1156,
+	1092,
+	1157,
+	1093,
+	1157,
+	1092,
+	1157,
+	1093,
+	1158,
+	1094,
+	1158,
+	1093,
+	1158,
+	1094,
+	1159,
+	1095,
+	1159,
+	1094,
+	1159,
+	1095,
+	1160,
+	1096,
+	1160,
+	1095,
+	1160,
+	1096,
+	1161,
+	1097,
+	1161,
+	1096,
+	1161,
+	1097,
+	1162,
+	1098,
+	1162,
+	1097,
+	1162,
+	1098,
+	1163,
+	1099,
+	1163,
+	1098,
+	1163,
+	1099,
+	1164,
+	1100,
+	1164,
+	1099,
+	1164,
+	1100,
+	1165,
+	1101,
+	1165,
+	1100,
+	1165,
+	1101,
+	1166,
+	1102,
+	1166,
+	1101,
+	1166,
+	1102,
+	1167,
+	1103,
+	1167,
+	1102,
+	1167,
+	1103,
+	1168,
+	1104,
+	1168,
+	1103,
+	1168,
+	1104,
+	1169,
+	1105,
+	1169,
+	1104,
+	1169,
+	1105,
+	1170,
+	1106,
+	1170,
+	1105,
+	1170,
+	1106,
+	1171,
+	1107,
+	1171,
+	1106,
+	1171,
+	1107,
+	1172,
+	1108,
+	1172,
+	1107,
+	1172,
+	1108,
+	1173,
+	1109,
+	1173,
+	1108,
+	1173,
+	1109,
+	1174,
+	1110,
+	1174,
+	1109,
+	1174,
+	1110,
+	1175,
+	1111,
+	1175,
+	1110,
+	1175,
+	1111,
+	1176,
+	1112,
+	1176,
+	1111,
+	1176,
+	1112,
+	1177,
+	1113,
+	1177,
+	1112,
+	1177,
+	1113,
+	1178,
+	1114,
+	1178,
+	1113,
+	1178,
+	1114,
+	1179,
+	1115,
+	1179,
+	1114,
+	1179,
+	1115,
+	1180,
+	1116,
+	1180,
+	1115,
+	1180,
+	1116,
+	1181,
+	1117,
+	1181,
+	1116,
+	1181,
+	1117,
+	1182,
+	1118,
+	1182,
+	1117,
+	1182,
+	1118,
+	1183,
+	1119,
+	1183,
+	1118,
+	1183,
+	1119,
+	1184,
+	1120,
+	1184,
+	1119,
+	1184,
+	1120,
+	1185,
+	1121,
+	1185,
+	1120,
+	1185,
+	1121,
+	1186,
+	1122,
+	1186,
+	1121,
+	1186,
+	1122,
+	1187,
+	1123,
+	1187,
+	1122,
+	1187,
+	1123,
+	1188,
+	1124,
+	1188,
+	1123,
+	1188,
+	1124,
+	1189,
+	1125,
+	1189,
+	1124,
+	1189,
+	1125,
+	1190,
+	1126,
+	1190,
+	1125,
+	1190,
+	1126,
+	1191,
+	1127,
+	1191,
+	1126,
+	1191,
+	1127,
+	1192,
+	1128,
+	1192,
+	1127,
+	1192,
+	1128,
+	1193,
+	1129,
+	1193,
+	1128,
+	1193,
+	1129,
+	1194,
+	1130,
+	1194,
+	1129,
+	1194,
+	1130,
+	1195,
+	1131,
+	1195,
+	1130,
+	1195,
+	1131,
+	1196,
+	1132,
+	1196,
+	1131,
+	1196,
+	1132,
+	1197,
+	1133,
+	1197,
+	1132,
+	1197,
+	1133,
+	1198,
+	1134,
+	1198,
+	1133,
+	1198,
+	1134,
+	1199,
+	1135,
+	1199,
+	1134,
+	1199,
+	1135,
+	1200,
+	1136,
+	1200,
+	1135,
+	1200,
+	1136,
+	1201,
+	1137,
+	1201,
+	1136,
+	1201,
+	1137,
+	1202,
+	1138,
+	1202,
+	1137,
+	1202,
+	1138,
+	1203,
+	1139,
+	1203,
+	1138,
+	1203,
+	1139,
+	1204,
+	1140,
+	1204,
+	1139,
+	1204,
+	1140,
+	1205,
+	1141,
+	1205,
+	1140,
+	1205,
+	1141,
+	1206,
+	1142,
+	1206,
+	1141,
+	1206,
+	1142,
+	1207,
+	1143,
+	1207,
+	1142,
+	1207,
+	1143,
+	1208,
+	1144,
+	1208,
+	1143,
+	1208,
+	1144,
+	1209,
+	1145,
+	1209,
+	1144,
+	1209,
+	1145,
+	1210,
+	1146,
+	1210,
+	1145,
+	1210,
+	1146,
+	1211,
+	1147,
+	1211,
+	1146,
+	1211,
+	1147,
+	1212,
+	1148,
+	1212,
+	1147,
+	1212,
+	1148,
+	1213,
+	1149,
+	1213,
+	1148,
+	1213,
+	1149,
+	1214,
+	1150,
+	1214,
+	1149,
+	1214,
+	1150,
+	1215,
+	1151,
+	1215,
+	1150,
+	1216,
+	1152,
+	1217,
+	1153,
+	1217,
+	1152,
+	1217,
+	1153,
+	1218,
+	1154,
+	1218,
+	1153,
+	1218,
+	1154,
+	1219,
+	1155,
+	1219,
+	1154,
+	1219,
+	1155,
+	1220,
+	1156,
+	1220,
+	1155,
+	1220,
+	1156,
+	1221,
+	1157,
+	1221,
+	1156,
+	1221,
+	1157,
+	1222,
+	1158,
+	1222,
+	1157,
+	1222,
+	1158,
+	1223,
+	1159,
+	1223,
+	1158,
+	1223,
+	1159,
+	1224,
+	1160,
+	1224,
+	1159,
+	1224,
+	1160,
+	1225,
+	1161,
+	1225,
+	1160,
+	1225,
+	1161,
+	1226,
+	1162,
+	1226,
+	1161,
+	1226,
+	1162,
+	1227,
+	1163,
+	1227,
+	1162,
+	1227,
+	1163,
+	1228,
+	1164,
+	1228,
+	1163,
+	1228,
+	1164,
+	1229,
+	1165,
+	1229,
+	1164,
+	1229,
+	1165,
+	1230,
+	1166,
+	1230,
+	1165,
+	1230,
+	1166,
+	1231,
+	1167,
+	1231,
+	1166,
+	1231,
+	1167,
+	1232,
+	1168,
+	1232,
+	1167,
+	1232,
+	1168,
+	1233,
+	1169,
+	1233,
+	1168,
+	1233,
+	1169,
+	1234,
+	1170,
+	1234,
+	1169,
+	1234,
+	1170,
+	1235,
+	1171,
+	1235,
+	1170,
+	1235,
+	1171,
+	1236,
+	1172,
+	1236,
+	1171,
+	1236,
+	1172,
+	1237,
+	1173,
+	1237,
+	1172,
+	1237,
+	1173,
+	1238,
+	1174,
+	1238,
+	1173,
+	1238,
+	1174,
+	1239,
+	1175,
+	1239,
+	1174,
+	1239,
+	1175,
+	1240,
+	1176,
+	1240,
+	1175,
+	1240,
+	1176,
+	1241,
+	1177,
+	1241,
+	1176,
+	1241,
+	1177,
+	1242,
+	1178,
+	1242,
+	1177,
+	1242,
+	1178,
+	1243,
+	1179,
+	1243,
+	1178,
+	1243,
+	1179,
+	1244,
+	1180,
+	1244,
+	1179,
+	1244,
+	1180,
+	1245,
+	1181,
+	1245,
+	1180,
+	1245,
+	1181,
+	1246,
+	1182,
+	1246,
+	1181,
+	1246,
+	1182,
+	1247,
+	1183,
+	1247,
+	1182,
+	1247,
+	1183,
+	1248,
+	1184,
+	1248,
+	1183,
+	1248,
+	1184,
+	1249,
+	1185,
+	1249,
+	1184,
+	1249,
+	1185,
+	1250,
+	1186,
+	1250,
+	1185,
+	1250,
+	1186,
+	1251,
+	1187,
+	1251,
+	1186,
+	1251,
+	1187,
+	1252,
+	1188,
+	1252,
+	1187,
+	1252,
+	1188,
+	1253,
+	1189,
+	1253,
+	1188,
+	1253,
+	1189,
+	1254,
+	1190,
+	1254,
+	1189,
+	1254,
+	1190,
+	1255,
+	1191,
+	1255,
+	1190,
+	1255,
+	1191,
+	1256,
+	1192,
+	1256,
+	1191,
+	1256,
+	1192,
+	1257,
+	1193,
+	1257,
+	1192,
+	1257,
+	1193,
+	1258,
+	1194,
+	1258,
+	1193,
+	1258,
+	1194,
+	1259,
+	1195,
+	1259,
+	1194,
+	1259,
+	1195,
+	1260,
+	1196,
+	1260,
+	1195,
+	1260,
+	1196,
+	1261,
+	1197,
+	1261,
+	1196,
+	1261,
+	1197,
+	1262,
+	1198,
+	1262,
+	1197,
+	1262,
+	1198,
+	1263,
+	1199,
+	1263,
+	1198,
+	1263,
+	1199,
+	1264,
+	1200,
+	1264,
+	1199,
+	1264,
+	1200,
+	1265,
+	1201,
+	1265,
+	1200,
+	1265,
+	1201,
+	1266,
+	1202,
+	1266,
+	1201,
+	1266,
+	1202,
+	1267,
+	1203,
+	1267,
+	1202,
+	1267,
+	1203,
+	1268,
+	1204,
+	1268,
+	1203,
+	1268,
+	1204,
+	1269,
+	1205,
+	1269,
+	1204,
+	1269,
+	1205,
+	1270,
+	1206,
+	1270,
+	1205,
+	1270,
+	1206,
+	1271,
+	1207,
+	1271,
+	1206,
+	1271,
+	1207,
+	1272,
+	1208,
+	1272,
+	1207,
+	1272,
+	1208,
+	1273,
+	1209,
+	1273,
+	1208,
+	1273,
+	1209,
+	1274,
+	1210,
+	1274,
+	1209,
+	1274,
+	1210,
+	1275,
+	1211,
+	1275,
+	1210,
+	1275,
+	1211,
+	1276,
+	1212,
+	1276,
+	1211,
+	1276,
+	1212,
+	1277,
+	1213,
+	1277,
+	1212,
+	1277,
+	1213,
+	1278,
+	1214,
+	1278,
+	1213,
+	1278,
+	1214,
+	1279,
+	1215,
+	1279,
+	1214,
+	1280,
+	1216,
+	1281,
+	1217,
+	1281,
+	1216,
+	1281,
+	1217,
+	1282,
+	1218,
+	1282,
+	1217,
+	1282,
+	1218,
+	1283,
+	1219,
+	1283,
+	1218,
+	1283,
+	1219,
+	1284,
+	1220,
+	1284,
+	1219,
+	1284,
+	1220,
+	1285,
+	1221,
+	1285,
+	1220,
+	1285,
+	1221,
+	1286,
+	1222,
+	1286,
+	1221,
+	1286,
+	1222,
+	1287,
+	1223,
+	1287,
+	1222,
+	1287,
+	1223,
+	1288,
+	1224,
+	1288,
+	1223,
+	1288,
+	1224,
+	1289,
+	1225,
+	1289,
+	1224,
+	1289,
+	1225,
+	1290,
+	1226,
+	1290,
+	1225,
+	1290,
+	1226,
+	1291,
+	1227,
+	1291,
+	1226,
+	1291,
+	1227,
+	1292,
+	1228,
+	1292,
+	1227,
+	1292,
+	1228,
+	1293,
+	1229,
+	1293,
+	1228,
+	1293,
+	1229,
+	1294,
+	1230,
+	1294,
+	1229,
+	1294,
+	1230,
+	1295,
+	1231,
+	1295,
+	1230,
+	1295,
+	1231,
+	1296,
+	1232,
+	1296,
+	1231,
+	1296,
+	1232,
+	1297,
+	1233,
+	1297,
+	1232,
+	1297,
+	1233,
+	1298,
+	1234,
+	1298,
+	1233,
+	1298,
+	1234,
+	1299,
+	1235,
+	1299,
+	1234,
+	1299,
+	1235,
+	1300,
+	1236,
+	1300,
+	1235,
+	1300,
+	1236,
+	1301,
+	1237,
+	1301,
+	1236,
+	1301,
+	1237,
+	1302,
+	1238,
+	1302,
+	1237,
+	1302,
+	1238,
+	1303,
+	1239,
+	1303,
+	1238,
+	1303,
+	1239,
+	1304,
+	1240,
+	1304,
+	1239,
+	1304,
+	1240,
+	1305,
+	1241,
+	1305,
+	1240,
+	1305,
+	1241,
+	1306,
+	1242,
+	1306,
+	1241,
+	1306,
+	1242,
+	1307,
+	1243,
+	1307,
+	1242,
+	1307,
+	1243,
+	1308,
+	1244,
+	1308,
+	1243,
+	1308,
+	1244,
+	1309,
+	1245,
+	1309,
+	1244,
+	1309,
+	1245,
+	1310,
+	1246,
+	1310,
+	1245,
+	1310,
+	1246,
+	1311,
+	1247,
+	1311,
+	1246,
+	1311,
+	1247,
+	1312,
+	1248,
+	1312,
+	1247,
+	1312,
+	1248,
+	1313,
+	1249,
+	1313,
+	1248,
+	1313,
+	1249,
+	1314,
+	1250,
+	1314,
+	1249,
+	1314,
+	1250,
+	1315,
+	1251,
+	1315,
+	1250,
+	1315,
+	1251,
+	1316,
+	1252,
+	1316,
+	1251,
+	1316,
+	1252,
+	1317,
+	1253,
+	1317,
+	1252,
+	1317,
+	1253,
+	1318,
+	1254,
+	1318,
+	1253,
+	1318,
+	1254,
+	1319,
+	1255,
+	1319,
+	1254,
+	1319,
+	1255,
+	1320,
+	1256,
+	1320,
+	1255,
+	1320,
+	1256,
+	1321,
+	1257,
+	1321,
+	1256,
+	1321,
+	1257,
+	1322,
+	1258,
+	1322,
+	1257,
+	1322,
+	1258,
+	1323,
+	1259,
+	1323,
+	1258,
+	1323,
+	1259,
+	1324,
+	1260,
+	1324,
+	1259,
+	1324,
+	1260,
+	1325,
+	1261,
+	1325,
+	1260,
+	1325,
+	1261,
+	1326,
+	1262,
+	1326,
+	1261,
+	1326,
+	1262,
+	1327,
+	1263,
+	1327,
+	1262,
+	1327,
+	1263,
+	1328,
+	1264,
+	1328,
+	1263,
+	1328,
+	1264,
+	1329,
+	1265,
+	1329,
+	1264,
+	1329,
+	1265,
+	1330,
+	1266,
+	1330,
+	1265,
+	1330,
+	1266,
+	1331,
+	1267,
+	1331,
+	1266,
+	1331,
+	1267,
+	1332,
+	1268,
+	1332,
+	1267,
+	1332,
+	1268,
+	1333,
+	1269,
+	1333,
+	1268,
+	1333,
+	1269,
+	1334,
+	1270,
+	1334,
+	1269,
+	1334,
+	1270,
+	1335,
+	1271,
+	1335,
+	1270,
+	1335,
+	1271,
+	1336,
+	1272,
+	1336,
+	1271,
+	1336,
+	1272,
+	1337,
+	1273,
+	1337,
+	1272,
+	1337,
+	1273,
+	1338,
+	1274,
+	1338,
+	1273,
+	1338,
+	1274,
+	1339,
+	1275,
+	1339,
+	1274,
+	1339,
+	1275,
+	1340,
+	1276,
+	1340,
+	1275,
+	1340,
+	1276,
+	1341,
+	1277,
+	1341,
+	1276,
+	1341,
+	1277,
+	1342,
+	1278,
+	1342,
+	1277,
+	1342,
+	1278,
+	1343,
+	1279,
+	1343,
+	1278,
+	1344,
+	1280,
+	1345,
+	1281,
+	1345,
+	1280,
+	1345,
+	1281,
+	1346,
+	1282,
+	1346,
+	1281,
+	1346,
+	1282,
+	1347,
+	1283,
+	1347,
+	1282,
+	1347,
+	1283,
+	1348,
+	1284,
+	1348,
+	1283,
+	1348,
+	1284,
+	1349,
+	1285,
+	1349,
+	1284,
+	1349,
+	1285,
+	1350,
+	1286,
+	1350,
+	1285,
+	1350,
+	1286,
+	1351,
+	1287,
+	1351,
+	1286,
+	1351,
+	1287,
+	1352,
+	1288,
+	1352,
+	1287,
+	1352,
+	1288,
+	1353,
+	1289,
+	1353,
+	1288,
+	1353,
+	1289,
+	1354,
+	1290,
+	1354,
+	1289,
+	1354,
+	1290,
+	1355,
+	1291,
+	1355,
+	1290,
+	1355,
+	1291,
+	1356,
+	1292,
+	1356,
+	1291,
+	1356,
+	1292,
+	1357,
+	1293,
+	1357,
+	1292,
+	1357,
+	1293,
+	1358,
+	1294,
+	1358,
+	1293,
+	1358,
+	1294,
+	1359,
+	1295,
+	1359,
+	1294,
+	1359,
+	1295,
+	1360,
+	1296,
+	1360,
+	1295,
+	1360,
+	1296,
+	1361,
+	1297,
+	1361,
+	1296,
+	1361,
+	1297,
+	1362,
+	1298,
+	1362,
+	1297,
+	1362,
+	1298,
+	1363,
+	1299,
+	1363,
+	1298,
+	1363,
+	1299,
+	1364,
+	1300,
+	1364,
+	1299,
+	1364,
+	1300,
+	1365,
+	1301,
+	1365,
+	1300,
+	1365,
+	1301,
+	1366,
+	1302,
+	1366,
+	1301,
+	1366,
+	1302,
+	1367,
+	1303,
+	1367,
+	1302,
+	1367,
+	1303,
+	1368,
+	1304,
+	1368,
+	1303,
+	1368,
+	1304,
+	1369,
+	1305,
+	1369,
+	1304,
+	1369,
+	1305,
+	1370,
+	1306,
+	1370,
+	1305,
+	1370,
+	1306,
+	1371,
+	1307,
+	1371,
+	1306,
+	1371,
+	1307,
+	1372,
+	1308,
+	1372,
+	1307,
+	1372,
+	1308,
+	1373,
+	1309,
+	1373,
+	1308,
+	1373,
+	1309,
+	1374,
+	1310,
+	1374,
+	1309,
+	1374,
+	1310,
+	1375,
+	1311,
+	1375,
+	1310,
+	1375,
+	1311,
+	1376,
+	1312,
+	1376,
+	1311,
+	1376,
+	1312,
+	1377,
+	1313,
+	1377,
+	1312,
+	1377,
+	1313,
+	1378,
+	1314,
+	1378,
+	1313,
+	1378,
+	1314,
+	1379,
+	1315,
+	1379,
+	1314,
+	1379,
+	1315,
+	1380,
+	1316,
+	1380,
+	1315,
+	1380,
+	1316,
+	1381,
+	1317,
+	1381,
+	1316,
+	1381,
+	1317,
+	1382,
+	1318,
+	1382,
+	1317,
+	1382,
+	1318,
+	1383,
+	1319,
+	1383,
+	1318,
+	1383,
+	1319,
+	1384,
+	1320,
+	1384,
+	1319,
+	1384,
+	1320,
+	1385,
+	1321,
+	1385,
+	1320,
+	1385,
+	1321,
+	1386,
+	1322,
+	1386,
+	1321,
+	1386,
+	1322,
+	1387,
+	1323,
+	1387,
+	1322,
+	1387,
+	1323,
+	1388,
+	1324,
+	1388,
+	1323,
+	1388,
+	1324,
+	1389,
+	1325,
+	1389,
+	1324,
+	1389,
+	1325,
+	1390,
+	1326,
+	1390,
+	1325,
+	1390,
+	1326,
+	1391,
+	1327,
+	1391,
+	1326,
+	1391,
+	1327,
+	1392,
+	1328,
+	1392,
+	1327,
+	1392,
+	1328,
+	1393,
+	1329,
+	1393,
+	1328,
+	1393,
+	1329,
+	1394,
+	1330,
+	1394,
+	1329,
+	1394,
+	1330,
+	1395,
+	1331,
+	1395,
+	1330,
+	1395,
+	1331,
+	1396,
+	1332,
+	1396,
+	1331,
+	1396,
+	1332,
+	1397,
+	1333,
+	1397,
+	1332,
+	1397,
+	1333,
+	1398,
+	1334,
+	1398,
+	1333,
+	1398,
+	1334,
+	1399,
+	1335,
+	1399,
+	1334,
+	1399,
+	1335,
+	1400,
+	1336,
+	1400,
+	1335,
+	1400,
+	1336,
+	1401,
+	1337,
+	1401,
+	1336,
+	1401,
+	1337,
+	1402,
+	1338,
+	1402,
+	1337,
+	1402,
+	1338,
+	1403,
+	1339,
+	1403,
+	1338,
+	1403,
+	1339,
+	1404,
+	1340,
+	1404,
+	1339,
+	1404,
+	1340,
+	1405,
+	1341,
+	1405,
+	1340,
+	1405,
+	1341,
+	1406,
+	1342,
+	1406,
+	1341,
+	1406,
+	1342,
+	1407,
+	1343,
+	1407,
+	1342,
+	1408,
+	1344,
+	1409,
+	1345,
+	1409,
+	1344,
+	1409,
+	1345,
+	1410,
+	1346,
+	1410,
+	1345,
+	1410,
+	1346,
+	1411,
+	1347,
+	1411,
+	1346,
+	1411,
+	1347,
+	1412,
+	1348,
+	1412,
+	1347,
+	1412,
+	1348,
+	1413,
+	1349,
+	1413,
+	1348,
+	1413,
+	1349,
+	1414,
+	1350,
+	1414,
+	1349,
+	1414,
+	1350,
+	1415,
+	1351,
+	1415,
+	1350,
+	1415,
+	1351,
+	1416,
+	1352,
+	1416,
+	1351,
+	1416,
+	1352,
+	1417,
+	1353,
+	1417,
+	1352,
+	1417,
+	1353,
+	1418,
+	1354,
+	1418,
+	1353,
+	1418,
+	1354,
+	1419,
+	1355,
+	1419,
+	1354,
+	1419,
+	1355,
+	1420,
+	1356,
+	1420,
+	1355,
+	1420,
+	1356,
+	1421,
+	1357,
+	1421,
+	1356,
+	1421,
+	1357,
+	1422,
+	1358,
+	1422,
+	1357,
+	1422,
+	1358,
+	1423,
+	1359,
+	1423,
+	1358,
+	1423,
+	1359,
+	1424,
+	1360,
+	1424,
+	1359,
+	1424,
+	1360,
+	1425,
+	1361,
+	1425,
+	1360,
+	1425,
+	1361,
+	1426,
+	1362,
+	1426,
+	1361,
+	1426,
+	1362,
+	1427,
+	1363,
+	1427,
+	1362,
+	1427,
+	1363,
+	1428,
+	1364,
+	1428,
+	1363,
+	1428,
+	1364,
+	1429,
+	1365,
+	1429,
+	1364,
+	1429,
+	1365,
+	1430,
+	1366,
+	1430,
+	1365,
+	1430,
+	1366,
+	1431,
+	1367,
+	1431,
+	1366,
+	1431,
+	1367,
+	1432,
+	1368,
+	1432,
+	1367,
+	1432,
+	1368,
+	1433,
+	1369,
+	1433,
+	1368,
+	1433,
+	1369,
+	1434,
+	1370,
+	1434,
+	1369,
+	1434,
+	1370,
+	1435,
+	1371,
+	1435,
+	1370,
+	1435,
+	1371,
+	1436,
+	1372,
+	1436,
+	1371,
+	1436,
+	1372,
+	1437,
+	1373,
+	1437,
+	1372,
+	1437,
+	1373,
+	1438,
+	1374,
+	1438,
+	1373,
+	1438,
+	1374,
+	1439,
+	1375,
+	1439,
+	1374,
+	1439,
+	1375,
+	1440,
+	1376,
+	1440,
+	1375,
+	1440,
+	1376,
+	1441,
+	1377,
+	1441,
+	1376,
+	1441,
+	1377,
+	1442,
+	1378,
+	1442,
+	1377,
+	1442,
+	1378,
+	1443,
+	1379,
+	1443,
+	1378,
+	1443,
+	1379,
+	1444,
+	1380,
+	1444,
+	1379,
+	1444,
+	1380,
+	1445,
+	1381,
+	1445,
+	1380,
+	1445,
+	1381,
+	1446,
+	1382,
+	1446,
+	1381,
+	1446,
+	1382,
+	1447,
+	1383,
+	1447,
+	1382,
+	1447,
+	1383,
+	1448,
+	1384,
+	1448,
+	1383,
+	1448,
+	1384,
+	1449,
+	1385,
+	1449,
+	1384,
+	1449,
+	1385,
+	1450,
+	1386,
+	1450,
+	1385,
+	1450,
+	1386,
+	1451,
+	1387,
+	1451,
+	1386,
+	1451,
+	1387,
+	1452,
+	1388,
+	1452,
+	1387,
+	1452,
+	1388,
+	1453,
+	1389,
+	1453,
+	1388,
+	1453,
+	1389,
+	1454,
+	1390,
+	1454,
+	1389,
+	1454,
+	1390,
+	1455,
+	1391,
+	1455,
+	1390,
+	1455,
+	1391,
+	1456,
+	1392,
+	1456,
+	1391,
+	1456,
+	1392,
+	1457,
+	1393,
+	1457,
+	1392,
+	1457,
+	1393,
+	1458,
+	1394,
+	1458,
+	1393,
+	1458,
+	1394,
+	1459,
+	1395,
+	1459,
+	1394,
+	1459,
+	1395,
+	1460,
+	1396,
+	1460,
+	1395,
+	1460,
+	1396,
+	1461,
+	1397,
+	1461,
+	1396,
+	1461,
+	1397,
+	1462,
+	1398,
+	1462,
+	1397,
+	1462,
+	1398,
+	1463,
+	1399,
+	1463,
+	1398,
+	1463,
+	1399,
+	1464,
+	1400,
+	1464,
+	1399,
+	1464,
+	1400,
+	1465,
+	1401,
+	1465,
+	1400,
+	1465,
+	1401,
+	1466,
+	1402,
+	1466,
+	1401,
+	1466,
+	1402,
+	1467,
+	1403,
+	1467,
+	1402,
+	1467,
+	1403,
+	1468,
+	1404,
+	1468,
+	1403,
+	1468,
+	1404,
+	1469,
+	1405,
+	1469,
+	1404,
+	1469,
+	1405,
+	1470,
+	1406,
+	1470,
+	1405,
+	1470,
+	1406,
+	1471,
+	1407,
+	1471,
+	1406,
+	1472,
+	1408,
+	1473,
+	1409,
+	1473,
+	1408,
+	1473,
+	1409,
+	1474,
+	1410,
+	1474,
+	1409,
+	1474,
+	1410,
+	1475,
+	1411,
+	1475,
+	1410,
+	1475,
+	1411,
+	1476,
+	1412,
+	1476,
+	1411,
+	1476,
+	1412,
+	1477,
+	1413,
+	1477,
+	1412,
+	1477,
+	1413,
+	1478,
+	1414,
+	1478,
+	1413,
+	1478,
+	1414,
+	1479,
+	1415,
+	1479,
+	1414,
+	1479,
+	1415,
+	1480,
+	1416,
+	1480,
+	1415,
+	1480,
+	1416,
+	1481,
+	1417,
+	1481,
+	1416,
+	1481,
+	1417,
+	1482,
+	1418,
+	1482,
+	1417,
+	1482,
+	1418,
+	1483,
+	1419,
+	1483,
+	1418,
+	1483,
+	1419,
+	1484,
+	1420,
+	1484,
+	1419,
+	1484,
+	1420,
+	1485,
+	1421,
+	1485,
+	1420,
+	1485,
+	1421,
+	1486,
+	1422,
+	1486,
+	1421,
+	1486,
+	1422,
+	1487,
+	1423,
+	1487,
+	1422,
+	1487,
+	1423,
+	1488,
+	1424,
+	1488,
+	1423,
+	1488,
+	1424,
+	1489,
+	1425,
+	1489,
+	1424,
+	1489,
+	1425,
+	1490,
+	1426,
+	1490,
+	1425,
+	1490,
+	1426,
+	1491,
+	1427,
+	1491,
+	1426,
+	1491,
+	1427,
+	1492,
+	1428,
+	1492,
+	1427,
+	1492,
+	1428,
+	1493,
+	1429,
+	1493,
+	1428,
+	1493,
+	1429,
+	1494,
+	1430,
+	1494,
+	1429,
+	1494,
+	1430,
+	1495,
+	1431,
+	1495,
+	1430,
+	1495,
+	1431,
+	1496,
+	1432,
+	1496,
+	1431,
+	1496,
+	1432,
+	1497,
+	1433,
+	1497,
+	1432,
+	1497,
+	1433,
+	1498,
+	1434,
+	1498,
+	1433,
+	1498,
+	1434,
+	1499,
+	1435,
+	1499,
+	1434,
+	1499,
+	1435,
+	1500,
+	1436,
+	1500,
+	1435,
+	1500,
+	1436,
+	1501,
+	1437,
+	1501,
+	1436,
+	1501,
+	1437,
+	1502,
+	1438,
+	1502,
+	1437,
+	1502,
+	1438,
+	1503,
+	1439,
+	1503,
+	1438,
+	1503,
+	1439,
+	1504,
+	1440,
+	1504,
+	1439,
+	1504,
+	1440,
+	1505,
+	1441,
+	1505,
+	1440,
+	1505,
+	1441,
+	1506,
+	1442,
+	1506,
+	1441,
+	1506,
+	1442,
+	1507,
+	1443,
+	1507,
+	1442,
+	1507,
+	1443,
+	1508,
+	1444,
+	1508,
+	1443,
+	1508,
+	1444,
+	1509,
+	1445,
+	1509,
+	1444,
+	1509,
+	1445,
+	1510,
+	1446,
+	1510,
+	1445,
+	1510,
+	1446,
+	1511,
+	1447,
+	1511,
+	1446,
+	1511,
+	1447,
+	1512,
+	1448,
+	1512,
+	1447,
+	1512,
+	1448,
+	1513,
+	1449,
+	1513,
+	1448,
+	1513,
+	1449,
+	1514,
+	1450,
+	1514,
+	1449,
+	1514,
+	1450,
+	1515,
+	1451,
+	1515,
+	1450,
+	1515,
+	1451,
+	1516,
+	1452,
+	1516,
+	1451,
+	1516,
+	1452,
+	1517,
+	1453,
+	1517,
+	1452,
+	1517,
+	1453,
+	1518,
+	1454,
+	1518,
+	1453,
+	1518,
+	1454,
+	1519,
+	1455,
+	1519,
+	1454,
+	1519,
+	1455,
+	1520,
+	1456,
+	1520,
+	1455,
+	1520,
+	1456,
+	1521,
+	1457,
+	1521,
+	1456,
+	1521,
+	1457,
+	1522,
+	1458,
+	1522,
+	1457,
+	1522,
+	1458,
+	1523,
+	1459,
+	1523,
+	1458,
+	1523,
+	1459,
+	1524,
+	1460,
+	1524,
+	1459,
+	1524,
+	1460,
+	1525,
+	1461,
+	1525,
+	1460,
+	1525,
+	1461,
+	1526,
+	1462,
+	1526,
+	1461,
+	1526,
+	1462,
+	1527,
+	1463,
+	1527,
+	1462,
+	1527,
+	1463,
+	1528,
+	1464,
+	1528,
+	1463,
+	1528,
+	1464,
+	1529,
+	1465,
+	1529,
+	1464,
+	1529,
+	1465,
+	1530,
+	1466,
+	1530,
+	1465,
+	1530,
+	1466,
+	1531,
+	1467,
+	1531,
+	1466,
+	1531,
+	1467,
+	1532,
+	1468,
+	1532,
+	1467,
+	1532,
+	1468,
+	1533,
+	1469,
+	1533,
+	1468,
+	1533,
+	1469,
+	1534,
+	1470,
+	1534,
+	1469,
+	1534,
+	1470,
+	1535,
+	1471,
+	1535,
+	1470,
+	1536,
+	1472,
+	1537,
+	1473,
+	1537,
+	1472,
+	1537,
+	1473,
+	1538,
+	1474,
+	1538,
+	1473,
+	1538,
+	1474,
+	1539,
+	1475,
+	1539,
+	1474,
+	1539,
+	1475,
+	1540,
+	1476,
+	1540,
+	1475,
+	1540,
+	1476,
+	1541,
+	1477,
+	1541,
+	1476,
+	1541,
+	1477,
+	1542,
+	1478,
+	1542,
+	1477,
+	1542,
+	1478,
+	1543,
+	1479,
+	1543,
+	1478,
+	1543,
+	1479,
+	1544,
+	1480,
+	1544,
+	1479,
+	1544,
+	1480,
+	1545,
+	1481,
+	1545,
+	1480,
+	1545,
+	1481,
+	1546,
+	1482,
+	1546,
+	1481,
+	1546,
+	1482,
+	1547,
+	1483,
+	1547,
+	1482,
+	1547,
+	1483,
+	1548,
+	1484,
+	1548,
+	1483,
+	1548,
+	1484,
+	1549,
+	1485,
+	1549,
+	1484,
+	1549,
+	1485,
+	1550,
+	1486,
+	1550,
+	1485,
+	1550,
+	1486,
+	1551,
+	1487,
+	1551,
+	1486,
+	1551,
+	1487,
+	1552,
+	1488,
+	1552,
+	1487,
+	1552,
+	1488,
+	1553,
+	1489,
+	1553,
+	1488,
+	1553,
+	1489,
+	1554,
+	1490,
+	1554,
+	1489,
+	1554,
+	1490,
+	1555,
+	1491,
+	1555,
+	1490,
+	1555,
+	1491,
+	1556,
+	1492,
+	1556,
+	1491,
+	1556,
+	1492,
+	1557,
+	1493,
+	1557,
+	1492,
+	1557,
+	1493,
+	1558,
+	1494,
+	1558,
+	1493,
+	1558,
+	1494,
+	1559,
+	1495,
+	1559,
+	1494,
+	1559,
+	1495,
+	1560,
+	1496,
+	1560,
+	1495,
+	1560,
+	1496,
+	1561,
+	1497,
+	1561,
+	1496,
+	1561,
+	1497,
+	1562,
+	1498,
+	1562,
+	1497,
+	1562,
+	1498,
+	1563,
+	1499,
+	1563,
+	1498,
+	1563,
+	1499,
+	1564,
+	1500,
+	1564,
+	1499,
+	1564,
+	1500,
+	1565,
+	1501,
+	1565,
+	1500,
+	1565,
+	1501,
+	1566,
+	1502,
+	1566,
+	1501,
+	1566,
+	1502,
+	1567,
+	1503,
+	1567,
+	1502,
+	1567,
+	1503,
+	1568,
+	1504,
+	1568,
+	1503,
+	1568,
+	1504,
+	1569,
+	1505,
+	1569,
+	1504,
+	1569,
+	1505,
+	1570,
+	1506,
+	1570,
+	1505,
+	1570,
+	1506,
+	1571,
+	1507,
+	1571,
+	1506,
+	1571,
+	1507,
+	1572,
+	1508,
+	1572,
+	1507,
+	1572,
+	1508,
+	1573,
+	1509,
+	1573,
+	1508,
+	1573,
+	1509,
+	1574,
+	1510,
+	1574,
+	1509,
+	1574,
+	1510,
+	1575,
+	1511,
+	1575,
+	1510,
+	1575,
+	1511,
+	1576,
+	1512,
+	1576,
+	1511,
+	1576,
+	1512,
+	1577,
+	1513,
+	1577,
+	1512,
+	1577,
+	1513,
+	1578,
+	1514,
+	1578,
+	1513,
+	1578,
+	1514,
+	1579,
+	1515,
+	1579,
+	1514,
+	1579,
+	1515,
+	1580,
+	1516,
+	1580,
+	1515,
+	1580,
+	1516,
+	1581,
+	1517,
+	1581,
+	1516,
+	1581,
+	1517,
+	1582,
+	1518,
+	1582,
+	1517,
+	1582,
+	1518,
+	1583,
+	1519,
+	1583,
+	1518,
+	1583,
+	1519,
+	1584,
+	1520,
+	1584,
+	1519,
+	1584,
+	1520,
+	1585,
+	1521,
+	1585,
+	1520,
+	1585,
+	1521,
+	1586,
+	1522,
+	1586,
+	1521,
+	1586,
+	1522,
+	1587,
+	1523,
+	1587,
+	1522,
+	1587,
+	1523,
+	1588,
+	1524,
+	1588,
+	1523,
+	1588,
+	1524,
+	1589,
+	1525,
+	1589,
+	1524,
+	1589,
+	1525,
+	1590,
+	1526,
+	1590,
+	1525,
+	1590,
+	1526,
+	1591,
+	1527,
+	1591,
+	1526,
+	1591,
+	1527,
+	1592,
+	1528,
+	1592,
+	1527,
+	1592,
+	1528,
+	1593,
+	1529,
+	1593,
+	1528,
+	1593,
+	1529,
+	1594,
+	1530,
+	1594,
+	1529,
+	1594,
+	1530,
+	1595,
+	1531,
+	1595,
+	1530,
+	1595,
+	1531,
+	1596,
+	1532,
+	1596,
+	1531,
+	1596,
+	1532,
+	1597,
+	1533,
+	1597,
+	1532,
+	1597,
+	1533,
+	1598,
+	1534,
+	1598,
+	1533,
+	1598,
+	1534,
+	1599,
+	1535,
+	1599,
+	1534,
+	1600,
+	1536,
+	1601,
+	1537,
+	1601,
+	1536,
+	1601,
+	1537,
+	1602,
+	1538,
+	1602,
+	1537,
+	1602,
+	1538,
+	1603,
+	1539,
+	1603,
+	1538,
+	1603,
+	1539,
+	1604,
+	1540,
+	1604,
+	1539,
+	1604,
+	1540,
+	1605,
+	1541,
+	1605,
+	1540,
+	1605,
+	1541,
+	1606,
+	1542,
+	1606,
+	1541,
+	1606,
+	1542,
+	1607,
+	1543,
+	1607,
+	1542,
+	1607,
+	1543,
+	1608,
+	1544,
+	1608,
+	1543,
+	1608,
+	1544,
+	1609,
+	1545,
+	1609,
+	1544,
+	1609,
+	1545,
+	1610,
+	1546,
+	1610,
+	1545,
+	1610,
+	1546,
+	1611,
+	1547,
+	1611,
+	1546,
+	1611,
+	1547,
+	1612,
+	1548,
+	1612,
+	1547,
+	1612,
+	1548,
+	1613,
+	1549,
+	1613,
+	1548,
+	1613,
+	1549,
+	1614,
+	1550,
+	1614,
+	1549,
+	1614,
+	1550,
+	1615,
+	1551,
+	1615,
+	1550,
+	1615,
+	1551,
+	1616,
+	1552,
+	1616,
+	1551,
+	1616,
+	1552,
+	1617,
+	1553,
+	1617,
+	1552,
+	1617,
+	1553,
+	1618,
+	1554,
+	1618,
+	1553,
+	1618,
+	1554,
+	1619,
+	1555,
+	1619,
+	1554,
+	1619,
+	1555,
+	1620,
+	1556,
+	1620,
+	1555,
+	1620,
+	1556,
+	1621,
+	1557,
+	1621,
+	1556,
+	1621,
+	1557,
+	1622,
+	1558,
+	1622,
+	1557,
+	1622,
+	1558,
+	1623,
+	1559,
+	1623,
+	1558,
+	1623,
+	1559,
+	1624,
+	1560,
+	1624,
+	1559,
+	1624,
+	1560,
+	1625,
+	1561,
+	1625,
+	1560,
+	1625,
+	1561,
+	1626,
+	1562,
+	1626,
+	1561,
+	1626,
+	1562,
+	1627,
+	1563,
+	1627,
+	1562,
+	1627,
+	1563,
+	1628,
+	1564,
+	1628,
+	1563,
+	1628,
+	1564,
+	1629,
+	1565,
+	1629,
+	1564,
+	1629,
+	1565,
+	1630,
+	1566,
+	1630,
+	1565,
+	1630,
+	1566,
+	1631,
+	1567,
+	1631,
+	1566,
+	1631,
+	1567,
+	1632,
+	1568,
+	1632,
+	1567,
+	1632,
+	1568,
+	1633,
+	1569,
+	1633,
+	1568,
+	1633,
+	1569,
+	1634,
+	1570,
+	1634,
+	1569,
+	1634,
+	1570,
+	1635,
+	1571,
+	1635,
+	1570,
+	1635,
+	1571,
+	1636,
+	1572,
+	1636,
+	1571,
+	1636,
+	1572,
+	1637,
+	1573,
+	1637,
+	1572,
+	1637,
+	1573,
+	1638,
+	1574,
+	1638,
+	1573,
+	1638,
+	1574,
+	1639,
+	1575,
+	1639,
+	1574,
+	1639,
+	1575,
+	1640,
+	1576,
+	1640,
+	1575,
+	1640,
+	1576,
+	1641,
+	1577,
+	1641,
+	1576,
+	1641,
+	1577,
+	1642,
+	1578,
+	1642,
+	1577,
+	1642,
+	1578,
+	1643,
+	1579,
+	1643,
+	1578,
+	1643,
+	1579,
+	1644,
+	1580,
+	1644,
+	1579,
+	1644,
+	1580,
+	1645,
+	1581,
+	1645,
+	1580,
+	1645,
+	1581,
+	1646,
+	1582,
+	1646,
+	1581,
+	1646,
+	1582,
+	1647,
+	1583,
+	1647,
+	1582,
+	1647,
+	1583,
+	1648,
+	1584,
+	1648,
+	1583,
+	1648,
+	1584,
+	1649,
+	1585,
+	1649,
+	1584,
+	1649,
+	1585,
+	1650,
+	1586,
+	1650,
+	1585,
+	1650,
+	1586,
+	1651,
+	1587,
+	1651,
+	1586,
+	1651,
+	1587,
+	1652,
+	1588,
+	1652,
+	1587,
+	1652,
+	1588,
+	1653,
+	1589,
+	1653,
+	1588,
+	1653,
+	1589,
+	1654,
+	1590,
+	1654,
+	1589,
+	1654,
+	1590,
+	1655,
+	1591,
+	1655,
+	1590,
+	1655,
+	1591,
+	1656,
+	1592,
+	1656,
+	1591,
+	1656,
+	1592,
+	1657,
+	1593,
+	1657,
+	1592,
+	1657,
+	1593,
+	1658,
+	1594,
+	1658,
+	1593,
+	1658,
+	1594,
+	1659,
+	1595,
+	1659,
+	1594,
+	1659,
+	1595,
+	1660,
+	1596,
+	1660,
+	1595,
+	1660,
+	1596,
+	1661,
+	1597,
+	1661,
+	1596,
+	1661,
+	1597,
+	1662,
+	1598,
+	1662,
+	1597,
+	1662,
+	1598,
+	1663,
+	1599,
+	1663,
+	1598,
+	1664,
+	1600,
+	1665,
+	1601,
+	1665,
+	1600,
+	1665,
+	1601,
+	1666,
+	1602,
+	1666,
+	1601,
+	1666,
+	1602,
+	1667,
+	1603,
+	1667,
+	1602,
+	1667,
+	1603,
+	1668,
+	1604,
+	1668,
+	1603,
+	1668,
+	1604,
+	1669,
+	1605,
+	1669,
+	1604,
+	1669,
+	1605,
+	1670,
+	1606,
+	1670,
+	1605,
+	1670,
+	1606,
+	1671,
+	1607,
+	1671,
+	1606,
+	1671,
+	1607,
+	1672,
+	1608,
+	1672,
+	1607,
+	1672,
+	1608,
+	1673,
+	1609,
+	1673,
+	1608,
+	1673,
+	1609,
+	1674,
+	1610,
+	1674,
+	1609,
+	1674,
+	1610,
+	1675,
+	1611,
+	1675,
+	1610,
+	1675,
+	1611,
+	1676,
+	1612,
+	1676,
+	1611,
+	1676,
+	1612,
+	1677,
+	1613,
+	1677,
+	1612,
+	1677,
+	1613,
+	1678,
+	1614,
+	1678,
+	1613,
+	1678,
+	1614,
+	1679,
+	1615,
+	1679,
+	1614,
+	1679,
+	1615,
+	1680,
+	1616,
+	1680,
+	1615,
+	1680,
+	1616,
+	1681,
+	1617,
+	1681,
+	1616,
+	1681,
+	1617,
+	1682,
+	1618,
+	1682,
+	1617,
+	1682,
+	1618,
+	1683,
+	1619,
+	1683,
+	1618,
+	1683,
+	1619,
+	1684,
+	1620,
+	1684,
+	1619,
+	1684,
+	1620,
+	1685,
+	1621,
+	1685,
+	1620,
+	1685,
+	1621,
+	1686,
+	1622,
+	1686,
+	1621,
+	1686,
+	1622,
+	1687,
+	1623,
+	1687,
+	1622,
+	1687,
+	1623,
+	1688,
+	1624,
+	1688,
+	1623,
+	1688,
+	1624,
+	1689,
+	1625,
+	1689,
+	1624,
+	1689,
+	1625,
+	1690,
+	1626,
+	1690,
+	1625,
+	1690,
+	1626,
+	1691,
+	1627,
+	1691,
+	1626,
+	1691,
+	1627,
+	1692,
+	1628,
+	1692,
+	1627,
+	1692,
+	1628,
+	1693,
+	1629,
+	1693,
+	1628,
+	1693,
+	1629,
+	1694,
+	1630,
+	1694,
+	1629,
+	1694,
+	1630,
+	1695,
+	1631,
+	1695,
+	1630,
+	1695,
+	1631,
+	1696,
+	1632,
+	1696,
+	1631,
+	1696,
+	1632,
+	1697,
+	1633,
+	1697,
+	1632,
+	1697,
+	1633,
+	1698,
+	1634,
+	1698,
+	1633,
+	1698,
+	1634,
+	1699,
+	1635,
+	1699,
+	1634,
+	1699,
+	1635,
+	1700,
+	1636,
+	1700,
+	1635,
+	1700,
+	1636,
+	1701,
+	1637,
+	1701,
+	1636,
+	1701,
+	1637,
+	1702,
+	1638,
+	1702,
+	1637,
+	1702,
+	1638,
+	1703,
+	1639,
+	1703,
+	1638,
+	1703,
+	1639,
+	1704,
+	1640,
+	1704,
+	1639,
+	1704,
+	1640,
+	1705,
+	1641,
+	1705,
+	1640,
+	1705,
+	1641,
+	1706,
+	1642,
+	1706,
+	1641,
+	1706,
+	1642,
+	1707,
+	1643,
+	1707,
+	1642,
+	1707,
+	1643,
+	1708,
+	1644,
+	1708,
+	1643,
+	1708,
+	1644,
+	1709,
+	1645,
+	1709,
+	1644,
+	1709,
+	1645,
+	1710,
+	1646,
+	1710,
+	1645,
+	1710,
+	1646,
+	1711,
+	1647,
+	1711,
+	1646,
+	1711,
+	1647,
+	1712,
+	1648,
+	1712,
+	1647,
+	1712,
+	1648,
+	1713,
+	1649,
+	1713,
+	1648,
+	1713,
+	1649,
+	1714,
+	1650,
+	1714,
+	1649,
+	1714,
+	1650,
+	1715,
+	1651,
+	1715,
+	1650,
+	1715,
+	1651,
+	1716,
+	1652,
+	1716,
+	1651,
+	1716,
+	1652,
+	1717,
+	1653,
+	1717,
+	1652,
+	1717,
+	1653,
+	1718,
+	1654,
+	1718,
+	1653,
+	1718,
+	1654,
+	1719,
+	1655,
+	1719,
+	1654,
+	1719,
+	1655,
+	1720,
+	1656,
+	1720,
+	1655,
+	1720,
+	1656,
+	1721,
+	1657,
+	1721,
+	1656,
+	1721,
+	1657,
+	1722,
+	1658,
+	1722,
+	1657,
+	1722,
+	1658,
+	1723,
+	1659,
+	1723,
+	1658,
+	1723,
+	1659,
+	1724,
+	1660,
+	1724,
+	1659,
+	1724,
+	1660,
+	1725,
+	1661,
+	1725,
+	1660,
+	1725,
+	1661,
+	1726,
+	1662,
+	1726,
+	1661,
+	1726,
+	1662,
+	1727,
+	1663,
+	1727,
+	1662,
+	1728,
+	1664,
+	1729,
+	1665,
+	1729,
+	1664,
+	1729,
+	1665,
+	1730,
+	1666,
+	1730,
+	1665,
+	1730,
+	1666,
+	1731,
+	1667,
+	1731,
+	1666,
+	1731,
+	1667,
+	1732,
+	1668,
+	1732,
+	1667,
+	1732,
+	1668,
+	1733,
+	1669,
+	1733,
+	1668,
+	1733,
+	1669,
+	1734,
+	1670,
+	1734,
+	1669,
+	1734,
+	1670,
+	1735,
+	1671,
+	1735,
+	1670,
+	1735,
+	1671,
+	1736,
+	1672,
+	1736,
+	1671,
+	1736,
+	1672,
+	1737,
+	1673,
+	1737,
+	1672,
+	1737,
+	1673,
+	1738,
+	1674,
+	1738,
+	1673,
+	1738,
+	1674,
+	1739,
+	1675,
+	1739,
+	1674,
+	1739,
+	1675,
+	1740,
+	1676,
+	1740,
+	1675,
+	1740,
+	1676,
+	1741,
+	1677,
+	1741,
+	1676,
+	1741,
+	1677,
+	1742,
+	1678,
+	1742,
+	1677,
+	1742,
+	1678,
+	1743,
+	1679,
+	1743,
+	1678,
+	1743,
+	1679,
+	1744,
+	1680,
+	1744,
+	1679,
+	1744,
+	1680,
+	1745,
+	1681,
+	1745,
+	1680,
+	1745,
+	1681,
+	1746,
+	1682,
+	1746,
+	1681,
+	1746,
+	1682,
+	1747,
+	1683,
+	1747,
+	1682,
+	1747,
+	1683,
+	1748,
+	1684,
+	1748,
+	1683,
+	1748,
+	1684,
+	1749,
+	1685,
+	1749,
+	1684,
+	1749,
+	1685,
+	1750,
+	1686,
+	1750,
+	1685,
+	1750,
+	1686,
+	1751,
+	1687,
+	1751,
+	1686,
+	1751,
+	1687,
+	1752,
+	1688,
+	1752,
+	1687,
+	1752,
+	1688,
+	1753,
+	1689,
+	1753,
+	1688,
+	1753,
+	1689,
+	1754,
+	1690,
+	1754,
+	1689,
+	1754,
+	1690,
+	1755,
+	1691,
+	1755,
+	1690,
+	1755,
+	1691,
+	1756,
+	1692,
+	1756,
+	1691,
+	1756,
+	1692,
+	1757,
+	1693,
+	1757,
+	1692,
+	1757,
+	1693,
+	1758,
+	1694,
+	1758,
+	1693,
+	1758,
+	1694,
+	1759,
+	1695,
+	1759,
+	1694,
+	1759,
+	1695,
+	1760,
+	1696,
+	1760,
+	1695,
+	1760,
+	1696,
+	1761,
+	1697,
+	1761,
+	1696,
+	1761,
+	1697,
+	1762,
+	1698,
+	1762,
+	1697,
+	1762,
+	1698,
+	1763,
+	1699,
+	1763,
+	1698,
+	1763,
+	1699,
+	1764,
+	1700,
+	1764,
+	1699,
+	1764,
+	1700,
+	1765,
+	1701,
+	1765,
+	1700,
+	1765,
+	1701,
+	1766,
+	1702,
+	1766,
+	1701,
+	1766,
+	1702,
+	1767,
+	1703,
+	1767,
+	1702,
+	1767,
+	1703,
+	1768,
+	1704,
+	1768,
+	1703,
+	1768,
+	1704,
+	1769,
+	1705,
+	1769,
+	1704,
+	1769,
+	1705,
+	1770,
+	1706,
+	1770,
+	1705,
+	1770,
+	1706,
+	1771,
+	1707,
+	1771,
+	1706,
+	1771,
+	1707,
+	1772,
+	1708,
+	1772,
+	1707,
+	1772,
+	1708,
+	1773,
+	1709,
+	1773,
+	1708,
+	1773,
+	1709,
+	1774,
+	1710,
+	1774,
+	1709,
+	1774,
+	1710,
+	1775,
+	1711,
+	1775,
+	1710,
+	1775,
+	1711,
+	1776,
+	1712,
+	1776,
+	1711,
+	1776,
+	1712,
+	1777,
+	1713,
+	1777,
+	1712,
+	1777,
+	1713,
+	1778,
+	1714,
+	1778,
+	1713,
+	1778,
+	1714,
+	1779,
+	1715,
+	1779,
+	1714,
+	1779,
+	1715,
+	1780,
+	1716,
+	1780,
+	1715,
+	1780,
+	1716,
+	1781,
+	1717,
+	1781,
+	1716,
+	1781,
+	1717,
+	1782,
+	1718,
+	1782,
+	1717,
+	1782,
+	1718,
+	1783,
+	1719,
+	1783,
+	1718,
+	1783,
+	1719,
+	1784,
+	1720,
+	1784,
+	1719,
+	1784,
+	1720,
+	1785,
+	1721,
+	1785,
+	1720,
+	1785,
+	1721,
+	1786,
+	1722,
+	1786,
+	1721,
+	1786,
+	1722,
+	1787,
+	1723,
+	1787,
+	1722,
+	1787,
+	1723,
+	1788,
+	1724,
+	1788,
+	1723,
+	1788,
+	1724,
+	1789,
+	1725,
+	1789,
+	1724,
+	1789,
+	1725,
+	1790,
+	1726,
+	1790,
+	1725,
+	1790,
+	1726,
+	1791,
+	1727,
+	1791,
+	1726,
+	1792,
+	1728,
+	1793,
+	1729,
+	1793,
+	1728,
+	1793,
+	1729,
+	1794,
+	1730,
+	1794,
+	1729,
+	1794,
+	1730,
+	1795,
+	1731,
+	1795,
+	1730,
+	1795,
+	1731,
+	1796,
+	1732,
+	1796,
+	1731,
+	1796,
+	1732,
+	1797,
+	1733,
+	1797,
+	1732,
+	1797,
+	1733,
+	1798,
+	1734,
+	1798,
+	1733,
+	1798,
+	1734,
+	1799,
+	1735,
+	1799,
+	1734,
+	1799,
+	1735,
+	1800,
+	1736,
+	1800,
+	1735,
+	1800,
+	1736,
+	1801,
+	1737,
+	1801,
+	1736,
+	1801,
+	1737,
+	1802,
+	1738,
+	1802,
+	1737,
+	1802,
+	1738,
+	1803,
+	1739,
+	1803,
+	1738,
+	1803,
+	1739,
+	1804,
+	1740,
+	1804,
+	1739,
+	1804,
+	1740,
+	1805,
+	1741,
+	1805,
+	1740,
+	1805,
+	1741,
+	1806,
+	1742,
+	1806,
+	1741,
+	1806,
+	1742,
+	1807,
+	1743,
+	1807,
+	1742,
+	1807,
+	1743,
+	1808,
+	1744,
+	1808,
+	1743,
+	1808,
+	1744,
+	1809,
+	1745,
+	1809,
+	1744,
+	1809,
+	1745,
+	1810,
+	1746,
+	1810,
+	1745,
+	1810,
+	1746,
+	1811,
+	1747,
+	1811,
+	1746,
+	1811,
+	1747,
+	1812,
+	1748,
+	1812,
+	1747,
+	1812,
+	1748,
+	1813,
+	1749,
+	1813,
+	1748,
+	1813,
+	1749,
+	1814,
+	1750,
+	1814,
+	1749,
+	1814,
+	1750,
+	1815,
+	1751,
+	1815,
+	1750,
+	1815,
+	1751,
+	1816,
+	1752,
+	1816,
+	1751,
+	1816,
+	1752,
+	1817,
+	1753,
+	1817,
+	1752,
+	1817,
+	1753,
+	1818,
+	1754,
+	1818,
+	1753,
+	1818,
+	1754,
+	1819,
+	1755,
+	1819,
+	1754,
+	1819,
+	1755,
+	1820,
+	1756,
+	1820,
+	1755,
+	1820,
+	1756,
+	1821,
+	1757,
+	1821,
+	1756,
+	1821,
+	1757,
+	1822,
+	1758,
+	1822,
+	1757,
+	1822,
+	1758,
+	1823,
+	1759,
+	1823,
+	1758,
+	1823,
+	1759,
+	1824,
+	1760,
+	1824,
+	1759,
+	1824,
+	1760,
+	1825,
+	1761,
+	1825,
+	1760,
+	1825,
+	1761,
+	1826,
+	1762,
+	1826,
+	1761,
+	1826,
+	1762,
+	1827,
+	1763,
+	1827,
+	1762,
+	1827,
+	1763,
+	1828,
+	1764,
+	1828,
+	1763,
+	1828,
+	1764,
+	1829,
+	1765,
+	1829,
+	1764,
+	1829,
+	1765,
+	1830,
+	1766,
+	1830,
+	1765,
+	1830,
+	1766,
+	1831,
+	1767,
+	1831,
+	1766,
+	1831,
+	1767,
+	1832,
+	1768,
+	1832,
+	1767,
+	1832,
+	1768,
+	1833,
+	1769,
+	1833,
+	1768,
+	1833,
+	1769,
+	1834,
+	1770,
+	1834,
+	1769,
+	1834,
+	1770,
+	1835,
+	1771,
+	1835,
+	1770,
+	1835,
+	1771,
+	1836,
+	1772,
+	1836,
+	1771,
+	1836,
+	1772,
+	1837,
+	1773,
+	1837,
+	1772,
+	1837,
+	1773,
+	1838,
+	1774,
+	1838,
+	1773,
+	1838,
+	1774,
+	1839,
+	1775,
+	1839,
+	1774,
+	1839,
+	1775,
+	1840,
+	1776,
+	1840,
+	1775,
+	1840,
+	1776,
+	1841,
+	1777,
+	1841,
+	1776,
+	1841,
+	1777,
+	1842,
+	1778,
+	1842,
+	1777,
+	1842,
+	1778,
+	1843,
+	1779,
+	1843,
+	1778,
+	1843,
+	1779,
+	1844,
+	1780,
+	1844,
+	1779,
+	1844,
+	1780,
+	1845,
+	1781,
+	1845,
+	1780,
+	1845,
+	1781,
+	1846,
+	1782,
+	1846,
+	1781,
+	1846,
+	1782,
+	1847,
+	1783,
+	1847,
+	1782,
+	1847,
+	1783,
+	1848,
+	1784,
+	1848,
+	1783,
+	1848,
+	1784,
+	1849,
+	1785,
+	1849,
+	1784,
+	1849,
+	1785,
+	1850,
+	1786,
+	1850,
+	1785,
+	1850,
+	1786,
+	1851,
+	1787,
+	1851,
+	1786,
+	1851,
+	1787,
+	1852,
+	1788,
+	1852,
+	1787,
+	1852,
+	1788,
+	1853,
+	1789,
+	1853,
+	1788,
+	1853,
+	1789,
+	1854,
+	1790,
+	1854,
+	1789,
+	1854,
+	1790,
+	1855,
+	1791,
+	1855,
+	1790,
+	1856,
+	1792,
+	1857,
+	1793,
+	1857,
+	1792,
+	1857,
+	1793,
+	1858,
+	1794,
+	1858,
+	1793,
+	1858,
+	1794,
+	1859,
+	1795,
+	1859,
+	1794,
+	1859,
+	1795,
+	1860,
+	1796,
+	1860,
+	1795,
+	1860,
+	1796,
+	1861,
+	1797,
+	1861,
+	1796,
+	1861,
+	1797,
+	1862,
+	1798,
+	1862,
+	1797,
+	1862,
+	1798,
+	1863,
+	1799,
+	1863,
+	1798,
+	1863,
+	1799,
+	1864,
+	1800,
+	1864,
+	1799,
+	1864,
+	1800,
+	1865,
+	1801,
+	1865,
+	1800,
+	1865,
+	1801,
+	1866,
+	1802,
+	1866,
+	1801,
+	1866,
+	1802,
+	1867,
+	1803,
+	1867,
+	1802,
+	1867,
+	1803,
+	1868,
+	1804,
+	1868,
+	1803,
+	1868,
+	1804,
+	1869,
+	1805,
+	1869,
+	1804,
+	1869,
+	1805,
+	1870,
+	1806,
+	1870,
+	1805,
+	1870,
+	1806,
+	1871,
+	1807,
+	1871,
+	1806,
+	1871,
+	1807,
+	1872,
+	1808,
+	1872,
+	1807,
+	1872,
+	1808,
+	1873,
+	1809,
+	1873,
+	1808,
+	1873,
+	1809,
+	1874,
+	1810,
+	1874,
+	1809,
+	1874,
+	1810,
+	1875,
+	1811,
+	1875,
+	1810,
+	1875,
+	1811,
+	1876,
+	1812,
+	1876,
+	1811,
+	1876,
+	1812,
+	1877,
+	1813,
+	1877,
+	1812,
+	1877,
+	1813,
+	1878,
+	1814,
+	1878,
+	1813,
+	1878,
+	1814,
+	1879,
+	1815,
+	1879,
+	1814,
+	1879,
+	1815,
+	1880,
+	1816,
+	1880,
+	1815,
+	1880,
+	1816,
+	1881,
+	1817,
+	1881,
+	1816,
+	1881,
+	1817,
+	1882,
+	1818,
+	1882,
+	1817,
+	1882,
+	1818,
+	1883,
+	1819,
+	1883,
+	1818,
+	1883,
+	1819,
+	1884,
+	1820,
+	1884,
+	1819,
+	1884,
+	1820,
+	1885,
+	1821,
+	1885,
+	1820,
+	1885,
+	1821,
+	1886,
+	1822,
+	1886,
+	1821,
+	1886,
+	1822,
+	1887,
+	1823,
+	1887,
+	1822,
+	1887,
+	1823,
+	1888,
+	1824,
+	1888,
+	1823,
+	1888,
+	1824,
+	1889,
+	1825,
+	1889,
+	1824,
+	1889,
+	1825,
+	1890,
+	1826,
+	1890,
+	1825,
+	1890,
+	1826,
+	1891,
+	1827,
+	1891,
+	1826,
+	1891,
+	1827,
+	1892,
+	1828,
+	1892,
+	1827,
+	1892,
+	1828,
+	1893,
+	1829,
+	1893,
+	1828,
+	1893,
+	1829,
+	1894,
+	1830,
+	1894,
+	1829,
+	1894,
+	1830,
+	1895,
+	1831,
+	1895,
+	1830,
+	1895,
+	1831,
+	1896,
+	1832,
+	1896,
+	1831,
+	1896,
+	1832,
+	1897,
+	1833,
+	1897,
+	1832,
+	1897,
+	1833,
+	1898,
+	1834,
+	1898,
+	1833,
+	1898,
+	1834,
+	1899,
+	1835,
+	1899,
+	1834,
+	1899,
+	1835,
+	1900,
+	1836,
+	1900,
+	1835,
+	1900,
+	1836,
+	1901,
+	1837,
+	1901,
+	1836,
+	1901,
+	1837,
+	1902,
+	1838,
+	1902,
+	1837,
+	1902,
+	1838,
+	1903,
+	1839,
+	1903,
+	1838,
+	1903,
+	1839,
+	1904,
+	1840,
+	1904,
+	1839,
+	1904,
+	1840,
+	1905,
+	1841,
+	1905,
+	1840,
+	1905,
+	1841,
+	1906,
+	1842,
+	1906,
+	1841,
+	1906,
+	1842,
+	1907,
+	1843,
+	1907,
+	1842,
+	1907,
+	1843,
+	1908,
+	1844,
+	1908,
+	1843,
+	1908,
+	1844,
+	1909,
+	1845,
+	1909,
+	1844,
+	1909,
+	1845,
+	1910,
+	1846,
+	1910,
+	1845,
+	1910,
+	1846,
+	1911,
+	1847,
+	1911,
+	1846,
+	1911,
+	1847,
+	1912,
+	1848,
+	1912,
+	1847,
+	1912,
+	1848,
+	1913,
+	1849,
+	1913,
+	1848,
+	1913,
+	1849,
+	1914,
+	1850,
+	1914,
+	1849,
+	1914,
+	1850,
+	1915,
+	1851,
+	1915,
+	1850,
+	1915,
+	1851,
+	1916,
+	1852,
+	1916,
+	1851,
+	1916,
+	1852,
+	1917,
+	1853,
+	1917,
+	1852,
+	1917,
+	1853,
+	1918,
+	1854,
+	1918,
+	1853,
+	1918,
+	1854,
+	1919,
+	1855,
+	1919,
+	1854,
+	1920,
+	1856,
+	1921,
+	1857,
+	1921,
+	1856,
+	1921,
+	1857,
+	1922,
+	1858,
+	1922,
+	1857,
+	1922,
+	1858,
+	1923,
+	1859,
+	1923,
+	1858,
+	1923,
+	1859,
+	1924,
+	1860,
+	1924,
+	1859,
+	1924,
+	1860,
+	1925,
+	1861,
+	1925,
+	1860,
+	1925,
+	1861,
+	1926,
+	1862,
+	1926,
+	1861,
+	1926,
+	1862,
+	1927,
+	1863,
+	1927,
+	1862,
+	1927,
+	1863,
+	1928,
+	1864,
+	1928,
+	1863,
+	1928,
+	1864,
+	1929,
+	1865,
+	1929,
+	1864,
+	1929,
+	1865,
+	1930,
+	1866,
+	1930,
+	1865,
+	1930,
+	1866,
+	1931,
+	1867,
+	1931,
+	1866,
+	1931,
+	1867,
+	1932,
+	1868,
+	1932,
+	1867,
+	1932,
+	1868,
+	1933,
+	1869,
+	1933,
+	1868,
+	1933,
+	1869,
+	1934,
+	1870,
+	1934,
+	1869,
+	1934,
+	1870,
+	1935,
+	1871,
+	1935,
+	1870,
+	1935,
+	1871,
+	1936,
+	1872,
+	1936,
+	1871,
+	1936,
+	1872,
+	1937,
+	1873,
+	1937,
+	1872,
+	1937,
+	1873,
+	1938,
+	1874,
+	1938,
+	1873,
+	1938,
+	1874,
+	1939,
+	1875,
+	1939,
+	1874,
+	1939,
+	1875,
+	1940,
+	1876,
+	1940,
+	1875,
+	1940,
+	1876,
+	1941,
+	1877,
+	1941,
+	1876,
+	1941,
+	1877,
+	1942,
+	1878,
+	1942,
+	1877,
+	1942,
+	1878,
+	1943,
+	1879,
+	1943,
+	1878,
+	1943,
+	1879,
+	1944,
+	1880,
+	1944,
+	1879,
+	1944,
+	1880,
+	1945,
+	1881,
+	1945,
+	1880,
+	1945,
+	1881,
+	1946,
+	1882,
+	1946,
+	1881,
+	1946,
+	1882,
+	1947,
+	1883,
+	1947,
+	1882,
+	1947,
+	1883,
+	1948,
+	1884,
+	1948,
+	1883,
+	1948,
+	1884,
+	1949,
+	1885,
+	1949,
+	1884,
+	1949,
+	1885,
+	1950,
+	1886,
+	1950,
+	1885,
+	1950,
+	1886,
+	1951,
+	1887,
+	1951,
+	1886,
+	1951,
+	1887,
+	1952,
+	1888,
+	1952,
+	1887,
+	1952,
+	1888,
+	1953,
+	1889,
+	1953,
+	1888,
+	1953,
+	1889,
+	1954,
+	1890,
+	1954,
+	1889,
+	1954,
+	1890,
+	1955,
+	1891,
+	1955,
+	1890,
+	1955,
+	1891,
+	1956,
+	1892,
+	1956,
+	1891,
+	1956,
+	1892,
+	1957,
+	1893,
+	1957,
+	1892,
+	1957,
+	1893,
+	1958,
+	1894,
+	1958,
+	1893,
+	1958,
+	1894,
+	1959,
+	1895,
+	1959,
+	1894,
+	1959,
+	1895,
+	1960,
+	1896,
+	1960,
+	1895,
+	1960,
+	1896,
+	1961,
+	1897,
+	1961,
+	1896,
+	1961,
+	1897,
+	1962,
+	1898,
+	1962,
+	1897,
+	1962,
+	1898,
+	1963,
+	1899,
+	1963,
+	1898,
+	1963,
+	1899,
+	1964,
+	1900,
+	1964,
+	1899,
+	1964,
+	1900,
+	1965,
+	1901,
+	1965,
+	1900,
+	1965,
+	1901,
+	1966,
+	1902,
+	1966,
+	1901,
+	1966,
+	1902,
+	1967,
+	1903,
+	1967,
+	1902,
+	1967,
+	1903,
+	1968,
+	1904,
+	1968,
+	1903,
+	1968,
+	1904,
+	1969,
+	1905,
+	1969,
+	1904,
+	1969,
+	1905,
+	1970,
+	1906,
+	1970,
+	1905,
+	1970,
+	1906,
+	1971,
+	1907,
+	1971,
+	1906,
+	1971,
+	1907,
+	1972,
+	1908,
+	1972,
+	1907,
+	1972,
+	1908,
+	1973,
+	1909,
+	1973,
+	1908,
+	1973,
+	1909,
+	1974,
+	1910,
+	1974,
+	1909,
+	1974,
+	1910,
+	1975,
+	1911,
+	1975,
+	1910,
+	1975,
+	1911,
+	1976,
+	1912,
+	1976,
+	1911,
+	1976,
+	1912,
+	1977,
+	1913,
+	1977,
+	1912,
+	1977,
+	1913,
+	1978,
+	1914,
+	1978,
+	1913,
+	1978,
+	1914,
+	1979,
+	1915,
+	1979,
+	1914,
+	1979,
+	1915,
+	1980,
+	1916,
+	1980,
+	1915,
+	1980,
+	1916,
+	1981,
+	1917,
+	1981,
+	1916,
+	1981,
+	1917,
+	1982,
+	1918,
+	1982,
+	1917,
+	1982,
+	1918,
+	1983,
+	1919,
+	1983,
+	1918,
+	1984,
+	1920,
+	1985,
+	1921,
+	1985,
+	1920,
+	1985,
+	1921,
+	1986,
+	1922,
+	1986,
+	1921,
+	1986,
+	1922,
+	1987,
+	1923,
+	1987,
+	1922,
+	1987,
+	1923,
+	1988,
+	1924,
+	1988,
+	1923,
+	1988,
+	1924,
+	1989,
+	1925,
+	1989,
+	1924,
+	1989,
+	1925,
+	1990,
+	1926,
+	1990,
+	1925,
+	1990,
+	1926,
+	1991,
+	1927,
+	1991,
+	1926,
+	1991,
+	1927,
+	1992,
+	1928,
+	1992,
+	1927,
+	1992,
+	1928,
+	1993,
+	1929,
+	1993,
+	1928,
+	1993,
+	1929,
+	1994,
+	1930,
+	1994,
+	1929,
+	1994,
+	1930,
+	1995,
+	1931,
+	1995,
+	1930,
+	1995,
+	1931,
+	1996,
+	1932,
+	1996,
+	1931,
+	1996,
+	1932,
+	1997,
+	1933,
+	1997,
+	1932,
+	1997,
+	1933,
+	1998,
+	1934,
+	1998,
+	1933,
+	1998,
+	1934,
+	1999,
+	1935,
+	1999,
+	1934,
+	1999,
+	1935,
+	2000,
+	1936,
+	2000,
+	1935,
+	2000,
+	1936,
+	2001,
+	1937,
+	2001,
+	1936,
+	2001,
+	1937,
+	2002,
+	1938,
+	2002,
+	1937,
+	2002,
+	1938,
+	2003,
+	1939,
+	2003,
+	1938,
+	2003,
+	1939,
+	2004,
+	1940,
+	2004,
+	1939,
+	2004,
+	1940,
+	2005,
+	1941,
+	2005,
+	1940,
+	2005,
+	1941,
+	2006,
+	1942,
+	2006,
+	1941,
+	2006,
+	1942,
+	2007,
+	1943,
+	2007,
+	1942,
+	2007,
+	1943,
+	2008,
+	1944,
+	2008,
+	1943,
+	2008,
+	1944,
+	2009,
+	1945,
+	2009,
+	1944,
+	2009,
+	1945,
+	2010,
+	1946,
+	2010,
+	1945,
+	2010,
+	1946,
+	2011,
+	1947,
+	2011,
+	1946,
+	2011,
+	1947,
+	2012,
+	1948,
+	2012,
+	1947,
+	2012,
+	1948,
+	2013,
+	1949,
+	2013,
+	1948,
+	2013,
+	1949,
+	2014,
+	1950,
+	2014,
+	1949,
+	2014,
+	1950,
+	2015,
+	1951,
+	2015,
+	1950,
+	2015,
+	1951,
+	2016,
+	1952,
+	2016,
+	1951,
+	2016,
+	1952,
+	2017,
+	1953,
+	2017,
+	1952,
+	2017,
+	1953,
+	2018,
+	1954,
+	2018,
+	1953,
+	2018,
+	1954,
+	2019,
+	1955,
+	2019,
+	1954,
+	2019,
+	1955,
+	2020,
+	1956,
+	2020,
+	1955,
+	2020,
+	1956,
+	2021,
+	1957,
+	2021,
+	1956,
+	2021,
+	1957,
+	2022,
+	1958,
+	2022,
+	1957,
+	2022,
+	1958,
+	2023,
+	1959,
+	2023,
+	1958,
+	2023,
+	1959,
+	2024,
+	1960,
+	2024,
+	1959,
+	2024,
+	1960,
+	2025,
+	1961,
+	2025,
+	1960,
+	2025,
+	1961,
+	2026,
+	1962,
+	2026,
+	1961,
+	2026,
+	1962,
+	2027,
+	1963,
+	2027,
+	1962,
+	2027,
+	1963,
+	2028,
+	1964,
+	2028,
+	1963,
+	2028,
+	1964,
+	2029,
+	1965,
+	2029,
+	1964,
+	2029,
+	1965,
+	2030,
+	1966,
+	2030,
+	1965,
+	2030,
+	1966,
+	2031,
+	1967,
+	2031,
+	1966,
+	2031,
+	1967,
+	2032,
+	1968,
+	2032,
+	1967,
+	2032,
+	1968,
+	2033,
+	1969,
+	2033,
+	1968,
+	2033,
+	1969,
+	2034,
+	1970,
+	2034,
+	1969,
+	2034,
+	1970,
+	2035,
+	1971,
+	2035,
+	1970,
+	2035,
+	1971,
+	2036,
+	1972,
+	2036,
+	1971,
+	2036,
+	1972,
+	2037,
+	1973,
+	2037,
+	1972,
+	2037,
+	1973,
+	2038,
+	1974,
+	2038,
+	1973,
+	2038,
+	1974,
+	2039,
+	1975,
+	2039,
+	1974,
+	2039,
+	1975,
+	2040,
+	1976,
+	2040,
+	1975,
+	2040,
+	1976,
+	2041,
+	1977,
+	2041,
+	1976,
+	2041,
+	1977,
+	2042,
+	1978,
+	2042,
+	1977,
+	2042,
+	1978,
+	2043,
+	1979,
+	2043,
+	1978,
+	2043,
+	1979,
+	2044,
+	1980,
+	2044,
+	1979,
+	2044,
+	1980,
+	2045,
+	1981,
+	2045,
+	1980,
+	2045,
+	1981,
+	2046,
+	1982,
+	2046,
+	1981,
+	2046,
+	1982,
+	2047,
+	1983,
+	2047,
+	1982,
+};
+
+#define Landscape04VtxCount 2112
+#define Landscape04IdxCount 12096
+
+btScalar Landscape04Vtx[] = {
+	3.90625f,
+	18.9654f,
+	125.0f,
+	3.90625f,
+	20.0876f,
+	128.906f,
+	7.8125f,
+	20.5764f,
+	125.0f,
+	7.8125f,
+	21.0764f,
+	128.906f,
+	11.7188f,
+	21.5489f,
+	125.0f,
+	11.7188f,
+	21.4076f,
+	128.906f,
+	15.625f,
+	22.4963f,
+	125.0f,
+	15.625f,
+	22.6299f,
+	128.906f,
+	19.5313f,
+	22.3264f,
+	125.0f,
+	19.5313f,
+	22.1174f,
+	128.906f,
+	23.4375f,
+	20.3987f,
+	125.0f,
+	23.4375f,
+	20.3977f,
+	128.906f,
+	27.3438f,
+	18.6622f,
+	125.0f,
+	27.3438f,
+	18.7343f,
+	128.906f,
+	31.25f,
+	17.4724f,
+	125.0f,
+	31.25f,
+	17.9144f,
+	128.906f,
+	35.1563f,
+	16.4832f,
+	125.0f,
+	35.1563f,
+	17.2941f,
+	128.906f,
+	39.0625f,
+	15.2653f,
+	125.0f,
+	39.0625f,
+	16.5386f,
+	128.906f,
+	42.9688f,
+	14.379f,
+	125.0f,
+	42.9688f,
+	15.6892f,
+	128.906f,
+	46.875f,
+	13.9872f,
+	125.0f,
+	46.875f,
+	14.6414f,
+	128.906f,
+	50.7813f,
+	14.7002f,
+	125.0f,
+	50.7813f,
+	14.3505f,
+	128.906f,
+	54.6875f,
+	15.1119f,
+	125.0f,
+	54.6875f,
+	14.1604f,
+	128.906f,
+	58.5938f,
+	14.6638f,
+	125.0f,
+	58.5938f,
+	14.517f,
+	128.906f,
+	62.5f,
+	14.668f,
+	125.0f,
+	62.5f,
+	15.1057f,
+	128.906f,
+	66.4063f,
+	14.9792f,
+	125.0f,
+	66.4063f,
+	16.0684f,
+	128.906f,
+	70.3125f,
+	15.4776f,
+	125.0f,
+	70.3125f,
+	16.6251f,
+	128.906f,
+	74.2188f,
+	15.0939f,
+	125.0f,
+	74.2188f,
+	15.9689f,
+	128.906f,
+	78.125f,
+	15.5318f,
+	125.0f,
+	78.125f,
+	16.0234f,
+	128.906f,
+	82.0313f,
+	16.0777f,
+	125.0f,
+	82.0313f,
+	16.205f,
+	128.906f,
+	85.9375f,
+	17.8753f,
+	125.0f,
+	85.9375f,
+	18.8167f,
+	128.906f,
+	89.8438f,
+	18.8786f,
+	125.0f,
+	89.8438f,
+	19.6433f,
+	128.906f,
+	93.75f,
+	19.8208f,
+	125.0f,
+	93.75f,
+	20.2916f,
+	128.906f,
+	97.6563f,
+	23.2578f,
+	125.0f,
+	97.6563f,
+	23.2308f,
+	128.906f,
+	101.563f,
+	25.3117f,
+	125.0f,
+	101.563f,
+	25.882f,
+	128.906f,
+	105.469f,
+	26.8718f,
+	125.0f,
+	105.469f,
+	27.5736f,
+	128.906f,
+	109.375f,
+	28.7414f,
+	125.0f,
+	109.375f,
+	28.9662f,
+	128.906f,
+	113.281f,
+	29.9339f,
+	125.0f,
+	113.281f,
+	30.5702f,
+	128.906f,
+	117.188f,
+	30.6849f,
+	125.0f,
+	117.188f,
+	31.8627f,
+	128.906f,
+	121.094f,
+	32.4202f,
+	125.0f,
+	121.094f,
+	32.5216f,
+	128.906f,
+	125.0f,
+	34.7495f,
+	125.0f,
+	125.0f,
+	34.1918f,
+	128.906f,
+	128.906f,
+	37.137f,
+	125.0f,
+	128.906f,
+	37.0161f,
+	128.906f,
+	132.813f,
+	38.4113f,
+	125.0f,
+	132.813f,
+	38.5084f,
+	128.906f,
+	136.719f,
+	38.1788f,
+	125.0f,
+	136.719f,
+	39.1631f,
+	128.906f,
+	140.625f,
+	38.7652f,
+	125.0f,
+	140.625f,
+	39.0529f,
+	128.906f,
+	144.531f,
+	37.9353f,
+	125.0f,
+	144.531f,
+	38.9229f,
+	128.906f,
+	148.438f,
+	38.5681f,
+	125.0f,
+	148.438f,
+	38.4312f,
+	128.906f,
+	152.344f,
+	38.6243f,
+	125.0f,
+	152.344f,
+	39.1086f,
+	128.906f,
+	156.25f,
+	39.6341f,
+	125.0f,
+	156.25f,
+	39.7022f,
+	128.906f,
+	160.156f,
+	39.762f,
+	125.0f,
+	160.156f,
+	39.3007f,
+	128.906f,
+	164.063f,
+	38.5385f,
+	125.0f,
+	164.063f,
+	38.2318f,
+	128.906f,
+	167.969f,
+	36.3551f,
+	125.0f,
+	167.969f,
+	36.7493f,
+	128.906f,
+	171.875f,
+	36.1936f,
+	125.0f,
+	171.875f,
+	35.9781f,
+	128.906f,
+	175.781f,
+	35.5636f,
+	125.0f,
+	175.781f,
+	35.7712f,
+	128.906f,
+	179.688f,
+	34.6544f,
+	125.0f,
+	179.688f,
+	35.6247f,
+	128.906f,
+	183.594f,
+	34.1597f,
+	125.0f,
+	183.594f,
+	35.4808f,
+	128.906f,
+	187.5f,
+	33.5567f,
+	125.0f,
+	187.5f,
+	35.6102f,
+	128.906f,
+	191.406f,
+	33.0138f,
+	125.0f,
+	191.406f,
+	34.0305f,
+	128.906f,
+	195.313f,
+	31.2722f,
+	125.0f,
+	195.313f,
+	32.0227f,
+	128.906f,
+	199.219f,
+	29.2529f,
+	125.0f,
+	199.219f,
+	29.7666f,
+	128.906f,
+	203.125f,
+	26.9435f,
+	125.0f,
+	203.125f,
+	27.3968f,
+	128.906f,
+	207.031f,
+	25.0844f,
+	125.0f,
+	207.031f,
+	25.1642f,
+	128.906f,
+	210.938f,
+	23.6605f,
+	125.0f,
+	210.938f,
+	24.279f,
+	128.906f,
+	214.844f,
+	22.0745f,
+	125.0f,
+	214.844f,
+	22.4357f,
+	128.906f,
+	218.75f,
+	20.3206f,
+	125.0f,
+	218.75f,
+	21.7754f,
+	128.906f,
+	222.656f,
+	20.0402f,
+	125.0f,
+	222.656f,
+	19.6381f,
+	128.906f,
+	226.563f,
+	20.1162f,
+	125.0f,
+	226.563f,
+	19.78f,
+	128.906f,
+	230.469f,
+	20.2399f,
+	125.0f,
+	230.469f,
+	20.0349f,
+	128.906f,
+	234.375f,
+	19.6142f,
+	125.0f,
+	234.375f,
+	19.1534f,
+	128.906f,
+	238.281f,
+	18.6118f,
+	125.0f,
+	238.281f,
+	17.863f,
+	128.906f,
+	242.188f,
+	17.3711f,
+	125.0f,
+	242.188f,
+	17.658f,
+	128.906f,
+	246.094f,
+	17.675f,
+	125.0f,
+	246.094f,
+	16.951f,
+	128.906f,
+	250.0f,
+	17.3999f,
+	125.0f,
+	250.0f,
+	16.2961f,
+	128.906f,
+	3.90625f,
+	18.5327f,
+	121.094f,
+	7.8125f,
+	19.7267f,
+	121.094f,
+	11.7188f,
+	20.9891f,
+	121.094f,
+	15.625f,
+	22.237f,
+	121.094f,
+	19.5313f,
+	22.3238f,
+	121.094f,
+	23.4375f,
+	20.1525f,
+	121.094f,
+	27.3438f,
+	17.9536f,
+	121.094f,
+	31.25f,
+	17.647f,
+	121.094f,
+	35.1563f,
+	16.241f,
+	121.094f,
+	39.0625f,
+	14.6821f,
+	121.094f,
+	42.9688f,
+	14.4948f,
+	121.094f,
+	46.875f,
+	15.0351f,
+	121.094f,
+	50.7813f,
+	15.3893f,
+	121.094f,
+	54.6875f,
+	15.1531f,
+	121.094f,
+	58.5938f,
+	14.9284f,
+	121.094f,
+	62.5f,
+	15.1197f,
+	121.094f,
+	66.4063f,
+	15.1561f,
+	121.094f,
+	70.3125f,
+	15.1593f,
+	121.094f,
+	74.2188f,
+	15.0707f,
+	121.094f,
+	78.125f,
+	16.0455f,
+	121.094f,
+	82.0313f,
+	16.6186f,
+	121.094f,
+	85.9375f,
+	17.4149f,
+	121.094f,
+	89.8438f,
+	18.746f,
+	121.094f,
+	93.75f,
+	18.8475f,
+	121.094f,
+	97.6563f,
+	21.6899f,
+	121.094f,
+	101.563f,
+	24.567f,
+	121.094f,
+	105.469f,
+	25.7581f,
+	121.094f,
+	109.375f,
+	27.437f,
+	121.094f,
+	113.281f,
+	29.1226f,
+	121.094f,
+	117.188f,
+	30.137f,
+	121.094f,
+	121.094f,
+	32.1062f,
+	121.094f,
+	125.0f,
+	34.674f,
+	121.094f,
+	128.906f,
+	37.1044f,
+	121.094f,
+	132.813f,
+	37.8111f,
+	121.094f,
+	136.719f,
+	37.7901f,
+	121.094f,
+	140.625f,
+	37.5727f,
+	121.094f,
+	144.531f,
+	37.1561f,
+	121.094f,
+	148.438f,
+	38.1976f,
+	121.094f,
+	152.344f,
+	38.9227f,
+	121.094f,
+	156.25f,
+	40.3124f,
+	121.094f,
+	160.156f,
+	40.6867f,
+	121.094f,
+	164.063f,
+	39.5374f,
+	121.094f,
+	167.969f,
+	38.019f,
+	121.094f,
+	171.875f,
+	36.4573f,
+	121.094f,
+	175.781f,
+	35.2509f,
+	121.094f,
+	179.688f,
+	34.6709f,
+	121.094f,
+	183.594f,
+	33.5584f,
+	121.094f,
+	187.5f,
+	33.2411f,
+	121.094f,
+	191.406f,
+	31.7588f,
+	121.094f,
+	195.313f,
+	30.3558f,
+	121.094f,
+	199.219f,
+	28.879f,
+	121.094f,
+	203.125f,
+	26.7589f,
+	121.094f,
+	207.031f,
+	25.0535f,
+	121.094f,
+	210.938f,
+	23.0477f,
+	121.094f,
+	214.844f,
+	20.6897f,
+	121.094f,
+	218.75f,
+	19.3676f,
+	121.094f,
+	222.656f,
+	19.2985f,
+	121.094f,
+	226.563f,
+	20.2312f,
+	121.094f,
+	230.469f,
+	20.317f,
+	121.094f,
+	234.375f,
+	20.2468f,
+	121.094f,
+	238.281f,
+	20.3734f,
+	121.094f,
+	242.188f,
+	18.3676f,
+	121.094f,
+	246.094f,
+	16.642f,
+	121.094f,
+	250.0f,
+	17.5995f,
+	121.094f,
+	3.90625f,
+	18.919f,
+	117.188f,
+	7.8125f,
+	19.2124f,
+	117.188f,
+	11.7188f,
+	20.7659f,
+	117.188f,
+	15.625f,
+	20.5809f,
+	117.188f,
+	19.5313f,
+	20.3134f,
+	117.188f,
+	23.4375f,
+	18.6669f,
+	117.188f,
+	27.3438f,
+	17.5145f,
+	117.188f,
+	31.25f,
+	17.0813f,
+	117.188f,
+	35.1563f,
+	15.6789f,
+	117.188f,
+	39.0625f,
+	14.7581f,
+	117.188f,
+	42.9688f,
+	14.4424f,
+	117.188f,
+	46.875f,
+	14.7991f,
+	117.188f,
+	50.7813f,
+	15.0726f,
+	117.188f,
+	54.6875f,
+	14.8056f,
+	117.188f,
+	58.5938f,
+	15.756f,
+	117.188f,
+	62.5f,
+	16.3024f,
+	117.188f,
+	66.4063f,
+	16.0449f,
+	117.188f,
+	70.3125f,
+	15.9115f,
+	117.188f,
+	74.2188f,
+	16.1633f,
+	117.188f,
+	78.125f,
+	17.3323f,
+	117.188f,
+	82.0313f,
+	17.2659f,
+	117.188f,
+	85.9375f,
+	17.987f,
+	117.188f,
+	89.8438f,
+	18.3044f,
+	117.188f,
+	93.75f,
+	18.2665f,
+	117.188f,
+	97.6563f,
+	19.5364f,
+	117.188f,
+	101.563f,
+	21.7536f,
+	117.188f,
+	105.469f,
+	23.6545f,
+	117.188f,
+	109.375f,
+	25.5212f,
+	117.188f,
+	113.281f,
+	28.1179f,
+	117.188f,
+	117.188f,
+	29.5931f,
+	117.188f,
+	121.094f,
+	31.8126f,
+	117.188f,
+	125.0f,
+	34.0227f,
+	117.188f,
+	128.906f,
+	36.3895f,
+	117.188f,
+	132.813f,
+	37.0423f,
+	117.188f,
+	136.719f,
+	36.8278f,
+	117.188f,
+	140.625f,
+	36.2349f,
+	117.188f,
+	144.531f,
+	36.8825f,
+	117.188f,
+	148.438f,
+	39.6492f,
+	117.188f,
+	152.344f,
+	41.6626f,
+	117.188f,
+	156.25f,
+	42.5091f,
+	117.188f,
+	160.156f,
+	43.0711f,
+	117.188f,
+	164.063f,
+	41.7733f,
+	117.188f,
+	167.969f,
+	40.5985f,
+	117.188f,
+	171.875f,
+	38.1852f,
+	117.188f,
+	175.781f,
+	37.023f,
+	117.188f,
+	179.688f,
+	35.8533f,
+	117.188f,
+	183.594f,
+	34.5754f,
+	117.188f,
+	187.5f,
+	33.6585f,
+	117.188f,
+	191.406f,
+	32.534f,
+	117.188f,
+	195.313f,
+	31.0632f,
+	117.188f,
+	199.219f,
+	29.0243f,
+	117.188f,
+	203.125f,
+	27.0248f,
+	117.188f,
+	207.031f,
+	25.1597f,
+	117.188f,
+	210.938f,
+	22.6282f,
+	117.188f,
+	214.844f,
+	20.6205f,
+	117.188f,
+	218.75f,
+	19.2556f,
+	117.188f,
+	222.656f,
+	18.8259f,
+	117.188f,
+	226.563f,
+	19.2235f,
+	117.188f,
+	230.469f,
+	20.4441f,
+	117.188f,
+	234.375f,
+	20.5373f,
+	117.188f,
+	238.281f,
+	20.3082f,
+	117.188f,
+	242.188f,
+	19.4397f,
+	117.188f,
+	246.094f,
+	17.9806f,
+	117.188f,
+	250.0f,
+	17.3395f,
+	117.188f,
+	3.90625f,
+	18.3498f,
+	113.281f,
+	7.8125f,
+	18.7009f,
+	113.281f,
+	11.7188f,
+	19.3704f,
+	113.281f,
+	15.625f,
+	19.5203f,
+	113.281f,
+	19.5313f,
+	18.5704f,
+	113.281f,
+	23.4375f,
+	17.6697f,
+	113.281f,
+	27.3438f,
+	16.8001f,
+	113.281f,
+	31.25f,
+	16.54f,
+	113.281f,
+	35.1563f,
+	15.8558f,
+	113.281f,
+	39.0625f,
+	15.1296f,
+	113.281f,
+	42.9688f,
+	15.8599f,
+	113.281f,
+	46.875f,
+	16.437f,
+	113.281f,
+	50.7813f,
+	16.2977f,
+	113.281f,
+	54.6875f,
+	16.7076f,
+	113.281f,
+	58.5938f,
+	16.8187f,
+	113.281f,
+	62.5f,
+	17.1513f,
+	113.281f,
+	66.4063f,
+	16.5296f,
+	113.281f,
+	70.3125f,
+	15.8782f,
+	113.281f,
+	74.2188f,
+	16.614f,
+	113.281f,
+	78.125f,
+	17.0474f,
+	113.281f,
+	82.0313f,
+	17.3371f,
+	113.281f,
+	85.9375f,
+	17.9565f,
+	113.281f,
+	89.8438f,
+	18.3918f,
+	113.281f,
+	93.75f,
+	19.0258f,
+	113.281f,
+	97.6563f,
+	19.2791f,
+	113.281f,
+	101.563f,
+	20.1533f,
+	113.281f,
+	105.469f,
+	22.2922f,
+	113.281f,
+	109.375f,
+	24.6835f,
+	113.281f,
+	113.281f,
+	25.7755f,
+	113.281f,
+	117.188f,
+	28.8805f,
+	113.281f,
+	121.094f,
+	31.2119f,
+	113.281f,
+	125.0f,
+	33.4657f,
+	113.281f,
+	128.906f,
+	35.1055f,
+	113.281f,
+	132.813f,
+	36.4197f,
+	113.281f,
+	136.719f,
+	37.3017f,
+	113.281f,
+	140.625f,
+	37.1796f,
+	113.281f,
+	144.531f,
+	38.2037f,
+	113.281f,
+	148.438f,
+	41.4383f,
+	113.281f,
+	152.344f,
+	43.9714f,
+	113.281f,
+	156.25f,
+	45.0067f,
+	113.281f,
+	160.156f,
+	45.1491f,
+	113.281f,
+	164.063f,
+	43.8042f,
+	113.281f,
+	167.969f,
+	42.5165f,
+	113.281f,
+	171.875f,
+	40.361f,
+	113.281f,
+	175.781f,
+	38.3494f,
+	113.281f,
+	179.688f,
+	37.4529f,
+	113.281f,
+	183.594f,
+	35.5766f,
+	113.281f,
+	187.5f,
+	34.2438f,
+	113.281f,
+	191.406f,
+	32.0218f,
+	113.281f,
+	195.313f,
+	30.2021f,
+	113.281f,
+	199.219f,
+	28.8256f,
+	113.281f,
+	203.125f,
+	27.2081f,
+	113.281f,
+	207.031f,
+	24.992f,
+	113.281f,
+	210.938f,
+	22.5332f,
+	113.281f,
+	214.844f,
+	19.7765f,
+	113.281f,
+	218.75f,
+	18.5573f,
+	113.281f,
+	222.656f,
+	18.1469f,
+	113.281f,
+	226.563f,
+	17.9659f,
+	113.281f,
+	230.469f,
+	19.2f,
+	113.281f,
+	234.375f,
+	20.0741f,
+	113.281f,
+	238.281f,
+	20.1159f,
+	113.281f,
+	242.188f,
+	19.0382f,
+	113.281f,
+	246.094f,
+	18.3417f,
+	113.281f,
+	250.0f,
+	18.7603f,
+	113.281f,
+	3.90625f,
+	18.0017f,
+	109.375f,
+	7.8125f,
+	18.1552f,
+	109.375f,
+	11.7188f,
+	18.2026f,
+	109.375f,
+	15.625f,
+	18.2042f,
+	109.375f,
+	19.5313f,
+	17.7806f,
+	109.375f,
+	23.4375f,
+	17.5378f,
+	109.375f,
+	27.3438f,
+	16.8627f,
+	109.375f,
+	31.25f,
+	15.9329f,
+	109.375f,
+	35.1563f,
+	15.192f,
+	109.375f,
+	39.0625f,
+	16.0796f,
+	109.375f,
+	42.9688f,
+	16.1895f,
+	109.375f,
+	46.875f,
+	15.9774f,
+	109.375f,
+	50.7813f,
+	16.9529f,
+	109.375f,
+	54.6875f,
+	17.0901f,
+	109.375f,
+	58.5938f,
+	17.3722f,
+	109.375f,
+	62.5f,
+	16.5809f,
+	109.375f,
+	66.4063f,
+	16.8111f,
+	109.375f,
+	70.3125f,
+	16.9238f,
+	109.375f,
+	74.2188f,
+	16.8422f,
+	109.375f,
+	78.125f,
+	17.0401f,
+	109.375f,
+	82.0313f,
+	16.8637f,
+	109.375f,
+	85.9375f,
+	17.4071f,
+	109.375f,
+	89.8438f,
+	17.944f,
+	109.375f,
+	93.75f,
+	18.5255f,
+	109.375f,
+	97.6563f,
+	18.2829f,
+	109.375f,
+	101.563f,
+	19.0975f,
+	109.375f,
+	105.469f,
+	20.4292f,
+	109.375f,
+	109.375f,
+	22.163f,
+	109.375f,
+	113.281f,
+	25.6773f,
+	109.375f,
+	117.188f,
+	27.8617f,
+	109.375f,
+	121.094f,
+	30.6543f,
+	109.375f,
+	125.0f,
+	33.4226f,
+	109.375f,
+	128.906f,
+	34.4263f,
+	109.375f,
+	132.813f,
+	36.8747f,
+	109.375f,
+	136.719f,
+	37.4551f,
+	109.375f,
+	140.625f,
+	37.4975f,
+	109.375f,
+	144.531f,
+	40.0751f,
+	109.375f,
+	148.438f,
+	42.7524f,
+	109.375f,
+	152.344f,
+	44.7756f,
+	109.375f,
+	156.25f,
+	46.1787f,
+	109.375f,
+	160.156f,
+	46.3753f,
+	109.375f,
+	164.063f,
+	45.2089f,
+	109.375f,
+	167.969f,
+	43.7487f,
+	109.375f,
+	171.875f,
+	41.6365f,
+	109.375f,
+	175.781f,
+	39.7459f,
+	109.375f,
+	179.688f,
+	36.9804f,
+	109.375f,
+	183.594f,
+	35.6688f,
+	109.375f,
+	187.5f,
+	35.0212f,
+	109.375f,
+	191.406f,
+	32.4383f,
+	109.375f,
+	195.313f,
+	29.6046f,
+	109.375f,
+	199.219f,
+	28.1822f,
+	109.375f,
+	203.125f,
+	26.2444f,
+	109.375f,
+	207.031f,
+	24.1442f,
+	109.375f,
+	210.938f,
+	22.1072f,
+	109.375f,
+	214.844f,
+	20.0401f,
+	109.375f,
+	218.75f,
+	18.0663f,
+	109.375f,
+	222.656f,
+	16.866f,
+	109.375f,
+	226.563f,
+	16.9372f,
+	109.375f,
+	230.469f,
+	16.9853f,
+	109.375f,
+	234.375f,
+	17.6761f,
+	109.375f,
+	238.281f,
+	18.3669f,
+	109.375f,
+	242.188f,
+	18.4156f,
+	109.375f,
+	246.094f,
+	18.2171f,
+	109.375f,
+	250.0f,
+	18.5941f,
+	109.375f,
+	3.90625f,
+	17.9608f,
+	105.469f,
+	7.8125f,
+	18.4369f,
+	105.469f,
+	11.7188f,
+	18.4406f,
+	105.469f,
+	15.625f,
+	17.8685f,
+	105.469f,
+	19.5313f,
+	17.7519f,
+	105.469f,
+	23.4375f,
+	17.5734f,
+	105.469f,
+	27.3438f,
+	16.3397f,
+	105.469f,
+	31.25f,
+	15.8618f,
+	105.469f,
+	35.1563f,
+	16.1194f,
+	105.469f,
+	39.0625f,
+	16.889f,
+	105.469f,
+	42.9688f,
+	16.2804f,
+	105.469f,
+	46.875f,
+	15.8474f,
+	105.469f,
+	50.7813f,
+	16.2892f,
+	105.469f,
+	54.6875f,
+	16.2854f,
+	105.469f,
+	58.5938f,
+	16.7368f,
+	105.469f,
+	62.5f,
+	17.4055f,
+	105.469f,
+	66.4063f,
+	16.8808f,
+	105.469f,
+	70.3125f,
+	17.3183f,
+	105.469f,
+	74.2188f,
+	17.7166f,
+	105.469f,
+	78.125f,
+	17.0657f,
+	105.469f,
+	82.0313f,
+	16.7305f,
+	105.469f,
+	85.9375f,
+	16.3929f,
+	105.469f,
+	89.8438f,
+	16.6475f,
+	105.469f,
+	93.75f,
+	17.7645f,
+	105.469f,
+	97.6563f,
+	18.4212f,
+	105.469f,
+	101.563f,
+	18.4107f,
+	105.469f,
+	105.469f,
+	19.3751f,
+	105.469f,
+	109.375f,
+	21.843f,
+	105.469f,
+	113.281f,
+	25.0143f,
+	105.469f,
+	117.188f,
+	26.9168f,
+	105.469f,
+	121.094f,
+	29.8403f,
+	105.469f,
+	125.0f,
+	32.4937f,
+	105.469f,
+	128.906f,
+	34.4076f,
+	105.469f,
+	132.813f,
+	35.2497f,
+	105.469f,
+	136.719f,
+	36.4785f,
+	105.469f,
+	140.625f,
+	37.7983f,
+	105.469f,
+	144.531f,
+	40.5712f,
+	105.469f,
+	148.438f,
+	43.3698f,
+	105.469f,
+	152.344f,
+	45.784f,
+	105.469f,
+	156.25f,
+	46.9835f,
+	105.469f,
+	160.156f,
+	47.2774f,
+	105.469f,
+	164.063f,
+	46.7695f,
+	105.469f,
+	167.969f,
+	45.0199f,
+	105.469f,
+	171.875f,
+	42.588f,
+	105.469f,
+	175.781f,
+	39.988f,
+	105.469f,
+	179.688f,
+	38.0653f,
+	105.469f,
+	183.594f,
+	37.5754f,
+	105.469f,
+	187.5f,
+	35.6316f,
+	105.469f,
+	191.406f,
+	32.4143f,
+	105.469f,
+	195.313f,
+	29.5342f,
+	105.469f,
+	199.219f,
+	27.2795f,
+	105.469f,
+	203.125f,
+	26.065f,
+	105.469f,
+	207.031f,
+	24.8633f,
+	105.469f,
+	210.938f,
+	23.0216f,
+	105.469f,
+	214.844f,
+	21.1684f,
+	105.469f,
+	218.75f,
+	18.9315f,
+	105.469f,
+	222.656f,
+	17.7013f,
+	105.469f,
+	226.563f,
+	16.9466f,
+	105.469f,
+	230.469f,
+	17.1437f,
+	105.469f,
+	234.375f,
+	17.6691f,
+	105.469f,
+	238.281f,
+	17.9243f,
+	105.469f,
+	242.188f,
+	18.0005f,
+	105.469f,
+	246.094f,
+	18.6179f,
+	105.469f,
+	250.0f,
+	19.2165f,
+	105.469f,
+	3.90625f,
+	17.7074f,
+	101.563f,
+	7.8125f,
+	18.411f,
+	101.563f,
+	11.7188f,
+	17.9916f,
+	101.563f,
+	15.625f,
+	18.5349f,
+	101.563f,
+	19.5313f,
+	18.6607f,
+	101.563f,
+	23.4375f,
+	17.406f,
+	101.563f,
+	27.3438f,
+	17.2356f,
+	101.563f,
+	31.25f,
+	17.0395f,
+	101.563f,
+	35.1563f,
+	17.9903f,
+	101.563f,
+	39.0625f,
+	18.2603f,
+	101.563f,
+	42.9688f,
+	17.9037f,
+	101.563f,
+	46.875f,
+	17.2358f,
+	101.563f,
+	50.7813f,
+	16.1089f,
+	101.563f,
+	54.6875f,
+	16.6043f,
+	101.563f,
+	58.5938f,
+	16.5656f,
+	101.563f,
+	62.5f,
+	16.8655f,
+	101.563f,
+	66.4063f,
+	17.0123f,
+	101.563f,
+	70.3125f,
+	17.4985f,
+	101.563f,
+	74.2188f,
+	18.0195f,
+	101.563f,
+	78.125f,
+	17.3417f,
+	101.563f,
+	82.0313f,
+	16.8477f,
+	101.563f,
+	85.9375f,
+	15.4602f,
+	101.563f,
+	89.8438f,
+	15.6001f,
+	101.563f,
+	93.75f,
+	16.8889f,
+	101.563f,
+	97.6563f,
+	17.2944f,
+	101.563f,
+	101.563f,
+	17.3431f,
+	101.563f,
+	105.469f,
+	18.2306f,
+	101.563f,
+	109.375f,
+	20.5556f,
+	101.563f,
+	113.281f,
+	22.5598f,
+	101.563f,
+	117.188f,
+	25.0997f,
+	101.563f,
+	121.094f,
+	28.2048f,
+	101.563f,
+	125.0f,
+	30.46f,
+	101.563f,
+	128.906f,
+	32.5729f,
+	101.563f,
+	132.813f,
+	34.5568f,
+	101.563f,
+	136.719f,
+	36.463f,
+	101.563f,
+	140.625f,
+	37.8259f,
+	101.563f,
+	144.531f,
+	40.4357f,
+	101.563f,
+	148.438f,
+	43.6544f,
+	101.563f,
+	152.344f,
+	46.204f,
+	101.563f,
+	156.25f,
+	47.3874f,
+	101.563f,
+	160.156f,
+	47.5222f,
+	101.563f,
+	164.063f,
+	46.8312f,
+	101.563f,
+	167.969f,
+	44.5065f,
+	101.563f,
+	171.875f,
+	43.7648f,
+	101.563f,
+	175.781f,
+	41.9789f,
+	101.563f,
+	179.688f,
+	40.785f,
+	101.563f,
+	183.594f,
+	38.7639f,
+	101.563f,
+	187.5f,
+	36.1589f,
+	101.563f,
+	191.406f,
+	33.4197f,
+	101.563f,
+	195.313f,
+	29.7568f,
+	101.563f,
+	199.219f,
+	27.2343f,
+	101.563f,
+	203.125f,
+	26.3845f,
+	101.563f,
+	207.031f,
+	25.3149f,
+	101.563f,
+	210.938f,
+	23.4896f,
+	101.563f,
+	214.844f,
+	22.229f,
+	101.563f,
+	218.75f,
+	20.0014f,
+	101.563f,
+	222.656f,
+	19.0955f,
+	101.563f,
+	226.563f,
+	17.971f,
+	101.563f,
+	230.469f,
+	16.9303f,
+	101.563f,
+	234.375f,
+	17.3619f,
+	101.563f,
+	238.281f,
+	17.0337f,
+	101.563f,
+	242.188f,
+	17.1424f,
+	101.563f,
+	246.094f,
+	18.334f,
+	101.563f,
+	250.0f,
+	19.2744f,
+	101.563f,
+	3.90625f,
+	18.0176f,
+	97.6563f,
+	7.8125f,
+	18.1916f,
+	97.6563f,
+	11.7188f,
+	17.72f,
+	97.6563f,
+	15.625f,
+	18.3444f,
+	97.6563f,
+	19.5313f,
+	18.7102f,
+	97.6563f,
+	23.4375f,
+	17.4143f,
+	97.6563f,
+	27.3438f,
+	18.0085f,
+	97.6563f,
+	31.25f,
+	18.4924f,
+	97.6563f,
+	35.1563f,
+	19.4324f,
+	97.6563f,
+	39.0625f,
+	19.7998f,
+	97.6563f,
+	42.9688f,
+	19.5444f,
+	97.6563f,
+	46.875f,
+	19.5513f,
+	97.6563f,
+	50.7813f,
+	17.9397f,
+	97.6563f,
+	54.6875f,
+	16.6383f,
+	97.6563f,
+	58.5938f,
+	16.0619f,
+	97.6563f,
+	62.5f,
+	16.7402f,
+	97.6563f,
+	66.4063f,
+	16.955f,
+	97.6563f,
+	70.3125f,
+	17.5912f,
+	97.6563f,
+	74.2188f,
+	17.1181f,
+	97.6563f,
+	78.125f,
+	16.9063f,
+	97.6563f,
+	82.0313f,
+	16.3988f,
+	97.6563f,
+	85.9375f,
+	15.935f,
+	97.6563f,
+	89.8438f,
+	16.0664f,
+	97.6563f,
+	93.75f,
+	16.1926f,
+	97.6563f,
+	97.6563f,
+	16.5004f,
+	97.6563f,
+	101.563f,
+	17.1185f,
+	97.6563f,
+	105.469f,
+	17.2859f,
+	97.6563f,
+	109.375f,
+	19.0026f,
+	97.6563f,
+	113.281f,
+	21.0018f,
+	97.6563f,
+	117.188f,
+	23.6336f,
+	97.6563f,
+	121.094f,
+	26.4831f,
+	97.6563f,
+	125.0f,
+	29.3075f,
+	97.6563f,
+	128.906f,
+	32.5702f,
+	97.6563f,
+	132.813f,
+	34.5711f,
+	97.6563f,
+	136.719f,
+	36.1666f,
+	97.6563f,
+	140.625f,
+	37.5909f,
+	97.6563f,
+	144.531f,
+	40.3232f,
+	97.6563f,
+	148.438f,
+	42.661f,
+	97.6563f,
+	152.344f,
+	45.5604f,
+	97.6563f,
+	156.25f,
+	47.6984f,
+	97.6563f,
+	160.156f,
+	47.4129f,
+	97.6563f,
+	164.063f,
+	47.1564f,
+	97.6563f,
+	167.969f,
+	45.3058f,
+	97.6563f,
+	171.875f,
+	44.8069f,
+	97.6563f,
+	175.781f,
+	43.6847f,
+	97.6563f,
+	179.688f,
+	41.6831f,
+	97.6563f,
+	183.594f,
+	39.4072f,
+	97.6563f,
+	187.5f,
+	36.6118f,
+	97.6563f,
+	191.406f,
+	33.396f,
+	97.6563f,
+	195.313f,
+	29.9372f,
+	97.6563f,
+	199.219f,
+	28.0616f,
+	97.6563f,
+	203.125f,
+	27.3957f,
+	97.6563f,
+	207.031f,
+	25.6934f,
+	97.6563f,
+	210.938f,
+	24.4412f,
+	97.6563f,
+	214.844f,
+	23.2356f,
+	97.6563f,
+	218.75f,
+	21.445f,
+	97.6563f,
+	222.656f,
+	19.5412f,
+	97.6563f,
+	226.563f,
+	18.4898f,
+	97.6563f,
+	230.469f,
+	17.727f,
+	97.6563f,
+	234.375f,
+	16.5139f,
+	97.6563f,
+	238.281f,
+	16.2579f,
+	97.6563f,
+	242.188f,
+	16.1539f,
+	97.6563f,
+	246.094f,
+	17.0856f,
+	97.6563f,
+	250.0f,
+	18.5151f,
+	97.6563f,
+	3.90625f,
+	17.1671f,
+	93.75f,
+	7.8125f,
+	16.817f,
+	93.75f,
+	11.7188f,
+	17.5293f,
+	93.75f,
+	15.625f,
+	18.7701f,
+	93.75f,
+	19.5313f,
+	18.3362f,
+	93.75f,
+	23.4375f,
+	19.0869f,
+	93.75f,
+	27.3438f,
+	19.7557f,
+	93.75f,
+	31.25f,
+	20.0113f,
+	93.75f,
+	35.1563f,
+	20.3441f,
+	93.75f,
+	39.0625f,
+	21.4434f,
+	93.75f,
+	42.9688f,
+	21.6008f,
+	93.75f,
+	46.875f,
+	21.5423f,
+	93.75f,
+	50.7813f,
+	20.7592f,
+	93.75f,
+	54.6875f,
+	18.9207f,
+	93.75f,
+	58.5938f,
+	17.6772f,
+	93.75f,
+	62.5f,
+	17.5409f,
+	93.75f,
+	66.4063f,
+	17.599f,
+	93.75f,
+	70.3125f,
+	18.2626f,
+	93.75f,
+	74.2188f,
+	18.4046f,
+	93.75f,
+	78.125f,
+	18.215f,
+	93.75f,
+	82.0313f,
+	18.4743f,
+	93.75f,
+	85.9375f,
+	17.6579f,
+	93.75f,
+	89.8438f,
+	17.732f,
+	93.75f,
+	93.75f,
+	18.4172f,
+	93.75f,
+	97.6563f,
+	19.0439f,
+	93.75f,
+	101.563f,
+	19.7437f,
+	93.75f,
+	105.469f,
+	19.8588f,
+	93.75f,
+	109.375f,
+	19.7414f,
+	93.75f,
+	113.281f,
+	21.4756f,
+	93.75f,
+	117.188f,
+	24.1862f,
+	93.75f,
+	121.094f,
+	26.8351f,
+	93.75f,
+	125.0f,
+	29.9621f,
+	93.75f,
+	128.906f,
+	32.8267f,
+	93.75f,
+	132.813f,
+	34.6779f,
+	93.75f,
+	136.719f,
+	36.0083f,
+	93.75f,
+	140.625f,
+	36.9812f,
+	93.75f,
+	144.531f,
+	39.6087f,
+	93.75f,
+	148.438f,
+	42.2269f,
+	93.75f,
+	152.344f,
+	44.492f,
+	93.75f,
+	156.25f,
+	47.1767f,
+	93.75f,
+	160.156f,
+	47.5667f,
+	93.75f,
+	164.063f,
+	46.9625f,
+	93.75f,
+	167.969f,
+	45.6865f,
+	93.75f,
+	171.875f,
+	45.7668f,
+	93.75f,
+	175.781f,
+	44.8303f,
+	93.75f,
+	179.688f,
+	42.5904f,
+	93.75f,
+	183.594f,
+	40.3536f,
+	93.75f,
+	187.5f,
+	37.9498f,
+	93.75f,
+	191.406f,
+	35.1415f,
+	93.75f,
+	195.313f,
+	31.5011f,
+	93.75f,
+	199.219f,
+	29.695f,
+	93.75f,
+	203.125f,
+	27.7988f,
+	93.75f,
+	207.031f,
+	26.3522f,
+	93.75f,
+	210.938f,
+	25.8544f,
+	93.75f,
+	214.844f,
+	24.7269f,
+	93.75f,
+	218.75f,
+	23.7697f,
+	93.75f,
+	222.656f,
+	20.9249f,
+	93.75f,
+	226.563f,
+	19.1368f,
+	93.75f,
+	230.469f,
+	18.5704f,
+	93.75f,
+	234.375f,
+	17.554f,
+	93.75f,
+	238.281f,
+	14.9004f,
+	93.75f,
+	242.188f,
+	16.3253f,
+	93.75f,
+	246.094f,
+	16.0037f,
+	93.75f,
+	250.0f,
+	15.9921f,
+	93.75f,
+	3.90625f,
+	15.6427f,
+	89.8438f,
+	7.8125f,
+	16.2722f,
+	89.8438f,
+	11.7188f,
+	17.6471f,
+	89.8438f,
+	15.625f,
+	18.8565f,
+	89.8438f,
+	19.5313f,
+	19.651f,
+	89.8438f,
+	23.4375f,
+	20.9243f,
+	89.8438f,
+	27.3438f,
+	20.8045f,
+	89.8438f,
+	31.25f,
+	20.2274f,
+	89.8438f,
+	35.1563f,
+	21.5768f,
+	89.8438f,
+	39.0625f,
+	22.566f,
+	89.8438f,
+	42.9688f,
+	23.4111f,
+	89.8438f,
+	46.875f,
+	23.5063f,
+	89.8438f,
+	50.7813f,
+	22.9631f,
+	89.8438f,
+	54.6875f,
+	21.5642f,
+	89.8438f,
+	58.5938f,
+	20.3649f,
+	89.8438f,
+	62.5f,
+	19.6177f,
+	89.8438f,
+	66.4063f,
+	18.6758f,
+	89.8438f,
+	70.3125f,
+	18.6837f,
+	89.8438f,
+	74.2188f,
+	19.7593f,
+	89.8438f,
+	78.125f,
+	20.4356f,
+	89.8438f,
+	82.0313f,
+	20.1806f,
+	89.8438f,
+	85.9375f,
+	19.4513f,
+	89.8438f,
+	89.8438f,
+	19.2942f,
+	89.8438f,
+	93.75f,
+	19.9864f,
+	89.8438f,
+	97.6563f,
+	20.6569f,
+	89.8438f,
+	101.563f,
+	20.8985f,
+	89.8438f,
+	105.469f,
+	20.8027f,
+	89.8438f,
+	109.375f,
+	21.5099f,
+	89.8438f,
+	113.281f,
+	22.7491f,
+	89.8438f,
+	117.188f,
+	24.1938f,
+	89.8438f,
+	121.094f,
+	27.3472f,
+	89.8438f,
+	125.0f,
+	29.9546f,
+	89.8438f,
+	128.906f,
+	32.3821f,
+	89.8438f,
+	132.813f,
+	34.2078f,
+	89.8438f,
+	136.719f,
+	35.7419f,
+	89.8438f,
+	140.625f,
+	36.6408f,
+	89.8438f,
+	144.531f,
+	39.1756f,
+	89.8438f,
+	148.438f,
+	42.1721f,
+	89.8438f,
+	152.344f,
+	43.7891f,
+	89.8438f,
+	156.25f,
+	45.9566f,
+	89.8438f,
+	160.156f,
+	47.5521f,
+	89.8438f,
+	164.063f,
+	47.0165f,
+	89.8438f,
+	167.969f,
+	46.0084f,
+	89.8438f,
+	171.875f,
+	46.0374f,
+	89.8438f,
+	175.781f,
+	45.9301f,
+	89.8438f,
+	179.688f,
+	43.5326f,
+	89.8438f,
+	183.594f,
+	40.5203f,
+	89.8438f,
+	187.5f,
+	38.133f,
+	89.8438f,
+	191.406f,
+	35.8688f,
+	89.8438f,
+	195.313f,
+	33.0648f,
+	89.8438f,
+	199.219f,
+	31.0451f,
+	89.8438f,
+	203.125f,
+	27.691f,
+	89.8438f,
+	207.031f,
+	26.7927f,
+	89.8438f,
+	210.938f,
+	26.334f,
+	89.8438f,
+	214.844f,
+	25.0669f,
+	89.8438f,
+	218.75f,
+	23.4149f,
+	89.8438f,
+	222.656f,
+	20.9786f,
+	89.8438f,
+	226.563f,
+	18.963f,
+	89.8438f,
+	230.469f,
+	18.7894f,
+	89.8438f,
+	234.375f,
+	17.2683f,
+	89.8438f,
+	238.281f,
+	14.98f,
+	89.8438f,
+	242.188f,
+	15.4163f,
+	89.8438f,
+	246.094f,
+	15.4238f,
+	89.8438f,
+	250.0f,
+	15.9208f,
+	89.8438f,
+	3.90625f,
+	15.5916f,
+	85.9375f,
+	7.8125f,
+	16.3916f,
+	85.9375f,
+	11.7188f,
+	18.2047f,
+	85.9375f,
+	15.625f,
+	19.1861f,
+	85.9375f,
+	19.5313f,
+	20.7525f,
+	85.9375f,
+	23.4375f,
+	21.6364f,
+	85.9375f,
+	27.3438f,
+	21.9262f,
+	85.9375f,
+	31.25f,
+	21.6225f,
+	85.9375f,
+	35.1563f,
+	22.4806f,
+	85.9375f,
+	39.0625f,
+	23.7973f,
+	85.9375f,
+	42.9688f,
+	24.6135f,
+	85.9375f,
+	46.875f,
+	24.8421f,
+	85.9375f,
+	50.7813f,
+	24.5451f,
+	85.9375f,
+	54.6875f,
+	23.688f,
+	85.9375f,
+	58.5938f,
+	22.221f,
+	85.9375f,
+	62.5f,
+	21.5009f,
+	85.9375f,
+	66.4063f,
+	21.2241f,
+	85.9375f,
+	70.3125f,
+	20.2058f,
+	85.9375f,
+	74.2188f,
+	20.3437f,
+	85.9375f,
+	78.125f,
+	21.8786f,
+	85.9375f,
+	82.0313f,
+	21.9425f,
+	85.9375f,
+	85.9375f,
+	20.6496f,
+	85.9375f,
+	89.8438f,
+	20.6855f,
+	85.9375f,
+	93.75f,
+	20.6495f,
+	85.9375f,
+	97.6563f,
+	21.0738f,
+	85.9375f,
+	101.563f,
+	21.7991f,
+	85.9375f,
+	105.469f,
+	22.3795f,
+	85.9375f,
+	109.375f,
+	22.4292f,
+	85.9375f,
+	113.281f,
+	23.6451f,
+	85.9375f,
+	117.188f,
+	24.8457f,
+	85.9375f,
+	121.094f,
+	26.7121f,
+	85.9375f,
+	125.0f,
+	29.2236f,
+	85.9375f,
+	128.906f,
+	31.5942f,
+	85.9375f,
+	132.813f,
+	33.8517f,
+	85.9375f,
+	136.719f,
+	35.7145f,
+	85.9375f,
+	140.625f,
+	36.6808f,
+	85.9375f,
+	144.531f,
+	38.8926f,
+	85.9375f,
+	148.438f,
+	41.6484f,
+	85.9375f,
+	152.344f,
+	44.2035f,
+	85.9375f,
+	156.25f,
+	45.1997f,
+	85.9375f,
+	160.156f,
+	46.1921f,
+	85.9375f,
+	164.063f,
+	47.2097f,
+	85.9375f,
+	167.969f,
+	47.0691f,
+	85.9375f,
+	171.875f,
+	45.5257f,
+	85.9375f,
+	175.781f,
+	44.6746f,
+	85.9375f,
+	179.688f,
+	43.6223f,
+	85.9375f,
+	183.594f,
+	40.2395f,
+	85.9375f,
+	187.5f,
+	38.445f,
+	85.9375f,
+	191.406f,
+	36.5002f,
+	85.9375f,
+	195.313f,
+	33.7977f,
+	85.9375f,
+	199.219f,
+	31.5943f,
+	85.9375f,
+	203.125f,
+	28.8305f,
+	85.9375f,
+	207.031f,
+	27.4922f,
+	85.9375f,
+	210.938f,
+	26.0386f,
+	85.9375f,
+	214.844f,
+	24.1792f,
+	85.9375f,
+	218.75f,
+	22.1567f,
+	85.9375f,
+	222.656f,
+	20.1169f,
+	85.9375f,
+	226.563f,
+	19.3603f,
+	85.9375f,
+	230.469f,
+	17.7703f,
+	85.9375f,
+	234.375f,
+	16.3147f,
+	85.9375f,
+	238.281f,
+	15.0886f,
+	85.9375f,
+	242.188f,
+	15.1332f,
+	85.9375f,
+	246.094f,
+	14.7802f,
+	85.9375f,
+	250.0f,
+	15.2259f,
+	85.9375f,
+	3.90625f,
+	16.9644f,
+	82.0313f,
+	7.8125f,
+	17.8f,
+	82.0313f,
+	11.7188f,
+	19.2943f,
+	82.0313f,
+	15.625f,
+	21.0269f,
+	82.0313f,
+	19.5313f,
+	22.3312f,
+	82.0313f,
+	23.4375f,
+	23.0871f,
+	82.0313f,
+	27.3438f,
+	23.1115f,
+	82.0313f,
+	31.25f,
+	23.5304f,
+	82.0313f,
+	35.1563f,
+	24.1493f,
+	82.0313f,
+	39.0625f,
+	25.0848f,
+	82.0313f,
+	42.9688f,
+	26.0789f,
+	82.0313f,
+	46.875f,
+	26.3399f,
+	82.0313f,
+	50.7813f,
+	25.4397f,
+	82.0313f,
+	54.6875f,
+	24.894f,
+	82.0313f,
+	58.5938f,
+	24.1026f,
+	82.0313f,
+	62.5f,
+	24.0749f,
+	82.0313f,
+	66.4063f,
+	23.5256f,
+	82.0313f,
+	70.3125f,
+	21.9612f,
+	82.0313f,
+	74.2188f,
+	21.932f,
+	82.0313f,
+	78.125f,
+	22.6241f,
+	82.0313f,
+	82.0313f,
+	22.672f,
+	82.0313f,
+	85.9375f,
+	21.4303f,
+	82.0313f,
+	89.8438f,
+	21.6964f,
+	82.0313f,
+	93.75f,
+	21.7198f,
+	82.0313f,
+	97.6563f,
+	22.4953f,
+	82.0313f,
+	101.563f,
+	23.0451f,
+	82.0313f,
+	105.469f,
+	23.0285f,
+	82.0313f,
+	109.375f,
+	23.24f,
+	82.0313f,
+	113.281f,
+	23.6861f,
+	82.0313f,
+	117.188f,
+	24.7685f,
+	82.0313f,
+	121.094f,
+	26.4466f,
+	82.0313f,
+	125.0f,
+	28.8315f,
+	82.0313f,
+	128.906f,
+	30.9624f,
+	82.0313f,
+	132.813f,
+	33.7991f,
+	82.0313f,
+	136.719f,
+	35.8079f,
+	82.0313f,
+	140.625f,
+	37.0254f,
+	82.0313f,
+	144.531f,
+	38.7479f,
+	82.0313f,
+	148.438f,
+	42.0473f,
+	82.0313f,
+	152.344f,
+	43.7879f,
+	82.0313f,
+	156.25f,
+	45.1826f,
+	82.0313f,
+	160.156f,
+	46.2454f,
+	82.0313f,
+	164.063f,
+	47.0196f,
+	82.0313f,
+	167.969f,
+	47.2872f,
+	82.0313f,
+	171.875f,
+	46.2496f,
+	82.0313f,
+	175.781f,
+	44.3338f,
+	82.0313f,
+	179.688f,
+	43.1095f,
+	82.0313f,
+	183.594f,
+	40.7857f,
+	82.0313f,
+	187.5f,
+	39.646f,
+	82.0313f,
+	191.406f,
+	37.5425f,
+	82.0313f,
+	195.313f,
+	35.2951f,
+	82.0313f,
+	199.219f,
+	33.6324f,
+	82.0313f,
+	203.125f,
+	30.8911f,
+	82.0313f,
+	207.031f,
+	27.2798f,
+	82.0313f,
+	210.938f,
+	25.4308f,
+	82.0313f,
+	214.844f,
+	23.8814f,
+	82.0313f,
+	218.75f,
+	22.4441f,
+	82.0313f,
+	222.656f,
+	20.3771f,
+	82.0313f,
+	226.563f,
+	19.2073f,
+	82.0313f,
+	230.469f,
+	19.0082f,
+	82.0313f,
+	234.375f,
+	17.769f,
+	82.0313f,
+	238.281f,
+	15.8302f,
+	82.0313f,
+	242.188f,
+	14.2967f,
+	82.0313f,
+	246.094f,
+	15.1365f,
+	82.0313f,
+	250.0f,
+	14.9159f,
+	82.0313f,
+	3.90625f,
+	18.8244f,
+	78.125f,
+	7.8125f,
+	19.5283f,
+	78.125f,
+	11.7188f,
+	20.9466f,
+	78.125f,
+	15.625f,
+	22.0951f,
+	78.125f,
+	19.5313f,
+	23.2483f,
+	78.125f,
+	23.4375f,
+	23.8238f,
+	78.125f,
+	27.3438f,
+	24.6236f,
+	78.125f,
+	31.25f,
+	24.0856f,
+	78.125f,
+	35.1563f,
+	25.6129f,
+	78.125f,
+	39.0625f,
+	26.8525f,
+	78.125f,
+	42.9688f,
+	26.9859f,
+	78.125f,
+	46.875f,
+	26.6403f,
+	78.125f,
+	50.7813f,
+	26.6419f,
+	78.125f,
+	54.6875f,
+	27.4236f,
+	78.125f,
+	58.5938f,
+	26.5989f,
+	78.125f,
+	62.5f,
+	26.137f,
+	78.125f,
+	66.4063f,
+	24.8717f,
+	78.125f,
+	70.3125f,
+	23.8694f,
+	78.125f,
+	74.2188f,
+	23.2668f,
+	78.125f,
+	78.125f,
+	23.1081f,
+	78.125f,
+	82.0313f,
+	23.3134f,
+	78.125f,
+	85.9375f,
+	23.0903f,
+	78.125f,
+	89.8438f,
+	23.2822f,
+	78.125f,
+	93.75f,
+	24.291f,
+	78.125f,
+	97.6563f,
+	24.5546f,
+	78.125f,
+	101.563f,
+	24.4216f,
+	78.125f,
+	105.469f,
+	24.6379f,
+	78.125f,
+	109.375f,
+	24.5235f,
+	78.125f,
+	113.281f,
+	24.88f,
+	78.125f,
+	117.188f,
+	25.6988f,
+	78.125f,
+	121.094f,
+	26.9155f,
+	78.125f,
+	125.0f,
+	29.7499f,
+	78.125f,
+	128.906f,
+	31.361f,
+	78.125f,
+	132.813f,
+	33.9367f,
+	78.125f,
+	136.719f,
+	35.4066f,
+	78.125f,
+	140.625f,
+	36.6153f,
+	78.125f,
+	144.531f,
+	38.6091f,
+	78.125f,
+	148.438f,
+	41.2276f,
+	78.125f,
+	152.344f,
+	43.2187f,
+	78.125f,
+	156.25f,
+	45.2494f,
+	78.125f,
+	160.156f,
+	46.5334f,
+	78.125f,
+	164.063f,
+	47.1659f,
+	78.125f,
+	167.969f,
+	47.5409f,
+	78.125f,
+	171.875f,
+	46.3778f,
+	78.125f,
+	175.781f,
+	44.8935f,
+	78.125f,
+	179.688f,
+	43.7429f,
+	78.125f,
+	183.594f,
+	42.4748f,
+	78.125f,
+	187.5f,
+	40.5234f,
+	78.125f,
+	191.406f,
+	38.2806f,
+	78.125f,
+	195.313f,
+	36.297f,
+	78.125f,
+	199.219f,
+	35.0641f,
+	78.125f,
+	203.125f,
+	32.4145f,
+	78.125f,
+	207.031f,
+	29.4539f,
+	78.125f,
+	210.938f,
+	25.7399f,
+	78.125f,
+	214.844f,
+	23.157f,
+	78.125f,
+	218.75f,
+	20.9425f,
+	78.125f,
+	222.656f,
+	19.2349f,
+	78.125f,
+	226.563f,
+	18.5576f,
+	78.125f,
+	230.469f,
+	18.8407f,
+	78.125f,
+	234.375f,
+	17.6562f,
+	78.125f,
+	238.281f,
+	15.7207f,
+	78.125f,
+	242.188f,
+	14.3385f,
+	78.125f,
+	246.094f,
+	13.9958f,
+	78.125f,
+	250.0f,
+	14.6888f,
+	78.125f,
+	3.90625f,
+	20.6829f,
+	74.2188f,
+	7.8125f,
+	22.7393f,
+	74.2188f,
+	11.7188f,
+	22.9007f,
+	74.2188f,
+	15.625f,
+	23.3717f,
+	74.2188f,
+	19.5313f,
+	23.7991f,
+	74.2188f,
+	23.4375f,
+	24.5576f,
+	74.2188f,
+	27.3438f,
+	25.3464f,
+	74.2188f,
+	31.25f,
+	25.8349f,
+	74.2188f,
+	35.1563f,
+	26.2326f,
+	74.2188f,
+	39.0625f,
+	27.8003f,
+	74.2188f,
+	42.9688f,
+	28.502f,
+	74.2188f,
+	46.875f,
+	28.7947f,
+	74.2188f,
+	50.7813f,
+	29.109f,
+	74.2188f,
+	54.6875f,
+	29.4315f,
+	74.2188f,
+	58.5938f,
+	29.1948f,
+	74.2188f,
+	62.5f,
+	28.241f,
+	74.2188f,
+	66.4063f,
+	26.6727f,
+	74.2188f,
+	70.3125f,
+	25.5496f,
+	74.2188f,
+	74.2188f,
+	24.2265f,
+	74.2188f,
+	78.125f,
+	24.8641f,
+	74.2188f,
+	82.0313f,
+	24.8692f,
+	74.2188f,
+	85.9375f,
+	23.8066f,
+	74.2188f,
+	89.8438f,
+	24.5827f,
+	74.2188f,
+	93.75f,
+	25.5885f,
+	74.2188f,
+	97.6563f,
+	25.005f,
+	74.2188f,
+	101.563f,
+	25.4768f,
+	74.2188f,
+	105.469f,
+	25.8326f,
+	74.2188f,
+	109.375f,
+	25.8587f,
+	74.2188f,
+	113.281f,
+	26.8029f,
+	74.2188f,
+	117.188f,
+	27.8764f,
+	74.2188f,
+	121.094f,
+	28.8835f,
+	74.2188f,
+	125.0f,
+	30.0077f,
+	74.2188f,
+	128.906f,
+	31.9776f,
+	74.2188f,
+	132.813f,
+	34.2008f,
+	74.2188f,
+	136.719f,
+	35.4023f,
+	74.2188f,
+	140.625f,
+	36.3754f,
+	74.2188f,
+	144.531f,
+	38.9991f,
+	74.2188f,
+	148.438f,
+	41.295f,
+	74.2188f,
+	152.344f,
+	44.1131f,
+	74.2188f,
+	156.25f,
+	46.2221f,
+	74.2188f,
+	160.156f,
+	46.7797f,
+	74.2188f,
+	164.063f,
+	47.446f,
+	74.2188f,
+	167.969f,
+	47.1396f,
+	74.2188f,
+	171.875f,
+	45.9937f,
+	74.2188f,
+	175.781f,
+	45.4284f,
+	74.2188f,
+	179.688f,
+	45.018f,
+	74.2188f,
+	183.594f,
+	43.1233f,
+	74.2188f,
+	187.5f,
+	41.2272f,
+	74.2188f,
+	191.406f,
+	37.8072f,
+	74.2188f,
+	195.313f,
+	36.5304f,
+	74.2188f,
+	199.219f,
+	35.1638f,
+	74.2188f,
+	203.125f,
+	33.1538f,
+	74.2188f,
+	207.031f,
+	30.2207f,
+	74.2188f,
+	210.938f,
+	26.1665f,
+	74.2188f,
+	214.844f,
+	22.1619f,
+	74.2188f,
+	218.75f,
+	18.452f,
+	74.2188f,
+	222.656f,
+	17.0925f,
+	74.2188f,
+	226.563f,
+	17.3468f,
+	74.2188f,
+	230.469f,
+	16.447f,
+	74.2188f,
+	234.375f,
+	15.7197f,
+	74.2188f,
+	238.281f,
+	14.7889f,
+	74.2188f,
+	242.188f,
+	13.641f,
+	74.2188f,
+	246.094f,
+	12.7728f,
+	74.2188f,
+	250.0f,
+	13.3875f,
+	74.2188f,
+	3.90625f,
+	22.948f,
+	70.3125f,
+	7.8125f,
+	24.3431f,
+	70.3125f,
+	11.7188f,
+	24.6307f,
+	70.3125f,
+	15.625f,
+	24.9963f,
+	70.3125f,
+	19.5313f,
+	25.2034f,
+	70.3125f,
+	23.4375f,
+	25.2791f,
+	70.3125f,
+	27.3438f,
+	25.8257f,
+	70.3125f,
+	31.25f,
+	27.1123f,
+	70.3125f,
+	35.1563f,
+	27.8795f,
+	70.3125f,
+	39.0625f,
+	28.8437f,
+	70.3125f,
+	42.9688f,
+	29.8883f,
+	70.3125f,
+	46.875f,
+	30.6548f,
+	70.3125f,
+	50.7813f,
+	31.0396f,
+	70.3125f,
+	54.6875f,
+	31.6324f,
+	70.3125f,
+	58.5938f,
+	31.5222f,
+	70.3125f,
+	62.5f,
+	30.4696f,
+	70.3125f,
+	66.4063f,
+	28.7208f,
+	70.3125f,
+	70.3125f,
+	26.8611f,
+	70.3125f,
+	74.2188f,
+	25.6776f,
+	70.3125f,
+	78.125f,
+	26.1193f,
+	70.3125f,
+	82.0313f,
+	25.1971f,
+	70.3125f,
+	85.9375f,
+	24.4814f,
+	70.3125f,
+	89.8438f,
+	25.1213f,
+	70.3125f,
+	93.75f,
+	26.1411f,
+	70.3125f,
+	97.6563f,
+	26.4276f,
+	70.3125f,
+	101.563f,
+	26.0728f,
+	70.3125f,
+	105.469f,
+	26.113f,
+	70.3125f,
+	109.375f,
+	27.5702f,
+	70.3125f,
+	113.281f,
+	28.6199f,
+	70.3125f,
+	117.188f,
+	30.054f,
+	70.3125f,
+	121.094f,
+	30.255f,
+	70.3125f,
+	125.0f,
+	30.9839f,
+	70.3125f,
+	128.906f,
+	32.4045f,
+	70.3125f,
+	132.813f,
+	33.9858f,
+	70.3125f,
+	136.719f,
+	35.8568f,
+	70.3125f,
+	140.625f,
+	37.5803f,
+	70.3125f,
+	144.531f,
+	40.2984f,
+	70.3125f,
+	148.438f,
+	41.9326f,
+	70.3125f,
+	152.344f,
+	44.1607f,
+	70.3125f,
+	156.25f,
+	45.6454f,
+	70.3125f,
+	160.156f,
+	47.3567f,
+	70.3125f,
+	164.063f,
+	48.1147f,
+	70.3125f,
+	167.969f,
+	47.7671f,
+	70.3125f,
+	171.875f,
+	46.1009f,
+	70.3125f,
+	175.781f,
+	45.3829f,
+	70.3125f,
+	179.688f,
+	44.3458f,
+	70.3125f,
+	183.594f,
+	42.818f,
+	70.3125f,
+	187.5f,
+	40.5253f,
+	70.3125f,
+	191.406f,
+	37.6731f,
+	70.3125f,
+	195.313f,
+	36.7234f,
+	70.3125f,
+	199.219f,
+	35.0848f,
+	70.3125f,
+	203.125f,
+	33.0857f,
+	70.3125f,
+	207.031f,
+	30.0508f,
+	70.3125f,
+	210.938f,
+	26.741f,
+	70.3125f,
+	214.844f,
+	22.7613f,
+	70.3125f,
+	218.75f,
+	18.5375f,
+	70.3125f,
+	222.656f,
+	15.6052f,
+	70.3125f,
+	226.563f,
+	14.6945f,
+	70.3125f,
+	230.469f,
+	15.0013f,
+	70.3125f,
+	234.375f,
+	13.9965f,
+	70.3125f,
+	238.281f,
+	12.4404f,
+	70.3125f,
+	242.188f,
+	12.4448f,
+	70.3125f,
+	246.094f,
+	11.7446f,
+	70.3125f,
+	250.0f,
+	11.7886f,
+	70.3125f,
+	3.90625f,
+	25.5564f,
+	66.4063f,
+	7.8125f,
+	26.1216f,
+	66.4063f,
+	11.7188f,
+	26.234f,
+	66.4063f,
+	15.625f,
+	26.4553f,
+	66.4063f,
+	19.5313f,
+	26.9827f,
+	66.4063f,
+	23.4375f,
+	27.0173f,
+	66.4063f,
+	27.3438f,
+	27.3577f,
+	66.4063f,
+	31.25f,
+	28.895f,
+	66.4063f,
+	35.1563f,
+	30.1057f,
+	66.4063f,
+	39.0625f,
+	30.249f,
+	66.4063f,
+	42.9688f,
+	31.1394f,
+	66.4063f,
+	46.875f,
+	31.7197f,
+	66.4063f,
+	50.7813f,
+	33.2905f,
+	66.4063f,
+	54.6875f,
+	33.6208f,
+	66.4063f,
+	58.5938f,
+	33.5152f,
+	66.4063f,
+	62.5f,
+	31.5128f,
+	66.4063f,
+	66.4063f,
+	30.1049f,
+	66.4063f,
+	70.3125f,
+	28.9139f,
+	66.4063f,
+	74.2188f,
+	27.093f,
+	66.4063f,
+	78.125f,
+	26.8272f,
+	66.4063f,
+	82.0313f,
+	25.8777f,
+	66.4063f,
+	85.9375f,
+	25.2597f,
+	66.4063f,
+	89.8438f,
+	25.8742f,
+	66.4063f,
+	93.75f,
+	27.4783f,
+	66.4063f,
+	97.6563f,
+	27.1897f,
+	66.4063f,
+	101.563f,
+	26.8406f,
+	66.4063f,
+	105.469f,
+	27.2889f,
+	66.4063f,
+	109.375f,
+	28.6616f,
+	66.4063f,
+	113.281f,
+	29.2852f,
+	66.4063f,
+	117.188f,
+	30.3362f,
+	66.4063f,
+	121.094f,
+	32.0648f,
+	66.4063f,
+	125.0f,
+	32.6693f,
+	66.4063f,
+	128.906f,
+	33.7239f,
+	66.4063f,
+	132.813f,
+	34.8193f,
+	66.4063f,
+	136.719f,
+	36.6878f,
+	66.4063f,
+	140.625f,
+	38.5422f,
+	66.4063f,
+	144.531f,
+	40.5193f,
+	66.4063f,
+	148.438f,
+	42.0434f,
+	66.4063f,
+	152.344f,
+	43.692f,
+	66.4063f,
+	156.25f,
+	46.2f,
+	66.4063f,
+	160.156f,
+	47.7247f,
+	66.4063f,
+	164.063f,
+	48.3486f,
+	66.4063f,
+	167.969f,
+	48.4057f,
+	66.4063f,
+	171.875f,
+	47.4141f,
+	66.4063f,
+	175.781f,
+	45.925f,
+	66.4063f,
+	179.688f,
+	44.0772f,
+	66.4063f,
+	183.594f,
+	42.0866f,
+	66.4063f,
+	187.5f,
+	40.2687f,
+	66.4063f,
+	191.406f,
+	38.0236f,
+	66.4063f,
+	195.313f,
+	36.9223f,
+	66.4063f,
+	199.219f,
+	35.6323f,
+	66.4063f,
+	203.125f,
+	33.0001f,
+	66.4063f,
+	207.031f,
+	30.1425f,
+	66.4063f,
+	210.938f,
+	26.4551f,
+	66.4063f,
+	214.844f,
+	22.4224f,
+	66.4063f,
+	218.75f,
+	18.5557f,
+	66.4063f,
+	222.656f,
+	16.1428f,
+	66.4063f,
+	226.563f,
+	14.9942f,
+	66.4063f,
+	230.469f,
+	14.9221f,
+	66.4063f,
+	234.375f,
+	13.3816f,
+	66.4063f,
+	238.281f,
+	10.9914f,
+	66.4063f,
+	242.188f,
+	10.6094f,
+	66.4063f,
+	246.094f,
+	9.77905f,
+	66.4063f,
+	250.0f,
+	9.99853f,
+	66.4063f,
+	3.90625f,
+	27.1929f,
+	62.5f,
+	7.8125f,
+	28.1411f,
+	62.5f,
+	11.7188f,
+	27.9312f,
+	62.5f,
+	15.625f,
+	27.692f,
+	62.5f,
+	19.5313f,
+	27.8511f,
+	62.5f,
+	23.4375f,
+	28.2162f,
+	62.5f,
+	27.3438f,
+	29.5518f,
+	62.5f,
+	31.25f,
+	30.2367f,
+	62.5f,
+	35.1563f,
+	31.1075f,
+	62.5f,
+	39.0625f,
+	31.6239f,
+	62.5f,
+	42.9688f,
+	32.8498f,
+	62.5f,
+	46.875f,
+	33.1521f,
+	62.5f,
+	50.7813f,
+	34.6411f,
+	62.5f,
+	54.6875f,
+	35.0063f,
+	62.5f,
+	58.5938f,
+	33.8006f,
+	62.5f,
+	62.5f,
+	33.1029f,
+	62.5f,
+	66.4063f,
+	32.1466f,
+	62.5f,
+	70.3125f,
+	30.2614f,
+	62.5f,
+	74.2188f,
+	28.2978f,
+	62.5f,
+	78.125f,
+	28.0764f,
+	62.5f,
+	82.0313f,
+	27.2473f,
+	62.5f,
+	85.9375f,
+	26.2769f,
+	62.5f,
+	89.8438f,
+	26.2922f,
+	62.5f,
+	93.75f,
+	27.1235f,
+	62.5f,
+	97.6563f,
+	27.498f,
+	62.5f,
+	101.563f,
+	27.2257f,
+	62.5f,
+	105.469f,
+	28.2897f,
+	62.5f,
+	109.375f,
+	28.8921f,
+	62.5f,
+	113.281f,
+	30.563f,
+	62.5f,
+	117.188f,
+	32.1298f,
+	62.5f,
+	121.094f,
+	32.8639f,
+	62.5f,
+	125.0f,
+	34.6537f,
+	62.5f,
+	128.906f,
+	35.4867f,
+	62.5f,
+	132.813f,
+	36.6181f,
+	62.5f,
+	136.719f,
+	37.6418f,
+	62.5f,
+	140.625f,
+	39.2228f,
+	62.5f,
+	144.531f,
+	40.5105f,
+	62.5f,
+	148.438f,
+	42.215f,
+	62.5f,
+	152.344f,
+	43.5394f,
+	62.5f,
+	156.25f,
+	45.1171f,
+	62.5f,
+	160.156f,
+	46.6711f,
+	62.5f,
+	164.063f,
+	47.4274f,
+	62.5f,
+	167.969f,
+	47.6821f,
+	62.5f,
+	171.875f,
+	48.0762f,
+	62.5f,
+	175.781f,
+	46.4607f,
+	62.5f,
+	179.688f,
+	44.7623f,
+	62.5f,
+	183.594f,
+	42.6372f,
+	62.5f,
+	187.5f,
+	40.3231f,
+	62.5f,
+	191.406f,
+	38.4371f,
+	62.5f,
+	195.313f,
+	36.1978f,
+	62.5f,
+	199.219f,
+	35.38f,
+	62.5f,
+	203.125f,
+	32.0325f,
+	62.5f,
+	207.031f,
+	29.2047f,
+	62.5f,
+	210.938f,
+	27.481f,
+	62.5f,
+	214.844f,
+	24.0627f,
+	62.5f,
+	218.75f,
+	20.6235f,
+	62.5f,
+	222.656f,
+	18.5468f,
+	62.5f,
+	226.563f,
+	17.2736f,
+	62.5f,
+	230.469f,
+	15.4125f,
+	62.5f,
+	234.375f,
+	13.6775f,
+	62.5f,
+	238.281f,
+	11.4407f,
+	62.5f,
+	242.188f,
+	9.73154f,
+	62.5f,
+	246.094f,
+	8.55197f,
+	62.5f,
+	250.0f,
+	8.43693f,
+	62.5f,
+	3.90625f,
+	28.3495f,
+	58.5938f,
+	7.8125f,
+	28.8832f,
+	58.5938f,
+	11.7188f,
+	28.5512f,
+	58.5938f,
+	15.625f,
+	28.8533f,
+	58.5938f,
+	19.5313f,
+	29.0576f,
+	58.5938f,
+	23.4375f,
+	30.3079f,
+	58.5938f,
+	27.3438f,
+	31.3861f,
+	58.5938f,
+	31.25f,
+	33.0252f,
+	58.5938f,
+	35.1563f,
+	33.4087f,
+	58.5938f,
+	39.0625f,
+	34.3736f,
+	58.5938f,
+	42.9688f,
+	34.6944f,
+	58.5938f,
+	46.875f,
+	34.1156f,
+	58.5938f,
+	50.7813f,
+	34.7246f,
+	58.5938f,
+	54.6875f,
+	35.3934f,
+	58.5938f,
+	58.5938f,
+	34.9508f,
+	58.5938f,
+	62.5f,
+	34.469f,
+	58.5938f,
+	66.4063f,
+	33.1584f,
+	58.5938f,
+	70.3125f,
+	30.5913f,
+	58.5938f,
+	74.2188f,
+	30.4147f,
+	58.5938f,
+	78.125f,
+	30.821f,
+	58.5938f,
+	82.0313f,
+	29.9244f,
+	58.5938f,
+	85.9375f,
+	28.365f,
+	58.5938f,
+	89.8438f,
+	27.8694f,
+	58.5938f,
+	93.75f,
+	27.7517f,
+	58.5938f,
+	97.6563f,
+	27.9188f,
+	58.5938f,
+	101.563f,
+	27.7605f,
+	58.5938f,
+	105.469f,
+	28.252f,
+	58.5938f,
+	109.375f,
+	29.4592f,
+	58.5938f,
+	113.281f,
+	31.2608f,
+	58.5938f,
+	117.188f,
+	33.5373f,
+	58.5938f,
+	121.094f,
+	34.4995f,
+	58.5938f,
+	125.0f,
+	35.1593f,
+	58.5938f,
+	128.906f,
+	36.6148f,
+	58.5938f,
+	132.813f,
+	37.1425f,
+	58.5938f,
+	136.719f,
+	38.2148f,
+	58.5938f,
+	140.625f,
+	38.9964f,
+	58.5938f,
+	144.531f,
+	40.3196f,
+	58.5938f,
+	148.438f,
+	42.4959f,
+	58.5938f,
+	152.344f,
+	43.37f,
+	58.5938f,
+	156.25f,
+	44.3488f,
+	58.5938f,
+	160.156f,
+	45.6441f,
+	58.5937f,
+	164.063f,
+	45.6597f,
+	58.5937f,
+	167.969f,
+	46.9631f,
+	58.5938f,
+	171.875f,
+	47.0933f,
+	58.5938f,
+	175.781f,
+	45.839f,
+	58.5937f,
+	179.688f,
+	44.0491f,
+	58.5937f,
+	183.594f,
+	41.6462f,
+	58.5938f,
+	187.5f,
+	39.9012f,
+	58.5938f,
+	191.406f,
+	37.8373f,
+	58.5938f,
+	195.313f,
+	35.0871f,
+	58.5938f,
+	199.219f,
+	34.6045f,
+	58.5938f,
+	203.125f,
+	32.4469f,
+	58.5938f,
+	207.031f,
+	30.5103f,
+	58.5938f,
+	210.938f,
+	28.7194f,
+	58.5938f,
+	214.844f,
+	26.3358f,
+	58.5938f,
+	218.75f,
+	24.3668f,
+	58.5938f,
+	222.656f,
+	22.1719f,
+	58.5938f,
+	226.563f,
+	20.1708f,
+	58.5938f,
+	230.469f,
+	18.1384f,
+	58.5938f,
+	234.375f,
+	15.6994f,
+	58.5938f,
+	238.281f,
+	12.6124f,
+	58.5938f,
+	242.188f,
+	11.2279f,
+	58.5938f,
+	246.094f,
+	10.4938f,
+	58.5938f,
+	250.0f,
+	9.45058f,
+	58.5938f,
+	3.90625f,
+	29.2057f,
+	54.6875f,
+	7.8125f,
+	29.4161f,
+	54.6875f,
+	11.7188f,
+	29.6274f,
+	54.6875f,
+	15.625f,
+	29.8747f,
+	54.6875f,
+	19.5313f,
+	31.3353f,
+	54.6875f,
+	23.4375f,
+	32.5261f,
+	54.6875f,
+	27.3438f,
+	34.3893f,
+	54.6875f,
+	31.25f,
+	34.9525f,
+	54.6875f,
+	35.1563f,
+	35.8992f,
+	54.6875f,
+	39.0625f,
+	36.2066f,
+	54.6875f,
+	42.9688f,
+	36.4212f,
+	54.6875f,
+	46.875f,
+	36.1377f,
+	54.6875f,
+	50.7813f,
+	35.4213f,
+	54.6875f,
+	54.6875f,
+	35.5045f,
+	54.6875f,
+	58.5938f,
+	36.0891f,
+	54.6875f,
+	62.5f,
+	36.0244f,
+	54.6875f,
+	66.4063f,
+	34.9086f,
+	54.6875f,
+	70.3125f,
+	32.8671f,
+	54.6875f,
+	74.2188f,
+	33.5578f,
+	54.6875f,
+	78.125f,
+	33.8468f,
+	54.6875f,
+	82.0313f,
+	32.868f,
+	54.6875f,
+	85.9375f,
+	31.2245f,
+	54.6875f,
+	89.8438f,
+	29.442f,
+	54.6875f,
+	93.75f,
+	28.9144f,
+	54.6875f,
+	97.6563f,
+	27.6797f,
+	54.6875f,
+	101.563f,
+	27.9585f,
+	54.6875f,
+	105.469f,
+	28.5492f,
+	54.6875f,
+	109.375f,
+	29.119f,
+	54.6875f,
+	113.281f,
+	30.7234f,
+	54.6875f,
+	117.188f,
+	32.402f,
+	54.6875f,
+	121.094f,
+	34.3605f,
+	54.6875f,
+	125.0f,
+	35.6614f,
+	54.6875f,
+	128.906f,
+	37.1814f,
+	54.6875f,
+	132.813f,
+	37.8509f,
+	54.6875f,
+	136.719f,
+	38.3282f,
+	54.6875f,
+	140.625f,
+	39.021f,
+	54.6875f,
+	144.531f,
+	39.8455f,
+	54.6875f,
+	148.438f,
+	41.3547f,
+	54.6875f,
+	152.344f,
+	42.0848f,
+	54.6875f,
+	156.25f,
+	42.4546f,
+	54.6875f,
+	160.156f,
+	43.3035f,
+	54.6875f,
+	164.063f,
+	44.2757f,
+	54.6875f,
+	167.969f,
+	45.0917f,
+	54.6875f,
+	171.875f,
+	44.9479f,
+	54.6875f,
+	175.781f,
+	44.386f,
+	54.6875f,
+	179.688f,
+	43.1031f,
+	54.6875f,
+	183.594f,
+	41.5243f,
+	54.6875f,
+	187.5f,
+	39.9976f,
+	54.6875f,
+	191.406f,
+	37.1931f,
+	54.6875f,
+	195.313f,
+	35.2297f,
+	54.6875f,
+	199.219f,
+	34.439f,
+	54.6875f,
+	203.125f,
+	32.7399f,
+	54.6875f,
+	207.031f,
+	31.4766f,
+	54.6875f,
+	210.938f,
+	29.9402f,
+	54.6875f,
+	214.844f,
+	28.6752f,
+	54.6875f,
+	218.75f,
+	27.0387f,
+	54.6875f,
+	222.656f,
+	24.4777f,
+	54.6875f,
+	226.563f,
+	21.7169f,
+	54.6875f,
+	230.469f,
+	20.0299f,
+	54.6875f,
+	234.375f,
+	17.3103f,
+	54.6875f,
+	238.281f,
+	14.1891f,
+	54.6875f,
+	242.188f,
+	12.1605f,
+	54.6875f,
+	246.094f,
+	10.9065f,
+	54.6875f,
+	250.0f,
+	10.6619f,
+	54.6875f,
+	3.90625f,
+	30.4306f,
+	50.7813f,
+	7.8125f,
+	30.9679f,
+	50.7813f,
+	11.7188f,
+	31.3065f,
+	50.7813f,
+	15.625f,
+	32.0527f,
+	50.7813f,
+	19.5313f,
+	33.9185f,
+	50.7813f,
+	23.4375f,
+	34.6834f,
+	50.7813f,
+	27.3438f,
+	35.8025f,
+	50.7813f,
+	31.25f,
+	36.824f,
+	50.7813f,
+	35.1563f,
+	37.9949f,
+	50.7813f,
+	39.0625f,
+	38.2428f,
+	50.7813f,
+	42.9688f,
+	37.3912f,
+	50.7813f,
+	46.875f,
+	37.2849f,
+	50.7813f,
+	50.7813f,
+	36.4441f,
+	50.7813f,
+	54.6875f,
+	36.5986f,
+	50.7813f,
+	58.5938f,
+	36.7371f,
+	50.7813f,
+	62.5f,
+	36.6154f,
+	50.7813f,
+	66.4063f,
+	35.9475f,
+	50.7813f,
+	70.3125f,
+	35.1832f,
+	50.7813f,
+	74.2188f,
+	35.7876f,
+	50.7813f,
+	78.125f,
+	35.9086f,
+	50.7813f,
+	82.0313f,
+	35.0048f,
+	50.7813f,
+	85.9375f,
+	33.7202f,
+	50.7813f,
+	89.8438f,
+	32.6473f,
+	50.7813f,
+	93.75f,
+	30.9552f,
+	50.7813f,
+	97.6563f,
+	28.7453f,
+	50.7813f,
+	101.563f,
+	29.1526f,
+	50.7813f,
+	105.469f,
+	29.9957f,
+	50.7813f,
+	109.375f,
+	30.5544f,
+	50.7813f,
+	113.281f,
+	31.6947f,
+	50.7813f,
+	117.188f,
+	32.7584f,
+	50.7813f,
+	121.094f,
+	34.2518f,
+	50.7813f,
+	125.0f,
+	36.3694f,
+	50.7813f,
+	128.906f,
+	36.9477f,
+	50.7813f,
+	132.813f,
+	37.2918f,
+	50.7813f,
+	136.719f,
+	37.8325f,
+	50.7813f,
+	140.625f,
+	38.0845f,
+	50.7813f,
+	144.531f,
+	40.0088f,
+	50.7813f,
+	148.438f,
+	40.8219f,
+	50.7813f,
+	152.344f,
+	42.4039f,
+	50.7813f,
+	156.25f,
+	42.6086f,
+	50.7813f,
+	160.156f,
+	43.5487f,
+	50.7813f,
+	164.063f,
+	43.5328f,
+	50.7813f,
+	167.969f,
+	44.212f,
+	50.7812f,
+	171.875f,
+	43.6744f,
+	50.7813f,
+	175.781f,
+	43.198f,
+	50.7813f,
+	179.688f,
+	42.957f,
+	50.7813f,
+	183.594f,
+	41.4993f,
+	50.7813f,
+	187.5f,
+	39.5101f,
+	50.7813f,
+	191.406f,
+	38.1729f,
+	50.7813f,
+	195.313f,
+	35.4881f,
+	50.7813f,
+	199.219f,
+	34.6384f,
+	50.7813f,
+	203.125f,
+	34.1873f,
+	50.7813f,
+	207.031f,
+	32.1155f,
+	50.7813f,
+	210.938f,
+	30.912f,
+	50.7813f,
+	214.844f,
+	30.3391f,
+	50.7813f,
+	218.75f,
+	28.1256f,
+	50.7813f,
+	222.656f,
+	24.902f,
+	50.7813f,
+	226.563f,
+	22.2443f,
+	50.7813f,
+	230.469f,
+	20.9172f,
+	50.7813f,
+	234.375f,
+	18.8508f,
+	50.7813f,
+	238.281f,
+	15.9912f,
+	50.7813f,
+	242.188f,
+	12.7716f,
+	50.7813f,
+	246.094f,
+	11.6189f,
+	50.7813f,
+	250.0f,
+	12.2688f,
+	50.7813f,
+	3.90625f,
+	30.8772f,
+	46.875f,
+	7.8125f,
+	32.4754f,
+	46.875f,
+	11.7188f,
+	33.6983f,
+	46.875f,
+	15.625f,
+	35.14f,
+	46.875f,
+	19.5313f,
+	37.0369f,
+	46.875f,
+	23.4375f,
+	38.369f,
+	46.875f,
+	27.3438f,
+	38.6134f,
+	46.875f,
+	31.25f,
+	38.9784f,
+	46.875f,
+	35.1563f,
+	39.9891f,
+	46.875f,
+	39.0625f,
+	40.3197f,
+	46.875f,
+	42.9688f,
+	39.9692f,
+	46.875f,
+	46.875f,
+	39.6994f,
+	46.875f,
+	50.7813f,
+	39.4183f,
+	46.875f,
+	54.6875f,
+	38.2948f,
+	46.875f,
+	58.5938f,
+	38.32f,
+	46.875f,
+	62.5f,
+	38.621f,
+	46.875f,
+	66.4063f,
+	38.2134f,
+	46.875f,
+	70.3125f,
+	36.9577f,
+	46.875f,
+	74.2188f,
+	37.2936f,
+	46.875f,
+	78.125f,
+	37.8653f,
+	46.875f,
+	82.0313f,
+	36.9058f,
+	46.875f,
+	85.9375f,
+	36.1841f,
+	46.875f,
+	89.8438f,
+	34.8143f,
+	46.875f,
+	93.75f,
+	33.0783f,
+	46.875f,
+	97.6563f,
+	30.9854f,
+	46.875f,
+	101.563f,
+	30.934f,
+	46.875f,
+	105.469f,
+	32.108f,
+	46.875f,
+	109.375f,
+	33.0462f,
+	46.875f,
+	113.281f,
+	32.9253f,
+	46.875f,
+	117.188f,
+	33.3377f,
+	46.875f,
+	121.094f,
+	34.2153f,
+	46.875f,
+	125.0f,
+	35.0739f,
+	46.875f,
+	128.906f,
+	36.8239f,
+	46.875f,
+	132.813f,
+	37.1463f,
+	46.875f,
+	136.719f,
+	37.5409f,
+	46.875f,
+	140.625f,
+	38.8265f,
+	46.875f,
+	144.531f,
+	40.7241f,
+	46.875f,
+	148.438f,
+	40.9349f,
+	46.875f,
+	152.344f,
+	42.4491f,
+	46.875f,
+	156.25f,
+	43.9695f,
+	46.875f,
+	160.156f,
+	44.2191f,
+	46.875f,
+	164.063f,
+	44.9265f,
+	46.875f,
+	167.969f,
+	43.9423f,
+	46.875f,
+	171.875f,
+	43.273f,
+	46.875f,
+	175.781f,
+	43.2543f,
+	46.875f,
+	179.688f,
+	42.5328f,
+	46.875f,
+	183.594f,
+	41.1777f,
+	46.875f,
+	187.5f,
+	39.3553f,
+	46.875f,
+	191.406f,
+	37.8242f,
+	46.875f,
+	195.313f,
+	36.4649f,
+	46.875f,
+	199.219f,
+	35.6955f,
+	46.875f,
+	203.125f,
+	35.1878f,
+	46.875f,
+	207.031f,
+	32.9438f,
+	46.875f,
+	210.938f,
+	31.3677f,
+	46.875f,
+	214.844f,
+	30.7282f,
+	46.875f,
+	218.75f,
+	28.3328f,
+	46.875f,
+	222.656f,
+	25.0599f,
+	46.875f,
+	226.563f,
+	24.1932f,
+	46.875f,
+	230.469f,
+	22.3853f,
+	46.875f,
+	234.375f,
+	19.4896f,
+	46.875f,
+	238.281f,
+	16.8753f,
+	46.875f,
+	242.188f,
+	13.9469f,
+	46.875f,
+	246.094f,
+	13.2975f,
+	46.875f,
+	250.0f,
+	13.2524f,
+	46.875f,
+	3.90625f,
+	31.8945f,
+	42.9688f,
+	7.8125f,
+	34.0117f,
+	42.9688f,
+	11.7188f,
+	36.2441f,
+	42.9688f,
+	15.625f,
+	37.3622f,
+	42.9688f,
+	19.5313f,
+	39.5877f,
+	42.9688f,
+	23.4375f,
+	41.0994f,
+	42.9688f,
+	27.3438f,
+	42.0864f,
+	42.9688f,
+	31.25f,
+	42.0849f,
+	42.9688f,
+	35.1563f,
+	42.2038f,
+	42.9688f,
+	39.0625f,
+	43.473f,
+	42.9688f,
+	42.9688f,
+	42.7754f,
+	42.9688f,
+	46.875f,
+	42.3177f,
+	42.9688f,
+	50.7813f,
+	42.209f,
+	42.9688f,
+	54.6875f,
+	41.3095f,
+	42.9688f,
+	58.5938f,
+	40.8629f,
+	42.9688f,
+	62.5f,
+	40.4776f,
+	42.9688f,
+	66.4063f,
+	40.1396f,
+	42.9688f,
+	70.3125f,
+	39.1169f,
+	42.9688f,
+	74.2188f,
+	39.1382f,
+	42.9688f,
+	78.125f,
+	39.1421f,
+	42.9688f,
+	82.0313f,
+	38.9022f,
+	42.9688f,
+	85.9375f,
+	37.5711f,
+	42.9688f,
+	89.8438f,
+	36.7924f,
+	42.9688f,
+	93.75f,
+	34.7734f,
+	42.9688f,
+	97.6563f,
+	33.167f,
+	42.9688f,
+	101.563f,
+	32.4173f,
+	42.9688f,
+	105.469f,
+	33.0466f,
+	42.9688f,
+	109.375f,
+	33.3882f,
+	42.9688f,
+	113.281f,
+	33.7538f,
+	42.9688f,
+	117.188f,
+	33.5661f,
+	42.9688f,
+	121.094f,
+	33.9051f,
+	42.9688f,
+	125.0f,
+	34.9181f,
+	42.9688f,
+	128.906f,
+	35.2925f,
+	42.9688f,
+	132.813f,
+	37.1741f,
+	42.9688f,
+	136.719f,
+	38.0993f,
+	42.9688f,
+	140.625f,
+	38.7621f,
+	42.9688f,
+	144.531f,
+	39.712f,
+	42.9688f,
+	148.438f,
+	40.7257f,
+	42.9688f,
+	152.344f,
+	42.2465f,
+	42.9688f,
+	156.25f,
+	43.5331f,
+	42.9688f,
+	160.156f,
+	44.6745f,
+	42.9687f,
+	164.063f,
+	44.564f,
+	42.9688f,
+	167.969f,
+	44.6075f,
+	42.9688f,
+	171.875f,
+	43.2227f,
+	42.9688f,
+	175.781f,
+	42.5688f,
+	42.9688f,
+	179.688f,
+	41.9742f,
+	42.9688f,
+	183.594f,
+	40.3484f,
+	42.9688f,
+	187.5f,
+	38.9109f,
+	42.9688f,
+	191.406f,
+	37.7273f,
+	42.9688f,
+	195.313f,
+	36.5287f,
+	42.9688f,
+	199.219f,
+	35.9361f,
+	42.9688f,
+	203.125f,
+	35.1638f,
+	42.9688f,
+	207.031f,
+	33.6615f,
+	42.9688f,
+	210.938f,
+	31.2785f,
+	42.9688f,
+	214.844f,
+	30.1259f,
+	42.9688f,
+	218.75f,
+	28.6143f,
+	42.9688f,
+	222.656f,
+	26.1162f,
+	42.9688f,
+	226.563f,
+	24.2882f,
+	42.9688f,
+	230.469f,
+	22.5195f,
+	42.9688f,
+	234.375f,
+	20.1462f,
+	42.9688f,
+	238.281f,
+	17.4811f,
+	42.9688f,
+	242.188f,
+	15.2736f,
+	42.9688f,
+	246.094f,
+	13.788f,
+	42.9688f,
+	250.0f,
+	13.1723f,
+	42.9688f,
+	3.90625f,
+	34.9171f,
+	39.0625f,
+	7.8125f,
+	36.7711f,
+	39.0625f,
+	11.7188f,
+	38.5677f,
+	39.0625f,
+	15.625f,
+	40.0524f,
+	39.0625f,
+	19.5313f,
+	42.2392f,
+	39.0625f,
+	23.4375f,
+	43.2332f,
+	39.0625f,
+	27.3438f,
+	44.8254f,
+	39.0625f,
+	31.25f,
+	45.1808f,
+	39.0625f,
+	35.1563f,
+	44.9684f,
+	39.0625f,
+	39.0625f,
+	45.0647f,
+	39.0625f,
+	42.9688f,
+	45.0888f,
+	39.0625f,
+	46.875f,
+	45.5266f,
+	39.0625f,
+	50.7813f,
+	45.2542f,
+	39.0625f,
+	54.6875f,
+	44.1797f,
+	39.0625f,
+	58.5938f,
+	43.2658f,
+	39.0625f,
+	62.5f,
+	42.7568f,
+	39.0625f,
+	66.4063f,
+	42.4159f,
+	39.0625f,
+	70.3125f,
+	41.3883f,
+	39.0625f,
+	74.2188f,
+	41.1975f,
+	39.0625f,
+	78.125f,
+	41.3073f,
+	39.0625f,
+	82.0313f,
+	41.0587f,
+	39.0625f,
+	85.9375f,
+	40.0611f,
+	39.0625f,
+	89.8438f,
+	38.7299f,
+	39.0625f,
+	93.75f,
+	37.2923f,
+	39.0625f,
+	97.6563f,
+	35.7971f,
+	39.0625f,
+	101.563f,
+	35.1982f,
+	39.0625f,
+	105.469f,
+	33.6408f,
+	39.0625f,
+	109.375f,
+	33.2619f,
+	39.0625f,
+	113.281f,
+	33.8387f,
+	39.0625f,
+	117.188f,
+	34.7554f,
+	39.0625f,
+	121.094f,
+	33.8569f,
+	39.0625f,
+	125.0f,
+	34.7741f,
+	39.0625f,
+	128.906f,
+	35.7319f,
+	39.0625f,
+	132.813f,
+	36.6023f,
+	39.0625f,
+	136.719f,
+	37.7084f,
+	39.0625f,
+	140.625f,
+	38.2513f,
+	39.0625f,
+	144.531f,
+	39.1992f,
+	39.0625f,
+	148.438f,
+	40.2336f,
+	39.0625f,
+	152.344f,
+	41.0883f,
+	39.0625f,
+	156.25f,
+	42.4004f,
+	39.0625f,
+	160.156f,
+	42.8753f,
+	39.0625f,
+	164.063f,
+	43.1631f,
+	39.0625f,
+	167.969f,
+	43.6378f,
+	39.0625f,
+	171.875f,
+	43.2113f,
+	39.0625f,
+	175.781f,
+	42.5474f,
+	39.0625f,
+	179.688f,
+	41.3413f,
+	39.0625f,
+	183.594f,
+	39.4383f,
+	39.0625f,
+	187.5f,
+	38.9723f,
+	39.0625f,
+	191.406f,
+	37.3549f,
+	39.0625f,
+	195.313f,
+	35.8615f,
+	39.0625f,
+	199.219f,
+	34.9243f,
+	39.0625f,
+	203.125f,
+	34.598f,
+	39.0625f,
+	207.031f,
+	33.6592f,
+	39.0625f,
+	210.938f,
+	32.2347f,
+	39.0625f,
+	214.844f,
+	30.4117f,
+	39.0625f,
+	218.75f,
+	28.4787f,
+	39.0625f,
+	222.656f,
+	26.6538f,
+	39.0625f,
+	226.563f,
+	24.4892f,
+	39.0625f,
+	230.469f,
+	22.9637f,
+	39.0625f,
+	234.375f,
+	20.6363f,
+	39.0625f,
+	238.281f,
+	18.4584f,
+	39.0625f,
+	242.188f,
+	16.293f,
+	39.0625f,
+	246.094f,
+	13.7473f,
+	39.0625f,
+	250.0f,
+	13.2449f,
+	39.0625f,
+	3.90625f,
+	38.5427f,
+	35.1563f,
+	7.8125f,
+	39.2771f,
+	35.1563f,
+	11.7188f,
+	40.4801f,
+	35.1563f,
+	15.625f,
+	42.2714f,
+	35.1563f,
+	19.5313f,
+	44.0743f,
+	35.1562f,
+	23.4375f,
+	45.9071f,
+	35.1562f,
+	27.3438f,
+	47.4425f,
+	35.1563f,
+	31.25f,
+	47.765f,
+	35.1563f,
+	35.1563f,
+	46.8453f,
+	35.1562f,
+	39.0625f,
+	47.1161f,
+	35.1562f,
+	42.9688f,
+	46.591f,
+	35.1563f,
+	46.875f,
+	47.4064f,
+	35.1563f,
+	50.7813f,
+	47.2001f,
+	35.1562f,
+	54.6875f,
+	47.2372f,
+	35.1562f,
+	58.5938f,
+	46.9666f,
+	35.1563f,
+	62.5f,
+	45.3322f,
+	35.1563f,
+	66.4063f,
+	44.4351f,
+	35.1562f,
+	70.3125f,
+	43.869f,
+	35.1562f,
+	74.2188f,
+	43.7604f,
+	35.1563f,
+	78.125f,
+	43.6414f,
+	35.1563f,
+	82.0313f,
+	43.6044f,
+	35.1563f,
+	85.9375f,
+	41.9765f,
+	35.1563f,
+	89.8438f,
+	40.597f,
+	35.1563f,
+	93.75f,
+	38.8088f,
+	35.1563f,
+	97.6563f,
+	37.4254f,
+	35.1563f,
+	101.563f,
+	36.4869f,
+	35.1563f,
+	105.469f,
+	34.7975f,
+	35.1563f,
+	109.375f,
+	32.6051f,
+	35.1563f,
+	113.281f,
+	32.3929f,
+	35.1563f,
+	117.188f,
+	33.3906f,
+	35.1563f,
+	121.094f,
+	33.728f,
+	35.1563f,
+	125.0f,
+	33.8089f,
+	35.1563f,
+	128.906f,
+	35.2443f,
+	35.1563f,
+	132.813f,
+	35.9877f,
+	35.1563f,
+	136.719f,
+	36.3747f,
+	35.1563f,
+	140.625f,
+	37.6045f,
+	35.1563f,
+	144.531f,
+	38.3698f,
+	35.1563f,
+	148.438f,
+	39.393f,
+	35.1563f,
+	152.344f,
+	40.0115f,
+	35.1563f,
+	156.25f,
+	40.8722f,
+	35.1563f,
+	160.156f,
+	40.7302f,
+	35.1563f,
+	164.063f,
+	41.6767f,
+	35.1563f,
+	167.969f,
+	42.1719f,
+	35.1563f,
+	171.875f,
+	41.924f,
+	35.1563f,
+	175.781f,
+	40.9628f,
+	35.1563f,
+	179.688f,
+	39.3209f,
+	35.1563f,
+	183.594f,
+	37.9615f,
+	35.1563f,
+	187.5f,
+	37.2902f,
+	35.1563f,
+	191.406f,
+	36.1521f,
+	35.1563f,
+	195.313f,
+	35.5697f,
+	35.1563f,
+	199.219f,
+	35.0547f,
+	35.1563f,
+	203.125f,
+	33.8422f,
+	35.1563f,
+	207.031f,
+	33.1699f,
+	35.1563f,
+	210.938f,
+	32.4197f,
+	35.1563f,
+	214.844f,
+	31.0723f,
+	35.1563f,
+	218.75f,
+	29.1069f,
+	35.1563f,
+	222.656f,
+	26.4015f,
+	35.1563f,
+	226.563f,
+	23.6862f,
+	35.1563f,
+	230.469f,
+	22.3142f,
+	35.1563f,
+	234.375f,
+	20.9225f,
+	35.1563f,
+	238.281f,
+	18.6533f,
+	35.1563f,
+	242.188f,
+	16.5438f,
+	35.1563f,
+	246.094f,
+	14.5457f,
+	35.1563f,
+	250.0f,
+	13.5112f,
+	35.1563f,
+	3.90625f,
+	41.4381f,
+	31.25f,
+	7.8125f,
+	41.4661f,
+	31.25f,
+	11.7188f,
+	42.5211f,
+	31.25f,
+	15.625f,
+	44.1517f,
+	31.25f,
+	19.5313f,
+	45.8301f,
+	31.25f,
+	23.4375f,
+	47.3213f,
+	31.25f,
+	27.3438f,
+	49.1504f,
+	31.25f,
+	31.25f,
+	49.1313f,
+	31.25f,
+	35.1563f,
+	48.4621f,
+	31.25f,
+	39.0625f,
+	48.0866f,
+	31.25f,
+	42.9688f,
+	47.5259f,
+	31.25f,
+	46.875f,
+	48.2042f,
+	31.25f,
+	50.7813f,
+	48.2678f,
+	31.25f,
+	54.6875f,
+	48.6796f,
+	31.25f,
+	58.5938f,
+	49.1508f,
+	31.25f,
+	62.5f,
+	48.5261f,
+	31.25f,
+	66.4063f,
+	47.2699f,
+	31.25f,
+	70.3125f,
+	46.3239f,
+	31.25f,
+	74.2188f,
+	45.9053f,
+	31.25f,
+	78.125f,
+	45.2948f,
+	31.25f,
+	82.0313f,
+	45.1222f,
+	31.25f,
+	85.9375f,
+	44.1773f,
+	31.25f,
+	89.8438f,
+	42.0751f,
+	31.25f,
+	93.75f,
+	39.8181f,
+	31.25f,
+	97.6563f,
+	38.1904f,
+	31.25f,
+	101.563f,
+	36.9029f,
+	31.25f,
+	105.469f,
+	35.9897f,
+	31.25f,
+	109.375f,
+	34.1082f,
+	31.25f,
+	113.281f,
+	33.9882f,
+	31.25f,
+	117.188f,
+	33.4544f,
+	31.25f,
+	121.094f,
+	32.7435f,
+	31.25f,
+	125.0f,
+	32.2982f,
+	31.25f,
+	128.906f,
+	33.2893f,
+	31.25f,
+	132.813f,
+	34.4302f,
+	31.25f,
+	136.719f,
+	35.501f,
+	31.25f,
+	140.625f,
+	36.4162f,
+	31.25f,
+	144.531f,
+	38.0795f,
+	31.25f,
+	148.438f,
+	38.4184f,
+	31.25f,
+	152.344f,
+	38.1695f,
+	31.25f,
+	156.25f,
+	39.1334f,
+	31.25f,
+	160.156f,
+	39.8018f,
+	31.25f,
+	164.063f,
+	40.4009f,
+	31.25f,
+	167.969f,
+	40.6662f,
+	31.25f,
+	171.875f,
+	40.6389f,
+	31.25f,
+	175.781f,
+	40.0005f,
+	31.25f,
+	179.688f,
+	38.1437f,
+	31.25f,
+	183.594f,
+	36.1677f,
+	31.25f,
+	187.5f,
+	35.7553f,
+	31.25f,
+	191.406f,
+	35.2539f,
+	31.25f,
+	195.313f,
+	34.5258f,
+	31.25f,
+	199.219f,
+	33.9511f,
+	31.25f,
+	203.125f,
+	33.8209f,
+	31.25f,
+	207.031f,
+	32.5194f,
+	31.25f,
+	210.938f,
+	31.6797f,
+	31.25f,
+	214.844f,
+	30.494f,
+	31.25f,
+	218.75f,
+	28.9089f,
+	31.25f,
+	222.656f,
+	27.096f,
+	31.25f,
+	226.563f,
+	23.5752f,
+	31.25f,
+	230.469f,
+	22.5423f,
+	31.25f,
+	234.375f,
+	20.8438f,
+	31.25f,
+	238.281f,
+	18.7938f,
+	31.25f,
+	242.188f,
+	16.7022f,
+	31.25f,
+	246.094f,
+	14.6115f,
+	31.25f,
+	250.0f,
+	12.7758f,
+	31.25f,
+	3.90625f,
+	42.7334f,
+	27.3437f,
+	7.8125f,
+	43.3658f,
+	27.3438f,
+	11.7188f,
+	44.93f,
+	27.3437f,
+	15.625f,
+	46.7113f,
+	27.3438f,
+	19.5313f,
+	48.1031f,
+	27.3437f,
+	23.4375f,
+	48.7173f,
+	27.3438f,
+	27.3438f,
+	49.0875f,
+	27.3437f,
+	31.25f,
+	50.1272f,
+	27.3438f,
+	35.1563f,
+	49.1784f,
+	27.3437f,
+	39.0625f,
+	50.4569f,
+	27.3438f,
+	42.9688f,
+	49.7216f,
+	27.3437f,
+	46.875f,
+	49.0563f,
+	27.3438f,
+	50.7813f,
+	48.7494f,
+	27.3437f,
+	54.6875f,
+	49.0519f,
+	27.3438f,
+	58.5938f,
+	49.8264f,
+	27.3437f,
+	62.5f,
+	49.8194f,
+	27.3438f,
+	66.4063f,
+	48.9033f,
+	27.3437f,
+	70.3125f,
+	47.5002f,
+	27.3438f,
+	74.2188f,
+	46.7308f,
+	27.3437f,
+	78.125f,
+	45.8132f,
+	27.3438f,
+	82.0313f,
+	45.4303f,
+	27.3437f,
+	85.9375f,
+	44.4837f,
+	27.3438f,
+	89.8438f,
+	42.6706f,
+	27.3437f,
+	93.75f,
+	40.5108f,
+	27.3438f,
+	97.6563f,
+	38.4748f,
+	27.3437f,
+	101.563f,
+	38.2458f,
+	27.3438f,
+	105.469f,
+	37.8191f,
+	27.3437f,
+	109.375f,
+	37.5503f,
+	27.3438f,
+	113.281f,
+	36.4883f,
+	27.3437f,
+	117.188f,
+	35.7025f,
+	27.3438f,
+	121.094f,
+	34.3569f,
+	27.3437f,
+	125.0f,
+	34.052f,
+	27.3438f,
+	128.906f,
+	34.3166f,
+	27.3437f,
+	132.813f,
+	33.9873f,
+	27.3438f,
+	136.719f,
+	33.8326f,
+	27.3437f,
+	140.625f,
+	35.5138f,
+	27.3438f,
+	144.531f,
+	35.9847f,
+	27.3437f,
+	148.438f,
+	36.3159f,
+	27.3438f,
+	152.344f,
+	38.1026f,
+	27.3437f,
+	156.25f,
+	39.0191f,
+	27.3438f,
+	160.156f,
+	39.0705f,
+	27.3437f,
+	164.063f,
+	38.9644f,
+	27.3438f,
+	167.969f,
+	38.0972f,
+	27.3437f,
+	171.875f,
+	38.277f,
+	27.3438f,
+	175.781f,
+	37.5686f,
+	27.3437f,
+	179.688f,
+	35.9897f,
+	27.3438f,
+	183.594f,
+	34.1554f,
+	27.3437f,
+	187.5f,
+	33.9646f,
+	27.3438f,
+	191.406f,
+	33.9556f,
+	27.3437f,
+	195.313f,
+	33.7374f,
+	27.3438f,
+	199.219f,
+	33.3736f,
+	27.3437f,
+	203.125f,
+	32.1967f,
+	27.3438f,
+	207.031f,
+	32.2131f,
+	27.3437f,
+	210.938f,
+	30.4757f,
+	27.3438f,
+	214.844f,
+	29.0495f,
+	27.3437f,
+	218.75f,
+	27.539f,
+	27.3438f,
+	222.656f,
+	25.7435f,
+	27.3437f,
+	226.563f,
+	23.5358f,
+	27.3438f,
+	230.469f,
+	22.5305f,
+	27.3437f,
+	234.375f,
+	20.3466f,
+	27.3438f,
+	238.281f,
+	18.5956f,
+	27.3438f,
+	242.188f,
+	16.6554f,
+	27.3438f,
+	246.094f,
+	14.7633f,
+	27.3438f,
+	250.0f,
+	12.979f,
+	27.3438f,
+	3.90625f,
+	44.6783f,
+	23.4375f,
+	7.8125f,
+	46.1279f,
+	23.4375f,
+	11.7188f,
+	47.9921f,
+	23.4375f,
+	15.625f,
+	48.593f,
+	23.4375f,
+	19.5313f,
+	49.826f,
+	23.4375f,
+	23.4375f,
+	50.0111f,
+	23.4375f,
+	27.3438f,
+	49.773f,
+	23.4375f,
+	31.25f,
+	50.6443f,
+	23.4375f,
+	35.1563f,
+	50.242f,
+	23.4375f,
+	39.0625f,
+	51.5289f,
+	23.4375f,
+	42.9688f,
+	51.3905f,
+	23.4375f,
+	46.875f,
+	50.5543f,
+	23.4375f,
+	50.7813f,
+	49.96f,
+	23.4375f,
+	54.6875f,
+	51.029f,
+	23.4375f,
+	58.5938f,
+	50.4996f,
+	23.4375f,
+	62.5f,
+	50.0508f,
+	23.4375f,
+	66.4063f,
+	49.4463f,
+	23.4375f,
+	70.3125f,
+	48.7613f,
+	23.4375f,
+	74.2188f,
+	48.0188f,
+	23.4375f,
+	78.125f,
+	48.0992f,
+	23.4375f,
+	82.0313f,
+	47.1947f,
+	23.4375f,
+	85.9375f,
+	45.1889f,
+	23.4375f,
+	89.8438f,
+	43.9247f,
+	23.4375f,
+	93.75f,
+	41.7965f,
+	23.4375f,
+	97.6563f,
+	40.363f,
+	23.4375f,
+	101.563f,
+	40.3201f,
+	23.4375f,
+	105.469f,
+	39.2422f,
+	23.4375f,
+	109.375f,
+	38.6318f,
+	23.4375f,
+	113.281f,
+	37.9263f,
+	23.4375f,
+	117.188f,
+	37.113f,
+	23.4375f,
+	121.094f,
+	35.4884f,
+	23.4375f,
+	125.0f,
+	35.8385f,
+	23.4375f,
+	128.906f,
+	35.4941f,
+	23.4375f,
+	132.813f,
+	34.1911f,
+	23.4375f,
+	136.719f,
+	33.6791f,
+	23.4375f,
+	140.625f,
+	33.4506f,
+	23.4375f,
+	144.531f,
+	35.4822f,
+	23.4375f,
+	148.438f,
+	36.0187f,
+	23.4375f,
+	152.344f,
+	38.231f,
+	23.4375f,
+	156.25f,
+	39.1197f,
+	23.4375f,
+	160.156f,
+	38.9095f,
+	23.4375f,
+	164.063f,
+	38.1737f,
+	23.4375f,
+	167.969f,
+	36.7498f,
+	23.4375f,
+	171.875f,
+	36.6113f,
+	23.4375f,
+	175.781f,
+	35.5895f,
+	23.4375f,
+	179.688f,
+	34.7415f,
+	23.4375f,
+	183.594f,
+	32.6574f,
+	23.4375f,
+	187.5f,
+	32.5837f,
+	23.4375f,
+	191.406f,
+	32.5272f,
+	23.4375f,
+	195.313f,
+	32.3611f,
+	23.4375f,
+	199.219f,
+	31.4784f,
+	23.4375f,
+	203.125f,
+	30.8078f,
+	23.4375f,
+	207.031f,
+	29.9524f,
+	23.4375f,
+	210.938f,
+	29.9998f,
+	23.4375f,
+	214.844f,
+	28.4828f,
+	23.4375f,
+	218.75f,
+	26.6709f,
+	23.4375f,
+	222.656f,
+	24.9874f,
+	23.4375f,
+	226.563f,
+	23.0213f,
+	23.4375f,
+	230.469f,
+	21.3587f,
+	23.4375f,
+	234.375f,
+	19.0527f,
+	23.4375f,
+	238.281f,
+	18.1056f,
+	23.4375f,
+	242.188f,
+	16.7916f,
+	23.4375f,
+	246.094f,
+	14.9561f,
+	23.4375f,
+	250.0f,
+	13.0063f,
+	23.4375f,
+	3.90625f,
+	46.9055f,
+	19.5312f,
+	7.8125f,
+	48.3769f,
+	19.5312f,
+	11.7188f,
+	50.0613f,
+	19.5312f,
+	15.625f,
+	50.9962f,
+	19.5312f,
+	19.5313f,
+	51.161f,
+	19.5312f,
+	23.4375f,
+	51.7721f,
+	19.5312f,
+	27.3438f,
+	51.5823f,
+	19.5312f,
+	31.25f,
+	51.5274f,
+	19.5312f,
+	35.1563f,
+	51.5913f,
+	19.5312f,
+	39.0625f,
+	52.4399f,
+	19.5312f,
+	42.9688f,
+	52.5999f,
+	19.5312f,
+	46.875f,
+	51.9309f,
+	19.5312f,
+	50.7813f,
+	51.6062f,
+	19.5312f,
+	54.6875f,
+	50.86f,
+	19.5312f,
+	58.5938f,
+	51.1496f,
+	19.5312f,
+	62.5f,
+	50.1957f,
+	19.5312f,
+	66.4063f,
+	49.8047f,
+	19.5312f,
+	70.3125f,
+	49.1838f,
+	19.5312f,
+	74.2188f,
+	48.7276f,
+	19.5312f,
+	78.125f,
+	48.4967f,
+	19.5312f,
+	82.0313f,
+	47.4515f,
+	19.5312f,
+	85.9375f,
+	46.2594f,
+	19.5312f,
+	89.8438f,
+	44.6756f,
+	19.5312f,
+	93.75f,
+	43.0377f,
+	19.5312f,
+	97.6563f,
+	41.3508f,
+	19.5312f,
+	101.563f,
+	40.8261f,
+	19.5312f,
+	105.469f,
+	40.5524f,
+	19.5312f,
+	109.375f,
+	39.7289f,
+	19.5312f,
+	113.281f,
+	38.9437f,
+	19.5312f,
+	117.188f,
+	38.3781f,
+	19.5312f,
+	121.094f,
+	36.9618f,
+	19.5312f,
+	125.0f,
+	35.9735f,
+	19.5312f,
+	128.906f,
+	35.3887f,
+	19.5312f,
+	132.813f,
+	34.5133f,
+	19.5312f,
+	136.719f,
+	34.7253f,
+	19.5312f,
+	140.625f,
+	33.9228f,
+	19.5312f,
+	144.531f,
+	34.2826f,
+	19.5312f,
+	148.438f,
+	35.5643f,
+	19.5312f,
+	152.344f,
+	37.7492f,
+	19.5312f,
+	156.25f,
+	38.7871f,
+	19.5312f,
+	160.156f,
+	38.6036f,
+	19.5312f,
+	164.063f,
+	38.2702f,
+	19.5312f,
+	167.969f,
+	35.931f,
+	19.5312f,
+	171.875f,
+	34.8252f,
+	19.5312f,
+	175.781f,
+	33.99f,
+	19.5312f,
+	179.688f,
+	33.664f,
+	19.5312f,
+	183.594f,
+	31.6973f,
+	19.5312f,
+	187.5f,
+	31.3559f,
+	19.5312f,
+	191.406f,
+	31.3589f,
+	19.5312f,
+	195.313f,
+	30.7614f,
+	19.5312f,
+	199.219f,
+	29.2596f,
+	19.5312f,
+	203.125f,
+	28.7711f,
+	19.5312f,
+	207.031f,
+	27.9455f,
+	19.5312f,
+	210.938f,
+	28.3339f,
+	19.5312f,
+	214.844f,
+	28.3863f,
+	19.5312f,
+	218.75f,
+	27.4513f,
+	19.5312f,
+	222.656f,
+	25.0652f,
+	19.5312f,
+	226.563f,
+	23.2291f,
+	19.5312f,
+	230.469f,
+	20.8477f,
+	19.5313f,
+	234.375f,
+	19.424f,
+	19.5313f,
+	238.281f,
+	17.7051f,
+	19.5313f,
+	242.188f,
+	16.5977f,
+	19.5313f,
+	246.094f,
+	14.7851f,
+	19.5313f,
+	250.0f,
+	12.8344f,
+	19.5313f,
+	3.90625f,
+	49.2295f,
+	15.625f,
+	7.8125f,
+	50.0754f,
+	15.625f,
+	11.7188f,
+	51.5873f,
+	15.625f,
+	15.625f,
+	52.0525f,
+	15.625f,
+	19.5313f,
+	51.4269f,
+	15.625f,
+	23.4375f,
+	51.8405f,
+	15.625f,
+	27.3438f,
+	52.3327f,
+	15.625f,
+	31.25f,
+	53.011f,
+	15.625f,
+	35.1563f,
+	52.7359f,
+	15.625f,
+	39.0625f,
+	53.2852f,
+	15.625f,
+	42.9688f,
+	53.6617f,
+	15.625f,
+	46.875f,
+	52.4883f,
+	15.625f,
+	50.7813f,
+	51.9362f,
+	15.625f,
+	54.6875f,
+	50.8372f,
+	15.625f,
+	58.5938f,
+	50.1782f,
+	15.625f,
+	62.5f,
+	49.0401f,
+	15.625f,
+	66.4063f,
+	49.1011f,
+	15.625f,
+	70.3125f,
+	48.7903f,
+	15.625f,
+	74.2188f,
+	48.6124f,
+	15.625f,
+	78.125f,
+	48.1259f,
+	15.625f,
+	82.0313f,
+	47.7267f,
+	15.625f,
+	85.9375f,
+	46.9214f,
+	15.625f,
+	89.8438f,
+	45.0939f,
+	15.625f,
+	93.75f,
+	43.6563f,
+	15.625f,
+	97.6563f,
+	42.5709f,
+	15.625f,
+	101.563f,
+	41.9572f,
+	15.625f,
+	105.469f,
+	40.973f,
+	15.625f,
+	109.375f,
+	40.7682f,
+	15.625f,
+	113.281f,
+	39.3641f,
+	15.625f,
+	117.188f,
+	39.2768f,
+	15.625f,
+	121.094f,
+	37.5977f,
+	15.625f,
+	125.0f,
+	36.0608f,
+	15.625f,
+	128.906f,
+	36.045f,
+	15.625f,
+	132.813f,
+	35.1379f,
+	15.625f,
+	136.719f,
+	34.9875f,
+	15.625f,
+	140.625f,
+	34.0482f,
+	15.625f,
+	144.531f,
+	33.8104f,
+	15.625f,
+	148.438f,
+	34.9994f,
+	15.625f,
+	152.344f,
+	36.2664f,
+	15.625f,
+	156.25f,
+	37.7694f,
+	15.625f,
+	160.156f,
+	37.6584f,
+	15.625f,
+	164.063f,
+	36.9226f,
+	15.625f,
+	167.969f,
+	34.7519f,
+	15.625f,
+	171.875f,
+	33.2827f,
+	15.625f,
+	175.781f,
+	32.8949f,
+	15.625f,
+	179.688f,
+	32.1339f,
+	15.625f,
+	183.594f,
+	30.407f,
+	15.625f,
+	187.5f,
+	28.996f,
+	15.625f,
+	191.406f,
+	29.3357f,
+	15.625f,
+	195.313f,
+	29.1098f,
+	15.625f,
+	199.219f,
+	27.8354f,
+	15.625f,
+	203.125f,
+	26.4739f,
+	15.625f,
+	207.031f,
+	26.1829f,
+	15.625f,
+	210.938f,
+	27.387f,
+	15.625f,
+	214.844f,
+	27.4944f,
+	15.625f,
+	218.75f,
+	26.4893f,
+	15.625f,
+	222.656f,
+	24.7764f,
+	15.625f,
+	226.563f,
+	22.9689f,
+	15.625f,
+	230.469f,
+	20.4237f,
+	15.625f,
+	234.375f,
+	18.8049f,
+	15.625f,
+	238.281f,
+	17.4547f,
+	15.625f,
+	242.188f,
+	16.2758f,
+	15.625f,
+	246.094f,
+	14.2192f,
+	15.625f,
+	250.0f,
+	11.8103f,
+	15.625f,
+	3.90625f,
+	51.1233f,
+	11.7187f,
+	7.8125f,
+	51.8127f,
+	11.7187f,
+	11.7188f,
+	52.0971f,
+	11.7187f,
+	15.625f,
+	51.8317f,
+	11.7187f,
+	19.5313f,
+	52.1213f,
+	11.7187f,
+	23.4375f,
+	51.7889f,
+	11.7187f,
+	27.3438f,
+	52.2065f,
+	11.7187f,
+	31.25f,
+	52.438f,
+	11.7187f,
+	35.1563f,
+	52.6021f,
+	11.7187f,
+	39.0625f,
+	53.2864f,
+	11.7187f,
+	42.9688f,
+	52.8882f,
+	11.7187f,
+	46.875f,
+	52.6009f,
+	11.7187f,
+	50.7813f,
+	52.8442f,
+	11.7187f,
+	54.6875f,
+	52.6512f,
+	11.7187f,
+	58.5938f,
+	51.6436f,
+	11.7187f,
+	62.5f,
+	50.4271f,
+	11.7187f,
+	66.4063f,
+	49.3264f,
+	11.7187f,
+	70.3125f,
+	48.6522f,
+	11.7187f,
+	74.2188f,
+	49.5854f,
+	11.7187f,
+	78.125f,
+	50.3492f,
+	11.7187f,
+	82.0313f,
+	49.035f,
+	11.7187f,
+	85.9375f,
+	47.6474f,
+	11.7187f,
+	89.8438f,
+	46.0472f,
+	11.7187f,
+	93.75f,
+	44.7337f,
+	11.7187f,
+	97.6563f,
+	44.3349f,
+	11.7187f,
+	101.563f,
+	43.475f,
+	11.7187f,
+	105.469f,
+	42.9461f,
+	11.7187f,
+	109.375f,
+	41.7731f,
+	11.7187f,
+	113.281f,
+	40.717f,
+	11.7187f,
+	117.188f,
+	39.399f,
+	11.7187f,
+	121.094f,
+	38.1327f,
+	11.7187f,
+	125.0f,
+	36.3286f,
+	11.7187f,
+	128.906f,
+	36.2512f,
+	11.7187f,
+	132.813f,
+	35.1997f,
+	11.7187f,
+	136.719f,
+	33.9406f,
+	11.7187f,
+	140.625f,
+	33.3109f,
+	11.7187f,
+	144.531f,
+	33.8153f,
+	11.7187f,
+	148.438f,
+	33.6823f,
+	11.7187f,
+	152.344f,
+	34.7077f,
+	11.7187f,
+	156.25f,
+	35.4472f,
+	11.7187f,
+	160.156f,
+	35.6332f,
+	11.7187f,
+	164.063f,
+	34.3651f,
+	11.7187f,
+	167.969f,
+	32.9876f,
+	11.7187f,
+	171.875f,
+	32.2858f,
+	11.7187f,
+	175.781f,
+	32.1374f,
+	11.7187f,
+	179.688f,
+	30.9575f,
+	11.7187f,
+	183.594f,
+	29.1111f,
+	11.7187f,
+	187.5f,
+	28.149f,
+	11.7187f,
+	191.406f,
+	27.4443f,
+	11.7187f,
+	195.313f,
+	27.3781f,
+	11.7187f,
+	199.219f,
+	26.4413f,
+	11.7187f,
+	203.125f,
+	24.9734f,
+	11.7187f,
+	207.031f,
+	25.0959f,
+	11.7187f,
+	210.938f,
+	26.2472f,
+	11.7187f,
+	214.844f,
+	26.1569f,
+	11.7187f,
+	218.75f,
+	24.8556f,
+	11.7187f,
+	222.656f,
+	22.8797f,
+	11.7187f,
+	226.563f,
+	21.8102f,
+	11.7187f,
+	230.469f,
+	19.294f,
+	11.7187f,
+	234.375f,
+	17.5291f,
+	11.7187f,
+	238.281f,
+	16.242f,
+	11.7187f,
+	242.188f,
+	15.2738f,
+	11.7187f,
+	246.094f,
+	13.8715f,
+	11.7187f,
+	250.0f,
+	12.3043f,
+	11.7187f,
+	3.90625f,
+	52.2527f,
+	7.8125f,
+	7.8125f,
+	52.7759f,
+	7.8125f,
+	11.7188f,
+	52.1635f,
+	7.8125f,
+	15.625f,
+	52.2016f,
+	7.8125f,
+	19.5313f,
+	51.9832f,
+	7.8125f,
+	23.4375f,
+	51.4669f,
+	7.8125f,
+	27.3438f,
+	51.0033f,
+	7.8125f,
+	31.25f,
+	50.7124f,
+	7.8125f,
+	35.1563f,
+	51.6427f,
+	7.8125f,
+	39.0625f,
+	52.5008f,
+	7.8125f,
+	42.9688f,
+	53.2834f,
+	7.8125f,
+	46.875f,
+	52.5339f,
+	7.8125f,
+	50.7813f,
+	52.627f,
+	7.8125f,
+	54.6875f,
+	52.9017f,
+	7.8125f,
+	58.5938f,
+	52.8616f,
+	7.8125f,
+	62.5f,
+	51.7566f,
+	7.8125f,
+	66.4063f,
+	51.3268f,
+	7.8125f,
+	70.3125f,
+	50.6108f,
+	7.8125f,
+	74.2188f,
+	50.9277f,
+	7.8125f,
+	78.125f,
+	51.701f,
+	7.8125f,
+	82.0313f,
+	50.5549f,
+	7.8125f,
+	85.9375f,
+	48.4345f,
+	7.8125f,
+	89.8438f,
+	47.3592f,
+	7.8125f,
+	93.75f,
+	45.7216f,
+	7.8125f,
+	97.6563f,
+	45.75f,
+	7.8125f,
+	101.563f,
+	44.4249f,
+	7.8125f,
+	105.469f,
+	44.7192f,
+	7.8125f,
+	109.375f,
+	44.4938f,
+	7.8125f,
+	113.281f,
+	43.252f,
+	7.8125f,
+	117.188f,
+	41.3735f,
+	7.8125f,
+	121.094f,
+	39.8664f,
+	7.8125f,
+	125.0f,
+	37.025f,
+	7.8125f,
+	128.906f,
+	36.5094f,
+	7.8125f,
+	132.813f,
+	35.3554f,
+	7.8125f,
+	136.719f,
+	33.9389f,
+	7.8125f,
+	140.625f,
+	32.7715f,
+	7.8125f,
+	144.531f,
+	32.8295f,
+	7.8125f,
+	148.438f,
+	32.4513f,
+	7.8125f,
+	152.344f,
+	33.4598f,
+	7.8125f,
+	156.25f,
+	34.3434f,
+	7.8125f,
+	160.156f,
+	34.8633f,
+	7.8125f,
+	164.063f,
+	33.7043f,
+	7.8125f,
+	167.969f,
+	32.5629f,
+	7.8125f,
+	171.875f,
+	31.5117f,
+	7.8125f,
+	175.781f,
+	30.9816f,
+	7.8125f,
+	179.688f,
+	30.2039f,
+	7.8125f,
+	183.594f,
+	28.5054f,
+	7.8125f,
+	187.5f,
+	26.8519f,
+	7.8125f,
+	191.406f,
+	25.6078f,
+	7.8125f,
+	195.313f,
+	26.0906f,
+	7.8125f,
+	199.219f,
+	25.313f,
+	7.8125f,
+	203.125f,
+	24.0014f,
+	7.8125f,
+	207.031f,
+	24.066f,
+	7.8125f,
+	210.938f,
+	24.4935f,
+	7.8125f,
+	214.844f,
+	24.3803f,
+	7.8125f,
+	218.75f,
+	23.0075f,
+	7.8125f,
+	222.656f,
+	21.1023f,
+	7.8125f,
+	226.563f,
+	19.0418f,
+	7.8125f,
+	230.469f,
+	17.9588f,
+	7.8125f,
+	234.375f,
+	16.5211f,
+	7.8125f,
+	238.281f,
+	15.4949f,
+	7.8125f,
+	242.188f,
+	14.0938f,
+	7.8125f,
+	246.094f,
+	13.3141f,
+	7.8125f,
+	250.0f,
+	12.9595f,
+	7.8125f,
+	3.90625f,
+	52.6186f,
+	3.90625f,
+	7.8125f,
+	51.8648f,
+	3.90625f,
+	11.7188f,
+	51.1949f,
+	3.90625f,
+	15.625f,
+	50.2102f,
+	3.90625f,
+	19.5313f,
+	50.6058f,
+	3.90625f,
+	23.4375f,
+	50.7008f,
+	3.90625f,
+	27.3438f,
+	51.2163f,
+	3.90625f,
+	31.25f,
+	51.4263f,
+	3.90625f,
+	35.1563f,
+	52.1968f,
+	3.90625f,
+	39.0625f,
+	53.9783f,
+	3.90625f,
+	42.9688f,
+	53.8927f,
+	3.90625f,
+	46.875f,
+	53.3266f,
+	3.90625f,
+	50.7813f,
+	53.5901f,
+	3.90625f,
+	54.6875f,
+	55.5679f,
+	3.90625f,
+	58.5938f,
+	55.1819f,
+	3.90625f,
+	62.5f,
+	53.6891f,
+	3.90625f,
+	66.4063f,
+	53.0541f,
+	3.90625f,
+	70.3125f,
+	51.6665f,
+	3.90625f,
+	74.2188f,
+	51.4469f,
+	3.90625f,
+	78.125f,
+	51.9591f,
+	3.90625f,
+	82.0313f,
+	51.0418f,
+	3.90625f,
+	85.9375f,
+	49.7513f,
+	3.90625f,
+	89.8438f,
+	48.7329f,
+	3.90625f,
+	93.75f,
+	46.8713f,
+	3.90625f,
+	97.6563f,
+	46.3905f,
+	3.90625f,
+	101.563f,
+	45.4241f,
+	3.90625f,
+	105.469f,
+	45.6811f,
+	3.90625f,
+	109.375f,
+	45.3238f,
+	3.90625f,
+	113.281f,
+	43.6112f,
+	3.90625f,
+	117.188f,
+	42.1291f,
+	3.90625f,
+	121.094f,
+	40.4747f,
+	3.90625f,
+	125.0f,
+	39.3351f,
+	3.90625f,
+	128.906f,
+	38.0742f,
+	3.90625f,
+	132.813f,
+	36.7758f,
+	3.90625f,
+	136.719f,
+	34.9213f,
+	3.90625f,
+	140.625f,
+	32.3643f,
+	3.90625f,
+	144.531f,
+	31.7157f,
+	3.90625f,
+	148.438f,
+	30.6005f,
+	3.90625f,
+	152.344f,
+	31.6034f,
+	3.90625f,
+	156.25f,
+	32.6503f,
+	3.90625f,
+	160.156f,
+	33.3131f,
+	3.90625f,
+	164.063f,
+	32.5745f,
+	3.90625f,
+	167.969f,
+	31.5017f,
+	3.90625f,
+	171.875f,
+	30.6842f,
+	3.90625f,
+	175.781f,
+	29.8734f,
+	3.90625f,
+	179.688f,
+	28.6537f,
+	3.90625f,
+	183.594f,
+	27.2073f,
+	3.90625f,
+	187.5f,
+	25.4367f,
+	3.90625f,
+	191.406f,
+	24.1609f,
+	3.90625f,
+	195.313f,
+	23.9724f,
+	3.90625f,
+	199.219f,
+	23.7702f,
+	3.90625f,
+	203.125f,
+	22.4031f,
+	3.90625f,
+	207.031f,
+	22.1587f,
+	3.90625f,
+	210.938f,
+	21.6154f,
+	3.90625f,
+	214.844f,
+	21.8202f,
+	3.90625f,
+	218.75f,
+	21.017f,
+	3.90625f,
+	222.656f,
+	19.3736f,
+	3.90625f,
+	226.563f,
+	18.2127f,
+	3.90625f,
+	230.469f,
+	17.2263f,
+	3.90625f,
+	234.375f,
+	16.2938f,
+	3.90625f,
+	238.281f,
+	14.4518f,
+	3.90625f,
+	242.188f,
+	13.6398f,
+	3.90625f,
+	246.094f,
+	13.2404f,
+	3.90625f,
+	250.0f,
+	12.7102f,
+	3.90625f,
+};
+
+btScalar Landscape04Nml[] = {
+	-0.350125f,
+	0.914758f,
+	-0.201568f,
+	-0.310159f,
+	0.930741f,
+	-0.193707f,
+	-0.297809f,
+	0.93918f,
+	-0.171025f,
+	-0.203808f,
+	0.975413f,
+	-0.083855f,
+	-0.227869f,
+	0.971729f,
+	-0.0617958f,
+	-0.175976f,
+	0.984209f,
+	0.0190985f,
+	-0.113434f,
+	0.992992f,
+	-0.0331636f,
+	-0.10748f,
+	0.994138f,
+	-0.0117748f,
+	0.264437f,
+	0.964372f,
+	0.00769155f,
+	0.281666f,
+	0.958691f,
+	0.0397075f,
+	0.430486f,
+	0.901936f,
+	-0.0345351f,
+	0.401178f,
+	0.915992f,
+	-0.00383073f,
+	0.323069f,
+	0.944057f,
+	-0.0662002f,
+	0.321744f,
+	0.945983f,
+	-0.039967f,
+	0.269775f,
+	0.962292f,
+	-0.0348534f,
+	0.20193f,
+	0.970428f,
+	-0.132266f,
+	0.268889f,
+	0.954681f,
+	-0.127604f,
+	0.194635f,
+	0.954618f,
+	-0.225435f,
+	0.221506f,
+	0.956393f,
+	-0.190387f,
+	0.193103f,
+	0.932235f,
+	-0.306022f,
+	0.127904f,
+	0.985279f,
+	-0.113427f,
+	0.190082f,
+	0.941797f,
+	-0.277285f,
+	-0.00897869f,
+	0.999816f,
+	0.0169309f,
+	0.104995f,
+	0.98929f,
+	-0.101393f,
+	-0.0904331f,
+	0.992726f,
+	0.0794834f,
+	0.0230108f,
+	0.991613f,
+	0.127174f,
+	0.0155488f,
+	0.993572f,
+	0.11213f,
+	0.0288983f,
+	0.981821f,
+	0.187597f,
+	0.0247864f,
+	0.996149f,
+	0.0840949f,
+	-0.0831472f,
+	0.996537f,
+	0.000391199f,
+	-0.0501709f,
+	0.99867f,
+	0.0118531f,
+	-0.153f,
+	0.976743f,
+	-0.15021f,
+	-0.106591f,
+	0.988499f,
+	-0.107277f,
+	-0.178503f,
+	0.946807f,
+	-0.267757f,
+	-0.0254657f,
+	0.984638f,
+	-0.172739f,
+	-0.00387521f,
+	0.963955f,
+	-0.266035f,
+	-0.0158619f,
+	0.994497f,
+	-0.103554f,
+	0.0516719f,
+	0.979433f,
+	-0.195043f,
+	-0.113536f,
+	0.993496f,
+	-0.00869834f,
+	-0.0532458f,
+	0.993386f,
+	-0.101726f,
+	-0.240923f,
+	0.970479f,
+	0.0112676f,
+	-0.272825f,
+	0.959264f,
+	-0.0733371f,
+	-0.364171f,
+	0.921854f,
+	-0.132533f,
+	-0.38043f,
+	0.901643f,
+	-0.205699f,
+	-0.208475f,
+	0.967633f,
+	-0.142215f,
+	-0.200209f,
+	0.964847f,
+	-0.170257f,
+	-0.436593f,
+	0.880066f,
+	-0.186734f,
+	-0.420663f,
+	0.90307f,
+	-0.0866427f,
+	-0.564169f,
+	0.813693f,
+	-0.140058f,
+	-0.556718f,
+	0.83037f,
+	-0.0234562f,
+	-0.419122f,
+	0.896066f,
+	-0.146295f,
+	-0.466908f,
+	0.873897f,
+	-0.135282f,
+	-0.39151f,
+	0.89596f,
+	-0.209704f,
+	-0.388383f,
+	0.911455f,
+	-0.135677f,
+	-0.356022f,
+	0.918213f,
+	-0.173589f,
+	-0.334437f,
+	0.939184f,
+	-0.0780065f,
+	-0.257665f,
+	0.953587f,
+	-0.155824f,
+	-0.309301f,
+	0.93272f,
+	-0.185382f,
+	-0.315034f,
+	0.931862f,
+	-0.179961f,
+	-0.295926f,
+	0.931298f,
+	-0.212393f,
+	-0.436779f,
+	0.896592f,
+	-0.0731173f,
+	-0.317368f,
+	0.948237f,
+	0.0111289f,
+	-0.503169f,
+	0.863334f,
+	0.0383931f,
+	-0.468116f,
+	0.877337f,
+	0.105583f,
+	-0.41232f,
+	0.911034f,
+	0.00307775f,
+	-0.465256f,
+	0.885053f,
+	0.0147642f,
+	-0.139311f,
+	0.987488f,
+	-0.0738976f,
+	-0.20689f,
+	0.974976f,
+	-0.0813499f,
+	-0.0453849f,
+	0.98457f,
+	-0.169006f,
+	-0.109269f,
+	0.973649f,
+	-0.20017f,
+	0.0405907f,
+	0.980595f,
+	-0.191794f,
+	0.0742781f,
+	0.990348f,
+	-0.117022f,
+	-0.00934593f,
+	0.982385f,
+	-0.186633f,
+	0.00811898f,
+	0.984163f,
+	-0.177079f,
+	-0.0726933f,
+	0.996391f,
+	-0.043832f,
+	0.0160265f,
+	0.999861f,
+	-0.00453309f,
+	-0.163053f,
+	0.986585f,
+	0.00801872f,
+	-0.185529f,
+	0.978031f,
+	-0.0950467f,
+	-0.137829f,
+	0.987875f,
+	0.0714611f,
+	-0.0578854f,
+	0.998186f,
+	0.0165557f,
+	0.148249f,
+	0.976119f,
+	0.158788f,
+	0.193139f,
+	0.975453f,
+	0.10578f,
+	0.369772f,
+	0.912299f,
+	0.176006f,
+	0.348645f,
+	0.936628f,
+	0.0342667f,
+	0.282769f,
+	0.952501f,
+	0.113063f,
+	0.239504f,
+	0.96906f,
+	-0.059674f,
+	0.137712f,
+	0.990197f,
+	0.0233582f,
+	0.149987f,
+	0.988306f,
+	0.0274647f,
+	0.169834f,
+	0.984573f,
+	-0.0420991f,
+	0.0927723f,
+	0.990592f,
+	-0.100603f,
+	0.171676f,
+	0.97845f,
+	-0.114732f,
+	0.0567364f,
+	0.963622f,
+	-0.261179f,
+	0.117062f,
+	0.969073f,
+	-0.217242f,
+	0.0434058f,
+	0.931949f,
+	-0.359981f,
+	0.148347f,
+	0.946865f,
+	-0.285375f,
+	0.103327f,
+	0.903437f,
+	-0.416082f,
+	0.28421f,
+	0.914779f,
+	-0.287061f,
+	0.391793f,
+	0.893555f,
+	-0.21922f,
+	0.419866f,
+	0.888994f,
+	-0.182764f,
+	0.461528f,
+	0.873246f,
+	-0.156313f,
+	0.483081f,
+	0.869853f,
+	-0.099941f,
+	0.503438f,
+	0.857022f,
+	-0.109831f,
+	0.46584f,
+	0.882166f,
+	-0.0691099f,
+	0.489623f,
+	0.868073f,
+	-0.0819641f,
+	0.410796f,
+	0.910896f,
+	-0.0389227f,
+	0.393119f,
+	0.918063f,
+	-0.0511611f,
+	0.359627f,
+	0.921042f,
+	-0.1495f,
+	0.306646f,
+	0.942147f,
+	-0.135377f,
+	0.381773f,
+	0.903228f,
+	-0.196033f,
+	0.360002f,
+	0.920948f,
+	-0.149176f,
+	0.203221f,
+	0.945872f,
+	-0.253037f,
+	0.218471f,
+	0.943498f,
+	-0.249162f,
+	0.0567054f,
+	0.995659f,
+	-0.0738017f,
+	0.229305f,
+	0.968679f,
+	0.0952866f,
+	-0.0263963f,
+	0.99794f,
+	0.0584726f,
+	-0.0422212f,
+	0.996107f,
+	0.0773806f,
+	0.0415928f,
+	0.997459f,
+	0.0578396f,
+	0.0625406f,
+	0.995706f,
+	0.0682456f,
+	0.174866f,
+	0.970931f,
+	0.163448f,
+	0.248971f,
+	0.959664f,
+	0.13061f,
+	0.296526f,
+	0.91909f,
+	0.259511f,
+	0.244457f,
+	0.962524f,
+	0.117427f,
+	0.144028f,
+	0.988219f,
+	0.0517682f,
+	0.0516566f,
+	0.998622f,
+	-0.00921711f,
+	-0.0100473f,
+	0.999479f,
+	-0.0306849f,
+	0.144821f,
+	0.968281f,
+	0.203614f,
+	0.0927686f,
+	0.985877f,
+	0.139429f,
+	0.159268f,
+	0.950036f,
+	0.268448f,
+	-0.238265f,
+	0.969366f,
+	-0.0596594f,
+	-0.317162f,
+	0.937667f,
+	-0.14209f,
+	-0.252226f,
+	0.956124f,
+	-0.149026f,
+	-0.139275f,
+	0.959516f,
+	-0.244809f,
+	0.225678f,
+	0.948782f,
+	-0.221092f,
+	0.454598f,
+	0.876109f,
+	-0.160545f,
+	0.280777f,
+	0.950726f,
+	-0.131467f,
+	0.235562f,
+	0.968875f,
+	-0.076101f,
+	0.32523f,
+	0.943278f,
+	-0.0667146f,
+	0.204883f,
+	0.977104f,
+	-0.0573623f,
+	-0.016814f,
+	0.999658f,
+	-0.0200258f,
+	-0.0821474f,
+	0.994185f,
+	0.0696248f,
+	-0.0248008f,
+	0.998098f,
+	0.0564331f,
+	0.000698274f,
+	0.999817f,
+	0.0191283f,
+	0.0007523f,
+	0.989994f,
+	0.141106f,
+	-0.0137951f,
+	0.98192f,
+	0.188792f,
+	-0.00956379f,
+	0.990301f,
+	0.138609f,
+	-0.0156365f,
+	0.996604f,
+	0.0808513f,
+	-0.104293f,
+	0.986463f,
+	0.126542f,
+	-0.156424f,
+	0.969975f,
+	0.186228f,
+	-0.167617f,
+	0.975111f,
+	0.145129f,
+	-0.261339f,
+	0.965118f,
+	0.0157997f,
+	-0.160877f,
+	0.9832f,
+	-0.0862302f,
+	-0.296054f,
+	0.934306f,
+	-0.198555f,
+	-0.550185f,
+	0.752769f,
+	-0.361436f,
+	-0.408582f,
+	0.840233f,
+	-0.356467f,
+	-0.339245f,
+	0.876729f,
+	-0.340968f,
+	-0.402741f,
+	0.85772f,
+	-0.319556f,
+	-0.316164f,
+	0.924069f,
+	-0.214795f,
+	-0.348907f,
+	0.927941f,
+	-0.131109f,
+	-0.48502f,
+	0.870548f,
+	-0.0830789f,
+	-0.53006f,
+	0.843646f,
+	-0.085433f,
+	-0.352226f,
+	0.931519f,
+	-0.0906107f,
+	-0.0975811f,
+	0.982258f,
+	-0.160146f,
+	0.0477418f,
+	0.981235f,
+	-0.186812f,
+	0.0219054f,
+	0.966987f,
+	-0.253882f,
+	-0.115057f,
+	0.988784f,
+	-0.0952266f,
+	-0.238673f,
+	0.960258f,
+	0.144707f,
+	-0.213447f,
+	0.931011f,
+	0.296071f,
+	-0.201955f,
+	0.923284f,
+	0.326742f,
+	0.101325f,
+	0.921693f,
+	0.374453f,
+	0.294403f,
+	0.882174f,
+	0.367555f,
+	0.373397f,
+	0.835094f,
+	0.403971f,
+	0.278351f,
+	0.921647f,
+	0.270347f,
+	0.215461f,
+	0.962466f,
+	0.16503f,
+	0.225302f,
+	0.965479f,
+	0.13073f,
+	0.175997f,
+	0.983214f,
+	0.0481225f,
+	0.220124f,
+	0.97536f,
+	0.0147531f,
+	0.32343f,
+	0.94566f,
+	-0.0334783f,
+	0.369971f,
+	0.927728f,
+	-0.0494253f,
+	0.427777f,
+	0.903113f,
+	-0.037328f,
+	0.446874f,
+	0.894597f,
+	9.72625e-005f,
+	0.445338f,
+	0.895316f,
+	-0.00910111f,
+	0.463955f,
+	0.88101f,
+	-0.0925573f,
+	0.398143f,
+	0.905258f,
+	-0.148289f,
+	0.190091f,
+	0.969836f,
+	-0.152589f,
+	-0.0830374f,
+	0.980972f,
+	-0.175495f,
+	-0.1343f,
+	0.985908f,
+	-0.0997463f,
+	-0.00843053f,
+	0.999434f,
+	0.0325608f,
+	0.021819f,
+	0.995847f,
+	0.0883913f,
+	0.206682f,
+	0.96009f,
+	0.188439f,
+	0.388829f,
+	0.882727f,
+	0.263827f,
+	0.0707915f,
+	0.996578f,
+	0.0426701f,
+	-0.161491f,
+	0.983232f,
+	-0.0847068f,
+	-0.0785342f,
+	0.996721f,
+	-0.0194704f,
+	-0.224473f,
+	0.966422f,
+	-0.125062f,
+	-0.159666f,
+	0.968511f,
+	-0.191032f,
+	0.0318558f,
+	0.951557f,
+	-0.305817f,
+	0.187349f,
+	0.896729f,
+	-0.400972f,
+	0.324927f,
+	0.900628f,
+	-0.288602f,
+	0.217775f,
+	0.961772f,
+	-0.16604f,
+	0.20019f,
+	0.973241f,
+	-0.112807f,
+	0.277242f,
+	0.959937f,
+	-0.0407145f,
+	0.14204f,
+	0.987332f,
+	0.0707153f,
+	-0.0153938f,
+	0.984428f,
+	0.175114f,
+	-0.0735255f,
+	0.984081f,
+	0.161796f,
+	-0.0237909f,
+	0.990594f,
+	0.134749f,
+	-0.0614906f,
+	0.985818f,
+	0.156146f,
+	-0.143236f,
+	0.970943f,
+	0.191711f,
+	-0.0137498f,
+	0.973243f,
+	0.229369f,
+	0.0567477f,
+	0.984597f,
+	0.165372f,
+	-0.0347212f,
+	0.993259f,
+	0.110594f,
+	-0.143386f,
+	0.976741f,
+	0.159429f,
+	-0.139502f,
+	0.982211f,
+	0.125705f,
+	-0.0993842f,
+	0.989216f,
+	0.107588f,
+	-0.136731f,
+	0.987843f,
+	0.0739654f,
+	-0.0893069f,
+	0.995969f,
+	0.00840628f,
+	-0.123862f,
+	0.992294f,
+	-0.00315825f,
+	-0.391175f,
+	0.886683f,
+	-0.246529f,
+	-0.44403f,
+	0.793263f,
+	-0.41662f,
+	-0.399761f,
+	0.83626f,
+	-0.375315f,
+	-0.422675f,
+	0.841058f,
+	-0.33759f,
+	-0.445112f,
+	0.835127f,
+	-0.323168f,
+	-0.410733f,
+	0.898417f,
+	-0.155389f,
+	-0.485628f,
+	0.867891f,
+	-0.104549f,
+	-0.491383f,
+	0.859111f,
+	-0.143077f,
+	-0.358033f,
+	0.910383f,
+	-0.207399f,
+	-0.0910122f,
+	0.986127f,
+	-0.138818f,
+	0.0820594f,
+	0.995842f,
+	-0.039567f,
+	-0.0287013f,
+	0.999312f,
+	-0.0234726f,
+	-0.346268f,
+	0.933835f,
+	0.0897299f,
+	-0.471073f,
+	0.825151f,
+	0.311795f,
+	-0.27505f,
+	0.819541f,
+	0.502693f,
+	-0.154238f,
+	0.84574f,
+	0.510818f,
+	0.0836929f,
+	0.869512f,
+	0.48677f,
+	0.266688f,
+	0.84547f,
+	0.462663f,
+	0.365749f,
+	0.809921f,
+	0.458537f,
+	0.371864f,
+	0.832105f,
+	0.411483f,
+	0.260242f,
+	0.895369f,
+	0.361371f,
+	0.283389f,
+	0.903576f,
+	0.321311f,
+	0.269874f,
+	0.934168f,
+	0.233448f,
+	0.265321f,
+	0.957928f,
+	0.10945f,
+	0.333071f,
+	0.942841f,
+	0.0106961f,
+	0.387903f,
+	0.9217f,
+	0.000193271f,
+	0.435792f,
+	0.899834f,
+	0.0195967f,
+	0.454676f,
+	0.88982f,
+	0.0386129f,
+	0.482276f,
+	0.876019f,
+	-0.000723308f,
+	0.505259f,
+	0.860654f,
+	-0.0631586f,
+	0.398328f,
+	0.910448f,
+	-0.111444f,
+	0.21929f,
+	0.970647f,
+	-0.0987756f,
+	0.0111053f,
+	0.988208f,
+	-0.152714f,
+	-0.210805f,
+	0.943357f,
+	-0.256201f,
+	-0.146846f,
+	0.978658f,
+	-0.143755f,
+	0.0139602f,
+	0.999731f,
+	-0.0184963f,
+	0.133096f,
+	0.990721f,
+	-0.0275154f,
+	0.2933f,
+	0.953875f,
+	0.0640122f,
+	0.228393f,
+	0.945969f,
+	0.230173f,
+	0.0546169f,
+	0.969859f,
+	0.237467f,
+	-0.0762534f,
+	0.988779f,
+	-0.128459f,
+	-0.106647f,
+	0.982213f,
+	-0.154543f,
+	-0.122396f,
+	0.949634f,
+	-0.28847f,
+	0.0920652f,
+	0.954226f,
+	-0.284566f,
+	0.185259f,
+	0.946785f,
+	-0.263206f,
+	0.232314f,
+	0.960849f,
+	-0.150996f,
+	0.169992f,
+	0.979263f,
+	-0.110207f,
+	0.125326f,
+	0.980516f,
+	-0.151267f,
+	0.149673f,
+	0.98818f,
+	-0.0331477f,
+	0.0238199f,
+	0.989878f,
+	0.139909f,
+	-0.107594f,
+	0.981438f,
+	0.158754f,
+	-0.0846643f,
+	0.982313f,
+	0.167013f,
+	-0.0375415f,
+	0.970751f,
+	0.237134f,
+	-0.0510768f,
+	0.964816f,
+	0.257917f,
+	-0.0443365f,
+	0.980593f,
+	0.190977f,
+	0.00242513f,
+	0.997744f,
+	0.0670872f,
+	0.124335f,
+	0.983389f,
+	0.132238f,
+	-0.00301992f,
+	0.993206f,
+	0.116332f,
+	-0.125192f,
+	0.990103f,
+	0.0634287f,
+	-0.100487f,
+	0.994519f,
+	-0.0288746f,
+	-0.101663f,
+	0.992712f,
+	-0.0647098f,
+	-0.139647f,
+	0.987963f,
+	-0.0665471f,
+	-0.130136f,
+	0.990189f,
+	-0.0508981f,
+	-0.0756901f,
+	0.997123f,
+	-0.00415316f,
+	-0.171558f,
+	0.977059f,
+	-0.126185f,
+	-0.351855f,
+	0.892529f,
+	-0.282117f,
+	-0.447333f,
+	0.817645f,
+	-0.362422f,
+	-0.423851f,
+	0.857249f,
+	-0.29236f,
+	-0.448058f,
+	0.866215f,
+	-0.221171f,
+	-0.531086f,
+	0.820738f,
+	-0.210565f,
+	-0.511898f,
+	0.851158f,
+	-0.116153f,
+	-0.425868f,
+	0.900461f,
+	-0.0883553f,
+	-0.399025f,
+	0.900598f,
+	-0.172345f,
+	-0.24223f,
+	0.968919f,
+	-0.0502012f,
+	-0.0663613f,
+	0.996507f,
+	0.0506899f,
+	-0.138021f,
+	0.972657f,
+	0.186782f,
+	-0.4139f,
+	0.851097f,
+	0.322987f,
+	-0.550512f,
+	0.782849f,
+	0.289973f,
+	-0.380287f,
+	0.863038f,
+	0.332486f,
+	-0.131533f,
+	0.903571f,
+	0.407748f,
+	0.119586f,
+	0.9109f,
+	0.394918f,
+	0.299052f,
+	0.87558f,
+	0.379379f,
+	0.370047f,
+	0.8611f,
+	0.348671f,
+	0.442832f,
+	0.822723f,
+	0.356408f,
+	0.35885f,
+	0.890772f,
+	0.278839f,
+	0.314791f,
+	0.940053f,
+	0.131179f,
+	0.339464f,
+	0.925728f,
+	0.166711f,
+	0.403599f,
+	0.900778f,
+	0.160334f,
+	0.45653f,
+	0.889636f,
+	-0.0113152f,
+	0.365242f,
+	0.916509f,
+	-0.163124f,
+	0.379822f,
+	0.91652f,
+	-0.125407f,
+	0.442125f,
+	0.891797f,
+	-0.096041f,
+	0.493888f,
+	0.864551f,
+	-0.0928755f,
+	0.541781f,
+	0.83947f,
+	-0.041994f,
+	0.441424f,
+	0.894377f,
+	-0.0723577f,
+	0.226514f,
+	0.958331f,
+	-0.174048f,
+	0.0664964f,
+	0.969681f,
+	-0.235153f,
+	-0.103823f,
+	0.949537f,
+	-0.295973f,
+	-0.233692f,
+	0.889012f,
+	-0.39376f,
+	-0.0987171f,
+	0.939339f,
+	-0.328477f,
+	0.103986f,
+	0.972613f,
+	-0.207871f,
+	0.198802f,
+	0.974287f,
+	-0.106033f,
+	0.0601774f,
+	0.998175f,
+	0.00500958f,
+	-0.0421158f,
+	0.995212f,
+	0.0882012f,
+	-0.0598721f,
+	0.997785f,
+	-0.0289851f,
+	-0.030607f,
+	0.999125f,
+	-0.0285146f,
+	-0.00697633f,
+	0.993471f,
+	-0.113875f,
+	0.0388611f,
+	0.980882f,
+	-0.190686f,
+	0.0977483f,
+	0.98843f,
+	-0.115983f,
+	0.15403f,
+	0.986798f,
+	-0.0500538f,
+	0.193054f,
+	0.979913f,
+	-0.0500083f,
+	0.157678f,
+	0.98694f,
+	-0.0329733f,
+	-0.0158549f,
+	0.999428f,
+	0.0298765f,
+	-0.0525571f,
+	0.987534f,
+	0.14837f,
+	0.000720533f,
+	0.997813f,
+	0.0660913f,
+	-0.102677f,
+	0.99254f,
+	-0.0657426f,
+	-0.099341f,
+	0.994285f,
+	-0.0391091f,
+	-0.0676495f,
+	0.996952f,
+	-0.0388727f,
+	0.0225146f,
+	0.999293f,
+	0.0301014f,
+	0.0577235f,
+	0.997453f,
+	0.0418936f,
+	-0.0269869f,
+	0.999243f,
+	0.0280361f,
+	0.00446401f,
+	0.985157f,
+	0.171599f,
+	-0.0141502f,
+	0.990326f,
+	0.138035f,
+	-0.00518586f,
+	0.999975f,
+	0.00477817f,
+	-0.0328139f,
+	0.995381f,
+	-0.09022f,
+	-0.128063f,
+	0.971338f,
+	-0.200254f,
+	-0.151852f,
+	0.967914f,
+	-0.200209f,
+	-0.0720493f,
+	0.989055f,
+	-0.128759f,
+	-0.0591129f,
+	0.991504f,
+	-0.115868f,
+	-0.248059f,
+	0.943661f,
+	-0.219024f,
+	-0.389946f,
+	0.877483f,
+	-0.279225f,
+	-0.523332f,
+	0.810744f,
+	-0.262332f,
+	-0.51839f,
+	0.842544f,
+	-0.146256f,
+	-0.550368f,
+	0.815716f,
+	-0.178051f,
+	-0.560732f,
+	0.813038f,
+	-0.156683f,
+	-0.427123f,
+	0.899415f,
+	-0.0928351f,
+	-0.366593f,
+	0.924495f,
+	-0.104494f,
+	-0.322547f,
+	0.93696f,
+	-0.134426f,
+	-0.128035f,
+	0.99042f,
+	-0.0517317f,
+	-0.291376f,
+	0.953688f,
+	0.0746902f,
+	-0.520094f,
+	0.826135f,
+	0.216802f,
+	-0.516864f,
+	0.826474f,
+	0.22314f,
+	-0.396988f,
+	0.892552f,
+	0.213897f,
+	-0.184148f,
+	0.954818f,
+	0.233263f,
+	0.0957205f,
+	0.95579f,
+	0.278034f,
+	0.314018f,
+	0.892294f,
+	0.32435f,
+	0.401668f,
+	0.873128f,
+	0.276243f,
+	0.463054f,
+	0.857596f,
+	0.223851f,
+	0.480022f,
+	0.855973f,
+	0.192066f,
+	0.375927f,
+	0.916106f,
+	0.13939f,
+	0.288789f,
+	0.941864f,
+	0.171735f,
+	0.396643f,
+	0.909563f,
+	0.123974f,
+	0.561623f,
+	0.825897f,
+	0.0497286f,
+	0.465605f,
+	0.881752f,
+	-0.0756653f,
+	0.370044f,
+	0.915005f,
+	-0.160728f,
+	0.427822f,
+	0.898624f,
+	-0.0971747f,
+	0.465206f,
+	0.885137f,
+	-0.0107503f,
+	0.468824f,
+	0.88183f,
+	0.0507874f,
+	0.478143f,
+	0.868746f,
+	0.12907f,
+	0.351411f,
+	0.934208f,
+	0.0613665f,
+	0.140442f,
+	0.98844f,
+	-0.0571117f,
+	-0.0122878f,
+	0.991421f,
+	-0.130131f,
+	-0.117862f,
+	0.972142f,
+	-0.202603f,
+	-0.15815f,
+	0.947613f,
+	-0.27752f,
+	-0.0729629f,
+	0.95654f,
+	-0.282325f,
+	0.0272484f,
+	0.989771f,
+	-0.14004f,
+	-0.0137333f,
+	0.999563f,
+	0.0261849f,
+	-0.0985129f,
+	0.993299f,
+	0.0604412f,
+	-0.135233f,
+	0.990548f,
+	-0.0229695f,
+	-0.0373153f,
+	0.999264f,
+	0.00888433f,
+	0.0352261f,
+	0.99933f,
+	0.00994916f,
+	0.061219f,
+	0.99588f,
+	0.0668911f,
+	0.0815695f,
+	0.99444f,
+	0.0665983f,
+	0.144386f,
+	0.989424f,
+	0.0139045f,
+	0.184662f,
+	0.980318f,
+	0.0698361f,
+	0.0224217f,
+	0.989677f,
+	0.14155f,
+	-0.0794321f,
+	0.954058f,
+	0.288901f,
+	-0.0304562f,
+	0.959461f,
+	0.280192f,
+	0.112423f,
+	0.968918f,
+	0.220359f,
+	0.0390938f,
+	0.993037f,
+	0.111126f,
+	-0.0885962f,
+	0.9933f,
+	-0.0741985f,
+	-0.0453085f,
+	0.996418f,
+	-0.0714089f,
+	-0.123875f,
+	0.985221f,
+	-0.118298f,
+	0.00670832f,
+	0.999925f,
+	0.010273f,
+	-0.0146906f,
+	0.998569f,
+	0.0514303f,
+	-0.0998092f,
+	0.992773f,
+	0.0666264f,
+	0.0466126f,
+	0.990197f,
+	0.131669f,
+	0.103009f,
+	0.992862f,
+	0.0601126f,
+	0.113553f,
+	0.993084f,
+	-0.0298385f,
+	-0.0128779f,
+	0.975704f,
+	-0.218713f,
+	-0.177855f,
+	0.94662f,
+	-0.268846f,
+	-0.191482f,
+	0.955424f,
+	-0.224722f,
+	-0.0532043f,
+	0.987628f,
+	-0.147512f,
+	-0.140744f,
+	0.970833f,
+	-0.194099f,
+	-0.387395f,
+	0.889373f,
+	-0.242778f,
+	-0.531553f,
+	0.818908f,
+	-0.216427f,
+	-0.531571f,
+	0.799354f,
+	-0.280115f,
+	-0.51407f,
+	0.81292f,
+	-0.273666f,
+	-0.549112f,
+	0.793924f,
+	-0.261078f,
+	-0.484709f,
+	0.822384f,
+	-0.297895f,
+	-0.322663f,
+	0.926066f,
+	-0.195678f,
+	-0.315438f,
+	0.927311f,
+	-0.201479f,
+	-0.289702f,
+	0.947148f,
+	-0.13778f,
+	-0.417457f,
+	0.908684f,
+	-0.00477603f,
+	-0.584599f,
+	0.810188f,
+	0.0428868f,
+	-0.55194f,
+	0.828316f,
+	0.0962071f,
+	-0.397599f,
+	0.904432f,
+	0.154656f,
+	-0.183216f,
+	0.971572f,
+	0.149931f,
+	0.0355131f,
+	0.990243f,
+	0.134751f,
+	0.298837f,
+	0.942288f,
+	0.150964f,
+	0.413659f,
+	0.900634f,
+	0.133206f,
+	0.498073f,
+	0.828388f,
+	0.256313f,
+	0.444018f,
+	0.853405f,
+	0.273035f,
+	0.327561f,
+	0.881897f,
+	0.339061f,
+	0.313826f,
+	0.898686f,
+	0.306392f,
+	0.495157f,
+	0.851292f,
+	0.173556f,
+	0.614747f,
+	0.78345f,
+	0.0910662f,
+	0.55187f,
+	0.833866f,
+	0.0103585f,
+	0.367713f,
+	0.926545f,
+	-0.0793776f,
+	0.311567f,
+	0.950223f,
+	0.00108255f,
+	0.382947f,
+	0.917094f,
+	0.110859f,
+	0.410945f,
+	0.895808f,
+	0.169272f,
+	0.455231f,
+	0.858878f,
+	0.234721f,
+	0.373673f,
+	0.896264f,
+	0.238911f,
+	0.246571f,
+	0.935158f,
+	0.254328f,
+	0.0808975f,
+	0.990111f,
+	0.114608f,
+	-0.0843211f,
+	0.99633f,
+	-0.0147289f,
+	-0.0859474f,
+	0.994869f,
+	-0.0533687f,
+	-0.0567528f,
+	0.986639f,
+	-0.152718f,
+	-0.104487f,
+	0.984189f,
+	-0.143019f,
+	-0.139027f,
+	0.990289f,
+	8.5057e-005f,
+	-0.137547f,
+	0.987918f,
+	0.0714029f,
+	-0.144256f,
+	0.989201f,
+	-0.0259182f,
+	-0.026694f,
+	0.998838f,
+	-0.0401331f,
+	-0.0313342f,
+	0.99664f,
+	-0.0756769f,
+	-0.0574884f,
+	0.99781f,
+	0.0327011f,
+	0.145005f,
+	0.983413f,
+	0.108961f,
+	0.119257f,
+	0.992151f,
+	0.0376122f,
+	0.0587452f,
+	0.978725f,
+	0.196585f,
+	-0.0803833f,
+	0.947865f,
+	0.308369f,
+	-0.127827f,
+	0.919581f,
+	0.371526f,
+	-0.00616421f,
+	0.930831f,
+	0.365399f,
+	0.107639f,
+	0.912609f,
+	0.394409f,
+	0.210572f,
+	0.88729f,
+	0.410336f,
+	0.0740329f,
+	0.980065f,
+	0.184368f,
+	-0.0250926f,
+	0.999613f,
+	0.0120275f,
+	-0.0610433f,
+	0.996433f,
+	-0.05826f,
+	-0.0708404f,
+	0.994984f,
+	-0.0706271f,
+	-0.0640037f,
+	0.997923f,
+	-0.00726403f,
+	-0.0949547f,
+	0.99548f,
+	0.00148231f,
+	0.00929451f,
+	0.997943f,
+	-0.0634315f,
+	0.147986f,
+	0.988795f,
+	-0.0195964f,
+	0.19874f,
+	0.98001f,
+	-0.00909425f,
+	0.119683f,
+	0.99247f,
+	-0.0260466f,
+	-0.140841f,
+	0.984951f,
+	-0.10018f,
+	-0.197496f,
+	0.959342f,
+	-0.201637f,
+	-0.0821482f,
+	0.973605f,
+	-0.212945f,
+	-0.090387f,
+	0.978841f,
+	-0.18358f,
+	-0.34459f,
+	0.903344f,
+	-0.255395f,
+	-0.465169f,
+	0.833236f,
+	-0.29889f,
+	-0.493353f,
+	0.789348f,
+	-0.365421f,
+	-0.529455f,
+	0.773394f,
+	-0.348624f,
+	-0.541108f,
+	0.776645f,
+	-0.322528f,
+	-0.503238f,
+	0.814279f,
+	-0.289312f,
+	-0.451111f,
+	0.869282f,
+	-0.202106f,
+	-0.405307f,
+	0.906179f,
+	-0.120689f,
+	-0.367499f,
+	0.92846f,
+	-0.0539062f,
+	-0.448648f,
+	0.893437f,
+	-0.0220131f,
+	-0.582415f,
+	0.811815f,
+	-0.0418214f,
+	-0.587857f,
+	0.805915f,
+	-0.0701802f,
+	-0.440963f,
+	0.897524f,
+	0.00144435f,
+	-0.150082f,
+	0.985674f,
+	0.0769547f,
+	0.0512849f,
+	0.998035f,
+	0.0359923f,
+	0.331471f,
+	0.9412f,
+	0.0653422f,
+	0.327057f,
+	0.943418f,
+	0.0547333f,
+	0.325027f,
+	0.917755f,
+	0.228216f,
+	0.374201f,
+	0.856118f,
+	0.35642f,
+	0.374565f,
+	0.858588f,
+	0.350039f,
+	0.460817f,
+	0.854058f,
+	0.241312f,
+	0.556465f,
+	0.823608f,
+	0.109619f,
+	0.63153f,
+	0.770458f,
+	0.0869767f,
+	0.587056f,
+	0.806123f,
+	0.074369f,
+	0.365958f,
+	0.924908f,
+	0.10305f,
+	0.26636f,
+	0.954918f,
+	0.131089f,
+	0.330741f,
+	0.937061f,
+	0.111923f,
+	0.358992f,
+	0.918233f,
+	0.167249f,
+	0.397317f,
+	0.888574f,
+	0.229294f,
+	0.378918f,
+	0.890078f,
+	0.253343f,
+	0.252398f,
+	0.944302f,
+	0.211161f,
+	0.242388f,
+	0.947895f,
+	0.206744f,
+	0.0865865f,
+	0.99456f,
+	0.0579091f,
+	-0.0181168f,
+	0.990006f,
+	-0.139854f,
+	0.0162661f,
+	0.98021f,
+	-0.197289f,
+	-0.148111f,
+	0.960303f,
+	-0.236394f,
+	-0.255052f,
+	0.949006f,
+	-0.185302f,
+	-0.211751f,
+	0.971559f,
+	-0.105997f,
+	-0.0120621f,
+	0.994912f,
+	-0.100021f,
+	-0.015173f,
+	0.98959f,
+	-0.143115f,
+	-0.0401151f,
+	0.99847f,
+	-0.0380528f,
+	-0.0979763f,
+	0.995187f,
+	0.00194195f,
+	0.0571375f,
+	0.998251f,
+	0.0151643f,
+	0.0776787f,
+	0.976915f,
+	0.199006f,
+	-0.101892f,
+	0.95655f,
+	0.273185f,
+	-0.133768f,
+	0.938598f,
+	0.318024f,
+	-0.177801f,
+	0.93623f,
+	0.303084f,
+	-0.022321f,
+	0.922329f,
+	0.385761f,
+	0.0333931f,
+	0.905943f,
+	0.422081f,
+	0.163361f,
+	0.862964f,
+	0.478127f,
+	0.305267f,
+	0.821497f,
+	0.481617f,
+	0.18106f,
+	0.939243f,
+	0.291615f,
+	-0.00700511f,
+	0.992472f,
+	0.122275f,
+	-0.0966012f,
+	0.992994f,
+	0.068052f,
+	-0.106034f,
+	0.991731f,
+	0.0722919f,
+	-0.0353039f,
+	0.993084f,
+	0.11197f,
+	0.0541772f,
+	0.995603f,
+	0.0764134f,
+	0.08347f,
+	0.989853f,
+	0.114994f,
+	0.130868f,
+	0.975887f,
+	0.174696f,
+	0.0723356f,
+	0.969665f,
+	0.23349f,
+	-0.0470347f,
+	0.960948f,
+	0.272703f,
+	-0.10077f,
+	0.971805f,
+	0.213169f,
+	-0.119566f,
+	0.974584f,
+	0.189448f,
+	-0.0774738f,
+	0.965859f,
+	0.247214f,
+	-0.198029f,
+	0.968836f,
+	0.1488f,
+	-0.435505f,
+	0.897132f,
+	-0.0740912f,
+	-0.502708f,
+	0.857298f,
+	-0.111019f,
+	-0.564282f,
+	0.819749f,
+	-0.0979722f,
+	-0.594236f,
+	0.795147f,
+	-0.120937f,
+	-0.591492f,
+	0.803058f,
+	-0.0723546f,
+	-0.526826f,
+	0.849968f,
+	-0.0029614f,
+	-0.410127f,
+	0.912007f,
+	0.00617969f,
+	-0.355675f,
+	0.932755f,
+	-0.0588432f,
+	-0.457125f,
+	0.883759f,
+	-0.100032f,
+	-0.544765f,
+	0.834451f,
+	-0.0832032f,
+	-0.554858f,
+	0.819866f,
+	-0.141253f,
+	-0.535218f,
+	0.826621f,
+	-0.173894f,
+	-0.203549f,
+	0.978635f,
+	-0.0289948f,
+	0.0668755f,
+	0.997729f,
+	0.00799418f,
+	0.247034f,
+	0.968844f,
+	0.017759f,
+	0.275407f,
+	0.949712f,
+	0.148988f,
+	0.19759f,
+	0.950103f,
+	0.241375f,
+	0.374575f,
+	0.880138f,
+	0.291635f,
+	0.446827f,
+	0.865948f,
+	0.224675f,
+	0.519968f,
+	0.833624f,
+	0.186291f,
+	0.587008f,
+	0.786117f,
+	0.193499f,
+	0.636373f,
+	0.75334f,
+	0.165857f,
+	0.540728f,
+	0.822377f,
+	0.176944f,
+	0.345338f,
+	0.910903f,
+	0.225828f,
+	0.278322f,
+	0.945193f,
+	0.170723f,
+	0.30876f,
+	0.936535f,
+	0.166043f,
+	0.303863f,
+	0.916063f,
+	0.261719f,
+	0.319419f,
+	0.895614f,
+	0.309591f,
+	0.43277f,
+	0.828092f,
+	0.356332f,
+	0.333077f,
+	0.917687f,
+	0.216587f,
+	0.219655f,
+	0.964319f,
+	0.147787f,
+	0.242228f,
+	0.95005f,
+	0.196802f,
+	0.204875f,
+	0.978767f,
+	-0.00640881f,
+	-0.000192716f,
+	0.97566f,
+	-0.219288f,
+	-0.0681124f,
+	0.988809f,
+	-0.132732f,
+	-0.241144f,
+	0.919453f,
+	-0.310573f,
+	-0.290276f,
+	0.882193f,
+	-0.370776f,
+	0.0292627f,
+	0.97223f,
+	-0.232189f,
+	-0.0803803f,
+	0.976804f,
+	-0.198478f,
+	-0.203999f,
+	0.977793f,
+	-0.0480039f,
+	-0.118856f,
+	0.989202f,
+	0.0857425f,
+	-0.0783112f,
+	0.985397f,
+	0.151198f,
+	-0.0878718f,
+	0.938803f,
+	0.333059f,
+	-0.083435f,
+	0.948159f,
+	0.30665f,
+	-0.110585f,
+	0.962509f,
+	0.247682f,
+	-0.186686f,
+	0.943514f,
+	0.273733f,
+	-0.149516f,
+	0.932553f,
+	0.32862f,
+	-0.00475332f,
+	0.899494f,
+	0.436906f,
+	0.0862131f,
+	0.885009f,
+	0.457522f,
+	0.277459f,
+	0.815555f,
+	0.507825f,
+	0.298118f,
+	0.799955f,
+	0.520766f,
+	0.14455f,
+	0.869997f,
+	0.471392f,
+	0.0121492f,
+	0.942115f,
+	0.335071f,
+	-0.0752209f,
+	0.977077f,
+	0.199154f,
+	-0.128636f,
+	0.97789f,
+	0.164878f,
+	-0.000660482f,
+	0.945164f,
+	0.326595f,
+	0.00550592f,
+	0.919316f,
+	0.393482f,
+	0.0803772f,
+	0.905979f,
+	0.415621f,
+	0.0810259f,
+	0.907487f,
+	0.412192f,
+	-0.090779f,
+	0.919652f,
+	0.382099f,
+	-0.137864f,
+	0.897436f,
+	0.419048f,
+	-0.130404f,
+	0.886486f,
+	0.444001f,
+	-0.0852724f,
+	0.906321f,
+	0.413897f,
+	-0.0259127f,
+	0.906615f,
+	0.421163f,
+	-0.225351f,
+	0.915922f,
+	0.332119f,
+	-0.462548f,
+	0.869686f,
+	0.172323f,
+	-0.572668f,
+	0.816922f,
+	0.0684804f,
+	-0.585929f,
+	0.806118f,
+	0.0828267f,
+	-0.593406f,
+	0.803366f,
+	0.0497268f,
+	-0.516762f,
+	0.856027f,
+	-0.0132014f,
+	-0.38427f,
+	0.922646f,
+	-0.0325731f,
+	-0.287245f,
+	0.956724f,
+	-0.0465863f,
+	-0.413146f,
+	0.905396f,
+	-0.097823f,
+	-0.564236f,
+	0.818421f,
+	-0.108744f,
+	-0.507227f,
+	0.858315f,
+	-0.0775611f,
+	-0.527754f,
+	0.82927f,
+	-0.183811f,
+	-0.354765f,
+	0.918321f,
+	-0.175582f,
+	0.0463007f,
+	0.998926f,
+	-0.00175561f,
+	0.214268f,
+	0.976774f,
+	0.00151756f,
+	0.165544f,
+	0.983729f,
+	0.0698077f,
+	0.096445f,
+	0.982342f,
+	0.16032f,
+	0.366991f,
+	0.896711f,
+	0.24744f,
+	0.500788f,
+	0.845195f,
+	0.186699f,
+	0.507012f,
+	0.85355f,
+	0.119965f,
+	0.542994f,
+	0.824496f,
+	0.159261f,
+	0.605757f,
+	0.757486f,
+	0.243463f,
+	0.532123f,
+	0.786802f,
+	0.312711f,
+	0.44869f,
+	0.847812f,
+	0.282652f,
+	0.34333f,
+	0.935092f,
+	0.0879082f,
+	0.24319f,
+	0.961353f,
+	0.129073f,
+	0.223708f,
+	0.954136f,
+	0.198946f,
+	0.276144f,
+	0.94134f,
+	0.193965f,
+	0.41277f,
+	0.892522f,
+	0.181731f,
+	0.485836f,
+	0.856185f,
+	0.175815f,
+	0.251109f,
+	0.963495f,
+	0.0928509f,
+	0.217377f,
+	0.969921f,
+	0.109544f,
+	0.402023f,
+	0.911537f,
+	0.0864706f,
+	0.0930878f,
+	0.988366f,
+	-0.120284f,
+	-0.0926141f,
+	0.987658f,
+	-0.126311f,
+	-0.0129498f,
+	0.988134f,
+	-0.153049f,
+	-0.0752509f,
+	0.973537f,
+	-0.215783f,
+	-0.167591f,
+	0.970187f,
+	-0.175075f,
+	-0.227938f,
+	0.971032f,
+	-0.0717025f,
+	-0.288377f,
+	0.95589f,
+	0.0557925f,
+	-0.2706f,
+	0.959797f,
+	0.0746015f,
+	-0.201821f,
+	0.948409f,
+	0.244517f,
+	-0.135104f,
+	0.944724f,
+	0.298737f,
+	0.0536332f,
+	0.953012f,
+	0.298147f,
+	-0.104499f,
+	0.972769f,
+	0.206883f,
+	-0.26012f,
+	0.936243f,
+	0.236192f,
+	-0.221301f,
+	0.933098f,
+	0.283468f,
+	-0.0976008f,
+	0.934678f,
+	0.341835f,
+	0.0488135f,
+	0.920165f,
+	0.388475f,
+	0.20566f,
+	0.878417f,
+	0.431379f,
+	0.294052f,
+	0.82595f,
+	0.480979f,
+	0.211093f,
+	0.846234f,
+	0.489211f,
+	0.1526f,
+	0.86506f,
+	0.477897f,
+	0.100541f,
+	0.907805f,
+	0.407163f,
+	-0.126416f,
+	0.965258f,
+	0.228683f,
+	-0.211306f,
+	0.949302f,
+	0.232755f,
+	-0.037039f,
+	0.912463f,
+	0.40748f,
+	0.117233f,
+	0.908378f,
+	0.401379f,
+	0.101997f,
+	0.928038f,
+	0.35825f,
+	-0.0502775f,
+	0.939056f,
+	0.340069f,
+	-0.158243f,
+	0.952358f,
+	0.260718f,
+	-0.125329f,
+	0.958222f,
+	0.257106f,
+	-0.051336f,
+	0.956723f,
+	0.286436f,
+	-0.0625203f,
+	0.954305f,
+	0.29222f,
+	-0.207996f,
+	0.932703f,
+	0.294623f,
+	-0.319481f,
+	0.91161f,
+	0.258649f,
+	-0.495077f,
+	0.865137f,
+	0.0802322f,
+	-0.579132f,
+	0.814857f,
+	-0.0247929f,
+	-0.549115f,
+	0.83292f,
+	-0.0686783f,
+	-0.493373f,
+	0.86244f,
+	-0.113053f,
+	-0.402759f,
+	0.911225f,
+	-0.0863345f,
+	-0.292096f,
+	0.955556f,
+	-0.0399004f,
+	-0.382523f,
+	0.923047f,
+	-0.0407488f,
+	-0.572187f,
+	0.816414f,
+	-0.0779103f,
+	-0.512485f,
+	0.857517f,
+	-0.0449819f,
+	-0.420369f,
+	0.906318f,
+	-0.0433336f,
+	-0.419207f,
+	0.879291f,
+	-0.22608f,
+	-0.129012f,
+	0.980121f,
+	-0.150729f,
+	0.168538f,
+	0.98409f,
+	0.056222f,
+	0.177285f,
+	0.97778f,
+	0.111881f,
+	0.0313595f,
+	0.998166f,
+	-0.0517722f,
+	0.266622f,
+	0.963684f,
+	-0.0150476f,
+	0.566513f,
+	0.817464f,
+	0.103999f,
+	0.539244f,
+	0.841888f,
+	0.0209898f,
+	0.503392f,
+	0.861782f,
+	0.0626771f,
+	0.548011f,
+	0.825978f,
+	0.132075f,
+	0.53464f,
+	0.817691f,
+	0.213407f,
+	0.52656f,
+	0.822061f,
+	0.21668f,
+	0.418461f,
+	0.898681f,
+	0.131391f,
+	0.217077f,
+	0.97168f,
+	0.0933593f,
+	0.230073f,
+	0.97316f,
+	0.00512693f,
+	0.352039f,
+	0.933499f,
+	-0.0681773f,
+	0.427612f,
+	0.891089f,
+	-0.152014f,
+	0.47402f,
+	0.877861f,
+	-0.0682997f,
+	0.292505f,
+	0.956178f,
+	-0.0128375f,
+	0.212998f,
+	0.971167f,
+	-0.107084f,
+	0.394409f,
+	0.913171f,
+	-0.102761f,
+	0.229015f,
+	0.973422f,
+	0.000912976f,
+	-0.0760893f,
+	0.988509f,
+	-0.130618f,
+	-0.0515625f,
+	0.984716f,
+	-0.166362f,
+	-0.0928406f,
+	0.987408f,
+	-0.128086f,
+	-0.200115f,
+	0.967117f,
+	0.156969f,
+	-0.29324f,
+	0.941681f,
+	0.165066f,
+	-0.336305f,
+	0.919935f,
+	0.201539f,
+	-0.298108f,
+	0.921775f,
+	0.247915f,
+	-0.262609f,
+	0.920325f,
+	0.289892f,
+	-0.146209f,
+	0.952657f,
+	0.266586f,
+	-0.00778438f,
+	0.956339f,
+	0.292158f,
+	-0.050022f,
+	0.92665f,
+	0.372583f,
+	-0.258705f,
+	0.916977f,
+	0.303687f,
+	-0.247478f,
+	0.923305f,
+	0.293706f,
+	-0.126717f,
+	0.938107f,
+	0.322331f,
+	0.0303988f,
+	0.946862f,
+	0.320201f,
+	0.135735f,
+	0.944675f,
+	0.298606f,
+	0.25669f,
+	0.889672f,
+	0.377616f,
+	0.215508f,
+	0.868916f,
+	0.44558f,
+	0.117717f,
+	0.868155f,
+	0.482129f,
+	0.172493f,
+	0.853951f,
+	0.490931f,
+	0.0744588f,
+	0.909987f,
+	0.407897f,
+	-0.203499f,
+	0.942765f,
+	0.264163f,
+	-0.165852f,
+	0.956441f,
+	0.240237f,
+	0.150303f,
+	0.946565f,
+	0.285349f,
+	0.126121f,
+	0.955231f,
+	0.267632f,
+	0.00383767f,
+	0.957166f,
+	0.289515f,
+	-0.0803601f,
+	0.965694f,
+	0.246937f,
+	-0.14415f,
+	0.963474f,
+	0.225698f,
+	-0.128772f,
+	0.964294f,
+	0.231421f,
+	-0.0634991f,
+	0.964707f,
+	0.255554f,
+	-0.15178f,
+	0.96554f,
+	0.211412f,
+	-0.290877f,
+	0.950446f,
+	0.109737f,
+	-0.365587f,
+	0.928197f,
+	0.069257f,
+	-0.512709f,
+	0.855901f,
+	-0.0675528f,
+	-0.522587f,
+	0.843414f,
+	-0.12472f,
+	-0.519355f,
+	0.843468f,
+	-0.13723f,
+	-0.458617f,
+	0.886978f,
+	-0.054221f,
+	-0.335795f,
+	0.941914f,
+	0.00633015f,
+	-0.354719f,
+	0.934449f,
+	0.0312872f,
+	-0.552854f,
+	0.83289f,
+	-0.025441f,
+	-0.550469f,
+	0.834453f,
+	-0.0259307f,
+	-0.388185f,
+	0.921529f,
+	-0.00983026f,
+	-0.282899f,
+	0.957493f,
+	-0.056358f,
+	-0.256814f,
+	0.955751f,
+	-0.143483f,
+	-0.0731312f,
+	0.996697f,
+	-0.0353254f,
+	0.211397f,
+	0.967055f,
+	0.141832f,
+	0.27554f,
+	0.960583f,
+	0.0368595f,
+	0.217196f,
+	0.959783f,
+	-0.177882f,
+	0.479261f,
+	0.875236f,
+	-0.0653524f,
+	0.513664f,
+	0.856169f,
+	0.0558883f,
+	0.446145f,
+	0.882397f,
+	0.149434f,
+	0.498219f,
+	0.84712f,
+	0.184837f,
+	0.503236f,
+	0.827823f,
+	0.247916f,
+	0.51285f,
+	0.815024f,
+	0.269666f,
+	0.506381f,
+	0.824734f,
+	0.251778f,
+	0.333663f,
+	0.940706f,
+	0.0611746f,
+	0.353215f,
+	0.932965f,
+	-0.069389f,
+	0.414309f,
+	0.904024f,
+	-0.105298f,
+	0.451897f,
+	0.886486f,
+	-0.0996557f,
+	0.345824f,
+	0.933767f,
+	-0.0921138f,
+	0.280994f,
+	0.95917f,
+	0.0321915f,
+	0.317081f,
+	0.945948f,
+	0.0681282f,
+	0.344866f,
+	0.938141f,
+	0.0309596f,
+	0.224406f,
+	0.974203f,
+	0.0238892f,
+	-0.0108486f,
+	0.995761f,
+	-0.0913323f,
+	-0.00158176f,
+	0.998953f,
+	-0.0457292f,
+	-0.115676f,
+	0.985559f,
+	-0.123663f,
+	-0.188171f,
+	0.911466f,
+	0.365816f,
+	-0.262724f,
+	0.896783f,
+	0.356029f,
+	-0.358149f,
+	0.883197f,
+	0.302807f,
+	-0.323424f,
+	0.894918f,
+	0.307438f,
+	-0.242922f,
+	0.924564f,
+	0.293548f,
+	-0.121147f,
+	0.94907f,
+	0.290844f,
+	-0.0341414f,
+	0.951299f,
+	0.306374f,
+	-0.132493f,
+	0.945016f,
+	0.298983f,
+	-0.194216f,
+	0.905093f,
+	0.378268f,
+	-0.212944f,
+	0.914784f,
+	0.343257f,
+	-0.127802f,
+	0.956235f,
+	0.263215f,
+	0.0483659f,
+	0.968777f,
+	0.243172f,
+	0.117573f,
+	0.942608f,
+	0.312517f,
+	0.164225f,
+	0.89741f,
+	0.409494f,
+	0.122313f,
+	0.88201f,
+	0.455081f,
+	0.101965f,
+	0.875392f,
+	0.472537f,
+	0.209339f,
+	0.879095f,
+	0.428217f,
+	0.174899f,
+	0.892224f,
+	0.416349f,
+	-0.060088f,
+	0.941634f,
+	0.331231f,
+	-0.120508f,
+	0.975773f,
+	0.182606f,
+	0.112168f,
+	0.972734f,
+	0.202994f,
+	0.117253f,
+	0.950933f,
+	0.286318f,
+	-0.0544328f,
+	0.941394f,
+	0.332887f,
+	-0.0790068f,
+	0.915303f,
+	0.394942f,
+	-0.127609f,
+	0.917525f,
+	0.376648f,
+	-0.0756868f,
+	0.941409f,
+	0.328666f,
+	-0.0332439f,
+	0.958716f,
+	0.282415f,
+	-0.0735168f,
+	0.965505f,
+	0.249792f,
+	-0.203882f,
+	0.964791f,
+	0.166163f,
+	-0.320453f,
+	0.94269f,
+	0.0929826f,
+	-0.471247f,
+	0.881185f,
+	0.0379224f,
+	-0.492278f,
+	0.869051f,
+	0.0491152f,
+	-0.532259f,
+	0.846256f,
+	-0.0234739f,
+	-0.499446f,
+	0.866138f,
+	-0.0189645f,
+	-0.373407f,
+	0.92679f,
+	-0.0403466f,
+	-0.352534f,
+	0.935772f,
+	-0.00715155f,
+	-0.527726f,
+	0.848793f,
+	-0.0324855f,
+	-0.520812f,
+	0.852354f,
+	-0.0474108f,
+	-0.409147f,
+	0.909436f,
+	-0.0743255f,
+	-0.294722f,
+	0.955583f,
+	0.000817458f,
+	-0.222255f,
+	0.974321f,
+	0.0360744f,
+	-0.14278f,
+	0.989739f,
+	0.00545783f,
+	0.112175f,
+	0.992761f,
+	0.0429195f,
+	0.349968f,
+	0.931754f,
+	0.0967357f,
+	0.338116f,
+	0.939385f,
+	0.056869f,
+	0.379594f,
+	0.923814f,
+	0.0497667f,
+	0.434257f,
+	0.879279f,
+	0.195674f,
+	0.391146f,
+	0.89525f,
+	0.213383f,
+	0.465582f,
+	0.860371f,
+	0.207352f,
+	0.429826f,
+	0.860017f,
+	0.274991f,
+	0.465148f,
+	0.815034f,
+	0.34548f,
+	0.575943f,
+	0.73808f,
+	0.351465f,
+	0.535537f,
+	0.824709f,
+	0.181813f,
+	0.414278f,
+	0.908562f,
+	-0.0537569f,
+	0.380258f,
+	0.913027f,
+	-0.147599f,
+	0.408447f,
+	0.90132f,
+	-0.144197f,
+	0.367806f,
+	0.925659f,
+	-0.0887431f,
+	0.142987f,
+	0.986995f,
+	-0.073455f,
+	0.215691f,
+	0.972786f,
+	0.0846483f,
+	0.373384f,
+	0.916381f,
+	0.144331f,
+	0.381582f,
+	0.918997f,
+	0.0991966f,
+	0.0727073f,
+	0.993287f,
+	-0.0899678f,
+	-0.0658262f,
+	0.992454f,
+	-0.103446f,
+	0.0138596f,
+	0.999564f,
+	-0.0260736f,
+	-0.215981f,
+	0.852322f,
+	0.47634f,
+	-0.206677f,
+	0.845053f,
+	0.493123f,
+	-0.272991f,
+	0.879681f,
+	0.389406f,
+	-0.267376f,
+	0.924267f,
+	0.272471f,
+	-0.22026f,
+	0.956955f,
+	0.189003f,
+	-0.175208f,
+	0.966589f,
+	0.187106f,
+	-0.043064f,
+	0.959071f,
+	0.279872f,
+	-0.116589f,
+	0.955061f,
+	0.272519f,
+	-0.310776f,
+	0.922421f,
+	0.229257f,
+	-0.169995f,
+	0.929299f,
+	0.32788f,
+	-0.0175005f,
+	0.941141f,
+	0.337561f,
+	0.0138751f,
+	0.95035f,
+	0.310874f,
+	-0.0519487f,
+	0.924056f,
+	0.37871f,
+	0.0171204f,
+	0.875115f,
+	0.483613f,
+	0.148666f,
+	0.835016f,
+	0.529761f,
+	0.187668f,
+	0.864969f,
+	0.465412f,
+	0.241037f,
+	0.89408f,
+	0.377521f,
+	0.22255f,
+	0.900707f,
+	0.373093f,
+	0.0517034f,
+	0.945752f,
+	0.320749f,
+	-0.0271248f,
+	0.957046f,
+	0.288665f,
+	0.0325916f,
+	0.970401f,
+	0.239289f,
+	0.0171507f,
+	0.960836f,
+	0.276588f,
+	-0.143534f,
+	0.9275f,
+	0.345169f,
+	-0.0983366f,
+	0.916766f,
+	0.38713f,
+	-0.0476997f,
+	0.944806f,
+	0.32414f,
+	-0.0337303f,
+	0.946895f,
+	0.319767f,
+	-0.0100366f,
+	0.942379f,
+	0.334396f,
+	-0.0544901f,
+	0.938102f,
+	0.342046f,
+	-0.14598f,
+	0.916868f,
+	0.371541f,
+	-0.23743f,
+	0.904478f,
+	0.354324f,
+	-0.411826f,
+	0.87795f,
+	0.244136f,
+	-0.481531f,
+	0.866693f,
+	0.130273f,
+	-0.469337f,
+	0.874903f,
+	0.119446f,
+	-0.452816f,
+	0.890509f,
+	0.0441746f,
+	-0.332275f,
+	0.942324f,
+	-0.0402274f,
+	-0.391441f,
+	0.91825f,
+	-0.0599172f,
+	-0.492183f,
+	0.870395f,
+	0.0129854f,
+	-0.540952f,
+	0.839903f,
+	-0.0439814f,
+	-0.452633f,
+	0.891182f,
+	0.0302916f,
+	-0.353037f,
+	0.931758f,
+	0.0848037f,
+	-0.230998f,
+	0.971043f,
+	0.0609518f,
+	-0.110559f,
+	0.993184f,
+	0.0368984f,
+	0.0985994f,
+	0.994896f,
+	-0.0214387f,
+	0.290703f,
+	0.956813f,
+	-0.000841556f,
+	0.306742f,
+	0.941069f,
+	0.142471f,
+	0.309512f,
+	0.928678f,
+	0.20435f,
+	0.393276f,
+	0.890035f,
+	0.23059f,
+	0.472781f,
+	0.864565f,
+	0.170309f,
+	0.455511f,
+	0.888755f,
+	0.0512287f,
+	0.387199f,
+	0.912459f,
+	0.13227f,
+	0.420125f,
+	0.891345f,
+	0.170293f,
+	0.568557f,
+	0.791084f,
+	0.225676f,
+	0.642678f,
+	0.725845f,
+	0.245181f,
+	0.61301f,
+	0.785525f,
+	0.0846683f,
+	0.519083f,
+	0.833826f,
+	-0.187849f,
+	0.390386f,
+	0.832025f,
+	-0.394123f,
+	0.254733f,
+	0.897839f,
+	-0.359161f,
+	0.0968538f,
+	0.955535f,
+	-0.278518f,
+	0.110338f,
+	0.951183f,
+	-0.288231f,
+	0.337547f,
+	0.917961f,
+	-0.20835f,
+	0.382401f,
+	0.916771f,
+	-0.115327f,
+	0.232755f,
+	0.967238f,
+	-0.101374f,
+	-0.075544f,
+	0.963631f,
+	-0.256338f,
+	-0.111861f,
+	0.963998f,
+	-0.241238f,
+	-0.403631f,
+	0.823611f,
+	0.398431f,
+	-0.211285f,
+	0.853176f,
+	0.476917f,
+	-0.0996818f,
+	0.887327f,
+	0.450237f,
+	-0.119017f,
+	0.926423f,
+	0.357178f,
+	-0.147962f,
+	0.959424f,
+	0.240027f,
+	-0.17904f,
+	0.969453f,
+	0.167646f,
+	-0.182698f,
+	0.967757f,
+	0.173402f,
+	-0.0875162f,
+	0.935774f,
+	0.341566f,
+	-0.247354f,
+	0.926662f,
+	0.283043f,
+	-0.269706f,
+	0.932828f,
+	0.238937f,
+	-0.116046f,
+	0.932011f,
+	0.34335f,
+	-0.054572f,
+	0.895119f,
+	0.442474f,
+	-0.0702883f,
+	0.870311f,
+	0.487462f,
+	-0.0238769f,
+	0.872685f,
+	0.4877f,
+	0.145141f,
+	0.847062f,
+	0.511292f,
+	0.26226f,
+	0.839585f,
+	0.475728f,
+	0.307436f,
+	0.859155f,
+	0.409067f,
+	0.272452f,
+	0.896089f,
+	0.35042f,
+	0.0602872f,
+	0.949936f,
+	0.306572f,
+	-0.0269541f,
+	0.950357f,
+	0.309992f,
+	0.110161f,
+	0.964193f,
+	0.241239f,
+	0.0112822f,
+	0.980274f,
+	0.19732f,
+	-0.201697f,
+	0.957263f,
+	0.207282f,
+	-0.0780713f,
+	0.964435f,
+	0.252529f,
+	0.00973745f,
+	0.973101f,
+	0.230172f,
+	-0.0755968f,
+	0.981149f,
+	0.177855f,
+	-0.0876613f,
+	0.97114f,
+	0.221817f,
+	-0.111729f,
+	0.927016f,
+	0.357991f,
+	-0.221124f,
+	0.882386f,
+	0.41533f,
+	-0.204491f,
+	0.867297f,
+	0.45385f,
+	-0.238609f,
+	0.89578f,
+	0.375026f,
+	-0.38933f,
+	0.904206f,
+	0.175592f,
+	-0.447525f,
+	0.889442f,
+	0.0928077f,
+	-0.421271f,
+	0.9063f,
+	0.0339399f,
+	-0.295839f,
+	0.951557f,
+	0.0837779f,
+	-0.40469f,
+	0.90695f,
+	0.116906f,
+	-0.500893f,
+	0.852054f,
+	0.152018f,
+	-0.539765f,
+	0.838827f,
+	0.0708671f,
+	-0.497421f,
+	0.864837f,
+	0.068037f,
+	-0.338953f,
+	0.937284f,
+	0.0813017f,
+	-0.178116f,
+	0.975677f,
+	0.127782f,
+	-0.0428295f,
+	0.992057f,
+	0.118272f,
+	0.176596f,
+	0.983706f,
+	0.0336999f,
+	0.217356f,
+	0.975284f,
+	-0.0397137f,
+	0.172156f,
+	0.984981f,
+	0.0131952f,
+	0.279801f,
+	0.958586f,
+	0.0531518f,
+	0.429228f,
+	0.901897f,
+	0.0484305f,
+	0.537427f,
+	0.843269f,
+	0.00840869f,
+	0.461159f,
+	0.886671f,
+	-0.0338697f,
+	0.347666f,
+	0.937337f,
+	0.022966f,
+	0.390524f,
+	0.920568f,
+	0.00669632f,
+	0.544615f,
+	0.837115f,
+	0.0513162f,
+	0.64737f,
+	0.75903f,
+	0.0691749f,
+	0.709483f,
+	0.698136f,
+	0.0961199f,
+	0.69002f,
+	0.723355f,
+	-0.0250988f,
+	0.510759f,
+	0.819636f,
+	-0.259464f,
+	0.161066f,
+	0.87948f,
+	-0.447854f,
+	0.0742832f,
+	0.901252f,
+	-0.426881f,
+	0.164688f,
+	0.896506f,
+	-0.411284f,
+	0.211827f,
+	0.873436f,
+	-0.43845f,
+	0.238498f,
+	0.898773f,
+	-0.367868f,
+	0.244991f,
+	0.941894f,
+	-0.229815f,
+	0.0339169f,
+	0.959887f,
+	-0.278328f,
+	-0.150927f,
+	0.928909f,
+	-0.338156f,
+	-0.262269f,
+	0.839002f,
+	0.47675f,
+	-0.199453f,
+	0.89484f,
+	0.39935f,
+	-0.0695117f,
+	0.920513f,
+	0.384478f,
+	-0.0794509f,
+	0.922822f,
+	0.376943f,
+	-0.0384813f,
+	0.923599f,
+	0.381424f,
+	-0.0906334f,
+	0.946866f,
+	0.308593f,
+	-0.231342f,
+	0.940055f,
+	0.250554f,
+	-0.228342f,
+	0.910605f,
+	0.344468f,
+	-0.168052f,
+	0.897027f,
+	0.408779f,
+	-0.249241f,
+	0.920512f,
+	0.300892f,
+	-0.201125f,
+	0.932701f,
+	0.29936f,
+	-0.156169f,
+	0.918655f,
+	0.362882f,
+	-0.101964f,
+	0.881359f,
+	0.461314f,
+	-0.0479674f,
+	0.88379f,
+	0.465418f,
+	0.160937f,
+	0.878499f,
+	0.449821f,
+	0.298148f,
+	0.878819f,
+	0.372539f,
+	0.363972f,
+	0.843945f,
+	0.394059f,
+	0.330687f,
+	0.867316f,
+	0.372033f,
+	0.109951f,
+	0.941418f,
+	0.318814f,
+	0.0530775f,
+	0.967978f,
+	0.245361f,
+	0.171035f,
+	0.972595f,
+	0.157499f,
+	0.0211384f,
+	0.985036f,
+	0.171048f,
+	-0.223743f,
+	0.958122f,
+	0.178723f,
+	-0.143003f,
+	0.966115f,
+	0.214875f,
+	0.0335442f,
+	0.969798f,
+	0.24159f,
+	0.00108957f,
+	0.977785f,
+	0.209606f,
+	-0.185748f,
+	0.96522f,
+	0.183978f,
+	-0.245345f,
+	0.928456f,
+	0.278881f,
+	-0.278935f,
+	0.920412f,
+	0.273928f,
+	-0.227379f,
+	0.922009f,
+	0.313367f,
+	-0.127558f,
+	0.911679f,
+	0.390603f,
+	-0.252363f,
+	0.916101f,
+	0.311563f,
+	-0.353299f,
+	0.912723f,
+	0.205222f,
+	-0.418007f,
+	0.90407f,
+	0.089031f,
+	-0.400603f,
+	0.906481f,
+	0.133452f,
+	-0.448512f,
+	0.870078f,
+	0.204452f,
+	-0.467166f,
+	0.869433f,
+	0.160757f,
+	-0.442544f,
+	0.892618f,
+	0.0859534f,
+	-0.465336f,
+	0.885122f,
+	-0.00451183f,
+	-0.389888f,
+	0.920791f,
+	0.0114409f,
+	-0.26105f,
+	0.96208f,
+	0.079086f,
+	-0.0611649f,
+	0.990413f,
+	0.123862f,
+	0.218817f,
+	0.959555f,
+	0.177126f,
+	0.289447f,
+	0.944291f,
+	0.156638f,
+	0.238555f,
+	0.970242f,
+	0.0415028f,
+	0.303951f,
+	0.946528f,
+	-0.108164f,
+	0.431424f,
+	0.894504f,
+	-0.117199f,
+	0.527248f,
+	0.845956f,
+	-0.0797999f,
+	0.433918f,
+	0.900916f,
+	0.0081213f,
+	0.311993f,
+	0.948885f,
+	0.0477355f,
+	0.430547f,
+	0.901487f,
+	0.0441572f,
+	0.533619f,
+	0.845624f,
+	-0.013065f,
+	0.634808f,
+	0.772557f,
+	-0.013228f,
+	0.691864f,
+	0.721963f,
+	0.00965866f,
+	0.719067f,
+	0.694383f,
+	0.0278453f,
+	0.653183f,
+	0.756562f,
+	0.0310991f,
+	0.386363f,
+	0.918778f,
+	-0.0810638f,
+	0.0570874f,
+	0.970389f,
+	-0.234704f,
+	0.136394f,
+	0.961794f,
+	-0.237379f,
+	0.31236f,
+	0.906525f,
+	-0.283977f,
+	0.169471f,
+	0.890916f,
+	-0.421365f,
+	0.117142f,
+	0.913195f,
+	-0.390323f,
+	0.0777866f,
+	0.931625f,
+	-0.354998f,
+	-0.0437682f,
+	0.92941f,
+	-0.366443f,
+	-0.144429f,
+	0.859889f,
+	0.489623f,
+	-0.0880742f,
+	0.890372f,
+	0.446633f,
+	-0.0314378f,
+	0.923882f,
+	0.381384f,
+	-0.0838814f,
+	0.944139f,
+	0.318693f,
+	-0.0693885f,
+	0.945887f,
+	0.316991f,
+	-0.0723769f,
+	0.923178f,
+	0.377496f,
+	-0.19706f,
+	0.892458f,
+	0.405815f,
+	-0.297386f,
+	0.892332f,
+	0.339566f,
+	-0.156962f,
+	0.91638f,
+	0.368254f,
+	-0.15276f,
+	0.919794f,
+	0.361447f,
+	-0.17017f,
+	0.922781f,
+	0.345714f,
+	-0.253151f,
+	0.920843f,
+	0.296586f,
+	-0.189094f,
+	0.905109f,
+	0.380816f,
+	0.00126887f,
+	0.929197f,
+	0.369582f,
+	0.193396f,
+	0.936415f,
+	0.292787f,
+	0.338227f,
+	0.878943f,
+	0.336247f,
+	0.32269f,
+	0.878938f,
+	0.351198f,
+	0.355444f,
+	0.867037f,
+	0.34915f,
+	0.217316f,
+	0.918786f,
+	0.329554f,
+	0.123007f,
+	0.956146f,
+	0.265807f,
+	0.19987f,
+	0.950731f,
+	0.236986f,
+	0.0209731f,
+	0.979076f,
+	0.202411f,
+	-0.247784f,
+	0.961065f,
+	0.122302f,
+	-0.158935f,
+	0.979718f,
+	0.122036f,
+	0.0602949f,
+	0.986043f,
+	0.155188f,
+	-0.0308065f,
+	0.985867f,
+	0.164674f,
+	-0.185866f,
+	0.954971f,
+	0.231267f,
+	-0.272851f,
+	0.942767f,
+	0.191682f,
+	-0.226832f,
+	0.938998f,
+	0.258516f,
+	-0.311155f,
+	0.923351f,
+	0.224958f,
+	-0.264965f,
+	0.917378f,
+	0.297004f,
+	-0.186536f,
+	0.890461f,
+	0.41507f,
+	-0.257136f,
+	0.895376f,
+	0.363569f,
+	-0.330368f,
+	0.897563f,
+	0.291955f,
+	-0.415623f,
+	0.888172f,
+	0.19598f,
+	-0.414839f,
+	0.89462f,
+	0.166025f,
+	-0.429244f,
+	0.901932f,
+	0.0476213f,
+	-0.370358f,
+	0.92848f,
+	0.0275516f,
+	-0.456696f,
+	0.886215f,
+	-0.0777874f,
+	-0.424934f,
+	0.901633f,
+	-0.0805556f,
+	-0.26755f,
+	0.960865f,
+	-0.0718042f,
+	-0.0958709f,
+	0.992595f,
+	-0.0745981f,
+	0.0853594f,
+	0.996177f,
+	0.0185983f,
+	0.317006f,
+	0.925486f,
+	0.207323f,
+	0.362438f,
+	0.919121f,
+	0.154455f,
+	0.423147f,
+	0.903697f,
+	0.0654098f,
+	0.439077f,
+	0.898135f,
+	-0.0237805f,
+	0.463592f,
+	0.885685f,
+	-0.0253961f,
+	0.432904f,
+	0.900567f,
+	0.0396714f,
+	0.274262f,
+	0.960561f,
+	-0.0458644f,
+	0.460874f,
+	0.887433f,
+	0.00757752f,
+	0.557878f,
+	0.824691f,
+	-0.0930446f,
+	0.608392f,
+	0.791916f,
+	-0.0522232f,
+	0.68605f,
+	0.722282f,
+	0.0874302f,
+	0.697187f,
+	0.705867f,
+	0.125228f,
+	0.597474f,
+	0.77589f,
+	0.202532f,
+	0.400677f,
+	0.868028f,
+	0.293233f,
+	0.18602f,
+	0.951589f,
+	0.244694f,
+	0.190924f,
+	0.979879f,
+	0.0581851f,
+	0.431268f,
+	0.902043f,
+	-0.01807f,
+	0.329374f,
+	0.934061f,
+	-0.137997f,
+	0.144406f,
+	0.935772f,
+	-0.321679f,
+	0.0779514f,
+	0.92222f,
+	-0.378727f,
+	-0.0417532f,
+	0.914206f,
+	-0.403093f,
+	-0.201619f,
+	0.929423f,
+	0.309066f,
+	-0.0738258f,
+	0.948242f,
+	0.308847f,
+	0.0288118f,
+	0.952024f,
+	0.304665f,
+	-0.00526808f,
+	0.951397f,
+	0.307922f,
+	-0.0992485f,
+	0.952014f,
+	0.289515f,
+	-0.179425f,
+	0.914994f,
+	0.361376f,
+	-0.223397f,
+	0.866943f,
+	0.445538f,
+	-0.185005f,
+	0.868122f,
+	0.460584f,
+	-0.180405f,
+	0.90051f,
+	0.395646f,
+	-0.165976f,
+	0.891215f,
+	0.422122f,
+	-0.142635f,
+	0.91411f,
+	0.37955f,
+	-0.196593f,
+	0.942079f,
+	0.271733f,
+	-0.231892f,
+	0.955708f,
+	0.181242f,
+	0.0754625f,
+	0.968764f,
+	0.236224f,
+	0.189929f,
+	0.95814f,
+	0.214232f,
+	0.245783f,
+	0.922809f,
+	0.29667f,
+	0.350212f,
+	0.885135f,
+	0.30641f,
+	0.361791f,
+	0.894635f,
+	0.262174f,
+	0.218601f,
+	0.892888f,
+	0.393656f,
+	0.122578f,
+	0.888731f,
+	0.441737f,
+	0.221602f,
+	0.877963f,
+	0.42435f,
+	0.113111f,
+	0.927784f,
+	0.355561f,
+	-0.0962286f,
+	0.967788f,
+	0.232652f,
+	-0.169743f,
+	0.984124f,
+	0.0518298f,
+	0.00440837f,
+	0.997134f,
+	0.0755295f,
+	-0.0780505f,
+	0.992255f,
+	0.096638f,
+	-0.206915f,
+	0.971074f,
+	0.119173f,
+	-0.298261f,
+	0.946469f,
+	0.123437f,
+	-0.365054f,
+	0.904843f,
+	0.219077f,
+	-0.255666f,
+	0.897337f,
+	0.35975f,
+	-0.290965f,
+	0.914197f,
+	0.282104f,
+	-0.292271f,
+	0.916518f,
+	0.27308f,
+	-0.219619f,
+	0.919339f,
+	0.326472f,
+	-0.256286f,
+	0.928086f,
+	0.270137f,
+	-0.310598f,
+	0.93305f,
+	0.18151f,
+	-0.350728f,
+	0.934452f,
+	0.0615507f,
+	-0.388138f,
+	0.92156f,
+	0.00876308f,
+	-0.343471f,
+	0.93847f,
+	0.0360903f,
+	-0.339947f,
+	0.939272f,
+	-0.0469463f,
+	-0.382902f,
+	0.903055f,
+	-0.19462f,
+	-0.249239f,
+	0.929446f,
+	-0.272047f,
+	-0.147764f,
+	0.944907f,
+	-0.29209f,
+	-0.0668186f,
+	0.978447f,
+	-0.19539f,
+	0.17553f,
+	0.981686f,
+	-0.0740426f,
+	0.388973f,
+	0.921211f,
+	-0.00833323f,
+	0.44678f,
+	0.894539f,
+	-0.0136777f,
+	0.47739f,
+	0.878112f,
+	-0.0318964f,
+	0.465567f,
+	0.884409f,
+	-0.0326842f,
+	0.484387f,
+	0.873859f,
+	-0.0417148f,
+	0.315003f,
+	0.932104f,
+	-0.178762f,
+	0.426472f,
+	0.898104f,
+	-0.107381f,
+	0.587094f,
+	0.80929f,
+	-0.0192587f,
+	0.491946f,
+	0.869904f,
+	0.0354452f,
+	0.550379f,
+	0.808299f,
+	0.209131f,
+	0.597166f,
+	0.706874f,
+	0.379107f,
+	0.503286f,
+	0.706664f,
+	0.497322f,
+	0.349603f,
+	0.761935f,
+	0.545191f,
+	0.317931f,
+	0.791281f,
+	0.522298f,
+	0.357034f,
+	0.859818f,
+	0.365021f,
+	0.457671f,
+	0.859336f,
+	0.22821f,
+	0.436038f,
+	0.880267f,
+	0.187085f,
+	0.291237f,
+	0.949467f,
+	0.117016f,
+	0.172846f,
+	0.983353f,
+	0.0560389f,
+	0.00924155f,
+	0.999014f,
+	-0.043417f,
+	-0.112379f,
+	0.966854f,
+	0.22927f,
+	-0.0543436f,
+	0.980353f,
+	0.189616f,
+	0.0014105f,
+	0.977032f,
+	0.213089f,
+	-0.0810261f,
+	0.954455f,
+	0.287143f,
+	-0.162384f,
+	0.905883f,
+	0.391161f,
+	-0.248623f,
+	0.850337f,
+	0.463803f,
+	-0.272281f,
+	0.829594f,
+	0.48748f,
+	-0.210534f,
+	0.842738f,
+	0.495447f,
+	-0.142516f,
+	0.845822f,
+	0.514076f,
+	-0.128959f,
+	0.864859f,
+	0.485168f,
+	-0.000520612f,
+	0.895905f,
+	0.444245f,
+	0.00320439f,
+	0.940529f,
+	0.339698f,
+	-0.169376f,
+	0.979765f,
+	0.106637f,
+	-0.0517963f,
+	0.994886f,
+	0.0867084f,
+	0.124214f,
+	0.955178f,
+	0.268711f,
+	0.208945f,
+	0.916166f,
+	0.342027f,
+	0.39407f,
+	0.858275f,
+	0.328745f,
+	0.248342f,
+	0.913565f,
+	0.322063f,
+	0.031165f,
+	0.861455f,
+	0.506877f,
+	0.0654094f,
+	0.812115f,
+	0.57982f,
+	0.246891f,
+	0.786687f,
+	0.565834f,
+	0.230643f,
+	0.834381f,
+	0.500612f,
+	0.069509f,
+	0.924157f,
+	0.375637f,
+	0.0080049f,
+	0.977951f,
+	0.208681f,
+	-0.0216545f,
+	0.998818f,
+	0.043521f,
+	-0.0416834f,
+	0.994806f,
+	0.0928633f,
+	-0.209164f,
+	0.977378f,
+	0.0313447f,
+	-0.33727f,
+	0.941399f,
+	0.00405643f,
+	-0.445763f,
+	0.895148f,
+	-0.00236945f,
+	-0.379089f,
+	0.924127f,
+	0.0477591f,
+	-0.212534f,
+	0.958583f,
+	0.189598f,
+	-0.289703f,
+	0.944216f,
+	0.156615f,
+	-0.225857f,
+	0.954875f,
+	0.19288f,
+	-0.19812f,
+	0.968114f,
+	0.153308f,
+	-0.225491f,
+	0.970896f,
+	0.0807165f,
+	-0.268028f,
+	0.963292f,
+	-0.0151842f,
+	-0.386115f,
+	0.917249f,
+	-0.0978197f,
+	-0.332792f,
+	0.935954f,
+	-0.115065f,
+	-0.223332f,
+	0.957817f,
+	-0.180856f,
+	-0.272615f,
+	0.913397f,
+	-0.302304f,
+	-0.182015f,
+	0.92061f,
+	-0.345468f,
+	-0.156497f,
+	0.91949f,
+	-0.36062f,
+	-0.125465f,
+	0.931751f,
+	-0.340733f,
+	0.1054f,
+	0.935905f,
+	-0.336114f,
+	0.348771f,
+	0.906917f,
+	-0.236346f,
+	0.444797f,
+	0.880373f,
+	-0.164617f,
+	0.451025f,
+	0.885434f,
+	-0.112171f,
+	0.467976f,
+	0.880983f,
+	-0.0697667f,
+	0.499335f,
+	0.858868f,
+	-0.114062f,
+	0.349601f,
+	0.930335f,
+	-0.110707f,
+	0.307802f,
+	0.944888f,
+	-0.11156f,
+	0.473394f,
+	0.878106f,
+	0.0694821f,
+	0.43441f,
+	0.869457f,
+	0.23523f,
+	0.41901f,
+	0.855868f,
+	0.303184f,
+	0.452664f,
+	0.775597f,
+	0.439937f,
+	0.432369f,
+	0.72522f,
+	0.535829f,
+	0.415514f,
+	0.737038f,
+	0.533032f,
+	0.381011f,
+	0.793693f,
+	0.474217f,
+	0.445314f,
+	0.773558f,
+	0.450892f,
+	0.520117f,
+	0.767192f,
+	0.375359f,
+	0.457464f,
+	0.838846f,
+	0.295064f,
+	0.276432f,
+	0.924946f,
+	0.260884f,
+	0.199394f,
+	0.937964f,
+	0.283664f,
+	0.190897f,
+	0.927436f,
+	0.32159f,
+	-0.0705492f,
+	0.959049f,
+	0.274315f,
+	-0.0655623f,
+	0.961527f,
+	0.266772f,
+	-0.0518964f,
+	0.943387f,
+	0.32761f,
+	-0.202287f,
+	0.906319f,
+	0.371032f,
+	-0.245861f,
+	0.842829f,
+	0.478739f,
+	-0.310342f,
+	0.836362f,
+	0.451869f,
+	-0.256381f,
+	0.850522f,
+	0.459219f,
+	-0.198762f,
+	0.867072f,
+	0.456815f,
+	-0.12379f,
+	0.863897f,
+	0.48822f,
+	-0.0469651f,
+	0.900623f,
+	0.432056f,
+	-8.11553e-005f,
+	0.943721f,
+	0.330744f,
+	0.129628f,
+	0.925055f,
+	0.357028f,
+	0.0340614f,
+	0.966037f,
+	0.256151f,
+	-0.0890995f,
+	0.983963f,
+	0.154524f,
+	-0.0322587f,
+	0.981394f,
+	0.189278f,
+	0.138447f,
+	0.956229f,
+	0.257794f,
+	0.317932f,
+	0.883665f,
+	0.343592f,
+	0.154174f,
+	0.859961f,
+	0.486516f,
+	-0.0823702f,
+	0.837125f,
+	0.540774f,
+	0.067942f,
+	0.838652f,
+	0.540413f,
+	0.256779f,
+	0.806501f,
+	0.532561f,
+	0.317316f,
+	0.771073f,
+	0.552047f,
+	0.228943f,
+	0.837474f,
+	0.496208f,
+	0.221417f,
+	0.908583f,
+	0.354192f,
+	0.0661321f,
+	0.986936f,
+	0.146917f,
+	-0.101631f,
+	0.981129f,
+	0.164493f,
+	-0.140334f,
+	0.967949f,
+	0.20828f,
+	-0.26644f,
+	0.954208f,
+	0.136f,
+	-0.376833f,
+	0.92539f,
+	0.0406146f,
+	-0.423125f,
+	0.902479f,
+	-0.0805992f,
+	-0.378547f,
+	0.924929f,
+	-0.0347556f,
+	-0.294214f,
+	0.950388f,
+	0.101004f,
+	-0.253707f,
+	0.966868f,
+	0.0282789f,
+	-0.1425f,
+	0.989661f,
+	0.0162607f,
+	-0.152778f,
+	0.987285f,
+	-0.0438961f,
+	-0.226417f,
+	0.971142f,
+	-0.0749508f,
+	-0.278106f,
+	0.959626f,
+	-0.0421373f,
+	-0.315252f,
+	0.936348f,
+	-0.154492f,
+	-0.13807f,
+	0.983353f,
+	-0.118124f,
+	-0.169891f,
+	0.968928f,
+	-0.179762f,
+	-0.200272f,
+	0.947942f,
+	-0.247583f,
+	-0.182846f,
+	0.93983f,
+	-0.288594f,
+	-0.0836086f,
+	0.941177f,
+	-0.327408f,
+	0.0732417f,
+	0.918516f,
+	-0.388542f,
+	0.208177f,
+	0.929929f,
+	-0.303139f,
+	0.350352f,
+	0.926406f,
+	-0.137933f,
+	0.401951f,
+	0.914196f,
+	-0.0517823f,
+	0.448456f,
+	0.893661f,
+	-0.0160636f,
+	0.515556f,
+	0.856358f,
+	0.0291996f,
+	0.347689f,
+	0.937245f,
+	0.0261378f,
+	0.255909f,
+	0.965329f,
+	0.0514824f,
+	0.382053f,
+	0.909938f,
+	0.161395f,
+	0.340926f,
+	0.922929f,
+	0.178808f,
+	0.312845f,
+	0.910786f,
+	0.269439f,
+	0.364196f,
+	0.849776f,
+	0.381106f,
+	0.45928f,
+	0.814969f,
+	0.353394f,
+	0.52951f,
+	0.800019f,
+	0.282116f,
+	0.449914f,
+	0.855375f,
+	0.256731f,
+	0.454599f,
+	0.838858f,
+	0.299428f,
+	0.555327f,
+	0.766362f,
+	0.322957f,
+	0.54417f,
+	0.781393f,
+	0.305455f,
+	0.357615f,
+	0.911759f,
+	0.202005f,
+	0.139813f,
+	0.972952f,
+	0.183891f,
+	0.109083f,
+	0.950848f,
+	0.289808f,
+	-0.192892f,
+	0.944314f,
+	0.266579f,
+	-0.117537f,
+	0.919218f,
+	0.375796f,
+	-0.132138f,
+	0.875254f,
+	0.465263f,
+	-0.253971f,
+	0.812679f,
+	0.524453f,
+	-0.263136f,
+	0.777105f,
+	0.571723f,
+	-0.18663f,
+	0.797568f,
+	0.573633f,
+	-0.239071f,
+	0.855961f,
+	0.458449f,
+	-0.228946f,
+	0.872463f,
+	0.431732f,
+	-0.154745f,
+	0.876861f,
+	0.455159f,
+	0.0511929f,
+	0.876307f,
+	0.479025f,
+	0.079622f,
+	0.902874f,
+	0.422468f,
+	0.0999946f,
+	0.903351f,
+	0.417083f,
+	0.103272f,
+	0.908778f,
+	0.404299f,
+	-0.0300958f,
+	0.943633f,
+	0.329622f,
+	-0.0276233f,
+	0.954592f,
+	0.296632f,
+	0.0865379f,
+	0.944508f,
+	0.316884f,
+	0.19572f,
+	0.915809f,
+	0.350694f,
+	0.0629871f,
+	0.902785f,
+	0.425456f,
+	-0.0973105f,
+	0.893058f,
+	0.439293f,
+	0.0850344f,
+	0.884912f,
+	0.45793f,
+	0.226219f,
+	0.859273f,
+	0.458775f,
+	0.265876f,
+	0.822998f,
+	0.50198f,
+	0.299522f,
+	0.800365f,
+	0.519329f,
+	0.365936f,
+	0.804413f,
+	0.467986f,
+	0.167843f,
+	0.908094f,
+	0.383659f,
+	-0.151292f,
+	0.923022f,
+	0.353753f,
+	-0.16349f,
+	0.897488f,
+	0.409618f,
+	-0.164454f,
+	0.89713f,
+	0.410016f,
+	-0.256833f,
+	0.931773f,
+	0.256583f,
+	-0.308509f,
+	0.944441f,
+	0.11337f,
+	-0.397192f,
+	0.916896f,
+	-0.0392391f,
+	-0.321804f,
+	0.945652f,
+	-0.046751f,
+	-0.145617f,
+	0.989197f,
+	-0.0168656f,
+	-0.117605f,
+	0.989571f,
+	-0.083174f,
+	-0.131213f,
+	0.988938f,
+	-0.0691672f,
+	-0.264465f,
+	0.964357f,
+	-0.00857016f,
+	-0.279285f,
+	0.95849f,
+	0.0574115f,
+	-0.308064f,
+	0.950873f,
+	-0.0306128f,
+	-0.232189f,
+	0.97071f,
+	0.0617333f,
+	-0.126956f,
+	0.977263f,
+	0.169823f,
+	-0.134913f,
+	0.981643f,
+	0.134817f,
+	-0.0643092f,
+	0.996192f,
+	0.0588766f,
+	-0.0179518f,
+	0.989177f,
+	-0.145623f,
+	0.100718f,
+	0.978365f,
+	-0.180716f,
+	0.107842f,
+	0.981772f,
+	-0.156502f,
+	0.235537f,
+	0.96668f,
+	-0.100264f,
+	0.400696f,
+	0.915349f,
+	-0.0397433f,
+	0.382123f,
+	0.921514f,
+	-0.0692327f,
+	0.451191f,
+	0.890657f,
+	0.0561954f,
+	0.368356f,
+	0.915308f,
+	0.162865f,
+	0.16123f,
+	0.974745f,
+	0.154523f,
+	0.326647f,
+	0.914341f,
+	0.239337f,
+	0.365189f,
+	0.91282f,
+	0.182749f,
+	0.230086f,
+	0.959458f,
+	0.162792f,
+	0.336546f,
+	0.918886f,
+	0.205876f,
+	0.545838f,
+	0.824177f,
+	0.150977f,
+	0.544526f,
+	0.829407f,
+	0.124801f,
+	0.442013f,
+	0.862414f,
+	0.24671f,
+	0.417167f,
+	0.87901f,
+	0.230894f,
+	0.525918f,
+	0.823184f,
+	0.213956f,
+	0.591278f,
+	0.763502f,
+	0.259719f,
+	0.412761f,
+	0.877728f,
+	0.243355f,
+	0.079495f,
+	0.961838f,
+	0.261818f,
+	-0.108191f,
+	0.959339f,
+	0.260698f,
+	-0.395968f,
+	0.898347f,
+	0.190215f,
+	-0.315805f,
+	0.885393f,
+	0.341095f,
+	-0.255081f,
+	0.831656f,
+	0.493236f,
+	-0.32798f,
+	0.786298f,
+	0.523607f,
+	-0.31899f,
+	0.766541f,
+	0.557369f,
+	-0.160414f,
+	0.763167f,
+	0.625974f,
+	-0.0711111f,
+	0.771377f,
+	0.632393f,
+	-0.143173f,
+	0.825852f,
+	0.545409f,
+	-0.172278f,
+	0.854223f,
+	0.490534f,
+	0.0123154f,
+	0.838365f,
+	0.544971f,
+	0.0830743f,
+	0.830631f,
+	0.550592f,
+	0.0507686f,
+	0.835031f,
+	0.547855f,
+	0.149519f,
+	0.800804f,
+	0.579962f,
+	0.0893025f,
+	0.847618f,
+	0.523038f,
+	-0.0238205f,
+	0.893087f,
+	0.449253f,
+	0.0209713f,
+	0.900623f,
+	0.434095f,
+	0.182588f,
+	0.867377f,
+	0.462945f,
+	0.0933756f,
+	0.88802f,
+	0.450223f,
+	-0.0988317f,
+	0.917919f,
+	0.384262f,
+	0.0323919f,
+	0.922001f,
+	0.38583f,
+	0.205498f,
+	0.882674f,
+	0.422678f,
+	0.228981f,
+	0.875897f,
+	0.424702f,
+	0.330967f,
+	0.833446f,
+	0.442526f,
+	0.386545f,
+	0.82285f,
+	0.416534f,
+	0.244254f,
+	0.85459f,
+	0.458275f,
+	-0.128515f,
+	0.915454f,
+	0.381351f,
+	-0.221592f,
+	0.919582f,
+	0.324447f,
+	-0.103305f,
+	0.941351f,
+	0.321226f,
+	-0.0534104f,
+	0.960954f,
+	0.271504f,
+	-0.164863f,
+	0.980806f,
+	0.104112f,
+	-0.239884f,
+	0.970598f,
+	-0.0198681f,
+	-0.303213f,
+	0.937604f,
+	-0.170178f,
+	-0.252015f,
+	0.951441f,
+	-0.176773f,
+	-0.108694f,
+	0.994072f,
+	0.00232095f,
+	-0.192935f,
+	0.981013f,
+	0.0197642f,
+	-0.322908f,
+	0.946132f,
+	0.0237552f,
+	-0.269028f,
+	0.963107f,
+	-0.00704542f,
+	-0.230013f,
+	0.973161f,
+	0.00722315f,
+	-0.357365f,
+	0.933662f,
+	-0.0237822f,
+	-0.204315f,
+	0.973479f,
+	0.102922f,
+	-0.115797f,
+	0.983778f,
+	0.137007f,
+	0.0200406f,
+	0.991033f,
+	0.132107f,
+	0.176509f,
+	0.981212f,
+	0.0778953f,
+	0.102914f,
+	0.991977f,
+	-0.0734239f,
+	0.103634f,
+	0.990563f,
+	-0.0896973f,
+	0.246302f,
+	0.962545f,
+	-0.113327f,
+	0.365449f,
+	0.921945f,
+	-0.12831f,
+	0.388572f,
+	0.919102f,
+	-0.0652967f,
+	0.33675f,
+	0.940592f,
+	-0.0434361f,
+	0.294334f,
+	0.951251f,
+	0.0921318f,
+	0.170376f,
+	0.973956f,
+	0.149605f,
+	0.291052f,
+	0.946977f,
+	0.136102f,
+	0.448607f,
+	0.879963f,
+	0.156258f,
+	0.275208f,
+	0.960522f,
+	0.0407201f,
+	0.320727f,
+	0.94717f,
+	-0.00171267f,
+	0.563867f,
+	0.822582f,
+	0.0735748f,
+	0.458264f,
+	0.882692f,
+	0.104155f,
+	0.35932f,
+	0.917336f,
+	0.171414f,
+	0.473577f,
+	0.85831f,
+	0.197555f,
+	0.552768f,
+	0.818756f,
+	0.155195f,
+	0.56022f,
+	0.811568f,
+	0.165865f,
+	0.410483f,
+	0.877955f,
+	0.246373f,
+	0.119318f,
+	0.965792f,
+	0.230239f,
+	-0.0302464f,
+	0.98755f,
+	0.15437f,
+	-0.434902f,
+	0.821345f,
+	0.369123f,
+	-0.425801f,
+	0.804682f,
+	0.41374f,
+	-0.330648f,
+	0.807018f,
+	0.489278f,
+	-0.341863f,
+	0.793213f,
+	0.503928f,
+	-0.356504f,
+	0.786512f,
+	0.504286f,
+	-0.269874f,
+	0.813284f,
+	0.515498f,
+	-0.0937663f,
+	0.786137f,
+	0.610898f,
+	-0.0122488f,
+	0.782782f,
+	0.622176f,
+	-0.145176f,
+	0.838097f,
+	0.525849f,
+	-0.0659853f,
+	0.863648f,
+	0.499758f,
+	0.0911511f,
+	0.81559f,
+	0.571406f,
+	0.0567409f,
+	0.801208f,
+	0.59569f,
+	0.110855f,
+	0.801019f,
+	0.588286f,
+	0.153854f,
+	0.799367f,
+	0.580811f,
+	0.0810561f,
+	0.837494f,
+	0.540401f,
+	0.0627084f,
+	0.873537f,
+	0.482702f,
+	0.153028f,
+	0.87118f,
+	0.466506f,
+	0.121758f,
+	0.869515f,
+	0.478663f,
+	-0.0139367f,
+	0.889364f,
+	0.456987f,
+	0.0116753f,
+	0.909652f,
+	0.415206f,
+	0.182976f,
+	0.873078f,
+	0.451946f,
+	0.230254f,
+	0.874104f,
+	0.427698f,
+	0.299542f,
+	0.853577f,
+	0.42624f,
+	0.365816f,
+	0.815944f,
+	0.447677f,
+	0.258135f,
+	0.828321f,
+	0.497243f,
+	0.0438733f,
+	0.899999f,
+	0.433678f,
+	-0.113551f,
+	0.976415f,
+	0.183628f,
+	-0.115165f,
+	0.991964f,
+	0.0523877f,
+	-0.0427249f,
+	0.989973f,
+	0.134639f,
+	-0.000526251f,
+	0.987641f,
+	0.156735f,
+	-0.182878f,
+	0.982656f,
+	-0.0306907f,
+	-0.187196f,
+	0.982029f,
+	-0.0240342f,
+	-0.272847f,
+	0.956238f,
+	-0.105656f,
+	-0.292658f,
+	0.95046f,
+	-0.104775f,
+	-0.178909f,
+	0.983865f,
+	0.00116467f,
+	-0.22078f,
+	0.973898f,
+	-0.0527095f,
+	-0.269354f,
+	0.950491f,
+	-0.154966f,
+	-0.262457f,
+	0.956005f,
+	-0.131038f,
+	-0.333574f,
+	0.929233f,
+	-0.158915f,
+	-0.27846f,
+	0.93913f,
+	-0.201231f,
+	-0.105722f,
+	0.98028f,
+	-0.166954f,
+	-0.03086f,
+	0.983393f,
+	-0.178845f,
+	0.166296f,
+	0.985117f,
+	-0.0434662f,
+	0.22991f,
+	0.973119f,
+	0.0134671f,
+	0.156605f,
+	0.983722f,
+	-0.0881293f,
+	0.276714f,
+	0.94824f,
+	-0.155787f,
+	0.32696f,
+	0.929339f,
+	-0.171541f,
+	0.339039f,
+	0.938238f,
+	-0.0690071f,
+	0.308789f,
+	0.948131f,
+	-0.0754727f,
+	0.23717f,
+	0.967343f,
+	-0.0894326f,
+	0.163558f,
+	0.982662f,
+	-0.0873214f,
+	0.252735f,
+	0.966333f,
+	-0.0482272f,
+	0.434287f,
+	0.896865f,
+	0.0838305f,
+	0.398093f,
+	0.912104f,
+	0.0979158f,
+	0.320154f,
+	0.94669f,
+	-0.0357668f,
+	0.45783f,
+	0.889003f,
+	0.00810452f,
+	0.504235f,
+	0.85135f,
+	0.144742f,
+	0.385352f,
+	0.920157f,
+	0.0693918f,
+	0.466232f,
+	0.882239f,
+	0.0654287f,
+	0.538345f,
+	0.833943f,
+	0.121343f,
+	0.517827f,
+	0.838051f,
+	0.171829f,
+	0.46128f,
+	0.862173f,
+	0.209471f,
+	0.229103f,
+	0.969676f,
+	0.085091f,
+	0.119821f,
+	0.992172f,
+	0.0351865f,
+	-0.316654f,
+	0.75101f,
+	0.579409f,
+	-0.356062f,
+	0.779142f,
+	0.515904f,
+	-0.357471f,
+	0.814286f,
+	0.457331f,
+	-0.357809f,
+	0.798452f,
+	0.484198f,
+	-0.344344f,
+	0.806376f,
+	0.480818f,
+	-0.279175f,
+	0.813317f,
+	0.510467f,
+	-0.188283f,
+	0.817533f,
+	0.544233f,
+	0.0108927f,
+	0.825394f,
+	0.564451f,
+	0.000505664f,
+	0.854739f,
+	0.519058f,
+	-0.0291193f,
+	0.899152f,
+	0.436667f,
+	-0.043893f,
+	0.902469f,
+	0.428513f,
+	-0.00142614f,
+	0.854428f,
+	0.519568f,
+	0.10644f,
+	0.82426f,
+	0.556117f,
+	0.17821f,
+	0.772022f,
+	0.610101f,
+	0.155558f,
+	0.792656f,
+	0.58949f,
+	0.103298f,
+	0.851042f,
+	0.514837f,
+	0.136998f,
+	0.86222f,
+	0.487656f,
+	0.128814f,
+	0.846529f,
+	0.516522f,
+	0.0086465f,
+	0.861582f,
+	0.507544f,
+	0.0126115f,
+	0.865086f,
+	0.501464f,
+	0.152876f,
+	0.854998f,
+	0.495588f,
+	0.261992f,
+	0.846686f,
+	0.463122f,
+	0.298132f,
+	0.855648f,
+	0.423065f,
+	0.330245f,
+	0.846388f,
+	0.417811f,
+	0.241868f,
+	0.85891f,
+	0.451412f,
+	0.243399f,
+	0.870337f,
+	0.428102f,
+	0.218863f,
+	0.950296f,
+	0.221442f,
+	-0.0230145f,
+	0.994562f,
+	-0.101567f,
+	-0.18143f,
+	0.968994f,
+	-0.167732f,
+	-0.00536077f,
+	0.999859f,
+	-0.0158957f,
+	-0.0149312f,
+	0.999841f,
+	-0.00972481f,
+	-0.248945f,
+	0.961384f,
+	-0.11733f,
+	-0.206226f,
+	0.978121f,
+	-0.0273758f,
+	-0.251569f,
+	0.958037f,
+	-0.137399f,
+	-0.215501f,
+	0.957565f,
+	-0.191386f,
+	-0.183194f,
+	0.972176f,
+	-0.145991f,
+	-0.242363f,
+	0.956164f,
+	-0.164351f,
+	-0.223675f,
+	0.959477f,
+	-0.171387f,
+	-0.263678f,
+	0.929229f,
+	-0.25886f,
+	-0.190809f,
+	0.923444f,
+	-0.332932f,
+	-0.125476f,
+	0.902264f,
+	-0.412524f,
+	-0.0800599f,
+	0.931052f,
+	-0.355994f,
+	0.00289679f,
+	0.952892f,
+	-0.303297f,
+	0.173027f,
+	0.965415f,
+	-0.195025f,
+	0.23552f,
+	0.951626f,
+	-0.197328f,
+	0.324166f,
+	0.90746f,
+	-0.26727f,
+	0.272213f,
+	0.920502f,
+	-0.280314f,
+	0.263103f,
+	0.942676f,
+	-0.205278f,
+	0.331376f,
+	0.931643f,
+	-0.1491f,
+	0.273621f,
+	0.957062f,
+	-0.0957296f,
+	0.174678f,
+	0.976512f,
+	-0.126141f,
+	0.162465f,
+	0.97193f,
+	-0.170168f,
+	0.285207f,
+	0.956722f,
+	-0.0577913f,
+	0.392887f,
+	0.912166f,
+	0.116586f,
+	0.413213f,
+	0.901715f,
+	0.127138f,
+	0.444428f,
+	0.894805f,
+	0.0425078f,
+	0.482399f,
+	0.875952f,
+	0.000225918f,
+	0.414394f,
+	0.908379f,
+	-0.0559034f,
+	0.421361f,
+	0.906852f,
+	-0.00856344f,
+	0.501069f,
+	0.86151f,
+	0.0820434f,
+	0.492896f,
+	0.86226f,
+	0.116453f,
+	0.497628f,
+	0.854344f,
+	0.149874f,
+	0.327901f,
+	0.939568f,
+	0.0984569f,
+	0.134608f,
+	0.990256f,
+	0.0356963f,
+	-0.115732f,
+	0.781457f,
+	0.613132f,
+	-0.224646f,
+	0.82464f,
+	0.519137f,
+	-0.330602f,
+	0.837584f,
+	0.434919f,
+	-0.37055f,
+	0.826801f,
+	0.423193f,
+	-0.389755f,
+	0.836631f,
+	0.38489f,
+	-0.35019f,
+	0.83732f,
+	0.419835f,
+	-0.192063f,
+	0.866433f,
+	0.460875f,
+	0.0577661f,
+	0.893053f,
+	0.446228f,
+	0.0715028f,
+	0.909685f,
+	0.409097f,
+	0.0355467f,
+	0.937027f,
+	0.347443f,
+	-0.0473295f,
+	0.949618f,
+	0.309815f,
+	-0.0714543f,
+	0.946618f,
+	0.31434f,
+	0.0109848f,
+	0.930588f,
+	0.365903f,
+	0.0306039f,
+	0.876434f,
+	0.480548f,
+	0.171338f,
+	0.790427f,
+	0.588106f,
+	0.228263f,
+	0.773415f,
+	0.591376f,
+	0.15062f,
+	0.839076f,
+	0.522748f,
+	0.0933237f,
+	0.852392f,
+	0.514508f,
+	0.0403687f,
+	0.864191f,
+	0.501542f,
+	0.0159293f,
+	0.89067f,
+	0.454371f,
+	0.162582f,
+	0.873944f,
+	0.458028f,
+	0.324998f,
+	0.838057f,
+	0.438219f,
+	0.361417f,
+	0.861814f,
+	0.355886f,
+	0.357364f,
+	0.88789f,
+	0.289727f,
+	0.288052f,
+	0.920034f,
+	0.265637f,
+	0.274707f,
+	0.932706f,
+	0.233657f,
+	0.415911f,
+	0.867317f,
+	0.273456f,
+	0.214502f,
+	0.965967f,
+	0.144559f,
+	-0.0739208f,
+	0.997262f,
+	-0.00212715f,
+	-0.130316f,
+	0.972201f,
+	-0.194533f,
+	0.00262571f,
+	0.981048f,
+	-0.193747f,
+	-0.190851f,
+	0.93935f,
+	-0.284951f,
+	-0.250649f,
+	0.92646f,
+	-0.280798f,
+	-0.16238f,
+	0.957944f,
+	-0.236595f,
+	-0.204897f,
+	0.9457f,
+	-0.252327f,
+	-0.246487f,
+	0.945291f,
+	-0.213705f,
+	-0.204741f,
+	0.966747f,
+	-0.153234f,
+	-0.173965f,
+	0.952924f,
+	-0.248341f,
+	-0.185492f,
+	0.924696f,
+	-0.332461f,
+	-0.120486f,
+	0.929748f,
+	-0.347926f,
+	-0.0981061f,
+	0.932335f,
+	-0.348033f,
+	-0.143961f,
+	0.923839f,
+	-0.354678f,
+	-0.0348514f,
+	0.936175f,
+	-0.349804f,
+	0.141193f,
+	0.941481f,
+	-0.306069f,
+	0.298926f,
+	0.908144f,
+	-0.293117f,
+	0.339558f,
+	0.869399f,
+	-0.35895f,
+	0.236934f,
+	0.893673f,
+	-0.381064f,
+	0.188986f,
+	0.916304f,
+	-0.353088f,
+	0.222126f,
+	0.937284f,
+	-0.268624f,
+	0.165461f,
+	0.966952f,
+	-0.193976f,
+	0.194618f,
+	0.975642f,
+	-0.101229f,
+	0.225585f,
+	0.970105f,
+	-0.0894815f,
+	0.18757f,
+	0.970367f,
+	-0.152331f,
+	0.271776f,
+	0.9587f,
+	-0.0838549f,
+	0.390134f,
+	0.920749f,
+	0.00399703f,
+	0.487191f,
+	0.870564f,
+	0.0690114f,
+	0.567845f,
+	0.821826f,
+	0.0464111f,
+	0.430596f,
+	0.898843f,
+	-0.0816633f,
+	0.345462f,
+	0.936301f,
+	-0.063213f,
+	0.439054f,
+	0.898457f,
+	0.0025505f,
+	0.485886f,
+	0.873093f,
+	0.040301f,
+	0.468523f,
+	0.882438f,
+	0.0422951f,
+	0.395695f,
+	0.916215f,
+	0.0630502f,
+	0.224264f,
+	0.974198f,
+	-0.0253916f,
+	-0.04074f,
+	0.869731f,
+	0.491842f,
+	-0.147521f,
+	0.861626f,
+	0.485632f,
+	-0.290306f,
+	0.828918f,
+	0.47814f,
+	-0.344291f,
+	0.81826f,
+	0.460342f,
+	-0.325822f,
+	0.848235f,
+	0.417537f,
+	-0.347006f,
+	0.892025f,
+	0.289618f,
+	-0.23289f,
+	0.9484f,
+	0.215175f,
+	0.0826503f,
+	0.953848f,
+	0.288692f,
+	0.0849803f,
+	0.942357f,
+	0.323639f,
+	0.0946367f,
+	0.912864f,
+	0.397143f,
+	0.0188563f,
+	0.944615f,
+	0.327637f,
+	-0.0844647f,
+	0.976435f,
+	0.198596f,
+	-0.0480441f,
+	0.982086f,
+	0.182207f,
+	-0.108246f,
+	0.969423f,
+	0.220233f,
+	0.0163534f,
+	0.944153f,
+	0.329102f,
+	0.218936f,
+	0.864112f,
+	0.453186f,
+	0.243602f,
+	0.846524f,
+	0.473344f,
+	0.157715f,
+	0.898021f,
+	0.410713f,
+	0.124101f,
+	0.930824f,
+	0.343753f,
+	0.0887369f,
+	0.958556f,
+	0.270731f,
+	0.13199f,
+	0.965856f,
+	0.222935f,
+	0.34996f,
+	0.900513f,
+	0.258077f,
+	0.45204f,
+	0.856515f,
+	0.249081f,
+	0.434574f,
+	0.879659f,
+	0.19325f,
+	0.307812f,
+	0.936972f,
+	0.165332f,
+	0.238408f,
+	0.942387f,
+	0.234669f,
+	0.292411f,
+	0.883524f,
+	0.365897f,
+	0.235944f,
+	0.851222f,
+	0.468777f,
+	0.0834983f,
+	0.888208f,
+	0.45179f,
+	0.120252f,
+	0.948234f,
+	0.293925f,
+	0.107426f,
+	0.988487f,
+	0.106553f,
+	-0.0604958f,
+	0.997925f,
+	0.0220282f,
+	-0.22861f,
+	0.965114f,
+	-0.127644f,
+	-0.213845f,
+	0.934088f,
+	-0.285919f,
+	-0.236679f,
+	0.925441f,
+	-0.295876f,
+	-0.274282f,
+	0.922231f,
+	-0.272506f,
+	-0.200442f,
+	0.934584f,
+	-0.293896f,
+	-0.0905439f,
+	0.955043f,
+	-0.282301f,
+	-0.107977f,
+	0.974204f,
+	-0.198159f,
+	-0.176859f,
+	0.954188f,
+	-0.241343f,
+	-0.109412f,
+	0.961464f,
+	-0.252221f,
+	-0.0832631f,
+	0.934053f,
+	-0.347292f,
+	-0.0389646f,
+	0.894623f,
+	-0.44512f,
+	0.0844722f,
+	0.90285f,
+	-0.421576f,
+	0.278944f,
+	0.884527f,
+	-0.373902f,
+	0.405411f,
+	0.845478f,
+	-0.347577f,
+	0.241979f,
+	0.880406f,
+	-0.407837f,
+	0.10107f,
+	0.917999f,
+	-0.383487f,
+	0.153454f,
+	0.950374f,
+	-0.270631f,
+	0.150056f,
+	0.964994f,
+	-0.215103f,
+	0.116981f,
+	0.964373f,
+	-0.237277f,
+	0.171185f,
+	0.966068f,
+	-0.19341f,
+	0.269303f,
+	0.954896f,
+	-0.1251f,
+	0.246577f,
+	0.939836f,
+	-0.236448f,
+	0.325998f,
+	0.915178f,
+	-0.237011f,
+	0.400262f,
+	0.89707f,
+	-0.18723f,
+	0.540095f,
+	0.838463f,
+	-0.0726465f,
+	0.4591f,
+	0.888384f,
+	0.000734802f,
+	0.350121f,
+	0.936701f,
+	0.00262749f,
+	0.415959f,
+	0.907987f,
+	-0.0503785f,
+	0.469999f,
+	0.882626f,
+	-0.00849165f,
+	0.46759f,
+	0.883776f,
+	0.0172864f,
+	0.444948f,
+	0.895095f,
+	0.0287648f,
+	0.38429f,
+	0.923043f,
+	-0.0176926f,
+	-0.184131f,
+	0.893945f,
+	0.408605f,
+	-0.22256f,
+	0.84592f,
+	0.484651f,
+	-0.306803f,
+	0.799127f,
+	0.516979f,
+	-0.327467f,
+	0.825975f,
+	0.458836f,
+	-0.215523f,
+	0.873324f,
+	0.43687f,
+	-0.122358f,
+	0.93676f,
+	0.327886f,
+	-0.214245f,
+	0.969738f,
+	0.117081f,
+	0.00165628f,
+	0.984816f,
+	0.173596f,
+	-0.0471807f,
+	0.97232f,
+	0.228838f,
+	-0.042786f,
+	0.929182f,
+	0.367137f,
+	0.159108f,
+	0.885534f,
+	0.43648f,
+	0.0848362f,
+	0.945025f,
+	0.315803f,
+	-0.0323525f,
+	0.969808f,
+	0.241716f,
+	-0.0998895f,
+	0.964402f,
+	0.244849f,
+	-0.0727123f,
+	0.986494f,
+	0.146772f,
+	0.121392f,
+	0.97688f,
+	0.175982f,
+	0.260802f,
+	0.928486f,
+	0.264378f,
+	0.24004f,
+	0.922405f,
+	0.302572f,
+	0.162896f,
+	0.94112f,
+	0.296239f,
+	0.158069f,
+	0.936377f,
+	0.313389f,
+	0.18876f,
+	0.956613f,
+	0.221947f,
+	0.312407f,
+	0.939867f,
+	0.138025f,
+	0.450948f,
+	0.870255f,
+	0.198248f,
+	0.44762f,
+	0.863366f,
+	0.232885f,
+	0.235953f,
+	0.935784f,
+	0.261983f,
+	0.128819f,
+	0.928252f,
+	0.348933f,
+	0.106701f,
+	0.927182f,
+	0.359094f,
+	0.172918f,
+	0.882203f,
+	0.437968f,
+	0.183128f,
+	0.868984f,
+	0.459707f,
+	0.240959f,
+	0.881259f,
+	0.406597f,
+	0.154256f,
+	0.918617f,
+	0.363797f,
+	0.0253035f,
+	0.919137f,
+	0.393124f,
+	0.0182377f,
+	0.964511f,
+	0.263413f,
+	0.0263571f,
+	0.99964f,
+	0.00499089f,
+	-0.149002f,
+	0.961331f,
+	-0.231604f,
+	-0.264821f,
+	0.912849f,
+	-0.310769f,
+	-0.139498f,
+	0.954507f,
+	-0.263548f,
+	-0.253683f,
+	0.93262f,
+	-0.25664f,
+	-0.265231f,
+	0.9626f,
+	-0.0552561f,
+	-0.114883f,
+	0.993341f,
+	-0.00868247f,
+	0.0072742f,
+	0.99351f,
+	-0.113513f,
+	0.112563f,
+	0.957036f,
+	-0.26723f,
+	0.0621414f,
+	0.905176f,
+	-0.420469f,
+	0.0722297f,
+	0.880288f,
+	-0.468909f,
+	0.230329f,
+	0.856327f,
+	-0.462225f,
+	0.381575f,
+	0.843927f,
+	-0.377079f,
+	0.221134f,
+	0.891315f,
+	-0.395799f,
+	0.0308171f,
+	0.923698f,
+	-0.381879f,
+	0.0400222f,
+	0.939112f,
+	-0.341272f,
+	0.100477f,
+	0.950816f,
+	-0.293006f,
+	0.177047f,
+	0.942783f,
+	-0.282515f,
+	0.133298f,
+	0.926135f,
+	-0.352852f,
+	0.196525f,
+	0.937661f,
+	-0.286653f,
+	0.349249f,
+	0.920399f,
+	-0.17576f,
+	0.344233f,
+	0.909171f,
+	-0.234334f,
+	0.376056f,
+	0.891226f,
+	-0.25357f,
+	0.439076f,
+	0.869021f,
+	-0.228069f,
+	0.419906f,
+	0.900431f,
+	-0.113589f,
+	0.367672f,
+	0.919513f,
+	-0.13897f,
+	0.413581f,
+	0.894358f,
+	-0.170514f,
+	0.417856f,
+	0.905717f,
+	-0.0712231f,
+	0.442627f,
+	0.896671f,
+	0.00788109f,
+	0.434719f,
+	0.900071f,
+	0.0298519f,
+	0.417993f,
+	0.908131f,
+	0.0240916f,
+	-0.312333f,
+	0.839022f,
+	0.445522f,
+	-0.320499f,
+	0.80841f,
+	0.493714f,
+	-0.254519f,
+	0.811123f,
+	0.526593f,
+	-0.204612f,
+	0.85744f,
+	0.472156f,
+	-0.178862f,
+	0.910868f,
+	0.371925f,
+	-0.00702334f,
+	0.926328f,
+	0.376653f,
+	-0.0708828f,
+	0.954444f,
+	0.289847f,
+	-0.0771525f,
+	0.977635f,
+	0.195648f,
+	-0.0751036f,
+	0.961343f,
+	0.264914f,
+	-0.145577f,
+	0.95681f,
+	0.25164f,
+	0.127391f,
+	0.9356f,
+	0.329278f,
+	0.155803f,
+	0.922417f,
+	0.353372f,
+	-0.0158909f,
+	0.953782f,
+	0.300078f,
+	-0.071615f,
+	0.974742f,
+	0.211541f,
+	0.0985463f,
+	0.976728f,
+	0.190504f,
+	0.112633f,
+	0.991267f,
+	0.0685771f,
+	0.169574f,
+	0.979892f,
+	0.105153f,
+	0.189025f,
+	0.96308f,
+	0.191696f,
+	0.0919285f,
+	0.967342f,
+	0.236218f,
+	0.12853f,
+	0.953507f,
+	0.272588f,
+	0.291986f,
+	0.918653f,
+	0.266123f,
+	0.353363f,
+	0.907675f,
+	0.226407f,
+	0.385555f,
+	0.89484f,
+	0.224962f,
+	0.404454f,
+	0.872627f,
+	0.273752f,
+	0.205311f,
+	0.929054f,
+	0.307743f,
+	0.110161f,
+	0.942272f,
+	0.316208f,
+	0.185964f,
+	0.923078f,
+	0.336668f,
+	0.152054f,
+	0.949861f,
+	0.273212f,
+	0.185461f,
+	0.938647f,
+	0.290768f,
+	0.273329f,
+	0.907935f,
+	0.317718f,
+	0.1744f,
+	0.944567f,
+	0.278169f,
+	0.0252708f,
+	0.979111f,
+	0.20175f,
+	0.168508f,
+	0.972599f,
+	0.160178f,
+	0.171022f,
+	0.978059f,
+	0.118964f,
+	0.0998107f,
+	0.989636f,
+	0.103241f,
+	-0.201522f,
+	0.966723f,
+	-0.157591f,
+	-0.270475f,
+	0.936595f,
+	-0.222784f,
+	-0.312657f,
+	0.944755f,
+	-0.0984088f,
+	-0.352005f,
+	0.934773f,
+	-0.0478632f,
+	-0.0861214f,
+	0.995901f,
+	-0.0276381f,
+	0.0987576f,
+	0.994369f,
+	-0.0384345f,
+	0.271502f,
+	0.95802f,
+	-0.0921061f,
+	0.198786f,
+	0.941001f,
+	-0.273863f,
+	0.12025f,
+	0.91375f,
+	-0.388073f,
+	0.19318f,
+	0.901312f,
+	-0.38771f,
+	0.347672f,
+	0.893681f,
+	-0.283653f,
+	0.243349f,
+	0.925421f,
+	-0.290477f,
+	0.0173943f,
+	0.947888f,
+	-0.318129f,
+	0.037959f,
+	0.944705f,
+	-0.325718f,
+	0.138906f,
+	0.919468f,
+	-0.36781f,
+	0.157447f,
+	0.882137f,
+	-0.443897f,
+	0.187757f,
+	0.895179f,
+	-0.404229f,
+	0.0607904f,
+	0.891083f,
+	-0.44975f,
+	0.186006f,
+	0.945946f,
+	-0.265685f,
+	0.365887f,
+	0.929282f,
+	-0.0506235f,
+	0.41897f,
+	0.907686f,
+	-0.0238758f,
+	0.421784f,
+	0.903427f,
+	-0.0769231f,
+	0.443234f,
+	0.894342f,
+	-0.0608035f,
+	0.410975f,
+	0.898831f,
+	-0.152323f,
+	0.386797f,
+	0.913648f,
+	-0.125039f,
+	0.291947f,
+	0.94823f,
+	-0.125004f,
+	0.388472f,
+	0.921139f,
+	-0.0243475f,
+	0.43729f,
+	0.89932f,
+	0.000909095f,
+	0.438439f,
+	0.898727f,
+	-0.00777216f,
+	-0.28789f,
+	0.841477f,
+	0.457204f,
+	-0.335895f,
+	0.843138f,
+	0.419871f,
+	-0.2812f,
+	0.876582f,
+	0.390553f,
+	-0.0955224f,
+	0.927302f,
+	0.361922f,
+	-0.12003f,
+	0.968207f,
+	0.219473f,
+	-0.0624603f,
+	0.972133f,
+	0.225956f,
+	0.00876105f,
+	0.944888f,
+	0.327276f,
+	-0.0188296f,
+	0.951986f,
+	0.305562f,
+	-0.0880524f,
+	0.955492f,
+	0.28157f,
+	-0.14211f,
+	0.96142f,
+	0.235533f,
+	0.0867118f,
+	0.963277f,
+	0.254122f,
+	0.135173f,
+	0.965034f,
+	0.224584f,
+	0.150393f,
+	0.96446f,
+	0.217252f,
+	0.0301773f,
+	0.99954f,
+	0.00289386f,
+	0.112215f,
+	0.991225f,
+	-0.0698593f,
+	0.139936f,
+	0.985559f,
+	-0.0953439f,
+	0.125274f,
+	0.991296f,
+	-0.0404889f,
+	0.130003f,
+	0.991461f,
+	0.0102436f,
+	0.104702f,
+	0.992835f,
+	0.0575904f,
+	0.129192f,
+	0.991077f,
+	0.0328109f,
+	0.258743f,
+	0.962487f,
+	0.0816753f,
+	0.358319f,
+	0.917773f,
+	0.171175f,
+	0.362543f,
+	0.919373f,
+	0.152698f,
+	0.379026f,
+	0.899795f,
+	0.216122f,
+	0.252574f,
+	0.930076f,
+	0.266767f,
+	0.106065f,
+	0.974915f,
+	0.195683f,
+	0.13953f,
+	0.968709f,
+	0.205267f,
+	0.207814f,
+	0.946678f,
+	0.246198f,
+	0.149976f,
+	0.969192f,
+	0.195383f,
+	0.250422f,
+	0.937237f,
+	0.242644f,
+	0.308573f,
+	0.924236f,
+	0.224878f,
+	0.137327f,
+	0.986571f,
+	0.0884273f,
+	0.176869f,
+	0.981357f,
+	0.0752039f,
+	0.106914f,
+	0.989761f,
+	0.0945676f,
+	0.0990876f,
+	0.985862f,
+	0.135123f,
+	0.0562231f,
+	0.995571f,
+	0.0753513f,
+	-0.246892f,
+	0.957072f,
+	-0.15185f,
+	-0.351837f,
+	0.92065f,
+	-0.169157f,
+	-0.377614f,
+	0.902561f,
+	-0.206862f,
+	-0.10132f,
+	0.980362f,
+	-0.169188f,
+	0.0776454f,
+	0.98254f,
+	-0.169077f,
+	0.306304f,
+	0.93954f,
+	-0.153108f,
+	0.377181f,
+	0.900422f,
+	-0.216738f,
+	0.189257f,
+	0.917577f,
+	-0.349621f,
+	0.154953f,
+	0.928643f,
+	-0.337063f,
+	0.267717f,
+	0.911458f,
+	-0.312367f,
+	0.294676f,
+	0.908518f,
+	-0.296244f,
+	0.0231864f,
+	0.917435f,
+	-0.39721f,
+	0.0626224f,
+	0.928776f,
+	-0.365314f,
+	0.222796f,
+	0.906686f,
+	-0.358165f,
+	0.23143f,
+	0.87959f,
+	-0.415646f,
+	0.13808f,
+	0.870415f,
+	-0.472559f,
+	0.025291f,
+	0.910796f,
+	-0.412081f,
+	-0.0453254f,
+	0.945277f,
+	-0.323104f,
+	0.159501f,
+	0.971914f,
+	-0.17304f,
+	0.38445f,
+	0.922508f,
+	-0.0343154f,
+	0.457445f,
+	0.889226f,
+	-0.00452937f,
+	0.479545f,
+	0.877417f,
+	-0.0132742f,
+	0.420093f,
+	0.902443f,
+	-0.0954967f,
+	0.386091f,
+	0.921349f,
+	-0.0452663f,
+	0.319162f,
+	0.945851f,
+	-0.059174f,
+	0.358596f,
+	0.930564f,
+	-0.0738904f,
+	0.442653f,
+	0.891593f,
+	-0.0955061f,
+	0.442432f,
+	0.88607f,
+	-0.138327f,
+	-0.180108f,
+	0.868506f,
+	0.461799f,
+	-0.252344f,
+	0.891893f,
+	0.375298f,
+	-0.214515f,
+	0.951228f,
+	0.221693f,
+	-0.0232238f,
+	0.989215f,
+	0.144618f,
+	0.0240637f,
+	0.992144f,
+	0.122761f,
+	-0.119024f,
+	0.992873f,
+	0.00598183f,
+	-0.113037f,
+	0.992656f,
+	0.0430988f,
+	-0.0429691f,
+	0.994091f,
+	0.0996822f,
+	-0.0494378f,
+	0.98881f,
+	0.140751f,
+	-0.101045f,
+	0.990831f,
+	0.0896877f,
+	0.0748729f,
+	0.995782f,
+	0.0530223f,
+	0.173588f,
+	0.976877f,
+	0.124814f,
+	0.168744f,
+	0.967443f,
+	0.188628f,
+	0.211654f,
+	0.955224f,
+	0.206761f,
+	0.198232f,
+	0.976689f,
+	0.0823528f,
+	0.160641f,
+	0.986993f,
+	-0.00630407f,
+	0.0575905f,
+	0.994633f,
+	-0.0859521f,
+	0.0365841f,
+	0.998447f,
+	-0.0420043f,
+	0.0556411f,
+	0.989086f,
+	0.136432f,
+	0.127974f,
+	0.973486f,
+	0.1896f,
+	0.188609f,
+	0.96964f,
+	0.155643f,
+	0.316079f,
+	0.935031f,
+	0.16066f,
+	0.368833f,
+	0.913789f,
+	0.170151f,
+	0.28567f,
+	0.933317f,
+	0.217512f,
+	0.224877f,
+	0.919424f,
+	0.322631f,
+	0.173372f,
+	0.927466f,
+	0.331284f,
+	0.14641f,
+	0.951279f,
+	0.271352f,
+	0.199618f,
+	0.950197f,
+	0.239328f,
+	0.194716f,
+	0.961761f,
+	0.192616f,
+	0.211001f,
+	0.970026f,
+	0.12053f,
+	0.377145f,
+	0.915922f,
+	0.137289f,
+	0.173279f,
+	0.983115f,
+	0.0588147f,
+	0.137169f,
+	0.986854f,
+	0.085457f,
+	0.167124f,
+	0.984519f,
+	0.0528309f,
+	0.114693f,
+	0.990538f,
+	-0.0753596f,
+	0.120988f,
+	0.991416f,
+	-0.0495523f,
+	-0.0934722f,
+	0.99234f,
+	-0.0807704f,
+	-0.28812f,
+	0.930265f,
+	-0.227141f,
+	-0.319246f,
+	0.884516f,
+	-0.340167f,
+	-0.147049f,
+	0.912977f,
+	-0.380591f,
+	0.113837f,
+	0.925954f,
+	-0.360071f,
+	0.286328f,
+	0.873071f,
+	-0.394668f,
+	0.386305f,
+	0.86841f,
+	-0.310857f,
+	0.201568f,
+	0.937185f,
+	-0.284702f,
+	0.165365f,
+	0.953527f,
+	-0.251875f,
+	0.277218f,
+	0.910704f,
+	-0.306215f,
+	0.350715f,
+	0.890932f,
+	-0.288511f,
+	0.130261f,
+	0.920935f,
+	-0.367302f,
+	-0.00793534f,
+	0.891743f,
+	-0.452472f,
+	0.173424f,
+	0.90309f,
+	-0.392878f,
+	0.309572f,
+	0.891597f,
+	-0.330484f,
+	0.155483f,
+	0.904383f,
+	-0.397387f,
+	-0.0901615f,
+	0.931774f,
+	-0.351664f,
+	-0.12522f,
+	0.950283f,
+	-0.285102f,
+	0.116309f,
+	0.952999f,
+	-0.279758f,
+	0.314059f,
+	0.900664f,
+	-0.300285f,
+	0.399484f,
+	0.884115f,
+	-0.242388f,
+	0.476487f,
+	0.865346f,
+	-0.155359f,
+	0.461331f,
+	0.87037f,
+	-0.172132f,
+	0.340659f,
+	0.915541f,
+	-0.213858f,
+	0.307988f,
+	0.934535f,
+	-0.178292f,
+	0.356904f,
+	0.924065f,
+	-0.136833f,
+	0.470016f,
+	0.879468f,
+	-0.0749671f,
+	0.505067f,
+	0.862447f,
+	-0.0330571f,
+	-0.15355f,
+	0.924768f,
+	0.348175f,
+	-0.09321f,
+	0.949622f,
+	0.299215f,
+	-0.0484808f,
+	0.991662f,
+	0.1194f,
+	-0.0103305f,
+	0.999605f,
+	0.0261285f,
+	0.0401188f,
+	0.998578f,
+	0.0351042f,
+	-0.00661539f,
+	0.998628f,
+	-0.0519471f,
+	-0.0683745f,
+	0.981776f,
+	-0.177318f,
+	-0.0856989f,
+	0.966825f,
+	-0.240633f,
+	-0.0983519f,
+	0.984458f,
+	-0.145499f,
+	-0.0680709f,
+	0.995572f,
+	-0.0648268f,
+	0.0777629f,
+	0.996246f,
+	-0.0380386f,
+	0.0383267f,
+	0.998901f,
+	-0.0269619f,
+	0.00333347f,
+	0.997094f,
+	0.0761077f,
+	0.139217f,
+	0.959624f,
+	0.244419f,
+	0.245721f,
+	0.912381f,
+	0.327386f,
+	0.246821f,
+	0.907772f,
+	0.339159f,
+	0.175417f,
+	0.940931f,
+	0.289617f,
+	-0.027159f,
+	0.9789f,
+	0.202525f,
+	-0.173424f,
+	0.953226f,
+	0.247557f,
+	0.0844967f,
+	0.921276f,
+	0.37962f,
+	0.304261f,
+	0.89366f,
+	0.329845f,
+	0.31812f,
+	0.923926f,
+	0.21251f,
+	0.353311f,
+	0.902952f,
+	0.244642f,
+	0.195957f,
+	0.945525f,
+	0.25997f,
+	0.182247f,
+	0.923305f,
+	0.338075f,
+	0.134205f,
+	0.934918f,
+	0.328507f,
+	0.176553f,
+	0.881734f,
+	0.437463f,
+	0.22427f,
+	0.87574f,
+	0.42753f,
+	0.29074f,
+	0.869795f,
+	0.398657f,
+	0.272684f,
+	0.924539f,
+	0.266215f,
+	0.39631f,
+	0.892935f,
+	0.213556f,
+	0.227086f,
+	0.96746f,
+	0.111597f,
+	0.14196f,
+	0.988195f,
+	0.0576051f,
+	0.283679f,
+	0.958555f,
+	0.0264133f,
+	0.216474f,
+	0.969698f,
+	-0.113251f,
+	0.0386649f,
+	0.982201f,
+	-0.183812f,
+	-0.0151491f,
+	0.988164f,
+	-0.152652f,
+	-0.145516f,
+	0.952277f,
+	-0.268316f,
+	-0.219857f,
+	0.921944f,
+	-0.318875f,
+	-0.140821f,
+	0.920717f,
+	-0.363936f,
+	0.13255f,
+	0.932146f,
+	-0.33695f,
+	0.285156f,
+	0.898104f,
+	-0.334807f,
+	0.270867f,
+	0.921389f,
+	-0.278701f,
+	0.136545f,
+	0.958362f,
+	-0.250793f,
+	0.156889f,
+	0.960437f,
+	-0.230103f,
+	0.337521f,
+	0.917391f,
+	-0.210889f,
+	0.340375f,
+	0.909959f,
+	-0.236896f,
+	0.226521f,
+	0.931852f,
+	-0.283443f,
+	0.0467156f,
+	0.919678f,
+	-0.389885f,
+	0.11829f,
+	0.926104f,
+	-0.358244f,
+	0.284734f,
+	0.910765f,
+	-0.299055f,
+	0.155007f,
+	0.943096f,
+	-0.294183f,
+	-0.117772f,
+	0.948884f,
+	-0.29283f,
+	-0.124268f,
+	0.932168f,
+	-0.340029f,
+	0.155477f,
+	0.92011f,
+	-0.359477f,
+	0.348711f,
+	0.859859f,
+	-0.372885f,
+	0.344156f,
+	0.842199f,
+	-0.415039f,
+	0.367487f,
+	0.839547f,
+	-0.400142f,
+	0.45537f,
+	0.851179f,
+	-0.261021f,
+	0.340771f,
+	0.905445f,
+	-0.25307f,
+	0.281592f,
+	0.927438f,
+	-0.246101f,
+	0.270207f,
+	0.930215f,
+	-0.248371f,
+	0.337751f,
+	0.936799f,
+	-0.0912801f,
+	0.415821f,
+	0.905383f,
+	0.085868f,
+	-0.0508816f,
+	0.992949f,
+	0.107064f,
+	0.00772943f,
+	0.999926f,
+	0.0093874f,
+	0.0748585f,
+	0.990585f,
+	-0.114623f,
+	0.0155266f,
+	0.983672f,
+	-0.179298f,
+	0.0579395f,
+	0.986738f,
+	-0.15163f,
+	0.0876255f,
+	0.991018f,
+	-0.10102f,
+	0.0527296f,
+	0.995461f,
+	-0.0792264f,
+	-0.086898f,
+	0.99085f,
+	-0.103274f,
+	-0.226618f,
+	0.972789f,
+	-0.0482267f,
+	-0.175193f,
+	0.983195f,
+	0.0513344f,
+	0.0267808f,
+	0.994997f,
+	0.0962477f,
+	0.0618698f,
+	0.991981f,
+	0.110211f,
+	-0.098328f,
+	0.984739f,
+	0.143601f,
+	-0.00458312f,
+	0.952299f,
+	0.305132f,
+	0.173153f,
+	0.913691f,
+	0.367678f,
+	0.186464f,
+	0.911194f,
+	0.367365f,
+	0.171431f,
+	0.905309f,
+	0.388622f,
+	0.0620384f,
+	0.93682f,
+	0.344266f,
+	-0.143644f,
+	0.960893f,
+	0.23675f,
+	0.0362541f,
+	0.97893f,
+	0.200951f,
+	0.349667f,
+	0.904284f,
+	0.244957f,
+	0.338175f,
+	0.903327f,
+	0.26389f,
+	0.333852f,
+	0.898218f,
+	0.285914f,
+	0.192181f,
+	0.948404f,
+	0.252183f,
+	0.15408f,
+	0.957234f,
+	0.244873f,
+	0.108314f,
+	0.961372f,
+	0.253046f,
+	0.0186373f,
+	0.953687f,
+	0.300223f,
+	0.205839f,
+	0.914416f,
+	0.34853f,
+	0.331275f,
+	0.886521f,
+	0.323015f,
+	0.368345f,
+	0.875165f,
+	0.313702f,
+	0.405591f,
+	0.862022f,
+	0.303997f,
+	0.335644f,
+	0.884308f,
+	0.324566f,
+	0.194457f,
+	0.953987f,
+	0.228245f,
+	0.317589f,
+	0.932139f,
+	0.173936f,
+	0.34707f,
+	0.93458f,
+	0.0781131f,
+	0.1429f,
+	0.981779f,
+	-0.125256f,
+	0.0457434f,
+	0.962864f,
+	-0.266085f,
+	-0.0800896f,
+	0.929514f,
+	-0.359987f,
+	-0.224976f,
+	0.908098f,
+	-0.353191f,
+	-0.16594f,
+	0.929111f,
+	-0.330481f,
+	0.0749763f,
+	0.957672f,
+	-0.277928f,
+	0.277052f,
+	0.936424f,
+	-0.215295f,
+	0.266206f,
+	0.947023f,
+	-0.17967f,
+	0.192217f,
+	0.96172f,
+	-0.195315f,
+	0.159333f,
+	0.947925f,
+	-0.275775f,
+	0.291985f,
+	0.916673f,
+	-0.272864f,
+	0.390644f,
+	0.893072f,
+	-0.223205f,
+	0.316013f,
+	0.901654f,
+	-0.295223f,
+	0.0938304f,
+	0.916417f,
+	-0.38907f,
+	0.0371906f,
+	0.918056f,
+	-0.394702f,
+	0.249356f,
+	0.914822f,
+	-0.317682f,
+	0.159281f,
+	0.933374f,
+	-0.321625f,
+	-0.034507f,
+	0.927426f,
+	-0.372412f,
+	-0.0639276f,
+	0.876921f,
+	-0.476365f,
+	0.150154f,
+	0.87361f,
+	-0.462881f,
+	0.34577f,
+	0.845394f,
+	-0.407127f,
+	0.406017f,
+	0.841234f,
+	-0.357037f,
+	0.322181f,
+	0.876026f,
+	-0.358855f,
+	0.315882f,
+	0.91236f,
+	-0.260417f,
+	0.325378f,
+	0.928704f,
+	-0.177873f,
+	0.281437f,
+	0.937288f,
+	-0.205633f,
+	0.23991f,
+	0.955112f,
+	-0.173792f,
+	0.165717f,
+	0.980838f,
+	-0.102443f,
+	0.16591f,
+	0.98582f,
+	-0.0251575f,
+	0.188672f,
+	0.97776f,
+	0.0915829f,
+	0.0994257f,
+	0.983812f,
+	-0.14909f,
+	0.199087f,
+	0.95198f,
+	-0.232593f,
+	0.0121878f,
+	0.914874f,
+	-0.403556f,
+	-0.0234414f,
+	0.930265f,
+	-0.36614f,
+	-0.038124f,
+	0.972539f,
+	-0.229595f,
+	-0.0300917f,
+	0.999515f,
+	-0.00796094f,
+	-0.092201f,
+	0.984658f,
+	0.148144f,
+	-0.315366f,
+	0.938181f,
+	0.142688f,
+	-0.138968f,
+	0.942311f,
+	0.304528f,
+	0.0277459f,
+	0.977812f,
+	0.207641f,
+	0.0496201f,
+	0.98101f,
+	0.187502f,
+	-0.256039f,
+	0.940975f,
+	0.22138f,
+	-0.0796386f,
+	0.864833f,
+	0.495703f,
+	0.172206f,
+	0.836979f,
+	0.519434f,
+	0.218401f,
+	0.8652f,
+	0.451365f,
+	0.211231f,
+	0.888948f,
+	0.406391f,
+	0.153922f,
+	0.942863f,
+	0.295494f,
+	-0.0705923f,
+	0.983817f,
+	0.164685f,
+	0.0334153f,
+	0.99603f,
+	0.0825054f,
+	0.282635f,
+	0.9535f,
+	0.104667f,
+	0.322121f,
+	0.91103f,
+	0.257413f,
+	0.32296f,
+	0.89395f,
+	0.310726f,
+	0.263681f,
+	0.921808f,
+	0.284152f,
+	0.145976f,
+	0.970498f,
+	0.191897f,
+	0.110214f,
+	0.967993f,
+	0.225482f,
+	0.0100073f,
+	0.970397f,
+	0.241307f,
+	0.231259f,
+	0.94984f,
+	0.210532f,
+	0.350804f,
+	0.929639f,
+	0.112731f,
+	0.388908f,
+	0.908557f,
+	0.152559f,
+	0.325259f,
+	0.933029f,
+	0.153831f,
+	0.358244f,
+	0.845843f,
+	0.395235f,
+	0.245479f,
+	0.88292f,
+	0.400241f,
+	0.340078f,
+	0.880829f,
+	0.329372f,
+	0.448713f,
+	0.860203f,
+	0.242295f,
+	0.291253f,
+	0.956268f,
+	-0.0268833f,
+	0.174446f,
+	0.957532f,
+	-0.229565f,
+	-0.0246181f,
+	0.920367f,
+	-0.390281f,
+	-0.230596f,
+	0.878986f,
+	-0.417383f,
+	-0.188847f,
+	0.897269f,
+	-0.399054f,
+	0.0175328f,
+	0.926292f,
+	-0.376398f,
+	0.23985f,
+	0.925856f,
+	-0.291997f,
+	0.22945f,
+	0.938275f,
+	-0.258829f,
+	0.212396f,
+	0.953082f,
+	-0.21569f,
+	0.229329f,
+	0.940641f,
+	-0.250204f,
+	0.284501f,
+	0.899212f,
+	-0.33238f,
+	0.376241f,
+	0.875275f,
+	-0.30387f,
+	0.33476f,
+	0.887829f,
+	-0.315744f,
+	0.163808f,
+	0.925647f,
+	-0.341094f,
+	0.00890663f,
+	0.895805f,
+	-0.444357f,
+	0.214972f,
+	0.896442f,
+	-0.38753f,
+	0.17587f,
+	0.912162f,
+	-0.370177f,
+	0.075136f,
+	0.903308f,
+	-0.422362f,
+	-0.00910936f,
+	0.832148f,
+	-0.55448f,
+	0.080579f,
+	0.825188f,
+	-0.559082f,
+	0.296201f,
+	0.838595f,
+	-0.457191f,
+	0.316267f,
+	0.8627f,
+	-0.39462f,
+	0.301959f,
+	0.9215f,
+	-0.24425f,
+	0.239667f,
+	0.953185f,
+	-0.184387f,
+	0.359606f,
+	0.929321f,
+	-0.0839473f,
+	0.264487f,
+	0.941897f,
+	-0.207066f,
+	0.184815f,
+	0.971569f,
+	-0.147976f,
+	0.141833f,
+	0.988976f,
+	-0.0425335f,
+	0.112364f,
+	0.992816f,
+	-0.0411276f,
+};
+
+btScalar Landscape04Tex[] = {
+	0.507813f,
+	0.25f,
+	0.507813f,
+	0.242188f,
+	0.515625f,
+	0.25f,
+	0.515625f,
+	0.242188f,
+	0.523438f,
+	0.25f,
+	0.523438f,
+	0.242188f,
+	0.53125f,
+	0.25f,
+	0.53125f,
+	0.242188f,
+	0.539063f,
+	0.25f,
+	0.539063f,
+	0.242188f,
+	0.546875f,
+	0.25f,
+	0.546875f,
+	0.242188f,
+	0.554688f,
+	0.25f,
+	0.554688f,
+	0.242188f,
+	0.5625f,
+	0.25f,
+	0.5625f,
+	0.242188f,
+	0.570313f,
+	0.25f,
+	0.570313f,
+	0.242188f,
+	0.578125f,
+	0.25f,
+	0.578125f,
+	0.242188f,
+	0.585938f,
+	0.25f,
+	0.585938f,
+	0.242188f,
+	0.59375f,
+	0.25f,
+	0.59375f,
+	0.242188f,
+	0.601563f,
+	0.25f,
+	0.601563f,
+	0.242188f,
+	0.609375f,
+	0.25f,
+	0.609375f,
+	0.242188f,
+	0.617188f,
+	0.25f,
+	0.617188f,
+	0.242188f,
+	0.625f,
+	0.25f,
+	0.625f,
+	0.242188f,
+	0.632813f,
+	0.25f,
+	0.632813f,
+	0.242188f,
+	0.640625f,
+	0.25f,
+	0.640625f,
+	0.242188f,
+	0.648438f,
+	0.25f,
+	0.648438f,
+	0.242188f,
+	0.65625f,
+	0.25f,
+	0.65625f,
+	0.242188f,
+	0.664063f,
+	0.25f,
+	0.664063f,
+	0.242188f,
+	0.671875f,
+	0.25f,
+	0.671875f,
+	0.242188f,
+	0.679688f,
+	0.25f,
+	0.679688f,
+	0.242188f,
+	0.6875f,
+	0.25f,
+	0.6875f,
+	0.242188f,
+	0.695313f,
+	0.25f,
+	0.695313f,
+	0.242188f,
+	0.703125f,
+	0.25f,
+	0.703125f,
+	0.242188f,
+	0.710938f,
+	0.25f,
+	0.710938f,
+	0.242188f,
+	0.71875f,
+	0.25f,
+	0.71875f,
+	0.242188f,
+	0.726563f,
+	0.25f,
+	0.726563f,
+	0.242188f,
+	0.734375f,
+	0.25f,
+	0.734375f,
+	0.242188f,
+	0.742188f,
+	0.25f,
+	0.742188f,
+	0.242188f,
+	0.75f,
+	0.25f,
+	0.75f,
+	0.242188f,
+	0.757813f,
+	0.25f,
+	0.757813f,
+	0.242188f,
+	0.765625f,
+	0.25f,
+	0.765625f,
+	0.242188f,
+	0.773438f,
+	0.25f,
+	0.773438f,
+	0.242188f,
+	0.78125f,
+	0.25f,
+	0.78125f,
+	0.242188f,
+	0.789063f,
+	0.25f,
+	0.789063f,
+	0.242188f,
+	0.796875f,
+	0.25f,
+	0.796875f,
+	0.242188f,
+	0.804688f,
+	0.25f,
+	0.804688f,
+	0.242188f,
+	0.8125f,
+	0.25f,
+	0.8125f,
+	0.242188f,
+	0.820313f,
+	0.25f,
+	0.820313f,
+	0.242188f,
+	0.828125f,
+	0.25f,
+	0.828125f,
+	0.242188f,
+	0.835938f,
+	0.25f,
+	0.835938f,
+	0.242188f,
+	0.84375f,
+	0.25f,
+	0.84375f,
+	0.242188f,
+	0.851563f,
+	0.25f,
+	0.851563f,
+	0.242188f,
+	0.859375f,
+	0.25f,
+	0.859375f,
+	0.242188f,
+	0.867188f,
+	0.25f,
+	0.867188f,
+	0.242188f,
+	0.875f,
+	0.25f,
+	0.875f,
+	0.242188f,
+	0.882813f,
+	0.25f,
+	0.882813f,
+	0.242188f,
+	0.890625f,
+	0.25f,
+	0.890625f,
+	0.242188f,
+	0.898438f,
+	0.25f,
+	0.898438f,
+	0.242188f,
+	0.90625f,
+	0.25f,
+	0.90625f,
+	0.242188f,
+	0.914063f,
+	0.25f,
+	0.914063f,
+	0.242188f,
+	0.921875f,
+	0.25f,
+	0.921875f,
+	0.242188f,
+	0.929688f,
+	0.25f,
+	0.929688f,
+	0.242188f,
+	0.9375f,
+	0.25f,
+	0.9375f,
+	0.242188f,
+	0.945313f,
+	0.25f,
+	0.945313f,
+	0.242188f,
+	0.953125f,
+	0.25f,
+	0.953125f,
+	0.242188f,
+	0.960938f,
+	0.25f,
+	0.960938f,
+	0.242188f,
+	0.96875f,
+	0.25f,
+	0.96875f,
+	0.242188f,
+	0.976563f,
+	0.25f,
+	0.976563f,
+	0.242188f,
+	0.984375f,
+	0.25f,
+	0.984375f,
+	0.242188f,
+	0.992188f,
+	0.25f,
+	0.992188f,
+	0.242188f,
+	1.0f,
+	0.25f,
+	1.0f,
+	0.242188f,
+	0.507813f,
+	0.257813f,
+	0.515625f,
+	0.257813f,
+	0.523438f,
+	0.257813f,
+	0.53125f,
+	0.257813f,
+	0.539063f,
+	0.257813f,
+	0.546875f,
+	0.257813f,
+	0.554688f,
+	0.257813f,
+	0.5625f,
+	0.257813f,
+	0.570313f,
+	0.257813f,
+	0.578125f,
+	0.257813f,
+	0.585938f,
+	0.257813f,
+	0.59375f,
+	0.257813f,
+	0.601563f,
+	0.257813f,
+	0.609375f,
+	0.257813f,
+	0.617188f,
+	0.257813f,
+	0.625f,
+	0.257813f,
+	0.632813f,
+	0.257813f,
+	0.640625f,
+	0.257813f,
+	0.648438f,
+	0.257813f,
+	0.65625f,
+	0.257813f,
+	0.664063f,
+	0.257813f,
+	0.671875f,
+	0.257813f,
+	0.679688f,
+	0.257813f,
+	0.6875f,
+	0.257813f,
+	0.695313f,
+	0.257813f,
+	0.703125f,
+	0.257813f,
+	0.710938f,
+	0.257813f,
+	0.71875f,
+	0.257813f,
+	0.726563f,
+	0.257813f,
+	0.734375f,
+	0.257813f,
+	0.742188f,
+	0.257813f,
+	0.75f,
+	0.257813f,
+	0.757813f,
+	0.257813f,
+	0.765625f,
+	0.257813f,
+	0.773438f,
+	0.257813f,
+	0.78125f,
+	0.257813f,
+	0.789063f,
+	0.257813f,
+	0.796875f,
+	0.257813f,
+	0.804688f,
+	0.257813f,
+	0.8125f,
+	0.257813f,
+	0.820313f,
+	0.257813f,
+	0.828125f,
+	0.257813f,
+	0.835938f,
+	0.257813f,
+	0.84375f,
+	0.257813f,
+	0.851563f,
+	0.257813f,
+	0.859375f,
+	0.257813f,
+	0.867188f,
+	0.257813f,
+	0.875f,
+	0.257813f,
+	0.882813f,
+	0.257813f,
+	0.890625f,
+	0.257813f,
+	0.898438f,
+	0.257813f,
+	0.90625f,
+	0.257813f,
+	0.914063f,
+	0.257813f,
+	0.921875f,
+	0.257813f,
+	0.929688f,
+	0.257813f,
+	0.9375f,
+	0.257813f,
+	0.945313f,
+	0.257813f,
+	0.953125f,
+	0.257813f,
+	0.960938f,
+	0.257813f,
+	0.96875f,
+	0.257813f,
+	0.976563f,
+	0.257813f,
+	0.984375f,
+	0.257813f,
+	0.992188f,
+	0.257813f,
+	1.0f,
+	0.257813f,
+	0.507813f,
+	0.265625f,
+	0.515625f,
+	0.265625f,
+	0.523438f,
+	0.265625f,
+	0.53125f,
+	0.265625f,
+	0.539063f,
+	0.265625f,
+	0.546875f,
+	0.265625f,
+	0.554688f,
+	0.265625f,
+	0.5625f,
+	0.265625f,
+	0.570313f,
+	0.265625f,
+	0.578125f,
+	0.265625f,
+	0.585938f,
+	0.265625f,
+	0.59375f,
+	0.265625f,
+	0.601563f,
+	0.265625f,
+	0.609375f,
+	0.265625f,
+	0.617188f,
+	0.265625f,
+	0.625f,
+	0.265625f,
+	0.632813f,
+	0.265625f,
+	0.640625f,
+	0.265625f,
+	0.648438f,
+	0.265625f,
+	0.65625f,
+	0.265625f,
+	0.664063f,
+	0.265625f,
+	0.671875f,
+	0.265625f,
+	0.679688f,
+	0.265625f,
+	0.6875f,
+	0.265625f,
+	0.695313f,
+	0.265625f,
+	0.703125f,
+	0.265625f,
+	0.710938f,
+	0.265625f,
+	0.71875f,
+	0.265625f,
+	0.726563f,
+	0.265625f,
+	0.734375f,
+	0.265625f,
+	0.742188f,
+	0.265625f,
+	0.75f,
+	0.265625f,
+	0.757813f,
+	0.265625f,
+	0.765625f,
+	0.265625f,
+	0.773438f,
+	0.265625f,
+	0.78125f,
+	0.265625f,
+	0.789063f,
+	0.265625f,
+	0.796875f,
+	0.265625f,
+	0.804688f,
+	0.265625f,
+	0.8125f,
+	0.265625f,
+	0.820313f,
+	0.265625f,
+	0.828125f,
+	0.265625f,
+	0.835938f,
+	0.265625f,
+	0.84375f,
+	0.265625f,
+	0.851563f,
+	0.265625f,
+	0.859375f,
+	0.265625f,
+	0.867188f,
+	0.265625f,
+	0.875f,
+	0.265625f,
+	0.882813f,
+	0.265625f,
+	0.890625f,
+	0.265625f,
+	0.898438f,
+	0.265625f,
+	0.90625f,
+	0.265625f,
+	0.914063f,
+	0.265625f,
+	0.921875f,
+	0.265625f,
+	0.929688f,
+	0.265625f,
+	0.9375f,
+	0.265625f,
+	0.945313f,
+	0.265625f,
+	0.953125f,
+	0.265625f,
+	0.960938f,
+	0.265625f,
+	0.96875f,
+	0.265625f,
+	0.976563f,
+	0.265625f,
+	0.984375f,
+	0.265625f,
+	0.992188f,
+	0.265625f,
+	1.0f,
+	0.265625f,
+	0.507813f,
+	0.273438f,
+	0.515625f,
+	0.273438f,
+	0.523438f,
+	0.273438f,
+	0.53125f,
+	0.273438f,
+	0.539063f,
+	0.273438f,
+	0.546875f,
+	0.273438f,
+	0.554688f,
+	0.273438f,
+	0.5625f,
+	0.273438f,
+	0.570313f,
+	0.273438f,
+	0.578125f,
+	0.273438f,
+	0.585938f,
+	0.273438f,
+	0.59375f,
+	0.273438f,
+	0.601563f,
+	0.273438f,
+	0.609375f,
+	0.273438f,
+	0.617188f,
+	0.273438f,
+	0.625f,
+	0.273438f,
+	0.632813f,
+	0.273438f,
+	0.640625f,
+	0.273438f,
+	0.648438f,
+	0.273438f,
+	0.65625f,
+	0.273438f,
+	0.664063f,
+	0.273438f,
+	0.671875f,
+	0.273438f,
+	0.679688f,
+	0.273438f,
+	0.6875f,
+	0.273438f,
+	0.695313f,
+	0.273438f,
+	0.703125f,
+	0.273438f,
+	0.710938f,
+	0.273438f,
+	0.71875f,
+	0.273438f,
+	0.726563f,
+	0.273438f,
+	0.734375f,
+	0.273438f,
+	0.742188f,
+	0.273438f,
+	0.75f,
+	0.273438f,
+	0.757813f,
+	0.273438f,
+	0.765625f,
+	0.273438f,
+	0.773438f,
+	0.273438f,
+	0.78125f,
+	0.273438f,
+	0.789063f,
+	0.273438f,
+	0.796875f,
+	0.273438f,
+	0.804688f,
+	0.273438f,
+	0.8125f,
+	0.273438f,
+	0.820313f,
+	0.273438f,
+	0.828125f,
+	0.273438f,
+	0.835938f,
+	0.273438f,
+	0.84375f,
+	0.273438f,
+	0.851563f,
+	0.273438f,
+	0.859375f,
+	0.273438f,
+	0.867188f,
+	0.273438f,
+	0.875f,
+	0.273438f,
+	0.882813f,
+	0.273438f,
+	0.890625f,
+	0.273438f,
+	0.898438f,
+	0.273438f,
+	0.90625f,
+	0.273438f,
+	0.914063f,
+	0.273438f,
+	0.921875f,
+	0.273438f,
+	0.929688f,
+	0.273438f,
+	0.9375f,
+	0.273438f,
+	0.945313f,
+	0.273438f,
+	0.953125f,
+	0.273438f,
+	0.960938f,
+	0.273438f,
+	0.96875f,
+	0.273438f,
+	0.976563f,
+	0.273438f,
+	0.984375f,
+	0.273438f,
+	0.992188f,
+	0.273438f,
+	1.0f,
+	0.273438f,
+	0.507813f,
+	0.28125f,
+	0.515625f,
+	0.28125f,
+	0.523438f,
+	0.28125f,
+	0.53125f,
+	0.28125f,
+	0.539063f,
+	0.28125f,
+	0.546875f,
+	0.28125f,
+	0.554688f,
+	0.28125f,
+	0.5625f,
+	0.28125f,
+	0.570313f,
+	0.28125f,
+	0.578125f,
+	0.28125f,
+	0.585938f,
+	0.28125f,
+	0.59375f,
+	0.28125f,
+	0.601563f,
+	0.28125f,
+	0.609375f,
+	0.28125f,
+	0.617188f,
+	0.28125f,
+	0.625f,
+	0.28125f,
+	0.632813f,
+	0.28125f,
+	0.640625f,
+	0.28125f,
+	0.648438f,
+	0.28125f,
+	0.65625f,
+	0.28125f,
+	0.664063f,
+	0.28125f,
+	0.671875f,
+	0.28125f,
+	0.679688f,
+	0.28125f,
+	0.6875f,
+	0.28125f,
+	0.695313f,
+	0.28125f,
+	0.703125f,
+	0.28125f,
+	0.710938f,
+	0.28125f,
+	0.71875f,
+	0.28125f,
+	0.726563f,
+	0.28125f,
+	0.734375f,
+	0.28125f,
+	0.742188f,
+	0.28125f,
+	0.75f,
+	0.28125f,
+	0.757813f,
+	0.28125f,
+	0.765625f,
+	0.28125f,
+	0.773438f,
+	0.28125f,
+	0.78125f,
+	0.28125f,
+	0.789063f,
+	0.28125f,
+	0.796875f,
+	0.28125f,
+	0.804688f,
+	0.28125f,
+	0.8125f,
+	0.28125f,
+	0.820313f,
+	0.28125f,
+	0.828125f,
+	0.28125f,
+	0.835938f,
+	0.28125f,
+	0.84375f,
+	0.28125f,
+	0.851563f,
+	0.28125f,
+	0.859375f,
+	0.28125f,
+	0.867188f,
+	0.28125f,
+	0.875f,
+	0.28125f,
+	0.882813f,
+	0.28125f,
+	0.890625f,
+	0.28125f,
+	0.898438f,
+	0.28125f,
+	0.90625f,
+	0.28125f,
+	0.914063f,
+	0.28125f,
+	0.921875f,
+	0.28125f,
+	0.929688f,
+	0.28125f,
+	0.9375f,
+	0.28125f,
+	0.945313f,
+	0.28125f,
+	0.953125f,
+	0.28125f,
+	0.960938f,
+	0.28125f,
+	0.96875f,
+	0.28125f,
+	0.976563f,
+	0.28125f,
+	0.984375f,
+	0.28125f,
+	0.992188f,
+	0.28125f,
+	1.0f,
+	0.28125f,
+	0.507813f,
+	0.289063f,
+	0.515625f,
+	0.289063f,
+	0.523438f,
+	0.289063f,
+	0.53125f,
+	0.289063f,
+	0.539063f,
+	0.289063f,
+	0.546875f,
+	0.289063f,
+	0.554688f,
+	0.289063f,
+	0.5625f,
+	0.289063f,
+	0.570313f,
+	0.289063f,
+	0.578125f,
+	0.289063f,
+	0.585938f,
+	0.289063f,
+	0.59375f,
+	0.289063f,
+	0.601563f,
+	0.289063f,
+	0.609375f,
+	0.289063f,
+	0.617188f,
+	0.289063f,
+	0.625f,
+	0.289063f,
+	0.632813f,
+	0.289063f,
+	0.640625f,
+	0.289063f,
+	0.648438f,
+	0.289063f,
+	0.65625f,
+	0.289063f,
+	0.664063f,
+	0.289063f,
+	0.671875f,
+	0.289063f,
+	0.679688f,
+	0.289063f,
+	0.6875f,
+	0.289063f,
+	0.695313f,
+	0.289063f,
+	0.703125f,
+	0.289063f,
+	0.710938f,
+	0.289063f,
+	0.71875f,
+	0.289063f,
+	0.726563f,
+	0.289063f,
+	0.734375f,
+	0.289063f,
+	0.742188f,
+	0.289063f,
+	0.75f,
+	0.289063f,
+	0.757813f,
+	0.289063f,
+	0.765625f,
+	0.289063f,
+	0.773438f,
+	0.289063f,
+	0.78125f,
+	0.289063f,
+	0.789063f,
+	0.289063f,
+	0.796875f,
+	0.289063f,
+	0.804688f,
+	0.289063f,
+	0.8125f,
+	0.289063f,
+	0.820313f,
+	0.289063f,
+	0.828125f,
+	0.289063f,
+	0.835938f,
+	0.289063f,
+	0.84375f,
+	0.289063f,
+	0.851563f,
+	0.289063f,
+	0.859375f,
+	0.289063f,
+	0.867188f,
+	0.289063f,
+	0.875f,
+	0.289063f,
+	0.882813f,
+	0.289063f,
+	0.890625f,
+	0.289063f,
+	0.898438f,
+	0.289063f,
+	0.90625f,
+	0.289063f,
+	0.914063f,
+	0.289063f,
+	0.921875f,
+	0.289063f,
+	0.929688f,
+	0.289063f,
+	0.9375f,
+	0.289063f,
+	0.945313f,
+	0.289063f,
+	0.953125f,
+	0.289063f,
+	0.960938f,
+	0.289063f,
+	0.96875f,
+	0.289063f,
+	0.976563f,
+	0.289063f,
+	0.984375f,
+	0.289063f,
+	0.992188f,
+	0.289063f,
+	1.0f,
+	0.289063f,
+	0.507813f,
+	0.296875f,
+	0.515625f,
+	0.296875f,
+	0.523438f,
+	0.296875f,
+	0.53125f,
+	0.296875f,
+	0.539063f,
+	0.296875f,
+	0.546875f,
+	0.296875f,
+	0.554688f,
+	0.296875f,
+	0.5625f,
+	0.296875f,
+	0.570313f,
+	0.296875f,
+	0.578125f,
+	0.296875f,
+	0.585938f,
+	0.296875f,
+	0.59375f,
+	0.296875f,
+	0.601563f,
+	0.296875f,
+	0.609375f,
+	0.296875f,
+	0.617188f,
+	0.296875f,
+	0.625f,
+	0.296875f,
+	0.632813f,
+	0.296875f,
+	0.640625f,
+	0.296875f,
+	0.648438f,
+	0.296875f,
+	0.65625f,
+	0.296875f,
+	0.664063f,
+	0.296875f,
+	0.671875f,
+	0.296875f,
+	0.679688f,
+	0.296875f,
+	0.6875f,
+	0.296875f,
+	0.695313f,
+	0.296875f,
+	0.703125f,
+	0.296875f,
+	0.710938f,
+	0.296875f,
+	0.71875f,
+	0.296875f,
+	0.726563f,
+	0.296875f,
+	0.734375f,
+	0.296875f,
+	0.742188f,
+	0.296875f,
+	0.75f,
+	0.296875f,
+	0.757813f,
+	0.296875f,
+	0.765625f,
+	0.296875f,
+	0.773438f,
+	0.296875f,
+	0.78125f,
+	0.296875f,
+	0.789063f,
+	0.296875f,
+	0.796875f,
+	0.296875f,
+	0.804688f,
+	0.296875f,
+	0.8125f,
+	0.296875f,
+	0.820313f,
+	0.296875f,
+	0.828125f,
+	0.296875f,
+	0.835938f,
+	0.296875f,
+	0.84375f,
+	0.296875f,
+	0.851563f,
+	0.296875f,
+	0.859375f,
+	0.296875f,
+	0.867188f,
+	0.296875f,
+	0.875f,
+	0.296875f,
+	0.882813f,
+	0.296875f,
+	0.890625f,
+	0.296875f,
+	0.898438f,
+	0.296875f,
+	0.90625f,
+	0.296875f,
+	0.914063f,
+	0.296875f,
+	0.921875f,
+	0.296875f,
+	0.929688f,
+	0.296875f,
+	0.9375f,
+	0.296875f,
+	0.945313f,
+	0.296875f,
+	0.953125f,
+	0.296875f,
+	0.960938f,
+	0.296875f,
+	0.96875f,
+	0.296875f,
+	0.976563f,
+	0.296875f,
+	0.984375f,
+	0.296875f,
+	0.992188f,
+	0.296875f,
+	1.0f,
+	0.296875f,
+	0.507813f,
+	0.304688f,
+	0.515625f,
+	0.304688f,
+	0.523438f,
+	0.304688f,
+	0.53125f,
+	0.304688f,
+	0.539063f,
+	0.304688f,
+	0.546875f,
+	0.304688f,
+	0.554688f,
+	0.304688f,
+	0.5625f,
+	0.304688f,
+	0.570313f,
+	0.304688f,
+	0.578125f,
+	0.304688f,
+	0.585938f,
+	0.304688f,
+	0.59375f,
+	0.304688f,
+	0.601563f,
+	0.304688f,
+	0.609375f,
+	0.304688f,
+	0.617188f,
+	0.304688f,
+	0.625f,
+	0.304688f,
+	0.632813f,
+	0.304688f,
+	0.640625f,
+	0.304688f,
+	0.648438f,
+	0.304688f,
+	0.65625f,
+	0.304688f,
+	0.664063f,
+	0.304688f,
+	0.671875f,
+	0.304688f,
+	0.679688f,
+	0.304688f,
+	0.6875f,
+	0.304688f,
+	0.695313f,
+	0.304688f,
+	0.703125f,
+	0.304688f,
+	0.710938f,
+	0.304688f,
+	0.71875f,
+	0.304688f,
+	0.726563f,
+	0.304688f,
+	0.734375f,
+	0.304688f,
+	0.742188f,
+	0.304688f,
+	0.75f,
+	0.304688f,
+	0.757813f,
+	0.304688f,
+	0.765625f,
+	0.304688f,
+	0.773438f,
+	0.304688f,
+	0.78125f,
+	0.304688f,
+	0.789063f,
+	0.304688f,
+	0.796875f,
+	0.304688f,
+	0.804688f,
+	0.304688f,
+	0.8125f,
+	0.304688f,
+	0.820313f,
+	0.304688f,
+	0.828125f,
+	0.304688f,
+	0.835938f,
+	0.304688f,
+	0.84375f,
+	0.304688f,
+	0.851563f,
+	0.304688f,
+	0.859375f,
+	0.304688f,
+	0.867188f,
+	0.304688f,
+	0.875f,
+	0.304688f,
+	0.882813f,
+	0.304688f,
+	0.890625f,
+	0.304688f,
+	0.898438f,
+	0.304688f,
+	0.90625f,
+	0.304688f,
+	0.914063f,
+	0.304688f,
+	0.921875f,
+	0.304688f,
+	0.929688f,
+	0.304688f,
+	0.9375f,
+	0.304688f,
+	0.945313f,
+	0.304688f,
+	0.953125f,
+	0.304688f,
+	0.960938f,
+	0.304688f,
+	0.96875f,
+	0.304688f,
+	0.976563f,
+	0.304688f,
+	0.984375f,
+	0.304688f,
+	0.992188f,
+	0.304688f,
+	1.0f,
+	0.304688f,
+	0.507813f,
+	0.3125f,
+	0.515625f,
+	0.3125f,
+	0.523438f,
+	0.3125f,
+	0.53125f,
+	0.3125f,
+	0.539063f,
+	0.3125f,
+	0.546875f,
+	0.3125f,
+	0.554688f,
+	0.3125f,
+	0.5625f,
+	0.3125f,
+	0.570313f,
+	0.3125f,
+	0.578125f,
+	0.3125f,
+	0.585938f,
+	0.3125f,
+	0.59375f,
+	0.3125f,
+	0.601563f,
+	0.3125f,
+	0.609375f,
+	0.3125f,
+	0.617188f,
+	0.3125f,
+	0.625f,
+	0.3125f,
+	0.632813f,
+	0.3125f,
+	0.640625f,
+	0.3125f,
+	0.648438f,
+	0.3125f,
+	0.65625f,
+	0.3125f,
+	0.664063f,
+	0.3125f,
+	0.671875f,
+	0.3125f,
+	0.679688f,
+	0.3125f,
+	0.6875f,
+	0.3125f,
+	0.695313f,
+	0.3125f,
+	0.703125f,
+	0.3125f,
+	0.710938f,
+	0.3125f,
+	0.71875f,
+	0.3125f,
+	0.726563f,
+	0.3125f,
+	0.734375f,
+	0.3125f,
+	0.742188f,
+	0.3125f,
+	0.75f,
+	0.3125f,
+	0.757813f,
+	0.3125f,
+	0.765625f,
+	0.3125f,
+	0.773438f,
+	0.3125f,
+	0.78125f,
+	0.3125f,
+	0.789063f,
+	0.3125f,
+	0.796875f,
+	0.3125f,
+	0.804688f,
+	0.3125f,
+	0.8125f,
+	0.3125f,
+	0.820313f,
+	0.3125f,
+	0.828125f,
+	0.3125f,
+	0.835938f,
+	0.3125f,
+	0.84375f,
+	0.3125f,
+	0.851563f,
+	0.3125f,
+	0.859375f,
+	0.3125f,
+	0.867188f,
+	0.3125f,
+	0.875f,
+	0.3125f,
+	0.882813f,
+	0.3125f,
+	0.890625f,
+	0.3125f,
+	0.898438f,
+	0.3125f,
+	0.90625f,
+	0.3125f,
+	0.914063f,
+	0.3125f,
+	0.921875f,
+	0.3125f,
+	0.929688f,
+	0.3125f,
+	0.9375f,
+	0.3125f,
+	0.945313f,
+	0.3125f,
+	0.953125f,
+	0.3125f,
+	0.960938f,
+	0.3125f,
+	0.96875f,
+	0.3125f,
+	0.976563f,
+	0.3125f,
+	0.984375f,
+	0.3125f,
+	0.992188f,
+	0.3125f,
+	1.0f,
+	0.3125f,
+	0.507813f,
+	0.320313f,
+	0.515625f,
+	0.320313f,
+	0.523438f,
+	0.320313f,
+	0.53125f,
+	0.320313f,
+	0.539063f,
+	0.320313f,
+	0.546875f,
+	0.320313f,
+	0.554688f,
+	0.320313f,
+	0.5625f,
+	0.320313f,
+	0.570313f,
+	0.320313f,
+	0.578125f,
+	0.320313f,
+	0.585938f,
+	0.320313f,
+	0.59375f,
+	0.320313f,
+	0.601563f,
+	0.320313f,
+	0.609375f,
+	0.320313f,
+	0.617188f,
+	0.320313f,
+	0.625f,
+	0.320313f,
+	0.632813f,
+	0.320313f,
+	0.640625f,
+	0.320313f,
+	0.648438f,
+	0.320313f,
+	0.65625f,
+	0.320313f,
+	0.664063f,
+	0.320313f,
+	0.671875f,
+	0.320313f,
+	0.679688f,
+	0.320313f,
+	0.6875f,
+	0.320313f,
+	0.695313f,
+	0.320313f,
+	0.703125f,
+	0.320313f,
+	0.710938f,
+	0.320313f,
+	0.71875f,
+	0.320313f,
+	0.726563f,
+	0.320313f,
+	0.734375f,
+	0.320313f,
+	0.742188f,
+	0.320313f,
+	0.75f,
+	0.320313f,
+	0.757813f,
+	0.320313f,
+	0.765625f,
+	0.320313f,
+	0.773438f,
+	0.320313f,
+	0.78125f,
+	0.320313f,
+	0.789063f,
+	0.320313f,
+	0.796875f,
+	0.320313f,
+	0.804688f,
+	0.320313f,
+	0.8125f,
+	0.320313f,
+	0.820313f,
+	0.320313f,
+	0.828125f,
+	0.320313f,
+	0.835938f,
+	0.320313f,
+	0.84375f,
+	0.320313f,
+	0.851563f,
+	0.320313f,
+	0.859375f,
+	0.320313f,
+	0.867188f,
+	0.320313f,
+	0.875f,
+	0.320313f,
+	0.882813f,
+	0.320313f,
+	0.890625f,
+	0.320313f,
+	0.898438f,
+	0.320313f,
+	0.90625f,
+	0.320313f,
+	0.914063f,
+	0.320313f,
+	0.921875f,
+	0.320313f,
+	0.929688f,
+	0.320313f,
+	0.9375f,
+	0.320313f,
+	0.945313f,
+	0.320313f,
+	0.953125f,
+	0.320313f,
+	0.960938f,
+	0.320313f,
+	0.96875f,
+	0.320313f,
+	0.976563f,
+	0.320313f,
+	0.984375f,
+	0.320313f,
+	0.992188f,
+	0.320313f,
+	1.0f,
+	0.320313f,
+	0.507813f,
+	0.328125f,
+	0.515625f,
+	0.328125f,
+	0.523438f,
+	0.328125f,
+	0.53125f,
+	0.328125f,
+	0.539063f,
+	0.328125f,
+	0.546875f,
+	0.328125f,
+	0.554688f,
+	0.328125f,
+	0.5625f,
+	0.328125f,
+	0.570313f,
+	0.328125f,
+	0.578125f,
+	0.328125f,
+	0.585938f,
+	0.328125f,
+	0.59375f,
+	0.328125f,
+	0.601563f,
+	0.328125f,
+	0.609375f,
+	0.328125f,
+	0.617188f,
+	0.328125f,
+	0.625f,
+	0.328125f,
+	0.632813f,
+	0.328125f,
+	0.640625f,
+	0.328125f,
+	0.648438f,
+	0.328125f,
+	0.65625f,
+	0.328125f,
+	0.664063f,
+	0.328125f,
+	0.671875f,
+	0.328125f,
+	0.679688f,
+	0.328125f,
+	0.6875f,
+	0.328125f,
+	0.695313f,
+	0.328125f,
+	0.703125f,
+	0.328125f,
+	0.710938f,
+	0.328125f,
+	0.71875f,
+	0.328125f,
+	0.726563f,
+	0.328125f,
+	0.734375f,
+	0.328125f,
+	0.742188f,
+	0.328125f,
+	0.75f,
+	0.328125f,
+	0.757813f,
+	0.328125f,
+	0.765625f,
+	0.328125f,
+	0.773438f,
+	0.328125f,
+	0.78125f,
+	0.328125f,
+	0.789063f,
+	0.328125f,
+	0.796875f,
+	0.328125f,
+	0.804688f,
+	0.328125f,
+	0.8125f,
+	0.328125f,
+	0.820313f,
+	0.328125f,
+	0.828125f,
+	0.328125f,
+	0.835938f,
+	0.328125f,
+	0.84375f,
+	0.328125f,
+	0.851563f,
+	0.328125f,
+	0.859375f,
+	0.328125f,
+	0.867188f,
+	0.328125f,
+	0.875f,
+	0.328125f,
+	0.882813f,
+	0.328125f,
+	0.890625f,
+	0.328125f,
+	0.898438f,
+	0.328125f,
+	0.90625f,
+	0.328125f,
+	0.914063f,
+	0.328125f,
+	0.921875f,
+	0.328125f,
+	0.929688f,
+	0.328125f,
+	0.9375f,
+	0.328125f,
+	0.945313f,
+	0.328125f,
+	0.953125f,
+	0.328125f,
+	0.960938f,
+	0.328125f,
+	0.96875f,
+	0.328125f,
+	0.976563f,
+	0.328125f,
+	0.984375f,
+	0.328125f,
+	0.992188f,
+	0.328125f,
+	1.0f,
+	0.328125f,
+	0.507813f,
+	0.335938f,
+	0.515625f,
+	0.335938f,
+	0.523438f,
+	0.335938f,
+	0.53125f,
+	0.335938f,
+	0.539063f,
+	0.335938f,
+	0.546875f,
+	0.335938f,
+	0.554688f,
+	0.335938f,
+	0.5625f,
+	0.335938f,
+	0.570313f,
+	0.335938f,
+	0.578125f,
+	0.335938f,
+	0.585938f,
+	0.335938f,
+	0.59375f,
+	0.335938f,
+	0.601563f,
+	0.335938f,
+	0.609375f,
+	0.335938f,
+	0.617188f,
+	0.335938f,
+	0.625f,
+	0.335938f,
+	0.632813f,
+	0.335938f,
+	0.640625f,
+	0.335938f,
+	0.648438f,
+	0.335938f,
+	0.65625f,
+	0.335938f,
+	0.664063f,
+	0.335938f,
+	0.671875f,
+	0.335938f,
+	0.679688f,
+	0.335938f,
+	0.6875f,
+	0.335938f,
+	0.695313f,
+	0.335938f,
+	0.703125f,
+	0.335938f,
+	0.710938f,
+	0.335938f,
+	0.71875f,
+	0.335938f,
+	0.726563f,
+	0.335938f,
+	0.734375f,
+	0.335938f,
+	0.742188f,
+	0.335938f,
+	0.75f,
+	0.335938f,
+	0.757813f,
+	0.335938f,
+	0.765625f,
+	0.335938f,
+	0.773438f,
+	0.335938f,
+	0.78125f,
+	0.335938f,
+	0.789063f,
+	0.335938f,
+	0.796875f,
+	0.335938f,
+	0.804688f,
+	0.335938f,
+	0.8125f,
+	0.335938f,
+	0.820313f,
+	0.335938f,
+	0.828125f,
+	0.335938f,
+	0.835938f,
+	0.335938f,
+	0.84375f,
+	0.335938f,
+	0.851563f,
+	0.335938f,
+	0.859375f,
+	0.335938f,
+	0.867188f,
+	0.335938f,
+	0.875f,
+	0.335938f,
+	0.882813f,
+	0.335938f,
+	0.890625f,
+	0.335938f,
+	0.898438f,
+	0.335938f,
+	0.90625f,
+	0.335938f,
+	0.914063f,
+	0.335938f,
+	0.921875f,
+	0.335938f,
+	0.929688f,
+	0.335938f,
+	0.9375f,
+	0.335938f,
+	0.945313f,
+	0.335938f,
+	0.953125f,
+	0.335938f,
+	0.960938f,
+	0.335938f,
+	0.96875f,
+	0.335938f,
+	0.976563f,
+	0.335938f,
+	0.984375f,
+	0.335938f,
+	0.992188f,
+	0.335938f,
+	1.0f,
+	0.335938f,
+	0.507813f,
+	0.34375f,
+	0.515625f,
+	0.34375f,
+	0.523438f,
+	0.34375f,
+	0.53125f,
+	0.34375f,
+	0.539063f,
+	0.34375f,
+	0.546875f,
+	0.34375f,
+	0.554688f,
+	0.34375f,
+	0.5625f,
+	0.34375f,
+	0.570313f,
+	0.34375f,
+	0.578125f,
+	0.34375f,
+	0.585938f,
+	0.34375f,
+	0.59375f,
+	0.34375f,
+	0.601563f,
+	0.34375f,
+	0.609375f,
+	0.34375f,
+	0.617188f,
+	0.34375f,
+	0.625f,
+	0.34375f,
+	0.632813f,
+	0.34375f,
+	0.640625f,
+	0.34375f,
+	0.648438f,
+	0.34375f,
+	0.65625f,
+	0.34375f,
+	0.664063f,
+	0.34375f,
+	0.671875f,
+	0.34375f,
+	0.679688f,
+	0.34375f,
+	0.6875f,
+	0.34375f,
+	0.695313f,
+	0.34375f,
+	0.703125f,
+	0.34375f,
+	0.710938f,
+	0.34375f,
+	0.71875f,
+	0.34375f,
+	0.726563f,
+	0.34375f,
+	0.734375f,
+	0.34375f,
+	0.742188f,
+	0.34375f,
+	0.75f,
+	0.34375f,
+	0.757813f,
+	0.34375f,
+	0.765625f,
+	0.34375f,
+	0.773438f,
+	0.34375f,
+	0.78125f,
+	0.34375f,
+	0.789063f,
+	0.34375f,
+	0.796875f,
+	0.34375f,
+	0.804688f,
+	0.34375f,
+	0.8125f,
+	0.34375f,
+	0.820313f,
+	0.34375f,
+	0.828125f,
+	0.34375f,
+	0.835938f,
+	0.34375f,
+	0.84375f,
+	0.34375f,
+	0.851563f,
+	0.34375f,
+	0.859375f,
+	0.34375f,
+	0.867188f,
+	0.34375f,
+	0.875f,
+	0.34375f,
+	0.882813f,
+	0.34375f,
+	0.890625f,
+	0.34375f,
+	0.898438f,
+	0.34375f,
+	0.90625f,
+	0.34375f,
+	0.914063f,
+	0.34375f,
+	0.921875f,
+	0.34375f,
+	0.929688f,
+	0.34375f,
+	0.9375f,
+	0.34375f,
+	0.945313f,
+	0.34375f,
+	0.953125f,
+	0.34375f,
+	0.960938f,
+	0.34375f,
+	0.96875f,
+	0.34375f,
+	0.976563f,
+	0.34375f,
+	0.984375f,
+	0.34375f,
+	0.992188f,
+	0.34375f,
+	1.0f,
+	0.34375f,
+	0.507813f,
+	0.351563f,
+	0.515625f,
+	0.351563f,
+	0.523438f,
+	0.351563f,
+	0.53125f,
+	0.351563f,
+	0.539063f,
+	0.351563f,
+	0.546875f,
+	0.351563f,
+	0.554688f,
+	0.351563f,
+	0.5625f,
+	0.351563f,
+	0.570313f,
+	0.351563f,
+	0.578125f,
+	0.351563f,
+	0.585938f,
+	0.351563f,
+	0.59375f,
+	0.351563f,
+	0.601563f,
+	0.351563f,
+	0.609375f,
+	0.351563f,
+	0.617188f,
+	0.351563f,
+	0.625f,
+	0.351563f,
+	0.632813f,
+	0.351563f,
+	0.640625f,
+	0.351563f,
+	0.648438f,
+	0.351563f,
+	0.65625f,
+	0.351563f,
+	0.664063f,
+	0.351563f,
+	0.671875f,
+	0.351563f,
+	0.679688f,
+	0.351563f,
+	0.6875f,
+	0.351563f,
+	0.695313f,
+	0.351563f,
+	0.703125f,
+	0.351563f,
+	0.710938f,
+	0.351563f,
+	0.71875f,
+	0.351563f,
+	0.726563f,
+	0.351563f,
+	0.734375f,
+	0.351563f,
+	0.742188f,
+	0.351563f,
+	0.75f,
+	0.351563f,
+	0.757813f,
+	0.351563f,
+	0.765625f,
+	0.351563f,
+	0.773438f,
+	0.351563f,
+	0.78125f,
+	0.351563f,
+	0.789063f,
+	0.351563f,
+	0.796875f,
+	0.351563f,
+	0.804688f,
+	0.351563f,
+	0.8125f,
+	0.351563f,
+	0.820313f,
+	0.351563f,
+	0.828125f,
+	0.351563f,
+	0.835938f,
+	0.351563f,
+	0.84375f,
+	0.351563f,
+	0.851563f,
+	0.351563f,
+	0.859375f,
+	0.351563f,
+	0.867188f,
+	0.351563f,
+	0.875f,
+	0.351563f,
+	0.882813f,
+	0.351563f,
+	0.890625f,
+	0.351563f,
+	0.898438f,
+	0.351563f,
+	0.90625f,
+	0.351563f,
+	0.914063f,
+	0.351563f,
+	0.921875f,
+	0.351563f,
+	0.929688f,
+	0.351563f,
+	0.9375f,
+	0.351563f,
+	0.945313f,
+	0.351563f,
+	0.953125f,
+	0.351563f,
+	0.960938f,
+	0.351563f,
+	0.96875f,
+	0.351563f,
+	0.976563f,
+	0.351563f,
+	0.984375f,
+	0.351563f,
+	0.992188f,
+	0.351563f,
+	1.0f,
+	0.351563f,
+	0.507813f,
+	0.359375f,
+	0.515625f,
+	0.359375f,
+	0.523438f,
+	0.359375f,
+	0.53125f,
+	0.359375f,
+	0.539063f,
+	0.359375f,
+	0.546875f,
+	0.359375f,
+	0.554688f,
+	0.359375f,
+	0.5625f,
+	0.359375f,
+	0.570313f,
+	0.359375f,
+	0.578125f,
+	0.359375f,
+	0.585938f,
+	0.359375f,
+	0.59375f,
+	0.359375f,
+	0.601563f,
+	0.359375f,
+	0.609375f,
+	0.359375f,
+	0.617188f,
+	0.359375f,
+	0.625f,
+	0.359375f,
+	0.632813f,
+	0.359375f,
+	0.640625f,
+	0.359375f,
+	0.648438f,
+	0.359375f,
+	0.65625f,
+	0.359375f,
+	0.664063f,
+	0.359375f,
+	0.671875f,
+	0.359375f,
+	0.679688f,
+	0.359375f,
+	0.6875f,
+	0.359375f,
+	0.695313f,
+	0.359375f,
+	0.703125f,
+	0.359375f,
+	0.710938f,
+	0.359375f,
+	0.71875f,
+	0.359375f,
+	0.726563f,
+	0.359375f,
+	0.734375f,
+	0.359375f,
+	0.742188f,
+	0.359375f,
+	0.75f,
+	0.359375f,
+	0.757813f,
+	0.359375f,
+	0.765625f,
+	0.359375f,
+	0.773438f,
+	0.359375f,
+	0.78125f,
+	0.359375f,
+	0.789063f,
+	0.359375f,
+	0.796875f,
+	0.359375f,
+	0.804688f,
+	0.359375f,
+	0.8125f,
+	0.359375f,
+	0.820313f,
+	0.359375f,
+	0.828125f,
+	0.359375f,
+	0.835938f,
+	0.359375f,
+	0.84375f,
+	0.359375f,
+	0.851563f,
+	0.359375f,
+	0.859375f,
+	0.359375f,
+	0.867188f,
+	0.359375f,
+	0.875f,
+	0.359375f,
+	0.882813f,
+	0.359375f,
+	0.890625f,
+	0.359375f,
+	0.898438f,
+	0.359375f,
+	0.90625f,
+	0.359375f,
+	0.914063f,
+	0.359375f,
+	0.921875f,
+	0.359375f,
+	0.929688f,
+	0.359375f,
+	0.9375f,
+	0.359375f,
+	0.945313f,
+	0.359375f,
+	0.953125f,
+	0.359375f,
+	0.960938f,
+	0.359375f,
+	0.96875f,
+	0.359375f,
+	0.976563f,
+	0.359375f,
+	0.984375f,
+	0.359375f,
+	0.992188f,
+	0.359375f,
+	1.0f,
+	0.359375f,
+	0.507813f,
+	0.367188f,
+	0.515625f,
+	0.367188f,
+	0.523438f,
+	0.367188f,
+	0.53125f,
+	0.367188f,
+	0.539063f,
+	0.367188f,
+	0.546875f,
+	0.367188f,
+	0.554688f,
+	0.367188f,
+	0.5625f,
+	0.367188f,
+	0.570313f,
+	0.367188f,
+	0.578125f,
+	0.367188f,
+	0.585938f,
+	0.367188f,
+	0.59375f,
+	0.367188f,
+	0.601563f,
+	0.367188f,
+	0.609375f,
+	0.367188f,
+	0.617188f,
+	0.367188f,
+	0.625f,
+	0.367188f,
+	0.632813f,
+	0.367188f,
+	0.640625f,
+	0.367188f,
+	0.648438f,
+	0.367188f,
+	0.65625f,
+	0.367188f,
+	0.664063f,
+	0.367188f,
+	0.671875f,
+	0.367188f,
+	0.679688f,
+	0.367188f,
+	0.6875f,
+	0.367188f,
+	0.695313f,
+	0.367188f,
+	0.703125f,
+	0.367188f,
+	0.710938f,
+	0.367188f,
+	0.71875f,
+	0.367188f,
+	0.726563f,
+	0.367188f,
+	0.734375f,
+	0.367188f,
+	0.742188f,
+	0.367188f,
+	0.75f,
+	0.367188f,
+	0.757813f,
+	0.367188f,
+	0.765625f,
+	0.367188f,
+	0.773438f,
+	0.367188f,
+	0.78125f,
+	0.367188f,
+	0.789063f,
+	0.367188f,
+	0.796875f,
+	0.367188f,
+	0.804688f,
+	0.367188f,
+	0.8125f,
+	0.367188f,
+	0.820313f,
+	0.367188f,
+	0.828125f,
+	0.367188f,
+	0.835938f,
+	0.367188f,
+	0.84375f,
+	0.367188f,
+	0.851563f,
+	0.367188f,
+	0.859375f,
+	0.367188f,
+	0.867188f,
+	0.367188f,
+	0.875f,
+	0.367188f,
+	0.882813f,
+	0.367188f,
+	0.890625f,
+	0.367188f,
+	0.898438f,
+	0.367188f,
+	0.90625f,
+	0.367188f,
+	0.914063f,
+	0.367188f,
+	0.921875f,
+	0.367188f,
+	0.929688f,
+	0.367188f,
+	0.9375f,
+	0.367188f,
+	0.945313f,
+	0.367188f,
+	0.953125f,
+	0.367188f,
+	0.960938f,
+	0.367188f,
+	0.96875f,
+	0.367188f,
+	0.976563f,
+	0.367188f,
+	0.984375f,
+	0.367188f,
+	0.992188f,
+	0.367188f,
+	1.0f,
+	0.367188f,
+	0.507813f,
+	0.375f,
+	0.515625f,
+	0.375f,
+	0.523438f,
+	0.375f,
+	0.53125f,
+	0.375f,
+	0.539063f,
+	0.375f,
+	0.546875f,
+	0.375f,
+	0.554688f,
+	0.375f,
+	0.5625f,
+	0.375f,
+	0.570313f,
+	0.375f,
+	0.578125f,
+	0.375f,
+	0.585938f,
+	0.375f,
+	0.59375f,
+	0.375f,
+	0.601563f,
+	0.375f,
+	0.609375f,
+	0.375f,
+	0.617188f,
+	0.375f,
+	0.625f,
+	0.375f,
+	0.632813f,
+	0.375f,
+	0.640625f,
+	0.375f,
+	0.648438f,
+	0.375f,
+	0.65625f,
+	0.375f,
+	0.664063f,
+	0.375f,
+	0.671875f,
+	0.375f,
+	0.679688f,
+	0.375f,
+	0.6875f,
+	0.375f,
+	0.695313f,
+	0.375f,
+	0.703125f,
+	0.375f,
+	0.710938f,
+	0.375f,
+	0.71875f,
+	0.375f,
+	0.726563f,
+	0.375f,
+	0.734375f,
+	0.375f,
+	0.742188f,
+	0.375f,
+	0.75f,
+	0.375f,
+	0.757813f,
+	0.375f,
+	0.765625f,
+	0.375f,
+	0.773438f,
+	0.375f,
+	0.78125f,
+	0.375f,
+	0.789063f,
+	0.375f,
+	0.796875f,
+	0.375f,
+	0.804688f,
+	0.375f,
+	0.8125f,
+	0.375f,
+	0.820313f,
+	0.375f,
+	0.828125f,
+	0.375f,
+	0.835938f,
+	0.375f,
+	0.84375f,
+	0.375f,
+	0.851563f,
+	0.375f,
+	0.859375f,
+	0.375f,
+	0.867188f,
+	0.375f,
+	0.875f,
+	0.375f,
+	0.882813f,
+	0.375f,
+	0.890625f,
+	0.375f,
+	0.898438f,
+	0.375f,
+	0.90625f,
+	0.375f,
+	0.914063f,
+	0.375f,
+	0.921875f,
+	0.375f,
+	0.929688f,
+	0.375f,
+	0.9375f,
+	0.375f,
+	0.945313f,
+	0.375f,
+	0.953125f,
+	0.375f,
+	0.960938f,
+	0.375f,
+	0.96875f,
+	0.375f,
+	0.976563f,
+	0.375f,
+	0.984375f,
+	0.375f,
+	0.992188f,
+	0.375f,
+	1.0f,
+	0.375f,
+	0.507813f,
+	0.382813f,
+	0.515625f,
+	0.382813f,
+	0.523438f,
+	0.382813f,
+	0.53125f,
+	0.382813f,
+	0.539063f,
+	0.382813f,
+	0.546875f,
+	0.382813f,
+	0.554688f,
+	0.382813f,
+	0.5625f,
+	0.382813f,
+	0.570313f,
+	0.382813f,
+	0.578125f,
+	0.382813f,
+	0.585938f,
+	0.382813f,
+	0.59375f,
+	0.382813f,
+	0.601563f,
+	0.382813f,
+	0.609375f,
+	0.382813f,
+	0.617188f,
+	0.382813f,
+	0.625f,
+	0.382813f,
+	0.632813f,
+	0.382813f,
+	0.640625f,
+	0.382813f,
+	0.648438f,
+	0.382813f,
+	0.65625f,
+	0.382813f,
+	0.664063f,
+	0.382813f,
+	0.671875f,
+	0.382813f,
+	0.679688f,
+	0.382813f,
+	0.6875f,
+	0.382813f,
+	0.695313f,
+	0.382813f,
+	0.703125f,
+	0.382813f,
+	0.710938f,
+	0.382813f,
+	0.71875f,
+	0.382813f,
+	0.726563f,
+	0.382813f,
+	0.734375f,
+	0.382813f,
+	0.742188f,
+	0.382813f,
+	0.75f,
+	0.382813f,
+	0.757813f,
+	0.382813f,
+	0.765625f,
+	0.382813f,
+	0.773438f,
+	0.382813f,
+	0.78125f,
+	0.382813f,
+	0.789063f,
+	0.382813f,
+	0.796875f,
+	0.382813f,
+	0.804688f,
+	0.382813f,
+	0.8125f,
+	0.382813f,
+	0.820313f,
+	0.382813f,
+	0.828125f,
+	0.382813f,
+	0.835938f,
+	0.382813f,
+	0.84375f,
+	0.382813f,
+	0.851563f,
+	0.382813f,
+	0.859375f,
+	0.382813f,
+	0.867188f,
+	0.382813f,
+	0.875f,
+	0.382813f,
+	0.882813f,
+	0.382813f,
+	0.890625f,
+	0.382813f,
+	0.898438f,
+	0.382813f,
+	0.90625f,
+	0.382813f,
+	0.914063f,
+	0.382813f,
+	0.921875f,
+	0.382813f,
+	0.929688f,
+	0.382813f,
+	0.9375f,
+	0.382813f,
+	0.945313f,
+	0.382813f,
+	0.953125f,
+	0.382813f,
+	0.960938f,
+	0.382813f,
+	0.96875f,
+	0.382813f,
+	0.976563f,
+	0.382813f,
+	0.984375f,
+	0.382813f,
+	0.992188f,
+	0.382813f,
+	1.0f,
+	0.382813f,
+	0.507813f,
+	0.390625f,
+	0.515625f,
+	0.390625f,
+	0.523438f,
+	0.390625f,
+	0.53125f,
+	0.390625f,
+	0.539063f,
+	0.390625f,
+	0.546875f,
+	0.390625f,
+	0.554688f,
+	0.390625f,
+	0.5625f,
+	0.390625f,
+	0.570313f,
+	0.390625f,
+	0.578125f,
+	0.390625f,
+	0.585938f,
+	0.390625f,
+	0.59375f,
+	0.390625f,
+	0.601563f,
+	0.390625f,
+	0.609375f,
+	0.390625f,
+	0.617188f,
+	0.390625f,
+	0.625f,
+	0.390625f,
+	0.632813f,
+	0.390625f,
+	0.640625f,
+	0.390625f,
+	0.648438f,
+	0.390625f,
+	0.65625f,
+	0.390625f,
+	0.664063f,
+	0.390625f,
+	0.671875f,
+	0.390625f,
+	0.679688f,
+	0.390625f,
+	0.6875f,
+	0.390625f,
+	0.695313f,
+	0.390625f,
+	0.703125f,
+	0.390625f,
+	0.710938f,
+	0.390625f,
+	0.71875f,
+	0.390625f,
+	0.726563f,
+	0.390625f,
+	0.734375f,
+	0.390625f,
+	0.742188f,
+	0.390625f,
+	0.75f,
+	0.390625f,
+	0.757813f,
+	0.390625f,
+	0.765625f,
+	0.390625f,
+	0.773438f,
+	0.390625f,
+	0.78125f,
+	0.390625f,
+	0.789063f,
+	0.390625f,
+	0.796875f,
+	0.390625f,
+	0.804688f,
+	0.390625f,
+	0.8125f,
+	0.390625f,
+	0.820313f,
+	0.390625f,
+	0.828125f,
+	0.390625f,
+	0.835938f,
+	0.390625f,
+	0.84375f,
+	0.390625f,
+	0.851563f,
+	0.390625f,
+	0.859375f,
+	0.390625f,
+	0.867188f,
+	0.390625f,
+	0.875f,
+	0.390625f,
+	0.882813f,
+	0.390625f,
+	0.890625f,
+	0.390625f,
+	0.898438f,
+	0.390625f,
+	0.90625f,
+	0.390625f,
+	0.914063f,
+	0.390625f,
+	0.921875f,
+	0.390625f,
+	0.929688f,
+	0.390625f,
+	0.9375f,
+	0.390625f,
+	0.945313f,
+	0.390625f,
+	0.953125f,
+	0.390625f,
+	0.960938f,
+	0.390625f,
+	0.96875f,
+	0.390625f,
+	0.976563f,
+	0.390625f,
+	0.984375f,
+	0.390625f,
+	0.992188f,
+	0.390625f,
+	1.0f,
+	0.390625f,
+	0.507813f,
+	0.398438f,
+	0.515625f,
+	0.398438f,
+	0.523438f,
+	0.398438f,
+	0.53125f,
+	0.398438f,
+	0.539063f,
+	0.398438f,
+	0.546875f,
+	0.398438f,
+	0.554688f,
+	0.398438f,
+	0.5625f,
+	0.398438f,
+	0.570313f,
+	0.398438f,
+	0.578125f,
+	0.398438f,
+	0.585938f,
+	0.398438f,
+	0.59375f,
+	0.398438f,
+	0.601563f,
+	0.398438f,
+	0.609375f,
+	0.398438f,
+	0.617188f,
+	0.398438f,
+	0.625f,
+	0.398438f,
+	0.632813f,
+	0.398438f,
+	0.640625f,
+	0.398438f,
+	0.648438f,
+	0.398438f,
+	0.65625f,
+	0.398438f,
+	0.664063f,
+	0.398438f,
+	0.671875f,
+	0.398438f,
+	0.679688f,
+	0.398438f,
+	0.6875f,
+	0.398438f,
+	0.695313f,
+	0.398438f,
+	0.703125f,
+	0.398438f,
+	0.710938f,
+	0.398438f,
+	0.71875f,
+	0.398438f,
+	0.726563f,
+	0.398438f,
+	0.734375f,
+	0.398438f,
+	0.742188f,
+	0.398438f,
+	0.75f,
+	0.398438f,
+	0.757813f,
+	0.398438f,
+	0.765625f,
+	0.398438f,
+	0.773438f,
+	0.398438f,
+	0.78125f,
+	0.398438f,
+	0.789063f,
+	0.398438f,
+	0.796875f,
+	0.398438f,
+	0.804688f,
+	0.398438f,
+	0.8125f,
+	0.398438f,
+	0.820313f,
+	0.398438f,
+	0.828125f,
+	0.398438f,
+	0.835938f,
+	0.398438f,
+	0.84375f,
+	0.398438f,
+	0.851563f,
+	0.398438f,
+	0.859375f,
+	0.398438f,
+	0.867188f,
+	0.398438f,
+	0.875f,
+	0.398438f,
+	0.882813f,
+	0.398438f,
+	0.890625f,
+	0.398438f,
+	0.898438f,
+	0.398438f,
+	0.90625f,
+	0.398438f,
+	0.914063f,
+	0.398438f,
+	0.921875f,
+	0.398438f,
+	0.929688f,
+	0.398438f,
+	0.9375f,
+	0.398438f,
+	0.945313f,
+	0.398438f,
+	0.953125f,
+	0.398438f,
+	0.960938f,
+	0.398438f,
+	0.96875f,
+	0.398438f,
+	0.976563f,
+	0.398438f,
+	0.984375f,
+	0.398438f,
+	0.992188f,
+	0.398438f,
+	1.0f,
+	0.398438f,
+	0.507813f,
+	0.40625f,
+	0.515625f,
+	0.40625f,
+	0.523438f,
+	0.40625f,
+	0.53125f,
+	0.40625f,
+	0.539063f,
+	0.40625f,
+	0.546875f,
+	0.40625f,
+	0.554688f,
+	0.40625f,
+	0.5625f,
+	0.40625f,
+	0.570313f,
+	0.40625f,
+	0.578125f,
+	0.40625f,
+	0.585938f,
+	0.40625f,
+	0.59375f,
+	0.40625f,
+	0.601563f,
+	0.40625f,
+	0.609375f,
+	0.40625f,
+	0.617188f,
+	0.40625f,
+	0.625f,
+	0.40625f,
+	0.632813f,
+	0.40625f,
+	0.640625f,
+	0.40625f,
+	0.648438f,
+	0.40625f,
+	0.65625f,
+	0.40625f,
+	0.664063f,
+	0.40625f,
+	0.671875f,
+	0.40625f,
+	0.679688f,
+	0.40625f,
+	0.6875f,
+	0.40625f,
+	0.695313f,
+	0.40625f,
+	0.703125f,
+	0.40625f,
+	0.710938f,
+	0.40625f,
+	0.71875f,
+	0.40625f,
+	0.726563f,
+	0.40625f,
+	0.734375f,
+	0.40625f,
+	0.742188f,
+	0.40625f,
+	0.75f,
+	0.40625f,
+	0.757813f,
+	0.40625f,
+	0.765625f,
+	0.40625f,
+	0.773438f,
+	0.40625f,
+	0.78125f,
+	0.40625f,
+	0.789063f,
+	0.40625f,
+	0.796875f,
+	0.40625f,
+	0.804688f,
+	0.40625f,
+	0.8125f,
+	0.40625f,
+	0.820313f,
+	0.40625f,
+	0.828125f,
+	0.40625f,
+	0.835938f,
+	0.40625f,
+	0.84375f,
+	0.40625f,
+	0.851563f,
+	0.40625f,
+	0.859375f,
+	0.40625f,
+	0.867188f,
+	0.40625f,
+	0.875f,
+	0.40625f,
+	0.882813f,
+	0.40625f,
+	0.890625f,
+	0.40625f,
+	0.898438f,
+	0.40625f,
+	0.90625f,
+	0.40625f,
+	0.914063f,
+	0.40625f,
+	0.921875f,
+	0.40625f,
+	0.929688f,
+	0.40625f,
+	0.9375f,
+	0.40625f,
+	0.945313f,
+	0.40625f,
+	0.953125f,
+	0.40625f,
+	0.960938f,
+	0.40625f,
+	0.96875f,
+	0.40625f,
+	0.976563f,
+	0.40625f,
+	0.984375f,
+	0.40625f,
+	0.992188f,
+	0.40625f,
+	1.0f,
+	0.40625f,
+	0.507813f,
+	0.414063f,
+	0.515625f,
+	0.414063f,
+	0.523438f,
+	0.414063f,
+	0.53125f,
+	0.414063f,
+	0.539063f,
+	0.414063f,
+	0.546875f,
+	0.414063f,
+	0.554688f,
+	0.414063f,
+	0.5625f,
+	0.414063f,
+	0.570313f,
+	0.414063f,
+	0.578125f,
+	0.414063f,
+	0.585938f,
+	0.414063f,
+	0.59375f,
+	0.414063f,
+	0.601563f,
+	0.414063f,
+	0.609375f,
+	0.414063f,
+	0.617188f,
+	0.414063f,
+	0.625f,
+	0.414063f,
+	0.632813f,
+	0.414063f,
+	0.640625f,
+	0.414063f,
+	0.648438f,
+	0.414063f,
+	0.65625f,
+	0.414063f,
+	0.664063f,
+	0.414063f,
+	0.671875f,
+	0.414063f,
+	0.679688f,
+	0.414063f,
+	0.6875f,
+	0.414063f,
+	0.695313f,
+	0.414063f,
+	0.703125f,
+	0.414063f,
+	0.710938f,
+	0.414063f,
+	0.71875f,
+	0.414063f,
+	0.726563f,
+	0.414063f,
+	0.734375f,
+	0.414063f,
+	0.742188f,
+	0.414063f,
+	0.75f,
+	0.414063f,
+	0.757813f,
+	0.414063f,
+	0.765625f,
+	0.414063f,
+	0.773438f,
+	0.414063f,
+	0.78125f,
+	0.414063f,
+	0.789063f,
+	0.414063f,
+	0.796875f,
+	0.414063f,
+	0.804688f,
+	0.414063f,
+	0.8125f,
+	0.414063f,
+	0.820313f,
+	0.414063f,
+	0.828125f,
+	0.414063f,
+	0.835938f,
+	0.414063f,
+	0.84375f,
+	0.414063f,
+	0.851563f,
+	0.414063f,
+	0.859375f,
+	0.414063f,
+	0.867188f,
+	0.414063f,
+	0.875f,
+	0.414063f,
+	0.882813f,
+	0.414063f,
+	0.890625f,
+	0.414063f,
+	0.898438f,
+	0.414063f,
+	0.90625f,
+	0.414063f,
+	0.914063f,
+	0.414063f,
+	0.921875f,
+	0.414063f,
+	0.929688f,
+	0.414063f,
+	0.9375f,
+	0.414063f,
+	0.945313f,
+	0.414063f,
+	0.953125f,
+	0.414063f,
+	0.960938f,
+	0.414063f,
+	0.96875f,
+	0.414063f,
+	0.976563f,
+	0.414063f,
+	0.984375f,
+	0.414063f,
+	0.992188f,
+	0.414063f,
+	1.0f,
+	0.414063f,
+	0.507813f,
+	0.421875f,
+	0.515625f,
+	0.421875f,
+	0.523438f,
+	0.421875f,
+	0.53125f,
+	0.421875f,
+	0.539063f,
+	0.421875f,
+	0.546875f,
+	0.421875f,
+	0.554688f,
+	0.421875f,
+	0.5625f,
+	0.421875f,
+	0.570313f,
+	0.421875f,
+	0.578125f,
+	0.421875f,
+	0.585938f,
+	0.421875f,
+	0.59375f,
+	0.421875f,
+	0.601563f,
+	0.421875f,
+	0.609375f,
+	0.421875f,
+	0.617188f,
+	0.421875f,
+	0.625f,
+	0.421875f,
+	0.632813f,
+	0.421875f,
+	0.640625f,
+	0.421875f,
+	0.648438f,
+	0.421875f,
+	0.65625f,
+	0.421875f,
+	0.664063f,
+	0.421875f,
+	0.671875f,
+	0.421875f,
+	0.679688f,
+	0.421875f,
+	0.6875f,
+	0.421875f,
+	0.695313f,
+	0.421875f,
+	0.703125f,
+	0.421875f,
+	0.710938f,
+	0.421875f,
+	0.71875f,
+	0.421875f,
+	0.726563f,
+	0.421875f,
+	0.734375f,
+	0.421875f,
+	0.742188f,
+	0.421875f,
+	0.75f,
+	0.421875f,
+	0.757813f,
+	0.421875f,
+	0.765625f,
+	0.421875f,
+	0.773438f,
+	0.421875f,
+	0.78125f,
+	0.421875f,
+	0.789063f,
+	0.421875f,
+	0.796875f,
+	0.421875f,
+	0.804688f,
+	0.421875f,
+	0.8125f,
+	0.421875f,
+	0.820313f,
+	0.421875f,
+	0.828125f,
+	0.421875f,
+	0.835938f,
+	0.421875f,
+	0.84375f,
+	0.421875f,
+	0.851563f,
+	0.421875f,
+	0.859375f,
+	0.421875f,
+	0.867188f,
+	0.421875f,
+	0.875f,
+	0.421875f,
+	0.882813f,
+	0.421875f,
+	0.890625f,
+	0.421875f,
+	0.898438f,
+	0.421875f,
+	0.90625f,
+	0.421875f,
+	0.914063f,
+	0.421875f,
+	0.921875f,
+	0.421875f,
+	0.929688f,
+	0.421875f,
+	0.9375f,
+	0.421875f,
+	0.945313f,
+	0.421875f,
+	0.953125f,
+	0.421875f,
+	0.960938f,
+	0.421875f,
+	0.96875f,
+	0.421875f,
+	0.976563f,
+	0.421875f,
+	0.984375f,
+	0.421875f,
+	0.992188f,
+	0.421875f,
+	1.0f,
+	0.421875f,
+	0.507813f,
+	0.429688f,
+	0.515625f,
+	0.429688f,
+	0.523438f,
+	0.429688f,
+	0.53125f,
+	0.429688f,
+	0.539063f,
+	0.429688f,
+	0.546875f,
+	0.429688f,
+	0.554688f,
+	0.429688f,
+	0.5625f,
+	0.429688f,
+	0.570313f,
+	0.429688f,
+	0.578125f,
+	0.429688f,
+	0.585938f,
+	0.429688f,
+	0.59375f,
+	0.429688f,
+	0.601563f,
+	0.429688f,
+	0.609375f,
+	0.429688f,
+	0.617188f,
+	0.429688f,
+	0.625f,
+	0.429688f,
+	0.632813f,
+	0.429688f,
+	0.640625f,
+	0.429688f,
+	0.648438f,
+	0.429688f,
+	0.65625f,
+	0.429688f,
+	0.664063f,
+	0.429688f,
+	0.671875f,
+	0.429688f,
+	0.679688f,
+	0.429688f,
+	0.6875f,
+	0.429688f,
+	0.695313f,
+	0.429688f,
+	0.703125f,
+	0.429688f,
+	0.710938f,
+	0.429688f,
+	0.71875f,
+	0.429688f,
+	0.726563f,
+	0.429688f,
+	0.734375f,
+	0.429688f,
+	0.742188f,
+	0.429688f,
+	0.75f,
+	0.429688f,
+	0.757813f,
+	0.429688f,
+	0.765625f,
+	0.429688f,
+	0.773438f,
+	0.429688f,
+	0.78125f,
+	0.429688f,
+	0.789063f,
+	0.429688f,
+	0.796875f,
+	0.429688f,
+	0.804688f,
+	0.429688f,
+	0.8125f,
+	0.429688f,
+	0.820313f,
+	0.429688f,
+	0.828125f,
+	0.429688f,
+	0.835938f,
+	0.429688f,
+	0.84375f,
+	0.429688f,
+	0.851563f,
+	0.429688f,
+	0.859375f,
+	0.429688f,
+	0.867188f,
+	0.429688f,
+	0.875f,
+	0.429688f,
+	0.882813f,
+	0.429688f,
+	0.890625f,
+	0.429688f,
+	0.898438f,
+	0.429688f,
+	0.90625f,
+	0.429688f,
+	0.914063f,
+	0.429688f,
+	0.921875f,
+	0.429688f,
+	0.929688f,
+	0.429688f,
+	0.9375f,
+	0.429688f,
+	0.945313f,
+	0.429688f,
+	0.953125f,
+	0.429688f,
+	0.960938f,
+	0.429688f,
+	0.96875f,
+	0.429688f,
+	0.976563f,
+	0.429688f,
+	0.984375f,
+	0.429688f,
+	0.992188f,
+	0.429688f,
+	1.0f,
+	0.429688f,
+	0.507813f,
+	0.4375f,
+	0.515625f,
+	0.4375f,
+	0.523438f,
+	0.4375f,
+	0.53125f,
+	0.4375f,
+	0.539063f,
+	0.4375f,
+	0.546875f,
+	0.4375f,
+	0.554688f,
+	0.4375f,
+	0.5625f,
+	0.4375f,
+	0.570313f,
+	0.4375f,
+	0.578125f,
+	0.4375f,
+	0.585938f,
+	0.4375f,
+	0.59375f,
+	0.4375f,
+	0.601563f,
+	0.4375f,
+	0.609375f,
+	0.4375f,
+	0.617188f,
+	0.4375f,
+	0.625f,
+	0.4375f,
+	0.632813f,
+	0.4375f,
+	0.640625f,
+	0.4375f,
+	0.648438f,
+	0.4375f,
+	0.65625f,
+	0.4375f,
+	0.664063f,
+	0.4375f,
+	0.671875f,
+	0.4375f,
+	0.679688f,
+	0.4375f,
+	0.6875f,
+	0.4375f,
+	0.695313f,
+	0.4375f,
+	0.703125f,
+	0.4375f,
+	0.710938f,
+	0.4375f,
+	0.71875f,
+	0.4375f,
+	0.726563f,
+	0.4375f,
+	0.734375f,
+	0.4375f,
+	0.742188f,
+	0.4375f,
+	0.75f,
+	0.4375f,
+	0.757813f,
+	0.4375f,
+	0.765625f,
+	0.4375f,
+	0.773438f,
+	0.4375f,
+	0.78125f,
+	0.4375f,
+	0.789063f,
+	0.4375f,
+	0.796875f,
+	0.4375f,
+	0.804688f,
+	0.4375f,
+	0.8125f,
+	0.4375f,
+	0.820313f,
+	0.4375f,
+	0.828125f,
+	0.4375f,
+	0.835938f,
+	0.4375f,
+	0.84375f,
+	0.4375f,
+	0.851563f,
+	0.4375f,
+	0.859375f,
+	0.4375f,
+	0.867188f,
+	0.4375f,
+	0.875f,
+	0.4375f,
+	0.882813f,
+	0.4375f,
+	0.890625f,
+	0.4375f,
+	0.898438f,
+	0.4375f,
+	0.90625f,
+	0.4375f,
+	0.914063f,
+	0.4375f,
+	0.921875f,
+	0.4375f,
+	0.929688f,
+	0.4375f,
+	0.9375f,
+	0.4375f,
+	0.945313f,
+	0.4375f,
+	0.953125f,
+	0.4375f,
+	0.960938f,
+	0.4375f,
+	0.96875f,
+	0.4375f,
+	0.976563f,
+	0.4375f,
+	0.984375f,
+	0.4375f,
+	0.992188f,
+	0.4375f,
+	1.0f,
+	0.4375f,
+	0.507813f,
+	0.445313f,
+	0.515625f,
+	0.445313f,
+	0.523438f,
+	0.445313f,
+	0.53125f,
+	0.445313f,
+	0.539063f,
+	0.445313f,
+	0.546875f,
+	0.445313f,
+	0.554688f,
+	0.445313f,
+	0.5625f,
+	0.445313f,
+	0.570313f,
+	0.445313f,
+	0.578125f,
+	0.445313f,
+	0.585938f,
+	0.445313f,
+	0.59375f,
+	0.445313f,
+	0.601563f,
+	0.445313f,
+	0.609375f,
+	0.445313f,
+	0.617188f,
+	0.445313f,
+	0.625f,
+	0.445313f,
+	0.632813f,
+	0.445313f,
+	0.640625f,
+	0.445313f,
+	0.648438f,
+	0.445313f,
+	0.65625f,
+	0.445313f,
+	0.664063f,
+	0.445313f,
+	0.671875f,
+	0.445313f,
+	0.679688f,
+	0.445313f,
+	0.6875f,
+	0.445313f,
+	0.695313f,
+	0.445313f,
+	0.703125f,
+	0.445313f,
+	0.710938f,
+	0.445313f,
+	0.71875f,
+	0.445313f,
+	0.726563f,
+	0.445313f,
+	0.734375f,
+	0.445313f,
+	0.742188f,
+	0.445313f,
+	0.75f,
+	0.445313f,
+	0.757813f,
+	0.445313f,
+	0.765625f,
+	0.445313f,
+	0.773438f,
+	0.445313f,
+	0.78125f,
+	0.445313f,
+	0.789063f,
+	0.445313f,
+	0.796875f,
+	0.445313f,
+	0.804688f,
+	0.445313f,
+	0.8125f,
+	0.445313f,
+	0.820313f,
+	0.445313f,
+	0.828125f,
+	0.445313f,
+	0.835938f,
+	0.445313f,
+	0.84375f,
+	0.445313f,
+	0.851563f,
+	0.445313f,
+	0.859375f,
+	0.445313f,
+	0.867188f,
+	0.445313f,
+	0.875f,
+	0.445313f,
+	0.882813f,
+	0.445313f,
+	0.890625f,
+	0.445313f,
+	0.898438f,
+	0.445313f,
+	0.90625f,
+	0.445313f,
+	0.914063f,
+	0.445313f,
+	0.921875f,
+	0.445313f,
+	0.929688f,
+	0.445313f,
+	0.9375f,
+	0.445313f,
+	0.945313f,
+	0.445313f,
+	0.953125f,
+	0.445313f,
+	0.960938f,
+	0.445313f,
+	0.96875f,
+	0.445313f,
+	0.976563f,
+	0.445313f,
+	0.984375f,
+	0.445313f,
+	0.992188f,
+	0.445313f,
+	1.0f,
+	0.445313f,
+	0.507813f,
+	0.453125f,
+	0.515625f,
+	0.453125f,
+	0.523438f,
+	0.453125f,
+	0.53125f,
+	0.453125f,
+	0.539063f,
+	0.453125f,
+	0.546875f,
+	0.453125f,
+	0.554688f,
+	0.453125f,
+	0.5625f,
+	0.453125f,
+	0.570313f,
+	0.453125f,
+	0.578125f,
+	0.453125f,
+	0.585938f,
+	0.453125f,
+	0.59375f,
+	0.453125f,
+	0.601563f,
+	0.453125f,
+	0.609375f,
+	0.453125f,
+	0.617188f,
+	0.453125f,
+	0.625f,
+	0.453125f,
+	0.632813f,
+	0.453125f,
+	0.640625f,
+	0.453125f,
+	0.648438f,
+	0.453125f,
+	0.65625f,
+	0.453125f,
+	0.664063f,
+	0.453125f,
+	0.671875f,
+	0.453125f,
+	0.679688f,
+	0.453125f,
+	0.6875f,
+	0.453125f,
+	0.695313f,
+	0.453125f,
+	0.703125f,
+	0.453125f,
+	0.710938f,
+	0.453125f,
+	0.71875f,
+	0.453125f,
+	0.726563f,
+	0.453125f,
+	0.734375f,
+	0.453125f,
+	0.742188f,
+	0.453125f,
+	0.75f,
+	0.453125f,
+	0.757813f,
+	0.453125f,
+	0.765625f,
+	0.453125f,
+	0.773438f,
+	0.453125f,
+	0.78125f,
+	0.453125f,
+	0.789063f,
+	0.453125f,
+	0.796875f,
+	0.453125f,
+	0.804688f,
+	0.453125f,
+	0.8125f,
+	0.453125f,
+	0.820313f,
+	0.453125f,
+	0.828125f,
+	0.453125f,
+	0.835938f,
+	0.453125f,
+	0.84375f,
+	0.453125f,
+	0.851563f,
+	0.453125f,
+	0.859375f,
+	0.453125f,
+	0.867188f,
+	0.453125f,
+	0.875f,
+	0.453125f,
+	0.882813f,
+	0.453125f,
+	0.890625f,
+	0.453125f,
+	0.898438f,
+	0.453125f,
+	0.90625f,
+	0.453125f,
+	0.914063f,
+	0.453125f,
+	0.921875f,
+	0.453125f,
+	0.929688f,
+	0.453125f,
+	0.9375f,
+	0.453125f,
+	0.945313f,
+	0.453125f,
+	0.953125f,
+	0.453125f,
+	0.960938f,
+	0.453125f,
+	0.96875f,
+	0.453125f,
+	0.976563f,
+	0.453125f,
+	0.984375f,
+	0.453125f,
+	0.992188f,
+	0.453125f,
+	1.0f,
+	0.453125f,
+	0.507813f,
+	0.460938f,
+	0.515625f,
+	0.460938f,
+	0.523438f,
+	0.460938f,
+	0.53125f,
+	0.460938f,
+	0.539063f,
+	0.460938f,
+	0.546875f,
+	0.460938f,
+	0.554688f,
+	0.460938f,
+	0.5625f,
+	0.460938f,
+	0.570313f,
+	0.460938f,
+	0.578125f,
+	0.460938f,
+	0.585938f,
+	0.460938f,
+	0.59375f,
+	0.460938f,
+	0.601563f,
+	0.460938f,
+	0.609375f,
+	0.460938f,
+	0.617188f,
+	0.460938f,
+	0.625f,
+	0.460938f,
+	0.632813f,
+	0.460938f,
+	0.640625f,
+	0.460938f,
+	0.648438f,
+	0.460938f,
+	0.65625f,
+	0.460938f,
+	0.664063f,
+	0.460938f,
+	0.671875f,
+	0.460938f,
+	0.679688f,
+	0.460938f,
+	0.6875f,
+	0.460938f,
+	0.695313f,
+	0.460938f,
+	0.703125f,
+	0.460938f,
+	0.710938f,
+	0.460938f,
+	0.71875f,
+	0.460938f,
+	0.726563f,
+	0.460938f,
+	0.734375f,
+	0.460938f,
+	0.742188f,
+	0.460938f,
+	0.75f,
+	0.460938f,
+	0.757813f,
+	0.460938f,
+	0.765625f,
+	0.460938f,
+	0.773438f,
+	0.460938f,
+	0.78125f,
+	0.460938f,
+	0.789063f,
+	0.460938f,
+	0.796875f,
+	0.460938f,
+	0.804688f,
+	0.460938f,
+	0.8125f,
+	0.460938f,
+	0.820313f,
+	0.460938f,
+	0.828125f,
+	0.460938f,
+	0.835938f,
+	0.460938f,
+	0.84375f,
+	0.460938f,
+	0.851563f,
+	0.460938f,
+	0.859375f,
+	0.460938f,
+	0.867188f,
+	0.460938f,
+	0.875f,
+	0.460938f,
+	0.882813f,
+	0.460938f,
+	0.890625f,
+	0.460938f,
+	0.898438f,
+	0.460938f,
+	0.90625f,
+	0.460938f,
+	0.914063f,
+	0.460938f,
+	0.921875f,
+	0.460938f,
+	0.929688f,
+	0.460938f,
+	0.9375f,
+	0.460938f,
+	0.945313f,
+	0.460938f,
+	0.953125f,
+	0.460938f,
+	0.960938f,
+	0.460938f,
+	0.96875f,
+	0.460938f,
+	0.976563f,
+	0.460938f,
+	0.984375f,
+	0.460938f,
+	0.992188f,
+	0.460938f,
+	1.0f,
+	0.460938f,
+	0.507813f,
+	0.46875f,
+	0.515625f,
+	0.46875f,
+	0.523438f,
+	0.46875f,
+	0.53125f,
+	0.46875f,
+	0.539063f,
+	0.46875f,
+	0.546875f,
+	0.46875f,
+	0.554688f,
+	0.46875f,
+	0.5625f,
+	0.46875f,
+	0.570313f,
+	0.46875f,
+	0.578125f,
+	0.46875f,
+	0.585938f,
+	0.46875f,
+	0.59375f,
+	0.46875f,
+	0.601563f,
+	0.46875f,
+	0.609375f,
+	0.46875f,
+	0.617188f,
+	0.46875f,
+	0.625f,
+	0.46875f,
+	0.632813f,
+	0.46875f,
+	0.640625f,
+	0.46875f,
+	0.648438f,
+	0.46875f,
+	0.65625f,
+	0.46875f,
+	0.664063f,
+	0.46875f,
+	0.671875f,
+	0.46875f,
+	0.679688f,
+	0.46875f,
+	0.6875f,
+	0.46875f,
+	0.695313f,
+	0.46875f,
+	0.703125f,
+	0.46875f,
+	0.710938f,
+	0.46875f,
+	0.71875f,
+	0.46875f,
+	0.726563f,
+	0.46875f,
+	0.734375f,
+	0.46875f,
+	0.742188f,
+	0.46875f,
+	0.75f,
+	0.46875f,
+	0.757813f,
+	0.46875f,
+	0.765625f,
+	0.46875f,
+	0.773438f,
+	0.46875f,
+	0.78125f,
+	0.46875f,
+	0.789063f,
+	0.46875f,
+	0.796875f,
+	0.46875f,
+	0.804688f,
+	0.46875f,
+	0.8125f,
+	0.46875f,
+	0.820313f,
+	0.46875f,
+	0.828125f,
+	0.46875f,
+	0.835938f,
+	0.46875f,
+	0.84375f,
+	0.46875f,
+	0.851563f,
+	0.46875f,
+	0.859375f,
+	0.46875f,
+	0.867188f,
+	0.46875f,
+	0.875f,
+	0.46875f,
+	0.882813f,
+	0.46875f,
+	0.890625f,
+	0.46875f,
+	0.898438f,
+	0.46875f,
+	0.90625f,
+	0.46875f,
+	0.914063f,
+	0.46875f,
+	0.921875f,
+	0.46875f,
+	0.929688f,
+	0.46875f,
+	0.9375f,
+	0.46875f,
+	0.945313f,
+	0.46875f,
+	0.953125f,
+	0.46875f,
+	0.960938f,
+	0.46875f,
+	0.96875f,
+	0.46875f,
+	0.976563f,
+	0.46875f,
+	0.984375f,
+	0.46875f,
+	0.992188f,
+	0.46875f,
+	1.0f,
+	0.46875f,
+	0.507813f,
+	0.476563f,
+	0.515625f,
+	0.476563f,
+	0.523438f,
+	0.476563f,
+	0.53125f,
+	0.476563f,
+	0.539063f,
+	0.476563f,
+	0.546875f,
+	0.476563f,
+	0.554688f,
+	0.476563f,
+	0.5625f,
+	0.476563f,
+	0.570313f,
+	0.476563f,
+	0.578125f,
+	0.476563f,
+	0.585938f,
+	0.476563f,
+	0.59375f,
+	0.476563f,
+	0.601563f,
+	0.476563f,
+	0.609375f,
+	0.476563f,
+	0.617188f,
+	0.476563f,
+	0.625f,
+	0.476563f,
+	0.632813f,
+	0.476563f,
+	0.640625f,
+	0.476563f,
+	0.648438f,
+	0.476563f,
+	0.65625f,
+	0.476563f,
+	0.664063f,
+	0.476563f,
+	0.671875f,
+	0.476563f,
+	0.679688f,
+	0.476563f,
+	0.6875f,
+	0.476563f,
+	0.695313f,
+	0.476563f,
+	0.703125f,
+	0.476563f,
+	0.710938f,
+	0.476563f,
+	0.71875f,
+	0.476563f,
+	0.726563f,
+	0.476563f,
+	0.734375f,
+	0.476563f,
+	0.742188f,
+	0.476563f,
+	0.75f,
+	0.476563f,
+	0.757813f,
+	0.476563f,
+	0.765625f,
+	0.476563f,
+	0.773438f,
+	0.476563f,
+	0.78125f,
+	0.476563f,
+	0.789063f,
+	0.476563f,
+	0.796875f,
+	0.476563f,
+	0.804688f,
+	0.476563f,
+	0.8125f,
+	0.476563f,
+	0.820313f,
+	0.476563f,
+	0.828125f,
+	0.476563f,
+	0.835938f,
+	0.476563f,
+	0.84375f,
+	0.476563f,
+	0.851563f,
+	0.476563f,
+	0.859375f,
+	0.476563f,
+	0.867188f,
+	0.476563f,
+	0.875f,
+	0.476563f,
+	0.882813f,
+	0.476563f,
+	0.890625f,
+	0.476563f,
+	0.898438f,
+	0.476563f,
+	0.90625f,
+	0.476563f,
+	0.914063f,
+	0.476563f,
+	0.921875f,
+	0.476563f,
+	0.929688f,
+	0.476563f,
+	0.9375f,
+	0.476563f,
+	0.945313f,
+	0.476563f,
+	0.953125f,
+	0.476563f,
+	0.960938f,
+	0.476563f,
+	0.96875f,
+	0.476563f,
+	0.976563f,
+	0.476563f,
+	0.984375f,
+	0.476563f,
+	0.992188f,
+	0.476563f,
+	1.0f,
+	0.476563f,
+	0.507813f,
+	0.484375f,
+	0.515625f,
+	0.484375f,
+	0.523438f,
+	0.484375f,
+	0.53125f,
+	0.484375f,
+	0.539063f,
+	0.484375f,
+	0.546875f,
+	0.484375f,
+	0.554688f,
+	0.484375f,
+	0.5625f,
+	0.484375f,
+	0.570313f,
+	0.484375f,
+	0.578125f,
+	0.484375f,
+	0.585938f,
+	0.484375f,
+	0.59375f,
+	0.484375f,
+	0.601563f,
+	0.484375f,
+	0.609375f,
+	0.484375f,
+	0.617188f,
+	0.484375f,
+	0.625f,
+	0.484375f,
+	0.632813f,
+	0.484375f,
+	0.640625f,
+	0.484375f,
+	0.648438f,
+	0.484375f,
+	0.65625f,
+	0.484375f,
+	0.664063f,
+	0.484375f,
+	0.671875f,
+	0.484375f,
+	0.679688f,
+	0.484375f,
+	0.6875f,
+	0.484375f,
+	0.695313f,
+	0.484375f,
+	0.703125f,
+	0.484375f,
+	0.710938f,
+	0.484375f,
+	0.71875f,
+	0.484375f,
+	0.726563f,
+	0.484375f,
+	0.734375f,
+	0.484375f,
+	0.742188f,
+	0.484375f,
+	0.75f,
+	0.484375f,
+	0.757813f,
+	0.484375f,
+	0.765625f,
+	0.484375f,
+	0.773438f,
+	0.484375f,
+	0.78125f,
+	0.484375f,
+	0.789063f,
+	0.484375f,
+	0.796875f,
+	0.484375f,
+	0.804688f,
+	0.484375f,
+	0.8125f,
+	0.484375f,
+	0.820313f,
+	0.484375f,
+	0.828125f,
+	0.484375f,
+	0.835938f,
+	0.484375f,
+	0.84375f,
+	0.484375f,
+	0.851563f,
+	0.484375f,
+	0.859375f,
+	0.484375f,
+	0.867188f,
+	0.484375f,
+	0.875f,
+	0.484375f,
+	0.882813f,
+	0.484375f,
+	0.890625f,
+	0.484375f,
+	0.898438f,
+	0.484375f,
+	0.90625f,
+	0.484375f,
+	0.914063f,
+	0.484375f,
+	0.921875f,
+	0.484375f,
+	0.929688f,
+	0.484375f,
+	0.9375f,
+	0.484375f,
+	0.945313f,
+	0.484375f,
+	0.953125f,
+	0.484375f,
+	0.960938f,
+	0.484375f,
+	0.96875f,
+	0.484375f,
+	0.976563f,
+	0.484375f,
+	0.984375f,
+	0.484375f,
+	0.992188f,
+	0.484375f,
+	1.0f,
+	0.484375f,
+	0.507813f,
+	0.492188f,
+	0.515625f,
+	0.492188f,
+	0.523438f,
+	0.492188f,
+	0.53125f,
+	0.492188f,
+	0.539063f,
+	0.492188f,
+	0.546875f,
+	0.492188f,
+	0.554688f,
+	0.492188f,
+	0.5625f,
+	0.492188f,
+	0.570313f,
+	0.492188f,
+	0.578125f,
+	0.492188f,
+	0.585938f,
+	0.492188f,
+	0.59375f,
+	0.492188f,
+	0.601563f,
+	0.492188f,
+	0.609375f,
+	0.492188f,
+	0.617188f,
+	0.492188f,
+	0.625f,
+	0.492188f,
+	0.632813f,
+	0.492188f,
+	0.640625f,
+	0.492188f,
+	0.648438f,
+	0.492188f,
+	0.65625f,
+	0.492188f,
+	0.664063f,
+	0.492188f,
+	0.671875f,
+	0.492188f,
+	0.679688f,
+	0.492188f,
+	0.6875f,
+	0.492188f,
+	0.695313f,
+	0.492188f,
+	0.703125f,
+	0.492188f,
+	0.710938f,
+	0.492188f,
+	0.71875f,
+	0.492188f,
+	0.726563f,
+	0.492188f,
+	0.734375f,
+	0.492188f,
+	0.742188f,
+	0.492188f,
+	0.75f,
+	0.492188f,
+	0.757813f,
+	0.492188f,
+	0.765625f,
+	0.492188f,
+	0.773438f,
+	0.492188f,
+	0.78125f,
+	0.492188f,
+	0.789063f,
+	0.492188f,
+	0.796875f,
+	0.492188f,
+	0.804688f,
+	0.492188f,
+	0.8125f,
+	0.492188f,
+	0.820313f,
+	0.492188f,
+	0.828125f,
+	0.492188f,
+	0.835938f,
+	0.492188f,
+	0.84375f,
+	0.492188f,
+	0.851563f,
+	0.492188f,
+	0.859375f,
+	0.492188f,
+	0.867188f,
+	0.492188f,
+	0.875f,
+	0.492188f,
+	0.882813f,
+	0.492188f,
+	0.890625f,
+	0.492188f,
+	0.898438f,
+	0.492188f,
+	0.90625f,
+	0.492188f,
+	0.914063f,
+	0.492188f,
+	0.921875f,
+	0.492188f,
+	0.929688f,
+	0.492188f,
+	0.9375f,
+	0.492188f,
+	0.945313f,
+	0.492188f,
+	0.953125f,
+	0.492188f,
+	0.960938f,
+	0.492188f,
+	0.96875f,
+	0.492188f,
+	0.976563f,
+	0.492188f,
+	0.984375f,
+	0.492188f,
+	0.992188f,
+	0.492188f,
+	1.0f,
+	0.492188f,
+};
+
+unsigned short Landscape04Idx[] = {
+	0,
+	1,
+	2,
+	3,
+	2,
+	1,
+	2,
+	3,
+	4,
+	5,
+	4,
+	3,
+	4,
+	5,
+	6,
+	7,
+	6,
+	5,
+	6,
+	7,
+	8,
+	9,
+	8,
+	7,
+	8,
+	9,
+	10,
+	11,
+	10,
+	9,
+	10,
+	11,
+	12,
+	13,
+	12,
+	11,
+	12,
+	13,
+	14,
+	15,
+	14,
+	13,
+	14,
+	15,
+	16,
+	17,
+	16,
+	15,
+	16,
+	17,
+	18,
+	19,
+	18,
+	17,
+	18,
+	19,
+	20,
+	21,
+	20,
+	19,
+	20,
+	21,
+	22,
+	23,
+	22,
+	21,
+	22,
+	23,
+	24,
+	25,
+	24,
+	23,
+	24,
+	25,
+	26,
+	27,
+	26,
+	25,
+	26,
+	27,
+	28,
+	29,
+	28,
+	27,
+	28,
+	29,
+	30,
+	31,
+	30,
+	29,
+	30,
+	31,
+	32,
+	33,
+	32,
+	31,
+	32,
+	33,
+	34,
+	35,
+	34,
+	33,
+	34,
+	35,
+	36,
+	37,
+	36,
+	35,
+	36,
+	37,
+	38,
+	39,
+	38,
+	37,
+	38,
+	39,
+	40,
+	41,
+	40,
+	39,
+	40,
+	41,
+	42,
+	43,
+	42,
+	41,
+	42,
+	43,
+	44,
+	45,
+	44,
+	43,
+	44,
+	45,
+	46,
+	47,
+	46,
+	45,
+	46,
+	47,
+	48,
+	49,
+	48,
+	47,
+	48,
+	49,
+	50,
+	51,
+	50,
+	49,
+	50,
+	51,
+	52,
+	53,
+	52,
+	51,
+	52,
+	53,
+	54,
+	55,
+	54,
+	53,
+	54,
+	55,
+	56,
+	57,
+	56,
+	55,
+	56,
+	57,
+	58,
+	59,
+	58,
+	57,
+	58,
+	59,
+	60,
+	61,
+	60,
+	59,
+	60,
+	61,
+	62,
+	63,
+	62,
+	61,
+	62,
+	63,
+	64,
+	65,
+	64,
+	63,
+	64,
+	65,
+	66,
+	67,
+	66,
+	65,
+	66,
+	67,
+	68,
+	69,
+	68,
+	67,
+	68,
+	69,
+	70,
+	71,
+	70,
+	69,
+	70,
+	71,
+	72,
+	73,
+	72,
+	71,
+	72,
+	73,
+	74,
+	75,
+	74,
+	73,
+	74,
+	75,
+	76,
+	77,
+	76,
+	75,
+	76,
+	77,
+	78,
+	79,
+	78,
+	77,
+	78,
+	79,
+	80,
+	81,
+	80,
+	79,
+	80,
+	81,
+	82,
+	83,
+	82,
+	81,
+	82,
+	83,
+	84,
+	85,
+	84,
+	83,
+	84,
+	85,
+	86,
+	87,
+	86,
+	85,
+	86,
+	87,
+	88,
+	89,
+	88,
+	87,
+	88,
+	89,
+	90,
+	91,
+	90,
+	89,
+	90,
+	91,
+	92,
+	93,
+	92,
+	91,
+	92,
+	93,
+	94,
+	95,
+	94,
+	93,
+	94,
+	95,
+	96,
+	97,
+	96,
+	95,
+	96,
+	97,
+	98,
+	99,
+	98,
+	97,
+	98,
+	99,
+	100,
+	101,
+	100,
+	99,
+	100,
+	101,
+	102,
+	103,
+	102,
+	101,
+	102,
+	103,
+	104,
+	105,
+	104,
+	103,
+	104,
+	105,
+	106,
+	107,
+	106,
+	105,
+	106,
+	107,
+	108,
+	109,
+	108,
+	107,
+	108,
+	109,
+	110,
+	111,
+	110,
+	109,
+	110,
+	111,
+	112,
+	113,
+	112,
+	111,
+	112,
+	113,
+	114,
+	115,
+	114,
+	113,
+	114,
+	115,
+	116,
+	117,
+	116,
+	115,
+	116,
+	117,
+	118,
+	119,
+	118,
+	117,
+	118,
+	119,
+	120,
+	121,
+	120,
+	119,
+	120,
+	121,
+	122,
+	123,
+	122,
+	121,
+	122,
+	123,
+	124,
+	125,
+	124,
+	123,
+	124,
+	125,
+	126,
+	127,
+	126,
+	125,
+	128,
+	0,
+	129,
+	2,
+	129,
+	0,
+	129,
+	2,
+	130,
+	4,
+	130,
+	2,
+	130,
+	4,
+	131,
+	6,
+	131,
+	4,
+	131,
+	6,
+	132,
+	8,
+	132,
+	6,
+	132,
+	8,
+	133,
+	10,
+	133,
+	8,
+	133,
+	10,
+	134,
+	12,
+	134,
+	10,
+	134,
+	12,
+	135,
+	14,
+	135,
+	12,
+	135,
+	14,
+	136,
+	16,
+	136,
+	14,
+	136,
+	16,
+	137,
+	18,
+	137,
+	16,
+	137,
+	18,
+	138,
+	20,
+	138,
+	18,
+	138,
+	20,
+	139,
+	22,
+	139,
+	20,
+	139,
+	22,
+	140,
+	24,
+	140,
+	22,
+	140,
+	24,
+	141,
+	26,
+	141,
+	24,
+	141,
+	26,
+	142,
+	28,
+	142,
+	26,
+	142,
+	28,
+	143,
+	30,
+	143,
+	28,
+	143,
+	30,
+	144,
+	32,
+	144,
+	30,
+	144,
+	32,
+	145,
+	34,
+	145,
+	32,
+	145,
+	34,
+	146,
+	36,
+	146,
+	34,
+	146,
+	36,
+	147,
+	38,
+	147,
+	36,
+	147,
+	38,
+	148,
+	40,
+	148,
+	38,
+	148,
+	40,
+	149,
+	42,
+	149,
+	40,
+	149,
+	42,
+	150,
+	44,
+	150,
+	42,
+	150,
+	44,
+	151,
+	46,
+	151,
+	44,
+	151,
+	46,
+	152,
+	48,
+	152,
+	46,
+	152,
+	48,
+	153,
+	50,
+	153,
+	48,
+	153,
+	50,
+	154,
+	52,
+	154,
+	50,
+	154,
+	52,
+	155,
+	54,
+	155,
+	52,
+	155,
+	54,
+	156,
+	56,
+	156,
+	54,
+	156,
+	56,
+	157,
+	58,
+	157,
+	56,
+	157,
+	58,
+	158,
+	60,
+	158,
+	58,
+	158,
+	60,
+	159,
+	62,
+	159,
+	60,
+	159,
+	62,
+	160,
+	64,
+	160,
+	62,
+	160,
+	64,
+	161,
+	66,
+	161,
+	64,
+	161,
+	66,
+	162,
+	68,
+	162,
+	66,
+	162,
+	68,
+	163,
+	70,
+	163,
+	68,
+	163,
+	70,
+	164,
+	72,
+	164,
+	70,
+	164,
+	72,
+	165,
+	74,
+	165,
+	72,
+	165,
+	74,
+	166,
+	76,
+	166,
+	74,
+	166,
+	76,
+	167,
+	78,
+	167,
+	76,
+	167,
+	78,
+	168,
+	80,
+	168,
+	78,
+	168,
+	80,
+	169,
+	82,
+	169,
+	80,
+	169,
+	82,
+	170,
+	84,
+	170,
+	82,
+	170,
+	84,
+	171,
+	86,
+	171,
+	84,
+	171,
+	86,
+	172,
+	88,
+	172,
+	86,
+	172,
+	88,
+	173,
+	90,
+	173,
+	88,
+	173,
+	90,
+	174,
+	92,
+	174,
+	90,
+	174,
+	92,
+	175,
+	94,
+	175,
+	92,
+	175,
+	94,
+	176,
+	96,
+	176,
+	94,
+	176,
+	96,
+	177,
+	98,
+	177,
+	96,
+	177,
+	98,
+	178,
+	100,
+	178,
+	98,
+	178,
+	100,
+	179,
+	102,
+	179,
+	100,
+	179,
+	102,
+	180,
+	104,
+	180,
+	102,
+	180,
+	104,
+	181,
+	106,
+	181,
+	104,
+	181,
+	106,
+	182,
+	108,
+	182,
+	106,
+	182,
+	108,
+	183,
+	110,
+	183,
+	108,
+	183,
+	110,
+	184,
+	112,
+	184,
+	110,
+	184,
+	112,
+	185,
+	114,
+	185,
+	112,
+	185,
+	114,
+	186,
+	116,
+	186,
+	114,
+	186,
+	116,
+	187,
+	118,
+	187,
+	116,
+	187,
+	118,
+	188,
+	120,
+	188,
+	118,
+	188,
+	120,
+	189,
+	122,
+	189,
+	120,
+	189,
+	122,
+	190,
+	124,
+	190,
+	122,
+	190,
+	124,
+	191,
+	126,
+	191,
+	124,
+	192,
+	128,
+	193,
+	129,
+	193,
+	128,
+	193,
+	129,
+	194,
+	130,
+	194,
+	129,
+	194,
+	130,
+	195,
+	131,
+	195,
+	130,
+	195,
+	131,
+	196,
+	132,
+	196,
+	131,
+	196,
+	132,
+	197,
+	133,
+	197,
+	132,
+	197,
+	133,
+	198,
+	134,
+	198,
+	133,
+	198,
+	134,
+	199,
+	135,
+	199,
+	134,
+	199,
+	135,
+	200,
+	136,
+	200,
+	135,
+	200,
+	136,
+	201,
+	137,
+	201,
+	136,
+	201,
+	137,
+	202,
+	138,
+	202,
+	137,
+	202,
+	138,
+	203,
+	139,
+	203,
+	138,
+	203,
+	139,
+	204,
+	140,
+	204,
+	139,
+	204,
+	140,
+	205,
+	141,
+	205,
+	140,
+	205,
+	141,
+	206,
+	142,
+	206,
+	141,
+	206,
+	142,
+	207,
+	143,
+	207,
+	142,
+	207,
+	143,
+	208,
+	144,
+	208,
+	143,
+	208,
+	144,
+	209,
+	145,
+	209,
+	144,
+	209,
+	145,
+	210,
+	146,
+	210,
+	145,
+	210,
+	146,
+	211,
+	147,
+	211,
+	146,
+	211,
+	147,
+	212,
+	148,
+	212,
+	147,
+	212,
+	148,
+	213,
+	149,
+	213,
+	148,
+	213,
+	149,
+	214,
+	150,
+	214,
+	149,
+	214,
+	150,
+	215,
+	151,
+	215,
+	150,
+	215,
+	151,
+	216,
+	152,
+	216,
+	151,
+	216,
+	152,
+	217,
+	153,
+	217,
+	152,
+	217,
+	153,
+	218,
+	154,
+	218,
+	153,
+	218,
+	154,
+	219,
+	155,
+	219,
+	154,
+	219,
+	155,
+	220,
+	156,
+	220,
+	155,
+	220,
+	156,
+	221,
+	157,
+	221,
+	156,
+	221,
+	157,
+	222,
+	158,
+	222,
+	157,
+	222,
+	158,
+	223,
+	159,
+	223,
+	158,
+	223,
+	159,
+	224,
+	160,
+	224,
+	159,
+	224,
+	160,
+	225,
+	161,
+	225,
+	160,
+	225,
+	161,
+	226,
+	162,
+	226,
+	161,
+	226,
+	162,
+	227,
+	163,
+	227,
+	162,
+	227,
+	163,
+	228,
+	164,
+	228,
+	163,
+	228,
+	164,
+	229,
+	165,
+	229,
+	164,
+	229,
+	165,
+	230,
+	166,
+	230,
+	165,
+	230,
+	166,
+	231,
+	167,
+	231,
+	166,
+	231,
+	167,
+	232,
+	168,
+	232,
+	167,
+	232,
+	168,
+	233,
+	169,
+	233,
+	168,
+	233,
+	169,
+	234,
+	170,
+	234,
+	169,
+	234,
+	170,
+	235,
+	171,
+	235,
+	170,
+	235,
+	171,
+	236,
+	172,
+	236,
+	171,
+	236,
+	172,
+	237,
+	173,
+	237,
+	172,
+	237,
+	173,
+	238,
+	174,
+	238,
+	173,
+	238,
+	174,
+	239,
+	175,
+	239,
+	174,
+	239,
+	175,
+	240,
+	176,
+	240,
+	175,
+	240,
+	176,
+	241,
+	177,
+	241,
+	176,
+	241,
+	177,
+	242,
+	178,
+	242,
+	177,
+	242,
+	178,
+	243,
+	179,
+	243,
+	178,
+	243,
+	179,
+	244,
+	180,
+	244,
+	179,
+	244,
+	180,
+	245,
+	181,
+	245,
+	180,
+	245,
+	181,
+	246,
+	182,
+	246,
+	181,
+	246,
+	182,
+	247,
+	183,
+	247,
+	182,
+	247,
+	183,
+	248,
+	184,
+	248,
+	183,
+	248,
+	184,
+	249,
+	185,
+	249,
+	184,
+	249,
+	185,
+	250,
+	186,
+	250,
+	185,
+	250,
+	186,
+	251,
+	187,
+	251,
+	186,
+	251,
+	187,
+	252,
+	188,
+	252,
+	187,
+	252,
+	188,
+	253,
+	189,
+	253,
+	188,
+	253,
+	189,
+	254,
+	190,
+	254,
+	189,
+	254,
+	190,
+	255,
+	191,
+	255,
+	190,
+	256,
+	192,
+	257,
+	193,
+	257,
+	192,
+	257,
+	193,
+	258,
+	194,
+	258,
+	193,
+	258,
+	194,
+	259,
+	195,
+	259,
+	194,
+	259,
+	195,
+	260,
+	196,
+	260,
+	195,
+	260,
+	196,
+	261,
+	197,
+	261,
+	196,
+	261,
+	197,
+	262,
+	198,
+	262,
+	197,
+	262,
+	198,
+	263,
+	199,
+	263,
+	198,
+	263,
+	199,
+	264,
+	200,
+	264,
+	199,
+	264,
+	200,
+	265,
+	201,
+	265,
+	200,
+	265,
+	201,
+	266,
+	202,
+	266,
+	201,
+	266,
+	202,
+	267,
+	203,
+	267,
+	202,
+	267,
+	203,
+	268,
+	204,
+	268,
+	203,
+	268,
+	204,
+	269,
+	205,
+	269,
+	204,
+	269,
+	205,
+	270,
+	206,
+	270,
+	205,
+	270,
+	206,
+	271,
+	207,
+	271,
+	206,
+	271,
+	207,
+	272,
+	208,
+	272,
+	207,
+	272,
+	208,
+	273,
+	209,
+	273,
+	208,
+	273,
+	209,
+	274,
+	210,
+	274,
+	209,
+	274,
+	210,
+	275,
+	211,
+	275,
+	210,
+	275,
+	211,
+	276,
+	212,
+	276,
+	211,
+	276,
+	212,
+	277,
+	213,
+	277,
+	212,
+	277,
+	213,
+	278,
+	214,
+	278,
+	213,
+	278,
+	214,
+	279,
+	215,
+	279,
+	214,
+	279,
+	215,
+	280,
+	216,
+	280,
+	215,
+	280,
+	216,
+	281,
+	217,
+	281,
+	216,
+	281,
+	217,
+	282,
+	218,
+	282,
+	217,
+	282,
+	218,
+	283,
+	219,
+	283,
+	218,
+	283,
+	219,
+	284,
+	220,
+	284,
+	219,
+	284,
+	220,
+	285,
+	221,
+	285,
+	220,
+	285,
+	221,
+	286,
+	222,
+	286,
+	221,
+	286,
+	222,
+	287,
+	223,
+	287,
+	222,
+	287,
+	223,
+	288,
+	224,
+	288,
+	223,
+	288,
+	224,
+	289,
+	225,
+	289,
+	224,
+	289,
+	225,
+	290,
+	226,
+	290,
+	225,
+	290,
+	226,
+	291,
+	227,
+	291,
+	226,
+	291,
+	227,
+	292,
+	228,
+	292,
+	227,
+	292,
+	228,
+	293,
+	229,
+	293,
+	228,
+	293,
+	229,
+	294,
+	230,
+	294,
+	229,
+	294,
+	230,
+	295,
+	231,
+	295,
+	230,
+	295,
+	231,
+	296,
+	232,
+	296,
+	231,
+	296,
+	232,
+	297,
+	233,
+	297,
+	232,
+	297,
+	233,
+	298,
+	234,
+	298,
+	233,
+	298,
+	234,
+	299,
+	235,
+	299,
+	234,
+	299,
+	235,
+	300,
+	236,
+	300,
+	235,
+	300,
+	236,
+	301,
+	237,
+	301,
+	236,
+	301,
+	237,
+	302,
+	238,
+	302,
+	237,
+	302,
+	238,
+	303,
+	239,
+	303,
+	238,
+	303,
+	239,
+	304,
+	240,
+	304,
+	239,
+	304,
+	240,
+	305,
+	241,
+	305,
+	240,
+	305,
+	241,
+	306,
+	242,
+	306,
+	241,
+	306,
+	242,
+	307,
+	243,
+	307,
+	242,
+	307,
+	243,
+	308,
+	244,
+	308,
+	243,
+	308,
+	244,
+	309,
+	245,
+	309,
+	244,
+	309,
+	245,
+	310,
+	246,
+	310,
+	245,
+	310,
+	246,
+	311,
+	247,
+	311,
+	246,
+	311,
+	247,
+	312,
+	248,
+	312,
+	247,
+	312,
+	248,
+	313,
+	249,
+	313,
+	248,
+	313,
+	249,
+	314,
+	250,
+	314,
+	249,
+	314,
+	250,
+	315,
+	251,
+	315,
+	250,
+	315,
+	251,
+	316,
+	252,
+	316,
+	251,
+	316,
+	252,
+	317,
+	253,
+	317,
+	252,
+	317,
+	253,
+	318,
+	254,
+	318,
+	253,
+	318,
+	254,
+	319,
+	255,
+	319,
+	254,
+	320,
+	256,
+	321,
+	257,
+	321,
+	256,
+	321,
+	257,
+	322,
+	258,
+	322,
+	257,
+	322,
+	258,
+	323,
+	259,
+	323,
+	258,
+	323,
+	259,
+	324,
+	260,
+	324,
+	259,
+	324,
+	260,
+	325,
+	261,
+	325,
+	260,
+	325,
+	261,
+	326,
+	262,
+	326,
+	261,
+	326,
+	262,
+	327,
+	263,
+	327,
+	262,
+	327,
+	263,
+	328,
+	264,
+	328,
+	263,
+	328,
+	264,
+	329,
+	265,
+	329,
+	264,
+	329,
+	265,
+	330,
+	266,
+	330,
+	265,
+	330,
+	266,
+	331,
+	267,
+	331,
+	266,
+	331,
+	267,
+	332,
+	268,
+	332,
+	267,
+	332,
+	268,
+	333,
+	269,
+	333,
+	268,
+	333,
+	269,
+	334,
+	270,
+	334,
+	269,
+	334,
+	270,
+	335,
+	271,
+	335,
+	270,
+	335,
+	271,
+	336,
+	272,
+	336,
+	271,
+	336,
+	272,
+	337,
+	273,
+	337,
+	272,
+	337,
+	273,
+	338,
+	274,
+	338,
+	273,
+	338,
+	274,
+	339,
+	275,
+	339,
+	274,
+	339,
+	275,
+	340,
+	276,
+	340,
+	275,
+	340,
+	276,
+	341,
+	277,
+	341,
+	276,
+	341,
+	277,
+	342,
+	278,
+	342,
+	277,
+	342,
+	278,
+	343,
+	279,
+	343,
+	278,
+	343,
+	279,
+	344,
+	280,
+	344,
+	279,
+	344,
+	280,
+	345,
+	281,
+	345,
+	280,
+	345,
+	281,
+	346,
+	282,
+	346,
+	281,
+	346,
+	282,
+	347,
+	283,
+	347,
+	282,
+	347,
+	283,
+	348,
+	284,
+	348,
+	283,
+	348,
+	284,
+	349,
+	285,
+	349,
+	284,
+	349,
+	285,
+	350,
+	286,
+	350,
+	285,
+	350,
+	286,
+	351,
+	287,
+	351,
+	286,
+	351,
+	287,
+	352,
+	288,
+	352,
+	287,
+	352,
+	288,
+	353,
+	289,
+	353,
+	288,
+	353,
+	289,
+	354,
+	290,
+	354,
+	289,
+	354,
+	290,
+	355,
+	291,
+	355,
+	290,
+	355,
+	291,
+	356,
+	292,
+	356,
+	291,
+	356,
+	292,
+	357,
+	293,
+	357,
+	292,
+	357,
+	293,
+	358,
+	294,
+	358,
+	293,
+	358,
+	294,
+	359,
+	295,
+	359,
+	294,
+	359,
+	295,
+	360,
+	296,
+	360,
+	295,
+	360,
+	296,
+	361,
+	297,
+	361,
+	296,
+	361,
+	297,
+	362,
+	298,
+	362,
+	297,
+	362,
+	298,
+	363,
+	299,
+	363,
+	298,
+	363,
+	299,
+	364,
+	300,
+	364,
+	299,
+	364,
+	300,
+	365,
+	301,
+	365,
+	300,
+	365,
+	301,
+	366,
+	302,
+	366,
+	301,
+	366,
+	302,
+	367,
+	303,
+	367,
+	302,
+	367,
+	303,
+	368,
+	304,
+	368,
+	303,
+	368,
+	304,
+	369,
+	305,
+	369,
+	304,
+	369,
+	305,
+	370,
+	306,
+	370,
+	305,
+	370,
+	306,
+	371,
+	307,
+	371,
+	306,
+	371,
+	307,
+	372,
+	308,
+	372,
+	307,
+	372,
+	308,
+	373,
+	309,
+	373,
+	308,
+	373,
+	309,
+	374,
+	310,
+	374,
+	309,
+	374,
+	310,
+	375,
+	311,
+	375,
+	310,
+	375,
+	311,
+	376,
+	312,
+	376,
+	311,
+	376,
+	312,
+	377,
+	313,
+	377,
+	312,
+	377,
+	313,
+	378,
+	314,
+	378,
+	313,
+	378,
+	314,
+	379,
+	315,
+	379,
+	314,
+	379,
+	315,
+	380,
+	316,
+	380,
+	315,
+	380,
+	316,
+	381,
+	317,
+	381,
+	316,
+	381,
+	317,
+	382,
+	318,
+	382,
+	317,
+	382,
+	318,
+	383,
+	319,
+	383,
+	318,
+	384,
+	320,
+	385,
+	321,
+	385,
+	320,
+	385,
+	321,
+	386,
+	322,
+	386,
+	321,
+	386,
+	322,
+	387,
+	323,
+	387,
+	322,
+	387,
+	323,
+	388,
+	324,
+	388,
+	323,
+	388,
+	324,
+	389,
+	325,
+	389,
+	324,
+	389,
+	325,
+	390,
+	326,
+	390,
+	325,
+	390,
+	326,
+	391,
+	327,
+	391,
+	326,
+	391,
+	327,
+	392,
+	328,
+	392,
+	327,
+	392,
+	328,
+	393,
+	329,
+	393,
+	328,
+	393,
+	329,
+	394,
+	330,
+	394,
+	329,
+	394,
+	330,
+	395,
+	331,
+	395,
+	330,
+	395,
+	331,
+	396,
+	332,
+	396,
+	331,
+	396,
+	332,
+	397,
+	333,
+	397,
+	332,
+	397,
+	333,
+	398,
+	334,
+	398,
+	333,
+	398,
+	334,
+	399,
+	335,
+	399,
+	334,
+	399,
+	335,
+	400,
+	336,
+	400,
+	335,
+	400,
+	336,
+	401,
+	337,
+	401,
+	336,
+	401,
+	337,
+	402,
+	338,
+	402,
+	337,
+	402,
+	338,
+	403,
+	339,
+	403,
+	338,
+	403,
+	339,
+	404,
+	340,
+	404,
+	339,
+	404,
+	340,
+	405,
+	341,
+	405,
+	340,
+	405,
+	341,
+	406,
+	342,
+	406,
+	341,
+	406,
+	342,
+	407,
+	343,
+	407,
+	342,
+	407,
+	343,
+	408,
+	344,
+	408,
+	343,
+	408,
+	344,
+	409,
+	345,
+	409,
+	344,
+	409,
+	345,
+	410,
+	346,
+	410,
+	345,
+	410,
+	346,
+	411,
+	347,
+	411,
+	346,
+	411,
+	347,
+	412,
+	348,
+	412,
+	347,
+	412,
+	348,
+	413,
+	349,
+	413,
+	348,
+	413,
+	349,
+	414,
+	350,
+	414,
+	349,
+	414,
+	350,
+	415,
+	351,
+	415,
+	350,
+	415,
+	351,
+	416,
+	352,
+	416,
+	351,
+	416,
+	352,
+	417,
+	353,
+	417,
+	352,
+	417,
+	353,
+	418,
+	354,
+	418,
+	353,
+	418,
+	354,
+	419,
+	355,
+	419,
+	354,
+	419,
+	355,
+	420,
+	356,
+	420,
+	355,
+	420,
+	356,
+	421,
+	357,
+	421,
+	356,
+	421,
+	357,
+	422,
+	358,
+	422,
+	357,
+	422,
+	358,
+	423,
+	359,
+	423,
+	358,
+	423,
+	359,
+	424,
+	360,
+	424,
+	359,
+	424,
+	360,
+	425,
+	361,
+	425,
+	360,
+	425,
+	361,
+	426,
+	362,
+	426,
+	361,
+	426,
+	362,
+	427,
+	363,
+	427,
+	362,
+	427,
+	363,
+	428,
+	364,
+	428,
+	363,
+	428,
+	364,
+	429,
+	365,
+	429,
+	364,
+	429,
+	365,
+	430,
+	366,
+	430,
+	365,
+	430,
+	366,
+	431,
+	367,
+	431,
+	366,
+	431,
+	367,
+	432,
+	368,
+	432,
+	367,
+	432,
+	368,
+	433,
+	369,
+	433,
+	368,
+	433,
+	369,
+	434,
+	370,
+	434,
+	369,
+	434,
+	370,
+	435,
+	371,
+	435,
+	370,
+	435,
+	371,
+	436,
+	372,
+	436,
+	371,
+	436,
+	372,
+	437,
+	373,
+	437,
+	372,
+	437,
+	373,
+	438,
+	374,
+	438,
+	373,
+	438,
+	374,
+	439,
+	375,
+	439,
+	374,
+	439,
+	375,
+	440,
+	376,
+	440,
+	375,
+	440,
+	376,
+	441,
+	377,
+	441,
+	376,
+	441,
+	377,
+	442,
+	378,
+	442,
+	377,
+	442,
+	378,
+	443,
+	379,
+	443,
+	378,
+	443,
+	379,
+	444,
+	380,
+	444,
+	379,
+	444,
+	380,
+	445,
+	381,
+	445,
+	380,
+	445,
+	381,
+	446,
+	382,
+	446,
+	381,
+	446,
+	382,
+	447,
+	383,
+	447,
+	382,
+	448,
+	384,
+	449,
+	385,
+	449,
+	384,
+	449,
+	385,
+	450,
+	386,
+	450,
+	385,
+	450,
+	386,
+	451,
+	387,
+	451,
+	386,
+	451,
+	387,
+	452,
+	388,
+	452,
+	387,
+	452,
+	388,
+	453,
+	389,
+	453,
+	388,
+	453,
+	389,
+	454,
+	390,
+	454,
+	389,
+	454,
+	390,
+	455,
+	391,
+	455,
+	390,
+	455,
+	391,
+	456,
+	392,
+	456,
+	391,
+	456,
+	392,
+	457,
+	393,
+	457,
+	392,
+	457,
+	393,
+	458,
+	394,
+	458,
+	393,
+	458,
+	394,
+	459,
+	395,
+	459,
+	394,
+	459,
+	395,
+	460,
+	396,
+	460,
+	395,
+	460,
+	396,
+	461,
+	397,
+	461,
+	396,
+	461,
+	397,
+	462,
+	398,
+	462,
+	397,
+	462,
+	398,
+	463,
+	399,
+	463,
+	398,
+	463,
+	399,
+	464,
+	400,
+	464,
+	399,
+	464,
+	400,
+	465,
+	401,
+	465,
+	400,
+	465,
+	401,
+	466,
+	402,
+	466,
+	401,
+	466,
+	402,
+	467,
+	403,
+	467,
+	402,
+	467,
+	403,
+	468,
+	404,
+	468,
+	403,
+	468,
+	404,
+	469,
+	405,
+	469,
+	404,
+	469,
+	405,
+	470,
+	406,
+	470,
+	405,
+	470,
+	406,
+	471,
+	407,
+	471,
+	406,
+	471,
+	407,
+	472,
+	408,
+	472,
+	407,
+	472,
+	408,
+	473,
+	409,
+	473,
+	408,
+	473,
+	409,
+	474,
+	410,
+	474,
+	409,
+	474,
+	410,
+	475,
+	411,
+	475,
+	410,
+	475,
+	411,
+	476,
+	412,
+	476,
+	411,
+	476,
+	412,
+	477,
+	413,
+	477,
+	412,
+	477,
+	413,
+	478,
+	414,
+	478,
+	413,
+	478,
+	414,
+	479,
+	415,
+	479,
+	414,
+	479,
+	415,
+	480,
+	416,
+	480,
+	415,
+	480,
+	416,
+	481,
+	417,
+	481,
+	416,
+	481,
+	417,
+	482,
+	418,
+	482,
+	417,
+	482,
+	418,
+	483,
+	419,
+	483,
+	418,
+	483,
+	419,
+	484,
+	420,
+	484,
+	419,
+	484,
+	420,
+	485,
+	421,
+	485,
+	420,
+	485,
+	421,
+	486,
+	422,
+	486,
+	421,
+	486,
+	422,
+	487,
+	423,
+	487,
+	422,
+	487,
+	423,
+	488,
+	424,
+	488,
+	423,
+	488,
+	424,
+	489,
+	425,
+	489,
+	424,
+	489,
+	425,
+	490,
+	426,
+	490,
+	425,
+	490,
+	426,
+	491,
+	427,
+	491,
+	426,
+	491,
+	427,
+	492,
+	428,
+	492,
+	427,
+	492,
+	428,
+	493,
+	429,
+	493,
+	428,
+	493,
+	429,
+	494,
+	430,
+	494,
+	429,
+	494,
+	430,
+	495,
+	431,
+	495,
+	430,
+	495,
+	431,
+	496,
+	432,
+	496,
+	431,
+	496,
+	432,
+	497,
+	433,
+	497,
+	432,
+	497,
+	433,
+	498,
+	434,
+	498,
+	433,
+	498,
+	434,
+	499,
+	435,
+	499,
+	434,
+	499,
+	435,
+	500,
+	436,
+	500,
+	435,
+	500,
+	436,
+	501,
+	437,
+	501,
+	436,
+	501,
+	437,
+	502,
+	438,
+	502,
+	437,
+	502,
+	438,
+	503,
+	439,
+	503,
+	438,
+	503,
+	439,
+	504,
+	440,
+	504,
+	439,
+	504,
+	440,
+	505,
+	441,
+	505,
+	440,
+	505,
+	441,
+	506,
+	442,
+	506,
+	441,
+	506,
+	442,
+	507,
+	443,
+	507,
+	442,
+	507,
+	443,
+	508,
+	444,
+	508,
+	443,
+	508,
+	444,
+	509,
+	445,
+	509,
+	444,
+	509,
+	445,
+	510,
+	446,
+	510,
+	445,
+	510,
+	446,
+	511,
+	447,
+	511,
+	446,
+	512,
+	448,
+	513,
+	449,
+	513,
+	448,
+	513,
+	449,
+	514,
+	450,
+	514,
+	449,
+	514,
+	450,
+	515,
+	451,
+	515,
+	450,
+	515,
+	451,
+	516,
+	452,
+	516,
+	451,
+	516,
+	452,
+	517,
+	453,
+	517,
+	452,
+	517,
+	453,
+	518,
+	454,
+	518,
+	453,
+	518,
+	454,
+	519,
+	455,
+	519,
+	454,
+	519,
+	455,
+	520,
+	456,
+	520,
+	455,
+	520,
+	456,
+	521,
+	457,
+	521,
+	456,
+	521,
+	457,
+	522,
+	458,
+	522,
+	457,
+	522,
+	458,
+	523,
+	459,
+	523,
+	458,
+	523,
+	459,
+	524,
+	460,
+	524,
+	459,
+	524,
+	460,
+	525,
+	461,
+	525,
+	460,
+	525,
+	461,
+	526,
+	462,
+	526,
+	461,
+	526,
+	462,
+	527,
+	463,
+	527,
+	462,
+	527,
+	463,
+	528,
+	464,
+	528,
+	463,
+	528,
+	464,
+	529,
+	465,
+	529,
+	464,
+	529,
+	465,
+	530,
+	466,
+	530,
+	465,
+	530,
+	466,
+	531,
+	467,
+	531,
+	466,
+	531,
+	467,
+	532,
+	468,
+	532,
+	467,
+	532,
+	468,
+	533,
+	469,
+	533,
+	468,
+	533,
+	469,
+	534,
+	470,
+	534,
+	469,
+	534,
+	470,
+	535,
+	471,
+	535,
+	470,
+	535,
+	471,
+	536,
+	472,
+	536,
+	471,
+	536,
+	472,
+	537,
+	473,
+	537,
+	472,
+	537,
+	473,
+	538,
+	474,
+	538,
+	473,
+	538,
+	474,
+	539,
+	475,
+	539,
+	474,
+	539,
+	475,
+	540,
+	476,
+	540,
+	475,
+	540,
+	476,
+	541,
+	477,
+	541,
+	476,
+	541,
+	477,
+	542,
+	478,
+	542,
+	477,
+	542,
+	478,
+	543,
+	479,
+	543,
+	478,
+	543,
+	479,
+	544,
+	480,
+	544,
+	479,
+	544,
+	480,
+	545,
+	481,
+	545,
+	480,
+	545,
+	481,
+	546,
+	482,
+	546,
+	481,
+	546,
+	482,
+	547,
+	483,
+	547,
+	482,
+	547,
+	483,
+	548,
+	484,
+	548,
+	483,
+	548,
+	484,
+	549,
+	485,
+	549,
+	484,
+	549,
+	485,
+	550,
+	486,
+	550,
+	485,
+	550,
+	486,
+	551,
+	487,
+	551,
+	486,
+	551,
+	487,
+	552,
+	488,
+	552,
+	487,
+	552,
+	488,
+	553,
+	489,
+	553,
+	488,
+	553,
+	489,
+	554,
+	490,
+	554,
+	489,
+	554,
+	490,
+	555,
+	491,
+	555,
+	490,
+	555,
+	491,
+	556,
+	492,
+	556,
+	491,
+	556,
+	492,
+	557,
+	493,
+	557,
+	492,
+	557,
+	493,
+	558,
+	494,
+	558,
+	493,
+	558,
+	494,
+	559,
+	495,
+	559,
+	494,
+	559,
+	495,
+	560,
+	496,
+	560,
+	495,
+	560,
+	496,
+	561,
+	497,
+	561,
+	496,
+	561,
+	497,
+	562,
+	498,
+	562,
+	497,
+	562,
+	498,
+	563,
+	499,
+	563,
+	498,
+	563,
+	499,
+	564,
+	500,
+	564,
+	499,
+	564,
+	500,
+	565,
+	501,
+	565,
+	500,
+	565,
+	501,
+	566,
+	502,
+	566,
+	501,
+	566,
+	502,
+	567,
+	503,
+	567,
+	502,
+	567,
+	503,
+	568,
+	504,
+	568,
+	503,
+	568,
+	504,
+	569,
+	505,
+	569,
+	504,
+	569,
+	505,
+	570,
+	506,
+	570,
+	505,
+	570,
+	506,
+	571,
+	507,
+	571,
+	506,
+	571,
+	507,
+	572,
+	508,
+	572,
+	507,
+	572,
+	508,
+	573,
+	509,
+	573,
+	508,
+	573,
+	509,
+	574,
+	510,
+	574,
+	509,
+	574,
+	510,
+	575,
+	511,
+	575,
+	510,
+	576,
+	512,
+	577,
+	513,
+	577,
+	512,
+	577,
+	513,
+	578,
+	514,
+	578,
+	513,
+	578,
+	514,
+	579,
+	515,
+	579,
+	514,
+	579,
+	515,
+	580,
+	516,
+	580,
+	515,
+	580,
+	516,
+	581,
+	517,
+	581,
+	516,
+	581,
+	517,
+	582,
+	518,
+	582,
+	517,
+	582,
+	518,
+	583,
+	519,
+	583,
+	518,
+	583,
+	519,
+	584,
+	520,
+	584,
+	519,
+	584,
+	520,
+	585,
+	521,
+	585,
+	520,
+	585,
+	521,
+	586,
+	522,
+	586,
+	521,
+	586,
+	522,
+	587,
+	523,
+	587,
+	522,
+	587,
+	523,
+	588,
+	524,
+	588,
+	523,
+	588,
+	524,
+	589,
+	525,
+	589,
+	524,
+	589,
+	525,
+	590,
+	526,
+	590,
+	525,
+	590,
+	526,
+	591,
+	527,
+	591,
+	526,
+	591,
+	527,
+	592,
+	528,
+	592,
+	527,
+	592,
+	528,
+	593,
+	529,
+	593,
+	528,
+	593,
+	529,
+	594,
+	530,
+	594,
+	529,
+	594,
+	530,
+	595,
+	531,
+	595,
+	530,
+	595,
+	531,
+	596,
+	532,
+	596,
+	531,
+	596,
+	532,
+	597,
+	533,
+	597,
+	532,
+	597,
+	533,
+	598,
+	534,
+	598,
+	533,
+	598,
+	534,
+	599,
+	535,
+	599,
+	534,
+	599,
+	535,
+	600,
+	536,
+	600,
+	535,
+	600,
+	536,
+	601,
+	537,
+	601,
+	536,
+	601,
+	537,
+	602,
+	538,
+	602,
+	537,
+	602,
+	538,
+	603,
+	539,
+	603,
+	538,
+	603,
+	539,
+	604,
+	540,
+	604,
+	539,
+	604,
+	540,
+	605,
+	541,
+	605,
+	540,
+	605,
+	541,
+	606,
+	542,
+	606,
+	541,
+	606,
+	542,
+	607,
+	543,
+	607,
+	542,
+	607,
+	543,
+	608,
+	544,
+	608,
+	543,
+	608,
+	544,
+	609,
+	545,
+	609,
+	544,
+	609,
+	545,
+	610,
+	546,
+	610,
+	545,
+	610,
+	546,
+	611,
+	547,
+	611,
+	546,
+	611,
+	547,
+	612,
+	548,
+	612,
+	547,
+	612,
+	548,
+	613,
+	549,
+	613,
+	548,
+	613,
+	549,
+	614,
+	550,
+	614,
+	549,
+	614,
+	550,
+	615,
+	551,
+	615,
+	550,
+	615,
+	551,
+	616,
+	552,
+	616,
+	551,
+	616,
+	552,
+	617,
+	553,
+	617,
+	552,
+	617,
+	553,
+	618,
+	554,
+	618,
+	553,
+	618,
+	554,
+	619,
+	555,
+	619,
+	554,
+	619,
+	555,
+	620,
+	556,
+	620,
+	555,
+	620,
+	556,
+	621,
+	557,
+	621,
+	556,
+	621,
+	557,
+	622,
+	558,
+	622,
+	557,
+	622,
+	558,
+	623,
+	559,
+	623,
+	558,
+	623,
+	559,
+	624,
+	560,
+	624,
+	559,
+	624,
+	560,
+	625,
+	561,
+	625,
+	560,
+	625,
+	561,
+	626,
+	562,
+	626,
+	561,
+	626,
+	562,
+	627,
+	563,
+	627,
+	562,
+	627,
+	563,
+	628,
+	564,
+	628,
+	563,
+	628,
+	564,
+	629,
+	565,
+	629,
+	564,
+	629,
+	565,
+	630,
+	566,
+	630,
+	565,
+	630,
+	566,
+	631,
+	567,
+	631,
+	566,
+	631,
+	567,
+	632,
+	568,
+	632,
+	567,
+	632,
+	568,
+	633,
+	569,
+	633,
+	568,
+	633,
+	569,
+	634,
+	570,
+	634,
+	569,
+	634,
+	570,
+	635,
+	571,
+	635,
+	570,
+	635,
+	571,
+	636,
+	572,
+	636,
+	571,
+	636,
+	572,
+	637,
+	573,
+	637,
+	572,
+	637,
+	573,
+	638,
+	574,
+	638,
+	573,
+	638,
+	574,
+	639,
+	575,
+	639,
+	574,
+	640,
+	576,
+	641,
+	577,
+	641,
+	576,
+	641,
+	577,
+	642,
+	578,
+	642,
+	577,
+	642,
+	578,
+	643,
+	579,
+	643,
+	578,
+	643,
+	579,
+	644,
+	580,
+	644,
+	579,
+	644,
+	580,
+	645,
+	581,
+	645,
+	580,
+	645,
+	581,
+	646,
+	582,
+	646,
+	581,
+	646,
+	582,
+	647,
+	583,
+	647,
+	582,
+	647,
+	583,
+	648,
+	584,
+	648,
+	583,
+	648,
+	584,
+	649,
+	585,
+	649,
+	584,
+	649,
+	585,
+	650,
+	586,
+	650,
+	585,
+	650,
+	586,
+	651,
+	587,
+	651,
+	586,
+	651,
+	587,
+	652,
+	588,
+	652,
+	587,
+	652,
+	588,
+	653,
+	589,
+	653,
+	588,
+	653,
+	589,
+	654,
+	590,
+	654,
+	589,
+	654,
+	590,
+	655,
+	591,
+	655,
+	590,
+	655,
+	591,
+	656,
+	592,
+	656,
+	591,
+	656,
+	592,
+	657,
+	593,
+	657,
+	592,
+	657,
+	593,
+	658,
+	594,
+	658,
+	593,
+	658,
+	594,
+	659,
+	595,
+	659,
+	594,
+	659,
+	595,
+	660,
+	596,
+	660,
+	595,
+	660,
+	596,
+	661,
+	597,
+	661,
+	596,
+	661,
+	597,
+	662,
+	598,
+	662,
+	597,
+	662,
+	598,
+	663,
+	599,
+	663,
+	598,
+	663,
+	599,
+	664,
+	600,
+	664,
+	599,
+	664,
+	600,
+	665,
+	601,
+	665,
+	600,
+	665,
+	601,
+	666,
+	602,
+	666,
+	601,
+	666,
+	602,
+	667,
+	603,
+	667,
+	602,
+	667,
+	603,
+	668,
+	604,
+	668,
+	603,
+	668,
+	604,
+	669,
+	605,
+	669,
+	604,
+	669,
+	605,
+	670,
+	606,
+	670,
+	605,
+	670,
+	606,
+	671,
+	607,
+	671,
+	606,
+	671,
+	607,
+	672,
+	608,
+	672,
+	607,
+	672,
+	608,
+	673,
+	609,
+	673,
+	608,
+	673,
+	609,
+	674,
+	610,
+	674,
+	609,
+	674,
+	610,
+	675,
+	611,
+	675,
+	610,
+	675,
+	611,
+	676,
+	612,
+	676,
+	611,
+	676,
+	612,
+	677,
+	613,
+	677,
+	612,
+	677,
+	613,
+	678,
+	614,
+	678,
+	613,
+	678,
+	614,
+	679,
+	615,
+	679,
+	614,
+	679,
+	615,
+	680,
+	616,
+	680,
+	615,
+	680,
+	616,
+	681,
+	617,
+	681,
+	616,
+	681,
+	617,
+	682,
+	618,
+	682,
+	617,
+	682,
+	618,
+	683,
+	619,
+	683,
+	618,
+	683,
+	619,
+	684,
+	620,
+	684,
+	619,
+	684,
+	620,
+	685,
+	621,
+	685,
+	620,
+	685,
+	621,
+	686,
+	622,
+	686,
+	621,
+	686,
+	622,
+	687,
+	623,
+	687,
+	622,
+	687,
+	623,
+	688,
+	624,
+	688,
+	623,
+	688,
+	624,
+	689,
+	625,
+	689,
+	624,
+	689,
+	625,
+	690,
+	626,
+	690,
+	625,
+	690,
+	626,
+	691,
+	627,
+	691,
+	626,
+	691,
+	627,
+	692,
+	628,
+	692,
+	627,
+	692,
+	628,
+	693,
+	629,
+	693,
+	628,
+	693,
+	629,
+	694,
+	630,
+	694,
+	629,
+	694,
+	630,
+	695,
+	631,
+	695,
+	630,
+	695,
+	631,
+	696,
+	632,
+	696,
+	631,
+	696,
+	632,
+	697,
+	633,
+	697,
+	632,
+	697,
+	633,
+	698,
+	634,
+	698,
+	633,
+	698,
+	634,
+	699,
+	635,
+	699,
+	634,
+	699,
+	635,
+	700,
+	636,
+	700,
+	635,
+	700,
+	636,
+	701,
+	637,
+	701,
+	636,
+	701,
+	637,
+	702,
+	638,
+	702,
+	637,
+	702,
+	638,
+	703,
+	639,
+	703,
+	638,
+	704,
+	640,
+	705,
+	641,
+	705,
+	640,
+	705,
+	641,
+	706,
+	642,
+	706,
+	641,
+	706,
+	642,
+	707,
+	643,
+	707,
+	642,
+	707,
+	643,
+	708,
+	644,
+	708,
+	643,
+	708,
+	644,
+	709,
+	645,
+	709,
+	644,
+	709,
+	645,
+	710,
+	646,
+	710,
+	645,
+	710,
+	646,
+	711,
+	647,
+	711,
+	646,
+	711,
+	647,
+	712,
+	648,
+	712,
+	647,
+	712,
+	648,
+	713,
+	649,
+	713,
+	648,
+	713,
+	649,
+	714,
+	650,
+	714,
+	649,
+	714,
+	650,
+	715,
+	651,
+	715,
+	650,
+	715,
+	651,
+	716,
+	652,
+	716,
+	651,
+	716,
+	652,
+	717,
+	653,
+	717,
+	652,
+	717,
+	653,
+	718,
+	654,
+	718,
+	653,
+	718,
+	654,
+	719,
+	655,
+	719,
+	654,
+	719,
+	655,
+	720,
+	656,
+	720,
+	655,
+	720,
+	656,
+	721,
+	657,
+	721,
+	656,
+	721,
+	657,
+	722,
+	658,
+	722,
+	657,
+	722,
+	658,
+	723,
+	659,
+	723,
+	658,
+	723,
+	659,
+	724,
+	660,
+	724,
+	659,
+	724,
+	660,
+	725,
+	661,
+	725,
+	660,
+	725,
+	661,
+	726,
+	662,
+	726,
+	661,
+	726,
+	662,
+	727,
+	663,
+	727,
+	662,
+	727,
+	663,
+	728,
+	664,
+	728,
+	663,
+	728,
+	664,
+	729,
+	665,
+	729,
+	664,
+	729,
+	665,
+	730,
+	666,
+	730,
+	665,
+	730,
+	666,
+	731,
+	667,
+	731,
+	666,
+	731,
+	667,
+	732,
+	668,
+	732,
+	667,
+	732,
+	668,
+	733,
+	669,
+	733,
+	668,
+	733,
+	669,
+	734,
+	670,
+	734,
+	669,
+	734,
+	670,
+	735,
+	671,
+	735,
+	670,
+	735,
+	671,
+	736,
+	672,
+	736,
+	671,
+	736,
+	672,
+	737,
+	673,
+	737,
+	672,
+	737,
+	673,
+	738,
+	674,
+	738,
+	673,
+	738,
+	674,
+	739,
+	675,
+	739,
+	674,
+	739,
+	675,
+	740,
+	676,
+	740,
+	675,
+	740,
+	676,
+	741,
+	677,
+	741,
+	676,
+	741,
+	677,
+	742,
+	678,
+	742,
+	677,
+	742,
+	678,
+	743,
+	679,
+	743,
+	678,
+	743,
+	679,
+	744,
+	680,
+	744,
+	679,
+	744,
+	680,
+	745,
+	681,
+	745,
+	680,
+	745,
+	681,
+	746,
+	682,
+	746,
+	681,
+	746,
+	682,
+	747,
+	683,
+	747,
+	682,
+	747,
+	683,
+	748,
+	684,
+	748,
+	683,
+	748,
+	684,
+	749,
+	685,
+	749,
+	684,
+	749,
+	685,
+	750,
+	686,
+	750,
+	685,
+	750,
+	686,
+	751,
+	687,
+	751,
+	686,
+	751,
+	687,
+	752,
+	688,
+	752,
+	687,
+	752,
+	688,
+	753,
+	689,
+	753,
+	688,
+	753,
+	689,
+	754,
+	690,
+	754,
+	689,
+	754,
+	690,
+	755,
+	691,
+	755,
+	690,
+	755,
+	691,
+	756,
+	692,
+	756,
+	691,
+	756,
+	692,
+	757,
+	693,
+	757,
+	692,
+	757,
+	693,
+	758,
+	694,
+	758,
+	693,
+	758,
+	694,
+	759,
+	695,
+	759,
+	694,
+	759,
+	695,
+	760,
+	696,
+	760,
+	695,
+	760,
+	696,
+	761,
+	697,
+	761,
+	696,
+	761,
+	697,
+	762,
+	698,
+	762,
+	697,
+	762,
+	698,
+	763,
+	699,
+	763,
+	698,
+	763,
+	699,
+	764,
+	700,
+	764,
+	699,
+	764,
+	700,
+	765,
+	701,
+	765,
+	700,
+	765,
+	701,
+	766,
+	702,
+	766,
+	701,
+	766,
+	702,
+	767,
+	703,
+	767,
+	702,
+	768,
+	704,
+	769,
+	705,
+	769,
+	704,
+	769,
+	705,
+	770,
+	706,
+	770,
+	705,
+	770,
+	706,
+	771,
+	707,
+	771,
+	706,
+	771,
+	707,
+	772,
+	708,
+	772,
+	707,
+	772,
+	708,
+	773,
+	709,
+	773,
+	708,
+	773,
+	709,
+	774,
+	710,
+	774,
+	709,
+	774,
+	710,
+	775,
+	711,
+	775,
+	710,
+	775,
+	711,
+	776,
+	712,
+	776,
+	711,
+	776,
+	712,
+	777,
+	713,
+	777,
+	712,
+	777,
+	713,
+	778,
+	714,
+	778,
+	713,
+	778,
+	714,
+	779,
+	715,
+	779,
+	714,
+	779,
+	715,
+	780,
+	716,
+	780,
+	715,
+	780,
+	716,
+	781,
+	717,
+	781,
+	716,
+	781,
+	717,
+	782,
+	718,
+	782,
+	717,
+	782,
+	718,
+	783,
+	719,
+	783,
+	718,
+	783,
+	719,
+	784,
+	720,
+	784,
+	719,
+	784,
+	720,
+	785,
+	721,
+	785,
+	720,
+	785,
+	721,
+	786,
+	722,
+	786,
+	721,
+	786,
+	722,
+	787,
+	723,
+	787,
+	722,
+	787,
+	723,
+	788,
+	724,
+	788,
+	723,
+	788,
+	724,
+	789,
+	725,
+	789,
+	724,
+	789,
+	725,
+	790,
+	726,
+	790,
+	725,
+	790,
+	726,
+	791,
+	727,
+	791,
+	726,
+	791,
+	727,
+	792,
+	728,
+	792,
+	727,
+	792,
+	728,
+	793,
+	729,
+	793,
+	728,
+	793,
+	729,
+	794,
+	730,
+	794,
+	729,
+	794,
+	730,
+	795,
+	731,
+	795,
+	730,
+	795,
+	731,
+	796,
+	732,
+	796,
+	731,
+	796,
+	732,
+	797,
+	733,
+	797,
+	732,
+	797,
+	733,
+	798,
+	734,
+	798,
+	733,
+	798,
+	734,
+	799,
+	735,
+	799,
+	734,
+	799,
+	735,
+	800,
+	736,
+	800,
+	735,
+	800,
+	736,
+	801,
+	737,
+	801,
+	736,
+	801,
+	737,
+	802,
+	738,
+	802,
+	737,
+	802,
+	738,
+	803,
+	739,
+	803,
+	738,
+	803,
+	739,
+	804,
+	740,
+	804,
+	739,
+	804,
+	740,
+	805,
+	741,
+	805,
+	740,
+	805,
+	741,
+	806,
+	742,
+	806,
+	741,
+	806,
+	742,
+	807,
+	743,
+	807,
+	742,
+	807,
+	743,
+	808,
+	744,
+	808,
+	743,
+	808,
+	744,
+	809,
+	745,
+	809,
+	744,
+	809,
+	745,
+	810,
+	746,
+	810,
+	745,
+	810,
+	746,
+	811,
+	747,
+	811,
+	746,
+	811,
+	747,
+	812,
+	748,
+	812,
+	747,
+	812,
+	748,
+	813,
+	749,
+	813,
+	748,
+	813,
+	749,
+	814,
+	750,
+	814,
+	749,
+	814,
+	750,
+	815,
+	751,
+	815,
+	750,
+	815,
+	751,
+	816,
+	752,
+	816,
+	751,
+	816,
+	752,
+	817,
+	753,
+	817,
+	752,
+	817,
+	753,
+	818,
+	754,
+	818,
+	753,
+	818,
+	754,
+	819,
+	755,
+	819,
+	754,
+	819,
+	755,
+	820,
+	756,
+	820,
+	755,
+	820,
+	756,
+	821,
+	757,
+	821,
+	756,
+	821,
+	757,
+	822,
+	758,
+	822,
+	757,
+	822,
+	758,
+	823,
+	759,
+	823,
+	758,
+	823,
+	759,
+	824,
+	760,
+	824,
+	759,
+	824,
+	760,
+	825,
+	761,
+	825,
+	760,
+	825,
+	761,
+	826,
+	762,
+	826,
+	761,
+	826,
+	762,
+	827,
+	763,
+	827,
+	762,
+	827,
+	763,
+	828,
+	764,
+	828,
+	763,
+	828,
+	764,
+	829,
+	765,
+	829,
+	764,
+	829,
+	765,
+	830,
+	766,
+	830,
+	765,
+	830,
+	766,
+	831,
+	767,
+	831,
+	766,
+	832,
+	768,
+	833,
+	769,
+	833,
+	768,
+	833,
+	769,
+	834,
+	770,
+	834,
+	769,
+	834,
+	770,
+	835,
+	771,
+	835,
+	770,
+	835,
+	771,
+	836,
+	772,
+	836,
+	771,
+	836,
+	772,
+	837,
+	773,
+	837,
+	772,
+	837,
+	773,
+	838,
+	774,
+	838,
+	773,
+	838,
+	774,
+	839,
+	775,
+	839,
+	774,
+	839,
+	775,
+	840,
+	776,
+	840,
+	775,
+	840,
+	776,
+	841,
+	777,
+	841,
+	776,
+	841,
+	777,
+	842,
+	778,
+	842,
+	777,
+	842,
+	778,
+	843,
+	779,
+	843,
+	778,
+	843,
+	779,
+	844,
+	780,
+	844,
+	779,
+	844,
+	780,
+	845,
+	781,
+	845,
+	780,
+	845,
+	781,
+	846,
+	782,
+	846,
+	781,
+	846,
+	782,
+	847,
+	783,
+	847,
+	782,
+	847,
+	783,
+	848,
+	784,
+	848,
+	783,
+	848,
+	784,
+	849,
+	785,
+	849,
+	784,
+	849,
+	785,
+	850,
+	786,
+	850,
+	785,
+	850,
+	786,
+	851,
+	787,
+	851,
+	786,
+	851,
+	787,
+	852,
+	788,
+	852,
+	787,
+	852,
+	788,
+	853,
+	789,
+	853,
+	788,
+	853,
+	789,
+	854,
+	790,
+	854,
+	789,
+	854,
+	790,
+	855,
+	791,
+	855,
+	790,
+	855,
+	791,
+	856,
+	792,
+	856,
+	791,
+	856,
+	792,
+	857,
+	793,
+	857,
+	792,
+	857,
+	793,
+	858,
+	794,
+	858,
+	793,
+	858,
+	794,
+	859,
+	795,
+	859,
+	794,
+	859,
+	795,
+	860,
+	796,
+	860,
+	795,
+	860,
+	796,
+	861,
+	797,
+	861,
+	796,
+	861,
+	797,
+	862,
+	798,
+	862,
+	797,
+	862,
+	798,
+	863,
+	799,
+	863,
+	798,
+	863,
+	799,
+	864,
+	800,
+	864,
+	799,
+	864,
+	800,
+	865,
+	801,
+	865,
+	800,
+	865,
+	801,
+	866,
+	802,
+	866,
+	801,
+	866,
+	802,
+	867,
+	803,
+	867,
+	802,
+	867,
+	803,
+	868,
+	804,
+	868,
+	803,
+	868,
+	804,
+	869,
+	805,
+	869,
+	804,
+	869,
+	805,
+	870,
+	806,
+	870,
+	805,
+	870,
+	806,
+	871,
+	807,
+	871,
+	806,
+	871,
+	807,
+	872,
+	808,
+	872,
+	807,
+	872,
+	808,
+	873,
+	809,
+	873,
+	808,
+	873,
+	809,
+	874,
+	810,
+	874,
+	809,
+	874,
+	810,
+	875,
+	811,
+	875,
+	810,
+	875,
+	811,
+	876,
+	812,
+	876,
+	811,
+	876,
+	812,
+	877,
+	813,
+	877,
+	812,
+	877,
+	813,
+	878,
+	814,
+	878,
+	813,
+	878,
+	814,
+	879,
+	815,
+	879,
+	814,
+	879,
+	815,
+	880,
+	816,
+	880,
+	815,
+	880,
+	816,
+	881,
+	817,
+	881,
+	816,
+	881,
+	817,
+	882,
+	818,
+	882,
+	817,
+	882,
+	818,
+	883,
+	819,
+	883,
+	818,
+	883,
+	819,
+	884,
+	820,
+	884,
+	819,
+	884,
+	820,
+	885,
+	821,
+	885,
+	820,
+	885,
+	821,
+	886,
+	822,
+	886,
+	821,
+	886,
+	822,
+	887,
+	823,
+	887,
+	822,
+	887,
+	823,
+	888,
+	824,
+	888,
+	823,
+	888,
+	824,
+	889,
+	825,
+	889,
+	824,
+	889,
+	825,
+	890,
+	826,
+	890,
+	825,
+	890,
+	826,
+	891,
+	827,
+	891,
+	826,
+	891,
+	827,
+	892,
+	828,
+	892,
+	827,
+	892,
+	828,
+	893,
+	829,
+	893,
+	828,
+	893,
+	829,
+	894,
+	830,
+	894,
+	829,
+	894,
+	830,
+	895,
+	831,
+	895,
+	830,
+	896,
+	832,
+	897,
+	833,
+	897,
+	832,
+	897,
+	833,
+	898,
+	834,
+	898,
+	833,
+	898,
+	834,
+	899,
+	835,
+	899,
+	834,
+	899,
+	835,
+	900,
+	836,
+	900,
+	835,
+	900,
+	836,
+	901,
+	837,
+	901,
+	836,
+	901,
+	837,
+	902,
+	838,
+	902,
+	837,
+	902,
+	838,
+	903,
+	839,
+	903,
+	838,
+	903,
+	839,
+	904,
+	840,
+	904,
+	839,
+	904,
+	840,
+	905,
+	841,
+	905,
+	840,
+	905,
+	841,
+	906,
+	842,
+	906,
+	841,
+	906,
+	842,
+	907,
+	843,
+	907,
+	842,
+	907,
+	843,
+	908,
+	844,
+	908,
+	843,
+	908,
+	844,
+	909,
+	845,
+	909,
+	844,
+	909,
+	845,
+	910,
+	846,
+	910,
+	845,
+	910,
+	846,
+	911,
+	847,
+	911,
+	846,
+	911,
+	847,
+	912,
+	848,
+	912,
+	847,
+	912,
+	848,
+	913,
+	849,
+	913,
+	848,
+	913,
+	849,
+	914,
+	850,
+	914,
+	849,
+	914,
+	850,
+	915,
+	851,
+	915,
+	850,
+	915,
+	851,
+	916,
+	852,
+	916,
+	851,
+	916,
+	852,
+	917,
+	853,
+	917,
+	852,
+	917,
+	853,
+	918,
+	854,
+	918,
+	853,
+	918,
+	854,
+	919,
+	855,
+	919,
+	854,
+	919,
+	855,
+	920,
+	856,
+	920,
+	855,
+	920,
+	856,
+	921,
+	857,
+	921,
+	856,
+	921,
+	857,
+	922,
+	858,
+	922,
+	857,
+	922,
+	858,
+	923,
+	859,
+	923,
+	858,
+	923,
+	859,
+	924,
+	860,
+	924,
+	859,
+	924,
+	860,
+	925,
+	861,
+	925,
+	860,
+	925,
+	861,
+	926,
+	862,
+	926,
+	861,
+	926,
+	862,
+	927,
+	863,
+	927,
+	862,
+	927,
+	863,
+	928,
+	864,
+	928,
+	863,
+	928,
+	864,
+	929,
+	865,
+	929,
+	864,
+	929,
+	865,
+	930,
+	866,
+	930,
+	865,
+	930,
+	866,
+	931,
+	867,
+	931,
+	866,
+	931,
+	867,
+	932,
+	868,
+	932,
+	867,
+	932,
+	868,
+	933,
+	869,
+	933,
+	868,
+	933,
+	869,
+	934,
+	870,
+	934,
+	869,
+	934,
+	870,
+	935,
+	871,
+	935,
+	870,
+	935,
+	871,
+	936,
+	872,
+	936,
+	871,
+	936,
+	872,
+	937,
+	873,
+	937,
+	872,
+	937,
+	873,
+	938,
+	874,
+	938,
+	873,
+	938,
+	874,
+	939,
+	875,
+	939,
+	874,
+	939,
+	875,
+	940,
+	876,
+	940,
+	875,
+	940,
+	876,
+	941,
+	877,
+	941,
+	876,
+	941,
+	877,
+	942,
+	878,
+	942,
+	877,
+	942,
+	878,
+	943,
+	879,
+	943,
+	878,
+	943,
+	879,
+	944,
+	880,
+	944,
+	879,
+	944,
+	880,
+	945,
+	881,
+	945,
+	880,
+	945,
+	881,
+	946,
+	882,
+	946,
+	881,
+	946,
+	882,
+	947,
+	883,
+	947,
+	882,
+	947,
+	883,
+	948,
+	884,
+	948,
+	883,
+	948,
+	884,
+	949,
+	885,
+	949,
+	884,
+	949,
+	885,
+	950,
+	886,
+	950,
+	885,
+	950,
+	886,
+	951,
+	887,
+	951,
+	886,
+	951,
+	887,
+	952,
+	888,
+	952,
+	887,
+	952,
+	888,
+	953,
+	889,
+	953,
+	888,
+	953,
+	889,
+	954,
+	890,
+	954,
+	889,
+	954,
+	890,
+	955,
+	891,
+	955,
+	890,
+	955,
+	891,
+	956,
+	892,
+	956,
+	891,
+	956,
+	892,
+	957,
+	893,
+	957,
+	892,
+	957,
+	893,
+	958,
+	894,
+	958,
+	893,
+	958,
+	894,
+	959,
+	895,
+	959,
+	894,
+	960,
+	896,
+	961,
+	897,
+	961,
+	896,
+	961,
+	897,
+	962,
+	898,
+	962,
+	897,
+	962,
+	898,
+	963,
+	899,
+	963,
+	898,
+	963,
+	899,
+	964,
+	900,
+	964,
+	899,
+	964,
+	900,
+	965,
+	901,
+	965,
+	900,
+	965,
+	901,
+	966,
+	902,
+	966,
+	901,
+	966,
+	902,
+	967,
+	903,
+	967,
+	902,
+	967,
+	903,
+	968,
+	904,
+	968,
+	903,
+	968,
+	904,
+	969,
+	905,
+	969,
+	904,
+	969,
+	905,
+	970,
+	906,
+	970,
+	905,
+	970,
+	906,
+	971,
+	907,
+	971,
+	906,
+	971,
+	907,
+	972,
+	908,
+	972,
+	907,
+	972,
+	908,
+	973,
+	909,
+	973,
+	908,
+	973,
+	909,
+	974,
+	910,
+	974,
+	909,
+	974,
+	910,
+	975,
+	911,
+	975,
+	910,
+	975,
+	911,
+	976,
+	912,
+	976,
+	911,
+	976,
+	912,
+	977,
+	913,
+	977,
+	912,
+	977,
+	913,
+	978,
+	914,
+	978,
+	913,
+	978,
+	914,
+	979,
+	915,
+	979,
+	914,
+	979,
+	915,
+	980,
+	916,
+	980,
+	915,
+	980,
+	916,
+	981,
+	917,
+	981,
+	916,
+	981,
+	917,
+	982,
+	918,
+	982,
+	917,
+	982,
+	918,
+	983,
+	919,
+	983,
+	918,
+	983,
+	919,
+	984,
+	920,
+	984,
+	919,
+	984,
+	920,
+	985,
+	921,
+	985,
+	920,
+	985,
+	921,
+	986,
+	922,
+	986,
+	921,
+	986,
+	922,
+	987,
+	923,
+	987,
+	922,
+	987,
+	923,
+	988,
+	924,
+	988,
+	923,
+	988,
+	924,
+	989,
+	925,
+	989,
+	924,
+	989,
+	925,
+	990,
+	926,
+	990,
+	925,
+	990,
+	926,
+	991,
+	927,
+	991,
+	926,
+	991,
+	927,
+	992,
+	928,
+	992,
+	927,
+	992,
+	928,
+	993,
+	929,
+	993,
+	928,
+	993,
+	929,
+	994,
+	930,
+	994,
+	929,
+	994,
+	930,
+	995,
+	931,
+	995,
+	930,
+	995,
+	931,
+	996,
+	932,
+	996,
+	931,
+	996,
+	932,
+	997,
+	933,
+	997,
+	932,
+	997,
+	933,
+	998,
+	934,
+	998,
+	933,
+	998,
+	934,
+	999,
+	935,
+	999,
+	934,
+	999,
+	935,
+	1000,
+	936,
+	1000,
+	935,
+	1000,
+	936,
+	1001,
+	937,
+	1001,
+	936,
+	1001,
+	937,
+	1002,
+	938,
+	1002,
+	937,
+	1002,
+	938,
+	1003,
+	939,
+	1003,
+	938,
+	1003,
+	939,
+	1004,
+	940,
+	1004,
+	939,
+	1004,
+	940,
+	1005,
+	941,
+	1005,
+	940,
+	1005,
+	941,
+	1006,
+	942,
+	1006,
+	941,
+	1006,
+	942,
+	1007,
+	943,
+	1007,
+	942,
+	1007,
+	943,
+	1008,
+	944,
+	1008,
+	943,
+	1008,
+	944,
+	1009,
+	945,
+	1009,
+	944,
+	1009,
+	945,
+	1010,
+	946,
+	1010,
+	945,
+	1010,
+	946,
+	1011,
+	947,
+	1011,
+	946,
+	1011,
+	947,
+	1012,
+	948,
+	1012,
+	947,
+	1012,
+	948,
+	1013,
+	949,
+	1013,
+	948,
+	1013,
+	949,
+	1014,
+	950,
+	1014,
+	949,
+	1014,
+	950,
+	1015,
+	951,
+	1015,
+	950,
+	1015,
+	951,
+	1016,
+	952,
+	1016,
+	951,
+	1016,
+	952,
+	1017,
+	953,
+	1017,
+	952,
+	1017,
+	953,
+	1018,
+	954,
+	1018,
+	953,
+	1018,
+	954,
+	1019,
+	955,
+	1019,
+	954,
+	1019,
+	955,
+	1020,
+	956,
+	1020,
+	955,
+	1020,
+	956,
+	1021,
+	957,
+	1021,
+	956,
+	1021,
+	957,
+	1022,
+	958,
+	1022,
+	957,
+	1022,
+	958,
+	1023,
+	959,
+	1023,
+	958,
+	1024,
+	960,
+	1025,
+	961,
+	1025,
+	960,
+	1025,
+	961,
+	1026,
+	962,
+	1026,
+	961,
+	1026,
+	962,
+	1027,
+	963,
+	1027,
+	962,
+	1027,
+	963,
+	1028,
+	964,
+	1028,
+	963,
+	1028,
+	964,
+	1029,
+	965,
+	1029,
+	964,
+	1029,
+	965,
+	1030,
+	966,
+	1030,
+	965,
+	1030,
+	966,
+	1031,
+	967,
+	1031,
+	966,
+	1031,
+	967,
+	1032,
+	968,
+	1032,
+	967,
+	1032,
+	968,
+	1033,
+	969,
+	1033,
+	968,
+	1033,
+	969,
+	1034,
+	970,
+	1034,
+	969,
+	1034,
+	970,
+	1035,
+	971,
+	1035,
+	970,
+	1035,
+	971,
+	1036,
+	972,
+	1036,
+	971,
+	1036,
+	972,
+	1037,
+	973,
+	1037,
+	972,
+	1037,
+	973,
+	1038,
+	974,
+	1038,
+	973,
+	1038,
+	974,
+	1039,
+	975,
+	1039,
+	974,
+	1039,
+	975,
+	1040,
+	976,
+	1040,
+	975,
+	1040,
+	976,
+	1041,
+	977,
+	1041,
+	976,
+	1041,
+	977,
+	1042,
+	978,
+	1042,
+	977,
+	1042,
+	978,
+	1043,
+	979,
+	1043,
+	978,
+	1043,
+	979,
+	1044,
+	980,
+	1044,
+	979,
+	1044,
+	980,
+	1045,
+	981,
+	1045,
+	980,
+	1045,
+	981,
+	1046,
+	982,
+	1046,
+	981,
+	1046,
+	982,
+	1047,
+	983,
+	1047,
+	982,
+	1047,
+	983,
+	1048,
+	984,
+	1048,
+	983,
+	1048,
+	984,
+	1049,
+	985,
+	1049,
+	984,
+	1049,
+	985,
+	1050,
+	986,
+	1050,
+	985,
+	1050,
+	986,
+	1051,
+	987,
+	1051,
+	986,
+	1051,
+	987,
+	1052,
+	988,
+	1052,
+	987,
+	1052,
+	988,
+	1053,
+	989,
+	1053,
+	988,
+	1053,
+	989,
+	1054,
+	990,
+	1054,
+	989,
+	1054,
+	990,
+	1055,
+	991,
+	1055,
+	990,
+	1055,
+	991,
+	1056,
+	992,
+	1056,
+	991,
+	1056,
+	992,
+	1057,
+	993,
+	1057,
+	992,
+	1057,
+	993,
+	1058,
+	994,
+	1058,
+	993,
+	1058,
+	994,
+	1059,
+	995,
+	1059,
+	994,
+	1059,
+	995,
+	1060,
+	996,
+	1060,
+	995,
+	1060,
+	996,
+	1061,
+	997,
+	1061,
+	996,
+	1061,
+	997,
+	1062,
+	998,
+	1062,
+	997,
+	1062,
+	998,
+	1063,
+	999,
+	1063,
+	998,
+	1063,
+	999,
+	1064,
+	1000,
+	1064,
+	999,
+	1064,
+	1000,
+	1065,
+	1001,
+	1065,
+	1000,
+	1065,
+	1001,
+	1066,
+	1002,
+	1066,
+	1001,
+	1066,
+	1002,
+	1067,
+	1003,
+	1067,
+	1002,
+	1067,
+	1003,
+	1068,
+	1004,
+	1068,
+	1003,
+	1068,
+	1004,
+	1069,
+	1005,
+	1069,
+	1004,
+	1069,
+	1005,
+	1070,
+	1006,
+	1070,
+	1005,
+	1070,
+	1006,
+	1071,
+	1007,
+	1071,
+	1006,
+	1071,
+	1007,
+	1072,
+	1008,
+	1072,
+	1007,
+	1072,
+	1008,
+	1073,
+	1009,
+	1073,
+	1008,
+	1073,
+	1009,
+	1074,
+	1010,
+	1074,
+	1009,
+	1074,
+	1010,
+	1075,
+	1011,
+	1075,
+	1010,
+	1075,
+	1011,
+	1076,
+	1012,
+	1076,
+	1011,
+	1076,
+	1012,
+	1077,
+	1013,
+	1077,
+	1012,
+	1077,
+	1013,
+	1078,
+	1014,
+	1078,
+	1013,
+	1078,
+	1014,
+	1079,
+	1015,
+	1079,
+	1014,
+	1079,
+	1015,
+	1080,
+	1016,
+	1080,
+	1015,
+	1080,
+	1016,
+	1081,
+	1017,
+	1081,
+	1016,
+	1081,
+	1017,
+	1082,
+	1018,
+	1082,
+	1017,
+	1082,
+	1018,
+	1083,
+	1019,
+	1083,
+	1018,
+	1083,
+	1019,
+	1084,
+	1020,
+	1084,
+	1019,
+	1084,
+	1020,
+	1085,
+	1021,
+	1085,
+	1020,
+	1085,
+	1021,
+	1086,
+	1022,
+	1086,
+	1021,
+	1086,
+	1022,
+	1087,
+	1023,
+	1087,
+	1022,
+	1088,
+	1024,
+	1089,
+	1025,
+	1089,
+	1024,
+	1089,
+	1025,
+	1090,
+	1026,
+	1090,
+	1025,
+	1090,
+	1026,
+	1091,
+	1027,
+	1091,
+	1026,
+	1091,
+	1027,
+	1092,
+	1028,
+	1092,
+	1027,
+	1092,
+	1028,
+	1093,
+	1029,
+	1093,
+	1028,
+	1093,
+	1029,
+	1094,
+	1030,
+	1094,
+	1029,
+	1094,
+	1030,
+	1095,
+	1031,
+	1095,
+	1030,
+	1095,
+	1031,
+	1096,
+	1032,
+	1096,
+	1031,
+	1096,
+	1032,
+	1097,
+	1033,
+	1097,
+	1032,
+	1097,
+	1033,
+	1098,
+	1034,
+	1098,
+	1033,
+	1098,
+	1034,
+	1099,
+	1035,
+	1099,
+	1034,
+	1099,
+	1035,
+	1100,
+	1036,
+	1100,
+	1035,
+	1100,
+	1036,
+	1101,
+	1037,
+	1101,
+	1036,
+	1101,
+	1037,
+	1102,
+	1038,
+	1102,
+	1037,
+	1102,
+	1038,
+	1103,
+	1039,
+	1103,
+	1038,
+	1103,
+	1039,
+	1104,
+	1040,
+	1104,
+	1039,
+	1104,
+	1040,
+	1105,
+	1041,
+	1105,
+	1040,
+	1105,
+	1041,
+	1106,
+	1042,
+	1106,
+	1041,
+	1106,
+	1042,
+	1107,
+	1043,
+	1107,
+	1042,
+	1107,
+	1043,
+	1108,
+	1044,
+	1108,
+	1043,
+	1108,
+	1044,
+	1109,
+	1045,
+	1109,
+	1044,
+	1109,
+	1045,
+	1110,
+	1046,
+	1110,
+	1045,
+	1110,
+	1046,
+	1111,
+	1047,
+	1111,
+	1046,
+	1111,
+	1047,
+	1112,
+	1048,
+	1112,
+	1047,
+	1112,
+	1048,
+	1113,
+	1049,
+	1113,
+	1048,
+	1113,
+	1049,
+	1114,
+	1050,
+	1114,
+	1049,
+	1114,
+	1050,
+	1115,
+	1051,
+	1115,
+	1050,
+	1115,
+	1051,
+	1116,
+	1052,
+	1116,
+	1051,
+	1116,
+	1052,
+	1117,
+	1053,
+	1117,
+	1052,
+	1117,
+	1053,
+	1118,
+	1054,
+	1118,
+	1053,
+	1118,
+	1054,
+	1119,
+	1055,
+	1119,
+	1054,
+	1119,
+	1055,
+	1120,
+	1056,
+	1120,
+	1055,
+	1120,
+	1056,
+	1121,
+	1057,
+	1121,
+	1056,
+	1121,
+	1057,
+	1122,
+	1058,
+	1122,
+	1057,
+	1122,
+	1058,
+	1123,
+	1059,
+	1123,
+	1058,
+	1123,
+	1059,
+	1124,
+	1060,
+	1124,
+	1059,
+	1124,
+	1060,
+	1125,
+	1061,
+	1125,
+	1060,
+	1125,
+	1061,
+	1126,
+	1062,
+	1126,
+	1061,
+	1126,
+	1062,
+	1127,
+	1063,
+	1127,
+	1062,
+	1127,
+	1063,
+	1128,
+	1064,
+	1128,
+	1063,
+	1128,
+	1064,
+	1129,
+	1065,
+	1129,
+	1064,
+	1129,
+	1065,
+	1130,
+	1066,
+	1130,
+	1065,
+	1130,
+	1066,
+	1131,
+	1067,
+	1131,
+	1066,
+	1131,
+	1067,
+	1132,
+	1068,
+	1132,
+	1067,
+	1132,
+	1068,
+	1133,
+	1069,
+	1133,
+	1068,
+	1133,
+	1069,
+	1134,
+	1070,
+	1134,
+	1069,
+	1134,
+	1070,
+	1135,
+	1071,
+	1135,
+	1070,
+	1135,
+	1071,
+	1136,
+	1072,
+	1136,
+	1071,
+	1136,
+	1072,
+	1137,
+	1073,
+	1137,
+	1072,
+	1137,
+	1073,
+	1138,
+	1074,
+	1138,
+	1073,
+	1138,
+	1074,
+	1139,
+	1075,
+	1139,
+	1074,
+	1139,
+	1075,
+	1140,
+	1076,
+	1140,
+	1075,
+	1140,
+	1076,
+	1141,
+	1077,
+	1141,
+	1076,
+	1141,
+	1077,
+	1142,
+	1078,
+	1142,
+	1077,
+	1142,
+	1078,
+	1143,
+	1079,
+	1143,
+	1078,
+	1143,
+	1079,
+	1144,
+	1080,
+	1144,
+	1079,
+	1144,
+	1080,
+	1145,
+	1081,
+	1145,
+	1080,
+	1145,
+	1081,
+	1146,
+	1082,
+	1146,
+	1081,
+	1146,
+	1082,
+	1147,
+	1083,
+	1147,
+	1082,
+	1147,
+	1083,
+	1148,
+	1084,
+	1148,
+	1083,
+	1148,
+	1084,
+	1149,
+	1085,
+	1149,
+	1084,
+	1149,
+	1085,
+	1150,
+	1086,
+	1150,
+	1085,
+	1150,
+	1086,
+	1151,
+	1087,
+	1151,
+	1086,
+	1152,
+	1088,
+	1153,
+	1089,
+	1153,
+	1088,
+	1153,
+	1089,
+	1154,
+	1090,
+	1154,
+	1089,
+	1154,
+	1090,
+	1155,
+	1091,
+	1155,
+	1090,
+	1155,
+	1091,
+	1156,
+	1092,
+	1156,
+	1091,
+	1156,
+	1092,
+	1157,
+	1093,
+	1157,
+	1092,
+	1157,
+	1093,
+	1158,
+	1094,
+	1158,
+	1093,
+	1158,
+	1094,
+	1159,
+	1095,
+	1159,
+	1094,
+	1159,
+	1095,
+	1160,
+	1096,
+	1160,
+	1095,
+	1160,
+	1096,
+	1161,
+	1097,
+	1161,
+	1096,
+	1161,
+	1097,
+	1162,
+	1098,
+	1162,
+	1097,
+	1162,
+	1098,
+	1163,
+	1099,
+	1163,
+	1098,
+	1163,
+	1099,
+	1164,
+	1100,
+	1164,
+	1099,
+	1164,
+	1100,
+	1165,
+	1101,
+	1165,
+	1100,
+	1165,
+	1101,
+	1166,
+	1102,
+	1166,
+	1101,
+	1166,
+	1102,
+	1167,
+	1103,
+	1167,
+	1102,
+	1167,
+	1103,
+	1168,
+	1104,
+	1168,
+	1103,
+	1168,
+	1104,
+	1169,
+	1105,
+	1169,
+	1104,
+	1169,
+	1105,
+	1170,
+	1106,
+	1170,
+	1105,
+	1170,
+	1106,
+	1171,
+	1107,
+	1171,
+	1106,
+	1171,
+	1107,
+	1172,
+	1108,
+	1172,
+	1107,
+	1172,
+	1108,
+	1173,
+	1109,
+	1173,
+	1108,
+	1173,
+	1109,
+	1174,
+	1110,
+	1174,
+	1109,
+	1174,
+	1110,
+	1175,
+	1111,
+	1175,
+	1110,
+	1175,
+	1111,
+	1176,
+	1112,
+	1176,
+	1111,
+	1176,
+	1112,
+	1177,
+	1113,
+	1177,
+	1112,
+	1177,
+	1113,
+	1178,
+	1114,
+	1178,
+	1113,
+	1178,
+	1114,
+	1179,
+	1115,
+	1179,
+	1114,
+	1179,
+	1115,
+	1180,
+	1116,
+	1180,
+	1115,
+	1180,
+	1116,
+	1181,
+	1117,
+	1181,
+	1116,
+	1181,
+	1117,
+	1182,
+	1118,
+	1182,
+	1117,
+	1182,
+	1118,
+	1183,
+	1119,
+	1183,
+	1118,
+	1183,
+	1119,
+	1184,
+	1120,
+	1184,
+	1119,
+	1184,
+	1120,
+	1185,
+	1121,
+	1185,
+	1120,
+	1185,
+	1121,
+	1186,
+	1122,
+	1186,
+	1121,
+	1186,
+	1122,
+	1187,
+	1123,
+	1187,
+	1122,
+	1187,
+	1123,
+	1188,
+	1124,
+	1188,
+	1123,
+	1188,
+	1124,
+	1189,
+	1125,
+	1189,
+	1124,
+	1189,
+	1125,
+	1190,
+	1126,
+	1190,
+	1125,
+	1190,
+	1126,
+	1191,
+	1127,
+	1191,
+	1126,
+	1191,
+	1127,
+	1192,
+	1128,
+	1192,
+	1127,
+	1192,
+	1128,
+	1193,
+	1129,
+	1193,
+	1128,
+	1193,
+	1129,
+	1194,
+	1130,
+	1194,
+	1129,
+	1194,
+	1130,
+	1195,
+	1131,
+	1195,
+	1130,
+	1195,
+	1131,
+	1196,
+	1132,
+	1196,
+	1131,
+	1196,
+	1132,
+	1197,
+	1133,
+	1197,
+	1132,
+	1197,
+	1133,
+	1198,
+	1134,
+	1198,
+	1133,
+	1198,
+	1134,
+	1199,
+	1135,
+	1199,
+	1134,
+	1199,
+	1135,
+	1200,
+	1136,
+	1200,
+	1135,
+	1200,
+	1136,
+	1201,
+	1137,
+	1201,
+	1136,
+	1201,
+	1137,
+	1202,
+	1138,
+	1202,
+	1137,
+	1202,
+	1138,
+	1203,
+	1139,
+	1203,
+	1138,
+	1203,
+	1139,
+	1204,
+	1140,
+	1204,
+	1139,
+	1204,
+	1140,
+	1205,
+	1141,
+	1205,
+	1140,
+	1205,
+	1141,
+	1206,
+	1142,
+	1206,
+	1141,
+	1206,
+	1142,
+	1207,
+	1143,
+	1207,
+	1142,
+	1207,
+	1143,
+	1208,
+	1144,
+	1208,
+	1143,
+	1208,
+	1144,
+	1209,
+	1145,
+	1209,
+	1144,
+	1209,
+	1145,
+	1210,
+	1146,
+	1210,
+	1145,
+	1210,
+	1146,
+	1211,
+	1147,
+	1211,
+	1146,
+	1211,
+	1147,
+	1212,
+	1148,
+	1212,
+	1147,
+	1212,
+	1148,
+	1213,
+	1149,
+	1213,
+	1148,
+	1213,
+	1149,
+	1214,
+	1150,
+	1214,
+	1149,
+	1214,
+	1150,
+	1215,
+	1151,
+	1215,
+	1150,
+	1216,
+	1152,
+	1217,
+	1153,
+	1217,
+	1152,
+	1217,
+	1153,
+	1218,
+	1154,
+	1218,
+	1153,
+	1218,
+	1154,
+	1219,
+	1155,
+	1219,
+	1154,
+	1219,
+	1155,
+	1220,
+	1156,
+	1220,
+	1155,
+	1220,
+	1156,
+	1221,
+	1157,
+	1221,
+	1156,
+	1221,
+	1157,
+	1222,
+	1158,
+	1222,
+	1157,
+	1222,
+	1158,
+	1223,
+	1159,
+	1223,
+	1158,
+	1223,
+	1159,
+	1224,
+	1160,
+	1224,
+	1159,
+	1224,
+	1160,
+	1225,
+	1161,
+	1225,
+	1160,
+	1225,
+	1161,
+	1226,
+	1162,
+	1226,
+	1161,
+	1226,
+	1162,
+	1227,
+	1163,
+	1227,
+	1162,
+	1227,
+	1163,
+	1228,
+	1164,
+	1228,
+	1163,
+	1228,
+	1164,
+	1229,
+	1165,
+	1229,
+	1164,
+	1229,
+	1165,
+	1230,
+	1166,
+	1230,
+	1165,
+	1230,
+	1166,
+	1231,
+	1167,
+	1231,
+	1166,
+	1231,
+	1167,
+	1232,
+	1168,
+	1232,
+	1167,
+	1232,
+	1168,
+	1233,
+	1169,
+	1233,
+	1168,
+	1233,
+	1169,
+	1234,
+	1170,
+	1234,
+	1169,
+	1234,
+	1170,
+	1235,
+	1171,
+	1235,
+	1170,
+	1235,
+	1171,
+	1236,
+	1172,
+	1236,
+	1171,
+	1236,
+	1172,
+	1237,
+	1173,
+	1237,
+	1172,
+	1237,
+	1173,
+	1238,
+	1174,
+	1238,
+	1173,
+	1238,
+	1174,
+	1239,
+	1175,
+	1239,
+	1174,
+	1239,
+	1175,
+	1240,
+	1176,
+	1240,
+	1175,
+	1240,
+	1176,
+	1241,
+	1177,
+	1241,
+	1176,
+	1241,
+	1177,
+	1242,
+	1178,
+	1242,
+	1177,
+	1242,
+	1178,
+	1243,
+	1179,
+	1243,
+	1178,
+	1243,
+	1179,
+	1244,
+	1180,
+	1244,
+	1179,
+	1244,
+	1180,
+	1245,
+	1181,
+	1245,
+	1180,
+	1245,
+	1181,
+	1246,
+	1182,
+	1246,
+	1181,
+	1246,
+	1182,
+	1247,
+	1183,
+	1247,
+	1182,
+	1247,
+	1183,
+	1248,
+	1184,
+	1248,
+	1183,
+	1248,
+	1184,
+	1249,
+	1185,
+	1249,
+	1184,
+	1249,
+	1185,
+	1250,
+	1186,
+	1250,
+	1185,
+	1250,
+	1186,
+	1251,
+	1187,
+	1251,
+	1186,
+	1251,
+	1187,
+	1252,
+	1188,
+	1252,
+	1187,
+	1252,
+	1188,
+	1253,
+	1189,
+	1253,
+	1188,
+	1253,
+	1189,
+	1254,
+	1190,
+	1254,
+	1189,
+	1254,
+	1190,
+	1255,
+	1191,
+	1255,
+	1190,
+	1255,
+	1191,
+	1256,
+	1192,
+	1256,
+	1191,
+	1256,
+	1192,
+	1257,
+	1193,
+	1257,
+	1192,
+	1257,
+	1193,
+	1258,
+	1194,
+	1258,
+	1193,
+	1258,
+	1194,
+	1259,
+	1195,
+	1259,
+	1194,
+	1259,
+	1195,
+	1260,
+	1196,
+	1260,
+	1195,
+	1260,
+	1196,
+	1261,
+	1197,
+	1261,
+	1196,
+	1261,
+	1197,
+	1262,
+	1198,
+	1262,
+	1197,
+	1262,
+	1198,
+	1263,
+	1199,
+	1263,
+	1198,
+	1263,
+	1199,
+	1264,
+	1200,
+	1264,
+	1199,
+	1264,
+	1200,
+	1265,
+	1201,
+	1265,
+	1200,
+	1265,
+	1201,
+	1266,
+	1202,
+	1266,
+	1201,
+	1266,
+	1202,
+	1267,
+	1203,
+	1267,
+	1202,
+	1267,
+	1203,
+	1268,
+	1204,
+	1268,
+	1203,
+	1268,
+	1204,
+	1269,
+	1205,
+	1269,
+	1204,
+	1269,
+	1205,
+	1270,
+	1206,
+	1270,
+	1205,
+	1270,
+	1206,
+	1271,
+	1207,
+	1271,
+	1206,
+	1271,
+	1207,
+	1272,
+	1208,
+	1272,
+	1207,
+	1272,
+	1208,
+	1273,
+	1209,
+	1273,
+	1208,
+	1273,
+	1209,
+	1274,
+	1210,
+	1274,
+	1209,
+	1274,
+	1210,
+	1275,
+	1211,
+	1275,
+	1210,
+	1275,
+	1211,
+	1276,
+	1212,
+	1276,
+	1211,
+	1276,
+	1212,
+	1277,
+	1213,
+	1277,
+	1212,
+	1277,
+	1213,
+	1278,
+	1214,
+	1278,
+	1213,
+	1278,
+	1214,
+	1279,
+	1215,
+	1279,
+	1214,
+	1280,
+	1216,
+	1281,
+	1217,
+	1281,
+	1216,
+	1281,
+	1217,
+	1282,
+	1218,
+	1282,
+	1217,
+	1282,
+	1218,
+	1283,
+	1219,
+	1283,
+	1218,
+	1283,
+	1219,
+	1284,
+	1220,
+	1284,
+	1219,
+	1284,
+	1220,
+	1285,
+	1221,
+	1285,
+	1220,
+	1285,
+	1221,
+	1286,
+	1222,
+	1286,
+	1221,
+	1286,
+	1222,
+	1287,
+	1223,
+	1287,
+	1222,
+	1287,
+	1223,
+	1288,
+	1224,
+	1288,
+	1223,
+	1288,
+	1224,
+	1289,
+	1225,
+	1289,
+	1224,
+	1289,
+	1225,
+	1290,
+	1226,
+	1290,
+	1225,
+	1290,
+	1226,
+	1291,
+	1227,
+	1291,
+	1226,
+	1291,
+	1227,
+	1292,
+	1228,
+	1292,
+	1227,
+	1292,
+	1228,
+	1293,
+	1229,
+	1293,
+	1228,
+	1293,
+	1229,
+	1294,
+	1230,
+	1294,
+	1229,
+	1294,
+	1230,
+	1295,
+	1231,
+	1295,
+	1230,
+	1295,
+	1231,
+	1296,
+	1232,
+	1296,
+	1231,
+	1296,
+	1232,
+	1297,
+	1233,
+	1297,
+	1232,
+	1297,
+	1233,
+	1298,
+	1234,
+	1298,
+	1233,
+	1298,
+	1234,
+	1299,
+	1235,
+	1299,
+	1234,
+	1299,
+	1235,
+	1300,
+	1236,
+	1300,
+	1235,
+	1300,
+	1236,
+	1301,
+	1237,
+	1301,
+	1236,
+	1301,
+	1237,
+	1302,
+	1238,
+	1302,
+	1237,
+	1302,
+	1238,
+	1303,
+	1239,
+	1303,
+	1238,
+	1303,
+	1239,
+	1304,
+	1240,
+	1304,
+	1239,
+	1304,
+	1240,
+	1305,
+	1241,
+	1305,
+	1240,
+	1305,
+	1241,
+	1306,
+	1242,
+	1306,
+	1241,
+	1306,
+	1242,
+	1307,
+	1243,
+	1307,
+	1242,
+	1307,
+	1243,
+	1308,
+	1244,
+	1308,
+	1243,
+	1308,
+	1244,
+	1309,
+	1245,
+	1309,
+	1244,
+	1309,
+	1245,
+	1310,
+	1246,
+	1310,
+	1245,
+	1310,
+	1246,
+	1311,
+	1247,
+	1311,
+	1246,
+	1311,
+	1247,
+	1312,
+	1248,
+	1312,
+	1247,
+	1312,
+	1248,
+	1313,
+	1249,
+	1313,
+	1248,
+	1313,
+	1249,
+	1314,
+	1250,
+	1314,
+	1249,
+	1314,
+	1250,
+	1315,
+	1251,
+	1315,
+	1250,
+	1315,
+	1251,
+	1316,
+	1252,
+	1316,
+	1251,
+	1316,
+	1252,
+	1317,
+	1253,
+	1317,
+	1252,
+	1317,
+	1253,
+	1318,
+	1254,
+	1318,
+	1253,
+	1318,
+	1254,
+	1319,
+	1255,
+	1319,
+	1254,
+	1319,
+	1255,
+	1320,
+	1256,
+	1320,
+	1255,
+	1320,
+	1256,
+	1321,
+	1257,
+	1321,
+	1256,
+	1321,
+	1257,
+	1322,
+	1258,
+	1322,
+	1257,
+	1322,
+	1258,
+	1323,
+	1259,
+	1323,
+	1258,
+	1323,
+	1259,
+	1324,
+	1260,
+	1324,
+	1259,
+	1324,
+	1260,
+	1325,
+	1261,
+	1325,
+	1260,
+	1325,
+	1261,
+	1326,
+	1262,
+	1326,
+	1261,
+	1326,
+	1262,
+	1327,
+	1263,
+	1327,
+	1262,
+	1327,
+	1263,
+	1328,
+	1264,
+	1328,
+	1263,
+	1328,
+	1264,
+	1329,
+	1265,
+	1329,
+	1264,
+	1329,
+	1265,
+	1330,
+	1266,
+	1330,
+	1265,
+	1330,
+	1266,
+	1331,
+	1267,
+	1331,
+	1266,
+	1331,
+	1267,
+	1332,
+	1268,
+	1332,
+	1267,
+	1332,
+	1268,
+	1333,
+	1269,
+	1333,
+	1268,
+	1333,
+	1269,
+	1334,
+	1270,
+	1334,
+	1269,
+	1334,
+	1270,
+	1335,
+	1271,
+	1335,
+	1270,
+	1335,
+	1271,
+	1336,
+	1272,
+	1336,
+	1271,
+	1336,
+	1272,
+	1337,
+	1273,
+	1337,
+	1272,
+	1337,
+	1273,
+	1338,
+	1274,
+	1338,
+	1273,
+	1338,
+	1274,
+	1339,
+	1275,
+	1339,
+	1274,
+	1339,
+	1275,
+	1340,
+	1276,
+	1340,
+	1275,
+	1340,
+	1276,
+	1341,
+	1277,
+	1341,
+	1276,
+	1341,
+	1277,
+	1342,
+	1278,
+	1342,
+	1277,
+	1342,
+	1278,
+	1343,
+	1279,
+	1343,
+	1278,
+	1344,
+	1280,
+	1345,
+	1281,
+	1345,
+	1280,
+	1345,
+	1281,
+	1346,
+	1282,
+	1346,
+	1281,
+	1346,
+	1282,
+	1347,
+	1283,
+	1347,
+	1282,
+	1347,
+	1283,
+	1348,
+	1284,
+	1348,
+	1283,
+	1348,
+	1284,
+	1349,
+	1285,
+	1349,
+	1284,
+	1349,
+	1285,
+	1350,
+	1286,
+	1350,
+	1285,
+	1350,
+	1286,
+	1351,
+	1287,
+	1351,
+	1286,
+	1351,
+	1287,
+	1352,
+	1288,
+	1352,
+	1287,
+	1352,
+	1288,
+	1353,
+	1289,
+	1353,
+	1288,
+	1353,
+	1289,
+	1354,
+	1290,
+	1354,
+	1289,
+	1354,
+	1290,
+	1355,
+	1291,
+	1355,
+	1290,
+	1355,
+	1291,
+	1356,
+	1292,
+	1356,
+	1291,
+	1356,
+	1292,
+	1357,
+	1293,
+	1357,
+	1292,
+	1357,
+	1293,
+	1358,
+	1294,
+	1358,
+	1293,
+	1358,
+	1294,
+	1359,
+	1295,
+	1359,
+	1294,
+	1359,
+	1295,
+	1360,
+	1296,
+	1360,
+	1295,
+	1360,
+	1296,
+	1361,
+	1297,
+	1361,
+	1296,
+	1361,
+	1297,
+	1362,
+	1298,
+	1362,
+	1297,
+	1362,
+	1298,
+	1363,
+	1299,
+	1363,
+	1298,
+	1363,
+	1299,
+	1364,
+	1300,
+	1364,
+	1299,
+	1364,
+	1300,
+	1365,
+	1301,
+	1365,
+	1300,
+	1365,
+	1301,
+	1366,
+	1302,
+	1366,
+	1301,
+	1366,
+	1302,
+	1367,
+	1303,
+	1367,
+	1302,
+	1367,
+	1303,
+	1368,
+	1304,
+	1368,
+	1303,
+	1368,
+	1304,
+	1369,
+	1305,
+	1369,
+	1304,
+	1369,
+	1305,
+	1370,
+	1306,
+	1370,
+	1305,
+	1370,
+	1306,
+	1371,
+	1307,
+	1371,
+	1306,
+	1371,
+	1307,
+	1372,
+	1308,
+	1372,
+	1307,
+	1372,
+	1308,
+	1373,
+	1309,
+	1373,
+	1308,
+	1373,
+	1309,
+	1374,
+	1310,
+	1374,
+	1309,
+	1374,
+	1310,
+	1375,
+	1311,
+	1375,
+	1310,
+	1375,
+	1311,
+	1376,
+	1312,
+	1376,
+	1311,
+	1376,
+	1312,
+	1377,
+	1313,
+	1377,
+	1312,
+	1377,
+	1313,
+	1378,
+	1314,
+	1378,
+	1313,
+	1378,
+	1314,
+	1379,
+	1315,
+	1379,
+	1314,
+	1379,
+	1315,
+	1380,
+	1316,
+	1380,
+	1315,
+	1380,
+	1316,
+	1381,
+	1317,
+	1381,
+	1316,
+	1381,
+	1317,
+	1382,
+	1318,
+	1382,
+	1317,
+	1382,
+	1318,
+	1383,
+	1319,
+	1383,
+	1318,
+	1383,
+	1319,
+	1384,
+	1320,
+	1384,
+	1319,
+	1384,
+	1320,
+	1385,
+	1321,
+	1385,
+	1320,
+	1385,
+	1321,
+	1386,
+	1322,
+	1386,
+	1321,
+	1386,
+	1322,
+	1387,
+	1323,
+	1387,
+	1322,
+	1387,
+	1323,
+	1388,
+	1324,
+	1388,
+	1323,
+	1388,
+	1324,
+	1389,
+	1325,
+	1389,
+	1324,
+	1389,
+	1325,
+	1390,
+	1326,
+	1390,
+	1325,
+	1390,
+	1326,
+	1391,
+	1327,
+	1391,
+	1326,
+	1391,
+	1327,
+	1392,
+	1328,
+	1392,
+	1327,
+	1392,
+	1328,
+	1393,
+	1329,
+	1393,
+	1328,
+	1393,
+	1329,
+	1394,
+	1330,
+	1394,
+	1329,
+	1394,
+	1330,
+	1395,
+	1331,
+	1395,
+	1330,
+	1395,
+	1331,
+	1396,
+	1332,
+	1396,
+	1331,
+	1396,
+	1332,
+	1397,
+	1333,
+	1397,
+	1332,
+	1397,
+	1333,
+	1398,
+	1334,
+	1398,
+	1333,
+	1398,
+	1334,
+	1399,
+	1335,
+	1399,
+	1334,
+	1399,
+	1335,
+	1400,
+	1336,
+	1400,
+	1335,
+	1400,
+	1336,
+	1401,
+	1337,
+	1401,
+	1336,
+	1401,
+	1337,
+	1402,
+	1338,
+	1402,
+	1337,
+	1402,
+	1338,
+	1403,
+	1339,
+	1403,
+	1338,
+	1403,
+	1339,
+	1404,
+	1340,
+	1404,
+	1339,
+	1404,
+	1340,
+	1405,
+	1341,
+	1405,
+	1340,
+	1405,
+	1341,
+	1406,
+	1342,
+	1406,
+	1341,
+	1406,
+	1342,
+	1407,
+	1343,
+	1407,
+	1342,
+	1408,
+	1344,
+	1409,
+	1345,
+	1409,
+	1344,
+	1409,
+	1345,
+	1410,
+	1346,
+	1410,
+	1345,
+	1410,
+	1346,
+	1411,
+	1347,
+	1411,
+	1346,
+	1411,
+	1347,
+	1412,
+	1348,
+	1412,
+	1347,
+	1412,
+	1348,
+	1413,
+	1349,
+	1413,
+	1348,
+	1413,
+	1349,
+	1414,
+	1350,
+	1414,
+	1349,
+	1414,
+	1350,
+	1415,
+	1351,
+	1415,
+	1350,
+	1415,
+	1351,
+	1416,
+	1352,
+	1416,
+	1351,
+	1416,
+	1352,
+	1417,
+	1353,
+	1417,
+	1352,
+	1417,
+	1353,
+	1418,
+	1354,
+	1418,
+	1353,
+	1418,
+	1354,
+	1419,
+	1355,
+	1419,
+	1354,
+	1419,
+	1355,
+	1420,
+	1356,
+	1420,
+	1355,
+	1420,
+	1356,
+	1421,
+	1357,
+	1421,
+	1356,
+	1421,
+	1357,
+	1422,
+	1358,
+	1422,
+	1357,
+	1422,
+	1358,
+	1423,
+	1359,
+	1423,
+	1358,
+	1423,
+	1359,
+	1424,
+	1360,
+	1424,
+	1359,
+	1424,
+	1360,
+	1425,
+	1361,
+	1425,
+	1360,
+	1425,
+	1361,
+	1426,
+	1362,
+	1426,
+	1361,
+	1426,
+	1362,
+	1427,
+	1363,
+	1427,
+	1362,
+	1427,
+	1363,
+	1428,
+	1364,
+	1428,
+	1363,
+	1428,
+	1364,
+	1429,
+	1365,
+	1429,
+	1364,
+	1429,
+	1365,
+	1430,
+	1366,
+	1430,
+	1365,
+	1430,
+	1366,
+	1431,
+	1367,
+	1431,
+	1366,
+	1431,
+	1367,
+	1432,
+	1368,
+	1432,
+	1367,
+	1432,
+	1368,
+	1433,
+	1369,
+	1433,
+	1368,
+	1433,
+	1369,
+	1434,
+	1370,
+	1434,
+	1369,
+	1434,
+	1370,
+	1435,
+	1371,
+	1435,
+	1370,
+	1435,
+	1371,
+	1436,
+	1372,
+	1436,
+	1371,
+	1436,
+	1372,
+	1437,
+	1373,
+	1437,
+	1372,
+	1437,
+	1373,
+	1438,
+	1374,
+	1438,
+	1373,
+	1438,
+	1374,
+	1439,
+	1375,
+	1439,
+	1374,
+	1439,
+	1375,
+	1440,
+	1376,
+	1440,
+	1375,
+	1440,
+	1376,
+	1441,
+	1377,
+	1441,
+	1376,
+	1441,
+	1377,
+	1442,
+	1378,
+	1442,
+	1377,
+	1442,
+	1378,
+	1443,
+	1379,
+	1443,
+	1378,
+	1443,
+	1379,
+	1444,
+	1380,
+	1444,
+	1379,
+	1444,
+	1380,
+	1445,
+	1381,
+	1445,
+	1380,
+	1445,
+	1381,
+	1446,
+	1382,
+	1446,
+	1381,
+	1446,
+	1382,
+	1447,
+	1383,
+	1447,
+	1382,
+	1447,
+	1383,
+	1448,
+	1384,
+	1448,
+	1383,
+	1448,
+	1384,
+	1449,
+	1385,
+	1449,
+	1384,
+	1449,
+	1385,
+	1450,
+	1386,
+	1450,
+	1385,
+	1450,
+	1386,
+	1451,
+	1387,
+	1451,
+	1386,
+	1451,
+	1387,
+	1452,
+	1388,
+	1452,
+	1387,
+	1452,
+	1388,
+	1453,
+	1389,
+	1453,
+	1388,
+	1453,
+	1389,
+	1454,
+	1390,
+	1454,
+	1389,
+	1454,
+	1390,
+	1455,
+	1391,
+	1455,
+	1390,
+	1455,
+	1391,
+	1456,
+	1392,
+	1456,
+	1391,
+	1456,
+	1392,
+	1457,
+	1393,
+	1457,
+	1392,
+	1457,
+	1393,
+	1458,
+	1394,
+	1458,
+	1393,
+	1458,
+	1394,
+	1459,
+	1395,
+	1459,
+	1394,
+	1459,
+	1395,
+	1460,
+	1396,
+	1460,
+	1395,
+	1460,
+	1396,
+	1461,
+	1397,
+	1461,
+	1396,
+	1461,
+	1397,
+	1462,
+	1398,
+	1462,
+	1397,
+	1462,
+	1398,
+	1463,
+	1399,
+	1463,
+	1398,
+	1463,
+	1399,
+	1464,
+	1400,
+	1464,
+	1399,
+	1464,
+	1400,
+	1465,
+	1401,
+	1465,
+	1400,
+	1465,
+	1401,
+	1466,
+	1402,
+	1466,
+	1401,
+	1466,
+	1402,
+	1467,
+	1403,
+	1467,
+	1402,
+	1467,
+	1403,
+	1468,
+	1404,
+	1468,
+	1403,
+	1468,
+	1404,
+	1469,
+	1405,
+	1469,
+	1404,
+	1469,
+	1405,
+	1470,
+	1406,
+	1470,
+	1405,
+	1470,
+	1406,
+	1471,
+	1407,
+	1471,
+	1406,
+	1472,
+	1408,
+	1473,
+	1409,
+	1473,
+	1408,
+	1473,
+	1409,
+	1474,
+	1410,
+	1474,
+	1409,
+	1474,
+	1410,
+	1475,
+	1411,
+	1475,
+	1410,
+	1475,
+	1411,
+	1476,
+	1412,
+	1476,
+	1411,
+	1476,
+	1412,
+	1477,
+	1413,
+	1477,
+	1412,
+	1477,
+	1413,
+	1478,
+	1414,
+	1478,
+	1413,
+	1478,
+	1414,
+	1479,
+	1415,
+	1479,
+	1414,
+	1479,
+	1415,
+	1480,
+	1416,
+	1480,
+	1415,
+	1480,
+	1416,
+	1481,
+	1417,
+	1481,
+	1416,
+	1481,
+	1417,
+	1482,
+	1418,
+	1482,
+	1417,
+	1482,
+	1418,
+	1483,
+	1419,
+	1483,
+	1418,
+	1483,
+	1419,
+	1484,
+	1420,
+	1484,
+	1419,
+	1484,
+	1420,
+	1485,
+	1421,
+	1485,
+	1420,
+	1485,
+	1421,
+	1486,
+	1422,
+	1486,
+	1421,
+	1486,
+	1422,
+	1487,
+	1423,
+	1487,
+	1422,
+	1487,
+	1423,
+	1488,
+	1424,
+	1488,
+	1423,
+	1488,
+	1424,
+	1489,
+	1425,
+	1489,
+	1424,
+	1489,
+	1425,
+	1490,
+	1426,
+	1490,
+	1425,
+	1490,
+	1426,
+	1491,
+	1427,
+	1491,
+	1426,
+	1491,
+	1427,
+	1492,
+	1428,
+	1492,
+	1427,
+	1492,
+	1428,
+	1493,
+	1429,
+	1493,
+	1428,
+	1493,
+	1429,
+	1494,
+	1430,
+	1494,
+	1429,
+	1494,
+	1430,
+	1495,
+	1431,
+	1495,
+	1430,
+	1495,
+	1431,
+	1496,
+	1432,
+	1496,
+	1431,
+	1496,
+	1432,
+	1497,
+	1433,
+	1497,
+	1432,
+	1497,
+	1433,
+	1498,
+	1434,
+	1498,
+	1433,
+	1498,
+	1434,
+	1499,
+	1435,
+	1499,
+	1434,
+	1499,
+	1435,
+	1500,
+	1436,
+	1500,
+	1435,
+	1500,
+	1436,
+	1501,
+	1437,
+	1501,
+	1436,
+	1501,
+	1437,
+	1502,
+	1438,
+	1502,
+	1437,
+	1502,
+	1438,
+	1503,
+	1439,
+	1503,
+	1438,
+	1503,
+	1439,
+	1504,
+	1440,
+	1504,
+	1439,
+	1504,
+	1440,
+	1505,
+	1441,
+	1505,
+	1440,
+	1505,
+	1441,
+	1506,
+	1442,
+	1506,
+	1441,
+	1506,
+	1442,
+	1507,
+	1443,
+	1507,
+	1442,
+	1507,
+	1443,
+	1508,
+	1444,
+	1508,
+	1443,
+	1508,
+	1444,
+	1509,
+	1445,
+	1509,
+	1444,
+	1509,
+	1445,
+	1510,
+	1446,
+	1510,
+	1445,
+	1510,
+	1446,
+	1511,
+	1447,
+	1511,
+	1446,
+	1511,
+	1447,
+	1512,
+	1448,
+	1512,
+	1447,
+	1512,
+	1448,
+	1513,
+	1449,
+	1513,
+	1448,
+	1513,
+	1449,
+	1514,
+	1450,
+	1514,
+	1449,
+	1514,
+	1450,
+	1515,
+	1451,
+	1515,
+	1450,
+	1515,
+	1451,
+	1516,
+	1452,
+	1516,
+	1451,
+	1516,
+	1452,
+	1517,
+	1453,
+	1517,
+	1452,
+	1517,
+	1453,
+	1518,
+	1454,
+	1518,
+	1453,
+	1518,
+	1454,
+	1519,
+	1455,
+	1519,
+	1454,
+	1519,
+	1455,
+	1520,
+	1456,
+	1520,
+	1455,
+	1520,
+	1456,
+	1521,
+	1457,
+	1521,
+	1456,
+	1521,
+	1457,
+	1522,
+	1458,
+	1522,
+	1457,
+	1522,
+	1458,
+	1523,
+	1459,
+	1523,
+	1458,
+	1523,
+	1459,
+	1524,
+	1460,
+	1524,
+	1459,
+	1524,
+	1460,
+	1525,
+	1461,
+	1525,
+	1460,
+	1525,
+	1461,
+	1526,
+	1462,
+	1526,
+	1461,
+	1526,
+	1462,
+	1527,
+	1463,
+	1527,
+	1462,
+	1527,
+	1463,
+	1528,
+	1464,
+	1528,
+	1463,
+	1528,
+	1464,
+	1529,
+	1465,
+	1529,
+	1464,
+	1529,
+	1465,
+	1530,
+	1466,
+	1530,
+	1465,
+	1530,
+	1466,
+	1531,
+	1467,
+	1531,
+	1466,
+	1531,
+	1467,
+	1532,
+	1468,
+	1532,
+	1467,
+	1532,
+	1468,
+	1533,
+	1469,
+	1533,
+	1468,
+	1533,
+	1469,
+	1534,
+	1470,
+	1534,
+	1469,
+	1534,
+	1470,
+	1535,
+	1471,
+	1535,
+	1470,
+	1536,
+	1472,
+	1537,
+	1473,
+	1537,
+	1472,
+	1537,
+	1473,
+	1538,
+	1474,
+	1538,
+	1473,
+	1538,
+	1474,
+	1539,
+	1475,
+	1539,
+	1474,
+	1539,
+	1475,
+	1540,
+	1476,
+	1540,
+	1475,
+	1540,
+	1476,
+	1541,
+	1477,
+	1541,
+	1476,
+	1541,
+	1477,
+	1542,
+	1478,
+	1542,
+	1477,
+	1542,
+	1478,
+	1543,
+	1479,
+	1543,
+	1478,
+	1543,
+	1479,
+	1544,
+	1480,
+	1544,
+	1479,
+	1544,
+	1480,
+	1545,
+	1481,
+	1545,
+	1480,
+	1545,
+	1481,
+	1546,
+	1482,
+	1546,
+	1481,
+	1546,
+	1482,
+	1547,
+	1483,
+	1547,
+	1482,
+	1547,
+	1483,
+	1548,
+	1484,
+	1548,
+	1483,
+	1548,
+	1484,
+	1549,
+	1485,
+	1549,
+	1484,
+	1549,
+	1485,
+	1550,
+	1486,
+	1550,
+	1485,
+	1550,
+	1486,
+	1551,
+	1487,
+	1551,
+	1486,
+	1551,
+	1487,
+	1552,
+	1488,
+	1552,
+	1487,
+	1552,
+	1488,
+	1553,
+	1489,
+	1553,
+	1488,
+	1553,
+	1489,
+	1554,
+	1490,
+	1554,
+	1489,
+	1554,
+	1490,
+	1555,
+	1491,
+	1555,
+	1490,
+	1555,
+	1491,
+	1556,
+	1492,
+	1556,
+	1491,
+	1556,
+	1492,
+	1557,
+	1493,
+	1557,
+	1492,
+	1557,
+	1493,
+	1558,
+	1494,
+	1558,
+	1493,
+	1558,
+	1494,
+	1559,
+	1495,
+	1559,
+	1494,
+	1559,
+	1495,
+	1560,
+	1496,
+	1560,
+	1495,
+	1560,
+	1496,
+	1561,
+	1497,
+	1561,
+	1496,
+	1561,
+	1497,
+	1562,
+	1498,
+	1562,
+	1497,
+	1562,
+	1498,
+	1563,
+	1499,
+	1563,
+	1498,
+	1563,
+	1499,
+	1564,
+	1500,
+	1564,
+	1499,
+	1564,
+	1500,
+	1565,
+	1501,
+	1565,
+	1500,
+	1565,
+	1501,
+	1566,
+	1502,
+	1566,
+	1501,
+	1566,
+	1502,
+	1567,
+	1503,
+	1567,
+	1502,
+	1567,
+	1503,
+	1568,
+	1504,
+	1568,
+	1503,
+	1568,
+	1504,
+	1569,
+	1505,
+	1569,
+	1504,
+	1569,
+	1505,
+	1570,
+	1506,
+	1570,
+	1505,
+	1570,
+	1506,
+	1571,
+	1507,
+	1571,
+	1506,
+	1571,
+	1507,
+	1572,
+	1508,
+	1572,
+	1507,
+	1572,
+	1508,
+	1573,
+	1509,
+	1573,
+	1508,
+	1573,
+	1509,
+	1574,
+	1510,
+	1574,
+	1509,
+	1574,
+	1510,
+	1575,
+	1511,
+	1575,
+	1510,
+	1575,
+	1511,
+	1576,
+	1512,
+	1576,
+	1511,
+	1576,
+	1512,
+	1577,
+	1513,
+	1577,
+	1512,
+	1577,
+	1513,
+	1578,
+	1514,
+	1578,
+	1513,
+	1578,
+	1514,
+	1579,
+	1515,
+	1579,
+	1514,
+	1579,
+	1515,
+	1580,
+	1516,
+	1580,
+	1515,
+	1580,
+	1516,
+	1581,
+	1517,
+	1581,
+	1516,
+	1581,
+	1517,
+	1582,
+	1518,
+	1582,
+	1517,
+	1582,
+	1518,
+	1583,
+	1519,
+	1583,
+	1518,
+	1583,
+	1519,
+	1584,
+	1520,
+	1584,
+	1519,
+	1584,
+	1520,
+	1585,
+	1521,
+	1585,
+	1520,
+	1585,
+	1521,
+	1586,
+	1522,
+	1586,
+	1521,
+	1586,
+	1522,
+	1587,
+	1523,
+	1587,
+	1522,
+	1587,
+	1523,
+	1588,
+	1524,
+	1588,
+	1523,
+	1588,
+	1524,
+	1589,
+	1525,
+	1589,
+	1524,
+	1589,
+	1525,
+	1590,
+	1526,
+	1590,
+	1525,
+	1590,
+	1526,
+	1591,
+	1527,
+	1591,
+	1526,
+	1591,
+	1527,
+	1592,
+	1528,
+	1592,
+	1527,
+	1592,
+	1528,
+	1593,
+	1529,
+	1593,
+	1528,
+	1593,
+	1529,
+	1594,
+	1530,
+	1594,
+	1529,
+	1594,
+	1530,
+	1595,
+	1531,
+	1595,
+	1530,
+	1595,
+	1531,
+	1596,
+	1532,
+	1596,
+	1531,
+	1596,
+	1532,
+	1597,
+	1533,
+	1597,
+	1532,
+	1597,
+	1533,
+	1598,
+	1534,
+	1598,
+	1533,
+	1598,
+	1534,
+	1599,
+	1535,
+	1599,
+	1534,
+	1600,
+	1536,
+	1601,
+	1537,
+	1601,
+	1536,
+	1601,
+	1537,
+	1602,
+	1538,
+	1602,
+	1537,
+	1602,
+	1538,
+	1603,
+	1539,
+	1603,
+	1538,
+	1603,
+	1539,
+	1604,
+	1540,
+	1604,
+	1539,
+	1604,
+	1540,
+	1605,
+	1541,
+	1605,
+	1540,
+	1605,
+	1541,
+	1606,
+	1542,
+	1606,
+	1541,
+	1606,
+	1542,
+	1607,
+	1543,
+	1607,
+	1542,
+	1607,
+	1543,
+	1608,
+	1544,
+	1608,
+	1543,
+	1608,
+	1544,
+	1609,
+	1545,
+	1609,
+	1544,
+	1609,
+	1545,
+	1610,
+	1546,
+	1610,
+	1545,
+	1610,
+	1546,
+	1611,
+	1547,
+	1611,
+	1546,
+	1611,
+	1547,
+	1612,
+	1548,
+	1612,
+	1547,
+	1612,
+	1548,
+	1613,
+	1549,
+	1613,
+	1548,
+	1613,
+	1549,
+	1614,
+	1550,
+	1614,
+	1549,
+	1614,
+	1550,
+	1615,
+	1551,
+	1615,
+	1550,
+	1615,
+	1551,
+	1616,
+	1552,
+	1616,
+	1551,
+	1616,
+	1552,
+	1617,
+	1553,
+	1617,
+	1552,
+	1617,
+	1553,
+	1618,
+	1554,
+	1618,
+	1553,
+	1618,
+	1554,
+	1619,
+	1555,
+	1619,
+	1554,
+	1619,
+	1555,
+	1620,
+	1556,
+	1620,
+	1555,
+	1620,
+	1556,
+	1621,
+	1557,
+	1621,
+	1556,
+	1621,
+	1557,
+	1622,
+	1558,
+	1622,
+	1557,
+	1622,
+	1558,
+	1623,
+	1559,
+	1623,
+	1558,
+	1623,
+	1559,
+	1624,
+	1560,
+	1624,
+	1559,
+	1624,
+	1560,
+	1625,
+	1561,
+	1625,
+	1560,
+	1625,
+	1561,
+	1626,
+	1562,
+	1626,
+	1561,
+	1626,
+	1562,
+	1627,
+	1563,
+	1627,
+	1562,
+	1627,
+	1563,
+	1628,
+	1564,
+	1628,
+	1563,
+	1628,
+	1564,
+	1629,
+	1565,
+	1629,
+	1564,
+	1629,
+	1565,
+	1630,
+	1566,
+	1630,
+	1565,
+	1630,
+	1566,
+	1631,
+	1567,
+	1631,
+	1566,
+	1631,
+	1567,
+	1632,
+	1568,
+	1632,
+	1567,
+	1632,
+	1568,
+	1633,
+	1569,
+	1633,
+	1568,
+	1633,
+	1569,
+	1634,
+	1570,
+	1634,
+	1569,
+	1634,
+	1570,
+	1635,
+	1571,
+	1635,
+	1570,
+	1635,
+	1571,
+	1636,
+	1572,
+	1636,
+	1571,
+	1636,
+	1572,
+	1637,
+	1573,
+	1637,
+	1572,
+	1637,
+	1573,
+	1638,
+	1574,
+	1638,
+	1573,
+	1638,
+	1574,
+	1639,
+	1575,
+	1639,
+	1574,
+	1639,
+	1575,
+	1640,
+	1576,
+	1640,
+	1575,
+	1640,
+	1576,
+	1641,
+	1577,
+	1641,
+	1576,
+	1641,
+	1577,
+	1642,
+	1578,
+	1642,
+	1577,
+	1642,
+	1578,
+	1643,
+	1579,
+	1643,
+	1578,
+	1643,
+	1579,
+	1644,
+	1580,
+	1644,
+	1579,
+	1644,
+	1580,
+	1645,
+	1581,
+	1645,
+	1580,
+	1645,
+	1581,
+	1646,
+	1582,
+	1646,
+	1581,
+	1646,
+	1582,
+	1647,
+	1583,
+	1647,
+	1582,
+	1647,
+	1583,
+	1648,
+	1584,
+	1648,
+	1583,
+	1648,
+	1584,
+	1649,
+	1585,
+	1649,
+	1584,
+	1649,
+	1585,
+	1650,
+	1586,
+	1650,
+	1585,
+	1650,
+	1586,
+	1651,
+	1587,
+	1651,
+	1586,
+	1651,
+	1587,
+	1652,
+	1588,
+	1652,
+	1587,
+	1652,
+	1588,
+	1653,
+	1589,
+	1653,
+	1588,
+	1653,
+	1589,
+	1654,
+	1590,
+	1654,
+	1589,
+	1654,
+	1590,
+	1655,
+	1591,
+	1655,
+	1590,
+	1655,
+	1591,
+	1656,
+	1592,
+	1656,
+	1591,
+	1656,
+	1592,
+	1657,
+	1593,
+	1657,
+	1592,
+	1657,
+	1593,
+	1658,
+	1594,
+	1658,
+	1593,
+	1658,
+	1594,
+	1659,
+	1595,
+	1659,
+	1594,
+	1659,
+	1595,
+	1660,
+	1596,
+	1660,
+	1595,
+	1660,
+	1596,
+	1661,
+	1597,
+	1661,
+	1596,
+	1661,
+	1597,
+	1662,
+	1598,
+	1662,
+	1597,
+	1662,
+	1598,
+	1663,
+	1599,
+	1663,
+	1598,
+	1664,
+	1600,
+	1665,
+	1601,
+	1665,
+	1600,
+	1665,
+	1601,
+	1666,
+	1602,
+	1666,
+	1601,
+	1666,
+	1602,
+	1667,
+	1603,
+	1667,
+	1602,
+	1667,
+	1603,
+	1668,
+	1604,
+	1668,
+	1603,
+	1668,
+	1604,
+	1669,
+	1605,
+	1669,
+	1604,
+	1669,
+	1605,
+	1670,
+	1606,
+	1670,
+	1605,
+	1670,
+	1606,
+	1671,
+	1607,
+	1671,
+	1606,
+	1671,
+	1607,
+	1672,
+	1608,
+	1672,
+	1607,
+	1672,
+	1608,
+	1673,
+	1609,
+	1673,
+	1608,
+	1673,
+	1609,
+	1674,
+	1610,
+	1674,
+	1609,
+	1674,
+	1610,
+	1675,
+	1611,
+	1675,
+	1610,
+	1675,
+	1611,
+	1676,
+	1612,
+	1676,
+	1611,
+	1676,
+	1612,
+	1677,
+	1613,
+	1677,
+	1612,
+	1677,
+	1613,
+	1678,
+	1614,
+	1678,
+	1613,
+	1678,
+	1614,
+	1679,
+	1615,
+	1679,
+	1614,
+	1679,
+	1615,
+	1680,
+	1616,
+	1680,
+	1615,
+	1680,
+	1616,
+	1681,
+	1617,
+	1681,
+	1616,
+	1681,
+	1617,
+	1682,
+	1618,
+	1682,
+	1617,
+	1682,
+	1618,
+	1683,
+	1619,
+	1683,
+	1618,
+	1683,
+	1619,
+	1684,
+	1620,
+	1684,
+	1619,
+	1684,
+	1620,
+	1685,
+	1621,
+	1685,
+	1620,
+	1685,
+	1621,
+	1686,
+	1622,
+	1686,
+	1621,
+	1686,
+	1622,
+	1687,
+	1623,
+	1687,
+	1622,
+	1687,
+	1623,
+	1688,
+	1624,
+	1688,
+	1623,
+	1688,
+	1624,
+	1689,
+	1625,
+	1689,
+	1624,
+	1689,
+	1625,
+	1690,
+	1626,
+	1690,
+	1625,
+	1690,
+	1626,
+	1691,
+	1627,
+	1691,
+	1626,
+	1691,
+	1627,
+	1692,
+	1628,
+	1692,
+	1627,
+	1692,
+	1628,
+	1693,
+	1629,
+	1693,
+	1628,
+	1693,
+	1629,
+	1694,
+	1630,
+	1694,
+	1629,
+	1694,
+	1630,
+	1695,
+	1631,
+	1695,
+	1630,
+	1695,
+	1631,
+	1696,
+	1632,
+	1696,
+	1631,
+	1696,
+	1632,
+	1697,
+	1633,
+	1697,
+	1632,
+	1697,
+	1633,
+	1698,
+	1634,
+	1698,
+	1633,
+	1698,
+	1634,
+	1699,
+	1635,
+	1699,
+	1634,
+	1699,
+	1635,
+	1700,
+	1636,
+	1700,
+	1635,
+	1700,
+	1636,
+	1701,
+	1637,
+	1701,
+	1636,
+	1701,
+	1637,
+	1702,
+	1638,
+	1702,
+	1637,
+	1702,
+	1638,
+	1703,
+	1639,
+	1703,
+	1638,
+	1703,
+	1639,
+	1704,
+	1640,
+	1704,
+	1639,
+	1704,
+	1640,
+	1705,
+	1641,
+	1705,
+	1640,
+	1705,
+	1641,
+	1706,
+	1642,
+	1706,
+	1641,
+	1706,
+	1642,
+	1707,
+	1643,
+	1707,
+	1642,
+	1707,
+	1643,
+	1708,
+	1644,
+	1708,
+	1643,
+	1708,
+	1644,
+	1709,
+	1645,
+	1709,
+	1644,
+	1709,
+	1645,
+	1710,
+	1646,
+	1710,
+	1645,
+	1710,
+	1646,
+	1711,
+	1647,
+	1711,
+	1646,
+	1711,
+	1647,
+	1712,
+	1648,
+	1712,
+	1647,
+	1712,
+	1648,
+	1713,
+	1649,
+	1713,
+	1648,
+	1713,
+	1649,
+	1714,
+	1650,
+	1714,
+	1649,
+	1714,
+	1650,
+	1715,
+	1651,
+	1715,
+	1650,
+	1715,
+	1651,
+	1716,
+	1652,
+	1716,
+	1651,
+	1716,
+	1652,
+	1717,
+	1653,
+	1717,
+	1652,
+	1717,
+	1653,
+	1718,
+	1654,
+	1718,
+	1653,
+	1718,
+	1654,
+	1719,
+	1655,
+	1719,
+	1654,
+	1719,
+	1655,
+	1720,
+	1656,
+	1720,
+	1655,
+	1720,
+	1656,
+	1721,
+	1657,
+	1721,
+	1656,
+	1721,
+	1657,
+	1722,
+	1658,
+	1722,
+	1657,
+	1722,
+	1658,
+	1723,
+	1659,
+	1723,
+	1658,
+	1723,
+	1659,
+	1724,
+	1660,
+	1724,
+	1659,
+	1724,
+	1660,
+	1725,
+	1661,
+	1725,
+	1660,
+	1725,
+	1661,
+	1726,
+	1662,
+	1726,
+	1661,
+	1726,
+	1662,
+	1727,
+	1663,
+	1727,
+	1662,
+	1728,
+	1664,
+	1729,
+	1665,
+	1729,
+	1664,
+	1729,
+	1665,
+	1730,
+	1666,
+	1730,
+	1665,
+	1730,
+	1666,
+	1731,
+	1667,
+	1731,
+	1666,
+	1731,
+	1667,
+	1732,
+	1668,
+	1732,
+	1667,
+	1732,
+	1668,
+	1733,
+	1669,
+	1733,
+	1668,
+	1733,
+	1669,
+	1734,
+	1670,
+	1734,
+	1669,
+	1734,
+	1670,
+	1735,
+	1671,
+	1735,
+	1670,
+	1735,
+	1671,
+	1736,
+	1672,
+	1736,
+	1671,
+	1736,
+	1672,
+	1737,
+	1673,
+	1737,
+	1672,
+	1737,
+	1673,
+	1738,
+	1674,
+	1738,
+	1673,
+	1738,
+	1674,
+	1739,
+	1675,
+	1739,
+	1674,
+	1739,
+	1675,
+	1740,
+	1676,
+	1740,
+	1675,
+	1740,
+	1676,
+	1741,
+	1677,
+	1741,
+	1676,
+	1741,
+	1677,
+	1742,
+	1678,
+	1742,
+	1677,
+	1742,
+	1678,
+	1743,
+	1679,
+	1743,
+	1678,
+	1743,
+	1679,
+	1744,
+	1680,
+	1744,
+	1679,
+	1744,
+	1680,
+	1745,
+	1681,
+	1745,
+	1680,
+	1745,
+	1681,
+	1746,
+	1682,
+	1746,
+	1681,
+	1746,
+	1682,
+	1747,
+	1683,
+	1747,
+	1682,
+	1747,
+	1683,
+	1748,
+	1684,
+	1748,
+	1683,
+	1748,
+	1684,
+	1749,
+	1685,
+	1749,
+	1684,
+	1749,
+	1685,
+	1750,
+	1686,
+	1750,
+	1685,
+	1750,
+	1686,
+	1751,
+	1687,
+	1751,
+	1686,
+	1751,
+	1687,
+	1752,
+	1688,
+	1752,
+	1687,
+	1752,
+	1688,
+	1753,
+	1689,
+	1753,
+	1688,
+	1753,
+	1689,
+	1754,
+	1690,
+	1754,
+	1689,
+	1754,
+	1690,
+	1755,
+	1691,
+	1755,
+	1690,
+	1755,
+	1691,
+	1756,
+	1692,
+	1756,
+	1691,
+	1756,
+	1692,
+	1757,
+	1693,
+	1757,
+	1692,
+	1757,
+	1693,
+	1758,
+	1694,
+	1758,
+	1693,
+	1758,
+	1694,
+	1759,
+	1695,
+	1759,
+	1694,
+	1759,
+	1695,
+	1760,
+	1696,
+	1760,
+	1695,
+	1760,
+	1696,
+	1761,
+	1697,
+	1761,
+	1696,
+	1761,
+	1697,
+	1762,
+	1698,
+	1762,
+	1697,
+	1762,
+	1698,
+	1763,
+	1699,
+	1763,
+	1698,
+	1763,
+	1699,
+	1764,
+	1700,
+	1764,
+	1699,
+	1764,
+	1700,
+	1765,
+	1701,
+	1765,
+	1700,
+	1765,
+	1701,
+	1766,
+	1702,
+	1766,
+	1701,
+	1766,
+	1702,
+	1767,
+	1703,
+	1767,
+	1702,
+	1767,
+	1703,
+	1768,
+	1704,
+	1768,
+	1703,
+	1768,
+	1704,
+	1769,
+	1705,
+	1769,
+	1704,
+	1769,
+	1705,
+	1770,
+	1706,
+	1770,
+	1705,
+	1770,
+	1706,
+	1771,
+	1707,
+	1771,
+	1706,
+	1771,
+	1707,
+	1772,
+	1708,
+	1772,
+	1707,
+	1772,
+	1708,
+	1773,
+	1709,
+	1773,
+	1708,
+	1773,
+	1709,
+	1774,
+	1710,
+	1774,
+	1709,
+	1774,
+	1710,
+	1775,
+	1711,
+	1775,
+	1710,
+	1775,
+	1711,
+	1776,
+	1712,
+	1776,
+	1711,
+	1776,
+	1712,
+	1777,
+	1713,
+	1777,
+	1712,
+	1777,
+	1713,
+	1778,
+	1714,
+	1778,
+	1713,
+	1778,
+	1714,
+	1779,
+	1715,
+	1779,
+	1714,
+	1779,
+	1715,
+	1780,
+	1716,
+	1780,
+	1715,
+	1780,
+	1716,
+	1781,
+	1717,
+	1781,
+	1716,
+	1781,
+	1717,
+	1782,
+	1718,
+	1782,
+	1717,
+	1782,
+	1718,
+	1783,
+	1719,
+	1783,
+	1718,
+	1783,
+	1719,
+	1784,
+	1720,
+	1784,
+	1719,
+	1784,
+	1720,
+	1785,
+	1721,
+	1785,
+	1720,
+	1785,
+	1721,
+	1786,
+	1722,
+	1786,
+	1721,
+	1786,
+	1722,
+	1787,
+	1723,
+	1787,
+	1722,
+	1787,
+	1723,
+	1788,
+	1724,
+	1788,
+	1723,
+	1788,
+	1724,
+	1789,
+	1725,
+	1789,
+	1724,
+	1789,
+	1725,
+	1790,
+	1726,
+	1790,
+	1725,
+	1790,
+	1726,
+	1791,
+	1727,
+	1791,
+	1726,
+	1792,
+	1728,
+	1793,
+	1729,
+	1793,
+	1728,
+	1793,
+	1729,
+	1794,
+	1730,
+	1794,
+	1729,
+	1794,
+	1730,
+	1795,
+	1731,
+	1795,
+	1730,
+	1795,
+	1731,
+	1796,
+	1732,
+	1796,
+	1731,
+	1796,
+	1732,
+	1797,
+	1733,
+	1797,
+	1732,
+	1797,
+	1733,
+	1798,
+	1734,
+	1798,
+	1733,
+	1798,
+	1734,
+	1799,
+	1735,
+	1799,
+	1734,
+	1799,
+	1735,
+	1800,
+	1736,
+	1800,
+	1735,
+	1800,
+	1736,
+	1801,
+	1737,
+	1801,
+	1736,
+	1801,
+	1737,
+	1802,
+	1738,
+	1802,
+	1737,
+	1802,
+	1738,
+	1803,
+	1739,
+	1803,
+	1738,
+	1803,
+	1739,
+	1804,
+	1740,
+	1804,
+	1739,
+	1804,
+	1740,
+	1805,
+	1741,
+	1805,
+	1740,
+	1805,
+	1741,
+	1806,
+	1742,
+	1806,
+	1741,
+	1806,
+	1742,
+	1807,
+	1743,
+	1807,
+	1742,
+	1807,
+	1743,
+	1808,
+	1744,
+	1808,
+	1743,
+	1808,
+	1744,
+	1809,
+	1745,
+	1809,
+	1744,
+	1809,
+	1745,
+	1810,
+	1746,
+	1810,
+	1745,
+	1810,
+	1746,
+	1811,
+	1747,
+	1811,
+	1746,
+	1811,
+	1747,
+	1812,
+	1748,
+	1812,
+	1747,
+	1812,
+	1748,
+	1813,
+	1749,
+	1813,
+	1748,
+	1813,
+	1749,
+	1814,
+	1750,
+	1814,
+	1749,
+	1814,
+	1750,
+	1815,
+	1751,
+	1815,
+	1750,
+	1815,
+	1751,
+	1816,
+	1752,
+	1816,
+	1751,
+	1816,
+	1752,
+	1817,
+	1753,
+	1817,
+	1752,
+	1817,
+	1753,
+	1818,
+	1754,
+	1818,
+	1753,
+	1818,
+	1754,
+	1819,
+	1755,
+	1819,
+	1754,
+	1819,
+	1755,
+	1820,
+	1756,
+	1820,
+	1755,
+	1820,
+	1756,
+	1821,
+	1757,
+	1821,
+	1756,
+	1821,
+	1757,
+	1822,
+	1758,
+	1822,
+	1757,
+	1822,
+	1758,
+	1823,
+	1759,
+	1823,
+	1758,
+	1823,
+	1759,
+	1824,
+	1760,
+	1824,
+	1759,
+	1824,
+	1760,
+	1825,
+	1761,
+	1825,
+	1760,
+	1825,
+	1761,
+	1826,
+	1762,
+	1826,
+	1761,
+	1826,
+	1762,
+	1827,
+	1763,
+	1827,
+	1762,
+	1827,
+	1763,
+	1828,
+	1764,
+	1828,
+	1763,
+	1828,
+	1764,
+	1829,
+	1765,
+	1829,
+	1764,
+	1829,
+	1765,
+	1830,
+	1766,
+	1830,
+	1765,
+	1830,
+	1766,
+	1831,
+	1767,
+	1831,
+	1766,
+	1831,
+	1767,
+	1832,
+	1768,
+	1832,
+	1767,
+	1832,
+	1768,
+	1833,
+	1769,
+	1833,
+	1768,
+	1833,
+	1769,
+	1834,
+	1770,
+	1834,
+	1769,
+	1834,
+	1770,
+	1835,
+	1771,
+	1835,
+	1770,
+	1835,
+	1771,
+	1836,
+	1772,
+	1836,
+	1771,
+	1836,
+	1772,
+	1837,
+	1773,
+	1837,
+	1772,
+	1837,
+	1773,
+	1838,
+	1774,
+	1838,
+	1773,
+	1838,
+	1774,
+	1839,
+	1775,
+	1839,
+	1774,
+	1839,
+	1775,
+	1840,
+	1776,
+	1840,
+	1775,
+	1840,
+	1776,
+	1841,
+	1777,
+	1841,
+	1776,
+	1841,
+	1777,
+	1842,
+	1778,
+	1842,
+	1777,
+	1842,
+	1778,
+	1843,
+	1779,
+	1843,
+	1778,
+	1843,
+	1779,
+	1844,
+	1780,
+	1844,
+	1779,
+	1844,
+	1780,
+	1845,
+	1781,
+	1845,
+	1780,
+	1845,
+	1781,
+	1846,
+	1782,
+	1846,
+	1781,
+	1846,
+	1782,
+	1847,
+	1783,
+	1847,
+	1782,
+	1847,
+	1783,
+	1848,
+	1784,
+	1848,
+	1783,
+	1848,
+	1784,
+	1849,
+	1785,
+	1849,
+	1784,
+	1849,
+	1785,
+	1850,
+	1786,
+	1850,
+	1785,
+	1850,
+	1786,
+	1851,
+	1787,
+	1851,
+	1786,
+	1851,
+	1787,
+	1852,
+	1788,
+	1852,
+	1787,
+	1852,
+	1788,
+	1853,
+	1789,
+	1853,
+	1788,
+	1853,
+	1789,
+	1854,
+	1790,
+	1854,
+	1789,
+	1854,
+	1790,
+	1855,
+	1791,
+	1855,
+	1790,
+	1856,
+	1792,
+	1857,
+	1793,
+	1857,
+	1792,
+	1857,
+	1793,
+	1858,
+	1794,
+	1858,
+	1793,
+	1858,
+	1794,
+	1859,
+	1795,
+	1859,
+	1794,
+	1859,
+	1795,
+	1860,
+	1796,
+	1860,
+	1795,
+	1860,
+	1796,
+	1861,
+	1797,
+	1861,
+	1796,
+	1861,
+	1797,
+	1862,
+	1798,
+	1862,
+	1797,
+	1862,
+	1798,
+	1863,
+	1799,
+	1863,
+	1798,
+	1863,
+	1799,
+	1864,
+	1800,
+	1864,
+	1799,
+	1864,
+	1800,
+	1865,
+	1801,
+	1865,
+	1800,
+	1865,
+	1801,
+	1866,
+	1802,
+	1866,
+	1801,
+	1866,
+	1802,
+	1867,
+	1803,
+	1867,
+	1802,
+	1867,
+	1803,
+	1868,
+	1804,
+	1868,
+	1803,
+	1868,
+	1804,
+	1869,
+	1805,
+	1869,
+	1804,
+	1869,
+	1805,
+	1870,
+	1806,
+	1870,
+	1805,
+	1870,
+	1806,
+	1871,
+	1807,
+	1871,
+	1806,
+	1871,
+	1807,
+	1872,
+	1808,
+	1872,
+	1807,
+	1872,
+	1808,
+	1873,
+	1809,
+	1873,
+	1808,
+	1873,
+	1809,
+	1874,
+	1810,
+	1874,
+	1809,
+	1874,
+	1810,
+	1875,
+	1811,
+	1875,
+	1810,
+	1875,
+	1811,
+	1876,
+	1812,
+	1876,
+	1811,
+	1876,
+	1812,
+	1877,
+	1813,
+	1877,
+	1812,
+	1877,
+	1813,
+	1878,
+	1814,
+	1878,
+	1813,
+	1878,
+	1814,
+	1879,
+	1815,
+	1879,
+	1814,
+	1879,
+	1815,
+	1880,
+	1816,
+	1880,
+	1815,
+	1880,
+	1816,
+	1881,
+	1817,
+	1881,
+	1816,
+	1881,
+	1817,
+	1882,
+	1818,
+	1882,
+	1817,
+	1882,
+	1818,
+	1883,
+	1819,
+	1883,
+	1818,
+	1883,
+	1819,
+	1884,
+	1820,
+	1884,
+	1819,
+	1884,
+	1820,
+	1885,
+	1821,
+	1885,
+	1820,
+	1885,
+	1821,
+	1886,
+	1822,
+	1886,
+	1821,
+	1886,
+	1822,
+	1887,
+	1823,
+	1887,
+	1822,
+	1887,
+	1823,
+	1888,
+	1824,
+	1888,
+	1823,
+	1888,
+	1824,
+	1889,
+	1825,
+	1889,
+	1824,
+	1889,
+	1825,
+	1890,
+	1826,
+	1890,
+	1825,
+	1890,
+	1826,
+	1891,
+	1827,
+	1891,
+	1826,
+	1891,
+	1827,
+	1892,
+	1828,
+	1892,
+	1827,
+	1892,
+	1828,
+	1893,
+	1829,
+	1893,
+	1828,
+	1893,
+	1829,
+	1894,
+	1830,
+	1894,
+	1829,
+	1894,
+	1830,
+	1895,
+	1831,
+	1895,
+	1830,
+	1895,
+	1831,
+	1896,
+	1832,
+	1896,
+	1831,
+	1896,
+	1832,
+	1897,
+	1833,
+	1897,
+	1832,
+	1897,
+	1833,
+	1898,
+	1834,
+	1898,
+	1833,
+	1898,
+	1834,
+	1899,
+	1835,
+	1899,
+	1834,
+	1899,
+	1835,
+	1900,
+	1836,
+	1900,
+	1835,
+	1900,
+	1836,
+	1901,
+	1837,
+	1901,
+	1836,
+	1901,
+	1837,
+	1902,
+	1838,
+	1902,
+	1837,
+	1902,
+	1838,
+	1903,
+	1839,
+	1903,
+	1838,
+	1903,
+	1839,
+	1904,
+	1840,
+	1904,
+	1839,
+	1904,
+	1840,
+	1905,
+	1841,
+	1905,
+	1840,
+	1905,
+	1841,
+	1906,
+	1842,
+	1906,
+	1841,
+	1906,
+	1842,
+	1907,
+	1843,
+	1907,
+	1842,
+	1907,
+	1843,
+	1908,
+	1844,
+	1908,
+	1843,
+	1908,
+	1844,
+	1909,
+	1845,
+	1909,
+	1844,
+	1909,
+	1845,
+	1910,
+	1846,
+	1910,
+	1845,
+	1910,
+	1846,
+	1911,
+	1847,
+	1911,
+	1846,
+	1911,
+	1847,
+	1912,
+	1848,
+	1912,
+	1847,
+	1912,
+	1848,
+	1913,
+	1849,
+	1913,
+	1848,
+	1913,
+	1849,
+	1914,
+	1850,
+	1914,
+	1849,
+	1914,
+	1850,
+	1915,
+	1851,
+	1915,
+	1850,
+	1915,
+	1851,
+	1916,
+	1852,
+	1916,
+	1851,
+	1916,
+	1852,
+	1917,
+	1853,
+	1917,
+	1852,
+	1917,
+	1853,
+	1918,
+	1854,
+	1918,
+	1853,
+	1918,
+	1854,
+	1919,
+	1855,
+	1919,
+	1854,
+	1920,
+	1856,
+	1921,
+	1857,
+	1921,
+	1856,
+	1921,
+	1857,
+	1922,
+	1858,
+	1922,
+	1857,
+	1922,
+	1858,
+	1923,
+	1859,
+	1923,
+	1858,
+	1923,
+	1859,
+	1924,
+	1860,
+	1924,
+	1859,
+	1924,
+	1860,
+	1925,
+	1861,
+	1925,
+	1860,
+	1925,
+	1861,
+	1926,
+	1862,
+	1926,
+	1861,
+	1926,
+	1862,
+	1927,
+	1863,
+	1927,
+	1862,
+	1927,
+	1863,
+	1928,
+	1864,
+	1928,
+	1863,
+	1928,
+	1864,
+	1929,
+	1865,
+	1929,
+	1864,
+	1929,
+	1865,
+	1930,
+	1866,
+	1930,
+	1865,
+	1930,
+	1866,
+	1931,
+	1867,
+	1931,
+	1866,
+	1931,
+	1867,
+	1932,
+	1868,
+	1932,
+	1867,
+	1932,
+	1868,
+	1933,
+	1869,
+	1933,
+	1868,
+	1933,
+	1869,
+	1934,
+	1870,
+	1934,
+	1869,
+	1934,
+	1870,
+	1935,
+	1871,
+	1935,
+	1870,
+	1935,
+	1871,
+	1936,
+	1872,
+	1936,
+	1871,
+	1936,
+	1872,
+	1937,
+	1873,
+	1937,
+	1872,
+	1937,
+	1873,
+	1938,
+	1874,
+	1938,
+	1873,
+	1938,
+	1874,
+	1939,
+	1875,
+	1939,
+	1874,
+	1939,
+	1875,
+	1940,
+	1876,
+	1940,
+	1875,
+	1940,
+	1876,
+	1941,
+	1877,
+	1941,
+	1876,
+	1941,
+	1877,
+	1942,
+	1878,
+	1942,
+	1877,
+	1942,
+	1878,
+	1943,
+	1879,
+	1943,
+	1878,
+	1943,
+	1879,
+	1944,
+	1880,
+	1944,
+	1879,
+	1944,
+	1880,
+	1945,
+	1881,
+	1945,
+	1880,
+	1945,
+	1881,
+	1946,
+	1882,
+	1946,
+	1881,
+	1946,
+	1882,
+	1947,
+	1883,
+	1947,
+	1882,
+	1947,
+	1883,
+	1948,
+	1884,
+	1948,
+	1883,
+	1948,
+	1884,
+	1949,
+	1885,
+	1949,
+	1884,
+	1949,
+	1885,
+	1950,
+	1886,
+	1950,
+	1885,
+	1950,
+	1886,
+	1951,
+	1887,
+	1951,
+	1886,
+	1951,
+	1887,
+	1952,
+	1888,
+	1952,
+	1887,
+	1952,
+	1888,
+	1953,
+	1889,
+	1953,
+	1888,
+	1953,
+	1889,
+	1954,
+	1890,
+	1954,
+	1889,
+	1954,
+	1890,
+	1955,
+	1891,
+	1955,
+	1890,
+	1955,
+	1891,
+	1956,
+	1892,
+	1956,
+	1891,
+	1956,
+	1892,
+	1957,
+	1893,
+	1957,
+	1892,
+	1957,
+	1893,
+	1958,
+	1894,
+	1958,
+	1893,
+	1958,
+	1894,
+	1959,
+	1895,
+	1959,
+	1894,
+	1959,
+	1895,
+	1960,
+	1896,
+	1960,
+	1895,
+	1960,
+	1896,
+	1961,
+	1897,
+	1961,
+	1896,
+	1961,
+	1897,
+	1962,
+	1898,
+	1962,
+	1897,
+	1962,
+	1898,
+	1963,
+	1899,
+	1963,
+	1898,
+	1963,
+	1899,
+	1964,
+	1900,
+	1964,
+	1899,
+	1964,
+	1900,
+	1965,
+	1901,
+	1965,
+	1900,
+	1965,
+	1901,
+	1966,
+	1902,
+	1966,
+	1901,
+	1966,
+	1902,
+	1967,
+	1903,
+	1967,
+	1902,
+	1967,
+	1903,
+	1968,
+	1904,
+	1968,
+	1903,
+	1968,
+	1904,
+	1969,
+	1905,
+	1969,
+	1904,
+	1969,
+	1905,
+	1970,
+	1906,
+	1970,
+	1905,
+	1970,
+	1906,
+	1971,
+	1907,
+	1971,
+	1906,
+	1971,
+	1907,
+	1972,
+	1908,
+	1972,
+	1907,
+	1972,
+	1908,
+	1973,
+	1909,
+	1973,
+	1908,
+	1973,
+	1909,
+	1974,
+	1910,
+	1974,
+	1909,
+	1974,
+	1910,
+	1975,
+	1911,
+	1975,
+	1910,
+	1975,
+	1911,
+	1976,
+	1912,
+	1976,
+	1911,
+	1976,
+	1912,
+	1977,
+	1913,
+	1977,
+	1912,
+	1977,
+	1913,
+	1978,
+	1914,
+	1978,
+	1913,
+	1978,
+	1914,
+	1979,
+	1915,
+	1979,
+	1914,
+	1979,
+	1915,
+	1980,
+	1916,
+	1980,
+	1915,
+	1980,
+	1916,
+	1981,
+	1917,
+	1981,
+	1916,
+	1981,
+	1917,
+	1982,
+	1918,
+	1982,
+	1917,
+	1982,
+	1918,
+	1983,
+	1919,
+	1983,
+	1918,
+	1984,
+	1920,
+	1985,
+	1921,
+	1985,
+	1920,
+	1985,
+	1921,
+	1986,
+	1922,
+	1986,
+	1921,
+	1986,
+	1922,
+	1987,
+	1923,
+	1987,
+	1922,
+	1987,
+	1923,
+	1988,
+	1924,
+	1988,
+	1923,
+	1988,
+	1924,
+	1989,
+	1925,
+	1989,
+	1924,
+	1989,
+	1925,
+	1990,
+	1926,
+	1990,
+	1925,
+	1990,
+	1926,
+	1991,
+	1927,
+	1991,
+	1926,
+	1991,
+	1927,
+	1992,
+	1928,
+	1992,
+	1927,
+	1992,
+	1928,
+	1993,
+	1929,
+	1993,
+	1928,
+	1993,
+	1929,
+	1994,
+	1930,
+	1994,
+	1929,
+	1994,
+	1930,
+	1995,
+	1931,
+	1995,
+	1930,
+	1995,
+	1931,
+	1996,
+	1932,
+	1996,
+	1931,
+	1996,
+	1932,
+	1997,
+	1933,
+	1997,
+	1932,
+	1997,
+	1933,
+	1998,
+	1934,
+	1998,
+	1933,
+	1998,
+	1934,
+	1999,
+	1935,
+	1999,
+	1934,
+	1999,
+	1935,
+	2000,
+	1936,
+	2000,
+	1935,
+	2000,
+	1936,
+	2001,
+	1937,
+	2001,
+	1936,
+	2001,
+	1937,
+	2002,
+	1938,
+	2002,
+	1937,
+	2002,
+	1938,
+	2003,
+	1939,
+	2003,
+	1938,
+	2003,
+	1939,
+	2004,
+	1940,
+	2004,
+	1939,
+	2004,
+	1940,
+	2005,
+	1941,
+	2005,
+	1940,
+	2005,
+	1941,
+	2006,
+	1942,
+	2006,
+	1941,
+	2006,
+	1942,
+	2007,
+	1943,
+	2007,
+	1942,
+	2007,
+	1943,
+	2008,
+	1944,
+	2008,
+	1943,
+	2008,
+	1944,
+	2009,
+	1945,
+	2009,
+	1944,
+	2009,
+	1945,
+	2010,
+	1946,
+	2010,
+	1945,
+	2010,
+	1946,
+	2011,
+	1947,
+	2011,
+	1946,
+	2011,
+	1947,
+	2012,
+	1948,
+	2012,
+	1947,
+	2012,
+	1948,
+	2013,
+	1949,
+	2013,
+	1948,
+	2013,
+	1949,
+	2014,
+	1950,
+	2014,
+	1949,
+	2014,
+	1950,
+	2015,
+	1951,
+	2015,
+	1950,
+	2015,
+	1951,
+	2016,
+	1952,
+	2016,
+	1951,
+	2016,
+	1952,
+	2017,
+	1953,
+	2017,
+	1952,
+	2017,
+	1953,
+	2018,
+	1954,
+	2018,
+	1953,
+	2018,
+	1954,
+	2019,
+	1955,
+	2019,
+	1954,
+	2019,
+	1955,
+	2020,
+	1956,
+	2020,
+	1955,
+	2020,
+	1956,
+	2021,
+	1957,
+	2021,
+	1956,
+	2021,
+	1957,
+	2022,
+	1958,
+	2022,
+	1957,
+	2022,
+	1958,
+	2023,
+	1959,
+	2023,
+	1958,
+	2023,
+	1959,
+	2024,
+	1960,
+	2024,
+	1959,
+	2024,
+	1960,
+	2025,
+	1961,
+	2025,
+	1960,
+	2025,
+	1961,
+	2026,
+	1962,
+	2026,
+	1961,
+	2026,
+	1962,
+	2027,
+	1963,
+	2027,
+	1962,
+	2027,
+	1963,
+	2028,
+	1964,
+	2028,
+	1963,
+	2028,
+	1964,
+	2029,
+	1965,
+	2029,
+	1964,
+	2029,
+	1965,
+	2030,
+	1966,
+	2030,
+	1965,
+	2030,
+	1966,
+	2031,
+	1967,
+	2031,
+	1966,
+	2031,
+	1967,
+	2032,
+	1968,
+	2032,
+	1967,
+	2032,
+	1968,
+	2033,
+	1969,
+	2033,
+	1968,
+	2033,
+	1969,
+	2034,
+	1970,
+	2034,
+	1969,
+	2034,
+	1970,
+	2035,
+	1971,
+	2035,
+	1970,
+	2035,
+	1971,
+	2036,
+	1972,
+	2036,
+	1971,
+	2036,
+	1972,
+	2037,
+	1973,
+	2037,
+	1972,
+	2037,
+	1973,
+	2038,
+	1974,
+	2038,
+	1973,
+	2038,
+	1974,
+	2039,
+	1975,
+	2039,
+	1974,
+	2039,
+	1975,
+	2040,
+	1976,
+	2040,
+	1975,
+	2040,
+	1976,
+	2041,
+	1977,
+	2041,
+	1976,
+	2041,
+	1977,
+	2042,
+	1978,
+	2042,
+	1977,
+	2042,
+	1978,
+	2043,
+	1979,
+	2043,
+	1978,
+	2043,
+	1979,
+	2044,
+	1980,
+	2044,
+	1979,
+	2044,
+	1980,
+	2045,
+	1981,
+	2045,
+	1980,
+	2045,
+	1981,
+	2046,
+	1982,
+	2046,
+	1981,
+	2046,
+	1982,
+	2047,
+	1983,
+	2047,
+	1982,
+	2048,
+	1984,
+	2049,
+	1985,
+	2049,
+	1984,
+	2049,
+	1985,
+	2050,
+	1986,
+	2050,
+	1985,
+	2050,
+	1986,
+	2051,
+	1987,
+	2051,
+	1986,
+	2051,
+	1987,
+	2052,
+	1988,
+	2052,
+	1987,
+	2052,
+	1988,
+	2053,
+	1989,
+	2053,
+	1988,
+	2053,
+	1989,
+	2054,
+	1990,
+	2054,
+	1989,
+	2054,
+	1990,
+	2055,
+	1991,
+	2055,
+	1990,
+	2055,
+	1991,
+	2056,
+	1992,
+	2056,
+	1991,
+	2056,
+	1992,
+	2057,
+	1993,
+	2057,
+	1992,
+	2057,
+	1993,
+	2058,
+	1994,
+	2058,
+	1993,
+	2058,
+	1994,
+	2059,
+	1995,
+	2059,
+	1994,
+	2059,
+	1995,
+	2060,
+	1996,
+	2060,
+	1995,
+	2060,
+	1996,
+	2061,
+	1997,
+	2061,
+	1996,
+	2061,
+	1997,
+	2062,
+	1998,
+	2062,
+	1997,
+	2062,
+	1998,
+	2063,
+	1999,
+	2063,
+	1998,
+	2063,
+	1999,
+	2064,
+	2000,
+	2064,
+	1999,
+	2064,
+	2000,
+	2065,
+	2001,
+	2065,
+	2000,
+	2065,
+	2001,
+	2066,
+	2002,
+	2066,
+	2001,
+	2066,
+	2002,
+	2067,
+	2003,
+	2067,
+	2002,
+	2067,
+	2003,
+	2068,
+	2004,
+	2068,
+	2003,
+	2068,
+	2004,
+	2069,
+	2005,
+	2069,
+	2004,
+	2069,
+	2005,
+	2070,
+	2006,
+	2070,
+	2005,
+	2070,
+	2006,
+	2071,
+	2007,
+	2071,
+	2006,
+	2071,
+	2007,
+	2072,
+	2008,
+	2072,
+	2007,
+	2072,
+	2008,
+	2073,
+	2009,
+	2073,
+	2008,
+	2073,
+	2009,
+	2074,
+	2010,
+	2074,
+	2009,
+	2074,
+	2010,
+	2075,
+	2011,
+	2075,
+	2010,
+	2075,
+	2011,
+	2076,
+	2012,
+	2076,
+	2011,
+	2076,
+	2012,
+	2077,
+	2013,
+	2077,
+	2012,
+	2077,
+	2013,
+	2078,
+	2014,
+	2078,
+	2013,
+	2078,
+	2014,
+	2079,
+	2015,
+	2079,
+	2014,
+	2079,
+	2015,
+	2080,
+	2016,
+	2080,
+	2015,
+	2080,
+	2016,
+	2081,
+	2017,
+	2081,
+	2016,
+	2081,
+	2017,
+	2082,
+	2018,
+	2082,
+	2017,
+	2082,
+	2018,
+	2083,
+	2019,
+	2083,
+	2018,
+	2083,
+	2019,
+	2084,
+	2020,
+	2084,
+	2019,
+	2084,
+	2020,
+	2085,
+	2021,
+	2085,
+	2020,
+	2085,
+	2021,
+	2086,
+	2022,
+	2086,
+	2021,
+	2086,
+	2022,
+	2087,
+	2023,
+	2087,
+	2022,
+	2087,
+	2023,
+	2088,
+	2024,
+	2088,
+	2023,
+	2088,
+	2024,
+	2089,
+	2025,
+	2089,
+	2024,
+	2089,
+	2025,
+	2090,
+	2026,
+	2090,
+	2025,
+	2090,
+	2026,
+	2091,
+	2027,
+	2091,
+	2026,
+	2091,
+	2027,
+	2092,
+	2028,
+	2092,
+	2027,
+	2092,
+	2028,
+	2093,
+	2029,
+	2093,
+	2028,
+	2093,
+	2029,
+	2094,
+	2030,
+	2094,
+	2029,
+	2094,
+	2030,
+	2095,
+	2031,
+	2095,
+	2030,
+	2095,
+	2031,
+	2096,
+	2032,
+	2096,
+	2031,
+	2096,
+	2032,
+	2097,
+	2033,
+	2097,
+	2032,
+	2097,
+	2033,
+	2098,
+	2034,
+	2098,
+	2033,
+	2098,
+	2034,
+	2099,
+	2035,
+	2099,
+	2034,
+	2099,
+	2035,
+	2100,
+	2036,
+	2100,
+	2035,
+	2100,
+	2036,
+	2101,
+	2037,
+	2101,
+	2036,
+	2101,
+	2037,
+	2102,
+	2038,
+	2102,
+	2037,
+	2102,
+	2038,
+	2103,
+	2039,
+	2103,
+	2038,
+	2103,
+	2039,
+	2104,
+	2040,
+	2104,
+	2039,
+	2104,
+	2040,
+	2105,
+	2041,
+	2105,
+	2040,
+	2105,
+	2041,
+	2106,
+	2042,
+	2106,
+	2041,
+	2106,
+	2042,
+	2107,
+	2043,
+	2107,
+	2042,
+	2107,
+	2043,
+	2108,
+	2044,
+	2108,
+	2043,
+	2108,
+	2044,
+	2109,
+	2045,
+	2109,
+	2044,
+	2109,
+	2045,
+	2110,
+	2046,
+	2110,
+	2045,
+	2110,
+	2046,
+	2111,
+	2047,
+	2111,
+	2046,
+};
+
+#define Landscape05VtxCount 2244
+#define Landscape05IdxCount 12870
+
+btScalar Landscape05Vtx[] = {
+	-250.0f,
+	-0.990273f,
+	0.0f,
+	-250.0f,
+	0.139875f,
+	3.90625f,
+	-246.094f,
+	0.671004f,
+	0.0f,
+	-246.094f,
+	1.72995f,
+	3.90625f,
+	-242.188f,
+	1.84097f,
+	0.0f,
+	-242.188f,
+	2.60122f,
+	3.90625f,
+	-238.281f,
+	3.67319f,
+	-1.6056e-007f,
+	-238.281f,
+	4.01346f,
+	3.90625f,
+	-234.375f,
+	4.96849f,
+	-2.1718e-007f,
+	-234.375f,
+	5.13654f,
+	3.90625f,
+	-230.469f,
+	6.56215f,
+	-2.86841e-007f,
+	-230.469f,
+	6.69665f,
+	3.90625f,
+	-226.563f,
+	8.30102f,
+	-3.62849e-007f,
+	-226.563f,
+	8.43203f,
+	3.90625f,
+	-222.656f,
+	9.94385f,
+	-4.3466e-007f,
+	-222.656f,
+	9.83442f,
+	3.90625f,
+	-218.75f,
+	11.5986f,
+	-5.06992e-007f,
+	-218.75f,
+	11.3645f,
+	3.90625f,
+	-214.844f,
+	14.3141f,
+	-6.2569e-007f,
+	-214.844f,
+	14.222f,
+	3.90625f,
+	-210.938f,
+	16.5538f,
+	-7.2359e-007f,
+	-210.938f,
+	16.1758f,
+	3.90625f,
+	-207.031f,
+	18.852f,
+	-8.24046e-007f,
+	-207.031f,
+	18.9127f,
+	3.90625f,
+	-203.125f,
+	21.5344f,
+	-9.41301e-007f,
+	-203.125f,
+	21.2478f,
+	3.90625f,
+	-199.219f,
+	22.7337f,
+	-9.93723e-007f,
+	-199.219f,
+	23.0589f,
+	3.90625f,
+	-195.313f,
+	24.4712f,
+	-1.06967e-006f,
+	-195.313f,
+	24.6025f,
+	3.90625f,
+	-191.406f,
+	26.1169f,
+	-1.14161e-006f,
+	-191.406f,
+	25.8143f,
+	3.90625f,
+	-187.5f,
+	26.9988f,
+	-1.18015e-006f,
+	-187.5f,
+	27.5696f,
+	3.90625f,
+	-183.594f,
+	28.3854f,
+	-1.24077e-006f,
+	-183.594f,
+	29.2176f,
+	3.90625f,
+	-179.688f,
+	29.0457f,
+	-1.26963e-006f,
+	-179.688f,
+	29.6835f,
+	3.90625f,
+	-175.781f,
+	29.802f,
+	-1.30269e-006f,
+	-175.781f,
+	30.7416f,
+	3.90625f,
+	-171.875f,
+	30.1559f,
+	-1.31816e-006f,
+	-171.875f,
+	31.4405f,
+	3.90625f,
+	-167.969f,
+	32.3708f,
+	-1.41497e-006f,
+	-167.969f,
+	33.0831f,
+	3.90625f,
+	-164.063f,
+	34.9705f,
+	-1.52861e-006f,
+	-164.063f,
+	34.6225f,
+	3.90625f,
+	-160.156f,
+	36.396f,
+	-1.59092e-006f,
+	-160.156f,
+	35.4992f,
+	3.90625f,
+	-156.25f,
+	37.2947f,
+	-1.6302e-006f,
+	-156.25f,
+	37.4126f,
+	3.90625f,
+	-152.344f,
+	38.248f,
+	-1.67187e-006f,
+	-152.344f,
+	38.453f,
+	3.90625f,
+	-148.438f,
+	38.3176f,
+	-1.67491e-006f,
+	-148.438f,
+	38.9974f,
+	3.90625f,
+	-144.531f,
+	38.1589f,
+	-1.66798e-006f,
+	-144.531f,
+	38.7871f,
+	3.90625f,
+	-140.625f,
+	36.5895f,
+	-1.59938e-006f,
+	-140.625f,
+	37.6021f,
+	3.90625f,
+	-136.719f,
+	35.718f,
+	-1.56128e-006f,
+	-136.719f,
+	36.1797f,
+	3.90625f,
+	-132.813f,
+	33.7519f,
+	-1.47534e-006f,
+	-132.813f,
+	34.9906f,
+	3.90625f,
+	-128.906f,
+	33.2853f,
+	-1.45495e-006f,
+	-128.906f,
+	34.1304f,
+	3.90625f,
+	-125.0f,
+	33.4003f,
+	-1.45997e-006f,
+	-125.0f,
+	34.3517f,
+	3.90625f,
+	-121.094f,
+	33.1132f,
+	-1.44742e-006f,
+	-121.094f,
+	33.6612f,
+	3.90625f,
+	-117.188f,
+	32.7861f,
+	-1.43313e-006f,
+	-117.188f,
+	32.7047f,
+	3.90625f,
+	-113.281f,
+	33.0037f,
+	-1.44264e-006f,
+	-113.281f,
+	32.3958f,
+	3.90625f,
+	-109.375f,
+	32.508f,
+	-1.42097e-006f,
+	-109.375f,
+	31.0818f,
+	3.90625f,
+	-105.469f,
+	31.8384f,
+	-1.3917e-006f,
+	-105.469f,
+	30.9536f,
+	3.90625f,
+	-101.563f,
+	31.1858f,
+	-1.36317e-006f,
+	-101.563f,
+	29.8205f,
+	3.90625f,
+	-97.6563f,
+	29.6739f,
+	-1.29709e-006f,
+	-97.6563f,
+	28.4796f,
+	3.90625f,
+	-93.75f,
+	27.8258f,
+	-1.2163e-006f,
+	-93.75f,
+	27.6494f,
+	3.90625f,
+	-89.8438f,
+	25.9046f,
+	-1.13232e-006f,
+	-89.8438f,
+	25.5721f,
+	3.90625f,
+	-85.9375f,
+	23.4229f,
+	-1.02385e-006f,
+	-85.9375f,
+	24.227f,
+	3.90625f,
+	-82.0313f,
+	23.3671f,
+	-1.02141e-006f,
+	-82.0313f,
+	23.2611f,
+	3.90625f,
+	-78.125f,
+	23.0585f,
+	-1.00792e-006f,
+	-78.125f,
+	22.4589f,
+	3.90625f,
+	-74.2188f,
+	23.9226f,
+	-1.04569e-006f,
+	-74.2188f,
+	23.2261f,
+	3.90625f,
+	-70.3125f,
+	23.6449f,
+	-1.03355e-006f,
+	-70.3125f,
+	23.5025f,
+	3.90625f,
+	-66.4063f,
+	23.2789f,
+	-1.01755e-006f,
+	-66.4063f,
+	23.6913f,
+	3.90625f,
+	-62.5f,
+	24.5841f,
+	-1.07461e-006f,
+	-62.5f,
+	24.6785f,
+	3.90625f,
+	-58.5938f,
+	25.71f,
+	-1.12382e-006f,
+	-58.5938f,
+	25.4946f,
+	3.90625f,
+	-54.6875f,
+	26.9872f,
+	-1.17965e-006f,
+	-54.6875f,
+	25.9722f,
+	3.90625f,
+	-50.7813f,
+	27.8632f,
+	-1.21794e-006f,
+	-50.7813f,
+	26.1977f,
+	3.90625f,
+	-46.875f,
+	28.0326f,
+	-1.22534e-006f,
+	-46.875f,
+	26.8539f,
+	3.90625f,
+	-42.9688f,
+	28.0866f,
+	-1.2277e-006f,
+	-42.9688f,
+	27.7268f,
+	3.90625f,
+	-39.0625f,
+	30.1482f,
+	-1.31782e-006f,
+	-39.0625f,
+	29.2046f,
+	3.90625f,
+	-35.1563f,
+	32.4049f,
+	-1.41646e-006f,
+	-35.1563f,
+	31.79f,
+	3.90625f,
+	-31.25f,
+	34.4714f,
+	-1.50679e-006f,
+	-31.25f,
+	34.2658f,
+	3.90625f,
+	-27.3438f,
+	37.2668f,
+	-1.62898e-006f,
+	-27.3438f,
+	35.9914f,
+	3.90625f,
+	-23.4375f,
+	38.7934f,
+	-1.69571e-006f,
+	-23.4375f,
+	38.3776f,
+	3.90625f,
+	-19.5313f,
+	40.4024f,
+	-1.76605e-006f,
+	-19.5313f,
+	39.8852f,
+	3.90625f,
+	-15.625f,
+	42.8177f,
+	-1.87162e-006f,
+	-15.625f,
+	43.1455f,
+	3.90625f,
+	-11.7188f,
+	45.0198f,
+	-1.96788e-006f,
+	-11.7188f,
+	45.5059f,
+	3.90625f,
+	-7.8125f,
+	46.7349f,
+	-2.04285e-006f,
+	-7.8125f,
+	47.4257f,
+	3.90625f,
+	-3.90625f,
+	48.376f,
+	-2.11458e-006f,
+	-3.90625f,
+	49.9032f,
+	3.90625f,
+	0.0f,
+	49.9016f,
+	-2.18127e-006f,
+	0.0f,
+	52.0322f,
+	3.90625f,
+	3.90625f,
+	50.3865f,
+	-2.20246e-006f,
+	3.90625f,
+	52.6186f,
+	3.90625f,
+	-250.0f,
+	-0.818988f,
+	-3.90625f,
+	-246.094f,
+	0.671433f,
+	-3.90625f,
+	-242.188f,
+	2.83415f,
+	-3.90625f,
+	-238.281f,
+	4.19978f,
+	-3.90625f,
+	-234.375f,
+	5.59158f,
+	-3.90625f,
+	-230.469f,
+	6.94041f,
+	-3.90625f,
+	-226.563f,
+	8.34599f,
+	-3.90625f,
+	-222.656f,
+	9.85416f,
+	-3.90625f,
+	-218.75f,
+	10.8989f,
+	-3.90625f,
+	-214.844f,
+	13.6339f,
+	-3.90625f,
+	-210.938f,
+	16.5116f,
+	-3.90625f,
+	-207.031f,
+	17.7111f,
+	-3.90625f,
+	-203.125f,
+	20.7442f,
+	-3.90625f,
+	-199.219f,
+	22.5356f,
+	-3.90625f,
+	-195.313f,
+	24.3988f,
+	-3.90625f,
+	-191.406f,
+	25.8062f,
+	-3.90625f,
+	-187.5f,
+	26.9714f,
+	-3.90625f,
+	-183.594f,
+	27.7397f,
+	-3.90625f,
+	-179.688f,
+	28.8632f,
+	-3.90625f,
+	-175.781f,
+	29.9688f,
+	-3.90625f,
+	-171.875f,
+	32.154f,
+	-3.90625f,
+	-167.969f,
+	33.3799f,
+	-3.90625f,
+	-164.063f,
+	35.3882f,
+	-3.90625f,
+	-160.156f,
+	35.9765f,
+	-3.90625f,
+	-156.25f,
+	36.5306f,
+	-3.90625f,
+	-152.344f,
+	37.3214f,
+	-3.90625f,
+	-148.438f,
+	36.8126f,
+	-3.90625f,
+	-144.531f,
+	36.5407f,
+	-3.90625f,
+	-140.625f,
+	35.696f,
+	-3.90625f,
+	-136.719f,
+	35.1152f,
+	-3.90625f,
+	-132.813f,
+	34.1963f,
+	-3.90625f,
+	-128.906f,
+	34.0796f,
+	-3.90625f,
+	-125.0f,
+	34.2398f,
+	-3.90625f,
+	-121.094f,
+	34.1503f,
+	-3.90625f,
+	-117.188f,
+	33.7958f,
+	-3.90625f,
+	-113.281f,
+	33.856f,
+	-3.90625f,
+	-109.375f,
+	33.2705f,
+	-3.90625f,
+	-105.469f,
+	32.5804f,
+	-3.90625f,
+	-101.563f,
+	31.911f,
+	-3.90625f,
+	-97.6563f,
+	30.3705f,
+	-3.90625f,
+	-93.75f,
+	29.0627f,
+	-3.90625f,
+	-89.8438f,
+	26.6822f,
+	-3.90625f,
+	-85.9375f,
+	24.8309f,
+	-3.90625f,
+	-82.0313f,
+	23.8581f,
+	-3.90625f,
+	-78.125f,
+	23.3764f,
+	-3.90625f,
+	-74.2188f,
+	23.9582f,
+	-3.90625f,
+	-70.3125f,
+	24.13f,
+	-3.90625f,
+	-66.4063f,
+	24.4426f,
+	-3.90625f,
+	-62.5f,
+	25.5839f,
+	-3.90625f,
+	-58.5938f,
+	26.6899f,
+	-3.90625f,
+	-54.6875f,
+	27.9086f,
+	-3.90625f,
+	-50.7813f,
+	28.5131f,
+	-3.90625f,
+	-46.875f,
+	29.2612f,
+	-3.90625f,
+	-42.9688f,
+	29.4581f,
+	-3.90625f,
+	-39.0625f,
+	30.8972f,
+	-3.90625f,
+	-35.1563f,
+	32.9085f,
+	-3.90625f,
+	-31.25f,
+	34.9204f,
+	-3.90625f,
+	-27.3438f,
+	37.7223f,
+	-3.90625f,
+	-23.4375f,
+	38.921f,
+	-3.90625f,
+	-19.5313f,
+	40.2983f,
+	-3.90625f,
+	-15.625f,
+	41.7689f,
+	-3.90625f,
+	-11.7188f,
+	43.8388f,
+	-3.90625f,
+	-7.8125f,
+	44.7599f,
+	-3.90625f,
+	-3.90625f,
+	46.53f,
+	-3.90625f,
+	0.0f,
+	48.2498f,
+	-3.90625f,
+	3.90625f,
+	48.8559f,
+	-3.90625f,
+	-250.0f,
+	0.432867f,
+	-7.8125f,
+	-246.094f,
+	1.93096f,
+	-7.8125f,
+	-242.188f,
+	3.28774f,
+	-7.8125f,
+	-238.281f,
+	4.53112f,
+	-7.8125f,
+	-234.375f,
+	5.67699f,
+	-7.8125f,
+	-230.469f,
+	7.34068f,
+	-7.8125f,
+	-226.563f,
+	8.48553f,
+	-7.8125f,
+	-222.656f,
+	10.127f,
+	-7.8125f,
+	-218.75f,
+	11.3267f,
+	-7.8125f,
+	-214.844f,
+	13.3914f,
+	-7.8125f,
+	-210.938f,
+	15.5197f,
+	-7.8125f,
+	-207.031f,
+	17.9403f,
+	-7.8125f,
+	-203.125f,
+	20.5644f,
+	-7.8125f,
+	-199.219f,
+	22.8796f,
+	-7.8125f,
+	-195.313f,
+	23.715f,
+	-7.8125f,
+	-191.406f,
+	26.1312f,
+	-7.8125f,
+	-187.5f,
+	28.0754f,
+	-7.8125f,
+	-183.594f,
+	29.1199f,
+	-7.8125f,
+	-179.688f,
+	29.5774f,
+	-7.8125f,
+	-175.781f,
+	30.2676f,
+	-7.8125f,
+	-171.875f,
+	31.8275f,
+	-7.8125f,
+	-167.969f,
+	33.4969f,
+	-7.8125f,
+	-164.063f,
+	34.4445f,
+	-7.8125f,
+	-160.156f,
+	35.3881f,
+	-7.8125f,
+	-156.25f,
+	36.0267f,
+	-7.8125f,
+	-152.344f,
+	36.1221f,
+	-7.8125f,
+	-148.438f,
+	36.7707f,
+	-7.8125f,
+	-144.531f,
+	36.3067f,
+	-7.8125f,
+	-140.625f,
+	36.2295f,
+	-7.8125f,
+	-136.719f,
+	35.6858f,
+	-7.8125f,
+	-132.813f,
+	34.6232f,
+	-7.8125f,
+	-128.906f,
+	34.1675f,
+	-7.8125f,
+	-125.0f,
+	34.1756f,
+	-7.8125f,
+	-121.094f,
+	33.6453f,
+	-7.8125f,
+	-117.188f,
+	34.2516f,
+	-7.8125f,
+	-113.281f,
+	34.228f,
+	-7.8125f,
+	-109.375f,
+	34.253f,
+	-7.8125f,
+	-105.469f,
+	33.1798f,
+	-7.8125f,
+	-101.563f,
+	32.238f,
+	-7.8125f,
+	-97.6563f,
+	31.0377f,
+	-7.8125f,
+	-93.75f,
+	29.6795f,
+	-7.8125f,
+	-89.8438f,
+	27.5934f,
+	-7.8125f,
+	-85.9375f,
+	25.7426f,
+	-7.8125f,
+	-82.0313f,
+	24.4001f,
+	-7.8125f,
+	-78.125f,
+	24.4095f,
+	-7.8125f,
+	-74.2188f,
+	25.1494f,
+	-7.8125f,
+	-70.3125f,
+	25.0193f,
+	-7.8125f,
+	-66.4063f,
+	25.3902f,
+	-7.8125f,
+	-62.5f,
+	25.8612f,
+	-7.8125f,
+	-58.5938f,
+	26.8169f,
+	-7.8125f,
+	-54.6875f,
+	28.0698f,
+	-7.8125f,
+	-50.7813f,
+	28.978f,
+	-7.8125f,
+	-46.875f,
+	29.1063f,
+	-7.8125f,
+	-42.9688f,
+	30.6071f,
+	-7.8125f,
+	-39.0625f,
+	31.7015f,
+	-7.8125f,
+	-35.1563f,
+	32.6112f,
+	-7.8125f,
+	-31.25f,
+	34.6006f,
+	-7.8125f,
+	-27.3438f,
+	36.3005f,
+	-7.8125f,
+	-23.4375f,
+	38.4757f,
+	-7.8125f,
+	-19.5313f,
+	39.7014f,
+	-7.8125f,
+	-15.625f,
+	40.7762f,
+	-7.8125f,
+	-11.7188f,
+	42.6458f,
+	-7.8125f,
+	-7.8125f,
+	45.0307f,
+	-7.8125f,
+	-3.90625f,
+	47.2861f,
+	-7.8125f,
+	0.0f,
+	48.5591f,
+	-7.8125f,
+	3.90625f,
+	48.7225f,
+	-7.8125f,
+	-250.0f,
+	0.568294f,
+	-11.7188f,
+	-246.094f,
+	1.83097f,
+	-11.7188f,
+	-242.188f,
+	3.32037f,
+	-11.7188f,
+	-238.281f,
+	4.29184f,
+	-11.7188f,
+	-234.375f,
+	6.04113f,
+	-11.7188f,
+	-230.469f,
+	7.01872f,
+	-11.7188f,
+	-226.563f,
+	8.96731f,
+	-11.7188f,
+	-222.656f,
+	10.3749f,
+	-11.7188f,
+	-218.75f,
+	11.568f,
+	-11.7188f,
+	-214.844f,
+	13.9092f,
+	-11.7188f,
+	-210.938f,
+	15.6547f,
+	-11.7188f,
+	-207.031f,
+	18.2156f,
+	-11.7188f,
+	-203.125f,
+	20.0116f,
+	-11.7188f,
+	-199.219f,
+	21.5443f,
+	-11.7188f,
+	-195.313f,
+	23.4553f,
+	-11.7188f,
+	-191.406f,
+	26.2778f,
+	-11.7188f,
+	-187.5f,
+	28.0543f,
+	-11.7188f,
+	-183.594f,
+	29.2657f,
+	-11.7188f,
+	-179.688f,
+	29.6454f,
+	-11.7188f,
+	-175.781f,
+	30.699f,
+	-11.7188f,
+	-171.875f,
+	30.8229f,
+	-11.7188f,
+	-167.969f,
+	32.9874f,
+	-11.7188f,
+	-164.063f,
+	33.581f,
+	-11.7188f,
+	-160.156f,
+	34.6365f,
+	-11.7188f,
+	-156.25f,
+	35.6153f,
+	-11.7188f,
+	-152.344f,
+	36.2491f,
+	-11.7188f,
+	-148.438f,
+	36.2996f,
+	-11.7188f,
+	-144.531f,
+	36.5456f,
+	-11.7188f,
+	-140.625f,
+	36.3803f,
+	-11.7188f,
+	-136.719f,
+	35.2403f,
+	-11.7188f,
+	-132.813f,
+	34.0595f,
+	-11.7188f,
+	-128.906f,
+	34.1384f,
+	-11.7188f,
+	-125.0f,
+	33.59f,
+	-11.7188f,
+	-121.094f,
+	33.7745f,
+	-11.7188f,
+	-117.188f,
+	33.7284f,
+	-11.7188f,
+	-113.281f,
+	33.7013f,
+	-11.7188f,
+	-109.375f,
+	33.6335f,
+	-11.7188f,
+	-105.469f,
+	33.2451f,
+	-11.7188f,
+	-101.563f,
+	32.8691f,
+	-11.7188f,
+	-97.6563f,
+	31.1343f,
+	-11.7188f,
+	-93.75f,
+	29.5843f,
+	-11.7188f,
+	-89.8438f,
+	27.5891f,
+	-11.7188f,
+	-85.9375f,
+	25.75f,
+	-11.7188f,
+	-82.0313f,
+	25.4336f,
+	-11.7188f,
+	-78.125f,
+	25.6207f,
+	-11.7188f,
+	-74.2188f,
+	25.1627f,
+	-11.7188f,
+	-70.3125f,
+	25.542f,
+	-11.7188f,
+	-66.4063f,
+	25.5384f,
+	-11.7188f,
+	-62.5f,
+	25.9238f,
+	-11.7188f,
+	-58.5938f,
+	26.0718f,
+	-11.7188f,
+	-54.6875f,
+	27.4395f,
+	-11.7188f,
+	-50.7813f,
+	28.8032f,
+	-11.7188f,
+	-46.875f,
+	29.9667f,
+	-11.7188f,
+	-42.9688f,
+	31.7598f,
+	-11.7188f,
+	-39.0625f,
+	32.2636f,
+	-11.7188f,
+	-35.1563f,
+	32.5734f,
+	-11.7188f,
+	-31.25f,
+	33.543f,
+	-11.7188f,
+	-27.3438f,
+	35.1143f,
+	-11.7188f,
+	-23.4375f,
+	37.3147f,
+	-11.7188f,
+	-19.5313f,
+	39.2413f,
+	-11.7188f,
+	-15.625f,
+	41.8344f,
+	-11.7188f,
+	-11.7188f,
+	43.9992f,
+	-11.7188f,
+	-7.8125f,
+	46.8581f,
+	-11.7188f,
+	-3.90625f,
+	48.5977f,
+	-11.7188f,
+	0.0f,
+	48.7029f,
+	-11.7188f,
+	3.90625f,
+	49.6298f,
+	-11.7188f,
+	-250.0f,
+	1.50235f,
+	-15.625f,
+	-246.094f,
+	1.79115f,
+	-15.625f,
+	-242.188f,
+	2.52523f,
+	-15.625f,
+	-238.281f,
+	4.09278f,
+	-15.625f,
+	-234.375f,
+	6.21068f,
+	-15.625f,
+	-230.469f,
+	7.49819f,
+	-15.625f,
+	-226.563f,
+	8.56548f,
+	-15.625f,
+	-222.656f,
+	9.98954f,
+	-15.625f,
+	-218.75f,
+	12.3263f,
+	-15.625f,
+	-214.844f,
+	14.495f,
+	-15.625f,
+	-210.938f,
+	15.3551f,
+	-15.625f,
+	-207.031f,
+	17.6989f,
+	-15.625f,
+	-203.125f,
+	19.2847f,
+	-15.625f,
+	-199.219f,
+	21.1027f,
+	-15.625f,
+	-195.313f,
+	23.3408f,
+	-15.625f,
+	-191.406f,
+	25.3739f,
+	-15.625f,
+	-187.5f,
+	27.368f,
+	-15.625f,
+	-183.594f,
+	28.3731f,
+	-15.625f,
+	-179.688f,
+	29.5532f,
+	-15.625f,
+	-175.781f,
+	30.0011f,
+	-15.625f,
+	-171.875f,
+	31.0216f,
+	-15.625f,
+	-167.969f,
+	32.5546f,
+	-15.625f,
+	-164.063f,
+	32.6717f,
+	-15.625f,
+	-160.156f,
+	33.8465f,
+	-15.625f,
+	-156.25f,
+	35.1272f,
+	-15.625f,
+	-152.344f,
+	35.5572f,
+	-15.625f,
+	-148.438f,
+	36.643f,
+	-15.625f,
+	-144.531f,
+	36.4283f,
+	-15.625f,
+	-140.625f,
+	35.6122f,
+	-15.625f,
+	-136.719f,
+	35.358f,
+	-15.625f,
+	-132.813f,
+	34.1938f,
+	-15.625f,
+	-128.906f,
+	34.3913f,
+	-15.625f,
+	-125.0f,
+	33.2147f,
+	-15.625f,
+	-121.094f,
+	32.799f,
+	-15.625f,
+	-117.188f,
+	33.1385f,
+	-15.625f,
+	-113.281f,
+	33.1487f,
+	-15.625f,
+	-109.375f,
+	33.6564f,
+	-15.625f,
+	-105.469f,
+	33.2315f,
+	-15.625f,
+	-101.563f,
+	32.6066f,
+	-15.625f,
+	-97.6563f,
+	30.6926f,
+	-15.625f,
+	-93.75f,
+	28.534f,
+	-15.625f,
+	-89.8438f,
+	27.6738f,
+	-15.625f,
+	-85.9375f,
+	27.4216f,
+	-15.625f,
+	-82.0313f,
+	26.0324f,
+	-15.625f,
+	-78.125f,
+	25.775f,
+	-15.625f,
+	-74.2188f,
+	25.909f,
+	-15.625f,
+	-70.3125f,
+	25.0198f,
+	-15.625f,
+	-66.4063f,
+	25.9376f,
+	-15.625f,
+	-62.5f,
+	26.0382f,
+	-15.625f,
+	-58.5938f,
+	25.856f,
+	-15.625f,
+	-54.6875f,
+	27.3648f,
+	-15.625f,
+	-50.7813f,
+	28.9059f,
+	-15.625f,
+	-46.875f,
+	30.6601f,
+	-15.625f,
+	-42.9688f,
+	32.6996f,
+	-15.625f,
+	-39.0625f,
+	32.6909f,
+	-15.625f,
+	-35.1563f,
+	33.1697f,
+	-15.625f,
+	-31.25f,
+	34.6947f,
+	-15.625f,
+	-27.3438f,
+	35.6982f,
+	-15.625f,
+	-23.4375f,
+	38.2946f,
+	-15.625f,
+	-19.5313f,
+	40.6765f,
+	-15.625f,
+	-15.625f,
+	43.5894f,
+	-15.625f,
+	-11.7188f,
+	46.3071f,
+	-15.625f,
+	-7.8125f,
+	48.6578f,
+	-15.625f,
+	-3.90625f,
+	49.0003f,
+	-15.625f,
+	0.0f,
+	50.5123f,
+	-15.625f,
+	3.90625f,
+	50.6915f,
+	-15.625f,
+	-250.0f,
+	1.44302f,
+	-19.5313f,
+	-246.094f,
+	1.65093f,
+	-19.5313f,
+	-242.188f,
+	2.94233f,
+	-19.5313f,
+	-238.281f,
+	4.72065f,
+	-19.5313f,
+	-234.375f,
+	6.57861f,
+	-19.5313f,
+	-230.469f,
+	7.31849f,
+	-19.5313f,
+	-226.563f,
+	7.90567f,
+	-19.5313f,
+	-222.656f,
+	9.84414f,
+	-19.5313f,
+	-218.75f,
+	12.1574f,
+	-19.5313f,
+	-214.844f,
+	13.2825f,
+	-19.5313f,
+	-210.938f,
+	15.2284f,
+	-19.5313f,
+	-207.031f,
+	17.2765f,
+	-19.5313f,
+	-203.125f,
+	19.1565f,
+	-19.5313f,
+	-199.219f,
+	20.3098f,
+	-19.5313f,
+	-195.313f,
+	21.9346f,
+	-19.5313f,
+	-191.406f,
+	23.8549f,
+	-19.5313f,
+	-187.5f,
+	26.133f,
+	-19.5313f,
+	-183.594f,
+	27.5858f,
+	-19.5313f,
+	-179.688f,
+	28.557f,
+	-19.5313f,
+	-175.781f,
+	28.9754f,
+	-19.5313f,
+	-171.875f,
+	29.9709f,
+	-19.5313f,
+	-167.969f,
+	31.2632f,
+	-19.5313f,
+	-164.063f,
+	31.4957f,
+	-19.5313f,
+	-160.156f,
+	33.6753f,
+	-19.5313f,
+	-156.25f,
+	35.1342f,
+	-19.5313f,
+	-152.344f,
+	35.0617f,
+	-19.5313f,
+	-148.438f,
+	34.9467f,
+	-19.5313f,
+	-144.531f,
+	35.1042f,
+	-19.5313f,
+	-140.625f,
+	35.0842f,
+	-19.5313f,
+	-136.719f,
+	34.7766f,
+	-19.5313f,
+	-132.813f,
+	33.8305f,
+	-19.5313f,
+	-128.906f,
+	33.3013f,
+	-19.5313f,
+	-125.0f,
+	32.5726f,
+	-19.5313f,
+	-121.094f,
+	31.5139f,
+	-19.5313f,
+	-117.188f,
+	31.4576f,
+	-19.5313f,
+	-113.281f,
+	31.6546f,
+	-19.5313f,
+	-109.375f,
+	32.4663f,
+	-19.5313f,
+	-105.469f,
+	32.6148f,
+	-19.5313f,
+	-101.563f,
+	31.253f,
+	-19.5313f,
+	-97.6563f,
+	29.5875f,
+	-19.5313f,
+	-93.75f,
+	28.4866f,
+	-19.5313f,
+	-89.8438f,
+	29.106f,
+	-19.5313f,
+	-85.9375f,
+	28.7092f,
+	-19.5313f,
+	-82.0313f,
+	27.4567f,
+	-19.5313f,
+	-78.125f,
+	26.5225f,
+	-19.5313f,
+	-74.2188f,
+	26.7534f,
+	-19.5313f,
+	-70.3125f,
+	26.278f,
+	-19.5313f,
+	-66.4063f,
+	25.6949f,
+	-19.5313f,
+	-62.5f,
+	25.7385f,
+	-19.5313f,
+	-58.5938f,
+	25.8791f,
+	-19.5313f,
+	-54.6875f,
+	27.42f,
+	-19.5313f,
+	-50.7813f,
+	29.0777f,
+	-19.5313f,
+	-46.875f,
+	31.016f,
+	-19.5313f,
+	-42.9688f,
+	32.5331f,
+	-19.5313f,
+	-39.0625f,
+	33.213f,
+	-19.5313f,
+	-35.1563f,
+	33.9437f,
+	-19.5313f,
+	-31.25f,
+	35.6737f,
+	-19.5313f,
+	-27.3438f,
+	37.8841f,
+	-19.5313f,
+	-23.4375f,
+	40.5289f,
+	-19.5313f,
+	-19.5313f,
+	43.6786f,
+	-19.5313f,
+	-15.625f,
+	47.2945f,
+	-19.5313f,
+	-11.7188f,
+	49.7082f,
+	-19.5313f,
+	-7.8125f,
+	51.1285f,
+	-19.5313f,
+	-3.90625f,
+	51.5532f,
+	-19.5313f,
+	0.0f,
+	52.3342f,
+	-19.5313f,
+	3.90625f,
+	52.1028f,
+	-19.5313f,
+	-250.0f,
+	1.05337f,
+	-23.4375f,
+	-246.094f,
+	1.28315f,
+	-23.4375f,
+	-242.188f,
+	3.38102f,
+	-23.4375f,
+	-238.281f,
+	4.51357f,
+	-23.4375f,
+	-234.375f,
+	5.63288f,
+	-23.4375f,
+	-230.469f,
+	6.49498f,
+	-23.4375f,
+	-226.563f,
+	7.71248f,
+	-23.4375f,
+	-222.656f,
+	8.83716f,
+	-23.4375f,
+	-218.75f,
+	10.4002f,
+	-23.4375f,
+	-214.844f,
+	11.8049f,
+	-23.4375f,
+	-210.938f,
+	13.7948f,
+	-23.4375f,
+	-207.031f,
+	16.5066f,
+	-23.4375f,
+	-203.125f,
+	18.598f,
+	-23.4375f,
+	-199.219f,
+	20.3069f,
+	-23.4375f,
+	-195.313f,
+	21.6868f,
+	-23.4375f,
+	-191.406f,
+	22.5781f,
+	-23.4375f,
+	-187.5f,
+	25.0292f,
+	-23.4375f,
+	-183.594f,
+	26.5386f,
+	-23.4375f,
+	-179.688f,
+	27.1952f,
+	-23.4375f,
+	-175.781f,
+	28.4023f,
+	-23.4375f,
+	-171.875f,
+	29.0264f,
+	-23.4375f,
+	-167.969f,
+	29.9302f,
+	-23.4375f,
+	-164.063f,
+	31.7992f,
+	-23.4375f,
+	-160.156f,
+	33.4902f,
+	-23.4375f,
+	-156.25f,
+	34.4307f,
+	-23.4375f,
+	-152.344f,
+	34.1463f,
+	-23.4375f,
+	-148.438f,
+	33.5881f,
+	-23.4375f,
+	-144.531f,
+	34.0515f,
+	-23.4375f,
+	-140.625f,
+	33.7128f,
+	-23.4375f,
+	-136.719f,
+	33.2076f,
+	-23.4375f,
+	-132.813f,
+	32.0419f,
+	-23.4375f,
+	-128.906f,
+	31.3464f,
+	-23.4375f,
+	-125.0f,
+	31.3552f,
+	-23.4375f,
+	-121.094f,
+	30.6713f,
+	-23.4375f,
+	-117.188f,
+	30.1403f,
+	-23.4375f,
+	-113.281f,
+	30.1753f,
+	-23.4375f,
+	-109.375f,
+	30.6182f,
+	-23.4375f,
+	-105.469f,
+	31.2785f,
+	-23.4375f,
+	-101.563f,
+	30.4839f,
+	-23.4375f,
+	-97.6563f,
+	28.9907f,
+	-23.4375f,
+	-93.75f,
+	29.3427f,
+	-23.4375f,
+	-89.8438f,
+	29.5539f,
+	-23.4375f,
+	-85.9375f,
+	29.4313f,
+	-23.4375f,
+	-82.0313f,
+	28.0148f,
+	-23.4375f,
+	-78.125f,
+	27.3569f,
+	-23.4375f,
+	-74.2188f,
+	26.8569f,
+	-23.4375f,
+	-70.3125f,
+	25.6193f,
+	-23.4375f,
+	-66.4063f,
+	25.8188f,
+	-23.4375f,
+	-62.5f,
+	25.458f,
+	-23.4375f,
+	-58.5938f,
+	26.5128f,
+	-23.4375f,
+	-54.6875f,
+	27.2598f,
+	-23.4375f,
+	-50.7813f,
+	28.4912f,
+	-23.4375f,
+	-46.875f,
+	31.0376f,
+	-23.4375f,
+	-42.9688f,
+	33.0941f,
+	-23.4375f,
+	-39.0625f,
+	34.4933f,
+	-23.4375f,
+	-35.1563f,
+	37.1957f,
+	-23.4375f,
+	-31.25f,
+	39.4612f,
+	-23.4375f,
+	-27.3438f,
+	41.4598f,
+	-23.4375f,
+	-23.4375f,
+	43.5893f,
+	-23.4375f,
+	-19.5313f,
+	46.8054f,
+	-23.4375f,
+	-15.625f,
+	49.4177f,
+	-23.4375f,
+	-11.7188f,
+	51.7957f,
+	-23.4375f,
+	-7.8125f,
+	53.1306f,
+	-23.4375f,
+	-3.90625f,
+	53.4872f,
+	-23.4375f,
+	0.0f,
+	53.6348f,
+	-23.4375f,
+	3.90625f,
+	54.332f,
+	-23.4375f,
+	-250.0f,
+	1.05459f,
+	-27.3438f,
+	-246.094f,
+	2.15725f,
+	-27.3438f,
+	-242.188f,
+	3.16747f,
+	-27.3438f,
+	-238.281f,
+	4.17562f,
+	-27.3438f,
+	-234.375f,
+	5.17097f,
+	-27.3438f,
+	-230.469f,
+	6.61997f,
+	-27.3438f,
+	-226.563f,
+	7.25727f,
+	-27.3438f,
+	-222.656f,
+	9.26302f,
+	-27.3438f,
+	-218.75f,
+	10.7606f,
+	-27.3438f,
+	-214.844f,
+	11.6966f,
+	-27.3438f,
+	-210.938f,
+	13.0425f,
+	-27.3438f,
+	-207.031f,
+	15.0672f,
+	-27.3438f,
+	-203.125f,
+	17.5971f,
+	-27.3438f,
+	-199.219f,
+	19.3182f,
+	-27.3438f,
+	-195.313f,
+	20.4505f,
+	-27.3438f,
+	-191.406f,
+	20.7017f,
+	-27.3438f,
+	-187.5f,
+	22.8054f,
+	-27.3438f,
+	-183.594f,
+	24.7406f,
+	-27.3438f,
+	-179.688f,
+	25.7957f,
+	-27.3438f,
+	-175.781f,
+	28.4608f,
+	-27.3438f,
+	-171.875f,
+	29.5031f,
+	-27.3438f,
+	-167.969f,
+	29.8812f,
+	-27.3438f,
+	-164.063f,
+	31.4954f,
+	-27.3438f,
+	-160.156f,
+	32.6053f,
+	-27.3438f,
+	-156.25f,
+	32.9274f,
+	-27.3438f,
+	-152.344f,
+	32.6481f,
+	-27.3438f,
+	-148.438f,
+	32.4456f,
+	-27.3438f,
+	-144.531f,
+	32.0065f,
+	-27.3438f,
+	-140.625f,
+	31.7655f,
+	-27.3438f,
+	-136.719f,
+	31.6836f,
+	-27.3438f,
+	-132.813f,
+	30.9994f,
+	-27.3438f,
+	-128.906f,
+	30.4065f,
+	-27.3438f,
+	-125.0f,
+	29.7478f,
+	-27.3438f,
+	-121.094f,
+	29.3871f,
+	-27.3438f,
+	-117.188f,
+	28.6628f,
+	-27.3438f,
+	-113.281f,
+	28.88f,
+	-27.3438f,
+	-109.375f,
+	29.3757f,
+	-27.3438f,
+	-105.469f,
+	29.7372f,
+	-27.3438f,
+	-101.563f,
+	28.9035f,
+	-27.3438f,
+	-97.6563f,
+	29.0842f,
+	-27.3438f,
+	-93.75f,
+	28.969f,
+	-27.3438f,
+	-89.8438f,
+	29.282f,
+	-27.3438f,
+	-85.9375f,
+	29.4429f,
+	-27.3438f,
+	-82.0313f,
+	29.2385f,
+	-27.3438f,
+	-78.125f,
+	28.2845f,
+	-27.3438f,
+	-74.2188f,
+	26.9413f,
+	-27.3438f,
+	-70.3125f,
+	26.3888f,
+	-27.3438f,
+	-66.4063f,
+	26.4127f,
+	-27.3438f,
+	-62.5f,
+	27.4297f,
+	-27.3438f,
+	-58.5938f,
+	28.0301f,
+	-27.3438f,
+	-54.6875f,
+	28.3682f,
+	-27.3438f,
+	-50.7813f,
+	30.4624f,
+	-27.3438f,
+	-46.875f,
+	32.6469f,
+	-27.3438f,
+	-42.9688f,
+	34.7681f,
+	-27.3438f,
+	-39.0625f,
+	37.3677f,
+	-27.3438f,
+	-35.1563f,
+	40.0943f,
+	-27.3438f,
+	-31.25f,
+	42.4424f,
+	-27.3438f,
+	-27.3438f,
+	44.5954f,
+	-27.3438f,
+	-23.4375f,
+	48.1538f,
+	-27.3438f,
+	-19.5313f,
+	50.5809f,
+	-27.3438f,
+	-15.625f,
+	52.7959f,
+	-27.3438f,
+	-11.7188f,
+	53.9779f,
+	-27.3438f,
+	-7.8125f,
+	55.2657f,
+	-27.3438f,
+	-3.90625f,
+	55.7427f,
+	-27.3438f,
+	0.0f,
+	56.6047f,
+	-27.3438f,
+	3.90625f,
+	57.5273f,
+	-27.3438f,
+	-250.0f,
+	1.91243f,
+	-31.25f,
+	-246.094f,
+	1.77508f,
+	-31.25f,
+	-242.188f,
+	2.89721f,
+	-31.25f,
+	-238.281f,
+	4.82177f,
+	-31.25f,
+	-234.375f,
+	5.57483f,
+	-31.25f,
+	-230.469f,
+	6.15697f,
+	-31.25f,
+	-226.563f,
+	7.43219f,
+	-31.25f,
+	-222.656f,
+	9.10752f,
+	-31.25f,
+	-218.75f,
+	10.7345f,
+	-31.25f,
+	-214.844f,
+	11.7298f,
+	-31.25f,
+	-210.938f,
+	13.0008f,
+	-31.25f,
+	-207.031f,
+	14.4465f,
+	-31.25f,
+	-203.125f,
+	16.7635f,
+	-31.25f,
+	-199.219f,
+	18.7095f,
+	-31.25f,
+	-195.313f,
+	19.057f,
+	-31.25f,
+	-191.406f,
+	19.522f,
+	-31.25f,
+	-187.5f,
+	21.0252f,
+	-31.25f,
+	-183.594f,
+	22.477f,
+	-31.25f,
+	-179.688f,
+	24.9456f,
+	-31.25f,
+	-175.781f,
+	27.5579f,
+	-31.25f,
+	-171.875f,
+	28.9367f,
+	-31.25f,
+	-167.969f,
+	29.5938f,
+	-31.25f,
+	-164.063f,
+	29.9491f,
+	-31.25f,
+	-160.156f,
+	31.1043f,
+	-31.25f,
+	-156.25f,
+	31.898f,
+	-31.25f,
+	-152.344f,
+	32.025f,
+	-31.25f,
+	-148.438f,
+	32.2848f,
+	-31.25f,
+	-144.531f,
+	31.4433f,
+	-31.25f,
+	-140.625f,
+	29.9423f,
+	-31.25f,
+	-136.719f,
+	30.2535f,
+	-31.25f,
+	-132.813f,
+	30.4668f,
+	-31.25f,
+	-128.906f,
+	30.1261f,
+	-31.25f,
+	-125.0f,
+	29.2612f,
+	-31.25f,
+	-121.094f,
+	27.5496f,
+	-31.25f,
+	-117.188f,
+	27.0659f,
+	-31.25f,
+	-113.281f,
+	27.3359f,
+	-31.25f,
+	-109.375f,
+	27.8418f,
+	-31.25f,
+	-105.469f,
+	28.9814f,
+	-31.25f,
+	-101.563f,
+	28.4429f,
+	-31.25f,
+	-97.6563f,
+	28.5833f,
+	-31.25f,
+	-93.75f,
+	28.9986f,
+	-31.25f,
+	-89.8438f,
+	30.3273f,
+	-31.25f,
+	-85.9375f,
+	30.5898f,
+	-31.25f,
+	-82.0313f,
+	29.8768f,
+	-31.25f,
+	-78.125f,
+	28.7278f,
+	-31.25f,
+	-74.2188f,
+	28.2599f,
+	-31.25f,
+	-70.3125f,
+	27.5942f,
+	-31.25f,
+	-66.4063f,
+	28.2721f,
+	-31.25f,
+	-62.5f,
+	28.9526f,
+	-31.25f,
+	-58.5938f,
+	29.4527f,
+	-31.25f,
+	-54.6875f,
+	30.1605f,
+	-31.25f,
+	-50.7813f,
+	32.6242f,
+	-31.25f,
+	-46.875f,
+	35.2708f,
+	-31.25f,
+	-42.9688f,
+	37.6696f,
+	-31.25f,
+	-39.0625f,
+	40.1477f,
+	-31.25f,
+	-35.1563f,
+	42.5127f,
+	-31.25f,
+	-31.25f,
+	45.655f,
+	-31.25f,
+	-27.3438f,
+	48.5747f,
+	-31.25f,
+	-23.4375f,
+	51.2069f,
+	-31.25f,
+	-19.5313f,
+	53.5599f,
+	-31.25f,
+	-15.625f,
+	55.3726f,
+	-31.25f,
+	-11.7188f,
+	56.4687f,
+	-31.25f,
+	-7.8125f,
+	56.313f,
+	-31.25f,
+	-3.90625f,
+	58.0363f,
+	-31.25f,
+	0.0f,
+	59.422f,
+	-31.25f,
+	3.90625f,
+	59.4204f,
+	-31.25f,
+	-250.0f,
+	1.80637f,
+	-35.1563f,
+	-246.094f,
+	1.14243f,
+	-35.1563f,
+	-242.188f,
+	2.08309f,
+	-35.1563f,
+	-238.281f,
+	3.66548f,
+	-35.1563f,
+	-234.375f,
+	4.49251f,
+	-35.1563f,
+	-230.469f,
+	5.63985f,
+	-35.1563f,
+	-226.563f,
+	7.33778f,
+	-35.1563f,
+	-222.656f,
+	9.15183f,
+	-35.1563f,
+	-218.75f,
+	10.0463f,
+	-35.1563f,
+	-214.844f,
+	11.7521f,
+	-35.1563f,
+	-210.938f,
+	12.6919f,
+	-35.1563f,
+	-207.031f,
+	14.0216f,
+	-35.1563f,
+	-203.125f,
+	14.9825f,
+	-35.1563f,
+	-199.219f,
+	16.2286f,
+	-35.1563f,
+	-195.313f,
+	17.2153f,
+	-35.1563f,
+	-191.406f,
+	18.0692f,
+	-35.1563f,
+	-187.5f,
+	19.858f,
+	-35.1563f,
+	-183.594f,
+	22.2715f,
+	-35.1563f,
+	-179.688f,
+	25.6457f,
+	-35.1563f,
+	-175.781f,
+	27.6627f,
+	-35.1563f,
+	-171.875f,
+	28.6491f,
+	-35.1563f,
+	-167.969f,
+	29.5869f,
+	-35.1563f,
+	-164.063f,
+	29.5582f,
+	-35.1563f,
+	-160.156f,
+	30.7619f,
+	-35.1563f,
+	-156.25f,
+	31.372f,
+	-35.1563f,
+	-152.344f,
+	31.4423f,
+	-35.1563f,
+	-148.438f,
+	31.7578f,
+	-35.1563f,
+	-144.531f,
+	31.1339f,
+	-35.1563f,
+	-140.625f,
+	29.3454f,
+	-35.1563f,
+	-136.719f,
+	28.0675f,
+	-35.1563f,
+	-132.813f,
+	28.1828f,
+	-35.1563f,
+	-128.906f,
+	28.2649f,
+	-35.1563f,
+	-125.0f,
+	27.2326f,
+	-35.1563f,
+	-121.094f,
+	26.2567f,
+	-35.1563f,
+	-117.188f,
+	25.4914f,
+	-35.1563f,
+	-113.281f,
+	25.5444f,
+	-35.1563f,
+	-109.375f,
+	25.8703f,
+	-35.1563f,
+	-105.469f,
+	27.9373f,
+	-35.1563f,
+	-101.563f,
+	27.9306f,
+	-35.1563f,
+	-97.6563f,
+	27.9282f,
+	-35.1563f,
+	-93.75f,
+	28.9199f,
+	-35.1563f,
+	-89.8438f,
+	30.142f,
+	-35.1563f,
+	-85.9375f,
+	30.3479f,
+	-35.1563f,
+	-82.0313f,
+	29.749f,
+	-35.1563f,
+	-78.125f,
+	29.2656f,
+	-35.1563f,
+	-74.2188f,
+	28.8561f,
+	-35.1563f,
+	-70.3125f,
+	28.7144f,
+	-35.1563f,
+	-66.4063f,
+	29.3204f,
+	-35.1563f,
+	-62.5f,
+	29.6751f,
+	-35.1563f,
+	-58.5938f,
+	31.0647f,
+	-35.1563f,
+	-54.6875f,
+	32.3243f,
+	-35.1563f,
+	-50.7813f,
+	34.476f,
+	-35.1563f,
+	-46.875f,
+	37.0984f,
+	-35.1563f,
+	-42.9688f,
+	40.1281f,
+	-35.1563f,
+	-39.0625f,
+	42.4472f,
+	-35.1563f,
+	-35.1563f,
+	45.6772f,
+	-35.1563f,
+	-31.25f,
+	49.5655f,
+	-35.1563f,
+	-27.3438f,
+	51.5783f,
+	-35.1563f,
+	-23.4375f,
+	53.3f,
+	-35.1563f,
+	-19.5313f,
+	55.4127f,
+	-35.1563f,
+	-15.625f,
+	56.8152f,
+	-35.1563f,
+	-11.7188f,
+	56.8985f,
+	-35.1563f,
+	-7.8125f,
+	57.5886f,
+	-35.1563f,
+	-3.90625f,
+	58.9321f,
+	-35.1563f,
+	0.0f,
+	60.2297f,
+	-35.1563f,
+	3.90625f,
+	60.2212f,
+	-35.1563f,
+	-250.0f,
+	2.59935f,
+	-39.0625f,
+	-246.094f,
+	1.55278f,
+	-39.0625f,
+	-242.188f,
+	1.42243f,
+	-39.0625f,
+	-238.281f,
+	2.78238f,
+	-39.0625f,
+	-234.375f,
+	3.85918f,
+	-39.0625f,
+	-230.469f,
+	5.01321f,
+	-39.0625f,
+	-226.563f,
+	6.56707f,
+	-39.0625f,
+	-222.656f,
+	7.99762f,
+	-39.0625f,
+	-218.75f,
+	9.72642f,
+	-39.0625f,
+	-214.844f,
+	11.975f,
+	-39.0625f,
+	-210.938f,
+	12.8008f,
+	-39.0625f,
+	-207.031f,
+	13.6902f,
+	-39.0625f,
+	-203.125f,
+	14.2017f,
+	-39.0625f,
+	-199.219f,
+	14.8784f,
+	-39.0625f,
+	-195.313f,
+	16.6265f,
+	-39.0625f,
+	-191.406f,
+	17.066f,
+	-39.0625f,
+	-187.5f,
+	19.3153f,
+	-39.0625f,
+	-183.594f,
+	23.4017f,
+	-39.0625f,
+	-179.688f,
+	26.2073f,
+	-39.0625f,
+	-175.781f,
+	27.92f,
+	-39.0625f,
+	-171.875f,
+	29.0435f,
+	-39.0625f,
+	-167.969f,
+	28.8537f,
+	-39.0625f,
+	-164.063f,
+	29.6445f,
+	-39.0625f,
+	-160.156f,
+	30.2119f,
+	-39.0625f,
+	-156.25f,
+	30.4693f,
+	-39.0625f,
+	-152.344f,
+	30.6063f,
+	-39.0625f,
+	-148.438f,
+	30.8716f,
+	-39.0625f,
+	-144.531f,
+	30.3253f,
+	-39.0625f,
+	-140.625f,
+	29.3941f,
+	-39.0625f,
+	-136.719f,
+	27.7606f,
+	-39.0625f,
+	-132.813f,
+	26.806f,
+	-39.0625f,
+	-128.906f,
+	26.6501f,
+	-39.0625f,
+	-125.0f,
+	25.6992f,
+	-39.0625f,
+	-121.094f,
+	24.4674f,
+	-39.0625f,
+	-117.188f,
+	24.1124f,
+	-39.0625f,
+	-113.281f,
+	24.9142f,
+	-39.0625f,
+	-109.375f,
+	25.5696f,
+	-39.0625f,
+	-105.469f,
+	25.4691f,
+	-39.0625f,
+	-101.563f,
+	26.7147f,
+	-39.0625f,
+	-97.6563f,
+	26.7558f,
+	-39.0625f,
+	-93.75f,
+	27.9278f,
+	-39.0625f,
+	-89.8438f,
+	29.0149f,
+	-39.0625f,
+	-85.9375f,
+	29.3557f,
+	-39.0625f,
+	-82.0313f,
+	29.6134f,
+	-39.0625f,
+	-78.125f,
+	29.4742f,
+	-39.0625f,
+	-74.2188f,
+	29.3377f,
+	-39.0625f,
+	-70.3125f,
+	29.6082f,
+	-39.0625f,
+	-66.4063f,
+	29.4634f,
+	-39.0625f,
+	-62.5f,
+	31.1775f,
+	-39.0625f,
+	-58.5938f,
+	32.7227f,
+	-39.0625f,
+	-54.6875f,
+	34.2233f,
+	-39.0625f,
+	-50.7813f,
+	36.1862f,
+	-39.0625f,
+	-46.875f,
+	38.7123f,
+	-39.0625f,
+	-42.9688f,
+	41.2396f,
+	-39.0625f,
+	-39.0625f,
+	44.5857f,
+	-39.0625f,
+	-35.1563f,
+	47.0183f,
+	-39.0625f,
+	-31.25f,
+	50.9933f,
+	-39.0625f,
+	-27.3438f,
+	53.2967f,
+	-39.0625f,
+	-23.4375f,
+	55.2026f,
+	-39.0625f,
+	-19.5313f,
+	56.3858f,
+	-39.0625f,
+	-15.625f,
+	57.8615f,
+	-39.0625f,
+	-11.7188f,
+	57.7515f,
+	-39.0625f,
+	-7.8125f,
+	58.8071f,
+	-39.0625f,
+	-3.90625f,
+	59.73f,
+	-39.0625f,
+	0.0f,
+	59.8999f,
+	-39.0625f,
+	3.90625f,
+	59.9094f,
+	-39.0625f,
+	-250.0f,
+	2.73015f,
+	-42.9688f,
+	-246.094f,
+	1.9296f,
+	-42.9688f,
+	-242.188f,
+	2.00835f,
+	-42.9688f,
+	-238.281f,
+	3.16245f,
+	-42.9688f,
+	-234.375f,
+	3.35198f,
+	-42.9688f,
+	-230.469f,
+	4.50732f,
+	-42.9688f,
+	-226.563f,
+	6.28971f,
+	-42.9688f,
+	-222.656f,
+	7.89723f,
+	-42.9688f,
+	-218.75f,
+	9.28447f,
+	-42.9688f,
+	-214.844f,
+	11.4302f,
+	-42.9688f,
+	-210.938f,
+	12.7156f,
+	-42.9688f,
+	-207.031f,
+	13.6281f,
+	-42.9688f,
+	-203.125f,
+	14.5932f,
+	-42.9688f,
+	-199.219f,
+	14.8129f,
+	-42.9688f,
+	-195.313f,
+	15.7965f,
+	-42.9688f,
+	-191.406f,
+	16.3571f,
+	-42.9688f,
+	-187.5f,
+	20.257f,
+	-42.9688f,
+	-183.594f,
+	23.2993f,
+	-42.9688f,
+	-179.688f,
+	25.4583f,
+	-42.9688f,
+	-175.781f,
+	27.2887f,
+	-42.9688f,
+	-171.875f,
+	27.9862f,
+	-42.9688f,
+	-167.969f,
+	28.274f,
+	-42.9688f,
+	-164.063f,
+	28.9264f,
+	-42.9688f,
+	-160.156f,
+	29.1855f,
+	-42.9688f,
+	-156.25f,
+	29.8898f,
+	-42.9688f,
+	-152.344f,
+	29.4922f,
+	-42.9688f,
+	-148.438f,
+	29.257f,
+	-42.9688f,
+	-144.531f,
+	28.9137f,
+	-42.9688f,
+	-140.625f,
+	27.618f,
+	-42.9688f,
+	-136.719f,
+	26.8539f,
+	-42.9688f,
+	-132.813f,
+	26.2806f,
+	-42.9688f,
+	-128.906f,
+	25.1378f,
+	-42.9688f,
+	-125.0f,
+	24.508f,
+	-42.9688f,
+	-121.094f,
+	23.8458f,
+	-42.9688f,
+	-117.188f,
+	23.501f,
+	-42.9688f,
+	-113.281f,
+	24.0593f,
+	-42.9688f,
+	-109.375f,
+	24.1366f,
+	-42.9688f,
+	-105.469f,
+	24.075f,
+	-42.9688f,
+	-101.563f,
+	24.5025f,
+	-42.9688f,
+	-97.6563f,
+	24.8457f,
+	-42.9688f,
+	-93.75f,
+	26.5028f,
+	-42.9688f,
+	-89.8438f,
+	26.9842f,
+	-42.9688f,
+	-85.9375f,
+	28.5672f,
+	-42.9688f,
+	-82.0313f,
+	28.9848f,
+	-42.9688f,
+	-78.125f,
+	29.1484f,
+	-42.9688f,
+	-74.2188f,
+	28.8735f,
+	-42.9688f,
+	-70.3125f,
+	29.9085f,
+	-42.9688f,
+	-66.4063f,
+	31.647f,
+	-42.9688f,
+	-62.5f,
+	32.8553f,
+	-42.9688f,
+	-58.5938f,
+	34.4488f,
+	-42.9688f,
+	-54.6875f,
+	35.7724f,
+	-42.9688f,
+	-50.7813f,
+	38.5181f,
+	-42.9688f,
+	-46.875f,
+	40.619f,
+	-42.9688f,
+	-42.9688f,
+	42.6158f,
+	-42.9688f,
+	-39.0625f,
+	45.9557f,
+	-42.9688f,
+	-35.1563f,
+	48.8071f,
+	-42.9688f,
+	-31.25f,
+	51.5425f,
+	-42.9688f,
+	-27.3438f,
+	54.1461f,
+	-42.9688f,
+	-23.4375f,
+	56.6935f,
+	-42.9688f,
+	-19.5313f,
+	57.353f,
+	-42.9688f,
+	-15.625f,
+	58.289f,
+	-42.9688f,
+	-11.7188f,
+	58.4633f,
+	-42.9688f,
+	-7.8125f,
+	59.0033f,
+	-42.9688f,
+	-3.90625f,
+	59.61f,
+	-42.9688f,
+	0.0f,
+	59.6115f,
+	-42.9688f,
+	3.90625f,
+	59.5207f,
+	-42.9688f,
+	-250.0f,
+	2.05499f,
+	-46.875f,
+	-246.094f,
+	1.44228f,
+	-46.875f,
+	-242.188f,
+	1.95946f,
+	-46.875f,
+	-238.281f,
+	2.50642f,
+	-46.875f,
+	-234.375f,
+	3.23732f,
+	-46.875f,
+	-230.469f,
+	4.46051f,
+	-46.875f,
+	-226.563f,
+	6.17815f,
+	-46.875f,
+	-222.656f,
+	7.58101f,
+	-46.875f,
+	-218.75f,
+	9.4063f,
+	-46.875f,
+	-214.844f,
+	11.394f,
+	-46.875f,
+	-210.938f,
+	12.4493f,
+	-46.875f,
+	-207.031f,
+	13.1281f,
+	-46.875f,
+	-203.125f,
+	13.8316f,
+	-46.875f,
+	-199.219f,
+	14.1574f,
+	-46.875f,
+	-195.313f,
+	15.0289f,
+	-46.875f,
+	-191.406f,
+	17.2095f,
+	-46.875f,
+	-187.5f,
+	20.3326f,
+	-46.875f,
+	-183.594f,
+	22.5046f,
+	-46.875f,
+	-179.688f,
+	24.7998f,
+	-46.875f,
+	-175.781f,
+	26.3728f,
+	-46.875f,
+	-171.875f,
+	27.3394f,
+	-46.875f,
+	-167.969f,
+	27.2989f,
+	-46.875f,
+	-164.063f,
+	27.5191f,
+	-46.875f,
+	-160.156f,
+	28.1581f,
+	-46.875f,
+	-156.25f,
+	28.357f,
+	-46.875f,
+	-152.344f,
+	27.2465f,
+	-46.875f,
+	-148.438f,
+	27.6591f,
+	-46.875f,
+	-144.531f,
+	26.7196f,
+	-46.875f,
+	-140.625f,
+	25.3776f,
+	-46.875f,
+	-136.719f,
+	25.1174f,
+	-46.875f,
+	-132.813f,
+	24.6913f,
+	-46.875f,
+	-128.906f,
+	23.828f,
+	-46.875f,
+	-125.0f,
+	22.7885f,
+	-46.875f,
+	-121.094f,
+	23.6316f,
+	-46.875f,
+	-117.188f,
+	23.288f,
+	-46.875f,
+	-113.281f,
+	22.8849f,
+	-46.875f,
+	-109.375f,
+	22.6367f,
+	-46.875f,
+	-105.469f,
+	22.2282f,
+	-46.875f,
+	-101.563f,
+	22.7539f,
+	-46.875f,
+	-97.6563f,
+	23.4319f,
+	-46.875f,
+	-93.75f,
+	25.0494f,
+	-46.875f,
+	-89.8438f,
+	25.7759f,
+	-46.875f,
+	-85.9375f,
+	27.2287f,
+	-46.875f,
+	-82.0313f,
+	28.1554f,
+	-46.875f,
+	-78.125f,
+	28.6794f,
+	-46.875f,
+	-74.2188f,
+	30.4763f,
+	-46.875f,
+	-70.3125f,
+	32.23f,
+	-46.875f,
+	-66.4063f,
+	33.6868f,
+	-46.875f,
+	-62.5f,
+	34.7841f,
+	-46.875f,
+	-58.5938f,
+	36.2585f,
+	-46.875f,
+	-54.6875f,
+	38.2534f,
+	-46.875f,
+	-50.7813f,
+	39.5261f,
+	-46.875f,
+	-46.875f,
+	41.7676f,
+	-46.875f,
+	-42.9688f,
+	44.8849f,
+	-46.875f,
+	-39.0625f,
+	47.6394f,
+	-46.875f,
+	-35.1563f,
+	49.5783f,
+	-46.875f,
+	-31.25f,
+	52.3871f,
+	-46.875f,
+	-27.3438f,
+	54.9333f,
+	-46.875f,
+	-23.4375f,
+	56.6705f,
+	-46.875f,
+	-19.5313f,
+	56.898f,
+	-46.875f,
+	-15.625f,
+	58.678f,
+	-46.875f,
+	-11.7188f,
+	59.6595f,
+	-46.875f,
+	-7.8125f,
+	59.0163f,
+	-46.875f,
+	-3.90625f,
+	59.3587f,
+	-46.875f,
+	0.0f,
+	58.5405f,
+	-46.875f,
+	3.90625f,
+	58.9086f,
+	-46.875f,
+	-250.0f,
+	2.57742f,
+	-50.7813f,
+	-246.094f,
+	2.06275f,
+	-50.7813f,
+	-242.188f,
+	2.26453f,
+	-50.7813f,
+	-238.281f,
+	2.43527f,
+	-50.7813f,
+	-234.375f,
+	2.63858f,
+	-50.7813f,
+	-230.469f,
+	4.44964f,
+	-50.7813f,
+	-226.563f,
+	6.50192f,
+	-50.7813f,
+	-222.656f,
+	8.11006f,
+	-50.7813f,
+	-218.75f,
+	10.1023f,
+	-50.7813f,
+	-214.844f,
+	11.3708f,
+	-50.7813f,
+	-210.938f,
+	12.7395f,
+	-50.7813f,
+	-207.031f,
+	13.6541f,
+	-50.7813f,
+	-203.125f,
+	13.6317f,
+	-50.7813f,
+	-199.219f,
+	13.4823f,
+	-50.7813f,
+	-195.313f,
+	15.3032f,
+	-50.7813f,
+	-191.406f,
+	17.5085f,
+	-50.7813f,
+	-187.5f,
+	19.5731f,
+	-50.7813f,
+	-183.594f,
+	22.0894f,
+	-50.7813f,
+	-179.688f,
+	23.8927f,
+	-50.7813f,
+	-175.781f,
+	24.9335f,
+	-50.7813f,
+	-171.875f,
+	26.1125f,
+	-50.7813f,
+	-167.969f,
+	25.9034f,
+	-50.7813f,
+	-164.063f,
+	26.9549f,
+	-50.7813f,
+	-160.156f,
+	26.7939f,
+	-50.7813f,
+	-156.25f,
+	26.3447f,
+	-50.7813f,
+	-152.344f,
+	25.6085f,
+	-50.7813f,
+	-148.438f,
+	25.2823f,
+	-50.7813f,
+	-144.531f,
+	25.4854f,
+	-50.7813f,
+	-140.625f,
+	23.906f,
+	-50.7813f,
+	-136.719f,
+	23.7094f,
+	-50.7813f,
+	-132.813f,
+	22.9599f,
+	-50.7813f,
+	-128.906f,
+	22.3089f,
+	-50.7813f,
+	-125.0f,
+	22.302f,
+	-50.7813f,
+	-121.094f,
+	23.3289f,
+	-50.7813f,
+	-117.188f,
+	23.1804f,
+	-50.7813f,
+	-113.281f,
+	22.6693f,
+	-50.7813f,
+	-109.375f,
+	21.2587f,
+	-50.7813f,
+	-105.469f,
+	20.4638f,
+	-50.7813f,
+	-101.563f,
+	21.4819f,
+	-50.7813f,
+	-97.6563f,
+	22.0137f,
+	-50.7813f,
+	-93.75f,
+	23.4763f,
+	-50.7813f,
+	-89.8438f,
+	25.2125f,
+	-50.7813f,
+	-85.9375f,
+	26.446f,
+	-50.7813f,
+	-82.0313f,
+	27.5614f,
+	-50.7813f,
+	-78.125f,
+	29.5641f,
+	-50.7813f,
+	-74.2188f,
+	31.1552f,
+	-50.7813f,
+	-70.3125f,
+	33.5337f,
+	-50.7813f,
+	-66.4063f,
+	35.653f,
+	-50.7813f,
+	-62.5f,
+	36.2419f,
+	-50.7813f,
+	-58.5938f,
+	37.4297f,
+	-50.7813f,
+	-54.6875f,
+	39.7492f,
+	-50.7813f,
+	-50.7813f,
+	41.494f,
+	-50.7813f,
+	-46.875f,
+	44.5449f,
+	-50.7813f,
+	-42.9688f,
+	47.2689f,
+	-50.7813f,
+	-39.0625f,
+	49.6705f,
+	-50.7813f,
+	-35.1563f,
+	51.8942f,
+	-50.7813f,
+	-31.25f,
+	53.9483f,
+	-50.7813f,
+	-27.3438f,
+	55.2444f,
+	-50.7813f,
+	-23.4375f,
+	56.5482f,
+	-50.7813f,
+	-19.5313f,
+	58.5545f,
+	-50.7813f,
+	-15.625f,
+	59.5559f,
+	-50.7813f,
+	-11.7188f,
+	58.8699f,
+	-50.7813f,
+	-7.8125f,
+	59.0373f,
+	-50.7813f,
+	-3.90625f,
+	59.5884f,
+	-50.7813f,
+	0.0f,
+	59.6491f,
+	-50.7813f,
+	3.90625f,
+	59.8509f,
+	-50.7813f,
+	-250.0f,
+	2.04136f,
+	-54.6875f,
+	-246.094f,
+	2.5492f,
+	-54.6875f,
+	-242.188f,
+	2.70952f,
+	-54.6875f,
+	-238.281f,
+	3.00758f,
+	-54.6875f,
+	-234.375f,
+	3.54707f,
+	-54.6875f,
+	-230.469f,
+	5.09851f,
+	-54.6875f,
+	-226.563f,
+	7.09409f,
+	-54.6875f,
+	-222.656f,
+	8.40975f,
+	-54.6875f,
+	-218.75f,
+	10.0555f,
+	-54.6875f,
+	-214.844f,
+	11.4962f,
+	-54.6875f,
+	-210.938f,
+	12.1806f,
+	-54.6875f,
+	-207.031f,
+	12.7217f,
+	-54.6875f,
+	-203.125f,
+	12.6935f,
+	-54.6875f,
+	-199.219f,
+	14.0259f,
+	-54.6875f,
+	-195.313f,
+	16.1147f,
+	-54.6875f,
+	-191.406f,
+	18.3888f,
+	-54.6875f,
+	-187.5f,
+	19.3549f,
+	-54.6875f,
+	-183.594f,
+	21.6563f,
+	-54.6875f,
+	-179.688f,
+	22.9906f,
+	-54.6875f,
+	-175.781f,
+	23.7728f,
+	-54.6875f,
+	-171.875f,
+	25.2286f,
+	-54.6875f,
+	-167.969f,
+	26.0764f,
+	-54.6875f,
+	-164.063f,
+	26.746f,
+	-54.6875f,
+	-160.156f,
+	26.3029f,
+	-54.6875f,
+	-156.25f,
+	25.6172f,
+	-54.6875f,
+	-152.344f,
+	24.537f,
+	-54.6875f,
+	-148.438f,
+	23.8458f,
+	-54.6875f,
+	-144.531f,
+	23.3726f,
+	-54.6875f,
+	-140.625f,
+	22.8694f,
+	-54.6875f,
+	-136.719f,
+	22.5247f,
+	-54.6875f,
+	-132.813f,
+	21.436f,
+	-54.6875f,
+	-128.906f,
+	21.4712f,
+	-54.6875f,
+	-125.0f,
+	22.1621f,
+	-54.6875f,
+	-121.094f,
+	22.4599f,
+	-54.6875f,
+	-117.188f,
+	21.4148f,
+	-54.6875f,
+	-113.281f,
+	20.8237f,
+	-54.6875f,
+	-109.375f,
+	19.6257f,
+	-54.6875f,
+	-105.469f,
+	20.1462f,
+	-54.6875f,
+	-101.563f,
+	21.5895f,
+	-54.6875f,
+	-97.6563f,
+	22.2376f,
+	-54.6875f,
+	-93.75f,
+	23.679f,
+	-54.6875f,
+	-89.8438f,
+	24.9403f,
+	-54.6875f,
+	-85.9375f,
+	26.4205f,
+	-54.6875f,
+	-82.0313f,
+	27.9125f,
+	-54.6875f,
+	-78.125f,
+	30.0689f,
+	-54.6875f,
+	-74.2188f,
+	32.7388f,
+	-54.6875f,
+	-70.3125f,
+	34.3502f,
+	-54.6875f,
+	-66.4063f,
+	35.6763f,
+	-54.6875f,
+	-62.5f,
+	37.4625f,
+	-54.6875f,
+	-58.5938f,
+	38.3448f,
+	-54.6875f,
+	-54.6875f,
+	40.6027f,
+	-54.6875f,
+	-50.7813f,
+	44.4532f,
+	-54.6875f,
+	-46.875f,
+	47.6182f,
+	-54.6875f,
+	-42.9688f,
+	49.7683f,
+	-54.6875f,
+	-39.0625f,
+	52.1875f,
+	-54.6875f,
+	-35.1563f,
+	54.4951f,
+	-54.6875f,
+	-31.25f,
+	55.9437f,
+	-54.6875f,
+	-27.3438f,
+	57.1353f,
+	-54.6875f,
+	-23.4375f,
+	58.016f,
+	-54.6875f,
+	-19.5313f,
+	59.6013f,
+	-54.6875f,
+	-15.625f,
+	59.9872f,
+	-54.6875f,
+	-11.7188f,
+	59.8299f,
+	-54.6875f,
+	-7.8125f,
+	60.1035f,
+	-54.6875f,
+	-3.90625f,
+	60.8558f,
+	-54.6875f,
+	0.0f,
+	60.5619f,
+	-54.6875f,
+	3.90625f,
+	60.3928f,
+	-54.6875f,
+	-250.0f,
+	4.01167f,
+	-58.5938f,
+	-246.094f,
+	3.0694f,
+	-58.5938f,
+	-242.188f,
+	3.37661f,
+	-58.5938f,
+	-238.281f,
+	3.71931f,
+	-58.5938f,
+	-234.375f,
+	4.08816f,
+	-58.5938f,
+	-230.469f,
+	5.56386f,
+	-58.5938f,
+	-226.563f,
+	7.3314f,
+	-58.5938f,
+	-222.656f,
+	8.61323f,
+	-58.5938f,
+	-218.75f,
+	9.77849f,
+	-58.5938f,
+	-214.844f,
+	11.9744f,
+	-58.5938f,
+	-210.938f,
+	12.9366f,
+	-58.5938f,
+	-207.031f,
+	13.5175f,
+	-58.5938f,
+	-203.125f,
+	13.948f,
+	-58.5938f,
+	-199.219f,
+	14.4053f,
+	-58.5938f,
+	-195.313f,
+	16.1496f,
+	-58.5938f,
+	-191.406f,
+	17.8653f,
+	-58.5938f,
+	-187.5f,
+	18.9853f,
+	-58.5938f,
+	-183.594f,
+	21.2985f,
+	-58.5938f,
+	-179.688f,
+	23.4932f,
+	-58.5938f,
+	-175.781f,
+	25.3544f,
+	-58.5938f,
+	-171.875f,
+	26.1087f,
+	-58.5938f,
+	-167.969f,
+	26.5864f,
+	-58.5938f,
+	-164.063f,
+	25.8729f,
+	-58.5938f,
+	-160.156f,
+	25.0068f,
+	-58.5938f,
+	-156.25f,
+	25.2867f,
+	-58.5938f,
+	-152.344f,
+	23.9482f,
+	-58.5938f,
+	-148.438f,
+	23.23f,
+	-58.5938f,
+	-144.531f,
+	22.6171f,
+	-58.5938f,
+	-140.625f,
+	21.4991f,
+	-58.5938f,
+	-136.719f,
+	21.0822f,
+	-58.5938f,
+	-132.813f,
+	21.0037f,
+	-58.5938f,
+	-128.906f,
+	21.8362f,
+	-58.5938f,
+	-125.0f,
+	21.5985f,
+	-58.5938f,
+	-121.094f,
+	20.951f,
+	-58.5938f,
+	-117.188f,
+	21.2066f,
+	-58.5938f,
+	-113.281f,
+	19.7479f,
+	-58.5938f,
+	-109.375f,
+	18.5787f,
+	-58.5938f,
+	-105.469f,
+	20.3984f,
+	-58.5938f,
+	-101.563f,
+	22.257f,
+	-58.5938f,
+	-97.6563f,
+	23.3411f,
+	-58.5938f,
+	-93.75f,
+	24.362f,
+	-58.5938f,
+	-89.8438f,
+	25.7544f,
+	-58.5938f,
+	-85.9375f,
+	27.7522f,
+	-58.5938f,
+	-82.0313f,
+	28.9204f,
+	-58.5938f,
+	-78.125f,
+	30.8124f,
+	-58.5938f,
+	-74.2188f,
+	32.9097f,
+	-58.5938f,
+	-70.3125f,
+	34.8737f,
+	-58.5938f,
+	-66.4063f,
+	36.0518f,
+	-58.5938f,
+	-62.5f,
+	38.506f,
+	-58.5938f,
+	-58.5938f,
+	41.2951f,
+	-58.5938f,
+	-54.6875f,
+	43.3387f,
+	-58.5938f,
+	-50.7813f,
+	46.5457f,
+	-58.5938f,
+	-46.875f,
+	49.2409f,
+	-58.5938f,
+	-42.9688f,
+	51.3946f,
+	-58.5938f,
+	-39.0625f,
+	54.0957f,
+	-58.5938f,
+	-35.1563f,
+	55.8205f,
+	-58.5938f,
+	-31.25f,
+	57.094f,
+	-58.5938f,
+	-27.3438f,
+	58.0636f,
+	-58.5938f,
+	-23.4375f,
+	58.8159f,
+	-58.5938f,
+	-19.5313f,
+	59.9761f,
+	-58.5938f,
+	-15.625f,
+	60.2094f,
+	-58.5938f,
+	-11.7188f,
+	60.0275f,
+	-58.5938f,
+	-7.8125f,
+	61.0991f,
+	-58.5938f,
+	-3.90625f,
+	61.4786f,
+	-58.5938f,
+	0.0f,
+	61.4895f,
+	-58.5938f,
+	3.90625f,
+	61.5747f,
+	-58.5938f,
+	-250.0f,
+	5.54938f,
+	-62.5f,
+	-246.094f,
+	4.18374f,
+	-62.5f,
+	-242.188f,
+	3.90057f,
+	-62.5f,
+	-238.281f,
+	4.25951f,
+	-62.5f,
+	-234.375f,
+	4.82365f,
+	-62.5f,
+	-230.469f,
+	6.03197f,
+	-62.5f,
+	-226.563f,
+	7.69909f,
+	-62.5f,
+	-222.656f,
+	8.80826f,
+	-62.5f,
+	-218.75f,
+	10.8241f,
+	-62.5f,
+	-214.844f,
+	13.5771f,
+	-62.5f,
+	-210.938f,
+	14.456f,
+	-62.5f,
+	-207.031f,
+	15.0395f,
+	-62.5f,
+	-203.125f,
+	14.5505f,
+	-62.5f,
+	-199.219f,
+	16.1706f,
+	-62.5f,
+	-195.313f,
+	16.9508f,
+	-62.5f,
+	-191.406f,
+	18.2016f,
+	-62.5f,
+	-187.5f,
+	19.8694f,
+	-62.5f,
+	-183.594f,
+	22.6167f,
+	-62.5f,
+	-179.688f,
+	24.5727f,
+	-62.5f,
+	-175.781f,
+	26.0063f,
+	-62.5f,
+	-171.875f,
+	26.0399f,
+	-62.5f,
+	-167.969f,
+	26.6416f,
+	-62.5f,
+	-164.063f,
+	25.6476f,
+	-62.5f,
+	-160.156f,
+	24.4615f,
+	-62.5f,
+	-156.25f,
+	23.5295f,
+	-62.5f,
+	-152.344f,
+	23.7879f,
+	-62.5f,
+	-148.438f,
+	22.8826f,
+	-62.5f,
+	-144.531f,
+	21.6558f,
+	-62.5f,
+	-140.625f,
+	20.6405f,
+	-62.5f,
+	-136.719f,
+	20.1695f,
+	-62.5f,
+	-132.813f,
+	20.7715f,
+	-62.5f,
+	-128.906f,
+	20.5918f,
+	-62.5f,
+	-125.0f,
+	20.4476f,
+	-62.5f,
+	-121.094f,
+	19.9068f,
+	-62.5f,
+	-117.188f,
+	19.4838f,
+	-62.5f,
+	-113.281f,
+	17.843f,
+	-62.5f,
+	-109.375f,
+	18.5661f,
+	-62.5f,
+	-105.469f,
+	20.1106f,
+	-62.5f,
+	-101.563f,
+	21.3182f,
+	-62.5f,
+	-97.6563f,
+	23.2851f,
+	-62.5f,
+	-93.75f,
+	24.3601f,
+	-62.5f,
+	-89.8438f,
+	26.3742f,
+	-62.5f,
+	-85.9375f,
+	27.7409f,
+	-62.5f,
+	-82.0313f,
+	29.533f,
+	-62.5f,
+	-78.125f,
+	31.5622f,
+	-62.5f,
+	-74.2188f,
+	33.2773f,
+	-62.5f,
+	-70.3125f,
+	35.6025f,
+	-62.5f,
+	-66.4063f,
+	38.4255f,
+	-62.5f,
+	-62.5f,
+	40.916f,
+	-62.5f,
+	-58.5938f,
+	43.9378f,
+	-62.5f,
+	-54.6875f,
+	45.9116f,
+	-62.5f,
+	-50.7813f,
+	48.3177f,
+	-62.5f,
+	-46.875f,
+	50.1977f,
+	-62.5f,
+	-42.9688f,
+	52.4552f,
+	-62.5f,
+	-39.0625f,
+	54.6779f,
+	-62.5f,
+	-35.1563f,
+	56.1564f,
+	-62.5f,
+	-31.25f,
+	57.5665f,
+	-62.5f,
+	-27.3438f,
+	58.7762f,
+	-62.5f,
+	-23.4375f,
+	59.115f,
+	-62.5f,
+	-19.5313f,
+	58.5535f,
+	-62.5f,
+	-15.625f,
+	58.2117f,
+	-62.5f,
+	-11.7188f,
+	59.0863f,
+	-62.5f,
+	-7.8125f,
+	60.3775f,
+	-62.5f,
+	-3.90625f,
+	61.0192f,
+	-62.5f,
+	0.0f,
+	61.864f,
+	-62.5f,
+	3.90625f,
+	62.1111f,
+	-62.5f,
+	-250.0f,
+	6.08003f,
+	-66.4063f,
+	-246.094f,
+	5.13458f,
+	-66.4063f,
+	-242.188f,
+	5.0967f,
+	-66.4063f,
+	-238.281f,
+	5.36926f,
+	-66.4063f,
+	-234.375f,
+	5.21926f,
+	-66.4063f,
+	-230.469f,
+	6.37997f,
+	-66.4063f,
+	-226.563f,
+	7.85032f,
+	-66.4063f,
+	-222.656f,
+	9.36117f,
+	-66.4063f,
+	-218.75f,
+	11.896f,
+	-66.4063f,
+	-214.844f,
+	13.9549f,
+	-66.4063f,
+	-210.938f,
+	15.4673f,
+	-66.4063f,
+	-207.031f,
+	15.9885f,
+	-66.4063f,
+	-203.125f,
+	16.4425f,
+	-66.4063f,
+	-199.219f,
+	17.4253f,
+	-66.4063f,
+	-195.313f,
+	18.1385f,
+	-66.4063f,
+	-191.406f,
+	18.8676f,
+	-66.4063f,
+	-187.5f,
+	20.1316f,
+	-66.4063f,
+	-183.594f,
+	22.8534f,
+	-66.4063f,
+	-179.688f,
+	24.5364f,
+	-66.4063f,
+	-175.781f,
+	25.6234f,
+	-66.4063f,
+	-171.875f,
+	25.9362f,
+	-66.4063f,
+	-167.969f,
+	25.7735f,
+	-66.4063f,
+	-164.063f,
+	25.1524f,
+	-66.4063f,
+	-160.156f,
+	24.4245f,
+	-66.4063f,
+	-156.25f,
+	22.8769f,
+	-66.4063f,
+	-152.344f,
+	22.8762f,
+	-66.4063f,
+	-148.438f,
+	21.9008f,
+	-66.4063f,
+	-144.531f,
+	20.9242f,
+	-66.4063f,
+	-140.625f,
+	20.1022f,
+	-66.4063f,
+	-136.719f,
+	19.5823f,
+	-66.4063f,
+	-132.813f,
+	19.4415f,
+	-66.4063f,
+	-128.906f,
+	18.9513f,
+	-66.4063f,
+	-125.0f,
+	18.9264f,
+	-66.4063f,
+	-121.094f,
+	18.6878f,
+	-66.4063f,
+	-117.188f,
+	17.8998f,
+	-66.4063f,
+	-113.281f,
+	17.9815f,
+	-66.4063f,
+	-109.375f,
+	18.2652f,
+	-66.4063f,
+	-105.469f,
+	19.533f,
+	-66.4063f,
+	-101.563f,
+	21.0045f,
+	-66.4063f,
+	-97.6563f,
+	22.2461f,
+	-66.4063f,
+	-93.75f,
+	23.7189f,
+	-66.4063f,
+	-89.8438f,
+	25.574f,
+	-66.4063f,
+	-85.9375f,
+	27.55f,
+	-66.4063f,
+	-82.0313f,
+	29.733f,
+	-66.4063f,
+	-78.125f,
+	31.0763f,
+	-66.4063f,
+	-74.2188f,
+	33.9607f,
+	-66.4063f,
+	-70.3125f,
+	37.3595f,
+	-66.4063f,
+	-66.4063f,
+	41.019f,
+	-66.4063f,
+	-62.5f,
+	43.7286f,
+	-66.4063f,
+	-58.5938f,
+	46.5077f,
+	-66.4063f,
+	-54.6875f,
+	47.985f,
+	-66.4063f,
+	-50.7813f,
+	49.2623f,
+	-66.4063f,
+	-46.875f,
+	50.9465f,
+	-66.4063f,
+	-42.9688f,
+	52.912f,
+	-66.4063f,
+	-39.0625f,
+	55.0349f,
+	-66.4063f,
+	-35.1563f,
+	56.428f,
+	-66.4063f,
+	-31.25f,
+	57.3951f,
+	-66.4063f,
+	-27.3438f,
+	58.5332f,
+	-66.4063f,
+	-23.4375f,
+	58.3328f,
+	-66.4063f,
+	-19.5313f,
+	56.9549f,
+	-66.4063f,
+	-15.625f,
+	56.9387f,
+	-66.4063f,
+	-11.7188f,
+	58.3656f,
+	-66.4063f,
+	-7.8125f,
+	59.6577f,
+	-66.4063f,
+	-3.90625f,
+	59.8566f,
+	-66.4063f,
+	0.0f,
+	60.693f,
+	-66.4063f,
+	3.90625f,
+	60.8569f,
+	-66.4063f,
+	-250.0f,
+	6.38861f,
+	-70.3125f,
+	-246.094f,
+	6.37976f,
+	-70.3125f,
+	-242.188f,
+	6.52455f,
+	-70.3125f,
+	-238.281f,
+	6.93657f,
+	-70.3125f,
+	-234.375f,
+	6.77321f,
+	-70.3125f,
+	-230.469f,
+	7.26034f,
+	-70.3125f,
+	-226.563f,
+	8.99316f,
+	-70.3125f,
+	-222.656f,
+	10.5015f,
+	-70.3125f,
+	-218.75f,
+	11.631f,
+	-70.3125f,
+	-214.844f,
+	14.0548f,
+	-70.3125f,
+	-210.938f,
+	15.9163f,
+	-70.3125f,
+	-207.031f,
+	16.6824f,
+	-70.3125f,
+	-203.125f,
+	17.1063f,
+	-70.3125f,
+	-199.219f,
+	18.066f,
+	-70.3125f,
+	-195.313f,
+	18.5539f,
+	-70.3125f,
+	-191.406f,
+	18.8425f,
+	-70.3125f,
+	-187.5f,
+	20.7731f,
+	-70.3125f,
+	-183.594f,
+	22.8929f,
+	-70.3125f,
+	-179.688f,
+	24.2011f,
+	-70.3125f,
+	-175.781f,
+	24.5512f,
+	-70.3125f,
+	-171.875f,
+	24.651f,
+	-70.3125f,
+	-167.969f,
+	23.9906f,
+	-70.3125f,
+	-164.063f,
+	23.6279f,
+	-70.3125f,
+	-160.156f,
+	23.6162f,
+	-70.3125f,
+	-156.25f,
+	22.3196f,
+	-70.3125f,
+	-152.344f,
+	22.173f,
+	-70.3125f,
+	-148.438f,
+	20.6833f,
+	-70.3125f,
+	-144.531f,
+	19.6848f,
+	-70.3125f,
+	-140.625f,
+	18.4633f,
+	-70.3125f,
+	-136.719f,
+	18.2692f,
+	-70.3125f,
+	-132.813f,
+	18.0595f,
+	-70.3125f,
+	-128.906f,
+	17.2062f,
+	-70.3125f,
+	-125.0f,
+	17.0103f,
+	-70.3125f,
+	-121.094f,
+	17.1584f,
+	-70.3125f,
+	-117.188f,
+	17.5441f,
+	-70.3125f,
+	-113.281f,
+	17.5669f,
+	-70.3125f,
+	-109.375f,
+	17.7536f,
+	-70.3125f,
+	-105.469f,
+	18.3913f,
+	-70.3125f,
+	-101.563f,
+	19.7264f,
+	-70.3125f,
+	-97.6563f,
+	20.8943f,
+	-70.3125f,
+	-93.75f,
+	22.7517f,
+	-70.3125f,
+	-89.8438f,
+	25.1479f,
+	-70.3125f,
+	-85.9375f,
+	27.3953f,
+	-70.3125f,
+	-82.0313f,
+	29.5127f,
+	-70.3125f,
+	-78.125f,
+	31.2816f,
+	-70.3125f,
+	-74.2188f,
+	34.6589f,
+	-70.3125f,
+	-70.3125f,
+	38.2161f,
+	-70.3125f,
+	-66.4063f,
+	42.3872f,
+	-70.3125f,
+	-62.5f,
+	45.4363f,
+	-70.3125f,
+	-58.5938f,
+	47.0181f,
+	-70.3125f,
+	-54.6875f,
+	48.7348f,
+	-70.3125f,
+	-50.7813f,
+	49.8739f,
+	-70.3125f,
+	-46.875f,
+	51.2434f,
+	-70.3125f,
+	-42.9688f,
+	52.9444f,
+	-70.3125f,
+	-39.0625f,
+	54.8413f,
+	-70.3125f,
+	-35.1563f,
+	55.8776f,
+	-70.3125f,
+	-31.25f,
+	56.9088f,
+	-70.3125f,
+	-27.3438f,
+	56.8827f,
+	-70.3125f,
+	-23.4375f,
+	56.1649f,
+	-70.3125f,
+	-19.5313f,
+	54.9828f,
+	-70.3125f,
+	-15.625f,
+	56.5543f,
+	-70.3125f,
+	-11.7188f,
+	58.0071f,
+	-70.3125f,
+	-7.8125f,
+	58.1204f,
+	-70.3125f,
+	-3.90625f,
+	58.8019f,
+	-70.3125f,
+	0.0f,
+	59.3765f,
+	-70.3125f,
+	3.90625f,
+	59.1482f,
+	-70.3125f,
+	-250.0f,
+	7.29753f,
+	-74.2188f,
+	-246.094f,
+	6.9318f,
+	-74.2188f,
+	-242.188f,
+	7.9493f,
+	-74.2188f,
+	-238.281f,
+	7.61482f,
+	-74.2188f,
+	-234.375f,
+	8.38948f,
+	-74.2188f,
+	-230.469f,
+	8.85034f,
+	-74.2188f,
+	-226.563f,
+	10.783f,
+	-74.2188f,
+	-222.656f,
+	12.203f,
+	-74.2188f,
+	-218.75f,
+	12.7122f,
+	-74.2188f,
+	-214.844f,
+	14.2813f,
+	-74.2188f,
+	-210.938f,
+	16.1159f,
+	-74.2188f,
+	-207.031f,
+	16.8501f,
+	-74.2188f,
+	-203.125f,
+	17.728f,
+	-74.2188f,
+	-199.219f,
+	18.6948f,
+	-74.2188f,
+	-195.313f,
+	19.0254f,
+	-74.2188f,
+	-191.406f,
+	18.9874f,
+	-74.2188f,
+	-187.5f,
+	20.7575f,
+	-74.2188f,
+	-183.594f,
+	22.4682f,
+	-74.2188f,
+	-179.688f,
+	23.785f,
+	-74.2188f,
+	-175.781f,
+	23.136f,
+	-74.2188f,
+	-171.875f,
+	22.2872f,
+	-74.2188f,
+	-167.969f,
+	21.9381f,
+	-74.2188f,
+	-164.063f,
+	22.818f,
+	-74.2188f,
+	-160.156f,
+	21.8019f,
+	-74.2188f,
+	-156.25f,
+	21.3496f,
+	-74.2188f,
+	-152.344f,
+	19.9092f,
+	-74.2188f,
+	-148.438f,
+	19.5338f,
+	-74.2188f,
+	-144.531f,
+	19.2227f,
+	-74.2188f,
+	-140.625f,
+	17.2583f,
+	-74.2188f,
+	-136.719f,
+	15.7727f,
+	-74.2188f,
+	-132.813f,
+	15.2069f,
+	-74.2188f,
+	-128.906f,
+	15.0929f,
+	-74.2188f,
+	-125.0f,
+	15.3066f,
+	-74.2188f,
+	-121.094f,
+	15.1161f,
+	-74.2188f,
+	-117.188f,
+	16.1171f,
+	-74.2188f,
+	-113.281f,
+	17.2851f,
+	-74.2188f,
+	-109.375f,
+	16.8359f,
+	-74.2188f,
+	-105.469f,
+	17.6612f,
+	-74.2188f,
+	-101.563f,
+	18.1651f,
+	-74.2188f,
+	-97.6563f,
+	18.9354f,
+	-74.2188f,
+	-93.75f,
+	21.1152f,
+	-74.2188f,
+	-89.8438f,
+	23.9267f,
+	-74.2188f,
+	-85.9375f,
+	26.5361f,
+	-74.2188f,
+	-82.0313f,
+	29.6007f,
+	-74.2188f,
+	-78.125f,
+	31.8355f,
+	-74.2188f,
+	-74.2188f,
+	34.5711f,
+	-74.2188f,
+	-70.3125f,
+	37.6211f,
+	-74.2188f,
+	-66.4063f,
+	41.978f,
+	-74.2188f,
+	-62.5f,
+	44.757f,
+	-74.2188f,
+	-58.5938f,
+	47.2561f,
+	-74.2188f,
+	-54.6875f,
+	48.796f,
+	-74.2188f,
+	-50.7813f,
+	50.085f,
+	-74.2188f,
+	-46.875f,
+	51.427f,
+	-74.2188f,
+	-42.9688f,
+	52.9103f,
+	-74.2188f,
+	-39.0625f,
+	53.6345f,
+	-74.2188f,
+	-35.1563f,
+	55.5589f,
+	-74.2188f,
+	-31.25f,
+	56.4557f,
+	-74.2188f,
+	-27.3438f,
+	55.8259f,
+	-74.2188f,
+	-23.4375f,
+	55.2472f,
+	-74.2188f,
+	-19.5313f,
+	54.9161f,
+	-74.2188f,
+	-15.625f,
+	56.2403f,
+	-74.2188f,
+	-11.7188f,
+	57.7266f,
+	-74.2188f,
+	-7.8125f,
+	57.6855f,
+	-74.2188f,
+	-3.90625f,
+	57.4796f,
+	-74.2188f,
+	0.0f,
+	56.3955f,
+	-74.2188f,
+	3.90625f,
+	56.5167f,
+	-74.2188f,
+	-250.0f,
+	8.88618f,
+	-78.125f,
+	-246.094f,
+	8.31776f,
+	-78.125f,
+	-242.188f,
+	8.67289f,
+	-78.125f,
+	-238.281f,
+	9.52219f,
+	-78.125f,
+	-234.375f,
+	9.78196f,
+	-78.125f,
+	-230.469f,
+	11.3032f,
+	-78.125f,
+	-226.563f,
+	13.1558f,
+	-78.125f,
+	-222.656f,
+	14.4361f,
+	-78.125f,
+	-218.75f,
+	15.5721f,
+	-78.125f,
+	-214.844f,
+	14.3491f,
+	-78.125f,
+	-210.938f,
+	15.6393f,
+	-78.125f,
+	-207.031f,
+	16.9133f,
+	-78.125f,
+	-203.125f,
+	18.1402f,
+	-78.125f,
+	-199.219f,
+	19.179f,
+	-78.125f,
+	-195.313f,
+	18.9448f,
+	-78.125f,
+	-191.406f,
+	19.5289f,
+	-78.125f,
+	-187.5f,
+	20.8547f,
+	-78.125f,
+	-183.594f,
+	22.7611f,
+	-78.125f,
+	-179.688f,
+	22.8314f,
+	-78.125f,
+	-175.781f,
+	21.815f,
+	-78.125f,
+	-171.875f,
+	22.2112f,
+	-78.125f,
+	-167.969f,
+	21.9322f,
+	-78.125f,
+	-164.063f,
+	21.3024f,
+	-78.125f,
+	-160.156f,
+	20.354f,
+	-78.125f,
+	-156.25f,
+	19.8588f,
+	-78.125f,
+	-152.344f,
+	17.8458f,
+	-78.125f,
+	-148.438f,
+	18.0613f,
+	-78.125f,
+	-144.531f,
+	17.0664f,
+	-78.125f,
+	-140.625f,
+	16.2256f,
+	-78.125f,
+	-136.719f,
+	14.3082f,
+	-78.125f,
+	-132.813f,
+	13.3463f,
+	-78.125f,
+	-128.906f,
+	14.3881f,
+	-78.125f,
+	-125.0f,
+	14.6865f,
+	-78.125f,
+	-121.094f,
+	14.2011f,
+	-78.125f,
+	-117.188f,
+	15.4562f,
+	-78.125f,
+	-113.281f,
+	16.6171f,
+	-78.125f,
+	-109.375f,
+	16.2869f,
+	-78.125f,
+	-105.469f,
+	15.9406f,
+	-78.125f,
+	-101.563f,
+	17.5579f,
+	-78.125f,
+	-97.6563f,
+	19.157f,
+	-78.125f,
+	-93.75f,
+	21.0678f,
+	-78.125f,
+	-89.8438f,
+	23.1633f,
+	-78.125f,
+	-85.9375f,
+	25.2991f,
+	-78.125f,
+	-82.0313f,
+	28.9462f,
+	-78.125f,
+	-78.125f,
+	31.8594f,
+	-78.125f,
+	-74.2188f,
+	35.2294f,
+	-78.125f,
+	-70.3125f,
+	36.9557f,
+	-78.125f,
+	-66.4063f,
+	40.692f,
+	-78.125f,
+	-62.5f,
+	44.5904f,
+	-78.125f,
+	-58.5938f,
+	46.9805f,
+	-78.125f,
+	-54.6875f,
+	48.3073f,
+	-78.125f,
+	-50.7813f,
+	49.8001f,
+	-78.125f,
+	-46.875f,
+	51.4881f,
+	-78.125f,
+	-42.9688f,
+	52.7488f,
+	-78.125f,
+	-39.0625f,
+	53.0994f,
+	-78.125f,
+	-35.1563f,
+	54.6505f,
+	-78.125f,
+	-31.25f,
+	55.3393f,
+	-78.125f,
+	-27.3438f,
+	55.3608f,
+	-78.125f,
+	-23.4375f,
+	54.3833f,
+	-78.125f,
+	-19.5313f,
+	53.9595f,
+	-78.125f,
+	-15.625f,
+	55.0695f,
+	-78.125f,
+	-11.7188f,
+	56.423f,
+	-78.125f,
+	-7.8125f,
+	56.1568f,
+	-78.125f,
+	-3.90625f,
+	56.2841f,
+	-78.125f,
+	0.0f,
+	54.7508f,
+	-78.125f,
+	3.90625f,
+	54.4402f,
+	-78.125f,
+	-250.0f,
+	10.7839f,
+	-82.0313f,
+	-246.094f,
+	10.1255f,
+	-82.0313f,
+	-242.188f,
+	10.6621f,
+	-82.0313f,
+	-238.281f,
+	11.4172f,
+	-82.0313f,
+	-234.375f,
+	12.3063f,
+	-82.0313f,
+	-230.469f,
+	13.4915f,
+	-82.0313f,
+	-226.563f,
+	14.9113f,
+	-82.0313f,
+	-222.656f,
+	16.5463f,
+	-82.0313f,
+	-218.75f,
+	17.3752f,
+	-82.0313f,
+	-214.844f,
+	16.6701f,
+	-82.0313f,
+	-210.938f,
+	15.5847f,
+	-82.0313f,
+	-207.031f,
+	16.6988f,
+	-82.0313f,
+	-203.125f,
+	17.6449f,
+	-82.0313f,
+	-199.219f,
+	18.4976f,
+	-82.0313f,
+	-195.313f,
+	18.033f,
+	-82.0313f,
+	-191.406f,
+	19.1758f,
+	-82.0313f,
+	-187.5f,
+	20.7116f,
+	-82.0313f,
+	-183.594f,
+	21.5492f,
+	-82.0313f,
+	-179.688f,
+	20.7908f,
+	-82.0313f,
+	-175.781f,
+	20.6891f,
+	-82.0313f,
+	-171.875f,
+	21.6368f,
+	-82.0313f,
+	-167.969f,
+	21.6862f,
+	-82.0313f,
+	-164.063f,
+	20.4236f,
+	-82.0313f,
+	-160.156f,
+	19.4449f,
+	-82.0313f,
+	-156.25f,
+	17.8718f,
+	-82.0313f,
+	-152.344f,
+	16.0984f,
+	-82.0313f,
+	-148.438f,
+	16.1225f,
+	-82.0313f,
+	-144.531f,
+	15.3001f,
+	-82.0313f,
+	-140.625f,
+	14.0113f,
+	-82.0313f,
+	-136.719f,
+	12.7128f,
+	-82.0313f,
+	-132.813f,
+	13.1695f,
+	-82.0313f,
+	-128.906f,
+	14.1608f,
+	-82.0313f,
+	-125.0f,
+	14.006f,
+	-82.0313f,
+	-121.094f,
+	13.5671f,
+	-82.0313f,
+	-117.188f,
+	14.799f,
+	-82.0313f,
+	-113.281f,
+	15.6819f,
+	-82.0313f,
+	-109.375f,
+	15.1047f,
+	-82.0313f,
+	-105.469f,
+	15.4826f,
+	-82.0313f,
+	-101.563f,
+	17.2178f,
+	-82.0313f,
+	-97.6563f,
+	19.1794f,
+	-82.0313f,
+	-93.75f,
+	21.3021f,
+	-82.0313f,
+	-89.8438f,
+	21.9981f,
+	-82.0313f,
+	-85.9375f,
+	24.4031f,
+	-82.0313f,
+	-82.0313f,
+	28.8062f,
+	-82.0313f,
+	-78.125f,
+	31.7576f,
+	-82.0313f,
+	-74.2188f,
+	34.6198f,
+	-82.0313f,
+	-70.3125f,
+	37.0145f,
+	-82.0313f,
+	-66.4063f,
+	39.5952f,
+	-82.0313f,
+	-62.5f,
+	43.4294f,
+	-82.0313f,
+	-58.5938f,
+	45.9611f,
+	-82.0313f,
+	-54.6875f,
+	47.398f,
+	-82.0313f,
+	-50.7813f,
+	49.5672f,
+	-82.0313f,
+	-46.875f,
+	51.4863f,
+	-82.0313f,
+	-42.9688f,
+	52.3277f,
+	-82.0313f,
+	-39.0625f,
+	52.6736f,
+	-82.0313f,
+	-35.1563f,
+	53.5554f,
+	-82.0313f,
+	-31.25f,
+	54.4611f,
+	-82.0313f,
+	-27.3438f,
+	53.3151f,
+	-82.0313f,
+	-23.4375f,
+	52.9631f,
+	-82.0313f,
+	-19.5313f,
+	52.3147f,
+	-82.0313f,
+	-15.625f,
+	53.7891f,
+	-82.0313f,
+	-11.7188f,
+	54.3962f,
+	-82.0313f,
+	-7.8125f,
+	54.2326f,
+	-82.0313f,
+	-3.90625f,
+	53.6717f,
+	-82.0313f,
+	0.0f,
+	52.8681f,
+	-82.0313f,
+	3.90625f,
+	51.949f,
+	-82.0313f,
+	-250.0f,
+	12.2756f,
+	-85.9375f,
+	-246.094f,
+	11.9011f,
+	-85.9375f,
+	-242.188f,
+	13.4495f,
+	-85.9375f,
+	-238.281f,
+	14.3858f,
+	-85.9375f,
+	-234.375f,
+	14.855f,
+	-85.9375f,
+	-230.469f,
+	15.3384f,
+	-85.9375f,
+	-226.563f,
+	17.3357f,
+	-85.9375f,
+	-222.656f,
+	18.7108f,
+	-85.9375f,
+	-218.75f,
+	18.0095f,
+	-85.9375f,
+	-214.844f,
+	17.4308f,
+	-85.9375f,
+	-210.938f,
+	17.0565f,
+	-85.9375f,
+	-207.031f,
+	16.4039f,
+	-85.9375f,
+	-203.125f,
+	17.3449f,
+	-85.9375f,
+	-199.219f,
+	17.5816f,
+	-85.9375f,
+	-195.313f,
+	17.7511f,
+	-85.9375f,
+	-191.406f,
+	18.792f,
+	-85.9375f,
+	-187.5f,
+	19.7983f,
+	-85.9375f,
+	-183.594f,
+	19.6069f,
+	-85.9375f,
+	-179.688f,
+	19.1396f,
+	-85.9375f,
+	-175.781f,
+	19.0184f,
+	-85.9375f,
+	-171.875f,
+	19.7492f,
+	-85.9375f,
+	-167.969f,
+	19.6428f,
+	-85.9375f,
+	-164.063f,
+	18.6091f,
+	-85.9375f,
+	-160.156f,
+	18.1998f,
+	-85.9375f,
+	-156.25f,
+	16.6809f,
+	-85.9375f,
+	-152.344f,
+	15.0269f,
+	-85.9375f,
+	-148.438f,
+	13.3773f,
+	-85.9375f,
+	-144.531f,
+	12.7371f,
+	-85.9375f,
+	-140.625f,
+	12.2537f,
+	-85.9375f,
+	-136.719f,
+	12.6536f,
+	-85.9375f,
+	-132.813f,
+	12.7798f,
+	-85.9375f,
+	-128.906f,
+	13.2089f,
+	-85.9375f,
+	-125.0f,
+	12.8356f,
+	-85.9375f,
+	-121.094f,
+	12.5484f,
+	-85.9375f,
+	-117.188f,
+	13.5275f,
+	-85.9375f,
+	-113.281f,
+	13.5387f,
+	-85.9375f,
+	-109.375f,
+	13.6111f,
+	-85.9375f,
+	-105.469f,
+	14.7023f,
+	-85.9375f,
+	-101.563f,
+	16.6526f,
+	-85.9375f,
+	-97.6563f,
+	17.9729f,
+	-85.9375f,
+	-93.75f,
+	19.8258f,
+	-85.9375f,
+	-89.8438f,
+	21.7903f,
+	-85.9375f,
+	-85.9375f,
+	23.4003f,
+	-85.9375f,
+	-82.0313f,
+	27.4381f,
+	-85.9375f,
+	-78.125f,
+	30.1644f,
+	-85.9375f,
+	-74.2188f,
+	33.7682f,
+	-85.9375f,
+	-70.3125f,
+	36.1779f,
+	-85.9375f,
+	-66.4063f,
+	38.1368f,
+	-85.9375f,
+	-62.5f,
+	41.5768f,
+	-85.9375f,
+	-58.5938f,
+	43.7832f,
+	-85.9375f,
+	-54.6875f,
+	45.866f,
+	-85.9375f,
+	-50.7813f,
+	48.5751f,
+	-85.9375f,
+	-46.875f,
+	50.4188f,
+	-85.9375f,
+	-42.9688f,
+	51.0239f,
+	-85.9375f,
+	-39.0625f,
+	51.2389f,
+	-85.9375f,
+	-35.1563f,
+	51.8865f,
+	-85.9375f,
+	-31.25f,
+	52.9036f,
+	-85.9375f,
+	-27.3438f,
+	52.5405f,
+	-85.9375f,
+	-23.4375f,
+	52.3296f,
+	-85.9375f,
+	-19.5313f,
+	52.5889f,
+	-85.9375f,
+	-15.625f,
+	52.3033f,
+	-85.9375f,
+	-11.7188f,
+	52.1239f,
+	-85.9375f,
+	-7.8125f,
+	52.0608f,
+	-85.9375f,
+	-3.90625f,
+	51.0213f,
+	-85.9375f,
+	0.0f,
+	50.5601f,
+	-85.9375f,
+	3.90625f,
+	50.007f,
+	-85.9375f,
+	-250.0f,
+	13.6424f,
+	-89.8438f,
+	-246.094f,
+	14.2919f,
+	-89.8438f,
+	-242.188f,
+	15.9647f,
+	-89.8438f,
+	-238.281f,
+	17.1274f,
+	-89.8438f,
+	-234.375f,
+	17.9206f,
+	-89.8438f,
+	-230.469f,
+	17.9917f,
+	-89.8438f,
+	-226.563f,
+	19.3423f,
+	-89.8438f,
+	-222.656f,
+	20.1401f,
+	-89.8438f,
+	-218.75f,
+	19.295f,
+	-89.8438f,
+	-214.844f,
+	18.1101f,
+	-89.8438f,
+	-210.938f,
+	17.3485f,
+	-89.8438f,
+	-207.031f,
+	17.1077f,
+	-89.8438f,
+	-203.125f,
+	17.7413f,
+	-89.8438f,
+	-199.219f,
+	17.2325f,
+	-89.8438f,
+	-195.313f,
+	17.6696f,
+	-89.8438f,
+	-191.406f,
+	18.8437f,
+	-89.8438f,
+	-187.5f,
+	19.1808f,
+	-89.8438f,
+	-183.594f,
+	18.6366f,
+	-89.8438f,
+	-179.688f,
+	17.3251f,
+	-89.8438f,
+	-175.781f,
+	17.5752f,
+	-89.8438f,
+	-171.875f,
+	18.1005f,
+	-89.8438f,
+	-167.969f,
+	18.0907f,
+	-89.8438f,
+	-164.063f,
+	16.519f,
+	-89.8438f,
+	-160.156f,
+	15.5225f,
+	-89.8438f,
+	-156.25f,
+	14.3937f,
+	-89.8438f,
+	-152.344f,
+	13.4199f,
+	-89.8438f,
+	-148.438f,
+	12.8584f,
+	-89.8438f,
+	-144.531f,
+	12.8604f,
+	-89.8438f,
+	-140.625f,
+	12.2817f,
+	-89.8438f,
+	-136.719f,
+	12.4113f,
+	-89.8438f,
+	-132.813f,
+	12.9949f,
+	-89.8438f,
+	-128.906f,
+	11.9716f,
+	-89.8438f,
+	-125.0f,
+	11.8348f,
+	-89.8438f,
+	-121.094f,
+	12.2532f,
+	-89.8438f,
+	-117.188f,
+	12.5983f,
+	-89.8438f,
+	-113.281f,
+	13.2095f,
+	-89.8438f,
+	-109.375f,
+	13.7209f,
+	-89.8438f,
+	-105.469f,
+	13.8655f,
+	-89.8438f,
+	-101.563f,
+	14.8679f,
+	-89.8438f,
+	-97.6563f,
+	16.1039f,
+	-89.8438f,
+	-93.75f,
+	17.9997f,
+	-89.8438f,
+	-89.8438f,
+	20.0247f,
+	-89.8438f,
+	-85.9375f,
+	22.8012f,
+	-89.8438f,
+	-82.0313f,
+	25.8255f,
+	-89.8438f,
+	-78.125f,
+	29.0288f,
+	-89.8438f,
+	-74.2188f,
+	31.8325f,
+	-89.8438f,
+	-70.3125f,
+	34.2688f,
+	-89.8438f,
+	-66.4063f,
+	37.2576f,
+	-89.8438f,
+	-62.5f,
+	40.8036f,
+	-89.8438f,
+	-58.5938f,
+	43.0354f,
+	-89.8438f,
+	-54.6875f,
+	44.5176f,
+	-89.8438f,
+	-50.7813f,
+	47.4827f,
+	-89.8438f,
+	-46.875f,
+	48.9307f,
+	-89.8438f,
+	-42.9688f,
+	48.82f,
+	-89.8438f,
+	-39.0625f,
+	48.8887f,
+	-89.8438f,
+	-35.1563f,
+	50.05f,
+	-89.8438f,
+	-31.25f,
+	50.9253f,
+	-89.8438f,
+	-27.3438f,
+	52.3859f,
+	-89.8438f,
+	-23.4375f,
+	52.2702f,
+	-89.8438f,
+	-19.5313f,
+	52.0708f,
+	-89.8438f,
+	-15.625f,
+	51.2832f,
+	-89.8438f,
+	-11.7188f,
+	50.0989f,
+	-89.8438f,
+	-7.8125f,
+	49.6111f,
+	-89.8438f,
+	-3.90625f,
+	48.7785f,
+	-89.8438f,
+	0.0f,
+	48.7183f,
+	-89.8438f,
+	3.90625f,
+	47.6596f,
+	-89.8438f,
+	-250.0f,
+	15.247f,
+	-93.75f,
+	-246.094f,
+	17.6018f,
+	-93.75f,
+	-242.188f,
+	19.2494f,
+	-93.75f,
+	-238.281f,
+	20.8362f,
+	-93.75f,
+	-234.375f,
+	20.4345f,
+	-93.75f,
+	-230.469f,
+	21.1572f,
+	-93.75f,
+	-226.563f,
+	21.3131f,
+	-93.75f,
+	-222.656f,
+	20.8797f,
+	-93.75f,
+	-218.75f,
+	20.5347f,
+	-93.75f,
+	-214.844f,
+	19.3559f,
+	-93.75f,
+	-210.938f,
+	18.2443f,
+	-93.75f,
+	-207.031f,
+	17.5994f,
+	-93.75f,
+	-203.125f,
+	18.0336f,
+	-93.75f,
+	-199.219f,
+	18.0561f,
+	-93.75f,
+	-195.313f,
+	17.673f,
+	-93.75f,
+	-191.406f,
+	18.7132f,
+	-93.75f,
+	-187.5f,
+	18.4272f,
+	-93.75f,
+	-183.594f,
+	18.078f,
+	-93.75f,
+	-179.688f,
+	16.7984f,
+	-93.75f,
+	-175.781f,
+	16.1827f,
+	-93.75f,
+	-171.875f,
+	16.5937f,
+	-93.75f,
+	-167.969f,
+	16.0698f,
+	-93.75f,
+	-164.063f,
+	14.9813f,
+	-93.75f,
+	-160.156f,
+	13.1718f,
+	-93.75f,
+	-156.25f,
+	12.1738f,
+	-93.75f,
+	-152.344f,
+	12.229f,
+	-93.75f,
+	-148.438f,
+	12.2803f,
+	-93.75f,
+	-144.531f,
+	12.526f,
+	-93.75f,
+	-140.625f,
+	11.9028f,
+	-93.75f,
+	-136.719f,
+	12.3491f,
+	-93.75f,
+	-132.813f,
+	11.7412f,
+	-93.75f,
+	-128.906f,
+	11.5455f,
+	-93.75f,
+	-125.0f,
+	11.6285f,
+	-93.75f,
+	-121.094f,
+	11.478f,
+	-93.75f,
+	-117.188f,
+	11.536f,
+	-93.75f,
+	-113.281f,
+	11.8722f,
+	-93.75f,
+	-109.375f,
+	12.61f,
+	-93.75f,
+	-105.469f,
+	12.6899f,
+	-93.75f,
+	-101.563f,
+	13.1659f,
+	-93.75f,
+	-97.6563f,
+	14.5994f,
+	-93.75f,
+	-93.75f,
+	16.6015f,
+	-93.75f,
+	-89.8438f,
+	19.9429f,
+	-93.75f,
+	-85.9375f,
+	22.8876f,
+	-93.75f,
+	-82.0313f,
+	26.3209f,
+	-93.75f,
+	-78.125f,
+	28.8526f,
+	-93.75f,
+	-74.2188f,
+	30.2969f,
+	-93.75f,
+	-70.3125f,
+	33.1597f,
+	-93.75f,
+	-66.4063f,
+	36.2648f,
+	-93.75f,
+	-62.5f,
+	39.1918f,
+	-93.75f,
+	-58.5938f,
+	41.4171f,
+	-93.75f,
+	-54.6875f,
+	43.4299f,
+	-93.75f,
+	-50.7813f,
+	45.5438f,
+	-93.75f,
+	-46.875f,
+	46.6281f,
+	-93.75f,
+	-42.9688f,
+	46.784f,
+	-93.75f,
+	-39.0625f,
+	47.3415f,
+	-93.75f,
+	-35.1563f,
+	48.5539f,
+	-93.75f,
+	-31.25f,
+	50.5714f,
+	-93.75f,
+	-27.3438f,
+	51.0532f,
+	-93.75f,
+	-23.4375f,
+	51.7685f,
+	-93.75f,
+	-19.5313f,
+	51.3638f,
+	-93.75f,
+	-15.625f,
+	49.6289f,
+	-93.75f,
+	-11.7188f,
+	50.0322f,
+	-93.75f,
+	-7.8125f,
+	48.6289f,
+	-93.75f,
+	-3.90625f,
+	46.7733f,
+	-93.75f,
+	0.0f,
+	45.5993f,
+	-93.75f,
+	3.90625f,
+	45.4182f,
+	-93.75f,
+	-250.0f,
+	18.5038f,
+	-97.6563f,
+	-246.094f,
+	20.1199f,
+	-97.6563f,
+	-242.188f,
+	22.7365f,
+	-97.6563f,
+	-238.281f,
+	24.311f,
+	-97.6563f,
+	-234.375f,
+	24.2572f,
+	-97.6563f,
+	-230.469f,
+	24.3322f,
+	-97.6563f,
+	-226.563f,
+	24.3501f,
+	-97.6563f,
+	-222.656f,
+	23.3494f,
+	-97.6563f,
+	-218.75f,
+	21.7677f,
+	-97.6563f,
+	-214.844f,
+	20.6573f,
+	-97.6563f,
+	-210.938f,
+	18.8509f,
+	-97.6563f,
+	-207.031f,
+	18.1355f,
+	-97.6563f,
+	-203.125f,
+	18.5785f,
+	-97.6563f,
+	-199.219f,
+	18.2049f,
+	-97.6563f,
+	-195.313f,
+	17.4136f,
+	-97.6563f,
+	-191.406f,
+	18.6105f,
+	-97.6563f,
+	-187.5f,
+	18.0859f,
+	-97.6563f,
+	-183.594f,
+	17.3286f,
+	-97.6563f,
+	-179.688f,
+	16.66f,
+	-97.6563f,
+	-175.781f,
+	15.1619f,
+	-97.6563f,
+	-171.875f,
+	14.271f,
+	-97.6563f,
+	-167.969f,
+	13.4801f,
+	-97.6563f,
+	-164.063f,
+	12.6373f,
+	-97.6563f,
+	-160.156f,
+	11.4464f,
+	-97.6563f,
+	-156.25f,
+	11.5423f,
+	-97.6563f,
+	-152.344f,
+	11.795f,
+	-97.6563f,
+	-148.438f,
+	10.9108f,
+	-97.6563f,
+	-144.531f,
+	11.2217f,
+	-97.6563f,
+	-140.625f,
+	11.0533f,
+	-97.6563f,
+	-136.719f,
+	11.5512f,
+	-97.6563f,
+	-132.813f,
+	11.6628f,
+	-97.6563f,
+	-128.906f,
+	10.9589f,
+	-97.6563f,
+	-125.0f,
+	10.3779f,
+	-97.6563f,
+	-121.094f,
+	9.96294f,
+	-97.6563f,
+	-117.188f,
+	10.6728f,
+	-97.6563f,
+	-113.281f,
+	11.2587f,
+	-97.6563f,
+	-109.375f,
+	11.2512f,
+	-97.6563f,
+	-105.469f,
+	12.1215f,
+	-97.6563f,
+	-101.563f,
+	12.0908f,
+	-97.6563f,
+	-97.6563f,
+	13.5835f,
+	-97.6563f,
+	-93.75f,
+	16.6536f,
+	-97.6563f,
+	-89.8438f,
+	19.7104f,
+	-97.6563f,
+	-85.9375f,
+	22.8325f,
+	-97.6563f,
+	-82.0313f,
+	26.7422f,
+	-97.6563f,
+	-78.125f,
+	29.4762f,
+	-97.6563f,
+	-74.2188f,
+	30.148f,
+	-97.6563f,
+	-70.3125f,
+	33.5961f,
+	-97.6563f,
+	-66.4063f,
+	36.1685f,
+	-97.6563f,
+	-62.5f,
+	37.3648f,
+	-97.6563f,
+	-58.5938f,
+	39.4445f,
+	-97.6563f,
+	-54.6875f,
+	40.3698f,
+	-97.6563f,
+	-50.7813f,
+	43.2595f,
+	-97.6563f,
+	-46.875f,
+	43.8006f,
+	-97.6563f,
+	-42.9688f,
+	44.8371f,
+	-97.6563f,
+	-39.0625f,
+	46.8993f,
+	-97.6563f,
+	-35.1563f,
+	48.8152f,
+	-97.6563f,
+	-31.25f,
+	50.2801f,
+	-97.6563f,
+	-27.3438f,
+	49.7242f,
+	-97.6563f,
+	-23.4375f,
+	49.8502f,
+	-97.6563f,
+	-19.5313f,
+	49.8568f,
+	-97.6563f,
+	-15.625f,
+	48.3267f,
+	-97.6563f,
+	-11.7188f,
+	47.8521f,
+	-97.6563f,
+	-7.8125f,
+	47.3364f,
+	-97.6563f,
+	-3.90625f,
+	46.156f,
+	-97.6563f,
+	0.0f,
+	44.8966f,
+	-97.6563f,
+	3.90625f,
+	44.9637f,
+	-97.6563f,
+	-250.0f,
+	21.0334f,
+	-101.563f,
+	-246.094f,
+	23.093f,
+	-101.563f,
+	-242.188f,
+	25.4189f,
+	-101.563f,
+	-238.281f,
+	27.31f,
+	-101.563f,
+	-234.375f,
+	26.8223f,
+	-101.563f,
+	-230.469f,
+	26.375f,
+	-101.563f,
+	-226.563f,
+	26.7718f,
+	-101.563f,
+	-222.656f,
+	25.3642f,
+	-101.563f,
+	-218.75f,
+	23.7619f,
+	-101.563f,
+	-214.844f,
+	21.4458f,
+	-101.563f,
+	-210.938f,
+	19.7809f,
+	-101.563f,
+	-207.031f,
+	19.054f,
+	-101.563f,
+	-203.125f,
+	19.6087f,
+	-101.563f,
+	-199.219f,
+	19.2503f,
+	-101.563f,
+	-195.313f,
+	18.0809f,
+	-101.563f,
+	-191.406f,
+	17.75f,
+	-101.563f,
+	-187.5f,
+	17.1292f,
+	-101.563f,
+	-183.594f,
+	16.2151f,
+	-101.563f,
+	-179.688f,
+	15.8928f,
+	-101.563f,
+	-175.781f,
+	14.4866f,
+	-101.563f,
+	-171.875f,
+	13.9039f,
+	-101.563f,
+	-167.969f,
+	12.278f,
+	-101.563f,
+	-164.063f,
+	11.5804f,
+	-101.563f,
+	-160.156f,
+	12.0152f,
+	-101.563f,
+	-156.25f,
+	11.7113f,
+	-101.563f,
+	-152.344f,
+	10.7496f,
+	-101.563f,
+	-148.438f,
+	9.67121f,
+	-101.563f,
+	-144.531f,
+	9.72628f,
+	-101.563f,
+	-140.625f,
+	9.99849f,
+	-101.563f,
+	-136.719f,
+	10.504f,
+	-101.563f,
+	-132.813f,
+	11.0917f,
+	-101.563f,
+	-128.906f,
+	10.4997f,
+	-101.563f,
+	-125.0f,
+	9.12306f,
+	-101.563f,
+	-121.094f,
+	8.34841f,
+	-101.563f,
+	-117.188f,
+	8.92074f,
+	-101.563f,
+	-113.281f,
+	9.44857f,
+	-101.563f,
+	-109.375f,
+	10.5456f,
+	-101.563f,
+	-105.469f,
+	10.7435f,
+	-101.563f,
+	-101.563f,
+	11.6413f,
+	-101.563f,
+	-97.6563f,
+	14.2233f,
+	-101.563f,
+	-93.75f,
+	17.0641f,
+	-101.563f,
+	-89.8438f,
+	20.5963f,
+	-101.563f,
+	-85.9375f,
+	22.9601f,
+	-101.563f,
+	-82.0313f,
+	26.0881f,
+	-101.563f,
+	-78.125f,
+	28.3451f,
+	-101.563f,
+	-74.2188f,
+	30.4473f,
+	-101.563f,
+	-70.3125f,
+	33.7644f,
+	-101.563f,
+	-66.4063f,
+	36.3074f,
+	-101.563f,
+	-62.5f,
+	38.0683f,
+	-101.563f,
+	-58.5938f,
+	39.1597f,
+	-101.563f,
+	-54.6875f,
+	40.3396f,
+	-101.563f,
+	-50.7813f,
+	41.4946f,
+	-101.563f,
+	-46.875f,
+	43.0029f,
+	-101.563f,
+	-42.9688f,
+	44.8434f,
+	-101.563f,
+	-39.0625f,
+	47.2094f,
+	-101.563f,
+	-35.1563f,
+	47.3449f,
+	-101.563f,
+	-31.25f,
+	49.1989f,
+	-101.563f,
+	-27.3438f,
+	48.845f,
+	-101.563f,
+	-23.4375f,
+	47.635f,
+	-101.563f,
+	-19.5313f,
+	47.9355f,
+	-101.563f,
+	-15.625f,
+	47.1439f,
+	-101.563f,
+	-11.7188f,
+	45.929f,
+	-101.563f,
+	-7.8125f,
+	46.9058f,
+	-101.563f,
+	-3.90625f,
+	46.1235f,
+	-101.563f,
+	0.0f,
+	45.2655f,
+	-101.563f,
+	3.90625f,
+	44.5311f,
+	-101.563f,
+	-250.0f,
+	24.0006f,
+	-105.469f,
+	-246.094f,
+	26.733f,
+	-105.469f,
+	-242.188f,
+	28.4305f,
+	-105.469f,
+	-238.281f,
+	29.0431f,
+	-105.469f,
+	-234.375f,
+	28.1582f,
+	-105.469f,
+	-230.469f,
+	28.0178f,
+	-105.469f,
+	-226.563f,
+	27.4417f,
+	-105.469f,
+	-222.656f,
+	27.0081f,
+	-105.469f,
+	-218.75f,
+	24.9646f,
+	-105.469f,
+	-214.844f,
+	22.8713f,
+	-105.469f,
+	-210.938f,
+	21.4507f,
+	-105.469f,
+	-207.031f,
+	21.2058f,
+	-105.469f,
+	-203.125f,
+	20.8114f,
+	-105.469f,
+	-199.219f,
+	20.7281f,
+	-105.469f,
+	-195.313f,
+	19.7358f,
+	-105.469f,
+	-191.406f,
+	18.4733f,
+	-105.469f,
+	-187.5f,
+	17.1875f,
+	-105.469f,
+	-183.594f,
+	15.4383f,
+	-105.469f,
+	-179.688f,
+	14.151f,
+	-105.469f,
+	-175.781f,
+	13.882f,
+	-105.469f,
+	-171.875f,
+	12.9008f,
+	-105.469f,
+	-167.969f,
+	11.246f,
+	-105.469f,
+	-164.063f,
+	11.1287f,
+	-105.469f,
+	-160.156f,
+	10.748f,
+	-105.469f,
+	-156.25f,
+	11.5003f,
+	-105.469f,
+	-152.344f,
+	10.3683f,
+	-105.469f,
+	-148.438f,
+	9.87346f,
+	-105.469f,
+	-144.531f,
+	9.6524f,
+	-105.469f,
+	-140.625f,
+	8.36957f,
+	-105.469f,
+	-136.719f,
+	9.12242f,
+	-105.469f,
+	-132.813f,
+	9.41585f,
+	-105.469f,
+	-128.906f,
+	8.97735f,
+	-105.469f,
+	-125.0f,
+	7.89593f,
+	-105.469f,
+	-121.094f,
+	7.20155f,
+	-105.469f,
+	-117.188f,
+	6.63681f,
+	-105.469f,
+	-113.281f,
+	8.27572f,
+	-105.469f,
+	-109.375f,
+	8.39126f,
+	-105.469f,
+	-105.469f,
+	9.69363f,
+	-105.469f,
+	-101.563f,
+	12.2269f,
+	-105.469f,
+	-97.6563f,
+	15.3785f,
+	-105.469f,
+	-93.75f,
+	18.1643f,
+	-105.469f,
+	-89.8438f,
+	20.8715f,
+	-105.469f,
+	-85.9375f,
+	23.5096f,
+	-105.469f,
+	-82.0313f,
+	25.2072f,
+	-105.469f,
+	-78.125f,
+	27.8536f,
+	-105.469f,
+	-74.2188f,
+	30.8436f,
+	-105.469f,
+	-70.3125f,
+	33.8966f,
+	-105.469f,
+	-66.4063f,
+	36.3107f,
+	-105.469f,
+	-62.5f,
+	37.9291f,
+	-105.469f,
+	-58.5938f,
+	39.7963f,
+	-105.469f,
+	-54.6875f,
+	40.5554f,
+	-105.469f,
+	-50.7813f,
+	42.1374f,
+	-105.469f,
+	-46.875f,
+	42.7622f,
+	-105.469f,
+	-42.9688f,
+	44.5703f,
+	-105.469f,
+	-39.0625f,
+	46.4665f,
+	-105.469f,
+	-35.1563f,
+	46.6101f,
+	-105.469f,
+	-31.25f,
+	47.1188f,
+	-105.469f,
+	-27.3438f,
+	48.052f,
+	-105.469f,
+	-23.4375f,
+	47.7845f,
+	-105.469f,
+	-19.5313f,
+	47.8159f,
+	-105.469f,
+	-15.625f,
+	46.7772f,
+	-105.469f,
+	-11.7188f,
+	46.0033f,
+	-105.469f,
+	-7.8125f,
+	47.2861f,
+	-105.469f,
+	-3.90625f,
+	46.9832f,
+	-105.469f,
+	0.0f,
+	45.6472f,
+	-105.469f,
+	3.90625f,
+	44.8466f,
+	-105.469f,
+	-250.0f,
+	27.0053f,
+	-109.375f,
+	-246.094f,
+	28.4873f,
+	-109.375f,
+	-242.188f,
+	29.8219f,
+	-109.375f,
+	-238.281f,
+	30.0561f,
+	-109.375f,
+	-234.375f,
+	29.2892f,
+	-109.375f,
+	-230.469f,
+	29.5933f,
+	-109.375f,
+	-226.563f,
+	28.8697f,
+	-109.375f,
+	-222.656f,
+	27.4881f,
+	-109.375f,
+	-218.75f,
+	25.7165f,
+	-109.375f,
+	-214.844f,
+	23.9985f,
+	-109.375f,
+	-210.938f,
+	23.3958f,
+	-109.375f,
+	-207.031f,
+	23.3567f,
+	-109.375f,
+	-203.125f,
+	23.3311f,
+	-109.375f,
+	-199.219f,
+	22.2114f,
+	-109.375f,
+	-195.313f,
+	21.0452f,
+	-109.375f,
+	-191.406f,
+	20.2153f,
+	-109.375f,
+	-187.5f,
+	18.8202f,
+	-109.375f,
+	-183.594f,
+	16.7998f,
+	-109.375f,
+	-179.688f,
+	15.8942f,
+	-109.375f,
+	-175.781f,
+	14.8638f,
+	-109.375f,
+	-171.875f,
+	13.1475f,
+	-109.375f,
+	-167.969f,
+	12.7375f,
+	-109.375f,
+	-164.063f,
+	10.7456f,
+	-109.375f,
+	-160.156f,
+	10.2908f,
+	-109.375f,
+	-156.25f,
+	9.65347f,
+	-109.375f,
+	-152.344f,
+	10.1273f,
+	-109.375f,
+	-148.438f,
+	9.91826f,
+	-109.375f,
+	-144.531f,
+	8.92229f,
+	-109.375f,
+	-140.625f,
+	8.34112f,
+	-109.375f,
+	-136.719f,
+	7.82043f,
+	-109.375f,
+	-132.813f,
+	7.17703f,
+	-109.375f,
+	-128.906f,
+	7.28288f,
+	-109.375f,
+	-125.0f,
+	6.94364f,
+	-109.375f,
+	-121.094f,
+	6.57742f,
+	-109.375f,
+	-117.188f,
+	5.68794f,
+	-109.375f,
+	-113.281f,
+	5.66654f,
+	-109.375f,
+	-109.375f,
+	6.9457f,
+	-109.375f,
+	-105.469f,
+	9.81036f,
+	-109.375f,
+	-101.563f,
+	12.6651f,
+	-109.375f,
+	-97.6563f,
+	15.2246f,
+	-109.375f,
+	-93.75f,
+	18.3914f,
+	-109.375f,
+	-89.8438f,
+	21.0454f,
+	-109.375f,
+	-85.9375f,
+	23.3579f,
+	-109.375f,
+	-82.0313f,
+	25.0292f,
+	-109.375f,
+	-78.125f,
+	28.9637f,
+	-109.375f,
+	-74.2188f,
+	31.9858f,
+	-109.375f,
+	-70.3125f,
+	34.5815f,
+	-109.375f,
+	-66.4063f,
+	37.1495f,
+	-109.375f,
+	-62.5f,
+	38.5371f,
+	-109.375f,
+	-58.5938f,
+	39.6993f,
+	-109.375f,
+	-54.6875f,
+	41.3314f,
+	-109.375f,
+	-50.7813f,
+	42.3279f,
+	-109.375f,
+	-46.875f,
+	43.399f,
+	-109.375f,
+	-42.9688f,
+	44.8971f,
+	-109.375f,
+	-39.0625f,
+	46.4515f,
+	-109.375f,
+	-35.1563f,
+	46.6684f,
+	-109.375f,
+	-31.25f,
+	47.2696f,
+	-109.375f,
+	-27.3438f,
+	48.2082f,
+	-109.375f,
+	-23.4375f,
+	47.2707f,
+	-109.375f,
+	-19.5313f,
+	47.952f,
+	-109.375f,
+	-15.625f,
+	47.4088f,
+	-109.375f,
+	-11.7188f,
+	47.3981f,
+	-109.375f,
+	-7.8125f,
+	48.0766f,
+	-109.375f,
+	-3.90625f,
+	47.4974f,
+	-109.375f,
+	0.0f,
+	46.1817f,
+	-109.375f,
+	3.90625f,
+	45.3987f,
+	-109.375f,
+	-250.0f,
+	28.5243f,
+	-113.281f,
+	-246.094f,
+	30.3032f,
+	-113.281f,
+	-242.188f,
+	31.2443f,
+	-113.281f,
+	-238.281f,
+	30.733f,
+	-113.281f,
+	-234.375f,
+	31.2433f,
+	-113.281f,
+	-230.469f,
+	31.5829f,
+	-113.281f,
+	-226.563f,
+	30.3008f,
+	-113.281f,
+	-222.656f,
+	28.2348f,
+	-113.281f,
+	-218.75f,
+	25.8116f,
+	-113.281f,
+	-214.844f,
+	25.3702f,
+	-113.281f,
+	-210.938f,
+	24.8435f,
+	-113.281f,
+	-207.031f,
+	25.7524f,
+	-113.281f,
+	-203.125f,
+	26.0021f,
+	-113.281f,
+	-199.219f,
+	24.9024f,
+	-113.281f,
+	-195.313f,
+	23.7348f,
+	-113.281f,
+	-191.406f,
+	21.9608f,
+	-113.281f,
+	-187.5f,
+	20.2108f,
+	-113.281f,
+	-183.594f,
+	18.963f,
+	-113.281f,
+	-179.688f,
+	17.7929f,
+	-113.281f,
+	-175.781f,
+	16.3625f,
+	-113.281f,
+	-171.875f,
+	14.6525f,
+	-113.281f,
+	-167.969f,
+	13.4453f,
+	-113.281f,
+	-164.063f,
+	11.5352f,
+	-113.281f,
+	-160.156f,
+	10.457f,
+	-113.281f,
+	-156.25f,
+	9.86849f,
+	-113.281f,
+	-152.344f,
+	9.76379f,
+	-113.281f,
+	-148.438f,
+	9.40799f,
+	-113.281f,
+	-144.531f,
+	8.38098f,
+	-113.281f,
+	-140.625f,
+	8.03078f,
+	-113.281f,
+	-136.719f,
+	7.4536f,
+	-113.281f,
+	-132.813f,
+	6.32375f,
+	-113.281f,
+	-128.906f,
+	5.90846f,
+	-113.281f,
+	-125.0f,
+	5.44126f,
+	-113.281f,
+	-121.094f,
+	5.53385f,
+	-113.281f,
+	-117.188f,
+	5.35081f,
+	-113.281f,
+	-113.281f,
+	6.14244f,
+	-113.281f,
+	-109.375f,
+	7.72509f,
+	-113.281f,
+	-105.469f,
+	9.98969f,
+	-113.281f,
+	-101.563f,
+	12.8924f,
+	-113.281f,
+	-97.6563f,
+	15.6605f,
+	-113.281f,
+	-93.75f,
+	18.4427f,
+	-113.281f,
+	-89.8438f,
+	20.4633f,
+	-113.281f,
+	-85.9375f,
+	22.3484f,
+	-113.281f,
+	-82.0313f,
+	25.7434f,
+	-113.281f,
+	-78.125f,
+	29.5649f,
+	-113.281f,
+	-74.2188f,
+	32.7377f,
+	-113.281f,
+	-70.3125f,
+	34.4529f,
+	-113.281f,
+	-66.4063f,
+	37.0096f,
+	-113.281f,
+	-62.5f,
+	38.2565f,
+	-113.281f,
+	-58.5938f,
+	39.8951f,
+	-113.281f,
+	-54.6875f,
+	41.291f,
+	-113.281f,
+	-50.7813f,
+	42.6018f,
+	-113.281f,
+	-46.875f,
+	43.3624f,
+	-113.281f,
+	-42.9688f,
+	44.3449f,
+	-113.281f,
+	-39.0625f,
+	45.4446f,
+	-113.281f,
+	-35.1563f,
+	46.0157f,
+	-113.281f,
+	-31.25f,
+	47.6632f,
+	-113.281f,
+	-27.3438f,
+	47.6934f,
+	-113.281f,
+	-23.4375f,
+	46.4824f,
+	-113.281f,
+	-19.5313f,
+	48.2708f,
+	-113.281f,
+	-15.625f,
+	48.5036f,
+	-113.281f,
+	-11.7188f,
+	47.6795f,
+	-113.281f,
+	-7.8125f,
+	48.4742f,
+	-113.281f,
+	-3.90625f,
+	48.509f,
+	-113.281f,
+	0.0f,
+	47.4037f,
+	-113.281f,
+	3.90625f,
+	47.4869f,
+	-113.281f,
+	-250.0f,
+	30.7007f,
+	-117.188f,
+	-246.094f,
+	31.6625f,
+	-117.188f,
+	-242.188f,
+	31.8246f,
+	-117.188f,
+	-238.281f,
+	32.4951f,
+	-117.188f,
+	-234.375f,
+	33.3552f,
+	-117.188f,
+	-230.469f,
+	32.7471f,
+	-117.188f,
+	-226.563f,
+	30.8092f,
+	-117.188f,
+	-222.656f,
+	28.3135f,
+	-117.188f,
+	-218.75f,
+	27.0912f,
+	-117.188f,
+	-214.844f,
+	27.0184f,
+	-117.188f,
+	-210.938f,
+	27.5702f,
+	-117.188f,
+	-207.031f,
+	27.9311f,
+	-117.188f,
+	-203.125f,
+	28.0909f,
+	-117.188f,
+	-199.219f,
+	26.6916f,
+	-117.188f,
+	-195.313f,
+	25.6983f,
+	-117.188f,
+	-191.406f,
+	24.0617f,
+	-117.188f,
+	-187.5f,
+	22.1476f,
+	-117.188f,
+	-183.594f,
+	20.964f,
+	-117.188f,
+	-179.688f,
+	19.1417f,
+	-117.188f,
+	-175.781f,
+	18.0941f,
+	-117.188f,
+	-171.875f,
+	16.3483f,
+	-117.188f,
+	-167.969f,
+	13.8969f,
+	-117.188f,
+	-164.063f,
+	12.2065f,
+	-117.188f,
+	-160.156f,
+	10.4346f,
+	-117.188f,
+	-156.25f,
+	9.28283f,
+	-117.188f,
+	-152.344f,
+	8.20933f,
+	-117.188f,
+	-148.438f,
+	7.69157f,
+	-117.188f,
+	-144.531f,
+	7.05251f,
+	-117.188f,
+	-140.625f,
+	6.38685f,
+	-117.188f,
+	-136.719f,
+	5.88862f,
+	-117.188f,
+	-132.813f,
+	4.48007f,
+	-117.188f,
+	-128.906f,
+	4.03049f,
+	-117.188f,
+	-125.0f,
+	4.96603f,
+	-117.188f,
+	-121.094f,
+	6.08105f,
+	-117.188f,
+	-117.188f,
+	6.76315f,
+	-117.188f,
+	-113.281f,
+	7.41087f,
+	-117.188f,
+	-109.375f,
+	7.5353f,
+	-117.188f,
+	-105.469f,
+	9.88018f,
+	-117.188f,
+	-101.563f,
+	11.8887f,
+	-117.188f,
+	-97.6563f,
+	14.4702f,
+	-117.188f,
+	-93.75f,
+	17.2187f,
+	-117.188f,
+	-89.8438f,
+	20.2241f,
+	-117.188f,
+	-85.9375f,
+	22.2766f,
+	-117.188f,
+	-82.0313f,
+	25.968f,
+	-117.188f,
+	-78.125f,
+	29.2923f,
+	-117.188f,
+	-74.2188f,
+	31.9825f,
+	-117.188f,
+	-70.3125f,
+	34.0756f,
+	-117.188f,
+	-66.4063f,
+	35.9202f,
+	-117.188f,
+	-62.5f,
+	37.9131f,
+	-117.188f,
+	-58.5938f,
+	39.2288f,
+	-117.188f,
+	-54.6875f,
+	40.591f,
+	-117.188f,
+	-50.7813f,
+	42.5191f,
+	-117.188f,
+	-46.875f,
+	42.7237f,
+	-117.188f,
+	-42.9688f,
+	43.8388f,
+	-117.188f,
+	-39.0625f,
+	45.2151f,
+	-117.188f,
+	-35.1563f,
+	45.096f,
+	-117.188f,
+	-31.25f,
+	45.9904f,
+	-117.188f,
+	-27.3438f,
+	45.2594f,
+	-117.188f,
+	-23.4375f,
+	45.7333f,
+	-117.188f,
+	-19.5313f,
+	47.4248f,
+	-117.188f,
+	-15.625f,
+	48.122f,
+	-117.188f,
+	-11.7188f,
+	48.0312f,
+	-117.188f,
+	-7.8125f,
+	49.0431f,
+	-117.188f,
+	-3.90625f,
+	49.2804f,
+	-117.188f,
+	0.0f,
+	48.803f,
+	-117.188f,
+	3.90625f,
+	48.3887f,
+	-117.188f,
+	-250.0f,
+	31.7497f,
+	-121.094f,
+	-246.094f,
+	31.3973f,
+	-121.094f,
+	-242.188f,
+	32.0742f,
+	-121.094f,
+	-238.281f,
+	33.1521f,
+	-121.094f,
+	-234.375f,
+	33.6068f,
+	-121.094f,
+	-230.469f,
+	31.9815f,
+	-121.094f,
+	-226.563f,
+	30.2957f,
+	-121.094f,
+	-222.656f,
+	28.5699f,
+	-121.094f,
+	-218.75f,
+	28.3353f,
+	-121.094f,
+	-214.844f,
+	28.8422f,
+	-121.094f,
+	-210.938f,
+	29.4292f,
+	-121.094f,
+	-207.031f,
+	29.2833f,
+	-121.094f,
+	-203.125f,
+	28.4123f,
+	-121.094f,
+	-199.219f,
+	27.4455f,
+	-121.094f,
+	-195.313f,
+	26.9053f,
+	-121.094f,
+	-191.406f,
+	24.8164f,
+	-121.094f,
+	-187.5f,
+	22.4409f,
+	-121.094f,
+	-183.594f,
+	21.5447f,
+	-121.094f,
+	-179.688f,
+	20.6668f,
+	-121.094f,
+	-175.781f,
+	18.9757f,
+	-121.094f,
+	-171.875f,
+	16.8092f,
+	-121.094f,
+	-167.969f,
+	14.4997f,
+	-121.094f,
+	-164.063f,
+	13.0122f,
+	-121.094f,
+	-160.156f,
+	11.2904f,
+	-121.094f,
+	-156.25f,
+	9.63825f,
+	-121.094f,
+	-152.344f,
+	8.62771f,
+	-121.094f,
+	-148.438f,
+	7.36842f,
+	-121.094f,
+	-144.531f,
+	6.44275f,
+	-121.094f,
+	-140.625f,
+	5.50805f,
+	-121.094f,
+	-136.719f,
+	6.00349f,
+	-121.094f,
+	-132.813f,
+	4.67796f,
+	-121.094f,
+	-128.906f,
+	3.93081f,
+	-121.094f,
+	-125.0f,
+	5.39329f,
+	-121.094f,
+	-121.094f,
+	6.95361f,
+	-121.094f,
+	-117.188f,
+	8.00676f,
+	-121.094f,
+	-113.281f,
+	7.76936f,
+	-121.094f,
+	-109.375f,
+	8.598f,
+	-121.094f,
+	-105.469f,
+	9.71941f,
+	-121.094f,
+	-101.563f,
+	11.4789f,
+	-121.094f,
+	-97.6563f,
+	13.572f,
+	-121.094f,
+	-93.75f,
+	16.0296f,
+	-121.094f,
+	-89.8438f,
+	18.5079f,
+	-121.094f,
+	-85.9375f,
+	22.5232f,
+	-121.094f,
+	-82.0313f,
+	25.7298f,
+	-121.094f,
+	-78.125f,
+	29.0421f,
+	-121.094f,
+	-74.2188f,
+	31.8936f,
+	-121.094f,
+	-70.3125f,
+	33.6857f,
+	-121.094f,
+	-66.4063f,
+	35.8951f,
+	-121.094f,
+	-62.5f,
+	37.4244f,
+	-121.094f,
+	-58.5938f,
+	39.1337f,
+	-121.094f,
+	-54.6875f,
+	40.6842f,
+	-121.094f,
+	-50.7813f,
+	41.8829f,
+	-121.094f,
+	-46.875f,
+	42.9851f,
+	-121.094f,
+	-42.9688f,
+	42.3613f,
+	-121.094f,
+	-39.0625f,
+	44.0627f,
+	-121.094f,
+	-35.1563f,
+	43.3741f,
+	-121.094f,
+	-31.25f,
+	43.2393f,
+	-121.094f,
+	-27.3438f,
+	44.1982f,
+	-121.094f,
+	-23.4375f,
+	45.2747f,
+	-121.094f,
+	-19.5313f,
+	46.6461f,
+	-121.094f,
+	-15.625f,
+	47.338f,
+	-121.094f,
+	-11.7188f,
+	48.1318f,
+	-121.094f,
+	-7.8125f,
+	49.3601f,
+	-121.094f,
+	-3.90625f,
+	49.6752f,
+	-121.094f,
+	0.0f,
+	49.3611f,
+	-121.094f,
+	3.90625f,
+	49.6769f,
+	-121.094f,
+	-250.0f,
+	31.4025f,
+	-125.0f,
+	-246.094f,
+	31.4165f,
+	-125.0f,
+	-242.188f,
+	32.314f,
+	-125.0f,
+	-238.281f,
+	32.9822f,
+	-125.0f,
+	-234.375f,
+	32.6962f,
+	-125.0f,
+	-230.469f,
+	31.3632f,
+	-125.0f,
+	-226.563f,
+	29.4391f,
+	-125.0f,
+	-222.656f,
+	29.519f,
+	-125.0f,
+	-218.75f,
+	29.4481f,
+	-125.0f,
+	-214.844f,
+	29.8481f,
+	-125.0f,
+	-210.938f,
+	30.408f,
+	-125.0f,
+	-207.031f,
+	30.291f,
+	-125.0f,
+	-203.125f,
+	28.7473f,
+	-125.0f,
+	-199.219f,
+	28.1816f,
+	-125.0f,
+	-195.313f,
+	27.2839f,
+	-125.0f,
+	-191.406f,
+	25.7018f,
+	-125.0f,
+	-187.5f,
+	23.2882f,
+	-125.0f,
+	-183.594f,
+	22.1614f,
+	-125.0f,
+	-179.688f,
+	20.658f,
+	-125.0f,
+	-175.781f,
+	18.8433f,
+	-125.0f,
+	-171.875f,
+	16.364f,
+	-125.0f,
+	-167.969f,
+	14.7298f,
+	-125.0f,
+	-164.063f,
+	12.9859f,
+	-125.0f,
+	-160.156f,
+	11.3306f,
+	-125.0f,
+	-156.25f,
+	10.1916f,
+	-125.0f,
+	-152.344f,
+	8.3967f,
+	-125.0f,
+	-148.438f,
+	6.23292f,
+	-125.0f,
+	-144.531f,
+	5.48985f,
+	-125.0f,
+	-140.625f,
+	5.18276f,
+	-125.0f,
+	-136.719f,
+	5.56059f,
+	-125.0f,
+	-132.813f,
+	5.75157f,
+	-125.0f,
+	-128.906f,
+	5.32154f,
+	-125.0f,
+	-125.0f,
+	6.15672f,
+	-125.0f,
+	-121.094f,
+	7.53373f,
+	-125.0f,
+	-117.188f,
+	8.38676f,
+	-125.0f,
+	-113.281f,
+	8.64274f,
+	-125.0f,
+	-109.375f,
+	8.49941f,
+	-125.0f,
+	-105.469f,
+	9.24481f,
+	-125.0f,
+	-101.563f,
+	11.5178f,
+	-125.0f,
+	-97.6563f,
+	13.4113f,
+	-125.0f,
+	-93.75f,
+	15.4997f,
+	-125.0f,
+	-89.8438f,
+	17.3502f,
+	-125.0f,
+	-85.9375f,
+	20.8168f,
+	-125.0f,
+	-82.0313f,
+	24.9405f,
+	-125.0f,
+	-78.125f,
+	27.8681f,
+	-125.0f,
+	-74.2188f,
+	30.1495f,
+	-125.0f,
+	-70.3125f,
+	32.4402f,
+	-125.0f,
+	-66.4063f,
+	34.2537f,
+	-125.0f,
+	-62.5f,
+	36.5623f,
+	-125.0f,
+	-58.5938f,
+	38.9027f,
+	-125.0f,
+	-54.6875f,
+	40.1192f,
+	-125.0f,
+	-50.7813f,
+	41.9393f,
+	-125.0f,
+	-46.875f,
+	41.8765f,
+	-125.0f,
+	-42.9688f,
+	41.6371f,
+	-125.0f,
+	-39.0625f,
+	41.6432f,
+	-125.0f,
+	-35.1563f,
+	41.2852f,
+	-125.0f,
+	-31.25f,
+	41.5629f,
+	-125.0f,
+	-27.3438f,
+	42.2956f,
+	-125.0f,
+	-23.4375f,
+	43.9719f,
+	-125.0f,
+	-19.5313f,
+	46.2232f,
+	-125.0f,
+	-15.625f,
+	47.3104f,
+	-125.0f,
+	-11.7188f,
+	47.5943f,
+	-125.0f,
+	-7.8125f,
+	49.1192f,
+	-125.0f,
+	-3.90625f,
+	49.6341f,
+	-125.0f,
+	0.0f,
+	50.3481f,
+	-125.0f,
+	3.90625f,
+	50.3021f,
+	-125.0f,
+};
+
+btScalar Landscape05Nml[] = {
+	-0.379368f,
+	0.918093f,
+	-0.114827f,
+	-0.372144f,
+	0.893697f,
+	-0.250627f,
+	-0.36483f,
+	0.925769f,
+	-0.0992527f,
+	-0.303739f,
+	0.924201f,
+	-0.231506f,
+	-0.333317f,
+	0.942796f,
+	0.0059764f,
+	-0.301915f,
+	0.940094f,
+	-0.158338f,
+	-0.363026f,
+	0.931698f,
+	0.0122604f,
+	-0.316966f,
+	0.945703f,
+	-0.0719588f,
+	-0.334188f,
+	0.941548f,
+	0.0424963f,
+	-0.326039f,
+	0.944563f,
+	-0.0387196f,
+	-0.382515f,
+	0.923758f,
+	0.0188291f,
+	-0.388659f,
+	0.920843f,
+	-0.0315106f,
+	-0.393577f,
+	0.919186f,
+	-0.013971f,
+	-0.384968f,
+	0.922772f,
+	-0.0170923f,
+	-0.36589f,
+	0.930393f,
+	-0.0222354f,
+	-0.357745f,
+	0.933231f,
+	0.0331438f,
+	-0.482959f,
+	0.873942f,
+	-0.0545559f,
+	-0.473203f,
+	0.879732f,
+	0.0463645f,
+	-0.550088f,
+	0.834035f,
+	-0.0423024f,
+	-0.534007f,
+	0.844766f,
+	0.0347315f,
+	-0.469703f,
+	0.882824f,
+	0.000376011f,
+	-0.490919f,
+	0.868868f,
+	0.0637728f,
+	-0.552202f,
+	0.826862f,
+	-0.106641f,
+	-0.558464f,
+	0.829519f,
+	0.00395409f,
+	-0.437742f,
+	0.897949f,
+	-0.0454837f,
+	-0.437659f,
+	0.898576f,
+	0.0318733f,
+	-0.370538f,
+	0.927929f,
+	-0.0406078f,
+	-0.403245f,
+	0.912789f,
+	-0.064878f,
+	-0.385648f,
+	0.921933f,
+	-0.0362754f,
+	-0.356223f,
+	0.934382f,
+	-0.00604283f,
+	-0.30076f,
+	0.953691f,
+	-0.00400305f,
+	-0.305622f,
+	0.951852f,
+	0.0239231f,
+	-0.284526f,
+	0.956527f,
+	-0.0640436f,
+	-0.380428f,
+	0.91278f,
+	-0.148684f,
+	-0.270228f,
+	0.949845f,
+	-0.157392f,
+	-0.258662f,
+	0.947281f,
+	-0.189085f,
+	-0.182234f,
+	0.978377f,
+	-0.0978241f,
+	-0.170558f,
+	0.969333f,
+	-0.176927f,
+	-0.205282f,
+	0.978149f,
+	-0.0329196f,
+	-0.190223f,
+	0.949267f,
+	-0.250415f,
+	-0.274135f,
+	0.959498f,
+	0.0649128f,
+	-0.310884f,
+	0.912161f,
+	-0.267046f,
+	-0.496348f,
+	0.868119f,
+	0.00275513f,
+	-0.43081f,
+	0.896388f,
+	-0.104358f,
+	-0.405094f,
+	0.913485f,
+	0.0380057f,
+	-0.324068f,
+	0.9389f,
+	0.115955f,
+	-0.25697f,
+	0.965908f,
+	0.0314342f,
+	-0.271227f,
+	0.948776f,
+	0.162051f,
+	-0.254963f,
+	0.963309f,
+	-0.0838379f,
+	-0.344475f,
+	0.938191f,
+	-0.03368f,
+	-0.111765f,
+	0.981495f,
+	-0.15549f,
+	-0.167507f,
+	0.982459f,
+	-0.0819529f,
+	-0.0010222f,
+	0.966945f,
+	-0.254984f,
+	-0.0444844f,
+	0.98477f,
+	-0.168075f,
+	0.186055f,
+	0.950323f,
+	-0.249537f,
+	0.1896f,
+	0.965697f,
+	-0.177427f,
+	0.271688f,
+	0.939248f,
+	-0.209761f,
+	0.279232f,
+	0.936599f,
+	-0.211687f,
+	0.322549f,
+	0.939459f,
+	-0.115666f,
+	0.354799f,
+	0.922502f,
+	-0.152013f,
+	0.252542f,
+	0.965579f,
+	-0.0622893f,
+	0.223889f,
+	0.935481f,
+	-0.273404f,
+	0.054661f,
+	0.998373f,
+	-0.0162575f,
+	0.0861707f,
+	0.972348f,
+	-0.217056f,
+	0.0124775f,
+	0.999913f,
+	-0.00421609f,
+	0.0330599f,
+	0.976575f,
+	-0.212621f,
+	0.0918366f,
+	0.994675f,
+	0.046771f,
+	0.166973f,
+	0.980978f,
+	-0.0990035f,
+	0.0387017f,
+	0.993028f,
+	0.111346f,
+	0.125297f,
+	0.990619f,
+	0.054541f,
+	0.0541059f,
+	0.984899f,
+	0.164456f,
+	0.149711f,
+	0.968151f,
+	0.200673f,
+	0.168008f,
+	0.956272f,
+	0.239411f,
+	0.195367f,
+	0.93223f,
+	0.304595f,
+	0.147118f,
+	0.96491f,
+	0.217497f,
+	0.125818f,
+	0.960755f,
+	0.247225f,
+	0.270517f,
+	0.934497f,
+	0.23138f,
+	0.29818f,
+	0.904256f,
+	0.305629f,
+	0.363841f,
+	0.900609f,
+	0.237745f,
+	0.316827f,
+	0.923009f,
+	0.218347f,
+	0.413166f,
+	0.893779f,
+	0.17451f,
+	0.334815f,
+	0.940911f,
+	0.0508378f,
+	0.474676f,
+	0.869519f,
+	0.136452f,
+	0.456974f,
+	0.889396f,
+	0.0122055f,
+	0.272216f,
+	0.960219f,
+	0.0622813f,
+	0.228855f,
+	0.962963f,
+	-0.142573f,
+	0.0810211f,
+	0.995842f,
+	0.0416494f,
+	0.189938f,
+	0.980101f,
+	0.0576713f,
+	-0.0449078f,
+	0.994712f,
+	0.0923629f,
+	-0.00155869f,
+	0.98749f,
+	0.157671f,
+	-0.0840704f,
+	0.991095f,
+	0.103263f,
+	-0.0968834f,
+	0.985327f,
+	0.140515f,
+	0.0427121f,
+	0.991995f,
+	0.118832f,
+	-0.0240058f,
+	0.999711f,
+	0.000939081f,
+	-0.124569f,
+	0.986858f,
+	0.10293f,
+	-0.167243f,
+	0.982306f,
+	-0.0842863f,
+	-0.286295f,
+	0.953093f,
+	0.0982316f,
+	-0.243406f,
+	0.969914f,
+	-0.00444377f,
+	-0.280466f,
+	0.950626f,
+	0.132851f,
+	-0.21091f,
+	0.972115f,
+	0.102516f,
+	-0.230061f,
+	0.951476f,
+	0.204368f,
+	-0.123921f,
+	0.950092f,
+	0.286301f,
+	-0.126792f,
+	0.952499f,
+	0.276893f,
+	-0.0764868f,
+	0.927481f,
+	0.365962f,
+	-0.0452811f,
+	0.949055f,
+	0.31184f,
+	-0.138647f,
+	0.960819f,
+	0.240008f,
+	-0.25036f,
+	0.943892f,
+	0.215377f,
+	-0.314158f,
+	0.941939f,
+	0.118561f,
+	-0.458647f,
+	0.872527f,
+	0.168342f,
+	-0.427047f,
+	0.882261f,
+	0.198106f,
+	-0.485467f,
+	0.864542f,
+	0.129958f,
+	-0.523912f,
+	0.844181f,
+	0.113461f,
+	-0.532843f,
+	0.842328f,
+	0.081008f,
+	-0.518838f,
+	0.84918f,
+	0.0984888f,
+	-0.439028f,
+	0.883929f,
+	0.16101f,
+	-0.409166f,
+	0.878784f,
+	0.245606f,
+	-0.386543f,
+	0.918859f,
+	0.0792661f,
+	-0.447749f,
+	0.88853f,
+	0.100178f,
+	-0.431191f,
+	0.90206f,
+	0.0190184f,
+	-0.467639f,
+	0.880276f,
+	0.0801789f,
+	-0.518882f,
+	0.844495f,
+	-0.132623f,
+	-0.570181f,
+	0.817923f,
+	-0.076789f,
+	-0.420368f,
+	0.883342f,
+	-0.207357f,
+	-0.464447f,
+	0.877342f,
+	-0.120667f,
+	-0.386958f,
+	0.877414f,
+	-0.283564f,
+	-0.442101f,
+	0.874511f,
+	-0.199442f,
+	-0.380012f,
+	0.859996f,
+	-0.340584f,
+	-0.442865f,
+	0.822467f,
+	-0.356959f,
+	-0.24551f,
+	0.880879f,
+	-0.404695f,
+	-0.263304f,
+	0.844058f,
+	-0.467159f,
+	-0.116714f,
+	0.897206f,
+	-0.425909f,
+	-0.129252f,
+	0.860962f,
+	-0.491974f,
+	-0.352237f,
+	0.922053f,
+	0.160457f,
+	-0.402553f,
+	0.906198f,
+	0.129446f,
+	-0.377478f,
+	0.915341f,
+	0.140219f,
+	-0.336315f,
+	0.935519f,
+	0.10815f,
+	-0.335675f,
+	0.937548f,
+	0.0912505f,
+	-0.330532f,
+	0.939201f,
+	0.0930086f,
+	-0.361761f,
+	0.931606f,
+	0.035208f,
+	-0.318172f,
+	0.947538f,
+	0.0306247f,
+	-0.418525f,
+	0.907834f,
+	-0.0259689f,
+	-0.56364f,
+	0.818048f,
+	-0.114485f,
+	-0.461029f,
+	0.882661f,
+	-0.0914388f,
+	-0.472492f,
+	0.87835f,
+	-0.0724725f,
+	-0.523319f,
+	0.846244f,
+	-0.100037f,
+	-0.381187f,
+	0.924062f,
+	-0.0283799f,
+	-0.407557f,
+	0.911105f,
+	-0.0615298f,
+	-0.340677f,
+	0.939702f,
+	0.0299913f,
+	-0.237849f,
+	0.962659f,
+	0.129291f,
+	-0.233755f,
+	0.968303f,
+	0.0880164f,
+	-0.248597f,
+	0.967837f,
+	0.0386268f,
+	-0.357032f,
+	0.933656f,
+	0.0285478f,
+	-0.359392f,
+	0.919937f,
+	0.156695f,
+	-0.375075f,
+	0.918577f,
+	0.12464f,
+	-0.326685f,
+	0.944457f,
+	-0.0357437f,
+	-0.172605f,
+	0.980131f,
+	-0.0977257f,
+	-0.156177f,
+	0.9732f,
+	-0.168789f,
+	-0.0732432f,
+	0.97238f,
+	-0.221612f,
+	0.0871915f,
+	0.980367f,
+	-0.176858f,
+	0.1118f,
+	0.973873f,
+	-0.197667f,
+	0.197176f,
+	0.978426f,
+	-0.0616824f,
+	0.202039f,
+	0.979229f,
+	-0.0170475f,
+	0.172249f,
+	0.982761f,
+	0.0671591f,
+	0.0103709f,
+	0.995351f,
+	0.095751f,
+	0.00657151f,
+	0.996617f,
+	0.0819183f,
+	0.0314022f,
+	0.995508f,
+	0.0893156f,
+	0.0387801f,
+	0.982532f,
+	0.182011f,
+	0.0412148f,
+	0.983254f,
+	0.177521f,
+	0.166642f,
+	0.964252f,
+	0.20603f,
+	0.177047f,
+	0.971307f,
+	0.1588f,
+	0.255603f,
+	0.956785f,
+	0.138671f,
+	0.338465f,
+	0.927074f,
+	0.161166f,
+	0.418264f,
+	0.886168f,
+	0.199401f,
+	0.454161f,
+	0.868211f,
+	0.199869f,
+	0.355471f,
+	0.903694f,
+	0.2387f,
+	0.136408f,
+	0.975339f,
+	0.173515f,
+	-0.0223692f,
+	0.983821f,
+	0.177753f,
+	-0.0947578f,
+	0.983833f,
+	0.151964f,
+	-0.0484831f,
+	0.985895f,
+	0.16019f,
+	-0.137652f,
+	0.965784f,
+	0.219802f,
+	-0.273035f,
+	0.949633f,
+	0.153782f,
+	-0.284296f,
+	0.949219f,
+	0.134753f,
+	-0.233616f,
+	0.961781f,
+	0.142834f,
+	-0.158293f,
+	0.979011f,
+	0.128376f,
+	-0.142079f,
+	0.977628f,
+	0.155106f,
+	-0.179667f,
+	0.940095f,
+	0.289726f,
+	-0.385363f,
+	0.907468f,
+	0.167324f,
+	-0.462662f,
+	0.886082f,
+	0.0283396f,
+	-0.500483f,
+	0.865637f,
+	-0.0137244f,
+	-0.459387f,
+	0.885328f,
+	-0.0718224f,
+	-0.318003f,
+	0.947491f,
+	-0.0336944f,
+	-0.336522f,
+	0.937427f,
+	-0.0893505f,
+	-0.421711f,
+	0.882359f,
+	-0.208814f,
+	-0.386976f,
+	0.894588f,
+	-0.223522f,
+	-0.348564f,
+	0.925302f,
+	-0.149395f,
+	-0.389936f,
+	0.911457f,
+	-0.131135f,
+	-0.262418f,
+	0.94867f,
+	-0.17653f,
+	-0.142966f,
+	0.967048f,
+	-0.210661f,
+	-0.341303f,
+	0.927435f,
+	0.152892f,
+	-0.342877f,
+	0.929169f,
+	0.138133f,
+	-0.327958f,
+	0.941991f,
+	0.0713955f,
+	-0.312837f,
+	0.949244f,
+	0.0326933f,
+	-0.32505f,
+	0.944749f,
+	0.0423311f,
+	-0.35038f,
+	0.936272f,
+	0.0250833f,
+	-0.334661f,
+	0.939274f,
+	0.0759313f,
+	-0.336592f,
+	0.939816f,
+	0.0587454f,
+	-0.383743f,
+	0.919849f,
+	0.0813597f,
+	-0.479391f,
+	0.876726f,
+	0.0391772f,
+	-0.521184f,
+	0.850742f,
+	-0.0678625f,
+	-0.496942f,
+	0.867777f,
+	0.00353465f,
+	-0.521763f,
+	0.848113f,
+	-0.0920201f,
+	-0.373289f,
+	0.923494f,
+	-0.0883984f,
+	-0.40896f,
+	0.910065f,
+	-0.067337f,
+	-0.458758f,
+	0.888254f,
+	0.0233657f,
+	-0.335137f,
+	0.935384f,
+	0.112868f,
+	-0.174079f,
+	0.969266f,
+	0.173839f,
+	-0.174994f,
+	0.976179f,
+	0.128265f,
+	-0.244694f,
+	0.967717f,
+	0.0603988f,
+	-0.409093f,
+	0.90433f,
+	-0.121779f,
+	-0.290803f,
+	0.954139f,
+	-0.0710763f,
+	-0.266076f,
+	0.946406f,
+	-0.183082f,
+	-0.19492f,
+	0.966664f,
+	-0.166031f,
+	-0.107014f,
+	0.989078f,
+	-0.101359f,
+	-0.0950037f,
+	0.987234f,
+	-0.127838f,
+	-0.0081899f,
+	0.996807f,
+	-0.0794301f,
+	0.0655685f,
+	0.997841f,
+	0.0038314f,
+	0.121704f,
+	0.991617f,
+	0.0433953f,
+	0.204125f,
+	0.978885f,
+	0.010797f,
+	0.169834f,
+	0.985465f,
+	0.00398161f,
+	0.0639966f,
+	0.99795f,
+	0.000581677f,
+	0.0389498f,
+	0.997722f,
+	-0.0550831f,
+	-0.00230315f,
+	0.998522f,
+	-0.0543072f,
+	-0.0428959f,
+	0.99833f,
+	-0.0386874f,
+	8.35518e-005f,
+	0.999804f,
+	-0.0198162f,
+	0.12638f,
+	0.991004f,
+	0.0440296f,
+	0.219728f,
+	0.969155f,
+	0.111616f,
+	0.270292f,
+	0.956521f,
+	0.109589f,
+	0.325159f,
+	0.942616f,
+	0.0758083f,
+	0.394886f,
+	0.91647f,
+	0.0644013f,
+	0.455483f,
+	0.885289f,
+	0.0937962f,
+	0.346134f,
+	0.927862f,
+	0.13879f,
+	0.142703f,
+	0.967217f,
+	0.210065f,
+	-0.0417806f,
+	0.973195f,
+	0.226154f,
+	-0.0873343f,
+	0.983405f,
+	0.159022f,
+	-0.027932f,
+	0.984118f,
+	0.175304f,
+	-0.101812f,
+	0.985941f,
+	0.132496f,
+	-0.174734f,
+	0.983884f,
+	0.037939f,
+	-0.279511f,
+	0.957793f,
+	-0.0671252f,
+	-0.277834f,
+	0.959638f,
+	-0.04362f,
+	-0.153076f,
+	0.986374f,
+	0.0602763f,
+	-0.221825f,
+	0.968529f,
+	0.112897f,
+	-0.256381f,
+	0.940693f,
+	0.222182f,
+	-0.236646f,
+	0.958592f,
+	0.158432f,
+	-0.345917f,
+	0.937587f,
+	-0.0356594f,
+	-0.417749f,
+	0.894423f,
+	-0.159665f,
+	-0.456832f,
+	0.853011f,
+	-0.252341f,
+	-0.379407f,
+	0.905637f,
+	-0.189399f,
+	-0.328991f,
+	0.940983f,
+	-0.0794707f,
+	-0.363362f,
+	0.931271f,
+	0.0264943f,
+	-0.48653f,
+	0.873119f,
+	0.0308429f,
+	-0.459174f,
+	0.871133f,
+	0.174033f,
+	-0.359639f,
+	0.91236f,
+	0.1956f,
+	-0.2127f,
+	0.972657f,
+	0.0932592f,
+	-0.0697188f,
+	0.989689f,
+	0.12512f,
+	-0.251887f,
+	0.965064f,
+	0.0721469f,
+	-0.317161f,
+	0.947815f,
+	-0.0324826f,
+	-0.311043f,
+	0.947329f,
+	-0.076288f,
+	-0.343705f,
+	0.938452f,
+	-0.0342691f,
+	-0.318958f,
+	0.946045f,
+	0.0571365f,
+	-0.341405f,
+	0.939767f,
+	0.0167816f,
+	-0.371963f,
+	0.928183f,
+	-0.0109617f,
+	-0.353511f,
+	0.935132f,
+	0.0236193f,
+	-0.398287f,
+	0.910412f,
+	0.111881f,
+	-0.43162f,
+	0.897024f,
+	0.0951448f,
+	-0.485116f,
+	0.874338f,
+	-0.0140269f,
+	-0.473699f,
+	0.879939f,
+	-0.03627f,
+	-0.417805f,
+	0.900966f,
+	-0.117046f,
+	-0.424936f,
+	0.889519f,
+	-0.167884f,
+	-0.467852f,
+	0.878936f,
+	-0.0926624f,
+	-0.493825f,
+	0.865439f,
+	-0.0845782f,
+	-0.351989f,
+	0.932075f,
+	-0.0856709f,
+	-0.214961f,
+	0.974111f,
+	-0.0700008f,
+	-0.163285f,
+	0.986387f,
+	-0.0194449f,
+	-0.162841f,
+	0.986548f,
+	-0.0143588f,
+	-0.285987f,
+	0.956112f,
+	-0.0637334f,
+	-0.292441f,
+	0.94548f,
+	-0.143341f,
+	-0.215932f,
+	0.955314f,
+	-0.201864f,
+	-0.253415f,
+	0.950159f,
+	-0.181603f,
+	-0.183417f,
+	0.974504f,
+	-0.129231f,
+	-0.101906f,
+	0.993299f,
+	-0.0545242f,
+	-0.042238f,
+	0.99904f,
+	-0.0116303f,
+	0.0329811f,
+	0.99907f,
+	-0.0277622f,
+	0.132201f,
+	0.990073f,
+	-0.0477429f,
+	0.267032f,
+	0.963432f,
+	-0.0221792f,
+	0.1278f,
+	0.990718f,
+	-0.0463084f,
+	0.0964891f,
+	0.995299f,
+	-0.00830296f,
+	0.0476853f,
+	0.991211f,
+	-0.123396f,
+	-0.00640997f,
+	0.993203f,
+	-0.116222f,
+	-0.0126443f,
+	0.992773f,
+	-0.119338f,
+	-0.00631822f,
+	0.992917f,
+	-0.118638f,
+	0.0563885f,
+	0.995667f,
+	-0.073943f,
+	0.12664f,
+	0.991687f,
+	-0.022778f,
+	0.273262f,
+	0.961705f,
+	0.021246f,
+	0.388375f,
+	0.920615f,
+	-0.0403992f,
+	0.37695f,
+	0.920931f,
+	-0.0989673f,
+	0.400211f,
+	0.914808f,
+	0.0543818f,
+	0.279689f,
+	0.947142f,
+	0.15715f,
+	0.0626591f,
+	0.985325f,
+	0.158772f,
+	0.0197159f,
+	0.983213f,
+	0.181391f,
+	0.0112307f,
+	0.995546f,
+	0.0936022f,
+	-0.0611233f,
+	0.998037f,
+	0.013638f,
+	-0.0515369f,
+	0.996025f,
+	0.0726543f,
+	-0.060221f,
+	0.998076f,
+	0.0147593f,
+	-0.21333f,
+	0.972986f,
+	-0.0882534f,
+	-0.330599f,
+	0.94012f,
+	-0.0829391f,
+	-0.311254f,
+	0.950309f,
+	-0.00575056f,
+	-0.324983f,
+	0.931955f,
+	0.160768f,
+	-0.245964f,
+	0.942146f,
+	0.227736f,
+	-0.125195f,
+	0.981121f,
+	0.147403f,
+	-0.193437f,
+	0.975595f,
+	0.103908f,
+	-0.319958f,
+	0.946961f,
+	0.029845f,
+	-0.440983f,
+	0.895915f,
+	-0.0535662f,
+	-0.477838f,
+	0.878381f,
+	-0.0108058f,
+	-0.480471f,
+	0.872693f,
+	0.0869201f,
+	-0.478968f,
+	0.83494f,
+	0.271043f,
+	-0.490257f,
+	0.796981f,
+	0.352803f,
+	-0.434277f,
+	0.834185f,
+	0.339909f,
+	-0.265882f,
+	0.929328f,
+	0.256236f,
+	-0.142385f,
+	0.958793f,
+	0.245852f,
+	-0.182126f,
+	0.963412f,
+	0.196642f,
+	-0.0681643f,
+	0.992157f,
+	0.104781f,
+	-0.176883f,
+	0.983918f,
+	0.024857f,
+	-0.305513f,
+	0.952069f,
+	-0.0150524f,
+	-0.401485f,
+	0.91552f,
+	0.0251517f,
+	-0.372509f,
+	0.927256f,
+	0.0378572f,
+	-0.265017f,
+	0.964159f,
+	0.0127972f,
+	-0.342134f,
+	0.935688f,
+	-0.0862078f,
+	-0.427338f,
+	0.901948f,
+	-0.062226f,
+	-0.447549f,
+	0.894216f,
+	0.00877894f,
+	-0.382185f,
+	0.923573f,
+	-0.0307708f,
+	-0.386509f,
+	0.921774f,
+	-0.0307138f,
+	-0.457766f,
+	0.884255f,
+	-0.0924303f,
+	-0.384262f,
+	0.916404f,
+	-0.11201f,
+	-0.431623f,
+	0.886784f,
+	-0.165273f,
+	-0.460575f,
+	0.869789f,
+	-0.177024f,
+	-0.471547f,
+	0.850265f,
+	-0.233865f,
+	-0.351048f,
+	0.911491f,
+	-0.214361f,
+	-0.263539f,
+	0.9431f,
+	-0.202755f,
+	-0.173283f,
+	0.972074f,
+	-0.158258f,
+	-0.19847f,
+	0.960809f,
+	-0.193536f,
+	-0.275034f,
+	0.951707f,
+	-0.136422f,
+	-0.217032f,
+	0.958372f,
+	-0.185526f,
+	-0.201987f,
+	0.95666f,
+	-0.209771f,
+	-0.299318f,
+	0.94727f,
+	-0.114406f,
+	-0.187056f,
+	0.978613f,
+	-0.0855959f,
+	-0.155621f,
+	0.97153f,
+	-0.178637f,
+	-0.0810385f,
+	0.981009f,
+	-0.176221f,
+	0.0905036f,
+	0.986207f,
+	-0.138581f,
+	0.115825f,
+	0.982705f,
+	-0.14448f,
+	0.19636f,
+	0.97731f,
+	-0.0794224f,
+	0.143519f,
+	0.988245f,
+	-0.0526749f,
+	0.109744f,
+	0.989619f,
+	-0.0927937f,
+	0.197571f,
+	0.972036f,
+	-0.12693f,
+	0.00332495f,
+	0.962309f,
+	-0.271939f,
+	-0.0356976f,
+	0.959351f,
+	-0.279948f,
+	-0.0721767f,
+	0.96735f,
+	-0.242948f,
+	-0.00843005f,
+	0.989549f,
+	-0.143952f,
+	0.152572f,
+	0.983317f,
+	-0.0990425f,
+	0.281378f,
+	0.943362f,
+	-0.175768f,
+	0.428891f,
+	0.891683f,
+	-0.144753f,
+	0.290445f,
+	0.954517f,
+	-0.0673633f,
+	0.176401f,
+	0.973557f,
+	0.145155f,
+	0.232983f,
+	0.924473f,
+	0.301776f,
+	0.181127f,
+	0.950255f,
+	0.253393f,
+	-0.00165339f,
+	0.991402f,
+	0.130837f,
+	0.0981935f,
+	0.976268f,
+	0.193027f,
+	0.000170743f,
+	0.996657f,
+	0.0816968f,
+	-0.0970384f,
+	0.995225f,
+	-0.0105345f,
+	-0.00895717f,
+	0.999951f,
+	-0.00426387f,
+	-0.170944f,
+	0.985202f,
+	-0.0124686f,
+	-0.362907f,
+	0.93182f,
+	-0.00317037f,
+	-0.388121f,
+	0.921046f,
+	0.0322033f,
+	-0.407598f,
+	0.90852f,
+	0.0919578f,
+	-0.247403f,
+	0.962759f,
+	0.109032f,
+	-0.0829823f,
+	0.986114f,
+	0.143848f,
+	-0.240859f,
+	0.956011f,
+	0.167424f,
+	-0.312142f,
+	0.912012f,
+	0.266086f,
+	-0.398269f,
+	0.862926f,
+	0.311032f,
+	-0.511957f,
+	0.795091f,
+	0.325161f,
+	-0.506846f,
+	0.755093f,
+	0.415864f,
+	-0.506747f,
+	0.718735f,
+	0.476054f,
+	-0.45002f,
+	0.736589f,
+	0.504895f,
+	-0.287855f,
+	0.833759f,
+	0.471153f,
+	-0.237765f,
+	0.90713f,
+	0.34725f,
+	-0.146865f,
+	0.915961f,
+	0.373425f,
+	-0.0859218f,
+	0.935714f,
+	0.342136f,
+	-0.054455f,
+	0.996952f,
+	-0.0558782f,
+	-0.211499f,
+	0.976662f,
+	-0.0374149f,
+	-0.331452f,
+	0.940975f,
+	0.0686022f,
+	-0.397421f,
+	0.917381f,
+	0.0216451f,
+	-0.316207f,
+	0.946964f,
+	-0.0572054f,
+	-0.202804f,
+	0.975284f,
+	-0.0877067f,
+	-0.28846f,
+	0.951091f,
+	-0.110532f,
+	-0.440756f,
+	0.882415f,
+	-0.164552f,
+	-0.391159f,
+	0.897816f,
+	-0.202288f,
+	-0.37945f,
+	0.884355f,
+	-0.27191f,
+	-0.436492f,
+	0.880924f,
+	-0.182888f,
+	-0.458204f,
+	0.880643f,
+	-0.12049f,
+	-0.365575f,
+	0.927969f,
+	-0.0723085f,
+	-0.344164f,
+	0.93545f,
+	-0.0805227f,
+	-0.392565f,
+	0.898448f,
+	-0.196683f,
+	-0.458844f,
+	0.839155f,
+	-0.292028f,
+	-0.406986f,
+	0.873305f,
+	-0.267769f,
+	-0.264536f,
+	0.933458f,
+	-0.242234f,
+	-0.197907f,
+	0.946975f,
+	-0.253123f,
+	-0.162416f,
+	0.964761f,
+	-0.207018f,
+	-0.261287f,
+	0.932524f,
+	-0.249254f,
+	-0.237723f,
+	0.937266f,
+	-0.25499f,
+	-0.255938f,
+	0.959549f,
+	-0.117312f,
+	-0.378394f,
+	0.921703f,
+	-0.0853291f,
+	-0.154569f,
+	0.983106f,
+	-0.098032f,
+	0.020864f,
+	0.98441f,
+	-0.174648f,
+	-0.0493076f,
+	0.945704f,
+	-0.321268f,
+	0.00354211f,
+	0.950539f,
+	-0.310586f,
+	0.0705741f,
+	0.962405f,
+	-0.262289f,
+	0.155003f,
+	0.952815f,
+	-0.260992f,
+	0.190084f,
+	0.945182f,
+	-0.265518f,
+	0.109466f,
+	0.94166f,
+	-0.318268f,
+	0.219465f,
+	0.948713f,
+	-0.227551f,
+	0.131592f,
+	0.95776f,
+	-0.255694f,
+	-0.023132f,
+	0.936016f,
+	-0.351196f,
+	-0.102398f,
+	0.923738f,
+	-0.369083f,
+	-0.11778f,
+	0.928743f,
+	-0.351518f,
+	0.14699f,
+	0.959781f,
+	-0.239196f,
+	0.329451f,
+	0.917295f,
+	-0.223678f,
+	0.290403f,
+	0.942778f,
+	-0.163815f,
+	0.10086f,
+	0.993272f,
+	0.056896f,
+	0.00690717f,
+	0.980954f,
+	0.194116f,
+	0.198478f,
+	0.949829f,
+	0.241726f,
+	0.257584f,
+	0.935998f,
+	0.239913f,
+	0.0870031f,
+	0.976807f,
+	0.195647f,
+	0.0578083f,
+	0.994066f,
+	0.0921449f,
+	0.121554f,
+	0.989161f,
+	0.0823711f,
+	0.0335983f,
+	0.999242f,
+	0.0196737f,
+	-0.0544848f,
+	0.997579f,
+	-0.0432265f,
+	-0.170331f,
+	0.98419f,
+	0.0485619f,
+	-0.366378f,
+	0.930108f,
+	-0.0258115f,
+	-0.430564f,
+	0.901925f,
+	-0.0338598f,
+	-0.412156f,
+	0.909498f,
+	0.0542308f,
+	-0.303685f,
+	0.949097f,
+	0.0836093f,
+	-0.198153f,
+	0.949404f,
+	0.243656f,
+	-0.267445f,
+	0.871756f,
+	0.410506f,
+	-0.393769f,
+	0.805932f,
+	0.442062f,
+	-0.427473f,
+	0.750775f,
+	0.50359f,
+	-0.522691f,
+	0.707231f,
+	0.476044f,
+	-0.550081f,
+	0.670741f,
+	0.497511f,
+	-0.518356f,
+	0.695815f,
+	0.49714f,
+	-0.372017f,
+	0.764162f,
+	0.526934f,
+	-0.210863f,
+	0.841692f,
+	0.497082f,
+	-0.116051f,
+	0.87101f,
+	0.477362f,
+	-0.106872f,
+	0.906726f,
+	0.407954f,
+	0.0295506f,
+	0.897687f,
+	0.439643f,
+	-0.11391f,
+	0.993475f,
+	0.00559176f,
+	-0.238885f,
+	0.970513f,
+	0.0322297f,
+	-0.352278f,
+	0.935893f,
+	0.00201985f,
+	-0.29155f,
+	0.955165f,
+	-0.0515582f,
+	-0.283012f,
+	0.950207f,
+	-0.130422f,
+	-0.233718f,
+	0.966509f,
+	-0.105997f,
+	-0.293314f,
+	0.953293f,
+	-0.0721f,
+	-0.344057f,
+	0.937935f,
+	-0.0436188f,
+	-0.359338f,
+	0.921856f,
+	-0.145114f,
+	-0.361988f,
+	0.90939f,
+	-0.204876f,
+	-0.478777f,
+	0.840974f,
+	-0.252063f,
+	-0.501126f,
+	0.832032f,
+	-0.237897f,
+	-0.42396f,
+	0.887247f,
+	-0.1818f,
+	-0.340692f,
+	0.929815f,
+	-0.13919f,
+	-0.261328f,
+	0.946412f,
+	-0.189766f,
+	-0.383135f,
+	0.863856f,
+	-0.327048f,
+	-0.4248f,
+	0.838392f,
+	-0.341533f,
+	-0.258907f,
+	0.912327f,
+	-0.317216f,
+	-0.273875f,
+	0.922352f,
+	-0.272505f,
+	-0.216284f,
+	0.973372f,
+	-0.0759435f,
+	-0.186061f,
+	0.980681f,
+	-0.0603919f,
+	-0.327344f,
+	0.93227f,
+	-0.15401f,
+	-0.354135f,
+	0.933013f,
+	-0.0638423f,
+	-0.30838f,
+	0.94174f,
+	-0.13427f,
+	-0.0952482f,
+	0.963393f,
+	-0.250602f,
+	0.0864929f,
+	0.957116f,
+	-0.276491f,
+	0.0265645f,
+	0.947809f,
+	-0.31773f,
+	-0.00743162f,
+	0.929747f,
+	-0.368124f,
+	0.0794584f,
+	0.926075f,
+	-0.368877f,
+	0.177698f,
+	0.921503f,
+	-0.345334f,
+	0.210118f,
+	0.923104f,
+	-0.322071f,
+	0.0972314f,
+	0.929984f,
+	-0.354507f,
+	0.0931107f,
+	0.932401f,
+	-0.349226f,
+	0.163846f,
+	0.947557f,
+	-0.274392f,
+	0.04099f,
+	0.947023f,
+	-0.318539f,
+	-0.0637185f,
+	0.942657f,
+	-0.327625f,
+	-0.131539f,
+	0.923216f,
+	-0.361068f,
+	0.0323928f,
+	0.932437f,
+	-0.359877f,
+	0.242794f,
+	0.937436f,
+	-0.249528f,
+	0.154647f,
+	0.984538f,
+	-0.0822692f,
+	-0.0290139f,
+	0.999421f,
+	0.0177744f,
+	-0.0330797f,
+	0.998482f,
+	0.0440283f,
+	0.157195f,
+	0.980432f,
+	0.118503f,
+	0.251646f,
+	0.94505f,
+	0.208697f,
+	0.178529f,
+	0.966849f,
+	0.182568f,
+	0.171641f,
+	0.982807f,
+	0.0680498f,
+	0.107902f,
+	0.993714f,
+	0.0298233f,
+	0.00302695f,
+	0.994036f,
+	0.109006f,
+	-0.0844358f,
+	0.977656f,
+	0.19251f,
+	-0.18119f,
+	0.958323f,
+	0.220878f,
+	-0.285317f,
+	0.945377f,
+	0.157659f,
+	-0.419121f,
+	0.895183f,
+	0.151606f,
+	-0.490039f,
+	0.857134f,
+	0.158693f,
+	-0.402244f,
+	0.878123f,
+	0.259038f,
+	-0.398659f,
+	0.825161f,
+	0.400226f,
+	-0.427626f,
+	0.728675f,
+	0.534948f,
+	-0.378859f,
+	0.704334f,
+	0.600316f,
+	-0.386613f,
+	0.684959f,
+	0.617545f,
+	-0.440363f,
+	0.648556f,
+	0.62085f,
+	-0.484249f,
+	0.659981f,
+	0.574394f,
+	-0.462576f,
+	0.728741f,
+	0.504936f,
+	-0.380875f,
+	0.811463f,
+	0.443241f,
+	-0.190303f,
+	0.865049f,
+	0.464193f,
+	-0.0749094f,
+	0.86956f,
+	0.488113f,
+	-0.11614f,
+	0.868815f,
+	0.481323f,
+	-0.102623f,
+	0.843113f,
+	0.527854f,
+	-0.198362f,
+	0.979655f,
+	0.0304707f,
+	-0.238942f,
+	0.970277f,
+	0.0383318f,
+	-0.308109f,
+	0.951351f,
+	-0.000213496f,
+	-0.245044f,
+	0.968893f,
+	0.0346459f,
+	-0.275786f,
+	0.960816f,
+	-0.0278198f,
+	-0.256726f,
+	0.965729f,
+	-0.0381932f,
+	-0.318964f,
+	0.947473f,
+	-0.0236049f,
+	-0.388409f,
+	0.921405f,
+	0.0123096f,
+	-0.298771f,
+	0.953298f,
+	0.0442638f,
+	-0.291187f,
+	0.956662f,
+	0.00282226f,
+	-0.39367f,
+	0.915026f,
+	-0.0880448f,
+	-0.501897f,
+	0.840236f,
+	-0.20519f,
+	-0.460271f,
+	0.863055f,
+	-0.208055f,
+	-0.311786f,
+	0.925724f,
+	-0.214066f,
+	-0.177876f,
+	0.937081f,
+	-0.300397f,
+	-0.256831f,
+	0.902901f,
+	-0.344683f,
+	-0.413909f,
+	0.808626f,
+	-0.418096f,
+	-0.347694f,
+	0.845102f,
+	-0.406092f,
+	-0.390269f,
+	0.881564f,
+	-0.265585f,
+	-0.38258f,
+	0.915768f,
+	-0.122479f,
+	-0.172737f,
+	0.984864f,
+	-0.0142896f,
+	-0.221138f,
+	0.97315f,
+	-0.0638528f,
+	-0.32806f,
+	0.922266f,
+	-0.204454f,
+	-0.20334f,
+	0.945769f,
+	-0.253326f,
+	-0.0362109f,
+	0.959773f,
+	-0.278433f,
+	0.0451082f,
+	0.968522f,
+	-0.244806f,
+	0.103574f,
+	0.977375f,
+	-0.184421f,
+	0.095607f,
+	0.942862f,
+	-0.319172f,
+	0.028855f,
+	0.903939f,
+	-0.426688f,
+	0.0781753f,
+	0.937277f,
+	-0.339707f,
+	0.163597f,
+	0.966118f,
+	-0.199631f,
+	0.165445f,
+	0.973063f,
+	-0.160553f,
+	0.145787f,
+	0.95097f,
+	-0.272767f,
+	0.130591f,
+	0.92029f,
+	-0.368799f,
+	0.0531207f,
+	0.931628f,
+	-0.35951f,
+	-0.0802666f,
+	0.935074f,
+	-0.345244f,
+	-0.124987f,
+	0.942063f,
+	-0.311281f,
+	0.0397165f,
+	0.963525f,
+	-0.264653f,
+	0.0790619f,
+	0.96623f,
+	-0.245254f,
+	0.0277086f,
+	0.995754f,
+	-0.0877838f,
+	-0.0718135f,
+	0.997414f,
+	0.00271225f,
+	-0.0601764f,
+	0.993596f,
+	0.0956336f,
+	0.0305316f,
+	0.992338f,
+	0.119724f,
+	0.184993f,
+	0.96549f,
+	0.183324f,
+	0.240982f,
+	0.949316f,
+	0.20181f,
+	0.205406f,
+	0.960305f,
+	0.188739f,
+	0.0685231f,
+	0.967991f,
+	0.241448f,
+	-0.121139f,
+	0.95072f,
+	0.285408f,
+	-0.150135f,
+	0.918283f,
+	0.366355f,
+	-0.132611f,
+	0.919499f,
+	0.370048f,
+	-0.285199f,
+	0.893271f,
+	0.34746f,
+	-0.428415f,
+	0.803512f,
+	0.413316f,
+	-0.445474f,
+	0.783214f,
+	0.433738f,
+	-0.459983f,
+	0.771026f,
+	0.44038f,
+	-0.467611f,
+	0.730475f,
+	0.497741f,
+	-0.48066f,
+	0.718458f,
+	0.502777f,
+	-0.417628f,
+	0.706128f,
+	0.571814f,
+	-0.464585f,
+	0.665035f,
+	0.584713f,
+	-0.472738f,
+	0.646587f,
+	0.598702f,
+	-0.412146f,
+	0.689264f,
+	0.595861f,
+	-0.326825f,
+	0.752406f,
+	0.5719f,
+	-0.254151f,
+	0.834713f,
+	0.48853f,
+	-0.235109f,
+	0.888903f,
+	0.39316f,
+	-0.153581f,
+	0.849492f,
+	0.504753f,
+	-0.150095f,
+	0.815518f,
+	0.558929f,
+	-0.18873f,
+	0.837012f,
+	0.513607f,
+	0.0689174f,
+	0.995773f,
+	0.0607139f,
+	-0.155258f,
+	0.983404f,
+	-0.0938683f,
+	-0.345692f,
+	0.927547f,
+	-0.141961f,
+	-0.289881f,
+	0.953783f,
+	-0.079168f,
+	-0.192407f,
+	0.979661f,
+	-0.0569578f,
+	-0.267677f,
+	0.960104f,
+	-0.0809323f,
+	-0.338627f,
+	0.940905f,
+	-0.0054102f,
+	-0.378143f,
+	0.925406f,
+	-0.0251327f,
+	-0.331689f,
+	0.941021f,
+	-0.0667991f,
+	-0.266964f,
+	0.963694f,
+	-0.00485284f,
+	-0.326986f,
+	0.944023f,
+	-0.0435962f,
+	-0.406544f,
+	0.902607f,
+	-0.141498f,
+	-0.445264f,
+	0.84532f,
+	-0.295253f,
+	-0.261882f,
+	0.90946f,
+	-0.322956f,
+	-0.131634f,
+	0.928868f,
+	-0.346231f,
+	-0.231876f,
+	0.922232f,
+	-0.30939f,
+	-0.381112f,
+	0.87967f,
+	-0.284489f,
+	-0.459513f,
+	0.85999f,
+	-0.22196f,
+	-0.498013f,
+	0.864257f,
+	-0.0710131f,
+	-0.440544f,
+	0.89211f,
+	-0.100303f,
+	-0.247938f,
+	0.96287f,
+	-0.106806f,
+	-0.10732f,
+	0.992504f,
+	-0.0584663f,
+	-0.221465f,
+	0.956592f,
+	-0.189431f,
+	-0.229248f,
+	0.946541f,
+	-0.22695f,
+	-0.0978243f,
+	0.972744f,
+	-0.210239f,
+	-0.0379465f,
+	0.985853f,
+	-0.163259f,
+	0.0806013f,
+	0.992194f,
+	-0.0951546f,
+	0.280296f,
+	0.95443f,
+	-0.102456f,
+	0.155799f,
+	0.941292f,
+	-0.299494f,
+	-0.0466248f,
+	0.90184f,
+	-0.429548f,
+	0.0333539f,
+	0.93989f,
+	-0.339845f,
+	0.15766f,
+	0.95203f,
+	-0.262264f,
+	0.275219f,
+	0.92494f,
+	-0.262186f,
+	0.226492f,
+	0.914035f,
+	-0.336513f,
+	0.0375497f,
+	0.921004f,
+	-0.387739f,
+	-0.0841489f,
+	0.913809f,
+	-0.39733f,
+	-0.216548f,
+	0.901013f,
+	-0.375874f,
+	-0.0617755f,
+	0.971104f,
+	-0.230524f,
+	0.0635289f,
+	0.988552f,
+	-0.136856f,
+	-0.0898172f,
+	0.987883f,
+	-0.126568f,
+	-0.195744f,
+	0.9803f,
+	-0.0263689f,
+	-0.163398f,
+	0.98375f,
+	0.0744142f,
+	0.0549941f,
+	0.99236f,
+	0.110438f,
+	0.19398f,
+	0.975972f,
+	0.0992507f,
+	0.191759f,
+	0.972804f,
+	0.129928f,
+	0.149866f,
+	0.963222f,
+	0.223034f,
+	-0.00306242f,
+	0.957956f,
+	0.286898f,
+	-0.13576f,
+	0.938575f,
+	0.317249f,
+	-0.176601f,
+	0.936485f,
+	0.303f,
+	-0.158083f,
+	0.914215f,
+	0.373122f,
+	-0.316693f,
+	0.854194f,
+	0.412381f,
+	-0.498069f,
+	0.774619f,
+	0.389733f,
+	-0.492142f,
+	0.755365f,
+	0.432688f,
+	-0.453311f,
+	0.739293f,
+	0.49795f,
+	-0.471661f,
+	0.730931f,
+	0.49323f,
+	-0.504596f,
+	0.695479f,
+	0.511558f,
+	-0.486075f,
+	0.660592f,
+	0.572145f,
+	-0.455536f,
+	0.681017f,
+	0.573326f,
+	-0.475459f,
+	0.732851f,
+	0.486691f,
+	-0.40679f,
+	0.784517f,
+	0.468032f,
+	-0.294511f,
+	0.862991f,
+	0.410499f,
+	-0.137096f,
+	0.926626f,
+	0.350098f,
+	-0.212171f,
+	0.92693f,
+	0.30949f,
+	-0.320702f,
+	0.890591f,
+	0.322488f,
+	-0.144781f,
+	0.913051f,
+	0.381284f,
+	-0.0467088f,
+	0.929255f,
+	0.366475f,
+	0.190524f,
+	0.979715f,
+	0.0621193f,
+	-0.0159571f,
+	0.99888f,
+	-0.0445494f,
+	-0.299493f,
+	0.937414f,
+	-0.177647f,
+	-0.30245f,
+	0.926474f,
+	-0.223986f,
+	-0.236991f,
+	0.948637f,
+	-0.209579f,
+	-0.316653f,
+	0.935173f,
+	-0.15869f,
+	-0.385652f,
+	0.9143f,
+	-0.123807f,
+	-0.33937f,
+	0.934637f,
+	-0.106213f,
+	-0.347064f,
+	0.934195f,
+	-0.0826249f,
+	-0.295744f,
+	0.955249f,
+	0.00583919f,
+	-0.275005f,
+	0.961059f,
+	-0.0271544f,
+	-0.269439f,
+	0.957464f,
+	-0.103275f,
+	-0.282112f,
+	0.919833f,
+	-0.272616f,
+	-0.294141f,
+	0.877255f,
+	-0.379347f,
+	-0.188084f,
+	0.929949f,
+	-0.315942f,
+	-0.305781f,
+	0.908958f,
+	-0.283361f,
+	-0.494244f,
+	0.854771f,
+	-0.158396f,
+	-0.556326f,
+	0.828917f,
+	0.0582992f,
+	-0.534005f,
+	0.83843f,
+	0.108964f,
+	-0.372194f,
+	0.92607f,
+	0.0621723f,
+	-0.216902f,
+	0.97615f,
+	-0.00922891f,
+	-0.129625f,
+	0.988755f,
+	-0.0745716f,
+	-0.137022f,
+	0.98954f,
+	-0.0451077f,
+	-0.210914f,
+	0.969697f,
+	-0.123297f,
+	-0.0927848f,
+	0.980946f,
+	-0.170691f,
+	-0.0487293f,
+	0.98279f,
+	-0.178186f,
+	0.0377154f,
+	0.983594f,
+	-0.176409f,
+	0.270827f,
+	0.95519f,
+	-0.119436f,
+	0.365037f,
+	0.928517f,
+	-0.0678507f,
+	0.131842f,
+	0.951604f,
+	-0.277612f,
+	-0.0185121f,
+	0.905238f,
+	-0.424502f,
+	0.118166f,
+	0.903064f,
+	-0.412931f,
+	0.230045f,
+	0.8849f,
+	-0.405008f,
+	0.2101f,
+	0.906634f,
+	-0.365886f,
+	0.0544702f,
+	0.94453f,
+	-0.323878f,
+	-0.0630069f,
+	0.9598f,
+	-0.273522f,
+	-0.203027f,
+	0.928033f,
+	-0.312304f,
+	-0.22235f,
+	0.90002f,
+	-0.374866f,
+	0.0164141f,
+	0.973192f,
+	-0.229407f,
+	-0.131299f,
+	0.967472f,
+	-0.216237f,
+	-0.248586f,
+	0.95668f,
+	-0.151553f,
+	-0.180678f,
+	0.971697f,
+	-0.152182f,
+	0.021506f,
+	0.991774f,
+	-0.126182f,
+	0.129882f,
+	0.991187f,
+	-0.0260519f,
+	0.125479f,
+	0.988703f,
+	0.0819803f,
+	0.0585413f,
+	0.987325f,
+	0.14752f,
+	-0.0186301f,
+	0.977162f,
+	0.211676f,
+	-0.162972f,
+	0.968132f,
+	0.19016f,
+	-0.218545f,
+	0.935778f,
+	0.276691f,
+	-0.284144f,
+	0.890895f,
+	0.354356f,
+	-0.345593f,
+	0.839997f,
+	0.418295f,
+	-0.488331f,
+	0.792258f,
+	0.36587f,
+	-0.545891f,
+	0.770241f,
+	0.329746f,
+	-0.533891f,
+	0.766492f,
+	0.357002f,
+	-0.51665f,
+	0.749346f,
+	0.414189f,
+	-0.616561f,
+	0.690345f,
+	0.37852f,
+	-0.519109f,
+	0.719346f,
+	0.461593f,
+	-0.392236f,
+	0.782177f,
+	0.484097f,
+	-0.398436f,
+	0.817816f,
+	0.415241f,
+	-0.392025f,
+	0.864189f,
+	0.315428f,
+	-0.176475f,
+	0.937288f,
+	0.300577f,
+	-0.137444f,
+	0.969881f,
+	0.201097f,
+	-0.206545f,
+	0.942409f,
+	0.263066f,
+	-0.293185f,
+	0.938992f,
+	0.179823f,
+	-0.159029f,
+	0.985376f,
+	0.0611911f,
+	0.00174953f,
+	0.998094f,
+	0.0616789f,
+	0.241821f,
+	0.962041f,
+	0.126492f,
+	0.127737f,
+	0.984773f,
+	0.117921f,
+	-0.17559f,
+	0.984255f,
+	0.0202494f,
+	-0.277772f,
+	0.957333f,
+	-0.0797282f,
+	-0.264237f,
+	0.953214f,
+	-0.146839f,
+	-0.330132f,
+	0.935063f,
+	-0.129113f,
+	-0.363469f,
+	0.924563f,
+	-0.114338f,
+	-0.371034f,
+	0.917638f,
+	-0.142388f,
+	-0.425424f,
+	0.897691f,
+	-0.114736f,
+	-0.353654f,
+	0.934652f,
+	-0.0368062f,
+	-0.218582f,
+	0.975792f,
+	0.007136f,
+	-0.203676f,
+	0.978799f,
+	-0.0216238f,
+	-0.149661f,
+	0.987587f,
+	-0.0476727f,
+	-0.278943f,
+	0.945373f,
+	-0.1687f,
+	-0.239375f,
+	0.951961f,
+	-0.190969f,
+	-0.360119f,
+	0.921099f,
+	-0.147955f,
+	-0.584157f,
+	0.811569f,
+	0.0107674f,
+	-0.61484f,
+	0.786528f,
+	0.0578414f,
+	-0.504089f,
+	0.86363f,
+	-0.00605437f,
+	-0.333455f,
+	0.94143f,
+	-0.0501755f,
+	-0.123418f,
+	0.989972f,
+	-0.0687344f,
+	-0.105519f,
+	0.985418f,
+	-0.133478f,
+	-0.134701f,
+	0.9843f,
+	-0.114061f,
+	-0.137014f,
+	0.977235f,
+	-0.161985f,
+	-0.0439551f,
+	0.980481f,
+	-0.191638f,
+	-0.0327274f,
+	0.96544f,
+	-0.258561f,
+	0.0268923f,
+	0.955378f,
+	-0.294159f,
+	0.189265f,
+	0.941783f,
+	-0.277892f,
+	0.306008f,
+	0.930356f,
+	-0.201982f,
+	0.2909f,
+	0.948465f,
+	-0.12566f,
+	0.135694f,
+	0.963424f,
+	-0.231086f,
+	0.114996f,
+	0.92781f,
+	-0.354886f,
+	0.243157f,
+	0.920361f,
+	-0.306286f,
+	0.181493f,
+	0.943785f,
+	-0.27628f,
+	-0.0348676f,
+	0.964621f,
+	-0.261325f,
+	-0.138397f,
+	0.964431f,
+	-0.225208f,
+	-0.0584572f,
+	0.973863f,
+	-0.219483f,
+	-0.160488f,
+	0.904663f,
+	-0.394751f,
+	-0.113572f,
+	0.901558f,
+	-0.417487f,
+	-0.155065f,
+	0.923521f,
+	-0.350803f,
+	-0.242307f,
+	0.919914f,
+	-0.308295f,
+	-0.206106f,
+	0.923371f,
+	-0.323891f,
+	-0.0753677f,
+	0.972428f,
+	-0.220691f,
+	0.00286078f,
+	0.993423f,
+	-0.114469f,
+	0.0506503f,
+	0.998257f,
+	-0.0302924f,
+	-0.0328546f,
+	0.999299f,
+	0.017926f,
+	-0.060813f,
+	0.979003f,
+	0.194565f,
+	-0.19049f,
+	0.94338f,
+	0.271567f,
+	-0.332962f,
+	0.885593f,
+	0.323821f,
+	-0.330466f,
+	0.869145f,
+	0.367938f,
+	-0.383415f,
+	0.840587f,
+	0.382632f,
+	-0.450848f,
+	0.795155f,
+	0.405542f,
+	-0.50223f,
+	0.7918f,
+	0.347589f,
+	-0.586371f,
+	0.768822f,
+	0.255112f,
+	-0.550176f,
+	0.765625f,
+	0.333355f,
+	-0.594581f,
+	0.747662f,
+	0.295761f,
+	-0.604774f,
+	0.771025f,
+	0.199423f,
+	-0.461798f,
+	0.840354f,
+	0.283809f,
+	-0.323989f,
+	0.875237f,
+	0.359155f,
+	-0.321766f,
+	0.916629f,
+	0.23719f,
+	-0.168943f,
+	0.967667f,
+	0.187293f,
+	-0.107108f,
+	0.976625f,
+	0.186366f,
+	-0.222921f,
+	0.963011f,
+	0.151379f,
+	-0.142187f,
+	0.985732f,
+	0.0900906f,
+	-0.0555822f,
+	0.997373f,
+	-0.0464466f,
+	-0.00128055f,
+	0.995901f,
+	-0.0904418f,
+	0.189226f,
+	0.980362f,
+	-0.0555288f,
+	0.085267f,
+	0.996327f,
+	-0.00782177f,
+	-0.128918f,
+	0.990746f,
+	0.042464f,
+	-0.188312f,
+	0.982054f,
+	-0.0104463f,
+	-0.196136f,
+	0.979449f,
+	-0.0470074f,
+	-0.346836f,
+	0.935484f,
+	-0.0676365f,
+	-0.385817f,
+	0.920741f,
+	-0.0581445f,
+	-0.364523f,
+	0.930255f,
+	-0.0418259f,
+	-0.413227f,
+	0.910109f,
+	-0.0307546f,
+	-0.395357f,
+	0.915702f,
+	-0.071985f,
+	-0.249105f,
+	0.966325f,
+	-0.0645241f,
+	-0.224404f,
+	0.97132f,
+	-0.0786097f,
+	-0.136636f,
+	0.989057f,
+	-0.0556425f,
+	-0.161967f,
+	0.98357f,
+	-0.0797312f,
+	-0.264069f,
+	0.956689f,
+	-0.122532f,
+	-0.415862f,
+	0.909427f,
+	-0.00117779f,
+	-0.618635f,
+	0.784039f,
+	0.0507281f,
+	-0.569525f,
+	0.818988f,
+	-0.0700017f,
+	-0.458442f,
+	0.876243f,
+	-0.148424f,
+	-0.301532f,
+	0.936403f,
+	-0.179521f,
+	-0.125352f,
+	0.969963f,
+	-0.208469f,
+	-0.0885456f,
+	0.971015f,
+	-0.222014f,
+	-0.127345f,
+	0.96169f,
+	-0.242765f,
+	-0.111865f,
+	0.95953f,
+	-0.258434f,
+	-0.00408963f,
+	0.957803f,
+	-0.287396f,
+	0.0423217f,
+	0.932535f,
+	-0.358592f,
+	0.0695614f,
+	0.921939f,
+	-0.381037f,
+	0.190852f,
+	0.890613f,
+	-0.412775f,
+	0.209386f,
+	0.879353f,
+	-0.427663f,
+	0.178912f,
+	0.925963f,
+	-0.332541f,
+	0.21012f,
+	0.943847f,
+	-0.254954f,
+	0.194248f,
+	0.92787f,
+	-0.318316f,
+	0.12116f,
+	0.941808f,
+	-0.313556f,
+	0.143074f,
+	0.982238f,
+	-0.121399f,
+	0.00445755f,
+	0.990826f,
+	-0.135068f,
+	-0.0763662f,
+	0.964673f,
+	-0.252139f,
+	-0.00960064f,
+	0.938734f,
+	-0.34451f,
+	-0.0448775f,
+	0.923487f,
+	-0.380997f,
+	-0.121038f,
+	0.899958f,
+	-0.418839f,
+	-0.214432f,
+	0.896136f,
+	-0.388536f,
+	-0.236628f,
+	0.909444f,
+	-0.341933f,
+	-0.245801f,
+	0.902665f,
+	-0.353239f,
+	-0.210816f,
+	0.938091f,
+	-0.274848f,
+	-0.0790665f,
+	0.981118f,
+	-0.17651f,
+	-0.0418777f,
+	0.998086f,
+	-0.0455073f,
+	-0.112513f,
+	0.981903f,
+	0.152339f,
+	-0.289647f,
+	0.921573f,
+	0.258473f,
+	-0.276284f,
+	0.866929f,
+	0.414851f,
+	-0.316808f,
+	0.857367f,
+	0.405653f,
+	-0.333206f,
+	0.853137f,
+	0.401412f,
+	-0.396081f,
+	0.828088f,
+	0.396725f,
+	-0.485909f,
+	0.809843f,
+	0.328705f,
+	-0.463328f,
+	0.813789f,
+	0.350819f,
+	-0.520203f,
+	0.774122f,
+	0.360725f,
+	-0.581754f,
+	0.763678f,
+	0.279925f,
+	-0.55781f,
+	0.791203f,
+	0.250691f,
+	-0.576356f,
+	0.800103f,
+	0.166282f,
+	-0.522214f,
+	0.839566f,
+	0.149738f,
+	-0.327667f,
+	0.934488f,
+	0.139166f,
+	-0.239893f,
+	0.965369f,
+	0.102537f,
+	-0.178401f,
+	0.973537f,
+	0.142826f,
+	-0.0446164f,
+	0.980327f,
+	0.192274f,
+	-0.152707f,
+	0.98769f,
+	0.0338934f,
+	-0.061376f,
+	0.996098f,
+	-0.0634113f,
+	-0.00816896f,
+	0.988579f,
+	-0.150483f,
+	0.0167009f,
+	0.992551f,
+	-0.120678f,
+	0.148875f,
+	0.988771f,
+	-0.0129578f,
+	0.0273451f,
+	0.999626f,
+	0.000950796f,
+	-0.109359f,
+	0.99398f,
+	0.00672756f,
+	-0.162948f,
+	0.982686f,
+	-0.0881845f,
+	-0.242271f,
+	0.966262f,
+	-0.0874275f,
+	-0.357996f,
+	0.933723f,
+	0.000140943f,
+	-0.377863f,
+	0.925289f,
+	0.0325572f,
+	-0.389424f,
+	0.920391f,
+	0.0350616f,
+	-0.408888f,
+	0.910343f,
+	0.0639282f,
+	-0.371945f,
+	0.928232f,
+	0.00649489f,
+	-0.230632f,
+	0.97289f,
+	0.0171594f,
+	-0.159091f,
+	0.987197f,
+	-0.0114848f,
+	-0.122759f,
+	0.984183f,
+	-0.127724f,
+	-0.175251f,
+	0.974473f,
+	-0.14032f,
+	-0.35571f,
+	0.933079f,
+	-0.0532364f,
+	-0.501387f,
+	0.863164f,
+	0.0596562f,
+	-0.575441f,
+	0.816492f,
+	-0.0470046f,
+	-0.501056f,
+	0.856673f,
+	-0.122698f,
+	-0.414992f,
+	0.888139f,
+	-0.19746f,
+	-0.309585f,
+	0.914677f,
+	-0.259854f,
+	-0.0986663f,
+	0.965073f,
+	-0.242693f,
+	-0.0576728f,
+	0.965088f,
+	-0.255499f,
+	-0.0928316f,
+	0.963296f,
+	-0.251879f,
+	-0.0710107f,
+	0.944633f,
+	-0.320352f,
+	0.0799711f,
+	0.918771f,
+	-0.386606f,
+	0.0834923f,
+	0.89273f,
+	-0.442789f,
+	0.0521243f,
+	0.897343f,
+	-0.438246f,
+	0.251171f,
+	0.890827f,
+	-0.378604f,
+	0.176541f,
+	0.892631f,
+	-0.414781f,
+	0.102505f,
+	0.91423f,
+	-0.392015f,
+	0.148543f,
+	0.910792f,
+	-0.385219f,
+	0.204336f,
+	0.92739f,
+	-0.313361f,
+	0.00672261f,
+	0.969577f,
+	-0.244696f,
+	-0.0203828f,
+	0.994006f,
+	-0.10741f,
+	0.0984818f,
+	0.994155f,
+	-0.0442492f,
+	0.0884297f,
+	0.979853f,
+	-0.179077f,
+	0.079756f,
+	0.934869f,
+	-0.345919f,
+	-0.0373135f,
+	0.916973f,
+	-0.3972f,
+	-0.13475f,
+	0.922044f,
+	-0.362873f,
+	-0.248554f,
+	0.90561f,
+	-0.343645f,
+	-0.298871f,
+	0.900649f,
+	-0.315447f,
+	-0.245556f,
+	0.942684f,
+	-0.225941f,
+	-0.29156f,
+	0.92569f,
+	-0.241018f,
+	-0.210251f,
+	0.966564f,
+	-0.146796f,
+	-0.258034f,
+	0.965595f,
+	0.0323199f,
+	-0.368176f,
+	0.902709f,
+	0.22263f,
+	-0.350064f,
+	0.851117f,
+	0.391223f,
+	-0.273287f,
+	0.858969f,
+	0.432996f,
+	-0.285306f,
+	0.881397f,
+	0.376483f,
+	-0.391023f,
+	0.856564f,
+	0.336748f,
+	-0.346592f,
+	0.838969f,
+	0.419529f,
+	-0.422742f,
+	0.829366f,
+	0.365295f,
+	-0.513303f,
+	0.775065f,
+	0.368504f,
+	-0.526999f,
+	0.742246f,
+	0.413935f,
+	-0.485934f,
+	0.782442f,
+	0.389426f,
+	-0.494091f,
+	0.808005f,
+	0.32094f,
+	-0.527377f,
+	0.820007f,
+	0.222402f,
+	-0.463863f,
+	0.878834f,
+	0.111725f,
+	-0.310302f,
+	0.94881f,
+	0.0589178f,
+	-0.228025f,
+	0.964645f,
+	0.132153f,
+	-0.25901f,
+	0.96255f,
+	0.080067f,
+	-0.0424596f,
+	0.997867f,
+	0.0495831f,
+	-0.00646979f,
+	0.998786f,
+	0.048831f,
+	0.0235108f,
+	0.999153f,
+	0.033786f,
+	0.0350773f,
+	0.999112f,
+	0.0233587f,
+	-0.06489f,
+	0.99782f,
+	0.0120079f,
+	0.0653571f,
+	0.99589f,
+	0.0626978f,
+	0.0437681f,
+	0.989758f,
+	0.13588f,
+	-0.0612591f,
+	0.992124f,
+	0.109253f,
+	-0.0700659f,
+	0.993846f,
+	0.085792f,
+	-0.245254f,
+	0.968292f,
+	0.0475526f,
+	-0.425333f,
+	0.903383f,
+	0.0546907f,
+	-0.406557f,
+	0.90921f,
+	0.0897132f,
+	-0.40303f,
+	0.911526f,
+	0.0817765f,
+	-0.380881f,
+	0.92142f,
+	0.0769048f,
+	-0.320213f,
+	0.947262f,
+	0.0126033f,
+	-0.2583f,
+	0.964583f,
+	-0.0534921f,
+	-0.102892f,
+	0.993091f,
+	-0.0564197f,
+	-0.0482689f,
+	0.996133f,
+	-0.0734163f,
+	-0.214829f,
+	0.976629f,
+	0.00662477f,
+	-0.431775f,
+	0.896672f,
+	0.0977224f,
+	-0.451215f,
+	0.886255f,
+	0.104672f,
+	-0.522087f,
+	0.848838f,
+	-0.0830587f,
+	-0.458286f,
+	0.880944f,
+	-0.117949f,
+	-0.338524f,
+	0.917937f,
+	-0.206865f,
+	-0.285281f,
+	0.916752f,
+	-0.279607f,
+	-0.142352f,
+	0.962006f,
+	-0.232982f,
+	-0.0943041f,
+	0.983891f,
+	-0.151875f,
+	-0.0753867f,
+	0.988192f,
+	-0.133394f,
+	0.0592214f,
+	0.975378f,
+	-0.212437f,
+	0.135178f,
+	0.93923f,
+	-0.315553f,
+	0.146098f,
+	0.928461f,
+	-0.34149f,
+	0.0154593f,
+	0.901088f,
+	-0.433361f,
+	0.163565f,
+	0.906515f,
+	-0.389201f,
+	0.204593f,
+	0.933049f,
+	-0.295907f,
+	0.124274f,
+	0.938076f,
+	-0.323371f,
+	0.137407f,
+	0.92485f,
+	-0.354642f,
+	0.063168f,
+	0.960879f,
+	-0.269671f,
+	-0.0720239f,
+	0.98835f,
+	-0.134077f,
+	-0.0757271f,
+	0.981006f,
+	-0.178587f,
+	0.0897227f,
+	0.968994f,
+	-0.23022f,
+	0.219073f,
+	0.948381f,
+	-0.229303f,
+	0.192275f,
+	0.938149f,
+	-0.287936f,
+	-0.0492263f,
+	0.973953f,
+	-0.221343f,
+	-0.181885f,
+	0.971294f,
+	-0.153316f,
+	-0.242476f,
+	0.960686f,
+	-0.135229f,
+	-0.363624f,
+	0.917475f,
+	-0.161301f,
+	-0.330978f,
+	0.935565f,
+	-0.12317f,
+	-0.30439f,
+	0.949195f,
+	-0.0798413f,
+	-0.362853f,
+	0.931339f,
+	-0.0307322f,
+	-0.401675f,
+	0.903644f,
+	0.148607f,
+	-0.425736f,
+	0.872787f,
+	0.238731f,
+	-0.458216f,
+	0.866256f,
+	0.199096f,
+	-0.325646f,
+	0.913769f,
+	0.242862f,
+	-0.214745f,
+	0.922085f,
+	0.321938f,
+	-0.398463f,
+	0.884492f,
+	0.242694f,
+	-0.475038f,
+	0.830832f,
+	0.289927f,
+	-0.448294f,
+	0.764081f,
+	0.463909f,
+	-0.497042f,
+	0.7065f,
+	0.503792f,
+	-0.489906f,
+	0.735868f,
+	0.467431f,
+	-0.460921f,
+	0.76339f,
+	0.452535f,
+	-0.40897f,
+	0.781052f,
+	0.471913f,
+	-0.371818f,
+	0.839399f,
+	0.396435f,
+	-0.326758f,
+	0.904742f,
+	0.27326f,
+	-0.383198f,
+	0.91056f,
+	0.155045f,
+	-0.284609f,
+	0.924825f,
+	0.252383f,
+	-0.0749114f,
+	0.976737f,
+	0.200932f,
+	0.00799324f,
+	0.997093f,
+	0.0757729f,
+	-0.0700844f,
+	0.990942f,
+	0.114551f,
+	-0.0596966f,
+	0.983848f,
+	0.168758f,
+	0.00586433f,
+	0.977052f,
+	0.212922f,
+	-0.0605914f,
+	0.978841f,
+	0.195443f,
+	-0.0438257f,
+	0.995801f,
+	0.0803703f,
+	-0.0570689f,
+	0.993344f,
+	0.100052f,
+	-0.0606116f,
+	0.987839f,
+	0.143177f,
+	-0.0960986f,
+	0.983658f,
+	0.152253f,
+	-0.240218f,
+	0.956553f,
+	0.16523f,
+	-0.410215f,
+	0.902731f,
+	0.129617f,
+	-0.38596f,
+	0.917352f,
+	0.0974681f,
+	-0.348531f,
+	0.935694f,
+	0.0547901f,
+	-0.396424f,
+	0.918039f,
+	-0.00721866f,
+	-0.26358f,
+	0.961512f,
+	0.0775866f,
+	-0.177577f,
+	0.982975f,
+	0.0471779f,
+	-0.0921077f,
+	0.995708f,
+	0.00907831f,
+	-0.131805f,
+	0.991186f,
+	0.0133294f,
+	-0.348565f,
+	0.935587f,
+	0.0563885f,
+	-0.467549f,
+	0.880933f,
+	0.0731775f,
+	-0.372581f,
+	0.926945f,
+	0.0442312f,
+	-0.408929f,
+	0.911847f,
+	-0.0362219f,
+	-0.445009f,
+	0.893478f,
+	-0.0605312f,
+	-0.306432f,
+	0.951885f,
+	-0.00384437f,
+	-0.259351f,
+	0.965029f,
+	0.0381644f,
+	-0.265204f,
+	0.963994f,
+	-0.0195798f,
+	-0.114808f,
+	0.993343f,
+	0.00942441f,
+	-0.0279481f,
+	0.990324f,
+	-0.135929f,
+	0.103339f,
+	0.977655f,
+	-0.18306f,
+	0.218767f,
+	0.966894f,
+	-0.131368f,
+	0.207579f,
+	0.958824f,
+	-0.193824f,
+	0.136905f,
+	0.960239f,
+	-0.243308f,
+	0.117272f,
+	0.934734f,
+	-0.335438f,
+	0.133403f,
+	0.937193f,
+	-0.322294f,
+	0.140113f,
+	0.948531f,
+	-0.284001f,
+	0.0924439f,
+	0.975124f,
+	-0.201463f,
+	-0.0405443f,
+	0.993271f,
+	-0.108481f,
+	-0.0729426f,
+	0.987394f,
+	-0.140474f,
+	0.0307633f,
+	0.972795f,
+	-0.229615f,
+	0.200951f,
+	0.951021f,
+	-0.2349f,
+	0.206873f,
+	0.91785f,
+	-0.338755f,
+	0.0409109f,
+	0.957201f,
+	-0.286518f,
+	-0.211311f,
+	0.976629f,
+	-0.0392802f,
+	-0.256735f,
+	0.961768f,
+	0.0953371f,
+	-0.237528f,
+	0.960421f,
+	0.145504f,
+	-0.329105f,
+	0.937835f,
+	0.110248f,
+	-0.355083f,
+	0.930437f,
+	0.0905737f,
+	-0.33751f,
+	0.931415f,
+	0.13621f,
+	-0.400013f,
+	0.905919f,
+	0.138928f,
+	-0.505595f,
+	0.854442f,
+	0.119596f,
+	-0.452675f,
+	0.873473f,
+	0.179247f,
+	-0.360085f,
+	0.917004f,
+	0.17159f,
+	-0.404496f,
+	0.910531f,
+	0.0855373f,
+	-0.324231f,
+	0.903855f,
+	0.279141f,
+	-0.336075f,
+	0.852068f,
+	0.40129f,
+	-0.562491f,
+	0.75864f,
+	0.328737f,
+	-0.580482f,
+	0.703244f,
+	0.410473f,
+	-0.499356f,
+	0.747889f,
+	0.437385f,
+	-0.47057f,
+	0.77436f,
+	0.423001f,
+	-0.457721f,
+	0.780273f,
+	0.426221f,
+	-0.387043f,
+	0.830428f,
+	0.400733f,
+	-0.304454f,
+	0.882516f,
+	0.358431f,
+	-0.240482f,
+	0.915056f,
+	0.323791f,
+	-0.289179f,
+	0.919765f,
+	0.265345f,
+	-0.239541f,
+	0.954664f,
+	0.176742f,
+	-0.0468358f,
+	0.993768f,
+	0.10115f,
+	-0.0227943f,
+	0.987776f,
+	0.154204f,
+	-0.112093f,
+	0.964309f,
+	0.239881f,
+	-0.0599845f,
+	0.969963f,
+	0.235741f,
+	0.0387578f,
+	0.968143f,
+	0.24738f,
+	0.0187191f,
+	0.971458f,
+	0.236471f,
+	0.242021f,
+	0.896343f,
+	0.371478f,
+	0.0480335f,
+	0.972296f,
+	0.228765f,
+	-0.0779729f,
+	0.986176f,
+	0.146206f,
+	-0.0941394f,
+	0.982277f,
+	0.16208f,
+	-0.22083f,
+	0.962927f,
+	0.154936f,
+	-0.380194f,
+	0.918443f,
+	0.109152f,
+	-0.362825f,
+	0.928988f,
+	0.0730715f,
+	-0.322334f,
+	0.943799f,
+	0.0731113f,
+	-0.408658f,
+	0.905696f,
+	0.112752f,
+	-0.342623f,
+	0.91378f,
+	0.218209f,
+	-0.178962f,
+	0.947287f,
+	0.265744f,
+	-0.0963031f,
+	0.962264f,
+	0.254507f,
+	-0.129686f,
+	0.959928f,
+	0.248434f,
+	-0.25861f,
+	0.932715f,
+	0.251325f,
+	-0.400538f,
+	0.911394f,
+	0.0944958f,
+	-0.371118f,
+	0.928542f,
+	0.00899351f,
+	-0.395096f,
+	0.916517f,
+	0.0624194f,
+	-0.492959f,
+	0.864551f,
+	0.097688f,
+	-0.425957f,
+	0.892844f,
+	0.146255f,
+	-0.256791f,
+	0.9425f,
+	0.213898f,
+	-0.177422f,
+	0.976398f,
+	0.123157f,
+	0.0269208f,
+	0.996881f,
+	0.0741829f,
+	0.164645f,
+	0.980831f,
+	-0.104223f,
+	0.0973784f,
+	0.963273f,
+	-0.250244f,
+	0.114359f,
+	0.965463f,
+	-0.234102f,
+	0.250084f,
+	0.96398f,
+	-0.0905583f,
+	0.183861f,
+	0.973241f,
+	-0.137829f,
+	0.203921f,
+	0.957737f,
+	-0.202868f,
+	0.170155f,
+	0.95208f,
+	-0.254149f,
+	0.0373443f,
+	0.963666f,
+	-0.264487f,
+	-0.0311132f,
+	0.98854f,
+	-0.147717f,
+	-0.0500681f,
+	0.990616f,
+	-0.127173f,
+	0.0774781f,
+	0.980584f,
+	-0.180143f,
+	0.0416659f,
+	0.952342f,
+	-0.302174f,
+	0.183971f,
+	0.945491f,
+	-0.268702f,
+	0.234504f,
+	0.932825f,
+	-0.27358f,
+	-0.0611848f,
+	0.988685f,
+	-0.13696f,
+	-0.37387f,
+	0.925543f,
+	-0.059925f,
+	-0.361069f,
+	0.932447f,
+	-0.0130774f,
+	-0.247932f,
+	0.961796f,
+	0.1161f,
+	-0.321909f,
+	0.940217f,
+	0.111206f,
+	-0.373794f,
+	0.915694f,
+	0.147587f,
+	-0.370927f,
+	0.915202f,
+	0.157537f,
+	-0.367344f,
+	0.908177f,
+	0.20068f,
+	-0.445687f,
+	0.879826f,
+	0.165134f,
+	-0.480845f,
+	0.872838f,
+	0.0833169f,
+	-0.396228f,
+	0.900984f,
+	0.176722f,
+	-0.39533f,
+	0.870559f,
+	0.292987f,
+	-0.514705f,
+	0.791717f,
+	0.329034f,
+	-0.426478f,
+	0.754312f,
+	0.49913f,
+	-0.476928f,
+	0.731476f,
+	0.487321f,
+	-0.555203f,
+	0.748777f,
+	0.362053f,
+	-0.513793f,
+	0.811828f,
+	0.277402f,
+	-0.498737f,
+	0.823176f,
+	0.271372f,
+	-0.459197f,
+	0.851815f,
+	0.252089f,
+	-0.364638f,
+	0.907849f,
+	0.207f,
+	-0.280535f,
+	0.937686f,
+	0.205051f,
+	-0.204645f,
+	0.959273f,
+	0.194721f,
+	-0.188424f,
+	0.978285f,
+	0.0863425f,
+	-0.16576f,
+	0.97773f,
+	-0.128717f,
+	-0.0413953f,
+	0.984504f,
+	-0.170405f,
+	-0.119175f,
+	0.989154f,
+	-0.0858603f,
+	-0.164393f,
+	0.986215f,
+	0.018821f,
+	-0.0876541f,
+	0.994439f,
+	0.0583851f,
+	-0.00781607f,
+	0.987179f,
+	0.159428f,
+	-0.00608226f,
+	0.980142f,
+	0.198203f,
+	0.294056f,
+	0.919888f,
+	0.259494f,
+	0.176099f,
+	0.946212f,
+	0.271426f,
+	-0.0256669f,
+	0.973237f,
+	0.228366f,
+	-0.0934761f,
+	0.978631f,
+	0.183149f,
+	-0.211202f,
+	0.968374f,
+	0.132837f,
+	-0.345036f,
+	0.933287f,
+	0.0996237f,
+	-0.346043f,
+	0.935088f,
+	0.0765773f,
+	-0.381385f,
+	0.918419f,
+	0.105127f,
+	-0.476923f,
+	0.857096f,
+	0.19476f,
+	-0.397907f,
+	0.88874f,
+	0.227622f,
+	-0.175271f,
+	0.936954f,
+	0.30232f,
+	-0.040477f,
+	0.944541f,
+	0.325889f,
+	-0.142418f,
+	0.942444f,
+	0.302518f,
+	-0.246569f,
+	0.91514f,
+	0.318938f,
+	-0.255277f,
+	0.933873f,
+	0.25043f,
+	-0.348488f,
+	0.92941f,
+	0.121466f,
+	-0.472178f,
+	0.874219f,
+	0.113089f,
+	-0.490306f,
+	0.858256f,
+	0.151645f,
+	-0.38804f,
+	0.914553f,
+	0.114097f,
+	-0.196584f,
+	0.979051f,
+	0.0530513f,
+	-0.0793551f,
+	0.996572f,
+	-0.0234008f,
+	0.0406197f,
+	0.994776f,
+	-0.0936505f,
+	0.24653f,
+	0.966821f,
+	-0.0669378f,
+	0.269235f,
+	0.959692f,
+	-0.0806517f,
+	0.0569112f,
+	0.963296f,
+	-0.26234f,
+	0.131503f,
+	0.973945f,
+	-0.184764f,
+	0.24729f,
+	0.957434f,
+	-0.148892f,
+	0.248779f,
+	0.951221f,
+	-0.18245f,
+	0.18718f,
+	0.966303f,
+	-0.176696f,
+	0.00607471f,
+	0.977895f,
+	-0.20901f,
+	-0.0210706f,
+	0.975074f,
+	-0.220878f,
+	0.00501251f,
+	0.949574f,
+	-0.313502f,
+	0.0771251f,
+	0.945518f,
+	-0.316304f,
+	0.130553f,
+	0.948445f,
+	-0.288805f,
+	0.175519f,
+	0.929764f,
+	-0.323623f,
+	0.111769f,
+	0.971665f,
+	-0.208266f,
+	-0.210844f,
+	0.971563f,
+	-0.107753f,
+	-0.345299f,
+	0.9344f,
+	-0.087551f,
+	-0.367127f,
+	0.918607f,
+	-0.146212f,
+	-0.340753f,
+	0.929779f,
+	-0.139279f,
+	-0.358585f,
+	0.929839f,
+	-0.0825605f,
+	-0.393886f,
+	0.919008f,
+	-0.0166963f,
+	-0.401193f,
+	0.915983f,
+	0.00451588f,
+	-0.406108f,
+	0.91192f,
+	0.0589777f,
+	-0.45609f,
+	0.887954f,
+	0.0593294f,
+	-0.481921f,
+	0.86351f,
+	0.148669f,
+	-0.533578f,
+	0.80576f,
+	0.256994f,
+	-0.480795f,
+	0.753832f,
+	0.447854f,
+	-0.502576f,
+	0.721353f,
+	0.476516f,
+	-0.457582f,
+	0.746697f,
+	0.482766f,
+	-0.419108f,
+	0.791496f,
+	0.44484f,
+	-0.465376f,
+	0.834036f,
+	0.296325f,
+	-0.468919f,
+	0.860429f,
+	0.199442f,
+	-0.486627f,
+	0.858618f,
+	0.161151f,
+	-0.430227f,
+	0.89524f,
+	0.115972f,
+	-0.34028f,
+	0.937953f,
+	0.066739f,
+	-0.311486f,
+	0.949765f,
+	0.0303886f,
+	-0.166884f,
+	0.985403f,
+	0.0336267f,
+	0.0381647f,
+	0.996782f,
+	-0.0704869f,
+	0.0486826f,
+	0.951753f,
+	-0.302979f,
+	-0.0940893f,
+	0.932244f,
+	-0.349383f,
+	-0.229015f,
+	0.944857f,
+	-0.234089f,
+	-0.214421f,
+	0.956596f,
+	-0.19735f,
+	-0.17466f,
+	0.962579f,
+	-0.207209f,
+	-0.106663f,
+	0.986513f,
+	-0.124157f,
+	-0.0523564f,
+	0.993983f,
+	-0.0962102f,
+	0.1751f,
+	0.970986f,
+	0.162867f,
+	0.126838f,
+	0.957099f,
+	0.260524f,
+	-0.0248407f,
+	0.948904f,
+	0.314587f,
+	-0.0169284f,
+	0.94527f,
+	0.325849f,
+	-0.126002f,
+	0.963121f,
+	0.237743f,
+	-0.322368f,
+	0.933961f,
+	0.154262f,
+	-0.357267f,
+	0.920847f,
+	0.156206f,
+	-0.40825f,
+	0.900639f,
+	0.148934f,
+	-0.500408f,
+	0.86145f,
+	0.0865774f,
+	-0.437173f,
+	0.895731f,
+	0.0809122f,
+	-0.234862f,
+	0.957423f,
+	0.167871f,
+	-0.122112f,
+	0.971133f,
+	0.204913f,
+	-0.146988f,
+	0.949325f,
+	0.277805f,
+	-0.214866f,
+	0.947227f,
+	0.237893f,
+	-0.166781f,
+	0.968529f,
+	0.184757f,
+	-0.279132f,
+	0.953637f,
+	0.112522f,
+	-0.438908f,
+	0.892826f,
+	0.101101f,
+	-0.476448f,
+	0.878957f,
+	0.0207741f,
+	-0.317496f,
+	0.946313f,
+	-0.0607282f,
+	-0.175675f,
+	0.968847f,
+	-0.174568f,
+	0.00443594f,
+	0.981128f,
+	-0.193308f,
+	0.0639918f,
+	0.955901f,
+	-0.286634f,
+	0.156615f,
+	0.959233f,
+	-0.235253f,
+	0.281138f,
+	0.953388f,
+	-0.109604f,
+	0.173642f,
+	0.975105f,
+	-0.137905f,
+	0.125725f,
+	0.970112f,
+	-0.207546f,
+	0.23259f,
+	0.936622f,
+	-0.261996f,
+	0.234534f,
+	0.938208f,
+	-0.25448f,
+	0.160485f,
+	0.952598f,
+	-0.258459f,
+	0.0824642f,
+	0.968528f,
+	-0.234849f,
+	0.0634583f,
+	0.946763f,
+	-0.315614f,
+	0.0567562f,
+	0.917557f,
+	-0.393532f,
+	0.0240187f,
+	0.918352f,
+	-0.395035f,
+	0.0995244f,
+	0.946786f,
+	-0.30609f,
+	0.0782245f,
+	0.971194f,
+	-0.225085f,
+	0.0104903f,
+	0.995647f,
+	-0.0926114f,
+	-0.185802f,
+	0.976721f,
+	-0.107212f,
+	-0.328502f,
+	0.923412f,
+	-0.198486f,
+	-0.311331f,
+	0.92975f,
+	-0.196566f,
+	-0.349149f,
+	0.904891f,
+	-0.24345f,
+	-0.388436f,
+	0.90322f,
+	-0.182515f,
+	-0.447323f,
+	0.88531f,
+	-0.126995f,
+	-0.452109f,
+	0.890067f,
+	-0.0581177f,
+	-0.409043f,
+	0.912515f,
+	0.000312055f,
+	-0.489105f,
+	0.872225f,
+	-0.000401423f,
+	-0.602394f,
+	0.789815f,
+	0.115381f,
+	-0.644891f,
+	0.727938f,
+	0.232857f,
+	-0.581256f,
+	0.729671f,
+	0.360168f,
+	-0.503025f,
+	0.763549f,
+	0.404917f,
+	-0.449741f,
+	0.833702f,
+	0.320428f,
+	-0.320295f,
+	0.891402f,
+	0.320645f,
+	-0.365897f,
+	0.908793f,
+	0.200535f,
+	-0.418513f,
+	0.900509f,
+	0.118029f,
+	-0.464312f,
+	0.883882f,
+	0.0562756f,
+	-0.399182f,
+	0.916811f,
+	0.0105308f,
+	-0.291715f,
+	0.956056f,
+	-0.0293054f,
+	-0.237447f,
+	0.965751f,
+	-0.104617f,
+	-0.100041f,
+	0.966568f,
+	-0.236091f,
+	0.160871f,
+	0.934989f,
+	-0.316096f,
+	0.093049f,
+	0.931221f,
+	-0.352375f,
+	-0.15859f,
+	0.964926f,
+	-0.209204f,
+	-0.273524f,
+	0.944194f,
+	-0.183526f,
+	-0.190425f,
+	0.948278f,
+	-0.253984f,
+	-0.130985f,
+	0.95529f,
+	-0.265074f,
+	-0.109109f,
+	0.943759f,
+	-0.312112f,
+	-0.0442587f,
+	0.936376f,
+	-0.348197f,
+	0.0244075f,
+	0.991066f,
+	0.131121f,
+	-0.0145509f,
+	0.975134f,
+	0.221137f,
+	-0.0404534f,
+	0.947565f,
+	0.316994f,
+	-0.0554847f,
+	0.953641f,
+	0.295787f,
+	-0.0378486f,
+	0.926136f,
+	0.375287f,
+	-0.276884f,
+	0.909741f,
+	0.309364f,
+	-0.35531f,
+	0.878584f,
+	0.319132f,
+	-0.28855f,
+	0.905318f,
+	0.311668f,
+	-0.418654f,
+	0.900829f,
+	0.115051f,
+	-0.470621f,
+	0.881923f,
+	0.0269622f,
+	-0.302456f,
+	0.950707f,
+	0.0683814f,
+	-0.155931f,
+	0.981097f,
+	0.114601f,
+	-0.172528f,
+	0.971746f,
+	0.161072f,
+	-0.175279f,
+	0.972437f,
+	0.153763f,
+	-0.0948884f,
+	0.989506f,
+	0.108971f,
+	-0.271832f,
+	0.96203f,
+	0.0246161f,
+	-0.434113f,
+	0.899816f,
+	0.0433328f,
+	-0.41192f,
+	0.910729f,
+	-0.0299284f,
+	-0.184465f,
+	0.976107f,
+	-0.114836f,
+	-0.0519711f,
+	0.950434f,
+	-0.306552f,
+	0.0510061f,
+	0.914254f,
+	-0.401918f,
+	0.0714878f,
+	0.915457f,
+	-0.396015f,
+	0.0823148f,
+	0.944294f,
+	-0.318643f,
+	0.154376f,
+	0.938672f,
+	-0.308322f,
+	0.218285f,
+	0.948145f,
+	-0.231024f,
+	0.158935f,
+	0.938404f,
+	-0.306818f,
+	0.261223f,
+	0.9329f,
+	-0.247912f,
+	0.285998f,
+	0.932056f,
+	-0.222434f,
+	0.190198f,
+	0.913869f,
+	-0.358703f,
+	0.0636773f,
+	0.892218f,
+	-0.447094f,
+	0.10205f,
+	0.889697f,
+	-0.445f,
+	0.100031f,
+	0.900986f,
+	-0.422159f,
+	0.0104969f,
+	0.905423f,
+	-0.424381f,
+	-0.0688464f,
+	0.910262f,
+	-0.408268f,
+	-0.0482237f,
+	0.974352f,
+	-0.219802f,
+	-0.0083558f,
+	0.994225f,
+	-0.106992f,
+	-0.112134f,
+	0.979056f,
+	-0.169927f,
+	-0.229912f,
+	0.945374f,
+	-0.231102f,
+	-0.280533f,
+	0.899591f,
+	-0.334719f,
+	-0.346884f,
+	0.867971f,
+	-0.355384f,
+	-0.459064f,
+	0.843199f,
+	-0.279779f,
+	-0.497889f,
+	0.848119f,
+	-0.181111f,
+	-0.501207f,
+	0.860371f,
+	-0.0924901f,
+	-0.458162f,
+	0.888868f,
+	-0.00122281f,
+	-0.514613f,
+	0.855463f,
+	0.0579275f,
+	-0.647763f,
+	0.760835f,
+	0.0391491f,
+	-0.704753f,
+	0.709026f,
+	0.0246046f,
+	-0.656653f,
+	0.750377f,
+	0.0757771f,
+	-0.504188f,
+	0.854115f,
+	0.127601f,
+	-0.41033f,
+	0.905141f,
+	0.111126f,
+	-0.337511f,
+	0.936543f,
+	0.0947305f,
+	-0.307169f,
+	0.946112f,
+	0.10256f,
+	-0.367429f,
+	0.928128f,
+	0.0597776f,
+	-0.393986f,
+	0.91872f,
+	-0.0269814f,
+	-0.373766f,
+	0.918684f,
+	-0.127743f,
+	-0.26114f,
+	0.960116f,
+	-0.0999132f,
+	-0.103927f,
+	0.984722f,
+	-0.139723f,
+	0.0511518f,
+	0.955672f,
+	-0.289956f,
+	0.187205f,
+	0.928701f,
+	-0.320109f,
+	-0.0295799f,
+	0.970029f,
+	-0.241182f,
+	-0.314429f,
+	0.940081f,
+	-0.13184f,
+	-0.185337f,
+	0.978913f,
+	-0.0859053f,
+	-0.104364f,
+	0.967564f,
+	-0.230061f,
+	-0.0895833f,
+	0.932754f,
+	-0.349206f,
+	-0.054587f,
+	0.891296f,
+	-0.450124f,
+	0.0297567f,
+	0.885691f,
+	-0.463321f,
+	0.100841f,
+	0.951386f,
+	0.291024f,
+	-0.0719364f,
+	0.970866f,
+	0.22857f,
+	-0.0950354f,
+	0.957535f,
+	0.272204f,
+	-0.063148f,
+	0.9475f,
+	0.313457f,
+	-0.147905f,
+	0.922206f,
+	0.357295f,
+	-0.255052f,
+	0.862392f,
+	0.437296f,
+	-0.348295f,
+	0.831026f,
+	0.433689f,
+	-0.228735f,
+	0.861593f,
+	0.453141f,
+	-0.189137f,
+	0.904176f,
+	0.383004f,
+	-0.40614f,
+	0.912877f,
+	0.041313f,
+	-0.322035f,
+	0.946605f,
+	-0.0152552f,
+	-0.213289f,
+	0.976152f,
+	0.0404333f,
+	-0.216957f,
+	0.96919f,
+	0.116619f,
+	-0.143471f,
+	0.982181f,
+	0.121395f,
+	-0.0619809f,
+	0.995307f,
+	0.0743149f,
+	-0.20303f,
+	0.975599f,
+	0.0835793f,
+	-0.415979f,
+	0.909172f,
+	0.0191678f,
+	-0.336954f,
+	0.94062f,
+	-0.0411873f,
+	-0.0679584f,
+	0.981162f,
+	-0.180839f,
+	0.116786f,
+	0.956914f,
+	-0.265849f,
+	0.119526f,
+	0.96094f,
+	-0.249616f,
+	-0.00488697f,
+	0.95735f,
+	-0.288889f,
+	0.0539017f,
+	0.947486f,
+	-0.315223f,
+	0.147321f,
+	0.922615f,
+	-0.35648f,
+	0.255572f,
+	0.910786f,
+	-0.324272f,
+	0.156463f,
+	0.885962f,
+	-0.436566f,
+	0.1301f,
+	0.92297f,
+	-0.362215f,
+	0.25276f,
+	0.923086f,
+	-0.289871f,
+	0.383737f,
+	0.889757f,
+	-0.247141f,
+	0.211205f,
+	0.883014f,
+	-0.419141f,
+	0.0342331f,
+	0.879599f,
+	-0.474482f,
+	0.00319575f,
+	0.938694f,
+	-0.344735f,
+	0.0177214f,
+	0.953292f,
+	-0.301529f,
+	-0.111253f,
+	0.93857f,
+	-0.326663f,
+	-0.240335f,
+	0.933381f,
+	-0.26653f,
+	-0.0538188f,
+	0.987001f,
+	-0.151433f,
+	-0.0274864f,
+	0.979377f,
+	-0.200162f,
+	-0.187631f,
+	0.946384f,
+	-0.262966f,
+	-0.206926f,
+	0.955659f,
+	-0.209519f,
+	-0.334901f,
+	0.924406f,
+	-0.182523f,
+	-0.500035f,
+	0.842333f,
+	-0.201099f,
+	-0.536058f,
+	0.812568f,
+	-0.228857f,
+	-0.57838f,
+	0.789021f,
+	-0.207176f,
+	-0.551453f,
+	0.831854f,
+	-0.0625953f,
+	-0.537806f,
+	0.840551f,
+	0.0651045f,
+	-0.581123f,
+	0.812541f,
+	0.0455343f,
+	-0.677773f,
+	0.725811f,
+	-0.117567f,
+	-0.674512f,
+	0.726391f,
+	-0.131871f,
+	-0.561194f,
+	0.823313f,
+	-0.0849523f,
+	-0.426155f,
+	0.904036f,
+	-0.0333265f,
+	-0.350057f,
+	0.935877f,
+	-0.0399208f,
+	-0.324764f,
+	0.94579f,
+	-0.0029281f,
+	-0.334572f,
+	0.942069f,
+	0.0238272f,
+	-0.264187f,
+	0.96401f,
+	-0.0298196f,
+	-0.331302f,
+	0.926674f,
+	-0.177522f,
+	-0.297768f,
+	0.937944f,
+	-0.177749f,
+	-0.0551409f,
+	0.983889f,
+	-0.170067f,
+	0.144484f,
+	0.972505f,
+	-0.182644f,
+	0.119335f,
+	0.96645f,
+	-0.227451f,
+	-0.0885992f,
+	0.982619f,
+	-0.163126f,
+	-0.33707f,
+	0.92576f,
+	-0.171324f,
+	-0.162854f,
+	0.966557f,
+	-0.198108f,
+	0.0162126f,
+	0.974218f,
+	-0.225026f,
+	0.138436f,
+	0.947057f,
+	-0.289688f,
+	0.0835536f,
+	0.876982f,
+	-0.473204f,
+	-0.010237f,
+	0.848096f,
+	-0.529743f,
+	0.136921f,
+	0.906371f,
+	0.399681f,
+	0.0140824f,
+	0.922185f,
+	0.386492f,
+	-0.160268f,
+	0.929321f,
+	0.33268f,
+	-0.112451f,
+	0.900092f,
+	0.420938f,
+	-0.203296f,
+	0.876433f,
+	0.436504f,
+	-0.322996f,
+	0.829667f,
+	0.455332f,
+	-0.340765f,
+	0.827757f,
+	0.445755f,
+	-0.257344f,
+	0.84669f,
+	0.465715f,
+	0.00366351f,
+	0.865541f,
+	0.500825f,
+	-0.0425812f,
+	0.956742f,
+	0.287804f,
+	-0.322344f,
+	0.945159f,
+	-0.052618f,
+	-0.280797f,
+	0.958795f,
+	-0.0431994f,
+	-0.262333f,
+	0.964629f,
+	-0.0259446f,
+	-0.0891831f,
+	0.995449f,
+	-0.0335709f,
+	-0.0801038f,
+	0.992742f,
+	-0.0896982f,
+	-0.224206f,
+	0.974484f,
+	0.0105758f,
+	-0.364477f,
+	0.9309f,
+	-0.0241328f,
+	-0.198506f,
+	0.970273f,
+	-0.138443f,
+	0.0492304f,
+	0.955815f,
+	-0.289816f,
+	0.0465241f,
+	0.961334f,
+	-0.271428f,
+	0.0147498f,
+	0.993644f,
+	-0.111598f,
+	0.136409f,
+	0.989222f,
+	-0.0532271f,
+	0.148553f,
+	0.957532f,
+	-0.247113f,
+	0.203722f,
+	0.927854f,
+	-0.312384f,
+	0.268253f,
+	0.883803f,
+	-0.383317f,
+	0.18614f,
+	0.887058f,
+	-0.422469f,
+	0.10218f,
+	0.907566f,
+	-0.407286f,
+	0.200645f,
+	0.878358f,
+	-0.433854f,
+	0.320433f,
+	0.870875f,
+	-0.372692f,
+	0.278243f,
+	0.911383f,
+	-0.303252f,
+	-0.0169368f,
+	0.97379f,
+	-0.226818f,
+	-0.116502f,
+	0.978925f,
+	-0.16773f,
+	0.0246686f,
+	0.985931f,
+	-0.165321f,
+	-0.099417f,
+	0.977857f,
+	-0.184152f,
+	-0.275352f,
+	0.945128f,
+	-0.175824f,
+	-0.0928967f,
+	0.974055f,
+	-0.206368f,
+	0.0664566f,
+	0.97817f,
+	-0.196893f,
+	-0.180659f,
+	0.959555f,
+	-0.21591f,
+	-0.356529f,
+	0.924348f,
+	-0.135896f,
+	-0.392702f,
+	0.919607f,
+	0.0104344f,
+	-0.427591f,
+	0.903919f,
+	-0.00980201f,
+	-0.491673f,
+	0.851131f,
+	-0.183941f,
+	-0.597871f,
+	0.779934f,
+	-0.185076f,
+	-0.630214f,
+	0.771159f,
+	-0.0902474f,
+	-0.603795f,
+	0.796392f,
+	-0.0345128f,
+	-0.532942f,
+	0.846043f,
+	0.013577f,
+	-0.560658f,
+	0.826581f,
+	-0.049261f,
+	-0.693149f,
+	0.692482f,
+	-0.200033f,
+	-0.591049f,
+	0.792583f,
+	-0.14991f,
+	-0.423413f,
+	0.894971f,
+	-0.14053f,
+	-0.360923f,
+	0.922234f,
+	-0.138633f,
+	-0.376728f,
+	0.924323f,
+	-0.0608465f,
+	-0.330964f,
+	0.94352f,
+	-0.0152562f,
+	-0.205049f,
+	0.976512f,
+	-0.0661789f,
+	-0.221147f,
+	0.966952f,
+	-0.126878f,
+	-0.282753f,
+	0.933366f,
+	-0.221083f,
+	-0.0599842f,
+	0.959615f,
+	-0.274846f,
+	0.119046f,
+	0.947951f,
+	-0.295324f,
+	0.164559f,
+	0.948383f,
+	-0.27109f,
+	-0.0951076f,
+	0.948417f,
+	-0.302424f,
+	-0.271887f,
+	0.913351f,
+	-0.303098f,
+	-0.128933f,
+	0.917201f,
+	-0.376985f,
+	0.0280066f,
+	0.909443f,
+	-0.414885f,
+	0.150608f,
+	0.898143f,
+	-0.413106f,
+	0.212115f,
+	0.88838f,
+	-0.407172f,
+	0.0467869f,
+	0.87371f,
+	-0.484191f,
+	0.135605f,
+	0.903203f,
+	0.407228f,
+	-0.01172f,
+	0.896648f,
+	0.44259f,
+	-0.138887f,
+	0.847422f,
+	0.512432f,
+	-0.170991f,
+	0.843044f,
+	0.50994f,
+	-0.191878f,
+	0.839246f,
+	0.508772f,
+	-0.300268f,
+	0.838171f,
+	0.455311f,
+	-0.32966f,
+	0.831286f,
+	0.447535f,
+	-0.223175f,
+	0.877254f,
+	0.424992f,
+	-0.0256774f,
+	0.953915f,
+	0.298977f,
+	0.199545f,
+	0.913698f,
+	0.354031f,
+	-0.0319727f,
+	0.980881f,
+	0.191963f,
+	-0.258985f,
+	0.964126f,
+	-0.0582107f,
+	-0.212788f,
+	0.970943f,
+	-0.109502f,
+	-0.0721792f,
+	0.982085f,
+	-0.174064f,
+	-0.0849627f,
+	0.985898f,
+	-0.144175f,
+	-0.290021f,
+	0.949136f,
+	-0.122591f,
+	-0.248272f,
+	0.954348f,
+	-0.166075f,
+	-0.0507313f,
+	0.942327f,
+	-0.330828f,
+	0.0792104f,
+	0.910775f,
+	-0.405234f,
+	-0.0679775f,
+	0.927432f,
+	-0.367762f,
+	-0.0963141f,
+	0.945938f,
+	-0.309718f,
+	0.147422f,
+	0.952479f,
+	-0.266555f,
+	0.232988f,
+	0.930423f,
+	-0.282895f,
+	0.296671f,
+	0.921407f,
+	-0.250989f,
+	0.346023f,
+	0.880014f,
+	-0.325337f,
+	0.246011f,
+	0.893818f,
+	-0.374924f,
+	0.0779935f,
+	0.862828f,
+	-0.499444f,
+	0.218748f,
+	0.861753f,
+	-0.457746f,
+	0.236169f,
+	0.890523f,
+	-0.388836f,
+	0.122215f,
+	0.968128f,
+	-0.218613f,
+	-0.119249f,
+	0.983741f,
+	-0.134288f,
+	-0.0975043f,
+	0.983669f,
+	-0.151287f,
+	0.0551556f,
+	0.975975f,
+	-0.210786f,
+	-0.0858442f,
+	0.972611f,
+	-0.216008f,
+	-0.228301f,
+	0.939116f,
+	-0.256789f,
+	-0.0600278f,
+	0.94195f,
+	-0.330342f,
+	-0.00498162f,
+	0.954835f,
+	-0.297095f,
+	-0.236752f,
+	0.956732f,
+	-0.169151f,
+	-0.404481f,
+	0.905728f,
+	-0.126698f,
+	-0.442956f,
+	0.884106f,
+	-0.148815f,
+	-0.353117f,
+	0.929811f,
+	-0.103732f,
+	-0.367684f,
+	0.920274f,
+	-0.133808f,
+	-0.620195f,
+	0.758926f,
+	-0.19847f,
+	-0.650875f,
+	0.742352f,
+	-0.158981f,
+	-0.60395f,
+	0.783223f,
+	-0.147668f,
+	-0.562027f,
+	0.815077f,
+	-0.140626f,
+	-0.504739f,
+	0.855197f,
+	-0.117796f,
+	-0.629314f,
+	0.743816f,
+	-0.22517f,
+	-0.590837f,
+	0.750634f,
+	-0.295736f,
+	-0.432954f,
+	0.842346f,
+	-0.320942f,
+	-0.414184f,
+	0.8722f,
+	-0.260227f,
+	-0.438355f,
+	0.884876f,
+	-0.157606f,
+	-0.309198f,
+	0.940747f,
+	-0.13925f,
+	-0.155389f,
+	0.967122f,
+	-0.20132f,
+	-0.14424f,
+	0.961525f,
+	-0.233805f,
+	-0.235758f,
+	0.924f,
+	-0.301067f,
+	0.0151186f,
+	0.960375f,
+	-0.278299f,
+	0.144315f,
+	0.944571f,
+	-0.294888f,
+	0.112415f,
+	0.964242f,
+	-0.239999f,
+	-0.0426025f,
+	0.977992f,
+	-0.204249f,
+	-0.206795f,
+	0.910666f,
+	-0.357663f,
+	-0.0742651f,
+	0.885367f,
+	-0.458922f,
+	0.0946583f,
+	0.875247f,
+	-0.474324f,
+	0.121834f,
+	0.836586f,
+	-0.534117f,
+	0.198513f,
+	0.859849f,
+	-0.470374f,
+	0.17646f,
+	0.872184f,
+	-0.456242f,
+	0.0304109f,
+	0.916616f,
+	0.39861f,
+	-0.119037f,
+	0.881644f,
+	0.456655f,
+	-0.241587f,
+	0.81204f,
+	0.53125f,
+	-0.146676f,
+	0.796898f,
+	0.586037f,
+	-0.0991089f,
+	0.808485f,
+	0.580111f,
+	-0.265015f,
+	0.835696f,
+	0.481019f,
+	-0.330941f,
+	0.833473f,
+	0.442495f,
+	-0.0736129f,
+	0.908742f,
+	0.410816f,
+	0.128357f,
+	0.956244f,
+	0.26291f,
+	0.135386f,
+	0.977167f,
+	0.163754f,
+	0.135126f,
+	0.969499f,
+	0.204482f,
+	-0.0826833f,
+	0.991706f,
+	0.0984031f,
+	-0.125203f,
+	0.992066f,
+	-0.0113628f,
+	-0.0793175f,
+	0.988189f,
+	-0.131112f,
+	-0.135148f,
+	0.988869f,
+	-0.0622353f,
+	-0.236045f,
+	0.96998f,
+	-0.0584937f,
+	-0.106098f,
+	0.976702f,
+	-0.186536f,
+	0.0734477f,
+	0.937214f,
+	-0.340932f,
+	0.0657813f,
+	0.913127f,
+	-0.402333f,
+	-0.0656411f,
+	0.925185f,
+	-0.373797f,
+	-0.0812155f,
+	0.911514f,
+	-0.403169f,
+	0.138018f,
+	0.895606f,
+	-0.422895f,
+	0.180346f,
+	0.87052f,
+	-0.457898f,
+	0.220345f,
+	0.874256f,
+	-0.43258f,
+	0.337626f,
+	0.867122f,
+	-0.366208f,
+	0.351448f,
+	0.893332f,
+	-0.280076f,
+	0.206919f,
+	0.931373f,
+	-0.299548f,
+	0.143612f,
+	0.950749f,
+	-0.274684f,
+	0.0388897f,
+	0.972032f,
+	-0.231606f,
+	-0.0281782f,
+	0.996586f,
+	-0.077599f,
+	-0.0348963f,
+	0.997716f,
+	-0.0578427f,
+	-0.0315338f,
+	0.968969f,
+	-0.245163f,
+	0.0536322f,
+	0.969299f,
+	-0.239965f,
+	-0.0592746f,
+	0.980608f,
+	-0.186802f,
+	-0.146447f,
+	0.958871f,
+	-0.243144f,
+	-0.0489008f,
+	0.966653f,
+	-0.251379f,
+	-0.0921771f,
+	0.973026f,
+	-0.211482f,
+	-0.303489f,
+	0.921788f,
+	-0.24125f,
+	-0.360359f,
+	0.892722f,
+	-0.270533f,
+	-0.374413f,
+	0.86994f,
+	-0.320965f,
+	-0.420297f,
+	0.839321f,
+	-0.344805f,
+	-0.400389f,
+	0.890168f,
+	-0.217463f,
+	-0.5519f,
+	0.817694f,
+	-0.163655f,
+	-0.641175f,
+	0.723209f,
+	-0.25664f,
+	-0.591295f,
+	0.757829f,
+	-0.275801f,
+	-0.562781f,
+	0.775127f,
+	-0.287152f,
+	-0.492934f,
+	0.830818f,
+	-0.258375f,
+	-0.559738f,
+	0.799568f,
+	-0.21768f,
+	-0.572862f,
+	0.78051f,
+	-0.250266f,
+	-0.449965f,
+	0.836305f,
+	-0.31325f,
+	-0.485973f,
+	0.815927f,
+	-0.313197f,
+	-0.461831f,
+	0.850292f,
+	-0.252418f,
+	-0.261301f,
+	0.911823f,
+	-0.316702f,
+	-0.0988633f,
+	0.911184f,
+	-0.399961f,
+	-0.117544f,
+	0.902602f,
+	-0.414118f,
+	-0.193385f,
+	0.896249f,
+	-0.399173f,
+	-0.121448f,
+	0.924471f,
+	-0.361392f,
+	0.0924319f,
+	0.986306f,
+	-0.136592f,
+	0.0129691f,
+	0.994218f,
+	-0.106593f,
+	0.0478938f,
+	0.996018f,
+	-0.0752017f,
+	0.0322924f,
+	0.95892f,
+	-0.281832f,
+	0.0176709f,
+	0.880909f,
+	-0.472956f,
+	0.117774f,
+	0.85642f,
+	-0.502666f,
+	0.141956f,
+	0.850649f,
+	-0.506206f,
+	0.133057f,
+	0.865588f,
+	-0.482757f,
+	0.139695f,
+	0.858438f,
+	-0.493528f,
+	-0.227309f,
+	0.878161f,
+	0.420907f,
+	-0.208802f,
+	0.809453f,
+	0.548805f,
+	-0.283627f,
+	0.767885f,
+	0.574377f,
+	-0.166581f,
+	0.77975f,
+	0.603523f,
+	-0.0979994f,
+	0.806409f,
+	0.583181f,
+	-0.132228f,
+	0.805326f,
+	0.577898f,
+	-0.219374f,
+	0.878043f,
+	0.425342f,
+	-0.024745f,
+	0.955845f,
+	0.292828f,
+	0.235018f,
+	0.923494f,
+	0.303193f,
+	0.225806f,
+	0.944421f,
+	0.238915f,
+	0.125193f,
+	0.981151f,
+	0.147203f,
+	-0.0300197f,
+	0.990754f,
+	0.132305f,
+	-0.0418198f,
+	0.992604f,
+	0.113964f,
+	0.010498f,
+	0.998335f,
+	0.0567192f,
+	-0.187859f,
+	0.981941f,
+	-0.0223995f,
+	-0.164152f,
+	0.985849f,
+	-0.0340039f,
+	-0.00148231f,
+	0.989313f,
+	-0.145799f,
+	0.214865f,
+	0.96059f,
+	-0.176353f,
+	0.130927f,
+	0.950976f,
+	-0.280185f,
+	-0.0784848f,
+	0.932131f,
+	-0.353513f,
+	-0.05291f,
+	0.922588f,
+	-0.382142f,
+	0.16861f,
+	0.90111f,
+	-0.399463f,
+	0.291627f,
+	0.864919f,
+	-0.408495f,
+	0.209787f,
+	0.830907f,
+	-0.515347f,
+	0.211969f,
+	0.855025f,
+	-0.473287f,
+	0.179371f,
+	0.927145f,
+	-0.328982f,
+	0.0938016f,
+	0.98223f,
+	-0.162562f,
+	0.0948278f,
+	0.994302f,
+	-0.0487031f,
+	0.0439203f,
+	0.998532f,
+	-0.0316906f,
+	-0.0612398f,
+	0.9958f,
+	-0.0680553f,
+	0.0442323f,
+	0.992295f,
+	-0.115732f,
+	0.0938163f,
+	0.983362f,
+	-0.155559f,
+	-0.00984882f,
+	0.984434f,
+	-0.175479f,
+	-0.064778f,
+	0.984002f,
+	-0.165961f,
+	-0.129271f,
+	0.96358f,
+	-0.234101f,
+	-0.126642f,
+	0.968315f,
+	-0.215238f,
+	-0.066296f,
+	0.988071f,
+	-0.138997f,
+	-0.153283f,
+	0.960153f,
+	-0.233691f,
+	-0.288259f,
+	0.887225f,
+	-0.360193f,
+	-0.349196f,
+	0.862768f,
+	-0.365641f,
+	-0.457337f,
+	0.833523f,
+	-0.309971f,
+	-0.510223f,
+	0.838902f,
+	-0.189514f,
+	-0.576482f,
+	0.813491f,
+	-0.0768136f,
+	-0.627022f,
+	0.773599f,
+	-0.0915885f,
+	-0.562811f,
+	0.806938f,
+	-0.179152f,
+	-0.554556f,
+	0.77173f,
+	-0.31129f,
+	-0.544029f,
+	0.784112f,
+	-0.298665f,
+	-0.593089f,
+	0.773019f,
+	-0.225135f,
+	-0.565758f,
+	0.788678f,
+	-0.240633f,
+	-0.424914f,
+	0.871459f,
+	-0.244963f,
+	-0.461935f,
+	0.845882f,
+	-0.266647f,
+	-0.437432f,
+	0.833935f,
+	-0.336461f,
+	-0.166572f,
+	0.89804f,
+	-0.407159f,
+	-0.027465f,
+	0.893903f,
+	-0.447419f,
+	-0.142495f,
+	0.890824f,
+	-0.431426f,
+	-0.254187f,
+	0.896659f,
+	-0.36248f,
+	-0.245781f,
+	0.925153f,
+	-0.289282f,
+	-0.124728f,
+	0.970098f,
+	-0.208211f,
+	0.0496061f,
+	0.995502f,
+	-0.0807218f,
+	0.134453f,
+	0.977049f,
+	-0.165221f,
+	0.178593f,
+	0.948688f,
+	-0.260952f,
+	0.203783f,
+	0.948389f,
+	-0.242962f,
+	0.169172f,
+	0.89845f,
+	-0.405178f,
+	0.129822f,
+	0.855112f,
+	-0.501925f,
+	0.114157f,
+	0.849198f,
+	-0.515587f,
+	0.207913f,
+	0.855521f,
+	-0.47419f,
+	-0.447508f,
+	0.787815f,
+	0.423184f,
+	-0.372189f,
+	0.752087f,
+	0.543911f,
+	-0.298757f,
+	0.721076f,
+	0.625135f,
+	-0.109779f,
+	0.732409f,
+	0.671956f,
+	-0.05023f,
+	0.773443f,
+	0.631872f,
+	-0.0721375f,
+	0.784971f,
+	0.615319f,
+	0.0161123f,
+	0.834678f,
+	0.550503f,
+	0.0881584f,
+	0.925537f,
+	0.368252f,
+	0.194291f,
+	0.939133f,
+	0.283338f,
+	0.290284f,
+	0.915951f,
+	0.277072f,
+	0.206501f,
+	0.959193f,
+	0.193147f,
+	0.0129994f,
+	0.989588f,
+	0.143339f,
+	-0.0515539f,
+	0.993638f,
+	0.100126f,
+	0.0752528f,
+	0.992857f,
+	0.0925807f,
+	-0.11243f,
+	0.993659f,
+	-0.00132253f,
+	-0.0900456f,
+	0.995381f,
+	-0.0332891f,
+	0.0735618f,
+	0.988585f,
+	-0.131483f,
+	0.187914f,
+	0.97058f,
+	-0.150539f,
+	0.259537f,
+	0.959521f,
+	-0.109363f,
+	0.039582f,
+	0.950958f,
+	-0.306778f,
+	0.0151247f,
+	0.899216f,
+	-0.437243f,
+	0.157602f,
+	0.861329f,
+	-0.482984f,
+	0.313265f,
+	0.852495f,
+	-0.41847f,
+	0.26241f,
+	0.877515f,
+	-0.401384f,
+	0.106606f,
+	0.940488f,
+	-0.322671f,
+	0.0451106f,
+	0.964729f,
+	-0.259351f,
+	-0.0198008f,
+	0.966294f,
+	-0.256677f,
+	0.0415355f,
+	0.979836f,
+	-0.195439f,
+	0.019077f,
+	0.98811f,
+	-0.15256f,
+	0.00843283f,
+	0.995377f,
+	-0.095676f,
+	0.0813095f,
+	0.98616f,
+	-0.14449f,
+	0.0601215f,
+	0.98288f,
+	-0.174159f,
+	0.0231889f,
+	0.98066f,
+	-0.194342f,
+	-0.0257967f,
+	0.969536f,
+	-0.243588f,
+	-0.0655874f,
+	0.972755f,
+	-0.222364f,
+	-0.116074f,
+	0.960607f,
+	-0.252509f,
+	-0.11539f,
+	0.952331f,
+	-0.282402f,
+	-0.0547002f,
+	0.971779f,
+	-0.229464f,
+	-0.238443f,
+	0.921749f,
+	-0.305817f,
+	-0.409013f,
+	0.87493f,
+	-0.259242f,
+	-0.537403f,
+	0.830349f,
+	-0.147369f,
+	-0.604026f,
+	0.794872f,
+	-0.0577237f,
+	-0.636334f,
+	0.771366f,
+	0.00856593f,
+	-0.598176f,
+	0.796287f,
+	0.0900769f,
+	-0.445184f,
+	0.894265f,
+	0.0458439f,
+	-0.510078f,
+	0.851049f,
+	-0.124644f,
+	-0.584904f,
+	0.80616f,
+	-0.0894032f,
+	-0.566358f,
+	0.809139f,
+	-0.156631f,
+	-0.526778f,
+	0.78194f,
+	-0.333278f,
+	-0.411595f,
+	0.815587f,
+	-0.406703f,
+	-0.430581f,
+	0.806825f,
+	-0.404517f,
+	-0.346574f,
+	0.828739f,
+	-0.439406f,
+	-0.163187f,
+	0.84355f,
+	-0.511658f,
+	-0.120565f,
+	0.900123f,
+	-0.41862f,
+	-0.22033f,
+	0.94784f,
+	-0.230335f,
+	-0.354954f,
+	0.922144f,
+	-0.15381f,
+	-0.229701f,
+	0.962171f,
+	-0.146509f,
+	-0.156358f,
+	0.938689f,
+	-0.30727f,
+	-0.0202846f,
+	0.954287f,
+	-0.298202f,
+	0.237025f,
+	0.938874f,
+	-0.24967f,
+	0.153523f,
+	0.923965f,
+	-0.350312f,
+	0.146234f,
+	0.948682f,
+	-0.280389f,
+	0.334575f,
+	0.915861f,
+	-0.221942f,
+	0.32488f,
+	0.905199f,
+	-0.273985f,
+	0.124349f,
+	0.918374f,
+	-0.375668f,
+	0.0853809f,
+	0.932635f,
+	-0.350575f,
+	-0.326098f,
+	0.745953f,
+	0.580702f,
+	-0.408924f,
+	0.742079f,
+	0.53113f,
+	-0.380928f,
+	0.732802f,
+	0.563822f,
+	-0.135265f,
+	0.771831f,
+	0.621274f,
+	0.0172939f,
+	0.791015f,
+	0.611552f,
+	-0.0321407f,
+	0.821651f,
+	0.569084f,
+	0.110827f,
+	0.821493f,
+	0.559345f,
+	0.260047f,
+	0.831043f,
+	0.491674f,
+	0.30077f,
+	0.882298f,
+	0.362061f,
+	0.33436f,
+	0.910333f,
+	0.243922f,
+	0.27591f,
+	0.939307f,
+	0.203903f,
+	0.0278945f,
+	0.981912f,
+	0.18727f,
+	-0.00885636f,
+	0.980185f,
+	0.197887f,
+	0.145141f,
+	0.978135f,
+	0.148949f,
+	-0.0144219f,
+	0.999761f,
+	0.0164012f,
+	-0.0725846f,
+	0.989236f,
+	-0.127057f,
+	0.156537f,
+	0.975005f,
+	-0.157677f,
+	0.153594f,
+	0.966224f,
+	-0.206929f,
+	0.277291f,
+	0.95249f,
+	-0.125986f,
+	0.254121f,
+	0.951784f,
+	-0.171844f,
+	0.192884f,
+	0.934802f,
+	-0.298229f,
+	0.176671f,
+	0.893747f,
+	-0.412315f,
+	0.195208f,
+	0.917965f,
+	-0.345303f,
+	0.157451f,
+	0.974963f,
+	-0.157023f,
+	0.0279983f,
+	0.991052f,
+	-0.13051f,
+	0.088609f,
+	0.976865f,
+	-0.194637f,
+	0.0507072f,
+	0.953301f,
+	-0.297735f,
+	-0.0277167f,
+	0.944799f,
+	-0.326477f,
+	-0.027462f,
+	0.967827f,
+	-0.250115f,
+	-0.0885824f,
+	0.972427f,
+	-0.215728f,
+	0.0938124f,
+	0.990405f,
+	-0.101477f,
+	0.168783f,
+	0.975825f,
+	-0.138845f,
+	0.111665f,
+	0.949064f,
+	-0.294633f,
+	-0.0373777f,
+	0.928827f,
+	-0.368623f,
+	-0.132876f,
+	0.934016f,
+	-0.3316f,
+	-0.0938993f,
+	0.959978f,
+	-0.263865f,
+	-0.105226f,
+	0.962669f,
+	-0.249392f,
+	-0.104341f,
+	0.966883f,
+	-0.232916f,
+	-0.220802f,
+	0.965347f,
+	-0.13911f,
+	-0.478375f,
+	0.876928f,
+	-0.0464122f,
+	-0.604444f,
+	0.796064f,
+	0.0305022f,
+	-0.611643f,
+	0.789038f,
+	0.0575453f,
+	-0.651561f,
+	0.758511f,
+	-0.0113831f,
+	-0.622019f,
+	0.781788f,
+	-0.0435906f,
+	-0.406862f,
+	0.913403f,
+	-0.012587f,
+	-0.447294f,
+	0.893518f,
+	0.0394196f,
+	-0.595605f,
+	0.801728f,
+	0.049859f,
+	-0.453119f,
+	0.890822f,
+	0.0334497f,
+	-0.397535f,
+	0.913376f,
+	-0.0878049f,
+	-0.358743f,
+	0.901381f,
+	-0.242521f,
+	-0.368468f,
+	0.876571f,
+	-0.309604f,
+	-0.3524f,
+	0.834147f,
+	-0.42428f,
+	-0.221095f,
+	0.907887f,
+	-0.356171f,
+	-0.336012f,
+	0.912731f,
+	-0.232418f,
+	-0.365521f,
+	0.924164f,
+	-0.110978f,
+	-0.381997f,
+	0.913352f,
+	-0.140951f,
+	-0.128103f,
+	0.980976f,
+	-0.145863f,
+	0.0620369f,
+	0.958271f,
+	-0.279048f,
+	-0.0393717f,
+	0.894694f,
+	-0.44494f,
+	0.166576f,
+	0.906235f,
+	-0.388576f,
+	0.257306f,
+	0.912784f,
+	-0.317204f,
+	0.0500832f,
+	0.912737f,
+	-0.405466f,
+	0.219062f,
+	0.950498f,
+	-0.220374f,
+	0.303476f,
+	0.949102f,
+	-0.0843104f,
+	0.167756f,
+	0.983709f,
+	-0.0646101f,
+	-0.00137806f,
+	0.991718f,
+	-0.128423f,
+	-0.411803f,
+	0.737245f,
+	0.535619f,
+	-0.383529f,
+	0.716567f,
+	0.582612f,
+	-0.385829f,
+	0.756694f,
+	0.527779f,
+	-0.125894f,
+	0.866623f,
+	0.482821f,
+	0.0864817f,
+	0.885592f,
+	0.456341f,
+	0.0185611f,
+	0.909875f,
+	0.414467f,
+	0.0890012f,
+	0.92755f,
+	0.362947f,
+	0.3312f,
+	0.85507f,
+	0.39895f,
+	0.411118f,
+	0.842585f,
+	0.347898f,
+	0.395768f,
+	0.87253f,
+	0.286458f,
+	0.265631f,
+	0.912624f,
+	0.310738f,
+	0.0432866f,
+	0.942781f,
+	0.330591f,
+	-0.0291247f,
+	0.959608f,
+	0.279829f,
+	0.17674f,
+	0.935093f,
+	0.307187f,
+	0.194038f,
+	0.946511f,
+	0.25781f,
+	0.0938941f,
+	0.995535f,
+	0.00965941f,
+	0.2133f,
+	0.967919f,
+	-0.132802f,
+	0.174202f,
+	0.951285f,
+	-0.254382f,
+	0.185706f,
+	0.942688f,
+	-0.277223f,
+	0.254853f,
+	0.951817f,
+	-0.170569f,
+	0.272452f,
+	0.946195f,
+	-0.174599f,
+	0.236374f,
+	0.944357f,
+	-0.228728f,
+	0.0622104f,
+	0.974295f,
+	-0.216517f,
+	0.00421412f,
+	0.994674f,
+	-0.102989f,
+	0.150974f,
+	0.988535f,
+	0.00252771f,
+	0.198367f,
+	0.972494f,
+	-0.122094f,
+	0.128147f,
+	0.983415f,
+	-0.128347f,
+	0.00128047f,
+	0.972843f,
+	-0.231463f,
+	-0.0877992f,
+	0.94046f,
+	-0.328368f,
+	-0.123322f,
+	0.945018f,
+	-0.302876f,
+	0.0120775f,
+	0.960206f,
+	-0.279033f,
+	0.230563f,
+	0.945381f,
+	-0.230424f,
+	0.231597f,
+	0.934072f,
+	-0.271795f,
+	0.0492688f,
+	0.934225f,
+	-0.353265f,
+	-0.160672f,
+	0.892999f,
+	-0.4204f,
+	-0.160391f,
+	0.913064f,
+	-0.374951f,
+	-0.146451f,
+	0.932705f,
+	-0.329565f,
+	-0.203905f,
+	0.952995f,
+	-0.224107f,
+	-0.374034f,
+	0.927408f,
+	-0.00361175f,
+	-0.538909f,
+	0.826945f,
+	0.160435f,
+	-0.614792f,
+	0.776175f,
+	0.139939f,
+	-0.589081f,
+	0.79961f,
+	0.116649f,
+	-0.558852f,
+	0.827241f,
+	0.0579274f,
+	-0.582196f,
+	0.802416f,
+	-0.131063f,
+	-0.51435f,
+	0.846005f,
+	-0.140428f,
+	-0.52517f,
+	0.850476f,
+	0.0297862f,
+	-0.596917f,
+	0.80173f,
+	0.0303285f,
+	-0.476386f,
+	0.879145f,
+	0.0126877f,
+	-0.346071f,
+	0.935165f,
+	0.0755073f,
+	-0.29506f,
+	0.953573f,
+	0.0603189f,
+	-0.290873f,
+	0.956376f,
+	0.0271545f,
+	-0.342792f,
+	0.934849f,
+	-0.0924672f,
+	-0.36131f,
+	0.919889f,
+	-0.152511f,
+	-0.440677f,
+	0.895263f,
+	-0.0656364f,
+	-0.27224f,
+	0.960453f,
+	-0.0584458f,
+	-0.239345f,
+	0.939791f,
+	-0.243941f,
+	-0.184322f,
+	0.924268f,
+	-0.334296f,
+	0.170265f,
+	0.967851f,
+	-0.185131f,
+	0.0831722f,
+	0.975078f,
+	-0.205681f,
+	0.0764752f,
+	0.962386f,
+	-0.2607f,
+	0.25092f,
+	0.948574f,
+	-0.192995f,
+	-0.000511184f,
+	0.983325f,
+	-0.181855f,
+	0.00805518f,
+	0.99922f,
+	-0.0386666f,
+	0.231558f,
+	0.969957f,
+	0.0745867f,
+	0.213284f,
+	0.97378f,
+	0.0791335f,
+	0.134707f,
+	0.990255f,
+	0.0353415f,
+	-0.461887f,
+	0.727903f,
+	0.506772f,
+	-0.409704f,
+	0.769768f,
+	0.48949f,
+	-0.245031f,
+	0.85373f,
+	0.459461f,
+	-0.000652498f,
+	0.933053f,
+	0.359739f,
+	0.0977619f,
+	0.940993f,
+	0.323999f,
+	0.0976539f,
+	0.925223f,
+	0.366641f,
+	0.122528f,
+	0.958779f,
+	0.256377f,
+	0.300256f,
+	0.92807f,
+	0.220301f,
+	0.434057f,
+	0.868364f,
+	0.239872f,
+	0.373936f,
+	0.875783f,
+	0.305249f,
+	0.188752f,
+	0.892291f,
+	0.41011f,
+	0.0749298f,
+	0.875078f,
+	0.478146f,
+	0.0539526f,
+	0.905587f,
+	0.420716f,
+	0.139771f,
+	0.930537f,
+	0.338475f,
+	0.252071f,
+	0.902374f,
+	0.349544f,
+	0.271241f,
+	0.91149f,
+	0.309214f,
+	0.343876f,
+	0.91657f,
+	0.204082f,
+	0.324141f,
+	0.940857f,
+	0.098591f,
+	0.18373f,
+	0.982977f,
+	-0.000581414f,
+	0.215424f,
+	0.976468f,
+	-0.0101277f,
+	0.272942f,
+	0.961141f,
+	-0.0413737f,
+	0.263192f,
+	0.964688f,
+	-0.010384f,
+	0.0834313f,
+	0.988492f,
+	-0.126183f,
+	-0.0244777f,
+	0.972824f,
+	-0.230248f,
+	0.037395f,
+	0.972598f,
+	-0.229465f,
+	0.188221f,
+	0.98005f,
+	-0.0638298f,
+	0.133895f,
+	0.99093f,
+	-0.0113778f,
+	0.15553f,
+	0.985289f,
+	-0.0708293f,
+	0.062154f,
+	0.97927f,
+	-0.19279f,
+	-0.0906565f,
+	0.929896f,
+	-0.356476f,
+	-0.00537849f,
+	0.905315f,
+	-0.424706f,
+	0.162604f,
+	0.918237f,
+	-0.361109f,
+	0.211297f,
+	0.942163f,
+	-0.260159f,
+	0.166674f,
+	0.959094f,
+	-0.22882f,
+	-0.0900843f,
+	0.919646f,
+	-0.382278f,
+	-0.185542f,
+	0.891522f,
+	-0.413234f,
+	-0.236454f,
+	0.911319f,
+	-0.337026f,
+	-0.404129f,
+	0.904849f,
+	-0.133894f,
+	-0.540771f,
+	0.839361f,
+	0.0551279f,
+	-0.598434f,
+	0.794978f,
+	0.0994372f,
+	-0.56944f,
+	0.810652f,
+	0.136315f,
+	-0.572323f,
+	0.818089f,
+	0.0563579f,
+	-0.472334f,
+	0.880613f,
+	0.0376913f,
+	-0.539685f,
+	0.840552f,
+	-0.0470301f,
+	-0.574258f,
+	0.816988f,
+	0.0525225f,
+	-0.582793f,
+	0.802613f,
+	0.127141f,
+	-0.577964f,
+	0.810669f,
+	0.0936681f,
+	-0.453297f,
+	0.886551f,
+	0.0924669f,
+	-0.392456f,
+	0.918879f,
+	0.0405067f,
+	-0.316387f,
+	0.94595f,
+	0.0712573f,
+	-0.278453f,
+	0.953269f,
+	0.117224f,
+	-0.268053f,
+	0.957793f,
+	0.103824f,
+	-0.307148f,
+	0.94927f,
+	0.0674248f,
+	-0.42059f,
+	0.907249f,
+	-0.00173726f,
+	-0.259446f,
+	0.962613f,
+	-0.0778756f,
+	-0.0851837f,
+	0.992966f,
+	-0.082236f,
+	-0.215247f,
+	0.960313f,
+	-0.177393f,
+	-0.0219544f,
+	0.989556f,
+	-0.14247f,
+	0.0391647f,
+	0.99769f,
+	-0.0555004f,
+	0.102045f,
+	0.994433f,
+	0.0262785f,
+	0.194292f,
+	0.978837f,
+	0.0642512f,
+	-0.0292693f,
+	0.988875f,
+	0.145839f,
+	-0.101853f,
+	0.986247f,
+	0.130166f,
+	0.212882f,
+	0.964861f,
+	0.15403f,
+	0.245798f,
+	0.960888f,
+	0.127587f,
+	0.195444f,
+	0.974318f,
+	0.111832f,
+	-0.321858f,
+	0.809731f,
+	0.490656f,
+	-0.324834f,
+	0.8531f,
+	0.408293f,
+	-0.169338f,
+	0.931652f,
+	0.321478f,
+	0.0137661f,
+	0.965459f,
+	0.260189f,
+	0.0568655f,
+	0.931751f,
+	0.358619f,
+	0.0773718f,
+	0.91837f,
+	0.388084f,
+	0.261047f,
+	0.911575f,
+	0.317625f,
+	0.360487f,
+	0.919759f,
+	0.155217f,
+	0.377368f,
+	0.917164f,
+	0.128078f,
+	0.276887f,
+	0.917903f,
+	0.284232f,
+	0.0739314f,
+	0.913495f,
+	0.400076f,
+	0.00592871f,
+	0.863726f,
+	0.503926f,
+	0.12818f,
+	0.830694f,
+	0.541773f,
+	0.218813f,
+	0.849726f,
+	0.479673f,
+	0.242686f,
+	0.877276f,
+	0.414115f,
+	0.274843f,
+	0.886896f,
+	0.371318f,
+	0.349234f,
+	0.864992f,
+	0.360313f,
+	0.316807f,
+	0.866747f,
+	0.385206f,
+	0.243026f,
+	0.8884f,
+	0.389467f,
+	0.293176f,
+	0.904042f,
+	0.311057f,
+	0.24905f,
+	0.947495f,
+	0.200568f,
+	0.307601f,
+	0.926121f,
+	0.21836f,
+	0.250581f,
+	0.964737f,
+	0.0805682f,
+	0.134636f,
+	0.99035f,
+	-0.0328548f,
+	0.000251354f,
+	0.985828f,
+	-0.167762f,
+	0.0218107f,
+	0.990992f,
+	-0.132131f,
+	0.159951f,
+	0.984761f,
+	-0.068279f,
+	0.165852f,
+	0.977778f,
+	-0.128229f,
+	0.162621f,
+	0.98447f,
+	-0.06613f,
+	0.121502f,
+	0.975682f,
+	-0.182435f,
+	0.0565286f,
+	0.935574f,
+	-0.348576f,
+	0.0461029f,
+	0.9227f,
+	-0.382752f,
+	0.0939341f,
+	0.947555f,
+	-0.305477f,
+	0.144515f,
+	0.970016f,
+	-0.195409f,
+	0.0775217f,
+	0.989125f,
+	-0.124991f,
+	-0.200827f,
+	0.965332f,
+	-0.16674f,
+	-0.401609f,
+	0.907839f,
+	-0.120577f,
+	-0.559375f,
+	0.828885f,
+	-0.00699655f,
+	-0.565805f,
+	0.821746f,
+	0.0678162f,
+	-0.593147f,
+	0.804311f,
+	0.0354918f,
+	-0.576294f,
+	0.817225f,
+	0.00543077f,
+	-0.525544f,
+	0.848999f,
+	-0.0548173f,
+	-0.499547f,
+	0.863338f,
+	-0.0714126f,
+	-0.553806f,
+	0.830814f,
+	0.0551944f,
+	-0.639015f,
+	0.755184f,
+	0.146141f,
+	-0.555848f,
+	0.812796f,
+	0.174341f,
+	-0.558245f,
+	0.826947f,
+	0.0672363f,
+	-0.433561f,
+	0.898303f,
+	0.0712505f,
+	-0.328723f,
+	0.942541f,
+	0.0596481f,
+	-0.348698f,
+	0.936876f,
+	0.0259581f,
+	-0.301092f,
+	0.95068f,
+	0.0745005f,
+	-0.263015f,
+	0.962594f,
+	0.0650869f,
+	-0.284818f,
+	0.957539f,
+	0.0446894f,
+	-0.359379f,
+	0.932627f,
+	-0.032449f,
+	-0.231945f,
+	0.967322f,
+	-0.102417f,
+	-0.134462f,
+	0.989922f,
+	-0.0444264f,
+	-0.162306f,
+	0.986023f,
+	0.0376183f,
+	0.00794699f,
+	0.998548f,
+	-0.0532871f,
+	-0.0239448f,
+	0.993657f,
+	-0.109874f,
+	-0.0216422f,
+	0.99782f,
+	0.0623378f,
+	0.109723f,
+	0.978713f,
+	0.173443f,
+	-0.0637399f,
+	0.980084f,
+	0.188075f,
+	-0.0488189f,
+	0.981371f,
+	0.185814f,
+	0.215314f,
+	0.95546f,
+	0.201833f,
+	0.226954f,
+	0.944659f,
+	0.236876f,
+	0.18874f,
+	0.93582f,
+	0.297688f,
+	-0.35388f,
+	0.863488f,
+	0.359384f,
+	-0.279389f,
+	0.900607f,
+	0.332938f,
+	-0.0980507f,
+	0.952584f,
+	0.288043f,
+	-0.0324622f,
+	0.946395f,
+	0.321377f,
+	-0.0380375f,
+	0.913004f,
+	0.406173f,
+	0.128955f,
+	0.929408f,
+	0.345792f,
+	0.375928f,
+	0.898621f,
+	0.226181f,
+	0.446257f,
+	0.883274f,
+	0.143813f,
+	0.289683f,
+	0.938589f,
+	0.187442f,
+	0.125289f,
+	0.928145f,
+	0.350499f,
+	-0.0288389f,
+	0.895239f,
+	0.444652f,
+	-0.103894f,
+	0.871209f,
+	0.479793f,
+	0.105997f,
+	0.859294f,
+	0.500378f,
+	0.239743f,
+	0.842088f,
+	0.483127f,
+	0.302444f,
+	0.818919f,
+	0.48775f,
+	0.351983f,
+	0.830309f,
+	0.432082f,
+	0.318807f,
+	0.868172f,
+	0.380315f,
+	0.306771f,
+	0.857612f,
+	0.412787f,
+	0.273726f,
+	0.881543f,
+	0.384651f,
+	0.337032f,
+	0.866043f,
+	0.369295f,
+	0.363605f,
+	0.874829f,
+	0.320103f,
+	0.334634f,
+	0.927168f,
+	0.168463f,
+	0.372292f,
+	0.916204f,
+	0.148217f,
+	0.206342f,
+	0.978274f,
+	0.0200943f,
+	0.119354f,
+	0.989819f,
+	-0.077546f,
+	0.042858f,
+	0.974765f,
+	-0.21908f,
+	0.15227f,
+	0.956258f,
+	-0.24977f,
+	0.17642f,
+	0.955622f,
+	-0.235928f,
+	0.119264f,
+	0.963567f,
+	-0.239406f,
+	0.210452f,
+	0.949288f,
+	-0.233584f,
+	0.171674f,
+	0.93622f,
+	-0.306626f,
+	0.0511268f,
+	0.942128f,
+	-0.331333f,
+	0.00960037f,
+	0.978635f,
+	-0.205381f,
+	-0.00181509f,
+	0.99884f,
+	-0.048118f,
+	-0.0483779f,
+	0.993619f,
+	0.101885f,
+	-0.221067f,
+	0.964285f,
+	0.145887f,
+	-0.435375f,
+	0.898142f,
+	0.0615596f,
+	-0.544434f,
+	0.838804f,
+	-0.00062539f,
+	-0.579913f,
+	0.810216f,
+	-0.0851529f,
+	-0.5726f,
+	0.815766f,
+	-0.0815813f,
+	-0.546649f,
+	0.832873f,
+	-0.0865884f,
+	-0.465735f,
+	0.88205f,
+	-0.071268f,
+	-0.55864f,
+	0.824018f,
+	-0.0944285f,
+	-0.642115f,
+	0.765228f,
+	0.0459774f,
+	-0.656804f,
+	0.753752f,
+	0.0216163f,
+	-0.520592f,
+	0.853762f,
+	0.00863503f,
+	-0.481258f,
+	0.875004f,
+	-0.0525228f,
+	-0.443379f,
+	0.889071f,
+	-0.113874f,
+	-0.339817f,
+	0.937077f,
+	-0.0800719f,
+	-0.346478f,
+	0.935462f,
+	-0.0697409f,
+	-0.350474f,
+	0.934462f,
+	-0.0628307f,
+	-0.228751f,
+	0.97348f,
+	-0.00313391f,
+	-0.230759f,
+	0.970493f,
+	-0.0699589f,
+	-0.279469f,
+	0.954379f,
+	-0.105155f,
+	-0.198889f,
+	0.96686f,
+	-0.16008f,
+	-0.230529f,
+	0.946681f,
+	-0.225058f,
+	-0.14204f,
+	0.970201f,
+	-0.196301f,
+	0.0687794f,
+	0.962113f,
+	-0.263834f,
+	-0.0677159f,
+	0.979986f,
+	-0.187196f,
+	-0.220027f,
+	0.972288f,
+	-0.0790245f,
+	0.07326f,
+	0.993712f,
+	0.0846721f,
+	-0.0289367f,
+	0.993146f,
+	0.113239f,
+	-0.106822f,
+	0.986395f,
+	0.124957f,
+	0.128381f,
+	0.967004f,
+	0.22005f,
+	0.141757f,
+	0.945235f,
+	0.293998f,
+	0.0274083f,
+	0.95189f,
+	0.30521f,
+	-0.150915f,
+	0.940582f,
+	0.304189f,
+	-0.174369f,
+	0.970549f,
+	0.166222f,
+	-0.140821f,
+	0.979995f,
+	0.140639f,
+	-0.141606f,
+	0.959082f,
+	0.245171f,
+	0.011894f,
+	0.972798f,
+	0.23135f,
+	0.262326f,
+	0.961504f,
+	0.0818187f,
+	0.456393f,
+	0.889018f,
+	0.036791f,
+	0.382632f,
+	0.920315f,
+	0.0813253f,
+	0.174752f,
+	0.942069f,
+	0.286301f,
+	-0.045852f,
+	0.917014f,
+	0.396211f,
+	-0.0633233f,
+	0.882412f,
+	0.466197f,
+	-0.0422981f,
+	0.919143f,
+	0.391647f,
+	0.126089f,
+	0.949054f,
+	0.288786f,
+	0.256733f,
+	0.912921f,
+	0.317275f,
+	0.315104f,
+	0.887032f,
+	0.337468f,
+	0.409846f,
+	0.864148f,
+	0.292018f,
+	0.343944f,
+	0.901166f,
+	0.263823f,
+	0.312798f,
+	0.897029f,
+	0.312244f,
+	0.323227f,
+	0.888441f,
+	0.325879f,
+	0.342446f,
+	0.89904f,
+	0.272869f,
+	0.451059f,
+	0.860524f,
+	0.236736f,
+	0.423682f,
+	0.891569f,
+	0.159992f,
+	0.404089f,
+	0.899665f,
+	0.165275f,
+	0.34072f,
+	0.934631f,
+	0.101855f,
+	0.255675f,
+	0.966712f,
+	-0.00994645f,
+	0.192495f,
+	0.972523f,
+	-0.130939f,
+	0.146493f,
+	0.95759f,
+	-0.248115f,
+	0.177747f,
+	0.950895f,
+	-0.253387f,
+	0.10258f,
+	0.958737f,
+	-0.265144f,
+	0.233714f,
+	0.956929f,
+	-0.172236f,
+	0.223818f,
+	0.95591f,
+	-0.190111f,
+	-0.0753718f,
+	0.974181f,
+	-0.212814f,
+	-0.223858f,
+	0.97386f,
+	-0.0385406f,
+	-0.201603f,
+	0.967155f,
+	0.154817f,
+	-0.110966f,
+	0.95618f,
+	0.270934f,
+	-0.121146f,
+	0.966863f,
+	0.224722f,
+	-0.291476f,
+	0.94891f,
+	0.120877f,
+	-0.477923f,
+	0.877529f,
+	-0.0391374f,
+	-0.509066f,
+	0.849204f,
+	-0.140369f,
+	-0.547573f,
+	0.807834f,
+	-0.218101f,
+	-0.563212f,
+	0.785973f,
+	-0.255028f,
+	-0.550783f,
+	0.817799f,
+	-0.166865f,
+	-0.567941f,
+	0.823056f,
+	0.00472398f,
+	-0.662541f,
+	0.748994f,
+	-0.00687841f,
+	-0.61971f,
+	0.78387f,
+	-0.03883f,
+	-0.523314f,
+	0.847679f,
+	-0.0870804f,
+	-0.447797f,
+	0.889814f,
+	-0.0877948f,
+	-0.443749f,
+	0.888577f,
+	-0.116264f,
+	-0.376466f,
+	0.920201f,
+	-0.107257f,
+	-0.337652f,
+	0.938208f,
+	-0.0758775f,
+	-0.365552f,
+	0.926461f,
+	-0.0896778f,
+	-0.259904f,
+	0.962681f,
+	-0.0754604f,
+	-0.126151f,
+	0.988548f,
+	-0.0828222f,
+	-0.30144f,
+	0.926166f,
+	-0.226606f,
+	-0.124801f,
+	0.973148f,
+	-0.193411f,
+	-0.0842547f,
+	0.941418f,
+	-0.326548f,
+	-0.0799027f,
+	0.902475f,
+	-0.423267f,
+	-0.00736616f,
+	0.932864f,
+	-0.360152f,
+	-0.199402f,
+	0.957181f,
+	-0.209865f,
+	-0.285967f,
+	0.938676f,
+	-0.192641f,
+	-0.0884894f,
+	0.987166f,
+	-0.132941f,
+	-0.0982017f,
+	0.994337f,
+	0.0406204f,
+	-0.151395f,
+	0.982648f,
+	0.107153f,
+	0.0310104f,
+	0.988838f,
+	0.14573f,
+	0.106405f,
+	0.964191f,
+	0.242925f,
+	0.070474f,
+	0.952157f,
+	0.297374f,
+	0.0656706f,
+	0.9919f,
+	0.108725f,
+	-0.0894851f,
+	0.995828f,
+	0.0178395f,
+	-0.190523f,
+	0.981135f,
+	0.0327999f,
+	-0.155304f,
+	0.987556f,
+	0.0247798f,
+	0.115224f,
+	0.991572f,
+	-0.0592235f,
+	0.36579f,
+	0.920032f,
+	-0.140496f,
+	0.356271f,
+	0.926984f,
+	-0.117348f,
+	0.248335f,
+	0.959842f,
+	0.130508f,
+	0.000801886f,
+	0.966476f,
+	0.256755f,
+	-0.114974f,
+	0.940419f,
+	0.319989f,
+	-0.0524682f,
+	0.940494f,
+	0.335734f,
+	0.129742f,
+	0.951002f,
+	0.280646f,
+	0.183656f,
+	0.974747f,
+	0.127042f,
+	0.210533f,
+	0.964529f,
+	0.159247f,
+	0.299776f,
+	0.935816f,
+	0.185429f,
+	0.476652f,
+	0.857927f,
+	0.191739f,
+	0.365421f,
+	0.920615f,
+	0.137608f,
+	0.247354f,
+	0.961561f,
+	0.119232f,
+	0.333488f,
+	0.932256f,
+	0.140299f,
+	0.428629f,
+	0.898219f,
+	0.0973634f,
+	0.470887f,
+	0.881687f,
+	0.0298847f,
+	0.443595f,
+	0.892268f,
+	0.0841461f,
+	0.38152f,
+	0.920309f,
+	0.0864469f,
+	0.381462f,
+	0.916941f,
+	0.117074f,
+	0.327497f,
+	0.93955f,
+	0.099957f,
+	0.304803f,
+	0.952409f,
+	-0.00357992f,
+	0.239937f,
+	0.959204f,
+	-0.149528f,
+	0.202117f,
+	0.965308f,
+	-0.165315f,
+	0.0495866f,
+	0.988011f,
+	-0.146203f,
+	0.0854477f,
+	0.995976f,
+	-0.027023f,
+	0.244078f,
+	0.956317f,
+	0.160886f,
+	-0.0753613f,
+	0.986424f,
+	0.145905f,
+	-0.339089f,
+	0.932874f,
+	0.12151f,
+	-0.294837f,
+	0.942606f,
+	0.15673f,
+	-0.104304f,
+	0.973462f,
+	0.203698f,
+	-0.0723227f,
+	0.985619f,
+	0.152724f,
+	-0.210009f,
+	0.973927f,
+	0.0858055f,
+	-0.391811f,
+	0.919671f,
+	-0.0262484f,
+	-0.442429f,
+	0.895892f,
+	-0.0404195f,
+	-0.501975f,
+	0.857758f,
+	-0.11078f,
+	-0.516547f,
+	0.834688f,
+	-0.190982f,
+	-0.606461f,
+	0.747704f,
+	-0.270451f,
+	-0.650373f,
+	0.745527f,
+	-0.145618f,
+	-0.638901f,
+	0.762805f,
+	-0.0996673f,
+	-0.598555f,
+	0.785548f,
+	-0.156994f,
+	-0.501024f,
+	0.846694f,
+	-0.179123f,
+	-0.446137f,
+	0.875545f,
+	-0.185426f,
+	-0.431282f,
+	0.886668f,
+	-0.16678f,
+	-0.409115f,
+	0.903871f,
+	-0.125073f,
+	-0.364534f,
+	0.929271f,
+	-0.0597475f,
+	-0.342967f,
+	0.93838f,
+	-0.0426101f,
+	-0.26831f,
+	0.95962f,
+	-0.0844963f,
+	-0.0393852f,
+	0.992201f,
+	-0.118264f,
+	-0.116204f,
+	0.958118f,
+	-0.261737f,
+	-0.10396f,
+	0.911216f,
+	-0.398596f,
+	0.0690263f,
+	0.90803f,
+	-0.41318f,
+	-0.107766f,
+	0.879323f,
+	-0.463872f,
+	-0.204112f,
+	0.904181f,
+	-0.375227f,
+	-0.300499f,
+	0.93243f,
+	-0.200683f,
+	-0.27347f,
+	0.953749f,
+	-0.124807f,
+	-0.169754f,
+	0.978593f,
+	-0.116359f,
+	-0.231778f,
+	0.970053f,
+	-0.072634f,
+	-0.190395f,
+	0.98166f,
+	0.00964305f,
+	-0.0305984f,
+	0.996687f,
+	0.0753532f,
+	0.015862f,
+	0.984083f,
+	0.177002f,
+	-0.0353434f,
+	0.980638f,
+	0.192612f,
+	-0.00358253f,
+	0.996067f,
+	-0.0885361f,
+	-0.091201f,
+	0.995656f,
+	-0.0187243f,
+	-0.182622f,
+	0.982071f,
+	0.0467509f,
+	-0.0739202f,
+	0.997106f,
+	-0.017751f,
+	0.154438f,
+	0.971547f,
+	-0.179571f,
+	0.395535f,
+	0.904532f,
+	-0.159291f,
+	0.194508f,
+	0.960754f,
+	-0.197781f,
+	0.113269f,
+	0.98581f,
+	0.123894f,
+	-0.030891f,
+	0.963944f,
+	0.264306f,
+	-0.124571f,
+	0.959262f,
+	0.253572f,
+	-0.0553429f,
+	0.968125f,
+	0.244277f,
+	0.192328f,
+	0.950681f,
+	0.243343f,
+	0.217769f,
+	0.968216f,
+	0.123025f,
+	0.205296f,
+	0.966103f,
+	0.156522f,
+	0.276023f,
+	0.954237f,
+	0.11508f,
+	0.467224f,
+	0.868183f,
+	0.167212f,
+	0.402263f,
+	0.894308f,
+	0.195955f,
+	0.299601f,
+	0.940084f,
+	0.162733f,
+	0.355906f,
+	0.933872f,
+	0.0348486f,
+	0.474044f,
+	0.880198f,
+	-0.0230946f,
+	0.444725f,
+	0.891474f,
+	-0.0865651f,
+	0.431452f,
+	0.901988f,
+	0.0163334f,
+	0.385491f,
+	0.922676f,
+	0.00810292f,
+	0.339313f,
+	0.940655f,
+	0.00595024f,
+	0.37483f,
+	0.92173f,
+	0.099581f,
+	0.41171f,
+	0.911266f,
+	-0.00949356f,
+	0.281208f,
+	0.933096f,
+	-0.224175f,
+	0.138066f,
+	0.959634f,
+	-0.245031f,
+	0.0299217f,
+	0.992057f,
+	-0.122182f,
+	-0.0797424f,
+	0.99128f,
+	-0.104905f,
+	0.124146f,
+	0.977522f,
+	0.170405f,
+	-0.0302976f,
+	0.947743f,
+	0.317594f,
+	-0.301142f,
+	0.928457f,
+	0.21744f,
+	-0.278579f,
+	0.94845f,
+	0.151119f,
+	-0.150217f,
+	0.982764f,
+	0.107745f,
+	0.0163995f,
+	0.982022f,
+	0.188052f,
+	-0.137431f,
+	0.989816f,
+	0.0370977f,
+	-0.36652f,
+	0.926186f,
+	-0.0885568f,
+	-0.445397f,
+	0.895157f,
+	-0.0177851f,
+	-0.463397f,
+	0.885777f,
+	-0.0257252f,
+	-0.466469f,
+	0.878885f,
+	-0.099842f,
+	-0.557948f,
+	0.804805f,
+	-0.202443f,
+	-0.681509f,
+	0.679149f,
+	-0.272587f,
+	-0.629296f,
+	0.753928f,
+	-0.188625f,
+	-0.5596f,
+	0.798482f,
+	-0.221976f,
+	-0.503025f,
+	0.800303f,
+	-0.326313f,
+	-0.422254f,
+	0.855253f,
+	-0.300408f,
+	-0.454716f,
+	0.829192f,
+	-0.325075f,
+	-0.46025f,
+	0.856807f,
+	-0.232488f,
+	-0.37729f,
+	0.921922f,
+	-0.0878209f,
+	-0.375084f,
+	0.920087f,
+	-0.112928f,
+	-0.173161f,
+	0.984659f,
+	-0.0214944f,
+	-0.0348229f,
+	0.978528f,
+	-0.20315f,
+	0.0523603f,
+	0.977312f,
+	-0.205229f,
+	-0.0533357f,
+	0.893335f,
+	-0.446215f,
+	0.0246713f,
+	0.873256f,
+	-0.486637f,
+	-0.0923807f,
+	0.905308f,
+	-0.414587f,
+	-0.269958f,
+	0.871402f,
+	-0.409612f,
+	-0.388686f,
+	0.862358f,
+	-0.324442f,
+	-0.340148f,
+	0.928537f,
+	-0.148722f,
+	-0.147166f,
+	0.988619f,
+	-0.0312327f,
+	-0.248059f,
+	0.963625f,
+	-0.099463f,
+	-0.232297f,
+	0.969578f,
+	-0.0771772f,
+	-0.142695f,
+	0.989498f,
+	-0.02308f,
+	-0.0198137f,
+	0.98287f,
+	0.18323f,
+	-0.0333475f,
+	0.978727f,
+	0.202438f,
+};
+
+btScalar Landscape05Tex[] = {
+	0.0f,
+	0.5f,
+	0.0f,
+	0.492188f,
+	0.0078125f,
+	0.5f,
+	0.0078125f,
+	0.492188f,
+	0.015625f,
+	0.5f,
+	0.015625f,
+	0.492188f,
+	0.0234375f,
+	0.5f,
+	0.0234375f,
+	0.492188f,
+	0.03125f,
+	0.5f,
+	0.03125f,
+	0.492188f,
+	0.0390625f,
+	0.5f,
+	0.0390625f,
+	0.492188f,
+	0.046875f,
+	0.5f,
+	0.046875f,
+	0.492188f,
+	0.0546875f,
+	0.5f,
+	0.0546875f,
+	0.492188f,
+	0.0625f,
+	0.5f,
+	0.0625f,
+	0.492188f,
+	0.0703125f,
+	0.5f,
+	0.0703125f,
+	0.492188f,
+	0.078125f,
+	0.5f,
+	0.078125f,
+	0.492188f,
+	0.0859375f,
+	0.5f,
+	0.0859375f,
+	0.492188f,
+	0.09375f,
+	0.5f,
+	0.09375f,
+	0.492188f,
+	0.101563f,
+	0.5f,
+	0.101563f,
+	0.492188f,
+	0.109375f,
+	0.5f,
+	0.109375f,
+	0.492188f,
+	0.117188f,
+	0.5f,
+	0.117188f,
+	0.492188f,
+	0.125f,
+	0.5f,
+	0.125f,
+	0.492188f,
+	0.132813f,
+	0.5f,
+	0.132813f,
+	0.492188f,
+	0.140625f,
+	0.5f,
+	0.140625f,
+	0.492188f,
+	0.148438f,
+	0.5f,
+	0.148438f,
+	0.492188f,
+	0.15625f,
+	0.5f,
+	0.15625f,
+	0.492188f,
+	0.164063f,
+	0.5f,
+	0.164063f,
+	0.492188f,
+	0.171875f,
+	0.5f,
+	0.171875f,
+	0.492188f,
+	0.179688f,
+	0.5f,
+	0.179688f,
+	0.492188f,
+	0.1875f,
+	0.5f,
+	0.1875f,
+	0.492188f,
+	0.195313f,
+	0.5f,
+	0.195313f,
+	0.492188f,
+	0.203125f,
+	0.5f,
+	0.203125f,
+	0.492188f,
+	0.210938f,
+	0.5f,
+	0.210938f,
+	0.492188f,
+	0.21875f,
+	0.5f,
+	0.21875f,
+	0.492188f,
+	0.226563f,
+	0.5f,
+	0.226563f,
+	0.492188f,
+	0.234375f,
+	0.5f,
+	0.234375f,
+	0.492188f,
+	0.242188f,
+	0.5f,
+	0.242188f,
+	0.492188f,
+	0.25f,
+	0.5f,
+	0.25f,
+	0.492188f,
+	0.257813f,
+	0.5f,
+	0.257813f,
+	0.492188f,
+	0.265625f,
+	0.5f,
+	0.265625f,
+	0.492188f,
+	0.273438f,
+	0.5f,
+	0.273438f,
+	0.492188f,
+	0.28125f,
+	0.5f,
+	0.28125f,
+	0.492188f,
+	0.289063f,
+	0.5f,
+	0.289063f,
+	0.492188f,
+	0.296875f,
+	0.5f,
+	0.296875f,
+	0.492188f,
+	0.304688f,
+	0.5f,
+	0.304688f,
+	0.492188f,
+	0.3125f,
+	0.5f,
+	0.3125f,
+	0.492188f,
+	0.320313f,
+	0.5f,
+	0.320313f,
+	0.492188f,
+	0.328125f,
+	0.5f,
+	0.328125f,
+	0.492188f,
+	0.335938f,
+	0.5f,
+	0.335938f,
+	0.492188f,
+	0.34375f,
+	0.5f,
+	0.34375f,
+	0.492188f,
+	0.351563f,
+	0.5f,
+	0.351563f,
+	0.492188f,
+	0.359375f,
+	0.5f,
+	0.359375f,
+	0.492188f,
+	0.367188f,
+	0.5f,
+	0.367188f,
+	0.492188f,
+	0.375f,
+	0.5f,
+	0.375f,
+	0.492188f,
+	0.382813f,
+	0.5f,
+	0.382813f,
+	0.492188f,
+	0.390625f,
+	0.5f,
+	0.390625f,
+	0.492188f,
+	0.398438f,
+	0.5f,
+	0.398438f,
+	0.492188f,
+	0.40625f,
+	0.5f,
+	0.40625f,
+	0.492188f,
+	0.414063f,
+	0.5f,
+	0.414063f,
+	0.492188f,
+	0.421875f,
+	0.5f,
+	0.421875f,
+	0.492188f,
+	0.429688f,
+	0.5f,
+	0.429688f,
+	0.492188f,
+	0.4375f,
+	0.5f,
+	0.4375f,
+	0.492188f,
+	0.445313f,
+	0.5f,
+	0.445313f,
+	0.492188f,
+	0.453125f,
+	0.5f,
+	0.453125f,
+	0.492188f,
+	0.460938f,
+	0.5f,
+	0.460938f,
+	0.492188f,
+	0.46875f,
+	0.5f,
+	0.46875f,
+	0.492188f,
+	0.476563f,
+	0.5f,
+	0.476563f,
+	0.492188f,
+	0.484375f,
+	0.5f,
+	0.484375f,
+	0.492188f,
+	0.492188f,
+	0.5f,
+	0.492188f,
+	0.492188f,
+	0.5f,
+	0.5f,
+	0.5f,
+	0.492188f,
+	0.507813f,
+	0.5f,
+	0.507813f,
+	0.492188f,
+	0.0f,
+	0.507813f,
+	0.0078125f,
+	0.507813f,
+	0.015625f,
+	0.507813f,
+	0.0234375f,
+	0.507813f,
+	0.03125f,
+	0.507813f,
+	0.0390625f,
+	0.507813f,
+	0.046875f,
+	0.507813f,
+	0.0546875f,
+	0.507813f,
+	0.0625f,
+	0.507813f,
+	0.0703125f,
+	0.507813f,
+	0.078125f,
+	0.507813f,
+	0.0859375f,
+	0.507813f,
+	0.09375f,
+	0.507813f,
+	0.101563f,
+	0.507813f,
+	0.109375f,
+	0.507813f,
+	0.117188f,
+	0.507813f,
+	0.125f,
+	0.507813f,
+	0.132813f,
+	0.507813f,
+	0.140625f,
+	0.507813f,
+	0.148438f,
+	0.507813f,
+	0.15625f,
+	0.507813f,
+	0.164063f,
+	0.507813f,
+	0.171875f,
+	0.507813f,
+	0.179688f,
+	0.507813f,
+	0.1875f,
+	0.507813f,
+	0.195313f,
+	0.507813f,
+	0.203125f,
+	0.507813f,
+	0.210938f,
+	0.507813f,
+	0.21875f,
+	0.507813f,
+	0.226563f,
+	0.507813f,
+	0.234375f,
+	0.507813f,
+	0.242188f,
+	0.507813f,
+	0.25f,
+	0.507813f,
+	0.257813f,
+	0.507813f,
+	0.265625f,
+	0.507813f,
+	0.273438f,
+	0.507813f,
+	0.28125f,
+	0.507813f,
+	0.289063f,
+	0.507813f,
+	0.296875f,
+	0.507813f,
+	0.304688f,
+	0.507813f,
+	0.3125f,
+	0.507813f,
+	0.320313f,
+	0.507813f,
+	0.328125f,
+	0.507813f,
+	0.335938f,
+	0.507813f,
+	0.34375f,
+	0.507813f,
+	0.351563f,
+	0.507813f,
+	0.359375f,
+	0.507813f,
+	0.367188f,
+	0.507813f,
+	0.375f,
+	0.507813f,
+	0.382813f,
+	0.507813f,
+	0.390625f,
+	0.507813f,
+	0.398438f,
+	0.507813f,
+	0.40625f,
+	0.507813f,
+	0.414063f,
+	0.507813f,
+	0.421875f,
+	0.507813f,
+	0.429688f,
+	0.507813f,
+	0.4375f,
+	0.507813f,
+	0.445313f,
+	0.507813f,
+	0.453125f,
+	0.507813f,
+	0.460938f,
+	0.507813f,
+	0.46875f,
+	0.507813f,
+	0.476563f,
+	0.507813f,
+	0.484375f,
+	0.507813f,
+	0.492188f,
+	0.507813f,
+	0.5f,
+	0.507813f,
+	0.507813f,
+	0.507813f,
+	0.0f,
+	0.515625f,
+	0.0078125f,
+	0.515625f,
+	0.015625f,
+	0.515625f,
+	0.0234375f,
+	0.515625f,
+	0.03125f,
+	0.515625f,
+	0.0390625f,
+	0.515625f,
+	0.046875f,
+	0.515625f,
+	0.0546875f,
+	0.515625f,
+	0.0625f,
+	0.515625f,
+	0.0703125f,
+	0.515625f,
+	0.078125f,
+	0.515625f,
+	0.0859375f,
+	0.515625f,
+	0.09375f,
+	0.515625f,
+	0.101563f,
+	0.515625f,
+	0.109375f,
+	0.515625f,
+	0.117188f,
+	0.515625f,
+	0.125f,
+	0.515625f,
+	0.132813f,
+	0.515625f,
+	0.140625f,
+	0.515625f,
+	0.148438f,
+	0.515625f,
+	0.15625f,
+	0.515625f,
+	0.164063f,
+	0.515625f,
+	0.171875f,
+	0.515625f,
+	0.179688f,
+	0.515625f,
+	0.1875f,
+	0.515625f,
+	0.195313f,
+	0.515625f,
+	0.203125f,
+	0.515625f,
+	0.210938f,
+	0.515625f,
+	0.21875f,
+	0.515625f,
+	0.226563f,
+	0.515625f,
+	0.234375f,
+	0.515625f,
+	0.242188f,
+	0.515625f,
+	0.25f,
+	0.515625f,
+	0.257813f,
+	0.515625f,
+	0.265625f,
+	0.515625f,
+	0.273438f,
+	0.515625f,
+	0.28125f,
+	0.515625f,
+	0.289063f,
+	0.515625f,
+	0.296875f,
+	0.515625f,
+	0.304688f,
+	0.515625f,
+	0.3125f,
+	0.515625f,
+	0.320313f,
+	0.515625f,
+	0.328125f,
+	0.515625f,
+	0.335938f,
+	0.515625f,
+	0.34375f,
+	0.515625f,
+	0.351563f,
+	0.515625f,
+	0.359375f,
+	0.515625f,
+	0.367188f,
+	0.515625f,
+	0.375f,
+	0.515625f,
+	0.382813f,
+	0.515625f,
+	0.390625f,
+	0.515625f,
+	0.398438f,
+	0.515625f,
+	0.40625f,
+	0.515625f,
+	0.414063f,
+	0.515625f,
+	0.421875f,
+	0.515625f,
+	0.429688f,
+	0.515625f,
+	0.4375f,
+	0.515625f,
+	0.445313f,
+	0.515625f,
+	0.453125f,
+	0.515625f,
+	0.460938f,
+	0.515625f,
+	0.46875f,
+	0.515625f,
+	0.476563f,
+	0.515625f,
+	0.484375f,
+	0.515625f,
+	0.492188f,
+	0.515625f,
+	0.5f,
+	0.515625f,
+	0.507813f,
+	0.515625f,
+	0.0f,
+	0.523438f,
+	0.0078125f,
+	0.523438f,
+	0.015625f,
+	0.523438f,
+	0.0234375f,
+	0.523438f,
+	0.03125f,
+	0.523438f,
+	0.0390625f,
+	0.523438f,
+	0.046875f,
+	0.523438f,
+	0.0546875f,
+	0.523438f,
+	0.0625f,
+	0.523438f,
+	0.0703125f,
+	0.523438f,
+	0.078125f,
+	0.523438f,
+	0.0859375f,
+	0.523438f,
+	0.09375f,
+	0.523438f,
+	0.101563f,
+	0.523438f,
+	0.109375f,
+	0.523438f,
+	0.117188f,
+	0.523438f,
+	0.125f,
+	0.523438f,
+	0.132813f,
+	0.523438f,
+	0.140625f,
+	0.523438f,
+	0.148438f,
+	0.523438f,
+	0.15625f,
+	0.523438f,
+	0.164063f,
+	0.523438f,
+	0.171875f,
+	0.523438f,
+	0.179688f,
+	0.523438f,
+	0.1875f,
+	0.523438f,
+	0.195313f,
+	0.523438f,
+	0.203125f,
+	0.523438f,
+	0.210938f,
+	0.523438f,
+	0.21875f,
+	0.523438f,
+	0.226563f,
+	0.523438f,
+	0.234375f,
+	0.523438f,
+	0.242188f,
+	0.523438f,
+	0.25f,
+	0.523438f,
+	0.257813f,
+	0.523438f,
+	0.265625f,
+	0.523438f,
+	0.273438f,
+	0.523438f,
+	0.28125f,
+	0.523438f,
+	0.289063f,
+	0.523438f,
+	0.296875f,
+	0.523438f,
+	0.304688f,
+	0.523438f,
+	0.3125f,
+	0.523438f,
+	0.320313f,
+	0.523438f,
+	0.328125f,
+	0.523438f,
+	0.335938f,
+	0.523438f,
+	0.34375f,
+	0.523438f,
+	0.351563f,
+	0.523438f,
+	0.359375f,
+	0.523438f,
+	0.367188f,
+	0.523438f,
+	0.375f,
+	0.523438f,
+	0.382813f,
+	0.523438f,
+	0.390625f,
+	0.523438f,
+	0.398438f,
+	0.523438f,
+	0.40625f,
+	0.523438f,
+	0.414063f,
+	0.523438f,
+	0.421875f,
+	0.523438f,
+	0.429688f,
+	0.523438f,
+	0.4375f,
+	0.523438f,
+	0.445313f,
+	0.523438f,
+	0.453125f,
+	0.523438f,
+	0.460938f,
+	0.523438f,
+	0.46875f,
+	0.523438f,
+	0.476563f,
+	0.523438f,
+	0.484375f,
+	0.523438f,
+	0.492188f,
+	0.523438f,
+	0.5f,
+	0.523438f,
+	0.507813f,
+	0.523438f,
+	0.0f,
+	0.53125f,
+	0.0078125f,
+	0.53125f,
+	0.015625f,
+	0.53125f,
+	0.0234375f,
+	0.53125f,
+	0.03125f,
+	0.53125f,
+	0.0390625f,
+	0.53125f,
+	0.046875f,
+	0.53125f,
+	0.0546875f,
+	0.53125f,
+	0.0625f,
+	0.53125f,
+	0.0703125f,
+	0.53125f,
+	0.078125f,
+	0.53125f,
+	0.0859375f,
+	0.53125f,
+	0.09375f,
+	0.53125f,
+	0.101563f,
+	0.53125f,
+	0.109375f,
+	0.53125f,
+	0.117188f,
+	0.53125f,
+	0.125f,
+	0.53125f,
+	0.132813f,
+	0.53125f,
+	0.140625f,
+	0.53125f,
+	0.148438f,
+	0.53125f,
+	0.15625f,
+	0.53125f,
+	0.164063f,
+	0.53125f,
+	0.171875f,
+	0.53125f,
+	0.179688f,
+	0.53125f,
+	0.1875f,
+	0.53125f,
+	0.195313f,
+	0.53125f,
+	0.203125f,
+	0.53125f,
+	0.210938f,
+	0.53125f,
+	0.21875f,
+	0.53125f,
+	0.226563f,
+	0.53125f,
+	0.234375f,
+	0.53125f,
+	0.242188f,
+	0.53125f,
+	0.25f,
+	0.53125f,
+	0.257813f,
+	0.53125f,
+	0.265625f,
+	0.53125f,
+	0.273438f,
+	0.53125f,
+	0.28125f,
+	0.53125f,
+	0.289063f,
+	0.53125f,
+	0.296875f,
+	0.53125f,
+	0.304688f,
+	0.53125f,
+	0.3125f,
+	0.53125f,
+	0.320313f,
+	0.53125f,
+	0.328125f,
+	0.53125f,
+	0.335938f,
+	0.53125f,
+	0.34375f,
+	0.53125f,
+	0.351563f,
+	0.53125f,
+	0.359375f,
+	0.53125f,
+	0.367188f,
+	0.53125f,
+	0.375f,
+	0.53125f,
+	0.382813f,
+	0.53125f,
+	0.390625f,
+	0.53125f,
+	0.398438f,
+	0.53125f,
+	0.40625f,
+	0.53125f,
+	0.414063f,
+	0.53125f,
+	0.421875f,
+	0.53125f,
+	0.429688f,
+	0.53125f,
+	0.4375f,
+	0.53125f,
+	0.445313f,
+	0.53125f,
+	0.453125f,
+	0.53125f,
+	0.460938f,
+	0.53125f,
+	0.46875f,
+	0.53125f,
+	0.476563f,
+	0.53125f,
+	0.484375f,
+	0.53125f,
+	0.492188f,
+	0.53125f,
+	0.5f,
+	0.53125f,
+	0.507813f,
+	0.53125f,
+	0.0f,
+	0.539063f,
+	0.0078125f,
+	0.539063f,
+	0.015625f,
+	0.539063f,
+	0.0234375f,
+	0.539063f,
+	0.03125f,
+	0.539063f,
+	0.0390625f,
+	0.539063f,
+	0.046875f,
+	0.539063f,
+	0.0546875f,
+	0.539063f,
+	0.0625f,
+	0.539063f,
+	0.0703125f,
+	0.539063f,
+	0.078125f,
+	0.539063f,
+	0.0859375f,
+	0.539063f,
+	0.09375f,
+	0.539063f,
+	0.101563f,
+	0.539063f,
+	0.109375f,
+	0.539063f,
+	0.117188f,
+	0.539063f,
+	0.125f,
+	0.539063f,
+	0.132813f,
+	0.539063f,
+	0.140625f,
+	0.539063f,
+	0.148438f,
+	0.539063f,
+	0.15625f,
+	0.539063f,
+	0.164063f,
+	0.539063f,
+	0.171875f,
+	0.539063f,
+	0.179688f,
+	0.539063f,
+	0.1875f,
+	0.539063f,
+	0.195313f,
+	0.539063f,
+	0.203125f,
+	0.539063f,
+	0.210938f,
+	0.539063f,
+	0.21875f,
+	0.539063f,
+	0.226563f,
+	0.539063f,
+	0.234375f,
+	0.539063f,
+	0.242188f,
+	0.539063f,
+	0.25f,
+	0.539063f,
+	0.257813f,
+	0.539063f,
+	0.265625f,
+	0.539063f,
+	0.273438f,
+	0.539063f,
+	0.28125f,
+	0.539063f,
+	0.289063f,
+	0.539063f,
+	0.296875f,
+	0.539063f,
+	0.304688f,
+	0.539063f,
+	0.3125f,
+	0.539063f,
+	0.320313f,
+	0.539063f,
+	0.328125f,
+	0.539063f,
+	0.335938f,
+	0.539063f,
+	0.34375f,
+	0.539063f,
+	0.351563f,
+	0.539063f,
+	0.359375f,
+	0.539063f,
+	0.367188f,
+	0.539063f,
+	0.375f,
+	0.539063f,
+	0.382813f,
+	0.539063f,
+	0.390625f,
+	0.539063f,
+	0.398438f,
+	0.539063f,
+	0.40625f,
+	0.539063f,
+	0.414063f,
+	0.539063f,
+	0.421875f,
+	0.539063f,
+	0.429688f,
+	0.539063f,
+	0.4375f,
+	0.539063f,
+	0.445313f,
+	0.539063f,
+	0.453125f,
+	0.539063f,
+	0.460938f,
+	0.539063f,
+	0.46875f,
+	0.539063f,
+	0.476563f,
+	0.539063f,
+	0.484375f,
+	0.539063f,
+	0.492188f,
+	0.539063f,
+	0.5f,
+	0.539063f,
+	0.507813f,
+	0.539063f,
+	0.0f,
+	0.546875f,
+	0.0078125f,
+	0.546875f,
+	0.015625f,
+	0.546875f,
+	0.0234375f,
+	0.546875f,
+	0.03125f,
+	0.546875f,
+	0.0390625f,
+	0.546875f,
+	0.046875f,
+	0.546875f,
+	0.0546875f,
+	0.546875f,
+	0.0625f,
+	0.546875f,
+	0.0703125f,
+	0.546875f,
+	0.078125f,
+	0.546875f,
+	0.0859375f,
+	0.546875f,
+	0.09375f,
+	0.546875f,
+	0.101563f,
+	0.546875f,
+	0.109375f,
+	0.546875f,
+	0.117188f,
+	0.546875f,
+	0.125f,
+	0.546875f,
+	0.132813f,
+	0.546875f,
+	0.140625f,
+	0.546875f,
+	0.148438f,
+	0.546875f,
+	0.15625f,
+	0.546875f,
+	0.164063f,
+	0.546875f,
+	0.171875f,
+	0.546875f,
+	0.179688f,
+	0.546875f,
+	0.1875f,
+	0.546875f,
+	0.195313f,
+	0.546875f,
+	0.203125f,
+	0.546875f,
+	0.210938f,
+	0.546875f,
+	0.21875f,
+	0.546875f,
+	0.226563f,
+	0.546875f,
+	0.234375f,
+	0.546875f,
+	0.242188f,
+	0.546875f,
+	0.25f,
+	0.546875f,
+	0.257813f,
+	0.546875f,
+	0.265625f,
+	0.546875f,
+	0.273438f,
+	0.546875f,
+	0.28125f,
+	0.546875f,
+	0.289063f,
+	0.546875f,
+	0.296875f,
+	0.546875f,
+	0.304688f,
+	0.546875f,
+	0.3125f,
+	0.546875f,
+	0.320313f,
+	0.546875f,
+	0.328125f,
+	0.546875f,
+	0.335938f,
+	0.546875f,
+	0.34375f,
+	0.546875f,
+	0.351563f,
+	0.546875f,
+	0.359375f,
+	0.546875f,
+	0.367188f,
+	0.546875f,
+	0.375f,
+	0.546875f,
+	0.382813f,
+	0.546875f,
+	0.390625f,
+	0.546875f,
+	0.398438f,
+	0.546875f,
+	0.40625f,
+	0.546875f,
+	0.414063f,
+	0.546875f,
+	0.421875f,
+	0.546875f,
+	0.429688f,
+	0.546875f,
+	0.4375f,
+	0.546875f,
+	0.445313f,
+	0.546875f,
+	0.453125f,
+	0.546875f,
+	0.460938f,
+	0.546875f,
+	0.46875f,
+	0.546875f,
+	0.476563f,
+	0.546875f,
+	0.484375f,
+	0.546875f,
+	0.492188f,
+	0.546875f,
+	0.5f,
+	0.546875f,
+	0.507813f,
+	0.546875f,
+	0.0f,
+	0.554688f,
+	0.0078125f,
+	0.554688f,
+	0.015625f,
+	0.554688f,
+	0.0234375f,
+	0.554688f,
+	0.03125f,
+	0.554688f,
+	0.0390625f,
+	0.554688f,
+	0.046875f,
+	0.554688f,
+	0.0546875f,
+	0.554688f,
+	0.0625f,
+	0.554688f,
+	0.0703125f,
+	0.554688f,
+	0.078125f,
+	0.554688f,
+	0.0859375f,
+	0.554688f,
+	0.09375f,
+	0.554688f,
+	0.101563f,
+	0.554688f,
+	0.109375f,
+	0.554688f,
+	0.117188f,
+	0.554688f,
+	0.125f,
+	0.554688f,
+	0.132813f,
+	0.554688f,
+	0.140625f,
+	0.554688f,
+	0.148438f,
+	0.554688f,
+	0.15625f,
+	0.554688f,
+	0.164063f,
+	0.554688f,
+	0.171875f,
+	0.554688f,
+	0.179688f,
+	0.554688f,
+	0.1875f,
+	0.554688f,
+	0.195313f,
+	0.554688f,
+	0.203125f,
+	0.554688f,
+	0.210938f,
+	0.554688f,
+	0.21875f,
+	0.554688f,
+	0.226563f,
+	0.554688f,
+	0.234375f,
+	0.554688f,
+	0.242188f,
+	0.554688f,
+	0.25f,
+	0.554688f,
+	0.257813f,
+	0.554688f,
+	0.265625f,
+	0.554688f,
+	0.273438f,
+	0.554688f,
+	0.28125f,
+	0.554688f,
+	0.289063f,
+	0.554688f,
+	0.296875f,
+	0.554688f,
+	0.304688f,
+	0.554688f,
+	0.3125f,
+	0.554688f,
+	0.320313f,
+	0.554688f,
+	0.328125f,
+	0.554688f,
+	0.335938f,
+	0.554688f,
+	0.34375f,
+	0.554688f,
+	0.351563f,
+	0.554688f,
+	0.359375f,
+	0.554688f,
+	0.367188f,
+	0.554688f,
+	0.375f,
+	0.554688f,
+	0.382813f,
+	0.554688f,
+	0.390625f,
+	0.554688f,
+	0.398438f,
+	0.554688f,
+	0.40625f,
+	0.554688f,
+	0.414063f,
+	0.554688f,
+	0.421875f,
+	0.554688f,
+	0.429688f,
+	0.554688f,
+	0.4375f,
+	0.554688f,
+	0.445313f,
+	0.554688f,
+	0.453125f,
+	0.554688f,
+	0.460938f,
+	0.554688f,
+	0.46875f,
+	0.554688f,
+	0.476563f,
+	0.554688f,
+	0.484375f,
+	0.554688f,
+	0.492188f,
+	0.554688f,
+	0.5f,
+	0.554688f,
+	0.507813f,
+	0.554688f,
+	0.0f,
+	0.5625f,
+	0.0078125f,
+	0.5625f,
+	0.015625f,
+	0.5625f,
+	0.0234375f,
+	0.5625f,
+	0.03125f,
+	0.5625f,
+	0.0390625f,
+	0.5625f,
+	0.046875f,
+	0.5625f,
+	0.0546875f,
+	0.5625f,
+	0.0625f,
+	0.5625f,
+	0.0703125f,
+	0.5625f,
+	0.078125f,
+	0.5625f,
+	0.0859375f,
+	0.5625f,
+	0.09375f,
+	0.5625f,
+	0.101563f,
+	0.5625f,
+	0.109375f,
+	0.5625f,
+	0.117188f,
+	0.5625f,
+	0.125f,
+	0.5625f,
+	0.132813f,
+	0.5625f,
+	0.140625f,
+	0.5625f,
+	0.148438f,
+	0.5625f,
+	0.15625f,
+	0.5625f,
+	0.164063f,
+	0.5625f,
+	0.171875f,
+	0.5625f,
+	0.179688f,
+	0.5625f,
+	0.1875f,
+	0.5625f,
+	0.195313f,
+	0.5625f,
+	0.203125f,
+	0.5625f,
+	0.210938f,
+	0.5625f,
+	0.21875f,
+	0.5625f,
+	0.226563f,
+	0.5625f,
+	0.234375f,
+	0.5625f,
+	0.242188f,
+	0.5625f,
+	0.25f,
+	0.5625f,
+	0.257813f,
+	0.5625f,
+	0.265625f,
+	0.5625f,
+	0.273438f,
+	0.5625f,
+	0.28125f,
+	0.5625f,
+	0.289063f,
+	0.5625f,
+	0.296875f,
+	0.5625f,
+	0.304688f,
+	0.5625f,
+	0.3125f,
+	0.5625f,
+	0.320313f,
+	0.5625f,
+	0.328125f,
+	0.5625f,
+	0.335938f,
+	0.5625f,
+	0.34375f,
+	0.5625f,
+	0.351563f,
+	0.5625f,
+	0.359375f,
+	0.5625f,
+	0.367188f,
+	0.5625f,
+	0.375f,
+	0.5625f,
+	0.382813f,
+	0.5625f,
+	0.390625f,
+	0.5625f,
+	0.398438f,
+	0.5625f,
+	0.40625f,
+	0.5625f,
+	0.414063f,
+	0.5625f,
+	0.421875f,
+	0.5625f,
+	0.429688f,
+	0.5625f,
+	0.4375f,
+	0.5625f,
+	0.445313f,
+	0.5625f,
+	0.453125f,
+	0.5625f,
+	0.460938f,
+	0.5625f,
+	0.46875f,
+	0.5625f,
+	0.476563f,
+	0.5625f,
+	0.484375f,
+	0.5625f,
+	0.492188f,
+	0.5625f,
+	0.5f,
+	0.5625f,
+	0.507813f,
+	0.5625f,
+	0.0f,
+	0.570313f,
+	0.0078125f,
+	0.570313f,
+	0.015625f,
+	0.570313f,
+	0.0234375f,
+	0.570313f,
+	0.03125f,
+	0.570313f,
+	0.0390625f,
+	0.570313f,
+	0.046875f,
+	0.570313f,
+	0.0546875f,
+	0.570313f,
+	0.0625f,
+	0.570313f,
+	0.0703125f,
+	0.570313f,
+	0.078125f,
+	0.570313f,
+	0.0859375f,
+	0.570313f,
+	0.09375f,
+	0.570313f,
+	0.101563f,
+	0.570313f,
+	0.109375f,
+	0.570313f,
+	0.117188f,
+	0.570313f,
+	0.125f,
+	0.570313f,
+	0.132813f,
+	0.570313f,
+	0.140625f,
+	0.570313f,
+	0.148438f,
+	0.570313f,
+	0.15625f,
+	0.570313f,
+	0.164063f,
+	0.570313f,
+	0.171875f,
+	0.570313f,
+	0.179688f,
+	0.570313f,
+	0.1875f,
+	0.570313f,
+	0.195313f,
+	0.570313f,
+	0.203125f,
+	0.570313f,
+	0.210938f,
+	0.570313f,
+	0.21875f,
+	0.570313f,
+	0.226563f,
+	0.570313f,
+	0.234375f,
+	0.570313f,
+	0.242188f,
+	0.570313f,
+	0.25f,
+	0.570313f,
+	0.257813f,
+	0.570313f,
+	0.265625f,
+	0.570313f,
+	0.273438f,
+	0.570313f,
+	0.28125f,
+	0.570313f,
+	0.289063f,
+	0.570313f,
+	0.296875f,
+	0.570313f,
+	0.304688f,
+	0.570313f,
+	0.3125f,
+	0.570313f,
+	0.320313f,
+	0.570313f,
+	0.328125f,
+	0.570313f,
+	0.335938f,
+	0.570313f,
+	0.34375f,
+	0.570313f,
+	0.351563f,
+	0.570313f,
+	0.359375f,
+	0.570313f,
+	0.367188f,
+	0.570313f,
+	0.375f,
+	0.570313f,
+	0.382813f,
+	0.570313f,
+	0.390625f,
+	0.570313f,
+	0.398438f,
+	0.570313f,
+	0.40625f,
+	0.570313f,
+	0.414063f,
+	0.570313f,
+	0.421875f,
+	0.570313f,
+	0.429688f,
+	0.570313f,
+	0.4375f,
+	0.570313f,
+	0.445313f,
+	0.570313f,
+	0.453125f,
+	0.570313f,
+	0.460938f,
+	0.570313f,
+	0.46875f,
+	0.570313f,
+	0.476563f,
+	0.570313f,
+	0.484375f,
+	0.570313f,
+	0.492188f,
+	0.570313f,
+	0.5f,
+	0.570313f,
+	0.507813f,
+	0.570313f,
+	0.0f,
+	0.578125f,
+	0.0078125f,
+	0.578125f,
+	0.015625f,
+	0.578125f,
+	0.0234375f,
+	0.578125f,
+	0.03125f,
+	0.578125f,
+	0.0390625f,
+	0.578125f,
+	0.046875f,
+	0.578125f,
+	0.0546875f,
+	0.578125f,
+	0.0625f,
+	0.578125f,
+	0.0703125f,
+	0.578125f,
+	0.078125f,
+	0.578125f,
+	0.0859375f,
+	0.578125f,
+	0.09375f,
+	0.578125f,
+	0.101563f,
+	0.578125f,
+	0.109375f,
+	0.578125f,
+	0.117188f,
+	0.578125f,
+	0.125f,
+	0.578125f,
+	0.132813f,
+	0.578125f,
+	0.140625f,
+	0.578125f,
+	0.148438f,
+	0.578125f,
+	0.15625f,
+	0.578125f,
+	0.164063f,
+	0.578125f,
+	0.171875f,
+	0.578125f,
+	0.179688f,
+	0.578125f,
+	0.1875f,
+	0.578125f,
+	0.195313f,
+	0.578125f,
+	0.203125f,
+	0.578125f,
+	0.210938f,
+	0.578125f,
+	0.21875f,
+	0.578125f,
+	0.226563f,
+	0.578125f,
+	0.234375f,
+	0.578125f,
+	0.242188f,
+	0.578125f,
+	0.25f,
+	0.578125f,
+	0.257813f,
+	0.578125f,
+	0.265625f,
+	0.578125f,
+	0.273438f,
+	0.578125f,
+	0.28125f,
+	0.578125f,
+	0.289063f,
+	0.578125f,
+	0.296875f,
+	0.578125f,
+	0.304688f,
+	0.578125f,
+	0.3125f,
+	0.578125f,
+	0.320313f,
+	0.578125f,
+	0.328125f,
+	0.578125f,
+	0.335938f,
+	0.578125f,
+	0.34375f,
+	0.578125f,
+	0.351563f,
+	0.578125f,
+	0.359375f,
+	0.578125f,
+	0.367188f,
+	0.578125f,
+	0.375f,
+	0.578125f,
+	0.382813f,
+	0.578125f,
+	0.390625f,
+	0.578125f,
+	0.398438f,
+	0.578125f,
+	0.40625f,
+	0.578125f,
+	0.414063f,
+	0.578125f,
+	0.421875f,
+	0.578125f,
+	0.429688f,
+	0.578125f,
+	0.4375f,
+	0.578125f,
+	0.445313f,
+	0.578125f,
+	0.453125f,
+	0.578125f,
+	0.460938f,
+	0.578125f,
+	0.46875f,
+	0.578125f,
+	0.476563f,
+	0.578125f,
+	0.484375f,
+	0.578125f,
+	0.492188f,
+	0.578125f,
+	0.5f,
+	0.578125f,
+	0.507813f,
+	0.578125f,
+	0.0f,
+	0.585938f,
+	0.0078125f,
+	0.585938f,
+	0.015625f,
+	0.585938f,
+	0.0234375f,
+	0.585938f,
+	0.03125f,
+	0.585938f,
+	0.0390625f,
+	0.585938f,
+	0.046875f,
+	0.585938f,
+	0.0546875f,
+	0.585938f,
+	0.0625f,
+	0.585938f,
+	0.0703125f,
+	0.585938f,
+	0.078125f,
+	0.585938f,
+	0.0859375f,
+	0.585938f,
+	0.09375f,
+	0.585938f,
+	0.101563f,
+	0.585938f,
+	0.109375f,
+	0.585938f,
+	0.117188f,
+	0.585938f,
+	0.125f,
+	0.585938f,
+	0.132813f,
+	0.585938f,
+	0.140625f,
+	0.585938f,
+	0.148438f,
+	0.585938f,
+	0.15625f,
+	0.585938f,
+	0.164063f,
+	0.585938f,
+	0.171875f,
+	0.585938f,
+	0.179688f,
+	0.585938f,
+	0.1875f,
+	0.585938f,
+	0.195313f,
+	0.585938f,
+	0.203125f,
+	0.585938f,
+	0.210938f,
+	0.585938f,
+	0.21875f,
+	0.585938f,
+	0.226563f,
+	0.585938f,
+	0.234375f,
+	0.585938f,
+	0.242188f,
+	0.585938f,
+	0.25f,
+	0.585938f,
+	0.257813f,
+	0.585938f,
+	0.265625f,
+	0.585938f,
+	0.273438f,
+	0.585938f,
+	0.28125f,
+	0.585938f,
+	0.289063f,
+	0.585938f,
+	0.296875f,
+	0.585938f,
+	0.304688f,
+	0.585938f,
+	0.3125f,
+	0.585938f,
+	0.320313f,
+	0.585938f,
+	0.328125f,
+	0.585938f,
+	0.335938f,
+	0.585938f,
+	0.34375f,
+	0.585938f,
+	0.351563f,
+	0.585938f,
+	0.359375f,
+	0.585938f,
+	0.367188f,
+	0.585938f,
+	0.375f,
+	0.585938f,
+	0.382813f,
+	0.585938f,
+	0.390625f,
+	0.585938f,
+	0.398438f,
+	0.585938f,
+	0.40625f,
+	0.585938f,
+	0.414063f,
+	0.585938f,
+	0.421875f,
+	0.585938f,
+	0.429688f,
+	0.585938f,
+	0.4375f,
+	0.585938f,
+	0.445313f,
+	0.585938f,
+	0.453125f,
+	0.585938f,
+	0.460938f,
+	0.585938f,
+	0.46875f,
+	0.585938f,
+	0.476563f,
+	0.585938f,
+	0.484375f,
+	0.585938f,
+	0.492188f,
+	0.585938f,
+	0.5f,
+	0.585938f,
+	0.507813f,
+	0.585938f,
+	0.0f,
+	0.59375f,
+	0.0078125f,
+	0.59375f,
+	0.015625f,
+	0.59375f,
+	0.0234375f,
+	0.59375f,
+	0.03125f,
+	0.59375f,
+	0.0390625f,
+	0.59375f,
+	0.046875f,
+	0.59375f,
+	0.0546875f,
+	0.59375f,
+	0.0625f,
+	0.59375f,
+	0.0703125f,
+	0.59375f,
+	0.078125f,
+	0.59375f,
+	0.0859375f,
+	0.59375f,
+	0.09375f,
+	0.59375f,
+	0.101563f,
+	0.59375f,
+	0.109375f,
+	0.59375f,
+	0.117188f,
+	0.59375f,
+	0.125f,
+	0.59375f,
+	0.132813f,
+	0.59375f,
+	0.140625f,
+	0.59375f,
+	0.148438f,
+	0.59375f,
+	0.15625f,
+	0.59375f,
+	0.164063f,
+	0.59375f,
+	0.171875f,
+	0.59375f,
+	0.179688f,
+	0.59375f,
+	0.1875f,
+	0.59375f,
+	0.195313f,
+	0.59375f,
+	0.203125f,
+	0.59375f,
+	0.210938f,
+	0.59375f,
+	0.21875f,
+	0.59375f,
+	0.226563f,
+	0.59375f,
+	0.234375f,
+	0.59375f,
+	0.242188f,
+	0.59375f,
+	0.25f,
+	0.59375f,
+	0.257813f,
+	0.59375f,
+	0.265625f,
+	0.59375f,
+	0.273438f,
+	0.59375f,
+	0.28125f,
+	0.59375f,
+	0.289063f,
+	0.59375f,
+	0.296875f,
+	0.59375f,
+	0.304688f,
+	0.59375f,
+	0.3125f,
+	0.59375f,
+	0.320313f,
+	0.59375f,
+	0.328125f,
+	0.59375f,
+	0.335938f,
+	0.59375f,
+	0.34375f,
+	0.59375f,
+	0.351563f,
+	0.59375f,
+	0.359375f,
+	0.59375f,
+	0.367188f,
+	0.59375f,
+	0.375f,
+	0.59375f,
+	0.382813f,
+	0.59375f,
+	0.390625f,
+	0.59375f,
+	0.398438f,
+	0.59375f,
+	0.40625f,
+	0.59375f,
+	0.414063f,
+	0.59375f,
+	0.421875f,
+	0.59375f,
+	0.429688f,
+	0.59375f,
+	0.4375f,
+	0.59375f,
+	0.445313f,
+	0.59375f,
+	0.453125f,
+	0.59375f,
+	0.460938f,
+	0.59375f,
+	0.46875f,
+	0.59375f,
+	0.476563f,
+	0.59375f,
+	0.484375f,
+	0.59375f,
+	0.492188f,
+	0.59375f,
+	0.5f,
+	0.59375f,
+	0.507813f,
+	0.59375f,
+	0.0f,
+	0.601563f,
+	0.0078125f,
+	0.601563f,
+	0.015625f,
+	0.601563f,
+	0.0234375f,
+	0.601563f,
+	0.03125f,
+	0.601563f,
+	0.0390625f,
+	0.601563f,
+	0.046875f,
+	0.601563f,
+	0.0546875f,
+	0.601563f,
+	0.0625f,
+	0.601563f,
+	0.0703125f,
+	0.601563f,
+	0.078125f,
+	0.601563f,
+	0.0859375f,
+	0.601563f,
+	0.09375f,
+	0.601563f,
+	0.101563f,
+	0.601563f,
+	0.109375f,
+	0.601563f,
+	0.117188f,
+	0.601563f,
+	0.125f,
+	0.601563f,
+	0.132813f,
+	0.601563f,
+	0.140625f,
+	0.601563f,
+	0.148438f,
+	0.601563f,
+	0.15625f,
+	0.601563f,
+	0.164063f,
+	0.601563f,
+	0.171875f,
+	0.601563f,
+	0.179688f,
+	0.601563f,
+	0.1875f,
+	0.601563f,
+	0.195313f,
+	0.601563f,
+	0.203125f,
+	0.601563f,
+	0.210938f,
+	0.601563f,
+	0.21875f,
+	0.601563f,
+	0.226563f,
+	0.601563f,
+	0.234375f,
+	0.601563f,
+	0.242188f,
+	0.601563f,
+	0.25f,
+	0.601563f,
+	0.257813f,
+	0.601563f,
+	0.265625f,
+	0.601563f,
+	0.273438f,
+	0.601563f,
+	0.28125f,
+	0.601563f,
+	0.289063f,
+	0.601563f,
+	0.296875f,
+	0.601563f,
+	0.304688f,
+	0.601563f,
+	0.3125f,
+	0.601563f,
+	0.320313f,
+	0.601563f,
+	0.328125f,
+	0.601563f,
+	0.335938f,
+	0.601563f,
+	0.34375f,
+	0.601563f,
+	0.351563f,
+	0.601563f,
+	0.359375f,
+	0.601563f,
+	0.367188f,
+	0.601563f,
+	0.375f,
+	0.601563f,
+	0.382813f,
+	0.601563f,
+	0.390625f,
+	0.601563f,
+	0.398438f,
+	0.601563f,
+	0.40625f,
+	0.601563f,
+	0.414063f,
+	0.601563f,
+	0.421875f,
+	0.601563f,
+	0.429688f,
+	0.601563f,
+	0.4375f,
+	0.601563f,
+	0.445313f,
+	0.601563f,
+	0.453125f,
+	0.601563f,
+	0.460938f,
+	0.601563f,
+	0.46875f,
+	0.601563f,
+	0.476563f,
+	0.601563f,
+	0.484375f,
+	0.601563f,
+	0.492188f,
+	0.601563f,
+	0.5f,
+	0.601563f,
+	0.507813f,
+	0.601563f,
+	0.0f,
+	0.609375f,
+	0.0078125f,
+	0.609375f,
+	0.015625f,
+	0.609375f,
+	0.0234375f,
+	0.609375f,
+	0.03125f,
+	0.609375f,
+	0.0390625f,
+	0.609375f,
+	0.046875f,
+	0.609375f,
+	0.0546875f,
+	0.609375f,
+	0.0625f,
+	0.609375f,
+	0.0703125f,
+	0.609375f,
+	0.078125f,
+	0.609375f,
+	0.0859375f,
+	0.609375f,
+	0.09375f,
+	0.609375f,
+	0.101563f,
+	0.609375f,
+	0.109375f,
+	0.609375f,
+	0.117188f,
+	0.609375f,
+	0.125f,
+	0.609375f,
+	0.132813f,
+	0.609375f,
+	0.140625f,
+	0.609375f,
+	0.148438f,
+	0.609375f,
+	0.15625f,
+	0.609375f,
+	0.164063f,
+	0.609375f,
+	0.171875f,
+	0.609375f,
+	0.179688f,
+	0.609375f,
+	0.1875f,
+	0.609375f,
+	0.195313f,
+	0.609375f,
+	0.203125f,
+	0.609375f,
+	0.210938f,
+	0.609375f,
+	0.21875f,
+	0.609375f,
+	0.226563f,
+	0.609375f,
+	0.234375f,
+	0.609375f,
+	0.242188f,
+	0.609375f,
+	0.25f,
+	0.609375f,
+	0.257813f,
+	0.609375f,
+	0.265625f,
+	0.609375f,
+	0.273438f,
+	0.609375f,
+	0.28125f,
+	0.609375f,
+	0.289063f,
+	0.609375f,
+	0.296875f,
+	0.609375f,
+	0.304688f,
+	0.609375f,
+	0.3125f,
+	0.609375f,
+	0.320313f,
+	0.609375f,
+	0.328125f,
+	0.609375f,
+	0.335938f,
+	0.609375f,
+	0.34375f,
+	0.609375f,
+	0.351563f,
+	0.609375f,
+	0.359375f,
+	0.609375f,
+	0.367188f,
+	0.609375f,
+	0.375f,
+	0.609375f,
+	0.382813f,
+	0.609375f,
+	0.390625f,
+	0.609375f,
+	0.398438f,
+	0.609375f,
+	0.40625f,
+	0.609375f,
+	0.414063f,
+	0.609375f,
+	0.421875f,
+	0.609375f,
+	0.429688f,
+	0.609375f,
+	0.4375f,
+	0.609375f,
+	0.445313f,
+	0.609375f,
+	0.453125f,
+	0.609375f,
+	0.460938f,
+	0.609375f,
+	0.46875f,
+	0.609375f,
+	0.476563f,
+	0.609375f,
+	0.484375f,
+	0.609375f,
+	0.492188f,
+	0.609375f,
+	0.5f,
+	0.609375f,
+	0.507813f,
+	0.609375f,
+	0.0f,
+	0.617188f,
+	0.0078125f,
+	0.617188f,
+	0.015625f,
+	0.617188f,
+	0.0234375f,
+	0.617188f,
+	0.03125f,
+	0.617188f,
+	0.0390625f,
+	0.617188f,
+	0.046875f,
+	0.617188f,
+	0.0546875f,
+	0.617188f,
+	0.0625f,
+	0.617188f,
+	0.0703125f,
+	0.617188f,
+	0.078125f,
+	0.617188f,
+	0.0859375f,
+	0.617188f,
+	0.09375f,
+	0.617188f,
+	0.101563f,
+	0.617188f,
+	0.109375f,
+	0.617188f,
+	0.117188f,
+	0.617188f,
+	0.125f,
+	0.617188f,
+	0.132813f,
+	0.617188f,
+	0.140625f,
+	0.617188f,
+	0.148438f,
+	0.617188f,
+	0.15625f,
+	0.617188f,
+	0.164063f,
+	0.617188f,
+	0.171875f,
+	0.617188f,
+	0.179688f,
+	0.617188f,
+	0.1875f,
+	0.617188f,
+	0.195313f,
+	0.617188f,
+	0.203125f,
+	0.617188f,
+	0.210938f,
+	0.617188f,
+	0.21875f,
+	0.617188f,
+	0.226563f,
+	0.617188f,
+	0.234375f,
+	0.617188f,
+	0.242188f,
+	0.617188f,
+	0.25f,
+	0.617188f,
+	0.257813f,
+	0.617188f,
+	0.265625f,
+	0.617188f,
+	0.273438f,
+	0.617188f,
+	0.28125f,
+	0.617188f,
+	0.289063f,
+	0.617188f,
+	0.296875f,
+	0.617188f,
+	0.304688f,
+	0.617188f,
+	0.3125f,
+	0.617188f,
+	0.320313f,
+	0.617188f,
+	0.328125f,
+	0.617188f,
+	0.335938f,
+	0.617188f,
+	0.34375f,
+	0.617188f,
+	0.351563f,
+	0.617188f,
+	0.359375f,
+	0.617188f,
+	0.367188f,
+	0.617188f,
+	0.375f,
+	0.617188f,
+	0.382813f,
+	0.617188f,
+	0.390625f,
+	0.617188f,
+	0.398438f,
+	0.617188f,
+	0.40625f,
+	0.617188f,
+	0.414063f,
+	0.617188f,
+	0.421875f,
+	0.617188f,
+	0.429688f,
+	0.617188f,
+	0.4375f,
+	0.617188f,
+	0.445313f,
+	0.617188f,
+	0.453125f,
+	0.617188f,
+	0.460938f,
+	0.617188f,
+	0.46875f,
+	0.617188f,
+	0.476563f,
+	0.617188f,
+	0.484375f,
+	0.617188f,
+	0.492188f,
+	0.617188f,
+	0.5f,
+	0.617188f,
+	0.507813f,
+	0.617188f,
+	0.0f,
+	0.625f,
+	0.0078125f,
+	0.625f,
+	0.015625f,
+	0.625f,
+	0.0234375f,
+	0.625f,
+	0.03125f,
+	0.625f,
+	0.0390625f,
+	0.625f,
+	0.046875f,
+	0.625f,
+	0.0546875f,
+	0.625f,
+	0.0625f,
+	0.625f,
+	0.0703125f,
+	0.625f,
+	0.078125f,
+	0.625f,
+	0.0859375f,
+	0.625f,
+	0.09375f,
+	0.625f,
+	0.101563f,
+	0.625f,
+	0.109375f,
+	0.625f,
+	0.117188f,
+	0.625f,
+	0.125f,
+	0.625f,
+	0.132813f,
+	0.625f,
+	0.140625f,
+	0.625f,
+	0.148438f,
+	0.625f,
+	0.15625f,
+	0.625f,
+	0.164063f,
+	0.625f,
+	0.171875f,
+	0.625f,
+	0.179688f,
+	0.625f,
+	0.1875f,
+	0.625f,
+	0.195313f,
+	0.625f,
+	0.203125f,
+	0.625f,
+	0.210938f,
+	0.625f,
+	0.21875f,
+	0.625f,
+	0.226563f,
+	0.625f,
+	0.234375f,
+	0.625f,
+	0.242188f,
+	0.625f,
+	0.25f,
+	0.625f,
+	0.257813f,
+	0.625f,
+	0.265625f,
+	0.625f,
+	0.273438f,
+	0.625f,
+	0.28125f,
+	0.625f,
+	0.289063f,
+	0.625f,
+	0.296875f,
+	0.625f,
+	0.304688f,
+	0.625f,
+	0.3125f,
+	0.625f,
+	0.320313f,
+	0.625f,
+	0.328125f,
+	0.625f,
+	0.335938f,
+	0.625f,
+	0.34375f,
+	0.625f,
+	0.351563f,
+	0.625f,
+	0.359375f,
+	0.625f,
+	0.367188f,
+	0.625f,
+	0.375f,
+	0.625f,
+	0.382813f,
+	0.625f,
+	0.390625f,
+	0.625f,
+	0.398438f,
+	0.625f,
+	0.40625f,
+	0.625f,
+	0.414063f,
+	0.625f,
+	0.421875f,
+	0.625f,
+	0.429688f,
+	0.625f,
+	0.4375f,
+	0.625f,
+	0.445313f,
+	0.625f,
+	0.453125f,
+	0.625f,
+	0.460938f,
+	0.625f,
+	0.46875f,
+	0.625f,
+	0.476563f,
+	0.625f,
+	0.484375f,
+	0.625f,
+	0.492188f,
+	0.625f,
+	0.5f,
+	0.625f,
+	0.507813f,
+	0.625f,
+	0.0f,
+	0.632813f,
+	0.0078125f,
+	0.632813f,
+	0.015625f,
+	0.632813f,
+	0.0234375f,
+	0.632813f,
+	0.03125f,
+	0.632813f,
+	0.0390625f,
+	0.632813f,
+	0.046875f,
+	0.632813f,
+	0.0546875f,
+	0.632813f,
+	0.0625f,
+	0.632813f,
+	0.0703125f,
+	0.632813f,
+	0.078125f,
+	0.632813f,
+	0.0859375f,
+	0.632813f,
+	0.09375f,
+	0.632813f,
+	0.101563f,
+	0.632813f,
+	0.109375f,
+	0.632813f,
+	0.117188f,
+	0.632813f,
+	0.125f,
+	0.632813f,
+	0.132813f,
+	0.632813f,
+	0.140625f,
+	0.632813f,
+	0.148438f,
+	0.632813f,
+	0.15625f,
+	0.632813f,
+	0.164063f,
+	0.632813f,
+	0.171875f,
+	0.632813f,
+	0.179688f,
+	0.632813f,
+	0.1875f,
+	0.632813f,
+	0.195313f,
+	0.632813f,
+	0.203125f,
+	0.632813f,
+	0.210938f,
+	0.632813f,
+	0.21875f,
+	0.632813f,
+	0.226563f,
+	0.632813f,
+	0.234375f,
+	0.632813f,
+	0.242188f,
+	0.632813f,
+	0.25f,
+	0.632813f,
+	0.257813f,
+	0.632813f,
+	0.265625f,
+	0.632813f,
+	0.273438f,
+	0.632813f,
+	0.28125f,
+	0.632813f,
+	0.289063f,
+	0.632813f,
+	0.296875f,
+	0.632813f,
+	0.304688f,
+	0.632813f,
+	0.3125f,
+	0.632813f,
+	0.320313f,
+	0.632813f,
+	0.328125f,
+	0.632813f,
+	0.335938f,
+	0.632813f,
+	0.34375f,
+	0.632813f,
+	0.351563f,
+	0.632813f,
+	0.359375f,
+	0.632813f,
+	0.367188f,
+	0.632813f,
+	0.375f,
+	0.632813f,
+	0.382813f,
+	0.632813f,
+	0.390625f,
+	0.632813f,
+	0.398438f,
+	0.632813f,
+	0.40625f,
+	0.632813f,
+	0.414063f,
+	0.632813f,
+	0.421875f,
+	0.632813f,
+	0.429688f,
+	0.632813f,
+	0.4375f,
+	0.632813f,
+	0.445313f,
+	0.632813f,
+	0.453125f,
+	0.632813f,
+	0.460938f,
+	0.632813f,
+	0.46875f,
+	0.632813f,
+	0.476563f,
+	0.632813f,
+	0.484375f,
+	0.632813f,
+	0.492188f,
+	0.632813f,
+	0.5f,
+	0.632813f,
+	0.507813f,
+	0.632813f,
+	0.0f,
+	0.640625f,
+	0.0078125f,
+	0.640625f,
+	0.015625f,
+	0.640625f,
+	0.0234375f,
+	0.640625f,
+	0.03125f,
+	0.640625f,
+	0.0390625f,
+	0.640625f,
+	0.046875f,
+	0.640625f,
+	0.0546875f,
+	0.640625f,
+	0.0625f,
+	0.640625f,
+	0.0703125f,
+	0.640625f,
+	0.078125f,
+	0.640625f,
+	0.0859375f,
+	0.640625f,
+	0.09375f,
+	0.640625f,
+	0.101563f,
+	0.640625f,
+	0.109375f,
+	0.640625f,
+	0.117188f,
+	0.640625f,
+	0.125f,
+	0.640625f,
+	0.132813f,
+	0.640625f,
+	0.140625f,
+	0.640625f,
+	0.148438f,
+	0.640625f,
+	0.15625f,
+	0.640625f,
+	0.164063f,
+	0.640625f,
+	0.171875f,
+	0.640625f,
+	0.179688f,
+	0.640625f,
+	0.1875f,
+	0.640625f,
+	0.195313f,
+	0.640625f,
+	0.203125f,
+	0.640625f,
+	0.210938f,
+	0.640625f,
+	0.21875f,
+	0.640625f,
+	0.226563f,
+	0.640625f,
+	0.234375f,
+	0.640625f,
+	0.242188f,
+	0.640625f,
+	0.25f,
+	0.640625f,
+	0.257813f,
+	0.640625f,
+	0.265625f,
+	0.640625f,
+	0.273438f,
+	0.640625f,
+	0.28125f,
+	0.640625f,
+	0.289063f,
+	0.640625f,
+	0.296875f,
+	0.640625f,
+	0.304688f,
+	0.640625f,
+	0.3125f,
+	0.640625f,
+	0.320313f,
+	0.640625f,
+	0.328125f,
+	0.640625f,
+	0.335938f,
+	0.640625f,
+	0.34375f,
+	0.640625f,
+	0.351563f,
+	0.640625f,
+	0.359375f,
+	0.640625f,
+	0.367188f,
+	0.640625f,
+	0.375f,
+	0.640625f,
+	0.382813f,
+	0.640625f,
+	0.390625f,
+	0.640625f,
+	0.398438f,
+	0.640625f,
+	0.40625f,
+	0.640625f,
+	0.414063f,
+	0.640625f,
+	0.421875f,
+	0.640625f,
+	0.429688f,
+	0.640625f,
+	0.4375f,
+	0.640625f,
+	0.445313f,
+	0.640625f,
+	0.453125f,
+	0.640625f,
+	0.460938f,
+	0.640625f,
+	0.46875f,
+	0.640625f,
+	0.476563f,
+	0.640625f,
+	0.484375f,
+	0.640625f,
+	0.492188f,
+	0.640625f,
+	0.5f,
+	0.640625f,
+	0.507813f,
+	0.640625f,
+	0.0f,
+	0.648438f,
+	0.0078125f,
+	0.648438f,
+	0.015625f,
+	0.648438f,
+	0.0234375f,
+	0.648438f,
+	0.03125f,
+	0.648438f,
+	0.0390625f,
+	0.648438f,
+	0.046875f,
+	0.648438f,
+	0.0546875f,
+	0.648438f,
+	0.0625f,
+	0.648438f,
+	0.0703125f,
+	0.648438f,
+	0.078125f,
+	0.648438f,
+	0.0859375f,
+	0.648438f,
+	0.09375f,
+	0.648438f,
+	0.101563f,
+	0.648438f,
+	0.109375f,
+	0.648438f,
+	0.117188f,
+	0.648438f,
+	0.125f,
+	0.648438f,
+	0.132813f,
+	0.648438f,
+	0.140625f,
+	0.648438f,
+	0.148438f,
+	0.648438f,
+	0.15625f,
+	0.648438f,
+	0.164063f,
+	0.648438f,
+	0.171875f,
+	0.648438f,
+	0.179688f,
+	0.648438f,
+	0.1875f,
+	0.648438f,
+	0.195313f,
+	0.648438f,
+	0.203125f,
+	0.648438f,
+	0.210938f,
+	0.648438f,
+	0.21875f,
+	0.648438f,
+	0.226563f,
+	0.648438f,
+	0.234375f,
+	0.648438f,
+	0.242188f,
+	0.648438f,
+	0.25f,
+	0.648438f,
+	0.257813f,
+	0.648438f,
+	0.265625f,
+	0.648438f,
+	0.273438f,
+	0.648438f,
+	0.28125f,
+	0.648438f,
+	0.289063f,
+	0.648438f,
+	0.296875f,
+	0.648438f,
+	0.304688f,
+	0.648438f,
+	0.3125f,
+	0.648438f,
+	0.320313f,
+	0.648438f,
+	0.328125f,
+	0.648438f,
+	0.335938f,
+	0.648438f,
+	0.34375f,
+	0.648438f,
+	0.351563f,
+	0.648438f,
+	0.359375f,
+	0.648438f,
+	0.367188f,
+	0.648438f,
+	0.375f,
+	0.648438f,
+	0.382813f,
+	0.648438f,
+	0.390625f,
+	0.648438f,
+	0.398438f,
+	0.648438f,
+	0.40625f,
+	0.648438f,
+	0.414063f,
+	0.648438f,
+	0.421875f,
+	0.648438f,
+	0.429688f,
+	0.648438f,
+	0.4375f,
+	0.648438f,
+	0.445313f,
+	0.648438f,
+	0.453125f,
+	0.648438f,
+	0.460938f,
+	0.648438f,
+	0.46875f,
+	0.648438f,
+	0.476563f,
+	0.648438f,
+	0.484375f,
+	0.648438f,
+	0.492188f,
+	0.648438f,
+	0.5f,
+	0.648438f,
+	0.507813f,
+	0.648438f,
+	0.0f,
+	0.65625f,
+	0.0078125f,
+	0.65625f,
+	0.015625f,
+	0.65625f,
+	0.0234375f,
+	0.65625f,
+	0.03125f,
+	0.65625f,
+	0.0390625f,
+	0.65625f,
+	0.046875f,
+	0.65625f,
+	0.0546875f,
+	0.65625f,
+	0.0625f,
+	0.65625f,
+	0.0703125f,
+	0.65625f,
+	0.078125f,
+	0.65625f,
+	0.0859375f,
+	0.65625f,
+	0.09375f,
+	0.65625f,
+	0.101563f,
+	0.65625f,
+	0.109375f,
+	0.65625f,
+	0.117188f,
+	0.65625f,
+	0.125f,
+	0.65625f,
+	0.132813f,
+	0.65625f,
+	0.140625f,
+	0.65625f,
+	0.148438f,
+	0.65625f,
+	0.15625f,
+	0.65625f,
+	0.164063f,
+	0.65625f,
+	0.171875f,
+	0.65625f,
+	0.179688f,
+	0.65625f,
+	0.1875f,
+	0.65625f,
+	0.195313f,
+	0.65625f,
+	0.203125f,
+	0.65625f,
+	0.210938f,
+	0.65625f,
+	0.21875f,
+	0.65625f,
+	0.226563f,
+	0.65625f,
+	0.234375f,
+	0.65625f,
+	0.242188f,
+	0.65625f,
+	0.25f,
+	0.65625f,
+	0.257813f,
+	0.65625f,
+	0.265625f,
+	0.65625f,
+	0.273438f,
+	0.65625f,
+	0.28125f,
+	0.65625f,
+	0.289063f,
+	0.65625f,
+	0.296875f,
+	0.65625f,
+	0.304688f,
+	0.65625f,
+	0.3125f,
+	0.65625f,
+	0.320313f,
+	0.65625f,
+	0.328125f,
+	0.65625f,
+	0.335938f,
+	0.65625f,
+	0.34375f,
+	0.65625f,
+	0.351563f,
+	0.65625f,
+	0.359375f,
+	0.65625f,
+	0.367188f,
+	0.65625f,
+	0.375f,
+	0.65625f,
+	0.382813f,
+	0.65625f,
+	0.390625f,
+	0.65625f,
+	0.398438f,
+	0.65625f,
+	0.40625f,
+	0.65625f,
+	0.414063f,
+	0.65625f,
+	0.421875f,
+	0.65625f,
+	0.429688f,
+	0.65625f,
+	0.4375f,
+	0.65625f,
+	0.445313f,
+	0.65625f,
+	0.453125f,
+	0.65625f,
+	0.460938f,
+	0.65625f,
+	0.46875f,
+	0.65625f,
+	0.476563f,
+	0.65625f,
+	0.484375f,
+	0.65625f,
+	0.492188f,
+	0.65625f,
+	0.5f,
+	0.65625f,
+	0.507813f,
+	0.65625f,
+	0.0f,
+	0.664063f,
+	0.0078125f,
+	0.664063f,
+	0.015625f,
+	0.664063f,
+	0.0234375f,
+	0.664063f,
+	0.03125f,
+	0.664063f,
+	0.0390625f,
+	0.664063f,
+	0.046875f,
+	0.664063f,
+	0.0546875f,
+	0.664063f,
+	0.0625f,
+	0.664063f,
+	0.0703125f,
+	0.664063f,
+	0.078125f,
+	0.664063f,
+	0.0859375f,
+	0.664063f,
+	0.09375f,
+	0.664063f,
+	0.101563f,
+	0.664063f,
+	0.109375f,
+	0.664063f,
+	0.117188f,
+	0.664063f,
+	0.125f,
+	0.664063f,
+	0.132813f,
+	0.664063f,
+	0.140625f,
+	0.664063f,
+	0.148438f,
+	0.664063f,
+	0.15625f,
+	0.664063f,
+	0.164063f,
+	0.664063f,
+	0.171875f,
+	0.664063f,
+	0.179688f,
+	0.664063f,
+	0.1875f,
+	0.664063f,
+	0.195313f,
+	0.664063f,
+	0.203125f,
+	0.664063f,
+	0.210938f,
+	0.664063f,
+	0.21875f,
+	0.664063f,
+	0.226563f,
+	0.664063f,
+	0.234375f,
+	0.664063f,
+	0.242188f,
+	0.664063f,
+	0.25f,
+	0.664063f,
+	0.257813f,
+	0.664063f,
+	0.265625f,
+	0.664063f,
+	0.273438f,
+	0.664063f,
+	0.28125f,
+	0.664063f,
+	0.289063f,
+	0.664063f,
+	0.296875f,
+	0.664063f,
+	0.304688f,
+	0.664063f,
+	0.3125f,
+	0.664063f,
+	0.320313f,
+	0.664063f,
+	0.328125f,
+	0.664063f,
+	0.335938f,
+	0.664063f,
+	0.34375f,
+	0.664063f,
+	0.351563f,
+	0.664063f,
+	0.359375f,
+	0.664063f,
+	0.367188f,
+	0.664063f,
+	0.375f,
+	0.664063f,
+	0.382813f,
+	0.664063f,
+	0.390625f,
+	0.664063f,
+	0.398438f,
+	0.664063f,
+	0.40625f,
+	0.664063f,
+	0.414063f,
+	0.664063f,
+	0.421875f,
+	0.664063f,
+	0.429688f,
+	0.664063f,
+	0.4375f,
+	0.664063f,
+	0.445313f,
+	0.664063f,
+	0.453125f,
+	0.664063f,
+	0.460938f,
+	0.664063f,
+	0.46875f,
+	0.664063f,
+	0.476563f,
+	0.664063f,
+	0.484375f,
+	0.664063f,
+	0.492188f,
+	0.664063f,
+	0.5f,
+	0.664063f,
+	0.507813f,
+	0.664063f,
+	0.0f,
+	0.671875f,
+	0.0078125f,
+	0.671875f,
+	0.015625f,
+	0.671875f,
+	0.0234375f,
+	0.671875f,
+	0.03125f,
+	0.671875f,
+	0.0390625f,
+	0.671875f,
+	0.046875f,
+	0.671875f,
+	0.0546875f,
+	0.671875f,
+	0.0625f,
+	0.671875f,
+	0.0703125f,
+	0.671875f,
+	0.078125f,
+	0.671875f,
+	0.0859375f,
+	0.671875f,
+	0.09375f,
+	0.671875f,
+	0.101563f,
+	0.671875f,
+	0.109375f,
+	0.671875f,
+	0.117188f,
+	0.671875f,
+	0.125f,
+	0.671875f,
+	0.132813f,
+	0.671875f,
+	0.140625f,
+	0.671875f,
+	0.148438f,
+	0.671875f,
+	0.15625f,
+	0.671875f,
+	0.164063f,
+	0.671875f,
+	0.171875f,
+	0.671875f,
+	0.179688f,
+	0.671875f,
+	0.1875f,
+	0.671875f,
+	0.195313f,
+	0.671875f,
+	0.203125f,
+	0.671875f,
+	0.210938f,
+	0.671875f,
+	0.21875f,
+	0.671875f,
+	0.226563f,
+	0.671875f,
+	0.234375f,
+	0.671875f,
+	0.242188f,
+	0.671875f,
+	0.25f,
+	0.671875f,
+	0.257813f,
+	0.671875f,
+	0.265625f,
+	0.671875f,
+	0.273438f,
+	0.671875f,
+	0.28125f,
+	0.671875f,
+	0.289063f,
+	0.671875f,
+	0.296875f,
+	0.671875f,
+	0.304688f,
+	0.671875f,
+	0.3125f,
+	0.671875f,
+	0.320313f,
+	0.671875f,
+	0.328125f,
+	0.671875f,
+	0.335938f,
+	0.671875f,
+	0.34375f,
+	0.671875f,
+	0.351563f,
+	0.671875f,
+	0.359375f,
+	0.671875f,
+	0.367188f,
+	0.671875f,
+	0.375f,
+	0.671875f,
+	0.382813f,
+	0.671875f,
+	0.390625f,
+	0.671875f,
+	0.398438f,
+	0.671875f,
+	0.40625f,
+	0.671875f,
+	0.414063f,
+	0.671875f,
+	0.421875f,
+	0.671875f,
+	0.429688f,
+	0.671875f,
+	0.4375f,
+	0.671875f,
+	0.445313f,
+	0.671875f,
+	0.453125f,
+	0.671875f,
+	0.460938f,
+	0.671875f,
+	0.46875f,
+	0.671875f,
+	0.476563f,
+	0.671875f,
+	0.484375f,
+	0.671875f,
+	0.492188f,
+	0.671875f,
+	0.5f,
+	0.671875f,
+	0.507813f,
+	0.671875f,
+	0.0f,
+	0.679688f,
+	0.0078125f,
+	0.679688f,
+	0.015625f,
+	0.679688f,
+	0.0234375f,
+	0.679688f,
+	0.03125f,
+	0.679688f,
+	0.0390625f,
+	0.679688f,
+	0.046875f,
+	0.679688f,
+	0.0546875f,
+	0.679688f,
+	0.0625f,
+	0.679688f,
+	0.0703125f,
+	0.679688f,
+	0.078125f,
+	0.679688f,
+	0.0859375f,
+	0.679688f,
+	0.09375f,
+	0.679688f,
+	0.101563f,
+	0.679688f,
+	0.109375f,
+	0.679688f,
+	0.117188f,
+	0.679688f,
+	0.125f,
+	0.679688f,
+	0.132813f,
+	0.679688f,
+	0.140625f,
+	0.679688f,
+	0.148438f,
+	0.679688f,
+	0.15625f,
+	0.679688f,
+	0.164063f,
+	0.679688f,
+	0.171875f,
+	0.679688f,
+	0.179688f,
+	0.679688f,
+	0.1875f,
+	0.679688f,
+	0.195313f,
+	0.679688f,
+	0.203125f,
+	0.679688f,
+	0.210938f,
+	0.679688f,
+	0.21875f,
+	0.679688f,
+	0.226563f,
+	0.679688f,
+	0.234375f,
+	0.679688f,
+	0.242188f,
+	0.679688f,
+	0.25f,
+	0.679688f,
+	0.257813f,
+	0.679688f,
+	0.265625f,
+	0.679688f,
+	0.273438f,
+	0.679688f,
+	0.28125f,
+	0.679688f,
+	0.289063f,
+	0.679688f,
+	0.296875f,
+	0.679688f,
+	0.304688f,
+	0.679688f,
+	0.3125f,
+	0.679688f,
+	0.320313f,
+	0.679688f,
+	0.328125f,
+	0.679688f,
+	0.335938f,
+	0.679688f,
+	0.34375f,
+	0.679688f,
+	0.351563f,
+	0.679688f,
+	0.359375f,
+	0.679688f,
+	0.367188f,
+	0.679688f,
+	0.375f,
+	0.679688f,
+	0.382813f,
+	0.679688f,
+	0.390625f,
+	0.679688f,
+	0.398438f,
+	0.679688f,
+	0.40625f,
+	0.679688f,
+	0.414063f,
+	0.679688f,
+	0.421875f,
+	0.679688f,
+	0.429688f,
+	0.679688f,
+	0.4375f,
+	0.679688f,
+	0.445313f,
+	0.679688f,
+	0.453125f,
+	0.679688f,
+	0.460938f,
+	0.679688f,
+	0.46875f,
+	0.679688f,
+	0.476563f,
+	0.679688f,
+	0.484375f,
+	0.679688f,
+	0.492188f,
+	0.679688f,
+	0.5f,
+	0.679688f,
+	0.507813f,
+	0.679688f,
+	0.0f,
+	0.6875f,
+	0.0078125f,
+	0.6875f,
+	0.015625f,
+	0.6875f,
+	0.0234375f,
+	0.6875f,
+	0.03125f,
+	0.6875f,
+	0.0390625f,
+	0.6875f,
+	0.046875f,
+	0.6875f,
+	0.0546875f,
+	0.6875f,
+	0.0625f,
+	0.6875f,
+	0.0703125f,
+	0.6875f,
+	0.078125f,
+	0.6875f,
+	0.0859375f,
+	0.6875f,
+	0.09375f,
+	0.6875f,
+	0.101563f,
+	0.6875f,
+	0.109375f,
+	0.6875f,
+	0.117188f,
+	0.6875f,
+	0.125f,
+	0.6875f,
+	0.132813f,
+	0.6875f,
+	0.140625f,
+	0.6875f,
+	0.148438f,
+	0.6875f,
+	0.15625f,
+	0.6875f,
+	0.164063f,
+	0.6875f,
+	0.171875f,
+	0.6875f,
+	0.179688f,
+	0.6875f,
+	0.1875f,
+	0.6875f,
+	0.195313f,
+	0.6875f,
+	0.203125f,
+	0.6875f,
+	0.210938f,
+	0.6875f,
+	0.21875f,
+	0.6875f,
+	0.226563f,
+	0.6875f,
+	0.234375f,
+	0.6875f,
+	0.242188f,
+	0.6875f,
+	0.25f,
+	0.6875f,
+	0.257813f,
+	0.6875f,
+	0.265625f,
+	0.6875f,
+	0.273438f,
+	0.6875f,
+	0.28125f,
+	0.6875f,
+	0.289063f,
+	0.6875f,
+	0.296875f,
+	0.6875f,
+	0.304688f,
+	0.6875f,
+	0.3125f,
+	0.6875f,
+	0.320313f,
+	0.6875f,
+	0.328125f,
+	0.6875f,
+	0.335938f,
+	0.6875f,
+	0.34375f,
+	0.6875f,
+	0.351563f,
+	0.6875f,
+	0.359375f,
+	0.6875f,
+	0.367188f,
+	0.6875f,
+	0.375f,
+	0.6875f,
+	0.382813f,
+	0.6875f,
+	0.390625f,
+	0.6875f,
+	0.398438f,
+	0.6875f,
+	0.40625f,
+	0.6875f,
+	0.414063f,
+	0.6875f,
+	0.421875f,
+	0.6875f,
+	0.429688f,
+	0.6875f,
+	0.4375f,
+	0.6875f,
+	0.445313f,
+	0.6875f,
+	0.453125f,
+	0.6875f,
+	0.460938f,
+	0.6875f,
+	0.46875f,
+	0.6875f,
+	0.476563f,
+	0.6875f,
+	0.484375f,
+	0.6875f,
+	0.492188f,
+	0.6875f,
+	0.5f,
+	0.6875f,
+	0.507813f,
+	0.6875f,
+	0.0f,
+	0.695313f,
+	0.0078125f,
+	0.695313f,
+	0.015625f,
+	0.695313f,
+	0.0234375f,
+	0.695313f,
+	0.03125f,
+	0.695313f,
+	0.0390625f,
+	0.695313f,
+	0.046875f,
+	0.695313f,
+	0.0546875f,
+	0.695313f,
+	0.0625f,
+	0.695313f,
+	0.0703125f,
+	0.695313f,
+	0.078125f,
+	0.695313f,
+	0.0859375f,
+	0.695313f,
+	0.09375f,
+	0.695313f,
+	0.101563f,
+	0.695313f,
+	0.109375f,
+	0.695313f,
+	0.117188f,
+	0.695313f,
+	0.125f,
+	0.695313f,
+	0.132813f,
+	0.695313f,
+	0.140625f,
+	0.695313f,
+	0.148438f,
+	0.695313f,
+	0.15625f,
+	0.695313f,
+	0.164063f,
+	0.695313f,
+	0.171875f,
+	0.695313f,
+	0.179688f,
+	0.695313f,
+	0.1875f,
+	0.695313f,
+	0.195313f,
+	0.695313f,
+	0.203125f,
+	0.695313f,
+	0.210938f,
+	0.695313f,
+	0.21875f,
+	0.695313f,
+	0.226563f,
+	0.695313f,
+	0.234375f,
+	0.695313f,
+	0.242188f,
+	0.695313f,
+	0.25f,
+	0.695313f,
+	0.257813f,
+	0.695313f,
+	0.265625f,
+	0.695313f,
+	0.273438f,
+	0.695313f,
+	0.28125f,
+	0.695313f,
+	0.289063f,
+	0.695313f,
+	0.296875f,
+	0.695313f,
+	0.304688f,
+	0.695313f,
+	0.3125f,
+	0.695313f,
+	0.320313f,
+	0.695313f,
+	0.328125f,
+	0.695313f,
+	0.335938f,
+	0.695313f,
+	0.34375f,
+	0.695313f,
+	0.351563f,
+	0.695313f,
+	0.359375f,
+	0.695313f,
+	0.367188f,
+	0.695313f,
+	0.375f,
+	0.695313f,
+	0.382813f,
+	0.695313f,
+	0.390625f,
+	0.695313f,
+	0.398438f,
+	0.695313f,
+	0.40625f,
+	0.695313f,
+	0.414063f,
+	0.695313f,
+	0.421875f,
+	0.695313f,
+	0.429688f,
+	0.695313f,
+	0.4375f,
+	0.695313f,
+	0.445313f,
+	0.695313f,
+	0.453125f,
+	0.695313f,
+	0.460938f,
+	0.695313f,
+	0.46875f,
+	0.695313f,
+	0.476563f,
+	0.695313f,
+	0.484375f,
+	0.695313f,
+	0.492188f,
+	0.695313f,
+	0.5f,
+	0.695313f,
+	0.507813f,
+	0.695313f,
+	0.0f,
+	0.703125f,
+	0.0078125f,
+	0.703125f,
+	0.015625f,
+	0.703125f,
+	0.0234375f,
+	0.703125f,
+	0.03125f,
+	0.703125f,
+	0.0390625f,
+	0.703125f,
+	0.046875f,
+	0.703125f,
+	0.0546875f,
+	0.703125f,
+	0.0625f,
+	0.703125f,
+	0.0703125f,
+	0.703125f,
+	0.078125f,
+	0.703125f,
+	0.0859375f,
+	0.703125f,
+	0.09375f,
+	0.703125f,
+	0.101563f,
+	0.703125f,
+	0.109375f,
+	0.703125f,
+	0.117188f,
+	0.703125f,
+	0.125f,
+	0.703125f,
+	0.132813f,
+	0.703125f,
+	0.140625f,
+	0.703125f,
+	0.148438f,
+	0.703125f,
+	0.15625f,
+	0.703125f,
+	0.164063f,
+	0.703125f,
+	0.171875f,
+	0.703125f,
+	0.179688f,
+	0.703125f,
+	0.1875f,
+	0.703125f,
+	0.195313f,
+	0.703125f,
+	0.203125f,
+	0.703125f,
+	0.210938f,
+	0.703125f,
+	0.21875f,
+	0.703125f,
+	0.226563f,
+	0.703125f,
+	0.234375f,
+	0.703125f,
+	0.242188f,
+	0.703125f,
+	0.25f,
+	0.703125f,
+	0.257813f,
+	0.703125f,
+	0.265625f,
+	0.703125f,
+	0.273438f,
+	0.703125f,
+	0.28125f,
+	0.703125f,
+	0.289063f,
+	0.703125f,
+	0.296875f,
+	0.703125f,
+	0.304688f,
+	0.703125f,
+	0.3125f,
+	0.703125f,
+	0.320313f,
+	0.703125f,
+	0.328125f,
+	0.703125f,
+	0.335938f,
+	0.703125f,
+	0.34375f,
+	0.703125f,
+	0.351563f,
+	0.703125f,
+	0.359375f,
+	0.703125f,
+	0.367188f,
+	0.703125f,
+	0.375f,
+	0.703125f,
+	0.382813f,
+	0.703125f,
+	0.390625f,
+	0.703125f,
+	0.398438f,
+	0.703125f,
+	0.40625f,
+	0.703125f,
+	0.414063f,
+	0.703125f,
+	0.421875f,
+	0.703125f,
+	0.429688f,
+	0.703125f,
+	0.4375f,
+	0.703125f,
+	0.445313f,
+	0.703125f,
+	0.453125f,
+	0.703125f,
+	0.460938f,
+	0.703125f,
+	0.46875f,
+	0.703125f,
+	0.476563f,
+	0.703125f,
+	0.484375f,
+	0.703125f,
+	0.492188f,
+	0.703125f,
+	0.5f,
+	0.703125f,
+	0.507813f,
+	0.703125f,
+	0.0f,
+	0.710938f,
+	0.0078125f,
+	0.710938f,
+	0.015625f,
+	0.710938f,
+	0.0234375f,
+	0.710938f,
+	0.03125f,
+	0.710938f,
+	0.0390625f,
+	0.710938f,
+	0.046875f,
+	0.710938f,
+	0.0546875f,
+	0.710938f,
+	0.0625f,
+	0.710938f,
+	0.0703125f,
+	0.710938f,
+	0.078125f,
+	0.710938f,
+	0.0859375f,
+	0.710938f,
+	0.09375f,
+	0.710938f,
+	0.101563f,
+	0.710938f,
+	0.109375f,
+	0.710938f,
+	0.117188f,
+	0.710938f,
+	0.125f,
+	0.710938f,
+	0.132813f,
+	0.710938f,
+	0.140625f,
+	0.710938f,
+	0.148438f,
+	0.710938f,
+	0.15625f,
+	0.710938f,
+	0.164063f,
+	0.710938f,
+	0.171875f,
+	0.710938f,
+	0.179688f,
+	0.710938f,
+	0.1875f,
+	0.710938f,
+	0.195313f,
+	0.710938f,
+	0.203125f,
+	0.710938f,
+	0.210938f,
+	0.710938f,
+	0.21875f,
+	0.710938f,
+	0.226563f,
+	0.710938f,
+	0.234375f,
+	0.710938f,
+	0.242188f,
+	0.710938f,
+	0.25f,
+	0.710938f,
+	0.257813f,
+	0.710938f,
+	0.265625f,
+	0.710938f,
+	0.273438f,
+	0.710938f,
+	0.28125f,
+	0.710938f,
+	0.289063f,
+	0.710938f,
+	0.296875f,
+	0.710938f,
+	0.304688f,
+	0.710938f,
+	0.3125f,
+	0.710938f,
+	0.320313f,
+	0.710938f,
+	0.328125f,
+	0.710938f,
+	0.335938f,
+	0.710938f,
+	0.34375f,
+	0.710938f,
+	0.351563f,
+	0.710938f,
+	0.359375f,
+	0.710938f,
+	0.367188f,
+	0.710938f,
+	0.375f,
+	0.710938f,
+	0.382813f,
+	0.710938f,
+	0.390625f,
+	0.710938f,
+	0.398438f,
+	0.710938f,
+	0.40625f,
+	0.710938f,
+	0.414063f,
+	0.710938f,
+	0.421875f,
+	0.710938f,
+	0.429688f,
+	0.710938f,
+	0.4375f,
+	0.710938f,
+	0.445313f,
+	0.710938f,
+	0.453125f,
+	0.710938f,
+	0.460938f,
+	0.710938f,
+	0.46875f,
+	0.710938f,
+	0.476563f,
+	0.710938f,
+	0.484375f,
+	0.710938f,
+	0.492188f,
+	0.710938f,
+	0.5f,
+	0.710938f,
+	0.507813f,
+	0.710938f,
+	0.0f,
+	0.71875f,
+	0.0078125f,
+	0.71875f,
+	0.015625f,
+	0.71875f,
+	0.0234375f,
+	0.71875f,
+	0.03125f,
+	0.71875f,
+	0.0390625f,
+	0.71875f,
+	0.046875f,
+	0.71875f,
+	0.0546875f,
+	0.71875f,
+	0.0625f,
+	0.71875f,
+	0.0703125f,
+	0.71875f,
+	0.078125f,
+	0.71875f,
+	0.0859375f,
+	0.71875f,
+	0.09375f,
+	0.71875f,
+	0.101563f,
+	0.71875f,
+	0.109375f,
+	0.71875f,
+	0.117188f,
+	0.71875f,
+	0.125f,
+	0.71875f,
+	0.132813f,
+	0.71875f,
+	0.140625f,
+	0.71875f,
+	0.148438f,
+	0.71875f,
+	0.15625f,
+	0.71875f,
+	0.164063f,
+	0.71875f,
+	0.171875f,
+	0.71875f,
+	0.179688f,
+	0.71875f,
+	0.1875f,
+	0.71875f,
+	0.195313f,
+	0.71875f,
+	0.203125f,
+	0.71875f,
+	0.210938f,
+	0.71875f,
+	0.21875f,
+	0.71875f,
+	0.226563f,
+	0.71875f,
+	0.234375f,
+	0.71875f,
+	0.242188f,
+	0.71875f,
+	0.25f,
+	0.71875f,
+	0.257813f,
+	0.71875f,
+	0.265625f,
+	0.71875f,
+	0.273438f,
+	0.71875f,
+	0.28125f,
+	0.71875f,
+	0.289063f,
+	0.71875f,
+	0.296875f,
+	0.71875f,
+	0.304688f,
+	0.71875f,
+	0.3125f,
+	0.71875f,
+	0.320313f,
+	0.71875f,
+	0.328125f,
+	0.71875f,
+	0.335938f,
+	0.71875f,
+	0.34375f,
+	0.71875f,
+	0.351563f,
+	0.71875f,
+	0.359375f,
+	0.71875f,
+	0.367188f,
+	0.71875f,
+	0.375f,
+	0.71875f,
+	0.382813f,
+	0.71875f,
+	0.390625f,
+	0.71875f,
+	0.398438f,
+	0.71875f,
+	0.40625f,
+	0.71875f,
+	0.414063f,
+	0.71875f,
+	0.421875f,
+	0.71875f,
+	0.429688f,
+	0.71875f,
+	0.4375f,
+	0.71875f,
+	0.445313f,
+	0.71875f,
+	0.453125f,
+	0.71875f,
+	0.460938f,
+	0.71875f,
+	0.46875f,
+	0.71875f,
+	0.476563f,
+	0.71875f,
+	0.484375f,
+	0.71875f,
+	0.492188f,
+	0.71875f,
+	0.5f,
+	0.71875f,
+	0.507813f,
+	0.71875f,
+	0.0f,
+	0.726563f,
+	0.0078125f,
+	0.726563f,
+	0.015625f,
+	0.726563f,
+	0.0234375f,
+	0.726563f,
+	0.03125f,
+	0.726563f,
+	0.0390625f,
+	0.726563f,
+	0.046875f,
+	0.726563f,
+	0.0546875f,
+	0.726563f,
+	0.0625f,
+	0.726563f,
+	0.0703125f,
+	0.726563f,
+	0.078125f,
+	0.726563f,
+	0.0859375f,
+	0.726563f,
+	0.09375f,
+	0.726563f,
+	0.101563f,
+	0.726563f,
+	0.109375f,
+	0.726563f,
+	0.117188f,
+	0.726563f,
+	0.125f,
+	0.726563f,
+	0.132813f,
+	0.726563f,
+	0.140625f,
+	0.726563f,
+	0.148438f,
+	0.726563f,
+	0.15625f,
+	0.726563f,
+	0.164063f,
+	0.726563f,
+	0.171875f,
+	0.726563f,
+	0.179688f,
+	0.726563f,
+	0.1875f,
+	0.726563f,
+	0.195313f,
+	0.726563f,
+	0.203125f,
+	0.726563f,
+	0.210938f,
+	0.726563f,
+	0.21875f,
+	0.726563f,
+	0.226563f,
+	0.726563f,
+	0.234375f,
+	0.726563f,
+	0.242188f,
+	0.726563f,
+	0.25f,
+	0.726563f,
+	0.257813f,
+	0.726563f,
+	0.265625f,
+	0.726563f,
+	0.273438f,
+	0.726563f,
+	0.28125f,
+	0.726563f,
+	0.289063f,
+	0.726563f,
+	0.296875f,
+	0.726563f,
+	0.304688f,
+	0.726563f,
+	0.3125f,
+	0.726563f,
+	0.320313f,
+	0.726563f,
+	0.328125f,
+	0.726563f,
+	0.335938f,
+	0.726563f,
+	0.34375f,
+	0.726563f,
+	0.351563f,
+	0.726563f,
+	0.359375f,
+	0.726563f,
+	0.367188f,
+	0.726563f,
+	0.375f,
+	0.726563f,
+	0.382813f,
+	0.726563f,
+	0.390625f,
+	0.726563f,
+	0.398438f,
+	0.726563f,
+	0.40625f,
+	0.726563f,
+	0.414063f,
+	0.726563f,
+	0.421875f,
+	0.726563f,
+	0.429688f,
+	0.726563f,
+	0.4375f,
+	0.726563f,
+	0.445313f,
+	0.726563f,
+	0.453125f,
+	0.726563f,
+	0.460938f,
+	0.726563f,
+	0.46875f,
+	0.726563f,
+	0.476563f,
+	0.726563f,
+	0.484375f,
+	0.726563f,
+	0.492188f,
+	0.726563f,
+	0.5f,
+	0.726563f,
+	0.507813f,
+	0.726563f,
+	0.0f,
+	0.734375f,
+	0.0078125f,
+	0.734375f,
+	0.015625f,
+	0.734375f,
+	0.0234375f,
+	0.734375f,
+	0.03125f,
+	0.734375f,
+	0.0390625f,
+	0.734375f,
+	0.046875f,
+	0.734375f,
+	0.0546875f,
+	0.734375f,
+	0.0625f,
+	0.734375f,
+	0.0703125f,
+	0.734375f,
+	0.078125f,
+	0.734375f,
+	0.0859375f,
+	0.734375f,
+	0.09375f,
+	0.734375f,
+	0.101563f,
+	0.734375f,
+	0.109375f,
+	0.734375f,
+	0.117188f,
+	0.734375f,
+	0.125f,
+	0.734375f,
+	0.132813f,
+	0.734375f,
+	0.140625f,
+	0.734375f,
+	0.148438f,
+	0.734375f,
+	0.15625f,
+	0.734375f,
+	0.164063f,
+	0.734375f,
+	0.171875f,
+	0.734375f,
+	0.179688f,
+	0.734375f,
+	0.1875f,
+	0.734375f,
+	0.195313f,
+	0.734375f,
+	0.203125f,
+	0.734375f,
+	0.210938f,
+	0.734375f,
+	0.21875f,
+	0.734375f,
+	0.226563f,
+	0.734375f,
+	0.234375f,
+	0.734375f,
+	0.242188f,
+	0.734375f,
+	0.25f,
+	0.734375f,
+	0.257813f,
+	0.734375f,
+	0.265625f,
+	0.734375f,
+	0.273438f,
+	0.734375f,
+	0.28125f,
+	0.734375f,
+	0.289063f,
+	0.734375f,
+	0.296875f,
+	0.734375f,
+	0.304688f,
+	0.734375f,
+	0.3125f,
+	0.734375f,
+	0.320313f,
+	0.734375f,
+	0.328125f,
+	0.734375f,
+	0.335938f,
+	0.734375f,
+	0.34375f,
+	0.734375f,
+	0.351563f,
+	0.734375f,
+	0.359375f,
+	0.734375f,
+	0.367188f,
+	0.734375f,
+	0.375f,
+	0.734375f,
+	0.382813f,
+	0.734375f,
+	0.390625f,
+	0.734375f,
+	0.398438f,
+	0.734375f,
+	0.40625f,
+	0.734375f,
+	0.414063f,
+	0.734375f,
+	0.421875f,
+	0.734375f,
+	0.429688f,
+	0.734375f,
+	0.4375f,
+	0.734375f,
+	0.445313f,
+	0.734375f,
+	0.453125f,
+	0.734375f,
+	0.460938f,
+	0.734375f,
+	0.46875f,
+	0.734375f,
+	0.476563f,
+	0.734375f,
+	0.484375f,
+	0.734375f,
+	0.492188f,
+	0.734375f,
+	0.5f,
+	0.734375f,
+	0.507813f,
+	0.734375f,
+	0.0f,
+	0.742188f,
+	0.0078125f,
+	0.742188f,
+	0.015625f,
+	0.742188f,
+	0.0234375f,
+	0.742188f,
+	0.03125f,
+	0.742188f,
+	0.0390625f,
+	0.742188f,
+	0.046875f,
+	0.742188f,
+	0.0546875f,
+	0.742188f,
+	0.0625f,
+	0.742188f,
+	0.0703125f,
+	0.742188f,
+	0.078125f,
+	0.742188f,
+	0.0859375f,
+	0.742188f,
+	0.09375f,
+	0.742188f,
+	0.101563f,
+	0.742188f,
+	0.109375f,
+	0.742188f,
+	0.117188f,
+	0.742188f,
+	0.125f,
+	0.742188f,
+	0.132813f,
+	0.742188f,
+	0.140625f,
+	0.742188f,
+	0.148438f,
+	0.742188f,
+	0.15625f,
+	0.742188f,
+	0.164063f,
+	0.742188f,
+	0.171875f,
+	0.742188f,
+	0.179688f,
+	0.742188f,
+	0.1875f,
+	0.742188f,
+	0.195313f,
+	0.742188f,
+	0.203125f,
+	0.742188f,
+	0.210938f,
+	0.742188f,
+	0.21875f,
+	0.742188f,
+	0.226563f,
+	0.742188f,
+	0.234375f,
+	0.742188f,
+	0.242188f,
+	0.742188f,
+	0.25f,
+	0.742188f,
+	0.257813f,
+	0.742188f,
+	0.265625f,
+	0.742188f,
+	0.273438f,
+	0.742188f,
+	0.28125f,
+	0.742188f,
+	0.289063f,
+	0.742188f,
+	0.296875f,
+	0.742188f,
+	0.304688f,
+	0.742188f,
+	0.3125f,
+	0.742188f,
+	0.320313f,
+	0.742188f,
+	0.328125f,
+	0.742188f,
+	0.335938f,
+	0.742188f,
+	0.34375f,
+	0.742188f,
+	0.351563f,
+	0.742188f,
+	0.359375f,
+	0.742188f,
+	0.367188f,
+	0.742188f,
+	0.375f,
+	0.742188f,
+	0.382813f,
+	0.742188f,
+	0.390625f,
+	0.742188f,
+	0.398438f,
+	0.742188f,
+	0.40625f,
+	0.742188f,
+	0.414063f,
+	0.742188f,
+	0.421875f,
+	0.742188f,
+	0.429688f,
+	0.742188f,
+	0.4375f,
+	0.742188f,
+	0.445313f,
+	0.742188f,
+	0.453125f,
+	0.742188f,
+	0.460938f,
+	0.742188f,
+	0.46875f,
+	0.742188f,
+	0.476563f,
+	0.742188f,
+	0.484375f,
+	0.742188f,
+	0.492188f,
+	0.742188f,
+	0.5f,
+	0.742188f,
+	0.507813f,
+	0.742188f,
+	0.0f,
+	0.75f,
+	0.0078125f,
+	0.75f,
+	0.015625f,
+	0.75f,
+	0.0234375f,
+	0.75f,
+	0.03125f,
+	0.75f,
+	0.0390625f,
+	0.75f,
+	0.046875f,
+	0.75f,
+	0.0546875f,
+	0.75f,
+	0.0625f,
+	0.75f,
+	0.0703125f,
+	0.75f,
+	0.078125f,
+	0.75f,
+	0.0859375f,
+	0.75f,
+	0.09375f,
+	0.75f,
+	0.101563f,
+	0.75f,
+	0.109375f,
+	0.75f,
+	0.117188f,
+	0.75f,
+	0.125f,
+	0.75f,
+	0.132813f,
+	0.75f,
+	0.140625f,
+	0.75f,
+	0.148438f,
+	0.75f,
+	0.15625f,
+	0.75f,
+	0.164063f,
+	0.75f,
+	0.171875f,
+	0.75f,
+	0.179688f,
+	0.75f,
+	0.1875f,
+	0.75f,
+	0.195313f,
+	0.75f,
+	0.203125f,
+	0.75f,
+	0.210938f,
+	0.75f,
+	0.21875f,
+	0.75f,
+	0.226563f,
+	0.75f,
+	0.234375f,
+	0.75f,
+	0.242188f,
+	0.75f,
+	0.25f,
+	0.75f,
+	0.257813f,
+	0.75f,
+	0.265625f,
+	0.75f,
+	0.273438f,
+	0.75f,
+	0.28125f,
+	0.75f,
+	0.289063f,
+	0.75f,
+	0.296875f,
+	0.75f,
+	0.304688f,
+	0.75f,
+	0.3125f,
+	0.75f,
+	0.320313f,
+	0.75f,
+	0.328125f,
+	0.75f,
+	0.335938f,
+	0.75f,
+	0.34375f,
+	0.75f,
+	0.351563f,
+	0.75f,
+	0.359375f,
+	0.75f,
+	0.367188f,
+	0.75f,
+	0.375f,
+	0.75f,
+	0.382813f,
+	0.75f,
+	0.390625f,
+	0.75f,
+	0.398438f,
+	0.75f,
+	0.40625f,
+	0.75f,
+	0.414063f,
+	0.75f,
+	0.421875f,
+	0.75f,
+	0.429688f,
+	0.75f,
+	0.4375f,
+	0.75f,
+	0.445313f,
+	0.75f,
+	0.453125f,
+	0.75f,
+	0.460938f,
+	0.75f,
+	0.46875f,
+	0.75f,
+	0.476563f,
+	0.75f,
+	0.484375f,
+	0.75f,
+	0.492188f,
+	0.75f,
+	0.5f,
+	0.75f,
+	0.507813f,
+	0.75f,
+};
+
+unsigned short Landscape05Idx[] = {
+	0,
+	1,
+	2,
+	3,
+	2,
+	1,
+	2,
+	3,
+	4,
+	5,
+	4,
+	3,
+	4,
+	5,
+	6,
+	7,
+	6,
+	5,
+	6,
+	7,
+	8,
+	9,
+	8,
+	7,
+	8,
+	9,
+	10,
+	11,
+	10,
+	9,
+	10,
+	11,
+	12,
+	13,
+	12,
+	11,
+	12,
+	13,
+	14,
+	15,
+	14,
+	13,
+	14,
+	15,
+	16,
+	17,
+	16,
+	15,
+	16,
+	17,
+	18,
+	19,
+	18,
+	17,
+	18,
+	19,
+	20,
+	21,
+	20,
+	19,
+	20,
+	21,
+	22,
+	23,
+	22,
+	21,
+	22,
+	23,
+	24,
+	25,
+	24,
+	23,
+	24,
+	25,
+	26,
+	27,
+	26,
+	25,
+	26,
+	27,
+	28,
+	29,
+	28,
+	27,
+	28,
+	29,
+	30,
+	31,
+	30,
+	29,
+	30,
+	31,
+	32,
+	33,
+	32,
+	31,
+	32,
+	33,
+	34,
+	35,
+	34,
+	33,
+	34,
+	35,
+	36,
+	37,
+	36,
+	35,
+	36,
+	37,
+	38,
+	39,
+	38,
+	37,
+	38,
+	39,
+	40,
+	41,
+	40,
+	39,
+	40,
+	41,
+	42,
+	43,
+	42,
+	41,
+	42,
+	43,
+	44,
+	45,
+	44,
+	43,
+	44,
+	45,
+	46,
+	47,
+	46,
+	45,
+	46,
+	47,
+	48,
+	49,
+	48,
+	47,
+	48,
+	49,
+	50,
+	51,
+	50,
+	49,
+	50,
+	51,
+	52,
+	53,
+	52,
+	51,
+	52,
+	53,
+	54,
+	55,
+	54,
+	53,
+	54,
+	55,
+	56,
+	57,
+	56,
+	55,
+	56,
+	57,
+	58,
+	59,
+	58,
+	57,
+	58,
+	59,
+	60,
+	61,
+	60,
+	59,
+	60,
+	61,
+	62,
+	63,
+	62,
+	61,
+	62,
+	63,
+	64,
+	65,
+	64,
+	63,
+	64,
+	65,
+	66,
+	67,
+	66,
+	65,
+	66,
+	67,
+	68,
+	69,
+	68,
+	67,
+	68,
+	69,
+	70,
+	71,
+	70,
+	69,
+	70,
+	71,
+	72,
+	73,
+	72,
+	71,
+	72,
+	73,
+	74,
+	75,
+	74,
+	73,
+	74,
+	75,
+	76,
+	77,
+	76,
+	75,
+	76,
+	77,
+	78,
+	79,
+	78,
+	77,
+	78,
+	79,
+	80,
+	81,
+	80,
+	79,
+	80,
+	81,
+	82,
+	83,
+	82,
+	81,
+	82,
+	83,
+	84,
+	85,
+	84,
+	83,
+	84,
+	85,
+	86,
+	87,
+	86,
+	85,
+	86,
+	87,
+	88,
+	89,
+	88,
+	87,
+	88,
+	89,
+	90,
+	91,
+	90,
+	89,
+	90,
+	91,
+	92,
+	93,
+	92,
+	91,
+	92,
+	93,
+	94,
+	95,
+	94,
+	93,
+	94,
+	95,
+	96,
+	97,
+	96,
+	95,
+	96,
+	97,
+	98,
+	99,
+	98,
+	97,
+	98,
+	99,
+	100,
+	101,
+	100,
+	99,
+	100,
+	101,
+	102,
+	103,
+	102,
+	101,
+	102,
+	103,
+	104,
+	105,
+	104,
+	103,
+	104,
+	105,
+	106,
+	107,
+	106,
+	105,
+	106,
+	107,
+	108,
+	109,
+	108,
+	107,
+	108,
+	109,
+	110,
+	111,
+	110,
+	109,
+	110,
+	111,
+	112,
+	113,
+	112,
+	111,
+	112,
+	113,
+	114,
+	115,
+	114,
+	113,
+	114,
+	115,
+	116,
+	117,
+	116,
+	115,
+	116,
+	117,
+	118,
+	119,
+	118,
+	117,
+	118,
+	119,
+	120,
+	121,
+	120,
+	119,
+	120,
+	121,
+	122,
+	123,
+	122,
+	121,
+	122,
+	123,
+	124,
+	125,
+	124,
+	123,
+	124,
+	125,
+	126,
+	127,
+	126,
+	125,
+	126,
+	127,
+	128,
+	129,
+	128,
+	127,
+	128,
+	129,
+	130,
+	131,
+	130,
+	129,
+	132,
+	0,
+	133,
+	2,
+	133,
+	0,
+	133,
+	2,
+	134,
+	4,
+	134,
+	2,
+	134,
+	4,
+	135,
+	6,
+	135,
+	4,
+	135,
+	6,
+	136,
+	8,
+	136,
+	6,
+	136,
+	8,
+	137,
+	10,
+	137,
+	8,
+	137,
+	10,
+	138,
+	12,
+	138,
+	10,
+	138,
+	12,
+	139,
+	14,
+	139,
+	12,
+	139,
+	14,
+	140,
+	16,
+	140,
+	14,
+	140,
+	16,
+	141,
+	18,
+	141,
+	16,
+	141,
+	18,
+	142,
+	20,
+	142,
+	18,
+	142,
+	20,
+	143,
+	22,
+	143,
+	20,
+	143,
+	22,
+	144,
+	24,
+	144,
+	22,
+	144,
+	24,
+	145,
+	26,
+	145,
+	24,
+	145,
+	26,
+	146,
+	28,
+	146,
+	26,
+	146,
+	28,
+	147,
+	30,
+	147,
+	28,
+	147,
+	30,
+	148,
+	32,
+	148,
+	30,
+	148,
+	32,
+	149,
+	34,
+	149,
+	32,
+	149,
+	34,
+	150,
+	36,
+	150,
+	34,
+	150,
+	36,
+	151,
+	38,
+	151,
+	36,
+	151,
+	38,
+	152,
+	40,
+	152,
+	38,
+	152,
+	40,
+	153,
+	42,
+	153,
+	40,
+	153,
+	42,
+	154,
+	44,
+	154,
+	42,
+	154,
+	44,
+	155,
+	46,
+	155,
+	44,
+	155,
+	46,
+	156,
+	48,
+	156,
+	46,
+	156,
+	48,
+	157,
+	50,
+	157,
+	48,
+	157,
+	50,
+	158,
+	52,
+	158,
+	50,
+	158,
+	52,
+	159,
+	54,
+	159,
+	52,
+	159,
+	54,
+	160,
+	56,
+	160,
+	54,
+	160,
+	56,
+	161,
+	58,
+	161,
+	56,
+	161,
+	58,
+	162,
+	60,
+	162,
+	58,
+	162,
+	60,
+	163,
+	62,
+	163,
+	60,
+	163,
+	62,
+	164,
+	64,
+	164,
+	62,
+	164,
+	64,
+	165,
+	66,
+	165,
+	64,
+	165,
+	66,
+	166,
+	68,
+	166,
+	66,
+	166,
+	68,
+	167,
+	70,
+	167,
+	68,
+	167,
+	70,
+	168,
+	72,
+	168,
+	70,
+	168,
+	72,
+	169,
+	74,
+	169,
+	72,
+	169,
+	74,
+	170,
+	76,
+	170,
+	74,
+	170,
+	76,
+	171,
+	78,
+	171,
+	76,
+	171,
+	78,
+	172,
+	80,
+	172,
+	78,
+	172,
+	80,
+	173,
+	82,
+	173,
+	80,
+	173,
+	82,
+	174,
+	84,
+	174,
+	82,
+	174,
+	84,
+	175,
+	86,
+	175,
+	84,
+	175,
+	86,
+	176,
+	88,
+	176,
+	86,
+	176,
+	88,
+	177,
+	90,
+	177,
+	88,
+	177,
+	90,
+	178,
+	92,
+	178,
+	90,
+	178,
+	92,
+	179,
+	94,
+	179,
+	92,
+	179,
+	94,
+	180,
+	96,
+	180,
+	94,
+	180,
+	96,
+	181,
+	98,
+	181,
+	96,
+	181,
+	98,
+	182,
+	100,
+	182,
+	98,
+	182,
+	100,
+	183,
+	102,
+	183,
+	100,
+	183,
+	102,
+	184,
+	104,
+	184,
+	102,
+	184,
+	104,
+	185,
+	106,
+	185,
+	104,
+	185,
+	106,
+	186,
+	108,
+	186,
+	106,
+	186,
+	108,
+	187,
+	110,
+	187,
+	108,
+	187,
+	110,
+	188,
+	112,
+	188,
+	110,
+	188,
+	112,
+	189,
+	114,
+	189,
+	112,
+	189,
+	114,
+	190,
+	116,
+	190,
+	114,
+	190,
+	116,
+	191,
+	118,
+	191,
+	116,
+	191,
+	118,
+	192,
+	120,
+	192,
+	118,
+	192,
+	120,
+	193,
+	122,
+	193,
+	120,
+	193,
+	122,
+	194,
+	124,
+	194,
+	122,
+	194,
+	124,
+	195,
+	126,
+	195,
+	124,
+	195,
+	126,
+	196,
+	128,
+	196,
+	126,
+	196,
+	128,
+	197,
+	130,
+	197,
+	128,
+	198,
+	132,
+	199,
+	133,
+	199,
+	132,
+	199,
+	133,
+	200,
+	134,
+	200,
+	133,
+	200,
+	134,
+	201,
+	135,
+	201,
+	134,
+	201,
+	135,
+	202,
+	136,
+	202,
+	135,
+	202,
+	136,
+	203,
+	137,
+	203,
+	136,
+	203,
+	137,
+	204,
+	138,
+	204,
+	137,
+	204,
+	138,
+	205,
+	139,
+	205,
+	138,
+	205,
+	139,
+	206,
+	140,
+	206,
+	139,
+	206,
+	140,
+	207,
+	141,
+	207,
+	140,
+	207,
+	141,
+	208,
+	142,
+	208,
+	141,
+	208,
+	142,
+	209,
+	143,
+	209,
+	142,
+	209,
+	143,
+	210,
+	144,
+	210,
+	143,
+	210,
+	144,
+	211,
+	145,
+	211,
+	144,
+	211,
+	145,
+	212,
+	146,
+	212,
+	145,
+	212,
+	146,
+	213,
+	147,
+	213,
+	146,
+	213,
+	147,
+	214,
+	148,
+	214,
+	147,
+	214,
+	148,
+	215,
+	149,
+	215,
+	148,
+	215,
+	149,
+	216,
+	150,
+	216,
+	149,
+	216,
+	150,
+	217,
+	151,
+	217,
+	150,
+	217,
+	151,
+	218,
+	152,
+	218,
+	151,
+	218,
+	152,
+	219,
+	153,
+	219,
+	152,
+	219,
+	153,
+	220,
+	154,
+	220,
+	153,
+	220,
+	154,
+	221,
+	155,
+	221,
+	154,
+	221,
+	155,
+	222,
+	156,
+	222,
+	155,
+	222,
+	156,
+	223,
+	157,
+	223,
+	156,
+	223,
+	157,
+	224,
+	158,
+	224,
+	157,
+	224,
+	158,
+	225,
+	159,
+	225,
+	158,
+	225,
+	159,
+	226,
+	160,
+	226,
+	159,
+	226,
+	160,
+	227,
+	161,
+	227,
+	160,
+	227,
+	161,
+	228,
+	162,
+	228,
+	161,
+	228,
+	162,
+	229,
+	163,
+	229,
+	162,
+	229,
+	163,
+	230,
+	164,
+	230,
+	163,
+	230,
+	164,
+	231,
+	165,
+	231,
+	164,
+	231,
+	165,
+	232,
+	166,
+	232,
+	165,
+	232,
+	166,
+	233,
+	167,
+	233,
+	166,
+	233,
+	167,
+	234,
+	168,
+	234,
+	167,
+	234,
+	168,
+	235,
+	169,
+	235,
+	168,
+	235,
+	169,
+	236,
+	170,
+	236,
+	169,
+	236,
+	170,
+	237,
+	171,
+	237,
+	170,
+	237,
+	171,
+	238,
+	172,
+	238,
+	171,
+	238,
+	172,
+	239,
+	173,
+	239,
+	172,
+	239,
+	173,
+	240,
+	174,
+	240,
+	173,
+	240,
+	174,
+	241,
+	175,
+	241,
+	174,
+	241,
+	175,
+	242,
+	176,
+	242,
+	175,
+	242,
+	176,
+	243,
+	177,
+	243,
+	176,
+	243,
+	177,
+	244,
+	178,
+	244,
+	177,
+	244,
+	178,
+	245,
+	179,
+	245,
+	178,
+	245,
+	179,
+	246,
+	180,
+	246,
+	179,
+	246,
+	180,
+	247,
+	181,
+	247,
+	180,
+	247,
+	181,
+	248,
+	182,
+	248,
+	181,
+	248,
+	182,
+	249,
+	183,
+	249,
+	182,
+	249,
+	183,
+	250,
+	184,
+	250,
+	183,
+	250,
+	184,
+	251,
+	185,
+	251,
+	184,
+	251,
+	185,
+	252,
+	186,
+	252,
+	185,
+	252,
+	186,
+	253,
+	187,
+	253,
+	186,
+	253,
+	187,
+	254,
+	188,
+	254,
+	187,
+	254,
+	188,
+	255,
+	189,
+	255,
+	188,
+	255,
+	189,
+	256,
+	190,
+	256,
+	189,
+	256,
+	190,
+	257,
+	191,
+	257,
+	190,
+	257,
+	191,
+	258,
+	192,
+	258,
+	191,
+	258,
+	192,
+	259,
+	193,
+	259,
+	192,
+	259,
+	193,
+	260,
+	194,
+	260,
+	193,
+	260,
+	194,
+	261,
+	195,
+	261,
+	194,
+	261,
+	195,
+	262,
+	196,
+	262,
+	195,
+	262,
+	196,
+	263,
+	197,
+	263,
+	196,
+	264,
+	198,
+	265,
+	199,
+	265,
+	198,
+	265,
+	199,
+	266,
+	200,
+	266,
+	199,
+	266,
+	200,
+	267,
+	201,
+	267,
+	200,
+	267,
+	201,
+	268,
+	202,
+	268,
+	201,
+	268,
+	202,
+	269,
+	203,
+	269,
+	202,
+	269,
+	203,
+	270,
+	204,
+	270,
+	203,
+	270,
+	204,
+	271,
+	205,
+	271,
+	204,
+	271,
+	205,
+	272,
+	206,
+	272,
+	205,
+	272,
+	206,
+	273,
+	207,
+	273,
+	206,
+	273,
+	207,
+	274,
+	208,
+	274,
+	207,
+	274,
+	208,
+	275,
+	209,
+	275,
+	208,
+	275,
+	209,
+	276,
+	210,
+	276,
+	209,
+	276,
+	210,
+	277,
+	211,
+	277,
+	210,
+	277,
+	211,
+	278,
+	212,
+	278,
+	211,
+	278,
+	212,
+	279,
+	213,
+	279,
+	212,
+	279,
+	213,
+	280,
+	214,
+	280,
+	213,
+	280,
+	214,
+	281,
+	215,
+	281,
+	214,
+	281,
+	215,
+	282,
+	216,
+	282,
+	215,
+	282,
+	216,
+	283,
+	217,
+	283,
+	216,
+	283,
+	217,
+	284,
+	218,
+	284,
+	217,
+	284,
+	218,
+	285,
+	219,
+	285,
+	218,
+	285,
+	219,
+	286,
+	220,
+	286,
+	219,
+	286,
+	220,
+	287,
+	221,
+	287,
+	220,
+	287,
+	221,
+	288,
+	222,
+	288,
+	221,
+	288,
+	222,
+	289,
+	223,
+	289,
+	222,
+	289,
+	223,
+	290,
+	224,
+	290,
+	223,
+	290,
+	224,
+	291,
+	225,
+	291,
+	224,
+	291,
+	225,
+	292,
+	226,
+	292,
+	225,
+	292,
+	226,
+	293,
+	227,
+	293,
+	226,
+	293,
+	227,
+	294,
+	228,
+	294,
+	227,
+	294,
+	228,
+	295,
+	229,
+	295,
+	228,
+	295,
+	229,
+	296,
+	230,
+	296,
+	229,
+	296,
+	230,
+	297,
+	231,
+	297,
+	230,
+	297,
+	231,
+	298,
+	232,
+	298,
+	231,
+	298,
+	232,
+	299,
+	233,
+	299,
+	232,
+	299,
+	233,
+	300,
+	234,
+	300,
+	233,
+	300,
+	234,
+	301,
+	235,
+	301,
+	234,
+	301,
+	235,
+	302,
+	236,
+	302,
+	235,
+	302,
+	236,
+	303,
+	237,
+	303,
+	236,
+	303,
+	237,
+	304,
+	238,
+	304,
+	237,
+	304,
+	238,
+	305,
+	239,
+	305,
+	238,
+	305,
+	239,
+	306,
+	240,
+	306,
+	239,
+	306,
+	240,
+	307,
+	241,
+	307,
+	240,
+	307,
+	241,
+	308,
+	242,
+	308,
+	241,
+	308,
+	242,
+	309,
+	243,
+	309,
+	242,
+	309,
+	243,
+	310,
+	244,
+	310,
+	243,
+	310,
+	244,
+	311,
+	245,
+	311,
+	244,
+	311,
+	245,
+	312,
+	246,
+	312,
+	245,
+	312,
+	246,
+	313,
+	247,
+	313,
+	246,
+	313,
+	247,
+	314,
+	248,
+	314,
+	247,
+	314,
+	248,
+	315,
+	249,
+	315,
+	248,
+	315,
+	249,
+	316,
+	250,
+	316,
+	249,
+	316,
+	250,
+	317,
+	251,
+	317,
+	250,
+	317,
+	251,
+	318,
+	252,
+	318,
+	251,
+	318,
+	252,
+	319,
+	253,
+	319,
+	252,
+	319,
+	253,
+	320,
+	254,
+	320,
+	253,
+	320,
+	254,
+	321,
+	255,
+	321,
+	254,
+	321,
+	255,
+	322,
+	256,
+	322,
+	255,
+	322,
+	256,
+	323,
+	257,
+	323,
+	256,
+	323,
+	257,
+	324,
+	258,
+	324,
+	257,
+	324,
+	258,
+	325,
+	259,
+	325,
+	258,
+	325,
+	259,
+	326,
+	260,
+	326,
+	259,
+	326,
+	260,
+	327,
+	261,
+	327,
+	260,
+	327,
+	261,
+	328,
+	262,
+	328,
+	261,
+	328,
+	262,
+	329,
+	263,
+	329,
+	262,
+	330,
+	264,
+	331,
+	265,
+	331,
+	264,
+	331,
+	265,
+	332,
+	266,
+	332,
+	265,
+	332,
+	266,
+	333,
+	267,
+	333,
+	266,
+	333,
+	267,
+	334,
+	268,
+	334,
+	267,
+	334,
+	268,
+	335,
+	269,
+	335,
+	268,
+	335,
+	269,
+	336,
+	270,
+	336,
+	269,
+	336,
+	270,
+	337,
+	271,
+	337,
+	270,
+	337,
+	271,
+	338,
+	272,
+	338,
+	271,
+	338,
+	272,
+	339,
+	273,
+	339,
+	272,
+	339,
+	273,
+	340,
+	274,
+	340,
+	273,
+	340,
+	274,
+	341,
+	275,
+	341,
+	274,
+	341,
+	275,
+	342,
+	276,
+	342,
+	275,
+	342,
+	276,
+	343,
+	277,
+	343,
+	276,
+	343,
+	277,
+	344,
+	278,
+	344,
+	277,
+	344,
+	278,
+	345,
+	279,
+	345,
+	278,
+	345,
+	279,
+	346,
+	280,
+	346,
+	279,
+	346,
+	280,
+	347,
+	281,
+	347,
+	280,
+	347,
+	281,
+	348,
+	282,
+	348,
+	281,
+	348,
+	282,
+	349,
+	283,
+	349,
+	282,
+	349,
+	283,
+	350,
+	284,
+	350,
+	283,
+	350,
+	284,
+	351,
+	285,
+	351,
+	284,
+	351,
+	285,
+	352,
+	286,
+	352,
+	285,
+	352,
+	286,
+	353,
+	287,
+	353,
+	286,
+	353,
+	287,
+	354,
+	288,
+	354,
+	287,
+	354,
+	288,
+	355,
+	289,
+	355,
+	288,
+	355,
+	289,
+	356,
+	290,
+	356,
+	289,
+	356,
+	290,
+	357,
+	291,
+	357,
+	290,
+	357,
+	291,
+	358,
+	292,
+	358,
+	291,
+	358,
+	292,
+	359,
+	293,
+	359,
+	292,
+	359,
+	293,
+	360,
+	294,
+	360,
+	293,
+	360,
+	294,
+	361,
+	295,
+	361,
+	294,
+	361,
+	295,
+	362,
+	296,
+	362,
+	295,
+	362,
+	296,
+	363,
+	297,
+	363,
+	296,
+	363,
+	297,
+	364,
+	298,
+	364,
+	297,
+	364,
+	298,
+	365,
+	299,
+	365,
+	298,
+	365,
+	299,
+	366,
+	300,
+	366,
+	299,
+	366,
+	300,
+	367,
+	301,
+	367,
+	300,
+	367,
+	301,
+	368,
+	302,
+	368,
+	301,
+	368,
+	302,
+	369,
+	303,
+	369,
+	302,
+	369,
+	303,
+	370,
+	304,
+	370,
+	303,
+	370,
+	304,
+	371,
+	305,
+	371,
+	304,
+	371,
+	305,
+	372,
+	306,
+	372,
+	305,
+	372,
+	306,
+	373,
+	307,
+	373,
+	306,
+	373,
+	307,
+	374,
+	308,
+	374,
+	307,
+	374,
+	308,
+	375,
+	309,
+	375,
+	308,
+	375,
+	309,
+	376,
+	310,
+	376,
+	309,
+	376,
+	310,
+	377,
+	311,
+	377,
+	310,
+	377,
+	311,
+	378,
+	312,
+	378,
+	311,
+	378,
+	312,
+	379,
+	313,
+	379,
+	312,
+	379,
+	313,
+	380,
+	314,
+	380,
+	313,
+	380,
+	314,
+	381,
+	315,
+	381,
+	314,
+	381,
+	315,
+	382,
+	316,
+	382,
+	315,
+	382,
+	316,
+	383,
+	317,
+	383,
+	316,
+	383,
+	317,
+	384,
+	318,
+	384,
+	317,
+	384,
+	318,
+	385,
+	319,
+	385,
+	318,
+	385,
+	319,
+	386,
+	320,
+	386,
+	319,
+	386,
+	320,
+	387,
+	321,
+	387,
+	320,
+	387,
+	321,
+	388,
+	322,
+	388,
+	321,
+	388,
+	322,
+	389,
+	323,
+	389,
+	322,
+	389,
+	323,
+	390,
+	324,
+	390,
+	323,
+	390,
+	324,
+	391,
+	325,
+	391,
+	324,
+	391,
+	325,
+	392,
+	326,
+	392,
+	325,
+	392,
+	326,
+	393,
+	327,
+	393,
+	326,
+	393,
+	327,
+	394,
+	328,
+	394,
+	327,
+	394,
+	328,
+	395,
+	329,
+	395,
+	328,
+	396,
+	330,
+	397,
+	331,
+	397,
+	330,
+	397,
+	331,
+	398,
+	332,
+	398,
+	331,
+	398,
+	332,
+	399,
+	333,
+	399,
+	332,
+	399,
+	333,
+	400,
+	334,
+	400,
+	333,
+	400,
+	334,
+	401,
+	335,
+	401,
+	334,
+	401,
+	335,
+	402,
+	336,
+	402,
+	335,
+	402,
+	336,
+	403,
+	337,
+	403,
+	336,
+	403,
+	337,
+	404,
+	338,
+	404,
+	337,
+	404,
+	338,
+	405,
+	339,
+	405,
+	338,
+	405,
+	339,
+	406,
+	340,
+	406,
+	339,
+	406,
+	340,
+	407,
+	341,
+	407,
+	340,
+	407,
+	341,
+	408,
+	342,
+	408,
+	341,
+	408,
+	342,
+	409,
+	343,
+	409,
+	342,
+	409,
+	343,
+	410,
+	344,
+	410,
+	343,
+	410,
+	344,
+	411,
+	345,
+	411,
+	344,
+	411,
+	345,
+	412,
+	346,
+	412,
+	345,
+	412,
+	346,
+	413,
+	347,
+	413,
+	346,
+	413,
+	347,
+	414,
+	348,
+	414,
+	347,
+	414,
+	348,
+	415,
+	349,
+	415,
+	348,
+	415,
+	349,
+	416,
+	350,
+	416,
+	349,
+	416,
+	350,
+	417,
+	351,
+	417,
+	350,
+	417,
+	351,
+	418,
+	352,
+	418,
+	351,
+	418,
+	352,
+	419,
+	353,
+	419,
+	352,
+	419,
+	353,
+	420,
+	354,
+	420,
+	353,
+	420,
+	354,
+	421,
+	355,
+	421,
+	354,
+	421,
+	355,
+	422,
+	356,
+	422,
+	355,
+	422,
+	356,
+	423,
+	357,
+	423,
+	356,
+	423,
+	357,
+	424,
+	358,
+	424,
+	357,
+	424,
+	358,
+	425,
+	359,
+	425,
+	358,
+	425,
+	359,
+	426,
+	360,
+	426,
+	359,
+	426,
+	360,
+	427,
+	361,
+	427,
+	360,
+	427,
+	361,
+	428,
+	362,
+	428,
+	361,
+	428,
+	362,
+	429,
+	363,
+	429,
+	362,
+	429,
+	363,
+	430,
+	364,
+	430,
+	363,
+	430,
+	364,
+	431,
+	365,
+	431,
+	364,
+	431,
+	365,
+	432,
+	366,
+	432,
+	365,
+	432,
+	366,
+	433,
+	367,
+	433,
+	366,
+	433,
+	367,
+	434,
+	368,
+	434,
+	367,
+	434,
+	368,
+	435,
+	369,
+	435,
+	368,
+	435,
+	369,
+	436,
+	370,
+	436,
+	369,
+	436,
+	370,
+	437,
+	371,
+	437,
+	370,
+	437,
+	371,
+	438,
+	372,
+	438,
+	371,
+	438,
+	372,
+	439,
+	373,
+	439,
+	372,
+	439,
+	373,
+	440,
+	374,
+	440,
+	373,
+	440,
+	374,
+	441,
+	375,
+	441,
+	374,
+	441,
+	375,
+	442,
+	376,
+	442,
+	375,
+	442,
+	376,
+	443,
+	377,
+	443,
+	376,
+	443,
+	377,
+	444,
+	378,
+	444,
+	377,
+	444,
+	378,
+	445,
+	379,
+	445,
+	378,
+	445,
+	379,
+	446,
+	380,
+	446,
+	379,
+	446,
+	380,
+	447,
+	381,
+	447,
+	380,
+	447,
+	381,
+	448,
+	382,
+	448,
+	381,
+	448,
+	382,
+	449,
+	383,
+	449,
+	382,
+	449,
+	383,
+	450,
+	384,
+	450,
+	383,
+	450,
+	384,
+	451,
+	385,
+	451,
+	384,
+	451,
+	385,
+	452,
+	386,
+	452,
+	385,
+	452,
+	386,
+	453,
+	387,
+	453,
+	386,
+	453,
+	387,
+	454,
+	388,
+	454,
+	387,
+	454,
+	388,
+	455,
+	389,
+	455,
+	388,
+	455,
+	389,
+	456,
+	390,
+	456,
+	389,
+	456,
+	390,
+	457,
+	391,
+	457,
+	390,
+	457,
+	391,
+	458,
+	392,
+	458,
+	391,
+	458,
+	392,
+	459,
+	393,
+	459,
+	392,
+	459,
+	393,
+	460,
+	394,
+	460,
+	393,
+	460,
+	394,
+	461,
+	395,
+	461,
+	394,
+	462,
+	396,
+	463,
+	397,
+	463,
+	396,
+	463,
+	397,
+	464,
+	398,
+	464,
+	397,
+	464,
+	398,
+	465,
+	399,
+	465,
+	398,
+	465,
+	399,
+	466,
+	400,
+	466,
+	399,
+	466,
+	400,
+	467,
+	401,
+	467,
+	400,
+	467,
+	401,
+	468,
+	402,
+	468,
+	401,
+	468,
+	402,
+	469,
+	403,
+	469,
+	402,
+	469,
+	403,
+	470,
+	404,
+	470,
+	403,
+	470,
+	404,
+	471,
+	405,
+	471,
+	404,
+	471,
+	405,
+	472,
+	406,
+	472,
+	405,
+	472,
+	406,
+	473,
+	407,
+	473,
+	406,
+	473,
+	407,
+	474,
+	408,
+	474,
+	407,
+	474,
+	408,
+	475,
+	409,
+	475,
+	408,
+	475,
+	409,
+	476,
+	410,
+	476,
+	409,
+	476,
+	410,
+	477,
+	411,
+	477,
+	410,
+	477,
+	411,
+	478,
+	412,
+	478,
+	411,
+	478,
+	412,
+	479,
+	413,
+	479,
+	412,
+	479,
+	413,
+	480,
+	414,
+	480,
+	413,
+	480,
+	414,
+	481,
+	415,
+	481,
+	414,
+	481,
+	415,
+	482,
+	416,
+	482,
+	415,
+	482,
+	416,
+	483,
+	417,
+	483,
+	416,
+	483,
+	417,
+	484,
+	418,
+	484,
+	417,
+	484,
+	418,
+	485,
+	419,
+	485,
+	418,
+	485,
+	419,
+	486,
+	420,
+	486,
+	419,
+	486,
+	420,
+	487,
+	421,
+	487,
+	420,
+	487,
+	421,
+	488,
+	422,
+	488,
+	421,
+	488,
+	422,
+	489,
+	423,
+	489,
+	422,
+	489,
+	423,
+	490,
+	424,
+	490,
+	423,
+	490,
+	424,
+	491,
+	425,
+	491,
+	424,
+	491,
+	425,
+	492,
+	426,
+	492,
+	425,
+	492,
+	426,
+	493,
+	427,
+	493,
+	426,
+	493,
+	427,
+	494,
+	428,
+	494,
+	427,
+	494,
+	428,
+	495,
+	429,
+	495,
+	428,
+	495,
+	429,
+	496,
+	430,
+	496,
+	429,
+	496,
+	430,
+	497,
+	431,
+	497,
+	430,
+	497,
+	431,
+	498,
+	432,
+	498,
+	431,
+	498,
+	432,
+	499,
+	433,
+	499,
+	432,
+	499,
+	433,
+	500,
+	434,
+	500,
+	433,
+	500,
+	434,
+	501,
+	435,
+	501,
+	434,
+	501,
+	435,
+	502,
+	436,
+	502,
+	435,
+	502,
+	436,
+	503,
+	437,
+	503,
+	436,
+	503,
+	437,
+	504,
+	438,
+	504,
+	437,
+	504,
+	438,
+	505,
+	439,
+	505,
+	438,
+	505,
+	439,
+	506,
+	440,
+	506,
+	439,
+	506,
+	440,
+	507,
+	441,
+	507,
+	440,
+	507,
+	441,
+	508,
+	442,
+	508,
+	441,
+	508,
+	442,
+	509,
+	443,
+	509,
+	442,
+	509,
+	443,
+	510,
+	444,
+	510,
+	443,
+	510,
+	444,
+	511,
+	445,
+	511,
+	444,
+	511,
+	445,
+	512,
+	446,
+	512,
+	445,
+	512,
+	446,
+	513,
+	447,
+	513,
+	446,
+	513,
+	447,
+	514,
+	448,
+	514,
+	447,
+	514,
+	448,
+	515,
+	449,
+	515,
+	448,
+	515,
+	449,
+	516,
+	450,
+	516,
+	449,
+	516,
+	450,
+	517,
+	451,
+	517,
+	450,
+	517,
+	451,
+	518,
+	452,
+	518,
+	451,
+	518,
+	452,
+	519,
+	453,
+	519,
+	452,
+	519,
+	453,
+	520,
+	454,
+	520,
+	453,
+	520,
+	454,
+	521,
+	455,
+	521,
+	454,
+	521,
+	455,
+	522,
+	456,
+	522,
+	455,
+	522,
+	456,
+	523,
+	457,
+	523,
+	456,
+	523,
+	457,
+	524,
+	458,
+	524,
+	457,
+	524,
+	458,
+	525,
+	459,
+	525,
+	458,
+	525,
+	459,
+	526,
+	460,
+	526,
+	459,
+	526,
+	460,
+	527,
+	461,
+	527,
+	460,
+	528,
+	462,
+	529,
+	463,
+	529,
+	462,
+	529,
+	463,
+	530,
+	464,
+	530,
+	463,
+	530,
+	464,
+	531,
+	465,
+	531,
+	464,
+	531,
+	465,
+	532,
+	466,
+	532,
+	465,
+	532,
+	466,
+	533,
+	467,
+	533,
+	466,
+	533,
+	467,
+	534,
+	468,
+	534,
+	467,
+	534,
+	468,
+	535,
+	469,
+	535,
+	468,
+	535,
+	469,
+	536,
+	470,
+	536,
+	469,
+	536,
+	470,
+	537,
+	471,
+	537,
+	470,
+	537,
+	471,
+	538,
+	472,
+	538,
+	471,
+	538,
+	472,
+	539,
+	473,
+	539,
+	472,
+	539,
+	473,
+	540,
+	474,
+	540,
+	473,
+	540,
+	474,
+	541,
+	475,
+	541,
+	474,
+	541,
+	475,
+	542,
+	476,
+	542,
+	475,
+	542,
+	476,
+	543,
+	477,
+	543,
+	476,
+	543,
+	477,
+	544,
+	478,
+	544,
+	477,
+	544,
+	478,
+	545,
+	479,
+	545,
+	478,
+	545,
+	479,
+	546,
+	480,
+	546,
+	479,
+	546,
+	480,
+	547,
+	481,
+	547,
+	480,
+	547,
+	481,
+	548,
+	482,
+	548,
+	481,
+	548,
+	482,
+	549,
+	483,
+	549,
+	482,
+	549,
+	483,
+	550,
+	484,
+	550,
+	483,
+	550,
+	484,
+	551,
+	485,
+	551,
+	484,
+	551,
+	485,
+	552,
+	486,
+	552,
+	485,
+	552,
+	486,
+	553,
+	487,
+	553,
+	486,
+	553,
+	487,
+	554,
+	488,
+	554,
+	487,
+	554,
+	488,
+	555,
+	489,
+	555,
+	488,
+	555,
+	489,
+	556,
+	490,
+	556,
+	489,
+	556,
+	490,
+	557,
+	491,
+	557,
+	490,
+	557,
+	491,
+	558,
+	492,
+	558,
+	491,
+	558,
+	492,
+	559,
+	493,
+	559,
+	492,
+	559,
+	493,
+	560,
+	494,
+	560,
+	493,
+	560,
+	494,
+	561,
+	495,
+	561,
+	494,
+	561,
+	495,
+	562,
+	496,
+	562,
+	495,
+	562,
+	496,
+	563,
+	497,
+	563,
+	496,
+	563,
+	497,
+	564,
+	498,
+	564,
+	497,
+	564,
+	498,
+	565,
+	499,
+	565,
+	498,
+	565,
+	499,
+	566,
+	500,
+	566,
+	499,
+	566,
+	500,
+	567,
+	501,
+	567,
+	500,
+	567,
+	501,
+	568,
+	502,
+	568,
+	501,
+	568,
+	502,
+	569,
+	503,
+	569,
+	502,
+	569,
+	503,
+	570,
+	504,
+	570,
+	503,
+	570,
+	504,
+	571,
+	505,
+	571,
+	504,
+	571,
+	505,
+	572,
+	506,
+	572,
+	505,
+	572,
+	506,
+	573,
+	507,
+	573,
+	506,
+	573,
+	507,
+	574,
+	508,
+	574,
+	507,
+	574,
+	508,
+	575,
+	509,
+	575,
+	508,
+	575,
+	509,
+	576,
+	510,
+	576,
+	509,
+	576,
+	510,
+	577,
+	511,
+	577,
+	510,
+	577,
+	511,
+	578,
+	512,
+	578,
+	511,
+	578,
+	512,
+	579,
+	513,
+	579,
+	512,
+	579,
+	513,
+	580,
+	514,
+	580,
+	513,
+	580,
+	514,
+	581,
+	515,
+	581,
+	514,
+	581,
+	515,
+	582,
+	516,
+	582,
+	515,
+	582,
+	516,
+	583,
+	517,
+	583,
+	516,
+	583,
+	517,
+	584,
+	518,
+	584,
+	517,
+	584,
+	518,
+	585,
+	519,
+	585,
+	518,
+	585,
+	519,
+	586,
+	520,
+	586,
+	519,
+	586,
+	520,
+	587,
+	521,
+	587,
+	520,
+	587,
+	521,
+	588,
+	522,
+	588,
+	521,
+	588,
+	522,
+	589,
+	523,
+	589,
+	522,
+	589,
+	523,
+	590,
+	524,
+	590,
+	523,
+	590,
+	524,
+	591,
+	525,
+	591,
+	524,
+	591,
+	525,
+	592,
+	526,
+	592,
+	525,
+	592,
+	526,
+	593,
+	527,
+	593,
+	526,
+	594,
+	528,
+	595,
+	529,
+	595,
+	528,
+	595,
+	529,
+	596,
+	530,
+	596,
+	529,
+	596,
+	530,
+	597,
+	531,
+	597,
+	530,
+	597,
+	531,
+	598,
+	532,
+	598,
+	531,
+	598,
+	532,
+	599,
+	533,
+	599,
+	532,
+	599,
+	533,
+	600,
+	534,
+	600,
+	533,
+	600,
+	534,
+	601,
+	535,
+	601,
+	534,
+	601,
+	535,
+	602,
+	536,
+	602,
+	535,
+	602,
+	536,
+	603,
+	537,
+	603,
+	536,
+	603,
+	537,
+	604,
+	538,
+	604,
+	537,
+	604,
+	538,
+	605,
+	539,
+	605,
+	538,
+	605,
+	539,
+	606,
+	540,
+	606,
+	539,
+	606,
+	540,
+	607,
+	541,
+	607,
+	540,
+	607,
+	541,
+	608,
+	542,
+	608,
+	541,
+	608,
+	542,
+	609,
+	543,
+	609,
+	542,
+	609,
+	543,
+	610,
+	544,
+	610,
+	543,
+	610,
+	544,
+	611,
+	545,
+	611,
+	544,
+	611,
+	545,
+	612,
+	546,
+	612,
+	545,
+	612,
+	546,
+	613,
+	547,
+	613,
+	546,
+	613,
+	547,
+	614,
+	548,
+	614,
+	547,
+	614,
+	548,
+	615,
+	549,
+	615,
+	548,
+	615,
+	549,
+	616,
+	550,
+	616,
+	549,
+	616,
+	550,
+	617,
+	551,
+	617,
+	550,
+	617,
+	551,
+	618,
+	552,
+	618,
+	551,
+	618,
+	552,
+	619,
+	553,
+	619,
+	552,
+	619,
+	553,
+	620,
+	554,
+	620,
+	553,
+	620,
+	554,
+	621,
+	555,
+	621,
+	554,
+	621,
+	555,
+	622,
+	556,
+	622,
+	555,
+	622,
+	556,
+	623,
+	557,
+	623,
+	556,
+	623,
+	557,
+	624,
+	558,
+	624,
+	557,
+	624,
+	558,
+	625,
+	559,
+	625,
+	558,
+	625,
+	559,
+	626,
+	560,
+	626,
+	559,
+	626,
+	560,
+	627,
+	561,
+	627,
+	560,
+	627,
+	561,
+	628,
+	562,
+	628,
+	561,
+	628,
+	562,
+	629,
+	563,
+	629,
+	562,
+	629,
+	563,
+	630,
+	564,
+	630,
+	563,
+	630,
+	564,
+	631,
+	565,
+	631,
+	564,
+	631,
+	565,
+	632,
+	566,
+	632,
+	565,
+	632,
+	566,
+	633,
+	567,
+	633,
+	566,
+	633,
+	567,
+	634,
+	568,
+	634,
+	567,
+	634,
+	568,
+	635,
+	569,
+	635,
+	568,
+	635,
+	569,
+	636,
+	570,
+	636,
+	569,
+	636,
+	570,
+	637,
+	571,
+	637,
+	570,
+	637,
+	571,
+	638,
+	572,
+	638,
+	571,
+	638,
+	572,
+	639,
+	573,
+	639,
+	572,
+	639,
+	573,
+	640,
+	574,
+	640,
+	573,
+	640,
+	574,
+	641,
+	575,
+	641,
+	574,
+	641,
+	575,
+	642,
+	576,
+	642,
+	575,
+	642,
+	576,
+	643,
+	577,
+	643,
+	576,
+	643,
+	577,
+	644,
+	578,
+	644,
+	577,
+	644,
+	578,
+	645,
+	579,
+	645,
+	578,
+	645,
+	579,
+	646,
+	580,
+	646,
+	579,
+	646,
+	580,
+	647,
+	581,
+	647,
+	580,
+	647,
+	581,
+	648,
+	582,
+	648,
+	581,
+	648,
+	582,
+	649,
+	583,
+	649,
+	582,
+	649,
+	583,
+	650,
+	584,
+	650,
+	583,
+	650,
+	584,
+	651,
+	585,
+	651,
+	584,
+	651,
+	585,
+	652,
+	586,
+	652,
+	585,
+	652,
+	586,
+	653,
+	587,
+	653,
+	586,
+	653,
+	587,
+	654,
+	588,
+	654,
+	587,
+	654,
+	588,
+	655,
+	589,
+	655,
+	588,
+	655,
+	589,
+	656,
+	590,
+	656,
+	589,
+	656,
+	590,
+	657,
+	591,
+	657,
+	590,
+	657,
+	591,
+	658,
+	592,
+	658,
+	591,
+	658,
+	592,
+	659,
+	593,
+	659,
+	592,
+	660,
+	594,
+	661,
+	595,
+	661,
+	594,
+	661,
+	595,
+	662,
+	596,
+	662,
+	595,
+	662,
+	596,
+	663,
+	597,
+	663,
+	596,
+	663,
+	597,
+	664,
+	598,
+	664,
+	597,
+	664,
+	598,
+	665,
+	599,
+	665,
+	598,
+	665,
+	599,
+	666,
+	600,
+	666,
+	599,
+	666,
+	600,
+	667,
+	601,
+	667,
+	600,
+	667,
+	601,
+	668,
+	602,
+	668,
+	601,
+	668,
+	602,
+	669,
+	603,
+	669,
+	602,
+	669,
+	603,
+	670,
+	604,
+	670,
+	603,
+	670,
+	604,
+	671,
+	605,
+	671,
+	604,
+	671,
+	605,
+	672,
+	606,
+	672,
+	605,
+	672,
+	606,
+	673,
+	607,
+	673,
+	606,
+	673,
+	607,
+	674,
+	608,
+	674,
+	607,
+	674,
+	608,
+	675,
+	609,
+	675,
+	608,
+	675,
+	609,
+	676,
+	610,
+	676,
+	609,
+	676,
+	610,
+	677,
+	611,
+	677,
+	610,
+	677,
+	611,
+	678,
+	612,
+	678,
+	611,
+	678,
+	612,
+	679,
+	613,
+	679,
+	612,
+	679,
+	613,
+	680,
+	614,
+	680,
+	613,
+	680,
+	614,
+	681,
+	615,
+	681,
+	614,
+	681,
+	615,
+	682,
+	616,
+	682,
+	615,
+	682,
+	616,
+	683,
+	617,
+	683,
+	616,
+	683,
+	617,
+	684,
+	618,
+	684,
+	617,
+	684,
+	618,
+	685,
+	619,
+	685,
+	618,
+	685,
+	619,
+	686,
+	620,
+	686,
+	619,
+	686,
+	620,
+	687,
+	621,
+	687,
+	620,
+	687,
+	621,
+	688,
+	622,
+	688,
+	621,
+	688,
+	622,
+	689,
+	623,
+	689,
+	622,
+	689,
+	623,
+	690,
+	624,
+	690,
+	623,
+	690,
+	624,
+	691,
+	625,
+	691,
+	624,
+	691,
+	625,
+	692,
+	626,
+	692,
+	625,
+	692,
+	626,
+	693,
+	627,
+	693,
+	626,
+	693,
+	627,
+	694,
+	628,
+	694,
+	627,
+	694,
+	628,
+	695,
+	629,
+	695,
+	628,
+	695,
+	629,
+	696,
+	630,
+	696,
+	629,
+	696,
+	630,
+	697,
+	631,
+	697,
+	630,
+	697,
+	631,
+	698,
+	632,
+	698,
+	631,
+	698,
+	632,
+	699,
+	633,
+	699,
+	632,
+	699,
+	633,
+	700,
+	634,
+	700,
+	633,
+	700,
+	634,
+	701,
+	635,
+	701,
+	634,
+	701,
+	635,
+	702,
+	636,
+	702,
+	635,
+	702,
+	636,
+	703,
+	637,
+	703,
+	636,
+	703,
+	637,
+	704,
+	638,
+	704,
+	637,
+	704,
+	638,
+	705,
+	639,
+	705,
+	638,
+	705,
+	639,
+	706,
+	640,
+	706,
+	639,
+	706,
+	640,
+	707,
+	641,
+	707,
+	640,
+	707,
+	641,
+	708,
+	642,
+	708,
+	641,
+	708,
+	642,
+	709,
+	643,
+	709,
+	642,
+	709,
+	643,
+	710,
+	644,
+	710,
+	643,
+	710,
+	644,
+	711,
+	645,
+	711,
+	644,
+	711,
+	645,
+	712,
+	646,
+	712,
+	645,
+	712,
+	646,
+	713,
+	647,
+	713,
+	646,
+	713,
+	647,
+	714,
+	648,
+	714,
+	647,
+	714,
+	648,
+	715,
+	649,
+	715,
+	648,
+	715,
+	649,
+	716,
+	650,
+	716,
+	649,
+	716,
+	650,
+	717,
+	651,
+	717,
+	650,
+	717,
+	651,
+	718,
+	652,
+	718,
+	651,
+	718,
+	652,
+	719,
+	653,
+	719,
+	652,
+	719,
+	653,
+	720,
+	654,
+	720,
+	653,
+	720,
+	654,
+	721,
+	655,
+	721,
+	654,
+	721,
+	655,
+	722,
+	656,
+	722,
+	655,
+	722,
+	656,
+	723,
+	657,
+	723,
+	656,
+	723,
+	657,
+	724,
+	658,
+	724,
+	657,
+	724,
+	658,
+	725,
+	659,
+	725,
+	658,
+	726,
+	660,
+	727,
+	661,
+	727,
+	660,
+	727,
+	661,
+	728,
+	662,
+	728,
+	661,
+	728,
+	662,
+	729,
+	663,
+	729,
+	662,
+	729,
+	663,
+	730,
+	664,
+	730,
+	663,
+	730,
+	664,
+	731,
+	665,
+	731,
+	664,
+	731,
+	665,
+	732,
+	666,
+	732,
+	665,
+	732,
+	666,
+	733,
+	667,
+	733,
+	666,
+	733,
+	667,
+	734,
+	668,
+	734,
+	667,
+	734,
+	668,
+	735,
+	669,
+	735,
+	668,
+	735,
+	669,
+	736,
+	670,
+	736,
+	669,
+	736,
+	670,
+	737,
+	671,
+	737,
+	670,
+	737,
+	671,
+	738,
+	672,
+	738,
+	671,
+	738,
+	672,
+	739,
+	673,
+	739,
+	672,
+	739,
+	673,
+	740,
+	674,
+	740,
+	673,
+	740,
+	674,
+	741,
+	675,
+	741,
+	674,
+	741,
+	675,
+	742,
+	676,
+	742,
+	675,
+	742,
+	676,
+	743,
+	677,
+	743,
+	676,
+	743,
+	677,
+	744,
+	678,
+	744,
+	677,
+	744,
+	678,
+	745,
+	679,
+	745,
+	678,
+	745,
+	679,
+	746,
+	680,
+	746,
+	679,
+	746,
+	680,
+	747,
+	681,
+	747,
+	680,
+	747,
+	681,
+	748,
+	682,
+	748,
+	681,
+	748,
+	682,
+	749,
+	683,
+	749,
+	682,
+	749,
+	683,
+	750,
+	684,
+	750,
+	683,
+	750,
+	684,
+	751,
+	685,
+	751,
+	684,
+	751,
+	685,
+	752,
+	686,
+	752,
+	685,
+	752,
+	686,
+	753,
+	687,
+	753,
+	686,
+	753,
+	687,
+	754,
+	688,
+	754,
+	687,
+	754,
+	688,
+	755,
+	689,
+	755,
+	688,
+	755,
+	689,
+	756,
+	690,
+	756,
+	689,
+	756,
+	690,
+	757,
+	691,
+	757,
+	690,
+	757,
+	691,
+	758,
+	692,
+	758,
+	691,
+	758,
+	692,
+	759,
+	693,
+	759,
+	692,
+	759,
+	693,
+	760,
+	694,
+	760,
+	693,
+	760,
+	694,
+	761,
+	695,
+	761,
+	694,
+	761,
+	695,
+	762,
+	696,
+	762,
+	695,
+	762,
+	696,
+	763,
+	697,
+	763,
+	696,
+	763,
+	697,
+	764,
+	698,
+	764,
+	697,
+	764,
+	698,
+	765,
+	699,
+	765,
+	698,
+	765,
+	699,
+	766,
+	700,
+	766,
+	699,
+	766,
+	700,
+	767,
+	701,
+	767,
+	700,
+	767,
+	701,
+	768,
+	702,
+	768,
+	701,
+	768,
+	702,
+	769,
+	703,
+	769,
+	702,
+	769,
+	703,
+	770,
+	704,
+	770,
+	703,
+	770,
+	704,
+	771,
+	705,
+	771,
+	704,
+	771,
+	705,
+	772,
+	706,
+	772,
+	705,
+	772,
+	706,
+	773,
+	707,
+	773,
+	706,
+	773,
+	707,
+	774,
+	708,
+	774,
+	707,
+	774,
+	708,
+	775,
+	709,
+	775,
+	708,
+	775,
+	709,
+	776,
+	710,
+	776,
+	709,
+	776,
+	710,
+	777,
+	711,
+	777,
+	710,
+	777,
+	711,
+	778,
+	712,
+	778,
+	711,
+	778,
+	712,
+	779,
+	713,
+	779,
+	712,
+	779,
+	713,
+	780,
+	714,
+	780,
+	713,
+	780,
+	714,
+	781,
+	715,
+	781,
+	714,
+	781,
+	715,
+	782,
+	716,
+	782,
+	715,
+	782,
+	716,
+	783,
+	717,
+	783,
+	716,
+	783,
+	717,
+	784,
+	718,
+	784,
+	717,
+	784,
+	718,
+	785,
+	719,
+	785,
+	718,
+	785,
+	719,
+	786,
+	720,
+	786,
+	719,
+	786,
+	720,
+	787,
+	721,
+	787,
+	720,
+	787,
+	721,
+	788,
+	722,
+	788,
+	721,
+	788,
+	722,
+	789,
+	723,
+	789,
+	722,
+	789,
+	723,
+	790,
+	724,
+	790,
+	723,
+	790,
+	724,
+	791,
+	725,
+	791,
+	724,
+	792,
+	726,
+	793,
+	727,
+	793,
+	726,
+	793,
+	727,
+	794,
+	728,
+	794,
+	727,
+	794,
+	728,
+	795,
+	729,
+	795,
+	728,
+	795,
+	729,
+	796,
+	730,
+	796,
+	729,
+	796,
+	730,
+	797,
+	731,
+	797,
+	730,
+	797,
+	731,
+	798,
+	732,
+	798,
+	731,
+	798,
+	732,
+	799,
+	733,
+	799,
+	732,
+	799,
+	733,
+	800,
+	734,
+	800,
+	733,
+	800,
+	734,
+	801,
+	735,
+	801,
+	734,
+	801,
+	735,
+	802,
+	736,
+	802,
+	735,
+	802,
+	736,
+	803,
+	737,
+	803,
+	736,
+	803,
+	737,
+	804,
+	738,
+	804,
+	737,
+	804,
+	738,
+	805,
+	739,
+	805,
+	738,
+	805,
+	739,
+	806,
+	740,
+	806,
+	739,
+	806,
+	740,
+	807,
+	741,
+	807,
+	740,
+	807,
+	741,
+	808,
+	742,
+	808,
+	741,
+	808,
+	742,
+	809,
+	743,
+	809,
+	742,
+	809,
+	743,
+	810,
+	744,
+	810,
+	743,
+	810,
+	744,
+	811,
+	745,
+	811,
+	744,
+	811,
+	745,
+	812,
+	746,
+	812,
+	745,
+	812,
+	746,
+	813,
+	747,
+	813,
+	746,
+	813,
+	747,
+	814,
+	748,
+	814,
+	747,
+	814,
+	748,
+	815,
+	749,
+	815,
+	748,
+	815,
+	749,
+	816,
+	750,
+	816,
+	749,
+	816,
+	750,
+	817,
+	751,
+	817,
+	750,
+	817,
+	751,
+	818,
+	752,
+	818,
+	751,
+	818,
+	752,
+	819,
+	753,
+	819,
+	752,
+	819,
+	753,
+	820,
+	754,
+	820,
+	753,
+	820,
+	754,
+	821,
+	755,
+	821,
+	754,
+	821,
+	755,
+	822,
+	756,
+	822,
+	755,
+	822,
+	756,
+	823,
+	757,
+	823,
+	756,
+	823,
+	757,
+	824,
+	758,
+	824,
+	757,
+	824,
+	758,
+	825,
+	759,
+	825,
+	758,
+	825,
+	759,
+	826,
+	760,
+	826,
+	759,
+	826,
+	760,
+	827,
+	761,
+	827,
+	760,
+	827,
+	761,
+	828,
+	762,
+	828,
+	761,
+	828,
+	762,
+	829,
+	763,
+	829,
+	762,
+	829,
+	763,
+	830,
+	764,
+	830,
+	763,
+	830,
+	764,
+	831,
+	765,
+	831,
+	764,
+	831,
+	765,
+	832,
+	766,
+	832,
+	765,
+	832,
+	766,
+	833,
+	767,
+	833,
+	766,
+	833,
+	767,
+	834,
+	768,
+	834,
+	767,
+	834,
+	768,
+	835,
+	769,
+	835,
+	768,
+	835,
+	769,
+	836,
+	770,
+	836,
+	769,
+	836,
+	770,
+	837,
+	771,
+	837,
+	770,
+	837,
+	771,
+	838,
+	772,
+	838,
+	771,
+	838,
+	772,
+	839,
+	773,
+	839,
+	772,
+	839,
+	773,
+	840,
+	774,
+	840,
+	773,
+	840,
+	774,
+	841,
+	775,
+	841,
+	774,
+	841,
+	775,
+	842,
+	776,
+	842,
+	775,
+	842,
+	776,
+	843,
+	777,
+	843,
+	776,
+	843,
+	777,
+	844,
+	778,
+	844,
+	777,
+	844,
+	778,
+	845,
+	779,
+	845,
+	778,
+	845,
+	779,
+	846,
+	780,
+	846,
+	779,
+	846,
+	780,
+	847,
+	781,
+	847,
+	780,
+	847,
+	781,
+	848,
+	782,
+	848,
+	781,
+	848,
+	782,
+	849,
+	783,
+	849,
+	782,
+	849,
+	783,
+	850,
+	784,
+	850,
+	783,
+	850,
+	784,
+	851,
+	785,
+	851,
+	784,
+	851,
+	785,
+	852,
+	786,
+	852,
+	785,
+	852,
+	786,
+	853,
+	787,
+	853,
+	786,
+	853,
+	787,
+	854,
+	788,
+	854,
+	787,
+	854,
+	788,
+	855,
+	789,
+	855,
+	788,
+	855,
+	789,
+	856,
+	790,
+	856,
+	789,
+	856,
+	790,
+	857,
+	791,
+	857,
+	790,
+	858,
+	792,
+	859,
+	793,
+	859,
+	792,
+	859,
+	793,
+	860,
+	794,
+	860,
+	793,
+	860,
+	794,
+	861,
+	795,
+	861,
+	794,
+	861,
+	795,
+	862,
+	796,
+	862,
+	795,
+	862,
+	796,
+	863,
+	797,
+	863,
+	796,
+	863,
+	797,
+	864,
+	798,
+	864,
+	797,
+	864,
+	798,
+	865,
+	799,
+	865,
+	798,
+	865,
+	799,
+	866,
+	800,
+	866,
+	799,
+	866,
+	800,
+	867,
+	801,
+	867,
+	800,
+	867,
+	801,
+	868,
+	802,
+	868,
+	801,
+	868,
+	802,
+	869,
+	803,
+	869,
+	802,
+	869,
+	803,
+	870,
+	804,
+	870,
+	803,
+	870,
+	804,
+	871,
+	805,
+	871,
+	804,
+	871,
+	805,
+	872,
+	806,
+	872,
+	805,
+	872,
+	806,
+	873,
+	807,
+	873,
+	806,
+	873,
+	807,
+	874,
+	808,
+	874,
+	807,
+	874,
+	808,
+	875,
+	809,
+	875,
+	808,
+	875,
+	809,
+	876,
+	810,
+	876,
+	809,
+	876,
+	810,
+	877,
+	811,
+	877,
+	810,
+	877,
+	811,
+	878,
+	812,
+	878,
+	811,
+	878,
+	812,
+	879,
+	813,
+	879,
+	812,
+	879,
+	813,
+	880,
+	814,
+	880,
+	813,
+	880,
+	814,
+	881,
+	815,
+	881,
+	814,
+	881,
+	815,
+	882,
+	816,
+	882,
+	815,
+	882,
+	816,
+	883,
+	817,
+	883,
+	816,
+	883,
+	817,
+	884,
+	818,
+	884,
+	817,
+	884,
+	818,
+	885,
+	819,
+	885,
+	818,
+	885,
+	819,
+	886,
+	820,
+	886,
+	819,
+	886,
+	820,
+	887,
+	821,
+	887,
+	820,
+	887,
+	821,
+	888,
+	822,
+	888,
+	821,
+	888,
+	822,
+	889,
+	823,
+	889,
+	822,
+	889,
+	823,
+	890,
+	824,
+	890,
+	823,
+	890,
+	824,
+	891,
+	825,
+	891,
+	824,
+	891,
+	825,
+	892,
+	826,
+	892,
+	825,
+	892,
+	826,
+	893,
+	827,
+	893,
+	826,
+	893,
+	827,
+	894,
+	828,
+	894,
+	827,
+	894,
+	828,
+	895,
+	829,
+	895,
+	828,
+	895,
+	829,
+	896,
+	830,
+	896,
+	829,
+	896,
+	830,
+	897,
+	831,
+	897,
+	830,
+	897,
+	831,
+	898,
+	832,
+	898,
+	831,
+	898,
+	832,
+	899,
+	833,
+	899,
+	832,
+	899,
+	833,
+	900,
+	834,
+	900,
+	833,
+	900,
+	834,
+	901,
+	835,
+	901,
+	834,
+	901,
+	835,
+	902,
+	836,
+	902,
+	835,
+	902,
+	836,
+	903,
+	837,
+	903,
+	836,
+	903,
+	837,
+	904,
+	838,
+	904,
+	837,
+	904,
+	838,
+	905,
+	839,
+	905,
+	838,
+	905,
+	839,
+	906,
+	840,
+	906,
+	839,
+	906,
+	840,
+	907,
+	841,
+	907,
+	840,
+	907,
+	841,
+	908,
+	842,
+	908,
+	841,
+	908,
+	842,
+	909,
+	843,
+	909,
+	842,
+	909,
+	843,
+	910,
+	844,
+	910,
+	843,
+	910,
+	844,
+	911,
+	845,
+	911,
+	844,
+	911,
+	845,
+	912,
+	846,
+	912,
+	845,
+	912,
+	846,
+	913,
+	847,
+	913,
+	846,
+	913,
+	847,
+	914,
+	848,
+	914,
+	847,
+	914,
+	848,
+	915,
+	849,
+	915,
+	848,
+	915,
+	849,
+	916,
+	850,
+	916,
+	849,
+	916,
+	850,
+	917,
+	851,
+	917,
+	850,
+	917,
+	851,
+	918,
+	852,
+	918,
+	851,
+	918,
+	852,
+	919,
+	853,
+	919,
+	852,
+	919,
+	853,
+	920,
+	854,
+	920,
+	853,
+	920,
+	854,
+	921,
+	855,
+	921,
+	854,
+	921,
+	855,
+	922,
+	856,
+	922,
+	855,
+	922,
+	856,
+	923,
+	857,
+	923,
+	856,
+	924,
+	858,
+	925,
+	859,
+	925,
+	858,
+	925,
+	859,
+	926,
+	860,
+	926,
+	859,
+	926,
+	860,
+	927,
+	861,
+	927,
+	860,
+	927,
+	861,
+	928,
+	862,
+	928,
+	861,
+	928,
+	862,
+	929,
+	863,
+	929,
+	862,
+	929,
+	863,
+	930,
+	864,
+	930,
+	863,
+	930,
+	864,
+	931,
+	865,
+	931,
+	864,
+	931,
+	865,
+	932,
+	866,
+	932,
+	865,
+	932,
+	866,
+	933,
+	867,
+	933,
+	866,
+	933,
+	867,
+	934,
+	868,
+	934,
+	867,
+	934,
+	868,
+	935,
+	869,
+	935,
+	868,
+	935,
+	869,
+	936,
+	870,
+	936,
+	869,
+	936,
+	870,
+	937,
+	871,
+	937,
+	870,
+	937,
+	871,
+	938,
+	872,
+	938,
+	871,
+	938,
+	872,
+	939,
+	873,
+	939,
+	872,
+	939,
+	873,
+	940,
+	874,
+	940,
+	873,
+	940,
+	874,
+	941,
+	875,
+	941,
+	874,
+	941,
+	875,
+	942,
+	876,
+	942,
+	875,
+	942,
+	876,
+	943,
+	877,
+	943,
+	876,
+	943,
+	877,
+	944,
+	878,
+	944,
+	877,
+	944,
+	878,
+	945,
+	879,
+	945,
+	878,
+	945,
+	879,
+	946,
+	880,
+	946,
+	879,
+	946,
+	880,
+	947,
+	881,
+	947,
+	880,
+	947,
+	881,
+	948,
+	882,
+	948,
+	881,
+	948,
+	882,
+	949,
+	883,
+	949,
+	882,
+	949,
+	883,
+	950,
+	884,
+	950,
+	883,
+	950,
+	884,
+	951,
+	885,
+	951,
+	884,
+	951,
+	885,
+	952,
+	886,
+	952,
+	885,
+	952,
+	886,
+	953,
+	887,
+	953,
+	886,
+	953,
+	887,
+	954,
+	888,
+	954,
+	887,
+	954,
+	888,
+	955,
+	889,
+	955,
+	888,
+	955,
+	889,
+	956,
+	890,
+	956,
+	889,
+	956,
+	890,
+	957,
+	891,
+	957,
+	890,
+	957,
+	891,
+	958,
+	892,
+	958,
+	891,
+	958,
+	892,
+	959,
+	893,
+	959,
+	892,
+	959,
+	893,
+	960,
+	894,
+	960,
+	893,
+	960,
+	894,
+	961,
+	895,
+	961,
+	894,
+	961,
+	895,
+	962,
+	896,
+	962,
+	895,
+	962,
+	896,
+	963,
+	897,
+	963,
+	896,
+	963,
+	897,
+	964,
+	898,
+	964,
+	897,
+	964,
+	898,
+	965,
+	899,
+	965,
+	898,
+	965,
+	899,
+	966,
+	900,
+	966,
+	899,
+	966,
+	900,
+	967,
+	901,
+	967,
+	900,
+	967,
+	901,
+	968,
+	902,
+	968,
+	901,
+	968,
+	902,
+	969,
+	903,
+	969,
+	902,
+	969,
+	903,
+	970,
+	904,
+	970,
+	903,
+	970,
+	904,
+	971,
+	905,
+	971,
+	904,
+	971,
+	905,
+	972,
+	906,
+	972,
+	905,
+	972,
+	906,
+	973,
+	907,
+	973,
+	906,
+	973,
+	907,
+	974,
+	908,
+	974,
+	907,
+	974,
+	908,
+	975,
+	909,
+	975,
+	908,
+	975,
+	909,
+	976,
+	910,
+	976,
+	909,
+	976,
+	910,
+	977,
+	911,
+	977,
+	910,
+	977,
+	911,
+	978,
+	912,
+	978,
+	911,
+	978,
+	912,
+	979,
+	913,
+	979,
+	912,
+	979,
+	913,
+	980,
+	914,
+	980,
+	913,
+	980,
+	914,
+	981,
+	915,
+	981,
+	914,
+	981,
+	915,
+	982,
+	916,
+	982,
+	915,
+	982,
+	916,
+	983,
+	917,
+	983,
+	916,
+	983,
+	917,
+	984,
+	918,
+	984,
+	917,
+	984,
+	918,
+	985,
+	919,
+	985,
+	918,
+	985,
+	919,
+	986,
+	920,
+	986,
+	919,
+	986,
+	920,
+	987,
+	921,
+	987,
+	920,
+	987,
+	921,
+	988,
+	922,
+	988,
+	921,
+	988,
+	922,
+	989,
+	923,
+	989,
+	922,
+	990,
+	924,
+	991,
+	925,
+	991,
+	924,
+	991,
+	925,
+	992,
+	926,
+	992,
+	925,
+	992,
+	926,
+	993,
+	927,
+	993,
+	926,
+	993,
+	927,
+	994,
+	928,
+	994,
+	927,
+	994,
+	928,
+	995,
+	929,
+	995,
+	928,
+	995,
+	929,
+	996,
+	930,
+	996,
+	929,
+	996,
+	930,
+	997,
+	931,
+	997,
+	930,
+	997,
+	931,
+	998,
+	932,
+	998,
+	931,
+	998,
+	932,
+	999,
+	933,
+	999,
+	932,
+	999,
+	933,
+	1000,
+	934,
+	1000,
+	933,
+	1000,
+	934,
+	1001,
+	935,
+	1001,
+	934,
+	1001,
+	935,
+	1002,
+	936,
+	1002,
+	935,
+	1002,
+	936,
+	1003,
+	937,
+	1003,
+	936,
+	1003,
+	937,
+	1004,
+	938,
+	1004,
+	937,
+	1004,
+	938,
+	1005,
+	939,
+	1005,
+	938,
+	1005,
+	939,
+	1006,
+	940,
+	1006,
+	939,
+	1006,
+	940,
+	1007,
+	941,
+	1007,
+	940,
+	1007,
+	941,
+	1008,
+	942,
+	1008,
+	941,
+	1008,
+	942,
+	1009,
+	943,
+	1009,
+	942,
+	1009,
+	943,
+	1010,
+	944,
+	1010,
+	943,
+	1010,
+	944,
+	1011,
+	945,
+	1011,
+	944,
+	1011,
+	945,
+	1012,
+	946,
+	1012,
+	945,
+	1012,
+	946,
+	1013,
+	947,
+	1013,
+	946,
+	1013,
+	947,
+	1014,
+	948,
+	1014,
+	947,
+	1014,
+	948,
+	1015,
+	949,
+	1015,
+	948,
+	1015,
+	949,
+	1016,
+	950,
+	1016,
+	949,
+	1016,
+	950,
+	1017,
+	951,
+	1017,
+	950,
+	1017,
+	951,
+	1018,
+	952,
+	1018,
+	951,
+	1018,
+	952,
+	1019,
+	953,
+	1019,
+	952,
+	1019,
+	953,
+	1020,
+	954,
+	1020,
+	953,
+	1020,
+	954,
+	1021,
+	955,
+	1021,
+	954,
+	1021,
+	955,
+	1022,
+	956,
+	1022,
+	955,
+	1022,
+	956,
+	1023,
+	957,
+	1023,
+	956,
+	1023,
+	957,
+	1024,
+	958,
+	1024,
+	957,
+	1024,
+	958,
+	1025,
+	959,
+	1025,
+	958,
+	1025,
+	959,
+	1026,
+	960,
+	1026,
+	959,
+	1026,
+	960,
+	1027,
+	961,
+	1027,
+	960,
+	1027,
+	961,
+	1028,
+	962,
+	1028,
+	961,
+	1028,
+	962,
+	1029,
+	963,
+	1029,
+	962,
+	1029,
+	963,
+	1030,
+	964,
+	1030,
+	963,
+	1030,
+	964,
+	1031,
+	965,
+	1031,
+	964,
+	1031,
+	965,
+	1032,
+	966,
+	1032,
+	965,
+	1032,
+	966,
+	1033,
+	967,
+	1033,
+	966,
+	1033,
+	967,
+	1034,
+	968,
+	1034,
+	967,
+	1034,
+	968,
+	1035,
+	969,
+	1035,
+	968,
+	1035,
+	969,
+	1036,
+	970,
+	1036,
+	969,
+	1036,
+	970,
+	1037,
+	971,
+	1037,
+	970,
+	1037,
+	971,
+	1038,
+	972,
+	1038,
+	971,
+	1038,
+	972,
+	1039,
+	973,
+	1039,
+	972,
+	1039,
+	973,
+	1040,
+	974,
+	1040,
+	973,
+	1040,
+	974,
+	1041,
+	975,
+	1041,
+	974,
+	1041,
+	975,
+	1042,
+	976,
+	1042,
+	975,
+	1042,
+	976,
+	1043,
+	977,
+	1043,
+	976,
+	1043,
+	977,
+	1044,
+	978,
+	1044,
+	977,
+	1044,
+	978,
+	1045,
+	979,
+	1045,
+	978,
+	1045,
+	979,
+	1046,
+	980,
+	1046,
+	979,
+	1046,
+	980,
+	1047,
+	981,
+	1047,
+	980,
+	1047,
+	981,
+	1048,
+	982,
+	1048,
+	981,
+	1048,
+	982,
+	1049,
+	983,
+	1049,
+	982,
+	1049,
+	983,
+	1050,
+	984,
+	1050,
+	983,
+	1050,
+	984,
+	1051,
+	985,
+	1051,
+	984,
+	1051,
+	985,
+	1052,
+	986,
+	1052,
+	985,
+	1052,
+	986,
+	1053,
+	987,
+	1053,
+	986,
+	1053,
+	987,
+	1054,
+	988,
+	1054,
+	987,
+	1054,
+	988,
+	1055,
+	989,
+	1055,
+	988,
+	1056,
+	990,
+	1057,
+	991,
+	1057,
+	990,
+	1057,
+	991,
+	1058,
+	992,
+	1058,
+	991,
+	1058,
+	992,
+	1059,
+	993,
+	1059,
+	992,
+	1059,
+	993,
+	1060,
+	994,
+	1060,
+	993,
+	1060,
+	994,
+	1061,
+	995,
+	1061,
+	994,
+	1061,
+	995,
+	1062,
+	996,
+	1062,
+	995,
+	1062,
+	996,
+	1063,
+	997,
+	1063,
+	996,
+	1063,
+	997,
+	1064,
+	998,
+	1064,
+	997,
+	1064,
+	998,
+	1065,
+	999,
+	1065,
+	998,
+	1065,
+	999,
+	1066,
+	1000,
+	1066,
+	999,
+	1066,
+	1000,
+	1067,
+	1001,
+	1067,
+	1000,
+	1067,
+	1001,
+	1068,
+	1002,
+	1068,
+	1001,
+	1068,
+	1002,
+	1069,
+	1003,
+	1069,
+	1002,
+	1069,
+	1003,
+	1070,
+	1004,
+	1070,
+	1003,
+	1070,
+	1004,
+	1071,
+	1005,
+	1071,
+	1004,
+	1071,
+	1005,
+	1072,
+	1006,
+	1072,
+	1005,
+	1072,
+	1006,
+	1073,
+	1007,
+	1073,
+	1006,
+	1073,
+	1007,
+	1074,
+	1008,
+	1074,
+	1007,
+	1074,
+	1008,
+	1075,
+	1009,
+	1075,
+	1008,
+	1075,
+	1009,
+	1076,
+	1010,
+	1076,
+	1009,
+	1076,
+	1010,
+	1077,
+	1011,
+	1077,
+	1010,
+	1077,
+	1011,
+	1078,
+	1012,
+	1078,
+	1011,
+	1078,
+	1012,
+	1079,
+	1013,
+	1079,
+	1012,
+	1079,
+	1013,
+	1080,
+	1014,
+	1080,
+	1013,
+	1080,
+	1014,
+	1081,
+	1015,
+	1081,
+	1014,
+	1081,
+	1015,
+	1082,
+	1016,
+	1082,
+	1015,
+	1082,
+	1016,
+	1083,
+	1017,
+	1083,
+	1016,
+	1083,
+	1017,
+	1084,
+	1018,
+	1084,
+	1017,
+	1084,
+	1018,
+	1085,
+	1019,
+	1085,
+	1018,
+	1085,
+	1019,
+	1086,
+	1020,
+	1086,
+	1019,
+	1086,
+	1020,
+	1087,
+	1021,
+	1087,
+	1020,
+	1087,
+	1021,
+	1088,
+	1022,
+	1088,
+	1021,
+	1088,
+	1022,
+	1089,
+	1023,
+	1089,
+	1022,
+	1089,
+	1023,
+	1090,
+	1024,
+	1090,
+	1023,
+	1090,
+	1024,
+	1091,
+	1025,
+	1091,
+	1024,
+	1091,
+	1025,
+	1092,
+	1026,
+	1092,
+	1025,
+	1092,
+	1026,
+	1093,
+	1027,
+	1093,
+	1026,
+	1093,
+	1027,
+	1094,
+	1028,
+	1094,
+	1027,
+	1094,
+	1028,
+	1095,
+	1029,
+	1095,
+	1028,
+	1095,
+	1029,
+	1096,
+	1030,
+	1096,
+	1029,
+	1096,
+	1030,
+	1097,
+	1031,
+	1097,
+	1030,
+	1097,
+	1031,
+	1098,
+	1032,
+	1098,
+	1031,
+	1098,
+	1032,
+	1099,
+	1033,
+	1099,
+	1032,
+	1099,
+	1033,
+	1100,
+	1034,
+	1100,
+	1033,
+	1100,
+	1034,
+	1101,
+	1035,
+	1101,
+	1034,
+	1101,
+	1035,
+	1102,
+	1036,
+	1102,
+	1035,
+	1102,
+	1036,
+	1103,
+	1037,
+	1103,
+	1036,
+	1103,
+	1037,
+	1104,
+	1038,
+	1104,
+	1037,
+	1104,
+	1038,
+	1105,
+	1039,
+	1105,
+	1038,
+	1105,
+	1039,
+	1106,
+	1040,
+	1106,
+	1039,
+	1106,
+	1040,
+	1107,
+	1041,
+	1107,
+	1040,
+	1107,
+	1041,
+	1108,
+	1042,
+	1108,
+	1041,
+	1108,
+	1042,
+	1109,
+	1043,
+	1109,
+	1042,
+	1109,
+	1043,
+	1110,
+	1044,
+	1110,
+	1043,
+	1110,
+	1044,
+	1111,
+	1045,
+	1111,
+	1044,
+	1111,
+	1045,
+	1112,
+	1046,
+	1112,
+	1045,
+	1112,
+	1046,
+	1113,
+	1047,
+	1113,
+	1046,
+	1113,
+	1047,
+	1114,
+	1048,
+	1114,
+	1047,
+	1114,
+	1048,
+	1115,
+	1049,
+	1115,
+	1048,
+	1115,
+	1049,
+	1116,
+	1050,
+	1116,
+	1049,
+	1116,
+	1050,
+	1117,
+	1051,
+	1117,
+	1050,
+	1117,
+	1051,
+	1118,
+	1052,
+	1118,
+	1051,
+	1118,
+	1052,
+	1119,
+	1053,
+	1119,
+	1052,
+	1119,
+	1053,
+	1120,
+	1054,
+	1120,
+	1053,
+	1120,
+	1054,
+	1121,
+	1055,
+	1121,
+	1054,
+	1122,
+	1056,
+	1123,
+	1057,
+	1123,
+	1056,
+	1123,
+	1057,
+	1124,
+	1058,
+	1124,
+	1057,
+	1124,
+	1058,
+	1125,
+	1059,
+	1125,
+	1058,
+	1125,
+	1059,
+	1126,
+	1060,
+	1126,
+	1059,
+	1126,
+	1060,
+	1127,
+	1061,
+	1127,
+	1060,
+	1127,
+	1061,
+	1128,
+	1062,
+	1128,
+	1061,
+	1128,
+	1062,
+	1129,
+	1063,
+	1129,
+	1062,
+	1129,
+	1063,
+	1130,
+	1064,
+	1130,
+	1063,
+	1130,
+	1064,
+	1131,
+	1065,
+	1131,
+	1064,
+	1131,
+	1065,
+	1132,
+	1066,
+	1132,
+	1065,
+	1132,
+	1066,
+	1133,
+	1067,
+	1133,
+	1066,
+	1133,
+	1067,
+	1134,
+	1068,
+	1134,
+	1067,
+	1134,
+	1068,
+	1135,
+	1069,
+	1135,
+	1068,
+	1135,
+	1069,
+	1136,
+	1070,
+	1136,
+	1069,
+	1136,
+	1070,
+	1137,
+	1071,
+	1137,
+	1070,
+	1137,
+	1071,
+	1138,
+	1072,
+	1138,
+	1071,
+	1138,
+	1072,
+	1139,
+	1073,
+	1139,
+	1072,
+	1139,
+	1073,
+	1140,
+	1074,
+	1140,
+	1073,
+	1140,
+	1074,
+	1141,
+	1075,
+	1141,
+	1074,
+	1141,
+	1075,
+	1142,
+	1076,
+	1142,
+	1075,
+	1142,
+	1076,
+	1143,
+	1077,
+	1143,
+	1076,
+	1143,
+	1077,
+	1144,
+	1078,
+	1144,
+	1077,
+	1144,
+	1078,
+	1145,
+	1079,
+	1145,
+	1078,
+	1145,
+	1079,
+	1146,
+	1080,
+	1146,
+	1079,
+	1146,
+	1080,
+	1147,
+	1081,
+	1147,
+	1080,
+	1147,
+	1081,
+	1148,
+	1082,
+	1148,
+	1081,
+	1148,
+	1082,
+	1149,
+	1083,
+	1149,
+	1082,
+	1149,
+	1083,
+	1150,
+	1084,
+	1150,
+	1083,
+	1150,
+	1084,
+	1151,
+	1085,
+	1151,
+	1084,
+	1151,
+	1085,
+	1152,
+	1086,
+	1152,
+	1085,
+	1152,
+	1086,
+	1153,
+	1087,
+	1153,
+	1086,
+	1153,
+	1087,
+	1154,
+	1088,
+	1154,
+	1087,
+	1154,
+	1088,
+	1155,
+	1089,
+	1155,
+	1088,
+	1155,
+	1089,
+	1156,
+	1090,
+	1156,
+	1089,
+	1156,
+	1090,
+	1157,
+	1091,
+	1157,
+	1090,
+	1157,
+	1091,
+	1158,
+	1092,
+	1158,
+	1091,
+	1158,
+	1092,
+	1159,
+	1093,
+	1159,
+	1092,
+	1159,
+	1093,
+	1160,
+	1094,
+	1160,
+	1093,
+	1160,
+	1094,
+	1161,
+	1095,
+	1161,
+	1094,
+	1161,
+	1095,
+	1162,
+	1096,
+	1162,
+	1095,
+	1162,
+	1096,
+	1163,
+	1097,
+	1163,
+	1096,
+	1163,
+	1097,
+	1164,
+	1098,
+	1164,
+	1097,
+	1164,
+	1098,
+	1165,
+	1099,
+	1165,
+	1098,
+	1165,
+	1099,
+	1166,
+	1100,
+	1166,
+	1099,
+	1166,
+	1100,
+	1167,
+	1101,
+	1167,
+	1100,
+	1167,
+	1101,
+	1168,
+	1102,
+	1168,
+	1101,
+	1168,
+	1102,
+	1169,
+	1103,
+	1169,
+	1102,
+	1169,
+	1103,
+	1170,
+	1104,
+	1170,
+	1103,
+	1170,
+	1104,
+	1171,
+	1105,
+	1171,
+	1104,
+	1171,
+	1105,
+	1172,
+	1106,
+	1172,
+	1105,
+	1172,
+	1106,
+	1173,
+	1107,
+	1173,
+	1106,
+	1173,
+	1107,
+	1174,
+	1108,
+	1174,
+	1107,
+	1174,
+	1108,
+	1175,
+	1109,
+	1175,
+	1108,
+	1175,
+	1109,
+	1176,
+	1110,
+	1176,
+	1109,
+	1176,
+	1110,
+	1177,
+	1111,
+	1177,
+	1110,
+	1177,
+	1111,
+	1178,
+	1112,
+	1178,
+	1111,
+	1178,
+	1112,
+	1179,
+	1113,
+	1179,
+	1112,
+	1179,
+	1113,
+	1180,
+	1114,
+	1180,
+	1113,
+	1180,
+	1114,
+	1181,
+	1115,
+	1181,
+	1114,
+	1181,
+	1115,
+	1182,
+	1116,
+	1182,
+	1115,
+	1182,
+	1116,
+	1183,
+	1117,
+	1183,
+	1116,
+	1183,
+	1117,
+	1184,
+	1118,
+	1184,
+	1117,
+	1184,
+	1118,
+	1185,
+	1119,
+	1185,
+	1118,
+	1185,
+	1119,
+	1186,
+	1120,
+	1186,
+	1119,
+	1186,
+	1120,
+	1187,
+	1121,
+	1187,
+	1120,
+	1188,
+	1122,
+	1189,
+	1123,
+	1189,
+	1122,
+	1189,
+	1123,
+	1190,
+	1124,
+	1190,
+	1123,
+	1190,
+	1124,
+	1191,
+	1125,
+	1191,
+	1124,
+	1191,
+	1125,
+	1192,
+	1126,
+	1192,
+	1125,
+	1192,
+	1126,
+	1193,
+	1127,
+	1193,
+	1126,
+	1193,
+	1127,
+	1194,
+	1128,
+	1194,
+	1127,
+	1194,
+	1128,
+	1195,
+	1129,
+	1195,
+	1128,
+	1195,
+	1129,
+	1196,
+	1130,
+	1196,
+	1129,
+	1196,
+	1130,
+	1197,
+	1131,
+	1197,
+	1130,
+	1197,
+	1131,
+	1198,
+	1132,
+	1198,
+	1131,
+	1198,
+	1132,
+	1199,
+	1133,
+	1199,
+	1132,
+	1199,
+	1133,
+	1200,
+	1134,
+	1200,
+	1133,
+	1200,
+	1134,
+	1201,
+	1135,
+	1201,
+	1134,
+	1201,
+	1135,
+	1202,
+	1136,
+	1202,
+	1135,
+	1202,
+	1136,
+	1203,
+	1137,
+	1203,
+	1136,
+	1203,
+	1137,
+	1204,
+	1138,
+	1204,
+	1137,
+	1204,
+	1138,
+	1205,
+	1139,
+	1205,
+	1138,
+	1205,
+	1139,
+	1206,
+	1140,
+	1206,
+	1139,
+	1206,
+	1140,
+	1207,
+	1141,
+	1207,
+	1140,
+	1207,
+	1141,
+	1208,
+	1142,
+	1208,
+	1141,
+	1208,
+	1142,
+	1209,
+	1143,
+	1209,
+	1142,
+	1209,
+	1143,
+	1210,
+	1144,
+	1210,
+	1143,
+	1210,
+	1144,
+	1211,
+	1145,
+	1211,
+	1144,
+	1211,
+	1145,
+	1212,
+	1146,
+	1212,
+	1145,
+	1212,
+	1146,
+	1213,
+	1147,
+	1213,
+	1146,
+	1213,
+	1147,
+	1214,
+	1148,
+	1214,
+	1147,
+	1214,
+	1148,
+	1215,
+	1149,
+	1215,
+	1148,
+	1215,
+	1149,
+	1216,
+	1150,
+	1216,
+	1149,
+	1216,
+	1150,
+	1217,
+	1151,
+	1217,
+	1150,
+	1217,
+	1151,
+	1218,
+	1152,
+	1218,
+	1151,
+	1218,
+	1152,
+	1219,
+	1153,
+	1219,
+	1152,
+	1219,
+	1153,
+	1220,
+	1154,
+	1220,
+	1153,
+	1220,
+	1154,
+	1221,
+	1155,
+	1221,
+	1154,
+	1221,
+	1155,
+	1222,
+	1156,
+	1222,
+	1155,
+	1222,
+	1156,
+	1223,
+	1157,
+	1223,
+	1156,
+	1223,
+	1157,
+	1224,
+	1158,
+	1224,
+	1157,
+	1224,
+	1158,
+	1225,
+	1159,
+	1225,
+	1158,
+	1225,
+	1159,
+	1226,
+	1160,
+	1226,
+	1159,
+	1226,
+	1160,
+	1227,
+	1161,
+	1227,
+	1160,
+	1227,
+	1161,
+	1228,
+	1162,
+	1228,
+	1161,
+	1228,
+	1162,
+	1229,
+	1163,
+	1229,
+	1162,
+	1229,
+	1163,
+	1230,
+	1164,
+	1230,
+	1163,
+	1230,
+	1164,
+	1231,
+	1165,
+	1231,
+	1164,
+	1231,
+	1165,
+	1232,
+	1166,
+	1232,
+	1165,
+	1232,
+	1166,
+	1233,
+	1167,
+	1233,
+	1166,
+	1233,
+	1167,
+	1234,
+	1168,
+	1234,
+	1167,
+	1234,
+	1168,
+	1235,
+	1169,
+	1235,
+	1168,
+	1235,
+	1169,
+	1236,
+	1170,
+	1236,
+	1169,
+	1236,
+	1170,
+	1237,
+	1171,
+	1237,
+	1170,
+	1237,
+	1171,
+	1238,
+	1172,
+	1238,
+	1171,
+	1238,
+	1172,
+	1239,
+	1173,
+	1239,
+	1172,
+	1239,
+	1173,
+	1240,
+	1174,
+	1240,
+	1173,
+	1240,
+	1174,
+	1241,
+	1175,
+	1241,
+	1174,
+	1241,
+	1175,
+	1242,
+	1176,
+	1242,
+	1175,
+	1242,
+	1176,
+	1243,
+	1177,
+	1243,
+	1176,
+	1243,
+	1177,
+	1244,
+	1178,
+	1244,
+	1177,
+	1244,
+	1178,
+	1245,
+	1179,
+	1245,
+	1178,
+	1245,
+	1179,
+	1246,
+	1180,
+	1246,
+	1179,
+	1246,
+	1180,
+	1247,
+	1181,
+	1247,
+	1180,
+	1247,
+	1181,
+	1248,
+	1182,
+	1248,
+	1181,
+	1248,
+	1182,
+	1249,
+	1183,
+	1249,
+	1182,
+	1249,
+	1183,
+	1250,
+	1184,
+	1250,
+	1183,
+	1250,
+	1184,
+	1251,
+	1185,
+	1251,
+	1184,
+	1251,
+	1185,
+	1252,
+	1186,
+	1252,
+	1185,
+	1252,
+	1186,
+	1253,
+	1187,
+	1253,
+	1186,
+	1254,
+	1188,
+	1255,
+	1189,
+	1255,
+	1188,
+	1255,
+	1189,
+	1256,
+	1190,
+	1256,
+	1189,
+	1256,
+	1190,
+	1257,
+	1191,
+	1257,
+	1190,
+	1257,
+	1191,
+	1258,
+	1192,
+	1258,
+	1191,
+	1258,
+	1192,
+	1259,
+	1193,
+	1259,
+	1192,
+	1259,
+	1193,
+	1260,
+	1194,
+	1260,
+	1193,
+	1260,
+	1194,
+	1261,
+	1195,
+	1261,
+	1194,
+	1261,
+	1195,
+	1262,
+	1196,
+	1262,
+	1195,
+	1262,
+	1196,
+	1263,
+	1197,
+	1263,
+	1196,
+	1263,
+	1197,
+	1264,
+	1198,
+	1264,
+	1197,
+	1264,
+	1198,
+	1265,
+	1199,
+	1265,
+	1198,
+	1265,
+	1199,
+	1266,
+	1200,
+	1266,
+	1199,
+	1266,
+	1200,
+	1267,
+	1201,
+	1267,
+	1200,
+	1267,
+	1201,
+	1268,
+	1202,
+	1268,
+	1201,
+	1268,
+	1202,
+	1269,
+	1203,
+	1269,
+	1202,
+	1269,
+	1203,
+	1270,
+	1204,
+	1270,
+	1203,
+	1270,
+	1204,
+	1271,
+	1205,
+	1271,
+	1204,
+	1271,
+	1205,
+	1272,
+	1206,
+	1272,
+	1205,
+	1272,
+	1206,
+	1273,
+	1207,
+	1273,
+	1206,
+	1273,
+	1207,
+	1274,
+	1208,
+	1274,
+	1207,
+	1274,
+	1208,
+	1275,
+	1209,
+	1275,
+	1208,
+	1275,
+	1209,
+	1276,
+	1210,
+	1276,
+	1209,
+	1276,
+	1210,
+	1277,
+	1211,
+	1277,
+	1210,
+	1277,
+	1211,
+	1278,
+	1212,
+	1278,
+	1211,
+	1278,
+	1212,
+	1279,
+	1213,
+	1279,
+	1212,
+	1279,
+	1213,
+	1280,
+	1214,
+	1280,
+	1213,
+	1280,
+	1214,
+	1281,
+	1215,
+	1281,
+	1214,
+	1281,
+	1215,
+	1282,
+	1216,
+	1282,
+	1215,
+	1282,
+	1216,
+	1283,
+	1217,
+	1283,
+	1216,
+	1283,
+	1217,
+	1284,
+	1218,
+	1284,
+	1217,
+	1284,
+	1218,
+	1285,
+	1219,
+	1285,
+	1218,
+	1285,
+	1219,
+	1286,
+	1220,
+	1286,
+	1219,
+	1286,
+	1220,
+	1287,
+	1221,
+	1287,
+	1220,
+	1287,
+	1221,
+	1288,
+	1222,
+	1288,
+	1221,
+	1288,
+	1222,
+	1289,
+	1223,
+	1289,
+	1222,
+	1289,
+	1223,
+	1290,
+	1224,
+	1290,
+	1223,
+	1290,
+	1224,
+	1291,
+	1225,
+	1291,
+	1224,
+	1291,
+	1225,
+	1292,
+	1226,
+	1292,
+	1225,
+	1292,
+	1226,
+	1293,
+	1227,
+	1293,
+	1226,
+	1293,
+	1227,
+	1294,
+	1228,
+	1294,
+	1227,
+	1294,
+	1228,
+	1295,
+	1229,
+	1295,
+	1228,
+	1295,
+	1229,
+	1296,
+	1230,
+	1296,
+	1229,
+	1296,
+	1230,
+	1297,
+	1231,
+	1297,
+	1230,
+	1297,
+	1231,
+	1298,
+	1232,
+	1298,
+	1231,
+	1298,
+	1232,
+	1299,
+	1233,
+	1299,
+	1232,
+	1299,
+	1233,
+	1300,
+	1234,
+	1300,
+	1233,
+	1300,
+	1234,
+	1301,
+	1235,
+	1301,
+	1234,
+	1301,
+	1235,
+	1302,
+	1236,
+	1302,
+	1235,
+	1302,
+	1236,
+	1303,
+	1237,
+	1303,
+	1236,
+	1303,
+	1237,
+	1304,
+	1238,
+	1304,
+	1237,
+	1304,
+	1238,
+	1305,
+	1239,
+	1305,
+	1238,
+	1305,
+	1239,
+	1306,
+	1240,
+	1306,
+	1239,
+	1306,
+	1240,
+	1307,
+	1241,
+	1307,
+	1240,
+	1307,
+	1241,
+	1308,
+	1242,
+	1308,
+	1241,
+	1308,
+	1242,
+	1309,
+	1243,
+	1309,
+	1242,
+	1309,
+	1243,
+	1310,
+	1244,
+	1310,
+	1243,
+	1310,
+	1244,
+	1311,
+	1245,
+	1311,
+	1244,
+	1311,
+	1245,
+	1312,
+	1246,
+	1312,
+	1245,
+	1312,
+	1246,
+	1313,
+	1247,
+	1313,
+	1246,
+	1313,
+	1247,
+	1314,
+	1248,
+	1314,
+	1247,
+	1314,
+	1248,
+	1315,
+	1249,
+	1315,
+	1248,
+	1315,
+	1249,
+	1316,
+	1250,
+	1316,
+	1249,
+	1316,
+	1250,
+	1317,
+	1251,
+	1317,
+	1250,
+	1317,
+	1251,
+	1318,
+	1252,
+	1318,
+	1251,
+	1318,
+	1252,
+	1319,
+	1253,
+	1319,
+	1252,
+	1320,
+	1254,
+	1321,
+	1255,
+	1321,
+	1254,
+	1321,
+	1255,
+	1322,
+	1256,
+	1322,
+	1255,
+	1322,
+	1256,
+	1323,
+	1257,
+	1323,
+	1256,
+	1323,
+	1257,
+	1324,
+	1258,
+	1324,
+	1257,
+	1324,
+	1258,
+	1325,
+	1259,
+	1325,
+	1258,
+	1325,
+	1259,
+	1326,
+	1260,
+	1326,
+	1259,
+	1326,
+	1260,
+	1327,
+	1261,
+	1327,
+	1260,
+	1327,
+	1261,
+	1328,
+	1262,
+	1328,
+	1261,
+	1328,
+	1262,
+	1329,
+	1263,
+	1329,
+	1262,
+	1329,
+	1263,
+	1330,
+	1264,
+	1330,
+	1263,
+	1330,
+	1264,
+	1331,
+	1265,
+	1331,
+	1264,
+	1331,
+	1265,
+	1332,
+	1266,
+	1332,
+	1265,
+	1332,
+	1266,
+	1333,
+	1267,
+	1333,
+	1266,
+	1333,
+	1267,
+	1334,
+	1268,
+	1334,
+	1267,
+	1334,
+	1268,
+	1335,
+	1269,
+	1335,
+	1268,
+	1335,
+	1269,
+	1336,
+	1270,
+	1336,
+	1269,
+	1336,
+	1270,
+	1337,
+	1271,
+	1337,
+	1270,
+	1337,
+	1271,
+	1338,
+	1272,
+	1338,
+	1271,
+	1338,
+	1272,
+	1339,
+	1273,
+	1339,
+	1272,
+	1339,
+	1273,
+	1340,
+	1274,
+	1340,
+	1273,
+	1340,
+	1274,
+	1341,
+	1275,
+	1341,
+	1274,
+	1341,
+	1275,
+	1342,
+	1276,
+	1342,
+	1275,
+	1342,
+	1276,
+	1343,
+	1277,
+	1343,
+	1276,
+	1343,
+	1277,
+	1344,
+	1278,
+	1344,
+	1277,
+	1344,
+	1278,
+	1345,
+	1279,
+	1345,
+	1278,
+	1345,
+	1279,
+	1346,
+	1280,
+	1346,
+	1279,
+	1346,
+	1280,
+	1347,
+	1281,
+	1347,
+	1280,
+	1347,
+	1281,
+	1348,
+	1282,
+	1348,
+	1281,
+	1348,
+	1282,
+	1349,
+	1283,
+	1349,
+	1282,
+	1349,
+	1283,
+	1350,
+	1284,
+	1350,
+	1283,
+	1350,
+	1284,
+	1351,
+	1285,
+	1351,
+	1284,
+	1351,
+	1285,
+	1352,
+	1286,
+	1352,
+	1285,
+	1352,
+	1286,
+	1353,
+	1287,
+	1353,
+	1286,
+	1353,
+	1287,
+	1354,
+	1288,
+	1354,
+	1287,
+	1354,
+	1288,
+	1355,
+	1289,
+	1355,
+	1288,
+	1355,
+	1289,
+	1356,
+	1290,
+	1356,
+	1289,
+	1356,
+	1290,
+	1357,
+	1291,
+	1357,
+	1290,
+	1357,
+	1291,
+	1358,
+	1292,
+	1358,
+	1291,
+	1358,
+	1292,
+	1359,
+	1293,
+	1359,
+	1292,
+	1359,
+	1293,
+	1360,
+	1294,
+	1360,
+	1293,
+	1360,
+	1294,
+	1361,
+	1295,
+	1361,
+	1294,
+	1361,
+	1295,
+	1362,
+	1296,
+	1362,
+	1295,
+	1362,
+	1296,
+	1363,
+	1297,
+	1363,
+	1296,
+	1363,
+	1297,
+	1364,
+	1298,
+	1364,
+	1297,
+	1364,
+	1298,
+	1365,
+	1299,
+	1365,
+	1298,
+	1365,
+	1299,
+	1366,
+	1300,
+	1366,
+	1299,
+	1366,
+	1300,
+	1367,
+	1301,
+	1367,
+	1300,
+	1367,
+	1301,
+	1368,
+	1302,
+	1368,
+	1301,
+	1368,
+	1302,
+	1369,
+	1303,
+	1369,
+	1302,
+	1369,
+	1303,
+	1370,
+	1304,
+	1370,
+	1303,
+	1370,
+	1304,
+	1371,
+	1305,
+	1371,
+	1304,
+	1371,
+	1305,
+	1372,
+	1306,
+	1372,
+	1305,
+	1372,
+	1306,
+	1373,
+	1307,
+	1373,
+	1306,
+	1373,
+	1307,
+	1374,
+	1308,
+	1374,
+	1307,
+	1374,
+	1308,
+	1375,
+	1309,
+	1375,
+	1308,
+	1375,
+	1309,
+	1376,
+	1310,
+	1376,
+	1309,
+	1376,
+	1310,
+	1377,
+	1311,
+	1377,
+	1310,
+	1377,
+	1311,
+	1378,
+	1312,
+	1378,
+	1311,
+	1378,
+	1312,
+	1379,
+	1313,
+	1379,
+	1312,
+	1379,
+	1313,
+	1380,
+	1314,
+	1380,
+	1313,
+	1380,
+	1314,
+	1381,
+	1315,
+	1381,
+	1314,
+	1381,
+	1315,
+	1382,
+	1316,
+	1382,
+	1315,
+	1382,
+	1316,
+	1383,
+	1317,
+	1383,
+	1316,
+	1383,
+	1317,
+	1384,
+	1318,
+	1384,
+	1317,
+	1384,
+	1318,
+	1385,
+	1319,
+	1385,
+	1318,
+	1386,
+	1320,
+	1387,
+	1321,
+	1387,
+	1320,
+	1387,
+	1321,
+	1388,
+	1322,
+	1388,
+	1321,
+	1388,
+	1322,
+	1389,
+	1323,
+	1389,
+	1322,
+	1389,
+	1323,
+	1390,
+	1324,
+	1390,
+	1323,
+	1390,
+	1324,
+	1391,
+	1325,
+	1391,
+	1324,
+	1391,
+	1325,
+	1392,
+	1326,
+	1392,
+	1325,
+	1392,
+	1326,
+	1393,
+	1327,
+	1393,
+	1326,
+	1393,
+	1327,
+	1394,
+	1328,
+	1394,
+	1327,
+	1394,
+	1328,
+	1395,
+	1329,
+	1395,
+	1328,
+	1395,
+	1329,
+	1396,
+	1330,
+	1396,
+	1329,
+	1396,
+	1330,
+	1397,
+	1331,
+	1397,
+	1330,
+	1397,
+	1331,
+	1398,
+	1332,
+	1398,
+	1331,
+	1398,
+	1332,
+	1399,
+	1333,
+	1399,
+	1332,
+	1399,
+	1333,
+	1400,
+	1334,
+	1400,
+	1333,
+	1400,
+	1334,
+	1401,
+	1335,
+	1401,
+	1334,
+	1401,
+	1335,
+	1402,
+	1336,
+	1402,
+	1335,
+	1402,
+	1336,
+	1403,
+	1337,
+	1403,
+	1336,
+	1403,
+	1337,
+	1404,
+	1338,
+	1404,
+	1337,
+	1404,
+	1338,
+	1405,
+	1339,
+	1405,
+	1338,
+	1405,
+	1339,
+	1406,
+	1340,
+	1406,
+	1339,
+	1406,
+	1340,
+	1407,
+	1341,
+	1407,
+	1340,
+	1407,
+	1341,
+	1408,
+	1342,
+	1408,
+	1341,
+	1408,
+	1342,
+	1409,
+	1343,
+	1409,
+	1342,
+	1409,
+	1343,
+	1410,
+	1344,
+	1410,
+	1343,
+	1410,
+	1344,
+	1411,
+	1345,
+	1411,
+	1344,
+	1411,
+	1345,
+	1412,
+	1346,
+	1412,
+	1345,
+	1412,
+	1346,
+	1413,
+	1347,
+	1413,
+	1346,
+	1413,
+	1347,
+	1414,
+	1348,
+	1414,
+	1347,
+	1414,
+	1348,
+	1415,
+	1349,
+	1415,
+	1348,
+	1415,
+	1349,
+	1416,
+	1350,
+	1416,
+	1349,
+	1416,
+	1350,
+	1417,
+	1351,
+	1417,
+	1350,
+	1417,
+	1351,
+	1418,
+	1352,
+	1418,
+	1351,
+	1418,
+	1352,
+	1419,
+	1353,
+	1419,
+	1352,
+	1419,
+	1353,
+	1420,
+	1354,
+	1420,
+	1353,
+	1420,
+	1354,
+	1421,
+	1355,
+	1421,
+	1354,
+	1421,
+	1355,
+	1422,
+	1356,
+	1422,
+	1355,
+	1422,
+	1356,
+	1423,
+	1357,
+	1423,
+	1356,
+	1423,
+	1357,
+	1424,
+	1358,
+	1424,
+	1357,
+	1424,
+	1358,
+	1425,
+	1359,
+	1425,
+	1358,
+	1425,
+	1359,
+	1426,
+	1360,
+	1426,
+	1359,
+	1426,
+	1360,
+	1427,
+	1361,
+	1427,
+	1360,
+	1427,
+	1361,
+	1428,
+	1362,
+	1428,
+	1361,
+	1428,
+	1362,
+	1429,
+	1363,
+	1429,
+	1362,
+	1429,
+	1363,
+	1430,
+	1364,
+	1430,
+	1363,
+	1430,
+	1364,
+	1431,
+	1365,
+	1431,
+	1364,
+	1431,
+	1365,
+	1432,
+	1366,
+	1432,
+	1365,
+	1432,
+	1366,
+	1433,
+	1367,
+	1433,
+	1366,
+	1433,
+	1367,
+	1434,
+	1368,
+	1434,
+	1367,
+	1434,
+	1368,
+	1435,
+	1369,
+	1435,
+	1368,
+	1435,
+	1369,
+	1436,
+	1370,
+	1436,
+	1369,
+	1436,
+	1370,
+	1437,
+	1371,
+	1437,
+	1370,
+	1437,
+	1371,
+	1438,
+	1372,
+	1438,
+	1371,
+	1438,
+	1372,
+	1439,
+	1373,
+	1439,
+	1372,
+	1439,
+	1373,
+	1440,
+	1374,
+	1440,
+	1373,
+	1440,
+	1374,
+	1441,
+	1375,
+	1441,
+	1374,
+	1441,
+	1375,
+	1442,
+	1376,
+	1442,
+	1375,
+	1442,
+	1376,
+	1443,
+	1377,
+	1443,
+	1376,
+	1443,
+	1377,
+	1444,
+	1378,
+	1444,
+	1377,
+	1444,
+	1378,
+	1445,
+	1379,
+	1445,
+	1378,
+	1445,
+	1379,
+	1446,
+	1380,
+	1446,
+	1379,
+	1446,
+	1380,
+	1447,
+	1381,
+	1447,
+	1380,
+	1447,
+	1381,
+	1448,
+	1382,
+	1448,
+	1381,
+	1448,
+	1382,
+	1449,
+	1383,
+	1449,
+	1382,
+	1449,
+	1383,
+	1450,
+	1384,
+	1450,
+	1383,
+	1450,
+	1384,
+	1451,
+	1385,
+	1451,
+	1384,
+	1452,
+	1386,
+	1453,
+	1387,
+	1453,
+	1386,
+	1453,
+	1387,
+	1454,
+	1388,
+	1454,
+	1387,
+	1454,
+	1388,
+	1455,
+	1389,
+	1455,
+	1388,
+	1455,
+	1389,
+	1456,
+	1390,
+	1456,
+	1389,
+	1456,
+	1390,
+	1457,
+	1391,
+	1457,
+	1390,
+	1457,
+	1391,
+	1458,
+	1392,
+	1458,
+	1391,
+	1458,
+	1392,
+	1459,
+	1393,
+	1459,
+	1392,
+	1459,
+	1393,
+	1460,
+	1394,
+	1460,
+	1393,
+	1460,
+	1394,
+	1461,
+	1395,
+	1461,
+	1394,
+	1461,
+	1395,
+	1462,
+	1396,
+	1462,
+	1395,
+	1462,
+	1396,
+	1463,
+	1397,
+	1463,
+	1396,
+	1463,
+	1397,
+	1464,
+	1398,
+	1464,
+	1397,
+	1464,
+	1398,
+	1465,
+	1399,
+	1465,
+	1398,
+	1465,
+	1399,
+	1466,
+	1400,
+	1466,
+	1399,
+	1466,
+	1400,
+	1467,
+	1401,
+	1467,
+	1400,
+	1467,
+	1401,
+	1468,
+	1402,
+	1468,
+	1401,
+	1468,
+	1402,
+	1469,
+	1403,
+	1469,
+	1402,
+	1469,
+	1403,
+	1470,
+	1404,
+	1470,
+	1403,
+	1470,
+	1404,
+	1471,
+	1405,
+	1471,
+	1404,
+	1471,
+	1405,
+	1472,
+	1406,
+	1472,
+	1405,
+	1472,
+	1406,
+	1473,
+	1407,
+	1473,
+	1406,
+	1473,
+	1407,
+	1474,
+	1408,
+	1474,
+	1407,
+	1474,
+	1408,
+	1475,
+	1409,
+	1475,
+	1408,
+	1475,
+	1409,
+	1476,
+	1410,
+	1476,
+	1409,
+	1476,
+	1410,
+	1477,
+	1411,
+	1477,
+	1410,
+	1477,
+	1411,
+	1478,
+	1412,
+	1478,
+	1411,
+	1478,
+	1412,
+	1479,
+	1413,
+	1479,
+	1412,
+	1479,
+	1413,
+	1480,
+	1414,
+	1480,
+	1413,
+	1480,
+	1414,
+	1481,
+	1415,
+	1481,
+	1414,
+	1481,
+	1415,
+	1482,
+	1416,
+	1482,
+	1415,
+	1482,
+	1416,
+	1483,
+	1417,
+	1483,
+	1416,
+	1483,
+	1417,
+	1484,
+	1418,
+	1484,
+	1417,
+	1484,
+	1418,
+	1485,
+	1419,
+	1485,
+	1418,
+	1485,
+	1419,
+	1486,
+	1420,
+	1486,
+	1419,
+	1486,
+	1420,
+	1487,
+	1421,
+	1487,
+	1420,
+	1487,
+	1421,
+	1488,
+	1422,
+	1488,
+	1421,
+	1488,
+	1422,
+	1489,
+	1423,
+	1489,
+	1422,
+	1489,
+	1423,
+	1490,
+	1424,
+	1490,
+	1423,
+	1490,
+	1424,
+	1491,
+	1425,
+	1491,
+	1424,
+	1491,
+	1425,
+	1492,
+	1426,
+	1492,
+	1425,
+	1492,
+	1426,
+	1493,
+	1427,
+	1493,
+	1426,
+	1493,
+	1427,
+	1494,
+	1428,
+	1494,
+	1427,
+	1494,
+	1428,
+	1495,
+	1429,
+	1495,
+	1428,
+	1495,
+	1429,
+	1496,
+	1430,
+	1496,
+	1429,
+	1496,
+	1430,
+	1497,
+	1431,
+	1497,
+	1430,
+	1497,
+	1431,
+	1498,
+	1432,
+	1498,
+	1431,
+	1498,
+	1432,
+	1499,
+	1433,
+	1499,
+	1432,
+	1499,
+	1433,
+	1500,
+	1434,
+	1500,
+	1433,
+	1500,
+	1434,
+	1501,
+	1435,
+	1501,
+	1434,
+	1501,
+	1435,
+	1502,
+	1436,
+	1502,
+	1435,
+	1502,
+	1436,
+	1503,
+	1437,
+	1503,
+	1436,
+	1503,
+	1437,
+	1504,
+	1438,
+	1504,
+	1437,
+	1504,
+	1438,
+	1505,
+	1439,
+	1505,
+	1438,
+	1505,
+	1439,
+	1506,
+	1440,
+	1506,
+	1439,
+	1506,
+	1440,
+	1507,
+	1441,
+	1507,
+	1440,
+	1507,
+	1441,
+	1508,
+	1442,
+	1508,
+	1441,
+	1508,
+	1442,
+	1509,
+	1443,
+	1509,
+	1442,
+	1509,
+	1443,
+	1510,
+	1444,
+	1510,
+	1443,
+	1510,
+	1444,
+	1511,
+	1445,
+	1511,
+	1444,
+	1511,
+	1445,
+	1512,
+	1446,
+	1512,
+	1445,
+	1512,
+	1446,
+	1513,
+	1447,
+	1513,
+	1446,
+	1513,
+	1447,
+	1514,
+	1448,
+	1514,
+	1447,
+	1514,
+	1448,
+	1515,
+	1449,
+	1515,
+	1448,
+	1515,
+	1449,
+	1516,
+	1450,
+	1516,
+	1449,
+	1516,
+	1450,
+	1517,
+	1451,
+	1517,
+	1450,
+	1518,
+	1452,
+	1519,
+	1453,
+	1519,
+	1452,
+	1519,
+	1453,
+	1520,
+	1454,
+	1520,
+	1453,
+	1520,
+	1454,
+	1521,
+	1455,
+	1521,
+	1454,
+	1521,
+	1455,
+	1522,
+	1456,
+	1522,
+	1455,
+	1522,
+	1456,
+	1523,
+	1457,
+	1523,
+	1456,
+	1523,
+	1457,
+	1524,
+	1458,
+	1524,
+	1457,
+	1524,
+	1458,
+	1525,
+	1459,
+	1525,
+	1458,
+	1525,
+	1459,
+	1526,
+	1460,
+	1526,
+	1459,
+	1526,
+	1460,
+	1527,
+	1461,
+	1527,
+	1460,
+	1527,
+	1461,
+	1528,
+	1462,
+	1528,
+	1461,
+	1528,
+	1462,
+	1529,
+	1463,
+	1529,
+	1462,
+	1529,
+	1463,
+	1530,
+	1464,
+	1530,
+	1463,
+	1530,
+	1464,
+	1531,
+	1465,
+	1531,
+	1464,
+	1531,
+	1465,
+	1532,
+	1466,
+	1532,
+	1465,
+	1532,
+	1466,
+	1533,
+	1467,
+	1533,
+	1466,
+	1533,
+	1467,
+	1534,
+	1468,
+	1534,
+	1467,
+	1534,
+	1468,
+	1535,
+	1469,
+	1535,
+	1468,
+	1535,
+	1469,
+	1536,
+	1470,
+	1536,
+	1469,
+	1536,
+	1470,
+	1537,
+	1471,
+	1537,
+	1470,
+	1537,
+	1471,
+	1538,
+	1472,
+	1538,
+	1471,
+	1538,
+	1472,
+	1539,
+	1473,
+	1539,
+	1472,
+	1539,
+	1473,
+	1540,
+	1474,
+	1540,
+	1473,
+	1540,
+	1474,
+	1541,
+	1475,
+	1541,
+	1474,
+	1541,
+	1475,
+	1542,
+	1476,
+	1542,
+	1475,
+	1542,
+	1476,
+	1543,
+	1477,
+	1543,
+	1476,
+	1543,
+	1477,
+	1544,
+	1478,
+	1544,
+	1477,
+	1544,
+	1478,
+	1545,
+	1479,
+	1545,
+	1478,
+	1545,
+	1479,
+	1546,
+	1480,
+	1546,
+	1479,
+	1546,
+	1480,
+	1547,
+	1481,
+	1547,
+	1480,
+	1547,
+	1481,
+	1548,
+	1482,
+	1548,
+	1481,
+	1548,
+	1482,
+	1549,
+	1483,
+	1549,
+	1482,
+	1549,
+	1483,
+	1550,
+	1484,
+	1550,
+	1483,
+	1550,
+	1484,
+	1551,
+	1485,
+	1551,
+	1484,
+	1551,
+	1485,
+	1552,
+	1486,
+	1552,
+	1485,
+	1552,
+	1486,
+	1553,
+	1487,
+	1553,
+	1486,
+	1553,
+	1487,
+	1554,
+	1488,
+	1554,
+	1487,
+	1554,
+	1488,
+	1555,
+	1489,
+	1555,
+	1488,
+	1555,
+	1489,
+	1556,
+	1490,
+	1556,
+	1489,
+	1556,
+	1490,
+	1557,
+	1491,
+	1557,
+	1490,
+	1557,
+	1491,
+	1558,
+	1492,
+	1558,
+	1491,
+	1558,
+	1492,
+	1559,
+	1493,
+	1559,
+	1492,
+	1559,
+	1493,
+	1560,
+	1494,
+	1560,
+	1493,
+	1560,
+	1494,
+	1561,
+	1495,
+	1561,
+	1494,
+	1561,
+	1495,
+	1562,
+	1496,
+	1562,
+	1495,
+	1562,
+	1496,
+	1563,
+	1497,
+	1563,
+	1496,
+	1563,
+	1497,
+	1564,
+	1498,
+	1564,
+	1497,
+	1564,
+	1498,
+	1565,
+	1499,
+	1565,
+	1498,
+	1565,
+	1499,
+	1566,
+	1500,
+	1566,
+	1499,
+	1566,
+	1500,
+	1567,
+	1501,
+	1567,
+	1500,
+	1567,
+	1501,
+	1568,
+	1502,
+	1568,
+	1501,
+	1568,
+	1502,
+	1569,
+	1503,
+	1569,
+	1502,
+	1569,
+	1503,
+	1570,
+	1504,
+	1570,
+	1503,
+	1570,
+	1504,
+	1571,
+	1505,
+	1571,
+	1504,
+	1571,
+	1505,
+	1572,
+	1506,
+	1572,
+	1505,
+	1572,
+	1506,
+	1573,
+	1507,
+	1573,
+	1506,
+	1573,
+	1507,
+	1574,
+	1508,
+	1574,
+	1507,
+	1574,
+	1508,
+	1575,
+	1509,
+	1575,
+	1508,
+	1575,
+	1509,
+	1576,
+	1510,
+	1576,
+	1509,
+	1576,
+	1510,
+	1577,
+	1511,
+	1577,
+	1510,
+	1577,
+	1511,
+	1578,
+	1512,
+	1578,
+	1511,
+	1578,
+	1512,
+	1579,
+	1513,
+	1579,
+	1512,
+	1579,
+	1513,
+	1580,
+	1514,
+	1580,
+	1513,
+	1580,
+	1514,
+	1581,
+	1515,
+	1581,
+	1514,
+	1581,
+	1515,
+	1582,
+	1516,
+	1582,
+	1515,
+	1582,
+	1516,
+	1583,
+	1517,
+	1583,
+	1516,
+	1584,
+	1518,
+	1585,
+	1519,
+	1585,
+	1518,
+	1585,
+	1519,
+	1586,
+	1520,
+	1586,
+	1519,
+	1586,
+	1520,
+	1587,
+	1521,
+	1587,
+	1520,
+	1587,
+	1521,
+	1588,
+	1522,
+	1588,
+	1521,
+	1588,
+	1522,
+	1589,
+	1523,
+	1589,
+	1522,
+	1589,
+	1523,
+	1590,
+	1524,
+	1590,
+	1523,
+	1590,
+	1524,
+	1591,
+	1525,
+	1591,
+	1524,
+	1591,
+	1525,
+	1592,
+	1526,
+	1592,
+	1525,
+	1592,
+	1526,
+	1593,
+	1527,
+	1593,
+	1526,
+	1593,
+	1527,
+	1594,
+	1528,
+	1594,
+	1527,
+	1594,
+	1528,
+	1595,
+	1529,
+	1595,
+	1528,
+	1595,
+	1529,
+	1596,
+	1530,
+	1596,
+	1529,
+	1596,
+	1530,
+	1597,
+	1531,
+	1597,
+	1530,
+	1597,
+	1531,
+	1598,
+	1532,
+	1598,
+	1531,
+	1598,
+	1532,
+	1599,
+	1533,
+	1599,
+	1532,
+	1599,
+	1533,
+	1600,
+	1534,
+	1600,
+	1533,
+	1600,
+	1534,
+	1601,
+	1535,
+	1601,
+	1534,
+	1601,
+	1535,
+	1602,
+	1536,
+	1602,
+	1535,
+	1602,
+	1536,
+	1603,
+	1537,
+	1603,
+	1536,
+	1603,
+	1537,
+	1604,
+	1538,
+	1604,
+	1537,
+	1604,
+	1538,
+	1605,
+	1539,
+	1605,
+	1538,
+	1605,
+	1539,
+	1606,
+	1540,
+	1606,
+	1539,
+	1606,
+	1540,
+	1607,
+	1541,
+	1607,
+	1540,
+	1607,
+	1541,
+	1608,
+	1542,
+	1608,
+	1541,
+	1608,
+	1542,
+	1609,
+	1543,
+	1609,
+	1542,
+	1609,
+	1543,
+	1610,
+	1544,
+	1610,
+	1543,
+	1610,
+	1544,
+	1611,
+	1545,
+	1611,
+	1544,
+	1611,
+	1545,
+	1612,
+	1546,
+	1612,
+	1545,
+	1612,
+	1546,
+	1613,
+	1547,
+	1613,
+	1546,
+	1613,
+	1547,
+	1614,
+	1548,
+	1614,
+	1547,
+	1614,
+	1548,
+	1615,
+	1549,
+	1615,
+	1548,
+	1615,
+	1549,
+	1616,
+	1550,
+	1616,
+	1549,
+	1616,
+	1550,
+	1617,
+	1551,
+	1617,
+	1550,
+	1617,
+	1551,
+	1618,
+	1552,
+	1618,
+	1551,
+	1618,
+	1552,
+	1619,
+	1553,
+	1619,
+	1552,
+	1619,
+	1553,
+	1620,
+	1554,
+	1620,
+	1553,
+	1620,
+	1554,
+	1621,
+	1555,
+	1621,
+	1554,
+	1621,
+	1555,
+	1622,
+	1556,
+	1622,
+	1555,
+	1622,
+	1556,
+	1623,
+	1557,
+	1623,
+	1556,
+	1623,
+	1557,
+	1624,
+	1558,
+	1624,
+	1557,
+	1624,
+	1558,
+	1625,
+	1559,
+	1625,
+	1558,
+	1625,
+	1559,
+	1626,
+	1560,
+	1626,
+	1559,
+	1626,
+	1560,
+	1627,
+	1561,
+	1627,
+	1560,
+	1627,
+	1561,
+	1628,
+	1562,
+	1628,
+	1561,
+	1628,
+	1562,
+	1629,
+	1563,
+	1629,
+	1562,
+	1629,
+	1563,
+	1630,
+	1564,
+	1630,
+	1563,
+	1630,
+	1564,
+	1631,
+	1565,
+	1631,
+	1564,
+	1631,
+	1565,
+	1632,
+	1566,
+	1632,
+	1565,
+	1632,
+	1566,
+	1633,
+	1567,
+	1633,
+	1566,
+	1633,
+	1567,
+	1634,
+	1568,
+	1634,
+	1567,
+	1634,
+	1568,
+	1635,
+	1569,
+	1635,
+	1568,
+	1635,
+	1569,
+	1636,
+	1570,
+	1636,
+	1569,
+	1636,
+	1570,
+	1637,
+	1571,
+	1637,
+	1570,
+	1637,
+	1571,
+	1638,
+	1572,
+	1638,
+	1571,
+	1638,
+	1572,
+	1639,
+	1573,
+	1639,
+	1572,
+	1639,
+	1573,
+	1640,
+	1574,
+	1640,
+	1573,
+	1640,
+	1574,
+	1641,
+	1575,
+	1641,
+	1574,
+	1641,
+	1575,
+	1642,
+	1576,
+	1642,
+	1575,
+	1642,
+	1576,
+	1643,
+	1577,
+	1643,
+	1576,
+	1643,
+	1577,
+	1644,
+	1578,
+	1644,
+	1577,
+	1644,
+	1578,
+	1645,
+	1579,
+	1645,
+	1578,
+	1645,
+	1579,
+	1646,
+	1580,
+	1646,
+	1579,
+	1646,
+	1580,
+	1647,
+	1581,
+	1647,
+	1580,
+	1647,
+	1581,
+	1648,
+	1582,
+	1648,
+	1581,
+	1648,
+	1582,
+	1649,
+	1583,
+	1649,
+	1582,
+	1650,
+	1584,
+	1651,
+	1585,
+	1651,
+	1584,
+	1651,
+	1585,
+	1652,
+	1586,
+	1652,
+	1585,
+	1652,
+	1586,
+	1653,
+	1587,
+	1653,
+	1586,
+	1653,
+	1587,
+	1654,
+	1588,
+	1654,
+	1587,
+	1654,
+	1588,
+	1655,
+	1589,
+	1655,
+	1588,
+	1655,
+	1589,
+	1656,
+	1590,
+	1656,
+	1589,
+	1656,
+	1590,
+	1657,
+	1591,
+	1657,
+	1590,
+	1657,
+	1591,
+	1658,
+	1592,
+	1658,
+	1591,
+	1658,
+	1592,
+	1659,
+	1593,
+	1659,
+	1592,
+	1659,
+	1593,
+	1660,
+	1594,
+	1660,
+	1593,
+	1660,
+	1594,
+	1661,
+	1595,
+	1661,
+	1594,
+	1661,
+	1595,
+	1662,
+	1596,
+	1662,
+	1595,
+	1662,
+	1596,
+	1663,
+	1597,
+	1663,
+	1596,
+	1663,
+	1597,
+	1664,
+	1598,
+	1664,
+	1597,
+	1664,
+	1598,
+	1665,
+	1599,
+	1665,
+	1598,
+	1665,
+	1599,
+	1666,
+	1600,
+	1666,
+	1599,
+	1666,
+	1600,
+	1667,
+	1601,
+	1667,
+	1600,
+	1667,
+	1601,
+	1668,
+	1602,
+	1668,
+	1601,
+	1668,
+	1602,
+	1669,
+	1603,
+	1669,
+	1602,
+	1669,
+	1603,
+	1670,
+	1604,
+	1670,
+	1603,
+	1670,
+	1604,
+	1671,
+	1605,
+	1671,
+	1604,
+	1671,
+	1605,
+	1672,
+	1606,
+	1672,
+	1605,
+	1672,
+	1606,
+	1673,
+	1607,
+	1673,
+	1606,
+	1673,
+	1607,
+	1674,
+	1608,
+	1674,
+	1607,
+	1674,
+	1608,
+	1675,
+	1609,
+	1675,
+	1608,
+	1675,
+	1609,
+	1676,
+	1610,
+	1676,
+	1609,
+	1676,
+	1610,
+	1677,
+	1611,
+	1677,
+	1610,
+	1677,
+	1611,
+	1678,
+	1612,
+	1678,
+	1611,
+	1678,
+	1612,
+	1679,
+	1613,
+	1679,
+	1612,
+	1679,
+	1613,
+	1680,
+	1614,
+	1680,
+	1613,
+	1680,
+	1614,
+	1681,
+	1615,
+	1681,
+	1614,
+	1681,
+	1615,
+	1682,
+	1616,
+	1682,
+	1615,
+	1682,
+	1616,
+	1683,
+	1617,
+	1683,
+	1616,
+	1683,
+	1617,
+	1684,
+	1618,
+	1684,
+	1617,
+	1684,
+	1618,
+	1685,
+	1619,
+	1685,
+	1618,
+	1685,
+	1619,
+	1686,
+	1620,
+	1686,
+	1619,
+	1686,
+	1620,
+	1687,
+	1621,
+	1687,
+	1620,
+	1687,
+	1621,
+	1688,
+	1622,
+	1688,
+	1621,
+	1688,
+	1622,
+	1689,
+	1623,
+	1689,
+	1622,
+	1689,
+	1623,
+	1690,
+	1624,
+	1690,
+	1623,
+	1690,
+	1624,
+	1691,
+	1625,
+	1691,
+	1624,
+	1691,
+	1625,
+	1692,
+	1626,
+	1692,
+	1625,
+	1692,
+	1626,
+	1693,
+	1627,
+	1693,
+	1626,
+	1693,
+	1627,
+	1694,
+	1628,
+	1694,
+	1627,
+	1694,
+	1628,
+	1695,
+	1629,
+	1695,
+	1628,
+	1695,
+	1629,
+	1696,
+	1630,
+	1696,
+	1629,
+	1696,
+	1630,
+	1697,
+	1631,
+	1697,
+	1630,
+	1697,
+	1631,
+	1698,
+	1632,
+	1698,
+	1631,
+	1698,
+	1632,
+	1699,
+	1633,
+	1699,
+	1632,
+	1699,
+	1633,
+	1700,
+	1634,
+	1700,
+	1633,
+	1700,
+	1634,
+	1701,
+	1635,
+	1701,
+	1634,
+	1701,
+	1635,
+	1702,
+	1636,
+	1702,
+	1635,
+	1702,
+	1636,
+	1703,
+	1637,
+	1703,
+	1636,
+	1703,
+	1637,
+	1704,
+	1638,
+	1704,
+	1637,
+	1704,
+	1638,
+	1705,
+	1639,
+	1705,
+	1638,
+	1705,
+	1639,
+	1706,
+	1640,
+	1706,
+	1639,
+	1706,
+	1640,
+	1707,
+	1641,
+	1707,
+	1640,
+	1707,
+	1641,
+	1708,
+	1642,
+	1708,
+	1641,
+	1708,
+	1642,
+	1709,
+	1643,
+	1709,
+	1642,
+	1709,
+	1643,
+	1710,
+	1644,
+	1710,
+	1643,
+	1710,
+	1644,
+	1711,
+	1645,
+	1711,
+	1644,
+	1711,
+	1645,
+	1712,
+	1646,
+	1712,
+	1645,
+	1712,
+	1646,
+	1713,
+	1647,
+	1713,
+	1646,
+	1713,
+	1647,
+	1714,
+	1648,
+	1714,
+	1647,
+	1714,
+	1648,
+	1715,
+	1649,
+	1715,
+	1648,
+	1716,
+	1650,
+	1717,
+	1651,
+	1717,
+	1650,
+	1717,
+	1651,
+	1718,
+	1652,
+	1718,
+	1651,
+	1718,
+	1652,
+	1719,
+	1653,
+	1719,
+	1652,
+	1719,
+	1653,
+	1720,
+	1654,
+	1720,
+	1653,
+	1720,
+	1654,
+	1721,
+	1655,
+	1721,
+	1654,
+	1721,
+	1655,
+	1722,
+	1656,
+	1722,
+	1655,
+	1722,
+	1656,
+	1723,
+	1657,
+	1723,
+	1656,
+	1723,
+	1657,
+	1724,
+	1658,
+	1724,
+	1657,
+	1724,
+	1658,
+	1725,
+	1659,
+	1725,
+	1658,
+	1725,
+	1659,
+	1726,
+	1660,
+	1726,
+	1659,
+	1726,
+	1660,
+	1727,
+	1661,
+	1727,
+	1660,
+	1727,
+	1661,
+	1728,
+	1662,
+	1728,
+	1661,
+	1728,
+	1662,
+	1729,
+	1663,
+	1729,
+	1662,
+	1729,
+	1663,
+	1730,
+	1664,
+	1730,
+	1663,
+	1730,
+	1664,
+	1731,
+	1665,
+	1731,
+	1664,
+	1731,
+	1665,
+	1732,
+	1666,
+	1732,
+	1665,
+	1732,
+	1666,
+	1733,
+	1667,
+	1733,
+	1666,
+	1733,
+	1667,
+	1734,
+	1668,
+	1734,
+	1667,
+	1734,
+	1668,
+	1735,
+	1669,
+	1735,
+	1668,
+	1735,
+	1669,
+	1736,
+	1670,
+	1736,
+	1669,
+	1736,
+	1670,
+	1737,
+	1671,
+	1737,
+	1670,
+	1737,
+	1671,
+	1738,
+	1672,
+	1738,
+	1671,
+	1738,
+	1672,
+	1739,
+	1673,
+	1739,
+	1672,
+	1739,
+	1673,
+	1740,
+	1674,
+	1740,
+	1673,
+	1740,
+	1674,
+	1741,
+	1675,
+	1741,
+	1674,
+	1741,
+	1675,
+	1742,
+	1676,
+	1742,
+	1675,
+	1742,
+	1676,
+	1743,
+	1677,
+	1743,
+	1676,
+	1743,
+	1677,
+	1744,
+	1678,
+	1744,
+	1677,
+	1744,
+	1678,
+	1745,
+	1679,
+	1745,
+	1678,
+	1745,
+	1679,
+	1746,
+	1680,
+	1746,
+	1679,
+	1746,
+	1680,
+	1747,
+	1681,
+	1747,
+	1680,
+	1747,
+	1681,
+	1748,
+	1682,
+	1748,
+	1681,
+	1748,
+	1682,
+	1749,
+	1683,
+	1749,
+	1682,
+	1749,
+	1683,
+	1750,
+	1684,
+	1750,
+	1683,
+	1750,
+	1684,
+	1751,
+	1685,
+	1751,
+	1684,
+	1751,
+	1685,
+	1752,
+	1686,
+	1752,
+	1685,
+	1752,
+	1686,
+	1753,
+	1687,
+	1753,
+	1686,
+	1753,
+	1687,
+	1754,
+	1688,
+	1754,
+	1687,
+	1754,
+	1688,
+	1755,
+	1689,
+	1755,
+	1688,
+	1755,
+	1689,
+	1756,
+	1690,
+	1756,
+	1689,
+	1756,
+	1690,
+	1757,
+	1691,
+	1757,
+	1690,
+	1757,
+	1691,
+	1758,
+	1692,
+	1758,
+	1691,
+	1758,
+	1692,
+	1759,
+	1693,
+	1759,
+	1692,
+	1759,
+	1693,
+	1760,
+	1694,
+	1760,
+	1693,
+	1760,
+	1694,
+	1761,
+	1695,
+	1761,
+	1694,
+	1761,
+	1695,
+	1762,
+	1696,
+	1762,
+	1695,
+	1762,
+	1696,
+	1763,
+	1697,
+	1763,
+	1696,
+	1763,
+	1697,
+	1764,
+	1698,
+	1764,
+	1697,
+	1764,
+	1698,
+	1765,
+	1699,
+	1765,
+	1698,
+	1765,
+	1699,
+	1766,
+	1700,
+	1766,
+	1699,
+	1766,
+	1700,
+	1767,
+	1701,
+	1767,
+	1700,
+	1767,
+	1701,
+	1768,
+	1702,
+	1768,
+	1701,
+	1768,
+	1702,
+	1769,
+	1703,
+	1769,
+	1702,
+	1769,
+	1703,
+	1770,
+	1704,
+	1770,
+	1703,
+	1770,
+	1704,
+	1771,
+	1705,
+	1771,
+	1704,
+	1771,
+	1705,
+	1772,
+	1706,
+	1772,
+	1705,
+	1772,
+	1706,
+	1773,
+	1707,
+	1773,
+	1706,
+	1773,
+	1707,
+	1774,
+	1708,
+	1774,
+	1707,
+	1774,
+	1708,
+	1775,
+	1709,
+	1775,
+	1708,
+	1775,
+	1709,
+	1776,
+	1710,
+	1776,
+	1709,
+	1776,
+	1710,
+	1777,
+	1711,
+	1777,
+	1710,
+	1777,
+	1711,
+	1778,
+	1712,
+	1778,
+	1711,
+	1778,
+	1712,
+	1779,
+	1713,
+	1779,
+	1712,
+	1779,
+	1713,
+	1780,
+	1714,
+	1780,
+	1713,
+	1780,
+	1714,
+	1781,
+	1715,
+	1781,
+	1714,
+	1782,
+	1716,
+	1783,
+	1717,
+	1783,
+	1716,
+	1783,
+	1717,
+	1784,
+	1718,
+	1784,
+	1717,
+	1784,
+	1718,
+	1785,
+	1719,
+	1785,
+	1718,
+	1785,
+	1719,
+	1786,
+	1720,
+	1786,
+	1719,
+	1786,
+	1720,
+	1787,
+	1721,
+	1787,
+	1720,
+	1787,
+	1721,
+	1788,
+	1722,
+	1788,
+	1721,
+	1788,
+	1722,
+	1789,
+	1723,
+	1789,
+	1722,
+	1789,
+	1723,
+	1790,
+	1724,
+	1790,
+	1723,
+	1790,
+	1724,
+	1791,
+	1725,
+	1791,
+	1724,
+	1791,
+	1725,
+	1792,
+	1726,
+	1792,
+	1725,
+	1792,
+	1726,
+	1793,
+	1727,
+	1793,
+	1726,
+	1793,
+	1727,
+	1794,
+	1728,
+	1794,
+	1727,
+	1794,
+	1728,
+	1795,
+	1729,
+	1795,
+	1728,
+	1795,
+	1729,
+	1796,
+	1730,
+	1796,
+	1729,
+	1796,
+	1730,
+	1797,
+	1731,
+	1797,
+	1730,
+	1797,
+	1731,
+	1798,
+	1732,
+	1798,
+	1731,
+	1798,
+	1732,
+	1799,
+	1733,
+	1799,
+	1732,
+	1799,
+	1733,
+	1800,
+	1734,
+	1800,
+	1733,
+	1800,
+	1734,
+	1801,
+	1735,
+	1801,
+	1734,
+	1801,
+	1735,
+	1802,
+	1736,
+	1802,
+	1735,
+	1802,
+	1736,
+	1803,
+	1737,
+	1803,
+	1736,
+	1803,
+	1737,
+	1804,
+	1738,
+	1804,
+	1737,
+	1804,
+	1738,
+	1805,
+	1739,
+	1805,
+	1738,
+	1805,
+	1739,
+	1806,
+	1740,
+	1806,
+	1739,
+	1806,
+	1740,
+	1807,
+	1741,
+	1807,
+	1740,
+	1807,
+	1741,
+	1808,
+	1742,
+	1808,
+	1741,
+	1808,
+	1742,
+	1809,
+	1743,
+	1809,
+	1742,
+	1809,
+	1743,
+	1810,
+	1744,
+	1810,
+	1743,
+	1810,
+	1744,
+	1811,
+	1745,
+	1811,
+	1744,
+	1811,
+	1745,
+	1812,
+	1746,
+	1812,
+	1745,
+	1812,
+	1746,
+	1813,
+	1747,
+	1813,
+	1746,
+	1813,
+	1747,
+	1814,
+	1748,
+	1814,
+	1747,
+	1814,
+	1748,
+	1815,
+	1749,
+	1815,
+	1748,
+	1815,
+	1749,
+	1816,
+	1750,
+	1816,
+	1749,
+	1816,
+	1750,
+	1817,
+	1751,
+	1817,
+	1750,
+	1817,
+	1751,
+	1818,
+	1752,
+	1818,
+	1751,
+	1818,
+	1752,
+	1819,
+	1753,
+	1819,
+	1752,
+	1819,
+	1753,
+	1820,
+	1754,
+	1820,
+	1753,
+	1820,
+	1754,
+	1821,
+	1755,
+	1821,
+	1754,
+	1821,
+	1755,
+	1822,
+	1756,
+	1822,
+	1755,
+	1822,
+	1756,
+	1823,
+	1757,
+	1823,
+	1756,
+	1823,
+	1757,
+	1824,
+	1758,
+	1824,
+	1757,
+	1824,
+	1758,
+	1825,
+	1759,
+	1825,
+	1758,
+	1825,
+	1759,
+	1826,
+	1760,
+	1826,
+	1759,
+	1826,
+	1760,
+	1827,
+	1761,
+	1827,
+	1760,
+	1827,
+	1761,
+	1828,
+	1762,
+	1828,
+	1761,
+	1828,
+	1762,
+	1829,
+	1763,
+	1829,
+	1762,
+	1829,
+	1763,
+	1830,
+	1764,
+	1830,
+	1763,
+	1830,
+	1764,
+	1831,
+	1765,
+	1831,
+	1764,
+	1831,
+	1765,
+	1832,
+	1766,
+	1832,
+	1765,
+	1832,
+	1766,
+	1833,
+	1767,
+	1833,
+	1766,
+	1833,
+	1767,
+	1834,
+	1768,
+	1834,
+	1767,
+	1834,
+	1768,
+	1835,
+	1769,
+	1835,
+	1768,
+	1835,
+	1769,
+	1836,
+	1770,
+	1836,
+	1769,
+	1836,
+	1770,
+	1837,
+	1771,
+	1837,
+	1770,
+	1837,
+	1771,
+	1838,
+	1772,
+	1838,
+	1771,
+	1838,
+	1772,
+	1839,
+	1773,
+	1839,
+	1772,
+	1839,
+	1773,
+	1840,
+	1774,
+	1840,
+	1773,
+	1840,
+	1774,
+	1841,
+	1775,
+	1841,
+	1774,
+	1841,
+	1775,
+	1842,
+	1776,
+	1842,
+	1775,
+	1842,
+	1776,
+	1843,
+	1777,
+	1843,
+	1776,
+	1843,
+	1777,
+	1844,
+	1778,
+	1844,
+	1777,
+	1844,
+	1778,
+	1845,
+	1779,
+	1845,
+	1778,
+	1845,
+	1779,
+	1846,
+	1780,
+	1846,
+	1779,
+	1846,
+	1780,
+	1847,
+	1781,
+	1847,
+	1780,
+	1848,
+	1782,
+	1849,
+	1783,
+	1849,
+	1782,
+	1849,
+	1783,
+	1850,
+	1784,
+	1850,
+	1783,
+	1850,
+	1784,
+	1851,
+	1785,
+	1851,
+	1784,
+	1851,
+	1785,
+	1852,
+	1786,
+	1852,
+	1785,
+	1852,
+	1786,
+	1853,
+	1787,
+	1853,
+	1786,
+	1853,
+	1787,
+	1854,
+	1788,
+	1854,
+	1787,
+	1854,
+	1788,
+	1855,
+	1789,
+	1855,
+	1788,
+	1855,
+	1789,
+	1856,
+	1790,
+	1856,
+	1789,
+	1856,
+	1790,
+	1857,
+	1791,
+	1857,
+	1790,
+	1857,
+	1791,
+	1858,
+	1792,
+	1858,
+	1791,
+	1858,
+	1792,
+	1859,
+	1793,
+	1859,
+	1792,
+	1859,
+	1793,
+	1860,
+	1794,
+	1860,
+	1793,
+	1860,
+	1794,
+	1861,
+	1795,
+	1861,
+	1794,
+	1861,
+	1795,
+	1862,
+	1796,
+	1862,
+	1795,
+	1862,
+	1796,
+	1863,
+	1797,
+	1863,
+	1796,
+	1863,
+	1797,
+	1864,
+	1798,
+	1864,
+	1797,
+	1864,
+	1798,
+	1865,
+	1799,
+	1865,
+	1798,
+	1865,
+	1799,
+	1866,
+	1800,
+	1866,
+	1799,
+	1866,
+	1800,
+	1867,
+	1801,
+	1867,
+	1800,
+	1867,
+	1801,
+	1868,
+	1802,
+	1868,
+	1801,
+	1868,
+	1802,
+	1869,
+	1803,
+	1869,
+	1802,
+	1869,
+	1803,
+	1870,
+	1804,
+	1870,
+	1803,
+	1870,
+	1804,
+	1871,
+	1805,
+	1871,
+	1804,
+	1871,
+	1805,
+	1872,
+	1806,
+	1872,
+	1805,
+	1872,
+	1806,
+	1873,
+	1807,
+	1873,
+	1806,
+	1873,
+	1807,
+	1874,
+	1808,
+	1874,
+	1807,
+	1874,
+	1808,
+	1875,
+	1809,
+	1875,
+	1808,
+	1875,
+	1809,
+	1876,
+	1810,
+	1876,
+	1809,
+	1876,
+	1810,
+	1877,
+	1811,
+	1877,
+	1810,
+	1877,
+	1811,
+	1878,
+	1812,
+	1878,
+	1811,
+	1878,
+	1812,
+	1879,
+	1813,
+	1879,
+	1812,
+	1879,
+	1813,
+	1880,
+	1814,
+	1880,
+	1813,
+	1880,
+	1814,
+	1881,
+	1815,
+	1881,
+	1814,
+	1881,
+	1815,
+	1882,
+	1816,
+	1882,
+	1815,
+	1882,
+	1816,
+	1883,
+	1817,
+	1883,
+	1816,
+	1883,
+	1817,
+	1884,
+	1818,
+	1884,
+	1817,
+	1884,
+	1818,
+	1885,
+	1819,
+	1885,
+	1818,
+	1885,
+	1819,
+	1886,
+	1820,
+	1886,
+	1819,
+	1886,
+	1820,
+	1887,
+	1821,
+	1887,
+	1820,
+	1887,
+	1821,
+	1888,
+	1822,
+	1888,
+	1821,
+	1888,
+	1822,
+	1889,
+	1823,
+	1889,
+	1822,
+	1889,
+	1823,
+	1890,
+	1824,
+	1890,
+	1823,
+	1890,
+	1824,
+	1891,
+	1825,
+	1891,
+	1824,
+	1891,
+	1825,
+	1892,
+	1826,
+	1892,
+	1825,
+	1892,
+	1826,
+	1893,
+	1827,
+	1893,
+	1826,
+	1893,
+	1827,
+	1894,
+	1828,
+	1894,
+	1827,
+	1894,
+	1828,
+	1895,
+	1829,
+	1895,
+	1828,
+	1895,
+	1829,
+	1896,
+	1830,
+	1896,
+	1829,
+	1896,
+	1830,
+	1897,
+	1831,
+	1897,
+	1830,
+	1897,
+	1831,
+	1898,
+	1832,
+	1898,
+	1831,
+	1898,
+	1832,
+	1899,
+	1833,
+	1899,
+	1832,
+	1899,
+	1833,
+	1900,
+	1834,
+	1900,
+	1833,
+	1900,
+	1834,
+	1901,
+	1835,
+	1901,
+	1834,
+	1901,
+	1835,
+	1902,
+	1836,
+	1902,
+	1835,
+	1902,
+	1836,
+	1903,
+	1837,
+	1903,
+	1836,
+	1903,
+	1837,
+	1904,
+	1838,
+	1904,
+	1837,
+	1904,
+	1838,
+	1905,
+	1839,
+	1905,
+	1838,
+	1905,
+	1839,
+	1906,
+	1840,
+	1906,
+	1839,
+	1906,
+	1840,
+	1907,
+	1841,
+	1907,
+	1840,
+	1907,
+	1841,
+	1908,
+	1842,
+	1908,
+	1841,
+	1908,
+	1842,
+	1909,
+	1843,
+	1909,
+	1842,
+	1909,
+	1843,
+	1910,
+	1844,
+	1910,
+	1843,
+	1910,
+	1844,
+	1911,
+	1845,
+	1911,
+	1844,
+	1911,
+	1845,
+	1912,
+	1846,
+	1912,
+	1845,
+	1912,
+	1846,
+	1913,
+	1847,
+	1913,
+	1846,
+	1914,
+	1848,
+	1915,
+	1849,
+	1915,
+	1848,
+	1915,
+	1849,
+	1916,
+	1850,
+	1916,
+	1849,
+	1916,
+	1850,
+	1917,
+	1851,
+	1917,
+	1850,
+	1917,
+	1851,
+	1918,
+	1852,
+	1918,
+	1851,
+	1918,
+	1852,
+	1919,
+	1853,
+	1919,
+	1852,
+	1919,
+	1853,
+	1920,
+	1854,
+	1920,
+	1853,
+	1920,
+	1854,
+	1921,
+	1855,
+	1921,
+	1854,
+	1921,
+	1855,
+	1922,
+	1856,
+	1922,
+	1855,
+	1922,
+	1856,
+	1923,
+	1857,
+	1923,
+	1856,
+	1923,
+	1857,
+	1924,
+	1858,
+	1924,
+	1857,
+	1924,
+	1858,
+	1925,
+	1859,
+	1925,
+	1858,
+	1925,
+	1859,
+	1926,
+	1860,
+	1926,
+	1859,
+	1926,
+	1860,
+	1927,
+	1861,
+	1927,
+	1860,
+	1927,
+	1861,
+	1928,
+	1862,
+	1928,
+	1861,
+	1928,
+	1862,
+	1929,
+	1863,
+	1929,
+	1862,
+	1929,
+	1863,
+	1930,
+	1864,
+	1930,
+	1863,
+	1930,
+	1864,
+	1931,
+	1865,
+	1931,
+	1864,
+	1931,
+	1865,
+	1932,
+	1866,
+	1932,
+	1865,
+	1932,
+	1866,
+	1933,
+	1867,
+	1933,
+	1866,
+	1933,
+	1867,
+	1934,
+	1868,
+	1934,
+	1867,
+	1934,
+	1868,
+	1935,
+	1869,
+	1935,
+	1868,
+	1935,
+	1869,
+	1936,
+	1870,
+	1936,
+	1869,
+	1936,
+	1870,
+	1937,
+	1871,
+	1937,
+	1870,
+	1937,
+	1871,
+	1938,
+	1872,
+	1938,
+	1871,
+	1938,
+	1872,
+	1939,
+	1873,
+	1939,
+	1872,
+	1939,
+	1873,
+	1940,
+	1874,
+	1940,
+	1873,
+	1940,
+	1874,
+	1941,
+	1875,
+	1941,
+	1874,
+	1941,
+	1875,
+	1942,
+	1876,
+	1942,
+	1875,
+	1942,
+	1876,
+	1943,
+	1877,
+	1943,
+	1876,
+	1943,
+	1877,
+	1944,
+	1878,
+	1944,
+	1877,
+	1944,
+	1878,
+	1945,
+	1879,
+	1945,
+	1878,
+	1945,
+	1879,
+	1946,
+	1880,
+	1946,
+	1879,
+	1946,
+	1880,
+	1947,
+	1881,
+	1947,
+	1880,
+	1947,
+	1881,
+	1948,
+	1882,
+	1948,
+	1881,
+	1948,
+	1882,
+	1949,
+	1883,
+	1949,
+	1882,
+	1949,
+	1883,
+	1950,
+	1884,
+	1950,
+	1883,
+	1950,
+	1884,
+	1951,
+	1885,
+	1951,
+	1884,
+	1951,
+	1885,
+	1952,
+	1886,
+	1952,
+	1885,
+	1952,
+	1886,
+	1953,
+	1887,
+	1953,
+	1886,
+	1953,
+	1887,
+	1954,
+	1888,
+	1954,
+	1887,
+	1954,
+	1888,
+	1955,
+	1889,
+	1955,
+	1888,
+	1955,
+	1889,
+	1956,
+	1890,
+	1956,
+	1889,
+	1956,
+	1890,
+	1957,
+	1891,
+	1957,
+	1890,
+	1957,
+	1891,
+	1958,
+	1892,
+	1958,
+	1891,
+	1958,
+	1892,
+	1959,
+	1893,
+	1959,
+	1892,
+	1959,
+	1893,
+	1960,
+	1894,
+	1960,
+	1893,
+	1960,
+	1894,
+	1961,
+	1895,
+	1961,
+	1894,
+	1961,
+	1895,
+	1962,
+	1896,
+	1962,
+	1895,
+	1962,
+	1896,
+	1963,
+	1897,
+	1963,
+	1896,
+	1963,
+	1897,
+	1964,
+	1898,
+	1964,
+	1897,
+	1964,
+	1898,
+	1965,
+	1899,
+	1965,
+	1898,
+	1965,
+	1899,
+	1966,
+	1900,
+	1966,
+	1899,
+	1966,
+	1900,
+	1967,
+	1901,
+	1967,
+	1900,
+	1967,
+	1901,
+	1968,
+	1902,
+	1968,
+	1901,
+	1968,
+	1902,
+	1969,
+	1903,
+	1969,
+	1902,
+	1969,
+	1903,
+	1970,
+	1904,
+	1970,
+	1903,
+	1970,
+	1904,
+	1971,
+	1905,
+	1971,
+	1904,
+	1971,
+	1905,
+	1972,
+	1906,
+	1972,
+	1905,
+	1972,
+	1906,
+	1973,
+	1907,
+	1973,
+	1906,
+	1973,
+	1907,
+	1974,
+	1908,
+	1974,
+	1907,
+	1974,
+	1908,
+	1975,
+	1909,
+	1975,
+	1908,
+	1975,
+	1909,
+	1976,
+	1910,
+	1976,
+	1909,
+	1976,
+	1910,
+	1977,
+	1911,
+	1977,
+	1910,
+	1977,
+	1911,
+	1978,
+	1912,
+	1978,
+	1911,
+	1978,
+	1912,
+	1979,
+	1913,
+	1979,
+	1912,
+	1980,
+	1914,
+	1981,
+	1915,
+	1981,
+	1914,
+	1981,
+	1915,
+	1982,
+	1916,
+	1982,
+	1915,
+	1982,
+	1916,
+	1983,
+	1917,
+	1983,
+	1916,
+	1983,
+	1917,
+	1984,
+	1918,
+	1984,
+	1917,
+	1984,
+	1918,
+	1985,
+	1919,
+	1985,
+	1918,
+	1985,
+	1919,
+	1986,
+	1920,
+	1986,
+	1919,
+	1986,
+	1920,
+	1987,
+	1921,
+	1987,
+	1920,
+	1987,
+	1921,
+	1988,
+	1922,
+	1988,
+	1921,
+	1988,
+	1922,
+	1989,
+	1923,
+	1989,
+	1922,
+	1989,
+	1923,
+	1990,
+	1924,
+	1990,
+	1923,
+	1990,
+	1924,
+	1991,
+	1925,
+	1991,
+	1924,
+	1991,
+	1925,
+	1992,
+	1926,
+	1992,
+	1925,
+	1992,
+	1926,
+	1993,
+	1927,
+	1993,
+	1926,
+	1993,
+	1927,
+	1994,
+	1928,
+	1994,
+	1927,
+	1994,
+	1928,
+	1995,
+	1929,
+	1995,
+	1928,
+	1995,
+	1929,
+	1996,
+	1930,
+	1996,
+	1929,
+	1996,
+	1930,
+	1997,
+	1931,
+	1997,
+	1930,
+	1997,
+	1931,
+	1998,
+	1932,
+	1998,
+	1931,
+	1998,
+	1932,
+	1999,
+	1933,
+	1999,
+	1932,
+	1999,
+	1933,
+	2000,
+	1934,
+	2000,
+	1933,
+	2000,
+	1934,
+	2001,
+	1935,
+	2001,
+	1934,
+	2001,
+	1935,
+	2002,
+	1936,
+	2002,
+	1935,
+	2002,
+	1936,
+	2003,
+	1937,
+	2003,
+	1936,
+	2003,
+	1937,
+	2004,
+	1938,
+	2004,
+	1937,
+	2004,
+	1938,
+	2005,
+	1939,
+	2005,
+	1938,
+	2005,
+	1939,
+	2006,
+	1940,
+	2006,
+	1939,
+	2006,
+	1940,
+	2007,
+	1941,
+	2007,
+	1940,
+	2007,
+	1941,
+	2008,
+	1942,
+	2008,
+	1941,
+	2008,
+	1942,
+	2009,
+	1943,
+	2009,
+	1942,
+	2009,
+	1943,
+	2010,
+	1944,
+	2010,
+	1943,
+	2010,
+	1944,
+	2011,
+	1945,
+	2011,
+	1944,
+	2011,
+	1945,
+	2012,
+	1946,
+	2012,
+	1945,
+	2012,
+	1946,
+	2013,
+	1947,
+	2013,
+	1946,
+	2013,
+	1947,
+	2014,
+	1948,
+	2014,
+	1947,
+	2014,
+	1948,
+	2015,
+	1949,
+	2015,
+	1948,
+	2015,
+	1949,
+	2016,
+	1950,
+	2016,
+	1949,
+	2016,
+	1950,
+	2017,
+	1951,
+	2017,
+	1950,
+	2017,
+	1951,
+	2018,
+	1952,
+	2018,
+	1951,
+	2018,
+	1952,
+	2019,
+	1953,
+	2019,
+	1952,
+	2019,
+	1953,
+	2020,
+	1954,
+	2020,
+	1953,
+	2020,
+	1954,
+	2021,
+	1955,
+	2021,
+	1954,
+	2021,
+	1955,
+	2022,
+	1956,
+	2022,
+	1955,
+	2022,
+	1956,
+	2023,
+	1957,
+	2023,
+	1956,
+	2023,
+	1957,
+	2024,
+	1958,
+	2024,
+	1957,
+	2024,
+	1958,
+	2025,
+	1959,
+	2025,
+	1958,
+	2025,
+	1959,
+	2026,
+	1960,
+	2026,
+	1959,
+	2026,
+	1960,
+	2027,
+	1961,
+	2027,
+	1960,
+	2027,
+	1961,
+	2028,
+	1962,
+	2028,
+	1961,
+	2028,
+	1962,
+	2029,
+	1963,
+	2029,
+	1962,
+	2029,
+	1963,
+	2030,
+	1964,
+	2030,
+	1963,
+	2030,
+	1964,
+	2031,
+	1965,
+	2031,
+	1964,
+	2031,
+	1965,
+	2032,
+	1966,
+	2032,
+	1965,
+	2032,
+	1966,
+	2033,
+	1967,
+	2033,
+	1966,
+	2033,
+	1967,
+	2034,
+	1968,
+	2034,
+	1967,
+	2034,
+	1968,
+	2035,
+	1969,
+	2035,
+	1968,
+	2035,
+	1969,
+	2036,
+	1970,
+	2036,
+	1969,
+	2036,
+	1970,
+	2037,
+	1971,
+	2037,
+	1970,
+	2037,
+	1971,
+	2038,
+	1972,
+	2038,
+	1971,
+	2038,
+	1972,
+	2039,
+	1973,
+	2039,
+	1972,
+	2039,
+	1973,
+	2040,
+	1974,
+	2040,
+	1973,
+	2040,
+	1974,
+	2041,
+	1975,
+	2041,
+	1974,
+	2041,
+	1975,
+	2042,
+	1976,
+	2042,
+	1975,
+	2042,
+	1976,
+	2043,
+	1977,
+	2043,
+	1976,
+	2043,
+	1977,
+	2044,
+	1978,
+	2044,
+	1977,
+	2044,
+	1978,
+	2045,
+	1979,
+	2045,
+	1978,
+	2046,
+	1980,
+	2047,
+	1981,
+	2047,
+	1980,
+	2047,
+	1981,
+	2048,
+	1982,
+	2048,
+	1981,
+	2048,
+	1982,
+	2049,
+	1983,
+	2049,
+	1982,
+	2049,
+	1983,
+	2050,
+	1984,
+	2050,
+	1983,
+	2050,
+	1984,
+	2051,
+	1985,
+	2051,
+	1984,
+	2051,
+	1985,
+	2052,
+	1986,
+	2052,
+	1985,
+	2052,
+	1986,
+	2053,
+	1987,
+	2053,
+	1986,
+	2053,
+	1987,
+	2054,
+	1988,
+	2054,
+	1987,
+	2054,
+	1988,
+	2055,
+	1989,
+	2055,
+	1988,
+	2055,
+	1989,
+	2056,
+	1990,
+	2056,
+	1989,
+	2056,
+	1990,
+	2057,
+	1991,
+	2057,
+	1990,
+	2057,
+	1991,
+	2058,
+	1992,
+	2058,
+	1991,
+	2058,
+	1992,
+	2059,
+	1993,
+	2059,
+	1992,
+	2059,
+	1993,
+	2060,
+	1994,
+	2060,
+	1993,
+	2060,
+	1994,
+	2061,
+	1995,
+	2061,
+	1994,
+	2061,
+	1995,
+	2062,
+	1996,
+	2062,
+	1995,
+	2062,
+	1996,
+	2063,
+	1997,
+	2063,
+	1996,
+	2063,
+	1997,
+	2064,
+	1998,
+	2064,
+	1997,
+	2064,
+	1998,
+	2065,
+	1999,
+	2065,
+	1998,
+	2065,
+	1999,
+	2066,
+	2000,
+	2066,
+	1999,
+	2066,
+	2000,
+	2067,
+	2001,
+	2067,
+	2000,
+	2067,
+	2001,
+	2068,
+	2002,
+	2068,
+	2001,
+	2068,
+	2002,
+	2069,
+	2003,
+	2069,
+	2002,
+	2069,
+	2003,
+	2070,
+	2004,
+	2070,
+	2003,
+	2070,
+	2004,
+	2071,
+	2005,
+	2071,
+	2004,
+	2071,
+	2005,
+	2072,
+	2006,
+	2072,
+	2005,
+	2072,
+	2006,
+	2073,
+	2007,
+	2073,
+	2006,
+	2073,
+	2007,
+	2074,
+	2008,
+	2074,
+	2007,
+	2074,
+	2008,
+	2075,
+	2009,
+	2075,
+	2008,
+	2075,
+	2009,
+	2076,
+	2010,
+	2076,
+	2009,
+	2076,
+	2010,
+	2077,
+	2011,
+	2077,
+	2010,
+	2077,
+	2011,
+	2078,
+	2012,
+	2078,
+	2011,
+	2078,
+	2012,
+	2079,
+	2013,
+	2079,
+	2012,
+	2079,
+	2013,
+	2080,
+	2014,
+	2080,
+	2013,
+	2080,
+	2014,
+	2081,
+	2015,
+	2081,
+	2014,
+	2081,
+	2015,
+	2082,
+	2016,
+	2082,
+	2015,
+	2082,
+	2016,
+	2083,
+	2017,
+	2083,
+	2016,
+	2083,
+	2017,
+	2084,
+	2018,
+	2084,
+	2017,
+	2084,
+	2018,
+	2085,
+	2019,
+	2085,
+	2018,
+	2085,
+	2019,
+	2086,
+	2020,
+	2086,
+	2019,
+	2086,
+	2020,
+	2087,
+	2021,
+	2087,
+	2020,
+	2087,
+	2021,
+	2088,
+	2022,
+	2088,
+	2021,
+	2088,
+	2022,
+	2089,
+	2023,
+	2089,
+	2022,
+	2089,
+	2023,
+	2090,
+	2024,
+	2090,
+	2023,
+	2090,
+	2024,
+	2091,
+	2025,
+	2091,
+	2024,
+	2091,
+	2025,
+	2092,
+	2026,
+	2092,
+	2025,
+	2092,
+	2026,
+	2093,
+	2027,
+	2093,
+	2026,
+	2093,
+	2027,
+	2094,
+	2028,
+	2094,
+	2027,
+	2094,
+	2028,
+	2095,
+	2029,
+	2095,
+	2028,
+	2095,
+	2029,
+	2096,
+	2030,
+	2096,
+	2029,
+	2096,
+	2030,
+	2097,
+	2031,
+	2097,
+	2030,
+	2097,
+	2031,
+	2098,
+	2032,
+	2098,
+	2031,
+	2098,
+	2032,
+	2099,
+	2033,
+	2099,
+	2032,
+	2099,
+	2033,
+	2100,
+	2034,
+	2100,
+	2033,
+	2100,
+	2034,
+	2101,
+	2035,
+	2101,
+	2034,
+	2101,
+	2035,
+	2102,
+	2036,
+	2102,
+	2035,
+	2102,
+	2036,
+	2103,
+	2037,
+	2103,
+	2036,
+	2103,
+	2037,
+	2104,
+	2038,
+	2104,
+	2037,
+	2104,
+	2038,
+	2105,
+	2039,
+	2105,
+	2038,
+	2105,
+	2039,
+	2106,
+	2040,
+	2106,
+	2039,
+	2106,
+	2040,
+	2107,
+	2041,
+	2107,
+	2040,
+	2107,
+	2041,
+	2108,
+	2042,
+	2108,
+	2041,
+	2108,
+	2042,
+	2109,
+	2043,
+	2109,
+	2042,
+	2109,
+	2043,
+	2110,
+	2044,
+	2110,
+	2043,
+	2110,
+	2044,
+	2111,
+	2045,
+	2111,
+	2044,
+	2112,
+	2046,
+	2113,
+	2047,
+	2113,
+	2046,
+	2113,
+	2047,
+	2114,
+	2048,
+	2114,
+	2047,
+	2114,
+	2048,
+	2115,
+	2049,
+	2115,
+	2048,
+	2115,
+	2049,
+	2116,
+	2050,
+	2116,
+	2049,
+	2116,
+	2050,
+	2117,
+	2051,
+	2117,
+	2050,
+	2117,
+	2051,
+	2118,
+	2052,
+	2118,
+	2051,
+	2118,
+	2052,
+	2119,
+	2053,
+	2119,
+	2052,
+	2119,
+	2053,
+	2120,
+	2054,
+	2120,
+	2053,
+	2120,
+	2054,
+	2121,
+	2055,
+	2121,
+	2054,
+	2121,
+	2055,
+	2122,
+	2056,
+	2122,
+	2055,
+	2122,
+	2056,
+	2123,
+	2057,
+	2123,
+	2056,
+	2123,
+	2057,
+	2124,
+	2058,
+	2124,
+	2057,
+	2124,
+	2058,
+	2125,
+	2059,
+	2125,
+	2058,
+	2125,
+	2059,
+	2126,
+	2060,
+	2126,
+	2059,
+	2126,
+	2060,
+	2127,
+	2061,
+	2127,
+	2060,
+	2127,
+	2061,
+	2128,
+	2062,
+	2128,
+	2061,
+	2128,
+	2062,
+	2129,
+	2063,
+	2129,
+	2062,
+	2129,
+	2063,
+	2130,
+	2064,
+	2130,
+	2063,
+	2130,
+	2064,
+	2131,
+	2065,
+	2131,
+	2064,
+	2131,
+	2065,
+	2132,
+	2066,
+	2132,
+	2065,
+	2132,
+	2066,
+	2133,
+	2067,
+	2133,
+	2066,
+	2133,
+	2067,
+	2134,
+	2068,
+	2134,
+	2067,
+	2134,
+	2068,
+	2135,
+	2069,
+	2135,
+	2068,
+	2135,
+	2069,
+	2136,
+	2070,
+	2136,
+	2069,
+	2136,
+	2070,
+	2137,
+	2071,
+	2137,
+	2070,
+	2137,
+	2071,
+	2138,
+	2072,
+	2138,
+	2071,
+	2138,
+	2072,
+	2139,
+	2073,
+	2139,
+	2072,
+	2139,
+	2073,
+	2140,
+	2074,
+	2140,
+	2073,
+	2140,
+	2074,
+	2141,
+	2075,
+	2141,
+	2074,
+	2141,
+	2075,
+	2142,
+	2076,
+	2142,
+	2075,
+	2142,
+	2076,
+	2143,
+	2077,
+	2143,
+	2076,
+	2143,
+	2077,
+	2144,
+	2078,
+	2144,
+	2077,
+	2144,
+	2078,
+	2145,
+	2079,
+	2145,
+	2078,
+	2145,
+	2079,
+	2146,
+	2080,
+	2146,
+	2079,
+	2146,
+	2080,
+	2147,
+	2081,
+	2147,
+	2080,
+	2147,
+	2081,
+	2148,
+	2082,
+	2148,
+	2081,
+	2148,
+	2082,
+	2149,
+	2083,
+	2149,
+	2082,
+	2149,
+	2083,
+	2150,
+	2084,
+	2150,
+	2083,
+	2150,
+	2084,
+	2151,
+	2085,
+	2151,
+	2084,
+	2151,
+	2085,
+	2152,
+	2086,
+	2152,
+	2085,
+	2152,
+	2086,
+	2153,
+	2087,
+	2153,
+	2086,
+	2153,
+	2087,
+	2154,
+	2088,
+	2154,
+	2087,
+	2154,
+	2088,
+	2155,
+	2089,
+	2155,
+	2088,
+	2155,
+	2089,
+	2156,
+	2090,
+	2156,
+	2089,
+	2156,
+	2090,
+	2157,
+	2091,
+	2157,
+	2090,
+	2157,
+	2091,
+	2158,
+	2092,
+	2158,
+	2091,
+	2158,
+	2092,
+	2159,
+	2093,
+	2159,
+	2092,
+	2159,
+	2093,
+	2160,
+	2094,
+	2160,
+	2093,
+	2160,
+	2094,
+	2161,
+	2095,
+	2161,
+	2094,
+	2161,
+	2095,
+	2162,
+	2096,
+	2162,
+	2095,
+	2162,
+	2096,
+	2163,
+	2097,
+	2163,
+	2096,
+	2163,
+	2097,
+	2164,
+	2098,
+	2164,
+	2097,
+	2164,
+	2098,
+	2165,
+	2099,
+	2165,
+	2098,
+	2165,
+	2099,
+	2166,
+	2100,
+	2166,
+	2099,
+	2166,
+	2100,
+	2167,
+	2101,
+	2167,
+	2100,
+	2167,
+	2101,
+	2168,
+	2102,
+	2168,
+	2101,
+	2168,
+	2102,
+	2169,
+	2103,
+	2169,
+	2102,
+	2169,
+	2103,
+	2170,
+	2104,
+	2170,
+	2103,
+	2170,
+	2104,
+	2171,
+	2105,
+	2171,
+	2104,
+	2171,
+	2105,
+	2172,
+	2106,
+	2172,
+	2105,
+	2172,
+	2106,
+	2173,
+	2107,
+	2173,
+	2106,
+	2173,
+	2107,
+	2174,
+	2108,
+	2174,
+	2107,
+	2174,
+	2108,
+	2175,
+	2109,
+	2175,
+	2108,
+	2175,
+	2109,
+	2176,
+	2110,
+	2176,
+	2109,
+	2176,
+	2110,
+	2177,
+	2111,
+	2177,
+	2110,
+	2178,
+	2112,
+	2179,
+	2113,
+	2179,
+	2112,
+	2179,
+	2113,
+	2180,
+	2114,
+	2180,
+	2113,
+	2180,
+	2114,
+	2181,
+	2115,
+	2181,
+	2114,
+	2181,
+	2115,
+	2182,
+	2116,
+	2182,
+	2115,
+	2182,
+	2116,
+	2183,
+	2117,
+	2183,
+	2116,
+	2183,
+	2117,
+	2184,
+	2118,
+	2184,
+	2117,
+	2184,
+	2118,
+	2185,
+	2119,
+	2185,
+	2118,
+	2185,
+	2119,
+	2186,
+	2120,
+	2186,
+	2119,
+	2186,
+	2120,
+	2187,
+	2121,
+	2187,
+	2120,
+	2187,
+	2121,
+	2188,
+	2122,
+	2188,
+	2121,
+	2188,
+	2122,
+	2189,
+	2123,
+	2189,
+	2122,
+	2189,
+	2123,
+	2190,
+	2124,
+	2190,
+	2123,
+	2190,
+	2124,
+	2191,
+	2125,
+	2191,
+	2124,
+	2191,
+	2125,
+	2192,
+	2126,
+	2192,
+	2125,
+	2192,
+	2126,
+	2193,
+	2127,
+	2193,
+	2126,
+	2193,
+	2127,
+	2194,
+	2128,
+	2194,
+	2127,
+	2194,
+	2128,
+	2195,
+	2129,
+	2195,
+	2128,
+	2195,
+	2129,
+	2196,
+	2130,
+	2196,
+	2129,
+	2196,
+	2130,
+	2197,
+	2131,
+	2197,
+	2130,
+	2197,
+	2131,
+	2198,
+	2132,
+	2198,
+	2131,
+	2198,
+	2132,
+	2199,
+	2133,
+	2199,
+	2132,
+	2199,
+	2133,
+	2200,
+	2134,
+	2200,
+	2133,
+	2200,
+	2134,
+	2201,
+	2135,
+	2201,
+	2134,
+	2201,
+	2135,
+	2202,
+	2136,
+	2202,
+	2135,
+	2202,
+	2136,
+	2203,
+	2137,
+	2203,
+	2136,
+	2203,
+	2137,
+	2204,
+	2138,
+	2204,
+	2137,
+	2204,
+	2138,
+	2205,
+	2139,
+	2205,
+	2138,
+	2205,
+	2139,
+	2206,
+	2140,
+	2206,
+	2139,
+	2206,
+	2140,
+	2207,
+	2141,
+	2207,
+	2140,
+	2207,
+	2141,
+	2208,
+	2142,
+	2208,
+	2141,
+	2208,
+	2142,
+	2209,
+	2143,
+	2209,
+	2142,
+	2209,
+	2143,
+	2210,
+	2144,
+	2210,
+	2143,
+	2210,
+	2144,
+	2211,
+	2145,
+	2211,
+	2144,
+	2211,
+	2145,
+	2212,
+	2146,
+	2212,
+	2145,
+	2212,
+	2146,
+	2213,
+	2147,
+	2213,
+	2146,
+	2213,
+	2147,
+	2214,
+	2148,
+	2214,
+	2147,
+	2214,
+	2148,
+	2215,
+	2149,
+	2215,
+	2148,
+	2215,
+	2149,
+	2216,
+	2150,
+	2216,
+	2149,
+	2216,
+	2150,
+	2217,
+	2151,
+	2217,
+	2150,
+	2217,
+	2151,
+	2218,
+	2152,
+	2218,
+	2151,
+	2218,
+	2152,
+	2219,
+	2153,
+	2219,
+	2152,
+	2219,
+	2153,
+	2220,
+	2154,
+	2220,
+	2153,
+	2220,
+	2154,
+	2221,
+	2155,
+	2221,
+	2154,
+	2221,
+	2155,
+	2222,
+	2156,
+	2222,
+	2155,
+	2222,
+	2156,
+	2223,
+	2157,
+	2223,
+	2156,
+	2223,
+	2157,
+	2224,
+	2158,
+	2224,
+	2157,
+	2224,
+	2158,
+	2225,
+	2159,
+	2225,
+	2158,
+	2225,
+	2159,
+	2226,
+	2160,
+	2226,
+	2159,
+	2226,
+	2160,
+	2227,
+	2161,
+	2227,
+	2160,
+	2227,
+	2161,
+	2228,
+	2162,
+	2228,
+	2161,
+	2228,
+	2162,
+	2229,
+	2163,
+	2229,
+	2162,
+	2229,
+	2163,
+	2230,
+	2164,
+	2230,
+	2163,
+	2230,
+	2164,
+	2231,
+	2165,
+	2231,
+	2164,
+	2231,
+	2165,
+	2232,
+	2166,
+	2232,
+	2165,
+	2232,
+	2166,
+	2233,
+	2167,
+	2233,
+	2166,
+	2233,
+	2167,
+	2234,
+	2168,
+	2234,
+	2167,
+	2234,
+	2168,
+	2235,
+	2169,
+	2235,
+	2168,
+	2235,
+	2169,
+	2236,
+	2170,
+	2236,
+	2169,
+	2236,
+	2170,
+	2237,
+	2171,
+	2237,
+	2170,
+	2237,
+	2171,
+	2238,
+	2172,
+	2238,
+	2171,
+	2238,
+	2172,
+	2239,
+	2173,
+	2239,
+	2172,
+	2239,
+	2173,
+	2240,
+	2174,
+	2240,
+	2173,
+	2240,
+	2174,
+	2241,
+	2175,
+	2241,
+	2174,
+	2241,
+	2175,
+	2242,
+	2176,
+	2242,
+	2175,
+	2242,
+	2176,
+	2243,
+	2177,
+	2243,
+	2176,
+};
+
+#define Landscape06VtxCount 2310
+#define Landscape06IdxCount 13260
+
+btScalar Landscape06Vtx[] = {
+	-250.0f,
+	5.63631f,
+	246.094f,
+	-250.0f,
+	8.1152f,
+	250.0f,
+	-246.094f,
+	7.06461f,
+	246.094f,
+	-246.094f,
+	9.72778f,
+	250.0f,
+	-242.188f,
+	9.8471f,
+	246.094f,
+	-242.188f,
+	11.659f,
+	250.0f,
+	-238.281f,
+	12.8404f,
+	246.094f,
+	-238.281f,
+	12.5619f,
+	250.0f,
+	-234.375f,
+	13.9879f,
+	246.094f,
+	-234.375f,
+	12.9518f,
+	250.0f,
+	-230.469f,
+	15.7239f,
+	246.094f,
+	-230.469f,
+	15.1373f,
+	250.0f,
+	-226.563f,
+	17.5095f,
+	246.094f,
+	-226.563f,
+	17.0421f,
+	250.0f,
+	-222.656f,
+	18.4322f,
+	246.094f,
+	-222.656f,
+	17.9919f,
+	250.0f,
+	-218.75f,
+	19.0755f,
+	246.094f,
+	-218.75f,
+	18.7918f,
+	250.0f,
+	-214.844f,
+	19.9271f,
+	246.094f,
+	-214.844f,
+	19.5719f,
+	250.0f,
+	-210.938f,
+	19.7244f,
+	246.094f,
+	-210.938f,
+	20.0866f,
+	250.0f,
+	-207.031f,
+	18.9716f,
+	246.094f,
+	-207.031f,
+	19.7869f,
+	250.0f,
+	-203.125f,
+	19.1922f,
+	246.094f,
+	-203.125f,
+	20.0264f,
+	250.0f,
+	-199.219f,
+	17.8506f,
+	246.094f,
+	-199.219f,
+	19.3207f,
+	250.0f,
+	-195.313f,
+	15.238f,
+	246.094f,
+	-195.313f,
+	18.0244f,
+	250.0f,
+	-191.406f,
+	14.6904f,
+	246.094f,
+	-191.406f,
+	16.2939f,
+	250.0f,
+	-187.5f,
+	12.9803f,
+	246.094f,
+	-187.5f,
+	14.9619f,
+	250.0f,
+	-183.594f,
+	11.6545f,
+	246.094f,
+	-183.594f,
+	12.6676f,
+	250.0f,
+	-179.688f,
+	12.4631f,
+	246.094f,
+	-179.688f,
+	13.6712f,
+	250.0f,
+	-175.781f,
+	13.1206f,
+	246.094f,
+	-175.781f,
+	14.5417f,
+	250.0f,
+	-171.875f,
+	13.3105f,
+	246.094f,
+	-171.875f,
+	15.8974f,
+	250.0f,
+	-167.969f,
+	13.4543f,
+	246.094f,
+	-167.969f,
+	15.9641f,
+	250.0f,
+	-164.063f,
+	13.4505f,
+	246.094f,
+	-164.063f,
+	15.4826f,
+	250.0f,
+	-160.156f,
+	14.6873f,
+	246.094f,
+	-160.156f,
+	15.1093f,
+	250.0f,
+	-156.25f,
+	14.1623f,
+	246.094f,
+	-156.25f,
+	14.8119f,
+	250.0f,
+	-152.344f,
+	14.0111f,
+	246.094f,
+	-152.344f,
+	14.4017f,
+	250.0f,
+	-148.438f,
+	13.2014f,
+	246.094f,
+	-148.438f,
+	14.2916f,
+	250.0f,
+	-144.531f,
+	12.8662f,
+	246.094f,
+	-144.531f,
+	13.5685f,
+	250.0f,
+	-140.625f,
+	13.1721f,
+	246.094f,
+	-140.625f,
+	14.2972f,
+	250.0f,
+	-136.719f,
+	12.9479f,
+	246.094f,
+	-136.719f,
+	15.0727f,
+	250.0f,
+	-132.813f,
+	13.4221f,
+	246.094f,
+	-132.813f,
+	14.5344f,
+	250.0f,
+	-128.906f,
+	14.0862f,
+	246.094f,
+	-128.906f,
+	15.7145f,
+	250.0f,
+	-125.0f,
+	13.481f,
+	246.094f,
+	-125.0f,
+	15.4608f,
+	250.0f,
+	-121.094f,
+	12.6228f,
+	246.094f,
+	-121.094f,
+	15.1857f,
+	250.0f,
+	-117.188f,
+	12.0584f,
+	246.094f,
+	-117.188f,
+	15.444f,
+	250.0f,
+	-113.281f,
+	12.7173f,
+	246.094f,
+	-113.281f,
+	15.8882f,
+	250.0f,
+	-109.375f,
+	12.3498f,
+	246.094f,
+	-109.375f,
+	15.2023f,
+	250.0f,
+	-105.469f,
+	13.0125f,
+	246.094f,
+	-105.469f,
+	15.1747f,
+	250.0f,
+	-101.563f,
+	13.7023f,
+	246.094f,
+	-101.563f,
+	14.7499f,
+	250.0f,
+	-97.6563f,
+	14.0674f,
+	246.094f,
+	-97.6563f,
+	15.0991f,
+	250.0f,
+	-93.75f,
+	13.8437f,
+	246.094f,
+	-93.75f,
+	14.6676f,
+	250.0f,
+	-89.8438f,
+	14.6327f,
+	246.094f,
+	-89.8438f,
+	14.1527f,
+	250.0f,
+	-85.9375f,
+	13.2966f,
+	246.094f,
+	-85.9375f,
+	14.0388f,
+	250.0f,
+	-82.0313f,
+	12.8094f,
+	246.094f,
+	-82.0313f,
+	13.7786f,
+	250.0f,
+	-78.125f,
+	11.8006f,
+	246.094f,
+	-78.125f,
+	13.0685f,
+	250.0f,
+	-74.2188f,
+	11.6837f,
+	246.094f,
+	-74.2188f,
+	12.8361f,
+	250.0f,
+	-70.3125f,
+	11.0326f,
+	246.094f,
+	-70.3125f,
+	12.3629f,
+	250.0f,
+	-66.4063f,
+	11.893f,
+	246.094f,
+	-66.4063f,
+	11.1909f,
+	250.0f,
+	-62.5f,
+	10.6469f,
+	246.094f,
+	-62.5f,
+	9.92966f,
+	250.0f,
+	-58.5938f,
+	8.55287f,
+	246.094f,
+	-58.5938f,
+	8.8871f,
+	250.0f,
+	-54.6875f,
+	7.1029f,
+	246.094f,
+	-54.6875f,
+	7.4963f,
+	250.0f,
+	-50.7813f,
+	6.9758f,
+	246.094f,
+	-50.7813f,
+	6.23897f,
+	250.0f,
+	-46.875f,
+	7.98262f,
+	246.094f,
+	-46.875f,
+	6.88918f,
+	250.0f,
+	-42.9688f,
+	9.11554f,
+	246.094f,
+	-42.9688f,
+	7.29319f,
+	250.0f,
+	-39.0625f,
+	8.74373f,
+	246.094f,
+	-39.0625f,
+	6.89167f,
+	250.0f,
+	-35.1563f,
+	7.46275f,
+	246.094f,
+	-35.1563f,
+	6.659f,
+	250.0f,
+	-31.25f,
+	7.67626f,
+	246.094f,
+	-31.25f,
+	6.75404f,
+	250.0f,
+	-27.3438f,
+	7.00511f,
+	246.094f,
+	-27.3438f,
+	6.15573f,
+	250.0f,
+	-23.4375f,
+	5.63813f,
+	246.094f,
+	-23.4375f,
+	5.72737f,
+	250.0f,
+	-19.5313f,
+	5.11885f,
+	246.094f,
+	-19.5313f,
+	4.00822f,
+	250.0f,
+	-15.625f,
+	3.60038f,
+	246.094f,
+	-15.625f,
+	3.50471f,
+	250.0f,
+	-11.7188f,
+	3.05357f,
+	246.094f,
+	-11.7188f,
+	3.0992f,
+	250.0f,
+	-7.8125f,
+	2.48195f,
+	246.094f,
+	-7.8125f,
+	2.46052f,
+	250.0f,
+	-3.90625f,
+	1.69136f,
+	246.094f,
+	-3.90625f,
+	2.5505f,
+	250.0f,
+	0.0f,
+	1.14548f,
+	246.094f,
+	0.0f,
+	2.18079f,
+	250.0f,
+	3.90625f,
+	0.45291f,
+	246.094f,
+	3.90625f,
+	1.52302f,
+	250.0f,
+	-250.0f,
+	5.2159f,
+	242.188f,
+	-246.094f,
+	7.35218f,
+	242.188f,
+	-242.188f,
+	10.2284f,
+	242.188f,
+	-238.281f,
+	12.7552f,
+	242.188f,
+	-234.375f,
+	14.3317f,
+	242.188f,
+	-230.469f,
+	16.3594f,
+	242.188f,
+	-226.563f,
+	17.8216f,
+	242.188f,
+	-222.656f,
+	18.5321f,
+	242.188f,
+	-218.75f,
+	18.7578f,
+	242.188f,
+	-214.844f,
+	19.504f,
+	242.188f,
+	-210.938f,
+	18.9422f,
+	242.188f,
+	-207.031f,
+	17.9771f,
+	242.188f,
+	-203.125f,
+	17.2798f,
+	242.188f,
+	-199.219f,
+	15.2252f,
+	242.188f,
+	-195.313f,
+	13.8769f,
+	242.188f,
+	-191.406f,
+	12.8727f,
+	242.188f,
+	-187.5f,
+	11.7858f,
+	242.188f,
+	-183.594f,
+	12.4886f,
+	242.188f,
+	-179.688f,
+	12.9814f,
+	242.188f,
+	-175.781f,
+	13.5265f,
+	242.188f,
+	-171.875f,
+	13.8082f,
+	242.188f,
+	-167.969f,
+	13.8407f,
+	242.188f,
+	-164.063f,
+	13.5872f,
+	242.188f,
+	-160.156f,
+	13.8287f,
+	242.188f,
+	-156.25f,
+	13.5778f,
+	242.188f,
+	-152.344f,
+	13.0026f,
+	242.188f,
+	-148.438f,
+	12.6259f,
+	242.188f,
+	-144.531f,
+	12.4666f,
+	242.188f,
+	-140.625f,
+	12.634f,
+	242.188f,
+	-136.719f,
+	12.1746f,
+	242.188f,
+	-132.813f,
+	11.7885f,
+	242.188f,
+	-128.906f,
+	11.4539f,
+	242.188f,
+	-125.0f,
+	11.0084f,
+	242.188f,
+	-121.094f,
+	10.1521f,
+	242.188f,
+	-117.188f,
+	10.6008f,
+	242.188f,
+	-113.281f,
+	10.2088f,
+	242.188f,
+	-109.375f,
+	11.0344f,
+	242.188f,
+	-105.469f,
+	11.1441f,
+	242.188f,
+	-101.563f,
+	12.3959f,
+	242.188f,
+	-97.6563f,
+	13.3587f,
+	242.188f,
+	-93.75f,
+	14.2415f,
+	242.188f,
+	-89.8438f,
+	13.9809f,
+	242.188f,
+	-85.9375f,
+	13.3276f,
+	242.188f,
+	-82.0313f,
+	11.9639f,
+	242.188f,
+	-78.125f,
+	11.5863f,
+	242.188f,
+	-74.2188f,
+	11.7327f,
+	242.188f,
+	-70.3125f,
+	11.5527f,
+	242.188f,
+	-66.4063f,
+	12.3699f,
+	242.188f,
+	-62.5f,
+	11.1959f,
+	242.188f,
+	-58.5938f,
+	9.59967f,
+	242.188f,
+	-54.6875f,
+	8.38887f,
+	242.188f,
+	-50.7813f,
+	7.42613f,
+	242.188f,
+	-46.875f,
+	8.34697f,
+	242.188f,
+	-42.9688f,
+	9.7013f,
+	242.188f,
+	-39.0625f,
+	9.10668f,
+	242.188f,
+	-35.1563f,
+	8.24657f,
+	242.188f,
+	-31.25f,
+	8.06656f,
+	242.188f,
+	-27.3438f,
+	6.98555f,
+	242.188f,
+	-23.4375f,
+	6.88836f,
+	242.188f,
+	-19.5313f,
+	5.88079f,
+	242.188f,
+	-15.625f,
+	4.43148f,
+	242.188f,
+	-11.7188f,
+	3.65843f,
+	242.188f,
+	-7.8125f,
+	2.85687f,
+	242.188f,
+	-3.90625f,
+	1.8332f,
+	242.188f,
+	0.0f,
+	2.03971f,
+	242.188f,
+	3.90625f,
+	2.21488f,
+	242.188f,
+	-250.0f,
+	5.44463f,
+	238.281f,
+	-246.094f,
+	7.90885f,
+	238.281f,
+	-242.188f,
+	10.3908f,
+	238.281f,
+	-238.281f,
+	12.875f,
+	238.281f,
+	-234.375f,
+	14.8255f,
+	238.281f,
+	-230.469f,
+	16.5404f,
+	238.281f,
+	-226.563f,
+	17.8109f,
+	238.281f,
+	-222.656f,
+	19.0205f,
+	238.281f,
+	-218.75f,
+	18.7565f,
+	238.281f,
+	-214.844f,
+	18.9852f,
+	238.281f,
+	-210.938f,
+	18.3753f,
+	238.281f,
+	-207.031f,
+	16.6829f,
+	238.281f,
+	-203.125f,
+	15.8099f,
+	238.281f,
+	-199.219f,
+	13.2915f,
+	238.281f,
+	-195.313f,
+	13.447f,
+	238.281f,
+	-191.406f,
+	13.5971f,
+	238.281f,
+	-187.5f,
+	12.1473f,
+	238.281f,
+	-183.594f,
+	13.3531f,
+	238.281f,
+	-179.688f,
+	14.4732f,
+	238.281f,
+	-175.781f,
+	15.0267f,
+	238.281f,
+	-171.875f,
+	14.7852f,
+	238.281f,
+	-167.969f,
+	15.5706f,
+	238.281f,
+	-164.063f,
+	14.267f,
+	238.281f,
+	-160.156f,
+	14.0772f,
+	238.281f,
+	-156.25f,
+	12.4965f,
+	238.281f,
+	-152.344f,
+	12.1473f,
+	238.281f,
+	-148.438f,
+	11.8693f,
+	238.281f,
+	-144.531f,
+	11.2795f,
+	238.281f,
+	-140.625f,
+	10.8173f,
+	238.281f,
+	-136.719f,
+	10.792f,
+	238.281f,
+	-132.813f,
+	10.8481f,
+	238.281f,
+	-128.906f,
+	9.95928f,
+	238.281f,
+	-125.0f,
+	10.0976f,
+	238.281f,
+	-121.094f,
+	8.74444f,
+	238.281f,
+	-117.188f,
+	9.1761f,
+	238.281f,
+	-113.281f,
+	10.2354f,
+	238.281f,
+	-109.375f,
+	10.7023f,
+	238.281f,
+	-105.469f,
+	11.6386f,
+	238.281f,
+	-101.563f,
+	12.7789f,
+	238.281f,
+	-97.6563f,
+	13.956f,
+	238.281f,
+	-93.75f,
+	14.1101f,
+	238.281f,
+	-89.8438f,
+	13.2653f,
+	238.281f,
+	-85.9375f,
+	12.1604f,
+	238.281f,
+	-82.0313f,
+	11.6914f,
+	238.281f,
+	-78.125f,
+	11.3706f,
+	238.281f,
+	-74.2188f,
+	12.1449f,
+	238.281f,
+	-70.3125f,
+	12.4512f,
+	238.281f,
+	-66.4063f,
+	12.6436f,
+	238.281f,
+	-62.5f,
+	11.6692f,
+	238.281f,
+	-58.5938f,
+	10.8304f,
+	238.281f,
+	-54.6875f,
+	8.88158f,
+	238.281f,
+	-50.7813f,
+	7.94904f,
+	238.281f,
+	-46.875f,
+	8.47525f,
+	238.281f,
+	-42.9688f,
+	9.08763f,
+	238.281f,
+	-39.0625f,
+	9.21095f,
+	238.281f,
+	-35.1563f,
+	9.12926f,
+	238.281f,
+	-31.25f,
+	8.5517f,
+	238.281f,
+	-27.3438f,
+	7.86146f,
+	238.281f,
+	-23.4375f,
+	7.33662f,
+	238.281f,
+	-19.5313f,
+	6.37551f,
+	238.281f,
+	-15.625f,
+	5.59324f,
+	238.281f,
+	-11.7188f,
+	4.81831f,
+	238.281f,
+	-7.8125f,
+	4.35695f,
+	238.281f,
+	-3.90625f,
+	3.64159f,
+	238.281f,
+	0.0f,
+	3.70314f,
+	238.281f,
+	3.90625f,
+	3.04396f,
+	238.281f,
+	-250.0f,
+	5.92848f,
+	234.375f,
+	-246.094f,
+	8.10446f,
+	234.375f,
+	-242.188f,
+	10.3516f,
+	234.375f,
+	-238.281f,
+	12.4984f,
+	234.375f,
+	-234.375f,
+	15.0991f,
+	234.375f,
+	-230.469f,
+	16.0002f,
+	234.375f,
+	-226.563f,
+	17.2585f,
+	234.375f,
+	-222.656f,
+	18.1852f,
+	234.375f,
+	-218.75f,
+	18.7811f,
+	234.375f,
+	-214.844f,
+	18.4638f,
+	234.375f,
+	-210.938f,
+	18.3171f,
+	234.375f,
+	-207.031f,
+	16.1085f,
+	234.375f,
+	-203.125f,
+	15.1926f,
+	234.375f,
+	-199.219f,
+	14.1792f,
+	234.375f,
+	-195.313f,
+	13.5589f,
+	234.375f,
+	-191.406f,
+	13.9362f,
+	234.375f,
+	-187.5f,
+	13.303f,
+	234.375f,
+	-183.594f,
+	13.6602f,
+	234.375f,
+	-179.688f,
+	15.1086f,
+	234.375f,
+	-175.781f,
+	15.5943f,
+	234.375f,
+	-171.875f,
+	15.3663f,
+	234.375f,
+	-167.969f,
+	14.9609f,
+	234.375f,
+	-164.063f,
+	14.4285f,
+	234.375f,
+	-160.156f,
+	14.1532f,
+	234.375f,
+	-156.25f,
+	13.0139f,
+	234.375f,
+	-152.344f,
+	11.6503f,
+	234.375f,
+	-148.438f,
+	11.6112f,
+	234.375f,
+	-144.531f,
+	11.1097f,
+	234.375f,
+	-140.625f,
+	10.8763f,
+	234.375f,
+	-136.719f,
+	10.2321f,
+	234.375f,
+	-132.813f,
+	9.71321f,
+	234.375f,
+	-128.906f,
+	9.04388f,
+	234.375f,
+	-125.0f,
+	9.53542f,
+	234.375f,
+	-121.094f,
+	8.10006f,
+	234.375f,
+	-117.188f,
+	9.16948f,
+	234.375f,
+	-113.281f,
+	9.67824f,
+	234.375f,
+	-109.375f,
+	10.2679f,
+	234.375f,
+	-105.469f,
+	10.9669f,
+	234.375f,
+	-101.563f,
+	12.2942f,
+	234.375f,
+	-97.6563f,
+	13.2952f,
+	234.375f,
+	-93.75f,
+	13.0932f,
+	234.375f,
+	-89.8438f,
+	12.4514f,
+	234.375f,
+	-85.9375f,
+	12.2395f,
+	234.375f,
+	-82.0313f,
+	11.7622f,
+	234.375f,
+	-78.125f,
+	11.9666f,
+	234.375f,
+	-74.2188f,
+	12.2346f,
+	234.375f,
+	-70.3125f,
+	13.1648f,
+	234.375f,
+	-66.4063f,
+	13.506f,
+	234.375f,
+	-62.5f,
+	13.1773f,
+	234.375f,
+	-58.5938f,
+	11.9168f,
+	234.375f,
+	-54.6875f,
+	10.0208f,
+	234.375f,
+	-50.7813f,
+	9.08267f,
+	234.375f,
+	-46.875f,
+	8.4406f,
+	234.375f,
+	-42.9688f,
+	9.27515f,
+	234.375f,
+	-39.0625f,
+	10.2228f,
+	234.375f,
+	-35.1563f,
+	9.77624f,
+	234.375f,
+	-31.25f,
+	9.17943f,
+	234.375f,
+	-27.3438f,
+	8.83272f,
+	234.375f,
+	-23.4375f,
+	8.00355f,
+	234.375f,
+	-19.5313f,
+	7.37167f,
+	234.375f,
+	-15.625f,
+	6.87424f,
+	234.375f,
+	-11.7188f,
+	6.23994f,
+	234.375f,
+	-7.8125f,
+	5.50641f,
+	234.375f,
+	-3.90625f,
+	5.06839f,
+	234.375f,
+	0.0f,
+	5.06846f,
+	234.375f,
+	3.90625f,
+	5.19166f,
+	234.375f,
+	-250.0f,
+	4.98265f,
+	230.469f,
+	-246.094f,
+	7.878f,
+	230.469f,
+	-242.188f,
+	10.9188f,
+	230.469f,
+	-238.281f,
+	12.8549f,
+	230.469f,
+	-234.375f,
+	14.5578f,
+	230.469f,
+	-230.469f,
+	16.067f,
+	230.469f,
+	-226.563f,
+	17.9938f,
+	230.469f,
+	-222.656f,
+	18.3449f,
+	230.469f,
+	-218.75f,
+	18.4423f,
+	230.469f,
+	-214.844f,
+	18.9411f,
+	230.469f,
+	-210.938f,
+	17.3131f,
+	230.469f,
+	-207.031f,
+	15.3292f,
+	230.469f,
+	-203.125f,
+	15.5278f,
+	230.469f,
+	-199.219f,
+	14.9451f,
+	230.469f,
+	-195.313f,
+	13.8026f,
+	230.469f,
+	-191.406f,
+	13.1586f,
+	230.469f,
+	-187.5f,
+	13.4388f,
+	230.469f,
+	-183.594f,
+	14.2213f,
+	230.469f,
+	-179.688f,
+	14.907f,
+	230.469f,
+	-175.781f,
+	15.2295f,
+	230.469f,
+	-171.875f,
+	14.8701f,
+	230.469f,
+	-167.969f,
+	14.1393f,
+	230.469f,
+	-164.063f,
+	13.7829f,
+	230.469f,
+	-160.156f,
+	13.0614f,
+	230.469f,
+	-156.25f,
+	12.3416f,
+	230.469f,
+	-152.344f,
+	11.5366f,
+	230.469f,
+	-148.438f,
+	11.5201f,
+	230.469f,
+	-144.531f,
+	11.0918f,
+	230.469f,
+	-140.625f,
+	11.139f,
+	230.469f,
+	-136.719f,
+	10.0387f,
+	230.469f,
+	-132.813f,
+	8.59099f,
+	230.469f,
+	-128.906f,
+	7.71771f,
+	230.469f,
+	-125.0f,
+	7.44273f,
+	230.469f,
+	-121.094f,
+	8.17087f,
+	230.469f,
+	-117.188f,
+	8.34002f,
+	230.469f,
+	-113.281f,
+	9.22169f,
+	230.469f,
+	-109.375f,
+	10.2195f,
+	230.469f,
+	-105.469f,
+	11.523f,
+	230.469f,
+	-101.563f,
+	12.7411f,
+	230.469f,
+	-97.6563f,
+	12.7429f,
+	230.469f,
+	-93.75f,
+	12.3959f,
+	230.469f,
+	-89.8438f,
+	11.7559f,
+	230.469f,
+	-85.9375f,
+	10.3669f,
+	230.469f,
+	-82.0313f,
+	10.0825f,
+	230.469f,
+	-78.125f,
+	11.4451f,
+	230.469f,
+	-74.2188f,
+	12.235f,
+	230.469f,
+	-70.3125f,
+	13.6016f,
+	230.469f,
+	-66.4063f,
+	14.377f,
+	230.469f,
+	-62.5f,
+	13.967f,
+	230.469f,
+	-58.5938f,
+	12.862f,
+	230.469f,
+	-54.6875f,
+	11.4719f,
+	230.469f,
+	-50.7813f,
+	9.99381f,
+	230.469f,
+	-46.875f,
+	8.68857f,
+	230.469f,
+	-42.9688f,
+	9.43448f,
+	230.469f,
+	-39.0625f,
+	10.4708f,
+	230.469f,
+	-35.1563f,
+	11.0521f,
+	230.469f,
+	-31.25f,
+	10.5864f,
+	230.469f,
+	-27.3438f,
+	10.8331f,
+	230.469f,
+	-23.4375f,
+	9.96112f,
+	230.469f,
+	-19.5313f,
+	8.61029f,
+	230.469f,
+	-15.625f,
+	7.42407f,
+	230.469f,
+	-11.7188f,
+	6.43202f,
+	230.469f,
+	-7.8125f,
+	6.36726f,
+	230.469f,
+	-3.90625f,
+	6.52581f,
+	230.469f,
+	0.0f,
+	6.18686f,
+	230.469f,
+	3.90625f,
+	5.885f,
+	230.469f,
+	-250.0f,
+	4.92227f,
+	226.563f,
+	-246.094f,
+	8.66811f,
+	226.563f,
+	-242.188f,
+	11.7599f,
+	226.563f,
+	-238.281f,
+	13.6581f,
+	226.563f,
+	-234.375f,
+	15.6409f,
+	226.563f,
+	-230.469f,
+	16.7907f,
+	226.563f,
+	-226.563f,
+	17.4606f,
+	226.563f,
+	-222.656f,
+	18.4841f,
+	226.563f,
+	-218.75f,
+	18.4506f,
+	226.563f,
+	-214.844f,
+	17.5936f,
+	226.563f,
+	-210.938f,
+	16.5941f,
+	226.563f,
+	-207.031f,
+	14.8805f,
+	226.563f,
+	-203.125f,
+	15.3743f,
+	226.563f,
+	-199.219f,
+	15.4493f,
+	226.563f,
+	-195.313f,
+	14.5184f,
+	226.563f,
+	-191.406f,
+	12.9285f,
+	226.563f,
+	-187.5f,
+	13.3898f,
+	226.563f,
+	-183.594f,
+	14.0358f,
+	226.563f,
+	-179.688f,
+	15.2884f,
+	226.563f,
+	-175.781f,
+	14.972f,
+	226.563f,
+	-171.875f,
+	14.2355f,
+	226.563f,
+	-167.969f,
+	13.6786f,
+	226.563f,
+	-164.063f,
+	13.0771f,
+	226.563f,
+	-160.156f,
+	12.7879f,
+	226.563f,
+	-156.25f,
+	12.4767f,
+	226.563f,
+	-152.344f,
+	11.5156f,
+	226.563f,
+	-148.438f,
+	11.1725f,
+	226.563f,
+	-144.531f,
+	10.8869f,
+	226.563f,
+	-140.625f,
+	9.77232f,
+	226.563f,
+	-136.719f,
+	8.75728f,
+	226.563f,
+	-132.813f,
+	6.77705f,
+	226.563f,
+	-128.906f,
+	6.35083f,
+	226.563f,
+	-125.0f,
+	6.59888f,
+	226.563f,
+	-121.094f,
+	7.81295f,
+	226.563f,
+	-117.188f,
+	8.10078f,
+	226.563f,
+	-113.281f,
+	9.07634f,
+	226.563f,
+	-109.375f,
+	10.2289f,
+	226.563f,
+	-105.469f,
+	11.5342f,
+	226.563f,
+	-101.563f,
+	12.9142f,
+	226.563f,
+	-97.6563f,
+	12.8729f,
+	226.563f,
+	-93.75f,
+	12.8149f,
+	226.563f,
+	-89.8438f,
+	10.9671f,
+	226.563f,
+	-85.9375f,
+	10.0649f,
+	226.563f,
+	-82.0313f,
+	9.28012f,
+	226.563f,
+	-78.125f,
+	10.1324f,
+	226.563f,
+	-74.2188f,
+	11.8638f,
+	226.563f,
+	-70.3125f,
+	12.6141f,
+	226.563f,
+	-66.4063f,
+	13.6851f,
+	226.563f,
+	-62.5f,
+	13.9389f,
+	226.563f,
+	-58.5938f,
+	13.5413f,
+	226.563f,
+	-54.6875f,
+	12.4869f,
+	226.563f,
+	-50.7813f,
+	11.2774f,
+	226.563f,
+	-46.875f,
+	10.6009f,
+	226.563f,
+	-42.9688f,
+	11.4839f,
+	226.563f,
+	-39.0625f,
+	12.5408f,
+	226.563f,
+	-35.1563f,
+	12.8694f,
+	226.563f,
+	-31.25f,
+	12.5253f,
+	226.563f,
+	-27.3438f,
+	12.1887f,
+	226.563f,
+	-23.4375f,
+	11.5356f,
+	226.563f,
+	-19.5313f,
+	9.53151f,
+	226.563f,
+	-15.625f,
+	8.29811f,
+	226.563f,
+	-11.7188f,
+	7.38375f,
+	226.563f,
+	-7.8125f,
+	7.57607f,
+	226.563f,
+	-3.90625f,
+	7.41156f,
+	226.563f,
+	0.0f,
+	6.9836f,
+	226.563f,
+	3.90625f,
+	6.89682f,
+	226.563f,
+	-250.0f,
+	4.66781f,
+	222.656f,
+	-246.094f,
+	7.89882f,
+	222.656f,
+	-242.188f,
+	10.8629f,
+	222.656f,
+	-238.281f,
+	14.1235f,
+	222.656f,
+	-234.375f,
+	15.6001f,
+	222.656f,
+	-230.469f,
+	17.0347f,
+	222.656f,
+	-226.563f,
+	17.4872f,
+	222.656f,
+	-222.656f,
+	17.6157f,
+	222.656f,
+	-218.75f,
+	16.8213f,
+	222.656f,
+	-214.844f,
+	16.4076f,
+	222.656f,
+	-210.938f,
+	15.0745f,
+	222.656f,
+	-207.031f,
+	14.2914f,
+	222.656f,
+	-203.125f,
+	14.6094f,
+	222.656f,
+	-199.219f,
+	14.4637f,
+	222.656f,
+	-195.313f,
+	14.0807f,
+	222.656f,
+	-191.406f,
+	12.4559f,
+	222.656f,
+	-187.5f,
+	13.0367f,
+	222.656f,
+	-183.594f,
+	13.975f,
+	222.656f,
+	-179.688f,
+	14.802f,
+	222.656f,
+	-175.781f,
+	14.6145f,
+	222.656f,
+	-171.875f,
+	13.4733f,
+	222.656f,
+	-167.969f,
+	13.3385f,
+	222.656f,
+	-164.063f,
+	13.721f,
+	222.656f,
+	-160.156f,
+	12.5775f,
+	222.656f,
+	-156.25f,
+	11.962f,
+	222.656f,
+	-152.344f,
+	11.2422f,
+	222.656f,
+	-148.438f,
+	10.827f,
+	222.656f,
+	-144.531f,
+	10.2848f,
+	222.656f,
+	-140.625f,
+	8.45922f,
+	222.656f,
+	-136.719f,
+	7.72182f,
+	222.656f,
+	-132.813f,
+	6.23545f,
+	222.656f,
+	-128.906f,
+	5.69752f,
+	222.656f,
+	-125.0f,
+	6.29925f,
+	222.656f,
+	-121.094f,
+	7.1991f,
+	222.656f,
+	-117.188f,
+	7.56788f,
+	222.656f,
+	-113.281f,
+	8.87895f,
+	222.656f,
+	-109.375f,
+	9.92302f,
+	222.656f,
+	-105.469f,
+	10.2628f,
+	222.656f,
+	-101.563f,
+	11.427f,
+	222.656f,
+	-97.6563f,
+	12.2929f,
+	222.656f,
+	-93.75f,
+	11.6083f,
+	222.656f,
+	-89.8438f,
+	11.594f,
+	222.656f,
+	-85.9375f,
+	10.1683f,
+	222.656f,
+	-82.0313f,
+	10.4152f,
+	222.656f,
+	-78.125f,
+	10.765f,
+	222.656f,
+	-74.2188f,
+	11.5311f,
+	222.656f,
+	-70.3125f,
+	12.8761f,
+	222.656f,
+	-66.4063f,
+	14.8794f,
+	222.656f,
+	-62.5f,
+	15.7341f,
+	222.656f,
+	-58.5938f,
+	15.0851f,
+	222.656f,
+	-54.6875f,
+	14.4719f,
+	222.656f,
+	-50.7813f,
+	13.6899f,
+	222.656f,
+	-46.875f,
+	13.0842f,
+	222.656f,
+	-42.9688f,
+	13.1059f,
+	222.656f,
+	-39.0625f,
+	13.9942f,
+	222.656f,
+	-35.1563f,
+	13.8877f,
+	222.656f,
+	-31.25f,
+	14.1293f,
+	222.656f,
+	-27.3438f,
+	13.6276f,
+	222.656f,
+	-23.4375f,
+	12.2206f,
+	222.656f,
+	-19.5313f,
+	10.8481f,
+	222.656f,
+	-15.625f,
+	9.71168f,
+	222.656f,
+	-11.7188f,
+	8.51834f,
+	222.656f,
+	-7.8125f,
+	9.04274f,
+	222.656f,
+	-3.90625f,
+	8.46981f,
+	222.656f,
+	0.0f,
+	8.26045f,
+	222.656f,
+	3.90625f,
+	6.81349f,
+	222.656f,
+	-250.0f,
+	5.16984f,
+	218.75f,
+	-246.094f,
+	6.64731f,
+	218.75f,
+	-242.188f,
+	9.50207f,
+	218.75f,
+	-238.281f,
+	12.5115f,
+	218.75f,
+	-234.375f,
+	15.8009f,
+	218.75f,
+	-230.469f,
+	17.6139f,
+	218.75f,
+	-226.563f,
+	18.128f,
+	218.75f,
+	-222.656f,
+	17.3111f,
+	218.75f,
+	-218.75f,
+	16.3962f,
+	218.75f,
+	-214.844f,
+	16.0245f,
+	218.75f,
+	-210.938f,
+	14.5344f,
+	218.75f,
+	-207.031f,
+	13.4459f,
+	218.75f,
+	-203.125f,
+	13.3987f,
+	218.75f,
+	-199.219f,
+	13.5444f,
+	218.75f,
+	-195.313f,
+	12.1973f,
+	218.75f,
+	-191.406f,
+	11.8337f,
+	218.75f,
+	-187.5f,
+	13.3027f,
+	218.75f,
+	-183.594f,
+	13.2862f,
+	218.75f,
+	-179.688f,
+	14.577f,
+	218.75f,
+	-175.781f,
+	14.4312f,
+	218.75f,
+	-171.875f,
+	13.3065f,
+	218.75f,
+	-167.969f,
+	14.2726f,
+	218.75f,
+	-164.063f,
+	14.5522f,
+	218.75f,
+	-160.156f,
+	13.8269f,
+	218.75f,
+	-156.25f,
+	12.4234f,
+	218.75f,
+	-152.344f,
+	10.5035f,
+	218.75f,
+	-148.438f,
+	9.65297f,
+	218.75f,
+	-144.531f,
+	8.3692f,
+	218.75f,
+	-140.625f,
+	7.39811f,
+	218.75f,
+	-136.719f,
+	6.29024f,
+	218.75f,
+	-132.813f,
+	5.37103f,
+	218.75f,
+	-128.906f,
+	5.29069f,
+	218.75f,
+	-125.0f,
+	5.59696f,
+	218.75f,
+	-121.094f,
+	6.15404f,
+	218.75f,
+	-117.188f,
+	7.15855f,
+	218.75f,
+	-113.281f,
+	8.08243f,
+	218.75f,
+	-109.375f,
+	8.97937f,
+	218.75f,
+	-105.469f,
+	9.67177f,
+	218.75f,
+	-101.563f,
+	10.7738f,
+	218.75f,
+	-97.6563f,
+	11.4256f,
+	218.75f,
+	-93.75f,
+	11.6906f,
+	218.75f,
+	-89.8438f,
+	11.4527f,
+	218.75f,
+	-85.9375f,
+	11.5445f,
+	218.75f,
+	-82.0313f,
+	11.9384f,
+	218.75f,
+	-78.125f,
+	12.452f,
+	218.75f,
+	-74.2188f,
+	13.3202f,
+	218.75f,
+	-70.3125f,
+	14.2351f,
+	218.75f,
+	-66.4063f,
+	15.021f,
+	218.75f,
+	-62.5f,
+	16.1053f,
+	218.75f,
+	-58.5938f,
+	16.0633f,
+	218.75f,
+	-54.6875f,
+	15.6154f,
+	218.75f,
+	-50.7813f,
+	15.3347f,
+	218.75f,
+	-46.875f,
+	14.8984f,
+	218.75f,
+	-42.9688f,
+	14.1541f,
+	218.75f,
+	-39.0625f,
+	14.8343f,
+	218.75f,
+	-35.1563f,
+	14.8393f,
+	218.75f,
+	-31.25f,
+	14.865f,
+	218.75f,
+	-27.3438f,
+	13.9913f,
+	218.75f,
+	-23.4375f,
+	13.7749f,
+	218.75f,
+	-19.5313f,
+	12.6247f,
+	218.75f,
+	-15.625f,
+	11.3466f,
+	218.75f,
+	-11.7188f,
+	10.5048f,
+	218.75f,
+	-7.8125f,
+	9.94742f,
+	218.75f,
+	-3.90625f,
+	8.79577f,
+	218.75f,
+	0.0f,
+	8.31646f,
+	218.75f,
+	3.90625f,
+	8.02546f,
+	218.75f,
+	-250.0f,
+	4.42455f,
+	214.844f,
+	-246.094f,
+	6.15686f,
+	214.844f,
+	-242.188f,
+	8.4919f,
+	214.844f,
+	-238.281f,
+	12.2627f,
+	214.844f,
+	-234.375f,
+	15.9215f,
+	214.844f,
+	-230.469f,
+	17.6896f,
+	214.844f,
+	-226.563f,
+	18.1835f,
+	214.844f,
+	-222.656f,
+	17.9341f,
+	214.844f,
+	-218.75f,
+	16.9803f,
+	214.844f,
+	-214.844f,
+	15.6617f,
+	214.844f,
+	-210.938f,
+	14.3989f,
+	214.844f,
+	-207.031f,
+	12.7777f,
+	214.844f,
+	-203.125f,
+	12.7635f,
+	214.844f,
+	-199.219f,
+	12.8533f,
+	214.844f,
+	-195.313f,
+	12.1672f,
+	214.844f,
+	-191.406f,
+	12.2357f,
+	214.844f,
+	-187.5f,
+	12.5806f,
+	214.844f,
+	-183.594f,
+	12.5597f,
+	214.844f,
+	-179.688f,
+	13.6296f,
+	214.844f,
+	-175.781f,
+	13.8382f,
+	214.844f,
+	-171.875f,
+	14.4001f,
+	214.844f,
+	-167.969f,
+	14.3002f,
+	214.844f,
+	-164.063f,
+	14.3353f,
+	214.844f,
+	-160.156f,
+	14.0346f,
+	214.844f,
+	-156.25f,
+	12.9823f,
+	214.844f,
+	-152.344f,
+	10.8141f,
+	214.844f,
+	-148.438f,
+	9.57028f,
+	214.844f,
+	-144.531f,
+	8.18427f,
+	214.844f,
+	-140.625f,
+	6.89938f,
+	214.844f,
+	-136.719f,
+	5.79227f,
+	214.844f,
+	-132.813f,
+	4.60172f,
+	214.844f,
+	-128.906f,
+	4.59969f,
+	214.844f,
+	-125.0f,
+	5.20294f,
+	214.844f,
+	-121.094f,
+	6.17542f,
+	214.844f,
+	-117.188f,
+	7.13347f,
+	214.844f,
+	-113.281f,
+	8.1045f,
+	214.844f,
+	-109.375f,
+	8.73005f,
+	214.844f,
+	-105.469f,
+	9.96489f,
+	214.844f,
+	-101.563f,
+	11.1039f,
+	214.844f,
+	-97.6563f,
+	11.6791f,
+	214.844f,
+	-93.75f,
+	11.9246f,
+	214.844f,
+	-89.8438f,
+	12.0071f,
+	214.844f,
+	-85.9375f,
+	12.8099f,
+	214.844f,
+	-82.0313f,
+	13.3672f,
+	214.844f,
+	-78.125f,
+	13.5811f,
+	214.844f,
+	-74.2188f,
+	14.7559f,
+	214.844f,
+	-70.3125f,
+	15.4274f,
+	214.844f,
+	-66.4063f,
+	15.487f,
+	214.844f,
+	-62.5f,
+	16.3346f,
+	214.844f,
+	-58.5938f,
+	16.424f,
+	214.844f,
+	-54.6875f,
+	17.1014f,
+	214.844f,
+	-50.7813f,
+	17.634f,
+	214.844f,
+	-46.875f,
+	16.5132f,
+	214.844f,
+	-42.9688f,
+	15.1728f,
+	214.844f,
+	-39.0625f,
+	15.4699f,
+	214.844f,
+	-35.1563f,
+	16.154f,
+	214.844f,
+	-31.25f,
+	15.8527f,
+	214.844f,
+	-27.3438f,
+	15.4057f,
+	214.844f,
+	-23.4375f,
+	14.6476f,
+	214.844f,
+	-19.5313f,
+	13.1705f,
+	214.844f,
+	-15.625f,
+	11.9754f,
+	214.844f,
+	-11.7188f,
+	11.7453f,
+	214.844f,
+	-7.8125f,
+	10.8384f,
+	214.844f,
+	-3.90625f,
+	10.1259f,
+	214.844f,
+	0.0f,
+	9.49925f,
+	214.844f,
+	3.90625f,
+	9.25513f,
+	214.844f,
+	-250.0f,
+	3.60269f,
+	210.938f,
+	-246.094f,
+	5.37638f,
+	210.938f,
+	-242.188f,
+	7.66914f,
+	210.938f,
+	-238.281f,
+	11.9863f,
+	210.938f,
+	-234.375f,
+	14.9525f,
+	210.938f,
+	-230.469f,
+	16.5034f,
+	210.938f,
+	-226.563f,
+	17.8663f,
+	210.938f,
+	-222.656f,
+	17.1002f,
+	210.938f,
+	-218.75f,
+	16.0413f,
+	210.938f,
+	-214.844f,
+	14.8516f,
+	210.938f,
+	-210.938f,
+	13.8904f,
+	210.938f,
+	-207.031f,
+	11.9929f,
+	210.938f,
+	-203.125f,
+	11.8171f,
+	210.938f,
+	-199.219f,
+	11.6849f,
+	210.938f,
+	-195.313f,
+	11.056f,
+	210.938f,
+	-191.406f,
+	11.6318f,
+	210.938f,
+	-187.5f,
+	11.9333f,
+	210.938f,
+	-183.594f,
+	12.599f,
+	210.938f,
+	-179.688f,
+	14.0437f,
+	210.938f,
+	-175.781f,
+	14.7937f,
+	210.938f,
+	-171.875f,
+	14.8844f,
+	210.938f,
+	-167.969f,
+	14.3312f,
+	210.938f,
+	-164.063f,
+	13.2879f,
+	210.938f,
+	-160.156f,
+	12.3423f,
+	210.938f,
+	-156.25f,
+	11.4768f,
+	210.938f,
+	-152.344f,
+	9.94481f,
+	210.938f,
+	-148.438f,
+	7.76655f,
+	210.938f,
+	-144.531f,
+	6.59218f,
+	210.938f,
+	-140.625f,
+	6.49848f,
+	210.938f,
+	-136.719f,
+	5.2458f,
+	210.938f,
+	-132.813f,
+	4.27164f,
+	210.938f,
+	-128.906f,
+	4.68484f,
+	210.938f,
+	-125.0f,
+	5.2746f,
+	210.938f,
+	-121.094f,
+	6.12822f,
+	210.938f,
+	-117.188f,
+	8.02215f,
+	210.938f,
+	-113.281f,
+	8.95036f,
+	210.938f,
+	-109.375f,
+	9.92538f,
+	210.938f,
+	-105.469f,
+	10.4058f,
+	210.938f,
+	-101.563f,
+	11.2862f,
+	210.938f,
+	-97.6563f,
+	11.7274f,
+	210.938f,
+	-93.75f,
+	12.3175f,
+	210.938f,
+	-89.8438f,
+	12.6423f,
+	210.938f,
+	-85.9375f,
+	13.2212f,
+	210.938f,
+	-82.0313f,
+	13.9379f,
+	210.938f,
+	-78.125f,
+	15.3332f,
+	210.938f,
+	-74.2188f,
+	16.2893f,
+	210.938f,
+	-70.3125f,
+	16.1032f,
+	210.938f,
+	-66.4063f,
+	16.7786f,
+	210.938f,
+	-62.5f,
+	16.8038f,
+	210.938f,
+	-58.5938f,
+	16.1537f,
+	210.938f,
+	-54.6875f,
+	17.4306f,
+	210.938f,
+	-50.7813f,
+	17.313f,
+	210.938f,
+	-46.875f,
+	16.2568f,
+	210.938f,
+	-42.9688f,
+	16.0266f,
+	210.938f,
+	-39.0625f,
+	16.9569f,
+	210.938f,
+	-35.1563f,
+	18.0733f,
+	210.938f,
+	-31.25f,
+	17.4779f,
+	210.938f,
+	-27.3438f,
+	17.2939f,
+	210.938f,
+	-23.4375f,
+	16.1477f,
+	210.938f,
+	-19.5313f,
+	15.409f,
+	210.938f,
+	-15.625f,
+	14.0019f,
+	210.938f,
+	-11.7188f,
+	13.3531f,
+	210.938f,
+	-7.8125f,
+	12.4823f,
+	210.938f,
+	-3.90625f,
+	11.7842f,
+	210.938f,
+	0.0f,
+	11.0776f,
+	210.938f,
+	3.90625f,
+	10.5728f,
+	210.938f,
+	-250.0f,
+	3.49901f,
+	207.031f,
+	-246.094f,
+	4.00092f,
+	207.031f,
+	-242.188f,
+	7.06194f,
+	207.031f,
+	-238.281f,
+	10.1502f,
+	207.031f,
+	-234.375f,
+	13.0262f,
+	207.031f,
+	-230.469f,
+	15.541f,
+	207.031f,
+	-226.563f,
+	16.4029f,
+	207.031f,
+	-222.656f,
+	16.0741f,
+	207.031f,
+	-218.75f,
+	15.3706f,
+	207.031f,
+	-214.844f,
+	14.3529f,
+	207.031f,
+	-210.938f,
+	13.1351f,
+	207.031f,
+	-207.031f,
+	11.2939f,
+	207.031f,
+	-203.125f,
+	11.4337f,
+	207.031f,
+	-199.219f,
+	11.43f,
+	207.031f,
+	-195.313f,
+	10.6048f,
+	207.031f,
+	-191.406f,
+	10.859f,
+	207.031f,
+	-187.5f,
+	11.8447f,
+	207.031f,
+	-183.594f,
+	12.8305f,
+	207.031f,
+	-179.688f,
+	14.9116f,
+	207.031f,
+	-175.781f,
+	15.0225f,
+	207.031f,
+	-171.875f,
+	14.847f,
+	207.031f,
+	-167.969f,
+	13.7464f,
+	207.031f,
+	-164.063f,
+	12.6716f,
+	207.031f,
+	-160.156f,
+	10.4028f,
+	207.031f,
+	-156.25f,
+	9.61156f,
+	207.031f,
+	-152.344f,
+	9.08545f,
+	207.031f,
+	-148.438f,
+	6.96088f,
+	207.031f,
+	-144.531f,
+	6.6794f,
+	207.031f,
+	-140.625f,
+	6.08012f,
+	207.031f,
+	-136.719f,
+	5.02964f,
+	207.031f,
+	-132.813f,
+	4.93996f,
+	207.031f,
+	-128.906f,
+	4.955f,
+	207.031f,
+	-125.0f,
+	5.23446f,
+	207.031f,
+	-121.094f,
+	7.14164f,
+	207.031f,
+	-117.188f,
+	9.21655f,
+	207.031f,
+	-113.281f,
+	10.8802f,
+	207.031f,
+	-109.375f,
+	11.0518f,
+	207.031f,
+	-105.469f,
+	11.5707f,
+	207.031f,
+	-101.563f,
+	12.2834f,
+	207.031f,
+	-97.6563f,
+	12.7498f,
+	207.031f,
+	-93.75f,
+	12.6608f,
+	207.031f,
+	-89.8438f,
+	12.3649f,
+	207.031f,
+	-85.9375f,
+	13.1678f,
+	207.031f,
+	-82.0313f,
+	13.541f,
+	207.031f,
+	-78.125f,
+	14.3448f,
+	207.031f,
+	-74.2188f,
+	15.6006f,
+	207.031f,
+	-70.3125f,
+	17.0141f,
+	207.031f,
+	-66.4063f,
+	17.4107f,
+	207.031f,
+	-62.5f,
+	18.0045f,
+	207.031f,
+	-58.5938f,
+	17.6582f,
+	207.031f,
+	-54.6875f,
+	17.0297f,
+	207.031f,
+	-50.7813f,
+	16.6619f,
+	207.031f,
+	-46.875f,
+	17.1267f,
+	207.031f,
+	-42.9688f,
+	18.0618f,
+	207.031f,
+	-39.0625f,
+	18.7698f,
+	207.031f,
+	-35.1563f,
+	19.3034f,
+	207.031f,
+	-31.25f,
+	19.1566f,
+	207.031f,
+	-27.3438f,
+	19.1107f,
+	207.031f,
+	-23.4375f,
+	17.3298f,
+	207.031f,
+	-19.5313f,
+	15.7204f,
+	207.031f,
+	-15.625f,
+	14.7827f,
+	207.031f,
+	-11.7188f,
+	14.2027f,
+	207.031f,
+	-7.8125f,
+	13.5758f,
+	207.031f,
+	-3.90625f,
+	13.1935f,
+	207.031f,
+	0.0f,
+	11.8526f,
+	207.031f,
+	3.90625f,
+	10.4539f,
+	207.031f,
+	-250.0f,
+	3.85941f,
+	203.125f,
+	-246.094f,
+	3.80391f,
+	203.125f,
+	-242.188f,
+	6.8342f,
+	203.125f,
+	-238.281f,
+	10.0313f,
+	203.125f,
+	-234.375f,
+	12.9894f,
+	203.125f,
+	-230.469f,
+	15.1588f,
+	203.125f,
+	-226.563f,
+	15.6234f,
+	203.125f,
+	-222.656f,
+	15.112f,
+	203.125f,
+	-218.75f,
+	14.5577f,
+	203.125f,
+	-214.844f,
+	14.0703f,
+	203.125f,
+	-210.938f,
+	13.3523f,
+	203.125f,
+	-207.031f,
+	12.1264f,
+	203.125f,
+	-203.125f,
+	11.037f,
+	203.125f,
+	-199.219f,
+	10.3379f,
+	203.125f,
+	-195.313f,
+	11.3f,
+	203.125f,
+	-191.406f,
+	10.6845f,
+	203.125f,
+	-187.5f,
+	11.7023f,
+	203.125f,
+	-183.594f,
+	13.2057f,
+	203.125f,
+	-179.688f,
+	13.976f,
+	203.125f,
+	-175.781f,
+	14.994f,
+	203.125f,
+	-171.875f,
+	14.6465f,
+	203.125f,
+	-167.969f,
+	13.4879f,
+	203.125f,
+	-164.063f,
+	12.0617f,
+	203.125f,
+	-160.156f,
+	10.6454f,
+	203.125f,
+	-156.25f,
+	10.2693f,
+	203.125f,
+	-152.344f,
+	8.33279f,
+	203.125f,
+	-148.438f,
+	7.60557f,
+	203.125f,
+	-144.531f,
+	6.19774f,
+	203.125f,
+	-140.625f,
+	5.7751f,
+	203.125f,
+	-136.719f,
+	5.28903f,
+	203.125f,
+	-132.813f,
+	5.10696f,
+	203.125f,
+	-128.906f,
+	5.61944f,
+	203.125f,
+	-125.0f,
+	7.32929f,
+	203.125f,
+	-121.094f,
+	9.09158f,
+	203.125f,
+	-117.188f,
+	10.6952f,
+	203.125f,
+	-113.281f,
+	11.555f,
+	203.125f,
+	-109.375f,
+	12.5837f,
+	203.125f,
+	-105.469f,
+	13.4444f,
+	203.125f,
+	-101.563f,
+	14.3191f,
+	203.125f,
+	-97.6563f,
+	14.5546f,
+	203.125f,
+	-93.75f,
+	13.9216f,
+	203.125f,
+	-89.8438f,
+	13.07f,
+	203.125f,
+	-85.9375f,
+	13.0497f,
+	203.125f,
+	-82.0313f,
+	13.8884f,
+	203.125f,
+	-78.125f,
+	14.2048f,
+	203.125f,
+	-74.2188f,
+	16.2809f,
+	203.125f,
+	-70.3125f,
+	17.1518f,
+	203.125f,
+	-66.4063f,
+	18.4883f,
+	203.125f,
+	-62.5f,
+	19.2231f,
+	203.125f,
+	-58.5938f,
+	19.0199f,
+	203.125f,
+	-54.6875f,
+	18.4606f,
+	203.125f,
+	-50.7813f,
+	17.3076f,
+	203.125f,
+	-46.875f,
+	17.0012f,
+	203.125f,
+	-42.9688f,
+	18.4311f,
+	203.125f,
+	-39.0625f,
+	19.9758f,
+	203.125f,
+	-35.1563f,
+	20.1252f,
+	203.125f,
+	-31.25f,
+	20.126f,
+	203.125f,
+	-27.3438f,
+	18.9276f,
+	203.125f,
+	-23.4375f,
+	18.3938f,
+	203.125f,
+	-19.5313f,
+	16.6811f,
+	203.125f,
+	-15.625f,
+	15.7398f,
+	203.125f,
+	-11.7188f,
+	14.6978f,
+	203.125f,
+	-7.8125f,
+	14.7567f,
+	203.125f,
+	-3.90625f,
+	14.377f,
+	203.125f,
+	0.0f,
+	13.0029f,
+	203.125f,
+	3.90625f,
+	11.4706f,
+	203.125f,
+	-250.0f,
+	4.68355f,
+	199.219f,
+	-246.094f,
+	4.65569f,
+	199.219f,
+	-242.188f,
+	6.34925f,
+	199.219f,
+	-238.281f,
+	9.03665f,
+	199.219f,
+	-234.375f,
+	11.4587f,
+	199.219f,
+	-230.469f,
+	13.9932f,
+	199.219f,
+	-226.563f,
+	14.8268f,
+	199.219f,
+	-222.656f,
+	14.0552f,
+	199.219f,
+	-218.75f,
+	14.4455f,
+	199.219f,
+	-214.844f,
+	14.3053f,
+	199.219f,
+	-210.938f,
+	12.5781f,
+	199.219f,
+	-207.031f,
+	11.5778f,
+	199.219f,
+	-203.125f,
+	9.91652f,
+	199.219f,
+	-199.219f,
+	9.20832f,
+	199.219f,
+	-195.313f,
+	10.1078f,
+	199.219f,
+	-191.406f,
+	10.5638f,
+	199.219f,
+	-187.5f,
+	11.6649f,
+	199.219f,
+	-183.594f,
+	13.3758f,
+	199.219f,
+	-179.688f,
+	15.2035f,
+	199.219f,
+	-175.781f,
+	14.6909f,
+	199.219f,
+	-171.875f,
+	14.0312f,
+	199.219f,
+	-167.969f,
+	12.6808f,
+	199.219f,
+	-164.063f,
+	12.649f,
+	199.219f,
+	-160.156f,
+	11.6333f,
+	199.219f,
+	-156.25f,
+	10.8896f,
+	199.219f,
+	-152.344f,
+	8.72848f,
+	199.219f,
+	-148.438f,
+	7.55753f,
+	199.219f,
+	-144.531f,
+	6.70035f,
+	199.219f,
+	-140.625f,
+	5.28209f,
+	199.219f,
+	-136.719f,
+	5.47347f,
+	199.219f,
+	-132.813f,
+	7.25678f,
+	199.219f,
+	-128.906f,
+	9.06223f,
+	199.219f,
+	-125.0f,
+	9.91604f,
+	199.219f,
+	-121.094f,
+	10.882f,
+	199.219f,
+	-117.188f,
+	11.8314f,
+	199.219f,
+	-113.281f,
+	12.9729f,
+	199.219f,
+	-109.375f,
+	14.1144f,
+	199.219f,
+	-105.469f,
+	15.0374f,
+	199.219f,
+	-101.563f,
+	15.4321f,
+	199.219f,
+	-97.6563f,
+	15.9823f,
+	199.219f,
+	-93.75f,
+	15.4663f,
+	199.219f,
+	-89.8438f,
+	14.4094f,
+	199.219f,
+	-85.9375f,
+	14.1599f,
+	199.219f,
+	-82.0313f,
+	14.4239f,
+	199.219f,
+	-78.125f,
+	14.7717f,
+	199.219f,
+	-74.2188f,
+	15.3979f,
+	199.219f,
+	-70.3125f,
+	16.4014f,
+	199.219f,
+	-66.4063f,
+	17.9486f,
+	199.219f,
+	-62.5f,
+	19.3767f,
+	199.219f,
+	-58.5938f,
+	19.7322f,
+	199.219f,
+	-54.6875f,
+	19.0648f,
+	199.219f,
+	-50.7813f,
+	18.2481f,
+	199.219f,
+	-46.875f,
+	17.1507f,
+	199.219f,
+	-42.9688f,
+	18.6306f,
+	199.219f,
+	-39.0625f,
+	19.2486f,
+	199.219f,
+	-35.1563f,
+	20.3158f,
+	199.219f,
+	-31.25f,
+	19.6441f,
+	199.219f,
+	-27.3438f,
+	18.7294f,
+	199.219f,
+	-23.4375f,
+	17.9051f,
+	199.219f,
+	-19.5313f,
+	17.278f,
+	199.219f,
+	-15.625f,
+	16.1912f,
+	199.219f,
+	-11.7188f,
+	15.3685f,
+	199.219f,
+	-7.8125f,
+	14.8376f,
+	199.219f,
+	-3.90625f,
+	13.8988f,
+	199.219f,
+	0.0f,
+	12.5645f,
+	199.219f,
+	3.90625f,
+	12.1184f,
+	199.219f,
+	-250.0f,
+	5.71048f,
+	195.313f,
+	-246.094f,
+	4.68298f,
+	195.313f,
+	-242.188f,
+	5.30012f,
+	195.313f,
+	-238.281f,
+	7.72299f,
+	195.313f,
+	-234.375f,
+	10.9797f,
+	195.313f,
+	-230.469f,
+	12.6343f,
+	195.313f,
+	-226.563f,
+	13.8962f,
+	195.313f,
+	-222.656f,
+	13.2189f,
+	195.313f,
+	-218.75f,
+	14.0254f,
+	195.313f,
+	-214.844f,
+	14.5903f,
+	195.313f,
+	-210.938f,
+	12.6794f,
+	195.313f,
+	-207.031f,
+	9.8479f,
+	195.313f,
+	-203.125f,
+	8.05763f,
+	195.313f,
+	-199.219f,
+	7.68254f,
+	195.313f,
+	-195.313f,
+	9.0324f,
+	195.313f,
+	-191.406f,
+	10.7973f,
+	195.313f,
+	-187.5f,
+	12.1516f,
+	195.313f,
+	-183.594f,
+	13.1888f,
+	195.313f,
+	-179.688f,
+	14.2559f,
+	195.313f,
+	-175.781f,
+	14.0455f,
+	195.313f,
+	-171.875f,
+	13.2785f,
+	195.313f,
+	-167.969f,
+	12.7724f,
+	195.313f,
+	-164.063f,
+	12.56f,
+	195.313f,
+	-160.156f,
+	11.4647f,
+	195.313f,
+	-156.25f,
+	10.6463f,
+	195.313f,
+	-152.344f,
+	9.36927f,
+	195.313f,
+	-148.438f,
+	7.87862f,
+	195.313f,
+	-144.531f,
+	6.78168f,
+	195.313f,
+	-140.625f,
+	5.32688f,
+	195.313f,
+	-136.719f,
+	6.62928f,
+	195.313f,
+	-132.813f,
+	8.97871f,
+	195.313f,
+	-128.906f,
+	10.3174f,
+	195.313f,
+	-125.0f,
+	11.2136f,
+	195.313f,
+	-121.094f,
+	12.2822f,
+	195.313f,
+	-117.188f,
+	13.7351f,
+	195.313f,
+	-113.281f,
+	14.0196f,
+	195.313f,
+	-109.375f,
+	15.5457f,
+	195.313f,
+	-105.469f,
+	16.1402f,
+	195.313f,
+	-101.563f,
+	16.6719f,
+	195.313f,
+	-97.6563f,
+	16.2658f,
+	195.313f,
+	-93.75f,
+	16.5379f,
+	195.313f,
+	-89.8438f,
+	15.1289f,
+	195.313f,
+	-85.9375f,
+	14.7687f,
+	195.313f,
+	-82.0313f,
+	15.4638f,
+	195.313f,
+	-78.125f,
+	15.3391f,
+	195.313f,
+	-74.2188f,
+	14.8602f,
+	195.313f,
+	-70.3125f,
+	16.2701f,
+	195.313f,
+	-66.4063f,
+	17.9511f,
+	195.313f,
+	-62.5f,
+	19.108f,
+	195.313f,
+	-58.5938f,
+	19.5253f,
+	195.313f,
+	-54.6875f,
+	19.1648f,
+	195.313f,
+	-50.7813f,
+	18.0624f,
+	195.313f,
+	-46.875f,
+	17.2201f,
+	195.313f,
+	-42.9688f,
+	19.4165f,
+	195.313f,
+	-39.0625f,
+	20.3781f,
+	195.313f,
+	-35.1563f,
+	19.796f,
+	195.313f,
+	-31.25f,
+	18.9841f,
+	195.313f,
+	-27.3438f,
+	18.3143f,
+	195.313f,
+	-23.4375f,
+	18.1973f,
+	195.313f,
+	-19.5313f,
+	17.5121f,
+	195.313f,
+	-15.625f,
+	16.5969f,
+	195.313f,
+	-11.7188f,
+	15.3539f,
+	195.313f,
+	-7.8125f,
+	14.4654f,
+	195.313f,
+	-3.90625f,
+	13.8161f,
+	195.313f,
+	0.0f,
+	12.4727f,
+	195.313f,
+	3.90625f,
+	13.8013f,
+	195.313f,
+	-250.0f,
+	6.07831f,
+	191.406f,
+	-246.094f,
+	5.46721f,
+	191.406f,
+	-242.188f,
+	4.48351f,
+	191.406f,
+	-238.281f,
+	6.74031f,
+	191.406f,
+	-234.375f,
+	9.75661f,
+	191.406f,
+	-230.469f,
+	11.5382f,
+	191.406f,
+	-226.563f,
+	12.9559f,
+	191.406f,
+	-222.656f,
+	12.6196f,
+	191.406f,
+	-218.75f,
+	12.4516f,
+	191.406f,
+	-214.844f,
+	13.5738f,
+	191.406f,
+	-210.938f,
+	12.2334f,
+	191.406f,
+	-207.031f,
+	9.36284f,
+	191.406f,
+	-203.125f,
+	7.56119f,
+	191.406f,
+	-199.219f,
+	8.2975f,
+	191.406f,
+	-195.313f,
+	10.0432f,
+	191.406f,
+	-191.406f,
+	11.528f,
+	191.406f,
+	-187.5f,
+	12.9338f,
+	191.406f,
+	-183.594f,
+	13.9397f,
+	191.406f,
+	-179.688f,
+	14.1423f,
+	191.406f,
+	-175.781f,
+	13.7637f,
+	191.406f,
+	-171.875f,
+	12.7983f,
+	191.406f,
+	-167.969f,
+	12.6132f,
+	191.406f,
+	-164.063f,
+	12.07f,
+	191.406f,
+	-160.156f,
+	11.7037f,
+	191.406f,
+	-156.25f,
+	10.3692f,
+	191.406f,
+	-152.344f,
+	9.29784f,
+	191.406f,
+	-148.438f,
+	7.91508f,
+	191.406f,
+	-144.531f,
+	6.85636f,
+	191.406f,
+	-140.625f,
+	8.06021f,
+	191.406f,
+	-136.719f,
+	8.86078f,
+	191.406f,
+	-132.813f,
+	11.0565f,
+	191.406f,
+	-128.906f,
+	12.4031f,
+	191.406f,
+	-125.0f,
+	13.4308f,
+	191.406f,
+	-121.094f,
+	13.8732f,
+	191.406f,
+	-117.188f,
+	15.0555f,
+	191.406f,
+	-113.281f,
+	16.0219f,
+	191.406f,
+	-109.375f,
+	16.8646f,
+	191.406f,
+	-105.469f,
+	16.9156f,
+	191.406f,
+	-101.563f,
+	16.9811f,
+	191.406f,
+	-97.6563f,
+	17.1773f,
+	191.406f,
+	-93.75f,
+	16.9233f,
+	191.406f,
+	-89.8438f,
+	15.3563f,
+	191.406f,
+	-85.9375f,
+	14.4936f,
+	191.406f,
+	-82.0313f,
+	15.6108f,
+	191.406f,
+	-78.125f,
+	15.9615f,
+	191.406f,
+	-74.2188f,
+	14.6365f,
+	191.406f,
+	-70.3125f,
+	15.5344f,
+	191.406f,
+	-66.4063f,
+	17.4295f,
+	191.406f,
+	-62.5f,
+	18.2646f,
+	191.406f,
+	-58.5938f,
+	19.0205f,
+	191.406f,
+	-54.6875f,
+	19.0503f,
+	191.406f,
+	-50.7813f,
+	17.6912f,
+	191.406f,
+	-46.875f,
+	17.6816f,
+	191.406f,
+	-42.9688f,
+	18.8066f,
+	191.406f,
+	-39.0625f,
+	19.8444f,
+	191.406f,
+	-35.1563f,
+	18.7929f,
+	191.406f,
+	-31.25f,
+	18.6865f,
+	191.406f,
+	-27.3438f,
+	19.0671f,
+	191.406f,
+	-23.4375f,
+	18.6708f,
+	191.406f,
+	-19.5313f,
+	17.7215f,
+	191.406f,
+	-15.625f,
+	16.4711f,
+	191.406f,
+	-11.7188f,
+	15.4735f,
+	191.406f,
+	-7.8125f,
+	14.6316f,
+	191.406f,
+	-3.90625f,
+	13.8779f,
+	191.406f,
+	0.0f,
+	13.7777f,
+	191.406f,
+	3.90625f,
+	14.3936f,
+	191.406f,
+	-250.0f,
+	6.25219f,
+	187.5f,
+	-246.094f,
+	5.98752f,
+	187.5f,
+	-242.188f,
+	5.50108f,
+	187.5f,
+	-238.281f,
+	5.52049f,
+	187.5f,
+	-234.375f,
+	7.87236f,
+	187.5f,
+	-230.469f,
+	10.0244f,
+	187.5f,
+	-226.563f,
+	10.9579f,
+	187.5f,
+	-222.656f,
+	11.4176f,
+	187.5f,
+	-218.75f,
+	11.1583f,
+	187.5f,
+	-214.844f,
+	12.0797f,
+	187.5f,
+	-210.938f,
+	10.8226f,
+	187.5f,
+	-207.031f,
+	8.91363f,
+	187.5f,
+	-203.125f,
+	7.71952f,
+	187.5f,
+	-199.219f,
+	8.97116f,
+	187.5f,
+	-195.313f,
+	10.8813f,
+	187.5f,
+	-191.406f,
+	12.5874f,
+	187.5f,
+	-187.5f,
+	13.3418f,
+	187.5f,
+	-183.594f,
+	13.6407f,
+	187.5f,
+	-179.688f,
+	13.8787f,
+	187.5f,
+	-175.781f,
+	13.7918f,
+	187.5f,
+	-171.875f,
+	12.965f,
+	187.5f,
+	-167.969f,
+	12.2732f,
+	187.5f,
+	-164.063f,
+	11.6063f,
+	187.5f,
+	-160.156f,
+	10.9159f,
+	187.5f,
+	-156.25f,
+	10.2447f,
+	187.5f,
+	-152.344f,
+	9.32757f,
+	187.5f,
+	-148.438f,
+	9.17721f,
+	187.5f,
+	-144.531f,
+	9.53961f,
+	187.5f,
+	-140.625f,
+	10.4339f,
+	187.5f,
+	-136.719f,
+	11.8144f,
+	187.5f,
+	-132.813f,
+	13.3081f,
+	187.5f,
+	-128.906f,
+	13.571f,
+	187.5f,
+	-125.0f,
+	13.9242f,
+	187.5f,
+	-121.094f,
+	15.4069f,
+	187.5f,
+	-117.188f,
+	16.9689f,
+	187.5f,
+	-113.281f,
+	17.987f,
+	187.5f,
+	-109.375f,
+	18.7838f,
+	187.5f,
+	-105.469f,
+	18.7737f,
+	187.5f,
+	-101.563f,
+	18.6666f,
+	187.5f,
+	-97.6563f,
+	18.4809f,
+	187.5f,
+	-93.75f,
+	18.3562f,
+	187.5f,
+	-89.8438f,
+	16.3715f,
+	187.5f,
+	-85.9375f,
+	14.5483f,
+	187.5f,
+	-82.0313f,
+	14.9648f,
+	187.5f,
+	-78.125f,
+	16.1061f,
+	187.5f,
+	-74.2188f,
+	14.4715f,
+	187.5f,
+	-70.3125f,
+	14.8322f,
+	187.5f,
+	-66.4063f,
+	16.3093f,
+	187.5f,
+	-62.5f,
+	17.3305f,
+	187.5f,
+	-58.5938f,
+	18.3312f,
+	187.5f,
+	-54.6875f,
+	18.2865f,
+	187.5f,
+	-50.7813f,
+	17.4373f,
+	187.5f,
+	-46.875f,
+	17.9803f,
+	187.5f,
+	-42.9688f,
+	18.679f,
+	187.5f,
+	-39.0625f,
+	19.2363f,
+	187.5f,
+	-35.1563f,
+	19.9926f,
+	187.5f,
+	-31.25f,
+	19.8827f,
+	187.5f,
+	-27.3438f,
+	19.283f,
+	187.5f,
+	-23.4375f,
+	19.0081f,
+	187.5f,
+	-19.5313f,
+	17.5129f,
+	187.5f,
+	-15.625f,
+	16.6754f,
+	187.5f,
+	-11.7188f,
+	15.6685f,
+	187.5f,
+	-7.8125f,
+	14.6133f,
+	187.5f,
+	-3.90625f,
+	13.9468f,
+	187.5f,
+	0.0f,
+	14.2206f,
+	187.5f,
+	3.90625f,
+	14.1738f,
+	187.5f,
+	-250.0f,
+	7.10023f,
+	183.594f,
+	-246.094f,
+	6.39376f,
+	183.594f,
+	-242.188f,
+	5.78017f,
+	183.594f,
+	-238.281f,
+	5.07235f,
+	183.594f,
+	-234.375f,
+	5.98564f,
+	183.594f,
+	-230.469f,
+	7.6542f,
+	183.594f,
+	-226.563f,
+	8.75539f,
+	183.594f,
+	-222.656f,
+	9.90845f,
+	183.594f,
+	-218.75f,
+	10.2067f,
+	183.594f,
+	-214.844f,
+	10.2019f,
+	183.594f,
+	-210.938f,
+	9.2327f,
+	183.594f,
+	-207.031f,
+	7.67088f,
+	183.594f,
+	-203.125f,
+	8.15546f,
+	183.594f,
+	-199.219f,
+	9.42269f,
+	183.594f,
+	-195.313f,
+	10.8046f,
+	183.594f,
+	-191.406f,
+	13.3042f,
+	183.594f,
+	-187.5f,
+	13.9971f,
+	183.594f,
+	-183.594f,
+	13.621f,
+	183.594f,
+	-179.688f,
+	13.5612f,
+	183.594f,
+	-175.781f,
+	13.5357f,
+	183.594f,
+	-171.875f,
+	12.8778f,
+	183.594f,
+	-167.969f,
+	12.0385f,
+	183.594f,
+	-164.063f,
+	11.4391f,
+	183.594f,
+	-160.156f,
+	10.4255f,
+	183.594f,
+	-156.25f,
+	10.5692f,
+	183.594f,
+	-152.344f,
+	10.5452f,
+	183.594f,
+	-148.438f,
+	11.506f,
+	183.594f,
+	-144.531f,
+	12.1591f,
+	183.594f,
+	-140.625f,
+	12.6212f,
+	183.594f,
+	-136.719f,
+	13.5025f,
+	183.594f,
+	-132.813f,
+	14.3363f,
+	183.594f,
+	-128.906f,
+	14.5206f,
+	183.594f,
+	-125.0f,
+	15.4902f,
+	183.594f,
+	-121.094f,
+	17.4029f,
+	183.594f,
+	-117.188f,
+	17.9537f,
+	183.594f,
+	-113.281f,
+	18.5532f,
+	183.594f,
+	-109.375f,
+	19.2939f,
+	183.594f,
+	-105.469f,
+	19.2503f,
+	183.594f,
+	-101.563f,
+	19.8772f,
+	183.594f,
+	-97.6563f,
+	19.6753f,
+	183.594f,
+	-93.75f,
+	18.6744f,
+	183.594f,
+	-89.8438f,
+	17.7905f,
+	183.594f,
+	-85.9375f,
+	16.1613f,
+	183.594f,
+	-82.0313f,
+	15.7839f,
+	183.594f,
+	-78.125f,
+	15.657f,
+	183.594f,
+	-74.2188f,
+	14.4171f,
+	183.594f,
+	-70.3125f,
+	14.6083f,
+	183.594f,
+	-66.4063f,
+	15.5594f,
+	183.594f,
+	-62.5f,
+	16.1338f,
+	183.594f,
+	-58.5938f,
+	17.1134f,
+	183.594f,
+	-54.6875f,
+	16.8192f,
+	183.594f,
+	-50.7813f,
+	17.6885f,
+	183.594f,
+	-46.875f,
+	18.5331f,
+	183.594f,
+	-42.9688f,
+	19.7359f,
+	183.594f,
+	-39.0625f,
+	20.7966f,
+	183.594f,
+	-35.1563f,
+	20.414f,
+	183.594f,
+	-31.25f,
+	20.1587f,
+	183.594f,
+	-27.3438f,
+	19.9385f,
+	183.594f,
+	-23.4375f,
+	18.4694f,
+	183.594f,
+	-19.5313f,
+	16.9742f,
+	183.594f,
+	-15.625f,
+	16.0698f,
+	183.594f,
+	-11.7188f,
+	15.4466f,
+	183.594f,
+	-7.8125f,
+	15.0614f,
+	183.594f,
+	-3.90625f,
+	15.2165f,
+	183.594f,
+	0.0f,
+	14.2632f,
+	183.594f,
+	3.90625f,
+	13.9878f,
+	183.594f,
+	-250.0f,
+	8.16978f,
+	179.688f,
+	-246.094f,
+	7.02044f,
+	179.688f,
+	-242.188f,
+	6.49336f,
+	179.688f,
+	-238.281f,
+	6.17674f,
+	179.688f,
+	-234.375f,
+	4.65977f,
+	179.688f,
+	-230.469f,
+	5.28977f,
+	179.688f,
+	-226.563f,
+	7.10711f,
+	179.688f,
+	-222.656f,
+	8.03062f,
+	179.688f,
+	-218.75f,
+	9.32719f,
+	179.688f,
+	-214.844f,
+	9.22926f,
+	179.688f,
+	-210.938f,
+	8.64588f,
+	179.688f,
+	-207.031f,
+	7.76534f,
+	179.688f,
+	-203.125f,
+	8.37552f,
+	179.688f,
+	-199.219f,
+	8.61402f,
+	179.688f,
+	-195.313f,
+	10.7567f,
+	179.688f,
+	-191.406f,
+	12.1961f,
+	179.688f,
+	-187.5f,
+	13.5076f,
+	179.688f,
+	-183.594f,
+	13.5739f,
+	179.688f,
+	-179.688f,
+	13.6032f,
+	179.688f,
+	-175.781f,
+	13.5388f,
+	179.688f,
+	-171.875f,
+	13.0425f,
+	179.688f,
+	-167.969f,
+	13.5885f,
+	179.688f,
+	-164.063f,
+	13.2666f,
+	179.688f,
+	-160.156f,
+	11.7827f,
+	179.688f,
+	-156.25f,
+	12.3517f,
+	179.688f,
+	-152.344f,
+	13.1307f,
+	179.688f,
+	-148.438f,
+	13.6688f,
+	179.688f,
+	-144.531f,
+	13.758f,
+	179.688f,
+	-140.625f,
+	14.023f,
+	179.688f,
+	-136.719f,
+	15.1514f,
+	179.688f,
+	-132.813f,
+	16.004f,
+	179.688f,
+	-128.906f,
+	16.8991f,
+	179.688f,
+	-125.0f,
+	17.3616f,
+	179.688f,
+	-121.094f,
+	18.6059f,
+	179.688f,
+	-117.188f,
+	19.3263f,
+	179.688f,
+	-113.281f,
+	19.1956f,
+	179.688f,
+	-109.375f,
+	19.7991f,
+	179.688f,
+	-105.469f,
+	20.6907f,
+	179.688f,
+	-101.563f,
+	21.7059f,
+	179.688f,
+	-97.6563f,
+	21.5595f,
+	179.688f,
+	-93.75f,
+	20.4072f,
+	179.688f,
+	-89.8438f,
+	19.1786f,
+	179.688f,
+	-85.9375f,
+	18.2895f,
+	179.688f,
+	-82.0313f,
+	17.1568f,
+	179.688f,
+	-78.125f,
+	15.2991f,
+	179.688f,
+	-74.2188f,
+	14.0951f,
+	179.688f,
+	-70.3125f,
+	14.2935f,
+	179.688f,
+	-66.4063f,
+	15.0579f,
+	179.688f,
+	-62.5f,
+	15.3497f,
+	179.688f,
+	-58.5938f,
+	15.4148f,
+	179.688f,
+	-54.6875f,
+	17.2528f,
+	179.688f,
+	-50.7813f,
+	18.38f,
+	179.688f,
+	-46.875f,
+	19.343f,
+	179.688f,
+	-42.9688f,
+	20.2151f,
+	179.688f,
+	-39.0625f,
+	21.1482f,
+	179.688f,
+	-35.1563f,
+	20.8113f,
+	179.688f,
+	-31.25f,
+	19.3685f,
+	179.688f,
+	-27.3438f,
+	18.4966f,
+	179.688f,
+	-23.4375f,
+	17.1162f,
+	179.688f,
+	-19.5313f,
+	16.1739f,
+	179.688f,
+	-15.625f,
+	15.1081f,
+	179.688f,
+	-11.7188f,
+	15.5766f,
+	179.688f,
+	-7.8125f,
+	16.3649f,
+	179.688f,
+	-3.90625f,
+	16.3198f,
+	179.688f,
+	0.0f,
+	15.6844f,
+	179.688f,
+	3.90625f,
+	14.6785f,
+	179.688f,
+	-250.0f,
+	9.32456f,
+	175.781f,
+	-246.094f,
+	8.37571f,
+	175.781f,
+	-242.188f,
+	7.57502f,
+	175.781f,
+	-238.281f,
+	7.01497f,
+	175.781f,
+	-234.375f,
+	5.67261f,
+	175.781f,
+	-230.469f,
+	4.32895f,
+	175.781f,
+	-226.563f,
+	5.20027f,
+	175.781f,
+	-222.656f,
+	6.31061f,
+	175.781f,
+	-218.75f,
+	7.56464f,
+	175.781f,
+	-214.844f,
+	8.35874f,
+	175.781f,
+	-210.938f,
+	8.24556f,
+	175.781f,
+	-207.031f,
+	7.58905f,
+	175.781f,
+	-203.125f,
+	8.23662f,
+	175.781f,
+	-199.219f,
+	8.64236f,
+	175.781f,
+	-195.313f,
+	10.4842f,
+	175.781f,
+	-191.406f,
+	11.8296f,
+	175.781f,
+	-187.5f,
+	13.5307f,
+	175.781f,
+	-183.594f,
+	14.3422f,
+	175.781f,
+	-179.688f,
+	14.0725f,
+	175.781f,
+	-175.781f,
+	14.6f,
+	175.781f,
+	-171.875f,
+	13.9877f,
+	175.781f,
+	-167.969f,
+	13.7556f,
+	175.781f,
+	-164.063f,
+	13.4564f,
+	175.781f,
+	-160.156f,
+	13.6823f,
+	175.781f,
+	-156.25f,
+	14.2643f,
+	175.781f,
+	-152.344f,
+	14.5034f,
+	175.781f,
+	-148.438f,
+	14.905f,
+	175.781f,
+	-144.531f,
+	15.0207f,
+	175.781f,
+	-140.625f,
+	15.2745f,
+	175.781f,
+	-136.719f,
+	16.7553f,
+	175.781f,
+	-132.813f,
+	17.9777f,
+	175.781f,
+	-128.906f,
+	18.5468f,
+	175.781f,
+	-125.0f,
+	19.2067f,
+	175.781f,
+	-121.094f,
+	19.2384f,
+	175.781f,
+	-117.188f,
+	19.4993f,
+	175.781f,
+	-113.281f,
+	20.2276f,
+	175.781f,
+	-109.375f,
+	21.3946f,
+	175.781f,
+	-105.469f,
+	22.0598f,
+	175.781f,
+	-101.563f,
+	23.2713f,
+	175.781f,
+	-97.6563f,
+	22.6691f,
+	175.781f,
+	-93.75f,
+	21.3119f,
+	175.781f,
+	-89.8438f,
+	20.6083f,
+	175.781f,
+	-85.9375f,
+	19.4937f,
+	175.781f,
+	-82.0313f,
+	18.1998f,
+	175.781f,
+	-78.125f,
+	15.7716f,
+	175.781f,
+	-74.2188f,
+	14.2438f,
+	175.781f,
+	-70.3125f,
+	14.4105f,
+	175.781f,
+	-66.4063f,
+	15.1879f,
+	175.781f,
+	-62.5f,
+	15.7946f,
+	175.781f,
+	-58.5938f,
+	16.2302f,
+	175.781f,
+	-54.6875f,
+	17.1058f,
+	175.781f,
+	-50.7813f,
+	18.9688f,
+	175.781f,
+	-46.875f,
+	19.3102f,
+	175.781f,
+	-42.9688f,
+	19.3902f,
+	175.781f,
+	-39.0625f,
+	19.6545f,
+	175.781f,
+	-35.1563f,
+	19.2909f,
+	175.781f,
+	-31.25f,
+	18.5385f,
+	175.781f,
+	-27.3438f,
+	16.4388f,
+	175.781f,
+	-23.4375f,
+	15.5576f,
+	175.781f,
+	-19.5313f,
+	15.7726f,
+	175.781f,
+	-15.625f,
+	16.3756f,
+	175.781f,
+	-11.7188f,
+	16.9626f,
+	175.781f,
+	-7.8125f,
+	17.219f,
+	175.781f,
+	-3.90625f,
+	17.063f,
+	175.781f,
+	0.0f,
+	16.3609f,
+	175.781f,
+	3.90625f,
+	15.2963f,
+	175.781f,
+	-250.0f,
+	10.0329f,
+	171.875f,
+	-246.094f,
+	8.57258f,
+	171.875f,
+	-242.188f,
+	7.81755f,
+	171.875f,
+	-238.281f,
+	6.9951f,
+	171.875f,
+	-234.375f,
+	5.59199f,
+	171.875f,
+	-230.469f,
+	4.81205f,
+	171.875f,
+	-226.563f,
+	4.7432f,
+	171.875f,
+	-222.656f,
+	5.42683f,
+	171.875f,
+	-218.75f,
+	6.16332f,
+	171.875f,
+	-214.844f,
+	6.63573f,
+	171.875f,
+	-210.938f,
+	6.97578f,
+	171.875f,
+	-207.031f,
+	7.49804f,
+	171.875f,
+	-203.125f,
+	8.51155f,
+	171.875f,
+	-199.219f,
+	7.94356f,
+	171.875f,
+	-195.313f,
+	9.50881f,
+	171.875f,
+	-191.406f,
+	10.9726f,
+	171.875f,
+	-187.5f,
+	13.1622f,
+	171.875f,
+	-183.594f,
+	13.8249f,
+	171.875f,
+	-179.688f,
+	15.1925f,
+	171.875f,
+	-175.781f,
+	14.9284f,
+	171.875f,
+	-171.875f,
+	13.915f,
+	171.875f,
+	-167.969f,
+	14.2258f,
+	171.875f,
+	-164.063f,
+	13.435f,
+	171.875f,
+	-160.156f,
+	13.9359f,
+	171.875f,
+	-156.25f,
+	14.8963f,
+	171.875f,
+	-152.344f,
+	15.2933f,
+	171.875f,
+	-148.438f,
+	15.0124f,
+	171.875f,
+	-144.531f,
+	15.0787f,
+	171.875f,
+	-140.625f,
+	15.1958f,
+	171.875f,
+	-136.719f,
+	17.151f,
+	171.875f,
+	-132.813f,
+	18.8799f,
+	171.875f,
+	-128.906f,
+	19.5273f,
+	171.875f,
+	-125.0f,
+	19.6894f,
+	171.875f,
+	-121.094f,
+	19.6466f,
+	171.875f,
+	-117.188f,
+	20.5941f,
+	171.875f,
+	-113.281f,
+	21.5237f,
+	171.875f,
+	-109.375f,
+	22.5435f,
+	171.875f,
+	-105.469f,
+	23.0706f,
+	171.875f,
+	-101.563f,
+	23.614f,
+	171.875f,
+	-97.6563f,
+	22.4198f,
+	171.875f,
+	-93.75f,
+	21.9598f,
+	171.875f,
+	-89.8438f,
+	22.3051f,
+	171.875f,
+	-85.9375f,
+	21.7459f,
+	171.875f,
+	-82.0313f,
+	20.1308f,
+	171.875f,
+	-78.125f,
+	17.6018f,
+	171.875f,
+	-74.2188f,
+	15.106f,
+	171.875f,
+	-70.3125f,
+	16.0838f,
+	171.875f,
+	-66.4063f,
+	16.4153f,
+	171.875f,
+	-62.5f,
+	16.9093f,
+	171.875f,
+	-58.5938f,
+	16.7439f,
+	171.875f,
+	-54.6875f,
+	16.4659f,
+	171.875f,
+	-50.7813f,
+	18.0893f,
+	171.875f,
+	-46.875f,
+	18.8298f,
+	171.875f,
+	-42.9688f,
+	18.459f,
+	171.875f,
+	-39.0625f,
+	18.0953f,
+	171.875f,
+	-35.1563f,
+	18.2461f,
+	171.875f,
+	-31.25f,
+	17.0625f,
+	171.875f,
+	-27.3438f,
+	15.3181f,
+	171.875f,
+	-23.4375f,
+	15.1837f,
+	171.875f,
+	-19.5313f,
+	17.2025f,
+	171.875f,
+	-15.625f,
+	18.3144f,
+	171.875f,
+	-11.7188f,
+	18.4161f,
+	171.875f,
+	-7.8125f,
+	18.3279f,
+	171.875f,
+	-3.90625f,
+	17.5657f,
+	171.875f,
+	0.0f,
+	16.2057f,
+	171.875f,
+	3.90625f,
+	16.0791f,
+	171.875f,
+	-250.0f,
+	9.46368f,
+	167.969f,
+	-246.094f,
+	8.91851f,
+	167.969f,
+	-242.188f,
+	7.83383f,
+	167.969f,
+	-238.281f,
+	7.4147f,
+	167.969f,
+	-234.375f,
+	6.33692f,
+	167.969f,
+	-230.469f,
+	5.44334f,
+	167.969f,
+	-226.563f,
+	4.39369f,
+	167.969f,
+	-222.656f,
+	3.44146f,
+	167.969f,
+	-218.75f,
+	4.44651f,
+	167.969f,
+	-214.844f,
+	5.36701f,
+	167.969f,
+	-210.938f,
+	6.2915f,
+	167.969f,
+	-207.031f,
+	6.3588f,
+	167.969f,
+	-203.125f,
+	7.36203f,
+	167.969f,
+	-199.219f,
+	7.7957f,
+	167.969f,
+	-195.313f,
+	9.3926f,
+	167.969f,
+	-191.406f,
+	11.2699f,
+	167.969f,
+	-187.5f,
+	12.3727f,
+	167.969f,
+	-183.594f,
+	14.7022f,
+	167.969f,
+	-179.688f,
+	15.4324f,
+	167.969f,
+	-175.781f,
+	15.226f,
+	167.969f,
+	-171.875f,
+	13.6658f,
+	167.969f,
+	-167.969f,
+	14.0361f,
+	167.969f,
+	-164.063f,
+	13.5871f,
+	167.969f,
+	-160.156f,
+	14.725f,
+	167.969f,
+	-156.25f,
+	15.5452f,
+	167.969f,
+	-152.344f,
+	16.3685f,
+	167.969f,
+	-148.438f,
+	17.0213f,
+	167.969f,
+	-144.531f,
+	16.2228f,
+	167.969f,
+	-140.625f,
+	15.1123f,
+	167.969f,
+	-136.719f,
+	16.9339f,
+	167.969f,
+	-132.813f,
+	18.4025f,
+	167.969f,
+	-128.906f,
+	19.9945f,
+	167.969f,
+	-125.0f,
+	20.4069f,
+	167.969f,
+	-121.094f,
+	21.447f,
+	167.969f,
+	-117.188f,
+	22.384f,
+	167.969f,
+	-113.281f,
+	22.4822f,
+	167.969f,
+	-109.375f,
+	22.9018f,
+	167.969f,
+	-105.469f,
+	23.4936f,
+	167.969f,
+	-101.563f,
+	23.0085f,
+	167.969f,
+	-97.6563f,
+	22.8398f,
+	167.969f,
+	-93.75f,
+	23.2939f,
+	167.969f,
+	-89.8438f,
+	23.3336f,
+	167.969f,
+	-85.9375f,
+	22.6883f,
+	167.969f,
+	-82.0313f,
+	21.8752f,
+	167.969f,
+	-78.125f,
+	18.7456f,
+	167.969f,
+	-74.2188f,
+	16.5685f,
+	167.969f,
+	-70.3125f,
+	17.179f,
+	167.969f,
+	-66.4063f,
+	18.1074f,
+	167.969f,
+	-62.5f,
+	18.9865f,
+	167.969f,
+	-58.5938f,
+	17.4851f,
+	167.969f,
+	-54.6875f,
+	17.2795f,
+	167.969f,
+	-50.7813f,
+	16.9142f,
+	167.969f,
+	-46.875f,
+	17.1532f,
+	167.969f,
+	-42.9688f,
+	17.796f,
+	167.969f,
+	-39.0625f,
+	17.6868f,
+	167.969f,
+	-35.1563f,
+	16.7998f,
+	167.969f,
+	-31.25f,
+	16.0556f,
+	167.969f,
+	-27.3438f,
+	14.7864f,
+	167.969f,
+	-23.4375f,
+	16.8386f,
+	167.969f,
+	-19.5313f,
+	17.9676f,
+	167.969f,
+	-15.625f,
+	18.4144f,
+	167.969f,
+	-11.7188f,
+	18.9248f,
+	167.969f,
+	-7.8125f,
+	18.4614f,
+	167.969f,
+	-3.90625f,
+	17.2197f,
+	167.969f,
+	0.0f,
+	16.7097f,
+	167.969f,
+	3.90625f,
+	17.1455f,
+	167.969f,
+	-250.0f,
+	9.27861f,
+	164.063f,
+	-246.094f,
+	8.67875f,
+	164.063f,
+	-242.188f,
+	8.39269f,
+	164.063f,
+	-238.281f,
+	7.54041f,
+	164.063f,
+	-234.375f,
+	6.37361f,
+	164.063f,
+	-230.469f,
+	5.0066f,
+	164.063f,
+	-226.563f,
+	3.63142f,
+	164.063f,
+	-222.656f,
+	2.77898f,
+	164.063f,
+	-218.75f,
+	2.89032f,
+	164.063f,
+	-214.844f,
+	4.01591f,
+	164.063f,
+	-210.938f,
+	4.52151f,
+	164.063f,
+	-207.031f,
+	4.85596f,
+	164.063f,
+	-203.125f,
+	6.21759f,
+	164.063f,
+	-199.219f,
+	8.25574f,
+	164.063f,
+	-195.313f,
+	10.3856f,
+	164.063f,
+	-191.406f,
+	11.6593f,
+	164.063f,
+	-187.5f,
+	12.5334f,
+	164.063f,
+	-183.594f,
+	14.1044f,
+	164.063f,
+	-179.688f,
+	14.8149f,
+	164.063f,
+	-175.781f,
+	14.9916f,
+	164.063f,
+	-171.875f,
+	14.6218f,
+	164.063f,
+	-167.969f,
+	14.5374f,
+	164.063f,
+	-164.063f,
+	13.7748f,
+	164.063f,
+	-160.156f,
+	15.1069f,
+	164.063f,
+	-156.25f,
+	16.5225f,
+	164.063f,
+	-152.344f,
+	17.8264f,
+	164.063f,
+	-148.438f,
+	18.5076f,
+	164.063f,
+	-144.531f,
+	17.6099f,
+	164.063f,
+	-140.625f,
+	16.4656f,
+	164.063f,
+	-136.719f,
+	16.7761f,
+	164.063f,
+	-132.813f,
+	19.1652f,
+	164.063f,
+	-128.906f,
+	20.565f,
+	164.063f,
+	-125.0f,
+	21.7781f,
+	164.063f,
+	-121.094f,
+	22.7613f,
+	164.063f,
+	-117.188f,
+	23.5743f,
+	164.063f,
+	-113.281f,
+	23.3567f,
+	164.063f,
+	-109.375f,
+	24.4075f,
+	164.063f,
+	-105.469f,
+	24.4502f,
+	164.063f,
+	-101.563f,
+	24.044f,
+	164.063f,
+	-97.6563f,
+	24.669f,
+	164.063f,
+	-93.75f,
+	24.7946f,
+	164.063f,
+	-89.8438f,
+	23.9722f,
+	164.063f,
+	-85.9375f,
+	23.2481f,
+	164.063f,
+	-82.0313f,
+	22.4202f,
+	164.063f,
+	-78.125f,
+	19.4816f,
+	164.063f,
+	-74.2188f,
+	18.3571f,
+	164.063f,
+	-70.3125f,
+	19.3195f,
+	164.063f,
+	-66.4063f,
+	19.6276f,
+	164.063f,
+	-62.5f,
+	19.775f,
+	164.063f,
+	-58.5938f,
+	18.4049f,
+	164.063f,
+	-54.6875f,
+	17.6998f,
+	164.063f,
+	-50.7813f,
+	16.7989f,
+	164.063f,
+	-46.875f,
+	16.5351f,
+	164.063f,
+	-42.9688f,
+	16.0836f,
+	164.063f,
+	-39.0625f,
+	16.4446f,
+	164.063f,
+	-35.1563f,
+	15.0322f,
+	164.063f,
+	-31.25f,
+	14.1679f,
+	164.063f,
+	-27.3438f,
+	16.0461f,
+	164.063f,
+	-23.4375f,
+	16.985f,
+	164.063f,
+	-19.5313f,
+	17.3286f,
+	164.063f,
+	-15.625f,
+	18.477f,
+	164.063f,
+	-11.7188f,
+	17.8736f,
+	164.063f,
+	-7.8125f,
+	17.8059f,
+	164.063f,
+	-3.90625f,
+	17.2079f,
+	164.063f,
+	0.0f,
+	16.7726f,
+	164.063f,
+	3.90625f,
+	16.4621f,
+	164.063f,
+	-250.0f,
+	8.56359f,
+	160.156f,
+	-246.094f,
+	8.04536f,
+	160.156f,
+	-242.188f,
+	7.71795f,
+	160.156f,
+	-238.281f,
+	7.20369f,
+	160.156f,
+	-234.375f,
+	5.51432f,
+	160.156f,
+	-230.469f,
+	5.00541f,
+	160.156f,
+	-226.563f,
+	4.36899f,
+	160.156f,
+	-222.656f,
+	3.03865f,
+	160.156f,
+	-218.75f,
+	2.92915f,
+	160.156f,
+	-214.844f,
+	2.63693f,
+	160.156f,
+	-210.938f,
+	2.69254f,
+	160.156f,
+	-207.031f,
+	3.5578f,
+	160.156f,
+	-203.125f,
+	5.61634f,
+	160.156f,
+	-199.219f,
+	7.61065f,
+	160.156f,
+	-195.313f,
+	9.64763f,
+	160.156f,
+	-191.406f,
+	11.2848f,
+	160.156f,
+	-187.5f,
+	12.7624f,
+	160.156f,
+	-183.594f,
+	13.2875f,
+	160.156f,
+	-179.688f,
+	15.2776f,
+	160.156f,
+	-175.781f,
+	15.3268f,
+	160.156f,
+	-171.875f,
+	15.211f,
+	160.156f,
+	-167.969f,
+	14.343f,
+	160.156f,
+	-164.063f,
+	14.8683f,
+	160.156f,
+	-160.156f,
+	16.1659f,
+	160.156f,
+	-156.25f,
+	16.4538f,
+	160.156f,
+	-152.344f,
+	18.5601f,
+	160.156f,
+	-148.438f,
+	19.2615f,
+	160.156f,
+	-144.531f,
+	18.8155f,
+	160.156f,
+	-140.625f,
+	17.4377f,
+	160.156f,
+	-136.719f,
+	17.6478f,
+	160.156f,
+	-132.813f,
+	19.7168f,
+	160.156f,
+	-128.906f,
+	21.4745f,
+	160.156f,
+	-125.0f,
+	23.0596f,
+	160.156f,
+	-121.094f,
+	24.6069f,
+	160.156f,
+	-117.188f,
+	25.9676f,
+	160.156f,
+	-113.281f,
+	26.2865f,
+	160.156f,
+	-109.375f,
+	27.1441f,
+	160.156f,
+	-105.469f,
+	27.0334f,
+	160.156f,
+	-101.563f,
+	26.0567f,
+	160.156f,
+	-97.6563f,
+	26.2584f,
+	160.156f,
+	-93.75f,
+	26.2751f,
+	160.156f,
+	-89.8438f,
+	25.6929f,
+	160.156f,
+	-85.9375f,
+	24.0275f,
+	160.156f,
+	-82.0313f,
+	22.2346f,
+	160.156f,
+	-78.125f,
+	20.4728f,
+	160.156f,
+	-74.2188f,
+	19.6229f,
+	160.156f,
+	-70.3125f,
+	20.0997f,
+	160.156f,
+	-66.4063f,
+	21.118f,
+	160.156f,
+	-62.5f,
+	20.4515f,
+	160.156f,
+	-58.5938f,
+	19.4599f,
+	160.156f,
+	-54.6875f,
+	18.2081f,
+	160.156f,
+	-50.7813f,
+	16.8263f,
+	160.156f,
+	-46.875f,
+	16.3719f,
+	160.156f,
+	-42.9688f,
+	15.1416f,
+	160.156f,
+	-39.0625f,
+	14.5969f,
+	160.156f,
+	-35.1563f,
+	14.7039f,
+	160.156f,
+	-31.25f,
+	14.8314f,
+	160.156f,
+	-27.3438f,
+	16.4129f,
+	160.156f,
+	-23.4375f,
+	16.144f,
+	160.156f,
+	-19.5313f,
+	17.5764f,
+	160.156f,
+	-15.625f,
+	17.9247f,
+	160.156f,
+	-11.7188f,
+	17.0582f,
+	160.156f,
+	-7.8125f,
+	17.1554f,
+	160.156f,
+	-3.90625f,
+	16.8369f,
+	160.156f,
+	0.0f,
+	16.4316f,
+	160.156f,
+	3.90625f,
+	16.628f,
+	160.156f,
+	-250.0f,
+	7.51933f,
+	156.25f,
+	-246.094f,
+	7.63381f,
+	156.25f,
+	-242.188f,
+	7.57378f,
+	156.25f,
+	-238.281f,
+	6.94606f,
+	156.25f,
+	-234.375f,
+	4.79198f,
+	156.25f,
+	-230.469f,
+	4.43262f,
+	156.25f,
+	-226.563f,
+	4.13314f,
+	156.25f,
+	-222.656f,
+	2.75517f,
+	156.25f,
+	-218.75f,
+	2.67631f,
+	156.25f,
+	-214.844f,
+	3.321f,
+	156.25f,
+	-210.938f,
+	3.33063f,
+	156.25f,
+	-207.031f,
+	3.60719f,
+	156.25f,
+	-203.125f,
+	4.44636f,
+	156.25f,
+	-199.219f,
+	6.02108f,
+	156.25f,
+	-195.313f,
+	8.25702f,
+	156.25f,
+	-191.406f,
+	10.5762f,
+	156.25f,
+	-187.5f,
+	11.4514f,
+	156.25f,
+	-183.594f,
+	12.7361f,
+	156.25f,
+	-179.688f,
+	15.4206f,
+	156.25f,
+	-175.781f,
+	16.1997f,
+	156.25f,
+	-171.875f,
+	14.8996f,
+	156.25f,
+	-167.969f,
+	14.1118f,
+	156.25f,
+	-164.063f,
+	16.0576f,
+	156.25f,
+	-160.156f,
+	17.6078f,
+	156.25f,
+	-156.25f,
+	17.7518f,
+	156.25f,
+	-152.344f,
+	18.4278f,
+	156.25f,
+	-148.438f,
+	19.5827f,
+	156.25f,
+	-144.531f,
+	19.2756f,
+	156.25f,
+	-140.625f,
+	18.2888f,
+	156.25f,
+	-136.719f,
+	18.7157f,
+	156.25f,
+	-132.813f,
+	20.4669f,
+	156.25f,
+	-128.906f,
+	22.5748f,
+	156.25f,
+	-125.0f,
+	24.648f,
+	156.25f,
+	-121.094f,
+	27.1223f,
+	156.25f,
+	-117.188f,
+	28.0709f,
+	156.25f,
+	-113.281f,
+	28.4982f,
+	156.25f,
+	-109.375f,
+	29.0927f,
+	156.25f,
+	-105.469f,
+	29.2755f,
+	156.25f,
+	-101.563f,
+	28.9208f,
+	156.25f,
+	-97.6563f,
+	28.3829f,
+	156.25f,
+	-93.75f,
+	26.8508f,
+	156.25f,
+	-89.8438f,
+	25.9621f,
+	156.25f,
+	-85.9375f,
+	24.2707f,
+	156.25f,
+	-82.0313f,
+	22.6235f,
+	156.25f,
+	-78.125f,
+	21.9368f,
+	156.25f,
+	-74.2188f,
+	21.0831f,
+	156.25f,
+	-70.3125f,
+	21.368f,
+	156.25f,
+	-66.4063f,
+	21.3333f,
+	156.25f,
+	-62.5f,
+	20.5296f,
+	156.25f,
+	-58.5938f,
+	19.98f,
+	156.25f,
+	-54.6875f,
+	18.5818f,
+	156.25f,
+	-50.7813f,
+	17.2025f,
+	156.25f,
+	-46.875f,
+	16.1859f,
+	156.25f,
+	-42.9688f,
+	14.4559f,
+	156.25f,
+	-39.0625f,
+	13.7597f,
+	156.25f,
+	-35.1563f,
+	14.6354f,
+	156.25f,
+	-31.25f,
+	15.6213f,
+	156.25f,
+	-27.3438f,
+	15.683f,
+	156.25f,
+	-23.4375f,
+	16.5331f,
+	156.25f,
+	-19.5313f,
+	16.8272f,
+	156.25f,
+	-15.625f,
+	16.551f,
+	156.25f,
+	-11.7188f,
+	16.34f,
+	156.25f,
+	-7.8125f,
+	16.4067f,
+	156.25f,
+	-3.90625f,
+	15.8725f,
+	156.25f,
+	0.0f,
+	16.3451f,
+	156.25f,
+	3.90625f,
+	16.9346f,
+	156.25f,
+	-250.0f,
+	6.48899f,
+	152.344f,
+	-246.094f,
+	6.4047f,
+	152.344f,
+	-242.188f,
+	6.57203f,
+	152.344f,
+	-238.281f,
+	5.4628f,
+	152.344f,
+	-234.375f,
+	4.20753f,
+	152.344f,
+	-230.469f,
+	2.81156f,
+	152.344f,
+	-226.563f,
+	1.88132f,
+	152.344f,
+	-222.656f,
+	1.57153f,
+	152.344f,
+	-218.75f,
+	2.48106f,
+	152.344f,
+	-214.844f,
+	2.88884f,
+	152.344f,
+	-210.938f,
+	2.63578f,
+	152.344f,
+	-207.031f,
+	2.9717f,
+	152.344f,
+	-203.125f,
+	3.6084f,
+	152.344f,
+	-199.219f,
+	3.99032f,
+	152.344f,
+	-195.313f,
+	7.36858f,
+	152.344f,
+	-191.406f,
+	9.54951f,
+	152.344f,
+	-187.5f,
+	10.6254f,
+	152.344f,
+	-183.594f,
+	12.3317f,
+	152.344f,
+	-179.688f,
+	14.015f,
+	152.344f,
+	-175.781f,
+	14.8857f,
+	152.344f,
+	-171.875f,
+	14.9944f,
+	152.344f,
+	-167.969f,
+	14.7547f,
+	152.344f,
+	-164.063f,
+	16.7748f,
+	152.344f,
+	-160.156f,
+	18.5461f,
+	152.344f,
+	-156.25f,
+	19.5932f,
+	152.344f,
+	-152.344f,
+	19.1033f,
+	152.344f,
+	-148.438f,
+	19.012f,
+	152.344f,
+	-144.531f,
+	19.4428f,
+	152.344f,
+	-140.625f,
+	19.3453f,
+	152.344f,
+	-136.719f,
+	20.6611f,
+	152.344f,
+	-132.813f,
+	22.2914f,
+	152.344f,
+	-128.906f,
+	24.3802f,
+	152.344f,
+	-125.0f,
+	26.4048f,
+	152.344f,
+	-121.094f,
+	28.3525f,
+	152.344f,
+	-117.188f,
+	30.0561f,
+	152.344f,
+	-113.281f,
+	30.1155f,
+	152.344f,
+	-109.375f,
+	30.9005f,
+	152.344f,
+	-105.469f,
+	30.8767f,
+	152.344f,
+	-101.563f,
+	30.9056f,
+	152.344f,
+	-97.6563f,
+	30.3635f,
+	152.344f,
+	-93.75f,
+	28.3996f,
+	152.344f,
+	-89.8438f,
+	25.8081f,
+	152.344f,
+	-85.9375f,
+	24.3731f,
+	152.344f,
+	-82.0313f,
+	22.7783f,
+	152.344f,
+	-78.125f,
+	22.5973f,
+	152.344f,
+	-74.2188f,
+	21.8359f,
+	152.344f,
+	-70.3125f,
+	21.4903f,
+	152.344f,
+	-66.4063f,
+	21.0461f,
+	152.344f,
+	-62.5f,
+	19.9934f,
+	152.344f,
+	-58.5938f,
+	19.4729f,
+	152.344f,
+	-54.6875f,
+	18.1265f,
+	152.344f,
+	-50.7813f,
+	16.4684f,
+	152.344f,
+	-46.875f,
+	15.0104f,
+	152.344f,
+	-42.9688f,
+	13.8642f,
+	152.344f,
+	-39.0625f,
+	14.8875f,
+	152.344f,
+	-35.1563f,
+	15.117f,
+	152.344f,
+	-31.25f,
+	15.0707f,
+	152.344f,
+	-27.3438f,
+	15.3829f,
+	152.344f,
+	-23.4375f,
+	15.5218f,
+	152.344f,
+	-19.5313f,
+	15.215f,
+	152.344f,
+	-15.625f,
+	15.2099f,
+	152.344f,
+	-11.7188f,
+	15.5383f,
+	152.344f,
+	-7.8125f,
+	15.6462f,
+	152.344f,
+	-3.90625f,
+	15.3096f,
+	152.344f,
+	0.0f,
+	16.3854f,
+	152.344f,
+	3.90625f,
+	17.6952f,
+	152.344f,
+	-250.0f,
+	5.17712f,
+	148.438f,
+	-246.094f,
+	4.67214f,
+	148.438f,
+	-242.188f,
+	4.31659f,
+	148.438f,
+	-238.281f,
+	3.2191f,
+	148.438f,
+	-234.375f,
+	2.13365f,
+	148.438f,
+	-230.469f,
+	1.19555f,
+	148.438f,
+	-226.563f,
+	0.110638f,
+	148.438f,
+	-222.656f,
+	0.945025f,
+	148.438f,
+	-218.75f,
+	1.43378f,
+	148.438f,
+	-214.844f,
+	2.06915f,
+	148.438f,
+	-210.938f,
+	2.27715f,
+	148.438f,
+	-207.031f,
+	2.23051f,
+	148.438f,
+	-203.125f,
+	2.64045f,
+	148.438f,
+	-199.219f,
+	2.99575f,
+	148.438f,
+	-195.313f,
+	5.40402f,
+	148.438f,
+	-191.406f,
+	8.03643f,
+	148.438f,
+	-187.5f,
+	10.0212f,
+	148.438f,
+	-183.594f,
+	12.2205f,
+	148.438f,
+	-179.688f,
+	14.1884f,
+	148.438f,
+	-175.781f,
+	14.5505f,
+	148.438f,
+	-171.875f,
+	15.188f,
+	148.438f,
+	-167.969f,
+	15.2222f,
+	148.438f,
+	-164.063f,
+	17.4791f,
+	148.438f,
+	-160.156f,
+	19.6158f,
+	148.438f,
+	-156.25f,
+	20.2107f,
+	148.438f,
+	-152.344f,
+	20.552f,
+	148.438f,
+	-148.438f,
+	20.2463f,
+	148.438f,
+	-144.531f,
+	20.4526f,
+	148.438f,
+	-140.625f,
+	20.9426f,
+	148.438f,
+	-136.719f,
+	22.6331f,
+	148.438f,
+	-132.813f,
+	25.1345f,
+	148.438f,
+	-128.906f,
+	27.0299f,
+	148.438f,
+	-125.0f,
+	29.381f,
+	148.438f,
+	-121.094f,
+	31.0494f,
+	148.438f,
+	-117.188f,
+	31.7246f,
+	148.438f,
+	-113.281f,
+	31.9331f,
+	148.438f,
+	-109.375f,
+	31.9517f,
+	148.438f,
+	-105.469f,
+	32.217f,
+	148.438f,
+	-101.563f,
+	31.9001f,
+	148.438f,
+	-97.6563f,
+	30.471f,
+	148.438f,
+	-93.75f,
+	28.6143f,
+	148.438f,
+	-89.8438f,
+	26.5696f,
+	148.438f,
+	-85.9375f,
+	24.7785f,
+	148.438f,
+	-82.0313f,
+	23.3248f,
+	148.438f,
+	-78.125f,
+	22.2737f,
+	148.438f,
+	-74.2188f,
+	22.0395f,
+	148.438f,
+	-70.3125f,
+	21.4879f,
+	148.438f,
+	-66.4063f,
+	20.5539f,
+	148.438f,
+	-62.5f,
+	19.3981f,
+	148.438f,
+	-58.5938f,
+	18.0902f,
+	148.438f,
+	-54.6875f,
+	16.6154f,
+	148.438f,
+	-50.7813f,
+	15.8338f,
+	148.438f,
+	-46.875f,
+	14.0809f,
+	148.438f,
+	-42.9688f,
+	12.8188f,
+	148.438f,
+	-39.0625f,
+	14.0819f,
+	148.438f,
+	-35.1563f,
+	14.3673f,
+	148.438f,
+	-31.25f,
+	14.2973f,
+	148.438f,
+	-27.3438f,
+	15.1616f,
+	148.438f,
+	-23.4375f,
+	13.9458f,
+	148.438f,
+	-19.5313f,
+	14.9412f,
+	148.438f,
+	-15.625f,
+	15.4488f,
+	148.438f,
+	-11.7188f,
+	15.3397f,
+	148.438f,
+	-7.8125f,
+	15.0356f,
+	148.438f,
+	-3.90625f,
+	15.6431f,
+	148.438f,
+	0.0f,
+	16.6218f,
+	148.438f,
+	3.90625f,
+	18.4109f,
+	148.438f,
+	-250.0f,
+	5.38918f,
+	144.531f,
+	-246.094f,
+	4.29322f,
+	144.531f,
+	-242.188f,
+	2.99843f,
+	144.531f,
+	-238.281f,
+	2.80561f,
+	144.531f,
+	-234.375f,
+	1.65282f,
+	144.531f,
+	-230.469f,
+	-0.268879f,
+	144.531f,
+	-226.563f,
+	-0.474469f,
+	144.531f,
+	-222.656f,
+	-0.0607398f,
+	144.531f,
+	-218.75f,
+	0.859532f,
+	144.531f,
+	-214.844f,
+	1.28455f,
+	144.531f,
+	-210.938f,
+	1.69755f,
+	144.531f,
+	-207.031f,
+	2.1277f,
+	144.531f,
+	-203.125f,
+	2.92014f,
+	144.531f,
+	-199.219f,
+	3.85473f,
+	144.531f,
+	-195.313f,
+	4.38999f,
+	144.531f,
+	-191.406f,
+	6.72101f,
+	144.531f,
+	-187.5f,
+	9.24433f,
+	144.531f,
+	-183.594f,
+	11.6027f,
+	144.531f,
+	-179.688f,
+	13.2042f,
+	144.531f,
+	-175.781f,
+	14.6647f,
+	144.531f,
+	-171.875f,
+	14.7252f,
+	144.531f,
+	-167.969f,
+	16.1425f,
+	144.531f,
+	-164.063f,
+	18.1823f,
+	144.531f,
+	-160.156f,
+	19.9802f,
+	144.531f,
+	-156.25f,
+	22.2009f,
+	144.531f,
+	-152.344f,
+	21.9313f,
+	144.531f,
+	-148.438f,
+	22.3421f,
+	144.531f,
+	-144.531f,
+	21.6393f,
+	144.531f,
+	-140.625f,
+	23.0621f,
+	144.531f,
+	-136.719f,
+	24.695f,
+	144.531f,
+	-132.813f,
+	26.6159f,
+	144.531f,
+	-128.906f,
+	29.9912f,
+	144.531f,
+	-125.0f,
+	31.6471f,
+	144.531f,
+	-121.094f,
+	32.4919f,
+	144.531f,
+	-117.188f,
+	32.9775f,
+	144.531f,
+	-113.281f,
+	33.1587f,
+	144.531f,
+	-109.375f,
+	33.0247f,
+	144.531f,
+	-105.469f,
+	32.4654f,
+	144.531f,
+	-101.563f,
+	31.5009f,
+	144.531f,
+	-97.6563f,
+	30.2211f,
+	144.531f,
+	-93.75f,
+	28.3655f,
+	144.531f,
+	-89.8438f,
+	26.6696f,
+	144.531f,
+	-85.9375f,
+	25.6101f,
+	144.531f,
+	-82.0313f,
+	23.5563f,
+	144.531f,
+	-78.125f,
+	21.8779f,
+	144.531f,
+	-74.2188f,
+	21.4789f,
+	144.531f,
+	-70.3125f,
+	21.2134f,
+	144.531f,
+	-66.4063f,
+	20.0494f,
+	144.531f,
+	-62.5f,
+	19.4674f,
+	144.531f,
+	-58.5938f,
+	17.3288f,
+	144.531f,
+	-54.6875f,
+	16.7337f,
+	144.531f,
+	-50.7813f,
+	15.9259f,
+	144.531f,
+	-46.875f,
+	14.3007f,
+	144.531f,
+	-42.9688f,
+	13.3631f,
+	144.531f,
+	-39.0625f,
+	12.7904f,
+	144.531f,
+	-35.1563f,
+	13.6627f,
+	144.531f,
+	-31.25f,
+	13.6872f,
+	144.531f,
+	-27.3438f,
+	14.0818f,
+	144.531f,
+	-23.4375f,
+	13.953f,
+	144.531f,
+	-19.5313f,
+	14.0386f,
+	144.531f,
+	-15.625f,
+	14.1249f,
+	144.531f,
+	-11.7188f,
+	14.1069f,
+	144.531f,
+	-7.8125f,
+	14.4968f,
+	144.531f,
+	-3.90625f,
+	15.4283f,
+	144.531f,
+	0.0f,
+	16.5593f,
+	144.531f,
+	3.90625f,
+	17.8758f,
+	144.531f,
+	-250.0f,
+	5.32443f,
+	140.625f,
+	-246.094f,
+	4.53202f,
+	140.625f,
+	-242.188f,
+	2.85351f,
+	140.625f,
+	-238.281f,
+	1.48443f,
+	140.625f,
+	-234.375f,
+	0.193579f,
+	140.625f,
+	-230.469f,
+	-0.0240196f,
+	140.625f,
+	-226.563f,
+	-0.195521f,
+	140.625f,
+	-222.656f,
+	-0.525286f,
+	140.625f,
+	-218.75f,
+	0.255241f,
+	140.625f,
+	-214.844f,
+	0.505993f,
+	140.625f,
+	-210.938f,
+	1.2501f,
+	140.625f,
+	-207.031f,
+	2.77282f,
+	140.625f,
+	-203.125f,
+	3.23678f,
+	140.625f,
+	-199.219f,
+	3.81665f,
+	140.625f,
+	-195.313f,
+	4.45749f,
+	140.625f,
+	-191.406f,
+	6.57237f,
+	140.625f,
+	-187.5f,
+	8.78049f,
+	140.625f,
+	-183.594f,
+	10.653f,
+	140.625f,
+	-179.688f,
+	12.1762f,
+	140.625f,
+	-175.781f,
+	13.836f,
+	140.625f,
+	-171.875f,
+	14.4421f,
+	140.625f,
+	-167.969f,
+	16.2272f,
+	140.625f,
+	-164.063f,
+	17.8194f,
+	140.625f,
+	-160.156f,
+	20.3268f,
+	140.625f,
+	-156.25f,
+	21.6942f,
+	140.625f,
+	-152.344f,
+	21.8506f,
+	140.625f,
+	-148.438f,
+	22.857f,
+	140.625f,
+	-144.531f,
+	23.0189f,
+	140.625f,
+	-140.625f,
+	24.7041f,
+	140.625f,
+	-136.719f,
+	26.468f,
+	140.625f,
+	-132.813f,
+	28.6459f,
+	140.625f,
+	-128.906f,
+	30.9708f,
+	140.625f,
+	-125.0f,
+	33.2917f,
+	140.625f,
+	-121.094f,
+	34.9879f,
+	140.625f,
+	-117.188f,
+	34.5936f,
+	140.625f,
+	-113.281f,
+	34.2431f,
+	140.625f,
+	-109.375f,
+	33.7219f,
+	140.625f,
+	-105.469f,
+	32.9679f,
+	140.625f,
+	-101.563f,
+	31.3296f,
+	140.625f,
+	-97.6563f,
+	30.0001f,
+	140.625f,
+	-93.75f,
+	28.0182f,
+	140.625f,
+	-89.8438f,
+	26.2542f,
+	140.625f,
+	-85.9375f,
+	24.9632f,
+	140.625f,
+	-82.0313f,
+	23.5598f,
+	140.625f,
+	-78.125f,
+	21.3613f,
+	140.625f,
+	-74.2188f,
+	20.8425f,
+	140.625f,
+	-70.3125f,
+	20.6976f,
+	140.625f,
+	-66.4063f,
+	19.4459f,
+	140.625f,
+	-62.5f,
+	17.9969f,
+	140.625f,
+	-58.5938f,
+	17.2754f,
+	140.625f,
+	-54.6875f,
+	16.763f,
+	140.625f,
+	-50.7813f,
+	15.8668f,
+	140.625f,
+	-46.875f,
+	15.2278f,
+	140.625f,
+	-42.9688f,
+	14.0988f,
+	140.625f,
+	-39.0625f,
+	13.4132f,
+	140.625f,
+	-35.1563f,
+	12.9004f,
+	140.625f,
+	-31.25f,
+	12.6267f,
+	140.625f,
+	-27.3438f,
+	12.7032f,
+	140.625f,
+	-23.4375f,
+	12.0508f,
+	140.625f,
+	-19.5313f,
+	12.8332f,
+	140.625f,
+	-15.625f,
+	12.2269f,
+	140.625f,
+	-11.7188f,
+	12.2256f,
+	140.625f,
+	-7.8125f,
+	13.9086f,
+	140.625f,
+	-3.90625f,
+	15.559f,
+	140.625f,
+	0.0f,
+	16.8086f,
+	140.625f,
+	3.90625f,
+	18.5798f,
+	140.625f,
+	-250.0f,
+	4.69677f,
+	136.719f,
+	-246.094f,
+	3.45683f,
+	136.719f,
+	-242.188f,
+	1.81964f,
+	136.719f,
+	-238.281f,
+	1.13059f,
+	136.719f,
+	-234.375f,
+	0.535221f,
+	136.719f,
+	-230.469f,
+	0.868904f,
+	136.719f,
+	-226.563f,
+	0.574251f,
+	136.719f,
+	-222.656f,
+	0.279368f,
+	136.719f,
+	-218.75f,
+	-1.1876f,
+	136.719f,
+	-214.844f,
+	-0.688708f,
+	136.719f,
+	-210.938f,
+	0.470686f,
+	136.719f,
+	-207.031f,
+	2.00488f,
+	136.719f,
+	-203.125f,
+	3.42644f,
+	136.719f,
+	-199.219f,
+	4.20503f,
+	136.719f,
+	-195.313f,
+	5.23588f,
+	136.719f,
+	-191.406f,
+	6.02424f,
+	136.719f,
+	-187.5f,
+	7.96541f,
+	136.719f,
+	-183.594f,
+	10.5299f,
+	136.719f,
+	-179.688f,
+	12.0941f,
+	136.719f,
+	-175.781f,
+	13.5058f,
+	136.719f,
+	-171.875f,
+	14.8816f,
+	136.719f,
+	-167.969f,
+	16.551f,
+	136.719f,
+	-164.063f,
+	17.712f,
+	136.719f,
+	-160.156f,
+	19.6536f,
+	136.719f,
+	-156.25f,
+	21.4322f,
+	136.719f,
+	-152.344f,
+	22.672f,
+	136.719f,
+	-148.438f,
+	23.3463f,
+	136.719f,
+	-144.531f,
+	24.5334f,
+	136.719f,
+	-140.625f,
+	26.061f,
+	136.719f,
+	-136.719f,
+	27.7423f,
+	136.719f,
+	-132.813f,
+	30.1692f,
+	136.719f,
+	-128.906f,
+	33.3739f,
+	136.719f,
+	-125.0f,
+	34.9742f,
+	136.719f,
+	-121.094f,
+	35.9387f,
+	136.719f,
+	-117.188f,
+	36.0925f,
+	136.719f,
+	-113.281f,
+	35.6549f,
+	136.719f,
+	-109.375f,
+	34.5646f,
+	136.719f,
+	-105.469f,
+	34.6062f,
+	136.719f,
+	-101.563f,
+	32.8375f,
+	136.719f,
+	-97.6563f,
+	30.2678f,
+	136.719f,
+	-93.75f,
+	27.2213f,
+	136.719f,
+	-89.8438f,
+	26.1126f,
+	136.719f,
+	-85.9375f,
+	24.9965f,
+	136.719f,
+	-82.0313f,
+	22.5841f,
+	136.719f,
+	-78.125f,
+	21.7213f,
+	136.719f,
+	-74.2188f,
+	21.534f,
+	136.719f,
+	-70.3125f,
+	20.5652f,
+	136.719f,
+	-66.4063f,
+	19.032f,
+	136.719f,
+	-62.5f,
+	17.4252f,
+	136.719f,
+	-58.5938f,
+	16.7783f,
+	136.719f,
+	-54.6875f,
+	15.9619f,
+	136.719f,
+	-50.7813f,
+	14.8707f,
+	136.719f,
+	-46.875f,
+	14.3143f,
+	136.719f,
+	-42.9688f,
+	13.8793f,
+	136.719f,
+	-39.0625f,
+	12.6352f,
+	136.719f,
+	-35.1563f,
+	12.0433f,
+	136.719f,
+	-31.25f,
+	11.8551f,
+	136.719f,
+	-27.3438f,
+	12.0193f,
+	136.719f,
+	-23.4375f,
+	11.2795f,
+	136.719f,
+	-19.5313f,
+	11.6002f,
+	136.719f,
+	-15.625f,
+	10.9143f,
+	136.719f,
+	-11.7188f,
+	12.1473f,
+	136.719f,
+	-7.8125f,
+	14.3093f,
+	136.719f,
+	-3.90625f,
+	16.245f,
+	136.719f,
+	0.0f,
+	17.3141f,
+	136.719f,
+	3.90625f,
+	19.7224f,
+	136.719f,
+	-250.0f,
+	3.94613f,
+	132.813f,
+	-246.094f,
+	2.33247f,
+	132.813f,
+	-242.188f,
+	1.96569f,
+	132.813f,
+	-238.281f,
+	1.1741f,
+	132.813f,
+	-234.375f,
+	0.606142f,
+	132.813f,
+	-230.469f,
+	0.00901447f,
+	132.813f,
+	-226.563f,
+	0.143339f,
+	132.813f,
+	-222.656f,
+	-0.356031f,
+	132.813f,
+	-218.75f,
+	-1.55439f,
+	132.813f,
+	-214.844f,
+	-1.22801f,
+	132.813f,
+	-210.938f,
+	-0.390443f,
+	132.813f,
+	-207.031f,
+	1.15349f,
+	132.813f,
+	-203.125f,
+	2.6275f,
+	132.813f,
+	-199.219f,
+	3.55895f,
+	132.813f,
+	-195.313f,
+	4.99281f,
+	132.813f,
+	-191.406f,
+	4.99673f,
+	132.813f,
+	-187.5f,
+	6.96468f,
+	132.813f,
+	-183.594f,
+	10.0691f,
+	132.813f,
+	-179.688f,
+	12.3783f,
+	132.813f,
+	-175.781f,
+	13.2459f,
+	132.813f,
+	-171.875f,
+	14.3637f,
+	132.813f,
+	-167.969f,
+	16.3222f,
+	132.813f,
+	-164.063f,
+	17.6984f,
+	132.813f,
+	-160.156f,
+	19.3295f,
+	132.813f,
+	-156.25f,
+	20.9768f,
+	132.813f,
+	-152.344f,
+	23.1452f,
+	132.813f,
+	-148.438f,
+	23.885f,
+	132.813f,
+	-144.531f,
+	24.7169f,
+	132.813f,
+	-140.625f,
+	27.1655f,
+	132.813f,
+	-136.719f,
+	29.0232f,
+	132.813f,
+	-132.813f,
+	30.2573f,
+	132.813f,
+	-128.906f,
+	33.5563f,
+	132.813f,
+	-125.0f,
+	35.1858f,
+	132.813f,
+	-121.094f,
+	36.4332f,
+	132.813f,
+	-117.188f,
+	36.6359f,
+	132.813f,
+	-113.281f,
+	36.0253f,
+	132.813f,
+	-109.375f,
+	34.7127f,
+	132.813f,
+	-105.469f,
+	34.6833f,
+	132.813f,
+	-101.563f,
+	33.7208f,
+	132.813f,
+	-97.6563f,
+	30.9809f,
+	132.813f,
+	-93.75f,
+	27.9091f,
+	132.813f,
+	-89.8438f,
+	25.709f,
+	132.813f,
+	-85.9375f,
+	24.452f,
+	132.813f,
+	-82.0313f,
+	22.4897f,
+	132.813f,
+	-78.125f,
+	22.0485f,
+	132.813f,
+	-74.2188f,
+	22.1517f,
+	132.813f,
+	-70.3125f,
+	20.4874f,
+	132.813f,
+	-66.4063f,
+	19.0482f,
+	132.813f,
+	-62.5f,
+	17.1019f,
+	132.813f,
+	-58.5938f,
+	16.7815f,
+	132.813f,
+	-54.6875f,
+	15.1253f,
+	132.813f,
+	-50.7813f,
+	14.5074f,
+	132.813f,
+	-46.875f,
+	12.7631f,
+	132.813f,
+	-42.9688f,
+	12.6595f,
+	132.813f,
+	-39.0625f,
+	11.9406f,
+	132.813f,
+	-35.1563f,
+	11.7459f,
+	132.813f,
+	-31.25f,
+	10.8406f,
+	132.813f,
+	-27.3438f,
+	11.0393f,
+	132.813f,
+	-23.4375f,
+	10.4798f,
+	132.813f,
+	-19.5313f,
+	10.8165f,
+	132.813f,
+	-15.625f,
+	12.4368f,
+	132.813f,
+	-11.7188f,
+	13.2405f,
+	132.813f,
+	-7.8125f,
+	14.9282f,
+	132.813f,
+	-3.90625f,
+	16.4449f,
+	132.813f,
+	0.0f,
+	17.8238f,
+	132.813f,
+	3.90625f,
+	19.9574f,
+	132.813f,
+	-250.0f,
+	2.5744f,
+	128.906f,
+	-246.094f,
+	2.12474f,
+	128.906f,
+	-242.188f,
+	0.674823f,
+	128.906f,
+	-238.281f,
+	-0.305135f,
+	128.906f,
+	-234.375f,
+	-0.948647f,
+	128.906f,
+	-230.469f,
+	-0.982836f,
+	128.906f,
+	-226.563f,
+	-1.17369f,
+	128.906f,
+	-222.656f,
+	-1.48697f,
+	128.906f,
+	-218.75f,
+	-2.23137f,
+	128.906f,
+	-214.844f,
+	-2.13825f,
+	128.906f,
+	-210.938f,
+	-1.06826f,
+	128.906f,
+	-207.031f,
+	0.0666403f,
+	128.906f,
+	-203.125f,
+	1.15717f,
+	128.906f,
+	-199.219f,
+	3.14762f,
+	128.906f,
+	-195.313f,
+	4.08858f,
+	128.906f,
+	-191.406f,
+	5.07728f,
+	128.906f,
+	-187.5f,
+	8.06699f,
+	128.906f,
+	-183.594f,
+	10.7473f,
+	128.906f,
+	-179.688f,
+	12.0801f,
+	128.906f,
+	-175.781f,
+	13.1617f,
+	128.906f,
+	-171.875f,
+	14.5283f,
+	128.906f,
+	-167.969f,
+	15.8148f,
+	128.906f,
+	-164.063f,
+	16.9067f,
+	128.906f,
+	-160.156f,
+	18.6293f,
+	128.906f,
+	-156.25f,
+	20.8869f,
+	128.906f,
+	-152.344f,
+	22.6168f,
+	128.906f,
+	-148.438f,
+	23.9359f,
+	128.906f,
+	-144.531f,
+	26.521f,
+	128.906f,
+	-140.625f,
+	27.4381f,
+	128.906f,
+	-136.719f,
+	29.5698f,
+	128.906f,
+	-132.813f,
+	30.681f,
+	128.906f,
+	-128.906f,
+	33.28f,
+	128.906f,
+	-125.0f,
+	35.3433f,
+	128.906f,
+	-121.094f,
+	36.3509f,
+	128.906f,
+	-117.188f,
+	36.2098f,
+	128.906f,
+	-113.281f,
+	35.157f,
+	128.906f,
+	-109.375f,
+	35.3884f,
+	128.906f,
+	-105.469f,
+	35.7158f,
+	128.906f,
+	-101.563f,
+	34.3449f,
+	128.906f,
+	-97.6563f,
+	32.5198f,
+	128.906f,
+	-93.75f,
+	29.0611f,
+	128.906f,
+	-89.8438f,
+	25.9945f,
+	128.906f,
+	-85.9375f,
+	24.2624f,
+	128.906f,
+	-82.0313f,
+	23.0248f,
+	128.906f,
+	-78.125f,
+	21.6012f,
+	128.906f,
+	-74.2188f,
+	21.0399f,
+	128.906f,
+	-70.3125f,
+	20.1719f,
+	128.906f,
+	-66.4063f,
+	18.6862f,
+	128.906f,
+	-62.5f,
+	17.3287f,
+	128.906f,
+	-58.5938f,
+	16.0916f,
+	128.906f,
+	-54.6875f,
+	14.1153f,
+	128.906f,
+	-50.7813f,
+	12.6292f,
+	128.906f,
+	-46.875f,
+	12.0431f,
+	128.906f,
+	-42.9688f,
+	11.4785f,
+	128.906f,
+	-39.0625f,
+	11.911f,
+	128.906f,
+	-35.1563f,
+	11.6609f,
+	128.906f,
+	-31.25f,
+	10.4332f,
+	128.906f,
+	-27.3438f,
+	9.68026f,
+	128.906f,
+	-23.4375f,
+	9.84506f,
+	128.906f,
+	-19.5313f,
+	11.6097f,
+	128.906f,
+	-15.625f,
+	13.2944f,
+	128.906f,
+	-11.7188f,
+	14.0518f,
+	128.906f,
+	-7.8125f,
+	15.2998f,
+	128.906f,
+	-3.90625f,
+	16.8731f,
+	128.906f,
+	0.0f,
+	18.0594f,
+	128.906f,
+	3.90625f,
+	20.0876f,
+	128.906f,
+	-250.0f,
+	2.47782f,
+	125.0f,
+	-246.094f,
+	1.27263f,
+	125.0f,
+	-242.188f,
+	-0.535855f,
+	125.0f,
+	-238.281f,
+	-1.33089f,
+	125.0f,
+	-234.375f,
+	-1.63273f,
+	125.0f,
+	-230.469f,
+	-2.30607f,
+	125.0f,
+	-226.563f,
+	-2.13647f,
+	125.0f,
+	-222.656f,
+	-2.95807f,
+	125.0f,
+	-218.75f,
+	-2.92133f,
+	125.0f,
+	-214.844f,
+	-3.33811f,
+	125.0f,
+	-210.938f,
+	-2.29807f,
+	125.0f,
+	-207.031f,
+	-0.860766f,
+	125.0f,
+	-203.125f,
+	0.507027f,
+	125.0f,
+	-199.219f,
+	1.54044f,
+	125.0f,
+	-195.313f,
+	3.32139f,
+	125.0f,
+	-191.406f,
+	5.76593f,
+	125.0f,
+	-187.5f,
+	8.17548f,
+	125.0f,
+	-183.594f,
+	10.5223f,
+	125.0f,
+	-179.688f,
+	11.4741f,
+	125.0f,
+	-175.781f,
+	12.3545f,
+	125.0f,
+	-171.875f,
+	13.5542f,
+	125.0f,
+	-167.969f,
+	14.4358f,
+	125.0f,
+	-164.063f,
+	16.6197f,
+	125.0f,
+	-160.156f,
+	18.7561f,
+	125.0f,
+	-156.25f,
+	21.2618f,
+	125.0f,
+	-152.344f,
+	22.9541f,
+	125.0f,
+	-148.438f,
+	24.7574f,
+	125.0f,
+	-144.531f,
+	26.8375f,
+	125.0f,
+	-140.625f,
+	28.3307f,
+	125.0f,
+	-136.719f,
+	29.2598f,
+	125.0f,
+	-132.813f,
+	31.2334f,
+	125.0f,
+	-128.906f,
+	32.9236f,
+	125.0f,
+	-125.0f,
+	34.4853f,
+	125.0f,
+	-121.094f,
+	35.1589f,
+	125.0f,
+	-117.188f,
+	34.4655f,
+	125.0f,
+	-113.281f,
+	35.7692f,
+	125.0f,
+	-109.375f,
+	35.9985f,
+	125.0f,
+	-105.469f,
+	35.7974f,
+	125.0f,
+	-101.563f,
+	34.6099f,
+	125.0f,
+	-97.6563f,
+	32.4066f,
+	125.0f,
+	-93.75f,
+	28.8398f,
+	125.0f,
+	-89.8438f,
+	26.014f,
+	125.0f,
+	-85.9375f,
+	25.0319f,
+	125.0f,
+	-82.0313f,
+	23.7685f,
+	125.0f,
+	-78.125f,
+	22.4099f,
+	125.0f,
+	-74.2188f,
+	20.9166f,
+	125.0f,
+	-70.3125f,
+	19.1502f,
+	125.0f,
+	-66.4063f,
+	17.8355f,
+	125.0f,
+	-62.5f,
+	16.5146f,
+	125.0f,
+	-58.5938f,
+	14.9189f,
+	125.0f,
+	-54.6875f,
+	13.2423f,
+	125.0f,
+	-50.7813f,
+	12.2568f,
+	125.0f,
+	-46.875f,
+	11.4853f,
+	125.0f,
+	-42.9688f,
+	10.7795f,
+	125.0f,
+	-39.0625f,
+	10.3251f,
+	125.0f,
+	-35.1563f,
+	10.4077f,
+	125.0f,
+	-31.25f,
+	9.96202f,
+	125.0f,
+	-27.3438f,
+	9.77658f,
+	125.0f,
+	-23.4375f,
+	10.6703f,
+	125.0f,
+	-19.5313f,
+	12.2058f,
+	125.0f,
+	-15.625f,
+	13.8385f,
+	125.0f,
+	-11.7188f,
+	15.1556f,
+	125.0f,
+	-7.8125f,
+	15.7626f,
+	125.0f,
+	-3.90625f,
+	16.911f,
+	125.0f,
+	0.0f,
+	18.0803f,
+	125.0f,
+	3.90625f,
+	18.9654f,
+	125.0f,
+	-250.0f,
+	1.97449f,
+	121.094f,
+	-246.094f,
+	1.28169f,
+	121.094f,
+	-242.188f,
+	0.0699786f,
+	121.094f,
+	-238.281f,
+	-1.31551f,
+	121.094f,
+	-234.375f,
+	-2.33115f,
+	121.094f,
+	-230.469f,
+	-3.19445f,
+	121.094f,
+	-226.563f,
+	-3.91693f,
+	121.094f,
+	-222.656f,
+	-4.0298f,
+	121.094f,
+	-218.75f,
+	-4.334f,
+	121.094f,
+	-214.844f,
+	-3.5405f,
+	121.094f,
+	-210.938f,
+	-2.70043f,
+	121.094f,
+	-207.031f,
+	-2.86125f,
+	121.094f,
+	-203.125f,
+	-1.24727f,
+	121.094f,
+	-199.219f,
+	0.20797f,
+	121.094f,
+	-195.313f,
+	2.52573f,
+	121.094f,
+	-191.406f,
+	4.8544f,
+	121.094f,
+	-187.5f,
+	7.37504f,
+	121.094f,
+	-183.594f,
+	9.40828f,
+	121.094f,
+	-179.688f,
+	11.0747f,
+	121.094f,
+	-175.781f,
+	11.9892f,
+	121.094f,
+	-171.875f,
+	12.3358f,
+	121.094f,
+	-167.969f,
+	13.2084f,
+	121.094f,
+	-164.063f,
+	15.8626f,
+	121.094f,
+	-160.156f,
+	18.1098f,
+	121.094f,
+	-156.25f,
+	20.2905f,
+	121.094f,
+	-152.344f,
+	22.8183f,
+	121.094f,
+	-148.438f,
+	25.3439f,
+	121.094f,
+	-144.531f,
+	26.7908f,
+	121.094f,
+	-140.625f,
+	29.0959f,
+	121.094f,
+	-136.719f,
+	29.9478f,
+	121.094f,
+	-132.813f,
+	30.8054f,
+	121.094f,
+	-128.906f,
+	31.9545f,
+	121.094f,
+	-125.0f,
+	33.8025f,
+	121.094f,
+	-121.094f,
+	35.2826f,
+	121.094f,
+	-117.188f,
+	36.2373f,
+	121.094f,
+	-113.281f,
+	36.7861f,
+	121.094f,
+	-109.375f,
+	36.509f,
+	121.094f,
+	-105.469f,
+	35.7461f,
+	121.094f,
+	-101.563f,
+	33.7802f,
+	121.094f,
+	-97.6563f,
+	30.788f,
+	121.094f,
+	-93.75f,
+	28.1422f,
+	121.094f,
+	-89.8438f,
+	26.6316f,
+	121.094f,
+	-85.9375f,
+	26.0349f,
+	121.094f,
+	-82.0313f,
+	24.8022f,
+	121.094f,
+	-78.125f,
+	23.5217f,
+	121.094f,
+	-74.2188f,
+	21.74f,
+	121.094f,
+	-70.3125f,
+	20.0101f,
+	121.094f,
+	-66.4063f,
+	17.8705f,
+	121.094f,
+	-62.5f,
+	15.6785f,
+	121.094f,
+	-58.5938f,
+	13.74f,
+	121.094f,
+	-54.6875f,
+	12.3387f,
+	121.094f,
+	-50.7813f,
+	11.9457f,
+	121.094f,
+	-46.875f,
+	12.0102f,
+	121.094f,
+	-42.9688f,
+	11.0065f,
+	121.094f,
+	-39.0625f,
+	9.84571f,
+	121.094f,
+	-35.1563f,
+	10.0894f,
+	121.094f,
+	-31.25f,
+	10.5366f,
+	121.094f,
+	-27.3438f,
+	9.94957f,
+	121.094f,
+	-23.4375f,
+	11.0038f,
+	121.094f,
+	-19.5313f,
+	12.8084f,
+	121.094f,
+	-15.625f,
+	13.8969f,
+	121.094f,
+	-11.7188f,
+	14.9146f,
+	121.094f,
+	-7.8125f,
+	15.4187f,
+	121.094f,
+	-3.90625f,
+	16.094f,
+	121.094f,
+	0.0f,
+	17.0612f,
+	121.094f,
+	3.90625f,
+	18.5327f,
+	121.094f,
+	-250.0f,
+	2.18397f,
+	117.188f,
+	-246.094f,
+	1.51628f,
+	117.188f,
+	-242.188f,
+	0.628327f,
+	117.188f,
+	-238.281f,
+	-0.567933f,
+	117.188f,
+	-234.375f,
+	-2.01568f,
+	117.188f,
+	-230.469f,
+	-3.41089f,
+	117.188f,
+	-226.563f,
+	-3.82758f,
+	117.188f,
+	-222.656f,
+	-5.01586f,
+	117.188f,
+	-218.75f,
+	-4.74822f,
+	117.188f,
+	-214.844f,
+	-3.30853f,
+	117.188f,
+	-210.938f,
+	-2.32499f,
+	117.188f,
+	-207.031f,
+	-1.71509f,
+	117.188f,
+	-203.125f,
+	-1.19203f,
+	117.188f,
+	-199.219f,
+	0.219498f,
+	117.188f,
+	-195.313f,
+	1.66304f,
+	117.188f,
+	-191.406f,
+	4.35105f,
+	117.188f,
+	-187.5f,
+	6.33228f,
+	117.188f,
+	-183.594f,
+	8.00972f,
+	117.188f,
+	-179.688f,
+	9.71486f,
+	117.188f,
+	-175.781f,
+	10.7727f,
+	117.188f,
+	-171.875f,
+	11.358f,
+	117.188f,
+	-167.969f,
+	12.5239f,
+	117.188f,
+	-164.063f,
+	14.6278f,
+	117.188f,
+	-160.156f,
+	17.2069f,
+	117.188f,
+	-156.25f,
+	19.9779f,
+	117.188f,
+	-152.344f,
+	23.4607f,
+	117.188f,
+	-148.438f,
+	26.6108f,
+	117.188f,
+	-144.531f,
+	28.4635f,
+	117.188f,
+	-140.625f,
+	29.7705f,
+	117.188f,
+	-136.719f,
+	31.0684f,
+	117.188f,
+	-132.813f,
+	31.8395f,
+	117.188f,
+	-128.906f,
+	32.1658f,
+	117.188f,
+	-125.0f,
+	34.7478f,
+	117.188f,
+	-121.094f,
+	36.0624f,
+	117.188f,
+	-117.188f,
+	37.2702f,
+	117.188f,
+	-113.281f,
+	37.3474f,
+	117.188f,
+	-109.375f,
+	37.242f,
+	117.188f,
+	-105.469f,
+	36.1544f,
+	117.188f,
+	-101.563f,
+	33.403f,
+	117.188f,
+	-97.6563f,
+	31.294f,
+	117.188f,
+	-93.75f,
+	29.4961f,
+	117.188f,
+	-89.8438f,
+	29.0556f,
+	117.188f,
+	-85.9375f,
+	28.2757f,
+	117.188f,
+	-82.0313f,
+	26.6322f,
+	117.188f,
+	-78.125f,
+	24.8286f,
+	117.188f,
+	-74.2188f,
+	22.7019f,
+	117.188f,
+	-70.3125f,
+	20.4725f,
+	117.188f,
+	-66.4063f,
+	17.984f,
+	117.188f,
+	-62.5f,
+	16.3033f,
+	117.188f,
+	-58.5938f,
+	14.2087f,
+	117.188f,
+	-54.6875f,
+	12.8086f,
+	117.188f,
+	-50.7813f,
+	12.5463f,
+	117.188f,
+	-46.875f,
+	12.1781f,
+	117.188f,
+	-42.9688f,
+	11.1391f,
+	117.188f,
+	-39.0625f,
+	10.4623f,
+	117.188f,
+	-35.1563f,
+	11.0528f,
+	117.188f,
+	-31.25f,
+	11.454f,
+	117.188f,
+	-27.3438f,
+	10.5577f,
+	117.188f,
+	-23.4375f,
+	10.6328f,
+	117.188f,
+	-19.5313f,
+	12.5569f,
+	117.188f,
+	-15.625f,
+	13.5389f,
+	117.188f,
+	-11.7188f,
+	14.3792f,
+	117.188f,
+	-7.8125f,
+	15.4809f,
+	117.188f,
+	-3.90625f,
+	16.1008f,
+	117.188f,
+	0.0f,
+	17.3675f,
+	117.188f,
+	3.90625f,
+	18.919f,
+	117.188f,
+};
+
+btScalar Landscape06Nml[] = {
+	-0.373915f,
+	0.891474f,
+	-0.255855f,
+	-0.31015f,
+	0.793525f,
+	-0.52357f,
+	-0.450332f,
+	0.86393f,
+	-0.225447f,
+	-0.404472f,
+	0.777981f,
+	-0.480778f,
+	-0.557629f,
+	0.811458f,
+	-0.174885f,
+	-0.428564f,
+	0.86234f,
+	-0.269633f,
+	-0.414608f,
+	0.909847f,
+	-0.0166634f,
+	-0.208047f,
+	0.971233f,
+	0.115854f,
+	-0.328757f,
+	0.932331f,
+	0.150588f,
+	-0.263029f,
+	0.937991f,
+	0.225808f,
+	-0.409412f,
+	0.900937f,
+	0.143853f,
+	-0.455309f,
+	0.881347f,
+	0.126178f,
+	-0.31951f,
+	0.943247f,
+	0.0905511f,
+	-0.33825f,
+	0.934582f,
+	0.1102f,
+	-0.183669f,
+	0.981438f,
+	0.0551769f,
+	-0.208308f,
+	0.97293f,
+	0.100072f,
+	-0.189578f,
+	0.981862f,
+	-0.00282566f,
+	-0.201983f,
+	0.97649f,
+	0.0752952f,
+	-0.0672914f,
+	0.99749f,
+	-0.0220572f,
+	-0.118523f,
+	0.991949f,
+	0.0446084f,
+	0.102757f,
+	0.986595f,
+	-0.126773f,
+	0.00122687f,
+	0.992675f,
+	-0.120808f,
+	0.0798054f,
+	0.967751f,
+	-0.238933f,
+	0.00875196f,
+	0.978629f,
+	-0.205448f,
+	0.141554f,
+	0.932155f,
+	-0.333242f,
+	0.0918343f,
+	0.965319f,
+	-0.244387f,
+	0.372959f,
+	0.842559f,
+	-0.388582f,
+	0.280191f,
+	0.875069f,
+	-0.394647f,
+	0.314921f,
+	0.849656f,
+	-0.422977f,
+	0.258676f,
+	0.813335f,
+	-0.521127f,
+	0.266443f,
+	0.876708f,
+	-0.400489f,
+	0.358307f,
+	0.856764f,
+	-0.370907f,
+	0.280512f,
+	0.913716f,
+	-0.293999f,
+	0.337561f,
+	0.857178f,
+	-0.388971f,
+	0.0927666f,
+	0.994197f,
+	-0.0544758f,
+	0.155544f,
+	0.953116f,
+	-0.259567f,
+	-0.18671f,
+	0.979157f,
+	-0.0799463f,
+	-0.20939f,
+	0.930283f,
+	-0.301212f,
+	-0.117108f,
+	0.986639f,
+	-0.113269f,
+	-0.190516f,
+	0.897405f,
+	-0.397956f,
+	-0.0703231f,
+	0.977433f,
+	-0.199199f,
+	-0.142735f,
+	0.82748f,
+	-0.54305f,
+	-0.00706444f,
+	0.969596f,
+	-0.244609f,
+	0.0216131f,
+	0.85384f,
+	-0.520087f,
+	-0.100606f,
+	0.961424f,
+	-0.256011f,
+	0.00977565f,
+	0.925054f,
+	-0.379709f,
+	-0.0412166f,
+	0.978641f,
+	-0.201403f,
+	0.099113f,
+	0.987693f,
+	-0.12099f,
+	0.0911178f,
+	0.982669f,
+	-0.16143f,
+	0.0730708f,
+	0.986329f,
+	-0.147703f,
+	0.114859f,
+	0.978874f,
+	-0.169152f,
+	0.109302f,
+	0.983788f,
+	-0.142175f,
+	0.116167f,
+	0.976713f,
+	-0.180378f,
+	0.0784892f,
+	0.966143f,
+	-0.24578f,
+	0.0196949f,
+	0.987682f,
+	-0.155232f,
+	0.0258077f,
+	0.978923f,
+	-0.202593f,
+	-0.0161862f,
+	0.979217f,
+	-0.202168f,
+	-0.120896f,
+	0.935381f,
+	-0.332336f,
+	-0.0291128f,
+	0.941335f,
+	-0.336215f,
+	-0.0776893f,
+	0.901631f,
+	-0.425472f,
+	-0.0768763f,
+	0.919716f,
+	-0.384983f,
+	-0.0462705f,
+	0.951989f,
+	-0.302615f,
+	-0.0260847f,
+	0.891121f,
+	-0.453016f,
+	-0.0818404f,
+	0.911776f,
+	-0.40245f,
+	0.152271f,
+	0.86407f,
+	-0.479789f,
+	0.0880729f,
+	0.874485f,
+	-0.476991f,
+	0.11644f,
+	0.855496f,
+	-0.504548f,
+	0.0395982f,
+	0.813262f,
+	-0.580548f,
+	0.00631598f,
+	0.857568f,
+	-0.514332f,
+	-0.0780909f,
+	0.759651f,
+	-0.645626f,
+	-0.0538158f,
+	0.822232f,
+	-0.566603f,
+	0.0102932f,
+	0.785194f,
+	-0.619165f,
+	-0.00905015f,
+	0.879608f,
+	-0.475613f,
+	0.0439442f,
+	0.825793f,
+	-0.562259f,
+	-0.15058f,
+	0.877556f,
+	-0.455216f,
+	-0.0080088f,
+	0.902753f,
+	-0.430085f,
+	-0.112334f,
+	0.946952f,
+	-0.301104f,
+	0.00843129f,
+	0.966084f,
+	-0.258092f,
+	-0.0520095f,
+	0.981628f,
+	-0.183579f,
+	-0.0023169f,
+	0.970009f,
+	-0.243057f,
+	-0.0302799f,
+	0.995335f,
+	-0.0916051f,
+	0.0376961f,
+	0.991328f,
+	-0.125888f,
+	0.0852061f,
+	0.995425f,
+	-0.0432221f,
+	0.156966f,
+	0.986644f,
+	0.0435404f,
+	0.21491f,
+	0.973384f,
+	-0.079613f,
+	0.060548f,
+	0.977921f,
+	-0.200013f,
+	0.158822f,
+	0.967125f,
+	-0.198606f,
+	0.134591f,
+	0.957423f,
+	-0.255396f,
+	0.121293f,
+	0.978974f,
+	-0.164008f,
+	0.108432f,
+	0.947609f,
+	-0.300465f,
+	0.0857608f,
+	0.988377f,
+	-0.125519f,
+	0.0956294f,
+	0.951748f,
+	-0.291599f,
+	-0.0286686f,
+	0.995404f,
+	-0.0913747f,
+	0.0793846f,
+	0.975448f,
+	-0.205424f,
+	0.106071f,
+	0.990697f,
+	0.085251f,
+	0.292453f,
+	0.941038f,
+	0.170056f,
+	0.371746f,
+	0.914213f,
+	0.161306f,
+	0.341006f,
+	0.933768f,
+	0.108596f,
+	0.372402f,
+	0.920827f,
+	0.115737f,
+	0.298439f,
+	0.950662f,
+	-0.0847083f,
+	0.211549f,
+	0.974139f,
+	0.0793788f,
+	0.255698f,
+	0.96634f,
+	-0.0283838f,
+	-0.0706076f,
+	0.991212f,
+	0.111867f,
+	0.0490836f,
+	0.977096f,
+	0.207063f,
+	-0.256838f,
+	0.950876f,
+	0.172827f,
+	-0.168627f,
+	0.937168f,
+	0.30542f,
+	-0.0642391f,
+	0.963856f,
+	0.258562f,
+	-0.00196823f,
+	0.905532f,
+	0.424274f,
+	0.182795f,
+	0.945782f,
+	0.268481f,
+	0.13515f,
+	0.919671f,
+	0.368699f,
+	0.107184f,
+	0.970151f,
+	0.217528f,
+	0.00985613f,
+	0.977921f,
+	0.208742f,
+	0.0734564f,
+	0.98632f,
+	0.147572f,
+	0.067487f,
+	0.972043f,
+	0.224896f,
+	0.20672f,
+	0.968081f,
+	0.141727f,
+	0.186648f,
+	0.970679f,
+	0.151478f,
+	0.213561f,
+	0.965286f,
+	0.150383f,
+	0.189498f,
+	0.980689f,
+	0.0483704f,
+	0.277013f,
+	0.94213f,
+	0.188824f,
+	0.316429f,
+	0.927757f,
+	0.197839f,
+	0.225121f,
+	0.964838f,
+	0.135677f,
+	0.124434f,
+	0.992109f,
+	0.0153398f,
+	0.14416f,
+	0.987262f,
+	0.0673169f,
+	0.128154f,
+	0.991727f,
+	-0.0073791f,
+	0.1809f,
+	0.982671f,
+	0.0404037f,
+	0.125271f,
+	0.99083f,
+	-0.0506329f,
+	0.117639f,
+	0.992303f,
+	-0.0386759f,
+	0.0449726f,
+	0.973305f,
+	-0.225068f,
+	0.124809f,
+	0.992058f,
+	0.0156083f,
+	0.127135f,
+	0.958258f,
+	-0.256082f,
+	0.171896f,
+	0.982167f,
+	0.0761593f,
+	0.160304f,
+	0.951991f,
+	-0.260798f,
+	-0.494953f,
+	0.868907f,
+	-0.00477061f,
+	-0.512017f,
+	0.856533f,
+	0.0647248f,
+	-0.564588f,
+	0.823588f,
+	0.0542513f,
+	-0.480746f,
+	0.876502f,
+	0.0250513f,
+	-0.397786f,
+	0.91419f,
+	0.0776024f,
+	-0.3922f,
+	0.916181f,
+	0.0824136f,
+	-0.288362f,
+	0.955571f,
+	0.0610852f,
+	-0.109541f,
+	0.991807f,
+	0.0657195f,
+	-0.119597f,
+	0.99188f,
+	-0.0432477f,
+	-0.0246849f,
+	0.992746f,
+	-0.117673f,
+	0.197846f,
+	0.964215f,
+	-0.176481f,
+	0.198977f,
+	0.940868f,
+	-0.274182f,
+	0.288209f,
+	0.884317f,
+	-0.367314f,
+	0.309487f,
+	0.847917f,
+	-0.430411f,
+	0.274335f,
+	0.939851f,
+	-0.20352f,
+	0.256503f,
+	0.958634f,
+	-0.123399f,
+	0.0454718f,
+	0.993939f,
+	-0.100084f,
+	-0.104233f,
+	0.980418f,
+	0.167081f,
+	-0.137204f,
+	0.957647f,
+	0.253153f,
+	-0.0909923f,
+	0.97094f,
+	0.221352f,
+	-0.0588081f,
+	0.977218f,
+	0.203928f,
+	0.0555628f,
+	0.971956f,
+	0.228506f,
+	0.00693538f,
+	0.995197f,
+	0.0976442f,
+	0.0112691f,
+	0.996103f,
+	-0.0874744f,
+	0.104487f,
+	0.972486f,
+	-0.208215f,
+	0.102504f,
+	0.971128f,
+	-0.215412f,
+	0.0933319f,
+	0.976682f,
+	-0.193342f,
+	0.023135f,
+	0.974909f,
+	-0.221399f,
+	0.0195254f,
+	0.964185f,
+	-0.264511f,
+	0.0843961f,
+	0.966003f,
+	-0.244368f,
+	0.0791804f,
+	0.94997f,
+	-0.30214f,
+	0.048562f,
+	0.904645f,
+	-0.423391f,
+	0.168302f,
+	0.901104f,
+	-0.399607f,
+	0.0460994f,
+	0.899241f,
+	-0.435018f,
+	-0.0201301f,
+	0.942734f,
+	-0.332937f,
+	-0.0651933f,
+	0.964794f,
+	-0.254799f,
+	-0.107417f,
+	0.971064f,
+	-0.213298f,
+	-0.17484f,
+	0.97454f,
+	-0.140369f,
+	-0.26177f,
+	0.957564f,
+	-0.120611f,
+	-0.18964f,
+	0.980348f,
+	-0.0543506f,
+	-0.0244255f,
+	0.999511f,
+	-0.0195208f,
+	0.0943164f,
+	0.983888f,
+	-0.151887f,
+	0.241216f,
+	0.961222f,
+	-0.133665f,
+	0.186016f,
+	0.976207f,
+	-0.111437f,
+	0.0288865f,
+	0.998091f,
+	-0.0545842f,
+	-0.00269516f,
+	0.997826f,
+	0.0658428f,
+	-0.0454406f,
+	0.988515f,
+	0.144131f,
+	0.0349744f,
+	0.994103f,
+	0.102646f,
+	0.310638f,
+	0.939659f,
+	0.143339f,
+	0.362637f,
+	0.904005f,
+	0.226428f,
+	0.268459f,
+	0.940968f,
+	0.206177f,
+	-0.0101438f,
+	0.990408f,
+	0.137803f,
+	-0.259956f,
+	0.964753f,
+	0.0409231f,
+	-0.105214f,
+	0.99436f,
+	0.0133734f,
+	0.151003f,
+	0.984401f,
+	0.0902917f,
+	0.153972f,
+	0.971331f,
+	0.181133f,
+	0.131893f,
+	0.982033f,
+	0.134962f,
+	0.145326f,
+	0.983866f,
+	0.104346f,
+	0.172165f,
+	0.970545f,
+	0.16853f,
+	0.260168f,
+	0.947172f,
+	0.18756f,
+	0.265906f,
+	0.934787f,
+	0.235514f,
+	0.175251f,
+	0.956563f,
+	0.232968f,
+	0.205308f,
+	0.948623f,
+	0.240753f,
+	0.093567f,
+	0.968565f,
+	0.230493f,
+	0.000708259f,
+	0.964766f,
+	0.263107f,
+	0.00657781f,
+	0.964909f,
+	0.262504f,
+	-0.520396f,
+	0.851586f,
+	0.063156f,
+	-0.521936f,
+	0.850242f,
+	0.0683468f,
+	-0.537166f,
+	0.843365f,
+	0.0137284f,
+	-0.507784f,
+	0.86143f,
+	-0.00972442f,
+	-0.393238f,
+	0.917684f,
+	0.0567504f,
+	-0.362634f,
+	0.931285f,
+	-0.0347048f,
+	-0.298916f,
+	0.951591f,
+	-0.0715749f,
+	-0.125797f,
+	0.991634f,
+	-0.0289454f,
+	0.00629701f,
+	0.999979f,
+	0.00117199f,
+	0.0170902f,
+	0.994718f,
+	-0.101214f,
+	0.290594f,
+	0.952688f,
+	-0.0891078f,
+	0.285259f,
+	0.936469f,
+	-0.20409f,
+	0.342737f,
+	0.918097f,
+	-0.199071f,
+	0.262981f,
+	0.956466f,
+	-0.126547f,
+	-0.000199178f,
+	0.996828f,
+	-0.0795833f,
+	0.16652f,
+	0.978742f,
+	0.119733f,
+	0.0382843f,
+	0.984413f,
+	0.171653f,
+	-0.277981f,
+	0.950703f,
+	0.137441f,
+	-0.18354f,
+	0.954113f,
+	0.236605f,
+	-0.0382213f,
+	0.967232f,
+	0.251001f,
+	-0.0471282f,
+	0.983482f,
+	0.174763f,
+	0.05509f,
+	0.990469f,
+	0.126237f,
+	0.154415f,
+	0.97865f,
+	0.135647f,
+	0.187824f,
+	0.979878f,
+	0.0675348f,
+	0.226039f,
+	0.971999f,
+	-0.0642243f,
+	0.0780765f,
+	0.982532f,
+	-0.168921f,
+	0.109774f,
+	0.985685f,
+	-0.127961f,
+	0.112009f,
+	0.982676f,
+	-0.147653f,
+	0.0632751f,
+	0.975786f,
+	-0.209375f,
+	0.0264674f,
+	0.962968f,
+	-0.268312f,
+	0.10845f,
+	0.959018f,
+	-0.261771f,
+	0.0643921f,
+	0.961817f,
+	-0.266009f,
+	0.166593f,
+	0.964859f,
+	-0.203209f,
+	0.0747121f,
+	0.973608f,
+	-0.215653f,
+	-0.165051f,
+	0.968419f,
+	-0.186874f,
+	-0.148108f,
+	0.983106f,
+	-0.10755f,
+	-0.179372f,
+	0.979451f,
+	-0.0922022f,
+	-0.237948f,
+	0.970437f,
+	-0.0404116f,
+	-0.2824f,
+	0.959184f,
+	-0.014723f,
+	-0.146028f,
+	0.988959f,
+	-0.0252228f,
+	0.05616f,
+	0.991975f,
+	-0.113275f,
+	0.196359f,
+	0.969761f,
+	-0.144935f,
+	0.181455f,
+	0.976082f,
+	-0.119739f,
+	0.110973f,
+	0.993178f,
+	-0.035804f,
+	-0.0390828f,
+	0.998775f,
+	0.0303582f,
+	-0.136356f,
+	0.988616f,
+	0.0636122f,
+	-0.0521843f,
+	0.980102f,
+	0.191512f,
+	0.0572854f,
+	0.981374f,
+	0.183367f,
+	0.238568f,
+	0.946616f,
+	0.216801f,
+	0.340107f,
+	0.907515f,
+	0.246464f,
+	0.312043f,
+	0.926088f,
+	0.212108f,
+	0.0846085f,
+	0.98223f,
+	0.167527f,
+	-0.163231f,
+	0.986101f,
+	0.0309937f,
+	-0.143013f,
+	0.98971f,
+	-0.00457425f,
+	0.0291614f,
+	0.993948f,
+	0.105909f,
+	0.107232f,
+	0.980268f,
+	0.16606f,
+	0.13514f,
+	0.977368f,
+	0.162754f,
+	0.171582f,
+	0.963454f,
+	0.205708f,
+	0.160805f,
+	0.97344f,
+	0.162963f,
+	0.206565f,
+	0.959827f,
+	0.189905f,
+	0.203733f,
+	0.939018f,
+	0.277016f,
+	0.156541f,
+	0.940477f,
+	0.30166f,
+	0.14264f,
+	0.938158f,
+	0.315457f,
+	0.0877292f,
+	0.924317f,
+	0.371405f,
+	0.0427952f,
+	0.921735f,
+	0.385453f,
+	0.102307f,
+	0.915297f,
+	0.389569f,
+	-0.518725f,
+	0.854828f,
+	-0.0138881f,
+	-0.516652f,
+	0.85588f,
+	0.023226f,
+	-0.490153f,
+	0.869598f,
+	0.0595683f,
+	-0.505693f,
+	0.862598f,
+	-0.0140982f,
+	-0.393758f,
+	0.918824f,
+	-0.0267811f,
+	-0.308114f,
+	0.951253f,
+	-0.0135724f,
+	-0.25353f,
+	0.967309f,
+	0.00592796f,
+	-0.183935f,
+	0.978787f,
+	-0.0902442f,
+	-0.0335384f,
+	0.998587f,
+	-0.0412272f,
+	0.0888831f,
+	0.995408f,
+	-0.0355216f,
+	0.275528f,
+	0.951614f,
+	-0.136073f,
+	0.317879f,
+	0.941106f,
+	-0.115209f,
+	0.22556f,
+	0.974028f,
+	-0.0197739f,
+	0.262726f,
+	0.954534f,
+	0.140851f,
+	0.0383338f,
+	0.998565f,
+	0.0373963f,
+	0.0108706f,
+	0.999386f,
+	-0.0333096f,
+	0.0472758f,
+	0.987524f,
+	0.150202f,
+	-0.22401f,
+	0.968166f,
+	0.111686f,
+	-0.221122f,
+	0.974472f,
+	0.0388438f,
+	-0.0303833f,
+	0.999266f,
+	0.0233175f,
+	0.0911048f,
+	0.995841f,
+	0.000284795f,
+	0.0750561f,
+	0.987717f,
+	-0.137044f,
+	0.140099f,
+	0.985231f,
+	-0.098447f,
+	0.159287f,
+	0.981153f,
+	-0.10939f,
+	0.301657f,
+	0.953265f,
+	-0.0169985f,
+	0.140836f,
+	0.988971f,
+	-0.0458453f,
+	0.074059f,
+	0.996008f,
+	-0.0498236f,
+	0.0873182f,
+	0.996023f,
+	-0.0176849f,
+	0.132872f,
+	0.990946f,
+	0.019257f,
+	0.15553f,
+	0.982355f,
+	-0.103875f,
+	0.133638f,
+	0.955183f,
+	-0.264135f,
+	0.0505536f,
+	0.951293f,
+	-0.304114f,
+	0.0663471f,
+	0.962897f,
+	-0.261588f,
+	0.0679148f,
+	0.992885f,
+	-0.0978063f,
+	-0.186921f,
+	0.976146f,
+	-0.110452f,
+	-0.16844f,
+	0.980926f,
+	-0.0970201f,
+	-0.17716f,
+	0.9831f,
+	-0.0461376f,
+	-0.252028f,
+	0.967676f,
+	-0.00920485f,
+	-0.25063f,
+	0.967236f,
+	-0.0404965f,
+	-0.0995772f,
+	0.983353f,
+	-0.151991f,
+	0.0940064f,
+	0.974734f,
+	-0.202626f,
+	0.146102f,
+	0.962693f,
+	-0.227766f,
+	0.10874f,
+	0.966405f,
+	-0.232891f,
+	-0.0013416f,
+	0.987029f,
+	-0.160533f,
+	-0.0603915f,
+	0.998129f,
+	0.00954783f,
+	-0.17946f,
+	0.98293f,
+	0.040526f,
+	-0.153066f,
+	0.978461f,
+	0.138509f,
+	0.00546813f,
+	0.977756f,
+	0.209673f,
+	0.202775f,
+	0.944505f,
+	0.258443f,
+	0.334531f,
+	0.904949f,
+	0.262976f,
+	0.339399f,
+	0.898505f,
+	0.278385f,
+	0.212792f,
+	0.950144f,
+	0.227917f,
+	-0.0583572f,
+	0.996371f,
+	0.0619671f,
+	-0.218128f,
+	0.975136f,
+	0.0391184f,
+	-0.0703437f,
+	0.983861f,
+	0.16453f,
+	0.113041f,
+	0.961301f,
+	0.25124f,
+	0.0979771f,
+	0.959037f,
+	0.265798f,
+	0.151767f,
+	0.929082f,
+	0.337302f,
+	0.185905f,
+	0.937423f,
+	0.294409f,
+	0.169611f,
+	0.955662f,
+	0.240713f,
+	0.159864f,
+	0.96582f,
+	0.204047f,
+	0.151538f,
+	0.965571f,
+	0.211446f,
+	0.11661f,
+	0.954852f,
+	0.273241f,
+	0.0708035f,
+	0.941966f,
+	0.328158f,
+	-0.00402057f,
+	0.956357f,
+	0.292174f,
+	0.0123647f,
+	0.956622f,
+	0.291069f,
+	-0.626234f,
+	0.777268f,
+	-0.0607036f,
+	-0.590408f,
+	0.806122f,
+	0.0398278f,
+	-0.512253f,
+	0.84829f,
+	0.134171f,
+	-0.429387f,
+	0.891471f,
+	0.144588f,
+	-0.394702f,
+	0.915407f,
+	0.0789917f,
+	-0.352114f,
+	0.935018f,
+	0.0419128f,
+	-0.269358f,
+	0.962596f,
+	0.0292454f,
+	-0.0709514f,
+	0.996127f,
+	0.0519312f,
+	-0.0485279f,
+	0.996417f,
+	-0.069268f,
+	0.139101f,
+	0.983953f,
+	-0.111751f,
+	0.369972f,
+	0.916386f,
+	-0.152833f,
+	0.200502f,
+	0.96864f,
+	-0.146752f,
+	0.063154f,
+	0.997971f,
+	0.00814434f,
+	0.218613f,
+	0.964332f,
+	0.149236f,
+	0.233367f,
+	0.966768f,
+	0.104401f,
+	0.00832713f,
+	0.995958f,
+	-0.0894382f,
+	-0.101235f,
+	0.994608f,
+	-0.0224841f,
+	-0.188929f,
+	0.980627f,
+	0.051742f,
+	-0.131276f,
+	0.990999f,
+	0.026226f,
+	0.0111642f,
+	0.996226f,
+	-0.0860703f,
+	0.127344f,
+	0.982944f,
+	-0.132683f,
+	0.133649f,
+	0.978353f,
+	-0.157998f,
+	0.127047f,
+	0.978674f,
+	-0.161419f,
+	0.154013f,
+	0.97768f,
+	-0.142902f,
+	0.207952f,
+	0.974577f,
+	-0.0833996f,
+	0.130584f,
+	0.99044f,
+	-0.0444555f,
+	0.0527996f,
+	0.997244f,
+	-0.0521173f,
+	0.0873033f,
+	0.993919f,
+	-0.0671111f,
+	0.134372f,
+	0.9813f,
+	-0.137819f,
+	0.302979f,
+	0.937443f,
+	-0.171475f,
+	0.235087f,
+	0.922651f,
+	-0.305694f,
+	0.116878f,
+	0.945593f,
+	-0.303632f,
+	-0.0892912f,
+	0.947762f,
+	-0.306226f,
+	-0.0487728f,
+	0.993685f,
+	-0.101049f,
+	-0.161853f,
+	0.9816f,
+	-0.101314f,
+	-0.226351f,
+	0.97061f,
+	-0.0817454f,
+	-0.270044f,
+	0.962691f,
+	-0.0173905f,
+	-0.294262f,
+	0.954053f,
+	0.0565031f,
+	-0.151555f,
+	0.985239f,
+	0.0795882f,
+	0.00297078f,
+	0.999916f,
+	-0.0126498f,
+	0.158118f,
+	0.985077f,
+	-0.067991f,
+	0.232676f,
+	0.957923f,
+	-0.168067f,
+	0.184787f,
+	0.953241f,
+	-0.239135f,
+	-0.102652f,
+	0.943763f,
+	-0.314284f,
+	-0.249925f,
+	0.941897f,
+	-0.224429f,
+	-0.230538f,
+	0.969668f,
+	-0.0812203f,
+	-0.256878f,
+	0.964046f,
+	-0.0680376f,
+	-0.0528332f,
+	0.99816f,
+	0.0297627f,
+	0.16253f,
+	0.979605f,
+	0.118148f,
+	0.292443f,
+	0.935246f,
+	0.199479f,
+	0.337448f,
+	0.899957f,
+	0.276054f,
+	0.288581f,
+	0.911989f,
+	0.291541f,
+	0.0381605f,
+	0.961598f,
+	0.271797f,
+	-0.217082f,
+	0.942133f,
+	0.25546f,
+	-0.187341f,
+	0.947099f,
+	0.26059f,
+	0.0122725f,
+	0.939216f,
+	0.343107f,
+	0.0450967f,
+	0.927047f,
+	0.372224f,
+	0.0805118f,
+	0.921403f,
+	0.380178f,
+	0.269621f,
+	0.884781f,
+	0.380089f,
+	0.278457f,
+	0.920235f,
+	0.275007f,
+	0.240432f,
+	0.950543f,
+	0.19662f,
+	0.110916f,
+	0.980787f,
+	0.160482f,
+	0.0190768f,
+	0.974013f,
+	0.225685f,
+	0.0421661f,
+	0.96323f,
+	0.26535f,
+	0.0623149f,
+	0.965243f,
+	0.253816f,
+	0.0484827f,
+	0.970002f,
+	0.238214f,
+	-0.675447f,
+	0.735679f,
+	-0.050474f,
+	-0.639324f,
+	0.768795f,
+	-0.0148056f,
+	-0.556082f,
+	0.830482f,
+	0.0327513f,
+	-0.42972f,
+	0.893254f,
+	0.132053f,
+	-0.365389f,
+	0.922739f,
+	0.122653f,
+	-0.226979f,
+	0.966229f,
+	0.121993f,
+	-0.221717f,
+	0.973751f,
+	-0.051483f,
+	-0.0779728f,
+	0.987923f,
+	-0.133899f,
+	0.0930073f,
+	0.979917f,
+	-0.176386f,
+	0.192144f,
+	0.942491f,
+	-0.27348f,
+	0.309496f,
+	0.916222f,
+	-0.254459f,
+	0.155051f,
+	0.977443f,
+	-0.143405f,
+	-0.0554135f,
+	0.989739f,
+	-0.131708f,
+	0.110672f,
+	0.991805f,
+	-0.0638304f,
+	0.310319f,
+	0.950296f,
+	0.0252996f,
+	0.103349f,
+	0.993006f,
+	-0.0570824f,
+	-0.143599f,
+	0.988502f,
+	-0.0473533f,
+	-0.226116f,
+	0.973312f,
+	-0.0391734f,
+	-0.100068f,
+	0.994649f,
+	-0.0257001f,
+	0.124656f,
+	0.989757f,
+	-0.0695779f,
+	0.137305f,
+	0.97907f,
+	-0.150231f,
+	0.12072f,
+	0.989818f,
+	-0.075415f,
+	0.132256f,
+	0.990827f,
+	-0.0277589f,
+	0.0994133f,
+	0.991446f,
+	-0.0845708f,
+	0.16457f,
+	0.984921f,
+	-0.0533595f,
+	0.161357f,
+	0.986289f,
+	-0.034624f,
+	0.0776395f,
+	0.993281f,
+	-0.0858198f,
+	0.196429f,
+	0.972629f,
+	-0.124127f,
+	0.213597f,
+	0.93634f,
+	-0.278645f,
+	0.333587f,
+	0.906552f,
+	-0.258619f,
+	0.264447f,
+	0.928271f,
+	-0.261499f,
+	0.0224352f,
+	0.968338f,
+	-0.248633f,
+	-0.153007f,
+	0.973949f,
+	-0.167368f,
+	-0.171971f,
+	0.976037f,
+	-0.133332f,
+	-0.164739f,
+	0.982172f,
+	-0.0905542f,
+	-0.256427f,
+	0.965345f,
+	-0.0485236f,
+	-0.266685f,
+	0.961164f,
+	-0.0710119f,
+	-0.315314f,
+	0.936338f,
+	-0.154429f,
+	-0.180509f,
+	0.974939f,
+	-0.130043f,
+	0.0306802f,
+	0.996715f,
+	-0.0749509f,
+	0.181216f,
+	0.981966f,
+	-0.0538862f,
+	0.308423f,
+	0.951239f,
+	-0.0044789f,
+	0.193412f,
+	0.981099f,
+	-0.00609358f,
+	-0.00883535f,
+	0.999181f,
+	0.039479f,
+	-0.293629f,
+	0.95203f,
+	-0.0861418f,
+	-0.288511f,
+	0.952707f,
+	-0.0954526f,
+	-0.270635f,
+	0.961763f,
+	-0.0420598f,
+	-0.176015f,
+	0.982039f,
+	0.0679556f,
+	0.0472003f,
+	0.981703f,
+	0.184478f,
+	0.185293f,
+	0.947852f,
+	0.259313f,
+	0.26012f,
+	0.901797f,
+	0.345109f,
+	0.219376f,
+	0.887657f,
+	0.404894f,
+	0.015248f,
+	0.892187f,
+	0.451408f,
+	-0.212632f,
+	0.887876f,
+	0.407999f,
+	-0.145904f,
+	0.908525f,
+	0.391529f,
+	-0.0226457f,
+	0.932703f,
+	0.359933f,
+	0.0874951f,
+	0.910834f,
+	0.403393f,
+	0.125007f,
+	0.935932f,
+	0.329249f,
+	0.288568f,
+	0.918223f,
+	0.271284f,
+	0.34457f,
+	0.896771f,
+	0.277619f,
+	0.261558f,
+	0.928634f,
+	0.263108f,
+	0.0802026f,
+	0.961218f,
+	0.26387f,
+	0.0163948f,
+	0.952196f,
+	0.305047f,
+	0.0566148f,
+	0.964684f,
+	0.257253f,
+	0.102872f,
+	0.970943f,
+	0.216073f,
+	0.0353576f,
+	0.994079f,
+	0.102749f,
+	-0.569322f,
+	0.820332f,
+	-0.0541097f,
+	-0.616679f,
+	0.764093f,
+	-0.18939f,
+	-0.605157f,
+	0.764062f,
+	-0.223597f,
+	-0.50856f,
+	0.856476f,
+	-0.0884048f,
+	-0.372491f,
+	0.927008f,
+	0.0436669f,
+	-0.225048f,
+	0.969626f,
+	0.0958063f,
+	-0.0508165f,
+	0.996801f,
+	0.0616925f,
+	0.0586358f,
+	0.990558f,
+	-0.123919f,
+	0.126111f,
+	0.966195f,
+	-0.224862f,
+	0.229194f,
+	0.950926f,
+	-0.207869f,
+	0.252375f,
+	0.936474f,
+	-0.243564f,
+	0.0944308f,
+	0.971404f,
+	-0.217846f,
+	-0.0355117f,
+	0.972557f,
+	-0.229939f,
+	0.0856503f,
+	0.962722f,
+	-0.256575f,
+	0.220711f,
+	0.941477f,
+	-0.254769f,
+	0.0934053f,
+	0.989629f,
+	-0.109133f,
+	-0.156897f,
+	0.986627f,
+	-0.0441527f,
+	-0.224564f,
+	0.970579f,
+	-0.0868729f,
+	-0.0948813f,
+	0.992594f,
+	-0.0758608f,
+	0.168753f,
+	0.983045f,
+	-0.0717275f,
+	0.110894f,
+	0.991432f,
+	-0.0690319f,
+	-0.0147158f,
+	0.998265f,
+	0.0570193f,
+	0.10964f,
+	0.979883f,
+	0.16676f,
+	0.213201f,
+	0.96906f,
+	0.124368f,
+	0.195873f,
+	0.980015f,
+	-0.0346975f,
+	0.162476f,
+	0.975738f,
+	-0.146751f,
+	0.136902f,
+	0.9692f,
+	-0.204718f,
+	0.244929f,
+	0.933568f,
+	-0.26165f,
+	0.288988f,
+	0.918188f,
+	-0.270954f,
+	0.254175f,
+	0.924529f,
+	-0.283974f,
+	0.243695f,
+	0.954587f,
+	-0.171397f,
+	-0.00175415f,
+	0.99017f,
+	-0.13986f,
+	-0.165264f,
+	0.975245f,
+	-0.146916f,
+	-0.185767f,
+	0.967008f,
+	-0.174319f,
+	-0.191354f,
+	0.972667f,
+	-0.131541f,
+	-0.271241f,
+	0.952999f,
+	-0.134987f,
+	-0.1847f,
+	0.972855f,
+	-0.139424f,
+	-0.209304f,
+	0.957842f,
+	-0.1968f,
+	-0.243194f,
+	0.936f,
+	-0.254482f,
+	-0.0210884f,
+	0.983365f,
+	-0.18041f,
+	0.0761402f,
+	0.989042f,
+	-0.126486f,
+	0.185372f,
+	0.981538f,
+	0.047127f,
+	0.117606f,
+	0.973445f,
+	0.196404f,
+	-0.0453061f,
+	0.954332f,
+	0.295292f,
+	-0.152267f,
+	0.943756f,
+	0.293495f,
+	-0.272105f,
+	0.944288f,
+	0.185149f,
+	-0.341417f,
+	0.929337f,
+	0.140592f,
+	-0.316477f,
+	0.938022f,
+	0.141266f,
+	-0.0291064f,
+	0.965694f,
+	0.258045f,
+	0.139271f,
+	0.938861f,
+	0.31487f,
+	0.16066f,
+	0.916793f,
+	0.36562f,
+	0.163005f,
+	0.879828f,
+	0.446466f,
+	0.088987f,
+	0.884248f,
+	0.458461f,
+	-0.126118f,
+	0.932849f,
+	0.337472f,
+	-0.101381f,
+	0.953175f,
+	0.284919f,
+	-0.0233764f,
+	0.967738f,
+	0.250872f,
+	0.0600962f,
+	0.965273f,
+	0.254236f,
+	0.184472f,
+	0.94915f,
+	0.255117f,
+	0.293565f,
+	0.911429f,
+	0.288301f,
+	0.309916f,
+	0.89217f,
+	0.328611f,
+	0.260108f,
+	0.896879f,
+	0.357704f,
+	0.0945809f,
+	0.935133f,
+	0.341439f,
+	0.0335311f,
+	0.964748f,
+	0.261032f,
+	0.0942492f,
+	0.979731f,
+	0.176762f,
+	0.167685f,
+	0.967918f,
+	0.187127f,
+	0.258869f,
+	0.942682f,
+	0.210564f,
+	-0.367443f,
+	0.929937f,
+	-0.0142236f,
+	-0.499723f,
+	0.853143f,
+	-0.149749f,
+	-0.60287f,
+	0.768676f,
+	-0.213739f,
+	-0.628893f,
+	0.759885f,
+	-0.164524f,
+	-0.498958f,
+	0.866588f,
+	-0.00814533f,
+	-0.266358f,
+	0.961387f,
+	0.0691948f,
+	0.0209306f,
+	0.994406f,
+	0.103533f,
+	0.18825f,
+	0.979809f,
+	0.0673512f,
+	0.186929f,
+	0.982347f,
+	-0.00722501f,
+	0.221871f,
+	0.971137f,
+	-0.0875532f,
+	0.321849f,
+	0.94224f,
+	-0.0927163f,
+	0.129468f,
+	0.975377f,
+	-0.178544f,
+	-0.0214597f,
+	0.975387f,
+	-0.219454f,
+	0.135606f,
+	0.972282f,
+	-0.19047f,
+	0.166947f,
+	0.968719f,
+	-0.18361f,
+	-0.0604962f,
+	0.993281f,
+	-0.0986602f,
+	-0.147333f,
+	0.985679f,
+	-0.0820398f,
+	-0.177745f,
+	0.972235f,
+	-0.152201f,
+	-0.13389f,
+	0.979994f,
+	-0.147259f,
+	0.107621f,
+	0.993068f,
+	-0.0472599f,
+	0.0496354f,
+	0.9956f,
+	0.0794756f,
+	-0.114638f,
+	0.990271f,
+	0.0788811f,
+	0.0386746f,
+	0.994961f,
+	0.0924988f,
+	0.257639f,
+	0.951075f,
+	0.170521f,
+	0.371556f,
+	0.918219f,
+	0.137186f,
+	0.306734f,
+	0.951256f,
+	-0.0320228f,
+	0.251981f,
+	0.957147f,
+	-0.142743f,
+	0.259956f,
+	0.937158f,
+	-0.232721f,
+	0.273432f,
+	0.938847f,
+	-0.209289f,
+	0.242378f,
+	0.942977f,
+	-0.228139f,
+	0.135357f,
+	0.967026f,
+	-0.21573f,
+	-0.0237633f,
+	0.989278f,
+	-0.144096f,
+	-0.131198f,
+	0.984621f,
+	-0.11536f,
+	-0.202181f,
+	0.972555f,
+	-0.115152f,
+	-0.221308f,
+	0.9725f,
+	-0.0725642f,
+	-0.229514f,
+	0.969023f,
+	-0.0912046f,
+	-0.218972f,
+	0.967608f,
+	-0.125639f,
+	-0.212632f,
+	0.976006f,
+	-0.0469096f,
+	-0.218674f,
+	0.974967f,
+	-0.0402565f,
+	-0.122558f,
+	0.989962f,
+	-0.0703905f,
+	0.0166378f,
+	0.999654f,
+	0.0203946f,
+	-0.0104674f,
+	0.996634f,
+	0.0813074f,
+	-0.0169459f,
+	0.959611f,
+	0.28082f,
+	-0.0960206f,
+	0.935549f,
+	0.339894f,
+	-0.167668f,
+	0.926307f,
+	0.337405f,
+	-0.198261f,
+	0.909687f,
+	0.364915f,
+	-0.193335f,
+	0.935754f,
+	0.294935f,
+	-0.259424f,
+	0.960196f,
+	0.103554f,
+	-0.126539f,
+	0.989254f,
+	0.073239f,
+	0.0445245f,
+	0.981975f,
+	0.183692f,
+	0.070195f,
+	0.9396f,
+	0.334999f,
+	0.116045f,
+	0.901991f,
+	0.415867f,
+	0.160437f,
+	0.912696f,
+	0.375828f,
+	-0.00552585f,
+	0.963507f,
+	0.267627f,
+	-0.111729f,
+	0.971129f,
+	0.210774f,
+	0.00935468f,
+	0.964114f,
+	0.265323f,
+	0.084172f,
+	0.968508f,
+	0.234323f,
+	0.13752f,
+	0.967988f,
+	0.209968f,
+	0.208575f,
+	0.947382f,
+	0.242826f,
+	0.289545f,
+	0.920265f,
+	0.263203f,
+	0.228797f,
+	0.929214f,
+	0.290195f,
+	0.185013f,
+	0.916649f,
+	0.354295f,
+	0.160823f,
+	0.950358f,
+	0.266374f,
+	0.183734f,
+	0.959776f,
+	0.212302f,
+	0.0865279f,
+	0.982909f,
+	0.162492f,
+	0.143782f,
+	0.963199f,
+	0.227098f,
+	-0.40108f,
+	0.898526f,
+	-0.178287f,
+	-0.447805f,
+	0.881163f,
+	-0.15173f,
+	-0.619629f,
+	0.769135f,
+	-0.156501f,
+	-0.663764f,
+	0.743697f,
+	-0.0795752f,
+	-0.534645f,
+	0.83883f,
+	-0.102567f,
+	-0.293541f,
+	0.950588f,
+	-0.101077f,
+	-0.0154638f,
+	0.998684f,
+	-0.048892f,
+	0.170364f,
+	0.984269f,
+	-0.0468065f,
+	0.272586f,
+	0.961403f,
+	-0.0374194f,
+	0.276742f,
+	0.955139f,
+	-0.105472f,
+	0.3572f,
+	0.929651f,
+	-0.0903144f,
+	0.185848f,
+	0.967712f,
+	-0.170277f,
+	-0.00167559f,
+	0.978573f,
+	-0.205892f,
+	0.0698456f,
+	0.971595f,
+	-0.226108f,
+	0.0821889f,
+	0.985623f,
+	-0.147624f,
+	-0.0376538f,
+	0.998466f,
+	-0.0405822f,
+	-0.0983702f,
+	0.988409f,
+	-0.115634f,
+	-0.140633f,
+	0.987279f,
+	-0.0741791f,
+	-0.185061f,
+	0.981813f,
+	-0.0423742f,
+	-0.0718387f,
+	0.997236f,
+	0.0189748f,
+	0.00846681f,
+	0.991398f,
+	0.130611f,
+	0.00870324f,
+	0.999937f,
+	0.00714861f,
+	0.043927f,
+	0.984772f,
+	-0.168207f,
+	0.173423f,
+	0.967972f,
+	-0.181535f,
+	0.363952f,
+	0.925731f,
+	-0.10277f,
+	0.415083f,
+	0.906279f,
+	-0.0797799f,
+	0.295656f,
+	0.934439f,
+	-0.198525f,
+	0.285411f,
+	0.94244f,
+	-0.174208f,
+	0.286359f,
+	0.952372f,
+	-0.104818f,
+	0.274f,
+	0.954057f,
+	-0.121243f,
+	0.125082f,
+	0.985323f,
+	-0.116157f,
+	-0.0728358f,
+	0.994219f,
+	-0.0788892f,
+	-0.183935f,
+	0.981488f,
+	-0.0533801f,
+	-0.254614f,
+	0.966975f,
+	0.0114848f,
+	-0.238556f,
+	0.965368f,
+	0.105624f,
+	-0.207746f,
+	0.971319f,
+	0.115674f,
+	-0.215469f,
+	0.971204f,
+	0.101667f,
+	-0.267107f,
+	0.96138f,
+	0.0663435f,
+	-0.207576f,
+	0.97646f,
+	0.0586408f,
+	-0.117358f,
+	0.991748f,
+	0.0516096f,
+	-0.0500459f,
+	0.994852f,
+	0.0881198f,
+	-0.093813f,
+	0.986665f,
+	0.133006f,
+	-0.152698f,
+	0.969858f,
+	0.18989f,
+	-0.1251f,
+	0.953778f,
+	0.273236f,
+	-0.165614f,
+	0.925222f,
+	0.341373f,
+	-0.185498f,
+	0.929562f,
+	0.3186f,
+	-0.115032f,
+	0.960173f,
+	0.254626f,
+	-0.110794f,
+	0.97049f,
+	0.214181f,
+	-0.10146f,
+	0.992209f,
+	0.072301f,
+	-0.111958f,
+	0.99337f,
+	0.026117f,
+	-0.0975457f,
+	0.980844f,
+	0.168611f,
+	0.086247f,
+	0.976994f,
+	0.195051f,
+	0.241113f,
+	0.947591f,
+	0.20961f,
+	0.0868755f,
+	0.959222f,
+	0.268972f,
+	-0.141994f,
+	0.949853f,
+	0.278599f,
+	-0.0178282f,
+	0.934163f,
+	0.356401f,
+	0.0726972f,
+	0.940594f,
+	0.331659f,
+	0.165529f,
+	0.917627f,
+	0.361333f,
+	0.223743f,
+	0.920886f,
+	0.319231f,
+	0.302189f,
+	0.900958f,
+	0.311378f,
+	0.181249f,
+	0.939198f,
+	0.291642f,
+	0.15269f,
+	0.934294f,
+	0.32215f,
+	0.181639f,
+	0.932767f,
+	0.311371f,
+	0.174351f,
+	0.925291f,
+	0.336805f,
+	0.107261f,
+	0.938861f,
+	0.327163f,
+	0.0621733f,
+	0.949825f,
+	0.306542f,
+	-0.336425f,
+	0.924181f,
+	-0.180852f,
+	-0.467727f,
+	0.856958f,
+	-0.216458f,
+	-0.602238f,
+	0.781026f,
+	-0.165251f,
+	-0.647361f,
+	0.734151f,
+	-0.204809f,
+	-0.50962f,
+	0.821617f,
+	-0.255407f,
+	-0.329682f,
+	0.908003f,
+	-0.258533f,
+	-0.0514578f,
+	0.97257f,
+	-0.226846f,
+	0.197411f,
+	0.959315f,
+	-0.201849f,
+	0.264136f,
+	0.946231f,
+	-0.186758f,
+	0.271989f,
+	0.947232f,
+	-0.169627f,
+	0.342182f,
+	0.926412f,
+	-0.157076f,
+	0.226068f,
+	0.960114f,
+	-0.164544f,
+	0.0298714f,
+	0.986995f,
+	-0.157954f,
+	0.0947848f,
+	0.979734f,
+	-0.176458f,
+	0.0184686f,
+	0.978597f,
+	-0.204958f,
+	-0.115417f,
+	0.979217f,
+	-0.166771f,
+	-0.133289f,
+	0.987752f,
+	-0.0811202f,
+	-0.254272f,
+	0.966705f,
+	0.0287551f,
+	-0.238007f,
+	0.962858f,
+	0.127508f,
+	-0.0805244f,
+	0.989118f,
+	0.123135f,
+	0.0609568f,
+	0.996652f,
+	0.0544921f,
+	0.185345f,
+	0.981121f,
+	-0.0552078f,
+	0.246025f,
+	0.947034f,
+	-0.206392f,
+	0.188933f,
+	0.898455f,
+	-0.396338f,
+	0.253355f,
+	0.896162f,
+	-0.364288f,
+	0.431339f,
+	0.877591f,
+	-0.209237f,
+	0.33179f,
+	0.90994f,
+	-0.248847f,
+	0.173449f,
+	0.964884f,
+	-0.197267f,
+	0.195848f,
+	0.971573f,
+	-0.133f,
+	0.242458f,
+	0.968164f,
+	-0.0622215f,
+	0.0872514f,
+	0.995924f,
+	0.0228468f,
+	-0.104392f,
+	0.994289f,
+	0.0221861f,
+	-0.212909f,
+	0.976423f,
+	0.0355982f,
+	-0.329497f,
+	0.936369f,
+	0.121017f,
+	-0.322708f,
+	0.91595f,
+	0.238528f,
+	-0.206447f,
+	0.929806f,
+	0.304697f,
+	-0.167225f,
+	0.947523f,
+	0.272462f,
+	-0.184928f,
+	0.959175f,
+	0.213976f,
+	-0.173343f,
+	0.972643f,
+	0.154651f,
+	-0.113658f,
+	0.986612f,
+	0.116951f,
+	-0.0855668f,
+	0.994338f,
+	0.0630098f,
+	-0.114452f,
+	0.992427f,
+	0.0446133f,
+	-0.159653f,
+	0.986324f,
+	0.0409453f,
+	-0.238644f,
+	0.971105f,
+	-0.00174015f,
+	-0.263001f,
+	0.962569f,
+	0.0655076f,
+	-0.150786f,
+	0.97653f,
+	0.153794f,
+	-0.0789227f,
+	0.973225f,
+	0.21588f,
+	-0.0862836f,
+	0.967962f,
+	0.235807f,
+	0.0429765f,
+	0.969236f,
+	0.242351f,
+	-0.0440941f,
+	0.992467f,
+	0.114305f,
+	-0.115348f,
+	0.992717f,
+	-0.0347649f,
+	0.0790257f,
+	0.995351f,
+	-0.0550642f,
+	0.126473f,
+	0.98592f,
+	0.109395f,
+	-0.0409487f,
+	0.953557f,
+	0.298417f,
+	-0.206016f,
+	0.913735f,
+	0.350208f,
+	-0.0633912f,
+	0.92675f,
+	0.370293f,
+	0.0785739f,
+	0.913264f,
+	0.399719f,
+	0.177609f,
+	0.899902f,
+	0.398285f,
+	0.238034f,
+	0.923241f,
+	0.301604f,
+	0.255943f,
+	0.926508f,
+	0.27582f,
+	0.232022f,
+	0.914012f,
+	0.332787f,
+	0.162081f,
+	0.936068f,
+	0.312259f,
+	0.177513f,
+	0.926269f,
+	0.332437f,
+	0.185532f,
+	0.921601f,
+	0.340924f,
+	0.173632f,
+	0.950356f,
+	0.258214f,
+	0.111166f,
+	0.980225f,
+	0.163712f,
+	-0.0923042f,
+	0.995727f,
+	-0.00270435f,
+	-0.408896f,
+	0.902709f,
+	-0.133863f,
+	-0.602302f,
+	0.79183f,
+	-0.10118f,
+	-0.624884f,
+	0.765307f,
+	-0.154352f,
+	-0.552184f,
+	0.809036f,
+	-0.201379f,
+	-0.343811f,
+	0.917937f,
+	-0.197956f,
+	-0.0748905f,
+	0.960991f,
+	-0.266248f,
+	0.134998f,
+	0.958099f,
+	-0.252631f,
+	0.206547f,
+	0.962195f,
+	-0.177534f,
+	0.264489f,
+	0.960553f,
+	-0.0859237f,
+	0.340814f,
+	0.939333f,
+	-0.0387315f,
+	0.235136f,
+	0.971602f,
+	-0.0264814f,
+	0.0144037f,
+	0.991275f,
+	-0.131023f,
+	0.053242f,
+	0.991683f,
+	-0.117173f,
+	0.0920982f,
+	0.995717f,
+	0.00816044f,
+	-0.164789f,
+	0.980567f,
+	-0.106454f,
+	-0.239234f,
+	0.97035f,
+	-0.0344802f,
+	-0.316227f,
+	0.948287f,
+	0.0274269f,
+	-0.260328f,
+	0.965493f,
+	0.00728909f,
+	-0.00635978f,
+	0.999169f,
+	0.0402508f,
+	0.152101f,
+	0.988094f,
+	-0.023159f,
+	0.261272f,
+	0.960304f,
+	-0.0977355f,
+	0.363311f,
+	0.923635f,
+	-0.122082f,
+	0.303719f,
+	0.94151f,
+	-0.145994f,
+	0.209258f,
+	0.960639f,
+	-0.182713f,
+	0.299827f,
+	0.935978f,
+	-0.184526f,
+	0.310225f,
+	0.948937f,
+	-0.0572597f,
+	0.134013f,
+	0.988326f,
+	-0.0724722f,
+	0.173294f,
+	0.983169f,
+	-0.0578515f,
+	0.150596f,
+	0.988589f,
+	-0.00352276f,
+	0.0218728f,
+	0.99535f,
+	0.093809f,
+	-0.090936f,
+	0.980927f,
+	0.171796f,
+	-0.253868f,
+	0.938693f,
+	0.233251f,
+	-0.400767f,
+	0.870372f,
+	0.286074f,
+	-0.392418f,
+	0.877786f,
+	0.274773f,
+	-0.219224f,
+	0.925755f,
+	0.308089f,
+	-0.114269f,
+	0.92983f,
+	0.349798f,
+	-0.147993f,
+	0.921652f,
+	0.358685f,
+	-0.138523f,
+	0.925121f,
+	0.353501f,
+	-0.0290531f,
+	0.945854f,
+	0.32329f,
+	0.0440242f,
+	0.978167f,
+	0.203106f,
+	-0.0576599f,
+	0.997178f,
+	0.0480716f,
+	-0.156038f,
+	0.987653f,
+	-0.0139414f,
+	-0.143901f,
+	0.989541f,
+	-0.0100722f,
+	-0.293059f,
+	0.951458f,
+	-0.0940478f,
+	-0.298958f,
+	0.953936f,
+	-0.0251005f,
+	-0.203233f,
+	0.972711f,
+	0.111937f,
+	-0.134891f,
+	0.965356f,
+	0.223367f,
+	-0.0182075f,
+	0.958686f,
+	0.283884f,
+	0.123188f,
+	0.934113f,
+	0.33505f,
+	0.0872404f,
+	0.983488f,
+	0.15856f,
+	0.00440122f,
+	0.999845f,
+	-0.0170726f,
+	-0.143813f,
+	0.987727f,
+	0.0609306f,
+	-0.192356f,
+	0.942318f,
+	0.273927f,
+	-0.141157f,
+	0.926207f,
+	0.349593f,
+	-0.0674076f,
+	0.959831f,
+	0.272363f,
+	0.0730938f,
+	0.959591f,
+	0.27174f,
+	0.173541f,
+	0.961002f,
+	0.215311f,
+	0.369237f,
+	0.888798f,
+	0.271483f,
+	0.277281f,
+	0.944196f,
+	0.177789f,
+	0.215184f,
+	0.95909f,
+	0.183961f,
+	0.13088f,
+	0.973624f,
+	0.186887f,
+	0.130607f,
+	0.953976f,
+	0.269946f,
+	0.212637f,
+	0.930888f,
+	0.297042f,
+	0.306976f,
+	0.920481f,
+	0.241829f,
+	0.280289f,
+	0.947029f,
+	0.156763f,
+	0.0123331f,
+	0.988431f,
+	0.151171f,
+	-0.297868f,
+	0.952288f,
+	0.0664969f,
+	-0.612229f,
+	0.786332f,
+	-0.0828155f,
+	-0.600387f,
+	0.789438f,
+	-0.127758f,
+	-0.542733f,
+	0.826042f,
+	-0.151972f,
+	-0.320126f,
+	0.93364f,
+	-0.160733f,
+	0.000589343f,
+	0.981171f,
+	-0.193142f,
+	0.0980808f,
+	0.971507f,
+	-0.215763f,
+	0.124748f,
+	0.986178f,
+	-0.109047f,
+	0.199191f,
+	0.978521f,
+	-0.0531043f,
+	0.247764f,
+	0.965734f,
+	-0.0772702f,
+	0.318214f,
+	0.948019f,
+	-0.000766246f,
+	0.183917f,
+	0.97162f,
+	-0.148756f,
+	-0.0488566f,
+	0.965709f,
+	-0.25499f,
+	-0.0165518f,
+	0.99654f,
+	-0.0814512f,
+	-0.0793375f,
+	0.996823f,
+	-0.00696945f,
+	-0.310737f,
+	0.950344f,
+	-0.0169863f,
+	-0.292329f,
+	0.952706f,
+	0.0830406f,
+	-0.217409f,
+	0.975529f,
+	0.0328f,
+	-0.044323f,
+	0.995765f,
+	-0.0805443f,
+	0.185778f,
+	0.977354f,
+	-0.101323f,
+	0.271832f,
+	0.958328f,
+	-0.0878372f,
+	0.32088f,
+	0.946924f,
+	0.019279f,
+	0.252443f,
+	0.960909f,
+	0.113697f,
+	0.290552f,
+	0.947257f,
+	0.135217f,
+	0.289238f,
+	0.957058f,
+	-0.0195476f,
+	0.286171f,
+	0.957114f,
+	0.0451517f,
+	0.220997f,
+	0.975269f,
+	0.00320969f,
+	0.0994052f,
+	0.991378f,
+	-0.0853655f,
+	0.0429034f,
+	0.994069f,
+	0.099932f,
+	-0.0709962f,
+	0.952332f,
+	0.296687f,
+	-0.214284f,
+	0.897012f,
+	0.38659f,
+	-0.318505f,
+	0.838002f,
+	0.443066f,
+	-0.352211f,
+	0.849573f,
+	0.392649f,
+	-0.30013f,
+	0.898851f,
+	0.319356f,
+	-0.250783f,
+	0.928599f,
+	0.273517f,
+	-0.200191f,
+	0.919896f,
+	0.337217f,
+	-0.179596f,
+	0.907951f,
+	0.378643f,
+	-0.135043f,
+	0.919145f,
+	0.370049f,
+	0.0368434f,
+	0.920312f,
+	0.389447f,
+	0.16581f,
+	0.924682f,
+	0.34274f,
+	0.0946402f,
+	0.961136f,
+	0.259346f,
+	-0.111217f,
+	0.985094f,
+	0.131228f,
+	-0.13188f,
+	0.98641f,
+	0.0979915f,
+	-0.254562f,
+	0.966634f,
+	0.028585f,
+	-0.324299f,
+	0.94515f,
+	-0.0390035f,
+	-0.293729f,
+	0.954471f,
+	-0.0520494f,
+	-0.247862f,
+	0.966889f,
+	0.0607495f,
+	-0.0794894f,
+	0.980131f,
+	0.181727f,
+	0.101373f,
+	0.964007f,
+	0.245794f,
+	0.197084f,
+	0.947574f,
+	0.251517f,
+	0.177833f,
+	0.964662f,
+	0.194431f,
+	-0.161149f,
+	0.986485f,
+	0.0296539f,
+	-0.316387f,
+	0.94824f,
+	0.02721f,
+	-0.207789f,
+	0.976057f,
+	0.0643106f,
+	-0.00905536f,
+	0.99298f,
+	0.117933f,
+	0.141544f,
+	0.987983f,
+	0.062088f,
+	0.189336f,
+	0.98168f,
+	-0.0213574f,
+	0.273454f,
+	0.960225f,
+	0.0564811f,
+	0.315806f,
+	0.930776f,
+	0.184181f,
+	0.235283f,
+	0.955417f,
+	0.17838f,
+	0.124851f,
+	0.982004f,
+	0.141708f,
+	0.0792257f,
+	0.989953f,
+	0.117114f,
+	0.210835f,
+	0.9739f,
+	0.0840678f,
+	0.31429f,
+	0.942479f,
+	0.113817f,
+	0.350241f,
+	0.914076f,
+	0.20444f,
+	0.0694749f,
+	0.983151f,
+	0.169077f,
+	-0.169784f,
+	0.982476f,
+	0.076909f,
+	-0.507716f,
+	0.850133f,
+	-0.139637f,
+	-0.564212f,
+	0.800379f,
+	-0.202629f,
+	-0.514428f,
+	0.829332f,
+	-0.218112f,
+	-0.369417f,
+	0.885582f,
+	-0.28156f,
+	0.00180169f,
+	0.974596f,
+	-0.223965f,
+	0.0258344f,
+	0.976386f,
+	-0.214484f,
+	-0.024f,
+	0.996868f,
+	-0.0753534f,
+	0.239975f,
+	0.969587f,
+	0.0481022f,
+	0.34797f,
+	0.931588f,
+	-0.105173f,
+	0.316295f,
+	0.909782f,
+	-0.268803f,
+	0.250422f,
+	0.912989f,
+	-0.322087f,
+	-0.0369252f,
+	0.950156f,
+	-0.30958f,
+	-0.207502f,
+	0.950188f,
+	-0.232562f,
+	-0.167975f,
+	0.985706f,
+	-0.0129903f,
+	-0.315712f,
+	0.948273f,
+	0.0332206f,
+	-0.386969f,
+	0.921609f,
+	-0.0298463f,
+	-0.12805f,
+	0.991662f,
+	0.0144567f,
+	0.102711f,
+	0.991948f,
+	-0.0740863f,
+	0.21217f,
+	0.967879f,
+	-0.134884f,
+	0.167738f,
+	0.98185f,
+	-0.0885116f,
+	0.176293f,
+	0.984226f,
+	0.0148055f,
+	0.233609f,
+	0.968608f,
+	0.0850021f,
+	0.30166f,
+	0.950058f,
+	0.0799509f,
+	0.387591f,
+	0.914349f,
+	0.117215f,
+	0.244561f,
+	0.968825f,
+	0.0395933f,
+	0.294792f,
+	0.954101f,
+	0.0528114f,
+	0.0843374f,
+	0.996399f,
+	0.00873819f,
+	-0.221704f,
+	0.963341f,
+	0.151067f,
+	-0.335663f,
+	0.86809f,
+	0.365719f,
+	-0.262618f,
+	0.850841f,
+	0.455085f,
+	-0.222709f,
+	0.867235f,
+	0.445313f,
+	-0.24917f,
+	0.884312f,
+	0.39485f,
+	-0.238336f,
+	0.907466f,
+	0.345978f,
+	-0.270997f,
+	0.917236f,
+	0.291956f,
+	-0.229194f,
+	0.914337f,
+	0.333853f,
+	-0.15897f,
+	0.933059f,
+	0.322692f,
+	-0.100911f,
+	0.956766f,
+	0.272794f,
+	-0.0211523f,
+	0.974532f,
+	0.223248f,
+	0.201297f,
+	0.933635f,
+	0.29632f,
+	0.155914f,
+	0.954519f,
+	0.254134f,
+	-0.0218294f,
+	0.971898f,
+	0.234389f,
+	-0.079809f,
+	0.976613f,
+	0.199646f,
+	-0.0874479f,
+	0.990326f,
+	0.10774f,
+	-0.258167f,
+	0.959037f,
+	-0.116608f,
+	-0.306401f,
+	0.945943f,
+	-0.106352f,
+	-0.341562f,
+	0.936596f,
+	-0.0782577f,
+	-0.199458f,
+	0.979359f,
+	-0.0327519f,
+	0.0464294f,
+	0.997405f,
+	0.0550308f,
+	0.191208f,
+	0.978076f,
+	0.0825056f,
+	0.238583f,
+	0.96711f,
+	0.0881811f,
+	-0.0888379f,
+	0.993271f,
+	0.0743033f,
+	-0.264236f,
+	0.955782f,
+	0.129075f,
+	-0.188913f,
+	0.981529f,
+	0.0302016f,
+	-0.0145673f,
+	0.997134f,
+	-0.0742444f,
+	0.169633f,
+	0.978852f,
+	-0.114338f,
+	0.20381f,
+	0.976959f,
+	-0.0633407f,
+	0.175314f,
+	0.984354f,
+	-0.0176521f,
+	0.240514f,
+	0.967819f,
+	0.0740208f,
+	0.244396f,
+	0.964775f,
+	0.0973589f,
+	0.18832f,
+	0.980026f,
+	0.0639107f,
+	0.156937f,
+	0.987568f,
+	-0.00896143f,
+	0.262584f,
+	0.963481f,
+	-0.0524761f,
+	0.165405f,
+	0.986171f,
+	-0.0103631f,
+	0.180443f,
+	0.960877f,
+	0.210132f,
+	0.22428f,
+	0.955199f,
+	0.193116f,
+	0.0674282f,
+	0.994387f,
+	0.0815297f,
+	-0.367623f,
+	0.911009f,
+	-0.186858f,
+	-0.569756f,
+	0.78903f,
+	-0.229805f,
+	-0.492917f,
+	0.847419f,
+	-0.197265f,
+	-0.366141f,
+	0.895981f,
+	-0.251313f,
+	-0.0646011f,
+	0.969824f,
+	-0.235091f,
+	0.018291f,
+	0.976889f,
+	-0.212961f,
+	-0.170757f,
+	0.95698f,
+	-0.234588f,
+	0.158661f,
+	0.98264f,
+	-0.0961541f,
+	0.509439f,
+	0.859861f,
+	-0.0333235f,
+	0.45757f,
+	0.865797f,
+	-0.202548f,
+	0.211042f,
+	0.949174f,
+	-0.233516f,
+	-0.116125f,
+	0.987892f,
+	-0.102876f,
+	-0.347298f,
+	0.937329f,
+	-0.028262f,
+	-0.3353f,
+	0.938887f,
+	0.0778782f,
+	-0.281604f,
+	0.948411f,
+	0.145656f,
+	-0.254278f,
+	0.964997f,
+	0.0642133f,
+	-0.124948f,
+	0.985399f,
+	-0.115656f,
+	0.137997f,
+	0.981596f,
+	-0.132006f,
+	0.145883f,
+	0.979226f,
+	-0.140833f,
+	0.128056f,
+	0.990732f,
+	-0.0452937f,
+	0.135002f,
+	0.989818f,
+	-0.0451192f,
+	0.250583f,
+	0.968082f,
+	-0.00493589f,
+	0.249752f,
+	0.966686f,
+	-0.056052f,
+	0.354812f,
+	0.933896f,
+	0.0441336f,
+	0.303438f,
+	0.951308f,
+	0.0542095f,
+	0.224177f,
+	0.96836f,
+	0.10965f,
+	0.0241424f,
+	0.959753f,
+	0.279804f,
+	-0.360787f,
+	0.871516f,
+	0.332105f,
+	-0.379082f,
+	0.837086f,
+	0.394442f,
+	-0.267154f,
+	0.880877f,
+	0.390749f,
+	-0.209592f,
+	0.899886f,
+	0.382462f,
+	-0.280017f,
+	0.899934f,
+	0.33423f,
+	-0.205094f,
+	0.90311f,
+	0.377265f,
+	-0.215487f,
+	0.908768f,
+	0.35736f,
+	-0.222303f,
+	0.927919f,
+	0.299247f,
+	-0.133955f,
+	0.964793f,
+	0.226343f,
+	-0.0310722f,
+	0.978213f,
+	0.205265f,
+	0.00222901f,
+	0.986522f,
+	0.163613f,
+	0.163026f,
+	0.975343f,
+	0.148754f,
+	0.222032f,
+	0.968535f,
+	0.112436f,
+	-0.0591592f,
+	0.996482f,
+	0.0593585f,
+	-0.0736093f,
+	0.986012f,
+	0.149538f,
+	0.0883465f,
+	0.986402f,
+	0.138585f,
+	-0.129755f,
+	0.988677f,
+	-0.0753772f,
+	-0.360418f,
+	0.926521f,
+	-0.10797f,
+	-0.325602f,
+	0.942448f,
+	-0.0759939f,
+	-0.212184f,
+	0.970083f,
+	-0.117968f,
+	-0.0173686f,
+	0.99664f,
+	-0.0800487f,
+	0.199307f,
+	0.979749f,
+	-0.0191744f,
+	0.207601f,
+	0.977585f,
+	-0.0350739f,
+	-0.111673f,
+	0.993337f,
+	0.0284751f,
+	-0.348081f,
+	0.937445f,
+	0.00599776f,
+	-0.0214784f,
+	0.998661f,
+	0.0470579f,
+	0.101424f,
+	0.987937f,
+	-0.11702f,
+	0.14864f,
+	0.985437f,
+	-0.0825872f,
+	0.115279f,
+	0.993006f,
+	0.0255073f,
+	0.132171f,
+	0.98902f,
+	0.0661133f,
+	0.208651f,
+	0.976857f,
+	0.0470664f,
+	0.263292f,
+	0.96404f,
+	0.0361305f,
+	0.248825f,
+	0.968171f,
+	0.0270552f,
+	0.185161f,
+	0.982538f,
+	-0.018271f,
+	0.217415f,
+	0.97571f,
+	0.0268649f,
+	0.0197241f,
+	0.992022f,
+	0.124516f,
+	-0.222642f,
+	0.960275f,
+	0.168234f,
+	0.132211f,
+	0.987109f,
+	0.0902005f,
+	0.194249f,
+	0.96722f,
+	0.163561f,
+	-0.121192f,
+	0.992517f,
+	0.0149198f,
+	-0.530811f,
+	0.812343f,
+	-0.241533f,
+	-0.504434f,
+	0.808747f,
+	-0.302447f,
+	-0.34313f,
+	0.885425f,
+	-0.313504f,
+	-0.137778f,
+	0.93664f,
+	-0.322061f,
+	0.0757018f,
+	0.968813f,
+	-0.235947f,
+	-0.132891f,
+	0.938587f,
+	-0.318425f,
+	0.0404124f,
+	0.947798f,
+	-0.316301f,
+	0.44786f,
+	0.871235f,
+	-0.200923f,
+	0.490699f,
+	0.867082f,
+	-0.0859319f,
+	0.104719f,
+	0.99418f,
+	-0.0252995f,
+	-0.266739f,
+	0.955461f,
+	0.126271f,
+	-0.36926f,
+	0.905342f,
+	0.209771f,
+	-0.330235f,
+	0.922316f,
+	0.200695f,
+	-0.269586f,
+	0.955277f,
+	0.121531f,
+	-0.151874f,
+	0.986716f,
+	0.0576671f,
+	-0.0142621f,
+	0.999832f,
+	-0.0115305f,
+	0.159425f,
+	0.986955f,
+	-0.0224599f,
+	0.153623f,
+	0.986882f,
+	-0.0496328f,
+	0.106278f,
+	0.991325f,
+	-0.0773283f,
+	0.114508f,
+	0.986134f,
+	-0.120113f,
+	0.21169f,
+	0.974687f,
+	-0.0719165f,
+	0.274634f,
+	0.961096f,
+	-0.0295159f,
+	0.269382f,
+	0.962666f,
+	0.0266079f,
+	0.255851f,
+	0.94689f,
+	0.19478f,
+	-0.00861224f,
+	0.958716f,
+	0.284234f,
+	-0.164949f,
+	0.853283f,
+	0.494671f,
+	-0.299895f,
+	0.797641f,
+	0.523289f,
+	-0.348319f,
+	0.830543f,
+	0.434595f,
+	-0.252787f,
+	0.902204f,
+	0.349467f,
+	-0.200686f,
+	0.920719f,
+	0.334665f,
+	-0.211731f,
+	0.897332f,
+	0.387253f,
+	-0.253565f,
+	0.89104f,
+	0.376502f,
+	-0.186105f,
+	0.884245f,
+	0.42834f,
+	-0.119153f,
+	0.910802f,
+	0.395274f,
+	-0.0259565f,
+	0.945107f,
+	0.325728f,
+	-0.0365208f,
+	0.969055f,
+	0.244127f,
+	0.0217438f,
+	0.965814f,
+	0.258322f,
+	0.21499f,
+	0.950394f,
+	0.224789f,
+	0.314831f,
+	0.941255f,
+	0.12215f,
+	-0.024099f,
+	0.99913f,
+	-0.0340298f,
+	-0.193558f,
+	0.979871f,
+	-0.0488714f,
+	0.141024f,
+	0.987427f,
+	0.0714227f,
+	0.042141f,
+	0.998281f,
+	-0.0407328f,
+	-0.330902f,
+	0.928766f,
+	-0.167024f,
+	-0.316891f,
+	0.928564f,
+	-0.193256f,
+	-0.212611f,
+	0.956496f,
+	-0.199781f,
+	-0.0848317f,
+	0.98296f,
+	-0.163073f,
+	0.159095f,
+	0.98144f,
+	-0.107074f,
+	0.142493f,
+	0.988352f,
+	-0.0534431f,
+	-0.0993206f,
+	0.99343f,
+	0.0568515f,
+	-0.282995f,
+	0.956355f,
+	-0.0727984f,
+	-0.0511781f,
+	0.994657f,
+	-0.0896605f,
+	0.128118f,
+	0.991123f,
+	0.0355009f,
+	0.0178584f,
+	0.998165f,
+	0.057865f,
+	0.0308308f,
+	0.995199f,
+	0.0928875f,
+	0.176093f,
+	0.979878f,
+	0.0939732f,
+	0.250441f,
+	0.967914f,
+	0.0205173f,
+	0.266597f,
+	0.963616f,
+	0.0192599f,
+	0.242746f,
+	0.969766f,
+	0.0250589f,
+	0.198829f,
+	0.979834f,
+	0.0197961f,
+	0.092758f,
+	0.995177f,
+	0.031931f,
+	-0.00514037f,
+	0.987257f,
+	0.15905f,
+	-0.197401f,
+	0.976423f,
+	0.0873538f,
+	0.0947848f,
+	0.990346f,
+	0.101148f,
+	0.11003f,
+	0.98867f,
+	0.102099f,
+	0.0979659f,
+	0.987432f,
+	0.124019f,
+	-0.288467f,
+	0.943192f,
+	-0.16485f,
+	-0.465875f,
+	0.798355f,
+	-0.381562f,
+	-0.320527f,
+	0.848593f,
+	-0.420894f,
+	-0.189264f,
+	0.880141f,
+	-0.435352f,
+	-0.0157309f,
+	0.942454f,
+	-0.333965f,
+	-0.0523924f,
+	0.9528f,
+	-0.299042f,
+	0.0243535f,
+	0.924362f,
+	-0.38074f,
+	0.347438f,
+	0.877508f,
+	-0.330555f,
+	0.339023f,
+	0.92439f,
+	-0.174834f,
+	0.0111821f,
+	0.998297f,
+	0.0572478f,
+	-0.344224f,
+	0.932997f,
+	0.105009f,
+	-0.433099f,
+	0.895278f,
+	0.104414f,
+	-0.282796f,
+	0.937116f,
+	0.204547f,
+	-0.130039f,
+	0.982692f,
+	0.131936f,
+	-0.0814764f,
+	0.996291f,
+	-0.027691f,
+	-0.0200688f,
+	0.997106f,
+	-0.0733289f,
+	0.118984f,
+	0.992345f,
+	-0.0330638f,
+	0.199561f,
+	0.979885f,
+	0.00110984f,
+	0.153394f,
+	0.986654f,
+	-0.0546216f,
+	0.176634f,
+	0.980572f,
+	-0.0853107f,
+	0.13548f,
+	0.982889f,
+	-0.124795f,
+	0.191838f,
+	0.980855f,
+	0.0334985f,
+	0.104996f,
+	0.978045f,
+	0.180009f,
+	0.00782433f,
+	0.923816f,
+	0.382758f,
+	-0.0895214f,
+	0.848914f,
+	0.520894f,
+	-0.239967f,
+	0.84054f,
+	0.485703f,
+	-0.280756f,
+	0.842357f,
+	0.460011f,
+	-0.207606f,
+	0.901917f,
+	0.378742f,
+	-0.122486f,
+	0.94404f,
+	0.306245f,
+	-0.244402f,
+	0.93107f,
+	0.270881f,
+	-0.292773f,
+	0.891472f,
+	0.345777f,
+	-0.276286f,
+	0.909624f,
+	0.310243f,
+	-0.213016f,
+	0.932947f,
+	0.290231f,
+	-0.0942691f,
+	0.953854f,
+	0.28509f,
+	-0.0105057f,
+	0.953135f,
+	0.302364f,
+	0.0307865f,
+	0.936068f,
+	0.35047f,
+	0.0538732f,
+	0.955717f,
+	0.289315f,
+	0.209391f,
+	0.949668f,
+	0.232994f,
+	0.403861f,
+	0.868428f,
+	0.287628f,
+	0.149382f,
+	0.968969f,
+	0.196936f,
+	-0.176548f,
+	0.984269f,
+	0.00674917f,
+	0.0687777f,
+	0.996274f,
+	-0.0520396f,
+	0.147821f,
+	0.988716f,
+	-0.0242998f,
+	-0.223164f,
+	0.968308f,
+	-0.112148f,
+	-0.295488f,
+	0.928787f,
+	-0.2237f,
+	-0.23574f,
+	0.935973f,
+	-0.261496f,
+	-0.100501f,
+	0.963432f,
+	-0.248392f,
+	0.0576299f,
+	0.973773f,
+	-0.220102f,
+	0.0436147f,
+	0.999029f,
+	-0.00621142f,
+	-0.153496f,
+	0.982634f,
+	0.104254f,
+	-0.184805f,
+	0.972589f,
+	0.141133f,
+	-0.14696f,
+	0.984535f,
+	0.0953571f,
+	-0.0211774f,
+	0.989717f,
+	0.141466f,
+	0.0758245f,
+	0.9782f,
+	0.193326f,
+	0.117048f,
+	0.987762f,
+	0.103083f,
+	0.217731f,
+	0.97559f,
+	-0.0285914f,
+	0.270726f,
+	0.959521f,
+	-0.0776314f,
+	0.230415f,
+	0.971747f,
+	-0.0511441f,
+	0.234903f,
+	0.971865f,
+	0.0172727f,
+	0.182122f,
+	0.97948f,
+	0.0863184f,
+	0.0884364f,
+	0.988499f,
+	0.122674f,
+	-0.00977715f,
+	0.999042f,
+	0.0426606f,
+	-0.0304096f,
+	0.999492f,
+	-0.00954367f,
+	0.200711f,
+	0.957383f,
+	0.207686f,
+	0.148405f,
+	0.978101f,
+	0.145929f,
+	0.14921f,
+	0.978785f,
+	0.140417f,
+	0.0273685f,
+	0.999287f,
+	0.0260052f,
+	-0.3017f,
+	0.88706f,
+	-0.349431f,
+	-0.32483f,
+	0.824834f,
+	-0.462746f,
+	-0.238736f,
+	0.866733f,
+	-0.437926f,
+	-0.174101f,
+	0.907603f,
+	-0.382029f,
+	-0.0165261f,
+	0.968715f,
+	-0.247625f,
+	0.078914f,
+	0.949167f,
+	-0.30472f,
+	0.287731f,
+	0.926482f,
+	-0.242571f,
+	0.12793f,
+	0.981688f,
+	-0.141147f,
+	-0.134026f,
+	0.990975f,
+	-0.00233563f,
+	-0.342476f,
+	0.939327f,
+	-0.0193419f,
+	-0.427311f,
+	0.903697f,
+	-0.027138f,
+	-0.353742f,
+	0.934457f,
+	-0.0407041f,
+	-0.055135f,
+	0.997815f,
+	0.0363915f,
+	0.0312575f,
+	0.999385f,
+	0.0158812f,
+	0.00264454f,
+	0.999634f,
+	-0.0269175f,
+	0.0835808f,
+	0.996075f,
+	-0.0291308f,
+	0.150499f,
+	0.987413f,
+	0.0486412f,
+	0.165157f,
+	0.971811f,
+	0.168246f,
+	0.215634f,
+	0.960222f,
+	0.177413f,
+	0.0835282f,
+	0.988765f,
+	0.123967f,
+	-0.00975779f,
+	0.968408f,
+	0.249181f,
+	-0.06977f,
+	0.918125f,
+	0.3901f,
+	-0.139283f,
+	0.878718f,
+	0.456569f,
+	-0.11373f,
+	0.882765f,
+	0.455842f,
+	-0.169944f,
+	0.889011f,
+	0.42518f,
+	-0.209287f,
+	0.894084f,
+	0.395996f,
+	-0.156853f,
+	0.920873f,
+	0.356917f,
+	-0.124966f,
+	0.921391f,
+	0.367997f,
+	-0.29021f,
+	0.888579f,
+	0.355255f,
+	-0.269725f,
+	0.894676f,
+	0.356094f,
+	-0.146199f,
+	0.945073f,
+	0.292342f,
+	-0.175209f,
+	0.971632f,
+	0.15885f,
+	-0.117718f,
+	0.980316f,
+	0.158504f,
+	-0.0825429f,
+	0.966227f,
+	0.244116f,
+	-0.0312586f,
+	0.938703f,
+	0.343308f,
+	0.145253f,
+	0.922109f,
+	0.358632f,
+	0.209296f,
+	0.943478f,
+	0.256992f,
+	0.299421f,
+	0.901575f,
+	0.312265f,
+	0.248395f,
+	0.88619f,
+	0.39111f,
+	0.0914055f,
+	0.966416f,
+	0.240179f,
+	0.127765f,
+	0.989974f,
+	-0.0602251f,
+	0.140331f,
+	0.988333f,
+	-0.0592086f,
+	-0.14269f,
+	0.987394f,
+	-0.0685058f,
+	-0.196659f,
+	0.96924f,
+	-0.147981f,
+	-0.173702f,
+	0.951221f,
+	-0.254961f,
+	-0.143754f,
+	0.948468f,
+	-0.282389f,
+	-0.0849965f,
+	0.99069f,
+	-0.106347f,
+	-0.164159f,
+	0.984178f,
+	0.0666661f,
+	-0.232036f,
+	0.961292f,
+	0.148586f,
+	-0.256871f,
+	0.951713f,
+	0.168109f,
+	-0.0692891f,
+	0.973705f,
+	0.217018f,
+	0.083167f,
+	0.991239f,
+	0.102607f,
+	0.0755656f,
+	0.994003f,
+	-0.07904f,
+	0.210733f,
+	0.972404f,
+	-0.100116f,
+	0.30249f,
+	0.937213f,
+	-0.173582f,
+	0.293071f,
+	0.941554f,
+	-0.166086f,
+	0.154342f,
+	0.975072f,
+	-0.159414f,
+	0.102764f,
+	0.994605f,
+	0.0141294f,
+	0.056079f,
+	0.980415f,
+	0.188792f,
+	0.109909f,
+	0.955557f,
+	0.273554f,
+	0.133139f,
+	0.972499f,
+	0.191102f,
+	0.0554464f,
+	0.995429f,
+	0.0777578f,
+	0.259868f,
+	0.925249f,
+	0.276374f,
+	0.196037f,
+	0.949951f,
+	0.243232f,
+	0.114869f,
+	0.970528f,
+	0.21185f,
+	0.223665f,
+	0.947755f,
+	0.227452f,
+	0.0930818f,
+	0.995219f,
+	-0.0295687f,
+	-0.269847f,
+	0.892223f,
+	-0.362106f,
+	-0.284642f,
+	0.866853f,
+	-0.409321f,
+	-0.255009f,
+	0.880625f,
+	-0.399336f,
+	-0.131932f,
+	0.93993f,
+	-0.314842f,
+	0.0677192f,
+	0.974824f,
+	-0.212442f,
+	0.187299f,
+	0.973952f,
+	-0.127815f,
+	0.0529524f,
+	0.998138f,
+	-0.0302806f,
+	-0.109006f,
+	0.993972f,
+	0.0117426f,
+	-0.296161f,
+	0.95278f,
+	-0.067077f,
+	-0.391399f,
+	0.918205f,
+	-0.0608803f,
+	-0.369652f,
+	0.920023f,
+	-0.130056f,
+	-0.175066f,
+	0.983052f,
+	-0.0544101f,
+	0.0114037f,
+	0.997649f,
+	0.0675687f,
+	-0.0112147f,
+	0.996664f,
+	0.0808418f,
+	0.0734363f,
+	0.988721f,
+	0.130533f,
+	0.0224625f,
+	0.993745f,
+	0.109391f,
+	0.0118323f,
+	0.985875f,
+	0.167063f,
+	0.164185f,
+	0.947186f,
+	0.275466f,
+	0.0854603f,
+	0.916044f,
+	0.391867f,
+	-0.130673f,
+	0.906994f,
+	0.400358f,
+	-0.128332f,
+	0.898319f,
+	0.420183f,
+	-0.0833752f,
+	0.911617f,
+	0.402496f,
+	-0.0573327f,
+	0.932174f,
+	0.357442f,
+	-0.17852f,
+	0.926686f,
+	0.330734f,
+	-0.230606f,
+	0.897072f,
+	0.376939f,
+	-0.191094f,
+	0.893503f,
+	0.406369f,
+	-0.142227f,
+	0.886795f,
+	0.439733f,
+	-0.17679f,
+	0.896492f,
+	0.40626f,
+	-0.238548f,
+	0.945234f,
+	0.222772f,
+	-0.0952672f,
+	0.973092f,
+	0.209801f,
+	-0.096256f,
+	0.964628f,
+	0.245412f,
+	-0.179685f,
+	0.951666f,
+	0.249087f,
+	-0.204503f,
+	0.928081f,
+	0.311197f,
+	-0.0772696f,
+	0.924068f,
+	0.374336f,
+	0.158946f,
+	0.926358f,
+	0.341463f,
+	0.256333f,
+	0.910209f,
+	0.325291f,
+	0.24298f,
+	0.91134f,
+	0.332296f,
+	0.258464f,
+	0.899993f,
+	0.351011f,
+	0.335956f,
+	0.897826f,
+	0.28468f,
+	0.32299f,
+	0.94494f,
+	0.0525965f,
+	0.125001f,
+	0.99187f,
+	-0.0238687f,
+	-0.121525f,
+	0.992278f,
+	-0.0248174f,
+	-0.149564f,
+	0.988264f,
+	-0.0310731f,
+	-0.0664528f,
+	0.99755f,
+	-0.021853f,
+	-0.216702f,
+	0.971886f,
+	-0.0920818f,
+	-0.313688f,
+	0.949511f,
+	-0.0053432f,
+	-0.230579f,
+	0.964148f,
+	0.131349f,
+	-0.200205f,
+	0.977444f,
+	0.06724f,
+	-0.214561f,
+	0.975215f,
+	-0.0540219f,
+	-0.0751922f,
+	0.988525f,
+	-0.131015f,
+	0.196994f,
+	0.973692f,
+	-0.114533f,
+	0.277294f,
+	0.941009f,
+	-0.193932f,
+	0.227557f,
+	0.901482f,
+	-0.368168f,
+	0.240964f,
+	0.919471f,
+	-0.31066f,
+	0.212207f,
+	0.970864f,
+	-0.111317f,
+	0.0629816f,
+	0.997092f,
+	0.0428958f,
+	-0.106678f,
+	0.985091f,
+	0.134967f,
+	-0.0538645f,
+	0.972292f,
+	0.227481f,
+	0.0800601f,
+	0.969345f,
+	0.232295f,
+	0.209708f,
+	0.947853f,
+	0.239995f,
+	0.200719f,
+	0.957631f,
+	0.206531f,
+	0.262538f,
+	0.945755f,
+	0.191366f,
+	0.219609f,
+	0.958448f,
+	0.182068f,
+	0.16942f,
+	0.971857f,
+	0.163679f,
+	0.226298f,
+	0.968297f,
+	0.105781f,
+	0.311569f,
+	0.942438f,
+	0.12139f,
+	0.0252626f,
+	0.999298f,
+	-0.0276703f,
+	-0.250271f,
+	0.93337f,
+	-0.257262f,
+	-0.253906f,
+	0.911858f,
+	-0.322563f,
+	-0.227242f,
+	0.899531f,
+	-0.373102f,
+	-0.0651757f,
+	0.944171f,
+	-0.322945f,
+	0.0757455f,
+	0.97969f,
+	-0.185662f,
+	-0.00346825f,
+	0.999555f,
+	-0.0296364f,
+	-0.101674f,
+	0.994706f,
+	-0.0148914f,
+	-0.257112f,
+	0.961591f,
+	-0.0961018f,
+	-0.383381f,
+	0.91395f,
+	-0.133094f,
+	-0.376104f,
+	0.917884f,
+	-0.12663f,
+	-0.286338f,
+	0.956389f,
+	-0.0577212f,
+	-0.0969792f,
+	0.993405f,
+	0.061176f,
+	-0.0181638f,
+	0.982944f,
+	0.183006f,
+	0.0407231f,
+	0.989025f,
+	0.142023f,
+	0.0858284f,
+	0.987795f,
+	0.129982f,
+	0.0586048f,
+	0.994197f,
+	0.0902062f,
+	0.00131743f,
+	0.999561f,
+	0.0296072f,
+	-0.0615813f,
+	0.973472f,
+	0.220363f,
+	-0.103673f,
+	0.946783f,
+	0.304719f,
+	-0.0728984f,
+	0.963065f,
+	0.259214f,
+	-0.0671535f,
+	0.98356f,
+	0.16763f,
+	-0.0415144f,
+	0.986558f,
+	0.158053f,
+	-0.226194f,
+	0.961315f,
+	0.157196f,
+	-0.322442f,
+	0.916637f,
+	0.236235f,
+	-0.20303f,
+	0.923357f,
+	0.32587f,
+	-0.141662f,
+	0.940817f,
+	0.307889f,
+	-0.0764267f,
+	0.960304f,
+	0.268283f,
+	-0.0942789f,
+	0.977491f,
+	0.188741f,
+	-0.142883f,
+	0.973984f,
+	0.175899f,
+	-0.198273f,
+	0.947542f,
+	0.250702f,
+	-0.198314f,
+	0.931193f,
+	0.305861f,
+	-0.212116f,
+	0.938506f,
+	0.272421f,
+	-0.0469422f,
+	0.977819f,
+	0.204126f,
+	0.196637f,
+	0.969918f,
+	0.1435f,
+	0.210661f,
+	0.950426f,
+	0.228718f,
+	0.210629f,
+	0.90739f,
+	0.363701f,
+	0.274296f,
+	0.882172f,
+	0.382799f,
+	0.402024f,
+	0.855402f,
+	0.326595f,
+	0.442462f,
+	0.866019f,
+	0.232889f,
+	0.128104f,
+	0.97894f,
+	0.158954f,
+	-0.10509f,
+	0.973708f,
+	0.202109f,
+	-0.168744f,
+	0.972176f,
+	0.162479f,
+	-0.102712f,
+	0.980722f,
+	0.166234f,
+	-0.117365f,
+	0.985855f,
+	0.119644f,
+	-0.348177f,
+	0.934585f,
+	-0.0729569f,
+	-0.249993f,
+	0.967414f,
+	-0.040164f,
+	-0.059218f,
+	0.996444f,
+	-0.0599467f,
+	-0.0488698f,
+	0.975685f,
+	-0.21366f,
+	-0.0228314f,
+	0.943327f,
+	-0.331077f,
+	0.144917f,
+	0.936565f,
+	-0.319132f,
+	0.332603f,
+	0.901794f,
+	-0.275938f,
+	0.285592f,
+	0.906866f,
+	-0.309889f,
+	0.0349917f,
+	0.981145f,
+	-0.190079f,
+	-0.0795345f,
+	0.991829f,
+	0.0997459f,
+	-0.0793233f,
+	0.9451f,
+	0.317009f,
+	-0.0879959f,
+	0.940679f,
+	0.327688f,
+	-0.00912821f,
+	0.970457f,
+	0.241099f,
+	0.124716f,
+	0.982357f,
+	0.13936f,
+	0.187981f,
+	0.977561f,
+	0.0950669f,
+	0.255482f,
+	0.951122f,
+	0.173483f,
+	0.297001f,
+	0.952441f,
+	0.0681659f,
+	0.265042f,
+	0.961574f,
+	0.0716068f,
+	0.186715f,
+	0.981446f,
+	0.0436002f,
+	0.255349f,
+	0.964505f,
+	0.0672885f,
+	0.267248f,
+	0.96042f,
+	0.078566f,
+	0.154901f,
+	0.983709f,
+	0.0912232f,
+	-0.0558054f,
+	0.990723f,
+	-0.123913f,
+	-0.190326f,
+	0.930089f,
+	-0.314182f,
+	-0.171804f,
+	0.925365f,
+	-0.337911f,
+	-0.124574f,
+	0.93618f,
+	-0.328706f,
+	-0.0782933f,
+	0.960403f,
+	-0.267387f,
+	-0.15298f,
+	0.970001f,
+	-0.188931f,
+	-0.0717491f,
+	0.993745f,
+	-0.0855706f,
+	-0.147047f,
+	0.986451f,
+	-0.0727437f,
+	-0.378361f,
+	0.919377f,
+	-0.107652f,
+	-0.386168f,
+	0.917464f,
+	-0.0955771f,
+	-0.364818f,
+	0.925918f,
+	-0.097894f,
+	-0.234461f,
+	0.971639f,
+	0.0307667f,
+	-0.0876095f,
+	0.988677f,
+	0.121826f,
+	0.151616f,
+	0.984538f,
+	0.0877402f,
+	0.0730881f,
+	0.996968f,
+	-0.0267174f,
+	0.0661066f,
+	0.997404f,
+	0.0285557f,
+	0.00089126f,
+	0.998637f,
+	0.052186f,
+	-0.169004f,
+	0.978667f,
+	0.116824f,
+	-0.169994f,
+	0.972188f,
+	0.161096f,
+	-0.0375438f,
+	0.966292f,
+	0.254695f,
+	0.0282607f,
+	0.96926f,
+	0.244409f,
+	0.0134123f,
+	0.993493f,
+	0.113096f,
+	-0.245106f,
+	0.969303f,
+	-0.0193377f,
+	-0.4073f,
+	0.913294f,
+	0.000911808f,
+	-0.297873f,
+	0.952205f,
+	0.0676567f,
+	-0.106293f,
+	0.976869f,
+	0.185552f,
+	-0.0629676f,
+	0.97793f,
+	0.199217f,
+	-0.110366f,
+	0.958688f,
+	0.262177f,
+	-0.181956f,
+	0.936769f,
+	0.298926f,
+	-0.212233f,
+	0.945122f,
+	0.248398f,
+	-0.195256f,
+	0.962306f,
+	0.189318f,
+	-0.105775f,
+	0.982974f,
+	0.150248f,
+	0.0268617f,
+	0.999457f,
+	0.0191026f,
+	0.158413f,
+	0.985011f,
+	0.068261f,
+	0.0517671f,
+	0.977028f,
+	0.206729f,
+	0.0576574f,
+	0.95413f,
+	0.293788f,
+	0.234396f,
+	0.901434f,
+	0.363971f,
+	0.437391f,
+	0.816127f,
+	0.377659f,
+	0.504071f,
+	0.803908f,
+	0.315666f,
+	0.133347f,
+	0.946928f,
+	0.292483f,
+	-0.151412f,
+	0.933905f,
+	0.323877f,
+	-0.120106f,
+	0.92207f,
+	0.367915f,
+	-0.00325057f,
+	0.939171f,
+	0.343435f,
+	0.0348166f,
+	0.983178f,
+	0.179299f,
+	-0.135523f,
+	0.990774f,
+	0.00106677f,
+	-0.269937f,
+	0.929173f,
+	-0.252528f,
+	-0.0598233f,
+	0.968739f,
+	-0.240761f,
+	0.0705133f,
+	0.981516f,
+	-0.177915f,
+	0.0411605f,
+	0.966746f,
+	-0.252403f,
+	0.126252f,
+	0.944488f,
+	-0.30332f,
+	0.315542f,
+	0.911296f,
+	-0.264523f,
+	0.160596f,
+	0.976989f,
+	-0.140362f,
+	-0.167382f,
+	0.98071f,
+	0.100946f,
+	-0.298691f,
+	0.934743f,
+	0.192454f,
+	-0.145935f,
+	0.9608f,
+	0.235724f,
+	-0.00307512f,
+	0.970287f,
+	0.241936f,
+	0.110563f,
+	0.982642f,
+	0.148964f,
+	0.216043f,
+	0.97432f,
+	0.0634533f,
+	0.143964f,
+	0.986263f,
+	0.0809867f,
+	0.0914437f,
+	0.980957f,
+	0.17135f,
+	0.140934f,
+	0.985084f,
+	-0.0987321f,
+	0.206841f,
+	0.978337f,
+	0.00859891f,
+	0.190086f,
+	0.979435f,
+	0.0676362f,
+	0.201515f,
+	0.978077f,
+	0.0525072f,
+	0.267937f,
+	0.960786f,
+	0.0714189f,
+	0.246755f,
+	0.968907f,
+	0.0182169f,
+	0.214715f,
+	0.971106f,
+	-0.104168f,
+	-0.0180649f,
+	0.956568f,
+	-0.290949f,
+	-0.219959f,
+	0.899081f,
+	-0.378512f,
+	-0.191729f,
+	0.921961f,
+	-0.336494f,
+	-0.106738f,
+	0.947718f,
+	-0.300729f,
+	-0.152636f,
+	0.943663f,
+	-0.293602f,
+	-0.224106f,
+	0.947646f,
+	-0.227472f,
+	-0.228203f,
+	0.973419f,
+	0.019469f,
+	-0.388401f,
+	0.917519f,
+	0.0854554f,
+	-0.336148f,
+	0.939599f,
+	0.0644837f,
+	-0.402605f,
+	0.913568f,
+	-0.0574625f,
+	-0.305232f,
+	0.952235f,
+	-0.00907982f,
+	-0.096739f,
+	0.995183f,
+	-0.0159156f,
+	0.180076f,
+	0.982792f,
+	0.0411394f,
+	0.136148f,
+	0.986894f,
+	0.0866302f,
+	0.0219341f,
+	0.999371f,
+	0.0278606f,
+	-0.0791566f,
+	0.996134f,
+	0.0381004f,
+	-0.239326f,
+	0.960376f,
+	0.142833f,
+	-0.218166f,
+	0.951783f,
+	0.215666f,
+	-0.166214f,
+	0.94168f,
+	0.292596f,
+	0.0428911f,
+	0.92465f,
+	0.378394f,
+	0.200943f,
+	0.923885f,
+	0.325667f,
+	-0.0783125f,
+	0.985711f,
+	0.149132f,
+	-0.415101f,
+	0.909654f,
+	-0.0148509f,
+	-0.366356f,
+	0.929766f,
+	0.0363078f,
+	-0.239727f,
+	0.962799f,
+	0.124698f,
+	-0.166496f,
+	0.955565f,
+	0.243259f,
+	-0.200219f,
+	0.921854f,
+	0.331809f,
+	-0.112297f,
+	0.932828f,
+	0.342375f,
+	-0.106223f,
+	0.957221f,
+	0.269154f,
+	-0.127872f,
+	0.96503f,
+	0.228835f,
+	-0.0138049f,
+	0.984551f,
+	0.174552f,
+	0.0256733f,
+	0.993774f,
+	0.108417f,
+	0.00728748f,
+	0.973829f,
+	0.227164f,
+	-0.00741294f,
+	0.956693f,
+	0.291004f,
+	0.0683597f,
+	0.974464f,
+	0.213887f,
+	0.177941f,
+	0.966015f,
+	0.187489f,
+	0.424978f,
+	0.876377f,
+	0.226619f,
+	0.505816f,
+	0.827485f,
+	0.243758f,
+	0.166361f,
+	0.911198f,
+	0.376885f,
+	-0.17476f,
+	0.913668f,
+	0.366973f,
+	-0.176728f,
+	0.923512f,
+	0.340431f,
+	0.0722139f,
+	0.943797f,
+	0.322541f,
+	0.177366f,
+	0.957288f,
+	0.228344f,
+	0.0913959f,
+	0.986484f,
+	0.136004f,
+	-0.0297265f,
+	0.993047f,
+	-0.113903f,
+	-0.0869422f,
+	0.951911f,
+	-0.293781f,
+	-0.0450316f,
+	0.952406f,
+	-0.301489f,
+	0.143119f,
+	0.964298f,
+	-0.222813f,
+	0.165675f,
+	0.921893f,
+	-0.350237f,
+	0.164354f,
+	0.949667f,
+	-0.266682f,
+	-0.039757f,
+	0.998354f,
+	0.0413462f,
+	-0.291683f,
+	0.947651f,
+	0.12992f,
+	-0.239728f,
+	0.968947f,
+	0.0605947f,
+	-0.107127f,
+	0.994229f,
+	0.00574708f,
+	-0.00468879f,
+	0.997776f,
+	-0.0664969f,
+	0.179786f,
+	0.983119f,
+	-0.033983f,
+	0.200209f,
+	0.979349f,
+	-0.0281487f,
+	0.0601426f,
+	0.997956f,
+	0.0216006f,
+	-0.0759803f,
+	0.997037f,
+	0.0120005f,
+	0.14599f,
+	0.98347f,
+	-0.107112f,
+	0.111543f,
+	0.987674f,
+	-0.109808f,
+	0.157618f,
+	0.987042f,
+	-0.0300797f,
+	0.250909f,
+	0.967637f,
+	-0.026879f,
+	0.281043f,
+	0.956928f,
+	-0.0728269f,
+	0.296885f,
+	0.954758f,
+	-0.0172396f,
+	0.276747f,
+	0.960894f,
+	-0.00969537f,
+	0.102049f,
+	0.992961f,
+	-0.0601211f,
+	-0.130111f,
+	0.972079f,
+	-0.195279f,
+	-0.17254f,
+	0.923261f,
+	-0.343248f,
+	-0.125309f,
+	0.912244f,
+	-0.390012f,
+	-0.211743f,
+	0.924189f,
+	-0.317868f,
+	-0.376287f,
+	0.901788f,
+	-0.212569f,
+	-0.427638f,
+	0.901509f,
+	-0.0663888f,
+	-0.389415f,
+	0.920624f,
+	0.0283935f,
+	-0.297925f,
+	0.953877f,
+	0.0368632f,
+	-0.273734f,
+	0.961504f,
+	0.0240644f,
+	-0.334113f,
+	0.936286f,
+	-0.108341f,
+	-0.109536f,
+	0.993721f,
+	-0.0228029f,
+	0.0288145f,
+	0.999546f,
+	0.00876748f,
+	0.119784f,
+	0.984043f,
+	0.131571f,
+	0.0511538f,
+	0.994284f,
+	0.0937163f,
+	-0.0752276f,
+	0.983313f,
+	0.165639f,
+	-0.293078f,
+	0.946365f,
+	0.136011f,
+	-0.332793f,
+	0.935954f,
+	0.115063f,
+	-0.225106f,
+	0.941939f,
+	0.249154f,
+	0.0114661f,
+	0.958888f,
+	0.283552f,
+	0.24485f,
+	0.921506f,
+	0.301455f,
+	0.100987f,
+	0.953885f,
+	0.282675f,
+	-0.340266f,
+	0.932035f,
+	0.124616f,
+	-0.415762f,
+	0.898895f,
+	0.138312f,
+	-0.325966f,
+	0.925955f,
+	0.190664f,
+	-0.250966f,
+	0.918836f,
+	0.304559f,
+	-0.221816f,
+	0.898675f,
+	0.378392f,
+	-0.0852583f,
+	0.899614f,
+	0.428282f,
+	-0.0998073f,
+	0.904564f,
+	0.41449f,
+	-0.102816f,
+	0.885513f,
+	0.453096f,
+	0.0414724f,
+	0.91382f,
+	0.403996f,
+	-0.0128006f,
+	0.939036f,
+	0.343581f,
+	-0.0641104f,
+	0.924175f,
+	0.376551f,
+	0.0655361f,
+	0.926269f,
+	0.37112f,
+	0.187467f,
+	0.942186f,
+	0.277743f,
+	0.21985f,
+	0.965692f,
+	0.138218f,
+	0.3812f,
+	0.921864f,
+	0.0696633f,
+	0.433954f,
+	0.878909f,
+	0.197998f,
+	0.0643484f,
+	0.944154f,
+	0.32316f,
+	-0.162002f,
+	0.923385f,
+	0.348016f,
+	-0.0466746f,
+	0.93461f,
+	0.352597f,
+	0.113297f,
+	0.96975f,
+	0.216212f,
+	0.268791f,
+	0.938715f,
+	0.215791f,
+	0.199257f,
+	0.972974f,
+	0.116695f,
+	0.13591f,
+	0.990721f,
+	-0.000598755f,
+	0.098836f,
+	0.989317f,
+	-0.107165f,
+	0.00840194f,
+	0.94937f,
+	-0.314049f,
+	0.0977197f,
+	0.93606f,
+	-0.337997f,
+	0.228369f,
+	0.952655f,
+	-0.20074f,
+	-0.102319f,
+	0.98537f,
+	-0.136295f,
+	-0.210478f,
+	0.975126f,
+	0.0694824f,
+	-0.226245f,
+	0.97389f,
+	-0.0187694f,
+	-0.184535f,
+	0.981701f,
+	-0.0470082f,
+	-0.0356904f,
+	0.995184f,
+	-0.0912977f,
+	0.0448449f,
+	0.980059f,
+	-0.193583f,
+	0.0871766f,
+	0.981936f,
+	-0.167935f,
+	0.149691f,
+	0.986438f,
+	-0.0673319f,
+	0.081336f,
+	0.996451f,
+	-0.021693f,
+	0.0320348f,
+	0.999323f,
+	-0.0181162f,
+	0.0913657f,
+	0.979354f,
+	-0.180329f,
+	0.100696f,
+	0.986931f,
+	-0.125808f,
+	0.108832f,
+	0.988438f,
+	-0.105573f,
+	0.287509f,
+	0.953f,
+	-0.0955498f,
+	0.243655f,
+	0.954139f,
+	-0.173927f,
+	0.160509f,
+	0.983073f,
+	-0.0883436f,
+	0.264497f,
+	0.963724f,
+	0.0357424f,
+	0.162998f,
+	0.986545f,
+	0.0127154f,
+	0.0143391f,
+	0.999851f,
+	0.00965394f,
+	-0.0125406f,
+	0.999093f,
+	-0.0406807f,
+	-0.106874f,
+	0.984584f,
+	-0.138462f,
+	-0.285824f,
+	0.938351f,
+	-0.194429f,
+	-0.419998f,
+	0.877928f,
+	-0.22988f,
+	-0.451562f,
+	0.860313f,
+	-0.236545f,
+	-0.434075f,
+	0.875052f,
+	-0.214154f,
+	-0.338822f,
+	0.927615f,
+	-0.157258f,
+	-0.245036f,
+	0.962096f,
+	-0.119701f,
+	-0.344114f,
+	0.932339f,
+	-0.111035f,
+	-0.226404f,
+	0.972006f,
+	0.0628119f,
+	0.0419787f,
+	0.991974f,
+	0.119273f,
+	0.128473f,
+	0.991295f,
+	0.0288037f,
+	-0.0257017f,
+	0.999564f,
+	0.0145347f,
+	-0.185301f,
+	0.952066f,
+	0.243378f,
+	-0.184541f,
+	0.936895f,
+	0.29694f,
+	-0.273419f,
+	0.950852f,
+	0.145334f,
+	-0.319783f,
+	0.945196f,
+	0.0659039f,
+	-0.035432f,
+	0.98966f,
+	0.138987f,
+	0.220222f,
+	0.955124f,
+	0.19809f,
+	0.125192f,
+	0.96286f,
+	0.239224f,
+	-0.256002f,
+	0.939458f,
+	0.227776f,
+	-0.448892f,
+	0.878586f,
+	0.163043f,
+	-0.385115f,
+	0.893165f,
+	0.232256f,
+	-0.361248f,
+	0.871706f,
+	0.331103f,
+	-0.291851f,
+	0.846516f,
+	0.445235f,
+	-0.17348f,
+	0.85884f,
+	0.481973f,
+	-0.107775f,
+	0.841326f,
+	0.529675f,
+	-0.0921307f,
+	0.850827f,
+	0.517306f,
+	0.0950699f,
+	0.836893f,
+	0.539048f,
+	0.0822562f,
+	0.850572f,
+	0.519385f,
+	0.00749303f,
+	0.916802f,
+	0.399272f,
+	0.0761143f,
+	0.966912f,
+	0.243491f,
+	0.269493f,
+	0.937399f,
+	0.220582f,
+	0.37073f,
+	0.916186f,
+	0.152194f,
+	0.358083f,
+	0.929944f,
+	0.083549f,
+	0.335187f,
+	0.907961f,
+	0.251509f,
+	0.0578141f,
+	0.947361f,
+	0.314904f,
+	-0.166707f,
+	0.957873f,
+	0.233855f,
+	-0.0184246f,
+	0.983369f,
+	0.180682f,
+	0.167068f,
+	0.976917f,
+	0.13312f,
+	0.286534f,
+	0.942354f,
+	0.172822f,
+	0.301062f,
+	0.945554f,
+	0.123648f,
+	0.228175f,
+	0.972518f,
+	0.0463188f,
+	0.216797f,
+	0.97484f,
+	-0.0518194f,
+	0.199106f,
+	0.962895f,
+	-0.18218f,
+	0.00394531f,
+	0.962307f,
+	-0.271937f,
+	-0.0105699f,
+	0.99745f,
+	-0.0705888f,
+	-0.131705f,
+	0.985651f,
+	0.105578f,
+	-0.19725f,
+	0.980353f,
+	0.00065076f,
+	-0.141436f,
+	0.988723f,
+	-0.0492296f,
+	-0.163841f,
+	0.979948f,
+	-0.113394f,
+	0.0189882f,
+	0.981225f,
+	-0.191928f,
+	0.0882705f,
+	0.978772f,
+	-0.18497f,
+	0.0393937f,
+	0.981447f,
+	-0.187645f,
+	0.0729287f,
+	0.986122f,
+	-0.149146f,
+	0.0148824f,
+	0.998969f,
+	-0.0428982f,
+	-0.0177962f,
+	0.999449f,
+	0.0279995f,
+	-0.0162323f,
+	0.963189f,
+	-0.268333f,
+	0.00641467f,
+	0.976357f,
+	-0.216067f,
+	0.107749f,
+	0.98057f,
+	-0.16393f,
+	0.293413f,
+	0.939289f,
+	-0.177892f,
+	0.308304f,
+	0.934826f,
+	-0.17621f,
+	0.101903f,
+	0.952869f,
+	-0.285755f,
+	0.182917f,
+	0.946528f,
+	-0.265755f,
+	0.146405f,
+	0.977668f,
+	-0.15077f,
+	-0.0629734f,
+	0.995858f,
+	-0.0655825f,
+	-0.0448201f,
+	0.998977f,
+	-0.00597126f,
+	-0.0400505f,
+	0.999191f,
+	-0.00375744f,
+	-0.153158f,
+	0.98627f,
+	-0.0617534f,
+	-0.285484f,
+	0.92871f,
+	-0.236637f,
+	-0.448842f,
+	0.826713f,
+	-0.339243f,
+	-0.479202f,
+	0.840256f,
+	-0.253646f,
+	-0.347296f,
+	0.912974f,
+	-0.214157f,
+	-0.288381f,
+	0.931416f,
+	-0.222037f,
+	-0.393139f,
+	0.905395f,
+	-0.160316f,
+	-0.362299f,
+	0.919254f,
+	-0.153982f,
+	0.042344f,
+	0.998556f,
+	-0.0330675f,
+	0.205011f,
+	0.978411f,
+	0.0261187f,
+	-0.127573f,
+	0.99058f,
+	0.0497635f,
+	-0.371574f,
+	0.908811f,
+	0.189723f,
+	-0.216831f,
+	0.928294f,
+	0.302084f,
+	-0.0703165f,
+	0.93644f,
+	0.343708f,
+	-0.232099f,
+	0.969924f,
+	0.0733245f,
+	-0.112472f,
+	0.99344f,
+	-0.0206566f,
+	0.137846f,
+	0.985164f,
+	0.102232f,
+	0.0558694f,
+	0.966778f,
+	0.249437f,
+	-0.236804f,
+	0.911959f,
+	0.335045f,
+	-0.429918f,
+	0.856338f,
+	0.286105f,
+	-0.441526f,
+	0.844766f,
+	0.302366f,
+	-0.455345f,
+	0.82665f,
+	0.330622f,
+	-0.361376f,
+	0.843549f,
+	0.397281f,
+	-0.152799f,
+	0.875871f,
+	0.457714f,
+	-0.118894f,
+	0.891156f,
+	0.437842f,
+	-0.0896442f,
+	0.897342f,
+	0.432135f,
+	0.0157836f,
+	0.897193f,
+	0.441356f,
+	0.112602f,
+	0.854856f,
+	0.5065f,
+	0.219938f,
+	0.859901f,
+	0.460648f,
+	0.288065f,
+	0.92641f,
+	0.242451f,
+	0.293811f,
+	0.955367f,
+	0.0308066f,
+	0.390529f,
+	0.919592f,
+	0.0428713f,
+	0.271277f,
+	0.959279f,
+	0.0786938f,
+	0.217133f,
+	0.949907f,
+	0.22479f,
+	0.0884504f,
+	0.963513f,
+	0.252624f,
+	-0.0236259f,
+	0.986232f,
+	0.163669f,
+	0.0800779f,
+	0.996646f,
+	0.0168362f,
+	0.165418f,
+	0.984838f,
+	-0.0522657f,
+	0.249596f,
+	0.968284f,
+	-0.0113122f,
+	0.338274f,
+	0.940962f,
+	-0.0126639f,
+	0.305431f,
+	0.950632f,
+	-0.0548703f,
+	0.294152f,
+	0.946987f,
+	-0.12919f,
+	0.225417f,
+	0.970184f,
+	-0.0890507f,
+	-0.00713906f,
+	0.99978f,
+	0.0197001f,
+	-0.176932f,
+	0.984214f,
+	-0.00420403f,
+	-0.111846f,
+	0.993652f,
+	0.0120569f,
+	-0.1391f,
+	0.984895f,
+	-0.103119f,
+	-0.088794f,
+	0.987668f,
+	-0.128949f,
+	-0.0465185f,
+	0.96883f,
+	-0.243321f,
+	0.0250763f,
+	0.955082f,
+	-0.295277f,
+	0.0363238f,
+	0.977208f,
+	-0.209152f,
+	0.0515148f,
+	0.981849f,
+	-0.182534f,
+	-0.0181f,
+	0.986039f,
+	-0.165529f,
+	-0.1292f,
+	0.991547f,
+	-0.0118974f,
+	-0.123925f,
+	0.986172f,
+	0.110035f,
+	0.0445182f,
+	0.949745f,
+	-0.309843f,
+	-0.00147152f,
+	0.93224f,
+	-0.361838f,
+	0.114309f,
+	0.919114f,
+	-0.377045f,
+	0.249456f,
+	0.882365f,
+	-0.399004f,
+	0.318339f,
+	0.895336f,
+	-0.311503f,
+	0.245085f,
+	0.904168f,
+	-0.349877f,
+	0.0939131f,
+	0.907167f,
+	-0.410156f,
+	-0.0302879f,
+	0.963667f,
+	-0.265383f,
+	-0.13844f,
+	0.974516f,
+	-0.176503f,
+	-0.0411687f,
+	0.989896f,
+	-0.135687f,
+	-0.00628724f,
+	0.990542f,
+	-0.137063f,
+	-0.112489f,
+	0.976976f,
+	-0.181283f,
+	-0.1315f,
+	0.967086f,
+	-0.217836f,
+	-0.376506f,
+	0.872387f,
+	-0.311743f,
+	-0.531305f,
+	0.793042f,
+	-0.297992f,
+	-0.39351f,
+	0.883689f,
+	-0.253462f,
+	-0.336847f,
+	0.927504f,
+	-0.162083f,
+	-0.393317f,
+	0.917094f,
+	-0.0651222f,
+	-0.321501f,
+	0.93797f,
+	-0.129808f,
+	-0.135804f,
+	0.972419f,
+	-0.189625f,
+	0.0526632f,
+	0.998612f,
+	0.00112608f,
+	-0.194024f,
+	0.972777f,
+	0.126724f,
+	-0.436845f,
+	0.883669f,
+	0.168215f,
+	-0.311688f,
+	0.924669f,
+	0.218719f,
+	-0.0696464f,
+	0.953993f,
+	0.291628f,
+	0.0409792f,
+	0.956788f,
+	0.287884f,
+	-0.0764775f,
+	0.990645f,
+	0.113025f,
+	-0.0364568f,
+	0.989186f,
+	0.142066f,
+	-0.121833f,
+	0.946798f,
+	0.297877f,
+	-0.315082f,
+	0.850341f,
+	0.421476f,
+	-0.377714f,
+	0.797842f,
+	0.469873f,
+	-0.420842f,
+	0.786479f,
+	0.452043f,
+	-0.397492f,
+	0.78965f,
+	0.467389f,
+	-0.380055f,
+	0.83336f,
+	0.401334f,
+	-0.183142f,
+	0.896787f,
+	0.402781f,
+	-0.0888282f,
+	0.916137f,
+	0.3909f,
+	-0.0940934f,
+	0.935116f,
+	0.34162f,
+	0.00386799f,
+	0.937503f,
+	0.347956f,
+	0.10018f,
+	0.944394f,
+	0.313183f,
+	0.280679f,
+	0.93056f,
+	0.235113f,
+	0.465087f,
+	0.85876f,
+	0.215002f,
+	0.41466f,
+	0.904302f,
+	0.101461f,
+	0.364139f,
+	0.929581f,
+	0.0572809f,
+	0.242065f,
+	0.968602f,
+	0.0566915f,
+	0.117842f,
+	0.992149f,
+	0.0418746f,
+	0.148716f,
+	0.982681f,
+	0.110551f,
+	0.0959266f,
+	0.995185f,
+	0.0201233f,
+	0.176327f,
+	0.980433f,
+	-0.0875236f,
+	0.210189f,
+	0.965141f,
+	-0.155959f,
+	0.226725f,
+	0.946611f,
+	-0.229181f,
+	0.330781f,
+	0.920607f,
+	-0.207526f,
+	0.365923f,
+	0.916599f,
+	-0.161081f,
+	0.298516f,
+	0.923753f,
+	-0.239936f,
+	0.0221976f,
+	0.976238f,
+	-0.215559f,
+	-0.104515f,
+	0.994469f,
+	-0.0104162f,
+	-0.0427336f,
+	0.998984f,
+	-0.0143091f,
+	-0.0839971f,
+	0.989572f,
+	-0.117013f,
+	-0.00725244f,
+	0.993108f,
+	-0.116977f,
+	-0.0399839f,
+	0.966361f,
+	-0.254064f,
+	0.00504893f,
+	0.980798f,
+	-0.194961f,
+	-0.018473f,
+	0.987693f,
+	-0.155309f,
+	-0.0253738f,
+	0.987423f,
+	-0.15605f,
+	0.000452807f,
+	0.989468f,
+	-0.144748f,
+	-0.0811148f,
+	0.995994f,
+	-0.0376225f,
+	-0.286969f,
+	0.957515f,
+	0.0285449f,
+	-0.27524f,
+	0.951495f,
+	0.137481f,
+	0.163018f,
+	0.971572f,
+	-0.171676f,
+	0.122581f,
+	0.955248f,
+	-0.269212f,
+	0.130974f,
+	0.917919f,
+	-0.374527f,
+	0.258812f,
+	0.917892f,
+	-0.300816f,
+	0.268244f,
+	0.908354f,
+	-0.320839f,
+	0.223034f,
+	0.911459f,
+	-0.345686f,
+	0.0389184f,
+	0.957275f,
+	-0.28655f,
+	-0.140597f,
+	0.964524f,
+	-0.223439f,
+	-0.145862f,
+	0.970122f,
+	-0.193875f,
+	-0.104111f,
+	0.974098f,
+	-0.200733f,
+	-0.0208986f,
+	0.992723f,
+	-0.118595f,
+	-0.0701237f,
+	0.994147f,
+	-0.08218f,
+	-0.122604f,
+	0.99062f,
+	-0.0603304f,
+	-0.259222f,
+	0.963912f,
+	-0.0606481f,
+	-0.533518f,
+	0.797325f,
+	-0.282189f,
+	-0.48726f,
+	0.821939f,
+	-0.294948f,
+	-0.445665f,
+	0.877532f,
+	-0.176975f,
+	-0.446224f,
+	0.888631f,
+	-0.105925f,
+	-0.296073f,
+	0.952805f,
+	-0.0671049f,
+	-0.124475f,
+	0.991773f,
+	-0.0298685f,
+	-0.112069f,
+	0.99368f,
+	-0.00632266f,
+	-0.24484f,
+	0.957295f,
+	0.15375f,
+	-0.472578f,
+	0.869701f,
+	0.142444f,
+	-0.348902f,
+	0.914252f,
+	0.205937f,
+	-0.110311f,
+	0.945787f,
+	0.30548f,
+	-0.00134709f,
+	0.941519f,
+	0.336957f,
+	0.0293716f,
+	0.928574f,
+	0.369983f,
+	-0.116225f,
+	0.946895f,
+	0.299803f,
+	-0.223618f,
+	0.889099f,
+	0.399372f,
+	-0.413824f,
+	0.817577f,
+	0.400396f,
+	-0.452277f,
+	0.775981f,
+	0.439658f,
+	-0.398113f,
+	0.749968f,
+	0.528257f,
+	-0.374899f,
+	0.784234f,
+	0.494397f,
+	-0.25264f,
+	0.860337f,
+	0.442712f,
+	-0.127446f,
+	0.920564f,
+	0.369215f,
+	-0.018556f,
+	0.935495f,
+	0.352851f,
+	-0.0323754f,
+	0.965116f,
+	0.259814f,
+	0.0357851f,
+	0.98547f,
+	0.166039f,
+	0.195904f,
+	0.976812f,
+	0.0863732f,
+	0.361612f,
+	0.932271f,
+	0.0103395f,
+	0.440593f,
+	0.897705f,
+	0.00204446f,
+	0.433278f,
+	0.895277f,
+	0.103679f,
+	0.385805f,
+	0.912456f,
+	0.136304f,
+	0.326244f,
+	0.9426f,
+	0.0712044f,
+	0.139247f,
+	0.987833f,
+	-0.0692571f,
+	0.107504f,
+	0.992792f,
+	-0.0529845f,
+	0.186477f,
+	0.981836f,
+	-0.0349818f,
+	0.2261f,
+	0.969793f,
+	-0.0915407f,
+	0.319918f,
+	0.94368f,
+	-0.0843796f,
+	0.284455f,
+	0.935881f,
+	-0.207877f,
+	0.26738f,
+	0.950319f,
+	-0.159379f,
+	0.326413f,
+	0.941309f,
+	-0.085975f,
+	0.340028f,
+	0.93811f,
+	-0.0657985f,
+	0.0548427f,
+	0.991972f,
+	-0.113944f,
+	-0.195067f,
+	0.950504f,
+	-0.241849f,
+	-0.0282147f,
+	0.982936f,
+	-0.181769f,
+	-0.0838232f,
+	0.97875f,
+	-0.187144f,
+	0.0287357f,
+	0.988886f,
+	-0.145871f,
+	0.0192345f,
+	0.984318f,
+	-0.175351f,
+	-0.131262f,
+	0.971109f,
+	-0.199292f,
+	-0.0357158f,
+	0.988874f,
+	-0.144408f,
+	0.0171216f,
+	0.989641f,
+	-0.142542f,
+	-0.0610371f,
+	0.990627f,
+	-0.122202f,
+	-0.174272f,
+	0.984646f,
+	-0.0100664f,
+	-0.321779f,
+	0.946758f,
+	0.0104107f,
+	-0.391721f,
+	0.920071f,
+	-0.0049163f,
+	0.251962f,
+	0.967049f,
+	0.0364793f,
+	0.286588f,
+	0.95799f,
+	-0.0110494f,
+	0.190653f,
+	0.96361f,
+	-0.187371f,
+	0.192921f,
+	0.95146f,
+	-0.239803f,
+	0.313234f,
+	0.932132f,
+	-0.181696f,
+	0.220402f,
+	0.968379f,
+	-0.116899f,
+	0.0241557f,
+	0.995754f,
+	-0.0888337f,
+	-0.173138f,
+	0.969731f,
+	-0.172177f,
+	-0.148056f,
+	0.974915f,
+	-0.166191f,
+	-0.121802f,
+	0.976444f,
+	-0.178104f,
+	-0.134617f,
+	0.985638f,
+	-0.10196f,
+	-0.12881f,
+	0.990748f,
+	0.0427476f,
+	-0.193234f,
+	0.979772f,
+	0.0520324f,
+	-0.169584f,
+	0.981577f,
+	0.0880205f,
+	-0.37404f,
+	0.925821f,
+	-0.0543154f,
+	-0.520547f,
+	0.83989f,
+	-0.153672f,
+	-0.499517f,
+	0.851003f,
+	-0.162103f,
+	-0.4353f,
+	0.881523f,
+	-0.182841f,
+	-0.371568f,
+	0.902946f,
+	-0.21593f,
+	-0.165948f,
+	0.980792f,
+	-0.10251f,
+	-0.208618f,
+	0.975931f,
+	-0.0635357f,
+	-0.355123f,
+	0.932394f,
+	0.0673039f,
+	-0.461506f,
+	0.884901f,
+	0.0629418f,
+	-0.443442f,
+	0.893747f,
+	0.0676439f,
+	-0.18907f,
+	0.971969f,
+	0.139742f,
+	-0.0546977f,
+	0.978989f,
+	0.19644f,
+	0.0244551f,
+	0.950588f,
+	0.309492f,
+	-0.115369f,
+	0.932748f,
+	0.341572f,
+	-0.31704f,
+	0.862788f,
+	0.393805f,
+	-0.382907f,
+	0.826411f,
+	0.412829f,
+	-0.514077f,
+	0.784716f,
+	0.346333f,
+	-0.482563f,
+	0.790781f,
+	0.37656f,
+	-0.301253f,
+	0.838125f,
+	0.454745f,
+	-0.149029f,
+	0.885064f,
+	0.440966f,
+	-0.0699981f,
+	0.93986f,
+	0.33431f,
+	0.00541731f,
+	0.96209f,
+	0.272677f,
+	0.0875381f,
+	0.972016f,
+	0.217994f,
+	0.185287f,
+	0.977612f,
+	0.0997159f,
+	0.257792f,
+	0.964794f,
+	-0.0521163f,
+	0.377486f,
+	0.923846f,
+	-0.0633437f,
+	0.414459f,
+	0.907288f,
+	-0.071082f,
+	0.347034f,
+	0.936287f,
+	-0.0541691f,
+	0.366281f,
+	0.930406f,
+	0.0134975f,
+	0.42839f,
+	0.903092f,
+	0.0301138f,
+	0.236883f,
+	0.966501f,
+	-0.0988031f,
+	0.0750179f,
+	0.986987f,
+	-0.142226f,
+	0.187793f,
+	0.976018f,
+	-0.110108f,
+	0.233114f,
+	0.960011f,
+	-0.155038f,
+	0.295131f,
+	0.944107f,
+	-0.146833f,
+	0.293935f,
+	0.952937f,
+	-0.0742579f,
+	0.206131f,
+	0.978459f,
+	-0.0112805f,
+	0.26541f,
+	0.963541f,
+	0.0338617f,
+	0.315062f,
+	0.940538f,
+	0.126983f,
+	0.200639f,
+	0.96888f,
+	0.144968f,
+	-0.0482349f,
+	0.996749f,
+	-0.0645292f,
+	-0.0829471f,
+	0.973987f,
+	-0.210875f,
+	-0.0395681f,
+	0.974449f,
+	-0.221097f,
+	-0.0327152f,
+	0.953444f,
+	-0.299791f,
+	0.0198675f,
+	0.970814f,
+	-0.23901f,
+	-0.0300308f,
+	0.967142f,
+	-0.252456f,
+	-0.0212823f,
+	0.929856f,
+	-0.367308f,
+	-0.0806959f,
+	0.938686f,
+	-0.335198f,
+	-0.165388f,
+	0.976093f,
+	-0.141032f,
+	-0.248602f,
+	0.968455f,
+	-0.0171025f,
+	-0.306518f,
+	0.951371f,
+	0.0306604f,
+	-0.345042f,
+	0.93733f,
+	0.04856f,
+	0.223548f,
+	0.968386f,
+	-0.110699f,
+	0.301936f,
+	0.947319f,
+	-0.106873f,
+	0.333496f,
+	0.936283f,
+	-0.110248f,
+	0.267715f,
+	0.952143f,
+	-0.147486f,
+	0.160925f,
+	0.980864f,
+	-0.109589f,
+	0.106924f,
+	0.990465f,
+	0.086874f,
+	0.0634847f,
+	0.989163f,
+	0.132389f,
+	-0.00868593f,
+	0.99995f,
+	-0.00503069f,
+	-0.137697f,
+	0.961899f,
+	-0.236198f,
+	-0.140914f,
+	0.964191f,
+	-0.224676f,
+	-0.263955f,
+	0.951239f,
+	-0.159597f,
+	-0.23775f,
+	0.971227f,
+	-0.0138849f,
+	-0.148246f,
+	0.985689f,
+	0.0802536f,
+	-0.176705f,
+	0.981995f,
+	0.0667941f,
+	-0.283636f,
+	0.956796f,
+	0.0639697f,
+	-0.481368f,
+	0.872896f,
+	-0.0796102f,
+	-0.48359f,
+	0.86775f,
+	-0.114673f,
+	-0.410361f,
+	0.90546f,
+	-0.10838f,
+	-0.368916f,
+	0.919839f,
+	-0.133408f,
+	-0.290849f,
+	0.948818f,
+	-0.123086f,
+	-0.265473f,
+	0.964116f,
+	-0.001833f,
+	-0.375668f,
+	0.926391f,
+	0.025952f,
+	-0.457607f,
+	0.88747f,
+	-0.0547004f,
+	-0.428989f,
+	0.902388f,
+	-0.0407983f,
+	-0.246051f,
+	0.968578f,
+	-0.0362744f,
+	-0.121016f,
+	0.990282f,
+	0.0685327f,
+	-0.158606f,
+	0.977484f,
+	0.139173f,
+	-0.181659f,
+	0.932387f,
+	0.312498f,
+	-0.374645f,
+	0.868516f,
+	0.324533f,
+	-0.427131f,
+	0.84162f,
+	0.330508f,
+	-0.473189f,
+	0.797198f,
+	0.374923f,
+	-0.486417f,
+	0.800363f,
+	0.350452f,
+	-0.401778f,
+	0.85438f,
+	0.329557f,
+	-0.142919f,
+	0.913903f,
+	0.379941f,
+	0.0660554f,
+	0.918312f,
+	0.390308f,
+	0.107243f,
+	0.947465f,
+	0.301346f,
+	0.120927f,
+	0.966132f,
+	0.227959f,
+	0.280478f,
+	0.92581f,
+	0.253394f,
+	0.365712f,
+	0.921405f,
+	0.131406f,
+	0.413772f,
+	0.910147f,
+	-0.0206163f,
+	0.410674f,
+	0.90493f,
+	-0.111572f,
+	0.355567f,
+	0.932765f,
+	-0.0593443f,
+	0.345425f,
+	0.933621f,
+	-0.0950402f,
+	0.397628f,
+	0.912297f,
+	-0.0980078f,
+	0.290063f,
+	0.956994f,
+	0.00506036f,
+	0.106586f,
+	0.994174f,
+	-0.016042f,
+	0.184529f,
+	0.978373f,
+	-0.093465f,
+	0.32595f,
+	0.937225f,
+	-0.12396f,
+	0.234333f,
+	0.947332f,
+	-0.218287f,
+	0.205568f,
+	0.971289f,
+	-0.119751f,
+	0.183661f,
+	0.977533f,
+	-0.103434f,
+	0.18646f,
+	0.974485f,
+	-0.124944f,
+	0.228632f,
+	0.97345f,
+	-0.0111031f,
+	0.2372f,
+	0.970015f,
+	0.0529807f,
+	0.150741f,
+	0.988413f,
+	-0.0177775f,
+	0.0529111f,
+	0.986113f,
+	-0.15742f,
+	0.0129012f,
+	0.976239f,
+	-0.216311f,
+	0.0638914f,
+	0.966774f,
+	-0.247521f,
+	-0.013106f,
+	0.949224f,
+	-0.314329f,
+	0.00301657f,
+	0.947335f,
+	-0.320229f,
+	0.0158116f,
+	0.945699f,
+	-0.32466f,
+	-0.206362f,
+	0.955554f,
+	-0.21055f,
+	-0.363868f,
+	0.929813f,
+	-0.0551994f,
+	-0.322459f,
+	0.943841f,
+	0.0720059f,
+	-0.369143f,
+	0.923823f,
+	0.101411f,
+	-0.383217f,
+	0.903675f,
+	0.191093f,
+	0.316947f,
+	0.930379f,
+	-0.184227f,
+	0.292606f,
+	0.932053f,
+	-0.213681f,
+	0.281637f,
+	0.95325f,
+	-0.109518f,
+	0.181192f,
+	0.981727f,
+	-0.0581435f,
+	0.0846872f,
+	0.996407f,
+	0.000962506f,
+	-0.00109762f,
+	0.999999f,
+	0.000234158f,
+	0.0777708f,
+	0.996176f,
+	0.0398008f,
+	0.205791f,
+	0.978243f,
+	0.0262708f,
+	0.0568816f,
+	0.985436f,
+	-0.160253f,
+	-0.183235f,
+	0.956309f,
+	-0.227811f,
+	-0.306851f,
+	0.928821f,
+	-0.207686f,
+	-0.348537f,
+	0.918038f,
+	-0.189017f,
+	-0.243342f,
+	0.965099f,
+	-0.0967916f,
+	-0.232072f,
+	0.972378f,
+	-0.0249578f,
+	-0.190489f,
+	0.981246f,
+	0.0294989f,
+	-0.361119f,
+	0.921084f,
+	-0.145596f,
+	-0.509056f,
+	0.842731f,
+	-0.175118f,
+	-0.463553f,
+	0.883903f,
+	-0.0619248f,
+	-0.339892f,
+	0.940435f,
+	0.00741701f,
+	-0.334839f,
+	0.939566f,
+	-0.0714062f,
+	-0.350156f,
+	0.936419f,
+	-0.0225887f,
+	-0.347741f,
+	0.937357f,
+	0.020947f,
+	-0.370099f,
+	0.928938f,
+	-0.0100614f,
+	-0.438593f,
+	0.892875f,
+	-0.102033f,
+	-0.372504f,
+	0.925425f,
+	-0.0694955f,
+	-0.205666f,
+	0.969919f,
+	0.130228f,
+	-0.228734f,
+	0.96522f,
+	0.126612f,
+	-0.319826f,
+	0.92691f,
+	0.196338f,
+	-0.371568f,
+	0.883063f,
+	0.286595f,
+	-0.42486f,
+	0.867995f,
+	0.257059f,
+	-0.575514f,
+	0.802019f,
+	0.159839f,
+	-0.477155f,
+	0.843037f,
+	0.248216f,
+	-0.322215f,
+	0.91617f,
+	0.238347f,
+	-0.15776f,
+	0.967147f,
+	0.199344f,
+	0.0563134f,
+	0.972277f,
+	0.226949f,
+	0.189774f,
+	0.959109f,
+	0.209989f,
+	0.114773f,
+	0.983426f,
+	0.140357f,
+	0.195319f,
+	0.960799f,
+	0.196765f,
+	0.466014f,
+	0.846607f,
+	0.257076f,
+	0.551779f,
+	0.823036f,
+	0.13473f,
+	0.451922f,
+	0.891695f,
+	-0.0254353f,
+	0.295217f,
+	0.951228f,
+	-0.0895088f,
+	0.39575f,
+	0.916754f,
+	-0.0542532f,
+	0.335629f,
+	0.937827f,
+	-0.0885088f,
+	0.163272f,
+	0.984979f,
+	0.0561951f,
+	0.175225f,
+	0.975709f,
+	0.131485f,
+	0.276736f,
+	0.960943f,
+	0.00255915f,
+	0.374077f,
+	0.92611f,
+	-0.0488528f,
+	0.257806f,
+	0.961501f,
+	-0.0951409f,
+	0.210674f,
+	0.973483f,
+	-0.0891523f,
+	0.210996f,
+	0.9611f,
+	-0.178234f,
+	0.230566f,
+	0.953272f,
+	-0.195223f,
+	0.113631f,
+	0.949966f,
+	-0.290949f,
+	0.210906f,
+	0.960561f,
+	-0.181223f,
+	0.197018f,
+	0.968285f,
+	-0.153646f,
+	0.117662f,
+	0.979392f,
+	-0.164157f,
+	0.00452083f,
+	0.974487f,
+	-0.224398f,
+	0.0685234f,
+	0.976453f,
+	-0.20456f,
+	0.0486196f,
+	0.979817f,
+	-0.193895f,
+	-0.041249f,
+	0.985341f,
+	-0.165533f,
+	-0.0536621f,
+	0.998462f,
+	0.0138937f,
+	-0.34438f,
+	0.936413f,
+	0.0673216f,
+	-0.441342f,
+	0.892502f,
+	0.0930463f,
+	-0.35428f,
+	0.929013f,
+	0.106864f,
+	-0.394607f,
+	0.91136f,
+	0.117083f,
+	-0.495153f,
+	0.861045f,
+	0.115868f,
+	0.317163f,
+	0.930357f,
+	-0.183965f,
+	0.258032f,
+	0.948579f,
+	-0.183348f,
+	0.18786f,
+	0.965135f,
+	-0.182274f,
+	0.168177f,
+	0.970722f,
+	-0.171508f,
+	0.130487f,
+	0.977884f,
+	-0.163448f,
+	0.0391868f,
+	0.976408f,
+	-0.212349f,
+	0.0535243f,
+	0.973465f,
+	-0.222489f,
+	0.187797f,
+	0.962281f,
+	-0.196843f,
+	0.12136f,
+	0.981658f,
+	-0.147035f,
+	-0.157459f,
+	0.973185f,
+	-0.167681f,
+	-0.281843f,
+	0.941023f,
+	-0.18719f,
+	-0.339259f,
+	0.910185f,
+	-0.237625f,
+	-0.312535f,
+	0.920718f,
+	-0.233666f,
+	-0.266508f,
+	0.952365f,
+	-0.148237f,
+	-0.190534f,
+	0.974186f,
+	-0.121073f,
+	-0.276015f,
+	0.959165f,
+	-0.0617859f,
+	-0.523368f,
+	0.852103f,
+	0.00254573f,
+	-0.538f,
+	0.84284f,
+	-0.0133122f,
+	-0.352764f,
+	0.935613f,
+	-0.0136594f,
+	-0.269435f,
+	0.962844f,
+	-0.0183539f,
+	-0.350798f,
+	0.93502f,
+	-0.0517468f,
+	-0.373067f,
+	0.922044f,
+	-0.103225f,
+	-0.354323f,
+	0.929911f,
+	-0.0985928f,
+	-0.409705f,
+	0.907488f,
+	-0.0927797f,
+	-0.42852f,
+	0.900791f,
+	-0.070324f,
+	-0.329659f,
+	0.944032f,
+	-0.0113329f,
+	-0.243515f,
+	0.962301f,
+	0.121152f,
+	-0.341781f,
+	0.918017f,
+	0.201073f,
+	-0.462572f,
+	0.875527f,
+	0.139571f,
+	-0.350168f,
+	0.914262f,
+	0.203733f,
+	-0.49611f,
+	0.864935f,
+	0.0759072f,
+	-0.527565f,
+	0.849514f,
+	0.000485091f,
+	-0.337106f,
+	0.940759f,
+	0.0364912f,
+	-0.159402f,
+	0.986691f,
+	0.0321325f,
+	0.0661572f,
+	0.997809f,
+	-0.000201698f,
+	0.185343f,
+	0.982618f,
+	-0.0104608f,
+	0.145499f,
+	0.981994f,
+	0.120491f,
+	0.134704f,
+	0.982549f,
+	0.128264f,
+	0.406275f,
+	0.89759f,
+	0.17109f,
+	0.586902f,
+	0.779785f,
+	0.217901f,
+	0.565709f,
+	0.807524f,
+	0.166967f,
+	0.384632f,
+	0.92307f,
+	-3.36604e-005f,
+	0.35623f,
+	0.932256f,
+	-0.0632309f,
+	0.323525f,
+	0.94617f,
+	0.00968274f,
+	0.0775419f,
+	0.995759f,
+	-0.0495083f,
+	0.170196f,
+	0.984289f,
+	-0.0470022f,
+	0.351353f,
+	0.935822f,
+	-0.0280704f,
+	0.38341f,
+	0.923157f,
+	-0.0278874f,
+	0.285688f,
+	0.957776f,
+	-0.0323514f,
+	0.254076f,
+	0.961785f,
+	-0.102057f,
+	0.271137f,
+	0.936424f,
+	-0.222698f,
+	0.261266f,
+	0.933845f,
+	-0.24428f,
+	0.199017f,
+	0.946563f,
+	-0.253793f,
+	0.0763778f,
+	0.960008f,
+	-0.269355f,
+	0.131471f,
+	0.985485f,
+	-0.107402f,
+	0.160318f,
+	0.984539f,
+	-0.0705758f,
+	0.0961684f,
+	0.977977f,
+	-0.185235f,
+	0.0245162f,
+	0.963631f,
+	-0.26611f,
+	-0.0125968f,
+	0.989853f,
+	-0.141538f,
+	-0.234149f,
+	0.972198f,
+	0.00219358f,
+	-0.224015f,
+	0.949544f,
+	0.219506f,
+	-0.294091f,
+	0.928539f,
+	0.226551f,
+	-0.388903f,
+	0.912184f,
+	0.129128f,
+	-0.352208f,
+	0.9324f,
+	0.0811158f,
+	-0.3962f,
+	0.915032f,
+	0.0757807f,
+	-0.491066f,
+	0.869445f,
+	0.0540404f,
+	0.157697f,
+	0.961233f,
+	-0.226193f,
+	0.272083f,
+	0.946677f,
+	-0.172551f,
+	0.25297f,
+	0.931319f,
+	-0.262015f,
+	0.179666f,
+	0.941632f,
+	-0.284691f,
+	0.0998509f,
+	0.952676f,
+	-0.287122f,
+	0.0337305f,
+	0.95661f,
+	-0.289412f,
+	0.0669213f,
+	0.956372f,
+	-0.284383f,
+	0.111493f,
+	0.948222f,
+	-0.297395f,
+	0.109434f,
+	0.973643f,
+	-0.200107f,
+	-0.146896f,
+	0.95648f,
+	-0.252126f,
+	-0.266533f,
+	0.937028f,
+	-0.225695f,
+	-0.287184f,
+	0.932451f,
+	-0.219226f,
+	-0.333493f,
+	0.906758f,
+	-0.258015f,
+	-0.32756f,
+	0.915563f,
+	-0.233343f,
+	-0.294553f,
+	0.94475f,
+	-0.143827f,
+	-0.391872f,
+	0.91893f,
+	0.0447686f,
+	-0.558682f,
+	0.823628f,
+	0.0975275f,
+	-0.441987f,
+	0.895769f,
+	0.0473795f,
+	-0.31507f,
+	0.944961f,
+	-0.0882052f,
+	-0.286026f,
+	0.950757f,
+	-0.119373f,
+	-0.300544f,
+	0.946699f,
+	-0.115905f,
+	-0.336723f,
+	0.926445f,
+	-0.168278f,
+	-0.353572f,
+	0.929204f,
+	-0.107543f,
+	-0.453641f,
+	0.88906f,
+	-0.0615028f,
+	-0.438343f,
+	0.898681f,
+	0.0151213f,
+	-0.388424f,
+	0.921475f,
+	0.00321393f,
+	-0.409039f,
+	0.909757f,
+	0.0709235f,
+	-0.363684f,
+	0.905932f,
+	0.216843f,
+	-0.363969f,
+	0.919331f,
+	0.149522f,
+	-0.393196f,
+	0.918247f,
+	0.0470974f,
+	-0.399628f,
+	0.911703f,
+	0.0953624f,
+	-0.51262f,
+	0.855967f,
+	-0.0673815f,
+	-0.335242f,
+	0.936382f,
+	-0.103929f,
+	-0.0973696f,
+	0.981557f,
+	-0.164516f,
+	0.067792f,
+	0.980923f,
+	-0.182192f,
+	0.0872383f,
+	0.996018f,
+	-0.0183907f,
+	-0.00523703f,
+	0.995218f,
+	0.0975357f,
+	0.128581f,
+	0.983098f,
+	0.130327f,
+	0.373617f,
+	0.921384f,
+	0.107058f,
+	0.560261f,
+	0.820373f,
+	0.114439f,
+	0.627317f,
+	0.771722f,
+	0.104494f,
+	0.477878f,
+	0.875076f,
+	0.0766505f,
+	0.339671f,
+	0.937101f,
+	0.080413f,
+	0.338185f,
+	0.931593f,
+	0.133286f,
+	0.241006f,
+	0.969638f,
+	0.0414564f,
+	0.184566f,
+	0.96984f,
+	-0.159206f,
+	0.299844f,
+	0.937156f,
+	-0.178416f,
+	0.33645f,
+	0.93097f,
+	-0.14176f,
+	0.33978f,
+	0.935566f,
+	-0.0962638f,
+	0.338458f,
+	0.922961f,
+	-0.183273f,
+	0.376116f,
+	0.905613f,
+	-0.195964f,
+	0.229101f,
+	0.942068f,
+	-0.244989f,
+	0.179681f,
+	0.964126f,
+	-0.195387f,
+	0.0309568f,
+	0.968834f,
+	-0.245768f,
+	0.00573259f,
+	0.975463f,
+	-0.220088f,
+	0.156849f,
+	0.977783f,
+	-0.139061f,
+	0.21782f,
+	0.972525f,
+	-0.0821593f,
+	0.0218621f,
+	0.99451f,
+	-0.102332f,
+	-0.198564f,
+	0.980065f,
+	-0.00663249f,
+	-0.36267f,
+	0.923836f,
+	0.122463f,
+	-0.30382f,
+	0.935102f,
+	0.182419f,
+	-0.225949f,
+	0.949998f,
+	0.215522f,
+	-0.338005f,
+	0.935768f,
+	0.100459f,
+	-0.329518f,
+	0.942604f,
+	0.0540005f,
+	-0.353044f,
+	0.9356f,
+	0.00366832f,
+	-0.46383f,
+	0.880375f,
+	-0.0990046f,
+	0.265153f,
+	0.963251f,
+	-0.0429098f,
+	0.322279f,
+	0.944597f,
+	-0.0622248f,
+	0.315505f,
+	0.945542f,
+	-0.0800488f,
+	0.163962f,
+	0.974749f,
+	-0.151597f,
+	0.137337f,
+	0.972433f,
+	-0.188448f,
+	0.0704319f,
+	0.957822f,
+	-0.278599f,
+	0.0704671f,
+	0.945462f,
+	-0.318019f,
+	0.0908986f,
+	0.948607f,
+	-0.303121f,
+	0.035224f,
+	0.968727f,
+	-0.245614f,
+	-0.0832465f,
+	0.983302f,
+	-0.161824f,
+	-0.246429f,
+	0.938519f,
+	-0.241773f,
+	-0.316726f,
+	0.889326f,
+	-0.329823f,
+	-0.284897f,
+	0.918994f,
+	-0.272549f,
+	-0.362325f,
+	0.886545f,
+	-0.287677f,
+	-0.440048f,
+	0.874713f,
+	-0.203063f,
+	-0.497142f,
+	0.865956f,
+	-0.0544999f,
+	-0.523445f,
+	0.849121f,
+	-0.0707108f,
+	-0.401725f,
+	0.907593f,
+	-0.122034f,
+	-0.239401f,
+	0.964528f,
+	-0.111235f,
+	-0.233733f,
+	0.958501f,
+	-0.163231f,
+	-0.252964f,
+	0.932836f,
+	-0.256566f,
+	-0.367645f,
+	0.889692f,
+	-0.270713f,
+	-0.454692f,
+	0.878935f,
+	-0.143978f,
+	-0.492544f,
+	0.866924f,
+	-0.0764391f,
+	-0.481959f,
+	0.875013f,
+	-0.0454739f,
+	-0.427088f,
+	0.903155f,
+	0.0436767f,
+	-0.414523f,
+	0.900313f,
+	0.132691f,
+	-0.445145f,
+	0.893064f,
+	0.0654368f,
+	-0.272596f,
+	0.94477f,
+	0.181937f,
+	-0.346295f,
+	0.936658f,
+	0.0524542f,
+	-0.387211f,
+	0.921676f,
+	-0.0241059f,
+	-0.412405f,
+	0.90305f,
+	-0.120098f,
+	-0.307707f,
+	0.940243f,
+	-0.145806f,
+	-0.0608418f,
+	0.995582f,
+	-0.0715164f,
+	-0.0645131f,
+	0.997917f,
+	-0.000435129f,
+	-0.102008f,
+	0.988043f,
+	0.115607f,
+	0.0143588f,
+	0.992143f,
+	0.12428f,
+	0.177967f,
+	0.984035f,
+	-0.00139713f,
+	0.41001f,
+	0.908001f,
+	-0.0861781f,
+	0.552955f,
+	0.819416f,
+	-0.150989f,
+	0.604866f,
+	0.793986f,
+	-0.061019f,
+	0.412532f,
+	0.907382f,
+	0.080473f,
+	0.292095f,
+	0.937176f,
+	0.190737f,
+	0.30791f,
+	0.927063f,
+	0.213882f,
+	0.344775f,
+	0.913992f,
+	0.21389f,
+	0.356481f,
+	0.927786f,
+	0.110156f,
+	0.364153f,
+	0.931072f,
+	-0.0223179f,
+	0.345291f,
+	0.930006f,
+	-0.125944f,
+	0.351321f,
+	0.913987f,
+	-0.20298f,
+	0.3587f,
+	0.898336f,
+	-0.253627f,
+	0.30452f,
+	0.930923f,
+	-0.201617f,
+	0.2074f,
+	0.975489f,
+	-0.0735288f,
+	0.18932f,
+	0.981882f,
+	-0.00809888f,
+	0.163933f,
+	0.983471f,
+	-0.0768774f,
+	0.0155138f,
+	0.975385f,
+	-0.219964f,
+	0.0271837f,
+	0.983796f,
+	-0.177221f,
+	0.116676f,
+	0.992898f,
+	-0.0232359f,
+	-0.0753728f,
+	0.996934f,
+	0.0209924f,
+	-0.279745f,
+	0.951672f,
+	0.12674f,
+	-0.364174f,
+	0.921867f,
+	0.132433f,
+	-0.344523f,
+	0.936581f,
+	0.0641857f,
+	-0.216332f,
+	0.972578f,
+	0.0853902f,
+	-0.223892f,
+	0.974436f,
+	0.0186366f,
+	-0.28965f,
+	0.953049f,
+	-0.0883156f,
+	-0.269918f,
+	0.95756f,
+	-0.101108f,
+	-0.286201f,
+	0.950564f,
+	-0.120491f,
+	0.172976f,
+	0.984286f,
+	-0.0355076f,
+	0.24194f,
+	0.969981f,
+	0.0245291f,
+	0.324379f,
+	0.937283f,
+	0.127591f,
+	0.286811f,
+	0.953171f,
+	0.0959428f,
+	0.228455f,
+	0.972614f,
+	-0.0427886f,
+	0.182359f,
+	0.97568f,
+	-0.121631f,
+	0.113036f,
+	0.971479f,
+	-0.208452f,
+	0.0547152f,
+	0.964701f,
+	-0.257601f,
+	-0.089806f,
+	0.977237f,
+	-0.192205f,
+	-0.171631f,
+	0.984685f,
+	-0.0306458f,
+	-0.116586f,
+	0.992809f,
+	0.0271681f,
+	-0.181607f,
+	0.981068f,
+	-0.0672723f,
+	-0.351307f,
+	0.914748f,
+	-0.199546f,
+	-0.388005f,
+	0.90325f,
+	-0.183278f,
+	-0.498044f,
+	0.847159f,
+	-0.185132f,
+	-0.510366f,
+	0.84434f,
+	-0.163145f,
+	-0.479522f,
+	0.851128f,
+	-0.213636f,
+	-0.42037f,
+	0.86671f,
+	-0.268518f,
+	-0.285469f,
+	0.932257f,
+	-0.22227f,
+	-0.161107f,
+	0.969121f,
+	-0.186679f,
+	-0.183754f,
+	0.955302f,
+	-0.231585f,
+	-0.370817f,
+	0.89935f,
+	-0.231654f,
+	-0.514998f,
+	0.83014f,
+	-0.213645f,
+	-0.498206f,
+	0.85286f,
+	-0.156273f,
+	-0.539513f,
+	0.835182f,
+	-0.106757f,
+	-0.535773f,
+	0.843208f,
+	0.0441435f,
+	-0.434698f,
+	0.878206f,
+	0.19948f,
+	-0.415775f,
+	0.89222f,
+	0.176277f,
+	-0.35414f,
+	0.920981f,
+	0.162413f,
+	-0.208366f,
+	0.953013f,
+	0.219884f,
+	-0.257177f,
+	0.962661f,
+	0.0845243f,
+	-0.386488f,
+	0.920792f,
+	-0.0526133f,
+	-0.381213f,
+	0.924327f,
+	0.0172227f,
+	-0.280093f,
+	0.955497f,
+	0.0925905f,
+	-0.1219f,
+	0.953555f,
+	0.275451f,
+	-0.0595691f,
+	0.973079f,
+	0.222641f,
+	0.124431f,
+	0.978938f,
+	0.161854f,
+	0.328706f,
+	0.943592f,
+	0.0398269f,
+	0.495224f,
+	0.863825f,
+	-0.0925162f,
+	0.549494f,
+	0.832161f,
+	-0.0745945f,
+	0.445758f,
+	0.890738f,
+	0.0887957f,
+	0.286029f,
+	0.911685f,
+	0.294987f,
+	0.236342f,
+	0.90766f,
+	0.346837f,
+	0.306156f,
+	0.900003f,
+	0.310262f,
+	0.362522f,
+	0.893707f,
+	0.264322f,
+	0.407318f,
+	0.891604f,
+	0.197826f,
+	0.447705f,
+	0.883296f,
+	0.139101f,
+	0.451832f,
+	0.890524f,
+	0.0530504f,
+	0.450032f,
+	0.892977f,
+	-0.00796524f,
+	0.380264f,
+	0.922022f,
+	-0.0726326f,
+	0.220431f,
+	0.973877f,
+	-0.0545382f,
+	0.073814f,
+	0.997262f,
+	0.00436123f,
+	0.143916f,
+	0.987825f,
+	0.059083f,
+	0.242994f,
+	0.967605f,
+	0.068523f,
+	0.0793826f,
+	0.995647f,
+	0.0488496f,
+	-0.0810126f,
+	0.994023f,
+	0.0731786f,
+	0.0550609f,
+	0.987118f,
+	0.150223f,
+	-0.0403249f,
+	0.995863f,
+	0.0814341f,
+	-0.341404f,
+	0.939899f,
+	-0.00574405f,
+	-0.333197f,
+	0.942331f,
+	0.0315063f,
+	-0.270492f,
+	0.962353f,
+	-0.0266656f,
+	-0.217149f,
+	0.973729f,
+	-0.0685481f,
+	-0.150518f,
+	0.988024f,
+	-0.0339529f,
+	-0.227799f,
+	0.970772f,
+	-0.0755549f,
+	-0.30247f,
+	0.950166f,
+	-0.0754703f,
+	-0.319718f,
+	0.946617f,
+	-0.0411916f,
+	0.16825f,
+	0.98433f,
+	0.0527868f,
+	0.196178f,
+	0.978898f,
+	0.0572086f,
+	0.274186f,
+	0.954613f,
+	0.116347f,
+	0.32563f,
+	0.930709f,
+	0.166568f,
+	0.315871f,
+	0.943308f,
+	0.101959f,
+	0.191037f,
+	0.981318f,
+	-0.0227958f,
+	0.218135f,
+	0.975914f,
+	0.0029357f,
+	0.0466483f,
+	0.982299f,
+	-0.18142f,
+	-0.170175f,
+	0.975305f,
+	-0.140788f,
+	-0.258133f,
+	0.965917f,
+	0.0192531f,
+	-0.189679f,
+	0.978131f,
+	0.0853348f,
+	-0.0936377f,
+	0.967266f,
+	0.235858f,
+	-0.301926f,
+	0.950003f,
+	0.0795937f,
+	-0.345647f,
+	0.93835f,
+	0.00528925f,
+	-0.494118f,
+	0.858314f,
+	-0.138363f,
+	-0.492927f,
+	0.860507f,
+	-0.128646f,
+	-0.443878f,
+	0.87267f,
+	-0.203517f,
+	-0.398442f,
+	0.869961f,
+	-0.290537f,
+	-0.31747f,
+	0.894846f,
+	-0.313789f,
+	-0.189431f,
+	0.934926f,
+	-0.300049f,
+	-0.194231f,
+	0.947861f,
+	-0.252654f,
+	-0.355627f,
+	0.917296f,
+	-0.179159f,
+	-0.521351f,
+	0.821848f,
+	-0.229692f,
+	-0.537173f,
+	0.817848f,
+	-0.206322f,
+	-0.595314f,
+	0.798098f,
+	-0.0929575f,
+	-0.612312f,
+	0.785394f,
+	0.0907203f,
+	-0.484809f,
+	0.839064f,
+	0.246843f,
+	-0.327417f,
+	0.875762f,
+	0.354737f,
+	-0.358949f,
+	0.909479f,
+	0.20977f,
+	-0.221142f,
+	0.943893f,
+	0.245282f,
+	-0.137619f,
+	0.956208f,
+	0.258316f,
+	-0.37682f,
+	0.920718f,
+	0.101416f,
+	-0.393482f,
+	0.900899f,
+	0.183174f,
+	-0.309483f,
+	0.930699f,
+	0.194988f,
+	-0.137506f,
+	0.96116f,
+	0.2393f,
+	-0.0256175f,
+	0.984881f,
+	0.171327f,
+	0.155024f,
+	0.972933f,
+	0.171372f,
+	0.40312f,
+	0.907825f,
+	0.115531f,
+	0.491485f,
+	0.869632f,
+	-0.0467184f,
+	0.488586f,
+	0.869843f,
+	0.0682392f,
+	0.313615f,
+	0.910806f,
+	0.268473f,
+	0.190736f,
+	0.863506f,
+	0.466881f,
+	0.238952f,
+	0.837112f,
+	0.492083f,
+	0.344695f,
+	0.840122f,
+	0.418784f,
+	0.396648f,
+	0.860615f,
+	0.319393f,
+	0.456384f,
+	0.85928f,
+	0.230981f,
+	0.487857f,
+	0.863295f,
+	0.129295f,
+	0.451906f,
+	0.891012f,
+	0.043332f,
+	0.456211f,
+	0.882737f,
+	0.112455f,
+	0.397431f,
+	0.910062f,
+	0.117622f,
+	0.204941f,
+	0.971778f,
+	0.116821f,
+	0.0877111f,
+	0.985798f,
+	0.143208f,
+	0.14813f,
+	0.986469f,
+	0.0702648f,
+	0.212033f,
+	0.976625f,
+	0.035296f,
+	0.0413914f,
+	0.99116f,
+	0.126047f,
+	-0.10186f,
+	0.970634f,
+	0.217932f,
+	0.0558102f,
+	0.971334f,
+	0.231076f,
+	0.0834757f,
+	0.981533f,
+	0.172117f,
+	-0.293392f,
+	0.955612f,
+	-0.0269471f,
+	-0.339064f,
+	0.938377f,
+	-0.0669636f,
+	-0.232942f,
+	0.969004f,
+	-0.0822698f,
+	-0.249298f,
+	0.960887f,
+	-0.120613f,
+	-0.178309f,
+	0.98375f,
+	-0.0210319f,
+	-0.23671f,
+	0.971566f,
+	0.00516088f,
+	-0.322203f,
+	0.944986f,
+	0.0564443f,
+	-0.359276f,
+	0.929551f,
+	0.0827968f,
+};
+
+btScalar Landscape06Tex[] = {
+	0.0f,
+	0.0078125f,
+	0.0f,
+	0.0f,
+	0.0078125f,
+	0.0078125f,
+	0.0078125f,
+	0.0f,
+	0.015625f,
+	0.0078125f,
+	0.015625f,
+	0.0f,
+	0.0234375f,
+	0.0078125f,
+	0.0234375f,
+	0.0f,
+	0.03125f,
+	0.0078125f,
+	0.03125f,
+	0.0f,
+	0.0390625f,
+	0.0078125f,
+	0.0390625f,
+	0.0f,
+	0.046875f,
+	0.0078125f,
+	0.046875f,
+	0.0f,
+	0.0546875f,
+	0.0078125f,
+	0.0546875f,
+	0.0f,
+	0.0625f,
+	0.0078125f,
+	0.0625f,
+	0.0f,
+	0.0703125f,
+	0.0078125f,
+	0.0703125f,
+	0.0f,
+	0.078125f,
+	0.0078125f,
+	0.078125f,
+	0.0f,
+	0.0859375f,
+	0.0078125f,
+	0.0859375f,
+	0.0f,
+	0.09375f,
+	0.0078125f,
+	0.09375f,
+	0.0f,
+	0.101563f,
+	0.0078125f,
+	0.101563f,
+	0.0f,
+	0.109375f,
+	0.0078125f,
+	0.109375f,
+	0.0f,
+	0.117188f,
+	0.0078125f,
+	0.117188f,
+	0.0f,
+	0.125f,
+	0.0078125f,
+	0.125f,
+	0.0f,
+	0.132813f,
+	0.0078125f,
+	0.132813f,
+	0.0f,
+	0.140625f,
+	0.0078125f,
+	0.140625f,
+	0.0f,
+	0.148438f,
+	0.0078125f,
+	0.148438f,
+	0.0f,
+	0.15625f,
+	0.0078125f,
+	0.15625f,
+	0.0f,
+	0.164063f,
+	0.0078125f,
+	0.164063f,
+	0.0f,
+	0.171875f,
+	0.0078125f,
+	0.171875f,
+	0.0f,
+	0.179688f,
+	0.0078125f,
+	0.179688f,
+	0.0f,
+	0.1875f,
+	0.0078125f,
+	0.1875f,
+	0.0f,
+	0.195313f,
+	0.0078125f,
+	0.195313f,
+	0.0f,
+	0.203125f,
+	0.0078125f,
+	0.203125f,
+	0.0f,
+	0.210938f,
+	0.0078125f,
+	0.210938f,
+	0.0f,
+	0.21875f,
+	0.0078125f,
+	0.21875f,
+	0.0f,
+	0.226563f,
+	0.0078125f,
+	0.226563f,
+	0.0f,
+	0.234375f,
+	0.0078125f,
+	0.234375f,
+	0.0f,
+	0.242188f,
+	0.0078125f,
+	0.242188f,
+	0.0f,
+	0.25f,
+	0.0078125f,
+	0.25f,
+	0.0f,
+	0.257813f,
+	0.0078125f,
+	0.257813f,
+	0.0f,
+	0.265625f,
+	0.0078125f,
+	0.265625f,
+	0.0f,
+	0.273438f,
+	0.0078125f,
+	0.273438f,
+	0.0f,
+	0.28125f,
+	0.0078125f,
+	0.28125f,
+	0.0f,
+	0.289063f,
+	0.0078125f,
+	0.289063f,
+	0.0f,
+	0.296875f,
+	0.0078125f,
+	0.296875f,
+	0.0f,
+	0.304688f,
+	0.0078125f,
+	0.304688f,
+	0.0f,
+	0.3125f,
+	0.0078125f,
+	0.3125f,
+	0.0f,
+	0.320313f,
+	0.0078125f,
+	0.320313f,
+	0.0f,
+	0.328125f,
+	0.0078125f,
+	0.328125f,
+	0.0f,
+	0.335938f,
+	0.0078125f,
+	0.335938f,
+	0.0f,
+	0.34375f,
+	0.0078125f,
+	0.34375f,
+	0.0f,
+	0.351563f,
+	0.0078125f,
+	0.351563f,
+	0.0f,
+	0.359375f,
+	0.0078125f,
+	0.359375f,
+	0.0f,
+	0.367188f,
+	0.0078125f,
+	0.367188f,
+	0.0f,
+	0.375f,
+	0.0078125f,
+	0.375f,
+	0.0f,
+	0.382813f,
+	0.0078125f,
+	0.382813f,
+	0.0f,
+	0.390625f,
+	0.0078125f,
+	0.390625f,
+	0.0f,
+	0.398438f,
+	0.0078125f,
+	0.398438f,
+	0.0f,
+	0.40625f,
+	0.0078125f,
+	0.40625f,
+	0.0f,
+	0.414063f,
+	0.0078125f,
+	0.414063f,
+	0.0f,
+	0.421875f,
+	0.0078125f,
+	0.421875f,
+	0.0f,
+	0.429688f,
+	0.0078125f,
+	0.429688f,
+	0.0f,
+	0.4375f,
+	0.0078125f,
+	0.4375f,
+	0.0f,
+	0.445313f,
+	0.0078125f,
+	0.445313f,
+	0.0f,
+	0.453125f,
+	0.0078125f,
+	0.453125f,
+	0.0f,
+	0.460938f,
+	0.0078125f,
+	0.460938f,
+	0.0f,
+	0.46875f,
+	0.0078125f,
+	0.46875f,
+	0.0f,
+	0.476563f,
+	0.0078125f,
+	0.476563f,
+	0.0f,
+	0.484375f,
+	0.0078125f,
+	0.484375f,
+	0.0f,
+	0.492188f,
+	0.0078125f,
+	0.492188f,
+	0.0f,
+	0.5f,
+	0.0078125f,
+	0.5f,
+	0.0f,
+	0.507813f,
+	0.0078125f,
+	0.507813f,
+	0.0f,
+	0.0f,
+	0.015625f,
+	0.0078125f,
+	0.015625f,
+	0.015625f,
+	0.015625f,
+	0.0234375f,
+	0.015625f,
+	0.03125f,
+	0.015625f,
+	0.0390625f,
+	0.015625f,
+	0.046875f,
+	0.015625f,
+	0.0546875f,
+	0.015625f,
+	0.0625f,
+	0.015625f,
+	0.0703125f,
+	0.015625f,
+	0.078125f,
+	0.015625f,
+	0.0859375f,
+	0.015625f,
+	0.09375f,
+	0.015625f,
+	0.101563f,
+	0.015625f,
+	0.109375f,
+	0.015625f,
+	0.117188f,
+	0.015625f,
+	0.125f,
+	0.015625f,
+	0.132813f,
+	0.015625f,
+	0.140625f,
+	0.015625f,
+	0.148438f,
+	0.015625f,
+	0.15625f,
+	0.015625f,
+	0.164063f,
+	0.015625f,
+	0.171875f,
+	0.015625f,
+	0.179688f,
+	0.015625f,
+	0.1875f,
+	0.015625f,
+	0.195313f,
+	0.015625f,
+	0.203125f,
+	0.015625f,
+	0.210938f,
+	0.015625f,
+	0.21875f,
+	0.015625f,
+	0.226563f,
+	0.015625f,
+	0.234375f,
+	0.015625f,
+	0.242188f,
+	0.015625f,
+	0.25f,
+	0.015625f,
+	0.257813f,
+	0.015625f,
+	0.265625f,
+	0.015625f,
+	0.273438f,
+	0.015625f,
+	0.28125f,
+	0.015625f,
+	0.289063f,
+	0.015625f,
+	0.296875f,
+	0.015625f,
+	0.304688f,
+	0.015625f,
+	0.3125f,
+	0.015625f,
+	0.320313f,
+	0.015625f,
+	0.328125f,
+	0.015625f,
+	0.335938f,
+	0.015625f,
+	0.34375f,
+	0.015625f,
+	0.351563f,
+	0.015625f,
+	0.359375f,
+	0.015625f,
+	0.367188f,
+	0.015625f,
+	0.375f,
+	0.015625f,
+	0.382813f,
+	0.015625f,
+	0.390625f,
+	0.015625f,
+	0.398438f,
+	0.015625f,
+	0.40625f,
+	0.015625f,
+	0.414063f,
+	0.015625f,
+	0.421875f,
+	0.015625f,
+	0.429688f,
+	0.015625f,
+	0.4375f,
+	0.015625f,
+	0.445313f,
+	0.015625f,
+	0.453125f,
+	0.015625f,
+	0.460938f,
+	0.015625f,
+	0.46875f,
+	0.015625f,
+	0.476563f,
+	0.015625f,
+	0.484375f,
+	0.015625f,
+	0.492188f,
+	0.015625f,
+	0.5f,
+	0.015625f,
+	0.507813f,
+	0.015625f,
+	0.0f,
+	0.0234375f,
+	0.0078125f,
+	0.0234375f,
+	0.015625f,
+	0.0234375f,
+	0.0234375f,
+	0.0234375f,
+	0.03125f,
+	0.0234375f,
+	0.0390625f,
+	0.0234375f,
+	0.046875f,
+	0.0234375f,
+	0.0546875f,
+	0.0234375f,
+	0.0625f,
+	0.0234375f,
+	0.0703125f,
+	0.0234375f,
+	0.078125f,
+	0.0234375f,
+	0.0859375f,
+	0.0234375f,
+	0.09375f,
+	0.0234375f,
+	0.101563f,
+	0.0234375f,
+	0.109375f,
+	0.0234375f,
+	0.117188f,
+	0.0234375f,
+	0.125f,
+	0.0234375f,
+	0.132813f,
+	0.0234375f,
+	0.140625f,
+	0.0234375f,
+	0.148438f,
+	0.0234375f,
+	0.15625f,
+	0.0234375f,
+	0.164063f,
+	0.0234375f,
+	0.171875f,
+	0.0234375f,
+	0.179688f,
+	0.0234375f,
+	0.1875f,
+	0.0234375f,
+	0.195313f,
+	0.0234375f,
+	0.203125f,
+	0.0234375f,
+	0.210938f,
+	0.0234375f,
+	0.21875f,
+	0.0234375f,
+	0.226563f,
+	0.0234375f,
+	0.234375f,
+	0.0234375f,
+	0.242188f,
+	0.0234375f,
+	0.25f,
+	0.0234375f,
+	0.257813f,
+	0.0234375f,
+	0.265625f,
+	0.0234375f,
+	0.273438f,
+	0.0234375f,
+	0.28125f,
+	0.0234375f,
+	0.289063f,
+	0.0234375f,
+	0.296875f,
+	0.0234375f,
+	0.304688f,
+	0.0234375f,
+	0.3125f,
+	0.0234375f,
+	0.320313f,
+	0.0234375f,
+	0.328125f,
+	0.0234375f,
+	0.335938f,
+	0.0234375f,
+	0.34375f,
+	0.0234375f,
+	0.351563f,
+	0.0234375f,
+	0.359375f,
+	0.0234375f,
+	0.367188f,
+	0.0234375f,
+	0.375f,
+	0.0234375f,
+	0.382813f,
+	0.0234375f,
+	0.390625f,
+	0.0234375f,
+	0.398438f,
+	0.0234375f,
+	0.40625f,
+	0.0234375f,
+	0.414063f,
+	0.0234375f,
+	0.421875f,
+	0.0234375f,
+	0.429688f,
+	0.0234375f,
+	0.4375f,
+	0.0234375f,
+	0.445313f,
+	0.0234375f,
+	0.453125f,
+	0.0234375f,
+	0.460938f,
+	0.0234375f,
+	0.46875f,
+	0.0234375f,
+	0.476563f,
+	0.0234375f,
+	0.484375f,
+	0.0234375f,
+	0.492188f,
+	0.0234375f,
+	0.5f,
+	0.0234375f,
+	0.507813f,
+	0.0234375f,
+	0.0f,
+	0.03125f,
+	0.0078125f,
+	0.03125f,
+	0.015625f,
+	0.03125f,
+	0.0234375f,
+	0.03125f,
+	0.03125f,
+	0.03125f,
+	0.0390625f,
+	0.03125f,
+	0.046875f,
+	0.03125f,
+	0.0546875f,
+	0.03125f,
+	0.0625f,
+	0.03125f,
+	0.0703125f,
+	0.03125f,
+	0.078125f,
+	0.03125f,
+	0.0859375f,
+	0.03125f,
+	0.09375f,
+	0.03125f,
+	0.101563f,
+	0.03125f,
+	0.109375f,
+	0.03125f,
+	0.117188f,
+	0.03125f,
+	0.125f,
+	0.03125f,
+	0.132813f,
+	0.03125f,
+	0.140625f,
+	0.03125f,
+	0.148438f,
+	0.03125f,
+	0.15625f,
+	0.03125f,
+	0.164063f,
+	0.03125f,
+	0.171875f,
+	0.03125f,
+	0.179688f,
+	0.03125f,
+	0.1875f,
+	0.03125f,
+	0.195313f,
+	0.03125f,
+	0.203125f,
+	0.03125f,
+	0.210938f,
+	0.03125f,
+	0.21875f,
+	0.03125f,
+	0.226563f,
+	0.03125f,
+	0.234375f,
+	0.03125f,
+	0.242188f,
+	0.03125f,
+	0.25f,
+	0.03125f,
+	0.257813f,
+	0.03125f,
+	0.265625f,
+	0.03125f,
+	0.273438f,
+	0.03125f,
+	0.28125f,
+	0.03125f,
+	0.289063f,
+	0.03125f,
+	0.296875f,
+	0.03125f,
+	0.304688f,
+	0.03125f,
+	0.3125f,
+	0.03125f,
+	0.320313f,
+	0.03125f,
+	0.328125f,
+	0.03125f,
+	0.335938f,
+	0.03125f,
+	0.34375f,
+	0.03125f,
+	0.351563f,
+	0.03125f,
+	0.359375f,
+	0.03125f,
+	0.367188f,
+	0.03125f,
+	0.375f,
+	0.03125f,
+	0.382813f,
+	0.03125f,
+	0.390625f,
+	0.03125f,
+	0.398438f,
+	0.03125f,
+	0.40625f,
+	0.03125f,
+	0.414063f,
+	0.03125f,
+	0.421875f,
+	0.03125f,
+	0.429688f,
+	0.03125f,
+	0.4375f,
+	0.03125f,
+	0.445313f,
+	0.03125f,
+	0.453125f,
+	0.03125f,
+	0.460938f,
+	0.03125f,
+	0.46875f,
+	0.03125f,
+	0.476563f,
+	0.03125f,
+	0.484375f,
+	0.03125f,
+	0.492188f,
+	0.03125f,
+	0.5f,
+	0.03125f,
+	0.507813f,
+	0.03125f,
+	0.0f,
+	0.0390625f,
+	0.0078125f,
+	0.0390625f,
+	0.015625f,
+	0.0390625f,
+	0.0234375f,
+	0.0390625f,
+	0.03125f,
+	0.0390625f,
+	0.0390625f,
+	0.0390625f,
+	0.046875f,
+	0.0390625f,
+	0.0546875f,
+	0.0390625f,
+	0.0625f,
+	0.0390625f,
+	0.0703125f,
+	0.0390625f,
+	0.078125f,
+	0.0390625f,
+	0.0859375f,
+	0.0390625f,
+	0.09375f,
+	0.0390625f,
+	0.101563f,
+	0.0390625f,
+	0.109375f,
+	0.0390625f,
+	0.117188f,
+	0.0390625f,
+	0.125f,
+	0.0390625f,
+	0.132813f,
+	0.0390625f,
+	0.140625f,
+	0.0390625f,
+	0.148438f,
+	0.0390625f,
+	0.15625f,
+	0.0390625f,
+	0.164063f,
+	0.0390625f,
+	0.171875f,
+	0.0390625f,
+	0.179688f,
+	0.0390625f,
+	0.1875f,
+	0.0390625f,
+	0.195313f,
+	0.0390625f,
+	0.203125f,
+	0.0390625f,
+	0.210938f,
+	0.0390625f,
+	0.21875f,
+	0.0390625f,
+	0.226563f,
+	0.0390625f,
+	0.234375f,
+	0.0390625f,
+	0.242188f,
+	0.0390625f,
+	0.25f,
+	0.0390625f,
+	0.257813f,
+	0.0390625f,
+	0.265625f,
+	0.0390625f,
+	0.273438f,
+	0.0390625f,
+	0.28125f,
+	0.0390625f,
+	0.289063f,
+	0.0390625f,
+	0.296875f,
+	0.0390625f,
+	0.304688f,
+	0.0390625f,
+	0.3125f,
+	0.0390625f,
+	0.320313f,
+	0.0390625f,
+	0.328125f,
+	0.0390625f,
+	0.335938f,
+	0.0390625f,
+	0.34375f,
+	0.0390625f,
+	0.351563f,
+	0.0390625f,
+	0.359375f,
+	0.0390625f,
+	0.367188f,
+	0.0390625f,
+	0.375f,
+	0.0390625f,
+	0.382813f,
+	0.0390625f,
+	0.390625f,
+	0.0390625f,
+	0.398438f,
+	0.0390625f,
+	0.40625f,
+	0.0390625f,
+	0.414063f,
+	0.0390625f,
+	0.421875f,
+	0.0390625f,
+	0.429688f,
+	0.0390625f,
+	0.4375f,
+	0.0390625f,
+	0.445313f,
+	0.0390625f,
+	0.453125f,
+	0.0390625f,
+	0.460938f,
+	0.0390625f,
+	0.46875f,
+	0.0390625f,
+	0.476563f,
+	0.0390625f,
+	0.484375f,
+	0.0390625f,
+	0.492188f,
+	0.0390625f,
+	0.5f,
+	0.0390625f,
+	0.507813f,
+	0.0390625f,
+	0.0f,
+	0.046875f,
+	0.0078125f,
+	0.046875f,
+	0.015625f,
+	0.046875f,
+	0.0234375f,
+	0.046875f,
+	0.03125f,
+	0.046875f,
+	0.0390625f,
+	0.046875f,
+	0.046875f,
+	0.046875f,
+	0.0546875f,
+	0.046875f,
+	0.0625f,
+	0.046875f,
+	0.0703125f,
+	0.046875f,
+	0.078125f,
+	0.046875f,
+	0.0859375f,
+	0.046875f,
+	0.09375f,
+	0.046875f,
+	0.101563f,
+	0.046875f,
+	0.109375f,
+	0.046875f,
+	0.117188f,
+	0.046875f,
+	0.125f,
+	0.046875f,
+	0.132813f,
+	0.046875f,
+	0.140625f,
+	0.046875f,
+	0.148438f,
+	0.046875f,
+	0.15625f,
+	0.046875f,
+	0.164063f,
+	0.046875f,
+	0.171875f,
+	0.046875f,
+	0.179688f,
+	0.046875f,
+	0.1875f,
+	0.046875f,
+	0.195313f,
+	0.046875f,
+	0.203125f,
+	0.046875f,
+	0.210938f,
+	0.046875f,
+	0.21875f,
+	0.046875f,
+	0.226563f,
+	0.046875f,
+	0.234375f,
+	0.046875f,
+	0.242188f,
+	0.046875f,
+	0.25f,
+	0.046875f,
+	0.257813f,
+	0.046875f,
+	0.265625f,
+	0.046875f,
+	0.273438f,
+	0.046875f,
+	0.28125f,
+	0.046875f,
+	0.289063f,
+	0.046875f,
+	0.296875f,
+	0.046875f,
+	0.304688f,
+	0.046875f,
+	0.3125f,
+	0.046875f,
+	0.320313f,
+	0.046875f,
+	0.328125f,
+	0.046875f,
+	0.335938f,
+	0.046875f,
+	0.34375f,
+	0.046875f,
+	0.351563f,
+	0.046875f,
+	0.359375f,
+	0.046875f,
+	0.367188f,
+	0.046875f,
+	0.375f,
+	0.046875f,
+	0.382813f,
+	0.046875f,
+	0.390625f,
+	0.046875f,
+	0.398438f,
+	0.046875f,
+	0.40625f,
+	0.046875f,
+	0.414063f,
+	0.046875f,
+	0.421875f,
+	0.046875f,
+	0.429688f,
+	0.046875f,
+	0.4375f,
+	0.046875f,
+	0.445313f,
+	0.046875f,
+	0.453125f,
+	0.046875f,
+	0.460938f,
+	0.046875f,
+	0.46875f,
+	0.046875f,
+	0.476563f,
+	0.046875f,
+	0.484375f,
+	0.046875f,
+	0.492188f,
+	0.046875f,
+	0.5f,
+	0.046875f,
+	0.507813f,
+	0.046875f,
+	0.0f,
+	0.0546875f,
+	0.0078125f,
+	0.0546875f,
+	0.015625f,
+	0.0546875f,
+	0.0234375f,
+	0.0546875f,
+	0.03125f,
+	0.0546875f,
+	0.0390625f,
+	0.0546875f,
+	0.046875f,
+	0.0546875f,
+	0.0546875f,
+	0.0546875f,
+	0.0625f,
+	0.0546875f,
+	0.0703125f,
+	0.0546875f,
+	0.078125f,
+	0.0546875f,
+	0.0859375f,
+	0.0546875f,
+	0.09375f,
+	0.0546875f,
+	0.101563f,
+	0.0546875f,
+	0.109375f,
+	0.0546875f,
+	0.117188f,
+	0.0546875f,
+	0.125f,
+	0.0546875f,
+	0.132813f,
+	0.0546875f,
+	0.140625f,
+	0.0546875f,
+	0.148438f,
+	0.0546875f,
+	0.15625f,
+	0.0546875f,
+	0.164063f,
+	0.0546875f,
+	0.171875f,
+	0.0546875f,
+	0.179688f,
+	0.0546875f,
+	0.1875f,
+	0.0546875f,
+	0.195313f,
+	0.0546875f,
+	0.203125f,
+	0.0546875f,
+	0.210938f,
+	0.0546875f,
+	0.21875f,
+	0.0546875f,
+	0.226563f,
+	0.0546875f,
+	0.234375f,
+	0.0546875f,
+	0.242188f,
+	0.0546875f,
+	0.25f,
+	0.0546875f,
+	0.257813f,
+	0.0546875f,
+	0.265625f,
+	0.0546875f,
+	0.273438f,
+	0.0546875f,
+	0.28125f,
+	0.0546875f,
+	0.289063f,
+	0.0546875f,
+	0.296875f,
+	0.0546875f,
+	0.304688f,
+	0.0546875f,
+	0.3125f,
+	0.0546875f,
+	0.320313f,
+	0.0546875f,
+	0.328125f,
+	0.0546875f,
+	0.335938f,
+	0.0546875f,
+	0.34375f,
+	0.0546875f,
+	0.351563f,
+	0.0546875f,
+	0.359375f,
+	0.0546875f,
+	0.367188f,
+	0.0546875f,
+	0.375f,
+	0.0546875f,
+	0.382813f,
+	0.0546875f,
+	0.390625f,
+	0.0546875f,
+	0.398438f,
+	0.0546875f,
+	0.40625f,
+	0.0546875f,
+	0.414063f,
+	0.0546875f,
+	0.421875f,
+	0.0546875f,
+	0.429688f,
+	0.0546875f,
+	0.4375f,
+	0.0546875f,
+	0.445313f,
+	0.0546875f,
+	0.453125f,
+	0.0546875f,
+	0.460938f,
+	0.0546875f,
+	0.46875f,
+	0.0546875f,
+	0.476563f,
+	0.0546875f,
+	0.484375f,
+	0.0546875f,
+	0.492188f,
+	0.0546875f,
+	0.5f,
+	0.0546875f,
+	0.507813f,
+	0.0546875f,
+	0.0f,
+	0.0625f,
+	0.0078125f,
+	0.0625f,
+	0.015625f,
+	0.0625f,
+	0.0234375f,
+	0.0625f,
+	0.03125f,
+	0.0625f,
+	0.0390625f,
+	0.0625f,
+	0.046875f,
+	0.0625f,
+	0.0546875f,
+	0.0625f,
+	0.0625f,
+	0.0625f,
+	0.0703125f,
+	0.0625f,
+	0.078125f,
+	0.0625f,
+	0.0859375f,
+	0.0625f,
+	0.09375f,
+	0.0625f,
+	0.101563f,
+	0.0625f,
+	0.109375f,
+	0.0625f,
+	0.117188f,
+	0.0625f,
+	0.125f,
+	0.0625f,
+	0.132813f,
+	0.0625f,
+	0.140625f,
+	0.0625f,
+	0.148438f,
+	0.0625f,
+	0.15625f,
+	0.0625f,
+	0.164063f,
+	0.0625f,
+	0.171875f,
+	0.0625f,
+	0.179688f,
+	0.0625f,
+	0.1875f,
+	0.0625f,
+	0.195313f,
+	0.0625f,
+	0.203125f,
+	0.0625f,
+	0.210938f,
+	0.0625f,
+	0.21875f,
+	0.0625f,
+	0.226563f,
+	0.0625f,
+	0.234375f,
+	0.0625f,
+	0.242188f,
+	0.0625f,
+	0.25f,
+	0.0625f,
+	0.257813f,
+	0.0625f,
+	0.265625f,
+	0.0625f,
+	0.273438f,
+	0.0625f,
+	0.28125f,
+	0.0625f,
+	0.289063f,
+	0.0625f,
+	0.296875f,
+	0.0625f,
+	0.304688f,
+	0.0625f,
+	0.3125f,
+	0.0625f,
+	0.320313f,
+	0.0625f,
+	0.328125f,
+	0.0625f,
+	0.335938f,
+	0.0625f,
+	0.34375f,
+	0.0625f,
+	0.351563f,
+	0.0625f,
+	0.359375f,
+	0.0625f,
+	0.367188f,
+	0.0625f,
+	0.375f,
+	0.0625f,
+	0.382813f,
+	0.0625f,
+	0.390625f,
+	0.0625f,
+	0.398438f,
+	0.0625f,
+	0.40625f,
+	0.0625f,
+	0.414063f,
+	0.0625f,
+	0.421875f,
+	0.0625f,
+	0.429688f,
+	0.0625f,
+	0.4375f,
+	0.0625f,
+	0.445313f,
+	0.0625f,
+	0.453125f,
+	0.0625f,
+	0.460938f,
+	0.0625f,
+	0.46875f,
+	0.0625f,
+	0.476563f,
+	0.0625f,
+	0.484375f,
+	0.0625f,
+	0.492188f,
+	0.0625f,
+	0.5f,
+	0.0625f,
+	0.507813f,
+	0.0625f,
+	0.0f,
+	0.0703125f,
+	0.0078125f,
+	0.0703125f,
+	0.015625f,
+	0.0703125f,
+	0.0234375f,
+	0.0703125f,
+	0.03125f,
+	0.0703125f,
+	0.0390625f,
+	0.0703125f,
+	0.046875f,
+	0.0703125f,
+	0.0546875f,
+	0.0703125f,
+	0.0625f,
+	0.0703125f,
+	0.0703125f,
+	0.0703125f,
+	0.078125f,
+	0.0703125f,
+	0.0859375f,
+	0.0703125f,
+	0.09375f,
+	0.0703125f,
+	0.101563f,
+	0.0703125f,
+	0.109375f,
+	0.0703125f,
+	0.117188f,
+	0.0703125f,
+	0.125f,
+	0.0703125f,
+	0.132813f,
+	0.0703125f,
+	0.140625f,
+	0.0703125f,
+	0.148438f,
+	0.0703125f,
+	0.15625f,
+	0.0703125f,
+	0.164063f,
+	0.0703125f,
+	0.171875f,
+	0.0703125f,
+	0.179688f,
+	0.0703125f,
+	0.1875f,
+	0.0703125f,
+	0.195313f,
+	0.0703125f,
+	0.203125f,
+	0.0703125f,
+	0.210938f,
+	0.0703125f,
+	0.21875f,
+	0.0703125f,
+	0.226563f,
+	0.0703125f,
+	0.234375f,
+	0.0703125f,
+	0.242188f,
+	0.0703125f,
+	0.25f,
+	0.0703125f,
+	0.257813f,
+	0.0703125f,
+	0.265625f,
+	0.0703125f,
+	0.273438f,
+	0.0703125f,
+	0.28125f,
+	0.0703125f,
+	0.289063f,
+	0.0703125f,
+	0.296875f,
+	0.0703125f,
+	0.304688f,
+	0.0703125f,
+	0.3125f,
+	0.0703125f,
+	0.320313f,
+	0.0703125f,
+	0.328125f,
+	0.0703125f,
+	0.335938f,
+	0.0703125f,
+	0.34375f,
+	0.0703125f,
+	0.351563f,
+	0.0703125f,
+	0.359375f,
+	0.0703125f,
+	0.367188f,
+	0.0703125f,
+	0.375f,
+	0.0703125f,
+	0.382813f,
+	0.0703125f,
+	0.390625f,
+	0.0703125f,
+	0.398438f,
+	0.0703125f,
+	0.40625f,
+	0.0703125f,
+	0.414063f,
+	0.0703125f,
+	0.421875f,
+	0.0703125f,
+	0.429688f,
+	0.0703125f,
+	0.4375f,
+	0.0703125f,
+	0.445313f,
+	0.0703125f,
+	0.453125f,
+	0.0703125f,
+	0.460938f,
+	0.0703125f,
+	0.46875f,
+	0.0703125f,
+	0.476563f,
+	0.0703125f,
+	0.484375f,
+	0.0703125f,
+	0.492188f,
+	0.0703125f,
+	0.5f,
+	0.0703125f,
+	0.507813f,
+	0.0703125f,
+	0.0f,
+	0.078125f,
+	0.0078125f,
+	0.078125f,
+	0.015625f,
+	0.078125f,
+	0.0234375f,
+	0.078125f,
+	0.03125f,
+	0.078125f,
+	0.0390625f,
+	0.078125f,
+	0.046875f,
+	0.078125f,
+	0.0546875f,
+	0.078125f,
+	0.0625f,
+	0.078125f,
+	0.0703125f,
+	0.078125f,
+	0.078125f,
+	0.078125f,
+	0.0859375f,
+	0.078125f,
+	0.09375f,
+	0.078125f,
+	0.101563f,
+	0.078125f,
+	0.109375f,
+	0.078125f,
+	0.117188f,
+	0.078125f,
+	0.125f,
+	0.078125f,
+	0.132813f,
+	0.078125f,
+	0.140625f,
+	0.078125f,
+	0.148438f,
+	0.078125f,
+	0.15625f,
+	0.078125f,
+	0.164063f,
+	0.078125f,
+	0.171875f,
+	0.078125f,
+	0.179688f,
+	0.078125f,
+	0.1875f,
+	0.078125f,
+	0.195313f,
+	0.078125f,
+	0.203125f,
+	0.078125f,
+	0.210938f,
+	0.078125f,
+	0.21875f,
+	0.078125f,
+	0.226563f,
+	0.078125f,
+	0.234375f,
+	0.078125f,
+	0.242188f,
+	0.078125f,
+	0.25f,
+	0.078125f,
+	0.257813f,
+	0.078125f,
+	0.265625f,
+	0.078125f,
+	0.273438f,
+	0.078125f,
+	0.28125f,
+	0.078125f,
+	0.289063f,
+	0.078125f,
+	0.296875f,
+	0.078125f,
+	0.304688f,
+	0.078125f,
+	0.3125f,
+	0.078125f,
+	0.320313f,
+	0.078125f,
+	0.328125f,
+	0.078125f,
+	0.335938f,
+	0.078125f,
+	0.34375f,
+	0.078125f,
+	0.351563f,
+	0.078125f,
+	0.359375f,
+	0.078125f,
+	0.367188f,
+	0.078125f,
+	0.375f,
+	0.078125f,
+	0.382813f,
+	0.078125f,
+	0.390625f,
+	0.078125f,
+	0.398438f,
+	0.078125f,
+	0.40625f,
+	0.078125f,
+	0.414063f,
+	0.078125f,
+	0.421875f,
+	0.078125f,
+	0.429688f,
+	0.078125f,
+	0.4375f,
+	0.078125f,
+	0.445313f,
+	0.078125f,
+	0.453125f,
+	0.078125f,
+	0.460938f,
+	0.078125f,
+	0.46875f,
+	0.078125f,
+	0.476563f,
+	0.078125f,
+	0.484375f,
+	0.078125f,
+	0.492188f,
+	0.078125f,
+	0.5f,
+	0.078125f,
+	0.507813f,
+	0.078125f,
+	0.0f,
+	0.0859375f,
+	0.0078125f,
+	0.0859375f,
+	0.015625f,
+	0.0859375f,
+	0.0234375f,
+	0.0859375f,
+	0.03125f,
+	0.0859375f,
+	0.0390625f,
+	0.0859375f,
+	0.046875f,
+	0.0859375f,
+	0.0546875f,
+	0.0859375f,
+	0.0625f,
+	0.0859375f,
+	0.0703125f,
+	0.0859375f,
+	0.078125f,
+	0.0859375f,
+	0.0859375f,
+	0.0859375f,
+	0.09375f,
+	0.0859375f,
+	0.101563f,
+	0.0859375f,
+	0.109375f,
+	0.0859375f,
+	0.117188f,
+	0.0859375f,
+	0.125f,
+	0.0859375f,
+	0.132813f,
+	0.0859375f,
+	0.140625f,
+	0.0859375f,
+	0.148438f,
+	0.0859375f,
+	0.15625f,
+	0.0859375f,
+	0.164063f,
+	0.0859375f,
+	0.171875f,
+	0.0859375f,
+	0.179688f,
+	0.0859375f,
+	0.1875f,
+	0.0859375f,
+	0.195313f,
+	0.0859375f,
+	0.203125f,
+	0.0859375f,
+	0.210938f,
+	0.0859375f,
+	0.21875f,
+	0.0859375f,
+	0.226563f,
+	0.0859375f,
+	0.234375f,
+	0.0859375f,
+	0.242188f,
+	0.0859375f,
+	0.25f,
+	0.0859375f,
+	0.257813f,
+	0.0859375f,
+	0.265625f,
+	0.0859375f,
+	0.273438f,
+	0.0859375f,
+	0.28125f,
+	0.0859375f,
+	0.289063f,
+	0.0859375f,
+	0.296875f,
+	0.0859375f,
+	0.304688f,
+	0.0859375f,
+	0.3125f,
+	0.0859375f,
+	0.320313f,
+	0.0859375f,
+	0.328125f,
+	0.0859375f,
+	0.335938f,
+	0.0859375f,
+	0.34375f,
+	0.0859375f,
+	0.351563f,
+	0.0859375f,
+	0.359375f,
+	0.0859375f,
+	0.367188f,
+	0.0859375f,
+	0.375f,
+	0.0859375f,
+	0.382813f,
+	0.0859375f,
+	0.390625f,
+	0.0859375f,
+	0.398438f,
+	0.0859375f,
+	0.40625f,
+	0.0859375f,
+	0.414063f,
+	0.0859375f,
+	0.421875f,
+	0.0859375f,
+	0.429688f,
+	0.0859375f,
+	0.4375f,
+	0.0859375f,
+	0.445313f,
+	0.0859375f,
+	0.453125f,
+	0.0859375f,
+	0.460938f,
+	0.0859375f,
+	0.46875f,
+	0.0859375f,
+	0.476563f,
+	0.0859375f,
+	0.484375f,
+	0.0859375f,
+	0.492188f,
+	0.0859375f,
+	0.5f,
+	0.0859375f,
+	0.507813f,
+	0.0859375f,
+	0.0f,
+	0.09375f,
+	0.0078125f,
+	0.09375f,
+	0.015625f,
+	0.09375f,
+	0.0234375f,
+	0.09375f,
+	0.03125f,
+	0.09375f,
+	0.0390625f,
+	0.09375f,
+	0.046875f,
+	0.09375f,
+	0.0546875f,
+	0.09375f,
+	0.0625f,
+	0.09375f,
+	0.0703125f,
+	0.09375f,
+	0.078125f,
+	0.09375f,
+	0.0859375f,
+	0.09375f,
+	0.09375f,
+	0.09375f,
+	0.101563f,
+	0.09375f,
+	0.109375f,
+	0.09375f,
+	0.117188f,
+	0.09375f,
+	0.125f,
+	0.09375f,
+	0.132813f,
+	0.09375f,
+	0.140625f,
+	0.09375f,
+	0.148438f,
+	0.09375f,
+	0.15625f,
+	0.09375f,
+	0.164063f,
+	0.09375f,
+	0.171875f,
+	0.09375f,
+	0.179688f,
+	0.09375f,
+	0.1875f,
+	0.09375f,
+	0.195313f,
+	0.09375f,
+	0.203125f,
+	0.09375f,
+	0.210938f,
+	0.09375f,
+	0.21875f,
+	0.09375f,
+	0.226563f,
+	0.09375f,
+	0.234375f,
+	0.09375f,
+	0.242188f,
+	0.09375f,
+	0.25f,
+	0.09375f,
+	0.257813f,
+	0.09375f,
+	0.265625f,
+	0.09375f,
+	0.273438f,
+	0.09375f,
+	0.28125f,
+	0.09375f,
+	0.289063f,
+	0.09375f,
+	0.296875f,
+	0.09375f,
+	0.304688f,
+	0.09375f,
+	0.3125f,
+	0.09375f,
+	0.320313f,
+	0.09375f,
+	0.328125f,
+	0.09375f,
+	0.335938f,
+	0.09375f,
+	0.34375f,
+	0.09375f,
+	0.351563f,
+	0.09375f,
+	0.359375f,
+	0.09375f,
+	0.367188f,
+	0.09375f,
+	0.375f,
+	0.09375f,
+	0.382813f,
+	0.09375f,
+	0.390625f,
+	0.09375f,
+	0.398438f,
+	0.09375f,
+	0.40625f,
+	0.09375f,
+	0.414063f,
+	0.09375f,
+	0.421875f,
+	0.09375f,
+	0.429688f,
+	0.09375f,
+	0.4375f,
+	0.09375f,
+	0.445313f,
+	0.09375f,
+	0.453125f,
+	0.09375f,
+	0.460938f,
+	0.09375f,
+	0.46875f,
+	0.09375f,
+	0.476563f,
+	0.09375f,
+	0.484375f,
+	0.09375f,
+	0.492188f,
+	0.09375f,
+	0.5f,
+	0.09375f,
+	0.507813f,
+	0.09375f,
+	0.0f,
+	0.101563f,
+	0.0078125f,
+	0.101563f,
+	0.015625f,
+	0.101563f,
+	0.0234375f,
+	0.101563f,
+	0.03125f,
+	0.101563f,
+	0.0390625f,
+	0.101563f,
+	0.046875f,
+	0.101563f,
+	0.0546875f,
+	0.101563f,
+	0.0625f,
+	0.101563f,
+	0.0703125f,
+	0.101563f,
+	0.078125f,
+	0.101563f,
+	0.0859375f,
+	0.101563f,
+	0.09375f,
+	0.101563f,
+	0.101563f,
+	0.101563f,
+	0.109375f,
+	0.101563f,
+	0.117188f,
+	0.101563f,
+	0.125f,
+	0.101563f,
+	0.132813f,
+	0.101563f,
+	0.140625f,
+	0.101563f,
+	0.148438f,
+	0.101563f,
+	0.15625f,
+	0.101563f,
+	0.164063f,
+	0.101563f,
+	0.171875f,
+	0.101563f,
+	0.179688f,
+	0.101563f,
+	0.1875f,
+	0.101563f,
+	0.195313f,
+	0.101563f,
+	0.203125f,
+	0.101563f,
+	0.210938f,
+	0.101563f,
+	0.21875f,
+	0.101563f,
+	0.226563f,
+	0.101563f,
+	0.234375f,
+	0.101563f,
+	0.242188f,
+	0.101563f,
+	0.25f,
+	0.101563f,
+	0.257813f,
+	0.101563f,
+	0.265625f,
+	0.101563f,
+	0.273438f,
+	0.101563f,
+	0.28125f,
+	0.101563f,
+	0.289063f,
+	0.101563f,
+	0.296875f,
+	0.101563f,
+	0.304688f,
+	0.101563f,
+	0.3125f,
+	0.101563f,
+	0.320313f,
+	0.101563f,
+	0.328125f,
+	0.101563f,
+	0.335938f,
+	0.101563f,
+	0.34375f,
+	0.101563f,
+	0.351563f,
+	0.101563f,
+	0.359375f,
+	0.101563f,
+	0.367188f,
+	0.101563f,
+	0.375f,
+	0.101563f,
+	0.382813f,
+	0.101563f,
+	0.390625f,
+	0.101563f,
+	0.398438f,
+	0.101563f,
+	0.40625f,
+	0.101563f,
+	0.414063f,
+	0.101563f,
+	0.421875f,
+	0.101563f,
+	0.429688f,
+	0.101563f,
+	0.4375f,
+	0.101563f,
+	0.445313f,
+	0.101563f,
+	0.453125f,
+	0.101563f,
+	0.460938f,
+	0.101563f,
+	0.46875f,
+	0.101563f,
+	0.476563f,
+	0.101563f,
+	0.484375f,
+	0.101563f,
+	0.492188f,
+	0.101563f,
+	0.5f,
+	0.101563f,
+	0.507813f,
+	0.101563f,
+	0.0f,
+	0.109375f,
+	0.0078125f,
+	0.109375f,
+	0.015625f,
+	0.109375f,
+	0.0234375f,
+	0.109375f,
+	0.03125f,
+	0.109375f,
+	0.0390625f,
+	0.109375f,
+	0.046875f,
+	0.109375f,
+	0.0546875f,
+	0.109375f,
+	0.0625f,
+	0.109375f,
+	0.0703125f,
+	0.109375f,
+	0.078125f,
+	0.109375f,
+	0.0859375f,
+	0.109375f,
+	0.09375f,
+	0.109375f,
+	0.101563f,
+	0.109375f,
+	0.109375f,
+	0.109375f,
+	0.117188f,
+	0.109375f,
+	0.125f,
+	0.109375f,
+	0.132813f,
+	0.109375f,
+	0.140625f,
+	0.109375f,
+	0.148438f,
+	0.109375f,
+	0.15625f,
+	0.109375f,
+	0.164063f,
+	0.109375f,
+	0.171875f,
+	0.109375f,
+	0.179688f,
+	0.109375f,
+	0.1875f,
+	0.109375f,
+	0.195313f,
+	0.109375f,
+	0.203125f,
+	0.109375f,
+	0.210938f,
+	0.109375f,
+	0.21875f,
+	0.109375f,
+	0.226563f,
+	0.109375f,
+	0.234375f,
+	0.109375f,
+	0.242188f,
+	0.109375f,
+	0.25f,
+	0.109375f,
+	0.257813f,
+	0.109375f,
+	0.265625f,
+	0.109375f,
+	0.273438f,
+	0.109375f,
+	0.28125f,
+	0.109375f,
+	0.289063f,
+	0.109375f,
+	0.296875f,
+	0.109375f,
+	0.304688f,
+	0.109375f,
+	0.3125f,
+	0.109375f,
+	0.320313f,
+	0.109375f,
+	0.328125f,
+	0.109375f,
+	0.335938f,
+	0.109375f,
+	0.34375f,
+	0.109375f,
+	0.351563f,
+	0.109375f,
+	0.359375f,
+	0.109375f,
+	0.367188f,
+	0.109375f,
+	0.375f,
+	0.109375f,
+	0.382813f,
+	0.109375f,
+	0.390625f,
+	0.109375f,
+	0.398438f,
+	0.109375f,
+	0.40625f,
+	0.109375f,
+	0.414063f,
+	0.109375f,
+	0.421875f,
+	0.109375f,
+	0.429688f,
+	0.109375f,
+	0.4375f,
+	0.109375f,
+	0.445313f,
+	0.109375f,
+	0.453125f,
+	0.109375f,
+	0.460938f,
+	0.109375f,
+	0.46875f,
+	0.109375f,
+	0.476563f,
+	0.109375f,
+	0.484375f,
+	0.109375f,
+	0.492188f,
+	0.109375f,
+	0.5f,
+	0.109375f,
+	0.507813f,
+	0.109375f,
+	0.0f,
+	0.117188f,
+	0.0078125f,
+	0.117188f,
+	0.015625f,
+	0.117188f,
+	0.0234375f,
+	0.117188f,
+	0.03125f,
+	0.117188f,
+	0.0390625f,
+	0.117188f,
+	0.046875f,
+	0.117188f,
+	0.0546875f,
+	0.117188f,
+	0.0625f,
+	0.117188f,
+	0.0703125f,
+	0.117188f,
+	0.078125f,
+	0.117188f,
+	0.0859375f,
+	0.117188f,
+	0.09375f,
+	0.117188f,
+	0.101563f,
+	0.117188f,
+	0.109375f,
+	0.117188f,
+	0.117188f,
+	0.117188f,
+	0.125f,
+	0.117188f,
+	0.132813f,
+	0.117188f,
+	0.140625f,
+	0.117188f,
+	0.148438f,
+	0.117188f,
+	0.15625f,
+	0.117188f,
+	0.164063f,
+	0.117188f,
+	0.171875f,
+	0.117188f,
+	0.179688f,
+	0.117188f,
+	0.1875f,
+	0.117188f,
+	0.195313f,
+	0.117188f,
+	0.203125f,
+	0.117188f,
+	0.210938f,
+	0.117188f,
+	0.21875f,
+	0.117188f,
+	0.226563f,
+	0.117188f,
+	0.234375f,
+	0.117188f,
+	0.242188f,
+	0.117188f,
+	0.25f,
+	0.117188f,
+	0.257813f,
+	0.117188f,
+	0.265625f,
+	0.117188f,
+	0.273438f,
+	0.117188f,
+	0.28125f,
+	0.117188f,
+	0.289063f,
+	0.117188f,
+	0.296875f,
+	0.117188f,
+	0.304688f,
+	0.117188f,
+	0.3125f,
+	0.117188f,
+	0.320313f,
+	0.117188f,
+	0.328125f,
+	0.117188f,
+	0.335938f,
+	0.117188f,
+	0.34375f,
+	0.117188f,
+	0.351563f,
+	0.117188f,
+	0.359375f,
+	0.117188f,
+	0.367188f,
+	0.117188f,
+	0.375f,
+	0.117188f,
+	0.382813f,
+	0.117188f,
+	0.390625f,
+	0.117188f,
+	0.398438f,
+	0.117188f,
+	0.40625f,
+	0.117188f,
+	0.414063f,
+	0.117188f,
+	0.421875f,
+	0.117188f,
+	0.429688f,
+	0.117188f,
+	0.4375f,
+	0.117188f,
+	0.445313f,
+	0.117188f,
+	0.453125f,
+	0.117188f,
+	0.460938f,
+	0.117188f,
+	0.46875f,
+	0.117188f,
+	0.476563f,
+	0.117188f,
+	0.484375f,
+	0.117188f,
+	0.492188f,
+	0.117188f,
+	0.5f,
+	0.117188f,
+	0.507813f,
+	0.117188f,
+	0.0f,
+	0.125f,
+	0.0078125f,
+	0.125f,
+	0.015625f,
+	0.125f,
+	0.0234375f,
+	0.125f,
+	0.03125f,
+	0.125f,
+	0.0390625f,
+	0.125f,
+	0.046875f,
+	0.125f,
+	0.0546875f,
+	0.125f,
+	0.0625f,
+	0.125f,
+	0.0703125f,
+	0.125f,
+	0.078125f,
+	0.125f,
+	0.0859375f,
+	0.125f,
+	0.09375f,
+	0.125f,
+	0.101563f,
+	0.125f,
+	0.109375f,
+	0.125f,
+	0.117188f,
+	0.125f,
+	0.125f,
+	0.125f,
+	0.132813f,
+	0.125f,
+	0.140625f,
+	0.125f,
+	0.148438f,
+	0.125f,
+	0.15625f,
+	0.125f,
+	0.164063f,
+	0.125f,
+	0.171875f,
+	0.125f,
+	0.179688f,
+	0.125f,
+	0.1875f,
+	0.125f,
+	0.195313f,
+	0.125f,
+	0.203125f,
+	0.125f,
+	0.210938f,
+	0.125f,
+	0.21875f,
+	0.125f,
+	0.226563f,
+	0.125f,
+	0.234375f,
+	0.125f,
+	0.242188f,
+	0.125f,
+	0.25f,
+	0.125f,
+	0.257813f,
+	0.125f,
+	0.265625f,
+	0.125f,
+	0.273438f,
+	0.125f,
+	0.28125f,
+	0.125f,
+	0.289063f,
+	0.125f,
+	0.296875f,
+	0.125f,
+	0.304688f,
+	0.125f,
+	0.3125f,
+	0.125f,
+	0.320313f,
+	0.125f,
+	0.328125f,
+	0.125f,
+	0.335938f,
+	0.125f,
+	0.34375f,
+	0.125f,
+	0.351563f,
+	0.125f,
+	0.359375f,
+	0.125f,
+	0.367188f,
+	0.125f,
+	0.375f,
+	0.125f,
+	0.382813f,
+	0.125f,
+	0.390625f,
+	0.125f,
+	0.398438f,
+	0.125f,
+	0.40625f,
+	0.125f,
+	0.414063f,
+	0.125f,
+	0.421875f,
+	0.125f,
+	0.429688f,
+	0.125f,
+	0.4375f,
+	0.125f,
+	0.445313f,
+	0.125f,
+	0.453125f,
+	0.125f,
+	0.460938f,
+	0.125f,
+	0.46875f,
+	0.125f,
+	0.476563f,
+	0.125f,
+	0.484375f,
+	0.125f,
+	0.492188f,
+	0.125f,
+	0.5f,
+	0.125f,
+	0.507813f,
+	0.125f,
+	0.0f,
+	0.132813f,
+	0.0078125f,
+	0.132813f,
+	0.015625f,
+	0.132813f,
+	0.0234375f,
+	0.132813f,
+	0.03125f,
+	0.132813f,
+	0.0390625f,
+	0.132813f,
+	0.046875f,
+	0.132813f,
+	0.0546875f,
+	0.132813f,
+	0.0625f,
+	0.132813f,
+	0.0703125f,
+	0.132813f,
+	0.078125f,
+	0.132813f,
+	0.0859375f,
+	0.132813f,
+	0.09375f,
+	0.132813f,
+	0.101563f,
+	0.132813f,
+	0.109375f,
+	0.132813f,
+	0.117188f,
+	0.132813f,
+	0.125f,
+	0.132813f,
+	0.132813f,
+	0.132813f,
+	0.140625f,
+	0.132813f,
+	0.148438f,
+	0.132813f,
+	0.15625f,
+	0.132813f,
+	0.164063f,
+	0.132813f,
+	0.171875f,
+	0.132813f,
+	0.179688f,
+	0.132813f,
+	0.1875f,
+	0.132813f,
+	0.195313f,
+	0.132813f,
+	0.203125f,
+	0.132813f,
+	0.210938f,
+	0.132813f,
+	0.21875f,
+	0.132813f,
+	0.226563f,
+	0.132813f,
+	0.234375f,
+	0.132813f,
+	0.242188f,
+	0.132813f,
+	0.25f,
+	0.132813f,
+	0.257813f,
+	0.132813f,
+	0.265625f,
+	0.132813f,
+	0.273438f,
+	0.132813f,
+	0.28125f,
+	0.132813f,
+	0.289063f,
+	0.132813f,
+	0.296875f,
+	0.132813f,
+	0.304688f,
+	0.132813f,
+	0.3125f,
+	0.132813f,
+	0.320313f,
+	0.132813f,
+	0.328125f,
+	0.132813f,
+	0.335938f,
+	0.132813f,
+	0.34375f,
+	0.132813f,
+	0.351563f,
+	0.132813f,
+	0.359375f,
+	0.132813f,
+	0.367188f,
+	0.132813f,
+	0.375f,
+	0.132813f,
+	0.382813f,
+	0.132813f,
+	0.390625f,
+	0.132813f,
+	0.398438f,
+	0.132813f,
+	0.40625f,
+	0.132813f,
+	0.414063f,
+	0.132813f,
+	0.421875f,
+	0.132813f,
+	0.429688f,
+	0.132813f,
+	0.4375f,
+	0.132813f,
+	0.445313f,
+	0.132813f,
+	0.453125f,
+	0.132813f,
+	0.460938f,
+	0.132813f,
+	0.46875f,
+	0.132813f,
+	0.476563f,
+	0.132813f,
+	0.484375f,
+	0.132813f,
+	0.492188f,
+	0.132813f,
+	0.5f,
+	0.132813f,
+	0.507813f,
+	0.132813f,
+	0.0f,
+	0.140625f,
+	0.0078125f,
+	0.140625f,
+	0.015625f,
+	0.140625f,
+	0.0234375f,
+	0.140625f,
+	0.03125f,
+	0.140625f,
+	0.0390625f,
+	0.140625f,
+	0.046875f,
+	0.140625f,
+	0.0546875f,
+	0.140625f,
+	0.0625f,
+	0.140625f,
+	0.0703125f,
+	0.140625f,
+	0.078125f,
+	0.140625f,
+	0.0859375f,
+	0.140625f,
+	0.09375f,
+	0.140625f,
+	0.101563f,
+	0.140625f,
+	0.109375f,
+	0.140625f,
+	0.117188f,
+	0.140625f,
+	0.125f,
+	0.140625f,
+	0.132813f,
+	0.140625f,
+	0.140625f,
+	0.140625f,
+	0.148438f,
+	0.140625f,
+	0.15625f,
+	0.140625f,
+	0.164063f,
+	0.140625f,
+	0.171875f,
+	0.140625f,
+	0.179688f,
+	0.140625f,
+	0.1875f,
+	0.140625f,
+	0.195313f,
+	0.140625f,
+	0.203125f,
+	0.140625f,
+	0.210938f,
+	0.140625f,
+	0.21875f,
+	0.140625f,
+	0.226563f,
+	0.140625f,
+	0.234375f,
+	0.140625f,
+	0.242188f,
+	0.140625f,
+	0.25f,
+	0.140625f,
+	0.257813f,
+	0.140625f,
+	0.265625f,
+	0.140625f,
+	0.273438f,
+	0.140625f,
+	0.28125f,
+	0.140625f,
+	0.289063f,
+	0.140625f,
+	0.296875f,
+	0.140625f,
+	0.304688f,
+	0.140625f,
+	0.3125f,
+	0.140625f,
+	0.320313f,
+	0.140625f,
+	0.328125f,
+	0.140625f,
+	0.335938f,
+	0.140625f,
+	0.34375f,
+	0.140625f,
+	0.351563f,
+	0.140625f,
+	0.359375f,
+	0.140625f,
+	0.367188f,
+	0.140625f,
+	0.375f,
+	0.140625f,
+	0.382813f,
+	0.140625f,
+	0.390625f,
+	0.140625f,
+	0.398438f,
+	0.140625f,
+	0.40625f,
+	0.140625f,
+	0.414063f,
+	0.140625f,
+	0.421875f,
+	0.140625f,
+	0.429688f,
+	0.140625f,
+	0.4375f,
+	0.140625f,
+	0.445313f,
+	0.140625f,
+	0.453125f,
+	0.140625f,
+	0.460938f,
+	0.140625f,
+	0.46875f,
+	0.140625f,
+	0.476563f,
+	0.140625f,
+	0.484375f,
+	0.140625f,
+	0.492188f,
+	0.140625f,
+	0.5f,
+	0.140625f,
+	0.507813f,
+	0.140625f,
+	0.0f,
+	0.148438f,
+	0.0078125f,
+	0.148438f,
+	0.015625f,
+	0.148438f,
+	0.0234375f,
+	0.148438f,
+	0.03125f,
+	0.148438f,
+	0.0390625f,
+	0.148438f,
+	0.046875f,
+	0.148438f,
+	0.0546875f,
+	0.148438f,
+	0.0625f,
+	0.148438f,
+	0.0703125f,
+	0.148438f,
+	0.078125f,
+	0.148438f,
+	0.0859375f,
+	0.148438f,
+	0.09375f,
+	0.148438f,
+	0.101563f,
+	0.148438f,
+	0.109375f,
+	0.148438f,
+	0.117188f,
+	0.148438f,
+	0.125f,
+	0.148438f,
+	0.132813f,
+	0.148438f,
+	0.140625f,
+	0.148438f,
+	0.148438f,
+	0.148438f,
+	0.15625f,
+	0.148438f,
+	0.164063f,
+	0.148438f,
+	0.171875f,
+	0.148438f,
+	0.179688f,
+	0.148438f,
+	0.1875f,
+	0.148438f,
+	0.195313f,
+	0.148438f,
+	0.203125f,
+	0.148438f,
+	0.210938f,
+	0.148438f,
+	0.21875f,
+	0.148438f,
+	0.226563f,
+	0.148438f,
+	0.234375f,
+	0.148438f,
+	0.242188f,
+	0.148438f,
+	0.25f,
+	0.148438f,
+	0.257813f,
+	0.148438f,
+	0.265625f,
+	0.148438f,
+	0.273438f,
+	0.148438f,
+	0.28125f,
+	0.148438f,
+	0.289063f,
+	0.148438f,
+	0.296875f,
+	0.148438f,
+	0.304688f,
+	0.148438f,
+	0.3125f,
+	0.148438f,
+	0.320313f,
+	0.148438f,
+	0.328125f,
+	0.148438f,
+	0.335938f,
+	0.148438f,
+	0.34375f,
+	0.148438f,
+	0.351563f,
+	0.148438f,
+	0.359375f,
+	0.148438f,
+	0.367188f,
+	0.148438f,
+	0.375f,
+	0.148438f,
+	0.382813f,
+	0.148438f,
+	0.390625f,
+	0.148438f,
+	0.398438f,
+	0.148438f,
+	0.40625f,
+	0.148438f,
+	0.414063f,
+	0.148438f,
+	0.421875f,
+	0.148438f,
+	0.429688f,
+	0.148438f,
+	0.4375f,
+	0.148438f,
+	0.445313f,
+	0.148438f,
+	0.453125f,
+	0.148438f,
+	0.460938f,
+	0.148438f,
+	0.46875f,
+	0.148438f,
+	0.476563f,
+	0.148438f,
+	0.484375f,
+	0.148438f,
+	0.492188f,
+	0.148438f,
+	0.5f,
+	0.148438f,
+	0.507813f,
+	0.148438f,
+	0.0f,
+	0.15625f,
+	0.0078125f,
+	0.15625f,
+	0.015625f,
+	0.15625f,
+	0.0234375f,
+	0.15625f,
+	0.03125f,
+	0.15625f,
+	0.0390625f,
+	0.15625f,
+	0.046875f,
+	0.15625f,
+	0.0546875f,
+	0.15625f,
+	0.0625f,
+	0.15625f,
+	0.0703125f,
+	0.15625f,
+	0.078125f,
+	0.15625f,
+	0.0859375f,
+	0.15625f,
+	0.09375f,
+	0.15625f,
+	0.101563f,
+	0.15625f,
+	0.109375f,
+	0.15625f,
+	0.117188f,
+	0.15625f,
+	0.125f,
+	0.15625f,
+	0.132813f,
+	0.15625f,
+	0.140625f,
+	0.15625f,
+	0.148438f,
+	0.15625f,
+	0.15625f,
+	0.15625f,
+	0.164063f,
+	0.15625f,
+	0.171875f,
+	0.15625f,
+	0.179688f,
+	0.15625f,
+	0.1875f,
+	0.15625f,
+	0.195313f,
+	0.15625f,
+	0.203125f,
+	0.15625f,
+	0.210938f,
+	0.15625f,
+	0.21875f,
+	0.15625f,
+	0.226563f,
+	0.15625f,
+	0.234375f,
+	0.15625f,
+	0.242188f,
+	0.15625f,
+	0.25f,
+	0.15625f,
+	0.257813f,
+	0.15625f,
+	0.265625f,
+	0.15625f,
+	0.273438f,
+	0.15625f,
+	0.28125f,
+	0.15625f,
+	0.289063f,
+	0.15625f,
+	0.296875f,
+	0.15625f,
+	0.304688f,
+	0.15625f,
+	0.3125f,
+	0.15625f,
+	0.320313f,
+	0.15625f,
+	0.328125f,
+	0.15625f,
+	0.335938f,
+	0.15625f,
+	0.34375f,
+	0.15625f,
+	0.351563f,
+	0.15625f,
+	0.359375f,
+	0.15625f,
+	0.367188f,
+	0.15625f,
+	0.375f,
+	0.15625f,
+	0.382813f,
+	0.15625f,
+	0.390625f,
+	0.15625f,
+	0.398438f,
+	0.15625f,
+	0.40625f,
+	0.15625f,
+	0.414063f,
+	0.15625f,
+	0.421875f,
+	0.15625f,
+	0.429688f,
+	0.15625f,
+	0.4375f,
+	0.15625f,
+	0.445313f,
+	0.15625f,
+	0.453125f,
+	0.15625f,
+	0.460938f,
+	0.15625f,
+	0.46875f,
+	0.15625f,
+	0.476563f,
+	0.15625f,
+	0.484375f,
+	0.15625f,
+	0.492188f,
+	0.15625f,
+	0.5f,
+	0.15625f,
+	0.507813f,
+	0.15625f,
+	0.0f,
+	0.164063f,
+	0.0078125f,
+	0.164063f,
+	0.015625f,
+	0.164063f,
+	0.0234375f,
+	0.164063f,
+	0.03125f,
+	0.164063f,
+	0.0390625f,
+	0.164063f,
+	0.046875f,
+	0.164063f,
+	0.0546875f,
+	0.164063f,
+	0.0625f,
+	0.164063f,
+	0.0703125f,
+	0.164063f,
+	0.078125f,
+	0.164063f,
+	0.0859375f,
+	0.164063f,
+	0.09375f,
+	0.164063f,
+	0.101563f,
+	0.164063f,
+	0.109375f,
+	0.164063f,
+	0.117188f,
+	0.164063f,
+	0.125f,
+	0.164063f,
+	0.132813f,
+	0.164063f,
+	0.140625f,
+	0.164063f,
+	0.148438f,
+	0.164063f,
+	0.15625f,
+	0.164063f,
+	0.164063f,
+	0.164063f,
+	0.171875f,
+	0.164063f,
+	0.179688f,
+	0.164063f,
+	0.1875f,
+	0.164063f,
+	0.195313f,
+	0.164063f,
+	0.203125f,
+	0.164063f,
+	0.210938f,
+	0.164063f,
+	0.21875f,
+	0.164063f,
+	0.226563f,
+	0.164063f,
+	0.234375f,
+	0.164063f,
+	0.242188f,
+	0.164063f,
+	0.25f,
+	0.164063f,
+	0.257813f,
+	0.164063f,
+	0.265625f,
+	0.164063f,
+	0.273438f,
+	0.164063f,
+	0.28125f,
+	0.164063f,
+	0.289063f,
+	0.164063f,
+	0.296875f,
+	0.164063f,
+	0.304688f,
+	0.164063f,
+	0.3125f,
+	0.164063f,
+	0.320313f,
+	0.164063f,
+	0.328125f,
+	0.164063f,
+	0.335938f,
+	0.164063f,
+	0.34375f,
+	0.164063f,
+	0.351563f,
+	0.164063f,
+	0.359375f,
+	0.164063f,
+	0.367188f,
+	0.164063f,
+	0.375f,
+	0.164063f,
+	0.382813f,
+	0.164063f,
+	0.390625f,
+	0.164063f,
+	0.398438f,
+	0.164063f,
+	0.40625f,
+	0.164063f,
+	0.414063f,
+	0.164063f,
+	0.421875f,
+	0.164063f,
+	0.429688f,
+	0.164063f,
+	0.4375f,
+	0.164063f,
+	0.445313f,
+	0.164063f,
+	0.453125f,
+	0.164063f,
+	0.460938f,
+	0.164063f,
+	0.46875f,
+	0.164063f,
+	0.476563f,
+	0.164063f,
+	0.484375f,
+	0.164063f,
+	0.492188f,
+	0.164063f,
+	0.5f,
+	0.164063f,
+	0.507813f,
+	0.164063f,
+	0.0f,
+	0.171875f,
+	0.0078125f,
+	0.171875f,
+	0.015625f,
+	0.171875f,
+	0.0234375f,
+	0.171875f,
+	0.03125f,
+	0.171875f,
+	0.0390625f,
+	0.171875f,
+	0.046875f,
+	0.171875f,
+	0.0546875f,
+	0.171875f,
+	0.0625f,
+	0.171875f,
+	0.0703125f,
+	0.171875f,
+	0.078125f,
+	0.171875f,
+	0.0859375f,
+	0.171875f,
+	0.09375f,
+	0.171875f,
+	0.101563f,
+	0.171875f,
+	0.109375f,
+	0.171875f,
+	0.117188f,
+	0.171875f,
+	0.125f,
+	0.171875f,
+	0.132813f,
+	0.171875f,
+	0.140625f,
+	0.171875f,
+	0.148438f,
+	0.171875f,
+	0.15625f,
+	0.171875f,
+	0.164063f,
+	0.171875f,
+	0.171875f,
+	0.171875f,
+	0.179688f,
+	0.171875f,
+	0.1875f,
+	0.171875f,
+	0.195313f,
+	0.171875f,
+	0.203125f,
+	0.171875f,
+	0.210938f,
+	0.171875f,
+	0.21875f,
+	0.171875f,
+	0.226563f,
+	0.171875f,
+	0.234375f,
+	0.171875f,
+	0.242188f,
+	0.171875f,
+	0.25f,
+	0.171875f,
+	0.257813f,
+	0.171875f,
+	0.265625f,
+	0.171875f,
+	0.273438f,
+	0.171875f,
+	0.28125f,
+	0.171875f,
+	0.289063f,
+	0.171875f,
+	0.296875f,
+	0.171875f,
+	0.304688f,
+	0.171875f,
+	0.3125f,
+	0.171875f,
+	0.320313f,
+	0.171875f,
+	0.328125f,
+	0.171875f,
+	0.335938f,
+	0.171875f,
+	0.34375f,
+	0.171875f,
+	0.351563f,
+	0.171875f,
+	0.359375f,
+	0.171875f,
+	0.367188f,
+	0.171875f,
+	0.375f,
+	0.171875f,
+	0.382813f,
+	0.171875f,
+	0.390625f,
+	0.171875f,
+	0.398438f,
+	0.171875f,
+	0.40625f,
+	0.171875f,
+	0.414063f,
+	0.171875f,
+	0.421875f,
+	0.171875f,
+	0.429688f,
+	0.171875f,
+	0.4375f,
+	0.171875f,
+	0.445313f,
+	0.171875f,
+	0.453125f,
+	0.171875f,
+	0.460938f,
+	0.171875f,
+	0.46875f,
+	0.171875f,
+	0.476563f,
+	0.171875f,
+	0.484375f,
+	0.171875f,
+	0.492188f,
+	0.171875f,
+	0.5f,
+	0.171875f,
+	0.507813f,
+	0.171875f,
+	0.0f,
+	0.179688f,
+	0.0078125f,
+	0.179688f,
+	0.015625f,
+	0.179688f,
+	0.0234375f,
+	0.179688f,
+	0.03125f,
+	0.179688f,
+	0.0390625f,
+	0.179688f,
+	0.046875f,
+	0.179688f,
+	0.0546875f,
+	0.179688f,
+	0.0625f,
+	0.179688f,
+	0.0703125f,
+	0.179688f,
+	0.078125f,
+	0.179688f,
+	0.0859375f,
+	0.179688f,
+	0.09375f,
+	0.179688f,
+	0.101563f,
+	0.179688f,
+	0.109375f,
+	0.179688f,
+	0.117188f,
+	0.179688f,
+	0.125f,
+	0.179688f,
+	0.132813f,
+	0.179688f,
+	0.140625f,
+	0.179688f,
+	0.148438f,
+	0.179688f,
+	0.15625f,
+	0.179688f,
+	0.164063f,
+	0.179688f,
+	0.171875f,
+	0.179688f,
+	0.179688f,
+	0.179688f,
+	0.1875f,
+	0.179688f,
+	0.195313f,
+	0.179688f,
+	0.203125f,
+	0.179688f,
+	0.210938f,
+	0.179688f,
+	0.21875f,
+	0.179688f,
+	0.226563f,
+	0.179688f,
+	0.234375f,
+	0.179688f,
+	0.242188f,
+	0.179688f,
+	0.25f,
+	0.179688f,
+	0.257813f,
+	0.179688f,
+	0.265625f,
+	0.179688f,
+	0.273438f,
+	0.179688f,
+	0.28125f,
+	0.179688f,
+	0.289063f,
+	0.179688f,
+	0.296875f,
+	0.179688f,
+	0.304688f,
+	0.179688f,
+	0.3125f,
+	0.179688f,
+	0.320313f,
+	0.179688f,
+	0.328125f,
+	0.179688f,
+	0.335938f,
+	0.179688f,
+	0.34375f,
+	0.179688f,
+	0.351563f,
+	0.179688f,
+	0.359375f,
+	0.179688f,
+	0.367188f,
+	0.179688f,
+	0.375f,
+	0.179688f,
+	0.382813f,
+	0.179688f,
+	0.390625f,
+	0.179688f,
+	0.398438f,
+	0.179688f,
+	0.40625f,
+	0.179688f,
+	0.414063f,
+	0.179688f,
+	0.421875f,
+	0.179688f,
+	0.429688f,
+	0.179688f,
+	0.4375f,
+	0.179688f,
+	0.445313f,
+	0.179688f,
+	0.453125f,
+	0.179688f,
+	0.460938f,
+	0.179688f,
+	0.46875f,
+	0.179688f,
+	0.476563f,
+	0.179688f,
+	0.484375f,
+	0.179688f,
+	0.492188f,
+	0.179688f,
+	0.5f,
+	0.179688f,
+	0.507813f,
+	0.179688f,
+	0.0f,
+	0.1875f,
+	0.0078125f,
+	0.1875f,
+	0.015625f,
+	0.1875f,
+	0.0234375f,
+	0.1875f,
+	0.03125f,
+	0.1875f,
+	0.0390625f,
+	0.1875f,
+	0.046875f,
+	0.1875f,
+	0.0546875f,
+	0.1875f,
+	0.0625f,
+	0.1875f,
+	0.0703125f,
+	0.1875f,
+	0.078125f,
+	0.1875f,
+	0.0859375f,
+	0.1875f,
+	0.09375f,
+	0.1875f,
+	0.101563f,
+	0.1875f,
+	0.109375f,
+	0.1875f,
+	0.117188f,
+	0.1875f,
+	0.125f,
+	0.1875f,
+	0.132813f,
+	0.1875f,
+	0.140625f,
+	0.1875f,
+	0.148438f,
+	0.1875f,
+	0.15625f,
+	0.1875f,
+	0.164063f,
+	0.1875f,
+	0.171875f,
+	0.1875f,
+	0.179688f,
+	0.1875f,
+	0.1875f,
+	0.1875f,
+	0.195313f,
+	0.1875f,
+	0.203125f,
+	0.1875f,
+	0.210938f,
+	0.1875f,
+	0.21875f,
+	0.1875f,
+	0.226563f,
+	0.1875f,
+	0.234375f,
+	0.1875f,
+	0.242188f,
+	0.1875f,
+	0.25f,
+	0.1875f,
+	0.257813f,
+	0.1875f,
+	0.265625f,
+	0.1875f,
+	0.273438f,
+	0.1875f,
+	0.28125f,
+	0.1875f,
+	0.289063f,
+	0.1875f,
+	0.296875f,
+	0.1875f,
+	0.304688f,
+	0.1875f,
+	0.3125f,
+	0.1875f,
+	0.320313f,
+	0.1875f,
+	0.328125f,
+	0.1875f,
+	0.335938f,
+	0.1875f,
+	0.34375f,
+	0.1875f,
+	0.351563f,
+	0.1875f,
+	0.359375f,
+	0.1875f,
+	0.367188f,
+	0.1875f,
+	0.375f,
+	0.1875f,
+	0.382813f,
+	0.1875f,
+	0.390625f,
+	0.1875f,
+	0.398438f,
+	0.1875f,
+	0.40625f,
+	0.1875f,
+	0.414063f,
+	0.1875f,
+	0.421875f,
+	0.1875f,
+	0.429688f,
+	0.1875f,
+	0.4375f,
+	0.1875f,
+	0.445313f,
+	0.1875f,
+	0.453125f,
+	0.1875f,
+	0.460938f,
+	0.1875f,
+	0.46875f,
+	0.1875f,
+	0.476563f,
+	0.1875f,
+	0.484375f,
+	0.1875f,
+	0.492188f,
+	0.1875f,
+	0.5f,
+	0.1875f,
+	0.507813f,
+	0.1875f,
+	0.0f,
+	0.195313f,
+	0.0078125f,
+	0.195313f,
+	0.015625f,
+	0.195313f,
+	0.0234375f,
+	0.195313f,
+	0.03125f,
+	0.195313f,
+	0.0390625f,
+	0.195313f,
+	0.046875f,
+	0.195313f,
+	0.0546875f,
+	0.195313f,
+	0.0625f,
+	0.195313f,
+	0.0703125f,
+	0.195313f,
+	0.078125f,
+	0.195313f,
+	0.0859375f,
+	0.195313f,
+	0.09375f,
+	0.195313f,
+	0.101563f,
+	0.195313f,
+	0.109375f,
+	0.195313f,
+	0.117188f,
+	0.195313f,
+	0.125f,
+	0.195313f,
+	0.132813f,
+	0.195313f,
+	0.140625f,
+	0.195313f,
+	0.148438f,
+	0.195313f,
+	0.15625f,
+	0.195313f,
+	0.164063f,
+	0.195313f,
+	0.171875f,
+	0.195313f,
+	0.179688f,
+	0.195313f,
+	0.1875f,
+	0.195313f,
+	0.195313f,
+	0.195313f,
+	0.203125f,
+	0.195313f,
+	0.210938f,
+	0.195313f,
+	0.21875f,
+	0.195313f,
+	0.226563f,
+	0.195313f,
+	0.234375f,
+	0.195313f,
+	0.242188f,
+	0.195313f,
+	0.25f,
+	0.195313f,
+	0.257813f,
+	0.195313f,
+	0.265625f,
+	0.195313f,
+	0.273438f,
+	0.195313f,
+	0.28125f,
+	0.195313f,
+	0.289063f,
+	0.195313f,
+	0.296875f,
+	0.195313f,
+	0.304688f,
+	0.195313f,
+	0.3125f,
+	0.195313f,
+	0.320313f,
+	0.195313f,
+	0.328125f,
+	0.195313f,
+	0.335938f,
+	0.195313f,
+	0.34375f,
+	0.195313f,
+	0.351563f,
+	0.195313f,
+	0.359375f,
+	0.195313f,
+	0.367188f,
+	0.195313f,
+	0.375f,
+	0.195313f,
+	0.382813f,
+	0.195313f,
+	0.390625f,
+	0.195313f,
+	0.398438f,
+	0.195313f,
+	0.40625f,
+	0.195313f,
+	0.414063f,
+	0.195313f,
+	0.421875f,
+	0.195313f,
+	0.429688f,
+	0.195313f,
+	0.4375f,
+	0.195313f,
+	0.445313f,
+	0.195313f,
+	0.453125f,
+	0.195313f,
+	0.460938f,
+	0.195313f,
+	0.46875f,
+	0.195313f,
+	0.476563f,
+	0.195313f,
+	0.484375f,
+	0.195313f,
+	0.492188f,
+	0.195313f,
+	0.5f,
+	0.195313f,
+	0.507813f,
+	0.195313f,
+	0.0f,
+	0.203125f,
+	0.0078125f,
+	0.203125f,
+	0.015625f,
+	0.203125f,
+	0.0234375f,
+	0.203125f,
+	0.03125f,
+	0.203125f,
+	0.0390625f,
+	0.203125f,
+	0.046875f,
+	0.203125f,
+	0.0546875f,
+	0.203125f,
+	0.0625f,
+	0.203125f,
+	0.0703125f,
+	0.203125f,
+	0.078125f,
+	0.203125f,
+	0.0859375f,
+	0.203125f,
+	0.09375f,
+	0.203125f,
+	0.101563f,
+	0.203125f,
+	0.109375f,
+	0.203125f,
+	0.117188f,
+	0.203125f,
+	0.125f,
+	0.203125f,
+	0.132813f,
+	0.203125f,
+	0.140625f,
+	0.203125f,
+	0.148438f,
+	0.203125f,
+	0.15625f,
+	0.203125f,
+	0.164063f,
+	0.203125f,
+	0.171875f,
+	0.203125f,
+	0.179688f,
+	0.203125f,
+	0.1875f,
+	0.203125f,
+	0.195313f,
+	0.203125f,
+	0.203125f,
+	0.203125f,
+	0.210938f,
+	0.203125f,
+	0.21875f,
+	0.203125f,
+	0.226563f,
+	0.203125f,
+	0.234375f,
+	0.203125f,
+	0.242188f,
+	0.203125f,
+	0.25f,
+	0.203125f,
+	0.257813f,
+	0.203125f,
+	0.265625f,
+	0.203125f,
+	0.273438f,
+	0.203125f,
+	0.28125f,
+	0.203125f,
+	0.289063f,
+	0.203125f,
+	0.296875f,
+	0.203125f,
+	0.304688f,
+	0.203125f,
+	0.3125f,
+	0.203125f,
+	0.320313f,
+	0.203125f,
+	0.328125f,
+	0.203125f,
+	0.335938f,
+	0.203125f,
+	0.34375f,
+	0.203125f,
+	0.351563f,
+	0.203125f,
+	0.359375f,
+	0.203125f,
+	0.367188f,
+	0.203125f,
+	0.375f,
+	0.203125f,
+	0.382813f,
+	0.203125f,
+	0.390625f,
+	0.203125f,
+	0.398438f,
+	0.203125f,
+	0.40625f,
+	0.203125f,
+	0.414063f,
+	0.203125f,
+	0.421875f,
+	0.203125f,
+	0.429688f,
+	0.203125f,
+	0.4375f,
+	0.203125f,
+	0.445313f,
+	0.203125f,
+	0.453125f,
+	0.203125f,
+	0.460938f,
+	0.203125f,
+	0.46875f,
+	0.203125f,
+	0.476563f,
+	0.203125f,
+	0.484375f,
+	0.203125f,
+	0.492188f,
+	0.203125f,
+	0.5f,
+	0.203125f,
+	0.507813f,
+	0.203125f,
+	0.0f,
+	0.210938f,
+	0.0078125f,
+	0.210938f,
+	0.015625f,
+	0.210938f,
+	0.0234375f,
+	0.210938f,
+	0.03125f,
+	0.210938f,
+	0.0390625f,
+	0.210938f,
+	0.046875f,
+	0.210938f,
+	0.0546875f,
+	0.210938f,
+	0.0625f,
+	0.210938f,
+	0.0703125f,
+	0.210938f,
+	0.078125f,
+	0.210938f,
+	0.0859375f,
+	0.210938f,
+	0.09375f,
+	0.210938f,
+	0.101563f,
+	0.210938f,
+	0.109375f,
+	0.210938f,
+	0.117188f,
+	0.210938f,
+	0.125f,
+	0.210938f,
+	0.132813f,
+	0.210938f,
+	0.140625f,
+	0.210938f,
+	0.148438f,
+	0.210938f,
+	0.15625f,
+	0.210938f,
+	0.164063f,
+	0.210938f,
+	0.171875f,
+	0.210938f,
+	0.179688f,
+	0.210938f,
+	0.1875f,
+	0.210938f,
+	0.195313f,
+	0.210938f,
+	0.203125f,
+	0.210938f,
+	0.210938f,
+	0.210938f,
+	0.21875f,
+	0.210938f,
+	0.226563f,
+	0.210938f,
+	0.234375f,
+	0.210938f,
+	0.242188f,
+	0.210938f,
+	0.25f,
+	0.210938f,
+	0.257813f,
+	0.210938f,
+	0.265625f,
+	0.210938f,
+	0.273438f,
+	0.210938f,
+	0.28125f,
+	0.210938f,
+	0.289063f,
+	0.210938f,
+	0.296875f,
+	0.210938f,
+	0.304688f,
+	0.210938f,
+	0.3125f,
+	0.210938f,
+	0.320313f,
+	0.210938f,
+	0.328125f,
+	0.210938f,
+	0.335938f,
+	0.210938f,
+	0.34375f,
+	0.210938f,
+	0.351563f,
+	0.210938f,
+	0.359375f,
+	0.210938f,
+	0.367188f,
+	0.210938f,
+	0.375f,
+	0.210938f,
+	0.382813f,
+	0.210938f,
+	0.390625f,
+	0.210938f,
+	0.398438f,
+	0.210938f,
+	0.40625f,
+	0.210938f,
+	0.414063f,
+	0.210938f,
+	0.421875f,
+	0.210938f,
+	0.429688f,
+	0.210938f,
+	0.4375f,
+	0.210938f,
+	0.445313f,
+	0.210938f,
+	0.453125f,
+	0.210938f,
+	0.460938f,
+	0.210938f,
+	0.46875f,
+	0.210938f,
+	0.476563f,
+	0.210938f,
+	0.484375f,
+	0.210938f,
+	0.492188f,
+	0.210938f,
+	0.5f,
+	0.210938f,
+	0.507813f,
+	0.210938f,
+	0.0f,
+	0.21875f,
+	0.0078125f,
+	0.21875f,
+	0.015625f,
+	0.21875f,
+	0.0234375f,
+	0.21875f,
+	0.03125f,
+	0.21875f,
+	0.0390625f,
+	0.21875f,
+	0.046875f,
+	0.21875f,
+	0.0546875f,
+	0.21875f,
+	0.0625f,
+	0.21875f,
+	0.0703125f,
+	0.21875f,
+	0.078125f,
+	0.21875f,
+	0.0859375f,
+	0.21875f,
+	0.09375f,
+	0.21875f,
+	0.101563f,
+	0.21875f,
+	0.109375f,
+	0.21875f,
+	0.117188f,
+	0.21875f,
+	0.125f,
+	0.21875f,
+	0.132813f,
+	0.21875f,
+	0.140625f,
+	0.21875f,
+	0.148438f,
+	0.21875f,
+	0.15625f,
+	0.21875f,
+	0.164063f,
+	0.21875f,
+	0.171875f,
+	0.21875f,
+	0.179688f,
+	0.21875f,
+	0.1875f,
+	0.21875f,
+	0.195313f,
+	0.21875f,
+	0.203125f,
+	0.21875f,
+	0.210938f,
+	0.21875f,
+	0.21875f,
+	0.21875f,
+	0.226563f,
+	0.21875f,
+	0.234375f,
+	0.21875f,
+	0.242188f,
+	0.21875f,
+	0.25f,
+	0.21875f,
+	0.257813f,
+	0.21875f,
+	0.265625f,
+	0.21875f,
+	0.273438f,
+	0.21875f,
+	0.28125f,
+	0.21875f,
+	0.289063f,
+	0.21875f,
+	0.296875f,
+	0.21875f,
+	0.304688f,
+	0.21875f,
+	0.3125f,
+	0.21875f,
+	0.320313f,
+	0.21875f,
+	0.328125f,
+	0.21875f,
+	0.335938f,
+	0.21875f,
+	0.34375f,
+	0.21875f,
+	0.351563f,
+	0.21875f,
+	0.359375f,
+	0.21875f,
+	0.367188f,
+	0.21875f,
+	0.375f,
+	0.21875f,
+	0.382813f,
+	0.21875f,
+	0.390625f,
+	0.21875f,
+	0.398438f,
+	0.21875f,
+	0.40625f,
+	0.21875f,
+	0.414063f,
+	0.21875f,
+	0.421875f,
+	0.21875f,
+	0.429688f,
+	0.21875f,
+	0.4375f,
+	0.21875f,
+	0.445313f,
+	0.21875f,
+	0.453125f,
+	0.21875f,
+	0.460938f,
+	0.21875f,
+	0.46875f,
+	0.21875f,
+	0.476563f,
+	0.21875f,
+	0.484375f,
+	0.21875f,
+	0.492188f,
+	0.21875f,
+	0.5f,
+	0.21875f,
+	0.507813f,
+	0.21875f,
+	0.0f,
+	0.226563f,
+	0.0078125f,
+	0.226563f,
+	0.015625f,
+	0.226563f,
+	0.0234375f,
+	0.226563f,
+	0.03125f,
+	0.226563f,
+	0.0390625f,
+	0.226563f,
+	0.046875f,
+	0.226563f,
+	0.0546875f,
+	0.226563f,
+	0.0625f,
+	0.226563f,
+	0.0703125f,
+	0.226563f,
+	0.078125f,
+	0.226563f,
+	0.0859375f,
+	0.226563f,
+	0.09375f,
+	0.226563f,
+	0.101563f,
+	0.226563f,
+	0.109375f,
+	0.226563f,
+	0.117188f,
+	0.226563f,
+	0.125f,
+	0.226563f,
+	0.132813f,
+	0.226563f,
+	0.140625f,
+	0.226563f,
+	0.148438f,
+	0.226563f,
+	0.15625f,
+	0.226563f,
+	0.164063f,
+	0.226563f,
+	0.171875f,
+	0.226563f,
+	0.179688f,
+	0.226563f,
+	0.1875f,
+	0.226563f,
+	0.195313f,
+	0.226563f,
+	0.203125f,
+	0.226563f,
+	0.210938f,
+	0.226563f,
+	0.21875f,
+	0.226563f,
+	0.226563f,
+	0.226563f,
+	0.234375f,
+	0.226563f,
+	0.242188f,
+	0.226563f,
+	0.25f,
+	0.226563f,
+	0.257813f,
+	0.226563f,
+	0.265625f,
+	0.226563f,
+	0.273438f,
+	0.226563f,
+	0.28125f,
+	0.226563f,
+	0.289063f,
+	0.226563f,
+	0.296875f,
+	0.226563f,
+	0.304688f,
+	0.226563f,
+	0.3125f,
+	0.226563f,
+	0.320313f,
+	0.226563f,
+	0.328125f,
+	0.226563f,
+	0.335938f,
+	0.226563f,
+	0.34375f,
+	0.226563f,
+	0.351563f,
+	0.226563f,
+	0.359375f,
+	0.226563f,
+	0.367188f,
+	0.226563f,
+	0.375f,
+	0.226563f,
+	0.382813f,
+	0.226563f,
+	0.390625f,
+	0.226563f,
+	0.398438f,
+	0.226563f,
+	0.40625f,
+	0.226563f,
+	0.414063f,
+	0.226563f,
+	0.421875f,
+	0.226563f,
+	0.429688f,
+	0.226563f,
+	0.4375f,
+	0.226563f,
+	0.445313f,
+	0.226563f,
+	0.453125f,
+	0.226563f,
+	0.460938f,
+	0.226563f,
+	0.46875f,
+	0.226563f,
+	0.476563f,
+	0.226563f,
+	0.484375f,
+	0.226563f,
+	0.492188f,
+	0.226563f,
+	0.5f,
+	0.226563f,
+	0.507813f,
+	0.226563f,
+	0.0f,
+	0.234375f,
+	0.0078125f,
+	0.234375f,
+	0.015625f,
+	0.234375f,
+	0.0234375f,
+	0.234375f,
+	0.03125f,
+	0.234375f,
+	0.0390625f,
+	0.234375f,
+	0.046875f,
+	0.234375f,
+	0.0546875f,
+	0.234375f,
+	0.0625f,
+	0.234375f,
+	0.0703125f,
+	0.234375f,
+	0.078125f,
+	0.234375f,
+	0.0859375f,
+	0.234375f,
+	0.09375f,
+	0.234375f,
+	0.101563f,
+	0.234375f,
+	0.109375f,
+	0.234375f,
+	0.117188f,
+	0.234375f,
+	0.125f,
+	0.234375f,
+	0.132813f,
+	0.234375f,
+	0.140625f,
+	0.234375f,
+	0.148438f,
+	0.234375f,
+	0.15625f,
+	0.234375f,
+	0.164063f,
+	0.234375f,
+	0.171875f,
+	0.234375f,
+	0.179688f,
+	0.234375f,
+	0.1875f,
+	0.234375f,
+	0.195313f,
+	0.234375f,
+	0.203125f,
+	0.234375f,
+	0.210938f,
+	0.234375f,
+	0.21875f,
+	0.234375f,
+	0.226563f,
+	0.234375f,
+	0.234375f,
+	0.234375f,
+	0.242188f,
+	0.234375f,
+	0.25f,
+	0.234375f,
+	0.257813f,
+	0.234375f,
+	0.265625f,
+	0.234375f,
+	0.273438f,
+	0.234375f,
+	0.28125f,
+	0.234375f,
+	0.289063f,
+	0.234375f,
+	0.296875f,
+	0.234375f,
+	0.304688f,
+	0.234375f,
+	0.3125f,
+	0.234375f,
+	0.320313f,
+	0.234375f,
+	0.328125f,
+	0.234375f,
+	0.335938f,
+	0.234375f,
+	0.34375f,
+	0.234375f,
+	0.351563f,
+	0.234375f,
+	0.359375f,
+	0.234375f,
+	0.367188f,
+	0.234375f,
+	0.375f,
+	0.234375f,
+	0.382813f,
+	0.234375f,
+	0.390625f,
+	0.234375f,
+	0.398438f,
+	0.234375f,
+	0.40625f,
+	0.234375f,
+	0.414063f,
+	0.234375f,
+	0.421875f,
+	0.234375f,
+	0.429688f,
+	0.234375f,
+	0.4375f,
+	0.234375f,
+	0.445313f,
+	0.234375f,
+	0.453125f,
+	0.234375f,
+	0.460938f,
+	0.234375f,
+	0.46875f,
+	0.234375f,
+	0.476563f,
+	0.234375f,
+	0.484375f,
+	0.234375f,
+	0.492188f,
+	0.234375f,
+	0.5f,
+	0.234375f,
+	0.507813f,
+	0.234375f,
+	0.0f,
+	0.242188f,
+	0.0078125f,
+	0.242188f,
+	0.015625f,
+	0.242188f,
+	0.0234375f,
+	0.242188f,
+	0.03125f,
+	0.242188f,
+	0.0390625f,
+	0.242188f,
+	0.046875f,
+	0.242188f,
+	0.0546875f,
+	0.242188f,
+	0.0625f,
+	0.242188f,
+	0.0703125f,
+	0.242188f,
+	0.078125f,
+	0.242188f,
+	0.0859375f,
+	0.242188f,
+	0.09375f,
+	0.242188f,
+	0.101563f,
+	0.242188f,
+	0.109375f,
+	0.242188f,
+	0.117188f,
+	0.242188f,
+	0.125f,
+	0.242188f,
+	0.132813f,
+	0.242188f,
+	0.140625f,
+	0.242188f,
+	0.148438f,
+	0.242188f,
+	0.15625f,
+	0.242188f,
+	0.164063f,
+	0.242188f,
+	0.171875f,
+	0.242188f,
+	0.179688f,
+	0.242188f,
+	0.1875f,
+	0.242188f,
+	0.195313f,
+	0.242188f,
+	0.203125f,
+	0.242188f,
+	0.210938f,
+	0.242188f,
+	0.21875f,
+	0.242188f,
+	0.226563f,
+	0.242188f,
+	0.234375f,
+	0.242188f,
+	0.242188f,
+	0.242188f,
+	0.25f,
+	0.242188f,
+	0.257813f,
+	0.242188f,
+	0.265625f,
+	0.242188f,
+	0.273438f,
+	0.242188f,
+	0.28125f,
+	0.242188f,
+	0.289063f,
+	0.242188f,
+	0.296875f,
+	0.242188f,
+	0.304688f,
+	0.242188f,
+	0.3125f,
+	0.242188f,
+	0.320313f,
+	0.242188f,
+	0.328125f,
+	0.242188f,
+	0.335938f,
+	0.242188f,
+	0.34375f,
+	0.242188f,
+	0.351563f,
+	0.242188f,
+	0.359375f,
+	0.242188f,
+	0.367188f,
+	0.242188f,
+	0.375f,
+	0.242188f,
+	0.382813f,
+	0.242188f,
+	0.390625f,
+	0.242188f,
+	0.398438f,
+	0.242188f,
+	0.40625f,
+	0.242188f,
+	0.414063f,
+	0.242188f,
+	0.421875f,
+	0.242188f,
+	0.429688f,
+	0.242188f,
+	0.4375f,
+	0.242188f,
+	0.445313f,
+	0.242188f,
+	0.453125f,
+	0.242188f,
+	0.460938f,
+	0.242188f,
+	0.46875f,
+	0.242188f,
+	0.476563f,
+	0.242188f,
+	0.484375f,
+	0.242188f,
+	0.492188f,
+	0.242188f,
+	0.5f,
+	0.242188f,
+	0.507813f,
+	0.242188f,
+	0.0f,
+	0.25f,
+	0.0078125f,
+	0.25f,
+	0.015625f,
+	0.25f,
+	0.0234375f,
+	0.25f,
+	0.03125f,
+	0.25f,
+	0.0390625f,
+	0.25f,
+	0.046875f,
+	0.25f,
+	0.0546875f,
+	0.25f,
+	0.0625f,
+	0.25f,
+	0.0703125f,
+	0.25f,
+	0.078125f,
+	0.25f,
+	0.0859375f,
+	0.25f,
+	0.09375f,
+	0.25f,
+	0.101563f,
+	0.25f,
+	0.109375f,
+	0.25f,
+	0.117188f,
+	0.25f,
+	0.125f,
+	0.25f,
+	0.132813f,
+	0.25f,
+	0.140625f,
+	0.25f,
+	0.148438f,
+	0.25f,
+	0.15625f,
+	0.25f,
+	0.164063f,
+	0.25f,
+	0.171875f,
+	0.25f,
+	0.179688f,
+	0.25f,
+	0.1875f,
+	0.25f,
+	0.195313f,
+	0.25f,
+	0.203125f,
+	0.25f,
+	0.210938f,
+	0.25f,
+	0.21875f,
+	0.25f,
+	0.226563f,
+	0.25f,
+	0.234375f,
+	0.25f,
+	0.242188f,
+	0.25f,
+	0.25f,
+	0.25f,
+	0.257813f,
+	0.25f,
+	0.265625f,
+	0.25f,
+	0.273438f,
+	0.25f,
+	0.28125f,
+	0.25f,
+	0.289063f,
+	0.25f,
+	0.296875f,
+	0.25f,
+	0.304688f,
+	0.25f,
+	0.3125f,
+	0.25f,
+	0.320313f,
+	0.25f,
+	0.328125f,
+	0.25f,
+	0.335938f,
+	0.25f,
+	0.34375f,
+	0.25f,
+	0.351563f,
+	0.25f,
+	0.359375f,
+	0.25f,
+	0.367188f,
+	0.25f,
+	0.375f,
+	0.25f,
+	0.382813f,
+	0.25f,
+	0.390625f,
+	0.25f,
+	0.398438f,
+	0.25f,
+	0.40625f,
+	0.25f,
+	0.414063f,
+	0.25f,
+	0.421875f,
+	0.25f,
+	0.429688f,
+	0.25f,
+	0.4375f,
+	0.25f,
+	0.445313f,
+	0.25f,
+	0.453125f,
+	0.25f,
+	0.460938f,
+	0.25f,
+	0.46875f,
+	0.25f,
+	0.476563f,
+	0.25f,
+	0.484375f,
+	0.25f,
+	0.492188f,
+	0.25f,
+	0.5f,
+	0.25f,
+	0.507813f,
+	0.25f,
+	0.0f,
+	0.257813f,
+	0.0078125f,
+	0.257813f,
+	0.015625f,
+	0.257813f,
+	0.0234375f,
+	0.257813f,
+	0.03125f,
+	0.257813f,
+	0.0390625f,
+	0.257813f,
+	0.046875f,
+	0.257813f,
+	0.0546875f,
+	0.257813f,
+	0.0625f,
+	0.257813f,
+	0.0703125f,
+	0.257813f,
+	0.078125f,
+	0.257813f,
+	0.0859375f,
+	0.257813f,
+	0.09375f,
+	0.257813f,
+	0.101563f,
+	0.257813f,
+	0.109375f,
+	0.257813f,
+	0.117188f,
+	0.257813f,
+	0.125f,
+	0.257813f,
+	0.132813f,
+	0.257813f,
+	0.140625f,
+	0.257813f,
+	0.148438f,
+	0.257813f,
+	0.15625f,
+	0.257813f,
+	0.164063f,
+	0.257813f,
+	0.171875f,
+	0.257813f,
+	0.179688f,
+	0.257813f,
+	0.1875f,
+	0.257813f,
+	0.195313f,
+	0.257813f,
+	0.203125f,
+	0.257813f,
+	0.210938f,
+	0.257813f,
+	0.21875f,
+	0.257813f,
+	0.226563f,
+	0.257813f,
+	0.234375f,
+	0.257813f,
+	0.242188f,
+	0.257813f,
+	0.25f,
+	0.257813f,
+	0.257813f,
+	0.257813f,
+	0.265625f,
+	0.257813f,
+	0.273438f,
+	0.257813f,
+	0.28125f,
+	0.257813f,
+	0.289063f,
+	0.257813f,
+	0.296875f,
+	0.257813f,
+	0.304688f,
+	0.257813f,
+	0.3125f,
+	0.257813f,
+	0.320313f,
+	0.257813f,
+	0.328125f,
+	0.257813f,
+	0.335938f,
+	0.257813f,
+	0.34375f,
+	0.257813f,
+	0.351563f,
+	0.257813f,
+	0.359375f,
+	0.257813f,
+	0.367188f,
+	0.257813f,
+	0.375f,
+	0.257813f,
+	0.382813f,
+	0.257813f,
+	0.390625f,
+	0.257813f,
+	0.398438f,
+	0.257813f,
+	0.40625f,
+	0.257813f,
+	0.414063f,
+	0.257813f,
+	0.421875f,
+	0.257813f,
+	0.429688f,
+	0.257813f,
+	0.4375f,
+	0.257813f,
+	0.445313f,
+	0.257813f,
+	0.453125f,
+	0.257813f,
+	0.460938f,
+	0.257813f,
+	0.46875f,
+	0.257813f,
+	0.476563f,
+	0.257813f,
+	0.484375f,
+	0.257813f,
+	0.492188f,
+	0.257813f,
+	0.5f,
+	0.257813f,
+	0.507813f,
+	0.257813f,
+	0.0f,
+	0.265625f,
+	0.0078125f,
+	0.265625f,
+	0.015625f,
+	0.265625f,
+	0.0234375f,
+	0.265625f,
+	0.03125f,
+	0.265625f,
+	0.0390625f,
+	0.265625f,
+	0.046875f,
+	0.265625f,
+	0.0546875f,
+	0.265625f,
+	0.0625f,
+	0.265625f,
+	0.0703125f,
+	0.265625f,
+	0.078125f,
+	0.265625f,
+	0.0859375f,
+	0.265625f,
+	0.09375f,
+	0.265625f,
+	0.101563f,
+	0.265625f,
+	0.109375f,
+	0.265625f,
+	0.117188f,
+	0.265625f,
+	0.125f,
+	0.265625f,
+	0.132813f,
+	0.265625f,
+	0.140625f,
+	0.265625f,
+	0.148438f,
+	0.265625f,
+	0.15625f,
+	0.265625f,
+	0.164063f,
+	0.265625f,
+	0.171875f,
+	0.265625f,
+	0.179688f,
+	0.265625f,
+	0.1875f,
+	0.265625f,
+	0.195313f,
+	0.265625f,
+	0.203125f,
+	0.265625f,
+	0.210938f,
+	0.265625f,
+	0.21875f,
+	0.265625f,
+	0.226563f,
+	0.265625f,
+	0.234375f,
+	0.265625f,
+	0.242188f,
+	0.265625f,
+	0.25f,
+	0.265625f,
+	0.257813f,
+	0.265625f,
+	0.265625f,
+	0.265625f,
+	0.273438f,
+	0.265625f,
+	0.28125f,
+	0.265625f,
+	0.289063f,
+	0.265625f,
+	0.296875f,
+	0.265625f,
+	0.304688f,
+	0.265625f,
+	0.3125f,
+	0.265625f,
+	0.320313f,
+	0.265625f,
+	0.328125f,
+	0.265625f,
+	0.335938f,
+	0.265625f,
+	0.34375f,
+	0.265625f,
+	0.351563f,
+	0.265625f,
+	0.359375f,
+	0.265625f,
+	0.367188f,
+	0.265625f,
+	0.375f,
+	0.265625f,
+	0.382813f,
+	0.265625f,
+	0.390625f,
+	0.265625f,
+	0.398438f,
+	0.265625f,
+	0.40625f,
+	0.265625f,
+	0.414063f,
+	0.265625f,
+	0.421875f,
+	0.265625f,
+	0.429688f,
+	0.265625f,
+	0.4375f,
+	0.265625f,
+	0.445313f,
+	0.265625f,
+	0.453125f,
+	0.265625f,
+	0.460938f,
+	0.265625f,
+	0.46875f,
+	0.265625f,
+	0.476563f,
+	0.265625f,
+	0.484375f,
+	0.265625f,
+	0.492188f,
+	0.265625f,
+	0.5f,
+	0.265625f,
+	0.507813f,
+	0.265625f,
+};
+
+unsigned short Landscape06Idx[] = {
+	0,
+	1,
+	2,
+	3,
+	2,
+	1,
+	2,
+	3,
+	4,
+	5,
+	4,
+	3,
+	4,
+	5,
+	6,
+	7,
+	6,
+	5,
+	6,
+	7,
+	8,
+	9,
+	8,
+	7,
+	8,
+	9,
+	10,
+	11,
+	10,
+	9,
+	10,
+	11,
+	12,
+	13,
+	12,
+	11,
+	12,
+	13,
+	14,
+	15,
+	14,
+	13,
+	14,
+	15,
+	16,
+	17,
+	16,
+	15,
+	16,
+	17,
+	18,
+	19,
+	18,
+	17,
+	18,
+	19,
+	20,
+	21,
+	20,
+	19,
+	20,
+	21,
+	22,
+	23,
+	22,
+	21,
+	22,
+	23,
+	24,
+	25,
+	24,
+	23,
+	24,
+	25,
+	26,
+	27,
+	26,
+	25,
+	26,
+	27,
+	28,
+	29,
+	28,
+	27,
+	28,
+	29,
+	30,
+	31,
+	30,
+	29,
+	30,
+	31,
+	32,
+	33,
+	32,
+	31,
+	32,
+	33,
+	34,
+	35,
+	34,
+	33,
+	34,
+	35,
+	36,
+	37,
+	36,
+	35,
+	36,
+	37,
+	38,
+	39,
+	38,
+	37,
+	38,
+	39,
+	40,
+	41,
+	40,
+	39,
+	40,
+	41,
+	42,
+	43,
+	42,
+	41,
+	42,
+	43,
+	44,
+	45,
+	44,
+	43,
+	44,
+	45,
+	46,
+	47,
+	46,
+	45,
+	46,
+	47,
+	48,
+	49,
+	48,
+	47,
+	48,
+	49,
+	50,
+	51,
+	50,
+	49,
+	50,
+	51,
+	52,
+	53,
+	52,
+	51,
+	52,
+	53,
+	54,
+	55,
+	54,
+	53,
+	54,
+	55,
+	56,
+	57,
+	56,
+	55,
+	56,
+	57,
+	58,
+	59,
+	58,
+	57,
+	58,
+	59,
+	60,
+	61,
+	60,
+	59,
+	60,
+	61,
+	62,
+	63,
+	62,
+	61,
+	62,
+	63,
+	64,
+	65,
+	64,
+	63,
+	64,
+	65,
+	66,
+	67,
+	66,
+	65,
+	66,
+	67,
+	68,
+	69,
+	68,
+	67,
+	68,
+	69,
+	70,
+	71,
+	70,
+	69,
+	70,
+	71,
+	72,
+	73,
+	72,
+	71,
+	72,
+	73,
+	74,
+	75,
+	74,
+	73,
+	74,
+	75,
+	76,
+	77,
+	76,
+	75,
+	76,
+	77,
+	78,
+	79,
+	78,
+	77,
+	78,
+	79,
+	80,
+	81,
+	80,
+	79,
+	80,
+	81,
+	82,
+	83,
+	82,
+	81,
+	82,
+	83,
+	84,
+	85,
+	84,
+	83,
+	84,
+	85,
+	86,
+	87,
+	86,
+	85,
+	86,
+	87,
+	88,
+	89,
+	88,
+	87,
+	88,
+	89,
+	90,
+	91,
+	90,
+	89,
+	90,
+	91,
+	92,
+	93,
+	92,
+	91,
+	92,
+	93,
+	94,
+	95,
+	94,
+	93,
+	94,
+	95,
+	96,
+	97,
+	96,
+	95,
+	96,
+	97,
+	98,
+	99,
+	98,
+	97,
+	98,
+	99,
+	100,
+	101,
+	100,
+	99,
+	100,
+	101,
+	102,
+	103,
+	102,
+	101,
+	102,
+	103,
+	104,
+	105,
+	104,
+	103,
+	104,
+	105,
+	106,
+	107,
+	106,
+	105,
+	106,
+	107,
+	108,
+	109,
+	108,
+	107,
+	108,
+	109,
+	110,
+	111,
+	110,
+	109,
+	110,
+	111,
+	112,
+	113,
+	112,
+	111,
+	112,
+	113,
+	114,
+	115,
+	114,
+	113,
+	114,
+	115,
+	116,
+	117,
+	116,
+	115,
+	116,
+	117,
+	118,
+	119,
+	118,
+	117,
+	118,
+	119,
+	120,
+	121,
+	120,
+	119,
+	120,
+	121,
+	122,
+	123,
+	122,
+	121,
+	122,
+	123,
+	124,
+	125,
+	124,
+	123,
+	124,
+	125,
+	126,
+	127,
+	126,
+	125,
+	126,
+	127,
+	128,
+	129,
+	128,
+	127,
+	128,
+	129,
+	130,
+	131,
+	130,
+	129,
+	132,
+	0,
+	133,
+	2,
+	133,
+	0,
+	133,
+	2,
+	134,
+	4,
+	134,
+	2,
+	134,
+	4,
+	135,
+	6,
+	135,
+	4,
+	135,
+	6,
+	136,
+	8,
+	136,
+	6,
+	136,
+	8,
+	137,
+	10,
+	137,
+	8,
+	137,
+	10,
+	138,
+	12,
+	138,
+	10,
+	138,
+	12,
+	139,
+	14,
+	139,
+	12,
+	139,
+	14,
+	140,
+	16,
+	140,
+	14,
+	140,
+	16,
+	141,
+	18,
+	141,
+	16,
+	141,
+	18,
+	142,
+	20,
+	142,
+	18,
+	142,
+	20,
+	143,
+	22,
+	143,
+	20,
+	143,
+	22,
+	144,
+	24,
+	144,
+	22,
+	144,
+	24,
+	145,
+	26,
+	145,
+	24,
+	145,
+	26,
+	146,
+	28,
+	146,
+	26,
+	146,
+	28,
+	147,
+	30,
+	147,
+	28,
+	147,
+	30,
+	148,
+	32,
+	148,
+	30,
+	148,
+	32,
+	149,
+	34,
+	149,
+	32,
+	149,
+	34,
+	150,
+	36,
+	150,
+	34,
+	150,
+	36,
+	151,
+	38,
+	151,
+	36,
+	151,
+	38,
+	152,
+	40,
+	152,
+	38,
+	152,
+	40,
+	153,
+	42,
+	153,
+	40,
+	153,
+	42,
+	154,
+	44,
+	154,
+	42,
+	154,
+	44,
+	155,
+	46,
+	155,
+	44,
+	155,
+	46,
+	156,
+	48,
+	156,
+	46,
+	156,
+	48,
+	157,
+	50,
+	157,
+	48,
+	157,
+	50,
+	158,
+	52,
+	158,
+	50,
+	158,
+	52,
+	159,
+	54,
+	159,
+	52,
+	159,
+	54,
+	160,
+	56,
+	160,
+	54,
+	160,
+	56,
+	161,
+	58,
+	161,
+	56,
+	161,
+	58,
+	162,
+	60,
+	162,
+	58,
+	162,
+	60,
+	163,
+	62,
+	163,
+	60,
+	163,
+	62,
+	164,
+	64,
+	164,
+	62,
+	164,
+	64,
+	165,
+	66,
+	165,
+	64,
+	165,
+	66,
+	166,
+	68,
+	166,
+	66,
+	166,
+	68,
+	167,
+	70,
+	167,
+	68,
+	167,
+	70,
+	168,
+	72,
+	168,
+	70,
+	168,
+	72,
+	169,
+	74,
+	169,
+	72,
+	169,
+	74,
+	170,
+	76,
+	170,
+	74,
+	170,
+	76,
+	171,
+	78,
+	171,
+	76,
+	171,
+	78,
+	172,
+	80,
+	172,
+	78,
+	172,
+	80,
+	173,
+	82,
+	173,
+	80,
+	173,
+	82,
+	174,
+	84,
+	174,
+	82,
+	174,
+	84,
+	175,
+	86,
+	175,
+	84,
+	175,
+	86,
+	176,
+	88,
+	176,
+	86,
+	176,
+	88,
+	177,
+	90,
+	177,
+	88,
+	177,
+	90,
+	178,
+	92,
+	178,
+	90,
+	178,
+	92,
+	179,
+	94,
+	179,
+	92,
+	179,
+	94,
+	180,
+	96,
+	180,
+	94,
+	180,
+	96,
+	181,
+	98,
+	181,
+	96,
+	181,
+	98,
+	182,
+	100,
+	182,
+	98,
+	182,
+	100,
+	183,
+	102,
+	183,
+	100,
+	183,
+	102,
+	184,
+	104,
+	184,
+	102,
+	184,
+	104,
+	185,
+	106,
+	185,
+	104,
+	185,
+	106,
+	186,
+	108,
+	186,
+	106,
+	186,
+	108,
+	187,
+	110,
+	187,
+	108,
+	187,
+	110,
+	188,
+	112,
+	188,
+	110,
+	188,
+	112,
+	189,
+	114,
+	189,
+	112,
+	189,
+	114,
+	190,
+	116,
+	190,
+	114,
+	190,
+	116,
+	191,
+	118,
+	191,
+	116,
+	191,
+	118,
+	192,
+	120,
+	192,
+	118,
+	192,
+	120,
+	193,
+	122,
+	193,
+	120,
+	193,
+	122,
+	194,
+	124,
+	194,
+	122,
+	194,
+	124,
+	195,
+	126,
+	195,
+	124,
+	195,
+	126,
+	196,
+	128,
+	196,
+	126,
+	196,
+	128,
+	197,
+	130,
+	197,
+	128,
+	198,
+	132,
+	199,
+	133,
+	199,
+	132,
+	199,
+	133,
+	200,
+	134,
+	200,
+	133,
+	200,
+	134,
+	201,
+	135,
+	201,
+	134,
+	201,
+	135,
+	202,
+	136,
+	202,
+	135,
+	202,
+	136,
+	203,
+	137,
+	203,
+	136,
+	203,
+	137,
+	204,
+	138,
+	204,
+	137,
+	204,
+	138,
+	205,
+	139,
+	205,
+	138,
+	205,
+	139,
+	206,
+	140,
+	206,
+	139,
+	206,
+	140,
+	207,
+	141,
+	207,
+	140,
+	207,
+	141,
+	208,
+	142,
+	208,
+	141,
+	208,
+	142,
+	209,
+	143,
+	209,
+	142,
+	209,
+	143,
+	210,
+	144,
+	210,
+	143,
+	210,
+	144,
+	211,
+	145,
+	211,
+	144,
+	211,
+	145,
+	212,
+	146,
+	212,
+	145,
+	212,
+	146,
+	213,
+	147,
+	213,
+	146,
+	213,
+	147,
+	214,
+	148,
+	214,
+	147,
+	214,
+	148,
+	215,
+	149,
+	215,
+	148,
+	215,
+	149,
+	216,
+	150,
+	216,
+	149,
+	216,
+	150,
+	217,
+	151,
+	217,
+	150,
+	217,
+	151,
+	218,
+	152,
+	218,
+	151,
+	218,
+	152,
+	219,
+	153,
+	219,
+	152,
+	219,
+	153,
+	220,
+	154,
+	220,
+	153,
+	220,
+	154,
+	221,
+	155,
+	221,
+	154,
+	221,
+	155,
+	222,
+	156,
+	222,
+	155,
+	222,
+	156,
+	223,
+	157,
+	223,
+	156,
+	223,
+	157,
+	224,
+	158,
+	224,
+	157,
+	224,
+	158,
+	225,
+	159,
+	225,
+	158,
+	225,
+	159,
+	226,
+	160,
+	226,
+	159,
+	226,
+	160,
+	227,
+	161,
+	227,
+	160,
+	227,
+	161,
+	228,
+	162,
+	228,
+	161,
+	228,
+	162,
+	229,
+	163,
+	229,
+	162,
+	229,
+	163,
+	230,
+	164,
+	230,
+	163,
+	230,
+	164,
+	231,
+	165,
+	231,
+	164,
+	231,
+	165,
+	232,
+	166,
+	232,
+	165,
+	232,
+	166,
+	233,
+	167,
+	233,
+	166,
+	233,
+	167,
+	234,
+	168,
+	234,
+	167,
+	234,
+	168,
+	235,
+	169,
+	235,
+	168,
+	235,
+	169,
+	236,
+	170,
+	236,
+	169,
+	236,
+	170,
+	237,
+	171,
+	237,
+	170,
+	237,
+	171,
+	238,
+	172,
+	238,
+	171,
+	238,
+	172,
+	239,
+	173,
+	239,
+	172,
+	239,
+	173,
+	240,
+	174,
+	240,
+	173,
+	240,
+	174,
+	241,
+	175,
+	241,
+	174,
+	241,
+	175,
+	242,
+	176,
+	242,
+	175,
+	242,
+	176,
+	243,
+	177,
+	243,
+	176,
+	243,
+	177,
+	244,
+	178,
+	244,
+	177,
+	244,
+	178,
+	245,
+	179,
+	245,
+	178,
+	245,
+	179,
+	246,
+	180,
+	246,
+	179,
+	246,
+	180,
+	247,
+	181,
+	247,
+	180,
+	247,
+	181,
+	248,
+	182,
+	248,
+	181,
+	248,
+	182,
+	249,
+	183,
+	249,
+	182,
+	249,
+	183,
+	250,
+	184,
+	250,
+	183,
+	250,
+	184,
+	251,
+	185,
+	251,
+	184,
+	251,
+	185,
+	252,
+	186,
+	252,
+	185,
+	252,
+	186,
+	253,
+	187,
+	253,
+	186,
+	253,
+	187,
+	254,
+	188,
+	254,
+	187,
+	254,
+	188,
+	255,
+	189,
+	255,
+	188,
+	255,
+	189,
+	256,
+	190,
+	256,
+	189,
+	256,
+	190,
+	257,
+	191,
+	257,
+	190,
+	257,
+	191,
+	258,
+	192,
+	258,
+	191,
+	258,
+	192,
+	259,
+	193,
+	259,
+	192,
+	259,
+	193,
+	260,
+	194,
+	260,
+	193,
+	260,
+	194,
+	261,
+	195,
+	261,
+	194,
+	261,
+	195,
+	262,
+	196,
+	262,
+	195,
+	262,
+	196,
+	263,
+	197,
+	263,
+	196,
+	264,
+	198,
+	265,
+	199,
+	265,
+	198,
+	265,
+	199,
+	266,
+	200,
+	266,
+	199,
+	266,
+	200,
+	267,
+	201,
+	267,
+	200,
+	267,
+	201,
+	268,
+	202,
+	268,
+	201,
+	268,
+	202,
+	269,
+	203,
+	269,
+	202,
+	269,
+	203,
+	270,
+	204,
+	270,
+	203,
+	270,
+	204,
+	271,
+	205,
+	271,
+	204,
+	271,
+	205,
+	272,
+	206,
+	272,
+	205,
+	272,
+	206,
+	273,
+	207,
+	273,
+	206,
+	273,
+	207,
+	274,
+	208,
+	274,
+	207,
+	274,
+	208,
+	275,
+	209,
+	275,
+	208,
+	275,
+	209,
+	276,
+	210,
+	276,
+	209,
+	276,
+	210,
+	277,
+	211,
+	277,
+	210,
+	277,
+	211,
+	278,
+	212,
+	278,
+	211,
+	278,
+	212,
+	279,
+	213,
+	279,
+	212,
+	279,
+	213,
+	280,
+	214,
+	280,
+	213,
+	280,
+	214,
+	281,
+	215,
+	281,
+	214,
+	281,
+	215,
+	282,
+	216,
+	282,
+	215,
+	282,
+	216,
+	283,
+	217,
+	283,
+	216,
+	283,
+	217,
+	284,
+	218,
+	284,
+	217,
+	284,
+	218,
+	285,
+	219,
+	285,
+	218,
+	285,
+	219,
+	286,
+	220,
+	286,
+	219,
+	286,
+	220,
+	287,
+	221,
+	287,
+	220,
+	287,
+	221,
+	288,
+	222,
+	288,
+	221,
+	288,
+	222,
+	289,
+	223,
+	289,
+	222,
+	289,
+	223,
+	290,
+	224,
+	290,
+	223,
+	290,
+	224,
+	291,
+	225,
+	291,
+	224,
+	291,
+	225,
+	292,
+	226,
+	292,
+	225,
+	292,
+	226,
+	293,
+	227,
+	293,
+	226,
+	293,
+	227,
+	294,
+	228,
+	294,
+	227,
+	294,
+	228,
+	295,
+	229,
+	295,
+	228,
+	295,
+	229,
+	296,
+	230,
+	296,
+	229,
+	296,
+	230,
+	297,
+	231,
+	297,
+	230,
+	297,
+	231,
+	298,
+	232,
+	298,
+	231,
+	298,
+	232,
+	299,
+	233,
+	299,
+	232,
+	299,
+	233,
+	300,
+	234,
+	300,
+	233,
+	300,
+	234,
+	301,
+	235,
+	301,
+	234,
+	301,
+	235,
+	302,
+	236,
+	302,
+	235,
+	302,
+	236,
+	303,
+	237,
+	303,
+	236,
+	303,
+	237,
+	304,
+	238,
+	304,
+	237,
+	304,
+	238,
+	305,
+	239,
+	305,
+	238,
+	305,
+	239,
+	306,
+	240,
+	306,
+	239,
+	306,
+	240,
+	307,
+	241,
+	307,
+	240,
+	307,
+	241,
+	308,
+	242,
+	308,
+	241,
+	308,
+	242,
+	309,
+	243,
+	309,
+	242,
+	309,
+	243,
+	310,
+	244,
+	310,
+	243,
+	310,
+	244,
+	311,
+	245,
+	311,
+	244,
+	311,
+	245,
+	312,
+	246,
+	312,
+	245,
+	312,
+	246,
+	313,
+	247,
+	313,
+	246,
+	313,
+	247,
+	314,
+	248,
+	314,
+	247,
+	314,
+	248,
+	315,
+	249,
+	315,
+	248,
+	315,
+	249,
+	316,
+	250,
+	316,
+	249,
+	316,
+	250,
+	317,
+	251,
+	317,
+	250,
+	317,
+	251,
+	318,
+	252,
+	318,
+	251,
+	318,
+	252,
+	319,
+	253,
+	319,
+	252,
+	319,
+	253,
+	320,
+	254,
+	320,
+	253,
+	320,
+	254,
+	321,
+	255,
+	321,
+	254,
+	321,
+	255,
+	322,
+	256,
+	322,
+	255,
+	322,
+	256,
+	323,
+	257,
+	323,
+	256,
+	323,
+	257,
+	324,
+	258,
+	324,
+	257,
+	324,
+	258,
+	325,
+	259,
+	325,
+	258,
+	325,
+	259,
+	326,
+	260,
+	326,
+	259,
+	326,
+	260,
+	327,
+	261,
+	327,
+	260,
+	327,
+	261,
+	328,
+	262,
+	328,
+	261,
+	328,
+	262,
+	329,
+	263,
+	329,
+	262,
+	330,
+	264,
+	331,
+	265,
+	331,
+	264,
+	331,
+	265,
+	332,
+	266,
+	332,
+	265,
+	332,
+	266,
+	333,
+	267,
+	333,
+	266,
+	333,
+	267,
+	334,
+	268,
+	334,
+	267,
+	334,
+	268,
+	335,
+	269,
+	335,
+	268,
+	335,
+	269,
+	336,
+	270,
+	336,
+	269,
+	336,
+	270,
+	337,
+	271,
+	337,
+	270,
+	337,
+	271,
+	338,
+	272,
+	338,
+	271,
+	338,
+	272,
+	339,
+	273,
+	339,
+	272,
+	339,
+	273,
+	340,
+	274,
+	340,
+	273,
+	340,
+	274,
+	341,
+	275,
+	341,
+	274,
+	341,
+	275,
+	342,
+	276,
+	342,
+	275,
+	342,
+	276,
+	343,
+	277,
+	343,
+	276,
+	343,
+	277,
+	344,
+	278,
+	344,
+	277,
+	344,
+	278,
+	345,
+	279,
+	345,
+	278,
+	345,
+	279,
+	346,
+	280,
+	346,
+	279,
+	346,
+	280,
+	347,
+	281,
+	347,
+	280,
+	347,
+	281,
+	348,
+	282,
+	348,
+	281,
+	348,
+	282,
+	349,
+	283,
+	349,
+	282,
+	349,
+	283,
+	350,
+	284,
+	350,
+	283,
+	350,
+	284,
+	351,
+	285,
+	351,
+	284,
+	351,
+	285,
+	352,
+	286,
+	352,
+	285,
+	352,
+	286,
+	353,
+	287,
+	353,
+	286,
+	353,
+	287,
+	354,
+	288,
+	354,
+	287,
+	354,
+	288,
+	355,
+	289,
+	355,
+	288,
+	355,
+	289,
+	356,
+	290,
+	356,
+	289,
+	356,
+	290,
+	357,
+	291,
+	357,
+	290,
+	357,
+	291,
+	358,
+	292,
+	358,
+	291,
+	358,
+	292,
+	359,
+	293,
+	359,
+	292,
+	359,
+	293,
+	360,
+	294,
+	360,
+	293,
+	360,
+	294,
+	361,
+	295,
+	361,
+	294,
+	361,
+	295,
+	362,
+	296,
+	362,
+	295,
+	362,
+	296,
+	363,
+	297,
+	363,
+	296,
+	363,
+	297,
+	364,
+	298,
+	364,
+	297,
+	364,
+	298,
+	365,
+	299,
+	365,
+	298,
+	365,
+	299,
+	366,
+	300,
+	366,
+	299,
+	366,
+	300,
+	367,
+	301,
+	367,
+	300,
+	367,
+	301,
+	368,
+	302,
+	368,
+	301,
+	368,
+	302,
+	369,
+	303,
+	369,
+	302,
+	369,
+	303,
+	370,
+	304,
+	370,
+	303,
+	370,
+	304,
+	371,
+	305,
+	371,
+	304,
+	371,
+	305,
+	372,
+	306,
+	372,
+	305,
+	372,
+	306,
+	373,
+	307,
+	373,
+	306,
+	373,
+	307,
+	374,
+	308,
+	374,
+	307,
+	374,
+	308,
+	375,
+	309,
+	375,
+	308,
+	375,
+	309,
+	376,
+	310,
+	376,
+	309,
+	376,
+	310,
+	377,
+	311,
+	377,
+	310,
+	377,
+	311,
+	378,
+	312,
+	378,
+	311,
+	378,
+	312,
+	379,
+	313,
+	379,
+	312,
+	379,
+	313,
+	380,
+	314,
+	380,
+	313,
+	380,
+	314,
+	381,
+	315,
+	381,
+	314,
+	381,
+	315,
+	382,
+	316,
+	382,
+	315,
+	382,
+	316,
+	383,
+	317,
+	383,
+	316,
+	383,
+	317,
+	384,
+	318,
+	384,
+	317,
+	384,
+	318,
+	385,
+	319,
+	385,
+	318,
+	385,
+	319,
+	386,
+	320,
+	386,
+	319,
+	386,
+	320,
+	387,
+	321,
+	387,
+	320,
+	387,
+	321,
+	388,
+	322,
+	388,
+	321,
+	388,
+	322,
+	389,
+	323,
+	389,
+	322,
+	389,
+	323,
+	390,
+	324,
+	390,
+	323,
+	390,
+	324,
+	391,
+	325,
+	391,
+	324,
+	391,
+	325,
+	392,
+	326,
+	392,
+	325,
+	392,
+	326,
+	393,
+	327,
+	393,
+	326,
+	393,
+	327,
+	394,
+	328,
+	394,
+	327,
+	394,
+	328,
+	395,
+	329,
+	395,
+	328,
+	396,
+	330,
+	397,
+	331,
+	397,
+	330,
+	397,
+	331,
+	398,
+	332,
+	398,
+	331,
+	398,
+	332,
+	399,
+	333,
+	399,
+	332,
+	399,
+	333,
+	400,
+	334,
+	400,
+	333,
+	400,
+	334,
+	401,
+	335,
+	401,
+	334,
+	401,
+	335,
+	402,
+	336,
+	402,
+	335,
+	402,
+	336,
+	403,
+	337,
+	403,
+	336,
+	403,
+	337,
+	404,
+	338,
+	404,
+	337,
+	404,
+	338,
+	405,
+	339,
+	405,
+	338,
+	405,
+	339,
+	406,
+	340,
+	406,
+	339,
+	406,
+	340,
+	407,
+	341,
+	407,
+	340,
+	407,
+	341,
+	408,
+	342,
+	408,
+	341,
+	408,
+	342,
+	409,
+	343,
+	409,
+	342,
+	409,
+	343,
+	410,
+	344,
+	410,
+	343,
+	410,
+	344,
+	411,
+	345,
+	411,
+	344,
+	411,
+	345,
+	412,
+	346,
+	412,
+	345,
+	412,
+	346,
+	413,
+	347,
+	413,
+	346,
+	413,
+	347,
+	414,
+	348,
+	414,
+	347,
+	414,
+	348,
+	415,
+	349,
+	415,
+	348,
+	415,
+	349,
+	416,
+	350,
+	416,
+	349,
+	416,
+	350,
+	417,
+	351,
+	417,
+	350,
+	417,
+	351,
+	418,
+	352,
+	418,
+	351,
+	418,
+	352,
+	419,
+	353,
+	419,
+	352,
+	419,
+	353,
+	420,
+	354,
+	420,
+	353,
+	420,
+	354,
+	421,
+	355,
+	421,
+	354,
+	421,
+	355,
+	422,
+	356,
+	422,
+	355,
+	422,
+	356,
+	423,
+	357,
+	423,
+	356,
+	423,
+	357,
+	424,
+	358,
+	424,
+	357,
+	424,
+	358,
+	425,
+	359,
+	425,
+	358,
+	425,
+	359,
+	426,
+	360,
+	426,
+	359,
+	426,
+	360,
+	427,
+	361,
+	427,
+	360,
+	427,
+	361,
+	428,
+	362,
+	428,
+	361,
+	428,
+	362,
+	429,
+	363,
+	429,
+	362,
+	429,
+	363,
+	430,
+	364,
+	430,
+	363,
+	430,
+	364,
+	431,
+	365,
+	431,
+	364,
+	431,
+	365,
+	432,
+	366,
+	432,
+	365,
+	432,
+	366,
+	433,
+	367,
+	433,
+	366,
+	433,
+	367,
+	434,
+	368,
+	434,
+	367,
+	434,
+	368,
+	435,
+	369,
+	435,
+	368,
+	435,
+	369,
+	436,
+	370,
+	436,
+	369,
+	436,
+	370,
+	437,
+	371,
+	437,
+	370,
+	437,
+	371,
+	438,
+	372,
+	438,
+	371,
+	438,
+	372,
+	439,
+	373,
+	439,
+	372,
+	439,
+	373,
+	440,
+	374,
+	440,
+	373,
+	440,
+	374,
+	441,
+	375,
+	441,
+	374,
+	441,
+	375,
+	442,
+	376,
+	442,
+	375,
+	442,
+	376,
+	443,
+	377,
+	443,
+	376,
+	443,
+	377,
+	444,
+	378,
+	444,
+	377,
+	444,
+	378,
+	445,
+	379,
+	445,
+	378,
+	445,
+	379,
+	446,
+	380,
+	446,
+	379,
+	446,
+	380,
+	447,
+	381,
+	447,
+	380,
+	447,
+	381,
+	448,
+	382,
+	448,
+	381,
+	448,
+	382,
+	449,
+	383,
+	449,
+	382,
+	449,
+	383,
+	450,
+	384,
+	450,
+	383,
+	450,
+	384,
+	451,
+	385,
+	451,
+	384,
+	451,
+	385,
+	452,
+	386,
+	452,
+	385,
+	452,
+	386,
+	453,
+	387,
+	453,
+	386,
+	453,
+	387,
+	454,
+	388,
+	454,
+	387,
+	454,
+	388,
+	455,
+	389,
+	455,
+	388,
+	455,
+	389,
+	456,
+	390,
+	456,
+	389,
+	456,
+	390,
+	457,
+	391,
+	457,
+	390,
+	457,
+	391,
+	458,
+	392,
+	458,
+	391,
+	458,
+	392,
+	459,
+	393,
+	459,
+	392,
+	459,
+	393,
+	460,
+	394,
+	460,
+	393,
+	460,
+	394,
+	461,
+	395,
+	461,
+	394,
+	462,
+	396,
+	463,
+	397,
+	463,
+	396,
+	463,
+	397,
+	464,
+	398,
+	464,
+	397,
+	464,
+	398,
+	465,
+	399,
+	465,
+	398,
+	465,
+	399,
+	466,
+	400,
+	466,
+	399,
+	466,
+	400,
+	467,
+	401,
+	467,
+	400,
+	467,
+	401,
+	468,
+	402,
+	468,
+	401,
+	468,
+	402,
+	469,
+	403,
+	469,
+	402,
+	469,
+	403,
+	470,
+	404,
+	470,
+	403,
+	470,
+	404,
+	471,
+	405,
+	471,
+	404,
+	471,
+	405,
+	472,
+	406,
+	472,
+	405,
+	472,
+	406,
+	473,
+	407,
+	473,
+	406,
+	473,
+	407,
+	474,
+	408,
+	474,
+	407,
+	474,
+	408,
+	475,
+	409,
+	475,
+	408,
+	475,
+	409,
+	476,
+	410,
+	476,
+	409,
+	476,
+	410,
+	477,
+	411,
+	477,
+	410,
+	477,
+	411,
+	478,
+	412,
+	478,
+	411,
+	478,
+	412,
+	479,
+	413,
+	479,
+	412,
+	479,
+	413,
+	480,
+	414,
+	480,
+	413,
+	480,
+	414,
+	481,
+	415,
+	481,
+	414,
+	481,
+	415,
+	482,
+	416,
+	482,
+	415,
+	482,
+	416,
+	483,
+	417,
+	483,
+	416,
+	483,
+	417,
+	484,
+	418,
+	484,
+	417,
+	484,
+	418,
+	485,
+	419,
+	485,
+	418,
+	485,
+	419,
+	486,
+	420,
+	486,
+	419,
+	486,
+	420,
+	487,
+	421,
+	487,
+	420,
+	487,
+	421,
+	488,
+	422,
+	488,
+	421,
+	488,
+	422,
+	489,
+	423,
+	489,
+	422,
+	489,
+	423,
+	490,
+	424,
+	490,
+	423,
+	490,
+	424,
+	491,
+	425,
+	491,
+	424,
+	491,
+	425,
+	492,
+	426,
+	492,
+	425,
+	492,
+	426,
+	493,
+	427,
+	493,
+	426,
+	493,
+	427,
+	494,
+	428,
+	494,
+	427,
+	494,
+	428,
+	495,
+	429,
+	495,
+	428,
+	495,
+	429,
+	496,
+	430,
+	496,
+	429,
+	496,
+	430,
+	497,
+	431,
+	497,
+	430,
+	497,
+	431,
+	498,
+	432,
+	498,
+	431,
+	498,
+	432,
+	499,
+	433,
+	499,
+	432,
+	499,
+	433,
+	500,
+	434,
+	500,
+	433,
+	500,
+	434,
+	501,
+	435,
+	501,
+	434,
+	501,
+	435,
+	502,
+	436,
+	502,
+	435,
+	502,
+	436,
+	503,
+	437,
+	503,
+	436,
+	503,
+	437,
+	504,
+	438,
+	504,
+	437,
+	504,
+	438,
+	505,
+	439,
+	505,
+	438,
+	505,
+	439,
+	506,
+	440,
+	506,
+	439,
+	506,
+	440,
+	507,
+	441,
+	507,
+	440,
+	507,
+	441,
+	508,
+	442,
+	508,
+	441,
+	508,
+	442,
+	509,
+	443,
+	509,
+	442,
+	509,
+	443,
+	510,
+	444,
+	510,
+	443,
+	510,
+	444,
+	511,
+	445,
+	511,
+	444,
+	511,
+	445,
+	512,
+	446,
+	512,
+	445,
+	512,
+	446,
+	513,
+	447,
+	513,
+	446,
+	513,
+	447,
+	514,
+	448,
+	514,
+	447,
+	514,
+	448,
+	515,
+	449,
+	515,
+	448,
+	515,
+	449,
+	516,
+	450,
+	516,
+	449,
+	516,
+	450,
+	517,
+	451,
+	517,
+	450,
+	517,
+	451,
+	518,
+	452,
+	518,
+	451,
+	518,
+	452,
+	519,
+	453,
+	519,
+	452,
+	519,
+	453,
+	520,
+	454,
+	520,
+	453,
+	520,
+	454,
+	521,
+	455,
+	521,
+	454,
+	521,
+	455,
+	522,
+	456,
+	522,
+	455,
+	522,
+	456,
+	523,
+	457,
+	523,
+	456,
+	523,
+	457,
+	524,
+	458,
+	524,
+	457,
+	524,
+	458,
+	525,
+	459,
+	525,
+	458,
+	525,
+	459,
+	526,
+	460,
+	526,
+	459,
+	526,
+	460,
+	527,
+	461,
+	527,
+	460,
+	528,
+	462,
+	529,
+	463,
+	529,
+	462,
+	529,
+	463,
+	530,
+	464,
+	530,
+	463,
+	530,
+	464,
+	531,
+	465,
+	531,
+	464,
+	531,
+	465,
+	532,
+	466,
+	532,
+	465,
+	532,
+	466,
+	533,
+	467,
+	533,
+	466,
+	533,
+	467,
+	534,
+	468,
+	534,
+	467,
+	534,
+	468,
+	535,
+	469,
+	535,
+	468,
+	535,
+	469,
+	536,
+	470,
+	536,
+	469,
+	536,
+	470,
+	537,
+	471,
+	537,
+	470,
+	537,
+	471,
+	538,
+	472,
+	538,
+	471,
+	538,
+	472,
+	539,
+	473,
+	539,
+	472,
+	539,
+	473,
+	540,
+	474,
+	540,
+	473,
+	540,
+	474,
+	541,
+	475,
+	541,
+	474,
+	541,
+	475,
+	542,
+	476,
+	542,
+	475,
+	542,
+	476,
+	543,
+	477,
+	543,
+	476,
+	543,
+	477,
+	544,
+	478,
+	544,
+	477,
+	544,
+	478,
+	545,
+	479,
+	545,
+	478,
+	545,
+	479,
+	546,
+	480,
+	546,
+	479,
+	546,
+	480,
+	547,
+	481,
+	547,
+	480,
+	547,
+	481,
+	548,
+	482,
+	548,
+	481,
+	548,
+	482,
+	549,
+	483,
+	549,
+	482,
+	549,
+	483,
+	550,
+	484,
+	550,
+	483,
+	550,
+	484,
+	551,
+	485,
+	551,
+	484,
+	551,
+	485,
+	552,
+	486,
+	552,
+	485,
+	552,
+	486,
+	553,
+	487,
+	553,
+	486,
+	553,
+	487,
+	554,
+	488,
+	554,
+	487,
+	554,
+	488,
+	555,
+	489,
+	555,
+	488,
+	555,
+	489,
+	556,
+	490,
+	556,
+	489,
+	556,
+	490,
+	557,
+	491,
+	557,
+	490,
+	557,
+	491,
+	558,
+	492,
+	558,
+	491,
+	558,
+	492,
+	559,
+	493,
+	559,
+	492,
+	559,
+	493,
+	560,
+	494,
+	560,
+	493,
+	560,
+	494,
+	561,
+	495,
+	561,
+	494,
+	561,
+	495,
+	562,
+	496,
+	562,
+	495,
+	562,
+	496,
+	563,
+	497,
+	563,
+	496,
+	563,
+	497,
+	564,
+	498,
+	564,
+	497,
+	564,
+	498,
+	565,
+	499,
+	565,
+	498,
+	565,
+	499,
+	566,
+	500,
+	566,
+	499,
+	566,
+	500,
+	567,
+	501,
+	567,
+	500,
+	567,
+	501,
+	568,
+	502,
+	568,
+	501,
+	568,
+	502,
+	569,
+	503,
+	569,
+	502,
+	569,
+	503,
+	570,
+	504,
+	570,
+	503,
+	570,
+	504,
+	571,
+	505,
+	571,
+	504,
+	571,
+	505,
+	572,
+	506,
+	572,
+	505,
+	572,
+	506,
+	573,
+	507,
+	573,
+	506,
+	573,
+	507,
+	574,
+	508,
+	574,
+	507,
+	574,
+	508,
+	575,
+	509,
+	575,
+	508,
+	575,
+	509,
+	576,
+	510,
+	576,
+	509,
+	576,
+	510,
+	577,
+	511,
+	577,
+	510,
+	577,
+	511,
+	578,
+	512,
+	578,
+	511,
+	578,
+	512,
+	579,
+	513,
+	579,
+	512,
+	579,
+	513,
+	580,
+	514,
+	580,
+	513,
+	580,
+	514,
+	581,
+	515,
+	581,
+	514,
+	581,
+	515,
+	582,
+	516,
+	582,
+	515,
+	582,
+	516,
+	583,
+	517,
+	583,
+	516,
+	583,
+	517,
+	584,
+	518,
+	584,
+	517,
+	584,
+	518,
+	585,
+	519,
+	585,
+	518,
+	585,
+	519,
+	586,
+	520,
+	586,
+	519,
+	586,
+	520,
+	587,
+	521,
+	587,
+	520,
+	587,
+	521,
+	588,
+	522,
+	588,
+	521,
+	588,
+	522,
+	589,
+	523,
+	589,
+	522,
+	589,
+	523,
+	590,
+	524,
+	590,
+	523,
+	590,
+	524,
+	591,
+	525,
+	591,
+	524,
+	591,
+	525,
+	592,
+	526,
+	592,
+	525,
+	592,
+	526,
+	593,
+	527,
+	593,
+	526,
+	594,
+	528,
+	595,
+	529,
+	595,
+	528,
+	595,
+	529,
+	596,
+	530,
+	596,
+	529,
+	596,
+	530,
+	597,
+	531,
+	597,
+	530,
+	597,
+	531,
+	598,
+	532,
+	598,
+	531,
+	598,
+	532,
+	599,
+	533,
+	599,
+	532,
+	599,
+	533,
+	600,
+	534,
+	600,
+	533,
+	600,
+	534,
+	601,
+	535,
+	601,
+	534,
+	601,
+	535,
+	602,
+	536,
+	602,
+	535,
+	602,
+	536,
+	603,
+	537,
+	603,
+	536,
+	603,
+	537,
+	604,
+	538,
+	604,
+	537,
+	604,
+	538,
+	605,
+	539,
+	605,
+	538,
+	605,
+	539,
+	606,
+	540,
+	606,
+	539,
+	606,
+	540,
+	607,
+	541,
+	607,
+	540,
+	607,
+	541,
+	608,
+	542,
+	608,
+	541,
+	608,
+	542,
+	609,
+	543,
+	609,
+	542,
+	609,
+	543,
+	610,
+	544,
+	610,
+	543,
+	610,
+	544,
+	611,
+	545,
+	611,
+	544,
+	611,
+	545,
+	612,
+	546,
+	612,
+	545,
+	612,
+	546,
+	613,
+	547,
+	613,
+	546,
+	613,
+	547,
+	614,
+	548,
+	614,
+	547,
+	614,
+	548,
+	615,
+	549,
+	615,
+	548,
+	615,
+	549,
+	616,
+	550,
+	616,
+	549,
+	616,
+	550,
+	617,
+	551,
+	617,
+	550,
+	617,
+	551,
+	618,
+	552,
+	618,
+	551,
+	618,
+	552,
+	619,
+	553,
+	619,
+	552,
+	619,
+	553,
+	620,
+	554,
+	620,
+	553,
+	620,
+	554,
+	621,
+	555,
+	621,
+	554,
+	621,
+	555,
+	622,
+	556,
+	622,
+	555,
+	622,
+	556,
+	623,
+	557,
+	623,
+	556,
+	623,
+	557,
+	624,
+	558,
+	624,
+	557,
+	624,
+	558,
+	625,
+	559,
+	625,
+	558,
+	625,
+	559,
+	626,
+	560,
+	626,
+	559,
+	626,
+	560,
+	627,
+	561,
+	627,
+	560,
+	627,
+	561,
+	628,
+	562,
+	628,
+	561,
+	628,
+	562,
+	629,
+	563,
+	629,
+	562,
+	629,
+	563,
+	630,
+	564,
+	630,
+	563,
+	630,
+	564,
+	631,
+	565,
+	631,
+	564,
+	631,
+	565,
+	632,
+	566,
+	632,
+	565,
+	632,
+	566,
+	633,
+	567,
+	633,
+	566,
+	633,
+	567,
+	634,
+	568,
+	634,
+	567,
+	634,
+	568,
+	635,
+	569,
+	635,
+	568,
+	635,
+	569,
+	636,
+	570,
+	636,
+	569,
+	636,
+	570,
+	637,
+	571,
+	637,
+	570,
+	637,
+	571,
+	638,
+	572,
+	638,
+	571,
+	638,
+	572,
+	639,
+	573,
+	639,
+	572,
+	639,
+	573,
+	640,
+	574,
+	640,
+	573,
+	640,
+	574,
+	641,
+	575,
+	641,
+	574,
+	641,
+	575,
+	642,
+	576,
+	642,
+	575,
+	642,
+	576,
+	643,
+	577,
+	643,
+	576,
+	643,
+	577,
+	644,
+	578,
+	644,
+	577,
+	644,
+	578,
+	645,
+	579,
+	645,
+	578,
+	645,
+	579,
+	646,
+	580,
+	646,
+	579,
+	646,
+	580,
+	647,
+	581,
+	647,
+	580,
+	647,
+	581,
+	648,
+	582,
+	648,
+	581,
+	648,
+	582,
+	649,
+	583,
+	649,
+	582,
+	649,
+	583,
+	650,
+	584,
+	650,
+	583,
+	650,
+	584,
+	651,
+	585,
+	651,
+	584,
+	651,
+	585,
+	652,
+	586,
+	652,
+	585,
+	652,
+	586,
+	653,
+	587,
+	653,
+	586,
+	653,
+	587,
+	654,
+	588,
+	654,
+	587,
+	654,
+	588,
+	655,
+	589,
+	655,
+	588,
+	655,
+	589,
+	656,
+	590,
+	656,
+	589,
+	656,
+	590,
+	657,
+	591,
+	657,
+	590,
+	657,
+	591,
+	658,
+	592,
+	658,
+	591,
+	658,
+	592,
+	659,
+	593,
+	659,
+	592,
+	660,
+	594,
+	661,
+	595,
+	661,
+	594,
+	661,
+	595,
+	662,
+	596,
+	662,
+	595,
+	662,
+	596,
+	663,
+	597,
+	663,
+	596,
+	663,
+	597,
+	664,
+	598,
+	664,
+	597,
+	664,
+	598,
+	665,
+	599,
+	665,
+	598,
+	665,
+	599,
+	666,
+	600,
+	666,
+	599,
+	666,
+	600,
+	667,
+	601,
+	667,
+	600,
+	667,
+	601,
+	668,
+	602,
+	668,
+	601,
+	668,
+	602,
+	669,
+	603,
+	669,
+	602,
+	669,
+	603,
+	670,
+	604,
+	670,
+	603,
+	670,
+	604,
+	671,
+	605,
+	671,
+	604,
+	671,
+	605,
+	672,
+	606,
+	672,
+	605,
+	672,
+	606,
+	673,
+	607,
+	673,
+	606,
+	673,
+	607,
+	674,
+	608,
+	674,
+	607,
+	674,
+	608,
+	675,
+	609,
+	675,
+	608,
+	675,
+	609,
+	676,
+	610,
+	676,
+	609,
+	676,
+	610,
+	677,
+	611,
+	677,
+	610,
+	677,
+	611,
+	678,
+	612,
+	678,
+	611,
+	678,
+	612,
+	679,
+	613,
+	679,
+	612,
+	679,
+	613,
+	680,
+	614,
+	680,
+	613,
+	680,
+	614,
+	681,
+	615,
+	681,
+	614,
+	681,
+	615,
+	682,
+	616,
+	682,
+	615,
+	682,
+	616,
+	683,
+	617,
+	683,
+	616,
+	683,
+	617,
+	684,
+	618,
+	684,
+	617,
+	684,
+	618,
+	685,
+	619,
+	685,
+	618,
+	685,
+	619,
+	686,
+	620,
+	686,
+	619,
+	686,
+	620,
+	687,
+	621,
+	687,
+	620,
+	687,
+	621,
+	688,
+	622,
+	688,
+	621,
+	688,
+	622,
+	689,
+	623,
+	689,
+	622,
+	689,
+	623,
+	690,
+	624,
+	690,
+	623,
+	690,
+	624,
+	691,
+	625,
+	691,
+	624,
+	691,
+	625,
+	692,
+	626,
+	692,
+	625,
+	692,
+	626,
+	693,
+	627,
+	693,
+	626,
+	693,
+	627,
+	694,
+	628,
+	694,
+	627,
+	694,
+	628,
+	695,
+	629,
+	695,
+	628,
+	695,
+	629,
+	696,
+	630,
+	696,
+	629,
+	696,
+	630,
+	697,
+	631,
+	697,
+	630,
+	697,
+	631,
+	698,
+	632,
+	698,
+	631,
+	698,
+	632,
+	699,
+	633,
+	699,
+	632,
+	699,
+	633,
+	700,
+	634,
+	700,
+	633,
+	700,
+	634,
+	701,
+	635,
+	701,
+	634,
+	701,
+	635,
+	702,
+	636,
+	702,
+	635,
+	702,
+	636,
+	703,
+	637,
+	703,
+	636,
+	703,
+	637,
+	704,
+	638,
+	704,
+	637,
+	704,
+	638,
+	705,
+	639,
+	705,
+	638,
+	705,
+	639,
+	706,
+	640,
+	706,
+	639,
+	706,
+	640,
+	707,
+	641,
+	707,
+	640,
+	707,
+	641,
+	708,
+	642,
+	708,
+	641,
+	708,
+	642,
+	709,
+	643,
+	709,
+	642,
+	709,
+	643,
+	710,
+	644,
+	710,
+	643,
+	710,
+	644,
+	711,
+	645,
+	711,
+	644,
+	711,
+	645,
+	712,
+	646,
+	712,
+	645,
+	712,
+	646,
+	713,
+	647,
+	713,
+	646,
+	713,
+	647,
+	714,
+	648,
+	714,
+	647,
+	714,
+	648,
+	715,
+	649,
+	715,
+	648,
+	715,
+	649,
+	716,
+	650,
+	716,
+	649,
+	716,
+	650,
+	717,
+	651,
+	717,
+	650,
+	717,
+	651,
+	718,
+	652,
+	718,
+	651,
+	718,
+	652,
+	719,
+	653,
+	719,
+	652,
+	719,
+	653,
+	720,
+	654,
+	720,
+	653,
+	720,
+	654,
+	721,
+	655,
+	721,
+	654,
+	721,
+	655,
+	722,
+	656,
+	722,
+	655,
+	722,
+	656,
+	723,
+	657,
+	723,
+	656,
+	723,
+	657,
+	724,
+	658,
+	724,
+	657,
+	724,
+	658,
+	725,
+	659,
+	725,
+	658,
+	726,
+	660,
+	727,
+	661,
+	727,
+	660,
+	727,
+	661,
+	728,
+	662,
+	728,
+	661,
+	728,
+	662,
+	729,
+	663,
+	729,
+	662,
+	729,
+	663,
+	730,
+	664,
+	730,
+	663,
+	730,
+	664,
+	731,
+	665,
+	731,
+	664,
+	731,
+	665,
+	732,
+	666,
+	732,
+	665,
+	732,
+	666,
+	733,
+	667,
+	733,
+	666,
+	733,
+	667,
+	734,
+	668,
+	734,
+	667,
+	734,
+	668,
+	735,
+	669,
+	735,
+	668,
+	735,
+	669,
+	736,
+	670,
+	736,
+	669,
+	736,
+	670,
+	737,
+	671,
+	737,
+	670,
+	737,
+	671,
+	738,
+	672,
+	738,
+	671,
+	738,
+	672,
+	739,
+	673,
+	739,
+	672,
+	739,
+	673,
+	740,
+	674,
+	740,
+	673,
+	740,
+	674,
+	741,
+	675,
+	741,
+	674,
+	741,
+	675,
+	742,
+	676,
+	742,
+	675,
+	742,
+	676,
+	743,
+	677,
+	743,
+	676,
+	743,
+	677,
+	744,
+	678,
+	744,
+	677,
+	744,
+	678,
+	745,
+	679,
+	745,
+	678,
+	745,
+	679,
+	746,
+	680,
+	746,
+	679,
+	746,
+	680,
+	747,
+	681,
+	747,
+	680,
+	747,
+	681,
+	748,
+	682,
+	748,
+	681,
+	748,
+	682,
+	749,
+	683,
+	749,
+	682,
+	749,
+	683,
+	750,
+	684,
+	750,
+	683,
+	750,
+	684,
+	751,
+	685,
+	751,
+	684,
+	751,
+	685,
+	752,
+	686,
+	752,
+	685,
+	752,
+	686,
+	753,
+	687,
+	753,
+	686,
+	753,
+	687,
+	754,
+	688,
+	754,
+	687,
+	754,
+	688,
+	755,
+	689,
+	755,
+	688,
+	755,
+	689,
+	756,
+	690,
+	756,
+	689,
+	756,
+	690,
+	757,
+	691,
+	757,
+	690,
+	757,
+	691,
+	758,
+	692,
+	758,
+	691,
+	758,
+	692,
+	759,
+	693,
+	759,
+	692,
+	759,
+	693,
+	760,
+	694,
+	760,
+	693,
+	760,
+	694,
+	761,
+	695,
+	761,
+	694,
+	761,
+	695,
+	762,
+	696,
+	762,
+	695,
+	762,
+	696,
+	763,
+	697,
+	763,
+	696,
+	763,
+	697,
+	764,
+	698,
+	764,
+	697,
+	764,
+	698,
+	765,
+	699,
+	765,
+	698,
+	765,
+	699,
+	766,
+	700,
+	766,
+	699,
+	766,
+	700,
+	767,
+	701,
+	767,
+	700,
+	767,
+	701,
+	768,
+	702,
+	768,
+	701,
+	768,
+	702,
+	769,
+	703,
+	769,
+	702,
+	769,
+	703,
+	770,
+	704,
+	770,
+	703,
+	770,
+	704,
+	771,
+	705,
+	771,
+	704,
+	771,
+	705,
+	772,
+	706,
+	772,
+	705,
+	772,
+	706,
+	773,
+	707,
+	773,
+	706,
+	773,
+	707,
+	774,
+	708,
+	774,
+	707,
+	774,
+	708,
+	775,
+	709,
+	775,
+	708,
+	775,
+	709,
+	776,
+	710,
+	776,
+	709,
+	776,
+	710,
+	777,
+	711,
+	777,
+	710,
+	777,
+	711,
+	778,
+	712,
+	778,
+	711,
+	778,
+	712,
+	779,
+	713,
+	779,
+	712,
+	779,
+	713,
+	780,
+	714,
+	780,
+	713,
+	780,
+	714,
+	781,
+	715,
+	781,
+	714,
+	781,
+	715,
+	782,
+	716,
+	782,
+	715,
+	782,
+	716,
+	783,
+	717,
+	783,
+	716,
+	783,
+	717,
+	784,
+	718,
+	784,
+	717,
+	784,
+	718,
+	785,
+	719,
+	785,
+	718,
+	785,
+	719,
+	786,
+	720,
+	786,
+	719,
+	786,
+	720,
+	787,
+	721,
+	787,
+	720,
+	787,
+	721,
+	788,
+	722,
+	788,
+	721,
+	788,
+	722,
+	789,
+	723,
+	789,
+	722,
+	789,
+	723,
+	790,
+	724,
+	790,
+	723,
+	790,
+	724,
+	791,
+	725,
+	791,
+	724,
+	792,
+	726,
+	793,
+	727,
+	793,
+	726,
+	793,
+	727,
+	794,
+	728,
+	794,
+	727,
+	794,
+	728,
+	795,
+	729,
+	795,
+	728,
+	795,
+	729,
+	796,
+	730,
+	796,
+	729,
+	796,
+	730,
+	797,
+	731,
+	797,
+	730,
+	797,
+	731,
+	798,
+	732,
+	798,
+	731,
+	798,
+	732,
+	799,
+	733,
+	799,
+	732,
+	799,
+	733,
+	800,
+	734,
+	800,
+	733,
+	800,
+	734,
+	801,
+	735,
+	801,
+	734,
+	801,
+	735,
+	802,
+	736,
+	802,
+	735,
+	802,
+	736,
+	803,
+	737,
+	803,
+	736,
+	803,
+	737,
+	804,
+	738,
+	804,
+	737,
+	804,
+	738,
+	805,
+	739,
+	805,
+	738,
+	805,
+	739,
+	806,
+	740,
+	806,
+	739,
+	806,
+	740,
+	807,
+	741,
+	807,
+	740,
+	807,
+	741,
+	808,
+	742,
+	808,
+	741,
+	808,
+	742,
+	809,
+	743,
+	809,
+	742,
+	809,
+	743,
+	810,
+	744,
+	810,
+	743,
+	810,
+	744,
+	811,
+	745,
+	811,
+	744,
+	811,
+	745,
+	812,
+	746,
+	812,
+	745,
+	812,
+	746,
+	813,
+	747,
+	813,
+	746,
+	813,
+	747,
+	814,
+	748,
+	814,
+	747,
+	814,
+	748,
+	815,
+	749,
+	815,
+	748,
+	815,
+	749,
+	816,
+	750,
+	816,
+	749,
+	816,
+	750,
+	817,
+	751,
+	817,
+	750,
+	817,
+	751,
+	818,
+	752,
+	818,
+	751,
+	818,
+	752,
+	819,
+	753,
+	819,
+	752,
+	819,
+	753,
+	820,
+	754,
+	820,
+	753,
+	820,
+	754,
+	821,
+	755,
+	821,
+	754,
+	821,
+	755,
+	822,
+	756,
+	822,
+	755,
+	822,
+	756,
+	823,
+	757,
+	823,
+	756,
+	823,
+	757,
+	824,
+	758,
+	824,
+	757,
+	824,
+	758,
+	825,
+	759,
+	825,
+	758,
+	825,
+	759,
+	826,
+	760,
+	826,
+	759,
+	826,
+	760,
+	827,
+	761,
+	827,
+	760,
+	827,
+	761,
+	828,
+	762,
+	828,
+	761,
+	828,
+	762,
+	829,
+	763,
+	829,
+	762,
+	829,
+	763,
+	830,
+	764,
+	830,
+	763,
+	830,
+	764,
+	831,
+	765,
+	831,
+	764,
+	831,
+	765,
+	832,
+	766,
+	832,
+	765,
+	832,
+	766,
+	833,
+	767,
+	833,
+	766,
+	833,
+	767,
+	834,
+	768,
+	834,
+	767,
+	834,
+	768,
+	835,
+	769,
+	835,
+	768,
+	835,
+	769,
+	836,
+	770,
+	836,
+	769,
+	836,
+	770,
+	837,
+	771,
+	837,
+	770,
+	837,
+	771,
+	838,
+	772,
+	838,
+	771,
+	838,
+	772,
+	839,
+	773,
+	839,
+	772,
+	839,
+	773,
+	840,
+	774,
+	840,
+	773,
+	840,
+	774,
+	841,
+	775,
+	841,
+	774,
+	841,
+	775,
+	842,
+	776,
+	842,
+	775,
+	842,
+	776,
+	843,
+	777,
+	843,
+	776,
+	843,
+	777,
+	844,
+	778,
+	844,
+	777,
+	844,
+	778,
+	845,
+	779,
+	845,
+	778,
+	845,
+	779,
+	846,
+	780,
+	846,
+	779,
+	846,
+	780,
+	847,
+	781,
+	847,
+	780,
+	847,
+	781,
+	848,
+	782,
+	848,
+	781,
+	848,
+	782,
+	849,
+	783,
+	849,
+	782,
+	849,
+	783,
+	850,
+	784,
+	850,
+	783,
+	850,
+	784,
+	851,
+	785,
+	851,
+	784,
+	851,
+	785,
+	852,
+	786,
+	852,
+	785,
+	852,
+	786,
+	853,
+	787,
+	853,
+	786,
+	853,
+	787,
+	854,
+	788,
+	854,
+	787,
+	854,
+	788,
+	855,
+	789,
+	855,
+	788,
+	855,
+	789,
+	856,
+	790,
+	856,
+	789,
+	856,
+	790,
+	857,
+	791,
+	857,
+	790,
+	858,
+	792,
+	859,
+	793,
+	859,
+	792,
+	859,
+	793,
+	860,
+	794,
+	860,
+	793,
+	860,
+	794,
+	861,
+	795,
+	861,
+	794,
+	861,
+	795,
+	862,
+	796,
+	862,
+	795,
+	862,
+	796,
+	863,
+	797,
+	863,
+	796,
+	863,
+	797,
+	864,
+	798,
+	864,
+	797,
+	864,
+	798,
+	865,
+	799,
+	865,
+	798,
+	865,
+	799,
+	866,
+	800,
+	866,
+	799,
+	866,
+	800,
+	867,
+	801,
+	867,
+	800,
+	867,
+	801,
+	868,
+	802,
+	868,
+	801,
+	868,
+	802,
+	869,
+	803,
+	869,
+	802,
+	869,
+	803,
+	870,
+	804,
+	870,
+	803,
+	870,
+	804,
+	871,
+	805,
+	871,
+	804,
+	871,
+	805,
+	872,
+	806,
+	872,
+	805,
+	872,
+	806,
+	873,
+	807,
+	873,
+	806,
+	873,
+	807,
+	874,
+	808,
+	874,
+	807,
+	874,
+	808,
+	875,
+	809,
+	875,
+	808,
+	875,
+	809,
+	876,
+	810,
+	876,
+	809,
+	876,
+	810,
+	877,
+	811,
+	877,
+	810,
+	877,
+	811,
+	878,
+	812,
+	878,
+	811,
+	878,
+	812,
+	879,
+	813,
+	879,
+	812,
+	879,
+	813,
+	880,
+	814,
+	880,
+	813,
+	880,
+	814,
+	881,
+	815,
+	881,
+	814,
+	881,
+	815,
+	882,
+	816,
+	882,
+	815,
+	882,
+	816,
+	883,
+	817,
+	883,
+	816,
+	883,
+	817,
+	884,
+	818,
+	884,
+	817,
+	884,
+	818,
+	885,
+	819,
+	885,
+	818,
+	885,
+	819,
+	886,
+	820,
+	886,
+	819,
+	886,
+	820,
+	887,
+	821,
+	887,
+	820,
+	887,
+	821,
+	888,
+	822,
+	888,
+	821,
+	888,
+	822,
+	889,
+	823,
+	889,
+	822,
+	889,
+	823,
+	890,
+	824,
+	890,
+	823,
+	890,
+	824,
+	891,
+	825,
+	891,
+	824,
+	891,
+	825,
+	892,
+	826,
+	892,
+	825,
+	892,
+	826,
+	893,
+	827,
+	893,
+	826,
+	893,
+	827,
+	894,
+	828,
+	894,
+	827,
+	894,
+	828,
+	895,
+	829,
+	895,
+	828,
+	895,
+	829,
+	896,
+	830,
+	896,
+	829,
+	896,
+	830,
+	897,
+	831,
+	897,
+	830,
+	897,
+	831,
+	898,
+	832,
+	898,
+	831,
+	898,
+	832,
+	899,
+	833,
+	899,
+	832,
+	899,
+	833,
+	900,
+	834,
+	900,
+	833,
+	900,
+	834,
+	901,
+	835,
+	901,
+	834,
+	901,
+	835,
+	902,
+	836,
+	902,
+	835,
+	902,
+	836,
+	903,
+	837,
+	903,
+	836,
+	903,
+	837,
+	904,
+	838,
+	904,
+	837,
+	904,
+	838,
+	905,
+	839,
+	905,
+	838,
+	905,
+	839,
+	906,
+	840,
+	906,
+	839,
+	906,
+	840,
+	907,
+	841,
+	907,
+	840,
+	907,
+	841,
+	908,
+	842,
+	908,
+	841,
+	908,
+	842,
+	909,
+	843,
+	909,
+	842,
+	909,
+	843,
+	910,
+	844,
+	910,
+	843,
+	910,
+	844,
+	911,
+	845,
+	911,
+	844,
+	911,
+	845,
+	912,
+	846,
+	912,
+	845,
+	912,
+	846,
+	913,
+	847,
+	913,
+	846,
+	913,
+	847,
+	914,
+	848,
+	914,
+	847,
+	914,
+	848,
+	915,
+	849,
+	915,
+	848,
+	915,
+	849,
+	916,
+	850,
+	916,
+	849,
+	916,
+	850,
+	917,
+	851,
+	917,
+	850,
+	917,
+	851,
+	918,
+	852,
+	918,
+	851,
+	918,
+	852,
+	919,
+	853,
+	919,
+	852,
+	919,
+	853,
+	920,
+	854,
+	920,
+	853,
+	920,
+	854,
+	921,
+	855,
+	921,
+	854,
+	921,
+	855,
+	922,
+	856,
+	922,
+	855,
+	922,
+	856,
+	923,
+	857,
+	923,
+	856,
+	924,
+	858,
+	925,
+	859,
+	925,
+	858,
+	925,
+	859,
+	926,
+	860,
+	926,
+	859,
+	926,
+	860,
+	927,
+	861,
+	927,
+	860,
+	927,
+	861,
+	928,
+	862,
+	928,
+	861,
+	928,
+	862,
+	929,
+	863,
+	929,
+	862,
+	929,
+	863,
+	930,
+	864,
+	930,
+	863,
+	930,
+	864,
+	931,
+	865,
+	931,
+	864,
+	931,
+	865,
+	932,
+	866,
+	932,
+	865,
+	932,
+	866,
+	933,
+	867,
+	933,
+	866,
+	933,
+	867,
+	934,
+	868,
+	934,
+	867,
+	934,
+	868,
+	935,
+	869,
+	935,
+	868,
+	935,
+	869,
+	936,
+	870,
+	936,
+	869,
+	936,
+	870,
+	937,
+	871,
+	937,
+	870,
+	937,
+	871,
+	938,
+	872,
+	938,
+	871,
+	938,
+	872,
+	939,
+	873,
+	939,
+	872,
+	939,
+	873,
+	940,
+	874,
+	940,
+	873,
+	940,
+	874,
+	941,
+	875,
+	941,
+	874,
+	941,
+	875,
+	942,
+	876,
+	942,
+	875,
+	942,
+	876,
+	943,
+	877,
+	943,
+	876,
+	943,
+	877,
+	944,
+	878,
+	944,
+	877,
+	944,
+	878,
+	945,
+	879,
+	945,
+	878,
+	945,
+	879,
+	946,
+	880,
+	946,
+	879,
+	946,
+	880,
+	947,
+	881,
+	947,
+	880,
+	947,
+	881,
+	948,
+	882,
+	948,
+	881,
+	948,
+	882,
+	949,
+	883,
+	949,
+	882,
+	949,
+	883,
+	950,
+	884,
+	950,
+	883,
+	950,
+	884,
+	951,
+	885,
+	951,
+	884,
+	951,
+	885,
+	952,
+	886,
+	952,
+	885,
+	952,
+	886,
+	953,
+	887,
+	953,
+	886,
+	953,
+	887,
+	954,
+	888,
+	954,
+	887,
+	954,
+	888,
+	955,
+	889,
+	955,
+	888,
+	955,
+	889,
+	956,
+	890,
+	956,
+	889,
+	956,
+	890,
+	957,
+	891,
+	957,
+	890,
+	957,
+	891,
+	958,
+	892,
+	958,
+	891,
+	958,
+	892,
+	959,
+	893,
+	959,
+	892,
+	959,
+	893,
+	960,
+	894,
+	960,
+	893,
+	960,
+	894,
+	961,
+	895,
+	961,
+	894,
+	961,
+	895,
+	962,
+	896,
+	962,
+	895,
+	962,
+	896,
+	963,
+	897,
+	963,
+	896,
+	963,
+	897,
+	964,
+	898,
+	964,
+	897,
+	964,
+	898,
+	965,
+	899,
+	965,
+	898,
+	965,
+	899,
+	966,
+	900,
+	966,
+	899,
+	966,
+	900,
+	967,
+	901,
+	967,
+	900,
+	967,
+	901,
+	968,
+	902,
+	968,
+	901,
+	968,
+	902,
+	969,
+	903,
+	969,
+	902,
+	969,
+	903,
+	970,
+	904,
+	970,
+	903,
+	970,
+	904,
+	971,
+	905,
+	971,
+	904,
+	971,
+	905,
+	972,
+	906,
+	972,
+	905,
+	972,
+	906,
+	973,
+	907,
+	973,
+	906,
+	973,
+	907,
+	974,
+	908,
+	974,
+	907,
+	974,
+	908,
+	975,
+	909,
+	975,
+	908,
+	975,
+	909,
+	976,
+	910,
+	976,
+	909,
+	976,
+	910,
+	977,
+	911,
+	977,
+	910,
+	977,
+	911,
+	978,
+	912,
+	978,
+	911,
+	978,
+	912,
+	979,
+	913,
+	979,
+	912,
+	979,
+	913,
+	980,
+	914,
+	980,
+	913,
+	980,
+	914,
+	981,
+	915,
+	981,
+	914,
+	981,
+	915,
+	982,
+	916,
+	982,
+	915,
+	982,
+	916,
+	983,
+	917,
+	983,
+	916,
+	983,
+	917,
+	984,
+	918,
+	984,
+	917,
+	984,
+	918,
+	985,
+	919,
+	985,
+	918,
+	985,
+	919,
+	986,
+	920,
+	986,
+	919,
+	986,
+	920,
+	987,
+	921,
+	987,
+	920,
+	987,
+	921,
+	988,
+	922,
+	988,
+	921,
+	988,
+	922,
+	989,
+	923,
+	989,
+	922,
+	990,
+	924,
+	991,
+	925,
+	991,
+	924,
+	991,
+	925,
+	992,
+	926,
+	992,
+	925,
+	992,
+	926,
+	993,
+	927,
+	993,
+	926,
+	993,
+	927,
+	994,
+	928,
+	994,
+	927,
+	994,
+	928,
+	995,
+	929,
+	995,
+	928,
+	995,
+	929,
+	996,
+	930,
+	996,
+	929,
+	996,
+	930,
+	997,
+	931,
+	997,
+	930,
+	997,
+	931,
+	998,
+	932,
+	998,
+	931,
+	998,
+	932,
+	999,
+	933,
+	999,
+	932,
+	999,
+	933,
+	1000,
+	934,
+	1000,
+	933,
+	1000,
+	934,
+	1001,
+	935,
+	1001,
+	934,
+	1001,
+	935,
+	1002,
+	936,
+	1002,
+	935,
+	1002,
+	936,
+	1003,
+	937,
+	1003,
+	936,
+	1003,
+	937,
+	1004,
+	938,
+	1004,
+	937,
+	1004,
+	938,
+	1005,
+	939,
+	1005,
+	938,
+	1005,
+	939,
+	1006,
+	940,
+	1006,
+	939,
+	1006,
+	940,
+	1007,
+	941,
+	1007,
+	940,
+	1007,
+	941,
+	1008,
+	942,
+	1008,
+	941,
+	1008,
+	942,
+	1009,
+	943,
+	1009,
+	942,
+	1009,
+	943,
+	1010,
+	944,
+	1010,
+	943,
+	1010,
+	944,
+	1011,
+	945,
+	1011,
+	944,
+	1011,
+	945,
+	1012,
+	946,
+	1012,
+	945,
+	1012,
+	946,
+	1013,
+	947,
+	1013,
+	946,
+	1013,
+	947,
+	1014,
+	948,
+	1014,
+	947,
+	1014,
+	948,
+	1015,
+	949,
+	1015,
+	948,
+	1015,
+	949,
+	1016,
+	950,
+	1016,
+	949,
+	1016,
+	950,
+	1017,
+	951,
+	1017,
+	950,
+	1017,
+	951,
+	1018,
+	952,
+	1018,
+	951,
+	1018,
+	952,
+	1019,
+	953,
+	1019,
+	952,
+	1019,
+	953,
+	1020,
+	954,
+	1020,
+	953,
+	1020,
+	954,
+	1021,
+	955,
+	1021,
+	954,
+	1021,
+	955,
+	1022,
+	956,
+	1022,
+	955,
+	1022,
+	956,
+	1023,
+	957,
+	1023,
+	956,
+	1023,
+	957,
+	1024,
+	958,
+	1024,
+	957,
+	1024,
+	958,
+	1025,
+	959,
+	1025,
+	958,
+	1025,
+	959,
+	1026,
+	960,
+	1026,
+	959,
+	1026,
+	960,
+	1027,
+	961,
+	1027,
+	960,
+	1027,
+	961,
+	1028,
+	962,
+	1028,
+	961,
+	1028,
+	962,
+	1029,
+	963,
+	1029,
+	962,
+	1029,
+	963,
+	1030,
+	964,
+	1030,
+	963,
+	1030,
+	964,
+	1031,
+	965,
+	1031,
+	964,
+	1031,
+	965,
+	1032,
+	966,
+	1032,
+	965,
+	1032,
+	966,
+	1033,
+	967,
+	1033,
+	966,
+	1033,
+	967,
+	1034,
+	968,
+	1034,
+	967,
+	1034,
+	968,
+	1035,
+	969,
+	1035,
+	968,
+	1035,
+	969,
+	1036,
+	970,
+	1036,
+	969,
+	1036,
+	970,
+	1037,
+	971,
+	1037,
+	970,
+	1037,
+	971,
+	1038,
+	972,
+	1038,
+	971,
+	1038,
+	972,
+	1039,
+	973,
+	1039,
+	972,
+	1039,
+	973,
+	1040,
+	974,
+	1040,
+	973,
+	1040,
+	974,
+	1041,
+	975,
+	1041,
+	974,
+	1041,
+	975,
+	1042,
+	976,
+	1042,
+	975,
+	1042,
+	976,
+	1043,
+	977,
+	1043,
+	976,
+	1043,
+	977,
+	1044,
+	978,
+	1044,
+	977,
+	1044,
+	978,
+	1045,
+	979,
+	1045,
+	978,
+	1045,
+	979,
+	1046,
+	980,
+	1046,
+	979,
+	1046,
+	980,
+	1047,
+	981,
+	1047,
+	980,
+	1047,
+	981,
+	1048,
+	982,
+	1048,
+	981,
+	1048,
+	982,
+	1049,
+	983,
+	1049,
+	982,
+	1049,
+	983,
+	1050,
+	984,
+	1050,
+	983,
+	1050,
+	984,
+	1051,
+	985,
+	1051,
+	984,
+	1051,
+	985,
+	1052,
+	986,
+	1052,
+	985,
+	1052,
+	986,
+	1053,
+	987,
+	1053,
+	986,
+	1053,
+	987,
+	1054,
+	988,
+	1054,
+	987,
+	1054,
+	988,
+	1055,
+	989,
+	1055,
+	988,
+	1056,
+	990,
+	1057,
+	991,
+	1057,
+	990,
+	1057,
+	991,
+	1058,
+	992,
+	1058,
+	991,
+	1058,
+	992,
+	1059,
+	993,
+	1059,
+	992,
+	1059,
+	993,
+	1060,
+	994,
+	1060,
+	993,
+	1060,
+	994,
+	1061,
+	995,
+	1061,
+	994,
+	1061,
+	995,
+	1062,
+	996,
+	1062,
+	995,
+	1062,
+	996,
+	1063,
+	997,
+	1063,
+	996,
+	1063,
+	997,
+	1064,
+	998,
+	1064,
+	997,
+	1064,
+	998,
+	1065,
+	999,
+	1065,
+	998,
+	1065,
+	999,
+	1066,
+	1000,
+	1066,
+	999,
+	1066,
+	1000,
+	1067,
+	1001,
+	1067,
+	1000,
+	1067,
+	1001,
+	1068,
+	1002,
+	1068,
+	1001,
+	1068,
+	1002,
+	1069,
+	1003,
+	1069,
+	1002,
+	1069,
+	1003,
+	1070,
+	1004,
+	1070,
+	1003,
+	1070,
+	1004,
+	1071,
+	1005,
+	1071,
+	1004,
+	1071,
+	1005,
+	1072,
+	1006,
+	1072,
+	1005,
+	1072,
+	1006,
+	1073,
+	1007,
+	1073,
+	1006,
+	1073,
+	1007,
+	1074,
+	1008,
+	1074,
+	1007,
+	1074,
+	1008,
+	1075,
+	1009,
+	1075,
+	1008,
+	1075,
+	1009,
+	1076,
+	1010,
+	1076,
+	1009,
+	1076,
+	1010,
+	1077,
+	1011,
+	1077,
+	1010,
+	1077,
+	1011,
+	1078,
+	1012,
+	1078,
+	1011,
+	1078,
+	1012,
+	1079,
+	1013,
+	1079,
+	1012,
+	1079,
+	1013,
+	1080,
+	1014,
+	1080,
+	1013,
+	1080,
+	1014,
+	1081,
+	1015,
+	1081,
+	1014,
+	1081,
+	1015,
+	1082,
+	1016,
+	1082,
+	1015,
+	1082,
+	1016,
+	1083,
+	1017,
+	1083,
+	1016,
+	1083,
+	1017,
+	1084,
+	1018,
+	1084,
+	1017,
+	1084,
+	1018,
+	1085,
+	1019,
+	1085,
+	1018,
+	1085,
+	1019,
+	1086,
+	1020,
+	1086,
+	1019,
+	1086,
+	1020,
+	1087,
+	1021,
+	1087,
+	1020,
+	1087,
+	1021,
+	1088,
+	1022,
+	1088,
+	1021,
+	1088,
+	1022,
+	1089,
+	1023,
+	1089,
+	1022,
+	1089,
+	1023,
+	1090,
+	1024,
+	1090,
+	1023,
+	1090,
+	1024,
+	1091,
+	1025,
+	1091,
+	1024,
+	1091,
+	1025,
+	1092,
+	1026,
+	1092,
+	1025,
+	1092,
+	1026,
+	1093,
+	1027,
+	1093,
+	1026,
+	1093,
+	1027,
+	1094,
+	1028,
+	1094,
+	1027,
+	1094,
+	1028,
+	1095,
+	1029,
+	1095,
+	1028,
+	1095,
+	1029,
+	1096,
+	1030,
+	1096,
+	1029,
+	1096,
+	1030,
+	1097,
+	1031,
+	1097,
+	1030,
+	1097,
+	1031,
+	1098,
+	1032,
+	1098,
+	1031,
+	1098,
+	1032,
+	1099,
+	1033,
+	1099,
+	1032,
+	1099,
+	1033,
+	1100,
+	1034,
+	1100,
+	1033,
+	1100,
+	1034,
+	1101,
+	1035,
+	1101,
+	1034,
+	1101,
+	1035,
+	1102,
+	1036,
+	1102,
+	1035,
+	1102,
+	1036,
+	1103,
+	1037,
+	1103,
+	1036,
+	1103,
+	1037,
+	1104,
+	1038,
+	1104,
+	1037,
+	1104,
+	1038,
+	1105,
+	1039,
+	1105,
+	1038,
+	1105,
+	1039,
+	1106,
+	1040,
+	1106,
+	1039,
+	1106,
+	1040,
+	1107,
+	1041,
+	1107,
+	1040,
+	1107,
+	1041,
+	1108,
+	1042,
+	1108,
+	1041,
+	1108,
+	1042,
+	1109,
+	1043,
+	1109,
+	1042,
+	1109,
+	1043,
+	1110,
+	1044,
+	1110,
+	1043,
+	1110,
+	1044,
+	1111,
+	1045,
+	1111,
+	1044,
+	1111,
+	1045,
+	1112,
+	1046,
+	1112,
+	1045,
+	1112,
+	1046,
+	1113,
+	1047,
+	1113,
+	1046,
+	1113,
+	1047,
+	1114,
+	1048,
+	1114,
+	1047,
+	1114,
+	1048,
+	1115,
+	1049,
+	1115,
+	1048,
+	1115,
+	1049,
+	1116,
+	1050,
+	1116,
+	1049,
+	1116,
+	1050,
+	1117,
+	1051,
+	1117,
+	1050,
+	1117,
+	1051,
+	1118,
+	1052,
+	1118,
+	1051,
+	1118,
+	1052,
+	1119,
+	1053,
+	1119,
+	1052,
+	1119,
+	1053,
+	1120,
+	1054,
+	1120,
+	1053,
+	1120,
+	1054,
+	1121,
+	1055,
+	1121,
+	1054,
+	1122,
+	1056,
+	1123,
+	1057,
+	1123,
+	1056,
+	1123,
+	1057,
+	1124,
+	1058,
+	1124,
+	1057,
+	1124,
+	1058,
+	1125,
+	1059,
+	1125,
+	1058,
+	1125,
+	1059,
+	1126,
+	1060,
+	1126,
+	1059,
+	1126,
+	1060,
+	1127,
+	1061,
+	1127,
+	1060,
+	1127,
+	1061,
+	1128,
+	1062,
+	1128,
+	1061,
+	1128,
+	1062,
+	1129,
+	1063,
+	1129,
+	1062,
+	1129,
+	1063,
+	1130,
+	1064,
+	1130,
+	1063,
+	1130,
+	1064,
+	1131,
+	1065,
+	1131,
+	1064,
+	1131,
+	1065,
+	1132,
+	1066,
+	1132,
+	1065,
+	1132,
+	1066,
+	1133,
+	1067,
+	1133,
+	1066,
+	1133,
+	1067,
+	1134,
+	1068,
+	1134,
+	1067,
+	1134,
+	1068,
+	1135,
+	1069,
+	1135,
+	1068,
+	1135,
+	1069,
+	1136,
+	1070,
+	1136,
+	1069,
+	1136,
+	1070,
+	1137,
+	1071,
+	1137,
+	1070,
+	1137,
+	1071,
+	1138,
+	1072,
+	1138,
+	1071,
+	1138,
+	1072,
+	1139,
+	1073,
+	1139,
+	1072,
+	1139,
+	1073,
+	1140,
+	1074,
+	1140,
+	1073,
+	1140,
+	1074,
+	1141,
+	1075,
+	1141,
+	1074,
+	1141,
+	1075,
+	1142,
+	1076,
+	1142,
+	1075,
+	1142,
+	1076,
+	1143,
+	1077,
+	1143,
+	1076,
+	1143,
+	1077,
+	1144,
+	1078,
+	1144,
+	1077,
+	1144,
+	1078,
+	1145,
+	1079,
+	1145,
+	1078,
+	1145,
+	1079,
+	1146,
+	1080,
+	1146,
+	1079,
+	1146,
+	1080,
+	1147,
+	1081,
+	1147,
+	1080,
+	1147,
+	1081,
+	1148,
+	1082,
+	1148,
+	1081,
+	1148,
+	1082,
+	1149,
+	1083,
+	1149,
+	1082,
+	1149,
+	1083,
+	1150,
+	1084,
+	1150,
+	1083,
+	1150,
+	1084,
+	1151,
+	1085,
+	1151,
+	1084,
+	1151,
+	1085,
+	1152,
+	1086,
+	1152,
+	1085,
+	1152,
+	1086,
+	1153,
+	1087,
+	1153,
+	1086,
+	1153,
+	1087,
+	1154,
+	1088,
+	1154,
+	1087,
+	1154,
+	1088,
+	1155,
+	1089,
+	1155,
+	1088,
+	1155,
+	1089,
+	1156,
+	1090,
+	1156,
+	1089,
+	1156,
+	1090,
+	1157,
+	1091,
+	1157,
+	1090,
+	1157,
+	1091,
+	1158,
+	1092,
+	1158,
+	1091,
+	1158,
+	1092,
+	1159,
+	1093,
+	1159,
+	1092,
+	1159,
+	1093,
+	1160,
+	1094,
+	1160,
+	1093,
+	1160,
+	1094,
+	1161,
+	1095,
+	1161,
+	1094,
+	1161,
+	1095,
+	1162,
+	1096,
+	1162,
+	1095,
+	1162,
+	1096,
+	1163,
+	1097,
+	1163,
+	1096,
+	1163,
+	1097,
+	1164,
+	1098,
+	1164,
+	1097,
+	1164,
+	1098,
+	1165,
+	1099,
+	1165,
+	1098,
+	1165,
+	1099,
+	1166,
+	1100,
+	1166,
+	1099,
+	1166,
+	1100,
+	1167,
+	1101,
+	1167,
+	1100,
+	1167,
+	1101,
+	1168,
+	1102,
+	1168,
+	1101,
+	1168,
+	1102,
+	1169,
+	1103,
+	1169,
+	1102,
+	1169,
+	1103,
+	1170,
+	1104,
+	1170,
+	1103,
+	1170,
+	1104,
+	1171,
+	1105,
+	1171,
+	1104,
+	1171,
+	1105,
+	1172,
+	1106,
+	1172,
+	1105,
+	1172,
+	1106,
+	1173,
+	1107,
+	1173,
+	1106,
+	1173,
+	1107,
+	1174,
+	1108,
+	1174,
+	1107,
+	1174,
+	1108,
+	1175,
+	1109,
+	1175,
+	1108,
+	1175,
+	1109,
+	1176,
+	1110,
+	1176,
+	1109,
+	1176,
+	1110,
+	1177,
+	1111,
+	1177,
+	1110,
+	1177,
+	1111,
+	1178,
+	1112,
+	1178,
+	1111,
+	1178,
+	1112,
+	1179,
+	1113,
+	1179,
+	1112,
+	1179,
+	1113,
+	1180,
+	1114,
+	1180,
+	1113,
+	1180,
+	1114,
+	1181,
+	1115,
+	1181,
+	1114,
+	1181,
+	1115,
+	1182,
+	1116,
+	1182,
+	1115,
+	1182,
+	1116,
+	1183,
+	1117,
+	1183,
+	1116,
+	1183,
+	1117,
+	1184,
+	1118,
+	1184,
+	1117,
+	1184,
+	1118,
+	1185,
+	1119,
+	1185,
+	1118,
+	1185,
+	1119,
+	1186,
+	1120,
+	1186,
+	1119,
+	1186,
+	1120,
+	1187,
+	1121,
+	1187,
+	1120,
+	1188,
+	1122,
+	1189,
+	1123,
+	1189,
+	1122,
+	1189,
+	1123,
+	1190,
+	1124,
+	1190,
+	1123,
+	1190,
+	1124,
+	1191,
+	1125,
+	1191,
+	1124,
+	1191,
+	1125,
+	1192,
+	1126,
+	1192,
+	1125,
+	1192,
+	1126,
+	1193,
+	1127,
+	1193,
+	1126,
+	1193,
+	1127,
+	1194,
+	1128,
+	1194,
+	1127,
+	1194,
+	1128,
+	1195,
+	1129,
+	1195,
+	1128,
+	1195,
+	1129,
+	1196,
+	1130,
+	1196,
+	1129,
+	1196,
+	1130,
+	1197,
+	1131,
+	1197,
+	1130,
+	1197,
+	1131,
+	1198,
+	1132,
+	1198,
+	1131,
+	1198,
+	1132,
+	1199,
+	1133,
+	1199,
+	1132,
+	1199,
+	1133,
+	1200,
+	1134,
+	1200,
+	1133,
+	1200,
+	1134,
+	1201,
+	1135,
+	1201,
+	1134,
+	1201,
+	1135,
+	1202,
+	1136,
+	1202,
+	1135,
+	1202,
+	1136,
+	1203,
+	1137,
+	1203,
+	1136,
+	1203,
+	1137,
+	1204,
+	1138,
+	1204,
+	1137,
+	1204,
+	1138,
+	1205,
+	1139,
+	1205,
+	1138,
+	1205,
+	1139,
+	1206,
+	1140,
+	1206,
+	1139,
+	1206,
+	1140,
+	1207,
+	1141,
+	1207,
+	1140,
+	1207,
+	1141,
+	1208,
+	1142,
+	1208,
+	1141,
+	1208,
+	1142,
+	1209,
+	1143,
+	1209,
+	1142,
+	1209,
+	1143,
+	1210,
+	1144,
+	1210,
+	1143,
+	1210,
+	1144,
+	1211,
+	1145,
+	1211,
+	1144,
+	1211,
+	1145,
+	1212,
+	1146,
+	1212,
+	1145,
+	1212,
+	1146,
+	1213,
+	1147,
+	1213,
+	1146,
+	1213,
+	1147,
+	1214,
+	1148,
+	1214,
+	1147,
+	1214,
+	1148,
+	1215,
+	1149,
+	1215,
+	1148,
+	1215,
+	1149,
+	1216,
+	1150,
+	1216,
+	1149,
+	1216,
+	1150,
+	1217,
+	1151,
+	1217,
+	1150,
+	1217,
+	1151,
+	1218,
+	1152,
+	1218,
+	1151,
+	1218,
+	1152,
+	1219,
+	1153,
+	1219,
+	1152,
+	1219,
+	1153,
+	1220,
+	1154,
+	1220,
+	1153,
+	1220,
+	1154,
+	1221,
+	1155,
+	1221,
+	1154,
+	1221,
+	1155,
+	1222,
+	1156,
+	1222,
+	1155,
+	1222,
+	1156,
+	1223,
+	1157,
+	1223,
+	1156,
+	1223,
+	1157,
+	1224,
+	1158,
+	1224,
+	1157,
+	1224,
+	1158,
+	1225,
+	1159,
+	1225,
+	1158,
+	1225,
+	1159,
+	1226,
+	1160,
+	1226,
+	1159,
+	1226,
+	1160,
+	1227,
+	1161,
+	1227,
+	1160,
+	1227,
+	1161,
+	1228,
+	1162,
+	1228,
+	1161,
+	1228,
+	1162,
+	1229,
+	1163,
+	1229,
+	1162,
+	1229,
+	1163,
+	1230,
+	1164,
+	1230,
+	1163,
+	1230,
+	1164,
+	1231,
+	1165,
+	1231,
+	1164,
+	1231,
+	1165,
+	1232,
+	1166,
+	1232,
+	1165,
+	1232,
+	1166,
+	1233,
+	1167,
+	1233,
+	1166,
+	1233,
+	1167,
+	1234,
+	1168,
+	1234,
+	1167,
+	1234,
+	1168,
+	1235,
+	1169,
+	1235,
+	1168,
+	1235,
+	1169,
+	1236,
+	1170,
+	1236,
+	1169,
+	1236,
+	1170,
+	1237,
+	1171,
+	1237,
+	1170,
+	1237,
+	1171,
+	1238,
+	1172,
+	1238,
+	1171,
+	1238,
+	1172,
+	1239,
+	1173,
+	1239,
+	1172,
+	1239,
+	1173,
+	1240,
+	1174,
+	1240,
+	1173,
+	1240,
+	1174,
+	1241,
+	1175,
+	1241,
+	1174,
+	1241,
+	1175,
+	1242,
+	1176,
+	1242,
+	1175,
+	1242,
+	1176,
+	1243,
+	1177,
+	1243,
+	1176,
+	1243,
+	1177,
+	1244,
+	1178,
+	1244,
+	1177,
+	1244,
+	1178,
+	1245,
+	1179,
+	1245,
+	1178,
+	1245,
+	1179,
+	1246,
+	1180,
+	1246,
+	1179,
+	1246,
+	1180,
+	1247,
+	1181,
+	1247,
+	1180,
+	1247,
+	1181,
+	1248,
+	1182,
+	1248,
+	1181,
+	1248,
+	1182,
+	1249,
+	1183,
+	1249,
+	1182,
+	1249,
+	1183,
+	1250,
+	1184,
+	1250,
+	1183,
+	1250,
+	1184,
+	1251,
+	1185,
+	1251,
+	1184,
+	1251,
+	1185,
+	1252,
+	1186,
+	1252,
+	1185,
+	1252,
+	1186,
+	1253,
+	1187,
+	1253,
+	1186,
+	1254,
+	1188,
+	1255,
+	1189,
+	1255,
+	1188,
+	1255,
+	1189,
+	1256,
+	1190,
+	1256,
+	1189,
+	1256,
+	1190,
+	1257,
+	1191,
+	1257,
+	1190,
+	1257,
+	1191,
+	1258,
+	1192,
+	1258,
+	1191,
+	1258,
+	1192,
+	1259,
+	1193,
+	1259,
+	1192,
+	1259,
+	1193,
+	1260,
+	1194,
+	1260,
+	1193,
+	1260,
+	1194,
+	1261,
+	1195,
+	1261,
+	1194,
+	1261,
+	1195,
+	1262,
+	1196,
+	1262,
+	1195,
+	1262,
+	1196,
+	1263,
+	1197,
+	1263,
+	1196,
+	1263,
+	1197,
+	1264,
+	1198,
+	1264,
+	1197,
+	1264,
+	1198,
+	1265,
+	1199,
+	1265,
+	1198,
+	1265,
+	1199,
+	1266,
+	1200,
+	1266,
+	1199,
+	1266,
+	1200,
+	1267,
+	1201,
+	1267,
+	1200,
+	1267,
+	1201,
+	1268,
+	1202,
+	1268,
+	1201,
+	1268,
+	1202,
+	1269,
+	1203,
+	1269,
+	1202,
+	1269,
+	1203,
+	1270,
+	1204,
+	1270,
+	1203,
+	1270,
+	1204,
+	1271,
+	1205,
+	1271,
+	1204,
+	1271,
+	1205,
+	1272,
+	1206,
+	1272,
+	1205,
+	1272,
+	1206,
+	1273,
+	1207,
+	1273,
+	1206,
+	1273,
+	1207,
+	1274,
+	1208,
+	1274,
+	1207,
+	1274,
+	1208,
+	1275,
+	1209,
+	1275,
+	1208,
+	1275,
+	1209,
+	1276,
+	1210,
+	1276,
+	1209,
+	1276,
+	1210,
+	1277,
+	1211,
+	1277,
+	1210,
+	1277,
+	1211,
+	1278,
+	1212,
+	1278,
+	1211,
+	1278,
+	1212,
+	1279,
+	1213,
+	1279,
+	1212,
+	1279,
+	1213,
+	1280,
+	1214,
+	1280,
+	1213,
+	1280,
+	1214,
+	1281,
+	1215,
+	1281,
+	1214,
+	1281,
+	1215,
+	1282,
+	1216,
+	1282,
+	1215,
+	1282,
+	1216,
+	1283,
+	1217,
+	1283,
+	1216,
+	1283,
+	1217,
+	1284,
+	1218,
+	1284,
+	1217,
+	1284,
+	1218,
+	1285,
+	1219,
+	1285,
+	1218,
+	1285,
+	1219,
+	1286,
+	1220,
+	1286,
+	1219,
+	1286,
+	1220,
+	1287,
+	1221,
+	1287,
+	1220,
+	1287,
+	1221,
+	1288,
+	1222,
+	1288,
+	1221,
+	1288,
+	1222,
+	1289,
+	1223,
+	1289,
+	1222,
+	1289,
+	1223,
+	1290,
+	1224,
+	1290,
+	1223,
+	1290,
+	1224,
+	1291,
+	1225,
+	1291,
+	1224,
+	1291,
+	1225,
+	1292,
+	1226,
+	1292,
+	1225,
+	1292,
+	1226,
+	1293,
+	1227,
+	1293,
+	1226,
+	1293,
+	1227,
+	1294,
+	1228,
+	1294,
+	1227,
+	1294,
+	1228,
+	1295,
+	1229,
+	1295,
+	1228,
+	1295,
+	1229,
+	1296,
+	1230,
+	1296,
+	1229,
+	1296,
+	1230,
+	1297,
+	1231,
+	1297,
+	1230,
+	1297,
+	1231,
+	1298,
+	1232,
+	1298,
+	1231,
+	1298,
+	1232,
+	1299,
+	1233,
+	1299,
+	1232,
+	1299,
+	1233,
+	1300,
+	1234,
+	1300,
+	1233,
+	1300,
+	1234,
+	1301,
+	1235,
+	1301,
+	1234,
+	1301,
+	1235,
+	1302,
+	1236,
+	1302,
+	1235,
+	1302,
+	1236,
+	1303,
+	1237,
+	1303,
+	1236,
+	1303,
+	1237,
+	1304,
+	1238,
+	1304,
+	1237,
+	1304,
+	1238,
+	1305,
+	1239,
+	1305,
+	1238,
+	1305,
+	1239,
+	1306,
+	1240,
+	1306,
+	1239,
+	1306,
+	1240,
+	1307,
+	1241,
+	1307,
+	1240,
+	1307,
+	1241,
+	1308,
+	1242,
+	1308,
+	1241,
+	1308,
+	1242,
+	1309,
+	1243,
+	1309,
+	1242,
+	1309,
+	1243,
+	1310,
+	1244,
+	1310,
+	1243,
+	1310,
+	1244,
+	1311,
+	1245,
+	1311,
+	1244,
+	1311,
+	1245,
+	1312,
+	1246,
+	1312,
+	1245,
+	1312,
+	1246,
+	1313,
+	1247,
+	1313,
+	1246,
+	1313,
+	1247,
+	1314,
+	1248,
+	1314,
+	1247,
+	1314,
+	1248,
+	1315,
+	1249,
+	1315,
+	1248,
+	1315,
+	1249,
+	1316,
+	1250,
+	1316,
+	1249,
+	1316,
+	1250,
+	1317,
+	1251,
+	1317,
+	1250,
+	1317,
+	1251,
+	1318,
+	1252,
+	1318,
+	1251,
+	1318,
+	1252,
+	1319,
+	1253,
+	1319,
+	1252,
+	1320,
+	1254,
+	1321,
+	1255,
+	1321,
+	1254,
+	1321,
+	1255,
+	1322,
+	1256,
+	1322,
+	1255,
+	1322,
+	1256,
+	1323,
+	1257,
+	1323,
+	1256,
+	1323,
+	1257,
+	1324,
+	1258,
+	1324,
+	1257,
+	1324,
+	1258,
+	1325,
+	1259,
+	1325,
+	1258,
+	1325,
+	1259,
+	1326,
+	1260,
+	1326,
+	1259,
+	1326,
+	1260,
+	1327,
+	1261,
+	1327,
+	1260,
+	1327,
+	1261,
+	1328,
+	1262,
+	1328,
+	1261,
+	1328,
+	1262,
+	1329,
+	1263,
+	1329,
+	1262,
+	1329,
+	1263,
+	1330,
+	1264,
+	1330,
+	1263,
+	1330,
+	1264,
+	1331,
+	1265,
+	1331,
+	1264,
+	1331,
+	1265,
+	1332,
+	1266,
+	1332,
+	1265,
+	1332,
+	1266,
+	1333,
+	1267,
+	1333,
+	1266,
+	1333,
+	1267,
+	1334,
+	1268,
+	1334,
+	1267,
+	1334,
+	1268,
+	1335,
+	1269,
+	1335,
+	1268,
+	1335,
+	1269,
+	1336,
+	1270,
+	1336,
+	1269,
+	1336,
+	1270,
+	1337,
+	1271,
+	1337,
+	1270,
+	1337,
+	1271,
+	1338,
+	1272,
+	1338,
+	1271,
+	1338,
+	1272,
+	1339,
+	1273,
+	1339,
+	1272,
+	1339,
+	1273,
+	1340,
+	1274,
+	1340,
+	1273,
+	1340,
+	1274,
+	1341,
+	1275,
+	1341,
+	1274,
+	1341,
+	1275,
+	1342,
+	1276,
+	1342,
+	1275,
+	1342,
+	1276,
+	1343,
+	1277,
+	1343,
+	1276,
+	1343,
+	1277,
+	1344,
+	1278,
+	1344,
+	1277,
+	1344,
+	1278,
+	1345,
+	1279,
+	1345,
+	1278,
+	1345,
+	1279,
+	1346,
+	1280,
+	1346,
+	1279,
+	1346,
+	1280,
+	1347,
+	1281,
+	1347,
+	1280,
+	1347,
+	1281,
+	1348,
+	1282,
+	1348,
+	1281,
+	1348,
+	1282,
+	1349,
+	1283,
+	1349,
+	1282,
+	1349,
+	1283,
+	1350,
+	1284,
+	1350,
+	1283,
+	1350,
+	1284,
+	1351,
+	1285,
+	1351,
+	1284,
+	1351,
+	1285,
+	1352,
+	1286,
+	1352,
+	1285,
+	1352,
+	1286,
+	1353,
+	1287,
+	1353,
+	1286,
+	1353,
+	1287,
+	1354,
+	1288,
+	1354,
+	1287,
+	1354,
+	1288,
+	1355,
+	1289,
+	1355,
+	1288,
+	1355,
+	1289,
+	1356,
+	1290,
+	1356,
+	1289,
+	1356,
+	1290,
+	1357,
+	1291,
+	1357,
+	1290,
+	1357,
+	1291,
+	1358,
+	1292,
+	1358,
+	1291,
+	1358,
+	1292,
+	1359,
+	1293,
+	1359,
+	1292,
+	1359,
+	1293,
+	1360,
+	1294,
+	1360,
+	1293,
+	1360,
+	1294,
+	1361,
+	1295,
+	1361,
+	1294,
+	1361,
+	1295,
+	1362,
+	1296,
+	1362,
+	1295,
+	1362,
+	1296,
+	1363,
+	1297,
+	1363,
+	1296,
+	1363,
+	1297,
+	1364,
+	1298,
+	1364,
+	1297,
+	1364,
+	1298,
+	1365,
+	1299,
+	1365,
+	1298,
+	1365,
+	1299,
+	1366,
+	1300,
+	1366,
+	1299,
+	1366,
+	1300,
+	1367,
+	1301,
+	1367,
+	1300,
+	1367,
+	1301,
+	1368,
+	1302,
+	1368,
+	1301,
+	1368,
+	1302,
+	1369,
+	1303,
+	1369,
+	1302,
+	1369,
+	1303,
+	1370,
+	1304,
+	1370,
+	1303,
+	1370,
+	1304,
+	1371,
+	1305,
+	1371,
+	1304,
+	1371,
+	1305,
+	1372,
+	1306,
+	1372,
+	1305,
+	1372,
+	1306,
+	1373,
+	1307,
+	1373,
+	1306,
+	1373,
+	1307,
+	1374,
+	1308,
+	1374,
+	1307,
+	1374,
+	1308,
+	1375,
+	1309,
+	1375,
+	1308,
+	1375,
+	1309,
+	1376,
+	1310,
+	1376,
+	1309,
+	1376,
+	1310,
+	1377,
+	1311,
+	1377,
+	1310,
+	1377,
+	1311,
+	1378,
+	1312,
+	1378,
+	1311,
+	1378,
+	1312,
+	1379,
+	1313,
+	1379,
+	1312,
+	1379,
+	1313,
+	1380,
+	1314,
+	1380,
+	1313,
+	1380,
+	1314,
+	1381,
+	1315,
+	1381,
+	1314,
+	1381,
+	1315,
+	1382,
+	1316,
+	1382,
+	1315,
+	1382,
+	1316,
+	1383,
+	1317,
+	1383,
+	1316,
+	1383,
+	1317,
+	1384,
+	1318,
+	1384,
+	1317,
+	1384,
+	1318,
+	1385,
+	1319,
+	1385,
+	1318,
+	1386,
+	1320,
+	1387,
+	1321,
+	1387,
+	1320,
+	1387,
+	1321,
+	1388,
+	1322,
+	1388,
+	1321,
+	1388,
+	1322,
+	1389,
+	1323,
+	1389,
+	1322,
+	1389,
+	1323,
+	1390,
+	1324,
+	1390,
+	1323,
+	1390,
+	1324,
+	1391,
+	1325,
+	1391,
+	1324,
+	1391,
+	1325,
+	1392,
+	1326,
+	1392,
+	1325,
+	1392,
+	1326,
+	1393,
+	1327,
+	1393,
+	1326,
+	1393,
+	1327,
+	1394,
+	1328,
+	1394,
+	1327,
+	1394,
+	1328,
+	1395,
+	1329,
+	1395,
+	1328,
+	1395,
+	1329,
+	1396,
+	1330,
+	1396,
+	1329,
+	1396,
+	1330,
+	1397,
+	1331,
+	1397,
+	1330,
+	1397,
+	1331,
+	1398,
+	1332,
+	1398,
+	1331,
+	1398,
+	1332,
+	1399,
+	1333,
+	1399,
+	1332,
+	1399,
+	1333,
+	1400,
+	1334,
+	1400,
+	1333,
+	1400,
+	1334,
+	1401,
+	1335,
+	1401,
+	1334,
+	1401,
+	1335,
+	1402,
+	1336,
+	1402,
+	1335,
+	1402,
+	1336,
+	1403,
+	1337,
+	1403,
+	1336,
+	1403,
+	1337,
+	1404,
+	1338,
+	1404,
+	1337,
+	1404,
+	1338,
+	1405,
+	1339,
+	1405,
+	1338,
+	1405,
+	1339,
+	1406,
+	1340,
+	1406,
+	1339,
+	1406,
+	1340,
+	1407,
+	1341,
+	1407,
+	1340,
+	1407,
+	1341,
+	1408,
+	1342,
+	1408,
+	1341,
+	1408,
+	1342,
+	1409,
+	1343,
+	1409,
+	1342,
+	1409,
+	1343,
+	1410,
+	1344,
+	1410,
+	1343,
+	1410,
+	1344,
+	1411,
+	1345,
+	1411,
+	1344,
+	1411,
+	1345,
+	1412,
+	1346,
+	1412,
+	1345,
+	1412,
+	1346,
+	1413,
+	1347,
+	1413,
+	1346,
+	1413,
+	1347,
+	1414,
+	1348,
+	1414,
+	1347,
+	1414,
+	1348,
+	1415,
+	1349,
+	1415,
+	1348,
+	1415,
+	1349,
+	1416,
+	1350,
+	1416,
+	1349,
+	1416,
+	1350,
+	1417,
+	1351,
+	1417,
+	1350,
+	1417,
+	1351,
+	1418,
+	1352,
+	1418,
+	1351,
+	1418,
+	1352,
+	1419,
+	1353,
+	1419,
+	1352,
+	1419,
+	1353,
+	1420,
+	1354,
+	1420,
+	1353,
+	1420,
+	1354,
+	1421,
+	1355,
+	1421,
+	1354,
+	1421,
+	1355,
+	1422,
+	1356,
+	1422,
+	1355,
+	1422,
+	1356,
+	1423,
+	1357,
+	1423,
+	1356,
+	1423,
+	1357,
+	1424,
+	1358,
+	1424,
+	1357,
+	1424,
+	1358,
+	1425,
+	1359,
+	1425,
+	1358,
+	1425,
+	1359,
+	1426,
+	1360,
+	1426,
+	1359,
+	1426,
+	1360,
+	1427,
+	1361,
+	1427,
+	1360,
+	1427,
+	1361,
+	1428,
+	1362,
+	1428,
+	1361,
+	1428,
+	1362,
+	1429,
+	1363,
+	1429,
+	1362,
+	1429,
+	1363,
+	1430,
+	1364,
+	1430,
+	1363,
+	1430,
+	1364,
+	1431,
+	1365,
+	1431,
+	1364,
+	1431,
+	1365,
+	1432,
+	1366,
+	1432,
+	1365,
+	1432,
+	1366,
+	1433,
+	1367,
+	1433,
+	1366,
+	1433,
+	1367,
+	1434,
+	1368,
+	1434,
+	1367,
+	1434,
+	1368,
+	1435,
+	1369,
+	1435,
+	1368,
+	1435,
+	1369,
+	1436,
+	1370,
+	1436,
+	1369,
+	1436,
+	1370,
+	1437,
+	1371,
+	1437,
+	1370,
+	1437,
+	1371,
+	1438,
+	1372,
+	1438,
+	1371,
+	1438,
+	1372,
+	1439,
+	1373,
+	1439,
+	1372,
+	1439,
+	1373,
+	1440,
+	1374,
+	1440,
+	1373,
+	1440,
+	1374,
+	1441,
+	1375,
+	1441,
+	1374,
+	1441,
+	1375,
+	1442,
+	1376,
+	1442,
+	1375,
+	1442,
+	1376,
+	1443,
+	1377,
+	1443,
+	1376,
+	1443,
+	1377,
+	1444,
+	1378,
+	1444,
+	1377,
+	1444,
+	1378,
+	1445,
+	1379,
+	1445,
+	1378,
+	1445,
+	1379,
+	1446,
+	1380,
+	1446,
+	1379,
+	1446,
+	1380,
+	1447,
+	1381,
+	1447,
+	1380,
+	1447,
+	1381,
+	1448,
+	1382,
+	1448,
+	1381,
+	1448,
+	1382,
+	1449,
+	1383,
+	1449,
+	1382,
+	1449,
+	1383,
+	1450,
+	1384,
+	1450,
+	1383,
+	1450,
+	1384,
+	1451,
+	1385,
+	1451,
+	1384,
+	1452,
+	1386,
+	1453,
+	1387,
+	1453,
+	1386,
+	1453,
+	1387,
+	1454,
+	1388,
+	1454,
+	1387,
+	1454,
+	1388,
+	1455,
+	1389,
+	1455,
+	1388,
+	1455,
+	1389,
+	1456,
+	1390,
+	1456,
+	1389,
+	1456,
+	1390,
+	1457,
+	1391,
+	1457,
+	1390,
+	1457,
+	1391,
+	1458,
+	1392,
+	1458,
+	1391,
+	1458,
+	1392,
+	1459,
+	1393,
+	1459,
+	1392,
+	1459,
+	1393,
+	1460,
+	1394,
+	1460,
+	1393,
+	1460,
+	1394,
+	1461,
+	1395,
+	1461,
+	1394,
+	1461,
+	1395,
+	1462,
+	1396,
+	1462,
+	1395,
+	1462,
+	1396,
+	1463,
+	1397,
+	1463,
+	1396,
+	1463,
+	1397,
+	1464,
+	1398,
+	1464,
+	1397,
+	1464,
+	1398,
+	1465,
+	1399,
+	1465,
+	1398,
+	1465,
+	1399,
+	1466,
+	1400,
+	1466,
+	1399,
+	1466,
+	1400,
+	1467,
+	1401,
+	1467,
+	1400,
+	1467,
+	1401,
+	1468,
+	1402,
+	1468,
+	1401,
+	1468,
+	1402,
+	1469,
+	1403,
+	1469,
+	1402,
+	1469,
+	1403,
+	1470,
+	1404,
+	1470,
+	1403,
+	1470,
+	1404,
+	1471,
+	1405,
+	1471,
+	1404,
+	1471,
+	1405,
+	1472,
+	1406,
+	1472,
+	1405,
+	1472,
+	1406,
+	1473,
+	1407,
+	1473,
+	1406,
+	1473,
+	1407,
+	1474,
+	1408,
+	1474,
+	1407,
+	1474,
+	1408,
+	1475,
+	1409,
+	1475,
+	1408,
+	1475,
+	1409,
+	1476,
+	1410,
+	1476,
+	1409,
+	1476,
+	1410,
+	1477,
+	1411,
+	1477,
+	1410,
+	1477,
+	1411,
+	1478,
+	1412,
+	1478,
+	1411,
+	1478,
+	1412,
+	1479,
+	1413,
+	1479,
+	1412,
+	1479,
+	1413,
+	1480,
+	1414,
+	1480,
+	1413,
+	1480,
+	1414,
+	1481,
+	1415,
+	1481,
+	1414,
+	1481,
+	1415,
+	1482,
+	1416,
+	1482,
+	1415,
+	1482,
+	1416,
+	1483,
+	1417,
+	1483,
+	1416,
+	1483,
+	1417,
+	1484,
+	1418,
+	1484,
+	1417,
+	1484,
+	1418,
+	1485,
+	1419,
+	1485,
+	1418,
+	1485,
+	1419,
+	1486,
+	1420,
+	1486,
+	1419,
+	1486,
+	1420,
+	1487,
+	1421,
+	1487,
+	1420,
+	1487,
+	1421,
+	1488,
+	1422,
+	1488,
+	1421,
+	1488,
+	1422,
+	1489,
+	1423,
+	1489,
+	1422,
+	1489,
+	1423,
+	1490,
+	1424,
+	1490,
+	1423,
+	1490,
+	1424,
+	1491,
+	1425,
+	1491,
+	1424,
+	1491,
+	1425,
+	1492,
+	1426,
+	1492,
+	1425,
+	1492,
+	1426,
+	1493,
+	1427,
+	1493,
+	1426,
+	1493,
+	1427,
+	1494,
+	1428,
+	1494,
+	1427,
+	1494,
+	1428,
+	1495,
+	1429,
+	1495,
+	1428,
+	1495,
+	1429,
+	1496,
+	1430,
+	1496,
+	1429,
+	1496,
+	1430,
+	1497,
+	1431,
+	1497,
+	1430,
+	1497,
+	1431,
+	1498,
+	1432,
+	1498,
+	1431,
+	1498,
+	1432,
+	1499,
+	1433,
+	1499,
+	1432,
+	1499,
+	1433,
+	1500,
+	1434,
+	1500,
+	1433,
+	1500,
+	1434,
+	1501,
+	1435,
+	1501,
+	1434,
+	1501,
+	1435,
+	1502,
+	1436,
+	1502,
+	1435,
+	1502,
+	1436,
+	1503,
+	1437,
+	1503,
+	1436,
+	1503,
+	1437,
+	1504,
+	1438,
+	1504,
+	1437,
+	1504,
+	1438,
+	1505,
+	1439,
+	1505,
+	1438,
+	1505,
+	1439,
+	1506,
+	1440,
+	1506,
+	1439,
+	1506,
+	1440,
+	1507,
+	1441,
+	1507,
+	1440,
+	1507,
+	1441,
+	1508,
+	1442,
+	1508,
+	1441,
+	1508,
+	1442,
+	1509,
+	1443,
+	1509,
+	1442,
+	1509,
+	1443,
+	1510,
+	1444,
+	1510,
+	1443,
+	1510,
+	1444,
+	1511,
+	1445,
+	1511,
+	1444,
+	1511,
+	1445,
+	1512,
+	1446,
+	1512,
+	1445,
+	1512,
+	1446,
+	1513,
+	1447,
+	1513,
+	1446,
+	1513,
+	1447,
+	1514,
+	1448,
+	1514,
+	1447,
+	1514,
+	1448,
+	1515,
+	1449,
+	1515,
+	1448,
+	1515,
+	1449,
+	1516,
+	1450,
+	1516,
+	1449,
+	1516,
+	1450,
+	1517,
+	1451,
+	1517,
+	1450,
+	1518,
+	1452,
+	1519,
+	1453,
+	1519,
+	1452,
+	1519,
+	1453,
+	1520,
+	1454,
+	1520,
+	1453,
+	1520,
+	1454,
+	1521,
+	1455,
+	1521,
+	1454,
+	1521,
+	1455,
+	1522,
+	1456,
+	1522,
+	1455,
+	1522,
+	1456,
+	1523,
+	1457,
+	1523,
+	1456,
+	1523,
+	1457,
+	1524,
+	1458,
+	1524,
+	1457,
+	1524,
+	1458,
+	1525,
+	1459,
+	1525,
+	1458,
+	1525,
+	1459,
+	1526,
+	1460,
+	1526,
+	1459,
+	1526,
+	1460,
+	1527,
+	1461,
+	1527,
+	1460,
+	1527,
+	1461,
+	1528,
+	1462,
+	1528,
+	1461,
+	1528,
+	1462,
+	1529,
+	1463,
+	1529,
+	1462,
+	1529,
+	1463,
+	1530,
+	1464,
+	1530,
+	1463,
+	1530,
+	1464,
+	1531,
+	1465,
+	1531,
+	1464,
+	1531,
+	1465,
+	1532,
+	1466,
+	1532,
+	1465,
+	1532,
+	1466,
+	1533,
+	1467,
+	1533,
+	1466,
+	1533,
+	1467,
+	1534,
+	1468,
+	1534,
+	1467,
+	1534,
+	1468,
+	1535,
+	1469,
+	1535,
+	1468,
+	1535,
+	1469,
+	1536,
+	1470,
+	1536,
+	1469,
+	1536,
+	1470,
+	1537,
+	1471,
+	1537,
+	1470,
+	1537,
+	1471,
+	1538,
+	1472,
+	1538,
+	1471,
+	1538,
+	1472,
+	1539,
+	1473,
+	1539,
+	1472,
+	1539,
+	1473,
+	1540,
+	1474,
+	1540,
+	1473,
+	1540,
+	1474,
+	1541,
+	1475,
+	1541,
+	1474,
+	1541,
+	1475,
+	1542,
+	1476,
+	1542,
+	1475,
+	1542,
+	1476,
+	1543,
+	1477,
+	1543,
+	1476,
+	1543,
+	1477,
+	1544,
+	1478,
+	1544,
+	1477,
+	1544,
+	1478,
+	1545,
+	1479,
+	1545,
+	1478,
+	1545,
+	1479,
+	1546,
+	1480,
+	1546,
+	1479,
+	1546,
+	1480,
+	1547,
+	1481,
+	1547,
+	1480,
+	1547,
+	1481,
+	1548,
+	1482,
+	1548,
+	1481,
+	1548,
+	1482,
+	1549,
+	1483,
+	1549,
+	1482,
+	1549,
+	1483,
+	1550,
+	1484,
+	1550,
+	1483,
+	1550,
+	1484,
+	1551,
+	1485,
+	1551,
+	1484,
+	1551,
+	1485,
+	1552,
+	1486,
+	1552,
+	1485,
+	1552,
+	1486,
+	1553,
+	1487,
+	1553,
+	1486,
+	1553,
+	1487,
+	1554,
+	1488,
+	1554,
+	1487,
+	1554,
+	1488,
+	1555,
+	1489,
+	1555,
+	1488,
+	1555,
+	1489,
+	1556,
+	1490,
+	1556,
+	1489,
+	1556,
+	1490,
+	1557,
+	1491,
+	1557,
+	1490,
+	1557,
+	1491,
+	1558,
+	1492,
+	1558,
+	1491,
+	1558,
+	1492,
+	1559,
+	1493,
+	1559,
+	1492,
+	1559,
+	1493,
+	1560,
+	1494,
+	1560,
+	1493,
+	1560,
+	1494,
+	1561,
+	1495,
+	1561,
+	1494,
+	1561,
+	1495,
+	1562,
+	1496,
+	1562,
+	1495,
+	1562,
+	1496,
+	1563,
+	1497,
+	1563,
+	1496,
+	1563,
+	1497,
+	1564,
+	1498,
+	1564,
+	1497,
+	1564,
+	1498,
+	1565,
+	1499,
+	1565,
+	1498,
+	1565,
+	1499,
+	1566,
+	1500,
+	1566,
+	1499,
+	1566,
+	1500,
+	1567,
+	1501,
+	1567,
+	1500,
+	1567,
+	1501,
+	1568,
+	1502,
+	1568,
+	1501,
+	1568,
+	1502,
+	1569,
+	1503,
+	1569,
+	1502,
+	1569,
+	1503,
+	1570,
+	1504,
+	1570,
+	1503,
+	1570,
+	1504,
+	1571,
+	1505,
+	1571,
+	1504,
+	1571,
+	1505,
+	1572,
+	1506,
+	1572,
+	1505,
+	1572,
+	1506,
+	1573,
+	1507,
+	1573,
+	1506,
+	1573,
+	1507,
+	1574,
+	1508,
+	1574,
+	1507,
+	1574,
+	1508,
+	1575,
+	1509,
+	1575,
+	1508,
+	1575,
+	1509,
+	1576,
+	1510,
+	1576,
+	1509,
+	1576,
+	1510,
+	1577,
+	1511,
+	1577,
+	1510,
+	1577,
+	1511,
+	1578,
+	1512,
+	1578,
+	1511,
+	1578,
+	1512,
+	1579,
+	1513,
+	1579,
+	1512,
+	1579,
+	1513,
+	1580,
+	1514,
+	1580,
+	1513,
+	1580,
+	1514,
+	1581,
+	1515,
+	1581,
+	1514,
+	1581,
+	1515,
+	1582,
+	1516,
+	1582,
+	1515,
+	1582,
+	1516,
+	1583,
+	1517,
+	1583,
+	1516,
+	1584,
+	1518,
+	1585,
+	1519,
+	1585,
+	1518,
+	1585,
+	1519,
+	1586,
+	1520,
+	1586,
+	1519,
+	1586,
+	1520,
+	1587,
+	1521,
+	1587,
+	1520,
+	1587,
+	1521,
+	1588,
+	1522,
+	1588,
+	1521,
+	1588,
+	1522,
+	1589,
+	1523,
+	1589,
+	1522,
+	1589,
+	1523,
+	1590,
+	1524,
+	1590,
+	1523,
+	1590,
+	1524,
+	1591,
+	1525,
+	1591,
+	1524,
+	1591,
+	1525,
+	1592,
+	1526,
+	1592,
+	1525,
+	1592,
+	1526,
+	1593,
+	1527,
+	1593,
+	1526,
+	1593,
+	1527,
+	1594,
+	1528,
+	1594,
+	1527,
+	1594,
+	1528,
+	1595,
+	1529,
+	1595,
+	1528,
+	1595,
+	1529,
+	1596,
+	1530,
+	1596,
+	1529,
+	1596,
+	1530,
+	1597,
+	1531,
+	1597,
+	1530,
+	1597,
+	1531,
+	1598,
+	1532,
+	1598,
+	1531,
+	1598,
+	1532,
+	1599,
+	1533,
+	1599,
+	1532,
+	1599,
+	1533,
+	1600,
+	1534,
+	1600,
+	1533,
+	1600,
+	1534,
+	1601,
+	1535,
+	1601,
+	1534,
+	1601,
+	1535,
+	1602,
+	1536,
+	1602,
+	1535,
+	1602,
+	1536,
+	1603,
+	1537,
+	1603,
+	1536,
+	1603,
+	1537,
+	1604,
+	1538,
+	1604,
+	1537,
+	1604,
+	1538,
+	1605,
+	1539,
+	1605,
+	1538,
+	1605,
+	1539,
+	1606,
+	1540,
+	1606,
+	1539,
+	1606,
+	1540,
+	1607,
+	1541,
+	1607,
+	1540,
+	1607,
+	1541,
+	1608,
+	1542,
+	1608,
+	1541,
+	1608,
+	1542,
+	1609,
+	1543,
+	1609,
+	1542,
+	1609,
+	1543,
+	1610,
+	1544,
+	1610,
+	1543,
+	1610,
+	1544,
+	1611,
+	1545,
+	1611,
+	1544,
+	1611,
+	1545,
+	1612,
+	1546,
+	1612,
+	1545,
+	1612,
+	1546,
+	1613,
+	1547,
+	1613,
+	1546,
+	1613,
+	1547,
+	1614,
+	1548,
+	1614,
+	1547,
+	1614,
+	1548,
+	1615,
+	1549,
+	1615,
+	1548,
+	1615,
+	1549,
+	1616,
+	1550,
+	1616,
+	1549,
+	1616,
+	1550,
+	1617,
+	1551,
+	1617,
+	1550,
+	1617,
+	1551,
+	1618,
+	1552,
+	1618,
+	1551,
+	1618,
+	1552,
+	1619,
+	1553,
+	1619,
+	1552,
+	1619,
+	1553,
+	1620,
+	1554,
+	1620,
+	1553,
+	1620,
+	1554,
+	1621,
+	1555,
+	1621,
+	1554,
+	1621,
+	1555,
+	1622,
+	1556,
+	1622,
+	1555,
+	1622,
+	1556,
+	1623,
+	1557,
+	1623,
+	1556,
+	1623,
+	1557,
+	1624,
+	1558,
+	1624,
+	1557,
+	1624,
+	1558,
+	1625,
+	1559,
+	1625,
+	1558,
+	1625,
+	1559,
+	1626,
+	1560,
+	1626,
+	1559,
+	1626,
+	1560,
+	1627,
+	1561,
+	1627,
+	1560,
+	1627,
+	1561,
+	1628,
+	1562,
+	1628,
+	1561,
+	1628,
+	1562,
+	1629,
+	1563,
+	1629,
+	1562,
+	1629,
+	1563,
+	1630,
+	1564,
+	1630,
+	1563,
+	1630,
+	1564,
+	1631,
+	1565,
+	1631,
+	1564,
+	1631,
+	1565,
+	1632,
+	1566,
+	1632,
+	1565,
+	1632,
+	1566,
+	1633,
+	1567,
+	1633,
+	1566,
+	1633,
+	1567,
+	1634,
+	1568,
+	1634,
+	1567,
+	1634,
+	1568,
+	1635,
+	1569,
+	1635,
+	1568,
+	1635,
+	1569,
+	1636,
+	1570,
+	1636,
+	1569,
+	1636,
+	1570,
+	1637,
+	1571,
+	1637,
+	1570,
+	1637,
+	1571,
+	1638,
+	1572,
+	1638,
+	1571,
+	1638,
+	1572,
+	1639,
+	1573,
+	1639,
+	1572,
+	1639,
+	1573,
+	1640,
+	1574,
+	1640,
+	1573,
+	1640,
+	1574,
+	1641,
+	1575,
+	1641,
+	1574,
+	1641,
+	1575,
+	1642,
+	1576,
+	1642,
+	1575,
+	1642,
+	1576,
+	1643,
+	1577,
+	1643,
+	1576,
+	1643,
+	1577,
+	1644,
+	1578,
+	1644,
+	1577,
+	1644,
+	1578,
+	1645,
+	1579,
+	1645,
+	1578,
+	1645,
+	1579,
+	1646,
+	1580,
+	1646,
+	1579,
+	1646,
+	1580,
+	1647,
+	1581,
+	1647,
+	1580,
+	1647,
+	1581,
+	1648,
+	1582,
+	1648,
+	1581,
+	1648,
+	1582,
+	1649,
+	1583,
+	1649,
+	1582,
+	1650,
+	1584,
+	1651,
+	1585,
+	1651,
+	1584,
+	1651,
+	1585,
+	1652,
+	1586,
+	1652,
+	1585,
+	1652,
+	1586,
+	1653,
+	1587,
+	1653,
+	1586,
+	1653,
+	1587,
+	1654,
+	1588,
+	1654,
+	1587,
+	1654,
+	1588,
+	1655,
+	1589,
+	1655,
+	1588,
+	1655,
+	1589,
+	1656,
+	1590,
+	1656,
+	1589,
+	1656,
+	1590,
+	1657,
+	1591,
+	1657,
+	1590,
+	1657,
+	1591,
+	1658,
+	1592,
+	1658,
+	1591,
+	1658,
+	1592,
+	1659,
+	1593,
+	1659,
+	1592,
+	1659,
+	1593,
+	1660,
+	1594,
+	1660,
+	1593,
+	1660,
+	1594,
+	1661,
+	1595,
+	1661,
+	1594,
+	1661,
+	1595,
+	1662,
+	1596,
+	1662,
+	1595,
+	1662,
+	1596,
+	1663,
+	1597,
+	1663,
+	1596,
+	1663,
+	1597,
+	1664,
+	1598,
+	1664,
+	1597,
+	1664,
+	1598,
+	1665,
+	1599,
+	1665,
+	1598,
+	1665,
+	1599,
+	1666,
+	1600,
+	1666,
+	1599,
+	1666,
+	1600,
+	1667,
+	1601,
+	1667,
+	1600,
+	1667,
+	1601,
+	1668,
+	1602,
+	1668,
+	1601,
+	1668,
+	1602,
+	1669,
+	1603,
+	1669,
+	1602,
+	1669,
+	1603,
+	1670,
+	1604,
+	1670,
+	1603,
+	1670,
+	1604,
+	1671,
+	1605,
+	1671,
+	1604,
+	1671,
+	1605,
+	1672,
+	1606,
+	1672,
+	1605,
+	1672,
+	1606,
+	1673,
+	1607,
+	1673,
+	1606,
+	1673,
+	1607,
+	1674,
+	1608,
+	1674,
+	1607,
+	1674,
+	1608,
+	1675,
+	1609,
+	1675,
+	1608,
+	1675,
+	1609,
+	1676,
+	1610,
+	1676,
+	1609,
+	1676,
+	1610,
+	1677,
+	1611,
+	1677,
+	1610,
+	1677,
+	1611,
+	1678,
+	1612,
+	1678,
+	1611,
+	1678,
+	1612,
+	1679,
+	1613,
+	1679,
+	1612,
+	1679,
+	1613,
+	1680,
+	1614,
+	1680,
+	1613,
+	1680,
+	1614,
+	1681,
+	1615,
+	1681,
+	1614,
+	1681,
+	1615,
+	1682,
+	1616,
+	1682,
+	1615,
+	1682,
+	1616,
+	1683,
+	1617,
+	1683,
+	1616,
+	1683,
+	1617,
+	1684,
+	1618,
+	1684,
+	1617,
+	1684,
+	1618,
+	1685,
+	1619,
+	1685,
+	1618,
+	1685,
+	1619,
+	1686,
+	1620,
+	1686,
+	1619,
+	1686,
+	1620,
+	1687,
+	1621,
+	1687,
+	1620,
+	1687,
+	1621,
+	1688,
+	1622,
+	1688,
+	1621,
+	1688,
+	1622,
+	1689,
+	1623,
+	1689,
+	1622,
+	1689,
+	1623,
+	1690,
+	1624,
+	1690,
+	1623,
+	1690,
+	1624,
+	1691,
+	1625,
+	1691,
+	1624,
+	1691,
+	1625,
+	1692,
+	1626,
+	1692,
+	1625,
+	1692,
+	1626,
+	1693,
+	1627,
+	1693,
+	1626,
+	1693,
+	1627,
+	1694,
+	1628,
+	1694,
+	1627,
+	1694,
+	1628,
+	1695,
+	1629,
+	1695,
+	1628,
+	1695,
+	1629,
+	1696,
+	1630,
+	1696,
+	1629,
+	1696,
+	1630,
+	1697,
+	1631,
+	1697,
+	1630,
+	1697,
+	1631,
+	1698,
+	1632,
+	1698,
+	1631,
+	1698,
+	1632,
+	1699,
+	1633,
+	1699,
+	1632,
+	1699,
+	1633,
+	1700,
+	1634,
+	1700,
+	1633,
+	1700,
+	1634,
+	1701,
+	1635,
+	1701,
+	1634,
+	1701,
+	1635,
+	1702,
+	1636,
+	1702,
+	1635,
+	1702,
+	1636,
+	1703,
+	1637,
+	1703,
+	1636,
+	1703,
+	1637,
+	1704,
+	1638,
+	1704,
+	1637,
+	1704,
+	1638,
+	1705,
+	1639,
+	1705,
+	1638,
+	1705,
+	1639,
+	1706,
+	1640,
+	1706,
+	1639,
+	1706,
+	1640,
+	1707,
+	1641,
+	1707,
+	1640,
+	1707,
+	1641,
+	1708,
+	1642,
+	1708,
+	1641,
+	1708,
+	1642,
+	1709,
+	1643,
+	1709,
+	1642,
+	1709,
+	1643,
+	1710,
+	1644,
+	1710,
+	1643,
+	1710,
+	1644,
+	1711,
+	1645,
+	1711,
+	1644,
+	1711,
+	1645,
+	1712,
+	1646,
+	1712,
+	1645,
+	1712,
+	1646,
+	1713,
+	1647,
+	1713,
+	1646,
+	1713,
+	1647,
+	1714,
+	1648,
+	1714,
+	1647,
+	1714,
+	1648,
+	1715,
+	1649,
+	1715,
+	1648,
+	1716,
+	1650,
+	1717,
+	1651,
+	1717,
+	1650,
+	1717,
+	1651,
+	1718,
+	1652,
+	1718,
+	1651,
+	1718,
+	1652,
+	1719,
+	1653,
+	1719,
+	1652,
+	1719,
+	1653,
+	1720,
+	1654,
+	1720,
+	1653,
+	1720,
+	1654,
+	1721,
+	1655,
+	1721,
+	1654,
+	1721,
+	1655,
+	1722,
+	1656,
+	1722,
+	1655,
+	1722,
+	1656,
+	1723,
+	1657,
+	1723,
+	1656,
+	1723,
+	1657,
+	1724,
+	1658,
+	1724,
+	1657,
+	1724,
+	1658,
+	1725,
+	1659,
+	1725,
+	1658,
+	1725,
+	1659,
+	1726,
+	1660,
+	1726,
+	1659,
+	1726,
+	1660,
+	1727,
+	1661,
+	1727,
+	1660,
+	1727,
+	1661,
+	1728,
+	1662,
+	1728,
+	1661,
+	1728,
+	1662,
+	1729,
+	1663,
+	1729,
+	1662,
+	1729,
+	1663,
+	1730,
+	1664,
+	1730,
+	1663,
+	1730,
+	1664,
+	1731,
+	1665,
+	1731,
+	1664,
+	1731,
+	1665,
+	1732,
+	1666,
+	1732,
+	1665,
+	1732,
+	1666,
+	1733,
+	1667,
+	1733,
+	1666,
+	1733,
+	1667,
+	1734,
+	1668,
+	1734,
+	1667,
+	1734,
+	1668,
+	1735,
+	1669,
+	1735,
+	1668,
+	1735,
+	1669,
+	1736,
+	1670,
+	1736,
+	1669,
+	1736,
+	1670,
+	1737,
+	1671,
+	1737,
+	1670,
+	1737,
+	1671,
+	1738,
+	1672,
+	1738,
+	1671,
+	1738,
+	1672,
+	1739,
+	1673,
+	1739,
+	1672,
+	1739,
+	1673,
+	1740,
+	1674,
+	1740,
+	1673,
+	1740,
+	1674,
+	1741,
+	1675,
+	1741,
+	1674,
+	1741,
+	1675,
+	1742,
+	1676,
+	1742,
+	1675,
+	1742,
+	1676,
+	1743,
+	1677,
+	1743,
+	1676,
+	1743,
+	1677,
+	1744,
+	1678,
+	1744,
+	1677,
+	1744,
+	1678,
+	1745,
+	1679,
+	1745,
+	1678,
+	1745,
+	1679,
+	1746,
+	1680,
+	1746,
+	1679,
+	1746,
+	1680,
+	1747,
+	1681,
+	1747,
+	1680,
+	1747,
+	1681,
+	1748,
+	1682,
+	1748,
+	1681,
+	1748,
+	1682,
+	1749,
+	1683,
+	1749,
+	1682,
+	1749,
+	1683,
+	1750,
+	1684,
+	1750,
+	1683,
+	1750,
+	1684,
+	1751,
+	1685,
+	1751,
+	1684,
+	1751,
+	1685,
+	1752,
+	1686,
+	1752,
+	1685,
+	1752,
+	1686,
+	1753,
+	1687,
+	1753,
+	1686,
+	1753,
+	1687,
+	1754,
+	1688,
+	1754,
+	1687,
+	1754,
+	1688,
+	1755,
+	1689,
+	1755,
+	1688,
+	1755,
+	1689,
+	1756,
+	1690,
+	1756,
+	1689,
+	1756,
+	1690,
+	1757,
+	1691,
+	1757,
+	1690,
+	1757,
+	1691,
+	1758,
+	1692,
+	1758,
+	1691,
+	1758,
+	1692,
+	1759,
+	1693,
+	1759,
+	1692,
+	1759,
+	1693,
+	1760,
+	1694,
+	1760,
+	1693,
+	1760,
+	1694,
+	1761,
+	1695,
+	1761,
+	1694,
+	1761,
+	1695,
+	1762,
+	1696,
+	1762,
+	1695,
+	1762,
+	1696,
+	1763,
+	1697,
+	1763,
+	1696,
+	1763,
+	1697,
+	1764,
+	1698,
+	1764,
+	1697,
+	1764,
+	1698,
+	1765,
+	1699,
+	1765,
+	1698,
+	1765,
+	1699,
+	1766,
+	1700,
+	1766,
+	1699,
+	1766,
+	1700,
+	1767,
+	1701,
+	1767,
+	1700,
+	1767,
+	1701,
+	1768,
+	1702,
+	1768,
+	1701,
+	1768,
+	1702,
+	1769,
+	1703,
+	1769,
+	1702,
+	1769,
+	1703,
+	1770,
+	1704,
+	1770,
+	1703,
+	1770,
+	1704,
+	1771,
+	1705,
+	1771,
+	1704,
+	1771,
+	1705,
+	1772,
+	1706,
+	1772,
+	1705,
+	1772,
+	1706,
+	1773,
+	1707,
+	1773,
+	1706,
+	1773,
+	1707,
+	1774,
+	1708,
+	1774,
+	1707,
+	1774,
+	1708,
+	1775,
+	1709,
+	1775,
+	1708,
+	1775,
+	1709,
+	1776,
+	1710,
+	1776,
+	1709,
+	1776,
+	1710,
+	1777,
+	1711,
+	1777,
+	1710,
+	1777,
+	1711,
+	1778,
+	1712,
+	1778,
+	1711,
+	1778,
+	1712,
+	1779,
+	1713,
+	1779,
+	1712,
+	1779,
+	1713,
+	1780,
+	1714,
+	1780,
+	1713,
+	1780,
+	1714,
+	1781,
+	1715,
+	1781,
+	1714,
+	1782,
+	1716,
+	1783,
+	1717,
+	1783,
+	1716,
+	1783,
+	1717,
+	1784,
+	1718,
+	1784,
+	1717,
+	1784,
+	1718,
+	1785,
+	1719,
+	1785,
+	1718,
+	1785,
+	1719,
+	1786,
+	1720,
+	1786,
+	1719,
+	1786,
+	1720,
+	1787,
+	1721,
+	1787,
+	1720,
+	1787,
+	1721,
+	1788,
+	1722,
+	1788,
+	1721,
+	1788,
+	1722,
+	1789,
+	1723,
+	1789,
+	1722,
+	1789,
+	1723,
+	1790,
+	1724,
+	1790,
+	1723,
+	1790,
+	1724,
+	1791,
+	1725,
+	1791,
+	1724,
+	1791,
+	1725,
+	1792,
+	1726,
+	1792,
+	1725,
+	1792,
+	1726,
+	1793,
+	1727,
+	1793,
+	1726,
+	1793,
+	1727,
+	1794,
+	1728,
+	1794,
+	1727,
+	1794,
+	1728,
+	1795,
+	1729,
+	1795,
+	1728,
+	1795,
+	1729,
+	1796,
+	1730,
+	1796,
+	1729,
+	1796,
+	1730,
+	1797,
+	1731,
+	1797,
+	1730,
+	1797,
+	1731,
+	1798,
+	1732,
+	1798,
+	1731,
+	1798,
+	1732,
+	1799,
+	1733,
+	1799,
+	1732,
+	1799,
+	1733,
+	1800,
+	1734,
+	1800,
+	1733,
+	1800,
+	1734,
+	1801,
+	1735,
+	1801,
+	1734,
+	1801,
+	1735,
+	1802,
+	1736,
+	1802,
+	1735,
+	1802,
+	1736,
+	1803,
+	1737,
+	1803,
+	1736,
+	1803,
+	1737,
+	1804,
+	1738,
+	1804,
+	1737,
+	1804,
+	1738,
+	1805,
+	1739,
+	1805,
+	1738,
+	1805,
+	1739,
+	1806,
+	1740,
+	1806,
+	1739,
+	1806,
+	1740,
+	1807,
+	1741,
+	1807,
+	1740,
+	1807,
+	1741,
+	1808,
+	1742,
+	1808,
+	1741,
+	1808,
+	1742,
+	1809,
+	1743,
+	1809,
+	1742,
+	1809,
+	1743,
+	1810,
+	1744,
+	1810,
+	1743,
+	1810,
+	1744,
+	1811,
+	1745,
+	1811,
+	1744,
+	1811,
+	1745,
+	1812,
+	1746,
+	1812,
+	1745,
+	1812,
+	1746,
+	1813,
+	1747,
+	1813,
+	1746,
+	1813,
+	1747,
+	1814,
+	1748,
+	1814,
+	1747,
+	1814,
+	1748,
+	1815,
+	1749,
+	1815,
+	1748,
+	1815,
+	1749,
+	1816,
+	1750,
+	1816,
+	1749,
+	1816,
+	1750,
+	1817,
+	1751,
+	1817,
+	1750,
+	1817,
+	1751,
+	1818,
+	1752,
+	1818,
+	1751,
+	1818,
+	1752,
+	1819,
+	1753,
+	1819,
+	1752,
+	1819,
+	1753,
+	1820,
+	1754,
+	1820,
+	1753,
+	1820,
+	1754,
+	1821,
+	1755,
+	1821,
+	1754,
+	1821,
+	1755,
+	1822,
+	1756,
+	1822,
+	1755,
+	1822,
+	1756,
+	1823,
+	1757,
+	1823,
+	1756,
+	1823,
+	1757,
+	1824,
+	1758,
+	1824,
+	1757,
+	1824,
+	1758,
+	1825,
+	1759,
+	1825,
+	1758,
+	1825,
+	1759,
+	1826,
+	1760,
+	1826,
+	1759,
+	1826,
+	1760,
+	1827,
+	1761,
+	1827,
+	1760,
+	1827,
+	1761,
+	1828,
+	1762,
+	1828,
+	1761,
+	1828,
+	1762,
+	1829,
+	1763,
+	1829,
+	1762,
+	1829,
+	1763,
+	1830,
+	1764,
+	1830,
+	1763,
+	1830,
+	1764,
+	1831,
+	1765,
+	1831,
+	1764,
+	1831,
+	1765,
+	1832,
+	1766,
+	1832,
+	1765,
+	1832,
+	1766,
+	1833,
+	1767,
+	1833,
+	1766,
+	1833,
+	1767,
+	1834,
+	1768,
+	1834,
+	1767,
+	1834,
+	1768,
+	1835,
+	1769,
+	1835,
+	1768,
+	1835,
+	1769,
+	1836,
+	1770,
+	1836,
+	1769,
+	1836,
+	1770,
+	1837,
+	1771,
+	1837,
+	1770,
+	1837,
+	1771,
+	1838,
+	1772,
+	1838,
+	1771,
+	1838,
+	1772,
+	1839,
+	1773,
+	1839,
+	1772,
+	1839,
+	1773,
+	1840,
+	1774,
+	1840,
+	1773,
+	1840,
+	1774,
+	1841,
+	1775,
+	1841,
+	1774,
+	1841,
+	1775,
+	1842,
+	1776,
+	1842,
+	1775,
+	1842,
+	1776,
+	1843,
+	1777,
+	1843,
+	1776,
+	1843,
+	1777,
+	1844,
+	1778,
+	1844,
+	1777,
+	1844,
+	1778,
+	1845,
+	1779,
+	1845,
+	1778,
+	1845,
+	1779,
+	1846,
+	1780,
+	1846,
+	1779,
+	1846,
+	1780,
+	1847,
+	1781,
+	1847,
+	1780,
+	1848,
+	1782,
+	1849,
+	1783,
+	1849,
+	1782,
+	1849,
+	1783,
+	1850,
+	1784,
+	1850,
+	1783,
+	1850,
+	1784,
+	1851,
+	1785,
+	1851,
+	1784,
+	1851,
+	1785,
+	1852,
+	1786,
+	1852,
+	1785,
+	1852,
+	1786,
+	1853,
+	1787,
+	1853,
+	1786,
+	1853,
+	1787,
+	1854,
+	1788,
+	1854,
+	1787,
+	1854,
+	1788,
+	1855,
+	1789,
+	1855,
+	1788,
+	1855,
+	1789,
+	1856,
+	1790,
+	1856,
+	1789,
+	1856,
+	1790,
+	1857,
+	1791,
+	1857,
+	1790,
+	1857,
+	1791,
+	1858,
+	1792,
+	1858,
+	1791,
+	1858,
+	1792,
+	1859,
+	1793,
+	1859,
+	1792,
+	1859,
+	1793,
+	1860,
+	1794,
+	1860,
+	1793,
+	1860,
+	1794,
+	1861,
+	1795,
+	1861,
+	1794,
+	1861,
+	1795,
+	1862,
+	1796,
+	1862,
+	1795,
+	1862,
+	1796,
+	1863,
+	1797,
+	1863,
+	1796,
+	1863,
+	1797,
+	1864,
+	1798,
+	1864,
+	1797,
+	1864,
+	1798,
+	1865,
+	1799,
+	1865,
+	1798,
+	1865,
+	1799,
+	1866,
+	1800,
+	1866,
+	1799,
+	1866,
+	1800,
+	1867,
+	1801,
+	1867,
+	1800,
+	1867,
+	1801,
+	1868,
+	1802,
+	1868,
+	1801,
+	1868,
+	1802,
+	1869,
+	1803,
+	1869,
+	1802,
+	1869,
+	1803,
+	1870,
+	1804,
+	1870,
+	1803,
+	1870,
+	1804,
+	1871,
+	1805,
+	1871,
+	1804,
+	1871,
+	1805,
+	1872,
+	1806,
+	1872,
+	1805,
+	1872,
+	1806,
+	1873,
+	1807,
+	1873,
+	1806,
+	1873,
+	1807,
+	1874,
+	1808,
+	1874,
+	1807,
+	1874,
+	1808,
+	1875,
+	1809,
+	1875,
+	1808,
+	1875,
+	1809,
+	1876,
+	1810,
+	1876,
+	1809,
+	1876,
+	1810,
+	1877,
+	1811,
+	1877,
+	1810,
+	1877,
+	1811,
+	1878,
+	1812,
+	1878,
+	1811,
+	1878,
+	1812,
+	1879,
+	1813,
+	1879,
+	1812,
+	1879,
+	1813,
+	1880,
+	1814,
+	1880,
+	1813,
+	1880,
+	1814,
+	1881,
+	1815,
+	1881,
+	1814,
+	1881,
+	1815,
+	1882,
+	1816,
+	1882,
+	1815,
+	1882,
+	1816,
+	1883,
+	1817,
+	1883,
+	1816,
+	1883,
+	1817,
+	1884,
+	1818,
+	1884,
+	1817,
+	1884,
+	1818,
+	1885,
+	1819,
+	1885,
+	1818,
+	1885,
+	1819,
+	1886,
+	1820,
+	1886,
+	1819,
+	1886,
+	1820,
+	1887,
+	1821,
+	1887,
+	1820,
+	1887,
+	1821,
+	1888,
+	1822,
+	1888,
+	1821,
+	1888,
+	1822,
+	1889,
+	1823,
+	1889,
+	1822,
+	1889,
+	1823,
+	1890,
+	1824,
+	1890,
+	1823,
+	1890,
+	1824,
+	1891,
+	1825,
+	1891,
+	1824,
+	1891,
+	1825,
+	1892,
+	1826,
+	1892,
+	1825,
+	1892,
+	1826,
+	1893,
+	1827,
+	1893,
+	1826,
+	1893,
+	1827,
+	1894,
+	1828,
+	1894,
+	1827,
+	1894,
+	1828,
+	1895,
+	1829,
+	1895,
+	1828,
+	1895,
+	1829,
+	1896,
+	1830,
+	1896,
+	1829,
+	1896,
+	1830,
+	1897,
+	1831,
+	1897,
+	1830,
+	1897,
+	1831,
+	1898,
+	1832,
+	1898,
+	1831,
+	1898,
+	1832,
+	1899,
+	1833,
+	1899,
+	1832,
+	1899,
+	1833,
+	1900,
+	1834,
+	1900,
+	1833,
+	1900,
+	1834,
+	1901,
+	1835,
+	1901,
+	1834,
+	1901,
+	1835,
+	1902,
+	1836,
+	1902,
+	1835,
+	1902,
+	1836,
+	1903,
+	1837,
+	1903,
+	1836,
+	1903,
+	1837,
+	1904,
+	1838,
+	1904,
+	1837,
+	1904,
+	1838,
+	1905,
+	1839,
+	1905,
+	1838,
+	1905,
+	1839,
+	1906,
+	1840,
+	1906,
+	1839,
+	1906,
+	1840,
+	1907,
+	1841,
+	1907,
+	1840,
+	1907,
+	1841,
+	1908,
+	1842,
+	1908,
+	1841,
+	1908,
+	1842,
+	1909,
+	1843,
+	1909,
+	1842,
+	1909,
+	1843,
+	1910,
+	1844,
+	1910,
+	1843,
+	1910,
+	1844,
+	1911,
+	1845,
+	1911,
+	1844,
+	1911,
+	1845,
+	1912,
+	1846,
+	1912,
+	1845,
+	1912,
+	1846,
+	1913,
+	1847,
+	1913,
+	1846,
+	1914,
+	1848,
+	1915,
+	1849,
+	1915,
+	1848,
+	1915,
+	1849,
+	1916,
+	1850,
+	1916,
+	1849,
+	1916,
+	1850,
+	1917,
+	1851,
+	1917,
+	1850,
+	1917,
+	1851,
+	1918,
+	1852,
+	1918,
+	1851,
+	1918,
+	1852,
+	1919,
+	1853,
+	1919,
+	1852,
+	1919,
+	1853,
+	1920,
+	1854,
+	1920,
+	1853,
+	1920,
+	1854,
+	1921,
+	1855,
+	1921,
+	1854,
+	1921,
+	1855,
+	1922,
+	1856,
+	1922,
+	1855,
+	1922,
+	1856,
+	1923,
+	1857,
+	1923,
+	1856,
+	1923,
+	1857,
+	1924,
+	1858,
+	1924,
+	1857,
+	1924,
+	1858,
+	1925,
+	1859,
+	1925,
+	1858,
+	1925,
+	1859,
+	1926,
+	1860,
+	1926,
+	1859,
+	1926,
+	1860,
+	1927,
+	1861,
+	1927,
+	1860,
+	1927,
+	1861,
+	1928,
+	1862,
+	1928,
+	1861,
+	1928,
+	1862,
+	1929,
+	1863,
+	1929,
+	1862,
+	1929,
+	1863,
+	1930,
+	1864,
+	1930,
+	1863,
+	1930,
+	1864,
+	1931,
+	1865,
+	1931,
+	1864,
+	1931,
+	1865,
+	1932,
+	1866,
+	1932,
+	1865,
+	1932,
+	1866,
+	1933,
+	1867,
+	1933,
+	1866,
+	1933,
+	1867,
+	1934,
+	1868,
+	1934,
+	1867,
+	1934,
+	1868,
+	1935,
+	1869,
+	1935,
+	1868,
+	1935,
+	1869,
+	1936,
+	1870,
+	1936,
+	1869,
+	1936,
+	1870,
+	1937,
+	1871,
+	1937,
+	1870,
+	1937,
+	1871,
+	1938,
+	1872,
+	1938,
+	1871,
+	1938,
+	1872,
+	1939,
+	1873,
+	1939,
+	1872,
+	1939,
+	1873,
+	1940,
+	1874,
+	1940,
+	1873,
+	1940,
+	1874,
+	1941,
+	1875,
+	1941,
+	1874,
+	1941,
+	1875,
+	1942,
+	1876,
+	1942,
+	1875,
+	1942,
+	1876,
+	1943,
+	1877,
+	1943,
+	1876,
+	1943,
+	1877,
+	1944,
+	1878,
+	1944,
+	1877,
+	1944,
+	1878,
+	1945,
+	1879,
+	1945,
+	1878,
+	1945,
+	1879,
+	1946,
+	1880,
+	1946,
+	1879,
+	1946,
+	1880,
+	1947,
+	1881,
+	1947,
+	1880,
+	1947,
+	1881,
+	1948,
+	1882,
+	1948,
+	1881,
+	1948,
+	1882,
+	1949,
+	1883,
+	1949,
+	1882,
+	1949,
+	1883,
+	1950,
+	1884,
+	1950,
+	1883,
+	1950,
+	1884,
+	1951,
+	1885,
+	1951,
+	1884,
+	1951,
+	1885,
+	1952,
+	1886,
+	1952,
+	1885,
+	1952,
+	1886,
+	1953,
+	1887,
+	1953,
+	1886,
+	1953,
+	1887,
+	1954,
+	1888,
+	1954,
+	1887,
+	1954,
+	1888,
+	1955,
+	1889,
+	1955,
+	1888,
+	1955,
+	1889,
+	1956,
+	1890,
+	1956,
+	1889,
+	1956,
+	1890,
+	1957,
+	1891,
+	1957,
+	1890,
+	1957,
+	1891,
+	1958,
+	1892,
+	1958,
+	1891,
+	1958,
+	1892,
+	1959,
+	1893,
+	1959,
+	1892,
+	1959,
+	1893,
+	1960,
+	1894,
+	1960,
+	1893,
+	1960,
+	1894,
+	1961,
+	1895,
+	1961,
+	1894,
+	1961,
+	1895,
+	1962,
+	1896,
+	1962,
+	1895,
+	1962,
+	1896,
+	1963,
+	1897,
+	1963,
+	1896,
+	1963,
+	1897,
+	1964,
+	1898,
+	1964,
+	1897,
+	1964,
+	1898,
+	1965,
+	1899,
+	1965,
+	1898,
+	1965,
+	1899,
+	1966,
+	1900,
+	1966,
+	1899,
+	1966,
+	1900,
+	1967,
+	1901,
+	1967,
+	1900,
+	1967,
+	1901,
+	1968,
+	1902,
+	1968,
+	1901,
+	1968,
+	1902,
+	1969,
+	1903,
+	1969,
+	1902,
+	1969,
+	1903,
+	1970,
+	1904,
+	1970,
+	1903,
+	1970,
+	1904,
+	1971,
+	1905,
+	1971,
+	1904,
+	1971,
+	1905,
+	1972,
+	1906,
+	1972,
+	1905,
+	1972,
+	1906,
+	1973,
+	1907,
+	1973,
+	1906,
+	1973,
+	1907,
+	1974,
+	1908,
+	1974,
+	1907,
+	1974,
+	1908,
+	1975,
+	1909,
+	1975,
+	1908,
+	1975,
+	1909,
+	1976,
+	1910,
+	1976,
+	1909,
+	1976,
+	1910,
+	1977,
+	1911,
+	1977,
+	1910,
+	1977,
+	1911,
+	1978,
+	1912,
+	1978,
+	1911,
+	1978,
+	1912,
+	1979,
+	1913,
+	1979,
+	1912,
+	1980,
+	1914,
+	1981,
+	1915,
+	1981,
+	1914,
+	1981,
+	1915,
+	1982,
+	1916,
+	1982,
+	1915,
+	1982,
+	1916,
+	1983,
+	1917,
+	1983,
+	1916,
+	1983,
+	1917,
+	1984,
+	1918,
+	1984,
+	1917,
+	1984,
+	1918,
+	1985,
+	1919,
+	1985,
+	1918,
+	1985,
+	1919,
+	1986,
+	1920,
+	1986,
+	1919,
+	1986,
+	1920,
+	1987,
+	1921,
+	1987,
+	1920,
+	1987,
+	1921,
+	1988,
+	1922,
+	1988,
+	1921,
+	1988,
+	1922,
+	1989,
+	1923,
+	1989,
+	1922,
+	1989,
+	1923,
+	1990,
+	1924,
+	1990,
+	1923,
+	1990,
+	1924,
+	1991,
+	1925,
+	1991,
+	1924,
+	1991,
+	1925,
+	1992,
+	1926,
+	1992,
+	1925,
+	1992,
+	1926,
+	1993,
+	1927,
+	1993,
+	1926,
+	1993,
+	1927,
+	1994,
+	1928,
+	1994,
+	1927,
+	1994,
+	1928,
+	1995,
+	1929,
+	1995,
+	1928,
+	1995,
+	1929,
+	1996,
+	1930,
+	1996,
+	1929,
+	1996,
+	1930,
+	1997,
+	1931,
+	1997,
+	1930,
+	1997,
+	1931,
+	1998,
+	1932,
+	1998,
+	1931,
+	1998,
+	1932,
+	1999,
+	1933,
+	1999,
+	1932,
+	1999,
+	1933,
+	2000,
+	1934,
+	2000,
+	1933,
+	2000,
+	1934,
+	2001,
+	1935,
+	2001,
+	1934,
+	2001,
+	1935,
+	2002,
+	1936,
+	2002,
+	1935,
+	2002,
+	1936,
+	2003,
+	1937,
+	2003,
+	1936,
+	2003,
+	1937,
+	2004,
+	1938,
+	2004,
+	1937,
+	2004,
+	1938,
+	2005,
+	1939,
+	2005,
+	1938,
+	2005,
+	1939,
+	2006,
+	1940,
+	2006,
+	1939,
+	2006,
+	1940,
+	2007,
+	1941,
+	2007,
+	1940,
+	2007,
+	1941,
+	2008,
+	1942,
+	2008,
+	1941,
+	2008,
+	1942,
+	2009,
+	1943,
+	2009,
+	1942,
+	2009,
+	1943,
+	2010,
+	1944,
+	2010,
+	1943,
+	2010,
+	1944,
+	2011,
+	1945,
+	2011,
+	1944,
+	2011,
+	1945,
+	2012,
+	1946,
+	2012,
+	1945,
+	2012,
+	1946,
+	2013,
+	1947,
+	2013,
+	1946,
+	2013,
+	1947,
+	2014,
+	1948,
+	2014,
+	1947,
+	2014,
+	1948,
+	2015,
+	1949,
+	2015,
+	1948,
+	2015,
+	1949,
+	2016,
+	1950,
+	2016,
+	1949,
+	2016,
+	1950,
+	2017,
+	1951,
+	2017,
+	1950,
+	2017,
+	1951,
+	2018,
+	1952,
+	2018,
+	1951,
+	2018,
+	1952,
+	2019,
+	1953,
+	2019,
+	1952,
+	2019,
+	1953,
+	2020,
+	1954,
+	2020,
+	1953,
+	2020,
+	1954,
+	2021,
+	1955,
+	2021,
+	1954,
+	2021,
+	1955,
+	2022,
+	1956,
+	2022,
+	1955,
+	2022,
+	1956,
+	2023,
+	1957,
+	2023,
+	1956,
+	2023,
+	1957,
+	2024,
+	1958,
+	2024,
+	1957,
+	2024,
+	1958,
+	2025,
+	1959,
+	2025,
+	1958,
+	2025,
+	1959,
+	2026,
+	1960,
+	2026,
+	1959,
+	2026,
+	1960,
+	2027,
+	1961,
+	2027,
+	1960,
+	2027,
+	1961,
+	2028,
+	1962,
+	2028,
+	1961,
+	2028,
+	1962,
+	2029,
+	1963,
+	2029,
+	1962,
+	2029,
+	1963,
+	2030,
+	1964,
+	2030,
+	1963,
+	2030,
+	1964,
+	2031,
+	1965,
+	2031,
+	1964,
+	2031,
+	1965,
+	2032,
+	1966,
+	2032,
+	1965,
+	2032,
+	1966,
+	2033,
+	1967,
+	2033,
+	1966,
+	2033,
+	1967,
+	2034,
+	1968,
+	2034,
+	1967,
+	2034,
+	1968,
+	2035,
+	1969,
+	2035,
+	1968,
+	2035,
+	1969,
+	2036,
+	1970,
+	2036,
+	1969,
+	2036,
+	1970,
+	2037,
+	1971,
+	2037,
+	1970,
+	2037,
+	1971,
+	2038,
+	1972,
+	2038,
+	1971,
+	2038,
+	1972,
+	2039,
+	1973,
+	2039,
+	1972,
+	2039,
+	1973,
+	2040,
+	1974,
+	2040,
+	1973,
+	2040,
+	1974,
+	2041,
+	1975,
+	2041,
+	1974,
+	2041,
+	1975,
+	2042,
+	1976,
+	2042,
+	1975,
+	2042,
+	1976,
+	2043,
+	1977,
+	2043,
+	1976,
+	2043,
+	1977,
+	2044,
+	1978,
+	2044,
+	1977,
+	2044,
+	1978,
+	2045,
+	1979,
+	2045,
+	1978,
+	2046,
+	1980,
+	2047,
+	1981,
+	2047,
+	1980,
+	2047,
+	1981,
+	2048,
+	1982,
+	2048,
+	1981,
+	2048,
+	1982,
+	2049,
+	1983,
+	2049,
+	1982,
+	2049,
+	1983,
+	2050,
+	1984,
+	2050,
+	1983,
+	2050,
+	1984,
+	2051,
+	1985,
+	2051,
+	1984,
+	2051,
+	1985,
+	2052,
+	1986,
+	2052,
+	1985,
+	2052,
+	1986,
+	2053,
+	1987,
+	2053,
+	1986,
+	2053,
+	1987,
+	2054,
+	1988,
+	2054,
+	1987,
+	2054,
+	1988,
+	2055,
+	1989,
+	2055,
+	1988,
+	2055,
+	1989,
+	2056,
+	1990,
+	2056,
+	1989,
+	2056,
+	1990,
+	2057,
+	1991,
+	2057,
+	1990,
+	2057,
+	1991,
+	2058,
+	1992,
+	2058,
+	1991,
+	2058,
+	1992,
+	2059,
+	1993,
+	2059,
+	1992,
+	2059,
+	1993,
+	2060,
+	1994,
+	2060,
+	1993,
+	2060,
+	1994,
+	2061,
+	1995,
+	2061,
+	1994,
+	2061,
+	1995,
+	2062,
+	1996,
+	2062,
+	1995,
+	2062,
+	1996,
+	2063,
+	1997,
+	2063,
+	1996,
+	2063,
+	1997,
+	2064,
+	1998,
+	2064,
+	1997,
+	2064,
+	1998,
+	2065,
+	1999,
+	2065,
+	1998,
+	2065,
+	1999,
+	2066,
+	2000,
+	2066,
+	1999,
+	2066,
+	2000,
+	2067,
+	2001,
+	2067,
+	2000,
+	2067,
+	2001,
+	2068,
+	2002,
+	2068,
+	2001,
+	2068,
+	2002,
+	2069,
+	2003,
+	2069,
+	2002,
+	2069,
+	2003,
+	2070,
+	2004,
+	2070,
+	2003,
+	2070,
+	2004,
+	2071,
+	2005,
+	2071,
+	2004,
+	2071,
+	2005,
+	2072,
+	2006,
+	2072,
+	2005,
+	2072,
+	2006,
+	2073,
+	2007,
+	2073,
+	2006,
+	2073,
+	2007,
+	2074,
+	2008,
+	2074,
+	2007,
+	2074,
+	2008,
+	2075,
+	2009,
+	2075,
+	2008,
+	2075,
+	2009,
+	2076,
+	2010,
+	2076,
+	2009,
+	2076,
+	2010,
+	2077,
+	2011,
+	2077,
+	2010,
+	2077,
+	2011,
+	2078,
+	2012,
+	2078,
+	2011,
+	2078,
+	2012,
+	2079,
+	2013,
+	2079,
+	2012,
+	2079,
+	2013,
+	2080,
+	2014,
+	2080,
+	2013,
+	2080,
+	2014,
+	2081,
+	2015,
+	2081,
+	2014,
+	2081,
+	2015,
+	2082,
+	2016,
+	2082,
+	2015,
+	2082,
+	2016,
+	2083,
+	2017,
+	2083,
+	2016,
+	2083,
+	2017,
+	2084,
+	2018,
+	2084,
+	2017,
+	2084,
+	2018,
+	2085,
+	2019,
+	2085,
+	2018,
+	2085,
+	2019,
+	2086,
+	2020,
+	2086,
+	2019,
+	2086,
+	2020,
+	2087,
+	2021,
+	2087,
+	2020,
+	2087,
+	2021,
+	2088,
+	2022,
+	2088,
+	2021,
+	2088,
+	2022,
+	2089,
+	2023,
+	2089,
+	2022,
+	2089,
+	2023,
+	2090,
+	2024,
+	2090,
+	2023,
+	2090,
+	2024,
+	2091,
+	2025,
+	2091,
+	2024,
+	2091,
+	2025,
+	2092,
+	2026,
+	2092,
+	2025,
+	2092,
+	2026,
+	2093,
+	2027,
+	2093,
+	2026,
+	2093,
+	2027,
+	2094,
+	2028,
+	2094,
+	2027,
+	2094,
+	2028,
+	2095,
+	2029,
+	2095,
+	2028,
+	2095,
+	2029,
+	2096,
+	2030,
+	2096,
+	2029,
+	2096,
+	2030,
+	2097,
+	2031,
+	2097,
+	2030,
+	2097,
+	2031,
+	2098,
+	2032,
+	2098,
+	2031,
+	2098,
+	2032,
+	2099,
+	2033,
+	2099,
+	2032,
+	2099,
+	2033,
+	2100,
+	2034,
+	2100,
+	2033,
+	2100,
+	2034,
+	2101,
+	2035,
+	2101,
+	2034,
+	2101,
+	2035,
+	2102,
+	2036,
+	2102,
+	2035,
+	2102,
+	2036,
+	2103,
+	2037,
+	2103,
+	2036,
+	2103,
+	2037,
+	2104,
+	2038,
+	2104,
+	2037,
+	2104,
+	2038,
+	2105,
+	2039,
+	2105,
+	2038,
+	2105,
+	2039,
+	2106,
+	2040,
+	2106,
+	2039,
+	2106,
+	2040,
+	2107,
+	2041,
+	2107,
+	2040,
+	2107,
+	2041,
+	2108,
+	2042,
+	2108,
+	2041,
+	2108,
+	2042,
+	2109,
+	2043,
+	2109,
+	2042,
+	2109,
+	2043,
+	2110,
+	2044,
+	2110,
+	2043,
+	2110,
+	2044,
+	2111,
+	2045,
+	2111,
+	2044,
+	2112,
+	2046,
+	2113,
+	2047,
+	2113,
+	2046,
+	2113,
+	2047,
+	2114,
+	2048,
+	2114,
+	2047,
+	2114,
+	2048,
+	2115,
+	2049,
+	2115,
+	2048,
+	2115,
+	2049,
+	2116,
+	2050,
+	2116,
+	2049,
+	2116,
+	2050,
+	2117,
+	2051,
+	2117,
+	2050,
+	2117,
+	2051,
+	2118,
+	2052,
+	2118,
+	2051,
+	2118,
+	2052,
+	2119,
+	2053,
+	2119,
+	2052,
+	2119,
+	2053,
+	2120,
+	2054,
+	2120,
+	2053,
+	2120,
+	2054,
+	2121,
+	2055,
+	2121,
+	2054,
+	2121,
+	2055,
+	2122,
+	2056,
+	2122,
+	2055,
+	2122,
+	2056,
+	2123,
+	2057,
+	2123,
+	2056,
+	2123,
+	2057,
+	2124,
+	2058,
+	2124,
+	2057,
+	2124,
+	2058,
+	2125,
+	2059,
+	2125,
+	2058,
+	2125,
+	2059,
+	2126,
+	2060,
+	2126,
+	2059,
+	2126,
+	2060,
+	2127,
+	2061,
+	2127,
+	2060,
+	2127,
+	2061,
+	2128,
+	2062,
+	2128,
+	2061,
+	2128,
+	2062,
+	2129,
+	2063,
+	2129,
+	2062,
+	2129,
+	2063,
+	2130,
+	2064,
+	2130,
+	2063,
+	2130,
+	2064,
+	2131,
+	2065,
+	2131,
+	2064,
+	2131,
+	2065,
+	2132,
+	2066,
+	2132,
+	2065,
+	2132,
+	2066,
+	2133,
+	2067,
+	2133,
+	2066,
+	2133,
+	2067,
+	2134,
+	2068,
+	2134,
+	2067,
+	2134,
+	2068,
+	2135,
+	2069,
+	2135,
+	2068,
+	2135,
+	2069,
+	2136,
+	2070,
+	2136,
+	2069,
+	2136,
+	2070,
+	2137,
+	2071,
+	2137,
+	2070,
+	2137,
+	2071,
+	2138,
+	2072,
+	2138,
+	2071,
+	2138,
+	2072,
+	2139,
+	2073,
+	2139,
+	2072,
+	2139,
+	2073,
+	2140,
+	2074,
+	2140,
+	2073,
+	2140,
+	2074,
+	2141,
+	2075,
+	2141,
+	2074,
+	2141,
+	2075,
+	2142,
+	2076,
+	2142,
+	2075,
+	2142,
+	2076,
+	2143,
+	2077,
+	2143,
+	2076,
+	2143,
+	2077,
+	2144,
+	2078,
+	2144,
+	2077,
+	2144,
+	2078,
+	2145,
+	2079,
+	2145,
+	2078,
+	2145,
+	2079,
+	2146,
+	2080,
+	2146,
+	2079,
+	2146,
+	2080,
+	2147,
+	2081,
+	2147,
+	2080,
+	2147,
+	2081,
+	2148,
+	2082,
+	2148,
+	2081,
+	2148,
+	2082,
+	2149,
+	2083,
+	2149,
+	2082,
+	2149,
+	2083,
+	2150,
+	2084,
+	2150,
+	2083,
+	2150,
+	2084,
+	2151,
+	2085,
+	2151,
+	2084,
+	2151,
+	2085,
+	2152,
+	2086,
+	2152,
+	2085,
+	2152,
+	2086,
+	2153,
+	2087,
+	2153,
+	2086,
+	2153,
+	2087,
+	2154,
+	2088,
+	2154,
+	2087,
+	2154,
+	2088,
+	2155,
+	2089,
+	2155,
+	2088,
+	2155,
+	2089,
+	2156,
+	2090,
+	2156,
+	2089,
+	2156,
+	2090,
+	2157,
+	2091,
+	2157,
+	2090,
+	2157,
+	2091,
+	2158,
+	2092,
+	2158,
+	2091,
+	2158,
+	2092,
+	2159,
+	2093,
+	2159,
+	2092,
+	2159,
+	2093,
+	2160,
+	2094,
+	2160,
+	2093,
+	2160,
+	2094,
+	2161,
+	2095,
+	2161,
+	2094,
+	2161,
+	2095,
+	2162,
+	2096,
+	2162,
+	2095,
+	2162,
+	2096,
+	2163,
+	2097,
+	2163,
+	2096,
+	2163,
+	2097,
+	2164,
+	2098,
+	2164,
+	2097,
+	2164,
+	2098,
+	2165,
+	2099,
+	2165,
+	2098,
+	2165,
+	2099,
+	2166,
+	2100,
+	2166,
+	2099,
+	2166,
+	2100,
+	2167,
+	2101,
+	2167,
+	2100,
+	2167,
+	2101,
+	2168,
+	2102,
+	2168,
+	2101,
+	2168,
+	2102,
+	2169,
+	2103,
+	2169,
+	2102,
+	2169,
+	2103,
+	2170,
+	2104,
+	2170,
+	2103,
+	2170,
+	2104,
+	2171,
+	2105,
+	2171,
+	2104,
+	2171,
+	2105,
+	2172,
+	2106,
+	2172,
+	2105,
+	2172,
+	2106,
+	2173,
+	2107,
+	2173,
+	2106,
+	2173,
+	2107,
+	2174,
+	2108,
+	2174,
+	2107,
+	2174,
+	2108,
+	2175,
+	2109,
+	2175,
+	2108,
+	2175,
+	2109,
+	2176,
+	2110,
+	2176,
+	2109,
+	2176,
+	2110,
+	2177,
+	2111,
+	2177,
+	2110,
+	2178,
+	2112,
+	2179,
+	2113,
+	2179,
+	2112,
+	2179,
+	2113,
+	2180,
+	2114,
+	2180,
+	2113,
+	2180,
+	2114,
+	2181,
+	2115,
+	2181,
+	2114,
+	2181,
+	2115,
+	2182,
+	2116,
+	2182,
+	2115,
+	2182,
+	2116,
+	2183,
+	2117,
+	2183,
+	2116,
+	2183,
+	2117,
+	2184,
+	2118,
+	2184,
+	2117,
+	2184,
+	2118,
+	2185,
+	2119,
+	2185,
+	2118,
+	2185,
+	2119,
+	2186,
+	2120,
+	2186,
+	2119,
+	2186,
+	2120,
+	2187,
+	2121,
+	2187,
+	2120,
+	2187,
+	2121,
+	2188,
+	2122,
+	2188,
+	2121,
+	2188,
+	2122,
+	2189,
+	2123,
+	2189,
+	2122,
+	2189,
+	2123,
+	2190,
+	2124,
+	2190,
+	2123,
+	2190,
+	2124,
+	2191,
+	2125,
+	2191,
+	2124,
+	2191,
+	2125,
+	2192,
+	2126,
+	2192,
+	2125,
+	2192,
+	2126,
+	2193,
+	2127,
+	2193,
+	2126,
+	2193,
+	2127,
+	2194,
+	2128,
+	2194,
+	2127,
+	2194,
+	2128,
+	2195,
+	2129,
+	2195,
+	2128,
+	2195,
+	2129,
+	2196,
+	2130,
+	2196,
+	2129,
+	2196,
+	2130,
+	2197,
+	2131,
+	2197,
+	2130,
+	2197,
+	2131,
+	2198,
+	2132,
+	2198,
+	2131,
+	2198,
+	2132,
+	2199,
+	2133,
+	2199,
+	2132,
+	2199,
+	2133,
+	2200,
+	2134,
+	2200,
+	2133,
+	2200,
+	2134,
+	2201,
+	2135,
+	2201,
+	2134,
+	2201,
+	2135,
+	2202,
+	2136,
+	2202,
+	2135,
+	2202,
+	2136,
+	2203,
+	2137,
+	2203,
+	2136,
+	2203,
+	2137,
+	2204,
+	2138,
+	2204,
+	2137,
+	2204,
+	2138,
+	2205,
+	2139,
+	2205,
+	2138,
+	2205,
+	2139,
+	2206,
+	2140,
+	2206,
+	2139,
+	2206,
+	2140,
+	2207,
+	2141,
+	2207,
+	2140,
+	2207,
+	2141,
+	2208,
+	2142,
+	2208,
+	2141,
+	2208,
+	2142,
+	2209,
+	2143,
+	2209,
+	2142,
+	2209,
+	2143,
+	2210,
+	2144,
+	2210,
+	2143,
+	2210,
+	2144,
+	2211,
+	2145,
+	2211,
+	2144,
+	2211,
+	2145,
+	2212,
+	2146,
+	2212,
+	2145,
+	2212,
+	2146,
+	2213,
+	2147,
+	2213,
+	2146,
+	2213,
+	2147,
+	2214,
+	2148,
+	2214,
+	2147,
+	2214,
+	2148,
+	2215,
+	2149,
+	2215,
+	2148,
+	2215,
+	2149,
+	2216,
+	2150,
+	2216,
+	2149,
+	2216,
+	2150,
+	2217,
+	2151,
+	2217,
+	2150,
+	2217,
+	2151,
+	2218,
+	2152,
+	2218,
+	2151,
+	2218,
+	2152,
+	2219,
+	2153,
+	2219,
+	2152,
+	2219,
+	2153,
+	2220,
+	2154,
+	2220,
+	2153,
+	2220,
+	2154,
+	2221,
+	2155,
+	2221,
+	2154,
+	2221,
+	2155,
+	2222,
+	2156,
+	2222,
+	2155,
+	2222,
+	2156,
+	2223,
+	2157,
+	2223,
+	2156,
+	2223,
+	2157,
+	2224,
+	2158,
+	2224,
+	2157,
+	2224,
+	2158,
+	2225,
+	2159,
+	2225,
+	2158,
+	2225,
+	2159,
+	2226,
+	2160,
+	2226,
+	2159,
+	2226,
+	2160,
+	2227,
+	2161,
+	2227,
+	2160,
+	2227,
+	2161,
+	2228,
+	2162,
+	2228,
+	2161,
+	2228,
+	2162,
+	2229,
+	2163,
+	2229,
+	2162,
+	2229,
+	2163,
+	2230,
+	2164,
+	2230,
+	2163,
+	2230,
+	2164,
+	2231,
+	2165,
+	2231,
+	2164,
+	2231,
+	2165,
+	2232,
+	2166,
+	2232,
+	2165,
+	2232,
+	2166,
+	2233,
+	2167,
+	2233,
+	2166,
+	2233,
+	2167,
+	2234,
+	2168,
+	2234,
+	2167,
+	2234,
+	2168,
+	2235,
+	2169,
+	2235,
+	2168,
+	2235,
+	2169,
+	2236,
+	2170,
+	2236,
+	2169,
+	2236,
+	2170,
+	2237,
+	2171,
+	2237,
+	2170,
+	2237,
+	2171,
+	2238,
+	2172,
+	2238,
+	2171,
+	2238,
+	2172,
+	2239,
+	2173,
+	2239,
+	2172,
+	2239,
+	2173,
+	2240,
+	2174,
+	2240,
+	2173,
+	2240,
+	2174,
+	2241,
+	2175,
+	2241,
+	2174,
+	2241,
+	2175,
+	2242,
+	2176,
+	2242,
+	2175,
+	2242,
+	2176,
+	2243,
+	2177,
+	2243,
+	2176,
+	2244,
+	2178,
+	2245,
+	2179,
+	2245,
+	2178,
+	2245,
+	2179,
+	2246,
+	2180,
+	2246,
+	2179,
+	2246,
+	2180,
+	2247,
+	2181,
+	2247,
+	2180,
+	2247,
+	2181,
+	2248,
+	2182,
+	2248,
+	2181,
+	2248,
+	2182,
+	2249,
+	2183,
+	2249,
+	2182,
+	2249,
+	2183,
+	2250,
+	2184,
+	2250,
+	2183,
+	2250,
+	2184,
+	2251,
+	2185,
+	2251,
+	2184,
+	2251,
+	2185,
+	2252,
+	2186,
+	2252,
+	2185,
+	2252,
+	2186,
+	2253,
+	2187,
+	2253,
+	2186,
+	2253,
+	2187,
+	2254,
+	2188,
+	2254,
+	2187,
+	2254,
+	2188,
+	2255,
+	2189,
+	2255,
+	2188,
+	2255,
+	2189,
+	2256,
+	2190,
+	2256,
+	2189,
+	2256,
+	2190,
+	2257,
+	2191,
+	2257,
+	2190,
+	2257,
+	2191,
+	2258,
+	2192,
+	2258,
+	2191,
+	2258,
+	2192,
+	2259,
+	2193,
+	2259,
+	2192,
+	2259,
+	2193,
+	2260,
+	2194,
+	2260,
+	2193,
+	2260,
+	2194,
+	2261,
+	2195,
+	2261,
+	2194,
+	2261,
+	2195,
+	2262,
+	2196,
+	2262,
+	2195,
+	2262,
+	2196,
+	2263,
+	2197,
+	2263,
+	2196,
+	2263,
+	2197,
+	2264,
+	2198,
+	2264,
+	2197,
+	2264,
+	2198,
+	2265,
+	2199,
+	2265,
+	2198,
+	2265,
+	2199,
+	2266,
+	2200,
+	2266,
+	2199,
+	2266,
+	2200,
+	2267,
+	2201,
+	2267,
+	2200,
+	2267,
+	2201,
+	2268,
+	2202,
+	2268,
+	2201,
+	2268,
+	2202,
+	2269,
+	2203,
+	2269,
+	2202,
+	2269,
+	2203,
+	2270,
+	2204,
+	2270,
+	2203,
+	2270,
+	2204,
+	2271,
+	2205,
+	2271,
+	2204,
+	2271,
+	2205,
+	2272,
+	2206,
+	2272,
+	2205,
+	2272,
+	2206,
+	2273,
+	2207,
+	2273,
+	2206,
+	2273,
+	2207,
+	2274,
+	2208,
+	2274,
+	2207,
+	2274,
+	2208,
+	2275,
+	2209,
+	2275,
+	2208,
+	2275,
+	2209,
+	2276,
+	2210,
+	2276,
+	2209,
+	2276,
+	2210,
+	2277,
+	2211,
+	2277,
+	2210,
+	2277,
+	2211,
+	2278,
+	2212,
+	2278,
+	2211,
+	2278,
+	2212,
+	2279,
+	2213,
+	2279,
+	2212,
+	2279,
+	2213,
+	2280,
+	2214,
+	2280,
+	2213,
+	2280,
+	2214,
+	2281,
+	2215,
+	2281,
+	2214,
+	2281,
+	2215,
+	2282,
+	2216,
+	2282,
+	2215,
+	2282,
+	2216,
+	2283,
+	2217,
+	2283,
+	2216,
+	2283,
+	2217,
+	2284,
+	2218,
+	2284,
+	2217,
+	2284,
+	2218,
+	2285,
+	2219,
+	2285,
+	2218,
+	2285,
+	2219,
+	2286,
+	2220,
+	2286,
+	2219,
+	2286,
+	2220,
+	2287,
+	2221,
+	2287,
+	2220,
+	2287,
+	2221,
+	2288,
+	2222,
+	2288,
+	2221,
+	2288,
+	2222,
+	2289,
+	2223,
+	2289,
+	2222,
+	2289,
+	2223,
+	2290,
+	2224,
+	2290,
+	2223,
+	2290,
+	2224,
+	2291,
+	2225,
+	2291,
+	2224,
+	2291,
+	2225,
+	2292,
+	2226,
+	2292,
+	2225,
+	2292,
+	2226,
+	2293,
+	2227,
+	2293,
+	2226,
+	2293,
+	2227,
+	2294,
+	2228,
+	2294,
+	2227,
+	2294,
+	2228,
+	2295,
+	2229,
+	2295,
+	2228,
+	2295,
+	2229,
+	2296,
+	2230,
+	2296,
+	2229,
+	2296,
+	2230,
+	2297,
+	2231,
+	2297,
+	2230,
+	2297,
+	2231,
+	2298,
+	2232,
+	2298,
+	2231,
+	2298,
+	2232,
+	2299,
+	2233,
+	2299,
+	2232,
+	2299,
+	2233,
+	2300,
+	2234,
+	2300,
+	2233,
+	2300,
+	2234,
+	2301,
+	2235,
+	2301,
+	2234,
+	2301,
+	2235,
+	2302,
+	2236,
+	2302,
+	2235,
+	2302,
+	2236,
+	2303,
+	2237,
+	2303,
+	2236,
+	2303,
+	2237,
+	2304,
+	2238,
+	2304,
+	2237,
+	2304,
+	2238,
+	2305,
+	2239,
+	2305,
+	2238,
+	2305,
+	2239,
+	2306,
+	2240,
+	2306,
+	2239,
+	2306,
+	2240,
+	2307,
+	2241,
+	2307,
+	2240,
+	2307,
+	2241,
+	2308,
+	2242,
+	2308,
+	2241,
+	2308,
+	2242,
+	2309,
+	2243,
+	2309,
+	2242,
+};
+
+#define Landscape07VtxCount 2240
+#define Landscape07IdxCount 12852
+
+btScalar Landscape07Vtx[] = {
+	3.90625f,
+	49.6769f,
+	-121.094f,
+	3.90625f,
+	48.3887f,
+	-117.188f,
+	7.8125f,
+	48.8687f,
+	-121.094f,
+	7.8125f,
+	48.004f,
+	-117.188f,
+	11.7188f,
+	47.3453f,
+	-121.094f,
+	11.7188f,
+	46.8723f,
+	-117.188f,
+	15.625f,
+	44.9132f,
+	-121.094f,
+	15.625f,
+	45.5005f,
+	-117.188f,
+	19.5313f,
+	43.1526f,
+	-121.094f,
+	19.5313f,
+	43.3644f,
+	-117.188f,
+	23.4375f,
+	41.3946f,
+	-121.094f,
+	23.4375f,
+	42.3352f,
+	-117.188f,
+	27.3438f,
+	40.1349f,
+	-121.094f,
+	27.3438f,
+	41.1562f,
+	-117.188f,
+	31.25f,
+	39.2733f,
+	-121.094f,
+	31.25f,
+	39.1736f,
+	-117.188f,
+	35.1563f,
+	38.3718f,
+	-121.094f,
+	35.1563f,
+	38.0627f,
+	-117.188f,
+	39.0625f,
+	37.16f,
+	-121.094f,
+	39.0625f,
+	36.4728f,
+	-117.188f,
+	42.9688f,
+	35.2678f,
+	-121.094f,
+	42.9688f,
+	34.8001f,
+	-117.188f,
+	46.875f,
+	32.8529f,
+	-121.094f,
+	46.875f,
+	32.5103f,
+	-117.188f,
+	50.7813f,
+	32.0924f,
+	-121.094f,
+	50.7813f,
+	31.6328f,
+	-117.188f,
+	54.6875f,
+	33.2013f,
+	-121.094f,
+	54.6875f,
+	31.6106f,
+	-117.188f,
+	58.5938f,
+	34.1499f,
+	-121.094f,
+	58.5938f,
+	32.3004f,
+	-117.188f,
+	62.5f,
+	33.7675f,
+	-121.094f,
+	62.5f,
+	32.696f,
+	-117.188f,
+	66.4063f,
+	34.4892f,
+	-121.094f,
+	66.4063f,
+	33.3795f,
+	-117.188f,
+	70.3125f,
+	34.7441f,
+	-121.094f,
+	70.3125f,
+	33.9696f,
+	-117.188f,
+	74.2188f,
+	35.4435f,
+	-121.094f,
+	74.2188f,
+	34.9211f,
+	-117.188f,
+	78.125f,
+	36.6876f,
+	-121.094f,
+	78.125f,
+	36.7686f,
+	-117.188f,
+	82.0313f,
+	37.8831f,
+	-121.094f,
+	82.0313f,
+	37.7676f,
+	-117.188f,
+	85.9375f,
+	37.8533f,
+	-121.094f,
+	85.9375f,
+	37.8174f,
+	-117.188f,
+	89.8438f,
+	38.2467f,
+	-121.094f,
+	89.8438f,
+	38.2878f,
+	-117.188f,
+	93.75f,
+	39.5884f,
+	-121.094f,
+	93.75f,
+	39.6151f,
+	-117.188f,
+	97.6563f,
+	39.7164f,
+	-121.094f,
+	97.6563f,
+	39.7422f,
+	-117.188f,
+	101.563f,
+	40.296f,
+	-121.094f,
+	101.563f,
+	40.9611f,
+	-117.188f,
+	105.469f,
+	40.7222f,
+	-121.094f,
+	105.469f,
+	40.8932f,
+	-117.188f,
+	109.375f,
+	40.1304f,
+	-121.094f,
+	109.375f,
+	40.6603f,
+	-117.188f,
+	113.281f,
+	39.4566f,
+	-121.094f,
+	113.281f,
+	40.2935f,
+	-117.188f,
+	117.188f,
+	39.003f,
+	-121.094f,
+	117.188f,
+	39.8681f,
+	-117.188f,
+	121.094f,
+	38.091f,
+	-121.094f,
+	121.094f,
+	39.0965f,
+	-117.188f,
+	125.0f,
+	37.216f,
+	-121.094f,
+	125.0f,
+	37.1333f,
+	-117.188f,
+	128.906f,
+	35.4631f,
+	-121.094f,
+	128.906f,
+	35.5222f,
+	-117.188f,
+	132.813f,
+	33.4698f,
+	-121.094f,
+	132.813f,
+	33.9068f,
+	-117.188f,
+	136.719f,
+	31.5516f,
+	-121.094f,
+	136.719f,
+	32.2618f,
+	-117.188f,
+	140.625f,
+	28.6676f,
+	-121.094f,
+	140.625f,
+	29.8657f,
+	-117.188f,
+	144.531f,
+	26.5656f,
+	-121.094f,
+	144.531f,
+	28.1704f,
+	-117.188f,
+	148.438f,
+	24.1962f,
+	-121.094f,
+	148.438f,
+	27.1495f,
+	-117.188f,
+	152.344f,
+	22.2193f,
+	-121.094f,
+	152.344f,
+	24.5217f,
+	-117.188f,
+	156.25f,
+	20.1818f,
+	-121.094f,
+	156.25f,
+	22.0419f,
+	-117.188f,
+	160.156f,
+	17.6116f,
+	-121.094f,
+	160.156f,
+	19.9238f,
+	-117.188f,
+	164.063f,
+	15.5398f,
+	-121.094f,
+	164.063f,
+	17.6875f,
+	-117.188f,
+	167.969f,
+	13.7972f,
+	-121.094f,
+	167.969f,
+	15.5636f,
+	-117.188f,
+	171.875f,
+	11.7291f,
+	-121.094f,
+	171.875f,
+	13.5497f,
+	-117.188f,
+	175.781f,
+	9.31738f,
+	-121.094f,
+	175.781f,
+	11.2761f,
+	-117.188f,
+	179.688f,
+	6.60425f,
+	-121.094f,
+	179.688f,
+	8.95864f,
+	-117.188f,
+	183.594f,
+	4.50127f,
+	-121.094f,
+	183.594f,
+	7.04623f,
+	-117.188f,
+	187.5f,
+	2.77579f,
+	-121.094f,
+	187.5f,
+	4.83635f,
+	-117.188f,
+	191.406f,
+	1.39292f,
+	-121.094f,
+	191.406f,
+	2.76046f,
+	-117.188f,
+	195.313f,
+	-1.41093f,
+	-121.094f,
+	195.313f,
+	0.190119f,
+	-117.188f,
+	199.219f,
+	-2.1383f,
+	-121.094f,
+	199.219f,
+	-0.558379f,
+	-117.188f,
+	203.125f,
+	-2.43203f,
+	-121.094f,
+	203.125f,
+	-1.03303f,
+	-117.188f,
+	207.031f,
+	-3.74398f,
+	-121.094f,
+	207.031f,
+	-2.17563f,
+	-117.188f,
+	210.938f,
+	-4.31531f,
+	-121.094f,
+	210.938f,
+	-1.91155f,
+	-117.188f,
+	214.844f,
+	-5.42965f,
+	-121.094f,
+	214.844f,
+	-3.00018f,
+	-117.188f,
+	218.75f,
+	-6.70056f,
+	-121.094f,
+	218.75f,
+	-4.26691f,
+	-117.188f,
+	222.656f,
+	-6.19564f,
+	-121.094f,
+	222.656f,
+	-5.15855f,
+	-117.188f,
+	226.563f,
+	-4.68254f,
+	-121.094f,
+	226.563f,
+	-3.46348f,
+	-117.188f,
+	230.469f,
+	-3.31858f,
+	-121.094f,
+	230.469f,
+	-2.16077f,
+	-117.188f,
+	234.375f,
+	-3.88428f,
+	-121.094f,
+	234.375f,
+	-1.47785f,
+	-117.188f,
+	238.281f,
+	-3.80321f,
+	-121.094f,
+	238.281f,
+	-1.78424f,
+	-117.188f,
+	242.188f,
+	-3.43571f,
+	-121.094f,
+	242.188f,
+	-1.00317f,
+	-117.188f,
+	246.094f,
+	-3.77556f,
+	-121.094f,
+	246.094f,
+	-1.97981f,
+	-117.188f,
+	250.0f,
+	-3.83169f,
+	-121.094f,
+	250.0f,
+	-2.29372f,
+	-117.188f,
+	3.90625f,
+	50.3021f,
+	-125.0f,
+	7.8125f,
+	50.0186f,
+	-125.0f,
+	11.7188f,
+	47.8026f,
+	-125.0f,
+	15.625f,
+	45.4122f,
+	-125.0f,
+	19.5313f,
+	42.7204f,
+	-125.0f,
+	23.4375f,
+	42.1093f,
+	-125.0f,
+	27.3438f,
+	41.0672f,
+	-125.0f,
+	31.25f,
+	40.3016f,
+	-125.0f,
+	35.1563f,
+	38.401f,
+	-125.0f,
+	39.0625f,
+	36.5811f,
+	-125.0f,
+	42.9688f,
+	35.0771f,
+	-125.0f,
+	46.875f,
+	32.9255f,
+	-125.0f,
+	50.7813f,
+	31.2736f,
+	-125.0f,
+	54.6875f,
+	33.4622f,
+	-125.0f,
+	58.5938f,
+	34.314f,
+	-125.0f,
+	62.5f,
+	34.4185f,
+	-125.0f,
+	66.4063f,
+	34.621f,
+	-125.0f,
+	70.3125f,
+	34.9532f,
+	-125.0f,
+	74.2188f,
+	35.7305f,
+	-125.0f,
+	78.125f,
+	37.4446f,
+	-125.0f,
+	82.0313f,
+	37.6824f,
+	-125.0f,
+	85.9375f,
+	37.9835f,
+	-125.0f,
+	89.8438f,
+	38.5713f,
+	-125.0f,
+	93.75f,
+	39.56f,
+	-125.0f,
+	97.6563f,
+	40.0645f,
+	-125.0f,
+	101.563f,
+	39.9237f,
+	-125.0f,
+	105.469f,
+	39.8912f,
+	-125.0f,
+	109.375f,
+	39.9678f,
+	-125.0f,
+	113.281f,
+	39.7665f,
+	-125.0f,
+	117.188f,
+	38.758f,
+	-125.0f,
+	121.094f,
+	37.6738f,
+	-125.0f,
+	125.0f,
+	36.834f,
+	-125.0f,
+	128.906f,
+	34.7637f,
+	-125.0f,
+	132.813f,
+	31.9691f,
+	-125.0f,
+	136.719f,
+	30.7311f,
+	-125.0f,
+	140.625f,
+	27.9768f,
+	-125.0f,
+	144.531f,
+	25.22f,
+	-125.0f,
+	148.438f,
+	22.2616f,
+	-125.0f,
+	152.344f,
+	20.6399f,
+	-125.0f,
+	156.25f,
+	18.9363f,
+	-125.0f,
+	160.156f,
+	16.8778f,
+	-125.0f,
+	164.063f,
+	14.7425f,
+	-125.0f,
+	167.969f,
+	12.4299f,
+	-125.0f,
+	171.875f,
+	10.1017f,
+	-125.0f,
+	175.781f,
+	7.82169f,
+	-125.0f,
+	179.688f,
+	5.46502f,
+	-125.0f,
+	183.594f,
+	2.71076f,
+	-125.0f,
+	187.5f,
+	1.07736f,
+	-125.0f,
+	191.406f,
+	-0.592638f,
+	-125.0f,
+	195.313f,
+	-2.99173f,
+	-125.0f,
+	199.219f,
+	-4.30517f,
+	-125.0f,
+	203.125f,
+	-4.79591f,
+	-125.0f,
+	207.031f,
+	-6.32671f,
+	-125.0f,
+	210.938f,
+	-6.6914f,
+	-125.0f,
+	214.844f,
+	-8.34188f,
+	-125.0f,
+	218.75f,
+	-8.94371f,
+	-125.0f,
+	222.656f,
+	-7.16417f,
+	-125.0f,
+	226.563f,
+	-5.53904f,
+	-125.0f,
+	230.469f,
+	-5.10207f,
+	-125.0f,
+	234.375f,
+	-5.77507f,
+	-125.0f,
+	238.281f,
+	-5.5948f,
+	-125.0f,
+	242.188f,
+	-5.81224f,
+	-125.0f,
+	246.094f,
+	-5.48291f,
+	-125.0f,
+	250.0f,
+	-5.3221f,
+	-125.0f,
+	3.90625f,
+	50.4716f,
+	-128.906f,
+	7.8125f,
+	50.3922f,
+	-128.906f,
+	11.7188f,
+	48.0997f,
+	-128.906f,
+	15.625f,
+	44.9895f,
+	-128.906f,
+	19.5313f,
+	43.3038f,
+	-128.906f,
+	23.4375f,
+	42.8795f,
+	-128.906f,
+	27.3438f,
+	42.0905f,
+	-128.906f,
+	31.25f,
+	40.0566f,
+	-128.906f,
+	35.1563f,
+	37.7024f,
+	-128.906f,
+	39.0625f,
+	35.7533f,
+	-128.906f,
+	42.9688f,
+	32.9949f,
+	-128.906f,
+	46.875f,
+	31.7476f,
+	-128.906f,
+	50.7813f,
+	30.9413f,
+	-128.906f,
+	54.6875f,
+	31.9364f,
+	-128.906f,
+	58.5938f,
+	33.2028f,
+	-128.906f,
+	62.5f,
+	34.0103f,
+	-128.906f,
+	66.4063f,
+	34.3126f,
+	-128.906f,
+	70.3125f,
+	34.6096f,
+	-128.906f,
+	74.2188f,
+	35.8861f,
+	-128.906f,
+	78.125f,
+	36.5754f,
+	-128.906f,
+	82.0313f,
+	36.9009f,
+	-128.906f,
+	85.9375f,
+	37.369f,
+	-128.906f,
+	89.8438f,
+	38.2734f,
+	-128.906f,
+	93.75f,
+	38.7518f,
+	-128.906f,
+	97.6563f,
+	39.7576f,
+	-128.906f,
+	101.563f,
+	39.3413f,
+	-128.906f,
+	105.469f,
+	40.4224f,
+	-128.906f,
+	109.375f,
+	40.506f,
+	-128.906f,
+	113.281f,
+	39.7509f,
+	-128.906f,
+	117.188f,
+	38.6208f,
+	-128.906f,
+	121.094f,
+	37.1513f,
+	-128.906f,
+	125.0f,
+	36.003f,
+	-128.906f,
+	128.906f,
+	34.1307f,
+	-128.906f,
+	132.813f,
+	31.5523f,
+	-128.906f,
+	136.719f,
+	29.2003f,
+	-128.906f,
+	140.625f,
+	26.3718f,
+	-128.906f,
+	144.531f,
+	24.0851f,
+	-128.906f,
+	148.438f,
+	21.0492f,
+	-128.906f,
+	152.344f,
+	18.9709f,
+	-128.906f,
+	156.25f,
+	16.5536f,
+	-128.906f,
+	160.156f,
+	14.5588f,
+	-128.906f,
+	164.063f,
+	12.8386f,
+	-128.906f,
+	167.969f,
+	11.3092f,
+	-128.906f,
+	171.875f,
+	9.19396f,
+	-128.906f,
+	175.781f,
+	6.84617f,
+	-128.906f,
+	179.688f,
+	3.80062f,
+	-128.906f,
+	183.594f,
+	0.734751f,
+	-128.906f,
+	187.5f,
+	0.121523f,
+	-128.906f,
+	191.406f,
+	-1.9203f,
+	-128.906f,
+	195.313f,
+	-5.35291f,
+	-128.906f,
+	199.219f,
+	-7.06575f,
+	-128.906f,
+	203.125f,
+	-8.27325f,
+	-128.906f,
+	207.031f,
+	-8.82541f,
+	-128.906f,
+	210.938f,
+	-9.36185f,
+	-128.906f,
+	214.844f,
+	-10.8597f,
+	-128.906f,
+	218.75f,
+	-10.695f,
+	-128.906f,
+	222.656f,
+	-8.91012f,
+	-128.906f,
+	226.563f,
+	-8.24825f,
+	-128.906f,
+	230.469f,
+	-7.79624f,
+	-128.906f,
+	234.375f,
+	-6.74578f,
+	-128.906f,
+	238.281f,
+	-7.41285f,
+	-128.906f,
+	242.188f,
+	-7.01421f,
+	-128.906f,
+	246.094f,
+	-6.91669f,
+	-128.906f,
+	250.0f,
+	-6.09876f,
+	-128.906f,
+	3.90625f,
+	49.1054f,
+	-132.813f,
+	7.8125f,
+	48.771f,
+	-132.813f,
+	11.7188f,
+	46.9765f,
+	-132.813f,
+	15.625f,
+	44.4736f,
+	-132.813f,
+	19.5313f,
+	43.2026f,
+	-132.813f,
+	23.4375f,
+	42.2898f,
+	-132.813f,
+	27.3438f,
+	41.7492f,
+	-132.813f,
+	31.25f,
+	39.5792f,
+	-132.813f,
+	35.1563f,
+	36.5653f,
+	-132.813f,
+	39.0625f,
+	33.5612f,
+	-132.813f,
+	42.9688f,
+	31.9604f,
+	-132.813f,
+	46.875f,
+	30.953f,
+	-132.813f,
+	50.7813f,
+	30.5912f,
+	-132.813f,
+	54.6875f,
+	31.76f,
+	-132.813f,
+	58.5938f,
+	33.0843f,
+	-132.813f,
+	62.5f,
+	33.4323f,
+	-132.813f,
+	66.4063f,
+	33.9264f,
+	-132.813f,
+	70.3125f,
+	33.9268f,
+	-132.813f,
+	74.2188f,
+	33.8122f,
+	-132.813f,
+	78.125f,
+	34.9456f,
+	-132.813f,
+	82.0313f,
+	35.6308f,
+	-132.813f,
+	85.9375f,
+	35.8317f,
+	-132.813f,
+	89.8438f,
+	36.8255f,
+	-132.813f,
+	93.75f,
+	37.5781f,
+	-132.813f,
+	97.6563f,
+	39.0469f,
+	-132.813f,
+	101.563f,
+	38.905f,
+	-132.813f,
+	105.469f,
+	39.3656f,
+	-132.813f,
+	109.375f,
+	39.9706f,
+	-132.813f,
+	113.281f,
+	38.8077f,
+	-132.813f,
+	117.188f,
+	37.8378f,
+	-132.813f,
+	121.094f,
+	36.8368f,
+	-132.813f,
+	125.0f,
+	35.8474f,
+	-132.813f,
+	128.906f,
+	33.8502f,
+	-132.813f,
+	132.813f,
+	31.6251f,
+	-132.813f,
+	136.719f,
+	28.2781f,
+	-132.813f,
+	140.625f,
+	24.9841f,
+	-132.813f,
+	144.531f,
+	22.2281f,
+	-132.813f,
+	148.438f,
+	19.2974f,
+	-132.813f,
+	152.344f,
+	17.1516f,
+	-132.813f,
+	156.25f,
+	14.7654f,
+	-132.813f,
+	160.156f,
+	13.1833f,
+	-132.813f,
+	164.063f,
+	11.0184f,
+	-132.813f,
+	167.969f,
+	9.1589f,
+	-132.813f,
+	171.875f,
+	6.82631f,
+	-132.813f,
+	175.781f,
+	4.30633f,
+	-132.813f,
+	179.688f,
+	2.04751f,
+	-132.813f,
+	183.594f,
+	-0.74554f,
+	-132.813f,
+	187.5f,
+	-1.24688f,
+	-132.813f,
+	191.406f,
+	-3.70884f,
+	-132.813f,
+	195.313f,
+	-7.20423f,
+	-132.813f,
+	199.219f,
+	-9.63057f,
+	-132.813f,
+	203.125f,
+	-10.6411f,
+	-132.813f,
+	207.031f,
+	-11.1561f,
+	-132.813f,
+	210.938f,
+	-11.9998f,
+	-132.813f,
+	214.844f,
+	-13.1369f,
+	-132.813f,
+	218.75f,
+	-12.4543f,
+	-132.813f,
+	222.656f,
+	-11.5031f,
+	-132.813f,
+	226.563f,
+	-11.4632f,
+	-132.813f,
+	230.469f,
+	-10.5609f,
+	-132.813f,
+	234.375f,
+	-9.96017f,
+	-132.813f,
+	238.281f,
+	-9.64047f,
+	-132.813f,
+	242.188f,
+	-8.79112f,
+	-132.813f,
+	246.094f,
+	-8.33514f,
+	-132.813f,
+	250.0f,
+	-6.32649f,
+	-132.813f,
+	3.90625f,
+	47.9f,
+	-136.719f,
+	7.8125f,
+	47.0423f,
+	-136.719f,
+	11.7188f,
+	46.1087f,
+	-136.719f,
+	15.625f,
+	42.8209f,
+	-136.719f,
+	19.5313f,
+	41.8846f,
+	-136.719f,
+	23.4375f,
+	41.4071f,
+	-136.719f,
+	27.3438f,
+	39.6798f,
+	-136.719f,
+	31.25f,
+	38.1881f,
+	-136.719f,
+	35.1563f,
+	35.3952f,
+	-136.719f,
+	39.0625f,
+	31.8297f,
+	-136.719f,
+	42.9688f,
+	31.014f,
+	-136.719f,
+	46.875f,
+	29.29f,
+	-136.719f,
+	50.7813f,
+	29.4455f,
+	-136.719f,
+	54.6875f,
+	30.368f,
+	-136.719f,
+	58.5938f,
+	31.6261f,
+	-136.719f,
+	62.5f,
+	31.8803f,
+	-136.719f,
+	66.4063f,
+	32.8102f,
+	-136.719f,
+	70.3125f,
+	33.4331f,
+	-136.719f,
+	74.2188f,
+	33.19f,
+	-136.719f,
+	78.125f,
+	33.74f,
+	-136.719f,
+	82.0313f,
+	35.1047f,
+	-136.719f,
+	85.9375f,
+	36.2436f,
+	-136.719f,
+	89.8438f,
+	36.4928f,
+	-136.719f,
+	93.75f,
+	36.192f,
+	-136.719f,
+	97.6563f,
+	37.547f,
+	-136.719f,
+	101.563f,
+	38.0632f,
+	-136.719f,
+	105.469f,
+	38.6551f,
+	-136.719f,
+	109.375f,
+	38.4484f,
+	-136.719f,
+	113.281f,
+	37.8421f,
+	-136.719f,
+	117.188f,
+	37.5588f,
+	-136.719f,
+	121.094f,
+	37.278f,
+	-136.719f,
+	125.0f,
+	35.3541f,
+	-136.719f,
+	128.906f,
+	33.0939f,
+	-136.719f,
+	132.813f,
+	30.522f,
+	-136.719f,
+	136.719f,
+	27.5957f,
+	-136.719f,
+	140.625f,
+	24.4595f,
+	-136.719f,
+	144.531f,
+	21.0335f,
+	-136.719f,
+	148.438f,
+	18.0163f,
+	-136.719f,
+	152.344f,
+	15.3659f,
+	-136.719f,
+	156.25f,
+	13.4036f,
+	-136.719f,
+	160.156f,
+	11.6819f,
+	-136.719f,
+	164.063f,
+	9.68686f,
+	-136.719f,
+	167.969f,
+	7.56782f,
+	-136.719f,
+	171.875f,
+	4.49435f,
+	-136.719f,
+	175.781f,
+	1.55284f,
+	-136.719f,
+	179.688f,
+	0.275057f,
+	-136.719f,
+	183.594f,
+	-2.20168f,
+	-136.719f,
+	187.5f,
+	-3.16842f,
+	-136.719f,
+	191.406f,
+	-5.74212f,
+	-136.719f,
+	195.313f,
+	-8.33918f,
+	-136.719f,
+	199.219f,
+	-11.9926f,
+	-136.719f,
+	203.125f,
+	-13.7382f,
+	-136.719f,
+	207.031f,
+	-14.2163f,
+	-136.719f,
+	210.938f,
+	-14.76f,
+	-136.719f,
+	214.844f,
+	-14.7917f,
+	-136.719f,
+	218.75f,
+	-15.4594f,
+	-136.719f,
+	222.656f,
+	-14.7722f,
+	-136.719f,
+	226.563f,
+	-14.7687f,
+	-136.719f,
+	230.469f,
+	-13.0502f,
+	-136.719f,
+	234.375f,
+	-12.7522f,
+	-136.719f,
+	238.281f,
+	-12.1277f,
+	-136.719f,
+	242.188f,
+	-11.9805f,
+	-136.719f,
+	246.094f,
+	-9.26664f,
+	-136.719f,
+	250.0f,
+	-6.42671f,
+	-136.719f,
+	3.90625f,
+	47.2681f,
+	-140.625f,
+	7.8125f,
+	46.3513f,
+	-140.625f,
+	11.7188f,
+	45.1181f,
+	-140.625f,
+	15.625f,
+	42.9593f,
+	-140.625f,
+	19.5313f,
+	40.04f,
+	-140.625f,
+	23.4375f,
+	38.1657f,
+	-140.625f,
+	27.3438f,
+	37.2537f,
+	-140.625f,
+	31.25f,
+	35.6767f,
+	-140.625f,
+	35.1563f,
+	33.3413f,
+	-140.625f,
+	39.0625f,
+	30.7556f,
+	-140.625f,
+	42.9688f,
+	29.0258f,
+	-140.625f,
+	46.875f,
+	27.8122f,
+	-140.625f,
+	50.7813f,
+	27.4512f,
+	-140.625f,
+	54.6875f,
+	28.1912f,
+	-140.625f,
+	58.5938f,
+	29.8142f,
+	-140.625f,
+	62.5f,
+	30.1394f,
+	-140.625f,
+	66.4063f,
+	30.7105f,
+	-140.625f,
+	70.3125f,
+	31.9295f,
+	-140.625f,
+	74.2188f,
+	32.6689f,
+	-140.625f,
+	78.125f,
+	32.9232f,
+	-140.625f,
+	82.0313f,
+	35.5221f,
+	-140.625f,
+	85.9375f,
+	36.1785f,
+	-140.625f,
+	89.8438f,
+	35.864f,
+	-140.625f,
+	93.75f,
+	35.2473f,
+	-140.625f,
+	97.6563f,
+	35.6334f,
+	-140.625f,
+	101.563f,
+	36.5759f,
+	-140.625f,
+	105.469f,
+	37.2506f,
+	-140.625f,
+	109.375f,
+	36.7249f,
+	-140.625f,
+	113.281f,
+	36.4287f,
+	-140.625f,
+	117.188f,
+	36.6819f,
+	-140.625f,
+	121.094f,
+	36.4294f,
+	-140.625f,
+	125.0f,
+	35.2358f,
+	-140.625f,
+	128.906f,
+	32.9869f,
+	-140.625f,
+	132.813f,
+	30.156f,
+	-140.625f,
+	136.719f,
+	27.0471f,
+	-140.625f,
+	140.625f,
+	23.8554f,
+	-140.625f,
+	144.531f,
+	20.3993f,
+	-140.625f,
+	148.438f,
+	16.6224f,
+	-140.625f,
+	152.344f,
+	13.058f,
+	-140.625f,
+	156.25f,
+	11.1345f,
+	-140.625f,
+	160.156f,
+	9.35133f,
+	-140.625f,
+	164.063f,
+	7.36194f,
+	-140.625f,
+	167.969f,
+	5.31819f,
+	-140.625f,
+	171.875f,
+	2.78652f,
+	-140.625f,
+	175.781f,
+	0.868982f,
+	-140.625f,
+	179.688f,
+	-1.31465f,
+	-140.625f,
+	183.594f,
+	-3.64199f,
+	-140.625f,
+	187.5f,
+	-5.38333f,
+	-140.625f,
+	191.406f,
+	-8.08251f,
+	-140.625f,
+	195.313f,
+	-10.9184f,
+	-140.625f,
+	199.219f,
+	-14.2737f,
+	-140.625f,
+	203.125f,
+	-16.1495f,
+	-140.625f,
+	207.031f,
+	-16.9134f,
+	-140.625f,
+	210.938f,
+	-16.9575f,
+	-140.625f,
+	214.844f,
+	-17.6023f,
+	-140.625f,
+	218.75f,
+	-17.6633f,
+	-140.625f,
+	222.656f,
+	-17.159f,
+	-140.625f,
+	226.563f,
+	-16.2062f,
+	-140.625f,
+	230.469f,
+	-15.7685f,
+	-140.625f,
+	234.375f,
+	-15.0547f,
+	-140.625f,
+	238.281f,
+	-14.7858f,
+	-140.625f,
+	242.188f,
+	-12.8534f,
+	-140.625f,
+	246.094f,
+	-9.20599f,
+	-140.625f,
+	250.0f,
+	-5.60644f,
+	-140.625f,
+	3.90625f,
+	45.2398f,
+	-144.531f,
+	7.8125f,
+	45.0428f,
+	-144.531f,
+	11.7188f,
+	44.1179f,
+	-144.531f,
+	15.625f,
+	42.444f,
+	-144.531f,
+	19.5313f,
+	39.732f,
+	-144.531f,
+	23.4375f,
+	37.0479f,
+	-144.531f,
+	27.3438f,
+	34.3624f,
+	-144.531f,
+	31.25f,
+	33.2513f,
+	-144.531f,
+	35.1563f,
+	31.1146f,
+	-144.531f,
+	39.0625f,
+	29.2726f,
+	-144.531f,
+	42.9688f,
+	27.3159f,
+	-144.531f,
+	46.875f,
+	27.1241f,
+	-144.531f,
+	50.7813f,
+	26.6524f,
+	-144.531f,
+	54.6875f,
+	26.3337f,
+	-144.531f,
+	58.5938f,
+	27.8201f,
+	-144.531f,
+	62.5f,
+	27.8456f,
+	-144.531f,
+	66.4063f,
+	27.8306f,
+	-144.531f,
+	70.3125f,
+	29.8911f,
+	-144.531f,
+	74.2188f,
+	31.0667f,
+	-144.531f,
+	78.125f,
+	32.5778f,
+	-144.531f,
+	82.0313f,
+	34.5337f,
+	-144.531f,
+	85.9375f,
+	35.1457f,
+	-144.531f,
+	89.8438f,
+	34.7649f,
+	-144.531f,
+	93.75f,
+	34.0929f,
+	-144.531f,
+	97.6563f,
+	34.2934f,
+	-144.531f,
+	101.563f,
+	34.8046f,
+	-144.531f,
+	105.469f,
+	36.2496f,
+	-144.531f,
+	109.375f,
+	35.8351f,
+	-144.531f,
+	113.281f,
+	35.8228f,
+	-144.531f,
+	117.188f,
+	35.7495f,
+	-144.531f,
+	121.094f,
+	34.832f,
+	-144.531f,
+	125.0f,
+	34.3351f,
+	-144.531f,
+	128.906f,
+	32.4744f,
+	-144.531f,
+	132.813f,
+	29.6967f,
+	-144.531f,
+	136.719f,
+	26.263f,
+	-144.531f,
+	140.625f,
+	23.3556f,
+	-144.531f,
+	144.531f,
+	19.3517f,
+	-144.531f,
+	148.438f,
+	14.458f,
+	-144.531f,
+	152.344f,
+	11.2423f,
+	-144.531f,
+	156.25f,
+	9.75514f,
+	-144.531f,
+	160.156f,
+	7.96146f,
+	-144.531f,
+	164.063f,
+	5.67024f,
+	-144.531f,
+	167.969f,
+	4.08006f,
+	-144.531f,
+	171.875f,
+	1.71102f,
+	-144.531f,
+	175.781f,
+	-0.915369f,
+	-144.531f,
+	179.688f,
+	-2.66343f,
+	-144.531f,
+	183.594f,
+	-5.5816f,
+	-144.531f,
+	187.5f,
+	-7.79353f,
+	-144.531f,
+	191.406f,
+	-10.1772f,
+	-144.531f,
+	195.313f,
+	-13.5463f,
+	-144.531f,
+	199.219f,
+	-16.0692f,
+	-144.531f,
+	203.125f,
+	-17.2505f,
+	-144.531f,
+	207.031f,
+	-18.7241f,
+	-144.531f,
+	210.938f,
+	-18.7295f,
+	-144.531f,
+	214.844f,
+	-19.3f,
+	-144.531f,
+	218.75f,
+	-20.3181f,
+	-144.531f,
+	222.656f,
+	-19.4871f,
+	-144.531f,
+	226.563f,
+	-18.5465f,
+	-144.531f,
+	230.469f,
+	-17.525f,
+	-144.531f,
+	234.375f,
+	-16.5076f,
+	-144.531f,
+	238.281f,
+	-15.0993f,
+	-144.531f,
+	242.188f,
+	-13.0716f,
+	-144.531f,
+	246.094f,
+	-9.99063f,
+	-144.531f,
+	250.0f,
+	-5.64288f,
+	-144.531f,
+	3.90625f,
+	43.4167f,
+	-148.438f,
+	7.8125f,
+	43.0193f,
+	-148.438f,
+	11.7188f,
+	42.6242f,
+	-148.438f,
+	15.625f,
+	40.8831f,
+	-148.438f,
+	19.5313f,
+	38.6824f,
+	-148.438f,
+	23.4375f,
+	36.0177f,
+	-148.438f,
+	27.3438f,
+	32.9654f,
+	-148.438f,
+	31.25f,
+	31.3995f,
+	-148.438f,
+	35.1563f,
+	29.5101f,
+	-148.438f,
+	39.0625f,
+	27.4588f,
+	-148.438f,
+	42.9688f,
+	25.129f,
+	-148.438f,
+	46.875f,
+	25.4533f,
+	-148.438f,
+	50.7813f,
+	25.7106f,
+	-148.438f,
+	54.6875f,
+	25.737f,
+	-148.438f,
+	58.5938f,
+	26.1608f,
+	-148.438f,
+	62.5f,
+	27.2373f,
+	-148.438f,
+	66.4063f,
+	27.3635f,
+	-148.438f,
+	70.3125f,
+	27.7787f,
+	-148.438f,
+	74.2188f,
+	29.0906f,
+	-148.438f,
+	78.125f,
+	31.3992f,
+	-148.438f,
+	82.0313f,
+	32.9373f,
+	-148.438f,
+	85.9375f,
+	33.743f,
+	-148.438f,
+	89.8438f,
+	34.4265f,
+	-148.438f,
+	93.75f,
+	33.525f,
+	-148.438f,
+	97.6563f,
+	33.8231f,
+	-148.438f,
+	101.563f,
+	34.6826f,
+	-148.438f,
+	105.469f,
+	35.0275f,
+	-148.438f,
+	109.375f,
+	34.4667f,
+	-148.438f,
+	113.281f,
+	34.7266f,
+	-148.438f,
+	117.188f,
+	34.0788f,
+	-148.438f,
+	121.094f,
+	33.2521f,
+	-148.438f,
+	125.0f,
+	32.1914f,
+	-148.438f,
+	128.906f,
+	30.7782f,
+	-148.438f,
+	132.813f,
+	28.8615f,
+	-148.438f,
+	136.719f,
+	25.3691f,
+	-148.438f,
+	140.625f,
+	21.5786f,
+	-148.438f,
+	144.531f,
+	17.2969f,
+	-148.438f,
+	148.438f,
+	13.1925f,
+	-148.438f,
+	152.344f,
+	10.0632f,
+	-148.438f,
+	156.25f,
+	8.32421f,
+	-148.438f,
+	160.156f,
+	6.57856f,
+	-148.438f,
+	164.063f,
+	4.18522f,
+	-148.438f,
+	167.969f,
+	2.25091f,
+	-148.438f,
+	171.875f,
+	0.445952f,
+	-148.438f,
+	175.781f,
+	-1.73703f,
+	-148.438f,
+	179.688f,
+	-3.44886f,
+	-148.438f,
+	183.594f,
+	-6.77108f,
+	-148.438f,
+	187.5f,
+	-9.26031f,
+	-148.438f,
+	191.406f,
+	-12.38f,
+	-148.438f,
+	195.313f,
+	-14.6453f,
+	-148.438f,
+	199.219f,
+	-15.8435f,
+	-148.438f,
+	203.125f,
+	-17.3242f,
+	-148.438f,
+	207.031f,
+	-19.3932f,
+	-148.438f,
+	210.938f,
+	-19.7735f,
+	-148.438f,
+	214.844f,
+	-20.1293f,
+	-148.438f,
+	218.75f,
+	-20.5777f,
+	-148.438f,
+	222.656f,
+	-20.7145f,
+	-148.438f,
+	226.563f,
+	-20.64f,
+	-148.438f,
+	230.469f,
+	-19.6971f,
+	-148.438f,
+	234.375f,
+	-17.5016f,
+	-148.438f,
+	238.281f,
+	-14.644f,
+	-148.438f,
+	242.188f,
+	-12.3094f,
+	-148.438f,
+	246.094f,
+	-10.1634f,
+	-148.438f,
+	250.0f,
+	-6.79503f,
+	-148.438f,
+	3.90625f,
+	42.7212f,
+	-152.344f,
+	7.8125f,
+	41.7463f,
+	-152.344f,
+	11.7188f,
+	40.5249f,
+	-152.344f,
+	15.625f,
+	39.5225f,
+	-152.344f,
+	19.5313f,
+	36.6967f,
+	-152.344f,
+	23.4375f,
+	34.0075f,
+	-152.344f,
+	27.3438f,
+	31.2054f,
+	-152.344f,
+	31.25f,
+	28.8502f,
+	-152.344f,
+	35.1563f,
+	27.2625f,
+	-152.344f,
+	39.0625f,
+	24.9496f,
+	-152.344f,
+	42.9688f,
+	23.5897f,
+	-152.344f,
+	46.875f,
+	23.4709f,
+	-152.344f,
+	50.7813f,
+	24.179f,
+	-152.344f,
+	54.6875f,
+	25.021f,
+	-152.344f,
+	58.5938f,
+	25.6664f,
+	-152.344f,
+	62.5f,
+	25.7063f,
+	-152.344f,
+	66.4063f,
+	26.6928f,
+	-152.344f,
+	70.3125f,
+	26.8261f,
+	-152.344f,
+	74.2188f,
+	28.2549f,
+	-152.344f,
+	78.125f,
+	30.3373f,
+	-152.344f,
+	82.0313f,
+	31.6194f,
+	-152.344f,
+	85.9375f,
+	32.9189f,
+	-152.344f,
+	89.8438f,
+	32.7162f,
+	-152.344f,
+	93.75f,
+	33.0001f,
+	-152.344f,
+	97.6563f,
+	34.4407f,
+	-152.344f,
+	101.563f,
+	35.0813f,
+	-152.344f,
+	105.469f,
+	34.4143f,
+	-152.344f,
+	109.375f,
+	33.5195f,
+	-152.344f,
+	113.281f,
+	32.927f,
+	-152.344f,
+	117.188f,
+	32.6509f,
+	-152.344f,
+	121.094f,
+	32.6775f,
+	-152.344f,
+	125.0f,
+	30.887f,
+	-152.344f,
+	128.906f,
+	28.4296f,
+	-152.344f,
+	132.813f,
+	26.5539f,
+	-152.344f,
+	136.719f,
+	24.0803f,
+	-152.344f,
+	140.625f,
+	20.196f,
+	-152.344f,
+	144.531f,
+	16.4293f,
+	-152.344f,
+	148.438f,
+	12.8243f,
+	-152.344f,
+	152.344f,
+	9.76479f,
+	-152.344f,
+	156.25f,
+	7.14206f,
+	-152.344f,
+	160.156f,
+	4.74684f,
+	-152.344f,
+	164.063f,
+	2.30008f,
+	-152.344f,
+	167.969f,
+	1.49801f,
+	-152.344f,
+	171.875f,
+	-0.62719f,
+	-152.344f,
+	175.781f,
+	-1.99004f,
+	-152.344f,
+	179.688f,
+	-4.80775f,
+	-152.344f,
+	183.594f,
+	-8.00986f,
+	-152.344f,
+	187.5f,
+	-11.4771f,
+	-152.344f,
+	191.406f,
+	-12.8743f,
+	-152.344f,
+	195.313f,
+	-13.8733f,
+	-152.344f,
+	199.219f,
+	-15.0749f,
+	-152.344f,
+	203.125f,
+	-16.9234f,
+	-152.344f,
+	207.031f,
+	-18.3258f,
+	-152.344f,
+	210.938f,
+	-19.6583f,
+	-152.344f,
+	214.844f,
+	-20.9396f,
+	-152.344f,
+	218.75f,
+	-21.8071f,
+	-152.344f,
+	222.656f,
+	-21.4908f,
+	-152.344f,
+	226.563f,
+	-21.4698f,
+	-152.344f,
+	230.469f,
+	-19.3773f,
+	-152.344f,
+	234.375f,
+	-17.0448f,
+	-152.344f,
+	238.281f,
+	-14.0123f,
+	-152.344f,
+	242.188f,
+	-11.2372f,
+	-152.344f,
+	246.094f,
+	-9.11286f,
+	-152.344f,
+	250.0f,
+	-6.76792f,
+	-152.344f,
+	3.90625f,
+	41.7368f,
+	-156.25f,
+	7.8125f,
+	40.8494f,
+	-156.25f,
+	11.7188f,
+	39.2286f,
+	-156.25f,
+	15.625f,
+	37.4784f,
+	-156.25f,
+	19.5313f,
+	36.0345f,
+	-156.25f,
+	23.4375f,
+	33.9716f,
+	-156.25f,
+	27.3438f,
+	31.3041f,
+	-156.25f,
+	31.25f,
+	28.9777f,
+	-156.25f,
+	35.1563f,
+	26.0934f,
+	-156.25f,
+	39.0625f,
+	23.7421f,
+	-156.25f,
+	42.9688f,
+	22.4401f,
+	-156.25f,
+	46.875f,
+	22.1238f,
+	-156.25f,
+	50.7813f,
+	22.6669f,
+	-156.25f,
+	54.6875f,
+	23.7702f,
+	-156.25f,
+	58.5938f,
+	24.63f,
+	-156.25f,
+	62.5f,
+	25.2145f,
+	-156.25f,
+	66.4063f,
+	26.6101f,
+	-156.25f,
+	70.3125f,
+	27.3664f,
+	-156.25f,
+	74.2188f,
+	28.121f,
+	-156.25f,
+	78.125f,
+	29.5305f,
+	-156.25f,
+	82.0313f,
+	30.4367f,
+	-156.25f,
+	85.9375f,
+	30.627f,
+	-156.25f,
+	89.8438f,
+	30.4079f,
+	-156.25f,
+	93.75f,
+	32.2186f,
+	-156.25f,
+	97.6563f,
+	33.2916f,
+	-156.25f,
+	101.563f,
+	33.8066f,
+	-156.25f,
+	105.469f,
+	32.5269f,
+	-156.25f,
+	109.375f,
+	32.0751f,
+	-156.25f,
+	113.281f,
+	31.0298f,
+	-156.25f,
+	117.188f,
+	30.9869f,
+	-156.25f,
+	121.094f,
+	30.9826f,
+	-156.25f,
+	125.0f,
+	29.0676f,
+	-156.25f,
+	128.906f,
+	26.8988f,
+	-156.25f,
+	132.813f,
+	24.0771f,
+	-156.25f,
+	136.719f,
+	21.8087f,
+	-156.25f,
+	140.625f,
+	18.8179f,
+	-156.25f,
+	144.531f,
+	14.2483f,
+	-156.25f,
+	148.438f,
+	10.9236f,
+	-156.25f,
+	152.344f,
+	9.05948f,
+	-156.25f,
+	156.25f,
+	6.86087f,
+	-156.25f,
+	160.156f,
+	3.50699f,
+	-156.25f,
+	164.063f,
+	1.14903f,
+	-156.25f,
+	167.969f,
+	-0.639847f,
+	-156.25f,
+	171.875f,
+	-2.73828f,
+	-156.25f,
+	175.781f,
+	-4.02372f,
+	-156.25f,
+	179.688f,
+	-6.15141f,
+	-156.25f,
+	183.594f,
+	-8.81231f,
+	-156.25f,
+	187.5f,
+	-10.3417f,
+	-156.25f,
+	191.406f,
+	-11.1895f,
+	-156.25f,
+	195.313f,
+	-13.1464f,
+	-156.25f,
+	199.219f,
+	-14.5401f,
+	-156.25f,
+	203.125f,
+	-15.9427f,
+	-156.25f,
+	207.031f,
+	-17.492f,
+	-156.25f,
+	210.938f,
+	-19.0599f,
+	-156.25f,
+	214.844f,
+	-21.1101f,
+	-156.25f,
+	218.75f,
+	-21.3872f,
+	-156.25f,
+	222.656f,
+	-21.1481f,
+	-156.25f,
+	226.563f,
+	-20.2836f,
+	-156.25f,
+	230.469f,
+	-18.1679f,
+	-156.25f,
+	234.375f,
+	-15.72f,
+	-156.25f,
+	238.281f,
+	-13.4579f,
+	-156.25f,
+	242.188f,
+	-10.1453f,
+	-156.25f,
+	246.094f,
+	-8.09411f,
+	-156.25f,
+	250.0f,
+	-5.46467f,
+	-156.25f,
+	3.90625f,
+	40.4755f,
+	-160.156f,
+	7.8125f,
+	39.299f,
+	-160.156f,
+	11.7188f,
+	37.3972f,
+	-160.156f,
+	15.625f,
+	36.1894f,
+	-160.156f,
+	19.5313f,
+	34.3138f,
+	-160.156f,
+	23.4375f,
+	32.893f,
+	-160.156f,
+	27.3438f,
+	30.4515f,
+	-160.156f,
+	31.25f,
+	28.5808f,
+	-160.156f,
+	35.1563f,
+	25.8839f,
+	-160.156f,
+	39.0625f,
+	23.8505f,
+	-160.156f,
+	42.9688f,
+	22.3057f,
+	-160.156f,
+	46.875f,
+	21.4418f,
+	-160.156f,
+	50.7813f,
+	21.9709f,
+	-160.156f,
+	54.6875f,
+	23.0083f,
+	-160.156f,
+	58.5938f,
+	24.899f,
+	-160.156f,
+	62.5f,
+	25.213f,
+	-160.156f,
+	66.4063f,
+	26.1428f,
+	-160.156f,
+	70.3125f,
+	27.2675f,
+	-160.156f,
+	74.2188f,
+	28.0843f,
+	-160.156f,
+	78.125f,
+	28.9474f,
+	-160.156f,
+	82.0313f,
+	29.5078f,
+	-160.156f,
+	85.9375f,
+	29.7468f,
+	-160.156f,
+	89.8438f,
+	30.8621f,
+	-160.156f,
+	93.75f,
+	31.5001f,
+	-160.156f,
+	97.6563f,
+	32.1184f,
+	-160.156f,
+	101.563f,
+	31.2692f,
+	-160.156f,
+	105.469f,
+	30.4985f,
+	-160.156f,
+	109.375f,
+	29.4368f,
+	-160.156f,
+	113.281f,
+	30.6889f,
+	-160.156f,
+	117.188f,
+	29.6238f,
+	-160.156f,
+	121.094f,
+	28.6487f,
+	-160.156f,
+	125.0f,
+	26.3174f,
+	-160.156f,
+	128.906f,
+	24.6125f,
+	-160.156f,
+	132.813f,
+	22.1993f,
+	-160.156f,
+	136.719f,
+	19.3934f,
+	-160.156f,
+	140.625f,
+	16.5457f,
+	-160.156f,
+	144.531f,
+	13.4024f,
+	-160.156f,
+	148.438f,
+	9.69887f,
+	-160.156f,
+	152.344f,
+	8.13305f,
+	-160.156f,
+	156.25f,
+	6.48921f,
+	-160.156f,
+	160.156f,
+	2.56153f,
+	-160.156f,
+	164.063f,
+	0.0733139f,
+	-160.156f,
+	167.969f,
+	-1.11414f,
+	-160.156f,
+	171.875f,
+	-3.04708f,
+	-160.156f,
+	175.781f,
+	-6.18654f,
+	-160.156f,
+	179.688f,
+	-7.4188f,
+	-160.156f,
+	183.594f,
+	-9.1718f,
+	-160.156f,
+	187.5f,
+	-9.78027f,
+	-160.156f,
+	191.406f,
+	-10.5496f,
+	-160.156f,
+	195.313f,
+	-12.7259f,
+	-160.156f,
+	199.219f,
+	-13.9068f,
+	-160.156f,
+	203.125f,
+	-15.4772f,
+	-160.156f,
+	207.031f,
+	-17.6287f,
+	-160.156f,
+	210.938f,
+	-19.2502f,
+	-160.156f,
+	214.844f,
+	-19.5824f,
+	-160.156f,
+	218.75f,
+	-19.3114f,
+	-160.156f,
+	222.656f,
+	-19.5266f,
+	-160.156f,
+	226.563f,
+	-17.8446f,
+	-160.156f,
+	230.469f,
+	-16.3027f,
+	-160.156f,
+	234.375f,
+	-14.5015f,
+	-160.156f,
+	238.281f,
+	-11.9891f,
+	-160.156f,
+	242.188f,
+	-9.40017f,
+	-160.156f,
+	246.094f,
+	-6.63794f,
+	-160.156f,
+	250.0f,
+	-3.71573f,
+	-160.156f,
+	3.90625f,
+	38.8633f,
+	-164.063f,
+	7.8125f,
+	37.4382f,
+	-164.063f,
+	11.7188f,
+	35.7214f,
+	-164.063f,
+	15.625f,
+	34.0614f,
+	-164.063f,
+	19.5313f,
+	33.0957f,
+	-164.063f,
+	23.4375f,
+	32.0369f,
+	-164.063f,
+	27.3438f,
+	29.7096f,
+	-164.063f,
+	31.25f,
+	27.3216f,
+	-164.063f,
+	35.1563f,
+	25.2446f,
+	-164.063f,
+	39.0625f,
+	23.6071f,
+	-164.063f,
+	42.9688f,
+	22.2443f,
+	-164.063f,
+	46.875f,
+	21.2807f,
+	-164.063f,
+	50.7813f,
+	21.0358f,
+	-164.063f,
+	54.6875f,
+	22.8177f,
+	-164.063f,
+	58.5938f,
+	24.4434f,
+	-164.063f,
+	62.5f,
+	25.1375f,
+	-164.063f,
+	66.4063f,
+	25.3266f,
+	-164.063f,
+	70.3125f,
+	26.6102f,
+	-164.063f,
+	74.2188f,
+	27.6569f,
+	-164.063f,
+	78.125f,
+	27.8248f,
+	-164.063f,
+	82.0313f,
+	28.0421f,
+	-164.063f,
+	85.9375f,
+	29.1719f,
+	-164.063f,
+	89.8438f,
+	29.9529f,
+	-164.063f,
+	93.75f,
+	30.947f,
+	-164.063f,
+	97.6563f,
+	30.6189f,
+	-164.063f,
+	101.563f,
+	29.7913f,
+	-164.063f,
+	105.469f,
+	27.6858f,
+	-164.063f,
+	109.375f,
+	27.3234f,
+	-164.063f,
+	113.281f,
+	27.8148f,
+	-164.063f,
+	117.188f,
+	27.3571f,
+	-164.063f,
+	121.094f,
+	26.1572f,
+	-164.063f,
+	125.0f,
+	23.8557f,
+	-164.063f,
+	128.906f,
+	21.6383f,
+	-164.063f,
+	132.813f,
+	19.0681f,
+	-164.063f,
+	136.719f,
+	16.7352f,
+	-164.063f,
+	140.625f,
+	14.4004f,
+	-164.063f,
+	144.531f,
+	11.082f,
+	-164.063f,
+	148.438f,
+	8.38754f,
+	-164.063f,
+	152.344f,
+	7.0054f,
+	-164.063f,
+	156.25f,
+	4.95122f,
+	-164.063f,
+	160.156f,
+	2.47298f,
+	-164.063f,
+	164.063f,
+	0.777691f,
+	-164.063f,
+	167.969f,
+	-1.44055f,
+	-164.063f,
+	171.875f,
+	-3.57218f,
+	-164.063f,
+	175.781f,
+	-6.3396f,
+	-164.063f,
+	179.688f,
+	-7.49937f,
+	-164.063f,
+	183.594f,
+	-9.17485f,
+	-164.063f,
+	187.5f,
+	-9.92705f,
+	-164.063f,
+	191.406f,
+	-11.0737f,
+	-164.063f,
+	195.313f,
+	-12.8264f,
+	-164.063f,
+	199.219f,
+	-14.9306f,
+	-164.063f,
+	203.125f,
+	-15.9553f,
+	-164.063f,
+	207.031f,
+	-17.0898f,
+	-164.063f,
+	210.938f,
+	-18.5283f,
+	-164.063f,
+	214.844f,
+	-18.545f,
+	-164.063f,
+	218.75f,
+	-18.553f,
+	-164.063f,
+	222.656f,
+	-17.5725f,
+	-164.063f,
+	226.563f,
+	-15.6444f,
+	-164.063f,
+	230.469f,
+	-14.565f,
+	-164.063f,
+	234.375f,
+	-12.5578f,
+	-164.063f,
+	238.281f,
+	-10.6498f,
+	-164.063f,
+	242.188f,
+	-8.28284f,
+	-164.063f,
+	246.094f,
+	-5.87682f,
+	-164.063f,
+	250.0f,
+	-2.5339f,
+	-164.063f,
+	3.90625f,
+	37.2199f,
+	-167.969f,
+	7.8125f,
+	36.6782f,
+	-167.969f,
+	11.7188f,
+	36.2393f,
+	-167.969f,
+	15.625f,
+	33.4745f,
+	-167.969f,
+	19.5313f,
+	32.0928f,
+	-167.969f,
+	23.4375f,
+	30.5662f,
+	-167.969f,
+	27.3438f,
+	28.5968f,
+	-167.969f,
+	31.25f,
+	26.4298f,
+	-167.969f,
+	35.1563f,
+	23.9469f,
+	-167.969f,
+	39.0625f,
+	22.5415f,
+	-167.969f,
+	42.9688f,
+	21.8267f,
+	-167.969f,
+	46.875f,
+	21.2097f,
+	-167.969f,
+	50.7813f,
+	21.0841f,
+	-167.969f,
+	54.6875f,
+	21.7877f,
+	-167.969f,
+	58.5938f,
+	22.9351f,
+	-167.969f,
+	62.5f,
+	24.0641f,
+	-167.969f,
+	66.4063f,
+	24.42f,
+	-167.969f,
+	70.3125f,
+	24.8355f,
+	-167.969f,
+	74.2188f,
+	25.2701f,
+	-167.969f,
+	78.125f,
+	26.0252f,
+	-167.969f,
+	82.0313f,
+	26.8612f,
+	-167.969f,
+	85.9375f,
+	27.4256f,
+	-167.969f,
+	89.8438f,
+	28.994f,
+	-167.969f,
+	93.75f,
+	29.1766f,
+	-167.969f,
+	97.6563f,
+	27.8964f,
+	-167.969f,
+	101.563f,
+	26.6384f,
+	-167.969f,
+	105.469f,
+	24.9844f,
+	-167.969f,
+	109.375f,
+	25.0669f,
+	-167.969f,
+	113.281f,
+	24.572f,
+	-167.969f,
+	117.188f,
+	23.7817f,
+	-167.969f,
+	121.094f,
+	22.2089f,
+	-167.969f,
+	125.0f,
+	19.7633f,
+	-167.969f,
+	128.906f,
+	17.7618f,
+	-167.969f,
+	132.813f,
+	15.7339f,
+	-167.969f,
+	136.719f,
+	13.4975f,
+	-167.969f,
+	140.625f,
+	11.7364f,
+	-167.969f,
+	144.531f,
+	9.85351f,
+	-167.969f,
+	148.438f,
+	8.05282f,
+	-167.969f,
+	152.344f,
+	6.97463f,
+	-167.969f,
+	156.25f,
+	5.11511f,
+	-167.969f,
+	160.156f,
+	3.12954f,
+	-167.969f,
+	164.063f,
+	1.56555f,
+	-167.969f,
+	167.969f,
+	-1.77415f,
+	-167.969f,
+	171.875f,
+	-4.16322f,
+	-167.969f,
+	175.781f,
+	-5.85214f,
+	-167.969f,
+	179.688f,
+	-7.97892f,
+	-167.969f,
+	183.594f,
+	-9.87953f,
+	-167.969f,
+	187.5f,
+	-10.2762f,
+	-167.969f,
+	191.406f,
+	-11.5319f,
+	-167.969f,
+	195.313f,
+	-13.3612f,
+	-167.969f,
+	199.219f,
+	-15.3709f,
+	-167.969f,
+	203.125f,
+	-16.5674f,
+	-167.969f,
+	207.031f,
+	-17.6903f,
+	-167.969f,
+	210.938f,
+	-17.6736f,
+	-167.969f,
+	214.844f,
+	-16.8207f,
+	-167.969f,
+	218.75f,
+	-17.0254f,
+	-167.969f,
+	222.656f,
+	-16.3676f,
+	-167.969f,
+	226.563f,
+	-14.2816f,
+	-167.969f,
+	230.469f,
+	-13.3488f,
+	-167.969f,
+	234.375f,
+	-12.0136f,
+	-167.969f,
+	238.281f,
+	-9.90116f,
+	-167.969f,
+	242.188f,
+	-7.92295f,
+	-167.969f,
+	246.094f,
+	-5.41594f,
+	-167.969f,
+	250.0f,
+	-1.87299f,
+	-167.969f,
+	3.90625f,
+	35.3898f,
+	-171.875f,
+	7.8125f,
+	35.2527f,
+	-171.875f,
+	11.7188f,
+	34.3178f,
+	-171.875f,
+	15.625f,
+	33.0736f,
+	-171.875f,
+	19.5313f,
+	31.4013f,
+	-171.875f,
+	23.4375f,
+	28.9174f,
+	-171.875f,
+	27.3438f,
+	26.607f,
+	-171.875f,
+	31.25f,
+	24.7766f,
+	-171.875f,
+	35.1563f,
+	23.21f,
+	-171.875f,
+	39.0625f,
+	21.903f,
+	-171.875f,
+	42.9688f,
+	20.775f,
+	-171.875f,
+	46.875f,
+	20.114f,
+	-171.875f,
+	50.7813f,
+	19.6974f,
+	-171.875f,
+	54.6875f,
+	20.6726f,
+	-171.875f,
+	58.5938f,
+	22.241f,
+	-171.875f,
+	62.5f,
+	22.075f,
+	-171.875f,
+	66.4063f,
+	22.6771f,
+	-171.875f,
+	70.3125f,
+	22.4456f,
+	-171.875f,
+	74.2188f,
+	22.8643f,
+	-171.875f,
+	78.125f,
+	24.7268f,
+	-171.875f,
+	82.0313f,
+	25.7019f,
+	-171.875f,
+	85.9375f,
+	26.1196f,
+	-171.875f,
+	89.8438f,
+	25.6156f,
+	-171.875f,
+	93.75f,
+	24.7881f,
+	-171.875f,
+	97.6563f,
+	24.0074f,
+	-171.875f,
+	101.563f,
+	23.4739f,
+	-171.875f,
+	105.469f,
+	23.362f,
+	-171.875f,
+	109.375f,
+	22.2604f,
+	-171.875f,
+	113.281f,
+	21.2772f,
+	-171.875f,
+	117.188f,
+	19.7815f,
+	-171.875f,
+	121.094f,
+	17.9686f,
+	-171.875f,
+	125.0f,
+	16.3211f,
+	-171.875f,
+	128.906f,
+	14.2631f,
+	-171.875f,
+	132.813f,
+	12.4914f,
+	-171.875f,
+	136.719f,
+	10.3941f,
+	-171.875f,
+	140.625f,
+	8.91613f,
+	-171.875f,
+	144.531f,
+	9.17409f,
+	-171.875f,
+	148.438f,
+	7.34154f,
+	-171.875f,
+	152.344f,
+	6.13056f,
+	-171.875f,
+	156.25f,
+	4.58272f,
+	-171.875f,
+	160.156f,
+	2.77083f,
+	-171.875f,
+	164.063f,
+	1.11181f,
+	-171.875f,
+	167.969f,
+	-2.00034f,
+	-171.875f,
+	171.875f,
+	-3.64525f,
+	-171.875f,
+	175.781f,
+	-5.12602f,
+	-171.875f,
+	179.688f,
+	-8.3325f,
+	-171.875f,
+	183.594f,
+	-10.0807f,
+	-171.875f,
+	187.5f,
+	-10.8974f,
+	-171.875f,
+	191.406f,
+	-11.9623f,
+	-171.875f,
+	195.313f,
+	-14.5041f,
+	-171.875f,
+	199.219f,
+	-15.8629f,
+	-171.875f,
+	203.125f,
+	-17.2342f,
+	-171.875f,
+	207.031f,
+	-18.2786f,
+	-171.875f,
+	210.938f,
+	-16.9405f,
+	-171.875f,
+	214.844f,
+	-16.1592f,
+	-171.875f,
+	218.75f,
+	-15.9928f,
+	-171.875f,
+	222.656f,
+	-14.9179f,
+	-171.875f,
+	226.563f,
+	-13.6308f,
+	-171.875f,
+	230.469f,
+	-12.822f,
+	-171.875f,
+	234.375f,
+	-11.0168f,
+	-171.875f,
+	238.281f,
+	-8.54191f,
+	-171.875f,
+	242.188f,
+	-6.16464f,
+	-171.875f,
+	246.094f,
+	-4.35579f,
+	-171.875f,
+	250.0f,
+	-1.83408f,
+	-171.875f,
+	3.90625f,
+	34.823f,
+	-175.781f,
+	7.8125f,
+	33.9621f,
+	-175.781f,
+	11.7188f,
+	33.7226f,
+	-175.781f,
+	15.625f,
+	31.9821f,
+	-175.781f,
+	19.5313f,
+	29.6933f,
+	-175.781f,
+	23.4375f,
+	27.247f,
+	-175.781f,
+	27.3438f,
+	25.1394f,
+	-175.781f,
+	31.25f,
+	23.3125f,
+	-175.781f,
+	35.1563f,
+	21.288f,
+	-175.781f,
+	39.0625f,
+	21.2432f,
+	-175.781f,
+	42.9688f,
+	19.7041f,
+	-175.781f,
+	46.875f,
+	19.3043f,
+	-175.781f,
+	50.7813f,
+	18.5669f,
+	-175.781f,
+	54.6875f,
+	19.5408f,
+	-175.781f,
+	58.5938f,
+	20.3028f,
+	-175.781f,
+	62.5f,
+	20.573f,
+	-175.781f,
+	66.4063f,
+	20.7874f,
+	-175.781f,
+	70.3125f,
+	21.4507f,
+	-175.781f,
+	74.2188f,
+	22.9166f,
+	-175.781f,
+	78.125f,
+	23.6886f,
+	-175.781f,
+	82.0313f,
+	24.4139f,
+	-175.781f,
+	85.9375f,
+	25.1097f,
+	-175.781f,
+	89.8438f,
+	24.1395f,
+	-175.781f,
+	93.75f,
+	23.5282f,
+	-175.781f,
+	97.6563f,
+	22.7881f,
+	-175.781f,
+	101.563f,
+	21.2087f,
+	-175.781f,
+	105.469f,
+	20.6461f,
+	-175.781f,
+	109.375f,
+	19.7212f,
+	-175.781f,
+	113.281f,
+	17.9239f,
+	-175.781f,
+	117.188f,
+	16.9142f,
+	-175.781f,
+	121.094f,
+	16.1581f,
+	-175.781f,
+	125.0f,
+	15.1171f,
+	-175.781f,
+	128.906f,
+	13.1305f,
+	-175.781f,
+	132.813f,
+	10.3035f,
+	-175.781f,
+	136.719f,
+	7.95438f,
+	-175.781f,
+	140.625f,
+	7.49768f,
+	-175.781f,
+	144.531f,
+	7.76486f,
+	-175.781f,
+	148.438f,
+	6.84318f,
+	-175.781f,
+	152.344f,
+	6.0204f,
+	-175.781f,
+	156.25f,
+	4.83875f,
+	-175.781f,
+	160.156f,
+	2.59906f,
+	-175.781f,
+	164.063f,
+	1.35973f,
+	-175.781f,
+	167.969f,
+	-1.40345f,
+	-175.781f,
+	171.875f,
+	-3.6985f,
+	-175.781f,
+	175.781f,
+	-5.60686f,
+	-175.781f,
+	179.688f,
+	-8.15914f,
+	-175.781f,
+	183.594f,
+	-9.0389f,
+	-175.781f,
+	187.5f,
+	-11.2771f,
+	-175.781f,
+	191.406f,
+	-13.1363f,
+	-175.781f,
+	195.313f,
+	-14.845f,
+	-175.781f,
+	199.219f,
+	-15.885f,
+	-175.781f,
+	203.125f,
+	-17.6421f,
+	-175.781f,
+	207.031f,
+	-18.1972f,
+	-175.781f,
+	210.938f,
+	-16.4052f,
+	-175.781f,
+	214.844f,
+	-16.4522f,
+	-175.781f,
+	218.75f,
+	-15.8261f,
+	-175.781f,
+	222.656f,
+	-13.6816f,
+	-175.781f,
+	226.563f,
+	-12.8394f,
+	-175.781f,
+	230.469f,
+	-11.638f,
+	-175.781f,
+	234.375f,
+	-8.87545f,
+	-175.781f,
+	238.281f,
+	-6.82071f,
+	-175.781f,
+	242.188f,
+	-3.82988f,
+	-175.781f,
+	246.094f,
+	-2.34543f,
+	-175.781f,
+	250.0f,
+	-0.72787f,
+	-175.781f,
+	3.90625f,
+	32.9461f,
+	-179.688f,
+	7.8125f,
+	32.0951f,
+	-179.688f,
+	11.7188f,
+	31.1161f,
+	-179.688f,
+	15.625f,
+	29.4f,
+	-179.688f,
+	19.5313f,
+	27.5196f,
+	-179.688f,
+	23.4375f,
+	26.3351f,
+	-179.688f,
+	27.3438f,
+	24.0706f,
+	-179.688f,
+	31.25f,
+	21.9677f,
+	-179.688f,
+	35.1563f,
+	20.1582f,
+	-179.688f,
+	39.0625f,
+	19.3604f,
+	-179.688f,
+	42.9688f,
+	18.5912f,
+	-179.688f,
+	46.875f,
+	18.0845f,
+	-179.688f,
+	50.7813f,
+	18.0311f,
+	-179.688f,
+	54.6875f,
+	17.5412f,
+	-179.688f,
+	58.5938f,
+	17.724f,
+	-179.688f,
+	62.5f,
+	18.1752f,
+	-179.688f,
+	66.4063f,
+	18.8435f,
+	-179.688f,
+	70.3125f,
+	20.8887f,
+	-179.688f,
+	74.2188f,
+	21.9179f,
+	-179.688f,
+	78.125f,
+	22.3044f,
+	-179.688f,
+	82.0313f,
+	22.1491f,
+	-179.688f,
+	85.9375f,
+	23.261f,
+	-179.688f,
+	89.8438f,
+	22.4285f,
+	-179.688f,
+	93.75f,
+	21.5354f,
+	-179.688f,
+	97.6563f,
+	19.6399f,
+	-179.688f,
+	101.563f,
+	18.1312f,
+	-179.688f,
+	105.469f,
+	17.0655f,
+	-179.688f,
+	109.375f,
+	16.1471f,
+	-179.688f,
+	113.281f,
+	15.8256f,
+	-179.688f,
+	117.188f,
+	14.9609f,
+	-179.688f,
+	121.094f,
+	15.4508f,
+	-179.688f,
+	125.0f,
+	14.9122f,
+	-179.688f,
+	128.906f,
+	12.3324f,
+	-179.688f,
+	132.813f,
+	9.95184f,
+	-179.688f,
+	136.719f,
+	7.31755f,
+	-179.688f,
+	140.625f,
+	6.91109f,
+	-179.688f,
+	144.531f,
+	7.29489f,
+	-179.688f,
+	148.438f,
+	6.73968f,
+	-179.688f,
+	152.344f,
+	6.0555f,
+	-179.688f,
+	156.25f,
+	5.42266f,
+	-179.688f,
+	160.156f,
+	3.84651f,
+	-179.688f,
+	164.063f,
+	2.44552f,
+	-179.688f,
+	167.969f,
+	-0.187962f,
+	-179.688f,
+	171.875f,
+	-3.00626f,
+	-179.688f,
+	175.781f,
+	-5.38527f,
+	-179.688f,
+	179.688f,
+	-6.48806f,
+	-179.688f,
+	183.594f,
+	-9.24275f,
+	-179.688f,
+	187.5f,
+	-11.5122f,
+	-179.688f,
+	191.406f,
+	-12.6735f,
+	-179.688f,
+	195.313f,
+	-14.1843f,
+	-179.688f,
+	199.219f,
+	-15.4787f,
+	-179.688f,
+	203.125f,
+	-16.6061f,
+	-179.688f,
+	207.031f,
+	-17.1175f,
+	-179.688f,
+	210.938f,
+	-16.022f,
+	-179.688f,
+	214.844f,
+	-15.9349f,
+	-179.688f,
+	218.75f,
+	-14.6169f,
+	-179.688f,
+	222.656f,
+	-13.0146f,
+	-179.688f,
+	226.563f,
+	-12.2f,
+	-179.688f,
+	230.469f,
+	-9.81169f,
+	-179.688f,
+	234.375f,
+	-6.72224f,
+	-179.688f,
+	238.281f,
+	-4.11664f,
+	-179.688f,
+	242.188f,
+	-2.18066f,
+	-179.688f,
+	246.094f,
+	-0.510192f,
+	-179.688f,
+	250.0f,
+	1.48603f,
+	-179.688f,
+	3.90625f,
+	30.0027f,
+	-183.594f,
+	7.8125f,
+	29.6114f,
+	-183.594f,
+	11.7188f,
+	28.342f,
+	-183.594f,
+	15.625f,
+	26.9383f,
+	-183.594f,
+	19.5313f,
+	26.0219f,
+	-183.594f,
+	23.4375f,
+	25.017f,
+	-183.594f,
+	27.3438f,
+	22.7851f,
+	-183.594f,
+	31.25f,
+	20.6488f,
+	-183.594f,
+	35.1563f,
+	18.7107f,
+	-183.594f,
+	39.0625f,
+	17.0893f,
+	-183.594f,
+	42.9688f,
+	17.4316f,
+	-183.594f,
+	46.875f,
+	17.3211f,
+	-183.594f,
+	50.7813f,
+	16.5318f,
+	-183.594f,
+	54.6875f,
+	16.2012f,
+	-183.594f,
+	58.5938f,
+	17.0855f,
+	-183.594f,
+	62.5f,
+	17.2472f,
+	-183.594f,
+	66.4063f,
+	18.0123f,
+	-183.594f,
+	70.3125f,
+	18.684f,
+	-183.594f,
+	74.2188f,
+	19.625f,
+	-183.594f,
+	78.125f,
+	19.9442f,
+	-183.594f,
+	82.0313f,
+	19.9236f,
+	-183.594f,
+	85.9375f,
+	19.2286f,
+	-183.594f,
+	89.8438f,
+	19.5358f,
+	-183.594f,
+	93.75f,
+	18.429f,
+	-183.594f,
+	97.6563f,
+	16.1318f,
+	-183.594f,
+	101.563f,
+	14.371f,
+	-183.594f,
+	105.469f,
+	13.894f,
+	-183.594f,
+	109.375f,
+	13.5457f,
+	-183.594f,
+	113.281f,
+	13.7348f,
+	-183.594f,
+	117.188f,
+	14.0078f,
+	-183.594f,
+	121.094f,
+	14.2652f,
+	-183.594f,
+	125.0f,
+	13.5964f,
+	-183.594f,
+	128.906f,
+	11.3529f,
+	-183.594f,
+	132.813f,
+	8.43645f,
+	-183.594f,
+	136.719f,
+	6.95213f,
+	-183.594f,
+	140.625f,
+	7.16061f,
+	-183.594f,
+	144.531f,
+	6.71961f,
+	-183.594f,
+	148.438f,
+	5.35597f,
+	-183.594f,
+	152.344f,
+	5.22708f,
+	-183.594f,
+	156.25f,
+	5.07045f,
+	-183.594f,
+	160.156f,
+	3.44698f,
+	-183.594f,
+	164.063f,
+	2.33212f,
+	-183.594f,
+	167.969f,
+	0.462143f,
+	-183.594f,
+	171.875f,
+	-2.31458f,
+	-183.594f,
+	175.781f,
+	-4.89712f,
+	-183.594f,
+	179.688f,
+	-6.66797f,
+	-183.594f,
+	183.594f,
+	-9.25909f,
+	-183.594f,
+	187.5f,
+	-9.93472f,
+	-183.594f,
+	191.406f,
+	-12.0357f,
+	-183.594f,
+	195.313f,
+	-13.4286f,
+	-183.594f,
+	199.219f,
+	-14.4671f,
+	-183.594f,
+	203.125f,
+	-15.0102f,
+	-183.594f,
+	207.031f,
+	-14.8104f,
+	-183.594f,
+	210.938f,
+	-13.4733f,
+	-183.594f,
+	214.844f,
+	-14.0715f,
+	-183.594f,
+	218.75f,
+	-14.2416f,
+	-183.594f,
+	222.656f,
+	-12.2774f,
+	-183.594f,
+	226.563f,
+	-11.1048f,
+	-183.594f,
+	230.469f,
+	-8.72548f,
+	-183.594f,
+	234.375f,
+	-5.50563f,
+	-183.594f,
+	238.281f,
+	-2.81853f,
+	-183.594f,
+	242.188f,
+	-0.555239f,
+	-183.594f,
+	246.094f,
+	1.07177f,
+	-183.594f,
+	250.0f,
+	3.1022f,
+	-183.594f,
+	3.90625f,
+	27.6405f,
+	-187.5f,
+	7.8125f,
+	27.1266f,
+	-187.5f,
+	11.7188f,
+	26.0941f,
+	-187.5f,
+	15.625f,
+	25.1443f,
+	-187.5f,
+	19.5313f,
+	24.6236f,
+	-187.5f,
+	23.4375f,
+	23.7274f,
+	-187.5f,
+	27.3438f,
+	22.5792f,
+	-187.5f,
+	31.25f,
+	19.7482f,
+	-187.5f,
+	35.1563f,
+	17.6829f,
+	-187.5f,
+	39.0625f,
+	16.5577f,
+	-187.5f,
+	42.9688f,
+	15.8636f,
+	-187.5f,
+	46.875f,
+	16.0968f,
+	-187.5f,
+	50.7813f,
+	15.5614f,
+	-187.5f,
+	54.6875f,
+	15.4655f,
+	-187.5f,
+	58.5938f,
+	16.304f,
+	-187.5f,
+	62.5f,
+	16.7706f,
+	-187.5f,
+	66.4063f,
+	16.3947f,
+	-187.5f,
+	70.3125f,
+	16.6761f,
+	-187.5f,
+	74.2188f,
+	16.7627f,
+	-187.5f,
+	78.125f,
+	17.2579f,
+	-187.5f,
+	82.0313f,
+	16.7208f,
+	-187.5f,
+	85.9375f,
+	16.5278f,
+	-187.5f,
+	89.8438f,
+	16.2251f,
+	-187.5f,
+	93.75f,
+	15.0741f,
+	-187.5f,
+	97.6563f,
+	14.2628f,
+	-187.5f,
+	101.563f,
+	12.432f,
+	-187.5f,
+	105.469f,
+	10.8877f,
+	-187.5f,
+	109.375f,
+	11.903f,
+	-187.5f,
+	113.281f,
+	12.5606f,
+	-187.5f,
+	117.188f,
+	13.2652f,
+	-187.5f,
+	121.094f,
+	13.6914f,
+	-187.5f,
+	125.0f,
+	12.7849f,
+	-187.5f,
+	128.906f,
+	10.4802f,
+	-187.5f,
+	132.813f,
+	8.75276f,
+	-187.5f,
+	136.719f,
+	6.90392f,
+	-187.5f,
+	140.625f,
+	6.91636f,
+	-187.5f,
+	144.531f,
+	6.78271f,
+	-187.5f,
+	148.438f,
+	5.25436f,
+	-187.5f,
+	152.344f,
+	4.14458f,
+	-187.5f,
+	156.25f,
+	3.58445f,
+	-187.5f,
+	160.156f,
+	3.67538f,
+	-187.5f,
+	164.063f,
+	1.88171f,
+	-187.5f,
+	167.969f,
+	1.16358f,
+	-187.5f,
+	171.875f,
+	-0.909335f,
+	-187.5f,
+	175.781f,
+	-4.00056f,
+	-187.5f,
+	179.688f,
+	-6.532f,
+	-187.5f,
+	183.594f,
+	-8.29174f,
+	-187.5f,
+	187.5f,
+	-9.0196f,
+	-187.5f,
+	191.406f,
+	-10.1189f,
+	-187.5f,
+	195.313f,
+	-11.1349f,
+	-187.5f,
+	199.219f,
+	-12.4853f,
+	-187.5f,
+	203.125f,
+	-12.7324f,
+	-187.5f,
+	207.031f,
+	-12.949f,
+	-187.5f,
+	210.938f,
+	-11.8708f,
+	-187.5f,
+	214.844f,
+	-12.2515f,
+	-187.5f,
+	218.75f,
+	-12.8455f,
+	-187.5f,
+	222.656f,
+	-10.7923f,
+	-187.5f,
+	226.563f,
+	-8.82819f,
+	-187.5f,
+	230.469f,
+	-7.36721f,
+	-187.5f,
+	234.375f,
+	-5.23714f,
+	-187.5f,
+	238.281f,
+	-2.63334f,
+	-187.5f,
+	242.188f,
+	0.485313f,
+	-187.5f,
+	246.094f,
+	2.78278f,
+	-187.5f,
+	250.0f,
+	3.96313f,
+	-187.5f,
+	3.90625f,
+	25.3652f,
+	-191.406f,
+	7.8125f,
+	24.7195f,
+	-191.406f,
+	11.7188f,
+	25.004f,
+	-191.406f,
+	15.625f,
+	24.1773f,
+	-191.406f,
+	19.5313f,
+	22.7395f,
+	-191.406f,
+	23.4375f,
+	21.4739f,
+	-191.406f,
+	27.3438f,
+	21.0405f,
+	-191.406f,
+	31.25f,
+	18.3321f,
+	-191.406f,
+	35.1563f,
+	16.9491f,
+	-191.406f,
+	39.0625f,
+	15.1898f,
+	-191.406f,
+	42.9688f,
+	14.5842f,
+	-191.406f,
+	46.875f,
+	14.234f,
+	-191.406f,
+	50.7813f,
+	14.0689f,
+	-191.406f,
+	54.6875f,
+	15.4103f,
+	-191.406f,
+	58.5938f,
+	15.0749f,
+	-191.406f,
+	62.5f,
+	14.6893f,
+	-191.406f,
+	66.4063f,
+	14.8987f,
+	-191.406f,
+	70.3125f,
+	14.4416f,
+	-191.406f,
+	74.2188f,
+	14.3436f,
+	-191.406f,
+	78.125f,
+	13.5844f,
+	-191.406f,
+	82.0313f,
+	13.3989f,
+	-191.406f,
+	85.9375f,
+	14.3892f,
+	-191.406f,
+	89.8438f,
+	13.3595f,
+	-191.406f,
+	93.75f,
+	13.3004f,
+	-191.406f,
+	97.6563f,
+	11.8557f,
+	-191.406f,
+	101.563f,
+	9.50387f,
+	-191.406f,
+	105.469f,
+	9.09049f,
+	-191.406f,
+	109.375f,
+	10.2607f,
+	-191.406f,
+	113.281f,
+	11.3275f,
+	-191.406f,
+	117.188f,
+	11.8898f,
+	-191.406f,
+	121.094f,
+	11.9585f,
+	-191.406f,
+	125.0f,
+	11.0034f,
+	-191.406f,
+	128.906f,
+	10.0704f,
+	-191.406f,
+	132.813f,
+	8.84472f,
+	-191.406f,
+	136.719f,
+	7.56972f,
+	-191.406f,
+	140.625f,
+	6.66467f,
+	-191.406f,
+	144.531f,
+	5.57509f,
+	-191.406f,
+	148.438f,
+	4.43943f,
+	-191.406f,
+	152.344f,
+	3.51469f,
+	-191.406f,
+	156.25f,
+	2.91572f,
+	-191.406f,
+	160.156f,
+	3.43161f,
+	-191.406f,
+	164.063f,
+	1.97664f,
+	-191.406f,
+	167.969f,
+	1.37279f,
+	-191.406f,
+	171.875f,
+	-0.545961f,
+	-191.406f,
+	175.781f,
+	-3.78517f,
+	-191.406f,
+	179.688f,
+	-6.09483f,
+	-191.406f,
+	183.594f,
+	-6.45627f,
+	-191.406f,
+	187.5f,
+	-7.27376f,
+	-191.406f,
+	191.406f,
+	-8.99215f,
+	-191.406f,
+	195.313f,
+	-9.89915f,
+	-191.406f,
+	199.219f,
+	-10.9608f,
+	-191.406f,
+	203.125f,
+	-10.8387f,
+	-191.406f,
+	207.031f,
+	-10.5261f,
+	-191.406f,
+	210.938f,
+	-10.1365f,
+	-191.406f,
+	214.844f,
+	-10.631f,
+	-191.406f,
+	218.75f,
+	-10.8413f,
+	-191.406f,
+	222.656f,
+	-9.03823f,
+	-191.406f,
+	226.563f,
+	-7.39571f,
+	-191.406f,
+	230.469f,
+	-4.8409f,
+	-191.406f,
+	234.375f,
+	-3.47756f,
+	-191.406f,
+	238.281f,
+	-1.63291f,
+	-191.406f,
+	242.188f,
+	1.44814f,
+	-191.406f,
+	246.094f,
+	2.93141f,
+	-191.406f,
+	250.0f,
+	4.03991f,
+	-191.406f,
+	3.90625f,
+	23.0993f,
+	-195.313f,
+	7.8125f,
+	23.2309f,
+	-195.313f,
+	11.7188f,
+	23.4293f,
+	-195.313f,
+	15.625f,
+	22.4425f,
+	-195.313f,
+	19.5313f,
+	21.4905f,
+	-195.313f,
+	23.4375f,
+	19.6567f,
+	-195.313f,
+	27.3438f,
+	18.1324f,
+	-195.313f,
+	31.25f,
+	17.3872f,
+	-195.313f,
+	35.1563f,
+	16.265f,
+	-195.313f,
+	39.0625f,
+	13.8338f,
+	-195.313f,
+	42.9688f,
+	12.7629f,
+	-195.313f,
+	46.875f,
+	13.1006f,
+	-195.313f,
+	50.7813f,
+	13.3481f,
+	-195.313f,
+	54.6875f,
+	13.8039f,
+	-195.313f,
+	58.5938f,
+	13.0621f,
+	-195.313f,
+	62.5f,
+	12.4363f,
+	-195.313f,
+	66.4063f,
+	12.748f,
+	-195.313f,
+	70.3125f,
+	12.2979f,
+	-195.313f,
+	74.2188f,
+	11.3997f,
+	-195.313f,
+	78.125f,
+	12.1637f,
+	-195.313f,
+	82.0313f,
+	12.2143f,
+	-195.313f,
+	85.9375f,
+	12.0963f,
+	-195.313f,
+	89.8438f,
+	11.3468f,
+	-195.313f,
+	93.75f,
+	11.1939f,
+	-195.313f,
+	97.6563f,
+	9.31577f,
+	-195.313f,
+	101.563f,
+	9.0203f,
+	-195.313f,
+	105.469f,
+	8.39154f,
+	-195.313f,
+	109.375f,
+	8.72501f,
+	-195.313f,
+	113.281f,
+	9.3763f,
+	-195.313f,
+	117.188f,
+	9.56963f,
+	-195.313f,
+	121.094f,
+	9.54203f,
+	-195.313f,
+	125.0f,
+	9.30859f,
+	-195.313f,
+	128.906f,
+	9.02325f,
+	-195.313f,
+	132.813f,
+	8.54457f,
+	-195.313f,
+	136.719f,
+	7.91487f,
+	-195.313f,
+	140.625f,
+	5.8935f,
+	-195.313f,
+	144.531f,
+	4.77605f,
+	-195.313f,
+	148.438f,
+	3.03324f,
+	-195.313f,
+	152.344f,
+	2.63999f,
+	-195.313f,
+	156.25f,
+	1.85254f,
+	-195.313f,
+	160.156f,
+	2.58504f,
+	-195.313f,
+	164.063f,
+	1.86646f,
+	-195.313f,
+	167.969f,
+	0.472293f,
+	-195.313f,
+	171.875f,
+	-0.819486f,
+	-195.313f,
+	175.781f,
+	-3.28005f,
+	-195.313f,
+	179.688f,
+	-4.07223f,
+	-195.313f,
+	183.594f,
+	-5.23099f,
+	-195.313f,
+	187.5f,
+	-5.93446f,
+	-195.313f,
+	191.406f,
+	-7.40083f,
+	-195.313f,
+	195.313f,
+	-9.52595f,
+	-195.313f,
+	199.219f,
+	-9.06593f,
+	-195.313f,
+	203.125f,
+	-8.64632f,
+	-195.313f,
+	207.031f,
+	-8.71126f,
+	-195.313f,
+	210.938f,
+	-7.66946f,
+	-195.313f,
+	214.844f,
+	-8.22025f,
+	-195.313f,
+	218.75f,
+	-8.77434f,
+	-195.313f,
+	222.656f,
+	-7.8003f,
+	-195.313f,
+	226.563f,
+	-5.29317f,
+	-195.313f,
+	230.469f,
+	-3.13421f,
+	-195.313f,
+	234.375f,
+	-1.47978f,
+	-195.313f,
+	238.281f,
+	0.0436352f,
+	-195.313f,
+	242.188f,
+	1.56763f,
+	-195.313f,
+	246.094f,
+	3.2707f,
+	-195.313f,
+	250.0f,
+	5.38332f,
+	-195.313f,
+	3.90625f,
+	21.5827f,
+	-199.219f,
+	7.8125f,
+	21.5884f,
+	-199.219f,
+	11.7188f,
+	22.0551f,
+	-199.219f,
+	15.625f,
+	21.1895f,
+	-199.219f,
+	19.5313f,
+	19.9629f,
+	-199.219f,
+	23.4375f,
+	18.1891f,
+	-199.219f,
+	27.3438f,
+	17.3914f,
+	-199.219f,
+	31.25f,
+	15.7832f,
+	-199.219f,
+	35.1563f,
+	13.9537f,
+	-199.219f,
+	39.0625f,
+	11.7784f,
+	-199.219f,
+	42.9688f,
+	12.6473f,
+	-199.219f,
+	46.875f,
+	12.1685f,
+	-199.219f,
+	50.7813f,
+	12.2586f,
+	-199.219f,
+	54.6875f,
+	12.032f,
+	-199.219f,
+	58.5938f,
+	12.5025f,
+	-199.219f,
+	62.5f,
+	12.2207f,
+	-199.219f,
+	66.4063f,
+	10.4332f,
+	-199.219f,
+	70.3125f,
+	10.2093f,
+	-199.219f,
+	74.2188f,
+	9.56536f,
+	-199.219f,
+	78.125f,
+	10.5041f,
+	-199.219f,
+	82.0313f,
+	10.9136f,
+	-199.219f,
+	85.9375f,
+	10.6303f,
+	-199.219f,
+	89.8438f,
+	11.148f,
+	-199.219f,
+	93.75f,
+	10.2169f,
+	-199.219f,
+	97.6563f,
+	8.56966f,
+	-199.219f,
+	101.563f,
+	8.81808f,
+	-199.219f,
+	105.469f,
+	7.92638f,
+	-199.219f,
+	109.375f,
+	7.988f,
+	-199.219f,
+	113.281f,
+	8.07342f,
+	-199.219f,
+	117.188f,
+	8.41463f,
+	-199.219f,
+	121.094f,
+	8.44317f,
+	-199.219f,
+	125.0f,
+	8.93315f,
+	-199.219f,
+	128.906f,
+	8.02242f,
+	-199.219f,
+	132.813f,
+	7.78977f,
+	-199.219f,
+	136.719f,
+	7.24422f,
+	-199.219f,
+	140.625f,
+	6.65469f,
+	-199.219f,
+	144.531f,
+	5.63698f,
+	-199.219f,
+	148.438f,
+	3.71906f,
+	-199.219f,
+	152.344f,
+	1.94989f,
+	-199.219f,
+	156.25f,
+	1.5781f,
+	-199.219f,
+	160.156f,
+	2.54367f,
+	-199.219f,
+	164.063f,
+	2.24455f,
+	-199.219f,
+	167.969f,
+	0.172967f,
+	-199.219f,
+	171.875f,
+	-1.24076f,
+	-199.219f,
+	175.781f,
+	-2.09517f,
+	-199.219f,
+	179.688f,
+	-2.60068f,
+	-199.219f,
+	183.594f,
+	-3.35838f,
+	-199.219f,
+	187.5f,
+	-5.02796f,
+	-199.219f,
+	191.406f,
+	-6.75939f,
+	-199.219f,
+	195.313f,
+	-7.86176f,
+	-199.219f,
+	199.219f,
+	-7.60703f,
+	-199.219f,
+	203.125f,
+	-7.1176f,
+	-199.219f,
+	207.031f,
+	-7.21926f,
+	-199.219f,
+	210.938f,
+	-6.354f,
+	-199.219f,
+	214.844f,
+	-6.26146f,
+	-199.219f,
+	218.75f,
+	-7.39202f,
+	-199.219f,
+	222.656f,
+	-6.10132f,
+	-199.219f,
+	226.563f,
+	-4.15677f,
+	-199.219f,
+	230.469f,
+	-1.72339f,
+	-199.219f,
+	234.375f,
+	0.220408f,
+	-199.219f,
+	238.281f,
+	1.71501f,
+	-199.219f,
+	242.188f,
+	2.32136f,
+	-199.219f,
+	246.094f,
+	3.9302f,
+	-199.219f,
+	250.0f,
+	6.99831f,
+	-199.219f,
+	3.90625f,
+	20.3179f,
+	-203.125f,
+	7.8125f,
+	19.0038f,
+	-203.125f,
+	11.7188f,
+	19.8795f,
+	-203.125f,
+	15.625f,
+	18.863f,
+	-203.125f,
+	19.5313f,
+	17.2513f,
+	-203.125f,
+	23.4375f,
+	16.7786f,
+	-203.125f,
+	27.3438f,
+	16.4605f,
+	-203.125f,
+	31.25f,
+	14.0944f,
+	-203.125f,
+	35.1563f,
+	12.6715f,
+	-203.125f,
+	39.0625f,
+	12.2869f,
+	-203.125f,
+	42.9688f,
+	12.0256f,
+	-203.125f,
+	46.875f,
+	11.4308f,
+	-203.125f,
+	50.7813f,
+	11.5543f,
+	-203.125f,
+	54.6875f,
+	10.8247f,
+	-203.125f,
+	58.5938f,
+	12.5385f,
+	-203.125f,
+	62.5f,
+	12.1754f,
+	-203.125f,
+	66.4063f,
+	10.0857f,
+	-203.125f,
+	70.3125f,
+	8.73654f,
+	-203.125f,
+	74.2188f,
+	8.35323f,
+	-203.125f,
+	78.125f,
+	8.75049f,
+	-203.125f,
+	82.0313f,
+	9.69714f,
+	-203.125f,
+	85.9375f,
+	9.93848f,
+	-203.125f,
+	89.8438f,
+	9.99533f,
+	-203.125f,
+	93.75f,
+	9.28937f,
+	-203.125f,
+	97.6563f,
+	8.19048f,
+	-203.125f,
+	101.563f,
+	7.82659f,
+	-203.125f,
+	105.469f,
+	6.70152f,
+	-203.125f,
+	109.375f,
+	6.35245f,
+	-203.125f,
+	113.281f,
+	6.80811f,
+	-203.125f,
+	117.188f,
+	7.88474f,
+	-203.125f,
+	121.094f,
+	8.76964f,
+	-203.125f,
+	125.0f,
+	9.33913f,
+	-203.125f,
+	128.906f,
+	9.12843f,
+	-203.125f,
+	132.813f,
+	7.62144f,
+	-203.125f,
+	136.719f,
+	6.32841f,
+	-203.125f,
+	140.625f,
+	6.30299f,
+	-203.125f,
+	144.531f,
+	5.78467f,
+	-203.125f,
+	148.438f,
+	4.2404f,
+	-203.125f,
+	152.344f,
+	2.7611f,
+	-203.125f,
+	156.25f,
+	1.95904f,
+	-203.125f,
+	160.156f,
+	2.27166f,
+	-203.125f,
+	164.063f,
+	2.22405f,
+	-203.125f,
+	167.969f,
+	1.12279f,
+	-203.125f,
+	171.875f,
+	-0.169061f,
+	-203.125f,
+	175.781f,
+	-0.887647f,
+	-203.125f,
+	179.688f,
+	-0.896535f,
+	-203.125f,
+	183.594f,
+	-2.41604f,
+	-203.125f,
+	187.5f,
+	-3.63423f,
+	-203.125f,
+	191.406f,
+	-6.00826f,
+	-203.125f,
+	195.313f,
+	-5.87316f,
+	-203.125f,
+	199.219f,
+	-5.18767f,
+	-203.125f,
+	203.125f,
+	-4.23762f,
+	-203.125f,
+	207.031f,
+	-4.7338f,
+	-203.125f,
+	210.938f,
+	-4.88225f,
+	-203.125f,
+	214.844f,
+	-4.82274f,
+	-203.125f,
+	218.75f,
+	-5.06338f,
+	-203.125f,
+	222.656f,
+	-5.13737f,
+	-203.125f,
+	226.563f,
+	-2.74217f,
+	-203.125f,
+	230.469f,
+	0.0831564f,
+	-203.125f,
+	234.375f,
+	2.00986f,
+	-203.125f,
+	238.281f,
+	2.89937f,
+	-203.125f,
+	242.188f,
+	3.79442f,
+	-203.125f,
+	246.094f,
+	5.43821f,
+	-203.125f,
+	250.0f,
+	8.47222f,
+	-203.125f,
+	3.90625f,
+	18.3149f,
+	-207.031f,
+	7.8125f,
+	16.9318f,
+	-207.031f,
+	11.7188f,
+	16.7123f,
+	-207.031f,
+	15.625f,
+	16.066f,
+	-207.031f,
+	19.5313f,
+	15.8401f,
+	-207.031f,
+	23.4375f,
+	14.9793f,
+	-207.031f,
+	27.3438f,
+	13.5136f,
+	-207.031f,
+	31.25f,
+	12.316f,
+	-207.031f,
+	35.1563f,
+	12.4286f,
+	-207.031f,
+	39.0625f,
+	12.5926f,
+	-207.031f,
+	42.9688f,
+	12.419f,
+	-207.031f,
+	46.875f,
+	11.7087f,
+	-207.031f,
+	50.7813f,
+	10.9033f,
+	-207.031f,
+	54.6875f,
+	10.2175f,
+	-207.031f,
+	58.5938f,
+	10.7307f,
+	-207.031f,
+	62.5f,
+	9.9283f,
+	-207.031f,
+	66.4063f,
+	9.11458f,
+	-207.031f,
+	70.3125f,
+	6.81804f,
+	-207.031f,
+	74.2188f,
+	6.85559f,
+	-207.031f,
+	78.125f,
+	6.98146f,
+	-207.031f,
+	82.0313f,
+	8.41059f,
+	-207.031f,
+	85.9375f,
+	8.81018f,
+	-207.031f,
+	89.8438f,
+	9.25882f,
+	-207.031f,
+	93.75f,
+	8.4973f,
+	-207.031f,
+	97.6563f,
+	7.11312f,
+	-207.031f,
+	101.563f,
+	6.11367f,
+	-207.031f,
+	105.469f,
+	4.54171f,
+	-207.031f,
+	109.375f,
+	3.984f,
+	-207.031f,
+	113.281f,
+	6.23536f,
+	-207.031f,
+	117.188f,
+	7.41972f,
+	-207.031f,
+	121.094f,
+	8.40005f,
+	-207.031f,
+	125.0f,
+	9.21009f,
+	-207.031f,
+	128.906f,
+	9.10113f,
+	-207.031f,
+	132.813f,
+	8.69785f,
+	-207.031f,
+	136.719f,
+	7.08314f,
+	-207.031f,
+	140.625f,
+	6.14113f,
+	-207.031f,
+	144.531f,
+	4.85123f,
+	-207.031f,
+	148.438f,
+	4.53013f,
+	-207.031f,
+	152.344f,
+	4.73052f,
+	-207.031f,
+	156.25f,
+	3.50435f,
+	-207.031f,
+	160.156f,
+	3.02093f,
+	-207.031f,
+	164.063f,
+	2.65317f,
+	-207.031f,
+	167.969f,
+	1.91936f,
+	-207.031f,
+	171.875f,
+	1.31638f,
+	-207.031f,
+	175.781f,
+	0.631767f,
+	-207.031f,
+	179.688f,
+	-0.185018f,
+	-207.031f,
+	183.594f,
+	-1.04617f,
+	-207.031f,
+	187.5f,
+	-2.59594f,
+	-207.031f,
+	191.406f,
+	-3.62219f,
+	-207.031f,
+	195.313f,
+	-3.17366f,
+	-207.031f,
+	199.219f,
+	-3.0812f,
+	-207.031f,
+	203.125f,
+	-2.21365f,
+	-207.031f,
+	207.031f,
+	-3.02851f,
+	-207.031f,
+	210.938f,
+	-4.12823f,
+	-207.031f,
+	214.844f,
+	-3.42208f,
+	-207.031f,
+	218.75f,
+	-3.83284f,
+	-207.031f,
+	222.656f,
+	-3.83483f,
+	-207.031f,
+	226.563f,
+	-1.81388f,
+	-207.031f,
+	230.469f,
+	1.06182f,
+	-207.031f,
+	234.375f,
+	3.0063f,
+	-207.031f,
+	238.281f,
+	3.97581f,
+	-207.031f,
+	242.188f,
+	5.25584f,
+	-207.031f,
+	246.094f,
+	6.1092f,
+	-207.031f,
+	250.0f,
+	9.89458f,
+	-207.031f,
+	3.90625f,
+	16.2147f,
+	-210.938f,
+	7.8125f,
+	15.8155f,
+	-210.938f,
+	11.7188f,
+	14.9704f,
+	-210.938f,
+	15.625f,
+	14.6853f,
+	-210.938f,
+	19.5313f,
+	14.3326f,
+	-210.938f,
+	23.4375f,
+	14.0488f,
+	-210.938f,
+	27.3438f,
+	12.2057f,
+	-210.938f,
+	31.25f,
+	12.7526f,
+	-210.938f,
+	35.1563f,
+	13.1468f,
+	-210.938f,
+	39.0625f,
+	12.959f,
+	-210.938f,
+	42.9688f,
+	12.3931f,
+	-210.938f,
+	46.875f,
+	11.9578f,
+	-210.938f,
+	50.7813f,
+	10.5381f,
+	-210.938f,
+	54.6875f,
+	9.28222f,
+	-210.938f,
+	58.5938f,
+	9.20117f,
+	-210.938f,
+	62.5f,
+	8.74359f,
+	-210.938f,
+	66.4063f,
+	7.58308f,
+	-210.938f,
+	70.3125f,
+	5.98903f,
+	-210.938f,
+	74.2188f,
+	5.92315f,
+	-210.938f,
+	78.125f,
+	6.30208f,
+	-210.938f,
+	82.0313f,
+	7.35787f,
+	-210.938f,
+	85.9375f,
+	7.64729f,
+	-210.938f,
+	89.8438f,
+	7.89394f,
+	-210.938f,
+	93.75f,
+	7.64523f,
+	-210.938f,
+	97.6563f,
+	5.66526f,
+	-210.938f,
+	101.563f,
+	4.1348f,
+	-210.938f,
+	105.469f,
+	2.65548f,
+	-210.938f,
+	109.375f,
+	4.20615f,
+	-210.938f,
+	113.281f,
+	5.82801f,
+	-210.938f,
+	117.188f,
+	6.92681f,
+	-210.938f,
+	121.094f,
+	8.52107f,
+	-210.938f,
+	125.0f,
+	9.29929f,
+	-210.938f,
+	128.906f,
+	10.1454f,
+	-210.938f,
+	132.813f,
+	9.39782f,
+	-210.938f,
+	136.719f,
+	8.72704f,
+	-210.938f,
+	140.625f,
+	7.91058f,
+	-210.938f,
+	144.531f,
+	5.32835f,
+	-210.938f,
+	148.438f,
+	5.30143f,
+	-210.938f,
+	152.344f,
+	4.98294f,
+	-210.938f,
+	156.25f,
+	5.27331f,
+	-210.938f,
+	160.156f,
+	4.054f,
+	-210.938f,
+	164.063f,
+	4.25352f,
+	-210.938f,
+	167.969f,
+	3.60791f,
+	-210.938f,
+	171.875f,
+	2.94898f,
+	-210.938f,
+	175.781f,
+	1.97064f,
+	-210.938f,
+	179.688f,
+	1.21275f,
+	-210.938f,
+	183.594f,
+	-0.419751f,
+	-210.938f,
+	187.5f,
+	-1.77221f,
+	-210.938f,
+	191.406f,
+	-1.94763f,
+	-210.938f,
+	195.313f,
+	-1.32172f,
+	-210.938f,
+	199.219f,
+	-1.74453f,
+	-210.938f,
+	203.125f,
+	-0.694964f,
+	-210.938f,
+	207.031f,
+	-1.77277f,
+	-210.938f,
+	210.938f,
+	-2.39571f,
+	-210.938f,
+	214.844f,
+	-2.61021f,
+	-210.938f,
+	218.75f,
+	-3.16f,
+	-210.938f,
+	222.656f,
+	-2.46606f,
+	-210.938f,
+	226.563f,
+	-0.862086f,
+	-210.938f,
+	230.469f,
+	1.4487f,
+	-210.938f,
+	234.375f,
+	3.44239f,
+	-210.938f,
+	238.281f,
+	5.41949f,
+	-210.938f,
+	242.188f,
+	6.28416f,
+	-210.938f,
+	246.094f,
+	7.24993f,
+	-210.938f,
+	250.0f,
+	10.7227f,
+	-210.938f,
+	3.90625f,
+	14.284f,
+	-214.844f,
+	7.8125f,
+	14.031f,
+	-214.844f,
+	11.7188f,
+	12.8153f,
+	-214.844f,
+	15.625f,
+	12.2914f,
+	-214.844f,
+	19.5313f,
+	12.0657f,
+	-214.844f,
+	23.4375f,
+	12.4452f,
+	-214.844f,
+	27.3438f,
+	12.703f,
+	-214.844f,
+	31.25f,
+	12.3401f,
+	-214.844f,
+	35.1563f,
+	13.2219f,
+	-214.844f,
+	39.0625f,
+	12.9074f,
+	-214.844f,
+	42.9688f,
+	12.5934f,
+	-214.844f,
+	46.875f,
+	11.4717f,
+	-214.844f,
+	50.7813f,
+	10.548f,
+	-214.844f,
+	54.6875f,
+	9.43614f,
+	-214.844f,
+	58.5938f,
+	10.0982f,
+	-214.844f,
+	62.5f,
+	9.36536f,
+	-214.844f,
+	66.4063f,
+	8.07196f,
+	-214.844f,
+	70.3125f,
+	6.4483f,
+	-214.844f,
+	74.2188f,
+	5.80499f,
+	-214.844f,
+	78.125f,
+	5.60605f,
+	-214.844f,
+	82.0313f,
+	6.64906f,
+	-214.844f,
+	85.9375f,
+	7.64402f,
+	-214.844f,
+	89.8438f,
+	8.31151f,
+	-214.844f,
+	93.75f,
+	7.97344f,
+	-214.844f,
+	97.6563f,
+	5.39549f,
+	-214.844f,
+	101.563f,
+	3.66809f,
+	-214.844f,
+	105.469f,
+	3.2001f,
+	-214.844f,
+	109.375f,
+	5.91373f,
+	-214.844f,
+	113.281f,
+	7.40339f,
+	-214.844f,
+	117.188f,
+	8.30807f,
+	-214.844f,
+	121.094f,
+	9.75774f,
+	-214.844f,
+	125.0f,
+	10.2383f,
+	-214.844f,
+	128.906f,
+	10.3408f,
+	-214.844f,
+	132.813f,
+	10.6262f,
+	-214.844f,
+	136.719f,
+	10.8818f,
+	-214.844f,
+	140.625f,
+	9.09087f,
+	-214.844f,
+	144.531f,
+	6.48291f,
+	-214.844f,
+	148.438f,
+	5.02116f,
+	-214.844f,
+	152.344f,
+	5.97543f,
+	-214.844f,
+	156.25f,
+	6.33053f,
+	-214.844f,
+	160.156f,
+	5.91049f,
+	-214.844f,
+	164.063f,
+	5.03025f,
+	-214.844f,
+	167.969f,
+	5.01201f,
+	-214.844f,
+	171.875f,
+	4.36222f,
+	-214.844f,
+	175.781f,
+	3.69208f,
+	-214.844f,
+	179.688f,
+	2.96539f,
+	-214.844f,
+	183.594f,
+	1.43789f,
+	-214.844f,
+	187.5f,
+	-0.374301f,
+	-214.844f,
+	191.406f,
+	-0.955695f,
+	-214.844f,
+	195.313f,
+	-0.123769f,
+	-214.844f,
+	199.219f,
+	-0.113436f,
+	-214.844f,
+	203.125f,
+	-0.0171993f,
+	-214.844f,
+	207.031f,
+	-1.0984f,
+	-214.844f,
+	210.938f,
+	-1.10949f,
+	-214.844f,
+	214.844f,
+	-1.92471f,
+	-214.844f,
+	218.75f,
+	-2.26183f,
+	-214.844f,
+	222.656f,
+	-1.32064f,
+	-214.844f,
+	226.563f,
+	0.209158f,
+	-214.844f,
+	230.469f,
+	2.41199f,
+	-214.844f,
+	234.375f,
+	4.66871f,
+	-214.844f,
+	238.281f,
+	6.29773f,
+	-214.844f,
+	242.188f,
+	7.20184f,
+	-214.844f,
+	246.094f,
+	8.08018f,
+	-214.844f,
+	250.0f,
+	10.3057f,
+	-214.844f,
+	3.90625f,
+	13.272f,
+	-218.75f,
+	7.8125f,
+	12.8218f,
+	-218.75f,
+	11.7188f,
+	11.8102f,
+	-218.75f,
+	15.625f,
+	11.7105f,
+	-218.75f,
+	19.5313f,
+	11.5191f,
+	-218.75f,
+	23.4375f,
+	12.1253f,
+	-218.75f,
+	27.3438f,
+	12.0266f,
+	-218.75f,
+	31.25f,
+	12.3549f,
+	-218.75f,
+	35.1563f,
+	12.3822f,
+	-218.75f,
+	39.0625f,
+	12.268f,
+	-218.75f,
+	42.9688f,
+	12.5022f,
+	-218.75f,
+	46.875f,
+	11.2878f,
+	-218.75f,
+	50.7813f,
+	10.1823f,
+	-218.75f,
+	54.6875f,
+	10.4244f,
+	-218.75f,
+	58.5938f,
+	10.0047f,
+	-218.75f,
+	62.5f,
+	9.96061f,
+	-218.75f,
+	66.4063f,
+	8.64873f,
+	-218.75f,
+	70.3125f,
+	6.45636f,
+	-218.75f,
+	74.2188f,
+	5.30254f,
+	-218.75f,
+	78.125f,
+	5.2915f,
+	-218.75f,
+	82.0313f,
+	7.2575f,
+	-218.75f,
+	85.9375f,
+	8.1568f,
+	-218.75f,
+	89.8438f,
+	8.97514f,
+	-218.75f,
+	93.75f,
+	7.72908f,
+	-218.75f,
+	97.6563f,
+	5.41501f,
+	-218.75f,
+	101.563f,
+	4.24025f,
+	-218.75f,
+	105.469f,
+	5.39134f,
+	-218.75f,
+	109.375f,
+	7.69518f,
+	-218.75f,
+	113.281f,
+	8.87616f,
+	-218.75f,
+	117.188f,
+	9.44758f,
+	-218.75f,
+	121.094f,
+	9.21473f,
+	-218.75f,
+	125.0f,
+	10.1366f,
+	-218.75f,
+	128.906f,
+	11.6088f,
+	-218.75f,
+	132.813f,
+	12.0083f,
+	-218.75f,
+	136.719f,
+	12.3184f,
+	-218.75f,
+	140.625f,
+	10.8438f,
+	-218.75f,
+	144.531f,
+	7.65837f,
+	-218.75f,
+	148.438f,
+	6.07316f,
+	-218.75f,
+	152.344f,
+	6.4613f,
+	-218.75f,
+	156.25f,
+	7.01972f,
+	-218.75f,
+	160.156f,
+	7.25454f,
+	-218.75f,
+	164.063f,
+	6.31416f,
+	-218.75f,
+	167.969f,
+	6.48096f,
+	-218.75f,
+	171.875f,
+	5.89274f,
+	-218.75f,
+	175.781f,
+	5.71289f,
+	-218.75f,
+	179.688f,
+	4.3046f,
+	-218.75f,
+	183.594f,
+	2.49719f,
+	-218.75f,
+	187.5f,
+	1.16956f,
+	-218.75f,
+	191.406f,
+	1.21673f,
+	-218.75f,
+	195.313f,
+	1.19652f,
+	-218.75f,
+	199.219f,
+	1.27819f,
+	-218.75f,
+	203.125f,
+	1.06325f,
+	-218.75f,
+	207.031f,
+	0.133118f,
+	-218.75f,
+	210.938f,
+	-0.283675f,
+	-218.75f,
+	214.844f,
+	-0.471323f,
+	-218.75f,
+	218.75f,
+	-0.941533f,
+	-218.75f,
+	222.656f,
+	-0.953851f,
+	-218.75f,
+	226.563f,
+	0.751216f,
+	-218.75f,
+	230.469f,
+	2.54245f,
+	-218.75f,
+	234.375f,
+	5.17863f,
+	-218.75f,
+	238.281f,
+	7.22669f,
+	-218.75f,
+	242.188f,
+	8.44723f,
+	-218.75f,
+	246.094f,
+	8.59229f,
+	-218.75f,
+	250.0f,
+	10.4333f,
+	-218.75f,
+	3.90625f,
+	13.0199f,
+	-222.656f,
+	7.8125f,
+	13.1789f,
+	-222.656f,
+	11.7188f,
+	12.4614f,
+	-222.656f,
+	15.625f,
+	10.8521f,
+	-222.656f,
+	19.5313f,
+	11.2552f,
+	-222.656f,
+	23.4375f,
+	12.1618f,
+	-222.656f,
+	27.3438f,
+	12.6207f,
+	-222.656f,
+	31.25f,
+	12.7195f,
+	-222.656f,
+	35.1563f,
+	12.6379f,
+	-222.656f,
+	39.0625f,
+	12.5247f,
+	-222.656f,
+	42.9688f,
+	11.5493f,
+	-222.656f,
+	46.875f,
+	11.1218f,
+	-222.656f,
+	50.7813f,
+	11.1036f,
+	-222.656f,
+	54.6875f,
+	11.2909f,
+	-222.656f,
+	58.5938f,
+	9.99718f,
+	-222.656f,
+	62.5f,
+	9.07075f,
+	-222.656f,
+	66.4063f,
+	7.85904f,
+	-222.656f,
+	70.3125f,
+	6.00034f,
+	-222.656f,
+	74.2188f,
+	6.20222f,
+	-222.656f,
+	78.125f,
+	6.90091f,
+	-222.656f,
+	82.0313f,
+	8.15724f,
+	-222.656f,
+	85.9375f,
+	8.92624f,
+	-222.656f,
+	89.8438f,
+	9.54135f,
+	-222.656f,
+	93.75f,
+	8.05473f,
+	-222.656f,
+	97.6563f,
+	5.80654f,
+	-222.656f,
+	101.563f,
+	5.02178f,
+	-222.656f,
+	105.469f,
+	7.15584f,
+	-222.656f,
+	109.375f,
+	8.94755f,
+	-222.656f,
+	113.281f,
+	9.86631f,
+	-222.656f,
+	117.188f,
+	10.6421f,
+	-222.656f,
+	121.094f,
+	10.7891f,
+	-222.656f,
+	125.0f,
+	11.0716f,
+	-222.656f,
+	128.906f,
+	12.6376f,
+	-222.656f,
+	132.813f,
+	12.4373f,
+	-222.656f,
+	136.719f,
+	12.1143f,
+	-222.656f,
+	140.625f,
+	11.4028f,
+	-222.656f,
+	144.531f,
+	8.95242f,
+	-222.656f,
+	148.438f,
+	6.83012f,
+	-222.656f,
+	152.344f,
+	7.65217f,
+	-222.656f,
+	156.25f,
+	8.26579f,
+	-222.656f,
+	160.156f,
+	7.9665f,
+	-222.656f,
+	164.063f,
+	7.5217f,
+	-222.656f,
+	167.969f,
+	7.17758f,
+	-222.656f,
+	171.875f,
+	5.9966f,
+	-222.656f,
+	175.781f,
+	5.77514f,
+	-222.656f,
+	179.688f,
+	4.77675f,
+	-222.656f,
+	183.594f,
+	3.39545f,
+	-222.656f,
+	187.5f,
+	2.95911f,
+	-222.656f,
+	191.406f,
+	1.85368f,
+	-222.656f,
+	195.313f,
+	1.31365f,
+	-222.656f,
+	199.219f,
+	1.12622f,
+	-222.656f,
+	203.125f,
+	1.47676f,
+	-222.656f,
+	207.031f,
+	1.89446f,
+	-222.656f,
+	210.938f,
+	0.63056f,
+	-222.656f,
+	214.844f,
+	0.297565f,
+	-222.656f,
+	218.75f,
+	-0.0109998f,
+	-222.656f,
+	222.656f,
+	-0.225082f,
+	-222.656f,
+	226.563f,
+	0.63258f,
+	-222.656f,
+	230.469f,
+	2.89831f,
+	-222.656f,
+	234.375f,
+	5.64839f,
+	-222.656f,
+	238.281f,
+	7.22414f,
+	-222.656f,
+	242.188f,
+	7.89951f,
+	-222.656f,
+	246.094f,
+	8.80151f,
+	-222.656f,
+	250.0f,
+	10.9602f,
+	-222.656f,
+	3.90625f,
+	11.9733f,
+	-226.563f,
+	7.8125f,
+	12.8862f,
+	-226.563f,
+	11.7188f,
+	12.1283f,
+	-226.563f,
+	15.625f,
+	10.7234f,
+	-226.563f,
+	19.5313f,
+	11.6866f,
+	-226.563f,
+	23.4375f,
+	12.6552f,
+	-226.563f,
+	27.3438f,
+	12.7353f,
+	-226.563f,
+	31.25f,
+	11.7992f,
+	-226.563f,
+	35.1563f,
+	11.2006f,
+	-226.563f,
+	39.0625f,
+	10.9699f,
+	-226.563f,
+	42.9688f,
+	10.7653f,
+	-226.563f,
+	46.875f,
+	10.9947f,
+	-226.563f,
+	50.7813f,
+	11.2791f,
+	-226.563f,
+	54.6875f,
+	11.0716f,
+	-226.563f,
+	58.5938f,
+	10.7092f,
+	-226.563f,
+	62.5f,
+	9.16355f,
+	-226.563f,
+	66.4063f,
+	7.59431f,
+	-226.563f,
+	70.3125f,
+	6.68502f,
+	-226.563f,
+	74.2188f,
+	6.98133f,
+	-226.563f,
+	78.125f,
+	7.72239f,
+	-226.563f,
+	82.0313f,
+	9.00293f,
+	-226.563f,
+	85.9375f,
+	9.47866f,
+	-226.563f,
+	89.8438f,
+	8.94458f,
+	-226.563f,
+	93.75f,
+	7.79648f,
+	-226.563f,
+	97.6563f,
+	6.07787f,
+	-226.563f,
+	101.563f,
+	6.60546f,
+	-226.563f,
+	105.469f,
+	8.5652f,
+	-226.563f,
+	109.375f,
+	10.2869f,
+	-226.563f,
+	113.281f,
+	11.4751f,
+	-226.563f,
+	117.188f,
+	11.6224f,
+	-226.563f,
+	121.094f,
+	12.0803f,
+	-226.563f,
+	125.0f,
+	12.5335f,
+	-226.563f,
+	128.906f,
+	13.5918f,
+	-226.563f,
+	132.813f,
+	12.9198f,
+	-226.563f,
+	136.719f,
+	11.521f,
+	-226.563f,
+	140.625f,
+	10.6418f,
+	-226.563f,
+	144.531f,
+	8.8393f,
+	-226.563f,
+	148.438f,
+	8.79941f,
+	-226.563f,
+	152.344f,
+	9.4929f,
+	-226.563f,
+	156.25f,
+	9.96206f,
+	-226.563f,
+	160.156f,
+	8.75524f,
+	-226.563f,
+	164.063f,
+	7.64157f,
+	-226.563f,
+	167.969f,
+	7.1963f,
+	-226.563f,
+	171.875f,
+	6.83929f,
+	-226.563f,
+	175.781f,
+	6.10665f,
+	-226.563f,
+	179.688f,
+	4.70473f,
+	-226.563f,
+	183.594f,
+	4.54758f,
+	-226.563f,
+	187.5f,
+	3.58616f,
+	-226.563f,
+	191.406f,
+	2.97998f,
+	-226.563f,
+	195.313f,
+	1.49179f,
+	-226.563f,
+	199.219f,
+	1.85834f,
+	-226.563f,
+	203.125f,
+	1.49089f,
+	-226.563f,
+	207.031f,
+	1.39949f,
+	-226.563f,
+	210.938f,
+	0.863002f,
+	-226.563f,
+	214.844f,
+	1.15546f,
+	-226.563f,
+	218.75f,
+	0.609373f,
+	-226.563f,
+	222.656f,
+	1.04332f,
+	-226.563f,
+	226.563f,
+	1.58038f,
+	-226.563f,
+	230.469f,
+	4.11549f,
+	-226.563f,
+	234.375f,
+	5.64696f,
+	-226.563f,
+	238.281f,
+	6.61687f,
+	-226.563f,
+	242.188f,
+	7.3113f,
+	-226.563f,
+	246.094f,
+	8.56955f,
+	-226.563f,
+	250.0f,
+	10.7891f,
+	-226.563f,
+	3.90625f,
+	10.4619f,
+	-230.469f,
+	7.8125f,
+	11.4179f,
+	-230.469f,
+	11.7188f,
+	10.7841f,
+	-230.469f,
+	15.625f,
+	10.597f,
+	-230.469f,
+	19.5313f,
+	10.9999f,
+	-230.469f,
+	23.4375f,
+	11.5972f,
+	-230.469f,
+	27.3438f,
+	11.4553f,
+	-230.469f,
+	31.25f,
+	10.1015f,
+	-230.469f,
+	35.1563f,
+	10.412f,
+	-230.469f,
+	39.0625f,
+	9.72694f,
+	-230.469f,
+	42.9688f,
+	9.71973f,
+	-230.469f,
+	46.875f,
+	10.7767f,
+	-230.469f,
+	50.7813f,
+	10.8775f,
+	-230.469f,
+	54.6875f,
+	10.3186f,
+	-230.469f,
+	58.5938f,
+	10.4188f,
+	-230.469f,
+	62.5f,
+	8.94879f,
+	-230.469f,
+	66.4063f,
+	7.92103f,
+	-230.469f,
+	70.3125f,
+	8.48295f,
+	-230.469f,
+	74.2188f,
+	8.74782f,
+	-230.469f,
+	78.125f,
+	8.87976f,
+	-230.469f,
+	82.0313f,
+	9.68632f,
+	-230.469f,
+	85.9375f,
+	9.54993f,
+	-230.469f,
+	89.8438f,
+	9.04624f,
+	-230.469f,
+	93.75f,
+	8.49407f,
+	-230.469f,
+	97.6563f,
+	7.90008f,
+	-230.469f,
+	101.563f,
+	9.20657f,
+	-230.469f,
+	105.469f,
+	10.5114f,
+	-230.469f,
+	109.375f,
+	11.5284f,
+	-230.469f,
+	113.281f,
+	12.0378f,
+	-230.469f,
+	117.188f,
+	12.9398f,
+	-230.469f,
+	121.094f,
+	13.1489f,
+	-230.469f,
+	125.0f,
+	13.8974f,
+	-230.469f,
+	128.906f,
+	14.5048f,
+	-230.469f,
+	132.813f,
+	13.1823f,
+	-230.469f,
+	136.719f,
+	11.6226f,
+	-230.469f,
+	140.625f,
+	11.1108f,
+	-230.469f,
+	144.531f,
+	10.0418f,
+	-230.469f,
+	148.438f,
+	10.2026f,
+	-230.469f,
+	152.344f,
+	10.9585f,
+	-230.469f,
+	156.25f,
+	11.0258f,
+	-230.469f,
+	160.156f,
+	9.88552f,
+	-230.469f,
+	164.063f,
+	8.92538f,
+	-230.469f,
+	167.969f,
+	7.90306f,
+	-230.469f,
+	171.875f,
+	7.23733f,
+	-230.469f,
+	175.781f,
+	6.09503f,
+	-230.469f,
+	179.688f,
+	5.15065f,
+	-230.469f,
+	183.594f,
+	4.73006f,
+	-230.469f,
+	187.5f,
+	4.05091f,
+	-230.469f,
+	191.406f,
+	3.01834f,
+	-230.469f,
+	195.313f,
+	1.83317f,
+	-230.469f,
+	199.219f,
+	2.77945f,
+	-230.469f,
+	203.125f,
+	3.05633f,
+	-230.469f,
+	207.031f,
+	2.07007f,
+	-230.469f,
+	210.938f,
+	2.01993f,
+	-230.469f,
+	214.844f,
+	2.13491f,
+	-230.469f,
+	218.75f,
+	1.65812f,
+	-230.469f,
+	222.656f,
+	1.8404f,
+	-230.469f,
+	226.563f,
+	2.78297f,
+	-230.469f,
+	230.469f,
+	3.94561f,
+	-230.469f,
+	234.375f,
+	5.83019f,
+	-230.469f,
+	238.281f,
+	6.9093f,
+	-230.469f,
+	242.188f,
+	7.96229f,
+	-230.469f,
+	246.094f,
+	7.63052f,
+	-230.469f,
+	250.0f,
+	10.2449f,
+	-230.469f,
+	3.90625f,
+	8.85224f,
+	-234.375f,
+	7.8125f,
+	9.40139f,
+	-234.375f,
+	11.7188f,
+	9.62814f,
+	-234.375f,
+	15.625f,
+	9.97075f,
+	-234.375f,
+	19.5313f,
+	9.96073f,
+	-234.375f,
+	23.4375f,
+	9.70541f,
+	-234.375f,
+	27.3438f,
+	10.0435f,
+	-234.375f,
+	31.25f,
+	9.85879f,
+	-234.375f,
+	35.1563f,
+	9.52681f,
+	-234.375f,
+	39.0625f,
+	8.75341f,
+	-234.375f,
+	42.9688f,
+	8.99686f,
+	-234.375f,
+	46.875f,
+	9.56309f,
+	-234.375f,
+	50.7813f,
+	9.54486f,
+	-234.375f,
+	54.6875f,
+	10.0225f,
+	-234.375f,
+	58.5938f,
+	9.56394f,
+	-234.375f,
+	62.5f,
+	9.18474f,
+	-234.375f,
+	66.4063f,
+	9.29208f,
+	-234.375f,
+	70.3125f,
+	10.4881f,
+	-234.375f,
+	74.2188f,
+	10.8865f,
+	-234.375f,
+	78.125f,
+	11.0201f,
+	-234.375f,
+	82.0313f,
+	11.7722f,
+	-234.375f,
+	85.9375f,
+	11.1624f,
+	-234.375f,
+	89.8438f,
+	10.602f,
+	-234.375f,
+	93.75f,
+	9.93284f,
+	-234.375f,
+	97.6563f,
+	10.2532f,
+	-234.375f,
+	101.563f,
+	11.0848f,
+	-234.375f,
+	105.469f,
+	12.6576f,
+	-234.375f,
+	109.375f,
+	13.4783f,
+	-234.375f,
+	113.281f,
+	14.7992f,
+	-234.375f,
+	117.188f,
+	15.3803f,
+	-234.375f,
+	121.094f,
+	15.9985f,
+	-234.375f,
+	125.0f,
+	14.9035f,
+	-234.375f,
+	128.906f,
+	14.2715f,
+	-234.375f,
+	132.813f,
+	14.0098f,
+	-234.375f,
+	136.719f,
+	13.1141f,
+	-234.375f,
+	140.625f,
+	12.5809f,
+	-234.375f,
+	144.531f,
+	11.8546f,
+	-234.375f,
+	148.438f,
+	11.5219f,
+	-234.375f,
+	152.344f,
+	11.8842f,
+	-234.375f,
+	156.25f,
+	11.6581f,
+	-234.375f,
+	160.156f,
+	10.8307f,
+	-234.375f,
+	164.063f,
+	10.2712f,
+	-234.375f,
+	167.969f,
+	8.58443f,
+	-234.375f,
+	171.875f,
+	7.00592f,
+	-234.375f,
+	175.781f,
+	5.65553f,
+	-234.375f,
+	179.688f,
+	5.07429f,
+	-234.375f,
+	183.594f,
+	4.41004f,
+	-234.375f,
+	187.5f,
+	3.95516f,
+	-234.375f,
+	191.406f,
+	3.42243f,
+	-234.375f,
+	195.313f,
+	2.54334f,
+	-234.375f,
+	199.219f,
+	3.95931f,
+	-234.375f,
+	203.125f,
+	3.9139f,
+	-234.375f,
+	207.031f,
+	2.90644f,
+	-234.375f,
+	210.938f,
+	3.11525f,
+	-234.375f,
+	214.844f,
+	3.33135f,
+	-234.375f,
+	218.75f,
+	2.64229f,
+	-234.375f,
+	222.656f,
+	2.64397f,
+	-234.375f,
+	226.563f,
+	3.186f,
+	-234.375f,
+	230.469f,
+	4.46201f,
+	-234.375f,
+	234.375f,
+	5.92783f,
+	-234.375f,
+	238.281f,
+	6.79968f,
+	-234.375f,
+	242.188f,
+	8.7067f,
+	-234.375f,
+	246.094f,
+	8.47322f,
+	-234.375f,
+	250.0f,
+	10.3839f,
+	-234.375f,
+	3.90625f,
+	7.99527f,
+	-238.281f,
+	7.8125f,
+	8.62199f,
+	-238.281f,
+	11.7188f,
+	9.06695f,
+	-238.281f,
+	15.625f,
+	9.12589f,
+	-238.281f,
+	19.5313f,
+	8.97926f,
+	-238.281f,
+	23.4375f,
+	9.75152f,
+	-238.281f,
+	27.3438f,
+	9.58038f,
+	-238.281f,
+	31.25f,
+	9.30169f,
+	-238.281f,
+	35.1563f,
+	8.63599f,
+	-238.281f,
+	39.0625f,
+	8.72973f,
+	-238.281f,
+	42.9688f,
+	8.49513f,
+	-238.281f,
+	46.875f,
+	8.78362f,
+	-238.281f,
+	50.7813f,
+	8.75045f,
+	-238.281f,
+	54.6875f,
+	8.96186f,
+	-238.281f,
+	58.5938f,
+	10.0611f,
+	-238.281f,
+	62.5f,
+	11.1275f,
+	-238.281f,
+	66.4063f,
+	10.8209f,
+	-238.281f,
+	70.3125f,
+	12.0108f,
+	-238.281f,
+	74.2188f,
+	13.2126f,
+	-238.281f,
+	78.125f,
+	14.1323f,
+	-238.281f,
+	82.0313f,
+	14.3575f,
+	-238.281f,
+	85.9375f,
+	13.2781f,
+	-238.281f,
+	89.8438f,
+	12.8024f,
+	-238.281f,
+	93.75f,
+	12.0484f,
+	-238.281f,
+	97.6563f,
+	12.7657f,
+	-238.281f,
+	101.563f,
+	14.0307f,
+	-238.281f,
+	105.469f,
+	15.9567f,
+	-238.281f,
+	109.375f,
+	17.7803f,
+	-238.281f,
+	113.281f,
+	19.0777f,
+	-238.281f,
+	117.188f,
+	18.7555f,
+	-238.281f,
+	121.094f,
+	18.8129f,
+	-238.281f,
+	125.0f,
+	17.4807f,
+	-238.281f,
+	128.906f,
+	16.4022f,
+	-238.281f,
+	132.813f,
+	16.01f,
+	-238.281f,
+	136.719f,
+	15.1852f,
+	-238.281f,
+	140.625f,
+	13.9301f,
+	-238.281f,
+	144.531f,
+	12.8841f,
+	-238.281f,
+	148.438f,
+	11.7108f,
+	-238.281f,
+	152.344f,
+	11.414f,
+	-238.281f,
+	156.25f,
+	11.056f,
+	-238.281f,
+	160.156f,
+	10.8688f,
+	-238.281f,
+	164.063f,
+	10.5672f,
+	-238.281f,
+	167.969f,
+	10.0938f,
+	-238.281f,
+	171.875f,
+	7.73603f,
+	-238.281f,
+	175.781f,
+	5.94931f,
+	-238.281f,
+	179.688f,
+	5.51512f,
+	-238.281f,
+	183.594f,
+	5.27449f,
+	-238.281f,
+	187.5f,
+	4.94763f,
+	-238.281f,
+	191.406f,
+	4.13161f,
+	-238.281f,
+	195.313f,
+	3.59426f,
+	-238.281f,
+	199.219f,
+	4.03163f,
+	-238.281f,
+	203.125f,
+	4.38188f,
+	-238.281f,
+	207.031f,
+	3.09959f,
+	-238.281f,
+	210.938f,
+	3.1766f,
+	-238.281f,
+	214.844f,
+	3.05715f,
+	-238.281f,
+	218.75f,
+	3.20329f,
+	-238.281f,
+	222.656f,
+	2.53565f,
+	-238.281f,
+	226.563f,
+	3.1275f,
+	-238.281f,
+	230.469f,
+	4.54736f,
+	-238.281f,
+	234.375f,
+	5.9361f,
+	-238.281f,
+	238.281f,
+	6.99977f,
+	-238.281f,
+	242.188f,
+	8.20813f,
+	-238.281f,
+	246.094f,
+	9.56614f,
+	-238.281f,
+	250.0f,
+	11.4751f,
+	-238.281f,
+	3.90625f,
+	6.40337f,
+	-242.188f,
+	7.8125f,
+	7.88741f,
+	-242.188f,
+	11.7188f,
+	8.60661f,
+	-242.188f,
+	15.625f,
+	8.56923f,
+	-242.188f,
+	19.5313f,
+	8.60588f,
+	-242.188f,
+	23.4375f,
+	8.63232f,
+	-242.188f,
+	27.3438f,
+	8.3446f,
+	-242.188f,
+	31.25f,
+	7.50857f,
+	-242.188f,
+	35.1563f,
+	7.64026f,
+	-242.188f,
+	39.0625f,
+	7.75851f,
+	-242.188f,
+	42.9688f,
+	7.56672f,
+	-242.188f,
+	46.875f,
+	7.98994f,
+	-242.188f,
+	50.7813f,
+	9.62391f,
+	-242.188f,
+	54.6875f,
+	9.28711f,
+	-242.188f,
+	58.5938f,
+	10.3792f,
+	-242.188f,
+	62.5f,
+	11.2793f,
+	-242.188f,
+	66.4063f,
+	12.3048f,
+	-242.188f,
+	70.3125f,
+	13.5272f,
+	-242.188f,
+	74.2188f,
+	14.5101f,
+	-242.188f,
+	78.125f,
+	15.2091f,
+	-242.188f,
+	82.0313f,
+	15.9007f,
+	-242.188f,
+	85.9375f,
+	15.4601f,
+	-242.188f,
+	89.8438f,
+	14.5171f,
+	-242.188f,
+	93.75f,
+	14.2266f,
+	-242.188f,
+	97.6563f,
+	13.9558f,
+	-242.188f,
+	101.563f,
+	15.8234f,
+	-242.188f,
+	105.469f,
+	18.6741f,
+	-242.188f,
+	109.375f,
+	20.7296f,
+	-242.188f,
+	113.281f,
+	21.5353f,
+	-242.188f,
+	117.188f,
+	20.9821f,
+	-242.188f,
+	121.094f,
+	20.2232f,
+	-242.188f,
+	125.0f,
+	18.5423f,
+	-242.188f,
+	128.906f,
+	17.8591f,
+	-242.188f,
+	132.813f,
+	17.6716f,
+	-242.188f,
+	136.719f,
+	16.8982f,
+	-242.188f,
+	140.625f,
+	14.8574f,
+	-242.188f,
+	144.531f,
+	13.0736f,
+	-242.188f,
+	148.438f,
+	12.4847f,
+	-242.188f,
+	152.344f,
+	11.8101f,
+	-242.188f,
+	156.25f,
+	11.7863f,
+	-242.188f,
+	160.156f,
+	11.4288f,
+	-242.188f,
+	164.063f,
+	10.8653f,
+	-242.188f,
+	167.969f,
+	9.75951f,
+	-242.188f,
+	171.875f,
+	8.13212f,
+	-242.188f,
+	175.781f,
+	6.91851f,
+	-242.188f,
+	179.688f,
+	5.93418f,
+	-242.188f,
+	183.594f,
+	5.79732f,
+	-242.188f,
+	187.5f,
+	5.8082f,
+	-242.188f,
+	191.406f,
+	4.85116f,
+	-242.188f,
+	195.313f,
+	4.2744f,
+	-242.188f,
+	199.219f,
+	4.23009f,
+	-242.188f,
+	203.125f,
+	3.99841f,
+	-242.188f,
+	207.031f,
+	3.48205f,
+	-242.188f,
+	210.938f,
+	3.71102f,
+	-242.188f,
+	214.844f,
+	3.52803f,
+	-242.188f,
+	218.75f,
+	3.41263f,
+	-242.188f,
+	222.656f,
+	2.40768f,
+	-242.188f,
+	226.563f,
+	3.40111f,
+	-242.188f,
+	230.469f,
+	4.51594f,
+	-242.188f,
+	234.375f,
+	5.96131f,
+	-242.188f,
+	238.281f,
+	7.68646f,
+	-242.188f,
+	242.188f,
+	8.54536f,
+	-242.188f,
+	246.094f,
+	9.49379f,
+	-242.188f,
+	250.0f,
+	12.0532f,
+	-242.188f,
+	3.90625f,
+	6.09425f,
+	-246.094f,
+	7.8125f,
+	7.62532f,
+	-246.094f,
+	11.7188f,
+	8.33141f,
+	-246.094f,
+	15.625f,
+	8.6172f,
+	-246.094f,
+	19.5313f,
+	8.7607f,
+	-246.094f,
+	23.4375f,
+	7.89699f,
+	-246.094f,
+	27.3438f,
+	7.77868f,
+	-246.094f,
+	31.25f,
+	7.41037f,
+	-246.094f,
+	35.1563f,
+	6.57203f,
+	-246.094f,
+	39.0625f,
+	6.31554f,
+	-246.094f,
+	42.9688f,
+	7.72481f,
+	-246.094f,
+	46.875f,
+	8.88325f,
+	-246.094f,
+	50.7813f,
+	10.0433f,
+	-246.094f,
+	54.6875f,
+	10.7945f,
+	-246.094f,
+	58.5938f,
+	11.7506f,
+	-246.094f,
+	62.5f,
+	13.1397f,
+	-246.094f,
+	66.4063f,
+	13.1294f,
+	-246.094f,
+	70.3125f,
+	14.8885f,
+	-246.094f,
+	74.2188f,
+	15.5444f,
+	-246.094f,
+	78.125f,
+	16.4867f,
+	-246.094f,
+	82.0313f,
+	17.0601f,
+	-246.094f,
+	85.9375f,
+	17.2351f,
+	-246.094f,
+	89.8438f,
+	16.4292f,
+	-246.094f,
+	93.75f,
+	16.32f,
+	-246.094f,
+	97.6563f,
+	17.0323f,
+	-246.094f,
+	101.563f,
+	17.5524f,
+	-246.094f,
+	105.469f,
+	20.0544f,
+	-246.094f,
+	109.375f,
+	21.7596f,
+	-246.094f,
+	113.281f,
+	22.3401f,
+	-246.094f,
+	117.188f,
+	22.7891f,
+	-246.094f,
+	121.094f,
+	21.705f,
+	-246.094f,
+	125.0f,
+	20.4875f,
+	-246.094f,
+	128.906f,
+	19.3013f,
+	-246.094f,
+	132.813f,
+	18.5254f,
+	-246.094f,
+	136.719f,
+	17.4179f,
+	-246.094f,
+	140.625f,
+	14.7663f,
+	-246.094f,
+	144.531f,
+	13.8915f,
+	-246.094f,
+	148.438f,
+	12.0594f,
+	-246.094f,
+	152.344f,
+	11.8343f,
+	-246.094f,
+	156.25f,
+	12.3176f,
+	-246.094f,
+	160.156f,
+	12.7287f,
+	-246.094f,
+	164.063f,
+	10.9779f,
+	-246.094f,
+	167.969f,
+	10.1928f,
+	-246.094f,
+	171.875f,
+	8.20833f,
+	-246.094f,
+	175.781f,
+	7.71383f,
+	-246.094f,
+	179.688f,
+	7.59678f,
+	-246.094f,
+	183.594f,
+	6.98083f,
+	-246.094f,
+	187.5f,
+	6.81055f,
+	-246.094f,
+	191.406f,
+	6.13881f,
+	-246.094f,
+	195.313f,
+	4.42472f,
+	-246.094f,
+	199.219f,
+	3.97044f,
+	-246.094f,
+	203.125f,
+	4.06157f,
+	-246.094f,
+	207.031f,
+	3.73524f,
+	-246.094f,
+	210.938f,
+	4.45121f,
+	-246.094f,
+	214.844f,
+	3.42347f,
+	-246.094f,
+	218.75f,
+	2.70444f,
+	-246.094f,
+	222.656f,
+	3.88027f,
+	-246.094f,
+	226.563f,
+	4.53456f,
+	-246.094f,
+	230.469f,
+	5.69259f,
+	-246.094f,
+	234.375f,
+	6.23366f,
+	-246.094f,
+	238.281f,
+	7.38965f,
+	-246.094f,
+	242.188f,
+	8.96481f,
+	-246.094f,
+	246.094f,
+	10.9805f,
+	-246.094f,
+	250.0f,
+	13.0168f,
+	-246.094f,
+	3.90625f,
+	6.31953f,
+	-250.0f,
+	7.8125f,
+	6.89279f,
+	-250.0f,
+	11.7188f,
+	8.63362f,
+	-250.0f,
+	15.625f,
+	9.28278f,
+	-250.0f,
+	19.5313f,
+	9.05374f,
+	-250.0f,
+	23.4375f,
+	8.51295f,
+	-250.0f,
+	27.3438f,
+	8.2676f,
+	-250.0f,
+	31.25f,
+	7.86717f,
+	-250.0f,
+	35.1563f,
+	6.56073f,
+	-250.0f,
+	39.0625f,
+	6.77605f,
+	-250.0f,
+	42.9688f,
+	8.67577f,
+	-250.0f,
+	46.875f,
+	10.2384f,
+	-250.0f,
+	50.7813f,
+	11.5086f,
+	-250.0f,
+	54.6875f,
+	12.7259f,
+	-250.0f,
+	58.5938f,
+	14.4625f,
+	-250.0f,
+	62.5f,
+	15.7352f,
+	-250.0f,
+	66.4063f,
+	15.1953f,
+	-250.0f,
+	70.3125f,
+	16.1585f,
+	-250.0f,
+	74.2188f,
+	17.1058f,
+	-250.0f,
+	78.125f,
+	17.3014f,
+	-250.0f,
+	82.0313f,
+	18.6932f,
+	-250.0f,
+	85.9375f,
+	18.6138f,
+	-250.0f,
+	89.8438f,
+	18.0431f,
+	-250.0f,
+	93.75f,
+	18.293f,
+	-250.0f,
+	97.6563f,
+	18.5338f,
+	-250.0f,
+	101.563f,
+	18.8033f,
+	-250.0f,
+	105.469f,
+	22.2037f,
+	-250.0f,
+	109.375f,
+	24.04f,
+	-250.0f,
+	113.281f,
+	24.711f,
+	-250.0f,
+	117.188f,
+	24.2801f,
+	-250.0f,
+	121.094f,
+	23.1052f,
+	-250.0f,
+	125.0f,
+	21.9886f,
+	-250.0f,
+	128.906f,
+	21.2657f,
+	-250.0f,
+	132.813f,
+	19.5364f,
+	-250.0f,
+	136.719f,
+	18.5278f,
+	-250.0f,
+	140.625f,
+	15.9806f,
+	-250.0f,
+	144.531f,
+	14.8577f,
+	-250.0f,
+	148.438f,
+	13.3645f,
+	-250.0f,
+	152.344f,
+	12.8082f,
+	-250.0f,
+	156.25f,
+	13.3689f,
+	-250.0f,
+	160.156f,
+	12.7449f,
+	-250.0f,
+	164.063f,
+	11.1108f,
+	-250.0f,
+	167.969f,
+	9.59991f,
+	-250.0f,
+	171.875f,
+	8.88472f,
+	-250.0f,
+	175.781f,
+	8.39035f,
+	-250.0f,
+	179.688f,
+	7.9163f,
+	-250.0f,
+	183.594f,
+	7.4118f,
+	-250.0f,
+	187.5f,
+	6.98082f,
+	-250.0f,
+	191.406f,
+	7.20793f,
+	-250.0f,
+	195.313f,
+	6.19875f,
+	-250.0f,
+	199.219f,
+	4.05745f,
+	-250.0f,
+	203.125f,
+	4.65884f,
+	-250.0f,
+	207.031f,
+	3.75824f,
+	-250.0f,
+	210.938f,
+	4.17504f,
+	-250.0f,
+	214.844f,
+	4.37516f,
+	-250.0f,
+	218.75f,
+	4.69345f,
+	-250.0f,
+	222.656f,
+	5.87678f,
+	-250.0f,
+	226.563f,
+	6.28295f,
+	-250.0f,
+	230.469f,
+	7.2125f,
+	-250.0f,
+	234.375f,
+	7.55925f,
+	-250.0f,
+	238.281f,
+	7.93922f,
+	-250.0f,
+	242.188f,
+	9.87332f,
+	-250.0f,
+	246.094f,
+	11.5957f,
+	-250.0f,
+	250.0f,
+	13.3418f,
+	-250.0f,
+};
+
+btScalar Landscape07Nml[] = {
+	0.163295f,
+	0.951018f,
+	0.262487f,
+	0.144468f,
+	0.954269f,
+	0.261724f,
+	0.284339f,
+	0.929979f,
+	0.233003f,
+	0.211332f,
+	0.959058f,
+	0.188537f,
+	0.433374f,
+	0.893306f,
+	0.11913f,
+	0.363648f,
+	0.930033f,
+	0.052906f,
+	0.467682f,
+	0.883824f,
+	-0.0113249f,
+	0.383618f,
+	0.915858f,
+	-0.118494f,
+	0.389479f,
+	0.919494f,
+	-0.0532637f,
+	0.409514f,
+	0.907723f,
+	-0.0913076f,
+	0.332107f,
+	0.943241f,
+	-0.00112667f,
+	0.268223f,
+	0.935541f,
+	-0.229827f,
+	0.254548f,
+	0.967046f,
+	-0.0051751f,
+	0.306606f,
+	0.933957f,
+	-0.183623f,
+	0.282468f,
+	0.956486f,
+	0.073117f,
+	0.352033f,
+	0.935268f,
+	0.0366899f,
+	0.28404f,
+	0.958651f,
+	0.0175868f,
+	0.303901f,
+	0.947745f,
+	0.0970751f,
+	0.36555f,
+	0.930735f,
+	0.0102418f,
+	0.393208f,
+	0.907605f,
+	0.147107f,
+	0.468517f,
+	0.882377f,
+	0.0436299f,
+	0.45621f,
+	0.884295f,
+	0.0994741f,
+	0.387946f,
+	0.921329f,
+	0.0254982f,
+	0.35572f,
+	0.93034f,
+	0.0890492f,
+	-0.0727074f,
+	0.997226f,
+	-0.0159048f,
+	0.0416391f,
+	0.981376f,
+	0.187527f,
+	-0.216733f,
+	0.958137f,
+	0.187084f,
+	-0.0894435f,
+	0.917028f,
+	0.388664f,
+	-0.0768893f,
+	0.966885f,
+	0.243356f,
+	-0.0850782f,
+	0.918088f,
+	0.387139f,
+	-0.0500426f,
+	0.973558f,
+	0.222893f,
+	-0.133165f,
+	0.955198f,
+	0.264319f,
+	-0.123001f,
+	0.980349f,
+	0.154228f,
+	-0.136539f,
+	0.958129f,
+	0.251685f,
+	-0.132627f,
+	0.981796f,
+	0.135965f,
+	-0.174651f,
+	0.968606f,
+	0.176918f,
+	-0.259357f,
+	0.958248f,
+	0.120395f,
+	-0.298496f,
+	0.949786f,
+	0.0938444f,
+	-0.287382f,
+	0.955091f,
+	0.0721996f,
+	-0.350088f,
+	0.936687f,
+	-0.00747904f,
+	-0.148232f,
+	0.988935f,
+	-0.00587251f,
+	-0.126386f,
+	0.991686f,
+	0.0242043f,
+	-0.0549856f,
+	0.99804f,
+	0.0298927f,
+	-0.061356f,
+	0.998107f,
+	0.00430538f,
+	-0.205447f,
+	0.97828f,
+	0.0275574f,
+	-0.222811f,
+	0.974816f,
+	-0.00939735f,
+	-0.192208f,
+	0.981343f,
+	0.00477232f,
+	-0.179009f,
+	0.983825f,
+	-0.00666687f,
+	-0.0670729f,
+	0.997581f,
+	0.0182672f,
+	-0.127994f,
+	0.990724f,
+	-0.0456448f,
+	-0.132352f,
+	0.983294f,
+	-0.124961f,
+	-0.16906f,
+	0.976471f,
+	-0.133875f,
+	0.0163433f,
+	0.992538f,
+	-0.120836f,
+	0.061026f,
+	0.995929f,
+	-0.0663405f,
+	0.133906f,
+	0.98909f,
+	-0.0613958f,
+	0.0943148f,
+	0.983776f,
+	-0.152607f,
+	0.150352f,
+	0.985874f,
+	-0.0738065f,
+	0.100217f,
+	0.972528f,
+	-0.210109f,
+	0.174622f,
+	0.974275f,
+	-0.142462f,
+	0.154561f,
+	0.962801f,
+	-0.221644f,
+	0.214773f,
+	0.96191f,
+	-0.169122f,
+	0.258606f,
+	0.948184f,
+	-0.184582f,
+	0.352689f,
+	0.932616f,
+	-0.0764078f,
+	0.422646f,
+	0.906225f,
+	0.0112396f,
+	0.443105f,
+	0.890896f,
+	-0.0998108f,
+	0.401063f,
+	0.915401f,
+	-0.0344995f,
+	0.415945f,
+	0.889086f,
+	-0.19109f,
+	0.396075f,
+	0.910803f,
+	-0.116459f,
+	0.504361f,
+	0.849207f,
+	-0.15642f,
+	0.465554f,
+	0.866637f,
+	-0.179442f,
+	0.527872f,
+	0.824305f,
+	-0.204628f,
+	0.465951f,
+	0.840148f,
+	-0.277561f,
+	0.474007f,
+	0.822715f,
+	-0.31378f,
+	0.361245f,
+	0.837173f,
+	-0.410663f,
+	0.405138f,
+	0.793126f,
+	-0.454769f,
+	0.304965f,
+	0.772294f,
+	-0.557277f,
+	0.421648f,
+	0.811214f,
+	-0.405148f,
+	0.482203f,
+	0.762506f,
+	-0.431353f,
+	0.478963f,
+	0.817038f,
+	-0.321005f,
+	0.485062f,
+	0.781955f,
+	-0.391486f,
+	0.478205f,
+	0.82345f,
+	-0.305368f,
+	0.426707f,
+	0.781297f,
+	-0.455518f,
+	0.428677f,
+	0.841565f,
+	-0.32864f,
+	0.430024f,
+	0.798188f,
+	-0.421871f,
+	0.423016f,
+	0.835924f,
+	-0.349699f,
+	0.437416f,
+	0.818455f,
+	-0.372557f,
+	0.461522f,
+	0.813116f,
+	-0.354739f,
+	0.446182f,
+	0.808887f,
+	-0.382915f,
+	0.507869f,
+	0.791896f,
+	-0.339072f,
+	0.474665f,
+	0.780232f,
+	-0.407346f,
+	0.494125f,
+	0.792543f,
+	-0.357373f,
+	0.430265f,
+	0.769469f,
+	-0.472006f,
+	0.389469f,
+	0.809375f,
+	-0.439574f,
+	0.38782f,
+	0.781711f,
+	-0.488389f,
+	0.349938f,
+	0.837293f,
+	-0.4201f,
+	0.417236f,
+	0.816738f,
+	-0.398564f,
+	0.440298f,
+	0.822173f,
+	-0.360789f,
+	0.490994f,
+	0.819158f,
+	-0.296487f,
+	0.379279f,
+	0.852728f,
+	-0.359169f,
+	0.3675f,
+	0.860963f,
+	-0.351692f,
+	0.122152f,
+	0.892865f,
+	-0.433442f,
+	0.135293f,
+	0.922235f,
+	-0.362185f,
+	0.188083f,
+	0.883941f,
+	-0.428104f,
+	0.194653f,
+	0.9204f,
+	-0.339078f,
+	0.200053f,
+	0.870677f,
+	-0.449332f,
+	0.149584f,
+	0.899445f,
+	-0.410639f,
+	0.170948f,
+	0.845446f,
+	-0.505962f,
+	0.0834541f,
+	0.848059f,
+	-0.523289f,
+	0.233208f,
+	0.811352f,
+	-0.536024f,
+	0.246347f,
+	0.822898f,
+	-0.512008f,
+	0.0429626f,
+	0.875995f,
+	-0.480403f,
+	0.171623f,
+	0.870482f,
+	-0.461311f,
+	-0.202408f,
+	0.938053f,
+	-0.281226f,
+	-0.0831604f,
+	0.960463f,
+	-0.265698f,
+	-0.312635f,
+	0.912112f,
+	-0.265162f,
+	-0.344362f,
+	0.89728f,
+	-0.276231f,
+	-0.0852182f,
+	0.932714f,
+	-0.350403f,
+	-0.156991f,
+	0.922287f,
+	-0.353185f,
+	0.0213728f,
+	0.893503f,
+	-0.448548f,
+	-0.0577934f,
+	0.860578f,
+	-0.506029f,
+	-0.0250381f,
+	0.886654f,
+	-0.461755f,
+	-0.0319956f,
+	0.87749f,
+	-0.478526f,
+	-0.0302913f,
+	0.865602f,
+	-0.499816f,
+	-0.00892741f,
+	0.865625f,
+	-0.500613f,
+	0.0556557f,
+	0.906734f,
+	-0.418015f,
+	0.137632f,
+	0.905698f,
+	-0.400959f,
+	0.0276894f,
+	0.926625f,
+	-0.374965f,
+	0.074566f,
+	0.927887f,
+	-0.365329f,
+	0.0588963f,
+	0.991806f,
+	0.113367f,
+	0.300045f,
+	0.940314f,
+	0.160571f,
+	0.505162f,
+	0.858812f,
+	0.0851652f,
+	0.523651f,
+	0.851407f,
+	0.0299276f,
+	0.336751f,
+	0.940492f,
+	0.0455315f,
+	0.231254f,
+	0.960478f,
+	0.15493f,
+	0.265257f,
+	0.945144f,
+	0.190637f,
+	0.327138f,
+	0.941822f,
+	0.0771526f,
+	0.406507f,
+	0.912216f,
+	-0.0511354f,
+	0.398687f,
+	0.900126f,
+	-0.17556f,
+	0.399875f,
+	0.884983f,
+	-0.238547f,
+	0.421808f,
+	0.899838f,
+	-0.11122f,
+	-0.041369f,
+	0.987502f,
+	-0.152078f,
+	-0.327111f,
+	0.932019f,
+	-0.156008f,
+	-0.143307f,
+	0.985559f,
+	-0.0902006f,
+	-0.0270205f,
+	0.999466f,
+	0.0183744f,
+	-0.0836031f,
+	0.996473f,
+	-0.00727851f,
+	-0.153499f,
+	0.988141f,
+	-0.00380883f,
+	-0.269657f,
+	0.962702f,
+	0.0221269f,
+	-0.220011f,
+	0.975241f,
+	-0.0223422f,
+	-0.104184f,
+	0.990611f,
+	-0.0885198f,
+	-0.112376f,
+	0.99176f,
+	-0.0615135f,
+	-0.176142f,
+	0.984186f,
+	-0.0187604f,
+	-0.211815f,
+	0.974306f,
+	-0.076572f,
+	-0.0254097f,
+	0.999559f,
+	-0.0153608f,
+	-0.0364109f,
+	0.99734f,
+	-0.0631393f,
+	-0.0203648f,
+	0.999538f,
+	-0.0225481f,
+	0.0549873f,
+	0.998448f,
+	0.00884961f,
+	0.169599f,
+	0.985346f,
+	0.0181241f,
+	0.253148f,
+	0.96653f,
+	-0.0416731f,
+	0.241207f,
+	0.963047f,
+	-0.119834f,
+	0.334221f,
+	0.932038f,
+	-0.140004f,
+	0.510774f,
+	0.849501f,
+	-0.132124f,
+	0.446103f,
+	0.866333f,
+	-0.224633f,
+	0.443332f,
+	0.853241f,
+	-0.274658f,
+	0.556199f,
+	0.799442f,
+	-0.227011f,
+	0.56349f,
+	0.790862f,
+	-0.238781f,
+	0.469847f,
+	0.819465f,
+	-0.32821f,
+	0.384148f,
+	0.843359f,
+	-0.375735f,
+	0.405196f,
+	0.828658f,
+	-0.386189f,
+	0.451519f,
+	0.832227f,
+	-0.321758f,
+	0.460293f,
+	0.845627f,
+	-0.27027f,
+	0.479361f,
+	0.841341f,
+	-0.249716f,
+	0.486527f,
+	0.832565f,
+	-0.264815f,
+	0.505678f,
+	0.817374f,
+	-0.276024f,
+	0.532701f,
+	0.792427f,
+	-0.297134f,
+	0.419998f,
+	0.832504f,
+	-0.361301f,
+	0.381252f,
+	0.872209f,
+	-0.306428f,
+	0.441269f,
+	0.820876f,
+	-0.362552f,
+	0.40003f,
+	0.811169f,
+	-0.426593f,
+	0.192925f,
+	0.829083f,
+	-0.524786f,
+	0.183969f,
+	0.805942f,
+	-0.562684f,
+	0.196671f,
+	0.822252f,
+	-0.534063f,
+	0.210296f,
+	0.820946f,
+	-0.530871f,
+	0.203797f,
+	0.82129f,
+	-0.532869f,
+	-0.110131f,
+	0.879911f,
+	-0.462199f,
+	-0.313522f,
+	0.874849f,
+	-0.369247f,
+	-0.225349f,
+	0.894153f,
+	-0.386922f,
+	-0.0425073f,
+	0.90311f,
+	-0.4273f,
+	0.0811921f,
+	0.929959f,
+	-0.358587f,
+	-0.0097083f,
+	0.913772f,
+	-0.406111f,
+	-0.0203212f,
+	0.916094f,
+	-0.400448f,
+	-0.0594319f,
+	0.92652f,
+	-0.371521f,
+	-0.0269889f,
+	0.956838f,
+	-0.289365f,
+	0.0349749f,
+	0.98646f,
+	-0.160231f,
+	0.256968f,
+	0.956769f,
+	-0.13624f,
+	0.548943f,
+	0.832681f,
+	-0.0728256f,
+	0.489119f,
+	0.868806f,
+	-0.0770563f,
+	0.299363f,
+	0.954014f,
+	0.0154449f,
+	0.150669f,
+	0.988307f,
+	0.0233966f,
+	0.338483f,
+	0.938561f,
+	0.0673226f,
+	0.470525f,
+	0.880363f,
+	-0.0597344f,
+	0.482272f,
+	0.850276f,
+	-0.210818f,
+	0.467725f,
+	0.834993f,
+	-0.289861f,
+	0.394888f,
+	0.866151f,
+	-0.306343f,
+	0.253937f,
+	0.935832f,
+	-0.244407f,
+	-0.00400266f,
+	0.994244f,
+	-0.107062f,
+	-0.309146f,
+	0.937501f,
+	-0.15975f,
+	-0.226806f,
+	0.957844f,
+	-0.176334f,
+	-0.122632f,
+	0.982531f,
+	-0.139981f,
+	-0.0635605f,
+	0.992861f,
+	-0.10093f,
+	-0.151586f,
+	0.973622f,
+	-0.170534f,
+	-0.231525f,
+	0.948656f,
+	-0.215516f,
+	-0.166237f,
+	0.951792f,
+	-0.257795f,
+	-0.0869197f,
+	0.960928f,
+	-0.262798f,
+	-0.164573f,
+	0.950876f,
+	-0.262203f,
+	-0.167249f,
+	0.963013f,
+	-0.211268f,
+	-0.211402f,
+	0.954271f,
+	-0.211366f,
+	-0.0642089f,
+	0.988782f,
+	-0.134861f,
+	-0.0696806f,
+	0.987799f,
+	-0.139279f,
+	-0.124243f,
+	0.98904f,
+	-0.0797755f,
+	0.0962393f,
+	0.995288f,
+	-0.0118021f,
+	0.210783f,
+	0.972894f,
+	-0.0951158f,
+	0.297355f,
+	0.950074f,
+	-0.0945467f,
+	0.301001f,
+	0.949737f,
+	-0.0860135f,
+	0.352321f,
+	0.929179f,
+	-0.111785f,
+	0.488103f,
+	0.867307f,
+	-0.0976422f,
+	0.556803f,
+	0.828121f,
+	-0.0646904f,
+	0.522997f,
+	0.817722f,
+	-0.240427f,
+	0.526158f,
+	0.791225f,
+	-0.311642f,
+	0.539548f,
+	0.783883f,
+	-0.30727f,
+	0.519736f,
+	0.798926f,
+	-0.302643f,
+	0.456854f,
+	0.816569f,
+	-0.352845f,
+	0.429557f,
+	0.807438f,
+	-0.404381f,
+	0.403588f,
+	0.823842f,
+	-0.397997f,
+	0.363835f,
+	0.833866f,
+	-0.415079f,
+	0.411515f,
+	0.83345f,
+	-0.368804f,
+	0.472303f,
+	0.812756f,
+	-0.341113f,
+	0.520866f,
+	0.78709f,
+	-0.330436f,
+	0.571303f,
+	0.758641f,
+	-0.313172f,
+	0.364947f,
+	0.85616f,
+	-0.365791f,
+	0.334117f,
+	0.892356f,
+	-0.303424f,
+	0.531373f,
+	0.790182f,
+	-0.305376f,
+	0.490437f,
+	0.768139f,
+	-0.411624f,
+	0.28549f,
+	0.798709f,
+	-0.529679f,
+	0.166173f,
+	0.802828f,
+	-0.572585f,
+	0.142862f,
+	0.826392f,
+	-0.544671f,
+	0.199443f,
+	0.816751f,
+	-0.541424f,
+	0.128075f,
+	0.851947f,
+	-0.507724f,
+	-0.168704f,
+	0.879688f,
+	-0.444621f,
+	-0.244755f,
+	0.842741f,
+	-0.479461f,
+	-0.150804f,
+	0.809643f,
+	-0.567218f,
+	-0.142654f,
+	0.804501f,
+	-0.576565f,
+	-0.00468689f,
+	0.885234f,
+	-0.465123f,
+	-0.00403137f,
+	0.903548f,
+	-0.428468f,
+	-0.0506207f,
+	0.931001f,
+	-0.361489f,
+	-0.153442f,
+	0.941817f,
+	-0.299058f,
+	-0.162811f,
+	0.972443f,
+	-0.166875f,
+	0.109587f,
+	0.934225f,
+	-0.339431f,
+	0.212963f,
+	0.908729f,
+	-0.358967f,
+	0.490721f,
+	0.837065f,
+	-0.2419f,
+	0.423339f,
+	0.87185f,
+	-0.246298f,
+	0.265687f,
+	0.948953f,
+	-0.169996f,
+	0.19754f,
+	0.959782f,
+	-0.199488f,
+	0.295591f,
+	0.918793f,
+	-0.261622f,
+	0.531499f,
+	0.826018f,
+	-0.187622f,
+	0.59212f,
+	0.773761f,
+	-0.225139f,
+	0.430882f,
+	0.823206f,
+	-0.369692f,
+	0.346812f,
+	0.896722f,
+	-0.274977f,
+	0.157001f,
+	0.944818f,
+	-0.287523f,
+	-0.0770972f,
+	0.974843f,
+	-0.209133f,
+	-0.291803f,
+	0.93708f,
+	-0.191656f,
+	-0.196019f,
+	0.961744f,
+	-0.191378f,
+	-0.131765f,
+	0.96396f,
+	-0.231124f,
+	-0.0745388f,
+	0.982069f,
+	-0.173159f,
+	0.00914064f,
+	0.98959f,
+	-0.143621f,
+	-0.138284f,
+	0.94748f,
+	-0.288373f,
+	-0.221669f,
+	0.91917f,
+	-0.325561f,
+	-0.129149f,
+	0.970549f,
+	-0.203358f,
+	-0.130482f,
+	0.980721f,
+	-0.145466f,
+	-0.176902f,
+	0.951987f,
+	-0.249854f,
+	-0.247465f,
+	0.916992f,
+	-0.31287f,
+	-0.158128f,
+	0.953184f,
+	-0.25775f,
+	-0.0356987f,
+	0.985511f,
+	-0.165812f,
+	-0.125849f,
+	0.96636f,
+	-0.224301f,
+	0.0681695f,
+	0.96619f,
+	-0.248655f,
+	0.227225f,
+	0.953018f,
+	-0.200315f,
+	0.225952f,
+	0.967572f,
+	-0.112919f,
+	0.287704f,
+	0.957355f,
+	-0.0264129f,
+	0.36102f,
+	0.928385f,
+	-0.0881278f,
+	0.475672f,
+	0.87145f,
+	-0.119627f,
+	0.569214f,
+	0.81507f,
+	-0.107964f,
+	0.623663f,
+	0.769908f,
+	-0.13523f,
+	0.603105f,
+	0.773542f,
+	-0.19467f,
+	0.556766f,
+	0.776509f,
+	-0.295034f,
+	0.523993f,
+	0.789717f,
+	-0.319025f,
+	0.458736f,
+	0.810878f,
+	-0.36337f,
+	0.42608f,
+	0.838013f,
+	-0.340867f,
+	0.413816f,
+	0.852215f,
+	-0.320134f,
+	0.428047f,
+	0.839676f,
+	-0.334247f,
+	0.440545f,
+	0.806668f,
+	-0.393963f,
+	0.471664f,
+	0.754066f,
+	-0.457075f,
+	0.438131f,
+	0.75533f,
+	-0.487358f,
+	0.513035f,
+	0.778713f,
+	-0.361111f,
+	0.362236f,
+	0.865985f,
+	-0.344753f,
+	0.319311f,
+	0.872794f,
+	-0.36915f,
+	0.546544f,
+	0.761872f,
+	-0.347621f,
+	0.587841f,
+	0.74763f,
+	-0.309017f,
+	0.346001f,
+	0.792234f,
+	-0.502642f,
+	0.160837f,
+	0.807416f,
+	-0.567637f,
+	0.137348f,
+	0.82025f,
+	-0.555271f,
+	0.177955f,
+	0.827144f,
+	-0.533071f,
+	0.0951091f,
+	0.870125f,
+	-0.483567f,
+	-0.154432f,
+	0.835911f,
+	-0.526691f,
+	-0.124368f,
+	0.808763f,
+	-0.574834f,
+	-0.126819f,
+	0.782715f,
+	-0.609323f,
+	-0.137751f,
+	0.811099f,
+	-0.568456f,
+	-0.111652f,
+	0.799108f,
+	-0.590729f,
+	-0.083265f,
+	0.829705f,
+	-0.551957f,
+	-0.187386f,
+	0.858237f,
+	-0.477825f,
+	-0.293723f,
+	0.918982f,
+	-0.263055f,
+	-0.393626f,
+	0.913021f,
+	-0.107009f,
+	0.212209f,
+	0.950224f,
+	-0.228125f,
+	0.209499f,
+	0.936607f,
+	-0.280851f,
+	0.442676f,
+	0.872148f,
+	-0.208317f,
+	0.471617f,
+	0.857429f,
+	-0.205893f,
+	0.203873f,
+	0.890799f,
+	-0.406094f,
+	0.238352f,
+	0.874506f,
+	-0.422408f,
+	0.316589f,
+	0.834877f,
+	-0.45028f,
+	0.439788f,
+	0.802413f,
+	-0.403384f,
+	0.591147f,
+	0.75018f,
+	-0.29627f,
+	0.446858f,
+	0.837414f,
+	-0.314732f,
+	0.297014f,
+	0.892204f,
+	-0.340228f,
+	0.174626f,
+	0.914769f,
+	-0.364286f,
+	-0.105816f,
+	0.915255f,
+	-0.388731f,
+	-0.264967f,
+	0.884964f,
+	-0.382925f,
+	-0.17731f,
+	0.909999f,
+	-0.374785f,
+	-0.129483f,
+	0.910653f,
+	-0.39236f,
+	-0.183919f,
+	0.912509f,
+	-0.365379f,
+	-0.0547605f,
+	0.971103f,
+	-0.232295f,
+	-0.0329197f,
+	0.988161f,
+	-0.149845f,
+	-0.283679f,
+	0.94023f,
+	-0.188398f,
+	-0.271484f,
+	0.961222f,
+	-0.0484715f,
+	-0.126156f,
+	0.992006f,
+	-0.00297784f,
+	-0.0077445f,
+	0.99412f,
+	-0.10801f,
+	-0.122479f,
+	0.952558f,
+	-0.278626f,
+	-0.22816f,
+	0.898995f,
+	-0.373834f,
+	-0.116624f,
+	0.94701f,
+	-0.299285f,
+	-0.0338322f,
+	0.962019f,
+	-0.270876f,
+	0.0643125f,
+	0.93366f,
+	-0.352339f,
+	0.108033f,
+	0.951056f,
+	-0.28952f,
+	0.0914872f,
+	0.981979f,
+	-0.165373f,
+	0.260441f,
+	0.963994f,
+	-0.0537291f,
+	0.448443f,
+	0.892711f,
+	-0.0443492f,
+	0.523825f,
+	0.846692f,
+	-0.0933822f,
+	0.566469f,
+	0.810587f,
+	-0.148532f,
+	0.615421f,
+	0.777098f,
+	-0.131818f,
+	0.641634f,
+	0.7586f,
+	-0.11328f,
+	0.626845f,
+	0.758026f,
+	-0.180172f,
+	0.575952f,
+	0.768546f,
+	-0.278596f,
+	0.455289f,
+	0.793648f,
+	-0.403527f,
+	0.401888f,
+	0.827012f,
+	-0.393113f,
+	0.390072f,
+	0.829628f,
+	-0.399451f,
+	0.432707f,
+	0.817098f,
+	-0.380939f,
+	0.498394f,
+	0.785084f,
+	-0.367759f,
+	0.54453f,
+	0.759415f,
+	-0.356056f,
+	0.443321f,
+	0.820621f,
+	-0.360621f,
+	0.413861f,
+	0.828476f,
+	-0.377289f,
+	0.394054f,
+	0.852433f,
+	-0.343626f,
+	0.354186f,
+	0.831754f,
+	-0.427477f,
+	0.501406f,
+	0.754246f,
+	-0.423916f,
+	0.58911f,
+	0.726277f,
+	-0.354219f,
+	0.489087f,
+	0.757568f,
+	-0.432301f,
+	0.219144f,
+	0.803913f,
+	-0.552901f,
+	0.0950257f,
+	0.808184f,
+	-0.581213f,
+	0.0824554f,
+	0.830823f,
+	-0.550395f,
+	0.0933748f,
+	0.860985f,
+	-0.499987f,
+	-0.0248456f,
+	0.850125f,
+	-0.525994f,
+	-0.102917f,
+	0.824622f,
+	-0.556243f,
+	-0.137975f,
+	0.843048f,
+	-0.519839f,
+	-0.191841f,
+	0.811585f,
+	-0.551839f,
+	-0.0960986f,
+	0.833755f,
+	-0.543707f,
+	-0.122745f,
+	0.850064f,
+	-0.512177f,
+	-0.326981f,
+	0.870361f,
+	-0.368177f,
+	-0.538824f,
+	0.830097f,
+	-0.143558f,
+	-0.554748f,
+	0.831168f,
+	0.0375988f,
+	0.183636f,
+	0.945911f,
+	-0.267453f,
+	0.248003f,
+	0.941284f,
+	-0.229083f,
+	0.367193f,
+	0.90606f,
+	-0.210295f,
+	0.559963f,
+	0.826078f,
+	-0.0635307f,
+	0.486301f,
+	0.848236f,
+	-0.209779f,
+	0.313552f,
+	0.830527f,
+	-0.460336f,
+	0.26103f,
+	0.794184f,
+	-0.548758f,
+	0.384376f,
+	0.78311f,
+	-0.488869f,
+	0.479781f,
+	0.77201f,
+	-0.416905f,
+	0.481011f,
+	0.825397f,
+	-0.295547f,
+	0.281884f,
+	0.886831f,
+	-0.366158f,
+	0.202383f,
+	0.940438f,
+	-0.273162f,
+	-0.0238314f,
+	0.938511f,
+	-0.344426f,
+	-0.257973f,
+	0.859678f,
+	-0.440913f,
+	-0.194719f,
+	0.873936f,
+	-0.445332f,
+	-0.0838372f,
+	0.877697f,
+	-0.471825f,
+	-0.223876f,
+	0.839024f,
+	-0.495901f,
+	-0.216019f,
+	0.888182f,
+	-0.405548f,
+	-0.127765f,
+	0.960438f,
+	-0.247457f,
+	-0.306436f,
+	0.940762f,
+	-0.145138f,
+	-0.327317f,
+	0.939981f,
+	-0.096429f,
+	-0.0557083f,
+	0.990847f,
+	-0.122959f,
+	0.0995056f,
+	0.975129f,
+	-0.198043f,
+	0.0247654f,
+	0.966343f,
+	-0.256062f,
+	-0.1694f,
+	0.916546f,
+	-0.362281f,
+	-0.197841f,
+	0.908709f,
+	-0.367568f,
+	-0.0185126f,
+	0.95561f,
+	-0.294052f,
+	0.0824185f,
+	0.951583f,
+	-0.296138f,
+	0.0241627f,
+	0.96387f,
+	-0.265277f,
+	0.0355962f,
+	0.964767f,
+	-0.260688f,
+	0.155357f,
+	0.948871f,
+	-0.274788f,
+	0.403654f,
+	0.905713f,
+	-0.129414f,
+	0.540931f,
+	0.838513f,
+	-0.0654957f,
+	0.603296f,
+	0.79305f,
+	-0.0842943f,
+	0.615316f,
+	0.778563f,
+	-0.123395f,
+	0.650635f,
+	0.750663f,
+	-0.114799f,
+	0.681129f,
+	0.712532f,
+	-0.16841f,
+	0.640077f,
+	0.706799f,
+	-0.301225f,
+	0.501905f,
+	0.776085f,
+	-0.381816f,
+	0.395956f,
+	0.833034f,
+	-0.386359f,
+	0.40448f,
+	0.824611f,
+	-0.39549f,
+	0.410354f,
+	0.816219f,
+	-0.406689f,
+	0.470853f,
+	0.807605f,
+	-0.355065f,
+	0.489936f,
+	0.812779f,
+	-0.315203f,
+	0.459069f,
+	0.843316f,
+	-0.279417f,
+	0.469145f,
+	0.829489f,
+	-0.303069f,
+	0.440235f,
+	0.819159f,
+	-0.367657f,
+	0.420347f,
+	0.792019f,
+	-0.442734f,
+	0.528602f,
+	0.735131f,
+	-0.424456f,
+	0.540602f,
+	0.708419f,
+	-0.453752f,
+	0.493287f,
+	0.777492f,
+	-0.390095f,
+	0.304413f,
+	0.86604f,
+	-0.396619f,
+	0.0820709f,
+	0.870144f,
+	-0.485916f,
+	0.0884612f,
+	0.883073f,
+	-0.460823f,
+	0.0898563f,
+	0.860973f,
+	-0.500651f,
+	-0.0421635f,
+	0.844727f,
+	-0.533535f,
+	-0.161922f,
+	0.847271f,
+	-0.505878f,
+	-0.14449f,
+	0.888235f,
+	-0.436074f,
+	-0.171293f,
+	0.877903f,
+	-0.447153f,
+	-0.137238f,
+	0.90321f,
+	-0.406666f,
+	-0.254069f,
+	0.918554f,
+	-0.302831f,
+	-0.505168f,
+	0.843216f,
+	-0.183829f,
+	-0.675277f,
+	0.734237f,
+	-0.069976f,
+	-0.653992f,
+	0.755215f,
+	0.0440947f,
+	0.0555085f,
+	0.890635f,
+	-0.451319f,
+	0.137334f,
+	0.909799f,
+	-0.39167f,
+	0.308301f,
+	0.903589f,
+	-0.297451f,
+	0.471952f,
+	0.852104f,
+	-0.226231f,
+	0.566013f,
+	0.811602f,
+	-0.144679f,
+	0.544915f,
+	0.811135f,
+	-0.212433f,
+	0.36963f,
+	0.829124f,
+	-0.419437f,
+	0.344038f,
+	0.821377f,
+	-0.454948f,
+	0.421617f,
+	0.811326f,
+	-0.404955f,
+	0.42674f,
+	0.823996f,
+	-0.372724f,
+	0.214619f,
+	0.881696f,
+	-0.42018f,
+	0.0910032f,
+	0.951585f,
+	-0.293606f,
+	0.0846967f,
+	0.975495f,
+	-0.203065f,
+	-0.12731f,
+	0.949549f,
+	-0.286616f,
+	-0.203708f,
+	0.900619f,
+	-0.383912f,
+	-0.0136138f,
+	0.94578f,
+	-0.324521f,
+	-0.1774f,
+	0.907831f,
+	-0.379963f,
+	-0.319591f,
+	0.828051f,
+	-0.460644f,
+	-0.309551f,
+	0.868477f,
+	-0.387202f,
+	-0.350068f,
+	0.908991f,
+	-0.226245f,
+	-0.314996f,
+	0.908797f,
+	-0.273615f,
+	-0.0601423f,
+	0.962735f,
+	-0.263674f,
+	0.136393f,
+	0.973573f,
+	-0.183175f,
+	0.0532739f,
+	0.976623f,
+	-0.208255f,
+	-0.105007f,
+	0.973025f,
+	-0.205419f,
+	-0.20872f,
+	0.948662f,
+	-0.237649f,
+	-0.0905915f,
+	0.950284f,
+	-0.297915f,
+	0.0475864f,
+	0.961005f,
+	-0.272405f,
+	0.0362517f,
+	0.97079f,
+	-0.237174f,
+	0.105725f,
+	0.948531f,
+	-0.298516f,
+	0.162566f,
+	0.915122f,
+	-0.368949f,
+	0.273546f,
+	0.895769f,
+	-0.350385f,
+	0.484941f,
+	0.844255f,
+	-0.228179f,
+	0.616479f,
+	0.776457f,
+	-0.130645f,
+	0.628311f,
+	0.758456f,
+	-0.173119f,
+	0.646758f,
+	0.730427f,
+	-0.2195f,
+	0.713832f,
+	0.657703f,
+	-0.240564f,
+	0.670883f,
+	0.685042f,
+	-0.283959f,
+	0.484582f,
+	0.813502f,
+	-0.32155f,
+	0.374759f,
+	0.869215f,
+	-0.322522f,
+	0.442437f,
+	0.844514f,
+	-0.301738f,
+	0.417442f,
+	0.841211f,
+	-0.343666f,
+	0.423405f,
+	0.844004f,
+	-0.329219f,
+	0.51768f,
+	0.821209f,
+	-0.240049f,
+	0.452859f,
+	0.851327f,
+	-0.264878f,
+	0.509187f,
+	0.825405f,
+	-0.243796f,
+	0.514747f,
+	0.798114f,
+	-0.313129f,
+	0.470791f,
+	0.788824f,
+	-0.395111f,
+	0.531455f,
+	0.747848f,
+	-0.397843f,
+	0.533283f,
+	0.783064f,
+	-0.32003f,
+	0.426956f,
+	0.884256f,
+	-0.18921f,
+	0.350467f,
+	0.920762f,
+	-0.171379f,
+	0.166727f,
+	0.944055f,
+	-0.284537f,
+	0.0641204f,
+	0.940994f,
+	-0.332292f,
+	0.176576f,
+	0.941646f,
+	-0.286573f,
+	0.033479f,
+	0.945913f,
+	-0.322688f,
+	-0.166217f,
+	0.885456f,
+	-0.433982f,
+	-0.211415f,
+	0.849321f,
+	-0.483692f,
+	-0.245686f,
+	0.873508f,
+	-0.420264f,
+	-0.318583f,
+	0.913339f,
+	-0.253606f,
+	-0.37482f,
+	0.927017f,
+	-0.0122188f,
+	-0.519112f,
+	0.853899f,
+	0.0371293f,
+	-0.674751f,
+	0.732141f,
+	-0.0931649f,
+	-0.717847f,
+	0.685588f,
+	-0.121095f,
+	0.129526f,
+	0.933398f,
+	-0.33465f,
+	0.109756f,
+	0.909727f,
+	-0.400439f,
+	0.235187f,
+	0.88528f,
+	-0.401206f,
+	0.43527f,
+	0.839228f,
+	-0.32594f,
+	0.509145f,
+	0.799028f,
+	-0.319883f,
+	0.559944f,
+	0.774395f,
+	-0.294577f,
+	0.481154f,
+	0.808934f,
+	-0.337812f,
+	0.346903f,
+	0.826321f,
+	-0.443681f,
+	0.419785f,
+	0.810323f,
+	-0.408849f,
+	0.424579f,
+	0.803602f,
+	-0.417081f,
+	0.213763f,
+	0.882039f,
+	-0.419896f,
+	-0.065439f,
+	0.903315f,
+	-0.423958f,
+	-0.0365788f,
+	0.953894f,
+	-0.297908f,
+	-0.052968f,
+	0.984136f,
+	-0.169324f,
+	-0.178873f,
+	0.950393f,
+	-0.254476f,
+	-0.13588f,
+	0.955299f,
+	-0.262566f,
+	-0.0549577f,
+	0.986053f,
+	-0.157096f,
+	-0.250853f,
+	0.921347f,
+	-0.296972f,
+	-0.383387f,
+	0.86801f,
+	-0.31555f,
+	-0.39517f,
+	0.874494f,
+	-0.281248f,
+	-0.297344f,
+	0.903399f,
+	-0.308961f,
+	-0.146671f,
+	0.942034f,
+	-0.301762f,
+	0.0292749f,
+	0.969498f,
+	-0.243343f,
+	0.0315554f,
+	0.994938f,
+	-0.0954108f,
+	-0.135353f,
+	0.99076f,
+	0.00864549f,
+	-0.109362f,
+	0.993969f,
+	-0.00807889f,
+	0.00178341f,
+	0.978683f,
+	-0.205368f,
+	0.0583577f,
+	0.951175f,
+	-0.303086f,
+	0.0448944f,
+	0.938747f,
+	-0.341671f,
+	0.135893f,
+	0.935013f,
+	-0.327543f,
+	0.248098f,
+	0.92828f,
+	-0.277025f,
+	0.287291f,
+	0.872499f,
+	-0.395234f,
+	0.360517f,
+	0.825037f,
+	-0.435134f,
+	0.531263f,
+	0.786524f,
+	-0.314864f,
+	0.667801f,
+	0.716872f,
+	-0.200342f,
+	0.67932f,
+	0.687853f,
+	-0.2557f,
+	0.702261f,
+	0.671608f,
+	-0.236161f,
+	0.672702f,
+	0.722764f,
+	-0.15838f,
+	0.529805f,
+	0.828764f,
+	-0.180158f,
+	0.396956f,
+	0.86756f,
+	-0.29961f,
+	0.439447f,
+	0.830334f,
+	-0.342683f,
+	0.431898f,
+	0.838796f,
+	-0.33149f,
+	0.414335f,
+	0.865026f,
+	-0.282941f,
+	0.433505f,
+	0.865399f,
+	-0.251314f,
+	0.473777f,
+	0.866492f,
+	-0.157252f,
+	0.513796f,
+	0.828002f,
+	-0.224559f,
+	0.584841f,
+	0.771201f,
+	-0.251417f,
+	0.518412f,
+	0.788719f,
+	-0.330412f,
+	0.507007f,
+	0.831445f,
+	-0.227253f,
+	0.414775f,
+	0.908203f,
+	-0.0559478f,
+	0.370241f,
+	0.92627f,
+	0.07033f,
+	0.386742f,
+	0.919823f,
+	0.0659988f,
+	0.294152f,
+	0.955333f,
+	0.0285335f,
+	0.1108f,
+	0.9849f,
+	-0.133022f,
+	0.118551f,
+	0.967697f,
+	-0.222506f,
+	0.0772752f,
+	0.978981f,
+	-0.188747f,
+	-0.0200413f,
+	0.97522f,
+	-0.220327f,
+	-0.18076f,
+	0.942791f,
+	-0.280125f,
+	-0.356914f,
+	0.914544f,
+	-0.190318f,
+	-0.511643f,
+	0.854464f,
+	-0.0900754f,
+	-0.529301f,
+	0.843485f,
+	0.0915077f,
+	-0.481356f,
+	0.855106f,
+	0.192586f,
+	-0.566596f,
+	0.818312f,
+	0.0966086f,
+	-0.682392f,
+	0.727753f,
+	-0.0686784f,
+	0.232504f,
+	0.952167f,
+	-0.198291f,
+	0.256414f,
+	0.932781f,
+	-0.253323f,
+	0.252094f,
+	0.888895f,
+	-0.38251f,
+	0.391259f,
+	0.847753f,
+	-0.358095f,
+	0.537533f,
+	0.80784f,
+	-0.241771f,
+	0.561137f,
+	0.803605f,
+	-0.198354f,
+	0.542606f,
+	0.822395f,
+	-0.171013f,
+	0.447025f,
+	0.853524f,
+	-0.267703f,
+	0.421457f,
+	0.829331f,
+	-0.366857f,
+	0.381949f,
+	0.841011f,
+	-0.383165f,
+	0.196905f,
+	0.918187f,
+	-0.343745f,
+	-0.0750719f,
+	0.92165f,
+	-0.380691f,
+	-0.176435f,
+	0.915143f,
+	-0.362469f,
+	-0.162121f,
+	0.952528f,
+	-0.257698f,
+	-0.094717f,
+	0.979068f,
+	-0.180149f,
+	-0.167752f,
+	0.965606f,
+	-0.198655f,
+	-0.133367f,
+	0.985758f,
+	-0.102438f,
+	-0.176519f,
+	0.982527f,
+	-0.0590077f,
+	-0.382392f,
+	0.914243f,
+	-0.133925f,
+	-0.379354f,
+	0.898635f,
+	-0.220329f,
+	-0.2745f,
+	0.907747f,
+	-0.317246f,
+	-0.107475f,
+	0.924008f,
+	-0.366959f,
+	-0.0783766f,
+	0.915897f,
+	-0.393688f,
+	-0.161723f,
+	0.964079f,
+	-0.210708f,
+	-0.213776f,
+	0.971922f,
+	-0.0983248f,
+	0.0126393f,
+	0.993361f,
+	-0.114343f,
+	0.146279f,
+	0.956353f,
+	-0.252963f,
+	0.181548f,
+	0.939791f,
+	-0.289541f,
+	0.0719106f,
+	0.91394f,
+	-0.399427f,
+	0.0405362f,
+	0.92481f,
+	-0.378262f,
+	0.227996f,
+	0.9289f,
+	-0.291825f,
+	0.430007f,
+	0.847434f,
+	-0.311368f,
+	0.444003f,
+	0.803436f,
+	-0.396676f,
+	0.425815f,
+	0.77314f,
+	-0.470039f,
+	0.591393f,
+	0.731624f,
+	-0.339089f,
+	0.68448f,
+	0.684033f,
+	-0.252165f,
+	0.663878f,
+	0.696032f,
+	-0.273504f,
+	0.62681f,
+	0.752096f,
+	-0.203619f,
+	0.578478f,
+	0.810023f,
+	-0.0960529f,
+	0.535256f,
+	0.829774f,
+	-0.158038f,
+	0.488949f,
+	0.817442f,
+	-0.304496f,
+	0.370902f,
+	0.857519f,
+	-0.356501f,
+	0.349699f,
+	0.870975f,
+	-0.345126f,
+	0.374514f,
+	0.863134f,
+	-0.338731f,
+	0.45144f,
+	0.856074f,
+	-0.251673f,
+	0.565254f,
+	0.789722f,
+	-0.238384f,
+	0.610208f,
+	0.775791f,
+	-0.160605f,
+	0.460354f,
+	0.88479f,
+	-0.0722568f,
+	0.360414f,
+	0.930663f,
+	0.0629891f,
+	0.310809f,
+	0.940565f,
+	0.136874f,
+	0.344153f,
+	0.923997f,
+	0.166701f,
+	0.371378f,
+	0.913473f,
+	0.166271f,
+	0.349168f,
+	0.916329f,
+	0.196019f,
+	0.310264f,
+	0.946182f,
+	0.0920588f,
+	0.219218f,
+	0.972739f,
+	-0.075642f,
+	0.0579784f,
+	0.994476f,
+	-0.087501f,
+	-0.0556996f,
+	0.997544f,
+	-0.0424565f,
+	-0.239345f,
+	0.970003f,
+	0.0425244f,
+	-0.461388f,
+	0.876311f,
+	0.138566f,
+	-0.538726f,
+	0.825514f,
+	0.168229f,
+	-0.597717f,
+	0.791468f,
+	0.127721f,
+	-0.507215f,
+	0.833365f,
+	0.219627f,
+	-0.488959f,
+	0.84151f,
+	0.229738f,
+	-0.545304f,
+	0.815937f,
+	0.192066f,
+	0.227692f,
+	0.931856f,
+	-0.282489f,
+	0.297935f,
+	0.90904f,
+	-0.291343f,
+	0.353719f,
+	0.876832f,
+	-0.325652f,
+	0.346915f,
+	0.865884f,
+	-0.36041f,
+	0.409305f,
+	0.867351f,
+	-0.283145f,
+	0.519851f,
+	0.844165f,
+	-0.130922f,
+	0.531147f,
+	0.844051f,
+	-0.0738934f,
+	0.549452f,
+	0.835136f,
+	-0.0255055f,
+	0.519598f,
+	0.847001f,
+	-0.112281f,
+	0.416821f,
+	0.899711f,
+	-0.12954f,
+	0.213877f,
+	0.961324f,
+	-0.173531f,
+	-0.0327967f,
+	0.969436f,
+	-0.243141f,
+	-0.200151f,
+	0.944585f,
+	-0.26019f,
+	-0.261086f,
+	0.940261f,
+	-0.218503f,
+	-0.16617f,
+	0.980036f,
+	-0.109163f,
+	-0.211362f,
+	0.973049f,
+	-0.0922088f,
+	-0.262019f,
+	0.96267f,
+	-0.0679153f,
+	-0.172722f,
+	0.984229f,
+	0.0382049f,
+	-0.269464f,
+	0.962867f,
+	-0.0166155f,
+	-0.289017f,
+	0.944015f,
+	-0.159073f,
+	-0.146887f,
+	0.958128f,
+	-0.245795f,
+	-0.0700562f,
+	0.951312f,
+	-0.300164f,
+	-0.140619f,
+	0.963564f,
+	-0.227533f,
+	-0.278995f,
+	0.930049f,
+	-0.239105f,
+	-0.16269f,
+	0.936868f,
+	-0.309531f,
+	0.070144f,
+	0.909561f,
+	-0.409607f,
+	0.193776f,
+	0.876857f,
+	-0.43997f,
+	0.127038f,
+	0.902686f,
+	-0.411121f,
+	0.150617f,
+	0.947884f,
+	-0.280767f,
+	0.0386496f,
+	0.919015f,
+	-0.392324f,
+	0.208973f,
+	0.868713f,
+	-0.449075f,
+	0.403894f,
+	0.796876f,
+	-0.449287f,
+	0.495348f,
+	0.781817f,
+	-0.378673f,
+	0.489779f,
+	0.764879f,
+	-0.418421f,
+	0.499102f,
+	0.742417f,
+	-0.446893f,
+	0.648968f,
+	0.690613f,
+	-0.319208f,
+	0.677239f,
+	0.687846f,
+	-0.26118f,
+	0.512369f,
+	0.799495f,
+	-0.313506f,
+	0.465181f,
+	0.863456f,
+	-0.195064f,
+	0.589095f,
+	0.803266f,
+	-0.0879238f,
+	0.56026f,
+	0.801619f,
+	-0.208601f,
+	0.442292f,
+	0.866151f,
+	-0.232723f,
+	0.407485f,
+	0.876049f,
+	-0.257867f,
+	0.41887f,
+	0.854839f,
+	-0.306264f,
+	0.344336f,
+	0.834896f,
+	-0.429397f,
+	0.497957f,
+	0.824163f,
+	-0.269804f,
+	0.448098f,
+	0.886678f,
+	-0.114058f,
+	0.337837f,
+	0.929162f,
+	0.150081f,
+	0.341034f,
+	0.908641f,
+	0.240972f,
+	0.356163f,
+	0.918925f,
+	0.169481f,
+	0.332963f,
+	0.932465f,
+	0.140159f,
+	0.378366f,
+	0.915215f,
+	0.13864f,
+	0.366597f,
+	0.926522f,
+	0.0846395f,
+	0.364364f,
+	0.925578f,
+	0.102688f,
+	0.226565f,
+	0.954799f,
+	0.192424f,
+	0.0359845f,
+	0.964557f,
+	0.261408f,
+	-0.155471f,
+	0.954274f,
+	0.255321f,
+	-0.290268f,
+	0.886689f,
+	0.359898f,
+	-0.467017f,
+	0.828082f,
+	0.31012f,
+	-0.499403f,
+	0.82291f,
+	0.270953f,
+	-0.565258f,
+	0.797609f,
+	0.210482f,
+	-0.553063f,
+	0.809532f,
+	0.196925f,
+	-0.499446f,
+	0.823964f,
+	0.267652f,
+	-0.522286f,
+	0.796771f,
+	0.30393f,
+	0.282895f,
+	0.896955f,
+	-0.339766f,
+	0.328074f,
+	0.870604f,
+	-0.366628f,
+	0.343521f,
+	0.854938f,
+	-0.388683f,
+	0.333693f,
+	0.867418f,
+	-0.369101f,
+	0.350459f,
+	0.883644f,
+	-0.310405f,
+	0.440013f,
+	0.868347f,
+	-0.228826f,
+	0.488334f,
+	0.85139f,
+	-0.191483f,
+	0.49066f,
+	0.852892f,
+	-0.178404f,
+	0.509846f,
+	0.855822f,
+	-0.0873222f,
+	0.418823f,
+	0.907869f,
+	-0.0190138f,
+	0.288806f,
+	0.957176f,
+	-0.0201137f,
+	0.0497186f,
+	0.992214f,
+	-0.114191f,
+	-0.215841f,
+	0.960205f,
+	-0.177253f,
+	-0.338759f,
+	0.933444f,
+	-0.118004f,
+	-0.242696f,
+	0.969321f,
+	-0.0389388f,
+	-0.141909f,
+	0.989578f,
+	-0.0244358f,
+	-0.270493f,
+	0.952883f,
+	-0.137288f,
+	-0.235245f,
+	0.967095f,
+	-0.0968818f,
+	-0.186427f,
+	0.979041f,
+	-0.0819931f,
+	-0.181825f,
+	0.962183f,
+	-0.20284f,
+	-0.135402f,
+	0.958028f,
+	-0.252681f,
+	-0.153581f,
+	0.96935f,
+	-0.191767f,
+	-0.186528f,
+	0.978878f,
+	-0.0837011f,
+	-0.164286f,
+	0.974581f,
+	-0.152324f,
+	0.0119477f,
+	0.951315f,
+	-0.307988f,
+	0.181241f,
+	0.876938f,
+	-0.44512f,
+	0.193514f,
+	0.837326f,
+	-0.51131f,
+	-0.00806995f,
+	0.853668f,
+	-0.520756f,
+	0.0461085f,
+	0.918292f,
+	-0.393209f,
+	0.210027f,
+	0.898011f,
+	-0.386606f,
+	0.313179f,
+	0.820953f,
+	-0.477447f,
+	0.395672f,
+	0.762863f,
+	-0.511355f,
+	0.407119f,
+	0.752829f,
+	-0.517206f,
+	0.491283f,
+	0.735772f,
+	-0.466133f,
+	0.508563f,
+	0.731088f,
+	-0.454835f,
+	0.557969f,
+	0.720001f,
+	-0.412637f,
+	0.635268f,
+	0.712821f,
+	-0.297187f,
+	0.514275f,
+	0.818992f,
+	-0.254505f,
+	0.384017f,
+	0.888427f,
+	-0.251454f,
+	0.535431f,
+	0.823023f,
+	-0.189597f,
+	0.597396f,
+	0.79853f,
+	-0.0739445f,
+	0.435766f,
+	0.897283f,
+	-0.0706489f,
+	0.387025f,
+	0.91478f,
+	-0.115713f,
+	0.532369f,
+	0.842082f,
+	-0.0864959f,
+	0.42055f,
+	0.882636f,
+	-0.209979f,
+	0.370951f,
+	0.912219f,
+	-0.173928f,
+	0.309089f,
+	0.948381f,
+	-0.0709704f,
+	0.21321f,
+	0.976943f,
+	0.0111471f,
+	0.331446f,
+	0.943237f,
+	0.0211533f,
+	0.410945f,
+	0.911483f,
+	0.0179772f,
+	0.321726f,
+	0.946051f,
+	-0.0384626f,
+	0.397145f,
+	0.917286f,
+	0.0293659f,
+	0.411757f,
+	0.908804f,
+	0.0673213f,
+	0.22276f,
+	0.971882f,
+	0.0763077f,
+	0.069501f,
+	0.964908f,
+	0.253224f,
+	-0.028986f,
+	0.93542f,
+	0.352349f,
+	-0.1774f,
+	0.888082f,
+	0.424074f,
+	-0.313309f,
+	0.830284f,
+	0.460941f,
+	-0.375142f,
+	0.83463f,
+	0.403313f,
+	-0.455516f,
+	0.824707f,
+	0.335207f,
+	-0.516585f,
+	0.80896f,
+	0.280577f,
+	-0.560057f,
+	0.80406f,
+	0.199559f,
+	-0.56953f,
+	0.792393f,
+	0.218515f,
+	-0.567769f,
+	0.776958f,
+	0.271984f,
+	0.281384f,
+	0.90217f,
+	-0.326974f,
+	0.32181f,
+	0.911348f,
+	-0.256676f,
+	0.424167f,
+	0.891125f,
+	-0.16118f,
+	0.302129f,
+	0.903121f,
+	-0.305108f,
+	0.274213f,
+	0.914554f,
+	-0.297318f,
+	0.377666f,
+	0.887315f,
+	-0.264651f,
+	0.50458f,
+	0.840574f,
+	-0.197063f,
+	0.48044f,
+	0.846134f,
+	-0.230726f,
+	0.426379f,
+	0.87586f,
+	-0.225987f,
+	0.348305f,
+	0.925694f,
+	-0.147563f,
+	0.27972f,
+	0.958581f,
+	-0.053649f,
+	0.144728f,
+	0.989215f,
+	-0.0225097f,
+	-0.168728f,
+	0.979072f,
+	-0.113791f,
+	-0.360157f,
+	0.915919f,
+	-0.177143f,
+	-0.292774f,
+	0.933287f,
+	-0.207987f,
+	-0.10309f,
+	0.983541f,
+	-0.148387f,
+	-0.174215f,
+	0.960869f,
+	-0.215359f,
+	-0.250891f,
+	0.918965f,
+	-0.304233f,
+	-0.150246f,
+	0.940005f,
+	-0.306294f,
+	-0.0860686f,
+	0.946791f,
+	-0.310127f,
+	-0.15131f,
+	0.934427f,
+	-0.322415f,
+	-0.22276f,
+	0.935306f,
+	-0.27492f,
+	-0.201088f,
+	0.949203f,
+	-0.242028f,
+	-0.0437143f,
+	0.949864f,
+	-0.309592f,
+	0.109977f,
+	0.887847f,
+	-0.446802f,
+	0.297781f,
+	0.833674f,
+	-0.465096f,
+	0.214775f,
+	0.818536f,
+	-0.532795f,
+	0.0269455f,
+	0.850361f,
+	-0.52551f,
+	-0.017632f,
+	0.796129f,
+	-0.60487f,
+	0.185146f,
+	0.781388f,
+	-0.595948f,
+	0.323386f,
+	0.740218f,
+	-0.589491f,
+	0.406653f,
+	0.707179f,
+	-0.578387f,
+	0.409551f,
+	0.698057f,
+	-0.587354f,
+	0.432954f,
+	0.696782f,
+	-0.57188f,
+	0.429959f,
+	0.722053f,
+	-0.54201f,
+	0.513634f,
+	0.737641f,
+	-0.438254f,
+	0.557438f,
+	0.766448f,
+	-0.319093f,
+	0.451237f,
+	0.872287f,
+	-0.188415f,
+	0.398866f,
+	0.907449f,
+	-0.132071f,
+	0.479702f,
+	0.868398f,
+	-0.125579f,
+	0.492136f,
+	0.869715f,
+	0.0373829f,
+	0.490052f,
+	0.864036f,
+	0.115287f,
+	0.467195f,
+	0.882543f,
+	-0.0533554f,
+	0.500676f,
+	0.860686f,
+	-0.092427f,
+	0.467521f,
+	0.883982f,
+	0.000254135f,
+	0.346172f,
+	0.935182f,
+	-0.0748316f,
+	0.285844f,
+	0.955101f,
+	-0.0779434f,
+	0.233788f,
+	0.970423f,
+	-0.0601792f,
+	0.33578f,
+	0.93567f,
+	-0.108509f,
+	0.44843f,
+	0.890103f,
+	-0.0814045f,
+	0.344049f,
+	0.926181f,
+	-0.154332f,
+	0.278254f,
+	0.949058f,
+	-0.147866f,
+	0.299653f,
+	0.954043f,
+	0.00333978f,
+	0.154533f,
+	0.964067f,
+	0.21609f,
+	0.0182142f,
+	0.948347f,
+	0.316711f,
+	-0.116946f,
+	0.954294f,
+	0.275039f,
+	-0.30019f,
+	0.894483f,
+	0.33134f,
+	-0.320232f,
+	0.867471f,
+	0.380717f,
+	-0.340655f,
+	0.881399f,
+	0.327246f,
+	-0.432069f,
+	0.860755f,
+	0.269105f,
+	-0.470649f,
+	0.851696f,
+	0.23044f,
+	-0.520568f,
+	0.837827f,
+	0.164485f,
+	-0.594362f,
+	0.792684f,
+	0.135598f,
+	-0.629645f,
+	0.760492f,
+	0.15874f,
+	0.105475f,
+	0.917668f,
+	-0.383094f,
+	0.157333f,
+	0.940076f,
+	-0.302494f,
+	0.34936f,
+	0.922619f,
+	-0.163471f,
+	0.441147f,
+	0.892415f,
+	-0.0947875f,
+	0.353266f,
+	0.911437f,
+	-0.210916f,
+	0.379048f,
+	0.861228f,
+	-0.33854f,
+	0.442622f,
+	0.833751f,
+	-0.330068f,
+	0.481137f,
+	0.838111f,
+	-0.257053f,
+	0.418048f,
+	0.882249f,
+	-0.216499f,
+	0.270753f,
+	0.936711f,
+	-0.221958f,
+	0.184979f,
+	0.961951f,
+	-0.201082f,
+	0.112903f,
+	0.979904f,
+	-0.164442f,
+	-0.0774318f,
+	0.983977f,
+	-0.160602f,
+	-0.269214f,
+	0.939575f,
+	-0.211477f,
+	-0.244405f,
+	0.926884f,
+	-0.284872f,
+	-0.16522f,
+	0.91825f,
+	-0.359887f,
+	-0.0697709f,
+	0.937892f,
+	-0.339838f,
+	-0.121807f,
+	0.888033f,
+	-0.443351f,
+	-0.178259f,
+	0.862094f,
+	-0.474361f,
+	-0.173573f,
+	0.911189f,
+	-0.373641f,
+	-0.145335f,
+	0.940854f,
+	-0.30606f,
+	-0.196672f,
+	0.897435f,
+	-0.394881f,
+	-0.142648f,
+	0.86312f,
+	-0.484434f,
+	0.079713f,
+	0.828378f,
+	-0.554469f,
+	0.216417f,
+	0.76965f,
+	-0.600668f,
+	0.249468f,
+	0.776353f,
+	-0.578828f,
+	0.204058f,
+	0.841867f,
+	-0.499621f,
+	0.0644049f,
+	0.826788f,
+	-0.558814f,
+	0.116412f,
+	0.767322f,
+	-0.630607f,
+	0.208898f,
+	0.705315f,
+	-0.677416f,
+	0.323537f,
+	0.664792f,
+	-0.673332f,
+	0.378749f,
+	0.668133f,
+	-0.640428f,
+	0.350681f,
+	0.681998f,
+	-0.641795f,
+	0.388988f,
+	0.701053f,
+	-0.597673f,
+	0.366172f,
+	0.724838f,
+	-0.583548f,
+	0.331191f,
+	0.791609f,
+	-0.513486f,
+	0.441902f,
+	0.864123f,
+	-0.240861f,
+	0.365381f,
+	0.918735f,
+	-0.149742f,
+	0.346761f,
+	0.932102f,
+	-0.104611f,
+	0.441617f,
+	0.896164f,
+	-0.0431763f,
+	0.429069f,
+	0.903098f,
+	0.0177174f,
+	0.509493f,
+	0.859732f,
+	0.035759f,
+	0.550737f,
+	0.834518f,
+	-0.0163997f,
+	0.446836f,
+	0.894607f,
+	0.00385291f,
+	0.489488f,
+	0.868437f,
+	0.0788584f,
+	0.430014f,
+	0.900385f,
+	-0.0662903f,
+	0.277285f,
+	0.953602f,
+	-0.117285f,
+	0.208284f,
+	0.969937f,
+	-0.12586f,
+	0.377184f,
+	0.918436f,
+	-0.119197f,
+	0.417651f,
+	0.892053f,
+	-0.172653f,
+	0.381197f,
+	0.917074f,
+	-0.116891f,
+	0.274507f,
+	0.95009f,
+	-0.148238f,
+	0.0946799f,
+	0.989623f,
+	-0.108088f,
+	-0.059654f,
+	0.986641f,
+	0.151597f,
+	-0.0667871f,
+	0.959734f,
+	0.272857f,
+	-0.0714815f,
+	0.942101f,
+	0.327622f,
+	-0.300084f,
+	0.906469f,
+	0.297092f,
+	-0.336918f,
+	0.914203f,
+	0.225209f,
+	-0.288002f,
+	0.930996f,
+	0.224278f,
+	-0.416386f,
+	0.886687f,
+	0.201018f,
+	-0.454428f,
+	0.859405f,
+	0.234346f,
+	-0.478891f,
+	0.849426f,
+	0.221671f,
+	-0.583336f,
+	0.801078f,
+	0.13414f,
+	-0.664795f,
+	0.744846f,
+	0.0570272f,
+	0.0774054f,
+	0.9409f,
+	-0.329722f,
+	0.120466f,
+	0.940242f,
+	-0.318486f,
+	0.258377f,
+	0.92069f,
+	-0.292526f,
+	0.391172f,
+	0.892344f,
+	-0.225179f,
+	0.441921f,
+	0.861239f,
+	-0.250944f,
+	0.474164f,
+	0.819484f,
+	-0.321892f,
+	0.430001f,
+	0.828794f,
+	-0.358051f,
+	0.388327f,
+	0.849227f,
+	-0.357794f,
+	0.321794f,
+	0.900086f,
+	-0.293759f,
+	0.306798f,
+	0.936469f,
+	-0.170002f,
+	0.197413f,
+	0.950888f,
+	-0.238412f,
+	0.140677f,
+	0.959941f,
+	-0.242328f,
+	-0.0738732f,
+	0.952166f,
+	-0.296516f,
+	-0.264161f,
+	0.917561f,
+	-0.297155f,
+	-0.156821f,
+	0.939785f,
+	-0.303665f,
+	-0.074827f,
+	0.921443f,
+	-0.381239f,
+	-0.0597443f,
+	0.912887f,
+	-0.403816f,
+	-0.0722702f,
+	0.937805f,
+	-0.339556f,
+	-0.223343f,
+	0.933173f,
+	-0.281613f,
+	-0.284993f,
+	0.906137f,
+	-0.31256f,
+	-0.17102f,
+	0.941557f,
+	-0.290212f,
+	0.0188228f,
+	0.955829f,
+	-0.29332f,
+	0.0949729f,
+	0.880183f,
+	-0.465036f,
+	0.154174f,
+	0.836833f,
+	-0.525301f,
+	0.175395f,
+	0.823625f,
+	-0.539331f,
+	0.0906162f,
+	0.806123f,
+	-0.584769f,
+	0.167569f,
+	0.848038f,
+	-0.502744f,
+	0.206981f,
+	0.812951f,
+	-0.544306f,
+	0.220466f,
+	0.75453f,
+	-0.618126f,
+	0.281661f,
+	0.74367f,
+	-0.606318f,
+	0.323085f,
+	0.773947f,
+	-0.544631f,
+	0.389827f,
+	0.796004f,
+	-0.463047f,
+	0.409468f,
+	0.784217f,
+	-0.466197f,
+	0.383754f,
+	0.755374f,
+	-0.531172f,
+	0.333252f,
+	0.782449f,
+	-0.526039f,
+	0.13472f,
+	0.877229f,
+	-0.460782f,
+	0.220453f,
+	0.931705f,
+	-0.288664f,
+	0.346271f,
+	0.928921f,
+	-0.131156f,
+	0.317872f,
+	0.942854f,
+	-0.0999207f,
+	0.41364f,
+	0.908959f,
+	-0.0519229f,
+	0.398453f,
+	0.915561f,
+	-0.0546188f,
+	0.505703f,
+	0.862625f,
+	-0.0119489f,
+	0.526627f,
+	0.849939f,
+	0.0163649f,
+	0.402553f,
+	0.915142f,
+	0.0215902f,
+	0.486926f,
+	0.872826f,
+	0.0328415f,
+	0.480317f,
+	0.876602f,
+	0.0293992f,
+	0.350224f,
+	0.935385f,
+	0.0489656f,
+	0.241613f,
+	0.961192f,
+	-0.13317f,
+	0.388714f,
+	0.905381f,
+	-0.170843f,
+	0.410083f,
+	0.900693f,
+	-0.14347f,
+	0.356005f,
+	0.930194f,
+	-0.0894385f,
+	0.273996f,
+	0.955273f,
+	-0.111267f,
+	-0.044831f,
+	0.997624f,
+	-0.0523075f,
+	-0.196423f,
+	0.976135f,
+	0.0926162f,
+	-0.135564f,
+	0.988784f,
+	0.0626771f,
+	-0.172489f,
+	0.970476f,
+	0.168594f,
+	-0.254529f,
+	0.9218f,
+	0.292405f,
+	-0.284378f,
+	0.936305f,
+	0.206065f,
+	-0.327372f,
+	0.917976f,
+	0.223935f,
+	-0.435353f,
+	0.844597f,
+	0.311647f,
+	-0.503149f,
+	0.802852f,
+	0.319796f,
+	-0.41775f,
+	0.811758f,
+	0.408086f,
+	-0.454925f,
+	0.830308f,
+	0.321918f,
+	-0.572823f,
+	0.802298f,
+	0.167904f,
+	0.20617f,
+	0.937765f,
+	-0.279448f,
+	0.12824f,
+	0.920264f,
+	-0.369687f,
+	0.239724f,
+	0.89965f,
+	-0.364914f,
+	0.406692f,
+	0.839091f,
+	-0.361286f,
+	0.450018f,
+	0.81612f,
+	-0.362535f,
+	0.486709f,
+	0.828644f,
+	-0.276522f,
+	0.440087f,
+	0.85086f,
+	-0.286985f,
+	0.416932f,
+	0.85696f,
+	-0.302962f,
+	0.239451f,
+	0.901982f,
+	-0.359293f,
+	0.202502f,
+	0.927776f,
+	-0.313409f,
+	0.221835f,
+	0.941111f,
+	-0.255147f,
+	0.127859f,
+	0.963075f,
+	-0.236935f,
+	0.0102396f,
+	0.970361f,
+	-0.241441f,
+	-0.185811f,
+	0.907396f,
+	-0.376969f,
+	-0.143f,
+	0.87175f,
+	-0.468618f,
+	-0.054802f,
+	0.895065f,
+	-0.442557f,
+	-0.153942f,
+	0.908075f,
+	-0.389489f,
+	-0.214862f,
+	0.949277f,
+	-0.22958f,
+	-0.226443f,
+	0.961303f,
+	-0.156909f,
+	-0.189142f,
+	0.939849f,
+	-0.284446f,
+	-0.183498f,
+	0.904381f,
+	-0.385258f,
+	0.0372666f,
+	0.939229f,
+	-0.341264f,
+	0.17942f,
+	0.912891f,
+	-0.366659f,
+	0.186987f,
+	0.89504f,
+	-0.404894f,
+	0.249987f,
+	0.855827f,
+	-0.452843f,
+	0.209164f,
+	0.815071f,
+	-0.540287f,
+	0.137636f,
+	0.780743f,
+	-0.609506f,
+	0.248264f,
+	0.780183f,
+	-0.574177f,
+	0.268876f,
+	0.805155f,
+	-0.528613f,
+	0.166884f,
+	0.854291f,
+	-0.492277f,
+	0.223895f,
+	0.925944f,
+	-0.304136f,
+	0.382591f,
+	0.903499f,
+	-0.193167f,
+	0.505015f,
+	0.839819f,
+	-0.199159f,
+	0.522375f,
+	0.816711f,
+	-0.245169f,
+	0.295143f,
+	0.898426f,
+	-0.32515f,
+	0.045309f,
+	0.962545f,
+	-0.26731f,
+	0.0698554f,
+	0.972543f,
+	-0.221991f,
+	0.23803f,
+	0.966556f,
+	-0.0954522f,
+	0.24345f,
+	0.969904f,
+	-0.00421011f,
+	0.387893f,
+	0.915554f,
+	0.106303f,
+	0.388608f,
+	0.912695f,
+	0.126382f,
+	0.452964f,
+	0.880246f,
+	0.141388f,
+	0.553021f,
+	0.816379f,
+	0.166411f,
+	0.46714f,
+	0.881043f,
+	0.0744546f,
+	0.450683f,
+	0.892414f,
+	0.0219511f,
+	0.444978f,
+	0.886482f,
+	0.127064f,
+	0.382178f,
+	0.921652f,
+	0.0670691f,
+	0.411319f,
+	0.911388f,
+	-0.0137033f,
+	0.389838f,
+	0.919191f,
+	-0.0558004f,
+	0.35617f,
+	0.934375f,
+	0.0092699f,
+	0.326889f,
+	0.943423f,
+	0.0556465f,
+	0.261297f,
+	0.961477f,
+	0.0853544f,
+	-0.107365f,
+	0.988428f,
+	0.107158f,
+	-0.198313f,
+	0.974378f,
+	0.106114f,
+	-0.119767f,
+	0.989964f,
+	0.0750203f,
+	-0.291683f,
+	0.947022f,
+	0.134427f,
+	-0.31644f,
+	0.92799f,
+	0.196723f,
+	-0.289311f,
+	0.932636f,
+	0.215615f,
+	-0.411791f,
+	0.85345f,
+	0.319455f,
+	-0.469106f,
+	0.777331f,
+	0.419161f,
+	-0.481552f,
+	0.76826f,
+	0.421765f,
+	-0.441444f,
+	0.803246f,
+	0.399904f,
+	-0.347505f,
+	0.834501f,
+	0.427607f,
+	-0.388172f,
+	0.828163f,
+	0.404313f,
+	0.166663f,
+	0.855647f,
+	-0.489991f,
+	0.206118f,
+	0.852788f,
+	-0.479863f,
+	0.253643f,
+	0.809648f,
+	-0.529278f,
+	0.34663f,
+	0.798296f,
+	-0.492515f,
+	0.334799f,
+	0.852879f,
+	-0.400633f,
+	0.411503f,
+	0.867459f,
+	-0.279608f,
+	0.469719f,
+	0.846111f,
+	-0.251912f,
+	0.425418f,
+	0.857617f,
+	-0.288986f,
+	0.321984f,
+	0.890401f,
+	-0.321733f,
+	0.13105f,
+	0.897315f,
+	-0.421487f,
+	0.163065f,
+	0.944711f,
+	-0.284482f,
+	0.0880681f,
+	0.960841f,
+	-0.262734f,
+	0.0835185f,
+	0.96106f,
+	-0.263417f,
+	-0.0250069f,
+	0.943064f,
+	-0.33167f,
+	-0.080502f,
+	0.931121f,
+	-0.355714f,
+	-0.129429f,
+	0.916002f,
+	-0.379721f,
+	-0.246145f,
+	0.898013f,
+	-0.36467f,
+	-0.295885f,
+	0.891242f,
+	-0.343715f,
+	-0.176282f,
+	0.915144f,
+	-0.362541f,
+	-0.0418985f,
+	0.91018f,
+	-0.412089f,
+	-0.0774111f,
+	0.852502f,
+	-0.51696f,
+	-0.0321668f,
+	0.826692f,
+	-0.561735f,
+	0.194406f,
+	0.844754f,
+	-0.498595f,
+	0.282885f,
+	0.80862f,
+	-0.515859f,
+	0.302949f,
+	0.736294f,
+	-0.605056f,
+	0.233445f,
+	0.738314f,
+	-0.632768f,
+	0.172128f,
+	0.759349f,
+	-0.627504f,
+	0.112225f,
+	0.79134f,
+	-0.600988f,
+	0.137255f,
+	0.870359f,
+	-0.472902f,
+	0.0541041f,
+	0.935131f,
+	-0.350147f,
+	0.048453f,
+	0.960354f,
+	-0.274541f,
+	0.350102f,
+	0.918679f,
+	-0.182913f,
+	0.524752f,
+	0.830609f,
+	-0.186344f,
+	0.518158f,
+	0.835225f,
+	-0.184147f,
+	0.313736f,
+	0.944893f,
+	-0.0935296f,
+	0.0308812f,
+	0.997052f,
+	-0.070238f,
+	0.048477f,
+	0.985949f,
+	-0.159858f,
+	0.14972f,
+	0.972865f,
+	-0.1764f,
+	0.155626f,
+	0.983809f,
+	-0.0888849f,
+	0.284416f,
+	0.958659f,
+	0.0089454f,
+	0.3659f,
+	0.926807f,
+	0.0845335f,
+	0.421454f,
+	0.897257f,
+	0.131556f,
+	0.563402f,
+	0.804293f,
+	0.188919f,
+	0.539736f,
+	0.827553f,
+	0.154408f,
+	0.404327f,
+	0.91158f,
+	0.0744378f,
+	0.452914f,
+	0.883943f,
+	0.116249f,
+	0.458215f,
+	0.8862f,
+	0.0684684f,
+	0.412404f,
+	0.90336f,
+	0.117745f,
+	0.337667f,
+	0.93426f,
+	0.114626f,
+	0.331072f,
+	0.928113f,
+	0.170285f,
+	0.265924f,
+	0.943818f,
+	0.196193f,
+	0.193837f,
+	0.929607f,
+	0.313462f,
+	-0.0688814f,
+	0.919176f,
+	0.387776f,
+	-0.142537f,
+	0.930406f,
+	0.33768f,
+	-0.12463f,
+	0.963373f,
+	0.237444f,
+	-0.336333f,
+	0.924835f,
+	0.17765f,
+	-0.311125f,
+	0.930755f,
+	0.192081f,
+	-0.359893f,
+	0.911001f,
+	0.201382f,
+	-0.532454f,
+	0.800855f,
+	0.274086f,
+	-0.552598f,
+	0.767696f,
+	0.324466f,
+	-0.457025f,
+	0.795874f,
+	0.39713f,
+	-0.406778f,
+	0.834647f,
+	0.371344f,
+	-0.39211f,
+	0.844207f,
+	0.365466f,
+	-0.407171f,
+	0.83024f,
+	0.380675f,
+	0.088004f,
+	0.820624f,
+	-0.564651f,
+	0.180508f,
+	0.82686f,
+	-0.532654f,
+	0.264125f,
+	0.820464f,
+	-0.507027f,
+	0.247967f,
+	0.854234f,
+	-0.456943f,
+	0.24322f,
+	0.902001f,
+	-0.356704f,
+	0.342999f,
+	0.897422f,
+	-0.277462f,
+	0.495739f,
+	0.849894f,
+	-0.178668f,
+	0.449958f,
+	0.858561f,
+	-0.245787f,
+	0.384562f,
+	0.884942f,
+	-0.262659f,
+	0.158931f,
+	0.931299f,
+	-0.327755f,
+	-0.00482349f,
+	0.936712f,
+	-0.350067f,
+	0.115045f,
+	0.961792f,
+	-0.248435f,
+	0.108639f,
+	0.956333f,
+	-0.271339f,
+	-0.0605962f,
+	0.963938f,
+	-0.259135f,
+	-0.116693f,
+	0.974935f,
+	-0.189434f,
+	-0.0876965f,
+	0.975552f,
+	-0.201512f,
+	-0.158272f,
+	0.938607f,
+	-0.30654f,
+	-0.195709f,
+	0.870225f,
+	-0.452113f,
+	-0.139804f,
+	0.831767f,
+	-0.537233f,
+	-0.0224753f,
+	0.834621f,
+	-0.550366f,
+	0.0691358f,
+	0.82738f,
+	-0.557371f,
+	0.021368f,
+	0.778901f,
+	-0.626782f,
+	0.103745f,
+	0.763834f,
+	-0.637021f,
+	0.295282f,
+	0.754578f,
+	-0.586021f,
+	0.391718f,
+	0.767187f,
+	-0.507919f,
+	0.243831f,
+	0.78308f,
+	-0.57213f,
+	0.0624167f,
+	0.795727f,
+	-0.60243f,
+	0.0157622f,
+	0.882125f,
+	-0.470752f,
+	-0.0549233f,
+	0.922741f,
+	-0.381487f,
+	-0.0376875f,
+	0.97f,
+	-0.240167f,
+	0.0506221f,
+	0.974297f,
+	-0.219507f,
+	0.328414f,
+	0.911788f,
+	-0.246548f,
+	0.524714f,
+	0.832523f,
+	-0.177709f,
+	0.470173f,
+	0.873047f,
+	-0.12933f,
+	0.188699f,
+	0.978079f,
+	-0.0880599f,
+	0.0393835f,
+	0.999181f,
+	-0.00932192f,
+	0.202516f,
+	0.978334f,
+	-0.0430044f,
+	0.188361f,
+	0.964087f,
+	-0.187232f,
+	0.0636833f,
+	0.962187f,
+	-0.264841f,
+	0.180234f,
+	0.965248f,
+	-0.18924f,
+	0.346543f,
+	0.937198f,
+	-0.0395955f,
+	0.331037f,
+	0.942573f,
+	-0.0443968f,
+	0.504726f,
+	0.851052f,
+	0.144785f,
+	0.565376f,
+	0.80039f,
+	0.199312f,
+	0.492317f,
+	0.859822f,
+	0.135391f,
+	0.448961f,
+	0.892857f,
+	0.0352157f,
+	0.367625f,
+	0.92412f,
+	0.104186f,
+	0.329385f,
+	0.906428f,
+	0.264373f,
+	0.348699f,
+	0.881448f,
+	0.318526f,
+	0.290794f,
+	0.899496f,
+	0.326107f,
+	0.185082f,
+	0.919339f,
+	0.347219f,
+	0.0676347f,
+	0.907778f,
+	0.413962f,
+	-0.145808f,
+	0.884054f,
+	0.444059f,
+	-0.0815232f,
+	0.884669f,
+	0.459037f,
+	0.0810938f,
+	0.898461f,
+	0.431499f,
+	-0.248842f,
+	0.934053f,
+	0.256168f,
+	-0.367995f,
+	0.892045f,
+	0.262364f,
+	-0.356163f,
+	0.871443f,
+	0.337246f,
+	-0.546503f,
+	0.805165f,
+	0.230312f,
+	-0.590616f,
+	0.793807f,
+	0.145063f,
+	-0.541291f,
+	0.82267f,
+	0.173836f,
+	-0.431572f,
+	0.851071f,
+	0.299038f,
+	-0.381298f,
+	0.858781f,
+	0.342208f,
+	-0.443875f,
+	0.85724f,
+	0.260987f,
+	0.118157f,
+	0.850415f,
+	-0.512673f,
+	0.134653f,
+	0.857894f,
+	-0.49587f,
+	0.229214f,
+	0.896945f,
+	-0.378087f,
+	0.208074f,
+	0.910502f,
+	-0.35734f,
+	0.182505f,
+	0.899208f,
+	-0.397639f,
+	0.219865f,
+	0.895989f,
+	-0.385828f,
+	0.451196f,
+	0.865461f,
+	-0.217713f,
+	0.490084f,
+	0.844039f,
+	-0.217752f,
+	0.378309f,
+	0.899823f,
+	-0.217259f,
+	0.231483f,
+	0.942802f,
+	-0.239876f,
+	0.0439163f,
+	0.94313f,
+	-0.329511f,
+	0.0365981f,
+	0.93055f,
+	-0.364332f,
+	0.0406622f,
+	0.963235f,
+	-0.265566f,
+	-0.0474005f,
+	0.988537f,
+	-0.143342f,
+	-0.135564f,
+	0.953464f,
+	-0.269312f,
+	-0.0159099f,
+	0.95648f,
+	-0.291363f,
+	6.71815e-006f,
+	0.933398f,
+	-0.358843f,
+	-0.0477574f,
+	0.880875f,
+	-0.470933f,
+	-0.0515582f,
+	0.822668f,
+	-0.56618f,
+	0.00280332f,
+	0.78244f,
+	-0.62272f,
+	0.0365076f,
+	0.790824f,
+	-0.610954f,
+	0.0809221f,
+	0.832084f,
+	-0.548715f,
+	0.112086f,
+	0.801748f,
+	-0.587057f,
+	0.219407f,
+	0.814817f,
+	-0.536594f,
+	0.31647f,
+	0.811557f,
+	-0.491143f,
+	0.326532f,
+	0.816359f,
+	-0.476376f,
+	0.0311646f,
+	0.874097f,
+	-0.484751f,
+	-0.166146f,
+	0.898216f,
+	-0.406943f,
+	-0.145486f,
+	0.939877f,
+	-0.308975f,
+	-0.113562f,
+	0.952885f,
+	-0.281273f,
+	0.0633693f,
+	0.957888f,
+	-0.280063f,
+	0.322061f,
+	0.911056f,
+	-0.257398f,
+	0.438519f,
+	0.889327f,
+	-0.12961f,
+	0.430695f,
+	0.901938f,
+	0.0317863f,
+	0.232727f,
+	0.970972f,
+	0.0552405f,
+	0.0388751f,
+	0.995464f,
+	-0.0868351f,
+	0.197289f,
+	0.970749f,
+	-0.136837f,
+	0.308804f,
+	0.945817f,
+	-0.100347f,
+	0.177873f,
+	0.966831f,
+	-0.183299f,
+	0.0327621f,
+	0.970738f,
+	-0.237896f,
+	0.244781f,
+	0.968393f,
+	-0.0479323f,
+	0.27827f,
+	0.960269f,
+	-0.0211936f,
+	0.355239f,
+	0.931705f,
+	0.0757045f,
+	0.555707f,
+	0.816071f,
+	0.158801f,
+	0.563884f,
+	0.814994f,
+	0.133487f,
+	0.420142f,
+	0.89843f,
+	0.127685f,
+	0.31027f,
+	0.90429f,
+	0.293243f,
+	0.233723f,
+	0.926208f,
+	0.295826f,
+	0.272016f,
+	0.906457f,
+	0.323021f,
+	0.267428f,
+	0.881549f,
+	0.389042f,
+	0.161017f,
+	0.891985f,
+	0.422417f,
+	0.0459966f,
+	0.878435f,
+	0.475642f,
+	-0.0917474f,
+	0.877231f,
+	0.47122f,
+	-0.0819927f,
+	0.91503f,
+	0.394964f,
+	0.108269f,
+	0.907964f,
+	0.40482f,
+	-0.16221f,
+	0.904236f,
+	0.395026f,
+	-0.422279f,
+	0.840786f,
+	0.338761f,
+	-0.374364f,
+	0.835182f,
+	0.402893f,
+	-0.384829f,
+	0.826017f,
+	0.411828f,
+	-0.512379f,
+	0.829197f,
+	0.223383f,
+	-0.585197f,
+	0.801652f,
+	0.122056f,
+	-0.526709f,
+	0.831787f,
+	0.175237f,
+	-0.374079f,
+	0.907515f,
+	0.191003f,
+	-0.329797f,
+	0.931547f,
+	0.153144f,
+	0.105779f,
+	0.878895f,
+	-0.465138f,
+	0.0405535f,
+	0.897741f,
+	-0.438654f,
+	0.106545f,
+	0.927041f,
+	-0.359504f,
+	0.255352f,
+	0.917446f,
+	-0.305103f,
+	0.298997f,
+	0.88918f,
+	-0.346352f,
+	0.205215f,
+	0.859845f,
+	-0.467497f,
+	0.304244f,
+	0.842016f,
+	-0.445471f,
+	0.435228f,
+	0.863678f,
+	-0.254238f,
+	0.39753f,
+	0.896082f,
+	-0.197502f,
+	0.268558f,
+	0.910516f,
+	-0.314385f,
+	0.0970216f,
+	0.931439f,
+	-0.350727f,
+	0.0336528f,
+	0.944013f,
+	-0.328188f,
+	-0.0988412f,
+	0.948055f,
+	-0.302362f,
+	-0.0597673f,
+	0.966409f,
+	-0.249964f,
+	0.0558923f,
+	0.934228f,
+	-0.352269f,
+	-0.00489276f,
+	0.88655f,
+	-0.462606f,
+	0.0451038f,
+	0.899627f,
+	-0.434323f,
+	0.0627933f,
+	0.870215f,
+	-0.488654f,
+	0.0536848f,
+	0.846805f,
+	-0.529187f,
+	0.0729181f,
+	0.867797f,
+	-0.491539f,
+	-0.0450251f,
+	0.86132f,
+	-0.506063f,
+	0.0321391f,
+	0.857039f,
+	-0.514249f,
+	0.105366f,
+	0.853869f,
+	-0.509711f,
+	0.20021f,
+	0.860626f,
+	-0.468229f,
+	0.336826f,
+	0.823703f,
+	-0.456137f,
+	0.291163f,
+	0.890761f,
+	-0.348954f,
+	-0.0337704f,
+	0.937324f,
+	-0.34682f,
+	-0.238938f,
+	0.893089f,
+	-0.381184f,
+	-0.1654f,
+	0.905926f,
+	-0.389797f,
+	-0.0746684f,
+	0.904792f,
+	-0.419256f,
+	0.0731105f,
+	0.895556f,
+	-0.438901f,
+	0.199233f,
+	0.902713f,
+	-0.381334f,
+	0.277877f,
+	0.941082f,
+	-0.192742f,
+	0.300522f,
+	0.95354f,
+	-0.0211427f,
+	0.316945f,
+	0.945681f,
+	0.0723468f,
+	0.218722f,
+	0.970853f,
+	-0.0980014f,
+	0.256356f,
+	0.93882f,
+	-0.229999f,
+	0.242436f,
+	0.93442f,
+	-0.26093f,
+	0.1983f,
+	0.960329f,
+	-0.196077f,
+	0.00223103f,
+	0.977894f,
+	-0.209089f,
+	0.104164f,
+	0.98625f,
+	-0.128296f,
+	0.285507f,
+	0.957716f,
+	-0.0355725f,
+	0.283907f,
+	0.956269f,
+	-0.0703361f,
+	0.529334f,
+	0.848145f,
+	0.0213636f,
+	0.533064f,
+	0.836918f,
+	0.124145f,
+	0.319483f,
+	0.916151f,
+	0.242069f,
+	0.17728f,
+	0.930248f,
+	0.321263f,
+	0.27524f,
+	0.891192f,
+	0.360581f,
+	0.317681f,
+	0.901882f,
+	0.292724f,
+	0.194688f,
+	0.951543f,
+	0.23804f,
+	0.108971f,
+	0.911619f,
+	0.396329f,
+	-0.0300123f,
+	0.895185f,
+	0.444683f,
+	-0.0818392f,
+	0.875146f,
+	0.476887f,
+	-0.0034355f,
+	0.872809f,
+	0.48805f,
+	0.0854438f,
+	0.889906f,
+	0.448069f,
+	-0.143928f,
+	0.891079f,
+	0.430422f,
+	-0.400827f,
+	0.846578f,
+	0.350204f,
+	-0.436121f,
+	0.820693f,
+	0.369135f,
+	-0.389169f,
+	0.817738f,
+	0.42409f,
+	-0.354493f,
+	0.838309f,
+	0.414212f,
+	-0.495629f,
+	0.825913f,
+	0.268736f,
+	-0.491187f,
+	0.862049f,
+	0.124928f,
+	-0.360891f,
+	0.926358f,
+	0.107794f,
+	-0.272797f,
+	0.945677f,
+	0.17685f,
+	-0.0230447f,
+	0.8982f,
+	-0.438983f,
+	-0.0253824f,
+	0.922509f,
+	-0.38514f,
+	0.0868314f,
+	0.93389f,
+	-0.346856f,
+	0.228815f,
+	0.908408f,
+	-0.349913f,
+	0.325232f,
+	0.887343f,
+	-0.326875f,
+	0.342601f,
+	0.877959f,
+	-0.334385f,
+	0.256841f,
+	0.884237f,
+	-0.390073f,
+	0.281416f,
+	0.889548f,
+	-0.359874f,
+	0.383834f,
+	0.865745f,
+	-0.321181f,
+	0.3194f,
+	0.893039f,
+	-0.316962f,
+	0.102059f,
+	0.965529f,
+	-0.239452f,
+	-0.0466698f,
+	0.958891f,
+	-0.279912f,
+	-0.0536344f,
+	0.964707f,
+	-0.257804f,
+	-0.0261637f,
+	0.940106f,
+	-0.339875f,
+	0.144391f,
+	0.948897f,
+	-0.280616f,
+	0.0981473f,
+	0.936323f,
+	-0.337144f,
+	0.012852f,
+	0.869861f,
+	-0.493129f,
+	0.144402f,
+	0.872896f,
+	-0.466049f,
+	-0.00636809f,
+	0.871363f,
+	-0.490597f,
+	-0.0613187f,
+	0.915967f,
+	-0.396541f,
+	0.0199429f,
+	0.949099f,
+	-0.314346f,
+	0.0355652f,
+	0.92816f,
+	-0.370479f,
+	0.140076f,
+	0.947915f,
+	-0.286071f,
+	0.222188f,
+	0.910114f,
+	-0.349749f,
+	0.215543f,
+	0.917499f,
+	-0.33427f,
+	0.183013f,
+	0.971215f,
+	-0.152469f,
+	0.0390344f,
+	0.988083f,
+	-0.14889f,
+	-0.127226f,
+	0.955382f,
+	-0.266569f,
+	-0.116102f,
+	0.92344f,
+	-0.365757f,
+	-0.0309649f,
+	0.920225f,
+	-0.390164f,
+	0.00625843f,
+	0.924708f,
+	-0.380627f,
+	0.101949f,
+	0.952725f,
+	-0.286221f,
+	0.10526f,
+	0.958946f,
+	-0.263332f,
+	0.1589f,
+	0.975537f,
+	-0.151918f,
+	0.291601f,
+	0.956292f,
+	-0.0217678f,
+	0.33385f,
+	0.942155f,
+	0.0297851f,
+	0.349208f,
+	0.937042f,
+	0.00260008f,
+	0.278057f,
+	0.953965f,
+	-0.112407f,
+	0.149531f,
+	0.968881f,
+	-0.197256f,
+	-0.00612536f,
+	0.988275f,
+	-0.152563f,
+	-0.00797921f,
+	0.994274f,
+	-0.106558f,
+	0.301027f,
+	0.953574f,
+	-0.00894642f,
+	0.304582f,
+	0.944145f,
+	-0.125778f,
+	0.403446f,
+	0.913254f,
+	-0.0565483f,
+	0.37426f,
+	0.908704f,
+	0.184893f,
+	0.255667f,
+	0.895707f,
+	0.363791f,
+	0.219787f,
+	0.909558f,
+	0.352701f,
+	0.267099f,
+	0.929513f,
+	0.254289f,
+	0.378434f,
+	0.885367f,
+	0.270025f,
+	0.147409f,
+	0.95291f,
+	0.265015f,
+	-0.0634097f,
+	0.932842f,
+	0.354663f,
+	-0.0326192f,
+	0.907501f,
+	0.418782f,
+	-0.118713f,
+	0.911859f,
+	0.392963f,
+	-0.0609125f,
+	0.902157f,
+	0.427087f,
+	0.138333f,
+	0.871993f,
+	0.469567f,
+	-0.0649916f,
+	0.904886f,
+	0.420664f,
+	-0.383734f,
+	0.861279f,
+	0.333085f,
+	-0.474942f,
+	0.817835f,
+	0.324924f,
+	-0.422908f,
+	0.836367f,
+	0.348768f,
+	-0.339416f,
+	0.853379f,
+	0.395651f,
+	-0.324702f,
+	0.875389f,
+	0.358137f,
+	-0.41353f,
+	0.899847f,
+	0.138815f,
+	-0.448451f,
+	0.884614f,
+	0.12787f,
+	-0.414049f,
+	0.866279f,
+	0.279505f,
+	0.070634f,
+	0.912028f,
+	-0.404001f,
+	-0.0676482f,
+	0.885638f,
+	-0.459422f,
+	0.0565435f,
+	0.906984f,
+	-0.417353f,
+	0.246119f,
+	0.879096f,
+	-0.408185f,
+	0.292529f,
+	0.859337f,
+	-0.419485f,
+	0.280896f,
+	0.904751f,
+	-0.320192f,
+	0.320721f,
+	0.917291f,
+	-0.23604f,
+	0.350916f,
+	0.874365f,
+	-0.335178f,
+	0.376904f,
+	0.866371f,
+	-0.327636f,
+	0.17512f,
+	0.962866f,
+	-0.205478f,
+	0.0176642f,
+	0.987314f,
+	-0.157793f,
+	0.0227212f,
+	0.982851f,
+	-0.182998f,
+	0.0272561f,
+	0.971904f,
+	-0.233795f,
+	-0.0877209f,
+	0.950392f,
+	-0.298429f,
+	0.0166276f,
+	0.994097f,
+	-0.107211f,
+	0.266845f,
+	0.962366f,
+	-0.0514236f,
+	0.216132f,
+	0.934464f,
+	-0.282956f,
+	0.0993362f,
+	0.906446f,
+	-0.410472f,
+	-0.0104212f,
+	0.924877f,
+	-0.380123f,
+	-0.166185f,
+	0.907878f,
+	-0.384889f,
+	-0.0197905f,
+	0.953108f,
+	-0.301983f,
+	-0.0183125f,
+	0.962192f,
+	-0.271757f,
+	0.0845408f,
+	0.976284f,
+	-0.199307f,
+	0.269635f,
+	0.943751f,
+	-0.191394f,
+	0.189274f,
+	0.968047f,
+	-0.164501f,
+	0.102539f,
+	0.979864f,
+	-0.171327f,
+	0.106979f,
+	0.970988f,
+	-0.213865f,
+	-0.0373949f,
+	0.962501f,
+	-0.268688f,
+	-0.0919497f,
+	0.957563f,
+	-0.273163f,
+	-0.0692205f,
+	0.979823f,
+	-0.187497f,
+	-0.0661107f,
+	0.993399f,
+	-0.093741f,
+	0.0537161f,
+	0.998551f,
+	0.00311785f,
+	0.163558f,
+	0.98647f,
+	-0.0111964f,
+	0.128373f,
+	0.980868f,
+	-0.146347f,
+	0.126964f,
+	0.974881f,
+	-0.182993f,
+	0.228868f,
+	0.973261f,
+	0.0195364f,
+	0.336464f,
+	0.933228f,
+	0.126005f,
+	0.409696f,
+	0.899435f,
+	0.152205f,
+	0.227221f,
+	0.973118f,
+	0.0375761f,
+	-0.0400449f,
+	0.999001f,
+	-0.0198394f,
+	-0.0832424f,
+	0.995769f,
+	-0.0389306f,
+	0.262425f,
+	0.963268f,
+	0.0569854f,
+	0.380638f,
+	0.919787f,
+	0.0954299f,
+	0.267185f,
+	0.959941f,
+	0.0844166f,
+	0.200067f,
+	0.945675f,
+	0.256267f,
+	0.180437f,
+	0.922348f,
+	0.341639f,
+	0.274022f,
+	0.906356f,
+	0.321607f,
+	0.375587f,
+	0.88639f,
+	0.270641f,
+	0.289567f,
+	0.933145f,
+	0.213051f,
+	0.118001f,
+	0.9078f,
+	0.402461f,
+	-0.100351f,
+	0.886215f,
+	0.452275f,
+	-0.0321373f,
+	0.879207f,
+	0.475355f,
+	-0.064732f,
+	0.903306f,
+	0.424085f,
+	-0.117284f,
+	0.933968f,
+	0.337563f,
+	0.107835f,
+	0.909874f,
+	0.400625f,
+	-0.00684675f,
+	0.915037f,
+	0.403311f,
+	-0.3665f,
+	0.879987f,
+	0.302161f,
+	-0.484488f,
+	0.825175f,
+	0.290444f,
+	-0.455029f,
+	0.825809f,
+	0.33315f,
+	-0.355514f,
+	0.861697f,
+	0.362061f,
+	-0.249905f,
+	0.90704f,
+	0.338859f,
+	-0.283441f,
+	0.915216f,
+	0.286426f,
+	-0.489082f,
+	0.840765f,
+	0.232193f,
+	-0.566036f,
+	0.779585f,
+	0.26805f,
+	0.300059f,
+	0.882066f,
+	-0.363212f,
+	0.0511478f,
+	0.860745f,
+	-0.506461f,
+	0.0202137f,
+	0.82997f,
+	-0.557442f,
+	0.244641f,
+	0.828925f,
+	-0.503024f,
+	0.229733f,
+	0.86489f,
+	-0.446306f,
+	0.151553f,
+	0.888421f,
+	-0.433289f,
+	0.276054f,
+	0.875076f,
+	-0.397538f,
+	0.35746f,
+	0.874812f,
+	-0.326997f,
+	0.20869f,
+	0.962246f,
+	-0.174729f,
+	0.135202f,
+	0.98952f,
+	0.050694f,
+	0.0768682f,
+	0.997036f,
+	0.00329808f,
+	0.0854955f,
+	0.992826f,
+	-0.08359f,
+	0.0751533f,
+	0.982531f,
+	-0.170249f,
+	-0.0858423f,
+	0.966447f,
+	-0.242097f,
+	-0.101218f,
+	0.962967f,
+	-0.2499f,
+	0.245897f,
+	0.943422f,
+	-0.222463f,
+	0.411229f,
+	0.896277f,
+	-0.166064f,
+	0.160383f,
+	0.921177f,
+	-0.354556f,
+	0.0135902f,
+	0.93936f,
+	-0.342662f,
+	-0.185366f,
+	0.907574f,
+	-0.37676f,
+	-0.130182f,
+	0.940725f,
+	-0.313191f,
+	-0.0326676f,
+	0.972591f,
+	-0.230215f,
+	0.0675199f,
+	0.972602f,
+	-0.222457f,
+	0.233107f,
+	0.94649f,
+	-0.2232f,
+	0.212831f,
+	0.95378f,
+	-0.212148f,
+	0.167019f,
+	0.9356f,
+	-0.311059f,
+	0.16946f,
+	0.90555f,
+	-0.388925f,
+	-0.0763448f,
+	0.914067f,
+	-0.398312f,
+	-0.178349f,
+	0.9565f,
+	-0.230865f,
+	-0.221816f,
+	0.964561f,
+	-0.142896f,
+	-0.163528f,
+	0.986246f,
+	-0.0240246f,
+	-0.0459992f,
+	0.998297f,
+	0.0358721f,
+	0.192503f,
+	0.971257f,
+	0.140008f,
+	0.306262f,
+	0.942491f,
+	0.133843f,
+	0.166989f,
+	0.985549f,
+	-0.0284312f,
+	0.110164f,
+	0.988175f,
+	-0.106645f,
+	0.230491f,
+	0.969982f,
+	-0.0775155f,
+	0.320779f,
+	0.937031f,
+	0.138109f,
+	0.2844f,
+	0.912116f,
+	0.295231f,
+	0.0676957f,
+	0.97278f,
+	0.221621f,
+	-0.0445371f,
+	0.996486f,
+	0.0709375f,
+	0.140086f,
+	0.988598f,
+	0.0552233f,
+	0.294951f,
+	0.934183f,
+	0.200765f,
+	0.239076f,
+	0.923996f,
+	0.298453f,
+	0.115077f,
+	0.947116f,
+	0.299546f,
+	0.169084f,
+	0.942486f,
+	0.288323f,
+	0.304609f,
+	0.90997f,
+	0.281369f,
+	0.369662f,
+	0.880322f,
+	0.297294f,
+	0.206677f,
+	0.906857f,
+	0.36728f,
+	-0.0427609f,
+	0.882729f,
+	0.467933f,
+	-0.167345f,
+	0.859324f,
+	0.483279f,
+	-0.0302574f,
+	0.860894f,
+	0.507884f,
+	0.0910322f,
+	0.886636f,
+	0.453421f,
+	-0.0366606f,
+	0.947171f,
+	0.318627f,
+	0.025939f,
+	0.94095f,
+	0.337552f,
+	0.0591946f,
+	0.91956f,
+	0.388466f,
+	-0.284221f,
+	0.911546f,
+	0.297158f,
+	-0.532586f,
+	0.813173f,
+	0.234739f,
+	-0.487487f,
+	0.825499f,
+	0.284445f,
+	-0.31853f,
+	0.893358f,
+	0.316938f,
+	-0.238637f,
+	0.92505f,
+	0.295524f,
+	-0.265409f,
+	0.911937f,
+	0.312937f,
+	-0.505062f,
+	0.827653f,
+	0.244749f,
+	-0.589625f,
+	0.757122f,
+	0.281262f,
+	0.260545f,
+	0.875981f,
+	-0.405923f,
+	0.198469f,
+	0.90372f,
+	-0.379342f,
+	0.0608985f,
+	0.867502f,
+	-0.493691f,
+	0.108599f,
+	0.877043f,
+	-0.467977f,
+	0.149016f,
+	0.918586f,
+	-0.366053f,
+	0.269933f,
+	0.909568f,
+	-0.315946f,
+	0.225091f,
+	0.894351f,
+	-0.386613f,
+	0.14483f,
+	0.975181f,
+	-0.16747f,
+	0.0237141f,
+	0.999718f,
+	0.00125985f,
+	0.0312597f,
+	0.997955f,
+	0.0557504f,
+	0.105656f,
+	0.993029f,
+	0.0522575f,
+	0.205288f,
+	0.977382f,
+	0.0508146f,
+	0.175007f,
+	0.977751f,
+	-0.115656f,
+	0.0411408f,
+	0.976103f,
+	-0.213378f,
+	-0.0123853f,
+	0.935985f,
+	-0.351821f,
+	0.185506f,
+	0.902134f,
+	-0.38954f,
+	0.361594f,
+	0.882471f,
+	-0.300824f,
+	0.229178f,
+	0.926898f,
+	-0.297216f,
+	-0.016076f,
+	0.953923f,
+	-0.299621f,
+	-0.176229f,
+	0.940869f,
+	-0.289326f,
+	-0.197595f,
+	0.933757f,
+	-0.298419f,
+	-0.0925101f,
+	0.952321f,
+	-0.290735f,
+	0.0363018f,
+	0.966473f,
+	-0.254189f,
+	0.27059f,
+	0.939141f,
+	-0.211649f,
+	0.283887f,
+	0.910685f,
+	-0.300101f,
+	0.267987f,
+	0.87929f,
+	-0.39374f,
+	0.167837f,
+	0.906306f,
+	-0.387866f,
+	-0.162045f,
+	0.958045f,
+	-0.236411f,
+	-0.34242f,
+	0.923851f,
+	-0.171018f,
+	-0.280408f,
+	0.954479f,
+	-0.101693f,
+	-0.219474f,
+	0.974995f,
+	-0.0348799f,
+	-0.111179f,
+	0.993643f,
+	0.0176973f,
+	0.0791225f,
+	0.990452f,
+	0.112896f,
+	0.243665f,
+	0.947394f,
+	0.207537f,
+	0.282223f,
+	0.914505f,
+	0.289882f,
+	0.280685f,
+	0.943977f,
+	0.173563f,
+	0.165641f,
+	0.985889f,
+	-0.0242044f,
+	0.0702016f,
+	0.994363f,
+	0.0794649f,
+	0.118053f,
+	0.960325f,
+	0.252664f,
+	0.204772f,
+	0.904931f,
+	0.373051f,
+	0.0632983f,
+	0.962848f,
+	0.262521f,
+	0.122554f,
+	0.958346f,
+	0.257978f,
+	0.174517f,
+	0.943136f,
+	0.28291f,
+	0.181765f,
+	0.923678f,
+	0.337315f,
+	0.176745f,
+	0.924152f,
+	0.338681f,
+	0.201711f,
+	0.945597f,
+	0.255262f,
+	0.29766f,
+	0.929054f,
+	0.219676f,
+	0.268359f,
+	0.928086f,
+	0.258147f,
+	0.100906f,
+	0.896734f,
+	0.430912f,
+	-0.0388415f,
+	0.876619f,
+	0.479615f,
+	-0.130193f,
+	0.899332f,
+	0.417434f,
+	0.000668505f,
+	0.914851f,
+	0.403791f,
+	0.198601f,
+	0.908384f,
+	0.367961f,
+	0.0382447f,
+	0.953766f,
+	0.298106f,
+	-0.0134843f,
+	0.968824f,
+	0.247384f,
+	0.0247843f,
+	0.964757f,
+	0.261972f,
+	-0.214942f,
+	0.928034f,
+	0.304224f,
+	-0.51491f,
+	0.834181f,
+	0.197508f,
+	-0.514132f,
+	0.845f,
+	0.147116f,
+	-0.364403f,
+	0.910649f,
+	0.194754f,
+	-0.252308f,
+	0.925047f,
+	0.283953f,
+	-0.245043f,
+	0.926077f,
+	0.286941f,
+	-0.475784f,
+	0.852889f,
+	0.214964f,
+	-0.66621f,
+	0.724577f,
+	0.176499f,
+	0.0831836f,
+	0.888999f,
+	-0.45029f,
+	0.181271f,
+	0.909397f,
+	-0.374349f,
+	0.118635f,
+	0.893305f,
+	-0.433511f,
+	0.0803087f,
+	0.896743f,
+	-0.435204f,
+	0.0532614f,
+	0.909245f,
+	-0.41284f,
+	0.209897f,
+	0.941844f,
+	-0.262435f,
+	0.164344f,
+	0.979747f,
+	-0.114402f,
+	-0.0796744f,
+	0.996148f,
+	-0.0366233f,
+	-0.0133458f,
+	0.996096f,
+	0.0872637f,
+	0.0764545f,
+	0.99532f,
+	0.0590999f,
+	0.136206f,
+	0.990597f,
+	0.0128964f,
+	0.22076f,
+	0.975032f,
+	-0.0240476f,
+	0.302428f,
+	0.952936f,
+	-0.021205f,
+	0.123508f,
+	0.990766f,
+	-0.0559322f,
+	0.0598433f,
+	0.996046f,
+	-0.06566f,
+	0.217088f,
+	0.972764f,
+	-0.0812636f,
+	0.324106f,
+	0.93941f,
+	-0.111642f,
+	0.231973f,
+	0.969426f,
+	-0.0800149f,
+	-0.0239272f,
+	0.988929f,
+	-0.146448f,
+	-0.168479f,
+	0.969286f,
+	-0.179165f,
+	-0.198758f,
+	0.9628f,
+	-0.183064f,
+	-0.0847832f,
+	0.988177f,
+	-0.12774f,
+	-0.00304443f,
+	0.993662f,
+	-0.112364f,
+	0.297886f,
+	0.949812f,
+	-0.0955022f,
+	0.392699f,
+	0.900627f,
+	-0.186169f,
+	0.309254f,
+	0.921444f,
+	-0.235165f,
+	-0.0368216f,
+	0.992281f,
+	-0.118418f,
+	-0.30784f,
+	0.939111f,
+	0.152661f,
+	-0.339391f,
+	0.929078f,
+	0.147065f,
+	-0.31987f,
+	0.942094f,
+	0.100706f,
+	-0.261939f,
+	0.955297f,
+	0.137099f,
+	-0.18149f,
+	0.977639f,
+	0.106224f,
+	-0.0176854f,
+	0.987381f,
+	0.157371f,
+	0.134774f,
+	0.952305f,
+	0.273773f,
+	0.227558f,
+	0.898637f,
+	0.375058f,
+	0.367312f,
+	0.872839f,
+	0.3213f,
+	0.289472f,
+	0.940027f,
+	0.180432f,
+	0.0121921f,
+	0.995617f,
+	0.0927227f,
+	-0.0151053f,
+	0.984704f,
+	0.173582f,
+	0.12465f,
+	0.941586f,
+	0.312855f,
+	0.123765f,
+	0.936041f,
+	0.329407f,
+	0.0496474f,
+	0.956015f,
+	0.289087f,
+	0.155803f,
+	0.919433f,
+	0.361065f,
+	0.180039f,
+	0.912678f,
+	0.366885f,
+	0.192318f,
+	0.910529f,
+	0.365993f,
+	0.269572f,
+	0.892548f,
+	0.361509f,
+	0.331198f,
+	0.898525f,
+	0.288029f,
+	0.198758f,
+	0.948186f,
+	0.247866f,
+	-0.0345441f,
+	0.951973f,
+	0.304226f,
+	-0.0327497f,
+	0.929484f,
+	0.367404f,
+	-0.0643392f,
+	0.937143f,
+	0.342962f,
+	0.00774044f,
+	0.965859f,
+	0.258952f,
+	0.179174f,
+	0.948429f,
+	0.261495f,
+	0.132443f,
+	0.935778f,
+	0.32677f,
+	0.0607758f,
+	0.973146f,
+	0.222018f,
+	-0.0289622f,
+	0.977742f,
+	0.2078f,
+	-0.247283f,
+	0.928769f,
+	0.276114f,
+	-0.440694f,
+	0.866976f,
+	0.232681f,
+	-0.493254f,
+	0.853754f,
+	0.166745f,
+	-0.437376f,
+	0.881741f,
+	0.176734f,
+	-0.303558f,
+	0.920161f,
+	0.247297f,
+	-0.230002f,
+	0.942128f,
+	0.243914f,
+	-0.435382f,
+	0.879414f,
+	0.192544f,
+	-0.672886f,
+	0.738322f,
+	0.045878f,
+	0.0719528f,
+	0.93004f,
+	-0.360345f,
+	0.170321f,
+	0.920666f,
+	-0.351232f,
+	0.181011f,
+	0.922477f,
+	-0.340985f,
+	0.0828362f,
+	0.939404f,
+	-0.332654f,
+	-0.0227994f,
+	0.947238f,
+	-0.31972f,
+	-0.0485785f,
+	0.963562f,
+	-0.263036f,
+	0.0586424f,
+	0.995988f,
+	-0.0676002f,
+	-0.0660447f,
+	0.996659f,
+	-0.0480482f,
+	-0.0602898f,
+	0.992772f,
+	-0.103773f,
+	0.058767f,
+	0.996066f,
+	-0.0663303f,
+	0.189158f,
+	0.981943f,
+	0.00282556f,
+	0.237805f,
+	0.968932f,
+	-0.0679702f,
+	0.226076f,
+	0.973949f,
+	-0.0176966f,
+	0.0903031f,
+	0.990597f,
+	0.102775f,
+	0.00876316f,
+	0.995102f,
+	0.0984623f,
+	0.239141f,
+	0.958139f,
+	0.157419f,
+	0.358816f,
+	0.926379f,
+	0.11434f,
+	0.290281f,
+	0.955997f,
+	0.0425008f,
+	0.0827916f,
+	0.995067f,
+	-0.054651f,
+	-0.14974f,
+	0.985436f,
+	-0.0805802f,
+	-0.250148f,
+	0.9681f,
+	-0.0144092f,
+	-0.190918f,
+	0.980525f,
+	0.0460446f,
+	0.000678111f,
+	0.99542f,
+	0.0955933f,
+	0.316233f,
+	0.948486f,
+	0.019255f,
+	0.451155f,
+	0.892443f,
+	0.00187563f,
+	0.20864f,
+	0.975493f,
+	0.0698802f,
+	-0.187263f,
+	0.946264f,
+	0.263661f,
+	-0.412354f,
+	0.843904f,
+	0.343207f,
+	-0.267988f,
+	0.899756f,
+	0.344414f,
+	-0.237384f,
+	0.936767f,
+	0.25713f,
+	-0.24929f,
+	0.96341f,
+	0.0984657f,
+	-0.12508f,
+	0.979898f,
+	0.155419f,
+	-0.075281f,
+	0.975532f,
+	0.206567f,
+	-0.0362475f,
+	0.956877f,
+	0.288223f,
+	0.179598f,
+	0.903623f,
+	0.388856f,
+	0.452503f,
+	0.830262f,
+	0.325433f,
+	0.44384f,
+	0.859576f,
+	0.253251f,
+	0.0283124f,
+	0.992393f,
+	0.119807f,
+	-0.131018f,
+	0.979645f,
+	0.152082f,
+	-0.0108162f,
+	0.971878f,
+	0.235238f,
+	0.177243f,
+	0.920605f,
+	0.347953f,
+	0.0690998f,
+	0.954542f,
+	0.289956f,
+	0.0964158f,
+	0.939858f,
+	0.327675f,
+	0.141817f,
+	0.921257f,
+	0.362178f,
+	0.189018f,
+	0.897606f,
+	0.398216f,
+	0.266469f,
+	0.899974f,
+	0.345024f,
+	0.359545f,
+	0.871551f,
+	0.333357f,
+	0.237931f,
+	0.897592f,
+	0.371104f,
+	-0.0217966f,
+	0.934365f,
+	0.355651f,
+	-0.0978092f,
+	0.948287f,
+	0.30197f,
+	0.00875447f,
+	0.940305f,
+	0.340221f,
+	0.0870369f,
+	0.963741f,
+	0.252246f,
+	0.143744f,
+	0.964801f,
+	0.220218f,
+	0.0987042f,
+	0.960888f,
+	0.25875f,
+	0.124661f,
+	0.953903f,
+	0.273f,
+	-0.0397023f,
+	0.970451f,
+	0.238011f,
+	-0.294392f,
+	0.938787f,
+	0.17892f,
+	-0.415783f,
+	0.892445f,
+	0.175119f,
+	-0.502145f,
+	0.854833f,
+	0.130809f,
+	-0.438287f,
+	0.876552f,
+	0.198899f,
+	-0.315043f,
+	0.920499f,
+	0.231147f,
+	-0.194294f,
+	0.951114f,
+	0.240065f,
+	-0.351808f,
+	0.923717f,
+	0.151587f,
+	-0.54821f,
+	0.835857f,
+	0.0284484f,
+	0.0750917f,
+	0.989867f,
+	-0.120519f,
+	0.16891f,
+	0.981624f,
+	-0.0887941f,
+	0.190217f,
+	0.976992f,
+	-0.0964579f,
+	0.031324f,
+	0.983953f,
+	-0.175657f,
+	-0.0605958f,
+	0.993695f,
+	-0.0943344f,
+	-0.0750681f,
+	0.99685f,
+	-0.025582f,
+	-0.0331924f,
+	0.999431f,
+	-0.00606515f,
+	-0.0198899f,
+	0.99954f,
+	0.0228873f,
+	-0.0160511f,
+	0.998799f,
+	-0.0462827f,
+	0.0298246f,
+	0.995221f,
+	-0.092978f,
+	0.113995f,
+	0.985706f,
+	-0.124048f,
+	0.249662f,
+	0.968309f,
+	-0.00683024f,
+	0.100872f,
+	0.992347f,
+	0.0712218f,
+	0.0920036f,
+	0.982533f,
+	0.161755f,
+	0.0527146f,
+	0.998589f,
+	-0.00636128f,
+	0.182827f,
+	0.9816f,
+	-0.0550969f,
+	0.393766f,
+	0.919069f,
+	-0.0161334f,
+	0.337394f,
+	0.941358f,
+	0.00313128f,
+	0.105574f,
+	0.990777f,
+	0.0849468f,
+	-0.199161f,
+	0.971911f,
+	0.125398f,
+	-0.309481f,
+	0.93868f,
+	0.151989f,
+	-0.20903f,
+	0.965522f,
+	0.15516f,
+	0.0624223f,
+	0.987754f,
+	0.142987f,
+	0.384312f,
+	0.922399f,
+	0.0385395f,
+	0.395292f,
+	0.916973f,
+	0.0539f,
+	-0.00445825f,
+	0.983693f,
+	0.179798f,
+	-0.32103f,
+	0.866957f,
+	0.381215f,
+	-0.378167f,
+	0.863609f,
+	0.33342f,
+	-0.220175f,
+	0.926633f,
+	0.304752f,
+	-0.0614943f,
+	0.950074f,
+	0.305906f,
+	-0.12116f,
+	0.98024f,
+	0.156364f,
+	-0.278268f,
+	0.956461f,
+	0.0880323f,
+	-0.168756f,
+	0.960122f,
+	0.222908f,
+	-0.0650574f,
+	0.977781f,
+	0.199281f,
+	0.11325f,
+	0.979757f,
+	0.165078f,
+	0.469769f,
+	0.846474f,
+	0.250598f,
+	0.492575f,
+	0.830428f,
+	0.260305f,
+	0.123756f,
+	0.962501f,
+	0.241404f,
+	-0.13585f,
+	0.964887f,
+	0.224807f,
+	-0.0763658f,
+	0.97309f,
+	0.217403f,
+	0.0878568f,
+	0.965257f,
+	0.246088f,
+	0.105594f,
+	0.951417f,
+	0.289233f,
+	0.0757959f,
+	0.967864f,
+	0.239781f,
+	0.0993833f,
+	0.975608f,
+	0.195732f,
+	0.186309f,
+	0.954458f,
+	0.23302f,
+	0.338273f,
+	0.909543f,
+	0.241458f,
+	0.326788f,
+	0.907649f,
+	0.263405f,
+	0.193788f,
+	0.920444f,
+	0.339454f,
+	0.0304147f,
+	0.954662f,
+	0.296135f,
+	-0.0232537f,
+	0.980981f,
+	0.192706f,
+	0.000389577f,
+	0.986091f,
+	0.166207f,
+	0.0882095f,
+	0.967853f,
+	0.235542f,
+	0.188357f,
+	0.927906f,
+	0.321731f,
+	0.0670292f,
+	0.972109f,
+	0.224745f,
+	0.0943312f,
+	0.961869f,
+	0.256728f,
+	0.0613113f,
+	0.959756f,
+	0.274061f,
+	-0.207348f,
+	0.967924f,
+	0.141881f,
+	-0.415608f,
+	0.907723f,
+	0.0575284f,
+	-0.500123f,
+	0.863342f,
+	0.0672098f,
+	-0.492039f,
+	0.866172f,
+	0.0874256f,
+	-0.354073f,
+	0.931677f,
+	0.0813054f,
+	-0.181316f,
+	0.978479f,
+	0.0985071f,
+	-0.266622f,
+	0.956284f,
+	0.120138f,
+	-0.442863f,
+	0.891447f,
+	0.0958846f,
+	-0.0871303f,
+	0.98944f,
+	-0.115829f,
+	0.0906659f,
+	0.9958f,
+	-0.0127409f,
+	0.283182f,
+	0.958456f,
+	0.0342056f,
+	0.0813038f,
+	0.994836f,
+	-0.0607581f,
+	-0.14732f,
+	0.989082f,
+	0.00362058f,
+	-0.15085f,
+	0.987502f,
+	0.0456442f,
+	-0.0204288f,
+	0.99901f,
+	0.039516f,
+	0.00607957f,
+	0.996993f,
+	-0.0772516f,
+	0.0245166f,
+	0.989435f,
+	-0.142892f,
+	0.112542f,
+	0.984768f,
+	-0.132539f,
+	0.117701f,
+	0.980135f,
+	-0.159633f,
+	0.0712861f,
+	0.996099f,
+	-0.0520052f,
+	0.0255235f,
+	0.995475f,
+	0.0915291f,
+	0.102558f,
+	0.988742f,
+	0.10895f,
+	0.263691f,
+	0.960156f,
+	0.0925667f,
+	0.248163f,
+	0.965214f,
+	-0.0823197f,
+	0.340591f,
+	0.934756f,
+	-0.101139f,
+	0.19652f,
+	0.980248f,
+	0.0222232f,
+	-0.0707824f,
+	0.98306f,
+	0.169067f,
+	-0.214629f,
+	0.938414f,
+	0.270766f,
+	-0.253216f,
+	0.94197f,
+	0.220395f,
+	-0.140751f,
+	0.981088f,
+	0.132876f,
+	0.0855474f,
+	0.99626f,
+	0.0121329f,
+	0.407822f,
+	0.912623f,
+	0.0283097f,
+	0.314806f,
+	0.941456f,
+	0.120654f,
+	-0.127318f,
+	0.956166f,
+	0.263699f,
+	-0.403379f,
+	0.856412f,
+	0.322248f,
+	-0.326125f,
+	0.89105f,
+	0.315709f,
+	-0.192548f,
+	0.934549f,
+	0.29924f,
+	-0.115959f,
+	0.956033f,
+	0.26936f,
+	-0.0455884f,
+	0.940005f,
+	0.3381f,
+	-0.221624f,
+	0.931041f,
+	0.289905f,
+	-0.142796f,
+	0.963558f,
+	0.226198f,
+	0.0818112f,
+	0.991531f,
+	0.100865f,
+	0.115133f,
+	0.989689f,
+	-0.0852087f,
+	0.362891f,
+	0.931224f,
+	-0.0336289f,
+	0.464909f,
+	0.869676f,
+	0.1659f,
+	0.12135f,
+	0.938462f,
+	0.323362f,
+	-0.154102f,
+	0.92745f,
+	0.340718f,
+	-0.00840056f,
+	0.94535f,
+	0.325948f,
+	0.0978542f,
+	0.97811f,
+	0.183647f,
+	0.11792f,
+	0.982347f,
+	0.145222f,
+	0.146369f,
+	0.980631f,
+	0.130149f,
+	0.169334f,
+	0.978423f,
+	0.118383f,
+	0.164013f,
+	0.985699f,
+	0.0386944f,
+	0.265906f,
+	0.961228f,
+	0.0730397f,
+	0.245913f,
+	0.944548f,
+	0.217615f,
+	0.193695f,
+	0.94265f,
+	0.271832f,
+	0.193351f,
+	0.95598f,
+	0.22072f,
+	0.0582845f,
+	0.995708f,
+	0.0718875f,
+	-0.00685416f,
+	0.998237f,
+	0.0589609f,
+	-0.0637908f,
+	0.997757f,
+	0.0202719f,
+	0.11477f,
+	0.985697f,
+	0.123411f,
+	0.150647f,
+	0.970382f,
+	0.188848f,
+	0.0830539f,
+	0.976206f,
+	0.200309f,
+	0.0503424f,
+	0.976583f,
+	0.20917f,
+	-0.0756986f,
+	0.967299f,
+	0.242081f,
+	-0.38538f,
+	0.913963f,
+	0.127097f,
+	-0.499709f,
+	0.856093f,
+	0.131896f,
+	-0.457912f,
+	0.888414f,
+	0.0322019f,
+	-0.285439f,
+	0.956482f,
+	-0.0605596f,
+	-0.224005f,
+	0.968049f,
+	-0.112706f,
+	-0.33892f,
+	0.940492f,
+	-0.0246551f,
+	-0.468811f,
+	0.882994f,
+	0.0231736f,
+	-0.219323f,
+	0.927554f,
+	-0.302556f,
+	0.0032435f,
+	0.972826f,
+	-0.231515f,
+	0.227016f,
+	0.959392f,
+	-0.167423f,
+	0.0751831f,
+	0.995555f,
+	-0.0567285f,
+	-0.21163f,
+	0.975526f,
+	-0.0596754f,
+	-0.120787f,
+	0.989714f,
+	-0.0766664f,
+	0.103292f,
+	0.984862f,
+	-0.139202f,
+	0.130327f,
+	0.957045f,
+	-0.258998f,
+	0.100597f,
+	0.957666f,
+	-0.269734f,
+	0.0434385f,
+	0.943793f,
+	-0.327671f,
+	-0.00659457f,
+	0.974177f,
+	-0.225689f,
+	-0.0387678f,
+	0.996731f,
+	-0.0708824f,
+	0.0108947f,
+	0.998722f,
+	-0.049343f,
+	0.045379f,
+	0.994354f,
+	-0.0959194f,
+	0.256328f,
+	0.966322f,
+	0.0227405f,
+	0.338426f,
+	0.940797f,
+	0.0191927f,
+	0.245639f,
+	0.967185f,
+	0.0649251f,
+	0.104201f,
+	0.958601f,
+	0.265004f,
+	-0.106481f,
+	0.952706f,
+	0.284628f,
+	-0.229215f,
+	0.947098f,
+	0.224647f,
+	-0.194403f,
+	0.966329f,
+	0.168569f,
+	-0.00252669f,
+	0.996043f,
+	0.0888332f,
+	0.156392f,
+	0.987666f,
+	-0.00755935f,
+	0.321695f,
+	0.943636f,
+	0.0778705f,
+	0.130492f,
+	0.960095f,
+	0.247363f,
+	-0.218806f,
+	0.887212f,
+	0.406175f,
+	-0.387978f,
+	0.851763f,
+	0.352097f,
+	-0.317465f,
+	0.905687f,
+	0.280974f,
+	-0.175202f,
+	0.945708f,
+	0.273753f,
+	-0.0852507f,
+	0.952748f,
+	0.291554f,
+	-0.110501f,
+	0.951599f,
+	0.28679f,
+	-0.162568f,
+	0.933525f,
+	0.319534f,
+	-0.0379096f,
+	0.973407f,
+	0.225923f,
+	0.243134f,
+	0.964593f,
+	0.102203f,
+	0.236277f,
+	0.971524f,
+	-0.017745f,
+	0.298887f,
+	0.954255f,
+	-0.00800205f,
+	0.225509f,
+	0.966982f,
+	0.118704f,
+	-0.0160588f,
+	0.939828f,
+	0.341271f,
+	-0.127862f,
+	0.916925f,
+	0.378021f,
+	0.078893f,
+	0.93958f,
+	0.333116f,
+	0.244086f,
+	0.933689f,
+	0.262004f,
+	0.186692f,
+	0.967385f,
+	0.17121f,
+	0.108188f,
+	0.990525f,
+	0.0845894f,
+	0.174941f,
+	0.977766f,
+	0.115627f,
+	0.231991f,
+	0.970242f,
+	0.0693606f,
+	0.186114f,
+	0.981267f,
+	0.0497696f,
+	0.166608f,
+	0.977012f,
+	0.133002f,
+	0.191728f,
+	0.971565f,
+	0.138929f,
+	0.25765f,
+	0.957218f,
+	0.131718f,
+	0.087274f,
+	0.989729f,
+	0.113225f,
+	-0.00280678f,
+	0.977756f,
+	0.209725f,
+	0.0607703f,
+	0.980671f,
+	0.185986f,
+	0.0485237f,
+	0.997381f,
+	0.053629f,
+	0.0587736f,
+	0.987863f,
+	0.14378f,
+	0.0482407f,
+	0.976088f,
+	0.211956f,
+	0.0134663f,
+	0.978159f,
+	0.20742f,
+	-0.112292f,
+	0.962623f,
+	0.246469f,
+	-0.319272f,
+	0.919627f,
+	0.228803f,
+	-0.453582f,
+	0.883075f,
+	0.120176f,
+	-0.338159f,
+	0.939324f,
+	0.0576029f,
+	-0.23768f,
+	0.971299f,
+	-0.0092623f,
+	-0.191895f,
+	0.980604f,
+	-0.0399f,
+	-0.401044f,
+	0.906011f,
+	-0.135303f,
+	-0.489506f,
+	0.868205f,
+	-0.081269f,
+	-0.196977f,
+	0.901169f,
+	-0.386128f,
+	-0.0562291f,
+	0.922285f,
+	-0.382399f,
+	0.0867548f,
+	0.952728f,
+	-0.291176f,
+	0.0232316f,
+	0.988917f,
+	-0.146644f,
+	-0.11605f,
+	0.968007f,
+	-0.222475f,
+	-0.0789033f,
+	0.942785f,
+	-0.323929f,
+	0.139529f,
+	0.948189f,
+	-0.285427f,
+	0.132434f,
+	0.962288f,
+	-0.23762f,
+	0.0765905f,
+	0.96807f,
+	-0.238692f,
+	0.0641003f,
+	0.96574f,
+	-0.251472f,
+	-0.105766f,
+	0.965216f,
+	-0.239106f,
+	-0.110895f,
+	0.972771f,
+	-0.203515f,
+	0.0206339f,
+	0.984024f,
+	-0.176838f,
+	0.0647147f,
+	0.988173f,
+	-0.139018f,
+	0.148599f,
+	0.980872f,
+	-0.125734f,
+	0.271512f,
+	0.961735f,
+	0.0367049f,
+	0.0561912f,
+	0.976773f,
+	0.206777f,
+	-0.0583132f,
+	0.913697f,
+	0.402191f,
+	-0.0462589f,
+	0.893353f,
+	0.446968f,
+	-0.125152f,
+	0.910112f,
+	0.39501f,
+	-0.0803843f,
+	0.940756f,
+	0.329418f,
+	0.0619859f,
+	0.973174f,
+	0.221562f,
+	0.135828f,
+	0.971328f,
+	0.195124f,
+	0.132962f,
+	0.954202f,
+	0.267992f,
+	-0.0325488f,
+	0.903596f,
+	0.427147f,
+	-0.270164f,
+	0.841605f,
+	0.467668f,
+	-0.262238f,
+	0.850223f,
+	0.456456f,
+	-0.212116f,
+	0.889937f,
+	0.403757f,
+	-0.177521f,
+	0.909486f,
+	0.375929f,
+	-0.116828f,
+	0.901627f,
+	0.416436f,
+	-0.0747169f,
+	0.915103f,
+	0.396238f,
+	-0.119776f,
+	0.962629f,
+	0.242896f,
+	0.0380452f,
+	0.99097f,
+	0.128572f,
+	0.304108f,
+	0.937317f,
+	0.17016f,
+	0.240764f,
+	0.951762f,
+	0.190215f,
+	0.194326f,
+	0.952804f,
+	0.233243f,
+	0.142453f,
+	0.936947f,
+	0.31912f,
+	-0.0935081f,
+	0.945618f,
+	0.31155f,
+	-0.0887705f,
+	0.956167f,
+	0.27904f,
+	0.107828f,
+	0.967058f,
+	0.230592f,
+	0.241042f,
+	0.935322f,
+	0.258984f,
+	0.259409f,
+	0.922717f,
+	0.285133f,
+	0.218487f,
+	0.962504f,
+	0.160778f,
+	0.220571f,
+	0.975062f,
+	0.0245473f,
+	0.235132f,
+	0.971421f,
+	-0.0324531f,
+	0.193322f,
+	0.980828f,
+	0.0245576f,
+	0.123827f,
+	0.992302f,
+	-0.00201728f,
+	0.206505f,
+	0.97706f,
+	0.0520531f,
+	0.250594f,
+	0.965023f,
+	0.0770254f,
+	0.0246334f,
+	0.99033f,
+	0.136524f,
+	-0.123437f,
+	0.964871f,
+	0.231923f,
+	0.10276f,
+	0.956911f,
+	0.271591f,
+	0.090829f,
+	0.970486f,
+	0.223397f,
+	0.00393218f,
+	0.964068f,
+	0.265627f,
+	0.045739f,
+	0.962581f,
+	0.267105f,
+	0.0438394f,
+	0.968724f,
+	0.244235f,
+	-0.1348f,
+	0.971521f,
+	0.194876f,
+	-0.247965f,
+	0.950768f,
+	0.185883f,
+	-0.385563f,
+	0.920067f,
+	0.0694089f,
+	-0.33646f,
+	0.941527f,
+	0.0179056f,
+	-0.284408f,
+	0.957673f,
+	0.0444463f,
+	-0.0809611f,
+	0.98246f,
+	0.167982f,
+	-0.272195f,
+	0.961849f,
+	0.0275091f,
+	-0.538305f,
+	0.840251f,
+	-0.0648443f,
+	-0.138085f,
+	0.947265f,
+	-0.289173f,
+	-0.112292f,
+	0.943405f,
+	-0.312055f,
+	-0.0366032f,
+	0.968339f,
+	-0.246942f,
+	-0.0207584f,
+	0.978499f,
+	-0.205204f,
+	-0.0114432f,
+	0.978269f,
+	-0.207024f,
+	-0.017206f,
+	0.978017f,
+	-0.207814f,
+	-0.00196221f,
+	0.968739f,
+	-0.248075f,
+	0.111459f,
+	0.982805f,
+	-0.147209f,
+	0.0917515f,
+	0.980196f,
+	-0.175495f,
+	0.0783409f,
+	0.987595f,
+	-0.136083f,
+	-0.0849004f,
+	0.981698f,
+	-0.170473f,
+	-0.0826208f,
+	0.969176f,
+	-0.232103f,
+	-0.0513296f,
+	0.962825f,
+	-0.265205f,
+	-0.0169212f,
+	0.988046f,
+	-0.153227f,
+	0.0442536f,
+	0.99886f,
+	0.017891f,
+	0.0803284f,
+	0.974024f,
+	0.211719f,
+	-0.118041f,
+	0.942704f,
+	0.312052f,
+	-0.187621f,
+	0.893485f,
+	0.408023f,
+	-0.0735772f,
+	0.857937f,
+	0.508459f,
+	-0.0838693f,
+	0.837024f,
+	0.5407f,
+	-0.00356882f,
+	0.863268f,
+	0.504733f,
+	0.117551f,
+	0.889838f,
+	0.440874f,
+	0.141271f,
+	0.893306f,
+	0.426669f,
+	0.0270129f,
+	0.906148f,
+	0.422097f,
+	-0.109486f,
+	0.851548f,
+	0.512717f,
+	-0.266831f,
+	0.814637f,
+	0.514944f,
+	-0.253628f,
+	0.788787f,
+	0.559899f,
+	-0.216685f,
+	0.776961f,
+	0.591083f,
+	-0.15137f,
+	0.760068f,
+	0.631968f,
+	-0.119157f,
+	0.801398f,
+	0.586143f,
+	0.0626697f,
+	0.817134f,
+	0.573031f,
+	0.150716f,
+	0.886392f,
+	0.437714f,
+	0.0719955f,
+	0.965525f,
+	0.250157f,
+	0.170594f,
+	0.93758f,
+	0.303054f,
+	0.205981f,
+	0.906978f,
+	0.367374f,
+	0.159242f,
+	0.93166f,
+	0.326575f,
+	0.163686f,
+	0.939188f,
+	0.301881f,
+	0.00255834f,
+	0.983457f,
+	0.181126f,
+	-0.0246414f,
+	0.997684f,
+	0.063397f,
+	0.103068f,
+	0.994148f,
+	0.0323463f,
+	0.175261f,
+	0.977189f,
+	0.119941f,
+	0.238397f,
+	0.946614f,
+	0.216998f,
+	0.376211f,
+	0.893689f,
+	0.244508f,
+	0.336321f,
+	0.93903f,
+	0.0714918f,
+	0.22632f,
+	0.974025f,
+	-0.00733613f,
+	0.155366f,
+	0.98668f,
+	0.0481989f,
+	0.129371f,
+	0.988467f,
+	0.0787169f,
+	0.140766f,
+	0.985457f,
+	0.095182f,
+	0.181141f,
+	0.974304f,
+	0.133867f,
+	-0.0259321f,
+	0.983166f,
+	0.180868f,
+	-0.16382f,
+	0.974748f,
+	0.151756f,
+	0.12842f,
+	0.977623f,
+	0.166619f,
+	0.102805f,
+	0.986615f,
+	0.12658f,
+	-0.0352231f,
+	0.991461f,
+	0.125559f,
+	0.0344472f,
+	0.990276f,
+	0.134782f,
+	0.100258f,
+	0.97877f,
+	0.178768f,
+	-0.0763414f,
+	0.992566f,
+	0.0947915f,
+	-0.24142f,
+	0.968616f,
+	0.059149f,
+	-0.325267f,
+	0.943242f,
+	0.06705f,
+	-0.302069f,
+	0.9528f,
+	0.0304413f,
+	-0.317187f,
+	0.948361f,
+	-0.0017587f,
+	-0.219267f,
+	0.973832f,
+	0.059775f,
+	-0.187608f,
+	0.954493f,
+	0.231832f,
+	-0.46452f,
+	0.867868f,
+	0.176143f,
+	-0.203418f,
+	0.948131f,
+	-0.244273f,
+	-0.139664f,
+	0.973265f,
+	-0.182342f,
+	-0.0536959f,
+	0.988785f,
+	-0.139361f,
+	-0.00355604f,
+	0.986781f,
+	-0.162022f,
+	-0.0572809f,
+	0.980561f,
+	-0.187669f,
+	-0.0374007f,
+	0.985205f,
+	-0.167247f,
+	0.0555765f,
+	0.976159f,
+	-0.209822f,
+	0.0908927f,
+	0.962348f,
+	-0.256173f,
+	0.0600715f,
+	0.972748f,
+	-0.223946f,
+	0.0442581f,
+	0.987652f,
+	-0.150282f,
+	-0.0260568f,
+	0.986636f,
+	-0.160841f,
+	-0.0937884f,
+	0.986183f,
+	-0.136552f,
+	-0.00585357f,
+	0.999959f,
+	-0.00691373f,
+	-0.168872f,
+	0.982349f,
+	-0.0804476f,
+	-0.215485f,
+	0.975309f,
+	0.0483622f,
+	-0.0961691f,
+	0.964354f,
+	0.246521f,
+	-0.114487f,
+	0.922048f,
+	0.369757f,
+	-0.269656f,
+	0.899414f,
+	0.344007f,
+	-0.21772f,
+	0.897789f,
+	0.382849f,
+	-0.126818f,
+	0.886934f,
+	0.444145f,
+	0.0624514f,
+	0.872607f,
+	0.484415f,
+	0.170504f,
+	0.863439f,
+	0.474764f,
+	0.127681f,
+	0.882519f,
+	0.452612f,
+	0.0249418f,
+	0.887332f,
+	0.460457f,
+	-0.228952f,
+	0.87943f,
+	0.417354f,
+	-0.336679f,
+	0.801754f,
+	0.493799f,
+	-0.354676f,
+	0.742594f,
+	0.568119f,
+	-0.265358f,
+	0.728648f,
+	0.631393f,
+	-0.0874663f,
+	0.774696f,
+	0.626255f,
+	0.0313715f,
+	0.816845f,
+	0.576004f,
+	0.138491f,
+	0.877406f,
+	0.459325f,
+	0.251487f,
+	0.873743f,
+	0.416325f,
+	0.149012f,
+	0.891076f,
+	0.428695f,
+	0.134082f,
+	0.895567f,
+	0.424244f,
+	0.259356f,
+	0.879751f,
+	0.398462f,
+	0.273738f,
+	0.923515f,
+	0.268677f,
+	0.242075f,
+	0.954352f,
+	0.174962f,
+	0.166067f,
+	0.977105f,
+	0.132992f,
+	0.0519593f,
+	0.998404f,
+	0.022142f,
+	0.0706628f,
+	0.997395f,
+	0.0145074f,
+	0.0910476f,
+	0.994722f,
+	0.0473141f,
+	0.126598f,
+	0.990827f,
+	0.0472679f,
+	0.33108f,
+	0.937289f,
+	0.108974f,
+	0.427456f,
+	0.888646f,
+	0.166103f,
+	0.265492f,
+	0.95292f,
+	0.14648f,
+	0.0868945f,
+	0.990384f,
+	0.10765f,
+	0.0739344f,
+	0.98242f,
+	0.171417f,
+	0.14882f,
+	0.964095f,
+	0.219937f,
+	0.160065f,
+	0.969614f,
+	0.185009f,
+	0.0379065f,
+	0.980794f,
+	0.191328f,
+	-0.111879f,
+	0.992654f,
+	0.0460448f,
+	0.101571f,
+	0.994616f,
+	0.0205655f,
+	0.134276f,
+	0.987226f,
+	0.0857599f,
+	0.00322228f,
+	0.996946f,
+	0.0780295f,
+	-0.00585508f,
+	0.99961f,
+	0.0273218f,
+	0.102527f,
+	0.992913f,
+	0.0601057f,
+	-0.0243337f,
+	0.999696f,
+	0.00385478f,
+	-0.236106f,
+	0.971591f,
+	0.0163038f,
+	-0.335881f,
+	0.941896f,
+	0.00400261f,
+	-0.319925f,
+	0.947097f,
+	0.0255887f,
+	-0.262465f,
+	0.960477f,
+	0.0927118f,
+	-0.320184f,
+	0.947305f,
+	-0.00973767f,
+	-0.358146f,
+	0.929034f,
+	0.0928862f,
+	-0.431591f,
+	0.882961f,
+	0.184686f,
+	-0.350194f,
+	0.913588f,
+	-0.20669f,
+	-0.241714f,
+	0.958821f,
+	-0.149118f,
+	-0.0874799f,
+	0.991928f,
+	-0.0917931f,
+	-0.00637736f,
+	0.998289f,
+	-0.0581162f,
+	0.0261719f,
+	0.997729f,
+	-0.0620574f,
+	0.00430678f,
+	0.979141f,
+	-0.203135f,
+	0.121705f,
+	0.971178f,
+	-0.20494f,
+	0.10219f,
+	0.965909f,
+	-0.237861f,
+	0.00407698f,
+	0.957171f,
+	-0.289495f,
+	-0.0386862f,
+	0.968014f,
+	-0.247897f,
+	-0.0509849f,
+	0.995926f,
+	-0.0743816f,
+	-0.228245f,
+	0.973592f,
+	-0.00474817f,
+	-0.140696f,
+	0.979081f,
+	0.146984f,
+	-0.104046f,
+	0.966867f,
+	0.233113f,
+	-0.254332f,
+	0.94315f,
+	0.213969f,
+	-0.211685f,
+	0.953746f,
+	0.213442f,
+	-0.245201f,
+	0.93619f,
+	0.251844f,
+	-0.247199f,
+	0.912647f,
+	0.325527f,
+	-0.213426f,
+	0.932543f,
+	0.291228f,
+	-0.170741f,
+	0.942588f,
+	0.28701f,
+	-0.0363946f,
+	0.943193f,
+	0.330245f,
+	0.169433f,
+	0.88607f,
+	0.431478f,
+	0.12169f,
+	0.89261f,
+	0.434096f,
+	0.0508642f,
+	0.869951f,
+	0.490509f,
+	-0.175065f,
+	0.875657f,
+	0.450086f,
+	-0.464211f,
+	0.815419f,
+	0.345833f,
+	-0.467728f,
+	0.796275f,
+	0.383635f,
+	-0.295863f,
+	0.865688f,
+	0.403795f,
+	-0.0706376f,
+	0.91172f,
+	0.404693f,
+	0.151265f,
+	0.880258f,
+	0.449738f,
+	0.239887f,
+	0.896678f,
+	0.372052f,
+	0.270966f,
+	0.902061f,
+	0.335952f,
+	0.133682f,
+	0.938928f,
+	0.317085f,
+	0.132181f,
+	0.949509f,
+	0.284538f,
+	0.337234f,
+	0.911457f,
+	0.235624f,
+	0.391568f,
+	0.908725f,
+	0.144547f,
+	0.297707f,
+	0.949115f,
+	0.10272f,
+	0.163642f,
+	0.985787f,
+	0.038011f,
+	0.0603665f,
+	0.994817f,
+	0.0818182f,
+	0.0342529f,
+	0.984393f,
+	0.172617f,
+	0.146f,
+	0.969394f,
+	0.197379f,
+	0.189586f,
+	0.979398f,
+	0.0695505f,
+	0.32179f,
+	0.946595f,
+	0.0202369f,
+	0.339913f,
+	0.938655f,
+	0.0581868f,
+	0.255631f,
+	0.940824f,
+	0.222493f,
+	0.130905f,
+	0.959362f,
+	0.249975f,
+	0.0245005f,
+	0.97884f,
+	0.203155f,
+	0.116898f,
+	0.96642f,
+	0.228839f,
+	0.217161f,
+	0.952887f,
+	0.211771f,
+	0.0905814f,
+	0.991503f,
+	0.0933592f,
+	0.00963547f,
+	0.999795f,
+	0.0178162f,
+	0.0707892f,
+	0.997359f,
+	-0.0162393f,
+	0.0454623f,
+	0.996335f,
+	0.0724521f,
+	0.025845f,
+	0.99119f,
+	0.129903f,
+	0.0553395f,
+	0.998031f,
+	0.0295398f,
+	0.0632528f,
+	0.997901f,
+	0.0138837f,
+	-0.000723073f,
+	0.987186f,
+	0.159572f,
+	-0.246121f,
+	0.956173f,
+	0.158611f,
+	-0.292993f,
+	0.948379f,
+	0.121377f,
+	-0.358856f,
+	0.933219f,
+	0.0180357f,
+	-0.312153f,
+	0.948631f,
+	0.0515794f,
+	-0.263061f,
+	0.955548f,
+	0.133141f,
+	-0.387996f,
+	0.907685f,
+	0.159898f,
+	-0.516559f,
+	0.845117f,
+	0.137638f,
+	-0.310178f,
+	0.948377f,
+	-0.0661154f,
+	-0.300026f,
+	0.949757f,
+	-0.0891454f,
+	-0.137668f,
+	0.990363f,
+	0.0151269f,
+	-0.0326899f,
+	0.997118f,
+	0.0684562f,
+	0.0835016f,
+	0.994462f,
+	0.0638203f,
+	0.0992766f,
+	0.995028f,
+	0.00796582f,
+	0.068628f,
+	0.997514f,
+	-0.0159775f,
+	0.181484f,
+	0.983266f,
+	0.0158879f,
+	0.0929905f,
+	0.991619f,
+	-0.0896955f,
+	-0.159863f,
+	0.9831f,
+	-0.0892104f,
+	-0.274969f,
+	0.956779f,
+	0.094689f,
+	-0.2578f,
+	0.933703f,
+	0.248472f,
+	-0.255563f,
+	0.934109f,
+	0.249254f,
+	-0.183445f,
+	0.905456f,
+	0.382751f,
+	-0.258353f,
+	0.860148f,
+	0.439771f,
+	-0.12588f,
+	0.873686f,
+	0.469923f,
+	-0.210169f,
+	0.916013f,
+	0.341684f,
+	-0.272883f,
+	0.91339f,
+	0.302083f,
+	-0.180317f,
+	0.937251f,
+	0.298406f,
+	-0.199625f,
+	0.942232f,
+	0.268977f,
+	-0.0859427f,
+	0.9396f,
+	0.33131f,
+	0.0831524f,
+	0.928739f,
+	0.361288f,
+	0.0997333f,
+	0.904186f,
+	0.415333f,
+	-0.0517762f,
+	0.893569f,
+	0.445931f,
+	-0.109718f,
+	0.87826f,
+	0.465426f,
+	-0.369685f,
+	0.848108f,
+	0.379534f,
+	-0.446603f,
+	0.811841f,
+	0.376112f,
+	-0.267849f,
+	0.883969f,
+	0.383218f,
+	-0.10672f,
+	0.930725f,
+	0.349801f,
+	0.10205f,
+	0.92892f,
+	0.355941f,
+	0.253281f,
+	0.903219f,
+	0.346475f,
+	0.270898f,
+	0.880967f,
+	0.387957f,
+	0.236849f,
+	0.896348f,
+	0.374784f,
+	0.206634f,
+	0.946539f,
+	0.247723f,
+	0.405577f,
+	0.89206f,
+	0.199342f,
+	0.379351f,
+	0.915673f,
+	0.1328f,
+	0.334598f,
+	0.922412f,
+	0.192872f,
+	0.211991f,
+	0.969195f,
+	0.125385f,
+	-0.0201216f,
+	0.993487f,
+	0.112152f,
+	-0.0648495f,
+	0.986484f,
+	0.150479f,
+	0.170924f,
+	0.975936f,
+	0.135405f,
+	0.29249f,
+	0.9553f,
+	0.0430209f,
+	0.300918f,
+	0.953641f,
+	0.00421578f,
+	0.280252f,
+	0.954656f,
+	0.100457f,
+	0.110799f,
+	0.982326f,
+	0.150862f,
+	0.111953f,
+	0.970209f,
+	0.214852f,
+	0.0917898f,
+	0.974074f,
+	0.206772f,
+	0.0706157f,
+	0.981239f,
+	0.179398f,
+	0.263217f,
+	0.920389f,
+	0.289137f,
+	0.266708f,
+	0.942871f,
+	0.199653f,
+	0.0169344f,
+	0.99983f,
+	0.00724636f,
+	0.0586405f,
+	0.99674f,
+	0.0554216f,
+	-0.0335948f,
+	0.99924f,
+	0.0197934f,
+	0.0130139f,
+	0.996641f,
+	0.0808552f,
+	0.158081f,
+	0.974057f,
+	0.161934f,
+	-0.0718701f,
+	0.984912f,
+	0.157428f,
+	-0.146615f,
+	0.930223f,
+	0.336437f,
+	-0.215441f,
+	0.915614f,
+	0.339465f,
+	-0.194576f,
+	0.929319f,
+	0.313857f,
+	-0.21244f,
+	0.956751f,
+	0.198736f,
+	-0.353032f,
+	0.933914f,
+	0.0563254f,
+	-0.387138f,
+	0.913346f,
+	0.126188f,
+	-0.421226f,
+	0.884098f,
+	0.202334f,
+	-0.478159f,
+	0.863227f,
+	0.161871f,
+	-0.144962f,
+	0.987796f,
+	0.0569687f,
+	-0.329752f,
+	0.937067f,
+	-0.114758f,
+	-0.228627f,
+	0.973393f,
+	0.0153452f,
+	-0.0297707f,
+	0.988896f,
+	0.1456f,
+	0.0737235f,
+	0.992418f,
+	0.0983429f,
+	0.119683f,
+	0.983634f,
+	0.134687f,
+	0.0735029f,
+	0.988539f,
+	0.131863f,
+	0.205816f,
+	0.971725f,
+	0.115713f,
+	0.105316f,
+	0.994111f,
+	0.0255379f,
+	-0.224655f,
+	0.970814f,
+	0.0839657f,
+	-0.371877f,
+	0.9075f,
+	0.195325f,
+	-0.304303f,
+	0.906448f,
+	0.292833f,
+	-0.280483f,
+	0.900657f,
+	0.331883f,
+	-0.306628f,
+	0.862929f,
+	0.401664f,
+	-0.272078f,
+	0.807801f,
+	0.522907f,
+	-0.0728986f,
+	0.827771f,
+	0.55631f,
+	-0.0766844f,
+	0.868115f,
+	0.490404f,
+	-0.262952f,
+	0.903979f,
+	0.337163f,
+	-0.116268f,
+	0.92805f,
+	0.353844f,
+	-0.236581f,
+	0.941122f,
+	0.241494f,
+	-0.103825f,
+	0.933685f,
+	0.342713f,
+	0.0620174f,
+	0.936003f,
+	0.346485f,
+	0.0525461f,
+	0.928042f,
+	0.368751f,
+	-0.037371f,
+	0.900626f,
+	0.432986f,
+	-0.0859425f,
+	0.920181f,
+	0.381944f,
+	-0.402084f,
+	0.867474f,
+	0.292945f,
+	-0.458834f,
+	0.792013f,
+	0.402725f,
+	-0.247545f,
+	0.839465f,
+	0.483756f,
+	-0.0206347f,
+	0.857039f,
+	0.514838f,
+	0.131938f,
+	0.906082f,
+	0.402004f,
+	0.260907f,
+	0.906936f,
+	0.330749f,
+	0.222736f,
+	0.912076f,
+	0.344246f,
+	0.286017f,
+	0.867948f,
+	0.406029f,
+	0.265664f,
+	0.918021f,
+	0.29438f,
+	0.386646f,
+	0.888781f,
+	0.246116f,
+	0.416594f,
+	0.869611f,
+	0.265003f,
+	0.291338f,
+	0.924889f,
+	0.244341f,
+	0.264598f,
+	0.920497f,
+	0.287528f,
+	-0.0209737f,
+	0.965015f,
+	0.261353f,
+	0.011928f,
+	0.966786f,
+	0.255307f,
+	0.209759f,
+	0.975171f,
+	0.0710066f,
+	0.379568f,
+	0.924828f,
+	0.0249204f,
+	0.227757f,
+	0.968062f,
+	-0.104795f,
+	0.230276f,
+	0.968937f,
+	0.0901831f,
+	0.121279f,
+	0.97806f,
+	0.169381f,
+	0.101139f,
+	0.989453f,
+	0.103701f,
+	0.125341f,
+	0.986876f,
+	0.101809f,
+	0.00931107f,
+	0.998148f,
+	0.0601183f,
+	0.147262f,
+	0.96746f,
+	0.205755f,
+	0.372526f,
+	0.861294f,
+	0.34554f,
+	0.0770606f,
+	0.989688f,
+	0.120749f,
+	0.0673416f,
+	0.990666f,
+	0.11852f,
+	0.0242126f,
+	0.998823f,
+	0.0420167f,
+	-0.0975945f,
+	0.993903f,
+	-0.0513095f,
+	0.0117629f,
+	0.986762f,
+	0.16175f,
+	-0.119035f,
+	0.908985f,
+	0.399472f,
+	-0.171696f,
+	0.877378f,
+	0.448027f,
+	-0.168225f,
+	0.894295f,
+	0.414653f,
+	-0.158105f,
+	0.915758f,
+	0.369311f,
+	-0.0984338f,
+	0.938718f,
+	0.330333f,
+	-0.319812f,
+	0.930617f,
+	0.177966f,
+	-0.398204f,
+	0.897351f,
+	0.190248f,
+	-0.414882f,
+	0.896338f,
+	0.156369f,
+	-0.434877f,
+	0.894265f,
+	0.105701f,
+};
+
+btScalar Landscape07Tex[] = {
+	0.507813f,
+	0.742188f,
+	0.507813f,
+	0.734375f,
+	0.515625f,
+	0.742188f,
+	0.515625f,
+	0.734375f,
+	0.523438f,
+	0.742188f,
+	0.523438f,
+	0.734375f,
+	0.53125f,
+	0.742188f,
+	0.53125f,
+	0.734375f,
+	0.539063f,
+	0.742188f,
+	0.539063f,
+	0.734375f,
+	0.546875f,
+	0.742188f,
+	0.546875f,
+	0.734375f,
+	0.554688f,
+	0.742188f,
+	0.554688f,
+	0.734375f,
+	0.5625f,
+	0.742188f,
+	0.5625f,
+	0.734375f,
+	0.570313f,
+	0.742188f,
+	0.570313f,
+	0.734375f,
+	0.578125f,
+	0.742188f,
+	0.578125f,
+	0.734375f,
+	0.585938f,
+	0.742188f,
+	0.585938f,
+	0.734375f,
+	0.59375f,
+	0.742188f,
+	0.59375f,
+	0.734375f,
+	0.601563f,
+	0.742188f,
+	0.601563f,
+	0.734375f,
+	0.609375f,
+	0.742188f,
+	0.609375f,
+	0.734375f,
+	0.617188f,
+	0.742188f,
+	0.617188f,
+	0.734375f,
+	0.625f,
+	0.742188f,
+	0.625f,
+	0.734375f,
+	0.632813f,
+	0.742188f,
+	0.632813f,
+	0.734375f,
+	0.640625f,
+	0.742188f,
+	0.640625f,
+	0.734375f,
+	0.648438f,
+	0.742188f,
+	0.648438f,
+	0.734375f,
+	0.65625f,
+	0.742188f,
+	0.65625f,
+	0.734375f,
+	0.664063f,
+	0.742188f,
+	0.664063f,
+	0.734375f,
+	0.671875f,
+	0.742188f,
+	0.671875f,
+	0.734375f,
+	0.679688f,
+	0.742188f,
+	0.679688f,
+	0.734375f,
+	0.6875f,
+	0.742188f,
+	0.6875f,
+	0.734375f,
+	0.695313f,
+	0.742188f,
+	0.695313f,
+	0.734375f,
+	0.703125f,
+	0.742188f,
+	0.703125f,
+	0.734375f,
+	0.710938f,
+	0.742188f,
+	0.710938f,
+	0.734375f,
+	0.71875f,
+	0.742188f,
+	0.71875f,
+	0.734375f,
+	0.726563f,
+	0.742188f,
+	0.726563f,
+	0.734375f,
+	0.734375f,
+	0.742188f,
+	0.734375f,
+	0.734375f,
+	0.742188f,
+	0.742188f,
+	0.742188f,
+	0.734375f,
+	0.75f,
+	0.742188f,
+	0.75f,
+	0.734375f,
+	0.757813f,
+	0.742188f,
+	0.757813f,
+	0.734375f,
+	0.765625f,
+	0.742188f,
+	0.765625f,
+	0.734375f,
+	0.773438f,
+	0.742188f,
+	0.773438f,
+	0.734375f,
+	0.78125f,
+	0.742188f,
+	0.78125f,
+	0.734375f,
+	0.789063f,
+	0.742188f,
+	0.789063f,
+	0.734375f,
+	0.796875f,
+	0.742188f,
+	0.796875f,
+	0.734375f,
+	0.804688f,
+	0.742188f,
+	0.804688f,
+	0.734375f,
+	0.8125f,
+	0.742188f,
+	0.8125f,
+	0.734375f,
+	0.820313f,
+	0.742188f,
+	0.820313f,
+	0.734375f,
+	0.828125f,
+	0.742188f,
+	0.828125f,
+	0.734375f,
+	0.835938f,
+	0.742188f,
+	0.835938f,
+	0.734375f,
+	0.84375f,
+	0.742188f,
+	0.84375f,
+	0.734375f,
+	0.851563f,
+	0.742188f,
+	0.851563f,
+	0.734375f,
+	0.859375f,
+	0.742188f,
+	0.859375f,
+	0.734375f,
+	0.867188f,
+	0.742188f,
+	0.867188f,
+	0.734375f,
+	0.875f,
+	0.742188f,
+	0.875f,
+	0.734375f,
+	0.882813f,
+	0.742188f,
+	0.882813f,
+	0.734375f,
+	0.890625f,
+	0.742188f,
+	0.890625f,
+	0.734375f,
+	0.898438f,
+	0.742188f,
+	0.898438f,
+	0.734375f,
+	0.90625f,
+	0.742188f,
+	0.90625f,
+	0.734375f,
+	0.914063f,
+	0.742188f,
+	0.914063f,
+	0.734375f,
+	0.921875f,
+	0.742188f,
+	0.921875f,
+	0.734375f,
+	0.929688f,
+	0.742188f,
+	0.929688f,
+	0.734375f,
+	0.9375f,
+	0.742188f,
+	0.9375f,
+	0.734375f,
+	0.945313f,
+	0.742188f,
+	0.945313f,
+	0.734375f,
+	0.953125f,
+	0.742188f,
+	0.953125f,
+	0.734375f,
+	0.960938f,
+	0.742188f,
+	0.960938f,
+	0.734375f,
+	0.96875f,
+	0.742188f,
+	0.96875f,
+	0.734375f,
+	0.976563f,
+	0.742188f,
+	0.976563f,
+	0.734375f,
+	0.984375f,
+	0.742188f,
+	0.984375f,
+	0.734375f,
+	0.992188f,
+	0.742188f,
+	0.992188f,
+	0.734375f,
+	1.0f,
+	0.742188f,
+	1.0f,
+	0.734375f,
+	0.507813f,
+	0.75f,
+	0.515625f,
+	0.75f,
+	0.523438f,
+	0.75f,
+	0.53125f,
+	0.75f,
+	0.539063f,
+	0.75f,
+	0.546875f,
+	0.75f,
+	0.554688f,
+	0.75f,
+	0.5625f,
+	0.75f,
+	0.570313f,
+	0.75f,
+	0.578125f,
+	0.75f,
+	0.585938f,
+	0.75f,
+	0.59375f,
+	0.75f,
+	0.601563f,
+	0.75f,
+	0.609375f,
+	0.75f,
+	0.617188f,
+	0.75f,
+	0.625f,
+	0.75f,
+	0.632813f,
+	0.75f,
+	0.640625f,
+	0.75f,
+	0.648438f,
+	0.75f,
+	0.65625f,
+	0.75f,
+	0.664063f,
+	0.75f,
+	0.671875f,
+	0.75f,
+	0.679688f,
+	0.75f,
+	0.6875f,
+	0.75f,
+	0.695313f,
+	0.75f,
+	0.703125f,
+	0.75f,
+	0.710938f,
+	0.75f,
+	0.71875f,
+	0.75f,
+	0.726563f,
+	0.75f,
+	0.734375f,
+	0.75f,
+	0.742188f,
+	0.75f,
+	0.75f,
+	0.75f,
+	0.757813f,
+	0.75f,
+	0.765625f,
+	0.75f,
+	0.773438f,
+	0.75f,
+	0.78125f,
+	0.75f,
+	0.789063f,
+	0.75f,
+	0.796875f,
+	0.75f,
+	0.804688f,
+	0.75f,
+	0.8125f,
+	0.75f,
+	0.820313f,
+	0.75f,
+	0.828125f,
+	0.75f,
+	0.835938f,
+	0.75f,
+	0.84375f,
+	0.75f,
+	0.851563f,
+	0.75f,
+	0.859375f,
+	0.75f,
+	0.867188f,
+	0.75f,
+	0.875f,
+	0.75f,
+	0.882813f,
+	0.75f,
+	0.890625f,
+	0.75f,
+	0.898438f,
+	0.75f,
+	0.90625f,
+	0.75f,
+	0.914063f,
+	0.75f,
+	0.921875f,
+	0.75f,
+	0.929688f,
+	0.75f,
+	0.9375f,
+	0.75f,
+	0.945313f,
+	0.75f,
+	0.953125f,
+	0.75f,
+	0.960938f,
+	0.75f,
+	0.96875f,
+	0.75f,
+	0.976563f,
+	0.75f,
+	0.984375f,
+	0.75f,
+	0.992188f,
+	0.75f,
+	1.0f,
+	0.75f,
+	0.507813f,
+	0.757813f,
+	0.515625f,
+	0.757813f,
+	0.523438f,
+	0.757813f,
+	0.53125f,
+	0.757813f,
+	0.539063f,
+	0.757813f,
+	0.546875f,
+	0.757813f,
+	0.554688f,
+	0.757813f,
+	0.5625f,
+	0.757813f,
+	0.570313f,
+	0.757813f,
+	0.578125f,
+	0.757813f,
+	0.585938f,
+	0.757813f,
+	0.59375f,
+	0.757813f,
+	0.601563f,
+	0.757813f,
+	0.609375f,
+	0.757813f,
+	0.617188f,
+	0.757813f,
+	0.625f,
+	0.757813f,
+	0.632813f,
+	0.757813f,
+	0.640625f,
+	0.757813f,
+	0.648438f,
+	0.757813f,
+	0.65625f,
+	0.757813f,
+	0.664063f,
+	0.757813f,
+	0.671875f,
+	0.757813f,
+	0.679688f,
+	0.757813f,
+	0.6875f,
+	0.757813f,
+	0.695313f,
+	0.757813f,
+	0.703125f,
+	0.757813f,
+	0.710938f,
+	0.757813f,
+	0.71875f,
+	0.757813f,
+	0.726563f,
+	0.757813f,
+	0.734375f,
+	0.757813f,
+	0.742188f,
+	0.757813f,
+	0.75f,
+	0.757813f,
+	0.757813f,
+	0.757813f,
+	0.765625f,
+	0.757813f,
+	0.773438f,
+	0.757813f,
+	0.78125f,
+	0.757813f,
+	0.789063f,
+	0.757813f,
+	0.796875f,
+	0.757813f,
+	0.804688f,
+	0.757813f,
+	0.8125f,
+	0.757813f,
+	0.820313f,
+	0.757813f,
+	0.828125f,
+	0.757813f,
+	0.835938f,
+	0.757813f,
+	0.84375f,
+	0.757813f,
+	0.851563f,
+	0.757813f,
+	0.859375f,
+	0.757813f,
+	0.867188f,
+	0.757813f,
+	0.875f,
+	0.757813f,
+	0.882813f,
+	0.757813f,
+	0.890625f,
+	0.757813f,
+	0.898438f,
+	0.757813f,
+	0.90625f,
+	0.757813f,
+	0.914063f,
+	0.757813f,
+	0.921875f,
+	0.757813f,
+	0.929688f,
+	0.757813f,
+	0.9375f,
+	0.757813f,
+	0.945313f,
+	0.757813f,
+	0.953125f,
+	0.757813f,
+	0.960938f,
+	0.757813f,
+	0.96875f,
+	0.757813f,
+	0.976563f,
+	0.757813f,
+	0.984375f,
+	0.757813f,
+	0.992188f,
+	0.757813f,
+	1.0f,
+	0.757813f,
+	0.507813f,
+	0.765625f,
+	0.515625f,
+	0.765625f,
+	0.523438f,
+	0.765625f,
+	0.53125f,
+	0.765625f,
+	0.539063f,
+	0.765625f,
+	0.546875f,
+	0.765625f,
+	0.554688f,
+	0.765625f,
+	0.5625f,
+	0.765625f,
+	0.570313f,
+	0.765625f,
+	0.578125f,
+	0.765625f,
+	0.585938f,
+	0.765625f,
+	0.59375f,
+	0.765625f,
+	0.601563f,
+	0.765625f,
+	0.609375f,
+	0.765625f,
+	0.617188f,
+	0.765625f,
+	0.625f,
+	0.765625f,
+	0.632813f,
+	0.765625f,
+	0.640625f,
+	0.765625f,
+	0.648438f,
+	0.765625f,
+	0.65625f,
+	0.765625f,
+	0.664063f,
+	0.765625f,
+	0.671875f,
+	0.765625f,
+	0.679688f,
+	0.765625f,
+	0.6875f,
+	0.765625f,
+	0.695313f,
+	0.765625f,
+	0.703125f,
+	0.765625f,
+	0.710938f,
+	0.765625f,
+	0.71875f,
+	0.765625f,
+	0.726563f,
+	0.765625f,
+	0.734375f,
+	0.765625f,
+	0.742188f,
+	0.765625f,
+	0.75f,
+	0.765625f,
+	0.757813f,
+	0.765625f,
+	0.765625f,
+	0.765625f,
+	0.773438f,
+	0.765625f,
+	0.78125f,
+	0.765625f,
+	0.789063f,
+	0.765625f,
+	0.796875f,
+	0.765625f,
+	0.804688f,
+	0.765625f,
+	0.8125f,
+	0.765625f,
+	0.820313f,
+	0.765625f,
+	0.828125f,
+	0.765625f,
+	0.835938f,
+	0.765625f,
+	0.84375f,
+	0.765625f,
+	0.851563f,
+	0.765625f,
+	0.859375f,
+	0.765625f,
+	0.867188f,
+	0.765625f,
+	0.875f,
+	0.765625f,
+	0.882813f,
+	0.765625f,
+	0.890625f,
+	0.765625f,
+	0.898438f,
+	0.765625f,
+	0.90625f,
+	0.765625f,
+	0.914063f,
+	0.765625f,
+	0.921875f,
+	0.765625f,
+	0.929688f,
+	0.765625f,
+	0.9375f,
+	0.765625f,
+	0.945313f,
+	0.765625f,
+	0.953125f,
+	0.765625f,
+	0.960938f,
+	0.765625f,
+	0.96875f,
+	0.765625f,
+	0.976563f,
+	0.765625f,
+	0.984375f,
+	0.765625f,
+	0.992188f,
+	0.765625f,
+	1.0f,
+	0.765625f,
+	0.507813f,
+	0.773438f,
+	0.515625f,
+	0.773438f,
+	0.523438f,
+	0.773438f,
+	0.53125f,
+	0.773438f,
+	0.539063f,
+	0.773438f,
+	0.546875f,
+	0.773438f,
+	0.554688f,
+	0.773438f,
+	0.5625f,
+	0.773438f,
+	0.570313f,
+	0.773438f,
+	0.578125f,
+	0.773438f,
+	0.585938f,
+	0.773438f,
+	0.59375f,
+	0.773438f,
+	0.601563f,
+	0.773438f,
+	0.609375f,
+	0.773438f,
+	0.617188f,
+	0.773438f,
+	0.625f,
+	0.773438f,
+	0.632813f,
+	0.773438f,
+	0.640625f,
+	0.773438f,
+	0.648438f,
+	0.773438f,
+	0.65625f,
+	0.773438f,
+	0.664063f,
+	0.773438f,
+	0.671875f,
+	0.773438f,
+	0.679688f,
+	0.773438f,
+	0.6875f,
+	0.773438f,
+	0.695313f,
+	0.773438f,
+	0.703125f,
+	0.773438f,
+	0.710938f,
+	0.773438f,
+	0.71875f,
+	0.773438f,
+	0.726563f,
+	0.773438f,
+	0.734375f,
+	0.773438f,
+	0.742188f,
+	0.773438f,
+	0.75f,
+	0.773438f,
+	0.757813f,
+	0.773438f,
+	0.765625f,
+	0.773438f,
+	0.773438f,
+	0.773438f,
+	0.78125f,
+	0.773438f,
+	0.789063f,
+	0.773438f,
+	0.796875f,
+	0.773438f,
+	0.804688f,
+	0.773438f,
+	0.8125f,
+	0.773438f,
+	0.820313f,
+	0.773438f,
+	0.828125f,
+	0.773438f,
+	0.835938f,
+	0.773438f,
+	0.84375f,
+	0.773438f,
+	0.851563f,
+	0.773438f,
+	0.859375f,
+	0.773438f,
+	0.867188f,
+	0.773438f,
+	0.875f,
+	0.773438f,
+	0.882813f,
+	0.773438f,
+	0.890625f,
+	0.773438f,
+	0.898438f,
+	0.773438f,
+	0.90625f,
+	0.773438f,
+	0.914063f,
+	0.773438f,
+	0.921875f,
+	0.773438f,
+	0.929688f,
+	0.773438f,
+	0.9375f,
+	0.773438f,
+	0.945313f,
+	0.773438f,
+	0.953125f,
+	0.773438f,
+	0.960938f,
+	0.773438f,
+	0.96875f,
+	0.773438f,
+	0.976563f,
+	0.773438f,
+	0.984375f,
+	0.773438f,
+	0.992188f,
+	0.773438f,
+	1.0f,
+	0.773438f,
+	0.507813f,
+	0.78125f,
+	0.515625f,
+	0.78125f,
+	0.523438f,
+	0.78125f,
+	0.53125f,
+	0.78125f,
+	0.539063f,
+	0.78125f,
+	0.546875f,
+	0.78125f,
+	0.554688f,
+	0.78125f,
+	0.5625f,
+	0.78125f,
+	0.570313f,
+	0.78125f,
+	0.578125f,
+	0.78125f,
+	0.585938f,
+	0.78125f,
+	0.59375f,
+	0.78125f,
+	0.601563f,
+	0.78125f,
+	0.609375f,
+	0.78125f,
+	0.617188f,
+	0.78125f,
+	0.625f,
+	0.78125f,
+	0.632813f,
+	0.78125f,
+	0.640625f,
+	0.78125f,
+	0.648438f,
+	0.78125f,
+	0.65625f,
+	0.78125f,
+	0.664063f,
+	0.78125f,
+	0.671875f,
+	0.78125f,
+	0.679688f,
+	0.78125f,
+	0.6875f,
+	0.78125f,
+	0.695313f,
+	0.78125f,
+	0.703125f,
+	0.78125f,
+	0.710938f,
+	0.78125f,
+	0.71875f,
+	0.78125f,
+	0.726563f,
+	0.78125f,
+	0.734375f,
+	0.78125f,
+	0.742188f,
+	0.78125f,
+	0.75f,
+	0.78125f,
+	0.757813f,
+	0.78125f,
+	0.765625f,
+	0.78125f,
+	0.773438f,
+	0.78125f,
+	0.78125f,
+	0.78125f,
+	0.789063f,
+	0.78125f,
+	0.796875f,
+	0.78125f,
+	0.804688f,
+	0.78125f,
+	0.8125f,
+	0.78125f,
+	0.820313f,
+	0.78125f,
+	0.828125f,
+	0.78125f,
+	0.835938f,
+	0.78125f,
+	0.84375f,
+	0.78125f,
+	0.851563f,
+	0.78125f,
+	0.859375f,
+	0.78125f,
+	0.867188f,
+	0.78125f,
+	0.875f,
+	0.78125f,
+	0.882813f,
+	0.78125f,
+	0.890625f,
+	0.78125f,
+	0.898438f,
+	0.78125f,
+	0.90625f,
+	0.78125f,
+	0.914063f,
+	0.78125f,
+	0.921875f,
+	0.78125f,
+	0.929688f,
+	0.78125f,
+	0.9375f,
+	0.78125f,
+	0.945313f,
+	0.78125f,
+	0.953125f,
+	0.78125f,
+	0.960938f,
+	0.78125f,
+	0.96875f,
+	0.78125f,
+	0.976563f,
+	0.78125f,
+	0.984375f,
+	0.78125f,
+	0.992188f,
+	0.78125f,
+	1.0f,
+	0.78125f,
+	0.507813f,
+	0.789063f,
+	0.515625f,
+	0.789063f,
+	0.523438f,
+	0.789063f,
+	0.53125f,
+	0.789063f,
+	0.539063f,
+	0.789063f,
+	0.546875f,
+	0.789063f,
+	0.554688f,
+	0.789063f,
+	0.5625f,
+	0.789063f,
+	0.570313f,
+	0.789063f,
+	0.578125f,
+	0.789063f,
+	0.585938f,
+	0.789063f,
+	0.59375f,
+	0.789063f,
+	0.601563f,
+	0.789063f,
+	0.609375f,
+	0.789063f,
+	0.617188f,
+	0.789063f,
+	0.625f,
+	0.789063f,
+	0.632813f,
+	0.789063f,
+	0.640625f,
+	0.789063f,
+	0.648438f,
+	0.789063f,
+	0.65625f,
+	0.789063f,
+	0.664063f,
+	0.789063f,
+	0.671875f,
+	0.789063f,
+	0.679688f,
+	0.789063f,
+	0.6875f,
+	0.789063f,
+	0.695313f,
+	0.789063f,
+	0.703125f,
+	0.789063f,
+	0.710938f,
+	0.789063f,
+	0.71875f,
+	0.789063f,
+	0.726563f,
+	0.789063f,
+	0.734375f,
+	0.789063f,
+	0.742188f,
+	0.789063f,
+	0.75f,
+	0.789063f,
+	0.757813f,
+	0.789063f,
+	0.765625f,
+	0.789063f,
+	0.773438f,
+	0.789063f,
+	0.78125f,
+	0.789063f,
+	0.789063f,
+	0.789063f,
+	0.796875f,
+	0.789063f,
+	0.804688f,
+	0.789063f,
+	0.8125f,
+	0.789063f,
+	0.820313f,
+	0.789063f,
+	0.828125f,
+	0.789063f,
+	0.835938f,
+	0.789063f,
+	0.84375f,
+	0.789063f,
+	0.851563f,
+	0.789063f,
+	0.859375f,
+	0.789063f,
+	0.867188f,
+	0.789063f,
+	0.875f,
+	0.789063f,
+	0.882813f,
+	0.789063f,
+	0.890625f,
+	0.789063f,
+	0.898438f,
+	0.789063f,
+	0.90625f,
+	0.789063f,
+	0.914063f,
+	0.789063f,
+	0.921875f,
+	0.789063f,
+	0.929688f,
+	0.789063f,
+	0.9375f,
+	0.789063f,
+	0.945313f,
+	0.789063f,
+	0.953125f,
+	0.789063f,
+	0.960938f,
+	0.789063f,
+	0.96875f,
+	0.789063f,
+	0.976563f,
+	0.789063f,
+	0.984375f,
+	0.789063f,
+	0.992188f,
+	0.789063f,
+	1.0f,
+	0.789063f,
+	0.507813f,
+	0.796875f,
+	0.515625f,
+	0.796875f,
+	0.523438f,
+	0.796875f,
+	0.53125f,
+	0.796875f,
+	0.539063f,
+	0.796875f,
+	0.546875f,
+	0.796875f,
+	0.554688f,
+	0.796875f,
+	0.5625f,
+	0.796875f,
+	0.570313f,
+	0.796875f,
+	0.578125f,
+	0.796875f,
+	0.585938f,
+	0.796875f,
+	0.59375f,
+	0.796875f,
+	0.601563f,
+	0.796875f,
+	0.609375f,
+	0.796875f,
+	0.617188f,
+	0.796875f,
+	0.625f,
+	0.796875f,
+	0.632813f,
+	0.796875f,
+	0.640625f,
+	0.796875f,
+	0.648438f,
+	0.796875f,
+	0.65625f,
+	0.796875f,
+	0.664063f,
+	0.796875f,
+	0.671875f,
+	0.796875f,
+	0.679688f,
+	0.796875f,
+	0.6875f,
+	0.796875f,
+	0.695313f,
+	0.796875f,
+	0.703125f,
+	0.796875f,
+	0.710938f,
+	0.796875f,
+	0.71875f,
+	0.796875f,
+	0.726563f,
+	0.796875f,
+	0.734375f,
+	0.796875f,
+	0.742188f,
+	0.796875f,
+	0.75f,
+	0.796875f,
+	0.757813f,
+	0.796875f,
+	0.765625f,
+	0.796875f,
+	0.773438f,
+	0.796875f,
+	0.78125f,
+	0.796875f,
+	0.789063f,
+	0.796875f,
+	0.796875f,
+	0.796875f,
+	0.804688f,
+	0.796875f,
+	0.8125f,
+	0.796875f,
+	0.820313f,
+	0.796875f,
+	0.828125f,
+	0.796875f,
+	0.835938f,
+	0.796875f,
+	0.84375f,
+	0.796875f,
+	0.851563f,
+	0.796875f,
+	0.859375f,
+	0.796875f,
+	0.867188f,
+	0.796875f,
+	0.875f,
+	0.796875f,
+	0.882813f,
+	0.796875f,
+	0.890625f,
+	0.796875f,
+	0.898438f,
+	0.796875f,
+	0.90625f,
+	0.796875f,
+	0.914063f,
+	0.796875f,
+	0.921875f,
+	0.796875f,
+	0.929688f,
+	0.796875f,
+	0.9375f,
+	0.796875f,
+	0.945313f,
+	0.796875f,
+	0.953125f,
+	0.796875f,
+	0.960938f,
+	0.796875f,
+	0.96875f,
+	0.796875f,
+	0.976563f,
+	0.796875f,
+	0.984375f,
+	0.796875f,
+	0.992188f,
+	0.796875f,
+	1.0f,
+	0.796875f,
+	0.507813f,
+	0.804688f,
+	0.515625f,
+	0.804688f,
+	0.523438f,
+	0.804688f,
+	0.53125f,
+	0.804688f,
+	0.539063f,
+	0.804688f,
+	0.546875f,
+	0.804688f,
+	0.554688f,
+	0.804688f,
+	0.5625f,
+	0.804688f,
+	0.570313f,
+	0.804688f,
+	0.578125f,
+	0.804688f,
+	0.585938f,
+	0.804688f,
+	0.59375f,
+	0.804688f,
+	0.601563f,
+	0.804688f,
+	0.609375f,
+	0.804688f,
+	0.617188f,
+	0.804688f,
+	0.625f,
+	0.804688f,
+	0.632813f,
+	0.804688f,
+	0.640625f,
+	0.804688f,
+	0.648438f,
+	0.804688f,
+	0.65625f,
+	0.804688f,
+	0.664063f,
+	0.804688f,
+	0.671875f,
+	0.804688f,
+	0.679688f,
+	0.804688f,
+	0.6875f,
+	0.804688f,
+	0.695313f,
+	0.804688f,
+	0.703125f,
+	0.804688f,
+	0.710938f,
+	0.804688f,
+	0.71875f,
+	0.804688f,
+	0.726563f,
+	0.804688f,
+	0.734375f,
+	0.804688f,
+	0.742188f,
+	0.804688f,
+	0.75f,
+	0.804688f,
+	0.757813f,
+	0.804688f,
+	0.765625f,
+	0.804688f,
+	0.773438f,
+	0.804688f,
+	0.78125f,
+	0.804688f,
+	0.789063f,
+	0.804688f,
+	0.796875f,
+	0.804688f,
+	0.804688f,
+	0.804688f,
+	0.8125f,
+	0.804688f,
+	0.820313f,
+	0.804688f,
+	0.828125f,
+	0.804688f,
+	0.835938f,
+	0.804688f,
+	0.84375f,
+	0.804688f,
+	0.851563f,
+	0.804688f,
+	0.859375f,
+	0.804688f,
+	0.867188f,
+	0.804688f,
+	0.875f,
+	0.804688f,
+	0.882813f,
+	0.804688f,
+	0.890625f,
+	0.804688f,
+	0.898438f,
+	0.804688f,
+	0.90625f,
+	0.804688f,
+	0.914063f,
+	0.804688f,
+	0.921875f,
+	0.804688f,
+	0.929688f,
+	0.804688f,
+	0.9375f,
+	0.804688f,
+	0.945313f,
+	0.804688f,
+	0.953125f,
+	0.804688f,
+	0.960938f,
+	0.804688f,
+	0.96875f,
+	0.804688f,
+	0.976563f,
+	0.804688f,
+	0.984375f,
+	0.804688f,
+	0.992188f,
+	0.804688f,
+	1.0f,
+	0.804688f,
+	0.507813f,
+	0.8125f,
+	0.515625f,
+	0.8125f,
+	0.523438f,
+	0.8125f,
+	0.53125f,
+	0.8125f,
+	0.539063f,
+	0.8125f,
+	0.546875f,
+	0.8125f,
+	0.554688f,
+	0.8125f,
+	0.5625f,
+	0.8125f,
+	0.570313f,
+	0.8125f,
+	0.578125f,
+	0.8125f,
+	0.585938f,
+	0.8125f,
+	0.59375f,
+	0.8125f,
+	0.601563f,
+	0.8125f,
+	0.609375f,
+	0.8125f,
+	0.617188f,
+	0.8125f,
+	0.625f,
+	0.8125f,
+	0.632813f,
+	0.8125f,
+	0.640625f,
+	0.8125f,
+	0.648438f,
+	0.8125f,
+	0.65625f,
+	0.8125f,
+	0.664063f,
+	0.8125f,
+	0.671875f,
+	0.8125f,
+	0.679688f,
+	0.8125f,
+	0.6875f,
+	0.8125f,
+	0.695313f,
+	0.8125f,
+	0.703125f,
+	0.8125f,
+	0.710938f,
+	0.8125f,
+	0.71875f,
+	0.8125f,
+	0.726563f,
+	0.8125f,
+	0.734375f,
+	0.8125f,
+	0.742188f,
+	0.8125f,
+	0.75f,
+	0.8125f,
+	0.757813f,
+	0.8125f,
+	0.765625f,
+	0.8125f,
+	0.773438f,
+	0.8125f,
+	0.78125f,
+	0.8125f,
+	0.789063f,
+	0.8125f,
+	0.796875f,
+	0.8125f,
+	0.804688f,
+	0.8125f,
+	0.8125f,
+	0.8125f,
+	0.820313f,
+	0.8125f,
+	0.828125f,
+	0.8125f,
+	0.835938f,
+	0.8125f,
+	0.84375f,
+	0.8125f,
+	0.851563f,
+	0.8125f,
+	0.859375f,
+	0.8125f,
+	0.867188f,
+	0.8125f,
+	0.875f,
+	0.8125f,
+	0.882813f,
+	0.8125f,
+	0.890625f,
+	0.8125f,
+	0.898438f,
+	0.8125f,
+	0.90625f,
+	0.8125f,
+	0.914063f,
+	0.8125f,
+	0.921875f,
+	0.8125f,
+	0.929688f,
+	0.8125f,
+	0.9375f,
+	0.8125f,
+	0.945313f,
+	0.8125f,
+	0.953125f,
+	0.8125f,
+	0.960938f,
+	0.8125f,
+	0.96875f,
+	0.8125f,
+	0.976563f,
+	0.8125f,
+	0.984375f,
+	0.8125f,
+	0.992188f,
+	0.8125f,
+	1.0f,
+	0.8125f,
+	0.507813f,
+	0.820313f,
+	0.515625f,
+	0.820313f,
+	0.523438f,
+	0.820313f,
+	0.53125f,
+	0.820313f,
+	0.539063f,
+	0.820313f,
+	0.546875f,
+	0.820313f,
+	0.554688f,
+	0.820313f,
+	0.5625f,
+	0.820313f,
+	0.570313f,
+	0.820313f,
+	0.578125f,
+	0.820313f,
+	0.585938f,
+	0.820313f,
+	0.59375f,
+	0.820313f,
+	0.601563f,
+	0.820313f,
+	0.609375f,
+	0.820313f,
+	0.617188f,
+	0.820313f,
+	0.625f,
+	0.820313f,
+	0.632813f,
+	0.820313f,
+	0.640625f,
+	0.820313f,
+	0.648438f,
+	0.820313f,
+	0.65625f,
+	0.820313f,
+	0.664063f,
+	0.820313f,
+	0.671875f,
+	0.820313f,
+	0.679688f,
+	0.820313f,
+	0.6875f,
+	0.820313f,
+	0.695313f,
+	0.820313f,
+	0.703125f,
+	0.820313f,
+	0.710938f,
+	0.820313f,
+	0.71875f,
+	0.820313f,
+	0.726563f,
+	0.820313f,
+	0.734375f,
+	0.820313f,
+	0.742188f,
+	0.820313f,
+	0.75f,
+	0.820313f,
+	0.757813f,
+	0.820313f,
+	0.765625f,
+	0.820313f,
+	0.773438f,
+	0.820313f,
+	0.78125f,
+	0.820313f,
+	0.789063f,
+	0.820313f,
+	0.796875f,
+	0.820313f,
+	0.804688f,
+	0.820313f,
+	0.8125f,
+	0.820313f,
+	0.820313f,
+	0.820313f,
+	0.828125f,
+	0.820313f,
+	0.835938f,
+	0.820313f,
+	0.84375f,
+	0.820313f,
+	0.851563f,
+	0.820313f,
+	0.859375f,
+	0.820313f,
+	0.867188f,
+	0.820313f,
+	0.875f,
+	0.820313f,
+	0.882813f,
+	0.820313f,
+	0.890625f,
+	0.820313f,
+	0.898438f,
+	0.820313f,
+	0.90625f,
+	0.820313f,
+	0.914063f,
+	0.820313f,
+	0.921875f,
+	0.820313f,
+	0.929688f,
+	0.820313f,
+	0.9375f,
+	0.820313f,
+	0.945313f,
+	0.820313f,
+	0.953125f,
+	0.820313f,
+	0.960938f,
+	0.820313f,
+	0.96875f,
+	0.820313f,
+	0.976563f,
+	0.820313f,
+	0.984375f,
+	0.820313f,
+	0.992188f,
+	0.820313f,
+	1.0f,
+	0.820313f,
+	0.507813f,
+	0.828125f,
+	0.515625f,
+	0.828125f,
+	0.523438f,
+	0.828125f,
+	0.53125f,
+	0.828125f,
+	0.539063f,
+	0.828125f,
+	0.546875f,
+	0.828125f,
+	0.554688f,
+	0.828125f,
+	0.5625f,
+	0.828125f,
+	0.570313f,
+	0.828125f,
+	0.578125f,
+	0.828125f,
+	0.585938f,
+	0.828125f,
+	0.59375f,
+	0.828125f,
+	0.601563f,
+	0.828125f,
+	0.609375f,
+	0.828125f,
+	0.617188f,
+	0.828125f,
+	0.625f,
+	0.828125f,
+	0.632813f,
+	0.828125f,
+	0.640625f,
+	0.828125f,
+	0.648438f,
+	0.828125f,
+	0.65625f,
+	0.828125f,
+	0.664063f,
+	0.828125f,
+	0.671875f,
+	0.828125f,
+	0.679688f,
+	0.828125f,
+	0.6875f,
+	0.828125f,
+	0.695313f,
+	0.828125f,
+	0.703125f,
+	0.828125f,
+	0.710938f,
+	0.828125f,
+	0.71875f,
+	0.828125f,
+	0.726563f,
+	0.828125f,
+	0.734375f,
+	0.828125f,
+	0.742188f,
+	0.828125f,
+	0.75f,
+	0.828125f,
+	0.757813f,
+	0.828125f,
+	0.765625f,
+	0.828125f,
+	0.773438f,
+	0.828125f,
+	0.78125f,
+	0.828125f,
+	0.789063f,
+	0.828125f,
+	0.796875f,
+	0.828125f,
+	0.804688f,
+	0.828125f,
+	0.8125f,
+	0.828125f,
+	0.820313f,
+	0.828125f,
+	0.828125f,
+	0.828125f,
+	0.835938f,
+	0.828125f,
+	0.84375f,
+	0.828125f,
+	0.851563f,
+	0.828125f,
+	0.859375f,
+	0.828125f,
+	0.867188f,
+	0.828125f,
+	0.875f,
+	0.828125f,
+	0.882813f,
+	0.828125f,
+	0.890625f,
+	0.828125f,
+	0.898438f,
+	0.828125f,
+	0.90625f,
+	0.828125f,
+	0.914063f,
+	0.828125f,
+	0.921875f,
+	0.828125f,
+	0.929688f,
+	0.828125f,
+	0.9375f,
+	0.828125f,
+	0.945313f,
+	0.828125f,
+	0.953125f,
+	0.828125f,
+	0.960938f,
+	0.828125f,
+	0.96875f,
+	0.828125f,
+	0.976563f,
+	0.828125f,
+	0.984375f,
+	0.828125f,
+	0.992188f,
+	0.828125f,
+	1.0f,
+	0.828125f,
+	0.507813f,
+	0.835938f,
+	0.515625f,
+	0.835938f,
+	0.523438f,
+	0.835938f,
+	0.53125f,
+	0.835938f,
+	0.539063f,
+	0.835938f,
+	0.546875f,
+	0.835938f,
+	0.554688f,
+	0.835938f,
+	0.5625f,
+	0.835938f,
+	0.570313f,
+	0.835938f,
+	0.578125f,
+	0.835938f,
+	0.585938f,
+	0.835938f,
+	0.59375f,
+	0.835938f,
+	0.601563f,
+	0.835938f,
+	0.609375f,
+	0.835938f,
+	0.617188f,
+	0.835938f,
+	0.625f,
+	0.835938f,
+	0.632813f,
+	0.835938f,
+	0.640625f,
+	0.835938f,
+	0.648438f,
+	0.835938f,
+	0.65625f,
+	0.835938f,
+	0.664063f,
+	0.835938f,
+	0.671875f,
+	0.835938f,
+	0.679688f,
+	0.835938f,
+	0.6875f,
+	0.835938f,
+	0.695313f,
+	0.835938f,
+	0.703125f,
+	0.835938f,
+	0.710938f,
+	0.835938f,
+	0.71875f,
+	0.835938f,
+	0.726563f,
+	0.835938f,
+	0.734375f,
+	0.835938f,
+	0.742188f,
+	0.835938f,
+	0.75f,
+	0.835938f,
+	0.757813f,
+	0.835938f,
+	0.765625f,
+	0.835938f,
+	0.773438f,
+	0.835938f,
+	0.78125f,
+	0.835938f,
+	0.789063f,
+	0.835938f,
+	0.796875f,
+	0.835938f,
+	0.804688f,
+	0.835938f,
+	0.8125f,
+	0.835938f,
+	0.820313f,
+	0.835938f,
+	0.828125f,
+	0.835938f,
+	0.835938f,
+	0.835938f,
+	0.84375f,
+	0.835938f,
+	0.851563f,
+	0.835938f,
+	0.859375f,
+	0.835938f,
+	0.867188f,
+	0.835938f,
+	0.875f,
+	0.835938f,
+	0.882813f,
+	0.835938f,
+	0.890625f,
+	0.835938f,
+	0.898438f,
+	0.835938f,
+	0.90625f,
+	0.835938f,
+	0.914063f,
+	0.835938f,
+	0.921875f,
+	0.835938f,
+	0.929688f,
+	0.835938f,
+	0.9375f,
+	0.835938f,
+	0.945313f,
+	0.835938f,
+	0.953125f,
+	0.835938f,
+	0.960938f,
+	0.835938f,
+	0.96875f,
+	0.835938f,
+	0.976563f,
+	0.835938f,
+	0.984375f,
+	0.835938f,
+	0.992188f,
+	0.835938f,
+	1.0f,
+	0.835938f,
+	0.507813f,
+	0.84375f,
+	0.515625f,
+	0.84375f,
+	0.523438f,
+	0.84375f,
+	0.53125f,
+	0.84375f,
+	0.539063f,
+	0.84375f,
+	0.546875f,
+	0.84375f,
+	0.554688f,
+	0.84375f,
+	0.5625f,
+	0.84375f,
+	0.570313f,
+	0.84375f,
+	0.578125f,
+	0.84375f,
+	0.585938f,
+	0.84375f,
+	0.59375f,
+	0.84375f,
+	0.601563f,
+	0.84375f,
+	0.609375f,
+	0.84375f,
+	0.617188f,
+	0.84375f,
+	0.625f,
+	0.84375f,
+	0.632813f,
+	0.84375f,
+	0.640625f,
+	0.84375f,
+	0.648438f,
+	0.84375f,
+	0.65625f,
+	0.84375f,
+	0.664063f,
+	0.84375f,
+	0.671875f,
+	0.84375f,
+	0.679688f,
+	0.84375f,
+	0.6875f,
+	0.84375f,
+	0.695313f,
+	0.84375f,
+	0.703125f,
+	0.84375f,
+	0.710938f,
+	0.84375f,
+	0.71875f,
+	0.84375f,
+	0.726563f,
+	0.84375f,
+	0.734375f,
+	0.84375f,
+	0.742188f,
+	0.84375f,
+	0.75f,
+	0.84375f,
+	0.757813f,
+	0.84375f,
+	0.765625f,
+	0.84375f,
+	0.773438f,
+	0.84375f,
+	0.78125f,
+	0.84375f,
+	0.789063f,
+	0.84375f,
+	0.796875f,
+	0.84375f,
+	0.804688f,
+	0.84375f,
+	0.8125f,
+	0.84375f,
+	0.820313f,
+	0.84375f,
+	0.828125f,
+	0.84375f,
+	0.835938f,
+	0.84375f,
+	0.84375f,
+	0.84375f,
+	0.851563f,
+	0.84375f,
+	0.859375f,
+	0.84375f,
+	0.867188f,
+	0.84375f,
+	0.875f,
+	0.84375f,
+	0.882813f,
+	0.84375f,
+	0.890625f,
+	0.84375f,
+	0.898438f,
+	0.84375f,
+	0.90625f,
+	0.84375f,
+	0.914063f,
+	0.84375f,
+	0.921875f,
+	0.84375f,
+	0.929688f,
+	0.84375f,
+	0.9375f,
+	0.84375f,
+	0.945313f,
+	0.84375f,
+	0.953125f,
+	0.84375f,
+	0.960938f,
+	0.84375f,
+	0.96875f,
+	0.84375f,
+	0.976563f,
+	0.84375f,
+	0.984375f,
+	0.84375f,
+	0.992188f,
+	0.84375f,
+	1.0f,
+	0.84375f,
+	0.507813f,
+	0.851563f,
+	0.515625f,
+	0.851563f,
+	0.523438f,
+	0.851563f,
+	0.53125f,
+	0.851563f,
+	0.539063f,
+	0.851563f,
+	0.546875f,
+	0.851563f,
+	0.554688f,
+	0.851563f,
+	0.5625f,
+	0.851563f,
+	0.570313f,
+	0.851563f,
+	0.578125f,
+	0.851563f,
+	0.585938f,
+	0.851563f,
+	0.59375f,
+	0.851563f,
+	0.601563f,
+	0.851563f,
+	0.609375f,
+	0.851563f,
+	0.617188f,
+	0.851563f,
+	0.625f,
+	0.851563f,
+	0.632813f,
+	0.851563f,
+	0.640625f,
+	0.851563f,
+	0.648438f,
+	0.851563f,
+	0.65625f,
+	0.851563f,
+	0.664063f,
+	0.851563f,
+	0.671875f,
+	0.851563f,
+	0.679688f,
+	0.851563f,
+	0.6875f,
+	0.851563f,
+	0.695313f,
+	0.851563f,
+	0.703125f,
+	0.851563f,
+	0.710938f,
+	0.851563f,
+	0.71875f,
+	0.851563f,
+	0.726563f,
+	0.851563f,
+	0.734375f,
+	0.851563f,
+	0.742188f,
+	0.851563f,
+	0.75f,
+	0.851563f,
+	0.757813f,
+	0.851563f,
+	0.765625f,
+	0.851563f,
+	0.773438f,
+	0.851563f,
+	0.78125f,
+	0.851563f,
+	0.789063f,
+	0.851563f,
+	0.796875f,
+	0.851563f,
+	0.804688f,
+	0.851563f,
+	0.8125f,
+	0.851563f,
+	0.820313f,
+	0.851563f,
+	0.828125f,
+	0.851563f,
+	0.835938f,
+	0.851563f,
+	0.84375f,
+	0.851563f,
+	0.851563f,
+	0.851563f,
+	0.859375f,
+	0.851563f,
+	0.867188f,
+	0.851563f,
+	0.875f,
+	0.851563f,
+	0.882813f,
+	0.851563f,
+	0.890625f,
+	0.851563f,
+	0.898438f,
+	0.851563f,
+	0.90625f,
+	0.851563f,
+	0.914063f,
+	0.851563f,
+	0.921875f,
+	0.851563f,
+	0.929688f,
+	0.851563f,
+	0.9375f,
+	0.851563f,
+	0.945313f,
+	0.851563f,
+	0.953125f,
+	0.851563f,
+	0.960938f,
+	0.851563f,
+	0.96875f,
+	0.851563f,
+	0.976563f,
+	0.851563f,
+	0.984375f,
+	0.851563f,
+	0.992188f,
+	0.851563f,
+	1.0f,
+	0.851563f,
+	0.507813f,
+	0.859375f,
+	0.515625f,
+	0.859375f,
+	0.523438f,
+	0.859375f,
+	0.53125f,
+	0.859375f,
+	0.539063f,
+	0.859375f,
+	0.546875f,
+	0.859375f,
+	0.554688f,
+	0.859375f,
+	0.5625f,
+	0.859375f,
+	0.570313f,
+	0.859375f,
+	0.578125f,
+	0.859375f,
+	0.585938f,
+	0.859375f,
+	0.59375f,
+	0.859375f,
+	0.601563f,
+	0.859375f,
+	0.609375f,
+	0.859375f,
+	0.617188f,
+	0.859375f,
+	0.625f,
+	0.859375f,
+	0.632813f,
+	0.859375f,
+	0.640625f,
+	0.859375f,
+	0.648438f,
+	0.859375f,
+	0.65625f,
+	0.859375f,
+	0.664063f,
+	0.859375f,
+	0.671875f,
+	0.859375f,
+	0.679688f,
+	0.859375f,
+	0.6875f,
+	0.859375f,
+	0.695313f,
+	0.859375f,
+	0.703125f,
+	0.859375f,
+	0.710938f,
+	0.859375f,
+	0.71875f,
+	0.859375f,
+	0.726563f,
+	0.859375f,
+	0.734375f,
+	0.859375f,
+	0.742188f,
+	0.859375f,
+	0.75f,
+	0.859375f,
+	0.757813f,
+	0.859375f,
+	0.765625f,
+	0.859375f,
+	0.773438f,
+	0.859375f,
+	0.78125f,
+	0.859375f,
+	0.789063f,
+	0.859375f,
+	0.796875f,
+	0.859375f,
+	0.804688f,
+	0.859375f,
+	0.8125f,
+	0.859375f,
+	0.820313f,
+	0.859375f,
+	0.828125f,
+	0.859375f,
+	0.835938f,
+	0.859375f,
+	0.84375f,
+	0.859375f,
+	0.851563f,
+	0.859375f,
+	0.859375f,
+	0.859375f,
+	0.867188f,
+	0.859375f,
+	0.875f,
+	0.859375f,
+	0.882813f,
+	0.859375f,
+	0.890625f,
+	0.859375f,
+	0.898438f,
+	0.859375f,
+	0.90625f,
+	0.859375f,
+	0.914063f,
+	0.859375f,
+	0.921875f,
+	0.859375f,
+	0.929688f,
+	0.859375f,
+	0.9375f,
+	0.859375f,
+	0.945313f,
+	0.859375f,
+	0.953125f,
+	0.859375f,
+	0.960938f,
+	0.859375f,
+	0.96875f,
+	0.859375f,
+	0.976563f,
+	0.859375f,
+	0.984375f,
+	0.859375f,
+	0.992188f,
+	0.859375f,
+	1.0f,
+	0.859375f,
+	0.507813f,
+	0.867188f,
+	0.515625f,
+	0.867188f,
+	0.523438f,
+	0.867188f,
+	0.53125f,
+	0.867188f,
+	0.539063f,
+	0.867188f,
+	0.546875f,
+	0.867188f,
+	0.554688f,
+	0.867188f,
+	0.5625f,
+	0.867188f,
+	0.570313f,
+	0.867188f,
+	0.578125f,
+	0.867188f,
+	0.585938f,
+	0.867188f,
+	0.59375f,
+	0.867188f,
+	0.601563f,
+	0.867188f,
+	0.609375f,
+	0.867188f,
+	0.617188f,
+	0.867188f,
+	0.625f,
+	0.867188f,
+	0.632813f,
+	0.867188f,
+	0.640625f,
+	0.867188f,
+	0.648438f,
+	0.867188f,
+	0.65625f,
+	0.867188f,
+	0.664063f,
+	0.867188f,
+	0.671875f,
+	0.867188f,
+	0.679688f,
+	0.867188f,
+	0.6875f,
+	0.867188f,
+	0.695313f,
+	0.867188f,
+	0.703125f,
+	0.867188f,
+	0.710938f,
+	0.867188f,
+	0.71875f,
+	0.867188f,
+	0.726563f,
+	0.867188f,
+	0.734375f,
+	0.867188f,
+	0.742188f,
+	0.867188f,
+	0.75f,
+	0.867188f,
+	0.757813f,
+	0.867188f,
+	0.765625f,
+	0.867188f,
+	0.773438f,
+	0.867188f,
+	0.78125f,
+	0.867188f,
+	0.789063f,
+	0.867188f,
+	0.796875f,
+	0.867188f,
+	0.804688f,
+	0.867188f,
+	0.8125f,
+	0.867188f,
+	0.820313f,
+	0.867188f,
+	0.828125f,
+	0.867188f,
+	0.835938f,
+	0.867188f,
+	0.84375f,
+	0.867188f,
+	0.851563f,
+	0.867188f,
+	0.859375f,
+	0.867188f,
+	0.867188f,
+	0.867188f,
+	0.875f,
+	0.867188f,
+	0.882813f,
+	0.867188f,
+	0.890625f,
+	0.867188f,
+	0.898438f,
+	0.867188f,
+	0.90625f,
+	0.867188f,
+	0.914063f,
+	0.867188f,
+	0.921875f,
+	0.867188f,
+	0.929688f,
+	0.867188f,
+	0.9375f,
+	0.867188f,
+	0.945313f,
+	0.867188f,
+	0.953125f,
+	0.867188f,
+	0.960938f,
+	0.867188f,
+	0.96875f,
+	0.867188f,
+	0.976563f,
+	0.867188f,
+	0.984375f,
+	0.867188f,
+	0.992188f,
+	0.867188f,
+	1.0f,
+	0.867188f,
+	0.507813f,
+	0.875f,
+	0.515625f,
+	0.875f,
+	0.523438f,
+	0.875f,
+	0.53125f,
+	0.875f,
+	0.539063f,
+	0.875f,
+	0.546875f,
+	0.875f,
+	0.554688f,
+	0.875f,
+	0.5625f,
+	0.875f,
+	0.570313f,
+	0.875f,
+	0.578125f,
+	0.875f,
+	0.585938f,
+	0.875f,
+	0.59375f,
+	0.875f,
+	0.601563f,
+	0.875f,
+	0.609375f,
+	0.875f,
+	0.617188f,
+	0.875f,
+	0.625f,
+	0.875f,
+	0.632813f,
+	0.875f,
+	0.640625f,
+	0.875f,
+	0.648438f,
+	0.875f,
+	0.65625f,
+	0.875f,
+	0.664063f,
+	0.875f,
+	0.671875f,
+	0.875f,
+	0.679688f,
+	0.875f,
+	0.6875f,
+	0.875f,
+	0.695313f,
+	0.875f,
+	0.703125f,
+	0.875f,
+	0.710938f,
+	0.875f,
+	0.71875f,
+	0.875f,
+	0.726563f,
+	0.875f,
+	0.734375f,
+	0.875f,
+	0.742188f,
+	0.875f,
+	0.75f,
+	0.875f,
+	0.757813f,
+	0.875f,
+	0.765625f,
+	0.875f,
+	0.773438f,
+	0.875f,
+	0.78125f,
+	0.875f,
+	0.789063f,
+	0.875f,
+	0.796875f,
+	0.875f,
+	0.804688f,
+	0.875f,
+	0.8125f,
+	0.875f,
+	0.820313f,
+	0.875f,
+	0.828125f,
+	0.875f,
+	0.835938f,
+	0.875f,
+	0.84375f,
+	0.875f,
+	0.851563f,
+	0.875f,
+	0.859375f,
+	0.875f,
+	0.867188f,
+	0.875f,
+	0.875f,
+	0.875f,
+	0.882813f,
+	0.875f,
+	0.890625f,
+	0.875f,
+	0.898438f,
+	0.875f,
+	0.90625f,
+	0.875f,
+	0.914063f,
+	0.875f,
+	0.921875f,
+	0.875f,
+	0.929688f,
+	0.875f,
+	0.9375f,
+	0.875f,
+	0.945313f,
+	0.875f,
+	0.953125f,
+	0.875f,
+	0.960938f,
+	0.875f,
+	0.96875f,
+	0.875f,
+	0.976563f,
+	0.875f,
+	0.984375f,
+	0.875f,
+	0.992188f,
+	0.875f,
+	1.0f,
+	0.875f,
+	0.507813f,
+	0.882813f,
+	0.515625f,
+	0.882813f,
+	0.523438f,
+	0.882813f,
+	0.53125f,
+	0.882813f,
+	0.539063f,
+	0.882813f,
+	0.546875f,
+	0.882813f,
+	0.554688f,
+	0.882813f,
+	0.5625f,
+	0.882813f,
+	0.570313f,
+	0.882813f,
+	0.578125f,
+	0.882813f,
+	0.585938f,
+	0.882813f,
+	0.59375f,
+	0.882813f,
+	0.601563f,
+	0.882813f,
+	0.609375f,
+	0.882813f,
+	0.617188f,
+	0.882813f,
+	0.625f,
+	0.882813f,
+	0.632813f,
+	0.882813f,
+	0.640625f,
+	0.882813f,
+	0.648438f,
+	0.882813f,
+	0.65625f,
+	0.882813f,
+	0.664063f,
+	0.882813f,
+	0.671875f,
+	0.882813f,
+	0.679688f,
+	0.882813f,
+	0.6875f,
+	0.882813f,
+	0.695313f,
+	0.882813f,
+	0.703125f,
+	0.882813f,
+	0.710938f,
+	0.882813f,
+	0.71875f,
+	0.882813f,
+	0.726563f,
+	0.882813f,
+	0.734375f,
+	0.882813f,
+	0.742188f,
+	0.882813f,
+	0.75f,
+	0.882813f,
+	0.757813f,
+	0.882813f,
+	0.765625f,
+	0.882813f,
+	0.773438f,
+	0.882813f,
+	0.78125f,
+	0.882813f,
+	0.789063f,
+	0.882813f,
+	0.796875f,
+	0.882813f,
+	0.804688f,
+	0.882813f,
+	0.8125f,
+	0.882813f,
+	0.820313f,
+	0.882813f,
+	0.828125f,
+	0.882813f,
+	0.835938f,
+	0.882813f,
+	0.84375f,
+	0.882813f,
+	0.851563f,
+	0.882813f,
+	0.859375f,
+	0.882813f,
+	0.867188f,
+	0.882813f,
+	0.875f,
+	0.882813f,
+	0.882813f,
+	0.882813f,
+	0.890625f,
+	0.882813f,
+	0.898438f,
+	0.882813f,
+	0.90625f,
+	0.882813f,
+	0.914063f,
+	0.882813f,
+	0.921875f,
+	0.882813f,
+	0.929688f,
+	0.882813f,
+	0.9375f,
+	0.882813f,
+	0.945313f,
+	0.882813f,
+	0.953125f,
+	0.882813f,
+	0.960938f,
+	0.882813f,
+	0.96875f,
+	0.882813f,
+	0.976563f,
+	0.882813f,
+	0.984375f,
+	0.882813f,
+	0.992188f,
+	0.882813f,
+	1.0f,
+	0.882813f,
+	0.507813f,
+	0.890625f,
+	0.515625f,
+	0.890625f,
+	0.523438f,
+	0.890625f,
+	0.53125f,
+	0.890625f,
+	0.539063f,
+	0.890625f,
+	0.546875f,
+	0.890625f,
+	0.554688f,
+	0.890625f,
+	0.5625f,
+	0.890625f,
+	0.570313f,
+	0.890625f,
+	0.578125f,
+	0.890625f,
+	0.585938f,
+	0.890625f,
+	0.59375f,
+	0.890625f,
+	0.601563f,
+	0.890625f,
+	0.609375f,
+	0.890625f,
+	0.617188f,
+	0.890625f,
+	0.625f,
+	0.890625f,
+	0.632813f,
+	0.890625f,
+	0.640625f,
+	0.890625f,
+	0.648438f,
+	0.890625f,
+	0.65625f,
+	0.890625f,
+	0.664063f,
+	0.890625f,
+	0.671875f,
+	0.890625f,
+	0.679688f,
+	0.890625f,
+	0.6875f,
+	0.890625f,
+	0.695313f,
+	0.890625f,
+	0.703125f,
+	0.890625f,
+	0.710938f,
+	0.890625f,
+	0.71875f,
+	0.890625f,
+	0.726563f,
+	0.890625f,
+	0.734375f,
+	0.890625f,
+	0.742188f,
+	0.890625f,
+	0.75f,
+	0.890625f,
+	0.757813f,
+	0.890625f,
+	0.765625f,
+	0.890625f,
+	0.773438f,
+	0.890625f,
+	0.78125f,
+	0.890625f,
+	0.789063f,
+	0.890625f,
+	0.796875f,
+	0.890625f,
+	0.804688f,
+	0.890625f,
+	0.8125f,
+	0.890625f,
+	0.820313f,
+	0.890625f,
+	0.828125f,
+	0.890625f,
+	0.835938f,
+	0.890625f,
+	0.84375f,
+	0.890625f,
+	0.851563f,
+	0.890625f,
+	0.859375f,
+	0.890625f,
+	0.867188f,
+	0.890625f,
+	0.875f,
+	0.890625f,
+	0.882813f,
+	0.890625f,
+	0.890625f,
+	0.890625f,
+	0.898438f,
+	0.890625f,
+	0.90625f,
+	0.890625f,
+	0.914063f,
+	0.890625f,
+	0.921875f,
+	0.890625f,
+	0.929688f,
+	0.890625f,
+	0.9375f,
+	0.890625f,
+	0.945313f,
+	0.890625f,
+	0.953125f,
+	0.890625f,
+	0.960938f,
+	0.890625f,
+	0.96875f,
+	0.890625f,
+	0.976563f,
+	0.890625f,
+	0.984375f,
+	0.890625f,
+	0.992188f,
+	0.890625f,
+	1.0f,
+	0.890625f,
+	0.507813f,
+	0.898438f,
+	0.515625f,
+	0.898438f,
+	0.523438f,
+	0.898438f,
+	0.53125f,
+	0.898438f,
+	0.539063f,
+	0.898438f,
+	0.546875f,
+	0.898438f,
+	0.554688f,
+	0.898438f,
+	0.5625f,
+	0.898438f,
+	0.570313f,
+	0.898438f,
+	0.578125f,
+	0.898438f,
+	0.585938f,
+	0.898438f,
+	0.59375f,
+	0.898438f,
+	0.601563f,
+	0.898438f,
+	0.609375f,
+	0.898438f,
+	0.617188f,
+	0.898438f,
+	0.625f,
+	0.898438f,
+	0.632813f,
+	0.898438f,
+	0.640625f,
+	0.898438f,
+	0.648438f,
+	0.898438f,
+	0.65625f,
+	0.898438f,
+	0.664063f,
+	0.898438f,
+	0.671875f,
+	0.898438f,
+	0.679688f,
+	0.898438f,
+	0.6875f,
+	0.898438f,
+	0.695313f,
+	0.898438f,
+	0.703125f,
+	0.898438f,
+	0.710938f,
+	0.898438f,
+	0.71875f,
+	0.898438f,
+	0.726563f,
+	0.898438f,
+	0.734375f,
+	0.898438f,
+	0.742188f,
+	0.898438f,
+	0.75f,
+	0.898438f,
+	0.757813f,
+	0.898438f,
+	0.765625f,
+	0.898438f,
+	0.773438f,
+	0.898438f,
+	0.78125f,
+	0.898438f,
+	0.789063f,
+	0.898438f,
+	0.796875f,
+	0.898438f,
+	0.804688f,
+	0.898438f,
+	0.8125f,
+	0.898438f,
+	0.820313f,
+	0.898438f,
+	0.828125f,
+	0.898438f,
+	0.835938f,
+	0.898438f,
+	0.84375f,
+	0.898438f,
+	0.851563f,
+	0.898438f,
+	0.859375f,
+	0.898438f,
+	0.867188f,
+	0.898438f,
+	0.875f,
+	0.898438f,
+	0.882813f,
+	0.898438f,
+	0.890625f,
+	0.898438f,
+	0.898438f,
+	0.898438f,
+	0.90625f,
+	0.898438f,
+	0.914063f,
+	0.898438f,
+	0.921875f,
+	0.898438f,
+	0.929688f,
+	0.898438f,
+	0.9375f,
+	0.898438f,
+	0.945313f,
+	0.898438f,
+	0.953125f,
+	0.898438f,
+	0.960938f,
+	0.898438f,
+	0.96875f,
+	0.898438f,
+	0.976563f,
+	0.898438f,
+	0.984375f,
+	0.898438f,
+	0.992188f,
+	0.898438f,
+	1.0f,
+	0.898438f,
+	0.507813f,
+	0.90625f,
+	0.515625f,
+	0.90625f,
+	0.523438f,
+	0.90625f,
+	0.53125f,
+	0.90625f,
+	0.539063f,
+	0.90625f,
+	0.546875f,
+	0.90625f,
+	0.554688f,
+	0.90625f,
+	0.5625f,
+	0.90625f,
+	0.570313f,
+	0.90625f,
+	0.578125f,
+	0.90625f,
+	0.585938f,
+	0.90625f,
+	0.59375f,
+	0.90625f,
+	0.601563f,
+	0.90625f,
+	0.609375f,
+	0.90625f,
+	0.617188f,
+	0.90625f,
+	0.625f,
+	0.90625f,
+	0.632813f,
+	0.90625f,
+	0.640625f,
+	0.90625f,
+	0.648438f,
+	0.90625f,
+	0.65625f,
+	0.90625f,
+	0.664063f,
+	0.90625f,
+	0.671875f,
+	0.90625f,
+	0.679688f,
+	0.90625f,
+	0.6875f,
+	0.90625f,
+	0.695313f,
+	0.90625f,
+	0.703125f,
+	0.90625f,
+	0.710938f,
+	0.90625f,
+	0.71875f,
+	0.90625f,
+	0.726563f,
+	0.90625f,
+	0.734375f,
+	0.90625f,
+	0.742188f,
+	0.90625f,
+	0.75f,
+	0.90625f,
+	0.757813f,
+	0.90625f,
+	0.765625f,
+	0.90625f,
+	0.773438f,
+	0.90625f,
+	0.78125f,
+	0.90625f,
+	0.789063f,
+	0.90625f,
+	0.796875f,
+	0.90625f,
+	0.804688f,
+	0.90625f,
+	0.8125f,
+	0.90625f,
+	0.820313f,
+	0.90625f,
+	0.828125f,
+	0.90625f,
+	0.835938f,
+	0.90625f,
+	0.84375f,
+	0.90625f,
+	0.851563f,
+	0.90625f,
+	0.859375f,
+	0.90625f,
+	0.867188f,
+	0.90625f,
+	0.875f,
+	0.90625f,
+	0.882813f,
+	0.90625f,
+	0.890625f,
+	0.90625f,
+	0.898438f,
+	0.90625f,
+	0.90625f,
+	0.90625f,
+	0.914063f,
+	0.90625f,
+	0.921875f,
+	0.90625f,
+	0.929688f,
+	0.90625f,
+	0.9375f,
+	0.90625f,
+	0.945313f,
+	0.90625f,
+	0.953125f,
+	0.90625f,
+	0.960938f,
+	0.90625f,
+	0.96875f,
+	0.90625f,
+	0.976563f,
+	0.90625f,
+	0.984375f,
+	0.90625f,
+	0.992188f,
+	0.90625f,
+	1.0f,
+	0.90625f,
+	0.507813f,
+	0.914063f,
+	0.515625f,
+	0.914063f,
+	0.523438f,
+	0.914063f,
+	0.53125f,
+	0.914063f,
+	0.539063f,
+	0.914063f,
+	0.546875f,
+	0.914063f,
+	0.554688f,
+	0.914063f,
+	0.5625f,
+	0.914063f,
+	0.570313f,
+	0.914063f,
+	0.578125f,
+	0.914063f,
+	0.585938f,
+	0.914063f,
+	0.59375f,
+	0.914063f,
+	0.601563f,
+	0.914063f,
+	0.609375f,
+	0.914063f,
+	0.617188f,
+	0.914063f,
+	0.625f,
+	0.914063f,
+	0.632813f,
+	0.914063f,
+	0.640625f,
+	0.914063f,
+	0.648438f,
+	0.914063f,
+	0.65625f,
+	0.914063f,
+	0.664063f,
+	0.914063f,
+	0.671875f,
+	0.914063f,
+	0.679688f,
+	0.914063f,
+	0.6875f,
+	0.914063f,
+	0.695313f,
+	0.914063f,
+	0.703125f,
+	0.914063f,
+	0.710938f,
+	0.914063f,
+	0.71875f,
+	0.914063f,
+	0.726563f,
+	0.914063f,
+	0.734375f,
+	0.914063f,
+	0.742188f,
+	0.914063f,
+	0.75f,
+	0.914063f,
+	0.757813f,
+	0.914063f,
+	0.765625f,
+	0.914063f,
+	0.773438f,
+	0.914063f,
+	0.78125f,
+	0.914063f,
+	0.789063f,
+	0.914063f,
+	0.796875f,
+	0.914063f,
+	0.804688f,
+	0.914063f,
+	0.8125f,
+	0.914063f,
+	0.820313f,
+	0.914063f,
+	0.828125f,
+	0.914063f,
+	0.835938f,
+	0.914063f,
+	0.84375f,
+	0.914063f,
+	0.851563f,
+	0.914063f,
+	0.859375f,
+	0.914063f,
+	0.867188f,
+	0.914063f,
+	0.875f,
+	0.914063f,
+	0.882813f,
+	0.914063f,
+	0.890625f,
+	0.914063f,
+	0.898438f,
+	0.914063f,
+	0.90625f,
+	0.914063f,
+	0.914063f,
+	0.914063f,
+	0.921875f,
+	0.914063f,
+	0.929688f,
+	0.914063f,
+	0.9375f,
+	0.914063f,
+	0.945313f,
+	0.914063f,
+	0.953125f,
+	0.914063f,
+	0.960938f,
+	0.914063f,
+	0.96875f,
+	0.914063f,
+	0.976563f,
+	0.914063f,
+	0.984375f,
+	0.914063f,
+	0.992188f,
+	0.914063f,
+	1.0f,
+	0.914063f,
+	0.507813f,
+	0.921875f,
+	0.515625f,
+	0.921875f,
+	0.523438f,
+	0.921875f,
+	0.53125f,
+	0.921875f,
+	0.539063f,
+	0.921875f,
+	0.546875f,
+	0.921875f,
+	0.554688f,
+	0.921875f,
+	0.5625f,
+	0.921875f,
+	0.570313f,
+	0.921875f,
+	0.578125f,
+	0.921875f,
+	0.585938f,
+	0.921875f,
+	0.59375f,
+	0.921875f,
+	0.601563f,
+	0.921875f,
+	0.609375f,
+	0.921875f,
+	0.617188f,
+	0.921875f,
+	0.625f,
+	0.921875f,
+	0.632813f,
+	0.921875f,
+	0.640625f,
+	0.921875f,
+	0.648438f,
+	0.921875f,
+	0.65625f,
+	0.921875f,
+	0.664063f,
+	0.921875f,
+	0.671875f,
+	0.921875f,
+	0.679688f,
+	0.921875f,
+	0.6875f,
+	0.921875f,
+	0.695313f,
+	0.921875f,
+	0.703125f,
+	0.921875f,
+	0.710938f,
+	0.921875f,
+	0.71875f,
+	0.921875f,
+	0.726563f,
+	0.921875f,
+	0.734375f,
+	0.921875f,
+	0.742188f,
+	0.921875f,
+	0.75f,
+	0.921875f,
+	0.757813f,
+	0.921875f,
+	0.765625f,
+	0.921875f,
+	0.773438f,
+	0.921875f,
+	0.78125f,
+	0.921875f,
+	0.789063f,
+	0.921875f,
+	0.796875f,
+	0.921875f,
+	0.804688f,
+	0.921875f,
+	0.8125f,
+	0.921875f,
+	0.820313f,
+	0.921875f,
+	0.828125f,
+	0.921875f,
+	0.835938f,
+	0.921875f,
+	0.84375f,
+	0.921875f,
+	0.851563f,
+	0.921875f,
+	0.859375f,
+	0.921875f,
+	0.867188f,
+	0.921875f,
+	0.875f,
+	0.921875f,
+	0.882813f,
+	0.921875f,
+	0.890625f,
+	0.921875f,
+	0.898438f,
+	0.921875f,
+	0.90625f,
+	0.921875f,
+	0.914063f,
+	0.921875f,
+	0.921875f,
+	0.921875f,
+	0.929688f,
+	0.921875f,
+	0.9375f,
+	0.921875f,
+	0.945313f,
+	0.921875f,
+	0.953125f,
+	0.921875f,
+	0.960938f,
+	0.921875f,
+	0.96875f,
+	0.921875f,
+	0.976563f,
+	0.921875f,
+	0.984375f,
+	0.921875f,
+	0.992188f,
+	0.921875f,
+	1.0f,
+	0.921875f,
+	0.507813f,
+	0.929688f,
+	0.515625f,
+	0.929688f,
+	0.523438f,
+	0.929688f,
+	0.53125f,
+	0.929688f,
+	0.539063f,
+	0.929688f,
+	0.546875f,
+	0.929688f,
+	0.554688f,
+	0.929688f,
+	0.5625f,
+	0.929688f,
+	0.570313f,
+	0.929688f,
+	0.578125f,
+	0.929688f,
+	0.585938f,
+	0.929688f,
+	0.59375f,
+	0.929688f,
+	0.601563f,
+	0.929688f,
+	0.609375f,
+	0.929688f,
+	0.617188f,
+	0.929688f,
+	0.625f,
+	0.929688f,
+	0.632813f,
+	0.929688f,
+	0.640625f,
+	0.929688f,
+	0.648438f,
+	0.929688f,
+	0.65625f,
+	0.929688f,
+	0.664063f,
+	0.929688f,
+	0.671875f,
+	0.929688f,
+	0.679688f,
+	0.929688f,
+	0.6875f,
+	0.929688f,
+	0.695313f,
+	0.929688f,
+	0.703125f,
+	0.929688f,
+	0.710938f,
+	0.929688f,
+	0.71875f,
+	0.929688f,
+	0.726563f,
+	0.929688f,
+	0.734375f,
+	0.929688f,
+	0.742188f,
+	0.929688f,
+	0.75f,
+	0.929688f,
+	0.757813f,
+	0.929688f,
+	0.765625f,
+	0.929688f,
+	0.773438f,
+	0.929688f,
+	0.78125f,
+	0.929688f,
+	0.789063f,
+	0.929688f,
+	0.796875f,
+	0.929688f,
+	0.804688f,
+	0.929688f,
+	0.8125f,
+	0.929688f,
+	0.820313f,
+	0.929688f,
+	0.828125f,
+	0.929688f,
+	0.835938f,
+	0.929688f,
+	0.84375f,
+	0.929688f,
+	0.851563f,
+	0.929688f,
+	0.859375f,
+	0.929688f,
+	0.867188f,
+	0.929688f,
+	0.875f,
+	0.929688f,
+	0.882813f,
+	0.929688f,
+	0.890625f,
+	0.929688f,
+	0.898438f,
+	0.929688f,
+	0.90625f,
+	0.929688f,
+	0.914063f,
+	0.929688f,
+	0.921875f,
+	0.929688f,
+	0.929688f,
+	0.929688f,
+	0.9375f,
+	0.929688f,
+	0.945313f,
+	0.929688f,
+	0.953125f,
+	0.929688f,
+	0.960938f,
+	0.929688f,
+	0.96875f,
+	0.929688f,
+	0.976563f,
+	0.929688f,
+	0.984375f,
+	0.929688f,
+	0.992188f,
+	0.929688f,
+	1.0f,
+	0.929688f,
+	0.507813f,
+	0.9375f,
+	0.515625f,
+	0.9375f,
+	0.523438f,
+	0.9375f,
+	0.53125f,
+	0.9375f,
+	0.539063f,
+	0.9375f,
+	0.546875f,
+	0.9375f,
+	0.554688f,
+	0.9375f,
+	0.5625f,
+	0.9375f,
+	0.570313f,
+	0.9375f,
+	0.578125f,
+	0.9375f,
+	0.585938f,
+	0.9375f,
+	0.59375f,
+	0.9375f,
+	0.601563f,
+	0.9375f,
+	0.609375f,
+	0.9375f,
+	0.617188f,
+	0.9375f,
+	0.625f,
+	0.9375f,
+	0.632813f,
+	0.9375f,
+	0.640625f,
+	0.9375f,
+	0.648438f,
+	0.9375f,
+	0.65625f,
+	0.9375f,
+	0.664063f,
+	0.9375f,
+	0.671875f,
+	0.9375f,
+	0.679688f,
+	0.9375f,
+	0.6875f,
+	0.9375f,
+	0.695313f,
+	0.9375f,
+	0.703125f,
+	0.9375f,
+	0.710938f,
+	0.9375f,
+	0.71875f,
+	0.9375f,
+	0.726563f,
+	0.9375f,
+	0.734375f,
+	0.9375f,
+	0.742188f,
+	0.9375f,
+	0.75f,
+	0.9375f,
+	0.757813f,
+	0.9375f,
+	0.765625f,
+	0.9375f,
+	0.773438f,
+	0.9375f,
+	0.78125f,
+	0.9375f,
+	0.789063f,
+	0.9375f,
+	0.796875f,
+	0.9375f,
+	0.804688f,
+	0.9375f,
+	0.8125f,
+	0.9375f,
+	0.820313f,
+	0.9375f,
+	0.828125f,
+	0.9375f,
+	0.835938f,
+	0.9375f,
+	0.84375f,
+	0.9375f,
+	0.851563f,
+	0.9375f,
+	0.859375f,
+	0.9375f,
+	0.867188f,
+	0.9375f,
+	0.875f,
+	0.9375f,
+	0.882813f,
+	0.9375f,
+	0.890625f,
+	0.9375f,
+	0.898438f,
+	0.9375f,
+	0.90625f,
+	0.9375f,
+	0.914063f,
+	0.9375f,
+	0.921875f,
+	0.9375f,
+	0.929688f,
+	0.9375f,
+	0.9375f,
+	0.9375f,
+	0.945313f,
+	0.9375f,
+	0.953125f,
+	0.9375f,
+	0.960938f,
+	0.9375f,
+	0.96875f,
+	0.9375f,
+	0.976563f,
+	0.9375f,
+	0.984375f,
+	0.9375f,
+	0.992188f,
+	0.9375f,
+	1.0f,
+	0.9375f,
+	0.507813f,
+	0.945313f,
+	0.515625f,
+	0.945313f,
+	0.523438f,
+	0.945313f,
+	0.53125f,
+	0.945313f,
+	0.539063f,
+	0.945313f,
+	0.546875f,
+	0.945313f,
+	0.554688f,
+	0.945313f,
+	0.5625f,
+	0.945313f,
+	0.570313f,
+	0.945313f,
+	0.578125f,
+	0.945313f,
+	0.585938f,
+	0.945313f,
+	0.59375f,
+	0.945313f,
+	0.601563f,
+	0.945313f,
+	0.609375f,
+	0.945313f,
+	0.617188f,
+	0.945313f,
+	0.625f,
+	0.945313f,
+	0.632813f,
+	0.945313f,
+	0.640625f,
+	0.945313f,
+	0.648438f,
+	0.945313f,
+	0.65625f,
+	0.945313f,
+	0.664063f,
+	0.945313f,
+	0.671875f,
+	0.945313f,
+	0.679688f,
+	0.945313f,
+	0.6875f,
+	0.945313f,
+	0.695313f,
+	0.945313f,
+	0.703125f,
+	0.945313f,
+	0.710938f,
+	0.945313f,
+	0.71875f,
+	0.945313f,
+	0.726563f,
+	0.945313f,
+	0.734375f,
+	0.945313f,
+	0.742188f,
+	0.945313f,
+	0.75f,
+	0.945313f,
+	0.757813f,
+	0.945313f,
+	0.765625f,
+	0.945313f,
+	0.773438f,
+	0.945313f,
+	0.78125f,
+	0.945313f,
+	0.789063f,
+	0.945313f,
+	0.796875f,
+	0.945313f,
+	0.804688f,
+	0.945313f,
+	0.8125f,
+	0.945313f,
+	0.820313f,
+	0.945313f,
+	0.828125f,
+	0.945313f,
+	0.835938f,
+	0.945313f,
+	0.84375f,
+	0.945313f,
+	0.851563f,
+	0.945313f,
+	0.859375f,
+	0.945313f,
+	0.867188f,
+	0.945313f,
+	0.875f,
+	0.945313f,
+	0.882813f,
+	0.945313f,
+	0.890625f,
+	0.945313f,
+	0.898438f,
+	0.945313f,
+	0.90625f,
+	0.945313f,
+	0.914063f,
+	0.945313f,
+	0.921875f,
+	0.945313f,
+	0.929688f,
+	0.945313f,
+	0.9375f,
+	0.945313f,
+	0.945313f,
+	0.945313f,
+	0.953125f,
+	0.945313f,
+	0.960938f,
+	0.945313f,
+	0.96875f,
+	0.945313f,
+	0.976563f,
+	0.945313f,
+	0.984375f,
+	0.945313f,
+	0.992188f,
+	0.945313f,
+	1.0f,
+	0.945313f,
+	0.507813f,
+	0.953125f,
+	0.515625f,
+	0.953125f,
+	0.523438f,
+	0.953125f,
+	0.53125f,
+	0.953125f,
+	0.539063f,
+	0.953125f,
+	0.546875f,
+	0.953125f,
+	0.554688f,
+	0.953125f,
+	0.5625f,
+	0.953125f,
+	0.570313f,
+	0.953125f,
+	0.578125f,
+	0.953125f,
+	0.585938f,
+	0.953125f,
+	0.59375f,
+	0.953125f,
+	0.601563f,
+	0.953125f,
+	0.609375f,
+	0.953125f,
+	0.617188f,
+	0.953125f,
+	0.625f,
+	0.953125f,
+	0.632813f,
+	0.953125f,
+	0.640625f,
+	0.953125f,
+	0.648438f,
+	0.953125f,
+	0.65625f,
+	0.953125f,
+	0.664063f,
+	0.953125f,
+	0.671875f,
+	0.953125f,
+	0.679688f,
+	0.953125f,
+	0.6875f,
+	0.953125f,
+	0.695313f,
+	0.953125f,
+	0.703125f,
+	0.953125f,
+	0.710938f,
+	0.953125f,
+	0.71875f,
+	0.953125f,
+	0.726563f,
+	0.953125f,
+	0.734375f,
+	0.953125f,
+	0.742188f,
+	0.953125f,
+	0.75f,
+	0.953125f,
+	0.757813f,
+	0.953125f,
+	0.765625f,
+	0.953125f,
+	0.773438f,
+	0.953125f,
+	0.78125f,
+	0.953125f,
+	0.789063f,
+	0.953125f,
+	0.796875f,
+	0.953125f,
+	0.804688f,
+	0.953125f,
+	0.8125f,
+	0.953125f,
+	0.820313f,
+	0.953125f,
+	0.828125f,
+	0.953125f,
+	0.835938f,
+	0.953125f,
+	0.84375f,
+	0.953125f,
+	0.851563f,
+	0.953125f,
+	0.859375f,
+	0.953125f,
+	0.867188f,
+	0.953125f,
+	0.875f,
+	0.953125f,
+	0.882813f,
+	0.953125f,
+	0.890625f,
+	0.953125f,
+	0.898438f,
+	0.953125f,
+	0.90625f,
+	0.953125f,
+	0.914063f,
+	0.953125f,
+	0.921875f,
+	0.953125f,
+	0.929688f,
+	0.953125f,
+	0.9375f,
+	0.953125f,
+	0.945313f,
+	0.953125f,
+	0.953125f,
+	0.953125f,
+	0.960938f,
+	0.953125f,
+	0.96875f,
+	0.953125f,
+	0.976563f,
+	0.953125f,
+	0.984375f,
+	0.953125f,
+	0.992188f,
+	0.953125f,
+	1.0f,
+	0.953125f,
+	0.507813f,
+	0.960938f,
+	0.515625f,
+	0.960938f,
+	0.523438f,
+	0.960938f,
+	0.53125f,
+	0.960938f,
+	0.539063f,
+	0.960938f,
+	0.546875f,
+	0.960938f,
+	0.554688f,
+	0.960938f,
+	0.5625f,
+	0.960938f,
+	0.570313f,
+	0.960938f,
+	0.578125f,
+	0.960938f,
+	0.585938f,
+	0.960938f,
+	0.59375f,
+	0.960938f,
+	0.601563f,
+	0.960938f,
+	0.609375f,
+	0.960938f,
+	0.617188f,
+	0.960938f,
+	0.625f,
+	0.960938f,
+	0.632813f,
+	0.960938f,
+	0.640625f,
+	0.960938f,
+	0.648438f,
+	0.960938f,
+	0.65625f,
+	0.960938f,
+	0.664063f,
+	0.960938f,
+	0.671875f,
+	0.960938f,
+	0.679688f,
+	0.960938f,
+	0.6875f,
+	0.960938f,
+	0.695313f,
+	0.960938f,
+	0.703125f,
+	0.960938f,
+	0.710938f,
+	0.960938f,
+	0.71875f,
+	0.960938f,
+	0.726563f,
+	0.960938f,
+	0.734375f,
+	0.960938f,
+	0.742188f,
+	0.960938f,
+	0.75f,
+	0.960938f,
+	0.757813f,
+	0.960938f,
+	0.765625f,
+	0.960938f,
+	0.773438f,
+	0.960938f,
+	0.78125f,
+	0.960938f,
+	0.789063f,
+	0.960938f,
+	0.796875f,
+	0.960938f,
+	0.804688f,
+	0.960938f,
+	0.8125f,
+	0.960938f,
+	0.820313f,
+	0.960938f,
+	0.828125f,
+	0.960938f,
+	0.835938f,
+	0.960938f,
+	0.84375f,
+	0.960938f,
+	0.851563f,
+	0.960938f,
+	0.859375f,
+	0.960938f,
+	0.867188f,
+	0.960938f,
+	0.875f,
+	0.960938f,
+	0.882813f,
+	0.960938f,
+	0.890625f,
+	0.960938f,
+	0.898438f,
+	0.960938f,
+	0.90625f,
+	0.960938f,
+	0.914063f,
+	0.960938f,
+	0.921875f,
+	0.960938f,
+	0.929688f,
+	0.960938f,
+	0.9375f,
+	0.960938f,
+	0.945313f,
+	0.960938f,
+	0.953125f,
+	0.960938f,
+	0.960938f,
+	0.960938f,
+	0.96875f,
+	0.960938f,
+	0.976563f,
+	0.960938f,
+	0.984375f,
+	0.960938f,
+	0.992188f,
+	0.960938f,
+	1.0f,
+	0.960938f,
+	0.507813f,
+	0.96875f,
+	0.515625f,
+	0.96875f,
+	0.523438f,
+	0.96875f,
+	0.53125f,
+	0.96875f,
+	0.539063f,
+	0.96875f,
+	0.546875f,
+	0.96875f,
+	0.554688f,
+	0.96875f,
+	0.5625f,
+	0.96875f,
+	0.570313f,
+	0.96875f,
+	0.578125f,
+	0.96875f,
+	0.585938f,
+	0.96875f,
+	0.59375f,
+	0.96875f,
+	0.601563f,
+	0.96875f,
+	0.609375f,
+	0.96875f,
+	0.617188f,
+	0.96875f,
+	0.625f,
+	0.96875f,
+	0.632813f,
+	0.96875f,
+	0.640625f,
+	0.96875f,
+	0.648438f,
+	0.96875f,
+	0.65625f,
+	0.96875f,
+	0.664063f,
+	0.96875f,
+	0.671875f,
+	0.96875f,
+	0.679688f,
+	0.96875f,
+	0.6875f,
+	0.96875f,
+	0.695313f,
+	0.96875f,
+	0.703125f,
+	0.96875f,
+	0.710938f,
+	0.96875f,
+	0.71875f,
+	0.96875f,
+	0.726563f,
+	0.96875f,
+	0.734375f,
+	0.96875f,
+	0.742188f,
+	0.96875f,
+	0.75f,
+	0.96875f,
+	0.757813f,
+	0.96875f,
+	0.765625f,
+	0.96875f,
+	0.773438f,
+	0.96875f,
+	0.78125f,
+	0.96875f,
+	0.789063f,
+	0.96875f,
+	0.796875f,
+	0.96875f,
+	0.804688f,
+	0.96875f,
+	0.8125f,
+	0.96875f,
+	0.820313f,
+	0.96875f,
+	0.828125f,
+	0.96875f,
+	0.835938f,
+	0.96875f,
+	0.84375f,
+	0.96875f,
+	0.851563f,
+	0.96875f,
+	0.859375f,
+	0.96875f,
+	0.867188f,
+	0.96875f,
+	0.875f,
+	0.96875f,
+	0.882813f,
+	0.96875f,
+	0.890625f,
+	0.96875f,
+	0.898438f,
+	0.96875f,
+	0.90625f,
+	0.96875f,
+	0.914063f,
+	0.96875f,
+	0.921875f,
+	0.96875f,
+	0.929688f,
+	0.96875f,
+	0.9375f,
+	0.96875f,
+	0.945313f,
+	0.96875f,
+	0.953125f,
+	0.96875f,
+	0.960938f,
+	0.96875f,
+	0.96875f,
+	0.96875f,
+	0.976563f,
+	0.96875f,
+	0.984375f,
+	0.96875f,
+	0.992188f,
+	0.96875f,
+	1.0f,
+	0.96875f,
+	0.507813f,
+	0.976563f,
+	0.515625f,
+	0.976563f,
+	0.523438f,
+	0.976563f,
+	0.53125f,
+	0.976563f,
+	0.539063f,
+	0.976563f,
+	0.546875f,
+	0.976563f,
+	0.554688f,
+	0.976563f,
+	0.5625f,
+	0.976563f,
+	0.570313f,
+	0.976563f,
+	0.578125f,
+	0.976563f,
+	0.585938f,
+	0.976563f,
+	0.59375f,
+	0.976563f,
+	0.601563f,
+	0.976563f,
+	0.609375f,
+	0.976563f,
+	0.617188f,
+	0.976563f,
+	0.625f,
+	0.976563f,
+	0.632813f,
+	0.976563f,
+	0.640625f,
+	0.976563f,
+	0.648438f,
+	0.976563f,
+	0.65625f,
+	0.976563f,
+	0.664063f,
+	0.976563f,
+	0.671875f,
+	0.976563f,
+	0.679688f,
+	0.976563f,
+	0.6875f,
+	0.976563f,
+	0.695313f,
+	0.976563f,
+	0.703125f,
+	0.976563f,
+	0.710938f,
+	0.976563f,
+	0.71875f,
+	0.976563f,
+	0.726563f,
+	0.976563f,
+	0.734375f,
+	0.976563f,
+	0.742188f,
+	0.976563f,
+	0.75f,
+	0.976563f,
+	0.757813f,
+	0.976563f,
+	0.765625f,
+	0.976563f,
+	0.773438f,
+	0.976563f,
+	0.78125f,
+	0.976563f,
+	0.789063f,
+	0.976563f,
+	0.796875f,
+	0.976563f,
+	0.804688f,
+	0.976563f,
+	0.8125f,
+	0.976563f,
+	0.820313f,
+	0.976563f,
+	0.828125f,
+	0.976563f,
+	0.835938f,
+	0.976563f,
+	0.84375f,
+	0.976563f,
+	0.851563f,
+	0.976563f,
+	0.859375f,
+	0.976563f,
+	0.867188f,
+	0.976563f,
+	0.875f,
+	0.976563f,
+	0.882813f,
+	0.976563f,
+	0.890625f,
+	0.976563f,
+	0.898438f,
+	0.976563f,
+	0.90625f,
+	0.976563f,
+	0.914063f,
+	0.976563f,
+	0.921875f,
+	0.976563f,
+	0.929688f,
+	0.976563f,
+	0.9375f,
+	0.976563f,
+	0.945313f,
+	0.976563f,
+	0.953125f,
+	0.976563f,
+	0.960938f,
+	0.976563f,
+	0.96875f,
+	0.976563f,
+	0.976563f,
+	0.976563f,
+	0.984375f,
+	0.976563f,
+	0.992188f,
+	0.976563f,
+	1.0f,
+	0.976563f,
+	0.507813f,
+	0.984375f,
+	0.515625f,
+	0.984375f,
+	0.523438f,
+	0.984375f,
+	0.53125f,
+	0.984375f,
+	0.539063f,
+	0.984375f,
+	0.546875f,
+	0.984375f,
+	0.554688f,
+	0.984375f,
+	0.5625f,
+	0.984375f,
+	0.570313f,
+	0.984375f,
+	0.578125f,
+	0.984375f,
+	0.585938f,
+	0.984375f,
+	0.59375f,
+	0.984375f,
+	0.601563f,
+	0.984375f,
+	0.609375f,
+	0.984375f,
+	0.617188f,
+	0.984375f,
+	0.625f,
+	0.984375f,
+	0.632813f,
+	0.984375f,
+	0.640625f,
+	0.984375f,
+	0.648438f,
+	0.984375f,
+	0.65625f,
+	0.984375f,
+	0.664063f,
+	0.984375f,
+	0.671875f,
+	0.984375f,
+	0.679688f,
+	0.984375f,
+	0.6875f,
+	0.984375f,
+	0.695313f,
+	0.984375f,
+	0.703125f,
+	0.984375f,
+	0.710938f,
+	0.984375f,
+	0.71875f,
+	0.984375f,
+	0.726563f,
+	0.984375f,
+	0.734375f,
+	0.984375f,
+	0.742188f,
+	0.984375f,
+	0.75f,
+	0.984375f,
+	0.757813f,
+	0.984375f,
+	0.765625f,
+	0.984375f,
+	0.773438f,
+	0.984375f,
+	0.78125f,
+	0.984375f,
+	0.789063f,
+	0.984375f,
+	0.796875f,
+	0.984375f,
+	0.804688f,
+	0.984375f,
+	0.8125f,
+	0.984375f,
+	0.820313f,
+	0.984375f,
+	0.828125f,
+	0.984375f,
+	0.835938f,
+	0.984375f,
+	0.84375f,
+	0.984375f,
+	0.851563f,
+	0.984375f,
+	0.859375f,
+	0.984375f,
+	0.867188f,
+	0.984375f,
+	0.875f,
+	0.984375f,
+	0.882813f,
+	0.984375f,
+	0.890625f,
+	0.984375f,
+	0.898438f,
+	0.984375f,
+	0.90625f,
+	0.984375f,
+	0.914063f,
+	0.984375f,
+	0.921875f,
+	0.984375f,
+	0.929688f,
+	0.984375f,
+	0.9375f,
+	0.984375f,
+	0.945313f,
+	0.984375f,
+	0.953125f,
+	0.984375f,
+	0.960938f,
+	0.984375f,
+	0.96875f,
+	0.984375f,
+	0.976563f,
+	0.984375f,
+	0.984375f,
+	0.984375f,
+	0.992188f,
+	0.984375f,
+	1.0f,
+	0.984375f,
+	0.507813f,
+	0.992188f,
+	0.515625f,
+	0.992188f,
+	0.523438f,
+	0.992188f,
+	0.53125f,
+	0.992188f,
+	0.539063f,
+	0.992188f,
+	0.546875f,
+	0.992188f,
+	0.554688f,
+	0.992188f,
+	0.5625f,
+	0.992188f,
+	0.570313f,
+	0.992188f,
+	0.578125f,
+	0.992188f,
+	0.585938f,
+	0.992188f,
+	0.59375f,
+	0.992188f,
+	0.601563f,
+	0.992188f,
+	0.609375f,
+	0.992188f,
+	0.617188f,
+	0.992188f,
+	0.625f,
+	0.992188f,
+	0.632813f,
+	0.992188f,
+	0.640625f,
+	0.992188f,
+	0.648438f,
+	0.992188f,
+	0.65625f,
+	0.992188f,
+	0.664063f,
+	0.992188f,
+	0.671875f,
+	0.992188f,
+	0.679688f,
+	0.992188f,
+	0.6875f,
+	0.992188f,
+	0.695313f,
+	0.992188f,
+	0.703125f,
+	0.992188f,
+	0.710938f,
+	0.992188f,
+	0.71875f,
+	0.992188f,
+	0.726563f,
+	0.992188f,
+	0.734375f,
+	0.992188f,
+	0.742188f,
+	0.992188f,
+	0.75f,
+	0.992188f,
+	0.757813f,
+	0.992188f,
+	0.765625f,
+	0.992188f,
+	0.773438f,
+	0.992188f,
+	0.78125f,
+	0.992188f,
+	0.789063f,
+	0.992188f,
+	0.796875f,
+	0.992188f,
+	0.804688f,
+	0.992188f,
+	0.8125f,
+	0.992188f,
+	0.820313f,
+	0.992188f,
+	0.828125f,
+	0.992188f,
+	0.835938f,
+	0.992188f,
+	0.84375f,
+	0.992188f,
+	0.851563f,
+	0.992188f,
+	0.859375f,
+	0.992188f,
+	0.867188f,
+	0.992188f,
+	0.875f,
+	0.992188f,
+	0.882813f,
+	0.992188f,
+	0.890625f,
+	0.992188f,
+	0.898438f,
+	0.992188f,
+	0.90625f,
+	0.992188f,
+	0.914063f,
+	0.992188f,
+	0.921875f,
+	0.992188f,
+	0.929688f,
+	0.992188f,
+	0.9375f,
+	0.992188f,
+	0.945313f,
+	0.992188f,
+	0.953125f,
+	0.992188f,
+	0.960938f,
+	0.992188f,
+	0.96875f,
+	0.992188f,
+	0.976563f,
+	0.992188f,
+	0.984375f,
+	0.992188f,
+	0.992188f,
+	0.992188f,
+	1.0f,
+	0.992188f,
+	0.507813f,
+	1.0f,
+	0.515625f,
+	1.0f,
+	0.523438f,
+	1.0f,
+	0.53125f,
+	1.0f,
+	0.539063f,
+	1.0f,
+	0.546875f,
+	1.0f,
+	0.554688f,
+	1.0f,
+	0.5625f,
+	1.0f,
+	0.570313f,
+	1.0f,
+	0.578125f,
+	1.0f,
+	0.585938f,
+	1.0f,
+	0.59375f,
+	1.0f,
+	0.601563f,
+	1.0f,
+	0.609375f,
+	1.0f,
+	0.617188f,
+	1.0f,
+	0.625f,
+	1.0f,
+	0.632813f,
+	1.0f,
+	0.640625f,
+	1.0f,
+	0.648438f,
+	1.0f,
+	0.65625f,
+	1.0f,
+	0.664063f,
+	1.0f,
+	0.671875f,
+	1.0f,
+	0.679688f,
+	1.0f,
+	0.6875f,
+	1.0f,
+	0.695313f,
+	1.0f,
+	0.703125f,
+	1.0f,
+	0.710938f,
+	1.0f,
+	0.71875f,
+	1.0f,
+	0.726563f,
+	1.0f,
+	0.734375f,
+	1.0f,
+	0.742188f,
+	1.0f,
+	0.75f,
+	1.0f,
+	0.757813f,
+	1.0f,
+	0.765625f,
+	1.0f,
+	0.773438f,
+	1.0f,
+	0.78125f,
+	1.0f,
+	0.789063f,
+	1.0f,
+	0.796875f,
+	1.0f,
+	0.804688f,
+	1.0f,
+	0.8125f,
+	1.0f,
+	0.820313f,
+	1.0f,
+	0.828125f,
+	1.0f,
+	0.835938f,
+	1.0f,
+	0.84375f,
+	1.0f,
+	0.851563f,
+	1.0f,
+	0.859375f,
+	1.0f,
+	0.867188f,
+	1.0f,
+	0.875f,
+	1.0f,
+	0.882813f,
+	1.0f,
+	0.890625f,
+	1.0f,
+	0.898438f,
+	1.0f,
+	0.90625f,
+	1.0f,
+	0.914063f,
+	1.0f,
+	0.921875f,
+	1.0f,
+	0.929688f,
+	1.0f,
+	0.9375f,
+	1.0f,
+	0.945313f,
+	1.0f,
+	0.953125f,
+	1.0f,
+	0.960938f,
+	1.0f,
+	0.96875f,
+	1.0f,
+	0.976563f,
+	1.0f,
+	0.984375f,
+	1.0f,
+	0.992188f,
+	1.0f,
+	1.0f,
+	1.0f,
+};
+
+unsigned short Landscape07Idx[] = {
+	0,
+	1,
+	2,
+	3,
+	2,
+	1,
+	2,
+	3,
+	4,
+	5,
+	4,
+	3,
+	4,
+	5,
+	6,
+	7,
+	6,
+	5,
+	6,
+	7,
+	8,
+	9,
+	8,
+	7,
+	8,
+	9,
+	10,
+	11,
+	10,
+	9,
+	10,
+	11,
+	12,
+	13,
+	12,
+	11,
+	12,
+	13,
+	14,
+	15,
+	14,
+	13,
+	14,
+	15,
+	16,
+	17,
+	16,
+	15,
+	16,
+	17,
+	18,
+	19,
+	18,
+	17,
+	18,
+	19,
+	20,
+	21,
+	20,
+	19,
+	20,
+	21,
+	22,
+	23,
+	22,
+	21,
+	22,
+	23,
+	24,
+	25,
+	24,
+	23,
+	24,
+	25,
+	26,
+	27,
+	26,
+	25,
+	26,
+	27,
+	28,
+	29,
+	28,
+	27,
+	28,
+	29,
+	30,
+	31,
+	30,
+	29,
+	30,
+	31,
+	32,
+	33,
+	32,
+	31,
+	32,
+	33,
+	34,
+	35,
+	34,
+	33,
+	34,
+	35,
+	36,
+	37,
+	36,
+	35,
+	36,
+	37,
+	38,
+	39,
+	38,
+	37,
+	38,
+	39,
+	40,
+	41,
+	40,
+	39,
+	40,
+	41,
+	42,
+	43,
+	42,
+	41,
+	42,
+	43,
+	44,
+	45,
+	44,
+	43,
+	44,
+	45,
+	46,
+	47,
+	46,
+	45,
+	46,
+	47,
+	48,
+	49,
+	48,
+	47,
+	48,
+	49,
+	50,
+	51,
+	50,
+	49,
+	50,
+	51,
+	52,
+	53,
+	52,
+	51,
+	52,
+	53,
+	54,
+	55,
+	54,
+	53,
+	54,
+	55,
+	56,
+	57,
+	56,
+	55,
+	56,
+	57,
+	58,
+	59,
+	58,
+	57,
+	58,
+	59,
+	60,
+	61,
+	60,
+	59,
+	60,
+	61,
+	62,
+	63,
+	62,
+	61,
+	62,
+	63,
+	64,
+	65,
+	64,
+	63,
+	64,
+	65,
+	66,
+	67,
+	66,
+	65,
+	66,
+	67,
+	68,
+	69,
+	68,
+	67,
+	68,
+	69,
+	70,
+	71,
+	70,
+	69,
+	70,
+	71,
+	72,
+	73,
+	72,
+	71,
+	72,
+	73,
+	74,
+	75,
+	74,
+	73,
+	74,
+	75,
+	76,
+	77,
+	76,
+	75,
+	76,
+	77,
+	78,
+	79,
+	78,
+	77,
+	78,
+	79,
+	80,
+	81,
+	80,
+	79,
+	80,
+	81,
+	82,
+	83,
+	82,
+	81,
+	82,
+	83,
+	84,
+	85,
+	84,
+	83,
+	84,
+	85,
+	86,
+	87,
+	86,
+	85,
+	86,
+	87,
+	88,
+	89,
+	88,
+	87,
+	88,
+	89,
+	90,
+	91,
+	90,
+	89,
+	90,
+	91,
+	92,
+	93,
+	92,
+	91,
+	92,
+	93,
+	94,
+	95,
+	94,
+	93,
+	94,
+	95,
+	96,
+	97,
+	96,
+	95,
+	96,
+	97,
+	98,
+	99,
+	98,
+	97,
+	98,
+	99,
+	100,
+	101,
+	100,
+	99,
+	100,
+	101,
+	102,
+	103,
+	102,
+	101,
+	102,
+	103,
+	104,
+	105,
+	104,
+	103,
+	104,
+	105,
+	106,
+	107,
+	106,
+	105,
+	106,
+	107,
+	108,
+	109,
+	108,
+	107,
+	108,
+	109,
+	110,
+	111,
+	110,
+	109,
+	110,
+	111,
+	112,
+	113,
+	112,
+	111,
+	112,
+	113,
+	114,
+	115,
+	114,
+	113,
+	114,
+	115,
+	116,
+	117,
+	116,
+	115,
+	116,
+	117,
+	118,
+	119,
+	118,
+	117,
+	118,
+	119,
+	120,
+	121,
+	120,
+	119,
+	120,
+	121,
+	122,
+	123,
+	122,
+	121,
+	122,
+	123,
+	124,
+	125,
+	124,
+	123,
+	124,
+	125,
+	126,
+	127,
+	126,
+	125,
+	128,
+	0,
+	129,
+	2,
+	129,
+	0,
+	129,
+	2,
+	130,
+	4,
+	130,
+	2,
+	130,
+	4,
+	131,
+	6,
+	131,
+	4,
+	131,
+	6,
+	132,
+	8,
+	132,
+	6,
+	132,
+	8,
+	133,
+	10,
+	133,
+	8,
+	133,
+	10,
+	134,
+	12,
+	134,
+	10,
+	134,
+	12,
+	135,
+	14,
+	135,
+	12,
+	135,
+	14,
+	136,
+	16,
+	136,
+	14,
+	136,
+	16,
+	137,
+	18,
+	137,
+	16,
+	137,
+	18,
+	138,
+	20,
+	138,
+	18,
+	138,
+	20,
+	139,
+	22,
+	139,
+	20,
+	139,
+	22,
+	140,
+	24,
+	140,
+	22,
+	140,
+	24,
+	141,
+	26,
+	141,
+	24,
+	141,
+	26,
+	142,
+	28,
+	142,
+	26,
+	142,
+	28,
+	143,
+	30,
+	143,
+	28,
+	143,
+	30,
+	144,
+	32,
+	144,
+	30,
+	144,
+	32,
+	145,
+	34,
+	145,
+	32,
+	145,
+	34,
+	146,
+	36,
+	146,
+	34,
+	146,
+	36,
+	147,
+	38,
+	147,
+	36,
+	147,
+	38,
+	148,
+	40,
+	148,
+	38,
+	148,
+	40,
+	149,
+	42,
+	149,
+	40,
+	149,
+	42,
+	150,
+	44,
+	150,
+	42,
+	150,
+	44,
+	151,
+	46,
+	151,
+	44,
+	151,
+	46,
+	152,
+	48,
+	152,
+	46,
+	152,
+	48,
+	153,
+	50,
+	153,
+	48,
+	153,
+	50,
+	154,
+	52,
+	154,
+	50,
+	154,
+	52,
+	155,
+	54,
+	155,
+	52,
+	155,
+	54,
+	156,
+	56,
+	156,
+	54,
+	156,
+	56,
+	157,
+	58,
+	157,
+	56,
+	157,
+	58,
+	158,
+	60,
+	158,
+	58,
+	158,
+	60,
+	159,
+	62,
+	159,
+	60,
+	159,
+	62,
+	160,
+	64,
+	160,
+	62,
+	160,
+	64,
+	161,
+	66,
+	161,
+	64,
+	161,
+	66,
+	162,
+	68,
+	162,
+	66,
+	162,
+	68,
+	163,
+	70,
+	163,
+	68,
+	163,
+	70,
+	164,
+	72,
+	164,
+	70,
+	164,
+	72,
+	165,
+	74,
+	165,
+	72,
+	165,
+	74,
+	166,
+	76,
+	166,
+	74,
+	166,
+	76,
+	167,
+	78,
+	167,
+	76,
+	167,
+	78,
+	168,
+	80,
+	168,
+	78,
+	168,
+	80,
+	169,
+	82,
+	169,
+	80,
+	169,
+	82,
+	170,
+	84,
+	170,
+	82,
+	170,
+	84,
+	171,
+	86,
+	171,
+	84,
+	171,
+	86,
+	172,
+	88,
+	172,
+	86,
+	172,
+	88,
+	173,
+	90,
+	173,
+	88,
+	173,
+	90,
+	174,
+	92,
+	174,
+	90,
+	174,
+	92,
+	175,
+	94,
+	175,
+	92,
+	175,
+	94,
+	176,
+	96,
+	176,
+	94,
+	176,
+	96,
+	177,
+	98,
+	177,
+	96,
+	177,
+	98,
+	178,
+	100,
+	178,
+	98,
+	178,
+	100,
+	179,
+	102,
+	179,
+	100,
+	179,
+	102,
+	180,
+	104,
+	180,
+	102,
+	180,
+	104,
+	181,
+	106,
+	181,
+	104,
+	181,
+	106,
+	182,
+	108,
+	182,
+	106,
+	182,
+	108,
+	183,
+	110,
+	183,
+	108,
+	183,
+	110,
+	184,
+	112,
+	184,
+	110,
+	184,
+	112,
+	185,
+	114,
+	185,
+	112,
+	185,
+	114,
+	186,
+	116,
+	186,
+	114,
+	186,
+	116,
+	187,
+	118,
+	187,
+	116,
+	187,
+	118,
+	188,
+	120,
+	188,
+	118,
+	188,
+	120,
+	189,
+	122,
+	189,
+	120,
+	189,
+	122,
+	190,
+	124,
+	190,
+	122,
+	190,
+	124,
+	191,
+	126,
+	191,
+	124,
+	192,
+	128,
+	193,
+	129,
+	193,
+	128,
+	193,
+	129,
+	194,
+	130,
+	194,
+	129,
+	194,
+	130,
+	195,
+	131,
+	195,
+	130,
+	195,
+	131,
+	196,
+	132,
+	196,
+	131,
+	196,
+	132,
+	197,
+	133,
+	197,
+	132,
+	197,
+	133,
+	198,
+	134,
+	198,
+	133,
+	198,
+	134,
+	199,
+	135,
+	199,
+	134,
+	199,
+	135,
+	200,
+	136,
+	200,
+	135,
+	200,
+	136,
+	201,
+	137,
+	201,
+	136,
+	201,
+	137,
+	202,
+	138,
+	202,
+	137,
+	202,
+	138,
+	203,
+	139,
+	203,
+	138,
+	203,
+	139,
+	204,
+	140,
+	204,
+	139,
+	204,
+	140,
+	205,
+	141,
+	205,
+	140,
+	205,
+	141,
+	206,
+	142,
+	206,
+	141,
+	206,
+	142,
+	207,
+	143,
+	207,
+	142,
+	207,
+	143,
+	208,
+	144,
+	208,
+	143,
+	208,
+	144,
+	209,
+	145,
+	209,
+	144,
+	209,
+	145,
+	210,
+	146,
+	210,
+	145,
+	210,
+	146,
+	211,
+	147,
+	211,
+	146,
+	211,
+	147,
+	212,
+	148,
+	212,
+	147,
+	212,
+	148,
+	213,
+	149,
+	213,
+	148,
+	213,
+	149,
+	214,
+	150,
+	214,
+	149,
+	214,
+	150,
+	215,
+	151,
+	215,
+	150,
+	215,
+	151,
+	216,
+	152,
+	216,
+	151,
+	216,
+	152,
+	217,
+	153,
+	217,
+	152,
+	217,
+	153,
+	218,
+	154,
+	218,
+	153,
+	218,
+	154,
+	219,
+	155,
+	219,
+	154,
+	219,
+	155,
+	220,
+	156,
+	220,
+	155,
+	220,
+	156,
+	221,
+	157,
+	221,
+	156,
+	221,
+	157,
+	222,
+	158,
+	222,
+	157,
+	222,
+	158,
+	223,
+	159,
+	223,
+	158,
+	223,
+	159,
+	224,
+	160,
+	224,
+	159,
+	224,
+	160,
+	225,
+	161,
+	225,
+	160,
+	225,
+	161,
+	226,
+	162,
+	226,
+	161,
+	226,
+	162,
+	227,
+	163,
+	227,
+	162,
+	227,
+	163,
+	228,
+	164,
+	228,
+	163,
+	228,
+	164,
+	229,
+	165,
+	229,
+	164,
+	229,
+	165,
+	230,
+	166,
+	230,
+	165,
+	230,
+	166,
+	231,
+	167,
+	231,
+	166,
+	231,
+	167,
+	232,
+	168,
+	232,
+	167,
+	232,
+	168,
+	233,
+	169,
+	233,
+	168,
+	233,
+	169,
+	234,
+	170,
+	234,
+	169,
+	234,
+	170,
+	235,
+	171,
+	235,
+	170,
+	235,
+	171,
+	236,
+	172,
+	236,
+	171,
+	236,
+	172,
+	237,
+	173,
+	237,
+	172,
+	237,
+	173,
+	238,
+	174,
+	238,
+	173,
+	238,
+	174,
+	239,
+	175,
+	239,
+	174,
+	239,
+	175,
+	240,
+	176,
+	240,
+	175,
+	240,
+	176,
+	241,
+	177,
+	241,
+	176,
+	241,
+	177,
+	242,
+	178,
+	242,
+	177,
+	242,
+	178,
+	243,
+	179,
+	243,
+	178,
+	243,
+	179,
+	244,
+	180,
+	244,
+	179,
+	244,
+	180,
+	245,
+	181,
+	245,
+	180,
+	245,
+	181,
+	246,
+	182,
+	246,
+	181,
+	246,
+	182,
+	247,
+	183,
+	247,
+	182,
+	247,
+	183,
+	248,
+	184,
+	248,
+	183,
+	248,
+	184,
+	249,
+	185,
+	249,
+	184,
+	249,
+	185,
+	250,
+	186,
+	250,
+	185,
+	250,
+	186,
+	251,
+	187,
+	251,
+	186,
+	251,
+	187,
+	252,
+	188,
+	252,
+	187,
+	252,
+	188,
+	253,
+	189,
+	253,
+	188,
+	253,
+	189,
+	254,
+	190,
+	254,
+	189,
+	254,
+	190,
+	255,
+	191,
+	255,
+	190,
+	256,
+	192,
+	257,
+	193,
+	257,
+	192,
+	257,
+	193,
+	258,
+	194,
+	258,
+	193,
+	258,
+	194,
+	259,
+	195,
+	259,
+	194,
+	259,
+	195,
+	260,
+	196,
+	260,
+	195,
+	260,
+	196,
+	261,
+	197,
+	261,
+	196,
+	261,
+	197,
+	262,
+	198,
+	262,
+	197,
+	262,
+	198,
+	263,
+	199,
+	263,
+	198,
+	263,
+	199,
+	264,
+	200,
+	264,
+	199,
+	264,
+	200,
+	265,
+	201,
+	265,
+	200,
+	265,
+	201,
+	266,
+	202,
+	266,
+	201,
+	266,
+	202,
+	267,
+	203,
+	267,
+	202,
+	267,
+	203,
+	268,
+	204,
+	268,
+	203,
+	268,
+	204,
+	269,
+	205,
+	269,
+	204,
+	269,
+	205,
+	270,
+	206,
+	270,
+	205,
+	270,
+	206,
+	271,
+	207,
+	271,
+	206,
+	271,
+	207,
+	272,
+	208,
+	272,
+	207,
+	272,
+	208,
+	273,
+	209,
+	273,
+	208,
+	273,
+	209,
+	274,
+	210,
+	274,
+	209,
+	274,
+	210,
+	275,
+	211,
+	275,
+	210,
+	275,
+	211,
+	276,
+	212,
+	276,
+	211,
+	276,
+	212,
+	277,
+	213,
+	277,
+	212,
+	277,
+	213,
+	278,
+	214,
+	278,
+	213,
+	278,
+	214,
+	279,
+	215,
+	279,
+	214,
+	279,
+	215,
+	280,
+	216,
+	280,
+	215,
+	280,
+	216,
+	281,
+	217,
+	281,
+	216,
+	281,
+	217,
+	282,
+	218,
+	282,
+	217,
+	282,
+	218,
+	283,
+	219,
+	283,
+	218,
+	283,
+	219,
+	284,
+	220,
+	284,
+	219,
+	284,
+	220,
+	285,
+	221,
+	285,
+	220,
+	285,
+	221,
+	286,
+	222,
+	286,
+	221,
+	286,
+	222,
+	287,
+	223,
+	287,
+	222,
+	287,
+	223,
+	288,
+	224,
+	288,
+	223,
+	288,
+	224,
+	289,
+	225,
+	289,
+	224,
+	289,
+	225,
+	290,
+	226,
+	290,
+	225,
+	290,
+	226,
+	291,
+	227,
+	291,
+	226,
+	291,
+	227,
+	292,
+	228,
+	292,
+	227,
+	292,
+	228,
+	293,
+	229,
+	293,
+	228,
+	293,
+	229,
+	294,
+	230,
+	294,
+	229,
+	294,
+	230,
+	295,
+	231,
+	295,
+	230,
+	295,
+	231,
+	296,
+	232,
+	296,
+	231,
+	296,
+	232,
+	297,
+	233,
+	297,
+	232,
+	297,
+	233,
+	298,
+	234,
+	298,
+	233,
+	298,
+	234,
+	299,
+	235,
+	299,
+	234,
+	299,
+	235,
+	300,
+	236,
+	300,
+	235,
+	300,
+	236,
+	301,
+	237,
+	301,
+	236,
+	301,
+	237,
+	302,
+	238,
+	302,
+	237,
+	302,
+	238,
+	303,
+	239,
+	303,
+	238,
+	303,
+	239,
+	304,
+	240,
+	304,
+	239,
+	304,
+	240,
+	305,
+	241,
+	305,
+	240,
+	305,
+	241,
+	306,
+	242,
+	306,
+	241,
+	306,
+	242,
+	307,
+	243,
+	307,
+	242,
+	307,
+	243,
+	308,
+	244,
+	308,
+	243,
+	308,
+	244,
+	309,
+	245,
+	309,
+	244,
+	309,
+	245,
+	310,
+	246,
+	310,
+	245,
+	310,
+	246,
+	311,
+	247,
+	311,
+	246,
+	311,
+	247,
+	312,
+	248,
+	312,
+	247,
+	312,
+	248,
+	313,
+	249,
+	313,
+	248,
+	313,
+	249,
+	314,
+	250,
+	314,
+	249,
+	314,
+	250,
+	315,
+	251,
+	315,
+	250,
+	315,
+	251,
+	316,
+	252,
+	316,
+	251,
+	316,
+	252,
+	317,
+	253,
+	317,
+	252,
+	317,
+	253,
+	318,
+	254,
+	318,
+	253,
+	318,
+	254,
+	319,
+	255,
+	319,
+	254,
+	320,
+	256,
+	321,
+	257,
+	321,
+	256,
+	321,
+	257,
+	322,
+	258,
+	322,
+	257,
+	322,
+	258,
+	323,
+	259,
+	323,
+	258,
+	323,
+	259,
+	324,
+	260,
+	324,
+	259,
+	324,
+	260,
+	325,
+	261,
+	325,
+	260,
+	325,
+	261,
+	326,
+	262,
+	326,
+	261,
+	326,
+	262,
+	327,
+	263,
+	327,
+	262,
+	327,
+	263,
+	328,
+	264,
+	328,
+	263,
+	328,
+	264,
+	329,
+	265,
+	329,
+	264,
+	329,
+	265,
+	330,
+	266,
+	330,
+	265,
+	330,
+	266,
+	331,
+	267,
+	331,
+	266,
+	331,
+	267,
+	332,
+	268,
+	332,
+	267,
+	332,
+	268,
+	333,
+	269,
+	333,
+	268,
+	333,
+	269,
+	334,
+	270,
+	334,
+	269,
+	334,
+	270,
+	335,
+	271,
+	335,
+	270,
+	335,
+	271,
+	336,
+	272,
+	336,
+	271,
+	336,
+	272,
+	337,
+	273,
+	337,
+	272,
+	337,
+	273,
+	338,
+	274,
+	338,
+	273,
+	338,
+	274,
+	339,
+	275,
+	339,
+	274,
+	339,
+	275,
+	340,
+	276,
+	340,
+	275,
+	340,
+	276,
+	341,
+	277,
+	341,
+	276,
+	341,
+	277,
+	342,
+	278,
+	342,
+	277,
+	342,
+	278,
+	343,
+	279,
+	343,
+	278,
+	343,
+	279,
+	344,
+	280,
+	344,
+	279,
+	344,
+	280,
+	345,
+	281,
+	345,
+	280,
+	345,
+	281,
+	346,
+	282,
+	346,
+	281,
+	346,
+	282,
+	347,
+	283,
+	347,
+	282,
+	347,
+	283,
+	348,
+	284,
+	348,
+	283,
+	348,
+	284,
+	349,
+	285,
+	349,
+	284,
+	349,
+	285,
+	350,
+	286,
+	350,
+	285,
+	350,
+	286,
+	351,
+	287,
+	351,
+	286,
+	351,
+	287,
+	352,
+	288,
+	352,
+	287,
+	352,
+	288,
+	353,
+	289,
+	353,
+	288,
+	353,
+	289,
+	354,
+	290,
+	354,
+	289,
+	354,
+	290,
+	355,
+	291,
+	355,
+	290,
+	355,
+	291,
+	356,
+	292,
+	356,
+	291,
+	356,
+	292,
+	357,
+	293,
+	357,
+	292,
+	357,
+	293,
+	358,
+	294,
+	358,
+	293,
+	358,
+	294,
+	359,
+	295,
+	359,
+	294,
+	359,
+	295,
+	360,
+	296,
+	360,
+	295,
+	360,
+	296,
+	361,
+	297,
+	361,
+	296,
+	361,
+	297,
+	362,
+	298,
+	362,
+	297,
+	362,
+	298,
+	363,
+	299,
+	363,
+	298,
+	363,
+	299,
+	364,
+	300,
+	364,
+	299,
+	364,
+	300,
+	365,
+	301,
+	365,
+	300,
+	365,
+	301,
+	366,
+	302,
+	366,
+	301,
+	366,
+	302,
+	367,
+	303,
+	367,
+	302,
+	367,
+	303,
+	368,
+	304,
+	368,
+	303,
+	368,
+	304,
+	369,
+	305,
+	369,
+	304,
+	369,
+	305,
+	370,
+	306,
+	370,
+	305,
+	370,
+	306,
+	371,
+	307,
+	371,
+	306,
+	371,
+	307,
+	372,
+	308,
+	372,
+	307,
+	372,
+	308,
+	373,
+	309,
+	373,
+	308,
+	373,
+	309,
+	374,
+	310,
+	374,
+	309,
+	374,
+	310,
+	375,
+	311,
+	375,
+	310,
+	375,
+	311,
+	376,
+	312,
+	376,
+	311,
+	376,
+	312,
+	377,
+	313,
+	377,
+	312,
+	377,
+	313,
+	378,
+	314,
+	378,
+	313,
+	378,
+	314,
+	379,
+	315,
+	379,
+	314,
+	379,
+	315,
+	380,
+	316,
+	380,
+	315,
+	380,
+	316,
+	381,
+	317,
+	381,
+	316,
+	381,
+	317,
+	382,
+	318,
+	382,
+	317,
+	382,
+	318,
+	383,
+	319,
+	383,
+	318,
+	384,
+	320,
+	385,
+	321,
+	385,
+	320,
+	385,
+	321,
+	386,
+	322,
+	386,
+	321,
+	386,
+	322,
+	387,
+	323,
+	387,
+	322,
+	387,
+	323,
+	388,
+	324,
+	388,
+	323,
+	388,
+	324,
+	389,
+	325,
+	389,
+	324,
+	389,
+	325,
+	390,
+	326,
+	390,
+	325,
+	390,
+	326,
+	391,
+	327,
+	391,
+	326,
+	391,
+	327,
+	392,
+	328,
+	392,
+	327,
+	392,
+	328,
+	393,
+	329,
+	393,
+	328,
+	393,
+	329,
+	394,
+	330,
+	394,
+	329,
+	394,
+	330,
+	395,
+	331,
+	395,
+	330,
+	395,
+	331,
+	396,
+	332,
+	396,
+	331,
+	396,
+	332,
+	397,
+	333,
+	397,
+	332,
+	397,
+	333,
+	398,
+	334,
+	398,
+	333,
+	398,
+	334,
+	399,
+	335,
+	399,
+	334,
+	399,
+	335,
+	400,
+	336,
+	400,
+	335,
+	400,
+	336,
+	401,
+	337,
+	401,
+	336,
+	401,
+	337,
+	402,
+	338,
+	402,
+	337,
+	402,
+	338,
+	403,
+	339,
+	403,
+	338,
+	403,
+	339,
+	404,
+	340,
+	404,
+	339,
+	404,
+	340,
+	405,
+	341,
+	405,
+	340,
+	405,
+	341,
+	406,
+	342,
+	406,
+	341,
+	406,
+	342,
+	407,
+	343,
+	407,
+	342,
+	407,
+	343,
+	408,
+	344,
+	408,
+	343,
+	408,
+	344,
+	409,
+	345,
+	409,
+	344,
+	409,
+	345,
+	410,
+	346,
+	410,
+	345,
+	410,
+	346,
+	411,
+	347,
+	411,
+	346,
+	411,
+	347,
+	412,
+	348,
+	412,
+	347,
+	412,
+	348,
+	413,
+	349,
+	413,
+	348,
+	413,
+	349,
+	414,
+	350,
+	414,
+	349,
+	414,
+	350,
+	415,
+	351,
+	415,
+	350,
+	415,
+	351,
+	416,
+	352,
+	416,
+	351,
+	416,
+	352,
+	417,
+	353,
+	417,
+	352,
+	417,
+	353,
+	418,
+	354,
+	418,
+	353,
+	418,
+	354,
+	419,
+	355,
+	419,
+	354,
+	419,
+	355,
+	420,
+	356,
+	420,
+	355,
+	420,
+	356,
+	421,
+	357,
+	421,
+	356,
+	421,
+	357,
+	422,
+	358,
+	422,
+	357,
+	422,
+	358,
+	423,
+	359,
+	423,
+	358,
+	423,
+	359,
+	424,
+	360,
+	424,
+	359,
+	424,
+	360,
+	425,
+	361,
+	425,
+	360,
+	425,
+	361,
+	426,
+	362,
+	426,
+	361,
+	426,
+	362,
+	427,
+	363,
+	427,
+	362,
+	427,
+	363,
+	428,
+	364,
+	428,
+	363,
+	428,
+	364,
+	429,
+	365,
+	429,
+	364,
+	429,
+	365,
+	430,
+	366,
+	430,
+	365,
+	430,
+	366,
+	431,
+	367,
+	431,
+	366,
+	431,
+	367,
+	432,
+	368,
+	432,
+	367,
+	432,
+	368,
+	433,
+	369,
+	433,
+	368,
+	433,
+	369,
+	434,
+	370,
+	434,
+	369,
+	434,
+	370,
+	435,
+	371,
+	435,
+	370,
+	435,
+	371,
+	436,
+	372,
+	436,
+	371,
+	436,
+	372,
+	437,
+	373,
+	437,
+	372,
+	437,
+	373,
+	438,
+	374,
+	438,
+	373,
+	438,
+	374,
+	439,
+	375,
+	439,
+	374,
+	439,
+	375,
+	440,
+	376,
+	440,
+	375,
+	440,
+	376,
+	441,
+	377,
+	441,
+	376,
+	441,
+	377,
+	442,
+	378,
+	442,
+	377,
+	442,
+	378,
+	443,
+	379,
+	443,
+	378,
+	443,
+	379,
+	444,
+	380,
+	444,
+	379,
+	444,
+	380,
+	445,
+	381,
+	445,
+	380,
+	445,
+	381,
+	446,
+	382,
+	446,
+	381,
+	446,
+	382,
+	447,
+	383,
+	447,
+	382,
+	448,
+	384,
+	449,
+	385,
+	449,
+	384,
+	449,
+	385,
+	450,
+	386,
+	450,
+	385,
+	450,
+	386,
+	451,
+	387,
+	451,
+	386,
+	451,
+	387,
+	452,
+	388,
+	452,
+	387,
+	452,
+	388,
+	453,
+	389,
+	453,
+	388,
+	453,
+	389,
+	454,
+	390,
+	454,
+	389,
+	454,
+	390,
+	455,
+	391,
+	455,
+	390,
+	455,
+	391,
+	456,
+	392,
+	456,
+	391,
+	456,
+	392,
+	457,
+	393,
+	457,
+	392,
+	457,
+	393,
+	458,
+	394,
+	458,
+	393,
+	458,
+	394,
+	459,
+	395,
+	459,
+	394,
+	459,
+	395,
+	460,
+	396,
+	460,
+	395,
+	460,
+	396,
+	461,
+	397,
+	461,
+	396,
+	461,
+	397,
+	462,
+	398,
+	462,
+	397,
+	462,
+	398,
+	463,
+	399,
+	463,
+	398,
+	463,
+	399,
+	464,
+	400,
+	464,
+	399,
+	464,
+	400,
+	465,
+	401,
+	465,
+	400,
+	465,
+	401,
+	466,
+	402,
+	466,
+	401,
+	466,
+	402,
+	467,
+	403,
+	467,
+	402,
+	467,
+	403,
+	468,
+	404,
+	468,
+	403,
+	468,
+	404,
+	469,
+	405,
+	469,
+	404,
+	469,
+	405,
+	470,
+	406,
+	470,
+	405,
+	470,
+	406,
+	471,
+	407,
+	471,
+	406,
+	471,
+	407,
+	472,
+	408,
+	472,
+	407,
+	472,
+	408,
+	473,
+	409,
+	473,
+	408,
+	473,
+	409,
+	474,
+	410,
+	474,
+	409,
+	474,
+	410,
+	475,
+	411,
+	475,
+	410,
+	475,
+	411,
+	476,
+	412,
+	476,
+	411,
+	476,
+	412,
+	477,
+	413,
+	477,
+	412,
+	477,
+	413,
+	478,
+	414,
+	478,
+	413,
+	478,
+	414,
+	479,
+	415,
+	479,
+	414,
+	479,
+	415,
+	480,
+	416,
+	480,
+	415,
+	480,
+	416,
+	481,
+	417,
+	481,
+	416,
+	481,
+	417,
+	482,
+	418,
+	482,
+	417,
+	482,
+	418,
+	483,
+	419,
+	483,
+	418,
+	483,
+	419,
+	484,
+	420,
+	484,
+	419,
+	484,
+	420,
+	485,
+	421,
+	485,
+	420,
+	485,
+	421,
+	486,
+	422,
+	486,
+	421,
+	486,
+	422,
+	487,
+	423,
+	487,
+	422,
+	487,
+	423,
+	488,
+	424,
+	488,
+	423,
+	488,
+	424,
+	489,
+	425,
+	489,
+	424,
+	489,
+	425,
+	490,
+	426,
+	490,
+	425,
+	490,
+	426,
+	491,
+	427,
+	491,
+	426,
+	491,
+	427,
+	492,
+	428,
+	492,
+	427,
+	492,
+	428,
+	493,
+	429,
+	493,
+	428,
+	493,
+	429,
+	494,
+	430,
+	494,
+	429,
+	494,
+	430,
+	495,
+	431,
+	495,
+	430,
+	495,
+	431,
+	496,
+	432,
+	496,
+	431,
+	496,
+	432,
+	497,
+	433,
+	497,
+	432,
+	497,
+	433,
+	498,
+	434,
+	498,
+	433,
+	498,
+	434,
+	499,
+	435,
+	499,
+	434,
+	499,
+	435,
+	500,
+	436,
+	500,
+	435,
+	500,
+	436,
+	501,
+	437,
+	501,
+	436,
+	501,
+	437,
+	502,
+	438,
+	502,
+	437,
+	502,
+	438,
+	503,
+	439,
+	503,
+	438,
+	503,
+	439,
+	504,
+	440,
+	504,
+	439,
+	504,
+	440,
+	505,
+	441,
+	505,
+	440,
+	505,
+	441,
+	506,
+	442,
+	506,
+	441,
+	506,
+	442,
+	507,
+	443,
+	507,
+	442,
+	507,
+	443,
+	508,
+	444,
+	508,
+	443,
+	508,
+	444,
+	509,
+	445,
+	509,
+	444,
+	509,
+	445,
+	510,
+	446,
+	510,
+	445,
+	510,
+	446,
+	511,
+	447,
+	511,
+	446,
+	512,
+	448,
+	513,
+	449,
+	513,
+	448,
+	513,
+	449,
+	514,
+	450,
+	514,
+	449,
+	514,
+	450,
+	515,
+	451,
+	515,
+	450,
+	515,
+	451,
+	516,
+	452,
+	516,
+	451,
+	516,
+	452,
+	517,
+	453,
+	517,
+	452,
+	517,
+	453,
+	518,
+	454,
+	518,
+	453,
+	518,
+	454,
+	519,
+	455,
+	519,
+	454,
+	519,
+	455,
+	520,
+	456,
+	520,
+	455,
+	520,
+	456,
+	521,
+	457,
+	521,
+	456,
+	521,
+	457,
+	522,
+	458,
+	522,
+	457,
+	522,
+	458,
+	523,
+	459,
+	523,
+	458,
+	523,
+	459,
+	524,
+	460,
+	524,
+	459,
+	524,
+	460,
+	525,
+	461,
+	525,
+	460,
+	525,
+	461,
+	526,
+	462,
+	526,
+	461,
+	526,
+	462,
+	527,
+	463,
+	527,
+	462,
+	527,
+	463,
+	528,
+	464,
+	528,
+	463,
+	528,
+	464,
+	529,
+	465,
+	529,
+	464,
+	529,
+	465,
+	530,
+	466,
+	530,
+	465,
+	530,
+	466,
+	531,
+	467,
+	531,
+	466,
+	531,
+	467,
+	532,
+	468,
+	532,
+	467,
+	532,
+	468,
+	533,
+	469,
+	533,
+	468,
+	533,
+	469,
+	534,
+	470,
+	534,
+	469,
+	534,
+	470,
+	535,
+	471,
+	535,
+	470,
+	535,
+	471,
+	536,
+	472,
+	536,
+	471,
+	536,
+	472,
+	537,
+	473,
+	537,
+	472,
+	537,
+	473,
+	538,
+	474,
+	538,
+	473,
+	538,
+	474,
+	539,
+	475,
+	539,
+	474,
+	539,
+	475,
+	540,
+	476,
+	540,
+	475,
+	540,
+	476,
+	541,
+	477,
+	541,
+	476,
+	541,
+	477,
+	542,
+	478,
+	542,
+	477,
+	542,
+	478,
+	543,
+	479,
+	543,
+	478,
+	543,
+	479,
+	544,
+	480,
+	544,
+	479,
+	544,
+	480,
+	545,
+	481,
+	545,
+	480,
+	545,
+	481,
+	546,
+	482,
+	546,
+	481,
+	546,
+	482,
+	547,
+	483,
+	547,
+	482,
+	547,
+	483,
+	548,
+	484,
+	548,
+	483,
+	548,
+	484,
+	549,
+	485,
+	549,
+	484,
+	549,
+	485,
+	550,
+	486,
+	550,
+	485,
+	550,
+	486,
+	551,
+	487,
+	551,
+	486,
+	551,
+	487,
+	552,
+	488,
+	552,
+	487,
+	552,
+	488,
+	553,
+	489,
+	553,
+	488,
+	553,
+	489,
+	554,
+	490,
+	554,
+	489,
+	554,
+	490,
+	555,
+	491,
+	555,
+	490,
+	555,
+	491,
+	556,
+	492,
+	556,
+	491,
+	556,
+	492,
+	557,
+	493,
+	557,
+	492,
+	557,
+	493,
+	558,
+	494,
+	558,
+	493,
+	558,
+	494,
+	559,
+	495,
+	559,
+	494,
+	559,
+	495,
+	560,
+	496,
+	560,
+	495,
+	560,
+	496,
+	561,
+	497,
+	561,
+	496,
+	561,
+	497,
+	562,
+	498,
+	562,
+	497,
+	562,
+	498,
+	563,
+	499,
+	563,
+	498,
+	563,
+	499,
+	564,
+	500,
+	564,
+	499,
+	564,
+	500,
+	565,
+	501,
+	565,
+	500,
+	565,
+	501,
+	566,
+	502,
+	566,
+	501,
+	566,
+	502,
+	567,
+	503,
+	567,
+	502,
+	567,
+	503,
+	568,
+	504,
+	568,
+	503,
+	568,
+	504,
+	569,
+	505,
+	569,
+	504,
+	569,
+	505,
+	570,
+	506,
+	570,
+	505,
+	570,
+	506,
+	571,
+	507,
+	571,
+	506,
+	571,
+	507,
+	572,
+	508,
+	572,
+	507,
+	572,
+	508,
+	573,
+	509,
+	573,
+	508,
+	573,
+	509,
+	574,
+	510,
+	574,
+	509,
+	574,
+	510,
+	575,
+	511,
+	575,
+	510,
+	576,
+	512,
+	577,
+	513,
+	577,
+	512,
+	577,
+	513,
+	578,
+	514,
+	578,
+	513,
+	578,
+	514,
+	579,
+	515,
+	579,
+	514,
+	579,
+	515,
+	580,
+	516,
+	580,
+	515,
+	580,
+	516,
+	581,
+	517,
+	581,
+	516,
+	581,
+	517,
+	582,
+	518,
+	582,
+	517,
+	582,
+	518,
+	583,
+	519,
+	583,
+	518,
+	583,
+	519,
+	584,
+	520,
+	584,
+	519,
+	584,
+	520,
+	585,
+	521,
+	585,
+	520,
+	585,
+	521,
+	586,
+	522,
+	586,
+	521,
+	586,
+	522,
+	587,
+	523,
+	587,
+	522,
+	587,
+	523,
+	588,
+	524,
+	588,
+	523,
+	588,
+	524,
+	589,
+	525,
+	589,
+	524,
+	589,
+	525,
+	590,
+	526,
+	590,
+	525,
+	590,
+	526,
+	591,
+	527,
+	591,
+	526,
+	591,
+	527,
+	592,
+	528,
+	592,
+	527,
+	592,
+	528,
+	593,
+	529,
+	593,
+	528,
+	593,
+	529,
+	594,
+	530,
+	594,
+	529,
+	594,
+	530,
+	595,
+	531,
+	595,
+	530,
+	595,
+	531,
+	596,
+	532,
+	596,
+	531,
+	596,
+	532,
+	597,
+	533,
+	597,
+	532,
+	597,
+	533,
+	598,
+	534,
+	598,
+	533,
+	598,
+	534,
+	599,
+	535,
+	599,
+	534,
+	599,
+	535,
+	600,
+	536,
+	600,
+	535,
+	600,
+	536,
+	601,
+	537,
+	601,
+	536,
+	601,
+	537,
+	602,
+	538,
+	602,
+	537,
+	602,
+	538,
+	603,
+	539,
+	603,
+	538,
+	603,
+	539,
+	604,
+	540,
+	604,
+	539,
+	604,
+	540,
+	605,
+	541,
+	605,
+	540,
+	605,
+	541,
+	606,
+	542,
+	606,
+	541,
+	606,
+	542,
+	607,
+	543,
+	607,
+	542,
+	607,
+	543,
+	608,
+	544,
+	608,
+	543,
+	608,
+	544,
+	609,
+	545,
+	609,
+	544,
+	609,
+	545,
+	610,
+	546,
+	610,
+	545,
+	610,
+	546,
+	611,
+	547,
+	611,
+	546,
+	611,
+	547,
+	612,
+	548,
+	612,
+	547,
+	612,
+	548,
+	613,
+	549,
+	613,
+	548,
+	613,
+	549,
+	614,
+	550,
+	614,
+	549,
+	614,
+	550,
+	615,
+	551,
+	615,
+	550,
+	615,
+	551,
+	616,
+	552,
+	616,
+	551,
+	616,
+	552,
+	617,
+	553,
+	617,
+	552,
+	617,
+	553,
+	618,
+	554,
+	618,
+	553,
+	618,
+	554,
+	619,
+	555,
+	619,
+	554,
+	619,
+	555,
+	620,
+	556,
+	620,
+	555,
+	620,
+	556,
+	621,
+	557,
+	621,
+	556,
+	621,
+	557,
+	622,
+	558,
+	622,
+	557,
+	622,
+	558,
+	623,
+	559,
+	623,
+	558,
+	623,
+	559,
+	624,
+	560,
+	624,
+	559,
+	624,
+	560,
+	625,
+	561,
+	625,
+	560,
+	625,
+	561,
+	626,
+	562,
+	626,
+	561,
+	626,
+	562,
+	627,
+	563,
+	627,
+	562,
+	627,
+	563,
+	628,
+	564,
+	628,
+	563,
+	628,
+	564,
+	629,
+	565,
+	629,
+	564,
+	629,
+	565,
+	630,
+	566,
+	630,
+	565,
+	630,
+	566,
+	631,
+	567,
+	631,
+	566,
+	631,
+	567,
+	632,
+	568,
+	632,
+	567,
+	632,
+	568,
+	633,
+	569,
+	633,
+	568,
+	633,
+	569,
+	634,
+	570,
+	634,
+	569,
+	634,
+	570,
+	635,
+	571,
+	635,
+	570,
+	635,
+	571,
+	636,
+	572,
+	636,
+	571,
+	636,
+	572,
+	637,
+	573,
+	637,
+	572,
+	637,
+	573,
+	638,
+	574,
+	638,
+	573,
+	638,
+	574,
+	639,
+	575,
+	639,
+	574,
+	640,
+	576,
+	641,
+	577,
+	641,
+	576,
+	641,
+	577,
+	642,
+	578,
+	642,
+	577,
+	642,
+	578,
+	643,
+	579,
+	643,
+	578,
+	643,
+	579,
+	644,
+	580,
+	644,
+	579,
+	644,
+	580,
+	645,
+	581,
+	645,
+	580,
+	645,
+	581,
+	646,
+	582,
+	646,
+	581,
+	646,
+	582,
+	647,
+	583,
+	647,
+	582,
+	647,
+	583,
+	648,
+	584,
+	648,
+	583,
+	648,
+	584,
+	649,
+	585,
+	649,
+	584,
+	649,
+	585,
+	650,
+	586,
+	650,
+	585,
+	650,
+	586,
+	651,
+	587,
+	651,
+	586,
+	651,
+	587,
+	652,
+	588,
+	652,
+	587,
+	652,
+	588,
+	653,
+	589,
+	653,
+	588,
+	653,
+	589,
+	654,
+	590,
+	654,
+	589,
+	654,
+	590,
+	655,
+	591,
+	655,
+	590,
+	655,
+	591,
+	656,
+	592,
+	656,
+	591,
+	656,
+	592,
+	657,
+	593,
+	657,
+	592,
+	657,
+	593,
+	658,
+	594,
+	658,
+	593,
+	658,
+	594,
+	659,
+	595,
+	659,
+	594,
+	659,
+	595,
+	660,
+	596,
+	660,
+	595,
+	660,
+	596,
+	661,
+	597,
+	661,
+	596,
+	661,
+	597,
+	662,
+	598,
+	662,
+	597,
+	662,
+	598,
+	663,
+	599,
+	663,
+	598,
+	663,
+	599,
+	664,
+	600,
+	664,
+	599,
+	664,
+	600,
+	665,
+	601,
+	665,
+	600,
+	665,
+	601,
+	666,
+	602,
+	666,
+	601,
+	666,
+	602,
+	667,
+	603,
+	667,
+	602,
+	667,
+	603,
+	668,
+	604,
+	668,
+	603,
+	668,
+	604,
+	669,
+	605,
+	669,
+	604,
+	669,
+	605,
+	670,
+	606,
+	670,
+	605,
+	670,
+	606,
+	671,
+	607,
+	671,
+	606,
+	671,
+	607,
+	672,
+	608,
+	672,
+	607,
+	672,
+	608,
+	673,
+	609,
+	673,
+	608,
+	673,
+	609,
+	674,
+	610,
+	674,
+	609,
+	674,
+	610,
+	675,
+	611,
+	675,
+	610,
+	675,
+	611,
+	676,
+	612,
+	676,
+	611,
+	676,
+	612,
+	677,
+	613,
+	677,
+	612,
+	677,
+	613,
+	678,
+	614,
+	678,
+	613,
+	678,
+	614,
+	679,
+	615,
+	679,
+	614,
+	679,
+	615,
+	680,
+	616,
+	680,
+	615,
+	680,
+	616,
+	681,
+	617,
+	681,
+	616,
+	681,
+	617,
+	682,
+	618,
+	682,
+	617,
+	682,
+	618,
+	683,
+	619,
+	683,
+	618,
+	683,
+	619,
+	684,
+	620,
+	684,
+	619,
+	684,
+	620,
+	685,
+	621,
+	685,
+	620,
+	685,
+	621,
+	686,
+	622,
+	686,
+	621,
+	686,
+	622,
+	687,
+	623,
+	687,
+	622,
+	687,
+	623,
+	688,
+	624,
+	688,
+	623,
+	688,
+	624,
+	689,
+	625,
+	689,
+	624,
+	689,
+	625,
+	690,
+	626,
+	690,
+	625,
+	690,
+	626,
+	691,
+	627,
+	691,
+	626,
+	691,
+	627,
+	692,
+	628,
+	692,
+	627,
+	692,
+	628,
+	693,
+	629,
+	693,
+	628,
+	693,
+	629,
+	694,
+	630,
+	694,
+	629,
+	694,
+	630,
+	695,
+	631,
+	695,
+	630,
+	695,
+	631,
+	696,
+	632,
+	696,
+	631,
+	696,
+	632,
+	697,
+	633,
+	697,
+	632,
+	697,
+	633,
+	698,
+	634,
+	698,
+	633,
+	698,
+	634,
+	699,
+	635,
+	699,
+	634,
+	699,
+	635,
+	700,
+	636,
+	700,
+	635,
+	700,
+	636,
+	701,
+	637,
+	701,
+	636,
+	701,
+	637,
+	702,
+	638,
+	702,
+	637,
+	702,
+	638,
+	703,
+	639,
+	703,
+	638,
+	704,
+	640,
+	705,
+	641,
+	705,
+	640,
+	705,
+	641,
+	706,
+	642,
+	706,
+	641,
+	706,
+	642,
+	707,
+	643,
+	707,
+	642,
+	707,
+	643,
+	708,
+	644,
+	708,
+	643,
+	708,
+	644,
+	709,
+	645,
+	709,
+	644,
+	709,
+	645,
+	710,
+	646,
+	710,
+	645,
+	710,
+	646,
+	711,
+	647,
+	711,
+	646,
+	711,
+	647,
+	712,
+	648,
+	712,
+	647,
+	712,
+	648,
+	713,
+	649,
+	713,
+	648,
+	713,
+	649,
+	714,
+	650,
+	714,
+	649,
+	714,
+	650,
+	715,
+	651,
+	715,
+	650,
+	715,
+	651,
+	716,
+	652,
+	716,
+	651,
+	716,
+	652,
+	717,
+	653,
+	717,
+	652,
+	717,
+	653,
+	718,
+	654,
+	718,
+	653,
+	718,
+	654,
+	719,
+	655,
+	719,
+	654,
+	719,
+	655,
+	720,
+	656,
+	720,
+	655,
+	720,
+	656,
+	721,
+	657,
+	721,
+	656,
+	721,
+	657,
+	722,
+	658,
+	722,
+	657,
+	722,
+	658,
+	723,
+	659,
+	723,
+	658,
+	723,
+	659,
+	724,
+	660,
+	724,
+	659,
+	724,
+	660,
+	725,
+	661,
+	725,
+	660,
+	725,
+	661,
+	726,
+	662,
+	726,
+	661,
+	726,
+	662,
+	727,
+	663,
+	727,
+	662,
+	727,
+	663,
+	728,
+	664,
+	728,
+	663,
+	728,
+	664,
+	729,
+	665,
+	729,
+	664,
+	729,
+	665,
+	730,
+	666,
+	730,
+	665,
+	730,
+	666,
+	731,
+	667,
+	731,
+	666,
+	731,
+	667,
+	732,
+	668,
+	732,
+	667,
+	732,
+	668,
+	733,
+	669,
+	733,
+	668,
+	733,
+	669,
+	734,
+	670,
+	734,
+	669,
+	734,
+	670,
+	735,
+	671,
+	735,
+	670,
+	735,
+	671,
+	736,
+	672,
+	736,
+	671,
+	736,
+	672,
+	737,
+	673,
+	737,
+	672,
+	737,
+	673,
+	738,
+	674,
+	738,
+	673,
+	738,
+	674,
+	739,
+	675,
+	739,
+	674,
+	739,
+	675,
+	740,
+	676,
+	740,
+	675,
+	740,
+	676,
+	741,
+	677,
+	741,
+	676,
+	741,
+	677,
+	742,
+	678,
+	742,
+	677,
+	742,
+	678,
+	743,
+	679,
+	743,
+	678,
+	743,
+	679,
+	744,
+	680,
+	744,
+	679,
+	744,
+	680,
+	745,
+	681,
+	745,
+	680,
+	745,
+	681,
+	746,
+	682,
+	746,
+	681,
+	746,
+	682,
+	747,
+	683,
+	747,
+	682,
+	747,
+	683,
+	748,
+	684,
+	748,
+	683,
+	748,
+	684,
+	749,
+	685,
+	749,
+	684,
+	749,
+	685,
+	750,
+	686,
+	750,
+	685,
+	750,
+	686,
+	751,
+	687,
+	751,
+	686,
+	751,
+	687,
+	752,
+	688,
+	752,
+	687,
+	752,
+	688,
+	753,
+	689,
+	753,
+	688,
+	753,
+	689,
+	754,
+	690,
+	754,
+	689,
+	754,
+	690,
+	755,
+	691,
+	755,
+	690,
+	755,
+	691,
+	756,
+	692,
+	756,
+	691,
+	756,
+	692,
+	757,
+	693,
+	757,
+	692,
+	757,
+	693,
+	758,
+	694,
+	758,
+	693,
+	758,
+	694,
+	759,
+	695,
+	759,
+	694,
+	759,
+	695,
+	760,
+	696,
+	760,
+	695,
+	760,
+	696,
+	761,
+	697,
+	761,
+	696,
+	761,
+	697,
+	762,
+	698,
+	762,
+	697,
+	762,
+	698,
+	763,
+	699,
+	763,
+	698,
+	763,
+	699,
+	764,
+	700,
+	764,
+	699,
+	764,
+	700,
+	765,
+	701,
+	765,
+	700,
+	765,
+	701,
+	766,
+	702,
+	766,
+	701,
+	766,
+	702,
+	767,
+	703,
+	767,
+	702,
+	768,
+	704,
+	769,
+	705,
+	769,
+	704,
+	769,
+	705,
+	770,
+	706,
+	770,
+	705,
+	770,
+	706,
+	771,
+	707,
+	771,
+	706,
+	771,
+	707,
+	772,
+	708,
+	772,
+	707,
+	772,
+	708,
+	773,
+	709,
+	773,
+	708,
+	773,
+	709,
+	774,
+	710,
+	774,
+	709,
+	774,
+	710,
+	775,
+	711,
+	775,
+	710,
+	775,
+	711,
+	776,
+	712,
+	776,
+	711,
+	776,
+	712,
+	777,
+	713,
+	777,
+	712,
+	777,
+	713,
+	778,
+	714,
+	778,
+	713,
+	778,
+	714,
+	779,
+	715,
+	779,
+	714,
+	779,
+	715,
+	780,
+	716,
+	780,
+	715,
+	780,
+	716,
+	781,
+	717,
+	781,
+	716,
+	781,
+	717,
+	782,
+	718,
+	782,
+	717,
+	782,
+	718,
+	783,
+	719,
+	783,
+	718,
+	783,
+	719,
+	784,
+	720,
+	784,
+	719,
+	784,
+	720,
+	785,
+	721,
+	785,
+	720,
+	785,
+	721,
+	786,
+	722,
+	786,
+	721,
+	786,
+	722,
+	787,
+	723,
+	787,
+	722,
+	787,
+	723,
+	788,
+	724,
+	788,
+	723,
+	788,
+	724,
+	789,
+	725,
+	789,
+	724,
+	789,
+	725,
+	790,
+	726,
+	790,
+	725,
+	790,
+	726,
+	791,
+	727,
+	791,
+	726,
+	791,
+	727,
+	792,
+	728,
+	792,
+	727,
+	792,
+	728,
+	793,
+	729,
+	793,
+	728,
+	793,
+	729,
+	794,
+	730,
+	794,
+	729,
+	794,
+	730,
+	795,
+	731,
+	795,
+	730,
+	795,
+	731,
+	796,
+	732,
+	796,
+	731,
+	796,
+	732,
+	797,
+	733,
+	797,
+	732,
+	797,
+	733,
+	798,
+	734,
+	798,
+	733,
+	798,
+	734,
+	799,
+	735,
+	799,
+	734,
+	799,
+	735,
+	800,
+	736,
+	800,
+	735,
+	800,
+	736,
+	801,
+	737,
+	801,
+	736,
+	801,
+	737,
+	802,
+	738,
+	802,
+	737,
+	802,
+	738,
+	803,
+	739,
+	803,
+	738,
+	803,
+	739,
+	804,
+	740,
+	804,
+	739,
+	804,
+	740,
+	805,
+	741,
+	805,
+	740,
+	805,
+	741,
+	806,
+	742,
+	806,
+	741,
+	806,
+	742,
+	807,
+	743,
+	807,
+	742,
+	807,
+	743,
+	808,
+	744,
+	808,
+	743,
+	808,
+	744,
+	809,
+	745,
+	809,
+	744,
+	809,
+	745,
+	810,
+	746,
+	810,
+	745,
+	810,
+	746,
+	811,
+	747,
+	811,
+	746,
+	811,
+	747,
+	812,
+	748,
+	812,
+	747,
+	812,
+	748,
+	813,
+	749,
+	813,
+	748,
+	813,
+	749,
+	814,
+	750,
+	814,
+	749,
+	814,
+	750,
+	815,
+	751,
+	815,
+	750,
+	815,
+	751,
+	816,
+	752,
+	816,
+	751,
+	816,
+	752,
+	817,
+	753,
+	817,
+	752,
+	817,
+	753,
+	818,
+	754,
+	818,
+	753,
+	818,
+	754,
+	819,
+	755,
+	819,
+	754,
+	819,
+	755,
+	820,
+	756,
+	820,
+	755,
+	820,
+	756,
+	821,
+	757,
+	821,
+	756,
+	821,
+	757,
+	822,
+	758,
+	822,
+	757,
+	822,
+	758,
+	823,
+	759,
+	823,
+	758,
+	823,
+	759,
+	824,
+	760,
+	824,
+	759,
+	824,
+	760,
+	825,
+	761,
+	825,
+	760,
+	825,
+	761,
+	826,
+	762,
+	826,
+	761,
+	826,
+	762,
+	827,
+	763,
+	827,
+	762,
+	827,
+	763,
+	828,
+	764,
+	828,
+	763,
+	828,
+	764,
+	829,
+	765,
+	829,
+	764,
+	829,
+	765,
+	830,
+	766,
+	830,
+	765,
+	830,
+	766,
+	831,
+	767,
+	831,
+	766,
+	832,
+	768,
+	833,
+	769,
+	833,
+	768,
+	833,
+	769,
+	834,
+	770,
+	834,
+	769,
+	834,
+	770,
+	835,
+	771,
+	835,
+	770,
+	835,
+	771,
+	836,
+	772,
+	836,
+	771,
+	836,
+	772,
+	837,
+	773,
+	837,
+	772,
+	837,
+	773,
+	838,
+	774,
+	838,
+	773,
+	838,
+	774,
+	839,
+	775,
+	839,
+	774,
+	839,
+	775,
+	840,
+	776,
+	840,
+	775,
+	840,
+	776,
+	841,
+	777,
+	841,
+	776,
+	841,
+	777,
+	842,
+	778,
+	842,
+	777,
+	842,
+	778,
+	843,
+	779,
+	843,
+	778,
+	843,
+	779,
+	844,
+	780,
+	844,
+	779,
+	844,
+	780,
+	845,
+	781,
+	845,
+	780,
+	845,
+	781,
+	846,
+	782,
+	846,
+	781,
+	846,
+	782,
+	847,
+	783,
+	847,
+	782,
+	847,
+	783,
+	848,
+	784,
+	848,
+	783,
+	848,
+	784,
+	849,
+	785,
+	849,
+	784,
+	849,
+	785,
+	850,
+	786,
+	850,
+	785,
+	850,
+	786,
+	851,
+	787,
+	851,
+	786,
+	851,
+	787,
+	852,
+	788,
+	852,
+	787,
+	852,
+	788,
+	853,
+	789,
+	853,
+	788,
+	853,
+	789,
+	854,
+	790,
+	854,
+	789,
+	854,
+	790,
+	855,
+	791,
+	855,
+	790,
+	855,
+	791,
+	856,
+	792,
+	856,
+	791,
+	856,
+	792,
+	857,
+	793,
+	857,
+	792,
+	857,
+	793,
+	858,
+	794,
+	858,
+	793,
+	858,
+	794,
+	859,
+	795,
+	859,
+	794,
+	859,
+	795,
+	860,
+	796,
+	860,
+	795,
+	860,
+	796,
+	861,
+	797,
+	861,
+	796,
+	861,
+	797,
+	862,
+	798,
+	862,
+	797,
+	862,
+	798,
+	863,
+	799,
+	863,
+	798,
+	863,
+	799,
+	864,
+	800,
+	864,
+	799,
+	864,
+	800,
+	865,
+	801,
+	865,
+	800,
+	865,
+	801,
+	866,
+	802,
+	866,
+	801,
+	866,
+	802,
+	867,
+	803,
+	867,
+	802,
+	867,
+	803,
+	868,
+	804,
+	868,
+	803,
+	868,
+	804,
+	869,
+	805,
+	869,
+	804,
+	869,
+	805,
+	870,
+	806,
+	870,
+	805,
+	870,
+	806,
+	871,
+	807,
+	871,
+	806,
+	871,
+	807,
+	872,
+	808,
+	872,
+	807,
+	872,
+	808,
+	873,
+	809,
+	873,
+	808,
+	873,
+	809,
+	874,
+	810,
+	874,
+	809,
+	874,
+	810,
+	875,
+	811,
+	875,
+	810,
+	875,
+	811,
+	876,
+	812,
+	876,
+	811,
+	876,
+	812,
+	877,
+	813,
+	877,
+	812,
+	877,
+	813,
+	878,
+	814,
+	878,
+	813,
+	878,
+	814,
+	879,
+	815,
+	879,
+	814,
+	879,
+	815,
+	880,
+	816,
+	880,
+	815,
+	880,
+	816,
+	881,
+	817,
+	881,
+	816,
+	881,
+	817,
+	882,
+	818,
+	882,
+	817,
+	882,
+	818,
+	883,
+	819,
+	883,
+	818,
+	883,
+	819,
+	884,
+	820,
+	884,
+	819,
+	884,
+	820,
+	885,
+	821,
+	885,
+	820,
+	885,
+	821,
+	886,
+	822,
+	886,
+	821,
+	886,
+	822,
+	887,
+	823,
+	887,
+	822,
+	887,
+	823,
+	888,
+	824,
+	888,
+	823,
+	888,
+	824,
+	889,
+	825,
+	889,
+	824,
+	889,
+	825,
+	890,
+	826,
+	890,
+	825,
+	890,
+	826,
+	891,
+	827,
+	891,
+	826,
+	891,
+	827,
+	892,
+	828,
+	892,
+	827,
+	892,
+	828,
+	893,
+	829,
+	893,
+	828,
+	893,
+	829,
+	894,
+	830,
+	894,
+	829,
+	894,
+	830,
+	895,
+	831,
+	895,
+	830,
+	896,
+	832,
+	897,
+	833,
+	897,
+	832,
+	897,
+	833,
+	898,
+	834,
+	898,
+	833,
+	898,
+	834,
+	899,
+	835,
+	899,
+	834,
+	899,
+	835,
+	900,
+	836,
+	900,
+	835,
+	900,
+	836,
+	901,
+	837,
+	901,
+	836,
+	901,
+	837,
+	902,
+	838,
+	902,
+	837,
+	902,
+	838,
+	903,
+	839,
+	903,
+	838,
+	903,
+	839,
+	904,
+	840,
+	904,
+	839,
+	904,
+	840,
+	905,
+	841,
+	905,
+	840,
+	905,
+	841,
+	906,
+	842,
+	906,
+	841,
+	906,
+	842,
+	907,
+	843,
+	907,
+	842,
+	907,
+	843,
+	908,
+	844,
+	908,
+	843,
+	908,
+	844,
+	909,
+	845,
+	909,
+	844,
+	909,
+	845,
+	910,
+	846,
+	910,
+	845,
+	910,
+	846,
+	911,
+	847,
+	911,
+	846,
+	911,
+	847,
+	912,
+	848,
+	912,
+	847,
+	912,
+	848,
+	913,
+	849,
+	913,
+	848,
+	913,
+	849,
+	914,
+	850,
+	914,
+	849,
+	914,
+	850,
+	915,
+	851,
+	915,
+	850,
+	915,
+	851,
+	916,
+	852,
+	916,
+	851,
+	916,
+	852,
+	917,
+	853,
+	917,
+	852,
+	917,
+	853,
+	918,
+	854,
+	918,
+	853,
+	918,
+	854,
+	919,
+	855,
+	919,
+	854,
+	919,
+	855,
+	920,
+	856,
+	920,
+	855,
+	920,
+	856,
+	921,
+	857,
+	921,
+	856,
+	921,
+	857,
+	922,
+	858,
+	922,
+	857,
+	922,
+	858,
+	923,
+	859,
+	923,
+	858,
+	923,
+	859,
+	924,
+	860,
+	924,
+	859,
+	924,
+	860,
+	925,
+	861,
+	925,
+	860,
+	925,
+	861,
+	926,
+	862,
+	926,
+	861,
+	926,
+	862,
+	927,
+	863,
+	927,
+	862,
+	927,
+	863,
+	928,
+	864,
+	928,
+	863,
+	928,
+	864,
+	929,
+	865,
+	929,
+	864,
+	929,
+	865,
+	930,
+	866,
+	930,
+	865,
+	930,
+	866,
+	931,
+	867,
+	931,
+	866,
+	931,
+	867,
+	932,
+	868,
+	932,
+	867,
+	932,
+	868,
+	933,
+	869,
+	933,
+	868,
+	933,
+	869,
+	934,
+	870,
+	934,
+	869,
+	934,
+	870,
+	935,
+	871,
+	935,
+	870,
+	935,
+	871,
+	936,
+	872,
+	936,
+	871,
+	936,
+	872,
+	937,
+	873,
+	937,
+	872,
+	937,
+	873,
+	938,
+	874,
+	938,
+	873,
+	938,
+	874,
+	939,
+	875,
+	939,
+	874,
+	939,
+	875,
+	940,
+	876,
+	940,
+	875,
+	940,
+	876,
+	941,
+	877,
+	941,
+	876,
+	941,
+	877,
+	942,
+	878,
+	942,
+	877,
+	942,
+	878,
+	943,
+	879,
+	943,
+	878,
+	943,
+	879,
+	944,
+	880,
+	944,
+	879,
+	944,
+	880,
+	945,
+	881,
+	945,
+	880,
+	945,
+	881,
+	946,
+	882,
+	946,
+	881,
+	946,
+	882,
+	947,
+	883,
+	947,
+	882,
+	947,
+	883,
+	948,
+	884,
+	948,
+	883,
+	948,
+	884,
+	949,
+	885,
+	949,
+	884,
+	949,
+	885,
+	950,
+	886,
+	950,
+	885,
+	950,
+	886,
+	951,
+	887,
+	951,
+	886,
+	951,
+	887,
+	952,
+	888,
+	952,
+	887,
+	952,
+	888,
+	953,
+	889,
+	953,
+	888,
+	953,
+	889,
+	954,
+	890,
+	954,
+	889,
+	954,
+	890,
+	955,
+	891,
+	955,
+	890,
+	955,
+	891,
+	956,
+	892,
+	956,
+	891,
+	956,
+	892,
+	957,
+	893,
+	957,
+	892,
+	957,
+	893,
+	958,
+	894,
+	958,
+	893,
+	958,
+	894,
+	959,
+	895,
+	959,
+	894,
+	960,
+	896,
+	961,
+	897,
+	961,
+	896,
+	961,
+	897,
+	962,
+	898,
+	962,
+	897,
+	962,
+	898,
+	963,
+	899,
+	963,
+	898,
+	963,
+	899,
+	964,
+	900,
+	964,
+	899,
+	964,
+	900,
+	965,
+	901,
+	965,
+	900,
+	965,
+	901,
+	966,
+	902,
+	966,
+	901,
+	966,
+	902,
+	967,
+	903,
+	967,
+	902,
+	967,
+	903,
+	968,
+	904,
+	968,
+	903,
+	968,
+	904,
+	969,
+	905,
+	969,
+	904,
+	969,
+	905,
+	970,
+	906,
+	970,
+	905,
+	970,
+	906,
+	971,
+	907,
+	971,
+	906,
+	971,
+	907,
+	972,
+	908,
+	972,
+	907,
+	972,
+	908,
+	973,
+	909,
+	973,
+	908,
+	973,
+	909,
+	974,
+	910,
+	974,
+	909,
+	974,
+	910,
+	975,
+	911,
+	975,
+	910,
+	975,
+	911,
+	976,
+	912,
+	976,
+	911,
+	976,
+	912,
+	977,
+	913,
+	977,
+	912,
+	977,
+	913,
+	978,
+	914,
+	978,
+	913,
+	978,
+	914,
+	979,
+	915,
+	979,
+	914,
+	979,
+	915,
+	980,
+	916,
+	980,
+	915,
+	980,
+	916,
+	981,
+	917,
+	981,
+	916,
+	981,
+	917,
+	982,
+	918,
+	982,
+	917,
+	982,
+	918,
+	983,
+	919,
+	983,
+	918,
+	983,
+	919,
+	984,
+	920,
+	984,
+	919,
+	984,
+	920,
+	985,
+	921,
+	985,
+	920,
+	985,
+	921,
+	986,
+	922,
+	986,
+	921,
+	986,
+	922,
+	987,
+	923,
+	987,
+	922,
+	987,
+	923,
+	988,
+	924,
+	988,
+	923,
+	988,
+	924,
+	989,
+	925,
+	989,
+	924,
+	989,
+	925,
+	990,
+	926,
+	990,
+	925,
+	990,
+	926,
+	991,
+	927,
+	991,
+	926,
+	991,
+	927,
+	992,
+	928,
+	992,
+	927,
+	992,
+	928,
+	993,
+	929,
+	993,
+	928,
+	993,
+	929,
+	994,
+	930,
+	994,
+	929,
+	994,
+	930,
+	995,
+	931,
+	995,
+	930,
+	995,
+	931,
+	996,
+	932,
+	996,
+	931,
+	996,
+	932,
+	997,
+	933,
+	997,
+	932,
+	997,
+	933,
+	998,
+	934,
+	998,
+	933,
+	998,
+	934,
+	999,
+	935,
+	999,
+	934,
+	999,
+	935,
+	1000,
+	936,
+	1000,
+	935,
+	1000,
+	936,
+	1001,
+	937,
+	1001,
+	936,
+	1001,
+	937,
+	1002,
+	938,
+	1002,
+	937,
+	1002,
+	938,
+	1003,
+	939,
+	1003,
+	938,
+	1003,
+	939,
+	1004,
+	940,
+	1004,
+	939,
+	1004,
+	940,
+	1005,
+	941,
+	1005,
+	940,
+	1005,
+	941,
+	1006,
+	942,
+	1006,
+	941,
+	1006,
+	942,
+	1007,
+	943,
+	1007,
+	942,
+	1007,
+	943,
+	1008,
+	944,
+	1008,
+	943,
+	1008,
+	944,
+	1009,
+	945,
+	1009,
+	944,
+	1009,
+	945,
+	1010,
+	946,
+	1010,
+	945,
+	1010,
+	946,
+	1011,
+	947,
+	1011,
+	946,
+	1011,
+	947,
+	1012,
+	948,
+	1012,
+	947,
+	1012,
+	948,
+	1013,
+	949,
+	1013,
+	948,
+	1013,
+	949,
+	1014,
+	950,
+	1014,
+	949,
+	1014,
+	950,
+	1015,
+	951,
+	1015,
+	950,
+	1015,
+	951,
+	1016,
+	952,
+	1016,
+	951,
+	1016,
+	952,
+	1017,
+	953,
+	1017,
+	952,
+	1017,
+	953,
+	1018,
+	954,
+	1018,
+	953,
+	1018,
+	954,
+	1019,
+	955,
+	1019,
+	954,
+	1019,
+	955,
+	1020,
+	956,
+	1020,
+	955,
+	1020,
+	956,
+	1021,
+	957,
+	1021,
+	956,
+	1021,
+	957,
+	1022,
+	958,
+	1022,
+	957,
+	1022,
+	958,
+	1023,
+	959,
+	1023,
+	958,
+	1024,
+	960,
+	1025,
+	961,
+	1025,
+	960,
+	1025,
+	961,
+	1026,
+	962,
+	1026,
+	961,
+	1026,
+	962,
+	1027,
+	963,
+	1027,
+	962,
+	1027,
+	963,
+	1028,
+	964,
+	1028,
+	963,
+	1028,
+	964,
+	1029,
+	965,
+	1029,
+	964,
+	1029,
+	965,
+	1030,
+	966,
+	1030,
+	965,
+	1030,
+	966,
+	1031,
+	967,
+	1031,
+	966,
+	1031,
+	967,
+	1032,
+	968,
+	1032,
+	967,
+	1032,
+	968,
+	1033,
+	969,
+	1033,
+	968,
+	1033,
+	969,
+	1034,
+	970,
+	1034,
+	969,
+	1034,
+	970,
+	1035,
+	971,
+	1035,
+	970,
+	1035,
+	971,
+	1036,
+	972,
+	1036,
+	971,
+	1036,
+	972,
+	1037,
+	973,
+	1037,
+	972,
+	1037,
+	973,
+	1038,
+	974,
+	1038,
+	973,
+	1038,
+	974,
+	1039,
+	975,
+	1039,
+	974,
+	1039,
+	975,
+	1040,
+	976,
+	1040,
+	975,
+	1040,
+	976,
+	1041,
+	977,
+	1041,
+	976,
+	1041,
+	977,
+	1042,
+	978,
+	1042,
+	977,
+	1042,
+	978,
+	1043,
+	979,
+	1043,
+	978,
+	1043,
+	979,
+	1044,
+	980,
+	1044,
+	979,
+	1044,
+	980,
+	1045,
+	981,
+	1045,
+	980,
+	1045,
+	981,
+	1046,
+	982,
+	1046,
+	981,
+	1046,
+	982,
+	1047,
+	983,
+	1047,
+	982,
+	1047,
+	983,
+	1048,
+	984,
+	1048,
+	983,
+	1048,
+	984,
+	1049,
+	985,
+	1049,
+	984,
+	1049,
+	985,
+	1050,
+	986,
+	1050,
+	985,
+	1050,
+	986,
+	1051,
+	987,
+	1051,
+	986,
+	1051,
+	987,
+	1052,
+	988,
+	1052,
+	987,
+	1052,
+	988,
+	1053,
+	989,
+	1053,
+	988,
+	1053,
+	989,
+	1054,
+	990,
+	1054,
+	989,
+	1054,
+	990,
+	1055,
+	991,
+	1055,
+	990,
+	1055,
+	991,
+	1056,
+	992,
+	1056,
+	991,
+	1056,
+	992,
+	1057,
+	993,
+	1057,
+	992,
+	1057,
+	993,
+	1058,
+	994,
+	1058,
+	993,
+	1058,
+	994,
+	1059,
+	995,
+	1059,
+	994,
+	1059,
+	995,
+	1060,
+	996,
+	1060,
+	995,
+	1060,
+	996,
+	1061,
+	997,
+	1061,
+	996,
+	1061,
+	997,
+	1062,
+	998,
+	1062,
+	997,
+	1062,
+	998,
+	1063,
+	999,
+	1063,
+	998,
+	1063,
+	999,
+	1064,
+	1000,
+	1064,
+	999,
+	1064,
+	1000,
+	1065,
+	1001,
+	1065,
+	1000,
+	1065,
+	1001,
+	1066,
+	1002,
+	1066,
+	1001,
+	1066,
+	1002,
+	1067,
+	1003,
+	1067,
+	1002,
+	1067,
+	1003,
+	1068,
+	1004,
+	1068,
+	1003,
+	1068,
+	1004,
+	1069,
+	1005,
+	1069,
+	1004,
+	1069,
+	1005,
+	1070,
+	1006,
+	1070,
+	1005,
+	1070,
+	1006,
+	1071,
+	1007,
+	1071,
+	1006,
+	1071,
+	1007,
+	1072,
+	1008,
+	1072,
+	1007,
+	1072,
+	1008,
+	1073,
+	1009,
+	1073,
+	1008,
+	1073,
+	1009,
+	1074,
+	1010,
+	1074,
+	1009,
+	1074,
+	1010,
+	1075,
+	1011,
+	1075,
+	1010,
+	1075,
+	1011,
+	1076,
+	1012,
+	1076,
+	1011,
+	1076,
+	1012,
+	1077,
+	1013,
+	1077,
+	1012,
+	1077,
+	1013,
+	1078,
+	1014,
+	1078,
+	1013,
+	1078,
+	1014,
+	1079,
+	1015,
+	1079,
+	1014,
+	1079,
+	1015,
+	1080,
+	1016,
+	1080,
+	1015,
+	1080,
+	1016,
+	1081,
+	1017,
+	1081,
+	1016,
+	1081,
+	1017,
+	1082,
+	1018,
+	1082,
+	1017,
+	1082,
+	1018,
+	1083,
+	1019,
+	1083,
+	1018,
+	1083,
+	1019,
+	1084,
+	1020,
+	1084,
+	1019,
+	1084,
+	1020,
+	1085,
+	1021,
+	1085,
+	1020,
+	1085,
+	1021,
+	1086,
+	1022,
+	1086,
+	1021,
+	1086,
+	1022,
+	1087,
+	1023,
+	1087,
+	1022,
+	1088,
+	1024,
+	1089,
+	1025,
+	1089,
+	1024,
+	1089,
+	1025,
+	1090,
+	1026,
+	1090,
+	1025,
+	1090,
+	1026,
+	1091,
+	1027,
+	1091,
+	1026,
+	1091,
+	1027,
+	1092,
+	1028,
+	1092,
+	1027,
+	1092,
+	1028,
+	1093,
+	1029,
+	1093,
+	1028,
+	1093,
+	1029,
+	1094,
+	1030,
+	1094,
+	1029,
+	1094,
+	1030,
+	1095,
+	1031,
+	1095,
+	1030,
+	1095,
+	1031,
+	1096,
+	1032,
+	1096,
+	1031,
+	1096,
+	1032,
+	1097,
+	1033,
+	1097,
+	1032,
+	1097,
+	1033,
+	1098,
+	1034,
+	1098,
+	1033,
+	1098,
+	1034,
+	1099,
+	1035,
+	1099,
+	1034,
+	1099,
+	1035,
+	1100,
+	1036,
+	1100,
+	1035,
+	1100,
+	1036,
+	1101,
+	1037,
+	1101,
+	1036,
+	1101,
+	1037,
+	1102,
+	1038,
+	1102,
+	1037,
+	1102,
+	1038,
+	1103,
+	1039,
+	1103,
+	1038,
+	1103,
+	1039,
+	1104,
+	1040,
+	1104,
+	1039,
+	1104,
+	1040,
+	1105,
+	1041,
+	1105,
+	1040,
+	1105,
+	1041,
+	1106,
+	1042,
+	1106,
+	1041,
+	1106,
+	1042,
+	1107,
+	1043,
+	1107,
+	1042,
+	1107,
+	1043,
+	1108,
+	1044,
+	1108,
+	1043,
+	1108,
+	1044,
+	1109,
+	1045,
+	1109,
+	1044,
+	1109,
+	1045,
+	1110,
+	1046,
+	1110,
+	1045,
+	1110,
+	1046,
+	1111,
+	1047,
+	1111,
+	1046,
+	1111,
+	1047,
+	1112,
+	1048,
+	1112,
+	1047,
+	1112,
+	1048,
+	1113,
+	1049,
+	1113,
+	1048,
+	1113,
+	1049,
+	1114,
+	1050,
+	1114,
+	1049,
+	1114,
+	1050,
+	1115,
+	1051,
+	1115,
+	1050,
+	1115,
+	1051,
+	1116,
+	1052,
+	1116,
+	1051,
+	1116,
+	1052,
+	1117,
+	1053,
+	1117,
+	1052,
+	1117,
+	1053,
+	1118,
+	1054,
+	1118,
+	1053,
+	1118,
+	1054,
+	1119,
+	1055,
+	1119,
+	1054,
+	1119,
+	1055,
+	1120,
+	1056,
+	1120,
+	1055,
+	1120,
+	1056,
+	1121,
+	1057,
+	1121,
+	1056,
+	1121,
+	1057,
+	1122,
+	1058,
+	1122,
+	1057,
+	1122,
+	1058,
+	1123,
+	1059,
+	1123,
+	1058,
+	1123,
+	1059,
+	1124,
+	1060,
+	1124,
+	1059,
+	1124,
+	1060,
+	1125,
+	1061,
+	1125,
+	1060,
+	1125,
+	1061,
+	1126,
+	1062,
+	1126,
+	1061,
+	1126,
+	1062,
+	1127,
+	1063,
+	1127,
+	1062,
+	1127,
+	1063,
+	1128,
+	1064,
+	1128,
+	1063,
+	1128,
+	1064,
+	1129,
+	1065,
+	1129,
+	1064,
+	1129,
+	1065,
+	1130,
+	1066,
+	1130,
+	1065,
+	1130,
+	1066,
+	1131,
+	1067,
+	1131,
+	1066,
+	1131,
+	1067,
+	1132,
+	1068,
+	1132,
+	1067,
+	1132,
+	1068,
+	1133,
+	1069,
+	1133,
+	1068,
+	1133,
+	1069,
+	1134,
+	1070,
+	1134,
+	1069,
+	1134,
+	1070,
+	1135,
+	1071,
+	1135,
+	1070,
+	1135,
+	1071,
+	1136,
+	1072,
+	1136,
+	1071,
+	1136,
+	1072,
+	1137,
+	1073,
+	1137,
+	1072,
+	1137,
+	1073,
+	1138,
+	1074,
+	1138,
+	1073,
+	1138,
+	1074,
+	1139,
+	1075,
+	1139,
+	1074,
+	1139,
+	1075,
+	1140,
+	1076,
+	1140,
+	1075,
+	1140,
+	1076,
+	1141,
+	1077,
+	1141,
+	1076,
+	1141,
+	1077,
+	1142,
+	1078,
+	1142,
+	1077,
+	1142,
+	1078,
+	1143,
+	1079,
+	1143,
+	1078,
+	1143,
+	1079,
+	1144,
+	1080,
+	1144,
+	1079,
+	1144,
+	1080,
+	1145,
+	1081,
+	1145,
+	1080,
+	1145,
+	1081,
+	1146,
+	1082,
+	1146,
+	1081,
+	1146,
+	1082,
+	1147,
+	1083,
+	1147,
+	1082,
+	1147,
+	1083,
+	1148,
+	1084,
+	1148,
+	1083,
+	1148,
+	1084,
+	1149,
+	1085,
+	1149,
+	1084,
+	1149,
+	1085,
+	1150,
+	1086,
+	1150,
+	1085,
+	1150,
+	1086,
+	1151,
+	1087,
+	1151,
+	1086,
+	1152,
+	1088,
+	1153,
+	1089,
+	1153,
+	1088,
+	1153,
+	1089,
+	1154,
+	1090,
+	1154,
+	1089,
+	1154,
+	1090,
+	1155,
+	1091,
+	1155,
+	1090,
+	1155,
+	1091,
+	1156,
+	1092,
+	1156,
+	1091,
+	1156,
+	1092,
+	1157,
+	1093,
+	1157,
+	1092,
+	1157,
+	1093,
+	1158,
+	1094,
+	1158,
+	1093,
+	1158,
+	1094,
+	1159,
+	1095,
+	1159,
+	1094,
+	1159,
+	1095,
+	1160,
+	1096,
+	1160,
+	1095,
+	1160,
+	1096,
+	1161,
+	1097,
+	1161,
+	1096,
+	1161,
+	1097,
+	1162,
+	1098,
+	1162,
+	1097,
+	1162,
+	1098,
+	1163,
+	1099,
+	1163,
+	1098,
+	1163,
+	1099,
+	1164,
+	1100,
+	1164,
+	1099,
+	1164,
+	1100,
+	1165,
+	1101,
+	1165,
+	1100,
+	1165,
+	1101,
+	1166,
+	1102,
+	1166,
+	1101,
+	1166,
+	1102,
+	1167,
+	1103,
+	1167,
+	1102,
+	1167,
+	1103,
+	1168,
+	1104,
+	1168,
+	1103,
+	1168,
+	1104,
+	1169,
+	1105,
+	1169,
+	1104,
+	1169,
+	1105,
+	1170,
+	1106,
+	1170,
+	1105,
+	1170,
+	1106,
+	1171,
+	1107,
+	1171,
+	1106,
+	1171,
+	1107,
+	1172,
+	1108,
+	1172,
+	1107,
+	1172,
+	1108,
+	1173,
+	1109,
+	1173,
+	1108,
+	1173,
+	1109,
+	1174,
+	1110,
+	1174,
+	1109,
+	1174,
+	1110,
+	1175,
+	1111,
+	1175,
+	1110,
+	1175,
+	1111,
+	1176,
+	1112,
+	1176,
+	1111,
+	1176,
+	1112,
+	1177,
+	1113,
+	1177,
+	1112,
+	1177,
+	1113,
+	1178,
+	1114,
+	1178,
+	1113,
+	1178,
+	1114,
+	1179,
+	1115,
+	1179,
+	1114,
+	1179,
+	1115,
+	1180,
+	1116,
+	1180,
+	1115,
+	1180,
+	1116,
+	1181,
+	1117,
+	1181,
+	1116,
+	1181,
+	1117,
+	1182,
+	1118,
+	1182,
+	1117,
+	1182,
+	1118,
+	1183,
+	1119,
+	1183,
+	1118,
+	1183,
+	1119,
+	1184,
+	1120,
+	1184,
+	1119,
+	1184,
+	1120,
+	1185,
+	1121,
+	1185,
+	1120,
+	1185,
+	1121,
+	1186,
+	1122,
+	1186,
+	1121,
+	1186,
+	1122,
+	1187,
+	1123,
+	1187,
+	1122,
+	1187,
+	1123,
+	1188,
+	1124,
+	1188,
+	1123,
+	1188,
+	1124,
+	1189,
+	1125,
+	1189,
+	1124,
+	1189,
+	1125,
+	1190,
+	1126,
+	1190,
+	1125,
+	1190,
+	1126,
+	1191,
+	1127,
+	1191,
+	1126,
+	1191,
+	1127,
+	1192,
+	1128,
+	1192,
+	1127,
+	1192,
+	1128,
+	1193,
+	1129,
+	1193,
+	1128,
+	1193,
+	1129,
+	1194,
+	1130,
+	1194,
+	1129,
+	1194,
+	1130,
+	1195,
+	1131,
+	1195,
+	1130,
+	1195,
+	1131,
+	1196,
+	1132,
+	1196,
+	1131,
+	1196,
+	1132,
+	1197,
+	1133,
+	1197,
+	1132,
+	1197,
+	1133,
+	1198,
+	1134,
+	1198,
+	1133,
+	1198,
+	1134,
+	1199,
+	1135,
+	1199,
+	1134,
+	1199,
+	1135,
+	1200,
+	1136,
+	1200,
+	1135,
+	1200,
+	1136,
+	1201,
+	1137,
+	1201,
+	1136,
+	1201,
+	1137,
+	1202,
+	1138,
+	1202,
+	1137,
+	1202,
+	1138,
+	1203,
+	1139,
+	1203,
+	1138,
+	1203,
+	1139,
+	1204,
+	1140,
+	1204,
+	1139,
+	1204,
+	1140,
+	1205,
+	1141,
+	1205,
+	1140,
+	1205,
+	1141,
+	1206,
+	1142,
+	1206,
+	1141,
+	1206,
+	1142,
+	1207,
+	1143,
+	1207,
+	1142,
+	1207,
+	1143,
+	1208,
+	1144,
+	1208,
+	1143,
+	1208,
+	1144,
+	1209,
+	1145,
+	1209,
+	1144,
+	1209,
+	1145,
+	1210,
+	1146,
+	1210,
+	1145,
+	1210,
+	1146,
+	1211,
+	1147,
+	1211,
+	1146,
+	1211,
+	1147,
+	1212,
+	1148,
+	1212,
+	1147,
+	1212,
+	1148,
+	1213,
+	1149,
+	1213,
+	1148,
+	1213,
+	1149,
+	1214,
+	1150,
+	1214,
+	1149,
+	1214,
+	1150,
+	1215,
+	1151,
+	1215,
+	1150,
+	1216,
+	1152,
+	1217,
+	1153,
+	1217,
+	1152,
+	1217,
+	1153,
+	1218,
+	1154,
+	1218,
+	1153,
+	1218,
+	1154,
+	1219,
+	1155,
+	1219,
+	1154,
+	1219,
+	1155,
+	1220,
+	1156,
+	1220,
+	1155,
+	1220,
+	1156,
+	1221,
+	1157,
+	1221,
+	1156,
+	1221,
+	1157,
+	1222,
+	1158,
+	1222,
+	1157,
+	1222,
+	1158,
+	1223,
+	1159,
+	1223,
+	1158,
+	1223,
+	1159,
+	1224,
+	1160,
+	1224,
+	1159,
+	1224,
+	1160,
+	1225,
+	1161,
+	1225,
+	1160,
+	1225,
+	1161,
+	1226,
+	1162,
+	1226,
+	1161,
+	1226,
+	1162,
+	1227,
+	1163,
+	1227,
+	1162,
+	1227,
+	1163,
+	1228,
+	1164,
+	1228,
+	1163,
+	1228,
+	1164,
+	1229,
+	1165,
+	1229,
+	1164,
+	1229,
+	1165,
+	1230,
+	1166,
+	1230,
+	1165,
+	1230,
+	1166,
+	1231,
+	1167,
+	1231,
+	1166,
+	1231,
+	1167,
+	1232,
+	1168,
+	1232,
+	1167,
+	1232,
+	1168,
+	1233,
+	1169,
+	1233,
+	1168,
+	1233,
+	1169,
+	1234,
+	1170,
+	1234,
+	1169,
+	1234,
+	1170,
+	1235,
+	1171,
+	1235,
+	1170,
+	1235,
+	1171,
+	1236,
+	1172,
+	1236,
+	1171,
+	1236,
+	1172,
+	1237,
+	1173,
+	1237,
+	1172,
+	1237,
+	1173,
+	1238,
+	1174,
+	1238,
+	1173,
+	1238,
+	1174,
+	1239,
+	1175,
+	1239,
+	1174,
+	1239,
+	1175,
+	1240,
+	1176,
+	1240,
+	1175,
+	1240,
+	1176,
+	1241,
+	1177,
+	1241,
+	1176,
+	1241,
+	1177,
+	1242,
+	1178,
+	1242,
+	1177,
+	1242,
+	1178,
+	1243,
+	1179,
+	1243,
+	1178,
+	1243,
+	1179,
+	1244,
+	1180,
+	1244,
+	1179,
+	1244,
+	1180,
+	1245,
+	1181,
+	1245,
+	1180,
+	1245,
+	1181,
+	1246,
+	1182,
+	1246,
+	1181,
+	1246,
+	1182,
+	1247,
+	1183,
+	1247,
+	1182,
+	1247,
+	1183,
+	1248,
+	1184,
+	1248,
+	1183,
+	1248,
+	1184,
+	1249,
+	1185,
+	1249,
+	1184,
+	1249,
+	1185,
+	1250,
+	1186,
+	1250,
+	1185,
+	1250,
+	1186,
+	1251,
+	1187,
+	1251,
+	1186,
+	1251,
+	1187,
+	1252,
+	1188,
+	1252,
+	1187,
+	1252,
+	1188,
+	1253,
+	1189,
+	1253,
+	1188,
+	1253,
+	1189,
+	1254,
+	1190,
+	1254,
+	1189,
+	1254,
+	1190,
+	1255,
+	1191,
+	1255,
+	1190,
+	1255,
+	1191,
+	1256,
+	1192,
+	1256,
+	1191,
+	1256,
+	1192,
+	1257,
+	1193,
+	1257,
+	1192,
+	1257,
+	1193,
+	1258,
+	1194,
+	1258,
+	1193,
+	1258,
+	1194,
+	1259,
+	1195,
+	1259,
+	1194,
+	1259,
+	1195,
+	1260,
+	1196,
+	1260,
+	1195,
+	1260,
+	1196,
+	1261,
+	1197,
+	1261,
+	1196,
+	1261,
+	1197,
+	1262,
+	1198,
+	1262,
+	1197,
+	1262,
+	1198,
+	1263,
+	1199,
+	1263,
+	1198,
+	1263,
+	1199,
+	1264,
+	1200,
+	1264,
+	1199,
+	1264,
+	1200,
+	1265,
+	1201,
+	1265,
+	1200,
+	1265,
+	1201,
+	1266,
+	1202,
+	1266,
+	1201,
+	1266,
+	1202,
+	1267,
+	1203,
+	1267,
+	1202,
+	1267,
+	1203,
+	1268,
+	1204,
+	1268,
+	1203,
+	1268,
+	1204,
+	1269,
+	1205,
+	1269,
+	1204,
+	1269,
+	1205,
+	1270,
+	1206,
+	1270,
+	1205,
+	1270,
+	1206,
+	1271,
+	1207,
+	1271,
+	1206,
+	1271,
+	1207,
+	1272,
+	1208,
+	1272,
+	1207,
+	1272,
+	1208,
+	1273,
+	1209,
+	1273,
+	1208,
+	1273,
+	1209,
+	1274,
+	1210,
+	1274,
+	1209,
+	1274,
+	1210,
+	1275,
+	1211,
+	1275,
+	1210,
+	1275,
+	1211,
+	1276,
+	1212,
+	1276,
+	1211,
+	1276,
+	1212,
+	1277,
+	1213,
+	1277,
+	1212,
+	1277,
+	1213,
+	1278,
+	1214,
+	1278,
+	1213,
+	1278,
+	1214,
+	1279,
+	1215,
+	1279,
+	1214,
+	1280,
+	1216,
+	1281,
+	1217,
+	1281,
+	1216,
+	1281,
+	1217,
+	1282,
+	1218,
+	1282,
+	1217,
+	1282,
+	1218,
+	1283,
+	1219,
+	1283,
+	1218,
+	1283,
+	1219,
+	1284,
+	1220,
+	1284,
+	1219,
+	1284,
+	1220,
+	1285,
+	1221,
+	1285,
+	1220,
+	1285,
+	1221,
+	1286,
+	1222,
+	1286,
+	1221,
+	1286,
+	1222,
+	1287,
+	1223,
+	1287,
+	1222,
+	1287,
+	1223,
+	1288,
+	1224,
+	1288,
+	1223,
+	1288,
+	1224,
+	1289,
+	1225,
+	1289,
+	1224,
+	1289,
+	1225,
+	1290,
+	1226,
+	1290,
+	1225,
+	1290,
+	1226,
+	1291,
+	1227,
+	1291,
+	1226,
+	1291,
+	1227,
+	1292,
+	1228,
+	1292,
+	1227,
+	1292,
+	1228,
+	1293,
+	1229,
+	1293,
+	1228,
+	1293,
+	1229,
+	1294,
+	1230,
+	1294,
+	1229,
+	1294,
+	1230,
+	1295,
+	1231,
+	1295,
+	1230,
+	1295,
+	1231,
+	1296,
+	1232,
+	1296,
+	1231,
+	1296,
+	1232,
+	1297,
+	1233,
+	1297,
+	1232,
+	1297,
+	1233,
+	1298,
+	1234,
+	1298,
+	1233,
+	1298,
+	1234,
+	1299,
+	1235,
+	1299,
+	1234,
+	1299,
+	1235,
+	1300,
+	1236,
+	1300,
+	1235,
+	1300,
+	1236,
+	1301,
+	1237,
+	1301,
+	1236,
+	1301,
+	1237,
+	1302,
+	1238,
+	1302,
+	1237,
+	1302,
+	1238,
+	1303,
+	1239,
+	1303,
+	1238,
+	1303,
+	1239,
+	1304,
+	1240,
+	1304,
+	1239,
+	1304,
+	1240,
+	1305,
+	1241,
+	1305,
+	1240,
+	1305,
+	1241,
+	1306,
+	1242,
+	1306,
+	1241,
+	1306,
+	1242,
+	1307,
+	1243,
+	1307,
+	1242,
+	1307,
+	1243,
+	1308,
+	1244,
+	1308,
+	1243,
+	1308,
+	1244,
+	1309,
+	1245,
+	1309,
+	1244,
+	1309,
+	1245,
+	1310,
+	1246,
+	1310,
+	1245,
+	1310,
+	1246,
+	1311,
+	1247,
+	1311,
+	1246,
+	1311,
+	1247,
+	1312,
+	1248,
+	1312,
+	1247,
+	1312,
+	1248,
+	1313,
+	1249,
+	1313,
+	1248,
+	1313,
+	1249,
+	1314,
+	1250,
+	1314,
+	1249,
+	1314,
+	1250,
+	1315,
+	1251,
+	1315,
+	1250,
+	1315,
+	1251,
+	1316,
+	1252,
+	1316,
+	1251,
+	1316,
+	1252,
+	1317,
+	1253,
+	1317,
+	1252,
+	1317,
+	1253,
+	1318,
+	1254,
+	1318,
+	1253,
+	1318,
+	1254,
+	1319,
+	1255,
+	1319,
+	1254,
+	1319,
+	1255,
+	1320,
+	1256,
+	1320,
+	1255,
+	1320,
+	1256,
+	1321,
+	1257,
+	1321,
+	1256,
+	1321,
+	1257,
+	1322,
+	1258,
+	1322,
+	1257,
+	1322,
+	1258,
+	1323,
+	1259,
+	1323,
+	1258,
+	1323,
+	1259,
+	1324,
+	1260,
+	1324,
+	1259,
+	1324,
+	1260,
+	1325,
+	1261,
+	1325,
+	1260,
+	1325,
+	1261,
+	1326,
+	1262,
+	1326,
+	1261,
+	1326,
+	1262,
+	1327,
+	1263,
+	1327,
+	1262,
+	1327,
+	1263,
+	1328,
+	1264,
+	1328,
+	1263,
+	1328,
+	1264,
+	1329,
+	1265,
+	1329,
+	1264,
+	1329,
+	1265,
+	1330,
+	1266,
+	1330,
+	1265,
+	1330,
+	1266,
+	1331,
+	1267,
+	1331,
+	1266,
+	1331,
+	1267,
+	1332,
+	1268,
+	1332,
+	1267,
+	1332,
+	1268,
+	1333,
+	1269,
+	1333,
+	1268,
+	1333,
+	1269,
+	1334,
+	1270,
+	1334,
+	1269,
+	1334,
+	1270,
+	1335,
+	1271,
+	1335,
+	1270,
+	1335,
+	1271,
+	1336,
+	1272,
+	1336,
+	1271,
+	1336,
+	1272,
+	1337,
+	1273,
+	1337,
+	1272,
+	1337,
+	1273,
+	1338,
+	1274,
+	1338,
+	1273,
+	1338,
+	1274,
+	1339,
+	1275,
+	1339,
+	1274,
+	1339,
+	1275,
+	1340,
+	1276,
+	1340,
+	1275,
+	1340,
+	1276,
+	1341,
+	1277,
+	1341,
+	1276,
+	1341,
+	1277,
+	1342,
+	1278,
+	1342,
+	1277,
+	1342,
+	1278,
+	1343,
+	1279,
+	1343,
+	1278,
+	1344,
+	1280,
+	1345,
+	1281,
+	1345,
+	1280,
+	1345,
+	1281,
+	1346,
+	1282,
+	1346,
+	1281,
+	1346,
+	1282,
+	1347,
+	1283,
+	1347,
+	1282,
+	1347,
+	1283,
+	1348,
+	1284,
+	1348,
+	1283,
+	1348,
+	1284,
+	1349,
+	1285,
+	1349,
+	1284,
+	1349,
+	1285,
+	1350,
+	1286,
+	1350,
+	1285,
+	1350,
+	1286,
+	1351,
+	1287,
+	1351,
+	1286,
+	1351,
+	1287,
+	1352,
+	1288,
+	1352,
+	1287,
+	1352,
+	1288,
+	1353,
+	1289,
+	1353,
+	1288,
+	1353,
+	1289,
+	1354,
+	1290,
+	1354,
+	1289,
+	1354,
+	1290,
+	1355,
+	1291,
+	1355,
+	1290,
+	1355,
+	1291,
+	1356,
+	1292,
+	1356,
+	1291,
+	1356,
+	1292,
+	1357,
+	1293,
+	1357,
+	1292,
+	1357,
+	1293,
+	1358,
+	1294,
+	1358,
+	1293,
+	1358,
+	1294,
+	1359,
+	1295,
+	1359,
+	1294,
+	1359,
+	1295,
+	1360,
+	1296,
+	1360,
+	1295,
+	1360,
+	1296,
+	1361,
+	1297,
+	1361,
+	1296,
+	1361,
+	1297,
+	1362,
+	1298,
+	1362,
+	1297,
+	1362,
+	1298,
+	1363,
+	1299,
+	1363,
+	1298,
+	1363,
+	1299,
+	1364,
+	1300,
+	1364,
+	1299,
+	1364,
+	1300,
+	1365,
+	1301,
+	1365,
+	1300,
+	1365,
+	1301,
+	1366,
+	1302,
+	1366,
+	1301,
+	1366,
+	1302,
+	1367,
+	1303,
+	1367,
+	1302,
+	1367,
+	1303,
+	1368,
+	1304,
+	1368,
+	1303,
+	1368,
+	1304,
+	1369,
+	1305,
+	1369,
+	1304,
+	1369,
+	1305,
+	1370,
+	1306,
+	1370,
+	1305,
+	1370,
+	1306,
+	1371,
+	1307,
+	1371,
+	1306,
+	1371,
+	1307,
+	1372,
+	1308,
+	1372,
+	1307,
+	1372,
+	1308,
+	1373,
+	1309,
+	1373,
+	1308,
+	1373,
+	1309,
+	1374,
+	1310,
+	1374,
+	1309,
+	1374,
+	1310,
+	1375,
+	1311,
+	1375,
+	1310,
+	1375,
+	1311,
+	1376,
+	1312,
+	1376,
+	1311,
+	1376,
+	1312,
+	1377,
+	1313,
+	1377,
+	1312,
+	1377,
+	1313,
+	1378,
+	1314,
+	1378,
+	1313,
+	1378,
+	1314,
+	1379,
+	1315,
+	1379,
+	1314,
+	1379,
+	1315,
+	1380,
+	1316,
+	1380,
+	1315,
+	1380,
+	1316,
+	1381,
+	1317,
+	1381,
+	1316,
+	1381,
+	1317,
+	1382,
+	1318,
+	1382,
+	1317,
+	1382,
+	1318,
+	1383,
+	1319,
+	1383,
+	1318,
+	1383,
+	1319,
+	1384,
+	1320,
+	1384,
+	1319,
+	1384,
+	1320,
+	1385,
+	1321,
+	1385,
+	1320,
+	1385,
+	1321,
+	1386,
+	1322,
+	1386,
+	1321,
+	1386,
+	1322,
+	1387,
+	1323,
+	1387,
+	1322,
+	1387,
+	1323,
+	1388,
+	1324,
+	1388,
+	1323,
+	1388,
+	1324,
+	1389,
+	1325,
+	1389,
+	1324,
+	1389,
+	1325,
+	1390,
+	1326,
+	1390,
+	1325,
+	1390,
+	1326,
+	1391,
+	1327,
+	1391,
+	1326,
+	1391,
+	1327,
+	1392,
+	1328,
+	1392,
+	1327,
+	1392,
+	1328,
+	1393,
+	1329,
+	1393,
+	1328,
+	1393,
+	1329,
+	1394,
+	1330,
+	1394,
+	1329,
+	1394,
+	1330,
+	1395,
+	1331,
+	1395,
+	1330,
+	1395,
+	1331,
+	1396,
+	1332,
+	1396,
+	1331,
+	1396,
+	1332,
+	1397,
+	1333,
+	1397,
+	1332,
+	1397,
+	1333,
+	1398,
+	1334,
+	1398,
+	1333,
+	1398,
+	1334,
+	1399,
+	1335,
+	1399,
+	1334,
+	1399,
+	1335,
+	1400,
+	1336,
+	1400,
+	1335,
+	1400,
+	1336,
+	1401,
+	1337,
+	1401,
+	1336,
+	1401,
+	1337,
+	1402,
+	1338,
+	1402,
+	1337,
+	1402,
+	1338,
+	1403,
+	1339,
+	1403,
+	1338,
+	1403,
+	1339,
+	1404,
+	1340,
+	1404,
+	1339,
+	1404,
+	1340,
+	1405,
+	1341,
+	1405,
+	1340,
+	1405,
+	1341,
+	1406,
+	1342,
+	1406,
+	1341,
+	1406,
+	1342,
+	1407,
+	1343,
+	1407,
+	1342,
+	1408,
+	1344,
+	1409,
+	1345,
+	1409,
+	1344,
+	1409,
+	1345,
+	1410,
+	1346,
+	1410,
+	1345,
+	1410,
+	1346,
+	1411,
+	1347,
+	1411,
+	1346,
+	1411,
+	1347,
+	1412,
+	1348,
+	1412,
+	1347,
+	1412,
+	1348,
+	1413,
+	1349,
+	1413,
+	1348,
+	1413,
+	1349,
+	1414,
+	1350,
+	1414,
+	1349,
+	1414,
+	1350,
+	1415,
+	1351,
+	1415,
+	1350,
+	1415,
+	1351,
+	1416,
+	1352,
+	1416,
+	1351,
+	1416,
+	1352,
+	1417,
+	1353,
+	1417,
+	1352,
+	1417,
+	1353,
+	1418,
+	1354,
+	1418,
+	1353,
+	1418,
+	1354,
+	1419,
+	1355,
+	1419,
+	1354,
+	1419,
+	1355,
+	1420,
+	1356,
+	1420,
+	1355,
+	1420,
+	1356,
+	1421,
+	1357,
+	1421,
+	1356,
+	1421,
+	1357,
+	1422,
+	1358,
+	1422,
+	1357,
+	1422,
+	1358,
+	1423,
+	1359,
+	1423,
+	1358,
+	1423,
+	1359,
+	1424,
+	1360,
+	1424,
+	1359,
+	1424,
+	1360,
+	1425,
+	1361,
+	1425,
+	1360,
+	1425,
+	1361,
+	1426,
+	1362,
+	1426,
+	1361,
+	1426,
+	1362,
+	1427,
+	1363,
+	1427,
+	1362,
+	1427,
+	1363,
+	1428,
+	1364,
+	1428,
+	1363,
+	1428,
+	1364,
+	1429,
+	1365,
+	1429,
+	1364,
+	1429,
+	1365,
+	1430,
+	1366,
+	1430,
+	1365,
+	1430,
+	1366,
+	1431,
+	1367,
+	1431,
+	1366,
+	1431,
+	1367,
+	1432,
+	1368,
+	1432,
+	1367,
+	1432,
+	1368,
+	1433,
+	1369,
+	1433,
+	1368,
+	1433,
+	1369,
+	1434,
+	1370,
+	1434,
+	1369,
+	1434,
+	1370,
+	1435,
+	1371,
+	1435,
+	1370,
+	1435,
+	1371,
+	1436,
+	1372,
+	1436,
+	1371,
+	1436,
+	1372,
+	1437,
+	1373,
+	1437,
+	1372,
+	1437,
+	1373,
+	1438,
+	1374,
+	1438,
+	1373,
+	1438,
+	1374,
+	1439,
+	1375,
+	1439,
+	1374,
+	1439,
+	1375,
+	1440,
+	1376,
+	1440,
+	1375,
+	1440,
+	1376,
+	1441,
+	1377,
+	1441,
+	1376,
+	1441,
+	1377,
+	1442,
+	1378,
+	1442,
+	1377,
+	1442,
+	1378,
+	1443,
+	1379,
+	1443,
+	1378,
+	1443,
+	1379,
+	1444,
+	1380,
+	1444,
+	1379,
+	1444,
+	1380,
+	1445,
+	1381,
+	1445,
+	1380,
+	1445,
+	1381,
+	1446,
+	1382,
+	1446,
+	1381,
+	1446,
+	1382,
+	1447,
+	1383,
+	1447,
+	1382,
+	1447,
+	1383,
+	1448,
+	1384,
+	1448,
+	1383,
+	1448,
+	1384,
+	1449,
+	1385,
+	1449,
+	1384,
+	1449,
+	1385,
+	1450,
+	1386,
+	1450,
+	1385,
+	1450,
+	1386,
+	1451,
+	1387,
+	1451,
+	1386,
+	1451,
+	1387,
+	1452,
+	1388,
+	1452,
+	1387,
+	1452,
+	1388,
+	1453,
+	1389,
+	1453,
+	1388,
+	1453,
+	1389,
+	1454,
+	1390,
+	1454,
+	1389,
+	1454,
+	1390,
+	1455,
+	1391,
+	1455,
+	1390,
+	1455,
+	1391,
+	1456,
+	1392,
+	1456,
+	1391,
+	1456,
+	1392,
+	1457,
+	1393,
+	1457,
+	1392,
+	1457,
+	1393,
+	1458,
+	1394,
+	1458,
+	1393,
+	1458,
+	1394,
+	1459,
+	1395,
+	1459,
+	1394,
+	1459,
+	1395,
+	1460,
+	1396,
+	1460,
+	1395,
+	1460,
+	1396,
+	1461,
+	1397,
+	1461,
+	1396,
+	1461,
+	1397,
+	1462,
+	1398,
+	1462,
+	1397,
+	1462,
+	1398,
+	1463,
+	1399,
+	1463,
+	1398,
+	1463,
+	1399,
+	1464,
+	1400,
+	1464,
+	1399,
+	1464,
+	1400,
+	1465,
+	1401,
+	1465,
+	1400,
+	1465,
+	1401,
+	1466,
+	1402,
+	1466,
+	1401,
+	1466,
+	1402,
+	1467,
+	1403,
+	1467,
+	1402,
+	1467,
+	1403,
+	1468,
+	1404,
+	1468,
+	1403,
+	1468,
+	1404,
+	1469,
+	1405,
+	1469,
+	1404,
+	1469,
+	1405,
+	1470,
+	1406,
+	1470,
+	1405,
+	1470,
+	1406,
+	1471,
+	1407,
+	1471,
+	1406,
+	1472,
+	1408,
+	1473,
+	1409,
+	1473,
+	1408,
+	1473,
+	1409,
+	1474,
+	1410,
+	1474,
+	1409,
+	1474,
+	1410,
+	1475,
+	1411,
+	1475,
+	1410,
+	1475,
+	1411,
+	1476,
+	1412,
+	1476,
+	1411,
+	1476,
+	1412,
+	1477,
+	1413,
+	1477,
+	1412,
+	1477,
+	1413,
+	1478,
+	1414,
+	1478,
+	1413,
+	1478,
+	1414,
+	1479,
+	1415,
+	1479,
+	1414,
+	1479,
+	1415,
+	1480,
+	1416,
+	1480,
+	1415,
+	1480,
+	1416,
+	1481,
+	1417,
+	1481,
+	1416,
+	1481,
+	1417,
+	1482,
+	1418,
+	1482,
+	1417,
+	1482,
+	1418,
+	1483,
+	1419,
+	1483,
+	1418,
+	1483,
+	1419,
+	1484,
+	1420,
+	1484,
+	1419,
+	1484,
+	1420,
+	1485,
+	1421,
+	1485,
+	1420,
+	1485,
+	1421,
+	1486,
+	1422,
+	1486,
+	1421,
+	1486,
+	1422,
+	1487,
+	1423,
+	1487,
+	1422,
+	1487,
+	1423,
+	1488,
+	1424,
+	1488,
+	1423,
+	1488,
+	1424,
+	1489,
+	1425,
+	1489,
+	1424,
+	1489,
+	1425,
+	1490,
+	1426,
+	1490,
+	1425,
+	1490,
+	1426,
+	1491,
+	1427,
+	1491,
+	1426,
+	1491,
+	1427,
+	1492,
+	1428,
+	1492,
+	1427,
+	1492,
+	1428,
+	1493,
+	1429,
+	1493,
+	1428,
+	1493,
+	1429,
+	1494,
+	1430,
+	1494,
+	1429,
+	1494,
+	1430,
+	1495,
+	1431,
+	1495,
+	1430,
+	1495,
+	1431,
+	1496,
+	1432,
+	1496,
+	1431,
+	1496,
+	1432,
+	1497,
+	1433,
+	1497,
+	1432,
+	1497,
+	1433,
+	1498,
+	1434,
+	1498,
+	1433,
+	1498,
+	1434,
+	1499,
+	1435,
+	1499,
+	1434,
+	1499,
+	1435,
+	1500,
+	1436,
+	1500,
+	1435,
+	1500,
+	1436,
+	1501,
+	1437,
+	1501,
+	1436,
+	1501,
+	1437,
+	1502,
+	1438,
+	1502,
+	1437,
+	1502,
+	1438,
+	1503,
+	1439,
+	1503,
+	1438,
+	1503,
+	1439,
+	1504,
+	1440,
+	1504,
+	1439,
+	1504,
+	1440,
+	1505,
+	1441,
+	1505,
+	1440,
+	1505,
+	1441,
+	1506,
+	1442,
+	1506,
+	1441,
+	1506,
+	1442,
+	1507,
+	1443,
+	1507,
+	1442,
+	1507,
+	1443,
+	1508,
+	1444,
+	1508,
+	1443,
+	1508,
+	1444,
+	1509,
+	1445,
+	1509,
+	1444,
+	1509,
+	1445,
+	1510,
+	1446,
+	1510,
+	1445,
+	1510,
+	1446,
+	1511,
+	1447,
+	1511,
+	1446,
+	1511,
+	1447,
+	1512,
+	1448,
+	1512,
+	1447,
+	1512,
+	1448,
+	1513,
+	1449,
+	1513,
+	1448,
+	1513,
+	1449,
+	1514,
+	1450,
+	1514,
+	1449,
+	1514,
+	1450,
+	1515,
+	1451,
+	1515,
+	1450,
+	1515,
+	1451,
+	1516,
+	1452,
+	1516,
+	1451,
+	1516,
+	1452,
+	1517,
+	1453,
+	1517,
+	1452,
+	1517,
+	1453,
+	1518,
+	1454,
+	1518,
+	1453,
+	1518,
+	1454,
+	1519,
+	1455,
+	1519,
+	1454,
+	1519,
+	1455,
+	1520,
+	1456,
+	1520,
+	1455,
+	1520,
+	1456,
+	1521,
+	1457,
+	1521,
+	1456,
+	1521,
+	1457,
+	1522,
+	1458,
+	1522,
+	1457,
+	1522,
+	1458,
+	1523,
+	1459,
+	1523,
+	1458,
+	1523,
+	1459,
+	1524,
+	1460,
+	1524,
+	1459,
+	1524,
+	1460,
+	1525,
+	1461,
+	1525,
+	1460,
+	1525,
+	1461,
+	1526,
+	1462,
+	1526,
+	1461,
+	1526,
+	1462,
+	1527,
+	1463,
+	1527,
+	1462,
+	1527,
+	1463,
+	1528,
+	1464,
+	1528,
+	1463,
+	1528,
+	1464,
+	1529,
+	1465,
+	1529,
+	1464,
+	1529,
+	1465,
+	1530,
+	1466,
+	1530,
+	1465,
+	1530,
+	1466,
+	1531,
+	1467,
+	1531,
+	1466,
+	1531,
+	1467,
+	1532,
+	1468,
+	1532,
+	1467,
+	1532,
+	1468,
+	1533,
+	1469,
+	1533,
+	1468,
+	1533,
+	1469,
+	1534,
+	1470,
+	1534,
+	1469,
+	1534,
+	1470,
+	1535,
+	1471,
+	1535,
+	1470,
+	1536,
+	1472,
+	1537,
+	1473,
+	1537,
+	1472,
+	1537,
+	1473,
+	1538,
+	1474,
+	1538,
+	1473,
+	1538,
+	1474,
+	1539,
+	1475,
+	1539,
+	1474,
+	1539,
+	1475,
+	1540,
+	1476,
+	1540,
+	1475,
+	1540,
+	1476,
+	1541,
+	1477,
+	1541,
+	1476,
+	1541,
+	1477,
+	1542,
+	1478,
+	1542,
+	1477,
+	1542,
+	1478,
+	1543,
+	1479,
+	1543,
+	1478,
+	1543,
+	1479,
+	1544,
+	1480,
+	1544,
+	1479,
+	1544,
+	1480,
+	1545,
+	1481,
+	1545,
+	1480,
+	1545,
+	1481,
+	1546,
+	1482,
+	1546,
+	1481,
+	1546,
+	1482,
+	1547,
+	1483,
+	1547,
+	1482,
+	1547,
+	1483,
+	1548,
+	1484,
+	1548,
+	1483,
+	1548,
+	1484,
+	1549,
+	1485,
+	1549,
+	1484,
+	1549,
+	1485,
+	1550,
+	1486,
+	1550,
+	1485,
+	1550,
+	1486,
+	1551,
+	1487,
+	1551,
+	1486,
+	1551,
+	1487,
+	1552,
+	1488,
+	1552,
+	1487,
+	1552,
+	1488,
+	1553,
+	1489,
+	1553,
+	1488,
+	1553,
+	1489,
+	1554,
+	1490,
+	1554,
+	1489,
+	1554,
+	1490,
+	1555,
+	1491,
+	1555,
+	1490,
+	1555,
+	1491,
+	1556,
+	1492,
+	1556,
+	1491,
+	1556,
+	1492,
+	1557,
+	1493,
+	1557,
+	1492,
+	1557,
+	1493,
+	1558,
+	1494,
+	1558,
+	1493,
+	1558,
+	1494,
+	1559,
+	1495,
+	1559,
+	1494,
+	1559,
+	1495,
+	1560,
+	1496,
+	1560,
+	1495,
+	1560,
+	1496,
+	1561,
+	1497,
+	1561,
+	1496,
+	1561,
+	1497,
+	1562,
+	1498,
+	1562,
+	1497,
+	1562,
+	1498,
+	1563,
+	1499,
+	1563,
+	1498,
+	1563,
+	1499,
+	1564,
+	1500,
+	1564,
+	1499,
+	1564,
+	1500,
+	1565,
+	1501,
+	1565,
+	1500,
+	1565,
+	1501,
+	1566,
+	1502,
+	1566,
+	1501,
+	1566,
+	1502,
+	1567,
+	1503,
+	1567,
+	1502,
+	1567,
+	1503,
+	1568,
+	1504,
+	1568,
+	1503,
+	1568,
+	1504,
+	1569,
+	1505,
+	1569,
+	1504,
+	1569,
+	1505,
+	1570,
+	1506,
+	1570,
+	1505,
+	1570,
+	1506,
+	1571,
+	1507,
+	1571,
+	1506,
+	1571,
+	1507,
+	1572,
+	1508,
+	1572,
+	1507,
+	1572,
+	1508,
+	1573,
+	1509,
+	1573,
+	1508,
+	1573,
+	1509,
+	1574,
+	1510,
+	1574,
+	1509,
+	1574,
+	1510,
+	1575,
+	1511,
+	1575,
+	1510,
+	1575,
+	1511,
+	1576,
+	1512,
+	1576,
+	1511,
+	1576,
+	1512,
+	1577,
+	1513,
+	1577,
+	1512,
+	1577,
+	1513,
+	1578,
+	1514,
+	1578,
+	1513,
+	1578,
+	1514,
+	1579,
+	1515,
+	1579,
+	1514,
+	1579,
+	1515,
+	1580,
+	1516,
+	1580,
+	1515,
+	1580,
+	1516,
+	1581,
+	1517,
+	1581,
+	1516,
+	1581,
+	1517,
+	1582,
+	1518,
+	1582,
+	1517,
+	1582,
+	1518,
+	1583,
+	1519,
+	1583,
+	1518,
+	1583,
+	1519,
+	1584,
+	1520,
+	1584,
+	1519,
+	1584,
+	1520,
+	1585,
+	1521,
+	1585,
+	1520,
+	1585,
+	1521,
+	1586,
+	1522,
+	1586,
+	1521,
+	1586,
+	1522,
+	1587,
+	1523,
+	1587,
+	1522,
+	1587,
+	1523,
+	1588,
+	1524,
+	1588,
+	1523,
+	1588,
+	1524,
+	1589,
+	1525,
+	1589,
+	1524,
+	1589,
+	1525,
+	1590,
+	1526,
+	1590,
+	1525,
+	1590,
+	1526,
+	1591,
+	1527,
+	1591,
+	1526,
+	1591,
+	1527,
+	1592,
+	1528,
+	1592,
+	1527,
+	1592,
+	1528,
+	1593,
+	1529,
+	1593,
+	1528,
+	1593,
+	1529,
+	1594,
+	1530,
+	1594,
+	1529,
+	1594,
+	1530,
+	1595,
+	1531,
+	1595,
+	1530,
+	1595,
+	1531,
+	1596,
+	1532,
+	1596,
+	1531,
+	1596,
+	1532,
+	1597,
+	1533,
+	1597,
+	1532,
+	1597,
+	1533,
+	1598,
+	1534,
+	1598,
+	1533,
+	1598,
+	1534,
+	1599,
+	1535,
+	1599,
+	1534,
+	1600,
+	1536,
+	1601,
+	1537,
+	1601,
+	1536,
+	1601,
+	1537,
+	1602,
+	1538,
+	1602,
+	1537,
+	1602,
+	1538,
+	1603,
+	1539,
+	1603,
+	1538,
+	1603,
+	1539,
+	1604,
+	1540,
+	1604,
+	1539,
+	1604,
+	1540,
+	1605,
+	1541,
+	1605,
+	1540,
+	1605,
+	1541,
+	1606,
+	1542,
+	1606,
+	1541,
+	1606,
+	1542,
+	1607,
+	1543,
+	1607,
+	1542,
+	1607,
+	1543,
+	1608,
+	1544,
+	1608,
+	1543,
+	1608,
+	1544,
+	1609,
+	1545,
+	1609,
+	1544,
+	1609,
+	1545,
+	1610,
+	1546,
+	1610,
+	1545,
+	1610,
+	1546,
+	1611,
+	1547,
+	1611,
+	1546,
+	1611,
+	1547,
+	1612,
+	1548,
+	1612,
+	1547,
+	1612,
+	1548,
+	1613,
+	1549,
+	1613,
+	1548,
+	1613,
+	1549,
+	1614,
+	1550,
+	1614,
+	1549,
+	1614,
+	1550,
+	1615,
+	1551,
+	1615,
+	1550,
+	1615,
+	1551,
+	1616,
+	1552,
+	1616,
+	1551,
+	1616,
+	1552,
+	1617,
+	1553,
+	1617,
+	1552,
+	1617,
+	1553,
+	1618,
+	1554,
+	1618,
+	1553,
+	1618,
+	1554,
+	1619,
+	1555,
+	1619,
+	1554,
+	1619,
+	1555,
+	1620,
+	1556,
+	1620,
+	1555,
+	1620,
+	1556,
+	1621,
+	1557,
+	1621,
+	1556,
+	1621,
+	1557,
+	1622,
+	1558,
+	1622,
+	1557,
+	1622,
+	1558,
+	1623,
+	1559,
+	1623,
+	1558,
+	1623,
+	1559,
+	1624,
+	1560,
+	1624,
+	1559,
+	1624,
+	1560,
+	1625,
+	1561,
+	1625,
+	1560,
+	1625,
+	1561,
+	1626,
+	1562,
+	1626,
+	1561,
+	1626,
+	1562,
+	1627,
+	1563,
+	1627,
+	1562,
+	1627,
+	1563,
+	1628,
+	1564,
+	1628,
+	1563,
+	1628,
+	1564,
+	1629,
+	1565,
+	1629,
+	1564,
+	1629,
+	1565,
+	1630,
+	1566,
+	1630,
+	1565,
+	1630,
+	1566,
+	1631,
+	1567,
+	1631,
+	1566,
+	1631,
+	1567,
+	1632,
+	1568,
+	1632,
+	1567,
+	1632,
+	1568,
+	1633,
+	1569,
+	1633,
+	1568,
+	1633,
+	1569,
+	1634,
+	1570,
+	1634,
+	1569,
+	1634,
+	1570,
+	1635,
+	1571,
+	1635,
+	1570,
+	1635,
+	1571,
+	1636,
+	1572,
+	1636,
+	1571,
+	1636,
+	1572,
+	1637,
+	1573,
+	1637,
+	1572,
+	1637,
+	1573,
+	1638,
+	1574,
+	1638,
+	1573,
+	1638,
+	1574,
+	1639,
+	1575,
+	1639,
+	1574,
+	1639,
+	1575,
+	1640,
+	1576,
+	1640,
+	1575,
+	1640,
+	1576,
+	1641,
+	1577,
+	1641,
+	1576,
+	1641,
+	1577,
+	1642,
+	1578,
+	1642,
+	1577,
+	1642,
+	1578,
+	1643,
+	1579,
+	1643,
+	1578,
+	1643,
+	1579,
+	1644,
+	1580,
+	1644,
+	1579,
+	1644,
+	1580,
+	1645,
+	1581,
+	1645,
+	1580,
+	1645,
+	1581,
+	1646,
+	1582,
+	1646,
+	1581,
+	1646,
+	1582,
+	1647,
+	1583,
+	1647,
+	1582,
+	1647,
+	1583,
+	1648,
+	1584,
+	1648,
+	1583,
+	1648,
+	1584,
+	1649,
+	1585,
+	1649,
+	1584,
+	1649,
+	1585,
+	1650,
+	1586,
+	1650,
+	1585,
+	1650,
+	1586,
+	1651,
+	1587,
+	1651,
+	1586,
+	1651,
+	1587,
+	1652,
+	1588,
+	1652,
+	1587,
+	1652,
+	1588,
+	1653,
+	1589,
+	1653,
+	1588,
+	1653,
+	1589,
+	1654,
+	1590,
+	1654,
+	1589,
+	1654,
+	1590,
+	1655,
+	1591,
+	1655,
+	1590,
+	1655,
+	1591,
+	1656,
+	1592,
+	1656,
+	1591,
+	1656,
+	1592,
+	1657,
+	1593,
+	1657,
+	1592,
+	1657,
+	1593,
+	1658,
+	1594,
+	1658,
+	1593,
+	1658,
+	1594,
+	1659,
+	1595,
+	1659,
+	1594,
+	1659,
+	1595,
+	1660,
+	1596,
+	1660,
+	1595,
+	1660,
+	1596,
+	1661,
+	1597,
+	1661,
+	1596,
+	1661,
+	1597,
+	1662,
+	1598,
+	1662,
+	1597,
+	1662,
+	1598,
+	1663,
+	1599,
+	1663,
+	1598,
+	1664,
+	1600,
+	1665,
+	1601,
+	1665,
+	1600,
+	1665,
+	1601,
+	1666,
+	1602,
+	1666,
+	1601,
+	1666,
+	1602,
+	1667,
+	1603,
+	1667,
+	1602,
+	1667,
+	1603,
+	1668,
+	1604,
+	1668,
+	1603,
+	1668,
+	1604,
+	1669,
+	1605,
+	1669,
+	1604,
+	1669,
+	1605,
+	1670,
+	1606,
+	1670,
+	1605,
+	1670,
+	1606,
+	1671,
+	1607,
+	1671,
+	1606,
+	1671,
+	1607,
+	1672,
+	1608,
+	1672,
+	1607,
+	1672,
+	1608,
+	1673,
+	1609,
+	1673,
+	1608,
+	1673,
+	1609,
+	1674,
+	1610,
+	1674,
+	1609,
+	1674,
+	1610,
+	1675,
+	1611,
+	1675,
+	1610,
+	1675,
+	1611,
+	1676,
+	1612,
+	1676,
+	1611,
+	1676,
+	1612,
+	1677,
+	1613,
+	1677,
+	1612,
+	1677,
+	1613,
+	1678,
+	1614,
+	1678,
+	1613,
+	1678,
+	1614,
+	1679,
+	1615,
+	1679,
+	1614,
+	1679,
+	1615,
+	1680,
+	1616,
+	1680,
+	1615,
+	1680,
+	1616,
+	1681,
+	1617,
+	1681,
+	1616,
+	1681,
+	1617,
+	1682,
+	1618,
+	1682,
+	1617,
+	1682,
+	1618,
+	1683,
+	1619,
+	1683,
+	1618,
+	1683,
+	1619,
+	1684,
+	1620,
+	1684,
+	1619,
+	1684,
+	1620,
+	1685,
+	1621,
+	1685,
+	1620,
+	1685,
+	1621,
+	1686,
+	1622,
+	1686,
+	1621,
+	1686,
+	1622,
+	1687,
+	1623,
+	1687,
+	1622,
+	1687,
+	1623,
+	1688,
+	1624,
+	1688,
+	1623,
+	1688,
+	1624,
+	1689,
+	1625,
+	1689,
+	1624,
+	1689,
+	1625,
+	1690,
+	1626,
+	1690,
+	1625,
+	1690,
+	1626,
+	1691,
+	1627,
+	1691,
+	1626,
+	1691,
+	1627,
+	1692,
+	1628,
+	1692,
+	1627,
+	1692,
+	1628,
+	1693,
+	1629,
+	1693,
+	1628,
+	1693,
+	1629,
+	1694,
+	1630,
+	1694,
+	1629,
+	1694,
+	1630,
+	1695,
+	1631,
+	1695,
+	1630,
+	1695,
+	1631,
+	1696,
+	1632,
+	1696,
+	1631,
+	1696,
+	1632,
+	1697,
+	1633,
+	1697,
+	1632,
+	1697,
+	1633,
+	1698,
+	1634,
+	1698,
+	1633,
+	1698,
+	1634,
+	1699,
+	1635,
+	1699,
+	1634,
+	1699,
+	1635,
+	1700,
+	1636,
+	1700,
+	1635,
+	1700,
+	1636,
+	1701,
+	1637,
+	1701,
+	1636,
+	1701,
+	1637,
+	1702,
+	1638,
+	1702,
+	1637,
+	1702,
+	1638,
+	1703,
+	1639,
+	1703,
+	1638,
+	1703,
+	1639,
+	1704,
+	1640,
+	1704,
+	1639,
+	1704,
+	1640,
+	1705,
+	1641,
+	1705,
+	1640,
+	1705,
+	1641,
+	1706,
+	1642,
+	1706,
+	1641,
+	1706,
+	1642,
+	1707,
+	1643,
+	1707,
+	1642,
+	1707,
+	1643,
+	1708,
+	1644,
+	1708,
+	1643,
+	1708,
+	1644,
+	1709,
+	1645,
+	1709,
+	1644,
+	1709,
+	1645,
+	1710,
+	1646,
+	1710,
+	1645,
+	1710,
+	1646,
+	1711,
+	1647,
+	1711,
+	1646,
+	1711,
+	1647,
+	1712,
+	1648,
+	1712,
+	1647,
+	1712,
+	1648,
+	1713,
+	1649,
+	1713,
+	1648,
+	1713,
+	1649,
+	1714,
+	1650,
+	1714,
+	1649,
+	1714,
+	1650,
+	1715,
+	1651,
+	1715,
+	1650,
+	1715,
+	1651,
+	1716,
+	1652,
+	1716,
+	1651,
+	1716,
+	1652,
+	1717,
+	1653,
+	1717,
+	1652,
+	1717,
+	1653,
+	1718,
+	1654,
+	1718,
+	1653,
+	1718,
+	1654,
+	1719,
+	1655,
+	1719,
+	1654,
+	1719,
+	1655,
+	1720,
+	1656,
+	1720,
+	1655,
+	1720,
+	1656,
+	1721,
+	1657,
+	1721,
+	1656,
+	1721,
+	1657,
+	1722,
+	1658,
+	1722,
+	1657,
+	1722,
+	1658,
+	1723,
+	1659,
+	1723,
+	1658,
+	1723,
+	1659,
+	1724,
+	1660,
+	1724,
+	1659,
+	1724,
+	1660,
+	1725,
+	1661,
+	1725,
+	1660,
+	1725,
+	1661,
+	1726,
+	1662,
+	1726,
+	1661,
+	1726,
+	1662,
+	1727,
+	1663,
+	1727,
+	1662,
+	1728,
+	1664,
+	1729,
+	1665,
+	1729,
+	1664,
+	1729,
+	1665,
+	1730,
+	1666,
+	1730,
+	1665,
+	1730,
+	1666,
+	1731,
+	1667,
+	1731,
+	1666,
+	1731,
+	1667,
+	1732,
+	1668,
+	1732,
+	1667,
+	1732,
+	1668,
+	1733,
+	1669,
+	1733,
+	1668,
+	1733,
+	1669,
+	1734,
+	1670,
+	1734,
+	1669,
+	1734,
+	1670,
+	1735,
+	1671,
+	1735,
+	1670,
+	1735,
+	1671,
+	1736,
+	1672,
+	1736,
+	1671,
+	1736,
+	1672,
+	1737,
+	1673,
+	1737,
+	1672,
+	1737,
+	1673,
+	1738,
+	1674,
+	1738,
+	1673,
+	1738,
+	1674,
+	1739,
+	1675,
+	1739,
+	1674,
+	1739,
+	1675,
+	1740,
+	1676,
+	1740,
+	1675,
+	1740,
+	1676,
+	1741,
+	1677,
+	1741,
+	1676,
+	1741,
+	1677,
+	1742,
+	1678,
+	1742,
+	1677,
+	1742,
+	1678,
+	1743,
+	1679,
+	1743,
+	1678,
+	1743,
+	1679,
+	1744,
+	1680,
+	1744,
+	1679,
+	1744,
+	1680,
+	1745,
+	1681,
+	1745,
+	1680,
+	1745,
+	1681,
+	1746,
+	1682,
+	1746,
+	1681,
+	1746,
+	1682,
+	1747,
+	1683,
+	1747,
+	1682,
+	1747,
+	1683,
+	1748,
+	1684,
+	1748,
+	1683,
+	1748,
+	1684,
+	1749,
+	1685,
+	1749,
+	1684,
+	1749,
+	1685,
+	1750,
+	1686,
+	1750,
+	1685,
+	1750,
+	1686,
+	1751,
+	1687,
+	1751,
+	1686,
+	1751,
+	1687,
+	1752,
+	1688,
+	1752,
+	1687,
+	1752,
+	1688,
+	1753,
+	1689,
+	1753,
+	1688,
+	1753,
+	1689,
+	1754,
+	1690,
+	1754,
+	1689,
+	1754,
+	1690,
+	1755,
+	1691,
+	1755,
+	1690,
+	1755,
+	1691,
+	1756,
+	1692,
+	1756,
+	1691,
+	1756,
+	1692,
+	1757,
+	1693,
+	1757,
+	1692,
+	1757,
+	1693,
+	1758,
+	1694,
+	1758,
+	1693,
+	1758,
+	1694,
+	1759,
+	1695,
+	1759,
+	1694,
+	1759,
+	1695,
+	1760,
+	1696,
+	1760,
+	1695,
+	1760,
+	1696,
+	1761,
+	1697,
+	1761,
+	1696,
+	1761,
+	1697,
+	1762,
+	1698,
+	1762,
+	1697,
+	1762,
+	1698,
+	1763,
+	1699,
+	1763,
+	1698,
+	1763,
+	1699,
+	1764,
+	1700,
+	1764,
+	1699,
+	1764,
+	1700,
+	1765,
+	1701,
+	1765,
+	1700,
+	1765,
+	1701,
+	1766,
+	1702,
+	1766,
+	1701,
+	1766,
+	1702,
+	1767,
+	1703,
+	1767,
+	1702,
+	1767,
+	1703,
+	1768,
+	1704,
+	1768,
+	1703,
+	1768,
+	1704,
+	1769,
+	1705,
+	1769,
+	1704,
+	1769,
+	1705,
+	1770,
+	1706,
+	1770,
+	1705,
+	1770,
+	1706,
+	1771,
+	1707,
+	1771,
+	1706,
+	1771,
+	1707,
+	1772,
+	1708,
+	1772,
+	1707,
+	1772,
+	1708,
+	1773,
+	1709,
+	1773,
+	1708,
+	1773,
+	1709,
+	1774,
+	1710,
+	1774,
+	1709,
+	1774,
+	1710,
+	1775,
+	1711,
+	1775,
+	1710,
+	1775,
+	1711,
+	1776,
+	1712,
+	1776,
+	1711,
+	1776,
+	1712,
+	1777,
+	1713,
+	1777,
+	1712,
+	1777,
+	1713,
+	1778,
+	1714,
+	1778,
+	1713,
+	1778,
+	1714,
+	1779,
+	1715,
+	1779,
+	1714,
+	1779,
+	1715,
+	1780,
+	1716,
+	1780,
+	1715,
+	1780,
+	1716,
+	1781,
+	1717,
+	1781,
+	1716,
+	1781,
+	1717,
+	1782,
+	1718,
+	1782,
+	1717,
+	1782,
+	1718,
+	1783,
+	1719,
+	1783,
+	1718,
+	1783,
+	1719,
+	1784,
+	1720,
+	1784,
+	1719,
+	1784,
+	1720,
+	1785,
+	1721,
+	1785,
+	1720,
+	1785,
+	1721,
+	1786,
+	1722,
+	1786,
+	1721,
+	1786,
+	1722,
+	1787,
+	1723,
+	1787,
+	1722,
+	1787,
+	1723,
+	1788,
+	1724,
+	1788,
+	1723,
+	1788,
+	1724,
+	1789,
+	1725,
+	1789,
+	1724,
+	1789,
+	1725,
+	1790,
+	1726,
+	1790,
+	1725,
+	1790,
+	1726,
+	1791,
+	1727,
+	1791,
+	1726,
+	1792,
+	1728,
+	1793,
+	1729,
+	1793,
+	1728,
+	1793,
+	1729,
+	1794,
+	1730,
+	1794,
+	1729,
+	1794,
+	1730,
+	1795,
+	1731,
+	1795,
+	1730,
+	1795,
+	1731,
+	1796,
+	1732,
+	1796,
+	1731,
+	1796,
+	1732,
+	1797,
+	1733,
+	1797,
+	1732,
+	1797,
+	1733,
+	1798,
+	1734,
+	1798,
+	1733,
+	1798,
+	1734,
+	1799,
+	1735,
+	1799,
+	1734,
+	1799,
+	1735,
+	1800,
+	1736,
+	1800,
+	1735,
+	1800,
+	1736,
+	1801,
+	1737,
+	1801,
+	1736,
+	1801,
+	1737,
+	1802,
+	1738,
+	1802,
+	1737,
+	1802,
+	1738,
+	1803,
+	1739,
+	1803,
+	1738,
+	1803,
+	1739,
+	1804,
+	1740,
+	1804,
+	1739,
+	1804,
+	1740,
+	1805,
+	1741,
+	1805,
+	1740,
+	1805,
+	1741,
+	1806,
+	1742,
+	1806,
+	1741,
+	1806,
+	1742,
+	1807,
+	1743,
+	1807,
+	1742,
+	1807,
+	1743,
+	1808,
+	1744,
+	1808,
+	1743,
+	1808,
+	1744,
+	1809,
+	1745,
+	1809,
+	1744,
+	1809,
+	1745,
+	1810,
+	1746,
+	1810,
+	1745,
+	1810,
+	1746,
+	1811,
+	1747,
+	1811,
+	1746,
+	1811,
+	1747,
+	1812,
+	1748,
+	1812,
+	1747,
+	1812,
+	1748,
+	1813,
+	1749,
+	1813,
+	1748,
+	1813,
+	1749,
+	1814,
+	1750,
+	1814,
+	1749,
+	1814,
+	1750,
+	1815,
+	1751,
+	1815,
+	1750,
+	1815,
+	1751,
+	1816,
+	1752,
+	1816,
+	1751,
+	1816,
+	1752,
+	1817,
+	1753,
+	1817,
+	1752,
+	1817,
+	1753,
+	1818,
+	1754,
+	1818,
+	1753,
+	1818,
+	1754,
+	1819,
+	1755,
+	1819,
+	1754,
+	1819,
+	1755,
+	1820,
+	1756,
+	1820,
+	1755,
+	1820,
+	1756,
+	1821,
+	1757,
+	1821,
+	1756,
+	1821,
+	1757,
+	1822,
+	1758,
+	1822,
+	1757,
+	1822,
+	1758,
+	1823,
+	1759,
+	1823,
+	1758,
+	1823,
+	1759,
+	1824,
+	1760,
+	1824,
+	1759,
+	1824,
+	1760,
+	1825,
+	1761,
+	1825,
+	1760,
+	1825,
+	1761,
+	1826,
+	1762,
+	1826,
+	1761,
+	1826,
+	1762,
+	1827,
+	1763,
+	1827,
+	1762,
+	1827,
+	1763,
+	1828,
+	1764,
+	1828,
+	1763,
+	1828,
+	1764,
+	1829,
+	1765,
+	1829,
+	1764,
+	1829,
+	1765,
+	1830,
+	1766,
+	1830,
+	1765,
+	1830,
+	1766,
+	1831,
+	1767,
+	1831,
+	1766,
+	1831,
+	1767,
+	1832,
+	1768,
+	1832,
+	1767,
+	1832,
+	1768,
+	1833,
+	1769,
+	1833,
+	1768,
+	1833,
+	1769,
+	1834,
+	1770,
+	1834,
+	1769,
+	1834,
+	1770,
+	1835,
+	1771,
+	1835,
+	1770,
+	1835,
+	1771,
+	1836,
+	1772,
+	1836,
+	1771,
+	1836,
+	1772,
+	1837,
+	1773,
+	1837,
+	1772,
+	1837,
+	1773,
+	1838,
+	1774,
+	1838,
+	1773,
+	1838,
+	1774,
+	1839,
+	1775,
+	1839,
+	1774,
+	1839,
+	1775,
+	1840,
+	1776,
+	1840,
+	1775,
+	1840,
+	1776,
+	1841,
+	1777,
+	1841,
+	1776,
+	1841,
+	1777,
+	1842,
+	1778,
+	1842,
+	1777,
+	1842,
+	1778,
+	1843,
+	1779,
+	1843,
+	1778,
+	1843,
+	1779,
+	1844,
+	1780,
+	1844,
+	1779,
+	1844,
+	1780,
+	1845,
+	1781,
+	1845,
+	1780,
+	1845,
+	1781,
+	1846,
+	1782,
+	1846,
+	1781,
+	1846,
+	1782,
+	1847,
+	1783,
+	1847,
+	1782,
+	1847,
+	1783,
+	1848,
+	1784,
+	1848,
+	1783,
+	1848,
+	1784,
+	1849,
+	1785,
+	1849,
+	1784,
+	1849,
+	1785,
+	1850,
+	1786,
+	1850,
+	1785,
+	1850,
+	1786,
+	1851,
+	1787,
+	1851,
+	1786,
+	1851,
+	1787,
+	1852,
+	1788,
+	1852,
+	1787,
+	1852,
+	1788,
+	1853,
+	1789,
+	1853,
+	1788,
+	1853,
+	1789,
+	1854,
+	1790,
+	1854,
+	1789,
+	1854,
+	1790,
+	1855,
+	1791,
+	1855,
+	1790,
+	1856,
+	1792,
+	1857,
+	1793,
+	1857,
+	1792,
+	1857,
+	1793,
+	1858,
+	1794,
+	1858,
+	1793,
+	1858,
+	1794,
+	1859,
+	1795,
+	1859,
+	1794,
+	1859,
+	1795,
+	1860,
+	1796,
+	1860,
+	1795,
+	1860,
+	1796,
+	1861,
+	1797,
+	1861,
+	1796,
+	1861,
+	1797,
+	1862,
+	1798,
+	1862,
+	1797,
+	1862,
+	1798,
+	1863,
+	1799,
+	1863,
+	1798,
+	1863,
+	1799,
+	1864,
+	1800,
+	1864,
+	1799,
+	1864,
+	1800,
+	1865,
+	1801,
+	1865,
+	1800,
+	1865,
+	1801,
+	1866,
+	1802,
+	1866,
+	1801,
+	1866,
+	1802,
+	1867,
+	1803,
+	1867,
+	1802,
+	1867,
+	1803,
+	1868,
+	1804,
+	1868,
+	1803,
+	1868,
+	1804,
+	1869,
+	1805,
+	1869,
+	1804,
+	1869,
+	1805,
+	1870,
+	1806,
+	1870,
+	1805,
+	1870,
+	1806,
+	1871,
+	1807,
+	1871,
+	1806,
+	1871,
+	1807,
+	1872,
+	1808,
+	1872,
+	1807,
+	1872,
+	1808,
+	1873,
+	1809,
+	1873,
+	1808,
+	1873,
+	1809,
+	1874,
+	1810,
+	1874,
+	1809,
+	1874,
+	1810,
+	1875,
+	1811,
+	1875,
+	1810,
+	1875,
+	1811,
+	1876,
+	1812,
+	1876,
+	1811,
+	1876,
+	1812,
+	1877,
+	1813,
+	1877,
+	1812,
+	1877,
+	1813,
+	1878,
+	1814,
+	1878,
+	1813,
+	1878,
+	1814,
+	1879,
+	1815,
+	1879,
+	1814,
+	1879,
+	1815,
+	1880,
+	1816,
+	1880,
+	1815,
+	1880,
+	1816,
+	1881,
+	1817,
+	1881,
+	1816,
+	1881,
+	1817,
+	1882,
+	1818,
+	1882,
+	1817,
+	1882,
+	1818,
+	1883,
+	1819,
+	1883,
+	1818,
+	1883,
+	1819,
+	1884,
+	1820,
+	1884,
+	1819,
+	1884,
+	1820,
+	1885,
+	1821,
+	1885,
+	1820,
+	1885,
+	1821,
+	1886,
+	1822,
+	1886,
+	1821,
+	1886,
+	1822,
+	1887,
+	1823,
+	1887,
+	1822,
+	1887,
+	1823,
+	1888,
+	1824,
+	1888,
+	1823,
+	1888,
+	1824,
+	1889,
+	1825,
+	1889,
+	1824,
+	1889,
+	1825,
+	1890,
+	1826,
+	1890,
+	1825,
+	1890,
+	1826,
+	1891,
+	1827,
+	1891,
+	1826,
+	1891,
+	1827,
+	1892,
+	1828,
+	1892,
+	1827,
+	1892,
+	1828,
+	1893,
+	1829,
+	1893,
+	1828,
+	1893,
+	1829,
+	1894,
+	1830,
+	1894,
+	1829,
+	1894,
+	1830,
+	1895,
+	1831,
+	1895,
+	1830,
+	1895,
+	1831,
+	1896,
+	1832,
+	1896,
+	1831,
+	1896,
+	1832,
+	1897,
+	1833,
+	1897,
+	1832,
+	1897,
+	1833,
+	1898,
+	1834,
+	1898,
+	1833,
+	1898,
+	1834,
+	1899,
+	1835,
+	1899,
+	1834,
+	1899,
+	1835,
+	1900,
+	1836,
+	1900,
+	1835,
+	1900,
+	1836,
+	1901,
+	1837,
+	1901,
+	1836,
+	1901,
+	1837,
+	1902,
+	1838,
+	1902,
+	1837,
+	1902,
+	1838,
+	1903,
+	1839,
+	1903,
+	1838,
+	1903,
+	1839,
+	1904,
+	1840,
+	1904,
+	1839,
+	1904,
+	1840,
+	1905,
+	1841,
+	1905,
+	1840,
+	1905,
+	1841,
+	1906,
+	1842,
+	1906,
+	1841,
+	1906,
+	1842,
+	1907,
+	1843,
+	1907,
+	1842,
+	1907,
+	1843,
+	1908,
+	1844,
+	1908,
+	1843,
+	1908,
+	1844,
+	1909,
+	1845,
+	1909,
+	1844,
+	1909,
+	1845,
+	1910,
+	1846,
+	1910,
+	1845,
+	1910,
+	1846,
+	1911,
+	1847,
+	1911,
+	1846,
+	1911,
+	1847,
+	1912,
+	1848,
+	1912,
+	1847,
+	1912,
+	1848,
+	1913,
+	1849,
+	1913,
+	1848,
+	1913,
+	1849,
+	1914,
+	1850,
+	1914,
+	1849,
+	1914,
+	1850,
+	1915,
+	1851,
+	1915,
+	1850,
+	1915,
+	1851,
+	1916,
+	1852,
+	1916,
+	1851,
+	1916,
+	1852,
+	1917,
+	1853,
+	1917,
+	1852,
+	1917,
+	1853,
+	1918,
+	1854,
+	1918,
+	1853,
+	1918,
+	1854,
+	1919,
+	1855,
+	1919,
+	1854,
+	1920,
+	1856,
+	1921,
+	1857,
+	1921,
+	1856,
+	1921,
+	1857,
+	1922,
+	1858,
+	1922,
+	1857,
+	1922,
+	1858,
+	1923,
+	1859,
+	1923,
+	1858,
+	1923,
+	1859,
+	1924,
+	1860,
+	1924,
+	1859,
+	1924,
+	1860,
+	1925,
+	1861,
+	1925,
+	1860,
+	1925,
+	1861,
+	1926,
+	1862,
+	1926,
+	1861,
+	1926,
+	1862,
+	1927,
+	1863,
+	1927,
+	1862,
+	1927,
+	1863,
+	1928,
+	1864,
+	1928,
+	1863,
+	1928,
+	1864,
+	1929,
+	1865,
+	1929,
+	1864,
+	1929,
+	1865,
+	1930,
+	1866,
+	1930,
+	1865,
+	1930,
+	1866,
+	1931,
+	1867,
+	1931,
+	1866,
+	1931,
+	1867,
+	1932,
+	1868,
+	1932,
+	1867,
+	1932,
+	1868,
+	1933,
+	1869,
+	1933,
+	1868,
+	1933,
+	1869,
+	1934,
+	1870,
+	1934,
+	1869,
+	1934,
+	1870,
+	1935,
+	1871,
+	1935,
+	1870,
+	1935,
+	1871,
+	1936,
+	1872,
+	1936,
+	1871,
+	1936,
+	1872,
+	1937,
+	1873,
+	1937,
+	1872,
+	1937,
+	1873,
+	1938,
+	1874,
+	1938,
+	1873,
+	1938,
+	1874,
+	1939,
+	1875,
+	1939,
+	1874,
+	1939,
+	1875,
+	1940,
+	1876,
+	1940,
+	1875,
+	1940,
+	1876,
+	1941,
+	1877,
+	1941,
+	1876,
+	1941,
+	1877,
+	1942,
+	1878,
+	1942,
+	1877,
+	1942,
+	1878,
+	1943,
+	1879,
+	1943,
+	1878,
+	1943,
+	1879,
+	1944,
+	1880,
+	1944,
+	1879,
+	1944,
+	1880,
+	1945,
+	1881,
+	1945,
+	1880,
+	1945,
+	1881,
+	1946,
+	1882,
+	1946,
+	1881,
+	1946,
+	1882,
+	1947,
+	1883,
+	1947,
+	1882,
+	1947,
+	1883,
+	1948,
+	1884,
+	1948,
+	1883,
+	1948,
+	1884,
+	1949,
+	1885,
+	1949,
+	1884,
+	1949,
+	1885,
+	1950,
+	1886,
+	1950,
+	1885,
+	1950,
+	1886,
+	1951,
+	1887,
+	1951,
+	1886,
+	1951,
+	1887,
+	1952,
+	1888,
+	1952,
+	1887,
+	1952,
+	1888,
+	1953,
+	1889,
+	1953,
+	1888,
+	1953,
+	1889,
+	1954,
+	1890,
+	1954,
+	1889,
+	1954,
+	1890,
+	1955,
+	1891,
+	1955,
+	1890,
+	1955,
+	1891,
+	1956,
+	1892,
+	1956,
+	1891,
+	1956,
+	1892,
+	1957,
+	1893,
+	1957,
+	1892,
+	1957,
+	1893,
+	1958,
+	1894,
+	1958,
+	1893,
+	1958,
+	1894,
+	1959,
+	1895,
+	1959,
+	1894,
+	1959,
+	1895,
+	1960,
+	1896,
+	1960,
+	1895,
+	1960,
+	1896,
+	1961,
+	1897,
+	1961,
+	1896,
+	1961,
+	1897,
+	1962,
+	1898,
+	1962,
+	1897,
+	1962,
+	1898,
+	1963,
+	1899,
+	1963,
+	1898,
+	1963,
+	1899,
+	1964,
+	1900,
+	1964,
+	1899,
+	1964,
+	1900,
+	1965,
+	1901,
+	1965,
+	1900,
+	1965,
+	1901,
+	1966,
+	1902,
+	1966,
+	1901,
+	1966,
+	1902,
+	1967,
+	1903,
+	1967,
+	1902,
+	1967,
+	1903,
+	1968,
+	1904,
+	1968,
+	1903,
+	1968,
+	1904,
+	1969,
+	1905,
+	1969,
+	1904,
+	1969,
+	1905,
+	1970,
+	1906,
+	1970,
+	1905,
+	1970,
+	1906,
+	1971,
+	1907,
+	1971,
+	1906,
+	1971,
+	1907,
+	1972,
+	1908,
+	1972,
+	1907,
+	1972,
+	1908,
+	1973,
+	1909,
+	1973,
+	1908,
+	1973,
+	1909,
+	1974,
+	1910,
+	1974,
+	1909,
+	1974,
+	1910,
+	1975,
+	1911,
+	1975,
+	1910,
+	1975,
+	1911,
+	1976,
+	1912,
+	1976,
+	1911,
+	1976,
+	1912,
+	1977,
+	1913,
+	1977,
+	1912,
+	1977,
+	1913,
+	1978,
+	1914,
+	1978,
+	1913,
+	1978,
+	1914,
+	1979,
+	1915,
+	1979,
+	1914,
+	1979,
+	1915,
+	1980,
+	1916,
+	1980,
+	1915,
+	1980,
+	1916,
+	1981,
+	1917,
+	1981,
+	1916,
+	1981,
+	1917,
+	1982,
+	1918,
+	1982,
+	1917,
+	1982,
+	1918,
+	1983,
+	1919,
+	1983,
+	1918,
+	1984,
+	1920,
+	1985,
+	1921,
+	1985,
+	1920,
+	1985,
+	1921,
+	1986,
+	1922,
+	1986,
+	1921,
+	1986,
+	1922,
+	1987,
+	1923,
+	1987,
+	1922,
+	1987,
+	1923,
+	1988,
+	1924,
+	1988,
+	1923,
+	1988,
+	1924,
+	1989,
+	1925,
+	1989,
+	1924,
+	1989,
+	1925,
+	1990,
+	1926,
+	1990,
+	1925,
+	1990,
+	1926,
+	1991,
+	1927,
+	1991,
+	1926,
+	1991,
+	1927,
+	1992,
+	1928,
+	1992,
+	1927,
+	1992,
+	1928,
+	1993,
+	1929,
+	1993,
+	1928,
+	1993,
+	1929,
+	1994,
+	1930,
+	1994,
+	1929,
+	1994,
+	1930,
+	1995,
+	1931,
+	1995,
+	1930,
+	1995,
+	1931,
+	1996,
+	1932,
+	1996,
+	1931,
+	1996,
+	1932,
+	1997,
+	1933,
+	1997,
+	1932,
+	1997,
+	1933,
+	1998,
+	1934,
+	1998,
+	1933,
+	1998,
+	1934,
+	1999,
+	1935,
+	1999,
+	1934,
+	1999,
+	1935,
+	2000,
+	1936,
+	2000,
+	1935,
+	2000,
+	1936,
+	2001,
+	1937,
+	2001,
+	1936,
+	2001,
+	1937,
+	2002,
+	1938,
+	2002,
+	1937,
+	2002,
+	1938,
+	2003,
+	1939,
+	2003,
+	1938,
+	2003,
+	1939,
+	2004,
+	1940,
+	2004,
+	1939,
+	2004,
+	1940,
+	2005,
+	1941,
+	2005,
+	1940,
+	2005,
+	1941,
+	2006,
+	1942,
+	2006,
+	1941,
+	2006,
+	1942,
+	2007,
+	1943,
+	2007,
+	1942,
+	2007,
+	1943,
+	2008,
+	1944,
+	2008,
+	1943,
+	2008,
+	1944,
+	2009,
+	1945,
+	2009,
+	1944,
+	2009,
+	1945,
+	2010,
+	1946,
+	2010,
+	1945,
+	2010,
+	1946,
+	2011,
+	1947,
+	2011,
+	1946,
+	2011,
+	1947,
+	2012,
+	1948,
+	2012,
+	1947,
+	2012,
+	1948,
+	2013,
+	1949,
+	2013,
+	1948,
+	2013,
+	1949,
+	2014,
+	1950,
+	2014,
+	1949,
+	2014,
+	1950,
+	2015,
+	1951,
+	2015,
+	1950,
+	2015,
+	1951,
+	2016,
+	1952,
+	2016,
+	1951,
+	2016,
+	1952,
+	2017,
+	1953,
+	2017,
+	1952,
+	2017,
+	1953,
+	2018,
+	1954,
+	2018,
+	1953,
+	2018,
+	1954,
+	2019,
+	1955,
+	2019,
+	1954,
+	2019,
+	1955,
+	2020,
+	1956,
+	2020,
+	1955,
+	2020,
+	1956,
+	2021,
+	1957,
+	2021,
+	1956,
+	2021,
+	1957,
+	2022,
+	1958,
+	2022,
+	1957,
+	2022,
+	1958,
+	2023,
+	1959,
+	2023,
+	1958,
+	2023,
+	1959,
+	2024,
+	1960,
+	2024,
+	1959,
+	2024,
+	1960,
+	2025,
+	1961,
+	2025,
+	1960,
+	2025,
+	1961,
+	2026,
+	1962,
+	2026,
+	1961,
+	2026,
+	1962,
+	2027,
+	1963,
+	2027,
+	1962,
+	2027,
+	1963,
+	2028,
+	1964,
+	2028,
+	1963,
+	2028,
+	1964,
+	2029,
+	1965,
+	2029,
+	1964,
+	2029,
+	1965,
+	2030,
+	1966,
+	2030,
+	1965,
+	2030,
+	1966,
+	2031,
+	1967,
+	2031,
+	1966,
+	2031,
+	1967,
+	2032,
+	1968,
+	2032,
+	1967,
+	2032,
+	1968,
+	2033,
+	1969,
+	2033,
+	1968,
+	2033,
+	1969,
+	2034,
+	1970,
+	2034,
+	1969,
+	2034,
+	1970,
+	2035,
+	1971,
+	2035,
+	1970,
+	2035,
+	1971,
+	2036,
+	1972,
+	2036,
+	1971,
+	2036,
+	1972,
+	2037,
+	1973,
+	2037,
+	1972,
+	2037,
+	1973,
+	2038,
+	1974,
+	2038,
+	1973,
+	2038,
+	1974,
+	2039,
+	1975,
+	2039,
+	1974,
+	2039,
+	1975,
+	2040,
+	1976,
+	2040,
+	1975,
+	2040,
+	1976,
+	2041,
+	1977,
+	2041,
+	1976,
+	2041,
+	1977,
+	2042,
+	1978,
+	2042,
+	1977,
+	2042,
+	1978,
+	2043,
+	1979,
+	2043,
+	1978,
+	2043,
+	1979,
+	2044,
+	1980,
+	2044,
+	1979,
+	2044,
+	1980,
+	2045,
+	1981,
+	2045,
+	1980,
+	2045,
+	1981,
+	2046,
+	1982,
+	2046,
+	1981,
+	2046,
+	1982,
+	2047,
+	1983,
+	2047,
+	1982,
+	2048,
+	1984,
+	2049,
+	1985,
+	2049,
+	1984,
+	2049,
+	1985,
+	2050,
+	1986,
+	2050,
+	1985,
+	2050,
+	1986,
+	2051,
+	1987,
+	2051,
+	1986,
+	2051,
+	1987,
+	2052,
+	1988,
+	2052,
+	1987,
+	2052,
+	1988,
+	2053,
+	1989,
+	2053,
+	1988,
+	2053,
+	1989,
+	2054,
+	1990,
+	2054,
+	1989,
+	2054,
+	1990,
+	2055,
+	1991,
+	2055,
+	1990,
+	2055,
+	1991,
+	2056,
+	1992,
+	2056,
+	1991,
+	2056,
+	1992,
+	2057,
+	1993,
+	2057,
+	1992,
+	2057,
+	1993,
+	2058,
+	1994,
+	2058,
+	1993,
+	2058,
+	1994,
+	2059,
+	1995,
+	2059,
+	1994,
+	2059,
+	1995,
+	2060,
+	1996,
+	2060,
+	1995,
+	2060,
+	1996,
+	2061,
+	1997,
+	2061,
+	1996,
+	2061,
+	1997,
+	2062,
+	1998,
+	2062,
+	1997,
+	2062,
+	1998,
+	2063,
+	1999,
+	2063,
+	1998,
+	2063,
+	1999,
+	2064,
+	2000,
+	2064,
+	1999,
+	2064,
+	2000,
+	2065,
+	2001,
+	2065,
+	2000,
+	2065,
+	2001,
+	2066,
+	2002,
+	2066,
+	2001,
+	2066,
+	2002,
+	2067,
+	2003,
+	2067,
+	2002,
+	2067,
+	2003,
+	2068,
+	2004,
+	2068,
+	2003,
+	2068,
+	2004,
+	2069,
+	2005,
+	2069,
+	2004,
+	2069,
+	2005,
+	2070,
+	2006,
+	2070,
+	2005,
+	2070,
+	2006,
+	2071,
+	2007,
+	2071,
+	2006,
+	2071,
+	2007,
+	2072,
+	2008,
+	2072,
+	2007,
+	2072,
+	2008,
+	2073,
+	2009,
+	2073,
+	2008,
+	2073,
+	2009,
+	2074,
+	2010,
+	2074,
+	2009,
+	2074,
+	2010,
+	2075,
+	2011,
+	2075,
+	2010,
+	2075,
+	2011,
+	2076,
+	2012,
+	2076,
+	2011,
+	2076,
+	2012,
+	2077,
+	2013,
+	2077,
+	2012,
+	2077,
+	2013,
+	2078,
+	2014,
+	2078,
+	2013,
+	2078,
+	2014,
+	2079,
+	2015,
+	2079,
+	2014,
+	2079,
+	2015,
+	2080,
+	2016,
+	2080,
+	2015,
+	2080,
+	2016,
+	2081,
+	2017,
+	2081,
+	2016,
+	2081,
+	2017,
+	2082,
+	2018,
+	2082,
+	2017,
+	2082,
+	2018,
+	2083,
+	2019,
+	2083,
+	2018,
+	2083,
+	2019,
+	2084,
+	2020,
+	2084,
+	2019,
+	2084,
+	2020,
+	2085,
+	2021,
+	2085,
+	2020,
+	2085,
+	2021,
+	2086,
+	2022,
+	2086,
+	2021,
+	2086,
+	2022,
+	2087,
+	2023,
+	2087,
+	2022,
+	2087,
+	2023,
+	2088,
+	2024,
+	2088,
+	2023,
+	2088,
+	2024,
+	2089,
+	2025,
+	2089,
+	2024,
+	2089,
+	2025,
+	2090,
+	2026,
+	2090,
+	2025,
+	2090,
+	2026,
+	2091,
+	2027,
+	2091,
+	2026,
+	2091,
+	2027,
+	2092,
+	2028,
+	2092,
+	2027,
+	2092,
+	2028,
+	2093,
+	2029,
+	2093,
+	2028,
+	2093,
+	2029,
+	2094,
+	2030,
+	2094,
+	2029,
+	2094,
+	2030,
+	2095,
+	2031,
+	2095,
+	2030,
+	2095,
+	2031,
+	2096,
+	2032,
+	2096,
+	2031,
+	2096,
+	2032,
+	2097,
+	2033,
+	2097,
+	2032,
+	2097,
+	2033,
+	2098,
+	2034,
+	2098,
+	2033,
+	2098,
+	2034,
+	2099,
+	2035,
+	2099,
+	2034,
+	2099,
+	2035,
+	2100,
+	2036,
+	2100,
+	2035,
+	2100,
+	2036,
+	2101,
+	2037,
+	2101,
+	2036,
+	2101,
+	2037,
+	2102,
+	2038,
+	2102,
+	2037,
+	2102,
+	2038,
+	2103,
+	2039,
+	2103,
+	2038,
+	2103,
+	2039,
+	2104,
+	2040,
+	2104,
+	2039,
+	2104,
+	2040,
+	2105,
+	2041,
+	2105,
+	2040,
+	2105,
+	2041,
+	2106,
+	2042,
+	2106,
+	2041,
+	2106,
+	2042,
+	2107,
+	2043,
+	2107,
+	2042,
+	2107,
+	2043,
+	2108,
+	2044,
+	2108,
+	2043,
+	2108,
+	2044,
+	2109,
+	2045,
+	2109,
+	2044,
+	2109,
+	2045,
+	2110,
+	2046,
+	2110,
+	2045,
+	2110,
+	2046,
+	2111,
+	2047,
+	2111,
+	2046,
+	2112,
+	2048,
+	2113,
+	2049,
+	2113,
+	2048,
+	2113,
+	2049,
+	2114,
+	2050,
+	2114,
+	2049,
+	2114,
+	2050,
+	2115,
+	2051,
+	2115,
+	2050,
+	2115,
+	2051,
+	2116,
+	2052,
+	2116,
+	2051,
+	2116,
+	2052,
+	2117,
+	2053,
+	2117,
+	2052,
+	2117,
+	2053,
+	2118,
+	2054,
+	2118,
+	2053,
+	2118,
+	2054,
+	2119,
+	2055,
+	2119,
+	2054,
+	2119,
+	2055,
+	2120,
+	2056,
+	2120,
+	2055,
+	2120,
+	2056,
+	2121,
+	2057,
+	2121,
+	2056,
+	2121,
+	2057,
+	2122,
+	2058,
+	2122,
+	2057,
+	2122,
+	2058,
+	2123,
+	2059,
+	2123,
+	2058,
+	2123,
+	2059,
+	2124,
+	2060,
+	2124,
+	2059,
+	2124,
+	2060,
+	2125,
+	2061,
+	2125,
+	2060,
+	2125,
+	2061,
+	2126,
+	2062,
+	2126,
+	2061,
+	2126,
+	2062,
+	2127,
+	2063,
+	2127,
+	2062,
+	2127,
+	2063,
+	2128,
+	2064,
+	2128,
+	2063,
+	2128,
+	2064,
+	2129,
+	2065,
+	2129,
+	2064,
+	2129,
+	2065,
+	2130,
+	2066,
+	2130,
+	2065,
+	2130,
+	2066,
+	2131,
+	2067,
+	2131,
+	2066,
+	2131,
+	2067,
+	2132,
+	2068,
+	2132,
+	2067,
+	2132,
+	2068,
+	2133,
+	2069,
+	2133,
+	2068,
+	2133,
+	2069,
+	2134,
+	2070,
+	2134,
+	2069,
+	2134,
+	2070,
+	2135,
+	2071,
+	2135,
+	2070,
+	2135,
+	2071,
+	2136,
+	2072,
+	2136,
+	2071,
+	2136,
+	2072,
+	2137,
+	2073,
+	2137,
+	2072,
+	2137,
+	2073,
+	2138,
+	2074,
+	2138,
+	2073,
+	2138,
+	2074,
+	2139,
+	2075,
+	2139,
+	2074,
+	2139,
+	2075,
+	2140,
+	2076,
+	2140,
+	2075,
+	2140,
+	2076,
+	2141,
+	2077,
+	2141,
+	2076,
+	2141,
+	2077,
+	2142,
+	2078,
+	2142,
+	2077,
+	2142,
+	2078,
+	2143,
+	2079,
+	2143,
+	2078,
+	2143,
+	2079,
+	2144,
+	2080,
+	2144,
+	2079,
+	2144,
+	2080,
+	2145,
+	2081,
+	2145,
+	2080,
+	2145,
+	2081,
+	2146,
+	2082,
+	2146,
+	2081,
+	2146,
+	2082,
+	2147,
+	2083,
+	2147,
+	2082,
+	2147,
+	2083,
+	2148,
+	2084,
+	2148,
+	2083,
+	2148,
+	2084,
+	2149,
+	2085,
+	2149,
+	2084,
+	2149,
+	2085,
+	2150,
+	2086,
+	2150,
+	2085,
+	2150,
+	2086,
+	2151,
+	2087,
+	2151,
+	2086,
+	2151,
+	2087,
+	2152,
+	2088,
+	2152,
+	2087,
+	2152,
+	2088,
+	2153,
+	2089,
+	2153,
+	2088,
+	2153,
+	2089,
+	2154,
+	2090,
+	2154,
+	2089,
+	2154,
+	2090,
+	2155,
+	2091,
+	2155,
+	2090,
+	2155,
+	2091,
+	2156,
+	2092,
+	2156,
+	2091,
+	2156,
+	2092,
+	2157,
+	2093,
+	2157,
+	2092,
+	2157,
+	2093,
+	2158,
+	2094,
+	2158,
+	2093,
+	2158,
+	2094,
+	2159,
+	2095,
+	2159,
+	2094,
+	2159,
+	2095,
+	2160,
+	2096,
+	2160,
+	2095,
+	2160,
+	2096,
+	2161,
+	2097,
+	2161,
+	2096,
+	2161,
+	2097,
+	2162,
+	2098,
+	2162,
+	2097,
+	2162,
+	2098,
+	2163,
+	2099,
+	2163,
+	2098,
+	2163,
+	2099,
+	2164,
+	2100,
+	2164,
+	2099,
+	2164,
+	2100,
+	2165,
+	2101,
+	2165,
+	2100,
+	2165,
+	2101,
+	2166,
+	2102,
+	2166,
+	2101,
+	2166,
+	2102,
+	2167,
+	2103,
+	2167,
+	2102,
+	2167,
+	2103,
+	2168,
+	2104,
+	2168,
+	2103,
+	2168,
+	2104,
+	2169,
+	2105,
+	2169,
+	2104,
+	2169,
+	2105,
+	2170,
+	2106,
+	2170,
+	2105,
+	2170,
+	2106,
+	2171,
+	2107,
+	2171,
+	2106,
+	2171,
+	2107,
+	2172,
+	2108,
+	2172,
+	2107,
+	2172,
+	2108,
+	2173,
+	2109,
+	2173,
+	2108,
+	2173,
+	2109,
+	2174,
+	2110,
+	2174,
+	2109,
+	2174,
+	2110,
+	2175,
+	2111,
+	2175,
+	2110,
+	2176,
+	2112,
+	2177,
+	2113,
+	2177,
+	2112,
+	2177,
+	2113,
+	2178,
+	2114,
+	2178,
+	2113,
+	2178,
+	2114,
+	2179,
+	2115,
+	2179,
+	2114,
+	2179,
+	2115,
+	2180,
+	2116,
+	2180,
+	2115,
+	2180,
+	2116,
+	2181,
+	2117,
+	2181,
+	2116,
+	2181,
+	2117,
+	2182,
+	2118,
+	2182,
+	2117,
+	2182,
+	2118,
+	2183,
+	2119,
+	2183,
+	2118,
+	2183,
+	2119,
+	2184,
+	2120,
+	2184,
+	2119,
+	2184,
+	2120,
+	2185,
+	2121,
+	2185,
+	2120,
+	2185,
+	2121,
+	2186,
+	2122,
+	2186,
+	2121,
+	2186,
+	2122,
+	2187,
+	2123,
+	2187,
+	2122,
+	2187,
+	2123,
+	2188,
+	2124,
+	2188,
+	2123,
+	2188,
+	2124,
+	2189,
+	2125,
+	2189,
+	2124,
+	2189,
+	2125,
+	2190,
+	2126,
+	2190,
+	2125,
+	2190,
+	2126,
+	2191,
+	2127,
+	2191,
+	2126,
+	2191,
+	2127,
+	2192,
+	2128,
+	2192,
+	2127,
+	2192,
+	2128,
+	2193,
+	2129,
+	2193,
+	2128,
+	2193,
+	2129,
+	2194,
+	2130,
+	2194,
+	2129,
+	2194,
+	2130,
+	2195,
+	2131,
+	2195,
+	2130,
+	2195,
+	2131,
+	2196,
+	2132,
+	2196,
+	2131,
+	2196,
+	2132,
+	2197,
+	2133,
+	2197,
+	2132,
+	2197,
+	2133,
+	2198,
+	2134,
+	2198,
+	2133,
+	2198,
+	2134,
+	2199,
+	2135,
+	2199,
+	2134,
+	2199,
+	2135,
+	2200,
+	2136,
+	2200,
+	2135,
+	2200,
+	2136,
+	2201,
+	2137,
+	2201,
+	2136,
+	2201,
+	2137,
+	2202,
+	2138,
+	2202,
+	2137,
+	2202,
+	2138,
+	2203,
+	2139,
+	2203,
+	2138,
+	2203,
+	2139,
+	2204,
+	2140,
+	2204,
+	2139,
+	2204,
+	2140,
+	2205,
+	2141,
+	2205,
+	2140,
+	2205,
+	2141,
+	2206,
+	2142,
+	2206,
+	2141,
+	2206,
+	2142,
+	2207,
+	2143,
+	2207,
+	2142,
+	2207,
+	2143,
+	2208,
+	2144,
+	2208,
+	2143,
+	2208,
+	2144,
+	2209,
+	2145,
+	2209,
+	2144,
+	2209,
+	2145,
+	2210,
+	2146,
+	2210,
+	2145,
+	2210,
+	2146,
+	2211,
+	2147,
+	2211,
+	2146,
+	2211,
+	2147,
+	2212,
+	2148,
+	2212,
+	2147,
+	2212,
+	2148,
+	2213,
+	2149,
+	2213,
+	2148,
+	2213,
+	2149,
+	2214,
+	2150,
+	2214,
+	2149,
+	2214,
+	2150,
+	2215,
+	2151,
+	2215,
+	2150,
+	2215,
+	2151,
+	2216,
+	2152,
+	2216,
+	2151,
+	2216,
+	2152,
+	2217,
+	2153,
+	2217,
+	2152,
+	2217,
+	2153,
+	2218,
+	2154,
+	2218,
+	2153,
+	2218,
+	2154,
+	2219,
+	2155,
+	2219,
+	2154,
+	2219,
+	2155,
+	2220,
+	2156,
+	2220,
+	2155,
+	2220,
+	2156,
+	2221,
+	2157,
+	2221,
+	2156,
+	2221,
+	2157,
+	2222,
+	2158,
+	2222,
+	2157,
+	2222,
+	2158,
+	2223,
+	2159,
+	2223,
+	2158,
+	2223,
+	2159,
+	2224,
+	2160,
+	2224,
+	2159,
+	2224,
+	2160,
+	2225,
+	2161,
+	2225,
+	2160,
+	2225,
+	2161,
+	2226,
+	2162,
+	2226,
+	2161,
+	2226,
+	2162,
+	2227,
+	2163,
+	2227,
+	2162,
+	2227,
+	2163,
+	2228,
+	2164,
+	2228,
+	2163,
+	2228,
+	2164,
+	2229,
+	2165,
+	2229,
+	2164,
+	2229,
+	2165,
+	2230,
+	2166,
+	2230,
+	2165,
+	2230,
+	2166,
+	2231,
+	2167,
+	2231,
+	2166,
+	2231,
+	2167,
+	2232,
+	2168,
+	2232,
+	2167,
+	2232,
+	2168,
+	2233,
+	2169,
+	2233,
+	2168,
+	2233,
+	2169,
+	2234,
+	2170,
+	2234,
+	2169,
+	2234,
+	2170,
+	2235,
+	2171,
+	2235,
+	2170,
+	2235,
+	2171,
+	2236,
+	2172,
+	2236,
+	2171,
+	2236,
+	2172,
+	2237,
+	2173,
+	2237,
+	2172,
+	2237,
+	2173,
+	2238,
+	2174,
+	2238,
+	2173,
+	2238,
+	2174,
+	2239,
+	2175,
+	2239,
+	2174,
+};
+
+#define Landscape08VtxCount 2178
+#define Landscape08IdxCount 12480
+
+btScalar Landscape08Vtx[] = {
+	-250.0f,
+	30.98f,
+	-128.906f,
+	-250.0f,
+	31.4025f,
+	-125.0f,
+	-246.094f,
+	31.7629f,
+	-128.906f,
+	-246.094f,
+	31.4165f,
+	-125.0f,
+	-242.188f,
+	32.5689f,
+	-128.906f,
+	-242.188f,
+	32.314f,
+	-125.0f,
+	-238.281f,
+	32.9125f,
+	-128.906f,
+	-238.281f,
+	32.9822f,
+	-125.0f,
+	-234.375f,
+	32.5915f,
+	-128.906f,
+	-234.375f,
+	32.6962f,
+	-125.0f,
+	-230.469f,
+	31.2708f,
+	-128.906f,
+	-230.469f,
+	31.3632f,
+	-125.0f,
+	-226.563f,
+	30.5212f,
+	-128.906f,
+	-226.563f,
+	29.4391f,
+	-125.0f,
+	-222.656f,
+	30.2031f,
+	-128.906f,
+	-222.656f,
+	29.519f,
+	-125.0f,
+	-218.75f,
+	30.4582f,
+	-128.906f,
+	-218.75f,
+	29.4481f,
+	-125.0f,
+	-214.844f,
+	30.6941f,
+	-128.906f,
+	-214.844f,
+	29.8481f,
+	-125.0f,
+	-210.938f,
+	30.5035f,
+	-128.906f,
+	-210.938f,
+	30.408f,
+	-125.0f,
+	-207.031f,
+	30.2726f,
+	-128.906f,
+	-207.031f,
+	30.291f,
+	-125.0f,
+	-203.125f,
+	29.38f,
+	-128.906f,
+	-203.125f,
+	28.7473f,
+	-125.0f,
+	-199.219f,
+	28.6973f,
+	-128.906f,
+	-199.219f,
+	28.1816f,
+	-125.0f,
+	-195.313f,
+	27.9768f,
+	-128.906f,
+	-195.313f,
+	27.2839f,
+	-125.0f,
+	-191.406f,
+	26.1169f,
+	-128.906f,
+	-191.406f,
+	25.7018f,
+	-125.0f,
+	-187.5f,
+	23.8648f,
+	-128.906f,
+	-187.5f,
+	23.2882f,
+	-125.0f,
+	-183.594f,
+	21.95f,
+	-128.906f,
+	-183.594f,
+	22.1614f,
+	-125.0f,
+	-179.688f,
+	19.6798f,
+	-128.906f,
+	-179.688f,
+	20.658f,
+	-125.0f,
+	-175.781f,
+	17.3507f,
+	-128.906f,
+	-175.781f,
+	18.8433f,
+	-125.0f,
+	-171.875f,
+	15.7914f,
+	-128.906f,
+	-171.875f,
+	16.364f,
+	-125.0f,
+	-167.969f,
+	14.3745f,
+	-128.906f,
+	-167.969f,
+	14.7298f,
+	-125.0f,
+	-164.063f,
+	12.4911f,
+	-128.906f,
+	-164.063f,
+	12.9859f,
+	-125.0f,
+	-160.156f,
+	11.0533f,
+	-128.906f,
+	-160.156f,
+	11.3306f,
+	-125.0f,
+	-156.25f,
+	9.15062f,
+	-128.906f,
+	-156.25f,
+	10.1916f,
+	-125.0f,
+	-152.344f,
+	6.68059f,
+	-128.906f,
+	-152.344f,
+	8.3967f,
+	-125.0f,
+	-148.438f,
+	5.57112f,
+	-128.906f,
+	-148.438f,
+	6.23292f,
+	-125.0f,
+	-144.531f,
+	5.2271f,
+	-128.906f,
+	-144.531f,
+	5.48985f,
+	-125.0f,
+	-140.625f,
+	5.87576f,
+	-128.906f,
+	-140.625f,
+	5.18276f,
+	-125.0f,
+	-136.719f,
+	6.85614f,
+	-128.906f,
+	-136.719f,
+	5.56059f,
+	-125.0f,
+	-132.813f,
+	6.86087f,
+	-128.906f,
+	-132.813f,
+	5.75157f,
+	-125.0f,
+	-128.906f,
+	7.10341f,
+	-128.906f,
+	-128.906f,
+	5.32154f,
+	-125.0f,
+	-125.0f,
+	7.54727f,
+	-128.906f,
+	-125.0f,
+	6.15672f,
+	-125.0f,
+	-121.094f,
+	8.02225f,
+	-128.906f,
+	-121.094f,
+	7.53373f,
+	-125.0f,
+	-117.188f,
+	8.70065f,
+	-128.906f,
+	-117.188f,
+	8.38676f,
+	-125.0f,
+	-113.281f,
+	9.39689f,
+	-128.906f,
+	-113.281f,
+	8.64274f,
+	-125.0f,
+	-109.375f,
+	8.80449f,
+	-128.906f,
+	-109.375f,
+	8.49941f,
+	-125.0f,
+	-105.469f,
+	9.43366f,
+	-128.906f,
+	-105.469f,
+	9.24481f,
+	-125.0f,
+	-101.563f,
+	10.868f,
+	-128.906f,
+	-101.563f,
+	11.5178f,
+	-125.0f,
+	-97.6563f,
+	12.8404f,
+	-128.906f,
+	-97.6563f,
+	13.4113f,
+	-125.0f,
+	-93.75f,
+	14.8214f,
+	-128.906f,
+	-93.75f,
+	15.4997f,
+	-125.0f,
+	-89.8438f,
+	16.618f,
+	-128.906f,
+	-89.8438f,
+	17.3502f,
+	-125.0f,
+	-85.9375f,
+	20.2496f,
+	-128.906f,
+	-85.9375f,
+	20.8168f,
+	-125.0f,
+	-82.0313f,
+	23.697f,
+	-128.906f,
+	-82.0313f,
+	24.9405f,
+	-125.0f,
+	-78.125f,
+	26.4451f,
+	-128.906f,
+	-78.125f,
+	27.8681f,
+	-125.0f,
+	-74.2188f,
+	28.7901f,
+	-128.906f,
+	-74.2188f,
+	30.1495f,
+	-125.0f,
+	-70.3125f,
+	31.4052f,
+	-128.906f,
+	-70.3125f,
+	32.4402f,
+	-125.0f,
+	-66.4063f,
+	33.3106f,
+	-128.906f,
+	-66.4063f,
+	34.2537f,
+	-125.0f,
+	-62.5f,
+	35.8538f,
+	-128.906f,
+	-62.5f,
+	36.5623f,
+	-125.0f,
+	-58.5938f,
+	37.9798f,
+	-128.906f,
+	-58.5938f,
+	38.9027f,
+	-125.0f,
+	-54.6875f,
+	39.4006f,
+	-128.906f,
+	-54.6875f,
+	40.1192f,
+	-125.0f,
+	-50.7813f,
+	40.6584f,
+	-128.906f,
+	-50.7813f,
+	41.9393f,
+	-125.0f,
+	-46.875f,
+	40.8896f,
+	-128.906f,
+	-46.875f,
+	41.8765f,
+	-125.0f,
+	-42.9688f,
+	39.9544f,
+	-128.906f,
+	-42.9688f,
+	41.6371f,
+	-125.0f,
+	-39.0625f,
+	40.0893f,
+	-128.906f,
+	-39.0625f,
+	41.6432f,
+	-125.0f,
+	-35.1563f,
+	39.3183f,
+	-128.906f,
+	-35.1563f,
+	41.2852f,
+	-125.0f,
+	-31.25f,
+	39.8575f,
+	-128.906f,
+	-31.25f,
+	41.5629f,
+	-125.0f,
+	-27.3438f,
+	41.5378f,
+	-128.906f,
+	-27.3438f,
+	42.2956f,
+	-125.0f,
+	-23.4375f,
+	44.0561f,
+	-128.906f,
+	-23.4375f,
+	43.9719f,
+	-125.0f,
+	-19.5313f,
+	45.4298f,
+	-128.906f,
+	-19.5313f,
+	46.2232f,
+	-125.0f,
+	-15.625f,
+	47.4474f,
+	-128.906f,
+	-15.625f,
+	47.3104f,
+	-125.0f,
+	-11.7188f,
+	48.0018f,
+	-128.906f,
+	-11.7188f,
+	47.5943f,
+	-125.0f,
+	-7.8125f,
+	48.0717f,
+	-128.906f,
+	-7.8125f,
+	49.1192f,
+	-125.0f,
+	-3.90625f,
+	48.7253f,
+	-128.906f,
+	-3.90625f,
+	49.6341f,
+	-125.0f,
+	0.0f,
+	49.8f,
+	-128.906f,
+	0.0f,
+	50.3481f,
+	-125.0f,
+	3.90625f,
+	50.4716f,
+	-128.906f,
+	3.90625f,
+	50.3021f,
+	-125.0f,
+	-250.0f,
+	31.1145f,
+	-132.813f,
+	-246.094f,
+	31.857f,
+	-132.813f,
+	-242.188f,
+	32.7446f,
+	-132.813f,
+	-238.281f,
+	33.1734f,
+	-132.813f,
+	-234.375f,
+	32.1952f,
+	-132.813f,
+	-230.469f,
+	31.8959f,
+	-132.813f,
+	-226.563f,
+	32.1326f,
+	-132.813f,
+	-222.656f,
+	32.1631f,
+	-132.813f,
+	-218.75f,
+	31.3795f,
+	-132.813f,
+	-214.844f,
+	30.9888f,
+	-132.813f,
+	-210.938f,
+	30.5577f,
+	-132.813f,
+	-207.031f,
+	30.1392f,
+	-132.813f,
+	-203.125f,
+	29.8482f,
+	-132.813f,
+	-199.219f,
+	28.5903f,
+	-132.813f,
+	-195.313f,
+	27.4671f,
+	-132.813f,
+	-191.406f,
+	25.5032f,
+	-132.813f,
+	-187.5f,
+	23.2799f,
+	-132.813f,
+	-183.594f,
+	21.2846f,
+	-132.813f,
+	-179.688f,
+	19.3954f,
+	-132.813f,
+	-175.781f,
+	18.1112f,
+	-132.813f,
+	-171.875f,
+	16.3831f,
+	-132.813f,
+	-167.969f,
+	14.5038f,
+	-132.813f,
+	-164.063f,
+	12.8109f,
+	-132.813f,
+	-160.156f,
+	10.386f,
+	-132.813f,
+	-156.25f,
+	7.93486f,
+	-132.813f,
+	-152.344f,
+	7.25449f,
+	-132.813f,
+	-148.438f,
+	6.19974f,
+	-132.813f,
+	-144.531f,
+	5.89578f,
+	-132.813f,
+	-140.625f,
+	6.61884f,
+	-132.813f,
+	-136.719f,
+	7.53382f,
+	-132.813f,
+	-132.813f,
+	8.21024f,
+	-132.813f,
+	-128.906f,
+	8.74115f,
+	-132.813f,
+	-125.0f,
+	8.97047f,
+	-132.813f,
+	-121.094f,
+	9.41307f,
+	-132.813f,
+	-117.188f,
+	10.0468f,
+	-132.813f,
+	-113.281f,
+	9.47404f,
+	-132.813f,
+	-109.375f,
+	9.418f,
+	-132.813f,
+	-105.469f,
+	10.3176f,
+	-132.813f,
+	-101.563f,
+	11.3001f,
+	-132.813f,
+	-97.6563f,
+	12.5318f,
+	-132.813f,
+	-93.75f,
+	14.6986f,
+	-132.813f,
+	-89.8438f,
+	16.6495f,
+	-132.813f,
+	-85.9375f,
+	19.1906f,
+	-132.813f,
+	-82.0313f,
+	23.4349f,
+	-132.813f,
+	-78.125f,
+	26.1629f,
+	-132.813f,
+	-74.2188f,
+	28.739f,
+	-132.813f,
+	-70.3125f,
+	31.1271f,
+	-132.813f,
+	-66.4063f,
+	32.2452f,
+	-132.813f,
+	-62.5f,
+	34.0303f,
+	-132.813f,
+	-58.5938f,
+	36.1234f,
+	-132.813f,
+	-54.6875f,
+	38.3054f,
+	-132.813f,
+	-50.7813f,
+	38.7936f,
+	-132.813f,
+	-46.875f,
+	39.1319f,
+	-132.813f,
+	-42.9688f,
+	39.1462f,
+	-132.813f,
+	-39.0625f,
+	38.4732f,
+	-132.813f,
+	-35.1563f,
+	38.3061f,
+	-132.813f,
+	-31.25f,
+	39.4999f,
+	-132.813f,
+	-27.3438f,
+	41.8953f,
+	-132.813f,
+	-23.4375f,
+	43.2645f,
+	-132.813f,
+	-19.5313f,
+	44.7736f,
+	-132.813f,
+	-15.625f,
+	46.2491f,
+	-132.813f,
+	-11.7188f,
+	47.4527f,
+	-132.813f,
+	-7.8125f,
+	47.1407f,
+	-132.813f,
+	-3.90625f,
+	48.0628f,
+	-132.813f,
+	0.0f,
+	48.5651f,
+	-132.813f,
+	3.90625f,
+	49.1054f,
+	-132.813f,
+	-250.0f,
+	30.7461f,
+	-136.719f,
+	-246.094f,
+	30.8483f,
+	-136.719f,
+	-242.188f,
+	32.188f,
+	-136.719f,
+	-238.281f,
+	33.149f,
+	-136.719f,
+	-234.375f,
+	32.3165f,
+	-136.719f,
+	-230.469f,
+	32.613f,
+	-136.719f,
+	-226.563f,
+	33.3246f,
+	-136.719f,
+	-222.656f,
+	32.6429f,
+	-136.719f,
+	-218.75f,
+	31.8882f,
+	-136.719f,
+	-214.844f,
+	31.5125f,
+	-136.719f,
+	-210.938f,
+	30.2065f,
+	-136.719f,
+	-207.031f,
+	30.0024f,
+	-136.719f,
+	-203.125f,
+	29.5699f,
+	-136.719f,
+	-199.219f,
+	28.1245f,
+	-136.719f,
+	-195.313f,
+	26.764f,
+	-136.719f,
+	-191.406f,
+	24.8025f,
+	-136.719f,
+	-187.5f,
+	22.7863f,
+	-136.719f,
+	-183.594f,
+	21.0979f,
+	-136.719f,
+	-179.688f,
+	19.5742f,
+	-136.719f,
+	-175.781f,
+	17.9263f,
+	-136.719f,
+	-171.875f,
+	16.0908f,
+	-136.719f,
+	-167.969f,
+	14.6542f,
+	-136.719f,
+	-164.063f,
+	12.4534f,
+	-136.719f,
+	-160.156f,
+	9.93763f,
+	-136.719f,
+	-156.25f,
+	7.87486f,
+	-136.719f,
+	-152.344f,
+	7.06627f,
+	-136.719f,
+	-148.438f,
+	6.22453f,
+	-136.719f,
+	-144.531f,
+	6.39864f,
+	-136.719f,
+	-140.625f,
+	7.02103f,
+	-136.719f,
+	-136.719f,
+	7.85488f,
+	-136.719f,
+	-132.813f,
+	9.33235f,
+	-136.719f,
+	-128.906f,
+	10.546f,
+	-136.719f,
+	-125.0f,
+	10.1958f,
+	-136.719f,
+	-121.094f,
+	9.85385f,
+	-136.719f,
+	-117.188f,
+	10.2437f,
+	-136.719f,
+	-113.281f,
+	9.95341f,
+	-136.719f,
+	-109.375f,
+	9.05387f,
+	-136.719f,
+	-105.469f,
+	10.3384f,
+	-136.719f,
+	-101.563f,
+	11.2859f,
+	-136.719f,
+	-97.6563f,
+	12.3544f,
+	-136.719f,
+	-93.75f,
+	14.0582f,
+	-136.719f,
+	-89.8438f,
+	15.9772f,
+	-136.719f,
+	-85.9375f,
+	18.8673f,
+	-136.719f,
+	-82.0313f,
+	22.2278f,
+	-136.719f,
+	-78.125f,
+	25.0468f,
+	-136.719f,
+	-74.2188f,
+	27.6452f,
+	-136.719f,
+	-70.3125f,
+	29.155f,
+	-136.719f,
+	-66.4063f,
+	30.7457f,
+	-136.719f,
+	-62.5f,
+	32.6722f,
+	-136.719f,
+	-58.5938f,
+	34.5222f,
+	-136.719f,
+	-54.6875f,
+	36.3904f,
+	-136.719f,
+	-50.7813f,
+	36.1946f,
+	-136.719f,
+	-46.875f,
+	36.5194f,
+	-136.719f,
+	-42.9688f,
+	36.2715f,
+	-136.719f,
+	-39.0625f,
+	36.4185f,
+	-136.719f,
+	-35.1563f,
+	37.1668f,
+	-136.719f,
+	-31.25f,
+	38.3933f,
+	-136.719f,
+	-27.3438f,
+	40.8416f,
+	-136.719f,
+	-23.4375f,
+	42.7243f,
+	-136.719f,
+	-19.5313f,
+	43.7567f,
+	-136.719f,
+	-15.625f,
+	44.7705f,
+	-136.719f,
+	-11.7188f,
+	45.3267f,
+	-136.719f,
+	-7.8125f,
+	46.433f,
+	-136.719f,
+	-3.90625f,
+	47.3134f,
+	-136.719f,
+	0.0f,
+	48.4146f,
+	-136.719f,
+	3.90625f,
+	47.9f,
+	-136.719f,
+	-250.0f,
+	29.1575f,
+	-140.625f,
+	-246.094f,
+	30.5173f,
+	-140.625f,
+	-242.188f,
+	31.576f,
+	-140.625f,
+	-238.281f,
+	31.6992f,
+	-140.625f,
+	-234.375f,
+	32.9063f,
+	-140.625f,
+	-230.469f,
+	33.2752f,
+	-140.625f,
+	-226.563f,
+	32.8003f,
+	-140.625f,
+	-222.656f,
+	33.133f,
+	-140.625f,
+	-218.75f,
+	32.0543f,
+	-140.625f,
+	-214.844f,
+	31.2672f,
+	-140.625f,
+	-210.938f,
+	30.2378f,
+	-140.625f,
+	-207.031f,
+	29.601f,
+	-140.625f,
+	-203.125f,
+	28.4643f,
+	-140.625f,
+	-199.219f,
+	26.8711f,
+	-140.625f,
+	-195.313f,
+	24.936f,
+	-140.625f,
+	-191.406f,
+	22.9115f,
+	-140.625f,
+	-187.5f,
+	21.8507f,
+	-140.625f,
+	-183.594f,
+	20.4435f,
+	-140.625f,
+	-179.688f,
+	18.4455f,
+	-140.625f,
+	-175.781f,
+	17.1667f,
+	-140.625f,
+	-171.875f,
+	15.2077f,
+	-140.625f,
+	-167.969f,
+	13.4799f,
+	-140.625f,
+	-164.063f,
+	11.7723f,
+	-140.625f,
+	-160.156f,
+	9.26955f,
+	-140.625f,
+	-156.25f,
+	7.56528f,
+	-140.625f,
+	-152.344f,
+	6.4244f,
+	-140.625f,
+	-148.438f,
+	6.60539f,
+	-140.625f,
+	-144.531f,
+	6.44163f,
+	-140.625f,
+	-140.625f,
+	6.55017f,
+	-140.625f,
+	-136.719f,
+	7.62805f,
+	-140.625f,
+	-132.813f,
+	9.20726f,
+	-140.625f,
+	-128.906f,
+	10.5063f,
+	-140.625f,
+	-125.0f,
+	10.6867f,
+	-140.625f,
+	-121.094f,
+	9.3702f,
+	-140.625f,
+	-117.188f,
+	9.53484f,
+	-140.625f,
+	-113.281f,
+	8.855f,
+	-140.625f,
+	-109.375f,
+	9.3082f,
+	-140.625f,
+	-105.469f,
+	9.67718f,
+	-140.625f,
+	-101.563f,
+	10.5233f,
+	-140.625f,
+	-97.6563f,
+	11.8026f,
+	-140.625f,
+	-93.75f,
+	13.1675f,
+	-140.625f,
+	-89.8438f,
+	15.253f,
+	-140.625f,
+	-85.9375f,
+	18.1074f,
+	-140.625f,
+	-82.0313f,
+	20.8004f,
+	-140.625f,
+	-78.125f,
+	23.7651f,
+	-140.625f,
+	-74.2188f,
+	25.7067f,
+	-140.625f,
+	-70.3125f,
+	27.5126f,
+	-140.625f,
+	-66.4063f,
+	29.8191f,
+	-140.625f,
+	-62.5f,
+	31.7367f,
+	-140.625f,
+	-58.5938f,
+	32.8891f,
+	-140.625f,
+	-54.6875f,
+	34.0989f,
+	-140.625f,
+	-50.7813f,
+	34.6645f,
+	-140.625f,
+	-46.875f,
+	34.0325f,
+	-140.625f,
+	-42.9688f,
+	33.7773f,
+	-140.625f,
+	-39.0625f,
+	34.1723f,
+	-140.625f,
+	-35.1563f,
+	36.0861f,
+	-140.625f,
+	-31.25f,
+	38.8562f,
+	-140.625f,
+	-27.3438f,
+	40.5684f,
+	-140.625f,
+	-23.4375f,
+	42.6832f,
+	-140.625f,
+	-19.5313f,
+	43.505f,
+	-140.625f,
+	-15.625f,
+	43.7197f,
+	-140.625f,
+	-11.7188f,
+	43.8656f,
+	-140.625f,
+	-7.8125f,
+	45.6272f,
+	-140.625f,
+	-3.90625f,
+	46.7713f,
+	-140.625f,
+	0.0f,
+	47.1255f,
+	-140.625f,
+	3.90625f,
+	47.2681f,
+	-140.625f,
+	-250.0f,
+	28.3388f,
+	-144.531f,
+	-246.094f,
+	29.5689f,
+	-144.531f,
+	-242.188f,
+	30.0422f,
+	-144.531f,
+	-238.281f,
+	30.6319f,
+	-144.531f,
+	-234.375f,
+	32.5914f,
+	-144.531f,
+	-230.469f,
+	33.306f,
+	-144.531f,
+	-226.563f,
+	32.9265f,
+	-144.531f,
+	-222.656f,
+	32.5363f,
+	-144.531f,
+	-218.75f,
+	31.8845f,
+	-144.531f,
+	-214.844f,
+	31.7429f,
+	-144.531f,
+	-210.938f,
+	29.6521f,
+	-144.531f,
+	-207.031f,
+	28.3301f,
+	-144.531f,
+	-203.125f,
+	26.8166f,
+	-144.531f,
+	-199.219f,
+	25.0756f,
+	-144.531f,
+	-195.313f,
+	23.0988f,
+	-144.531f,
+	-191.406f,
+	21.2037f,
+	-144.531f,
+	-187.5f,
+	20.271f,
+	-144.531f,
+	-183.594f,
+	18.4189f,
+	-144.531f,
+	-179.688f,
+	16.2352f,
+	-144.531f,
+	-175.781f,
+	14.734f,
+	-144.531f,
+	-171.875f,
+	13.9522f,
+	-144.531f,
+	-167.969f,
+	12.543f,
+	-144.531f,
+	-164.063f,
+	10.6335f,
+	-144.531f,
+	-160.156f,
+	8.53885f,
+	-144.531f,
+	-156.25f,
+	7.32299f,
+	-144.531f,
+	-152.344f,
+	6.69849f,
+	-144.531f,
+	-148.438f,
+	5.37792f,
+	-144.531f,
+	-144.531f,
+	5.52557f,
+	-144.531f,
+	-140.625f,
+	5.94721f,
+	-144.531f,
+	-136.719f,
+	7.15949f,
+	-144.531f,
+	-132.813f,
+	8.5533f,
+	-144.531f,
+	-128.906f,
+	9.68048f,
+	-144.531f,
+	-125.0f,
+	9.80421f,
+	-144.531f,
+	-121.094f,
+	9.67052f,
+	-144.531f,
+	-117.188f,
+	9.82889f,
+	-144.531f,
+	-113.281f,
+	9.40895f,
+	-144.531f,
+	-109.375f,
+	9.53728f,
+	-144.531f,
+	-105.469f,
+	9.89567f,
+	-144.531f,
+	-101.563f,
+	10.4472f,
+	-144.531f,
+	-97.6563f,
+	11.3813f,
+	-144.531f,
+	-93.75f,
+	13.6687f,
+	-144.531f,
+	-89.8438f,
+	15.6897f,
+	-144.531f,
+	-85.9375f,
+	17.6694f,
+	-144.531f,
+	-82.0313f,
+	20.0542f,
+	-144.531f,
+	-78.125f,
+	22.2881f,
+	-144.531f,
+	-74.2188f,
+	24.021f,
+	-144.531f,
+	-70.3125f,
+	26.6221f,
+	-144.531f,
+	-66.4063f,
+	28.7647f,
+	-144.531f,
+	-62.5f,
+	31.0025f,
+	-144.531f,
+	-58.5938f,
+	31.9212f,
+	-144.531f,
+	-54.6875f,
+	32.1124f,
+	-144.531f,
+	-50.7813f,
+	33.4656f,
+	-144.531f,
+	-46.875f,
+	33.5412f,
+	-144.531f,
+	-42.9688f,
+	33.5562f,
+	-144.531f,
+	-39.0625f,
+	34.3563f,
+	-144.531f,
+	-35.1563f,
+	36.2482f,
+	-144.531f,
+	-31.25f,
+	37.99f,
+	-144.531f,
+	-27.3438f,
+	40.3527f,
+	-144.531f,
+	-23.4375f,
+	42.4204f,
+	-144.531f,
+	-19.5313f,
+	44.0f,
+	-144.531f,
+	-15.625f,
+	44.183f,
+	-144.531f,
+	-11.7188f,
+	44.0185f,
+	-144.531f,
+	-7.8125f,
+	45.08f,
+	-144.531f,
+	-3.90625f,
+	45.5784f,
+	-144.531f,
+	0.0f,
+	44.8122f,
+	-144.531f,
+	3.90625f,
+	45.2398f,
+	-144.531f,
+	-250.0f,
+	27.5165f,
+	-148.438f,
+	-246.094f,
+	28.4707f,
+	-148.438f,
+	-242.188f,
+	28.8693f,
+	-148.438f,
+	-238.281f,
+	29.8936f,
+	-148.438f,
+	-234.375f,
+	30.9982f,
+	-148.438f,
+	-230.469f,
+	31.9158f,
+	-148.438f,
+	-226.563f,
+	33.0887f,
+	-148.438f,
+	-222.656f,
+	32.141f,
+	-148.438f,
+	-218.75f,
+	31.0388f,
+	-148.438f,
+	-214.844f,
+	30.5599f,
+	-148.438f,
+	-210.938f,
+	29.1269f,
+	-148.438f,
+	-207.031f,
+	26.6179f,
+	-148.438f,
+	-203.125f,
+	25.2859f,
+	-148.438f,
+	-199.219f,
+	23.1182f,
+	-148.438f,
+	-195.313f,
+	21.139f,
+	-148.438f,
+	-191.406f,
+	19.7044f,
+	-148.438f,
+	-187.5f,
+	18.4387f,
+	-148.438f,
+	-183.594f,
+	17.6363f,
+	-148.438f,
+	-179.688f,
+	15.8724f,
+	-148.438f,
+	-175.781f,
+	14.454f,
+	-148.438f,
+	-171.875f,
+	13.2052f,
+	-148.438f,
+	-167.969f,
+	11.7702f,
+	-148.438f,
+	-164.063f,
+	10.4965f,
+	-148.438f,
+	-160.156f,
+	8.29165f,
+	-148.438f,
+	-156.25f,
+	7.24803f,
+	-148.438f,
+	-152.344f,
+	6.79621f,
+	-148.438f,
+	-148.438f,
+	5.48372f,
+	-148.438f,
+	-144.531f,
+	4.11362f,
+	-148.438f,
+	-140.625f,
+	4.6586f,
+	-148.438f,
+	-136.719f,
+	6.20081f,
+	-148.438f,
+	-132.813f,
+	7.67687f,
+	-148.438f,
+	-128.906f,
+	9.0742f,
+	-148.438f,
+	-125.0f,
+	8.8028f,
+	-148.438f,
+	-121.094f,
+	9.309f,
+	-148.438f,
+	-117.188f,
+	9.26616f,
+	-148.438f,
+	-113.281f,
+	9.88711f,
+	-148.438f,
+	-109.375f,
+	9.19023f,
+	-148.438f,
+	-105.469f,
+	9.46828f,
+	-148.438f,
+	-101.563f,
+	10.1584f,
+	-148.438f,
+	-97.6563f,
+	11.2649f,
+	-148.438f,
+	-93.75f,
+	13.476f,
+	-148.438f,
+	-89.8438f,
+	15.8318f,
+	-148.438f,
+	-85.9375f,
+	17.6136f,
+	-148.438f,
+	-82.0313f,
+	18.7495f,
+	-148.438f,
+	-78.125f,
+	20.5385f,
+	-148.438f,
+	-74.2188f,
+	23.5666f,
+	-148.438f,
+	-70.3125f,
+	26.2836f,
+	-148.438f,
+	-66.4063f,
+	28.729f,
+	-148.438f,
+	-62.5f,
+	30.3854f,
+	-148.438f,
+	-58.5938f,
+	30.9909f,
+	-148.438f,
+	-54.6875f,
+	31.4288f,
+	-148.438f,
+	-50.7813f,
+	31.916f,
+	-148.438f,
+	-46.875f,
+	32.4745f,
+	-148.438f,
+	-42.9688f,
+	32.0881f,
+	-148.438f,
+	-39.0625f,
+	34.0231f,
+	-148.438f,
+	-35.1563f,
+	35.6432f,
+	-148.438f,
+	-31.25f,
+	37.6278f,
+	-148.438f,
+	-27.3438f,
+	39.652f,
+	-148.438f,
+	-23.4375f,
+	42.3336f,
+	-148.438f,
+	-19.5313f,
+	43.3336f,
+	-148.438f,
+	-15.625f,
+	43.9329f,
+	-148.438f,
+	-11.7188f,
+	43.8742f,
+	-148.438f,
+	-7.8125f,
+	44.336f,
+	-148.438f,
+	-3.90625f,
+	44.2738f,
+	-148.438f,
+	0.0f,
+	42.6429f,
+	-148.438f,
+	3.90625f,
+	43.4167f,
+	-148.438f,
+	-250.0f,
+	27.7654f,
+	-152.344f,
+	-246.094f,
+	28.2588f,
+	-152.344f,
+	-242.188f,
+	28.0365f,
+	-152.344f,
+	-238.281f,
+	29.4531f,
+	-152.344f,
+	-234.375f,
+	31.8507f,
+	-152.344f,
+	-230.469f,
+	31.9987f,
+	-152.344f,
+	-226.563f,
+	32.2635f,
+	-152.344f,
+	-222.656f,
+	32.4573f,
+	-152.344f,
+	-218.75f,
+	30.3791f,
+	-152.344f,
+	-214.844f,
+	29.1133f,
+	-152.344f,
+	-210.938f,
+	27.6466f,
+	-152.344f,
+	-207.031f,
+	25.5524f,
+	-152.344f,
+	-203.125f,
+	23.857f,
+	-152.344f,
+	-199.219f,
+	21.724f,
+	-152.344f,
+	-195.313f,
+	19.9592f,
+	-152.344f,
+	-191.406f,
+	18.6648f,
+	-152.344f,
+	-187.5f,
+	17.3913f,
+	-152.344f,
+	-183.594f,
+	17.3113f,
+	-152.344f,
+	-179.688f,
+	15.8776f,
+	-152.344f,
+	-175.781f,
+	13.7968f,
+	-152.344f,
+	-171.875f,
+	11.9961f,
+	-152.344f,
+	-167.969f,
+	10.9315f,
+	-152.344f,
+	-164.063f,
+	9.24337f,
+	-152.344f,
+	-160.156f,
+	7.95749f,
+	-152.344f,
+	-156.25f,
+	6.95525f,
+	-152.344f,
+	-152.344f,
+	6.523f,
+	-152.344f,
+	-148.438f,
+	5.62313f,
+	-152.344f,
+	-144.531f,
+	4.31939f,
+	-152.344f,
+	-140.625f,
+	3.1203f,
+	-152.344f,
+	-136.719f,
+	4.98713f,
+	-152.344f,
+	-132.813f,
+	6.64544f,
+	-152.344f,
+	-128.906f,
+	7.48658f,
+	-152.344f,
+	-125.0f,
+	8.08424f,
+	-152.344f,
+	-121.094f,
+	8.96562f,
+	-152.344f,
+	-117.188f,
+	9.10159f,
+	-152.344f,
+	-113.281f,
+	9.38004f,
+	-152.344f,
+	-109.375f,
+	8.97581f,
+	-152.344f,
+	-105.469f,
+	8.78511f,
+	-152.344f,
+	-101.563f,
+	9.76846f,
+	-152.344f,
+	-97.6563f,
+	10.4299f,
+	-152.344f,
+	-93.75f,
+	13.6059f,
+	-152.344f,
+	-89.8438f,
+	16.3193f,
+	-152.344f,
+	-85.9375f,
+	17.6959f,
+	-152.344f,
+	-82.0313f,
+	18.5545f,
+	-152.344f,
+	-78.125f,
+	20.1179f,
+	-152.344f,
+	-74.2188f,
+	22.929f,
+	-152.344f,
+	-70.3125f,
+	25.8413f,
+	-152.344f,
+	-66.4063f,
+	28.4214f,
+	-152.344f,
+	-62.5f,
+	30.0187f,
+	-152.344f,
+	-58.5938f,
+	30.4285f,
+	-152.344f,
+	-54.6875f,
+	30.9236f,
+	-152.344f,
+	-50.7813f,
+	31.3519f,
+	-152.344f,
+	-46.875f,
+	31.0939f,
+	-152.344f,
+	-42.9688f,
+	30.2517f,
+	-152.344f,
+	-39.0625f,
+	32.8953f,
+	-152.344f,
+	-35.1563f,
+	34.6998f,
+	-152.344f,
+	-31.25f,
+	36.8107f,
+	-152.344f,
+	-27.3438f,
+	38.8491f,
+	-152.344f,
+	-23.4375f,
+	41.3749f,
+	-152.344f,
+	-19.5313f,
+	42.0838f,
+	-152.344f,
+	-15.625f,
+	42.3106f,
+	-152.344f,
+	-11.7188f,
+	43.9654f,
+	-152.344f,
+	-7.8125f,
+	44.3642f,
+	-152.344f,
+	-3.90625f,
+	43.1787f,
+	-152.344f,
+	0.0f,
+	41.875f,
+	-152.344f,
+	3.90625f,
+	42.7212f,
+	-152.344f,
+	-250.0f,
+	27.3076f,
+	-156.25f,
+	-246.094f,
+	27.8739f,
+	-156.25f,
+	-242.188f,
+	27.7337f,
+	-156.25f,
+	-238.281f,
+	28.4499f,
+	-156.25f,
+	-234.375f,
+	30.5068f,
+	-156.25f,
+	-230.469f,
+	31.1326f,
+	-156.25f,
+	-226.563f,
+	32.3149f,
+	-156.25f,
+	-222.656f,
+	31.2724f,
+	-156.25f,
+	-218.75f,
+	29.5487f,
+	-156.25f,
+	-214.844f,
+	26.8408f,
+	-156.25f,
+	-210.938f,
+	25.2503f,
+	-156.25f,
+	-207.031f,
+	24.2811f,
+	-156.25f,
+	-203.125f,
+	23.8635f,
+	-156.25f,
+	-199.219f,
+	22.2573f,
+	-156.25f,
+	-195.313f,
+	20.6368f,
+	-156.25f,
+	-191.406f,
+	19.4922f,
+	-156.25f,
+	-187.5f,
+	18.0281f,
+	-156.25f,
+	-183.594f,
+	15.4098f,
+	-156.25f,
+	-179.688f,
+	13.9176f,
+	-156.25f,
+	-175.781f,
+	11.8192f,
+	-156.25f,
+	-171.875f,
+	9.31112f,
+	-156.25f,
+	-167.969f,
+	8.81167f,
+	-156.25f,
+	-164.063f,
+	8.04908f,
+	-156.25f,
+	-160.156f,
+	6.4764f,
+	-156.25f,
+	-156.25f,
+	5.83656f,
+	-156.25f,
+	-152.344f,
+	5.70173f,
+	-156.25f,
+	-148.438f,
+	6.05686f,
+	-156.25f,
+	-144.531f,
+	3.98364f,
+	-156.25f,
+	-140.625f,
+	2.80636f,
+	-156.25f,
+	-136.719f,
+	3.53326f,
+	-156.25f,
+	-132.813f,
+	4.97177f,
+	-156.25f,
+	-128.906f,
+	6.71319f,
+	-156.25f,
+	-125.0f,
+	8.26478f,
+	-156.25f,
+	-121.094f,
+	9.00909f,
+	-156.25f,
+	-117.188f,
+	8.8849f,
+	-156.25f,
+	-113.281f,
+	9.50654f,
+	-156.25f,
+	-109.375f,
+	9.16878f,
+	-156.25f,
+	-105.469f,
+	8.84796f,
+	-156.25f,
+	-101.563f,
+	9.78015f,
+	-156.25f,
+	-97.6563f,
+	11.1536f,
+	-156.25f,
+	-93.75f,
+	13.416f,
+	-156.25f,
+	-89.8438f,
+	15.8674f,
+	-156.25f,
+	-85.9375f,
+	17.2814f,
+	-156.25f,
+	-82.0313f,
+	18.1958f,
+	-156.25f,
+	-78.125f,
+	19.5037f,
+	-156.25f,
+	-74.2188f,
+	22.0147f,
+	-156.25f,
+	-70.3125f,
+	24.3288f,
+	-156.25f,
+	-66.4063f,
+	26.5193f,
+	-156.25f,
+	-62.5f,
+	27.9571f,
+	-156.25f,
+	-58.5938f,
+	28.8524f,
+	-156.25f,
+	-54.6875f,
+	30.6249f,
+	-156.25f,
+	-50.7813f,
+	30.9824f,
+	-156.25f,
+	-46.875f,
+	31.0372f,
+	-156.25f,
+	-42.9688f,
+	30.2189f,
+	-156.25f,
+	-39.0625f,
+	32.0632f,
+	-156.25f,
+	-35.1563f,
+	34.0061f,
+	-156.25f,
+	-31.25f,
+	35.3975f,
+	-156.25f,
+	-27.3438f,
+	37.8006f,
+	-156.25f,
+	-23.4375f,
+	40.1384f,
+	-156.25f,
+	-19.5313f,
+	40.5455f,
+	-156.25f,
+	-15.625f,
+	41.6044f,
+	-156.25f,
+	-11.7188f,
+	43.1078f,
+	-156.25f,
+	-7.8125f,
+	43.5927f,
+	-156.25f,
+	-3.90625f,
+	43.0245f,
+	-156.25f,
+	0.0f,
+	41.3824f,
+	-156.25f,
+	3.90625f,
+	41.7368f,
+	-156.25f,
+	-250.0f,
+	27.1128f,
+	-160.156f,
+	-246.094f,
+	26.9845f,
+	-160.156f,
+	-242.188f,
+	26.7433f,
+	-160.156f,
+	-238.281f,
+	27.3777f,
+	-160.156f,
+	-234.375f,
+	29.1743f,
+	-160.156f,
+	-230.469f,
+	31.0712f,
+	-160.156f,
+	-226.563f,
+	31.3707f,
+	-160.156f,
+	-222.656f,
+	30.2327f,
+	-160.156f,
+	-218.75f,
+	27.897f,
+	-160.156f,
+	-214.844f,
+	26.4218f,
+	-160.156f,
+	-210.938f,
+	24.0007f,
+	-160.156f,
+	-207.031f,
+	23.6445f,
+	-160.156f,
+	-203.125f,
+	23.6467f,
+	-160.156f,
+	-199.219f,
+	22.8576f,
+	-160.156f,
+	-195.313f,
+	20.6778f,
+	-160.156f,
+	-191.406f,
+	19.3331f,
+	-160.156f,
+	-187.5f,
+	17.8893f,
+	-160.156f,
+	-183.594f,
+	14.3376f,
+	-160.156f,
+	-179.688f,
+	11.9084f,
+	-160.156f,
+	-175.781f,
+	9.60285f,
+	-160.156f,
+	-171.875f,
+	7.78231f,
+	-160.156f,
+	-167.969f,
+	8.15369f,
+	-160.156f,
+	-164.063f,
+	7.46984f,
+	-160.156f,
+	-160.156f,
+	6.48522f,
+	-160.156f,
+	-156.25f,
+	5.27847f,
+	-160.156f,
+	-152.344f,
+	4.69473f,
+	-160.156f,
+	-148.438f,
+	5.14018f,
+	-160.156f,
+	-144.531f,
+	3.26777f,
+	-160.156f,
+	-140.625f,
+	3.33507f,
+	-160.156f,
+	-136.719f,
+	2.47156f,
+	-160.156f,
+	-132.813f,
+	4.15824f,
+	-160.156f,
+	-128.906f,
+	6.45432f,
+	-160.156f,
+	-125.0f,
+	7.99373f,
+	-160.156f,
+	-121.094f,
+	8.38925f,
+	-160.156f,
+	-117.188f,
+	8.59802f,
+	-160.156f,
+	-113.281f,
+	9.4891f,
+	-160.156f,
+	-109.375f,
+	9.20323f,
+	-160.156f,
+	-105.469f,
+	8.27038f,
+	-160.156f,
+	-101.563f,
+	9.71848f,
+	-160.156f,
+	-97.6563f,
+	11.8577f,
+	-160.156f,
+	-93.75f,
+	14.596f,
+	-160.156f,
+	-89.8438f,
+	16.1058f,
+	-160.156f,
+	-85.9375f,
+	17.6531f,
+	-160.156f,
+	-82.0313f,
+	18.2123f,
+	-160.156f,
+	-78.125f,
+	18.7175f,
+	-160.156f,
+	-74.2188f,
+	20.7283f,
+	-160.156f,
+	-70.3125f,
+	23.5217f,
+	-160.156f,
+	-66.4063f,
+	26.4239f,
+	-160.156f,
+	-62.5f,
+	27.757f,
+	-160.156f,
+	-58.5938f,
+	28.1862f,
+	-160.156f,
+	-54.6875f,
+	28.9075f,
+	-160.156f,
+	-50.7813f,
+	29.5287f,
+	-160.156f,
+	-46.875f,
+	29.3972f,
+	-160.156f,
+	-42.9688f,
+	29.568f,
+	-160.156f,
+	-39.0625f,
+	30.605f,
+	-160.156f,
+	-35.1563f,
+	33.0369f,
+	-160.156f,
+	-31.25f,
+	34.749f,
+	-160.156f,
+	-27.3438f,
+	37.4864f,
+	-160.156f,
+	-23.4375f,
+	39.2291f,
+	-160.156f,
+	-19.5313f,
+	39.6275f,
+	-160.156f,
+	-15.625f,
+	39.865f,
+	-160.156f,
+	-11.7188f,
+	41.1833f,
+	-160.156f,
+	-7.8125f,
+	41.7789f,
+	-160.156f,
+	-3.90625f,
+	41.6972f,
+	-160.156f,
+	0.0f,
+	40.379f,
+	-160.156f,
+	3.90625f,
+	40.4755f,
+	-160.156f,
+	-250.0f,
+	26.3982f,
+	-164.063f,
+	-246.094f,
+	26.3606f,
+	-164.063f,
+	-242.188f,
+	26.6508f,
+	-164.063f,
+	-238.281f,
+	27.2228f,
+	-164.063f,
+	-234.375f,
+	29.1682f,
+	-164.063f,
+	-230.469f,
+	30.116f,
+	-164.063f,
+	-226.563f,
+	30.3591f,
+	-164.063f,
+	-222.656f,
+	28.8713f,
+	-164.063f,
+	-218.75f,
+	26.8459f,
+	-164.063f,
+	-214.844f,
+	24.9771f,
+	-164.063f,
+	-210.938f,
+	24.4581f,
+	-164.063f,
+	-207.031f,
+	23.6584f,
+	-164.063f,
+	-203.125f,
+	22.7316f,
+	-164.063f,
+	-199.219f,
+	21.1836f,
+	-164.063f,
+	-195.313f,
+	19.6131f,
+	-164.063f,
+	-191.406f,
+	18.5182f,
+	-164.063f,
+	-187.5f,
+	16.824f,
+	-164.063f,
+	-183.594f,
+	13.8772f,
+	-164.063f,
+	-179.688f,
+	10.3923f,
+	-164.063f,
+	-175.781f,
+	7.50643f,
+	-164.063f,
+	-171.875f,
+	6.58466f,
+	-164.063f,
+	-167.969f,
+	6.81413f,
+	-164.063f,
+	-164.063f,
+	6.88249f,
+	-164.063f,
+	-160.156f,
+	6.78655f,
+	-164.063f,
+	-156.25f,
+	5.18348f,
+	-164.063f,
+	-152.344f,
+	4.44173f,
+	-164.063f,
+	-148.438f,
+	4.56392f,
+	-164.063f,
+	-144.531f,
+	3.00722f,
+	-164.063f,
+	-140.625f,
+	2.88808f,
+	-164.063f,
+	-136.719f,
+	2.58477f,
+	-164.063f,
+	-132.813f,
+	3.20911f,
+	-164.063f,
+	-128.906f,
+	5.33043f,
+	-164.063f,
+	-125.0f,
+	6.73698f,
+	-164.063f,
+	-121.094f,
+	7.71971f,
+	-164.063f,
+	-117.188f,
+	8.44689f,
+	-164.063f,
+	-113.281f,
+	9.05366f,
+	-164.063f,
+	-109.375f,
+	8.81111f,
+	-164.063f,
+	-105.469f,
+	7.75706f,
+	-164.063f,
+	-101.563f,
+	11.1131f,
+	-164.063f,
+	-97.6563f,
+	12.8283f,
+	-164.063f,
+	-93.75f,
+	14.7771f,
+	-164.063f,
+	-89.8438f,
+	16.181f,
+	-164.063f,
+	-85.9375f,
+	17.4228f,
+	-164.063f,
+	-82.0313f,
+	18.5185f,
+	-164.063f,
+	-78.125f,
+	19.3122f,
+	-164.063f,
+	-74.2188f,
+	20.1572f,
+	-164.063f,
+	-70.3125f,
+	22.741f,
+	-164.063f,
+	-66.4063f,
+	24.5911f,
+	-164.063f,
+	-62.5f,
+	26.3846f,
+	-164.063f,
+	-58.5938f,
+	26.7315f,
+	-164.063f,
+	-54.6875f,
+	27.0842f,
+	-164.063f,
+	-50.7813f,
+	28.7654f,
+	-164.063f,
+	-46.875f,
+	28.7233f,
+	-164.063f,
+	-42.9688f,
+	29.2872f,
+	-164.063f,
+	-39.0625f,
+	29.4838f,
+	-164.063f,
+	-35.1563f,
+	32.7848f,
+	-164.063f,
+	-31.25f,
+	34.771f,
+	-164.063f,
+	-27.3438f,
+	36.568f,
+	-164.063f,
+	-23.4375f,
+	37.5518f,
+	-164.063f,
+	-19.5313f,
+	38.4106f,
+	-164.063f,
+	-15.625f,
+	39.2979f,
+	-164.063f,
+	-11.7188f,
+	39.3573f,
+	-164.063f,
+	-7.8125f,
+	40.0034f,
+	-164.063f,
+	-3.90625f,
+	39.5971f,
+	-164.063f,
+	0.0f,
+	38.8676f,
+	-164.063f,
+	3.90625f,
+	38.8633f,
+	-164.063f,
+	-250.0f,
+	25.2893f,
+	-167.969f,
+	-246.094f,
+	25.108f,
+	-167.969f,
+	-242.188f,
+	25.5028f,
+	-167.969f,
+	-238.281f,
+	26.6095f,
+	-167.969f,
+	-234.375f,
+	28.3221f,
+	-167.969f,
+	-230.469f,
+	28.5453f,
+	-167.969f,
+	-226.563f,
+	28.2595f,
+	-167.969f,
+	-222.656f,
+	26.8423f,
+	-167.969f,
+	-218.75f,
+	25.0092f,
+	-167.969f,
+	-214.844f,
+	24.2925f,
+	-167.969f,
+	-210.938f,
+	23.8404f,
+	-167.969f,
+	-207.031f,
+	22.7515f,
+	-167.969f,
+	-203.125f,
+	22.5332f,
+	-167.969f,
+	-199.219f,
+	20.3284f,
+	-167.969f,
+	-195.313f,
+	18.8238f,
+	-167.969f,
+	-191.406f,
+	17.0096f,
+	-167.969f,
+	-187.5f,
+	14.7741f,
+	-167.969f,
+	-183.594f,
+	12.4233f,
+	-167.969f,
+	-179.688f,
+	9.35872f,
+	-167.969f,
+	-175.781f,
+	6.39156f,
+	-167.969f,
+	-171.875f,
+	4.97533f,
+	-167.969f,
+	-167.969f,
+	4.85484f,
+	-167.969f,
+	-164.063f,
+	5.54727f,
+	-167.969f,
+	-160.156f,
+	5.08595f,
+	-167.969f,
+	-156.25f,
+	3.82379f,
+	-167.969f,
+	-152.344f,
+	3.95751f,
+	-167.969f,
+	-148.438f,
+	4.60866f,
+	-167.969f,
+	-144.531f,
+	3.48771f,
+	-167.969f,
+	-140.625f,
+	3.26748f,
+	-167.969f,
+	-136.719f,
+	1.87672f,
+	-167.969f,
+	-132.813f,
+	2.70232f,
+	-167.969f,
+	-128.906f,
+	4.51339f,
+	-167.969f,
+	-125.0f,
+	6.0309f,
+	-167.969f,
+	-121.094f,
+	7.41076f,
+	-167.969f,
+	-117.188f,
+	7.44121f,
+	-167.969f,
+	-113.281f,
+	7.50774f,
+	-167.969f,
+	-109.375f,
+	6.89121f,
+	-167.969f,
+	-105.469f,
+	8.13035f,
+	-167.969f,
+	-101.563f,
+	11.7503f,
+	-167.969f,
+	-97.6563f,
+	14.1358f,
+	-167.969f,
+	-93.75f,
+	15.4553f,
+	-167.969f,
+	-89.8438f,
+	16.6233f,
+	-167.969f,
+	-85.9375f,
+	16.9002f,
+	-167.969f,
+	-82.0313f,
+	18.4951f,
+	-167.969f,
+	-78.125f,
+	19.0947f,
+	-167.969f,
+	-74.2188f,
+	20.0506f,
+	-167.969f,
+	-70.3125f,
+	20.9426f,
+	-167.969f,
+	-66.4063f,
+	22.9738f,
+	-167.969f,
+	-62.5f,
+	24.6229f,
+	-167.969f,
+	-58.5938f,
+	26.446f,
+	-167.969f,
+	-54.6875f,
+	26.6448f,
+	-167.969f,
+	-50.7813f,
+	26.7349f,
+	-167.969f,
+	-46.875f,
+	28.1266f,
+	-167.969f,
+	-42.9688f,
+	29.6034f,
+	-167.969f,
+	-39.0625f,
+	30.3572f,
+	-167.969f,
+	-35.1563f,
+	31.5467f,
+	-167.969f,
+	-31.25f,
+	33.6878f,
+	-167.969f,
+	-27.3438f,
+	35.587f,
+	-167.969f,
+	-23.4375f,
+	36.0939f,
+	-167.969f,
+	-19.5313f,
+	37.5008f,
+	-167.969f,
+	-15.625f,
+	38.2137f,
+	-167.969f,
+	-11.7188f,
+	38.0843f,
+	-167.969f,
+	-7.8125f,
+	38.5726f,
+	-167.969f,
+	-3.90625f,
+	38.3565f,
+	-167.969f,
+	0.0f,
+	37.8848f,
+	-167.969f,
+	3.90625f,
+	37.2199f,
+	-167.969f,
+	-250.0f,
+	24.1398f,
+	-171.875f,
+	-246.094f,
+	23.8227f,
+	-171.875f,
+	-242.188f,
+	24.7818f,
+	-171.875f,
+	-238.281f,
+	26.1053f,
+	-171.875f,
+	-234.375f,
+	26.9542f,
+	-171.875f,
+	-230.469f,
+	26.4956f,
+	-171.875f,
+	-226.563f,
+	25.4866f,
+	-171.875f,
+	-222.656f,
+	24.7397f,
+	-171.875f,
+	-218.75f,
+	23.4337f,
+	-171.875f,
+	-214.844f,
+	23.2342f,
+	-171.875f,
+	-210.938f,
+	22.1055f,
+	-171.875f,
+	-207.031f,
+	20.7279f,
+	-171.875f,
+	-203.125f,
+	20.7273f,
+	-171.875f,
+	-199.219f,
+	19.1302f,
+	-171.875f,
+	-195.313f,
+	16.3679f,
+	-171.875f,
+	-191.406f,
+	14.4548f,
+	-171.875f,
+	-187.5f,
+	12.5085f,
+	-171.875f,
+	-183.594f,
+	10.0081f,
+	-171.875f,
+	-179.688f,
+	7.8572f,
+	-171.875f,
+	-175.781f,
+	4.38151f,
+	-171.875f,
+	-171.875f,
+	3.2342f,
+	-171.875f,
+	-167.969f,
+	3.37553f,
+	-171.875f,
+	-164.063f,
+	3.90509f,
+	-171.875f,
+	-160.156f,
+	3.26335f,
+	-171.875f,
+	-156.25f,
+	2.88438f,
+	-171.875f,
+	-152.344f,
+	4.22045f,
+	-171.875f,
+	-148.438f,
+	3.83297f,
+	-171.875f,
+	-144.531f,
+	2.98648f,
+	-171.875f,
+	-140.625f,
+	2.83916f,
+	-171.875f,
+	-136.719f,
+	1.97368f,
+	-171.875f,
+	-132.813f,
+	1.85909f,
+	-171.875f,
+	-128.906f,
+	3.2051f,
+	-171.875f,
+	-125.0f,
+	5.12684f,
+	-171.875f,
+	-121.094f,
+	5.86909f,
+	-171.875f,
+	-117.188f,
+	6.45429f,
+	-171.875f,
+	-113.281f,
+	6.28889f,
+	-171.875f,
+	-109.375f,
+	7.53536f,
+	-171.875f,
+	-105.469f,
+	9.44844f,
+	-171.875f,
+	-101.563f,
+	11.4162f,
+	-171.875f,
+	-97.6563f,
+	13.7412f,
+	-171.875f,
+	-93.75f,
+	14.8315f,
+	-171.875f,
+	-89.8438f,
+	15.4968f,
+	-171.875f,
+	-85.9375f,
+	16.3468f,
+	-171.875f,
+	-82.0313f,
+	18.2605f,
+	-171.875f,
+	-78.125f,
+	18.0829f,
+	-171.875f,
+	-74.2188f,
+	18.1489f,
+	-171.875f,
+	-70.3125f,
+	20.6678f,
+	-171.875f,
+	-66.4063f,
+	23.1234f,
+	-171.875f,
+	-62.5f,
+	24.4247f,
+	-171.875f,
+	-58.5938f,
+	26.5223f,
+	-171.875f,
+	-54.6875f,
+	26.4286f,
+	-171.875f,
+	-50.7813f,
+	26.7163f,
+	-171.875f,
+	-46.875f,
+	28.0436f,
+	-171.875f,
+	-42.9688f,
+	29.6821f,
+	-171.875f,
+	-39.0625f,
+	30.721f,
+	-171.875f,
+	-35.1563f,
+	31.1869f,
+	-171.875f,
+	-31.25f,
+	32.2507f,
+	-171.875f,
+	-27.3438f,
+	33.3898f,
+	-171.875f,
+	-23.4375f,
+	33.9008f,
+	-171.875f,
+	-19.5313f,
+	34.8028f,
+	-171.875f,
+	-15.625f,
+	35.7178f,
+	-171.875f,
+	-11.7188f,
+	35.7796f,
+	-171.875f,
+	-7.8125f,
+	35.6384f,
+	-171.875f,
+	-3.90625f,
+	35.5122f,
+	-171.875f,
+	0.0f,
+	35.5973f,
+	-171.875f,
+	3.90625f,
+	35.3898f,
+	-171.875f,
+	-250.0f,
+	23.4472f,
+	-175.781f,
+	-246.094f,
+	24.0295f,
+	-175.781f,
+	-242.188f,
+	25.0451f,
+	-175.781f,
+	-238.281f,
+	25.8985f,
+	-175.781f,
+	-234.375f,
+	26.561f,
+	-175.781f,
+	-230.469f,
+	25.8342f,
+	-175.781f,
+	-226.563f,
+	24.8466f,
+	-175.781f,
+	-222.656f,
+	24.9204f,
+	-175.781f,
+	-218.75f,
+	23.1933f,
+	-175.781f,
+	-214.844f,
+	22.3916f,
+	-175.781f,
+	-210.938f,
+	20.9595f,
+	-175.781f,
+	-207.031f,
+	19.4013f,
+	-175.781f,
+	-203.125f,
+	18.3359f,
+	-175.781f,
+	-199.219f,
+	16.2135f,
+	-175.781f,
+	-195.313f,
+	14.3022f,
+	-175.781f,
+	-191.406f,
+	12.4792f,
+	-175.781f,
+	-187.5f,
+	10.1621f,
+	-175.781f,
+	-183.594f,
+	7.8368f,
+	-175.781f,
+	-179.688f,
+	5.59407f,
+	-175.781f,
+	-175.781f,
+	3.47332f,
+	-175.781f,
+	-171.875f,
+	2.4167f,
+	-175.781f,
+	-167.969f,
+	2.13794f,
+	-175.781f,
+	-164.063f,
+	2.36632f,
+	-175.781f,
+	-160.156f,
+	2.44955f,
+	-175.781f,
+	-156.25f,
+	2.40042f,
+	-175.781f,
+	-152.344f,
+	3.0142f,
+	-175.781f,
+	-148.438f,
+	2.58304f,
+	-175.781f,
+	-144.531f,
+	3.06221f,
+	-175.781f,
+	-140.625f,
+	2.8937f,
+	-175.781f,
+	-136.719f,
+	2.59115f,
+	-175.781f,
+	-132.813f,
+	2.27806f,
+	-175.781f,
+	-128.906f,
+	3.67695f,
+	-175.781f,
+	-125.0f,
+	5.23254f,
+	-175.781f,
+	-121.094f,
+	6.12339f,
+	-175.781f,
+	-117.188f,
+	6.24689f,
+	-175.781f,
+	-113.281f,
+	6.79282f,
+	-175.781f,
+	-109.375f,
+	7.83542f,
+	-175.781f,
+	-105.469f,
+	9.33972f,
+	-175.781f,
+	-101.563f,
+	11.2701f,
+	-175.781f,
+	-97.6563f,
+	13.0689f,
+	-175.781f,
+	-93.75f,
+	13.927f,
+	-175.781f,
+	-89.8438f,
+	14.9788f,
+	-175.781f,
+	-85.9375f,
+	15.6647f,
+	-175.781f,
+	-82.0313f,
+	16.3833f,
+	-175.781f,
+	-78.125f,
+	16.1061f,
+	-175.781f,
+	-74.2188f,
+	17.7393f,
+	-175.781f,
+	-70.3125f,
+	19.8808f,
+	-175.781f,
+	-66.4063f,
+	22.2751f,
+	-175.781f,
+	-62.5f,
+	23.8491f,
+	-175.781f,
+	-58.5938f,
+	25.3344f,
+	-175.781f,
+	-54.6875f,
+	26.6818f,
+	-175.781f,
+	-50.7813f,
+	27.9151f,
+	-175.781f,
+	-46.875f,
+	28.5054f,
+	-175.781f,
+	-42.9688f,
+	29.7057f,
+	-175.781f,
+	-39.0625f,
+	30.623f,
+	-175.781f,
+	-35.1563f,
+	31.5341f,
+	-175.781f,
+	-31.25f,
+	31.663f,
+	-175.781f,
+	-27.3438f,
+	31.1886f,
+	-175.781f,
+	-23.4375f,
+	31.5377f,
+	-175.781f,
+	-19.5313f,
+	31.9508f,
+	-175.781f,
+	-15.625f,
+	32.9549f,
+	-175.781f,
+	-11.7188f,
+	33.7731f,
+	-175.781f,
+	-7.8125f,
+	33.8023f,
+	-175.781f,
+	-3.90625f,
+	34.5283f,
+	-175.781f,
+	0.0f,
+	34.7929f,
+	-175.781f,
+	3.90625f,
+	34.823f,
+	-175.781f,
+	-250.0f,
+	22.2698f,
+	-179.688f,
+	-246.094f,
+	23.7669f,
+	-179.688f,
+	-242.188f,
+	24.59f,
+	-179.688f,
+	-238.281f,
+	26.1637f,
+	-179.688f,
+	-234.375f,
+	25.5266f,
+	-179.688f,
+	-230.469f,
+	24.4911f,
+	-179.688f,
+	-226.563f,
+	24.894f,
+	-179.688f,
+	-222.656f,
+	23.7469f,
+	-179.688f,
+	-218.75f,
+	22.9663f,
+	-179.688f,
+	-214.844f,
+	20.6574f,
+	-179.688f,
+	-210.938f,
+	19.2502f,
+	-179.688f,
+	-207.031f,
+	17.3967f,
+	-179.688f,
+	-203.125f,
+	15.9684f,
+	-179.688f,
+	-199.219f,
+	13.2948f,
+	-179.688f,
+	-195.313f,
+	11.9318f,
+	-179.688f,
+	-191.406f,
+	9.64213f,
+	-179.688f,
+	-187.5f,
+	7.9435f,
+	-179.688f,
+	-183.594f,
+	6.1917f,
+	-179.688f,
+	-179.688f,
+	4.0394f,
+	-179.688f,
+	-175.781f,
+	1.9267f,
+	-179.688f,
+	-171.875f,
+	1.73477f,
+	-179.688f,
+	-167.969f,
+	0.994442f,
+	-179.688f,
+	-164.063f,
+	0.99617f,
+	-179.688f,
+	-160.156f,
+	1.00048f,
+	-179.688f,
+	-156.25f,
+	1.54446f,
+	-179.688f,
+	-152.344f,
+	0.849521f,
+	-179.688f,
+	-148.438f,
+	1.3046f,
+	-179.688f,
+	-144.531f,
+	1.38519f,
+	-179.688f,
+	-140.625f,
+	0.916628f,
+	-179.688f,
+	-136.719f,
+	1.39685f,
+	-179.688f,
+	-132.813f,
+	2.17945f,
+	-179.688f,
+	-128.906f,
+	4.01973f,
+	-179.688f,
+	-125.0f,
+	5.72989f,
+	-179.688f,
+	-121.094f,
+	7.24268f,
+	-179.688f,
+	-117.188f,
+	7.06199f,
+	-179.688f,
+	-113.281f,
+	7.91292f,
+	-179.688f,
+	-109.375f,
+	7.8138f,
+	-179.688f,
+	-105.469f,
+	10.102f,
+	-179.688f,
+	-101.563f,
+	11.8106f,
+	-179.688f,
+	-97.6563f,
+	12.9642f,
+	-179.688f,
+	-93.75f,
+	13.5879f,
+	-179.688f,
+	-89.8438f,
+	13.4552f,
+	-179.688f,
+	-85.9375f,
+	14.1844f,
+	-179.688f,
+	-82.0313f,
+	14.3802f,
+	-179.688f,
+	-78.125f,
+	15.3847f,
+	-179.688f,
+	-74.2188f,
+	17.2288f,
+	-179.688f,
+	-70.3125f,
+	18.9285f,
+	-179.688f,
+	-66.4063f,
+	20.0035f,
+	-179.688f,
+	-62.5f,
+	22.2672f,
+	-179.688f,
+	-58.5938f,
+	25.1262f,
+	-179.688f,
+	-54.6875f,
+	27.2745f,
+	-179.688f,
+	-50.7813f,
+	28.2648f,
+	-179.688f,
+	-46.875f,
+	29.3825f,
+	-179.688f,
+	-42.9688f,
+	30.2137f,
+	-179.688f,
+	-39.0625f,
+	31.3826f,
+	-179.688f,
+	-35.1563f,
+	31.25f,
+	-179.688f,
+	-31.25f,
+	31.0392f,
+	-179.688f,
+	-27.3438f,
+	30.3369f,
+	-179.688f,
+	-23.4375f,
+	30.5503f,
+	-179.688f,
+	-19.5313f,
+	30.9715f,
+	-179.688f,
+	-15.625f,
+	31.8287f,
+	-179.688f,
+	-11.7188f,
+	32.1393f,
+	-179.688f,
+	-7.8125f,
+	32.0725f,
+	-179.688f,
+	-3.90625f,
+	32.6574f,
+	-179.688f,
+	0.0f,
+	32.8889f,
+	-179.688f,
+	3.90625f,
+	32.9461f,
+	-179.688f,
+	-250.0f,
+	22.3874f,
+	-183.594f,
+	-246.094f,
+	22.8072f,
+	-183.594f,
+	-242.188f,
+	23.1353f,
+	-183.594f,
+	-238.281f,
+	24.0949f,
+	-183.594f,
+	-234.375f,
+	24.0026f,
+	-183.594f,
+	-230.469f,
+	23.458f,
+	-183.594f,
+	-226.563f,
+	23.872f,
+	-183.594f,
+	-222.656f,
+	22.969f,
+	-183.594f,
+	-218.75f,
+	21.8375f,
+	-183.594f,
+	-214.844f,
+	19.9316f,
+	-183.594f,
+	-210.938f,
+	16.812f,
+	-183.594f,
+	-207.031f,
+	15.1789f,
+	-183.594f,
+	-203.125f,
+	13.7876f,
+	-183.594f,
+	-199.219f,
+	11.6818f,
+	-183.594f,
+	-195.313f,
+	9.75291f,
+	-183.594f,
+	-191.406f,
+	7.08878f,
+	-183.594f,
+	-187.5f,
+	6.43001f,
+	-183.594f,
+	-183.594f,
+	5.15238f,
+	-183.594f,
+	-179.688f,
+	3.77653f,
+	-183.594f,
+	-175.781f,
+	3.01737f,
+	-183.594f,
+	-171.875f,
+	1.46355f,
+	-183.594f,
+	-167.969f,
+	0.767798f,
+	-183.594f,
+	-164.063f,
+	1.98474f,
+	-183.594f,
+	-160.156f,
+	1.09473f,
+	-183.594f,
+	-156.25f,
+	1.29857f,
+	-183.594f,
+	-152.344f,
+	-0.203491f,
+	-183.594f,
+	-148.438f,
+	-0.506199f,
+	-183.594f,
+	-144.531f,
+	-0.678603f,
+	-183.594f,
+	-140.625f,
+	0.165814f,
+	-183.594f,
+	-136.719f,
+	1.44759f,
+	-183.594f,
+	-132.813f,
+	1.43337f,
+	-183.594f,
+	-128.906f,
+	3.23614f,
+	-183.594f,
+	-125.0f,
+	4.8541f,
+	-183.594f,
+	-121.094f,
+	6.64038f,
+	-183.594f,
+	-117.188f,
+	7.96432f,
+	-183.594f,
+	-113.281f,
+	8.52594f,
+	-183.594f,
+	-109.375f,
+	7.78399f,
+	-183.594f,
+	-105.469f,
+	9.45422f,
+	-183.594f,
+	-101.563f,
+	11.3198f,
+	-183.594f,
+	-97.6563f,
+	12.2369f,
+	-183.594f,
+	-93.75f,
+	12.7733f,
+	-183.594f,
+	-89.8438f,
+	12.9184f,
+	-183.594f,
+	-85.9375f,
+	12.958f,
+	-183.594f,
+	-82.0313f,
+	13.3326f,
+	-183.594f,
+	-78.125f,
+	14.3984f,
+	-183.594f,
+	-74.2188f,
+	16.2737f,
+	-183.594f,
+	-70.3125f,
+	17.9981f,
+	-183.594f,
+	-66.4063f,
+	19.5314f,
+	-183.594f,
+	-62.5f,
+	21.4039f,
+	-183.594f,
+	-58.5938f,
+	24.8945f,
+	-183.594f,
+	-54.6875f,
+	26.9904f,
+	-183.594f,
+	-50.7813f,
+	28.6222f,
+	-183.594f,
+	-46.875f,
+	30.2128f,
+	-183.594f,
+	-42.9688f,
+	30.5142f,
+	-183.594f,
+	-39.0625f,
+	30.7026f,
+	-183.594f,
+	-35.1563f,
+	30.6413f,
+	-183.594f,
+	-31.25f,
+	29.7659f,
+	-183.594f,
+	-27.3438f,
+	30.2613f,
+	-183.594f,
+	-23.4375f,
+	31.0694f,
+	-183.594f,
+	-19.5313f,
+	31.0437f,
+	-183.594f,
+	-15.625f,
+	30.9824f,
+	-183.594f,
+	-11.7188f,
+	30.4648f,
+	-183.594f,
+	-7.8125f,
+	30.0916f,
+	-183.594f,
+	-3.90625f,
+	30.0801f,
+	-183.594f,
+	0.0f,
+	29.9992f,
+	-183.594f,
+	3.90625f,
+	30.0027f,
+	-183.594f,
+	-250.0f,
+	22.2829f,
+	-187.5f,
+	-246.094f,
+	23.1567f,
+	-187.5f,
+	-242.188f,
+	23.2229f,
+	-187.5f,
+	-238.281f,
+	23.6644f,
+	-187.5f,
+	-234.375f,
+	23.5148f,
+	-187.5f,
+	-230.469f,
+	22.8756f,
+	-187.5f,
+	-226.563f,
+	22.2471f,
+	-187.5f,
+	-222.656f,
+	21.4292f,
+	-187.5f,
+	-218.75f,
+	20.4108f,
+	-187.5f,
+	-214.844f,
+	18.2601f,
+	-187.5f,
+	-210.938f,
+	16.3575f,
+	-187.5f,
+	-207.031f,
+	13.0762f,
+	-187.5f,
+	-203.125f,
+	11.5916f,
+	-187.5f,
+	-199.219f,
+	9.81885f,
+	-187.5f,
+	-195.313f,
+	8.57193f,
+	-187.5f,
+	-191.406f,
+	5.93865f,
+	-187.5f,
+	-187.5f,
+	5.15801f,
+	-187.5f,
+	-183.594f,
+	3.89597f,
+	-187.5f,
+	-179.688f,
+	4.52236f,
+	-187.5f,
+	-175.781f,
+	4.21162f,
+	-187.5f,
+	-171.875f,
+	2.62521f,
+	-187.5f,
+	-167.969f,
+	1.85733f,
+	-187.5f,
+	-164.063f,
+	2.14119f,
+	-187.5f,
+	-160.156f,
+	2.60992f,
+	-187.5f,
+	-156.25f,
+	1.99742f,
+	-187.5f,
+	-152.344f,
+	0.836315f,
+	-187.5f,
+	-148.438f,
+	-0.122141f,
+	-187.5f,
+	-144.531f,
+	-1.21041f,
+	-187.5f,
+	-140.625f,
+	0.620409f,
+	-187.5f,
+	-136.719f,
+	2.20372f,
+	-187.5f,
+	-132.813f,
+	2.55457f,
+	-187.5f,
+	-128.906f,
+	3.09944f,
+	-187.5f,
+	-125.0f,
+	4.76219f,
+	-187.5f,
+	-121.094f,
+	6.5939f,
+	-187.5f,
+	-117.188f,
+	7.40657f,
+	-187.5f,
+	-113.281f,
+	8.17096f,
+	-187.5f,
+	-109.375f,
+	8.8965f,
+	-187.5f,
+	-105.469f,
+	9.54116f,
+	-187.5f,
+	-101.563f,
+	10.8183f,
+	-187.5f,
+	-97.6563f,
+	12.2345f,
+	-187.5f,
+	-93.75f,
+	11.945f,
+	-187.5f,
+	-89.8438f,
+	12.3063f,
+	-187.5f,
+	-85.9375f,
+	12.7736f,
+	-187.5f,
+	-82.0313f,
+	13.2581f,
+	-187.5f,
+	-78.125f,
+	14.2241f,
+	-187.5f,
+	-74.2188f,
+	15.1957f,
+	-187.5f,
+	-70.3125f,
+	17.7241f,
+	-187.5f,
+	-66.4063f,
+	21.0931f,
+	-187.5f,
+	-62.5f,
+	23.7741f,
+	-187.5f,
+	-58.5938f,
+	24.8775f,
+	-187.5f,
+	-54.6875f,
+	26.5924f,
+	-187.5f,
+	-50.7813f,
+	28.0699f,
+	-187.5f,
+	-46.875f,
+	30.1552f,
+	-187.5f,
+	-42.9688f,
+	30.8508f,
+	-187.5f,
+	-39.0625f,
+	30.7935f,
+	-187.5f,
+	-35.1563f,
+	30.3224f,
+	-187.5f,
+	-31.25f,
+	28.8455f,
+	-187.5f,
+	-27.3438f,
+	30.2059f,
+	-187.5f,
+	-23.4375f,
+	31.5456f,
+	-187.5f,
+	-19.5313f,
+	31.0657f,
+	-187.5f,
+	-15.625f,
+	30.5686f,
+	-187.5f,
+	-11.7188f,
+	29.9754f,
+	-187.5f,
+	-7.8125f,
+	28.7754f,
+	-187.5f,
+	-3.90625f,
+	28.2457f,
+	-187.5f,
+	0.0f,
+	27.4045f,
+	-187.5f,
+	3.90625f,
+	27.6405f,
+	-187.5f,
+	-250.0f,
+	21.5096f,
+	-191.406f,
+	-246.094f,
+	22.1931f,
+	-191.406f,
+	-242.188f,
+	22.416f,
+	-191.406f,
+	-238.281f,
+	22.619f,
+	-191.406f,
+	-234.375f,
+	22.9242f,
+	-191.406f,
+	-230.469f,
+	22.6042f,
+	-191.406f,
+	-226.563f,
+	21.5344f,
+	-191.406f,
+	-222.656f,
+	20.226f,
+	-191.406f,
+	-218.75f,
+	19.6198f,
+	-191.406f,
+	-214.844f,
+	18.0849f,
+	-191.406f,
+	-210.938f,
+	15.9896f,
+	-191.406f,
+	-207.031f,
+	12.7402f,
+	-191.406f,
+	-203.125f,
+	9.98899f,
+	-191.406f,
+	-199.219f,
+	7.38602f,
+	-191.406f,
+	-195.313f,
+	6.23078f,
+	-191.406f,
+	-191.406f,
+	4.8714f,
+	-191.406f,
+	-187.5f,
+	4.87792f,
+	-191.406f,
+	-183.594f,
+	4.53381f,
+	-191.406f,
+	-179.688f,
+	5.23517f,
+	-191.406f,
+	-175.781f,
+	4.22349f,
+	-191.406f,
+	-171.875f,
+	3.46214f,
+	-191.406f,
+	-167.969f,
+	3.62202f,
+	-191.406f,
+	-164.063f,
+	3.07142f,
+	-191.406f,
+	-160.156f,
+	3.69893f,
+	-191.406f,
+	-156.25f,
+	4.20827f,
+	-191.406f,
+	-152.344f,
+	2.23654f,
+	-191.406f,
+	-148.438f,
+	0.582121f,
+	-191.406f,
+	-144.531f,
+	0.44941f,
+	-191.406f,
+	-140.625f,
+	2.42446f,
+	-191.406f,
+	-136.719f,
+	3.54807f,
+	-191.406f,
+	-132.813f,
+	3.58143f,
+	-191.406f,
+	-128.906f,
+	4.42162f,
+	-191.406f,
+	-125.0f,
+	5.24153f,
+	-191.406f,
+	-121.094f,
+	6.55792f,
+	-191.406f,
+	-117.188f,
+	6.93471f,
+	-191.406f,
+	-113.281f,
+	7.73309f,
+	-191.406f,
+	-109.375f,
+	8.04468f,
+	-191.406f,
+	-105.469f,
+	9.15528f,
+	-191.406f,
+	-101.563f,
+	10.9583f,
+	-191.406f,
+	-97.6563f,
+	12.1897f,
+	-191.406f,
+	-93.75f,
+	11.6481f,
+	-191.406f,
+	-89.8438f,
+	11.6514f,
+	-191.406f,
+	-85.9375f,
+	12.4326f,
+	-191.406f,
+	-82.0313f,
+	13.3808f,
+	-191.406f,
+	-78.125f,
+	14.386f,
+	-191.406f,
+	-74.2188f,
+	16.182f,
+	-191.406f,
+	-70.3125f,
+	18.9931f,
+	-191.406f,
+	-66.4063f,
+	22.8308f,
+	-191.406f,
+	-62.5f,
+	25.3868f,
+	-191.406f,
+	-58.5938f,
+	26.1484f,
+	-191.406f,
+	-54.6875f,
+	25.6258f,
+	-191.406f,
+	-50.7813f,
+	26.9464f,
+	-191.406f,
+	-46.875f,
+	29.0075f,
+	-191.406f,
+	-42.9688f,
+	29.8523f,
+	-191.406f,
+	-39.0625f,
+	30.1236f,
+	-191.406f,
+	-35.1563f,
+	29.7557f,
+	-191.406f,
+	-31.25f,
+	28.4913f,
+	-191.406f,
+	-27.3438f,
+	29.5389f,
+	-191.406f,
+	-23.4375f,
+	30.4685f,
+	-191.406f,
+	-19.5313f,
+	30.3743f,
+	-191.406f,
+	-15.625f,
+	30.3762f,
+	-191.406f,
+	-11.7188f,
+	29.0099f,
+	-191.406f,
+	-7.8125f,
+	28.1952f,
+	-191.406f,
+	-3.90625f,
+	26.135f,
+	-191.406f,
+	0.0f,
+	25.2418f,
+	-191.406f,
+	3.90625f,
+	25.3652f,
+	-191.406f,
+	-250.0f,
+	20.78f,
+	-195.313f,
+	-246.094f,
+	20.8279f,
+	-195.313f,
+	-242.188f,
+	21.2199f,
+	-195.313f,
+	-238.281f,
+	22.0652f,
+	-195.313f,
+	-234.375f,
+	22.2095f,
+	-195.313f,
+	-230.469f,
+	22.1372f,
+	-195.313f,
+	-226.563f,
+	21.0165f,
+	-195.313f,
+	-222.656f,
+	19.4174f,
+	-195.313f,
+	-218.75f,
+	17.7927f,
+	-195.313f,
+	-214.844f,
+	16.6172f,
+	-195.313f,
+	-210.938f,
+	14.7065f,
+	-195.313f,
+	-207.031f,
+	11.8095f,
+	-195.313f,
+	-203.125f,
+	9.63824f,
+	-195.313f,
+	-199.219f,
+	6.4991f,
+	-195.313f,
+	-195.313f,
+	6.23707f,
+	-195.313f,
+	-191.406f,
+	6.60374f,
+	-195.313f,
+	-187.5f,
+	6.22557f,
+	-195.313f,
+	-183.594f,
+	5.47951f,
+	-195.313f,
+	-179.688f,
+	5.16851f,
+	-195.313f,
+	-175.781f,
+	4.83538f,
+	-195.313f,
+	-171.875f,
+	4.16992f,
+	-195.313f,
+	-167.969f,
+	5.40533f,
+	-195.313f,
+	-164.063f,
+	5.01562f,
+	-195.313f,
+	-160.156f,
+	4.58978f,
+	-195.313f,
+	-156.25f,
+	4.73252f,
+	-195.313f,
+	-152.344f,
+	3.14586f,
+	-195.313f,
+	-148.438f,
+	1.16894f,
+	-195.313f,
+	-144.531f,
+	2.4916f,
+	-195.313f,
+	-140.625f,
+	3.98933f,
+	-195.313f,
+	-136.719f,
+	5.16861f,
+	-195.313f,
+	-132.813f,
+	5.68931f,
+	-195.313f,
+	-128.906f,
+	5.45815f,
+	-195.313f,
+	-125.0f,
+	5.15506f,
+	-195.313f,
+	-121.094f,
+	6.46153f,
+	-195.313f,
+	-117.188f,
+	7.36577f,
+	-195.313f,
+	-113.281f,
+	8.13491f,
+	-195.313f,
+	-109.375f,
+	7.50896f,
+	-195.313f,
+	-105.469f,
+	8.93662f,
+	-195.313f,
+	-101.563f,
+	10.6513f,
+	-195.313f,
+	-97.6563f,
+	10.6255f,
+	-195.313f,
+	-93.75f,
+	10.5332f,
+	-195.313f,
+	-89.8438f,
+	11.5758f,
+	-195.313f,
+	-85.9375f,
+	11.568f,
+	-195.313f,
+	-82.0313f,
+	14.2419f,
+	-195.313f,
+	-78.125f,
+	16.1272f,
+	-195.313f,
+	-74.2188f,
+	17.0994f,
+	-195.313f,
+	-70.3125f,
+	20.4651f,
+	-195.313f,
+	-66.4063f,
+	23.534f,
+	-195.313f,
+	-62.5f,
+	25.1181f,
+	-195.313f,
+	-58.5938f,
+	25.9427f,
+	-195.313f,
+	-54.6875f,
+	25.5166f,
+	-195.313f,
+	-50.7813f,
+	25.1027f,
+	-195.313f,
+	-46.875f,
+	27.2281f,
+	-195.313f,
+	-42.9688f,
+	28.7319f,
+	-195.313f,
+	-39.0625f,
+	28.8984f,
+	-195.313f,
+	-35.1563f,
+	28.3307f,
+	-195.313f,
+	-31.25f,
+	27.4754f,
+	-195.313f,
+	-27.3438f,
+	27.8763f,
+	-195.313f,
+	-23.4375f,
+	28.1023f,
+	-195.313f,
+	-19.5313f,
+	28.9815f,
+	-195.313f,
+	-15.625f,
+	28.5849f,
+	-195.313f,
+	-11.7188f,
+	27.2687f,
+	-195.313f,
+	-7.8125f,
+	26.8112f,
+	-195.313f,
+	-3.90625f,
+	25.3636f,
+	-195.313f,
+	0.0f,
+	23.2134f,
+	-195.313f,
+	3.90625f,
+	23.0993f,
+	-195.313f,
+	-250.0f,
+	20.2026f,
+	-199.219f,
+	-246.094f,
+	19.5895f,
+	-199.219f,
+	-242.188f,
+	20.3489f,
+	-199.219f,
+	-238.281f,
+	21.0293f,
+	-199.219f,
+	-234.375f,
+	21.5343f,
+	-199.219f,
+	-230.469f,
+	20.6859f,
+	-199.219f,
+	-226.563f,
+	19.9279f,
+	-199.219f,
+	-222.656f,
+	18.7217f,
+	-199.219f,
+	-218.75f,
+	17.4818f,
+	-199.219f,
+	-214.844f,
+	15.0438f,
+	-199.219f,
+	-210.938f,
+	13.4082f,
+	-199.219f,
+	-207.031f,
+	10.7188f,
+	-199.219f,
+	-203.125f,
+	8.32176f,
+	-199.219f,
+	-199.219f,
+	7.30407f,
+	-199.219f,
+	-195.313f,
+	7.02569f,
+	-199.219f,
+	-191.406f,
+	7.38826f,
+	-199.219f,
+	-187.5f,
+	6.94954f,
+	-199.219f,
+	-183.594f,
+	6.62067f,
+	-199.219f,
+	-179.688f,
+	6.55308f,
+	-199.219f,
+	-175.781f,
+	6.3403f,
+	-199.219f,
+	-171.875f,
+	5.0001f,
+	-199.219f,
+	-167.969f,
+	6.51564f,
+	-199.219f,
+	-164.063f,
+	6.69774f,
+	-199.219f,
+	-160.156f,
+	5.67189f,
+	-199.219f,
+	-156.25f,
+	4.8973f,
+	-199.219f,
+	-152.344f,
+	3.43798f,
+	-199.219f,
+	-148.438f,
+	2.08531f,
+	-199.219f,
+	-144.531f,
+	3.86643f,
+	-199.219f,
+	-140.625f,
+	6.0862f,
+	-199.219f,
+	-136.719f,
+	6.99995f,
+	-199.219f,
+	-132.813f,
+	8.32808f,
+	-199.219f,
+	-128.906f,
+	8.55809f,
+	-199.219f,
+	-125.0f,
+	8.26904f,
+	-199.219f,
+	-121.094f,
+	8.63733f,
+	-199.219f,
+	-117.188f,
+	9.11106f,
+	-199.219f,
+	-113.281f,
+	9.73154f,
+	-199.219f,
+	-109.375f,
+	9.14108f,
+	-199.219f,
+	-105.469f,
+	9.3525f,
+	-199.219f,
+	-101.563f,
+	9.56281f,
+	-199.219f,
+	-97.6563f,
+	9.74866f,
+	-199.219f,
+	-93.75f,
+	10.9852f,
+	-199.219f,
+	-89.8438f,
+	12.3926f,
+	-199.219f,
+	-85.9375f,
+	13.6407f,
+	-199.219f,
+	-82.0313f,
+	15.9886f,
+	-199.219f,
+	-78.125f,
+	17.7913f,
+	-199.219f,
+	-74.2188f,
+	18.8352f,
+	-199.219f,
+	-70.3125f,
+	20.2718f,
+	-199.219f,
+	-66.4063f,
+	23.501f,
+	-199.219f,
+	-62.5f,
+	24.6073f,
+	-199.219f,
+	-58.5938f,
+	25.3028f,
+	-199.219f,
+	-54.6875f,
+	25.2244f,
+	-199.219f,
+	-50.7813f,
+	23.9922f,
+	-199.219f,
+	-46.875f,
+	24.6425f,
+	-199.219f,
+	-42.9688f,
+	26.6199f,
+	-199.219f,
+	-39.0625f,
+	27.5474f,
+	-199.219f,
+	-35.1563f,
+	27.4672f,
+	-199.219f,
+	-31.25f,
+	27.2906f,
+	-199.219f,
+	-27.3438f,
+	26.489f,
+	-199.219f,
+	-23.4375f,
+	26.3554f,
+	-199.219f,
+	-19.5313f,
+	26.1787f,
+	-199.219f,
+	-15.625f,
+	26.2538f,
+	-199.219f,
+	-11.7188f,
+	25.7694f,
+	-199.219f,
+	-7.8125f,
+	25.2691f,
+	-199.219f,
+	-3.90625f,
+	23.3867f,
+	-199.219f,
+	0.0f,
+	22.5717f,
+	-199.219f,
+	3.90625f,
+	21.5827f,
+	-199.219f,
+	-250.0f,
+	19.3526f,
+	-203.125f,
+	-246.094f,
+	19.2964f,
+	-203.125f,
+	-242.188f,
+	19.226f,
+	-203.125f,
+	-238.281f,
+	19.4274f,
+	-203.125f,
+	-234.375f,
+	19.4317f,
+	-203.125f,
+	-230.469f,
+	19.3079f,
+	-203.125f,
+	-226.563f,
+	18.212f,
+	-203.125f,
+	-222.656f,
+	17.8371f,
+	-203.125f,
+	-218.75f,
+	16.8642f,
+	-203.125f,
+	-214.844f,
+	14.8539f,
+	-203.125f,
+	-210.938f,
+	12.425f,
+	-203.125f,
+	-207.031f,
+	10.0369f,
+	-203.125f,
+	-203.125f,
+	9.00151f,
+	-203.125f,
+	-199.219f,
+	8.61334f,
+	-203.125f,
+	-195.313f,
+	8.09586f,
+	-203.125f,
+	-191.406f,
+	8.18143f,
+	-203.125f,
+	-187.5f,
+	7.75345f,
+	-203.125f,
+	-183.594f,
+	7.72772f,
+	-203.125f,
+	-179.688f,
+	7.71649f,
+	-203.125f,
+	-175.781f,
+	7.72935f,
+	-203.125f,
+	-171.875f,
+	6.70116f,
+	-203.125f,
+	-167.969f,
+	6.58828f,
+	-203.125f,
+	-164.063f,
+	6.47975f,
+	-203.125f,
+	-160.156f,
+	5.96451f,
+	-203.125f,
+	-156.25f,
+	5.85253f,
+	-203.125f,
+	-152.344f,
+	5.14982f,
+	-203.125f,
+	-148.438f,
+	4.60646f,
+	-203.125f,
+	-144.531f,
+	6.3659f,
+	-203.125f,
+	-140.625f,
+	7.66587f,
+	-203.125f,
+	-136.719f,
+	8.68095f,
+	-203.125f,
+	-132.813f,
+	9.86922f,
+	-203.125f,
+	-128.906f,
+	9.93481f,
+	-203.125f,
+	-125.0f,
+	10.9585f,
+	-203.125f,
+	-121.094f,
+	10.9271f,
+	-203.125f,
+	-117.188f,
+	11.4348f,
+	-203.125f,
+	-113.281f,
+	11.0548f,
+	-203.125f,
+	-109.375f,
+	11.2501f,
+	-203.125f,
+	-105.469f,
+	11.7673f,
+	-203.125f,
+	-101.563f,
+	10.8899f,
+	-203.125f,
+	-97.6563f,
+	11.3791f,
+	-203.125f,
+	-93.75f,
+	12.168f,
+	-203.125f,
+	-89.8438f,
+	12.7667f,
+	-203.125f,
+	-85.9375f,
+	15.2415f,
+	-203.125f,
+	-82.0313f,
+	17.9783f,
+	-203.125f,
+	-78.125f,
+	19.6193f,
+	-203.125f,
+	-74.2188f,
+	19.6343f,
+	-203.125f,
+	-70.3125f,
+	19.7814f,
+	-203.125f,
+	-66.4063f,
+	21.45f,
+	-203.125f,
+	-62.5f,
+	24.1224f,
+	-203.125f,
+	-58.5938f,
+	24.9145f,
+	-203.125f,
+	-54.6875f,
+	24.2614f,
+	-203.125f,
+	-50.7813f,
+	24.025f,
+	-203.125f,
+	-46.875f,
+	23.1092f,
+	-203.125f,
+	-42.9688f,
+	24.0294f,
+	-203.125f,
+	-39.0625f,
+	25.4744f,
+	-203.125f,
+	-35.1563f,
+	25.9477f,
+	-203.125f,
+	-31.25f,
+	25.5895f,
+	-203.125f,
+	-27.3438f,
+	25.0752f,
+	-203.125f,
+	-23.4375f,
+	24.6537f,
+	-203.125f,
+	-19.5313f,
+	25.0025f,
+	-203.125f,
+	-15.625f,
+	25.211f,
+	-203.125f,
+	-11.7188f,
+	24.2103f,
+	-203.125f,
+	-7.8125f,
+	23.1363f,
+	-203.125f,
+	-3.90625f,
+	21.4314f,
+	-203.125f,
+	0.0f,
+	20.8784f,
+	-203.125f,
+	3.90625f,
+	20.3179f,
+	-203.125f,
+	-250.0f,
+	18.4857f,
+	-207.031f,
+	-246.094f,
+	18.9103f,
+	-207.031f,
+	-242.188f,
+	17.7666f,
+	-207.031f,
+	-238.281f,
+	18.3803f,
+	-207.031f,
+	-234.375f,
+	17.7746f,
+	-207.031f,
+	-230.469f,
+	18.1956f,
+	-207.031f,
+	-226.563f,
+	17.4596f,
+	-207.031f,
+	-222.656f,
+	16.5346f,
+	-207.031f,
+	-218.75f,
+	15.3933f,
+	-207.031f,
+	-214.844f,
+	14.0342f,
+	-207.031f,
+	-210.938f,
+	11.5492f,
+	-207.031f,
+	-207.031f,
+	10.8526f,
+	-207.031f,
+	-203.125f,
+	10.5164f,
+	-207.031f,
+	-199.219f,
+	10.4957f,
+	-207.031f,
+	-195.313f,
+	9.57889f,
+	-207.031f,
+	-191.406f,
+	9.42031f,
+	-207.031f,
+	-187.5f,
+	9.08544f,
+	-207.031f,
+	-183.594f,
+	8.10082f,
+	-207.031f,
+	-179.688f,
+	8.5632f,
+	-207.031f,
+	-175.781f,
+	8.74392f,
+	-207.031f,
+	-171.875f,
+	8.56175f,
+	-207.031f,
+	-167.969f,
+	7.13665f,
+	-207.031f,
+	-164.063f,
+	6.99003f,
+	-207.031f,
+	-160.156f,
+	7.1192f,
+	-207.031f,
+	-156.25f,
+	6.173f,
+	-207.031f,
+	-152.344f,
+	6.44193f,
+	-207.031f,
+	-148.438f,
+	7.15583f,
+	-207.031f,
+	-144.531f,
+	7.74526f,
+	-207.031f,
+	-140.625f,
+	9.38846f,
+	-207.031f,
+	-136.719f,
+	10.1943f,
+	-207.031f,
+	-132.813f,
+	10.5195f,
+	-207.031f,
+	-128.906f,
+	11.4457f,
+	-207.031f,
+	-125.0f,
+	12.4233f,
+	-207.031f,
+	-121.094f,
+	12.8633f,
+	-207.031f,
+	-117.188f,
+	13.4045f,
+	-207.031f,
+	-113.281f,
+	12.9134f,
+	-207.031f,
+	-109.375f,
+	12.9203f,
+	-207.031f,
+	-105.469f,
+	13.2173f,
+	-207.031f,
+	-101.563f,
+	12.9065f,
+	-207.031f,
+	-97.6563f,
+	12.9327f,
+	-207.031f,
+	-93.75f,
+	13.5926f,
+	-207.031f,
+	-89.8438f,
+	14.5472f,
+	-207.031f,
+	-85.9375f,
+	16.41f,
+	-207.031f,
+	-82.0313f,
+	19.1484f,
+	-207.031f,
+	-78.125f,
+	20.5688f,
+	-207.031f,
+	-74.2188f,
+	20.1464f,
+	-207.031f,
+	-70.3125f,
+	19.9352f,
+	-207.031f,
+	-66.4063f,
+	20.4543f,
+	-207.031f,
+	-62.5f,
+	22.0083f,
+	-207.031f,
+	-58.5938f,
+	23.2866f,
+	-207.031f,
+	-54.6875f,
+	23.3242f,
+	-207.031f,
+	-50.7813f,
+	23.0127f,
+	-207.031f,
+	-46.875f,
+	23.4455f,
+	-207.031f,
+	-42.9688f,
+	23.4808f,
+	-207.031f,
+	-39.0625f,
+	24.4622f,
+	-207.031f,
+	-35.1563f,
+	25.1122f,
+	-207.031f,
+	-31.25f,
+	25.3818f,
+	-207.031f,
+	-27.3438f,
+	24.0051f,
+	-207.031f,
+	-23.4375f,
+	22.3971f,
+	-207.031f,
+	-19.5313f,
+	23.4811f,
+	-207.031f,
+	-15.625f,
+	23.8447f,
+	-207.031f,
+	-11.7188f,
+	22.3912f,
+	-207.031f,
+	-7.8125f,
+	21.7286f,
+	-207.031f,
+	-3.90625f,
+	20.1632f,
+	-207.031f,
+	0.0f,
+	18.6587f,
+	-207.031f,
+	3.90625f,
+	18.3149f,
+	-207.031f,
+	-250.0f,
+	17.6517f,
+	-210.938f,
+	-246.094f,
+	17.8132f,
+	-210.938f,
+	-242.188f,
+	17.4894f,
+	-210.938f,
+	-238.281f,
+	16.7087f,
+	-210.938f,
+	-234.375f,
+	15.9111f,
+	-210.938f,
+	-230.469f,
+	16.6733f,
+	-210.938f,
+	-226.563f,
+	16.6911f,
+	-210.938f,
+	-222.656f,
+	14.6177f,
+	-210.938f,
+	-218.75f,
+	13.6959f,
+	-210.938f,
+	-214.844f,
+	12.227f,
+	-210.938f,
+	-210.938f,
+	11.5376f,
+	-210.938f,
+	-207.031f,
+	11.7259f,
+	-210.938f,
+	-203.125f,
+	11.4804f,
+	-210.938f,
+	-199.219f,
+	11.8728f,
+	-210.938f,
+	-195.313f,
+	11.7357f,
+	-210.938f,
+	-191.406f,
+	10.6319f,
+	-210.938f,
+	-187.5f,
+	10.7016f,
+	-210.938f,
+	-183.594f,
+	9.53811f,
+	-210.938f,
+	-179.688f,
+	9.65149f,
+	-210.938f,
+	-175.781f,
+	9.45993f,
+	-210.938f,
+	-171.875f,
+	9.4427f,
+	-210.938f,
+	-167.969f,
+	8.02525f,
+	-210.938f,
+	-164.063f,
+	6.71089f,
+	-210.938f,
+	-160.156f,
+	7.22567f,
+	-210.938f,
+	-156.25f,
+	7.52391f,
+	-210.938f,
+	-152.344f,
+	8.46765f,
+	-210.938f,
+	-148.438f,
+	8.60801f,
+	-210.938f,
+	-144.531f,
+	9.89046f,
+	-210.938f,
+	-140.625f,
+	10.9163f,
+	-210.938f,
+	-136.719f,
+	11.445f,
+	-210.938f,
+	-132.813f,
+	12.6949f,
+	-210.938f,
+	-128.906f,
+	13.3645f,
+	-210.938f,
+	-125.0f,
+	14.5389f,
+	-210.938f,
+	-121.094f,
+	14.7689f,
+	-210.938f,
+	-117.188f,
+	15.8285f,
+	-210.938f,
+	-113.281f,
+	15.5058f,
+	-210.938f,
+	-109.375f,
+	14.3542f,
+	-210.938f,
+	-105.469f,
+	14.9928f,
+	-210.938f,
+	-101.563f,
+	14.9601f,
+	-210.938f,
+	-97.6563f,
+	15.1602f,
+	-210.938f,
+	-93.75f,
+	15.1589f,
+	-210.938f,
+	-89.8438f,
+	16.5401f,
+	-210.938f,
+	-85.9375f,
+	18.2407f,
+	-210.938f,
+	-82.0313f,
+	19.8006f,
+	-210.938f,
+	-78.125f,
+	20.9223f,
+	-210.938f,
+	-74.2188f,
+	20.5615f,
+	-210.938f,
+	-70.3125f,
+	21.0505f,
+	-210.938f,
+	-66.4063f,
+	21.024f,
+	-210.938f,
+	-62.5f,
+	21.7216f,
+	-210.938f,
+	-58.5938f,
+	22.8737f,
+	-210.938f,
+	-54.6875f,
+	23.631f,
+	-210.938f,
+	-50.7813f,
+	23.6265f,
+	-210.938f,
+	-46.875f,
+	23.5636f,
+	-210.938f,
+	-42.9688f,
+	24.1299f,
+	-210.938f,
+	-39.0625f,
+	24.6395f,
+	-210.938f,
+	-35.1563f,
+	25.3237f,
+	-210.938f,
+	-31.25f,
+	24.7459f,
+	-210.938f,
+	-27.3438f,
+	22.2327f,
+	-210.938f,
+	-23.4375f,
+	21.6309f,
+	-210.938f,
+	-19.5313f,
+	22.3059f,
+	-210.938f,
+	-15.625f,
+	22.1894f,
+	-210.938f,
+	-11.7188f,
+	21.2088f,
+	-210.938f,
+	-7.8125f,
+	20.3383f,
+	-210.938f,
+	-3.90625f,
+	18.4799f,
+	-210.938f,
+	0.0f,
+	17.18f,
+	-210.938f,
+	3.90625f,
+	16.2147f,
+	-210.938f,
+	-250.0f,
+	17.6547f,
+	-214.844f,
+	-246.094f,
+	17.1845f,
+	-214.844f,
+	-242.188f,
+	17.6913f,
+	-214.844f,
+	-238.281f,
+	16.8842f,
+	-214.844f,
+	-234.375f,
+	14.7169f,
+	-214.844f,
+	-230.469f,
+	15.4287f,
+	-214.844f,
+	-226.563f,
+	14.5659f,
+	-214.844f,
+	-222.656f,
+	13.1756f,
+	-214.844f,
+	-218.75f,
+	12.021f,
+	-214.844f,
+	-214.844f,
+	11.9663f,
+	-214.844f,
+	-210.938f,
+	12.535f,
+	-214.844f,
+	-207.031f,
+	12.5802f,
+	-214.844f,
+	-203.125f,
+	12.7437f,
+	-214.844f,
+	-199.219f,
+	12.9859f,
+	-214.844f,
+	-195.313f,
+	12.7714f,
+	-214.844f,
+	-191.406f,
+	11.9783f,
+	-214.844f,
+	-187.5f,
+	11.9282f,
+	-214.844f,
+	-183.594f,
+	10.7633f,
+	-214.844f,
+	-179.688f,
+	10.3463f,
+	-214.844f,
+	-175.781f,
+	10.1867f,
+	-214.844f,
+	-171.875f,
+	10.378f,
+	-214.844f,
+	-167.969f,
+	8.81572f,
+	-214.844f,
+	-164.063f,
+	7.29133f,
+	-214.844f,
+	-160.156f,
+	8.45242f,
+	-214.844f,
+	-156.25f,
+	9.77224f,
+	-214.844f,
+	-152.344f,
+	10.4567f,
+	-214.844f,
+	-148.438f,
+	11.0484f,
+	-214.844f,
+	-144.531f,
+	12.1985f,
+	-214.844f,
+	-140.625f,
+	13.766f,
+	-214.844f,
+	-136.719f,
+	14.9123f,
+	-214.844f,
+	-132.813f,
+	15.4577f,
+	-214.844f,
+	-128.906f,
+	16.3401f,
+	-214.844f,
+	-125.0f,
+	16.5963f,
+	-214.844f,
+	-121.094f,
+	16.9605f,
+	-214.844f,
+	-117.188f,
+	16.548f,
+	-214.844f,
+	-113.281f,
+	16.701f,
+	-214.844f,
+	-109.375f,
+	16.6987f,
+	-214.844f,
+	-105.469f,
+	16.1393f,
+	-214.844f,
+	-101.563f,
+	15.4379f,
+	-214.844f,
+	-97.6563f,
+	15.9931f,
+	-214.844f,
+	-93.75f,
+	16.7962f,
+	-214.844f,
+	-89.8438f,
+	18.5464f,
+	-214.844f,
+	-85.9375f,
+	20.2834f,
+	-214.844f,
+	-82.0313f,
+	20.8463f,
+	-214.844f,
+	-78.125f,
+	21.263f,
+	-214.844f,
+	-74.2188f,
+	22.137f,
+	-214.844f,
+	-70.3125f,
+	22.1614f,
+	-214.844f,
+	-66.4063f,
+	21.7706f,
+	-214.844f,
+	-62.5f,
+	23.0496f,
+	-214.844f,
+	-58.5938f,
+	23.0762f,
+	-214.844f,
+	-54.6875f,
+	24.2163f,
+	-214.844f,
+	-50.7813f,
+	23.9415f,
+	-214.844f,
+	-46.875f,
+	23.115f,
+	-214.844f,
+	-42.9688f,
+	24.4371f,
+	-214.844f,
+	-39.0625f,
+	25.7433f,
+	-214.844f,
+	-35.1563f,
+	24.6385f,
+	-214.844f,
+	-31.25f,
+	23.2822f,
+	-214.844f,
+	-27.3438f,
+	21.8583f,
+	-214.844f,
+	-23.4375f,
+	21.2352f,
+	-214.844f,
+	-19.5313f,
+	21.3084f,
+	-214.844f,
+	-15.625f,
+	20.7264f,
+	-214.844f,
+	-11.7188f,
+	19.67f,
+	-214.844f,
+	-7.8125f,
+	18.8192f,
+	-214.844f,
+	-3.90625f,
+	16.6504f,
+	-214.844f,
+	0.0f,
+	14.8779f,
+	-214.844f,
+	3.90625f,
+	14.284f,
+	-214.844f,
+	-250.0f,
+	17.1549f,
+	-218.75f,
+	-246.094f,
+	16.6295f,
+	-218.75f,
+	-242.188f,
+	17.7459f,
+	-218.75f,
+	-238.281f,
+	17.3894f,
+	-218.75f,
+	-234.375f,
+	15.2738f,
+	-218.75f,
+	-230.469f,
+	13.3984f,
+	-218.75f,
+	-226.563f,
+	12.8639f,
+	-218.75f,
+	-222.656f,
+	12.3225f,
+	-218.75f,
+	-218.75f,
+	12.1914f,
+	-218.75f,
+	-214.844f,
+	12.4104f,
+	-218.75f,
+	-210.938f,
+	12.9278f,
+	-218.75f,
+	-207.031f,
+	13.387f,
+	-218.75f,
+	-203.125f,
+	13.4342f,
+	-218.75f,
+	-199.219f,
+	12.7445f,
+	-218.75f,
+	-195.313f,
+	12.543f,
+	-218.75f,
+	-191.406f,
+	12.1437f,
+	-218.75f,
+	-187.5f,
+	12.3491f,
+	-218.75f,
+	-183.594f,
+	11.2334f,
+	-218.75f,
+	-179.688f,
+	11.4016f,
+	-218.75f,
+	-175.781f,
+	11.2455f,
+	-218.75f,
+	-171.875f,
+	10.3681f,
+	-218.75f,
+	-167.969f,
+	9.23056f,
+	-218.75f,
+	-164.063f,
+	8.35869f,
+	-218.75f,
+	-160.156f,
+	10.3612f,
+	-218.75f,
+	-156.25f,
+	11.8429f,
+	-218.75f,
+	-152.344f,
+	13.2154f,
+	-218.75f,
+	-148.438f,
+	13.6238f,
+	-218.75f,
+	-144.531f,
+	14.8343f,
+	-218.75f,
+	-140.625f,
+	15.5549f,
+	-218.75f,
+	-136.719f,
+	16.9496f,
+	-218.75f,
+	-132.813f,
+	17.9187f,
+	-218.75f,
+	-128.906f,
+	17.7467f,
+	-218.75f,
+	-125.0f,
+	17.8229f,
+	-218.75f,
+	-121.094f,
+	17.4408f,
+	-218.75f,
+	-117.188f,
+	17.3929f,
+	-218.75f,
+	-113.281f,
+	17.9861f,
+	-218.75f,
+	-109.375f,
+	18.0206f,
+	-218.75f,
+	-105.469f,
+	17.6787f,
+	-218.75f,
+	-101.563f,
+	17.3769f,
+	-218.75f,
+	-97.6563f,
+	17.5683f,
+	-218.75f,
+	-93.75f,
+	18.0067f,
+	-218.75f,
+	-89.8438f,
+	18.9639f,
+	-218.75f,
+	-85.9375f,
+	20.8377f,
+	-218.75f,
+	-82.0313f,
+	22.207f,
+	-218.75f,
+	-78.125f,
+	23.1239f,
+	-218.75f,
+	-74.2188f,
+	22.384f,
+	-218.75f,
+	-70.3125f,
+	22.2939f,
+	-218.75f,
+	-66.4063f,
+	21.8208f,
+	-218.75f,
+	-62.5f,
+	22.9458f,
+	-218.75f,
+	-58.5938f,
+	24.2547f,
+	-218.75f,
+	-54.6875f,
+	24.5855f,
+	-218.75f,
+	-50.7813f,
+	23.9529f,
+	-218.75f,
+	-46.875f,
+	22.9226f,
+	-218.75f,
+	-42.9688f,
+	25.1015f,
+	-218.75f,
+	-39.0625f,
+	25.1591f,
+	-218.75f,
+	-35.1563f,
+	23.6146f,
+	-218.75f,
+	-31.25f,
+	21.7924f,
+	-218.75f,
+	-27.3438f,
+	20.3147f,
+	-218.75f,
+	-23.4375f,
+	19.9227f,
+	-218.75f,
+	-19.5313f,
+	20.3267f,
+	-218.75f,
+	-15.625f,
+	19.1903f,
+	-218.75f,
+	-11.7188f,
+	17.3132f,
+	-218.75f,
+	-7.8125f,
+	16.5145f,
+	-218.75f,
+	-3.90625f,
+	15.5991f,
+	-218.75f,
+	0.0f,
+	13.7865f,
+	-218.75f,
+	3.90625f,
+	13.272f,
+	-218.75f,
+	-250.0f,
+	16.7536f,
+	-222.656f,
+	-246.094f,
+	16.7692f,
+	-222.656f,
+	-242.188f,
+	17.6216f,
+	-222.656f,
+	-238.281f,
+	17.7524f,
+	-222.656f,
+	-234.375f,
+	15.7102f,
+	-222.656f,
+	-230.469f,
+	13.9934f,
+	-222.656f,
+	-226.563f,
+	13.1311f,
+	-222.656f,
+	-222.656f,
+	13.6218f,
+	-222.656f,
+	-218.75f,
+	13.8812f,
+	-222.656f,
+	-214.844f,
+	13.6928f,
+	-222.656f,
+	-210.938f,
+	13.2498f,
+	-222.656f,
+	-207.031f,
+	13.9199f,
+	-222.656f,
+	-203.125f,
+	14.8224f,
+	-222.656f,
+	-199.219f,
+	14.7821f,
+	-222.656f,
+	-195.313f,
+	14.4118f,
+	-222.656f,
+	-191.406f,
+	13.2421f,
+	-222.656f,
+	-187.5f,
+	13.1953f,
+	-222.656f,
+	-183.594f,
+	11.9441f,
+	-222.656f,
+	-179.688f,
+	11.8006f,
+	-222.656f,
+	-175.781f,
+	11.2509f,
+	-222.656f,
+	-171.875f,
+	9.7863f,
+	-222.656f,
+	-167.969f,
+	8.85086f,
+	-222.656f,
+	-164.063f,
+	10.6896f,
+	-222.656f,
+	-160.156f,
+	12.9132f,
+	-222.656f,
+	-156.25f,
+	13.602f,
+	-222.656f,
+	-152.344f,
+	15.3711f,
+	-222.656f,
+	-148.438f,
+	16.1768f,
+	-222.656f,
+	-144.531f,
+	16.9203f,
+	-222.656f,
+	-140.625f,
+	17.0404f,
+	-222.656f,
+	-136.719f,
+	18.4968f,
+	-222.656f,
+	-132.813f,
+	18.8222f,
+	-222.656f,
+	-128.906f,
+	19.2736f,
+	-222.656f,
+	-125.0f,
+	19.1956f,
+	-222.656f,
+	-121.094f,
+	18.5998f,
+	-222.656f,
+	-117.188f,
+	18.5054f,
+	-222.656f,
+	-113.281f,
+	19.68f,
+	-222.656f,
+	-109.375f,
+	19.5038f,
+	-222.656f,
+	-105.469f,
+	19.4749f,
+	-222.656f,
+	-101.563f,
+	18.7504f,
+	-222.656f,
+	-97.6563f,
+	18.6121f,
+	-222.656f,
+	-93.75f,
+	19.1119f,
+	-222.656f,
+	-89.8438f,
+	20.5347f,
+	-222.656f,
+	-85.9375f,
+	21.4412f,
+	-222.656f,
+	-82.0313f,
+	22.187f,
+	-222.656f,
+	-78.125f,
+	22.9384f,
+	-222.656f,
+	-74.2188f,
+	22.5226f,
+	-222.656f,
+	-70.3125f,
+	22.7323f,
+	-222.656f,
+	-66.4063f,
+	23.4931f,
+	-222.656f,
+	-62.5f,
+	24.6895f,
+	-222.656f,
+	-58.5938f,
+	24.9745f,
+	-222.656f,
+	-54.6875f,
+	24.801f,
+	-222.656f,
+	-50.7813f,
+	23.2235f,
+	-222.656f,
+	-46.875f,
+	22.4973f,
+	-222.656f,
+	-42.9688f,
+	23.9826f,
+	-222.656f,
+	-39.0625f,
+	23.4458f,
+	-222.656f,
+	-35.1563f,
+	22.66f,
+	-222.656f,
+	-31.25f,
+	20.8011f,
+	-222.656f,
+	-27.3438f,
+	18.877f,
+	-222.656f,
+	-23.4375f,
+	17.9999f,
+	-222.656f,
+	-19.5313f,
+	18.2206f,
+	-222.656f,
+	-15.625f,
+	17.8501f,
+	-222.656f,
+	-11.7188f,
+	16.2125f,
+	-222.656f,
+	-7.8125f,
+	15.4897f,
+	-222.656f,
+	-3.90625f,
+	14.2048f,
+	-222.656f,
+	0.0f,
+	13.1443f,
+	-222.656f,
+	3.90625f,
+	13.0199f,
+	-222.656f,
+	-250.0f,
+	15.9959f,
+	-226.563f,
+	-246.094f,
+	16.3902f,
+	-226.563f,
+	-242.188f,
+	17.2433f,
+	-226.563f,
+	-238.281f,
+	16.8903f,
+	-226.563f,
+	-234.375f,
+	16.2616f,
+	-226.563f,
+	-230.469f,
+	16.3335f,
+	-226.563f,
+	-226.563f,
+	15.3662f,
+	-226.563f,
+	-222.656f,
+	14.6429f,
+	-226.563f,
+	-218.75f,
+	15.2987f,
+	-226.563f,
+	-214.844f,
+	15.1249f,
+	-226.563f,
+	-210.938f,
+	14.6321f,
+	-226.563f,
+	-207.031f,
+	15.402f,
+	-226.563f,
+	-203.125f,
+	15.5803f,
+	-226.563f,
+	-199.219f,
+	15.8024f,
+	-226.563f,
+	-195.313f,
+	14.9564f,
+	-226.563f,
+	-191.406f,
+	14.7272f,
+	-226.563f,
+	-187.5f,
+	14.0749f,
+	-226.563f,
+	-183.594f,
+	12.2838f,
+	-226.563f,
+	-179.688f,
+	12.0268f,
+	-226.563f,
+	-175.781f,
+	10.904f,
+	-226.563f,
+	-171.875f,
+	10.0049f,
+	-226.563f,
+	-167.969f,
+	9.85558f,
+	-226.563f,
+	-164.063f,
+	11.873f,
+	-226.563f,
+	-160.156f,
+	14.0684f,
+	-226.563f,
+	-156.25f,
+	15.4765f,
+	-226.563f,
+	-152.344f,
+	16.7458f,
+	-226.563f,
+	-148.438f,
+	17.9359f,
+	-226.563f,
+	-144.531f,
+	18.4507f,
+	-226.563f,
+	-140.625f,
+	18.3457f,
+	-226.563f,
+	-136.719f,
+	20.0059f,
+	-226.563f,
+	-132.813f,
+	20.3125f,
+	-226.563f,
+	-128.906f,
+	19.751f,
+	-226.563f,
+	-125.0f,
+	19.8084f,
+	-226.563f,
+	-121.094f,
+	19.9091f,
+	-226.563f,
+	-117.188f,
+	20.3401f,
+	-226.563f,
+	-113.281f,
+	20.8121f,
+	-226.563f,
+	-109.375f,
+	20.5705f,
+	-226.563f,
+	-105.469f,
+	20.9909f,
+	-226.563f,
+	-101.563f,
+	20.4171f,
+	-226.563f,
+	-97.6563f,
+	19.834f,
+	-226.563f,
+	-93.75f,
+	19.9289f,
+	-226.563f,
+	-89.8438f,
+	20.4305f,
+	-226.563f,
+	-85.9375f,
+	21.4097f,
+	-226.563f,
+	-82.0313f,
+	21.9666f,
+	-226.563f,
+	-78.125f,
+	22.5232f,
+	-226.563f,
+	-74.2188f,
+	22.2049f,
+	-226.563f,
+	-70.3125f,
+	22.7045f,
+	-226.563f,
+	-66.4063f,
+	23.7933f,
+	-226.563f,
+	-62.5f,
+	24.5938f,
+	-226.563f,
+	-58.5938f,
+	24.6161f,
+	-226.563f,
+	-54.6875f,
+	23.6008f,
+	-226.563f,
+	-50.7813f,
+	21.9411f,
+	-226.563f,
+	-46.875f,
+	21.6164f,
+	-226.563f,
+	-42.9688f,
+	22.5551f,
+	-226.563f,
+	-39.0625f,
+	22.5032f,
+	-226.563f,
+	-35.1563f,
+	21.5165f,
+	-226.563f,
+	-31.25f,
+	19.8362f,
+	-226.563f,
+	-27.3438f,
+	17.5967f,
+	-226.563f,
+	-23.4375f,
+	15.6932f,
+	-226.563f,
+	-19.5313f,
+	15.7774f,
+	-226.563f,
+	-15.625f,
+	15.6405f,
+	-226.563f,
+	-11.7188f,
+	14.7549f,
+	-226.563f,
+	-7.8125f,
+	14.3205f,
+	-226.563f,
+	-3.90625f,
+	13.2947f,
+	-226.563f,
+	0.0f,
+	11.9266f,
+	-226.563f,
+	3.90625f,
+	11.9733f,
+	-226.563f,
+	-250.0f,
+	15.2423f,
+	-230.469f,
+	-246.094f,
+	16.2143f,
+	-230.469f,
+	-242.188f,
+	17.2462f,
+	-230.469f,
+	-238.281f,
+	17.7941f,
+	-230.469f,
+	-234.375f,
+	18.4029f,
+	-230.469f,
+	-230.469f,
+	18.5726f,
+	-230.469f,
+	-226.563f,
+	17.4729f,
+	-230.469f,
+	-222.656f,
+	15.9467f,
+	-230.469f,
+	-218.75f,
+	15.5021f,
+	-230.469f,
+	-214.844f,
+	15.7096f,
+	-230.469f,
+	-210.938f,
+	15.6276f,
+	-230.469f,
+	-207.031f,
+	15.7025f,
+	-230.469f,
+	-203.125f,
+	14.8851f,
+	-230.469f,
+	-199.219f,
+	14.87f,
+	-230.469f,
+	-195.313f,
+	14.3971f,
+	-230.469f,
+	-191.406f,
+	14.5771f,
+	-230.469f,
+	-187.5f,
+	13.8163f,
+	-230.469f,
+	-183.594f,
+	12.7605f,
+	-230.469f,
+	-179.688f,
+	12.587f,
+	-230.469f,
+	-175.781f,
+	11.0727f,
+	-230.469f,
+	-171.875f,
+	10.0166f,
+	-230.469f,
+	-167.969f,
+	12.5787f,
+	-230.469f,
+	-164.063f,
+	13.3613f,
+	-230.469f,
+	-160.156f,
+	14.7537f,
+	-230.469f,
+	-156.25f,
+	15.9879f,
+	-230.469f,
+	-152.344f,
+	17.6792f,
+	-230.469f,
+	-148.438f,
+	18.5224f,
+	-230.469f,
+	-144.531f,
+	18.5026f,
+	-230.469f,
+	-140.625f,
+	19.4852f,
+	-230.469f,
+	-136.719f,
+	20.3222f,
+	-230.469f,
+	-132.813f,
+	20.2809f,
+	-230.469f,
+	-128.906f,
+	21.0408f,
+	-230.469f,
+	-125.0f,
+	20.4729f,
+	-230.469f,
+	-121.094f,
+	20.8829f,
+	-230.469f,
+	-117.188f,
+	21.532f,
+	-230.469f,
+	-113.281f,
+	21.3373f,
+	-230.469f,
+	-109.375f,
+	22.0014f,
+	-230.469f,
+	-105.469f,
+	22.1484f,
+	-230.469f,
+	-101.563f,
+	21.7053f,
+	-230.469f,
+	-97.6563f,
+	20.5255f,
+	-230.469f,
+	-93.75f,
+	19.6269f,
+	-230.469f,
+	-89.8438f,
+	20.0012f,
+	-230.469f,
+	-85.9375f,
+	21.0697f,
+	-230.469f,
+	-82.0313f,
+	21.8192f,
+	-230.469f,
+	-78.125f,
+	22.7525f,
+	-230.469f,
+	-74.2188f,
+	22.3932f,
+	-230.469f,
+	-70.3125f,
+	22.0383f,
+	-230.469f,
+	-66.4063f,
+	22.5989f,
+	-230.469f,
+	-62.5f,
+	23.0428f,
+	-230.469f,
+	-58.5938f,
+	22.4512f,
+	-230.469f,
+	-54.6875f,
+	21.5848f,
+	-230.469f,
+	-50.7813f,
+	20.085f,
+	-230.469f,
+	-46.875f,
+	19.9106f,
+	-230.469f,
+	-42.9688f,
+	20.5256f,
+	-230.469f,
+	-39.0625f,
+	20.2072f,
+	-230.469f,
+	-35.1563f,
+	18.9414f,
+	-230.469f,
+	-31.25f,
+	17.9342f,
+	-230.469f,
+	-27.3438f,
+	15.3472f,
+	-230.469f,
+	-23.4375f,
+	13.2173f,
+	-230.469f,
+	-19.5313f,
+	13.1448f,
+	-230.469f,
+	-15.625f,
+	13.7506f,
+	-230.469f,
+	-11.7188f,
+	12.7439f,
+	-230.469f,
+	-7.8125f,
+	12.5338f,
+	-230.469f,
+	-3.90625f,
+	12.0435f,
+	-230.469f,
+	0.0f,
+	11.0483f,
+	-230.469f,
+	3.90625f,
+	10.4619f,
+	-230.469f,
+	-250.0f,
+	15.6879f,
+	-234.375f,
+	-246.094f,
+	17.6667f,
+	-234.375f,
+	-242.188f,
+	18.8427f,
+	-234.375f,
+	-238.281f,
+	19.6527f,
+	-234.375f,
+	-234.375f,
+	19.7979f,
+	-234.375f,
+	-230.469f,
+	19.8698f,
+	-234.375f,
+	-226.563f,
+	19.1736f,
+	-234.375f,
+	-222.656f,
+	16.9995f,
+	-234.375f,
+	-218.75f,
+	15.4573f,
+	-234.375f,
+	-214.844f,
+	15.6294f,
+	-234.375f,
+	-210.938f,
+	15.4315f,
+	-234.375f,
+	-207.031f,
+	15.1239f,
+	-234.375f,
+	-203.125f,
+	14.669f,
+	-234.375f,
+	-199.219f,
+	14.4586f,
+	-234.375f,
+	-195.313f,
+	14.1329f,
+	-234.375f,
+	-191.406f,
+	14.0558f,
+	-234.375f,
+	-187.5f,
+	13.3746f,
+	-234.375f,
+	-183.594f,
+	13.2348f,
+	-234.375f,
+	-179.688f,
+	13.3354f,
+	-234.375f,
+	-175.781f,
+	12.1532f,
+	-234.375f,
+	-171.875f,
+	11.4785f,
+	-234.375f,
+	-167.969f,
+	12.7174f,
+	-234.375f,
+	-164.063f,
+	14.0617f,
+	-234.375f,
+	-160.156f,
+	15.3367f,
+	-234.375f,
+	-156.25f,
+	16.6196f,
+	-234.375f,
+	-152.344f,
+	17.6677f,
+	-234.375f,
+	-148.438f,
+	18.475f,
+	-234.375f,
+	-144.531f,
+	19.8205f,
+	-234.375f,
+	-140.625f,
+	19.6973f,
+	-234.375f,
+	-136.719f,
+	20.5952f,
+	-234.375f,
+	-132.813f,
+	20.3507f,
+	-234.375f,
+	-128.906f,
+	20.8729f,
+	-234.375f,
+	-125.0f,
+	21.9377f,
+	-234.375f,
+	-121.094f,
+	21.8916f,
+	-234.375f,
+	-117.188f,
+	21.9614f,
+	-234.375f,
+	-113.281f,
+	22.1752f,
+	-234.375f,
+	-109.375f,
+	22.2881f,
+	-234.375f,
+	-105.469f,
+	23.1063f,
+	-234.375f,
+	-101.563f,
+	23.4826f,
+	-234.375f,
+	-97.6563f,
+	22.5968f,
+	-234.375f,
+	-93.75f,
+	21.3142f,
+	-234.375f,
+	-89.8438f,
+	19.9609f,
+	-234.375f,
+	-85.9375f,
+	21.4353f,
+	-234.375f,
+	-82.0313f,
+	21.9716f,
+	-234.375f,
+	-78.125f,
+	22.6918f,
+	-234.375f,
+	-74.2188f,
+	21.9561f,
+	-234.375f,
+	-70.3125f,
+	21.3085f,
+	-234.375f,
+	-66.4063f,
+	21.4104f,
+	-234.375f,
+	-62.5f,
+	21.4904f,
+	-234.375f,
+	-58.5938f,
+	20.2467f,
+	-234.375f,
+	-54.6875f,
+	19.1535f,
+	-234.375f,
+	-50.7813f,
+	17.9598f,
+	-234.375f,
+	-46.875f,
+	18.0449f,
+	-234.375f,
+	-42.9688f,
+	18.3612f,
+	-234.375f,
+	-39.0625f,
+	17.5008f,
+	-234.375f,
+	-35.1563f,
+	16.7819f,
+	-234.375f,
+	-31.25f,
+	15.4328f,
+	-234.375f,
+	-27.3438f,
+	13.9747f,
+	-234.375f,
+	-23.4375f,
+	12.1868f,
+	-234.375f,
+	-19.5313f,
+	12.0847f,
+	-234.375f,
+	-15.625f,
+	11.926f,
+	-234.375f,
+	-11.7188f,
+	11.3058f,
+	-234.375f,
+	-7.8125f,
+	11.0187f,
+	-234.375f,
+	-3.90625f,
+	10.1275f,
+	-234.375f,
+	0.0f,
+	9.73133f,
+	-234.375f,
+	3.90625f,
+	8.85224f,
+	-234.375f,
+	-250.0f,
+	16.6463f,
+	-238.281f,
+	-246.094f,
+	18.8582f,
+	-238.281f,
+	-242.188f,
+	19.6269f,
+	-238.281f,
+	-238.281f,
+	20.3222f,
+	-238.281f,
+	-234.375f,
+	20.8316f,
+	-238.281f,
+	-230.469f,
+	20.6072f,
+	-238.281f,
+	-226.563f,
+	19.2331f,
+	-238.281f,
+	-222.656f,
+	18.0021f,
+	-238.281f,
+	-218.75f,
+	16.4891f,
+	-238.281f,
+	-214.844f,
+	15.7845f,
+	-238.281f,
+	-210.938f,
+	15.4622f,
+	-238.281f,
+	-207.031f,
+	14.3459f,
+	-238.281f,
+	-203.125f,
+	14.6544f,
+	-238.281f,
+	-199.219f,
+	13.7779f,
+	-238.281f,
+	-195.313f,
+	13.4199f,
+	-238.281f,
+	-191.406f,
+	13.2089f,
+	-238.281f,
+	-187.5f,
+	12.5036f,
+	-238.281f,
+	-183.594f,
+	12.6398f,
+	-238.281f,
+	-179.688f,
+	13.015f,
+	-238.281f,
+	-175.781f,
+	12.659f,
+	-238.281f,
+	-171.875f,
+	13.2801f,
+	-238.281f,
+	-167.969f,
+	13.9547f,
+	-238.281f,
+	-164.063f,
+	14.8792f,
+	-238.281f,
+	-160.156f,
+	16.4144f,
+	-238.281f,
+	-156.25f,
+	17.1062f,
+	-238.281f,
+	-152.344f,
+	17.9028f,
+	-238.281f,
+	-148.438f,
+	19.1823f,
+	-238.281f,
+	-144.531f,
+	20.6903f,
+	-238.281f,
+	-140.625f,
+	19.9053f,
+	-238.281f,
+	-136.719f,
+	20.8795f,
+	-238.281f,
+	-132.813f,
+	21.7034f,
+	-238.281f,
+	-128.906f,
+	21.8373f,
+	-238.281f,
+	-125.0f,
+	22.5134f,
+	-238.281f,
+	-121.094f,
+	22.7918f,
+	-238.281f,
+	-117.188f,
+	23.1126f,
+	-238.281f,
+	-113.281f,
+	23.0308f,
+	-238.281f,
+	-109.375f,
+	23.7212f,
+	-238.281f,
+	-105.469f,
+	24.6127f,
+	-238.281f,
+	-101.563f,
+	24.5942f,
+	-238.281f,
+	-97.6563f,
+	24.0315f,
+	-238.281f,
+	-93.75f,
+	23.2191f,
+	-238.281f,
+	-89.8438f,
+	21.3372f,
+	-238.281f,
+	-85.9375f,
+	20.6395f,
+	-238.281f,
+	-82.0313f,
+	22.2808f,
+	-238.281f,
+	-78.125f,
+	22.2977f,
+	-238.281f,
+	-74.2188f,
+	21.5802f,
+	-238.281f,
+	-70.3125f,
+	20.5131f,
+	-238.281f,
+	-66.4063f,
+	20.0882f,
+	-238.281f,
+	-62.5f,
+	19.9865f,
+	-238.281f,
+	-58.5938f,
+	19.1423f,
+	-238.281f,
+	-54.6875f,
+	16.917f,
+	-238.281f,
+	-50.7813f,
+	16.0256f,
+	-238.281f,
+	-46.875f,
+	15.4122f,
+	-238.281f,
+	-42.9688f,
+	15.0531f,
+	-238.281f,
+	-39.0625f,
+	15.8819f,
+	-238.281f,
+	-35.1563f,
+	14.3724f,
+	-238.281f,
+	-31.25f,
+	12.993f,
+	-238.281f,
+	-27.3438f,
+	11.8948f,
+	-238.281f,
+	-23.4375f,
+	10.1339f,
+	-238.281f,
+	-19.5313f,
+	10.4205f,
+	-238.281f,
+	-15.625f,
+	10.7339f,
+	-238.281f,
+	-11.7188f,
+	9.86852f,
+	-238.281f,
+	-7.8125f,
+	8.89818f,
+	-238.281f,
+	-3.90625f,
+	8.20848f,
+	-238.281f,
+	0.0f,
+	7.89095f,
+	-238.281f,
+	3.90625f,
+	7.99527f,
+	-238.281f,
+	-250.0f,
+	16.461f,
+	-242.188f,
+	-246.094f,
+	18.8623f,
+	-242.188f,
+	-242.188f,
+	19.6097f,
+	-242.188f,
+	-238.281f,
+	20.8167f,
+	-242.188f,
+	-234.375f,
+	21.0667f,
+	-242.188f,
+	-230.469f,
+	20.3337f,
+	-242.188f,
+	-226.563f,
+	18.9993f,
+	-242.188f,
+	-222.656f,
+	17.8141f,
+	-242.188f,
+	-218.75f,
+	17.3651f,
+	-242.188f,
+	-214.844f,
+	16.1703f,
+	-242.188f,
+	-210.938f,
+	15.3612f,
+	-242.188f,
+	-207.031f,
+	14.5062f,
+	-242.188f,
+	-203.125f,
+	14.0333f,
+	-242.188f,
+	-199.219f,
+	13.0731f,
+	-242.188f,
+	-195.313f,
+	13.0716f,
+	-242.188f,
+	-191.406f,
+	12.2773f,
+	-242.188f,
+	-187.5f,
+	12.1599f,
+	-242.188f,
+	-183.594f,
+	12.0841f,
+	-242.188f,
+	-179.688f,
+	11.1979f,
+	-242.188f,
+	-175.781f,
+	11.7767f,
+	-242.188f,
+	-171.875f,
+	13.5192f,
+	-242.188f,
+	-167.969f,
+	13.6117f,
+	-242.188f,
+	-164.063f,
+	14.5377f,
+	-242.188f,
+	-160.156f,
+	16.1128f,
+	-242.188f,
+	-156.25f,
+	17.0591f,
+	-242.188f,
+	-152.344f,
+	18.0547f,
+	-242.188f,
+	-148.438f,
+	19.9927f,
+	-242.188f,
+	-144.531f,
+	20.5592f,
+	-242.188f,
+	-140.625f,
+	20.5602f,
+	-242.188f,
+	-136.719f,
+	20.6585f,
+	-242.188f,
+	-132.813f,
+	22.6924f,
+	-242.188f,
+	-128.906f,
+	23.4786f,
+	-242.188f,
+	-125.0f,
+	23.9921f,
+	-242.188f,
+	-121.094f,
+	24.3221f,
+	-242.188f,
+	-117.188f,
+	24.7845f,
+	-242.188f,
+	-113.281f,
+	24.0995f,
+	-242.188f,
+	-109.375f,
+	25.5836f,
+	-242.188f,
+	-105.469f,
+	25.1932f,
+	-242.188f,
+	-101.563f,
+	25.0022f,
+	-242.188f,
+	-97.6563f,
+	24.569f,
+	-242.188f,
+	-93.75f,
+	24.5749f,
+	-242.188f,
+	-89.8438f,
+	22.6678f,
+	-242.188f,
+	-85.9375f,
+	20.6652f,
+	-242.188f,
+	-82.0313f,
+	21.1719f,
+	-242.188f,
+	-78.125f,
+	21.9102f,
+	-242.188f,
+	-74.2188f,
+	20.9512f,
+	-242.188f,
+	-70.3125f,
+	19.1099f,
+	-242.188f,
+	-66.4063f,
+	18.2366f,
+	-242.188f,
+	-62.5f,
+	16.9751f,
+	-242.188f,
+	-58.5938f,
+	16.938f,
+	-242.188f,
+	-54.6875f,
+	16.3692f,
+	-242.188f,
+	-50.7813f,
+	14.5702f,
+	-242.188f,
+	-46.875f,
+	13.5527f,
+	-242.188f,
+	-42.9688f,
+	13.0169f,
+	-242.188f,
+	-39.0625f,
+	11.9599f,
+	-242.188f,
+	-35.1563f,
+	11.4675f,
+	-242.188f,
+	-31.25f,
+	10.1264f,
+	-242.188f,
+	-27.3438f,
+	9.05124f,
+	-242.188f,
+	-23.4375f,
+	8.17722f,
+	-242.188f,
+	-19.5313f,
+	8.42066f,
+	-242.188f,
+	-15.625f,
+	8.13199f,
+	-242.188f,
+	-11.7188f,
+	7.70744f,
+	-242.188f,
+	-7.8125f,
+	7.06448f,
+	-242.188f,
+	-3.90625f,
+	6.2428f,
+	-242.188f,
+	0.0f,
+	6.35893f,
+	-242.188f,
+	3.90625f,
+	6.40337f,
+	-242.188f,
+	-250.0f,
+	16.6546f,
+	-246.094f,
+	-246.094f,
+	17.6689f,
+	-246.094f,
+	-242.188f,
+	18.7575f,
+	-246.094f,
+	-238.281f,
+	20.3967f,
+	-246.094f,
+	-234.375f,
+	20.3065f,
+	-246.094f,
+	-230.469f,
+	20.2082f,
+	-246.094f,
+	-226.563f,
+	19.5383f,
+	-246.094f,
+	-222.656f,
+	17.7409f,
+	-246.094f,
+	-218.75f,
+	16.6708f,
+	-246.094f,
+	-214.844f,
+	15.9584f,
+	-246.094f,
+	-210.938f,
+	14.8412f,
+	-246.094f,
+	-207.031f,
+	14.5591f,
+	-246.094f,
+	-203.125f,
+	13.9049f,
+	-246.094f,
+	-199.219f,
+	12.4723f,
+	-246.094f,
+	-195.313f,
+	11.7361f,
+	-246.094f,
+	-191.406f,
+	11.5463f,
+	-246.094f,
+	-187.5f,
+	10.9687f,
+	-246.094f,
+	-183.594f,
+	10.6795f,
+	-246.094f,
+	-179.688f,
+	10.6856f,
+	-246.094f,
+	-175.781f,
+	10.6342f,
+	-246.094f,
+	-171.875f,
+	12.061f,
+	-246.094f,
+	-167.969f,
+	12.3131f,
+	-246.094f,
+	-164.063f,
+	13.8453f,
+	-246.094f,
+	-160.156f,
+	15.3522f,
+	-246.094f,
+	-156.25f,
+	16.575f,
+	-246.094f,
+	-152.344f,
+	17.953f,
+	-246.094f,
+	-148.438f,
+	18.9271f,
+	-246.094f,
+	-144.531f,
+	19.6463f,
+	-246.094f,
+	-140.625f,
+	20.0348f,
+	-246.094f,
+	-136.719f,
+	20.8966f,
+	-246.094f,
+	-132.813f,
+	22.7081f,
+	-246.094f,
+	-128.906f,
+	24.2289f,
+	-246.094f,
+	-125.0f,
+	24.3296f,
+	-246.094f,
+	-121.094f,
+	25.513f,
+	-246.094f,
+	-117.188f,
+	26.0616f,
+	-246.094f,
+	-113.281f,
+	25.9026f,
+	-246.094f,
+	-109.375f,
+	25.3793f,
+	-246.094f,
+	-105.469f,
+	26.0086f,
+	-246.094f,
+	-101.563f,
+	25.9668f,
+	-246.094f,
+	-97.6563f,
+	25.4377f,
+	-246.094f,
+	-93.75f,
+	24.6398f,
+	-246.094f,
+	-89.8438f,
+	22.6277f,
+	-246.094f,
+	-85.9375f,
+	20.9377f,
+	-246.094f,
+	-82.0313f,
+	20.5815f,
+	-246.094f,
+	-78.125f,
+	20.2521f,
+	-246.094f,
+	-74.2188f,
+	19.1439f,
+	-246.094f,
+	-70.3125f,
+	17.8492f,
+	-246.094f,
+	-66.4063f,
+	16.6347f,
+	-246.094f,
+	-62.5f,
+	15.9154f,
+	-246.094f,
+	-58.5938f,
+	14.2098f,
+	-246.094f,
+	-54.6875f,
+	13.5957f,
+	-246.094f,
+	-50.7813f,
+	12.5676f,
+	-246.094f,
+	-46.875f,
+	11.2422f,
+	-246.094f,
+	-42.9688f,
+	10.426f,
+	-246.094f,
+	-39.0625f,
+	10.1665f,
+	-246.094f,
+	-35.1563f,
+	9.19605f,
+	-246.094f,
+	-31.25f,
+	7.36042f,
+	-246.094f,
+	-27.3438f,
+	5.74959f,
+	-246.094f,
+	-23.4375f,
+	5.41512f,
+	-246.094f,
+	-19.5313f,
+	6.03312f,
+	-246.094f,
+	-15.625f,
+	5.93285f,
+	-246.094f,
+	-11.7188f,
+	5.3331f,
+	-246.094f,
+	-7.8125f,
+	5.48059f,
+	-246.094f,
+	-3.90625f,
+	4.92566f,
+	-246.094f,
+	0.0f,
+	5.05645f,
+	-246.094f,
+	3.90625f,
+	6.09425f,
+	-246.094f,
+	-250.0f,
+	17.2418f,
+	-250.0f,
+	-246.094f,
+	17.9679f,
+	-250.0f,
+	-242.188f,
+	19.359f,
+	-250.0f,
+	-238.281f,
+	19.3277f,
+	-250.0f,
+	-234.375f,
+	20.1575f,
+	-250.0f,
+	-230.469f,
+	19.8999f,
+	-250.0f,
+	-226.563f,
+	18.9681f,
+	-250.0f,
+	-222.656f,
+	17.7696f,
+	-250.0f,
+	-218.75f,
+	15.6199f,
+	-250.0f,
+	-214.844f,
+	14.6555f,
+	-250.0f,
+	-210.938f,
+	13.0514f,
+	-250.0f,
+	-207.031f,
+	13.6029f,
+	-250.0f,
+	-203.125f,
+	13.1455f,
+	-250.0f,
+	-199.219f,
+	12.0056f,
+	-250.0f,
+	-195.313f,
+	11.1773f,
+	-250.0f,
+	-191.406f,
+	10.7263f,
+	-250.0f,
+	-187.5f,
+	10.2543f,
+	-250.0f,
+	-183.594f,
+	9.76389f,
+	-250.0f,
+	-179.688f,
+	9.00623f,
+	-250.0f,
+	-175.781f,
+	9.47424f,
+	-250.0f,
+	-171.875f,
+	10.8011f,
+	-250.0f,
+	-167.969f,
+	12.4395f,
+	-250.0f,
+	-164.063f,
+	13.7736f,
+	-250.0f,
+	-160.156f,
+	14.0938f,
+	-250.0f,
+	-156.25f,
+	15.8447f,
+	-250.0f,
+	-152.344f,
+	17.1975f,
+	-250.0f,
+	-148.438f,
+	17.963f,
+	-250.0f,
+	-144.531f,
+	19.3662f,
+	-250.0f,
+	-140.625f,
+	20.309f,
+	-250.0f,
+	-136.719f,
+	21.9063f,
+	-250.0f,
+	-132.813f,
+	22.8363f,
+	-250.0f,
+	-128.906f,
+	24.0073f,
+	-250.0f,
+	-125.0f,
+	25.2989f,
+	-250.0f,
+	-121.094f,
+	26.2944f,
+	-250.0f,
+	-117.188f,
+	27.4482f,
+	-250.0f,
+	-113.281f,
+	27.4823f,
+	-250.0f,
+	-109.375f,
+	27.2835f,
+	-250.0f,
+	-105.469f,
+	27.4754f,
+	-250.0f,
+	-101.563f,
+	27.7731f,
+	-250.0f,
+	-97.6563f,
+	26.6981f,
+	-250.0f,
+	-93.75f,
+	24.4699f,
+	-250.0f,
+	-89.8438f,
+	22.81f,
+	-250.0f,
+	-85.9375f,
+	21.6739f,
+	-250.0f,
+	-82.0313f,
+	19.8713f,
+	-250.0f,
+	-78.125f,
+	18.5848f,
+	-250.0f,
+	-74.2188f,
+	17.7134f,
+	-250.0f,
+	-70.3125f,
+	15.5276f,
+	-250.0f,
+	-66.4063f,
+	14.6805f,
+	-250.0f,
+	-62.5f,
+	14.0332f,
+	-250.0f,
+	-58.5938f,
+	12.1429f,
+	-250.0f,
+	-54.6875f,
+	10.3027f,
+	-250.0f,
+	-50.7813f,
+	9.68001f,
+	-250.0f,
+	-46.875f,
+	8.12561f,
+	-250.0f,
+	-42.9688f,
+	8.26581f,
+	-250.0f,
+	-39.0625f,
+	7.98056f,
+	-250.0f,
+	-35.1563f,
+	7.43215f,
+	-250.0f,
+	-31.25f,
+	6.33038f,
+	-250.0f,
+	-27.3438f,
+	4.62549f,
+	-250.0f,
+	-23.4375f,
+	3.83616f,
+	-250.0f,
+	-19.5313f,
+	4.24597f,
+	-250.0f,
+	-15.625f,
+	3.79997f,
+	-250.0f,
+	-11.7188f,
+	3.74461f,
+	-250.0f,
+	-7.8125f,
+	3.79853f,
+	-250.0f,
+	-3.90625f,
+	3.95418f,
+	-250.0f,
+	0.0f,
+	5.70623f,
+	-250.0f,
+	3.90625f,
+	6.31953f,
+	-250.0f,
+};
+
+btScalar Landscape08Nml[] = {
+	-0.193879f,
+	0.980285f,
+	-0.0381128f,
+	-0.101407f,
+	0.994799f,
+	-0.00961843f,
+	-0.17812f,
+	0.983422f,
+	0.0339701f,
+	-0.107869f,
+	0.990758f,
+	0.0822321f,
+	-0.150224f,
+	0.986838f,
+	0.0598614f,
+	-0.176421f,
+	0.983338f,
+	0.0438458f,
+	0.00771709f,
+	0.999873f,
+	0.0139132f,
+	-0.0458501f,
+	0.998747f,
+	-0.0200731f,
+	0.170866f,
+	0.984802f,
+	-0.0311488f,
+	0.198428f,
+	0.979783f,
+	-0.0255296f,
+	0.223966f,
+	0.969797f,
+	0.0966125f,
+	0.319719f,
+	0.946459f,
+	0.0446654f,
+	0.155788f,
+	0.942148f,
+	0.296794f,
+	0.226142f,
+	0.945324f,
+	0.234996f,
+	0.0234229f,
+	0.954977f,
+	0.295752f,
+	-0.0213542f,
+	0.981077f,
+	0.192434f,
+	-0.0320299f,
+	0.976907f,
+	0.211248f,
+	-0.0305686f,
+	0.97015f,
+	0.240572f,
+	-0.00290395f,
+	0.990031f,
+	0.14082f,
+	-0.0740282f,
+	0.98339f,
+	0.165723f,
+	0.0359831f,
+	0.998663f,
+	0.0371117f,
+	-0.048977f,
+	0.998654f,
+	0.0171003f,
+	0.119085f,
+	0.992879f,
+	0.00312204f,
+	0.163687f,
+	0.985928f,
+	0.0339365f,
+	0.233927f,
+	0.967265f,
+	0.0983717f,
+	0.258555f,
+	0.954734f,
+	0.147076f,
+	0.185228f,
+	0.98177f,
+	0.0426319f,
+	0.171781f,
+	0.975163f,
+	0.139813f,
+	0.312497f,
+	0.949826f,
+	0.0132586f,
+	0.315278f,
+	0.937034f,
+	0.150223f,
+	0.455936f,
+	0.889912f,
+	-0.0133666f,
+	0.444363f,
+	0.88993f,
+	0.102789f,
+	0.477095f,
+	0.878821f,
+	-0.00729384f,
+	0.442265f,
+	0.892911f,
+	0.0843273f,
+	0.441901f,
+	0.89445f,
+	-0.0684218f,
+	0.356563f,
+	0.929766f,
+	-0.091634f,
+	0.46452f,
+	0.88048f,
+	-0.0947459f,
+	0.399286f,
+	0.883106f,
+	-0.246362f,
+	0.430625f,
+	0.899506f,
+	-0.073831f,
+	0.418125f,
+	0.862027f,
+	-0.286498f,
+	0.390492f,
+	0.919986f,
+	-0.0337736f,
+	0.451928f,
+	0.884249f,
+	-0.117748f,
+	0.389473f,
+	0.920638f,
+	-0.0271218f,
+	0.401911f,
+	0.911214f,
+	-0.0903147f,
+	0.411594f,
+	0.910246f,
+	-0.0451926f,
+	0.385985f,
+	0.916603f,
+	-0.104187f,
+	0.406515f,
+	0.904587f,
+	-0.128329f,
+	0.375686f,
+	0.920382f,
+	-0.108425f,
+	0.421893f,
+	0.886378f,
+	-0.190632f,
+	0.362475f,
+	0.891842f,
+	-0.270609f,
+	0.382406f,
+	0.917607f,
+	-0.108459f,
+	0.380095f,
+	0.864773f,
+	-0.32817f,
+	0.206545f,
+	0.977978f,
+	-0.0299668f,
+	0.319336f,
+	0.938074f,
+	-0.134321f,
+	-0.0276167f,
+	0.998803f,
+	0.0403598f,
+	0.0724517f,
+	0.997355f,
+	-0.00577643f,
+	-0.170399f,
+	0.974366f,
+	0.146884f,
+	-0.0444923f,
+	0.976538f,
+	0.210699f,
+	-0.123713f,
+	0.961736f,
+	0.244457f,
+	-0.0585476f,
+	0.950932f,
+	0.303809f,
+	-0.0436638f,
+	0.948824f,
+	0.312774f,
+	-0.0108452f,
+	0.950133f,
+	0.311655f,
+	-0.0562151f,
+	0.924389f,
+	0.377285f,
+	-0.024656f,
+	0.918307f,
+	0.3951f,
+	-0.11936f,
+	0.930674f,
+	0.345831f,
+	-0.21058f,
+	0.936144f,
+	0.281584f,
+	-0.166672f,
+	0.952976f,
+	0.253095f,
+	-0.262868f,
+	0.958623f,
+	0.109278f,
+	-0.138859f,
+	0.97532f,
+	0.171667f,
+	-0.166823f,
+	0.980233f,
+	0.106364f,
+	-0.016911f,
+	0.994026f,
+	0.107828f,
+	0.014088f,
+	0.986713f,
+	0.161858f,
+	-0.0269312f,
+	0.989998f,
+	0.138489f,
+	-0.0681193f,
+	0.995186f,
+	0.0704648f,
+	-0.241507f,
+	0.962694f,
+	0.122045f,
+	-0.306148f,
+	0.951983f,
+	0.00131283f,
+	-0.400562f,
+	0.916076f,
+	-0.0188573f,
+	-0.46755f,
+	0.872686f,
+	-0.140772f,
+	-0.451983f,
+	0.886731f,
+	-0.0970551f,
+	-0.445163f,
+	0.885181f,
+	-0.135217f,
+	-0.440559f,
+	0.893764f,
+	-0.0842181f,
+	-0.44058f,
+	0.883958f,
+	-0.156548f,
+	-0.530573f,
+	0.842324f,
+	-0.094771f,
+	-0.559377f,
+	0.815929f,
+	-0.14614f,
+	-0.675146f,
+	0.724837f,
+	-0.137074f,
+	-0.671227f,
+	0.729467f,
+	-0.131655f,
+	-0.627673f,
+	0.767191f,
+	-0.132076f,
+	-0.630683f,
+	0.736819f,
+	-0.243592f,
+	-0.548071f,
+	0.819689f,
+	-0.166518f,
+	-0.526895f,
+	0.799727f,
+	-0.287781f,
+	-0.521779f,
+	0.83885f,
+	-0.155167f,
+	-0.501504f,
+	0.822365f,
+	-0.268719f,
+	-0.465479f,
+	0.867433f,
+	-0.175756f,
+	-0.453816f,
+	0.862676f,
+	-0.223251f,
+	-0.458424f,
+	0.854844f,
+	-0.243083f,
+	-0.470698f,
+	0.860374f,
+	-0.195446f,
+	-0.485669f,
+	0.830839f,
+	-0.27172f,
+	-0.494445f,
+	0.85319f,
+	-0.166102f,
+	-0.418394f,
+	0.865747f,
+	-0.274642f,
+	-0.405345f,
+	0.892443f,
+	-0.198093f,
+	-0.287108f,
+	0.926134f,
+	-0.244631f,
+	-0.325256f,
+	0.923685f,
+	-0.202519f,
+	-0.192384f,
+	0.91848f,
+	-0.345518f,
+	-0.208186f,
+	0.935081f,
+	-0.28685f,
+	0.0681073f,
+	0.948251f,
+	-0.310131f,
+	0.077158f,
+	0.955715f,
+	-0.283998f,
+	0.102278f,
+	0.947499f,
+	-0.302962f,
+	0.02043f,
+	0.921087f,
+	-0.388821f,
+	0.0627177f,
+	0.929646f,
+	-0.363077f,
+	0.0629047f,
+	0.918578f,
+	-0.390202f,
+	-0.00415691f,
+	0.947597f,
+	-0.31944f,
+	-0.00512929f,
+	0.899538f,
+	-0.436812f,
+	-0.271944f,
+	0.935195f,
+	-0.226842f,
+	-0.177509f,
+	0.92231f,
+	-0.343271f,
+	-0.413186f,
+	0.904845f,
+	-0.102632f,
+	-0.338265f,
+	0.931446f,
+	-0.13411f,
+	-0.418276f,
+	0.90315f,
+	-0.0967731f,
+	-0.404177f,
+	0.914278f,
+	-0.0271442f,
+	-0.400569f,
+	0.902696f,
+	-0.157112f,
+	-0.429625f,
+	0.894308f,
+	-0.125039f,
+	-0.29004f,
+	0.948484f,
+	-0.127491f,
+	-0.188203f,
+	0.980777f,
+	0.0515283f,
+	-0.0585039f,
+	0.997556f,
+	-0.0381961f,
+	-0.133431f,
+	0.99094f,
+	0.0152943f,
+	-0.143343f,
+	0.971126f,
+	-0.1907f,
+	-0.24516f,
+	0.938627f,
+	-0.242644f,
+	-0.188833f,
+	0.958258f,
+	-0.214673f,
+	-0.174705f,
+	0.963776f,
+	-0.201528f,
+	-0.196517f,
+	0.95296f,
+	-0.230756f,
+	-0.128653f,
+	0.987396f,
+	-0.0921772f,
+	-0.120365f,
+	0.975049f,
+	-0.186527f,
+	0.0117596f,
+	0.998991f,
+	0.0433545f,
+	-0.146882f,
+	0.98666f,
+	-0.0701983f,
+	-0.218442f,
+	0.971087f,
+	-0.0962923f,
+	-0.179096f,
+	0.983284f,
+	-0.0328244f,
+	0.0658277f,
+	0.997324f,
+	0.0318063f,
+	0.120963f,
+	0.992647f,
+	0.00454206f,
+	0.0263542f,
+	0.988052f,
+	0.151849f,
+	0.0179305f,
+	0.957276f,
+	0.288619f,
+	0.0987151f,
+	0.955923f,
+	0.276526f,
+	0.113577f,
+	0.970939f,
+	0.210662f,
+	0.111989f,
+	0.989066f,
+	0.0959572f,
+	0.0937332f,
+	0.995324f,
+	-0.0233266f,
+	0.0889156f,
+	0.995493f,
+	-0.0329669f,
+	0.214527f,
+	0.976717f,
+	-0.0013568f,
+	0.281036f,
+	0.957864f,
+	-0.0592866f,
+	0.349427f,
+	0.927689f,
+	-0.131507f,
+	0.460507f,
+	0.876585f,
+	-0.139754f,
+	0.465208f,
+	0.877856f,
+	-0.1138f,
+	0.432422f,
+	0.897621f,
+	-0.0853653f,
+	0.392928f,
+	0.918987f,
+	-0.032723f,
+	0.389134f,
+	0.920603f,
+	0.0326418f,
+	0.40247f,
+	0.914003f,
+	0.0511488f,
+	0.41651f,
+	0.90858f,
+	0.031652f,
+	0.468908f,
+	0.883168f,
+	-0.0118055f,
+	0.497957f,
+	0.862594f,
+	-0.0892785f,
+	0.342146f,
+	0.929254f,
+	-0.139366f,
+	0.262957f,
+	0.964807f,
+	-0.00115352f,
+	0.156573f,
+	0.98302f,
+	0.095691f,
+	-0.0479214f,
+	0.988417f,
+	0.143995f,
+	-0.198695f,
+	0.970386f,
+	0.13737f,
+	-0.222539f,
+	0.963461f,
+	0.14906f,
+	-0.145574f,
+	0.943362f,
+	0.298121f,
+	-0.065459f,
+	0.922659f,
+	0.380021f,
+	-0.0644219f,
+	0.950539f,
+	0.303852f,
+	-0.126762f,
+	0.967843f,
+	0.217283f,
+	-0.017815f,
+	0.980142f,
+	0.197496f,
+	0.0660407f,
+	0.994277f,
+	0.0839804f,
+	-0.101583f,
+	0.994471f,
+	0.0266049f,
+	-0.224345f,
+	0.969139f,
+	0.102176f,
+	-0.280297f,
+	0.958092f,
+	0.0591033f,
+	-0.402555f,
+	0.91416f,
+	-0.047541f,
+	-0.458467f,
+	0.883974f,
+	-0.0916445f,
+	-0.50134f,
+	0.862765f,
+	-0.0655406f,
+	-0.644808f,
+	0.754744f,
+	-0.12077f,
+	-0.636358f,
+	0.756299f,
+	-0.151855f,
+	-0.556238f,
+	0.818404f,
+	-0.144268f,
+	-0.504016f,
+	0.849904f,
+	-0.153725f,
+	-0.404172f,
+	0.887071f,
+	-0.223046f,
+	-0.360363f,
+	0.894242f,
+	-0.265463f,
+	-0.432057f,
+	0.840836f,
+	-0.326069f,
+	-0.4393f,
+	0.818603f,
+	-0.370006f,
+	-0.249988f,
+	0.890718f,
+	-0.379642f,
+	-0.114697f,
+	0.874572f,
+	-0.471135f,
+	-0.0301956f,
+	0.870113f,
+	-0.491927f,
+	0.0871874f,
+	0.907337f,
+	-0.411263f,
+	0.0509325f,
+	0.923392f,
+	-0.380464f,
+	-0.106299f,
+	0.953821f,
+	-0.280938f,
+	-0.389809f,
+	0.901657f,
+	-0.187255f,
+	-0.420279f,
+	0.904001f,
+	-0.0784108f,
+	-0.360569f,
+	0.922439f,
+	-0.138186f,
+	-0.332116f,
+	0.91853f,
+	-0.214478f,
+	-0.305854f,
+	0.899541f,
+	-0.311896f,
+	-0.11957f,
+	0.95083f,
+	-0.285701f,
+	-0.0843961f,
+	0.977455f,
+	-0.193542f,
+	-0.186555f,
+	0.968589f,
+	-0.164414f,
+	-0.1142f,
+	0.975963f,
+	-0.185618f,
+	-0.138309f,
+	0.943055f,
+	-0.30252f,
+	-0.101226f,
+	0.981339f,
+	-0.163482f,
+	-0.184633f,
+	0.97099f,
+	-0.151951f,
+	-0.239394f,
+	0.95355f,
+	-0.182845f,
+	-0.0575173f,
+	0.989733f,
+	-0.130847f,
+	0.0688205f,
+	0.993792f,
+	0.0874178f,
+	-0.0714424f,
+	0.990397f,
+	0.118361f,
+	-0.0225247f,
+	0.994972f,
+	0.0975878f,
+	0.167362f,
+	0.976776f,
+	0.133786f,
+	0.156506f,
+	0.98511f,
+	0.0711603f,
+	0.198564f,
+	0.979194f,
+	0.0418473f,
+	0.173408f,
+	0.984455f,
+	-0.0278778f,
+	0.108869f,
+	0.989375f,
+	-0.0963545f,
+	0.224679f,
+	0.96015f,
+	-0.166226f,
+	0.339104f,
+	0.91731f,
+	-0.208688f,
+	0.367935f,
+	0.88797f,
+	-0.275922f,
+	0.418707f,
+	0.869398f,
+	-0.262357f,
+	0.420889f,
+	0.892687f,
+	-0.161129f,
+	0.397172f,
+	0.910077f,
+	-0.118378f,
+	0.374326f,
+	0.920598f,
+	-0.11126f,
+	0.397932f,
+	0.911721f,
+	-0.102056f,
+	0.386888f,
+	0.911258f,
+	-0.141166f,
+	0.41482f,
+	0.902273f,
+	-0.117593f,
+	0.501715f,
+	0.859192f,
+	-0.100356f,
+	0.491949f,
+	0.863362f,
+	-0.112214f,
+	0.357466f,
+	0.931719f,
+	-0.0641779f,
+	0.171333f,
+	0.982821f,
+	-0.068616f,
+	0.100623f,
+	0.994346f,
+	0.0339287f,
+	-0.0698557f,
+	0.996834f,
+	0.0379692f,
+	-0.194026f,
+	0.980994f,
+	0.00220452f,
+	-0.288205f,
+	0.957419f,
+	0.0169548f,
+	-0.304635f,
+	0.947239f,
+	0.0996808f,
+	-0.10216f,
+	0.973655f,
+	0.20386f,
+	0.100532f,
+	0.974742f,
+	0.199427f,
+	-0.0238908f,
+	0.99964f,
+	0.0121747f,
+	-0.00850096f,
+	0.997624f,
+	-0.0683673f,
+	0.116859f,
+	0.992157f,
+	-0.044359f,
+	-0.0433286f,
+	0.998946f,
+	-0.0151181f,
+	-0.258294f,
+	0.961617f,
+	-0.0926162f,
+	-0.256378f,
+	0.96262f,
+	-0.0873673f,
+	-0.327211f,
+	0.940376f,
+	-0.0928767f,
+	-0.431734f,
+	0.888327f,
+	-0.15646f,
+	-0.514253f,
+	0.844258f,
+	-0.150905f,
+	-0.599748f,
+	0.789083f,
+	-0.132858f,
+	-0.620824f,
+	0.749219f,
+	-0.230756f,
+	-0.533018f,
+	0.803035f,
+	-0.266508f,
+	-0.441513f,
+	0.840682f,
+	-0.313561f,
+	-0.38701f,
+	0.854241f,
+	-0.347124f,
+	-0.380219f,
+	0.879441f,
+	-0.286385f,
+	-0.39628f,
+	0.874175f,
+	-0.280679f,
+	-0.390488f,
+	0.846052f,
+	-0.362926f,
+	-0.205032f,
+	0.876667f,
+	-0.435221f,
+	-0.00372872f,
+	0.883142f,
+	-0.46909f,
+	-0.0083869f,
+	0.837348f,
+	-0.546606f,
+	-0.00127167f,
+	0.831923f,
+	-0.55489f,
+	-0.11424f,
+	0.875282f,
+	-0.469926f,
+	-0.256213f,
+	0.933918f,
+	-0.249305f,
+	-0.393049f,
+	0.915109f,
+	-0.0899313f,
+	-0.484342f,
+	0.863396f,
+	-0.141282f,
+	-0.32612f,
+	0.940905f,
+	-0.0913441f,
+	-0.240051f,
+	0.956808f,
+	-0.163992f,
+	-0.189326f,
+	0.934609f,
+	-0.301099f,
+	-0.228613f,
+	0.900757f,
+	-0.369288f,
+	-0.206601f,
+	0.953154f,
+	-0.220936f,
+	-0.220523f,
+	0.958575f,
+	-0.180285f,
+	-0.0691943f,
+	0.98249f,
+	-0.172992f,
+	0.0652464f,
+	0.984331f,
+	-0.163816f,
+	-0.308082f,
+	0.909128f,
+	-0.280306f,
+	-0.234588f,
+	0.948864f,
+	-0.211249f,
+	-0.164432f,
+	0.95809f,
+	-0.234578f,
+	-0.206026f,
+	0.945244f,
+	-0.253116f,
+	-0.143287f,
+	0.989535f,
+	-0.0170174f,
+	0.0124441f,
+	0.996035f,
+	0.0880878f,
+	0.00356068f,
+	0.999352f,
+	-0.0358152f,
+	0.110457f,
+	0.993318f,
+	-0.0334531f,
+	0.202646f,
+	0.978802f,
+	0.0296789f,
+	0.245502f,
+	0.969355f,
+	0.00893075f,
+	0.235742f,
+	0.966989f,
+	-0.096741f,
+	0.211469f,
+	0.957228f,
+	-0.197474f,
+	0.297424f,
+	0.906479f,
+	-0.299724f,
+	0.384843f,
+	0.8614f,
+	-0.331489f,
+	0.405425f,
+	0.833969f,
+	-0.374335f,
+	0.330388f,
+	0.8594f,
+	-0.390224f,
+	0.318232f,
+	0.891429f,
+	-0.32262f,
+	0.388106f,
+	0.870631f,
+	-0.302284f,
+	0.354731f,
+	0.863719f,
+	-0.357989f,
+	0.344798f,
+	0.878386f,
+	-0.330988f,
+	0.405293f,
+	0.884611f,
+	-0.230654f,
+	0.388923f,
+	0.889959f,
+	-0.23814f,
+	0.464087f,
+	0.861962f,
+	-0.20407f,
+	0.454884f,
+	0.878774f,
+	-0.144348f,
+	0.334448f,
+	0.940492f,
+	-0.0601651f,
+	0.155367f,
+	0.984248f,
+	-0.0843604f,
+	0.0216917f,
+	0.991768f,
+	-0.126198f,
+	-0.0136477f,
+	0.995915f,
+	-0.089255f,
+	-0.167328f,
+	0.979282f,
+	-0.114052f,
+	-0.307453f,
+	0.946588f,
+	-0.0971837f,
+	-0.335506f,
+	0.9366f,
+	-0.101072f,
+	-0.175739f,
+	0.978185f,
+	-0.110768f,
+	0.119064f,
+	0.992411f,
+	-0.0307238f,
+	0.11077f,
+	0.993829f,
+	0.00590121f,
+	0.0501349f,
+	0.998052f,
+	-0.0371321f,
+	0.0267572f,
+	0.997581f,
+	-0.0641572f,
+	-0.0614311f,
+	0.997945f,
+	0.0181992f,
+	-0.171984f,
+	0.984492f,
+	-0.0345973f,
+	-0.25243f,
+	0.961435f,
+	-0.109187f,
+	-0.338599f,
+	0.935923f,
+	-0.0969507f,
+	-0.406007f,
+	0.913202f,
+	-0.0349361f,
+	-0.506218f,
+	0.860674f,
+	-0.0546185f,
+	-0.568342f,
+	0.8123f,
+	-0.130983f,
+	-0.570141f,
+	0.791669f,
+	-0.219544f,
+	-0.495272f,
+	0.816181f,
+	-0.297581f,
+	-0.441753f,
+	0.829099f,
+	-0.342707f,
+	-0.433015f,
+	0.854206f,
+	-0.287802f,
+	-0.452692f,
+	0.8617f,
+	-0.229223f,
+	-0.349843f,
+	0.914647f,
+	-0.202562f,
+	-0.26556f,
+	0.912134f,
+	-0.312233f,
+	-0.238012f,
+	0.870367f,
+	-0.431058f,
+	0.0104117f,
+	0.943359f,
+	-0.331612f,
+	0.0744935f,
+	0.949145f,
+	-0.305899f,
+	-0.0305186f,
+	0.956187f,
+	-0.291161f,
+	-0.253914f,
+	0.939488f,
+	-0.229978f,
+	-0.449831f,
+	0.878563f,
+	-0.160557f,
+	-0.46937f,
+	0.880955f,
+	-0.0600792f,
+	-0.456075f,
+	0.88917f,
+	-0.0370459f,
+	-0.35963f,
+	0.932902f,
+	-0.0189682f,
+	-0.136797f,
+	0.989932f,
+	0.0363352f,
+	-0.0613131f,
+	0.996495f,
+	-0.0569106f,
+	-0.21207f,
+	0.964351f,
+	-0.158282f,
+	-0.303853f,
+	0.931291f,
+	-0.200924f,
+	-0.14101f,
+	0.957182f,
+	-0.252823f,
+	-0.0888984f,
+	0.919027f,
+	-0.384041f,
+	0.0067746f,
+	0.936029f,
+	-0.351857f,
+	-0.277531f,
+	0.936633f,
+	-0.213766f,
+	-0.206375f,
+	0.947006f,
+	-0.246148f,
+	-0.159145f,
+	0.94264f,
+	-0.293433f,
+	-0.254895f,
+	0.932893f,
+	-0.254437f,
+	-0.289527f,
+	0.928279f,
+	-0.233391f,
+	-0.0765713f,
+	0.988951f,
+	-0.126934f,
+	0.118605f,
+	0.992812f,
+	0.0160497f,
+	0.122094f,
+	0.985714f,
+	-0.116021f,
+	0.123131f,
+	0.980876f,
+	-0.150734f,
+	0.257926f,
+	0.962137f,
+	-0.0881221f,
+	0.397575f,
+	0.90803f,
+	-0.131971f,
+	0.301628f,
+	0.898949f,
+	-0.317666f,
+	0.360055f,
+	0.863992f,
+	-0.351962f,
+	0.391486f,
+	0.830925f,
+	-0.39535f,
+	0.399022f,
+	0.829333f,
+	-0.391136f,
+	0.323505f,
+	0.871183f,
+	-0.369302f,
+	0.290418f,
+	0.885393f,
+	-0.362955f,
+	0.422788f,
+	0.860776f,
+	-0.283398f,
+	0.400499f,
+	0.876008f,
+	-0.26872f,
+	0.272367f,
+	0.912425f,
+	-0.305444f,
+	0.289824f,
+	0.919053f,
+	-0.267101f,
+	0.375469f,
+	0.907173f,
+	-0.189898f,
+	0.450189f,
+	0.881784f,
+	-0.140667f,
+	0.386895f,
+	0.914552f,
+	-0.117932f,
+	0.236065f,
+	0.970562f,
+	-0.0477698f,
+	0.25497f,
+	0.966484f,
+	0.0299776f,
+	0.147152f,
+	0.978905f,
+	-0.141747f,
+	-0.0638684f,
+	0.954892f,
+	-0.290005f,
+	-0.198781f,
+	0.952653f,
+	-0.230082f,
+	-0.310279f,
+	0.934977f,
+	-0.171888f,
+	-0.315284f,
+	0.933842f,
+	-0.168923f,
+	-0.14676f,
+	0.971582f,
+	-0.185715f,
+	-0.0201641f,
+	0.976785f,
+	-0.213271f,
+	0.0408109f,
+	0.997823f,
+	-0.0518006f,
+	-0.000100141f,
+	1.0f,
+	-0.000656924f,
+	0.0713875f,
+	0.992775f,
+	0.096444f,
+	-0.0699693f,
+	0.997522f,
+	-0.0073179f,
+	-0.120441f,
+	0.992484f,
+	-0.0216487f,
+	-0.200799f,
+	0.979135f,
+	-0.0312183f,
+	-0.379156f,
+	0.923729f,
+	-0.0544518f,
+	-0.468756f,
+	0.883079f,
+	0.0209709f,
+	-0.451556f,
+	0.890079f,
+	0.0621062f,
+	-0.476504f,
+	0.87674f,
+	-0.0653536f,
+	-0.492274f,
+	0.840855f,
+	-0.22501f,
+	-0.481358f,
+	0.828756f,
+	-0.285409f,
+	-0.474733f,
+	0.852404f,
+	-0.219173f,
+	-0.502016f,
+	0.852123f,
+	-0.147874f,
+	-0.474734f,
+	0.870513f,
+	-0.12975f,
+	-0.344408f,
+	0.92173f,
+	-0.178317f,
+	-0.150823f,
+	0.963991f,
+	-0.21903f,
+	-0.180013f,
+	0.935609f,
+	-0.303696f,
+	-0.154788f,
+	0.929555f,
+	-0.334617f,
+	0.0226749f,
+	0.973389f,
+	-0.228036f,
+	-0.128469f,
+	0.975007f,
+	-0.181264f,
+	-0.302747f,
+	0.952293f,
+	-0.0385077f,
+	-0.427741f,
+	0.902872f,
+	-0.0431169f,
+	-0.47673f,
+	0.871329f,
+	-0.116249f,
+	-0.489254f,
+	0.866227f,
+	-0.101399f,
+	-0.407231f,
+	0.911582f,
+	-0.0564075f,
+	-0.202058f,
+	0.978968f,
+	-0.0281862f,
+	-0.00674228f,
+	0.999486f,
+	0.0313481f,
+	-0.103136f,
+	0.994637f,
+	-0.00773474f,
+	-0.196734f,
+	0.967877f,
+	-0.156554f,
+	0.0323675f,
+	0.951182f,
+	-0.306928f,
+	0.00132526f,
+	0.886111f,
+	-0.463472f,
+	-0.0819618f,
+	0.88666f,
+	-0.4551f,
+	-0.207835f,
+	0.973361f,
+	-0.0968142f,
+	-0.157163f,
+	0.972283f,
+	-0.173105f,
+	-0.187284f,
+	0.955049f,
+	-0.229797f,
+	-0.285445f,
+	0.950862f,
+	-0.119931f,
+	-0.25293f,
+	0.964263f,
+	-0.078892f,
+	-0.219599f,
+	0.957265f,
+	-0.188204f,
+	-0.0108412f,
+	0.995374f,
+	-0.0954668f,
+	0.265678f,
+	0.963807f,
+	-0.0221529f,
+	0.203794f,
+	0.959343f,
+	-0.195266f,
+	0.214345f,
+	0.928921f,
+	-0.301932f,
+	0.439386f,
+	0.868442f,
+	-0.22967f,
+	0.401404f,
+	0.868685f,
+	-0.290278f,
+	0.386804f,
+	0.861005f,
+	-0.330232f,
+	0.428054f,
+	0.836263f,
+	-0.342686f,
+	0.371108f,
+	0.864198f,
+	-0.339765f,
+	0.321515f,
+	0.897421f,
+	-0.302098f,
+	0.213518f,
+	0.927633f,
+	-0.306443f,
+	0.325579f,
+	0.933219f,
+	-0.151988f,
+	0.403183f,
+	0.912352f,
+	-0.0711129f,
+	0.337076f,
+	0.932606f,
+	-0.128942f,
+	0.295377f,
+	0.932293f,
+	-0.208765f,
+	0.330751f,
+	0.922115f,
+	-0.200767f,
+	0.392168f,
+	0.906602f,
+	-0.155808f,
+	0.373592f,
+	0.925323f,
+	-0.0648487f,
+	0.191498f,
+	0.98018f,
+	-0.0507507f,
+	0.210624f,
+	0.977447f,
+	-0.015309f,
+	0.322948f,
+	0.945895f,
+	0.0314047f,
+	0.111956f,
+	0.981203f,
+	-0.157186f,
+	-0.247376f,
+	0.91284f,
+	-0.32485f,
+	-0.344293f,
+	0.903462f,
+	-0.255381f,
+	-0.317143f,
+	0.916625f,
+	-0.243348f,
+	-0.146502f,
+	0.958945f,
+	-0.242819f,
+	-0.0529375f,
+	0.980235f,
+	-0.19062f,
+	-0.0439655f,
+	0.993569f,
+	-0.104344f,
+	-0.0681441f,
+	0.993007f,
+	-0.0964036f,
+	0.0333119f,
+	0.999062f,
+	-0.0276811f,
+	0.0418264f,
+	0.997289f,
+	-0.0605344f,
+	-0.133447f,
+	0.982771f,
+	-0.127878f,
+	-0.204776f,
+	0.9734f,
+	-0.102754f,
+	-0.405337f,
+	0.909688f,
+	-0.0903804f,
+	-0.513852f,
+	0.857872f,
+	0.00340788f,
+	-0.448907f,
+	0.892038f,
+	0.0524446f,
+	-0.345596f,
+	0.938383f,
+	0.000245611f,
+	-0.371875f,
+	0.917654f,
+	-0.14007f,
+	-0.507047f,
+	0.834221f,
+	-0.216744f,
+	-0.563482f,
+	0.814021f,
+	-0.140919f,
+	-0.549501f,
+	0.831415f,
+	-0.0824446f,
+	-0.452205f,
+	0.89061f,
+	-0.0482179f,
+	-0.283377f,
+	0.952701f,
+	-0.109812f,
+	-0.141817f,
+	0.97445f,
+	-0.174169f,
+	-0.1066f,
+	0.981505f,
+	-0.159008f,
+	-0.128743f,
+	0.958435f,
+	-0.254611f,
+	0.00656601f,
+	0.946015f,
+	-0.324056f,
+	-0.2018f,
+	0.913066f,
+	-0.354384f,
+	-0.37997f,
+	0.904414f,
+	-0.19406f,
+	-0.423353f,
+	0.890783f,
+	-0.165163f,
+	-0.446411f,
+	0.883929f,
+	-0.139235f,
+	-0.512365f,
+	0.844229f,
+	-0.157352f,
+	-0.38243f,
+	0.91272f,
+	-0.143839f,
+	-0.20154f,
+	0.953013f,
+	-0.226157f,
+	-0.104673f,
+	0.977037f,
+	-0.185586f,
+	-0.0458745f,
+	0.998873f,
+	-0.0121567f,
+	-0.0345945f,
+	0.993617f,
+	-0.107371f,
+	0.172752f,
+	0.948616f,
+	-0.265111f,
+	0.0733608f,
+	0.946968f,
+	-0.312842f,
+	-0.16546f,
+	0.93251f,
+	-0.321012f,
+	-0.129843f,
+	0.991294f,
+	-0.0218587f,
+	-0.0514732f,
+	0.996939f,
+	-0.0588533f,
+	-0.139666f,
+	0.979954f,
+	-0.142066f,
+	-0.409538f,
+	0.893138f,
+	-0.185964f,
+	-0.25948f,
+	0.963277f,
+	-0.0690542f,
+	-0.106228f,
+	0.993322f,
+	-0.0450175f,
+	-0.047863f,
+	0.993002f,
+	-0.107966f,
+	0.238746f,
+	0.962198f,
+	-0.131057f,
+	0.395076f,
+	0.900486f,
+	-0.181771f,
+	0.285693f,
+	0.874669f,
+	-0.391577f,
+	0.358513f,
+	0.848133f,
+	-0.39005f,
+	0.400938f,
+	0.884343f,
+	-0.239137f,
+	0.415724f,
+	0.899223f,
+	-0.136277f,
+	0.438653f,
+	0.894164f,
+	-0.0897495f,
+	0.361082f,
+	0.930821f,
+	-0.0565009f,
+	0.321158f,
+	0.946416f,
+	-0.0339725f,
+	0.242073f,
+	0.961641f,
+	-0.129024f,
+	0.199607f,
+	0.93926f,
+	-0.279192f,
+	0.404284f,
+	0.887623f,
+	-0.220636f,
+	0.424881f,
+	0.860893f,
+	-0.279892f,
+	0.291182f,
+	0.870529f,
+	-0.396727f,
+	0.302468f,
+	0.897545f,
+	-0.320822f,
+	0.33835f,
+	0.898885f,
+	-0.278433f,
+	0.289098f,
+	0.929341f,
+	-0.229667f,
+	0.170367f,
+	0.971163f,
+	-0.166783f,
+	0.129237f,
+	0.986609f,
+	-0.0995005f,
+	0.305057f,
+	0.951694f,
+	0.0349234f,
+	0.306439f,
+	0.951736f,
+	-0.0171507f,
+	-0.0808802f,
+	0.976235f,
+	-0.201056f,
+	-0.37625f,
+	0.871862f,
+	-0.313516f,
+	-0.307717f,
+	0.906797f,
+	-0.28815f,
+	-0.221648f,
+	0.946026f,
+	-0.236446f,
+	-0.153972f,
+	0.983161f,
+	-0.0984244f,
+	-0.108206f,
+	0.992418f,
+	-0.0582996f,
+	-0.0581427f,
+	0.997361f,
+	-0.0434687f,
+	0.00296039f,
+	0.999365f,
+	-0.0355116f,
+	0.0891034f,
+	0.995894f,
+	-0.0160169f,
+	-0.110645f,
+	0.991801f,
+	-0.0639364f,
+	-0.218461f,
+	0.975223f,
+	-0.0348525f,
+	-0.395365f,
+	0.918398f,
+	-0.0152307f,
+	-0.576836f,
+	0.816159f,
+	-0.0338453f,
+	-0.444941f,
+	0.895556f,
+	-0.00249309f,
+	-0.286239f,
+	0.957764f,
+	-0.0274641f,
+	-0.294715f,
+	0.953259f,
+	-0.0666355f,
+	-0.477956f,
+	0.87064f,
+	-0.116377f,
+	-0.574643f,
+	0.800737f,
+	-0.169131f,
+	-0.54804f,
+	0.808388f,
+	-0.214852f,
+	-0.442187f,
+	0.863382f,
+	-0.242986f,
+	-0.246722f,
+	0.934143f,
+	-0.257887f,
+	-0.157124f,
+	0.964153f,
+	-0.213827f,
+	-0.112706f,
+	0.987993f,
+	-0.10568f,
+	-0.0332674f,
+	0.993709f,
+	-0.106936f,
+	0.112688f,
+	0.981964f,
+	-0.151814f,
+	-0.167f,
+	0.962022f,
+	-0.215928f,
+	-0.466198f,
+	0.854366f,
+	-0.229606f,
+	-0.414399f,
+	0.885329f,
+	-0.210869f,
+	-0.461383f,
+	0.855213f,
+	-0.236084f,
+	-0.488245f,
+	0.847976f,
+	-0.206287f,
+	-0.351309f,
+	0.900136f,
+	-0.257559f,
+	-0.14601f,
+	0.942734f,
+	-0.29989f,
+	-0.222931f,
+	0.937875f,
+	-0.265879f,
+	-0.195469f,
+	0.970505f,
+	-0.141106f,
+	0.07525f,
+	0.994532f,
+	-0.0724173f,
+	0.279727f,
+	0.951429f,
+	-0.128592f,
+	0.077712f,
+	0.980159f,
+	-0.182341f,
+	-0.20264f,
+	0.956685f,
+	-0.209022f,
+	-0.0986596f,
+	0.987061f,
+	-0.126403f,
+	-0.0477559f,
+	0.985147f,
+	-0.164941f,
+	-0.0669351f,
+	0.983547f,
+	-0.167793f,
+	-0.331517f,
+	0.915331f,
+	-0.228616f,
+	-0.350669f,
+	0.900109f,
+	-0.258526f,
+	-0.179805f,
+	0.971282f,
+	-0.155824f,
+	0.0156578f,
+	0.989915f,
+	-0.140797f,
+	0.301547f,
+	0.9226f,
+	-0.240579f,
+	0.457383f,
+	0.852861f,
+	-0.25185f,
+	0.449776f,
+	0.84917f,
+	-0.276789f,
+	0.26609f,
+	0.885033f,
+	-0.381984f,
+	0.182331f,
+	0.952085f,
+	-0.245538f,
+	0.260541f,
+	0.964562f,
+	-0.0416928f,
+	0.408684f,
+	0.907067f,
+	0.101033f,
+	0.342263f,
+	0.936545f,
+	0.0757594f,
+	0.318298f,
+	0.944991f,
+	0.0753604f,
+	0.467785f,
+	0.882822f,
+	0.0424513f,
+	0.409568f,
+	0.864687f,
+	-0.290809f,
+	0.379738f,
+	0.82358f,
+	-0.421325f,
+	0.451329f,
+	0.792384f,
+	-0.410402f,
+	0.275091f,
+	0.868881f,
+	-0.411547f,
+	0.161796f,
+	0.92881f,
+	-0.333367f,
+	0.286521f,
+	0.932696f,
+	-0.219053f,
+	0.272475f,
+	0.944744f,
+	-0.182252f,
+	0.119383f,
+	0.965719f,
+	-0.230508f,
+	-0.0212448f,
+	0.971989f,
+	-0.234063f,
+	0.226311f,
+	0.969491f,
+	-0.094178f,
+	0.326176f,
+	0.942844f,
+	-0.068215f,
+	0.104404f,
+	0.994209f,
+	-0.0254499f,
+	-0.295807f,
+	0.921372f,
+	-0.252133f,
+	-0.383855f,
+	0.886842f,
+	-0.257228f,
+	-0.359597f,
+	0.921141f,
+	-0.148961f,
+	-0.240318f,
+	0.969399f,
+	-0.0501282f,
+	-0.0922578f,
+	0.994071f,
+	-0.0575481f,
+	-0.0797027f,
+	0.995693f,
+	-0.047355f,
+	-0.026569f,
+	0.999636f,
+	0.00472767f,
+	0.105393f,
+	0.994402f,
+	0.00758912f,
+	-0.0968377f,
+	0.99427f,
+	-0.0452707f,
+	-0.304918f,
+	0.952227f,
+	0.0169656f,
+	-0.404524f,
+	0.901318f,
+	0.154875f,
+	-0.513873f,
+	0.850873f,
+	0.109318f,
+	-0.450348f,
+	0.892744f,
+	-0.0139455f,
+	-0.274075f,
+	0.961559f,
+	-0.0169546f,
+	-0.246789f,
+	0.966677f,
+	-0.068048f,
+	-0.421796f,
+	0.89143f,
+	-0.165651f,
+	-0.530762f,
+	0.820949f,
+	-0.210556f,
+	-0.518596f,
+	0.828643f,
+	-0.210734f,
+	-0.419929f,
+	0.882924f,
+	-0.210013f,
+	-0.267086f,
+	0.925885f,
+	-0.26721f,
+	-0.260528f,
+	0.916111f,
+	-0.304739f,
+	-0.212437f,
+	0.941505f,
+	-0.261606f,
+	-0.048105f,
+	0.973033f,
+	-0.225594f,
+	0.0765563f,
+	0.979806f,
+	-0.184712f,
+	-0.093108f,
+	0.98921f,
+	-0.113109f,
+	-0.45825f,
+	0.862094f,
+	-0.216335f,
+	-0.388948f,
+	0.902314f,
+	-0.185873f,
+	-0.448149f,
+	0.871913f,
+	-0.197307f,
+	-0.488741f,
+	0.854988f,
+	-0.173574f,
+	-0.313337f,
+	0.916762f,
+	-0.247724f,
+	-0.157546f,
+	0.938004f,
+	-0.308753f,
+	-0.267357f,
+	0.911027f,
+	-0.313926f,
+	-0.236818f,
+	0.920159f,
+	-0.311809f,
+	0.000164176f,
+	0.954985f,
+	-0.296656f,
+	0.271822f,
+	0.944232f,
+	-0.185848f,
+	0.151331f,
+	0.970946f,
+	-0.185371f,
+	-0.118147f,
+	0.962507f,
+	-0.244174f,
+	0.026977f,
+	0.993643f,
+	-0.109301f,
+	0.00824696f,
+	0.988318f,
+	-0.152184f,
+	-0.049843f,
+	0.98983f,
+	-0.133236f,
+	-0.292853f,
+	0.946012f,
+	-0.138915f,
+	-0.402779f,
+	0.899681f,
+	-0.168355f,
+	-0.216565f,
+	0.962959f,
+	-0.160656f,
+	0.0811851f,
+	0.971223f,
+	-0.223909f,
+	0.376654f,
+	0.888442f,
+	-0.262304f,
+	0.412611f,
+	0.862287f,
+	-0.293621f,
+	0.420494f,
+	0.885689f,
+	-0.196825f,
+	0.303261f,
+	0.948914f,
+	-0.0871512f,
+	0.0927021f,
+	0.987654f,
+	-0.12628f,
+	0.131263f,
+	0.975894f,
+	-0.174359f,
+	0.34789f,
+	0.928255f,
+	-0.131586f,
+	0.388684f,
+	0.916314f,
+	-0.0964015f,
+	0.334363f,
+	0.935247f,
+	-0.116251f,
+	0.500896f,
+	0.857152f,
+	-0.119971f,
+	0.598542f,
+	0.784881f,
+	-0.160341f,
+	0.47847f,
+	0.803478f,
+	-0.354245f,
+	0.40143f,
+	0.813052f,
+	-0.421663f,
+	0.177917f,
+	0.923323f,
+	-0.340324f,
+	0.0444056f,
+	0.967329f,
+	-0.249605f,
+	0.182957f,
+	0.975679f,
+	-0.12074f,
+	0.298547f,
+	0.954355f,
+	0.00877178f,
+	0.20958f,
+	0.975318f,
+	-0.0695111f,
+	0.014388f,
+	0.988042f,
+	-0.153512f,
+	0.159715f,
+	0.970499f,
+	-0.180618f,
+	0.22067f,
+	0.966546f,
+	-0.130745f,
+	0.121564f,
+	0.992499f,
+	-0.0129668f,
+	-0.106928f,
+	0.989668f,
+	-0.0955226f,
+	-0.432009f,
+	0.877086f,
+	-0.209972f,
+	-0.412195f,
+	0.894243f,
+	-0.174429f,
+	-0.247992f,
+	0.954923f,
+	-0.163162f,
+	-0.103668f,
+	0.985418f,
+	-0.134925f,
+	-0.118626f,
+	0.990103f,
+	-0.0749928f,
+	-0.0679366f,
+	0.995617f,
+	-0.0642786f,
+	0.157737f,
+	0.986207f,
+	-0.0501565f,
+	-0.132086f,
+	0.989105f,
+	-0.064997f,
+	-0.385668f,
+	0.914108f,
+	0.125169f,
+	-0.489653f,
+	0.859555f,
+	0.146305f,
+	-0.451033f,
+	0.881762f,
+	0.138074f,
+	-0.379544f,
+	0.923663f,
+	0.0528468f,
+	-0.267976f,
+	0.962936f,
+	0.0307148f,
+	-0.154653f,
+	0.986101f,
+	0.0607174f,
+	-0.285519f,
+	0.958009f,
+	-0.0264139f,
+	-0.517333f,
+	0.83498f,
+	-0.187551f,
+	-0.544673f,
+	0.81339f,
+	-0.204273f,
+	-0.443255f,
+	0.872475f,
+	-0.205697f,
+	-0.212541f,
+	0.959106f,
+	-0.18693f,
+	-0.144834f,
+	0.956217f,
+	-0.254307f,
+	-0.219765f,
+	0.912031f,
+	-0.346271f,
+	-0.054698f,
+	0.959311f,
+	-0.277002f,
+	-0.0226538f,
+	0.964658f,
+	-0.262528f,
+	-0.09277f,
+	0.980401f,
+	-0.173803f,
+	-0.427129f,
+	0.87184f,
+	-0.2397f,
+	-0.458168f,
+	0.877303f,
+	-0.142906f,
+	-0.456008f,
+	0.884075f,
+	-0.102317f,
+	-0.457836f,
+	0.873049f,
+	-0.167843f,
+	-0.276231f,
+	0.922652f,
+	-0.269091f,
+	-0.0986428f,
+	0.965162f,
+	-0.242345f,
+	-0.166497f,
+	0.944239f,
+	-0.284061f,
+	-0.221568f,
+	0.881867f,
+	-0.416194f,
+	-0.047486f,
+	0.902488f,
+	-0.428089f,
+	0.159799f,
+	0.906084f,
+	-0.391761f,
+	0.154437f,
+	0.936571f,
+	-0.314616f,
+	-0.0388024f,
+	0.943344f,
+	-0.329539f,
+	0.0179311f,
+	0.971802f,
+	-0.235116f,
+	-0.0317957f,
+	0.972144f,
+	-0.232219f,
+	-0.108238f,
+	0.982139f,
+	-0.153906f,
+	-0.294778f,
+	0.950488f,
+	-0.098378f,
+	-0.31352f,
+	0.940894f,
+	-0.128155f,
+	-0.158161f,
+	0.944104f,
+	-0.289226f,
+	0.136392f,
+	0.925587f,
+	-0.353108f,
+	0.369725f,
+	0.858345f,
+	-0.355736f,
+	0.408427f,
+	0.863142f,
+	-0.296941f,
+	0.264495f,
+	0.934318f,
+	-0.238939f,
+	0.231394f,
+	0.968992f,
+	-0.0866717f,
+	0.180537f,
+	0.980662f,
+	-0.0755592f,
+	0.289728f,
+	0.94884f,
+	-0.125539f,
+	0.338081f,
+	0.901985f,
+	-0.268559f,
+	0.344111f,
+	0.905129f,
+	-0.249658f,
+	0.337921f,
+	0.897299f,
+	-0.284014f,
+	0.46242f,
+	0.831252f,
+	-0.308526f,
+	0.625979f,
+	0.756355f,
+	-0.18994f,
+	0.59942f,
+	0.766009f,
+	-0.232218f,
+	0.396651f,
+	0.850096f,
+	-0.346416f,
+	0.113051f,
+	0.922761f,
+	-0.368417f,
+	-0.0568672f,
+	0.928859f,
+	-0.366041f,
+	0.0370994f,
+	0.962262f,
+	-0.269583f,
+	0.21844f,
+	0.959083f,
+	-0.180121f,
+	0.248457f,
+	0.958661f,
+	-0.138705f,
+	0.0562715f,
+	0.995806f,
+	-0.072134f,
+	0.151796f,
+	0.987439f,
+	-0.0438309f,
+	0.213126f,
+	0.976907f,
+	0.0151789f,
+	0.0825188f,
+	0.995896f,
+	-0.0371849f,
+	-0.0293603f,
+	0.995761f,
+	-0.0871655f,
+	-0.339382f,
+	0.929166f,
+	-0.146528f,
+	-0.407976f,
+	0.887929f,
+	-0.212458f,
+	-0.300706f,
+	0.928797f,
+	-0.216592f,
+	-0.171876f,
+	0.971688f,
+	-0.162117f,
+	-0.133134f,
+	0.975354f,
+	-0.175954f,
+	-0.0436112f,
+	0.969589f,
+	-0.240823f,
+	0.0955252f,
+	0.97277f,
+	-0.211171f,
+	-0.222971f,
+	0.974797f,
+	-0.00733171f,
+	-0.502187f,
+	0.842082f,
+	0.19674f,
+	-0.406382f,
+	0.878535f,
+	0.251057f,
+	-0.403841f,
+	0.907763f,
+	0.113486f,
+	-0.295941f,
+	0.954472f,
+	0.0374491f,
+	-0.309098f,
+	0.948653f,
+	-0.0672074f,
+	-0.212726f,
+	0.977025f,
+	0.0130525f,
+	-0.199979f,
+	0.978912f,
+	0.0417118f,
+	-0.374584f,
+	0.922961f,
+	-0.0884893f,
+	-0.481248f,
+	0.836641f,
+	-0.261597f,
+	-0.419239f,
+	0.839768f,
+	-0.345005f,
+	-0.269419f,
+	0.905569f,
+	-0.327654f,
+	-0.084614f,
+	0.973021f,
+	-0.214643f,
+	-0.193736f,
+	0.935164f,
+	-0.296537f,
+	-0.190273f,
+	0.932167f,
+	-0.307995f,
+	-0.0917672f,
+	0.986648f,
+	-0.134552f,
+	-0.101923f,
+	0.994749f,
+	0.009248f,
+	-0.329353f,
+	0.943234f,
+	-0.0428565f,
+	-0.527408f,
+	0.832391f,
+	-0.170191f,
+	-0.427451f,
+	0.895563f,
+	-0.123505f,
+	-0.337252f,
+	0.917187f,
+	-0.212202f,
+	-0.254472f,
+	0.911026f,
+	-0.324462f,
+	-0.191138f,
+	0.941948f,
+	-0.276043f,
+	-0.0895186f,
+	0.969134f,
+	-0.229708f,
+	-0.115141f,
+	0.935532f,
+	-0.33395f,
+	-0.0316994f,
+	0.925937f,
+	-0.376346f,
+	0.117945f,
+	0.920189f,
+	-0.373285f,
+	0.121803f,
+	0.934924f,
+	-0.333287f,
+	-0.0046923f,
+	0.925271f,
+	-0.379279f,
+	0.0524128f,
+	0.95708f,
+	-0.285046f,
+	-0.0476851f,
+	0.956392f,
+	-0.288167f,
+	-0.185718f,
+	0.956668f,
+	-0.224263f,
+	-0.292875f,
+	0.939689f,
+	-0.176661f,
+	-0.212138f,
+	0.937073f,
+	-0.277295f,
+	0.00215598f,
+	0.9095f,
+	-0.415698f,
+	0.155074f,
+	0.855231f,
+	-0.494501f,
+	0.3372f,
+	0.836708f,
+	-0.431528f,
+	0.272726f,
+	0.886233f,
+	-0.374449f,
+	0.193484f,
+	0.944931f,
+	-0.263949f,
+	0.192169f,
+	0.938969f,
+	-0.285322f,
+	0.141281f,
+	0.932743f,
+	-0.331708f,
+	0.278032f,
+	0.931044f,
+	-0.236339f,
+	0.426985f,
+	0.871432f,
+	-0.241434f,
+	0.368362f,
+	0.861689f,
+	-0.349f,
+	0.400587f,
+	0.825418f,
+	-0.397762f,
+	0.451323f,
+	0.785144f,
+	-0.424095f,
+	0.523643f,
+	0.765884f,
+	-0.373121f,
+	0.603289f,
+	0.753586f,
+	-0.261056f,
+	0.44978f,
+	0.832328f,
+	-0.323928f,
+	0.156509f,
+	0.915232f,
+	-0.371289f,
+	-0.0704135f,
+	0.915939f,
+	-0.395092f,
+	-0.00319557f,
+	0.926331f,
+	-0.376696f,
+	0.166676f,
+	0.911893f,
+	-0.37506f,
+	0.102989f,
+	0.962696f,
+	-0.250219f,
+	-0.0387958f,
+	0.995347f,
+	-0.0881961f,
+	0.0653507f,
+	0.992864f,
+	-0.0997527f,
+	0.179449f,
+	0.98367f,
+	-0.0138117f,
+	0.177828f,
+	0.983985f,
+	0.012264f,
+	0.0645076f,
+	0.995168f,
+	-0.0740203f,
+	-0.292502f,
+	0.938695f,
+	-0.182468f,
+	-0.400433f,
+	0.889464f,
+	-0.220243f,
+	-0.318802f,
+	0.923541f,
+	-0.213161f,
+	-0.169897f,
+	0.961934f,
+	-0.214052f,
+	-0.0267051f,
+	0.972116f,
+	-0.232975f,
+	-0.00536052f,
+	0.964395f,
+	-0.264412f,
+	-0.100769f,
+	0.988596f,
+	-0.111905f,
+	-0.404303f,
+	0.910751f,
+	0.0840968f,
+	-0.594207f,
+	0.803932f,
+	0.0247338f,
+	-0.396136f,
+	0.914658f,
+	0.0804795f,
+	-0.304433f,
+	0.952514f,
+	0.00620435f,
+	-0.201276f,
+	0.977901f,
+	-0.0565476f,
+	-0.264949f,
+	0.959844f,
+	-0.0922019f,
+	-0.227773f,
+	0.971084f,
+	-0.0715179f,
+	-0.172114f,
+	0.969698f,
+	-0.173387f,
+	-0.26936f,
+	0.945102f,
+	-0.185006f,
+	-0.392685f,
+	0.904465f,
+	-0.166556f,
+	-0.407044f,
+	0.896103f,
+	-0.176958f,
+	-0.40747f,
+	0.889993f,
+	-0.204647f,
+	-0.189782f,
+	0.978511f,
+	-0.0806113f,
+	-0.0480587f,
+	0.996223f,
+	-0.0723184f,
+	-0.217275f,
+	0.958525f,
+	-0.184451f,
+	-0.306094f,
+	0.944116f,
+	-0.122276f,
+	-0.254593f,
+	0.966558f,
+	0.0308049f,
+	-0.20196f,
+	0.972664f,
+	0.114613f,
+	-0.409794f,
+	0.899925f,
+	-0.14901f,
+	-0.415034f,
+	0.857771f,
+	-0.303274f,
+	-0.263165f,
+	0.89665f,
+	-0.356039f,
+	-0.215387f,
+	0.884962f,
+	-0.412857f,
+	-0.225079f,
+	0.887943f,
+	-0.401119f,
+	-0.0773061f,
+	0.916142f,
+	-0.393328f,
+	-0.0308036f,
+	0.905486f,
+	-0.423257f,
+	-0.0371917f,
+	0.883129f,
+	-0.467653f,
+	0.0716369f,
+	0.893813f,
+	-0.442681f,
+	0.12997f,
+	0.919319f,
+	-0.371429f,
+	0.119867f,
+	0.921216f,
+	-0.370126f,
+	0.0228827f,
+	0.984493f,
+	-0.173923f,
+	-0.0834452f,
+	0.988816f,
+	-0.123614f,
+	-0.247718f,
+	0.964917f,
+	-0.0870125f,
+	-0.254118f,
+	0.961997f,
+	-0.0999321f,
+	-0.0671834f,
+	0.977202f,
+	-0.201403f,
+	0.157483f,
+	0.940773f,
+	-0.300243f,
+	0.164503f,
+	0.92764f,
+	-0.335294f,
+	0.27582f,
+	0.929794f,
+	-0.243733f,
+	0.209142f,
+	0.946949f,
+	-0.244024f,
+	0.183638f,
+	0.949161f,
+	-0.255677f,
+	0.277174f,
+	0.906106f,
+	-0.319605f,
+	0.178788f,
+	0.896597f,
+	-0.405153f,
+	0.185529f,
+	0.860132f,
+	-0.475134f,
+	0.438868f,
+	0.800307f,
+	-0.408538f,
+	0.441024f,
+	0.788796f,
+	-0.428135f,
+	0.397261f,
+	0.791714f,
+	-0.464083f,
+	0.440809f,
+	0.77176f,
+	-0.458338f,
+	0.455755f,
+	0.768172f,
+	-0.449666f,
+	0.535299f,
+	0.762932f,
+	-0.362477f,
+	0.450448f,
+	0.842352f,
+	-0.295872f,
+	0.136515f,
+	0.937333f,
+	-0.320579f,
+	-0.0637901f,
+	0.937145f,
+	-0.343061f,
+	-0.0112309f,
+	0.935306f,
+	-0.353662f,
+	0.108413f,
+	0.948157f,
+	-0.298738f,
+	-0.0660356f,
+	0.972239f,
+	-0.224477f,
+	-0.07256f,
+	0.985988f,
+	-0.150208f,
+	0.0814078f,
+	0.980504f,
+	-0.178842f,
+	0.133209f,
+	0.989139f,
+	-0.0621265f,
+	0.112681f,
+	0.993117f,
+	-0.0319677f,
+	0.144875f,
+	0.987157f,
+	0.0673239f,
+	-0.178705f,
+	0.983714f,
+	-0.0192655f,
+	-0.383305f,
+	0.919432f,
+	-0.0878717f,
+	-0.311703f,
+	0.944518f,
+	-0.103569f,
+	-0.170547f,
+	0.974222f,
+	-0.147663f,
+	-0.0584686f,
+	0.987712f,
+	-0.144938f,
+	-0.130239f,
+	0.988008f,
+	-0.0829397f,
+	-0.30957f,
+	0.949755f,
+	0.0461837f,
+	-0.426068f,
+	0.896859f,
+	0.118784f,
+	-0.505712f,
+	0.862298f,
+	-0.0263905f,
+	-0.384432f,
+	0.913927f,
+	-0.130189f,
+	-0.233817f,
+	0.957708f,
+	-0.167708f,
+	-0.196686f,
+	0.961804f,
+	-0.190386f,
+	-0.272431f,
+	0.94059f,
+	-0.202662f,
+	-0.180772f,
+	0.950727f,
+	-0.251872f,
+	-0.0565853f,
+	0.956064f,
+	-0.287647f,
+	-0.288561f,
+	0.926858f,
+	-0.240141f,
+	-0.491099f,
+	0.856076f,
+	-0.161104f,
+	-0.419638f,
+	0.904096f,
+	-0.0807095f,
+	-0.388583f,
+	0.916169f,
+	-0.0981701f,
+	-0.261262f,
+	0.961028f,
+	-0.0903754f,
+	-0.0632456f,
+	0.997064f,
+	0.0431658f,
+	-0.169715f,
+	0.97859f,
+	0.116442f,
+	-0.344027f,
+	0.938297f,
+	0.0352825f,
+	-0.314669f,
+	0.949192f,
+	0.00417096f,
+	-0.192981f,
+	0.980434f,
+	0.0388389f,
+	-0.184602f,
+	0.98279f,
+	-0.00683269f,
+	-0.246496f,
+	0.934378f,
+	-0.25725f,
+	-0.19921f,
+	0.861846f,
+	-0.466409f,
+	-0.140436f,
+	0.848535f,
+	-0.510163f,
+	-0.20288f,
+	0.807079f,
+	-0.554493f,
+	-0.11519f,
+	0.832336f,
+	-0.542169f,
+	0.00924053f,
+	0.875455f,
+	-0.483211f,
+	-0.00888073f,
+	0.876341f,
+	-0.48161f,
+	0.00107193f,
+	0.907613f,
+	-0.419807f,
+	0.021101f,
+	0.930448f,
+	-0.365817f,
+	0.0745313f,
+	0.948396f,
+	-0.308205f,
+	-0.200438f,
+	0.964136f,
+	-0.17397f,
+	-0.166231f,
+	0.985214f,
+	-0.0414839f,
+	-0.252324f,
+	0.967639f,
+	-0.00281073f,
+	-0.16447f,
+	0.986195f,
+	-0.0192238f,
+	0.0101706f,
+	0.983613f,
+	-0.180006f,
+	0.16229f,
+	0.966979f,
+	-0.196502f,
+	0.152128f,
+	0.981833f,
+	-0.113406f,
+	0.194455f,
+	0.973444f,
+	-0.120809f,
+	0.334057f,
+	0.938492f,
+	-0.0874058f,
+	0.243016f,
+	0.928299f,
+	-0.281434f,
+	0.337071f,
+	0.885295f,
+	-0.320369f,
+	0.298461f,
+	0.876938f,
+	-0.376698f,
+	0.311828f,
+	0.819683f,
+	-0.480502f,
+	0.369257f,
+	0.755567f,
+	-0.54108f,
+	0.401798f,
+	0.784012f,
+	-0.473163f,
+	0.404891f,
+	0.784738f,
+	-0.469309f,
+	0.444437f,
+	0.782155f,
+	-0.436702f,
+	0.466084f,
+	0.794919f,
+	-0.388419f,
+	0.447341f,
+	0.805216f,
+	-0.389247f,
+	0.362297f,
+	0.887389f,
+	-0.285098f,
+	0.179937f,
+	0.962799f,
+	-0.201595f,
+	0.000795301f,
+	0.958246f,
+	-0.285946f,
+	-0.0439986f,
+	0.938528f,
+	-0.342389f,
+	0.000314903f,
+	0.959745f,
+	-0.280871f,
+	-0.0200826f,
+	0.975564f,
+	-0.218794f,
+	-0.0669112f,
+	0.936012f,
+	-0.345551f,
+	0.0051897f,
+	0.948012f,
+	-0.318192f,
+	0.0134178f,
+	0.970832f,
+	-0.239387f,
+	0.036317f,
+	0.978504f,
+	-0.203005f,
+	0.0625457f,
+	0.996542f,
+	-0.0547064f,
+	-0.151505f,
+	0.986626f,
+	0.0601296f,
+	-0.354535f,
+	0.929709f,
+	0.0997293f,
+	-0.323458f,
+	0.940866f,
+	0.100727f,
+	-0.112965f,
+	0.981029f,
+	0.157548f,
+	-0.108156f,
+	0.989168f,
+	0.0992381f,
+	-0.141093f,
+	0.979303f,
+	0.145114f,
+	-0.335564f,
+	0.940028f,
+	0.061184f,
+	-0.404784f,
+	0.910739f,
+	0.081883f,
+	-0.415621f,
+	0.909054f,
+	0.0296628f,
+	-0.326024f,
+	0.941449f,
+	-0.0859172f,
+	-0.204455f,
+	0.961807f,
+	-0.182004f,
+	-0.198427f,
+	0.946732f,
+	-0.253624f,
+	-0.160629f,
+	0.949f,
+	-0.27129f,
+	-0.122223f,
+	0.918206f,
+	-0.376775f,
+	-0.161284f,
+	0.939678f,
+	-0.301651f,
+	-0.374966f,
+	0.911783f,
+	-0.167489f,
+	-0.467696f,
+	0.856498f,
+	-0.218336f,
+	-0.443475f,
+	0.843003f,
+	-0.304427f,
+	-0.385194f,
+	0.898165f,
+	-0.211955f,
+	-0.377418f,
+	0.917998f,
+	-0.121804f,
+	-0.264639f,
+	0.962925f,
+	0.0523651f,
+	-0.211739f,
+	0.961017f,
+	0.177801f,
+	-0.229995f,
+	0.957255f,
+	0.175401f,
+	-0.280377f,
+	0.956102f,
+	0.0851875f,
+	-0.20016f,
+	0.97825f,
+	0.0544282f,
+	-0.10573f,
+	0.994257f,
+	-0.0165441f,
+	0.0203896f,
+	0.991211f,
+	-0.130708f,
+	-0.0236073f,
+	0.94884f,
+	-0.314873f,
+	-0.0941765f,
+	0.92043f,
+	-0.379394f,
+	-0.167941f,
+	0.897458f,
+	-0.407879f,
+	-0.187085f,
+	0.877031f,
+	-0.442511f,
+	-0.0729267f,
+	0.89358f,
+	-0.44294f,
+	-0.0781669f,
+	0.903365f,
+	-0.421688f,
+	-0.0898224f,
+	0.927661f,
+	-0.362461f,
+	-0.0306254f,
+	0.944826f,
+	-0.326139f,
+	0.00767666f,
+	0.952077f,
+	-0.305762f,
+	-0.288656f,
+	0.939633f,
+	-0.183761f,
+	-0.235623f,
+	0.952993f,
+	-0.190489f,
+	-0.273085f,
+	0.931861f,
+	-0.238874f,
+	-0.0949222f,
+	0.974332f,
+	-0.204123f,
+	0.149266f,
+	0.955245f,
+	-0.255397f,
+	0.0666117f,
+	0.957576f,
+	-0.280376f,
+	0.127398f,
+	0.979355f,
+	-0.156952f,
+	0.209457f,
+	0.954497f,
+	-0.21228f,
+	0.367092f,
+	0.913409f,
+	-0.175864f,
+	0.415953f,
+	0.865553f,
+	-0.278928f,
+	0.34245f,
+	0.832959f,
+	-0.434635f,
+	0.340781f,
+	0.830404f,
+	-0.440793f,
+	0.395293f,
+	0.802521f,
+	-0.446882f,
+	0.405952f,
+	0.792834f,
+	-0.454552f,
+	0.385024f,
+	0.788348f,
+	-0.479858f,
+	0.365166f,
+	0.783008f,
+	-0.503539f,
+	0.371074f,
+	0.838688f,
+	-0.39863f,
+	0.42233f,
+	0.859897f,
+	-0.286732f,
+	0.440629f,
+	0.882917f,
+	-0.162183f,
+	0.299827f,
+	0.949298f,
+	-0.0945333f,
+	0.141695f,
+	0.979344f,
+	-0.144247f,
+	0.039666f,
+	0.992248f,
+	-0.117771f,
+	0.021245f,
+	0.997585f,
+	-0.0661304f,
+	-0.0594041f,
+	0.983411f,
+	-0.17139f,
+	0.0611812f,
+	0.981318f,
+	-0.182404f,
+	0.0186916f,
+	0.932529f,
+	-0.360611f,
+	-0.0300853f,
+	0.91754f,
+	-0.396504f,
+	-0.00135599f,
+	0.922081f,
+	-0.386995f,
+	-0.0351954f,
+	0.956784f,
+	-0.28866f,
+	-0.108108f,
+	0.976189f,
+	-0.188065f,
+	-0.279221f,
+	0.950183f,
+	-0.13852f,
+	-0.398641f,
+	0.914814f,
+	-0.0648175f,
+	-0.383626f,
+	0.922668f,
+	-0.0389249f,
+	-0.188191f,
+	0.977628f,
+	0.0939533f,
+	-0.083441f,
+	0.973103f,
+	0.21473f,
+	-0.0631642f,
+	0.980575f,
+	0.185698f,
+	-0.269017f,
+	0.963031f,
+	0.0141438f,
+	-0.4376f,
+	0.89917f,
+	-0.000301879f,
+	-0.339736f,
+	0.940513f,
+	0.00384959f,
+	-0.235638f,
+	0.967987f,
+	-0.0864624f,
+	-0.0773761f,
+	0.988655f,
+	-0.128744f,
+	-0.0852549f,
+	0.968269f,
+	-0.234917f,
+	-0.114948f,
+	0.939941f,
+	-0.3214f,
+	-0.156571f,
+	0.928217f,
+	-0.337488f,
+	-0.29563f,
+	0.924155f,
+	-0.241951f,
+	-0.401682f,
+	0.899225f,
+	-0.173337f,
+	-0.351799f,
+	0.915761f,
+	-0.193956f,
+	-0.391021f,
+	0.882077f,
+	-0.262761f,
+	-0.525453f,
+	0.810665f,
+	-0.258305f,
+	-0.504092f,
+	0.859496f,
+	-0.0846014f,
+	-0.362403f,
+	0.931317f,
+	0.0362275f,
+	-0.27912f,
+	0.954258f,
+	0.107159f,
+	-0.207619f,
+	0.961802f,
+	0.178414f,
+	-0.228638f,
+	0.970139f,
+	0.0809669f,
+	-0.12077f,
+	0.992669f,
+	0.00484841f,
+	0.0304882f,
+	0.99448f,
+	-0.100401f,
+	0.0674392f,
+	0.979801f,
+	-0.18826f,
+	0.0351304f,
+	0.9953f,
+	-0.090241f,
+	-0.0704736f,
+	0.995263f,
+	-0.0669708f,
+	-0.129706f,
+	0.981562f,
+	-0.1404f,
+	-0.122442f,
+	0.956888f,
+	-0.263387f,
+	-0.0356665f,
+	0.922731f,
+	-0.38379f,
+	-0.0454106f,
+	0.896226f,
+	-0.441267f,
+	-0.0870705f,
+	0.865568f,
+	-0.493164f,
+	-0.0312927f,
+	0.854755f,
+	-0.518087f,
+	-0.0110302f,
+	0.85359f,
+	-0.520829f,
+	-0.135251f,
+	0.990349f,
+	0.0302781f,
+	-0.120846f,
+	0.991438f,
+	-0.049458f,
+	-0.156404f,
+	0.974115f,
+	-0.163209f,
+	-0.121903f,
+	0.951948f,
+	-0.280952f,
+	0.0966131f,
+	0.959924f,
+	-0.263082f,
+	0.0624341f,
+	0.96714f,
+	-0.24646f,
+	0.0557469f,
+	0.94749f,
+	-0.31489f,
+	0.245712f,
+	0.928812f,
+	-0.27737f,
+	0.339947f,
+	0.895451f,
+	-0.28741f,
+	0.505833f,
+	0.828917f,
+	-0.238808f,
+	0.492153f,
+	0.815708f,
+	-0.303985f,
+	0.325713f,
+	0.824266f,
+	-0.463138f,
+	0.357884f,
+	0.8174f,
+	-0.451416f,
+	0.423911f,
+	0.828952f,
+	-0.364879f,
+	0.465983f,
+	0.818349f,
+	-0.3364f,
+	0.340136f,
+	0.856815f,
+	-0.387524f,
+	0.250037f,
+	0.902839f,
+	-0.349804f,
+	0.270063f,
+	0.93551f,
+	-0.227788f,
+	0.268197f,
+	0.961943f,
+	0.0523086f,
+	0.314452f,
+	0.921737f,
+	0.226982f,
+	0.230483f,
+	0.962611f,
+	0.142328f,
+	-0.0337231f,
+	0.996519f,
+	0.0762456f,
+	-0.0478467f,
+	0.987694f,
+	0.1489f,
+	0.0777224f,
+	0.977564f,
+	0.195776f,
+	0.137813f,
+	0.987309f,
+	0.0789204f,
+	0.213773f,
+	0.976881f,
+	-0.00209812f,
+	0.0678985f,
+	0.982243f,
+	-0.174896f,
+	-0.118448f,
+	0.956882f,
+	-0.26523f,
+	-0.229961f,
+	0.9707f,
+	-0.0697049f,
+	-0.144208f,
+	0.98561f,
+	0.0881926f,
+	-0.198479f,
+	0.979386f,
+	0.0375393f,
+	-0.401292f,
+	0.909987f,
+	-0.104347f,
+	-0.400254f,
+	0.91005f,
+	-0.107726f,
+	-0.346067f,
+	0.932825f,
+	-0.100374f,
+	-0.193125f,
+	0.981161f,
+	0.00517742f,
+	-0.0334943f,
+	0.995589f,
+	0.0876359f,
+	-0.09901f,
+	0.987334f,
+	0.12397f,
+	-0.411919f,
+	0.909058f,
+	-0.0627387f,
+	-0.33988f,
+	0.934279f,
+	-0.107727f,
+	-0.163445f,
+	0.980417f,
+	-0.109859f,
+	-0.094399f,
+	0.976137f,
+	-0.195566f,
+	-0.0281723f,
+	0.98965f,
+	-0.140708f,
+	-0.0765865f,
+	0.985816f,
+	-0.149338f,
+	-0.168645f,
+	0.974838f,
+	-0.145776f,
+	-0.316363f,
+	0.934327f,
+	-0.164156f,
+	-0.429172f,
+	0.879196f,
+	-0.206943f,
+	-0.428946f,
+	0.898522f,
+	-0.0930795f,
+	-0.397223f,
+	0.909843f,
+	0.12f,
+	-0.511164f,
+	0.850782f,
+	0.12199f,
+	-0.553545f,
+	0.831305f,
+	-0.0501975f,
+	-0.425265f,
+	0.901367f,
+	-0.0817687f,
+	-0.377377f,
+	0.925701f,
+	-0.0257517f,
+	-0.226427f,
+	0.969468f,
+	0.0941363f,
+	-0.0709665f,
+	0.993431f,
+	0.0897693f,
+	-0.0343935f,
+	0.997803f,
+	-0.0566276f,
+	0.136725f,
+	0.981098f,
+	-0.136942f,
+	-0.000388307f,
+	0.974615f,
+	-0.223888f,
+	-0.143125f,
+	0.988947f,
+	-0.0387096f,
+	-0.0654844f,
+	0.993475f,
+	0.0933713f,
+	0.0107967f,
+	0.999865f,
+	0.0124207f,
+	0.0463655f,
+	0.990074f,
+	-0.132676f,
+	0.111072f,
+	0.958636f,
+	-0.262069f,
+	0.052211f,
+	0.918497f,
+	-0.391967f,
+	0.014765f,
+	0.869476f,
+	-0.493754f,
+	-0.00446669f,
+	0.826302f,
+	-0.56321f,
+	-0.00312167f,
+	0.829643f,
+	-0.558286f,
+	-0.205328f,
+	0.971118f,
+	-0.121531f,
+	-0.107279f,
+	0.990692f,
+	-0.0837913f,
+	-0.0655817f,
+	0.993795f,
+	-0.089834f,
+	-0.0669083f,
+	0.985851f,
+	-0.15369f,
+	0.0877486f,
+	0.98832f,
+	-0.124596f,
+	0.169572f,
+	0.978484f,
+	-0.117533f,
+	0.160152f,
+	0.950603f,
+	-0.265903f,
+	0.208233f,
+	0.926f,
+	-0.314903f,
+	0.349792f,
+	0.904675f,
+	-0.243329f,
+	0.449891f,
+	0.870303f,
+	-0.200426f,
+	0.566229f,
+	0.816333f,
+	-0.113956f,
+	0.48817f,
+	0.833849f,
+	-0.257655f,
+	0.363235f,
+	0.831342f,
+	-0.420631f,
+	0.324206f,
+	0.826771f,
+	-0.459718f,
+	0.3997f,
+	0.840833f,
+	-0.365021f,
+	0.353025f,
+	0.906211f,
+	-0.232714f,
+	0.219616f,
+	0.962891f,
+	-0.156874f,
+	0.0720827f,
+	0.994934f,
+	-0.0700696f,
+	0.045678f,
+	0.994046f,
+	0.0989266f,
+	0.213575f,
+	0.964796f,
+	0.153475f,
+	0.24905f,
+	0.930442f,
+	0.268798f,
+	0.0777133f,
+	0.945053f,
+	0.317546f,
+	-0.128028f,
+	0.977296f,
+	0.168824f,
+	0.0217263f,
+	0.951068f,
+	0.308215f,
+	0.207313f,
+	0.918764f,
+	0.335998f,
+	0.282654f,
+	0.924456f,
+	0.255906f,
+	0.201157f,
+	0.96204f,
+	0.184429f,
+	-0.110233f,
+	0.981395f,
+	0.157205f,
+	-0.355659f,
+	0.909169f,
+	0.216606f,
+	-0.21295f,
+	0.947904f,
+	0.236917f,
+	-0.107393f,
+	0.959263f,
+	0.261306f,
+	-0.278087f,
+	0.947596f,
+	0.157257f,
+	-0.393558f,
+	0.918794f,
+	0.0304824f,
+	-0.302068f,
+	0.952957f,
+	-0.0250724f,
+	-0.213276f,
+	0.970666f,
+	-0.110997f,
+	-0.166999f,
+	0.978773f,
+	-0.118807f,
+	-0.142246f,
+	0.989828f,
+	0.00258048f,
+	-0.283745f,
+	0.958854f,
+	0.0093455f,
+	-0.336957f,
+	0.941016f,
+	-0.0308147f,
+	-0.113565f,
+	0.9931f,
+	-0.02925f,
+	-0.0231129f,
+	0.991621f,
+	-0.127093f,
+	-0.107284f,
+	0.981887f,
+	-0.156166f,
+	-0.121783f,
+	0.990389f,
+	-0.0655664f,
+	-0.179469f,
+	0.983757f,
+	0.00373427f,
+	-0.267261f,
+	0.963295f,
+	0.0251965f,
+	-0.419417f,
+	0.907445f,
+	0.0251735f,
+	-0.582729f,
+	0.80835f,
+	0.0836507f,
+	-0.554692f,
+	0.78035f,
+	0.288741f,
+	-0.368624f,
+	0.840437f,
+	0.397218f,
+	-0.336016f,
+	0.929619f,
+	0.151335f,
+	-0.379048f,
+	0.912637f,
+	-0.153022f,
+	-0.410461f,
+	0.89244f,
+	-0.187275f,
+	-0.310698f,
+	0.938768f,
+	-0.148932f,
+	-0.0772428f,
+	0.993562f,
+	-0.0828798f,
+	0.0559112f,
+	0.996518f,
+	-0.0618564f,
+	0.218481f,
+	0.971621f,
+	-0.090653f,
+	0.0070055f,
+	0.988587f,
+	-0.150488f,
+	-0.287385f,
+	0.949521f,
+	-0.125778f,
+	-0.0963797f,
+	0.992515f,
+	-0.0749989f,
+	0.0940601f,
+	0.994076f,
+	-0.0544632f,
+	0.147534f,
+	0.985277f,
+	-0.0863886f,
+	0.20617f,
+	0.964455f,
+	-0.165287f,
+	0.228919f,
+	0.941159f,
+	-0.248628f,
+	0.142687f,
+	0.889558f,
+	-0.433967f,
+	0.0525074f,
+	0.86193f,
+	-0.5043f,
+	-0.0400559f,
+	0.852931f,
+	-0.520485f,
+	-0.12929f,
+	0.965503f,
+	-0.226025f,
+	-0.12119f,
+	0.954637f,
+	-0.271994f,
+	-0.0677494f,
+	0.970158f,
+	-0.232815f,
+	-0.0658176f,
+	0.978188f,
+	-0.197017f,
+	0.00868199f,
+	0.985201f,
+	-0.171183f,
+	0.183883f,
+	0.977449f,
+	-0.103828f,
+	0.283397f,
+	0.948052f,
+	-0.144513f,
+	0.244002f,
+	0.935244f,
+	-0.256481f,
+	0.251457f,
+	0.918413f,
+	-0.305429f,
+	0.421894f,
+	0.885288f,
+	-0.195626f,
+	0.539016f,
+	0.82675f,
+	-0.161076f,
+	0.595125f,
+	0.795068f,
+	-0.117014f,
+	0.542945f,
+	0.81823f,
+	-0.188971f,
+	0.36087f,
+	0.878337f,
+	-0.313523f,
+	0.249934f,
+	0.94591f,
+	-0.206849f,
+	0.203095f,
+	0.978645f,
+	0.0317209f,
+	0.0808087f,
+	0.992314f,
+	0.0937131f,
+	0.015528f,
+	0.990219f,
+	0.138653f,
+	0.01799f,
+	0.994881f,
+	0.09944f,
+	0.195411f,
+	0.975412f,
+	0.101915f,
+	0.0694818f,
+	0.977162f,
+	0.200816f,
+	0.0667035f,
+	0.917371f,
+	0.392404f,
+	-0.00815505f,
+	0.942331f,
+	0.334582f,
+	-0.124548f,
+	0.965608f,
+	0.228228f,
+	0.172601f,
+	0.943034f,
+	0.284421f,
+	0.392995f,
+	0.877789f,
+	0.273937f,
+	0.148864f,
+	0.962548f,
+	0.226586f,
+	-0.160978f,
+	0.90924f,
+	0.383887f,
+	-0.338041f,
+	0.865118f,
+	0.370538f,
+	-0.158685f,
+	0.913484f,
+	0.374654f,
+	-0.085827f,
+	0.934088f,
+	0.346573f,
+	-0.160284f,
+	0.956319f,
+	0.244467f,
+	-0.286424f,
+	0.955431f,
+	0.0715057f,
+	-0.239888f,
+	0.970684f,
+	0.0150701f,
+	-0.160609f,
+	0.986985f,
+	0.00807186f,
+	-0.109896f,
+	0.993313f,
+	-0.0353894f,
+	-0.197211f,
+	0.969041f,
+	-0.148551f,
+	-0.329877f,
+	0.939761f,
+	-0.0896172f,
+	-0.308832f,
+	0.948199f,
+	-0.0744408f,
+	-0.098416f,
+	0.980296f,
+	-0.171271f,
+	0.0274733f,
+	0.990192f,
+	-0.136989f,
+	-0.0841565f,
+	0.99088f,
+	-0.105235f,
+	-0.256459f,
+	0.960709f,
+	-0.106143f,
+	-0.249667f,
+	0.95978f,
+	0.128406f,
+	-0.305999f,
+	0.931391f,
+	0.197168f,
+	-0.484241f,
+	0.852569f,
+	0.196565f,
+	-0.610379f,
+	0.753144f,
+	0.245383f,
+	-0.585787f,
+	0.783089f,
+	0.208867f,
+	-0.367515f,
+	0.91758f,
+	0.151588f,
+	-0.0411995f,
+	0.989239f,
+	0.140389f,
+	-0.109078f,
+	0.987353f,
+	-0.115051f,
+	-0.380949f,
+	0.866858f,
+	-0.321615f,
+	-0.342318f,
+	0.88779f,
+	-0.307647f,
+	-0.12792f,
+	0.955198f,
+	-0.266896f,
+	0.0278952f,
+	0.967981f,
+	-0.249469f,
+	0.188442f,
+	0.9544f,
+	-0.231539f,
+	0.052008f,
+	0.978364f,
+	-0.200246f,
+	-0.225418f,
+	0.931417f,
+	-0.285742f,
+	-0.134566f,
+	0.926089f,
+	-0.352493f,
+	0.0345745f,
+	0.959769f,
+	-0.278653f,
+	0.174695f,
+	0.953806f,
+	-0.24441f,
+	0.227273f,
+	0.930386f,
+	-0.287627f,
+	0.325716f,
+	0.918321f,
+	-0.224934f,
+	0.329407f,
+	0.888239f,
+	-0.32019f,
+	0.0905336f,
+	0.875389f,
+	-0.474867f,
+	-0.0331275f,
+	0.86706f,
+	-0.497102f,
+	0.0288126f,
+	0.978255f,
+	-0.205394f,
+	-0.0838329f,
+	0.954569f,
+	-0.285956f,
+	-0.140323f,
+	0.954698f,
+	-0.262415f,
+	-0.112432f,
+	0.972197f,
+	-0.205408f,
+	0.0092799f,
+	0.981035f,
+	-0.193608f,
+	0.142017f,
+	0.962963f,
+	-0.229203f,
+	0.310781f,
+	0.933484f,
+	-0.17895f,
+	0.359578f,
+	0.919553f,
+	-0.158514f,
+	0.334745f,
+	0.907674f,
+	-0.253129f,
+	0.345814f,
+	0.873436f,
+	-0.342815f,
+	0.500723f,
+	0.821828f,
+	-0.271799f,
+	0.538977f,
+	0.812424f,
+	-0.22242f,
+	0.523422f,
+	0.839245f,
+	-0.147303f,
+	0.340441f,
+	0.940266f,
+	0.000412888f,
+	0.0152874f,
+	0.997305f,
+	0.0717554f,
+	0.0533145f,
+	0.966764f,
+	0.250049f,
+	0.112464f,
+	0.954457f,
+	0.276338f,
+	0.109039f,
+	0.955163f,
+	0.275271f,
+	0.0445431f,
+	0.979533f,
+	0.196291f,
+	0.165433f,
+	0.962373f,
+	0.21557f,
+	-0.0715535f,
+	0.977821f,
+	0.196841f,
+	-0.0891149f,
+	0.939351f,
+	0.331178f,
+	0.117094f,
+	0.910023f,
+	0.397676f,
+	0.030807f,
+	0.968216f,
+	0.248212f,
+	0.157233f,
+	0.982334f,
+	0.101481f,
+	0.403254f,
+	0.903723f,
+	0.143774f,
+	0.0482774f,
+	0.97679f,
+	0.208689f,
+	-0.297552f,
+	0.88274f,
+	0.363639f,
+	-0.30014f,
+	0.861944f,
+	0.408619f,
+	-0.211374f,
+	0.886111f,
+	0.412466f,
+	-0.03076f,
+	0.854928f,
+	0.517834f,
+	0.0282722f,
+	0.878122f,
+	0.477601f,
+	-0.13332f,
+	0.93673f,
+	0.32367f,
+	-0.256519f,
+	0.940042f,
+	0.224764f,
+	-0.183801f,
+	0.953616f,
+	0.238397f,
+	-0.0194462f,
+	0.968434f,
+	0.24851f,
+	-0.0907191f,
+	0.988269f,
+	0.122863f,
+	-0.322189f,
+	0.946234f,
+	-0.028899f,
+	-0.20601f,
+	0.965456f,
+	-0.159543f,
+	-0.0654489f,
+	0.973414f,
+	-0.219504f,
+	-0.113732f,
+	0.990052f,
+	-0.0828341f,
+	-0.135223f,
+	0.986029f,
+	0.0972711f,
+	-0.295266f,
+	0.944373f,
+	0.144834f,
+	-0.450404f,
+	0.860579f,
+	0.237781f,
+	-0.30004f,
+	0.881766f,
+	0.363958f,
+	-0.429075f,
+	0.860577f,
+	0.274411f,
+	-0.624789f,
+	0.771784f,
+	0.118272f,
+	-0.497638f,
+	0.864372f,
+	0.0722275f,
+	-0.313601f,
+	0.946808f,
+	-0.0721819f,
+	-0.057809f,
+	0.993544f,
+	-0.0976184f,
+	0.13458f,
+	0.987765f,
+	-0.078798f,
+	-0.184662f,
+	0.92514f,
+	-0.331688f,
+	-0.385787f,
+	0.812528f,
+	-0.436996f,
+	-0.187957f,
+	0.911737f,
+	-0.36525f,
+	0.0316981f,
+	0.954599f,
+	-0.296202f,
+	0.147926f,
+	0.956328f,
+	-0.252101f,
+	0.104858f,
+	0.974711f,
+	-0.197342f,
+	-0.0836115f,
+	0.931387f,
+	-0.354298f,
+	-0.111379f,
+	0.87594f,
+	-0.469386f,
+	-0.0328315f,
+	0.880204f,
+	-0.473458f,
+	0.162025f,
+	0.887756f,
+	-0.430856f,
+	0.205253f,
+	0.903446f,
+	-0.376373f,
+	0.237481f,
+	0.902569f,
+	-0.359125f,
+	0.385116f,
+	0.876359f,
+	-0.289276f,
+	0.249914f,
+	0.920198f,
+	-0.301294f,
+	0.0143883f,
+	0.906805f,
+	-0.421304f,
+	0.1198f,
+	0.98226f,
+	-0.14427f,
+	-0.009516f,
+	0.980934f,
+	-0.194106f,
+	-0.149357f,
+	0.951394f,
+	-0.269335f,
+	-0.133007f,
+	0.936454f,
+	-0.324597f,
+	0.034566f,
+	0.948692f,
+	-0.314306f,
+	0.178184f,
+	0.929444f,
+	-0.323086f,
+	0.219637f,
+	0.922638f,
+	-0.317015f,
+	0.296463f,
+	0.935411f,
+	-0.192652f,
+	0.416664f,
+	0.902617f,
+	-0.108048f,
+	0.442812f,
+	0.876638f,
+	-0.188209f,
+	0.465688f,
+	0.849444f,
+	-0.248152f,
+	0.511879f,
+	0.84424f,
+	-0.158868f,
+	0.360617f,
+	0.931627f,
+	-0.0450278f,
+	0.228988f,
+	0.955033f,
+	0.188354f,
+	-0.00280316f,
+	0.974776f,
+	0.223168f,
+	0.00899431f,
+	0.980078f,
+	0.198407f,
+	0.0845579f,
+	0.975657f,
+	0.202347f,
+	0.0600237f,
+	0.962271f,
+	0.265389f,
+	0.0344627f,
+	0.950379f,
+	0.309181f,
+	0.173636f,
+	0.921696f,
+	0.346881f,
+	-0.00190385f,
+	0.960894f,
+	0.276909f,
+	-0.186383f,
+	0.97431f,
+	0.126416f,
+	0.101162f,
+	0.98048f,
+	0.168596f,
+	0.181976f,
+	0.961147f,
+	0.207559f,
+	0.220019f,
+	0.957024f,
+	0.188939f,
+	0.310192f,
+	0.917199f,
+	0.250053f,
+	-0.02225f,
+	0.932984f,
+	0.359229f,
+	-0.395015f,
+	0.837639f,
+	0.377259f,
+	-0.325443f,
+	0.861588f,
+	0.389554f,
+	-0.255559f,
+	0.880464f,
+	0.39934f,
+	-0.151471f,
+	0.886274f,
+	0.437693f,
+	-0.0211154f,
+	0.863177f,
+	0.50446f,
+	0.00094362f,
+	0.808505f,
+	0.588488f,
+	-0.114242f,
+	0.850647f,
+	0.513176f,
+	-0.11027f,
+	0.888828f,
+	0.444776f,
+	-0.0310984f,
+	0.926772f,
+	0.374335f,
+	0.036991f,
+	0.899416f,
+	0.435525f,
+	-0.0593828f,
+	0.941327f,
+	0.33223f,
+	-0.108182f,
+	0.990534f,
+	0.0844942f,
+	-0.153469f,
+	0.985899f,
+	0.066708f,
+	-0.257292f,
+	0.956946f,
+	0.134368f,
+	-0.339432f,
+	0.926138f,
+	0.164482f,
+	-0.361227f,
+	0.853531f,
+	0.3755f,
+	-0.433268f,
+	0.811828f,
+	0.391425f,
+	-0.292152f,
+	0.883075f,
+	0.367186f,
+	-0.254971f,
+	0.931997f,
+	0.257627f,
+	-0.51111f,
+	0.857028f,
+	-0.0653379f,
+	-0.482419f,
+	0.859823f,
+	-0.167263f,
+	-0.240122f,
+	0.964988f,
+	-0.105544f,
+	-0.0637549f,
+	0.987476f,
+	-0.144314f,
+	0.14266f,
+	0.980144f,
+	-0.137714f,
+	0.096896f,
+	0.982614f,
+	-0.158371f,
+	-0.287298f,
+	0.856944f,
+	-0.42791f,
+	-0.299829f,
+	0.819408f,
+	-0.488542f,
+	-0.0881013f,
+	0.911449f,
+	-0.40187f,
+	0.0509938f,
+	0.949808f,
+	-0.308649f,
+	0.13334f,
+	0.962273f,
+	-0.237174f,
+	0.0865622f,
+	0.946427f,
+	-0.311099f,
+	0.0118172f,
+	0.924665f,
+	-0.380599f,
+	-0.0178448f,
+	0.910652f,
+	-0.412789f,
+	0.073892f,
+	0.906856f,
+	-0.414913f,
+	0.15114f,
+	0.90612f,
+	-0.395099f,
+	0.255577f,
+	0.878518f,
+	-0.403593f,
+	0.278013f,
+	0.865146f,
+	-0.417411f,
+	0.239832f,
+	0.923443f,
+	-0.299555f,
+	0.188412f,
+	0.940744f,
+	-0.281961f,
+	-0.0158305f,
+	0.982567f,
+	-0.185231f,
+	0.0666038f,
+	0.988337f,
+	-0.136945f,
+	-0.0538402f,
+	0.959334f,
+	-0.277092f,
+	-0.0212127f,
+	0.945816f,
+	-0.324009f,
+	-0.0150833f,
+	0.913689f,
+	-0.406133f,
+	0.15601f,
+	0.93774f,
+	-0.310331f,
+	0.182702f,
+	0.936618f,
+	-0.298942f,
+	0.189924f,
+	0.93758f,
+	-0.29133f,
+	0.333869f,
+	0.91329f,
+	-0.233307f,
+	0.499532f,
+	0.857573f,
+	-0.122619f,
+	0.46551f,
+	0.873216f,
+	-0.144201f,
+	0.373694f,
+	0.926999f,
+	0.0320189f,
+	0.203779f,
+	0.950539f,
+	0.234414f,
+	0.13831f,
+	0.928366f,
+	0.344974f,
+	0.0515931f,
+	0.949665f,
+	0.30899f,
+	0.0310079f,
+	0.96445f,
+	0.262439f,
+	0.0853119f,
+	0.968829f,
+	0.232577f,
+	-0.00103764f,
+	0.981733f,
+	0.190261f,
+	-0.00365072f,
+	0.967667f,
+	0.252206f,
+	0.10066f,
+	0.945677f,
+	0.309134f,
+	0.178572f,
+	0.914026f,
+	0.364237f,
+	-0.0213985f,
+	0.991455f,
+	0.128684f,
+	0.0498313f,
+	0.996519f,
+	0.0668339f,
+	0.120586f,
+	0.983203f,
+	0.137006f,
+	0.0910496f,
+	0.981472f,
+	0.16859f,
+	0.13401f,
+	0.919805f,
+	0.368783f,
+	-0.0801133f,
+	0.861028f,
+	0.502208f,
+	-0.337717f,
+	0.841946f,
+	0.420801f,
+	-0.27627f,
+	0.878916f,
+	0.388821f,
+	-0.2301f,
+	0.91025f,
+	0.344237f,
+	-0.177792f,
+	0.940411f,
+	0.289857f,
+	-0.131507f,
+	0.928729f,
+	0.346652f,
+	-0.0961971f,
+	0.892019f,
+	0.441642f,
+	-0.0639687f,
+	0.872394f,
+	0.4846f,
+	-0.0102449f,
+	0.879124f,
+	0.476482f,
+	-0.00257342f,
+	0.917704f,
+	0.397258f,
+	-0.0554909f,
+	0.910659f,
+	0.409416f,
+	0.0291401f,
+	0.896118f,
+	0.442858f,
+	0.0220451f,
+	0.91331f,
+	0.406668f,
+	-0.138595f,
+	0.921526f,
+	0.362741f,
+	-0.186305f,
+	0.924786f,
+	0.331755f,
+	-0.347011f,
+	0.903153f,
+	0.25278f,
+	-0.513046f,
+	0.817508f,
+	0.261656f,
+	-0.445268f,
+	0.835978f,
+	0.320745f,
+	-0.177443f,
+	0.933005f,
+	0.313074f,
+	-0.0397144f,
+	0.982015f,
+	0.184579f,
+	-0.223543f,
+	0.974128f,
+	-0.0332155f,
+	-0.4666f,
+	0.831165f,
+	-0.302406f,
+	-0.335541f,
+	0.890675f,
+	-0.306773f,
+	-0.0318096f,
+	0.973987f,
+	-0.224358f,
+	0.0953506f,
+	0.970682f,
+	-0.220646f,
+	0.134482f,
+	0.984534f,
+	-0.112281f,
+	-0.0162953f,
+	0.992479f,
+	-0.121323f,
+	-0.284204f,
+	0.902721f,
+	-0.322992f,
+	-0.211997f,
+	0.906314f,
+	-0.365585f,
+	-0.016875f,
+	0.958349f,
+	-0.285101f,
+	0.129044f,
+	0.959618f,
+	-0.24996f,
+	0.151996f,
+	0.928771f,
+	-0.338057f,
+	-0.0199776f,
+	0.904327f,
+	-0.426372f,
+	-0.0559071f,
+	0.940256f,
+	-0.335846f,
+	0.108952f,
+	0.945546f,
+	-0.306712f,
+	0.215589f,
+	0.905767f,
+	-0.364838f,
+	0.293281f,
+	0.878158f,
+	-0.377921f,
+	0.279356f,
+	0.877367f,
+	-0.390112f,
+	0.127912f,
+	0.886694f,
+	-0.444312f,
+	0.153161f,
+	0.902051f,
+	-0.403541f,
+	-0.0890667f,
+	0.969622f,
+	-0.227816f,
+	0.0791521f,
+	0.98141f,
+	-0.174841f,
+	0.0791423f,
+	0.971591f,
+	-0.22304f,
+	0.0168825f,
+	0.939671f,
+	-0.341662f,
+	-0.00465273f,
+	0.922224f,
+	-0.386629f,
+	0.0341103f,
+	0.949158f,
+	-0.312946f,
+	0.243022f,
+	0.94331f,
+	-0.226069f,
+	0.218985f,
+	0.910646f,
+	-0.350386f,
+	0.282576f,
+	0.88974f,
+	-0.358487f,
+	0.398347f,
+	0.877162f,
+	-0.268155f,
+	0.330147f,
+	0.941044f,
+	-0.073754f,
+	0.178397f,
+	0.970659f,
+	0.16123f,
+	0.0525065f,
+	0.954596f,
+	0.293241f,
+	0.0945297f,
+	0.914894f,
+	0.392472f,
+	0.13661f,
+	0.905749f,
+	0.401193f,
+	0.0406243f,
+	0.947359f,
+	0.317587f,
+	0.163762f,
+	0.925717f,
+	0.340926f,
+	0.040504f,
+	0.970394f,
+	0.238108f,
+	-0.0543453f,
+	0.975142f,
+	0.214812f,
+	2.68223e-005f,
+	0.976435f,
+	0.215812f,
+	0.209407f,
+	0.932778f,
+	0.293383f,
+	0.184464f,
+	0.966229f,
+	0.179928f,
+	-0.0113387f,
+	0.999016f,
+	0.0428878f,
+	0.079177f,
+	0.981677f,
+	0.173323f,
+	0.0362262f,
+	0.968187f,
+	0.24759f,
+	-0.0723427f,
+	0.93572f,
+	0.345245f,
+	-0.135834f,
+	0.890086f,
+	0.435082f,
+	-0.264248f,
+	0.873681f,
+	0.408479f,
+	-0.262216f,
+	0.89706f,
+	0.355706f,
+	-0.164052f,
+	0.919196f,
+	0.358002f,
+	-0.167176f,
+	0.924403f,
+	0.342829f,
+	-0.200682f,
+	0.904947f,
+	0.375229f,
+	-0.158624f,
+	0.899685f,
+	0.406701f,
+	-0.112022f,
+	0.891533f,
+	0.438886f,
+	-0.00921475f,
+	0.869473f,
+	0.493894f,
+	0.0802624f,
+	0.881225f,
+	0.465833f,
+	-0.0504548f,
+	0.922517f,
+	0.382645f,
+	-0.0121989f,
+	0.918687f,
+	0.394797f,
+	0.0440736f,
+	0.891185f,
+	0.451494f,
+	-0.0756766f,
+	0.900734f,
+	0.427728f,
+	-0.202037f,
+	0.909488f,
+	0.363335f,
+	-0.295423f,
+	0.866009f,
+	0.403428f,
+	-0.471319f,
+	0.827048f,
+	0.30635f,
+	-0.443758f,
+	0.874939f,
+	0.193806f,
+	-0.125026f,
+	0.977756f,
+	0.168412f,
+	0.0442668f,
+	0.987172f,
+	0.153403f,
+	-0.0338798f,
+	0.987768f,
+	0.152205f,
+	-0.259589f,
+	0.965039f,
+	-0.0362462f,
+	-0.35784f,
+	0.903258f,
+	-0.236805f,
+	-0.167942f,
+	0.956248f,
+	-0.239554f,
+	0.0460995f,
+	0.994911f,
+	-0.0895878f,
+	-0.00166787f,
+	0.99811f,
+	-0.0614342f,
+	-0.0336402f,
+	0.998923f,
+	0.0319432f,
+	-0.139942f,
+	0.989786f,
+	0.0271849f,
+	-0.21913f,
+	0.971861f,
+	-0.0864193f,
+	-0.083914f,
+	0.990307f,
+	-0.110685f,
+	0.180721f,
+	0.971397f,
+	-0.154041f,
+	0.29639f,
+	0.913592f,
+	-0.278393f,
+	0.0452233f,
+	0.94418f,
+	-0.326312f,
+	-0.13463f,
+	0.924181f,
+	-0.357441f,
+	0.11753f,
+	0.929423f,
+	-0.349798f,
+	0.238754f,
+	0.909243f,
+	-0.340989f,
+	0.272577f,
+	0.899491f,
+	-0.341494f,
+	0.343945f,
+	0.879082f,
+	-0.330025f,
+	0.202726f,
+	0.889055f,
+	-0.410468f,
+	0.0880936f,
+	0.876474f,
+	-0.473321f,
+	-0.000386659f,
+	0.989518f,
+	-0.144407f,
+	-0.0138532f,
+	0.983228f,
+	-0.181856f,
+	0.165824f,
+	0.98552f,
+	-0.0353913f,
+	0.196669f,
+	0.963831f,
+	-0.179867f,
+	0.00115533f,
+	0.93443f,
+	-0.356144f,
+	-0.0579019f,
+	0.928374f,
+	-0.36711f,
+	0.234096f,
+	0.913194f,
+	-0.333581f,
+	0.311749f,
+	0.881031f,
+	-0.355805f,
+	0.243154f,
+	0.902483f,
+	-0.355529f,
+	0.214274f,
+	0.956658f,
+	-0.197209f,
+	0.120355f,
+	0.990537f,
+	0.0659672f,
+	0.0219689f,
+	0.979298f,
+	0.201227f,
+	-0.0108785f,
+	0.963809f,
+	0.266373f,
+	-0.016985f,
+	0.957116f,
+	0.289205f,
+	0.15437f,
+	0.922679f,
+	0.353316f,
+	0.0959731f,
+	0.93811f,
+	0.332776f,
+	0.138832f,
+	0.935317f,
+	0.325434f,
+	0.133758f,
+	0.941295f,
+	0.309956f,
+	-0.00148525f,
+	0.972503f,
+	0.232885f,
+	0.00817406f,
+	0.979885f,
+	0.199396f,
+	0.180862f,
+	0.960033f,
+	0.213602f,
+	0.330054f,
+	0.924212f,
+	0.192085f,
+	0.039978f,
+	0.994865f,
+	0.0929833f,
+	-0.118088f,
+	0.976595f,
+	0.179768f,
+	-0.100092f,
+	0.923425f,
+	0.370498f,
+	-0.117559f,
+	0.88568f,
+	0.449166f,
+	-0.170937f,
+	0.879572f,
+	0.443997f,
+	-0.244838f,
+	0.844603f,
+	0.47613f,
+	-0.196312f,
+	0.844324f,
+	0.498577f,
+	-0.188529f,
+	0.85759f,
+	0.478535f,
+	-0.188501f,
+	0.839785f,
+	0.509145f,
+	-0.185899f,
+	0.842964f,
+	0.50483f,
+	-0.154293f,
+	0.872091f,
+	0.464382f,
+	-0.115474f,
+	0.894542f,
+	0.431811f,
+	-0.0887035f,
+	0.930393f,
+	0.35567f,
+	0.133188f,
+	0.884773f,
+	0.446583f,
+	0.0484666f,
+	0.90226f,
+	0.42846f,
+	-0.0427135f,
+	0.946807f,
+	0.318954f,
+	-0.0239721f,
+	0.952831f,
+	0.302554f,
+	-0.0435714f,
+	0.926502f,
+	0.373759f,
+	-0.182333f,
+	0.899048f,
+	0.398079f,
+	-0.323546f,
+	0.846433f,
+	0.422929f,
+	-0.334412f,
+	0.852971f,
+	0.40076f,
+	-0.325744f,
+	0.921829f,
+	0.210052f,
+	-0.140593f,
+	0.980752f,
+	0.135497f,
+	-0.000911154f,
+	0.974293f,
+	0.225285f,
+	-0.0250989f,
+	0.969759f,
+	0.242771f,
+	-0.116671f,
+	0.973198f,
+	0.198177f,
+	-0.222025f,
+	0.967605f,
+	0.12019f,
+	-0.252573f,
+	0.967519f,
+	-0.0106675f,
+	-0.0639595f,
+	0.99456f,
+	0.0822198f,
+	0.0427289f,
+	0.995551f,
+	0.0839736f,
+	-0.103724f,
+	0.994603f,
+	-0.00239601f,
+	-0.143088f,
+	0.981404f,
+	0.127957f,
+	-0.10974f,
+	0.986771f,
+	0.119333f,
+	0.0104156f,
+	0.996494f,
+	-0.083017f,
+	0.293943f,
+	0.936018f,
+	-0.193565f,
+	0.319276f,
+	0.921897f,
+	-0.219472f,
+	0.0381885f,
+	0.98033f,
+	-0.193638f,
+	-0.0675527f,
+	0.960756f,
+	-0.269042f,
+	0.11652f,
+	0.926645f,
+	-0.357425f,
+	0.2292f,
+	0.915276f,
+	-0.331265f,
+	0.30797f,
+	0.891339f,
+	-0.33267f,
+	0.348546f,
+	0.853103f,
+	-0.38824f,
+	0.249601f,
+	0.874176f,
+	-0.416553f,
+	0.18778f,
+	0.887174f,
+	-0.421499f,
+	0.122671f,
+	0.990262f,
+	-0.0658213f,
+	-0.0435566f,
+	0.992887f,
+	-0.11081f,
+	0.0494387f,
+	0.998572f,
+	0.0202637f,
+	0.34574f,
+	0.93458f,
+	0.0838063f,
+	0.205482f,
+	0.970541f,
+	-0.125808f,
+	0.00807532f,
+	0.928646f,
+	-0.370879f,
+	0.212354f,
+	0.896105f,
+	-0.389746f,
+	0.285287f,
+	0.924061f,
+	-0.254407f,
+	0.130923f,
+	0.978283f,
+	-0.160691f,
+	-0.0198715f,
+	0.999555f,
+	-0.0222427f,
+	-0.0516664f,
+	0.987583f,
+	0.148362f,
+	-0.0269196f,
+	0.97761f,
+	0.208697f,
+	-0.00903021f,
+	0.979554f,
+	0.200976f,
+	-0.00834551f,
+	0.993685f,
+	0.111894f,
+	0.110842f,
+	0.987362f,
+	0.113269f,
+	0.106874f,
+	0.976878f,
+	0.185167f,
+	0.141547f,
+	0.968321f,
+	0.205716f,
+	0.174972f,
+	0.958256f,
+	0.22612f,
+	0.054828f,
+	0.97071f,
+	0.233913f,
+	0.0299952f,
+	0.981566f,
+	0.188753f,
+	0.154988f,
+	0.980787f,
+	0.118472f,
+	0.340268f,
+	0.925521f,
+	0.166219f,
+	0.0136729f,
+	0.972695f,
+	0.231683f,
+	-0.270301f,
+	0.899629f,
+	0.342937f,
+	-0.212226f,
+	0.859098f,
+	0.465736f,
+	-0.140535f,
+	0.846284f,
+	0.513861f,
+	-0.175101f,
+	0.833937f,
+	0.523345f,
+	-0.270288f,
+	0.821688f,
+	0.501769f,
+	-0.282918f,
+	0.830124f,
+	0.48047f,
+	-0.174774f,
+	0.812594f,
+	0.556008f,
+	-0.140913f,
+	0.828898f,
+	0.541361f,
+	-0.117146f,
+	0.878471f,
+	0.463211f,
+	-0.0728003f,
+	0.920501f,
+	0.383899f,
+	-0.00293246f,
+	0.948861f,
+	0.315679f,
+	-0.025836f,
+	0.967046f,
+	0.253289f,
+	-0.00528251f,
+	0.957042f,
+	0.289901f,
+	0.088837f,
+	0.914901f,
+	0.393781f,
+	0.103014f,
+	0.924276f,
+	0.367561f,
+	0.00437406f,
+	0.95596f,
+	0.293464f,
+	-0.1442f,
+	0.952275f,
+	0.269032f,
+	-0.25396f,
+	0.922416f,
+	0.290951f,
+	-0.3894f,
+	0.883133f,
+	0.261618f,
+	-0.283615f,
+	0.906122f,
+	0.313857f,
+	-0.158058f,
+	0.930594f,
+	0.330171f,
+	-0.134893f,
+	0.961854f,
+	0.237993f,
+	-0.0720522f,
+	0.980808f,
+	0.181173f,
+	0.0349752f,
+	0.985618f,
+	0.16533f,
+	-0.115886f,
+	0.987377f,
+	0.107965f,
+	-0.182211f,
+	0.968171f,
+	0.171592f,
+	-0.154769f,
+	0.971197f,
+	0.181169f,
+	-0.0833304f,
+	0.991727f,
+	0.0976435f,
+	0.136344f,
+	0.989699f,
+	0.0436644f,
+	-0.106946f,
+	0.993768f,
+	-0.0314277f,
+	-0.261215f,
+	0.963441f,
+	0.0595659f,
+	0.0120329f,
+	0.999596f,
+	0.0257635f,
+	0.254582f,
+	0.953185f,
+	-0.163178f,
+	0.299581f,
+	0.899014f,
+	-0.319413f,
+	0.266729f,
+	0.9307f,
+	-0.250307f,
+	0.0579078f,
+	0.977779f,
+	-0.201483f,
+	0.0590491f,
+	0.968354f,
+	-0.242494f,
+	0.196887f,
+	0.912909f,
+	-0.357536f,
+	0.211047f,
+	0.877381f,
+	-0.430885f,
+	0.301745f,
+	0.869054f,
+	-0.39204f,
+	0.422629f,
+	0.852977f,
+	-0.306291f,
+	0.252055f,
+	0.896241f,
+	-0.364994f,
+	0.158615f,
+	0.91987f,
+	-0.35872f,
+	0.099088f,
+	0.991841f,
+	-0.0802016f,
+	-0.0649468f,
+	0.996188f,
+	-0.0582405f,
+	-0.09006f,
+	0.995865f,
+	-0.0119566f,
+	0.299186f,
+	0.949686f,
+	0.0926523f,
+	0.448961f,
+	0.886032f,
+	0.115674f,
+	0.225408f,
+	0.968479f,
+	-0.106019f,
+	0.110364f,
+	0.983262f,
+	-0.144965f,
+	0.0982296f,
+	0.994337f,
+	0.0405443f,
+	0.03386f,
+	0.98307f,
+	0.180072f,
+	-0.0548904f,
+	0.982813f,
+	0.176255f,
+	-0.131535f,
+	0.986412f,
+	0.0984329f,
+	-0.0772354f,
+	0.9803f,
+	0.181787f,
+	0.0556449f,
+	0.958844f,
+	0.278429f,
+	0.08308f,
+	0.969903f,
+	0.228882f,
+	0.0990101f,
+	0.980512f,
+	0.169685f,
+	0.044494f,
+	0.989611f,
+	0.136713f,
+	0.124145f,
+	0.981303f,
+	0.14708f,
+	0.126925f,
+	0.98249f,
+	0.136391f,
+	0.0289993f,
+	0.988064f,
+	0.151292f,
+	0.146433f,
+	0.982737f,
+	0.113073f,
+	0.210582f,
+	0.977005f,
+	-0.0334257f,
+	0.179552f,
+	0.980748f,
+	0.0767724f,
+	-0.0986728f,
+	0.925956f,
+	0.364513f,
+	-0.333893f,
+	0.835984f,
+	0.435484f,
+	-0.316161f,
+	0.849609f,
+	0.422146f,
+	-0.184942f,
+	0.836066f,
+	0.516517f,
+	-0.165011f,
+	0.827696f,
+	0.536368f,
+	-0.1919f,
+	0.849729f,
+	0.491054f,
+	-0.260791f,
+	0.881445f,
+	0.393754f,
+	-0.244518f,
+	0.891442f,
+	0.3815f,
+	-0.101674f,
+	0.91665f,
+	0.386543f,
+	-0.0135975f,
+	0.926806f,
+	0.375295f,
+	0.0383624f,
+	0.948469f,
+	0.31454f,
+	0.0311937f,
+	0.973858f,
+	0.225008f,
+	-0.0712105f,
+	0.966505f,
+	0.24657f,
+	-0.0567001f,
+	0.939446f,
+	0.337973f,
+	0.028793f,
+	0.937988f,
+	0.345471f,
+	0.0944493f,
+	0.922855f,
+	0.373388f,
+	0.0339618f,
+	0.928396f,
+	0.370037f,
+	-0.0877384f,
+	0.940895f,
+	0.327137f,
+	-0.18953f,
+	0.934542f,
+	0.301182f,
+	-0.32638f,
+	0.91712f,
+	0.22884f,
+	-0.359606f,
+	0.925931f,
+	0.115484f,
+	-0.250341f,
+	0.958991f,
+	0.132911f,
+	-0.0188851f,
+	0.981881f,
+	0.188556f,
+	0.0444017f,
+	0.992958f,
+	0.109832f,
+	0.0292244f,
+	0.992914f,
+	0.115188f,
+	-0.0809364f,
+	0.975181f,
+	0.206087f,
+	-0.271318f,
+	0.947628f,
+	0.168488f,
+	-0.147667f,
+	0.972329f,
+	0.181027f,
+	0.0428511f,
+	0.996597f,
+	0.0704105f,
+	0.186761f,
+	0.979997f,
+	-0.0687482f,
+	-0.111624f,
+	0.989428f,
+	-0.0925828f,
+	-0.210799f,
+	0.973161f,
+	-0.0923101f,
+	0.115063f,
+	0.969975f,
+	-0.214262f,
+	0.376036f,
+	0.900817f,
+	-0.217086f,
+	0.373114f,
+	0.884398f,
+	-0.280403f,
+	0.226074f,
+	0.905778f,
+	-0.358407f,
+	0.0100432f,
+	0.919347f,
+	-0.393319f,
+	0.0770135f,
+	0.93428f,
+	-0.348124f,
+	0.321395f,
+	0.895396f,
+	-0.308175f,
+	0.278274f,
+	0.88968f,
+	-0.361984f,
+	0.208857f,
+	0.897848f,
+	-0.387619f,
+	0.325776f,
+	0.898072f,
+	-0.295527f,
+	0.259741f,
+	0.94586f,
+	-0.194637f,
+	0.133572f,
+	0.977992f,
+	-0.160282f,
+	-0.0277257f,
+	0.992037f,
+	-0.122857f,
+	-0.0924217f,
+	0.994571f,
+	-0.0478129f,
+	-0.116438f,
+	0.990661f,
+	-0.0709396f,
+	0.19557f,
+	0.979919f,
+	-0.0388625f,
+	0.381806f,
+	0.908869f,
+	0.167871f,
+	0.299282f,
+	0.900933f,
+	0.314247f,
+	0.0638964f,
+	0.963274f,
+	0.260808f,
+	-0.0731879f,
+	0.961388f,
+	0.265284f,
+	0.00180295f,
+	0.933351f,
+	0.35896f,
+	0.0655899f,
+	0.939022f,
+	0.337544f,
+	-0.0612046f,
+	0.96894f,
+	0.239602f,
+	-0.166052f,
+	0.961913f,
+	0.217141f,
+	-0.0893118f,
+	0.965245f,
+	0.245614f,
+	0.0820047f,
+	0.941494f,
+	0.326902f,
+	0.146932f,
+	0.937808f,
+	0.314527f,
+	0.136588f,
+	0.939539f,
+	0.314023f,
+	0.166222f,
+	0.964584f,
+	0.204811f,
+	0.17109f,
+	0.976368f,
+	0.132039f,
+	0.0961069f,
+	0.992806f,
+	0.0714098f,
+	0.21778f,
+	0.975905f,
+	-0.013487f,
+	0.251597f,
+	0.967828f,
+	-0.00281592f,
+	-0.0966896f,
+	0.992674f,
+	0.0724564f,
+	-0.377842f,
+	0.87018f,
+	0.316262f,
+	-0.323773f,
+	0.853386f,
+	0.408537f,
+	-0.278729f,
+	0.867238f,
+	0.412564f,
+	-0.286188f,
+	0.874143f,
+	0.392391f,
+	-0.157911f,
+	0.873337f,
+	0.46081f,
+	-0.102832f,
+	0.901917f,
+	0.419488f,
+	-0.202979f,
+	0.914239f,
+	0.350665f,
+	-0.202531f,
+	0.912766f,
+	0.354739f,
+	-0.0843061f,
+	0.956165f,
+	0.28043f,
+	-0.032801f,
+	0.972626f,
+	0.23005f,
+	0.0558474f,
+	0.961664f,
+	0.268485f,
+	0.0617913f,
+	0.944956f,
+	0.321309f,
+	-0.110343f,
+	0.937288f,
+	0.330629f,
+	-0.100375f,
+	0.942449f,
+	0.318927f,
+	0.00551388f,
+	0.94452f,
+	0.328408f,
+	0.0918462f,
+	0.918926f,
+	0.383587f,
+	0.101653f,
+	0.927592f,
+	0.3595f,
+	-0.0426308f,
+	0.960188f,
+	0.276083f,
+	-0.204594f,
+	0.956809f,
+	0.206539f,
+	-0.269971f,
+	0.94929f,
+	0.161132f,
+	-0.226691f,
+	0.969699f,
+	0.0910768f,
+	-0.201053f,
+	0.979426f,
+	-0.0173973f,
+	-0.0500104f,
+	0.996428f,
+	-0.0680439f,
+	0.0272717f,
+	0.999341f,
+	-0.0239459f,
+	-0.123434f,
+	0.99095f,
+	0.0527561f,
+	-0.192945f,
+	0.962627f,
+	0.190054f,
+	-0.168165f,
+	0.969015f,
+	0.180916f,
+	-0.018086f,
+	0.998622f,
+	0.0492547f,
+	0.193647f,
+	0.975713f,
+	-0.102395f,
+	0.238523f,
+	0.949336f,
+	-0.204618f,
+	-0.0631885f,
+	0.979427f,
+	-0.191649f,
+	-0.143153f,
+	0.951631f,
+	-0.271858f,
+	0.148284f,
+	0.940281f,
+	-0.306403f,
+	0.321113f,
+	0.91022f,
+	-0.261508f,
+	0.430557f,
+	0.873923f,
+	-0.225566f,
+	0.33081f,
+	0.885978f,
+	-0.324974f,
+	0.0651303f,
+	0.881392f,
+	-0.467874f,
+	0.0061581f,
+	0.870221f,
+	-0.492623f,
+	0.228459f,
+	0.886891f,
+	-0.401535f,
+	0.271547f,
+	0.915184f,
+	-0.297827f,
+	0.234822f,
+	0.937165f,
+	-0.258033f,
+	0.27549f,
+	0.92259f,
+	-0.270061f,
+	0.15924f,
+	0.956523f,
+	-0.244348f,
+	0.0559303f,
+	0.980799f,
+	-0.186831f,
+	-0.135424f,
+	0.978967f,
+	-0.152593f,
+	-0.15029f,
+	0.985676f,
+	-0.0765294f,
+	-0.0914165f,
+	0.995631f,
+	-0.0190383f,
+	0.0718608f,
+	0.995714f,
+	0.0582141f,
+	0.110439f,
+	0.955564f,
+	0.273313f,
+	0.150494f,
+	0.878589f,
+	0.453246f,
+	0.206788f,
+	0.864483f,
+	0.458157f,
+	0.00161058f,
+	0.957582f,
+	0.288156f,
+	-0.0606597f,
+	0.978401f,
+	0.197616f,
+	0.0692656f,
+	0.9636f,
+	0.25822f,
+	-0.0150286f,
+	0.961837f,
+	0.273212f,
+	-0.0821089f,
+	0.979895f,
+	0.181835f,
+	-0.0658015f,
+	0.997594f,
+	0.0218166f,
+	0.0735253f,
+	0.997209f,
+	0.0129617f,
+	0.108564f,
+	0.993746f,
+	0.0261473f,
+	0.141903f,
+	0.981669f,
+	0.127241f,
+	0.25029f,
+	0.961471f,
+	0.113707f,
+	0.225135f,
+	0.967003f,
+	0.119246f,
+	0.180078f,
+	0.979492f,
+	0.0903737f,
+	0.237995f,
+	0.971216f,
+	-0.00990333f,
+	0.0690008f,
+	0.993039f,
+	0.0954582f,
+	-0.15301f,
+	0.921345f,
+	0.357369f,
+	-0.436898f,
+	0.858127f,
+	0.2697f,
+	-0.402318f,
+	0.892319f,
+	0.204714f,
+	-0.306797f,
+	0.913547f,
+	0.267033f,
+	-0.291188f,
+	0.917032f,
+	0.272509f,
+	-0.177835f,
+	0.951614f,
+	0.250608f,
+	-0.0915363f,
+	0.968867f,
+	0.230039f,
+	-0.166531f,
+	0.945303f,
+	0.280483f,
+	-0.214524f,
+	0.956179f,
+	0.199251f,
+	-0.012479f,
+	0.976094f,
+	0.216991f,
+	0.0485598f,
+	0.972045f,
+	0.22972f,
+	-0.0252191f,
+	0.985709f,
+	0.166561f,
+	-0.0505751f,
+	0.962642f,
+	0.266012f,
+	-0.0744793f,
+	0.942362f,
+	0.3262f,
+	-0.0759606f,
+	0.964725f,
+	0.252062f,
+	-0.0161104f,
+	0.954528f,
+	0.297687f,
+	0.0264811f,
+	0.949176f,
+	0.313631f,
+	0.160628f,
+	0.931063f,
+	0.327597f,
+	0.0783265f,
+	0.972396f,
+	0.219798f,
+	-0.0844827f,
+	0.993769f,
+	0.0727062f,
+	-0.216702f,
+	0.975588f,
+	-0.035603f,
+	-0.195742f,
+	0.979732f,
+	-0.0425419f,
+	-0.158684f,
+	0.986912f,
+	-0.0287187f,
+	-0.0351752f,
+	0.999203f,
+	-0.0188605f,
+	0.0075235f,
+	0.998877f,
+	-0.0467686f,
+	-0.172586f,
+	0.978556f,
+	-0.112436f,
+	-0.211691f,
+	0.968971f,
+	-0.127601f,
+	-0.0966389f,
+	0.974492f,
+	-0.202552f,
+	0.105494f,
+	0.955113f,
+	-0.276822f,
+	0.276059f,
+	0.900517f,
+	-0.335947f,
+	0.219894f,
+	0.907239f,
+	-0.358557f,
+	-0.0517693f,
+	0.940977f,
+	-0.334489f,
+	-0.112634f,
+	0.913693f,
+	-0.390485f,
+	0.139923f,
+	0.91136f,
+	-0.387097f,
+	0.277005f,
+	0.880398f,
+	-0.384926f,
+	0.432717f,
+	0.843875f,
+	-0.317222f,
+	0.433921f,
+	0.823502f,
+	-0.365455f,
+	0.17364f,
+	0.848637f,
+	-0.499665f,
+	-0.015678f,
+	0.850557f,
+	-0.525649f,
+	0.122709f,
+	0.874405f,
+	-0.469423f,
+	0.164019f,
+	0.896294f,
+	-0.412014f,
+	0.166557f,
+	0.925047f,
+	-0.34139f,
+	0.280426f,
+	0.925939f,
+	-0.25298f,
+	0.167623f,
+	0.949542f,
+	-0.265088f,
+	-0.00102675f,
+	0.947405f,
+	-0.320035f,
+	-0.299103f,
+	0.954018f,
+	0.0196808f,
+	-0.231787f,
+	0.963234f,
+	0.135851f,
+	-0.196753f,
+	0.961454f,
+	0.192081f,
+	-0.100151f,
+	0.951932f,
+	0.289472f,
+	-0.0563981f,
+	0.925245f,
+	0.375154f,
+	0.0944709f,
+	0.906549f,
+	0.411394f,
+	0.305132f,
+	0.862547f,
+	0.403618f,
+	0.241596f,
+	0.931691f,
+	0.271261f,
+	-0.00370494f,
+	0.998524f,
+	0.0541932f,
+	-0.000261525f,
+	0.998839f,
+	0.0481646f,
+	0.0260826f,
+	0.996855f,
+	0.0748309f,
+	0.0599122f,
+	0.998202f,
+	-0.00179631f,
+	0.0800977f,
+	0.992669f,
+	-0.0905174f,
+	0.0495455f,
+	0.986325f,
+	-0.157186f,
+	0.0563113f,
+	0.99071f,
+	-0.123787f,
+	0.0832843f,
+	0.991933f,
+	-0.095561f,
+	0.195142f,
+	0.979158f,
+	-0.0563024f,
+	0.166634f,
+	0.980307f,
+	0.105976f,
+	0.195862f,
+	0.965878f,
+	0.169461f,
+	0.284001f,
+	0.943304f,
+	0.171815f,
+	-0.127388f,
+	0.981047f,
+	0.146008f,
+	-0.325222f,
+	0.907949f,
+	0.264311f,
+	-0.283635f,
+	0.916157f,
+	0.28321f,
+	-0.335047f,
+	0.926228f,
+	0.17276f,
+	-0.335005f,
+	0.934046f,
+	0.123816f,
+	-0.290471f,
+	0.951826f,
+	0.098256f,
+	-0.155538f,
+	0.980437f,
+	0.120632f,
+	-0.103955f,
+	0.982905f,
+	0.151957f,
+	-0.195165f,
+	0.971298f,
+	0.135979f,
+	-0.117017f,
+	0.988828f,
+	0.0923353f,
+	-0.0942839f,
+	0.995508f,
+	0.00860997f,
+	-0.0378307f,
+	0.988218f,
+	0.148301f,
+	0.011735f,
+	0.964206f,
+	0.264893f,
+	-0.104568f,
+	0.970188f,
+	0.218634f,
+	-0.0628876f,
+	0.976435f,
+	0.206445f,
+	-0.0629747f,
+	0.98253f,
+	0.175127f,
+	-0.0956593f,
+	0.974263f,
+	0.204109f,
+	0.00313264f,
+	0.95614f,
+	0.292895f,
+	0.184054f,
+	0.913334f,
+	0.363241f,
+	0.234886f,
+	0.917194f,
+	0.321843f,
+	0.0818984f,
+	0.986888f,
+	0.139086f,
+	-0.195667f,
+	0.979747f,
+	-0.0425424f,
+	-0.217661f,
+	0.976006f,
+	-0.00606019f,
+	-0.197993f,
+	0.980131f,
+	-0.011927f,
+	-0.0476541f,
+	0.998861f,
+	-0.00224411f,
+	0.0987461f,
+	0.994341f,
+	-0.039179f,
+	-0.0376594f,
+	0.985822f,
+	-0.163515f,
+	-0.127665f,
+	0.950129f,
+	-0.284528f,
+	0.022229f,
+	0.926621f,
+	-0.37534f,
+	0.1509f,
+	0.867911f,
+	-0.473243f,
+	0.251356f,
+	0.84329f,
+	-0.475061f,
+	0.180391f,
+	0.877498f,
+	-0.44436f,
+	-0.0381311f,
+	0.903323f,
+	-0.427263f,
+	-0.0302687f,
+	0.878817f,
+	-0.476199f,
+	0.151045f,
+	0.843437f,
+	-0.515557f,
+	0.243043f,
+	0.829132f,
+	-0.503459f,
+	0.361214f,
+	0.815934f,
+	-0.451416f,
+	0.469501f,
+	0.80804f,
+	-0.355866f,
+	0.232058f,
+	0.89573f,
+	-0.379233f,
+	-0.0406313f,
+	0.902008f,
+	-0.429803f,
+	0.0570971f,
+	0.896722f,
+	-0.438895f,
+	0.139199f,
+	0.907425f,
+	-0.396488f,
+	0.0981956f,
+	0.909915f,
+	-0.403003f,
+	0.173099f,
+	0.913856f,
+	-0.367293f,
+	0.208242f,
+	0.936494f,
+	-0.28216f,
+	0.104323f,
+	0.936228f,
+	-0.335549f,
+	-0.455877f,
+	0.874672f,
+	0.164697f,
+	-0.324643f,
+	0.906811f,
+	0.268889f,
+	-0.22917f,
+	0.934048f,
+	0.273927f,
+	-0.11917f,
+	0.945648f,
+	0.302569f,
+	-0.0303449f,
+	0.953424f,
+	0.300104f,
+	0.0953211f,
+	0.968161f,
+	0.231468f,
+	0.307551f,
+	0.928088f,
+	0.209914f,
+	0.396906f,
+	0.882705f,
+	0.251588f,
+	0.154339f,
+	0.98019f,
+	0.124127f,
+	0.00614755f,
+	0.999958f,
+	0.00674104f,
+	0.0862143f,
+	0.995356f,
+	-0.0428297f,
+	0.0605751f,
+	0.988948f,
+	-0.135323f,
+	0.116851f,
+	0.991236f,
+	-0.0616197f,
+	0.0626175f,
+	0.989161f,
+	-0.132815f,
+	0.0598334f,
+	0.989391f,
+	-0.132381f,
+	0.0870904f,
+	0.982628f,
+	-0.163882f,
+	0.0967617f,
+	0.982554f,
+	-0.15882f,
+	0.0255981f,
+	0.999032f,
+	-0.0357718f,
+	0.114826f,
+	0.99101f,
+	0.0686587f,
+	0.196799f,
+	0.954402f,
+	0.22447f,
+	-0.0385546f,
+	0.932725f,
+	0.358521f,
+	-0.332784f,
+	0.924223f,
+	0.18726f,
+	-0.304588f,
+	0.936692f,
+	0.172726f,
+	-0.293315f,
+	0.937819f,
+	0.185638f,
+	-0.274742f,
+	0.953043f,
+	0.127381f,
+	-0.263119f,
+	0.962853f,
+	0.0606766f,
+	-0.268024f,
+	0.959606f,
+	0.0855591f,
+	-0.0879001f,
+	0.973995f,
+	0.208824f,
+	-0.133948f,
+	0.986848f,
+	0.0904876f,
+	-0.113332f,
+	0.988235f,
+	0.102703f,
+	-0.0299834f,
+	0.985262f,
+	0.168402f,
+	-0.19277f,
+	0.976736f,
+	0.0939502f,
+	-0.0881002f,
+	0.973369f,
+	0.211639f,
+	-0.024161f,
+	0.965814f,
+	0.258109f,
+	-0.0447814f,
+	0.977625f,
+	0.205534f,
+	-0.0454862f,
+	0.975256f,
+	0.216349f,
+	-0.133105f,
+	0.964838f,
+	0.22665f,
+	-0.114579f,
+	0.956534f,
+	0.268169f,
+	0.0712671f,
+	0.941693f,
+	0.328841f,
+	0.238728f,
+	0.884921f,
+	0.399904f,
+	0.297664f,
+	0.869038f,
+	0.395183f,
+	-0.00961778f,
+	0.988677f,
+	0.149748f,
+	-0.265709f,
+	0.963666f,
+	-0.0273077f,
+	-0.143358f,
+	0.988736f,
+	0.0430136f,
+	-0.00534208f,
+	0.998711f,
+	-0.0504723f,
+	0.174549f,
+	0.979244f,
+	-0.103024f,
+	0.0753759f,
+	0.97722f,
+	-0.198391f,
+	-0.0309169f,
+	0.954209f,
+	-0.297538f,
+	0.114484f,
+	0.932628f,
+	-0.342197f,
+	0.277629f,
+	0.881086f,
+	-0.382896f,
+	0.233881f,
+	0.840787f,
+	-0.488238f,
+	0.145974f,
+	0.866169f,
+	-0.477957f,
+	-0.0214889f,
+	0.855591f,
+	-0.517207f,
+	0.015747f,
+	0.850281f,
+	-0.526094f,
+	0.181736f,
+	0.859322f,
+	-0.478056f,
+	0.233268f,
+	0.832868f,
+	-0.501913f,
+	0.278912f,
+	0.819449f,
+	-0.500711f,
+	0.37496f,
+	0.838284f,
+	-0.395834f,
+	0.211098f,
+	0.909912f,
+	-0.357069f,
+	0.0173895f,
+	0.949305f,
+	-0.313875f,
+	0.0778513f,
+	0.935569f,
+	-0.344455f,
+	0.13573f,
+	0.919161f,
+	-0.369756f,
+	0.128317f,
+	0.903382f,
+	-0.40919f,
+	0.134873f,
+	0.894846f,
+	-0.425512f,
+	0.140765f,
+	0.922098f,
+	-0.360446f,
+	0.195779f,
+	0.941368f,
+	-0.274766f,
+	-0.498792f,
+	0.861228f,
+	0.0974355f,
+	-0.334273f,
+	0.933116f,
+	0.132498f,
+	-0.209899f,
+	0.97009f,
+	0.121936f,
+	-0.146122f,
+	0.979163f,
+	0.141027f,
+	-0.00844043f,
+	0.991347f,
+	0.130997f,
+	0.183871f,
+	0.98064f,
+	0.0673491f,
+	0.295623f,
+	0.955305f,
+	0.000649681f,
+	0.325261f,
+	0.940591f,
+	0.0974362f,
+	0.279972f,
+	0.936209f,
+	0.212435f,
+	0.117319f,
+	0.989809f,
+	0.0807136f,
+	0.167452f,
+	0.985876f,
+	0.00303625f,
+	0.0997326f,
+	0.991951f,
+	-0.0780129f,
+	0.0970545f,
+	0.989541f,
+	-0.106723f,
+	0.122983f,
+	0.982138f,
+	-0.14241f,
+	0.0889416f,
+	0.984545f,
+	-0.150867f,
+	0.0922265f,
+	0.975522f,
+	-0.199627f,
+	0.0767647f,
+	0.98447f,
+	-0.15788f,
+	-0.0166949f,
+	0.981051f,
+	-0.193027f,
+	-0.0192651f,
+	0.97159f,
+	-0.235885f,
+	-0.0430007f,
+	0.99834f,
+	-0.038322f,
+	-0.1057f,
+	0.976121f,
+	0.189775f,
+	-0.21501f,
+	0.968939f,
+	0.122177f,
+	-0.312622f,
+	0.947332f,
+	0.0695023f,
+	-0.268759f,
+	0.958656f,
+	0.0935212f,
+	-0.210053f,
+	0.974561f,
+	0.0781578f,
+	-0.280996f,
+	0.956877f,
+	0.0736733f,
+	-0.29425f,
+	0.945004f,
+	0.142776f,
+	-0.103752f,
+	0.988352f,
+	0.111339f,
+	-0.0179991f,
+	0.994529f,
+	0.102897f,
+	-0.257355f,
+	0.965403f,
+	0.0420096f,
+	-0.105403f,
+	0.956057f,
+	0.273578f,
+	-0.10459f,
+	0.942017f,
+	0.318851f,
+	-0.129983f,
+	0.956026f,
+	0.262903f,
+	-0.0671262f,
+	0.95499f,
+	0.288944f,
+	-0.00387184f,
+	0.948915f,
+	0.315508f,
+	-0.104327f,
+	0.957897f,
+	0.267486f,
+	-0.136557f,
+	0.931775f,
+	0.336375f,
+	-0.0981417f,
+	0.964639f,
+	0.24462f,
+	0.0564237f,
+	0.977306f,
+	0.204178f,
+	0.151449f,
+	0.955346f,
+	0.253725f,
+	0.313069f,
+	0.882901f,
+	0.349962f,
+	0.317375f,
+	0.903515f,
+	0.287983f,
+	-0.14146f,
+	0.988238f,
+	-0.0580959f,
+	-0.183704f,
+	0.977531f,
+	-0.10337f,
+	0.0729777f,
+	0.993775f,
+	-0.0841813f,
+	0.241185f,
+	0.959561f,
+	-0.145165f,
+	0.180872f,
+	0.946861f,
+	-0.26597f,
+	0.0759246f,
+	0.918564f,
+	-0.387911f,
+	0.0834031f,
+	0.881426f,
+	-0.4649f,
+	0.312989f,
+	0.886301f,
+	-0.341334f,
+	0.345782f,
+	0.8869f,
+	-0.306339f,
+	0.190174f,
+	0.893803f,
+	-0.40614f,
+	0.0967003f,
+	0.870562f,
+	-0.482463f,
+	-0.011292f,
+	0.813313f,
+	-0.581716f,
+	0.104307f,
+	0.818569f,
+	-0.564858f,
+	0.278742f,
+	0.804599f,
+	-0.524332f,
+	0.252871f,
+	0.80123f,
+	-0.542298f,
+	0.288393f,
+	0.816691f,
+	-0.499846f,
+	0.158986f,
+	0.877853f,
+	-0.451771f,
+	-0.0422089f,
+	0.892803f,
+	-0.448466f,
+	0.0676213f,
+	0.902423f,
+	-0.425511f,
+	0.196008f,
+	0.897779f,
+	-0.394428f,
+	0.174291f,
+	0.88488f,
+	-0.431984f,
+	0.107973f,
+	0.893114f,
+	-0.43668f,
+	0.0286973f,
+	0.916566f,
+	-0.398853f,
+	0.0334026f,
+	0.935074f,
+	-0.352875f,
+	-0.456752f,
+	0.886621f,
+	-0.0726759f,
+	-0.35821f,
+	0.92461f,
+	-0.129546f,
+	-0.255187f,
+	0.962466f,
+	-0.0924034f,
+	-0.153659f,
+	0.987984f,
+	-0.0166497f,
+	0.0326193f,
+	0.998752f,
+	-0.0378261f,
+	0.219848f,
+	0.975435f,
+	-0.0138776f,
+	0.325192f,
+	0.945498f,
+	0.0168406f,
+	0.223054f,
+	0.973348f,
+	-0.0532875f,
+	0.221049f,
+	0.975263f,
+	0.000679153f,
+	0.242907f,
+	0.969656f,
+	0.0276409f,
+	0.175892f,
+	0.983375f,
+	-0.0451076f,
+	0.180873f,
+	0.98342f,
+	0.0130764f,
+	0.169259f,
+	0.981997f,
+	-0.0838673f,
+	0.138819f,
+	0.973225f,
+	-0.183198f,
+	0.0923263f,
+	0.975478f,
+	-0.199795f,
+	0.109785f,
+	0.97291f,
+	-0.203452f,
+	0.048887f,
+	0.975403f,
+	-0.214938f,
+	0.0862303f,
+	0.974446f,
+	-0.207409f,
+	0.0239822f,
+	0.965181f,
+	-0.260482f,
+	-0.234299f,
+	0.93066f,
+	-0.281028f,
+	-0.183154f,
+	0.968628f,
+	-0.167974f,
+	-0.163946f,
+	0.9725f,
+	-0.165423f,
+	-0.29935f,
+	0.945623f,
+	-0.127226f,
+	-0.309491f,
+	0.943295f,
+	-0.120043f,
+	-0.244588f,
+	0.967669f,
+	-0.0615978f,
+	-0.316375f,
+	0.948228f,
+	-0.0277512f,
+	-0.278706f,
+	0.959538f,
+	-0.0401272f,
+	-0.112855f,
+	0.98959f,
+	-0.0893067f,
+	-0.0120823f,
+	0.999804f,
+	0.015665f,
+	-0.269265f,
+	0.962743f,
+	0.0249422f,
+	-0.319779f,
+	0.940968f,
+	0.110998f,
+	-0.127925f,
+	0.957822f,
+	0.257316f,
+	-0.134411f,
+	0.958853f,
+	0.250069f,
+	-0.0963489f,
+	0.939739f,
+	0.328035f,
+	0.013379f,
+	0.931979f,
+	0.362265f,
+	-0.059723f,
+	0.950577f,
+	0.304692f,
+	-0.140375f,
+	0.96932f,
+	0.201776f,
+	0.0285405f,
+	0.975242f,
+	0.219289f,
+	0.0759984f,
+	0.981739f,
+	0.174395f,
+	0.082912f,
+	0.985645f,
+	0.14707f,
+	0.244118f,
+	0.959921f,
+	0.137686f,
+	0.433469f,
+	0.888297f,
+	0.151764f,
+	0.159753f,
+	0.986026f,
+	0.0472448f,
+	-0.155828f,
+	0.965805f,
+	-0.207217f,
+	0.0529598f,
+	0.961817f,
+	-0.268522f,
+	0.302231f,
+	0.91749f,
+	-0.258588f,
+	0.300969f,
+	0.905771f,
+	-0.298324f,
+	0.219954f,
+	0.902269f,
+	-0.370851f,
+	0.168125f,
+	0.874674f,
+	-0.45462f,
+	0.0852064f,
+	0.832228f,
+	-0.547846f,
+	0.293285f,
+	0.876411f,
+	-0.381953f,
+	0.299707f,
+	0.878674f,
+	-0.371628f,
+	0.169625f,
+	0.87124f,
+	-0.460618f,
+	0.152784f,
+	0.862886f,
+	-0.481751f,
+	0.140952f,
+	0.826781f,
+	-0.544578f,
+	0.216806f,
+	0.796193f,
+	-0.564865f,
+	0.252088f,
+	0.778347f,
+	-0.575003f,
+	0.184028f,
+	0.779276f,
+	-0.599052f,
+	0.07662f,
+	0.847353f,
+	-0.525474f,
+	-0.000576164f,
+	0.875581f,
+	-0.483072f,
+	0.0676453f,
+	0.855821f,
+	-0.51283f,
+	0.10935f,
+	0.864233f,
+	-0.491064f,
+	0.170357f,
+	0.902391f,
+	-0.395814f,
+	0.0783522f,
+	0.922085f,
+	-0.378973f,
+	-0.0376769f,
+	0.945309f,
+	-0.323992f,
+	-0.0145087f,
+	0.973617f,
+	-0.227725f,
+	-0.23379f,
+	0.969091f,
+	0.0787691f,
+	-0.308611f,
+	0.949667f,
+	-0.0537712f,
+	-0.26795f,
+	0.959457f,
+	-0.087437f,
+	-0.196118f,
+	0.96672f,
+	-0.16429f,
+	0.0184009f,
+	0.993828f,
+	-0.109391f,
+	0.124962f,
+	0.988681f,
+	-0.0830367f,
+	0.297057f,
+	0.954812f,
+	-0.00955538f,
+	0.355506f,
+	0.934478f,
+	-0.0191401f,
+	0.206845f,
+	0.957298f,
+	-0.201981f,
+	0.24827f,
+	0.946264f,
+	-0.207234f,
+	0.137685f,
+	0.959548f,
+	-0.245584f,
+	0.129837f,
+	0.983718f,
+	-0.124261f,
+	0.240211f,
+	0.966075f,
+	-0.0948542f,
+	0.253383f,
+	0.959847f,
+	-0.120381f,
+	0.101386f,
+	0.970431f,
+	-0.219056f,
+	0.110568f,
+	0.971775f,
+	-0.208395f,
+	0.09998f,
+	0.968593f,
+	-0.227667f,
+	0.051279f,
+	0.9528f,
+	-0.299236f,
+	0.0182953f,
+	0.960636f,
+	-0.277207f,
+	-0.177379f,
+	0.948528f,
+	-0.262356f,
+	-0.248744f,
+	0.930203f,
+	-0.269905f,
+	-0.201336f,
+	0.9681f,
+	-0.14915f,
+	-0.308378f,
+	0.940105f,
+	-0.145279f,
+	-0.337871f,
+	0.915739f,
+	-0.217407f,
+	-0.303349f,
+	0.940151f,
+	-0.155226f,
+	-0.267648f,
+	0.955794f,
+	-0.121746f,
+	-0.256838f,
+	0.946595f,
+	-0.194914f,
+	-0.151848f,
+	0.978969f,
+	-0.136244f,
+	-0.166527f,
+	0.98578f,
+	-0.0225025f,
+	-0.271416f,
+	0.956933f,
+	0.103014f,
+	-0.388293f,
+	0.921445f,
+	0.0129329f,
+	-0.211649f,
+	0.973838f,
+	0.0827345f,
+	-0.164151f,
+	0.971899f,
+	0.168719f,
+	-0.20343f,
+	0.950968f,
+	0.232971f,
+	-0.0501604f,
+	0.944198f,
+	0.325535f,
+	0.0851988f,
+	0.916779f,
+	0.390203f,
+	-0.0675238f,
+	0.966737f,
+	0.246698f,
+	-0.050967f,
+	0.964665f,
+	0.258503f,
+	0.0897532f,
+	0.945965f,
+	0.311599f,
+	0.203817f,
+	0.954291f,
+	0.218604f,
+	0.298323f,
+	0.9542f,
+	0.0224806f,
+	0.409994f,
+	0.911395f,
+	0.0355409f,
+	0.297451f,
+	0.952362f,
+	0.0673044f,
+	0.087158f,
+	0.982486f,
+	-0.164695f,
+	0.130693f,
+	0.926163f,
+	-0.353753f,
+	0.287973f,
+	0.877932f,
+	-0.3825f,
+	0.285473f,
+	0.870692f,
+	-0.400501f,
+	0.210236f,
+	0.894171f,
+	-0.395297f,
+	0.291478f,
+	0.889926f,
+	-0.350816f,
+	0.238796f,
+	0.833f,
+	-0.499086f,
+	0.156519f,
+	0.786723f,
+	-0.597134f,
+	0.265294f,
+	0.807831f,
+	-0.526334f,
+	0.196683f,
+	0.821511f,
+	-0.535197f,
+	0.111545f,
+	0.852981f,
+	-0.509883f,
+	0.148451f,
+	0.876975f,
+	-0.457031f,
+	0.27925f,
+	0.865803f,
+	-0.415216f,
+	0.364812f,
+	0.845771f,
+	-0.389337f,
+	0.213362f,
+	0.862896f,
+	-0.458135f,
+	-0.014091f,
+	0.870788f,
+	-0.491456f,
+	-0.0389733f,
+	0.872117f,
+	-0.487742f,
+	0.0697073f,
+	0.876793f,
+	-0.475789f,
+	0.0500075f,
+	0.893805f,
+	-0.445659f,
+	0.0507492f,
+	0.920605f,
+	-0.387184f,
+	0.00717016f,
+	0.971083f,
+	-0.238636f,
+	-0.12982f,
+	0.987525f,
+	-0.0891113f,
+	-0.196671f,
+	0.977747f,
+	-0.0730188f,
+	-0.180786f,
+	0.972597f,
+	0.146192f,
+	-0.276836f,
+	0.956623f,
+	0.0907445f,
+	-0.145247f,
+	0.980389f,
+	0.133193f,
+	-0.201228f,
+	0.967008f,
+	-0.156214f,
+	-0.0137179f,
+	0.995281f,
+	-0.0960578f,
+	0.139707f,
+	0.987867f,
+	-0.0678349f,
+	0.246306f,
+	0.96116f,
+	-0.124516f,
+	0.421865f,
+	0.906227f,
+	-0.0279788f,
+	0.299255f,
+	0.934152f,
+	-0.194439f,
+	0.288356f,
+	0.912569f,
+	-0.289945f,
+	0.0853497f,
+	0.915952f,
+	-0.392106f,
+	0.039019f,
+	0.957394f,
+	-0.286136f,
+	0.208597f,
+	0.95771f,
+	-0.198188f,
+	0.25753f,
+	0.95731f,
+	-0.131287f,
+	0.153643f,
+	0.978938f,
+	-0.134439f,
+	0.0994252f,
+	0.976974f,
+	-0.188775f,
+	0.12654f,
+	0.974603f,
+	-0.184759f,
+	0.142684f,
+	0.966335f,
+	-0.214099f,
+	-0.00843645f,
+	0.93512f,
+	-0.354231f,
+	-0.17704f,
+	0.933769f,
+	-0.311017f,
+	-0.343277f,
+	0.895674f,
+	-0.282717f,
+	-0.276715f,
+	0.959562f,
+	-0.0516624f,
+	-0.215753f,
+	0.976427f,
+	-0.00633257f,
+	-0.305134f,
+	0.926522f,
+	-0.220112f,
+	-0.33388f,
+	0.920497f,
+	-0.203001f,
+	-0.259644f,
+	0.948413f,
+	-0.181927f,
+	-0.268974f,
+	0.938104f,
+	-0.218205f,
+	-0.245938f,
+	0.962991f,
+	-0.110289f,
+	-0.275564f,
+	0.96071f,
+	0.0331654f,
+	-0.258271f,
+	0.944524f,
+	0.202903f,
+	-0.309053f,
+	0.947461f,
+	0.0824847f,
+	-0.320335f,
+	0.94673f,
+	-0.0329778f,
+	-0.208609f,
+	0.963472f,
+	0.167941f,
+	-0.270763f,
+	0.941796f,
+	0.199269f,
+	-0.104692f,
+	0.947993f,
+	0.30058f,
+	0.0304241f,
+	0.930802f,
+	0.364255f,
+	0.0189457f,
+	0.906511f,
+	0.421757f,
+	-0.0823065f,
+	0.924037f,
+	0.373337f,
+	0.102263f,
+	0.911082f,
+	0.39934f,
+	0.325851f,
+	0.888801f,
+	0.322263f,
+	0.371159f,
+	0.927767f,
+	0.0385981f,
+	0.355076f,
+	0.934525f,
+	0.0241533f,
+	0.375158f,
+	0.916478f,
+	0.139015f,
+	0.286108f,
+	0.953917f,
+	-0.0904664f,
+	0.199009f,
+	0.919897f,
+	-0.337913f,
+	0.358636f,
+	0.872243f,
+	-0.332523f,
+	0.268543f,
+	0.846175f,
+	-0.460296f,
+	0.182977f,
+	0.871041f,
+	-0.455858f,
+	0.289295f,
+	0.860781f,
+	-0.418765f,
+	0.382576f,
+	0.820168f,
+	-0.425393f,
+	0.183794f,
+	0.780369f,
+	-0.597699f,
+	0.239111f,
+	0.770893f,
+	-0.590381f,
+	0.11759f,
+	0.781853f,
+	-0.612273f,
+	0.0625615f,
+	0.849006f,
+	-0.524666f,
+	0.09237f,
+	0.869569f,
+	-0.485096f,
+	0.210947f,
+	0.881757f,
+	-0.421908f,
+	0.36331f,
+	0.890409f,
+	-0.274185f,
+	0.280816f,
+	0.923638f,
+	-0.260836f,
+	0.0186632f,
+	0.936387f,
+	-0.350473f,
+	-0.00764646f,
+	0.914133f,
+	-0.405343f,
+	0.0383964f,
+	0.885647f,
+	-0.462769f,
+	0.0296537f,
+	0.913944f,
+	-0.404755f,
+	-0.02984f,
+	0.920171f,
+	-0.390377f,
+	-0.172982f,
+	0.943792f,
+	-0.281663f,
+	-0.19032f,
+	0.979403f,
+	0.0674393f,
+	-0.205961f,
+	0.972526f,
+	0.108505f,
+};
+
+btScalar Landscape08Tex[] = {
+	0.0f,
+	0.757813f,
+	0.0f,
+	0.75f,
+	0.0078125f,
+	0.757813f,
+	0.0078125f,
+	0.75f,
+	0.015625f,
+	0.757813f,
+	0.015625f,
+	0.75f,
+	0.0234375f,
+	0.757813f,
+	0.0234375f,
+	0.75f,
+	0.03125f,
+	0.757813f,
+	0.03125f,
+	0.75f,
+	0.0390625f,
+	0.757813f,
+	0.0390625f,
+	0.75f,
+	0.046875f,
+	0.757813f,
+	0.046875f,
+	0.75f,
+	0.0546875f,
+	0.757813f,
+	0.0546875f,
+	0.75f,
+	0.0625f,
+	0.757813f,
+	0.0625f,
+	0.75f,
+	0.0703125f,
+	0.757813f,
+	0.0703125f,
+	0.75f,
+	0.078125f,
+	0.757813f,
+	0.078125f,
+	0.75f,
+	0.0859375f,
+	0.757813f,
+	0.0859375f,
+	0.75f,
+	0.09375f,
+	0.757813f,
+	0.09375f,
+	0.75f,
+	0.101563f,
+	0.757813f,
+	0.101563f,
+	0.75f,
+	0.109375f,
+	0.757813f,
+	0.109375f,
+	0.75f,
+	0.117188f,
+	0.757813f,
+	0.117188f,
+	0.75f,
+	0.125f,
+	0.757813f,
+	0.125f,
+	0.75f,
+	0.132813f,
+	0.757813f,
+	0.132813f,
+	0.75f,
+	0.140625f,
+	0.757813f,
+	0.140625f,
+	0.75f,
+	0.148438f,
+	0.757813f,
+	0.148438f,
+	0.75f,
+	0.15625f,
+	0.757813f,
+	0.15625f,
+	0.75f,
+	0.164063f,
+	0.757813f,
+	0.164063f,
+	0.75f,
+	0.171875f,
+	0.757813f,
+	0.171875f,
+	0.75f,
+	0.179688f,
+	0.757813f,
+	0.179688f,
+	0.75f,
+	0.1875f,
+	0.757813f,
+	0.1875f,
+	0.75f,
+	0.195313f,
+	0.757813f,
+	0.195313f,
+	0.75f,
+	0.203125f,
+	0.757813f,
+	0.203125f,
+	0.75f,
+	0.210938f,
+	0.757813f,
+	0.210938f,
+	0.75f,
+	0.21875f,
+	0.757813f,
+	0.21875f,
+	0.75f,
+	0.226563f,
+	0.757813f,
+	0.226563f,
+	0.75f,
+	0.234375f,
+	0.757813f,
+	0.234375f,
+	0.75f,
+	0.242188f,
+	0.757813f,
+	0.242188f,
+	0.75f,
+	0.25f,
+	0.757813f,
+	0.25f,
+	0.75f,
+	0.257813f,
+	0.757813f,
+	0.257813f,
+	0.75f,
+	0.265625f,
+	0.757813f,
+	0.265625f,
+	0.75f,
+	0.273438f,
+	0.757813f,
+	0.273438f,
+	0.75f,
+	0.28125f,
+	0.757813f,
+	0.28125f,
+	0.75f,
+	0.289063f,
+	0.757813f,
+	0.289063f,
+	0.75f,
+	0.296875f,
+	0.757813f,
+	0.296875f,
+	0.75f,
+	0.304688f,
+	0.757813f,
+	0.304688f,
+	0.75f,
+	0.3125f,
+	0.757813f,
+	0.3125f,
+	0.75f,
+	0.320313f,
+	0.757813f,
+	0.320313f,
+	0.75f,
+	0.328125f,
+	0.757813f,
+	0.328125f,
+	0.75f,
+	0.335938f,
+	0.757813f,
+	0.335938f,
+	0.75f,
+	0.34375f,
+	0.757813f,
+	0.34375f,
+	0.75f,
+	0.351563f,
+	0.757813f,
+	0.351563f,
+	0.75f,
+	0.359375f,
+	0.757813f,
+	0.359375f,
+	0.75f,
+	0.367188f,
+	0.757813f,
+	0.367188f,
+	0.75f,
+	0.375f,
+	0.757813f,
+	0.375f,
+	0.75f,
+	0.382813f,
+	0.757813f,
+	0.382813f,
+	0.75f,
+	0.390625f,
+	0.757813f,
+	0.390625f,
+	0.75f,
+	0.398438f,
+	0.757813f,
+	0.398438f,
+	0.75f,
+	0.40625f,
+	0.757813f,
+	0.40625f,
+	0.75f,
+	0.414063f,
+	0.757813f,
+	0.414063f,
+	0.75f,
+	0.421875f,
+	0.757813f,
+	0.421875f,
+	0.75f,
+	0.429688f,
+	0.757813f,
+	0.429688f,
+	0.75f,
+	0.4375f,
+	0.757813f,
+	0.4375f,
+	0.75f,
+	0.445313f,
+	0.757813f,
+	0.445313f,
+	0.75f,
+	0.453125f,
+	0.757813f,
+	0.453125f,
+	0.75f,
+	0.460938f,
+	0.757813f,
+	0.460938f,
+	0.75f,
+	0.46875f,
+	0.757813f,
+	0.46875f,
+	0.75f,
+	0.476563f,
+	0.757813f,
+	0.476563f,
+	0.75f,
+	0.484375f,
+	0.757813f,
+	0.484375f,
+	0.75f,
+	0.492188f,
+	0.757813f,
+	0.492188f,
+	0.75f,
+	0.5f,
+	0.757813f,
+	0.5f,
+	0.75f,
+	0.507813f,
+	0.757813f,
+	0.507813f,
+	0.75f,
+	0.0f,
+	0.765625f,
+	0.0078125f,
+	0.765625f,
+	0.015625f,
+	0.765625f,
+	0.0234375f,
+	0.765625f,
+	0.03125f,
+	0.765625f,
+	0.0390625f,
+	0.765625f,
+	0.046875f,
+	0.765625f,
+	0.0546875f,
+	0.765625f,
+	0.0625f,
+	0.765625f,
+	0.0703125f,
+	0.765625f,
+	0.078125f,
+	0.765625f,
+	0.0859375f,
+	0.765625f,
+	0.09375f,
+	0.765625f,
+	0.101563f,
+	0.765625f,
+	0.109375f,
+	0.765625f,
+	0.117188f,
+	0.765625f,
+	0.125f,
+	0.765625f,
+	0.132813f,
+	0.765625f,
+	0.140625f,
+	0.765625f,
+	0.148438f,
+	0.765625f,
+	0.15625f,
+	0.765625f,
+	0.164063f,
+	0.765625f,
+	0.171875f,
+	0.765625f,
+	0.179688f,
+	0.765625f,
+	0.1875f,
+	0.765625f,
+	0.195313f,
+	0.765625f,
+	0.203125f,
+	0.765625f,
+	0.210938f,
+	0.765625f,
+	0.21875f,
+	0.765625f,
+	0.226563f,
+	0.765625f,
+	0.234375f,
+	0.765625f,
+	0.242188f,
+	0.765625f,
+	0.25f,
+	0.765625f,
+	0.257813f,
+	0.765625f,
+	0.265625f,
+	0.765625f,
+	0.273438f,
+	0.765625f,
+	0.28125f,
+	0.765625f,
+	0.289063f,
+	0.765625f,
+	0.296875f,
+	0.765625f,
+	0.304688f,
+	0.765625f,
+	0.3125f,
+	0.765625f,
+	0.320313f,
+	0.765625f,
+	0.328125f,
+	0.765625f,
+	0.335938f,
+	0.765625f,
+	0.34375f,
+	0.765625f,
+	0.351563f,
+	0.765625f,
+	0.359375f,
+	0.765625f,
+	0.367188f,
+	0.765625f,
+	0.375f,
+	0.765625f,
+	0.382813f,
+	0.765625f,
+	0.390625f,
+	0.765625f,
+	0.398438f,
+	0.765625f,
+	0.40625f,
+	0.765625f,
+	0.414063f,
+	0.765625f,
+	0.421875f,
+	0.765625f,
+	0.429688f,
+	0.765625f,
+	0.4375f,
+	0.765625f,
+	0.445313f,
+	0.765625f,
+	0.453125f,
+	0.765625f,
+	0.460938f,
+	0.765625f,
+	0.46875f,
+	0.765625f,
+	0.476563f,
+	0.765625f,
+	0.484375f,
+	0.765625f,
+	0.492188f,
+	0.765625f,
+	0.5f,
+	0.765625f,
+	0.507813f,
+	0.765625f,
+	0.0f,
+	0.773438f,
+	0.0078125f,
+	0.773438f,
+	0.015625f,
+	0.773438f,
+	0.0234375f,
+	0.773438f,
+	0.03125f,
+	0.773438f,
+	0.0390625f,
+	0.773438f,
+	0.046875f,
+	0.773438f,
+	0.0546875f,
+	0.773438f,
+	0.0625f,
+	0.773438f,
+	0.0703125f,
+	0.773438f,
+	0.078125f,
+	0.773438f,
+	0.0859375f,
+	0.773438f,
+	0.09375f,
+	0.773438f,
+	0.101563f,
+	0.773438f,
+	0.109375f,
+	0.773438f,
+	0.117188f,
+	0.773438f,
+	0.125f,
+	0.773438f,
+	0.132813f,
+	0.773438f,
+	0.140625f,
+	0.773438f,
+	0.148438f,
+	0.773438f,
+	0.15625f,
+	0.773438f,
+	0.164063f,
+	0.773438f,
+	0.171875f,
+	0.773438f,
+	0.179688f,
+	0.773438f,
+	0.1875f,
+	0.773438f,
+	0.195313f,
+	0.773438f,
+	0.203125f,
+	0.773438f,
+	0.210938f,
+	0.773438f,
+	0.21875f,
+	0.773438f,
+	0.226563f,
+	0.773438f,
+	0.234375f,
+	0.773438f,
+	0.242188f,
+	0.773438f,
+	0.25f,
+	0.773438f,
+	0.257813f,
+	0.773438f,
+	0.265625f,
+	0.773438f,
+	0.273438f,
+	0.773438f,
+	0.28125f,
+	0.773438f,
+	0.289063f,
+	0.773438f,
+	0.296875f,
+	0.773438f,
+	0.304688f,
+	0.773438f,
+	0.3125f,
+	0.773438f,
+	0.320313f,
+	0.773438f,
+	0.328125f,
+	0.773438f,
+	0.335938f,
+	0.773438f,
+	0.34375f,
+	0.773438f,
+	0.351563f,
+	0.773438f,
+	0.359375f,
+	0.773438f,
+	0.367188f,
+	0.773438f,
+	0.375f,
+	0.773438f,
+	0.382813f,
+	0.773438f,
+	0.390625f,
+	0.773438f,
+	0.398438f,
+	0.773438f,
+	0.40625f,
+	0.773438f,
+	0.414063f,
+	0.773438f,
+	0.421875f,
+	0.773438f,
+	0.429688f,
+	0.773438f,
+	0.4375f,
+	0.773438f,
+	0.445313f,
+	0.773438f,
+	0.453125f,
+	0.773438f,
+	0.460938f,
+	0.773438f,
+	0.46875f,
+	0.773438f,
+	0.476563f,
+	0.773438f,
+	0.484375f,
+	0.773438f,
+	0.492188f,
+	0.773438f,
+	0.5f,
+	0.773438f,
+	0.507813f,
+	0.773438f,
+	0.0f,
+	0.78125f,
+	0.0078125f,
+	0.78125f,
+	0.015625f,
+	0.78125f,
+	0.0234375f,
+	0.78125f,
+	0.03125f,
+	0.78125f,
+	0.0390625f,
+	0.78125f,
+	0.046875f,
+	0.78125f,
+	0.0546875f,
+	0.78125f,
+	0.0625f,
+	0.78125f,
+	0.0703125f,
+	0.78125f,
+	0.078125f,
+	0.78125f,
+	0.0859375f,
+	0.78125f,
+	0.09375f,
+	0.78125f,
+	0.101563f,
+	0.78125f,
+	0.109375f,
+	0.78125f,
+	0.117188f,
+	0.78125f,
+	0.125f,
+	0.78125f,
+	0.132813f,
+	0.78125f,
+	0.140625f,
+	0.78125f,
+	0.148438f,
+	0.78125f,
+	0.15625f,
+	0.78125f,
+	0.164063f,
+	0.78125f,
+	0.171875f,
+	0.78125f,
+	0.179688f,
+	0.78125f,
+	0.1875f,
+	0.78125f,
+	0.195313f,
+	0.78125f,
+	0.203125f,
+	0.78125f,
+	0.210938f,
+	0.78125f,
+	0.21875f,
+	0.78125f,
+	0.226563f,
+	0.78125f,
+	0.234375f,
+	0.78125f,
+	0.242188f,
+	0.78125f,
+	0.25f,
+	0.78125f,
+	0.257813f,
+	0.78125f,
+	0.265625f,
+	0.78125f,
+	0.273438f,
+	0.78125f,
+	0.28125f,
+	0.78125f,
+	0.289063f,
+	0.78125f,
+	0.296875f,
+	0.78125f,
+	0.304688f,
+	0.78125f,
+	0.3125f,
+	0.78125f,
+	0.320313f,
+	0.78125f,
+	0.328125f,
+	0.78125f,
+	0.335938f,
+	0.78125f,
+	0.34375f,
+	0.78125f,
+	0.351563f,
+	0.78125f,
+	0.359375f,
+	0.78125f,
+	0.367188f,
+	0.78125f,
+	0.375f,
+	0.78125f,
+	0.382813f,
+	0.78125f,
+	0.390625f,
+	0.78125f,
+	0.398438f,
+	0.78125f,
+	0.40625f,
+	0.78125f,
+	0.414063f,
+	0.78125f,
+	0.421875f,
+	0.78125f,
+	0.429688f,
+	0.78125f,
+	0.4375f,
+	0.78125f,
+	0.445313f,
+	0.78125f,
+	0.453125f,
+	0.78125f,
+	0.460938f,
+	0.78125f,
+	0.46875f,
+	0.78125f,
+	0.476563f,
+	0.78125f,
+	0.484375f,
+	0.78125f,
+	0.492188f,
+	0.78125f,
+	0.5f,
+	0.78125f,
+	0.507813f,
+	0.78125f,
+	0.0f,
+	0.789063f,
+	0.0078125f,
+	0.789063f,
+	0.015625f,
+	0.789063f,
+	0.0234375f,
+	0.789063f,
+	0.03125f,
+	0.789063f,
+	0.0390625f,
+	0.789063f,
+	0.046875f,
+	0.789063f,
+	0.0546875f,
+	0.789063f,
+	0.0625f,
+	0.789063f,
+	0.0703125f,
+	0.789063f,
+	0.078125f,
+	0.789063f,
+	0.0859375f,
+	0.789063f,
+	0.09375f,
+	0.789063f,
+	0.101563f,
+	0.789063f,
+	0.109375f,
+	0.789063f,
+	0.117188f,
+	0.789063f,
+	0.125f,
+	0.789063f,
+	0.132813f,
+	0.789063f,
+	0.140625f,
+	0.789063f,
+	0.148438f,
+	0.789063f,
+	0.15625f,
+	0.789063f,
+	0.164063f,
+	0.789063f,
+	0.171875f,
+	0.789063f,
+	0.179688f,
+	0.789063f,
+	0.1875f,
+	0.789063f,
+	0.195313f,
+	0.789063f,
+	0.203125f,
+	0.789063f,
+	0.210938f,
+	0.789063f,
+	0.21875f,
+	0.789063f,
+	0.226563f,
+	0.789063f,
+	0.234375f,
+	0.789063f,
+	0.242188f,
+	0.789063f,
+	0.25f,
+	0.789063f,
+	0.257813f,
+	0.789063f,
+	0.265625f,
+	0.789063f,
+	0.273438f,
+	0.789063f,
+	0.28125f,
+	0.789063f,
+	0.289063f,
+	0.789063f,
+	0.296875f,
+	0.789063f,
+	0.304688f,
+	0.789063f,
+	0.3125f,
+	0.789063f,
+	0.320313f,
+	0.789063f,
+	0.328125f,
+	0.789063f,
+	0.335938f,
+	0.789063f,
+	0.34375f,
+	0.789063f,
+	0.351563f,
+	0.789063f,
+	0.359375f,
+	0.789063f,
+	0.367188f,
+	0.789063f,
+	0.375f,
+	0.789063f,
+	0.382813f,
+	0.789063f,
+	0.390625f,
+	0.789063f,
+	0.398438f,
+	0.789063f,
+	0.40625f,
+	0.789063f,
+	0.414063f,
+	0.789063f,
+	0.421875f,
+	0.789063f,
+	0.429688f,
+	0.789063f,
+	0.4375f,
+	0.789063f,
+	0.445313f,
+	0.789063f,
+	0.453125f,
+	0.789063f,
+	0.460938f,
+	0.789063f,
+	0.46875f,
+	0.789063f,
+	0.476563f,
+	0.789063f,
+	0.484375f,
+	0.789063f,
+	0.492188f,
+	0.789063f,
+	0.5f,
+	0.789063f,
+	0.507813f,
+	0.789063f,
+	0.0f,
+	0.796875f,
+	0.0078125f,
+	0.796875f,
+	0.015625f,
+	0.796875f,
+	0.0234375f,
+	0.796875f,
+	0.03125f,
+	0.796875f,
+	0.0390625f,
+	0.796875f,
+	0.046875f,
+	0.796875f,
+	0.0546875f,
+	0.796875f,
+	0.0625f,
+	0.796875f,
+	0.0703125f,
+	0.796875f,
+	0.078125f,
+	0.796875f,
+	0.0859375f,
+	0.796875f,
+	0.09375f,
+	0.796875f,
+	0.101563f,
+	0.796875f,
+	0.109375f,
+	0.796875f,
+	0.117188f,
+	0.796875f,
+	0.125f,
+	0.796875f,
+	0.132813f,
+	0.796875f,
+	0.140625f,
+	0.796875f,
+	0.148438f,
+	0.796875f,
+	0.15625f,
+	0.796875f,
+	0.164063f,
+	0.796875f,
+	0.171875f,
+	0.796875f,
+	0.179688f,
+	0.796875f,
+	0.1875f,
+	0.796875f,
+	0.195313f,
+	0.796875f,
+	0.203125f,
+	0.796875f,
+	0.210938f,
+	0.796875f,
+	0.21875f,
+	0.796875f,
+	0.226563f,
+	0.796875f,
+	0.234375f,
+	0.796875f,
+	0.242188f,
+	0.796875f,
+	0.25f,
+	0.796875f,
+	0.257813f,
+	0.796875f,
+	0.265625f,
+	0.796875f,
+	0.273438f,
+	0.796875f,
+	0.28125f,
+	0.796875f,
+	0.289063f,
+	0.796875f,
+	0.296875f,
+	0.796875f,
+	0.304688f,
+	0.796875f,
+	0.3125f,
+	0.796875f,
+	0.320313f,
+	0.796875f,
+	0.328125f,
+	0.796875f,
+	0.335938f,
+	0.796875f,
+	0.34375f,
+	0.796875f,
+	0.351563f,
+	0.796875f,
+	0.359375f,
+	0.796875f,
+	0.367188f,
+	0.796875f,
+	0.375f,
+	0.796875f,
+	0.382813f,
+	0.796875f,
+	0.390625f,
+	0.796875f,
+	0.398438f,
+	0.796875f,
+	0.40625f,
+	0.796875f,
+	0.414063f,
+	0.796875f,
+	0.421875f,
+	0.796875f,
+	0.429688f,
+	0.796875f,
+	0.4375f,
+	0.796875f,
+	0.445313f,
+	0.796875f,
+	0.453125f,
+	0.796875f,
+	0.460938f,
+	0.796875f,
+	0.46875f,
+	0.796875f,
+	0.476563f,
+	0.796875f,
+	0.484375f,
+	0.796875f,
+	0.492188f,
+	0.796875f,
+	0.5f,
+	0.796875f,
+	0.507813f,
+	0.796875f,
+	0.0f,
+	0.804688f,
+	0.0078125f,
+	0.804688f,
+	0.015625f,
+	0.804688f,
+	0.0234375f,
+	0.804688f,
+	0.03125f,
+	0.804688f,
+	0.0390625f,
+	0.804688f,
+	0.046875f,
+	0.804688f,
+	0.0546875f,
+	0.804688f,
+	0.0625f,
+	0.804688f,
+	0.0703125f,
+	0.804688f,
+	0.078125f,
+	0.804688f,
+	0.0859375f,
+	0.804688f,
+	0.09375f,
+	0.804688f,
+	0.101563f,
+	0.804688f,
+	0.109375f,
+	0.804688f,
+	0.117188f,
+	0.804688f,
+	0.125f,
+	0.804688f,
+	0.132813f,
+	0.804688f,
+	0.140625f,
+	0.804688f,
+	0.148438f,
+	0.804688f,
+	0.15625f,
+	0.804688f,
+	0.164063f,
+	0.804688f,
+	0.171875f,
+	0.804688f,
+	0.179688f,
+	0.804688f,
+	0.1875f,
+	0.804688f,
+	0.195313f,
+	0.804688f,
+	0.203125f,
+	0.804688f,
+	0.210938f,
+	0.804688f,
+	0.21875f,
+	0.804688f,
+	0.226563f,
+	0.804688f,
+	0.234375f,
+	0.804688f,
+	0.242188f,
+	0.804688f,
+	0.25f,
+	0.804688f,
+	0.257813f,
+	0.804688f,
+	0.265625f,
+	0.804688f,
+	0.273438f,
+	0.804688f,
+	0.28125f,
+	0.804688f,
+	0.289063f,
+	0.804688f,
+	0.296875f,
+	0.804688f,
+	0.304688f,
+	0.804688f,
+	0.3125f,
+	0.804688f,
+	0.320313f,
+	0.804688f,
+	0.328125f,
+	0.804688f,
+	0.335938f,
+	0.804688f,
+	0.34375f,
+	0.804688f,
+	0.351563f,
+	0.804688f,
+	0.359375f,
+	0.804688f,
+	0.367188f,
+	0.804688f,
+	0.375f,
+	0.804688f,
+	0.382813f,
+	0.804688f,
+	0.390625f,
+	0.804688f,
+	0.398438f,
+	0.804688f,
+	0.40625f,
+	0.804688f,
+	0.414063f,
+	0.804688f,
+	0.421875f,
+	0.804688f,
+	0.429688f,
+	0.804688f,
+	0.4375f,
+	0.804688f,
+	0.445313f,
+	0.804688f,
+	0.453125f,
+	0.804688f,
+	0.460938f,
+	0.804688f,
+	0.46875f,
+	0.804688f,
+	0.476563f,
+	0.804688f,
+	0.484375f,
+	0.804688f,
+	0.492188f,
+	0.804688f,
+	0.5f,
+	0.804688f,
+	0.507813f,
+	0.804688f,
+	0.0f,
+	0.8125f,
+	0.0078125f,
+	0.8125f,
+	0.015625f,
+	0.8125f,
+	0.0234375f,
+	0.8125f,
+	0.03125f,
+	0.8125f,
+	0.0390625f,
+	0.8125f,
+	0.046875f,
+	0.8125f,
+	0.0546875f,
+	0.8125f,
+	0.0625f,
+	0.8125f,
+	0.0703125f,
+	0.8125f,
+	0.078125f,
+	0.8125f,
+	0.0859375f,
+	0.8125f,
+	0.09375f,
+	0.8125f,
+	0.101563f,
+	0.8125f,
+	0.109375f,
+	0.8125f,
+	0.117188f,
+	0.8125f,
+	0.125f,
+	0.8125f,
+	0.132813f,
+	0.8125f,
+	0.140625f,
+	0.8125f,
+	0.148438f,
+	0.8125f,
+	0.15625f,
+	0.8125f,
+	0.164063f,
+	0.8125f,
+	0.171875f,
+	0.8125f,
+	0.179688f,
+	0.8125f,
+	0.1875f,
+	0.8125f,
+	0.195313f,
+	0.8125f,
+	0.203125f,
+	0.8125f,
+	0.210938f,
+	0.8125f,
+	0.21875f,
+	0.8125f,
+	0.226563f,
+	0.8125f,
+	0.234375f,
+	0.8125f,
+	0.242188f,
+	0.8125f,
+	0.25f,
+	0.8125f,
+	0.257813f,
+	0.8125f,
+	0.265625f,
+	0.8125f,
+	0.273438f,
+	0.8125f,
+	0.28125f,
+	0.8125f,
+	0.289063f,
+	0.8125f,
+	0.296875f,
+	0.8125f,
+	0.304688f,
+	0.8125f,
+	0.3125f,
+	0.8125f,
+	0.320313f,
+	0.8125f,
+	0.328125f,
+	0.8125f,
+	0.335938f,
+	0.8125f,
+	0.34375f,
+	0.8125f,
+	0.351563f,
+	0.8125f,
+	0.359375f,
+	0.8125f,
+	0.367188f,
+	0.8125f,
+	0.375f,
+	0.8125f,
+	0.382813f,
+	0.8125f,
+	0.390625f,
+	0.8125f,
+	0.398438f,
+	0.8125f,
+	0.40625f,
+	0.8125f,
+	0.414063f,
+	0.8125f,
+	0.421875f,
+	0.8125f,
+	0.429688f,
+	0.8125f,
+	0.4375f,
+	0.8125f,
+	0.445313f,
+	0.8125f,
+	0.453125f,
+	0.8125f,
+	0.460938f,
+	0.8125f,
+	0.46875f,
+	0.8125f,
+	0.476563f,
+	0.8125f,
+	0.484375f,
+	0.8125f,
+	0.492188f,
+	0.8125f,
+	0.5f,
+	0.8125f,
+	0.507813f,
+	0.8125f,
+	0.0f,
+	0.820313f,
+	0.0078125f,
+	0.820313f,
+	0.015625f,
+	0.820313f,
+	0.0234375f,
+	0.820313f,
+	0.03125f,
+	0.820313f,
+	0.0390625f,
+	0.820313f,
+	0.046875f,
+	0.820313f,
+	0.0546875f,
+	0.820313f,
+	0.0625f,
+	0.820313f,
+	0.0703125f,
+	0.820313f,
+	0.078125f,
+	0.820313f,
+	0.0859375f,
+	0.820313f,
+	0.09375f,
+	0.820313f,
+	0.101563f,
+	0.820313f,
+	0.109375f,
+	0.820313f,
+	0.117188f,
+	0.820313f,
+	0.125f,
+	0.820313f,
+	0.132813f,
+	0.820313f,
+	0.140625f,
+	0.820313f,
+	0.148438f,
+	0.820313f,
+	0.15625f,
+	0.820313f,
+	0.164063f,
+	0.820313f,
+	0.171875f,
+	0.820313f,
+	0.179688f,
+	0.820313f,
+	0.1875f,
+	0.820313f,
+	0.195313f,
+	0.820313f,
+	0.203125f,
+	0.820313f,
+	0.210938f,
+	0.820313f,
+	0.21875f,
+	0.820313f,
+	0.226563f,
+	0.820313f,
+	0.234375f,
+	0.820313f,
+	0.242188f,
+	0.820313f,
+	0.25f,
+	0.820313f,
+	0.257813f,
+	0.820313f,
+	0.265625f,
+	0.820313f,
+	0.273438f,
+	0.820313f,
+	0.28125f,
+	0.820313f,
+	0.289063f,
+	0.820313f,
+	0.296875f,
+	0.820313f,
+	0.304688f,
+	0.820313f,
+	0.3125f,
+	0.820313f,
+	0.320313f,
+	0.820313f,
+	0.328125f,
+	0.820313f,
+	0.335938f,
+	0.820313f,
+	0.34375f,
+	0.820313f,
+	0.351563f,
+	0.820313f,
+	0.359375f,
+	0.820313f,
+	0.367188f,
+	0.820313f,
+	0.375f,
+	0.820313f,
+	0.382813f,
+	0.820313f,
+	0.390625f,
+	0.820313f,
+	0.398438f,
+	0.820313f,
+	0.40625f,
+	0.820313f,
+	0.414063f,
+	0.820313f,
+	0.421875f,
+	0.820313f,
+	0.429688f,
+	0.820313f,
+	0.4375f,
+	0.820313f,
+	0.445313f,
+	0.820313f,
+	0.453125f,
+	0.820313f,
+	0.460938f,
+	0.820313f,
+	0.46875f,
+	0.820313f,
+	0.476563f,
+	0.820313f,
+	0.484375f,
+	0.820313f,
+	0.492188f,
+	0.820313f,
+	0.5f,
+	0.820313f,
+	0.507813f,
+	0.820313f,
+	0.0f,
+	0.828125f,
+	0.0078125f,
+	0.828125f,
+	0.015625f,
+	0.828125f,
+	0.0234375f,
+	0.828125f,
+	0.03125f,
+	0.828125f,
+	0.0390625f,
+	0.828125f,
+	0.046875f,
+	0.828125f,
+	0.0546875f,
+	0.828125f,
+	0.0625f,
+	0.828125f,
+	0.0703125f,
+	0.828125f,
+	0.078125f,
+	0.828125f,
+	0.0859375f,
+	0.828125f,
+	0.09375f,
+	0.828125f,
+	0.101563f,
+	0.828125f,
+	0.109375f,
+	0.828125f,
+	0.117188f,
+	0.828125f,
+	0.125f,
+	0.828125f,
+	0.132813f,
+	0.828125f,
+	0.140625f,
+	0.828125f,
+	0.148438f,
+	0.828125f,
+	0.15625f,
+	0.828125f,
+	0.164063f,
+	0.828125f,
+	0.171875f,
+	0.828125f,
+	0.179688f,
+	0.828125f,
+	0.1875f,
+	0.828125f,
+	0.195313f,
+	0.828125f,
+	0.203125f,
+	0.828125f,
+	0.210938f,
+	0.828125f,
+	0.21875f,
+	0.828125f,
+	0.226563f,
+	0.828125f,
+	0.234375f,
+	0.828125f,
+	0.242188f,
+	0.828125f,
+	0.25f,
+	0.828125f,
+	0.257813f,
+	0.828125f,
+	0.265625f,
+	0.828125f,
+	0.273438f,
+	0.828125f,
+	0.28125f,
+	0.828125f,
+	0.289063f,
+	0.828125f,
+	0.296875f,
+	0.828125f,
+	0.304688f,
+	0.828125f,
+	0.3125f,
+	0.828125f,
+	0.320313f,
+	0.828125f,
+	0.328125f,
+	0.828125f,
+	0.335938f,
+	0.828125f,
+	0.34375f,
+	0.828125f,
+	0.351563f,
+	0.828125f,
+	0.359375f,
+	0.828125f,
+	0.367188f,
+	0.828125f,
+	0.375f,
+	0.828125f,
+	0.382813f,
+	0.828125f,
+	0.390625f,
+	0.828125f,
+	0.398438f,
+	0.828125f,
+	0.40625f,
+	0.828125f,
+	0.414063f,
+	0.828125f,
+	0.421875f,
+	0.828125f,
+	0.429688f,
+	0.828125f,
+	0.4375f,
+	0.828125f,
+	0.445313f,
+	0.828125f,
+	0.453125f,
+	0.828125f,
+	0.460938f,
+	0.828125f,
+	0.46875f,
+	0.828125f,
+	0.476563f,
+	0.828125f,
+	0.484375f,
+	0.828125f,
+	0.492188f,
+	0.828125f,
+	0.5f,
+	0.828125f,
+	0.507813f,
+	0.828125f,
+	0.0f,
+	0.835938f,
+	0.0078125f,
+	0.835938f,
+	0.015625f,
+	0.835938f,
+	0.0234375f,
+	0.835938f,
+	0.03125f,
+	0.835938f,
+	0.0390625f,
+	0.835938f,
+	0.046875f,
+	0.835938f,
+	0.0546875f,
+	0.835938f,
+	0.0625f,
+	0.835938f,
+	0.0703125f,
+	0.835938f,
+	0.078125f,
+	0.835938f,
+	0.0859375f,
+	0.835938f,
+	0.09375f,
+	0.835938f,
+	0.101563f,
+	0.835938f,
+	0.109375f,
+	0.835938f,
+	0.117188f,
+	0.835938f,
+	0.125f,
+	0.835938f,
+	0.132813f,
+	0.835938f,
+	0.140625f,
+	0.835938f,
+	0.148438f,
+	0.835938f,
+	0.15625f,
+	0.835938f,
+	0.164063f,
+	0.835938f,
+	0.171875f,
+	0.835938f,
+	0.179688f,
+	0.835938f,
+	0.1875f,
+	0.835938f,
+	0.195313f,
+	0.835938f,
+	0.203125f,
+	0.835938f,
+	0.210938f,
+	0.835938f,
+	0.21875f,
+	0.835938f,
+	0.226563f,
+	0.835938f,
+	0.234375f,
+	0.835938f,
+	0.242188f,
+	0.835938f,
+	0.25f,
+	0.835938f,
+	0.257813f,
+	0.835938f,
+	0.265625f,
+	0.835938f,
+	0.273438f,
+	0.835938f,
+	0.28125f,
+	0.835938f,
+	0.289063f,
+	0.835938f,
+	0.296875f,
+	0.835938f,
+	0.304688f,
+	0.835938f,
+	0.3125f,
+	0.835938f,
+	0.320313f,
+	0.835938f,
+	0.328125f,
+	0.835938f,
+	0.335938f,
+	0.835938f,
+	0.34375f,
+	0.835938f,
+	0.351563f,
+	0.835938f,
+	0.359375f,
+	0.835938f,
+	0.367188f,
+	0.835938f,
+	0.375f,
+	0.835938f,
+	0.382813f,
+	0.835938f,
+	0.390625f,
+	0.835938f,
+	0.398438f,
+	0.835938f,
+	0.40625f,
+	0.835938f,
+	0.414063f,
+	0.835938f,
+	0.421875f,
+	0.835938f,
+	0.429688f,
+	0.835938f,
+	0.4375f,
+	0.835938f,
+	0.445313f,
+	0.835938f,
+	0.453125f,
+	0.835938f,
+	0.460938f,
+	0.835938f,
+	0.46875f,
+	0.835938f,
+	0.476563f,
+	0.835938f,
+	0.484375f,
+	0.835938f,
+	0.492188f,
+	0.835938f,
+	0.5f,
+	0.835938f,
+	0.507813f,
+	0.835938f,
+	0.0f,
+	0.84375f,
+	0.0078125f,
+	0.84375f,
+	0.015625f,
+	0.84375f,
+	0.0234375f,
+	0.84375f,
+	0.03125f,
+	0.84375f,
+	0.0390625f,
+	0.84375f,
+	0.046875f,
+	0.84375f,
+	0.0546875f,
+	0.84375f,
+	0.0625f,
+	0.84375f,
+	0.0703125f,
+	0.84375f,
+	0.078125f,
+	0.84375f,
+	0.0859375f,
+	0.84375f,
+	0.09375f,
+	0.84375f,
+	0.101563f,
+	0.84375f,
+	0.109375f,
+	0.84375f,
+	0.117188f,
+	0.84375f,
+	0.125f,
+	0.84375f,
+	0.132813f,
+	0.84375f,
+	0.140625f,
+	0.84375f,
+	0.148438f,
+	0.84375f,
+	0.15625f,
+	0.84375f,
+	0.164063f,
+	0.84375f,
+	0.171875f,
+	0.84375f,
+	0.179688f,
+	0.84375f,
+	0.1875f,
+	0.84375f,
+	0.195313f,
+	0.84375f,
+	0.203125f,
+	0.84375f,
+	0.210938f,
+	0.84375f,
+	0.21875f,
+	0.84375f,
+	0.226563f,
+	0.84375f,
+	0.234375f,
+	0.84375f,
+	0.242188f,
+	0.84375f,
+	0.25f,
+	0.84375f,
+	0.257813f,
+	0.84375f,
+	0.265625f,
+	0.84375f,
+	0.273438f,
+	0.84375f,
+	0.28125f,
+	0.84375f,
+	0.289063f,
+	0.84375f,
+	0.296875f,
+	0.84375f,
+	0.304688f,
+	0.84375f,
+	0.3125f,
+	0.84375f,
+	0.320313f,
+	0.84375f,
+	0.328125f,
+	0.84375f,
+	0.335938f,
+	0.84375f,
+	0.34375f,
+	0.84375f,
+	0.351563f,
+	0.84375f,
+	0.359375f,
+	0.84375f,
+	0.367188f,
+	0.84375f,
+	0.375f,
+	0.84375f,
+	0.382813f,
+	0.84375f,
+	0.390625f,
+	0.84375f,
+	0.398438f,
+	0.84375f,
+	0.40625f,
+	0.84375f,
+	0.414063f,
+	0.84375f,
+	0.421875f,
+	0.84375f,
+	0.429688f,
+	0.84375f,
+	0.4375f,
+	0.84375f,
+	0.445313f,
+	0.84375f,
+	0.453125f,
+	0.84375f,
+	0.460938f,
+	0.84375f,
+	0.46875f,
+	0.84375f,
+	0.476563f,
+	0.84375f,
+	0.484375f,
+	0.84375f,
+	0.492188f,
+	0.84375f,
+	0.5f,
+	0.84375f,
+	0.507813f,
+	0.84375f,
+	0.0f,
+	0.851563f,
+	0.0078125f,
+	0.851563f,
+	0.015625f,
+	0.851563f,
+	0.0234375f,
+	0.851563f,
+	0.03125f,
+	0.851563f,
+	0.0390625f,
+	0.851563f,
+	0.046875f,
+	0.851563f,
+	0.0546875f,
+	0.851563f,
+	0.0625f,
+	0.851563f,
+	0.0703125f,
+	0.851563f,
+	0.078125f,
+	0.851563f,
+	0.0859375f,
+	0.851563f,
+	0.09375f,
+	0.851563f,
+	0.101563f,
+	0.851563f,
+	0.109375f,
+	0.851563f,
+	0.117188f,
+	0.851563f,
+	0.125f,
+	0.851563f,
+	0.132813f,
+	0.851563f,
+	0.140625f,
+	0.851563f,
+	0.148438f,
+	0.851563f,
+	0.15625f,
+	0.851563f,
+	0.164063f,
+	0.851563f,
+	0.171875f,
+	0.851563f,
+	0.179688f,
+	0.851563f,
+	0.1875f,
+	0.851563f,
+	0.195313f,
+	0.851563f,
+	0.203125f,
+	0.851563f,
+	0.210938f,
+	0.851563f,
+	0.21875f,
+	0.851563f,
+	0.226563f,
+	0.851563f,
+	0.234375f,
+	0.851563f,
+	0.242188f,
+	0.851563f,
+	0.25f,
+	0.851563f,
+	0.257813f,
+	0.851563f,
+	0.265625f,
+	0.851563f,
+	0.273438f,
+	0.851563f,
+	0.28125f,
+	0.851563f,
+	0.289063f,
+	0.851563f,
+	0.296875f,
+	0.851563f,
+	0.304688f,
+	0.851563f,
+	0.3125f,
+	0.851563f,
+	0.320313f,
+	0.851563f,
+	0.328125f,
+	0.851563f,
+	0.335938f,
+	0.851563f,
+	0.34375f,
+	0.851563f,
+	0.351563f,
+	0.851563f,
+	0.359375f,
+	0.851563f,
+	0.367188f,
+	0.851563f,
+	0.375f,
+	0.851563f,
+	0.382813f,
+	0.851563f,
+	0.390625f,
+	0.851563f,
+	0.398438f,
+	0.851563f,
+	0.40625f,
+	0.851563f,
+	0.414063f,
+	0.851563f,
+	0.421875f,
+	0.851563f,
+	0.429688f,
+	0.851563f,
+	0.4375f,
+	0.851563f,
+	0.445313f,
+	0.851563f,
+	0.453125f,
+	0.851563f,
+	0.460938f,
+	0.851563f,
+	0.46875f,
+	0.851563f,
+	0.476563f,
+	0.851563f,
+	0.484375f,
+	0.851563f,
+	0.492188f,
+	0.851563f,
+	0.5f,
+	0.851563f,
+	0.507813f,
+	0.851563f,
+	0.0f,
+	0.859375f,
+	0.0078125f,
+	0.859375f,
+	0.015625f,
+	0.859375f,
+	0.0234375f,
+	0.859375f,
+	0.03125f,
+	0.859375f,
+	0.0390625f,
+	0.859375f,
+	0.046875f,
+	0.859375f,
+	0.0546875f,
+	0.859375f,
+	0.0625f,
+	0.859375f,
+	0.0703125f,
+	0.859375f,
+	0.078125f,
+	0.859375f,
+	0.0859375f,
+	0.859375f,
+	0.09375f,
+	0.859375f,
+	0.101563f,
+	0.859375f,
+	0.109375f,
+	0.859375f,
+	0.117188f,
+	0.859375f,
+	0.125f,
+	0.859375f,
+	0.132813f,
+	0.859375f,
+	0.140625f,
+	0.859375f,
+	0.148438f,
+	0.859375f,
+	0.15625f,
+	0.859375f,
+	0.164063f,
+	0.859375f,
+	0.171875f,
+	0.859375f,
+	0.179688f,
+	0.859375f,
+	0.1875f,
+	0.859375f,
+	0.195313f,
+	0.859375f,
+	0.203125f,
+	0.859375f,
+	0.210938f,
+	0.859375f,
+	0.21875f,
+	0.859375f,
+	0.226563f,
+	0.859375f,
+	0.234375f,
+	0.859375f,
+	0.242188f,
+	0.859375f,
+	0.25f,
+	0.859375f,
+	0.257813f,
+	0.859375f,
+	0.265625f,
+	0.859375f,
+	0.273438f,
+	0.859375f,
+	0.28125f,
+	0.859375f,
+	0.289063f,
+	0.859375f,
+	0.296875f,
+	0.859375f,
+	0.304688f,
+	0.859375f,
+	0.3125f,
+	0.859375f,
+	0.320313f,
+	0.859375f,
+	0.328125f,
+	0.859375f,
+	0.335938f,
+	0.859375f,
+	0.34375f,
+	0.859375f,
+	0.351563f,
+	0.859375f,
+	0.359375f,
+	0.859375f,
+	0.367188f,
+	0.859375f,
+	0.375f,
+	0.859375f,
+	0.382813f,
+	0.859375f,
+	0.390625f,
+	0.859375f,
+	0.398438f,
+	0.859375f,
+	0.40625f,
+	0.859375f,
+	0.414063f,
+	0.859375f,
+	0.421875f,
+	0.859375f,
+	0.429688f,
+	0.859375f,
+	0.4375f,
+	0.859375f,
+	0.445313f,
+	0.859375f,
+	0.453125f,
+	0.859375f,
+	0.460938f,
+	0.859375f,
+	0.46875f,
+	0.859375f,
+	0.476563f,
+	0.859375f,
+	0.484375f,
+	0.859375f,
+	0.492188f,
+	0.859375f,
+	0.5f,
+	0.859375f,
+	0.507813f,
+	0.859375f,
+	0.0f,
+	0.867188f,
+	0.0078125f,
+	0.867188f,
+	0.015625f,
+	0.867188f,
+	0.0234375f,
+	0.867188f,
+	0.03125f,
+	0.867188f,
+	0.0390625f,
+	0.867188f,
+	0.046875f,
+	0.867188f,
+	0.0546875f,
+	0.867188f,
+	0.0625f,
+	0.867188f,
+	0.0703125f,
+	0.867188f,
+	0.078125f,
+	0.867188f,
+	0.0859375f,
+	0.867188f,
+	0.09375f,
+	0.867188f,
+	0.101563f,
+	0.867188f,
+	0.109375f,
+	0.867188f,
+	0.117188f,
+	0.867188f,
+	0.125f,
+	0.867188f,
+	0.132813f,
+	0.867188f,
+	0.140625f,
+	0.867188f,
+	0.148438f,
+	0.867188f,
+	0.15625f,
+	0.867188f,
+	0.164063f,
+	0.867188f,
+	0.171875f,
+	0.867188f,
+	0.179688f,
+	0.867188f,
+	0.1875f,
+	0.867188f,
+	0.195313f,
+	0.867188f,
+	0.203125f,
+	0.867188f,
+	0.210938f,
+	0.867188f,
+	0.21875f,
+	0.867188f,
+	0.226563f,
+	0.867188f,
+	0.234375f,
+	0.867188f,
+	0.242188f,
+	0.867188f,
+	0.25f,
+	0.867188f,
+	0.257813f,
+	0.867188f,
+	0.265625f,
+	0.867188f,
+	0.273438f,
+	0.867188f,
+	0.28125f,
+	0.867188f,
+	0.289063f,
+	0.867188f,
+	0.296875f,
+	0.867188f,
+	0.304688f,
+	0.867188f,
+	0.3125f,
+	0.867188f,
+	0.320313f,
+	0.867188f,
+	0.328125f,
+	0.867188f,
+	0.335938f,
+	0.867188f,
+	0.34375f,
+	0.867188f,
+	0.351563f,
+	0.867188f,
+	0.359375f,
+	0.867188f,
+	0.367188f,
+	0.867188f,
+	0.375f,
+	0.867188f,
+	0.382813f,
+	0.867188f,
+	0.390625f,
+	0.867188f,
+	0.398438f,
+	0.867188f,
+	0.40625f,
+	0.867188f,
+	0.414063f,
+	0.867188f,
+	0.421875f,
+	0.867188f,
+	0.429688f,
+	0.867188f,
+	0.4375f,
+	0.867188f,
+	0.445313f,
+	0.867188f,
+	0.453125f,
+	0.867188f,
+	0.460938f,
+	0.867188f,
+	0.46875f,
+	0.867188f,
+	0.476563f,
+	0.867188f,
+	0.484375f,
+	0.867188f,
+	0.492188f,
+	0.867188f,
+	0.5f,
+	0.867188f,
+	0.507813f,
+	0.867188f,
+	0.0f,
+	0.875f,
+	0.0078125f,
+	0.875f,
+	0.015625f,
+	0.875f,
+	0.0234375f,
+	0.875f,
+	0.03125f,
+	0.875f,
+	0.0390625f,
+	0.875f,
+	0.046875f,
+	0.875f,
+	0.0546875f,
+	0.875f,
+	0.0625f,
+	0.875f,
+	0.0703125f,
+	0.875f,
+	0.078125f,
+	0.875f,
+	0.0859375f,
+	0.875f,
+	0.09375f,
+	0.875f,
+	0.101563f,
+	0.875f,
+	0.109375f,
+	0.875f,
+	0.117188f,
+	0.875f,
+	0.125f,
+	0.875f,
+	0.132813f,
+	0.875f,
+	0.140625f,
+	0.875f,
+	0.148438f,
+	0.875f,
+	0.15625f,
+	0.875f,
+	0.164063f,
+	0.875f,
+	0.171875f,
+	0.875f,
+	0.179688f,
+	0.875f,
+	0.1875f,
+	0.875f,
+	0.195313f,
+	0.875f,
+	0.203125f,
+	0.875f,
+	0.210938f,
+	0.875f,
+	0.21875f,
+	0.875f,
+	0.226563f,
+	0.875f,
+	0.234375f,
+	0.875f,
+	0.242188f,
+	0.875f,
+	0.25f,
+	0.875f,
+	0.257813f,
+	0.875f,
+	0.265625f,
+	0.875f,
+	0.273438f,
+	0.875f,
+	0.28125f,
+	0.875f,
+	0.289063f,
+	0.875f,
+	0.296875f,
+	0.875f,
+	0.304688f,
+	0.875f,
+	0.3125f,
+	0.875f,
+	0.320313f,
+	0.875f,
+	0.328125f,
+	0.875f,
+	0.335938f,
+	0.875f,
+	0.34375f,
+	0.875f,
+	0.351563f,
+	0.875f,
+	0.359375f,
+	0.875f,
+	0.367188f,
+	0.875f,
+	0.375f,
+	0.875f,
+	0.382813f,
+	0.875f,
+	0.390625f,
+	0.875f,
+	0.398438f,
+	0.875f,
+	0.40625f,
+	0.875f,
+	0.414063f,
+	0.875f,
+	0.421875f,
+	0.875f,
+	0.429688f,
+	0.875f,
+	0.4375f,
+	0.875f,
+	0.445313f,
+	0.875f,
+	0.453125f,
+	0.875f,
+	0.460938f,
+	0.875f,
+	0.46875f,
+	0.875f,
+	0.476563f,
+	0.875f,
+	0.484375f,
+	0.875f,
+	0.492188f,
+	0.875f,
+	0.5f,
+	0.875f,
+	0.507813f,
+	0.875f,
+	0.0f,
+	0.882813f,
+	0.0078125f,
+	0.882813f,
+	0.015625f,
+	0.882813f,
+	0.0234375f,
+	0.882813f,
+	0.03125f,
+	0.882813f,
+	0.0390625f,
+	0.882813f,
+	0.046875f,
+	0.882813f,
+	0.0546875f,
+	0.882813f,
+	0.0625f,
+	0.882813f,
+	0.0703125f,
+	0.882813f,
+	0.078125f,
+	0.882813f,
+	0.0859375f,
+	0.882813f,
+	0.09375f,
+	0.882813f,
+	0.101563f,
+	0.882813f,
+	0.109375f,
+	0.882813f,
+	0.117188f,
+	0.882813f,
+	0.125f,
+	0.882813f,
+	0.132813f,
+	0.882813f,
+	0.140625f,
+	0.882813f,
+	0.148438f,
+	0.882813f,
+	0.15625f,
+	0.882813f,
+	0.164063f,
+	0.882813f,
+	0.171875f,
+	0.882813f,
+	0.179688f,
+	0.882813f,
+	0.1875f,
+	0.882813f,
+	0.195313f,
+	0.882813f,
+	0.203125f,
+	0.882813f,
+	0.210938f,
+	0.882813f,
+	0.21875f,
+	0.882813f,
+	0.226563f,
+	0.882813f,
+	0.234375f,
+	0.882813f,
+	0.242188f,
+	0.882813f,
+	0.25f,
+	0.882813f,
+	0.257813f,
+	0.882813f,
+	0.265625f,
+	0.882813f,
+	0.273438f,
+	0.882813f,
+	0.28125f,
+	0.882813f,
+	0.289063f,
+	0.882813f,
+	0.296875f,
+	0.882813f,
+	0.304688f,
+	0.882813f,
+	0.3125f,
+	0.882813f,
+	0.320313f,
+	0.882813f,
+	0.328125f,
+	0.882813f,
+	0.335938f,
+	0.882813f,
+	0.34375f,
+	0.882813f,
+	0.351563f,
+	0.882813f,
+	0.359375f,
+	0.882813f,
+	0.367188f,
+	0.882813f,
+	0.375f,
+	0.882813f,
+	0.382813f,
+	0.882813f,
+	0.390625f,
+	0.882813f,
+	0.398438f,
+	0.882813f,
+	0.40625f,
+	0.882813f,
+	0.414063f,
+	0.882813f,
+	0.421875f,
+	0.882813f,
+	0.429688f,
+	0.882813f,
+	0.4375f,
+	0.882813f,
+	0.445313f,
+	0.882813f,
+	0.453125f,
+	0.882813f,
+	0.460938f,
+	0.882813f,
+	0.46875f,
+	0.882813f,
+	0.476563f,
+	0.882813f,
+	0.484375f,
+	0.882813f,
+	0.492188f,
+	0.882813f,
+	0.5f,
+	0.882813f,
+	0.507813f,
+	0.882813f,
+	0.0f,
+	0.890625f,
+	0.0078125f,
+	0.890625f,
+	0.015625f,
+	0.890625f,
+	0.0234375f,
+	0.890625f,
+	0.03125f,
+	0.890625f,
+	0.0390625f,
+	0.890625f,
+	0.046875f,
+	0.890625f,
+	0.0546875f,
+	0.890625f,
+	0.0625f,
+	0.890625f,
+	0.0703125f,
+	0.890625f,
+	0.078125f,
+	0.890625f,
+	0.0859375f,
+	0.890625f,
+	0.09375f,
+	0.890625f,
+	0.101563f,
+	0.890625f,
+	0.109375f,
+	0.890625f,
+	0.117188f,
+	0.890625f,
+	0.125f,
+	0.890625f,
+	0.132813f,
+	0.890625f,
+	0.140625f,
+	0.890625f,
+	0.148438f,
+	0.890625f,
+	0.15625f,
+	0.890625f,
+	0.164063f,
+	0.890625f,
+	0.171875f,
+	0.890625f,
+	0.179688f,
+	0.890625f,
+	0.1875f,
+	0.890625f,
+	0.195313f,
+	0.890625f,
+	0.203125f,
+	0.890625f,
+	0.210938f,
+	0.890625f,
+	0.21875f,
+	0.890625f,
+	0.226563f,
+	0.890625f,
+	0.234375f,
+	0.890625f,
+	0.242188f,
+	0.890625f,
+	0.25f,
+	0.890625f,
+	0.257813f,
+	0.890625f,
+	0.265625f,
+	0.890625f,
+	0.273438f,
+	0.890625f,
+	0.28125f,
+	0.890625f,
+	0.289063f,
+	0.890625f,
+	0.296875f,
+	0.890625f,
+	0.304688f,
+	0.890625f,
+	0.3125f,
+	0.890625f,
+	0.320313f,
+	0.890625f,
+	0.328125f,
+	0.890625f,
+	0.335938f,
+	0.890625f,
+	0.34375f,
+	0.890625f,
+	0.351563f,
+	0.890625f,
+	0.359375f,
+	0.890625f,
+	0.367188f,
+	0.890625f,
+	0.375f,
+	0.890625f,
+	0.382813f,
+	0.890625f,
+	0.390625f,
+	0.890625f,
+	0.398438f,
+	0.890625f,
+	0.40625f,
+	0.890625f,
+	0.414063f,
+	0.890625f,
+	0.421875f,
+	0.890625f,
+	0.429688f,
+	0.890625f,
+	0.4375f,
+	0.890625f,
+	0.445313f,
+	0.890625f,
+	0.453125f,
+	0.890625f,
+	0.460938f,
+	0.890625f,
+	0.46875f,
+	0.890625f,
+	0.476563f,
+	0.890625f,
+	0.484375f,
+	0.890625f,
+	0.492188f,
+	0.890625f,
+	0.5f,
+	0.890625f,
+	0.507813f,
+	0.890625f,
+	0.0f,
+	0.898438f,
+	0.0078125f,
+	0.898438f,
+	0.015625f,
+	0.898438f,
+	0.0234375f,
+	0.898438f,
+	0.03125f,
+	0.898438f,
+	0.0390625f,
+	0.898438f,
+	0.046875f,
+	0.898438f,
+	0.0546875f,
+	0.898438f,
+	0.0625f,
+	0.898438f,
+	0.0703125f,
+	0.898438f,
+	0.078125f,
+	0.898438f,
+	0.0859375f,
+	0.898438f,
+	0.09375f,
+	0.898438f,
+	0.101563f,
+	0.898438f,
+	0.109375f,
+	0.898438f,
+	0.117188f,
+	0.898438f,
+	0.125f,
+	0.898438f,
+	0.132813f,
+	0.898438f,
+	0.140625f,
+	0.898438f,
+	0.148438f,
+	0.898438f,
+	0.15625f,
+	0.898438f,
+	0.164063f,
+	0.898438f,
+	0.171875f,
+	0.898438f,
+	0.179688f,
+	0.898438f,
+	0.1875f,
+	0.898438f,
+	0.195313f,
+	0.898438f,
+	0.203125f,
+	0.898438f,
+	0.210938f,
+	0.898438f,
+	0.21875f,
+	0.898438f,
+	0.226563f,
+	0.898438f,
+	0.234375f,
+	0.898438f,
+	0.242188f,
+	0.898438f,
+	0.25f,
+	0.898438f,
+	0.257813f,
+	0.898438f,
+	0.265625f,
+	0.898438f,
+	0.273438f,
+	0.898438f,
+	0.28125f,
+	0.898438f,
+	0.289063f,
+	0.898438f,
+	0.296875f,
+	0.898438f,
+	0.304688f,
+	0.898438f,
+	0.3125f,
+	0.898438f,
+	0.320313f,
+	0.898438f,
+	0.328125f,
+	0.898438f,
+	0.335938f,
+	0.898438f,
+	0.34375f,
+	0.898438f,
+	0.351563f,
+	0.898438f,
+	0.359375f,
+	0.898438f,
+	0.367188f,
+	0.898438f,
+	0.375f,
+	0.898438f,
+	0.382813f,
+	0.898438f,
+	0.390625f,
+	0.898438f,
+	0.398438f,
+	0.898438f,
+	0.40625f,
+	0.898438f,
+	0.414063f,
+	0.898438f,
+	0.421875f,
+	0.898438f,
+	0.429688f,
+	0.898438f,
+	0.4375f,
+	0.898438f,
+	0.445313f,
+	0.898438f,
+	0.453125f,
+	0.898438f,
+	0.460938f,
+	0.898438f,
+	0.46875f,
+	0.898438f,
+	0.476563f,
+	0.898438f,
+	0.484375f,
+	0.898438f,
+	0.492188f,
+	0.898438f,
+	0.5f,
+	0.898438f,
+	0.507813f,
+	0.898438f,
+	0.0f,
+	0.90625f,
+	0.0078125f,
+	0.90625f,
+	0.015625f,
+	0.90625f,
+	0.0234375f,
+	0.90625f,
+	0.03125f,
+	0.90625f,
+	0.0390625f,
+	0.90625f,
+	0.046875f,
+	0.90625f,
+	0.0546875f,
+	0.90625f,
+	0.0625f,
+	0.90625f,
+	0.0703125f,
+	0.90625f,
+	0.078125f,
+	0.90625f,
+	0.0859375f,
+	0.90625f,
+	0.09375f,
+	0.90625f,
+	0.101563f,
+	0.90625f,
+	0.109375f,
+	0.90625f,
+	0.117188f,
+	0.90625f,
+	0.125f,
+	0.90625f,
+	0.132813f,
+	0.90625f,
+	0.140625f,
+	0.90625f,
+	0.148438f,
+	0.90625f,
+	0.15625f,
+	0.90625f,
+	0.164063f,
+	0.90625f,
+	0.171875f,
+	0.90625f,
+	0.179688f,
+	0.90625f,
+	0.1875f,
+	0.90625f,
+	0.195313f,
+	0.90625f,
+	0.203125f,
+	0.90625f,
+	0.210938f,
+	0.90625f,
+	0.21875f,
+	0.90625f,
+	0.226563f,
+	0.90625f,
+	0.234375f,
+	0.90625f,
+	0.242188f,
+	0.90625f,
+	0.25f,
+	0.90625f,
+	0.257813f,
+	0.90625f,
+	0.265625f,
+	0.90625f,
+	0.273438f,
+	0.90625f,
+	0.28125f,
+	0.90625f,
+	0.289063f,
+	0.90625f,
+	0.296875f,
+	0.90625f,
+	0.304688f,
+	0.90625f,
+	0.3125f,
+	0.90625f,
+	0.320313f,
+	0.90625f,
+	0.328125f,
+	0.90625f,
+	0.335938f,
+	0.90625f,
+	0.34375f,
+	0.90625f,
+	0.351563f,
+	0.90625f,
+	0.359375f,
+	0.90625f,
+	0.367188f,
+	0.90625f,
+	0.375f,
+	0.90625f,
+	0.382813f,
+	0.90625f,
+	0.390625f,
+	0.90625f,
+	0.398438f,
+	0.90625f,
+	0.40625f,
+	0.90625f,
+	0.414063f,
+	0.90625f,
+	0.421875f,
+	0.90625f,
+	0.429688f,
+	0.90625f,
+	0.4375f,
+	0.90625f,
+	0.445313f,
+	0.90625f,
+	0.453125f,
+	0.90625f,
+	0.460938f,
+	0.90625f,
+	0.46875f,
+	0.90625f,
+	0.476563f,
+	0.90625f,
+	0.484375f,
+	0.90625f,
+	0.492188f,
+	0.90625f,
+	0.5f,
+	0.90625f,
+	0.507813f,
+	0.90625f,
+	0.0f,
+	0.914063f,
+	0.0078125f,
+	0.914063f,
+	0.015625f,
+	0.914063f,
+	0.0234375f,
+	0.914063f,
+	0.03125f,
+	0.914063f,
+	0.0390625f,
+	0.914063f,
+	0.046875f,
+	0.914063f,
+	0.0546875f,
+	0.914063f,
+	0.0625f,
+	0.914063f,
+	0.0703125f,
+	0.914063f,
+	0.078125f,
+	0.914063f,
+	0.0859375f,
+	0.914063f,
+	0.09375f,
+	0.914063f,
+	0.101563f,
+	0.914063f,
+	0.109375f,
+	0.914063f,
+	0.117188f,
+	0.914063f,
+	0.125f,
+	0.914063f,
+	0.132813f,
+	0.914063f,
+	0.140625f,
+	0.914063f,
+	0.148438f,
+	0.914063f,
+	0.15625f,
+	0.914063f,
+	0.164063f,
+	0.914063f,
+	0.171875f,
+	0.914063f,
+	0.179688f,
+	0.914063f,
+	0.1875f,
+	0.914063f,
+	0.195313f,
+	0.914063f,
+	0.203125f,
+	0.914063f,
+	0.210938f,
+	0.914063f,
+	0.21875f,
+	0.914063f,
+	0.226563f,
+	0.914063f,
+	0.234375f,
+	0.914063f,
+	0.242188f,
+	0.914063f,
+	0.25f,
+	0.914063f,
+	0.257813f,
+	0.914063f,
+	0.265625f,
+	0.914063f,
+	0.273438f,
+	0.914063f,
+	0.28125f,
+	0.914063f,
+	0.289063f,
+	0.914063f,
+	0.296875f,
+	0.914063f,
+	0.304688f,
+	0.914063f,
+	0.3125f,
+	0.914063f,
+	0.320313f,
+	0.914063f,
+	0.328125f,
+	0.914063f,
+	0.335938f,
+	0.914063f,
+	0.34375f,
+	0.914063f,
+	0.351563f,
+	0.914063f,
+	0.359375f,
+	0.914063f,
+	0.367188f,
+	0.914063f,
+	0.375f,
+	0.914063f,
+	0.382813f,
+	0.914063f,
+	0.390625f,
+	0.914063f,
+	0.398438f,
+	0.914063f,
+	0.40625f,
+	0.914063f,
+	0.414063f,
+	0.914063f,
+	0.421875f,
+	0.914063f,
+	0.429688f,
+	0.914063f,
+	0.4375f,
+	0.914063f,
+	0.445313f,
+	0.914063f,
+	0.453125f,
+	0.914063f,
+	0.460938f,
+	0.914063f,
+	0.46875f,
+	0.914063f,
+	0.476563f,
+	0.914063f,
+	0.484375f,
+	0.914063f,
+	0.492188f,
+	0.914063f,
+	0.5f,
+	0.914063f,
+	0.507813f,
+	0.914063f,
+	0.0f,
+	0.921875f,
+	0.0078125f,
+	0.921875f,
+	0.015625f,
+	0.921875f,
+	0.0234375f,
+	0.921875f,
+	0.03125f,
+	0.921875f,
+	0.0390625f,
+	0.921875f,
+	0.046875f,
+	0.921875f,
+	0.0546875f,
+	0.921875f,
+	0.0625f,
+	0.921875f,
+	0.0703125f,
+	0.921875f,
+	0.078125f,
+	0.921875f,
+	0.0859375f,
+	0.921875f,
+	0.09375f,
+	0.921875f,
+	0.101563f,
+	0.921875f,
+	0.109375f,
+	0.921875f,
+	0.117188f,
+	0.921875f,
+	0.125f,
+	0.921875f,
+	0.132813f,
+	0.921875f,
+	0.140625f,
+	0.921875f,
+	0.148438f,
+	0.921875f,
+	0.15625f,
+	0.921875f,
+	0.164063f,
+	0.921875f,
+	0.171875f,
+	0.921875f,
+	0.179688f,
+	0.921875f,
+	0.1875f,
+	0.921875f,
+	0.195313f,
+	0.921875f,
+	0.203125f,
+	0.921875f,
+	0.210938f,
+	0.921875f,
+	0.21875f,
+	0.921875f,
+	0.226563f,
+	0.921875f,
+	0.234375f,
+	0.921875f,
+	0.242188f,
+	0.921875f,
+	0.25f,
+	0.921875f,
+	0.257813f,
+	0.921875f,
+	0.265625f,
+	0.921875f,
+	0.273438f,
+	0.921875f,
+	0.28125f,
+	0.921875f,
+	0.289063f,
+	0.921875f,
+	0.296875f,
+	0.921875f,
+	0.304688f,
+	0.921875f,
+	0.3125f,
+	0.921875f,
+	0.320313f,
+	0.921875f,
+	0.328125f,
+	0.921875f,
+	0.335938f,
+	0.921875f,
+	0.34375f,
+	0.921875f,
+	0.351563f,
+	0.921875f,
+	0.359375f,
+	0.921875f,
+	0.367188f,
+	0.921875f,
+	0.375f,
+	0.921875f,
+	0.382813f,
+	0.921875f,
+	0.390625f,
+	0.921875f,
+	0.398438f,
+	0.921875f,
+	0.40625f,
+	0.921875f,
+	0.414063f,
+	0.921875f,
+	0.421875f,
+	0.921875f,
+	0.429688f,
+	0.921875f,
+	0.4375f,
+	0.921875f,
+	0.445313f,
+	0.921875f,
+	0.453125f,
+	0.921875f,
+	0.460938f,
+	0.921875f,
+	0.46875f,
+	0.921875f,
+	0.476563f,
+	0.921875f,
+	0.484375f,
+	0.921875f,
+	0.492188f,
+	0.921875f,
+	0.5f,
+	0.921875f,
+	0.507813f,
+	0.921875f,
+	0.0f,
+	0.929688f,
+	0.0078125f,
+	0.929688f,
+	0.015625f,
+	0.929688f,
+	0.0234375f,
+	0.929688f,
+	0.03125f,
+	0.929688f,
+	0.0390625f,
+	0.929688f,
+	0.046875f,
+	0.929688f,
+	0.0546875f,
+	0.929688f,
+	0.0625f,
+	0.929688f,
+	0.0703125f,
+	0.929688f,
+	0.078125f,
+	0.929688f,
+	0.0859375f,
+	0.929688f,
+	0.09375f,
+	0.929688f,
+	0.101563f,
+	0.929688f,
+	0.109375f,
+	0.929688f,
+	0.117188f,
+	0.929688f,
+	0.125f,
+	0.929688f,
+	0.132813f,
+	0.929688f,
+	0.140625f,
+	0.929688f,
+	0.148438f,
+	0.929688f,
+	0.15625f,
+	0.929688f,
+	0.164063f,
+	0.929688f,
+	0.171875f,
+	0.929688f,
+	0.179688f,
+	0.929688f,
+	0.1875f,
+	0.929688f,
+	0.195313f,
+	0.929688f,
+	0.203125f,
+	0.929688f,
+	0.210938f,
+	0.929688f,
+	0.21875f,
+	0.929688f,
+	0.226563f,
+	0.929688f,
+	0.234375f,
+	0.929688f,
+	0.242188f,
+	0.929688f,
+	0.25f,
+	0.929688f,
+	0.257813f,
+	0.929688f,
+	0.265625f,
+	0.929688f,
+	0.273438f,
+	0.929688f,
+	0.28125f,
+	0.929688f,
+	0.289063f,
+	0.929688f,
+	0.296875f,
+	0.929688f,
+	0.304688f,
+	0.929688f,
+	0.3125f,
+	0.929688f,
+	0.320313f,
+	0.929688f,
+	0.328125f,
+	0.929688f,
+	0.335938f,
+	0.929688f,
+	0.34375f,
+	0.929688f,
+	0.351563f,
+	0.929688f,
+	0.359375f,
+	0.929688f,
+	0.367188f,
+	0.929688f,
+	0.375f,
+	0.929688f,
+	0.382813f,
+	0.929688f,
+	0.390625f,
+	0.929688f,
+	0.398438f,
+	0.929688f,
+	0.40625f,
+	0.929688f,
+	0.414063f,
+	0.929688f,
+	0.421875f,
+	0.929688f,
+	0.429688f,
+	0.929688f,
+	0.4375f,
+	0.929688f,
+	0.445313f,
+	0.929688f,
+	0.453125f,
+	0.929688f,
+	0.460938f,
+	0.929688f,
+	0.46875f,
+	0.929688f,
+	0.476563f,
+	0.929688f,
+	0.484375f,
+	0.929688f,
+	0.492188f,
+	0.929688f,
+	0.5f,
+	0.929688f,
+	0.507813f,
+	0.929688f,
+	0.0f,
+	0.9375f,
+	0.0078125f,
+	0.9375f,
+	0.015625f,
+	0.9375f,
+	0.0234375f,
+	0.9375f,
+	0.03125f,
+	0.9375f,
+	0.0390625f,
+	0.9375f,
+	0.046875f,
+	0.9375f,
+	0.0546875f,
+	0.9375f,
+	0.0625f,
+	0.9375f,
+	0.0703125f,
+	0.9375f,
+	0.078125f,
+	0.9375f,
+	0.0859375f,
+	0.9375f,
+	0.09375f,
+	0.9375f,
+	0.101563f,
+	0.9375f,
+	0.109375f,
+	0.9375f,
+	0.117188f,
+	0.9375f,
+	0.125f,
+	0.9375f,
+	0.132813f,
+	0.9375f,
+	0.140625f,
+	0.9375f,
+	0.148438f,
+	0.9375f,
+	0.15625f,
+	0.9375f,
+	0.164063f,
+	0.9375f,
+	0.171875f,
+	0.9375f,
+	0.179688f,
+	0.9375f,
+	0.1875f,
+	0.9375f,
+	0.195313f,
+	0.9375f,
+	0.203125f,
+	0.9375f,
+	0.210938f,
+	0.9375f,
+	0.21875f,
+	0.9375f,
+	0.226563f,
+	0.9375f,
+	0.234375f,
+	0.9375f,
+	0.242188f,
+	0.9375f,
+	0.25f,
+	0.9375f,
+	0.257813f,
+	0.9375f,
+	0.265625f,
+	0.9375f,
+	0.273438f,
+	0.9375f,
+	0.28125f,
+	0.9375f,
+	0.289063f,
+	0.9375f,
+	0.296875f,
+	0.9375f,
+	0.304688f,
+	0.9375f,
+	0.3125f,
+	0.9375f,
+	0.320313f,
+	0.9375f,
+	0.328125f,
+	0.9375f,
+	0.335938f,
+	0.9375f,
+	0.34375f,
+	0.9375f,
+	0.351563f,
+	0.9375f,
+	0.359375f,
+	0.9375f,
+	0.367188f,
+	0.9375f,
+	0.375f,
+	0.9375f,
+	0.382813f,
+	0.9375f,
+	0.390625f,
+	0.9375f,
+	0.398438f,
+	0.9375f,
+	0.40625f,
+	0.9375f,
+	0.414063f,
+	0.9375f,
+	0.421875f,
+	0.9375f,
+	0.429688f,
+	0.9375f,
+	0.4375f,
+	0.9375f,
+	0.445313f,
+	0.9375f,
+	0.453125f,
+	0.9375f,
+	0.460938f,
+	0.9375f,
+	0.46875f,
+	0.9375f,
+	0.476563f,
+	0.9375f,
+	0.484375f,
+	0.9375f,
+	0.492188f,
+	0.9375f,
+	0.5f,
+	0.9375f,
+	0.507813f,
+	0.9375f,
+	0.0f,
+	0.945313f,
+	0.0078125f,
+	0.945313f,
+	0.015625f,
+	0.945313f,
+	0.0234375f,
+	0.945313f,
+	0.03125f,
+	0.945313f,
+	0.0390625f,
+	0.945313f,
+	0.046875f,
+	0.945313f,
+	0.0546875f,
+	0.945313f,
+	0.0625f,
+	0.945313f,
+	0.0703125f,
+	0.945313f,
+	0.078125f,
+	0.945313f,
+	0.0859375f,
+	0.945313f,
+	0.09375f,
+	0.945313f,
+	0.101563f,
+	0.945313f,
+	0.109375f,
+	0.945313f,
+	0.117188f,
+	0.945313f,
+	0.125f,
+	0.945313f,
+	0.132813f,
+	0.945313f,
+	0.140625f,
+	0.945313f,
+	0.148438f,
+	0.945313f,
+	0.15625f,
+	0.945313f,
+	0.164063f,
+	0.945313f,
+	0.171875f,
+	0.945313f,
+	0.179688f,
+	0.945313f,
+	0.1875f,
+	0.945313f,
+	0.195313f,
+	0.945313f,
+	0.203125f,
+	0.945313f,
+	0.210938f,
+	0.945313f,
+	0.21875f,
+	0.945313f,
+	0.226563f,
+	0.945313f,
+	0.234375f,
+	0.945313f,
+	0.242188f,
+	0.945313f,
+	0.25f,
+	0.945313f,
+	0.257813f,
+	0.945313f,
+	0.265625f,
+	0.945313f,
+	0.273438f,
+	0.945313f,
+	0.28125f,
+	0.945313f,
+	0.289063f,
+	0.945313f,
+	0.296875f,
+	0.945313f,
+	0.304688f,
+	0.945313f,
+	0.3125f,
+	0.945313f,
+	0.320313f,
+	0.945313f,
+	0.328125f,
+	0.945313f,
+	0.335938f,
+	0.945313f,
+	0.34375f,
+	0.945313f,
+	0.351563f,
+	0.945313f,
+	0.359375f,
+	0.945313f,
+	0.367188f,
+	0.945313f,
+	0.375f,
+	0.945313f,
+	0.382813f,
+	0.945313f,
+	0.390625f,
+	0.945313f,
+	0.398438f,
+	0.945313f,
+	0.40625f,
+	0.945313f,
+	0.414063f,
+	0.945313f,
+	0.421875f,
+	0.945313f,
+	0.429688f,
+	0.945313f,
+	0.4375f,
+	0.945313f,
+	0.445313f,
+	0.945313f,
+	0.453125f,
+	0.945313f,
+	0.460938f,
+	0.945313f,
+	0.46875f,
+	0.945313f,
+	0.476563f,
+	0.945313f,
+	0.484375f,
+	0.945313f,
+	0.492188f,
+	0.945313f,
+	0.5f,
+	0.945313f,
+	0.507813f,
+	0.945313f,
+	0.0f,
+	0.953125f,
+	0.0078125f,
+	0.953125f,
+	0.015625f,
+	0.953125f,
+	0.0234375f,
+	0.953125f,
+	0.03125f,
+	0.953125f,
+	0.0390625f,
+	0.953125f,
+	0.046875f,
+	0.953125f,
+	0.0546875f,
+	0.953125f,
+	0.0625f,
+	0.953125f,
+	0.0703125f,
+	0.953125f,
+	0.078125f,
+	0.953125f,
+	0.0859375f,
+	0.953125f,
+	0.09375f,
+	0.953125f,
+	0.101563f,
+	0.953125f,
+	0.109375f,
+	0.953125f,
+	0.117188f,
+	0.953125f,
+	0.125f,
+	0.953125f,
+	0.132813f,
+	0.953125f,
+	0.140625f,
+	0.953125f,
+	0.148438f,
+	0.953125f,
+	0.15625f,
+	0.953125f,
+	0.164063f,
+	0.953125f,
+	0.171875f,
+	0.953125f,
+	0.179688f,
+	0.953125f,
+	0.1875f,
+	0.953125f,
+	0.195313f,
+	0.953125f,
+	0.203125f,
+	0.953125f,
+	0.210938f,
+	0.953125f,
+	0.21875f,
+	0.953125f,
+	0.226563f,
+	0.953125f,
+	0.234375f,
+	0.953125f,
+	0.242188f,
+	0.953125f,
+	0.25f,
+	0.953125f,
+	0.257813f,
+	0.953125f,
+	0.265625f,
+	0.953125f,
+	0.273438f,
+	0.953125f,
+	0.28125f,
+	0.953125f,
+	0.289063f,
+	0.953125f,
+	0.296875f,
+	0.953125f,
+	0.304688f,
+	0.953125f,
+	0.3125f,
+	0.953125f,
+	0.320313f,
+	0.953125f,
+	0.328125f,
+	0.953125f,
+	0.335938f,
+	0.953125f,
+	0.34375f,
+	0.953125f,
+	0.351563f,
+	0.953125f,
+	0.359375f,
+	0.953125f,
+	0.367188f,
+	0.953125f,
+	0.375f,
+	0.953125f,
+	0.382813f,
+	0.953125f,
+	0.390625f,
+	0.953125f,
+	0.398438f,
+	0.953125f,
+	0.40625f,
+	0.953125f,
+	0.414063f,
+	0.953125f,
+	0.421875f,
+	0.953125f,
+	0.429688f,
+	0.953125f,
+	0.4375f,
+	0.953125f,
+	0.445313f,
+	0.953125f,
+	0.453125f,
+	0.953125f,
+	0.460938f,
+	0.953125f,
+	0.46875f,
+	0.953125f,
+	0.476563f,
+	0.953125f,
+	0.484375f,
+	0.953125f,
+	0.492188f,
+	0.953125f,
+	0.5f,
+	0.953125f,
+	0.507813f,
+	0.953125f,
+	0.0f,
+	0.960938f,
+	0.0078125f,
+	0.960938f,
+	0.015625f,
+	0.960938f,
+	0.0234375f,
+	0.960938f,
+	0.03125f,
+	0.960938f,
+	0.0390625f,
+	0.960938f,
+	0.046875f,
+	0.960938f,
+	0.0546875f,
+	0.960938f,
+	0.0625f,
+	0.960938f,
+	0.0703125f,
+	0.960938f,
+	0.078125f,
+	0.960938f,
+	0.0859375f,
+	0.960938f,
+	0.09375f,
+	0.960938f,
+	0.101563f,
+	0.960938f,
+	0.109375f,
+	0.960938f,
+	0.117188f,
+	0.960938f,
+	0.125f,
+	0.960938f,
+	0.132813f,
+	0.960938f,
+	0.140625f,
+	0.960938f,
+	0.148438f,
+	0.960938f,
+	0.15625f,
+	0.960938f,
+	0.164063f,
+	0.960938f,
+	0.171875f,
+	0.960938f,
+	0.179688f,
+	0.960938f,
+	0.1875f,
+	0.960938f,
+	0.195313f,
+	0.960938f,
+	0.203125f,
+	0.960938f,
+	0.210938f,
+	0.960938f,
+	0.21875f,
+	0.960938f,
+	0.226563f,
+	0.960938f,
+	0.234375f,
+	0.960938f,
+	0.242188f,
+	0.960938f,
+	0.25f,
+	0.960938f,
+	0.257813f,
+	0.960938f,
+	0.265625f,
+	0.960938f,
+	0.273438f,
+	0.960938f,
+	0.28125f,
+	0.960938f,
+	0.289063f,
+	0.960938f,
+	0.296875f,
+	0.960938f,
+	0.304688f,
+	0.960938f,
+	0.3125f,
+	0.960938f,
+	0.320313f,
+	0.960938f,
+	0.328125f,
+	0.960938f,
+	0.335938f,
+	0.960938f,
+	0.34375f,
+	0.960938f,
+	0.351563f,
+	0.960938f,
+	0.359375f,
+	0.960938f,
+	0.367188f,
+	0.960938f,
+	0.375f,
+	0.960938f,
+	0.382813f,
+	0.960938f,
+	0.390625f,
+	0.960938f,
+	0.398438f,
+	0.960938f,
+	0.40625f,
+	0.960938f,
+	0.414063f,
+	0.960938f,
+	0.421875f,
+	0.960938f,
+	0.429688f,
+	0.960938f,
+	0.4375f,
+	0.960938f,
+	0.445313f,
+	0.960938f,
+	0.453125f,
+	0.960938f,
+	0.460938f,
+	0.960938f,
+	0.46875f,
+	0.960938f,
+	0.476563f,
+	0.960938f,
+	0.484375f,
+	0.960938f,
+	0.492188f,
+	0.960938f,
+	0.5f,
+	0.960938f,
+	0.507813f,
+	0.960938f,
+	0.0f,
+	0.96875f,
+	0.0078125f,
+	0.96875f,
+	0.015625f,
+	0.96875f,
+	0.0234375f,
+	0.96875f,
+	0.03125f,
+	0.96875f,
+	0.0390625f,
+	0.96875f,
+	0.046875f,
+	0.96875f,
+	0.0546875f,
+	0.96875f,
+	0.0625f,
+	0.96875f,
+	0.0703125f,
+	0.96875f,
+	0.078125f,
+	0.96875f,
+	0.0859375f,
+	0.96875f,
+	0.09375f,
+	0.96875f,
+	0.101563f,
+	0.96875f,
+	0.109375f,
+	0.96875f,
+	0.117188f,
+	0.96875f,
+	0.125f,
+	0.96875f,
+	0.132813f,
+	0.96875f,
+	0.140625f,
+	0.96875f,
+	0.148438f,
+	0.96875f,
+	0.15625f,
+	0.96875f,
+	0.164063f,
+	0.96875f,
+	0.171875f,
+	0.96875f,
+	0.179688f,
+	0.96875f,
+	0.1875f,
+	0.96875f,
+	0.195313f,
+	0.96875f,
+	0.203125f,
+	0.96875f,
+	0.210938f,
+	0.96875f,
+	0.21875f,
+	0.96875f,
+	0.226563f,
+	0.96875f,
+	0.234375f,
+	0.96875f,
+	0.242188f,
+	0.96875f,
+	0.25f,
+	0.96875f,
+	0.257813f,
+	0.96875f,
+	0.265625f,
+	0.96875f,
+	0.273438f,
+	0.96875f,
+	0.28125f,
+	0.96875f,
+	0.289063f,
+	0.96875f,
+	0.296875f,
+	0.96875f,
+	0.304688f,
+	0.96875f,
+	0.3125f,
+	0.96875f,
+	0.320313f,
+	0.96875f,
+	0.328125f,
+	0.96875f,
+	0.335938f,
+	0.96875f,
+	0.34375f,
+	0.96875f,
+	0.351563f,
+	0.96875f,
+	0.359375f,
+	0.96875f,
+	0.367188f,
+	0.96875f,
+	0.375f,
+	0.96875f,
+	0.382813f,
+	0.96875f,
+	0.390625f,
+	0.96875f,
+	0.398438f,
+	0.96875f,
+	0.40625f,
+	0.96875f,
+	0.414063f,
+	0.96875f,
+	0.421875f,
+	0.96875f,
+	0.429688f,
+	0.96875f,
+	0.4375f,
+	0.96875f,
+	0.445313f,
+	0.96875f,
+	0.453125f,
+	0.96875f,
+	0.460938f,
+	0.96875f,
+	0.46875f,
+	0.96875f,
+	0.476563f,
+	0.96875f,
+	0.484375f,
+	0.96875f,
+	0.492188f,
+	0.96875f,
+	0.5f,
+	0.96875f,
+	0.507813f,
+	0.96875f,
+	0.0f,
+	0.976563f,
+	0.0078125f,
+	0.976563f,
+	0.015625f,
+	0.976563f,
+	0.0234375f,
+	0.976563f,
+	0.03125f,
+	0.976563f,
+	0.0390625f,
+	0.976563f,
+	0.046875f,
+	0.976563f,
+	0.0546875f,
+	0.976563f,
+	0.0625f,
+	0.976563f,
+	0.0703125f,
+	0.976563f,
+	0.078125f,
+	0.976563f,
+	0.0859375f,
+	0.976563f,
+	0.09375f,
+	0.976563f,
+	0.101563f,
+	0.976563f,
+	0.109375f,
+	0.976563f,
+	0.117188f,
+	0.976563f,
+	0.125f,
+	0.976563f,
+	0.132813f,
+	0.976563f,
+	0.140625f,
+	0.976563f,
+	0.148438f,
+	0.976563f,
+	0.15625f,
+	0.976563f,
+	0.164063f,
+	0.976563f,
+	0.171875f,
+	0.976563f,
+	0.179688f,
+	0.976563f,
+	0.1875f,
+	0.976563f,
+	0.195313f,
+	0.976563f,
+	0.203125f,
+	0.976563f,
+	0.210938f,
+	0.976563f,
+	0.21875f,
+	0.976563f,
+	0.226563f,
+	0.976563f,
+	0.234375f,
+	0.976563f,
+	0.242188f,
+	0.976563f,
+	0.25f,
+	0.976563f,
+	0.257813f,
+	0.976563f,
+	0.265625f,
+	0.976563f,
+	0.273438f,
+	0.976563f,
+	0.28125f,
+	0.976563f,
+	0.289063f,
+	0.976563f,
+	0.296875f,
+	0.976563f,
+	0.304688f,
+	0.976563f,
+	0.3125f,
+	0.976563f,
+	0.320313f,
+	0.976563f,
+	0.328125f,
+	0.976563f,
+	0.335938f,
+	0.976563f,
+	0.34375f,
+	0.976563f,
+	0.351563f,
+	0.976563f,
+	0.359375f,
+	0.976563f,
+	0.367188f,
+	0.976563f,
+	0.375f,
+	0.976563f,
+	0.382813f,
+	0.976563f,
+	0.390625f,
+	0.976563f,
+	0.398438f,
+	0.976563f,
+	0.40625f,
+	0.976563f,
+	0.414063f,
+	0.976563f,
+	0.421875f,
+	0.976563f,
+	0.429688f,
+	0.976563f,
+	0.4375f,
+	0.976563f,
+	0.445313f,
+	0.976563f,
+	0.453125f,
+	0.976563f,
+	0.460938f,
+	0.976563f,
+	0.46875f,
+	0.976563f,
+	0.476563f,
+	0.976563f,
+	0.484375f,
+	0.976563f,
+	0.492188f,
+	0.976563f,
+	0.5f,
+	0.976563f,
+	0.507813f,
+	0.976563f,
+	0.0f,
+	0.984375f,
+	0.0078125f,
+	0.984375f,
+	0.015625f,
+	0.984375f,
+	0.0234375f,
+	0.984375f,
+	0.03125f,
+	0.984375f,
+	0.0390625f,
+	0.984375f,
+	0.046875f,
+	0.984375f,
+	0.0546875f,
+	0.984375f,
+	0.0625f,
+	0.984375f,
+	0.0703125f,
+	0.984375f,
+	0.078125f,
+	0.984375f,
+	0.0859375f,
+	0.984375f,
+	0.09375f,
+	0.984375f,
+	0.101563f,
+	0.984375f,
+	0.109375f,
+	0.984375f,
+	0.117188f,
+	0.984375f,
+	0.125f,
+	0.984375f,
+	0.132813f,
+	0.984375f,
+	0.140625f,
+	0.984375f,
+	0.148438f,
+	0.984375f,
+	0.15625f,
+	0.984375f,
+	0.164063f,
+	0.984375f,
+	0.171875f,
+	0.984375f,
+	0.179688f,
+	0.984375f,
+	0.1875f,
+	0.984375f,
+	0.195313f,
+	0.984375f,
+	0.203125f,
+	0.984375f,
+	0.210938f,
+	0.984375f,
+	0.21875f,
+	0.984375f,
+	0.226563f,
+	0.984375f,
+	0.234375f,
+	0.984375f,
+	0.242188f,
+	0.984375f,
+	0.25f,
+	0.984375f,
+	0.257813f,
+	0.984375f,
+	0.265625f,
+	0.984375f,
+	0.273438f,
+	0.984375f,
+	0.28125f,
+	0.984375f,
+	0.289063f,
+	0.984375f,
+	0.296875f,
+	0.984375f,
+	0.304688f,
+	0.984375f,
+	0.3125f,
+	0.984375f,
+	0.320313f,
+	0.984375f,
+	0.328125f,
+	0.984375f,
+	0.335938f,
+	0.984375f,
+	0.34375f,
+	0.984375f,
+	0.351563f,
+	0.984375f,
+	0.359375f,
+	0.984375f,
+	0.367188f,
+	0.984375f,
+	0.375f,
+	0.984375f,
+	0.382813f,
+	0.984375f,
+	0.390625f,
+	0.984375f,
+	0.398438f,
+	0.984375f,
+	0.40625f,
+	0.984375f,
+	0.414063f,
+	0.984375f,
+	0.421875f,
+	0.984375f,
+	0.429688f,
+	0.984375f,
+	0.4375f,
+	0.984375f,
+	0.445313f,
+	0.984375f,
+	0.453125f,
+	0.984375f,
+	0.460938f,
+	0.984375f,
+	0.46875f,
+	0.984375f,
+	0.476563f,
+	0.984375f,
+	0.484375f,
+	0.984375f,
+	0.492188f,
+	0.984375f,
+	0.5f,
+	0.984375f,
+	0.507813f,
+	0.984375f,
+	0.0f,
+	0.992188f,
+	0.0078125f,
+	0.992188f,
+	0.015625f,
+	0.992188f,
+	0.0234375f,
+	0.992188f,
+	0.03125f,
+	0.992188f,
+	0.0390625f,
+	0.992188f,
+	0.046875f,
+	0.992188f,
+	0.0546875f,
+	0.992188f,
+	0.0625f,
+	0.992188f,
+	0.0703125f,
+	0.992188f,
+	0.078125f,
+	0.992188f,
+	0.0859375f,
+	0.992188f,
+	0.09375f,
+	0.992188f,
+	0.101563f,
+	0.992188f,
+	0.109375f,
+	0.992188f,
+	0.117188f,
+	0.992188f,
+	0.125f,
+	0.992188f,
+	0.132813f,
+	0.992188f,
+	0.140625f,
+	0.992188f,
+	0.148438f,
+	0.992188f,
+	0.15625f,
+	0.992188f,
+	0.164063f,
+	0.992188f,
+	0.171875f,
+	0.992188f,
+	0.179688f,
+	0.992188f,
+	0.1875f,
+	0.992188f,
+	0.195313f,
+	0.992188f,
+	0.203125f,
+	0.992188f,
+	0.210938f,
+	0.992188f,
+	0.21875f,
+	0.992188f,
+	0.226563f,
+	0.992188f,
+	0.234375f,
+	0.992188f,
+	0.242188f,
+	0.992188f,
+	0.25f,
+	0.992188f,
+	0.257813f,
+	0.992188f,
+	0.265625f,
+	0.992188f,
+	0.273438f,
+	0.992188f,
+	0.28125f,
+	0.992188f,
+	0.289063f,
+	0.992188f,
+	0.296875f,
+	0.992188f,
+	0.304688f,
+	0.992188f,
+	0.3125f,
+	0.992188f,
+	0.320313f,
+	0.992188f,
+	0.328125f,
+	0.992188f,
+	0.335938f,
+	0.992188f,
+	0.34375f,
+	0.992188f,
+	0.351563f,
+	0.992188f,
+	0.359375f,
+	0.992188f,
+	0.367188f,
+	0.992188f,
+	0.375f,
+	0.992188f,
+	0.382813f,
+	0.992188f,
+	0.390625f,
+	0.992188f,
+	0.398438f,
+	0.992188f,
+	0.40625f,
+	0.992188f,
+	0.414063f,
+	0.992188f,
+	0.421875f,
+	0.992188f,
+	0.429688f,
+	0.992188f,
+	0.4375f,
+	0.992188f,
+	0.445313f,
+	0.992188f,
+	0.453125f,
+	0.992188f,
+	0.460938f,
+	0.992188f,
+	0.46875f,
+	0.992188f,
+	0.476563f,
+	0.992188f,
+	0.484375f,
+	0.992188f,
+	0.492188f,
+	0.992188f,
+	0.5f,
+	0.992188f,
+	0.507813f,
+	0.992188f,
+	0.0f,
+	1.0f,
+	0.0078125f,
+	1.0f,
+	0.015625f,
+	1.0f,
+	0.0234375f,
+	1.0f,
+	0.03125f,
+	1.0f,
+	0.0390625f,
+	1.0f,
+	0.046875f,
+	1.0f,
+	0.0546875f,
+	1.0f,
+	0.0625f,
+	1.0f,
+	0.0703125f,
+	1.0f,
+	0.078125f,
+	1.0f,
+	0.0859375f,
+	1.0f,
+	0.09375f,
+	1.0f,
+	0.101563f,
+	1.0f,
+	0.109375f,
+	1.0f,
+	0.117188f,
+	1.0f,
+	0.125f,
+	1.0f,
+	0.132813f,
+	1.0f,
+	0.140625f,
+	1.0f,
+	0.148438f,
+	1.0f,
+	0.15625f,
+	1.0f,
+	0.164063f,
+	1.0f,
+	0.171875f,
+	1.0f,
+	0.179688f,
+	1.0f,
+	0.1875f,
+	1.0f,
+	0.195313f,
+	1.0f,
+	0.203125f,
+	1.0f,
+	0.210938f,
+	1.0f,
+	0.21875f,
+	1.0f,
+	0.226563f,
+	1.0f,
+	0.234375f,
+	1.0f,
+	0.242188f,
+	1.0f,
+	0.25f,
+	1.0f,
+	0.257813f,
+	1.0f,
+	0.265625f,
+	1.0f,
+	0.273438f,
+	1.0f,
+	0.28125f,
+	1.0f,
+	0.289063f,
+	1.0f,
+	0.296875f,
+	1.0f,
+	0.304688f,
+	1.0f,
+	0.3125f,
+	1.0f,
+	0.320313f,
+	1.0f,
+	0.328125f,
+	1.0f,
+	0.335938f,
+	1.0f,
+	0.34375f,
+	1.0f,
+	0.351563f,
+	1.0f,
+	0.359375f,
+	1.0f,
+	0.367188f,
+	1.0f,
+	0.375f,
+	1.0f,
+	0.382813f,
+	1.0f,
+	0.390625f,
+	1.0f,
+	0.398438f,
+	1.0f,
+	0.40625f,
+	1.0f,
+	0.414063f,
+	1.0f,
+	0.421875f,
+	1.0f,
+	0.429688f,
+	1.0f,
+	0.4375f,
+	1.0f,
+	0.445313f,
+	1.0f,
+	0.453125f,
+	1.0f,
+	0.460938f,
+	1.0f,
+	0.46875f,
+	1.0f,
+	0.476563f,
+	1.0f,
+	0.484375f,
+	1.0f,
+	0.492188f,
+	1.0f,
+	0.5f,
+	1.0f,
+	0.507813f,
+	1.0f,
+};
+
+unsigned short Landscape08Idx[] = {
+	0,
+	1,
+	2,
+	3,
+	2,
+	1,
+	2,
+	3,
+	4,
+	5,
+	4,
+	3,
+	4,
+	5,
+	6,
+	7,
+	6,
+	5,
+	6,
+	7,
+	8,
+	9,
+	8,
+	7,
+	8,
+	9,
+	10,
+	11,
+	10,
+	9,
+	10,
+	11,
+	12,
+	13,
+	12,
+	11,
+	12,
+	13,
+	14,
+	15,
+	14,
+	13,
+	14,
+	15,
+	16,
+	17,
+	16,
+	15,
+	16,
+	17,
+	18,
+	19,
+	18,
+	17,
+	18,
+	19,
+	20,
+	21,
+	20,
+	19,
+	20,
+	21,
+	22,
+	23,
+	22,
+	21,
+	22,
+	23,
+	24,
+	25,
+	24,
+	23,
+	24,
+	25,
+	26,
+	27,
+	26,
+	25,
+	26,
+	27,
+	28,
+	29,
+	28,
+	27,
+	28,
+	29,
+	30,
+	31,
+	30,
+	29,
+	30,
+	31,
+	32,
+	33,
+	32,
+	31,
+	32,
+	33,
+	34,
+	35,
+	34,
+	33,
+	34,
+	35,
+	36,
+	37,
+	36,
+	35,
+	36,
+	37,
+	38,
+	39,
+	38,
+	37,
+	38,
+	39,
+	40,
+	41,
+	40,
+	39,
+	40,
+	41,
+	42,
+	43,
+	42,
+	41,
+	42,
+	43,
+	44,
+	45,
+	44,
+	43,
+	44,
+	45,
+	46,
+	47,
+	46,
+	45,
+	46,
+	47,
+	48,
+	49,
+	48,
+	47,
+	48,
+	49,
+	50,
+	51,
+	50,
+	49,
+	50,
+	51,
+	52,
+	53,
+	52,
+	51,
+	52,
+	53,
+	54,
+	55,
+	54,
+	53,
+	54,
+	55,
+	56,
+	57,
+	56,
+	55,
+	56,
+	57,
+	58,
+	59,
+	58,
+	57,
+	58,
+	59,
+	60,
+	61,
+	60,
+	59,
+	60,
+	61,
+	62,
+	63,
+	62,
+	61,
+	62,
+	63,
+	64,
+	65,
+	64,
+	63,
+	64,
+	65,
+	66,
+	67,
+	66,
+	65,
+	66,
+	67,
+	68,
+	69,
+	68,
+	67,
+	68,
+	69,
+	70,
+	71,
+	70,
+	69,
+	70,
+	71,
+	72,
+	73,
+	72,
+	71,
+	72,
+	73,
+	74,
+	75,
+	74,
+	73,
+	74,
+	75,
+	76,
+	77,
+	76,
+	75,
+	76,
+	77,
+	78,
+	79,
+	78,
+	77,
+	78,
+	79,
+	80,
+	81,
+	80,
+	79,
+	80,
+	81,
+	82,
+	83,
+	82,
+	81,
+	82,
+	83,
+	84,
+	85,
+	84,
+	83,
+	84,
+	85,
+	86,
+	87,
+	86,
+	85,
+	86,
+	87,
+	88,
+	89,
+	88,
+	87,
+	88,
+	89,
+	90,
+	91,
+	90,
+	89,
+	90,
+	91,
+	92,
+	93,
+	92,
+	91,
+	92,
+	93,
+	94,
+	95,
+	94,
+	93,
+	94,
+	95,
+	96,
+	97,
+	96,
+	95,
+	96,
+	97,
+	98,
+	99,
+	98,
+	97,
+	98,
+	99,
+	100,
+	101,
+	100,
+	99,
+	100,
+	101,
+	102,
+	103,
+	102,
+	101,
+	102,
+	103,
+	104,
+	105,
+	104,
+	103,
+	104,
+	105,
+	106,
+	107,
+	106,
+	105,
+	106,
+	107,
+	108,
+	109,
+	108,
+	107,
+	108,
+	109,
+	110,
+	111,
+	110,
+	109,
+	110,
+	111,
+	112,
+	113,
+	112,
+	111,
+	112,
+	113,
+	114,
+	115,
+	114,
+	113,
+	114,
+	115,
+	116,
+	117,
+	116,
+	115,
+	116,
+	117,
+	118,
+	119,
+	118,
+	117,
+	118,
+	119,
+	120,
+	121,
+	120,
+	119,
+	120,
+	121,
+	122,
+	123,
+	122,
+	121,
+	122,
+	123,
+	124,
+	125,
+	124,
+	123,
+	124,
+	125,
+	126,
+	127,
+	126,
+	125,
+	126,
+	127,
+	128,
+	129,
+	128,
+	127,
+	128,
+	129,
+	130,
+	131,
+	130,
+	129,
+	132,
+	0,
+	133,
+	2,
+	133,
+	0,
+	133,
+	2,
+	134,
+	4,
+	134,
+	2,
+	134,
+	4,
+	135,
+	6,
+	135,
+	4,
+	135,
+	6,
+	136,
+	8,
+	136,
+	6,
+	136,
+	8,
+	137,
+	10,
+	137,
+	8,
+	137,
+	10,
+	138,
+	12,
+	138,
+	10,
+	138,
+	12,
+	139,
+	14,
+	139,
+	12,
+	139,
+	14,
+	140,
+	16,
+	140,
+	14,
+	140,
+	16,
+	141,
+	18,
+	141,
+	16,
+	141,
+	18,
+	142,
+	20,
+	142,
+	18,
+	142,
+	20,
+	143,
+	22,
+	143,
+	20,
+	143,
+	22,
+	144,
+	24,
+	144,
+	22,
+	144,
+	24,
+	145,
+	26,
+	145,
+	24,
+	145,
+	26,
+	146,
+	28,
+	146,
+	26,
+	146,
+	28,
+	147,
+	30,
+	147,
+	28,
+	147,
+	30,
+	148,
+	32,
+	148,
+	30,
+	148,
+	32,
+	149,
+	34,
+	149,
+	32,
+	149,
+	34,
+	150,
+	36,
+	150,
+	34,
+	150,
+	36,
+	151,
+	38,
+	151,
+	36,
+	151,
+	38,
+	152,
+	40,
+	152,
+	38,
+	152,
+	40,
+	153,
+	42,
+	153,
+	40,
+	153,
+	42,
+	154,
+	44,
+	154,
+	42,
+	154,
+	44,
+	155,
+	46,
+	155,
+	44,
+	155,
+	46,
+	156,
+	48,
+	156,
+	46,
+	156,
+	48,
+	157,
+	50,
+	157,
+	48,
+	157,
+	50,
+	158,
+	52,
+	158,
+	50,
+	158,
+	52,
+	159,
+	54,
+	159,
+	52,
+	159,
+	54,
+	160,
+	56,
+	160,
+	54,
+	160,
+	56,
+	161,
+	58,
+	161,
+	56,
+	161,
+	58,
+	162,
+	60,
+	162,
+	58,
+	162,
+	60,
+	163,
+	62,
+	163,
+	60,
+	163,
+	62,
+	164,
+	64,
+	164,
+	62,
+	164,
+	64,
+	165,
+	66,
+	165,
+	64,
+	165,
+	66,
+	166,
+	68,
+	166,
+	66,
+	166,
+	68,
+	167,
+	70,
+	167,
+	68,
+	167,
+	70,
+	168,
+	72,
+	168,
+	70,
+	168,
+	72,
+	169,
+	74,
+	169,
+	72,
+	169,
+	74,
+	170,
+	76,
+	170,
+	74,
+	170,
+	76,
+	171,
+	78,
+	171,
+	76,
+	171,
+	78,
+	172,
+	80,
+	172,
+	78,
+	172,
+	80,
+	173,
+	82,
+	173,
+	80,
+	173,
+	82,
+	174,
+	84,
+	174,
+	82,
+	174,
+	84,
+	175,
+	86,
+	175,
+	84,
+	175,
+	86,
+	176,
+	88,
+	176,
+	86,
+	176,
+	88,
+	177,
+	90,
+	177,
+	88,
+	177,
+	90,
+	178,
+	92,
+	178,
+	90,
+	178,
+	92,
+	179,
+	94,
+	179,
+	92,
+	179,
+	94,
+	180,
+	96,
+	180,
+	94,
+	180,
+	96,
+	181,
+	98,
+	181,
+	96,
+	181,
+	98,
+	182,
+	100,
+	182,
+	98,
+	182,
+	100,
+	183,
+	102,
+	183,
+	100,
+	183,
+	102,
+	184,
+	104,
+	184,
+	102,
+	184,
+	104,
+	185,
+	106,
+	185,
+	104,
+	185,
+	106,
+	186,
+	108,
+	186,
+	106,
+	186,
+	108,
+	187,
+	110,
+	187,
+	108,
+	187,
+	110,
+	188,
+	112,
+	188,
+	110,
+	188,
+	112,
+	189,
+	114,
+	189,
+	112,
+	189,
+	114,
+	190,
+	116,
+	190,
+	114,
+	190,
+	116,
+	191,
+	118,
+	191,
+	116,
+	191,
+	118,
+	192,
+	120,
+	192,
+	118,
+	192,
+	120,
+	193,
+	122,
+	193,
+	120,
+	193,
+	122,
+	194,
+	124,
+	194,
+	122,
+	194,
+	124,
+	195,
+	126,
+	195,
+	124,
+	195,
+	126,
+	196,
+	128,
+	196,
+	126,
+	196,
+	128,
+	197,
+	130,
+	197,
+	128,
+	198,
+	132,
+	199,
+	133,
+	199,
+	132,
+	199,
+	133,
+	200,
+	134,
+	200,
+	133,
+	200,
+	134,
+	201,
+	135,
+	201,
+	134,
+	201,
+	135,
+	202,
+	136,
+	202,
+	135,
+	202,
+	136,
+	203,
+	137,
+	203,
+	136,
+	203,
+	137,
+	204,
+	138,
+	204,
+	137,
+	204,
+	138,
+	205,
+	139,
+	205,
+	138,
+	205,
+	139,
+	206,
+	140,
+	206,
+	139,
+	206,
+	140,
+	207,
+	141,
+	207,
+	140,
+	207,
+	141,
+	208,
+	142,
+	208,
+	141,
+	208,
+	142,
+	209,
+	143,
+	209,
+	142,
+	209,
+	143,
+	210,
+	144,
+	210,
+	143,
+	210,
+	144,
+	211,
+	145,
+	211,
+	144,
+	211,
+	145,
+	212,
+	146,
+	212,
+	145,
+	212,
+	146,
+	213,
+	147,
+	213,
+	146,
+	213,
+	147,
+	214,
+	148,
+	214,
+	147,
+	214,
+	148,
+	215,
+	149,
+	215,
+	148,
+	215,
+	149,
+	216,
+	150,
+	216,
+	149,
+	216,
+	150,
+	217,
+	151,
+	217,
+	150,
+	217,
+	151,
+	218,
+	152,
+	218,
+	151,
+	218,
+	152,
+	219,
+	153,
+	219,
+	152,
+	219,
+	153,
+	220,
+	154,
+	220,
+	153,
+	220,
+	154,
+	221,
+	155,
+	221,
+	154,
+	221,
+	155,
+	222,
+	156,
+	222,
+	155,
+	222,
+	156,
+	223,
+	157,
+	223,
+	156,
+	223,
+	157,
+	224,
+	158,
+	224,
+	157,
+	224,
+	158,
+	225,
+	159,
+	225,
+	158,
+	225,
+	159,
+	226,
+	160,
+	226,
+	159,
+	226,
+	160,
+	227,
+	161,
+	227,
+	160,
+	227,
+	161,
+	228,
+	162,
+	228,
+	161,
+	228,
+	162,
+	229,
+	163,
+	229,
+	162,
+	229,
+	163,
+	230,
+	164,
+	230,
+	163,
+	230,
+	164,
+	231,
+	165,
+	231,
+	164,
+	231,
+	165,
+	232,
+	166,
+	232,
+	165,
+	232,
+	166,
+	233,
+	167,
+	233,
+	166,
+	233,
+	167,
+	234,
+	168,
+	234,
+	167,
+	234,
+	168,
+	235,
+	169,
+	235,
+	168,
+	235,
+	169,
+	236,
+	170,
+	236,
+	169,
+	236,
+	170,
+	237,
+	171,
+	237,
+	170,
+	237,
+	171,
+	238,
+	172,
+	238,
+	171,
+	238,
+	172,
+	239,
+	173,
+	239,
+	172,
+	239,
+	173,
+	240,
+	174,
+	240,
+	173,
+	240,
+	174,
+	241,
+	175,
+	241,
+	174,
+	241,
+	175,
+	242,
+	176,
+	242,
+	175,
+	242,
+	176,
+	243,
+	177,
+	243,
+	176,
+	243,
+	177,
+	244,
+	178,
+	244,
+	177,
+	244,
+	178,
+	245,
+	179,
+	245,
+	178,
+	245,
+	179,
+	246,
+	180,
+	246,
+	179,
+	246,
+	180,
+	247,
+	181,
+	247,
+	180,
+	247,
+	181,
+	248,
+	182,
+	248,
+	181,
+	248,
+	182,
+	249,
+	183,
+	249,
+	182,
+	249,
+	183,
+	250,
+	184,
+	250,
+	183,
+	250,
+	184,
+	251,
+	185,
+	251,
+	184,
+	251,
+	185,
+	252,
+	186,
+	252,
+	185,
+	252,
+	186,
+	253,
+	187,
+	253,
+	186,
+	253,
+	187,
+	254,
+	188,
+	254,
+	187,
+	254,
+	188,
+	255,
+	189,
+	255,
+	188,
+	255,
+	189,
+	256,
+	190,
+	256,
+	189,
+	256,
+	190,
+	257,
+	191,
+	257,
+	190,
+	257,
+	191,
+	258,
+	192,
+	258,
+	191,
+	258,
+	192,
+	259,
+	193,
+	259,
+	192,
+	259,
+	193,
+	260,
+	194,
+	260,
+	193,
+	260,
+	194,
+	261,
+	195,
+	261,
+	194,
+	261,
+	195,
+	262,
+	196,
+	262,
+	195,
+	262,
+	196,
+	263,
+	197,
+	263,
+	196,
+	264,
+	198,
+	265,
+	199,
+	265,
+	198,
+	265,
+	199,
+	266,
+	200,
+	266,
+	199,
+	266,
+	200,
+	267,
+	201,
+	267,
+	200,
+	267,
+	201,
+	268,
+	202,
+	268,
+	201,
+	268,
+	202,
+	269,
+	203,
+	269,
+	202,
+	269,
+	203,
+	270,
+	204,
+	270,
+	203,
+	270,
+	204,
+	271,
+	205,
+	271,
+	204,
+	271,
+	205,
+	272,
+	206,
+	272,
+	205,
+	272,
+	206,
+	273,
+	207,
+	273,
+	206,
+	273,
+	207,
+	274,
+	208,
+	274,
+	207,
+	274,
+	208,
+	275,
+	209,
+	275,
+	208,
+	275,
+	209,
+	276,
+	210,
+	276,
+	209,
+	276,
+	210,
+	277,
+	211,
+	277,
+	210,
+	277,
+	211,
+	278,
+	212,
+	278,
+	211,
+	278,
+	212,
+	279,
+	213,
+	279,
+	212,
+	279,
+	213,
+	280,
+	214,
+	280,
+	213,
+	280,
+	214,
+	281,
+	215,
+	281,
+	214,
+	281,
+	215,
+	282,
+	216,
+	282,
+	215,
+	282,
+	216,
+	283,
+	217,
+	283,
+	216,
+	283,
+	217,
+	284,
+	218,
+	284,
+	217,
+	284,
+	218,
+	285,
+	219,
+	285,
+	218,
+	285,
+	219,
+	286,
+	220,
+	286,
+	219,
+	286,
+	220,
+	287,
+	221,
+	287,
+	220,
+	287,
+	221,
+	288,
+	222,
+	288,
+	221,
+	288,
+	222,
+	289,
+	223,
+	289,
+	222,
+	289,
+	223,
+	290,
+	224,
+	290,
+	223,
+	290,
+	224,
+	291,
+	225,
+	291,
+	224,
+	291,
+	225,
+	292,
+	226,
+	292,
+	225,
+	292,
+	226,
+	293,
+	227,
+	293,
+	226,
+	293,
+	227,
+	294,
+	228,
+	294,
+	227,
+	294,
+	228,
+	295,
+	229,
+	295,
+	228,
+	295,
+	229,
+	296,
+	230,
+	296,
+	229,
+	296,
+	230,
+	297,
+	231,
+	297,
+	230,
+	297,
+	231,
+	298,
+	232,
+	298,
+	231,
+	298,
+	232,
+	299,
+	233,
+	299,
+	232,
+	299,
+	233,
+	300,
+	234,
+	300,
+	233,
+	300,
+	234,
+	301,
+	235,
+	301,
+	234,
+	301,
+	235,
+	302,
+	236,
+	302,
+	235,
+	302,
+	236,
+	303,
+	237,
+	303,
+	236,
+	303,
+	237,
+	304,
+	238,
+	304,
+	237,
+	304,
+	238,
+	305,
+	239,
+	305,
+	238,
+	305,
+	239,
+	306,
+	240,
+	306,
+	239,
+	306,
+	240,
+	307,
+	241,
+	307,
+	240,
+	307,
+	241,
+	308,
+	242,
+	308,
+	241,
+	308,
+	242,
+	309,
+	243,
+	309,
+	242,
+	309,
+	243,
+	310,
+	244,
+	310,
+	243,
+	310,
+	244,
+	311,
+	245,
+	311,
+	244,
+	311,
+	245,
+	312,
+	246,
+	312,
+	245,
+	312,
+	246,
+	313,
+	247,
+	313,
+	246,
+	313,
+	247,
+	314,
+	248,
+	314,
+	247,
+	314,
+	248,
+	315,
+	249,
+	315,
+	248,
+	315,
+	249,
+	316,
+	250,
+	316,
+	249,
+	316,
+	250,
+	317,
+	251,
+	317,
+	250,
+	317,
+	251,
+	318,
+	252,
+	318,
+	251,
+	318,
+	252,
+	319,
+	253,
+	319,
+	252,
+	319,
+	253,
+	320,
+	254,
+	320,
+	253,
+	320,
+	254,
+	321,
+	255,
+	321,
+	254,
+	321,
+	255,
+	322,
+	256,
+	322,
+	255,
+	322,
+	256,
+	323,
+	257,
+	323,
+	256,
+	323,
+	257,
+	324,
+	258,
+	324,
+	257,
+	324,
+	258,
+	325,
+	259,
+	325,
+	258,
+	325,
+	259,
+	326,
+	260,
+	326,
+	259,
+	326,
+	260,
+	327,
+	261,
+	327,
+	260,
+	327,
+	261,
+	328,
+	262,
+	328,
+	261,
+	328,
+	262,
+	329,
+	263,
+	329,
+	262,
+	330,
+	264,
+	331,
+	265,
+	331,
+	264,
+	331,
+	265,
+	332,
+	266,
+	332,
+	265,
+	332,
+	266,
+	333,
+	267,
+	333,
+	266,
+	333,
+	267,
+	334,
+	268,
+	334,
+	267,
+	334,
+	268,
+	335,
+	269,
+	335,
+	268,
+	335,
+	269,
+	336,
+	270,
+	336,
+	269,
+	336,
+	270,
+	337,
+	271,
+	337,
+	270,
+	337,
+	271,
+	338,
+	272,
+	338,
+	271,
+	338,
+	272,
+	339,
+	273,
+	339,
+	272,
+	339,
+	273,
+	340,
+	274,
+	340,
+	273,
+	340,
+	274,
+	341,
+	275,
+	341,
+	274,
+	341,
+	275,
+	342,
+	276,
+	342,
+	275,
+	342,
+	276,
+	343,
+	277,
+	343,
+	276,
+	343,
+	277,
+	344,
+	278,
+	344,
+	277,
+	344,
+	278,
+	345,
+	279,
+	345,
+	278,
+	345,
+	279,
+	346,
+	280,
+	346,
+	279,
+	346,
+	280,
+	347,
+	281,
+	347,
+	280,
+	347,
+	281,
+	348,
+	282,
+	348,
+	281,
+	348,
+	282,
+	349,
+	283,
+	349,
+	282,
+	349,
+	283,
+	350,
+	284,
+	350,
+	283,
+	350,
+	284,
+	351,
+	285,
+	351,
+	284,
+	351,
+	285,
+	352,
+	286,
+	352,
+	285,
+	352,
+	286,
+	353,
+	287,
+	353,
+	286,
+	353,
+	287,
+	354,
+	288,
+	354,
+	287,
+	354,
+	288,
+	355,
+	289,
+	355,
+	288,
+	355,
+	289,
+	356,
+	290,
+	356,
+	289,
+	356,
+	290,
+	357,
+	291,
+	357,
+	290,
+	357,
+	291,
+	358,
+	292,
+	358,
+	291,
+	358,
+	292,
+	359,
+	293,
+	359,
+	292,
+	359,
+	293,
+	360,
+	294,
+	360,
+	293,
+	360,
+	294,
+	361,
+	295,
+	361,
+	294,
+	361,
+	295,
+	362,
+	296,
+	362,
+	295,
+	362,
+	296,
+	363,
+	297,
+	363,
+	296,
+	363,
+	297,
+	364,
+	298,
+	364,
+	297,
+	364,
+	298,
+	365,
+	299,
+	365,
+	298,
+	365,
+	299,
+	366,
+	300,
+	366,
+	299,
+	366,
+	300,
+	367,
+	301,
+	367,
+	300,
+	367,
+	301,
+	368,
+	302,
+	368,
+	301,
+	368,
+	302,
+	369,
+	303,
+	369,
+	302,
+	369,
+	303,
+	370,
+	304,
+	370,
+	303,
+	370,
+	304,
+	371,
+	305,
+	371,
+	304,
+	371,
+	305,
+	372,
+	306,
+	372,
+	305,
+	372,
+	306,
+	373,
+	307,
+	373,
+	306,
+	373,
+	307,
+	374,
+	308,
+	374,
+	307,
+	374,
+	308,
+	375,
+	309,
+	375,
+	308,
+	375,
+	309,
+	376,
+	310,
+	376,
+	309,
+	376,
+	310,
+	377,
+	311,
+	377,
+	310,
+	377,
+	311,
+	378,
+	312,
+	378,
+	311,
+	378,
+	312,
+	379,
+	313,
+	379,
+	312,
+	379,
+	313,
+	380,
+	314,
+	380,
+	313,
+	380,
+	314,
+	381,
+	315,
+	381,
+	314,
+	381,
+	315,
+	382,
+	316,
+	382,
+	315,
+	382,
+	316,
+	383,
+	317,
+	383,
+	316,
+	383,
+	317,
+	384,
+	318,
+	384,
+	317,
+	384,
+	318,
+	385,
+	319,
+	385,
+	318,
+	385,
+	319,
+	386,
+	320,
+	386,
+	319,
+	386,
+	320,
+	387,
+	321,
+	387,
+	320,
+	387,
+	321,
+	388,
+	322,
+	388,
+	321,
+	388,
+	322,
+	389,
+	323,
+	389,
+	322,
+	389,
+	323,
+	390,
+	324,
+	390,
+	323,
+	390,
+	324,
+	391,
+	325,
+	391,
+	324,
+	391,
+	325,
+	392,
+	326,
+	392,
+	325,
+	392,
+	326,
+	393,
+	327,
+	393,
+	326,
+	393,
+	327,
+	394,
+	328,
+	394,
+	327,
+	394,
+	328,
+	395,
+	329,
+	395,
+	328,
+	396,
+	330,
+	397,
+	331,
+	397,
+	330,
+	397,
+	331,
+	398,
+	332,
+	398,
+	331,
+	398,
+	332,
+	399,
+	333,
+	399,
+	332,
+	399,
+	333,
+	400,
+	334,
+	400,
+	333,
+	400,
+	334,
+	401,
+	335,
+	401,
+	334,
+	401,
+	335,
+	402,
+	336,
+	402,
+	335,
+	402,
+	336,
+	403,
+	337,
+	403,
+	336,
+	403,
+	337,
+	404,
+	338,
+	404,
+	337,
+	404,
+	338,
+	405,
+	339,
+	405,
+	338,
+	405,
+	339,
+	406,
+	340,
+	406,
+	339,
+	406,
+	340,
+	407,
+	341,
+	407,
+	340,
+	407,
+	341,
+	408,
+	342,
+	408,
+	341,
+	408,
+	342,
+	409,
+	343,
+	409,
+	342,
+	409,
+	343,
+	410,
+	344,
+	410,
+	343,
+	410,
+	344,
+	411,
+	345,
+	411,
+	344,
+	411,
+	345,
+	412,
+	346,
+	412,
+	345,
+	412,
+	346,
+	413,
+	347,
+	413,
+	346,
+	413,
+	347,
+	414,
+	348,
+	414,
+	347,
+	414,
+	348,
+	415,
+	349,
+	415,
+	348,
+	415,
+	349,
+	416,
+	350,
+	416,
+	349,
+	416,
+	350,
+	417,
+	351,
+	417,
+	350,
+	417,
+	351,
+	418,
+	352,
+	418,
+	351,
+	418,
+	352,
+	419,
+	353,
+	419,
+	352,
+	419,
+	353,
+	420,
+	354,
+	420,
+	353,
+	420,
+	354,
+	421,
+	355,
+	421,
+	354,
+	421,
+	355,
+	422,
+	356,
+	422,
+	355,
+	422,
+	356,
+	423,
+	357,
+	423,
+	356,
+	423,
+	357,
+	424,
+	358,
+	424,
+	357,
+	424,
+	358,
+	425,
+	359,
+	425,
+	358,
+	425,
+	359,
+	426,
+	360,
+	426,
+	359,
+	426,
+	360,
+	427,
+	361,
+	427,
+	360,
+	427,
+	361,
+	428,
+	362,
+	428,
+	361,
+	428,
+	362,
+	429,
+	363,
+	429,
+	362,
+	429,
+	363,
+	430,
+	364,
+	430,
+	363,
+	430,
+	364,
+	431,
+	365,
+	431,
+	364,
+	431,
+	365,
+	432,
+	366,
+	432,
+	365,
+	432,
+	366,
+	433,
+	367,
+	433,
+	366,
+	433,
+	367,
+	434,
+	368,
+	434,
+	367,
+	434,
+	368,
+	435,
+	369,
+	435,
+	368,
+	435,
+	369,
+	436,
+	370,
+	436,
+	369,
+	436,
+	370,
+	437,
+	371,
+	437,
+	370,
+	437,
+	371,
+	438,
+	372,
+	438,
+	371,
+	438,
+	372,
+	439,
+	373,
+	439,
+	372,
+	439,
+	373,
+	440,
+	374,
+	440,
+	373,
+	440,
+	374,
+	441,
+	375,
+	441,
+	374,
+	441,
+	375,
+	442,
+	376,
+	442,
+	375,
+	442,
+	376,
+	443,
+	377,
+	443,
+	376,
+	443,
+	377,
+	444,
+	378,
+	444,
+	377,
+	444,
+	378,
+	445,
+	379,
+	445,
+	378,
+	445,
+	379,
+	446,
+	380,
+	446,
+	379,
+	446,
+	380,
+	447,
+	381,
+	447,
+	380,
+	447,
+	381,
+	448,
+	382,
+	448,
+	381,
+	448,
+	382,
+	449,
+	383,
+	449,
+	382,
+	449,
+	383,
+	450,
+	384,
+	450,
+	383,
+	450,
+	384,
+	451,
+	385,
+	451,
+	384,
+	451,
+	385,
+	452,
+	386,
+	452,
+	385,
+	452,
+	386,
+	453,
+	387,
+	453,
+	386,
+	453,
+	387,
+	454,
+	388,
+	454,
+	387,
+	454,
+	388,
+	455,
+	389,
+	455,
+	388,
+	455,
+	389,
+	456,
+	390,
+	456,
+	389,
+	456,
+	390,
+	457,
+	391,
+	457,
+	390,
+	457,
+	391,
+	458,
+	392,
+	458,
+	391,
+	458,
+	392,
+	459,
+	393,
+	459,
+	392,
+	459,
+	393,
+	460,
+	394,
+	460,
+	393,
+	460,
+	394,
+	461,
+	395,
+	461,
+	394,
+	462,
+	396,
+	463,
+	397,
+	463,
+	396,
+	463,
+	397,
+	464,
+	398,
+	464,
+	397,
+	464,
+	398,
+	465,
+	399,
+	465,
+	398,
+	465,
+	399,
+	466,
+	400,
+	466,
+	399,
+	466,
+	400,
+	467,
+	401,
+	467,
+	400,
+	467,
+	401,
+	468,
+	402,
+	468,
+	401,
+	468,
+	402,
+	469,
+	403,
+	469,
+	402,
+	469,
+	403,
+	470,
+	404,
+	470,
+	403,
+	470,
+	404,
+	471,
+	405,
+	471,
+	404,
+	471,
+	405,
+	472,
+	406,
+	472,
+	405,
+	472,
+	406,
+	473,
+	407,
+	473,
+	406,
+	473,
+	407,
+	474,
+	408,
+	474,
+	407,
+	474,
+	408,
+	475,
+	409,
+	475,
+	408,
+	475,
+	409,
+	476,
+	410,
+	476,
+	409,
+	476,
+	410,
+	477,
+	411,
+	477,
+	410,
+	477,
+	411,
+	478,
+	412,
+	478,
+	411,
+	478,
+	412,
+	479,
+	413,
+	479,
+	412,
+	479,
+	413,
+	480,
+	414,
+	480,
+	413,
+	480,
+	414,
+	481,
+	415,
+	481,
+	414,
+	481,
+	415,
+	482,
+	416,
+	482,
+	415,
+	482,
+	416,
+	483,
+	417,
+	483,
+	416,
+	483,
+	417,
+	484,
+	418,
+	484,
+	417,
+	484,
+	418,
+	485,
+	419,
+	485,
+	418,
+	485,
+	419,
+	486,
+	420,
+	486,
+	419,
+	486,
+	420,
+	487,
+	421,
+	487,
+	420,
+	487,
+	421,
+	488,
+	422,
+	488,
+	421,
+	488,
+	422,
+	489,
+	423,
+	489,
+	422,
+	489,
+	423,
+	490,
+	424,
+	490,
+	423,
+	490,
+	424,
+	491,
+	425,
+	491,
+	424,
+	491,
+	425,
+	492,
+	426,
+	492,
+	425,
+	492,
+	426,
+	493,
+	427,
+	493,
+	426,
+	493,
+	427,
+	494,
+	428,
+	494,
+	427,
+	494,
+	428,
+	495,
+	429,
+	495,
+	428,
+	495,
+	429,
+	496,
+	430,
+	496,
+	429,
+	496,
+	430,
+	497,
+	431,
+	497,
+	430,
+	497,
+	431,
+	498,
+	432,
+	498,
+	431,
+	498,
+	432,
+	499,
+	433,
+	499,
+	432,
+	499,
+	433,
+	500,
+	434,
+	500,
+	433,
+	500,
+	434,
+	501,
+	435,
+	501,
+	434,
+	501,
+	435,
+	502,
+	436,
+	502,
+	435,
+	502,
+	436,
+	503,
+	437,
+	503,
+	436,
+	503,
+	437,
+	504,
+	438,
+	504,
+	437,
+	504,
+	438,
+	505,
+	439,
+	505,
+	438,
+	505,
+	439,
+	506,
+	440,
+	506,
+	439,
+	506,
+	440,
+	507,
+	441,
+	507,
+	440,
+	507,
+	441,
+	508,
+	442,
+	508,
+	441,
+	508,
+	442,
+	509,
+	443,
+	509,
+	442,
+	509,
+	443,
+	510,
+	444,
+	510,
+	443,
+	510,
+	444,
+	511,
+	445,
+	511,
+	444,
+	511,
+	445,
+	512,
+	446,
+	512,
+	445,
+	512,
+	446,
+	513,
+	447,
+	513,
+	446,
+	513,
+	447,
+	514,
+	448,
+	514,
+	447,
+	514,
+	448,
+	515,
+	449,
+	515,
+	448,
+	515,
+	449,
+	516,
+	450,
+	516,
+	449,
+	516,
+	450,
+	517,
+	451,
+	517,
+	450,
+	517,
+	451,
+	518,
+	452,
+	518,
+	451,
+	518,
+	452,
+	519,
+	453,
+	519,
+	452,
+	519,
+	453,
+	520,
+	454,
+	520,
+	453,
+	520,
+	454,
+	521,
+	455,
+	521,
+	454,
+	521,
+	455,
+	522,
+	456,
+	522,
+	455,
+	522,
+	456,
+	523,
+	457,
+	523,
+	456,
+	523,
+	457,
+	524,
+	458,
+	524,
+	457,
+	524,
+	458,
+	525,
+	459,
+	525,
+	458,
+	525,
+	459,
+	526,
+	460,
+	526,
+	459,
+	526,
+	460,
+	527,
+	461,
+	527,
+	460,
+	528,
+	462,
+	529,
+	463,
+	529,
+	462,
+	529,
+	463,
+	530,
+	464,
+	530,
+	463,
+	530,
+	464,
+	531,
+	465,
+	531,
+	464,
+	531,
+	465,
+	532,
+	466,
+	532,
+	465,
+	532,
+	466,
+	533,
+	467,
+	533,
+	466,
+	533,
+	467,
+	534,
+	468,
+	534,
+	467,
+	534,
+	468,
+	535,
+	469,
+	535,
+	468,
+	535,
+	469,
+	536,
+	470,
+	536,
+	469,
+	536,
+	470,
+	537,
+	471,
+	537,
+	470,
+	537,
+	471,
+	538,
+	472,
+	538,
+	471,
+	538,
+	472,
+	539,
+	473,
+	539,
+	472,
+	539,
+	473,
+	540,
+	474,
+	540,
+	473,
+	540,
+	474,
+	541,
+	475,
+	541,
+	474,
+	541,
+	475,
+	542,
+	476,
+	542,
+	475,
+	542,
+	476,
+	543,
+	477,
+	543,
+	476,
+	543,
+	477,
+	544,
+	478,
+	544,
+	477,
+	544,
+	478,
+	545,
+	479,
+	545,
+	478,
+	545,
+	479,
+	546,
+	480,
+	546,
+	479,
+	546,
+	480,
+	547,
+	481,
+	547,
+	480,
+	547,
+	481,
+	548,
+	482,
+	548,
+	481,
+	548,
+	482,
+	549,
+	483,
+	549,
+	482,
+	549,
+	483,
+	550,
+	484,
+	550,
+	483,
+	550,
+	484,
+	551,
+	485,
+	551,
+	484,
+	551,
+	485,
+	552,
+	486,
+	552,
+	485,
+	552,
+	486,
+	553,
+	487,
+	553,
+	486,
+	553,
+	487,
+	554,
+	488,
+	554,
+	487,
+	554,
+	488,
+	555,
+	489,
+	555,
+	488,
+	555,
+	489,
+	556,
+	490,
+	556,
+	489,
+	556,
+	490,
+	557,
+	491,
+	557,
+	490,
+	557,
+	491,
+	558,
+	492,
+	558,
+	491,
+	558,
+	492,
+	559,
+	493,
+	559,
+	492,
+	559,
+	493,
+	560,
+	494,
+	560,
+	493,
+	560,
+	494,
+	561,
+	495,
+	561,
+	494,
+	561,
+	495,
+	562,
+	496,
+	562,
+	495,
+	562,
+	496,
+	563,
+	497,
+	563,
+	496,
+	563,
+	497,
+	564,
+	498,
+	564,
+	497,
+	564,
+	498,
+	565,
+	499,
+	565,
+	498,
+	565,
+	499,
+	566,
+	500,
+	566,
+	499,
+	566,
+	500,
+	567,
+	501,
+	567,
+	500,
+	567,
+	501,
+	568,
+	502,
+	568,
+	501,
+	568,
+	502,
+	569,
+	503,
+	569,
+	502,
+	569,
+	503,
+	570,
+	504,
+	570,
+	503,
+	570,
+	504,
+	571,
+	505,
+	571,
+	504,
+	571,
+	505,
+	572,
+	506,
+	572,
+	505,
+	572,
+	506,
+	573,
+	507,
+	573,
+	506,
+	573,
+	507,
+	574,
+	508,
+	574,
+	507,
+	574,
+	508,
+	575,
+	509,
+	575,
+	508,
+	575,
+	509,
+	576,
+	510,
+	576,
+	509,
+	576,
+	510,
+	577,
+	511,
+	577,
+	510,
+	577,
+	511,
+	578,
+	512,
+	578,
+	511,
+	578,
+	512,
+	579,
+	513,
+	579,
+	512,
+	579,
+	513,
+	580,
+	514,
+	580,
+	513,
+	580,
+	514,
+	581,
+	515,
+	581,
+	514,
+	581,
+	515,
+	582,
+	516,
+	582,
+	515,
+	582,
+	516,
+	583,
+	517,
+	583,
+	516,
+	583,
+	517,
+	584,
+	518,
+	584,
+	517,
+	584,
+	518,
+	585,
+	519,
+	585,
+	518,
+	585,
+	519,
+	586,
+	520,
+	586,
+	519,
+	586,
+	520,
+	587,
+	521,
+	587,
+	520,
+	587,
+	521,
+	588,
+	522,
+	588,
+	521,
+	588,
+	522,
+	589,
+	523,
+	589,
+	522,
+	589,
+	523,
+	590,
+	524,
+	590,
+	523,
+	590,
+	524,
+	591,
+	525,
+	591,
+	524,
+	591,
+	525,
+	592,
+	526,
+	592,
+	525,
+	592,
+	526,
+	593,
+	527,
+	593,
+	526,
+	594,
+	528,
+	595,
+	529,
+	595,
+	528,
+	595,
+	529,
+	596,
+	530,
+	596,
+	529,
+	596,
+	530,
+	597,
+	531,
+	597,
+	530,
+	597,
+	531,
+	598,
+	532,
+	598,
+	531,
+	598,
+	532,
+	599,
+	533,
+	599,
+	532,
+	599,
+	533,
+	600,
+	534,
+	600,
+	533,
+	600,
+	534,
+	601,
+	535,
+	601,
+	534,
+	601,
+	535,
+	602,
+	536,
+	602,
+	535,
+	602,
+	536,
+	603,
+	537,
+	603,
+	536,
+	603,
+	537,
+	604,
+	538,
+	604,
+	537,
+	604,
+	538,
+	605,
+	539,
+	605,
+	538,
+	605,
+	539,
+	606,
+	540,
+	606,
+	539,
+	606,
+	540,
+	607,
+	541,
+	607,
+	540,
+	607,
+	541,
+	608,
+	542,
+	608,
+	541,
+	608,
+	542,
+	609,
+	543,
+	609,
+	542,
+	609,
+	543,
+	610,
+	544,
+	610,
+	543,
+	610,
+	544,
+	611,
+	545,
+	611,
+	544,
+	611,
+	545,
+	612,
+	546,
+	612,
+	545,
+	612,
+	546,
+	613,
+	547,
+	613,
+	546,
+	613,
+	547,
+	614,
+	548,
+	614,
+	547,
+	614,
+	548,
+	615,
+	549,
+	615,
+	548,
+	615,
+	549,
+	616,
+	550,
+	616,
+	549,
+	616,
+	550,
+	617,
+	551,
+	617,
+	550,
+	617,
+	551,
+	618,
+	552,
+	618,
+	551,
+	618,
+	552,
+	619,
+	553,
+	619,
+	552,
+	619,
+	553,
+	620,
+	554,
+	620,
+	553,
+	620,
+	554,
+	621,
+	555,
+	621,
+	554,
+	621,
+	555,
+	622,
+	556,
+	622,
+	555,
+	622,
+	556,
+	623,
+	557,
+	623,
+	556,
+	623,
+	557,
+	624,
+	558,
+	624,
+	557,
+	624,
+	558,
+	625,
+	559,
+	625,
+	558,
+	625,
+	559,
+	626,
+	560,
+	626,
+	559,
+	626,
+	560,
+	627,
+	561,
+	627,
+	560,
+	627,
+	561,
+	628,
+	562,
+	628,
+	561,
+	628,
+	562,
+	629,
+	563,
+	629,
+	562,
+	629,
+	563,
+	630,
+	564,
+	630,
+	563,
+	630,
+	564,
+	631,
+	565,
+	631,
+	564,
+	631,
+	565,
+	632,
+	566,
+	632,
+	565,
+	632,
+	566,
+	633,
+	567,
+	633,
+	566,
+	633,
+	567,
+	634,
+	568,
+	634,
+	567,
+	634,
+	568,
+	635,
+	569,
+	635,
+	568,
+	635,
+	569,
+	636,
+	570,
+	636,
+	569,
+	636,
+	570,
+	637,
+	571,
+	637,
+	570,
+	637,
+	571,
+	638,
+	572,
+	638,
+	571,
+	638,
+	572,
+	639,
+	573,
+	639,
+	572,
+	639,
+	573,
+	640,
+	574,
+	640,
+	573,
+	640,
+	574,
+	641,
+	575,
+	641,
+	574,
+	641,
+	575,
+	642,
+	576,
+	642,
+	575,
+	642,
+	576,
+	643,
+	577,
+	643,
+	576,
+	643,
+	577,
+	644,
+	578,
+	644,
+	577,
+	644,
+	578,
+	645,
+	579,
+	645,
+	578,
+	645,
+	579,
+	646,
+	580,
+	646,
+	579,
+	646,
+	580,
+	647,
+	581,
+	647,
+	580,
+	647,
+	581,
+	648,
+	582,
+	648,
+	581,
+	648,
+	582,
+	649,
+	583,
+	649,
+	582,
+	649,
+	583,
+	650,
+	584,
+	650,
+	583,
+	650,
+	584,
+	651,
+	585,
+	651,
+	584,
+	651,
+	585,
+	652,
+	586,
+	652,
+	585,
+	652,
+	586,
+	653,
+	587,
+	653,
+	586,
+	653,
+	587,
+	654,
+	588,
+	654,
+	587,
+	654,
+	588,
+	655,
+	589,
+	655,
+	588,
+	655,
+	589,
+	656,
+	590,
+	656,
+	589,
+	656,
+	590,
+	657,
+	591,
+	657,
+	590,
+	657,
+	591,
+	658,
+	592,
+	658,
+	591,
+	658,
+	592,
+	659,
+	593,
+	659,
+	592,
+	660,
+	594,
+	661,
+	595,
+	661,
+	594,
+	661,
+	595,
+	662,
+	596,
+	662,
+	595,
+	662,
+	596,
+	663,
+	597,
+	663,
+	596,
+	663,
+	597,
+	664,
+	598,
+	664,
+	597,
+	664,
+	598,
+	665,
+	599,
+	665,
+	598,
+	665,
+	599,
+	666,
+	600,
+	666,
+	599,
+	666,
+	600,
+	667,
+	601,
+	667,
+	600,
+	667,
+	601,
+	668,
+	602,
+	668,
+	601,
+	668,
+	602,
+	669,
+	603,
+	669,
+	602,
+	669,
+	603,
+	670,
+	604,
+	670,
+	603,
+	670,
+	604,
+	671,
+	605,
+	671,
+	604,
+	671,
+	605,
+	672,
+	606,
+	672,
+	605,
+	672,
+	606,
+	673,
+	607,
+	673,
+	606,
+	673,
+	607,
+	674,
+	608,
+	674,
+	607,
+	674,
+	608,
+	675,
+	609,
+	675,
+	608,
+	675,
+	609,
+	676,
+	610,
+	676,
+	609,
+	676,
+	610,
+	677,
+	611,
+	677,
+	610,
+	677,
+	611,
+	678,
+	612,
+	678,
+	611,
+	678,
+	612,
+	679,
+	613,
+	679,
+	612,
+	679,
+	613,
+	680,
+	614,
+	680,
+	613,
+	680,
+	614,
+	681,
+	615,
+	681,
+	614,
+	681,
+	615,
+	682,
+	616,
+	682,
+	615,
+	682,
+	616,
+	683,
+	617,
+	683,
+	616,
+	683,
+	617,
+	684,
+	618,
+	684,
+	617,
+	684,
+	618,
+	685,
+	619,
+	685,
+	618,
+	685,
+	619,
+	686,
+	620,
+	686,
+	619,
+	686,
+	620,
+	687,
+	621,
+	687,
+	620,
+	687,
+	621,
+	688,
+	622,
+	688,
+	621,
+	688,
+	622,
+	689,
+	623,
+	689,
+	622,
+	689,
+	623,
+	690,
+	624,
+	690,
+	623,
+	690,
+	624,
+	691,
+	625,
+	691,
+	624,
+	691,
+	625,
+	692,
+	626,
+	692,
+	625,
+	692,
+	626,
+	693,
+	627,
+	693,
+	626,
+	693,
+	627,
+	694,
+	628,
+	694,
+	627,
+	694,
+	628,
+	695,
+	629,
+	695,
+	628,
+	695,
+	629,
+	696,
+	630,
+	696,
+	629,
+	696,
+	630,
+	697,
+	631,
+	697,
+	630,
+	697,
+	631,
+	698,
+	632,
+	698,
+	631,
+	698,
+	632,
+	699,
+	633,
+	699,
+	632,
+	699,
+	633,
+	700,
+	634,
+	700,
+	633,
+	700,
+	634,
+	701,
+	635,
+	701,
+	634,
+	701,
+	635,
+	702,
+	636,
+	702,
+	635,
+	702,
+	636,
+	703,
+	637,
+	703,
+	636,
+	703,
+	637,
+	704,
+	638,
+	704,
+	637,
+	704,
+	638,
+	705,
+	639,
+	705,
+	638,
+	705,
+	639,
+	706,
+	640,
+	706,
+	639,
+	706,
+	640,
+	707,
+	641,
+	707,
+	640,
+	707,
+	641,
+	708,
+	642,
+	708,
+	641,
+	708,
+	642,
+	709,
+	643,
+	709,
+	642,
+	709,
+	643,
+	710,
+	644,
+	710,
+	643,
+	710,
+	644,
+	711,
+	645,
+	711,
+	644,
+	711,
+	645,
+	712,
+	646,
+	712,
+	645,
+	712,
+	646,
+	713,
+	647,
+	713,
+	646,
+	713,
+	647,
+	714,
+	648,
+	714,
+	647,
+	714,
+	648,
+	715,
+	649,
+	715,
+	648,
+	715,
+	649,
+	716,
+	650,
+	716,
+	649,
+	716,
+	650,
+	717,
+	651,
+	717,
+	650,
+	717,
+	651,
+	718,
+	652,
+	718,
+	651,
+	718,
+	652,
+	719,
+	653,
+	719,
+	652,
+	719,
+	653,
+	720,
+	654,
+	720,
+	653,
+	720,
+	654,
+	721,
+	655,
+	721,
+	654,
+	721,
+	655,
+	722,
+	656,
+	722,
+	655,
+	722,
+	656,
+	723,
+	657,
+	723,
+	656,
+	723,
+	657,
+	724,
+	658,
+	724,
+	657,
+	724,
+	658,
+	725,
+	659,
+	725,
+	658,
+	726,
+	660,
+	727,
+	661,
+	727,
+	660,
+	727,
+	661,
+	728,
+	662,
+	728,
+	661,
+	728,
+	662,
+	729,
+	663,
+	729,
+	662,
+	729,
+	663,
+	730,
+	664,
+	730,
+	663,
+	730,
+	664,
+	731,
+	665,
+	731,
+	664,
+	731,
+	665,
+	732,
+	666,
+	732,
+	665,
+	732,
+	666,
+	733,
+	667,
+	733,
+	666,
+	733,
+	667,
+	734,
+	668,
+	734,
+	667,
+	734,
+	668,
+	735,
+	669,
+	735,
+	668,
+	735,
+	669,
+	736,
+	670,
+	736,
+	669,
+	736,
+	670,
+	737,
+	671,
+	737,
+	670,
+	737,
+	671,
+	738,
+	672,
+	738,
+	671,
+	738,
+	672,
+	739,
+	673,
+	739,
+	672,
+	739,
+	673,
+	740,
+	674,
+	740,
+	673,
+	740,
+	674,
+	741,
+	675,
+	741,
+	674,
+	741,
+	675,
+	742,
+	676,
+	742,
+	675,
+	742,
+	676,
+	743,
+	677,
+	743,
+	676,
+	743,
+	677,
+	744,
+	678,
+	744,
+	677,
+	744,
+	678,
+	745,
+	679,
+	745,
+	678,
+	745,
+	679,
+	746,
+	680,
+	746,
+	679,
+	746,
+	680,
+	747,
+	681,
+	747,
+	680,
+	747,
+	681,
+	748,
+	682,
+	748,
+	681,
+	748,
+	682,
+	749,
+	683,
+	749,
+	682,
+	749,
+	683,
+	750,
+	684,
+	750,
+	683,
+	750,
+	684,
+	751,
+	685,
+	751,
+	684,
+	751,
+	685,
+	752,
+	686,
+	752,
+	685,
+	752,
+	686,
+	753,
+	687,
+	753,
+	686,
+	753,
+	687,
+	754,
+	688,
+	754,
+	687,
+	754,
+	688,
+	755,
+	689,
+	755,
+	688,
+	755,
+	689,
+	756,
+	690,
+	756,
+	689,
+	756,
+	690,
+	757,
+	691,
+	757,
+	690,
+	757,
+	691,
+	758,
+	692,
+	758,
+	691,
+	758,
+	692,
+	759,
+	693,
+	759,
+	692,
+	759,
+	693,
+	760,
+	694,
+	760,
+	693,
+	760,
+	694,
+	761,
+	695,
+	761,
+	694,
+	761,
+	695,
+	762,
+	696,
+	762,
+	695,
+	762,
+	696,
+	763,
+	697,
+	763,
+	696,
+	763,
+	697,
+	764,
+	698,
+	764,
+	697,
+	764,
+	698,
+	765,
+	699,
+	765,
+	698,
+	765,
+	699,
+	766,
+	700,
+	766,
+	699,
+	766,
+	700,
+	767,
+	701,
+	767,
+	700,
+	767,
+	701,
+	768,
+	702,
+	768,
+	701,
+	768,
+	702,
+	769,
+	703,
+	769,
+	702,
+	769,
+	703,
+	770,
+	704,
+	770,
+	703,
+	770,
+	704,
+	771,
+	705,
+	771,
+	704,
+	771,
+	705,
+	772,
+	706,
+	772,
+	705,
+	772,
+	706,
+	773,
+	707,
+	773,
+	706,
+	773,
+	707,
+	774,
+	708,
+	774,
+	707,
+	774,
+	708,
+	775,
+	709,
+	775,
+	708,
+	775,
+	709,
+	776,
+	710,
+	776,
+	709,
+	776,
+	710,
+	777,
+	711,
+	777,
+	710,
+	777,
+	711,
+	778,
+	712,
+	778,
+	711,
+	778,
+	712,
+	779,
+	713,
+	779,
+	712,
+	779,
+	713,
+	780,
+	714,
+	780,
+	713,
+	780,
+	714,
+	781,
+	715,
+	781,
+	714,
+	781,
+	715,
+	782,
+	716,
+	782,
+	715,
+	782,
+	716,
+	783,
+	717,
+	783,
+	716,
+	783,
+	717,
+	784,
+	718,
+	784,
+	717,
+	784,
+	718,
+	785,
+	719,
+	785,
+	718,
+	785,
+	719,
+	786,
+	720,
+	786,
+	719,
+	786,
+	720,
+	787,
+	721,
+	787,
+	720,
+	787,
+	721,
+	788,
+	722,
+	788,
+	721,
+	788,
+	722,
+	789,
+	723,
+	789,
+	722,
+	789,
+	723,
+	790,
+	724,
+	790,
+	723,
+	790,
+	724,
+	791,
+	725,
+	791,
+	724,
+	792,
+	726,
+	793,
+	727,
+	793,
+	726,
+	793,
+	727,
+	794,
+	728,
+	794,
+	727,
+	794,
+	728,
+	795,
+	729,
+	795,
+	728,
+	795,
+	729,
+	796,
+	730,
+	796,
+	729,
+	796,
+	730,
+	797,
+	731,
+	797,
+	730,
+	797,
+	731,
+	798,
+	732,
+	798,
+	731,
+	798,
+	732,
+	799,
+	733,
+	799,
+	732,
+	799,
+	733,
+	800,
+	734,
+	800,
+	733,
+	800,
+	734,
+	801,
+	735,
+	801,
+	734,
+	801,
+	735,
+	802,
+	736,
+	802,
+	735,
+	802,
+	736,
+	803,
+	737,
+	803,
+	736,
+	803,
+	737,
+	804,
+	738,
+	804,
+	737,
+	804,
+	738,
+	805,
+	739,
+	805,
+	738,
+	805,
+	739,
+	806,
+	740,
+	806,
+	739,
+	806,
+	740,
+	807,
+	741,
+	807,
+	740,
+	807,
+	741,
+	808,
+	742,
+	808,
+	741,
+	808,
+	742,
+	809,
+	743,
+	809,
+	742,
+	809,
+	743,
+	810,
+	744,
+	810,
+	743,
+	810,
+	744,
+	811,
+	745,
+	811,
+	744,
+	811,
+	745,
+	812,
+	746,
+	812,
+	745,
+	812,
+	746,
+	813,
+	747,
+	813,
+	746,
+	813,
+	747,
+	814,
+	748,
+	814,
+	747,
+	814,
+	748,
+	815,
+	749,
+	815,
+	748,
+	815,
+	749,
+	816,
+	750,
+	816,
+	749,
+	816,
+	750,
+	817,
+	751,
+	817,
+	750,
+	817,
+	751,
+	818,
+	752,
+	818,
+	751,
+	818,
+	752,
+	819,
+	753,
+	819,
+	752,
+	819,
+	753,
+	820,
+	754,
+	820,
+	753,
+	820,
+	754,
+	821,
+	755,
+	821,
+	754,
+	821,
+	755,
+	822,
+	756,
+	822,
+	755,
+	822,
+	756,
+	823,
+	757,
+	823,
+	756,
+	823,
+	757,
+	824,
+	758,
+	824,
+	757,
+	824,
+	758,
+	825,
+	759,
+	825,
+	758,
+	825,
+	759,
+	826,
+	760,
+	826,
+	759,
+	826,
+	760,
+	827,
+	761,
+	827,
+	760,
+	827,
+	761,
+	828,
+	762,
+	828,
+	761,
+	828,
+	762,
+	829,
+	763,
+	829,
+	762,
+	829,
+	763,
+	830,
+	764,
+	830,
+	763,
+	830,
+	764,
+	831,
+	765,
+	831,
+	764,
+	831,
+	765,
+	832,
+	766,
+	832,
+	765,
+	832,
+	766,
+	833,
+	767,
+	833,
+	766,
+	833,
+	767,
+	834,
+	768,
+	834,
+	767,
+	834,
+	768,
+	835,
+	769,
+	835,
+	768,
+	835,
+	769,
+	836,
+	770,
+	836,
+	769,
+	836,
+	770,
+	837,
+	771,
+	837,
+	770,
+	837,
+	771,
+	838,
+	772,
+	838,
+	771,
+	838,
+	772,
+	839,
+	773,
+	839,
+	772,
+	839,
+	773,
+	840,
+	774,
+	840,
+	773,
+	840,
+	774,
+	841,
+	775,
+	841,
+	774,
+	841,
+	775,
+	842,
+	776,
+	842,
+	775,
+	842,
+	776,
+	843,
+	777,
+	843,
+	776,
+	843,
+	777,
+	844,
+	778,
+	844,
+	777,
+	844,
+	778,
+	845,
+	779,
+	845,
+	778,
+	845,
+	779,
+	846,
+	780,
+	846,
+	779,
+	846,
+	780,
+	847,
+	781,
+	847,
+	780,
+	847,
+	781,
+	848,
+	782,
+	848,
+	781,
+	848,
+	782,
+	849,
+	783,
+	849,
+	782,
+	849,
+	783,
+	850,
+	784,
+	850,
+	783,
+	850,
+	784,
+	851,
+	785,
+	851,
+	784,
+	851,
+	785,
+	852,
+	786,
+	852,
+	785,
+	852,
+	786,
+	853,
+	787,
+	853,
+	786,
+	853,
+	787,
+	854,
+	788,
+	854,
+	787,
+	854,
+	788,
+	855,
+	789,
+	855,
+	788,
+	855,
+	789,
+	856,
+	790,
+	856,
+	789,
+	856,
+	790,
+	857,
+	791,
+	857,
+	790,
+	858,
+	792,
+	859,
+	793,
+	859,
+	792,
+	859,
+	793,
+	860,
+	794,
+	860,
+	793,
+	860,
+	794,
+	861,
+	795,
+	861,
+	794,
+	861,
+	795,
+	862,
+	796,
+	862,
+	795,
+	862,
+	796,
+	863,
+	797,
+	863,
+	796,
+	863,
+	797,
+	864,
+	798,
+	864,
+	797,
+	864,
+	798,
+	865,
+	799,
+	865,
+	798,
+	865,
+	799,
+	866,
+	800,
+	866,
+	799,
+	866,
+	800,
+	867,
+	801,
+	867,
+	800,
+	867,
+	801,
+	868,
+	802,
+	868,
+	801,
+	868,
+	802,
+	869,
+	803,
+	869,
+	802,
+	869,
+	803,
+	870,
+	804,
+	870,
+	803,
+	870,
+	804,
+	871,
+	805,
+	871,
+	804,
+	871,
+	805,
+	872,
+	806,
+	872,
+	805,
+	872,
+	806,
+	873,
+	807,
+	873,
+	806,
+	873,
+	807,
+	874,
+	808,
+	874,
+	807,
+	874,
+	808,
+	875,
+	809,
+	875,
+	808,
+	875,
+	809,
+	876,
+	810,
+	876,
+	809,
+	876,
+	810,
+	877,
+	811,
+	877,
+	810,
+	877,
+	811,
+	878,
+	812,
+	878,
+	811,
+	878,
+	812,
+	879,
+	813,
+	879,
+	812,
+	879,
+	813,
+	880,
+	814,
+	880,
+	813,
+	880,
+	814,
+	881,
+	815,
+	881,
+	814,
+	881,
+	815,
+	882,
+	816,
+	882,
+	815,
+	882,
+	816,
+	883,
+	817,
+	883,
+	816,
+	883,
+	817,
+	884,
+	818,
+	884,
+	817,
+	884,
+	818,
+	885,
+	819,
+	885,
+	818,
+	885,
+	819,
+	886,
+	820,
+	886,
+	819,
+	886,
+	820,
+	887,
+	821,
+	887,
+	820,
+	887,
+	821,
+	888,
+	822,
+	888,
+	821,
+	888,
+	822,
+	889,
+	823,
+	889,
+	822,
+	889,
+	823,
+	890,
+	824,
+	890,
+	823,
+	890,
+	824,
+	891,
+	825,
+	891,
+	824,
+	891,
+	825,
+	892,
+	826,
+	892,
+	825,
+	892,
+	826,
+	893,
+	827,
+	893,
+	826,
+	893,
+	827,
+	894,
+	828,
+	894,
+	827,
+	894,
+	828,
+	895,
+	829,
+	895,
+	828,
+	895,
+	829,
+	896,
+	830,
+	896,
+	829,
+	896,
+	830,
+	897,
+	831,
+	897,
+	830,
+	897,
+	831,
+	898,
+	832,
+	898,
+	831,
+	898,
+	832,
+	899,
+	833,
+	899,
+	832,
+	899,
+	833,
+	900,
+	834,
+	900,
+	833,
+	900,
+	834,
+	901,
+	835,
+	901,
+	834,
+	901,
+	835,
+	902,
+	836,
+	902,
+	835,
+	902,
+	836,
+	903,
+	837,
+	903,
+	836,
+	903,
+	837,
+	904,
+	838,
+	904,
+	837,
+	904,
+	838,
+	905,
+	839,
+	905,
+	838,
+	905,
+	839,
+	906,
+	840,
+	906,
+	839,
+	906,
+	840,
+	907,
+	841,
+	907,
+	840,
+	907,
+	841,
+	908,
+	842,
+	908,
+	841,
+	908,
+	842,
+	909,
+	843,
+	909,
+	842,
+	909,
+	843,
+	910,
+	844,
+	910,
+	843,
+	910,
+	844,
+	911,
+	845,
+	911,
+	844,
+	911,
+	845,
+	912,
+	846,
+	912,
+	845,
+	912,
+	846,
+	913,
+	847,
+	913,
+	846,
+	913,
+	847,
+	914,
+	848,
+	914,
+	847,
+	914,
+	848,
+	915,
+	849,
+	915,
+	848,
+	915,
+	849,
+	916,
+	850,
+	916,
+	849,
+	916,
+	850,
+	917,
+	851,
+	917,
+	850,
+	917,
+	851,
+	918,
+	852,
+	918,
+	851,
+	918,
+	852,
+	919,
+	853,
+	919,
+	852,
+	919,
+	853,
+	920,
+	854,
+	920,
+	853,
+	920,
+	854,
+	921,
+	855,
+	921,
+	854,
+	921,
+	855,
+	922,
+	856,
+	922,
+	855,
+	922,
+	856,
+	923,
+	857,
+	923,
+	856,
+	924,
+	858,
+	925,
+	859,
+	925,
+	858,
+	925,
+	859,
+	926,
+	860,
+	926,
+	859,
+	926,
+	860,
+	927,
+	861,
+	927,
+	860,
+	927,
+	861,
+	928,
+	862,
+	928,
+	861,
+	928,
+	862,
+	929,
+	863,
+	929,
+	862,
+	929,
+	863,
+	930,
+	864,
+	930,
+	863,
+	930,
+	864,
+	931,
+	865,
+	931,
+	864,
+	931,
+	865,
+	932,
+	866,
+	932,
+	865,
+	932,
+	866,
+	933,
+	867,
+	933,
+	866,
+	933,
+	867,
+	934,
+	868,
+	934,
+	867,
+	934,
+	868,
+	935,
+	869,
+	935,
+	868,
+	935,
+	869,
+	936,
+	870,
+	936,
+	869,
+	936,
+	870,
+	937,
+	871,
+	937,
+	870,
+	937,
+	871,
+	938,
+	872,
+	938,
+	871,
+	938,
+	872,
+	939,
+	873,
+	939,
+	872,
+	939,
+	873,
+	940,
+	874,
+	940,
+	873,
+	940,
+	874,
+	941,
+	875,
+	941,
+	874,
+	941,
+	875,
+	942,
+	876,
+	942,
+	875,
+	942,
+	876,
+	943,
+	877,
+	943,
+	876,
+	943,
+	877,
+	944,
+	878,
+	944,
+	877,
+	944,
+	878,
+	945,
+	879,
+	945,
+	878,
+	945,
+	879,
+	946,
+	880,
+	946,
+	879,
+	946,
+	880,
+	947,
+	881,
+	947,
+	880,
+	947,
+	881,
+	948,
+	882,
+	948,
+	881,
+	948,
+	882,
+	949,
+	883,
+	949,
+	882,
+	949,
+	883,
+	950,
+	884,
+	950,
+	883,
+	950,
+	884,
+	951,
+	885,
+	951,
+	884,
+	951,
+	885,
+	952,
+	886,
+	952,
+	885,
+	952,
+	886,
+	953,
+	887,
+	953,
+	886,
+	953,
+	887,
+	954,
+	888,
+	954,
+	887,
+	954,
+	888,
+	955,
+	889,
+	955,
+	888,
+	955,
+	889,
+	956,
+	890,
+	956,
+	889,
+	956,
+	890,
+	957,
+	891,
+	957,
+	890,
+	957,
+	891,
+	958,
+	892,
+	958,
+	891,
+	958,
+	892,
+	959,
+	893,
+	959,
+	892,
+	959,
+	893,
+	960,
+	894,
+	960,
+	893,
+	960,
+	894,
+	961,
+	895,
+	961,
+	894,
+	961,
+	895,
+	962,
+	896,
+	962,
+	895,
+	962,
+	896,
+	963,
+	897,
+	963,
+	896,
+	963,
+	897,
+	964,
+	898,
+	964,
+	897,
+	964,
+	898,
+	965,
+	899,
+	965,
+	898,
+	965,
+	899,
+	966,
+	900,
+	966,
+	899,
+	966,
+	900,
+	967,
+	901,
+	967,
+	900,
+	967,
+	901,
+	968,
+	902,
+	968,
+	901,
+	968,
+	902,
+	969,
+	903,
+	969,
+	902,
+	969,
+	903,
+	970,
+	904,
+	970,
+	903,
+	970,
+	904,
+	971,
+	905,
+	971,
+	904,
+	971,
+	905,
+	972,
+	906,
+	972,
+	905,
+	972,
+	906,
+	973,
+	907,
+	973,
+	906,
+	973,
+	907,
+	974,
+	908,
+	974,
+	907,
+	974,
+	908,
+	975,
+	909,
+	975,
+	908,
+	975,
+	909,
+	976,
+	910,
+	976,
+	909,
+	976,
+	910,
+	977,
+	911,
+	977,
+	910,
+	977,
+	911,
+	978,
+	912,
+	978,
+	911,
+	978,
+	912,
+	979,
+	913,
+	979,
+	912,
+	979,
+	913,
+	980,
+	914,
+	980,
+	913,
+	980,
+	914,
+	981,
+	915,
+	981,
+	914,
+	981,
+	915,
+	982,
+	916,
+	982,
+	915,
+	982,
+	916,
+	983,
+	917,
+	983,
+	916,
+	983,
+	917,
+	984,
+	918,
+	984,
+	917,
+	984,
+	918,
+	985,
+	919,
+	985,
+	918,
+	985,
+	919,
+	986,
+	920,
+	986,
+	919,
+	986,
+	920,
+	987,
+	921,
+	987,
+	920,
+	987,
+	921,
+	988,
+	922,
+	988,
+	921,
+	988,
+	922,
+	989,
+	923,
+	989,
+	922,
+	990,
+	924,
+	991,
+	925,
+	991,
+	924,
+	991,
+	925,
+	992,
+	926,
+	992,
+	925,
+	992,
+	926,
+	993,
+	927,
+	993,
+	926,
+	993,
+	927,
+	994,
+	928,
+	994,
+	927,
+	994,
+	928,
+	995,
+	929,
+	995,
+	928,
+	995,
+	929,
+	996,
+	930,
+	996,
+	929,
+	996,
+	930,
+	997,
+	931,
+	997,
+	930,
+	997,
+	931,
+	998,
+	932,
+	998,
+	931,
+	998,
+	932,
+	999,
+	933,
+	999,
+	932,
+	999,
+	933,
+	1000,
+	934,
+	1000,
+	933,
+	1000,
+	934,
+	1001,
+	935,
+	1001,
+	934,
+	1001,
+	935,
+	1002,
+	936,
+	1002,
+	935,
+	1002,
+	936,
+	1003,
+	937,
+	1003,
+	936,
+	1003,
+	937,
+	1004,
+	938,
+	1004,
+	937,
+	1004,
+	938,
+	1005,
+	939,
+	1005,
+	938,
+	1005,
+	939,
+	1006,
+	940,
+	1006,
+	939,
+	1006,
+	940,
+	1007,
+	941,
+	1007,
+	940,
+	1007,
+	941,
+	1008,
+	942,
+	1008,
+	941,
+	1008,
+	942,
+	1009,
+	943,
+	1009,
+	942,
+	1009,
+	943,
+	1010,
+	944,
+	1010,
+	943,
+	1010,
+	944,
+	1011,
+	945,
+	1011,
+	944,
+	1011,
+	945,
+	1012,
+	946,
+	1012,
+	945,
+	1012,
+	946,
+	1013,
+	947,
+	1013,
+	946,
+	1013,
+	947,
+	1014,
+	948,
+	1014,
+	947,
+	1014,
+	948,
+	1015,
+	949,
+	1015,
+	948,
+	1015,
+	949,
+	1016,
+	950,
+	1016,
+	949,
+	1016,
+	950,
+	1017,
+	951,
+	1017,
+	950,
+	1017,
+	951,
+	1018,
+	952,
+	1018,
+	951,
+	1018,
+	952,
+	1019,
+	953,
+	1019,
+	952,
+	1019,
+	953,
+	1020,
+	954,
+	1020,
+	953,
+	1020,
+	954,
+	1021,
+	955,
+	1021,
+	954,
+	1021,
+	955,
+	1022,
+	956,
+	1022,
+	955,
+	1022,
+	956,
+	1023,
+	957,
+	1023,
+	956,
+	1023,
+	957,
+	1024,
+	958,
+	1024,
+	957,
+	1024,
+	958,
+	1025,
+	959,
+	1025,
+	958,
+	1025,
+	959,
+	1026,
+	960,
+	1026,
+	959,
+	1026,
+	960,
+	1027,
+	961,
+	1027,
+	960,
+	1027,
+	961,
+	1028,
+	962,
+	1028,
+	961,
+	1028,
+	962,
+	1029,
+	963,
+	1029,
+	962,
+	1029,
+	963,
+	1030,
+	964,
+	1030,
+	963,
+	1030,
+	964,
+	1031,
+	965,
+	1031,
+	964,
+	1031,
+	965,
+	1032,
+	966,
+	1032,
+	965,
+	1032,
+	966,
+	1033,
+	967,
+	1033,
+	966,
+	1033,
+	967,
+	1034,
+	968,
+	1034,
+	967,
+	1034,
+	968,
+	1035,
+	969,
+	1035,
+	968,
+	1035,
+	969,
+	1036,
+	970,
+	1036,
+	969,
+	1036,
+	970,
+	1037,
+	971,
+	1037,
+	970,
+	1037,
+	971,
+	1038,
+	972,
+	1038,
+	971,
+	1038,
+	972,
+	1039,
+	973,
+	1039,
+	972,
+	1039,
+	973,
+	1040,
+	974,
+	1040,
+	973,
+	1040,
+	974,
+	1041,
+	975,
+	1041,
+	974,
+	1041,
+	975,
+	1042,
+	976,
+	1042,
+	975,
+	1042,
+	976,
+	1043,
+	977,
+	1043,
+	976,
+	1043,
+	977,
+	1044,
+	978,
+	1044,
+	977,
+	1044,
+	978,
+	1045,
+	979,
+	1045,
+	978,
+	1045,
+	979,
+	1046,
+	980,
+	1046,
+	979,
+	1046,
+	980,
+	1047,
+	981,
+	1047,
+	980,
+	1047,
+	981,
+	1048,
+	982,
+	1048,
+	981,
+	1048,
+	982,
+	1049,
+	983,
+	1049,
+	982,
+	1049,
+	983,
+	1050,
+	984,
+	1050,
+	983,
+	1050,
+	984,
+	1051,
+	985,
+	1051,
+	984,
+	1051,
+	985,
+	1052,
+	986,
+	1052,
+	985,
+	1052,
+	986,
+	1053,
+	987,
+	1053,
+	986,
+	1053,
+	987,
+	1054,
+	988,
+	1054,
+	987,
+	1054,
+	988,
+	1055,
+	989,
+	1055,
+	988,
+	1056,
+	990,
+	1057,
+	991,
+	1057,
+	990,
+	1057,
+	991,
+	1058,
+	992,
+	1058,
+	991,
+	1058,
+	992,
+	1059,
+	993,
+	1059,
+	992,
+	1059,
+	993,
+	1060,
+	994,
+	1060,
+	993,
+	1060,
+	994,
+	1061,
+	995,
+	1061,
+	994,
+	1061,
+	995,
+	1062,
+	996,
+	1062,
+	995,
+	1062,
+	996,
+	1063,
+	997,
+	1063,
+	996,
+	1063,
+	997,
+	1064,
+	998,
+	1064,
+	997,
+	1064,
+	998,
+	1065,
+	999,
+	1065,
+	998,
+	1065,
+	999,
+	1066,
+	1000,
+	1066,
+	999,
+	1066,
+	1000,
+	1067,
+	1001,
+	1067,
+	1000,
+	1067,
+	1001,
+	1068,
+	1002,
+	1068,
+	1001,
+	1068,
+	1002,
+	1069,
+	1003,
+	1069,
+	1002,
+	1069,
+	1003,
+	1070,
+	1004,
+	1070,
+	1003,
+	1070,
+	1004,
+	1071,
+	1005,
+	1071,
+	1004,
+	1071,
+	1005,
+	1072,
+	1006,
+	1072,
+	1005,
+	1072,
+	1006,
+	1073,
+	1007,
+	1073,
+	1006,
+	1073,
+	1007,
+	1074,
+	1008,
+	1074,
+	1007,
+	1074,
+	1008,
+	1075,
+	1009,
+	1075,
+	1008,
+	1075,
+	1009,
+	1076,
+	1010,
+	1076,
+	1009,
+	1076,
+	1010,
+	1077,
+	1011,
+	1077,
+	1010,
+	1077,
+	1011,
+	1078,
+	1012,
+	1078,
+	1011,
+	1078,
+	1012,
+	1079,
+	1013,
+	1079,
+	1012,
+	1079,
+	1013,
+	1080,
+	1014,
+	1080,
+	1013,
+	1080,
+	1014,
+	1081,
+	1015,
+	1081,
+	1014,
+	1081,
+	1015,
+	1082,
+	1016,
+	1082,
+	1015,
+	1082,
+	1016,
+	1083,
+	1017,
+	1083,
+	1016,
+	1083,
+	1017,
+	1084,
+	1018,
+	1084,
+	1017,
+	1084,
+	1018,
+	1085,
+	1019,
+	1085,
+	1018,
+	1085,
+	1019,
+	1086,
+	1020,
+	1086,
+	1019,
+	1086,
+	1020,
+	1087,
+	1021,
+	1087,
+	1020,
+	1087,
+	1021,
+	1088,
+	1022,
+	1088,
+	1021,
+	1088,
+	1022,
+	1089,
+	1023,
+	1089,
+	1022,
+	1089,
+	1023,
+	1090,
+	1024,
+	1090,
+	1023,
+	1090,
+	1024,
+	1091,
+	1025,
+	1091,
+	1024,
+	1091,
+	1025,
+	1092,
+	1026,
+	1092,
+	1025,
+	1092,
+	1026,
+	1093,
+	1027,
+	1093,
+	1026,
+	1093,
+	1027,
+	1094,
+	1028,
+	1094,
+	1027,
+	1094,
+	1028,
+	1095,
+	1029,
+	1095,
+	1028,
+	1095,
+	1029,
+	1096,
+	1030,
+	1096,
+	1029,
+	1096,
+	1030,
+	1097,
+	1031,
+	1097,
+	1030,
+	1097,
+	1031,
+	1098,
+	1032,
+	1098,
+	1031,
+	1098,
+	1032,
+	1099,
+	1033,
+	1099,
+	1032,
+	1099,
+	1033,
+	1100,
+	1034,
+	1100,
+	1033,
+	1100,
+	1034,
+	1101,
+	1035,
+	1101,
+	1034,
+	1101,
+	1035,
+	1102,
+	1036,
+	1102,
+	1035,
+	1102,
+	1036,
+	1103,
+	1037,
+	1103,
+	1036,
+	1103,
+	1037,
+	1104,
+	1038,
+	1104,
+	1037,
+	1104,
+	1038,
+	1105,
+	1039,
+	1105,
+	1038,
+	1105,
+	1039,
+	1106,
+	1040,
+	1106,
+	1039,
+	1106,
+	1040,
+	1107,
+	1041,
+	1107,
+	1040,
+	1107,
+	1041,
+	1108,
+	1042,
+	1108,
+	1041,
+	1108,
+	1042,
+	1109,
+	1043,
+	1109,
+	1042,
+	1109,
+	1043,
+	1110,
+	1044,
+	1110,
+	1043,
+	1110,
+	1044,
+	1111,
+	1045,
+	1111,
+	1044,
+	1111,
+	1045,
+	1112,
+	1046,
+	1112,
+	1045,
+	1112,
+	1046,
+	1113,
+	1047,
+	1113,
+	1046,
+	1113,
+	1047,
+	1114,
+	1048,
+	1114,
+	1047,
+	1114,
+	1048,
+	1115,
+	1049,
+	1115,
+	1048,
+	1115,
+	1049,
+	1116,
+	1050,
+	1116,
+	1049,
+	1116,
+	1050,
+	1117,
+	1051,
+	1117,
+	1050,
+	1117,
+	1051,
+	1118,
+	1052,
+	1118,
+	1051,
+	1118,
+	1052,
+	1119,
+	1053,
+	1119,
+	1052,
+	1119,
+	1053,
+	1120,
+	1054,
+	1120,
+	1053,
+	1120,
+	1054,
+	1121,
+	1055,
+	1121,
+	1054,
+	1122,
+	1056,
+	1123,
+	1057,
+	1123,
+	1056,
+	1123,
+	1057,
+	1124,
+	1058,
+	1124,
+	1057,
+	1124,
+	1058,
+	1125,
+	1059,
+	1125,
+	1058,
+	1125,
+	1059,
+	1126,
+	1060,
+	1126,
+	1059,
+	1126,
+	1060,
+	1127,
+	1061,
+	1127,
+	1060,
+	1127,
+	1061,
+	1128,
+	1062,
+	1128,
+	1061,
+	1128,
+	1062,
+	1129,
+	1063,
+	1129,
+	1062,
+	1129,
+	1063,
+	1130,
+	1064,
+	1130,
+	1063,
+	1130,
+	1064,
+	1131,
+	1065,
+	1131,
+	1064,
+	1131,
+	1065,
+	1132,
+	1066,
+	1132,
+	1065,
+	1132,
+	1066,
+	1133,
+	1067,
+	1133,
+	1066,
+	1133,
+	1067,
+	1134,
+	1068,
+	1134,
+	1067,
+	1134,
+	1068,
+	1135,
+	1069,
+	1135,
+	1068,
+	1135,
+	1069,
+	1136,
+	1070,
+	1136,
+	1069,
+	1136,
+	1070,
+	1137,
+	1071,
+	1137,
+	1070,
+	1137,
+	1071,
+	1138,
+	1072,
+	1138,
+	1071,
+	1138,
+	1072,
+	1139,
+	1073,
+	1139,
+	1072,
+	1139,
+	1073,
+	1140,
+	1074,
+	1140,
+	1073,
+	1140,
+	1074,
+	1141,
+	1075,
+	1141,
+	1074,
+	1141,
+	1075,
+	1142,
+	1076,
+	1142,
+	1075,
+	1142,
+	1076,
+	1143,
+	1077,
+	1143,
+	1076,
+	1143,
+	1077,
+	1144,
+	1078,
+	1144,
+	1077,
+	1144,
+	1078,
+	1145,
+	1079,
+	1145,
+	1078,
+	1145,
+	1079,
+	1146,
+	1080,
+	1146,
+	1079,
+	1146,
+	1080,
+	1147,
+	1081,
+	1147,
+	1080,
+	1147,
+	1081,
+	1148,
+	1082,
+	1148,
+	1081,
+	1148,
+	1082,
+	1149,
+	1083,
+	1149,
+	1082,
+	1149,
+	1083,
+	1150,
+	1084,
+	1150,
+	1083,
+	1150,
+	1084,
+	1151,
+	1085,
+	1151,
+	1084,
+	1151,
+	1085,
+	1152,
+	1086,
+	1152,
+	1085,
+	1152,
+	1086,
+	1153,
+	1087,
+	1153,
+	1086,
+	1153,
+	1087,
+	1154,
+	1088,
+	1154,
+	1087,
+	1154,
+	1088,
+	1155,
+	1089,
+	1155,
+	1088,
+	1155,
+	1089,
+	1156,
+	1090,
+	1156,
+	1089,
+	1156,
+	1090,
+	1157,
+	1091,
+	1157,
+	1090,
+	1157,
+	1091,
+	1158,
+	1092,
+	1158,
+	1091,
+	1158,
+	1092,
+	1159,
+	1093,
+	1159,
+	1092,
+	1159,
+	1093,
+	1160,
+	1094,
+	1160,
+	1093,
+	1160,
+	1094,
+	1161,
+	1095,
+	1161,
+	1094,
+	1161,
+	1095,
+	1162,
+	1096,
+	1162,
+	1095,
+	1162,
+	1096,
+	1163,
+	1097,
+	1163,
+	1096,
+	1163,
+	1097,
+	1164,
+	1098,
+	1164,
+	1097,
+	1164,
+	1098,
+	1165,
+	1099,
+	1165,
+	1098,
+	1165,
+	1099,
+	1166,
+	1100,
+	1166,
+	1099,
+	1166,
+	1100,
+	1167,
+	1101,
+	1167,
+	1100,
+	1167,
+	1101,
+	1168,
+	1102,
+	1168,
+	1101,
+	1168,
+	1102,
+	1169,
+	1103,
+	1169,
+	1102,
+	1169,
+	1103,
+	1170,
+	1104,
+	1170,
+	1103,
+	1170,
+	1104,
+	1171,
+	1105,
+	1171,
+	1104,
+	1171,
+	1105,
+	1172,
+	1106,
+	1172,
+	1105,
+	1172,
+	1106,
+	1173,
+	1107,
+	1173,
+	1106,
+	1173,
+	1107,
+	1174,
+	1108,
+	1174,
+	1107,
+	1174,
+	1108,
+	1175,
+	1109,
+	1175,
+	1108,
+	1175,
+	1109,
+	1176,
+	1110,
+	1176,
+	1109,
+	1176,
+	1110,
+	1177,
+	1111,
+	1177,
+	1110,
+	1177,
+	1111,
+	1178,
+	1112,
+	1178,
+	1111,
+	1178,
+	1112,
+	1179,
+	1113,
+	1179,
+	1112,
+	1179,
+	1113,
+	1180,
+	1114,
+	1180,
+	1113,
+	1180,
+	1114,
+	1181,
+	1115,
+	1181,
+	1114,
+	1181,
+	1115,
+	1182,
+	1116,
+	1182,
+	1115,
+	1182,
+	1116,
+	1183,
+	1117,
+	1183,
+	1116,
+	1183,
+	1117,
+	1184,
+	1118,
+	1184,
+	1117,
+	1184,
+	1118,
+	1185,
+	1119,
+	1185,
+	1118,
+	1185,
+	1119,
+	1186,
+	1120,
+	1186,
+	1119,
+	1186,
+	1120,
+	1187,
+	1121,
+	1187,
+	1120,
+	1188,
+	1122,
+	1189,
+	1123,
+	1189,
+	1122,
+	1189,
+	1123,
+	1190,
+	1124,
+	1190,
+	1123,
+	1190,
+	1124,
+	1191,
+	1125,
+	1191,
+	1124,
+	1191,
+	1125,
+	1192,
+	1126,
+	1192,
+	1125,
+	1192,
+	1126,
+	1193,
+	1127,
+	1193,
+	1126,
+	1193,
+	1127,
+	1194,
+	1128,
+	1194,
+	1127,
+	1194,
+	1128,
+	1195,
+	1129,
+	1195,
+	1128,
+	1195,
+	1129,
+	1196,
+	1130,
+	1196,
+	1129,
+	1196,
+	1130,
+	1197,
+	1131,
+	1197,
+	1130,
+	1197,
+	1131,
+	1198,
+	1132,
+	1198,
+	1131,
+	1198,
+	1132,
+	1199,
+	1133,
+	1199,
+	1132,
+	1199,
+	1133,
+	1200,
+	1134,
+	1200,
+	1133,
+	1200,
+	1134,
+	1201,
+	1135,
+	1201,
+	1134,
+	1201,
+	1135,
+	1202,
+	1136,
+	1202,
+	1135,
+	1202,
+	1136,
+	1203,
+	1137,
+	1203,
+	1136,
+	1203,
+	1137,
+	1204,
+	1138,
+	1204,
+	1137,
+	1204,
+	1138,
+	1205,
+	1139,
+	1205,
+	1138,
+	1205,
+	1139,
+	1206,
+	1140,
+	1206,
+	1139,
+	1206,
+	1140,
+	1207,
+	1141,
+	1207,
+	1140,
+	1207,
+	1141,
+	1208,
+	1142,
+	1208,
+	1141,
+	1208,
+	1142,
+	1209,
+	1143,
+	1209,
+	1142,
+	1209,
+	1143,
+	1210,
+	1144,
+	1210,
+	1143,
+	1210,
+	1144,
+	1211,
+	1145,
+	1211,
+	1144,
+	1211,
+	1145,
+	1212,
+	1146,
+	1212,
+	1145,
+	1212,
+	1146,
+	1213,
+	1147,
+	1213,
+	1146,
+	1213,
+	1147,
+	1214,
+	1148,
+	1214,
+	1147,
+	1214,
+	1148,
+	1215,
+	1149,
+	1215,
+	1148,
+	1215,
+	1149,
+	1216,
+	1150,
+	1216,
+	1149,
+	1216,
+	1150,
+	1217,
+	1151,
+	1217,
+	1150,
+	1217,
+	1151,
+	1218,
+	1152,
+	1218,
+	1151,
+	1218,
+	1152,
+	1219,
+	1153,
+	1219,
+	1152,
+	1219,
+	1153,
+	1220,
+	1154,
+	1220,
+	1153,
+	1220,
+	1154,
+	1221,
+	1155,
+	1221,
+	1154,
+	1221,
+	1155,
+	1222,
+	1156,
+	1222,
+	1155,
+	1222,
+	1156,
+	1223,
+	1157,
+	1223,
+	1156,
+	1223,
+	1157,
+	1224,
+	1158,
+	1224,
+	1157,
+	1224,
+	1158,
+	1225,
+	1159,
+	1225,
+	1158,
+	1225,
+	1159,
+	1226,
+	1160,
+	1226,
+	1159,
+	1226,
+	1160,
+	1227,
+	1161,
+	1227,
+	1160,
+	1227,
+	1161,
+	1228,
+	1162,
+	1228,
+	1161,
+	1228,
+	1162,
+	1229,
+	1163,
+	1229,
+	1162,
+	1229,
+	1163,
+	1230,
+	1164,
+	1230,
+	1163,
+	1230,
+	1164,
+	1231,
+	1165,
+	1231,
+	1164,
+	1231,
+	1165,
+	1232,
+	1166,
+	1232,
+	1165,
+	1232,
+	1166,
+	1233,
+	1167,
+	1233,
+	1166,
+	1233,
+	1167,
+	1234,
+	1168,
+	1234,
+	1167,
+	1234,
+	1168,
+	1235,
+	1169,
+	1235,
+	1168,
+	1235,
+	1169,
+	1236,
+	1170,
+	1236,
+	1169,
+	1236,
+	1170,
+	1237,
+	1171,
+	1237,
+	1170,
+	1237,
+	1171,
+	1238,
+	1172,
+	1238,
+	1171,
+	1238,
+	1172,
+	1239,
+	1173,
+	1239,
+	1172,
+	1239,
+	1173,
+	1240,
+	1174,
+	1240,
+	1173,
+	1240,
+	1174,
+	1241,
+	1175,
+	1241,
+	1174,
+	1241,
+	1175,
+	1242,
+	1176,
+	1242,
+	1175,
+	1242,
+	1176,
+	1243,
+	1177,
+	1243,
+	1176,
+	1243,
+	1177,
+	1244,
+	1178,
+	1244,
+	1177,
+	1244,
+	1178,
+	1245,
+	1179,
+	1245,
+	1178,
+	1245,
+	1179,
+	1246,
+	1180,
+	1246,
+	1179,
+	1246,
+	1180,
+	1247,
+	1181,
+	1247,
+	1180,
+	1247,
+	1181,
+	1248,
+	1182,
+	1248,
+	1181,
+	1248,
+	1182,
+	1249,
+	1183,
+	1249,
+	1182,
+	1249,
+	1183,
+	1250,
+	1184,
+	1250,
+	1183,
+	1250,
+	1184,
+	1251,
+	1185,
+	1251,
+	1184,
+	1251,
+	1185,
+	1252,
+	1186,
+	1252,
+	1185,
+	1252,
+	1186,
+	1253,
+	1187,
+	1253,
+	1186,
+	1254,
+	1188,
+	1255,
+	1189,
+	1255,
+	1188,
+	1255,
+	1189,
+	1256,
+	1190,
+	1256,
+	1189,
+	1256,
+	1190,
+	1257,
+	1191,
+	1257,
+	1190,
+	1257,
+	1191,
+	1258,
+	1192,
+	1258,
+	1191,
+	1258,
+	1192,
+	1259,
+	1193,
+	1259,
+	1192,
+	1259,
+	1193,
+	1260,
+	1194,
+	1260,
+	1193,
+	1260,
+	1194,
+	1261,
+	1195,
+	1261,
+	1194,
+	1261,
+	1195,
+	1262,
+	1196,
+	1262,
+	1195,
+	1262,
+	1196,
+	1263,
+	1197,
+	1263,
+	1196,
+	1263,
+	1197,
+	1264,
+	1198,
+	1264,
+	1197,
+	1264,
+	1198,
+	1265,
+	1199,
+	1265,
+	1198,
+	1265,
+	1199,
+	1266,
+	1200,
+	1266,
+	1199,
+	1266,
+	1200,
+	1267,
+	1201,
+	1267,
+	1200,
+	1267,
+	1201,
+	1268,
+	1202,
+	1268,
+	1201,
+	1268,
+	1202,
+	1269,
+	1203,
+	1269,
+	1202,
+	1269,
+	1203,
+	1270,
+	1204,
+	1270,
+	1203,
+	1270,
+	1204,
+	1271,
+	1205,
+	1271,
+	1204,
+	1271,
+	1205,
+	1272,
+	1206,
+	1272,
+	1205,
+	1272,
+	1206,
+	1273,
+	1207,
+	1273,
+	1206,
+	1273,
+	1207,
+	1274,
+	1208,
+	1274,
+	1207,
+	1274,
+	1208,
+	1275,
+	1209,
+	1275,
+	1208,
+	1275,
+	1209,
+	1276,
+	1210,
+	1276,
+	1209,
+	1276,
+	1210,
+	1277,
+	1211,
+	1277,
+	1210,
+	1277,
+	1211,
+	1278,
+	1212,
+	1278,
+	1211,
+	1278,
+	1212,
+	1279,
+	1213,
+	1279,
+	1212,
+	1279,
+	1213,
+	1280,
+	1214,
+	1280,
+	1213,
+	1280,
+	1214,
+	1281,
+	1215,
+	1281,
+	1214,
+	1281,
+	1215,
+	1282,
+	1216,
+	1282,
+	1215,
+	1282,
+	1216,
+	1283,
+	1217,
+	1283,
+	1216,
+	1283,
+	1217,
+	1284,
+	1218,
+	1284,
+	1217,
+	1284,
+	1218,
+	1285,
+	1219,
+	1285,
+	1218,
+	1285,
+	1219,
+	1286,
+	1220,
+	1286,
+	1219,
+	1286,
+	1220,
+	1287,
+	1221,
+	1287,
+	1220,
+	1287,
+	1221,
+	1288,
+	1222,
+	1288,
+	1221,
+	1288,
+	1222,
+	1289,
+	1223,
+	1289,
+	1222,
+	1289,
+	1223,
+	1290,
+	1224,
+	1290,
+	1223,
+	1290,
+	1224,
+	1291,
+	1225,
+	1291,
+	1224,
+	1291,
+	1225,
+	1292,
+	1226,
+	1292,
+	1225,
+	1292,
+	1226,
+	1293,
+	1227,
+	1293,
+	1226,
+	1293,
+	1227,
+	1294,
+	1228,
+	1294,
+	1227,
+	1294,
+	1228,
+	1295,
+	1229,
+	1295,
+	1228,
+	1295,
+	1229,
+	1296,
+	1230,
+	1296,
+	1229,
+	1296,
+	1230,
+	1297,
+	1231,
+	1297,
+	1230,
+	1297,
+	1231,
+	1298,
+	1232,
+	1298,
+	1231,
+	1298,
+	1232,
+	1299,
+	1233,
+	1299,
+	1232,
+	1299,
+	1233,
+	1300,
+	1234,
+	1300,
+	1233,
+	1300,
+	1234,
+	1301,
+	1235,
+	1301,
+	1234,
+	1301,
+	1235,
+	1302,
+	1236,
+	1302,
+	1235,
+	1302,
+	1236,
+	1303,
+	1237,
+	1303,
+	1236,
+	1303,
+	1237,
+	1304,
+	1238,
+	1304,
+	1237,
+	1304,
+	1238,
+	1305,
+	1239,
+	1305,
+	1238,
+	1305,
+	1239,
+	1306,
+	1240,
+	1306,
+	1239,
+	1306,
+	1240,
+	1307,
+	1241,
+	1307,
+	1240,
+	1307,
+	1241,
+	1308,
+	1242,
+	1308,
+	1241,
+	1308,
+	1242,
+	1309,
+	1243,
+	1309,
+	1242,
+	1309,
+	1243,
+	1310,
+	1244,
+	1310,
+	1243,
+	1310,
+	1244,
+	1311,
+	1245,
+	1311,
+	1244,
+	1311,
+	1245,
+	1312,
+	1246,
+	1312,
+	1245,
+	1312,
+	1246,
+	1313,
+	1247,
+	1313,
+	1246,
+	1313,
+	1247,
+	1314,
+	1248,
+	1314,
+	1247,
+	1314,
+	1248,
+	1315,
+	1249,
+	1315,
+	1248,
+	1315,
+	1249,
+	1316,
+	1250,
+	1316,
+	1249,
+	1316,
+	1250,
+	1317,
+	1251,
+	1317,
+	1250,
+	1317,
+	1251,
+	1318,
+	1252,
+	1318,
+	1251,
+	1318,
+	1252,
+	1319,
+	1253,
+	1319,
+	1252,
+	1320,
+	1254,
+	1321,
+	1255,
+	1321,
+	1254,
+	1321,
+	1255,
+	1322,
+	1256,
+	1322,
+	1255,
+	1322,
+	1256,
+	1323,
+	1257,
+	1323,
+	1256,
+	1323,
+	1257,
+	1324,
+	1258,
+	1324,
+	1257,
+	1324,
+	1258,
+	1325,
+	1259,
+	1325,
+	1258,
+	1325,
+	1259,
+	1326,
+	1260,
+	1326,
+	1259,
+	1326,
+	1260,
+	1327,
+	1261,
+	1327,
+	1260,
+	1327,
+	1261,
+	1328,
+	1262,
+	1328,
+	1261,
+	1328,
+	1262,
+	1329,
+	1263,
+	1329,
+	1262,
+	1329,
+	1263,
+	1330,
+	1264,
+	1330,
+	1263,
+	1330,
+	1264,
+	1331,
+	1265,
+	1331,
+	1264,
+	1331,
+	1265,
+	1332,
+	1266,
+	1332,
+	1265,
+	1332,
+	1266,
+	1333,
+	1267,
+	1333,
+	1266,
+	1333,
+	1267,
+	1334,
+	1268,
+	1334,
+	1267,
+	1334,
+	1268,
+	1335,
+	1269,
+	1335,
+	1268,
+	1335,
+	1269,
+	1336,
+	1270,
+	1336,
+	1269,
+	1336,
+	1270,
+	1337,
+	1271,
+	1337,
+	1270,
+	1337,
+	1271,
+	1338,
+	1272,
+	1338,
+	1271,
+	1338,
+	1272,
+	1339,
+	1273,
+	1339,
+	1272,
+	1339,
+	1273,
+	1340,
+	1274,
+	1340,
+	1273,
+	1340,
+	1274,
+	1341,
+	1275,
+	1341,
+	1274,
+	1341,
+	1275,
+	1342,
+	1276,
+	1342,
+	1275,
+	1342,
+	1276,
+	1343,
+	1277,
+	1343,
+	1276,
+	1343,
+	1277,
+	1344,
+	1278,
+	1344,
+	1277,
+	1344,
+	1278,
+	1345,
+	1279,
+	1345,
+	1278,
+	1345,
+	1279,
+	1346,
+	1280,
+	1346,
+	1279,
+	1346,
+	1280,
+	1347,
+	1281,
+	1347,
+	1280,
+	1347,
+	1281,
+	1348,
+	1282,
+	1348,
+	1281,
+	1348,
+	1282,
+	1349,
+	1283,
+	1349,
+	1282,
+	1349,
+	1283,
+	1350,
+	1284,
+	1350,
+	1283,
+	1350,
+	1284,
+	1351,
+	1285,
+	1351,
+	1284,
+	1351,
+	1285,
+	1352,
+	1286,
+	1352,
+	1285,
+	1352,
+	1286,
+	1353,
+	1287,
+	1353,
+	1286,
+	1353,
+	1287,
+	1354,
+	1288,
+	1354,
+	1287,
+	1354,
+	1288,
+	1355,
+	1289,
+	1355,
+	1288,
+	1355,
+	1289,
+	1356,
+	1290,
+	1356,
+	1289,
+	1356,
+	1290,
+	1357,
+	1291,
+	1357,
+	1290,
+	1357,
+	1291,
+	1358,
+	1292,
+	1358,
+	1291,
+	1358,
+	1292,
+	1359,
+	1293,
+	1359,
+	1292,
+	1359,
+	1293,
+	1360,
+	1294,
+	1360,
+	1293,
+	1360,
+	1294,
+	1361,
+	1295,
+	1361,
+	1294,
+	1361,
+	1295,
+	1362,
+	1296,
+	1362,
+	1295,
+	1362,
+	1296,
+	1363,
+	1297,
+	1363,
+	1296,
+	1363,
+	1297,
+	1364,
+	1298,
+	1364,
+	1297,
+	1364,
+	1298,
+	1365,
+	1299,
+	1365,
+	1298,
+	1365,
+	1299,
+	1366,
+	1300,
+	1366,
+	1299,
+	1366,
+	1300,
+	1367,
+	1301,
+	1367,
+	1300,
+	1367,
+	1301,
+	1368,
+	1302,
+	1368,
+	1301,
+	1368,
+	1302,
+	1369,
+	1303,
+	1369,
+	1302,
+	1369,
+	1303,
+	1370,
+	1304,
+	1370,
+	1303,
+	1370,
+	1304,
+	1371,
+	1305,
+	1371,
+	1304,
+	1371,
+	1305,
+	1372,
+	1306,
+	1372,
+	1305,
+	1372,
+	1306,
+	1373,
+	1307,
+	1373,
+	1306,
+	1373,
+	1307,
+	1374,
+	1308,
+	1374,
+	1307,
+	1374,
+	1308,
+	1375,
+	1309,
+	1375,
+	1308,
+	1375,
+	1309,
+	1376,
+	1310,
+	1376,
+	1309,
+	1376,
+	1310,
+	1377,
+	1311,
+	1377,
+	1310,
+	1377,
+	1311,
+	1378,
+	1312,
+	1378,
+	1311,
+	1378,
+	1312,
+	1379,
+	1313,
+	1379,
+	1312,
+	1379,
+	1313,
+	1380,
+	1314,
+	1380,
+	1313,
+	1380,
+	1314,
+	1381,
+	1315,
+	1381,
+	1314,
+	1381,
+	1315,
+	1382,
+	1316,
+	1382,
+	1315,
+	1382,
+	1316,
+	1383,
+	1317,
+	1383,
+	1316,
+	1383,
+	1317,
+	1384,
+	1318,
+	1384,
+	1317,
+	1384,
+	1318,
+	1385,
+	1319,
+	1385,
+	1318,
+	1386,
+	1320,
+	1387,
+	1321,
+	1387,
+	1320,
+	1387,
+	1321,
+	1388,
+	1322,
+	1388,
+	1321,
+	1388,
+	1322,
+	1389,
+	1323,
+	1389,
+	1322,
+	1389,
+	1323,
+	1390,
+	1324,
+	1390,
+	1323,
+	1390,
+	1324,
+	1391,
+	1325,
+	1391,
+	1324,
+	1391,
+	1325,
+	1392,
+	1326,
+	1392,
+	1325,
+	1392,
+	1326,
+	1393,
+	1327,
+	1393,
+	1326,
+	1393,
+	1327,
+	1394,
+	1328,
+	1394,
+	1327,
+	1394,
+	1328,
+	1395,
+	1329,
+	1395,
+	1328,
+	1395,
+	1329,
+	1396,
+	1330,
+	1396,
+	1329,
+	1396,
+	1330,
+	1397,
+	1331,
+	1397,
+	1330,
+	1397,
+	1331,
+	1398,
+	1332,
+	1398,
+	1331,
+	1398,
+	1332,
+	1399,
+	1333,
+	1399,
+	1332,
+	1399,
+	1333,
+	1400,
+	1334,
+	1400,
+	1333,
+	1400,
+	1334,
+	1401,
+	1335,
+	1401,
+	1334,
+	1401,
+	1335,
+	1402,
+	1336,
+	1402,
+	1335,
+	1402,
+	1336,
+	1403,
+	1337,
+	1403,
+	1336,
+	1403,
+	1337,
+	1404,
+	1338,
+	1404,
+	1337,
+	1404,
+	1338,
+	1405,
+	1339,
+	1405,
+	1338,
+	1405,
+	1339,
+	1406,
+	1340,
+	1406,
+	1339,
+	1406,
+	1340,
+	1407,
+	1341,
+	1407,
+	1340,
+	1407,
+	1341,
+	1408,
+	1342,
+	1408,
+	1341,
+	1408,
+	1342,
+	1409,
+	1343,
+	1409,
+	1342,
+	1409,
+	1343,
+	1410,
+	1344,
+	1410,
+	1343,
+	1410,
+	1344,
+	1411,
+	1345,
+	1411,
+	1344,
+	1411,
+	1345,
+	1412,
+	1346,
+	1412,
+	1345,
+	1412,
+	1346,
+	1413,
+	1347,
+	1413,
+	1346,
+	1413,
+	1347,
+	1414,
+	1348,
+	1414,
+	1347,
+	1414,
+	1348,
+	1415,
+	1349,
+	1415,
+	1348,
+	1415,
+	1349,
+	1416,
+	1350,
+	1416,
+	1349,
+	1416,
+	1350,
+	1417,
+	1351,
+	1417,
+	1350,
+	1417,
+	1351,
+	1418,
+	1352,
+	1418,
+	1351,
+	1418,
+	1352,
+	1419,
+	1353,
+	1419,
+	1352,
+	1419,
+	1353,
+	1420,
+	1354,
+	1420,
+	1353,
+	1420,
+	1354,
+	1421,
+	1355,
+	1421,
+	1354,
+	1421,
+	1355,
+	1422,
+	1356,
+	1422,
+	1355,
+	1422,
+	1356,
+	1423,
+	1357,
+	1423,
+	1356,
+	1423,
+	1357,
+	1424,
+	1358,
+	1424,
+	1357,
+	1424,
+	1358,
+	1425,
+	1359,
+	1425,
+	1358,
+	1425,
+	1359,
+	1426,
+	1360,
+	1426,
+	1359,
+	1426,
+	1360,
+	1427,
+	1361,
+	1427,
+	1360,
+	1427,
+	1361,
+	1428,
+	1362,
+	1428,
+	1361,
+	1428,
+	1362,
+	1429,
+	1363,
+	1429,
+	1362,
+	1429,
+	1363,
+	1430,
+	1364,
+	1430,
+	1363,
+	1430,
+	1364,
+	1431,
+	1365,
+	1431,
+	1364,
+	1431,
+	1365,
+	1432,
+	1366,
+	1432,
+	1365,
+	1432,
+	1366,
+	1433,
+	1367,
+	1433,
+	1366,
+	1433,
+	1367,
+	1434,
+	1368,
+	1434,
+	1367,
+	1434,
+	1368,
+	1435,
+	1369,
+	1435,
+	1368,
+	1435,
+	1369,
+	1436,
+	1370,
+	1436,
+	1369,
+	1436,
+	1370,
+	1437,
+	1371,
+	1437,
+	1370,
+	1437,
+	1371,
+	1438,
+	1372,
+	1438,
+	1371,
+	1438,
+	1372,
+	1439,
+	1373,
+	1439,
+	1372,
+	1439,
+	1373,
+	1440,
+	1374,
+	1440,
+	1373,
+	1440,
+	1374,
+	1441,
+	1375,
+	1441,
+	1374,
+	1441,
+	1375,
+	1442,
+	1376,
+	1442,
+	1375,
+	1442,
+	1376,
+	1443,
+	1377,
+	1443,
+	1376,
+	1443,
+	1377,
+	1444,
+	1378,
+	1444,
+	1377,
+	1444,
+	1378,
+	1445,
+	1379,
+	1445,
+	1378,
+	1445,
+	1379,
+	1446,
+	1380,
+	1446,
+	1379,
+	1446,
+	1380,
+	1447,
+	1381,
+	1447,
+	1380,
+	1447,
+	1381,
+	1448,
+	1382,
+	1448,
+	1381,
+	1448,
+	1382,
+	1449,
+	1383,
+	1449,
+	1382,
+	1449,
+	1383,
+	1450,
+	1384,
+	1450,
+	1383,
+	1450,
+	1384,
+	1451,
+	1385,
+	1451,
+	1384,
+	1452,
+	1386,
+	1453,
+	1387,
+	1453,
+	1386,
+	1453,
+	1387,
+	1454,
+	1388,
+	1454,
+	1387,
+	1454,
+	1388,
+	1455,
+	1389,
+	1455,
+	1388,
+	1455,
+	1389,
+	1456,
+	1390,
+	1456,
+	1389,
+	1456,
+	1390,
+	1457,
+	1391,
+	1457,
+	1390,
+	1457,
+	1391,
+	1458,
+	1392,
+	1458,
+	1391,
+	1458,
+	1392,
+	1459,
+	1393,
+	1459,
+	1392,
+	1459,
+	1393,
+	1460,
+	1394,
+	1460,
+	1393,
+	1460,
+	1394,
+	1461,
+	1395,
+	1461,
+	1394,
+	1461,
+	1395,
+	1462,
+	1396,
+	1462,
+	1395,
+	1462,
+	1396,
+	1463,
+	1397,
+	1463,
+	1396,
+	1463,
+	1397,
+	1464,
+	1398,
+	1464,
+	1397,
+	1464,
+	1398,
+	1465,
+	1399,
+	1465,
+	1398,
+	1465,
+	1399,
+	1466,
+	1400,
+	1466,
+	1399,
+	1466,
+	1400,
+	1467,
+	1401,
+	1467,
+	1400,
+	1467,
+	1401,
+	1468,
+	1402,
+	1468,
+	1401,
+	1468,
+	1402,
+	1469,
+	1403,
+	1469,
+	1402,
+	1469,
+	1403,
+	1470,
+	1404,
+	1470,
+	1403,
+	1470,
+	1404,
+	1471,
+	1405,
+	1471,
+	1404,
+	1471,
+	1405,
+	1472,
+	1406,
+	1472,
+	1405,
+	1472,
+	1406,
+	1473,
+	1407,
+	1473,
+	1406,
+	1473,
+	1407,
+	1474,
+	1408,
+	1474,
+	1407,
+	1474,
+	1408,
+	1475,
+	1409,
+	1475,
+	1408,
+	1475,
+	1409,
+	1476,
+	1410,
+	1476,
+	1409,
+	1476,
+	1410,
+	1477,
+	1411,
+	1477,
+	1410,
+	1477,
+	1411,
+	1478,
+	1412,
+	1478,
+	1411,
+	1478,
+	1412,
+	1479,
+	1413,
+	1479,
+	1412,
+	1479,
+	1413,
+	1480,
+	1414,
+	1480,
+	1413,
+	1480,
+	1414,
+	1481,
+	1415,
+	1481,
+	1414,
+	1481,
+	1415,
+	1482,
+	1416,
+	1482,
+	1415,
+	1482,
+	1416,
+	1483,
+	1417,
+	1483,
+	1416,
+	1483,
+	1417,
+	1484,
+	1418,
+	1484,
+	1417,
+	1484,
+	1418,
+	1485,
+	1419,
+	1485,
+	1418,
+	1485,
+	1419,
+	1486,
+	1420,
+	1486,
+	1419,
+	1486,
+	1420,
+	1487,
+	1421,
+	1487,
+	1420,
+	1487,
+	1421,
+	1488,
+	1422,
+	1488,
+	1421,
+	1488,
+	1422,
+	1489,
+	1423,
+	1489,
+	1422,
+	1489,
+	1423,
+	1490,
+	1424,
+	1490,
+	1423,
+	1490,
+	1424,
+	1491,
+	1425,
+	1491,
+	1424,
+	1491,
+	1425,
+	1492,
+	1426,
+	1492,
+	1425,
+	1492,
+	1426,
+	1493,
+	1427,
+	1493,
+	1426,
+	1493,
+	1427,
+	1494,
+	1428,
+	1494,
+	1427,
+	1494,
+	1428,
+	1495,
+	1429,
+	1495,
+	1428,
+	1495,
+	1429,
+	1496,
+	1430,
+	1496,
+	1429,
+	1496,
+	1430,
+	1497,
+	1431,
+	1497,
+	1430,
+	1497,
+	1431,
+	1498,
+	1432,
+	1498,
+	1431,
+	1498,
+	1432,
+	1499,
+	1433,
+	1499,
+	1432,
+	1499,
+	1433,
+	1500,
+	1434,
+	1500,
+	1433,
+	1500,
+	1434,
+	1501,
+	1435,
+	1501,
+	1434,
+	1501,
+	1435,
+	1502,
+	1436,
+	1502,
+	1435,
+	1502,
+	1436,
+	1503,
+	1437,
+	1503,
+	1436,
+	1503,
+	1437,
+	1504,
+	1438,
+	1504,
+	1437,
+	1504,
+	1438,
+	1505,
+	1439,
+	1505,
+	1438,
+	1505,
+	1439,
+	1506,
+	1440,
+	1506,
+	1439,
+	1506,
+	1440,
+	1507,
+	1441,
+	1507,
+	1440,
+	1507,
+	1441,
+	1508,
+	1442,
+	1508,
+	1441,
+	1508,
+	1442,
+	1509,
+	1443,
+	1509,
+	1442,
+	1509,
+	1443,
+	1510,
+	1444,
+	1510,
+	1443,
+	1510,
+	1444,
+	1511,
+	1445,
+	1511,
+	1444,
+	1511,
+	1445,
+	1512,
+	1446,
+	1512,
+	1445,
+	1512,
+	1446,
+	1513,
+	1447,
+	1513,
+	1446,
+	1513,
+	1447,
+	1514,
+	1448,
+	1514,
+	1447,
+	1514,
+	1448,
+	1515,
+	1449,
+	1515,
+	1448,
+	1515,
+	1449,
+	1516,
+	1450,
+	1516,
+	1449,
+	1516,
+	1450,
+	1517,
+	1451,
+	1517,
+	1450,
+	1518,
+	1452,
+	1519,
+	1453,
+	1519,
+	1452,
+	1519,
+	1453,
+	1520,
+	1454,
+	1520,
+	1453,
+	1520,
+	1454,
+	1521,
+	1455,
+	1521,
+	1454,
+	1521,
+	1455,
+	1522,
+	1456,
+	1522,
+	1455,
+	1522,
+	1456,
+	1523,
+	1457,
+	1523,
+	1456,
+	1523,
+	1457,
+	1524,
+	1458,
+	1524,
+	1457,
+	1524,
+	1458,
+	1525,
+	1459,
+	1525,
+	1458,
+	1525,
+	1459,
+	1526,
+	1460,
+	1526,
+	1459,
+	1526,
+	1460,
+	1527,
+	1461,
+	1527,
+	1460,
+	1527,
+	1461,
+	1528,
+	1462,
+	1528,
+	1461,
+	1528,
+	1462,
+	1529,
+	1463,
+	1529,
+	1462,
+	1529,
+	1463,
+	1530,
+	1464,
+	1530,
+	1463,
+	1530,
+	1464,
+	1531,
+	1465,
+	1531,
+	1464,
+	1531,
+	1465,
+	1532,
+	1466,
+	1532,
+	1465,
+	1532,
+	1466,
+	1533,
+	1467,
+	1533,
+	1466,
+	1533,
+	1467,
+	1534,
+	1468,
+	1534,
+	1467,
+	1534,
+	1468,
+	1535,
+	1469,
+	1535,
+	1468,
+	1535,
+	1469,
+	1536,
+	1470,
+	1536,
+	1469,
+	1536,
+	1470,
+	1537,
+	1471,
+	1537,
+	1470,
+	1537,
+	1471,
+	1538,
+	1472,
+	1538,
+	1471,
+	1538,
+	1472,
+	1539,
+	1473,
+	1539,
+	1472,
+	1539,
+	1473,
+	1540,
+	1474,
+	1540,
+	1473,
+	1540,
+	1474,
+	1541,
+	1475,
+	1541,
+	1474,
+	1541,
+	1475,
+	1542,
+	1476,
+	1542,
+	1475,
+	1542,
+	1476,
+	1543,
+	1477,
+	1543,
+	1476,
+	1543,
+	1477,
+	1544,
+	1478,
+	1544,
+	1477,
+	1544,
+	1478,
+	1545,
+	1479,
+	1545,
+	1478,
+	1545,
+	1479,
+	1546,
+	1480,
+	1546,
+	1479,
+	1546,
+	1480,
+	1547,
+	1481,
+	1547,
+	1480,
+	1547,
+	1481,
+	1548,
+	1482,
+	1548,
+	1481,
+	1548,
+	1482,
+	1549,
+	1483,
+	1549,
+	1482,
+	1549,
+	1483,
+	1550,
+	1484,
+	1550,
+	1483,
+	1550,
+	1484,
+	1551,
+	1485,
+	1551,
+	1484,
+	1551,
+	1485,
+	1552,
+	1486,
+	1552,
+	1485,
+	1552,
+	1486,
+	1553,
+	1487,
+	1553,
+	1486,
+	1553,
+	1487,
+	1554,
+	1488,
+	1554,
+	1487,
+	1554,
+	1488,
+	1555,
+	1489,
+	1555,
+	1488,
+	1555,
+	1489,
+	1556,
+	1490,
+	1556,
+	1489,
+	1556,
+	1490,
+	1557,
+	1491,
+	1557,
+	1490,
+	1557,
+	1491,
+	1558,
+	1492,
+	1558,
+	1491,
+	1558,
+	1492,
+	1559,
+	1493,
+	1559,
+	1492,
+	1559,
+	1493,
+	1560,
+	1494,
+	1560,
+	1493,
+	1560,
+	1494,
+	1561,
+	1495,
+	1561,
+	1494,
+	1561,
+	1495,
+	1562,
+	1496,
+	1562,
+	1495,
+	1562,
+	1496,
+	1563,
+	1497,
+	1563,
+	1496,
+	1563,
+	1497,
+	1564,
+	1498,
+	1564,
+	1497,
+	1564,
+	1498,
+	1565,
+	1499,
+	1565,
+	1498,
+	1565,
+	1499,
+	1566,
+	1500,
+	1566,
+	1499,
+	1566,
+	1500,
+	1567,
+	1501,
+	1567,
+	1500,
+	1567,
+	1501,
+	1568,
+	1502,
+	1568,
+	1501,
+	1568,
+	1502,
+	1569,
+	1503,
+	1569,
+	1502,
+	1569,
+	1503,
+	1570,
+	1504,
+	1570,
+	1503,
+	1570,
+	1504,
+	1571,
+	1505,
+	1571,
+	1504,
+	1571,
+	1505,
+	1572,
+	1506,
+	1572,
+	1505,
+	1572,
+	1506,
+	1573,
+	1507,
+	1573,
+	1506,
+	1573,
+	1507,
+	1574,
+	1508,
+	1574,
+	1507,
+	1574,
+	1508,
+	1575,
+	1509,
+	1575,
+	1508,
+	1575,
+	1509,
+	1576,
+	1510,
+	1576,
+	1509,
+	1576,
+	1510,
+	1577,
+	1511,
+	1577,
+	1510,
+	1577,
+	1511,
+	1578,
+	1512,
+	1578,
+	1511,
+	1578,
+	1512,
+	1579,
+	1513,
+	1579,
+	1512,
+	1579,
+	1513,
+	1580,
+	1514,
+	1580,
+	1513,
+	1580,
+	1514,
+	1581,
+	1515,
+	1581,
+	1514,
+	1581,
+	1515,
+	1582,
+	1516,
+	1582,
+	1515,
+	1582,
+	1516,
+	1583,
+	1517,
+	1583,
+	1516,
+	1584,
+	1518,
+	1585,
+	1519,
+	1585,
+	1518,
+	1585,
+	1519,
+	1586,
+	1520,
+	1586,
+	1519,
+	1586,
+	1520,
+	1587,
+	1521,
+	1587,
+	1520,
+	1587,
+	1521,
+	1588,
+	1522,
+	1588,
+	1521,
+	1588,
+	1522,
+	1589,
+	1523,
+	1589,
+	1522,
+	1589,
+	1523,
+	1590,
+	1524,
+	1590,
+	1523,
+	1590,
+	1524,
+	1591,
+	1525,
+	1591,
+	1524,
+	1591,
+	1525,
+	1592,
+	1526,
+	1592,
+	1525,
+	1592,
+	1526,
+	1593,
+	1527,
+	1593,
+	1526,
+	1593,
+	1527,
+	1594,
+	1528,
+	1594,
+	1527,
+	1594,
+	1528,
+	1595,
+	1529,
+	1595,
+	1528,
+	1595,
+	1529,
+	1596,
+	1530,
+	1596,
+	1529,
+	1596,
+	1530,
+	1597,
+	1531,
+	1597,
+	1530,
+	1597,
+	1531,
+	1598,
+	1532,
+	1598,
+	1531,
+	1598,
+	1532,
+	1599,
+	1533,
+	1599,
+	1532,
+	1599,
+	1533,
+	1600,
+	1534,
+	1600,
+	1533,
+	1600,
+	1534,
+	1601,
+	1535,
+	1601,
+	1534,
+	1601,
+	1535,
+	1602,
+	1536,
+	1602,
+	1535,
+	1602,
+	1536,
+	1603,
+	1537,
+	1603,
+	1536,
+	1603,
+	1537,
+	1604,
+	1538,
+	1604,
+	1537,
+	1604,
+	1538,
+	1605,
+	1539,
+	1605,
+	1538,
+	1605,
+	1539,
+	1606,
+	1540,
+	1606,
+	1539,
+	1606,
+	1540,
+	1607,
+	1541,
+	1607,
+	1540,
+	1607,
+	1541,
+	1608,
+	1542,
+	1608,
+	1541,
+	1608,
+	1542,
+	1609,
+	1543,
+	1609,
+	1542,
+	1609,
+	1543,
+	1610,
+	1544,
+	1610,
+	1543,
+	1610,
+	1544,
+	1611,
+	1545,
+	1611,
+	1544,
+	1611,
+	1545,
+	1612,
+	1546,
+	1612,
+	1545,
+	1612,
+	1546,
+	1613,
+	1547,
+	1613,
+	1546,
+	1613,
+	1547,
+	1614,
+	1548,
+	1614,
+	1547,
+	1614,
+	1548,
+	1615,
+	1549,
+	1615,
+	1548,
+	1615,
+	1549,
+	1616,
+	1550,
+	1616,
+	1549,
+	1616,
+	1550,
+	1617,
+	1551,
+	1617,
+	1550,
+	1617,
+	1551,
+	1618,
+	1552,
+	1618,
+	1551,
+	1618,
+	1552,
+	1619,
+	1553,
+	1619,
+	1552,
+	1619,
+	1553,
+	1620,
+	1554,
+	1620,
+	1553,
+	1620,
+	1554,
+	1621,
+	1555,
+	1621,
+	1554,
+	1621,
+	1555,
+	1622,
+	1556,
+	1622,
+	1555,
+	1622,
+	1556,
+	1623,
+	1557,
+	1623,
+	1556,
+	1623,
+	1557,
+	1624,
+	1558,
+	1624,
+	1557,
+	1624,
+	1558,
+	1625,
+	1559,
+	1625,
+	1558,
+	1625,
+	1559,
+	1626,
+	1560,
+	1626,
+	1559,
+	1626,
+	1560,
+	1627,
+	1561,
+	1627,
+	1560,
+	1627,
+	1561,
+	1628,
+	1562,
+	1628,
+	1561,
+	1628,
+	1562,
+	1629,
+	1563,
+	1629,
+	1562,
+	1629,
+	1563,
+	1630,
+	1564,
+	1630,
+	1563,
+	1630,
+	1564,
+	1631,
+	1565,
+	1631,
+	1564,
+	1631,
+	1565,
+	1632,
+	1566,
+	1632,
+	1565,
+	1632,
+	1566,
+	1633,
+	1567,
+	1633,
+	1566,
+	1633,
+	1567,
+	1634,
+	1568,
+	1634,
+	1567,
+	1634,
+	1568,
+	1635,
+	1569,
+	1635,
+	1568,
+	1635,
+	1569,
+	1636,
+	1570,
+	1636,
+	1569,
+	1636,
+	1570,
+	1637,
+	1571,
+	1637,
+	1570,
+	1637,
+	1571,
+	1638,
+	1572,
+	1638,
+	1571,
+	1638,
+	1572,
+	1639,
+	1573,
+	1639,
+	1572,
+	1639,
+	1573,
+	1640,
+	1574,
+	1640,
+	1573,
+	1640,
+	1574,
+	1641,
+	1575,
+	1641,
+	1574,
+	1641,
+	1575,
+	1642,
+	1576,
+	1642,
+	1575,
+	1642,
+	1576,
+	1643,
+	1577,
+	1643,
+	1576,
+	1643,
+	1577,
+	1644,
+	1578,
+	1644,
+	1577,
+	1644,
+	1578,
+	1645,
+	1579,
+	1645,
+	1578,
+	1645,
+	1579,
+	1646,
+	1580,
+	1646,
+	1579,
+	1646,
+	1580,
+	1647,
+	1581,
+	1647,
+	1580,
+	1647,
+	1581,
+	1648,
+	1582,
+	1648,
+	1581,
+	1648,
+	1582,
+	1649,
+	1583,
+	1649,
+	1582,
+	1650,
+	1584,
+	1651,
+	1585,
+	1651,
+	1584,
+	1651,
+	1585,
+	1652,
+	1586,
+	1652,
+	1585,
+	1652,
+	1586,
+	1653,
+	1587,
+	1653,
+	1586,
+	1653,
+	1587,
+	1654,
+	1588,
+	1654,
+	1587,
+	1654,
+	1588,
+	1655,
+	1589,
+	1655,
+	1588,
+	1655,
+	1589,
+	1656,
+	1590,
+	1656,
+	1589,
+	1656,
+	1590,
+	1657,
+	1591,
+	1657,
+	1590,
+	1657,
+	1591,
+	1658,
+	1592,
+	1658,
+	1591,
+	1658,
+	1592,
+	1659,
+	1593,
+	1659,
+	1592,
+	1659,
+	1593,
+	1660,
+	1594,
+	1660,
+	1593,
+	1660,
+	1594,
+	1661,
+	1595,
+	1661,
+	1594,
+	1661,
+	1595,
+	1662,
+	1596,
+	1662,
+	1595,
+	1662,
+	1596,
+	1663,
+	1597,
+	1663,
+	1596,
+	1663,
+	1597,
+	1664,
+	1598,
+	1664,
+	1597,
+	1664,
+	1598,
+	1665,
+	1599,
+	1665,
+	1598,
+	1665,
+	1599,
+	1666,
+	1600,
+	1666,
+	1599,
+	1666,
+	1600,
+	1667,
+	1601,
+	1667,
+	1600,
+	1667,
+	1601,
+	1668,
+	1602,
+	1668,
+	1601,
+	1668,
+	1602,
+	1669,
+	1603,
+	1669,
+	1602,
+	1669,
+	1603,
+	1670,
+	1604,
+	1670,
+	1603,
+	1670,
+	1604,
+	1671,
+	1605,
+	1671,
+	1604,
+	1671,
+	1605,
+	1672,
+	1606,
+	1672,
+	1605,
+	1672,
+	1606,
+	1673,
+	1607,
+	1673,
+	1606,
+	1673,
+	1607,
+	1674,
+	1608,
+	1674,
+	1607,
+	1674,
+	1608,
+	1675,
+	1609,
+	1675,
+	1608,
+	1675,
+	1609,
+	1676,
+	1610,
+	1676,
+	1609,
+	1676,
+	1610,
+	1677,
+	1611,
+	1677,
+	1610,
+	1677,
+	1611,
+	1678,
+	1612,
+	1678,
+	1611,
+	1678,
+	1612,
+	1679,
+	1613,
+	1679,
+	1612,
+	1679,
+	1613,
+	1680,
+	1614,
+	1680,
+	1613,
+	1680,
+	1614,
+	1681,
+	1615,
+	1681,
+	1614,
+	1681,
+	1615,
+	1682,
+	1616,
+	1682,
+	1615,
+	1682,
+	1616,
+	1683,
+	1617,
+	1683,
+	1616,
+	1683,
+	1617,
+	1684,
+	1618,
+	1684,
+	1617,
+	1684,
+	1618,
+	1685,
+	1619,
+	1685,
+	1618,
+	1685,
+	1619,
+	1686,
+	1620,
+	1686,
+	1619,
+	1686,
+	1620,
+	1687,
+	1621,
+	1687,
+	1620,
+	1687,
+	1621,
+	1688,
+	1622,
+	1688,
+	1621,
+	1688,
+	1622,
+	1689,
+	1623,
+	1689,
+	1622,
+	1689,
+	1623,
+	1690,
+	1624,
+	1690,
+	1623,
+	1690,
+	1624,
+	1691,
+	1625,
+	1691,
+	1624,
+	1691,
+	1625,
+	1692,
+	1626,
+	1692,
+	1625,
+	1692,
+	1626,
+	1693,
+	1627,
+	1693,
+	1626,
+	1693,
+	1627,
+	1694,
+	1628,
+	1694,
+	1627,
+	1694,
+	1628,
+	1695,
+	1629,
+	1695,
+	1628,
+	1695,
+	1629,
+	1696,
+	1630,
+	1696,
+	1629,
+	1696,
+	1630,
+	1697,
+	1631,
+	1697,
+	1630,
+	1697,
+	1631,
+	1698,
+	1632,
+	1698,
+	1631,
+	1698,
+	1632,
+	1699,
+	1633,
+	1699,
+	1632,
+	1699,
+	1633,
+	1700,
+	1634,
+	1700,
+	1633,
+	1700,
+	1634,
+	1701,
+	1635,
+	1701,
+	1634,
+	1701,
+	1635,
+	1702,
+	1636,
+	1702,
+	1635,
+	1702,
+	1636,
+	1703,
+	1637,
+	1703,
+	1636,
+	1703,
+	1637,
+	1704,
+	1638,
+	1704,
+	1637,
+	1704,
+	1638,
+	1705,
+	1639,
+	1705,
+	1638,
+	1705,
+	1639,
+	1706,
+	1640,
+	1706,
+	1639,
+	1706,
+	1640,
+	1707,
+	1641,
+	1707,
+	1640,
+	1707,
+	1641,
+	1708,
+	1642,
+	1708,
+	1641,
+	1708,
+	1642,
+	1709,
+	1643,
+	1709,
+	1642,
+	1709,
+	1643,
+	1710,
+	1644,
+	1710,
+	1643,
+	1710,
+	1644,
+	1711,
+	1645,
+	1711,
+	1644,
+	1711,
+	1645,
+	1712,
+	1646,
+	1712,
+	1645,
+	1712,
+	1646,
+	1713,
+	1647,
+	1713,
+	1646,
+	1713,
+	1647,
+	1714,
+	1648,
+	1714,
+	1647,
+	1714,
+	1648,
+	1715,
+	1649,
+	1715,
+	1648,
+	1716,
+	1650,
+	1717,
+	1651,
+	1717,
+	1650,
+	1717,
+	1651,
+	1718,
+	1652,
+	1718,
+	1651,
+	1718,
+	1652,
+	1719,
+	1653,
+	1719,
+	1652,
+	1719,
+	1653,
+	1720,
+	1654,
+	1720,
+	1653,
+	1720,
+	1654,
+	1721,
+	1655,
+	1721,
+	1654,
+	1721,
+	1655,
+	1722,
+	1656,
+	1722,
+	1655,
+	1722,
+	1656,
+	1723,
+	1657,
+	1723,
+	1656,
+	1723,
+	1657,
+	1724,
+	1658,
+	1724,
+	1657,
+	1724,
+	1658,
+	1725,
+	1659,
+	1725,
+	1658,
+	1725,
+	1659,
+	1726,
+	1660,
+	1726,
+	1659,
+	1726,
+	1660,
+	1727,
+	1661,
+	1727,
+	1660,
+	1727,
+	1661,
+	1728,
+	1662,
+	1728,
+	1661,
+	1728,
+	1662,
+	1729,
+	1663,
+	1729,
+	1662,
+	1729,
+	1663,
+	1730,
+	1664,
+	1730,
+	1663,
+	1730,
+	1664,
+	1731,
+	1665,
+	1731,
+	1664,
+	1731,
+	1665,
+	1732,
+	1666,
+	1732,
+	1665,
+	1732,
+	1666,
+	1733,
+	1667,
+	1733,
+	1666,
+	1733,
+	1667,
+	1734,
+	1668,
+	1734,
+	1667,
+	1734,
+	1668,
+	1735,
+	1669,
+	1735,
+	1668,
+	1735,
+	1669,
+	1736,
+	1670,
+	1736,
+	1669,
+	1736,
+	1670,
+	1737,
+	1671,
+	1737,
+	1670,
+	1737,
+	1671,
+	1738,
+	1672,
+	1738,
+	1671,
+	1738,
+	1672,
+	1739,
+	1673,
+	1739,
+	1672,
+	1739,
+	1673,
+	1740,
+	1674,
+	1740,
+	1673,
+	1740,
+	1674,
+	1741,
+	1675,
+	1741,
+	1674,
+	1741,
+	1675,
+	1742,
+	1676,
+	1742,
+	1675,
+	1742,
+	1676,
+	1743,
+	1677,
+	1743,
+	1676,
+	1743,
+	1677,
+	1744,
+	1678,
+	1744,
+	1677,
+	1744,
+	1678,
+	1745,
+	1679,
+	1745,
+	1678,
+	1745,
+	1679,
+	1746,
+	1680,
+	1746,
+	1679,
+	1746,
+	1680,
+	1747,
+	1681,
+	1747,
+	1680,
+	1747,
+	1681,
+	1748,
+	1682,
+	1748,
+	1681,
+	1748,
+	1682,
+	1749,
+	1683,
+	1749,
+	1682,
+	1749,
+	1683,
+	1750,
+	1684,
+	1750,
+	1683,
+	1750,
+	1684,
+	1751,
+	1685,
+	1751,
+	1684,
+	1751,
+	1685,
+	1752,
+	1686,
+	1752,
+	1685,
+	1752,
+	1686,
+	1753,
+	1687,
+	1753,
+	1686,
+	1753,
+	1687,
+	1754,
+	1688,
+	1754,
+	1687,
+	1754,
+	1688,
+	1755,
+	1689,
+	1755,
+	1688,
+	1755,
+	1689,
+	1756,
+	1690,
+	1756,
+	1689,
+	1756,
+	1690,
+	1757,
+	1691,
+	1757,
+	1690,
+	1757,
+	1691,
+	1758,
+	1692,
+	1758,
+	1691,
+	1758,
+	1692,
+	1759,
+	1693,
+	1759,
+	1692,
+	1759,
+	1693,
+	1760,
+	1694,
+	1760,
+	1693,
+	1760,
+	1694,
+	1761,
+	1695,
+	1761,
+	1694,
+	1761,
+	1695,
+	1762,
+	1696,
+	1762,
+	1695,
+	1762,
+	1696,
+	1763,
+	1697,
+	1763,
+	1696,
+	1763,
+	1697,
+	1764,
+	1698,
+	1764,
+	1697,
+	1764,
+	1698,
+	1765,
+	1699,
+	1765,
+	1698,
+	1765,
+	1699,
+	1766,
+	1700,
+	1766,
+	1699,
+	1766,
+	1700,
+	1767,
+	1701,
+	1767,
+	1700,
+	1767,
+	1701,
+	1768,
+	1702,
+	1768,
+	1701,
+	1768,
+	1702,
+	1769,
+	1703,
+	1769,
+	1702,
+	1769,
+	1703,
+	1770,
+	1704,
+	1770,
+	1703,
+	1770,
+	1704,
+	1771,
+	1705,
+	1771,
+	1704,
+	1771,
+	1705,
+	1772,
+	1706,
+	1772,
+	1705,
+	1772,
+	1706,
+	1773,
+	1707,
+	1773,
+	1706,
+	1773,
+	1707,
+	1774,
+	1708,
+	1774,
+	1707,
+	1774,
+	1708,
+	1775,
+	1709,
+	1775,
+	1708,
+	1775,
+	1709,
+	1776,
+	1710,
+	1776,
+	1709,
+	1776,
+	1710,
+	1777,
+	1711,
+	1777,
+	1710,
+	1777,
+	1711,
+	1778,
+	1712,
+	1778,
+	1711,
+	1778,
+	1712,
+	1779,
+	1713,
+	1779,
+	1712,
+	1779,
+	1713,
+	1780,
+	1714,
+	1780,
+	1713,
+	1780,
+	1714,
+	1781,
+	1715,
+	1781,
+	1714,
+	1782,
+	1716,
+	1783,
+	1717,
+	1783,
+	1716,
+	1783,
+	1717,
+	1784,
+	1718,
+	1784,
+	1717,
+	1784,
+	1718,
+	1785,
+	1719,
+	1785,
+	1718,
+	1785,
+	1719,
+	1786,
+	1720,
+	1786,
+	1719,
+	1786,
+	1720,
+	1787,
+	1721,
+	1787,
+	1720,
+	1787,
+	1721,
+	1788,
+	1722,
+	1788,
+	1721,
+	1788,
+	1722,
+	1789,
+	1723,
+	1789,
+	1722,
+	1789,
+	1723,
+	1790,
+	1724,
+	1790,
+	1723,
+	1790,
+	1724,
+	1791,
+	1725,
+	1791,
+	1724,
+	1791,
+	1725,
+	1792,
+	1726,
+	1792,
+	1725,
+	1792,
+	1726,
+	1793,
+	1727,
+	1793,
+	1726,
+	1793,
+	1727,
+	1794,
+	1728,
+	1794,
+	1727,
+	1794,
+	1728,
+	1795,
+	1729,
+	1795,
+	1728,
+	1795,
+	1729,
+	1796,
+	1730,
+	1796,
+	1729,
+	1796,
+	1730,
+	1797,
+	1731,
+	1797,
+	1730,
+	1797,
+	1731,
+	1798,
+	1732,
+	1798,
+	1731,
+	1798,
+	1732,
+	1799,
+	1733,
+	1799,
+	1732,
+	1799,
+	1733,
+	1800,
+	1734,
+	1800,
+	1733,
+	1800,
+	1734,
+	1801,
+	1735,
+	1801,
+	1734,
+	1801,
+	1735,
+	1802,
+	1736,
+	1802,
+	1735,
+	1802,
+	1736,
+	1803,
+	1737,
+	1803,
+	1736,
+	1803,
+	1737,
+	1804,
+	1738,
+	1804,
+	1737,
+	1804,
+	1738,
+	1805,
+	1739,
+	1805,
+	1738,
+	1805,
+	1739,
+	1806,
+	1740,
+	1806,
+	1739,
+	1806,
+	1740,
+	1807,
+	1741,
+	1807,
+	1740,
+	1807,
+	1741,
+	1808,
+	1742,
+	1808,
+	1741,
+	1808,
+	1742,
+	1809,
+	1743,
+	1809,
+	1742,
+	1809,
+	1743,
+	1810,
+	1744,
+	1810,
+	1743,
+	1810,
+	1744,
+	1811,
+	1745,
+	1811,
+	1744,
+	1811,
+	1745,
+	1812,
+	1746,
+	1812,
+	1745,
+	1812,
+	1746,
+	1813,
+	1747,
+	1813,
+	1746,
+	1813,
+	1747,
+	1814,
+	1748,
+	1814,
+	1747,
+	1814,
+	1748,
+	1815,
+	1749,
+	1815,
+	1748,
+	1815,
+	1749,
+	1816,
+	1750,
+	1816,
+	1749,
+	1816,
+	1750,
+	1817,
+	1751,
+	1817,
+	1750,
+	1817,
+	1751,
+	1818,
+	1752,
+	1818,
+	1751,
+	1818,
+	1752,
+	1819,
+	1753,
+	1819,
+	1752,
+	1819,
+	1753,
+	1820,
+	1754,
+	1820,
+	1753,
+	1820,
+	1754,
+	1821,
+	1755,
+	1821,
+	1754,
+	1821,
+	1755,
+	1822,
+	1756,
+	1822,
+	1755,
+	1822,
+	1756,
+	1823,
+	1757,
+	1823,
+	1756,
+	1823,
+	1757,
+	1824,
+	1758,
+	1824,
+	1757,
+	1824,
+	1758,
+	1825,
+	1759,
+	1825,
+	1758,
+	1825,
+	1759,
+	1826,
+	1760,
+	1826,
+	1759,
+	1826,
+	1760,
+	1827,
+	1761,
+	1827,
+	1760,
+	1827,
+	1761,
+	1828,
+	1762,
+	1828,
+	1761,
+	1828,
+	1762,
+	1829,
+	1763,
+	1829,
+	1762,
+	1829,
+	1763,
+	1830,
+	1764,
+	1830,
+	1763,
+	1830,
+	1764,
+	1831,
+	1765,
+	1831,
+	1764,
+	1831,
+	1765,
+	1832,
+	1766,
+	1832,
+	1765,
+	1832,
+	1766,
+	1833,
+	1767,
+	1833,
+	1766,
+	1833,
+	1767,
+	1834,
+	1768,
+	1834,
+	1767,
+	1834,
+	1768,
+	1835,
+	1769,
+	1835,
+	1768,
+	1835,
+	1769,
+	1836,
+	1770,
+	1836,
+	1769,
+	1836,
+	1770,
+	1837,
+	1771,
+	1837,
+	1770,
+	1837,
+	1771,
+	1838,
+	1772,
+	1838,
+	1771,
+	1838,
+	1772,
+	1839,
+	1773,
+	1839,
+	1772,
+	1839,
+	1773,
+	1840,
+	1774,
+	1840,
+	1773,
+	1840,
+	1774,
+	1841,
+	1775,
+	1841,
+	1774,
+	1841,
+	1775,
+	1842,
+	1776,
+	1842,
+	1775,
+	1842,
+	1776,
+	1843,
+	1777,
+	1843,
+	1776,
+	1843,
+	1777,
+	1844,
+	1778,
+	1844,
+	1777,
+	1844,
+	1778,
+	1845,
+	1779,
+	1845,
+	1778,
+	1845,
+	1779,
+	1846,
+	1780,
+	1846,
+	1779,
+	1846,
+	1780,
+	1847,
+	1781,
+	1847,
+	1780,
+	1848,
+	1782,
+	1849,
+	1783,
+	1849,
+	1782,
+	1849,
+	1783,
+	1850,
+	1784,
+	1850,
+	1783,
+	1850,
+	1784,
+	1851,
+	1785,
+	1851,
+	1784,
+	1851,
+	1785,
+	1852,
+	1786,
+	1852,
+	1785,
+	1852,
+	1786,
+	1853,
+	1787,
+	1853,
+	1786,
+	1853,
+	1787,
+	1854,
+	1788,
+	1854,
+	1787,
+	1854,
+	1788,
+	1855,
+	1789,
+	1855,
+	1788,
+	1855,
+	1789,
+	1856,
+	1790,
+	1856,
+	1789,
+	1856,
+	1790,
+	1857,
+	1791,
+	1857,
+	1790,
+	1857,
+	1791,
+	1858,
+	1792,
+	1858,
+	1791,
+	1858,
+	1792,
+	1859,
+	1793,
+	1859,
+	1792,
+	1859,
+	1793,
+	1860,
+	1794,
+	1860,
+	1793,
+	1860,
+	1794,
+	1861,
+	1795,
+	1861,
+	1794,
+	1861,
+	1795,
+	1862,
+	1796,
+	1862,
+	1795,
+	1862,
+	1796,
+	1863,
+	1797,
+	1863,
+	1796,
+	1863,
+	1797,
+	1864,
+	1798,
+	1864,
+	1797,
+	1864,
+	1798,
+	1865,
+	1799,
+	1865,
+	1798,
+	1865,
+	1799,
+	1866,
+	1800,
+	1866,
+	1799,
+	1866,
+	1800,
+	1867,
+	1801,
+	1867,
+	1800,
+	1867,
+	1801,
+	1868,
+	1802,
+	1868,
+	1801,
+	1868,
+	1802,
+	1869,
+	1803,
+	1869,
+	1802,
+	1869,
+	1803,
+	1870,
+	1804,
+	1870,
+	1803,
+	1870,
+	1804,
+	1871,
+	1805,
+	1871,
+	1804,
+	1871,
+	1805,
+	1872,
+	1806,
+	1872,
+	1805,
+	1872,
+	1806,
+	1873,
+	1807,
+	1873,
+	1806,
+	1873,
+	1807,
+	1874,
+	1808,
+	1874,
+	1807,
+	1874,
+	1808,
+	1875,
+	1809,
+	1875,
+	1808,
+	1875,
+	1809,
+	1876,
+	1810,
+	1876,
+	1809,
+	1876,
+	1810,
+	1877,
+	1811,
+	1877,
+	1810,
+	1877,
+	1811,
+	1878,
+	1812,
+	1878,
+	1811,
+	1878,
+	1812,
+	1879,
+	1813,
+	1879,
+	1812,
+	1879,
+	1813,
+	1880,
+	1814,
+	1880,
+	1813,
+	1880,
+	1814,
+	1881,
+	1815,
+	1881,
+	1814,
+	1881,
+	1815,
+	1882,
+	1816,
+	1882,
+	1815,
+	1882,
+	1816,
+	1883,
+	1817,
+	1883,
+	1816,
+	1883,
+	1817,
+	1884,
+	1818,
+	1884,
+	1817,
+	1884,
+	1818,
+	1885,
+	1819,
+	1885,
+	1818,
+	1885,
+	1819,
+	1886,
+	1820,
+	1886,
+	1819,
+	1886,
+	1820,
+	1887,
+	1821,
+	1887,
+	1820,
+	1887,
+	1821,
+	1888,
+	1822,
+	1888,
+	1821,
+	1888,
+	1822,
+	1889,
+	1823,
+	1889,
+	1822,
+	1889,
+	1823,
+	1890,
+	1824,
+	1890,
+	1823,
+	1890,
+	1824,
+	1891,
+	1825,
+	1891,
+	1824,
+	1891,
+	1825,
+	1892,
+	1826,
+	1892,
+	1825,
+	1892,
+	1826,
+	1893,
+	1827,
+	1893,
+	1826,
+	1893,
+	1827,
+	1894,
+	1828,
+	1894,
+	1827,
+	1894,
+	1828,
+	1895,
+	1829,
+	1895,
+	1828,
+	1895,
+	1829,
+	1896,
+	1830,
+	1896,
+	1829,
+	1896,
+	1830,
+	1897,
+	1831,
+	1897,
+	1830,
+	1897,
+	1831,
+	1898,
+	1832,
+	1898,
+	1831,
+	1898,
+	1832,
+	1899,
+	1833,
+	1899,
+	1832,
+	1899,
+	1833,
+	1900,
+	1834,
+	1900,
+	1833,
+	1900,
+	1834,
+	1901,
+	1835,
+	1901,
+	1834,
+	1901,
+	1835,
+	1902,
+	1836,
+	1902,
+	1835,
+	1902,
+	1836,
+	1903,
+	1837,
+	1903,
+	1836,
+	1903,
+	1837,
+	1904,
+	1838,
+	1904,
+	1837,
+	1904,
+	1838,
+	1905,
+	1839,
+	1905,
+	1838,
+	1905,
+	1839,
+	1906,
+	1840,
+	1906,
+	1839,
+	1906,
+	1840,
+	1907,
+	1841,
+	1907,
+	1840,
+	1907,
+	1841,
+	1908,
+	1842,
+	1908,
+	1841,
+	1908,
+	1842,
+	1909,
+	1843,
+	1909,
+	1842,
+	1909,
+	1843,
+	1910,
+	1844,
+	1910,
+	1843,
+	1910,
+	1844,
+	1911,
+	1845,
+	1911,
+	1844,
+	1911,
+	1845,
+	1912,
+	1846,
+	1912,
+	1845,
+	1912,
+	1846,
+	1913,
+	1847,
+	1913,
+	1846,
+	1914,
+	1848,
+	1915,
+	1849,
+	1915,
+	1848,
+	1915,
+	1849,
+	1916,
+	1850,
+	1916,
+	1849,
+	1916,
+	1850,
+	1917,
+	1851,
+	1917,
+	1850,
+	1917,
+	1851,
+	1918,
+	1852,
+	1918,
+	1851,
+	1918,
+	1852,
+	1919,
+	1853,
+	1919,
+	1852,
+	1919,
+	1853,
+	1920,
+	1854,
+	1920,
+	1853,
+	1920,
+	1854,
+	1921,
+	1855,
+	1921,
+	1854,
+	1921,
+	1855,
+	1922,
+	1856,
+	1922,
+	1855,
+	1922,
+	1856,
+	1923,
+	1857,
+	1923,
+	1856,
+	1923,
+	1857,
+	1924,
+	1858,
+	1924,
+	1857,
+	1924,
+	1858,
+	1925,
+	1859,
+	1925,
+	1858,
+	1925,
+	1859,
+	1926,
+	1860,
+	1926,
+	1859,
+	1926,
+	1860,
+	1927,
+	1861,
+	1927,
+	1860,
+	1927,
+	1861,
+	1928,
+	1862,
+	1928,
+	1861,
+	1928,
+	1862,
+	1929,
+	1863,
+	1929,
+	1862,
+	1929,
+	1863,
+	1930,
+	1864,
+	1930,
+	1863,
+	1930,
+	1864,
+	1931,
+	1865,
+	1931,
+	1864,
+	1931,
+	1865,
+	1932,
+	1866,
+	1932,
+	1865,
+	1932,
+	1866,
+	1933,
+	1867,
+	1933,
+	1866,
+	1933,
+	1867,
+	1934,
+	1868,
+	1934,
+	1867,
+	1934,
+	1868,
+	1935,
+	1869,
+	1935,
+	1868,
+	1935,
+	1869,
+	1936,
+	1870,
+	1936,
+	1869,
+	1936,
+	1870,
+	1937,
+	1871,
+	1937,
+	1870,
+	1937,
+	1871,
+	1938,
+	1872,
+	1938,
+	1871,
+	1938,
+	1872,
+	1939,
+	1873,
+	1939,
+	1872,
+	1939,
+	1873,
+	1940,
+	1874,
+	1940,
+	1873,
+	1940,
+	1874,
+	1941,
+	1875,
+	1941,
+	1874,
+	1941,
+	1875,
+	1942,
+	1876,
+	1942,
+	1875,
+	1942,
+	1876,
+	1943,
+	1877,
+	1943,
+	1876,
+	1943,
+	1877,
+	1944,
+	1878,
+	1944,
+	1877,
+	1944,
+	1878,
+	1945,
+	1879,
+	1945,
+	1878,
+	1945,
+	1879,
+	1946,
+	1880,
+	1946,
+	1879,
+	1946,
+	1880,
+	1947,
+	1881,
+	1947,
+	1880,
+	1947,
+	1881,
+	1948,
+	1882,
+	1948,
+	1881,
+	1948,
+	1882,
+	1949,
+	1883,
+	1949,
+	1882,
+	1949,
+	1883,
+	1950,
+	1884,
+	1950,
+	1883,
+	1950,
+	1884,
+	1951,
+	1885,
+	1951,
+	1884,
+	1951,
+	1885,
+	1952,
+	1886,
+	1952,
+	1885,
+	1952,
+	1886,
+	1953,
+	1887,
+	1953,
+	1886,
+	1953,
+	1887,
+	1954,
+	1888,
+	1954,
+	1887,
+	1954,
+	1888,
+	1955,
+	1889,
+	1955,
+	1888,
+	1955,
+	1889,
+	1956,
+	1890,
+	1956,
+	1889,
+	1956,
+	1890,
+	1957,
+	1891,
+	1957,
+	1890,
+	1957,
+	1891,
+	1958,
+	1892,
+	1958,
+	1891,
+	1958,
+	1892,
+	1959,
+	1893,
+	1959,
+	1892,
+	1959,
+	1893,
+	1960,
+	1894,
+	1960,
+	1893,
+	1960,
+	1894,
+	1961,
+	1895,
+	1961,
+	1894,
+	1961,
+	1895,
+	1962,
+	1896,
+	1962,
+	1895,
+	1962,
+	1896,
+	1963,
+	1897,
+	1963,
+	1896,
+	1963,
+	1897,
+	1964,
+	1898,
+	1964,
+	1897,
+	1964,
+	1898,
+	1965,
+	1899,
+	1965,
+	1898,
+	1965,
+	1899,
+	1966,
+	1900,
+	1966,
+	1899,
+	1966,
+	1900,
+	1967,
+	1901,
+	1967,
+	1900,
+	1967,
+	1901,
+	1968,
+	1902,
+	1968,
+	1901,
+	1968,
+	1902,
+	1969,
+	1903,
+	1969,
+	1902,
+	1969,
+	1903,
+	1970,
+	1904,
+	1970,
+	1903,
+	1970,
+	1904,
+	1971,
+	1905,
+	1971,
+	1904,
+	1971,
+	1905,
+	1972,
+	1906,
+	1972,
+	1905,
+	1972,
+	1906,
+	1973,
+	1907,
+	1973,
+	1906,
+	1973,
+	1907,
+	1974,
+	1908,
+	1974,
+	1907,
+	1974,
+	1908,
+	1975,
+	1909,
+	1975,
+	1908,
+	1975,
+	1909,
+	1976,
+	1910,
+	1976,
+	1909,
+	1976,
+	1910,
+	1977,
+	1911,
+	1977,
+	1910,
+	1977,
+	1911,
+	1978,
+	1912,
+	1978,
+	1911,
+	1978,
+	1912,
+	1979,
+	1913,
+	1979,
+	1912,
+	1980,
+	1914,
+	1981,
+	1915,
+	1981,
+	1914,
+	1981,
+	1915,
+	1982,
+	1916,
+	1982,
+	1915,
+	1982,
+	1916,
+	1983,
+	1917,
+	1983,
+	1916,
+	1983,
+	1917,
+	1984,
+	1918,
+	1984,
+	1917,
+	1984,
+	1918,
+	1985,
+	1919,
+	1985,
+	1918,
+	1985,
+	1919,
+	1986,
+	1920,
+	1986,
+	1919,
+	1986,
+	1920,
+	1987,
+	1921,
+	1987,
+	1920,
+	1987,
+	1921,
+	1988,
+	1922,
+	1988,
+	1921,
+	1988,
+	1922,
+	1989,
+	1923,
+	1989,
+	1922,
+	1989,
+	1923,
+	1990,
+	1924,
+	1990,
+	1923,
+	1990,
+	1924,
+	1991,
+	1925,
+	1991,
+	1924,
+	1991,
+	1925,
+	1992,
+	1926,
+	1992,
+	1925,
+	1992,
+	1926,
+	1993,
+	1927,
+	1993,
+	1926,
+	1993,
+	1927,
+	1994,
+	1928,
+	1994,
+	1927,
+	1994,
+	1928,
+	1995,
+	1929,
+	1995,
+	1928,
+	1995,
+	1929,
+	1996,
+	1930,
+	1996,
+	1929,
+	1996,
+	1930,
+	1997,
+	1931,
+	1997,
+	1930,
+	1997,
+	1931,
+	1998,
+	1932,
+	1998,
+	1931,
+	1998,
+	1932,
+	1999,
+	1933,
+	1999,
+	1932,
+	1999,
+	1933,
+	2000,
+	1934,
+	2000,
+	1933,
+	2000,
+	1934,
+	2001,
+	1935,
+	2001,
+	1934,
+	2001,
+	1935,
+	2002,
+	1936,
+	2002,
+	1935,
+	2002,
+	1936,
+	2003,
+	1937,
+	2003,
+	1936,
+	2003,
+	1937,
+	2004,
+	1938,
+	2004,
+	1937,
+	2004,
+	1938,
+	2005,
+	1939,
+	2005,
+	1938,
+	2005,
+	1939,
+	2006,
+	1940,
+	2006,
+	1939,
+	2006,
+	1940,
+	2007,
+	1941,
+	2007,
+	1940,
+	2007,
+	1941,
+	2008,
+	1942,
+	2008,
+	1941,
+	2008,
+	1942,
+	2009,
+	1943,
+	2009,
+	1942,
+	2009,
+	1943,
+	2010,
+	1944,
+	2010,
+	1943,
+	2010,
+	1944,
+	2011,
+	1945,
+	2011,
+	1944,
+	2011,
+	1945,
+	2012,
+	1946,
+	2012,
+	1945,
+	2012,
+	1946,
+	2013,
+	1947,
+	2013,
+	1946,
+	2013,
+	1947,
+	2014,
+	1948,
+	2014,
+	1947,
+	2014,
+	1948,
+	2015,
+	1949,
+	2015,
+	1948,
+	2015,
+	1949,
+	2016,
+	1950,
+	2016,
+	1949,
+	2016,
+	1950,
+	2017,
+	1951,
+	2017,
+	1950,
+	2017,
+	1951,
+	2018,
+	1952,
+	2018,
+	1951,
+	2018,
+	1952,
+	2019,
+	1953,
+	2019,
+	1952,
+	2019,
+	1953,
+	2020,
+	1954,
+	2020,
+	1953,
+	2020,
+	1954,
+	2021,
+	1955,
+	2021,
+	1954,
+	2021,
+	1955,
+	2022,
+	1956,
+	2022,
+	1955,
+	2022,
+	1956,
+	2023,
+	1957,
+	2023,
+	1956,
+	2023,
+	1957,
+	2024,
+	1958,
+	2024,
+	1957,
+	2024,
+	1958,
+	2025,
+	1959,
+	2025,
+	1958,
+	2025,
+	1959,
+	2026,
+	1960,
+	2026,
+	1959,
+	2026,
+	1960,
+	2027,
+	1961,
+	2027,
+	1960,
+	2027,
+	1961,
+	2028,
+	1962,
+	2028,
+	1961,
+	2028,
+	1962,
+	2029,
+	1963,
+	2029,
+	1962,
+	2029,
+	1963,
+	2030,
+	1964,
+	2030,
+	1963,
+	2030,
+	1964,
+	2031,
+	1965,
+	2031,
+	1964,
+	2031,
+	1965,
+	2032,
+	1966,
+	2032,
+	1965,
+	2032,
+	1966,
+	2033,
+	1967,
+	2033,
+	1966,
+	2033,
+	1967,
+	2034,
+	1968,
+	2034,
+	1967,
+	2034,
+	1968,
+	2035,
+	1969,
+	2035,
+	1968,
+	2035,
+	1969,
+	2036,
+	1970,
+	2036,
+	1969,
+	2036,
+	1970,
+	2037,
+	1971,
+	2037,
+	1970,
+	2037,
+	1971,
+	2038,
+	1972,
+	2038,
+	1971,
+	2038,
+	1972,
+	2039,
+	1973,
+	2039,
+	1972,
+	2039,
+	1973,
+	2040,
+	1974,
+	2040,
+	1973,
+	2040,
+	1974,
+	2041,
+	1975,
+	2041,
+	1974,
+	2041,
+	1975,
+	2042,
+	1976,
+	2042,
+	1975,
+	2042,
+	1976,
+	2043,
+	1977,
+	2043,
+	1976,
+	2043,
+	1977,
+	2044,
+	1978,
+	2044,
+	1977,
+	2044,
+	1978,
+	2045,
+	1979,
+	2045,
+	1978,
+	2046,
+	1980,
+	2047,
+	1981,
+	2047,
+	1980,
+	2047,
+	1981,
+	2048,
+	1982,
+	2048,
+	1981,
+	2048,
+	1982,
+	2049,
+	1983,
+	2049,
+	1982,
+	2049,
+	1983,
+	2050,
+	1984,
+	2050,
+	1983,
+	2050,
+	1984,
+	2051,
+	1985,
+	2051,
+	1984,
+	2051,
+	1985,
+	2052,
+	1986,
+	2052,
+	1985,
+	2052,
+	1986,
+	2053,
+	1987,
+	2053,
+	1986,
+	2053,
+	1987,
+	2054,
+	1988,
+	2054,
+	1987,
+	2054,
+	1988,
+	2055,
+	1989,
+	2055,
+	1988,
+	2055,
+	1989,
+	2056,
+	1990,
+	2056,
+	1989,
+	2056,
+	1990,
+	2057,
+	1991,
+	2057,
+	1990,
+	2057,
+	1991,
+	2058,
+	1992,
+	2058,
+	1991,
+	2058,
+	1992,
+	2059,
+	1993,
+	2059,
+	1992,
+	2059,
+	1993,
+	2060,
+	1994,
+	2060,
+	1993,
+	2060,
+	1994,
+	2061,
+	1995,
+	2061,
+	1994,
+	2061,
+	1995,
+	2062,
+	1996,
+	2062,
+	1995,
+	2062,
+	1996,
+	2063,
+	1997,
+	2063,
+	1996,
+	2063,
+	1997,
+	2064,
+	1998,
+	2064,
+	1997,
+	2064,
+	1998,
+	2065,
+	1999,
+	2065,
+	1998,
+	2065,
+	1999,
+	2066,
+	2000,
+	2066,
+	1999,
+	2066,
+	2000,
+	2067,
+	2001,
+	2067,
+	2000,
+	2067,
+	2001,
+	2068,
+	2002,
+	2068,
+	2001,
+	2068,
+	2002,
+	2069,
+	2003,
+	2069,
+	2002,
+	2069,
+	2003,
+	2070,
+	2004,
+	2070,
+	2003,
+	2070,
+	2004,
+	2071,
+	2005,
+	2071,
+	2004,
+	2071,
+	2005,
+	2072,
+	2006,
+	2072,
+	2005,
+	2072,
+	2006,
+	2073,
+	2007,
+	2073,
+	2006,
+	2073,
+	2007,
+	2074,
+	2008,
+	2074,
+	2007,
+	2074,
+	2008,
+	2075,
+	2009,
+	2075,
+	2008,
+	2075,
+	2009,
+	2076,
+	2010,
+	2076,
+	2009,
+	2076,
+	2010,
+	2077,
+	2011,
+	2077,
+	2010,
+	2077,
+	2011,
+	2078,
+	2012,
+	2078,
+	2011,
+	2078,
+	2012,
+	2079,
+	2013,
+	2079,
+	2012,
+	2079,
+	2013,
+	2080,
+	2014,
+	2080,
+	2013,
+	2080,
+	2014,
+	2081,
+	2015,
+	2081,
+	2014,
+	2081,
+	2015,
+	2082,
+	2016,
+	2082,
+	2015,
+	2082,
+	2016,
+	2083,
+	2017,
+	2083,
+	2016,
+	2083,
+	2017,
+	2084,
+	2018,
+	2084,
+	2017,
+	2084,
+	2018,
+	2085,
+	2019,
+	2085,
+	2018,
+	2085,
+	2019,
+	2086,
+	2020,
+	2086,
+	2019,
+	2086,
+	2020,
+	2087,
+	2021,
+	2087,
+	2020,
+	2087,
+	2021,
+	2088,
+	2022,
+	2088,
+	2021,
+	2088,
+	2022,
+	2089,
+	2023,
+	2089,
+	2022,
+	2089,
+	2023,
+	2090,
+	2024,
+	2090,
+	2023,
+	2090,
+	2024,
+	2091,
+	2025,
+	2091,
+	2024,
+	2091,
+	2025,
+	2092,
+	2026,
+	2092,
+	2025,
+	2092,
+	2026,
+	2093,
+	2027,
+	2093,
+	2026,
+	2093,
+	2027,
+	2094,
+	2028,
+	2094,
+	2027,
+	2094,
+	2028,
+	2095,
+	2029,
+	2095,
+	2028,
+	2095,
+	2029,
+	2096,
+	2030,
+	2096,
+	2029,
+	2096,
+	2030,
+	2097,
+	2031,
+	2097,
+	2030,
+	2097,
+	2031,
+	2098,
+	2032,
+	2098,
+	2031,
+	2098,
+	2032,
+	2099,
+	2033,
+	2099,
+	2032,
+	2099,
+	2033,
+	2100,
+	2034,
+	2100,
+	2033,
+	2100,
+	2034,
+	2101,
+	2035,
+	2101,
+	2034,
+	2101,
+	2035,
+	2102,
+	2036,
+	2102,
+	2035,
+	2102,
+	2036,
+	2103,
+	2037,
+	2103,
+	2036,
+	2103,
+	2037,
+	2104,
+	2038,
+	2104,
+	2037,
+	2104,
+	2038,
+	2105,
+	2039,
+	2105,
+	2038,
+	2105,
+	2039,
+	2106,
+	2040,
+	2106,
+	2039,
+	2106,
+	2040,
+	2107,
+	2041,
+	2107,
+	2040,
+	2107,
+	2041,
+	2108,
+	2042,
+	2108,
+	2041,
+	2108,
+	2042,
+	2109,
+	2043,
+	2109,
+	2042,
+	2109,
+	2043,
+	2110,
+	2044,
+	2110,
+	2043,
+	2110,
+	2044,
+	2111,
+	2045,
+	2111,
+	2044,
+	2112,
+	2046,
+	2113,
+	2047,
+	2113,
+	2046,
+	2113,
+	2047,
+	2114,
+	2048,
+	2114,
+	2047,
+	2114,
+	2048,
+	2115,
+	2049,
+	2115,
+	2048,
+	2115,
+	2049,
+	2116,
+	2050,
+	2116,
+	2049,
+	2116,
+	2050,
+	2117,
+	2051,
+	2117,
+	2050,
+	2117,
+	2051,
+	2118,
+	2052,
+	2118,
+	2051,
+	2118,
+	2052,
+	2119,
+	2053,
+	2119,
+	2052,
+	2119,
+	2053,
+	2120,
+	2054,
+	2120,
+	2053,
+	2120,
+	2054,
+	2121,
+	2055,
+	2121,
+	2054,
+	2121,
+	2055,
+	2122,
+	2056,
+	2122,
+	2055,
+	2122,
+	2056,
+	2123,
+	2057,
+	2123,
+	2056,
+	2123,
+	2057,
+	2124,
+	2058,
+	2124,
+	2057,
+	2124,
+	2058,
+	2125,
+	2059,
+	2125,
+	2058,
+	2125,
+	2059,
+	2126,
+	2060,
+	2126,
+	2059,
+	2126,
+	2060,
+	2127,
+	2061,
+	2127,
+	2060,
+	2127,
+	2061,
+	2128,
+	2062,
+	2128,
+	2061,
+	2128,
+	2062,
+	2129,
+	2063,
+	2129,
+	2062,
+	2129,
+	2063,
+	2130,
+	2064,
+	2130,
+	2063,
+	2130,
+	2064,
+	2131,
+	2065,
+	2131,
+	2064,
+	2131,
+	2065,
+	2132,
+	2066,
+	2132,
+	2065,
+	2132,
+	2066,
+	2133,
+	2067,
+	2133,
+	2066,
+	2133,
+	2067,
+	2134,
+	2068,
+	2134,
+	2067,
+	2134,
+	2068,
+	2135,
+	2069,
+	2135,
+	2068,
+	2135,
+	2069,
+	2136,
+	2070,
+	2136,
+	2069,
+	2136,
+	2070,
+	2137,
+	2071,
+	2137,
+	2070,
+	2137,
+	2071,
+	2138,
+	2072,
+	2138,
+	2071,
+	2138,
+	2072,
+	2139,
+	2073,
+	2139,
+	2072,
+	2139,
+	2073,
+	2140,
+	2074,
+	2140,
+	2073,
+	2140,
+	2074,
+	2141,
+	2075,
+	2141,
+	2074,
+	2141,
+	2075,
+	2142,
+	2076,
+	2142,
+	2075,
+	2142,
+	2076,
+	2143,
+	2077,
+	2143,
+	2076,
+	2143,
+	2077,
+	2144,
+	2078,
+	2144,
+	2077,
+	2144,
+	2078,
+	2145,
+	2079,
+	2145,
+	2078,
+	2145,
+	2079,
+	2146,
+	2080,
+	2146,
+	2079,
+	2146,
+	2080,
+	2147,
+	2081,
+	2147,
+	2080,
+	2147,
+	2081,
+	2148,
+	2082,
+	2148,
+	2081,
+	2148,
+	2082,
+	2149,
+	2083,
+	2149,
+	2082,
+	2149,
+	2083,
+	2150,
+	2084,
+	2150,
+	2083,
+	2150,
+	2084,
+	2151,
+	2085,
+	2151,
+	2084,
+	2151,
+	2085,
+	2152,
+	2086,
+	2152,
+	2085,
+	2152,
+	2086,
+	2153,
+	2087,
+	2153,
+	2086,
+	2153,
+	2087,
+	2154,
+	2088,
+	2154,
+	2087,
+	2154,
+	2088,
+	2155,
+	2089,
+	2155,
+	2088,
+	2155,
+	2089,
+	2156,
+	2090,
+	2156,
+	2089,
+	2156,
+	2090,
+	2157,
+	2091,
+	2157,
+	2090,
+	2157,
+	2091,
+	2158,
+	2092,
+	2158,
+	2091,
+	2158,
+	2092,
+	2159,
+	2093,
+	2159,
+	2092,
+	2159,
+	2093,
+	2160,
+	2094,
+	2160,
+	2093,
+	2160,
+	2094,
+	2161,
+	2095,
+	2161,
+	2094,
+	2161,
+	2095,
+	2162,
+	2096,
+	2162,
+	2095,
+	2162,
+	2096,
+	2163,
+	2097,
+	2163,
+	2096,
+	2163,
+	2097,
+	2164,
+	2098,
+	2164,
+	2097,
+	2164,
+	2098,
+	2165,
+	2099,
+	2165,
+	2098,
+	2165,
+	2099,
+	2166,
+	2100,
+	2166,
+	2099,
+	2166,
+	2100,
+	2167,
+	2101,
+	2167,
+	2100,
+	2167,
+	2101,
+	2168,
+	2102,
+	2168,
+	2101,
+	2168,
+	2102,
+	2169,
+	2103,
+	2169,
+	2102,
+	2169,
+	2103,
+	2170,
+	2104,
+	2170,
+	2103,
+	2170,
+	2104,
+	2171,
+	2105,
+	2171,
+	2104,
+	2171,
+	2105,
+	2172,
+	2106,
+	2172,
+	2105,
+	2172,
+	2106,
+	2173,
+	2107,
+	2173,
+	2106,
+	2173,
+	2107,
+	2174,
+	2108,
+	2174,
+	2107,
+	2174,
+	2108,
+	2175,
+	2109,
+	2175,
+	2108,
+	2175,
+	2109,
+	2176,
+	2110,
+	2176,
+	2109,
+	2176,
+	2110,
+	2177,
+	2111,
+	2177,
+	2110,
+};
+
+#define Landscape01VtxCount 2048
+#define Landscape01IdxCount 11718
+
+btScalar Landscape01Vtx[] = {
+	3.90626f,
+	0.452911f,
+	246.094f,
+	3.90626f,
+	1.52302f,
+	250.0f,
+	7.8125f,
+	1.18238f,
+	246.094f,
+	7.81251f,
+	1.7549f,
+	250.0f,
+	11.7188f,
+	2.12911f,
+	246.094f,
+	11.7188f,
+	2.62454f,
+	250.0f,
+	15.625f,
+	3.01456f,
+	246.094f,
+	15.625f,
+	3.22814f,
+	250.0f,
+	19.5313f,
+	3.97431f,
+	246.094f,
+	19.5313f,
+	3.63231f,
+	250.0f,
+	23.4375f,
+	4.08741f,
+	246.094f,
+	23.4375f,
+	4.24097f,
+	250.0f,
+	27.3438f,
+	5.8163f,
+	246.094f,
+	27.3438f,
+	5.93409f,
+	250.0f,
+	31.25f,
+	6.86809f,
+	246.094f,
+	31.25f,
+	7.34105f,
+	250.0f,
+	35.1563f,
+	8.25405f,
+	246.094f,
+	35.1563f,
+	8.62507f,
+	250.0f,
+	39.0625f,
+	8.38601f,
+	246.094f,
+	39.0625f,
+	8.68483f,
+	250.0f,
+	42.9688f,
+	6.94797f,
+	246.094f,
+	42.9688f,
+	7.71847f,
+	250.0f,
+	46.875f,
+	4.60698f,
+	246.094f,
+	46.875f,
+	6.12159f,
+	250.0f,
+	50.7813f,
+	3.6429f,
+	246.094f,
+	50.7813f,
+	5.13002f,
+	250.0f,
+	54.6875f,
+	4.01945f,
+	246.094f,
+	54.6875f,
+	5.50476f,
+	250.0f,
+	58.5938f,
+	4.05996f,
+	246.094f,
+	58.5938f,
+	5.31917f,
+	250.0f,
+	62.5f,
+	3.98995f,
+	246.094f,
+	62.5f,
+	5.51823f,
+	250.0f,
+	66.4063f,
+	5.44402f,
+	246.094f,
+	66.4063f,
+	6.80029f,
+	250.0f,
+	70.3125f,
+	6.03873f,
+	246.094f,
+	70.3125f,
+	7.41783f,
+	250.0f,
+	74.2188f,
+	6.37187f,
+	246.094f,
+	74.2188f,
+	8.16051f,
+	250.0f,
+	78.125f,
+	6.74414f,
+	246.094f,
+	78.125f,
+	8.72099f,
+	250.0f,
+	82.0313f,
+	7.37958f,
+	246.094f,
+	82.0313f,
+	10.1125f,
+	250.0f,
+	85.9375f,
+	8.97782f,
+	246.094f,
+	85.9375f,
+	10.4624f,
+	250.0f,
+	89.8438f,
+	11.0829f,
+	246.094f,
+	89.8438f,
+	11.6403f,
+	250.0f,
+	93.75f,
+	12.3286f,
+	246.094f,
+	93.75f,
+	13.1378f,
+	250.0f,
+	97.6563f,
+	13.5966f,
+	246.094f,
+	97.6563f,
+	14.2949f,
+	250.0f,
+	101.563f,
+	15.5602f,
+	246.094f,
+	101.563f,
+	16.9487f,
+	250.0f,
+	105.469f,
+	16.9944f,
+	246.094f,
+	105.469f,
+	18.1946f,
+	250.0f,
+	109.375f,
+	17.886f,
+	246.094f,
+	109.375f,
+	19.5101f,
+	250.0f,
+	113.281f,
+	18.9289f,
+	246.094f,
+	113.281f,
+	20.9286f,
+	250.0f,
+	117.188f,
+	18.9873f,
+	246.094f,
+	117.188f,
+	20.0636f,
+	250.0f,
+	121.094f,
+	18.4954f,
+	246.094f,
+	121.094f,
+	20.5657f,
+	250.0f,
+	125.0f,
+	20.1484f,
+	246.094f,
+	125.0f,
+	21.1466f,
+	250.0f,
+	128.906f,
+	20.5032f,
+	246.094f,
+	128.906f,
+	22.3026f,
+	250.0f,
+	132.813f,
+	21.212f,
+	246.094f,
+	132.813f,
+	22.9139f,
+	250.0f,
+	136.719f,
+	22.289f,
+	246.094f,
+	136.719f,
+	24.4671f,
+	250.0f,
+	140.625f,
+	23.2441f,
+	246.094f,
+	140.625f,
+	24.3276f,
+	250.0f,
+	144.531f,
+	22.4971f,
+	246.094f,
+	144.531f,
+	24.3128f,
+	250.0f,
+	148.438f,
+	22.6347f,
+	246.094f,
+	148.438f,
+	23.8291f,
+	250.0f,
+	152.344f,
+	23.5767f,
+	246.094f,
+	152.344f,
+	24.1369f,
+	250.0f,
+	156.25f,
+	25.193f,
+	246.094f,
+	156.25f,
+	24.9132f,
+	250.0f,
+	160.156f,
+	25.2521f,
+	246.094f,
+	160.156f,
+	24.7251f,
+	250.0f,
+	164.063f,
+	25.7424f,
+	246.094f,
+	164.063f,
+	24.1169f,
+	250.0f,
+	167.969f,
+	24.3269f,
+	246.094f,
+	167.969f,
+	24.6092f,
+	250.0f,
+	171.875f,
+	25.0479f,
+	246.094f,
+	171.875f,
+	24.967f,
+	250.0f,
+	175.781f,
+	25.0107f,
+	246.094f,
+	175.781f,
+	24.7879f,
+	250.0f,
+	179.688f,
+	23.583f,
+	246.094f,
+	179.688f,
+	22.6841f,
+	250.0f,
+	183.594f,
+	20.958f,
+	246.094f,
+	183.594f,
+	20.6584f,
+	250.0f,
+	187.5f,
+	19.7535f,
+	246.094f,
+	187.5f,
+	20.0313f,
+	250.0f,
+	191.406f,
+	20.4707f,
+	246.094f,
+	191.406f,
+	20.3896f,
+	250.0f,
+	195.313f,
+	19.7551f,
+	246.094f,
+	195.313f,
+	21.5643f,
+	250.0f,
+	199.219f,
+	19.698f,
+	246.094f,
+	199.219f,
+	21.5733f,
+	250.0f,
+	203.125f,
+	20.0732f,
+	246.094f,
+	203.125f,
+	20.38f,
+	250.0f,
+	207.031f,
+	19.8667f,
+	246.094f,
+	207.031f,
+	19.3779f,
+	250.0f,
+	210.938f,
+	19.4501f,
+	246.094f,
+	210.938f,
+	19.5994f,
+	250.0f,
+	214.844f,
+	19.2918f,
+	246.094f,
+	214.844f,
+	19.0966f,
+	250.0f,
+	218.75f,
+	18.7652f,
+	246.094f,
+	218.75f,
+	19.9256f,
+	250.0f,
+	222.656f,
+	18.8129f,
+	246.094f,
+	222.656f,
+	19.8704f,
+	250.0f,
+	226.563f,
+	18.3547f,
+	246.094f,
+	226.563f,
+	18.8671f,
+	250.0f,
+	230.469f,
+	16.9801f,
+	246.094f,
+	230.469f,
+	17.4931f,
+	250.0f,
+	234.375f,
+	15.6173f,
+	246.094f,
+	234.375f,
+	16.1699f,
+	250.0f,
+	238.281f,
+	15.549f,
+	246.094f,
+	238.281f,
+	15.3704f,
+	250.0f,
+	242.188f,
+	15.2468f,
+	246.094f,
+	242.188f,
+	15.0306f,
+	250.0f,
+	246.094f,
+	14.1325f,
+	246.094f,
+	246.094f,
+	14.2622f,
+	250.0f,
+	250.0f,
+	14.4063f,
+	246.094f,
+	250.0f,
+	14.3657f,
+	250.0f,
+	3.90626f,
+	2.21488f,
+	242.188f,
+	7.81252f,
+	2.28606f,
+	242.188f,
+	11.7188f,
+	3.88428f,
+	242.188f,
+	15.625f,
+	3.39117f,
+	242.188f,
+	19.5313f,
+	3.64824f,
+	242.188f,
+	23.4375f,
+	4.14072f,
+	242.188f,
+	27.3438f,
+	5.74104f,
+	242.188f,
+	31.25f,
+	6.66142f,
+	242.188f,
+	35.1563f,
+	7.31371f,
+	242.188f,
+	39.0625f,
+	7.68371f,
+	242.188f,
+	42.9688f,
+	6.99041f,
+	242.188f,
+	46.875f,
+	4.89778f,
+	242.188f,
+	50.7813f,
+	2.64913f,
+	242.188f,
+	54.6875f,
+	2.76175f,
+	242.188f,
+	58.5938f,
+	3.10499f,
+	242.188f,
+	62.5f,
+	4.61915f,
+	242.188f,
+	66.4063f,
+	5.36769f,
+	242.188f,
+	70.3125f,
+	5.41759f,
+	242.188f,
+	74.2188f,
+	5.42279f,
+	242.188f,
+	78.125f,
+	5.53934f,
+	242.188f,
+	82.0313f,
+	5.38421f,
+	242.188f,
+	85.9375f,
+	7.77227f,
+	242.188f,
+	89.8438f,
+	9.40622f,
+	242.188f,
+	93.75f,
+	11.2904f,
+	242.188f,
+	97.6563f,
+	12.0748f,
+	242.188f,
+	101.563f,
+	14.1058f,
+	242.188f,
+	105.469f,
+	15.1513f,
+	242.188f,
+	109.375f,
+	15.9477f,
+	242.188f,
+	113.281f,
+	16.843f,
+	242.188f,
+	117.188f,
+	17.2117f,
+	242.188f,
+	121.094f,
+	18.2641f,
+	242.188f,
+	125.0f,
+	18.8672f,
+	242.188f,
+	128.906f,
+	19.3239f,
+	242.188f,
+	132.813f,
+	20.1067f,
+	242.188f,
+	136.719f,
+	20.8307f,
+	242.188f,
+	140.625f,
+	21.3646f,
+	242.188f,
+	144.531f,
+	21.6047f,
+	242.188f,
+	148.438f,
+	22.2456f,
+	242.188f,
+	152.344f,
+	23.5103f,
+	242.188f,
+	156.25f,
+	24.8533f,
+	242.188f,
+	160.156f,
+	25.4504f,
+	242.188f,
+	164.063f,
+	25.9357f,
+	242.188f,
+	167.969f,
+	24.8535f,
+	242.188f,
+	171.875f,
+	25.3099f,
+	242.188f,
+	175.781f,
+	25.3494f,
+	242.188f,
+	179.688f,
+	24.2229f,
+	242.188f,
+	183.594f,
+	21.0829f,
+	242.188f,
+	187.5f,
+	19.574f,
+	242.188f,
+	191.406f,
+	19.9835f,
+	242.188f,
+	195.313f,
+	19.6061f,
+	242.188f,
+	199.219f,
+	18.9509f,
+	242.188f,
+	203.125f,
+	20.1818f,
+	242.188f,
+	207.031f,
+	19.2962f,
+	242.188f,
+	210.938f,
+	18.8908f,
+	242.188f,
+	214.844f,
+	18.7996f,
+	242.188f,
+	218.75f,
+	18.7982f,
+	242.188f,
+	222.656f,
+	18.3283f,
+	242.188f,
+	226.563f,
+	17.7287f,
+	242.188f,
+	230.469f,
+	15.6882f,
+	242.188f,
+	234.375f,
+	15.2468f,
+	242.188f,
+	238.281f,
+	15.2703f,
+	242.188f,
+	242.188f,
+	14.4812f,
+	242.188f,
+	246.094f,
+	14.5597f,
+	242.188f,
+	250.0f,
+	14.178f,
+	242.188f,
+	3.90626f,
+	3.04396f,
+	238.281f,
+	7.81252f,
+	3.88428f,
+	238.281f,
+	11.7188f,
+	4.51367f,
+	238.281f,
+	15.625f,
+	4.1993f,
+	238.281f,
+	19.5313f,
+	4.48585f,
+	238.281f,
+	23.4375f,
+	5.11452f,
+	238.281f,
+	27.3438f,
+	4.98441f,
+	238.281f,
+	31.25f,
+	5.77536f,
+	238.281f,
+	35.1563f,
+	5.42743f,
+	238.281f,
+	39.0625f,
+	6.4581f,
+	238.281f,
+	42.9688f,
+	5.55272f,
+	238.281f,
+	46.875f,
+	3.69555f,
+	238.281f,
+	50.7813f,
+	3.08321f,
+	238.281f,
+	54.6875f,
+	2.96664f,
+	238.281f,
+	58.5938f,
+	3.94595f,
+	238.281f,
+	62.5f,
+	4.71605f,
+	238.281f,
+	66.4063f,
+	5.07906f,
+	238.281f,
+	70.3125f,
+	5.39291f,
+	238.281f,
+	74.2188f,
+	4.29289f,
+	238.281f,
+	78.125f,
+	4.20855f,
+	238.281f,
+	82.0313f,
+	5.10829f,
+	238.281f,
+	85.9375f,
+	5.48654f,
+	238.281f,
+	89.8438f,
+	7.06082f,
+	238.281f,
+	93.75f,
+	8.6827f,
+	238.281f,
+	97.6563f,
+	9.99779f,
+	238.281f,
+	101.563f,
+	11.9757f,
+	238.281f,
+	105.469f,
+	12.9031f,
+	238.281f,
+	109.375f,
+	13.7947f,
+	238.281f,
+	113.281f,
+	13.6154f,
+	238.281f,
+	117.188f,
+	15.9897f,
+	238.281f,
+	121.094f,
+	18.0884f,
+	238.281f,
+	125.0f,
+	18.714f,
+	238.281f,
+	128.906f,
+	19.1457f,
+	238.281f,
+	132.813f,
+	20.0791f,
+	238.281f,
+	136.719f,
+	20.3929f,
+	238.281f,
+	140.625f,
+	20.8277f,
+	238.281f,
+	144.531f,
+	21.2111f,
+	238.281f,
+	148.438f,
+	22.5091f,
+	238.281f,
+	152.344f,
+	23.9188f,
+	238.281f,
+	156.25f,
+	25.0278f,
+	238.281f,
+	160.156f,
+	25.8335f,
+	238.281f,
+	164.063f,
+	25.6558f,
+	238.281f,
+	167.969f,
+	24.3663f,
+	238.281f,
+	171.875f,
+	30.6775f,
+	238.281f,
+	175.781f,
+	30.89f,
+	238.281f,
+	179.688f,
+	29.2543f,
+	238.281f,
+	183.594f,
+	26.6241f,
+	238.281f,
+	187.5f,
+	24.7124f,
+	238.281f,
+	191.406f,
+	23.7048f,
+	238.281f,
+	195.313f,
+	23.3839f,
+	238.281f,
+	199.219f,
+	23.312f,
+	238.281f,
+	203.125f,
+	17.5221f,
+	238.281f,
+	207.031f,
+	17.418f,
+	238.281f,
+	210.938f,
+	17.5259f,
+	238.281f,
+	214.844f,
+	18.2392f,
+	238.281f,
+	218.75f,
+	18.6793f,
+	238.281f,
+	222.656f,
+	18.3701f,
+	238.281f,
+	226.563f,
+	17.2487f,
+	238.281f,
+	230.469f,
+	16.4f,
+	238.281f,
+	234.375f,
+	15.4998f,
+	238.281f,
+	238.281f,
+	14.6207f,
+	238.281f,
+	242.188f,
+	14.3055f,
+	238.281f,
+	246.094f,
+	14.2255f,
+	238.281f,
+	250.0f,
+	14.1326f,
+	238.281f,
+	3.90626f,
+	5.19166f,
+	234.375f,
+	7.81252f,
+	4.93292f,
+	234.375f,
+	11.7188f,
+	4.03413f,
+	234.375f,
+	15.625f,
+	3.70957f,
+	234.375f,
+	19.5313f,
+	4.44484f,
+	234.375f,
+	23.4375f,
+	5.12277f,
+	234.375f,
+	27.3438f,
+	4.60029f,
+	234.375f,
+	31.25f,
+	4.55048f,
+	234.375f,
+	35.1563f,
+	4.78512f,
+	234.375f,
+	39.0625f,
+	4.94627f,
+	234.375f,
+	42.9688f,
+	5.03351f,
+	234.375f,
+	46.875f,
+	3.08166f,
+	234.375f,
+	50.7813f,
+	2.57752f,
+	234.375f,
+	54.6875f,
+	3.08533f,
+	234.375f,
+	58.5938f,
+	4.0254f,
+	234.375f,
+	62.5f,
+	4.57575f,
+	234.375f,
+	66.4063f,
+	4.67125f,
+	234.375f,
+	70.3125f,
+	4.5612f,
+	234.375f,
+	74.2188f,
+	4.232f,
+	234.375f,
+	78.125f,
+	4.1571f,
+	234.375f,
+	82.0313f,
+	4.20157f,
+	234.375f,
+	85.9375f,
+	4.29102f,
+	234.375f,
+	89.8438f,
+	5.54826f,
+	234.375f,
+	93.75f,
+	7.06094f,
+	234.375f,
+	97.6563f,
+	8.27366f,
+	234.375f,
+	101.563f,
+	9.83852f,
+	234.375f,
+	105.469f,
+	10.9262f,
+	234.375f,
+	109.375f,
+	11.7812f,
+	234.375f,
+	113.281f,
+	13.8453f,
+	234.375f,
+	117.188f,
+	15.5538f,
+	234.375f,
+	121.094f,
+	16.8977f,
+	234.375f,
+	125.0f,
+	18.2996f,
+	234.375f,
+	128.906f,
+	19.6512f,
+	234.375f,
+	132.813f,
+	19.411f,
+	234.375f,
+	136.719f,
+	19.3317f,
+	234.375f,
+	140.625f,
+	20.656f,
+	234.375f,
+	144.531f,
+	21.6048f,
+	234.375f,
+	148.438f,
+	22.2246f,
+	234.375f,
+	152.344f,
+	23.6649f,
+	234.375f,
+	156.25f,
+	24.8772f,
+	234.375f,
+	160.156f,
+	27.6423f,
+	234.375f,
+	164.063f,
+	29.4442f,
+	234.375f,
+	167.969f,
+	29.6691f,
+	234.375f,
+	171.875f,
+	30.0772f,
+	234.375f,
+	175.781f,
+	30.3189f,
+	234.375f,
+	179.688f,
+	28.7319f,
+	234.375f,
+	183.594f,
+	26.6952f,
+	234.375f,
+	187.5f,
+	25.3375f,
+	234.375f,
+	191.406f,
+	24.1666f,
+	234.375f,
+	195.313f,
+	22.5458f,
+	234.375f,
+	199.219f,
+	22.2182f,
+	234.375f,
+	203.125f,
+	22.2413f,
+	234.375f,
+	207.031f,
+	21.8533f,
+	234.375f,
+	210.938f,
+	17.4596f,
+	234.375f,
+	214.844f,
+	17.2677f,
+	234.375f,
+	218.75f,
+	16.9584f,
+	234.375f,
+	222.656f,
+	16.6188f,
+	234.375f,
+	226.563f,
+	17.4388f,
+	234.375f,
+	230.469f,
+	16.936f,
+	234.375f,
+	234.375f,
+	15.6181f,
+	234.375f,
+	238.281f,
+	15.8373f,
+	234.375f,
+	242.188f,
+	15.0881f,
+	234.375f,
+	246.094f,
+	14.2247f,
+	234.375f,
+	250.0f,
+	14.111f,
+	234.375f,
+	3.90626f,
+	5.885f,
+	230.469f,
+	7.81251f,
+	5.4786f,
+	230.469f,
+	11.7188f,
+	5.0584f,
+	230.469f,
+	15.625f,
+	4.10283f,
+	230.469f,
+	19.5313f,
+	4.10569f,
+	230.469f,
+	23.4375f,
+	4.42202f,
+	230.469f,
+	27.3438f,
+	4.27849f,
+	230.469f,
+	31.25f,
+	4.25612f,
+	230.469f,
+	35.1563f,
+	3.83542f,
+	230.469f,
+	39.0625f,
+	3.37515f,
+	230.469f,
+	42.9688f,
+	4.16288f,
+	230.469f,
+	46.875f,
+	2.84197f,
+	230.469f,
+	50.7813f,
+	2.83467f,
+	230.469f,
+	54.6875f,
+	3.07874f,
+	230.469f,
+	58.5938f,
+	3.37745f,
+	230.469f,
+	62.5f,
+	4.09612f,
+	230.469f,
+	66.4063f,
+	4.65777f,
+	230.469f,
+	70.3125f,
+	4.45712f,
+	230.469f,
+	74.2188f,
+	3.89296f,
+	230.469f,
+	78.125f,
+	3.87471f,
+	230.469f,
+	82.0313f,
+	4.64568f,
+	230.469f,
+	85.9375f,
+	5.82987f,
+	230.469f,
+	89.8438f,
+	6.40084f,
+	230.469f,
+	93.75f,
+	7.65914f,
+	230.469f,
+	97.6563f,
+	8.07052f,
+	230.469f,
+	101.563f,
+	9.86632f,
+	230.469f,
+	105.469f,
+	11.8636f,
+	230.469f,
+	109.375f,
+	12.9547f,
+	230.469f,
+	113.281f,
+	14.2745f,
+	230.469f,
+	117.188f,
+	15.6876f,
+	230.469f,
+	121.094f,
+	17.2089f,
+	230.469f,
+	125.0f,
+	18.1267f,
+	230.469f,
+	128.906f,
+	19.379f,
+	230.469f,
+	132.813f,
+	19.2097f,
+	230.469f,
+	136.719f,
+	18.9335f,
+	230.469f,
+	140.625f,
+	19.9763f,
+	230.469f,
+	144.531f,
+	21.5401f,
+	230.469f,
+	148.438f,
+	21.7302f,
+	230.469f,
+	152.344f,
+	23.0108f,
+	230.469f,
+	156.25f,
+	28.7387f,
+	230.469f,
+	160.156f,
+	28.4179f,
+	230.469f,
+	164.063f,
+	28.6483f,
+	230.469f,
+	167.969f,
+	29.5567f,
+	230.469f,
+	171.875f,
+	29.589f,
+	230.469f,
+	175.781f,
+	29.7943f,
+	230.469f,
+	179.688f,
+	28.0587f,
+	230.469f,
+	183.594f,
+	27.6387f,
+	230.469f,
+	187.5f,
+	26.92f,
+	230.469f,
+	191.406f,
+	25.7995f,
+	230.469f,
+	195.313f,
+	23.8573f,
+	230.469f,
+	199.219f,
+	22.1543f,
+	230.469f,
+	203.125f,
+	21.8606f,
+	230.469f,
+	207.031f,
+	21.7644f,
+	230.469f,
+	210.938f,
+	22.284f,
+	230.469f,
+	214.844f,
+	22.465f,
+	230.469f,
+	218.75f,
+	16.4018f,
+	230.469f,
+	222.656f,
+	16.1053f,
+	230.469f,
+	226.563f,
+	16.9553f,
+	230.469f,
+	230.469f,
+	16.9851f,
+	230.469f,
+	234.375f,
+	16.0967f,
+	230.469f,
+	238.281f,
+	15.9758f,
+	230.469f,
+	242.188f,
+	15.3258f,
+	230.469f,
+	246.094f,
+	15.2909f,
+	230.469f,
+	250.0f,
+	14.7208f,
+	230.469f,
+	3.90626f,
+	6.89682f,
+	226.563f,
+	7.81251f,
+	6.58742f,
+	226.563f,
+	11.7188f,
+	6.03516f,
+	226.563f,
+	15.625f,
+	4.72243f,
+	226.563f,
+	19.5313f,
+	3.6445f,
+	226.563f,
+	23.4375f,
+	4.35761f,
+	226.563f,
+	27.3438f,
+	4.11714f,
+	226.563f,
+	31.25f,
+	4.31125f,
+	226.563f,
+	35.1563f,
+	3.42415f,
+	226.563f,
+	39.0625f,
+	2.29216f,
+	226.563f,
+	42.9688f,
+	2.47915f,
+	226.563f,
+	46.875f,
+	2.26767f,
+	226.563f,
+	50.7813f,
+	1.11914f,
+	226.563f,
+	54.6875f,
+	2.43266f,
+	226.563f,
+	58.5938f,
+	3.88718f,
+	226.563f,
+	62.5f,
+	3.9963f,
+	226.563f,
+	66.4063f,
+	4.30547f,
+	226.563f,
+	70.3125f,
+	4.43739f,
+	226.563f,
+	74.2188f,
+	3.89069f,
+	226.563f,
+	78.125f,
+	4.12082f,
+	226.563f,
+	82.0313f,
+	5.53252f,
+	226.563f,
+	85.9375f,
+	6.38493f,
+	226.563f,
+	89.8438f,
+	6.79959f,
+	226.563f,
+	93.75f,
+	8.29598f,
+	226.563f,
+	97.6563f,
+	8.48723f,
+	226.563f,
+	101.563f,
+	9.93554f,
+	226.563f,
+	105.469f,
+	11.5657f,
+	226.563f,
+	109.375f,
+	13.0486f,
+	226.563f,
+	113.281f,
+	13.8621f,
+	226.563f,
+	117.188f,
+	14.9688f,
+	226.563f,
+	121.094f,
+	16.3799f,
+	226.563f,
+	125.0f,
+	17.1973f,
+	226.563f,
+	128.906f,
+	17.376f,
+	226.563f,
+	132.813f,
+	18.1073f,
+	226.563f,
+	136.719f,
+	18.6844f,
+	226.563f,
+	140.625f,
+	18.5161f,
+	226.563f,
+	144.531f,
+	20.7617f,
+	226.563f,
+	148.438f,
+	21.0578f,
+	226.563f,
+	152.344f,
+	26.44f,
+	226.563f,
+	156.25f,
+	27.1807f,
+	226.563f,
+	160.156f,
+	27.2962f,
+	226.563f,
+	164.063f,
+	28.0507f,
+	226.563f,
+	167.969f,
+	28.6572f,
+	226.563f,
+	171.875f,
+	28.3487f,
+	226.563f,
+	175.781f,
+	23.7294f,
+	226.563f,
+	179.688f,
+	23.1113f,
+	226.563f,
+	183.594f,
+	22.5708f,
+	226.563f,
+	187.5f,
+	22.6165f,
+	226.563f,
+	191.406f,
+	21.8697f,
+	226.563f,
+	195.313f,
+	19.9841f,
+	226.563f,
+	199.219f,
+	22.9835f,
+	226.563f,
+	203.125f,
+	22.0743f,
+	226.563f,
+	207.031f,
+	22.4886f,
+	226.563f,
+	210.938f,
+	22.2516f,
+	226.563f,
+	214.844f,
+	22.3739f,
+	226.563f,
+	218.75f,
+	22.7815f,
+	226.563f,
+	222.656f,
+	17.0366f,
+	226.563f,
+	226.563f,
+	16.1334f,
+	226.563f,
+	230.469f,
+	16.9265f,
+	226.563f,
+	234.375f,
+	17.1793f,
+	226.563f,
+	238.281f,
+	17.3365f,
+	226.563f,
+	242.188f,
+	16.1971f,
+	226.563f,
+	246.094f,
+	15.2775f,
+	226.563f,
+	250.0f,
+	15.1313f,
+	226.563f,
+	3.90626f,
+	6.81349f,
+	222.656f,
+	7.81251f,
+	7.23848f,
+	222.656f,
+	11.7188f,
+	6.09864f,
+	222.656f,
+	15.625f,
+	4.9545f,
+	222.656f,
+	19.5313f,
+	3.88133f,
+	222.656f,
+	23.4375f,
+	4.06964f,
+	222.656f,
+	27.3438f,
+	3.90589f,
+	222.656f,
+	31.25f,
+	4.08304f,
+	222.656f,
+	35.1563f,
+	3.26204f,
+	222.656f,
+	39.0625f,
+	1.53457f,
+	222.656f,
+	42.9688f,
+	1.90835f,
+	222.656f,
+	46.875f,
+	1.98509f,
+	222.656f,
+	50.7813f,
+	2.14652f,
+	222.656f,
+	54.6875f,
+	2.7418f,
+	222.656f,
+	58.5938f,
+	3.74695f,
+	222.656f,
+	62.5f,
+	4.00354f,
+	222.656f,
+	66.4063f,
+	4.38792f,
+	222.656f,
+	70.3125f,
+	3.93121f,
+	222.656f,
+	74.2188f,
+	3.42647f,
+	222.656f,
+	78.125f,
+	5.0562f,
+	222.656f,
+	82.0313f,
+	5.98572f,
+	222.656f,
+	85.9375f,
+	6.52919f,
+	222.656f,
+	89.8438f,
+	6.83394f,
+	222.656f,
+	93.75f,
+	7.48974f,
+	222.656f,
+	97.6563f,
+	8.19267f,
+	222.656f,
+	101.563f,
+	9.33438f,
+	222.656f,
+	105.469f,
+	11.8423f,
+	222.656f,
+	109.375f,
+	13.1158f,
+	222.656f,
+	113.281f,
+	13.8944f,
+	222.656f,
+	117.188f,
+	14.8014f,
+	222.656f,
+	121.094f,
+	15.4129f,
+	222.656f,
+	125.0f,
+	15.6942f,
+	222.656f,
+	128.906f,
+	16.2049f,
+	222.656f,
+	132.813f,
+	17.0318f,
+	222.656f,
+	136.719f,
+	18.5423f,
+	222.656f,
+	140.625f,
+	18.8685f,
+	222.656f,
+	144.531f,
+	19.4529f,
+	222.656f,
+	148.438f,
+	25.9153f,
+	222.656f,
+	152.344f,
+	25.6773f,
+	222.656f,
+	156.25f,
+	26.0432f,
+	222.656f,
+	160.156f,
+	26.3016f,
+	222.656f,
+	164.063f,
+	27.084f,
+	222.656f,
+	167.969f,
+	27.1073f,
+	222.656f,
+	171.875f,
+	22.7536f,
+	222.656f,
+	175.781f,
+	23.3785f,
+	222.656f,
+	179.688f,
+	23.0862f,
+	222.656f,
+	183.594f,
+	22.5993f,
+	222.656f,
+	187.5f,
+	22.0197f,
+	222.656f,
+	191.406f,
+	21.8352f,
+	222.656f,
+	195.313f,
+	20.0501f,
+	222.656f,
+	199.219f,
+	18.5797f,
+	222.656f,
+	203.125f,
+	18.2905f,
+	222.656f,
+	207.031f,
+	22.7876f,
+	222.656f,
+	210.938f,
+	21.9787f,
+	222.656f,
+	214.844f,
+	21.4782f,
+	222.656f,
+	218.75f,
+	21.5786f,
+	222.656f,
+	222.656f,
+	21.6231f,
+	222.656f,
+	226.563f,
+	17.8058f,
+	222.656f,
+	230.469f,
+	17.6169f,
+	222.656f,
+	234.375f,
+	18.3242f,
+	222.656f,
+	238.281f,
+	18.4847f,
+	222.656f,
+	242.188f,
+	17.3189f,
+	222.656f,
+	246.094f,
+	16.7726f,
+	222.656f,
+	250.0f,
+	16.587f,
+	222.656f,
+	3.90627f,
+	8.02546f,
+	218.75f,
+	7.81251f,
+	8.24803f,
+	218.75f,
+	11.7188f,
+	6.92174f,
+	218.75f,
+	15.625f,
+	5.86085f,
+	218.75f,
+	19.5313f,
+	4.56603f,
+	218.75f,
+	23.4375f,
+	3.6909f,
+	218.75f,
+	27.3438f,
+	4.26522f,
+	218.75f,
+	31.25f,
+	3.37783f,
+	218.75f,
+	35.1563f,
+	1.72339f,
+	218.75f,
+	39.0625f,
+	2.22205f,
+	218.75f,
+	42.9688f,
+	2.71848f,
+	218.75f,
+	46.875f,
+	3.1467f,
+	218.75f,
+	50.7813f,
+	3.05327f,
+	218.75f,
+	54.6875f,
+	3.19537f,
+	218.75f,
+	58.5938f,
+	3.68243f,
+	218.75f,
+	62.5f,
+	3.35279f,
+	218.75f,
+	66.4063f,
+	4.00402f,
+	218.75f,
+	70.3125f,
+	2.9244f,
+	218.75f,
+	74.2188f,
+	4.39027f,
+	218.75f,
+	78.125f,
+	5.55878f,
+	218.75f,
+	82.0313f,
+	6.38772f,
+	218.75f,
+	85.9375f,
+	6.34964f,
+	218.75f,
+	89.8438f,
+	6.80441f,
+	218.75f,
+	93.75f,
+	6.5829f,
+	218.75f,
+	97.6563f,
+	7.27657f,
+	218.75f,
+	101.563f,
+	9.67388f,
+	218.75f,
+	105.469f,
+	10.833f,
+	218.75f,
+	109.375f,
+	12.1666f,
+	218.75f,
+	113.281f,
+	13.2095f,
+	218.75f,
+	117.188f,
+	14.2491f,
+	218.75f,
+	121.094f,
+	14.6953f,
+	218.75f,
+	125.0f,
+	14.2707f,
+	218.75f,
+	128.906f,
+	15.9556f,
+	218.75f,
+	132.813f,
+	16.7068f,
+	218.75f,
+	136.719f,
+	17.6679f,
+	218.75f,
+	140.625f,
+	18.8257f,
+	218.75f,
+	144.531f,
+	24.2255f,
+	218.75f,
+	148.438f,
+	25.0749f,
+	218.75f,
+	152.344f,
+	25.9271f,
+	218.75f,
+	156.25f,
+	26.2032f,
+	218.75f,
+	160.156f,
+	24.5168f,
+	218.75f,
+	164.063f,
+	26.2403f,
+	218.75f,
+	167.969f,
+	26.6223f,
+	218.75f,
+	171.875f,
+	22.4271f,
+	218.75f,
+	175.781f,
+	23.7925f,
+	218.75f,
+	179.688f,
+	23.3478f,
+	218.75f,
+	183.594f,
+	22.2279f,
+	218.75f,
+	187.5f,
+	22.2148f,
+	218.75f,
+	191.406f,
+	20.7538f,
+	218.75f,
+	195.313f,
+	19.5131f,
+	218.75f,
+	199.219f,
+	19.4834f,
+	218.75f,
+	203.125f,
+	18.3756f,
+	218.75f,
+	207.031f,
+	18.1034f,
+	218.75f,
+	210.938f,
+	20.0003f,
+	218.75f,
+	214.844f,
+	22.2111f,
+	218.75f,
+	218.75f,
+	21.6123f,
+	218.75f,
+	222.656f,
+	22.5943f,
+	218.75f,
+	226.563f,
+	24.3115f,
+	218.75f,
+	230.469f,
+	19.0536f,
+	218.75f,
+	234.375f,
+	18.6613f,
+	218.75f,
+	238.281f,
+	18.7675f,
+	218.75f,
+	242.188f,
+	18.3163f,
+	218.75f,
+	246.094f,
+	16.7013f,
+	218.75f,
+	250.0f,
+	17.0786f,
+	218.75f,
+	3.90627f,
+	9.25513f,
+	214.844f,
+	7.81251f,
+	9.67426f,
+	214.844f,
+	11.7188f,
+	8.92139f,
+	214.844f,
+	15.625f,
+	6.90738f,
+	214.844f,
+	19.5313f,
+	6.12616f,
+	214.844f,
+	23.4375f,
+	4.98302f,
+	214.844f,
+	27.3438f,
+	3.63786f,
+	214.844f,
+	31.25f,
+	2.52097f,
+	214.844f,
+	35.1563f,
+	3.30816f,
+	214.844f,
+	39.0625f,
+	4.04406f,
+	214.844f,
+	42.9688f,
+	4.48446f,
+	214.844f,
+	46.875f,
+	4.40695f,
+	214.844f,
+	50.7813f,
+	3.7693f,
+	214.844f,
+	54.6875f,
+	2.85523f,
+	214.844f,
+	58.5938f,
+	2.56849f,
+	214.844f,
+	62.5f,
+	2.56561f,
+	214.844f,
+	66.4063f,
+	2.82937f,
+	214.844f,
+	70.3125f,
+	2.75221f,
+	214.844f,
+	74.2188f,
+	5.02974f,
+	214.844f,
+	78.125f,
+	5.7988f,
+	214.844f,
+	82.0313f,
+	6.03219f,
+	214.844f,
+	85.9375f,
+	6.27423f,
+	214.844f,
+	89.8438f,
+	6.1671f,
+	214.844f,
+	93.75f,
+	6.86893f,
+	214.844f,
+	97.6563f,
+	7.94747f,
+	214.844f,
+	101.563f,
+	9.13548f,
+	214.844f,
+	105.469f,
+	9.63636f,
+	214.844f,
+	109.375f,
+	10.3351f,
+	214.844f,
+	113.281f,
+	12.4028f,
+	214.844f,
+	117.188f,
+	13.0321f,
+	214.844f,
+	121.094f,
+	13.6284f,
+	214.844f,
+	125.0f,
+	14.3167f,
+	214.844f,
+	128.906f,
+	15.0573f,
+	214.844f,
+	132.813f,
+	16.2022f,
+	214.844f,
+	136.719f,
+	17.7526f,
+	214.844f,
+	140.625f,
+	23.7093f,
+	214.844f,
+	144.531f,
+	24.3603f,
+	214.844f,
+	148.438f,
+	24.9195f,
+	214.844f,
+	152.344f,
+	25.198f,
+	214.844f,
+	156.25f,
+	20.8225f,
+	214.844f,
+	160.156f,
+	24.5918f,
+	214.844f,
+	164.063f,
+	25.1404f,
+	214.844f,
+	167.969f,
+	26.0659f,
+	214.844f,
+	171.875f,
+	22.1485f,
+	214.844f,
+	175.781f,
+	27.7236f,
+	214.844f,
+	179.688f,
+	27.4914f,
+	214.844f,
+	183.594f,
+	26.6606f,
+	214.844f,
+	187.5f,
+	26.623f,
+	214.844f,
+	191.406f,
+	26.3244f,
+	214.844f,
+	195.313f,
+	24.8535f,
+	214.844f,
+	199.219f,
+	23.6373f,
+	214.844f,
+	203.125f,
+	21.1881f,
+	214.844f,
+	207.031f,
+	19.7509f,
+	214.844f,
+	210.938f,
+	22.3046f,
+	214.844f,
+	214.844f,
+	22.5297f,
+	214.844f,
+	218.75f,
+	22.9498f,
+	214.844f,
+	222.656f,
+	23.2271f,
+	214.844f,
+	226.563f,
+	24.89f,
+	214.844f,
+	230.469f,
+	23.5226f,
+	214.844f,
+	234.375f,
+	19.0463f,
+	214.844f,
+	238.281f,
+	17.96f,
+	214.844f,
+	242.188f,
+	18.8106f,
+	214.844f,
+	246.094f,
+	17.3168f,
+	214.844f,
+	250.0f,
+	16.7955f,
+	214.844f,
+	3.90627f,
+	10.5728f,
+	210.938f,
+	7.81251f,
+	9.81018f,
+	210.938f,
+	11.7188f,
+	9.69715f,
+	210.938f,
+	15.625f,
+	8.42137f,
+	210.938f,
+	19.5313f,
+	7.09174f,
+	210.938f,
+	23.4375f,
+	6.45357f,
+	210.938f,
+	27.3438f,
+	4.58257f,
+	210.938f,
+	31.25f,
+	4.31044f,
+	210.938f,
+	35.1563f,
+	4.23584f,
+	210.938f,
+	39.0625f,
+	4.77527f,
+	210.938f,
+	42.9688f,
+	5.51217f,
+	210.938f,
+	46.875f,
+	5.48962f,
+	210.938f,
+	50.7813f,
+	4.50211f,
+	210.938f,
+	54.6875f,
+	4.06287f,
+	210.938f,
+	58.5938f,
+	3.43161f,
+	210.938f,
+	62.5f,
+	3.43195f,
+	210.938f,
+	66.4063f,
+	3.64204f,
+	210.938f,
+	70.3125f,
+	5.16151f,
+	210.938f,
+	74.2188f,
+	6.72853f,
+	210.938f,
+	78.125f,
+	7.43878f,
+	210.938f,
+	82.0313f,
+	7.30716f,
+	210.938f,
+	85.9375f,
+	6.54327f,
+	210.938f,
+	89.8438f,
+	5.96003f,
+	210.938f,
+	93.75f,
+	6.45099f,
+	210.938f,
+	97.6563f,
+	8.32748f,
+	210.938f,
+	101.563f,
+	8.85186f,
+	210.938f,
+	105.469f,
+	9.64058f,
+	210.938f,
+	109.375f,
+	10.4181f,
+	210.938f,
+	113.281f,
+	11.6911f,
+	210.938f,
+	117.188f,
+	12.0508f,
+	210.938f,
+	121.094f,
+	13.1004f,
+	210.938f,
+	125.0f,
+	14.4899f,
+	210.938f,
+	128.906f,
+	15.1295f,
+	210.938f,
+	132.813f,
+	15.6195f,
+	210.938f,
+	136.719f,
+	16.9219f,
+	210.938f,
+	140.625f,
+	23.4614f,
+	210.938f,
+	144.531f,
+	24.6763f,
+	210.938f,
+	148.438f,
+	26.12f,
+	210.938f,
+	152.344f,
+	21.7533f,
+	210.938f,
+	156.25f,
+	20.7448f,
+	210.938f,
+	160.156f,
+	24.1481f,
+	210.938f,
+	164.063f,
+	26.0464f,
+	210.938f,
+	167.969f,
+	25.1633f,
+	210.938f,
+	171.875f,
+	20.8056f,
+	210.938f,
+	175.781f,
+	26.3651f,
+	210.938f,
+	179.688f,
+	25.5322f,
+	210.938f,
+	183.594f,
+	26.3828f,
+	210.938f,
+	187.5f,
+	26.3586f,
+	210.938f,
+	191.406f,
+	26.1714f,
+	210.938f,
+	195.313f,
+	25.9695f,
+	210.938f,
+	199.219f,
+	24.3505f,
+	210.938f,
+	203.125f,
+	23.872f,
+	210.938f,
+	207.031f,
+	23.0401f,
+	210.938f,
+	210.938f,
+	22.3904f,
+	210.938f,
+	214.844f,
+	22.7647f,
+	210.938f,
+	218.75f,
+	23.266f,
+	210.938f,
+	222.656f,
+	23.8563f,
+	210.938f,
+	226.563f,
+	24.6635f,
+	210.938f,
+	230.469f,
+	24.3846f,
+	210.938f,
+	234.375f,
+	18.3213f,
+	210.938f,
+	238.281f,
+	17.6531f,
+	210.938f,
+	242.188f,
+	17.8854f,
+	210.938f,
+	246.094f,
+	17.1692f,
+	210.938f,
+	250.0f,
+	16.127f,
+	210.938f,
+	3.90626f,
+	10.4539f,
+	207.031f,
+	7.81251f,
+	10.0241f,
+	207.031f,
+	11.7188f,
+	10.3861f,
+	207.031f,
+	15.625f,
+	8.84417f,
+	207.031f,
+	19.5313f,
+	8.35477f,
+	207.031f,
+	23.4375f,
+	6.48112f,
+	207.031f,
+	27.3438f,
+	6.10753f,
+	207.031f,
+	31.25f,
+	6.13796f,
+	207.031f,
+	35.1563f,
+	6.51045f,
+	207.031f,
+	39.0625f,
+	6.65278f,
+	207.031f,
+	42.9688f,
+	6.27698f,
+	207.031f,
+	46.875f,
+	5.80577f,
+	207.031f,
+	50.7813f,
+	5.90354f,
+	207.031f,
+	54.6875f,
+	5.66137f,
+	207.031f,
+	58.5938f,
+	4.67472f,
+	207.031f,
+	62.5f,
+	4.81103f,
+	207.031f,
+	66.4063f,
+	6.06764f,
+	207.031f,
+	70.3125f,
+	7.61387f,
+	207.031f,
+	74.2188f,
+	8.72682f,
+	207.031f,
+	78.125f,
+	9.33231f,
+	207.031f,
+	82.0313f,
+	8.49751f,
+	207.031f,
+	85.9375f,
+	7.85293f,
+	207.031f,
+	89.8438f,
+	7.37573f,
+	207.031f,
+	93.75f,
+	7.4561f,
+	207.031f,
+	97.6563f,
+	7.76623f,
+	207.031f,
+	101.563f,
+	8.68264f,
+	207.031f,
+	105.469f,
+	10.4373f,
+	207.031f,
+	109.375f,
+	10.4722f,
+	207.031f,
+	113.281f,
+	11.4418f,
+	207.031f,
+	117.188f,
+	12.3081f,
+	207.031f,
+	121.094f,
+	12.9224f,
+	207.031f,
+	125.0f,
+	14.3204f,
+	207.031f,
+	128.906f,
+	15.1746f,
+	207.031f,
+	132.813f,
+	14.4847f,
+	207.031f,
+	136.719f,
+	20.974f,
+	207.031f,
+	140.625f,
+	23.4669f,
+	207.031f,
+	144.531f,
+	24.9918f,
+	207.031f,
+	148.438f,
+	25.7345f,
+	207.031f,
+	152.344f,
+	21.4943f,
+	207.031f,
+	156.25f,
+	22.169f,
+	207.031f,
+	160.156f,
+	24.9739f,
+	207.031f,
+	164.063f,
+	26.4423f,
+	207.031f,
+	167.969f,
+	25.8928f,
+	207.031f,
+	171.875f,
+	20.5408f,
+	207.031f,
+	175.781f,
+	24.2294f,
+	207.031f,
+	179.688f,
+	24.4008f,
+	207.031f,
+	183.594f,
+	25.2809f,
+	207.031f,
+	187.5f,
+	25.8589f,
+	207.031f,
+	191.406f,
+	26.3716f,
+	207.031f,
+	195.313f,
+	26.0525f,
+	207.031f,
+	199.219f,
+	24.6109f,
+	207.031f,
+	203.125f,
+	24.1128f,
+	207.031f,
+	207.031f,
+	23.4731f,
+	207.031f,
+	210.938f,
+	22.6487f,
+	207.031f,
+	214.844f,
+	22.7977f,
+	207.031f,
+	218.75f,
+	18.4754f,
+	207.031f,
+	222.656f,
+	23.1848f,
+	207.031f,
+	226.563f,
+	23.1818f,
+	207.031f,
+	230.469f,
+	22.9194f,
+	207.031f,
+	234.375f,
+	19.8052f,
+	207.031f,
+	238.281f,
+	16.8602f,
+	207.031f,
+	242.188f,
+	17.1047f,
+	207.031f,
+	246.094f,
+	16.1145f,
+	207.031f,
+	250.0f,
+	15.0049f,
+	207.031f,
+	3.90626f,
+	11.4706f,
+	203.125f,
+	7.81251f,
+	11.0922f,
+	203.125f,
+	11.7188f,
+	11.454f,
+	203.125f,
+	15.625f,
+	10.399f,
+	203.125f,
+	19.5313f,
+	8.89365f,
+	203.125f,
+	23.4375f,
+	7.52605f,
+	203.125f,
+	27.3438f,
+	7.07779f,
+	203.125f,
+	31.25f,
+	7.98082f,
+	203.125f,
+	35.1563f,
+	8.78342f,
+	203.125f,
+	39.0625f,
+	8.87165f,
+	203.125f,
+	42.9688f,
+	8.39122f,
+	203.125f,
+	46.875f,
+	7.48032f,
+	203.125f,
+	50.7813f,
+	6.77944f,
+	203.125f,
+	54.6875f,
+	7.14862f,
+	203.125f,
+	58.5938f,
+	6.46173f,
+	203.125f,
+	62.5f,
+	6.73824f,
+	203.125f,
+	66.4063f,
+	7.64505f,
+	203.125f,
+	70.3125f,
+	9.22763f,
+	203.125f,
+	74.2188f,
+	9.87781f,
+	203.125f,
+	78.125f,
+	10.1574f,
+	203.125f,
+	82.0313f,
+	9.81606f,
+	203.125f,
+	85.9375f,
+	9.8669f,
+	203.125f,
+	89.8438f,
+	10.0032f,
+	203.125f,
+	93.75f,
+	9.76597f,
+	203.125f,
+	97.6563f,
+	9.2129f,
+	203.125f,
+	101.563f,
+	8.89917f,
+	203.125f,
+	105.469f,
+	9.85112f,
+	203.125f,
+	109.375f,
+	11.4827f,
+	203.125f,
+	113.281f,
+	11.8911f,
+	203.125f,
+	117.188f,
+	12.3305f,
+	203.125f,
+	121.094f,
+	13.6098f,
+	203.125f,
+	125.0f,
+	14.1477f,
+	203.125f,
+	128.906f,
+	14.7928f,
+	203.125f,
+	132.813f,
+	16.3422f,
+	203.125f,
+	136.719f,
+	22.7583f,
+	203.125f,
+	140.625f,
+	24.5881f,
+	203.125f,
+	144.531f,
+	25.3565f,
+	203.125f,
+	148.438f,
+	21.7799f,
+	203.125f,
+	152.344f,
+	24.1222f,
+	203.125f,
+	156.25f,
+	26.6774f,
+	203.125f,
+	160.156f,
+	25.7031f,
+	203.125f,
+	164.063f,
+	26.9766f,
+	203.125f,
+	167.969f,
+	25.936f,
+	203.125f,
+	171.875f,
+	19.7727f,
+	203.125f,
+	175.781f,
+	19.3015f,
+	203.125f,
+	179.688f,
+	19.2421f,
+	203.125f,
+	183.594f,
+	24.8014f,
+	203.125f,
+	187.5f,
+	25.3041f,
+	203.125f,
+	191.406f,
+	25.3226f,
+	203.125f,
+	195.313f,
+	20.0369f,
+	203.125f,
+	199.219f,
+	19.4927f,
+	203.125f,
+	203.125f,
+	23.4349f,
+	203.125f,
+	207.031f,
+	22.748f,
+	203.125f,
+	210.938f,
+	22.4583f,
+	203.125f,
+	214.844f,
+	18.8936f,
+	203.125f,
+	218.75f,
+	17.4565f,
+	203.125f,
+	222.656f,
+	18.8235f,
+	203.125f,
+	226.563f,
+	21.4749f,
+	203.125f,
+	230.469f,
+	21.7691f,
+	203.125f,
+	234.375f,
+	21.1398f,
+	203.125f,
+	238.281f,
+	15.9012f,
+	203.125f,
+	242.188f,
+	15.9735f,
+	203.125f,
+	246.094f,
+	15.2287f,
+	203.125f,
+	250.0f,
+	13.5655f,
+	203.125f,
+	3.90626f,
+	12.1184f,
+	199.219f,
+	7.81251f,
+	12.3652f,
+	199.219f,
+	11.7188f,
+	12.1177f,
+	199.219f,
+	15.625f,
+	11.107f,
+	199.219f,
+	19.5313f,
+	9.91183f,
+	199.219f,
+	23.4375f,
+	8.6581f,
+	199.219f,
+	27.3438f,
+	7.98212f,
+	199.219f,
+	31.25f,
+	9.14995f,
+	199.219f,
+	35.1563f,
+	10.2879f,
+	199.219f,
+	39.0625f,
+	10.2569f,
+	199.219f,
+	42.9688f,
+	9.58908f,
+	199.219f,
+	46.875f,
+	8.1296f,
+	199.219f,
+	50.7813f,
+	7.81944f,
+	199.219f,
+	54.6875f,
+	8.54521f,
+	199.219f,
+	58.5938f,
+	8.14627f,
+	199.219f,
+	62.5f,
+	8.60974f,
+	199.219f,
+	66.4063f,
+	9.63518f,
+	199.219f,
+	70.3125f,
+	10.5321f,
+	199.219f,
+	74.2188f,
+	10.3348f,
+	199.219f,
+	78.125f,
+	11.2806f,
+	199.219f,
+	82.0313f,
+	11.3874f,
+	199.219f,
+	85.9375f,
+	11.6949f,
+	199.219f,
+	89.8438f,
+	12.3833f,
+	199.219f,
+	93.75f,
+	12.4654f,
+	199.219f,
+	97.6563f,
+	11.369f,
+	199.219f,
+	101.563f,
+	10.2737f,
+	199.219f,
+	105.469f,
+	10.4291f,
+	199.219f,
+	109.375f,
+	11.0962f,
+	199.219f,
+	113.281f,
+	12.1388f,
+	199.219f,
+	117.188f,
+	12.5535f,
+	199.219f,
+	121.094f,
+	13.2826f,
+	199.219f,
+	125.0f,
+	15.1899f,
+	199.219f,
+	128.906f,
+	16.3486f,
+	199.219f,
+	132.813f,
+	17.6147f,
+	199.219f,
+	136.719f,
+	23.878f,
+	199.219f,
+	140.625f,
+	24.5901f,
+	199.219f,
+	144.531f,
+	26.2181f,
+	199.219f,
+	148.438f,
+	21.847f,
+	199.219f,
+	152.344f,
+	26.5018f,
+	199.219f,
+	156.25f,
+	26.2772f,
+	199.219f,
+	160.156f,
+	26.4621f,
+	199.219f,
+	164.063f,
+	26.1902f,
+	199.219f,
+	167.969f,
+	26.1086f,
+	199.219f,
+	171.875f,
+	20.7414f,
+	199.219f,
+	175.781f,
+	20.393f,
+	199.219f,
+	179.688f,
+	19.7885f,
+	199.219f,
+	183.594f,
+	20.9687f,
+	199.219f,
+	187.5f,
+	23.8625f,
+	199.219f,
+	191.406f,
+	24.0825f,
+	199.219f,
+	195.313f,
+	19.4921f,
+	199.219f,
+	199.219f,
+	20.8763f,
+	199.219f,
+	203.125f,
+	21.987f,
+	199.219f,
+	207.031f,
+	21.9212f,
+	199.219f,
+	210.938f,
+	20.0341f,
+	199.219f,
+	214.844f,
+	15.7998f,
+	199.219f,
+	218.75f,
+	15.7759f,
+	199.219f,
+	222.656f,
+	15.8963f,
+	199.219f,
+	226.563f,
+	19.8168f,
+	199.219f,
+	230.469f,
+	19.9894f,
+	199.219f,
+	234.375f,
+	19.4382f,
+	199.219f,
+	238.281f,
+	14.2335f,
+	199.219f,
+	242.188f,
+	14.9225f,
+	199.219f,
+	246.094f,
+	13.5857f,
+	199.219f,
+	250.0f,
+	11.7225f,
+	199.219f,
+	3.90626f,
+	13.8013f,
+	195.313f,
+	7.81251f,
+	13.8046f,
+	195.313f,
+	11.7188f,
+	13.1462f,
+	195.313f,
+	15.625f,
+	12.2626f,
+	195.313f,
+	19.5313f,
+	10.67f,
+	195.313f,
+	23.4375f,
+	10.0372f,
+	195.313f,
+	27.3438f,
+	9.3255f,
+	195.313f,
+	31.25f,
+	10.5057f,
+	195.313f,
+	35.1563f,
+	11.0615f,
+	195.313f,
+	39.0625f,
+	11.2421f,
+	195.313f,
+	42.9688f,
+	10.4767f,
+	195.313f,
+	46.875f,
+	9.03042f,
+	195.313f,
+	50.7813f,
+	9.47397f,
+	195.313f,
+	54.6875f,
+	9.65703f,
+	195.313f,
+	58.5938f,
+	9.6345f,
+	195.313f,
+	62.5f,
+	9.9552f,
+	195.313f,
+	66.4063f,
+	10.8427f,
+	195.313f,
+	70.3125f,
+	11.7912f,
+	195.313f,
+	74.2188f,
+	11.5822f,
+	195.313f,
+	78.125f,
+	13.07f,
+	195.313f,
+	82.0313f,
+	13.803f,
+	195.313f,
+	85.9375f,
+	12.9764f,
+	195.313f,
+	89.8438f,
+	14.639f,
+	195.313f,
+	93.75f,
+	14.6139f,
+	195.313f,
+	97.6563f,
+	13.3162f,
+	195.313f,
+	101.563f,
+	12.7402f,
+	195.313f,
+	105.469f,
+	12.8061f,
+	195.313f,
+	109.375f,
+	12.1167f,
+	195.313f,
+	113.281f,
+	12.705f,
+	195.313f,
+	117.188f,
+	12.4568f,
+	195.313f,
+	121.094f,
+	13.5698f,
+	195.313f,
+	125.0f,
+	15.1843f,
+	195.313f,
+	128.906f,
+	16.7529f,
+	195.313f,
+	132.813f,
+	19.1744f,
+	195.313f,
+	136.719f,
+	23.9261f,
+	195.313f,
+	140.625f,
+	25.9824f,
+	195.313f,
+	144.531f,
+	26.1631f,
+	195.313f,
+	148.438f,
+	21.4735f,
+	195.313f,
+	152.344f,
+	25.5313f,
+	195.313f,
+	156.25f,
+	27.0098f,
+	195.313f,
+	160.156f,
+	27.5776f,
+	195.313f,
+	164.063f,
+	27.0858f,
+	195.313f,
+	167.969f,
+	26.3007f,
+	195.313f,
+	171.875f,
+	23.4599f,
+	195.313f,
+	175.781f,
+	26.4252f,
+	195.313f,
+	179.688f,
+	21.1453f,
+	195.313f,
+	183.594f,
+	21.1021f,
+	195.313f,
+	187.5f,
+	25.1644f,
+	195.313f,
+	191.406f,
+	24.8681f,
+	195.313f,
+	195.313f,
+	24.1757f,
+	195.313f,
+	199.219f,
+	20.0013f,
+	195.313f,
+	203.125f,
+	23.6085f,
+	195.313f,
+	207.031f,
+	22.7043f,
+	195.313f,
+	210.938f,
+	17.4097f,
+	195.313f,
+	214.844f,
+	16.8216f,
+	195.313f,
+	218.75f,
+	16.2595f,
+	195.313f,
+	222.656f,
+	15.547f,
+	195.313f,
+	226.563f,
+	20.5074f,
+	195.313f,
+	230.469f,
+	20.0296f,
+	195.313f,
+	234.375f,
+	19.4594f,
+	195.313f,
+	238.281f,
+	14.3376f,
+	195.313f,
+	242.188f,
+	13.8667f,
+	195.313f,
+	246.094f,
+	12.7786f,
+	195.313f,
+	250.0f,
+	12.669f,
+	195.313f,
+	3.90626f,
+	14.3936f,
+	191.406f,
+	7.81251f,
+	14.3324f,
+	191.406f,
+	11.7188f,
+	13.5165f,
+	191.406f,
+	15.625f,
+	12.3486f,
+	191.406f,
+	19.5313f,
+	10.8996f,
+	191.406f,
+	23.4375f,
+	10.767f,
+	191.406f,
+	27.3438f,
+	12.0663f,
+	191.406f,
+	31.25f,
+	12.0032f,
+	191.406f,
+	35.1563f,
+	12.6763f,
+	191.406f,
+	39.0625f,
+	12.4746f,
+	191.406f,
+	42.9688f,
+	10.9305f,
+	191.406f,
+	46.875f,
+	11.0794f,
+	191.406f,
+	50.7813f,
+	11.2588f,
+	191.406f,
+	54.6875f,
+	11.0855f,
+	191.406f,
+	58.5938f,
+	10.1448f,
+	191.406f,
+	62.5f,
+	11.1184f,
+	191.406f,
+	66.4063f,
+	12.2266f,
+	191.406f,
+	70.3125f,
+	12.3132f,
+	191.406f,
+	74.2188f,
+	13.6918f,
+	191.406f,
+	78.125f,
+	14.4314f,
+	191.406f,
+	82.0313f,
+	14.6924f,
+	191.406f,
+	85.9375f,
+	15.6669f,
+	191.406f,
+	89.8438f,
+	16.085f,
+	191.406f,
+	93.75f,
+	16.2697f,
+	191.406f,
+	97.6563f,
+	16.3584f,
+	191.406f,
+	101.563f,
+	15.6226f,
+	191.406f,
+	105.469f,
+	14.7096f,
+	191.406f,
+	109.375f,
+	14.172f,
+	191.406f,
+	113.281f,
+	13.6538f,
+	191.406f,
+	117.188f,
+	14.6791f,
+	191.406f,
+	121.094f,
+	15.1835f,
+	191.406f,
+	125.0f,
+	16.4947f,
+	191.406f,
+	128.906f,
+	17.5173f,
+	191.406f,
+	132.813f,
+	22.4657f,
+	191.406f,
+	136.719f,
+	25.2206f,
+	191.406f,
+	140.625f,
+	26.6814f,
+	191.406f,
+	144.531f,
+	27.4657f,
+	191.406f,
+	148.438f,
+	22.8092f,
+	191.406f,
+	152.344f,
+	22.336f,
+	191.406f,
+	156.25f,
+	29.0833f,
+	191.406f,
+	160.156f,
+	29.5204f,
+	191.406f,
+	164.063f,
+	29.4008f,
+	191.406f,
+	167.969f,
+	28.5038f,
+	191.406f,
+	171.875f,
+	27.7213f,
+	191.406f,
+	175.781f,
+	27.6884f,
+	191.406f,
+	179.688f,
+	25.8434f,
+	191.406f,
+	183.594f,
+	23.3048f,
+	191.406f,
+	187.5f,
+	27.635f,
+	191.406f,
+	191.406f,
+	26.1341f,
+	191.406f,
+	195.313f,
+	26.6792f,
+	191.406f,
+	199.219f,
+	22.747f,
+	191.406f,
+	203.125f,
+	22.8472f,
+	191.406f,
+	207.031f,
+	21.8628f,
+	191.406f,
+	210.938f,
+	20.5896f,
+	191.406f,
+	214.844f,
+	20.683f,
+	191.406f,
+	218.75f,
+	15.9904f,
+	191.406f,
+	222.656f,
+	16.3766f,
+	191.406f,
+	226.563f,
+	21.611f,
+	191.406f,
+	230.469f,
+	20.8727f,
+	191.406f,
+	234.375f,
+	20.2044f,
+	191.406f,
+	238.281f,
+	15.3358f,
+	191.406f,
+	242.188f,
+	14.7065f,
+	191.406f,
+	246.094f,
+	14.4372f,
+	191.406f,
+	250.0f,
+	14.1124f,
+	191.406f,
+	3.90626f,
+	14.1738f,
+	187.5f,
+	7.81252f,
+	14.5502f,
+	187.5f,
+	11.7188f,
+	13.6083f,
+	187.5f,
+	15.625f,
+	12.2654f,
+	187.5f,
+	19.5313f,
+	11.7405f,
+	187.5f,
+	23.4375f,
+	12.3756f,
+	187.5f,
+	27.3438f,
+	14.0775f,
+	187.5f,
+	31.25f,
+	13.9675f,
+	187.5f,
+	35.1563f,
+	14.3286f,
+	187.5f,
+	39.0625f,
+	13.1055f,
+	187.5f,
+	42.9688f,
+	13.0413f,
+	187.5f,
+	46.875f,
+	13.318f,
+	187.5f,
+	50.7813f,
+	12.9383f,
+	187.5f,
+	54.6875f,
+	12.9366f,
+	187.5f,
+	58.5938f,
+	12.1308f,
+	187.5f,
+	62.5f,
+	12.8501f,
+	187.5f,
+	66.4063f,
+	13.0312f,
+	187.5f,
+	70.3125f,
+	13.1657f,
+	187.5f,
+	74.2188f,
+	14.6177f,
+	187.5f,
+	78.125f,
+	16.1865f,
+	187.5f,
+	82.0313f,
+	16.3194f,
+	187.5f,
+	85.9375f,
+	16.9023f,
+	187.5f,
+	89.8438f,
+	17.5469f,
+	187.5f,
+	93.75f,
+	18.1166f,
+	187.5f,
+	97.6563f,
+	18.7398f,
+	187.5f,
+	101.563f,
+	18.2643f,
+	187.5f,
+	105.469f,
+	17.5115f,
+	187.5f,
+	109.375f,
+	16.8559f,
+	187.5f,
+	113.281f,
+	15.8332f,
+	187.5f,
+	117.188f,
+	16.4429f,
+	187.5f,
+	121.094f,
+	17.0698f,
+	187.5f,
+	125.0f,
+	18.0389f,
+	187.5f,
+	128.906f,
+	19.8697f,
+	187.5f,
+	132.813f,
+	24.8511f,
+	187.5f,
+	136.719f,
+	26.6838f,
+	187.5f,
+	140.625f,
+	28.5323f,
+	187.5f,
+	144.531f,
+	28.756f,
+	187.5f,
+	148.438f,
+	25.5762f,
+	187.5f,
+	152.344f,
+	25.8993f,
+	187.5f,
+	156.25f,
+	29.0469f,
+	187.5f,
+	160.156f,
+	32.1254f,
+	187.5f,
+	164.063f,
+	32.1318f,
+	187.5f,
+	167.969f,
+	31.7887f,
+	187.5f,
+	171.875f,
+	30.3727f,
+	187.5f,
+	175.781f,
+	30.1222f,
+	187.5f,
+	179.688f,
+	30.3556f,
+	187.5f,
+	183.594f,
+	30.49f,
+	187.5f,
+	187.5f,
+	29.3956f,
+	187.5f,
+	191.406f,
+	30.6569f,
+	187.5f,
+	195.313f,
+	30.8632f,
+	187.5f,
+	199.219f,
+	26.1118f,
+	187.5f,
+	203.125f,
+	25.5008f,
+	187.5f,
+	207.031f,
+	24.7878f,
+	187.5f,
+	210.938f,
+	27.5453f,
+	187.5f,
+	214.844f,
+	25.5271f,
+	187.5f,
+	218.75f,
+	20.2295f,
+	187.5f,
+	222.656f,
+	17.2785f,
+	187.5f,
+	226.563f,
+	22.0337f,
+	187.5f,
+	230.469f,
+	22.1938f,
+	187.5f,
+	234.375f,
+	21.6646f,
+	187.5f,
+	238.281f,
+	16.8654f,
+	187.5f,
+	242.188f,
+	15.704f,
+	187.5f,
+	246.094f,
+	15.9973f,
+	187.5f,
+	250.0f,
+	15.209f,
+	187.5f,
+	3.90626f,
+	13.9878f,
+	183.594f,
+	7.81252f,
+	14.3413f,
+	183.594f,
+	11.7188f,
+	13.1779f,
+	183.594f,
+	15.625f,
+	12.8538f,
+	183.594f,
+	19.5313f,
+	13.9436f,
+	183.594f,
+	23.4375f,
+	14.716f,
+	183.594f,
+	27.3438f,
+	14.991f,
+	183.594f,
+	31.25f,
+	15.4235f,
+	183.594f,
+	35.1563f,
+	15.3865f,
+	183.594f,
+	39.0625f,
+	14.2459f,
+	183.594f,
+	42.9688f,
+	15.2992f,
+	183.594f,
+	46.875f,
+	16.0599f,
+	183.594f,
+	50.7813f,
+	14.8603f,
+	183.594f,
+	54.6875f,
+	14.9726f,
+	183.594f,
+	58.5938f,
+	13.6053f,
+	183.594f,
+	62.5f,
+	13.057f,
+	183.594f,
+	66.4063f,
+	13.4201f,
+	183.594f,
+	70.3125f,
+	14.0782f,
+	183.594f,
+	74.2188f,
+	15.3178f,
+	183.594f,
+	78.125f,
+	16.3995f,
+	183.594f,
+	82.0313f,
+	17.4379f,
+	183.594f,
+	85.9375f,
+	17.9502f,
+	183.594f,
+	89.8438f,
+	18.4811f,
+	183.594f,
+	93.75f,
+	19.4227f,
+	183.594f,
+	97.6563f,
+	20.1694f,
+	183.594f,
+	101.563f,
+	20.1609f,
+	183.594f,
+	105.469f,
+	19.5537f,
+	183.594f,
+	109.375f,
+	19.039f,
+	183.594f,
+	113.281f,
+	18.2247f,
+	183.594f,
+	117.188f,
+	18.6643f,
+	183.594f,
+	121.094f,
+	19.2334f,
+	183.594f,
+	125.0f,
+	20.4158f,
+	183.594f,
+	128.906f,
+	21.1136f,
+	183.594f,
+	132.813f,
+	25.6638f,
+	183.594f,
+	136.719f,
+	27.4642f,
+	183.594f,
+	140.625f,
+	29.0749f,
+	183.594f,
+	144.531f,
+	30.6966f,
+	183.594f,
+	148.438f,
+	26.933f,
+	183.594f,
+	152.344f,
+	27.9984f,
+	183.594f,
+	156.25f,
+	28.4094f,
+	183.594f,
+	160.156f,
+	33.857f,
+	183.594f,
+	164.063f,
+	34.6528f,
+	183.594f,
+	167.969f,
+	33.405f,
+	183.594f,
+	171.875f,
+	31.8412f,
+	183.594f,
+	175.781f,
+	31.8788f,
+	183.594f,
+	179.688f,
+	32.395f,
+	183.594f,
+	183.594f,
+	32.8498f,
+	183.594f,
+	187.5f,
+	28.7385f,
+	183.594f,
+	191.406f,
+	33.6253f,
+	183.594f,
+	195.313f,
+	32.9673f,
+	183.594f,
+	199.219f,
+	31.8413f,
+	183.594f,
+	203.125f,
+	26.491f,
+	183.594f,
+	207.031f,
+	29.4589f,
+	183.594f,
+	210.938f,
+	28.7843f,
+	183.594f,
+	214.844f,
+	26.577f,
+	183.594f,
+	218.75f,
+	25.0304f,
+	183.594f,
+	222.656f,
+	18.7948f,
+	183.594f,
+	226.563f,
+	23.1467f,
+	183.594f,
+	230.469f,
+	22.3329f,
+	183.594f,
+	234.375f,
+	21.6877f,
+	183.594f,
+	238.281f,
+	16.4114f,
+	183.594f,
+	242.188f,
+	16.4672f,
+	183.594f,
+	246.094f,
+	16.3324f,
+	183.594f,
+	250.0f,
+	16.0497f,
+	183.594f,
+	3.90626f,
+	14.6785f,
+	179.688f,
+	7.81252f,
+	14.4582f,
+	179.688f,
+	11.7188f,
+	13.7379f,
+	179.688f,
+	15.625f,
+	13.9816f,
+	179.688f,
+	19.5313f,
+	14.9647f,
+	179.688f,
+	23.4375f,
+	15.3633f,
+	179.688f,
+	27.3438f,
+	16.1346f,
+	179.688f,
+	31.25f,
+	16.4088f,
+	179.688f,
+	35.1563f,
+	16.195f,
+	179.688f,
+	39.0625f,
+	16.1785f,
+	179.688f,
+	42.9688f,
+	17.2534f,
+	179.688f,
+	46.875f,
+	17.329f,
+	179.688f,
+	50.7813f,
+	16.0096f,
+	179.688f,
+	54.6875f,
+	15.4766f,
+	179.688f,
+	58.5938f,
+	14.0828f,
+	179.688f,
+	62.5f,
+	12.8927f,
+	179.688f,
+	66.4063f,
+	14.1195f,
+	179.688f,
+	70.3125f,
+	14.9421f,
+	179.688f,
+	74.2188f,
+	15.9015f,
+	179.688f,
+	78.125f,
+	17.3756f,
+	179.688f,
+	82.0313f,
+	18.6339f,
+	179.688f,
+	85.9375f,
+	19.7602f,
+	179.688f,
+	89.8438f,
+	19.8522f,
+	179.688f,
+	93.75f,
+	20.5838f,
+	179.688f,
+	97.6563f,
+	21.2938f,
+	179.688f,
+	101.563f,
+	21.1808f,
+	179.688f,
+	105.469f,
+	21.4575f,
+	179.688f,
+	109.375f,
+	21.1629f,
+	179.688f,
+	113.281f,
+	20.4789f,
+	179.688f,
+	117.188f,
+	20.5729f,
+	179.688f,
+	121.094f,
+	20.3917f,
+	179.688f,
+	125.0f,
+	21.8501f,
+	179.688f,
+	128.906f,
+	22.6846f,
+	179.688f,
+	132.813f,
+	23.4145f,
+	179.688f,
+	136.719f,
+	28.3033f,
+	179.688f,
+	140.625f,
+	30.5638f,
+	179.688f,
+	144.531f,
+	32.761f,
+	179.688f,
+	148.438f,
+	29.4434f,
+	179.688f,
+	152.344f,
+	30.346f,
+	179.688f,
+	156.25f,
+	31.7037f,
+	179.688f,
+	160.156f,
+	36.287f,
+	179.688f,
+	164.063f,
+	36.7423f,
+	179.688f,
+	167.969f,
+	35.7482f,
+	179.688f,
+	171.875f,
+	30.0008f,
+	179.688f,
+	175.781f,
+	29.6748f,
+	179.688f,
+	179.688f,
+	34.5316f,
+	179.688f,
+	183.594f,
+	34.4476f,
+	179.688f,
+	187.5f,
+	34.3489f,
+	179.688f,
+	191.406f,
+	33.4208f,
+	179.688f,
+	195.313f,
+	29.5511f,
+	179.688f,
+	199.219f,
+	28.9653f,
+	179.688f,
+	203.125f,
+	28.1749f,
+	179.688f,
+	207.031f,
+	30.5574f,
+	179.688f,
+	210.938f,
+	28.6513f,
+	179.688f,
+	214.844f,
+	27.1867f,
+	179.688f,
+	218.75f,
+	20.8455f,
+	179.688f,
+	222.656f,
+	20.3256f,
+	179.688f,
+	226.563f,
+	24.3717f,
+	179.688f,
+	230.469f,
+	23.2197f,
+	179.688f,
+	234.375f,
+	21.6566f,
+	179.688f,
+	238.281f,
+	16.2487f,
+	179.688f,
+	242.188f,
+	16.7759f,
+	179.688f,
+	246.094f,
+	16.5259f,
+	179.688f,
+	250.0f,
+	15.8782f,
+	179.688f,
+	3.90626f,
+	15.2963f,
+	175.781f,
+	7.81252f,
+	15.075f,
+	175.781f,
+	11.7188f,
+	14.8069f,
+	175.781f,
+	15.625f,
+	14.4469f,
+	175.781f,
+	19.5313f,
+	15.8073f,
+	175.781f,
+	23.4375f,
+	16.5419f,
+	175.781f,
+	27.3438f,
+	16.7791f,
+	175.781f,
+	31.25f,
+	17.1945f,
+	175.781f,
+	35.1563f,
+	16.9974f,
+	175.781f,
+	39.0625f,
+	16.9655f,
+	175.781f,
+	42.9688f,
+	17.7583f,
+	175.781f,
+	46.875f,
+	18.115f,
+	175.781f,
+	50.7813f,
+	16.6524f,
+	175.781f,
+	54.6875f,
+	15.897f,
+	175.781f,
+	58.5938f,
+	15.4613f,
+	175.781f,
+	62.5f,
+	14.3684f,
+	175.781f,
+	66.4063f,
+	15.0403f,
+	175.781f,
+	70.3125f,
+	15.9604f,
+	175.781f,
+	74.2188f,
+	16.9477f,
+	175.781f,
+	78.125f,
+	18.0563f,
+	175.781f,
+	82.0313f,
+	18.8971f,
+	175.781f,
+	85.9375f,
+	20.1037f,
+	175.781f,
+	89.8438f,
+	20.3627f,
+	175.781f,
+	93.75f,
+	20.0215f,
+	175.781f,
+	97.6563f,
+	20.8917f,
+	175.781f,
+	101.563f,
+	21.8702f,
+	175.781f,
+	105.469f,
+	22.7304f,
+	175.781f,
+	109.375f,
+	22.6873f,
+	175.781f,
+	113.281f,
+	21.4896f,
+	175.781f,
+	117.188f,
+	21.3864f,
+	175.781f,
+	121.094f,
+	22.4194f,
+	175.781f,
+	125.0f,
+	23.5751f,
+	175.781f,
+	128.906f,
+	23.9616f,
+	175.781f,
+	132.813f,
+	24.6066f,
+	175.781f,
+	136.719f,
+	30.8792f,
+	175.781f,
+	140.625f,
+	31.6572f,
+	175.781f,
+	144.531f,
+	34.2264f,
+	175.781f,
+	148.438f,
+	30.9611f,
+	175.781f,
+	152.344f,
+	35.8851f,
+	175.781f,
+	156.25f,
+	38.6379f,
+	175.781f,
+	160.156f,
+	39.1098f,
+	175.781f,
+	164.063f,
+	39.046f,
+	175.781f,
+	167.969f,
+	38.0327f,
+	175.781f,
+	171.875f,
+	36.6611f,
+	175.781f,
+	175.781f,
+	36.0664f,
+	175.781f,
+	179.688f,
+	36.1227f,
+	175.781f,
+	183.594f,
+	36.0705f,
+	175.781f,
+	187.5f,
+	35.9099f,
+	175.781f,
+	191.406f,
+	30.4106f,
+	175.781f,
+	195.313f,
+	30.0475f,
+	175.781f,
+	199.219f,
+	28.9213f,
+	175.781f,
+	203.125f,
+	32.8995f,
+	175.781f,
+	207.031f,
+	31.2376f,
+	175.781f,
+	210.938f,
+	30.0194f,
+	175.781f,
+	214.844f,
+	23.402f,
+	175.781f,
+	218.75f,
+	21.7271f,
+	175.781f,
+	222.656f,
+	20.0594f,
+	175.781f,
+	226.563f,
+	25.2266f,
+	175.781f,
+	230.469f,
+	24.1549f,
+	175.781f,
+	234.375f,
+	22.0418f,
+	175.781f,
+	238.281f,
+	15.6301f,
+	175.781f,
+	242.188f,
+	15.4767f,
+	175.781f,
+	246.094f,
+	15.8876f,
+	175.781f,
+	250.0f,
+	15.1339f,
+	175.781f,
+	3.90626f,
+	16.0791f,
+	171.875f,
+	7.81251f,
+	16.012f,
+	171.875f,
+	11.7188f,
+	15.027f,
+	171.875f,
+	15.625f,
+	15.1362f,
+	171.875f,
+	19.5313f,
+	16.3622f,
+	171.875f,
+	23.4375f,
+	16.7304f,
+	171.875f,
+	27.3438f,
+	17.228f,
+	171.875f,
+	31.25f,
+	16.4882f,
+	171.875f,
+	35.1563f,
+	16.5399f,
+	171.875f,
+	39.0625f,
+	17.5505f,
+	171.875f,
+	42.9688f,
+	17.6944f,
+	171.875f,
+	46.875f,
+	17.7481f,
+	171.875f,
+	50.7813f,
+	17.4568f,
+	171.875f,
+	54.6875f,
+	16.5655f,
+	171.875f,
+	58.5938f,
+	15.4313f,
+	171.875f,
+	62.5f,
+	14.962f,
+	171.875f,
+	66.4063f,
+	15.2516f,
+	171.875f,
+	70.3125f,
+	16.3088f,
+	171.875f,
+	74.2188f,
+	17.5354f,
+	171.875f,
+	78.125f,
+	18.5759f,
+	171.875f,
+	82.0313f,
+	19.1666f,
+	171.875f,
+	85.9375f,
+	19.8244f,
+	171.875f,
+	89.8438f,
+	20.6303f,
+	171.875f,
+	93.75f,
+	20.5635f,
+	171.875f,
+	97.6563f,
+	20.5768f,
+	171.875f,
+	101.563f,
+	21.542f,
+	171.875f,
+	105.469f,
+	22.5605f,
+	171.875f,
+	109.375f,
+	23.0118f,
+	171.875f,
+	113.281f,
+	22.6086f,
+	171.875f,
+	117.188f,
+	22.8502f,
+	171.875f,
+	121.094f,
+	23.2278f,
+	171.875f,
+	125.0f,
+	24.368f,
+	171.875f,
+	128.906f,
+	25.5759f,
+	171.875f,
+	132.813f,
+	27.7217f,
+	171.875f,
+	136.719f,
+	33.4581f,
+	171.875f,
+	140.625f,
+	33.4128f,
+	171.875f,
+	144.531f,
+	34.9465f,
+	171.875f,
+	148.438f,
+	31.4923f,
+	171.875f,
+	152.344f,
+	38.6707f,
+	171.875f,
+	156.25f,
+	40.2713f,
+	171.875f,
+	160.156f,
+	40.4155f,
+	171.875f,
+	164.063f,
+	41.0232f,
+	171.875f,
+	167.969f,
+	39.781f,
+	171.875f,
+	171.875f,
+	37.8376f,
+	171.875f,
+	175.781f,
+	38.0559f,
+	171.875f,
+	179.688f,
+	32.0147f,
+	171.875f,
+	183.594f,
+	35.2298f,
+	171.875f,
+	187.5f,
+	34.7221f,
+	171.875f,
+	191.406f,
+	31.5516f,
+	171.875f,
+	195.313f,
+	28.9984f,
+	171.875f,
+	199.219f,
+	29.8767f,
+	171.875f,
+	203.125f,
+	32.6404f,
+	171.875f,
+	207.031f,
+	31.3413f,
+	171.875f,
+	210.938f,
+	28.4132f,
+	171.875f,
+	214.844f,
+	22.9909f,
+	171.875f,
+	218.75f,
+	21.3955f,
+	171.875f,
+	222.656f,
+	25.3135f,
+	171.875f,
+	226.563f,
+	25.1463f,
+	171.875f,
+	230.469f,
+	23.4716f,
+	171.875f,
+	234.375f,
+	22.494f,
+	171.875f,
+	238.281f,
+	15.9351f,
+	171.875f,
+	242.188f,
+	15.2882f,
+	171.875f,
+	246.094f,
+	14.8463f,
+	171.875f,
+	250.0f,
+	14.5269f,
+	171.875f,
+	3.90626f,
+	17.1455f,
+	167.969f,
+	7.81251f,
+	16.6981f,
+	167.969f,
+	11.7188f,
+	16.5681f,
+	167.969f,
+	15.625f,
+	16.1667f,
+	167.969f,
+	19.5313f,
+	16.3523f,
+	167.969f,
+	23.4375f,
+	16.5389f,
+	167.969f,
+	27.3438f,
+	16.8075f,
+	167.969f,
+	31.25f,
+	17.1987f,
+	167.969f,
+	35.1563f,
+	17.86f,
+	167.969f,
+	39.0625f,
+	18.5438f,
+	167.969f,
+	42.9688f,
+	18.6718f,
+	167.969f,
+	46.875f,
+	17.9387f,
+	167.969f,
+	50.7813f,
+	17.5403f,
+	167.969f,
+	54.6875f,
+	17.4895f,
+	167.969f,
+	58.5938f,
+	16.9679f,
+	167.969f,
+	62.5f,
+	16.2192f,
+	167.969f,
+	66.4063f,
+	15.5699f,
+	167.969f,
+	70.3125f,
+	17.0017f,
+	167.969f,
+	74.2188f,
+	18.0147f,
+	167.969f,
+	78.125f,
+	18.9836f,
+	167.969f,
+	82.0313f,
+	19.8197f,
+	167.969f,
+	85.9375f,
+	19.8969f,
+	167.969f,
+	89.8438f,
+	20.6411f,
+	167.969f,
+	93.75f,
+	20.9768f,
+	167.969f,
+	97.6563f,
+	21.1498f,
+	167.969f,
+	101.563f,
+	21.3269f,
+	167.969f,
+	105.469f,
+	22.1153f,
+	167.969f,
+	109.375f,
+	22.208f,
+	167.969f,
+	113.281f,
+	23.2278f,
+	167.969f,
+	117.188f,
+	24.5722f,
+	167.969f,
+	121.094f,
+	25.3921f,
+	167.969f,
+	125.0f,
+	26.2683f,
+	167.969f,
+	128.906f,
+	28.138f,
+	167.969f,
+	132.813f,
+	29.9483f,
+	167.969f,
+	136.719f,
+	34.7607f,
+	167.969f,
+	140.625f,
+	35.3745f,
+	167.969f,
+	144.531f,
+	36.1401f,
+	167.969f,
+	148.438f,
+	38.0587f,
+	167.969f,
+	152.344f,
+	40.0092f,
+	167.969f,
+	156.25f,
+	40.9205f,
+	167.969f,
+	160.156f,
+	41.4664f,
+	167.969f,
+	164.063f,
+	41.8834f,
+	167.969f,
+	167.969f,
+	40.2863f,
+	167.969f,
+	171.875f,
+	38.4111f,
+	167.969f,
+	175.781f,
+	37.4971f,
+	167.969f,
+	179.688f,
+	32.0995f,
+	167.969f,
+	183.594f,
+	36.4852f,
+	167.969f,
+	187.5f,
+	34.5523f,
+	167.969f,
+	191.406f,
+	34.4101f,
+	167.969f,
+	195.313f,
+	29.577f,
+	167.969f,
+	199.219f,
+	33.7462f,
+	167.969f,
+	203.125f,
+	33.0191f,
+	167.969f,
+	207.031f,
+	31.6651f,
+	167.969f,
+	210.938f,
+	24.6623f,
+	167.969f,
+	214.844f,
+	22.6532f,
+	167.969f,
+	218.75f,
+	21.898f,
+	167.969f,
+	222.656f,
+	26.1764f,
+	167.969f,
+	226.563f,
+	24.7619f,
+	167.969f,
+	230.469f,
+	22.6772f,
+	167.969f,
+	234.375f,
+	17.6202f,
+	167.969f,
+	238.281f,
+	16.1581f,
+	167.969f,
+	242.188f,
+	14.7308f,
+	167.969f,
+	246.094f,
+	14.294f,
+	167.969f,
+	250.0f,
+	13.1169f,
+	167.969f,
+	3.90627f,
+	16.4621f,
+	164.063f,
+	7.81251f,
+	17.581f,
+	164.063f,
+	11.7188f,
+	17.7296f,
+	164.063f,
+	15.625f,
+	17.126f,
+	164.063f,
+	19.5313f,
+	17.3484f,
+	164.063f,
+	23.4375f,
+	17.9863f,
+	164.063f,
+	27.3438f,
+	18.6623f,
+	164.063f,
+	31.25f,
+	18.7934f,
+	164.063f,
+	35.1563f,
+	18.8245f,
+	164.063f,
+	39.0625f,
+	18.9554f,
+	164.063f,
+	42.9688f,
+	19.3152f,
+	164.063f,
+	46.875f,
+	18.5996f,
+	164.063f,
+	50.7813f,
+	18.0094f,
+	164.063f,
+	54.6875f,
+	17.5702f,
+	164.063f,
+	58.5938f,
+	17.5846f,
+	164.063f,
+	62.5f,
+	17.3718f,
+	164.063f,
+	66.4063f,
+	17.7189f,
+	164.063f,
+	70.3125f,
+	17.9805f,
+	164.063f,
+	74.2188f,
+	18.2986f,
+	164.063f,
+	78.125f,
+	18.9566f,
+	164.063f,
+	82.0313f,
+	20.4142f,
+	164.063f,
+	85.9375f,
+	20.5066f,
+	164.063f,
+	89.8438f,
+	20.7654f,
+	164.063f,
+	93.75f,
+	20.9457f,
+	164.063f,
+	97.6563f,
+	21.1078f,
+	164.063f,
+	101.563f,
+	20.7505f,
+	164.063f,
+	105.469f,
+	21.4615f,
+	164.063f,
+	109.375f,
+	22.8061f,
+	164.063f,
+	113.281f,
+	24.2655f,
+	164.063f,
+	117.188f,
+	24.815f,
+	164.063f,
+	121.094f,
+	26.3141f,
+	164.063f,
+	125.0f,
+	28.393f,
+	164.063f,
+	128.906f,
+	30.0565f,
+	164.063f,
+	132.813f,
+	31.4858f,
+	164.063f,
+	136.719f,
+	31.6549f,
+	164.063f,
+	140.625f,
+	37.0597f,
+	164.063f,
+	144.531f,
+	37.7613f,
+	164.063f,
+	148.438f,
+	38.9888f,
+	164.063f,
+	152.344f,
+	39.1482f,
+	164.063f,
+	156.25f,
+	36.6367f,
+	164.063f,
+	160.156f,
+	41.2606f,
+	164.063f,
+	164.063f,
+	42.2366f,
+	164.063f,
+	167.969f,
+	40.9757f,
+	164.063f,
+	171.875f,
+	33.9016f,
+	164.063f,
+	175.781f,
+	34.1798f,
+	164.063f,
+	179.688f,
+	33.0682f,
+	164.063f,
+	183.594f,
+	35.2269f,
+	164.063f,
+	187.5f,
+	35.1129f,
+	164.063f,
+	191.406f,
+	34.7006f,
+	164.063f,
+	195.313f,
+	30.1221f,
+	164.063f,
+	199.219f,
+	34.6592f,
+	164.063f,
+	203.125f,
+	33.6195f,
+	164.063f,
+	207.031f,
+	30.0546f,
+	164.063f,
+	210.938f,
+	24.8295f,
+	164.063f,
+	214.844f,
+	23.0298f,
+	164.063f,
+	218.75f,
+	26.5636f,
+	164.063f,
+	222.656f,
+	25.7973f,
+	164.063f,
+	226.563f,
+	23.7612f,
+	164.063f,
+	230.469f,
+	22.3646f,
+	164.063f,
+	234.375f,
+	16.1956f,
+	164.063f,
+	238.281f,
+	14.863f,
+	164.063f,
+	242.188f,
+	13.95f,
+	164.063f,
+	246.094f,
+	14.1968f,
+	164.063f,
+	250.0f,
+	13.2951f,
+	164.063f,
+	3.90627f,
+	16.628f,
+	160.156f,
+	7.81251f,
+	17.4268f,
+	160.156f,
+	11.7188f,
+	18.0363f,
+	160.156f,
+	15.625f,
+	18.1287f,
+	160.156f,
+	19.5313f,
+	18.6222f,
+	160.156f,
+	23.4375f,
+	18.2801f,
+	160.156f,
+	27.3438f,
+	18.5912f,
+	160.156f,
+	31.25f,
+	18.8635f,
+	160.156f,
+	35.1563f,
+	19.2193f,
+	160.156f,
+	39.0625f,
+	18.8821f,
+	160.156f,
+	42.9688f,
+	19.0078f,
+	160.156f,
+	46.875f,
+	19.3506f,
+	160.156f,
+	50.7813f,
+	17.8504f,
+	160.156f,
+	54.6875f,
+	18.5322f,
+	160.156f,
+	58.5938f,
+	18.2223f,
+	160.156f,
+	62.5f,
+	18.032f,
+	160.156f,
+	66.4063f,
+	18.574f,
+	160.156f,
+	70.3125f,
+	18.3835f,
+	160.156f,
+	74.2188f,
+	18.0842f,
+	160.156f,
+	78.125f,
+	19.8632f,
+	160.156f,
+	82.0313f,
+	20.9487f,
+	160.156f,
+	85.9375f,
+	20.6197f,
+	160.156f,
+	89.8438f,
+	20.5117f,
+	160.156f,
+	93.75f,
+	20.4182f,
+	160.156f,
+	97.6563f,
+	19.8654f,
+	160.156f,
+	101.563f,
+	20.1971f,
+	160.156f,
+	105.469f,
+	22.0419f,
+	160.156f,
+	109.375f,
+	23.4698f,
+	160.156f,
+	113.281f,
+	24.6461f,
+	160.156f,
+	117.188f,
+	26.2207f,
+	160.156f,
+	121.094f,
+	28.1249f,
+	160.156f,
+	125.0f,
+	29.8102f,
+	160.156f,
+	128.906f,
+	31.7349f,
+	160.156f,
+	132.813f,
+	32.4376f,
+	160.156f,
+	136.719f,
+	33.2795f,
+	160.156f,
+	140.625f,
+	37.4588f,
+	160.156f,
+	144.531f,
+	38.8195f,
+	160.156f,
+	148.438f,
+	39.9622f,
+	160.156f,
+	152.344f,
+	41.6752f,
+	160.156f,
+	156.25f,
+	37.6576f,
+	160.156f,
+	160.156f,
+	41.4722f,
+	160.156f,
+	164.063f,
+	41.8372f,
+	160.156f,
+	167.969f,
+	40.7289f,
+	160.156f,
+	171.875f,
+	35.5243f,
+	160.156f,
+	175.781f,
+	34.1726f,
+	160.156f,
+	179.688f,
+	33.9628f,
+	160.156f,
+	183.594f,
+	33.3012f,
+	160.156f,
+	187.5f,
+	37.6064f,
+	160.156f,
+	191.406f,
+	36.2987f,
+	160.156f,
+	195.313f,
+	32.9836f,
+	160.156f,
+	199.219f,
+	34.2771f,
+	160.156f,
+	203.125f,
+	33.5607f,
+	160.156f,
+	207.031f,
+	26.9351f,
+	160.156f,
+	210.938f,
+	24.3584f,
+	160.156f,
+	214.844f,
+	25.5428f,
+	160.156f,
+	218.75f,
+	26.0054f,
+	160.156f,
+	222.656f,
+	24.092f,
+	160.156f,
+	226.563f,
+	22.8948f,
+	160.156f,
+	230.469f,
+	17.1899f,
+	160.156f,
+	234.375f,
+	15.0552f,
+	160.156f,
+	238.281f,
+	14.2468f,
+	160.156f,
+	242.188f,
+	13.7862f,
+	160.156f,
+	246.094f,
+	14.5132f,
+	160.156f,
+	250.0f,
+	14.3684f,
+	160.156f,
+	3.90627f,
+	16.9346f,
+	156.25f,
+	7.81251f,
+	18.2437f,
+	156.25f,
+	11.7188f,
+	18.3869f,
+	156.25f,
+	15.625f,
+	18.1055f,
+	156.25f,
+	19.5313f,
+	18.7445f,
+	156.25f,
+	23.4375f,
+	18.9235f,
+	156.25f,
+	27.3438f,
+	18.455f,
+	156.25f,
+	31.25f,
+	18.6644f,
+	156.25f,
+	35.1563f,
+	18.9448f,
+	156.25f,
+	39.0625f,
+	18.9971f,
+	156.25f,
+	42.9688f,
+	18.8628f,
+	156.25f,
+	46.875f,
+	18.6886f,
+	156.25f,
+	50.7813f,
+	18.8494f,
+	156.25f,
+	54.6875f,
+	19.4408f,
+	156.25f,
+	58.5938f,
+	18.7384f,
+	156.25f,
+	62.5f,
+	17.473f,
+	156.25f,
+	66.4063f,
+	18.5906f,
+	156.25f,
+	70.3125f,
+	18.7252f,
+	156.25f,
+	74.2188f,
+	19.5013f,
+	156.25f,
+	78.125f,
+	19.8221f,
+	156.25f,
+	82.0313f,
+	19.8648f,
+	156.25f,
+	85.9375f,
+	19.8955f,
+	156.25f,
+	89.8438f,
+	19.4401f,
+	156.25f,
+	93.75f,
+	18.7973f,
+	156.25f,
+	97.6563f,
+	18.8923f,
+	156.25f,
+	101.563f,
+	20.6151f,
+	156.25f,
+	105.469f,
+	22.9824f,
+	156.25f,
+	109.375f,
+	25.2251f,
+	156.25f,
+	113.281f,
+	26.7829f,
+	156.25f,
+	117.188f,
+	27.8131f,
+	156.25f,
+	121.094f,
+	29.6707f,
+	156.25f,
+	125.0f,
+	31.4614f,
+	156.25f,
+	128.906f,
+	32.8387f,
+	156.25f,
+	132.813f,
+	33.7834f,
+	156.25f,
+	136.719f,
+	34.3986f,
+	156.25f,
+	140.625f,
+	35.1609f,
+	156.25f,
+	144.531f,
+	40.0963f,
+	156.25f,
+	148.438f,
+	41.0412f,
+	156.25f,
+	152.344f,
+	42.0325f,
+	156.25f,
+	156.25f,
+	42.1696f,
+	156.25f,
+	160.156f,
+	41.9265f,
+	156.25f,
+	164.063f,
+	43.279f,
+	156.25f,
+	167.969f,
+	42.5995f,
+	156.25f,
+	171.875f,
+	36.6937f,
+	156.25f,
+	175.781f,
+	34.8393f,
+	156.25f,
+	179.688f,
+	34.7157f,
+	156.25f,
+	183.594f,
+	34.0579f,
+	156.25f,
+	187.5f,
+	33.7647f,
+	156.25f,
+	191.406f,
+	33.2242f,
+	156.25f,
+	195.313f,
+	32.1053f,
+	156.25f,
+	199.219f,
+	30.6563f,
+	156.25f,
+	203.125f,
+	33.623f,
+	156.25f,
+	207.031f,
+	28.0199f,
+	156.25f,
+	210.938f,
+	30.5092f,
+	156.25f,
+	214.844f,
+	29.3828f,
+	156.25f,
+	218.75f,
+	27.3486f,
+	156.25f,
+	222.656f,
+	25.8671f,
+	156.25f,
+	226.563f,
+	24.1209f,
+	156.25f,
+	230.469f,
+	17.9979f,
+	156.25f,
+	234.375f,
+	16.1304f,
+	156.25f,
+	238.281f,
+	14.8281f,
+	156.25f,
+	242.188f,
+	13.097f,
+	156.25f,
+	246.094f,
+	13.3642f,
+	156.25f,
+	250.0f,
+	13.6085f,
+	156.25f,
+	3.90627f,
+	17.6952f,
+	152.344f,
+	7.81251f,
+	19.1063f,
+	152.344f,
+	11.7188f,
+	19.6398f,
+	152.344f,
+	15.625f,
+	19.8626f,
+	152.344f,
+	19.5313f,
+	19.1453f,
+	152.344f,
+	23.4375f,
+	19.4932f,
+	152.344f,
+	27.3438f,
+	19.3908f,
+	152.344f,
+	31.25f,
+	18.6492f,
+	152.344f,
+	35.1563f,
+	18.3861f,
+	152.344f,
+	39.0625f,
+	18.198f,
+	152.344f,
+	42.9688f,
+	18.4497f,
+	152.344f,
+	46.875f,
+	17.8083f,
+	152.344f,
+	50.7813f,
+	18.5296f,
+	152.344f,
+	54.6875f,
+	19.8096f,
+	152.344f,
+	58.5938f,
+	19.3324f,
+	152.344f,
+	62.5f,
+	18.1507f,
+	152.344f,
+	66.4063f,
+	17.7998f,
+	152.344f,
+	70.3125f,
+	17.9266f,
+	152.344f,
+	74.2188f,
+	18.569f,
+	152.344f,
+	78.125f,
+	19.5043f,
+	152.344f,
+	82.0313f,
+	20.0768f,
+	152.344f,
+	85.9375f,
+	19.5187f,
+	152.344f,
+	89.8438f,
+	20.2592f,
+	152.344f,
+	93.75f,
+	19.2159f,
+	152.344f,
+	97.6563f,
+	20.1174f,
+	152.344f,
+	101.563f,
+	21.9257f,
+	152.344f,
+	105.469f,
+	23.9219f,
+	152.344f,
+	109.375f,
+	25.8476f,
+	152.344f,
+	113.281f,
+	27.9183f,
+	152.344f,
+	117.188f,
+	29.2798f,
+	152.344f,
+	121.094f,
+	30.2289f,
+	152.344f,
+	125.0f,
+	31.7495f,
+	152.344f,
+	128.906f,
+	33.1684f,
+	152.344f,
+	132.813f,
+	34.4626f,
+	152.344f,
+	136.719f,
+	35.9981f,
+	152.344f,
+	140.625f,
+	36.5168f,
+	152.344f,
+	144.531f,
+	35.9325f,
+	152.344f,
+	148.438f,
+	41.231f,
+	152.344f,
+	152.344f,
+	42.7257f,
+	152.344f,
+	156.25f,
+	43.5162f,
+	152.344f,
+	160.156f,
+	44.357f,
+	152.344f,
+	164.063f,
+	44.2347f,
+	152.344f,
+	167.969f,
+	40.2679f,
+	152.344f,
+	171.875f,
+	36.2109f,
+	152.344f,
+	175.781f,
+	36.3906f,
+	152.344f,
+	179.688f,
+	35.227f,
+	152.344f,
+	183.594f,
+	34.7006f,
+	152.344f,
+	187.5f,
+	34.7763f,
+	152.344f,
+	191.406f,
+	34.0912f,
+	152.344f,
+	195.313f,
+	32.201f,
+	152.344f,
+	199.219f,
+	30.6601f,
+	152.344f,
+	203.125f,
+	28.7526f,
+	152.344f,
+	207.031f,
+	33.0587f,
+	152.344f,
+	210.938f,
+	31.7955f,
+	152.344f,
+	214.844f,
+	29.893f,
+	152.344f,
+	218.75f,
+	27.5989f,
+	152.344f,
+	222.656f,
+	26.1347f,
+	152.344f,
+	226.563f,
+	19.6378f,
+	152.344f,
+	230.469f,
+	18.6596f,
+	152.344f,
+	234.375f,
+	17.3965f,
+	152.344f,
+	238.281f,
+	15.5807f,
+	152.344f,
+	242.188f,
+	13.4071f,
+	152.344f,
+	246.094f,
+	12.7989f,
+	152.344f,
+	250.0f,
+	12.5897f,
+	152.344f,
+	3.90626f,
+	18.4109f,
+	148.438f,
+	7.81251f,
+	18.8163f,
+	148.438f,
+	11.7188f,
+	20.7396f,
+	148.438f,
+	15.625f,
+	21.7833f,
+	148.438f,
+	19.5313f,
+	20.6586f,
+	148.438f,
+	23.4375f,
+	19.8597f,
+	148.438f,
+	27.3438f,
+	20.0951f,
+	148.438f,
+	31.25f,
+	18.7811f,
+	148.438f,
+	35.1563f,
+	18.123f,
+	148.438f,
+	39.0625f,
+	17.773f,
+	148.438f,
+	42.9688f,
+	18.0095f,
+	148.438f,
+	46.875f,
+	17.694f,
+	148.438f,
+	50.7813f,
+	17.1666f,
+	148.438f,
+	54.6875f,
+	18.3484f,
+	148.438f,
+	58.5938f,
+	18.5612f,
+	148.438f,
+	62.5f,
+	18.1324f,
+	148.438f,
+	66.4063f,
+	17.4119f,
+	148.438f,
+	70.3125f,
+	17.2873f,
+	148.438f,
+	74.2188f,
+	17.6855f,
+	148.438f,
+	78.125f,
+	18.6618f,
+	148.438f,
+	82.0313f,
+	19.6447f,
+	148.438f,
+	85.9375f,
+	19.4743f,
+	148.438f,
+	89.8438f,
+	20.2887f,
+	148.438f,
+	93.75f,
+	20.2469f,
+	148.438f,
+	97.6563f,
+	21.1802f,
+	148.438f,
+	101.563f,
+	23.2002f,
+	148.438f,
+	105.469f,
+	24.8874f,
+	148.438f,
+	109.375f,
+	26.5433f,
+	148.438f,
+	113.281f,
+	28.653f,
+	148.438f,
+	117.188f,
+	30.2347f,
+	148.438f,
+	121.094f,
+	31.6949f,
+	148.438f,
+	125.0f,
+	33.2452f,
+	148.438f,
+	128.906f,
+	34.3964f,
+	148.438f,
+	132.813f,
+	35.2835f,
+	148.438f,
+	136.719f,
+	36.7099f,
+	148.438f,
+	140.625f,
+	37.1893f,
+	148.438f,
+	144.531f,
+	36.5212f,
+	148.438f,
+	148.438f,
+	36.7413f,
+	148.438f,
+	152.344f,
+	43.9965f,
+	148.438f,
+	156.25f,
+	44.9543f,
+	148.438f,
+	160.156f,
+	44.8078f,
+	148.438f,
+	164.063f,
+	45.09f,
+	148.438f,
+	167.969f,
+	43.0871f,
+	148.438f,
+	171.875f,
+	42.2067f,
+	148.438f,
+	175.781f,
+	40.5399f,
+	148.438f,
+	179.688f,
+	35.9902f,
+	148.438f,
+	183.594f,
+	34.4093f,
+	148.438f,
+	187.5f,
+	35.1087f,
+	148.438f,
+	191.406f,
+	34.3372f,
+	148.438f,
+	195.313f,
+	35.6724f,
+	148.438f,
+	199.219f,
+	34.961f,
+	148.438f,
+	203.125f,
+	34.4106f,
+	148.438f,
+	207.031f,
+	32.0028f,
+	148.438f,
+	210.938f,
+	31.3925f,
+	148.438f,
+	214.844f,
+	29.3539f,
+	148.438f,
+	218.75f,
+	27.6213f,
+	148.438f,
+	222.656f,
+	21.6694f,
+	148.438f,
+	226.563f,
+	20.356f,
+	148.438f,
+	230.469f,
+	19.6202f,
+	148.438f,
+	234.375f,
+	17.6247f,
+	148.438f,
+	238.281f,
+	16.5152f,
+	148.438f,
+	242.188f,
+	14.901f,
+	148.438f,
+	246.094f,
+	12.7994f,
+	148.438f,
+	250.0f,
+	12.2743f,
+	148.438f,
+	3.90626f,
+	17.8758f,
+	144.531f,
+	7.81251f,
+	19.3177f,
+	144.531f,
+	11.7188f,
+	20.9214f,
+	144.531f,
+	15.625f,
+	21.8589f,
+	144.531f,
+	19.5313f,
+	21.2904f,
+	144.531f,
+	23.4375f,
+	19.9784f,
+	144.531f,
+	27.3438f,
+	19.6359f,
+	144.531f,
+	31.25f,
+	19.4398f,
+	144.531f,
+	35.1563f,
+	18.6596f,
+	144.531f,
+	39.0625f,
+	17.1967f,
+	144.531f,
+	42.9688f,
+	16.797f,
+	144.531f,
+	46.875f,
+	16.4099f,
+	144.531f,
+	50.7813f,
+	16.54f,
+	144.531f,
+	54.6875f,
+	16.811f,
+	144.531f,
+	58.5938f,
+	17.31f,
+	144.531f,
+	62.5f,
+	17.5358f,
+	144.531f,
+	66.4063f,
+	16.8495f,
+	144.531f,
+	70.3125f,
+	17.2148f,
+	144.531f,
+	74.2188f,
+	16.6285f,
+	144.531f,
+	78.125f,
+	17.7911f,
+	144.531f,
+	82.0313f,
+	18.6054f,
+	144.531f,
+	85.9375f,
+	18.787f,
+	144.531f,
+	89.8438f,
+	20.4804f,
+	144.531f,
+	93.75f,
+	21.0544f,
+	144.531f,
+	97.6563f,
+	20.9487f,
+	144.531f,
+	101.563f,
+	23.1098f,
+	144.531f,
+	105.469f,
+	25.2196f,
+	144.531f,
+	109.375f,
+	27.0389f,
+	144.531f,
+	113.281f,
+	29.4971f,
+	144.531f,
+	117.188f,
+	31.0049f,
+	144.531f,
+	121.094f,
+	33.086f,
+	144.531f,
+	125.0f,
+	34.6611f,
+	144.531f,
+	128.906f,
+	35.8626f,
+	144.531f,
+	132.813f,
+	36.8672f,
+	144.531f,
+	136.719f,
+	37.5515f,
+	144.531f,
+	140.625f,
+	37.6433f,
+	144.531f,
+	144.531f,
+	37.8923f,
+	144.531f,
+	148.438f,
+	37.1277f,
+	144.531f,
+	152.344f,
+	40.0287f,
+	144.531f,
+	156.25f,
+	44.9863f,
+	144.531f,
+	160.156f,
+	45.0845f,
+	144.531f,
+	164.063f,
+	44.7823f,
+	144.531f,
+	167.969f,
+	42.5338f,
+	144.531f,
+	171.875f,
+	41.7912f,
+	144.531f,
+	175.781f,
+	41.5762f,
+	144.531f,
+	179.688f,
+	41.3242f,
+	144.531f,
+	183.594f,
+	39.6796f,
+	144.531f,
+	187.5f,
+	39.4704f,
+	144.531f,
+	191.406f,
+	38.5401f,
+	144.531f,
+	195.313f,
+	37.3853f,
+	144.531f,
+	199.219f,
+	35.4345f,
+	144.531f,
+	203.125f,
+	34.2437f,
+	144.531f,
+	207.031f,
+	31.8218f,
+	144.531f,
+	210.938f,
+	30.6041f,
+	144.531f,
+	214.844f,
+	26.9001f,
+	144.531f,
+	218.75f,
+	22.3094f,
+	144.531f,
+	222.656f,
+	21.4446f,
+	144.531f,
+	226.563f,
+	20.6643f,
+	144.531f,
+	230.469f,
+	20.3246f,
+	144.531f,
+	234.375f,
+	18.0382f,
+	144.531f,
+	238.281f,
+	15.7854f,
+	144.531f,
+	242.188f,
+	14.3314f,
+	144.531f,
+	246.094f,
+	12.4723f,
+	144.531f,
+	250.0f,
+	12.5491f,
+	144.531f,
+	3.90626f,
+	18.5798f,
+	140.625f,
+	7.81251f,
+	19.7271f,
+	140.625f,
+	11.7188f,
+	20.8566f,
+	140.625f,
+	15.625f,
+	21.6914f,
+	140.625f,
+	19.5313f,
+	20.9288f,
+	140.625f,
+	23.4375f,
+	20.0531f,
+	140.625f,
+	27.3438f,
+	19.1655f,
+	140.625f,
+	31.25f,
+	18.7947f,
+	140.625f,
+	35.1563f,
+	18.2984f,
+	140.625f,
+	39.0625f,
+	17.3295f,
+	140.625f,
+	42.9688f,
+	16.5557f,
+	140.625f,
+	46.875f,
+	16.1679f,
+	140.625f,
+	50.7813f,
+	16.0262f,
+	140.625f,
+	54.6875f,
+	16.1659f,
+	140.625f,
+	58.5938f,
+	16.459f,
+	140.625f,
+	62.5f,
+	17.0307f,
+	140.625f,
+	66.4063f,
+	17.6303f,
+	140.625f,
+	70.3125f,
+	16.7576f,
+	140.625f,
+	74.2188f,
+	16.9614f,
+	140.625f,
+	78.125f,
+	17.3439f,
+	140.625f,
+	82.0313f,
+	17.7742f,
+	140.625f,
+	85.9375f,
+	19.0774f,
+	140.625f,
+	89.8438f,
+	20.0724f,
+	140.625f,
+	93.75f,
+	21.5734f,
+	140.625f,
+	97.6563f,
+	21.4923f,
+	140.625f,
+	101.563f,
+	24.2474f,
+	140.625f,
+	105.469f,
+	25.9666f,
+	140.625f,
+	109.375f,
+	27.8803f,
+	140.625f,
+	113.281f,
+	29.6397f,
+	140.625f,
+	117.188f,
+	32.0374f,
+	140.625f,
+	121.094f,
+	34.014f,
+	140.625f,
+	125.0f,
+	35.1589f,
+	140.625f,
+	128.906f,
+	36.2526f,
+	140.625f,
+	132.813f,
+	37.5386f,
+	140.625f,
+	136.719f,
+	38.1647f,
+	140.625f,
+	140.625f,
+	37.9014f,
+	140.625f,
+	144.531f,
+	39.0558f,
+	140.625f,
+	148.438f,
+	38.1493f,
+	140.625f,
+	152.344f,
+	39.5967f,
+	140.625f,
+	156.25f,
+	40.3409f,
+	140.625f,
+	160.156f,
+	39.4778f,
+	140.625f,
+	164.063f,
+	43.7911f,
+	140.625f,
+	167.969f,
+	42.7467f,
+	140.625f,
+	171.875f,
+	41.4394f,
+	140.625f,
+	175.781f,
+	41.222f,
+	140.625f,
+	179.688f,
+	40.9501f,
+	140.625f,
+	183.594f,
+	40.2741f,
+	140.625f,
+	187.5f,
+	40.5011f,
+	140.625f,
+	191.406f,
+	39.8634f,
+	140.625f,
+	195.313f,
+	37.8944f,
+	140.625f,
+	199.219f,
+	35.6917f,
+	140.625f,
+	203.125f,
+	33.0921f,
+	140.625f,
+	207.031f,
+	30.7497f,
+	140.625f,
+	210.938f,
+	24.355f,
+	140.625f,
+	214.844f,
+	23.6102f,
+	140.625f,
+	218.75f,
+	23.2298f,
+	140.625f,
+	222.656f,
+	21.8035f,
+	140.625f,
+	226.563f,
+	21.0813f,
+	140.625f,
+	230.469f,
+	20.4423f,
+	140.625f,
+	234.375f,
+	19.372f,
+	140.625f,
+	238.281f,
+	16.9074f,
+	140.625f,
+	242.188f,
+	15.6931f,
+	140.625f,
+	246.094f,
+	14.0046f,
+	140.625f,
+	250.0f,
+	12.7719f,
+	140.625f,
+	3.90626f,
+	19.7224f,
+	136.719f,
+	7.81251f,
+	20.3645f,
+	136.719f,
+	11.7188f,
+	20.1938f,
+	136.719f,
+	15.625f,
+	20.0122f,
+	136.719f,
+	19.5313f,
+	20.9204f,
+	136.719f,
+	23.4375f,
+	20.2208f,
+	136.719f,
+	27.3438f,
+	19.3419f,
+	136.719f,
+	31.25f,
+	18.2059f,
+	136.719f,
+	35.1563f,
+	17.6089f,
+	136.719f,
+	39.0625f,
+	17.131f,
+	136.719f,
+	42.9688f,
+	16.8349f,
+	136.719f,
+	46.875f,
+	16.3462f,
+	136.719f,
+	50.7813f,
+	15.4488f,
+	136.719f,
+	54.6875f,
+	15.7887f,
+	136.719f,
+	58.5938f,
+	16.431f,
+	136.719f,
+	62.5f,
+	16.3378f,
+	136.719f,
+	66.4063f,
+	17.4585f,
+	136.719f,
+	70.3125f,
+	17.5113f,
+	136.719f,
+	74.2188f,
+	17.6407f,
+	136.719f,
+	78.125f,
+	17.0887f,
+	136.719f,
+	82.0313f,
+	17.2555f,
+	136.719f,
+	85.9375f,
+	18.6283f,
+	136.719f,
+	89.8438f,
+	19.6874f,
+	136.719f,
+	93.75f,
+	21.0963f,
+	136.719f,
+	97.6563f,
+	21.5582f,
+	136.719f,
+	101.563f,
+	24.9129f,
+	136.719f,
+	105.469f,
+	27.5761f,
+	136.719f,
+	109.375f,
+	28.7426f,
+	136.719f,
+	113.281f,
+	31.0958f,
+	136.719f,
+	117.188f,
+	33.7564f,
+	136.719f,
+	121.094f,
+	34.6927f,
+	136.719f,
+	125.0f,
+	35.0503f,
+	136.719f,
+	128.906f,
+	36.0657f,
+	136.719f,
+	132.813f,
+	37.2001f,
+	136.719f,
+	136.719f,
+	38.5625f,
+	136.719f,
+	140.625f,
+	38.8809f,
+	136.719f,
+	144.531f,
+	39.3646f,
+	136.719f,
+	148.438f,
+	38.919f,
+	136.719f,
+	152.344f,
+	39.5251f,
+	136.719f,
+	156.25f,
+	39.5392f,
+	136.719f,
+	160.156f,
+	39.7011f,
+	136.719f,
+	164.063f,
+	38.4043f,
+	136.719f,
+	167.969f,
+	37.7232f,
+	136.719f,
+	171.875f,
+	37.8418f,
+	136.719f,
+	175.781f,
+	41.0576f,
+	136.719f,
+	179.688f,
+	40.6804f,
+	136.719f,
+	183.594f,
+	40.6431f,
+	136.719f,
+	187.5f,
+	41.2286f,
+	136.719f,
+	191.406f,
+	40.221f,
+	136.719f,
+	195.313f,
+	37.9197f,
+	136.719f,
+	199.219f,
+	30.9591f,
+	136.719f,
+	203.125f,
+	28.2027f,
+	136.719f,
+	207.031f,
+	25.2338f,
+	136.719f,
+	210.938f,
+	24.1525f,
+	136.719f,
+	214.844f,
+	23.6344f,
+	136.719f,
+	218.75f,
+	22.6246f,
+	136.719f,
+	222.656f,
+	21.3675f,
+	136.719f,
+	226.563f,
+	21.0207f,
+	136.719f,
+	230.469f,
+	20.2558f,
+	136.719f,
+	234.375f,
+	18.3661f,
+	136.719f,
+	238.281f,
+	16.7584f,
+	136.719f,
+	242.188f,
+	16.2723f,
+	136.719f,
+	246.094f,
+	14.7268f,
+	136.719f,
+	250.0f,
+	13.5973f,
+	136.719f,
+	3.90626f,
+	19.9574f,
+	132.813f,
+	7.8125f,
+	21.126f,
+	132.813f,
+	11.7188f,
+	20.9977f,
+	132.813f,
+	15.625f,
+	21.2478f,
+	132.813f,
+	19.5313f,
+	21.5981f,
+	132.813f,
+	23.4375f,
+	20.0536f,
+	132.813f,
+	27.3438f,
+	18.6025f,
+	132.813f,
+	31.25f,
+	18.166f,
+	132.813f,
+	35.1563f,
+	17.207f,
+	132.813f,
+	39.0625f,
+	17.3703f,
+	132.813f,
+	42.9688f,
+	16.3317f,
+	132.813f,
+	46.875f,
+	15.4769f,
+	132.813f,
+	50.7813f,
+	14.7771f,
+	132.813f,
+	54.6875f,
+	14.8038f,
+	132.813f,
+	58.5938f,
+	15.7291f,
+	132.813f,
+	62.5f,
+	16.2292f,
+	132.813f,
+	66.4063f,
+	17.1488f,
+	132.813f,
+	70.3125f,
+	17.5027f,
+	132.813f,
+	74.2188f,
+	16.9736f,
+	132.813f,
+	78.125f,
+	16.4014f,
+	132.813f,
+	82.0313f,
+	16.7581f,
+	132.813f,
+	85.9375f,
+	18.1894f,
+	132.813f,
+	89.8438f,
+	20.0178f,
+	132.813f,
+	93.75f,
+	20.5813f,
+	132.813f,
+	97.6563f,
+	22.5893f,
+	132.813f,
+	101.563f,
+	25.6741f,
+	132.813f,
+	105.469f,
+	28.0908f,
+	132.813f,
+	109.375f,
+	29.1124f,
+	132.813f,
+	113.281f,
+	31.4752f,
+	132.813f,
+	117.188f,
+	33.2328f,
+	132.813f,
+	121.094f,
+	34.3747f,
+	132.813f,
+	125.0f,
+	34.8849f,
+	132.813f,
+	128.906f,
+	36.3771f,
+	132.813f,
+	132.813f,
+	37.3154f,
+	132.813f,
+	136.719f,
+	38.6196f,
+	132.813f,
+	140.625f,
+	39.1474f,
+	132.813f,
+	144.531f,
+	39.5395f,
+	132.813f,
+	148.438f,
+	38.9241f,
+	132.813f,
+	152.344f,
+	39.6801f,
+	132.813f,
+	156.25f,
+	39.7675f,
+	132.813f,
+	160.156f,
+	39.4464f,
+	132.813f,
+	164.063f,
+	38.2967f,
+	132.813f,
+	167.969f,
+	37.3679f,
+	132.813f,
+	171.875f,
+	36.5147f,
+	132.813f,
+	175.781f,
+	35.9217f,
+	132.813f,
+	179.688f,
+	35.6874f,
+	132.813f,
+	183.594f,
+	36.0348f,
+	132.813f,
+	187.5f,
+	36.167f,
+	132.813f,
+	191.406f,
+	34.7462f,
+	132.813f,
+	195.313f,
+	32.5911f,
+	132.813f,
+	199.219f,
+	30.8509f,
+	132.813f,
+	203.125f,
+	27.889f,
+	132.813f,
+	207.031f,
+	25.0869f,
+	132.813f,
+	210.938f,
+	23.713f,
+	132.813f,
+	214.844f,
+	23.4714f,
+	132.813f,
+	218.75f,
+	22.2633f,
+	132.813f,
+	222.656f,
+	21.1409f,
+	132.813f,
+	226.563f,
+	20.2725f,
+	132.813f,
+	230.469f,
+	19.4678f,
+	132.813f,
+	234.375f,
+	18.4511f,
+	132.813f,
+	238.281f,
+	18.0306f,
+	132.813f,
+	242.188f,
+	17.5677f,
+	132.813f,
+	246.094f,
+	16.403f,
+	132.813f,
+	250.0f,
+	14.7316f,
+	132.813f,
+	3.90626f,
+	20.0876f,
+	128.906f,
+	7.81252f,
+	21.0764f,
+	128.906f,
+	11.7188f,
+	21.4076f,
+	128.906f,
+	15.625f,
+	22.6299f,
+	128.906f,
+	19.5313f,
+	22.1174f,
+	128.906f,
+	23.4375f,
+	20.3977f,
+	128.906f,
+	27.3438f,
+	18.7343f,
+	128.906f,
+	31.25f,
+	17.9144f,
+	128.906f,
+	35.1563f,
+	17.2941f,
+	128.906f,
+	39.0625f,
+	16.5386f,
+	128.906f,
+	42.9688f,
+	15.6892f,
+	128.906f,
+	46.875f,
+	14.6414f,
+	128.906f,
+	50.7813f,
+	14.3505f,
+	128.906f,
+	54.6875f,
+	14.1604f,
+	128.906f,
+	58.5938f,
+	14.517f,
+	128.906f,
+	62.5f,
+	15.1057f,
+	128.906f,
+	66.4063f,
+	16.0684f,
+	128.906f,
+	70.3125f,
+	16.6251f,
+	128.906f,
+	74.2188f,
+	15.9689f,
+	128.906f,
+	78.125f,
+	16.0234f,
+	128.906f,
+	82.0313f,
+	16.205f,
+	128.906f,
+	85.9375f,
+	18.8167f,
+	128.906f,
+	89.8438f,
+	19.6433f,
+	128.906f,
+	93.75f,
+	20.2916f,
+	128.906f,
+	97.6563f,
+	23.2308f,
+	128.906f,
+	101.563f,
+	25.882f,
+	128.906f,
+	105.469f,
+	27.5736f,
+	128.906f,
+	109.375f,
+	28.9662f,
+	128.906f,
+	113.281f,
+	30.5702f,
+	128.906f,
+	117.188f,
+	31.8627f,
+	128.906f,
+	121.094f,
+	32.5216f,
+	128.906f,
+	125.0f,
+	34.1918f,
+	128.906f,
+	128.906f,
+	37.0161f,
+	128.906f,
+	132.813f,
+	38.5084f,
+	128.906f,
+	136.719f,
+	39.1631f,
+	128.906f,
+	140.625f,
+	39.0529f,
+	128.906f,
+	144.531f,
+	38.9229f,
+	128.906f,
+	148.438f,
+	38.4312f,
+	128.906f,
+	152.344f,
+	39.1086f,
+	128.906f,
+	156.25f,
+	39.7022f,
+	128.906f,
+	160.156f,
+	39.3007f,
+	128.906f,
+	164.063f,
+	38.2318f,
+	128.906f,
+	167.969f,
+	36.7493f,
+	128.906f,
+	171.875f,
+	35.9781f,
+	128.906f,
+	175.781f,
+	35.7712f,
+	128.906f,
+	179.688f,
+	35.6247f,
+	128.906f,
+	183.594f,
+	35.4808f,
+	128.906f,
+	187.5f,
+	35.6102f,
+	128.906f,
+	191.406f,
+	34.0305f,
+	128.906f,
+	195.313f,
+	32.0227f,
+	128.906f,
+	199.219f,
+	29.7666f,
+	128.906f,
+	203.125f,
+	27.3968f,
+	128.906f,
+	207.031f,
+	25.1642f,
+	128.906f,
+	210.938f,
+	24.279f,
+	128.906f,
+	214.844f,
+	22.4357f,
+	128.906f,
+	218.75f,
+	21.7754f,
+	128.906f,
+	222.656f,
+	19.6381f,
+	128.906f,
+	226.563f,
+	19.78f,
+	128.906f,
+	230.469f,
+	20.0349f,
+	128.906f,
+	234.375f,
+	19.1534f,
+	128.906f,
+	238.281f,
+	17.863f,
+	128.906f,
+	242.188f,
+	17.658f,
+	128.906f,
+	246.094f,
+	16.951f,
+	128.906f,
+	250.0f,
+	16.2961f,
+	128.906f,
+};
+
+btScalar Landscape01Nml[] = {
+	-0.145347f,
+	0.988603f,
+	0.0392193f,
+	-0.118578f,
+	0.971903f,
+	-0.203332f,
+	-0.210348f,
+	0.975548f,
+	0.0637181f,
+	-0.143154f,
+	0.979915f,
+	-0.138828f,
+	-0.186466f,
+	0.976661f,
+	0.106602f,
+	-0.200996f,
+	0.973874f,
+	-0.105691f,
+	-0.200019f,
+	0.979742f,
+	-0.00987837f,
+	-0.162567f,
+	0.986516f,
+	-0.0189093f,
+	-0.128872f,
+	0.991658f,
+	-0.00262187f,
+	-0.0972065f,
+	0.993702f,
+	0.0557464f,
+	-0.232168f,
+	0.972676f,
+	8.39761e-005f,
+	-0.280715f,
+	0.959127f,
+	-0.0356947f,
+	-0.328537f,
+	0.944066f,
+	-0.0283446f,
+	-0.348021f,
+	0.936189f,
+	-0.0493126f,
+	-0.28502f,
+	0.953899f,
+	-0.0940249f,
+	-0.329197f,
+	0.938125f,
+	-0.107479f,
+	-0.186873f,
+	0.969867f,
+	-0.15632f,
+	-0.168074f,
+	0.98179f,
+	-0.088542f,
+	0.138723f,
+	0.984643f,
+	-0.105994f,
+	0.139713f,
+	0.984758f,
+	-0.103594f,
+	0.415149f,
+	0.907443f,
+	-0.0647914f,
+	0.335594f,
+	0.916204f,
+	-0.218967f,
+	0.391251f,
+	0.906316f,
+	-0.159731f,
+	0.297117f,
+	0.890775f,
+	-0.343864f,
+	0.0782406f,
+	0.948307f,
+	-0.307558f,
+	0.0742546f,
+	0.932023f,
+	-0.354711f,
+	-0.0593029f,
+	0.94484f,
+	-0.322118f,
+	-0.035102f,
+	0.9388f,
+	-0.342668f,
+	-0.0398386f,
+	0.972105f,
+	-0.231139f,
+	0.0142535f,
+	0.946652f,
+	-0.321942f,
+	-0.149407f,
+	0.982239f,
+	-0.113505f,
+	-0.186817f,
+	0.918353f,
+	-0.348895f,
+	-0.227035f,
+	0.95418f,
+	-0.194923f,
+	-0.217455f,
+	0.921613f,
+	-0.32147f,
+	-0.104683f,
+	0.961425f,
+	-0.254368f,
+	-0.137473f,
+	0.92562f,
+	-0.352602f,
+	-0.0889131f,
+	0.942391f,
+	-0.322479f,
+	-0.137942f,
+	0.895959f,
+	-0.422173f,
+	-0.0994313f,
+	0.915873f,
+	-0.38896f,
+	-0.177412f,
+	0.858967f,
+	-0.480312f,
+	-0.28046f,
+	0.843765f,
+	-0.457605f,
+	-0.23875f,
+	0.832625f,
+	-0.499733f,
+	-0.35769f,
+	0.865922f,
+	-0.349624f,
+	-0.239679f,
+	0.924761f,
+	-0.295585f,
+	-0.367472f,
+	0.894137f,
+	-0.255898f,
+	-0.306721f,
+	0.940051f,
+	-0.149083f,
+	-0.29191f,
+	0.929123f,
+	-0.226977f,
+	-0.3205f,
+	0.928892f,
+	-0.185579f,
+	-0.367832f,
+	0.894452f,
+	-0.254274f,
+	-0.393375f,
+	0.898238f,
+	-0.196023f,
+	-0.386104f,
+	0.869165f,
+	-0.308993f,
+	-0.416765f,
+	0.860247f,
+	-0.293737f,
+	-0.257238f,
+	0.898443f,
+	-0.355849f,
+	-0.273377f,
+	0.911812f,
+	-0.306372f,
+	-0.228654f,
+	0.889208f,
+	-0.396265f,
+	-0.28545f,
+	0.876522f,
+	-0.387592f,
+	-0.142316f,
+	0.885962f,
+	-0.441381f,
+	-0.101084f,
+	0.908701f,
+	-0.405025f,
+	0.035618f,
+	0.945519f,
+	-0.323614f,
+	0.103277f,
+	0.941647f,
+	-0.320368f,
+	-0.120589f,
+	0.957422f,
+	-0.262302f,
+	-0.186114f,
+	0.894712f,
+	-0.40602f,
+	-0.202962f,
+	0.931974f,
+	-0.300385f,
+	-0.162074f,
+	0.943023f,
+	-0.290584f,
+	-0.152017f,
+	0.933176f,
+	-0.325688f,
+	-0.202811f,
+	0.891764f,
+	-0.404505f,
+	-0.195614f,
+	0.919053f,
+	-0.342165f,
+	-0.221332f,
+	0.883262f,
+	-0.413352f,
+	-0.230949f,
+	0.883479f,
+	-0.407587f,
+	-0.202664f,
+	0.884798f,
+	-0.419595f,
+	-0.013827f,
+	0.935183f,
+	-0.353894f,
+	0.0613953f,
+	0.949306f,
+	-0.308299f,
+	0.0379666f,
+	0.956996f,
+	-0.287605f,
+	0.0239474f,
+	0.920688f,
+	-0.389564f,
+	-0.124568f,
+	0.971246f,
+	-0.20289f,
+	-0.0173673f,
+	0.966674f,
+	-0.255421f,
+	-0.280608f,
+	0.954174f,
+	-0.103981f,
+	-0.188825f,
+	0.978003f,
+	-0.0886339f,
+	-0.193278f,
+	0.981044f,
+	-0.0139968f,
+	-0.089832f,
+	0.992161f,
+	0.0868734f,
+	-0.0617809f,
+	0.994525f,
+	0.0842802f,
+	0.0316335f,
+	0.979002f,
+	0.20138f,
+	0.126601f,
+	0.973442f,
+	0.190743f,
+	0.126356f,
+	0.954056f,
+	0.271683f,
+	0.0296197f,
+	0.996225f,
+	0.0816031f,
+	-0.130879f,
+	0.990212f,
+	-0.0484936f,
+	-0.0775613f,
+	0.996382f,
+	0.0347567f,
+	-0.0318445f,
+	0.999049f,
+	0.0297665f,
+	0.174213f,
+	0.981835f,
+	0.0751658f,
+	0.230898f,
+	0.968544f,
+	0.0927823f,
+	0.477724f,
+	0.867555f,
+	0.138304f,
+	0.489512f,
+	0.856269f,
+	0.164868f,
+	0.425011f,
+	0.903484f,
+	0.0555235f,
+	0.345126f,
+	0.937885f,
+	0.0355011f,
+	0.051136f,
+	0.997417f,
+	-0.0504465f,
+	0.0111243f,
+	0.99878f,
+	-0.0481145f,
+	0.00085351f,
+	0.998643f,
+	-0.0520782f,
+	-0.0736129f,
+	0.992491f,
+	-0.0976874f,
+	0.0605446f,
+	0.978416f,
+	-0.197578f,
+	-0.1248f,
+	0.898669f,
+	-0.420499f,
+	-0.068151f,
+	0.956411f,
+	-0.28396f,
+	0.0502596f,
+	0.934397f,
+	-0.35267f,
+	0.0492358f,
+	0.99416f,
+	-0.096025f,
+	0.22311f,
+	0.97441f,
+	-0.0273246f,
+	0.104257f,
+	0.993921f,
+	-0.0353788f,
+	0.135731f,
+	0.987345f,
+	0.0820234f,
+	0.0508084f,
+	0.996415f,
+	-0.0676404f,
+	0.013783f,
+	0.999772f,
+	-0.0162859f,
+	0.0814861f,
+	0.996154f,
+	-0.0322044f,
+	0.0451487f,
+	0.998313f,
+	-0.0365194f,
+	0.035547f,
+	0.992801f,
+	-0.114375f,
+	-0.0977551f,
+	0.955799f,
+	-0.277294f,
+	0.0588118f,
+	0.977967f,
+	-0.200303f,
+	0.0956551f,
+	0.968682f,
+	-0.229142f,
+	0.255494f,
+	0.951171f,
+	-0.173197f,
+	0.287347f,
+	0.949686f,
+	-0.124613f,
+	0.300983f,
+	0.934694f,
+	-0.189092f,
+	0.326044f,
+	0.937015f,
+	-0.125296f,
+	0.170234f,
+	0.979103f,
+	-0.111255f,
+	0.217643f,
+	0.971688f,
+	-0.0919459f,
+	0.0857423f,
+	0.995f,
+	-0.0512173f,
+	0.141055f,
+	0.988855f,
+	0.0476293f,
+	0.141065f,
+	0.98942f,
+	-0.0338874f,
+	0.161562f,
+	0.986303f,
+	0.0332183f,
+	0.113059f,
+	0.993231f,
+	0.0266602f,
+	0.073071f,
+	0.997081f,
+	-0.0221543f,
+	-0.0590251f,
+	0.997651f,
+	-0.034775f,
+	-0.0264959f,
+	0.999595f,
+	0.0103962f,
+	-0.0628475f,
+	0.932757f,
+	0.354985f,
+	-0.188464f,
+	0.930547f,
+	0.31395f,
+	-0.11595f,
+	0.95582f,
+	0.270118f,
+	-0.0150745f,
+	0.981122f,
+	0.192801f,
+	-0.121292f,
+	0.98854f,
+	0.0898753f,
+	-0.191875f,
+	0.979293f,
+	0.0645635f,
+	-0.302211f,
+	0.947932f,
+	-0.100469f,
+	-0.168835f,
+	0.972187f,
+	-0.162321f,
+	-0.165107f,
+	0.942083f,
+	-0.291925f,
+	0.0524842f,
+	0.966783f,
+	-0.250151f,
+	0.334898f,
+	0.925425f,
+	-0.177288f,
+	0.453352f,
+	0.888614f,
+	-0.0695481f,
+	0.212879f,
+	0.976177f,
+	-0.0419751f,
+	-0.0859137f,
+	0.991174f,
+	-0.100958f,
+	-0.19247f,
+	0.980365f,
+	-0.0428897f,
+	-0.217979f,
+	0.975456f,
+	0.0311624f,
+	-0.130678f,
+	0.991292f,
+	-0.0162531f,
+	0.0105625f,
+	0.994964f,
+	-0.0996785f,
+	-0.0191557f,
+	0.967247f,
+	-0.253114f,
+	-0.034833f,
+	0.962122f,
+	-0.270385f,
+	-0.195874f,
+	0.937997f,
+	-0.285996f,
+	-0.397161f,
+	0.831379f,
+	-0.388681f,
+	-0.379064f,
+	0.825916f,
+	-0.417342f,
+	-0.284483f,
+	0.874083f,
+	-0.393762f,
+	-0.320157f,
+	0.86551f,
+	-0.385217f,
+	-0.327447f,
+	0.85814f,
+	-0.395442f,
+	-0.219114f,
+	0.871062f,
+	-0.439592f,
+	-0.161876f,
+	0.861769f,
+	-0.480781f,
+	-0.18946f,
+	0.845726f,
+	-0.498852f,
+	-0.191307f,
+	0.924603f,
+	-0.32941f,
+	-0.159365f,
+	0.982225f,
+	-0.0991764f,
+	-0.164558f,
+	0.975832f,
+	-0.143777f,
+	-0.155521f,
+	0.974006f,
+	-0.164699f,
+	-0.172244f,
+	0.972979f,
+	-0.153766f,
+	-0.162541f,
+	0.961346f,
+	-0.222247f,
+	-0.11171f,
+	0.955927f,
+	-0.271523f,
+	-0.101714f,
+	0.980079f,
+	-0.170586f,
+	-0.223397f,
+	0.974336f,
+	-0.0276274f,
+	-0.300622f,
+	0.953413f,
+	0.0251167f,
+	-0.254202f,
+	0.967133f,
+	-0.00586307f,
+	-0.0994566f,
+	0.994394f,
+	0.0359007f,
+	0.078652f,
+	0.996758f,
+	-0.0169243f,
+	-0.0552979f,
+	0.987555f,
+	0.147234f,
+	-0.0666628f,
+	0.864508f,
+	0.498179f,
+	0.131082f,
+	0.854494f,
+	0.502651f,
+	0.414695f,
+	0.764646f,
+	0.4933f,
+	0.432926f,
+	0.790826f,
+	0.432632f,
+	0.126593f,
+	0.91514f,
+	0.382744f,
+	-0.0157552f,
+	0.943082f,
+	0.332186f,
+	0.122694f,
+	0.924647f,
+	0.36052f,
+	0.0975822f,
+	0.984244f,
+	0.147447f,
+	-0.026294f,
+	0.960938f,
+	-0.275512f,
+	0.1231f,
+	0.958251f,
+	-0.258072f,
+	0.037902f,
+	0.976085f,
+	-0.214059f,
+	-0.000148888f,
+	0.992562f,
+	-0.121742f,
+	0.0716429f,
+	0.997173f,
+	-0.0226693f,
+	0.135484f,
+	0.989193f,
+	-0.0560393f,
+	0.275603f,
+	0.956281f,
+	-0.0978236f,
+	0.283097f,
+	0.956822f,
+	-0.0659346f,
+	0.109624f,
+	0.991403f,
+	-0.0714361f,
+	0.084436f,
+	0.990816f,
+	-0.105609f,
+	0.0791881f,
+	0.990931f,
+	-0.108558f,
+	0.0674956f,
+	0.997569f,
+	-0.0173508f,
+	0.0556006f,
+	0.998429f,
+	0.00688119f,
+	-0.144974f,
+	0.947519f,
+	0.28494f,
+	-0.110826f,
+	0.961365f,
+	0.251981f,
+	-0.0669451f,
+	0.996693f,
+	0.0460586f,
+	-0.00516145f,
+	0.998802f,
+	0.0486696f,
+	-0.116537f,
+	0.988089f,
+	0.100498f,
+	-0.0456605f,
+	0.993379f,
+	0.105422f,
+	-0.110131f,
+	0.987256f,
+	-0.114879f,
+	-0.0746162f,
+	0.968429f,
+	-0.237861f,
+	-0.0785155f,
+	0.952358f,
+	-0.294703f,
+	-0.0192369f,
+	0.946876f,
+	-0.321024f,
+	0.320056f,
+	0.920022f,
+	-0.226108f,
+	0.288692f,
+	0.932613f,
+	-0.216541f,
+	0.123147f,
+	0.991593f,
+	-0.0397145f,
+	-0.113817f,
+	0.992375f,
+	0.0473138f,
+	-0.192042f,
+	0.9774f,
+	0.0883642f,
+	-0.156949f,
+	0.987573f,
+	0.00819321f,
+	-0.0848586f,
+	0.992344f,
+	-0.0897344f,
+	0.0818673f,
+	0.992357f,
+	-0.0923282f,
+	0.113464f,
+	0.986976f,
+	-0.114035f,
+	-0.0777263f,
+	0.979155f,
+	-0.187653f,
+	-0.11587f,
+	0.975173f,
+	-0.188711f,
+	-0.26618f,
+	0.902421f,
+	-0.338799f,
+	-0.343104f,
+	0.842974f,
+	-0.414336f,
+	-0.318919f,
+	0.837107f,
+	-0.444457f,
+	-0.324821f,
+	0.839352f,
+	-0.435867f,
+	-0.312979f,
+	0.836318f,
+	-0.45013f,
+	-0.203015f,
+	0.862499f,
+	-0.463553f,
+	-0.14187f,
+	0.900483f,
+	-0.411101f,
+	-0.22968f,
+	0.933243f,
+	-0.276233f,
+	-0.413973f,
+	0.871187f,
+	-0.263932f,
+	-0.305656f,
+	0.93798f,
+	-0.163607f,
+	-0.161875f,
+	0.985861f,
+	-0.0433003f,
+	-0.135788f,
+	0.990721f,
+	0.00582442f,
+	-0.138617f,
+	0.984876f,
+	-0.103942f,
+	-0.135024f,
+	0.980056f,
+	-0.145806f,
+	-0.124871f,
+	0.989793f,
+	-0.068687f,
+	-0.182018f,
+	0.982992f,
+	-0.024403f,
+	-0.309743f,
+	0.950592f,
+	-0.0208625f,
+	-0.30492f,
+	0.95221f,
+	0.0178823f,
+	-0.299424f,
+	0.951826f,
+	0.066125f,
+	-0.120448f,
+	0.944431f,
+	0.305848f,
+	0.118213f,
+	0.907792f,
+	0.402418f,
+	-0.261318f,
+	0.917154f,
+	0.300902f,
+	-0.411401f,
+	0.860866f,
+	0.299431f,
+	0.15139f,
+	0.91772f,
+	0.367249f,
+	0.409879f,
+	0.832051f,
+	0.373752f,
+	0.446772f,
+	0.77668f,
+	0.44403f,
+	0.301572f,
+	0.80653f,
+	0.508491f,
+	0.168293f,
+	0.89172f,
+	0.420135f,
+	0.0587854f,
+	0.961406f,
+	0.26878f,
+	0.30067f,
+	0.896979f,
+	0.324077f,
+	0.282217f,
+	0.935284f,
+	0.213535f,
+	0.148185f,
+	0.986837f,
+	0.0647602f,
+	-0.0572401f,
+	0.974528f,
+	-0.216838f,
+	-0.0945497f,
+	0.96665f,
+	-0.238009f,
+	-0.000668496f,
+	0.9725f,
+	-0.232902f,
+	0.125989f,
+	0.980136f,
+	-0.15317f,
+	0.218059f,
+	0.975888f,
+	-0.00959987f,
+	0.265461f,
+	0.958501f,
+	0.103951f,
+	0.173443f,
+	0.98019f,
+	0.0956349f,
+	0.133691f,
+	0.987754f,
+	0.0804258f,
+	0.0900836f,
+	0.995272f,
+	0.0363034f,
+	0.0177237f,
+	0.999106f,
+	-0.0383914f,
+	0.042211f,
+	0.998744f,
+	-0.0269875f,
+	0.0720539f,
+	0.94434f,
+	0.320982f,
+	0.0948772f,
+	0.964987f,
+	0.244537f,
+	0.123635f,
+	0.987961f,
+	0.0929884f,
+	-0.0283728f,
+	0.998997f,
+	-0.0346279f,
+	-0.152337f,
+	0.985597f,
+	-0.0734363f,
+	-0.0291778f,
+	0.996634f,
+	-0.0766092f,
+	0.0594392f,
+	0.995285f,
+	-0.0766423f,
+	-0.027888f,
+	0.982723f,
+	-0.182971f,
+	-0.0125244f,
+	0.971758f,
+	-0.235647f,
+	-0.0767296f,
+	0.943557f,
+	-0.322201f,
+	0.2299f,
+	0.955601f,
+	-0.184318f,
+	0.271645f,
+	0.9586f,
+	-0.0854157f,
+	0.0112173f,
+	0.999015f,
+	-0.0429278f,
+	-0.142475f,
+	0.989464f,
+	-0.02574f,
+	-0.192441f,
+	0.979224f,
+	-0.0639254f,
+	-0.103523f,
+	0.99301f,
+	-0.0567016f,
+	-0.00378459f,
+	0.998834f,
+	-0.0481324f,
+	0.0499927f,
+	0.992415f,
+	-0.112309f,
+	0.0737699f,
+	0.994576f,
+	-0.0733206f,
+	-0.0190206f,
+	0.999623f,
+	-0.0197948f,
+	-0.0783652f,
+	0.99692f,
+	0.00307073f,
+	-0.152226f,
+	0.987897f,
+	0.0297819f,
+	-0.333638f,
+	0.940154f,
+	-0.069252f,
+	-0.307736f,
+	0.941909f,
+	-0.134557f,
+	-0.334924f,
+	0.918699f,
+	-0.209327f,
+	-0.35357f,
+	0.914459f,
+	-0.19686f,
+	-0.243406f,
+	0.963329f,
+	-0.112917f,
+	-0.31479f,
+	0.943784f,
+	-0.100892f,
+	-0.368184f,
+	0.929745f,
+	0.00391099f,
+	-0.386308f,
+	0.922293f,
+	-0.0119138f,
+	-0.337617f,
+	0.936762f,
+	-0.0921568f,
+	-0.305867f,
+	0.947033f,
+	-0.0978487f,
+	-0.109063f,
+	0.994026f,
+	0.00418869f,
+	0.00976093f,
+	0.996792f,
+	-0.0794369f,
+	-0.152053f,
+	0.972765f,
+	-0.17495f,
+	-0.268682f,
+	0.956747f,
+	-0.111559f,
+	-0.16583f,
+	0.986099f,
+	0.0104333f,
+	-0.26795f,
+	0.960138f,
+	-0.0796053f,
+	-0.428361f,
+	0.903607f,
+	0.000904858f,
+	-0.364896f,
+	0.884093f,
+	0.291943f,
+	-0.411739f,
+	0.889329f,
+	0.19891f,
+	-0.213918f,
+	0.942658f,
+	0.256194f,
+	-0.0353818f,
+	0.912316f,
+	0.407955f,
+	-0.234679f,
+	0.972031f,
+	0.0090071f,
+	0.164799f,
+	0.976041f,
+	-0.142074f,
+	0.378329f,
+	0.920537f,
+	-0.0973577f,
+	0.389048f,
+	0.913009f,
+	0.122701f,
+	0.312785f,
+	0.918579f,
+	0.241617f,
+	0.331426f,
+	0.913352f,
+	0.236529f,
+	0.235473f,
+	0.970893f,
+	0.043811f,
+	0.0409183f,
+	0.988429f,
+	-0.14606f,
+	0.183882f,
+	0.951979f,
+	0.244794f,
+	0.256685f,
+	0.844334f,
+	0.470333f,
+	0.243297f,
+	0.84406f,
+	0.47788f,
+	0.178194f,
+	0.957255f,
+	0.227835f,
+	0.0574376f,
+	0.965885f,
+	-0.252523f,
+	-0.0590426f,
+	0.961892f,
+	-0.266977f,
+	0.0063288f,
+	0.996614f,
+	-0.081983f,
+	0.221194f,
+	0.97242f,
+	0.0739783f,
+	0.131016f,
+	0.988415f,
+	0.0766141f,
+	0.0953963f,
+	0.986256f,
+	0.134901f,
+	0.160579f,
+	0.972927f,
+	0.166216f,
+	0.109946f,
+	0.983906f,
+	0.14086f,
+	0.027673f,
+	0.996741f,
+	0.0757784f,
+	0.095102f,
+	0.971229f,
+	0.218334f,
+	0.102357f,
+	0.973251f,
+	0.205684f,
+	0.193741f,
+	0.956416f,
+	0.218477f,
+	0.132416f,
+	0.984788f,
+	0.112512f,
+	-0.0766537f,
+	0.99488f,
+	-0.0658589f,
+	-0.0304197f,
+	0.995587f,
+	-0.0887742f,
+	0.0261631f,
+	0.997431f,
+	-0.0666789f,
+	0.0720508f,
+	0.996334f,
+	-0.0461268f,
+	0.110802f,
+	0.979106f,
+	-0.170512f,
+	-0.036534f,
+	0.946972f,
+	-0.319234f,
+	0.0562543f,
+	0.953438f,
+	-0.296297f,
+	0.21433f,
+	0.964539f,
+	-0.154036f,
+	-0.0463138f,
+	0.986383f,
+	-0.157808f,
+	-0.114222f,
+	0.99275f,
+	-0.0374399f,
+	-0.129535f,
+	0.99146f,
+	-0.0150624f,
+	-0.148036f,
+	0.985214f,
+	-0.0862475f,
+	-0.0412316f,
+	0.997863f,
+	-0.050697f,
+	0.0938182f,
+	0.995513f,
+	-0.0123356f,
+	0.0585542f,
+	0.997889f,
+	-0.0281043f,
+	-0.11195f,
+	0.993633f,
+	0.0126653f,
+	-0.208443f,
+	0.969116f,
+	0.131782f,
+	-0.178284f,
+	0.959747f,
+	0.217024f,
+	-0.249524f,
+	0.951637f,
+	0.179236f,
+	-0.204568f,
+	0.966799f,
+	0.153139f,
+	-0.277831f,
+	0.959694f,
+	0.042405f,
+	-0.421523f,
+	0.906804f,
+	-0.00501147f,
+	-0.349246f,
+	0.93481f,
+	0.0644755f,
+	-0.271825f,
+	0.953501f,
+	0.130185f,
+	-0.341243f,
+	0.939899f,
+	0.0119564f,
+	-0.356048f,
+	0.93224f,
+	-0.0644791f,
+	-0.286188f,
+	0.955628f,
+	-0.0697892f,
+	-0.248084f,
+	0.956522f,
+	-0.153364f,
+	-0.154022f,
+	0.960443f,
+	-0.232007f,
+	0.032406f,
+	0.989794f,
+	-0.138774f,
+	-0.0622078f,
+	0.991529f,
+	-0.114016f,
+	-0.335467f,
+	0.915845f,
+	-0.220659f,
+	-0.194821f,
+	0.973732f,
+	-0.117857f,
+	-0.29903f,
+	0.953799f,
+	-0.0291431f,
+	-0.514277f,
+	0.834668f,
+	0.197101f,
+	-0.344769f,
+	0.927072f,
+	0.147212f,
+	-0.0936834f,
+	0.993837f,
+	0.0592615f,
+	-0.181141f,
+	0.974379f,
+	-0.133321f,
+	-0.0841805f,
+	0.983933f,
+	-0.157447f,
+	0.0661375f,
+	0.94785f,
+	-0.31178f,
+	0.143104f,
+	0.856028f,
+	-0.496726f,
+	0.226417f,
+	0.827547f,
+	-0.513714f,
+	0.178899f,
+	0.912784f,
+	-0.367179f,
+	0.234616f,
+	0.943911f,
+	-0.232351f,
+	0.346693f,
+	0.91935f,
+	-0.186008f,
+	0.307074f,
+	0.943627f,
+	-0.123586f,
+	0.214863f,
+	0.970065f,
+	0.113171f,
+	0.0234555f,
+	0.999712f,
+	0.00506759f,
+	-0.0206358f,
+	0.99868f,
+	0.047041f,
+	0.0320247f,
+	0.946177f,
+	0.322062f,
+	0.23638f,
+	0.837444f,
+	0.492759f,
+	0.410368f,
+	0.848265f,
+	0.33473f,
+	-0.0124285f,
+	0.999913f,
+	-0.00451951f,
+	-0.13197f,
+	0.981357f,
+	-0.139724f,
+	0.0888915f,
+	0.995883f,
+	0.0177605f,
+	0.12955f,
+	0.973581f,
+	0.188033f,
+	0.100974f,
+	0.97841f,
+	0.18033f,
+	0.116628f,
+	0.987352f,
+	0.107396f,
+	0.0879041f,
+	0.989191f,
+	0.117361f,
+	0.114472f,
+	0.980893f,
+	0.157306f,
+	0.0306685f,
+	0.986407f,
+	0.161431f,
+	0.128704f,
+	0.972047f,
+	0.196366f,
+	0.21783f,
+	0.966546f,
+	0.135421f,
+	0.280184f,
+	0.953049f,
+	0.114866f,
+	0.0272615f,
+	0.999564f,
+	-0.0113551f,
+	-0.0491486f,
+	0.997279f,
+	-0.0549472f,
+	0.00337261f,
+	0.998977f,
+	-0.0450999f,
+	0.0913253f,
+	0.995457f,
+	-0.0269266f,
+	0.252481f,
+	0.964775f,
+	-0.0739122f,
+	0.0897947f,
+	0.975122f,
+	-0.202665f,
+	-0.0238258f,
+	0.968534f,
+	-0.247739f,
+	0.162662f,
+	0.981573f,
+	-0.10028f,
+	-0.0276113f,
+	0.997652f,
+	-0.0626774f,
+	-0.289082f,
+	0.95335f,
+	-0.0869268f,
+	-0.160594f,
+	0.986876f,
+	0.0169191f,
+	-0.0752137f,
+	0.997117f,
+	0.00999502f,
+	-0.0455931f,
+	0.997939f,
+	-0.0451647f,
+	0.0616976f,
+	0.995202f,
+	-0.0759372f,
+	-0.00353073f,
+	0.999867f,
+	-0.0159004f,
+	-0.177748f,
+	0.976224f,
+	0.124065f,
+	-0.247702f,
+	0.959217f,
+	0.136188f,
+	-0.164797f,
+	0.981869f,
+	0.0936766f,
+	-0.214718f,
+	0.976098f,
+	0.0335935f,
+	-0.211552f,
+	0.977318f,
+	-0.00980662f,
+	-0.200169f,
+	0.979677f,
+	0.0128577f,
+	-0.39928f,
+	0.916411f,
+	-0.027687f,
+	-0.374531f,
+	0.927212f,
+	0.0022105f,
+	-0.268102f,
+	0.963363f,
+	0.00736207f,
+	-0.247283f,
+	0.968232f,
+	-0.0371081f,
+	-0.289483f,
+	0.949449f,
+	-0.121432f,
+	-0.253482f,
+	0.93971f,
+	-0.229547f,
+	-0.132892f,
+	0.950758f,
+	-0.279997f,
+	-0.140676f,
+	0.931036f,
+	-0.336723f,
+	-0.161496f,
+	0.9509f,
+	-0.264023f,
+	-0.0403886f,
+	0.9973f,
+	-0.0613364f,
+	-0.215095f,
+	0.96767f,
+	-0.131717f,
+	-0.434628f,
+	0.895597f,
+	-0.0948964f,
+	-0.381939f,
+	0.886142f,
+	0.262442f,
+	-0.43994f,
+	0.880276f,
+	0.177672f,
+	-0.252792f,
+	0.948954f,
+	-0.188633f,
+	-0.0941535f,
+	0.957693f,
+	-0.271953f,
+	-0.13352f,
+	0.964535f,
+	-0.227692f,
+	0.0341173f,
+	0.927935f,
+	-0.371176f,
+	0.348577f,
+	0.799586f,
+	-0.489036f,
+	0.387188f,
+	0.819484f,
+	-0.42253f,
+	0.14352f,
+	0.883544f,
+	-0.445815f,
+	0.0762879f,
+	0.891752f,
+	-0.446047f,
+	0.0742711f,
+	0.875908f,
+	-0.476728f,
+	0.300515f,
+	0.871535f,
+	-0.38745f,
+	0.0625809f,
+	0.886656f,
+	-0.458175f,
+	-0.0365474f,
+	0.9191f,
+	-0.392325f,
+	-0.0762363f,
+	0.966891f,
+	-0.243538f,
+	0.0117284f,
+	0.995382f,
+	0.0952715f,
+	0.0102532f,
+	0.999347f,
+	-0.0346391f,
+	-0.059511f,
+	0.989492f,
+	-0.131776f,
+	0.349383f,
+	0.904972f,
+	0.24281f,
+	0.425179f,
+	0.763732f,
+	0.485732f,
+	-0.0166138f,
+	0.992406f,
+	0.121875f,
+	-0.122272f,
+	0.990094f,
+	0.0690156f,
+	-0.015652f,
+	0.970579f,
+	0.240273f,
+	0.124649f,
+	0.94771f,
+	0.293785f,
+	0.220282f,
+	0.938434f,
+	0.266116f,
+	0.102745f,
+	0.973801f,
+	0.202865f,
+	0.0640356f,
+	0.977435f,
+	0.201297f,
+	-0.0952943f,
+	0.987515f,
+	0.125435f,
+	0.114947f,
+	0.977151f,
+	0.178783f,
+	0.258472f,
+	0.957495f,
+	0.128042f,
+	0.282157f,
+	0.951094f,
+	0.125728f,
+	0.142066f,
+	0.986542f,
+	0.0809464f,
+	-0.0434313f,
+	0.998053f,
+	-0.0447576f,
+	0.0347776f,
+	0.999239f,
+	-0.0176595f,
+	0.102204f,
+	0.984881f,
+	-0.139871f,
+	0.245582f,
+	0.958619f,
+	-0.144014f,
+	0.135608f,
+	0.990697f,
+	0.0113886f,
+	-0.0626335f,
+	0.997441f,
+	0.0344788f,
+	-0.0132478f,
+	0.995736f,
+	0.0912912f,
+	-0.039638f,
+	0.981575f,
+	0.186922f,
+	-0.205229f,
+	0.973473f,
+	0.10115f,
+	-0.153245f,
+	0.987696f,
+	-0.0311751f,
+	-0.0852914f,
+	0.993336f,
+	-0.0775215f,
+	0.0304281f,
+	0.997751f,
+	-0.0597208f,
+	0.0412582f,
+	0.993049f,
+	-0.110237f,
+	-0.115798f,
+	0.992196f,
+	0.0462328f,
+	-0.265664f,
+	0.954942f,
+	0.132323f,
+	-0.179634f,
+	0.978355f,
+	0.102729f,
+	-0.122093f,
+	0.992469f,
+	0.00988423f,
+	-0.0976525f,
+	0.994936f,
+	-0.0237989f,
+	-0.19391f,
+	0.963376f,
+	-0.185219f,
+	-0.249328f,
+	0.960076f,
+	-0.126845f,
+	-0.386054f,
+	0.920896f,
+	-0.0539736f,
+	-0.40236f,
+	0.909842f,
+	-0.101455f,
+	-0.264839f,
+	0.959901f,
+	-0.091928f,
+	-0.215529f,
+	0.973573f,
+	-0.0755211f,
+	-0.190591f,
+	0.977631f,
+	-0.0889496f,
+	-0.114636f,
+	0.971653f,
+	-0.20676f,
+	-0.147698f,
+	0.942871f,
+	-0.29863f,
+	-0.153003f,
+	0.970479f,
+	-0.186443f,
+	-0.259911f,
+	0.94737f,
+	-0.186912f,
+	-0.218176f,
+	0.967871f,
+	-0.124997f,
+	-0.218418f,
+	0.965394f,
+	0.142507f,
+	-0.497944f,
+	0.825767f,
+	0.264878f,
+	-0.394522f,
+	0.874216f,
+	0.283017f,
+	-0.174161f,
+	0.980284f,
+	0.0933364f,
+	-0.0291225f,
+	0.984908f,
+	-0.170609f,
+	-0.149188f,
+	0.939649f,
+	-0.307902f,
+	-0.109448f,
+	0.970586f,
+	-0.214438f,
+	0.391051f,
+	0.895182f,
+	-0.213842f,
+	0.237246f,
+	0.888641f,
+	-0.392468f,
+	0.104812f,
+	0.984981f,
+	-0.137213f,
+	0.1294f,
+	0.991592f,
+	-0.000205693f,
+	0.119158f,
+	0.992497f,
+	-0.0274125f,
+	0.117487f,
+	0.990494f,
+	-0.071548f,
+	0.234708f,
+	0.962187f,
+	-0.138234f,
+	0.347721f,
+	0.937443f,
+	-0.017023f,
+	0.135989f,
+	0.962379f,
+	-0.235229f,
+	-0.193384f,
+	0.875532f,
+	-0.442772f,
+	-0.209357f,
+	0.905544f,
+	-0.368998f,
+	0.0641865f,
+	0.982942f,
+	-0.172352f,
+	0.0534516f,
+	0.998302f,
+	-0.023133f,
+	-0.0579793f,
+	0.992675f,
+	-0.105989f,
+	0.299444f,
+	0.827258f,
+	0.475371f,
+	0.320901f,
+	0.752799f,
+	0.574731f,
+	-0.0625162f,
+	0.964286f,
+	0.257381f,
+	-0.0931157f,
+	0.981324f,
+	0.168322f,
+	0.0981691f,
+	0.975509f,
+	0.19684f,
+	0.238911f,
+	0.944952f,
+	0.223577f,
+	0.0852945f,
+	0.980047f,
+	0.179533f,
+	0.0437708f,
+	0.96942f,
+	0.241474f,
+	-0.0654565f,
+	0.948925f,
+	0.308637f,
+	0.105877f,
+	0.941798f,
+	0.319071f,
+	0.298409f,
+	0.90697f,
+	0.29725f,
+	0.267454f,
+	0.931587f,
+	0.246198f,
+	0.257873f,
+	0.930012f,
+	0.261877f,
+	0.0608152f,
+	0.99476f,
+	0.0821851f,
+	0.0682325f,
+	0.995644f,
+	-0.0635329f,
+	0.204976f,
+	0.974836f,
+	-0.0876375f,
+	0.100643f,
+	0.994422f,
+	0.031559f,
+	-0.0498971f,
+	0.971595f,
+	0.231328f,
+	-0.0948982f,
+	0.951903f,
+	0.291332f,
+	-0.0140779f,
+	0.962693f,
+	0.270229f,
+	0.0194699f,
+	0.983768f,
+	0.178386f,
+	-0.0700516f,
+	0.997536f,
+	0.00373294f,
+	-0.0458738f,
+	0.991776f,
+	-0.119485f,
+	-0.0457685f,
+	0.983541f,
+	-0.17479f,
+	0.031836f,
+	0.984739f,
+	-0.171101f,
+	-0.0846163f,
+	0.991107f,
+	-0.102703f,
+	-0.250146f,
+	0.959975f,
+	0.125993f,
+	-0.240823f,
+	0.966766f,
+	0.0858408f,
+	-0.110771f,
+	0.993685f,
+	0.0178603f,
+	-0.0536647f,
+	0.99805f,
+	-0.0318645f,
+	-0.0537905f,
+	0.996775f,
+	-0.0595505f,
+	-0.0979926f,
+	0.994498f,
+	-0.0370296f,
+	-0.317761f,
+	0.946482f,
+	-0.0565711f,
+	-0.353331f,
+	0.932392f,
+	-0.0761719f,
+	-0.315921f,
+	0.918114f,
+	-0.23929f,
+	-0.304095f,
+	0.907663f,
+	-0.289264f,
+	-0.232301f,
+	0.951296f,
+	-0.202665f,
+	-0.181242f,
+	0.959764f,
+	-0.214488f,
+	-0.0415921f,
+	0.982269f,
+	-0.182804f,
+	-0.134113f,
+	0.976644f,
+	-0.16787f,
+	-0.266673f,
+	0.950383f,
+	-0.160182f,
+	-0.233335f,
+	0.968889f,
+	-0.0825141f,
+	-0.383896f,
+	0.923094f,
+	0.0228394f,
+	-0.46523f,
+	0.826401f,
+	0.317211f,
+	-0.448022f,
+	0.824389f,
+	0.345917f,
+	-0.335673f,
+	0.941977f,
+	-0.00160348f,
+	0.00939714f,
+	0.9768f,
+	-0.213948f,
+	0.0525806f,
+	0.945774f,
+	-0.320541f,
+	-0.0139338f,
+	0.984205f,
+	-0.176483f,
+	-0.233879f,
+	0.941098f,
+	-0.244203f,
+	0.35813f,
+	0.924476f,
+	-0.13072f,
+	0.148621f,
+	0.988076f,
+	0.040214f,
+	-0.0873945f,
+	0.896884f,
+	0.433546f,
+	0.16715f,
+	0.882598f,
+	0.43941f,
+	0.105867f,
+	0.92276f,
+	0.370549f,
+	0.162793f,
+	0.877156f,
+	0.451769f,
+	0.26606f,
+	0.895485f,
+	0.356818f,
+	0.178343f,
+	0.923603f,
+	0.339339f,
+	0.205659f,
+	0.876785f,
+	0.434686f,
+	0.164046f,
+	0.939287f,
+	0.301379f,
+	-0.304778f,
+	0.94913f,
+	-0.0791393f,
+	-0.351721f,
+	0.931897f,
+	-0.088655f,
+	-0.137155f,
+	0.986834f,
+	0.0857151f,
+	-0.0493791f,
+	0.984585f,
+	0.167793f,
+	-0.29261f,
+	0.942092f,
+	0.163834f,
+	0.175576f,
+	0.863797f,
+	0.472257f,
+	0.388427f,
+	0.769345f,
+	0.507181f,
+	0.0396361f,
+	0.995255f,
+	0.0888612f,
+	0.000897162f,
+	0.999738f,
+	-0.022857f,
+	0.263974f,
+	0.951061f,
+	0.160623f,
+	0.140984f,
+	0.987533f,
+	0.0700142f,
+	-0.0604349f,
+	0.998129f,
+	-0.00925637f,
+	-0.0323604f,
+	0.969904f,
+	0.241328f,
+	0.0249905f,
+	0.978924f,
+	0.202689f,
+	0.301944f,
+	0.900385f,
+	0.313268f,
+	0.302439f,
+	0.903212f,
+	0.304531f,
+	0.227241f,
+	0.927301f,
+	0.297445f,
+	0.295557f,
+	0.903047f,
+	0.311692f,
+	0.215996f,
+	0.968849f,
+	0.121149f,
+	0.0543993f,
+	0.994951f,
+	0.0843384f,
+	-0.108272f,
+	0.967731f,
+	0.227539f,
+	-0.144218f,
+	0.941468f,
+	0.304694f,
+	-0.0465574f,
+	0.94074f,
+	0.335917f,
+	0.0834793f,
+	0.95338f,
+	0.289996f,
+	0.159412f,
+	0.96437f,
+	0.211135f,
+	0.125672f,
+	0.984055f,
+	0.125864f,
+	0.0125305f,
+	0.999902f,
+	-0.00630946f,
+	-0.0213081f,
+	0.999771f,
+	-0.00209364f,
+	-0.0845682f,
+	0.99631f,
+	0.014661f,
+	-0.191644f,
+	0.962461f,
+	0.192203f,
+	-0.326186f,
+	0.912172f,
+	0.248084f,
+	-0.125723f,
+	0.965189f,
+	0.229357f,
+	-0.0487346f,
+	0.993706f,
+	0.100859f,
+	0.0069351f,
+	0.999976f,
+	0.00057427f,
+	-0.0853775f,
+	0.991791f,
+	-0.0951918f,
+	-0.217561f,
+	0.97582f,
+	-0.0210368f,
+	-0.247132f,
+	0.964013f,
+	0.0979986f,
+	-0.253847f,
+	0.965546f,
+	-0.0573009f,
+	-0.17269f,
+	0.977352f,
+	-0.122318f,
+	-0.308873f,
+	0.930936f,
+	-0.19482f,
+	-0.274273f,
+	0.935966f,
+	-0.220775f,
+	-0.176582f,
+	0.954344f,
+	-0.240926f,
+	-0.17678f,
+	0.967725f,
+	-0.179601f,
+	-0.142126f,
+	0.989789f,
+	-0.0108556f,
+	-0.241082f,
+	0.966299f,
+	-0.0902532f,
+	-0.303483f,
+	0.94088f,
+	-0.150476f,
+	-0.634535f,
+	0.768468f,
+	-0.082594f,
+	-0.47113f,
+	0.814002f,
+	0.339761f,
+	-0.289984f,
+	0.937003f,
+	0.194769f,
+	0.025067f,
+	0.999685f,
+	-0.000862102f,
+	0.289006f,
+	0.893747f,
+	-0.343064f,
+	0.00615404f,
+	0.935866f,
+	-0.352301f,
+	-0.338901f,
+	0.929111f,
+	-0.147984f,
+	-0.164518f,
+	0.985591f,
+	-0.0393034f,
+	0.290961f,
+	0.935697f,
+	-0.199533f,
+	-0.0876053f,
+	0.971539f,
+	-0.220083f,
+	-0.32548f,
+	0.935239f,
+	0.139248f,
+	0.0766933f,
+	0.974848f,
+	0.20926f,
+	0.108828f,
+	0.917507f,
+	0.382541f,
+	0.0350786f,
+	0.924503f,
+	0.379557f,
+	0.162845f,
+	0.883516f,
+	0.439183f,
+	0.280718f,
+	0.786151f,
+	0.550603f,
+	0.282161f,
+	0.80649f,
+	0.519575f,
+	0.319525f,
+	0.746566f,
+	0.583561f,
+	-0.0912168f,
+	0.872752f,
+	0.479567f,
+	-0.288082f,
+	0.924626f,
+	0.249148f,
+	-0.142667f,
+	0.981082f,
+	0.130856f,
+	-0.066753f,
+	0.9808f,
+	0.183236f,
+	-0.230244f,
+	0.961075f,
+	0.152718f,
+	-0.067082f,
+	0.99457f,
+	0.0795691f,
+	0.611911f,
+	0.730537f,
+	0.303119f,
+	0.451199f,
+	0.889041f,
+	0.077617f,
+	0.0130284f,
+	0.992329f,
+	-0.12294f,
+	0.0930856f,
+	0.993052f,
+	-0.0719959f,
+	0.26722f,
+	0.962884f,
+	0.0380388f,
+	0.075301f,
+	0.995117f,
+	-0.0638176f,
+	0.167918f,
+	0.972374f,
+	0.162147f,
+	0.0578882f,
+	0.993576f,
+	0.0972437f,
+	0.196869f,
+	0.968468f,
+	0.152684f,
+	0.304163f,
+	0.924874f,
+	0.228237f,
+	0.255006f,
+	0.935584f,
+	0.244244f,
+	0.260728f,
+	0.944471f,
+	0.199987f,
+	0.218361f,
+	0.924111f,
+	0.313587f,
+	0.0535174f,
+	0.911234f,
+	0.408398f,
+	-0.0710624f,
+	0.921034f,
+	0.382946f,
+	-0.130246f,
+	0.949543f,
+	0.285314f,
+	-0.0655027f,
+	0.977569f,
+	0.200169f,
+	0.0903252f,
+	0.974724f,
+	0.204338f,
+	0.155207f,
+	0.949154f,
+	0.273892f,
+	0.153701f,
+	0.938218f,
+	0.310037f,
+	0.0621551f,
+	0.960028f,
+	0.272917f,
+	-0.0534301f,
+	0.951765f,
+	0.30214f,
+	-0.196733f,
+	0.911558f,
+	0.361052f,
+	-0.281614f,
+	0.838193f,
+	0.46704f,
+	-0.263195f,
+	0.866235f,
+	0.424694f,
+	-0.0481024f,
+	0.917426f,
+	0.394989f,
+	0.0935627f,
+	0.945047f,
+	0.31326f,
+	0.130693f,
+	0.965135f,
+	0.226792f,
+	0.00742185f,
+	0.989033f,
+	0.14751f,
+	-0.243053f,
+	0.969364f,
+	0.0354789f,
+	-0.273599f,
+	0.961363f,
+	-0.0304179f,
+	-0.215123f,
+	0.976563f,
+	-0.00682047f,
+	-0.164989f,
+	0.983922f,
+	0.068385f,
+	-0.241802f,
+	0.97031f,
+	0.00552545f,
+	-0.241315f,
+	0.967202f,
+	-0.0792945f,
+	-0.169018f,
+	0.981272f,
+	-0.0923975f,
+	-0.282714f,
+	0.953981f,
+	-0.0999632f,
+	-0.234963f,
+	0.971912f,
+	-0.0134244f,
+	-0.109087f,
+	0.993838f,
+	-0.0196489f,
+	-0.369236f,
+	0.9273f,
+	-0.0614783f,
+	-0.551241f,
+	0.800465f,
+	0.235349f,
+	-0.62344f,
+	0.781571f,
+	-0.0216512f,
+	-0.285923f,
+	0.957424f,
+	0.0398505f,
+	0.246101f,
+	0.967083f,
+	0.064696f,
+	0.379822f,
+	0.894837f,
+	-0.234526f,
+	-0.124179f,
+	0.991035f,
+	0.0492959f,
+	-0.55499f,
+	0.830986f,
+	0.0380685f,
+	-0.0883601f,
+	0.986961f,
+	0.13454f,
+	0.492332f,
+	0.870217f,
+	0.0182045f,
+	-0.0249785f,
+	0.975709f,
+	-0.217643f,
+	-0.368665f,
+	0.864796f,
+	-0.340902f,
+	-0.0172444f,
+	0.938433f,
+	-0.345031f,
+	-0.0663306f,
+	0.97669f,
+	-0.204147f,
+	0.00514992f,
+	0.997132f,
+	-0.0755029f,
+	0.0570337f,
+	0.998371f,
+	-0.00125828f,
+	0.249285f,
+	0.962439f,
+	0.107557f,
+	0.242481f,
+	0.961206f,
+	0.131476f,
+	0.205153f,
+	0.940815f,
+	0.269776f,
+	0.193253f,
+	0.908579f,
+	0.370322f,
+	-0.0564604f,
+	0.989265f,
+	0.134783f,
+	0.0286103f,
+	0.993761f,
+	-0.107795f,
+	-0.22802f,
+	0.927614f,
+	-0.29587f,
+	-0.141654f,
+	0.989087f,
+	-0.0405023f,
+	-0.0918591f,
+	0.979413f,
+	-0.179757f,
+	0.474817f,
+	0.877478f,
+	-0.067685f,
+	0.562064f,
+	0.827022f,
+	0.0108876f,
+	0.0667731f,
+	0.98619f,
+	-0.151561f,
+	0.0478258f,
+	0.978171f,
+	-0.202223f,
+	0.240461f,
+	0.955483f,
+	-0.170967f,
+	0.22331f,
+	0.956303f,
+	-0.188725f,
+	0.105513f,
+	0.987685f,
+	0.115519f,
+	0.0191904f,
+	0.988704f,
+	0.148645f,
+	0.138326f,
+	0.966121f,
+	0.217888f,
+	0.261136f,
+	0.942738f,
+	0.207491f,
+	0.283954f,
+	0.937656f,
+	0.20043f,
+	0.227821f,
+	0.960294f,
+	0.161036f,
+	0.0632997f,
+	0.956465f,
+	0.284901f,
+	-0.0487147f,
+	0.902832f,
+	0.427225f,
+	-0.0448066f,
+	0.869805f,
+	0.491357f,
+	0.0191513f,
+	0.881775f,
+	0.471282f,
+	0.0794772f,
+	0.93047f,
+	0.357644f,
+	0.0542875f,
+	0.971817f,
+	0.2294f,
+	0.0315472f,
+	0.963796f,
+	0.264769f,
+	0.140004f,
+	0.919916f,
+	0.36627f,
+	0.0838185f,
+	0.924915f,
+	0.370818f,
+	-0.147814f,
+	0.916849f,
+	0.370861f,
+	-0.285354f,
+	0.864307f,
+	0.414182f,
+	-0.277978f,
+	0.859855f,
+	0.428226f,
+	-0.199243f,
+	0.910371f,
+	0.362666f,
+	0.00801534f,
+	0.941586f,
+	0.336678f,
+	0.134574f,
+	0.9298f,
+	0.342582f,
+	0.118153f,
+	0.909557f,
+	0.398429f,
+	0.0557977f,
+	0.896269f,
+	0.439987f,
+	-0.0363608f,
+	0.927402f,
+	0.372294f,
+	-0.166377f,
+	0.978738f,
+	0.119962f,
+	-0.285966f,
+	0.957794f,
+	-0.0292047f,
+	-0.233552f,
+	0.97096f,
+	0.0518564f,
+	-0.131443f,
+	0.981568f,
+	0.138735f,
+	-0.225195f,
+	0.974079f,
+	0.0213645f,
+	-0.190643f,
+	0.980844f,
+	0.0400016f,
+	-0.234677f,
+	0.970688f,
+	0.051878f,
+	-0.269033f,
+	0.961888f,
+	-0.0489107f,
+	-0.0845976f,
+	0.996159f,
+	0.0225919f,
+	-0.404645f,
+	0.907558f,
+	0.112255f,
+	-0.609864f,
+	0.674076f,
+	0.416758f,
+	-0.498816f,
+	0.848126f,
+	0.178504f,
+	-0.144072f,
+	0.987953f,
+	-0.0565038f,
+	0.166758f,
+	0.948601f,
+	-0.268974f,
+	0.264567f,
+	0.924612f,
+	0.274038f,
+	-0.242512f,
+	0.859891f,
+	0.449195f,
+	-0.469649f,
+	0.864648f,
+	0.178364f,
+	-0.10506f,
+	0.987899f,
+	0.114094f,
+	0.522959f,
+	0.850167f,
+	0.0610757f,
+	0.207342f,
+	0.943984f,
+	-0.256717f,
+	-0.370985f,
+	0.736513f,
+	-0.565613f,
+	-0.196204f,
+	0.840957f,
+	-0.504277f,
+	-0.176697f,
+	0.964208f,
+	-0.197689f,
+	-0.102305f,
+	0.980589f,
+	-0.167266f,
+	0.103476f,
+	0.966902f,
+	-0.233225f,
+	0.176136f,
+	0.882185f,
+	-0.436721f,
+	0.1356f,
+	0.926363f,
+	-0.351374f,
+	0.144454f,
+	0.987968f,
+	-0.0552396f,
+	0.173673f,
+	0.98445f,
+	-0.0263929f,
+	0.186245f,
+	0.978364f,
+	-0.0900963f,
+	0.313839f,
+	0.899877f,
+	-0.302865f,
+	0.0432774f,
+	0.865555f,
+	-0.498941f,
+	-0.311487f,
+	0.833772f,
+	-0.45585f,
+	-0.00804547f,
+	0.940342f,
+	-0.340136f,
+	0.304128f,
+	0.919914f,
+	-0.247515f,
+	0.693924f,
+	0.703662f,
+	0.152743f,
+	0.239861f,
+	0.957303f,
+	-0.161363f,
+	0.0838446f,
+	0.969769f,
+	-0.229169f,
+	0.258925f,
+	0.935636f,
+	-0.239881f,
+	0.257223f,
+	0.918931f,
+	-0.299002f,
+	0.0548176f,
+	0.967903f,
+	0.245271f,
+	0.0212885f,
+	0.963347f,
+	0.267412f,
+	0.0818858f,
+	0.973102f,
+	0.215332f,
+	0.303912f,
+	0.917546f,
+	0.25641f,
+	0.304793f,
+	0.927062f,
+	0.218307f,
+	0.238677f,
+	0.941098f,
+	0.239517f,
+	-0.064428f,
+	0.967965f,
+	0.242677f,
+	-0.187169f,
+	0.922119f,
+	0.338622f,
+	-0.088608f,
+	0.904799f,
+	0.416518f,
+	0.0498324f,
+	0.910793f,
+	0.409846f,
+	0.176362f,
+	0.913248f,
+	0.367253f,
+	0.168717f,
+	0.938419f,
+	0.301504f,
+	0.00502329f,
+	0.962305f,
+	0.271928f,
+	0.0457173f,
+	0.940418f,
+	0.336934f,
+	0.0516487f,
+	0.913931f,
+	0.402569f,
+	-0.133343f,
+	0.891616f,
+	0.432713f,
+	-0.271457f,
+	0.878825f,
+	0.392399f,
+	-0.232052f,
+	0.920355f,
+	0.3148f,
+	-0.147635f,
+	0.961854f,
+	0.230305f,
+	-0.0156622f,
+	0.96416f,
+	0.264858f,
+	0.0430262f,
+	0.93984f,
+	0.338894f,
+	-0.0165403f,
+	0.899263f,
+	0.437095f,
+	0.0174547f,
+	0.845985f,
+	0.53292f,
+	0.0913065f,
+	0.841589f,
+	0.532345f,
+	0.0967863f,
+	0.903784f,
+	0.416901f,
+	-0.0948439f,
+	0.973273f,
+	0.209153f,
+	-0.30724f,
+	0.95163f,
+	-0.00197291f,
+	-0.219507f,
+	0.974242f,
+	0.051671f,
+	-0.123616f,
+	0.986822f,
+	0.104414f,
+	-0.209302f,
+	0.977457f,
+	0.0277521f,
+	-0.245642f,
+	0.966973f,
+	0.0679884f,
+	-0.189013f,
+	0.970874f,
+	0.147233f,
+	-0.260969f,
+	0.955926f,
+	0.134541f,
+	-0.586593f,
+	0.772947f,
+	0.241789f,
+	-0.622505f,
+	0.744412f,
+	0.241534f,
+	-0.343069f,
+	0.923585f,
+	0.171158f,
+	0.270136f,
+	0.949637f,
+	0.158794f,
+	-0.0270125f,
+	0.976583f,
+	-0.213437f,
+	-0.293688f,
+	0.905533f,
+	0.306199f,
+	-0.165876f,
+	0.923469f,
+	0.345963f,
+	-0.101353f,
+	0.963266f,
+	0.248689f,
+	-0.0607966f,
+	0.998139f,
+	0.00473307f,
+	0.571806f,
+	0.81892f,
+	0.04908f,
+	0.496821f,
+	0.86721f,
+	0.0334054f,
+	-0.0103979f,
+	0.971297f,
+	-0.237642f,
+	-0.296903f,
+	0.868994f,
+	-0.395851f,
+	-0.405401f,
+	0.821757f,
+	-0.400457f,
+	-0.0724266f,
+	0.96927f,
+	-0.235097f,
+	0.416989f,
+	0.879556f,
+	-0.229132f,
+	0.361436f,
+	0.845922f,
+	-0.392148f,
+	-0.194841f,
+	0.930819f,
+	-0.309213f,
+	-0.180426f,
+	0.920987f,
+	-0.345297f,
+	0.16396f,
+	0.957989f,
+	-0.235318f,
+	0.390246f,
+	0.873397f,
+	-0.291351f,
+	0.368832f,
+	0.745912f,
+	-0.554597f,
+	0.0989123f,
+	0.900328f,
+	-0.423823f,
+	-0.474178f,
+	0.712544f,
+	-0.517143f,
+	-0.225662f,
+	0.862106f,
+	-0.453707f,
+	0.0544551f,
+	0.930953f,
+	-0.361055f,
+	0.547706f,
+	0.827837f,
+	-0.121263f,
+	0.394416f,
+	0.886974f,
+	-0.240235f,
+	0.0920684f,
+	0.955894f,
+	-0.278909f,
+	0.287609f,
+	0.908713f,
+	-0.302524f,
+	0.34308f,
+	0.875033f,
+	-0.341487f,
+	-0.0471282f,
+	0.962572f,
+	0.266897f,
+	0.0309198f,
+	0.953932f,
+	0.298424f,
+	0.131633f,
+	0.963671f,
+	0.232402f,
+	0.278528f,
+	0.937297f,
+	0.209515f,
+	0.282669f,
+	0.933258f,
+	0.221646f,
+	0.232384f,
+	0.927485f,
+	0.292863f,
+	-0.0647083f,
+	0.957687f,
+	0.280443f,
+	-0.249973f,
+	0.928177f,
+	0.275683f,
+	-0.129841f,
+	0.953629f,
+	0.271538f,
+	0.0843284f,
+	0.953748f,
+	0.288536f,
+	0.245794f,
+	0.935145f,
+	0.255127f,
+	0.172562f,
+	0.957759f,
+	0.230042f,
+	-0.0230052f,
+	0.954645f,
+	0.296857f,
+	-0.041189f,
+	0.951248f,
+	0.305663f,
+	0.00483043f,
+	0.930995f,
+	0.364999f,
+	-0.165245f,
+	0.915404f,
+	0.367054f,
+	-0.220878f,
+	0.904299f,
+	0.365316f,
+	-0.0993279f,
+	0.939818f,
+	0.326919f,
+	-0.130653f,
+	0.959943f,
+	0.247869f,
+	-0.122986f,
+	0.930904f,
+	0.343936f,
+	-0.00592517f,
+	0.911134f,
+	0.412068f,
+	-0.1345f,
+	0.9137f,
+	0.383488f,
+	-0.0693903f,
+	0.866333f,
+	0.494623f,
+	0.121472f,
+	0.852483f,
+	0.508447f,
+	0.210048f,
+	0.85163f,
+	0.480215f,
+	0.0819942f,
+	0.889969f,
+	0.448588f,
+	-0.0885916f,
+	0.940837f,
+	0.327072f,
+	-0.228328f,
+	0.96901f,
+	0.0942702f,
+	-0.142437f,
+	0.987843f,
+	0.0622738f,
+	-0.157298f,
+	0.987135f,
+	0.0286638f,
+	-0.320718f,
+	0.947161f,
+	0.00499032f,
+	-0.336449f,
+	0.936473f,
+	0.0990975f,
+	-0.304779f,
+	0.919932f,
+	0.246646f,
+	-0.589969f,
+	0.761912f,
+	0.267259f,
+	-0.577652f,
+	0.799842f,
+	0.163009f,
+	-0.2738f,
+	0.948238f,
+	0.160868f,
+	0.240449f,
+	0.968762f,
+	0.0607085f,
+	-0.0196269f,
+	0.999224f,
+	-0.0341484f,
+	-0.384279f,
+	0.908117f,
+	0.166292f,
+	-0.0937293f,
+	0.985711f,
+	0.139963f,
+	0.0542133f,
+	0.980144f,
+	0.190731f,
+	0.0177665f,
+	0.999043f,
+	0.039964f,
+	0.448192f,
+	0.892243f,
+	0.0550135f,
+	0.417622f,
+	0.800327f,
+	0.430197f,
+	0.199972f,
+	0.838529f,
+	0.506833f,
+	-0.0526069f,
+	0.975321f,
+	0.214434f,
+	-0.547935f,
+	0.818163f,
+	-0.174291f,
+	-0.280437f,
+	0.954205f,
+	-0.10415f,
+	0.341739f,
+	0.938698f,
+	0.0453871f,
+	0.346269f,
+	0.925369f,
+	0.15424f,
+	-0.319444f,
+	0.944119f,
+	0.0812127f,
+	-0.192857f,
+	0.977783f,
+	0.0821343f,
+	0.335818f,
+	0.935599f,
+	-0.108997f,
+	0.474712f,
+	0.785031f,
+	-0.397964f,
+	0.373974f,
+	0.907089f,
+	-0.193218f,
+	0.0523306f,
+	0.977738f,
+	-0.203201f,
+	-0.41385f,
+	0.870502f,
+	-0.266372f,
+	-0.377073f,
+	0.911356f,
+	-0.165066f,
+	0.0445989f,
+	0.977381f,
+	-0.206731f,
+	0.525837f,
+	0.831576f,
+	-0.178819f,
+	0.378975f,
+	0.901633f,
+	-0.208411f,
+	0.088353f,
+	0.958416f,
+	-0.271353f,
+	0.309469f,
+	0.925076f,
+	-0.220144f,
+	0.420279f,
+	0.904173f,
+	-0.0763995f,
+	0.00329705f,
+	0.962532f,
+	0.271149f,
+	0.0784063f,
+	0.967252f,
+	0.241403f,
+	0.186812f,
+	0.966508f,
+	0.175965f,
+	0.294591f,
+	0.944303f,
+	0.146656f,
+	0.242144f,
+	0.958708f,
+	0.149151f,
+	0.122249f,
+	0.946777f,
+	0.297772f,
+	-0.0273117f,
+	0.906407f,
+	0.421521f,
+	-0.206066f,
+	0.9181f,
+	0.338568f,
+	-0.0954796f,
+	0.950658f,
+	0.295183f,
+	0.102184f,
+	0.964671f,
+	0.242834f,
+	0.213961f,
+	0.952875f,
+	0.215059f,
+	0.119187f,
+	0.935673f,
+	0.33213f,
+	-0.0431159f,
+	0.926594f,
+	0.373584f,
+	-0.0072858f,
+	0.954565f,
+	0.297913f,
+	-0.0455381f,
+	0.966183f,
+	0.253806f,
+	-0.154593f,
+	0.937454f,
+	0.311898f,
+	-0.199077f,
+	0.936411f,
+	0.288969f,
+	-0.136466f,
+	0.95497f,
+	0.263457f,
+	-0.127877f,
+	0.920831f,
+	0.3684f,
+	-0.229636f,
+	0.912787f,
+	0.337767f,
+	-0.0324452f,
+	0.91205f,
+	0.408794f,
+	-0.100812f,
+	0.892675f,
+	0.439282f,
+	-0.166782f,
+	0.900555f,
+	0.401477f,
+	0.102011f,
+	0.876619f,
+	0.470247f,
+	0.195025f,
+	0.830402f,
+	0.521918f,
+	0.0914158f,
+	0.843587f,
+	0.529154f,
+	0.0626366f,
+	0.873316f,
+	0.48311f,
+	-0.00226622f,
+	0.929744f,
+	0.3682f,
+	-0.0934177f,
+	0.966149f,
+	0.240479f,
+	-0.109555f,
+	0.963702f,
+	0.243468f,
+	-0.302241f,
+	0.931855f,
+	0.200739f,
+	-0.368178f,
+	0.918352f,
+	0.145171f,
+	-0.476623f,
+	0.864028f,
+	0.162128f,
+	-0.569304f,
+	0.726984f,
+	0.383911f,
+	-0.64096f,
+	0.755201f,
+	0.137264f,
+	-0.241026f,
+	0.942011f,
+	0.233501f,
+	0.376487f,
+	0.905115f,
+	0.197547f,
+	0.13011f,
+	0.991259f,
+	-0.0218225f,
+	-0.643013f,
+	0.733979f,
+	-0.218653f,
+	-0.19089f,
+	0.942227f,
+	0.275264f,
+	-0.00867818f,
+	0.931663f,
+	0.363219f,
+	0.146287f,
+	0.916711f,
+	0.371809f,
+	0.32054f,
+	0.88208f,
+	0.345239f,
+	0.0976689f,
+	0.827123f,
+	0.55347f,
+	0.0475977f,
+	0.818583f,
+	0.572413f,
+	0.312042f,
+	0.775215f,
+	0.549246f,
+	-0.398647f,
+	0.872033f,
+	0.283969f,
+	-0.297551f,
+	0.880657f,
+	0.368657f,
+	0.0684096f,
+	0.950263f,
+	0.303844f,
+	0.473417f,
+	0.718991f,
+	0.50885f,
+	-0.0712795f,
+	0.964076f,
+	0.255885f,
+	-0.187608f,
+	0.981414f,
+	0.0403824f,
+	0.441688f,
+	0.892595f,
+	0.090477f,
+	0.402228f,
+	0.910874f,
+	0.0923076f,
+	0.356001f,
+	0.889285f,
+	0.287114f,
+	0.109119f,
+	0.990916f,
+	0.0786044f,
+	-0.366364f,
+	0.926283f,
+	0.0881909f,
+	-0.361407f,
+	0.913864f,
+	0.185034f,
+	0.114451f,
+	0.98516f,
+	0.127909f,
+	0.511212f,
+	0.854805f,
+	0.0892759f,
+	0.488262f,
+	0.865451f,
+	0.112231f,
+	0.135362f,
+	0.990178f,
+	0.0350016f,
+	0.158924f,
+	0.983832f,
+	0.0825671f,
+	0.139428f,
+	0.973099f,
+	0.183407f,
+	-0.0124598f,
+	0.997106f,
+	0.0750005f,
+	0.111778f,
+	0.989445f,
+	0.0922193f,
+	0.245419f,
+	0.967744f,
+	0.0569325f,
+	0.2823f,
+	0.95863f,
+	0.0365395f,
+	0.172017f,
+	0.973333f,
+	0.151766f,
+	-0.129296f,
+	0.953534f,
+	0.27213f,
+	-0.0899396f,
+	0.877846f,
+	0.470422f,
+	-0.0963581f,
+	0.899855f,
+	0.425413f,
+	-0.0212856f,
+	0.934761f,
+	0.354638f,
+	0.147549f,
+	0.94824f,
+	0.281195f,
+	0.129526f,
+	0.93959f,
+	0.316849f,
+	0.0223606f,
+	0.903767f,
+	0.427441f,
+	-0.0124316f,
+	0.909175f,
+	0.41623f,
+	0.115235f,
+	0.910193f,
+	0.397831f,
+	-0.0283739f,
+	0.950232f,
+	0.310248f,
+	-0.203804f,
+	0.932573f,
+	0.297946f,
+	-0.13899f,
+	0.955458f,
+	0.260347f,
+	-0.204301f,
+	0.958838f,
+	0.197208f,
+	-0.229868f,
+	0.915186f,
+	0.331053f,
+	-0.132513f,
+	0.91447f,
+	0.38234f,
+	-0.151493f,
+	0.940711f,
+	0.3035f,
+	-0.124022f,
+	0.907796f,
+	0.400656f,
+	-0.112999f,
+	0.914934f,
+	0.387462f,
+	-0.039891f,
+	0.908327f,
+	0.416355f,
+	0.0930682f,
+	0.835427f,
+	0.541664f,
+	0.161351f,
+	0.801381f,
+	0.575981f,
+	0.131487f,
+	0.83942f,
+	0.527339f,
+	0.132693f,
+	0.857332f,
+	0.497367f,
+	-0.0832448f,
+	0.920852f,
+	0.380923f,
+	-0.145993f,
+	0.894645f,
+	0.422252f,
+	-0.213236f,
+	0.888697f,
+	0.405893f,
+	-0.293641f,
+	0.888131f,
+	0.353551f,
+	-0.525155f,
+	0.788991f,
+	0.318912f,
+	-0.588027f,
+	0.679363f,
+	0.438964f,
+	-0.478637f,
+	0.812929f,
+	0.331743f,
+	-0.264049f,
+	0.917426f,
+	0.297671f,
+	0.302963f,
+	0.900818f,
+	0.31103f,
+	0.420369f,
+	0.80167f,
+	0.424988f,
+	-0.470879f,
+	0.867699f,
+	0.159284f,
+	-0.530406f,
+	0.817263f,
+	0.225279f,
+	-0.0411983f,
+	0.860627f,
+	0.507566f,
+	0.103255f,
+	0.833118f,
+	0.543372f,
+	0.186539f,
+	0.814428f,
+	0.549463f,
+	0.132619f,
+	0.779192f,
+	0.612594f,
+	0.0761138f,
+	0.83531f,
+	0.544485f,
+	0.378863f,
+	0.611781f,
+	0.694397f,
+	-0.172003f,
+	0.719417f,
+	0.672944f,
+	-0.295852f,
+	0.804769f,
+	0.514605f,
+	0.0593285f,
+	0.827842f,
+	0.557814f,
+	0.323809f,
+	0.743921f,
+	0.584575f,
+	0.339913f,
+	0.758357f,
+	0.556197f,
+	-0.00694706f,
+	0.946602f,
+	0.322331f,
+	0.188872f,
+	0.934445f,
+	0.301895f,
+	0.251044f,
+	0.713229f,
+	0.654432f,
+	0.351195f,
+	0.638214f,
+	0.685087f,
+	0.295602f,
+	0.899369f,
+	0.322109f,
+	-0.450583f,
+	0.880167f,
+	0.14927f,
+	-0.375985f,
+	0.904392f,
+	0.201769f,
+	0.158376f,
+	0.94847f,
+	0.274448f,
+	0.500024f,
+	0.831884f,
+	0.240719f,
+	0.503159f,
+	0.8293f,
+	0.243089f,
+	0.0889199f,
+	0.964326f,
+	0.249335f,
+	0.108789f,
+	0.932871f,
+	0.34339f,
+	0.066105f,
+	0.944864f,
+	0.320722f,
+	-0.09433f,
+	0.994124f,
+	-0.0530892f,
+	0.0903529f,
+	0.995715f,
+	-0.0196726f,
+	0.246451f,
+	0.969124f,
+	-0.00783612f,
+	0.17532f,
+	0.977334f,
+	0.118663f,
+	0.0145033f,
+	0.945036f,
+	0.326645f,
+	-0.208385f,
+	0.89773f,
+	0.388145f,
+	-0.186403f,
+	0.920929f,
+	0.342264f,
+	-0.0196042f,
+	0.920127f,
+	0.391129f,
+	0.088861f,
+	0.938743f,
+	0.332966f,
+	0.0904885f,
+	0.955513f,
+	0.280725f,
+	0.00776342f,
+	0.887041f,
+	0.461625f,
+	0.0357997f,
+	0.855618f,
+	0.516368f,
+	0.0251977f,
+	0.899984f,
+	0.435195f,
+	0.113155f,
+	0.898436f,
+	0.424273f,
+	0.0488401f,
+	0.928538f,
+	0.36801f,
+	-0.122117f,
+	0.962671f,
+	0.241562f,
+	-0.0832756f,
+	0.977563f,
+	0.193483f,
+	-0.182752f,
+	0.960599f,
+	0.209407f,
+	-0.340533f,
+	0.923546f,
+	0.176353f,
+	-0.207225f,
+	0.949201f,
+	0.236801f,
+	-0.0875863f,
+	0.939463f,
+	0.331268f,
+	-0.156293f,
+	0.945917f,
+	0.284277f,
+	-0.15128f,
+	0.944026f,
+	0.293135f,
+	-0.133917f,
+	0.921967f,
+	0.363377f,
+	-0.0187779f,
+	0.901995f,
+	0.431337f,
+	0.137151f,
+	0.859664f,
+	0.492105f,
+	0.151864f,
+	0.841546f,
+	0.518398f,
+	0.169983f,
+	0.832825f,
+	0.526791f,
+	0.0329472f,
+	0.8585f,
+	0.511754f,
+	-0.148058f,
+	0.877168f,
+	0.456787f,
+	-0.179554f,
+	0.872912f,
+	0.453636f,
+	-0.29061f,
+	0.863835f,
+	0.411502f,
+	-0.582219f,
+	0.748049f,
+	0.318501f,
+	-0.586418f,
+	0.753548f,
+	0.297117f,
+	-0.423744f,
+	0.867437f,
+	0.260755f,
+	-0.266814f,
+	0.914007f,
+	0.305617f,
+	0.297036f,
+	0.879751f,
+	0.371224f,
+	0.301464f,
+	0.846429f,
+	0.438951f,
+	-0.267915f,
+	0.8201f,
+	0.505626f,
+	-0.708126f,
+	0.705156f,
+	0.0362171f,
+	-0.280503f,
+	0.856013f,
+	0.434234f,
+	0.0634361f,
+	0.843315f,
+	0.533662f,
+	0.203328f,
+	0.848496f,
+	0.488581f,
+	0.157757f,
+	0.86266f,
+	0.480552f,
+	-0.0108627f,
+	0.875364f,
+	0.483343f,
+	-0.00732908f,
+	0.804113f,
+	0.594431f,
+	0.217513f,
+	0.756413f,
+	0.616869f,
+	-0.242879f,
+	0.903897f,
+	0.352108f,
+	-0.0770731f,
+	0.775477f,
+	0.626654f,
+	0.238061f,
+	0.731126f,
+	0.639361f,
+	0.459013f,
+	0.658034f,
+	0.596908f,
+	0.0332364f,
+	0.855326f,
+	0.517022f,
+	-0.132848f,
+	0.766918f,
+	0.627844f,
+	-0.0252308f,
+	0.840734f,
+	0.54086f,
+	0.442735f,
+	0.688282f,
+	0.574677f,
+	0.624206f,
+	0.545029f,
+	0.559742f,
+	-0.216833f,
+	0.89857f,
+	0.381516f,
+	-0.428783f,
+	0.890698f,
+	0.151005f,
+	0.076598f,
+	0.986116f,
+	0.147334f,
+	0.479671f,
+	0.865386f,
+	0.144994f,
+	0.542246f,
+	0.827427f,
+	0.146065f,
+	0.100899f,
+	0.969794f,
+	0.222079f,
+	0.0591096f,
+	0.972132f,
+	0.226859f,
+	0.163564f,
+	0.950136f,
+	0.265495f,
+	-0.0539816f,
+	0.998166f,
+	0.0273959f,
+	0.085626f,
+	0.996323f,
+	0.00278248f,
+	0.159482f,
+	0.986364f,
+	0.0406345f,
+	-0.0565903f,
+	0.982572f,
+	0.177057f,
+	-0.167853f,
+	0.932231f,
+	0.320579f,
+	-0.135579f,
+	0.92648f,
+	0.351075f,
+	-0.12175f,
+	0.950039f,
+	0.287407f,
+	-0.0275f,
+	0.960651f,
+	0.276393f,
+	0.0945575f,
+	0.956567f,
+	0.27575f,
+	0.0118837f,
+	0.934274f,
+	0.356358f,
+	-0.160104f,
+	0.889888f,
+	0.42716f,
+	0.0609856f,
+	0.903744f,
+	0.423707f,
+	0.121664f,
+	0.922268f,
+	0.366906f,
+	0.148425f,
+	0.946235f,
+	0.287418f,
+	0.23463f,
+	0.944122f,
+	0.231479f,
+	-0.0440541f,
+	0.996345f,
+	0.0731815f,
+	-0.127251f,
+	0.98255f,
+	0.135658f,
+	-0.207412f,
+	0.958865f,
+	0.1938f,
+	-0.296871f,
+	0.939382f,
+	0.171549f,
+	-0.278192f,
+	0.946498f,
+	0.163558f,
+	-0.178451f,
+	0.945897f,
+	0.270988f,
+	-0.115294f,
+	0.937073f,
+	0.329548f,
+	-0.175206f,
+	0.945254f,
+	0.275312f,
+	-0.191323f,
+	0.939359f,
+	0.284604f,
+	-0.0822793f,
+	0.949627f,
+	0.302389f,
+	0.0583847f,
+	0.93226f,
+	0.357046f,
+	0.125066f,
+	0.884667f,
+	0.449136f,
+	0.147347f,
+	0.866347f,
+	0.477213f,
+	0.0545541f,
+	0.865292f,
+	0.49829f,
+	-0.098516f,
+	0.887377f,
+	0.450395f,
+	-0.209769f,
+	0.897417f,
+	0.388122f,
+	-0.210182f,
+	0.881546f,
+	0.422729f,
+	-0.451263f,
+	0.852365f,
+	0.264264f,
+	-0.650724f,
+	0.758775f,
+	-0.0286192f,
+	-0.407582f,
+	0.890583f,
+	0.201838f,
+	-0.388367f,
+	0.887583f,
+	0.247725f,
+	0.193188f,
+	0.884808f,
+	0.424019f,
+	0.215311f,
+	0.880386f,
+	0.422566f,
+	-0.165147f,
+	0.855262f,
+	0.491176f,
+	-0.520864f,
+	0.795129f,
+	0.310596f,
+	-0.488998f,
+	0.786967f,
+	0.37625f,
+	0.0562235f,
+	0.868104f,
+	0.493187f,
+	0.400928f,
+	0.84731f,
+	0.348313f,
+	0.199813f,
+	0.978725f,
+	-0.0465961f,
+	-0.198621f,
+	0.97682f,
+	0.0798329f,
+	-0.0891351f,
+	0.888352f,
+	0.450429f,
+	0.204835f,
+	0.834736f,
+	0.511135f,
+	-0.0720813f,
+	0.941881f,
+	0.328121f,
+	-0.196291f,
+	0.972713f,
+	0.123691f,
+	0.179787f,
+	0.980826f,
+	-0.0752149f,
+	0.511674f,
+	0.853811f,
+	0.0958982f,
+	0.0191479f,
+	0.909767f,
+	0.414677f,
+	-0.125562f,
+	0.89333f,
+	0.431505f,
+	0.22305f,
+	0.943278f,
+	0.245918f,
+	0.527748f,
+	0.84488f,
+	0.0875187f,
+	0.598212f,
+	0.799615f,
+	-0.0525252f,
+	0.0107332f,
+	0.903361f,
+	0.428747f,
+	-0.300811f,
+	0.914951f,
+	0.269032f,
+	0.179787f,
+	0.975264f,
+	0.128593f,
+	0.519301f,
+	0.854591f,
+	0.00126655f,
+	0.419398f,
+	0.906587f,
+	-0.0469514f,
+	0.0522982f,
+	0.994257f,
+	0.0933686f,
+	0.0513278f,
+	0.996267f,
+	0.0694112f,
+	0.103651f,
+	0.993237f,
+	0.0523089f,
+	0.0555975f,
+	0.984758f,
+	0.164805f,
+	0.0862163f,
+	0.988349f,
+	0.12543f,
+	0.0909734f,
+	0.981273f,
+	0.169784f,
+	-0.14512f,
+	0.970727f,
+	0.191388f,
+	-0.180918f,
+	0.953611f,
+	0.240612f,
+	-0.140102f,
+	0.96533f,
+	0.22025f,
+	-0.119189f,
+	0.970295f,
+	0.210526f,
+	-0.0126783f,
+	0.974075f,
+	0.225869f,
+	0.0237961f,
+	0.97809f,
+	0.20682f,
+	-0.0862872f,
+	0.95413f,
+	0.286688f,
+	-0.14433f,
+	0.944949f,
+	0.293667f,
+	0.132869f,
+	0.954959f,
+	0.265329f,
+	0.22733f,
+	0.94991f,
+	0.214458f,
+	0.185536f,
+	0.968744f,
+	0.164655f,
+	0.30218f,
+	0.927213f,
+	0.221277f,
+	-0.010566f,
+	0.987352f,
+	0.158194f,
+	-0.227641f,
+	0.957817f,
+	0.175404f,
+	-0.212635f,
+	0.950922f,
+	0.224799f,
+	-0.288872f,
+	0.93765f,
+	0.193302f,
+	-0.303211f,
+	0.936666f,
+	0.175273f,
+	-0.283958f,
+	0.943546f,
+	0.170553f,
+	-0.13575f,
+	0.960553f,
+	0.242714f,
+	-0.0816944f,
+	0.973992f,
+	0.211345f,
+	-0.191701f,
+	0.977982f,
+	0.0824724f,
+	-0.110352f,
+	0.986199f,
+	0.123427f,
+	-0.0409453f,
+	0.971384f,
+	0.233958f,
+	0.0185038f,
+	0.933683f,
+	0.357621f,
+	0.13477f,
+	0.907601f,
+	0.397615f,
+	0.0792432f,
+	0.925049f,
+	0.371489f,
+	-0.0350852f,
+	0.929789f,
+	0.366418f,
+	-0.159548f,
+	0.910971f,
+	0.380363f,
+	-0.245138f,
+	0.905643f,
+	0.346003f,
+	-0.179352f,
+	0.926492f,
+	0.330825f,
+	-0.589052f,
+	0.80668f,
+	0.0478056f,
+	-0.578625f,
+	0.779472f,
+	0.240033f,
+	-0.471687f,
+	0.839166f,
+	0.270762f,
+	0.0987404f,
+	0.916105f,
+	0.388589f,
+	0.173592f,
+	0.831445f,
+	0.527792f,
+	-0.220086f,
+	0.704489f,
+	0.674728f,
+	-0.395802f,
+	0.62503f,
+	0.672813f,
+	-0.417304f,
+	0.755058f,
+	0.505712f,
+	0.0513487f,
+	0.865997f,
+	0.497406f,
+	0.431689f,
+	0.734124f,
+	0.524124f,
+	0.359032f,
+	0.884637f,
+	0.297512f,
+	-0.308259f,
+	0.930686f,
+	0.196975f,
+	-0.34698f,
+	0.877125f,
+	0.332049f,
+	0.00851592f,
+	0.919266f,
+	0.393545f,
+	0.326193f,
+	0.840272f,
+	0.433061f,
+	0.261231f,
+	0.960149f,
+	-0.0993615f,
+	0.388612f,
+	0.889039f,
+	-0.242053f,
+	0.0354931f,
+	0.979528f,
+	-0.198152f,
+	0.0485316f,
+	0.907873f,
+	0.416427f,
+	-0.0781845f,
+	0.964592f,
+	0.251892f,
+	0.47974f,
+	0.876345f,
+	0.0432286f,
+	0.568817f,
+	0.783907f,
+	-0.248873f,
+	0.483889f,
+	0.834837f,
+	-0.262485f,
+	-0.220496f,
+	0.975376f,
+	0.00471288f,
+	-0.25449f,
+	0.933474f,
+	0.252706f,
+	0.326168f,
+	0.921789f,
+	0.209569f,
+	0.609761f,
+	0.790958f,
+	0.0507595f,
+	0.419183f,
+	0.900774f,
+	-0.11354f,
+	-0.0389936f,
+	0.992704f,
+	-0.114095f,
+	0.112818f,
+	0.992086f,
+	-0.0551048f,
+	0.140261f,
+	0.98577f,
+	-0.0926471f,
+	0.0460285f,
+	0.981507f,
+	0.185811f,
+	0.0839854f,
+	0.981486f,
+	0.172137f,
+	0.0780195f,
+	0.983837f,
+	0.161178f,
+	-0.135272f,
+	0.977846f,
+	0.159743f,
+	-0.233239f,
+	0.960885f,
+	0.149328f,
+	-0.119476f,
+	0.978748f,
+	0.166665f,
+	-0.0623017f,
+	0.991047f,
+	0.118089f,
+	-0.0310067f,
+	0.999432f,
+	0.0132292f,
+	-0.0037253f,
+	0.997112f,
+	0.0758502f,
+	-0.0758016f,
+	0.98526f,
+	0.153355f,
+	-0.143296f,
+	0.988211f,
+	0.0539015f,
+	0.103486f,
+	0.991653f,
+	0.076914f,
+	0.266632f,
+	0.947722f,
+	0.175298f,
+	0.164045f,
+	0.978994f,
+	0.121078f,
+	0.196418f,
+	0.969063f,
+	0.149458f,
+	0.0648458f,
+	0.968138f,
+	0.241876f,
+	-0.21695f,
+	0.963194f,
+	0.158716f,
+	-0.238014f,
+	0.956133f,
+	0.17076f,
+	-0.251543f,
+	0.948014f,
+	0.194926f,
+	-0.241597f,
+	0.958745f,
+	0.149794f,
+	-0.248822f,
+	0.966568f,
+	0.0619263f,
+	-0.195635f,
+	0.9804f,
+	0.0233089f,
+	0.00681016f,
+	0.994726f,
+	0.102342f,
+	-0.0728308f,
+	0.997328f,
+	0.00570638f,
+	-0.223928f,
+	0.970021f,
+	-0.0944255f,
+	-0.201047f,
+	0.979434f,
+	0.0169867f,
+	-0.100278f,
+	0.986057f,
+	0.132801f,
+	0.129703f,
+	0.962794f,
+	0.237074f,
+	0.129196f,
+	0.949613f,
+	0.28556f,
+	-0.100355f,
+	0.959332f,
+	0.263838f,
+	-0.226831f,
+	0.927446f,
+	0.297306f,
+	-0.211803f,
+	0.921673f,
+	0.325051f,
+	-0.16781f,
+	0.90652f,
+	0.387378f,
+	-0.507141f,
+	0.76624f,
+	0.394569f,
+	-0.499456f,
+	0.740703f,
+	0.449336f,
+	-0.375574f,
+	0.865361f,
+	0.331805f,
+	0.0665425f,
+	0.96722f,
+	0.245068f,
+	-0.127974f,
+	0.946728f,
+	0.295513f,
+	-0.531445f,
+	0.627941f,
+	0.568557f,
+	-0.268657f,
+	0.746051f,
+	0.609287f,
+	-0.123398f,
+	0.84105f,
+	0.526695f,
+	0.113268f,
+	0.868801f,
+	0.482033f,
+	0.278975f,
+	0.860996f,
+	0.425274f,
+	0.256512f,
+	0.783766f,
+	0.565608f,
+	0.24637f,
+	0.788587f,
+	0.563411f,
+	-0.207735f,
+	0.977522f,
+	-0.036006f,
+	0.0390118f,
+	0.996098f,
+	0.0791601f,
+	0.408253f,
+	0.910351f,
+	0.0677493f,
+	0.466297f,
+	0.863647f,
+	-0.191525f,
+	0.226125f,
+	0.967725f,
+	-0.111247f,
+	-0.24034f,
+	0.965221f,
+	0.102887f,
+	-0.130757f,
+	0.944853f,
+	0.300258f,
+	0.283435f,
+	0.943407f,
+	0.172188f,
+	0.590839f,
+	0.8059f,
+	-0.0378747f,
+	0.573782f,
+	0.756596f,
+	-0.313587f,
+	0.355206f,
+	0.926281f,
+	0.12583f,
+	-0.219704f,
+	0.910923f,
+	0.349212f,
+	-0.277723f,
+	0.959254f,
+	0.051969f,
+	0.340807f,
+	0.938572f,
+	0.0541606f,
+	0.677372f,
+	0.729826f,
+	0.0923128f,
+	0.49544f,
+	0.867668f,
+	-0.0411347f,
+	-0.024834f,
+	0.981688f,
+	-0.188872f,
+	0.050519f,
+	0.974996f,
+	-0.216403f,
+	0.180767f,
+	0.970256f,
+	-0.161015f,
+	0.0401148f,
+	0.977494f,
+	0.207113f,
+	0.106256f,
+	0.969045f,
+	0.222848f,
+	0.0969035f,
+	0.97128f,
+	0.217314f,
+	-0.118574f,
+	0.978564f,
+	0.16838f,
+	-0.194437f,
+	0.978726f,
+	0.0655019f,
+	-0.11441f,
+	0.993427f,
+	0.0037257f,
+	0.00229181f,
+	0.999514f,
+	0.0311045f,
+	0.0309142f,
+	0.998007f,
+	0.0550047f,
+	-0.113357f,
+	0.989867f,
+	0.085516f,
+	-0.111292f,
+	0.980012f,
+	0.164894f,
+	-0.0212066f,
+	0.993646f,
+	0.110539f,
+	0.0241257f,
+	0.999577f,
+	-0.0162417f,
+	0.157698f,
+	0.982481f,
+	0.0993122f,
+	0.222931f,
+	0.950361f,
+	0.21706f,
+	0.18078f,
+	0.964986f,
+	0.190052f,
+	0.0702985f,
+	0.98108f,
+	0.180387f,
+	-0.190259f,
+	0.977665f,
+	0.089291f,
+	-0.268574f,
+	0.956136f,
+	0.116926f,
+	-0.267756f,
+	0.955804f,
+	0.121429f,
+	-0.211446f,
+	0.969418f,
+	0.124579f,
+	-0.14687f,
+	0.983484f,
+	0.105776f,
+	-0.198985f,
+	0.979945f,
+	-0.0106117f,
+	-0.0887412f,
+	0.995564f,
+	0.0312775f,
+	0.0104704f,
+	0.992989f,
+	0.117739f,
+	-0.125001f,
+	0.9915f,
+	0.0360868f,
+	-0.238906f,
+	0.968221f,
+	-0.0739686f,
+	-0.167029f,
+	0.981518f,
+	-0.0933989f,
+	-0.0351406f,
+	0.998931f,
+	-0.030045f,
+	0.0130186f,
+	0.974123f,
+	0.225643f,
+	-0.0745329f,
+	0.922898f,
+	0.377762f,
+	-0.18971f,
+	0.916591f,
+	0.351953f,
+	-0.286917f,
+	0.902381f,
+	0.321538f,
+	-0.328487f,
+	0.84853f,
+	0.414841f,
+	-0.591704f,
+	0.685127f,
+	0.424839f,
+	-0.448564f,
+	0.796089f,
+	0.406241f,
+	-0.170353f,
+	0.888356f,
+	0.426384f,
+	-0.00830475f,
+	0.908708f,
+	0.417349f,
+	-0.140027f,
+	0.883683f,
+	0.446651f,
+	-0.599598f,
+	0.727182f,
+	0.334197f,
+	-0.234879f,
+	0.924162f,
+	0.301258f,
+	-0.0954672f,
+	0.951872f,
+	0.291248f,
+	0.100155f,
+	0.948228f,
+	0.301383f,
+	0.352663f,
+	0.898478f,
+	0.261471f,
+	0.217902f,
+	0.956165f,
+	0.19562f,
+	0.428441f,
+	0.89557f,
+	0.119967f,
+	0.0504867f,
+	0.972497f,
+	-0.227379f,
+	-0.160086f,
+	0.98254f,
+	-0.0948013f,
+	0.319131f,
+	0.945228f,
+	-0.0685555f,
+	0.64992f,
+	0.715088f,
+	0.257397f,
+	0.0361031f,
+	0.995429f,
+	0.0884124f,
+	-0.2599f,
+	0.897768f,
+	0.355618f,
+	-0.17567f,
+	0.983498f,
+	0.0432638f,
+	0.53944f,
+	0.841427f,
+	-0.0317039f,
+	0.60742f,
+	0.697232f,
+	-0.380669f,
+	0.609044f,
+	0.790595f,
+	-0.063438f,
+	-0.195234f,
+	0.980448f,
+	0.0245981f,
+	-0.224173f,
+	0.885759f,
+	0.406419f,
+	0.0964403f,
+	0.992198f,
+	0.0790071f,
+	0.380926f,
+	0.892571f,
+	-0.241272f,
+	0.532566f,
+	0.777301f,
+	-0.334927f,
+	0.58332f,
+	0.811668f,
+	0.0305478f,
+	0.122052f,
+	0.989417f,
+	-0.0784701f,
+	0.094933f,
+	0.975516f,
+	-0.198385f,
+	0.104703f,
+	0.956209f,
+	-0.273317f,
+	0.0116109f,
+	0.989434f,
+	0.144515f,
+	0.0514824f,
+	0.974923f,
+	0.216505f,
+	0.096067f,
+	0.950842f,
+	0.294399f,
+	0.00976988f,
+	0.964716f,
+	0.263111f,
+	-0.0931121f,
+	0.98126f,
+	0.168699f,
+	-0.0745948f,
+	0.982842f,
+	0.168693f,
+	-0.083139f,
+	0.982475f,
+	0.166825f,
+	-0.0763046f,
+	0.97088f,
+	0.22709f,
+	-0.130809f,
+	0.960701f,
+	0.244832f,
+	-0.117161f,
+	0.974629f,
+	0.190711f,
+	0.0735371f,
+	0.976475f,
+	0.202706f,
+	0.123062f,
+	0.984428f,
+	0.125529f,
+	0.0660058f,
+	0.995943f,
+	0.0611663f,
+	0.0811078f,
+	0.98996f,
+	0.115763f,
+	0.156048f,
+	0.953727f,
+	0.257008f,
+	0.12971f,
+	0.935453f,
+	0.32879f,
+	-0.0928149f,
+	0.955298f,
+	0.280698f,
+	-0.264252f,
+	0.949049f,
+	0.171686f,
+	-0.241724f,
+	0.966072f,
+	0.0909662f,
+	-0.244999f,
+	0.96713f,
+	0.0680795f,
+	-0.106995f,
+	0.982895f,
+	0.149898f,
+	-0.106861f,
+	0.990227f,
+	0.089616f,
+	-0.133621f,
+	0.990932f,
+	0.0141138f,
+	-0.0517957f,
+	0.998024f,
+	0.0355675f,
+	-0.0225779f,
+	0.998718f,
+	0.0453005f,
+	-0.144281f,
+	0.986502f,
+	-0.0774439f,
+	-0.157036f,
+	0.983398f,
+	-0.0909287f,
+	-0.161108f,
+	0.986936f,
+	-0.00118469f,
+	-0.22235f,
+	0.965394f,
+	0.136287f,
+	-0.250578f,
+	0.942366f,
+	0.221715f,
+	-0.217658f,
+	0.901831f,
+	0.373264f,
+	-0.29708f,
+	0.848133f,
+	0.438651f,
+	-0.36269f,
+	0.819581f,
+	0.443558f,
+	-0.534096f,
+	0.793842f,
+	0.290785f,
+	-0.584404f,
+	0.811192f,
+	0.0209707f,
+	-0.1404f,
+	0.905222f,
+	0.401075f,
+	-0.307079f,
+	0.89418f,
+	0.325797f,
+	-0.27164f,
+	0.834087f,
+	0.480115f,
+	-0.322843f,
+	0.946322f,
+	0.0157466f,
+	-0.301281f,
+	0.933652f,
+	-0.193713f,
+	-0.127165f,
+	0.985755f,
+	0.11007f,
+	0.121812f,
+	0.97858f,
+	0.165962f,
+	0.500139f,
+	0.864928f,
+	0.0419482f,
+	0.30357f,
+	0.892132f,
+	-0.334582f,
+	0.443241f,
+	0.85073f,
+	-0.282481f,
+	0.0967978f,
+	0.993781f,
+	0.0550442f,
+	-0.201565f,
+	0.978713f,
+	0.0386423f,
+	0.209591f,
+	0.974539f,
+	0.0796601f,
+	0.481917f,
+	0.851558f,
+	0.20641f,
+	-0.0224044f,
+	0.977009f,
+	0.212016f,
+	-0.238315f,
+	0.88567f,
+	0.398491f,
+	0.220358f,
+	0.960844f,
+	0.167992f,
+	0.601263f,
+	0.791797f,
+	-0.107428f,
+	0.618362f,
+	0.741713f,
+	-0.25979f,
+	0.284452f,
+	0.956119f,
+	0.0701626f,
+	-0.201478f,
+	0.913131f,
+	0.3544f,
+	-0.20526f,
+	0.978252f,
+	0.0298624f,
+	0.352634f,
+	0.929538f,
+	-0.107737f,
+	0.649062f,
+	0.752634f,
+	-0.110725f,
+	0.490387f,
+	0.729272f,
+	-0.477162f,
+	0.431974f,
+	0.874843f,
+	-0.219197f,
+	0.184608f,
+	0.975155f,
+	-0.122446f,
+	0.192786f,
+	0.978517f,
+	-0.0730681f,
+	0.240097f,
+	0.966116f,
+	-0.094733f,
+	-0.255309f,
+	0.963455f,
+	-0.0810722f,
+	-0.124334f,
+	0.990531f,
+	0.0582188f,
+	0.042075f,
+	0.979967f,
+	0.194667f,
+	0.0324324f,
+	0.965776f,
+	0.25734f,
+	-0.0760147f,
+	0.965606f,
+	0.248649f,
+	-0.138926f,
+	0.972343f,
+	0.187746f,
+	-0.0932442f,
+	0.974882f,
+	0.202264f,
+	-0.0380092f,
+	0.975147f,
+	0.218276f,
+	-0.0242537f,
+	0.984345f,
+	0.174576f,
+	-0.0724602f,
+	0.995976f,
+	0.0527463f,
+	0.0175716f,
+	0.997526f,
+	0.068069f,
+	0.191598f,
+	0.97051f,
+	0.146287f,
+	0.0888492f,
+	0.992747f,
+	0.0809944f,
+	0.0509079f,
+	0.989914f,
+	0.132209f,
+	0.0413152f,
+	0.988953f,
+	0.142354f,
+	-0.00590782f,
+	0.97647f,
+	0.215574f,
+	-0.0327876f,
+	0.94937f,
+	0.312443f,
+	-0.0862721f,
+	0.978712f,
+	0.186225f,
+	-0.179337f,
+	0.981669f,
+	0.0645377f,
+	-0.255621f,
+	0.960924f,
+	0.106226f,
+	-0.157413f,
+	0.981394f,
+	0.109943f,
+	-0.0325878f,
+	0.996293f,
+	0.0796149f,
+	-0.0627116f,
+	0.997982f,
+	-0.00999288f,
+	-0.0263234f,
+	0.995733f,
+	-0.0884504f,
+	0.00359159f,
+	0.990572f,
+	-0.136946f,
+	-0.0963f,
+	0.991181f,
+	-0.0910356f,
+	-0.255814f,
+	0.966717f,
+	-0.00409974f,
+	-0.292954f,
+	0.950051f,
+	0.107618f,
+	-0.259513f,
+	0.946888f,
+	0.189886f,
+	-0.274998f,
+	0.934354f,
+	0.226623f,
+	-0.37248f,
+	0.885745f,
+	0.276974f,
+	-0.384203f,
+	0.849481f,
+	0.361622f,
+	-0.326853f,
+	0.86434f,
+	0.382208f,
+	-0.213332f,
+	0.922586f,
+	0.321442f,
+	-0.528611f,
+	0.848285f,
+	0.0313709f,
+	-0.466119f,
+	0.869006f,
+	0.166018f,
+	-0.226659f,
+	0.921685f,
+	0.314837f,
+	-0.225942f,
+	0.929604f,
+	0.291181f,
+	0.262979f,
+	0.943638f,
+	0.200972f,
+	-0.158823f,
+	0.970135f,
+	-0.183342f,
+	-0.433654f,
+	0.893597f,
+	-0.115884f,
+	0.0458639f,
+	0.99877f,
+	-0.0188405f,
+	0.612149f,
+	0.789064f,
+	0.0514904f,
+	0.423383f,
+	0.878106f,
+	-0.222881f,
+	0.0967751f,
+	0.930754f,
+	-0.352606f,
+	0.0811144f,
+	0.996202f,
+	0.0316668f,
+	-0.413686f,
+	0.895072f,
+	-0.166465f,
+	0.148131f,
+	0.951189f,
+	0.270735f,
+	0.436798f,
+	0.864787f,
+	0.247692f,
+	0.0437864f,
+	0.959427f,
+	0.278536f,
+	-0.28501f,
+	0.956226f,
+	0.0663364f,
+	0.510274f,
+	0.859616f,
+	0.0260981f,
+	0.648806f,
+	0.686419f,
+	-0.328451f,
+	0.586912f,
+	0.808674f,
+	0.0397475f,
+	-0.0852935f,
+	0.966768f,
+	0.241009f,
+	-0.148057f,
+	0.961052f,
+	0.233361f,
+	0.164136f,
+	0.983527f,
+	-0.0757203f,
+	0.450314f,
+	0.849987f,
+	-0.273386f,
+	0.550526f,
+	0.728504f,
+	-0.407679f,
+	0.58281f,
+	0.780161f,
+	-0.227338f,
+	0.258267f,
+	0.941325f,
+	-0.21727f,
+	0.0807909f,
+	0.98982f,
+	-0.117172f,
+	0.0801488f,
+	0.996327f,
+	0.0301511f,
+	0.239863f,
+	0.961671f,
+	0.132871f,
+	-0.229647f,
+	0.969202f,
+	0.0889415f,
+	-0.172859f,
+	0.981826f,
+	0.0783421f,
+	-0.0626565f,
+	0.996388f,
+	0.0573105f,
+	-0.0572909f,
+	0.992727f,
+	0.105883f,
+	-0.0279351f,
+	0.983375f,
+	0.179427f,
+	-0.00285096f,
+	0.99214f,
+	0.125102f,
+	-0.084025f,
+	0.99632f,
+	-0.0168937f,
+	-0.0732377f,
+	0.997041f,
+	-0.0233556f,
+	-0.0045065f,
+	0.999839f,
+	0.0173404f,
+	0.0203121f,
+	0.999722f,
+	0.0119547f,
+	-0.0506539f,
+	0.996487f,
+	-0.0666886f,
+	0.119651f,
+	0.992498f,
+	0.0251293f,
+	0.0686084f,
+	0.989615f,
+	0.126312f,
+	0.000108814f,
+	0.982339f,
+	0.187109f,
+	0.0874025f,
+	0.98865f,
+	0.122196f,
+	-0.0625717f,
+	0.997577f,
+	0.0304034f,
+	-0.0486926f,
+	0.992353f,
+	0.113426f,
+	0.0140738f,
+	0.989644f,
+	0.142855f,
+	-0.151919f,
+	0.980609f,
+	0.123804f,
+	-0.280176f,
+	0.959074f,
+	0.0409668f,
+	-0.112828f,
+	0.992642f,
+	-0.0439511f,
+	0.0530002f,
+	0.995827f,
+	-0.0742939f,
+	0.0297885f,
+	0.985001f,
+	-0.169959f,
+	0.0528437f,
+	0.970999f,
+	-0.233169f,
+	-0.0380639f,
+	0.977109f,
+	-0.209305f,
+	-0.249056f,
+	0.968138f,
+	-0.0260696f,
+	-0.370842f,
+	0.913812f,
+	0.165599f,
+	-0.310025f,
+	0.907402f,
+	0.283736f,
+	-0.313659f,
+	0.908343f,
+	0.276641f,
+	-0.360766f,
+	0.88042f,
+	0.307747f,
+	-0.383668f,
+	0.851108f,
+	0.358349f,
+	-0.392242f,
+	0.857478f,
+	0.332984f,
+	-0.296931f,
+	0.900087f,
+	0.318865f,
+	-0.199402f,
+	0.936164f,
+	0.289543f,
+	-0.412291f,
+	0.885214f,
+	0.215434f,
+	-0.62242f,
+	0.781068f,
+	-0.0502514f,
+	-0.272781f,
+	0.928261f,
+	0.252828f,
+	-0.317665f,
+	0.921151f,
+	0.224876f,
+	0.0813846f,
+	0.925309f,
+	0.370378f,
+	0.00278871f,
+	0.889899f,
+	0.45615f,
+	-0.460626f,
+	0.879338f,
+	0.120782f,
+	0.0601251f,
+	0.985077f,
+	0.161272f,
+	0.599887f,
+	0.787248f,
+	0.142742f,
+	0.617017f,
+	0.753279f,
+	0.227729f,
+	0.13665f,
+	0.981422f,
+	0.134675f,
+	0.136502f,
+	0.974756f,
+	0.176687f,
+	-0.27066f,
+	0.954113f,
+	-0.128105f,
+	-0.13295f,
+	0.980241f,
+	-0.146465f,
+	0.409773f,
+	0.909514f,
+	-0.0697851f,
+	0.339811f,
+	0.93455f,
+	0.10557f,
+	-0.243979f,
+	0.943604f,
+	-0.223798f,
+	0.572252f,
+	0.820076f,
+	0.00181093f,
+	0.58136f,
+	0.813444f,
+	0.0181706f,
+	0.213313f,
+	0.927464f,
+	0.307095f,
+	-0.0427767f,
+	0.853854f,
+	0.518751f,
+	0.0717407f,
+	0.97577f,
+	0.206702f,
+	0.349298f,
+	0.936925f,
+	0.0127626f,
+	0.643074f,
+	0.765767f,
+	0.00757208f,
+	0.584117f,
+	0.763349f,
+	-0.275872f,
+	0.414478f,
+	0.906497f,
+	-0.0804466f,
+	0.213842f,
+	0.975055f,
+	-0.0594842f,
+	-0.00469446f,
+	0.990505f,
+	-0.137399f,
+	-0.0685672f,
+	0.992236f,
+	-0.103764f,
+	0.0844774f,
+	0.996384f,
+	-0.00904741f,
+	-0.320391f,
+	0.938064f,
+	0.131853f,
+	-0.173519f,
+	0.96335f,
+	0.204565f,
+	-0.0123366f,
+	0.973468f,
+	0.228492f,
+	-0.018009f,
+	0.983892f,
+	0.177855f,
+	-0.10447f,
+	0.992257f,
+	0.0671745f,
+	0.0409931f,
+	0.988078f,
+	0.148399f,
+	0.0370075f,
+	0.994865f,
+	0.0941976f,
+	-0.0471895f,
+	0.997972f,
+	-0.0427132f,
+	-0.0371271f,
+	0.993135f,
+	-0.110921f,
+	0.0109117f,
+	0.996203f,
+	-0.0863686f,
+	0.0455917f,
+	0.995961f,
+	-0.0773449f,
+	-0.0321894f,
+	0.986545f,
+	-0.160288f,
+	-0.0649603f,
+	0.996397f,
+	0.0545189f,
+	0.00369488f,
+	0.985567f,
+	0.169244f,
+	0.226168f,
+	0.962189f,
+	0.151787f,
+	0.029392f,
+	0.999567f,
+	0.00117257f,
+	-0.13579f,
+	0.984206f,
+	-0.113581f,
+	-0.10103f,
+	0.992288f,
+	-0.0718192f,
+	-0.125171f,
+	0.991084f,
+	0.0456533f,
+	-0.108309f,
+	0.993989f,
+	0.015999f,
+	-0.0231464f,
+	0.995269f,
+	-0.0943563f,
+	0.0270486f,
+	0.99325f,
+	-0.112795f,
+	0.141677f,
+	0.989359f,
+	-0.0331051f,
+	0.0268575f,
+	0.994547f,
+	-0.100767f,
+	-0.194101f,
+	0.980932f,
+	0.009818f,
+	-0.41139f,
+	0.899763f,
+	0.145547f,
+	-0.482013f,
+	0.8562f,
+	0.185973f,
+	-0.415606f,
+	0.872343f,
+	0.257468f,
+	-0.291757f,
+	0.884021f,
+	0.365218f,
+	-0.316561f,
+	0.886381f,
+	0.337814f,
+	-0.406f,
+	0.884827f,
+	0.22857f,
+	-0.363525f,
+	0.905831f,
+	0.217534f,
+	-0.301242f,
+	0.93366f,
+	0.193734f,
+	-0.208193f,
+	0.941974f,
+	0.263325f,
+	-0.164184f,
+	0.932027f,
+	0.323063f,
+	-0.4694f,
+	0.88027f,
+	-0.0691917f,
+	-0.525104f,
+	0.840943f,
+	-0.130688f,
+	-0.256903f,
+	0.950739f,
+	0.17348f,
+	-0.180022f,
+	0.968548f,
+	0.171775f,
+	0.0734506f,
+	0.860739f,
+	0.50372f,
+	-0.205317f,
+	0.895889f,
+	0.393991f,
+	0.0472127f,
+	0.984089f,
+	0.171289f,
+	0.492639f,
+	0.869295f,
+	-0.040419f,
+	0.615313f,
+	0.776504f,
+	0.135761f,
+	0.240143f,
+	0.940103f,
+	0.241946f,
+	0.0961855f,
+	0.982412f,
+	0.160044f,
+	0.107308f,
+	0.976554f,
+	0.186622f,
+	-0.0192621f,
+	0.988216f,
+	-0.151846f,
+	0.243819f,
+	0.934285f,
+	-0.260122f,
+	0.363158f,
+	0.92047f,
+	-0.144401f,
+	-0.0181857f,
+	0.911833f,
+	-0.410158f,
+	0.13216f,
+	0.935755f,
+	-0.326948f,
+	0.234069f,
+	0.876493f,
+	0.42068f,
+	-0.0429998f,
+	0.864233f,
+	0.501251f,
+	0.30178f,
+	0.838678f,
+	0.453374f,
+	0.334916f,
+	0.905993f,
+	0.258858f,
+	0.486799f,
+	0.865003f,
+	0.121641f,
+	0.551114f,
+	0.813232f,
+	-0.186886f,
+	0.639118f,
+	0.75121f,
+	0.164956f,
+	0.383938f,
+	0.890692f,
+	0.243432f,
+	0.354878f,
+	0.921145f,
+	0.159855f,
+	0.162961f,
+	0.98584f,
+	-0.0395363f,
+	-0.0637937f,
+	0.974986f,
+	-0.212914f,
+	-0.0365262f,
+	0.968846f,
+	-0.244954f,
+	-0.281965f,
+	0.951785f,
+	0.120834f,
+	-0.274882f,
+	0.955225f,
+	0.109473f,
+	-0.104135f,
+	0.948711f,
+	0.298502f,
+	0.0826411f,
+	0.912269f,
+	0.401168f,
+	0.0342531f,
+	0.97031f,
+	0.239425f,
+	-0.0365634f,
+	0.991589f,
+	0.124154f,
+	0.134024f,
+	0.975461f,
+	0.174679f,
+	0.109589f,
+	0.99345f,
+	0.032348f,
+	0.0453955f,
+	0.994687f,
+	-0.0923934f,
+	-0.0149079f,
+	0.988982f,
+	-0.147281f,
+	0.0512217f,
+	0.992549f,
+	-0.110554f,
+	0.0167819f,
+	0.988638f,
+	-0.149377f,
+	-0.222271f,
+	0.949144f,
+	-0.222982f,
+	-0.0921327f,
+	0.987637f,
+	-0.126823f,
+	0.189567f,
+	0.98184f,
+	-0.00744372f,
+	0.205171f,
+	0.976356f,
+	0.0680753f,
+	-0.00982996f,
+	0.993812f,
+	-0.110639f,
+	-0.0883427f,
+	0.978311f,
+	-0.18736f,
+	-0.198236f,
+	0.955921f,
+	-0.216604f,
+	-0.180283f,
+	0.972159f,
+	-0.149685f,
+	0.0029493f,
+	0.99947f,
+	-0.0324137f,
+	-0.0433514f,
+	0.998534f,
+	-0.0324142f,
+	0.0405175f,
+	0.99421f,
+	0.0995223f,
+	0.00286263f,
+	0.981263f,
+	0.19265f,
+	-0.296663f,
+	0.921382f,
+	0.251091f,
+	-0.412123f,
+	0.867858f,
+	0.277446f,
+	-0.439996f,
+	0.871969f,
+	0.214648f,
+	-0.457669f,
+	0.875232f,
+	0.156552f,
+	-0.384822f,
+	0.899193f,
+	0.208242f,
+	-0.276213f,
+	0.916653f,
+	0.288882f,
+	-0.314226f,
+	0.91283f,
+	0.260774f,
+	-0.345662f,
+	0.91535f,
+	0.206522f,
+	-0.311859f,
+	0.934366f,
+	0.17235f,
+	-0.323293f,
+	0.931681f,
+	0.165688f,
+	-0.218081f,
+	0.943645f,
+	0.248946f,
+	0.00414662f,
+	0.967721f,
+	0.251991f,
+	-0.350612f,
+	0.910773f,
+	-0.218092f,
+	-0.590427f,
+	0.768592f,
+	-0.246296f,
+	-0.263693f,
+	0.937904f,
+	0.225393f,
+	-0.149885f,
+	0.945975f,
+	0.287518f,
+	-0.0723712f,
+	0.947676f,
+	0.310922f,
+	0.303995f,
+	0.902765f,
+	0.304306f,
+	0.615729f,
+	0.768916f,
+	0.172179f,
+	0.376573f,
+	0.870472f,
+	0.316971f,
+	0.258103f,
+	0.862435f,
+	0.435417f,
+	0.208037f,
+	0.965523f,
+	0.156476f,
+	0.041711f,
+	0.997309f,
+	0.0602974f,
+	0.0896451f,
+	0.984172f,
+	0.152868f,
+	0.200861f,
+	0.950569f,
+	0.236798f,
+	0.331115f,
+	0.861074f,
+	0.385894f,
+	0.343908f,
+	0.839357f,
+	0.420961f,
+	-0.162885f,
+	0.985003f,
+	0.0568977f,
+	-0.0608521f,
+	0.991774f,
+	0.112611f,
+	0.279417f,
+	0.937386f,
+	0.207929f,
+	0.438178f,
+	0.898268f,
+	0.033396f,
+	0.516016f,
+	0.854846f,
+	-0.0544561f,
+	0.550254f,
+	0.781096f,
+	-0.295143f,
+	0.499018f,
+	0.830127f,
+	-0.248738f,
+	0.421585f,
+	0.905472f,
+	0.0488414f,
+	0.355515f,
+	0.918443f,
+	0.173411f,
+	0.416018f,
+	0.882036f,
+	0.221226f,
+	0.346021f,
+	0.922667f,
+	0.170161f,
+	0.0862406f,
+	0.994799f,
+	-0.0542001f,
+	0.0251294f,
+	0.989963f,
+	-0.139071f,
+	-0.167311f,
+	0.982002f,
+	0.0876306f,
+	-0.296088f,
+	0.953872f,
+	0.0496014f,
+	-0.309819f,
+	0.944071f,
+	0.112878f,
+	0.0107419f,
+	0.974593f,
+	0.223724f,
+	0.235566f,
+	0.938548f,
+	0.252263f,
+	0.0528759f,
+	0.995406f,
+	0.0798236f,
+	0.106055f,
+	0.992977f,
+	0.0524375f,
+	0.227694f,
+	0.967451f,
+	0.110427f,
+	0.15013f,
+	0.988604f,
+	0.0110517f,
+	0.0292872f,
+	0.989448f,
+	-0.141897f,
+	0.0113647f,
+	0.978518f,
+	-0.205848f,
+	0.0966514f,
+	0.981912f,
+	-0.162811f,
+	-0.0834695f,
+	0.969158f,
+	-0.231875f,
+	-0.173766f,
+	0.92349f,
+	-0.34201f,
+	0.0289323f,
+	0.967596f,
+	-0.250839f,
+	0.166759f,
+	0.980973f,
+	-0.0994165f,
+	0.0796755f,
+	0.992423f,
+	-0.0935347f,
+	-0.0109031f,
+	0.993494f,
+	-0.113363f,
+	-0.181202f,
+	0.957527f,
+	-0.224295f,
+	-0.231371f,
+	0.948894f,
+	-0.214636f,
+	-0.0963906f,
+	0.978232f,
+	-0.183771f,
+	-0.0964169f,
+	0.992283f,
+	-0.0779687f,
+	-0.114591f,
+	0.992373f,
+	0.045429f,
+	-0.0476997f,
+	0.984744f,
+	0.167343f,
+	-0.353531f,
+	0.929974f,
+	0.100818f,
+	-0.42903f,
+	0.892447f,
+	0.139543f,
+	-0.399459f,
+	0.902474f,
+	0.161164f,
+	-0.44275f,
+	0.883954f,
+	0.150326f,
+	-0.416721f,
+	0.891582f,
+	0.177271f,
+	-0.364313f,
+	0.907101f,
+	0.210818f,
+	-0.329954f,
+	0.890729f,
+	0.312622f,
+	-0.308128f,
+	0.891277f,
+	0.33269f,
+	-0.248313f,
+	0.912421f,
+	0.325314f,
+	-0.264673f,
+	0.92449f,
+	0.274348f,
+	-0.221501f,
+	0.958108f,
+	0.181568f,
+	-0.00722143f,
+	0.985032f,
+	0.17222f,
+	0.0811419f,
+	0.973825f,
+	0.212324f,
+	-0.519461f,
+	0.82914f,
+	-0.206608f,
+	-0.561212f,
+	0.816969f,
+	-0.132674f,
+	-0.10198f,
+	0.978452f,
+	0.179533f,
+	-0.0294922f,
+	0.994047f,
+	0.104885f,
+	0.212965f,
+	0.975972f,
+	0.0461033f,
+	0.39072f,
+	0.902699f,
+	0.180202f,
+	0.284816f,
+	0.877828f,
+	0.385096f,
+	0.371584f,
+	0.726424f,
+	0.578129f,
+	0.415725f,
+	0.734903f,
+	0.535809f,
+	0.0647658f,
+	0.913533f,
+	0.401575f,
+	0.0316961f,
+	0.895539f,
+	0.443852f,
+	-0.0215836f,
+	0.930013f,
+	0.366891f,
+	0.0389377f,
+	0.900411f,
+	0.433293f,
+	0.182398f,
+	0.888094f,
+	0.421923f,
+	0.319795f,
+	0.864372f,
+	0.388061f,
+	0.179682f,
+	0.983355f,
+	0.0269752f,
+	0.358016f,
+	0.913314f,
+	-0.19412f,
+	0.445422f,
+	0.82688f,
+	-0.343321f,
+	0.564533f,
+	0.736553f,
+	-0.372547f,
+	0.511683f,
+	0.792162f,
+	-0.332656f,
+	0.362215f,
+	0.931906f,
+	0.0187495f,
+	0.332114f,
+	0.925718f,
+	0.180958f,
+	0.376936f,
+	0.924108f,
+	0.0628019f,
+	0.34207f,
+	0.939661f,
+	0.00505146f,
+	0.432513f,
+	0.89733f,
+	0.0879243f,
+	0.250624f,
+	0.96783f,
+	0.022189f,
+	0.113333f,
+	0.993448f,
+	0.0146943f,
+	-0.330108f,
+	0.943938f,
+	0.00323688f,
+	-0.32108f,
+	0.944743f,
+	0.0660874f,
+	-0.312445f,
+	0.949733f,
+	0.0196284f,
+	-0.0425447f,
+	0.998988f,
+	-0.0145795f,
+	0.234895f,
+	0.971633f,
+	0.0274452f,
+	0.205978f,
+	0.978297f,
+	0.0225396f,
+	0.0556133f,
+	0.99289f,
+	-0.10525f,
+	0.149272f,
+	0.988455f,
+	-0.0259672f,
+	0.25486f,
+	0.966188f,
+	0.0390683f,
+	0.206371f,
+	0.977859f,
+	-0.0346908f,
+	0.0798975f,
+	0.983688f,
+	-0.161166f,
+	0.0387149f,
+	0.980238f,
+	-0.193996f,
+	-0.0261652f,
+	0.985317f,
+	-0.168719f,
+	-0.115457f,
+	0.963019f,
+	-0.243441f,
+	-0.0914394f,
+	0.962229f,
+	-0.256427f,
+	0.0382488f,
+	0.992063f,
+	-0.119784f,
+	0.0800161f,
+	0.996698f,
+	-0.0137989f,
+	0.0187475f,
+	0.998138f,
+	-0.0580508f,
+	-0.073595f,
+	0.994051f,
+	-0.0802936f,
+	-0.224165f,
+	0.957926f,
+	-0.179241f,
+	-0.16346f,
+	0.967941f,
+	-0.190711f,
+	-0.19173f,
+	0.978244f,
+	-0.0792358f,
+	-0.275576f,
+	0.961029f,
+	-0.0219235f,
+	-0.0407932f,
+	0.98802f,
+	0.148838f,
+	-0.278629f,
+	0.956556f,
+	0.085827f,
+	-0.465684f,
+	0.878931f,
+	0.103047f,
+	-0.438529f,
+	0.89146f,
+	0.11398f,
+	-0.455089f,
+	0.880964f,
+	0.129601f,
+	-0.457802f,
+	0.879895f,
+	0.127287f,
+	-0.406331f,
+	0.89051f,
+	0.204664f,
+	-0.386395f,
+	0.891456f,
+	0.236654f,
+	-0.321818f,
+	0.921226f,
+	0.218577f,
+	-0.271011f,
+	0.935727f,
+	0.22576f,
+	-0.198383f,
+	0.944022f,
+	0.263564f,
+	-0.105727f,
+	0.975806f,
+	0.191373f,
+	-0.0832756f,
+	0.987941f,
+	0.130528f,
+	0.0931562f,
+	0.956641f,
+	0.27597f,
+	-0.216408f,
+	0.96162f,
+	0.168686f,
+	-0.648586f,
+	0.688743f,
+	-0.323988f,
+	-0.276841f,
+	0.843915f,
+	-0.459527f,
+	-0.060911f,
+	0.935148f,
+	-0.348981f,
+	0.243821f,
+	0.963831f,
+	-0.107611f,
+	0.35478f,
+	0.93349f,
+	-0.0522288f,
+	0.124674f,
+	0.987025f,
+	-0.101179f,
+	0.106145f,
+	0.993646f,
+	0.0374371f,
+	0.264307f,
+	0.911176f,
+	0.316069f,
+	0.180037f,
+	0.821936f,
+	0.540378f,
+	0.0976487f,
+	0.839888f,
+	0.533903f,
+	0.242869f,
+	0.82432f,
+	0.511381f,
+	0.296956f,
+	0.900742f,
+	0.316987f,
+	0.37446f,
+	0.92343f,
+	0.0840066f,
+	0.38614f,
+	0.913414f,
+	-0.128727f,
+	0.497691f,
+	0.838063f,
+	-0.223505f,
+	0.399217f,
+	0.778523f,
+	-0.484281f,
+	0.607215f,
+	0.684189f,
+	-0.403949f,
+	0.455879f,
+	0.835157f,
+	-0.307715f,
+	0.317815f,
+	0.943806f,
+	-0.0906903f,
+	0.166917f,
+	0.983806f,
+	0.0653043f,
+	0.277188f,
+	0.953387f,
+	0.119249f,
+	0.491287f,
+	0.85011f,
+	0.189606f,
+	0.3858f,
+	0.919271f,
+	0.0780984f,
+	0.390109f,
+	0.91635f,
+	0.0900968f,
+	0.247947f,
+	0.964668f,
+	0.0890966f,
+	0.0188396f,
+	0.999506f,
+	0.0251451f,
+	-0.249227f,
+	0.949063f,
+	0.192782f,
+	-0.24873f,
+	0.963608f,
+	0.0979465f,
+	-0.225537f,
+	0.968208f,
+	-0.108193f,
+	-0.0586638f,
+	0.984304f,
+	-0.166448f,
+	0.193919f,
+	0.980395f,
+	-0.0349386f,
+	0.232927f,
+	0.972341f,
+	0.0172453f,
+	0.165218f,
+	0.985248f,
+	-0.0445953f,
+	0.10666f,
+	0.982482f,
+	-0.152814f,
+	0.176402f,
+	0.976328f,
+	-0.125164f,
+	0.217875f,
+	0.975941f,
+	-0.00837002f,
+	0.138055f,
+	0.990338f,
+	0.0130638f,
+	0.0914598f,
+	0.995289f,
+	-0.0321788f,
+	-0.014672f,
+	0.992233f,
+	-0.123523f,
+	-0.0701479f,
+	0.990985f,
+	-0.114142f,
+	-0.0940689f,
+	0.987781f,
+	-0.124254f,
+	-0.152176f,
+	0.977744f,
+	-0.144426f,
+	0.043676f,
+	0.996991f,
+	0.0640382f,
+	0.0457416f,
+	0.996307f,
+	0.07266f,
+	-0.0198973f,
+	0.997072f,
+	0.0738311f,
+	-0.119455f,
+	0.990174f,
+	-0.0727032f,
+	-0.224875f,
+	0.962572f,
+	-0.151282f,
+	-0.250045f,
+	0.966903f,
+	-0.0507448f,
+	-0.319974f,
+	0.944248f,
+	-0.0775328f,
+	-0.16005f,
+	0.987102f,
+	-0.00365841f,
+	-0.307005f,
+	0.947659f,
+	0.0876954f,
+	-0.490256f,
+	0.846833f,
+	0.206209f,
+	-0.400386f,
+	0.879926f,
+	0.255778f,
+	-0.427515f,
+	0.880624f,
+	0.204282f,
+	-0.477897f,
+	0.856347f,
+	0.195663f,
+	-0.43217f,
+	0.864768f,
+	0.255745f,
+	-0.342474f,
+	0.92438f,
+	0.16803f,
+	-0.284468f,
+	0.956998f,
+	0.0568588f,
+	-0.290121f,
+	0.956708f,
+	0.023234f,
+	-0.249156f,
+	0.966838f,
+	0.0560771f,
+	-0.0655515f,
+	0.986836f,
+	0.147842f,
+	-0.100568f,
+	0.984251f,
+	0.145384f,
+	-0.0191778f,
+	0.985445f,
+	0.168911f,
+	-0.0443403f,
+	0.97787f,
+	0.204462f,
+	-0.28653f,
+	0.957033f,
+	-0.044587f,
+	-0.127864f,
+	0.901634f,
+	-0.413166f,
+	-0.0930849f,
+	0.861283f,
+	-0.499526f,
+	-0.10032f,
+	0.791759f,
+	-0.60254f,
+	0.277857f,
+	0.863349f,
+	-0.421218f,
+	0.0733471f,
+	0.944573f,
+	-0.320003f,
+	0.0656198f,
+	0.995434f,
+	-0.0693225f,
+	0.0994234f,
+	0.993172f,
+	-0.0610351f,
+	0.0758799f,
+	0.991718f,
+	0.103618f,
+	0.0755546f,
+	0.978148f,
+	0.193698f,
+	0.318521f,
+	0.931105f,
+	0.177731f,
+	0.532035f,
+	0.846717f,
+	0.00302226f,
+	0.479952f,
+	0.801468f,
+	-0.356785f,
+	0.444207f,
+	0.753204f,
+	-0.485143f,
+	0.599635f,
+	0.661874f,
+	-0.449845f,
+	0.467802f,
+	0.782561f,
+	-0.410805f,
+	0.194572f,
+	0.899472f,
+	-0.391269f,
+	0.334078f,
+	0.938895f,
+	-0.0828733f,
+	0.236858f,
+	0.971355f,
+	0.0191963f,
+	0.177255f,
+	0.983392f,
+	0.0389945f,
+	0.22691f,
+	0.973661f,
+	-0.0222777f,
+	0.408661f,
+	0.912593f,
+	0.013075f,
+	0.394434f,
+	0.908333f,
+	0.139114f,
+	0.34039f,
+	0.913901f,
+	0.221176f,
+	0.340162f,
+	0.904445f,
+	0.257428f,
+	0.21637f,
+	0.954077f,
+	0.207173f,
+	-0.190356f,
+	0.960699f,
+	0.202044f,
+	-0.0745122f,
+	0.978557f,
+	0.192026f,
+	-0.0103556f,
+	0.997337f,
+	0.0721953f,
+	-0.102208f,
+	0.994222f,
+	-0.0328074f,
+	0.0538732f,
+	0.998534f,
+	0.00527007f,
+	0.220064f,
+	0.97523f,
+	-0.0223306f,
+	0.22889f,
+	0.972208f,
+	-0.0492086f,
+	0.203387f,
+	0.976813f,
+	-0.0668524f,
+	0.112155f,
+	0.987122f,
+	-0.114071f,
+	0.137033f,
+	0.989998f,
+	-0.0335468f,
+	0.125928f,
+	0.990544f,
+	-0.0544465f,
+	0.164164f,
+	0.983484f,
+	-0.0762248f,
+	0.056178f,
+	0.987899f,
+	-0.14457f,
+	-0.125491f,
+	0.977887f,
+	-0.167299f,
+	-0.0763702f,
+	0.993552f,
+	-0.0837951f,
+	-0.140516f,
+	0.986451f,
+	-0.0846751f,
+	-0.138825f,
+	0.988035f,
+	-0.0671838f,
+	0.0272382f,
+	0.998662f,
+	0.0439583f,
+	0.051406f,
+	0.998673f,
+	0.00322772f,
+	0.0131796f,
+	0.996364f,
+	-0.0841692f,
+	-0.197723f,
+	0.973335f,
+	-0.116299f,
+	-0.315939f,
+	0.94482f,
+	-0.0865842f,
+	-0.273936f,
+	0.961179f,
+	-0.0330844f,
+	-0.278588f,
+	0.957771f,
+	-0.0711653f,
+	-0.371629f,
+	0.922753f,
+	0.102078f,
+	-0.589295f,
+	0.797687f,
+	0.128167f,
+	-0.394808f,
+	0.893641f,
+	0.213383f,
+	-0.419749f,
+	0.89327f,
+	0.160869f,
+	-0.503386f,
+	0.848953f,
+	0.160878f,
+	-0.392151f,
+	0.910681f,
+	0.129912f,
+	-0.194389f,
+	0.97789f,
+	0.0771005f,
+	-0.210697f,
+	0.97754f,
+	0.00473511f,
+	-0.261758f,
+	0.965059f,
+	0.0120029f,
+	-0.306606f,
+	0.951531f,
+	-0.0240962f,
+	-0.191391f,
+	0.98062f,
+	0.0418887f,
+	-0.0805366f,
+	0.9875f,
+	0.135492f,
+	-0.0197042f,
+	0.996843f,
+	0.0769187f,
+	-0.0102082f,
+	0.996001f,
+	0.0887568f,
+	-0.106967f,
+	0.993499f,
+	0.0389638f,
+	-0.0299932f,
+	0.997488f,
+	-0.0641764f,
+	0.166392f,
+	0.98551f,
+	-0.0329295f,
+	0.122834f,
+	0.919366f,
+	-0.373736f,
+	0.0989442f,
+	0.860803f,
+	-0.499228f,
+	-0.16483f,
+	0.786842f,
+	-0.594736f,
+	-0.139994f,
+	0.854441f,
+	-0.500331f,
+	0.037386f,
+	0.884593f,
+	-0.464864f,
+	-0.0340706f,
+	0.910599f,
+	-0.411885f,
+	0.0643546f,
+	0.934103f,
+	-0.351155f,
+	0.330549f,
+	0.864687f,
+	-0.378225f,
+	0.61879f,
+	0.706641f,
+	-0.343158f,
+	0.664468f,
+	0.668218f,
+	-0.334614f,
+	0.535603f,
+	0.737564f,
+	-0.411252f,
+	0.392926f,
+	0.807647f,
+	-0.439677f,
+	0.299634f,
+	0.936543f,
+	-0.181953f,
+	0.20385f,
+	0.978529f,
+	-0.030423f,
+	0.255219f,
+	0.962099f,
+	-0.0960637f,
+	0.218057f,
+	0.97044f,
+	-0.103423f,
+	0.152183f,
+	0.981776f,
+	-0.113823f,
+	0.287579f,
+	0.953452f,
+	-0.0907011f,
+	0.354102f,
+	0.933846f,
+	-0.0504376f,
+	0.271766f,
+	0.955964f,
+	0.110796f,
+	0.254566f,
+	0.942907f,
+	0.214762f,
+	0.330431f,
+	0.909031f,
+	0.253925f,
+	0.276649f,
+	0.934017f,
+	0.226003f,
+	-0.276078f,
+	0.960525f,
+	0.0342386f,
+	-0.126608f,
+	0.988039f,
+	0.088024f,
+	-0.0433883f,
+	0.982429f,
+	0.181523f,
+	-0.0351658f,
+	0.95918f,
+	0.280603f,
+	0.130316f,
+	0.978179f,
+	0.161815f,
+	0.34012f,
+	0.939563f,
+	0.0392436f,
+	0.225269f,
+	0.971719f,
+	-0.0708295f,
+	0.186144f,
+	0.981343f,
+	-0.0481244f,
+	0.117145f,
+	0.991402f,
+	-0.0582961f,
+	0.122374f,
+	0.988553f,
+	-0.0882497f,
+	0.217284f,
+	0.968092f,
+	-0.124844f,
+	0.168939f,
+	0.967628f,
+	-0.1875f,
+	0.0966952f,
+	0.983818f,
+	-0.150838f,
+	-0.108071f,
+	0.971789f,
+	-0.209635f,
+	-0.167419f,
+	0.956466f,
+	-0.239047f,
+	-0.15925f,
+	0.972646f,
+	-0.169115f,
+	-0.169755f,
+	0.972705f,
+	-0.158205f,
+	0.0352685f,
+	0.991682f,
+	-0.123784f,
+	0.0984439f,
+	0.980655f,
+	-0.169186f,
+	0.0318934f,
+	0.989724f,
+	-0.139387f,
+	-0.246309f,
+	0.963763f,
+	-0.102435f,
+	-0.355567f,
+	0.934631f,
+	-0.00599911f,
+	-0.265814f,
+	0.963735f,
+	-0.0236194f,
+	-0.351588f,
+	0.935043f,
+	-0.0456126f,
+	-0.494494f,
+	0.858936f,
+	0.133056f,
+	-0.559402f,
+	0.824266f,
+	0.0874941f,
+	-0.405326f,
+	0.914016f,
+	0.0169127f,
+	-0.376559f,
+	0.926338f,
+	0.010028f,
+	-0.448864f,
+	0.890609f,
+	-0.0730511f,
+	-0.3487f,
+	0.913403f,
+	-0.210007f,
+	-0.225518f,
+	0.948441f,
+	-0.222713f,
+	-0.278172f,
+	0.957801f,
+	-0.0723737f,
+	-0.296428f,
+	0.947861f,
+	0.117f,
+	-0.260326f,
+	0.954501f,
+	0.14546f,
+	-0.208806f,
+	0.976306f,
+	0.0568064f,
+	-0.0937503f,
+	0.995595f,
+	-0.00141652f,
+	0.0211825f,
+	0.998587f,
+	-0.0487327f,
+	-0.0203898f,
+	0.998016f,
+	-0.0595622f,
+	-0.117256f,
+	0.992273f,
+	-0.0405676f,
+	0.0346735f,
+	0.999272f,
+	0.0158994f,
+	0.165596f,
+	0.985653f,
+	-0.0326431f,
+	0.277068f,
+	0.959929f,
+	-0.0420538f,
+	0.211278f,
+	0.971116f,
+	-0.110882f,
+	0.138826f,
+	0.972226f,
+	-0.188423f,
+	0.0186164f,
+	0.920791f,
+	-0.389612f,
+	0.00693313f,
+	0.891348f,
+	-0.453267f,
+	-0.0471378f,
+	0.869656f,
+	-0.491403f,
+	0.135484f,
+	0.84445f,
+	-0.518217f,
+	0.351566f,
+	0.784405f,
+	-0.510988f,
+	0.399468f,
+	0.772299f,
+	-0.493943f,
+	0.574953f,
+	0.790421f,
+	-0.211338f,
+	0.577809f,
+	0.813449f,
+	-0.0666111f,
+	0.451377f,
+	0.892327f,
+	0.00336233f,
+	0.237932f,
+	0.970883f,
+	-0.0278435f,
+	0.170635f,
+	0.975266f,
+	-0.140498f,
+	0.305065f,
+	0.94416f,
+	-0.124487f,
+	0.219111f,
+	0.958291f,
+	-0.183492f,
+	0.160317f,
+	0.981326f,
+	-0.106286f,
+	0.222178f,
+	0.974771f,
+	-0.021419f,
+	0.23168f,
+	0.971792f,
+	0.0441002f,
+	0.140177f,
+	0.984507f,
+	0.105338f,
+	0.184383f,
+	0.966339f,
+	0.179422f,
+	0.307531f,
+	0.911743f,
+	0.272303f,
+	0.342083f,
+	0.879118f,
+	0.331859f,
+	-0.245266f,
+	0.968917f,
+	0.0323163f,
+	-0.176433f,
+	0.984311f,
+	-0.00156667f,
+	-0.164847f,
+	0.983548f,
+	0.0738887f,
+	-0.0271087f,
+	0.959686f,
+	0.279762f,
+	0.210185f,
+	0.960158f,
+	0.18417f,
+	0.386525f,
+	0.917795f,
+	0.0908302f,
+	0.288585f,
+	0.956426f,
+	0.04436f,
+	0.157424f,
+	0.986731f,
+	-0.0397454f,
+	0.194229f,
+	0.980956f,
+	0.000793421f,
+	0.143953f,
+	0.978f,
+	-0.150974f,
+	0.243865f,
+	0.955091f,
+	-0.168319f,
+	0.151307f,
+	0.968911f,
+	-0.195749f,
+	0.0861511f,
+	0.987302f,
+	-0.133462f,
+	-0.0343302f,
+	0.988258f,
+	-0.148887f,
+	-0.149683f,
+	0.954065f,
+	-0.259529f,
+	-0.180054f,
+	0.943807f,
+	-0.277143f,
+	-0.182632f,
+	0.946912f,
+	-0.26458f,
+	0.0250152f,
+	0.97257f,
+	-0.23126f,
+	0.0655433f,
+	0.96826f,
+	-0.241197f,
+	0.00940225f,
+	0.990707f,
+	-0.135685f,
+	-0.313822f,
+	0.94168f,
+	-0.121471f,
+	-0.325919f,
+	0.940955f,
+	0.0915474f,
+	-0.245857f,
+	0.968763f,
+	-0.0324418f,
+	-0.38384f,
+	0.920444f,
+	-0.0738245f,
+	-0.542624f,
+	0.834584f,
+	0.0950211f,
+	-0.496894f,
+	0.865347f,
+	0.0653522f,
+	-0.40471f,
+	0.910862f,
+	-0.0808731f,
+	-0.336326f,
+	0.940002f,
+	-0.0572751f,
+	-0.384947f,
+	0.90765f,
+	-0.167296f,
+	-0.26052f,
+	0.919475f,
+	-0.294439f,
+	-0.278076f,
+	0.879766f,
+	-0.385599f,
+	-0.415096f,
+	0.880667f,
+	-0.2283f,
+	-0.411169f,
+	0.907675f,
+	0.0840562f,
+	-0.22106f,
+	0.940981f,
+	0.256296f,
+	-0.105371f,
+	0.978797f,
+	0.175653f,
+	-0.0100537f,
+	0.999811f,
+	0.0166273f,
+	0.0459065f,
+	0.991326f,
+	-0.123151f,
+	-0.0151969f,
+	0.991011f,
+	-0.132912f,
+	-0.164041f,
+	0.976761f,
+	-0.137947f,
+	0.00793599f,
+	0.998771f,
+	-0.0489272f,
+	0.178958f,
+	0.98335f,
+	-0.031577f,
+	0.314466f,
+	0.949045f,
+	-0.0206086f,
+	0.240757f,
+	0.963062f,
+	-0.120617f,
+	0.126531f,
+	0.982046f,
+	-0.139911f,
+	0.0695074f,
+	0.9956f,
+	-0.062839f,
+	0.0427419f,
+	0.998852f,
+	-0.02164f,
+	-0.0292495f,
+	0.993565f,
+	-0.109419f,
+	0.176081f,
+	0.974549f,
+	-0.138744f,
+	0.405406f,
+	0.900659f,
+	-0.156393f,
+	0.48202f,
+	0.865956f,
+	-0.133334f,
+	0.477566f,
+	0.852664f,
+	-0.211881f,
+	0.526274f,
+	0.839922f,
+	-0.132537f,
+	0.390331f,
+	0.920621f,
+	-0.0098857f,
+	0.349443f,
+	0.931118f,
+	0.104442f,
+	0.205374f,
+	0.96487f,
+	-0.163851f,
+	0.359411f,
+	0.921384f,
+	-0.147904f,
+	0.161592f,
+	0.938137f,
+	-0.306246f,
+	0.0124614f,
+	0.982178f,
+	-0.187542f,
+	0.143914f,
+	0.986786f,
+	0.0744463f,
+	0.270333f,
+	0.949018f,
+	0.162126f,
+	0.132f,
+	0.991194f,
+	0.0105184f,
+	0.131712f,
+	0.991267f,
+	0.00644011f,
+	0.199003f,
+	0.974024f,
+	0.108048f,
+	0.274163f,
+	0.928953f,
+	0.248757f,
+};
+
+btScalar Landscape01Tex[] = {
+	0.507813f,
+	0.0078125f,
+	0.507813f,
+	0.0f,
+	0.515625f,
+	0.0078125f,
+	0.515625f,
+	0.0f,
+	0.523438f,
+	0.0078125f,
+	0.523438f,
+	0.0f,
+	0.53125f,
+	0.0078125f,
+	0.53125f,
+	0.0f,
+	0.539063f,
+	0.0078125f,
+	0.539063f,
+	0.0f,
+	0.546875f,
+	0.0078125f,
+	0.546875f,
+	0.0f,
+	0.554688f,
+	0.0078125f,
+	0.554688f,
+	0.0f,
+	0.5625f,
+	0.0078125f,
+	0.5625f,
+	0.0f,
+	0.570313f,
+	0.0078125f,
+	0.570313f,
+	0.0f,
+	0.578125f,
+	0.0078125f,
+	0.578125f,
+	0.0f,
+	0.585938f,
+	0.0078125f,
+	0.585938f,
+	0.0f,
+	0.59375f,
+	0.0078125f,
+	0.59375f,
+	0.0f,
+	0.601563f,
+	0.0078125f,
+	0.601563f,
+	0.0f,
+	0.609375f,
+	0.0078125f,
+	0.609375f,
+	0.0f,
+	0.617188f,
+	0.0078125f,
+	0.617188f,
+	0.0f,
+	0.625f,
+	0.0078125f,
+	0.625f,
+	0.0f,
+	0.632813f,
+	0.0078125f,
+	0.632813f,
+	0.0f,
+	0.640625f,
+	0.0078125f,
+	0.640625f,
+	0.0f,
+	0.648438f,
+	0.0078125f,
+	0.648438f,
+	0.0f,
+	0.65625f,
+	0.0078125f,
+	0.65625f,
+	0.0f,
+	0.664063f,
+	0.0078125f,
+	0.664063f,
+	0.0f,
+	0.671875f,
+	0.0078125f,
+	0.671875f,
+	0.0f,
+	0.679688f,
+	0.0078125f,
+	0.679688f,
+	0.0f,
+	0.6875f,
+	0.0078125f,
+	0.6875f,
+	0.0f,
+	0.695313f,
+	0.0078125f,
+	0.695313f,
+	0.0f,
+	0.703125f,
+	0.0078125f,
+	0.703125f,
+	0.0f,
+	0.710938f,
+	0.0078125f,
+	0.710938f,
+	0.0f,
+	0.71875f,
+	0.0078125f,
+	0.71875f,
+	0.0f,
+	0.726563f,
+	0.0078125f,
+	0.726563f,
+	0.0f,
+	0.734375f,
+	0.0078125f,
+	0.734375f,
+	0.0f,
+	0.742188f,
+	0.0078125f,
+	0.742188f,
+	0.0f,
+	0.75f,
+	0.0078125f,
+	0.75f,
+	0.0f,
+	0.757813f,
+	0.0078125f,
+	0.757813f,
+	0.0f,
+	0.765625f,
+	0.0078125f,
+	0.765625f,
+	0.0f,
+	0.773438f,
+	0.0078125f,
+	0.773438f,
+	0.0f,
+	0.78125f,
+	0.0078125f,
+	0.78125f,
+	0.0f,
+	0.789063f,
+	0.0078125f,
+	0.789063f,
+	0.0f,
+	0.796875f,
+	0.0078125f,
+	0.796875f,
+	0.0f,
+	0.804688f,
+	0.0078125f,
+	0.804688f,
+	0.0f,
+	0.8125f,
+	0.0078125f,
+	0.8125f,
+	0.0f,
+	0.820313f,
+	0.0078125f,
+	0.820313f,
+	0.0f,
+	0.828125f,
+	0.0078125f,
+	0.828125f,
+	0.0f,
+	0.835938f,
+	0.0078125f,
+	0.835938f,
+	0.0f,
+	0.84375f,
+	0.0078125f,
+	0.84375f,
+	0.0f,
+	0.851563f,
+	0.0078125f,
+	0.851563f,
+	0.0f,
+	0.859375f,
+	0.0078125f,
+	0.859375f,
+	0.0f,
+	0.867188f,
+	0.0078125f,
+	0.867188f,
+	0.0f,
+	0.875f,
+	0.0078125f,
+	0.875f,
+	0.0f,
+	0.882813f,
+	0.0078125f,
+	0.882813f,
+	0.0f,
+	0.890625f,
+	0.0078125f,
+	0.890625f,
+	0.0f,
+	0.898438f,
+	0.0078125f,
+	0.898438f,
+	0.0f,
+	0.90625f,
+	0.0078125f,
+	0.90625f,
+	0.0f,
+	0.914063f,
+	0.0078125f,
+	0.914063f,
+	0.0f,
+	0.921875f,
+	0.0078125f,
+	0.921875f,
+	0.0f,
+	0.929688f,
+	0.0078125f,
+	0.929688f,
+	0.0f,
+	0.9375f,
+	0.0078125f,
+	0.9375f,
+	0.0f,
+	0.945313f,
+	0.0078125f,
+	0.945313f,
+	0.0f,
+	0.953125f,
+	0.0078125f,
+	0.953125f,
+	0.0f,
+	0.960938f,
+	0.0078125f,
+	0.960938f,
+	0.0f,
+	0.96875f,
+	0.0078125f,
+	0.96875f,
+	0.0f,
+	0.976563f,
+	0.0078125f,
+	0.976563f,
+	0.0f,
+	0.984375f,
+	0.0078125f,
+	0.984375f,
+	0.0f,
+	0.992188f,
+	0.0078125f,
+	0.992188f,
+	0.0f,
+	1.0f,
+	0.0078125f,
+	1.0f,
+	0.0f,
+	0.507813f,
+	0.015625f,
+	0.515625f,
+	0.015625f,
+	0.523438f,
+	0.015625f,
+	0.53125f,
+	0.015625f,
+	0.539063f,
+	0.015625f,
+	0.546875f,
+	0.015625f,
+	0.554688f,
+	0.015625f,
+	0.5625f,
+	0.015625f,
+	0.570313f,
+	0.015625f,
+	0.578125f,
+	0.015625f,
+	0.585938f,
+	0.015625f,
+	0.59375f,
+	0.015625f,
+	0.601563f,
+	0.015625f,
+	0.609375f,
+	0.015625f,
+	0.617188f,
+	0.015625f,
+	0.625f,
+	0.015625f,
+	0.632813f,
+	0.015625f,
+	0.640625f,
+	0.015625f,
+	0.648438f,
+	0.015625f,
+	0.65625f,
+	0.015625f,
+	0.664063f,
+	0.015625f,
+	0.671875f,
+	0.015625f,
+	0.679688f,
+	0.015625f,
+	0.6875f,
+	0.015625f,
+	0.695313f,
+	0.015625f,
+	0.703125f,
+	0.015625f,
+	0.710938f,
+	0.015625f,
+	0.71875f,
+	0.015625f,
+	0.726563f,
+	0.015625f,
+	0.734375f,
+	0.015625f,
+	0.742188f,
+	0.015625f,
+	0.75f,
+	0.015625f,
+	0.757813f,
+	0.015625f,
+	0.765625f,
+	0.015625f,
+	0.773438f,
+	0.015625f,
+	0.78125f,
+	0.015625f,
+	0.789063f,
+	0.015625f,
+	0.796875f,
+	0.015625f,
+	0.804688f,
+	0.015625f,
+	0.8125f,
+	0.015625f,
+	0.820313f,
+	0.015625f,
+	0.828125f,
+	0.015625f,
+	0.835938f,
+	0.015625f,
+	0.84375f,
+	0.015625f,
+	0.851563f,
+	0.015625f,
+	0.859375f,
+	0.015625f,
+	0.867188f,
+	0.015625f,
+	0.875f,
+	0.015625f,
+	0.882813f,
+	0.015625f,
+	0.890625f,
+	0.015625f,
+	0.898438f,
+	0.015625f,
+	0.90625f,
+	0.015625f,
+	0.914063f,
+	0.015625f,
+	0.921875f,
+	0.015625f,
+	0.929688f,
+	0.015625f,
+	0.9375f,
+	0.015625f,
+	0.945313f,
+	0.015625f,
+	0.953125f,
+	0.015625f,
+	0.960938f,
+	0.015625f,
+	0.96875f,
+	0.015625f,
+	0.976563f,
+	0.015625f,
+	0.984375f,
+	0.015625f,
+	0.992188f,
+	0.015625f,
+	1.0f,
+	0.015625f,
+	0.507813f,
+	0.0234375f,
+	0.515625f,
+	0.0234375f,
+	0.523438f,
+	0.0234375f,
+	0.53125f,
+	0.0234375f,
+	0.539063f,
+	0.0234375f,
+	0.546875f,
+	0.0234375f,
+	0.554688f,
+	0.0234375f,
+	0.5625f,
+	0.0234375f,
+	0.570313f,
+	0.0234375f,
+	0.578125f,
+	0.0234375f,
+	0.585938f,
+	0.0234375f,
+	0.59375f,
+	0.0234375f,
+	0.601563f,
+	0.0234375f,
+	0.609375f,
+	0.0234375f,
+	0.617188f,
+	0.0234375f,
+	0.625f,
+	0.0234375f,
+	0.632813f,
+	0.0234375f,
+	0.640625f,
+	0.0234375f,
+	0.648438f,
+	0.0234375f,
+	0.65625f,
+	0.0234375f,
+	0.664063f,
+	0.0234375f,
+	0.671875f,
+	0.0234375f,
+	0.679688f,
+	0.0234375f,
+	0.6875f,
+	0.0234375f,
+	0.695313f,
+	0.0234375f,
+	0.703125f,
+	0.0234375f,
+	0.710938f,
+	0.0234375f,
+	0.71875f,
+	0.0234375f,
+	0.726563f,
+	0.0234375f,
+	0.734375f,
+	0.0234375f,
+	0.742188f,
+	0.0234375f,
+	0.75f,
+	0.0234375f,
+	0.757813f,
+	0.0234375f,
+	0.765625f,
+	0.0234375f,
+	0.773438f,
+	0.0234375f,
+	0.78125f,
+	0.0234375f,
+	0.789063f,
+	0.0234375f,
+	0.796875f,
+	0.0234375f,
+	0.804688f,
+	0.0234375f,
+	0.8125f,
+	0.0234375f,
+	0.820313f,
+	0.0234375f,
+	0.828125f,
+	0.0234375f,
+	0.835938f,
+	0.0234375f,
+	0.84375f,
+	0.0234375f,
+	0.851563f,
+	0.0234375f,
+	0.859375f,
+	0.0234375f,
+	0.867188f,
+	0.0234375f,
+	0.875f,
+	0.0234375f,
+	0.882813f,
+	0.0234375f,
+	0.890625f,
+	0.0234375f,
+	0.898438f,
+	0.0234375f,
+	0.90625f,
+	0.0234375f,
+	0.914063f,
+	0.0234375f,
+	0.921875f,
+	0.0234375f,
+	0.929688f,
+	0.0234375f,
+	0.9375f,
+	0.0234375f,
+	0.945313f,
+	0.0234375f,
+	0.953125f,
+	0.0234375f,
+	0.960938f,
+	0.0234375f,
+	0.96875f,
+	0.0234375f,
+	0.976563f,
+	0.0234375f,
+	0.984375f,
+	0.0234375f,
+	0.992188f,
+	0.0234375f,
+	1.0f,
+	0.0234375f,
+	0.507813f,
+	0.03125f,
+	0.515625f,
+	0.03125f,
+	0.523438f,
+	0.03125f,
+	0.53125f,
+	0.03125f,
+	0.539063f,
+	0.03125f,
+	0.546875f,
+	0.03125f,
+	0.554688f,
+	0.03125f,
+	0.5625f,
+	0.03125f,
+	0.570313f,
+	0.03125f,
+	0.578125f,
+	0.03125f,
+	0.585938f,
+	0.03125f,
+	0.59375f,
+	0.03125f,
+	0.601563f,
+	0.03125f,
+	0.609375f,
+	0.03125f,
+	0.617188f,
+	0.03125f,
+	0.625f,
+	0.03125f,
+	0.632813f,
+	0.03125f,
+	0.640625f,
+	0.03125f,
+	0.648438f,
+	0.03125f,
+	0.65625f,
+	0.03125f,
+	0.664063f,
+	0.03125f,
+	0.671875f,
+	0.03125f,
+	0.679688f,
+	0.03125f,
+	0.6875f,
+	0.03125f,
+	0.695313f,
+	0.03125f,
+	0.703125f,
+	0.03125f,
+	0.710938f,
+	0.03125f,
+	0.71875f,
+	0.03125f,
+	0.726563f,
+	0.03125f,
+	0.734375f,
+	0.03125f,
+	0.742188f,
+	0.03125f,
+	0.75f,
+	0.03125f,
+	0.757813f,
+	0.03125f,
+	0.765625f,
+	0.03125f,
+	0.773438f,
+	0.03125f,
+	0.78125f,
+	0.03125f,
+	0.789063f,
+	0.03125f,
+	0.796875f,
+	0.03125f,
+	0.804688f,
+	0.03125f,
+	0.8125f,
+	0.03125f,
+	0.820313f,
+	0.03125f,
+	0.828125f,
+	0.03125f,
+	0.835938f,
+	0.03125f,
+	0.84375f,
+	0.03125f,
+	0.851563f,
+	0.03125f,
+	0.859375f,
+	0.03125f,
+	0.867188f,
+	0.03125f,
+	0.875f,
+	0.03125f,
+	0.882813f,
+	0.03125f,
+	0.890625f,
+	0.03125f,
+	0.898438f,
+	0.03125f,
+	0.90625f,
+	0.03125f,
+	0.914063f,
+	0.03125f,
+	0.921875f,
+	0.03125f,
+	0.929688f,
+	0.03125f,
+	0.9375f,
+	0.03125f,
+	0.945313f,
+	0.03125f,
+	0.953125f,
+	0.03125f,
+	0.960938f,
+	0.03125f,
+	0.96875f,
+	0.03125f,
+	0.976563f,
+	0.03125f,
+	0.984375f,
+	0.03125f,
+	0.992188f,
+	0.03125f,
+	1.0f,
+	0.03125f,
+	0.507813f,
+	0.0390625f,
+	0.515625f,
+	0.0390625f,
+	0.523438f,
+	0.0390625f,
+	0.53125f,
+	0.0390625f,
+	0.539063f,
+	0.0390625f,
+	0.546875f,
+	0.0390625f,
+	0.554688f,
+	0.0390625f,
+	0.5625f,
+	0.0390625f,
+	0.570313f,
+	0.0390625f,
+	0.578125f,
+	0.0390625f,
+	0.585938f,
+	0.0390625f,
+	0.59375f,
+	0.0390625f,
+	0.601563f,
+	0.0390625f,
+	0.609375f,
+	0.0390625f,
+	0.617188f,
+	0.0390625f,
+	0.625f,
+	0.0390625f,
+	0.632813f,
+	0.0390625f,
+	0.640625f,
+	0.0390625f,
+	0.648438f,
+	0.0390625f,
+	0.65625f,
+	0.0390625f,
+	0.664063f,
+	0.0390625f,
+	0.671875f,
+	0.0390625f,
+	0.679688f,
+	0.0390625f,
+	0.6875f,
+	0.0390625f,
+	0.695313f,
+	0.0390625f,
+	0.703125f,
+	0.0390625f,
+	0.710938f,
+	0.0390625f,
+	0.71875f,
+	0.0390625f,
+	0.726563f,
+	0.0390625f,
+	0.734375f,
+	0.0390625f,
+	0.742188f,
+	0.0390625f,
+	0.75f,
+	0.0390625f,
+	0.757813f,
+	0.0390625f,
+	0.765625f,
+	0.0390625f,
+	0.773438f,
+	0.0390625f,
+	0.78125f,
+	0.0390625f,
+	0.789063f,
+	0.0390625f,
+	0.796875f,
+	0.0390625f,
+	0.804688f,
+	0.0390625f,
+	0.8125f,
+	0.0390625f,
+	0.820313f,
+	0.0390625f,
+	0.828125f,
+	0.0390625f,
+	0.835938f,
+	0.0390625f,
+	0.84375f,
+	0.0390625f,
+	0.851563f,
+	0.0390625f,
+	0.859375f,
+	0.0390625f,
+	0.867188f,
+	0.0390625f,
+	0.875f,
+	0.0390625f,
+	0.882813f,
+	0.0390625f,
+	0.890625f,
+	0.0390625f,
+	0.898438f,
+	0.0390625f,
+	0.90625f,
+	0.0390625f,
+	0.914063f,
+	0.0390625f,
+	0.921875f,
+	0.0390625f,
+	0.929688f,
+	0.0390625f,
+	0.9375f,
+	0.0390625f,
+	0.945313f,
+	0.0390625f,
+	0.953125f,
+	0.0390625f,
+	0.960938f,
+	0.0390625f,
+	0.96875f,
+	0.0390625f,
+	0.976563f,
+	0.0390625f,
+	0.984375f,
+	0.0390625f,
+	0.992188f,
+	0.0390625f,
+	1.0f,
+	0.0390625f,
+	0.507813f,
+	0.046875f,
+	0.515625f,
+	0.046875f,
+	0.523438f,
+	0.046875f,
+	0.53125f,
+	0.046875f,
+	0.539063f,
+	0.046875f,
+	0.546875f,
+	0.046875f,
+	0.554688f,
+	0.046875f,
+	0.5625f,
+	0.046875f,
+	0.570313f,
+	0.046875f,
+	0.578125f,
+	0.046875f,
+	0.585938f,
+	0.046875f,
+	0.59375f,
+	0.046875f,
+	0.601563f,
+	0.046875f,
+	0.609375f,
+	0.046875f,
+	0.617188f,
+	0.046875f,
+	0.625f,
+	0.046875f,
+	0.632813f,
+	0.046875f,
+	0.640625f,
+	0.046875f,
+	0.648438f,
+	0.046875f,
+	0.65625f,
+	0.046875f,
+	0.664063f,
+	0.046875f,
+	0.671875f,
+	0.046875f,
+	0.679688f,
+	0.046875f,
+	0.6875f,
+	0.046875f,
+	0.695313f,
+	0.046875f,
+	0.703125f,
+	0.046875f,
+	0.710938f,
+	0.046875f,
+	0.71875f,
+	0.046875f,
+	0.726563f,
+	0.046875f,
+	0.734375f,
+	0.046875f,
+	0.742188f,
+	0.046875f,
+	0.75f,
+	0.046875f,
+	0.757813f,
+	0.046875f,
+	0.765625f,
+	0.046875f,
+	0.773438f,
+	0.046875f,
+	0.78125f,
+	0.046875f,
+	0.789063f,
+	0.046875f,
+	0.796875f,
+	0.046875f,
+	0.804688f,
+	0.046875f,
+	0.8125f,
+	0.046875f,
+	0.820313f,
+	0.046875f,
+	0.828125f,
+	0.046875f,
+	0.835938f,
+	0.046875f,
+	0.84375f,
+	0.046875f,
+	0.851563f,
+	0.046875f,
+	0.859375f,
+	0.046875f,
+	0.867188f,
+	0.046875f,
+	0.875f,
+	0.046875f,
+	0.882813f,
+	0.046875f,
+	0.890625f,
+	0.046875f,
+	0.898438f,
+	0.046875f,
+	0.90625f,
+	0.046875f,
+	0.914063f,
+	0.046875f,
+	0.921875f,
+	0.046875f,
+	0.929688f,
+	0.046875f,
+	0.9375f,
+	0.046875f,
+	0.945313f,
+	0.046875f,
+	0.953125f,
+	0.046875f,
+	0.960938f,
+	0.046875f,
+	0.96875f,
+	0.046875f,
+	0.976563f,
+	0.046875f,
+	0.984375f,
+	0.046875f,
+	0.992188f,
+	0.046875f,
+	1.0f,
+	0.046875f,
+	0.507813f,
+	0.0546875f,
+	0.515625f,
+	0.0546875f,
+	0.523438f,
+	0.0546875f,
+	0.53125f,
+	0.0546875f,
+	0.539063f,
+	0.0546875f,
+	0.546875f,
+	0.0546875f,
+	0.554688f,
+	0.0546875f,
+	0.5625f,
+	0.0546875f,
+	0.570313f,
+	0.0546875f,
+	0.578125f,
+	0.0546875f,
+	0.585938f,
+	0.0546875f,
+	0.59375f,
+	0.0546875f,
+	0.601563f,
+	0.0546875f,
+	0.609375f,
+	0.0546875f,
+	0.617188f,
+	0.0546875f,
+	0.625f,
+	0.0546875f,
+	0.632813f,
+	0.0546875f,
+	0.640625f,
+	0.0546875f,
+	0.648438f,
+	0.0546875f,
+	0.65625f,
+	0.0546875f,
+	0.664063f,
+	0.0546875f,
+	0.671875f,
+	0.0546875f,
+	0.679688f,
+	0.0546875f,
+	0.6875f,
+	0.0546875f,
+	0.695313f,
+	0.0546875f,
+	0.703125f,
+	0.0546875f,
+	0.710938f,
+	0.0546875f,
+	0.71875f,
+	0.0546875f,
+	0.726563f,
+	0.0546875f,
+	0.734375f,
+	0.0546875f,
+	0.742188f,
+	0.0546875f,
+	0.75f,
+	0.0546875f,
+	0.757813f,
+	0.0546875f,
+	0.765625f,
+	0.0546875f,
+	0.773438f,
+	0.0546875f,
+	0.78125f,
+	0.0546875f,
+	0.789063f,
+	0.0546875f,
+	0.796875f,
+	0.0546875f,
+	0.804688f,
+	0.0546875f,
+	0.8125f,
+	0.0546875f,
+	0.820313f,
+	0.0546875f,
+	0.828125f,
+	0.0546875f,
+	0.835938f,
+	0.0546875f,
+	0.84375f,
+	0.0546875f,
+	0.851563f,
+	0.0546875f,
+	0.859375f,
+	0.0546875f,
+	0.867188f,
+	0.0546875f,
+	0.875f,
+	0.0546875f,
+	0.882813f,
+	0.0546875f,
+	0.890625f,
+	0.0546875f,
+	0.898438f,
+	0.0546875f,
+	0.90625f,
+	0.0546875f,
+	0.914063f,
+	0.0546875f,
+	0.921875f,
+	0.0546875f,
+	0.929688f,
+	0.0546875f,
+	0.9375f,
+	0.0546875f,
+	0.945313f,
+	0.0546875f,
+	0.953125f,
+	0.0546875f,
+	0.960938f,
+	0.0546875f,
+	0.96875f,
+	0.0546875f,
+	0.976563f,
+	0.0546875f,
+	0.984375f,
+	0.0546875f,
+	0.992188f,
+	0.0546875f,
+	1.0f,
+	0.0546875f,
+	0.507813f,
+	0.0625f,
+	0.515625f,
+	0.0625f,
+	0.523438f,
+	0.0625f,
+	0.53125f,
+	0.0625f,
+	0.539063f,
+	0.0625f,
+	0.546875f,
+	0.0625f,
+	0.554688f,
+	0.0625f,
+	0.5625f,
+	0.0625f,
+	0.570313f,
+	0.0625f,
+	0.578125f,
+	0.0625f,
+	0.585938f,
+	0.0625f,
+	0.59375f,
+	0.0625f,
+	0.601563f,
+	0.0625f,
+	0.609375f,
+	0.0625f,
+	0.617188f,
+	0.0625f,
+	0.625f,
+	0.0625f,
+	0.632813f,
+	0.0625f,
+	0.640625f,
+	0.0625f,
+	0.648438f,
+	0.0625f,
+	0.65625f,
+	0.0625f,
+	0.664063f,
+	0.0625f,
+	0.671875f,
+	0.0625f,
+	0.679688f,
+	0.0625f,
+	0.6875f,
+	0.0625f,
+	0.695313f,
+	0.0625f,
+	0.703125f,
+	0.0625f,
+	0.710938f,
+	0.0625f,
+	0.71875f,
+	0.0625f,
+	0.726563f,
+	0.0625f,
+	0.734375f,
+	0.0625f,
+	0.742188f,
+	0.0625f,
+	0.75f,
+	0.0625f,
+	0.757813f,
+	0.0625f,
+	0.765625f,
+	0.0625f,
+	0.773438f,
+	0.0625f,
+	0.78125f,
+	0.0625f,
+	0.789063f,
+	0.0625f,
+	0.796875f,
+	0.0625f,
+	0.804688f,
+	0.0625f,
+	0.8125f,
+	0.0625f,
+	0.820313f,
+	0.0625f,
+	0.828125f,
+	0.0625f,
+	0.835938f,
+	0.0625f,
+	0.84375f,
+	0.0625f,
+	0.851563f,
+	0.0625f,
+	0.859375f,
+	0.0625f,
+	0.867188f,
+	0.0625f,
+	0.875f,
+	0.0625f,
+	0.882813f,
+	0.0625f,
+	0.890625f,
+	0.0625f,
+	0.898438f,
+	0.0625f,
+	0.90625f,
+	0.0625f,
+	0.914063f,
+	0.0625f,
+	0.921875f,
+	0.0625f,
+	0.929688f,
+	0.0625f,
+	0.9375f,
+	0.0625f,
+	0.945313f,
+	0.0625f,
+	0.953125f,
+	0.0625f,
+	0.960938f,
+	0.0625f,
+	0.96875f,
+	0.0625f,
+	0.976563f,
+	0.0625f,
+	0.984375f,
+	0.0625f,
+	0.992188f,
+	0.0625f,
+	1.0f,
+	0.0625f,
+	0.507813f,
+	0.0703125f,
+	0.515625f,
+	0.0703125f,
+	0.523438f,
+	0.0703125f,
+	0.53125f,
+	0.0703125f,
+	0.539063f,
+	0.0703125f,
+	0.546875f,
+	0.0703125f,
+	0.554688f,
+	0.0703125f,
+	0.5625f,
+	0.0703125f,
+	0.570313f,
+	0.0703125f,
+	0.578125f,
+	0.0703125f,
+	0.585938f,
+	0.0703125f,
+	0.59375f,
+	0.0703125f,
+	0.601563f,
+	0.0703125f,
+	0.609375f,
+	0.0703125f,
+	0.617188f,
+	0.0703125f,
+	0.625f,
+	0.0703125f,
+	0.632813f,
+	0.0703125f,
+	0.640625f,
+	0.0703125f,
+	0.648438f,
+	0.0703125f,
+	0.65625f,
+	0.0703125f,
+	0.664063f,
+	0.0703125f,
+	0.671875f,
+	0.0703125f,
+	0.679688f,
+	0.0703125f,
+	0.6875f,
+	0.0703125f,
+	0.695313f,
+	0.0703125f,
+	0.703125f,
+	0.0703125f,
+	0.710938f,
+	0.0703125f,
+	0.71875f,
+	0.0703125f,
+	0.726563f,
+	0.0703125f,
+	0.734375f,
+	0.0703125f,
+	0.742188f,
+	0.0703125f,
+	0.75f,
+	0.0703125f,
+	0.757813f,
+	0.0703125f,
+	0.765625f,
+	0.0703125f,
+	0.773438f,
+	0.0703125f,
+	0.78125f,
+	0.0703125f,
+	0.789063f,
+	0.0703125f,
+	0.796875f,
+	0.0703125f,
+	0.804688f,
+	0.0703125f,
+	0.8125f,
+	0.0703125f,
+	0.820313f,
+	0.0703125f,
+	0.828125f,
+	0.0703125f,
+	0.835938f,
+	0.0703125f,
+	0.84375f,
+	0.0703125f,
+	0.851563f,
+	0.0703125f,
+	0.859375f,
+	0.0703125f,
+	0.867188f,
+	0.0703125f,
+	0.875f,
+	0.0703125f,
+	0.882813f,
+	0.0703125f,
+	0.890625f,
+	0.0703125f,
+	0.898438f,
+	0.0703125f,
+	0.90625f,
+	0.0703125f,
+	0.914063f,
+	0.0703125f,
+	0.921875f,
+	0.0703125f,
+	0.929688f,
+	0.0703125f,
+	0.9375f,
+	0.0703125f,
+	0.945313f,
+	0.0703125f,
+	0.953125f,
+	0.0703125f,
+	0.960938f,
+	0.0703125f,
+	0.96875f,
+	0.0703125f,
+	0.976563f,
+	0.0703125f,
+	0.984375f,
+	0.0703125f,
+	0.992188f,
+	0.0703125f,
+	1.0f,
+	0.0703125f,
+	0.507813f,
+	0.078125f,
+	0.515625f,
+	0.078125f,
+	0.523438f,
+	0.078125f,
+	0.53125f,
+	0.078125f,
+	0.539063f,
+	0.078125f,
+	0.546875f,
+	0.078125f,
+	0.554688f,
+	0.078125f,
+	0.5625f,
+	0.078125f,
+	0.570313f,
+	0.078125f,
+	0.578125f,
+	0.078125f,
+	0.585938f,
+	0.078125f,
+	0.59375f,
+	0.078125f,
+	0.601563f,
+	0.078125f,
+	0.609375f,
+	0.078125f,
+	0.617188f,
+	0.078125f,
+	0.625f,
+	0.078125f,
+	0.632813f,
+	0.078125f,
+	0.640625f,
+	0.078125f,
+	0.648438f,
+	0.078125f,
+	0.65625f,
+	0.078125f,
+	0.664063f,
+	0.078125f,
+	0.671875f,
+	0.078125f,
+	0.679688f,
+	0.078125f,
+	0.6875f,
+	0.078125f,
+	0.695313f,
+	0.078125f,
+	0.703125f,
+	0.078125f,
+	0.710938f,
+	0.078125f,
+	0.71875f,
+	0.078125f,
+	0.726563f,
+	0.078125f,
+	0.734375f,
+	0.078125f,
+	0.742188f,
+	0.078125f,
+	0.75f,
+	0.078125f,
+	0.757813f,
+	0.078125f,
+	0.765625f,
+	0.078125f,
+	0.773438f,
+	0.078125f,
+	0.78125f,
+	0.078125f,
+	0.789063f,
+	0.078125f,
+	0.796875f,
+	0.078125f,
+	0.804688f,
+	0.078125f,
+	0.8125f,
+	0.078125f,
+	0.820313f,
+	0.078125f,
+	0.828125f,
+	0.078125f,
+	0.835938f,
+	0.078125f,
+	0.84375f,
+	0.078125f,
+	0.851563f,
+	0.078125f,
+	0.859375f,
+	0.078125f,
+	0.867188f,
+	0.078125f,
+	0.875f,
+	0.078125f,
+	0.882813f,
+	0.078125f,
+	0.890625f,
+	0.078125f,
+	0.898438f,
+	0.078125f,
+	0.90625f,
+	0.078125f,
+	0.914063f,
+	0.078125f,
+	0.921875f,
+	0.078125f,
+	0.929688f,
+	0.078125f,
+	0.9375f,
+	0.078125f,
+	0.945313f,
+	0.078125f,
+	0.953125f,
+	0.078125f,
+	0.960938f,
+	0.078125f,
+	0.96875f,
+	0.078125f,
+	0.976563f,
+	0.078125f,
+	0.984375f,
+	0.078125f,
+	0.992188f,
+	0.078125f,
+	1.0f,
+	0.078125f,
+	0.507813f,
+	0.0859375f,
+	0.515625f,
+	0.0859375f,
+	0.523438f,
+	0.0859375f,
+	0.53125f,
+	0.0859375f,
+	0.539063f,
+	0.0859375f,
+	0.546875f,
+	0.0859375f,
+	0.554688f,
+	0.0859375f,
+	0.5625f,
+	0.0859375f,
+	0.570313f,
+	0.0859375f,
+	0.578125f,
+	0.0859375f,
+	0.585938f,
+	0.0859375f,
+	0.59375f,
+	0.0859375f,
+	0.601563f,
+	0.0859375f,
+	0.609375f,
+	0.0859375f,
+	0.617188f,
+	0.0859375f,
+	0.625f,
+	0.0859375f,
+	0.632813f,
+	0.0859375f,
+	0.640625f,
+	0.0859375f,
+	0.648438f,
+	0.0859375f,
+	0.65625f,
+	0.0859375f,
+	0.664063f,
+	0.0859375f,
+	0.671875f,
+	0.0859375f,
+	0.679688f,
+	0.0859375f,
+	0.6875f,
+	0.0859375f,
+	0.695313f,
+	0.0859375f,
+	0.703125f,
+	0.0859375f,
+	0.710938f,
+	0.0859375f,
+	0.71875f,
+	0.0859375f,
+	0.726563f,
+	0.0859375f,
+	0.734375f,
+	0.0859375f,
+	0.742188f,
+	0.0859375f,
+	0.75f,
+	0.0859375f,
+	0.757813f,
+	0.0859375f,
+	0.765625f,
+	0.0859375f,
+	0.773438f,
+	0.0859375f,
+	0.78125f,
+	0.0859375f,
+	0.789063f,
+	0.0859375f,
+	0.796875f,
+	0.0859375f,
+	0.804688f,
+	0.0859375f,
+	0.8125f,
+	0.0859375f,
+	0.820313f,
+	0.0859375f,
+	0.828125f,
+	0.0859375f,
+	0.835938f,
+	0.0859375f,
+	0.84375f,
+	0.0859375f,
+	0.851563f,
+	0.0859375f,
+	0.859375f,
+	0.0859375f,
+	0.867188f,
+	0.0859375f,
+	0.875f,
+	0.0859375f,
+	0.882813f,
+	0.0859375f,
+	0.890625f,
+	0.0859375f,
+	0.898438f,
+	0.0859375f,
+	0.90625f,
+	0.0859375f,
+	0.914063f,
+	0.0859375f,
+	0.921875f,
+	0.0859375f,
+	0.929688f,
+	0.0859375f,
+	0.9375f,
+	0.0859375f,
+	0.945313f,
+	0.0859375f,
+	0.953125f,
+	0.0859375f,
+	0.960938f,
+	0.0859375f,
+	0.96875f,
+	0.0859375f,
+	0.976563f,
+	0.0859375f,
+	0.984375f,
+	0.0859375f,
+	0.992188f,
+	0.0859375f,
+	1.0f,
+	0.0859375f,
+	0.507813f,
+	0.09375f,
+	0.515625f,
+	0.09375f,
+	0.523438f,
+	0.09375f,
+	0.53125f,
+	0.09375f,
+	0.539063f,
+	0.09375f,
+	0.546875f,
+	0.09375f,
+	0.554688f,
+	0.09375f,
+	0.5625f,
+	0.09375f,
+	0.570313f,
+	0.09375f,
+	0.578125f,
+	0.09375f,
+	0.585938f,
+	0.09375f,
+	0.59375f,
+	0.09375f,
+	0.601563f,
+	0.09375f,
+	0.609375f,
+	0.09375f,
+	0.617188f,
+	0.09375f,
+	0.625f,
+	0.09375f,
+	0.632813f,
+	0.09375f,
+	0.640625f,
+	0.09375f,
+	0.648438f,
+	0.09375f,
+	0.65625f,
+	0.09375f,
+	0.664063f,
+	0.09375f,
+	0.671875f,
+	0.09375f,
+	0.679688f,
+	0.09375f,
+	0.6875f,
+	0.09375f,
+	0.695313f,
+	0.09375f,
+	0.703125f,
+	0.09375f,
+	0.710938f,
+	0.09375f,
+	0.71875f,
+	0.09375f,
+	0.726563f,
+	0.09375f,
+	0.734375f,
+	0.09375f,
+	0.742188f,
+	0.09375f,
+	0.75f,
+	0.09375f,
+	0.757813f,
+	0.09375f,
+	0.765625f,
+	0.09375f,
+	0.773438f,
+	0.09375f,
+	0.78125f,
+	0.09375f,
+	0.789063f,
+	0.09375f,
+	0.796875f,
+	0.09375f,
+	0.804688f,
+	0.09375f,
+	0.8125f,
+	0.09375f,
+	0.820313f,
+	0.09375f,
+	0.828125f,
+	0.09375f,
+	0.835938f,
+	0.09375f,
+	0.84375f,
+	0.09375f,
+	0.851563f,
+	0.09375f,
+	0.859375f,
+	0.09375f,
+	0.867188f,
+	0.09375f,
+	0.875f,
+	0.09375f,
+	0.882813f,
+	0.09375f,
+	0.890625f,
+	0.09375f,
+	0.898438f,
+	0.09375f,
+	0.90625f,
+	0.09375f,
+	0.914063f,
+	0.09375f,
+	0.921875f,
+	0.09375f,
+	0.929688f,
+	0.09375f,
+	0.9375f,
+	0.09375f,
+	0.945313f,
+	0.09375f,
+	0.953125f,
+	0.09375f,
+	0.960938f,
+	0.09375f,
+	0.96875f,
+	0.09375f,
+	0.976563f,
+	0.09375f,
+	0.984375f,
+	0.09375f,
+	0.992188f,
+	0.09375f,
+	1.0f,
+	0.09375f,
+	0.507813f,
+	0.101563f,
+	0.515625f,
+	0.101563f,
+	0.523438f,
+	0.101563f,
+	0.53125f,
+	0.101563f,
+	0.539063f,
+	0.101563f,
+	0.546875f,
+	0.101563f,
+	0.554688f,
+	0.101563f,
+	0.5625f,
+	0.101563f,
+	0.570313f,
+	0.101563f,
+	0.578125f,
+	0.101563f,
+	0.585938f,
+	0.101563f,
+	0.59375f,
+	0.101563f,
+	0.601563f,
+	0.101563f,
+	0.609375f,
+	0.101563f,
+	0.617188f,
+	0.101563f,
+	0.625f,
+	0.101563f,
+	0.632813f,
+	0.101563f,
+	0.640625f,
+	0.101563f,
+	0.648438f,
+	0.101563f,
+	0.65625f,
+	0.101563f,
+	0.664063f,
+	0.101563f,
+	0.671875f,
+	0.101563f,
+	0.679688f,
+	0.101563f,
+	0.6875f,
+	0.101563f,
+	0.695313f,
+	0.101563f,
+	0.703125f,
+	0.101563f,
+	0.710938f,
+	0.101563f,
+	0.71875f,
+	0.101563f,
+	0.726563f,
+	0.101563f,
+	0.734375f,
+	0.101563f,
+	0.742188f,
+	0.101563f,
+	0.75f,
+	0.101563f,
+	0.757813f,
+	0.101563f,
+	0.765625f,
+	0.101563f,
+	0.773438f,
+	0.101563f,
+	0.78125f,
+	0.101563f,
+	0.789063f,
+	0.101563f,
+	0.796875f,
+	0.101563f,
+	0.804688f,
+	0.101563f,
+	0.8125f,
+	0.101563f,
+	0.820313f,
+	0.101563f,
+	0.828125f,
+	0.101563f,
+	0.835938f,
+	0.101563f,
+	0.84375f,
+	0.101563f,
+	0.851563f,
+	0.101563f,
+	0.859375f,
+	0.101563f,
+	0.867188f,
+	0.101563f,
+	0.875f,
+	0.101563f,
+	0.882813f,
+	0.101563f,
+	0.890625f,
+	0.101563f,
+	0.898438f,
+	0.101563f,
+	0.90625f,
+	0.101563f,
+	0.914063f,
+	0.101563f,
+	0.921875f,
+	0.101563f,
+	0.929688f,
+	0.101563f,
+	0.9375f,
+	0.101563f,
+	0.945313f,
+	0.101563f,
+	0.953125f,
+	0.101563f,
+	0.960938f,
+	0.101563f,
+	0.96875f,
+	0.101563f,
+	0.976563f,
+	0.101563f,
+	0.984375f,
+	0.101563f,
+	0.992188f,
+	0.101563f,
+	1.0f,
+	0.101563f,
+	0.507813f,
+	0.109375f,
+	0.515625f,
+	0.109375f,
+	0.523438f,
+	0.109375f,
+	0.53125f,
+	0.109375f,
+	0.539063f,
+	0.109375f,
+	0.546875f,
+	0.109375f,
+	0.554688f,
+	0.109375f,
+	0.5625f,
+	0.109375f,
+	0.570313f,
+	0.109375f,
+	0.578125f,
+	0.109375f,
+	0.585938f,
+	0.109375f,
+	0.59375f,
+	0.109375f,
+	0.601563f,
+	0.109375f,
+	0.609375f,
+	0.109375f,
+	0.617188f,
+	0.109375f,
+	0.625f,
+	0.109375f,
+	0.632813f,
+	0.109375f,
+	0.640625f,
+	0.109375f,
+	0.648438f,
+	0.109375f,
+	0.65625f,
+	0.109375f,
+	0.664063f,
+	0.109375f,
+	0.671875f,
+	0.109375f,
+	0.679688f,
+	0.109375f,
+	0.6875f,
+	0.109375f,
+	0.695313f,
+	0.109375f,
+	0.703125f,
+	0.109375f,
+	0.710938f,
+	0.109375f,
+	0.71875f,
+	0.109375f,
+	0.726563f,
+	0.109375f,
+	0.734375f,
+	0.109375f,
+	0.742188f,
+	0.109375f,
+	0.75f,
+	0.109375f,
+	0.757813f,
+	0.109375f,
+	0.765625f,
+	0.109375f,
+	0.773438f,
+	0.109375f,
+	0.78125f,
+	0.109375f,
+	0.789063f,
+	0.109375f,
+	0.796875f,
+	0.109375f,
+	0.804688f,
+	0.109375f,
+	0.8125f,
+	0.109375f,
+	0.820313f,
+	0.109375f,
+	0.828125f,
+	0.109375f,
+	0.835938f,
+	0.109375f,
+	0.84375f,
+	0.109375f,
+	0.851563f,
+	0.109375f,
+	0.859375f,
+	0.109375f,
+	0.867188f,
+	0.109375f,
+	0.875f,
+	0.109375f,
+	0.882813f,
+	0.109375f,
+	0.890625f,
+	0.109375f,
+	0.898438f,
+	0.109375f,
+	0.90625f,
+	0.109375f,
+	0.914063f,
+	0.109375f,
+	0.921875f,
+	0.109375f,
+	0.929688f,
+	0.109375f,
+	0.9375f,
+	0.109375f,
+	0.945313f,
+	0.109375f,
+	0.953125f,
+	0.109375f,
+	0.960938f,
+	0.109375f,
+	0.96875f,
+	0.109375f,
+	0.976563f,
+	0.109375f,
+	0.984375f,
+	0.109375f,
+	0.992188f,
+	0.109375f,
+	1.0f,
+	0.109375f,
+	0.507813f,
+	0.117188f,
+	0.515625f,
+	0.117188f,
+	0.523438f,
+	0.117188f,
+	0.53125f,
+	0.117188f,
+	0.539063f,
+	0.117188f,
+	0.546875f,
+	0.117188f,
+	0.554688f,
+	0.117188f,
+	0.5625f,
+	0.117188f,
+	0.570313f,
+	0.117188f,
+	0.578125f,
+	0.117188f,
+	0.585938f,
+	0.117188f,
+	0.59375f,
+	0.117188f,
+	0.601563f,
+	0.117188f,
+	0.609375f,
+	0.117188f,
+	0.617188f,
+	0.117188f,
+	0.625f,
+	0.117188f,
+	0.632813f,
+	0.117188f,
+	0.640625f,
+	0.117188f,
+	0.648438f,
+	0.117188f,
+	0.65625f,
+	0.117188f,
+	0.664063f,
+	0.117188f,
+	0.671875f,
+	0.117188f,
+	0.679688f,
+	0.117188f,
+	0.6875f,
+	0.117188f,
+	0.695313f,
+	0.117188f,
+	0.703125f,
+	0.117188f,
+	0.710938f,
+	0.117188f,
+	0.71875f,
+	0.117188f,
+	0.726563f,
+	0.117188f,
+	0.734375f,
+	0.117188f,
+	0.742188f,
+	0.117188f,
+	0.75f,
+	0.117188f,
+	0.757813f,
+	0.117188f,
+	0.765625f,
+	0.117188f,
+	0.773438f,
+	0.117188f,
+	0.78125f,
+	0.117188f,
+	0.789063f,
+	0.117188f,
+	0.796875f,
+	0.117188f,
+	0.804688f,
+	0.117188f,
+	0.8125f,
+	0.117188f,
+	0.820313f,
+	0.117188f,
+	0.828125f,
+	0.117188f,
+	0.835938f,
+	0.117188f,
+	0.84375f,
+	0.117188f,
+	0.851563f,
+	0.117188f,
+	0.859375f,
+	0.117188f,
+	0.867188f,
+	0.117188f,
+	0.875f,
+	0.117188f,
+	0.882813f,
+	0.117188f,
+	0.890625f,
+	0.117188f,
+	0.898438f,
+	0.117188f,
+	0.90625f,
+	0.117188f,
+	0.914063f,
+	0.117188f,
+	0.921875f,
+	0.117188f,
+	0.929688f,
+	0.117188f,
+	0.9375f,
+	0.117188f,
+	0.945313f,
+	0.117188f,
+	0.953125f,
+	0.117188f,
+	0.960938f,
+	0.117188f,
+	0.96875f,
+	0.117188f,
+	0.976563f,
+	0.117188f,
+	0.984375f,
+	0.117188f,
+	0.992188f,
+	0.117188f,
+	1.0f,
+	0.117188f,
+	0.507813f,
+	0.125f,
+	0.515625f,
+	0.125f,
+	0.523438f,
+	0.125f,
+	0.53125f,
+	0.125f,
+	0.539063f,
+	0.125f,
+	0.546875f,
+	0.125f,
+	0.554688f,
+	0.125f,
+	0.5625f,
+	0.125f,
+	0.570313f,
+	0.125f,
+	0.578125f,
+	0.125f,
+	0.585938f,
+	0.125f,
+	0.59375f,
+	0.125f,
+	0.601563f,
+	0.125f,
+	0.609375f,
+	0.125f,
+	0.617188f,
+	0.125f,
+	0.625f,
+	0.125f,
+	0.632813f,
+	0.125f,
+	0.640625f,
+	0.125f,
+	0.648438f,
+	0.125f,
+	0.65625f,
+	0.125f,
+	0.664063f,
+	0.125f,
+	0.671875f,
+	0.125f,
+	0.679688f,
+	0.125f,
+	0.6875f,
+	0.125f,
+	0.695313f,
+	0.125f,
+	0.703125f,
+	0.125f,
+	0.710938f,
+	0.125f,
+	0.71875f,
+	0.125f,
+	0.726563f,
+	0.125f,
+	0.734375f,
+	0.125f,
+	0.742188f,
+	0.125f,
+	0.75f,
+	0.125f,
+	0.757813f,
+	0.125f,
+	0.765625f,
+	0.125f,
+	0.773438f,
+	0.125f,
+	0.78125f,
+	0.125f,
+	0.789063f,
+	0.125f,
+	0.796875f,
+	0.125f,
+	0.804688f,
+	0.125f,
+	0.8125f,
+	0.125f,
+	0.820313f,
+	0.125f,
+	0.828125f,
+	0.125f,
+	0.835938f,
+	0.125f,
+	0.84375f,
+	0.125f,
+	0.851563f,
+	0.125f,
+	0.859375f,
+	0.125f,
+	0.867188f,
+	0.125f,
+	0.875f,
+	0.125f,
+	0.882813f,
+	0.125f,
+	0.890625f,
+	0.125f,
+	0.898438f,
+	0.125f,
+	0.90625f,
+	0.125f,
+	0.914063f,
+	0.125f,
+	0.921875f,
+	0.125f,
+	0.929688f,
+	0.125f,
+	0.9375f,
+	0.125f,
+	0.945313f,
+	0.125f,
+	0.953125f,
+	0.125f,
+	0.960938f,
+	0.125f,
+	0.96875f,
+	0.125f,
+	0.976563f,
+	0.125f,
+	0.984375f,
+	0.125f,
+	0.992188f,
+	0.125f,
+	1.0f,
+	0.125f,
+	0.507813f,
+	0.132813f,
+	0.515625f,
+	0.132813f,
+	0.523438f,
+	0.132813f,
+	0.53125f,
+	0.132813f,
+	0.539063f,
+	0.132813f,
+	0.546875f,
+	0.132813f,
+	0.554688f,
+	0.132813f,
+	0.5625f,
+	0.132813f,
+	0.570313f,
+	0.132813f,
+	0.578125f,
+	0.132813f,
+	0.585938f,
+	0.132813f,
+	0.59375f,
+	0.132813f,
+	0.601563f,
+	0.132813f,
+	0.609375f,
+	0.132813f,
+	0.617188f,
+	0.132813f,
+	0.625f,
+	0.132813f,
+	0.632813f,
+	0.132813f,
+	0.640625f,
+	0.132813f,
+	0.648438f,
+	0.132813f,
+	0.65625f,
+	0.132813f,
+	0.664063f,
+	0.132813f,
+	0.671875f,
+	0.132813f,
+	0.679688f,
+	0.132813f,
+	0.6875f,
+	0.132813f,
+	0.695313f,
+	0.132813f,
+	0.703125f,
+	0.132813f,
+	0.710938f,
+	0.132813f,
+	0.71875f,
+	0.132813f,
+	0.726563f,
+	0.132813f,
+	0.734375f,
+	0.132813f,
+	0.742188f,
+	0.132813f,
+	0.75f,
+	0.132813f,
+	0.757813f,
+	0.132813f,
+	0.765625f,
+	0.132813f,
+	0.773438f,
+	0.132813f,
+	0.78125f,
+	0.132813f,
+	0.789063f,
+	0.132813f,
+	0.796875f,
+	0.132813f,
+	0.804688f,
+	0.132813f,
+	0.8125f,
+	0.132813f,
+	0.820313f,
+	0.132813f,
+	0.828125f,
+	0.132813f,
+	0.835938f,
+	0.132813f,
+	0.84375f,
+	0.132813f,
+	0.851563f,
+	0.132813f,
+	0.859375f,
+	0.132813f,
+	0.867188f,
+	0.132813f,
+	0.875f,
+	0.132813f,
+	0.882813f,
+	0.132813f,
+	0.890625f,
+	0.132813f,
+	0.898438f,
+	0.132813f,
+	0.90625f,
+	0.132813f,
+	0.914063f,
+	0.132813f,
+	0.921875f,
+	0.132813f,
+	0.929688f,
+	0.132813f,
+	0.9375f,
+	0.132813f,
+	0.945313f,
+	0.132813f,
+	0.953125f,
+	0.132813f,
+	0.960938f,
+	0.132813f,
+	0.96875f,
+	0.132813f,
+	0.976563f,
+	0.132813f,
+	0.984375f,
+	0.132813f,
+	0.992188f,
+	0.132813f,
+	1.0f,
+	0.132813f,
+	0.507813f,
+	0.140625f,
+	0.515625f,
+	0.140625f,
+	0.523438f,
+	0.140625f,
+	0.53125f,
+	0.140625f,
+	0.539063f,
+	0.140625f,
+	0.546875f,
+	0.140625f,
+	0.554688f,
+	0.140625f,
+	0.5625f,
+	0.140625f,
+	0.570313f,
+	0.140625f,
+	0.578125f,
+	0.140625f,
+	0.585938f,
+	0.140625f,
+	0.59375f,
+	0.140625f,
+	0.601563f,
+	0.140625f,
+	0.609375f,
+	0.140625f,
+	0.617188f,
+	0.140625f,
+	0.625f,
+	0.140625f,
+	0.632813f,
+	0.140625f,
+	0.640625f,
+	0.140625f,
+	0.648438f,
+	0.140625f,
+	0.65625f,
+	0.140625f,
+	0.664063f,
+	0.140625f,
+	0.671875f,
+	0.140625f,
+	0.679688f,
+	0.140625f,
+	0.6875f,
+	0.140625f,
+	0.695313f,
+	0.140625f,
+	0.703125f,
+	0.140625f,
+	0.710938f,
+	0.140625f,
+	0.71875f,
+	0.140625f,
+	0.726563f,
+	0.140625f,
+	0.734375f,
+	0.140625f,
+	0.742188f,
+	0.140625f,
+	0.75f,
+	0.140625f,
+	0.757813f,
+	0.140625f,
+	0.765625f,
+	0.140625f,
+	0.773438f,
+	0.140625f,
+	0.78125f,
+	0.140625f,
+	0.789063f,
+	0.140625f,
+	0.796875f,
+	0.140625f,
+	0.804688f,
+	0.140625f,
+	0.8125f,
+	0.140625f,
+	0.820313f,
+	0.140625f,
+	0.828125f,
+	0.140625f,
+	0.835938f,
+	0.140625f,
+	0.84375f,
+	0.140625f,
+	0.851563f,
+	0.140625f,
+	0.859375f,
+	0.140625f,
+	0.867188f,
+	0.140625f,
+	0.875f,
+	0.140625f,
+	0.882813f,
+	0.140625f,
+	0.890625f,
+	0.140625f,
+	0.898438f,
+	0.140625f,
+	0.90625f,
+	0.140625f,
+	0.914063f,
+	0.140625f,
+	0.921875f,
+	0.140625f,
+	0.929688f,
+	0.140625f,
+	0.9375f,
+	0.140625f,
+	0.945313f,
+	0.140625f,
+	0.953125f,
+	0.140625f,
+	0.960938f,
+	0.140625f,
+	0.96875f,
+	0.140625f,
+	0.976563f,
+	0.140625f,
+	0.984375f,
+	0.140625f,
+	0.992188f,
+	0.140625f,
+	1.0f,
+	0.140625f,
+	0.507813f,
+	0.148438f,
+	0.515625f,
+	0.148438f,
+	0.523438f,
+	0.148438f,
+	0.53125f,
+	0.148438f,
+	0.539063f,
+	0.148438f,
+	0.546875f,
+	0.148438f,
+	0.554688f,
+	0.148438f,
+	0.5625f,
+	0.148438f,
+	0.570313f,
+	0.148438f,
+	0.578125f,
+	0.148438f,
+	0.585938f,
+	0.148438f,
+	0.59375f,
+	0.148438f,
+	0.601563f,
+	0.148438f,
+	0.609375f,
+	0.148438f,
+	0.617188f,
+	0.148438f,
+	0.625f,
+	0.148438f,
+	0.632813f,
+	0.148438f,
+	0.640625f,
+	0.148438f,
+	0.648438f,
+	0.148438f,
+	0.65625f,
+	0.148438f,
+	0.664063f,
+	0.148438f,
+	0.671875f,
+	0.148438f,
+	0.679688f,
+	0.148438f,
+	0.6875f,
+	0.148438f,
+	0.695313f,
+	0.148438f,
+	0.703125f,
+	0.148438f,
+	0.710938f,
+	0.148438f,
+	0.71875f,
+	0.148438f,
+	0.726563f,
+	0.148438f,
+	0.734375f,
+	0.148438f,
+	0.742188f,
+	0.148438f,
+	0.75f,
+	0.148438f,
+	0.757813f,
+	0.148438f,
+	0.765625f,
+	0.148438f,
+	0.773438f,
+	0.148438f,
+	0.78125f,
+	0.148438f,
+	0.789063f,
+	0.148438f,
+	0.796875f,
+	0.148438f,
+	0.804688f,
+	0.148438f,
+	0.8125f,
+	0.148438f,
+	0.820313f,
+	0.148438f,
+	0.828125f,
+	0.148438f,
+	0.835938f,
+	0.148438f,
+	0.84375f,
+	0.148438f,
+	0.851563f,
+	0.148438f,
+	0.859375f,
+	0.148438f,
+	0.867188f,
+	0.148438f,
+	0.875f,
+	0.148438f,
+	0.882813f,
+	0.148438f,
+	0.890625f,
+	0.148438f,
+	0.898438f,
+	0.148438f,
+	0.90625f,
+	0.148438f,
+	0.914063f,
+	0.148438f,
+	0.921875f,
+	0.148438f,
+	0.929688f,
+	0.148438f,
+	0.9375f,
+	0.148438f,
+	0.945313f,
+	0.148438f,
+	0.953125f,
+	0.148438f,
+	0.960938f,
+	0.148438f,
+	0.96875f,
+	0.148438f,
+	0.976563f,
+	0.148438f,
+	0.984375f,
+	0.148438f,
+	0.992188f,
+	0.148438f,
+	1.0f,
+	0.148438f,
+	0.507813f,
+	0.15625f,
+	0.515625f,
+	0.15625f,
+	0.523438f,
+	0.15625f,
+	0.53125f,
+	0.15625f,
+	0.539063f,
+	0.15625f,
+	0.546875f,
+	0.15625f,
+	0.554688f,
+	0.15625f,
+	0.5625f,
+	0.15625f,
+	0.570313f,
+	0.15625f,
+	0.578125f,
+	0.15625f,
+	0.585938f,
+	0.15625f,
+	0.59375f,
+	0.15625f,
+	0.601563f,
+	0.15625f,
+	0.609375f,
+	0.15625f,
+	0.617188f,
+	0.15625f,
+	0.625f,
+	0.15625f,
+	0.632813f,
+	0.15625f,
+	0.640625f,
+	0.15625f,
+	0.648438f,
+	0.15625f,
+	0.65625f,
+	0.15625f,
+	0.664063f,
+	0.15625f,
+	0.671875f,
+	0.15625f,
+	0.679688f,
+	0.15625f,
+	0.6875f,
+	0.15625f,
+	0.695313f,
+	0.15625f,
+	0.703125f,
+	0.15625f,
+	0.710938f,
+	0.15625f,
+	0.71875f,
+	0.15625f,
+	0.726563f,
+	0.15625f,
+	0.734375f,
+	0.15625f,
+	0.742188f,
+	0.15625f,
+	0.75f,
+	0.15625f,
+	0.757813f,
+	0.15625f,
+	0.765625f,
+	0.15625f,
+	0.773438f,
+	0.15625f,
+	0.78125f,
+	0.15625f,
+	0.789063f,
+	0.15625f,
+	0.796875f,
+	0.15625f,
+	0.804688f,
+	0.15625f,
+	0.8125f,
+	0.15625f,
+	0.820313f,
+	0.15625f,
+	0.828125f,
+	0.15625f,
+	0.835938f,
+	0.15625f,
+	0.84375f,
+	0.15625f,
+	0.851563f,
+	0.15625f,
+	0.859375f,
+	0.15625f,
+	0.867188f,
+	0.15625f,
+	0.875f,
+	0.15625f,
+	0.882813f,
+	0.15625f,
+	0.890625f,
+	0.15625f,
+	0.898438f,
+	0.15625f,
+	0.90625f,
+	0.15625f,
+	0.914063f,
+	0.15625f,
+	0.921875f,
+	0.15625f,
+	0.929688f,
+	0.15625f,
+	0.9375f,
+	0.15625f,
+	0.945313f,
+	0.15625f,
+	0.953125f,
+	0.15625f,
+	0.960938f,
+	0.15625f,
+	0.96875f,
+	0.15625f,
+	0.976563f,
+	0.15625f,
+	0.984375f,
+	0.15625f,
+	0.992188f,
+	0.15625f,
+	1.0f,
+	0.15625f,
+	0.507813f,
+	0.164063f,
+	0.515625f,
+	0.164063f,
+	0.523438f,
+	0.164063f,
+	0.53125f,
+	0.164063f,
+	0.539063f,
+	0.164063f,
+	0.546875f,
+	0.164063f,
+	0.554688f,
+	0.164063f,
+	0.5625f,
+	0.164063f,
+	0.570313f,
+	0.164063f,
+	0.578125f,
+	0.164063f,
+	0.585938f,
+	0.164063f,
+	0.59375f,
+	0.164063f,
+	0.601563f,
+	0.164063f,
+	0.609375f,
+	0.164063f,
+	0.617188f,
+	0.164063f,
+	0.625f,
+	0.164063f,
+	0.632813f,
+	0.164063f,
+	0.640625f,
+	0.164063f,
+	0.648438f,
+	0.164063f,
+	0.65625f,
+	0.164063f,
+	0.664063f,
+	0.164063f,
+	0.671875f,
+	0.164063f,
+	0.679688f,
+	0.164063f,
+	0.6875f,
+	0.164063f,
+	0.695313f,
+	0.164063f,
+	0.703125f,
+	0.164063f,
+	0.710938f,
+	0.164063f,
+	0.71875f,
+	0.164063f,
+	0.726563f,
+	0.164063f,
+	0.734375f,
+	0.164063f,
+	0.742188f,
+	0.164063f,
+	0.75f,
+	0.164063f,
+	0.757813f,
+	0.164063f,
+	0.765625f,
+	0.164063f,
+	0.773438f,
+	0.164063f,
+	0.78125f,
+	0.164063f,
+	0.789063f,
+	0.164063f,
+	0.796875f,
+	0.164063f,
+	0.804688f,
+	0.164063f,
+	0.8125f,
+	0.164063f,
+	0.820313f,
+	0.164063f,
+	0.828125f,
+	0.164063f,
+	0.835938f,
+	0.164063f,
+	0.84375f,
+	0.164063f,
+	0.851563f,
+	0.164063f,
+	0.859375f,
+	0.164063f,
+	0.867188f,
+	0.164063f,
+	0.875f,
+	0.164063f,
+	0.882813f,
+	0.164063f,
+	0.890625f,
+	0.164063f,
+	0.898438f,
+	0.164063f,
+	0.90625f,
+	0.164063f,
+	0.914063f,
+	0.164063f,
+	0.921875f,
+	0.164063f,
+	0.929688f,
+	0.164063f,
+	0.9375f,
+	0.164063f,
+	0.945313f,
+	0.164063f,
+	0.953125f,
+	0.164063f,
+	0.960938f,
+	0.164063f,
+	0.96875f,
+	0.164063f,
+	0.976563f,
+	0.164063f,
+	0.984375f,
+	0.164063f,
+	0.992188f,
+	0.164063f,
+	1.0f,
+	0.164063f,
+	0.507813f,
+	0.171875f,
+	0.515625f,
+	0.171875f,
+	0.523438f,
+	0.171875f,
+	0.53125f,
+	0.171875f,
+	0.539063f,
+	0.171875f,
+	0.546875f,
+	0.171875f,
+	0.554688f,
+	0.171875f,
+	0.5625f,
+	0.171875f,
+	0.570313f,
+	0.171875f,
+	0.578125f,
+	0.171875f,
+	0.585938f,
+	0.171875f,
+	0.59375f,
+	0.171875f,
+	0.601563f,
+	0.171875f,
+	0.609375f,
+	0.171875f,
+	0.617188f,
+	0.171875f,
+	0.625f,
+	0.171875f,
+	0.632813f,
+	0.171875f,
+	0.640625f,
+	0.171875f,
+	0.648438f,
+	0.171875f,
+	0.65625f,
+	0.171875f,
+	0.664063f,
+	0.171875f,
+	0.671875f,
+	0.171875f,
+	0.679688f,
+	0.171875f,
+	0.6875f,
+	0.171875f,
+	0.695313f,
+	0.171875f,
+	0.703125f,
+	0.171875f,
+	0.710938f,
+	0.171875f,
+	0.71875f,
+	0.171875f,
+	0.726563f,
+	0.171875f,
+	0.734375f,
+	0.171875f,
+	0.742188f,
+	0.171875f,
+	0.75f,
+	0.171875f,
+	0.757813f,
+	0.171875f,
+	0.765625f,
+	0.171875f,
+	0.773438f,
+	0.171875f,
+	0.78125f,
+	0.171875f,
+	0.789063f,
+	0.171875f,
+	0.796875f,
+	0.171875f,
+	0.804688f,
+	0.171875f,
+	0.8125f,
+	0.171875f,
+	0.820313f,
+	0.171875f,
+	0.828125f,
+	0.171875f,
+	0.835938f,
+	0.171875f,
+	0.84375f,
+	0.171875f,
+	0.851563f,
+	0.171875f,
+	0.859375f,
+	0.171875f,
+	0.867188f,
+	0.171875f,
+	0.875f,
+	0.171875f,
+	0.882813f,
+	0.171875f,
+	0.890625f,
+	0.171875f,
+	0.898438f,
+	0.171875f,
+	0.90625f,
+	0.171875f,
+	0.914063f,
+	0.171875f,
+	0.921875f,
+	0.171875f,
+	0.929688f,
+	0.171875f,
+	0.9375f,
+	0.171875f,
+	0.945313f,
+	0.171875f,
+	0.953125f,
+	0.171875f,
+	0.960938f,
+	0.171875f,
+	0.96875f,
+	0.171875f,
+	0.976563f,
+	0.171875f,
+	0.984375f,
+	0.171875f,
+	0.992188f,
+	0.171875f,
+	1.0f,
+	0.171875f,
+	0.507813f,
+	0.179688f,
+	0.515625f,
+	0.179688f,
+	0.523438f,
+	0.179688f,
+	0.53125f,
+	0.179688f,
+	0.539063f,
+	0.179688f,
+	0.546875f,
+	0.179688f,
+	0.554688f,
+	0.179688f,
+	0.5625f,
+	0.179688f,
+	0.570313f,
+	0.179688f,
+	0.578125f,
+	0.179688f,
+	0.585938f,
+	0.179688f,
+	0.59375f,
+	0.179688f,
+	0.601563f,
+	0.179688f,
+	0.609375f,
+	0.179688f,
+	0.617188f,
+	0.179688f,
+	0.625f,
+	0.179688f,
+	0.632813f,
+	0.179688f,
+	0.640625f,
+	0.179688f,
+	0.648438f,
+	0.179688f,
+	0.65625f,
+	0.179688f,
+	0.664063f,
+	0.179688f,
+	0.671875f,
+	0.179688f,
+	0.679688f,
+	0.179688f,
+	0.6875f,
+	0.179688f,
+	0.695313f,
+	0.179688f,
+	0.703125f,
+	0.179688f,
+	0.710938f,
+	0.179688f,
+	0.71875f,
+	0.179688f,
+	0.726563f,
+	0.179688f,
+	0.734375f,
+	0.179688f,
+	0.742188f,
+	0.179688f,
+	0.75f,
+	0.179688f,
+	0.757813f,
+	0.179688f,
+	0.765625f,
+	0.179688f,
+	0.773438f,
+	0.179688f,
+	0.78125f,
+	0.179688f,
+	0.789063f,
+	0.179688f,
+	0.796875f,
+	0.179688f,
+	0.804688f,
+	0.179688f,
+	0.8125f,
+	0.179688f,
+	0.820313f,
+	0.179688f,
+	0.828125f,
+	0.179688f,
+	0.835938f,
+	0.179688f,
+	0.84375f,
+	0.179688f,
+	0.851563f,
+	0.179688f,
+	0.859375f,
+	0.179688f,
+	0.867188f,
+	0.179688f,
+	0.875f,
+	0.179688f,
+	0.882813f,
+	0.179688f,
+	0.890625f,
+	0.179688f,
+	0.898438f,
+	0.179688f,
+	0.90625f,
+	0.179688f,
+	0.914063f,
+	0.179688f,
+	0.921875f,
+	0.179688f,
+	0.929688f,
+	0.179688f,
+	0.9375f,
+	0.179688f,
+	0.945313f,
+	0.179688f,
+	0.953125f,
+	0.179688f,
+	0.960938f,
+	0.179688f,
+	0.96875f,
+	0.179688f,
+	0.976563f,
+	0.179688f,
+	0.984375f,
+	0.179688f,
+	0.992188f,
+	0.179688f,
+	1.0f,
+	0.179688f,
+	0.507813f,
+	0.1875f,
+	0.515625f,
+	0.1875f,
+	0.523438f,
+	0.1875f,
+	0.53125f,
+	0.1875f,
+	0.539063f,
+	0.1875f,
+	0.546875f,
+	0.1875f,
+	0.554688f,
+	0.1875f,
+	0.5625f,
+	0.1875f,
+	0.570313f,
+	0.1875f,
+	0.578125f,
+	0.1875f,
+	0.585938f,
+	0.1875f,
+	0.59375f,
+	0.1875f,
+	0.601563f,
+	0.1875f,
+	0.609375f,
+	0.1875f,
+	0.617188f,
+	0.1875f,
+	0.625f,
+	0.1875f,
+	0.632813f,
+	0.1875f,
+	0.640625f,
+	0.1875f,
+	0.648438f,
+	0.1875f,
+	0.65625f,
+	0.1875f,
+	0.664063f,
+	0.1875f,
+	0.671875f,
+	0.1875f,
+	0.679688f,
+	0.1875f,
+	0.6875f,
+	0.1875f,
+	0.695313f,
+	0.1875f,
+	0.703125f,
+	0.1875f,
+	0.710938f,
+	0.1875f,
+	0.71875f,
+	0.1875f,
+	0.726563f,
+	0.1875f,
+	0.734375f,
+	0.1875f,
+	0.742188f,
+	0.1875f,
+	0.75f,
+	0.1875f,
+	0.757813f,
+	0.1875f,
+	0.765625f,
+	0.1875f,
+	0.773438f,
+	0.1875f,
+	0.78125f,
+	0.1875f,
+	0.789063f,
+	0.1875f,
+	0.796875f,
+	0.1875f,
+	0.804688f,
+	0.1875f,
+	0.8125f,
+	0.1875f,
+	0.820313f,
+	0.1875f,
+	0.828125f,
+	0.1875f,
+	0.835938f,
+	0.1875f,
+	0.84375f,
+	0.1875f,
+	0.851563f,
+	0.1875f,
+	0.859375f,
+	0.1875f,
+	0.867188f,
+	0.1875f,
+	0.875f,
+	0.1875f,
+	0.882813f,
+	0.1875f,
+	0.890625f,
+	0.1875f,
+	0.898438f,
+	0.1875f,
+	0.90625f,
+	0.1875f,
+	0.914063f,
+	0.1875f,
+	0.921875f,
+	0.1875f,
+	0.929688f,
+	0.1875f,
+	0.9375f,
+	0.1875f,
+	0.945313f,
+	0.1875f,
+	0.953125f,
+	0.1875f,
+	0.960938f,
+	0.1875f,
+	0.96875f,
+	0.1875f,
+	0.976563f,
+	0.1875f,
+	0.984375f,
+	0.1875f,
+	0.992188f,
+	0.1875f,
+	1.0f,
+	0.1875f,
+	0.507813f,
+	0.195313f,
+	0.515625f,
+	0.195313f,
+	0.523438f,
+	0.195313f,
+	0.53125f,
+	0.195313f,
+	0.539063f,
+	0.195313f,
+	0.546875f,
+	0.195313f,
+	0.554688f,
+	0.195313f,
+	0.5625f,
+	0.195313f,
+	0.570313f,
+	0.195313f,
+	0.578125f,
+	0.195313f,
+	0.585938f,
+	0.195313f,
+	0.59375f,
+	0.195313f,
+	0.601563f,
+	0.195313f,
+	0.609375f,
+	0.195313f,
+	0.617188f,
+	0.195313f,
+	0.625f,
+	0.195313f,
+	0.632813f,
+	0.195313f,
+	0.640625f,
+	0.195313f,
+	0.648438f,
+	0.195313f,
+	0.65625f,
+	0.195313f,
+	0.664063f,
+	0.195313f,
+	0.671875f,
+	0.195313f,
+	0.679688f,
+	0.195313f,
+	0.6875f,
+	0.195313f,
+	0.695313f,
+	0.195313f,
+	0.703125f,
+	0.195313f,
+	0.710938f,
+	0.195313f,
+	0.71875f,
+	0.195313f,
+	0.726563f,
+	0.195313f,
+	0.734375f,
+	0.195313f,
+	0.742188f,
+	0.195313f,
+	0.75f,
+	0.195313f,
+	0.757813f,
+	0.195313f,
+	0.765625f,
+	0.195313f,
+	0.773438f,
+	0.195313f,
+	0.78125f,
+	0.195313f,
+	0.789063f,
+	0.195313f,
+	0.796875f,
+	0.195313f,
+	0.804688f,
+	0.195313f,
+	0.8125f,
+	0.195313f,
+	0.820313f,
+	0.195313f,
+	0.828125f,
+	0.195313f,
+	0.835938f,
+	0.195313f,
+	0.84375f,
+	0.195313f,
+	0.851563f,
+	0.195313f,
+	0.859375f,
+	0.195313f,
+	0.867188f,
+	0.195313f,
+	0.875f,
+	0.195313f,
+	0.882813f,
+	0.195313f,
+	0.890625f,
+	0.195313f,
+	0.898438f,
+	0.195313f,
+	0.90625f,
+	0.195313f,
+	0.914063f,
+	0.195313f,
+	0.921875f,
+	0.195313f,
+	0.929688f,
+	0.195313f,
+	0.9375f,
+	0.195313f,
+	0.945313f,
+	0.195313f,
+	0.953125f,
+	0.195313f,
+	0.960938f,
+	0.195313f,
+	0.96875f,
+	0.195313f,
+	0.976563f,
+	0.195313f,
+	0.984375f,
+	0.195313f,
+	0.992188f,
+	0.195313f,
+	1.0f,
+	0.195313f,
+	0.507813f,
+	0.203125f,
+	0.515625f,
+	0.203125f,
+	0.523438f,
+	0.203125f,
+	0.53125f,
+	0.203125f,
+	0.539063f,
+	0.203125f,
+	0.546875f,
+	0.203125f,
+	0.554688f,
+	0.203125f,
+	0.5625f,
+	0.203125f,
+	0.570313f,
+	0.203125f,
+	0.578125f,
+	0.203125f,
+	0.585938f,
+	0.203125f,
+	0.59375f,
+	0.203125f,
+	0.601563f,
+	0.203125f,
+	0.609375f,
+	0.203125f,
+	0.617188f,
+	0.203125f,
+	0.625f,
+	0.203125f,
+	0.632813f,
+	0.203125f,
+	0.640625f,
+	0.203125f,
+	0.648438f,
+	0.203125f,
+	0.65625f,
+	0.203125f,
+	0.664063f,
+	0.203125f,
+	0.671875f,
+	0.203125f,
+	0.679688f,
+	0.203125f,
+	0.6875f,
+	0.203125f,
+	0.695313f,
+	0.203125f,
+	0.703125f,
+	0.203125f,
+	0.710938f,
+	0.203125f,
+	0.71875f,
+	0.203125f,
+	0.726563f,
+	0.203125f,
+	0.734375f,
+	0.203125f,
+	0.742188f,
+	0.203125f,
+	0.75f,
+	0.203125f,
+	0.757813f,
+	0.203125f,
+	0.765625f,
+	0.203125f,
+	0.773438f,
+	0.203125f,
+	0.78125f,
+	0.203125f,
+	0.789063f,
+	0.203125f,
+	0.796875f,
+	0.203125f,
+	0.804688f,
+	0.203125f,
+	0.8125f,
+	0.203125f,
+	0.820313f,
+	0.203125f,
+	0.828125f,
+	0.203125f,
+	0.835938f,
+	0.203125f,
+	0.84375f,
+	0.203125f,
+	0.851563f,
+	0.203125f,
+	0.859375f,
+	0.203125f,
+	0.867188f,
+	0.203125f,
+	0.875f,
+	0.203125f,
+	0.882813f,
+	0.203125f,
+	0.890625f,
+	0.203125f,
+	0.898438f,
+	0.203125f,
+	0.90625f,
+	0.203125f,
+	0.914063f,
+	0.203125f,
+	0.921875f,
+	0.203125f,
+	0.929688f,
+	0.203125f,
+	0.9375f,
+	0.203125f,
+	0.945313f,
+	0.203125f,
+	0.953125f,
+	0.203125f,
+	0.960938f,
+	0.203125f,
+	0.96875f,
+	0.203125f,
+	0.976563f,
+	0.203125f,
+	0.984375f,
+	0.203125f,
+	0.992188f,
+	0.203125f,
+	1.0f,
+	0.203125f,
+	0.507813f,
+	0.210938f,
+	0.515625f,
+	0.210938f,
+	0.523438f,
+	0.210938f,
+	0.53125f,
+	0.210938f,
+	0.539063f,
+	0.210938f,
+	0.546875f,
+	0.210938f,
+	0.554688f,
+	0.210938f,
+	0.5625f,
+	0.210938f,
+	0.570313f,
+	0.210938f,
+	0.578125f,
+	0.210938f,
+	0.585938f,
+	0.210938f,
+	0.59375f,
+	0.210938f,
+	0.601563f,
+	0.210938f,
+	0.609375f,
+	0.210938f,
+	0.617188f,
+	0.210938f,
+	0.625f,
+	0.210938f,
+	0.632813f,
+	0.210938f,
+	0.640625f,
+	0.210938f,
+	0.648438f,
+	0.210938f,
+	0.65625f,
+	0.210938f,
+	0.664063f,
+	0.210938f,
+	0.671875f,
+	0.210938f,
+	0.679688f,
+	0.210938f,
+	0.6875f,
+	0.210938f,
+	0.695313f,
+	0.210938f,
+	0.703125f,
+	0.210938f,
+	0.710938f,
+	0.210938f,
+	0.71875f,
+	0.210938f,
+	0.726563f,
+	0.210938f,
+	0.734375f,
+	0.210938f,
+	0.742188f,
+	0.210938f,
+	0.75f,
+	0.210938f,
+	0.757813f,
+	0.210938f,
+	0.765625f,
+	0.210938f,
+	0.773438f,
+	0.210938f,
+	0.78125f,
+	0.210938f,
+	0.789063f,
+	0.210938f,
+	0.796875f,
+	0.210938f,
+	0.804688f,
+	0.210938f,
+	0.8125f,
+	0.210938f,
+	0.820313f,
+	0.210938f,
+	0.828125f,
+	0.210938f,
+	0.835938f,
+	0.210938f,
+	0.84375f,
+	0.210938f,
+	0.851563f,
+	0.210938f,
+	0.859375f,
+	0.210938f,
+	0.867188f,
+	0.210938f,
+	0.875f,
+	0.210938f,
+	0.882813f,
+	0.210938f,
+	0.890625f,
+	0.210938f,
+	0.898438f,
+	0.210938f,
+	0.90625f,
+	0.210938f,
+	0.914063f,
+	0.210938f,
+	0.921875f,
+	0.210938f,
+	0.929688f,
+	0.210938f,
+	0.9375f,
+	0.210938f,
+	0.945313f,
+	0.210938f,
+	0.953125f,
+	0.210938f,
+	0.960938f,
+	0.210938f,
+	0.96875f,
+	0.210938f,
+	0.976563f,
+	0.210938f,
+	0.984375f,
+	0.210938f,
+	0.992188f,
+	0.210938f,
+	1.0f,
+	0.210938f,
+	0.507813f,
+	0.21875f,
+	0.515625f,
+	0.21875f,
+	0.523438f,
+	0.21875f,
+	0.53125f,
+	0.21875f,
+	0.539063f,
+	0.21875f,
+	0.546875f,
+	0.21875f,
+	0.554688f,
+	0.21875f,
+	0.5625f,
+	0.21875f,
+	0.570313f,
+	0.21875f,
+	0.578125f,
+	0.21875f,
+	0.585938f,
+	0.21875f,
+	0.59375f,
+	0.21875f,
+	0.601563f,
+	0.21875f,
+	0.609375f,
+	0.21875f,
+	0.617188f,
+	0.21875f,
+	0.625f,
+	0.21875f,
+	0.632813f,
+	0.21875f,
+	0.640625f,
+	0.21875f,
+	0.648438f,
+	0.21875f,
+	0.65625f,
+	0.21875f,
+	0.664063f,
+	0.21875f,
+	0.671875f,
+	0.21875f,
+	0.679688f,
+	0.21875f,
+	0.6875f,
+	0.21875f,
+	0.695313f,
+	0.21875f,
+	0.703125f,
+	0.21875f,
+	0.710938f,
+	0.21875f,
+	0.71875f,
+	0.21875f,
+	0.726563f,
+	0.21875f,
+	0.734375f,
+	0.21875f,
+	0.742188f,
+	0.21875f,
+	0.75f,
+	0.21875f,
+	0.757813f,
+	0.21875f,
+	0.765625f,
+	0.21875f,
+	0.773438f,
+	0.21875f,
+	0.78125f,
+	0.21875f,
+	0.789063f,
+	0.21875f,
+	0.796875f,
+	0.21875f,
+	0.804688f,
+	0.21875f,
+	0.8125f,
+	0.21875f,
+	0.820313f,
+	0.21875f,
+	0.828125f,
+	0.21875f,
+	0.835938f,
+	0.21875f,
+	0.84375f,
+	0.21875f,
+	0.851563f,
+	0.21875f,
+	0.859375f,
+	0.21875f,
+	0.867188f,
+	0.21875f,
+	0.875f,
+	0.21875f,
+	0.882813f,
+	0.21875f,
+	0.890625f,
+	0.21875f,
+	0.898438f,
+	0.21875f,
+	0.90625f,
+	0.21875f,
+	0.914063f,
+	0.21875f,
+	0.921875f,
+	0.21875f,
+	0.929688f,
+	0.21875f,
+	0.9375f,
+	0.21875f,
+	0.945313f,
+	0.21875f,
+	0.953125f,
+	0.21875f,
+	0.960938f,
+	0.21875f,
+	0.96875f,
+	0.21875f,
+	0.976563f,
+	0.21875f,
+	0.984375f,
+	0.21875f,
+	0.992188f,
+	0.21875f,
+	1.0f,
+	0.21875f,
+	0.507813f,
+	0.226563f,
+	0.515625f,
+	0.226563f,
+	0.523438f,
+	0.226563f,
+	0.53125f,
+	0.226563f,
+	0.539063f,
+	0.226563f,
+	0.546875f,
+	0.226563f,
+	0.554688f,
+	0.226563f,
+	0.5625f,
+	0.226563f,
+	0.570313f,
+	0.226563f,
+	0.578125f,
+	0.226563f,
+	0.585938f,
+	0.226563f,
+	0.59375f,
+	0.226563f,
+	0.601563f,
+	0.226563f,
+	0.609375f,
+	0.226563f,
+	0.617188f,
+	0.226563f,
+	0.625f,
+	0.226563f,
+	0.632813f,
+	0.226563f,
+	0.640625f,
+	0.226563f,
+	0.648438f,
+	0.226563f,
+	0.65625f,
+	0.226563f,
+	0.664063f,
+	0.226563f,
+	0.671875f,
+	0.226563f,
+	0.679688f,
+	0.226563f,
+	0.6875f,
+	0.226563f,
+	0.695313f,
+	0.226563f,
+	0.703125f,
+	0.226563f,
+	0.710938f,
+	0.226563f,
+	0.71875f,
+	0.226563f,
+	0.726563f,
+	0.226563f,
+	0.734375f,
+	0.226563f,
+	0.742188f,
+	0.226563f,
+	0.75f,
+	0.226563f,
+	0.757813f,
+	0.226563f,
+	0.765625f,
+	0.226563f,
+	0.773438f,
+	0.226563f,
+	0.78125f,
+	0.226563f,
+	0.789063f,
+	0.226563f,
+	0.796875f,
+	0.226563f,
+	0.804688f,
+	0.226563f,
+	0.8125f,
+	0.226563f,
+	0.820313f,
+	0.226563f,
+	0.828125f,
+	0.226563f,
+	0.835938f,
+	0.226563f,
+	0.84375f,
+	0.226563f,
+	0.851563f,
+	0.226563f,
+	0.859375f,
+	0.226563f,
+	0.867188f,
+	0.226563f,
+	0.875f,
+	0.226563f,
+	0.882813f,
+	0.226563f,
+	0.890625f,
+	0.226563f,
+	0.898438f,
+	0.226563f,
+	0.90625f,
+	0.226563f,
+	0.914063f,
+	0.226563f,
+	0.921875f,
+	0.226563f,
+	0.929688f,
+	0.226563f,
+	0.9375f,
+	0.226563f,
+	0.945313f,
+	0.226563f,
+	0.953125f,
+	0.226563f,
+	0.960938f,
+	0.226563f,
+	0.96875f,
+	0.226563f,
+	0.976563f,
+	0.226563f,
+	0.984375f,
+	0.226563f,
+	0.992188f,
+	0.226563f,
+	1.0f,
+	0.226563f,
+	0.507813f,
+	0.234375f,
+	0.515625f,
+	0.234375f,
+	0.523438f,
+	0.234375f,
+	0.53125f,
+	0.234375f,
+	0.539063f,
+	0.234375f,
+	0.546875f,
+	0.234375f,
+	0.554688f,
+	0.234375f,
+	0.5625f,
+	0.234375f,
+	0.570313f,
+	0.234375f,
+	0.578125f,
+	0.234375f,
+	0.585938f,
+	0.234375f,
+	0.59375f,
+	0.234375f,
+	0.601563f,
+	0.234375f,
+	0.609375f,
+	0.234375f,
+	0.617188f,
+	0.234375f,
+	0.625f,
+	0.234375f,
+	0.632813f,
+	0.234375f,
+	0.640625f,
+	0.234375f,
+	0.648438f,
+	0.234375f,
+	0.65625f,
+	0.234375f,
+	0.664063f,
+	0.234375f,
+	0.671875f,
+	0.234375f,
+	0.679688f,
+	0.234375f,
+	0.6875f,
+	0.234375f,
+	0.695313f,
+	0.234375f,
+	0.703125f,
+	0.234375f,
+	0.710938f,
+	0.234375f,
+	0.71875f,
+	0.234375f,
+	0.726563f,
+	0.234375f,
+	0.734375f,
+	0.234375f,
+	0.742188f,
+	0.234375f,
+	0.75f,
+	0.234375f,
+	0.757813f,
+	0.234375f,
+	0.765625f,
+	0.234375f,
+	0.773438f,
+	0.234375f,
+	0.78125f,
+	0.234375f,
+	0.789063f,
+	0.234375f,
+	0.796875f,
+	0.234375f,
+	0.804688f,
+	0.234375f,
+	0.8125f,
+	0.234375f,
+	0.820313f,
+	0.234375f,
+	0.828125f,
+	0.234375f,
+	0.835938f,
+	0.234375f,
+	0.84375f,
+	0.234375f,
+	0.851563f,
+	0.234375f,
+	0.859375f,
+	0.234375f,
+	0.867188f,
+	0.234375f,
+	0.875f,
+	0.234375f,
+	0.882813f,
+	0.234375f,
+	0.890625f,
+	0.234375f,
+	0.898438f,
+	0.234375f,
+	0.90625f,
+	0.234375f,
+	0.914063f,
+	0.234375f,
+	0.921875f,
+	0.234375f,
+	0.929688f,
+	0.234375f,
+	0.9375f,
+	0.234375f,
+	0.945313f,
+	0.234375f,
+	0.953125f,
+	0.234375f,
+	0.960938f,
+	0.234375f,
+	0.96875f,
+	0.234375f,
+	0.976563f,
+	0.234375f,
+	0.984375f,
+	0.234375f,
+	0.992188f,
+	0.234375f,
+	1.0f,
+	0.234375f,
+	0.507813f,
+	0.242188f,
+	0.515625f,
+	0.242188f,
+	0.523438f,
+	0.242188f,
+	0.53125f,
+	0.242188f,
+	0.539063f,
+	0.242188f,
+	0.546875f,
+	0.242188f,
+	0.554688f,
+	0.242188f,
+	0.5625f,
+	0.242188f,
+	0.570313f,
+	0.242188f,
+	0.578125f,
+	0.242188f,
+	0.585938f,
+	0.242188f,
+	0.59375f,
+	0.242188f,
+	0.601563f,
+	0.242188f,
+	0.609375f,
+	0.242188f,
+	0.617188f,
+	0.242188f,
+	0.625f,
+	0.242188f,
+	0.632813f,
+	0.242188f,
+	0.640625f,
+	0.242188f,
+	0.648438f,
+	0.242188f,
+	0.65625f,
+	0.242188f,
+	0.664063f,
+	0.242188f,
+	0.671875f,
+	0.242188f,
+	0.679688f,
+	0.242188f,
+	0.6875f,
+	0.242188f,
+	0.695313f,
+	0.242188f,
+	0.703125f,
+	0.242188f,
+	0.710938f,
+	0.242188f,
+	0.71875f,
+	0.242188f,
+	0.726563f,
+	0.242188f,
+	0.734375f,
+	0.242188f,
+	0.742188f,
+	0.242188f,
+	0.75f,
+	0.242188f,
+	0.757813f,
+	0.242188f,
+	0.765625f,
+	0.242188f,
+	0.773438f,
+	0.242188f,
+	0.78125f,
+	0.242188f,
+	0.789063f,
+	0.242188f,
+	0.796875f,
+	0.242188f,
+	0.804688f,
+	0.242188f,
+	0.8125f,
+	0.242188f,
+	0.820313f,
+	0.242188f,
+	0.828125f,
+	0.242188f,
+	0.835938f,
+	0.242188f,
+	0.84375f,
+	0.242188f,
+	0.851563f,
+	0.242188f,
+	0.859375f,
+	0.242188f,
+	0.867188f,
+	0.242188f,
+	0.875f,
+	0.242188f,
+	0.882813f,
+	0.242188f,
+	0.890625f,
+	0.242188f,
+	0.898438f,
+	0.242188f,
+	0.90625f,
+	0.242188f,
+	0.914063f,
+	0.242188f,
+	0.921875f,
+	0.242188f,
+	0.929688f,
+	0.242188f,
+	0.9375f,
+	0.242188f,
+	0.945313f,
+	0.242188f,
+	0.953125f,
+	0.242188f,
+	0.960938f,
+	0.242188f,
+	0.96875f,
+	0.242188f,
+	0.976563f,
+	0.242188f,
+	0.984375f,
+	0.242188f,
+	0.992188f,
+	0.242188f,
+	1.0f,
+	0.242188f,
+};
+
+unsigned short Landscape01Idx[] = {
+	0,
+	1,
+	2,
+	3,
+	2,
+	1,
+	2,
+	3,
+	4,
+	5,
+	4,
+	3,
+	4,
+	5,
+	6,
+	7,
+	6,
+	5,
+	6,
+	7,
+	8,
+	9,
+	8,
+	7,
+	8,
+	9,
+	10,
+	11,
+	10,
+	9,
+	10,
+	11,
+	12,
+	13,
+	12,
+	11,
+	12,
+	13,
+	14,
+	15,
+	14,
+	13,
+	14,
+	15,
+	16,
+	17,
+	16,
+	15,
+	16,
+	17,
+	18,
+	19,
+	18,
+	17,
+	18,
+	19,
+	20,
+	21,
+	20,
+	19,
+	20,
+	21,
+	22,
+	23,
+	22,
+	21,
+	22,
+	23,
+	24,
+	25,
+	24,
+	23,
+	24,
+	25,
+	26,
+	27,
+	26,
+	25,
+	26,
+	27,
+	28,
+	29,
+	28,
+	27,
+	28,
+	29,
+	30,
+	31,
+	30,
+	29,
+	30,
+	31,
+	32,
+	33,
+	32,
+	31,
+	32,
+	33,
+	34,
+	35,
+	34,
+	33,
+	34,
+	35,
+	36,
+	37,
+	36,
+	35,
+	36,
+	37,
+	38,
+	39,
+	38,
+	37,
+	38,
+	39,
+	40,
+	41,
+	40,
+	39,
+	40,
+	41,
+	42,
+	43,
+	42,
+	41,
+	42,
+	43,
+	44,
+	45,
+	44,
+	43,
+	44,
+	45,
+	46,
+	47,
+	46,
+	45,
+	46,
+	47,
+	48,
+	49,
+	48,
+	47,
+	48,
+	49,
+	50,
+	51,
+	50,
+	49,
+	50,
+	51,
+	52,
+	53,
+	52,
+	51,
+	52,
+	53,
+	54,
+	55,
+	54,
+	53,
+	54,
+	55,
+	56,
+	57,
+	56,
+	55,
+	56,
+	57,
+	58,
+	59,
+	58,
+	57,
+	58,
+	59,
+	60,
+	61,
+	60,
+	59,
+	60,
+	61,
+	62,
+	63,
+	62,
+	61,
+	62,
+	63,
+	64,
+	65,
+	64,
+	63,
+	64,
+	65,
+	66,
+	67,
+	66,
+	65,
+	66,
+	67,
+	68,
+	69,
+	68,
+	67,
+	68,
+	69,
+	70,
+	71,
+	70,
+	69,
+	70,
+	71,
+	72,
+	73,
+	72,
+	71,
+	72,
+	73,
+	74,
+	75,
+	74,
+	73,
+	74,
+	75,
+	76,
+	77,
+	76,
+	75,
+	76,
+	77,
+	78,
+	79,
+	78,
+	77,
+	78,
+	79,
+	80,
+	81,
+	80,
+	79,
+	80,
+	81,
+	82,
+	83,
+	82,
+	81,
+	82,
+	83,
+	84,
+	85,
+	84,
+	83,
+	84,
+	85,
+	86,
+	87,
+	86,
+	85,
+	86,
+	87,
+	88,
+	89,
+	88,
+	87,
+	88,
+	89,
+	90,
+	91,
+	90,
+	89,
+	90,
+	91,
+	92,
+	93,
+	92,
+	91,
+	92,
+	93,
+	94,
+	95,
+	94,
+	93,
+	94,
+	95,
+	96,
+	97,
+	96,
+	95,
+	96,
+	97,
+	98,
+	99,
+	98,
+	97,
+	98,
+	99,
+	100,
+	101,
+	100,
+	99,
+	100,
+	101,
+	102,
+	103,
+	102,
+	101,
+	102,
+	103,
+	104,
+	105,
+	104,
+	103,
+	104,
+	105,
+	106,
+	107,
+	106,
+	105,
+	106,
+	107,
+	108,
+	109,
+	108,
+	107,
+	108,
+	109,
+	110,
+	111,
+	110,
+	109,
+	110,
+	111,
+	112,
+	113,
+	112,
+	111,
+	112,
+	113,
+	114,
+	115,
+	114,
+	113,
+	114,
+	115,
+	116,
+	117,
+	116,
+	115,
+	116,
+	117,
+	118,
+	119,
+	118,
+	117,
+	118,
+	119,
+	120,
+	121,
+	120,
+	119,
+	120,
+	121,
+	122,
+	123,
+	122,
+	121,
+	122,
+	123,
+	124,
+	125,
+	124,
+	123,
+	124,
+	125,
+	126,
+	127,
+	126,
+	125,
+	128,
+	0,
+	129,
+	2,
+	129,
+	0,
+	129,
+	2,
+	130,
+	4,
+	130,
+	2,
+	130,
+	4,
+	131,
+	6,
+	131,
+	4,
+	131,
+	6,
+	132,
+	8,
+	132,
+	6,
+	132,
+	8,
+	133,
+	10,
+	133,
+	8,
+	133,
+	10,
+	134,
+	12,
+	134,
+	10,
+	134,
+	12,
+	135,
+	14,
+	135,
+	12,
+	135,
+	14,
+	136,
+	16,
+	136,
+	14,
+	136,
+	16,
+	137,
+	18,
+	137,
+	16,
+	137,
+	18,
+	138,
+	20,
+	138,
+	18,
+	138,
+	20,
+	139,
+	22,
+	139,
+	20,
+	139,
+	22,
+	140,
+	24,
+	140,
+	22,
+	140,
+	24,
+	141,
+	26,
+	141,
+	24,
+	141,
+	26,
+	142,
+	28,
+	142,
+	26,
+	142,
+	28,
+	143,
+	30,
+	143,
+	28,
+	143,
+	30,
+	144,
+	32,
+	144,
+	30,
+	144,
+	32,
+	145,
+	34,
+	145,
+	32,
+	145,
+	34,
+	146,
+	36,
+	146,
+	34,
+	146,
+	36,
+	147,
+	38,
+	147,
+	36,
+	147,
+	38,
+	148,
+	40,
+	148,
+	38,
+	148,
+	40,
+	149,
+	42,
+	149,
+	40,
+	149,
+	42,
+	150,
+	44,
+	150,
+	42,
+	150,
+	44,
+	151,
+	46,
+	151,
+	44,
+	151,
+	46,
+	152,
+	48,
+	152,
+	46,
+	152,
+	48,
+	153,
+	50,
+	153,
+	48,
+	153,
+	50,
+	154,
+	52,
+	154,
+	50,
+	154,
+	52,
+	155,
+	54,
+	155,
+	52,
+	155,
+	54,
+	156,
+	56,
+	156,
+	54,
+	156,
+	56,
+	157,
+	58,
+	157,
+	56,
+	157,
+	58,
+	158,
+	60,
+	158,
+	58,
+	158,
+	60,
+	159,
+	62,
+	159,
+	60,
+	159,
+	62,
+	160,
+	64,
+	160,
+	62,
+	160,
+	64,
+	161,
+	66,
+	161,
+	64,
+	161,
+	66,
+	162,
+	68,
+	162,
+	66,
+	162,
+	68,
+	163,
+	70,
+	163,
+	68,
+	163,
+	70,
+	164,
+	72,
+	164,
+	70,
+	164,
+	72,
+	165,
+	74,
+	165,
+	72,
+	165,
+	74,
+	166,
+	76,
+	166,
+	74,
+	166,
+	76,
+	167,
+	78,
+	167,
+	76,
+	167,
+	78,
+	168,
+	80,
+	168,
+	78,
+	168,
+	80,
+	169,
+	82,
+	169,
+	80,
+	169,
+	82,
+	170,
+	84,
+	170,
+	82,
+	170,
+	84,
+	171,
+	86,
+	171,
+	84,
+	171,
+	86,
+	172,
+	88,
+	172,
+	86,
+	172,
+	88,
+	173,
+	90,
+	173,
+	88,
+	173,
+	90,
+	174,
+	92,
+	174,
+	90,
+	174,
+	92,
+	175,
+	94,
+	175,
+	92,
+	175,
+	94,
+	176,
+	96,
+	176,
+	94,
+	176,
+	96,
+	177,
+	98,
+	177,
+	96,
+	177,
+	98,
+	178,
+	100,
+	178,
+	98,
+	178,
+	100,
+	179,
+	102,
+	179,
+	100,
+	179,
+	102,
+	180,
+	104,
+	180,
+	102,
+	180,
+	104,
+	181,
+	106,
+	181,
+	104,
+	181,
+	106,
+	182,
+	108,
+	182,
+	106,
+	182,
+	108,
+	183,
+	110,
+	183,
+	108,
+	183,
+	110,
+	184,
+	112,
+	184,
+	110,
+	184,
+	112,
+	185,
+	114,
+	185,
+	112,
+	185,
+	114,
+	186,
+	116,
+	186,
+	114,
+	186,
+	116,
+	187,
+	118,
+	187,
+	116,
+	187,
+	118,
+	188,
+	120,
+	188,
+	118,
+	188,
+	120,
+	189,
+	122,
+	189,
+	120,
+	189,
+	122,
+	190,
+	124,
+	190,
+	122,
+	190,
+	124,
+	191,
+	126,
+	191,
+	124,
+	192,
+	128,
+	193,
+	129,
+	193,
+	128,
+	193,
+	129,
+	194,
+	130,
+	194,
+	129,
+	194,
+	130,
+	195,
+	131,
+	195,
+	130,
+	195,
+	131,
+	196,
+	132,
+	196,
+	131,
+	196,
+	132,
+	197,
+	133,
+	197,
+	132,
+	197,
+	133,
+	198,
+	134,
+	198,
+	133,
+	198,
+	134,
+	199,
+	135,
+	199,
+	134,
+	199,
+	135,
+	200,
+	136,
+	200,
+	135,
+	200,
+	136,
+	201,
+	137,
+	201,
+	136,
+	201,
+	137,
+	202,
+	138,
+	202,
+	137,
+	202,
+	138,
+	203,
+	139,
+	203,
+	138,
+	203,
+	139,
+	204,
+	140,
+	204,
+	139,
+	204,
+	140,
+	205,
+	141,
+	205,
+	140,
+	205,
+	141,
+	206,
+	142,
+	206,
+	141,
+	206,
+	142,
+	207,
+	143,
+	207,
+	142,
+	207,
+	143,
+	208,
+	144,
+	208,
+	143,
+	208,
+	144,
+	209,
+	145,
+	209,
+	144,
+	209,
+	145,
+	210,
+	146,
+	210,
+	145,
+	210,
+	146,
+	211,
+	147,
+	211,
+	146,
+	211,
+	147,
+	212,
+	148,
+	212,
+	147,
+	212,
+	148,
+	213,
+	149,
+	213,
+	148,
+	213,
+	149,
+	214,
+	150,
+	214,
+	149,
+	214,
+	150,
+	215,
+	151,
+	215,
+	150,
+	215,
+	151,
+	216,
+	152,
+	216,
+	151,
+	216,
+	152,
+	217,
+	153,
+	217,
+	152,
+	217,
+	153,
+	218,
+	154,
+	218,
+	153,
+	218,
+	154,
+	219,
+	155,
+	219,
+	154,
+	219,
+	155,
+	220,
+	156,
+	220,
+	155,
+	220,
+	156,
+	221,
+	157,
+	221,
+	156,
+	221,
+	157,
+	222,
+	158,
+	222,
+	157,
+	222,
+	158,
+	223,
+	159,
+	223,
+	158,
+	223,
+	159,
+	224,
+	160,
+	224,
+	159,
+	224,
+	160,
+	225,
+	161,
+	225,
+	160,
+	225,
+	161,
+	226,
+	162,
+	226,
+	161,
+	226,
+	162,
+	227,
+	163,
+	227,
+	162,
+	227,
+	163,
+	228,
+	164,
+	228,
+	163,
+	228,
+	164,
+	229,
+	165,
+	229,
+	164,
+	229,
+	165,
+	230,
+	166,
+	230,
+	165,
+	230,
+	166,
+	231,
+	167,
+	231,
+	166,
+	231,
+	167,
+	232,
+	168,
+	232,
+	167,
+	232,
+	168,
+	233,
+	169,
+	233,
+	168,
+	233,
+	169,
+	234,
+	170,
+	234,
+	169,
+	234,
+	170,
+	235,
+	171,
+	235,
+	170,
+	235,
+	171,
+	236,
+	172,
+	236,
+	171,
+	236,
+	172,
+	237,
+	173,
+	237,
+	172,
+	237,
+	173,
+	238,
+	174,
+	238,
+	173,
+	238,
+	174,
+	239,
+	175,
+	239,
+	174,
+	239,
+	175,
+	240,
+	176,
+	240,
+	175,
+	240,
+	176,
+	241,
+	177,
+	241,
+	176,
+	241,
+	177,
+	242,
+	178,
+	242,
+	177,
+	242,
+	178,
+	243,
+	179,
+	243,
+	178,
+	243,
+	179,
+	244,
+	180,
+	244,
+	179,
+	244,
+	180,
+	245,
+	181,
+	245,
+	180,
+	245,
+	181,
+	246,
+	182,
+	246,
+	181,
+	246,
+	182,
+	247,
+	183,
+	247,
+	182,
+	247,
+	183,
+	248,
+	184,
+	248,
+	183,
+	248,
+	184,
+	249,
+	185,
+	249,
+	184,
+	249,
+	185,
+	250,
+	186,
+	250,
+	185,
+	250,
+	186,
+	251,
+	187,
+	251,
+	186,
+	251,
+	187,
+	252,
+	188,
+	252,
+	187,
+	252,
+	188,
+	253,
+	189,
+	253,
+	188,
+	253,
+	189,
+	254,
+	190,
+	254,
+	189,
+	254,
+	190,
+	255,
+	191,
+	255,
+	190,
+	256,
+	192,
+	257,
+	193,
+	257,
+	192,
+	257,
+	193,
+	258,
+	194,
+	258,
+	193,
+	258,
+	194,
+	259,
+	195,
+	259,
+	194,
+	259,
+	195,
+	260,
+	196,
+	260,
+	195,
+	260,
+	196,
+	261,
+	197,
+	261,
+	196,
+	261,
+	197,
+	262,
+	198,
+	262,
+	197,
+	262,
+	198,
+	263,
+	199,
+	263,
+	198,
+	263,
+	199,
+	264,
+	200,
+	264,
+	199,
+	264,
+	200,
+	265,
+	201,
+	265,
+	200,
+	265,
+	201,
+	266,
+	202,
+	266,
+	201,
+	266,
+	202,
+	267,
+	203,
+	267,
+	202,
+	267,
+	203,
+	268,
+	204,
+	268,
+	203,
+	268,
+	204,
+	269,
+	205,
+	269,
+	204,
+	269,
+	205,
+	270,
+	206,
+	270,
+	205,
+	270,
+	206,
+	271,
+	207,
+	271,
+	206,
+	271,
+	207,
+	272,
+	208,
+	272,
+	207,
+	272,
+	208,
+	273,
+	209,
+	273,
+	208,
+	273,
+	209,
+	274,
+	210,
+	274,
+	209,
+	274,
+	210,
+	275,
+	211,
+	275,
+	210,
+	275,
+	211,
+	276,
+	212,
+	276,
+	211,
+	276,
+	212,
+	277,
+	213,
+	277,
+	212,
+	277,
+	213,
+	278,
+	214,
+	278,
+	213,
+	278,
+	214,
+	279,
+	215,
+	279,
+	214,
+	279,
+	215,
+	280,
+	216,
+	280,
+	215,
+	280,
+	216,
+	281,
+	217,
+	281,
+	216,
+	281,
+	217,
+	282,
+	218,
+	282,
+	217,
+	282,
+	218,
+	283,
+	219,
+	283,
+	218,
+	283,
+	219,
+	284,
+	220,
+	284,
+	219,
+	284,
+	220,
+	285,
+	221,
+	285,
+	220,
+	285,
+	221,
+	286,
+	222,
+	286,
+	221,
+	286,
+	222,
+	287,
+	223,
+	287,
+	222,
+	287,
+	223,
+	288,
+	224,
+	288,
+	223,
+	288,
+	224,
+	289,
+	225,
+	289,
+	224,
+	289,
+	225,
+	290,
+	226,
+	290,
+	225,
+	290,
+	226,
+	291,
+	227,
+	291,
+	226,
+	291,
+	227,
+	292,
+	228,
+	292,
+	227,
+	292,
+	228,
+	293,
+	229,
+	293,
+	228,
+	293,
+	229,
+	294,
+	230,
+	294,
+	229,
+	294,
+	230,
+	295,
+	231,
+	295,
+	230,
+	295,
+	231,
+	296,
+	232,
+	296,
+	231,
+	296,
+	232,
+	297,
+	233,
+	297,
+	232,
+	297,
+	233,
+	298,
+	234,
+	298,
+	233,
+	298,
+	234,
+	299,
+	235,
+	299,
+	234,
+	299,
+	235,
+	300,
+	236,
+	300,
+	235,
+	300,
+	236,
+	301,
+	237,
+	301,
+	236,
+	301,
+	237,
+	302,
+	238,
+	302,
+	237,
+	302,
+	238,
+	303,
+	239,
+	303,
+	238,
+	303,
+	239,
+	304,
+	240,
+	304,
+	239,
+	304,
+	240,
+	305,
+	241,
+	305,
+	240,
+	305,
+	241,
+	306,
+	242,
+	306,
+	241,
+	306,
+	242,
+	307,
+	243,
+	307,
+	242,
+	307,
+	243,
+	308,
+	244,
+	308,
+	243,
+	308,
+	244,
+	309,
+	245,
+	309,
+	244,
+	309,
+	245,
+	310,
+	246,
+	310,
+	245,
+	310,
+	246,
+	311,
+	247,
+	311,
+	246,
+	311,
+	247,
+	312,
+	248,
+	312,
+	247,
+	312,
+	248,
+	313,
+	249,
+	313,
+	248,
+	313,
+	249,
+	314,
+	250,
+	314,
+	249,
+	314,
+	250,
+	315,
+	251,
+	315,
+	250,
+	315,
+	251,
+	316,
+	252,
+	316,
+	251,
+	316,
+	252,
+	317,
+	253,
+	317,
+	252,
+	317,
+	253,
+	318,
+	254,
+	318,
+	253,
+	318,
+	254,
+	319,
+	255,
+	319,
+	254,
+	320,
+	256,
+	321,
+	257,
+	321,
+	256,
+	321,
+	257,
+	322,
+	258,
+	322,
+	257,
+	322,
+	258,
+	323,
+	259,
+	323,
+	258,
+	323,
+	259,
+	324,
+	260,
+	324,
+	259,
+	324,
+	260,
+	325,
+	261,
+	325,
+	260,
+	325,
+	261,
+	326,
+	262,
+	326,
+	261,
+	326,
+	262,
+	327,
+	263,
+	327,
+	262,
+	327,
+	263,
+	328,
+	264,
+	328,
+	263,
+	328,
+	264,
+	329,
+	265,
+	329,
+	264,
+	329,
+	265,
+	330,
+	266,
+	330,
+	265,
+	330,
+	266,
+	331,
+	267,
+	331,
+	266,
+	331,
+	267,
+	332,
+	268,
+	332,
+	267,
+	332,
+	268,
+	333,
+	269,
+	333,
+	268,
+	333,
+	269,
+	334,
+	270,
+	334,
+	269,
+	334,
+	270,
+	335,
+	271,
+	335,
+	270,
+	335,
+	271,
+	336,
+	272,
+	336,
+	271,
+	336,
+	272,
+	337,
+	273,
+	337,
+	272,
+	337,
+	273,
+	338,
+	274,
+	338,
+	273,
+	338,
+	274,
+	339,
+	275,
+	339,
+	274,
+	339,
+	275,
+	340,
+	276,
+	340,
+	275,
+	340,
+	276,
+	341,
+	277,
+	341,
+	276,
+	341,
+	277,
+	342,
+	278,
+	342,
+	277,
+	342,
+	278,
+	343,
+	279,
+	343,
+	278,
+	343,
+	279,
+	344,
+	280,
+	344,
+	279,
+	344,
+	280,
+	345,
+	281,
+	345,
+	280,
+	345,
+	281,
+	346,
+	282,
+	346,
+	281,
+	346,
+	282,
+	347,
+	283,
+	347,
+	282,
+	347,
+	283,
+	348,
+	284,
+	348,
+	283,
+	348,
+	284,
+	349,
+	285,
+	349,
+	284,
+	349,
+	285,
+	350,
+	286,
+	350,
+	285,
+	350,
+	286,
+	351,
+	287,
+	351,
+	286,
+	351,
+	287,
+	352,
+	288,
+	352,
+	287,
+	352,
+	288,
+	353,
+	289,
+	353,
+	288,
+	353,
+	289,
+	354,
+	290,
+	354,
+	289,
+	354,
+	290,
+	355,
+	291,
+	355,
+	290,
+	355,
+	291,
+	356,
+	292,
+	356,
+	291,
+	356,
+	292,
+	357,
+	293,
+	357,
+	292,
+	357,
+	293,
+	358,
+	294,
+	358,
+	293,
+	358,
+	294,
+	359,
+	295,
+	359,
+	294,
+	359,
+	295,
+	360,
+	296,
+	360,
+	295,
+	360,
+	296,
+	361,
+	297,
+	361,
+	296,
+	361,
+	297,
+	362,
+	298,
+	362,
+	297,
+	362,
+	298,
+	363,
+	299,
+	363,
+	298,
+	363,
+	299,
+	364,
+	300,
+	364,
+	299,
+	364,
+	300,
+	365,
+	301,
+	365,
+	300,
+	365,
+	301,
+	366,
+	302,
+	366,
+	301,
+	366,
+	302,
+	367,
+	303,
+	367,
+	302,
+	367,
+	303,
+	368,
+	304,
+	368,
+	303,
+	368,
+	304,
+	369,
+	305,
+	369,
+	304,
+	369,
+	305,
+	370,
+	306,
+	370,
+	305,
+	370,
+	306,
+	371,
+	307,
+	371,
+	306,
+	371,
+	307,
+	372,
+	308,
+	372,
+	307,
+	372,
+	308,
+	373,
+	309,
+	373,
+	308,
+	373,
+	309,
+	374,
+	310,
+	374,
+	309,
+	374,
+	310,
+	375,
+	311,
+	375,
+	310,
+	375,
+	311,
+	376,
+	312,
+	376,
+	311,
+	376,
+	312,
+	377,
+	313,
+	377,
+	312,
+	377,
+	313,
+	378,
+	314,
+	378,
+	313,
+	378,
+	314,
+	379,
+	315,
+	379,
+	314,
+	379,
+	315,
+	380,
+	316,
+	380,
+	315,
+	380,
+	316,
+	381,
+	317,
+	381,
+	316,
+	381,
+	317,
+	382,
+	318,
+	382,
+	317,
+	382,
+	318,
+	383,
+	319,
+	383,
+	318,
+	384,
+	320,
+	385,
+	321,
+	385,
+	320,
+	385,
+	321,
+	386,
+	322,
+	386,
+	321,
+	386,
+	322,
+	387,
+	323,
+	387,
+	322,
+	387,
+	323,
+	388,
+	324,
+	388,
+	323,
+	388,
+	324,
+	389,
+	325,
+	389,
+	324,
+	389,
+	325,
+	390,
+	326,
+	390,
+	325,
+	390,
+	326,
+	391,
+	327,
+	391,
+	326,
+	391,
+	327,
+	392,
+	328,
+	392,
+	327,
+	392,
+	328,
+	393,
+	329,
+	393,
+	328,
+	393,
+	329,
+	394,
+	330,
+	394,
+	329,
+	394,
+	330,
+	395,
+	331,
+	395,
+	330,
+	395,
+	331,
+	396,
+	332,
+	396,
+	331,
+	396,
+	332,
+	397,
+	333,
+	397,
+	332,
+	397,
+	333,
+	398,
+	334,
+	398,
+	333,
+	398,
+	334,
+	399,
+	335,
+	399,
+	334,
+	399,
+	335,
+	400,
+	336,
+	400,
+	335,
+	400,
+	336,
+	401,
+	337,
+	401,
+	336,
+	401,
+	337,
+	402,
+	338,
+	402,
+	337,
+	402,
+	338,
+	403,
+	339,
+	403,
+	338,
+	403,
+	339,
+	404,
+	340,
+	404,
+	339,
+	404,
+	340,
+	405,
+	341,
+	405,
+	340,
+	405,
+	341,
+	406,
+	342,
+	406,
+	341,
+	406,
+	342,
+	407,
+	343,
+	407,
+	342,
+	407,
+	343,
+	408,
+	344,
+	408,
+	343,
+	408,
+	344,
+	409,
+	345,
+	409,
+	344,
+	409,
+	345,
+	410,
+	346,
+	410,
+	345,
+	410,
+	346,
+	411,
+	347,
+	411,
+	346,
+	411,
+	347,
+	412,
+	348,
+	412,
+	347,
+	412,
+	348,
+	413,
+	349,
+	413,
+	348,
+	413,
+	349,
+	414,
+	350,
+	414,
+	349,
+	414,
+	350,
+	415,
+	351,
+	415,
+	350,
+	415,
+	351,
+	416,
+	352,
+	416,
+	351,
+	416,
+	352,
+	417,
+	353,
+	417,
+	352,
+	417,
+	353,
+	418,
+	354,
+	418,
+	353,
+	418,
+	354,
+	419,
+	355,
+	419,
+	354,
+	419,
+	355,
+	420,
+	356,
+	420,
+	355,
+	420,
+	356,
+	421,
+	357,
+	421,
+	356,
+	421,
+	357,
+	422,
+	358,
+	422,
+	357,
+	422,
+	358,
+	423,
+	359,
+	423,
+	358,
+	423,
+	359,
+	424,
+	360,
+	424,
+	359,
+	424,
+	360,
+	425,
+	361,
+	425,
+	360,
+	425,
+	361,
+	426,
+	362,
+	426,
+	361,
+	426,
+	362,
+	427,
+	363,
+	427,
+	362,
+	427,
+	363,
+	428,
+	364,
+	428,
+	363,
+	428,
+	364,
+	429,
+	365,
+	429,
+	364,
+	429,
+	365,
+	430,
+	366,
+	430,
+	365,
+	430,
+	366,
+	431,
+	367,
+	431,
+	366,
+	431,
+	367,
+	432,
+	368,
+	432,
+	367,
+	432,
+	368,
+	433,
+	369,
+	433,
+	368,
+	433,
+	369,
+	434,
+	370,
+	434,
+	369,
+	434,
+	370,
+	435,
+	371,
+	435,
+	370,
+	435,
+	371,
+	436,
+	372,
+	436,
+	371,
+	436,
+	372,
+	437,
+	373,
+	437,
+	372,
+	437,
+	373,
+	438,
+	374,
+	438,
+	373,
+	438,
+	374,
+	439,
+	375,
+	439,
+	374,
+	439,
+	375,
+	440,
+	376,
+	440,
+	375,
+	440,
+	376,
+	441,
+	377,
+	441,
+	376,
+	441,
+	377,
+	442,
+	378,
+	442,
+	377,
+	442,
+	378,
+	443,
+	379,
+	443,
+	378,
+	443,
+	379,
+	444,
+	380,
+	444,
+	379,
+	444,
+	380,
+	445,
+	381,
+	445,
+	380,
+	445,
+	381,
+	446,
+	382,
+	446,
+	381,
+	446,
+	382,
+	447,
+	383,
+	447,
+	382,
+	448,
+	384,
+	449,
+	385,
+	449,
+	384,
+	449,
+	385,
+	450,
+	386,
+	450,
+	385,
+	450,
+	386,
+	451,
+	387,
+	451,
+	386,
+	451,
+	387,
+	452,
+	388,
+	452,
+	387,
+	452,
+	388,
+	453,
+	389,
+	453,
+	388,
+	453,
+	389,
+	454,
+	390,
+	454,
+	389,
+	454,
+	390,
+	455,
+	391,
+	455,
+	390,
+	455,
+	391,
+	456,
+	392,
+	456,
+	391,
+	456,
+	392,
+	457,
+	393,
+	457,
+	392,
+	457,
+	393,
+	458,
+	394,
+	458,
+	393,
+	458,
+	394,
+	459,
+	395,
+	459,
+	394,
+	459,
+	395,
+	460,
+	396,
+	460,
+	395,
+	460,
+	396,
+	461,
+	397,
+	461,
+	396,
+	461,
+	397,
+	462,
+	398,
+	462,
+	397,
+	462,
+	398,
+	463,
+	399,
+	463,
+	398,
+	463,
+	399,
+	464,
+	400,
+	464,
+	399,
+	464,
+	400,
+	465,
+	401,
+	465,
+	400,
+	465,
+	401,
+	466,
+	402,
+	466,
+	401,
+	466,
+	402,
+	467,
+	403,
+	467,
+	402,
+	467,
+	403,
+	468,
+	404,
+	468,
+	403,
+	468,
+	404,
+	469,
+	405,
+	469,
+	404,
+	469,
+	405,
+	470,
+	406,
+	470,
+	405,
+	470,
+	406,
+	471,
+	407,
+	471,
+	406,
+	471,
+	407,
+	472,
+	408,
+	472,
+	407,
+	472,
+	408,
+	473,
+	409,
+	473,
+	408,
+	473,
+	409,
+	474,
+	410,
+	474,
+	409,
+	474,
+	410,
+	475,
+	411,
+	475,
+	410,
+	475,
+	411,
+	476,
+	412,
+	476,
+	411,
+	476,
+	412,
+	477,
+	413,
+	477,
+	412,
+	477,
+	413,
+	478,
+	414,
+	478,
+	413,
+	478,
+	414,
+	479,
+	415,
+	479,
+	414,
+	479,
+	415,
+	480,
+	416,
+	480,
+	415,
+	480,
+	416,
+	481,
+	417,
+	481,
+	416,
+	481,
+	417,
+	482,
+	418,
+	482,
+	417,
+	482,
+	418,
+	483,
+	419,
+	483,
+	418,
+	483,
+	419,
+	484,
+	420,
+	484,
+	419,
+	484,
+	420,
+	485,
+	421,
+	485,
+	420,
+	485,
+	421,
+	486,
+	422,
+	486,
+	421,
+	486,
+	422,
+	487,
+	423,
+	487,
+	422,
+	487,
+	423,
+	488,
+	424,
+	488,
+	423,
+	488,
+	424,
+	489,
+	425,
+	489,
+	424,
+	489,
+	425,
+	490,
+	426,
+	490,
+	425,
+	490,
+	426,
+	491,
+	427,
+	491,
+	426,
+	491,
+	427,
+	492,
+	428,
+	492,
+	427,
+	492,
+	428,
+	493,
+	429,
+	493,
+	428,
+	493,
+	429,
+	494,
+	430,
+	494,
+	429,
+	494,
+	430,
+	495,
+	431,
+	495,
+	430,
+	495,
+	431,
+	496,
+	432,
+	496,
+	431,
+	496,
+	432,
+	497,
+	433,
+	497,
+	432,
+	497,
+	433,
+	498,
+	434,
+	498,
+	433,
+	498,
+	434,
+	499,
+	435,
+	499,
+	434,
+	499,
+	435,
+	500,
+	436,
+	500,
+	435,
+	500,
+	436,
+	501,
+	437,
+	501,
+	436,
+	501,
+	437,
+	502,
+	438,
+	502,
+	437,
+	502,
+	438,
+	503,
+	439,
+	503,
+	438,
+	503,
+	439,
+	504,
+	440,
+	504,
+	439,
+	504,
+	440,
+	505,
+	441,
+	505,
+	440,
+	505,
+	441,
+	506,
+	442,
+	506,
+	441,
+	506,
+	442,
+	507,
+	443,
+	507,
+	442,
+	507,
+	443,
+	508,
+	444,
+	508,
+	443,
+	508,
+	444,
+	509,
+	445,
+	509,
+	444,
+	509,
+	445,
+	510,
+	446,
+	510,
+	445,
+	510,
+	446,
+	511,
+	447,
+	511,
+	446,
+	512,
+	448,
+	513,
+	449,
+	513,
+	448,
+	513,
+	449,
+	514,
+	450,
+	514,
+	449,
+	514,
+	450,
+	515,
+	451,
+	515,
+	450,
+	515,
+	451,
+	516,
+	452,
+	516,
+	451,
+	516,
+	452,
+	517,
+	453,
+	517,
+	452,
+	517,
+	453,
+	518,
+	454,
+	518,
+	453,
+	518,
+	454,
+	519,
+	455,
+	519,
+	454,
+	519,
+	455,
+	520,
+	456,
+	520,
+	455,
+	520,
+	456,
+	521,
+	457,
+	521,
+	456,
+	521,
+	457,
+	522,
+	458,
+	522,
+	457,
+	522,
+	458,
+	523,
+	459,
+	523,
+	458,
+	523,
+	459,
+	524,
+	460,
+	524,
+	459,
+	524,
+	460,
+	525,
+	461,
+	525,
+	460,
+	525,
+	461,
+	526,
+	462,
+	526,
+	461,
+	526,
+	462,
+	527,
+	463,
+	527,
+	462,
+	527,
+	463,
+	528,
+	464,
+	528,
+	463,
+	528,
+	464,
+	529,
+	465,
+	529,
+	464,
+	529,
+	465,
+	530,
+	466,
+	530,
+	465,
+	530,
+	466,
+	531,
+	467,
+	531,
+	466,
+	531,
+	467,
+	532,
+	468,
+	532,
+	467,
+	532,
+	468,
+	533,
+	469,
+	533,
+	468,
+	533,
+	469,
+	534,
+	470,
+	534,
+	469,
+	534,
+	470,
+	535,
+	471,
+	535,
+	470,
+	535,
+	471,
+	536,
+	472,
+	536,
+	471,
+	536,
+	472,
+	537,
+	473,
+	537,
+	472,
+	537,
+	473,
+	538,
+	474,
+	538,
+	473,
+	538,
+	474,
+	539,
+	475,
+	539,
+	474,
+	539,
+	475,
+	540,
+	476,
+	540,
+	475,
+	540,
+	476,
+	541,
+	477,
+	541,
+	476,
+	541,
+	477,
+	542,
+	478,
+	542,
+	477,
+	542,
+	478,
+	543,
+	479,
+	543,
+	478,
+	543,
+	479,
+	544,
+	480,
+	544,
+	479,
+	544,
+	480,
+	545,
+	481,
+	545,
+	480,
+	545,
+	481,
+	546,
+	482,
+	546,
+	481,
+	546,
+	482,
+	547,
+	483,
+	547,
+	482,
+	547,
+	483,
+	548,
+	484,
+	548,
+	483,
+	548,
+	484,
+	549,
+	485,
+	549,
+	484,
+	549,
+	485,
+	550,
+	486,
+	550,
+	485,
+	550,
+	486,
+	551,
+	487,
+	551,
+	486,
+	551,
+	487,
+	552,
+	488,
+	552,
+	487,
+	552,
+	488,
+	553,
+	489,
+	553,
+	488,
+	553,
+	489,
+	554,
+	490,
+	554,
+	489,
+	554,
+	490,
+	555,
+	491,
+	555,
+	490,
+	555,
+	491,
+	556,
+	492,
+	556,
+	491,
+	556,
+	492,
+	557,
+	493,
+	557,
+	492,
+	557,
+	493,
+	558,
+	494,
+	558,
+	493,
+	558,
+	494,
+	559,
+	495,
+	559,
+	494,
+	559,
+	495,
+	560,
+	496,
+	560,
+	495,
+	560,
+	496,
+	561,
+	497,
+	561,
+	496,
+	561,
+	497,
+	562,
+	498,
+	562,
+	497,
+	562,
+	498,
+	563,
+	499,
+	563,
+	498,
+	563,
+	499,
+	564,
+	500,
+	564,
+	499,
+	564,
+	500,
+	565,
+	501,
+	565,
+	500,
+	565,
+	501,
+	566,
+	502,
+	566,
+	501,
+	566,
+	502,
+	567,
+	503,
+	567,
+	502,
+	567,
+	503,
+	568,
+	504,
+	568,
+	503,
+	568,
+	504,
+	569,
+	505,
+	569,
+	504,
+	569,
+	505,
+	570,
+	506,
+	570,
+	505,
+	570,
+	506,
+	571,
+	507,
+	571,
+	506,
+	571,
+	507,
+	572,
+	508,
+	572,
+	507,
+	572,
+	508,
+	573,
+	509,
+	573,
+	508,
+	573,
+	509,
+	574,
+	510,
+	574,
+	509,
+	574,
+	510,
+	575,
+	511,
+	575,
+	510,
+	576,
+	512,
+	577,
+	513,
+	577,
+	512,
+	577,
+	513,
+	578,
+	514,
+	578,
+	513,
+	578,
+	514,
+	579,
+	515,
+	579,
+	514,
+	579,
+	515,
+	580,
+	516,
+	580,
+	515,
+	580,
+	516,
+	581,
+	517,
+	581,
+	516,
+	581,
+	517,
+	582,
+	518,
+	582,
+	517,
+	582,
+	518,
+	583,
+	519,
+	583,
+	518,
+	583,
+	519,
+	584,
+	520,
+	584,
+	519,
+	584,
+	520,
+	585,
+	521,
+	585,
+	520,
+	585,
+	521,
+	586,
+	522,
+	586,
+	521,
+	586,
+	522,
+	587,
+	523,
+	587,
+	522,
+	587,
+	523,
+	588,
+	524,
+	588,
+	523,
+	588,
+	524,
+	589,
+	525,
+	589,
+	524,
+	589,
+	525,
+	590,
+	526,
+	590,
+	525,
+	590,
+	526,
+	591,
+	527,
+	591,
+	526,
+	591,
+	527,
+	592,
+	528,
+	592,
+	527,
+	592,
+	528,
+	593,
+	529,
+	593,
+	528,
+	593,
+	529,
+	594,
+	530,
+	594,
+	529,
+	594,
+	530,
+	595,
+	531,
+	595,
+	530,
+	595,
+	531,
+	596,
+	532,
+	596,
+	531,
+	596,
+	532,
+	597,
+	533,
+	597,
+	532,
+	597,
+	533,
+	598,
+	534,
+	598,
+	533,
+	598,
+	534,
+	599,
+	535,
+	599,
+	534,
+	599,
+	535,
+	600,
+	536,
+	600,
+	535,
+	600,
+	536,
+	601,
+	537,
+	601,
+	536,
+	601,
+	537,
+	602,
+	538,
+	602,
+	537,
+	602,
+	538,
+	603,
+	539,
+	603,
+	538,
+	603,
+	539,
+	604,
+	540,
+	604,
+	539,
+	604,
+	540,
+	605,
+	541,
+	605,
+	540,
+	605,
+	541,
+	606,
+	542,
+	606,
+	541,
+	606,
+	542,
+	607,
+	543,
+	607,
+	542,
+	607,
+	543,
+	608,
+	544,
+	608,
+	543,
+	608,
+	544,
+	609,
+	545,
+	609,
+	544,
+	609,
+	545,
+	610,
+	546,
+	610,
+	545,
+	610,
+	546,
+	611,
+	547,
+	611,
+	546,
+	611,
+	547,
+	612,
+	548,
+	612,
+	547,
+	612,
+	548,
+	613,
+	549,
+	613,
+	548,
+	613,
+	549,
+	614,
+	550,
+	614,
+	549,
+	614,
+	550,
+	615,
+	551,
+	615,
+	550,
+	615,
+	551,
+	616,
+	552,
+	616,
+	551,
+	616,
+	552,
+	617,
+	553,
+	617,
+	552,
+	617,
+	553,
+	618,
+	554,
+	618,
+	553,
+	618,
+	554,
+	619,
+	555,
+	619,
+	554,
+	619,
+	555,
+	620,
+	556,
+	620,
+	555,
+	620,
+	556,
+	621,
+	557,
+	621,
+	556,
+	621,
+	557,
+	622,
+	558,
+	622,
+	557,
+	622,
+	558,
+	623,
+	559,
+	623,
+	558,
+	623,
+	559,
+	624,
+	560,
+	624,
+	559,
+	624,
+	560,
+	625,
+	561,
+	625,
+	560,
+	625,
+	561,
+	626,
+	562,
+	626,
+	561,
+	626,
+	562,
+	627,
+	563,
+	627,
+	562,
+	627,
+	563,
+	628,
+	564,
+	628,
+	563,
+	628,
+	564,
+	629,
+	565,
+	629,
+	564,
+	629,
+	565,
+	630,
+	566,
+	630,
+	565,
+	630,
+	566,
+	631,
+	567,
+	631,
+	566,
+	631,
+	567,
+	632,
+	568,
+	632,
+	567,
+	632,
+	568,
+	633,
+	569,
+	633,
+	568,
+	633,
+	569,
+	634,
+	570,
+	634,
+	569,
+	634,
+	570,
+	635,
+	571,
+	635,
+	570,
+	635,
+	571,
+	636,
+	572,
+	636,
+	571,
+	636,
+	572,
+	637,
+	573,
+	637,
+	572,
+	637,
+	573,
+	638,
+	574,
+	638,
+	573,
+	638,
+	574,
+	639,
+	575,
+	639,
+	574,
+	640,
+	576,
+	641,
+	577,
+	641,
+	576,
+	641,
+	577,
+	642,
+	578,
+	642,
+	577,
+	642,
+	578,
+	643,
+	579,
+	643,
+	578,
+	643,
+	579,
+	644,
+	580,
+	644,
+	579,
+	644,
+	580,
+	645,
+	581,
+	645,
+	580,
+	645,
+	581,
+	646,
+	582,
+	646,
+	581,
+	646,
+	582,
+	647,
+	583,
+	647,
+	582,
+	647,
+	583,
+	648,
+	584,
+	648,
+	583,
+	648,
+	584,
+	649,
+	585,
+	649,
+	584,
+	649,
+	585,
+	650,
+	586,
+	650,
+	585,
+	650,
+	586,
+	651,
+	587,
+	651,
+	586,
+	651,
+	587,
+	652,
+	588,
+	652,
+	587,
+	652,
+	588,
+	653,
+	589,
+	653,
+	588,
+	653,
+	589,
+	654,
+	590,
+	654,
+	589,
+	654,
+	590,
+	655,
+	591,
+	655,
+	590,
+	655,
+	591,
+	656,
+	592,
+	656,
+	591,
+	656,
+	592,
+	657,
+	593,
+	657,
+	592,
+	657,
+	593,
+	658,
+	594,
+	658,
+	593,
+	658,
+	594,
+	659,
+	595,
+	659,
+	594,
+	659,
+	595,
+	660,
+	596,
+	660,
+	595,
+	660,
+	596,
+	661,
+	597,
+	661,
+	596,
+	661,
+	597,
+	662,
+	598,
+	662,
+	597,
+	662,
+	598,
+	663,
+	599,
+	663,
+	598,
+	663,
+	599,
+	664,
+	600,
+	664,
+	599,
+	664,
+	600,
+	665,
+	601,
+	665,
+	600,
+	665,
+	601,
+	666,
+	602,
+	666,
+	601,
+	666,
+	602,
+	667,
+	603,
+	667,
+	602,
+	667,
+	603,
+	668,
+	604,
+	668,
+	603,
+	668,
+	604,
+	669,
+	605,
+	669,
+	604,
+	669,
+	605,
+	670,
+	606,
+	670,
+	605,
+	670,
+	606,
+	671,
+	607,
+	671,
+	606,
+	671,
+	607,
+	672,
+	608,
+	672,
+	607,
+	672,
+	608,
+	673,
+	609,
+	673,
+	608,
+	673,
+	609,
+	674,
+	610,
+	674,
+	609,
+	674,
+	610,
+	675,
+	611,
+	675,
+	610,
+	675,
+	611,
+	676,
+	612,
+	676,
+	611,
+	676,
+	612,
+	677,
+	613,
+	677,
+	612,
+	677,
+	613,
+	678,
+	614,
+	678,
+	613,
+	678,
+	614,
+	679,
+	615,
+	679,
+	614,
+	679,
+	615,
+	680,
+	616,
+	680,
+	615,
+	680,
+	616,
+	681,
+	617,
+	681,
+	616,
+	681,
+	617,
+	682,
+	618,
+	682,
+	617,
+	682,
+	618,
+	683,
+	619,
+	683,
+	618,
+	683,
+	619,
+	684,
+	620,
+	684,
+	619,
+	684,
+	620,
+	685,
+	621,
+	685,
+	620,
+	685,
+	621,
+	686,
+	622,
+	686,
+	621,
+	686,
+	622,
+	687,
+	623,
+	687,
+	622,
+	687,
+	623,
+	688,
+	624,
+	688,
+	623,
+	688,
+	624,
+	689,
+	625,
+	689,
+	624,
+	689,
+	625,
+	690,
+	626,
+	690,
+	625,
+	690,
+	626,
+	691,
+	627,
+	691,
+	626,
+	691,
+	627,
+	692,
+	628,
+	692,
+	627,
+	692,
+	628,
+	693,
+	629,
+	693,
+	628,
+	693,
+	629,
+	694,
+	630,
+	694,
+	629,
+	694,
+	630,
+	695,
+	631,
+	695,
+	630,
+	695,
+	631,
+	696,
+	632,
+	696,
+	631,
+	696,
+	632,
+	697,
+	633,
+	697,
+	632,
+	697,
+	633,
+	698,
+	634,
+	698,
+	633,
+	698,
+	634,
+	699,
+	635,
+	699,
+	634,
+	699,
+	635,
+	700,
+	636,
+	700,
+	635,
+	700,
+	636,
+	701,
+	637,
+	701,
+	636,
+	701,
+	637,
+	702,
+	638,
+	702,
+	637,
+	702,
+	638,
+	703,
+	639,
+	703,
+	638,
+	704,
+	640,
+	705,
+	641,
+	705,
+	640,
+	705,
+	641,
+	706,
+	642,
+	706,
+	641,
+	706,
+	642,
+	707,
+	643,
+	707,
+	642,
+	707,
+	643,
+	708,
+	644,
+	708,
+	643,
+	708,
+	644,
+	709,
+	645,
+	709,
+	644,
+	709,
+	645,
+	710,
+	646,
+	710,
+	645,
+	710,
+	646,
+	711,
+	647,
+	711,
+	646,
+	711,
+	647,
+	712,
+	648,
+	712,
+	647,
+	712,
+	648,
+	713,
+	649,
+	713,
+	648,
+	713,
+	649,
+	714,
+	650,
+	714,
+	649,
+	714,
+	650,
+	715,
+	651,
+	715,
+	650,
+	715,
+	651,
+	716,
+	652,
+	716,
+	651,
+	716,
+	652,
+	717,
+	653,
+	717,
+	652,
+	717,
+	653,
+	718,
+	654,
+	718,
+	653,
+	718,
+	654,
+	719,
+	655,
+	719,
+	654,
+	719,
+	655,
+	720,
+	656,
+	720,
+	655,
+	720,
+	656,
+	721,
+	657,
+	721,
+	656,
+	721,
+	657,
+	722,
+	658,
+	722,
+	657,
+	722,
+	658,
+	723,
+	659,
+	723,
+	658,
+	723,
+	659,
+	724,
+	660,
+	724,
+	659,
+	724,
+	660,
+	725,
+	661,
+	725,
+	660,
+	725,
+	661,
+	726,
+	662,
+	726,
+	661,
+	726,
+	662,
+	727,
+	663,
+	727,
+	662,
+	727,
+	663,
+	728,
+	664,
+	728,
+	663,
+	728,
+	664,
+	729,
+	665,
+	729,
+	664,
+	729,
+	665,
+	730,
+	666,
+	730,
+	665,
+	730,
+	666,
+	731,
+	667,
+	731,
+	666,
+	731,
+	667,
+	732,
+	668,
+	732,
+	667,
+	732,
+	668,
+	733,
+	669,
+	733,
+	668,
+	733,
+	669,
+	734,
+	670,
+	734,
+	669,
+	734,
+	670,
+	735,
+	671,
+	735,
+	670,
+	735,
+	671,
+	736,
+	672,
+	736,
+	671,
+	736,
+	672,
+	737,
+	673,
+	737,
+	672,
+	737,
+	673,
+	738,
+	674,
+	738,
+	673,
+	738,
+	674,
+	739,
+	675,
+	739,
+	674,
+	739,
+	675,
+	740,
+	676,
+	740,
+	675,
+	740,
+	676,
+	741,
+	677,
+	741,
+	676,
+	741,
+	677,
+	742,
+	678,
+	742,
+	677,
+	742,
+	678,
+	743,
+	679,
+	743,
+	678,
+	743,
+	679,
+	744,
+	680,
+	744,
+	679,
+	744,
+	680,
+	745,
+	681,
+	745,
+	680,
+	745,
+	681,
+	746,
+	682,
+	746,
+	681,
+	746,
+	682,
+	747,
+	683,
+	747,
+	682,
+	747,
+	683,
+	748,
+	684,
+	748,
+	683,
+	748,
+	684,
+	749,
+	685,
+	749,
+	684,
+	749,
+	685,
+	750,
+	686,
+	750,
+	685,
+	750,
+	686,
+	751,
+	687,
+	751,
+	686,
+	751,
+	687,
+	752,
+	688,
+	752,
+	687,
+	752,
+	688,
+	753,
+	689,
+	753,
+	688,
+	753,
+	689,
+	754,
+	690,
+	754,
+	689,
+	754,
+	690,
+	755,
+	691,
+	755,
+	690,
+	755,
+	691,
+	756,
+	692,
+	756,
+	691,
+	756,
+	692,
+	757,
+	693,
+	757,
+	692,
+	757,
+	693,
+	758,
+	694,
+	758,
+	693,
+	758,
+	694,
+	759,
+	695,
+	759,
+	694,
+	759,
+	695,
+	760,
+	696,
+	760,
+	695,
+	760,
+	696,
+	761,
+	697,
+	761,
+	696,
+	761,
+	697,
+	762,
+	698,
+	762,
+	697,
+	762,
+	698,
+	763,
+	699,
+	763,
+	698,
+	763,
+	699,
+	764,
+	700,
+	764,
+	699,
+	764,
+	700,
+	765,
+	701,
+	765,
+	700,
+	765,
+	701,
+	766,
+	702,
+	766,
+	701,
+	766,
+	702,
+	767,
+	703,
+	767,
+	702,
+	768,
+	704,
+	769,
+	705,
+	769,
+	704,
+	769,
+	705,
+	770,
+	706,
+	770,
+	705,
+	770,
+	706,
+	771,
+	707,
+	771,
+	706,
+	771,
+	707,
+	772,
+	708,
+	772,
+	707,
+	772,
+	708,
+	773,
+	709,
+	773,
+	708,
+	773,
+	709,
+	774,
+	710,
+	774,
+	709,
+	774,
+	710,
+	775,
+	711,
+	775,
+	710,
+	775,
+	711,
+	776,
+	712,
+	776,
+	711,
+	776,
+	712,
+	777,
+	713,
+	777,
+	712,
+	777,
+	713,
+	778,
+	714,
+	778,
+	713,
+	778,
+	714,
+	779,
+	715,
+	779,
+	714,
+	779,
+	715,
+	780,
+	716,
+	780,
+	715,
+	780,
+	716,
+	781,
+	717,
+	781,
+	716,
+	781,
+	717,
+	782,
+	718,
+	782,
+	717,
+	782,
+	718,
+	783,
+	719,
+	783,
+	718,
+	783,
+	719,
+	784,
+	720,
+	784,
+	719,
+	784,
+	720,
+	785,
+	721,
+	785,
+	720,
+	785,
+	721,
+	786,
+	722,
+	786,
+	721,
+	786,
+	722,
+	787,
+	723,
+	787,
+	722,
+	787,
+	723,
+	788,
+	724,
+	788,
+	723,
+	788,
+	724,
+	789,
+	725,
+	789,
+	724,
+	789,
+	725,
+	790,
+	726,
+	790,
+	725,
+	790,
+	726,
+	791,
+	727,
+	791,
+	726,
+	791,
+	727,
+	792,
+	728,
+	792,
+	727,
+	792,
+	728,
+	793,
+	729,
+	793,
+	728,
+	793,
+	729,
+	794,
+	730,
+	794,
+	729,
+	794,
+	730,
+	795,
+	731,
+	795,
+	730,
+	795,
+	731,
+	796,
+	732,
+	796,
+	731,
+	796,
+	732,
+	797,
+	733,
+	797,
+	732,
+	797,
+	733,
+	798,
+	734,
+	798,
+	733,
+	798,
+	734,
+	799,
+	735,
+	799,
+	734,
+	799,
+	735,
+	800,
+	736,
+	800,
+	735,
+	800,
+	736,
+	801,
+	737,
+	801,
+	736,
+	801,
+	737,
+	802,
+	738,
+	802,
+	737,
+	802,
+	738,
+	803,
+	739,
+	803,
+	738,
+	803,
+	739,
+	804,
+	740,
+	804,
+	739,
+	804,
+	740,
+	805,
+	741,
+	805,
+	740,
+	805,
+	741,
+	806,
+	742,
+	806,
+	741,
+	806,
+	742,
+	807,
+	743,
+	807,
+	742,
+	807,
+	743,
+	808,
+	744,
+	808,
+	743,
+	808,
+	744,
+	809,
+	745,
+	809,
+	744,
+	809,
+	745,
+	810,
+	746,
+	810,
+	745,
+	810,
+	746,
+	811,
+	747,
+	811,
+	746,
+	811,
+	747,
+	812,
+	748,
+	812,
+	747,
+	812,
+	748,
+	813,
+	749,
+	813,
+	748,
+	813,
+	749,
+	814,
+	750,
+	814,
+	749,
+	814,
+	750,
+	815,
+	751,
+	815,
+	750,
+	815,
+	751,
+	816,
+	752,
+	816,
+	751,
+	816,
+	752,
+	817,
+	753,
+	817,
+	752,
+	817,
+	753,
+	818,
+	754,
+	818,
+	753,
+	818,
+	754,
+	819,
+	755,
+	819,
+	754,
+	819,
+	755,
+	820,
+	756,
+	820,
+	755,
+	820,
+	756,
+	821,
+	757,
+	821,
+	756,
+	821,
+	757,
+	822,
+	758,
+	822,
+	757,
+	822,
+	758,
+	823,
+	759,
+	823,
+	758,
+	823,
+	759,
+	824,
+	760,
+	824,
+	759,
+	824,
+	760,
+	825,
+	761,
+	825,
+	760,
+	825,
+	761,
+	826,
+	762,
+	826,
+	761,
+	826,
+	762,
+	827,
+	763,
+	827,
+	762,
+	827,
+	763,
+	828,
+	764,
+	828,
+	763,
+	828,
+	764,
+	829,
+	765,
+	829,
+	764,
+	829,
+	765,
+	830,
+	766,
+	830,
+	765,
+	830,
+	766,
+	831,
+	767,
+	831,
+	766,
+	832,
+	768,
+	833,
+	769,
+	833,
+	768,
+	833,
+	769,
+	834,
+	770,
+	834,
+	769,
+	834,
+	770,
+	835,
+	771,
+	835,
+	770,
+	835,
+	771,
+	836,
+	772,
+	836,
+	771,
+	836,
+	772,
+	837,
+	773,
+	837,
+	772,
+	837,
+	773,
+	838,
+	774,
+	838,
+	773,
+	838,
+	774,
+	839,
+	775,
+	839,
+	774,
+	839,
+	775,
+	840,
+	776,
+	840,
+	775,
+	840,
+	776,
+	841,
+	777,
+	841,
+	776,
+	841,
+	777,
+	842,
+	778,
+	842,
+	777,
+	842,
+	778,
+	843,
+	779,
+	843,
+	778,
+	843,
+	779,
+	844,
+	780,
+	844,
+	779,
+	844,
+	780,
+	845,
+	781,
+	845,
+	780,
+	845,
+	781,
+	846,
+	782,
+	846,
+	781,
+	846,
+	782,
+	847,
+	783,
+	847,
+	782,
+	847,
+	783,
+	848,
+	784,
+	848,
+	783,
+	848,
+	784,
+	849,
+	785,
+	849,
+	784,
+	849,
+	785,
+	850,
+	786,
+	850,
+	785,
+	850,
+	786,
+	851,
+	787,
+	851,
+	786,
+	851,
+	787,
+	852,
+	788,
+	852,
+	787,
+	852,
+	788,
+	853,
+	789,
+	853,
+	788,
+	853,
+	789,
+	854,
+	790,
+	854,
+	789,
+	854,
+	790,
+	855,
+	791,
+	855,
+	790,
+	855,
+	791,
+	856,
+	792,
+	856,
+	791,
+	856,
+	792,
+	857,
+	793,
+	857,
+	792,
+	857,
+	793,
+	858,
+	794,
+	858,
+	793,
+	858,
+	794,
+	859,
+	795,
+	859,
+	794,
+	859,
+	795,
+	860,
+	796,
+	860,
+	795,
+	860,
+	796,
+	861,
+	797,
+	861,
+	796,
+	861,
+	797,
+	862,
+	798,
+	862,
+	797,
+	862,
+	798,
+	863,
+	799,
+	863,
+	798,
+	863,
+	799,
+	864,
+	800,
+	864,
+	799,
+	864,
+	800,
+	865,
+	801,
+	865,
+	800,
+	865,
+	801,
+	866,
+	802,
+	866,
+	801,
+	866,
+	802,
+	867,
+	803,
+	867,
+	802,
+	867,
+	803,
+	868,
+	804,
+	868,
+	803,
+	868,
+	804,
+	869,
+	805,
+	869,
+	804,
+	869,
+	805,
+	870,
+	806,
+	870,
+	805,
+	870,
+	806,
+	871,
+	807,
+	871,
+	806,
+	871,
+	807,
+	872,
+	808,
+	872,
+	807,
+	872,
+	808,
+	873,
+	809,
+	873,
+	808,
+	873,
+	809,
+	874,
+	810,
+	874,
+	809,
+	874,
+	810,
+	875,
+	811,
+	875,
+	810,
+	875,
+	811,
+	876,
+	812,
+	876,
+	811,
+	876,
+	812,
+	877,
+	813,
+	877,
+	812,
+	877,
+	813,
+	878,
+	814,
+	878,
+	813,
+	878,
+	814,
+	879,
+	815,
+	879,
+	814,
+	879,
+	815,
+	880,
+	816,
+	880,
+	815,
+	880,
+	816,
+	881,
+	817,
+	881,
+	816,
+	881,
+	817,
+	882,
+	818,
+	882,
+	817,
+	882,
+	818,
+	883,
+	819,
+	883,
+	818,
+	883,
+	819,
+	884,
+	820,
+	884,
+	819,
+	884,
+	820,
+	885,
+	821,
+	885,
+	820,
+	885,
+	821,
+	886,
+	822,
+	886,
+	821,
+	886,
+	822,
+	887,
+	823,
+	887,
+	822,
+	887,
+	823,
+	888,
+	824,
+	888,
+	823,
+	888,
+	824,
+	889,
+	825,
+	889,
+	824,
+	889,
+	825,
+	890,
+	826,
+	890,
+	825,
+	890,
+	826,
+	891,
+	827,
+	891,
+	826,
+	891,
+	827,
+	892,
+	828,
+	892,
+	827,
+	892,
+	828,
+	893,
+	829,
+	893,
+	828,
+	893,
+	829,
+	894,
+	830,
+	894,
+	829,
+	894,
+	830,
+	895,
+	831,
+	895,
+	830,
+	896,
+	832,
+	897,
+	833,
+	897,
+	832,
+	897,
+	833,
+	898,
+	834,
+	898,
+	833,
+	898,
+	834,
+	899,
+	835,
+	899,
+	834,
+	899,
+	835,
+	900,
+	836,
+	900,
+	835,
+	900,
+	836,
+	901,
+	837,
+	901,
+	836,
+	901,
+	837,
+	902,
+	838,
+	902,
+	837,
+	902,
+	838,
+	903,
+	839,
+	903,
+	838,
+	903,
+	839,
+	904,
+	840,
+	904,
+	839,
+	904,
+	840,
+	905,
+	841,
+	905,
+	840,
+	905,
+	841,
+	906,
+	842,
+	906,
+	841,
+	906,
+	842,
+	907,
+	843,
+	907,
+	842,
+	907,
+	843,
+	908,
+	844,
+	908,
+	843,
+	908,
+	844,
+	909,
+	845,
+	909,
+	844,
+	909,
+	845,
+	910,
+	846,
+	910,
+	845,
+	910,
+	846,
+	911,
+	847,
+	911,
+	846,
+	911,
+	847,
+	912,
+	848,
+	912,
+	847,
+	912,
+	848,
+	913,
+	849,
+	913,
+	848,
+	913,
+	849,
+	914,
+	850,
+	914,
+	849,
+	914,
+	850,
+	915,
+	851,
+	915,
+	850,
+	915,
+	851,
+	916,
+	852,
+	916,
+	851,
+	916,
+	852,
+	917,
+	853,
+	917,
+	852,
+	917,
+	853,
+	918,
+	854,
+	918,
+	853,
+	918,
+	854,
+	919,
+	855,
+	919,
+	854,
+	919,
+	855,
+	920,
+	856,
+	920,
+	855,
+	920,
+	856,
+	921,
+	857,
+	921,
+	856,
+	921,
+	857,
+	922,
+	858,
+	922,
+	857,
+	922,
+	858,
+	923,
+	859,
+	923,
+	858,
+	923,
+	859,
+	924,
+	860,
+	924,
+	859,
+	924,
+	860,
+	925,
+	861,
+	925,
+	860,
+	925,
+	861,
+	926,
+	862,
+	926,
+	861,
+	926,
+	862,
+	927,
+	863,
+	927,
+	862,
+	927,
+	863,
+	928,
+	864,
+	928,
+	863,
+	928,
+	864,
+	929,
+	865,
+	929,
+	864,
+	929,
+	865,
+	930,
+	866,
+	930,
+	865,
+	930,
+	866,
+	931,
+	867,
+	931,
+	866,
+	931,
+	867,
+	932,
+	868,
+	932,
+	867,
+	932,
+	868,
+	933,
+	869,
+	933,
+	868,
+	933,
+	869,
+	934,
+	870,
+	934,
+	869,
+	934,
+	870,
+	935,
+	871,
+	935,
+	870,
+	935,
+	871,
+	936,
+	872,
+	936,
+	871,
+	936,
+	872,
+	937,
+	873,
+	937,
+	872,
+	937,
+	873,
+	938,
+	874,
+	938,
+	873,
+	938,
+	874,
+	939,
+	875,
+	939,
+	874,
+	939,
+	875,
+	940,
+	876,
+	940,
+	875,
+	940,
+	876,
+	941,
+	877,
+	941,
+	876,
+	941,
+	877,
+	942,
+	878,
+	942,
+	877,
+	942,
+	878,
+	943,
+	879,
+	943,
+	878,
+	943,
+	879,
+	944,
+	880,
+	944,
+	879,
+	944,
+	880,
+	945,
+	881,
+	945,
+	880,
+	945,
+	881,
+	946,
+	882,
+	946,
+	881,
+	946,
+	882,
+	947,
+	883,
+	947,
+	882,
+	947,
+	883,
+	948,
+	884,
+	948,
+	883,
+	948,
+	884,
+	949,
+	885,
+	949,
+	884,
+	949,
+	885,
+	950,
+	886,
+	950,
+	885,
+	950,
+	886,
+	951,
+	887,
+	951,
+	886,
+	951,
+	887,
+	952,
+	888,
+	952,
+	887,
+	952,
+	888,
+	953,
+	889,
+	953,
+	888,
+	953,
+	889,
+	954,
+	890,
+	954,
+	889,
+	954,
+	890,
+	955,
+	891,
+	955,
+	890,
+	955,
+	891,
+	956,
+	892,
+	956,
+	891,
+	956,
+	892,
+	957,
+	893,
+	957,
+	892,
+	957,
+	893,
+	958,
+	894,
+	958,
+	893,
+	958,
+	894,
+	959,
+	895,
+	959,
+	894,
+	960,
+	896,
+	961,
+	897,
+	961,
+	896,
+	961,
+	897,
+	962,
+	898,
+	962,
+	897,
+	962,
+	898,
+	963,
+	899,
+	963,
+	898,
+	963,
+	899,
+	964,
+	900,
+	964,
+	899,
+	964,
+	900,
+	965,
+	901,
+	965,
+	900,
+	965,
+	901,
+	966,
+	902,
+	966,
+	901,
+	966,
+	902,
+	967,
+	903,
+	967,
+	902,
+	967,
+	903,
+	968,
+	904,
+	968,
+	903,
+	968,
+	904,
+	969,
+	905,
+	969,
+	904,
+	969,
+	905,
+	970,
+	906,
+	970,
+	905,
+	970,
+	906,
+	971,
+	907,
+	971,
+	906,
+	971,
+	907,
+	972,
+	908,
+	972,
+	907,
+	972,
+	908,
+	973,
+	909,
+	973,
+	908,
+	973,
+	909,
+	974,
+	910,
+	974,
+	909,
+	974,
+	910,
+	975,
+	911,
+	975,
+	910,
+	975,
+	911,
+	976,
+	912,
+	976,
+	911,
+	976,
+	912,
+	977,
+	913,
+	977,
+	912,
+	977,
+	913,
+	978,
+	914,
+	978,
+	913,
+	978,
+	914,
+	979,
+	915,
+	979,
+	914,
+	979,
+	915,
+	980,
+	916,
+	980,
+	915,
+	980,
+	916,
+	981,
+	917,
+	981,
+	916,
+	981,
+	917,
+	982,
+	918,
+	982,
+	917,
+	982,
+	918,
+	983,
+	919,
+	983,
+	918,
+	983,
+	919,
+	984,
+	920,
+	984,
+	919,
+	984,
+	920,
+	985,
+	921,
+	985,
+	920,
+	985,
+	921,
+	986,
+	922,
+	986,
+	921,
+	986,
+	922,
+	987,
+	923,
+	987,
+	922,
+	987,
+	923,
+	988,
+	924,
+	988,
+	923,
+	988,
+	924,
+	989,
+	925,
+	989,
+	924,
+	989,
+	925,
+	990,
+	926,
+	990,
+	925,
+	990,
+	926,
+	991,
+	927,
+	991,
+	926,
+	991,
+	927,
+	992,
+	928,
+	992,
+	927,
+	992,
+	928,
+	993,
+	929,
+	993,
+	928,
+	993,
+	929,
+	994,
+	930,
+	994,
+	929,
+	994,
+	930,
+	995,
+	931,
+	995,
+	930,
+	995,
+	931,
+	996,
+	932,
+	996,
+	931,
+	996,
+	932,
+	997,
+	933,
+	997,
+	932,
+	997,
+	933,
+	998,
+	934,
+	998,
+	933,
+	998,
+	934,
+	999,
+	935,
+	999,
+	934,
+	999,
+	935,
+	1000,
+	936,
+	1000,
+	935,
+	1000,
+	936,
+	1001,
+	937,
+	1001,
+	936,
+	1001,
+	937,
+	1002,
+	938,
+	1002,
+	937,
+	1002,
+	938,
+	1003,
+	939,
+	1003,
+	938,
+	1003,
+	939,
+	1004,
+	940,
+	1004,
+	939,
+	1004,
+	940,
+	1005,
+	941,
+	1005,
+	940,
+	1005,
+	941,
+	1006,
+	942,
+	1006,
+	941,
+	1006,
+	942,
+	1007,
+	943,
+	1007,
+	942,
+	1007,
+	943,
+	1008,
+	944,
+	1008,
+	943,
+	1008,
+	944,
+	1009,
+	945,
+	1009,
+	944,
+	1009,
+	945,
+	1010,
+	946,
+	1010,
+	945,
+	1010,
+	946,
+	1011,
+	947,
+	1011,
+	946,
+	1011,
+	947,
+	1012,
+	948,
+	1012,
+	947,
+	1012,
+	948,
+	1013,
+	949,
+	1013,
+	948,
+	1013,
+	949,
+	1014,
+	950,
+	1014,
+	949,
+	1014,
+	950,
+	1015,
+	951,
+	1015,
+	950,
+	1015,
+	951,
+	1016,
+	952,
+	1016,
+	951,
+	1016,
+	952,
+	1017,
+	953,
+	1017,
+	952,
+	1017,
+	953,
+	1018,
+	954,
+	1018,
+	953,
+	1018,
+	954,
+	1019,
+	955,
+	1019,
+	954,
+	1019,
+	955,
+	1020,
+	956,
+	1020,
+	955,
+	1020,
+	956,
+	1021,
+	957,
+	1021,
+	956,
+	1021,
+	957,
+	1022,
+	958,
+	1022,
+	957,
+	1022,
+	958,
+	1023,
+	959,
+	1023,
+	958,
+	1024,
+	960,
+	1025,
+	961,
+	1025,
+	960,
+	1025,
+	961,
+	1026,
+	962,
+	1026,
+	961,
+	1026,
+	962,
+	1027,
+	963,
+	1027,
+	962,
+	1027,
+	963,
+	1028,
+	964,
+	1028,
+	963,
+	1028,
+	964,
+	1029,
+	965,
+	1029,
+	964,
+	1029,
+	965,
+	1030,
+	966,
+	1030,
+	965,
+	1030,
+	966,
+	1031,
+	967,
+	1031,
+	966,
+	1031,
+	967,
+	1032,
+	968,
+	1032,
+	967,
+	1032,
+	968,
+	1033,
+	969,
+	1033,
+	968,
+	1033,
+	969,
+	1034,
+	970,
+	1034,
+	969,
+	1034,
+	970,
+	1035,
+	971,
+	1035,
+	970,
+	1035,
+	971,
+	1036,
+	972,
+	1036,
+	971,
+	1036,
+	972,
+	1037,
+	973,
+	1037,
+	972,
+	1037,
+	973,
+	1038,
+	974,
+	1038,
+	973,
+	1038,
+	974,
+	1039,
+	975,
+	1039,
+	974,
+	1039,
+	975,
+	1040,
+	976,
+	1040,
+	975,
+	1040,
+	976,
+	1041,
+	977,
+	1041,
+	976,
+	1041,
+	977,
+	1042,
+	978,
+	1042,
+	977,
+	1042,
+	978,
+	1043,
+	979,
+	1043,
+	978,
+	1043,
+	979,
+	1044,
+	980,
+	1044,
+	979,
+	1044,
+	980,
+	1045,
+	981,
+	1045,
+	980,
+	1045,
+	981,
+	1046,
+	982,
+	1046,
+	981,
+	1046,
+	982,
+	1047,
+	983,
+	1047,
+	982,
+	1047,
+	983,
+	1048,
+	984,
+	1048,
+	983,
+	1048,
+	984,
+	1049,
+	985,
+	1049,
+	984,
+	1049,
+	985,
+	1050,
+	986,
+	1050,
+	985,
+	1050,
+	986,
+	1051,
+	987,
+	1051,
+	986,
+	1051,
+	987,
+	1052,
+	988,
+	1052,
+	987,
+	1052,
+	988,
+	1053,
+	989,
+	1053,
+	988,
+	1053,
+	989,
+	1054,
+	990,
+	1054,
+	989,
+	1054,
+	990,
+	1055,
+	991,
+	1055,
+	990,
+	1055,
+	991,
+	1056,
+	992,
+	1056,
+	991,
+	1056,
+	992,
+	1057,
+	993,
+	1057,
+	992,
+	1057,
+	993,
+	1058,
+	994,
+	1058,
+	993,
+	1058,
+	994,
+	1059,
+	995,
+	1059,
+	994,
+	1059,
+	995,
+	1060,
+	996,
+	1060,
+	995,
+	1060,
+	996,
+	1061,
+	997,
+	1061,
+	996,
+	1061,
+	997,
+	1062,
+	998,
+	1062,
+	997,
+	1062,
+	998,
+	1063,
+	999,
+	1063,
+	998,
+	1063,
+	999,
+	1064,
+	1000,
+	1064,
+	999,
+	1064,
+	1000,
+	1065,
+	1001,
+	1065,
+	1000,
+	1065,
+	1001,
+	1066,
+	1002,
+	1066,
+	1001,
+	1066,
+	1002,
+	1067,
+	1003,
+	1067,
+	1002,
+	1067,
+	1003,
+	1068,
+	1004,
+	1068,
+	1003,
+	1068,
+	1004,
+	1069,
+	1005,
+	1069,
+	1004,
+	1069,
+	1005,
+	1070,
+	1006,
+	1070,
+	1005,
+	1070,
+	1006,
+	1071,
+	1007,
+	1071,
+	1006,
+	1071,
+	1007,
+	1072,
+	1008,
+	1072,
+	1007,
+	1072,
+	1008,
+	1073,
+	1009,
+	1073,
+	1008,
+	1073,
+	1009,
+	1074,
+	1010,
+	1074,
+	1009,
+	1074,
+	1010,
+	1075,
+	1011,
+	1075,
+	1010,
+	1075,
+	1011,
+	1076,
+	1012,
+	1076,
+	1011,
+	1076,
+	1012,
+	1077,
+	1013,
+	1077,
+	1012,
+	1077,
+	1013,
+	1078,
+	1014,
+	1078,
+	1013,
+	1078,
+	1014,
+	1079,
+	1015,
+	1079,
+	1014,
+	1079,
+	1015,
+	1080,
+	1016,
+	1080,
+	1015,
+	1080,
+	1016,
+	1081,
+	1017,
+	1081,
+	1016,
+	1081,
+	1017,
+	1082,
+	1018,
+	1082,
+	1017,
+	1082,
+	1018,
+	1083,
+	1019,
+	1083,
+	1018,
+	1083,
+	1019,
+	1084,
+	1020,
+	1084,
+	1019,
+	1084,
+	1020,
+	1085,
+	1021,
+	1085,
+	1020,
+	1085,
+	1021,
+	1086,
+	1022,
+	1086,
+	1021,
+	1086,
+	1022,
+	1087,
+	1023,
+	1087,
+	1022,
+	1088,
+	1024,
+	1089,
+	1025,
+	1089,
+	1024,
+	1089,
+	1025,
+	1090,
+	1026,
+	1090,
+	1025,
+	1090,
+	1026,
+	1091,
+	1027,
+	1091,
+	1026,
+	1091,
+	1027,
+	1092,
+	1028,
+	1092,
+	1027,
+	1092,
+	1028,
+	1093,
+	1029,
+	1093,
+	1028,
+	1093,
+	1029,
+	1094,
+	1030,
+	1094,
+	1029,
+	1094,
+	1030,
+	1095,
+	1031,
+	1095,
+	1030,
+	1095,
+	1031,
+	1096,
+	1032,
+	1096,
+	1031,
+	1096,
+	1032,
+	1097,
+	1033,
+	1097,
+	1032,
+	1097,
+	1033,
+	1098,
+	1034,
+	1098,
+	1033,
+	1098,
+	1034,
+	1099,
+	1035,
+	1099,
+	1034,
+	1099,
+	1035,
+	1100,
+	1036,
+	1100,
+	1035,
+	1100,
+	1036,
+	1101,
+	1037,
+	1101,
+	1036,
+	1101,
+	1037,
+	1102,
+	1038,
+	1102,
+	1037,
+	1102,
+	1038,
+	1103,
+	1039,
+	1103,
+	1038,
+	1103,
+	1039,
+	1104,
+	1040,
+	1104,
+	1039,
+	1104,
+	1040,
+	1105,
+	1041,
+	1105,
+	1040,
+	1105,
+	1041,
+	1106,
+	1042,
+	1106,
+	1041,
+	1106,
+	1042,
+	1107,
+	1043,
+	1107,
+	1042,
+	1107,
+	1043,
+	1108,
+	1044,
+	1108,
+	1043,
+	1108,
+	1044,
+	1109,
+	1045,
+	1109,
+	1044,
+	1109,
+	1045,
+	1110,
+	1046,
+	1110,
+	1045,
+	1110,
+	1046,
+	1111,
+	1047,
+	1111,
+	1046,
+	1111,
+	1047,
+	1112,
+	1048,
+	1112,
+	1047,
+	1112,
+	1048,
+	1113,
+	1049,
+	1113,
+	1048,
+	1113,
+	1049,
+	1114,
+	1050,
+	1114,
+	1049,
+	1114,
+	1050,
+	1115,
+	1051,
+	1115,
+	1050,
+	1115,
+	1051,
+	1116,
+	1052,
+	1116,
+	1051,
+	1116,
+	1052,
+	1117,
+	1053,
+	1117,
+	1052,
+	1117,
+	1053,
+	1118,
+	1054,
+	1118,
+	1053,
+	1118,
+	1054,
+	1119,
+	1055,
+	1119,
+	1054,
+	1119,
+	1055,
+	1120,
+	1056,
+	1120,
+	1055,
+	1120,
+	1056,
+	1121,
+	1057,
+	1121,
+	1056,
+	1121,
+	1057,
+	1122,
+	1058,
+	1122,
+	1057,
+	1122,
+	1058,
+	1123,
+	1059,
+	1123,
+	1058,
+	1123,
+	1059,
+	1124,
+	1060,
+	1124,
+	1059,
+	1124,
+	1060,
+	1125,
+	1061,
+	1125,
+	1060,
+	1125,
+	1061,
+	1126,
+	1062,
+	1126,
+	1061,
+	1126,
+	1062,
+	1127,
+	1063,
+	1127,
+	1062,
+	1127,
+	1063,
+	1128,
+	1064,
+	1128,
+	1063,
+	1128,
+	1064,
+	1129,
+	1065,
+	1129,
+	1064,
+	1129,
+	1065,
+	1130,
+	1066,
+	1130,
+	1065,
+	1130,
+	1066,
+	1131,
+	1067,
+	1131,
+	1066,
+	1131,
+	1067,
+	1132,
+	1068,
+	1132,
+	1067,
+	1132,
+	1068,
+	1133,
+	1069,
+	1133,
+	1068,
+	1133,
+	1069,
+	1134,
+	1070,
+	1134,
+	1069,
+	1134,
+	1070,
+	1135,
+	1071,
+	1135,
+	1070,
+	1135,
+	1071,
+	1136,
+	1072,
+	1136,
+	1071,
+	1136,
+	1072,
+	1137,
+	1073,
+	1137,
+	1072,
+	1137,
+	1073,
+	1138,
+	1074,
+	1138,
+	1073,
+	1138,
+	1074,
+	1139,
+	1075,
+	1139,
+	1074,
+	1139,
+	1075,
+	1140,
+	1076,
+	1140,
+	1075,
+	1140,
+	1076,
+	1141,
+	1077,
+	1141,
+	1076,
+	1141,
+	1077,
+	1142,
+	1078,
+	1142,
+	1077,
+	1142,
+	1078,
+	1143,
+	1079,
+	1143,
+	1078,
+	1143,
+	1079,
+	1144,
+	1080,
+	1144,
+	1079,
+	1144,
+	1080,
+	1145,
+	1081,
+	1145,
+	1080,
+	1145,
+	1081,
+	1146,
+	1082,
+	1146,
+	1081,
+	1146,
+	1082,
+	1147,
+	1083,
+	1147,
+	1082,
+	1147,
+	1083,
+	1148,
+	1084,
+	1148,
+	1083,
+	1148,
+	1084,
+	1149,
+	1085,
+	1149,
+	1084,
+	1149,
+	1085,
+	1150,
+	1086,
+	1150,
+	1085,
+	1150,
+	1086,
+	1151,
+	1087,
+	1151,
+	1086,
+	1152,
+	1088,
+	1153,
+	1089,
+	1153,
+	1088,
+	1153,
+	1089,
+	1154,
+	1090,
+	1154,
+	1089,
+	1154,
+	1090,
+	1155,
+	1091,
+	1155,
+	1090,
+	1155,
+	1091,
+	1156,
+	1092,
+	1156,
+	1091,
+	1156,
+	1092,
+	1157,
+	1093,
+	1157,
+	1092,
+	1157,
+	1093,
+	1158,
+	1094,
+	1158,
+	1093,
+	1158,
+	1094,
+	1159,
+	1095,
+	1159,
+	1094,
+	1159,
+	1095,
+	1160,
+	1096,
+	1160,
+	1095,
+	1160,
+	1096,
+	1161,
+	1097,
+	1161,
+	1096,
+	1161,
+	1097,
+	1162,
+	1098,
+	1162,
+	1097,
+	1162,
+	1098,
+	1163,
+	1099,
+	1163,
+	1098,
+	1163,
+	1099,
+	1164,
+	1100,
+	1164,
+	1099,
+	1164,
+	1100,
+	1165,
+	1101,
+	1165,
+	1100,
+	1165,
+	1101,
+	1166,
+	1102,
+	1166,
+	1101,
+	1166,
+	1102,
+	1167,
+	1103,
+	1167,
+	1102,
+	1167,
+	1103,
+	1168,
+	1104,
+	1168,
+	1103,
+	1168,
+	1104,
+	1169,
+	1105,
+	1169,
+	1104,
+	1169,
+	1105,
+	1170,
+	1106,
+	1170,
+	1105,
+	1170,
+	1106,
+	1171,
+	1107,
+	1171,
+	1106,
+	1171,
+	1107,
+	1172,
+	1108,
+	1172,
+	1107,
+	1172,
+	1108,
+	1173,
+	1109,
+	1173,
+	1108,
+	1173,
+	1109,
+	1174,
+	1110,
+	1174,
+	1109,
+	1174,
+	1110,
+	1175,
+	1111,
+	1175,
+	1110,
+	1175,
+	1111,
+	1176,
+	1112,
+	1176,
+	1111,
+	1176,
+	1112,
+	1177,
+	1113,
+	1177,
+	1112,
+	1177,
+	1113,
+	1178,
+	1114,
+	1178,
+	1113,
+	1178,
+	1114,
+	1179,
+	1115,
+	1179,
+	1114,
+	1179,
+	1115,
+	1180,
+	1116,
+	1180,
+	1115,
+	1180,
+	1116,
+	1181,
+	1117,
+	1181,
+	1116,
+	1181,
+	1117,
+	1182,
+	1118,
+	1182,
+	1117,
+	1182,
+	1118,
+	1183,
+	1119,
+	1183,
+	1118,
+	1183,
+	1119,
+	1184,
+	1120,
+	1184,
+	1119,
+	1184,
+	1120,
+	1185,
+	1121,
+	1185,
+	1120,
+	1185,
+	1121,
+	1186,
+	1122,
+	1186,
+	1121,
+	1186,
+	1122,
+	1187,
+	1123,
+	1187,
+	1122,
+	1187,
+	1123,
+	1188,
+	1124,
+	1188,
+	1123,
+	1188,
+	1124,
+	1189,
+	1125,
+	1189,
+	1124,
+	1189,
+	1125,
+	1190,
+	1126,
+	1190,
+	1125,
+	1190,
+	1126,
+	1191,
+	1127,
+	1191,
+	1126,
+	1191,
+	1127,
+	1192,
+	1128,
+	1192,
+	1127,
+	1192,
+	1128,
+	1193,
+	1129,
+	1193,
+	1128,
+	1193,
+	1129,
+	1194,
+	1130,
+	1194,
+	1129,
+	1194,
+	1130,
+	1195,
+	1131,
+	1195,
+	1130,
+	1195,
+	1131,
+	1196,
+	1132,
+	1196,
+	1131,
+	1196,
+	1132,
+	1197,
+	1133,
+	1197,
+	1132,
+	1197,
+	1133,
+	1198,
+	1134,
+	1198,
+	1133,
+	1198,
+	1134,
+	1199,
+	1135,
+	1199,
+	1134,
+	1199,
+	1135,
+	1200,
+	1136,
+	1200,
+	1135,
+	1200,
+	1136,
+	1201,
+	1137,
+	1201,
+	1136,
+	1201,
+	1137,
+	1202,
+	1138,
+	1202,
+	1137,
+	1202,
+	1138,
+	1203,
+	1139,
+	1203,
+	1138,
+	1203,
+	1139,
+	1204,
+	1140,
+	1204,
+	1139,
+	1204,
+	1140,
+	1205,
+	1141,
+	1205,
+	1140,
+	1205,
+	1141,
+	1206,
+	1142,
+	1206,
+	1141,
+	1206,
+	1142,
+	1207,
+	1143,
+	1207,
+	1142,
+	1207,
+	1143,
+	1208,
+	1144,
+	1208,
+	1143,
+	1208,
+	1144,
+	1209,
+	1145,
+	1209,
+	1144,
+	1209,
+	1145,
+	1210,
+	1146,
+	1210,
+	1145,
+	1210,
+	1146,
+	1211,
+	1147,
+	1211,
+	1146,
+	1211,
+	1147,
+	1212,
+	1148,
+	1212,
+	1147,
+	1212,
+	1148,
+	1213,
+	1149,
+	1213,
+	1148,
+	1213,
+	1149,
+	1214,
+	1150,
+	1214,
+	1149,
+	1214,
+	1150,
+	1215,
+	1151,
+	1215,
+	1150,
+	1216,
+	1152,
+	1217,
+	1153,
+	1217,
+	1152,
+	1217,
+	1153,
+	1218,
+	1154,
+	1218,
+	1153,
+	1218,
+	1154,
+	1219,
+	1155,
+	1219,
+	1154,
+	1219,
+	1155,
+	1220,
+	1156,
+	1220,
+	1155,
+	1220,
+	1156,
+	1221,
+	1157,
+	1221,
+	1156,
+	1221,
+	1157,
+	1222,
+	1158,
+	1222,
+	1157,
+	1222,
+	1158,
+	1223,
+	1159,
+	1223,
+	1158,
+	1223,
+	1159,
+	1224,
+	1160,
+	1224,
+	1159,
+	1224,
+	1160,
+	1225,
+	1161,
+	1225,
+	1160,
+	1225,
+	1161,
+	1226,
+	1162,
+	1226,
+	1161,
+	1226,
+	1162,
+	1227,
+	1163,
+	1227,
+	1162,
+	1227,
+	1163,
+	1228,
+	1164,
+	1228,
+	1163,
+	1228,
+	1164,
+	1229,
+	1165,
+	1229,
+	1164,
+	1229,
+	1165,
+	1230,
+	1166,
+	1230,
+	1165,
+	1230,
+	1166,
+	1231,
+	1167,
+	1231,
+	1166,
+	1231,
+	1167,
+	1232,
+	1168,
+	1232,
+	1167,
+	1232,
+	1168,
+	1233,
+	1169,
+	1233,
+	1168,
+	1233,
+	1169,
+	1234,
+	1170,
+	1234,
+	1169,
+	1234,
+	1170,
+	1235,
+	1171,
+	1235,
+	1170,
+	1235,
+	1171,
+	1236,
+	1172,
+	1236,
+	1171,
+	1236,
+	1172,
+	1237,
+	1173,
+	1237,
+	1172,
+	1237,
+	1173,
+	1238,
+	1174,
+	1238,
+	1173,
+	1238,
+	1174,
+	1239,
+	1175,
+	1239,
+	1174,
+	1239,
+	1175,
+	1240,
+	1176,
+	1240,
+	1175,
+	1240,
+	1176,
+	1241,
+	1177,
+	1241,
+	1176,
+	1241,
+	1177,
+	1242,
+	1178,
+	1242,
+	1177,
+	1242,
+	1178,
+	1243,
+	1179,
+	1243,
+	1178,
+	1243,
+	1179,
+	1244,
+	1180,
+	1244,
+	1179,
+	1244,
+	1180,
+	1245,
+	1181,
+	1245,
+	1180,
+	1245,
+	1181,
+	1246,
+	1182,
+	1246,
+	1181,
+	1246,
+	1182,
+	1247,
+	1183,
+	1247,
+	1182,
+	1247,
+	1183,
+	1248,
+	1184,
+	1248,
+	1183,
+	1248,
+	1184,
+	1249,
+	1185,
+	1249,
+	1184,
+	1249,
+	1185,
+	1250,
+	1186,
+	1250,
+	1185,
+	1250,
+	1186,
+	1251,
+	1187,
+	1251,
+	1186,
+	1251,
+	1187,
+	1252,
+	1188,
+	1252,
+	1187,
+	1252,
+	1188,
+	1253,
+	1189,
+	1253,
+	1188,
+	1253,
+	1189,
+	1254,
+	1190,
+	1254,
+	1189,
+	1254,
+	1190,
+	1255,
+	1191,
+	1255,
+	1190,
+	1255,
+	1191,
+	1256,
+	1192,
+	1256,
+	1191,
+	1256,
+	1192,
+	1257,
+	1193,
+	1257,
+	1192,
+	1257,
+	1193,
+	1258,
+	1194,
+	1258,
+	1193,
+	1258,
+	1194,
+	1259,
+	1195,
+	1259,
+	1194,
+	1259,
+	1195,
+	1260,
+	1196,
+	1260,
+	1195,
+	1260,
+	1196,
+	1261,
+	1197,
+	1261,
+	1196,
+	1261,
+	1197,
+	1262,
+	1198,
+	1262,
+	1197,
+	1262,
+	1198,
+	1263,
+	1199,
+	1263,
+	1198,
+	1263,
+	1199,
+	1264,
+	1200,
+	1264,
+	1199,
+	1264,
+	1200,
+	1265,
+	1201,
+	1265,
+	1200,
+	1265,
+	1201,
+	1266,
+	1202,
+	1266,
+	1201,
+	1266,
+	1202,
+	1267,
+	1203,
+	1267,
+	1202,
+	1267,
+	1203,
+	1268,
+	1204,
+	1268,
+	1203,
+	1268,
+	1204,
+	1269,
+	1205,
+	1269,
+	1204,
+	1269,
+	1205,
+	1270,
+	1206,
+	1270,
+	1205,
+	1270,
+	1206,
+	1271,
+	1207,
+	1271,
+	1206,
+	1271,
+	1207,
+	1272,
+	1208,
+	1272,
+	1207,
+	1272,
+	1208,
+	1273,
+	1209,
+	1273,
+	1208,
+	1273,
+	1209,
+	1274,
+	1210,
+	1274,
+	1209,
+	1274,
+	1210,
+	1275,
+	1211,
+	1275,
+	1210,
+	1275,
+	1211,
+	1276,
+	1212,
+	1276,
+	1211,
+	1276,
+	1212,
+	1277,
+	1213,
+	1277,
+	1212,
+	1277,
+	1213,
+	1278,
+	1214,
+	1278,
+	1213,
+	1278,
+	1214,
+	1279,
+	1215,
+	1279,
+	1214,
+	1280,
+	1216,
+	1281,
+	1217,
+	1281,
+	1216,
+	1281,
+	1217,
+	1282,
+	1218,
+	1282,
+	1217,
+	1282,
+	1218,
+	1283,
+	1219,
+	1283,
+	1218,
+	1283,
+	1219,
+	1284,
+	1220,
+	1284,
+	1219,
+	1284,
+	1220,
+	1285,
+	1221,
+	1285,
+	1220,
+	1285,
+	1221,
+	1286,
+	1222,
+	1286,
+	1221,
+	1286,
+	1222,
+	1287,
+	1223,
+	1287,
+	1222,
+	1287,
+	1223,
+	1288,
+	1224,
+	1288,
+	1223,
+	1288,
+	1224,
+	1289,
+	1225,
+	1289,
+	1224,
+	1289,
+	1225,
+	1290,
+	1226,
+	1290,
+	1225,
+	1290,
+	1226,
+	1291,
+	1227,
+	1291,
+	1226,
+	1291,
+	1227,
+	1292,
+	1228,
+	1292,
+	1227,
+	1292,
+	1228,
+	1293,
+	1229,
+	1293,
+	1228,
+	1293,
+	1229,
+	1294,
+	1230,
+	1294,
+	1229,
+	1294,
+	1230,
+	1295,
+	1231,
+	1295,
+	1230,
+	1295,
+	1231,
+	1296,
+	1232,
+	1296,
+	1231,
+	1296,
+	1232,
+	1297,
+	1233,
+	1297,
+	1232,
+	1297,
+	1233,
+	1298,
+	1234,
+	1298,
+	1233,
+	1298,
+	1234,
+	1299,
+	1235,
+	1299,
+	1234,
+	1299,
+	1235,
+	1300,
+	1236,
+	1300,
+	1235,
+	1300,
+	1236,
+	1301,
+	1237,
+	1301,
+	1236,
+	1301,
+	1237,
+	1302,
+	1238,
+	1302,
+	1237,
+	1302,
+	1238,
+	1303,
+	1239,
+	1303,
+	1238,
+	1303,
+	1239,
+	1304,
+	1240,
+	1304,
+	1239,
+	1304,
+	1240,
+	1305,
+	1241,
+	1305,
+	1240,
+	1305,
+	1241,
+	1306,
+	1242,
+	1306,
+	1241,
+	1306,
+	1242,
+	1307,
+	1243,
+	1307,
+	1242,
+	1307,
+	1243,
+	1308,
+	1244,
+	1308,
+	1243,
+	1308,
+	1244,
+	1309,
+	1245,
+	1309,
+	1244,
+	1309,
+	1245,
+	1310,
+	1246,
+	1310,
+	1245,
+	1310,
+	1246,
+	1311,
+	1247,
+	1311,
+	1246,
+	1311,
+	1247,
+	1312,
+	1248,
+	1312,
+	1247,
+	1312,
+	1248,
+	1313,
+	1249,
+	1313,
+	1248,
+	1313,
+	1249,
+	1314,
+	1250,
+	1314,
+	1249,
+	1314,
+	1250,
+	1315,
+	1251,
+	1315,
+	1250,
+	1315,
+	1251,
+	1316,
+	1252,
+	1316,
+	1251,
+	1316,
+	1252,
+	1317,
+	1253,
+	1317,
+	1252,
+	1317,
+	1253,
+	1318,
+	1254,
+	1318,
+	1253,
+	1318,
+	1254,
+	1319,
+	1255,
+	1319,
+	1254,
+	1319,
+	1255,
+	1320,
+	1256,
+	1320,
+	1255,
+	1320,
+	1256,
+	1321,
+	1257,
+	1321,
+	1256,
+	1321,
+	1257,
+	1322,
+	1258,
+	1322,
+	1257,
+	1322,
+	1258,
+	1323,
+	1259,
+	1323,
+	1258,
+	1323,
+	1259,
+	1324,
+	1260,
+	1324,
+	1259,
+	1324,
+	1260,
+	1325,
+	1261,
+	1325,
+	1260,
+	1325,
+	1261,
+	1326,
+	1262,
+	1326,
+	1261,
+	1326,
+	1262,
+	1327,
+	1263,
+	1327,
+	1262,
+	1327,
+	1263,
+	1328,
+	1264,
+	1328,
+	1263,
+	1328,
+	1264,
+	1329,
+	1265,
+	1329,
+	1264,
+	1329,
+	1265,
+	1330,
+	1266,
+	1330,
+	1265,
+	1330,
+	1266,
+	1331,
+	1267,
+	1331,
+	1266,
+	1331,
+	1267,
+	1332,
+	1268,
+	1332,
+	1267,
+	1332,
+	1268,
+	1333,
+	1269,
+	1333,
+	1268,
+	1333,
+	1269,
+	1334,
+	1270,
+	1334,
+	1269,
+	1334,
+	1270,
+	1335,
+	1271,
+	1335,
+	1270,
+	1335,
+	1271,
+	1336,
+	1272,
+	1336,
+	1271,
+	1336,
+	1272,
+	1337,
+	1273,
+	1337,
+	1272,
+	1337,
+	1273,
+	1338,
+	1274,
+	1338,
+	1273,
+	1338,
+	1274,
+	1339,
+	1275,
+	1339,
+	1274,
+	1339,
+	1275,
+	1340,
+	1276,
+	1340,
+	1275,
+	1340,
+	1276,
+	1341,
+	1277,
+	1341,
+	1276,
+	1341,
+	1277,
+	1342,
+	1278,
+	1342,
+	1277,
+	1342,
+	1278,
+	1343,
+	1279,
+	1343,
+	1278,
+	1344,
+	1280,
+	1345,
+	1281,
+	1345,
+	1280,
+	1345,
+	1281,
+	1346,
+	1282,
+	1346,
+	1281,
+	1346,
+	1282,
+	1347,
+	1283,
+	1347,
+	1282,
+	1347,
+	1283,
+	1348,
+	1284,
+	1348,
+	1283,
+	1348,
+	1284,
+	1349,
+	1285,
+	1349,
+	1284,
+	1349,
+	1285,
+	1350,
+	1286,
+	1350,
+	1285,
+	1350,
+	1286,
+	1351,
+	1287,
+	1351,
+	1286,
+	1351,
+	1287,
+	1352,
+	1288,
+	1352,
+	1287,
+	1352,
+	1288,
+	1353,
+	1289,
+	1353,
+	1288,
+	1353,
+	1289,
+	1354,
+	1290,
+	1354,
+	1289,
+	1354,
+	1290,
+	1355,
+	1291,
+	1355,
+	1290,
+	1355,
+	1291,
+	1356,
+	1292,
+	1356,
+	1291,
+	1356,
+	1292,
+	1357,
+	1293,
+	1357,
+	1292,
+	1357,
+	1293,
+	1358,
+	1294,
+	1358,
+	1293,
+	1358,
+	1294,
+	1359,
+	1295,
+	1359,
+	1294,
+	1359,
+	1295,
+	1360,
+	1296,
+	1360,
+	1295,
+	1360,
+	1296,
+	1361,
+	1297,
+	1361,
+	1296,
+	1361,
+	1297,
+	1362,
+	1298,
+	1362,
+	1297,
+	1362,
+	1298,
+	1363,
+	1299,
+	1363,
+	1298,
+	1363,
+	1299,
+	1364,
+	1300,
+	1364,
+	1299,
+	1364,
+	1300,
+	1365,
+	1301,
+	1365,
+	1300,
+	1365,
+	1301,
+	1366,
+	1302,
+	1366,
+	1301,
+	1366,
+	1302,
+	1367,
+	1303,
+	1367,
+	1302,
+	1367,
+	1303,
+	1368,
+	1304,
+	1368,
+	1303,
+	1368,
+	1304,
+	1369,
+	1305,
+	1369,
+	1304,
+	1369,
+	1305,
+	1370,
+	1306,
+	1370,
+	1305,
+	1370,
+	1306,
+	1371,
+	1307,
+	1371,
+	1306,
+	1371,
+	1307,
+	1372,
+	1308,
+	1372,
+	1307,
+	1372,
+	1308,
+	1373,
+	1309,
+	1373,
+	1308,
+	1373,
+	1309,
+	1374,
+	1310,
+	1374,
+	1309,
+	1374,
+	1310,
+	1375,
+	1311,
+	1375,
+	1310,
+	1375,
+	1311,
+	1376,
+	1312,
+	1376,
+	1311,
+	1376,
+	1312,
+	1377,
+	1313,
+	1377,
+	1312,
+	1377,
+	1313,
+	1378,
+	1314,
+	1378,
+	1313,
+	1378,
+	1314,
+	1379,
+	1315,
+	1379,
+	1314,
+	1379,
+	1315,
+	1380,
+	1316,
+	1380,
+	1315,
+	1380,
+	1316,
+	1381,
+	1317,
+	1381,
+	1316,
+	1381,
+	1317,
+	1382,
+	1318,
+	1382,
+	1317,
+	1382,
+	1318,
+	1383,
+	1319,
+	1383,
+	1318,
+	1383,
+	1319,
+	1384,
+	1320,
+	1384,
+	1319,
+	1384,
+	1320,
+	1385,
+	1321,
+	1385,
+	1320,
+	1385,
+	1321,
+	1386,
+	1322,
+	1386,
+	1321,
+	1386,
+	1322,
+	1387,
+	1323,
+	1387,
+	1322,
+	1387,
+	1323,
+	1388,
+	1324,
+	1388,
+	1323,
+	1388,
+	1324,
+	1389,
+	1325,
+	1389,
+	1324,
+	1389,
+	1325,
+	1390,
+	1326,
+	1390,
+	1325,
+	1390,
+	1326,
+	1391,
+	1327,
+	1391,
+	1326,
+	1391,
+	1327,
+	1392,
+	1328,
+	1392,
+	1327,
+	1392,
+	1328,
+	1393,
+	1329,
+	1393,
+	1328,
+	1393,
+	1329,
+	1394,
+	1330,
+	1394,
+	1329,
+	1394,
+	1330,
+	1395,
+	1331,
+	1395,
+	1330,
+	1395,
+	1331,
+	1396,
+	1332,
+	1396,
+	1331,
+	1396,
+	1332,
+	1397,
+	1333,
+	1397,
+	1332,
+	1397,
+	1333,
+	1398,
+	1334,
+	1398,
+	1333,
+	1398,
+	1334,
+	1399,
+	1335,
+	1399,
+	1334,
+	1399,
+	1335,
+	1400,
+	1336,
+	1400,
+	1335,
+	1400,
+	1336,
+	1401,
+	1337,
+	1401,
+	1336,
+	1401,
+	1337,
+	1402,
+	1338,
+	1402,
+	1337,
+	1402,
+	1338,
+	1403,
+	1339,
+	1403,
+	1338,
+	1403,
+	1339,
+	1404,
+	1340,
+	1404,
+	1339,
+	1404,
+	1340,
+	1405,
+	1341,
+	1405,
+	1340,
+	1405,
+	1341,
+	1406,
+	1342,
+	1406,
+	1341,
+	1406,
+	1342,
+	1407,
+	1343,
+	1407,
+	1342,
+	1408,
+	1344,
+	1409,
+	1345,
+	1409,
+	1344,
+	1409,
+	1345,
+	1410,
+	1346,
+	1410,
+	1345,
+	1410,
+	1346,
+	1411,
+	1347,
+	1411,
+	1346,
+	1411,
+	1347,
+	1412,
+	1348,
+	1412,
+	1347,
+	1412,
+	1348,
+	1413,
+	1349,
+	1413,
+	1348,
+	1413,
+	1349,
+	1414,
+	1350,
+	1414,
+	1349,
+	1414,
+	1350,
+	1415,
+	1351,
+	1415,
+	1350,
+	1415,
+	1351,
+	1416,
+	1352,
+	1416,
+	1351,
+	1416,
+	1352,
+	1417,
+	1353,
+	1417,
+	1352,
+	1417,
+	1353,
+	1418,
+	1354,
+	1418,
+	1353,
+	1418,
+	1354,
+	1419,
+	1355,
+	1419,
+	1354,
+	1419,
+	1355,
+	1420,
+	1356,
+	1420,
+	1355,
+	1420,
+	1356,
+	1421,
+	1357,
+	1421,
+	1356,
+	1421,
+	1357,
+	1422,
+	1358,
+	1422,
+	1357,
+	1422,
+	1358,
+	1423,
+	1359,
+	1423,
+	1358,
+	1423,
+	1359,
+	1424,
+	1360,
+	1424,
+	1359,
+	1424,
+	1360,
+	1425,
+	1361,
+	1425,
+	1360,
+	1425,
+	1361,
+	1426,
+	1362,
+	1426,
+	1361,
+	1426,
+	1362,
+	1427,
+	1363,
+	1427,
+	1362,
+	1427,
+	1363,
+	1428,
+	1364,
+	1428,
+	1363,
+	1428,
+	1364,
+	1429,
+	1365,
+	1429,
+	1364,
+	1429,
+	1365,
+	1430,
+	1366,
+	1430,
+	1365,
+	1430,
+	1366,
+	1431,
+	1367,
+	1431,
+	1366,
+	1431,
+	1367,
+	1432,
+	1368,
+	1432,
+	1367,
+	1432,
+	1368,
+	1433,
+	1369,
+	1433,
+	1368,
+	1433,
+	1369,
+	1434,
+	1370,
+	1434,
+	1369,
+	1434,
+	1370,
+	1435,
+	1371,
+	1435,
+	1370,
+	1435,
+	1371,
+	1436,
+	1372,
+	1436,
+	1371,
+	1436,
+	1372,
+	1437,
+	1373,
+	1437,
+	1372,
+	1437,
+	1373,
+	1438,
+	1374,
+	1438,
+	1373,
+	1438,
+	1374,
+	1439,
+	1375,
+	1439,
+	1374,
+	1439,
+	1375,
+	1440,
+	1376,
+	1440,
+	1375,
+	1440,
+	1376,
+	1441,
+	1377,
+	1441,
+	1376,
+	1441,
+	1377,
+	1442,
+	1378,
+	1442,
+	1377,
+	1442,
+	1378,
+	1443,
+	1379,
+	1443,
+	1378,
+	1443,
+	1379,
+	1444,
+	1380,
+	1444,
+	1379,
+	1444,
+	1380,
+	1445,
+	1381,
+	1445,
+	1380,
+	1445,
+	1381,
+	1446,
+	1382,
+	1446,
+	1381,
+	1446,
+	1382,
+	1447,
+	1383,
+	1447,
+	1382,
+	1447,
+	1383,
+	1448,
+	1384,
+	1448,
+	1383,
+	1448,
+	1384,
+	1449,
+	1385,
+	1449,
+	1384,
+	1449,
+	1385,
+	1450,
+	1386,
+	1450,
+	1385,
+	1450,
+	1386,
+	1451,
+	1387,
+	1451,
+	1386,
+	1451,
+	1387,
+	1452,
+	1388,
+	1452,
+	1387,
+	1452,
+	1388,
+	1453,
+	1389,
+	1453,
+	1388,
+	1453,
+	1389,
+	1454,
+	1390,
+	1454,
+	1389,
+	1454,
+	1390,
+	1455,
+	1391,
+	1455,
+	1390,
+	1455,
+	1391,
+	1456,
+	1392,
+	1456,
+	1391,
+	1456,
+	1392,
+	1457,
+	1393,
+	1457,
+	1392,
+	1457,
+	1393,
+	1458,
+	1394,
+	1458,
+	1393,
+	1458,
+	1394,
+	1459,
+	1395,
+	1459,
+	1394,
+	1459,
+	1395,
+	1460,
+	1396,
+	1460,
+	1395,
+	1460,
+	1396,
+	1461,
+	1397,
+	1461,
+	1396,
+	1461,
+	1397,
+	1462,
+	1398,
+	1462,
+	1397,
+	1462,
+	1398,
+	1463,
+	1399,
+	1463,
+	1398,
+	1463,
+	1399,
+	1464,
+	1400,
+	1464,
+	1399,
+	1464,
+	1400,
+	1465,
+	1401,
+	1465,
+	1400,
+	1465,
+	1401,
+	1466,
+	1402,
+	1466,
+	1401,
+	1466,
+	1402,
+	1467,
+	1403,
+	1467,
+	1402,
+	1467,
+	1403,
+	1468,
+	1404,
+	1468,
+	1403,
+	1468,
+	1404,
+	1469,
+	1405,
+	1469,
+	1404,
+	1469,
+	1405,
+	1470,
+	1406,
+	1470,
+	1405,
+	1470,
+	1406,
+	1471,
+	1407,
+	1471,
+	1406,
+	1472,
+	1408,
+	1473,
+	1409,
+	1473,
+	1408,
+	1473,
+	1409,
+	1474,
+	1410,
+	1474,
+	1409,
+	1474,
+	1410,
+	1475,
+	1411,
+	1475,
+	1410,
+	1475,
+	1411,
+	1476,
+	1412,
+	1476,
+	1411,
+	1476,
+	1412,
+	1477,
+	1413,
+	1477,
+	1412,
+	1477,
+	1413,
+	1478,
+	1414,
+	1478,
+	1413,
+	1478,
+	1414,
+	1479,
+	1415,
+	1479,
+	1414,
+	1479,
+	1415,
+	1480,
+	1416,
+	1480,
+	1415,
+	1480,
+	1416,
+	1481,
+	1417,
+	1481,
+	1416,
+	1481,
+	1417,
+	1482,
+	1418,
+	1482,
+	1417,
+	1482,
+	1418,
+	1483,
+	1419,
+	1483,
+	1418,
+	1483,
+	1419,
+	1484,
+	1420,
+	1484,
+	1419,
+	1484,
+	1420,
+	1485,
+	1421,
+	1485,
+	1420,
+	1485,
+	1421,
+	1486,
+	1422,
+	1486,
+	1421,
+	1486,
+	1422,
+	1487,
+	1423,
+	1487,
+	1422,
+	1487,
+	1423,
+	1488,
+	1424,
+	1488,
+	1423,
+	1488,
+	1424,
+	1489,
+	1425,
+	1489,
+	1424,
+	1489,
+	1425,
+	1490,
+	1426,
+	1490,
+	1425,
+	1490,
+	1426,
+	1491,
+	1427,
+	1491,
+	1426,
+	1491,
+	1427,
+	1492,
+	1428,
+	1492,
+	1427,
+	1492,
+	1428,
+	1493,
+	1429,
+	1493,
+	1428,
+	1493,
+	1429,
+	1494,
+	1430,
+	1494,
+	1429,
+	1494,
+	1430,
+	1495,
+	1431,
+	1495,
+	1430,
+	1495,
+	1431,
+	1496,
+	1432,
+	1496,
+	1431,
+	1496,
+	1432,
+	1497,
+	1433,
+	1497,
+	1432,
+	1497,
+	1433,
+	1498,
+	1434,
+	1498,
+	1433,
+	1498,
+	1434,
+	1499,
+	1435,
+	1499,
+	1434,
+	1499,
+	1435,
+	1500,
+	1436,
+	1500,
+	1435,
+	1500,
+	1436,
+	1501,
+	1437,
+	1501,
+	1436,
+	1501,
+	1437,
+	1502,
+	1438,
+	1502,
+	1437,
+	1502,
+	1438,
+	1503,
+	1439,
+	1503,
+	1438,
+	1503,
+	1439,
+	1504,
+	1440,
+	1504,
+	1439,
+	1504,
+	1440,
+	1505,
+	1441,
+	1505,
+	1440,
+	1505,
+	1441,
+	1506,
+	1442,
+	1506,
+	1441,
+	1506,
+	1442,
+	1507,
+	1443,
+	1507,
+	1442,
+	1507,
+	1443,
+	1508,
+	1444,
+	1508,
+	1443,
+	1508,
+	1444,
+	1509,
+	1445,
+	1509,
+	1444,
+	1509,
+	1445,
+	1510,
+	1446,
+	1510,
+	1445,
+	1510,
+	1446,
+	1511,
+	1447,
+	1511,
+	1446,
+	1511,
+	1447,
+	1512,
+	1448,
+	1512,
+	1447,
+	1512,
+	1448,
+	1513,
+	1449,
+	1513,
+	1448,
+	1513,
+	1449,
+	1514,
+	1450,
+	1514,
+	1449,
+	1514,
+	1450,
+	1515,
+	1451,
+	1515,
+	1450,
+	1515,
+	1451,
+	1516,
+	1452,
+	1516,
+	1451,
+	1516,
+	1452,
+	1517,
+	1453,
+	1517,
+	1452,
+	1517,
+	1453,
+	1518,
+	1454,
+	1518,
+	1453,
+	1518,
+	1454,
+	1519,
+	1455,
+	1519,
+	1454,
+	1519,
+	1455,
+	1520,
+	1456,
+	1520,
+	1455,
+	1520,
+	1456,
+	1521,
+	1457,
+	1521,
+	1456,
+	1521,
+	1457,
+	1522,
+	1458,
+	1522,
+	1457,
+	1522,
+	1458,
+	1523,
+	1459,
+	1523,
+	1458,
+	1523,
+	1459,
+	1524,
+	1460,
+	1524,
+	1459,
+	1524,
+	1460,
+	1525,
+	1461,
+	1525,
+	1460,
+	1525,
+	1461,
+	1526,
+	1462,
+	1526,
+	1461,
+	1526,
+	1462,
+	1527,
+	1463,
+	1527,
+	1462,
+	1527,
+	1463,
+	1528,
+	1464,
+	1528,
+	1463,
+	1528,
+	1464,
+	1529,
+	1465,
+	1529,
+	1464,
+	1529,
+	1465,
+	1530,
+	1466,
+	1530,
+	1465,
+	1530,
+	1466,
+	1531,
+	1467,
+	1531,
+	1466,
+	1531,
+	1467,
+	1532,
+	1468,
+	1532,
+	1467,
+	1532,
+	1468,
+	1533,
+	1469,
+	1533,
+	1468,
+	1533,
+	1469,
+	1534,
+	1470,
+	1534,
+	1469,
+	1534,
+	1470,
+	1535,
+	1471,
+	1535,
+	1470,
+	1536,
+	1472,
+	1537,
+	1473,
+	1537,
+	1472,
+	1537,
+	1473,
+	1538,
+	1474,
+	1538,
+	1473,
+	1538,
+	1474,
+	1539,
+	1475,
+	1539,
+	1474,
+	1539,
+	1475,
+	1540,
+	1476,
+	1540,
+	1475,
+	1540,
+	1476,
+	1541,
+	1477,
+	1541,
+	1476,
+	1541,
+	1477,
+	1542,
+	1478,
+	1542,
+	1477,
+	1542,
+	1478,
+	1543,
+	1479,
+	1543,
+	1478,
+	1543,
+	1479,
+	1544,
+	1480,
+	1544,
+	1479,
+	1544,
+	1480,
+	1545,
+	1481,
+	1545,
+	1480,
+	1545,
+	1481,
+	1546,
+	1482,
+	1546,
+	1481,
+	1546,
+	1482,
+	1547,
+	1483,
+	1547,
+	1482,
+	1547,
+	1483,
+	1548,
+	1484,
+	1548,
+	1483,
+	1548,
+	1484,
+	1549,
+	1485,
+	1549,
+	1484,
+	1549,
+	1485,
+	1550,
+	1486,
+	1550,
+	1485,
+	1550,
+	1486,
+	1551,
+	1487,
+	1551,
+	1486,
+	1551,
+	1487,
+	1552,
+	1488,
+	1552,
+	1487,
+	1552,
+	1488,
+	1553,
+	1489,
+	1553,
+	1488,
+	1553,
+	1489,
+	1554,
+	1490,
+	1554,
+	1489,
+	1554,
+	1490,
+	1555,
+	1491,
+	1555,
+	1490,
+	1555,
+	1491,
+	1556,
+	1492,
+	1556,
+	1491,
+	1556,
+	1492,
+	1557,
+	1493,
+	1557,
+	1492,
+	1557,
+	1493,
+	1558,
+	1494,
+	1558,
+	1493,
+	1558,
+	1494,
+	1559,
+	1495,
+	1559,
+	1494,
+	1559,
+	1495,
+	1560,
+	1496,
+	1560,
+	1495,
+	1560,
+	1496,
+	1561,
+	1497,
+	1561,
+	1496,
+	1561,
+	1497,
+	1562,
+	1498,
+	1562,
+	1497,
+	1562,
+	1498,
+	1563,
+	1499,
+	1563,
+	1498,
+	1563,
+	1499,
+	1564,
+	1500,
+	1564,
+	1499,
+	1564,
+	1500,
+	1565,
+	1501,
+	1565,
+	1500,
+	1565,
+	1501,
+	1566,
+	1502,
+	1566,
+	1501,
+	1566,
+	1502,
+	1567,
+	1503,
+	1567,
+	1502,
+	1567,
+	1503,
+	1568,
+	1504,
+	1568,
+	1503,
+	1568,
+	1504,
+	1569,
+	1505,
+	1569,
+	1504,
+	1569,
+	1505,
+	1570,
+	1506,
+	1570,
+	1505,
+	1570,
+	1506,
+	1571,
+	1507,
+	1571,
+	1506,
+	1571,
+	1507,
+	1572,
+	1508,
+	1572,
+	1507,
+	1572,
+	1508,
+	1573,
+	1509,
+	1573,
+	1508,
+	1573,
+	1509,
+	1574,
+	1510,
+	1574,
+	1509,
+	1574,
+	1510,
+	1575,
+	1511,
+	1575,
+	1510,
+	1575,
+	1511,
+	1576,
+	1512,
+	1576,
+	1511,
+	1576,
+	1512,
+	1577,
+	1513,
+	1577,
+	1512,
+	1577,
+	1513,
+	1578,
+	1514,
+	1578,
+	1513,
+	1578,
+	1514,
+	1579,
+	1515,
+	1579,
+	1514,
+	1579,
+	1515,
+	1580,
+	1516,
+	1580,
+	1515,
+	1580,
+	1516,
+	1581,
+	1517,
+	1581,
+	1516,
+	1581,
+	1517,
+	1582,
+	1518,
+	1582,
+	1517,
+	1582,
+	1518,
+	1583,
+	1519,
+	1583,
+	1518,
+	1583,
+	1519,
+	1584,
+	1520,
+	1584,
+	1519,
+	1584,
+	1520,
+	1585,
+	1521,
+	1585,
+	1520,
+	1585,
+	1521,
+	1586,
+	1522,
+	1586,
+	1521,
+	1586,
+	1522,
+	1587,
+	1523,
+	1587,
+	1522,
+	1587,
+	1523,
+	1588,
+	1524,
+	1588,
+	1523,
+	1588,
+	1524,
+	1589,
+	1525,
+	1589,
+	1524,
+	1589,
+	1525,
+	1590,
+	1526,
+	1590,
+	1525,
+	1590,
+	1526,
+	1591,
+	1527,
+	1591,
+	1526,
+	1591,
+	1527,
+	1592,
+	1528,
+	1592,
+	1527,
+	1592,
+	1528,
+	1593,
+	1529,
+	1593,
+	1528,
+	1593,
+	1529,
+	1594,
+	1530,
+	1594,
+	1529,
+	1594,
+	1530,
+	1595,
+	1531,
+	1595,
+	1530,
+	1595,
+	1531,
+	1596,
+	1532,
+	1596,
+	1531,
+	1596,
+	1532,
+	1597,
+	1533,
+	1597,
+	1532,
+	1597,
+	1533,
+	1598,
+	1534,
+	1598,
+	1533,
+	1598,
+	1534,
+	1599,
+	1535,
+	1599,
+	1534,
+	1600,
+	1536,
+	1601,
+	1537,
+	1601,
+	1536,
+	1601,
+	1537,
+	1602,
+	1538,
+	1602,
+	1537,
+	1602,
+	1538,
+	1603,
+	1539,
+	1603,
+	1538,
+	1603,
+	1539,
+	1604,
+	1540,
+	1604,
+	1539,
+	1604,
+	1540,
+	1605,
+	1541,
+	1605,
+	1540,
+	1605,
+	1541,
+	1606,
+	1542,
+	1606,
+	1541,
+	1606,
+	1542,
+	1607,
+	1543,
+	1607,
+	1542,
+	1607,
+	1543,
+	1608,
+	1544,
+	1608,
+	1543,
+	1608,
+	1544,
+	1609,
+	1545,
+	1609,
+	1544,
+	1609,
+	1545,
+	1610,
+	1546,
+	1610,
+	1545,
+	1610,
+	1546,
+	1611,
+	1547,
+	1611,
+	1546,
+	1611,
+	1547,
+	1612,
+	1548,
+	1612,
+	1547,
+	1612,
+	1548,
+	1613,
+	1549,
+	1613,
+	1548,
+	1613,
+	1549,
+	1614,
+	1550,
+	1614,
+	1549,
+	1614,
+	1550,
+	1615,
+	1551,
+	1615,
+	1550,
+	1615,
+	1551,
+	1616,
+	1552,
+	1616,
+	1551,
+	1616,
+	1552,
+	1617,
+	1553,
+	1617,
+	1552,
+	1617,
+	1553,
+	1618,
+	1554,
+	1618,
+	1553,
+	1618,
+	1554,
+	1619,
+	1555,
+	1619,
+	1554,
+	1619,
+	1555,
+	1620,
+	1556,
+	1620,
+	1555,
+	1620,
+	1556,
+	1621,
+	1557,
+	1621,
+	1556,
+	1621,
+	1557,
+	1622,
+	1558,
+	1622,
+	1557,
+	1622,
+	1558,
+	1623,
+	1559,
+	1623,
+	1558,
+	1623,
+	1559,
+	1624,
+	1560,
+	1624,
+	1559,
+	1624,
+	1560,
+	1625,
+	1561,
+	1625,
+	1560,
+	1625,
+	1561,
+	1626,
+	1562,
+	1626,
+	1561,
+	1626,
+	1562,
+	1627,
+	1563,
+	1627,
+	1562,
+	1627,
+	1563,
+	1628,
+	1564,
+	1628,
+	1563,
+	1628,
+	1564,
+	1629,
+	1565,
+	1629,
+	1564,
+	1629,
+	1565,
+	1630,
+	1566,
+	1630,
+	1565,
+	1630,
+	1566,
+	1631,
+	1567,
+	1631,
+	1566,
+	1631,
+	1567,
+	1632,
+	1568,
+	1632,
+	1567,
+	1632,
+	1568,
+	1633,
+	1569,
+	1633,
+	1568,
+	1633,
+	1569,
+	1634,
+	1570,
+	1634,
+	1569,
+	1634,
+	1570,
+	1635,
+	1571,
+	1635,
+	1570,
+	1635,
+	1571,
+	1636,
+	1572,
+	1636,
+	1571,
+	1636,
+	1572,
+	1637,
+	1573,
+	1637,
+	1572,
+	1637,
+	1573,
+	1638,
+	1574,
+	1638,
+	1573,
+	1638,
+	1574,
+	1639,
+	1575,
+	1639,
+	1574,
+	1639,
+	1575,
+	1640,
+	1576,
+	1640,
+	1575,
+	1640,
+	1576,
+	1641,
+	1577,
+	1641,
+	1576,
+	1641,
+	1577,
+	1642,
+	1578,
+	1642,
+	1577,
+	1642,
+	1578,
+	1643,
+	1579,
+	1643,
+	1578,
+	1643,
+	1579,
+	1644,
+	1580,
+	1644,
+	1579,
+	1644,
+	1580,
+	1645,
+	1581,
+	1645,
+	1580,
+	1645,
+	1581,
+	1646,
+	1582,
+	1646,
+	1581,
+	1646,
+	1582,
+	1647,
+	1583,
+	1647,
+	1582,
+	1647,
+	1583,
+	1648,
+	1584,
+	1648,
+	1583,
+	1648,
+	1584,
+	1649,
+	1585,
+	1649,
+	1584,
+	1649,
+	1585,
+	1650,
+	1586,
+	1650,
+	1585,
+	1650,
+	1586,
+	1651,
+	1587,
+	1651,
+	1586,
+	1651,
+	1587,
+	1652,
+	1588,
+	1652,
+	1587,
+	1652,
+	1588,
+	1653,
+	1589,
+	1653,
+	1588,
+	1653,
+	1589,
+	1654,
+	1590,
+	1654,
+	1589,
+	1654,
+	1590,
+	1655,
+	1591,
+	1655,
+	1590,
+	1655,
+	1591,
+	1656,
+	1592,
+	1656,
+	1591,
+	1656,
+	1592,
+	1657,
+	1593,
+	1657,
+	1592,
+	1657,
+	1593,
+	1658,
+	1594,
+	1658,
+	1593,
+	1658,
+	1594,
+	1659,
+	1595,
+	1659,
+	1594,
+	1659,
+	1595,
+	1660,
+	1596,
+	1660,
+	1595,
+	1660,
+	1596,
+	1661,
+	1597,
+	1661,
+	1596,
+	1661,
+	1597,
+	1662,
+	1598,
+	1662,
+	1597,
+	1662,
+	1598,
+	1663,
+	1599,
+	1663,
+	1598,
+	1664,
+	1600,
+	1665,
+	1601,
+	1665,
+	1600,
+	1665,
+	1601,
+	1666,
+	1602,
+	1666,
+	1601,
+	1666,
+	1602,
+	1667,
+	1603,
+	1667,
+	1602,
+	1667,
+	1603,
+	1668,
+	1604,
+	1668,
+	1603,
+	1668,
+	1604,
+	1669,
+	1605,
+	1669,
+	1604,
+	1669,
+	1605,
+	1670,
+	1606,
+	1670,
+	1605,
+	1670,
+	1606,
+	1671,
+	1607,
+	1671,
+	1606,
+	1671,
+	1607,
+	1672,
+	1608,
+	1672,
+	1607,
+	1672,
+	1608,
+	1673,
+	1609,
+	1673,
+	1608,
+	1673,
+	1609,
+	1674,
+	1610,
+	1674,
+	1609,
+	1674,
+	1610,
+	1675,
+	1611,
+	1675,
+	1610,
+	1675,
+	1611,
+	1676,
+	1612,
+	1676,
+	1611,
+	1676,
+	1612,
+	1677,
+	1613,
+	1677,
+	1612,
+	1677,
+	1613,
+	1678,
+	1614,
+	1678,
+	1613,
+	1678,
+	1614,
+	1679,
+	1615,
+	1679,
+	1614,
+	1679,
+	1615,
+	1680,
+	1616,
+	1680,
+	1615,
+	1680,
+	1616,
+	1681,
+	1617,
+	1681,
+	1616,
+	1681,
+	1617,
+	1682,
+	1618,
+	1682,
+	1617,
+	1682,
+	1618,
+	1683,
+	1619,
+	1683,
+	1618,
+	1683,
+	1619,
+	1684,
+	1620,
+	1684,
+	1619,
+	1684,
+	1620,
+	1685,
+	1621,
+	1685,
+	1620,
+	1685,
+	1621,
+	1686,
+	1622,
+	1686,
+	1621,
+	1686,
+	1622,
+	1687,
+	1623,
+	1687,
+	1622,
+	1687,
+	1623,
+	1688,
+	1624,
+	1688,
+	1623,
+	1688,
+	1624,
+	1689,
+	1625,
+	1689,
+	1624,
+	1689,
+	1625,
+	1690,
+	1626,
+	1690,
+	1625,
+	1690,
+	1626,
+	1691,
+	1627,
+	1691,
+	1626,
+	1691,
+	1627,
+	1692,
+	1628,
+	1692,
+	1627,
+	1692,
+	1628,
+	1693,
+	1629,
+	1693,
+	1628,
+	1693,
+	1629,
+	1694,
+	1630,
+	1694,
+	1629,
+	1694,
+	1630,
+	1695,
+	1631,
+	1695,
+	1630,
+	1695,
+	1631,
+	1696,
+	1632,
+	1696,
+	1631,
+	1696,
+	1632,
+	1697,
+	1633,
+	1697,
+	1632,
+	1697,
+	1633,
+	1698,
+	1634,
+	1698,
+	1633,
+	1698,
+	1634,
+	1699,
+	1635,
+	1699,
+	1634,
+	1699,
+	1635,
+	1700,
+	1636,
+	1700,
+	1635,
+	1700,
+	1636,
+	1701,
+	1637,
+	1701,
+	1636,
+	1701,
+	1637,
+	1702,
+	1638,
+	1702,
+	1637,
+	1702,
+	1638,
+	1703,
+	1639,
+	1703,
+	1638,
+	1703,
+	1639,
+	1704,
+	1640,
+	1704,
+	1639,
+	1704,
+	1640,
+	1705,
+	1641,
+	1705,
+	1640,
+	1705,
+	1641,
+	1706,
+	1642,
+	1706,
+	1641,
+	1706,
+	1642,
+	1707,
+	1643,
+	1707,
+	1642,
+	1707,
+	1643,
+	1708,
+	1644,
+	1708,
+	1643,
+	1708,
+	1644,
+	1709,
+	1645,
+	1709,
+	1644,
+	1709,
+	1645,
+	1710,
+	1646,
+	1710,
+	1645,
+	1710,
+	1646,
+	1711,
+	1647,
+	1711,
+	1646,
+	1711,
+	1647,
+	1712,
+	1648,
+	1712,
+	1647,
+	1712,
+	1648,
+	1713,
+	1649,
+	1713,
+	1648,
+	1713,
+	1649,
+	1714,
+	1650,
+	1714,
+	1649,
+	1714,
+	1650,
+	1715,
+	1651,
+	1715,
+	1650,
+	1715,
+	1651,
+	1716,
+	1652,
+	1716,
+	1651,
+	1716,
+	1652,
+	1717,
+	1653,
+	1717,
+	1652,
+	1717,
+	1653,
+	1718,
+	1654,
+	1718,
+	1653,
+	1718,
+	1654,
+	1719,
+	1655,
+	1719,
+	1654,
+	1719,
+	1655,
+	1720,
+	1656,
+	1720,
+	1655,
+	1720,
+	1656,
+	1721,
+	1657,
+	1721,
+	1656,
+	1721,
+	1657,
+	1722,
+	1658,
+	1722,
+	1657,
+	1722,
+	1658,
+	1723,
+	1659,
+	1723,
+	1658,
+	1723,
+	1659,
+	1724,
+	1660,
+	1724,
+	1659,
+	1724,
+	1660,
+	1725,
+	1661,
+	1725,
+	1660,
+	1725,
+	1661,
+	1726,
+	1662,
+	1726,
+	1661,
+	1726,
+	1662,
+	1727,
+	1663,
+	1727,
+	1662,
+	1728,
+	1664,
+	1729,
+	1665,
+	1729,
+	1664,
+	1729,
+	1665,
+	1730,
+	1666,
+	1730,
+	1665,
+	1730,
+	1666,
+	1731,
+	1667,
+	1731,
+	1666,
+	1731,
+	1667,
+	1732,
+	1668,
+	1732,
+	1667,
+	1732,
+	1668,
+	1733,
+	1669,
+	1733,
+	1668,
+	1733,
+	1669,
+	1734,
+	1670,
+	1734,
+	1669,
+	1734,
+	1670,
+	1735,
+	1671,
+	1735,
+	1670,
+	1735,
+	1671,
+	1736,
+	1672,
+	1736,
+	1671,
+	1736,
+	1672,
+	1737,
+	1673,
+	1737,
+	1672,
+	1737,
+	1673,
+	1738,
+	1674,
+	1738,
+	1673,
+	1738,
+	1674,
+	1739,
+	1675,
+	1739,
+	1674,
+	1739,
+	1675,
+	1740,
+	1676,
+	1740,
+	1675,
+	1740,
+	1676,
+	1741,
+	1677,
+	1741,
+	1676,
+	1741,
+	1677,
+	1742,
+	1678,
+	1742,
+	1677,
+	1742,
+	1678,
+	1743,
+	1679,
+	1743,
+	1678,
+	1743,
+	1679,
+	1744,
+	1680,
+	1744,
+	1679,
+	1744,
+	1680,
+	1745,
+	1681,
+	1745,
+	1680,
+	1745,
+	1681,
+	1746,
+	1682,
+	1746,
+	1681,
+	1746,
+	1682,
+	1747,
+	1683,
+	1747,
+	1682,
+	1747,
+	1683,
+	1748,
+	1684,
+	1748,
+	1683,
+	1748,
+	1684,
+	1749,
+	1685,
+	1749,
+	1684,
+	1749,
+	1685,
+	1750,
+	1686,
+	1750,
+	1685,
+	1750,
+	1686,
+	1751,
+	1687,
+	1751,
+	1686,
+	1751,
+	1687,
+	1752,
+	1688,
+	1752,
+	1687,
+	1752,
+	1688,
+	1753,
+	1689,
+	1753,
+	1688,
+	1753,
+	1689,
+	1754,
+	1690,
+	1754,
+	1689,
+	1754,
+	1690,
+	1755,
+	1691,
+	1755,
+	1690,
+	1755,
+	1691,
+	1756,
+	1692,
+	1756,
+	1691,
+	1756,
+	1692,
+	1757,
+	1693,
+	1757,
+	1692,
+	1757,
+	1693,
+	1758,
+	1694,
+	1758,
+	1693,
+	1758,
+	1694,
+	1759,
+	1695,
+	1759,
+	1694,
+	1759,
+	1695,
+	1760,
+	1696,
+	1760,
+	1695,
+	1760,
+	1696,
+	1761,
+	1697,
+	1761,
+	1696,
+	1761,
+	1697,
+	1762,
+	1698,
+	1762,
+	1697,
+	1762,
+	1698,
+	1763,
+	1699,
+	1763,
+	1698,
+	1763,
+	1699,
+	1764,
+	1700,
+	1764,
+	1699,
+	1764,
+	1700,
+	1765,
+	1701,
+	1765,
+	1700,
+	1765,
+	1701,
+	1766,
+	1702,
+	1766,
+	1701,
+	1766,
+	1702,
+	1767,
+	1703,
+	1767,
+	1702,
+	1767,
+	1703,
+	1768,
+	1704,
+	1768,
+	1703,
+	1768,
+	1704,
+	1769,
+	1705,
+	1769,
+	1704,
+	1769,
+	1705,
+	1770,
+	1706,
+	1770,
+	1705,
+	1770,
+	1706,
+	1771,
+	1707,
+	1771,
+	1706,
+	1771,
+	1707,
+	1772,
+	1708,
+	1772,
+	1707,
+	1772,
+	1708,
+	1773,
+	1709,
+	1773,
+	1708,
+	1773,
+	1709,
+	1774,
+	1710,
+	1774,
+	1709,
+	1774,
+	1710,
+	1775,
+	1711,
+	1775,
+	1710,
+	1775,
+	1711,
+	1776,
+	1712,
+	1776,
+	1711,
+	1776,
+	1712,
+	1777,
+	1713,
+	1777,
+	1712,
+	1777,
+	1713,
+	1778,
+	1714,
+	1778,
+	1713,
+	1778,
+	1714,
+	1779,
+	1715,
+	1779,
+	1714,
+	1779,
+	1715,
+	1780,
+	1716,
+	1780,
+	1715,
+	1780,
+	1716,
+	1781,
+	1717,
+	1781,
+	1716,
+	1781,
+	1717,
+	1782,
+	1718,
+	1782,
+	1717,
+	1782,
+	1718,
+	1783,
+	1719,
+	1783,
+	1718,
+	1783,
+	1719,
+	1784,
+	1720,
+	1784,
+	1719,
+	1784,
+	1720,
+	1785,
+	1721,
+	1785,
+	1720,
+	1785,
+	1721,
+	1786,
+	1722,
+	1786,
+	1721,
+	1786,
+	1722,
+	1787,
+	1723,
+	1787,
+	1722,
+	1787,
+	1723,
+	1788,
+	1724,
+	1788,
+	1723,
+	1788,
+	1724,
+	1789,
+	1725,
+	1789,
+	1724,
+	1789,
+	1725,
+	1790,
+	1726,
+	1790,
+	1725,
+	1790,
+	1726,
+	1791,
+	1727,
+	1791,
+	1726,
+	1792,
+	1728,
+	1793,
+	1729,
+	1793,
+	1728,
+	1793,
+	1729,
+	1794,
+	1730,
+	1794,
+	1729,
+	1794,
+	1730,
+	1795,
+	1731,
+	1795,
+	1730,
+	1795,
+	1731,
+	1796,
+	1732,
+	1796,
+	1731,
+	1796,
+	1732,
+	1797,
+	1733,
+	1797,
+	1732,
+	1797,
+	1733,
+	1798,
+	1734,
+	1798,
+	1733,
+	1798,
+	1734,
+	1799,
+	1735,
+	1799,
+	1734,
+	1799,
+	1735,
+	1800,
+	1736,
+	1800,
+	1735,
+	1800,
+	1736,
+	1801,
+	1737,
+	1801,
+	1736,
+	1801,
+	1737,
+	1802,
+	1738,
+	1802,
+	1737,
+	1802,
+	1738,
+	1803,
+	1739,
+	1803,
+	1738,
+	1803,
+	1739,
+	1804,
+	1740,
+	1804,
+	1739,
+	1804,
+	1740,
+	1805,
+	1741,
+	1805,
+	1740,
+	1805,
+	1741,
+	1806,
+	1742,
+	1806,
+	1741,
+	1806,
+	1742,
+	1807,
+	1743,
+	1807,
+	1742,
+	1807,
+	1743,
+	1808,
+	1744,
+	1808,
+	1743,
+	1808,
+	1744,
+	1809,
+	1745,
+	1809,
+	1744,
+	1809,
+	1745,
+	1810,
+	1746,
+	1810,
+	1745,
+	1810,
+	1746,
+	1811,
+	1747,
+	1811,
+	1746,
+	1811,
+	1747,
+	1812,
+	1748,
+	1812,
+	1747,
+	1812,
+	1748,
+	1813,
+	1749,
+	1813,
+	1748,
+	1813,
+	1749,
+	1814,
+	1750,
+	1814,
+	1749,
+	1814,
+	1750,
+	1815,
+	1751,
+	1815,
+	1750,
+	1815,
+	1751,
+	1816,
+	1752,
+	1816,
+	1751,
+	1816,
+	1752,
+	1817,
+	1753,
+	1817,
+	1752,
+	1817,
+	1753,
+	1818,
+	1754,
+	1818,
+	1753,
+	1818,
+	1754,
+	1819,
+	1755,
+	1819,
+	1754,
+	1819,
+	1755,
+	1820,
+	1756,
+	1820,
+	1755,
+	1820,
+	1756,
+	1821,
+	1757,
+	1821,
+	1756,
+	1821,
+	1757,
+	1822,
+	1758,
+	1822,
+	1757,
+	1822,
+	1758,
+	1823,
+	1759,
+	1823,
+	1758,
+	1823,
+	1759,
+	1824,
+	1760,
+	1824,
+	1759,
+	1824,
+	1760,
+	1825,
+	1761,
+	1825,
+	1760,
+	1825,
+	1761,
+	1826,
+	1762,
+	1826,
+	1761,
+	1826,
+	1762,
+	1827,
+	1763,
+	1827,
+	1762,
+	1827,
+	1763,
+	1828,
+	1764,
+	1828,
+	1763,
+	1828,
+	1764,
+	1829,
+	1765,
+	1829,
+	1764,
+	1829,
+	1765,
+	1830,
+	1766,
+	1830,
+	1765,
+	1830,
+	1766,
+	1831,
+	1767,
+	1831,
+	1766,
+	1831,
+	1767,
+	1832,
+	1768,
+	1832,
+	1767,
+	1832,
+	1768,
+	1833,
+	1769,
+	1833,
+	1768,
+	1833,
+	1769,
+	1834,
+	1770,
+	1834,
+	1769,
+	1834,
+	1770,
+	1835,
+	1771,
+	1835,
+	1770,
+	1835,
+	1771,
+	1836,
+	1772,
+	1836,
+	1771,
+	1836,
+	1772,
+	1837,
+	1773,
+	1837,
+	1772,
+	1837,
+	1773,
+	1838,
+	1774,
+	1838,
+	1773,
+	1838,
+	1774,
+	1839,
+	1775,
+	1839,
+	1774,
+	1839,
+	1775,
+	1840,
+	1776,
+	1840,
+	1775,
+	1840,
+	1776,
+	1841,
+	1777,
+	1841,
+	1776,
+	1841,
+	1777,
+	1842,
+	1778,
+	1842,
+	1777,
+	1842,
+	1778,
+	1843,
+	1779,
+	1843,
+	1778,
+	1843,
+	1779,
+	1844,
+	1780,
+	1844,
+	1779,
+	1844,
+	1780,
+	1845,
+	1781,
+	1845,
+	1780,
+	1845,
+	1781,
+	1846,
+	1782,
+	1846,
+	1781,
+	1846,
+	1782,
+	1847,
+	1783,
+	1847,
+	1782,
+	1847,
+	1783,
+	1848,
+	1784,
+	1848,
+	1783,
+	1848,
+	1784,
+	1849,
+	1785,
+	1849,
+	1784,
+	1849,
+	1785,
+	1850,
+	1786,
+	1850,
+	1785,
+	1850,
+	1786,
+	1851,
+	1787,
+	1851,
+	1786,
+	1851,
+	1787,
+	1852,
+	1788,
+	1852,
+	1787,
+	1852,
+	1788,
+	1853,
+	1789,
+	1853,
+	1788,
+	1853,
+	1789,
+	1854,
+	1790,
+	1854,
+	1789,
+	1854,
+	1790,
+	1855,
+	1791,
+	1855,
+	1790,
+	1856,
+	1792,
+	1857,
+	1793,
+	1857,
+	1792,
+	1857,
+	1793,
+	1858,
+	1794,
+	1858,
+	1793,
+	1858,
+	1794,
+	1859,
+	1795,
+	1859,
+	1794,
+	1859,
+	1795,
+	1860,
+	1796,
+	1860,
+	1795,
+	1860,
+	1796,
+	1861,
+	1797,
+	1861,
+	1796,
+	1861,
+	1797,
+	1862,
+	1798,
+	1862,
+	1797,
+	1862,
+	1798,
+	1863,
+	1799,
+	1863,
+	1798,
+	1863,
+	1799,
+	1864,
+	1800,
+	1864,
+	1799,
+	1864,
+	1800,
+	1865,
+	1801,
+	1865,
+	1800,
+	1865,
+	1801,
+	1866,
+	1802,
+	1866,
+	1801,
+	1866,
+	1802,
+	1867,
+	1803,
+	1867,
+	1802,
+	1867,
+	1803,
+	1868,
+	1804,
+	1868,
+	1803,
+	1868,
+	1804,
+	1869,
+	1805,
+	1869,
+	1804,
+	1869,
+	1805,
+	1870,
+	1806,
+	1870,
+	1805,
+	1870,
+	1806,
+	1871,
+	1807,
+	1871,
+	1806,
+	1871,
+	1807,
+	1872,
+	1808,
+	1872,
+	1807,
+	1872,
+	1808,
+	1873,
+	1809,
+	1873,
+	1808,
+	1873,
+	1809,
+	1874,
+	1810,
+	1874,
+	1809,
+	1874,
+	1810,
+	1875,
+	1811,
+	1875,
+	1810,
+	1875,
+	1811,
+	1876,
+	1812,
+	1876,
+	1811,
+	1876,
+	1812,
+	1877,
+	1813,
+	1877,
+	1812,
+	1877,
+	1813,
+	1878,
+	1814,
+	1878,
+	1813,
+	1878,
+	1814,
+	1879,
+	1815,
+	1879,
+	1814,
+	1879,
+	1815,
+	1880,
+	1816,
+	1880,
+	1815,
+	1880,
+	1816,
+	1881,
+	1817,
+	1881,
+	1816,
+	1881,
+	1817,
+	1882,
+	1818,
+	1882,
+	1817,
+	1882,
+	1818,
+	1883,
+	1819,
+	1883,
+	1818,
+	1883,
+	1819,
+	1884,
+	1820,
+	1884,
+	1819,
+	1884,
+	1820,
+	1885,
+	1821,
+	1885,
+	1820,
+	1885,
+	1821,
+	1886,
+	1822,
+	1886,
+	1821,
+	1886,
+	1822,
+	1887,
+	1823,
+	1887,
+	1822,
+	1887,
+	1823,
+	1888,
+	1824,
+	1888,
+	1823,
+	1888,
+	1824,
+	1889,
+	1825,
+	1889,
+	1824,
+	1889,
+	1825,
+	1890,
+	1826,
+	1890,
+	1825,
+	1890,
+	1826,
+	1891,
+	1827,
+	1891,
+	1826,
+	1891,
+	1827,
+	1892,
+	1828,
+	1892,
+	1827,
+	1892,
+	1828,
+	1893,
+	1829,
+	1893,
+	1828,
+	1893,
+	1829,
+	1894,
+	1830,
+	1894,
+	1829,
+	1894,
+	1830,
+	1895,
+	1831,
+	1895,
+	1830,
+	1895,
+	1831,
+	1896,
+	1832,
+	1896,
+	1831,
+	1896,
+	1832,
+	1897,
+	1833,
+	1897,
+	1832,
+	1897,
+	1833,
+	1898,
+	1834,
+	1898,
+	1833,
+	1898,
+	1834,
+	1899,
+	1835,
+	1899,
+	1834,
+	1899,
+	1835,
+	1900,
+	1836,
+	1900,
+	1835,
+	1900,
+	1836,
+	1901,
+	1837,
+	1901,
+	1836,
+	1901,
+	1837,
+	1902,
+	1838,
+	1902,
+	1837,
+	1902,
+	1838,
+	1903,
+	1839,
+	1903,
+	1838,
+	1903,
+	1839,
+	1904,
+	1840,
+	1904,
+	1839,
+	1904,
+	1840,
+	1905,
+	1841,
+	1905,
+	1840,
+	1905,
+	1841,
+	1906,
+	1842,
+	1906,
+	1841,
+	1906,
+	1842,
+	1907,
+	1843,
+	1907,
+	1842,
+	1907,
+	1843,
+	1908,
+	1844,
+	1908,
+	1843,
+	1908,
+	1844,
+	1909,
+	1845,
+	1909,
+	1844,
+	1909,
+	1845,
+	1910,
+	1846,
+	1910,
+	1845,
+	1910,
+	1846,
+	1911,
+	1847,
+	1911,
+	1846,
+	1911,
+	1847,
+	1912,
+	1848,
+	1912,
+	1847,
+	1912,
+	1848,
+	1913,
+	1849,
+	1913,
+	1848,
+	1913,
+	1849,
+	1914,
+	1850,
+	1914,
+	1849,
+	1914,
+	1850,
+	1915,
+	1851,
+	1915,
+	1850,
+	1915,
+	1851,
+	1916,
+	1852,
+	1916,
+	1851,
+	1916,
+	1852,
+	1917,
+	1853,
+	1917,
+	1852,
+	1917,
+	1853,
+	1918,
+	1854,
+	1918,
+	1853,
+	1918,
+	1854,
+	1919,
+	1855,
+	1919,
+	1854,
+	1920,
+	1856,
+	1921,
+	1857,
+	1921,
+	1856,
+	1921,
+	1857,
+	1922,
+	1858,
+	1922,
+	1857,
+	1922,
+	1858,
+	1923,
+	1859,
+	1923,
+	1858,
+	1923,
+	1859,
+	1924,
+	1860,
+	1924,
+	1859,
+	1924,
+	1860,
+	1925,
+	1861,
+	1925,
+	1860,
+	1925,
+	1861,
+	1926,
+	1862,
+	1926,
+	1861,
+	1926,
+	1862,
+	1927,
+	1863,
+	1927,
+	1862,
+	1927,
+	1863,
+	1928,
+	1864,
+	1928,
+	1863,
+	1928,
+	1864,
+	1929,
+	1865,
+	1929,
+	1864,
+	1929,
+	1865,
+	1930,
+	1866,
+	1930,
+	1865,
+	1930,
+	1866,
+	1931,
+	1867,
+	1931,
+	1866,
+	1931,
+	1867,
+	1932,
+	1868,
+	1932,
+	1867,
+	1932,
+	1868,
+	1933,
+	1869,
+	1933,
+	1868,
+	1933,
+	1869,
+	1934,
+	1870,
+	1934,
+	1869,
+	1934,
+	1870,
+	1935,
+	1871,
+	1935,
+	1870,
+	1935,
+	1871,
+	1936,
+	1872,
+	1936,
+	1871,
+	1936,
+	1872,
+	1937,
+	1873,
+	1937,
+	1872,
+	1937,
+	1873,
+	1938,
+	1874,
+	1938,
+	1873,
+	1938,
+	1874,
+	1939,
+	1875,
+	1939,
+	1874,
+	1939,
+	1875,
+	1940,
+	1876,
+	1940,
+	1875,
+	1940,
+	1876,
+	1941,
+	1877,
+	1941,
+	1876,
+	1941,
+	1877,
+	1942,
+	1878,
+	1942,
+	1877,
+	1942,
+	1878,
+	1943,
+	1879,
+	1943,
+	1878,
+	1943,
+	1879,
+	1944,
+	1880,
+	1944,
+	1879,
+	1944,
+	1880,
+	1945,
+	1881,
+	1945,
+	1880,
+	1945,
+	1881,
+	1946,
+	1882,
+	1946,
+	1881,
+	1946,
+	1882,
+	1947,
+	1883,
+	1947,
+	1882,
+	1947,
+	1883,
+	1948,
+	1884,
+	1948,
+	1883,
+	1948,
+	1884,
+	1949,
+	1885,
+	1949,
+	1884,
+	1949,
+	1885,
+	1950,
+	1886,
+	1950,
+	1885,
+	1950,
+	1886,
+	1951,
+	1887,
+	1951,
+	1886,
+	1951,
+	1887,
+	1952,
+	1888,
+	1952,
+	1887,
+	1952,
+	1888,
+	1953,
+	1889,
+	1953,
+	1888,
+	1953,
+	1889,
+	1954,
+	1890,
+	1954,
+	1889,
+	1954,
+	1890,
+	1955,
+	1891,
+	1955,
+	1890,
+	1955,
+	1891,
+	1956,
+	1892,
+	1956,
+	1891,
+	1956,
+	1892,
+	1957,
+	1893,
+	1957,
+	1892,
+	1957,
+	1893,
+	1958,
+	1894,
+	1958,
+	1893,
+	1958,
+	1894,
+	1959,
+	1895,
+	1959,
+	1894,
+	1959,
+	1895,
+	1960,
+	1896,
+	1960,
+	1895,
+	1960,
+	1896,
+	1961,
+	1897,
+	1961,
+	1896,
+	1961,
+	1897,
+	1962,
+	1898,
+	1962,
+	1897,
+	1962,
+	1898,
+	1963,
+	1899,
+	1963,
+	1898,
+	1963,
+	1899,
+	1964,
+	1900,
+	1964,
+	1899,
+	1964,
+	1900,
+	1965,
+	1901,
+	1965,
+	1900,
+	1965,
+	1901,
+	1966,
+	1902,
+	1966,
+	1901,
+	1966,
+	1902,
+	1967,
+	1903,
+	1967,
+	1902,
+	1967,
+	1903,
+	1968,
+	1904,
+	1968,
+	1903,
+	1968,
+	1904,
+	1969,
+	1905,
+	1969,
+	1904,
+	1969,
+	1905,
+	1970,
+	1906,
+	1970,
+	1905,
+	1970,
+	1906,
+	1971,
+	1907,
+	1971,
+	1906,
+	1971,
+	1907,
+	1972,
+	1908,
+	1972,
+	1907,
+	1972,
+	1908,
+	1973,
+	1909,
+	1973,
+	1908,
+	1973,
+	1909,
+	1974,
+	1910,
+	1974,
+	1909,
+	1974,
+	1910,
+	1975,
+	1911,
+	1975,
+	1910,
+	1975,
+	1911,
+	1976,
+	1912,
+	1976,
+	1911,
+	1976,
+	1912,
+	1977,
+	1913,
+	1977,
+	1912,
+	1977,
+	1913,
+	1978,
+	1914,
+	1978,
+	1913,
+	1978,
+	1914,
+	1979,
+	1915,
+	1979,
+	1914,
+	1979,
+	1915,
+	1980,
+	1916,
+	1980,
+	1915,
+	1980,
+	1916,
+	1981,
+	1917,
+	1981,
+	1916,
+	1981,
+	1917,
+	1982,
+	1918,
+	1982,
+	1917,
+	1982,
+	1918,
+	1983,
+	1919,
+	1983,
+	1918,
+	1984,
+	1920,
+	1985,
+	1921,
+	1985,
+	1920,
+	1985,
+	1921,
+	1986,
+	1922,
+	1986,
+	1921,
+	1986,
+	1922,
+	1987,
+	1923,
+	1987,
+	1922,
+	1987,
+	1923,
+	1988,
+	1924,
+	1988,
+	1923,
+	1988,
+	1924,
+	1989,
+	1925,
+	1989,
+	1924,
+	1989,
+	1925,
+	1990,
+	1926,
+	1990,
+	1925,
+	1990,
+	1926,
+	1991,
+	1927,
+	1991,
+	1926,
+	1991,
+	1927,
+	1992,
+	1928,
+	1992,
+	1927,
+	1992,
+	1928,
+	1993,
+	1929,
+	1993,
+	1928,
+	1993,
+	1929,
+	1994,
+	1930,
+	1994,
+	1929,
+	1994,
+	1930,
+	1995,
+	1931,
+	1995,
+	1930,
+	1995,
+	1931,
+	1996,
+	1932,
+	1996,
+	1931,
+	1996,
+	1932,
+	1997,
+	1933,
+	1997,
+	1932,
+	1997,
+	1933,
+	1998,
+	1934,
+	1998,
+	1933,
+	1998,
+	1934,
+	1999,
+	1935,
+	1999,
+	1934,
+	1999,
+	1935,
+	2000,
+	1936,
+	2000,
+	1935,
+	2000,
+	1936,
+	2001,
+	1937,
+	2001,
+	1936,
+	2001,
+	1937,
+	2002,
+	1938,
+	2002,
+	1937,
+	2002,
+	1938,
+	2003,
+	1939,
+	2003,
+	1938,
+	2003,
+	1939,
+	2004,
+	1940,
+	2004,
+	1939,
+	2004,
+	1940,
+	2005,
+	1941,
+	2005,
+	1940,
+	2005,
+	1941,
+	2006,
+	1942,
+	2006,
+	1941,
+	2006,
+	1942,
+	2007,
+	1943,
+	2007,
+	1942,
+	2007,
+	1943,
+	2008,
+	1944,
+	2008,
+	1943,
+	2008,
+	1944,
+	2009,
+	1945,
+	2009,
+	1944,
+	2009,
+	1945,
+	2010,
+	1946,
+	2010,
+	1945,
+	2010,
+	1946,
+	2011,
+	1947,
+	2011,
+	1946,
+	2011,
+	1947,
+	2012,
+	1948,
+	2012,
+	1947,
+	2012,
+	1948,
+	2013,
+	1949,
+	2013,
+	1948,
+	2013,
+	1949,
+	2014,
+	1950,
+	2014,
+	1949,
+	2014,
+	1950,
+	2015,
+	1951,
+	2015,
+	1950,
+	2015,
+	1951,
+	2016,
+	1952,
+	2016,
+	1951,
+	2016,
+	1952,
+	2017,
+	1953,
+	2017,
+	1952,
+	2017,
+	1953,
+	2018,
+	1954,
+	2018,
+	1953,
+	2018,
+	1954,
+	2019,
+	1955,
+	2019,
+	1954,
+	2019,
+	1955,
+	2020,
+	1956,
+	2020,
+	1955,
+	2020,
+	1956,
+	2021,
+	1957,
+	2021,
+	1956,
+	2021,
+	1957,
+	2022,
+	1958,
+	2022,
+	1957,
+	2022,
+	1958,
+	2023,
+	1959,
+	2023,
+	1958,
+	2023,
+	1959,
+	2024,
+	1960,
+	2024,
+	1959,
+	2024,
+	1960,
+	2025,
+	1961,
+	2025,
+	1960,
+	2025,
+	1961,
+	2026,
+	1962,
+	2026,
+	1961,
+	2026,
+	1962,
+	2027,
+	1963,
+	2027,
+	1962,
+	2027,
+	1963,
+	2028,
+	1964,
+	2028,
+	1963,
+	2028,
+	1964,
+	2029,
+	1965,
+	2029,
+	1964,
+	2029,
+	1965,
+	2030,
+	1966,
+	2030,
+	1965,
+	2030,
+	1966,
+	2031,
+	1967,
+	2031,
+	1966,
+	2031,
+	1967,
+	2032,
+	1968,
+	2032,
+	1967,
+	2032,
+	1968,
+	2033,
+	1969,
+	2033,
+	1968,
+	2033,
+	1969,
+	2034,
+	1970,
+	2034,
+	1969,
+	2034,
+	1970,
+	2035,
+	1971,
+	2035,
+	1970,
+	2035,
+	1971,
+	2036,
+	1972,
+	2036,
+	1971,
+	2036,
+	1972,
+	2037,
+	1973,
+	2037,
+	1972,
+	2037,
+	1973,
+	2038,
+	1974,
+	2038,
+	1973,
+	2038,
+	1974,
+	2039,
+	1975,
+	2039,
+	1974,
+	2039,
+	1975,
+	2040,
+	1976,
+	2040,
+	1975,
+	2040,
+	1976,
+	2041,
+	1977,
+	2041,
+	1976,
+	2041,
+	1977,
+	2042,
+	1978,
+	2042,
+	1977,
+	2042,
+	1978,
+	2043,
+	1979,
+	2043,
+	1978,
+	2043,
+	1979,
+	2044,
+	1980,
+	2044,
+	1979,
+	2044,
+	1980,
+	2045,
+	1981,
+	2045,
+	1980,
+	2045,
+	1981,
+	2046,
+	1982,
+	2046,
+	1981,
+	2046,
+	1982,
+	2047,
+	1983,
+	2047,
+	1982,
+};
diff --git a/engine/inc/bullet/Bullet2FileLoader/autogenerated/bullet2.h b/engine/inc/bullet/Bullet2FileLoader/autogenerated/bullet2.h
new file mode 100644
index 00000000..eaa27dfe
--- /dev/null
+++ b/engine/inc/bullet/Bullet2FileLoader/autogenerated/bullet2.h
@@ -0,0 +1,987 @@
+/* Copyright (C) 2011 Erwin Coumans & Charlie C
+*
+* This software is provided 'as-is', without any express or implied
+* warranty.  In no event will the authors be held liable for any damages
+* arising from the use of this software.
+*
+* Permission is granted to anyone to use this software for any purpose,
+* including commercial applications, and to alter it and redistribute it
+* freely, subject to the following restrictions:
+*
+* 1. The origin of this software must not be misrepresented; you must not
+*    claim that you wrote the original software. If you use this software
+*    in a product, an acknowledgment in the product documentation would be
+*    appreciated but is not required.
+* 2. Altered source versions must be plainly marked as such, and must not be
+*    misrepresented as being the original software.
+* 3. This notice may not be removed or altered from any source distribution.
+*/
+// Auto generated from Bullet/Extras/HeaderGenerator/bulletGenerate.py
+#ifndef __BULLET2_H__
+#define __BULLET2_H__
+namespace Bullet3SerializeBullet2
+{
+// put an empty struct in the case
+typedef struct bInvalidHandle
+{
+	int unused;
+} bInvalidHandle;
+
+class PointerArray;
+class b3PhysicsSystem;
+class ListBase;
+class b3Vector3FloatData;
+class b3Vector3DoubleData;
+class b3Matrix3x3FloatData;
+class b3Matrix3x3DoubleData;
+class b3TransformFloatData;
+class b3TransformDoubleData;
+class b3BvhSubtreeInfoData;
+class b3OptimizedBvhNodeFloatData;
+class b3OptimizedBvhNodeDoubleData;
+class b3QuantizedBvhNodeData;
+class b3QuantizedBvhFloatData;
+class b3QuantizedBvhDoubleData;
+class b3CollisionShapeData;
+class b3StaticPlaneShapeData;
+class b3ConvexInternalShapeData;
+class b3PositionAndRadius;
+class b3MultiSphereShapeData;
+class b3IntIndexData;
+class b3ShortIntIndexData;
+class b3ShortIntIndexTripletData;
+class b3CharIndexTripletData;
+class b3MeshPartData;
+class b3StridingMeshInterfaceData;
+class b3TriangleMeshShapeData;
+class b3ScaledTriangleMeshShapeData;
+class b3CompoundShapeChildData;
+class b3CompoundShapeData;
+class b3CylinderShapeData;
+class b3CapsuleShapeData;
+class b3TriangleInfoData;
+class b3TriangleInfoMapData;
+class b3GImpactMeshShapeData;
+class b3ConvexHullShapeData;
+class b3CollisionObjectDoubleData;
+class b3CollisionObjectFloatData;
+class b3DynamicsWorldDoubleData;
+class b3DynamicsWorldFloatData;
+class b3RigidBodyFloatData;
+class b3RigidBodyDoubleData;
+class b3ConstraintInfo1;
+class b3TypedConstraintData;
+class b3Point2PointConstraintFloatData;
+class b3Point2PointConstraintDoubleData;
+class b3HingeConstraintDoubleData;
+class b3HingeConstraintFloatData;
+class b3ConeTwistConstraintData;
+class b3Generic6DofConstraintData;
+class b3Generic6DofSpringConstraintData;
+class b3SliderConstraintData;
+class b3ContactSolverInfoDoubleData;
+class b3ContactSolverInfoFloatData;
+class SoftBodyMaterialData;
+class SoftBodyNodeData;
+class SoftBodyLinkData;
+class SoftBodyFaceData;
+class SoftBodyTetraData;
+class SoftRigidAnchorData;
+class SoftBodyConfigData;
+class SoftBodyPoseData;
+class SoftBodyClusterData;
+class b3SoftBodyJointData;
+class b3SoftBodyFloatData;
+// -------------------------------------------------- //
+class PointerArray
+{
+public:
+	int m_size;
+	int m_capacity;
+	void *m_data;
+};
+
+// -------------------------------------------------- //
+class b3PhysicsSystem
+{
+public:
+	PointerArray m_collisionShapes;
+	PointerArray m_collisionObjects;
+	PointerArray m_constraints;
+};
+
+// -------------------------------------------------- //
+class ListBase
+{
+public:
+	void *first;
+	void *last;
+};
+
+// -------------------------------------------------- //
+class b3Vector3FloatData
+{
+public:
+	float m_floats[4];
+};
+
+// -------------------------------------------------- //
+class b3Vector3DoubleData
+{
+public:
+	double m_floats[4];
+};
+
+// -------------------------------------------------- //
+class b3Matrix3x3FloatData
+{
+public:
+	b3Vector3FloatData m_el[3];
+};
+
+// -------------------------------------------------- //
+class b3Matrix3x3DoubleData
+{
+public:
+	b3Vector3DoubleData m_el[3];
+};
+
+// -------------------------------------------------- //
+class b3TransformFloatData
+{
+public:
+	b3Matrix3x3FloatData m_basis;
+	b3Vector3FloatData m_origin;
+};
+
+// -------------------------------------------------- //
+class b3TransformDoubleData
+{
+public:
+	b3Matrix3x3DoubleData m_basis;
+	b3Vector3DoubleData m_origin;
+};
+
+// -------------------------------------------------- //
+class b3BvhSubtreeInfoData
+{
+public:
+	int m_rootNodeIndex;
+	int m_subtreeSize;
+	short m_quantizedAabbMin[3];
+	short m_quantizedAabbMax[3];
+};
+
+// -------------------------------------------------- //
+class b3OptimizedBvhNodeFloatData
+{
+public:
+	b3Vector3FloatData m_aabbMinOrg;
+	b3Vector3FloatData m_aabbMaxOrg;
+	int m_escapeIndex;
+	int m_subPart;
+	int m_triangleIndex;
+	char m_pad[4];
+};
+
+// -------------------------------------------------- //
+class b3OptimizedBvhNodeDoubleData
+{
+public:
+	b3Vector3DoubleData m_aabbMinOrg;
+	b3Vector3DoubleData m_aabbMaxOrg;
+	int m_escapeIndex;
+	int m_subPart;
+	int m_triangleIndex;
+	char m_pad[4];
+};
+
+// -------------------------------------------------- //
+class b3QuantizedBvhNodeData
+{
+public:
+	short m_quantizedAabbMin[3];
+	short m_quantizedAabbMax[3];
+	int m_escapeIndexOrTriangleIndex;
+};
+
+// -------------------------------------------------- //
+class b3QuantizedBvhFloatData
+{
+public:
+	b3Vector3FloatData m_bvhAabbMin;
+	b3Vector3FloatData m_bvhAabbMax;
+	b3Vector3FloatData m_bvhQuantization;
+	int m_curNodeIndex;
+	int m_useQuantization;
+	int m_numContiguousLeafNodes;
+	int m_numQuantizedContiguousNodes;
+	b3OptimizedBvhNodeFloatData *m_contiguousNodesPtr;
+	b3QuantizedBvhNodeData *m_quantizedContiguousNodesPtr;
+	b3BvhSubtreeInfoData *m_subTreeInfoPtr;
+	int m_traversalMode;
+	int m_numSubtreeHeaders;
+};
+
+// -------------------------------------------------- //
+class b3QuantizedBvhDoubleData
+{
+public:
+	b3Vector3DoubleData m_bvhAabbMin;
+	b3Vector3DoubleData m_bvhAabbMax;
+	b3Vector3DoubleData m_bvhQuantization;
+	int m_curNodeIndex;
+	int m_useQuantization;
+	int m_numContiguousLeafNodes;
+	int m_numQuantizedContiguousNodes;
+	b3OptimizedBvhNodeDoubleData *m_contiguousNodesPtr;
+	b3QuantizedBvhNodeData *m_quantizedContiguousNodesPtr;
+	int m_traversalMode;
+	int m_numSubtreeHeaders;
+	b3BvhSubtreeInfoData *m_subTreeInfoPtr;
+};
+
+// -------------------------------------------------- //
+class b3CollisionShapeData
+{
+public:
+	char *m_name;
+	int m_shapeType;
+	char m_padding[4];
+};
+
+// -------------------------------------------------- //
+class b3StaticPlaneShapeData
+{
+public:
+	b3CollisionShapeData m_collisionShapeData;
+	b3Vector3FloatData m_localScaling;
+	b3Vector3FloatData m_planeNormal;
+	float m_planeConstant;
+	char m_pad[4];
+};
+
+// -------------------------------------------------- //
+class b3ConvexInternalShapeData
+{
+public:
+	b3CollisionShapeData m_collisionShapeData;
+	b3Vector3FloatData m_localScaling;
+	b3Vector3FloatData m_implicitShapeDimensions;
+	float m_collisionMargin;
+	int m_padding;
+};
+
+// -------------------------------------------------- //
+class b3PositionAndRadius
+{
+public:
+	b3Vector3FloatData m_pos;
+	float m_radius;
+};
+
+// -------------------------------------------------- //
+class b3MultiSphereShapeData
+{
+public:
+	b3ConvexInternalShapeData m_convexInternalShapeData;
+	b3PositionAndRadius *m_localPositionArrayPtr;
+	int m_localPositionArraySize;
+	char m_padding[4];
+};
+
+// -------------------------------------------------- //
+class b3IntIndexData
+{
+public:
+	int m_value;
+};
+
+// -------------------------------------------------- //
+class b3ShortIntIndexData
+{
+public:
+	short m_value;
+	char m_pad[2];
+};
+
+// -------------------------------------------------- //
+class b3ShortIntIndexTripletData
+{
+public:
+	short m_values[3];
+	char m_pad[2];
+};
+
+// -------------------------------------------------- //
+class b3CharIndexTripletData
+{
+public:
+	char m_values[3];
+	char m_pad;
+};
+
+// -------------------------------------------------- //
+class b3MeshPartData
+{
+public:
+	b3Vector3FloatData *m_vertices3f;
+	b3Vector3DoubleData *m_vertices3d;
+	b3IntIndexData *m_indices32;
+	b3ShortIntIndexTripletData *m_3indices16;
+	b3CharIndexTripletData *m_3indices8;
+	b3ShortIntIndexData *m_indices16;
+	int m_numTriangles;
+	int m_numVertices;
+};
+
+// -------------------------------------------------- //
+class b3StridingMeshInterfaceData
+{
+public:
+	b3MeshPartData *m_meshPartsPtr;
+	b3Vector3FloatData m_scaling;
+	int m_numMeshParts;
+	char m_padding[4];
+};
+
+// -------------------------------------------------- //
+class b3TriangleMeshShapeData
+{
+public:
+	b3CollisionShapeData m_collisionShapeData;
+	b3StridingMeshInterfaceData m_meshInterface;
+	b3QuantizedBvhFloatData *m_quantizedFloatBvh;
+	b3QuantizedBvhDoubleData *m_quantizedDoubleBvh;
+	b3TriangleInfoMapData *m_triangleInfoMap;
+	float m_collisionMargin;
+	char m_pad3[4];
+};
+
+// -------------------------------------------------- //
+class b3ScaledTriangleMeshShapeData
+{
+public:
+	b3TriangleMeshShapeData m_trimeshShapeData;
+	b3Vector3FloatData m_localScaling;
+};
+
+// -------------------------------------------------- //
+class b3CompoundShapeChildData
+{
+public:
+	b3TransformFloatData m_transform;
+	b3CollisionShapeData *m_childShape;
+	int m_childShapeType;
+	float m_childMargin;
+};
+
+// -------------------------------------------------- //
+class b3CompoundShapeData
+{
+public:
+	b3CollisionShapeData m_collisionShapeData;
+	b3CompoundShapeChildData *m_childShapePtr;
+	int m_numChildShapes;
+	float m_collisionMargin;
+};
+
+// -------------------------------------------------- //
+class b3CylinderShapeData
+{
+public:
+	b3ConvexInternalShapeData m_convexInternalShapeData;
+	int m_upAxis;
+	char m_padding[4];
+};
+
+// -------------------------------------------------- //
+class b3CapsuleShapeData
+{
+public:
+	b3ConvexInternalShapeData m_convexInternalShapeData;
+	int m_upAxis;
+	char m_padding[4];
+};
+
+// -------------------------------------------------- //
+class b3TriangleInfoData
+{
+public:
+	int m_flags;
+	float m_edgeV0V1Angle;
+	float m_edgeV1V2Angle;
+	float m_edgeV2V0Angle;
+};
+
+// -------------------------------------------------- //
+class b3TriangleInfoMapData
+{
+public:
+	int *m_hashTablePtr;
+	int *m_nextPtr;
+	b3TriangleInfoData *m_valueArrayPtr;
+	int *m_keyArrayPtr;
+	float m_convexEpsilon;
+	float m_planarEpsilon;
+	float m_equalVertexThreshold;
+	float m_edgeDistanceThreshold;
+	float m_zeroAreaThreshold;
+	int m_nextSize;
+	int m_hashTableSize;
+	int m_numValues;
+	int m_numKeys;
+	char m_padding[4];
+};
+
+// -------------------------------------------------- //
+class b3GImpactMeshShapeData
+{
+public:
+	b3CollisionShapeData m_collisionShapeData;
+	b3StridingMeshInterfaceData m_meshInterface;
+	b3Vector3FloatData m_localScaling;
+	float m_collisionMargin;
+	int m_gimpactSubType;
+};
+
+// -------------------------------------------------- //
+class b3ConvexHullShapeData
+{
+public:
+	b3ConvexInternalShapeData m_convexInternalShapeData;
+	b3Vector3FloatData *m_unscaledPointsFloatPtr;
+	b3Vector3DoubleData *m_unscaledPointsDoublePtr;
+	int m_numUnscaledPoints;
+	char m_padding3[4];
+};
+
+// -------------------------------------------------- //
+class b3CollisionObjectDoubleData
+{
+public:
+	void *m_broadphaseHandle;
+	void *m_collisionShape;
+	b3CollisionShapeData *m_rootCollisionShape;
+	char *m_name;
+	b3TransformDoubleData m_worldTransform;
+	b3TransformDoubleData m_interpolationWorldTransform;
+	b3Vector3DoubleData m_interpolationLinearVelocity;
+	b3Vector3DoubleData m_interpolationAngularVelocity;
+	b3Vector3DoubleData m_anisotropicFriction;
+	double m_contactProcessingThreshold;
+	double m_deactivationTime;
+	double m_friction;
+	double m_rollingFriction;
+	double m_restitution;
+	double m_hitFraction;
+	double m_ccdSweptSphereRadius;
+	double m_ccdMotionThreshold;
+	int m_hasAnisotropicFriction;
+	int m_collisionFlags;
+	int m_islandTag1;
+	int m_companionId;
+	int m_activationState1;
+	int m_internalType;
+	int m_checkCollideWith;
+	char m_padding[4];
+};
+
+// -------------------------------------------------- //
+class b3CollisionObjectFloatData
+{
+public:
+	void *m_broadphaseHandle;
+	void *m_collisionShape;
+	b3CollisionShapeData *m_rootCollisionShape;
+	char *m_name;
+	b3TransformFloatData m_worldTransform;
+	b3TransformFloatData m_interpolationWorldTransform;
+	b3Vector3FloatData m_interpolationLinearVelocity;
+	b3Vector3FloatData m_interpolationAngularVelocity;
+	b3Vector3FloatData m_anisotropicFriction;
+	float m_contactProcessingThreshold;
+	float m_deactivationTime;
+	float m_friction;
+	float m_rollingFriction;
+	float m_restitution;
+	float m_hitFraction;
+	float m_ccdSweptSphereRadius;
+	float m_ccdMotionThreshold;
+	int m_hasAnisotropicFriction;
+	int m_collisionFlags;
+	int m_islandTag1;
+	int m_companionId;
+	int m_activationState1;
+	int m_internalType;
+	int m_checkCollideWith;
+	char m_padding[4];
+};
+
+// -------------------------------------------------- //
+class b3RigidBodyFloatData
+{
+public:
+	b3CollisionObjectFloatData m_collisionObjectData;
+	b3Matrix3x3FloatData m_invInertiaTensorWorld;
+	b3Vector3FloatData m_linearVelocity;
+	b3Vector3FloatData m_angularVelocity;
+	b3Vector3FloatData m_angularFactor;
+	b3Vector3FloatData m_linearFactor;
+	b3Vector3FloatData m_gravity;
+	b3Vector3FloatData m_gravity_acceleration;
+	b3Vector3FloatData m_invInertiaLocal;
+	b3Vector3FloatData m_totalForce;
+	b3Vector3FloatData m_totalTorque;
+	float m_inverseMass;
+	float m_linearDamping;
+	float m_angularDamping;
+	float m_additionalDampingFactor;
+	float m_additionalLinearDampingThresholdSqr;
+	float m_additionalAngularDampingThresholdSqr;
+	float m_additionalAngularDampingFactor;
+	float m_linearSleepingThreshold;
+	float m_angularSleepingThreshold;
+	int m_additionalDamping;
+};
+
+// -------------------------------------------------- //
+class b3RigidBodyDoubleData
+{
+public:
+	b3CollisionObjectDoubleData m_collisionObjectData;
+	b3Matrix3x3DoubleData m_invInertiaTensorWorld;
+	b3Vector3DoubleData m_linearVelocity;
+	b3Vector3DoubleData m_angularVelocity;
+	b3Vector3DoubleData m_angularFactor;
+	b3Vector3DoubleData m_linearFactor;
+	b3Vector3DoubleData m_gravity;
+	b3Vector3DoubleData m_gravity_acceleration;
+	b3Vector3DoubleData m_invInertiaLocal;
+	b3Vector3DoubleData m_totalForce;
+	b3Vector3DoubleData m_totalTorque;
+	double m_inverseMass;
+	double m_linearDamping;
+	double m_angularDamping;
+	double m_additionalDampingFactor;
+	double m_additionalLinearDampingThresholdSqr;
+	double m_additionalAngularDampingThresholdSqr;
+	double m_additionalAngularDampingFactor;
+	double m_linearSleepingThreshold;
+	double m_angularSleepingThreshold;
+	int m_additionalDamping;
+	char m_padding[4];
+};
+
+// -------------------------------------------------- //
+class b3ConstraintInfo1
+{
+public:
+	int m_numConstraintRows;
+	int nub;
+};
+
+// -------------------------------------------------- //
+class b3TypedConstraintData
+{
+public:
+	bInvalidHandle *m_rbA;
+	bInvalidHandle *m_rbB;
+	char *m_name;
+	int m_objectType;
+	int m_userConstraintType;
+	int m_userConstraintId;
+	int m_needsFeedback;
+	float m_appliedImpulse;
+	float m_dbgDrawSize;
+	int m_disableCollisionsBetweenLinkedBodies;
+	int m_overrideNumSolverIterations;
+	float m_breakingImpulseThreshold;
+	int m_isEnabled;
+};
+
+// -------------------------------------------------- //
+class b3Point2PointConstraintFloatData
+{
+public:
+	b3TypedConstraintData m_typeConstraintData;
+	b3Vector3FloatData m_pivotInA;
+	b3Vector3FloatData m_pivotInB;
+};
+
+// -------------------------------------------------- //
+class b3Point2PointConstraintDoubleData
+{
+public:
+	b3TypedConstraintData m_typeConstraintData;
+	b3Vector3DoubleData m_pivotInA;
+	b3Vector3DoubleData m_pivotInB;
+};
+
+// -------------------------------------------------- //
+class b3HingeConstraintDoubleData
+{
+public:
+	b3TypedConstraintData m_typeConstraintData;
+	b3TransformDoubleData m_rbAFrame;
+	b3TransformDoubleData m_rbBFrame;
+	int m_useReferenceFrameA;
+	int m_angularOnly;
+	int m_enableAngularMotor;
+	float m_motorTargetVelocity;
+	float m_maxMotorImpulse;
+	float m_lowerLimit;
+	float m_upperLimit;
+	float m_limitSoftness;
+	float m_biasFactor;
+	float m_relaxationFactor;
+};
+
+// -------------------------------------------------- //
+class b3HingeConstraintFloatData
+{
+public:
+	b3TypedConstraintData m_typeConstraintData;
+	b3TransformFloatData m_rbAFrame;
+	b3TransformFloatData m_rbBFrame;
+	int m_useReferenceFrameA;
+	int m_angularOnly;
+	int m_enableAngularMotor;
+	float m_motorTargetVelocity;
+	float m_maxMotorImpulse;
+	float m_lowerLimit;
+	float m_upperLimit;
+	float m_limitSoftness;
+	float m_biasFactor;
+	float m_relaxationFactor;
+};
+
+// -------------------------------------------------- //
+class b3ConeTwistConstraintData
+{
+public:
+	b3TypedConstraintData m_typeConstraintData;
+	b3TransformFloatData m_rbAFrame;
+	b3TransformFloatData m_rbBFrame;
+	float m_swingSpan1;
+	float m_swingSpan2;
+	float m_twistSpan;
+	float m_limitSoftness;
+	float m_biasFactor;
+	float m_relaxationFactor;
+	float m_damping;
+	char m_pad[4];
+};
+
+// -------------------------------------------------- //
+class b3Generic6DofConstraintData
+{
+public:
+	b3TypedConstraintData m_typeConstraintData;
+	b3TransformFloatData m_rbAFrame;
+	b3TransformFloatData m_rbBFrame;
+	b3Vector3FloatData m_linearUpperLimit;
+	b3Vector3FloatData m_linearLowerLimit;
+	b3Vector3FloatData m_angularUpperLimit;
+	b3Vector3FloatData m_angularLowerLimit;
+	int m_useLinearReferenceFrameA;
+	int m_useOffsetForConstraintFrame;
+};
+
+// -------------------------------------------------- //
+class b3Generic6DofSpringConstraintData
+{
+public:
+	b3Generic6DofConstraintData m_6dofData;
+	int m_springEnabled[6];
+	float m_equilibriumPoint[6];
+	float m_springStiffness[6];
+	float m_springDamping[6];
+};
+
+// -------------------------------------------------- //
+class b3SliderConstraintData
+{
+public:
+	b3TypedConstraintData m_typeConstraintData;
+	b3TransformFloatData m_rbAFrame;
+	b3TransformFloatData m_rbBFrame;
+	float m_linearUpperLimit;
+	float m_linearLowerLimit;
+	float m_angularUpperLimit;
+	float m_angularLowerLimit;
+	int m_useLinearReferenceFrameA;
+	int m_useOffsetForConstraintFrame;
+};
+
+// -------------------------------------------------- //
+class b3ContactSolverInfoDoubleData
+{
+public:
+	double m_tau;
+	double m_damping;
+	double m_friction;
+	double m_timeStep;
+	double m_restitution;
+	double m_maxErrorReduction;
+	double m_sor;
+	double m_erp;
+	double m_erp2;
+	double m_globalCfm;
+	double m_splitImpulsePenetrationThreshold;
+	double m_splitImpulseTurnErp;
+	double m_linearSlop;
+	double m_warmstartingFactor;
+	double m_maxGyroscopicForce;
+	double m_singleAxisRollingFrictionThreshold;
+	int m_numIterations;
+	int m_solverMode;
+	int m_restingContactRestitutionThreshold;
+	int m_minimumSolverBatchSize;
+	int m_splitImpulse;
+	char m_padding[4];
+};
+
+// -------------------------------------------------- //
+class b3ContactSolverInfoFloatData
+{
+public:
+	float m_tau;
+	float m_damping;
+	float m_friction;
+	float m_timeStep;
+	float m_restitution;
+	float m_maxErrorReduction;
+	float m_sor;
+	float m_erp;
+	float m_erp2;
+	float m_globalCfm;
+	float m_splitImpulsePenetrationThreshold;
+	float m_splitImpulseTurnErp;
+	float m_linearSlop;
+	float m_warmstartingFactor;
+	float m_maxGyroscopicForce;
+	float m_singleAxisRollingFrictionThreshold;
+	int m_numIterations;
+	int m_solverMode;
+	int m_restingContactRestitutionThreshold;
+	int m_minimumSolverBatchSize;
+	int m_splitImpulse;
+	char m_padding[4];
+};
+
+// -------------------------------------------------- //
+class b3DynamicsWorldDoubleData
+{
+public:
+	b3ContactSolverInfoDoubleData m_solverInfo;
+	b3Vector3DoubleData m_gravity;
+};
+
+// -------------------------------------------------- //
+class b3DynamicsWorldFloatData
+{
+public:
+	b3ContactSolverInfoFloatData m_solverInfo;
+	b3Vector3FloatData m_gravity;
+};
+
+// -------------------------------------------------- //
+class SoftBodyMaterialData
+{
+public:
+	float m_linearStiffness;
+	float m_angularStiffness;
+	float m_volumeStiffness;
+	int m_flags;
+};
+
+// -------------------------------------------------- //
+class SoftBodyNodeData
+{
+public:
+	SoftBodyMaterialData *m_material;
+	b3Vector3FloatData m_position;
+	b3Vector3FloatData m_previousPosition;
+	b3Vector3FloatData m_velocity;
+	b3Vector3FloatData m_accumulatedForce;
+	b3Vector3FloatData m_normal;
+	float m_inverseMass;
+	float m_area;
+	int m_attach;
+	int m_pad;
+};
+
+// -------------------------------------------------- //
+class SoftBodyLinkData
+{
+public:
+	SoftBodyMaterialData *m_material;
+	int m_nodeIndices[2];
+	float m_restLength;
+	int m_bbending;
+};
+
+// -------------------------------------------------- //
+class SoftBodyFaceData
+{
+public:
+	b3Vector3FloatData m_normal;
+	SoftBodyMaterialData *m_material;
+	int m_nodeIndices[3];
+	float m_restArea;
+};
+
+// -------------------------------------------------- //
+class SoftBodyTetraData
+{
+public:
+	b3Vector3FloatData m_c0[4];
+	SoftBodyMaterialData *m_material;
+	int m_nodeIndices[4];
+	float m_restVolume;
+	float m_c1;
+	float m_c2;
+	int m_pad;
+};
+
+// -------------------------------------------------- //
+class SoftRigidAnchorData
+{
+public:
+	b3Matrix3x3FloatData m_c0;
+	b3Vector3FloatData m_c1;
+	b3Vector3FloatData m_localFrame;
+	bInvalidHandle *m_rigidBody;
+	int m_nodeIndex;
+	float m_c2;
+};
+
+// -------------------------------------------------- //
+class SoftBodyConfigData
+{
+public:
+	int m_aeroModel;
+	float m_baumgarte;
+	float m_damping;
+	float m_drag;
+	float m_lift;
+	float m_pressure;
+	float m_volume;
+	float m_dynamicFriction;
+	float m_poseMatch;
+	float m_rigidContactHardness;
+	float m_kineticContactHardness;
+	float m_softContactHardness;
+	float m_anchorHardness;
+	float m_softRigidClusterHardness;
+	float m_softKineticClusterHardness;
+	float m_softSoftClusterHardness;
+	float m_softRigidClusterImpulseSplit;
+	float m_softKineticClusterImpulseSplit;
+	float m_softSoftClusterImpulseSplit;
+	float m_maxVolume;
+	float m_timeScale;
+	int m_velocityIterations;
+	int m_positionIterations;
+	int m_driftIterations;
+	int m_clusterIterations;
+	int m_collisionFlags;
+};
+
+// -------------------------------------------------- //
+class SoftBodyPoseData
+{
+public:
+	b3Matrix3x3FloatData m_rot;
+	b3Matrix3x3FloatData m_scale;
+	b3Matrix3x3FloatData m_aqq;
+	b3Vector3FloatData m_com;
+	b3Vector3FloatData *m_positions;
+	float *m_weights;
+	int m_numPositions;
+	int m_numWeigts;
+	int m_bvolume;
+	int m_bframe;
+	float m_restVolume;
+	int m_pad;
+};
+
+// -------------------------------------------------- //
+class SoftBodyClusterData
+{
+public:
+	b3TransformFloatData m_framexform;
+	b3Matrix3x3FloatData m_locii;
+	b3Matrix3x3FloatData m_invwi;
+	b3Vector3FloatData m_com;
+	b3Vector3FloatData m_vimpulses[2];
+	b3Vector3FloatData m_dimpulses[2];
+	b3Vector3FloatData m_lv;
+	b3Vector3FloatData m_av;
+	b3Vector3FloatData *m_framerefs;
+	int *m_nodeIndices;
+	float *m_masses;
+	int m_numFrameRefs;
+	int m_numNodes;
+	int m_numMasses;
+	float m_idmass;
+	float m_imass;
+	int m_nvimpulses;
+	int m_ndimpulses;
+	float m_ndamping;
+	float m_ldamping;
+	float m_adamping;
+	float m_matching;
+	float m_maxSelfCollisionImpulse;
+	float m_selfCollisionImpulseFactor;
+	int m_containsAnchor;
+	int m_collide;
+	int m_clusterIndex;
+};
+
+// -------------------------------------------------- //
+class b3SoftBodyJointData
+{
+public:
+	void *m_bodyA;
+	void *m_bodyB;
+	b3Vector3FloatData m_refs[2];
+	float m_cfm;
+	float m_erp;
+	float m_split;
+	int m_delete;
+	b3Vector3FloatData m_relPosition[2];
+	int m_bodyAtype;
+	int m_bodyBtype;
+	int m_jointType;
+	int m_pad;
+};
+
+// -------------------------------------------------- //
+class b3SoftBodyFloatData
+{
+public:
+	b3CollisionObjectFloatData m_collisionObjectData;
+	SoftBodyPoseData *m_pose;
+	SoftBodyMaterialData **m_materials;
+	SoftBodyNodeData *m_nodes;
+	SoftBodyLinkData *m_links;
+	SoftBodyFaceData *m_faces;
+	SoftBodyTetraData *m_tetrahedra;
+	SoftRigidAnchorData *m_anchors;
+	SoftBodyClusterData *m_clusters;
+	b3SoftBodyJointData *m_joints;
+	int m_numMaterials;
+	int m_numNodes;
+	int m_numLinks;
+	int m_numFaces;
+	int m_numTetrahedra;
+	int m_numAnchors;
+	int m_numClusters;
+	int m_numJoints;
+	SoftBodyConfigData m_config;
+};
+
+}  // namespace Bullet3SerializeBullet2
+#endif  //__BULLET2_H__
\ No newline at end of file
diff --git a/engine/inc/bullet/Bullet2FileLoader/b3BulletFile.h b/engine/inc/bullet/Bullet2FileLoader/b3BulletFile.h
new file mode 100644
index 00000000..ede1d378
--- /dev/null
+++ b/engine/inc/bullet/Bullet2FileLoader/b3BulletFile.h
@@ -0,0 +1,74 @@
+/*
+bParse
+Copyright (c) 2006-2010 Charlie C & Erwin Coumans  http://gamekit.googlecode.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_BULLET_FILE_H
+#define B3_BULLET_FILE_H
+
+#include "b3File.h"
+#include "Bullet3Common/b3AlignedObjectArray.h"
+#include "b3Defines.h"
+
+#include "Bullet3Serialize/Bullet2FileLoader/b3Serializer.h"
+
+namespace bParse
+{
+// ----------------------------------------------------- //
+class b3BulletFile : public bFile
+{
+protected:
+	char* m_DnaCopy;
+
+public:
+	b3AlignedObjectArray<bStructHandle*> m_softBodies;
+
+	b3AlignedObjectArray<bStructHandle*> m_rigidBodies;
+
+	b3AlignedObjectArray<bStructHandle*> m_collisionObjects;
+
+	b3AlignedObjectArray<bStructHandle*> m_collisionShapes;
+
+	b3AlignedObjectArray<bStructHandle*> m_constraints;
+
+	b3AlignedObjectArray<bStructHandle*> m_bvhs;
+
+	b3AlignedObjectArray<bStructHandle*> m_triangleInfoMaps;
+
+	b3AlignedObjectArray<bStructHandle*> m_dynamicsWorldInfo;
+
+	b3AlignedObjectArray<char*> m_dataBlocks;
+	b3BulletFile();
+
+	b3BulletFile(const char* fileName);
+
+	b3BulletFile(char* memoryBuffer, int len);
+
+	virtual ~b3BulletFile();
+
+	virtual void addDataBlock(char* dataBlock);
+
+	// experimental
+	virtual int write(const char* fileName, bool fixupPointers = false);
+
+	virtual void parse(int verboseMode);
+
+	virtual void parseData();
+
+	virtual void writeDNA(FILE* fp);
+
+	void addStruct(const char* structType, void* data, int len, void* oldPtr, int code);
+};
+};  // namespace bParse
+
+#endif  //B3_BULLET_FILE_H
diff --git a/engine/inc/bullet/Bullet2FileLoader/b3Chunk.h b/engine/inc/bullet/Bullet2FileLoader/b3Chunk.h
new file mode 100644
index 00000000..c9d0f37d
--- /dev/null
+++ b/engine/inc/bullet/Bullet2FileLoader/b3Chunk.h
@@ -0,0 +1,84 @@
+/*
+bParse
+Copyright (c) 2006-2009 Charlie C & Erwin Coumans  http://gamekit.googlecode.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef __BCHUNK_H__
+#define __BCHUNK_H__
+
+#if defined(_WIN32) && !defined(__MINGW32__)
+#define b3Long64 __int64
+#elif defined(__MINGW32__)
+#include <stdint.h>
+#define b3Long64 int64_t
+#else
+#define b3Long64 long long
+#endif
+
+namespace bParse
+{
+// ----------------------------------------------------- //
+class bChunkPtr4
+{
+public:
+	bChunkPtr4() {}
+	int code;
+	int len;
+	union {
+		int m_uniqueInt;
+	};
+	int dna_nr;
+	int nr;
+};
+
+// ----------------------------------------------------- //
+class bChunkPtr8
+{
+public:
+	bChunkPtr8() {}
+	int code, len;
+	union {
+		b3Long64 oldPrev;
+		int m_uniqueInts[2];
+	};
+	int dna_nr, nr;
+};
+
+// ----------------------------------------------------- //
+class bChunkInd
+{
+public:
+	bChunkInd() {}
+	int code, len;
+	void *oldPtr;
+	int dna_nr, nr;
+};
+
+// ----------------------------------------------------- //
+class ChunkUtils
+{
+public:
+	// file chunk offset
+	static int getOffset(int flags);
+
+	// endian utils
+	static short swapShort(short sht);
+	static int swapInt(int inte);
+	static b3Long64 swapLong64(b3Long64 lng);
+};
+
+const int CHUNK_HEADER_LEN = ((sizeof(bChunkInd)));
+const bool VOID_IS_8 = ((sizeof(void *) == 8));
+}  // namespace bParse
+
+#endif  //__BCHUNK_H__
diff --git a/engine/inc/bullet/Bullet2FileLoader/b3Common.h b/engine/inc/bullet/Bullet2FileLoader/b3Common.h
new file mode 100644
index 00000000..5884fad4
--- /dev/null
+++ b/engine/inc/bullet/Bullet2FileLoader/b3Common.h
@@ -0,0 +1,40 @@
+/*
+bParse
+Copyright (c) 2006-2009 Charlie C & Erwin Coumans  http://gamekit.googlecode.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef __BCOMMON_H__
+#define __BCOMMON_H__
+
+#include <assert.h>
+//#include "bLog.h"
+#include "Bullet3Common/b3AlignedObjectArray.h"
+#include "Bullet3Common/b3HashMap.h"
+
+namespace bParse
+{
+class bMain;
+class bFileData;
+class bFile;
+class bDNA;
+
+// delete void* undefined
+typedef struct bStructHandle
+{
+	int unused;
+} bStructHandle;
+typedef b3AlignedObjectArray<bStructHandle*> bListBasePtr;
+typedef b3HashMap<b3HashPtr, bStructHandle*> bPtrMap;
+}  // namespace bParse
+
+#endif  //__BCOMMON_H__
diff --git a/engine/inc/bullet/Bullet2FileLoader/b3DNA.h b/engine/inc/bullet/Bullet2FileLoader/b3DNA.h
new file mode 100644
index 00000000..ca6004d9
--- /dev/null
+++ b/engine/inc/bullet/Bullet2FileLoader/b3DNA.h
@@ -0,0 +1,101 @@
+/*
+bParse
+Copyright (c) 2006-2009 Charlie C & Erwin Coumans  http://gamekit.googlecode.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef __BDNA_H__
+#define __BDNA_H__
+
+#include "b3Common.h"
+
+namespace bParse
+{
+struct bNameInfo
+{
+	char *m_name;
+	bool m_isPointer;
+	int m_dim0;
+	int m_dim1;
+};
+
+class bDNA
+{
+public:
+	bDNA();
+	~bDNA();
+
+	void init(char *data, int len, bool swap = false);
+
+	int getArraySize(char *str);
+	int getArraySizeNew(short name)
+	{
+		const bNameInfo &nameInfo = m_Names[name];
+		return nameInfo.m_dim0 * nameInfo.m_dim1;
+	}
+	int getElementSize(short type, short name)
+	{
+		const bNameInfo &nameInfo = m_Names[name];
+		int size = nameInfo.m_isPointer ? mPtrLen * nameInfo.m_dim0 * nameInfo.m_dim1 : mTlens[type] * nameInfo.m_dim0 * nameInfo.m_dim1;
+		return size;
+	}
+
+	int getNumNames() const
+	{
+		return m_Names.size();
+	}
+
+	char *getName(int ind);
+	char *getType(int ind);
+	short *getStruct(int ind);
+	short getLength(int ind);
+	int getReverseType(short type);
+	int getReverseType(const char *type);
+
+	int getNumStructs();
+
+	//
+	bool lessThan(bDNA *other);
+
+	void initCmpFlags(bDNA *memDNA);
+	bool flagNotEqual(int dna_nr);
+	bool flagEqual(int dna_nr);
+	bool flagNone(int dna_nr);
+
+	int getPointerSize();
+
+	void dumpTypeDefinitions();
+
+private:
+	enum FileDNAFlags
+	{
+		FDF_NONE = 0,
+		FDF_STRUCT_NEQU,
+		FDF_STRUCT_EQU
+	};
+
+	void initRecurseCmpFlags(int i);
+
+	b3AlignedObjectArray<int> mCMPFlags;
+
+	b3AlignedObjectArray<bNameInfo> m_Names;
+	b3AlignedObjectArray<char *> mTypes;
+	b3AlignedObjectArray<short *> mStructs;
+	b3AlignedObjectArray<short> mTlens;
+	b3HashMap<b3HashInt, int> mStructReverse;
+	b3HashMap<b3HashString, int> mTypeLookup;
+
+	int mPtrLen;
+};
+}  // namespace bParse
+
+#endif  //__BDNA_H__
diff --git a/engine/inc/bullet/Bullet2FileLoader/b3Defines.h b/engine/inc/bullet/Bullet2FileLoader/b3Defines.h
new file mode 100644
index 00000000..0524c94d
--- /dev/null
+++ b/engine/inc/bullet/Bullet2FileLoader/b3Defines.h
@@ -0,0 +1,149 @@
+/* Copyright (C) 2006-2009 Charlie C & Erwin Coumans http://gamekit.googlecode.com
+*
+* This software is provided 'as-is', without any express or implied
+* warranty.  In no event will the authors be held liable for any damages
+* arising from the use of this software.
+*
+* Permission is granted to anyone to use this software for any purpose,
+* including commercial applications, and to alter it and redistribute it
+* freely, subject to the following restrictions:
+*
+* 1. The origin of this software must not be misrepresented; you must not
+*    claim that you wrote the original software. If you use this software
+*    in a product, an acknowledgment in the product documentation would be
+*    appreciated but is not required.
+* 2. Altered source versions must be plainly marked as such, and must not be
+*    misrepresented as being the original software.
+* 3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef __B_DEFINES_H__
+#define __B_DEFINES_H__
+
+// MISC defines, see BKE_global.h, BKE_utildefines.h
+#define B3_SIZEOFBLENDERHEADER 12
+
+// ------------------------------------------------------------
+#if defined(__sgi) || defined(__sparc) || defined(__sparc__) || defined(__PPC__) || defined(__ppc__) || defined(__BIG_ENDIAN__)
+#define B3_MAKE_ID(a, b, c, d) ((int)(a) << 24 | (int)(b) << 16 | (c) << 8 | (d))
+#else
+#define B3_MAKE_ID(a, b, c, d) ((int)(d) << 24 | (int)(c) << 16 | (b) << 8 | (a))
+#endif
+
+// ------------------------------------------------------------
+#if defined(__sgi) || defined(__sparc) || defined(__sparc__) || defined(__PPC__) || defined(__ppc__) || defined(__BIG_ENDIAN__)
+#define B3_MAKE_ID2(c, d) ((c) << 8 | (d))
+#else
+#define B3_MAKE_ID2(c, d) ((d) << 8 | (c))
+#endif
+
+// ------------------------------------------------------------
+#define B3_ID_SCE B3_MAKE_ID2('S', 'C')
+#define B3_ID_LI B3_MAKE_ID2('L', 'I')
+#define B3_ID_OB B3_MAKE_ID2('O', 'B')
+#define B3_ID_ME B3_MAKE_ID2('M', 'E')
+#define B3_ID_CU B3_MAKE_ID2('C', 'U')
+#define B3_ID_MB B3_MAKE_ID2('M', 'B')
+#define B3_ID_MA B3_MAKE_ID2('M', 'A')
+#define B3_ID_TE B3_MAKE_ID2('T', 'E')
+#define B3_ID_IM B3_MAKE_ID2('I', 'M')
+#define B3_ID_IK B3_MAKE_ID2('I', 'K')
+#define B3_ID_WV B3_MAKE_ID2('W', 'V')
+#define B3_ID_LT B3_MAKE_ID2('L', 'T')
+#define B3_ID_SE B3_MAKE_ID2('S', 'E')
+#define B3_ID_LF B3_MAKE_ID2('L', 'F')
+#define B3_ID_LA B3_MAKE_ID2('L', 'A')
+#define B3_ID_CA B3_MAKE_ID2('C', 'A')
+#define B3_ID_IP B3_MAKE_ID2('I', 'P')
+#define B3_ID_KE B3_MAKE_ID2('K', 'E')
+#define B3_ID_WO B3_MAKE_ID2('W', 'O')
+#define B3_ID_SCR B3_MAKE_ID2('S', 'R')
+#define B3_ID_VF B3_MAKE_ID2('V', 'F')
+#define B3_ID_TXT B3_MAKE_ID2('T', 'X')
+#define B3_ID_SO B3_MAKE_ID2('S', 'O')
+#define B3_ID_SAMPLE B3_MAKE_ID2('S', 'A')
+#define B3_ID_GR B3_MAKE_ID2('G', 'R')
+#define B3_ID_ID B3_MAKE_ID2('I', 'D')
+#define B3_ID_AR B3_MAKE_ID2('A', 'R')
+#define B3_ID_AC B3_MAKE_ID2('A', 'C')
+#define B3_ID_SCRIPT B3_MAKE_ID2('P', 'Y')
+#define B3_ID_FLUIDSIM B3_MAKE_ID2('F', 'S')
+#define B3_ID_NT B3_MAKE_ID2('N', 'T')
+#define B3_ID_BR B3_MAKE_ID2('B', 'R')
+
+#define B3_ID_SEQ B3_MAKE_ID2('S', 'Q')
+#define B3_ID_CO B3_MAKE_ID2('C', 'O')
+#define B3_ID_PO B3_MAKE_ID2('A', 'C')
+#define B3_ID_NLA B3_MAKE_ID2('N', 'L')
+
+#define B3_ID_VS B3_MAKE_ID2('V', 'S')
+#define B3_ID_VN B3_MAKE_ID2('V', 'N')
+
+// ------------------------------------------------------------
+#define B3_FORM B3_MAKE_ID('F', 'O', 'R', 'M')
+#define B3_DDG1 B3_MAKE_ID('3', 'D', 'G', '1')
+#define B3_DDG2 B3_MAKE_ID('3', 'D', 'G', '2')
+#define B3_DDG3 B3_MAKE_ID('3', 'D', 'G', '3')
+#define B3_DDG4 B3_MAKE_ID('3', 'D', 'G', '4')
+#define B3_GOUR B3_MAKE_ID('G', 'O', 'U', 'R')
+#define B3_BLEN B3_MAKE_ID('B', 'L', 'E', 'N')
+#define B3_DER_ B3_MAKE_ID('D', 'E', 'R', '_')
+#define B3_V100 B3_MAKE_ID('V', '1', '0', '0')
+#define B3_DATA B3_MAKE_ID('D', 'A', 'T', 'A')
+#define B3_GLOB B3_MAKE_ID('G', 'L', 'O', 'B')
+#define B3_IMAG B3_MAKE_ID('I', 'M', 'A', 'G')
+#define B3_TEST B3_MAKE_ID('T', 'E', 'S', 'T')
+#define B3_USER B3_MAKE_ID('U', 'S', 'E', 'R')
+
+// ------------------------------------------------------------
+#define B3_DNA1 B3_MAKE_ID('D', 'N', 'A', '1')
+#define B3_REND B3_MAKE_ID('R', 'E', 'N', 'D')
+#define B3_ENDB B3_MAKE_ID('E', 'N', 'D', 'B')
+#define B3_NAME B3_MAKE_ID('N', 'A', 'M', 'E')
+#define B3_SDNA B3_MAKE_ID('S', 'D', 'N', 'A')
+#define B3_TYPE B3_MAKE_ID('T', 'Y', 'P', 'E')
+#define B3_TLEN B3_MAKE_ID('T', 'L', 'E', 'N')
+#define B3_STRC B3_MAKE_ID('S', 'T', 'R', 'C')
+
+// ------------------------------------------------------------
+#define B3_SWITCH_INT(a)    \
+	{                       \
+		char s_i, *p_i;     \
+		p_i = (char *)&(a); \
+		s_i = p_i[0];       \
+		p_i[0] = p_i[3];    \
+		p_i[3] = s_i;       \
+		s_i = p_i[1];       \
+		p_i[1] = p_i[2];    \
+		p_i[2] = s_i;       \
+	}
+
+// ------------------------------------------------------------
+#define B3_SWITCH_SHORT(a)  \
+	{                       \
+		char s_i, *p_i;     \
+		p_i = (char *)&(a); \
+		s_i = p_i[0];       \
+		p_i[0] = p_i[1];    \
+		p_i[1] = s_i;       \
+	}
+
+// ------------------------------------------------------------
+#define B3_SWITCH_LONGINT(a) \
+	{                        \
+		char s_i, *p_i;      \
+		p_i = (char *)&(a);  \
+		s_i = p_i[0];        \
+		p_i[0] = p_i[7];     \
+		p_i[7] = s_i;        \
+		s_i = p_i[1];        \
+		p_i[1] = p_i[6];     \
+		p_i[6] = s_i;        \
+		s_i = p_i[2];        \
+		p_i[2] = p_i[5];     \
+		p_i[5] = s_i;        \
+		s_i = p_i[3];        \
+		p_i[3] = p_i[4];     \
+		p_i[4] = s_i;        \
+	}
+
+#endif  //__B_DEFINES_H__
diff --git a/engine/inc/bullet/Bullet2FileLoader/b3File.h b/engine/inc/bullet/Bullet2FileLoader/b3File.h
new file mode 100644
index 00000000..bda229cf
--- /dev/null
+++ b/engine/inc/bullet/Bullet2FileLoader/b3File.h
@@ -0,0 +1,158 @@
+/*
+bParse
+Copyright (c) 2006-2009 Charlie C & Erwin Coumans  http://gamekit.googlecode.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef __BFILE_H__
+#define __BFILE_H__
+
+#include "b3Common.h"
+#include "b3Chunk.h"
+#include <stdio.h>
+
+namespace bParse
+{
+// ----------------------------------------------------- //
+enum bFileFlags
+{
+	FD_INVALID = 0,
+	FD_OK = 1,
+	FD_VOID_IS_8 = 2,
+	FD_ENDIAN_SWAP = 4,
+	FD_FILE_64 = 8,
+	FD_BITS_VARIES = 16,
+	FD_VERSION_VARIES = 32,
+	FD_DOUBLE_PRECISION = 64,
+	FD_BROKEN_DNA = 128
+};
+
+enum bFileVerboseMode
+{
+	FD_VERBOSE_EXPORT_XML = 1,
+	FD_VERBOSE_DUMP_DNA_TYPE_DEFINITIONS = 2,
+	FD_VERBOSE_DUMP_CHUNKS = 4,
+	FD_VERBOSE_DUMP_FILE_INFO = 8,
+};
+// ----------------------------------------------------- //
+class bFile
+{
+protected:
+	char m_headerString[7];
+
+	bool mOwnsBuffer;
+	char *mFileBuffer;
+	int mFileLen;
+	int mVersion;
+
+	bPtrMap mLibPointers;
+
+	int mDataStart;
+	bDNA *mFileDNA;
+	bDNA *mMemoryDNA;
+
+	b3AlignedObjectArray<char *> m_pointerFixupArray;
+	b3AlignedObjectArray<char *> m_pointerPtrFixupArray;
+
+	b3AlignedObjectArray<bChunkInd> m_chunks;
+	b3HashMap<b3HashPtr, bChunkInd> m_chunkPtrPtrMap;
+
+	//
+
+	bPtrMap mDataPointers;
+
+	int mFlags;
+
+	// ////////////////////////////////////////////////////////////////////////////
+
+	// buffer offset util
+	int getNextBlock(bChunkInd *dataChunk, const char *dataPtr, const int flags);
+	void safeSwapPtr(char *dst, const char *src);
+
+	virtual void parseHeader();
+
+	virtual void parseData() = 0;
+
+	void resolvePointersMismatch();
+	void resolvePointersChunk(const bChunkInd &dataChunk, int verboseMode);
+
+	int resolvePointersStructRecursive(char *strcPtr, int old_dna, int verboseMode, int recursion);
+	//void swapPtr(char *dst, char *src);
+
+	void parseStruct(char *strcPtr, char *dtPtr, int old_dna, int new_dna, bool fixupPointers);
+	void getMatchingFileDNA(short *old, const char *lookupName, const char *lookupType, char *strcData, char *data, bool fixupPointers);
+	char *getFileElement(short *firstStruct, char *lookupName, char *lookupType, char *data, short **foundPos);
+
+	void swap(char *head, class bChunkInd &ch, bool ignoreEndianFlag);
+	void swapData(char *data, short type, int arraySize, bool ignoreEndianFlag);
+	void swapStruct(int dna_nr, char *data, bool ignoreEndianFlag);
+	void swapLen(char *dataPtr);
+	void swapDNA(char *ptr);
+
+	char *readStruct(char *head, class bChunkInd &chunk);
+	char *getAsString(int code);
+
+	void parseInternal(int verboseMode, char *memDna, int memDnaLength);
+
+public:
+	bFile(const char *filename, const char headerString[7]);
+
+	//todo: make memoryBuffer const char
+	//bFile( const char *memoryBuffer, int len);
+	bFile(char *memoryBuffer, int len, const char headerString[7]);
+	virtual ~bFile();
+
+	bDNA *getFileDNA()
+	{
+		return mFileDNA;
+	}
+
+	virtual void addDataBlock(char *dataBlock) = 0;
+
+	int getFlags() const
+	{
+		return mFlags;
+	}
+
+	bPtrMap &getLibPointers()
+	{
+		return mLibPointers;
+	}
+
+	void *findLibPointer(void *ptr);
+
+	bool ok();
+
+	virtual void parse(int verboseMode) = 0;
+
+	virtual int write(const char *fileName, bool fixupPointers = false) = 0;
+
+	virtual void writeChunks(FILE *fp, bool fixupPointers);
+
+	virtual void writeDNA(FILE *fp) = 0;
+
+	void updateOldPointers();
+	void resolvePointers(int verboseMode);
+
+	void dumpChunks(bDNA *dna);
+
+	int getVersion() const
+	{
+		return mVersion;
+	}
+	//pre-swap the endianness, so that data loaded on a target with different endianness doesn't need to be swapped
+	void preSwap();
+	void writeFile(const char *fileName);
+};
+}  // namespace bParse
+
+#endif  //__BFILE_H__
diff --git a/engine/inc/bullet/Bullet2FileLoader/b3Serializer.h b/engine/inc/bullet/Bullet2FileLoader/b3Serializer.h
new file mode 100644
index 00000000..d9e153e2
--- /dev/null
+++ b/engine/inc/bullet/Bullet2FileLoader/b3Serializer.h
@@ -0,0 +1,601 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_SERIALIZER_H
+#define B3_SERIALIZER_H
+
+#include "Bullet3Common/b3Scalar.h"  // has definitions like B3_FORCE_INLINE
+#include "Bullet3Common/b3StackAlloc.h"
+#include "Bullet3Common/b3HashMap.h"
+
+#if !defined(__CELLOS_LV2__) && !defined(__MWERKS__)
+#include <memory.h>
+#endif
+#include <string.h>
+
+extern char b3s_bulletDNAstr[];
+extern int b3s_bulletDNAlen;
+extern char b3s_bulletDNAstr64[];
+extern int b3s_bulletDNAlen64;
+
+B3_FORCE_INLINE int b3StrLen(const char* str)
+{
+	if (!str)
+		return (0);
+	int len = 0;
+
+	while (*str != 0)
+	{
+		str++;
+		len++;
+	}
+
+	return len;
+}
+
+class b3Chunk
+{
+public:
+	int m_chunkCode;
+	int m_length;
+	void* m_oldPtr;
+	int m_dna_nr;
+	int m_number;
+};
+
+enum b3SerializationFlags
+{
+	B3_SERIALIZE_NO_BVH = 1,
+	B3_SERIALIZE_NO_TRIANGLEINFOMAP = 2,
+	B3_SERIALIZE_NO_DUPLICATE_ASSERT = 4
+};
+
+class b3Serializer
+{
+public:
+	virtual ~b3Serializer() {}
+
+	virtual const unsigned char* getBufferPointer() const = 0;
+
+	virtual int getCurrentBufferSize() const = 0;
+
+	virtual b3Chunk* allocate(size_t size, int numElements) = 0;
+
+	virtual void finalizeChunk(b3Chunk* chunk, const char* structType, int chunkCode, void* oldPtr) = 0;
+
+	virtual void* findPointer(void* oldPtr) = 0;
+
+	virtual void* getUniquePointer(void* oldPtr) = 0;
+
+	virtual void startSerialization() = 0;
+
+	virtual void finishSerialization() = 0;
+
+	virtual const char* findNameForPointer(const void* ptr) const = 0;
+
+	virtual void registerNameForPointer(const void* ptr, const char* name) = 0;
+
+	virtual void serializeName(const char* ptr) = 0;
+
+	virtual int getSerializationFlags() const = 0;
+
+	virtual void setSerializationFlags(int flags) = 0;
+};
+
+#define B3_HEADER_LENGTH 12
+#if defined(__sgi) || defined(__sparc) || defined(__sparc__) || defined(__PPC__) || defined(__ppc__) || defined(__BIG_ENDIAN__)
+#define B3_MAKE_ID(a, b, c, d) ((int)(a) << 24 | (int)(b) << 16 | (c) << 8 | (d))
+#else
+#define B3_MAKE_ID(a, b, c, d) ((int)(d) << 24 | (int)(c) << 16 | (b) << 8 | (a))
+#endif
+
+#define B3_SOFTBODY_CODE B3_MAKE_ID('S', 'B', 'D', 'Y')
+#define B3_COLLISIONOBJECT_CODE B3_MAKE_ID('C', 'O', 'B', 'J')
+#define B3_RIGIDBODY_CODE B3_MAKE_ID('R', 'B', 'D', 'Y')
+#define B3_CONSTRAINT_CODE B3_MAKE_ID('C', 'O', 'N', 'S')
+#define B3_BOXSHAPE_CODE B3_MAKE_ID('B', 'O', 'X', 'S')
+#define B3_QUANTIZED_BVH_CODE B3_MAKE_ID('Q', 'B', 'V', 'H')
+#define B3_TRIANLGE_INFO_MAP B3_MAKE_ID('T', 'M', 'A', 'P')
+#define B3_SHAPE_CODE B3_MAKE_ID('S', 'H', 'A', 'P')
+#define B3_ARRAY_CODE B3_MAKE_ID('A', 'R', 'A', 'Y')
+#define B3_SBMATERIAL_CODE B3_MAKE_ID('S', 'B', 'M', 'T')
+#define B3_SBNODE_CODE B3_MAKE_ID('S', 'B', 'N', 'D')
+#define B3_DYNAMICSWORLD_CODE B3_MAKE_ID('D', 'W', 'L', 'D')
+#define B3_DNA_CODE B3_MAKE_ID('D', 'N', 'A', '1')
+
+struct b3PointerUid
+{
+	union {
+		void* m_ptr;
+		int m_uniqueIds[2];
+	};
+};
+
+///The b3DefaultSerializer is the main Bullet serialization class.
+///The constructor takes an optional argument for backwards compatibility, it is recommended to leave this empty/zero.
+class b3DefaultSerializer : public b3Serializer
+{
+	b3AlignedObjectArray<char*> mTypes;
+	b3AlignedObjectArray<short*> mStructs;
+	b3AlignedObjectArray<short> mTlens;
+	b3HashMap<b3HashInt, int> mStructReverse;
+	b3HashMap<b3HashString, int> mTypeLookup;
+
+	b3HashMap<b3HashPtr, void*> m_chunkP;
+
+	b3HashMap<b3HashPtr, const char*> m_nameMap;
+
+	b3HashMap<b3HashPtr, b3PointerUid> m_uniquePointers;
+	int m_uniqueIdGenerator;
+
+	int m_totalSize;
+	unsigned char* m_buffer;
+	int m_currentSize;
+	void* m_dna;
+	int m_dnaLength;
+
+	int m_serializationFlags;
+
+	b3AlignedObjectArray<b3Chunk*> m_chunkPtrs;
+
+protected:
+	virtual void* findPointer(void* oldPtr)
+	{
+		void** ptr = m_chunkP.find(oldPtr);
+		if (ptr && *ptr)
+			return *ptr;
+		return 0;
+	}
+
+	void writeDNA()
+	{
+		b3Chunk* dnaChunk = allocate(m_dnaLength, 1);
+		memcpy(dnaChunk->m_oldPtr, m_dna, m_dnaLength);
+		finalizeChunk(dnaChunk, "DNA1", B3_DNA_CODE, m_dna);
+	}
+
+	int getReverseType(const char* type) const
+	{
+		b3HashString key(type);
+		const int* valuePtr = mTypeLookup.find(key);
+		if (valuePtr)
+			return *valuePtr;
+
+		return -1;
+	}
+
+	void initDNA(const char* bdnaOrg, int dnalen)
+	{
+		///was already initialized
+		if (m_dna)
+			return;
+
+		int littleEndian = 1;
+		littleEndian = ((char*)&littleEndian)[0];
+
+		m_dna = b3AlignedAlloc(dnalen, 16);
+		memcpy(m_dna, bdnaOrg, dnalen);
+		m_dnaLength = dnalen;
+
+		int* intPtr = 0;
+		short* shtPtr = 0;
+		char* cp = 0;
+		int dataLen = 0;
+		intPtr = (int*)m_dna;
+
+		/*
+				SDNA (4 bytes) (magic number)
+				NAME (4 bytes)
+				<nr> (4 bytes) amount of names (int)
+				<string>
+				<string>
+			*/
+
+		if (strncmp((const char*)m_dna, "SDNA", 4) == 0)
+		{
+			// skip ++ NAME
+			intPtr++;
+			intPtr++;
+		}
+
+		// Parse names
+		if (!littleEndian)
+			*intPtr = b3SwapEndian(*intPtr);
+
+		dataLen = *intPtr;
+
+		intPtr++;
+
+		cp = (char*)intPtr;
+		int i;
+		for (i = 0; i < dataLen; i++)
+		{
+			while (*cp) cp++;
+			cp++;
+		}
+		cp = b3AlignPointer(cp, 4);
+
+		/*
+				TYPE (4 bytes)
+				<nr> amount of types (int)
+				<string>
+				<string>
+			*/
+
+		intPtr = (int*)cp;
+		b3Assert(strncmp(cp, "TYPE", 4) == 0);
+		intPtr++;
+
+		if (!littleEndian)
+			*intPtr = b3SwapEndian(*intPtr);
+
+		dataLen = *intPtr;
+		intPtr++;
+
+		cp = (char*)intPtr;
+		for (i = 0; i < dataLen; i++)
+		{
+			mTypes.push_back(cp);
+			while (*cp) cp++;
+			cp++;
+		}
+
+		cp = b3AlignPointer(cp, 4);
+
+		/*
+				TLEN (4 bytes)
+				<len> (short) the lengths of types
+				<len>
+			*/
+
+		// Parse type lens
+		intPtr = (int*)cp;
+		b3Assert(strncmp(cp, "TLEN", 4) == 0);
+		intPtr++;
+
+		dataLen = (int)mTypes.size();
+
+		shtPtr = (short*)intPtr;
+		for (i = 0; i < dataLen; i++, shtPtr++)
+		{
+			if (!littleEndian)
+				shtPtr[0] = b3SwapEndian(shtPtr[0]);
+			mTlens.push_back(shtPtr[0]);
+		}
+
+		if (dataLen & 1) shtPtr++;
+
+		/*
+				STRC (4 bytes)
+				<nr> amount of structs (int)
+				<typenr>
+				<nr_of_elems>
+				<typenr>
+				<namenr>
+				<typenr>
+				<namenr>
+			*/
+
+		intPtr = (int*)shtPtr;
+		cp = (char*)intPtr;
+		b3Assert(strncmp(cp, "STRC", 4) == 0);
+		intPtr++;
+
+		if (!littleEndian)
+			*intPtr = b3SwapEndian(*intPtr);
+		dataLen = *intPtr;
+		intPtr++;
+
+		shtPtr = (short*)intPtr;
+		for (i = 0; i < dataLen; i++)
+		{
+			mStructs.push_back(shtPtr);
+
+			if (!littleEndian)
+			{
+				shtPtr[0] = b3SwapEndian(shtPtr[0]);
+				shtPtr[1] = b3SwapEndian(shtPtr[1]);
+
+				int len = shtPtr[1];
+				shtPtr += 2;
+
+				for (int a = 0; a < len; a++, shtPtr += 2)
+				{
+					shtPtr[0] = b3SwapEndian(shtPtr[0]);
+					shtPtr[1] = b3SwapEndian(shtPtr[1]);
+				}
+			}
+			else
+			{
+				shtPtr += (2 * shtPtr[1]) + 2;
+			}
+		}
+
+		// build reverse lookups
+		for (i = 0; i < (int)mStructs.size(); i++)
+		{
+			short* strc = mStructs.at(i);
+			mStructReverse.insert(strc[0], i);
+			mTypeLookup.insert(b3HashString(mTypes[strc[0]]), i);
+		}
+	}
+
+public:
+	b3DefaultSerializer(int totalSize = 0)
+		: m_totalSize(totalSize),
+		  m_currentSize(0),
+		  m_dna(0),
+		  m_dnaLength(0),
+		  m_serializationFlags(0)
+	{
+		m_buffer = m_totalSize ? (unsigned char*)b3AlignedAlloc(totalSize, 16) : 0;
+
+		const bool VOID_IS_8 = ((sizeof(void*) == 8));
+
+#ifdef B3_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+		if (VOID_IS_8)
+		{
+#if _WIN64
+			initDNA((const char*)b3s_bulletDNAstr64, b3s_bulletDNAlen64);
+#else
+			b3Assert(0);
+#endif
+		}
+		else
+		{
+#ifndef _WIN64
+			initDNA((const char*)b3s_bulletDNAstr, b3s_bulletDNAlen);
+#else
+			b3Assert(0);
+#endif
+		}
+
+#else   //B3_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+		if (VOID_IS_8)
+		{
+			initDNA((const char*)b3s_bulletDNAstr64, b3s_bulletDNAlen64);
+		}
+		else
+		{
+			initDNA((const char*)b3s_bulletDNAstr, b3s_bulletDNAlen);
+		}
+#endif  //B3_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+	}
+
+	virtual ~b3DefaultSerializer()
+	{
+		if (m_buffer)
+			b3AlignedFree(m_buffer);
+		if (m_dna)
+			b3AlignedFree(m_dna);
+	}
+
+	void writeHeader(unsigned char* buffer) const
+	{
+#ifdef B3_USE_DOUBLE_PRECISION
+		memcpy(buffer, "BULLETd", 7);
+#else
+		memcpy(buffer, "BULLETf", 7);
+#endif  //B3_USE_DOUBLE_PRECISION
+
+		int littleEndian = 1;
+		littleEndian = ((char*)&littleEndian)[0];
+
+		if (sizeof(void*) == 8)
+		{
+			buffer[7] = '-';
+		}
+		else
+		{
+			buffer[7] = '_';
+		}
+
+		if (littleEndian)
+		{
+			buffer[8] = 'v';
+		}
+		else
+		{
+			buffer[8] = 'V';
+		}
+
+		buffer[9] = '2';
+		buffer[10] = '8';
+		buffer[11] = '1';
+	}
+
+	virtual void startSerialization()
+	{
+		m_uniqueIdGenerator = 1;
+		if (m_totalSize)
+		{
+			unsigned char* buffer = internalAlloc(B3_HEADER_LENGTH);
+			writeHeader(buffer);
+		}
+	}
+
+	virtual void finishSerialization()
+	{
+		writeDNA();
+
+		//if we didn't pre-allocate a buffer, we need to create a contiguous buffer now
+		int mysize = 0;
+		if (!m_totalSize)
+		{
+			if (m_buffer)
+				b3AlignedFree(m_buffer);
+
+			m_currentSize += B3_HEADER_LENGTH;
+			m_buffer = (unsigned char*)b3AlignedAlloc(m_currentSize, 16);
+
+			unsigned char* currentPtr = m_buffer;
+			writeHeader(m_buffer);
+			currentPtr += B3_HEADER_LENGTH;
+			mysize += B3_HEADER_LENGTH;
+			for (int i = 0; i < m_chunkPtrs.size(); i++)
+			{
+				int curLength = sizeof(b3Chunk) + m_chunkPtrs[i]->m_length;
+				memcpy(currentPtr, m_chunkPtrs[i], curLength);
+				b3AlignedFree(m_chunkPtrs[i]);
+				currentPtr += curLength;
+				mysize += curLength;
+			}
+		}
+
+		mTypes.clear();
+		mStructs.clear();
+		mTlens.clear();
+		mStructReverse.clear();
+		mTypeLookup.clear();
+		m_chunkP.clear();
+		m_nameMap.clear();
+		m_uniquePointers.clear();
+		m_chunkPtrs.clear();
+	}
+
+	virtual void* getUniquePointer(void* oldPtr)
+	{
+		if (!oldPtr)
+			return 0;
+
+		b3PointerUid* uptr = (b3PointerUid*)m_uniquePointers.find(oldPtr);
+		if (uptr)
+		{
+			return uptr->m_ptr;
+		}
+		m_uniqueIdGenerator++;
+
+		b3PointerUid uid;
+		uid.m_uniqueIds[0] = m_uniqueIdGenerator;
+		uid.m_uniqueIds[1] = m_uniqueIdGenerator;
+		m_uniquePointers.insert(oldPtr, uid);
+		return uid.m_ptr;
+	}
+
+	virtual const unsigned char* getBufferPointer() const
+	{
+		return m_buffer;
+	}
+
+	virtual int getCurrentBufferSize() const
+	{
+		return m_currentSize;
+	}
+
+	virtual void finalizeChunk(b3Chunk* chunk, const char* structType, int chunkCode, void* oldPtr)
+	{
+		if (!(m_serializationFlags & B3_SERIALIZE_NO_DUPLICATE_ASSERT))
+		{
+			b3Assert(!findPointer(oldPtr));
+		}
+
+		chunk->m_dna_nr = getReverseType(structType);
+
+		chunk->m_chunkCode = chunkCode;
+
+		void* uniquePtr = getUniquePointer(oldPtr);
+
+		m_chunkP.insert(oldPtr, uniquePtr);  //chunk->m_oldPtr);
+		chunk->m_oldPtr = uniquePtr;         //oldPtr;
+	}
+
+	virtual unsigned char* internalAlloc(size_t size)
+	{
+		unsigned char* ptr = 0;
+
+		if (m_totalSize)
+		{
+			ptr = m_buffer + m_currentSize;
+			m_currentSize += int(size);
+			b3Assert(m_currentSize < m_totalSize);
+		}
+		else
+		{
+			ptr = (unsigned char*)b3AlignedAlloc(size, 16);
+			m_currentSize += int(size);
+		}
+		return ptr;
+	}
+
+	virtual b3Chunk* allocate(size_t size, int numElements)
+	{
+		unsigned char* ptr = internalAlloc(int(size) * numElements + sizeof(b3Chunk));
+
+		unsigned char* data = ptr + sizeof(b3Chunk);
+
+		b3Chunk* chunk = (b3Chunk*)ptr;
+		chunk->m_chunkCode = 0;
+		chunk->m_oldPtr = data;
+		chunk->m_length = int(size) * numElements;
+		chunk->m_number = numElements;
+
+		m_chunkPtrs.push_back(chunk);
+
+		return chunk;
+	}
+
+	virtual const char* findNameForPointer(const void* ptr) const
+	{
+		const char* const* namePtr = m_nameMap.find(ptr);
+		if (namePtr && *namePtr)
+			return *namePtr;
+		return 0;
+	}
+
+	virtual void registerNameForPointer(const void* ptr, const char* name)
+	{
+		m_nameMap.insert(ptr, name);
+	}
+
+	virtual void serializeName(const char* name)
+	{
+		if (name)
+		{
+			//don't serialize name twice
+			if (findPointer((void*)name))
+				return;
+
+			int len = b3StrLen(name);
+			if (len)
+			{
+				int newLen = len + 1;
+				int padding = ((newLen + 3) & ~3) - newLen;
+				newLen += padding;
+
+				//serialize name string now
+				b3Chunk* chunk = allocate(sizeof(char), newLen);
+				char* destinationName = (char*)chunk->m_oldPtr;
+				for (int i = 0; i < len; i++)
+				{
+					destinationName[i] = name[i];
+				}
+				destinationName[len] = 0;
+				finalizeChunk(chunk, "char", B3_ARRAY_CODE, (void*)name);
+			}
+		}
+	}
+
+	virtual int getSerializationFlags() const
+	{
+		return m_serializationFlags;
+	}
+
+	virtual void setSerializationFlags(int flags)
+	{
+		m_serializationFlags = flags;
+	}
+};
+
+#endif  //B3_SERIALIZER_H
diff --git a/engine/inc/bullet/Bullet3Collision/BroadPhaseCollision/b3BroadphaseCallback.h b/engine/inc/bullet/Bullet3Collision/BroadPhaseCollision/b3BroadphaseCallback.h
new file mode 100644
index 00000000..bec0800a
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Collision/BroadPhaseCollision/b3BroadphaseCallback.h
@@ -0,0 +1,38 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_BROADPHASE_CALLBACK_H
+#define B3_BROADPHASE_CALLBACK_H
+
+#include "Bullet3Common/b3Vector3.h"
+struct b3BroadphaseProxy;
+
+struct b3BroadphaseAabbCallback
+{
+	virtual ~b3BroadphaseAabbCallback() {}
+	virtual bool process(const b3BroadphaseProxy* proxy) = 0;
+};
+
+struct b3BroadphaseRayCallback : public b3BroadphaseAabbCallback
+{
+	///added some cached data to accelerate ray-AABB tests
+	b3Vector3 m_rayDirectionInverse;
+	unsigned int m_signs[3];
+	b3Scalar m_lambda_max;
+
+	virtual ~b3BroadphaseRayCallback() {}
+};
+
+#endif  //B3_BROADPHASE_CALLBACK_H
diff --git a/engine/inc/bullet/Bullet3Collision/BroadPhaseCollision/b3DynamicBvh.h b/engine/inc/bullet/Bullet3Collision/BroadPhaseCollision/b3DynamicBvh.h
new file mode 100644
index 00000000..f44e3377
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Collision/BroadPhaseCollision/b3DynamicBvh.h
@@ -0,0 +1,1332 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+///b3DynamicBvh implementation by Nathanael Presson
+
+#ifndef B3_DYNAMIC_BOUNDING_VOLUME_TREE_H
+#define B3_DYNAMIC_BOUNDING_VOLUME_TREE_H
+
+#include "Bullet3Common/b3AlignedObjectArray.h"
+#include "Bullet3Common/b3Vector3.h"
+#include "Bullet3Common/b3Transform.h"
+#include "Bullet3Geometry/b3AabbUtil.h"
+
+//
+// Compile time configuration
+//
+
+// Implementation profiles
+#define B3_DBVT_IMPL_GENERIC 0  // Generic implementation
+#define B3_DBVT_IMPL_SSE 1      // SSE
+
+// Template implementation of ICollide
+#ifdef _WIN32
+#if (defined(_MSC_VER) && _MSC_VER >= 1400)
+#define B3_DBVT_USE_TEMPLATE 1
+#else
+#define B3_DBVT_USE_TEMPLATE 0
+#endif
+#else
+#define B3_DBVT_USE_TEMPLATE 0
+#endif
+
+// Use only intrinsics instead of inline asm
+#define B3_DBVT_USE_INTRINSIC_SSE 1
+
+// Using memmov for collideOCL
+#define B3_DBVT_USE_MEMMOVE 1
+
+// Enable benchmarking code
+#define B3_DBVT_ENABLE_BENCHMARK 0
+
+// Inlining
+#define B3_DBVT_INLINE B3_FORCE_INLINE
+
+// Specific methods implementation
+
+//SSE gives errors on a MSVC 7.1
+#if defined(B3_USE_SSE)  //&& defined (_WIN32)
+#define B3_DBVT_SELECT_IMPL B3_DBVT_IMPL_SSE
+#define B3_DBVT_MERGE_IMPL B3_DBVT_IMPL_SSE
+#define B3_DBVT_INT0_IMPL B3_DBVT_IMPL_SSE
+#else
+#define B3_DBVT_SELECT_IMPL B3_DBVT_IMPL_GENERIC
+#define B3_DBVT_MERGE_IMPL B3_DBVT_IMPL_GENERIC
+#define B3_DBVT_INT0_IMPL B3_DBVT_IMPL_GENERIC
+#endif
+
+#if (B3_DBVT_SELECT_IMPL == B3_DBVT_IMPL_SSE) || \
+	(B3_DBVT_MERGE_IMPL == B3_DBVT_IMPL_SSE) ||  \
+	(B3_DBVT_INT0_IMPL == B3_DBVT_IMPL_SSE)
+#include <emmintrin.h>
+#endif
+
+//
+// Auto config and checks
+//
+
+#if B3_DBVT_USE_TEMPLATE
+#define B3_DBVT_VIRTUAL
+#define B3_DBVT_VIRTUAL_DTOR(a)
+#define B3_DBVT_PREFIX template <typename T>
+#define B3_DBVT_IPOLICY T& policy
+#define B3_DBVT_CHECKTYPE                        \
+	static const ICollide& typechecker = *(T*)1; \
+	(void)typechecker;
+#else
+#define B3_DBVT_VIRTUAL_DTOR(a) \
+	virtual ~a() {}
+#define B3_DBVT_VIRTUAL virtual
+#define B3_DBVT_PREFIX
+#define B3_DBVT_IPOLICY ICollide& policy
+#define B3_DBVT_CHECKTYPE
+#endif
+
+#if B3_DBVT_USE_MEMMOVE
+#if !defined(__CELLOS_LV2__) && !defined(__MWERKS__)
+#include <memory.h>
+#endif
+#include <string.h>
+#endif
+
+#ifndef B3_DBVT_USE_TEMPLATE
+#error "B3_DBVT_USE_TEMPLATE undefined"
+#endif
+
+#ifndef B3_DBVT_USE_MEMMOVE
+#error "B3_DBVT_USE_MEMMOVE undefined"
+#endif
+
+#ifndef B3_DBVT_ENABLE_BENCHMARK
+#error "B3_DBVT_ENABLE_BENCHMARK undefined"
+#endif
+
+#ifndef B3_DBVT_SELECT_IMPL
+#error "B3_DBVT_SELECT_IMPL undefined"
+#endif
+
+#ifndef B3_DBVT_MERGE_IMPL
+#error "B3_DBVT_MERGE_IMPL undefined"
+#endif
+
+#ifndef B3_DBVT_INT0_IMPL
+#error "B3_DBVT_INT0_IMPL undefined"
+#endif
+
+//
+// Defaults volumes
+//
+
+/* b3DbvtAabbMm			*/
+struct b3DbvtAabbMm
+{
+	B3_DBVT_INLINE b3Vector3 Center() const { return ((mi + mx) / 2); }
+	B3_DBVT_INLINE b3Vector3 Lengths() const { return (mx - mi); }
+	B3_DBVT_INLINE b3Vector3 Extents() const { return ((mx - mi) / 2); }
+	B3_DBVT_INLINE const b3Vector3& Mins() const { return (mi); }
+	B3_DBVT_INLINE const b3Vector3& Maxs() const { return (mx); }
+	static inline b3DbvtAabbMm FromCE(const b3Vector3& c, const b3Vector3& e);
+	static inline b3DbvtAabbMm FromCR(const b3Vector3& c, b3Scalar r);
+	static inline b3DbvtAabbMm FromMM(const b3Vector3& mi, const b3Vector3& mx);
+	static inline b3DbvtAabbMm FromPoints(const b3Vector3* pts, int n);
+	static inline b3DbvtAabbMm FromPoints(const b3Vector3** ppts, int n);
+	B3_DBVT_INLINE void Expand(const b3Vector3& e);
+	B3_DBVT_INLINE void SignedExpand(const b3Vector3& e);
+	B3_DBVT_INLINE bool Contain(const b3DbvtAabbMm& a) const;
+	B3_DBVT_INLINE int Classify(const b3Vector3& n, b3Scalar o, int s) const;
+	B3_DBVT_INLINE b3Scalar ProjectMinimum(const b3Vector3& v, unsigned signs) const;
+	B3_DBVT_INLINE friend bool b3Intersect(const b3DbvtAabbMm& a,
+										   const b3DbvtAabbMm& b);
+
+	B3_DBVT_INLINE friend bool b3Intersect(const b3DbvtAabbMm& a,
+										   const b3Vector3& b);
+
+	B3_DBVT_INLINE friend b3Scalar b3Proximity(const b3DbvtAabbMm& a,
+											   const b3DbvtAabbMm& b);
+	B3_DBVT_INLINE friend int b3Select(const b3DbvtAabbMm& o,
+									   const b3DbvtAabbMm& a,
+									   const b3DbvtAabbMm& b);
+	B3_DBVT_INLINE friend void b3Merge(const b3DbvtAabbMm& a,
+									   const b3DbvtAabbMm& b,
+									   b3DbvtAabbMm& r);
+	B3_DBVT_INLINE friend bool b3NotEqual(const b3DbvtAabbMm& a,
+										  const b3DbvtAabbMm& b);
+
+	B3_DBVT_INLINE b3Vector3& tMins() { return (mi); }
+	B3_DBVT_INLINE b3Vector3& tMaxs() { return (mx); }
+
+private:
+	B3_DBVT_INLINE void AddSpan(const b3Vector3& d, b3Scalar& smi, b3Scalar& smx) const;
+
+private:
+	b3Vector3 mi, mx;
+};
+
+// Types
+typedef b3DbvtAabbMm b3DbvtVolume;
+
+/* b3DbvtNode				*/
+struct b3DbvtNode
+{
+	b3DbvtVolume volume;
+	b3DbvtNode* parent;
+	B3_DBVT_INLINE bool isleaf() const { return (childs[1] == 0); }
+	B3_DBVT_INLINE bool isinternal() const { return (!isleaf()); }
+	union {
+		b3DbvtNode* childs[2];
+		void* data;
+		int dataAsInt;
+	};
+};
+
+///The b3DynamicBvh class implements a fast dynamic bounding volume tree based on axis aligned bounding boxes (aabb tree).
+///This b3DynamicBvh is used for soft body collision detection and for the b3DynamicBvhBroadphase. It has a fast insert, remove and update of nodes.
+///Unlike the b3QuantizedBvh, nodes can be dynamically moved around, which allows for change in topology of the underlying data structure.
+struct b3DynamicBvh
+{
+	/* Stack element	*/
+	struct sStkNN
+	{
+		const b3DbvtNode* a;
+		const b3DbvtNode* b;
+		sStkNN() {}
+		sStkNN(const b3DbvtNode* na, const b3DbvtNode* nb) : a(na), b(nb) {}
+	};
+	struct sStkNP
+	{
+		const b3DbvtNode* node;
+		int mask;
+		sStkNP(const b3DbvtNode* n, unsigned m) : node(n), mask(m) {}
+	};
+	struct sStkNPS
+	{
+		const b3DbvtNode* node;
+		int mask;
+		b3Scalar value;
+		sStkNPS() {}
+		sStkNPS(const b3DbvtNode* n, unsigned m, b3Scalar v) : node(n), mask(m), value(v) {}
+	};
+	struct sStkCLN
+	{
+		const b3DbvtNode* node;
+		b3DbvtNode* parent;
+		sStkCLN(const b3DbvtNode* n, b3DbvtNode* p) : node(n), parent(p) {}
+	};
+	// Policies/Interfaces
+
+	/* ICollide	*/
+	struct ICollide
+	{
+		B3_DBVT_VIRTUAL_DTOR(ICollide)
+		B3_DBVT_VIRTUAL void Process(const b3DbvtNode*, const b3DbvtNode*) {}
+		B3_DBVT_VIRTUAL void Process(const b3DbvtNode*) {}
+		B3_DBVT_VIRTUAL void Process(const b3DbvtNode* n, b3Scalar) { Process(n); }
+		B3_DBVT_VIRTUAL bool Descent(const b3DbvtNode*) { return (true); }
+		B3_DBVT_VIRTUAL bool AllLeaves(const b3DbvtNode*) { return (true); }
+	};
+	/* IWriter	*/
+	struct IWriter
+	{
+		virtual ~IWriter() {}
+		virtual void Prepare(const b3DbvtNode* root, int numnodes) = 0;
+		virtual void WriteNode(const b3DbvtNode*, int index, int parent, int child0, int child1) = 0;
+		virtual void WriteLeaf(const b3DbvtNode*, int index, int parent) = 0;
+	};
+	/* IClone	*/
+	struct IClone
+	{
+		virtual ~IClone() {}
+		virtual void CloneLeaf(b3DbvtNode*) {}
+	};
+
+	// Constants
+	enum
+	{
+		B3_SIMPLE_STACKSIZE = 64,
+		B3_DOUBLE_STACKSIZE = B3_SIMPLE_STACKSIZE * 2
+	};
+
+	// Fields
+	b3DbvtNode* m_root;
+	b3DbvtNode* m_free;
+	int m_lkhd;
+	int m_leaves;
+	unsigned m_opath;
+
+	b3AlignedObjectArray<sStkNN> m_stkStack;
+	mutable b3AlignedObjectArray<const b3DbvtNode*> m_rayTestStack;
+
+	// Methods
+	b3DynamicBvh();
+	~b3DynamicBvh();
+	void clear();
+	bool empty() const { return (0 == m_root); }
+	void optimizeBottomUp();
+	void optimizeTopDown(int bu_treshold = 128);
+	void optimizeIncremental(int passes);
+	b3DbvtNode* insert(const b3DbvtVolume& box, void* data);
+	void update(b3DbvtNode* leaf, int lookahead = -1);
+	void update(b3DbvtNode* leaf, b3DbvtVolume& volume);
+	bool update(b3DbvtNode* leaf, b3DbvtVolume& volume, const b3Vector3& velocity, b3Scalar margin);
+	bool update(b3DbvtNode* leaf, b3DbvtVolume& volume, const b3Vector3& velocity);
+	bool update(b3DbvtNode* leaf, b3DbvtVolume& volume, b3Scalar margin);
+	void remove(b3DbvtNode* leaf);
+	void write(IWriter* iwriter) const;
+	void clone(b3DynamicBvh& dest, IClone* iclone = 0) const;
+	static int maxdepth(const b3DbvtNode* node);
+	static int countLeaves(const b3DbvtNode* node);
+	static void extractLeaves(const b3DbvtNode* node, b3AlignedObjectArray<const b3DbvtNode*>& leaves);
+#if B3_DBVT_ENABLE_BENCHMARK
+	static void benchmark();
+#else
+	static void benchmark()
+	{
+	}
+#endif
+	// B3_DBVT_IPOLICY must support ICollide policy/interface
+	B3_DBVT_PREFIX
+	static void enumNodes(const b3DbvtNode* root,
+						  B3_DBVT_IPOLICY);
+	B3_DBVT_PREFIX
+	static void enumLeaves(const b3DbvtNode* root,
+						   B3_DBVT_IPOLICY);
+	B3_DBVT_PREFIX
+	void collideTT(const b3DbvtNode* root0,
+				   const b3DbvtNode* root1,
+				   B3_DBVT_IPOLICY);
+
+	B3_DBVT_PREFIX
+	void collideTTpersistentStack(const b3DbvtNode* root0,
+								  const b3DbvtNode* root1,
+								  B3_DBVT_IPOLICY);
+#if 0
+	B3_DBVT_PREFIX
+		void		collideTT(	const b3DbvtNode* root0,
+		const b3DbvtNode* root1,
+		const b3Transform& xform,
+		B3_DBVT_IPOLICY);
+	B3_DBVT_PREFIX
+		void		collideTT(	const b3DbvtNode* root0,
+		const b3Transform& xform0,
+		const b3DbvtNode* root1,
+		const b3Transform& xform1,
+		B3_DBVT_IPOLICY);
+#endif
+
+	B3_DBVT_PREFIX
+	void collideTV(const b3DbvtNode* root,
+				   const b3DbvtVolume& volume,
+				   B3_DBVT_IPOLICY) const;
+	///rayTest is a re-entrant ray test, and can be called in parallel as long as the b3AlignedAlloc is thread-safe (uses locking etc)
+	///rayTest is slower than rayTestInternal, because it builds a local stack, using memory allocations, and it recomputes signs/rayDirectionInverses each time
+	B3_DBVT_PREFIX
+	static void rayTest(const b3DbvtNode* root,
+						const b3Vector3& rayFrom,
+						const b3Vector3& rayTo,
+						B3_DBVT_IPOLICY);
+	///rayTestInternal is faster than rayTest, because it uses a persistent stack (to reduce dynamic memory allocations to a minimum) and it uses precomputed signs/rayInverseDirections
+	///rayTestInternal is used by b3DynamicBvhBroadphase to accelerate world ray casts
+	B3_DBVT_PREFIX
+	void rayTestInternal(const b3DbvtNode* root,
+						 const b3Vector3& rayFrom,
+						 const b3Vector3& rayTo,
+						 const b3Vector3& rayDirectionInverse,
+						 unsigned int signs[3],
+						 b3Scalar lambda_max,
+						 const b3Vector3& aabbMin,
+						 const b3Vector3& aabbMax,
+						 B3_DBVT_IPOLICY) const;
+
+	B3_DBVT_PREFIX
+	static void collideKDOP(const b3DbvtNode* root,
+							const b3Vector3* normals,
+							const b3Scalar* offsets,
+							int count,
+							B3_DBVT_IPOLICY);
+	B3_DBVT_PREFIX
+	static void collideOCL(const b3DbvtNode* root,
+						   const b3Vector3* normals,
+						   const b3Scalar* offsets,
+						   const b3Vector3& sortaxis,
+						   int count,
+						   B3_DBVT_IPOLICY,
+						   bool fullsort = true);
+	B3_DBVT_PREFIX
+	static void collideTU(const b3DbvtNode* root,
+						  B3_DBVT_IPOLICY);
+	// Helpers
+	static B3_DBVT_INLINE int nearest(const int* i, const b3DynamicBvh::sStkNPS* a, b3Scalar v, int l, int h)
+	{
+		int m = 0;
+		while (l < h)
+		{
+			m = (l + h) >> 1;
+			if (a[i[m]].value >= v)
+				l = m + 1;
+			else
+				h = m;
+		}
+		return (h);
+	}
+	static B3_DBVT_INLINE int allocate(b3AlignedObjectArray<int>& ifree,
+									   b3AlignedObjectArray<sStkNPS>& stock,
+									   const sStkNPS& value)
+	{
+		int i;
+		if (ifree.size() > 0)
+		{
+			i = ifree[ifree.size() - 1];
+			ifree.pop_back();
+			stock[i] = value;
+		}
+		else
+		{
+			i = stock.size();
+			stock.push_back(value);
+		}
+		return (i);
+	}
+	//
+private:
+	b3DynamicBvh(const b3DynamicBvh&) {}
+};
+
+//
+// Inline's
+//
+
+//
+inline b3DbvtAabbMm b3DbvtAabbMm::FromCE(const b3Vector3& c, const b3Vector3& e)
+{
+	b3DbvtAabbMm box;
+	box.mi = c - e;
+	box.mx = c + e;
+	return (box);
+}
+
+//
+inline b3DbvtAabbMm b3DbvtAabbMm::FromCR(const b3Vector3& c, b3Scalar r)
+{
+	return (FromCE(c, b3MakeVector3(r, r, r)));
+}
+
+//
+inline b3DbvtAabbMm b3DbvtAabbMm::FromMM(const b3Vector3& mi, const b3Vector3& mx)
+{
+	b3DbvtAabbMm box;
+	box.mi = mi;
+	box.mx = mx;
+	return (box);
+}
+
+//
+inline b3DbvtAabbMm b3DbvtAabbMm::FromPoints(const b3Vector3* pts, int n)
+{
+	b3DbvtAabbMm box;
+	box.mi = box.mx = pts[0];
+	for (int i = 1; i < n; ++i)
+	{
+		box.mi.setMin(pts[i]);
+		box.mx.setMax(pts[i]);
+	}
+	return (box);
+}
+
+//
+inline b3DbvtAabbMm b3DbvtAabbMm::FromPoints(const b3Vector3** ppts, int n)
+{
+	b3DbvtAabbMm box;
+	box.mi = box.mx = *ppts[0];
+	for (int i = 1; i < n; ++i)
+	{
+		box.mi.setMin(*ppts[i]);
+		box.mx.setMax(*ppts[i]);
+	}
+	return (box);
+}
+
+//
+B3_DBVT_INLINE void b3DbvtAabbMm::Expand(const b3Vector3& e)
+{
+	mi -= e;
+	mx += e;
+}
+
+//
+B3_DBVT_INLINE void b3DbvtAabbMm::SignedExpand(const b3Vector3& e)
+{
+	if (e.x > 0)
+		mx.setX(mx.x + e[0]);
+	else
+		mi.setX(mi.x + e[0]);
+	if (e.y > 0)
+		mx.setY(mx.y + e[1]);
+	else
+		mi.setY(mi.y + e[1]);
+	if (e.z > 0)
+		mx.setZ(mx.z + e[2]);
+	else
+		mi.setZ(mi.z + e[2]);
+}
+
+//
+B3_DBVT_INLINE bool b3DbvtAabbMm::Contain(const b3DbvtAabbMm& a) const
+{
+	return ((mi.x <= a.mi.x) &&
+			(mi.y <= a.mi.y) &&
+			(mi.z <= a.mi.z) &&
+			(mx.x >= a.mx.x) &&
+			(mx.y >= a.mx.y) &&
+			(mx.z >= a.mx.z));
+}
+
+//
+B3_DBVT_INLINE int b3DbvtAabbMm::Classify(const b3Vector3& n, b3Scalar o, int s) const
+{
+	b3Vector3 pi, px;
+	switch (s)
+	{
+		case (0 + 0 + 0):
+			px = b3MakeVector3(mi.x, mi.y, mi.z);
+			pi = b3MakeVector3(mx.x, mx.y, mx.z);
+			break;
+		case (1 + 0 + 0):
+			px = b3MakeVector3(mx.x, mi.y, mi.z);
+			pi = b3MakeVector3(mi.x, mx.y, mx.z);
+			break;
+		case (0 + 2 + 0):
+			px = b3MakeVector3(mi.x, mx.y, mi.z);
+			pi = b3MakeVector3(mx.x, mi.y, mx.z);
+			break;
+		case (1 + 2 + 0):
+			px = b3MakeVector3(mx.x, mx.y, mi.z);
+			pi = b3MakeVector3(mi.x, mi.y, mx.z);
+			break;
+		case (0 + 0 + 4):
+			px = b3MakeVector3(mi.x, mi.y, mx.z);
+			pi = b3MakeVector3(mx.x, mx.y, mi.z);
+			break;
+		case (1 + 0 + 4):
+			px = b3MakeVector3(mx.x, mi.y, mx.z);
+			pi = b3MakeVector3(mi.x, mx.y, mi.z);
+			break;
+		case (0 + 2 + 4):
+			px = b3MakeVector3(mi.x, mx.y, mx.z);
+			pi = b3MakeVector3(mx.x, mi.y, mi.z);
+			break;
+		case (1 + 2 + 4):
+			px = b3MakeVector3(mx.x, mx.y, mx.z);
+			pi = b3MakeVector3(mi.x, mi.y, mi.z);
+			break;
+	}
+	if ((b3Dot(n, px) + o) < 0) return (-1);
+	if ((b3Dot(n, pi) + o) >= 0) return (+1);
+	return (0);
+}
+
+//
+B3_DBVT_INLINE b3Scalar b3DbvtAabbMm::ProjectMinimum(const b3Vector3& v, unsigned signs) const
+{
+	const b3Vector3* b[] = {&mx, &mi};
+	const b3Vector3 p = b3MakeVector3(b[(signs >> 0) & 1]->x,
+									  b[(signs >> 1) & 1]->y,
+									  b[(signs >> 2) & 1]->z);
+	return (b3Dot(p, v));
+}
+
+//
+B3_DBVT_INLINE void b3DbvtAabbMm::AddSpan(const b3Vector3& d, b3Scalar& smi, b3Scalar& smx) const
+{
+	for (int i = 0; i < 3; ++i)
+	{
+		if (d[i] < 0)
+		{
+			smi += mx[i] * d[i];
+			smx += mi[i] * d[i];
+		}
+		else
+		{
+			smi += mi[i] * d[i];
+			smx += mx[i] * d[i];
+		}
+	}
+}
+
+//
+B3_DBVT_INLINE bool b3Intersect(const b3DbvtAabbMm& a,
+								const b3DbvtAabbMm& b)
+{
+#if B3_DBVT_INT0_IMPL == B3_DBVT_IMPL_SSE
+	const __m128 rt(_mm_or_ps(_mm_cmplt_ps(_mm_load_ps(b.mx), _mm_load_ps(a.mi)),
+							  _mm_cmplt_ps(_mm_load_ps(a.mx), _mm_load_ps(b.mi))));
+#if defined(_WIN32)
+	const __int32* pu((const __int32*)&rt);
+#else
+	const int* pu((const int*)&rt);
+#endif
+	return ((pu[0] | pu[1] | pu[2]) == 0);
+#else
+	return ((a.mi.x <= b.mx.x) &&
+			(a.mx.x >= b.mi.x) &&
+			(a.mi.y <= b.mx.y) &&
+			(a.mx.y >= b.mi.y) &&
+			(a.mi.z <= b.mx.z) &&
+			(a.mx.z >= b.mi.z));
+#endif
+}
+
+//
+B3_DBVT_INLINE bool b3Intersect(const b3DbvtAabbMm& a,
+								const b3Vector3& b)
+{
+	return ((b.x >= a.mi.x) &&
+			(b.y >= a.mi.y) &&
+			(b.z >= a.mi.z) &&
+			(b.x <= a.mx.x) &&
+			(b.y <= a.mx.y) &&
+			(b.z <= a.mx.z));
+}
+
+//////////////////////////////////////
+
+//
+B3_DBVT_INLINE b3Scalar b3Proximity(const b3DbvtAabbMm& a,
+									const b3DbvtAabbMm& b)
+{
+	const b3Vector3 d = (a.mi + a.mx) - (b.mi + b.mx);
+	return (b3Fabs(d.x) + b3Fabs(d.y) + b3Fabs(d.z));
+}
+
+//
+B3_DBVT_INLINE int b3Select(const b3DbvtAabbMm& o,
+							const b3DbvtAabbMm& a,
+							const b3DbvtAabbMm& b)
+{
+#if B3_DBVT_SELECT_IMPL == B3_DBVT_IMPL_SSE
+
+#if defined(_WIN32)
+	static B3_ATTRIBUTE_ALIGNED16(const unsigned __int32) mask[] = {0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff};
+#else
+	static B3_ATTRIBUTE_ALIGNED16(const unsigned int) mask[] = {0x7fffffff, 0x7fffffff, 0x7fffffff, 0x00000000 /*0x7fffffff*/};
+#endif
+	///@todo: the intrinsic version is 11% slower
+#if B3_DBVT_USE_INTRINSIC_SSE
+
+	union b3SSEUnion  ///NOTE: if we use more intrinsics, move b3SSEUnion into the LinearMath directory
+	{
+		__m128 ssereg;
+		float floats[4];
+		int ints[4];
+	};
+
+	__m128 omi(_mm_load_ps(o.mi));
+	omi = _mm_add_ps(omi, _mm_load_ps(o.mx));
+	__m128 ami(_mm_load_ps(a.mi));
+	ami = _mm_add_ps(ami, _mm_load_ps(a.mx));
+	ami = _mm_sub_ps(ami, omi);
+	ami = _mm_and_ps(ami, _mm_load_ps((const float*)mask));
+	__m128 bmi(_mm_load_ps(b.mi));
+	bmi = _mm_add_ps(bmi, _mm_load_ps(b.mx));
+	bmi = _mm_sub_ps(bmi, omi);
+	bmi = _mm_and_ps(bmi, _mm_load_ps((const float*)mask));
+	__m128 t0(_mm_movehl_ps(ami, ami));
+	ami = _mm_add_ps(ami, t0);
+	ami = _mm_add_ss(ami, _mm_shuffle_ps(ami, ami, 1));
+	__m128 t1(_mm_movehl_ps(bmi, bmi));
+	bmi = _mm_add_ps(bmi, t1);
+	bmi = _mm_add_ss(bmi, _mm_shuffle_ps(bmi, bmi, 1));
+
+	b3SSEUnion tmp;
+	tmp.ssereg = _mm_cmple_ss(bmi, ami);
+	return tmp.ints[0] & 1;
+
+#else
+	B3_ATTRIBUTE_ALIGNED16(__int32 r[1]);
+	__asm
+	{
+		mov		eax,o
+			mov		ecx,a
+			mov		edx,b
+			movaps	xmm0,[eax]
+		movaps	xmm5,mask
+			addps	xmm0,[eax+16]	
+		movaps	xmm1,[ecx]
+		movaps	xmm2,[edx]
+		addps	xmm1,[ecx+16]
+		addps	xmm2,[edx+16]
+		subps	xmm1,xmm0
+			subps	xmm2,xmm0
+			andps	xmm1,xmm5
+			andps	xmm2,xmm5
+			movhlps	xmm3,xmm1
+			movhlps	xmm4,xmm2
+			addps	xmm1,xmm3
+			addps	xmm2,xmm4
+			pshufd	xmm3,xmm1,1
+			pshufd	xmm4,xmm2,1
+			addss	xmm1,xmm3
+			addss	xmm2,xmm4
+			cmpless	xmm2,xmm1
+			movss	r,xmm2
+	}
+	return (r[0] & 1);
+#endif
+#else
+	return (b3Proximity(o, a) < b3Proximity(o, b) ? 0 : 1);
+#endif
+}
+
+//
+B3_DBVT_INLINE void b3Merge(const b3DbvtAabbMm& a,
+							const b3DbvtAabbMm& b,
+							b3DbvtAabbMm& r)
+{
+#if B3_DBVT_MERGE_IMPL == B3_DBVT_IMPL_SSE
+	__m128 ami(_mm_load_ps(a.mi));
+	__m128 amx(_mm_load_ps(a.mx));
+	__m128 bmi(_mm_load_ps(b.mi));
+	__m128 bmx(_mm_load_ps(b.mx));
+	ami = _mm_min_ps(ami, bmi);
+	amx = _mm_max_ps(amx, bmx);
+	_mm_store_ps(r.mi, ami);
+	_mm_store_ps(r.mx, amx);
+#else
+	for (int i = 0; i < 3; ++i)
+	{
+		if (a.mi[i] < b.mi[i])
+			r.mi[i] = a.mi[i];
+		else
+			r.mi[i] = b.mi[i];
+		if (a.mx[i] > b.mx[i])
+			r.mx[i] = a.mx[i];
+		else
+			r.mx[i] = b.mx[i];
+	}
+#endif
+}
+
+//
+B3_DBVT_INLINE bool b3NotEqual(const b3DbvtAabbMm& a,
+							   const b3DbvtAabbMm& b)
+{
+	return ((a.mi.x != b.mi.x) ||
+			(a.mi.y != b.mi.y) ||
+			(a.mi.z != b.mi.z) ||
+			(a.mx.x != b.mx.x) ||
+			(a.mx.y != b.mx.y) ||
+			(a.mx.z != b.mx.z));
+}
+
+//
+// Inline's
+//
+
+//
+B3_DBVT_PREFIX
+inline void b3DynamicBvh::enumNodes(const b3DbvtNode* root,
+									B3_DBVT_IPOLICY)
+{
+	B3_DBVT_CHECKTYPE
+	policy.Process(root);
+	if (root->isinternal())
+	{
+		enumNodes(root->childs[0], policy);
+		enumNodes(root->childs[1], policy);
+	}
+}
+
+//
+B3_DBVT_PREFIX
+inline void b3DynamicBvh::enumLeaves(const b3DbvtNode* root,
+									 B3_DBVT_IPOLICY)
+{
+	B3_DBVT_CHECKTYPE
+	if (root->isinternal())
+	{
+		enumLeaves(root->childs[0], policy);
+		enumLeaves(root->childs[1], policy);
+	}
+	else
+	{
+		policy.Process(root);
+	}
+}
+
+//
+B3_DBVT_PREFIX
+inline void b3DynamicBvh::collideTT(const b3DbvtNode* root0,
+									const b3DbvtNode* root1,
+									B3_DBVT_IPOLICY)
+{
+	B3_DBVT_CHECKTYPE
+	if (root0 && root1)
+	{
+		int depth = 1;
+		int treshold = B3_DOUBLE_STACKSIZE - 4;
+		b3AlignedObjectArray<sStkNN> stkStack;
+		stkStack.resize(B3_DOUBLE_STACKSIZE);
+		stkStack[0] = sStkNN(root0, root1);
+		do
+		{
+			sStkNN p = stkStack[--depth];
+			if (depth > treshold)
+			{
+				stkStack.resize(stkStack.size() * 2);
+				treshold = stkStack.size() - 4;
+			}
+			if (p.a == p.b)
+			{
+				if (p.a->isinternal())
+				{
+					stkStack[depth++] = sStkNN(p.a->childs[0], p.a->childs[0]);
+					stkStack[depth++] = sStkNN(p.a->childs[1], p.a->childs[1]);
+					stkStack[depth++] = sStkNN(p.a->childs[0], p.a->childs[1]);
+				}
+			}
+			else if (b3Intersect(p.a->volume, p.b->volume))
+			{
+				if (p.a->isinternal())
+				{
+					if (p.b->isinternal())
+					{
+						stkStack[depth++] = sStkNN(p.a->childs[0], p.b->childs[0]);
+						stkStack[depth++] = sStkNN(p.a->childs[1], p.b->childs[0]);
+						stkStack[depth++] = sStkNN(p.a->childs[0], p.b->childs[1]);
+						stkStack[depth++] = sStkNN(p.a->childs[1], p.b->childs[1]);
+					}
+					else
+					{
+						stkStack[depth++] = sStkNN(p.a->childs[0], p.b);
+						stkStack[depth++] = sStkNN(p.a->childs[1], p.b);
+					}
+				}
+				else
+				{
+					if (p.b->isinternal())
+					{
+						stkStack[depth++] = sStkNN(p.a, p.b->childs[0]);
+						stkStack[depth++] = sStkNN(p.a, p.b->childs[1]);
+					}
+					else
+					{
+						policy.Process(p.a, p.b);
+					}
+				}
+			}
+		} while (depth);
+	}
+}
+
+B3_DBVT_PREFIX
+inline void b3DynamicBvh::collideTTpersistentStack(const b3DbvtNode* root0,
+												   const b3DbvtNode* root1,
+												   B3_DBVT_IPOLICY)
+{
+	B3_DBVT_CHECKTYPE
+	if (root0 && root1)
+	{
+		int depth = 1;
+		int treshold = B3_DOUBLE_STACKSIZE - 4;
+
+		m_stkStack.resize(B3_DOUBLE_STACKSIZE);
+		m_stkStack[0] = sStkNN(root0, root1);
+		do
+		{
+			sStkNN p = m_stkStack[--depth];
+			if (depth > treshold)
+			{
+				m_stkStack.resize(m_stkStack.size() * 2);
+				treshold = m_stkStack.size() - 4;
+			}
+			if (p.a == p.b)
+			{
+				if (p.a->isinternal())
+				{
+					m_stkStack[depth++] = sStkNN(p.a->childs[0], p.a->childs[0]);
+					m_stkStack[depth++] = sStkNN(p.a->childs[1], p.a->childs[1]);
+					m_stkStack[depth++] = sStkNN(p.a->childs[0], p.a->childs[1]);
+				}
+			}
+			else if (b3Intersect(p.a->volume, p.b->volume))
+			{
+				if (p.a->isinternal())
+				{
+					if (p.b->isinternal())
+					{
+						m_stkStack[depth++] = sStkNN(p.a->childs[0], p.b->childs[0]);
+						m_stkStack[depth++] = sStkNN(p.a->childs[1], p.b->childs[0]);
+						m_stkStack[depth++] = sStkNN(p.a->childs[0], p.b->childs[1]);
+						m_stkStack[depth++] = sStkNN(p.a->childs[1], p.b->childs[1]);
+					}
+					else
+					{
+						m_stkStack[depth++] = sStkNN(p.a->childs[0], p.b);
+						m_stkStack[depth++] = sStkNN(p.a->childs[1], p.b);
+					}
+				}
+				else
+				{
+					if (p.b->isinternal())
+					{
+						m_stkStack[depth++] = sStkNN(p.a, p.b->childs[0]);
+						m_stkStack[depth++] = sStkNN(p.a, p.b->childs[1]);
+					}
+					else
+					{
+						policy.Process(p.a, p.b);
+					}
+				}
+			}
+		} while (depth);
+	}
+}
+
+#if 0
+//
+B3_DBVT_PREFIX
+inline void		b3DynamicBvh::collideTT(	const b3DbvtNode* root0,
+								  const b3DbvtNode* root1,
+								  const b3Transform& xform,
+								  B3_DBVT_IPOLICY)
+{
+	B3_DBVT_CHECKTYPE
+		if(root0&&root1)
+		{
+			int								depth=1;
+			int								treshold=B3_DOUBLE_STACKSIZE-4;
+			b3AlignedObjectArray<sStkNN>	stkStack;
+			stkStack.resize(B3_DOUBLE_STACKSIZE);
+			stkStack[0]=sStkNN(root0,root1);
+			do	{
+				sStkNN	p=stkStack[--depth];
+				if(b3Intersect(p.a->volume,p.b->volume,xform))
+				{
+					if(depth>treshold)
+					{
+						stkStack.resize(stkStack.size()*2);
+						treshold=stkStack.size()-4;
+					}
+					if(p.a->isinternal())
+					{
+						if(p.b->isinternal())
+						{					
+							stkStack[depth++]=sStkNN(p.a->childs[0],p.b->childs[0]);
+							stkStack[depth++]=sStkNN(p.a->childs[1],p.b->childs[0]);
+							stkStack[depth++]=sStkNN(p.a->childs[0],p.b->childs[1]);
+							stkStack[depth++]=sStkNN(p.a->childs[1],p.b->childs[1]);
+						}
+						else
+						{
+							stkStack[depth++]=sStkNN(p.a->childs[0],p.b);
+							stkStack[depth++]=sStkNN(p.a->childs[1],p.b);
+						}
+					}
+					else
+					{
+						if(p.b->isinternal())
+						{
+							stkStack[depth++]=sStkNN(p.a,p.b->childs[0]);
+							stkStack[depth++]=sStkNN(p.a,p.b->childs[1]);
+						}
+						else
+						{
+							policy.Process(p.a,p.b);
+						}
+					}
+				}
+			} while(depth);
+		}
+}
+//
+B3_DBVT_PREFIX
+inline void		b3DynamicBvh::collideTT(	const b3DbvtNode* root0,
+								  const b3Transform& xform0,
+								  const b3DbvtNode* root1,
+								  const b3Transform& xform1,
+								  B3_DBVT_IPOLICY)
+{
+	const b3Transform	xform=xform0.inverse()*xform1;
+	collideTT(root0,root1,xform,policy);
+}
+#endif
+
+//
+B3_DBVT_PREFIX
+inline void b3DynamicBvh::collideTV(const b3DbvtNode* root,
+									const b3DbvtVolume& vol,
+									B3_DBVT_IPOLICY) const
+{
+	B3_DBVT_CHECKTYPE
+	if (root)
+	{
+		B3_ATTRIBUTE_ALIGNED16(b3DbvtVolume)
+		volume(vol);
+		b3AlignedObjectArray<const b3DbvtNode*> stack;
+		stack.resize(0);
+		stack.reserve(B3_SIMPLE_STACKSIZE);
+		stack.push_back(root);
+		do
+		{
+			const b3DbvtNode* n = stack[stack.size() - 1];
+			stack.pop_back();
+			if (b3Intersect(n->volume, volume))
+			{
+				if (n->isinternal())
+				{
+					stack.push_back(n->childs[0]);
+					stack.push_back(n->childs[1]);
+				}
+				else
+				{
+					policy.Process(n);
+				}
+			}
+		} while (stack.size() > 0);
+	}
+}
+
+B3_DBVT_PREFIX
+inline void b3DynamicBvh::rayTestInternal(const b3DbvtNode* root,
+										  const b3Vector3& rayFrom,
+										  const b3Vector3& rayTo,
+										  const b3Vector3& rayDirectionInverse,
+										  unsigned int signs[3],
+										  b3Scalar lambda_max,
+										  const b3Vector3& aabbMin,
+										  const b3Vector3& aabbMax,
+										  B3_DBVT_IPOLICY) const
+{
+	(void)rayTo;
+	B3_DBVT_CHECKTYPE
+	if (root)
+	{
+		int depth = 1;
+		int treshold = B3_DOUBLE_STACKSIZE - 2;
+		b3AlignedObjectArray<const b3DbvtNode*>& stack = m_rayTestStack;
+		stack.resize(B3_DOUBLE_STACKSIZE);
+		stack[0] = root;
+		b3Vector3 bounds[2];
+		do
+		{
+			const b3DbvtNode* node = stack[--depth];
+			bounds[0] = node->volume.Mins() - aabbMax;
+			bounds[1] = node->volume.Maxs() - aabbMin;
+			b3Scalar tmin = 1.f, lambda_min = 0.f;
+			unsigned int result1 = false;
+			result1 = b3RayAabb2(rayFrom, rayDirectionInverse, signs, bounds, tmin, lambda_min, lambda_max);
+			if (result1)
+			{
+				if (node->isinternal())
+				{
+					if (depth > treshold)
+					{
+						stack.resize(stack.size() * 2);
+						treshold = stack.size() - 2;
+					}
+					stack[depth++] = node->childs[0];
+					stack[depth++] = node->childs[1];
+				}
+				else
+				{
+					policy.Process(node);
+				}
+			}
+		} while (depth);
+	}
+}
+
+//
+B3_DBVT_PREFIX
+inline void b3DynamicBvh::rayTest(const b3DbvtNode* root,
+								  const b3Vector3& rayFrom,
+								  const b3Vector3& rayTo,
+								  B3_DBVT_IPOLICY)
+{
+	B3_DBVT_CHECKTYPE
+	if (root)
+	{
+		b3Vector3 rayDir = (rayTo - rayFrom);
+		rayDir.normalize();
+
+		///what about division by zero? --> just set rayDirection[i] to INF/B3_LARGE_FLOAT
+		b3Vector3 rayDirectionInverse;
+		rayDirectionInverse[0] = rayDir[0] == b3Scalar(0.0) ? b3Scalar(B3_LARGE_FLOAT) : b3Scalar(1.0) / rayDir[0];
+		rayDirectionInverse[1] = rayDir[1] == b3Scalar(0.0) ? b3Scalar(B3_LARGE_FLOAT) : b3Scalar(1.0) / rayDir[1];
+		rayDirectionInverse[2] = rayDir[2] == b3Scalar(0.0) ? b3Scalar(B3_LARGE_FLOAT) : b3Scalar(1.0) / rayDir[2];
+		unsigned int signs[3] = {rayDirectionInverse[0] < 0.0, rayDirectionInverse[1] < 0.0, rayDirectionInverse[2] < 0.0};
+
+		b3Scalar lambda_max = rayDir.dot(rayTo - rayFrom);
+#ifdef COMPARE_BTRAY_AABB2
+		b3Vector3 resultNormal;
+#endif  //COMPARE_BTRAY_AABB2
+
+		b3AlignedObjectArray<const b3DbvtNode*> stack;
+
+		int depth = 1;
+		int treshold = B3_DOUBLE_STACKSIZE - 2;
+
+		stack.resize(B3_DOUBLE_STACKSIZE);
+		stack[0] = root;
+		b3Vector3 bounds[2];
+		do
+		{
+			const b3DbvtNode* node = stack[--depth];
+
+			bounds[0] = node->volume.Mins();
+			bounds[1] = node->volume.Maxs();
+
+			b3Scalar tmin = 1.f, lambda_min = 0.f;
+			unsigned int result1 = b3RayAabb2(rayFrom, rayDirectionInverse, signs, bounds, tmin, lambda_min, lambda_max);
+
+#ifdef COMPARE_BTRAY_AABB2
+			b3Scalar param = 1.f;
+			bool result2 = b3RayAabb(rayFrom, rayTo, node->volume.Mins(), node->volume.Maxs(), param, resultNormal);
+			b3Assert(result1 == result2);
+#endif  //TEST_BTRAY_AABB2
+
+			if (result1)
+			{
+				if (node->isinternal())
+				{
+					if (depth > treshold)
+					{
+						stack.resize(stack.size() * 2);
+						treshold = stack.size() - 2;
+					}
+					stack[depth++] = node->childs[0];
+					stack[depth++] = node->childs[1];
+				}
+				else
+				{
+					policy.Process(node);
+				}
+			}
+		} while (depth);
+	}
+}
+
+//
+B3_DBVT_PREFIX
+inline void b3DynamicBvh::collideKDOP(const b3DbvtNode* root,
+									  const b3Vector3* normals,
+									  const b3Scalar* offsets,
+									  int count,
+									  B3_DBVT_IPOLICY)
+{
+	B3_DBVT_CHECKTYPE
+	if (root)
+	{
+		const int inside = (1 << count) - 1;
+		b3AlignedObjectArray<sStkNP> stack;
+		int signs[sizeof(unsigned) * 8];
+		b3Assert(count < int(sizeof(signs) / sizeof(signs[0])));
+		for (int i = 0; i < count; ++i)
+		{
+			signs[i] = ((normals[i].x >= 0) ? 1 : 0) +
+					   ((normals[i].y >= 0) ? 2 : 0) +
+					   ((normals[i].z >= 0) ? 4 : 0);
+		}
+		stack.reserve(B3_SIMPLE_STACKSIZE);
+		stack.push_back(sStkNP(root, 0));
+		do
+		{
+			sStkNP se = stack[stack.size() - 1];
+			bool out = false;
+			stack.pop_back();
+			for (int i = 0, j = 1; (!out) && (i < count); ++i, j <<= 1)
+			{
+				if (0 == (se.mask & j))
+				{
+					const int side = se.node->volume.Classify(normals[i], offsets[i], signs[i]);
+					switch (side)
+					{
+						case -1:
+							out = true;
+							break;
+						case +1:
+							se.mask |= j;
+							break;
+					}
+				}
+			}
+			if (!out)
+			{
+				if ((se.mask != inside) && (se.node->isinternal()))
+				{
+					stack.push_back(sStkNP(se.node->childs[0], se.mask));
+					stack.push_back(sStkNP(se.node->childs[1], se.mask));
+				}
+				else
+				{
+					if (policy.AllLeaves(se.node)) enumLeaves(se.node, policy);
+				}
+			}
+		} while (stack.size());
+	}
+}
+
+//
+B3_DBVT_PREFIX
+inline void b3DynamicBvh::collideOCL(const b3DbvtNode* root,
+									 const b3Vector3* normals,
+									 const b3Scalar* offsets,
+									 const b3Vector3& sortaxis,
+									 int count,
+									 B3_DBVT_IPOLICY,
+									 bool fsort)
+{
+	B3_DBVT_CHECKTYPE
+	if (root)
+	{
+		const unsigned srtsgns = (sortaxis[0] >= 0 ? 1 : 0) +
+								 (sortaxis[1] >= 0 ? 2 : 0) +
+								 (sortaxis[2] >= 0 ? 4 : 0);
+		const int inside = (1 << count) - 1;
+		b3AlignedObjectArray<sStkNPS> stock;
+		b3AlignedObjectArray<int> ifree;
+		b3AlignedObjectArray<int> stack;
+		int signs[sizeof(unsigned) * 8];
+		b3Assert(count < int(sizeof(signs) / sizeof(signs[0])));
+		for (int i = 0; i < count; ++i)
+		{
+			signs[i] = ((normals[i].x >= 0) ? 1 : 0) +
+					   ((normals[i].y >= 0) ? 2 : 0) +
+					   ((normals[i].z >= 0) ? 4 : 0);
+		}
+		stock.reserve(B3_SIMPLE_STACKSIZE);
+		stack.reserve(B3_SIMPLE_STACKSIZE);
+		ifree.reserve(B3_SIMPLE_STACKSIZE);
+		stack.push_back(allocate(ifree, stock, sStkNPS(root, 0, root->volume.ProjectMinimum(sortaxis, srtsgns))));
+		do
+		{
+			const int id = stack[stack.size() - 1];
+			sStkNPS se = stock[id];
+			stack.pop_back();
+			ifree.push_back(id);
+			if (se.mask != inside)
+			{
+				bool out = false;
+				for (int i = 0, j = 1; (!out) && (i < count); ++i, j <<= 1)
+				{
+					if (0 == (se.mask & j))
+					{
+						const int side = se.node->volume.Classify(normals[i], offsets[i], signs[i]);
+						switch (side)
+						{
+							case -1:
+								out = true;
+								break;
+							case +1:
+								se.mask |= j;
+								break;
+						}
+					}
+				}
+				if (out) continue;
+			}
+			if (policy.Descent(se.node))
+			{
+				if (se.node->isinternal())
+				{
+					const b3DbvtNode* pns[] = {se.node->childs[0], se.node->childs[1]};
+					sStkNPS nes[] = {sStkNPS(pns[0], se.mask, pns[0]->volume.ProjectMinimum(sortaxis, srtsgns)),
+									 sStkNPS(pns[1], se.mask, pns[1]->volume.ProjectMinimum(sortaxis, srtsgns))};
+					const int q = nes[0].value < nes[1].value ? 1 : 0;
+					int j = stack.size();
+					if (fsort && (j > 0))
+					{
+						/* Insert 0	*/
+						j = nearest(&stack[0], &stock[0], nes[q].value, 0, stack.size());
+						stack.push_back(0);
+#if B3_DBVT_USE_MEMMOVE
+						memmove(&stack[j + 1], &stack[j], sizeof(int) * (stack.size() - j - 1));
+#else
+						for (int k = stack.size() - 1; k > j; --k) stack[k] = stack[k - 1];
+#endif
+						stack[j] = allocate(ifree, stock, nes[q]);
+						/* Insert 1	*/
+						j = nearest(&stack[0], &stock[0], nes[1 - q].value, j, stack.size());
+						stack.push_back(0);
+#if B3_DBVT_USE_MEMMOVE
+						memmove(&stack[j + 1], &stack[j], sizeof(int) * (stack.size() - j - 1));
+#else
+						for (int k = stack.size() - 1; k > j; --k) stack[k] = stack[k - 1];
+#endif
+						stack[j] = allocate(ifree, stock, nes[1 - q]);
+					}
+					else
+					{
+						stack.push_back(allocate(ifree, stock, nes[q]));
+						stack.push_back(allocate(ifree, stock, nes[1 - q]));
+					}
+				}
+				else
+				{
+					policy.Process(se.node, se.value);
+				}
+			}
+		} while (stack.size());
+	}
+}
+
+//
+B3_DBVT_PREFIX
+inline void b3DynamicBvh::collideTU(const b3DbvtNode* root,
+									B3_DBVT_IPOLICY)
+{
+	B3_DBVT_CHECKTYPE
+	if (root)
+	{
+		b3AlignedObjectArray<const b3DbvtNode*> stack;
+		stack.reserve(B3_SIMPLE_STACKSIZE);
+		stack.push_back(root);
+		do
+		{
+			const b3DbvtNode* n = stack[stack.size() - 1];
+			stack.pop_back();
+			if (policy.Descent(n))
+			{
+				if (n->isinternal())
+				{
+					stack.push_back(n->childs[0]);
+					stack.push_back(n->childs[1]);
+				}
+				else
+				{
+					policy.Process(n);
+				}
+			}
+		} while (stack.size() > 0);
+	}
+}
+
+//
+// PP Cleanup
+//
+
+#undef B3_DBVT_USE_MEMMOVE
+#undef B3_DBVT_USE_TEMPLATE
+#undef B3_DBVT_VIRTUAL_DTOR
+#undef B3_DBVT_VIRTUAL
+#undef B3_DBVT_PREFIX
+#undef B3_DBVT_IPOLICY
+#undef B3_DBVT_CHECKTYPE
+#undef B3_DBVT_IMPL_GENERIC
+#undef B3_DBVT_IMPL_SSE
+#undef B3_DBVT_USE_INTRINSIC_SSE
+#undef B3_DBVT_SELECT_IMPL
+#undef B3_DBVT_MERGE_IMPL
+#undef B3_DBVT_INT0_IMPL
+
+#endif
diff --git a/engine/inc/bullet/Bullet3Collision/BroadPhaseCollision/b3DynamicBvhBroadphase.h b/engine/inc/bullet/Bullet3Collision/BroadPhaseCollision/b3DynamicBvhBroadphase.h
new file mode 100644
index 00000000..c235e401
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Collision/BroadPhaseCollision/b3DynamicBvhBroadphase.h
@@ -0,0 +1,197 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+///b3DynamicBvhBroadphase implementation by Nathanael Presson
+#ifndef B3_DBVT_BROADPHASE_H
+#define B3_DBVT_BROADPHASE_H
+
+#include "Bullet3Collision/BroadPhaseCollision/b3DynamicBvh.h"
+#include "Bullet3Collision/BroadPhaseCollision/b3OverlappingPairCache.h"
+#include "Bullet3Common/b3AlignedObjectArray.h"
+
+#include "b3BroadphaseCallback.h"
+
+//
+// Compile time config
+//
+
+#define B3_DBVT_BP_PROFILE 0
+//#define B3_DBVT_BP_SORTPAIRS				1
+#define B3_DBVT_BP_PREVENTFALSEUPDATE 0
+#define B3_DBVT_BP_ACCURATESLEEPING 0
+#define B3_DBVT_BP_ENABLE_BENCHMARK 0
+#define B3_DBVT_BP_MARGIN (b3Scalar)0.05
+
+#if B3_DBVT_BP_PROFILE
+#define B3_DBVT_BP_PROFILING_RATE 256
+
+#endif
+
+B3_ATTRIBUTE_ALIGNED16(struct)
+b3BroadphaseProxy
+{
+	B3_DECLARE_ALIGNED_ALLOCATOR();
+
+	///optional filtering to cull potential collisions
+	enum CollisionFilterGroups
+	{
+		DefaultFilter = 1,
+		StaticFilter = 2,
+		KinematicFilter = 4,
+		DebrisFilter = 8,
+		SensorTrigger = 16,
+		CharacterFilter = 32,
+		AllFilter = -1  //all bits sets: DefaultFilter | StaticFilter | KinematicFilter | DebrisFilter | SensorTrigger
+	};
+
+	//Usually the client b3CollisionObject or Rigidbody class
+	void* m_clientObject;
+	int m_collisionFilterGroup;
+	int m_collisionFilterMask;
+	int m_uniqueId;  //m_uniqueId is introduced for paircache. could get rid of this, by calculating the address offset etc.
+
+	b3Vector3 m_aabbMin;
+	b3Vector3 m_aabbMax;
+
+	B3_FORCE_INLINE int getUid() const
+	{
+		return m_uniqueId;
+	}
+
+	//used for memory pools
+	b3BroadphaseProxy() : m_clientObject(0)
+	{
+	}
+
+	b3BroadphaseProxy(const b3Vector3& aabbMin, const b3Vector3& aabbMax, void* userPtr, int collisionFilterGroup, int collisionFilterMask)
+		: m_clientObject(userPtr),
+		  m_collisionFilterGroup(collisionFilterGroup),
+		  m_collisionFilterMask(collisionFilterMask),
+		  m_aabbMin(aabbMin),
+		  m_aabbMax(aabbMax)
+	{
+	}
+};
+
+//
+// b3DbvtProxy
+//
+struct b3DbvtProxy : b3BroadphaseProxy
+{
+	/* Fields		*/
+	//b3DbvtAabbMm	aabb;
+	b3DbvtNode* leaf;
+	b3DbvtProxy* links[2];
+	int stage;
+	/* ctor			*/
+
+	explicit b3DbvtProxy() {}
+	b3DbvtProxy(const b3Vector3& aabbMin, const b3Vector3& aabbMax, void* userPtr, int collisionFilterGroup, int collisionFilterMask) : b3BroadphaseProxy(aabbMin, aabbMax, userPtr, collisionFilterGroup, collisionFilterMask)
+	{
+		links[0] = links[1] = 0;
+	}
+};
+
+typedef b3AlignedObjectArray<b3DbvtProxy*> b3DbvtProxyArray;
+
+///The b3DynamicBvhBroadphase implements a broadphase using two dynamic AABB bounding volume hierarchies/trees (see b3DynamicBvh).
+///One tree is used for static/non-moving objects, and another tree is used for dynamic objects. Objects can move from one tree to the other.
+///This is a very fast broadphase, especially for very dynamic worlds where many objects are moving. Its insert/add and remove of objects is generally faster than the sweep and prune broadphases b3AxisSweep3 and b332BitAxisSweep3.
+struct b3DynamicBvhBroadphase
+{
+	/* Config		*/
+	enum
+	{
+		DYNAMIC_SET = 0, /* Dynamic set index	*/
+		FIXED_SET = 1,   /* Fixed set index		*/
+		STAGECOUNT = 2   /* Number of stages		*/
+	};
+	/* Fields		*/
+	b3DynamicBvh m_sets[2];                     // Dbvt sets
+	b3DbvtProxy* m_stageRoots[STAGECOUNT + 1];  // Stages list
+
+	b3AlignedObjectArray<b3DbvtProxy> m_proxies;
+	b3OverlappingPairCache* m_paircache;  // Pair cache
+	b3Scalar m_prediction;                // Velocity prediction
+	int m_stageCurrent;                   // Current stage
+	int m_fupdates;                       // % of fixed updates per frame
+	int m_dupdates;                       // % of dynamic updates per frame
+	int m_cupdates;                       // % of cleanup updates per frame
+	int m_newpairs;                       // Number of pairs created
+	int m_fixedleft;                      // Fixed optimization left
+	unsigned m_updates_call;              // Number of updates call
+	unsigned m_updates_done;              // Number of updates done
+	b3Scalar m_updates_ratio;             // m_updates_done/m_updates_call
+	int m_pid;                            // Parse id
+	int m_cid;                            // Cleanup index
+	bool m_releasepaircache;              // Release pair cache on delete
+	bool m_deferedcollide;                // Defere dynamic/static collision to collide call
+	bool m_needcleanup;                   // Need to run cleanup?
+#if B3_DBVT_BP_PROFILE
+	b3Clock m_clock;
+	struct
+	{
+		unsigned long m_total;
+		unsigned long m_ddcollide;
+		unsigned long m_fdcollide;
+		unsigned long m_cleanup;
+		unsigned long m_jobcount;
+	} m_profiling;
+#endif
+	/* Methods		*/
+	b3DynamicBvhBroadphase(int proxyCapacity, b3OverlappingPairCache* paircache = 0);
+	virtual ~b3DynamicBvhBroadphase();
+	void collide(b3Dispatcher* dispatcher);
+	void optimize();
+
+	/* b3BroadphaseInterface Implementation	*/
+	b3BroadphaseProxy* createProxy(const b3Vector3& aabbMin, const b3Vector3& aabbMax, int objectIndex, void* userPtr, int collisionFilterGroup, int collisionFilterMask);
+	virtual void destroyProxy(b3BroadphaseProxy* proxy, b3Dispatcher* dispatcher);
+	virtual void setAabb(int objectId, const b3Vector3& aabbMin, const b3Vector3& aabbMax, b3Dispatcher* dispatcher);
+	virtual void rayTest(const b3Vector3& rayFrom, const b3Vector3& rayTo, b3BroadphaseRayCallback& rayCallback, const b3Vector3& aabbMin = b3MakeVector3(0, 0, 0), const b3Vector3& aabbMax = b3MakeVector3(0, 0, 0));
+	virtual void aabbTest(const b3Vector3& aabbMin, const b3Vector3& aabbMax, b3BroadphaseAabbCallback& callback);
+
+	//virtual void					getAabb(b3BroadphaseProxy* proxy,b3Vector3& aabbMin, b3Vector3& aabbMax ) const;
+	virtual void getAabb(int objectId, b3Vector3& aabbMin, b3Vector3& aabbMax) const;
+	virtual void calculateOverlappingPairs(b3Dispatcher* dispatcher = 0);
+	virtual b3OverlappingPairCache* getOverlappingPairCache();
+	virtual const b3OverlappingPairCache* getOverlappingPairCache() const;
+	virtual void getBroadphaseAabb(b3Vector3& aabbMin, b3Vector3& aabbMax) const;
+	virtual void printStats();
+
+	///reset broadphase internal structures, to ensure determinism/reproducability
+	virtual void resetPool(b3Dispatcher* dispatcher);
+
+	void performDeferredRemoval(b3Dispatcher* dispatcher);
+
+	void setVelocityPrediction(b3Scalar prediction)
+	{
+		m_prediction = prediction;
+	}
+	b3Scalar getVelocityPrediction() const
+	{
+		return m_prediction;
+	}
+
+	///this setAabbForceUpdate is similar to setAabb but always forces the aabb update.
+	///it is not part of the b3BroadphaseInterface but specific to b3DynamicBvhBroadphase.
+	///it bypasses certain optimizations that prevent aabb updates (when the aabb shrinks), see
+	///http://code.google.com/p/bullet/issues/detail?id=223
+	void setAabbForceUpdate(b3BroadphaseProxy* absproxy, const b3Vector3& aabbMin, const b3Vector3& aabbMax, b3Dispatcher* /*dispatcher*/);
+
+	//static void						benchmark(b3BroadphaseInterface*);
+};
+
+#endif
diff --git a/engine/inc/bullet/Bullet3Collision/BroadPhaseCollision/b3OverlappingPair.h b/engine/inc/bullet/Bullet3Collision/BroadPhaseCollision/b3OverlappingPair.h
new file mode 100644
index 00000000..4ff9ebae
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Collision/BroadPhaseCollision/b3OverlappingPair.h
@@ -0,0 +1,70 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_OVERLAPPING_PAIR_H
+#define B3_OVERLAPPING_PAIR_H
+
+#include "Bullet3Common/shared/b3Int4.h"
+
+#define B3_NEW_PAIR_MARKER -1
+#define B3_REMOVED_PAIR_MARKER -2
+
+typedef b3Int4 b3BroadphasePair;
+
+inline b3Int4 b3MakeBroadphasePair(int xx, int yy)
+{
+	b3Int4 pair;
+
+	if (xx < yy)
+	{
+		pair.x = xx;
+		pair.y = yy;
+	}
+	else
+	{
+		pair.x = yy;
+		pair.y = xx;
+	}
+	pair.z = B3_NEW_PAIR_MARKER;
+	pair.w = B3_NEW_PAIR_MARKER;
+	return pair;
+}
+
+/*struct b3BroadphasePair : public b3Int4
+{
+	explicit b3BroadphasePair(){}
+	
+};
+*/
+
+class b3BroadphasePairSortPredicate
+{
+public:
+	bool operator()(const b3BroadphasePair& a, const b3BroadphasePair& b) const
+	{
+		const int uidA0 = a.x;
+		const int uidB0 = b.x;
+		const int uidA1 = a.y;
+		const int uidB1 = b.y;
+		return uidA0 > uidB0 || (uidA0 == uidB0 && uidA1 > uidB1);
+	}
+};
+
+B3_FORCE_INLINE bool operator==(const b3BroadphasePair& a, const b3BroadphasePair& b)
+{
+	return (a.x == b.x) && (a.y == b.y);
+}
+
+#endif  //B3_OVERLAPPING_PAIR_H
diff --git a/engine/inc/bullet/Bullet3Collision/BroadPhaseCollision/b3OverlappingPairCache.h b/engine/inc/bullet/Bullet3Collision/BroadPhaseCollision/b3OverlappingPairCache.h
new file mode 100644
index 00000000..f1de1d94
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Collision/BroadPhaseCollision/b3OverlappingPairCache.h
@@ -0,0 +1,427 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_OVERLAPPING_PAIR_CACHE_H
+#define B3_OVERLAPPING_PAIR_CACHE_H
+
+#include "Bullet3Common/shared/b3Int2.h"
+#include "Bullet3Common/b3AlignedObjectArray.h"
+
+class b3Dispatcher;
+#include "b3OverlappingPair.h"
+
+typedef b3AlignedObjectArray<b3BroadphasePair> b3BroadphasePairArray;
+
+struct b3OverlapCallback
+{
+	virtual ~b3OverlapCallback()
+	{
+	}
+	//return true for deletion of the pair
+	virtual bool processOverlap(b3BroadphasePair& pair) = 0;
+};
+
+struct b3OverlapFilterCallback
+{
+	virtual ~b3OverlapFilterCallback()
+	{
+	}
+	// return true when pairs need collision
+	virtual bool needBroadphaseCollision(int proxy0, int proxy1) const = 0;
+};
+
+extern int b3g_removePairs;
+extern int b3g_addedPairs;
+extern int b3g_findPairs;
+
+const int B3_NULL_PAIR = 0xffffffff;
+
+///The b3OverlappingPairCache provides an interface for overlapping pair management (add, remove, storage), used by the b3BroadphaseInterface broadphases.
+///The b3HashedOverlappingPairCache and b3SortedOverlappingPairCache classes are two implementations.
+class b3OverlappingPairCache
+{
+public:
+	virtual ~b3OverlappingPairCache() {}  // this is needed so we can get to the derived class destructor
+
+	virtual b3BroadphasePair* getOverlappingPairArrayPtr() = 0;
+
+	virtual const b3BroadphasePair* getOverlappingPairArrayPtr() const = 0;
+
+	virtual b3BroadphasePairArray& getOverlappingPairArray() = 0;
+
+	virtual void cleanOverlappingPair(b3BroadphasePair& pair, b3Dispatcher* dispatcher) = 0;
+
+	virtual int getNumOverlappingPairs() const = 0;
+
+	virtual void cleanProxyFromPairs(int proxy, b3Dispatcher* dispatcher) = 0;
+
+	virtual void setOverlapFilterCallback(b3OverlapFilterCallback* callback) = 0;
+
+	virtual void processAllOverlappingPairs(b3OverlapCallback*, b3Dispatcher* dispatcher) = 0;
+
+	virtual b3BroadphasePair* findPair(int proxy0, int proxy1) = 0;
+
+	virtual bool hasDeferredRemoval() = 0;
+
+	//virtual	void	setInternalGhostPairCallback(b3OverlappingPairCallback* ghostPairCallback)=0;
+
+	virtual b3BroadphasePair* addOverlappingPair(int proxy0, int proxy1) = 0;
+	virtual void* removeOverlappingPair(int proxy0, int proxy1, b3Dispatcher* dispatcher) = 0;
+	virtual void removeOverlappingPairsContainingProxy(int /*proxy0*/, b3Dispatcher* /*dispatcher*/) = 0;
+
+	virtual void sortOverlappingPairs(b3Dispatcher* dispatcher) = 0;
+};
+
+/// Hash-space based Pair Cache, thanks to Erin Catto, Box2D, http://www.box2d.org, and Pierre Terdiman, Codercorner, http://codercorner.com
+class b3HashedOverlappingPairCache : public b3OverlappingPairCache
+{
+	b3BroadphasePairArray m_overlappingPairArray;
+	b3OverlapFilterCallback* m_overlapFilterCallback;
+	//	bool		m_blockedForChanges;
+
+public:
+	b3HashedOverlappingPairCache();
+	virtual ~b3HashedOverlappingPairCache();
+
+	virtual void removeOverlappingPairsContainingProxy(int proxy, b3Dispatcher* dispatcher);
+
+	virtual void* removeOverlappingPair(int proxy0, int proxy1, b3Dispatcher* dispatcher);
+
+	B3_FORCE_INLINE bool needsBroadphaseCollision(int proxy0, int proxy1) const
+	{
+		if (m_overlapFilterCallback)
+			return m_overlapFilterCallback->needBroadphaseCollision(proxy0, proxy1);
+
+		bool collides = true;  //(proxy0->m_collisionFilterGroup & proxy1->m_collisionFilterMask) != 0;
+		//collides = collides && (proxy1->m_collisionFilterGroup & proxy0->m_collisionFilterMask);
+
+		return collides;
+	}
+
+	// Add a pair and return the new pair. If the pair already exists,
+	// no new pair is created and the old one is returned.
+	virtual b3BroadphasePair* addOverlappingPair(int proxy0, int proxy1)
+	{
+		b3g_addedPairs++;
+
+		if (!needsBroadphaseCollision(proxy0, proxy1))
+			return 0;
+
+		return internalAddPair(proxy0, proxy1);
+	}
+
+	void cleanProxyFromPairs(int proxy, b3Dispatcher* dispatcher);
+
+	virtual void processAllOverlappingPairs(b3OverlapCallback*, b3Dispatcher* dispatcher);
+
+	virtual b3BroadphasePair* getOverlappingPairArrayPtr()
+	{
+		return &m_overlappingPairArray[0];
+	}
+
+	const b3BroadphasePair* getOverlappingPairArrayPtr() const
+	{
+		return &m_overlappingPairArray[0];
+	}
+
+	b3BroadphasePairArray& getOverlappingPairArray()
+	{
+		return m_overlappingPairArray;
+	}
+
+	const b3BroadphasePairArray& getOverlappingPairArray() const
+	{
+		return m_overlappingPairArray;
+	}
+
+	void cleanOverlappingPair(b3BroadphasePair& pair, b3Dispatcher* dispatcher);
+
+	b3BroadphasePair* findPair(int proxy0, int proxy1);
+
+	int GetCount() const { return m_overlappingPairArray.size(); }
+	//	b3BroadphasePair* GetPairs() { return m_pairs; }
+
+	b3OverlapFilterCallback* getOverlapFilterCallback()
+	{
+		return m_overlapFilterCallback;
+	}
+
+	void setOverlapFilterCallback(b3OverlapFilterCallback* callback)
+	{
+		m_overlapFilterCallback = callback;
+	}
+
+	int getNumOverlappingPairs() const
+	{
+		return m_overlappingPairArray.size();
+	}
+
+private:
+	b3BroadphasePair* internalAddPair(int proxy0, int proxy1);
+
+	void growTables();
+
+	B3_FORCE_INLINE bool equalsPair(const b3BroadphasePair& pair, int proxyId1, int proxyId2)
+	{
+		return pair.x == proxyId1 && pair.y == proxyId2;
+	}
+
+	/*
+	// Thomas Wang's hash, see: http://www.concentric.net/~Ttwang/tech/inthash.htm
+	// This assumes proxyId1 and proxyId2 are 16-bit.
+	B3_FORCE_INLINE int getHash(int proxyId1, int proxyId2)
+	{
+		int key = (proxyId2 << 16) | proxyId1;
+		key = ~key + (key << 15);
+		key = key ^ (key >> 12);
+		key = key + (key << 2);
+		key = key ^ (key >> 4);
+		key = key * 2057;
+		key = key ^ (key >> 16);
+		return key;
+	}
+	*/
+
+	B3_FORCE_INLINE unsigned int getHash(unsigned int proxyId1, unsigned int proxyId2)
+	{
+		int key = static_cast<int>(((unsigned int)proxyId1) | (((unsigned int)proxyId2) << 16));
+		// Thomas Wang's hash
+
+		key += ~(key << 15);
+		key ^= (key >> 10);
+		key += (key << 3);
+		key ^= (key >> 6);
+		key += ~(key << 11);
+		key ^= (key >> 16);
+		return static_cast<unsigned int>(key);
+	}
+
+	B3_FORCE_INLINE b3BroadphasePair* internalFindPair(int proxy0, int proxy1, int hash)
+	{
+		int proxyId1 = proxy0;
+		int proxyId2 = proxy1;
+#if 0  // wrong, 'equalsPair' use unsorted uids, copy-past devil striked again. Nat.
+		if (proxyId1 > proxyId2) 
+			b3Swap(proxyId1, proxyId2);
+#endif
+
+		int index = m_hashTable[hash];
+
+		while (index != B3_NULL_PAIR && equalsPair(m_overlappingPairArray[index], proxyId1, proxyId2) == false)
+		{
+			index = m_next[index];
+		}
+
+		if (index == B3_NULL_PAIR)
+		{
+			return NULL;
+		}
+
+		b3Assert(index < m_overlappingPairArray.size());
+
+		return &m_overlappingPairArray[index];
+	}
+
+	virtual bool hasDeferredRemoval()
+	{
+		return false;
+	}
+
+	/*	virtual	void	setInternalGhostPairCallback(b3OverlappingPairCallback* ghostPairCallback)
+	{
+		m_ghostPairCallback = ghostPairCallback;
+	}
+	*/
+
+	virtual void sortOverlappingPairs(b3Dispatcher* dispatcher);
+
+protected:
+	b3AlignedObjectArray<int> m_hashTable;
+	b3AlignedObjectArray<int> m_next;
+	//	b3OverlappingPairCallback*	m_ghostPairCallback;
+};
+
+///b3SortedOverlappingPairCache maintains the objects with overlapping AABB
+///Typically managed by the Broadphase, Axis3Sweep or b3SimpleBroadphase
+class b3SortedOverlappingPairCache : public b3OverlappingPairCache
+{
+protected:
+	//avoid brute-force finding all the time
+	b3BroadphasePairArray m_overlappingPairArray;
+
+	//during the dispatch, check that user doesn't destroy/create proxy
+	bool m_blockedForChanges;
+
+	///by default, do the removal during the pair traversal
+	bool m_hasDeferredRemoval;
+
+	//if set, use the callback instead of the built in filter in needBroadphaseCollision
+	b3OverlapFilterCallback* m_overlapFilterCallback;
+
+	//		b3OverlappingPairCallback*	m_ghostPairCallback;
+
+public:
+	b3SortedOverlappingPairCache();
+	virtual ~b3SortedOverlappingPairCache();
+
+	virtual void processAllOverlappingPairs(b3OverlapCallback*, b3Dispatcher* dispatcher);
+
+	void* removeOverlappingPair(int proxy0, int proxy1, b3Dispatcher* dispatcher);
+
+	void cleanOverlappingPair(b3BroadphasePair& pair, b3Dispatcher* dispatcher);
+
+	b3BroadphasePair* addOverlappingPair(int proxy0, int proxy1);
+
+	b3BroadphasePair* findPair(int proxy0, int proxy1);
+
+	void cleanProxyFromPairs(int proxy, b3Dispatcher* dispatcher);
+
+	virtual void removeOverlappingPairsContainingProxy(int proxy, b3Dispatcher* dispatcher);
+
+	inline bool needsBroadphaseCollision(int proxy0, int proxy1) const
+	{
+		if (m_overlapFilterCallback)
+			return m_overlapFilterCallback->needBroadphaseCollision(proxy0, proxy1);
+
+		bool collides = true;  //(proxy0->m_collisionFilterGroup & proxy1->m_collisionFilterMask) != 0;
+		//collides = collides && (proxy1->m_collisionFilterGroup & proxy0->m_collisionFilterMask);
+
+		return collides;
+	}
+
+	b3BroadphasePairArray& getOverlappingPairArray()
+	{
+		return m_overlappingPairArray;
+	}
+
+	const b3BroadphasePairArray& getOverlappingPairArray() const
+	{
+		return m_overlappingPairArray;
+	}
+
+	b3BroadphasePair* getOverlappingPairArrayPtr()
+	{
+		return &m_overlappingPairArray[0];
+	}
+
+	const b3BroadphasePair* getOverlappingPairArrayPtr() const
+	{
+		return &m_overlappingPairArray[0];
+	}
+
+	int getNumOverlappingPairs() const
+	{
+		return m_overlappingPairArray.size();
+	}
+
+	b3OverlapFilterCallback* getOverlapFilterCallback()
+	{
+		return m_overlapFilterCallback;
+	}
+
+	void setOverlapFilterCallback(b3OverlapFilterCallback* callback)
+	{
+		m_overlapFilterCallback = callback;
+	}
+
+	virtual bool hasDeferredRemoval()
+	{
+		return m_hasDeferredRemoval;
+	}
+
+	/*		virtual	void	setInternalGhostPairCallback(b3OverlappingPairCallback* ghostPairCallback)
+		{
+			m_ghostPairCallback = ghostPairCallback;
+		}
+		*/
+	virtual void sortOverlappingPairs(b3Dispatcher* dispatcher);
+};
+
+///b3NullPairCache skips add/removal of overlapping pairs. Userful for benchmarking and unit testing.
+class b3NullPairCache : public b3OverlappingPairCache
+{
+	b3BroadphasePairArray m_overlappingPairArray;
+
+public:
+	virtual b3BroadphasePair* getOverlappingPairArrayPtr()
+	{
+		return &m_overlappingPairArray[0];
+	}
+	const b3BroadphasePair* getOverlappingPairArrayPtr() const
+	{
+		return &m_overlappingPairArray[0];
+	}
+	b3BroadphasePairArray& getOverlappingPairArray()
+	{
+		return m_overlappingPairArray;
+	}
+
+	virtual void cleanOverlappingPair(b3BroadphasePair& /*pair*/, b3Dispatcher* /*dispatcher*/)
+	{
+	}
+
+	virtual int getNumOverlappingPairs() const
+	{
+		return 0;
+	}
+
+	virtual void cleanProxyFromPairs(int /*proxy*/, b3Dispatcher* /*dispatcher*/)
+	{
+	}
+
+	virtual void setOverlapFilterCallback(b3OverlapFilterCallback* /*callback*/)
+	{
+	}
+
+	virtual void processAllOverlappingPairs(b3OverlapCallback*, b3Dispatcher* /*dispatcher*/)
+	{
+	}
+
+	virtual b3BroadphasePair* findPair(int /*proxy0*/, int /*proxy1*/)
+	{
+		return 0;
+	}
+
+	virtual bool hasDeferredRemoval()
+	{
+		return true;
+	}
+
+	//	virtual	void	setInternalGhostPairCallback(b3OverlappingPairCallback* /* ghostPairCallback */)
+	//	{
+	//
+	//	}
+
+	virtual b3BroadphasePair* addOverlappingPair(int /*proxy0*/, int /*proxy1*/)
+	{
+		return 0;
+	}
+
+	virtual void* removeOverlappingPair(int /*proxy0*/, int /*proxy1*/, b3Dispatcher* /*dispatcher*/)
+	{
+		return 0;
+	}
+
+	virtual void removeOverlappingPairsContainingProxy(int /*proxy0*/, b3Dispatcher* /*dispatcher*/)
+	{
+	}
+
+	virtual void sortOverlappingPairs(b3Dispatcher* dispatcher)
+	{
+		(void)dispatcher;
+	}
+};
+
+#endif  //B3_OVERLAPPING_PAIR_CACHE_H
diff --git a/engine/inc/bullet/Bullet3Collision/BroadPhaseCollision/shared/b3Aabb.h b/engine/inc/bullet/Bullet3Collision/BroadPhaseCollision/shared/b3Aabb.h
new file mode 100644
index 00000000..343a2c0e
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Collision/BroadPhaseCollision/shared/b3Aabb.h
@@ -0,0 +1,56 @@
+
+#ifndef B3_AABB_H
+#define B3_AABB_H
+
+#include "Bullet3Common/shared/b3Float4.h"
+#include "Bullet3Common/shared/b3Mat3x3.h"
+
+typedef struct b3Aabb b3Aabb_t;
+
+struct b3Aabb
+{
+	union {
+		float m_min[4];
+		b3Float4 m_minVec;
+		int m_minIndices[4];
+	};
+	union {
+		float m_max[4];
+		b3Float4 m_maxVec;
+		int m_signedMaxIndices[4];
+	};
+};
+
+inline void b3TransformAabb2(b3Float4ConstArg localAabbMin, b3Float4ConstArg localAabbMax, float margin,
+							 b3Float4ConstArg pos,
+							 b3QuatConstArg orn,
+							 b3Float4* aabbMinOut, b3Float4* aabbMaxOut)
+{
+	b3Float4 localHalfExtents = 0.5f * (localAabbMax - localAabbMin);
+	localHalfExtents += b3MakeFloat4(margin, margin, margin, 0.f);
+	b3Float4 localCenter = 0.5f * (localAabbMax + localAabbMin);
+	b3Mat3x3 m;
+	m = b3QuatGetRotationMatrix(orn);
+	b3Mat3x3 abs_b = b3AbsoluteMat3x3(m);
+	b3Float4 center = b3TransformPoint(localCenter, pos, orn);
+
+	b3Float4 extent = b3MakeFloat4(b3Dot3F4(localHalfExtents, b3GetRow(abs_b, 0)),
+								   b3Dot3F4(localHalfExtents, b3GetRow(abs_b, 1)),
+								   b3Dot3F4(localHalfExtents, b3GetRow(abs_b, 2)),
+								   0.f);
+	*aabbMinOut = center - extent;
+	*aabbMaxOut = center + extent;
+}
+
+/// conservative test for overlap between two aabbs
+inline bool b3TestAabbAgainstAabb(b3Float4ConstArg aabbMin1, b3Float4ConstArg aabbMax1,
+								  b3Float4ConstArg aabbMin2, b3Float4ConstArg aabbMax2)
+{
+	bool overlap = true;
+	overlap = (aabbMin1.x > aabbMax2.x || aabbMax1.x < aabbMin2.x) ? false : overlap;
+	overlap = (aabbMin1.z > aabbMax2.z || aabbMax1.z < aabbMin2.z) ? false : overlap;
+	overlap = (aabbMin1.y > aabbMax2.y || aabbMax1.y < aabbMin2.y) ? false : overlap;
+	return overlap;
+}
+
+#endif  //B3_AABB_H
diff --git a/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/b3Config.h b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/b3Config.h
new file mode 100644
index 00000000..518da89c
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/b3Config.h
@@ -0,0 +1,39 @@
+#ifndef B3_CONFIG_H
+#define B3_CONFIG_H
+
+struct b3Config
+{
+	int m_maxConvexBodies;
+	int m_maxConvexShapes;
+	int m_maxBroadphasePairs;
+	int m_maxContactCapacity;
+	int m_compoundPairCapacity;
+
+	int m_maxVerticesPerFace;
+	int m_maxFacesPerShape;
+	int m_maxConvexVertices;
+	int m_maxConvexIndices;
+	int m_maxConvexUniqueEdges;
+
+	int m_maxCompoundChildShapes;
+
+	int m_maxTriConvexPairCapacity;
+
+	b3Config()
+		: m_maxConvexBodies(128 * 1024),
+		  m_maxVerticesPerFace(64),
+		  m_maxFacesPerShape(12),
+		  m_maxConvexVertices(8192),
+		  m_maxConvexIndices(81920),
+		  m_maxConvexUniqueEdges(8192),
+		  m_maxCompoundChildShapes(8192),
+		  m_maxTriConvexPairCapacity(256 * 1024)
+	{
+		m_maxConvexShapes = m_maxConvexBodies;
+		m_maxBroadphasePairs = 16 * m_maxConvexBodies;
+		m_maxContactCapacity = m_maxBroadphasePairs;
+		m_compoundPairCapacity = 1024 * 1024;
+	}
+};
+
+#endif  //B3_CONFIG_H
diff --git a/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/b3Contact4.h b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/b3Contact4.h
new file mode 100644
index 00000000..c2cd3c72
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/b3Contact4.h
@@ -0,0 +1,55 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_CONTACT4_H
+#define B3_CONTACT4_H
+
+#include "Bullet3Common/b3Vector3.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3Contact4Data.h"
+
+B3_ATTRIBUTE_ALIGNED16(struct)
+b3Contact4 : public b3Contact4Data
+{
+	B3_DECLARE_ALIGNED_ALLOCATOR();
+
+	int getBodyA() const { return abs(m_bodyAPtrAndSignBit); }
+	int getBodyB() const { return abs(m_bodyBPtrAndSignBit); }
+	bool isBodyAFixed() const { return m_bodyAPtrAndSignBit < 0; }
+	bool isBodyBFixed() const { return m_bodyBPtrAndSignBit < 0; }
+	//	todo. make it safer
+	int& getBatchIdx() { return m_batchIdx; }
+	const int& getBatchIdx() const { return m_batchIdx; }
+	float getRestituitionCoeff() const { return ((float)m_restituitionCoeffCmp / (float)0xffff); }
+	void setRestituitionCoeff(float c)
+	{
+		b3Assert(c >= 0.f && c <= 1.f);
+		m_restituitionCoeffCmp = (unsigned short)(c * 0xffff);
+	}
+	float getFrictionCoeff() const { return ((float)m_frictionCoeffCmp / (float)0xffff); }
+	void setFrictionCoeff(float c)
+	{
+		b3Assert(c >= 0.f && c <= 1.f);
+		m_frictionCoeffCmp = (unsigned short)(c * 0xffff);
+	}
+
+	//float& getNPoints() { return m_worldNormal[3]; }
+	int getNPoints() const { return (int)m_worldNormalOnB.w; }
+
+	float getPenetration(int idx) const { return m_worldPosB[idx].w; }
+
+	bool isInvalid() const { return (getBodyA() == 0 || getBodyB() == 0); }
+};
+
+#endif  //B3_CONTACT4_H
diff --git a/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/b3ConvexUtility.h b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/b3ConvexUtility.h
new file mode 100644
index 00000000..4c8a88cb
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/b3ConvexUtility.h
@@ -0,0 +1,55 @@
+
+/*
+Copyright (c) 2012 Advanced Micro Devices, Inc.  
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+//Originally written by Erwin Coumans
+
+#ifndef _BT_CONVEX_UTILITY_H
+#define _BT_CONVEX_UTILITY_H
+
+#include "Bullet3Common/b3AlignedObjectArray.h"
+#include "Bullet3Common/b3Transform.h"
+
+struct b3MyFace
+{
+	b3AlignedObjectArray<int> m_indices;
+	b3Scalar m_plane[4];
+};
+
+B3_ATTRIBUTE_ALIGNED16(class)
+b3ConvexUtility
+{
+public:
+	B3_DECLARE_ALIGNED_ALLOCATOR();
+
+	b3Vector3 m_localCenter;
+	b3Vector3 m_extents;
+	b3Vector3 mC;
+	b3Vector3 mE;
+	b3Scalar m_radius;
+
+	b3AlignedObjectArray<b3Vector3> m_vertices;
+	b3AlignedObjectArray<b3MyFace> m_faces;
+	b3AlignedObjectArray<b3Vector3> m_uniqueEdges;
+
+	b3ConvexUtility()
+	{
+	}
+	virtual ~b3ConvexUtility();
+
+	bool initializePolyhedralFeatures(const b3Vector3* orgVertices, int numVertices, bool mergeCoplanarTriangles = true);
+
+	void initialize();
+	bool testContainment() const;
+};
+#endif
diff --git a/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/b3CpuNarrowPhase.h b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/b3CpuNarrowPhase.h
new file mode 100644
index 00000000..f02353c2
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/b3CpuNarrowPhase.h
@@ -0,0 +1,92 @@
+#ifndef B3_CPU_NARROWPHASE_H
+#define B3_CPU_NARROWPHASE_H
+
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h"
+#include "Bullet3Common/b3AlignedObjectArray.h"
+#include "Bullet3Common/b3Vector3.h"
+#include "Bullet3Collision/BroadPhaseCollision/shared/b3Aabb.h"
+#include "Bullet3Common/shared/b3Int4.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3Contact4Data.h"
+
+class b3CpuNarrowPhase
+{
+protected:
+	struct b3CpuNarrowPhaseInternalData* m_data;
+	int m_acceleratedCompanionShapeIndex;
+	int m_planeBodyIndex;
+	int m_static0Index;
+
+	int registerConvexHullShapeInternal(class b3ConvexUtility* convexPtr, b3Collidable& col);
+	int registerConcaveMeshShape(b3AlignedObjectArray<b3Vector3>* vertices, b3AlignedObjectArray<int>* indices, b3Collidable& col, const float* scaling);
+
+public:
+	b3CpuNarrowPhase(const struct b3Config& config);
+
+	virtual ~b3CpuNarrowPhase(void);
+
+	int registerSphereShape(float radius);
+	int registerPlaneShape(const b3Vector3& planeNormal, float planeConstant);
+
+	int registerCompoundShape(b3AlignedObjectArray<b3GpuChildShape>* childShapes);
+	int registerFace(const b3Vector3& faceNormal, float faceConstant);
+
+	int registerConcaveMesh(b3AlignedObjectArray<b3Vector3>* vertices, b3AlignedObjectArray<int>* indices, const float* scaling);
+
+	//do they need to be merged?
+
+	int registerConvexHullShape(b3ConvexUtility* utilPtr);
+	int registerConvexHullShape(const float* vertices, int strideInBytes, int numVertices, const float* scaling);
+
+	//int registerRigidBody(int collidableIndex, float mass, const float* position, const float* orientation, const float* aabbMin, const float* aabbMax,bool writeToGpu);
+	void setObjectTransform(const float* position, const float* orientation, int bodyIndex);
+
+	void writeAllBodiesToGpu();
+	void reset();
+	void readbackAllBodiesToCpu();
+	bool getObjectTransformFromCpu(float* position, float* orientation, int bodyIndex) const;
+
+	void setObjectTransformCpu(float* position, float* orientation, int bodyIndex);
+	void setObjectVelocityCpu(float* linVel, float* angVel, int bodyIndex);
+
+	//virtual void computeContacts(cl_mem broadphasePairs, int numBroadphasePairs, cl_mem aabbsWorldSpace, int numObjects);
+	virtual void computeContacts(b3AlignedObjectArray<b3Int4>& pairs, b3AlignedObjectArray<b3Aabb>& aabbsWorldSpace, b3AlignedObjectArray<b3RigidBodyData>& bodies);
+
+	const struct b3RigidBodyData* getBodiesCpu() const;
+	//struct b3RigidBodyData* getBodiesCpu();
+
+	int getNumBodiesGpu() const;
+
+	int getNumBodyInertiasGpu() const;
+
+	const struct b3Collidable* getCollidablesCpu() const;
+	int getNumCollidablesGpu() const;
+
+	/*const struct b3Contact4* getContactsCPU() const;
+
+	
+	int	getNumContactsGpu() const;
+	*/
+
+	const b3AlignedObjectArray<b3Contact4Data>& getContacts() const;
+
+	int getNumRigidBodies() const;
+
+	int allocateCollidable();
+
+	int getStatic0Index() const
+	{
+		return m_static0Index;
+	}
+	b3Collidable& getCollidableCpu(int collidableIndex);
+	const b3Collidable& getCollidableCpu(int collidableIndex) const;
+
+	const b3CpuNarrowPhaseInternalData* getInternalData() const
+	{
+		return m_data;
+	}
+
+	const struct b3Aabb& getLocalSpaceAabb(int collidableIndex) const;
+};
+
+#endif  //B3_CPU_NARROWPHASE_H
diff --git a/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/b3RaycastInfo.h b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/b3RaycastInfo.h
new file mode 100644
index 00000000..b50c0eca
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/b3RaycastInfo.h
@@ -0,0 +1,25 @@
+
+#ifndef B3_RAYCAST_INFO_H
+#define B3_RAYCAST_INFO_H
+
+#include "Bullet3Common/b3Vector3.h"
+
+B3_ATTRIBUTE_ALIGNED16(struct)
+b3RayInfo
+{
+	b3Vector3 m_from;
+	b3Vector3 m_to;
+};
+
+B3_ATTRIBUTE_ALIGNED16(struct)
+b3RayHit
+{
+	b3Scalar m_hitFraction;
+	int m_hitBody;
+	int m_hitResult1;
+	int m_hitResult2;
+	b3Vector3 m_hitPoint;
+	b3Vector3 m_hitNormal;
+};
+
+#endif  //B3_RAYCAST_INFO_H
diff --git a/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/b3RigidBodyCL.h b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/b3RigidBodyCL.h
new file mode 100644
index 00000000..be1be57f
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/b3RigidBodyCL.h
@@ -0,0 +1,28 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_RIGID_BODY_CL
+#define B3_RIGID_BODY_CL
+
+#include "Bullet3Common/b3Scalar.h"
+#include "Bullet3Common/b3Matrix3x3.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h"
+
+inline float b3GetInvMass(const b3RigidBodyData& body)
+{
+	return body.m_invMass;
+}
+
+#endif  //B3_RIGID_BODY_CL
diff --git a/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3BvhSubtreeInfoData.h b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3BvhSubtreeInfoData.h
new file mode 100644
index 00000000..d6beb662
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3BvhSubtreeInfoData.h
@@ -0,0 +1,19 @@
+
+#ifndef B3_BVH_SUBTREE_INFO_DATA_H
+#define B3_BVH_SUBTREE_INFO_DATA_H
+
+typedef struct b3BvhSubtreeInfoData b3BvhSubtreeInfoData_t;
+
+struct b3BvhSubtreeInfoData
+{
+	//12 bytes
+	unsigned short int m_quantizedAabbMin[3];
+	unsigned short int m_quantizedAabbMax[3];
+	//4 bytes, points to the root of the subtree
+	int m_rootNodeIndex;
+	//4 bytes
+	int m_subtreeSize;
+	int m_padding[3];
+};
+
+#endif  //B3_BVH_SUBTREE_INFO_DATA_H
diff --git a/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3BvhTraversal.h b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3BvhTraversal.h
new file mode 100644
index 00000000..7c2507cc
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3BvhTraversal.h
@@ -0,0 +1,123 @@
+
+
+#include "Bullet3Common/shared/b3Int4.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h"
+#include "Bullet3Collision/BroadPhaseCollision/shared/b3Aabb.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3BvhSubtreeInfoData.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3QuantizedBvhNodeData.h"
+
+// work-in-progress
+void b3BvhTraversal(__global const b3Int4* pairs,
+					__global const b3RigidBodyData* rigidBodies,
+					__global const b3Collidable* collidables,
+					__global b3Aabb* aabbs,
+					__global b3Int4* concavePairsOut,
+					__global volatile int* numConcavePairsOut,
+					__global const b3BvhSubtreeInfo* subtreeHeadersRoot,
+					__global const b3QuantizedBvhNode* quantizedNodesRoot,
+					__global const b3BvhInfo* bvhInfos,
+					int numPairs,
+					int maxNumConcavePairsCapacity,
+					int id)
+{
+	int bodyIndexA = pairs[id].x;
+	int bodyIndexB = pairs[id].y;
+	int collidableIndexA = rigidBodies[bodyIndexA].m_collidableIdx;
+	int collidableIndexB = rigidBodies[bodyIndexB].m_collidableIdx;
+
+	//once the broadphase avoids static-static pairs, we can remove this test
+	if ((rigidBodies[bodyIndexA].m_invMass == 0) && (rigidBodies[bodyIndexB].m_invMass == 0))
+	{
+		return;
+	}
+
+	if (collidables[collidableIndexA].m_shapeType != SHAPE_CONCAVE_TRIMESH)
+		return;
+
+	int shapeTypeB = collidables[collidableIndexB].m_shapeType;
+
+	if (shapeTypeB != SHAPE_CONVEX_HULL &&
+		shapeTypeB != SHAPE_SPHERE &&
+		shapeTypeB != SHAPE_COMPOUND_OF_CONVEX_HULLS)
+		return;
+
+	b3BvhInfo bvhInfo = bvhInfos[collidables[collidableIndexA].m_numChildShapes];
+
+	b3Float4 bvhAabbMin = bvhInfo.m_aabbMin;
+	b3Float4 bvhAabbMax = bvhInfo.m_aabbMax;
+	b3Float4 bvhQuantization = bvhInfo.m_quantization;
+	int numSubtreeHeaders = bvhInfo.m_numSubTrees;
+	__global const b3BvhSubtreeInfoData* subtreeHeaders = &subtreeHeadersRoot[bvhInfo.m_subTreeOffset];
+	__global const b3QuantizedBvhNodeData* quantizedNodes = &quantizedNodesRoot[bvhInfo.m_nodeOffset];
+
+	unsigned short int quantizedQueryAabbMin[3];
+	unsigned short int quantizedQueryAabbMax[3];
+	b3QuantizeWithClamp(quantizedQueryAabbMin, aabbs[bodyIndexB].m_minVec, false, bvhAabbMin, bvhAabbMax, bvhQuantization);
+	b3QuantizeWithClamp(quantizedQueryAabbMax, aabbs[bodyIndexB].m_maxVec, true, bvhAabbMin, bvhAabbMax, bvhQuantization);
+
+	for (int i = 0; i < numSubtreeHeaders; i++)
+	{
+		b3BvhSubtreeInfoData subtree = subtreeHeaders[i];
+
+		int overlap = b3TestQuantizedAabbAgainstQuantizedAabbSlow(quantizedQueryAabbMin, quantizedQueryAabbMax, subtree.m_quantizedAabbMin, subtree.m_quantizedAabbMax);
+		if (overlap != 0)
+		{
+			int startNodeIndex = subtree.m_rootNodeIndex;
+			int endNodeIndex = subtree.m_rootNodeIndex + subtree.m_subtreeSize;
+			int curIndex = startNodeIndex;
+			int escapeIndex;
+			int isLeafNode;
+			int aabbOverlap;
+			while (curIndex < endNodeIndex)
+			{
+				b3QuantizedBvhNodeData rootNode = quantizedNodes[curIndex];
+				aabbOverlap = b3TestQuantizedAabbAgainstQuantizedAabbSlow(quantizedQueryAabbMin, quantizedQueryAabbMax, rootNode.m_quantizedAabbMin, rootNode.m_quantizedAabbMax);
+				isLeafNode = b3IsLeaf(&rootNode);
+				if (aabbOverlap)
+				{
+					if (isLeafNode)
+					{
+						int triangleIndex = b3GetTriangleIndex(&rootNode);
+						if (shapeTypeB == SHAPE_COMPOUND_OF_CONVEX_HULLS)
+						{
+							int numChildrenB = collidables[collidableIndexB].m_numChildShapes;
+							int pairIdx = b3AtomicAdd(numConcavePairsOut, numChildrenB);
+							for (int b = 0; b < numChildrenB; b++)
+							{
+								if ((pairIdx + b) < maxNumConcavePairsCapacity)
+								{
+									int childShapeIndexB = collidables[collidableIndexB].m_shapeIndex + b;
+									b3Int4 newPair = b3MakeInt4(bodyIndexA, bodyIndexB, triangleIndex, childShapeIndexB);
+									concavePairsOut[pairIdx + b] = newPair;
+								}
+							}
+						}
+						else
+						{
+							int pairIdx = b3AtomicInc(numConcavePairsOut);
+							if (pairIdx < maxNumConcavePairsCapacity)
+							{
+								b3Int4 newPair = b3MakeInt4(bodyIndexA, bodyIndexB, triangleIndex, 0);
+								concavePairsOut[pairIdx] = newPair;
+							}
+						}
+					}
+					curIndex++;
+				}
+				else
+				{
+					if (isLeafNode)
+					{
+						curIndex++;
+					}
+					else
+					{
+						escapeIndex = b3GetEscapeIndex(&rootNode);
+						curIndex += escapeIndex;
+					}
+				}
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3ClipFaces.h b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3ClipFaces.h
new file mode 100644
index 00000000..0d9b13f1
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3ClipFaces.h
@@ -0,0 +1,171 @@
+#ifndef B3_CLIP_FACES_H
+#define B3_CLIP_FACES_H
+
+#include "Bullet3Common/shared/b3Int4.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h"
+#include "Bullet3Collision/BroadPhaseCollision/shared/b3Aabb.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3BvhSubtreeInfoData.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3QuantizedBvhNodeData.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3ConvexPolyhedronData.h"
+
+inline b3Float4 b3Lerp3(b3Float4ConstArg a, b3Float4ConstArg b, float t)
+{
+	return b3MakeFloat4(a.x + (b.x - a.x) * t,
+						a.y + (b.y - a.y) * t,
+						a.z + (b.z - a.z) * t,
+						0.f);
+}
+
+// Clips a face to the back of a plane, return the number of vertices out, stored in ppVtxOut
+int clipFaceGlobal(__global const b3Float4* pVtxIn, int numVertsIn, b3Float4ConstArg planeNormalWS, float planeEqWS, __global b3Float4* ppVtxOut)
+{
+	int ve;
+	float ds, de;
+	int numVertsOut = 0;
+	//double-check next test
+	//	if (numVertsIn < 2)
+	//		return 0;
+
+	b3Float4 firstVertex = pVtxIn[numVertsIn - 1];
+	b3Float4 endVertex = pVtxIn[0];
+
+	ds = b3Dot(planeNormalWS, firstVertex) + planeEqWS;
+
+	for (ve = 0; ve < numVertsIn; ve++)
+	{
+		endVertex = pVtxIn[ve];
+		de = b3Dot(planeNormalWS, endVertex) + planeEqWS;
+		if (ds < 0)
+		{
+			if (de < 0)
+			{
+				// Start < 0, end < 0, so output endVertex
+				ppVtxOut[numVertsOut++] = endVertex;
+			}
+			else
+			{
+				// Start < 0, end >= 0, so output intersection
+				ppVtxOut[numVertsOut++] = b3Lerp3(firstVertex, endVertex, (ds * 1.f / (ds - de)));
+			}
+		}
+		else
+		{
+			if (de < 0)
+			{
+				// Start >= 0, end < 0 so output intersection and end
+				ppVtxOut[numVertsOut++] = b3Lerp3(firstVertex, endVertex, (ds * 1.f / (ds - de)));
+				ppVtxOut[numVertsOut++] = endVertex;
+			}
+		}
+		firstVertex = endVertex;
+		ds = de;
+	}
+	return numVertsOut;
+}
+
+__kernel void clipFacesAndFindContactsKernel(__global const b3Float4* separatingNormals,
+											 __global const int* hasSeparatingAxis,
+											 __global b3Int4* clippingFacesOut,
+											 __global b3Float4* worldVertsA1,
+											 __global b3Float4* worldNormalsA1,
+											 __global b3Float4* worldVertsB1,
+											 __global b3Float4* worldVertsB2,
+											 int vertexFaceCapacity,
+											 int pairIndex)
+{
+	//    int i = get_global_id(0);
+	//int pairIndex = i;
+	int i = pairIndex;
+
+	float minDist = -1e30f;
+	float maxDist = 0.02f;
+
+	//	if (i<numPairs)
+	{
+		if (hasSeparatingAxis[i])
+		{
+			//			int bodyIndexA = pairs[i].x;
+			//		int bodyIndexB = pairs[i].y;
+
+			int numLocalContactsOut = 0;
+
+			int capacityWorldVertsB2 = vertexFaceCapacity;
+
+			__global b3Float4* pVtxIn = &worldVertsB1[pairIndex * capacityWorldVertsB2];
+			__global b3Float4* pVtxOut = &worldVertsB2[pairIndex * capacityWorldVertsB2];
+
+			{
+				__global b3Int4* clippingFaces = clippingFacesOut;
+
+				int closestFaceA = clippingFaces[pairIndex].x;
+				// int closestFaceB = clippingFaces[pairIndex].y;
+				int numVertsInA = clippingFaces[pairIndex].z;
+				int numVertsInB = clippingFaces[pairIndex].w;
+
+				int numVertsOut = 0;
+
+				if (closestFaceA >= 0)
+				{
+					// clip polygon to back of planes of all faces of hull A that are adjacent to witness face
+
+					for (int e0 = 0; e0 < numVertsInA; e0++)
+					{
+						const b3Float4 aw = worldVertsA1[pairIndex * capacityWorldVertsB2 + e0];
+						const b3Float4 bw = worldVertsA1[pairIndex * capacityWorldVertsB2 + ((e0 + 1) % numVertsInA)];
+						const b3Float4 WorldEdge0 = aw - bw;
+						b3Float4 worldPlaneAnormal1 = worldNormalsA1[pairIndex];
+						b3Float4 planeNormalWS1 = -b3Cross(WorldEdge0, worldPlaneAnormal1);
+						b3Float4 worldA1 = aw;
+						float planeEqWS1 = -b3Dot(worldA1, planeNormalWS1);
+						b3Float4 planeNormalWS = planeNormalWS1;
+						float planeEqWS = planeEqWS1;
+						numVertsOut = clipFaceGlobal(pVtxIn, numVertsInB, planeNormalWS, planeEqWS, pVtxOut);
+						__global b3Float4* tmp = pVtxOut;
+						pVtxOut = pVtxIn;
+						pVtxIn = tmp;
+						numVertsInB = numVertsOut;
+						numVertsOut = 0;
+					}
+
+					b3Float4 planeNormalWS = worldNormalsA1[pairIndex];
+					float planeEqWS = -b3Dot(planeNormalWS, worldVertsA1[pairIndex * capacityWorldVertsB2]);
+
+					for (int i = 0; i < numVertsInB; i++)
+					{
+						float depth = b3Dot(planeNormalWS, pVtxIn[i]) + planeEqWS;
+						if (depth <= minDist)
+						{
+							depth = minDist;
+						}
+						/*
+						static float maxDepth = 0.f;
+						if (depth < maxDepth)
+						{
+							maxDepth = depth;
+							if (maxDepth < -10)
+							{
+								printf("error at framecount %d?\n",myframecount);
+							}
+							printf("maxDepth = %f\n", maxDepth);
+
+						}
+*/
+						if (depth <= maxDist)
+						{
+							b3Float4 pointInWorld = pVtxIn[i];
+							pVtxOut[numLocalContactsOut++] = b3MakeFloat4(pointInWorld.x, pointInWorld.y, pointInWorld.z, depth);
+						}
+					}
+				}
+				clippingFaces[pairIndex].w = numLocalContactsOut;
+			}
+
+			for (int i = 0; i < numLocalContactsOut; i++)
+				pVtxIn[i] = pVtxOut[i];
+
+		}  //		if (hasSeparatingAxis[i])
+	}      //	if (i<numPairs)
+}
+
+#endif  //B3_CLIP_FACES_H
diff --git a/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h
new file mode 100644
index 00000000..9a8c668a
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h
@@ -0,0 +1,69 @@
+
+#ifndef B3_COLLIDABLE_H
+#define B3_COLLIDABLE_H
+
+#include "Bullet3Common/shared/b3Float4.h"
+#include "Bullet3Common/shared/b3Quat.h"
+
+enum b3ShapeTypes
+{
+	SHAPE_HEIGHT_FIELD = 1,
+
+	SHAPE_CONVEX_HULL = 3,
+	SHAPE_PLANE = 4,
+	SHAPE_CONCAVE_TRIMESH = 5,
+	SHAPE_COMPOUND_OF_CONVEX_HULLS = 6,
+	SHAPE_SPHERE = 7,
+	MAX_NUM_SHAPE_TYPES,
+};
+
+typedef struct b3Collidable b3Collidable_t;
+
+struct b3Collidable
+{
+	union {
+		int m_numChildShapes;
+		int m_bvhIndex;
+	};
+	union {
+		float m_radius;
+		int m_compoundBvhIndex;
+	};
+
+	int m_shapeType;
+	union {
+		int m_shapeIndex;
+		float m_height;
+	};
+};
+
+typedef struct b3GpuChildShape b3GpuChildShape_t;
+struct b3GpuChildShape
+{
+	b3Float4 m_childPosition;
+	b3Quat m_childOrientation;
+	union {
+		int m_shapeIndex;  //used for SHAPE_COMPOUND_OF_CONVEX_HULLS
+		int m_capsuleAxis;
+	};
+	union {
+		float m_radius;        //used for childshape of SHAPE_COMPOUND_OF_SPHERES or SHAPE_COMPOUND_OF_CAPSULES
+		int m_numChildShapes;  //used for compound shape
+	};
+	union {
+		float m_height;  //used for childshape of SHAPE_COMPOUND_OF_CAPSULES
+		int m_collidableShapeIndex;
+	};
+	int m_shapeType;
+};
+
+struct b3CompoundOverlappingPair
+{
+	int m_bodyIndexA;
+	int m_bodyIndexB;
+	//	int	m_pairType;
+	int m_childShapeIndexA;
+	int m_childShapeIndexB;
+};
+
+#endif  //B3_COLLIDABLE_H
diff --git a/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3Contact4Data.h b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3Contact4Data.h
new file mode 100644
index 00000000..d5f6daa9
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3Contact4Data.h
@@ -0,0 +1,36 @@
+#ifndef B3_CONTACT4DATA_H
+#define B3_CONTACT4DATA_H
+
+#include "Bullet3Common/shared/b3Float4.h"
+
+typedef struct b3Contact4Data b3Contact4Data_t;
+
+struct b3Contact4Data
+{
+	b3Float4 m_worldPosB[4];
+	//	b3Float4	m_localPosA[4];
+	//	b3Float4	m_localPosB[4];
+	b3Float4 m_worldNormalOnB;  //	w: m_nPoints
+	unsigned short m_restituitionCoeffCmp;
+	unsigned short m_frictionCoeffCmp;
+	int m_batchIdx;
+	int m_bodyAPtrAndSignBit;  //x:m_bodyAPtr, y:m_bodyBPtr
+	int m_bodyBPtrAndSignBit;
+
+	int m_childIndexA;
+	int m_childIndexB;
+	int m_unused1;
+	int m_unused2;
+};
+
+inline int b3Contact4Data_getNumPoints(const struct b3Contact4Data* contact)
+{
+	return (int)contact->m_worldNormalOnB.w;
+};
+
+inline void b3Contact4Data_setNumPoints(struct b3Contact4Data* contact, int numPoints)
+{
+	contact->m_worldNormalOnB.w = (float)numPoints;
+};
+
+#endif  //B3_CONTACT4DATA_H
\ No newline at end of file
diff --git a/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3ContactConvexConvexSAT.h b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3ContactConvexConvexSAT.h
new file mode 100644
index 00000000..ca68f4bc
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3ContactConvexConvexSAT.h
@@ -0,0 +1,486 @@
+
+#ifndef B3_CONTACT_CONVEX_CONVEX_SAT_H
+#define B3_CONTACT_CONVEX_CONVEX_SAT_H
+
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3Contact4Data.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3FindSeparatingAxis.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3ReduceContacts.h"
+
+#define B3_MAX_VERTS 1024
+
+inline b3Float4 b3Lerp3(const b3Float4& a, const b3Float4& b, float t)
+{
+	return b3MakeVector3(a.x + (b.x - a.x) * t,
+						 a.y + (b.y - a.y) * t,
+						 a.z + (b.z - a.z) * t,
+						 0.f);
+}
+
+// Clips a face to the back of a plane, return the number of vertices out, stored in ppVtxOut
+inline int b3ClipFace(const b3Float4* pVtxIn, int numVertsIn, b3Float4& planeNormalWS, float planeEqWS, b3Float4* ppVtxOut)
+{
+	int ve;
+	float ds, de;
+	int numVertsOut = 0;
+	if (numVertsIn < 2)
+		return 0;
+
+	b3Float4 firstVertex = pVtxIn[numVertsIn - 1];
+	b3Float4 endVertex = pVtxIn[0];
+
+	ds = b3Dot3F4(planeNormalWS, firstVertex) + planeEqWS;
+
+	for (ve = 0; ve < numVertsIn; ve++)
+	{
+		endVertex = pVtxIn[ve];
+
+		de = b3Dot3F4(planeNormalWS, endVertex) + planeEqWS;
+
+		if (ds < 0)
+		{
+			if (de < 0)
+			{
+				// Start < 0, end < 0, so output endVertex
+				ppVtxOut[numVertsOut++] = endVertex;
+			}
+			else
+			{
+				// Start < 0, end >= 0, so output intersection
+				ppVtxOut[numVertsOut++] = b3Lerp3(firstVertex, endVertex, (ds * 1.f / (ds - de)));
+			}
+		}
+		else
+		{
+			if (de < 0)
+			{
+				// Start >= 0, end < 0 so output intersection and end
+				ppVtxOut[numVertsOut++] = b3Lerp3(firstVertex, endVertex, (ds * 1.f / (ds - de)));
+				ppVtxOut[numVertsOut++] = endVertex;
+			}
+		}
+		firstVertex = endVertex;
+		ds = de;
+	}
+	return numVertsOut;
+}
+
+inline int b3ClipFaceAgainstHull(const b3Float4& separatingNormal, const b3ConvexPolyhedronData* hullA,
+								 const b3Float4& posA, const b3Quaternion& ornA, b3Float4* worldVertsB1, int numWorldVertsB1,
+								 b3Float4* worldVertsB2, int capacityWorldVertsB2,
+								 const float minDist, float maxDist,
+								 const b3AlignedObjectArray<b3Float4>& verticesA, const b3AlignedObjectArray<b3GpuFace>& facesA, const b3AlignedObjectArray<int>& indicesA,
+								 //const b3Float4* verticesB,	const b3GpuFace* facesB,	const int* indicesB,
+								 b3Float4* contactsOut,
+								 int contactCapacity)
+{
+	int numContactsOut = 0;
+
+	b3Float4* pVtxIn = worldVertsB1;
+	b3Float4* pVtxOut = worldVertsB2;
+
+	int numVertsIn = numWorldVertsB1;
+	int numVertsOut = 0;
+
+	int closestFaceA = -1;
+	{
+		float dmin = FLT_MAX;
+		for (int face = 0; face < hullA->m_numFaces; face++)
+		{
+			const b3Float4 Normal = b3MakeVector3(
+				facesA[hullA->m_faceOffset + face].m_plane.x,
+				facesA[hullA->m_faceOffset + face].m_plane.y,
+				facesA[hullA->m_faceOffset + face].m_plane.z, 0.f);
+			const b3Float4 faceANormalWS = b3QuatRotate(ornA, Normal);
+
+			float d = b3Dot3F4(faceANormalWS, separatingNormal);
+			if (d < dmin)
+			{
+				dmin = d;
+				closestFaceA = face;
+			}
+		}
+	}
+	if (closestFaceA < 0)
+		return numContactsOut;
+
+	b3GpuFace polyA = facesA[hullA->m_faceOffset + closestFaceA];
+
+	// clip polygon to back of planes of all faces of hull A that are adjacent to witness face
+	//int numContacts = numWorldVertsB1;
+	int numVerticesA = polyA.m_numIndices;
+	for (int e0 = 0; e0 < numVerticesA; e0++)
+	{
+		const b3Float4 a = verticesA[hullA->m_vertexOffset + indicesA[polyA.m_indexOffset + e0]];
+		const b3Float4 b = verticesA[hullA->m_vertexOffset + indicesA[polyA.m_indexOffset + ((e0 + 1) % numVerticesA)]];
+		const b3Float4 edge0 = a - b;
+		const b3Float4 WorldEdge0 = b3QuatRotate(ornA, edge0);
+		b3Float4 planeNormalA = b3MakeFloat4(polyA.m_plane.x, polyA.m_plane.y, polyA.m_plane.z, 0.f);
+		b3Float4 worldPlaneAnormal1 = b3QuatRotate(ornA, planeNormalA);
+
+		b3Float4 planeNormalWS1 = -b3Cross3(WorldEdge0, worldPlaneAnormal1);
+		b3Float4 worldA1 = b3TransformPoint(a, posA, ornA);
+		float planeEqWS1 = -b3Dot3F4(worldA1, planeNormalWS1);
+
+		b3Float4 planeNormalWS = planeNormalWS1;
+		float planeEqWS = planeEqWS1;
+
+		//clip face
+		//clipFace(*pVtxIn, *pVtxOut,planeNormalWS,planeEqWS);
+		numVertsOut = b3ClipFace(pVtxIn, numVertsIn, planeNormalWS, planeEqWS, pVtxOut);
+
+		//btSwap(pVtxIn,pVtxOut);
+		b3Float4* tmp = pVtxOut;
+		pVtxOut = pVtxIn;
+		pVtxIn = tmp;
+		numVertsIn = numVertsOut;
+		numVertsOut = 0;
+	}
+
+	// only keep points that are behind the witness face
+	{
+		b3Float4 localPlaneNormal = b3MakeFloat4(polyA.m_plane.x, polyA.m_plane.y, polyA.m_plane.z, 0.f);
+		float localPlaneEq = polyA.m_plane.w;
+		b3Float4 planeNormalWS = b3QuatRotate(ornA, localPlaneNormal);
+		float planeEqWS = localPlaneEq - b3Dot3F4(planeNormalWS, posA);
+		for (int i = 0; i < numVertsIn; i++)
+		{
+			float depth = b3Dot3F4(planeNormalWS, pVtxIn[i]) + planeEqWS;
+			if (depth <= minDist)
+			{
+				depth = minDist;
+			}
+			if (numContactsOut < contactCapacity)
+			{
+				if (depth <= maxDist)
+				{
+					b3Float4 pointInWorld = pVtxIn[i];
+					//resultOut.addContactPoint(separatingNormal,point,depth);
+					contactsOut[numContactsOut++] = b3MakeVector3(pointInWorld.x, pointInWorld.y, pointInWorld.z, depth);
+					//printf("depth=%f\n",depth);
+				}
+			}
+			else
+			{
+				b3Error("exceeding contact capacity (%d,%df)\n", numContactsOut, contactCapacity);
+			}
+		}
+	}
+
+	return numContactsOut;
+}
+
+inline int b3ClipHullAgainstHull(const b3Float4& separatingNormal,
+								 const b3ConvexPolyhedronData& hullA, const b3ConvexPolyhedronData& hullB,
+								 const b3Float4& posA, const b3Quaternion& ornA, const b3Float4& posB, const b3Quaternion& ornB,
+								 b3Float4* worldVertsB1, b3Float4* worldVertsB2, int capacityWorldVerts,
+								 const float minDist, float maxDist,
+								 const b3AlignedObjectArray<b3Float4>& verticesA, const b3AlignedObjectArray<b3GpuFace>& facesA, const b3AlignedObjectArray<int>& indicesA,
+								 const b3AlignedObjectArray<b3Float4>& verticesB, const b3AlignedObjectArray<b3GpuFace>& facesB, const b3AlignedObjectArray<int>& indicesB,
+
+								 b3Float4* contactsOut,
+								 int contactCapacity)
+{
+	int numContactsOut = 0;
+	int numWorldVertsB1 = 0;
+
+	B3_PROFILE("clipHullAgainstHull");
+
+	//float curMaxDist=maxDist;
+	int closestFaceB = -1;
+	float dmax = -FLT_MAX;
+
+	{
+		//B3_PROFILE("closestFaceB");
+		if (hullB.m_numFaces != 1)
+		{
+			//printf("wtf\n");
+		}
+		static bool once = true;
+		//printf("separatingNormal=%f,%f,%f\n",separatingNormal.x,separatingNormal.y,separatingNormal.z);
+
+		for (int face = 0; face < hullB.m_numFaces; face++)
+		{
+#ifdef BT_DEBUG_SAT_FACE
+			if (once)
+				printf("face %d\n", face);
+			const b3GpuFace* faceB = &facesB[hullB.m_faceOffset + face];
+			if (once)
+			{
+				for (int i = 0; i < faceB->m_numIndices; i++)
+				{
+					b3Float4 vert = verticesB[hullB.m_vertexOffset + indicesB[faceB->m_indexOffset + i]];
+					printf("vert[%d] = %f,%f,%f\n", i, vert.x, vert.y, vert.z);
+				}
+			}
+#endif  //BT_DEBUG_SAT_FACE \
+	//if (facesB[hullB.m_faceOffset+face].m_numIndices>2)
+			{
+				const b3Float4 Normal = b3MakeVector3(facesB[hullB.m_faceOffset + face].m_plane.x,
+													  facesB[hullB.m_faceOffset + face].m_plane.y, facesB[hullB.m_faceOffset + face].m_plane.z, 0.f);
+				const b3Float4 WorldNormal = b3QuatRotate(ornB, Normal);
+#ifdef BT_DEBUG_SAT_FACE
+				if (once)
+					printf("faceNormal = %f,%f,%f\n", Normal.x, Normal.y, Normal.z);
+#endif
+				float d = b3Dot3F4(WorldNormal, separatingNormal);
+				if (d > dmax)
+				{
+					dmax = d;
+					closestFaceB = face;
+				}
+			}
+		}
+		once = false;
+	}
+
+	b3Assert(closestFaceB >= 0);
+	{
+		//B3_PROFILE("worldVertsB1");
+		const b3GpuFace& polyB = facesB[hullB.m_faceOffset + closestFaceB];
+		const int numVertices = polyB.m_numIndices;
+		for (int e0 = 0; e0 < numVertices; e0++)
+		{
+			const b3Float4& b = verticesB[hullB.m_vertexOffset + indicesB[polyB.m_indexOffset + e0]];
+			worldVertsB1[numWorldVertsB1++] = b3TransformPoint(b, posB, ornB);
+		}
+	}
+
+	if (closestFaceB >= 0)
+	{
+		//B3_PROFILE("clipFaceAgainstHull");
+		numContactsOut = b3ClipFaceAgainstHull((b3Float4&)separatingNormal, &hullA,
+											   posA, ornA,
+											   worldVertsB1, numWorldVertsB1, worldVertsB2, capacityWorldVerts, minDist, maxDist,
+											   verticesA, facesA, indicesA,
+											   contactsOut, contactCapacity);
+	}
+
+	return numContactsOut;
+}
+
+inline int b3ClipHullHullSingle(
+	int bodyIndexA, int bodyIndexB,
+	const b3Float4& posA,
+	const b3Quaternion& ornA,
+	const b3Float4& posB,
+	const b3Quaternion& ornB,
+
+	int collidableIndexA, int collidableIndexB,
+
+	const b3AlignedObjectArray<b3RigidBodyData>* bodyBuf,
+	b3AlignedObjectArray<b3Contact4Data>* globalContactOut,
+	int& nContacts,
+
+	const b3AlignedObjectArray<b3ConvexPolyhedronData>& hostConvexDataA,
+	const b3AlignedObjectArray<b3ConvexPolyhedronData>& hostConvexDataB,
+
+	const b3AlignedObjectArray<b3Vector3>& verticesA,
+	const b3AlignedObjectArray<b3Vector3>& uniqueEdgesA,
+	const b3AlignedObjectArray<b3GpuFace>& facesA,
+	const b3AlignedObjectArray<int>& indicesA,
+
+	const b3AlignedObjectArray<b3Vector3>& verticesB,
+	const b3AlignedObjectArray<b3Vector3>& uniqueEdgesB,
+	const b3AlignedObjectArray<b3GpuFace>& facesB,
+	const b3AlignedObjectArray<int>& indicesB,
+
+	const b3AlignedObjectArray<b3Collidable>& hostCollidablesA,
+	const b3AlignedObjectArray<b3Collidable>& hostCollidablesB,
+	const b3Vector3& sepNormalWorldSpace,
+	int maxContactCapacity)
+{
+	int contactIndex = -1;
+	b3ConvexPolyhedronData hullA, hullB;
+
+	b3Collidable colA = hostCollidablesA[collidableIndexA];
+	hullA = hostConvexDataA[colA.m_shapeIndex];
+	//printf("numvertsA = %d\n",hullA.m_numVertices);
+
+	b3Collidable colB = hostCollidablesB[collidableIndexB];
+	hullB = hostConvexDataB[colB.m_shapeIndex];
+	//printf("numvertsB = %d\n",hullB.m_numVertices);
+
+	b3Float4 contactsOut[B3_MAX_VERTS];
+	int localContactCapacity = B3_MAX_VERTS;
+
+#ifdef _WIN32
+	b3Assert(_finite(bodyBuf->at(bodyIndexA).m_pos.x));
+	b3Assert(_finite(bodyBuf->at(bodyIndexB).m_pos.x));
+#endif
+
+	{
+		b3Float4 worldVertsB1[B3_MAX_VERTS];
+		b3Float4 worldVertsB2[B3_MAX_VERTS];
+		int capacityWorldVerts = B3_MAX_VERTS;
+
+		b3Float4 hostNormal = b3MakeFloat4(sepNormalWorldSpace.x, sepNormalWorldSpace.y, sepNormalWorldSpace.z, 0.f);
+		int shapeA = hostCollidablesA[collidableIndexA].m_shapeIndex;
+		int shapeB = hostCollidablesB[collidableIndexB].m_shapeIndex;
+
+		b3Scalar minDist = -1;
+		b3Scalar maxDist = 0.;
+
+		b3Transform trA, trB;
+		{
+			//B3_PROFILE("b3TransformPoint computation");
+			//trA.setIdentity();
+			trA.setOrigin(b3MakeVector3(posA.x, posA.y, posA.z));
+			trA.setRotation(b3Quaternion(ornA.x, ornA.y, ornA.z, ornA.w));
+
+			//trB.setIdentity();
+			trB.setOrigin(b3MakeVector3(posB.x, posB.y, posB.z));
+			trB.setRotation(b3Quaternion(ornB.x, ornB.y, ornB.z, ornB.w));
+		}
+
+		b3Quaternion trAorn = trA.getRotation();
+		b3Quaternion trBorn = trB.getRotation();
+
+		int numContactsOut = b3ClipHullAgainstHull(hostNormal,
+												   hostConvexDataA.at(shapeA),
+												   hostConvexDataB.at(shapeB),
+												   (b3Float4&)trA.getOrigin(), (b3Quaternion&)trAorn,
+												   (b3Float4&)trB.getOrigin(), (b3Quaternion&)trBorn,
+												   worldVertsB1, worldVertsB2, capacityWorldVerts,
+												   minDist, maxDist,
+												   verticesA, facesA, indicesA,
+												   verticesB, facesB, indicesB,
+
+												   contactsOut, localContactCapacity);
+
+		if (numContactsOut > 0)
+		{
+			B3_PROFILE("overlap");
+
+			b3Float4 normalOnSurfaceB = (b3Float4&)hostNormal;
+			//			b3Float4 centerOut;
+
+			b3Int4 contactIdx;
+			contactIdx.x = 0;
+			contactIdx.y = 1;
+			contactIdx.z = 2;
+			contactIdx.w = 3;
+
+			int numPoints = 0;
+
+			{
+				B3_PROFILE("extractManifold");
+				numPoints = b3ReduceContacts(contactsOut, numContactsOut, normalOnSurfaceB, &contactIdx);
+			}
+
+			b3Assert(numPoints);
+
+			if (nContacts < maxContactCapacity)
+			{
+				contactIndex = nContacts;
+				globalContactOut->expand();
+				b3Contact4Data& contact = globalContactOut->at(nContacts);
+				contact.m_batchIdx = 0;  //i;
+				contact.m_bodyAPtrAndSignBit = (bodyBuf->at(bodyIndexA).m_invMass == 0) ? -bodyIndexA : bodyIndexA;
+				contact.m_bodyBPtrAndSignBit = (bodyBuf->at(bodyIndexB).m_invMass == 0) ? -bodyIndexB : bodyIndexB;
+
+				contact.m_frictionCoeffCmp = 45874;
+				contact.m_restituitionCoeffCmp = 0;
+
+				//	float distance = 0.f;
+				for (int p = 0; p < numPoints; p++)
+				{
+					contact.m_worldPosB[p] = contactsOut[contactIdx.s[p]];  //check if it is actually on B
+					contact.m_worldNormalOnB = normalOnSurfaceB;
+				}
+				//printf("bodyIndexA %d,bodyIndexB %d,normal=%f,%f,%f numPoints %d\n",bodyIndexA,bodyIndexB,normalOnSurfaceB.x,normalOnSurfaceB.y,normalOnSurfaceB.z,numPoints);
+				contact.m_worldNormalOnB.w = (b3Scalar)numPoints;
+				nContacts++;
+			}
+			else
+			{
+				b3Error("Error: exceeding contact capacity (%d/%d)\n", nContacts, maxContactCapacity);
+			}
+		}
+	}
+	return contactIndex;
+}
+
+inline int b3ContactConvexConvexSAT(
+	int pairIndex,
+	int bodyIndexA, int bodyIndexB,
+	int collidableIndexA, int collidableIndexB,
+	const b3AlignedObjectArray<b3RigidBodyData>& rigidBodies,
+	const b3AlignedObjectArray<b3Collidable>& collidables,
+	const b3AlignedObjectArray<b3ConvexPolyhedronData>& convexShapes,
+	const b3AlignedObjectArray<b3Float4>& convexVertices,
+	const b3AlignedObjectArray<b3Float4>& uniqueEdges,
+	const b3AlignedObjectArray<int>& convexIndices,
+	const b3AlignedObjectArray<b3GpuFace>& faces,
+	b3AlignedObjectArray<b3Contact4Data>& globalContactsOut,
+	int& nGlobalContactsOut,
+	int maxContactCapacity)
+{
+	int contactIndex = -1;
+
+	b3Float4 posA = rigidBodies[bodyIndexA].m_pos;
+	b3Quaternion ornA = rigidBodies[bodyIndexA].m_quat;
+	b3Float4 posB = rigidBodies[bodyIndexB].m_pos;
+	b3Quaternion ornB = rigidBodies[bodyIndexB].m_quat;
+
+	b3ConvexPolyhedronData hullA, hullB;
+
+	b3Float4 sepNormalWorldSpace;
+
+	b3Collidable colA = collidables[collidableIndexA];
+	hullA = convexShapes[colA.m_shapeIndex];
+	//printf("numvertsA = %d\n",hullA.m_numVertices);
+
+	b3Collidable colB = collidables[collidableIndexB];
+	hullB = convexShapes[colB.m_shapeIndex];
+	//printf("numvertsB = %d\n",hullB.m_numVertices);
+
+#ifdef _WIN32
+	b3Assert(_finite(rigidBodies[bodyIndexA].m_pos.x));
+	b3Assert(_finite(rigidBodies[bodyIndexB].m_pos.x));
+#endif
+
+	bool foundSepAxis = b3FindSeparatingAxis(hullA, hullB,
+											 posA,
+											 ornA,
+											 posB,
+											 ornB,
+
+											 convexVertices, uniqueEdges, faces, convexIndices,
+											 convexVertices, uniqueEdges, faces, convexIndices,
+
+											 sepNormalWorldSpace);
+
+	if (foundSepAxis)
+	{
+		contactIndex = b3ClipHullHullSingle(
+			bodyIndexA, bodyIndexB,
+			posA, ornA,
+			posB, ornB,
+			collidableIndexA, collidableIndexB,
+			&rigidBodies,
+			&globalContactsOut,
+			nGlobalContactsOut,
+
+			convexShapes,
+			convexShapes,
+
+			convexVertices,
+			uniqueEdges,
+			faces,
+			convexIndices,
+
+			convexVertices,
+			uniqueEdges,
+			faces,
+			convexIndices,
+
+			collidables,
+			collidables,
+			sepNormalWorldSpace,
+			maxContactCapacity);
+	}
+
+	return contactIndex;
+}
+
+#endif  //B3_CONTACT_CONVEX_CONVEX_SAT_H
diff --git a/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3ContactSphereSphere.h b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3ContactSphereSphere.h
new file mode 100644
index 00000000..acf7c1b1
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3ContactSphereSphere.h
@@ -0,0 +1,153 @@
+
+#ifndef B3_CONTACT_SPHERE_SPHERE_H
+#define B3_CONTACT_SPHERE_SPHERE_H
+
+void computeContactSphereConvex(int pairIndex,
+								int bodyIndexA, int bodyIndexB,
+								int collidableIndexA, int collidableIndexB,
+								const b3RigidBodyData* rigidBodies,
+								const b3Collidable* collidables,
+								const b3ConvexPolyhedronData* convexShapes,
+								const b3Vector3* convexVertices,
+								const int* convexIndices,
+								const b3GpuFace* faces,
+								b3Contact4* globalContactsOut,
+								int& nGlobalContactsOut,
+								int maxContactCapacity)
+{
+	float radius = collidables[collidableIndexA].m_radius;
+	float4 spherePos1 = rigidBodies[bodyIndexA].m_pos;
+	b3Quaternion sphereOrn = rigidBodies[bodyIndexA].m_quat;
+
+	float4 pos = rigidBodies[bodyIndexB].m_pos;
+
+	b3Quaternion quat = rigidBodies[bodyIndexB].m_quat;
+
+	b3Transform tr;
+	tr.setIdentity();
+	tr.setOrigin(pos);
+	tr.setRotation(quat);
+	b3Transform trInv = tr.inverse();
+
+	float4 spherePos = trInv(spherePos1);
+
+	int collidableIndex = rigidBodies[bodyIndexB].m_collidableIdx;
+	int shapeIndex = collidables[collidableIndex].m_shapeIndex;
+	int numFaces = convexShapes[shapeIndex].m_numFaces;
+	float4 closestPnt = b3MakeVector3(0, 0, 0, 0);
+	float4 hitNormalWorld = b3MakeVector3(0, 0, 0, 0);
+	float minDist = -1000000.f;  // TODO: What is the largest/smallest float?
+	bool bCollide = true;
+	int region = -1;
+	float4 localHitNormal;
+	for (int f = 0; f < numFaces; f++)
+	{
+		b3GpuFace face = faces[convexShapes[shapeIndex].m_faceOffset + f];
+		float4 planeEqn;
+		float4 localPlaneNormal = b3MakeVector3(face.m_plane.x, face.m_plane.y, face.m_plane.z, 0.f);
+		float4 n1 = localPlaneNormal;  //quatRotate(quat,localPlaneNormal);
+		planeEqn = n1;
+		planeEqn[3] = face.m_plane.w;
+
+		float4 pntReturn;
+		float dist = signedDistanceFromPointToPlane(spherePos, planeEqn, &pntReturn);
+
+		if (dist > radius)
+		{
+			bCollide = false;
+			break;
+		}
+
+		if (dist > 0)
+		{
+			//might hit an edge or vertex
+			b3Vector3 out;
+
+			bool isInPoly = IsPointInPolygon(spherePos,
+											 &face,
+											 &convexVertices[convexShapes[shapeIndex].m_vertexOffset],
+											 convexIndices,
+											 &out);
+			if (isInPoly)
+			{
+				if (dist > minDist)
+				{
+					minDist = dist;
+					closestPnt = pntReturn;
+					localHitNormal = planeEqn;
+					region = 1;
+				}
+			}
+			else
+			{
+				b3Vector3 tmp = spherePos - out;
+				b3Scalar l2 = tmp.length2();
+				if (l2 < radius * radius)
+				{
+					dist = b3Sqrt(l2);
+					if (dist > minDist)
+					{
+						minDist = dist;
+						closestPnt = out;
+						localHitNormal = tmp / dist;
+						region = 2;
+					}
+				}
+				else
+				{
+					bCollide = false;
+					break;
+				}
+			}
+		}
+		else
+		{
+			if (dist > minDist)
+			{
+				minDist = dist;
+				closestPnt = pntReturn;
+				localHitNormal = planeEqn;
+				region = 3;
+			}
+		}
+	}
+	static int numChecks = 0;
+	numChecks++;
+
+	if (bCollide && minDist > -10000)
+	{
+		float4 normalOnSurfaceB1 = tr.getBasis() * localHitNormal;  //-hitNormalWorld;
+		float4 pOnB1 = tr(closestPnt);
+		//printf("dist ,%f,",minDist);
+		float actualDepth = minDist - radius;
+		if (actualDepth < 0)
+		{
+			//printf("actualDepth = ,%f,", actualDepth);
+			//printf("normalOnSurfaceB1 = ,%f,%f,%f,", normalOnSurfaceB1.x,normalOnSurfaceB1.y,normalOnSurfaceB1.z);
+			//printf("region=,%d,\n", region);
+			pOnB1[3] = actualDepth;
+
+			int dstIdx;
+			//    dstIdx = nGlobalContactsOut++;//AppendInc( nGlobalContactsOut, dstIdx );
+
+			if (nGlobalContactsOut < maxContactCapacity)
+			{
+				dstIdx = nGlobalContactsOut;
+				nGlobalContactsOut++;
+
+				b3Contact4* c = &globalContactsOut[dstIdx];
+				c->m_worldNormalOnB = normalOnSurfaceB1;
+				c->setFrictionCoeff(0.7);
+				c->setRestituitionCoeff(0.f);
+
+				c->m_batchIdx = pairIndex;
+				c->m_bodyAPtrAndSignBit = rigidBodies[bodyIndexA].m_invMass == 0 ? -bodyIndexA : bodyIndexA;
+				c->m_bodyBPtrAndSignBit = rigidBodies[bodyIndexB].m_invMass == 0 ? -bodyIndexB : bodyIndexB;
+				c->m_worldPosB[0] = pOnB1;
+				int numPoints = 1;
+				c->m_worldNormalOnB.w = (b3Scalar)numPoints;
+			}  //if (dstIdx < numPairs)
+		}
+	}  //if (hasCollision)
+}
+#endif  //B3_CONTACT_SPHERE_SPHERE_H
diff --git a/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3ConvexPolyhedronData.h b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3ConvexPolyhedronData.h
new file mode 100644
index 00000000..d5a73bd4
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3ConvexPolyhedronData.h
@@ -0,0 +1,38 @@
+
+#ifndef B3_CONVEX_POLYHEDRON_DATA_H
+#define B3_CONVEX_POLYHEDRON_DATA_H
+
+#include "Bullet3Common/shared/b3Float4.h"
+#include "Bullet3Common/shared/b3Quat.h"
+
+typedef struct b3GpuFace b3GpuFace_t;
+struct b3GpuFace
+{
+	b3Float4 m_plane;
+	int m_indexOffset;
+	int m_numIndices;
+	int m_unusedPadding1;
+	int m_unusedPadding2;
+};
+
+typedef struct b3ConvexPolyhedronData b3ConvexPolyhedronData_t;
+
+struct b3ConvexPolyhedronData
+{
+	b3Float4 m_localCenter;
+	b3Float4 m_extents;
+	b3Float4 mC;
+	b3Float4 mE;
+
+	float m_radius;
+	int m_faceOffset;
+	int m_numFaces;
+	int m_numVertices;
+
+	int m_vertexOffset;
+	int m_uniqueEdgesOffset;
+	int m_numUniqueEdges;
+	int m_unused;
+};
+
+#endif  //B3_CONVEX_POLYHEDRON_DATA_H
diff --git a/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3FindConcaveSatAxis.h b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3FindConcaveSatAxis.h
new file mode 100644
index 00000000..983554eb
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3FindConcaveSatAxis.h
@@ -0,0 +1,797 @@
+#ifndef B3_FIND_CONCAVE_SEPARATING_AXIS_H
+#define B3_FIND_CONCAVE_SEPARATING_AXIS_H
+
+#define B3_TRIANGLE_NUM_CONVEX_FACES 5
+
+#include "Bullet3Common/shared/b3Int4.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h"
+#include "Bullet3Collision/BroadPhaseCollision/shared/b3Aabb.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3BvhSubtreeInfoData.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3QuantizedBvhNodeData.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3ConvexPolyhedronData.h"
+
+inline void b3Project(__global const b3ConvexPolyhedronData* hull, b3Float4ConstArg pos, b3QuatConstArg orn,
+					  const b3Float4* dir, __global const b3Float4* vertices, float* min, float* max)
+{
+	min[0] = FLT_MAX;
+	max[0] = -FLT_MAX;
+	int numVerts = hull->m_numVertices;
+
+	const b3Float4 localDir = b3QuatRotate(b3QuatInverse(orn), *dir);
+	float offset = b3Dot(pos, *dir);
+	for (int i = 0; i < numVerts; i++)
+	{
+		float dp = b3Dot(vertices[hull->m_vertexOffset + i], localDir);
+		if (dp < min[0])
+			min[0] = dp;
+		if (dp > max[0])
+			max[0] = dp;
+	}
+	if (min[0] > max[0])
+	{
+		float tmp = min[0];
+		min[0] = max[0];
+		max[0] = tmp;
+	}
+	min[0] += offset;
+	max[0] += offset;
+}
+
+inline bool b3TestSepAxis(const b3ConvexPolyhedronData* hullA, __global const b3ConvexPolyhedronData* hullB,
+						  b3Float4ConstArg posA, b3QuatConstArg ornA,
+						  b3Float4ConstArg posB, b3QuatConstArg ornB,
+						  b3Float4* sep_axis, const b3Float4* verticesA, __global const b3Float4* verticesB, float* depth)
+{
+	float Min0, Max0;
+	float Min1, Max1;
+	b3Project(hullA, posA, ornA, sep_axis, verticesA, &Min0, &Max0);
+	b3Project(hullB, posB, ornB, sep_axis, verticesB, &Min1, &Max1);
+
+	if (Max0 < Min1 || Max1 < Min0)
+		return false;
+
+	float d0 = Max0 - Min1;
+	float d1 = Max1 - Min0;
+	*depth = d0 < d1 ? d0 : d1;
+	return true;
+}
+
+bool b3FindSeparatingAxis(const b3ConvexPolyhedronData* hullA, __global const b3ConvexPolyhedronData* hullB,
+						  b3Float4ConstArg posA1,
+						  b3QuatConstArg ornA,
+						  b3Float4ConstArg posB1,
+						  b3QuatConstArg ornB,
+						  b3Float4ConstArg DeltaC2,
+
+						  const b3Float4* verticesA,
+						  const b3Float4* uniqueEdgesA,
+						  const b3GpuFace* facesA,
+						  const int* indicesA,
+
+						  __global const b3Float4* verticesB,
+						  __global const b3Float4* uniqueEdgesB,
+						  __global const b3GpuFace* facesB,
+						  __global const int* indicesB,
+						  b3Float4* sep,
+						  float* dmin)
+{
+	b3Float4 posA = posA1;
+	posA.w = 0.f;
+	b3Float4 posB = posB1;
+	posB.w = 0.f;
+	/*
+	static int maxFaceVertex = 0;
+
+	int curFaceVertexAB = hullA->m_numFaces*hullB->m_numVertices;
+	curFaceVertexAB+= hullB->m_numFaces*hullA->m_numVertices;
+
+	if (curFaceVertexAB>maxFaceVertex)
+	{
+		maxFaceVertex = curFaceVertexAB;
+		printf("curFaceVertexAB = %d\n",curFaceVertexAB);
+		printf("hullA->m_numFaces = %d\n",hullA->m_numFaces);
+		printf("hullA->m_numVertices = %d\n",hullA->m_numVertices);
+		printf("hullB->m_numVertices = %d\n",hullB->m_numVertices);
+	}
+*/
+
+	int curPlaneTests = 0;
+	{
+		int numFacesA = hullA->m_numFaces;
+		// Test normals from hullA
+		for (int i = 0; i < numFacesA; i++)
+		{
+			const b3Float4 normal = facesA[hullA->m_faceOffset + i].m_plane;
+			b3Float4 faceANormalWS = b3QuatRotate(ornA, normal);
+			if (b3Dot(DeltaC2, faceANormalWS) < 0)
+				faceANormalWS *= -1.f;
+			curPlaneTests++;
+			float d;
+			if (!b3TestSepAxis(hullA, hullB, posA, ornA, posB, ornB, &faceANormalWS, verticesA, verticesB, &d))
+				return false;
+			if (d < *dmin)
+			{
+				*dmin = d;
+				*sep = faceANormalWS;
+			}
+		}
+	}
+	if ((b3Dot(-DeltaC2, *sep)) > 0.0f)
+	{
+		*sep = -(*sep);
+	}
+	return true;
+}
+
+b3Vector3 unitSphere162[] =
+	{
+		b3MakeVector3(0.000000, -1.000000, 0.000000),
+		b3MakeVector3(0.203181, -0.967950, 0.147618),
+		b3MakeVector3(-0.077607, -0.967950, 0.238853),
+		b3MakeVector3(0.723607, -0.447220, 0.525725),
+		b3MakeVector3(0.609547, -0.657519, 0.442856),
+		b3MakeVector3(0.812729, -0.502301, 0.295238),
+		b3MakeVector3(-0.251147, -0.967949, 0.000000),
+		b3MakeVector3(-0.077607, -0.967950, -0.238853),
+		b3MakeVector3(0.203181, -0.967950, -0.147618),
+		b3MakeVector3(0.860698, -0.251151, 0.442858),
+		b3MakeVector3(-0.276388, -0.447220, 0.850649),
+		b3MakeVector3(-0.029639, -0.502302, 0.864184),
+		b3MakeVector3(-0.155215, -0.251152, 0.955422),
+		b3MakeVector3(-0.894426, -0.447216, 0.000000),
+		b3MakeVector3(-0.831051, -0.502299, 0.238853),
+		b3MakeVector3(-0.956626, -0.251149, 0.147618),
+		b3MakeVector3(-0.276388, -0.447220, -0.850649),
+		b3MakeVector3(-0.483971, -0.502302, -0.716565),
+		b3MakeVector3(-0.436007, -0.251152, -0.864188),
+		b3MakeVector3(0.723607, -0.447220, -0.525725),
+		b3MakeVector3(0.531941, -0.502302, -0.681712),
+		b3MakeVector3(0.687159, -0.251152, -0.681715),
+		b3MakeVector3(0.687159, -0.251152, 0.681715),
+		b3MakeVector3(-0.436007, -0.251152, 0.864188),
+		b3MakeVector3(-0.956626, -0.251149, -0.147618),
+		b3MakeVector3(-0.155215, -0.251152, -0.955422),
+		b3MakeVector3(0.860698, -0.251151, -0.442858),
+		b3MakeVector3(0.276388, 0.447220, 0.850649),
+		b3MakeVector3(0.483971, 0.502302, 0.716565),
+		b3MakeVector3(0.232822, 0.657519, 0.716563),
+		b3MakeVector3(-0.723607, 0.447220, 0.525725),
+		b3MakeVector3(-0.531941, 0.502302, 0.681712),
+		b3MakeVector3(-0.609547, 0.657519, 0.442856),
+		b3MakeVector3(-0.723607, 0.447220, -0.525725),
+		b3MakeVector3(-0.812729, 0.502301, -0.295238),
+		b3MakeVector3(-0.609547, 0.657519, -0.442856),
+		b3MakeVector3(0.276388, 0.447220, -0.850649),
+		b3MakeVector3(0.029639, 0.502302, -0.864184),
+		b3MakeVector3(0.232822, 0.657519, -0.716563),
+		b3MakeVector3(0.894426, 0.447216, 0.000000),
+		b3MakeVector3(0.831051, 0.502299, -0.238853),
+		b3MakeVector3(0.753442, 0.657515, 0.000000),
+		b3MakeVector3(-0.232822, -0.657519, 0.716563),
+		b3MakeVector3(-0.162456, -0.850654, 0.499995),
+		b3MakeVector3(0.052790, -0.723612, 0.688185),
+		b3MakeVector3(0.138199, -0.894429, 0.425321),
+		b3MakeVector3(0.262869, -0.525738, 0.809012),
+		b3MakeVector3(0.361805, -0.723611, 0.587779),
+		b3MakeVector3(0.531941, -0.502302, 0.681712),
+		b3MakeVector3(0.425323, -0.850654, 0.309011),
+		b3MakeVector3(0.812729, -0.502301, -0.295238),
+		b3MakeVector3(0.609547, -0.657519, -0.442856),
+		b3MakeVector3(0.850648, -0.525736, 0.000000),
+		b3MakeVector3(0.670817, -0.723611, -0.162457),
+		b3MakeVector3(0.670817, -0.723610, 0.162458),
+		b3MakeVector3(0.425323, -0.850654, -0.309011),
+		b3MakeVector3(0.447211, -0.894428, 0.000001),
+		b3MakeVector3(-0.753442, -0.657515, 0.000000),
+		b3MakeVector3(-0.525730, -0.850652, 0.000000),
+		b3MakeVector3(-0.638195, -0.723609, 0.262864),
+		b3MakeVector3(-0.361801, -0.894428, 0.262864),
+		b3MakeVector3(-0.688189, -0.525736, 0.499997),
+		b3MakeVector3(-0.447211, -0.723610, 0.525729),
+		b3MakeVector3(-0.483971, -0.502302, 0.716565),
+		b3MakeVector3(-0.232822, -0.657519, -0.716563),
+		b3MakeVector3(-0.162456, -0.850654, -0.499995),
+		b3MakeVector3(-0.447211, -0.723611, -0.525727),
+		b3MakeVector3(-0.361801, -0.894429, -0.262863),
+		b3MakeVector3(-0.688189, -0.525736, -0.499997),
+		b3MakeVector3(-0.638195, -0.723609, -0.262863),
+		b3MakeVector3(-0.831051, -0.502299, -0.238853),
+		b3MakeVector3(0.361804, -0.723612, -0.587779),
+		b3MakeVector3(0.138197, -0.894429, -0.425321),
+		b3MakeVector3(0.262869, -0.525738, -0.809012),
+		b3MakeVector3(0.052789, -0.723611, -0.688186),
+		b3MakeVector3(-0.029639, -0.502302, -0.864184),
+		b3MakeVector3(0.956626, 0.251149, 0.147618),
+		b3MakeVector3(0.956626, 0.251149, -0.147618),
+		b3MakeVector3(0.951058, -0.000000, 0.309013),
+		b3MakeVector3(1.000000, 0.000000, 0.000000),
+		b3MakeVector3(0.947213, -0.276396, 0.162458),
+		b3MakeVector3(0.951058, 0.000000, -0.309013),
+		b3MakeVector3(0.947213, -0.276396, -0.162458),
+		b3MakeVector3(0.155215, 0.251152, 0.955422),
+		b3MakeVector3(0.436007, 0.251152, 0.864188),
+		b3MakeVector3(-0.000000, -0.000000, 1.000000),
+		b3MakeVector3(0.309017, 0.000000, 0.951056),
+		b3MakeVector3(0.138199, -0.276398, 0.951055),
+		b3MakeVector3(0.587786, 0.000000, 0.809017),
+		b3MakeVector3(0.447216, -0.276398, 0.850648),
+		b3MakeVector3(-0.860698, 0.251151, 0.442858),
+		b3MakeVector3(-0.687159, 0.251152, 0.681715),
+		b3MakeVector3(-0.951058, -0.000000, 0.309013),
+		b3MakeVector3(-0.809018, 0.000000, 0.587783),
+		b3MakeVector3(-0.861803, -0.276396, 0.425324),
+		b3MakeVector3(-0.587786, 0.000000, 0.809017),
+		b3MakeVector3(-0.670819, -0.276397, 0.688191),
+		b3MakeVector3(-0.687159, 0.251152, -0.681715),
+		b3MakeVector3(-0.860698, 0.251151, -0.442858),
+		b3MakeVector3(-0.587786, -0.000000, -0.809017),
+		b3MakeVector3(-0.809018, -0.000000, -0.587783),
+		b3MakeVector3(-0.670819, -0.276397, -0.688191),
+		b3MakeVector3(-0.951058, 0.000000, -0.309013),
+		b3MakeVector3(-0.861803, -0.276396, -0.425324),
+		b3MakeVector3(0.436007, 0.251152, -0.864188),
+		b3MakeVector3(0.155215, 0.251152, -0.955422),
+		b3MakeVector3(0.587786, -0.000000, -0.809017),
+		b3MakeVector3(0.309017, -0.000000, -0.951056),
+		b3MakeVector3(0.447216, -0.276398, -0.850648),
+		b3MakeVector3(0.000000, 0.000000, -1.000000),
+		b3MakeVector3(0.138199, -0.276398, -0.951055),
+		b3MakeVector3(0.670820, 0.276396, 0.688190),
+		b3MakeVector3(0.809019, -0.000002, 0.587783),
+		b3MakeVector3(0.688189, 0.525736, 0.499997),
+		b3MakeVector3(0.861804, 0.276394, 0.425323),
+		b3MakeVector3(0.831051, 0.502299, 0.238853),
+		b3MakeVector3(-0.447216, 0.276397, 0.850649),
+		b3MakeVector3(-0.309017, -0.000001, 0.951056),
+		b3MakeVector3(-0.262869, 0.525738, 0.809012),
+		b3MakeVector3(-0.138199, 0.276397, 0.951055),
+		b3MakeVector3(0.029639, 0.502302, 0.864184),
+		b3MakeVector3(-0.947213, 0.276396, -0.162458),
+		b3MakeVector3(-1.000000, 0.000001, 0.000000),
+		b3MakeVector3(-0.850648, 0.525736, -0.000000),
+		b3MakeVector3(-0.947213, 0.276397, 0.162458),
+		b3MakeVector3(-0.812729, 0.502301, 0.295238),
+		b3MakeVector3(-0.138199, 0.276397, -0.951055),
+		b3MakeVector3(-0.309016, -0.000000, -0.951057),
+		b3MakeVector3(-0.262869, 0.525738, -0.809012),
+		b3MakeVector3(-0.447215, 0.276397, -0.850649),
+		b3MakeVector3(-0.531941, 0.502302, -0.681712),
+		b3MakeVector3(0.861804, 0.276396, -0.425322),
+		b3MakeVector3(0.809019, 0.000000, -0.587782),
+		b3MakeVector3(0.688189, 0.525736, -0.499997),
+		b3MakeVector3(0.670821, 0.276397, -0.688189),
+		b3MakeVector3(0.483971, 0.502302, -0.716565),
+		b3MakeVector3(0.077607, 0.967950, 0.238853),
+		b3MakeVector3(0.251147, 0.967949, 0.000000),
+		b3MakeVector3(0.000000, 1.000000, 0.000000),
+		b3MakeVector3(0.162456, 0.850654, 0.499995),
+		b3MakeVector3(0.361800, 0.894429, 0.262863),
+		b3MakeVector3(0.447209, 0.723612, 0.525728),
+		b3MakeVector3(0.525730, 0.850652, 0.000000),
+		b3MakeVector3(0.638194, 0.723610, 0.262864),
+		b3MakeVector3(-0.203181, 0.967950, 0.147618),
+		b3MakeVector3(-0.425323, 0.850654, 0.309011),
+		b3MakeVector3(-0.138197, 0.894430, 0.425320),
+		b3MakeVector3(-0.361804, 0.723612, 0.587778),
+		b3MakeVector3(-0.052790, 0.723612, 0.688185),
+		b3MakeVector3(-0.203181, 0.967950, -0.147618),
+		b3MakeVector3(-0.425323, 0.850654, -0.309011),
+		b3MakeVector3(-0.447210, 0.894429, 0.000000),
+		b3MakeVector3(-0.670817, 0.723611, -0.162457),
+		b3MakeVector3(-0.670817, 0.723611, 0.162457),
+		b3MakeVector3(0.077607, 0.967950, -0.238853),
+		b3MakeVector3(0.162456, 0.850654, -0.499995),
+		b3MakeVector3(-0.138197, 0.894430, -0.425320),
+		b3MakeVector3(-0.052790, 0.723612, -0.688185),
+		b3MakeVector3(-0.361804, 0.723612, -0.587778),
+		b3MakeVector3(0.361800, 0.894429, -0.262863),
+		b3MakeVector3(0.638194, 0.723610, -0.262864),
+		b3MakeVector3(0.447209, 0.723612, -0.525728)};
+
+bool b3FindSeparatingAxisEdgeEdge(const b3ConvexPolyhedronData* hullA, __global const b3ConvexPolyhedronData* hullB,
+								  b3Float4ConstArg posA1,
+								  b3QuatConstArg ornA,
+								  b3Float4ConstArg posB1,
+								  b3QuatConstArg ornB,
+								  b3Float4ConstArg DeltaC2,
+								  const b3Float4* verticesA,
+								  const b3Float4* uniqueEdgesA,
+								  const b3GpuFace* facesA,
+								  const int* indicesA,
+								  __global const b3Float4* verticesB,
+								  __global const b3Float4* uniqueEdgesB,
+								  __global const b3GpuFace* facesB,
+								  __global const int* indicesB,
+								  b3Float4* sep,
+								  float* dmin,
+								  bool searchAllEdgeEdge)
+{
+	b3Float4 posA = posA1;
+	posA.w = 0.f;
+	b3Float4 posB = posB1;
+	posB.w = 0.f;
+
+	//	int curPlaneTests=0;
+
+	int curEdgeEdge = 0;
+	// Test edges
+	static int maxEdgeTests = 0;
+	int curEdgeTests = hullA->m_numUniqueEdges * hullB->m_numUniqueEdges;
+	if (curEdgeTests > maxEdgeTests)
+	{
+		maxEdgeTests = curEdgeTests;
+		printf("maxEdgeTests = %d\n", maxEdgeTests);
+		printf("hullA->m_numUniqueEdges = %d\n", hullA->m_numUniqueEdges);
+		printf("hullB->m_numUniqueEdges = %d\n", hullB->m_numUniqueEdges);
+	}
+
+	if (searchAllEdgeEdge)
+	{
+		for (int e0 = 0; e0 < hullA->m_numUniqueEdges; e0++)
+		{
+			const b3Float4 edge0 = uniqueEdgesA[hullA->m_uniqueEdgesOffset + e0];
+			b3Float4 edge0World = b3QuatRotate(ornA, edge0);
+
+			for (int e1 = 0; e1 < hullB->m_numUniqueEdges; e1++)
+			{
+				const b3Float4 edge1 = uniqueEdgesB[hullB->m_uniqueEdgesOffset + e1];
+				b3Float4 edge1World = b3QuatRotate(ornB, edge1);
+
+				b3Float4 crossje = b3Cross(edge0World, edge1World);
+
+				curEdgeEdge++;
+				if (!b3IsAlmostZero(crossje))
+				{
+					crossje = b3Normalized(crossje);
+					if (b3Dot(DeltaC2, crossje) < 0)
+						crossje *= -1.f;
+
+					float dist;
+					bool result = true;
+					{
+						float Min0, Max0;
+						float Min1, Max1;
+						b3Project(hullA, posA, ornA, &crossje, verticesA, &Min0, &Max0);
+						b3Project(hullB, posB, ornB, &crossje, verticesB, &Min1, &Max1);
+
+						if (Max0 < Min1 || Max1 < Min0)
+							return false;
+
+						float d0 = Max0 - Min1;
+						float d1 = Max1 - Min0;
+						dist = d0 < d1 ? d0 : d1;
+						result = true;
+					}
+
+					if (dist < *dmin)
+					{
+						*dmin = dist;
+						*sep = crossje;
+					}
+				}
+			}
+		}
+	}
+	else
+	{
+		int numDirections = sizeof(unitSphere162) / sizeof(b3Vector3);
+		//printf("numDirections =%d\n",numDirections );
+
+		for (int i = 0; i < numDirections; i++)
+		{
+			b3Float4 crossje = unitSphere162[i];
+			{
+				//if (b3Dot(DeltaC2,crossje)>0)
+				{
+					float dist;
+					bool result = true;
+					{
+						float Min0, Max0;
+						float Min1, Max1;
+						b3Project(hullA, posA, ornA, &crossje, verticesA, &Min0, &Max0);
+						b3Project(hullB, posB, ornB, &crossje, verticesB, &Min1, &Max1);
+
+						if (Max0 < Min1 || Max1 < Min0)
+							return false;
+
+						float d0 = Max0 - Min1;
+						float d1 = Max1 - Min0;
+						dist = d0 < d1 ? d0 : d1;
+						result = true;
+					}
+
+					if (dist < *dmin)
+					{
+						*dmin = dist;
+						*sep = crossje;
+					}
+				}
+			}
+		}
+	}
+
+	if ((b3Dot(-DeltaC2, *sep)) > 0.0f)
+	{
+		*sep = -(*sep);
+	}
+	return true;
+}
+
+inline int b3FindClippingFaces(b3Float4ConstArg separatingNormal,
+							   __global const b3ConvexPolyhedronData_t* hullA, __global const b3ConvexPolyhedronData_t* hullB,
+							   b3Float4ConstArg posA, b3QuatConstArg ornA, b3Float4ConstArg posB, b3QuatConstArg ornB,
+							   __global b3Float4* worldVertsA1,
+							   __global b3Float4* worldNormalsA1,
+							   __global b3Float4* worldVertsB1,
+							   int capacityWorldVerts,
+							   const float minDist, float maxDist,
+							   __global const b3Float4* verticesA,
+							   __global const b3GpuFace_t* facesA,
+							   __global const int* indicesA,
+							   __global const b3Float4* verticesB,
+							   __global const b3GpuFace_t* facesB,
+							   __global const int* indicesB,
+
+							   __global b3Int4* clippingFaces, int pairIndex)
+{
+	int numContactsOut = 0;
+	int numWorldVertsB1 = 0;
+
+	int closestFaceB = -1;
+	float dmax = -FLT_MAX;
+
+	{
+		for (int face = 0; face < hullB->m_numFaces; face++)
+		{
+			const b3Float4 Normal = b3MakeFloat4(facesB[hullB->m_faceOffset + face].m_plane.x,
+												 facesB[hullB->m_faceOffset + face].m_plane.y, facesB[hullB->m_faceOffset + face].m_plane.z, 0.f);
+			const b3Float4 WorldNormal = b3QuatRotate(ornB, Normal);
+			float d = b3Dot(WorldNormal, separatingNormal);
+			if (d > dmax)
+			{
+				dmax = d;
+				closestFaceB = face;
+			}
+		}
+	}
+
+	{
+		const b3GpuFace_t polyB = facesB[hullB->m_faceOffset + closestFaceB];
+		const int numVertices = polyB.m_numIndices;
+		for (int e0 = 0; e0 < numVertices; e0++)
+		{
+			const b3Float4 b = verticesB[hullB->m_vertexOffset + indicesB[polyB.m_indexOffset + e0]];
+			worldVertsB1[pairIndex * capacityWorldVerts + numWorldVertsB1++] = b3TransformPoint(b, posB, ornB);
+		}
+	}
+
+	int closestFaceA = -1;
+	{
+		float dmin = FLT_MAX;
+		for (int face = 0; face < hullA->m_numFaces; face++)
+		{
+			const b3Float4 Normal = b3MakeFloat4(
+				facesA[hullA->m_faceOffset + face].m_plane.x,
+				facesA[hullA->m_faceOffset + face].m_plane.y,
+				facesA[hullA->m_faceOffset + face].m_plane.z,
+				0.f);
+			const b3Float4 faceANormalWS = b3QuatRotate(ornA, Normal);
+
+			float d = b3Dot(faceANormalWS, separatingNormal);
+			if (d < dmin)
+			{
+				dmin = d;
+				closestFaceA = face;
+				worldNormalsA1[pairIndex] = faceANormalWS;
+			}
+		}
+	}
+
+	int numVerticesA = facesA[hullA->m_faceOffset + closestFaceA].m_numIndices;
+	for (int e0 = 0; e0 < numVerticesA; e0++)
+	{
+		const b3Float4 a = verticesA[hullA->m_vertexOffset + indicesA[facesA[hullA->m_faceOffset + closestFaceA].m_indexOffset + e0]];
+		worldVertsA1[pairIndex * capacityWorldVerts + e0] = b3TransformPoint(a, posA, ornA);
+	}
+
+	clippingFaces[pairIndex].x = closestFaceA;
+	clippingFaces[pairIndex].y = closestFaceB;
+	clippingFaces[pairIndex].z = numVerticesA;
+	clippingFaces[pairIndex].w = numWorldVertsB1;
+
+	return numContactsOut;
+}
+
+__kernel void b3FindConcaveSeparatingAxisKernel(__global b3Int4* concavePairs,
+												__global const b3RigidBodyData* rigidBodies,
+												__global const b3Collidable* collidables,
+												__global const b3ConvexPolyhedronData* convexShapes,
+												__global const b3Float4* vertices,
+												__global const b3Float4* uniqueEdges,
+												__global const b3GpuFace* faces,
+												__global const int* indices,
+												__global const b3GpuChildShape* gpuChildShapes,
+												__global b3Aabb* aabbs,
+												__global b3Float4* concaveSeparatingNormalsOut,
+												__global b3Int4* clippingFacesOut,
+												__global b3Vector3* worldVertsA1Out,
+												__global b3Vector3* worldNormalsA1Out,
+												__global b3Vector3* worldVertsB1Out,
+												__global int* hasSeparatingNormals,
+												int vertexFaceCapacity,
+												int numConcavePairs,
+												int pairIdx)
+{
+	int i = pairIdx;
+	/*	int i = get_global_id(0);
+	if (i>=numConcavePairs)
+		return;
+	int pairIdx = i;
+	*/
+
+	int bodyIndexA = concavePairs[i].x;
+	int bodyIndexB = concavePairs[i].y;
+
+	int collidableIndexA = rigidBodies[bodyIndexA].m_collidableIdx;
+	int collidableIndexB = rigidBodies[bodyIndexB].m_collidableIdx;
+
+	int shapeIndexA = collidables[collidableIndexA].m_shapeIndex;
+	int shapeIndexB = collidables[collidableIndexB].m_shapeIndex;
+
+	if (collidables[collidableIndexB].m_shapeType != SHAPE_CONVEX_HULL &&
+		collidables[collidableIndexB].m_shapeType != SHAPE_COMPOUND_OF_CONVEX_HULLS)
+	{
+		concavePairs[pairIdx].w = -1;
+		return;
+	}
+
+	hasSeparatingNormals[i] = 0;
+
+	//	int numFacesA = convexShapes[shapeIndexA].m_numFaces;
+	int numActualConcaveConvexTests = 0;
+
+	int f = concavePairs[i].z;
+
+	bool overlap = false;
+
+	b3ConvexPolyhedronData convexPolyhedronA;
+
+	//add 3 vertices of the triangle
+	convexPolyhedronA.m_numVertices = 3;
+	convexPolyhedronA.m_vertexOffset = 0;
+	b3Float4 localCenter = b3MakeFloat4(0.f, 0.f, 0.f, 0.f);
+
+	b3GpuFace face = faces[convexShapes[shapeIndexA].m_faceOffset + f];
+	b3Aabb triAabb;
+	triAabb.m_minVec = b3MakeFloat4(1e30f, 1e30f, 1e30f, 0.f);
+	triAabb.m_maxVec = b3MakeFloat4(-1e30f, -1e30f, -1e30f, 0.f);
+
+	b3Float4 verticesA[3];
+	for (int i = 0; i < 3; i++)
+	{
+		int index = indices[face.m_indexOffset + i];
+		b3Float4 vert = vertices[convexShapes[shapeIndexA].m_vertexOffset + index];
+		verticesA[i] = vert;
+		localCenter += vert;
+
+		triAabb.m_minVec = b3MinFloat4(triAabb.m_minVec, vert);
+		triAabb.m_maxVec = b3MaxFloat4(triAabb.m_maxVec, vert);
+	}
+
+	overlap = true;
+	overlap = (triAabb.m_minVec.x > aabbs[bodyIndexB].m_maxVec.x || triAabb.m_maxVec.x < aabbs[bodyIndexB].m_minVec.x) ? false : overlap;
+	overlap = (triAabb.m_minVec.z > aabbs[bodyIndexB].m_maxVec.z || triAabb.m_maxVec.z < aabbs[bodyIndexB].m_minVec.z) ? false : overlap;
+	overlap = (triAabb.m_minVec.y > aabbs[bodyIndexB].m_maxVec.y || triAabb.m_maxVec.y < aabbs[bodyIndexB].m_minVec.y) ? false : overlap;
+
+	if (overlap)
+	{
+		float dmin = FLT_MAX;
+		int hasSeparatingAxis = 5;
+		b3Float4 sepAxis = b3MakeFloat4(1, 2, 3, 4);
+
+		//	int localCC=0;
+		numActualConcaveConvexTests++;
+
+		//a triangle has 3 unique edges
+		convexPolyhedronA.m_numUniqueEdges = 3;
+		convexPolyhedronA.m_uniqueEdgesOffset = 0;
+		b3Float4 uniqueEdgesA[3];
+
+		uniqueEdgesA[0] = (verticesA[1] - verticesA[0]);
+		uniqueEdgesA[1] = (verticesA[2] - verticesA[1]);
+		uniqueEdgesA[2] = (verticesA[0] - verticesA[2]);
+
+		convexPolyhedronA.m_faceOffset = 0;
+
+		b3Float4 normal = b3MakeFloat4(face.m_plane.x, face.m_plane.y, face.m_plane.z, 0.f);
+
+		b3GpuFace facesA[B3_TRIANGLE_NUM_CONVEX_FACES];
+		int indicesA[3 + 3 + 2 + 2 + 2];
+		int curUsedIndices = 0;
+		int fidx = 0;
+
+		//front size of triangle
+		{
+			facesA[fidx].m_indexOffset = curUsedIndices;
+			indicesA[0] = 0;
+			indicesA[1] = 1;
+			indicesA[2] = 2;
+			curUsedIndices += 3;
+			float c = face.m_plane.w;
+			facesA[fidx].m_plane.x = normal.x;
+			facesA[fidx].m_plane.y = normal.y;
+			facesA[fidx].m_plane.z = normal.z;
+			facesA[fidx].m_plane.w = c;
+			facesA[fidx].m_numIndices = 3;
+		}
+		fidx++;
+		//back size of triangle
+		{
+			facesA[fidx].m_indexOffset = curUsedIndices;
+			indicesA[3] = 2;
+			indicesA[4] = 1;
+			indicesA[5] = 0;
+			curUsedIndices += 3;
+			float c = b3Dot(normal, verticesA[0]);
+			//	float c1 = -face.m_plane.w;
+			facesA[fidx].m_plane.x = -normal.x;
+			facesA[fidx].m_plane.y = -normal.y;
+			facesA[fidx].m_plane.z = -normal.z;
+			facesA[fidx].m_plane.w = c;
+			facesA[fidx].m_numIndices = 3;
+		}
+		fidx++;
+
+		bool addEdgePlanes = true;
+		if (addEdgePlanes)
+		{
+			int numVertices = 3;
+			int prevVertex = numVertices - 1;
+			for (int i = 0; i < numVertices; i++)
+			{
+				b3Float4 v0 = verticesA[i];
+				b3Float4 v1 = verticesA[prevVertex];
+
+				b3Float4 edgeNormal = b3Normalized(b3Cross(normal, v1 - v0));
+				float c = -b3Dot(edgeNormal, v0);
+
+				facesA[fidx].m_numIndices = 2;
+				facesA[fidx].m_indexOffset = curUsedIndices;
+				indicesA[curUsedIndices++] = i;
+				indicesA[curUsedIndices++] = prevVertex;
+
+				facesA[fidx].m_plane.x = edgeNormal.x;
+				facesA[fidx].m_plane.y = edgeNormal.y;
+				facesA[fidx].m_plane.z = edgeNormal.z;
+				facesA[fidx].m_plane.w = c;
+				fidx++;
+				prevVertex = i;
+			}
+		}
+		convexPolyhedronA.m_numFaces = B3_TRIANGLE_NUM_CONVEX_FACES;
+		convexPolyhedronA.m_localCenter = localCenter * (1.f / 3.f);
+
+		b3Float4 posA = rigidBodies[bodyIndexA].m_pos;
+		posA.w = 0.f;
+		b3Float4 posB = rigidBodies[bodyIndexB].m_pos;
+		posB.w = 0.f;
+
+		b3Quaternion ornA = rigidBodies[bodyIndexA].m_quat;
+		b3Quaternion ornB = rigidBodies[bodyIndexB].m_quat;
+
+		///////////////////
+		///compound shape support
+
+		if (collidables[collidableIndexB].m_shapeType == SHAPE_COMPOUND_OF_CONVEX_HULLS)
+		{
+			int compoundChild = concavePairs[pairIdx].w;
+			int childShapeIndexB = compoundChild;  //collidables[collidableIndexB].m_shapeIndex+compoundChild;
+			int childColIndexB = gpuChildShapes[childShapeIndexB].m_shapeIndex;
+			b3Float4 childPosB = gpuChildShapes[childShapeIndexB].m_childPosition;
+			b3Quaternion childOrnB = gpuChildShapes[childShapeIndexB].m_childOrientation;
+			b3Float4 newPosB = b3TransformPoint(childPosB, posB, ornB);
+			b3Quaternion newOrnB = b3QuatMul(ornB, childOrnB);
+			posB = newPosB;
+			ornB = newOrnB;
+			shapeIndexB = collidables[childColIndexB].m_shapeIndex;
+		}
+		//////////////////
+
+		b3Float4 c0local = convexPolyhedronA.m_localCenter;
+		b3Float4 c0 = b3TransformPoint(c0local, posA, ornA);
+		b3Float4 c1local = convexShapes[shapeIndexB].m_localCenter;
+		b3Float4 c1 = b3TransformPoint(c1local, posB, ornB);
+		const b3Float4 DeltaC2 = c0 - c1;
+
+		bool sepA = b3FindSeparatingAxis(&convexPolyhedronA, &convexShapes[shapeIndexB],
+										 posA, ornA,
+										 posB, ornB,
+										 DeltaC2,
+										 verticesA, uniqueEdgesA, facesA, indicesA,
+										 vertices, uniqueEdges, faces, indices,
+										 &sepAxis, &dmin);
+		hasSeparatingAxis = 4;
+		if (!sepA)
+		{
+			hasSeparatingAxis = 0;
+		}
+		else
+		{
+			bool sepB = b3FindSeparatingAxis(&convexShapes[shapeIndexB], &convexPolyhedronA,
+											 posB, ornB,
+											 posA, ornA,
+											 DeltaC2,
+											 vertices, uniqueEdges, faces, indices,
+											 verticesA, uniqueEdgesA, facesA, indicesA,
+											 &sepAxis, &dmin);
+
+			if (!sepB)
+			{
+				hasSeparatingAxis = 0;
+			}
+			else
+			{
+				bool sepEE = b3FindSeparatingAxisEdgeEdge(&convexPolyhedronA, &convexShapes[shapeIndexB],
+														  posA, ornA,
+														  posB, ornB,
+														  DeltaC2,
+														  verticesA, uniqueEdgesA, facesA, indicesA,
+														  vertices, uniqueEdges, faces, indices,
+														  &sepAxis, &dmin, true);
+
+				if (!sepEE)
+				{
+					hasSeparatingAxis = 0;
+				}
+				else
+				{
+					hasSeparatingAxis = 1;
+				}
+			}
+		}
+
+		if (hasSeparatingAxis)
+		{
+			hasSeparatingNormals[i] = 1;
+			sepAxis.w = dmin;
+			concaveSeparatingNormalsOut[pairIdx] = sepAxis;
+
+			//now compute clipping faces A and B, and world-space clipping vertices A and B...
+
+			float minDist = -1e30f;
+			float maxDist = 0.02f;
+
+			b3FindClippingFaces(sepAxis,
+								&convexPolyhedronA,
+								&convexShapes[shapeIndexB],
+								posA, ornA,
+								posB, ornB,
+								worldVertsA1Out,
+								worldNormalsA1Out,
+								worldVertsB1Out,
+								vertexFaceCapacity,
+								minDist, maxDist,
+								verticesA,
+								facesA,
+								indicesA,
+
+								vertices,
+								faces,
+								indices,
+								clippingFacesOut, pairIdx);
+		}
+		else
+		{
+			//mark this pair as in-active
+			concavePairs[pairIdx].w = -1;
+		}
+	}
+	else
+	{
+		//mark this pair as in-active
+		concavePairs[pairIdx].w = -1;
+	}
+}
+
+#endif  //B3_FIND_CONCAVE_SEPARATING_AXIS_H
diff --git a/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3FindSeparatingAxis.h b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3FindSeparatingAxis.h
new file mode 100644
index 00000000..b4981ae6
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3FindSeparatingAxis.h
@@ -0,0 +1,197 @@
+#ifndef B3_FIND_SEPARATING_AXIS_H
+#define B3_FIND_SEPARATING_AXIS_H
+
+inline void b3ProjectAxis(const b3ConvexPolyhedronData& hull, const b3Float4& pos, const b3Quaternion& orn, const b3Float4& dir, const b3AlignedObjectArray<b3Vector3>& vertices, b3Scalar& min, b3Scalar& max)
+{
+	min = FLT_MAX;
+	max = -FLT_MAX;
+	int numVerts = hull.m_numVertices;
+
+	const b3Float4 localDir = b3QuatRotate(orn.inverse(), dir);
+
+	b3Scalar offset = b3Dot3F4(pos, dir);
+
+	for (int i = 0; i < numVerts; i++)
+	{
+		//b3Vector3 pt = trans * vertices[m_vertexOffset+i];
+		//b3Scalar dp = pt.dot(dir);
+		//b3Vector3 vertex = vertices[hull.m_vertexOffset+i];
+		b3Scalar dp = b3Dot3F4((b3Float4&)vertices[hull.m_vertexOffset + i], localDir);
+		//b3Assert(dp==dpL);
+		if (dp < min) min = dp;
+		if (dp > max) max = dp;
+	}
+	if (min > max)
+	{
+		b3Scalar tmp = min;
+		min = max;
+		max = tmp;
+	}
+	min += offset;
+	max += offset;
+}
+
+inline bool b3TestSepAxis(const b3ConvexPolyhedronData& hullA, const b3ConvexPolyhedronData& hullB,
+						  const b3Float4& posA, const b3Quaternion& ornA,
+						  const b3Float4& posB, const b3Quaternion& ornB,
+						  const b3Float4& sep_axis, const b3AlignedObjectArray<b3Vector3>& verticesA, const b3AlignedObjectArray<b3Vector3>& verticesB, b3Scalar& depth)
+{
+	b3Scalar Min0, Max0;
+	b3Scalar Min1, Max1;
+	b3ProjectAxis(hullA, posA, ornA, sep_axis, verticesA, Min0, Max0);
+	b3ProjectAxis(hullB, posB, ornB, sep_axis, verticesB, Min1, Max1);
+
+	if (Max0 < Min1 || Max1 < Min0)
+		return false;
+
+	b3Scalar d0 = Max0 - Min1;
+	b3Assert(d0 >= 0.0f);
+	b3Scalar d1 = Max1 - Min0;
+	b3Assert(d1 >= 0.0f);
+	depth = d0 < d1 ? d0 : d1;
+	return true;
+}
+
+inline bool b3FindSeparatingAxis(const b3ConvexPolyhedronData& hullA, const b3ConvexPolyhedronData& hullB,
+								 const b3Float4& posA1,
+								 const b3Quaternion& ornA,
+								 const b3Float4& posB1,
+								 const b3Quaternion& ornB,
+								 const b3AlignedObjectArray<b3Vector3>& verticesA,
+								 const b3AlignedObjectArray<b3Vector3>& uniqueEdgesA,
+								 const b3AlignedObjectArray<b3GpuFace>& facesA,
+								 const b3AlignedObjectArray<int>& indicesA,
+								 const b3AlignedObjectArray<b3Vector3>& verticesB,
+								 const b3AlignedObjectArray<b3Vector3>& uniqueEdgesB,
+								 const b3AlignedObjectArray<b3GpuFace>& facesB,
+								 const b3AlignedObjectArray<int>& indicesB,
+
+								 b3Vector3& sep)
+{
+	B3_PROFILE("findSeparatingAxis");
+
+	b3Float4 posA = posA1;
+	posA.w = 0.f;
+	b3Float4 posB = posB1;
+	posB.w = 0.f;
+	//#ifdef TEST_INTERNAL_OBJECTS
+	b3Float4 c0local = (b3Float4&)hullA.m_localCenter;
+
+	b3Float4 c0 = b3TransformPoint(c0local, posA, ornA);
+	b3Float4 c1local = (b3Float4&)hullB.m_localCenter;
+	b3Float4 c1 = b3TransformPoint(c1local, posB, ornB);
+	const b3Float4 deltaC2 = c0 - c1;
+	//#endif
+
+	b3Scalar dmin = FLT_MAX;
+	int curPlaneTests = 0;
+
+	int numFacesA = hullA.m_numFaces;
+	// Test normals from hullA
+	for (int i = 0; i < numFacesA; i++)
+	{
+		const b3Float4& normal = (b3Float4&)facesA[hullA.m_faceOffset + i].m_plane;
+		b3Float4 faceANormalWS = b3QuatRotate(ornA, normal);
+
+		if (b3Dot3F4(deltaC2, faceANormalWS) < 0)
+			faceANormalWS *= -1.f;
+
+		curPlaneTests++;
+#ifdef TEST_INTERNAL_OBJECTS
+		gExpectedNbTests++;
+		if (gUseInternalObject && !TestInternalObjects(transA, transB, DeltaC2, faceANormalWS, hullA, hullB, dmin))
+			continue;
+		gActualNbTests++;
+#endif
+
+		b3Scalar d;
+		if (!b3TestSepAxis(hullA, hullB, posA, ornA, posB, ornB, faceANormalWS, verticesA, verticesB, d))
+			return false;
+
+		if (d < dmin)
+		{
+			dmin = d;
+			sep = (b3Vector3&)faceANormalWS;
+		}
+	}
+
+	int numFacesB = hullB.m_numFaces;
+	// Test normals from hullB
+	for (int i = 0; i < numFacesB; i++)
+	{
+		b3Float4 normal = (b3Float4&)facesB[hullB.m_faceOffset + i].m_plane;
+		b3Float4 WorldNormal = b3QuatRotate(ornB, normal);
+
+		if (b3Dot3F4(deltaC2, WorldNormal) < 0)
+		{
+			WorldNormal *= -1.f;
+		}
+		curPlaneTests++;
+#ifdef TEST_INTERNAL_OBJECTS
+		gExpectedNbTests++;
+		if (gUseInternalObject && !TestInternalObjects(transA, transB, DeltaC2, WorldNormal, hullA, hullB, dmin))
+			continue;
+		gActualNbTests++;
+#endif
+
+		b3Scalar d;
+		if (!b3TestSepAxis(hullA, hullB, posA, ornA, posB, ornB, WorldNormal, verticesA, verticesB, d))
+			return false;
+
+		if (d < dmin)
+		{
+			dmin = d;
+			sep = (b3Vector3&)WorldNormal;
+		}
+	}
+
+	//	b3Vector3 edgeAstart,edgeAend,edgeBstart,edgeBend;
+
+	int curEdgeEdge = 0;
+	// Test edges
+	for (int e0 = 0; e0 < hullA.m_numUniqueEdges; e0++)
+	{
+		const b3Float4& edge0 = (b3Float4&)uniqueEdgesA[hullA.m_uniqueEdgesOffset + e0];
+		b3Float4 edge0World = b3QuatRotate(ornA, (b3Float4&)edge0);
+
+		for (int e1 = 0; e1 < hullB.m_numUniqueEdges; e1++)
+		{
+			const b3Vector3 edge1 = uniqueEdgesB[hullB.m_uniqueEdgesOffset + e1];
+			b3Float4 edge1World = b3QuatRotate(ornB, (b3Float4&)edge1);
+
+			b3Float4 crossje = b3Cross3(edge0World, edge1World);
+
+			curEdgeEdge++;
+			if (!b3IsAlmostZero((b3Vector3&)crossje))
+			{
+				crossje = b3FastNormalized3(crossje);
+				if (b3Dot3F4(deltaC2, crossje) < 0)
+					crossje *= -1.f;
+
+#ifdef TEST_INTERNAL_OBJECTS
+				gExpectedNbTests++;
+				if (gUseInternalObject && !TestInternalObjects(transA, transB, DeltaC2, Cross, hullA, hullB, dmin))
+					continue;
+				gActualNbTests++;
+#endif
+
+				b3Scalar dist;
+				if (!b3TestSepAxis(hullA, hullB, posA, ornA, posB, ornB, crossje, verticesA, verticesB, dist))
+					return false;
+
+				if (dist < dmin)
+				{
+					dmin = dist;
+					sep = (b3Vector3&)crossje;
+				}
+			}
+		}
+	}
+
+	if ((b3Dot3F4(-deltaC2, (b3Float4&)sep)) > 0.0f)
+		sep = -sep;
+
+	return true;
+}
+
+#endif  //B3_FIND_SEPARATING_AXIS_H
diff --git a/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3MprPenetration.h b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3MprPenetration.h
new file mode 100644
index 00000000..a3bfbf29
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3MprPenetration.h
@@ -0,0 +1,888 @@
+
+/***
+ * ---------------------------------
+ * Copyright (c)2012 Daniel Fiser <danfis@danfis.cz>
+ *
+ *  This file was ported from mpr.c file, part of libccd.
+ *  The Minkoski Portal Refinement implementation was ported 
+ *  to OpenCL by Erwin Coumans for the Bullet 3 Physics library.
+ *  at http://github.com/erwincoumans/bullet3
+ *
+ *  Distributed under the OSI-approved BSD License (the "License");
+ *  see <http://www.opensource.org/licenses/bsd-license.php>.
+ *  This software is distributed WITHOUT ANY WARRANTY; without even the
+ *  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *  See the License for more information.
+ */
+
+#ifndef B3_MPR_PENETRATION_H
+#define B3_MPR_PENETRATION_H
+
+#include "Bullet3Common/shared/b3PlatformDefinitions.h"
+#include "Bullet3Common/shared/b3Float4.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3ConvexPolyhedronData.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h"
+
+#ifdef __cplusplus
+#define B3_MPR_SQRT sqrtf
+#else
+#define B3_MPR_SQRT sqrt
+#endif
+#define B3_MPR_FMIN(x, y) ((x) < (y) ? (x) : (y))
+#define B3_MPR_FABS fabs
+
+#define B3_MPR_TOLERANCE 1E-6f
+#define B3_MPR_MAX_ITERATIONS 1000
+
+struct _b3MprSupport_t
+{
+	b3Float4 v;   //!< Support point in minkowski sum
+	b3Float4 v1;  //!< Support point in obj1
+	b3Float4 v2;  //!< Support point in obj2
+};
+typedef struct _b3MprSupport_t b3MprSupport_t;
+
+struct _b3MprSimplex_t
+{
+	b3MprSupport_t ps[4];
+	int last;  //!< index of last added point
+};
+typedef struct _b3MprSimplex_t b3MprSimplex_t;
+
+inline b3MprSupport_t *b3MprSimplexPointW(b3MprSimplex_t *s, int idx)
+{
+	return &s->ps[idx];
+}
+
+inline void b3MprSimplexSetSize(b3MprSimplex_t *s, int size)
+{
+	s->last = size - 1;
+}
+
+inline int b3MprSimplexSize(const b3MprSimplex_t *s)
+{
+	return s->last + 1;
+}
+
+inline const b3MprSupport_t *b3MprSimplexPoint(const b3MprSimplex_t *s, int idx)
+{
+	// here is no check on boundaries
+	return &s->ps[idx];
+}
+
+inline void b3MprSupportCopy(b3MprSupport_t *d, const b3MprSupport_t *s)
+{
+	*d = *s;
+}
+
+inline void b3MprSimplexSet(b3MprSimplex_t *s, size_t pos, const b3MprSupport_t *a)
+{
+	b3MprSupportCopy(s->ps + pos, a);
+}
+
+inline void b3MprSimplexSwap(b3MprSimplex_t *s, size_t pos1, size_t pos2)
+{
+	b3MprSupport_t supp;
+
+	b3MprSupportCopy(&supp, &s->ps[pos1]);
+	b3MprSupportCopy(&s->ps[pos1], &s->ps[pos2]);
+	b3MprSupportCopy(&s->ps[pos2], &supp);
+}
+
+inline int b3MprIsZero(float val)
+{
+	return B3_MPR_FABS(val) < FLT_EPSILON;
+}
+
+inline int b3MprEq(float _a, float _b)
+{
+	float ab;
+	float a, b;
+
+	ab = B3_MPR_FABS(_a - _b);
+	if (B3_MPR_FABS(ab) < FLT_EPSILON)
+		return 1;
+
+	a = B3_MPR_FABS(_a);
+	b = B3_MPR_FABS(_b);
+	if (b > a)
+	{
+		return ab < FLT_EPSILON * b;
+	}
+	else
+	{
+		return ab < FLT_EPSILON * a;
+	}
+}
+
+inline int b3MprVec3Eq(const b3Float4 *a, const b3Float4 *b)
+{
+	return b3MprEq((*a).x, (*b).x) && b3MprEq((*a).y, (*b).y) && b3MprEq((*a).z, (*b).z);
+}
+
+inline b3Float4 b3LocalGetSupportVertex(b3Float4ConstArg supportVec, __global const b3ConvexPolyhedronData_t *hull, b3ConstArray(b3Float4) verticesA)
+{
+	b3Float4 supVec = b3MakeFloat4(0, 0, 0, 0);
+	float maxDot = -B3_LARGE_FLOAT;
+
+	if (0 < hull->m_numVertices)
+	{
+		const b3Float4 scaled = supportVec;
+		int index = b3MaxDot(scaled, &verticesA[hull->m_vertexOffset], hull->m_numVertices, &maxDot);
+		return verticesA[hull->m_vertexOffset + index];
+	}
+
+	return supVec;
+}
+
+B3_STATIC void b3MprConvexSupport(int pairIndex, int bodyIndex, b3ConstArray(b3RigidBodyData_t) cpuBodyBuf,
+								  b3ConstArray(b3ConvexPolyhedronData_t) cpuConvexData,
+								  b3ConstArray(b3Collidable_t) cpuCollidables,
+								  b3ConstArray(b3Float4) cpuVertices,
+								  __global b3Float4 *sepAxis,
+								  const b3Float4 *_dir, b3Float4 *outp, int logme)
+{
+	//dir is in worldspace, move to local space
+
+	b3Float4 pos = cpuBodyBuf[bodyIndex].m_pos;
+	b3Quat orn = cpuBodyBuf[bodyIndex].m_quat;
+
+	b3Float4 dir = b3MakeFloat4((*_dir).x, (*_dir).y, (*_dir).z, 0.f);
+
+	const b3Float4 localDir = b3QuatRotate(b3QuatInverse(orn), dir);
+
+	//find local support vertex
+	int colIndex = cpuBodyBuf[bodyIndex].m_collidableIdx;
+
+	b3Assert(cpuCollidables[colIndex].m_shapeType == SHAPE_CONVEX_HULL);
+	__global const b3ConvexPolyhedronData_t *hull = &cpuConvexData[cpuCollidables[colIndex].m_shapeIndex];
+
+	b3Float4 pInA;
+	if (logme)
+	{
+		//	b3Float4 supVec = b3MakeFloat4(0,0,0,0);
+		float maxDot = -B3_LARGE_FLOAT;
+
+		if (0 < hull->m_numVertices)
+		{
+			const b3Float4 scaled = localDir;
+			int index = b3MaxDot(scaled, &cpuVertices[hull->m_vertexOffset], hull->m_numVertices, &maxDot);
+			pInA = cpuVertices[hull->m_vertexOffset + index];
+		}
+	}
+	else
+	{
+		pInA = b3LocalGetSupportVertex(localDir, hull, cpuVertices);
+	}
+
+	//move vertex to world space
+	*outp = b3TransformPoint(pInA, pos, orn);
+}
+
+inline void b3MprSupport(int pairIndex, int bodyIndexA, int bodyIndexB, b3ConstArray(b3RigidBodyData_t) cpuBodyBuf,
+						 b3ConstArray(b3ConvexPolyhedronData_t) cpuConvexData,
+						 b3ConstArray(b3Collidable_t) cpuCollidables,
+						 b3ConstArray(b3Float4) cpuVertices,
+						 __global b3Float4 *sepAxis,
+						 const b3Float4 *_dir, b3MprSupport_t *supp)
+{
+	b3Float4 dir;
+	dir = *_dir;
+	b3MprConvexSupport(pairIndex, bodyIndexA, cpuBodyBuf, cpuConvexData, cpuCollidables, cpuVertices, sepAxis, &dir, &supp->v1, 0);
+	dir = *_dir * -1.f;
+	b3MprConvexSupport(pairIndex, bodyIndexB, cpuBodyBuf, cpuConvexData, cpuCollidables, cpuVertices, sepAxis, &dir, &supp->v2, 0);
+	supp->v = supp->v1 - supp->v2;
+}
+
+inline void b3FindOrigin(int bodyIndexA, int bodyIndexB, b3ConstArray(b3RigidBodyData_t) cpuBodyBuf, b3MprSupport_t *center)
+{
+	center->v1 = cpuBodyBuf[bodyIndexA].m_pos;
+	center->v2 = cpuBodyBuf[bodyIndexB].m_pos;
+	center->v = center->v1 - center->v2;
+}
+
+inline void b3MprVec3Set(b3Float4 *v, float x, float y, float z)
+{
+	(*v).x = x;
+	(*v).y = y;
+	(*v).z = z;
+	(*v).w = 0.f;
+}
+
+inline void b3MprVec3Add(b3Float4 *v, const b3Float4 *w)
+{
+	(*v).x += (*w).x;
+	(*v).y += (*w).y;
+	(*v).z += (*w).z;
+}
+
+inline void b3MprVec3Copy(b3Float4 *v, const b3Float4 *w)
+{
+	*v = *w;
+}
+
+inline void b3MprVec3Scale(b3Float4 *d, float k)
+{
+	*d *= k;
+}
+
+inline float b3MprVec3Dot(const b3Float4 *a, const b3Float4 *b)
+{
+	float dot;
+
+	dot = b3Dot3F4(*a, *b);
+	return dot;
+}
+
+inline float b3MprVec3Len2(const b3Float4 *v)
+{
+	return b3MprVec3Dot(v, v);
+}
+
+inline void b3MprVec3Normalize(b3Float4 *d)
+{
+	float k = 1.f / B3_MPR_SQRT(b3MprVec3Len2(d));
+	b3MprVec3Scale(d, k);
+}
+
+inline void b3MprVec3Cross(b3Float4 *d, const b3Float4 *a, const b3Float4 *b)
+{
+	*d = b3Cross3(*a, *b);
+}
+
+inline void b3MprVec3Sub2(b3Float4 *d, const b3Float4 *v, const b3Float4 *w)
+{
+	*d = *v - *w;
+}
+
+inline void b3PortalDir(const b3MprSimplex_t *portal, b3Float4 *dir)
+{
+	b3Float4 v2v1, v3v1;
+
+	b3MprVec3Sub2(&v2v1, &b3MprSimplexPoint(portal, 2)->v,
+				  &b3MprSimplexPoint(portal, 1)->v);
+	b3MprVec3Sub2(&v3v1, &b3MprSimplexPoint(portal, 3)->v,
+				  &b3MprSimplexPoint(portal, 1)->v);
+	b3MprVec3Cross(dir, &v2v1, &v3v1);
+	b3MprVec3Normalize(dir);
+}
+
+inline int portalEncapsulesOrigin(const b3MprSimplex_t *portal,
+								  const b3Float4 *dir)
+{
+	float dot;
+	dot = b3MprVec3Dot(dir, &b3MprSimplexPoint(portal, 1)->v);
+	return b3MprIsZero(dot) || dot > 0.f;
+}
+
+inline int portalReachTolerance(const b3MprSimplex_t *portal,
+								const b3MprSupport_t *v4,
+								const b3Float4 *dir)
+{
+	float dv1, dv2, dv3, dv4;
+	float dot1, dot2, dot3;
+
+	// find the smallest dot product of dir and {v1-v4, v2-v4, v3-v4}
+
+	dv1 = b3MprVec3Dot(&b3MprSimplexPoint(portal, 1)->v, dir);
+	dv2 = b3MprVec3Dot(&b3MprSimplexPoint(portal, 2)->v, dir);
+	dv3 = b3MprVec3Dot(&b3MprSimplexPoint(portal, 3)->v, dir);
+	dv4 = b3MprVec3Dot(&v4->v, dir);
+
+	dot1 = dv4 - dv1;
+	dot2 = dv4 - dv2;
+	dot3 = dv4 - dv3;
+
+	dot1 = B3_MPR_FMIN(dot1, dot2);
+	dot1 = B3_MPR_FMIN(dot1, dot3);
+
+	return b3MprEq(dot1, B3_MPR_TOLERANCE) || dot1 < B3_MPR_TOLERANCE;
+}
+
+inline int portalCanEncapsuleOrigin(const b3MprSimplex_t *portal,
+									const b3MprSupport_t *v4,
+									const b3Float4 *dir)
+{
+	float dot;
+	dot = b3MprVec3Dot(&v4->v, dir);
+	return b3MprIsZero(dot) || dot > 0.f;
+}
+
+inline void b3ExpandPortal(b3MprSimplex_t *portal,
+						   const b3MprSupport_t *v4)
+{
+	float dot;
+	b3Float4 v4v0;
+
+	b3MprVec3Cross(&v4v0, &v4->v, &b3MprSimplexPoint(portal, 0)->v);
+	dot = b3MprVec3Dot(&b3MprSimplexPoint(portal, 1)->v, &v4v0);
+	if (dot > 0.f)
+	{
+		dot = b3MprVec3Dot(&b3MprSimplexPoint(portal, 2)->v, &v4v0);
+		if (dot > 0.f)
+		{
+			b3MprSimplexSet(portal, 1, v4);
+		}
+		else
+		{
+			b3MprSimplexSet(portal, 3, v4);
+		}
+	}
+	else
+	{
+		dot = b3MprVec3Dot(&b3MprSimplexPoint(portal, 3)->v, &v4v0);
+		if (dot > 0.f)
+		{
+			b3MprSimplexSet(portal, 2, v4);
+		}
+		else
+		{
+			b3MprSimplexSet(portal, 1, v4);
+		}
+	}
+}
+
+B3_STATIC int b3DiscoverPortal(int pairIndex, int bodyIndexA, int bodyIndexB, b3ConstArray(b3RigidBodyData_t) cpuBodyBuf,
+							   b3ConstArray(b3ConvexPolyhedronData_t) cpuConvexData,
+							   b3ConstArray(b3Collidable_t) cpuCollidables,
+							   b3ConstArray(b3Float4) cpuVertices,
+							   __global b3Float4 *sepAxis,
+							   __global int *hasSepAxis,
+							   b3MprSimplex_t *portal)
+{
+	b3Float4 dir, va, vb;
+	float dot;
+	int cont;
+
+	// vertex 0 is center of portal
+	b3FindOrigin(bodyIndexA, bodyIndexB, cpuBodyBuf, b3MprSimplexPointW(portal, 0));
+	// vertex 0 is center of portal
+	b3MprSimplexSetSize(portal, 1);
+
+	b3Float4 zero = b3MakeFloat4(0, 0, 0, 0);
+	b3Float4 *b3mpr_vec3_origin = &zero;
+
+	if (b3MprVec3Eq(&b3MprSimplexPoint(portal, 0)->v, b3mpr_vec3_origin))
+	{
+		// Portal's center lies on origin (0,0,0) => we know that objects
+		// intersect but we would need to know penetration info.
+		// So move center little bit...
+		b3MprVec3Set(&va, FLT_EPSILON * 10.f, 0.f, 0.f);
+		b3MprVec3Add(&b3MprSimplexPointW(portal, 0)->v, &va);
+	}
+
+	// vertex 1 = support in direction of origin
+	b3MprVec3Copy(&dir, &b3MprSimplexPoint(portal, 0)->v);
+	b3MprVec3Scale(&dir, -1.f);
+	b3MprVec3Normalize(&dir);
+
+	b3MprSupport(pairIndex, bodyIndexA, bodyIndexB, cpuBodyBuf, cpuConvexData, cpuCollidables, cpuVertices, sepAxis, &dir, b3MprSimplexPointW(portal, 1));
+
+	b3MprSimplexSetSize(portal, 2);
+
+	// test if origin isn't outside of v1
+	dot = b3MprVec3Dot(&b3MprSimplexPoint(portal, 1)->v, &dir);
+
+	if (b3MprIsZero(dot) || dot < 0.f)
+		return -1;
+
+	// vertex 2
+	b3MprVec3Cross(&dir, &b3MprSimplexPoint(portal, 0)->v,
+				   &b3MprSimplexPoint(portal, 1)->v);
+	if (b3MprIsZero(b3MprVec3Len2(&dir)))
+	{
+		if (b3MprVec3Eq(&b3MprSimplexPoint(portal, 1)->v, b3mpr_vec3_origin))
+		{
+			// origin lies on v1
+			return 1;
+		}
+		else
+		{
+			// origin lies on v0-v1 segment
+			return 2;
+		}
+	}
+
+	b3MprVec3Normalize(&dir);
+	b3MprSupport(pairIndex, bodyIndexA, bodyIndexB, cpuBodyBuf, cpuConvexData, cpuCollidables, cpuVertices, sepAxis, &dir, b3MprSimplexPointW(portal, 2));
+
+	dot = b3MprVec3Dot(&b3MprSimplexPoint(portal, 2)->v, &dir);
+	if (b3MprIsZero(dot) || dot < 0.f)
+		return -1;
+
+	b3MprSimplexSetSize(portal, 3);
+
+	// vertex 3 direction
+	b3MprVec3Sub2(&va, &b3MprSimplexPoint(portal, 1)->v,
+				  &b3MprSimplexPoint(portal, 0)->v);
+	b3MprVec3Sub2(&vb, &b3MprSimplexPoint(portal, 2)->v,
+				  &b3MprSimplexPoint(portal, 0)->v);
+	b3MprVec3Cross(&dir, &va, &vb);
+	b3MprVec3Normalize(&dir);
+
+	// it is better to form portal faces to be oriented "outside" origin
+	dot = b3MprVec3Dot(&dir, &b3MprSimplexPoint(portal, 0)->v);
+	if (dot > 0.f)
+	{
+		b3MprSimplexSwap(portal, 1, 2);
+		b3MprVec3Scale(&dir, -1.f);
+	}
+
+	while (b3MprSimplexSize(portal) < 4)
+	{
+		b3MprSupport(pairIndex, bodyIndexA, bodyIndexB, cpuBodyBuf, cpuConvexData, cpuCollidables, cpuVertices, sepAxis, &dir, b3MprSimplexPointW(portal, 3));
+
+		dot = b3MprVec3Dot(&b3MprSimplexPoint(portal, 3)->v, &dir);
+		if (b3MprIsZero(dot) || dot < 0.f)
+			return -1;
+
+		cont = 0;
+
+		// test if origin is outside (v1, v0, v3) - set v2 as v3 and
+		// continue
+		b3MprVec3Cross(&va, &b3MprSimplexPoint(portal, 1)->v,
+					   &b3MprSimplexPoint(portal, 3)->v);
+		dot = b3MprVec3Dot(&va, &b3MprSimplexPoint(portal, 0)->v);
+		if (dot < 0.f && !b3MprIsZero(dot))
+		{
+			b3MprSimplexSet(portal, 2, b3MprSimplexPoint(portal, 3));
+			cont = 1;
+		}
+
+		if (!cont)
+		{
+			// test if origin is outside (v3, v0, v2) - set v1 as v3 and
+			// continue
+			b3MprVec3Cross(&va, &b3MprSimplexPoint(portal, 3)->v,
+						   &b3MprSimplexPoint(portal, 2)->v);
+			dot = b3MprVec3Dot(&va, &b3MprSimplexPoint(portal, 0)->v);
+			if (dot < 0.f && !b3MprIsZero(dot))
+			{
+				b3MprSimplexSet(portal, 1, b3MprSimplexPoint(portal, 3));
+				cont = 1;
+			}
+		}
+
+		if (cont)
+		{
+			b3MprVec3Sub2(&va, &b3MprSimplexPoint(portal, 1)->v,
+						  &b3MprSimplexPoint(portal, 0)->v);
+			b3MprVec3Sub2(&vb, &b3MprSimplexPoint(portal, 2)->v,
+						  &b3MprSimplexPoint(portal, 0)->v);
+			b3MprVec3Cross(&dir, &va, &vb);
+			b3MprVec3Normalize(&dir);
+		}
+		else
+		{
+			b3MprSimplexSetSize(portal, 4);
+		}
+	}
+
+	return 0;
+}
+
+B3_STATIC int b3RefinePortal(int pairIndex, int bodyIndexA, int bodyIndexB, b3ConstArray(b3RigidBodyData_t) cpuBodyBuf,
+							 b3ConstArray(b3ConvexPolyhedronData_t) cpuConvexData,
+							 b3ConstArray(b3Collidable_t) cpuCollidables,
+							 b3ConstArray(b3Float4) cpuVertices,
+							 __global b3Float4 *sepAxis,
+							 b3MprSimplex_t *portal)
+{
+	b3Float4 dir;
+	b3MprSupport_t v4;
+
+	for (int i = 0; i < B3_MPR_MAX_ITERATIONS; i++)
+	//while (1)
+	{
+		// compute direction outside the portal (from v0 throught v1,v2,v3
+		// face)
+		b3PortalDir(portal, &dir);
+
+		// test if origin is inside the portal
+		if (portalEncapsulesOrigin(portal, &dir))
+			return 0;
+
+		// get next support point
+
+		b3MprSupport(pairIndex, bodyIndexA, bodyIndexB, cpuBodyBuf, cpuConvexData, cpuCollidables, cpuVertices, sepAxis, &dir, &v4);
+
+		// test if v4 can expand portal to contain origin and if portal
+		// expanding doesn't reach given tolerance
+		if (!portalCanEncapsuleOrigin(portal, &v4, &dir) || portalReachTolerance(portal, &v4, &dir))
+		{
+			return -1;
+		}
+
+		// v1-v2-v3 triangle must be rearranged to face outside Minkowski
+		// difference (direction from v0).
+		b3ExpandPortal(portal, &v4);
+	}
+
+	return -1;
+}
+
+B3_STATIC void b3FindPos(const b3MprSimplex_t *portal, b3Float4 *pos)
+{
+	b3Float4 zero = b3MakeFloat4(0, 0, 0, 0);
+	b3Float4 *b3mpr_vec3_origin = &zero;
+
+	b3Float4 dir;
+	size_t i;
+	float b[4], sum, inv;
+	b3Float4 vec, p1, p2;
+
+	b3PortalDir(portal, &dir);
+
+	// use barycentric coordinates of tetrahedron to find origin
+	b3MprVec3Cross(&vec, &b3MprSimplexPoint(portal, 1)->v,
+				   &b3MprSimplexPoint(portal, 2)->v);
+	b[0] = b3MprVec3Dot(&vec, &b3MprSimplexPoint(portal, 3)->v);
+
+	b3MprVec3Cross(&vec, &b3MprSimplexPoint(portal, 3)->v,
+				   &b3MprSimplexPoint(portal, 2)->v);
+	b[1] = b3MprVec3Dot(&vec, &b3MprSimplexPoint(portal, 0)->v);
+
+	b3MprVec3Cross(&vec, &b3MprSimplexPoint(portal, 0)->v,
+				   &b3MprSimplexPoint(portal, 1)->v);
+	b[2] = b3MprVec3Dot(&vec, &b3MprSimplexPoint(portal, 3)->v);
+
+	b3MprVec3Cross(&vec, &b3MprSimplexPoint(portal, 2)->v,
+				   &b3MprSimplexPoint(portal, 1)->v);
+	b[3] = b3MprVec3Dot(&vec, &b3MprSimplexPoint(portal, 0)->v);
+
+	sum = b[0] + b[1] + b[2] + b[3];
+
+	if (b3MprIsZero(sum) || sum < 0.f)
+	{
+		b[0] = 0.f;
+
+		b3MprVec3Cross(&vec, &b3MprSimplexPoint(portal, 2)->v,
+					   &b3MprSimplexPoint(portal, 3)->v);
+		b[1] = b3MprVec3Dot(&vec, &dir);
+		b3MprVec3Cross(&vec, &b3MprSimplexPoint(portal, 3)->v,
+					   &b3MprSimplexPoint(portal, 1)->v);
+		b[2] = b3MprVec3Dot(&vec, &dir);
+		b3MprVec3Cross(&vec, &b3MprSimplexPoint(portal, 1)->v,
+					   &b3MprSimplexPoint(portal, 2)->v);
+		b[3] = b3MprVec3Dot(&vec, &dir);
+
+		sum = b[1] + b[2] + b[3];
+	}
+
+	inv = 1.f / sum;
+
+	b3MprVec3Copy(&p1, b3mpr_vec3_origin);
+	b3MprVec3Copy(&p2, b3mpr_vec3_origin);
+	for (i = 0; i < 4; i++)
+	{
+		b3MprVec3Copy(&vec, &b3MprSimplexPoint(portal, i)->v1);
+		b3MprVec3Scale(&vec, b[i]);
+		b3MprVec3Add(&p1, &vec);
+
+		b3MprVec3Copy(&vec, &b3MprSimplexPoint(portal, i)->v2);
+		b3MprVec3Scale(&vec, b[i]);
+		b3MprVec3Add(&p2, &vec);
+	}
+	b3MprVec3Scale(&p1, inv);
+	b3MprVec3Scale(&p2, inv);
+
+	b3MprVec3Copy(pos, &p1);
+	b3MprVec3Add(pos, &p2);
+	b3MprVec3Scale(pos, 0.5);
+}
+
+inline float b3MprVec3Dist2(const b3Float4 *a, const b3Float4 *b)
+{
+	b3Float4 ab;
+	b3MprVec3Sub2(&ab, a, b);
+	return b3MprVec3Len2(&ab);
+}
+
+inline float _b3MprVec3PointSegmentDist2(const b3Float4 *P,
+										 const b3Float4 *x0,
+										 const b3Float4 *b,
+										 b3Float4 *witness)
+{
+	// The computation comes from solving equation of segment:
+	//      S(t) = x0 + t.d
+	//          where - x0 is initial point of segment
+	//                - d is direction of segment from x0 (|d| > 0)
+	//                - t belongs to <0, 1> interval
+	//
+	// Than, distance from a segment to some point P can be expressed:
+	//      D(t) = |x0 + t.d - P|^2
+	//          which is distance from any point on segment. Minimization
+	//          of this function brings distance from P to segment.
+	// Minimization of D(t) leads to simple quadratic equation that's
+	// solving is straightforward.
+	//
+	// Bonus of this method is witness point for free.
+
+	float dist, t;
+	b3Float4 d, a;
+
+	// direction of segment
+	b3MprVec3Sub2(&d, b, x0);
+
+	// precompute vector from P to x0
+	b3MprVec3Sub2(&a, x0, P);
+
+	t = -1.f * b3MprVec3Dot(&a, &d);
+	t /= b3MprVec3Len2(&d);
+
+	if (t < 0.f || b3MprIsZero(t))
+	{
+		dist = b3MprVec3Dist2(x0, P);
+		if (witness)
+			b3MprVec3Copy(witness, x0);
+	}
+	else if (t > 1.f || b3MprEq(t, 1.f))
+	{
+		dist = b3MprVec3Dist2(b, P);
+		if (witness)
+			b3MprVec3Copy(witness, b);
+	}
+	else
+	{
+		if (witness)
+		{
+			b3MprVec3Copy(witness, &d);
+			b3MprVec3Scale(witness, t);
+			b3MprVec3Add(witness, x0);
+			dist = b3MprVec3Dist2(witness, P);
+		}
+		else
+		{
+			// recycling variables
+			b3MprVec3Scale(&d, t);
+			b3MprVec3Add(&d, &a);
+			dist = b3MprVec3Len2(&d);
+		}
+	}
+
+	return dist;
+}
+
+inline float b3MprVec3PointTriDist2(const b3Float4 *P,
+									const b3Float4 *x0, const b3Float4 *B,
+									const b3Float4 *C,
+									b3Float4 *witness)
+{
+	// Computation comes from analytic expression for triangle (x0, B, C)
+	//      T(s, t) = x0 + s.d1 + t.d2, where d1 = B - x0 and d2 = C - x0 and
+	// Then equation for distance is:
+	//      D(s, t) = | T(s, t) - P |^2
+	// This leads to minimization of quadratic function of two variables.
+	// The solution from is taken only if s is between 0 and 1, t is
+	// between 0 and 1 and t + s < 1, otherwise distance from segment is
+	// computed.
+
+	b3Float4 d1, d2, a;
+	float u, v, w, p, q, r;
+	float s, t, dist, dist2;
+	b3Float4 witness2;
+
+	b3MprVec3Sub2(&d1, B, x0);
+	b3MprVec3Sub2(&d2, C, x0);
+	b3MprVec3Sub2(&a, x0, P);
+
+	u = b3MprVec3Dot(&a, &a);
+	v = b3MprVec3Dot(&d1, &d1);
+	w = b3MprVec3Dot(&d2, &d2);
+	p = b3MprVec3Dot(&a, &d1);
+	q = b3MprVec3Dot(&a, &d2);
+	r = b3MprVec3Dot(&d1, &d2);
+
+	s = (q * r - w * p) / (w * v - r * r);
+	t = (-s * r - q) / w;
+
+	if ((b3MprIsZero(s) || s > 0.f) && (b3MprEq(s, 1.f) || s < 1.f) && (b3MprIsZero(t) || t > 0.f) && (b3MprEq(t, 1.f) || t < 1.f) && (b3MprEq(t + s, 1.f) || t + s < 1.f))
+	{
+		if (witness)
+		{
+			b3MprVec3Scale(&d1, s);
+			b3MprVec3Scale(&d2, t);
+			b3MprVec3Copy(witness, x0);
+			b3MprVec3Add(witness, &d1);
+			b3MprVec3Add(witness, &d2);
+
+			dist = b3MprVec3Dist2(witness, P);
+		}
+		else
+		{
+			dist = s * s * v;
+			dist += t * t * w;
+			dist += 2.f * s * t * r;
+			dist += 2.f * s * p;
+			dist += 2.f * t * q;
+			dist += u;
+		}
+	}
+	else
+	{
+		dist = _b3MprVec3PointSegmentDist2(P, x0, B, witness);
+
+		dist2 = _b3MprVec3PointSegmentDist2(P, x0, C, &witness2);
+		if (dist2 < dist)
+		{
+			dist = dist2;
+			if (witness)
+				b3MprVec3Copy(witness, &witness2);
+		}
+
+		dist2 = _b3MprVec3PointSegmentDist2(P, B, C, &witness2);
+		if (dist2 < dist)
+		{
+			dist = dist2;
+			if (witness)
+				b3MprVec3Copy(witness, &witness2);
+		}
+	}
+
+	return dist;
+}
+
+B3_STATIC void b3FindPenetr(int pairIndex, int bodyIndexA, int bodyIndexB, b3ConstArray(b3RigidBodyData_t) cpuBodyBuf,
+							b3ConstArray(b3ConvexPolyhedronData_t) cpuConvexData,
+							b3ConstArray(b3Collidable_t) cpuCollidables,
+							b3ConstArray(b3Float4) cpuVertices,
+							__global b3Float4 *sepAxis,
+							b3MprSimplex_t *portal,
+							float *depth, b3Float4 *pdir, b3Float4 *pos)
+{
+	b3Float4 dir;
+	b3MprSupport_t v4;
+	unsigned long iterations;
+
+	b3Float4 zero = b3MakeFloat4(0, 0, 0, 0);
+	b3Float4 *b3mpr_vec3_origin = &zero;
+
+	iterations = 1UL;
+	for (int i = 0; i < B3_MPR_MAX_ITERATIONS; i++)
+	//while (1)
+	{
+		// compute portal direction and obtain next support point
+		b3PortalDir(portal, &dir);
+
+		b3MprSupport(pairIndex, bodyIndexA, bodyIndexB, cpuBodyBuf, cpuConvexData, cpuCollidables, cpuVertices, sepAxis, &dir, &v4);
+
+		// reached tolerance -> find penetration info
+		if (portalReachTolerance(portal, &v4, &dir) || iterations == B3_MPR_MAX_ITERATIONS)
+		{
+			*depth = b3MprVec3PointTriDist2(b3mpr_vec3_origin, &b3MprSimplexPoint(portal, 1)->v, &b3MprSimplexPoint(portal, 2)->v, &b3MprSimplexPoint(portal, 3)->v, pdir);
+			*depth = B3_MPR_SQRT(*depth);
+
+			if (b3MprIsZero((*pdir).x) && b3MprIsZero((*pdir).y) && b3MprIsZero((*pdir).z))
+			{
+				*pdir = dir;
+			}
+			b3MprVec3Normalize(pdir);
+
+			// barycentric coordinates:
+			b3FindPos(portal, pos);
+
+			return;
+		}
+
+		b3ExpandPortal(portal, &v4);
+
+		iterations++;
+	}
+}
+
+B3_STATIC void b3FindPenetrTouch(b3MprSimplex_t *portal, float *depth, b3Float4 *dir, b3Float4 *pos)
+{
+	// Touching contact on portal's v1 - so depth is zero and direction
+	// is unimportant and pos can be guessed
+	*depth = 0.f;
+	b3Float4 zero = b3MakeFloat4(0, 0, 0, 0);
+	b3Float4 *b3mpr_vec3_origin = &zero;
+
+	b3MprVec3Copy(dir, b3mpr_vec3_origin);
+
+	b3MprVec3Copy(pos, &b3MprSimplexPoint(portal, 1)->v1);
+	b3MprVec3Add(pos, &b3MprSimplexPoint(portal, 1)->v2);
+	b3MprVec3Scale(pos, 0.5);
+}
+
+B3_STATIC void b3FindPenetrSegment(b3MprSimplex_t *portal,
+								   float *depth, b3Float4 *dir, b3Float4 *pos)
+{
+	// Origin lies on v0-v1 segment.
+	// Depth is distance to v1, direction also and position must be
+	// computed
+
+	b3MprVec3Copy(pos, &b3MprSimplexPoint(portal, 1)->v1);
+	b3MprVec3Add(pos, &b3MprSimplexPoint(portal, 1)->v2);
+	b3MprVec3Scale(pos, 0.5f);
+
+	b3MprVec3Copy(dir, &b3MprSimplexPoint(portal, 1)->v);
+	*depth = B3_MPR_SQRT(b3MprVec3Len2(dir));
+	b3MprVec3Normalize(dir);
+}
+
+inline int b3MprPenetration(int pairIndex, int bodyIndexA, int bodyIndexB,
+							b3ConstArray(b3RigidBodyData_t) cpuBodyBuf,
+							b3ConstArray(b3ConvexPolyhedronData_t) cpuConvexData,
+							b3ConstArray(b3Collidable_t) cpuCollidables,
+							b3ConstArray(b3Float4) cpuVertices,
+							__global b3Float4 *sepAxis,
+							__global int *hasSepAxis,
+							float *depthOut, b3Float4 *dirOut, b3Float4 *posOut)
+{
+	b3MprSimplex_t portal;
+
+	//	if (!hasSepAxis[pairIndex])
+	//	return -1;
+
+	hasSepAxis[pairIndex] = 0;
+	int res;
+
+	// Phase 1: Portal discovery
+	res = b3DiscoverPortal(pairIndex, bodyIndexA, bodyIndexB, cpuBodyBuf, cpuConvexData, cpuCollidables, cpuVertices, sepAxis, hasSepAxis, &portal);
+
+	//sepAxis[pairIndex] = *pdir;//or -dir?
+
+	switch (res)
+	{
+		case 0:
+		{
+			// Phase 2: Portal refinement
+
+			res = b3RefinePortal(pairIndex, bodyIndexA, bodyIndexB, cpuBodyBuf, cpuConvexData, cpuCollidables, cpuVertices, sepAxis, &portal);
+			if (res < 0)
+				return -1;
+
+			// Phase 3. Penetration info
+			b3FindPenetr(pairIndex, bodyIndexA, bodyIndexB, cpuBodyBuf, cpuConvexData, cpuCollidables, cpuVertices, sepAxis, &portal, depthOut, dirOut, posOut);
+			hasSepAxis[pairIndex] = 1;
+			sepAxis[pairIndex] = -*dirOut;
+			break;
+		}
+		case 1:
+		{
+			// Touching contact on portal's v1.
+			b3FindPenetrTouch(&portal, depthOut, dirOut, posOut);
+			break;
+		}
+		case 2:
+		{
+			b3FindPenetrSegment(&portal, depthOut, dirOut, posOut);
+			break;
+		}
+		default:
+		{
+			hasSepAxis[pairIndex] = 0;
+			//if (res < 0)
+			//{
+			// Origin isn't inside portal - no collision.
+			return -1;
+			//}
+		}
+	};
+
+	return 0;
+};
+
+#endif  //B3_MPR_PENETRATION_H
diff --git a/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3NewContactReduction.h b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3NewContactReduction.h
new file mode 100644
index 00000000..6e991e14
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3NewContactReduction.h
@@ -0,0 +1,175 @@
+
+#ifndef B3_NEW_CONTACT_REDUCTION_H
+#define B3_NEW_CONTACT_REDUCTION_H
+
+#include "Bullet3Common/shared/b3Float4.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3Contact4Data.h"
+
+#define GET_NPOINTS(x) (x).m_worldNormalOnB.w
+
+int b3ExtractManifoldSequentialGlobal(__global const b3Float4* p, int nPoints, b3Float4ConstArg nearNormal, b3Int4* contactIdx)
+{
+	if (nPoints == 0)
+		return 0;
+
+	if (nPoints <= 4)
+		return nPoints;
+
+	if (nPoints > 64)
+		nPoints = 64;
+
+	b3Float4 center = b3MakeFloat4(0, 0, 0, 0);
+	{
+		for (int i = 0; i < nPoints; i++)
+			center += p[i];
+		center /= (float)nPoints;
+	}
+
+	//	sample 4 directions
+
+	b3Float4 aVector = p[0] - center;
+	b3Float4 u = b3Cross(nearNormal, aVector);
+	b3Float4 v = b3Cross(nearNormal, u);
+	u = b3Normalized(u);
+	v = b3Normalized(v);
+
+	//keep point with deepest penetration
+	float minW = FLT_MAX;
+
+	int minIndex = -1;
+
+	b3Float4 maxDots;
+	maxDots.x = FLT_MIN;
+	maxDots.y = FLT_MIN;
+	maxDots.z = FLT_MIN;
+	maxDots.w = FLT_MIN;
+
+	//	idx, distance
+	for (int ie = 0; ie < nPoints; ie++)
+	{
+		if (p[ie].w < minW)
+		{
+			minW = p[ie].w;
+			minIndex = ie;
+		}
+		float f;
+		b3Float4 r = p[ie] - center;
+		f = b3Dot(u, r);
+		if (f < maxDots.x)
+		{
+			maxDots.x = f;
+			contactIdx[0].x = ie;
+		}
+
+		f = b3Dot(-u, r);
+		if (f < maxDots.y)
+		{
+			maxDots.y = f;
+			contactIdx[0].y = ie;
+		}
+
+		f = b3Dot(v, r);
+		if (f < maxDots.z)
+		{
+			maxDots.z = f;
+			contactIdx[0].z = ie;
+		}
+
+		f = b3Dot(-v, r);
+		if (f < maxDots.w)
+		{
+			maxDots.w = f;
+			contactIdx[0].w = ie;
+		}
+	}
+
+	if (contactIdx[0].x != minIndex && contactIdx[0].y != minIndex && contactIdx[0].z != minIndex && contactIdx[0].w != minIndex)
+	{
+		//replace the first contact with minimum (todo: replace contact with least penetration)
+		contactIdx[0].x = minIndex;
+	}
+
+	return 4;
+}
+
+__kernel void b3NewContactReductionKernel(__global b3Int4* pairs,
+										  __global const b3RigidBodyData_t* rigidBodies,
+										  __global const b3Float4* separatingNormals,
+										  __global const int* hasSeparatingAxis,
+										  __global struct b3Contact4Data* globalContactsOut,
+										  __global b3Int4* clippingFaces,
+										  __global b3Float4* worldVertsB2,
+										  volatile __global int* nGlobalContactsOut,
+										  int vertexFaceCapacity,
+										  int contactCapacity,
+										  int numPairs,
+										  int pairIndex)
+{
+	//    int i = get_global_id(0);
+	//int pairIndex = i;
+	int i = pairIndex;
+
+	b3Int4 contactIdx;
+	contactIdx = b3MakeInt4(0, 1, 2, 3);
+
+	if (i < numPairs)
+	{
+		if (hasSeparatingAxis[i])
+		{
+			int nPoints = clippingFaces[pairIndex].w;
+
+			if (nPoints > 0)
+			{
+				__global b3Float4* pointsIn = &worldVertsB2[pairIndex * vertexFaceCapacity];
+				b3Float4 normal = -separatingNormals[i];
+
+				int nReducedContacts = b3ExtractManifoldSequentialGlobal(pointsIn, nPoints, normal, &contactIdx);
+
+				int dstIdx;
+				dstIdx = b3AtomicInc(nGlobalContactsOut);
+
+				//#if 0
+				b3Assert(dstIdx < contactCapacity);
+				if (dstIdx < contactCapacity)
+				{
+					__global struct b3Contact4Data* c = &globalContactsOut[dstIdx];
+					c->m_worldNormalOnB = -normal;
+					c->m_restituitionCoeffCmp = (0.f * 0xffff);
+					c->m_frictionCoeffCmp = (0.7f * 0xffff);
+					c->m_batchIdx = pairIndex;
+					int bodyA = pairs[pairIndex].x;
+					int bodyB = pairs[pairIndex].y;
+
+					pairs[pairIndex].w = dstIdx;
+
+					c->m_bodyAPtrAndSignBit = rigidBodies[bodyA].m_invMass == 0 ? -bodyA : bodyA;
+					c->m_bodyBPtrAndSignBit = rigidBodies[bodyB].m_invMass == 0 ? -bodyB : bodyB;
+					c->m_childIndexA = -1;
+					c->m_childIndexB = -1;
+
+					switch (nReducedContacts)
+					{
+						case 4:
+							c->m_worldPosB[3] = pointsIn[contactIdx.w];
+						case 3:
+							c->m_worldPosB[2] = pointsIn[contactIdx.z];
+						case 2:
+							c->m_worldPosB[1] = pointsIn[contactIdx.y];
+						case 1:
+							c->m_worldPosB[0] = pointsIn[contactIdx.x];
+						default:
+						{
+						}
+					};
+
+					GET_NPOINTS(*c) = nReducedContacts;
+				}
+
+				//#endif
+
+			}  //		if (numContactsOut>0)
+		}      //		if (hasSeparatingAxis[i])
+	}          //	if (i<numPairs)
+}
+#endif
diff --git a/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3QuantizedBvhNodeData.h b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3QuantizedBvhNodeData.h
new file mode 100644
index 00000000..ba796eac
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3QuantizedBvhNodeData.h
@@ -0,0 +1,88 @@
+
+
+#ifndef B3_QUANTIZED_BVH_NODE_H
+#define B3_QUANTIZED_BVH_NODE_H
+
+#include "Bullet3Common/shared/b3Float4.h"
+
+#define B3_MAX_NUM_PARTS_IN_BITS 10
+
+///b3QuantizedBvhNodeData is a compressed aabb node, 16 bytes.
+///Node can be used for leafnode or internal node. Leafnodes can point to 32-bit triangle index (non-negative range).
+typedef struct b3QuantizedBvhNodeData b3QuantizedBvhNodeData_t;
+
+struct b3QuantizedBvhNodeData
+{
+	//12 bytes
+	unsigned short int m_quantizedAabbMin[3];
+	unsigned short int m_quantizedAabbMax[3];
+	//4 bytes
+	int m_escapeIndexOrTriangleIndex;
+};
+
+inline int b3GetTriangleIndex(const b3QuantizedBvhNodeData* rootNode)
+{
+	unsigned int x = 0;
+	unsigned int y = (~(x & 0)) << (31 - B3_MAX_NUM_PARTS_IN_BITS);
+	// Get only the lower bits where the triangle index is stored
+	return (rootNode->m_escapeIndexOrTriangleIndex & ~(y));
+}
+
+inline int b3IsLeaf(const b3QuantizedBvhNodeData* rootNode)
+{
+	//skipindex is negative (internal node), triangleindex >=0 (leafnode)
+	return (rootNode->m_escapeIndexOrTriangleIndex >= 0) ? 1 : 0;
+}
+
+inline int b3GetEscapeIndex(const b3QuantizedBvhNodeData* rootNode)
+{
+	return -rootNode->m_escapeIndexOrTriangleIndex;
+}
+
+inline void b3QuantizeWithClamp(unsigned short* out, b3Float4ConstArg point2, int isMax, b3Float4ConstArg bvhAabbMin, b3Float4ConstArg bvhAabbMax, b3Float4ConstArg bvhQuantization)
+{
+	b3Float4 clampedPoint = b3MaxFloat4(point2, bvhAabbMin);
+	clampedPoint = b3MinFloat4(clampedPoint, bvhAabbMax);
+
+	b3Float4 v = (clampedPoint - bvhAabbMin) * bvhQuantization;
+	if (isMax)
+	{
+		out[0] = (unsigned short)(((unsigned short)(v.x + 1.f) | 1));
+		out[1] = (unsigned short)(((unsigned short)(v.y + 1.f) | 1));
+		out[2] = (unsigned short)(((unsigned short)(v.z + 1.f) | 1));
+	}
+	else
+	{
+		out[0] = (unsigned short)(((unsigned short)(v.x) & 0xfffe));
+		out[1] = (unsigned short)(((unsigned short)(v.y) & 0xfffe));
+		out[2] = (unsigned short)(((unsigned short)(v.z) & 0xfffe));
+	}
+}
+
+inline int b3TestQuantizedAabbAgainstQuantizedAabbSlow(
+	const unsigned short int* aabbMin1,
+	const unsigned short int* aabbMax1,
+	const unsigned short int* aabbMin2,
+	const unsigned short int* aabbMax2)
+{
+	//int overlap = 1;
+	if (aabbMin1[0] > aabbMax2[0])
+		return 0;
+	if (aabbMax1[0] < aabbMin2[0])
+		return 0;
+	if (aabbMin1[1] > aabbMax2[1])
+		return 0;
+	if (aabbMax1[1] < aabbMin2[1])
+		return 0;
+	if (aabbMin1[2] > aabbMax2[2])
+		return 0;
+	if (aabbMax1[2] < aabbMin2[2])
+		return 0;
+	return 1;
+	//overlap = ((aabbMin1[0] > aabbMax2[0]) || (aabbMax1[0] < aabbMin2[0])) ? 0 : overlap;
+	//overlap = ((aabbMin1[2] > aabbMax2[2]) || (aabbMax1[2] < aabbMin2[2])) ? 0 : overlap;
+	//overlap = ((aabbMin1[1] > aabbMax2[1]) || (aabbMax1[1] < aabbMin2[1])) ? 0 : overlap;
+	//return overlap;
+}
+
+#endif  //B3_QUANTIZED_BVH_NODE_H
diff --git a/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3ReduceContacts.h b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3ReduceContacts.h
new file mode 100644
index 00000000..c108255b
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3ReduceContacts.h
@@ -0,0 +1,89 @@
+#ifndef B3_REDUCE_CONTACTS_H
+#define B3_REDUCE_CONTACTS_H
+
+inline int b3ReduceContacts(const b3Float4* p, int nPoints, const b3Float4& nearNormal, b3Int4* contactIdx)
+{
+	if (nPoints == 0)
+		return 0;
+
+	if (nPoints <= 4)
+		return nPoints;
+
+	if (nPoints > 64)
+		nPoints = 64;
+
+	b3Float4 center = b3MakeFloat4(0, 0, 0, 0);
+	{
+		for (int i = 0; i < nPoints; i++)
+			center += p[i];
+		center /= (float)nPoints;
+	}
+
+	//	sample 4 directions
+
+	b3Float4 aVector = p[0] - center;
+	b3Float4 u = b3Cross3(nearNormal, aVector);
+	b3Float4 v = b3Cross3(nearNormal, u);
+	u = b3FastNormalized3(u);
+	v = b3FastNormalized3(v);
+
+	//keep point with deepest penetration
+	float minW = FLT_MAX;
+
+	int minIndex = -1;
+
+	b3Float4 maxDots;
+	maxDots.x = FLT_MIN;
+	maxDots.y = FLT_MIN;
+	maxDots.z = FLT_MIN;
+	maxDots.w = FLT_MIN;
+
+	//	idx, distance
+	for (int ie = 0; ie < nPoints; ie++)
+	{
+		if (p[ie].w < minW)
+		{
+			minW = p[ie].w;
+			minIndex = ie;
+		}
+		float f;
+		b3Float4 r = p[ie] - center;
+		f = b3Dot3F4(u, r);
+		if (f < maxDots.x)
+		{
+			maxDots.x = f;
+			contactIdx[0].x = ie;
+		}
+
+		f = b3Dot3F4(-u, r);
+		if (f < maxDots.y)
+		{
+			maxDots.y = f;
+			contactIdx[0].y = ie;
+		}
+
+		f = b3Dot3F4(v, r);
+		if (f < maxDots.z)
+		{
+			maxDots.z = f;
+			contactIdx[0].z = ie;
+		}
+
+		f = b3Dot3F4(-v, r);
+		if (f < maxDots.w)
+		{
+			maxDots.w = f;
+			contactIdx[0].w = ie;
+		}
+	}
+
+	if (contactIdx[0].x != minIndex && contactIdx[0].y != minIndex && contactIdx[0].z != minIndex && contactIdx[0].w != minIndex)
+	{
+		//replace the first contact with minimum (todo: replace contact with least penetration)
+		contactIdx[0].x = minIndex;
+	}
+
+	return 4;
+}
+
+#endif  //B3_REDUCE_CONTACTS_H
diff --git a/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h
new file mode 100644
index 00000000..663e946f
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h
@@ -0,0 +1,31 @@
+#ifndef B3_RIGIDBODY_DATA_H
+#define B3_RIGIDBODY_DATA_H
+
+#include "Bullet3Common/shared/b3Float4.h"
+#include "Bullet3Common/shared/b3Quat.h"
+#include "Bullet3Common/shared/b3Mat3x3.h"
+
+typedef struct b3RigidBodyData b3RigidBodyData_t;
+
+struct b3RigidBodyData
+{
+	b3Float4 m_pos;
+	b3Quat m_quat;
+	b3Float4 m_linVel;
+	b3Float4 m_angVel;
+
+	int m_collidableIdx;
+	float m_invMass;
+	float m_restituitionCoeff;
+	float m_frictionCoeff;
+};
+
+typedef struct b3InertiaData b3InertiaData_t;
+
+struct b3InertiaData
+{
+	b3Mat3x3 m_invInertiaWorld;
+	b3Mat3x3 m_initInvInertia;
+};
+
+#endif  //B3_RIGIDBODY_DATA_H
diff --git a/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3UpdateAabbs.h b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3UpdateAabbs.h
new file mode 100644
index 00000000..e0c3a5cf
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Collision/NarrowPhaseCollision/shared/b3UpdateAabbs.h
@@ -0,0 +1,35 @@
+#ifndef B3_UPDATE_AABBS_H
+#define B3_UPDATE_AABBS_H
+
+#include "Bullet3Collision/BroadPhaseCollision/shared/b3Aabb.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h"
+
+void b3ComputeWorldAabb(int bodyId, __global const b3RigidBodyData_t* bodies, __global const b3Collidable_t* collidables, __global const b3Aabb_t* localShapeAABB, __global b3Aabb_t* worldAabbs)
+{
+	__global const b3RigidBodyData_t* body = &bodies[bodyId];
+
+	b3Float4 position = body->m_pos;
+	b3Quat orientation = body->m_quat;
+
+	int collidableIndex = body->m_collidableIdx;
+	int shapeIndex = collidables[collidableIndex].m_shapeIndex;
+
+	if (shapeIndex >= 0)
+	{
+		b3Aabb_t localAabb = localShapeAABB[collidableIndex];
+		b3Aabb_t worldAabb;
+
+		b3Float4 aabbAMinOut, aabbAMaxOut;
+		float margin = 0.f;
+		b3TransformAabb2(localAabb.m_minVec, localAabb.m_maxVec, margin, position, orientation, &aabbAMinOut, &aabbAMaxOut);
+
+		worldAabb.m_minVec = aabbAMinOut;
+		worldAabb.m_minIndices[3] = bodyId;
+		worldAabb.m_maxVec = aabbAMaxOut;
+		worldAabb.m_signedMaxIndices[3] = body[bodyId].m_invMass == 0.f ? 0 : 1;
+		worldAabbs[bodyId] = worldAabb;
+	}
+}
+
+#endif  //B3_UPDATE_AABBS_H
diff --git a/engine/inc/bullet/Bullet3Common/b3AlignedAllocator.h b/engine/inc/bullet/Bullet3Common/b3AlignedAllocator.h
new file mode 100644
index 00000000..bcff9f12
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Common/b3AlignedAllocator.h
@@ -0,0 +1,110 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_ALIGNED_ALLOCATOR
+#define B3_ALIGNED_ALLOCATOR
+
+///we probably replace this with our own aligned memory allocator
+///so we replace _aligned_malloc and _aligned_free with our own
+///that is better portable and more predictable
+
+#include "b3Scalar.h"
+//#define B3_DEBUG_MEMORY_ALLOCATIONS 1
+#ifdef B3_DEBUG_MEMORY_ALLOCATIONS
+
+#define b3AlignedAlloc(a, b) \
+	b3AlignedAllocInternal(a, b, __LINE__, __FILE__)
+
+#define b3AlignedFree(ptr) \
+	b3AlignedFreeInternal(ptr, __LINE__, __FILE__)
+
+void* b3AlignedAllocInternal(size_t size, int alignment, int line, char* filename);
+
+void b3AlignedFreeInternal(void* ptr, int line, char* filename);
+
+#else
+void* b3AlignedAllocInternal(size_t size, int alignment);
+void b3AlignedFreeInternal(void* ptr);
+
+#define b3AlignedAlloc(size, alignment) b3AlignedAllocInternal(size, alignment)
+#define b3AlignedFree(ptr) b3AlignedFreeInternal(ptr)
+
+#endif
+typedef int btSizeType;
+
+typedef void*(b3AlignedAllocFunc)(size_t size, int alignment);
+typedef void(b3AlignedFreeFunc)(void* memblock);
+typedef void*(b3AllocFunc)(size_t size);
+typedef void(b3FreeFunc)(void* memblock);
+
+///The developer can let all Bullet memory allocations go through a custom memory allocator, using b3AlignedAllocSetCustom
+void b3AlignedAllocSetCustom(b3AllocFunc* allocFunc, b3FreeFunc* freeFunc);
+///If the developer has already an custom aligned allocator, then b3AlignedAllocSetCustomAligned can be used. The default aligned allocator pre-allocates extra memory using the non-aligned allocator, and instruments it.
+void b3AlignedAllocSetCustomAligned(b3AlignedAllocFunc* allocFunc, b3AlignedFreeFunc* freeFunc);
+
+///The b3AlignedAllocator is a portable class for aligned memory allocations.
+///Default implementations for unaligned and aligned allocations can be overridden by a custom allocator using b3AlignedAllocSetCustom and b3AlignedAllocSetCustomAligned.
+template <typename T, unsigned Alignment>
+class b3AlignedAllocator
+{
+	typedef b3AlignedAllocator<T, Alignment> self_type;
+
+public:
+	//just going down a list:
+	b3AlignedAllocator() {}
+	/*
+	b3AlignedAllocator( const self_type & ) {}
+	*/
+
+	template <typename Other>
+	b3AlignedAllocator(const b3AlignedAllocator<Other, Alignment>&)
+	{
+	}
+
+	typedef const T* const_pointer;
+	typedef const T& const_reference;
+	typedef T* pointer;
+	typedef T& reference;
+	typedef T value_type;
+
+	pointer address(reference ref) const { return &ref; }
+	const_pointer address(const_reference ref) const { return &ref; }
+	pointer allocate(btSizeType n, const_pointer* hint = 0)
+	{
+		(void)hint;
+		return reinterpret_cast<pointer>(b3AlignedAlloc(sizeof(value_type) * n, Alignment));
+	}
+	void construct(pointer ptr, const value_type& value) { new (ptr) value_type(value); }
+	void deallocate(pointer ptr)
+	{
+		b3AlignedFree(reinterpret_cast<void*>(ptr));
+	}
+	void destroy(pointer ptr) { ptr->~value_type(); }
+
+	template <typename O>
+	struct rebind
+	{
+		typedef b3AlignedAllocator<O, Alignment> other;
+	};
+	template <typename O>
+	self_type& operator=(const b3AlignedAllocator<O, Alignment>&)
+	{
+		return *this;
+	}
+
+	friend bool operator==(const self_type&, const self_type&) { return true; }
+};
+
+#endif  //B3_ALIGNED_ALLOCATOR
diff --git a/engine/inc/bullet/Bullet3Common/b3AlignedObjectArray.h b/engine/inc/bullet/Bullet3Common/b3AlignedObjectArray.h
new file mode 100644
index 00000000..249e381b
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Common/b3AlignedObjectArray.h
@@ -0,0 +1,522 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_OBJECT_ARRAY__
+#define B3_OBJECT_ARRAY__
+
+#include "b3Scalar.h"  // has definitions like B3_FORCE_INLINE
+#include "b3AlignedAllocator.h"
+
+///If the platform doesn't support placement new, you can disable B3_USE_PLACEMENT_NEW
+///then the b3AlignedObjectArray doesn't support objects with virtual methods, and non-trivial constructors/destructors
+///You can enable B3_USE_MEMCPY, then swapping elements in the array will use memcpy instead of operator=
+///see discussion here: http://continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=1231 and
+///http://www.continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=1240
+
+#define B3_USE_PLACEMENT_NEW 1
+//#define B3_USE_MEMCPY 1 //disable, because it is cumbersome to find out for each platform where memcpy is defined. It can be in <memory.h> or <string.h> or otherwise...
+#define B3_ALLOW_ARRAY_COPY_OPERATOR  // enabling this can accidently perform deep copies of data if you are not careful
+
+#ifdef B3_USE_MEMCPY
+#include <memory.h>
+#include <string.h>
+#endif  //B3_USE_MEMCPY
+
+#ifdef B3_USE_PLACEMENT_NEW
+#include <new>  //for placement new
+#endif          //B3_USE_PLACEMENT_NEW
+
+///The b3AlignedObjectArray template class uses a subset of the stl::vector interface for its methods
+///It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data
+template <typename T>
+//template <class T>
+class b3AlignedObjectArray
+{
+	b3AlignedAllocator<T, 16> m_allocator;
+
+	int m_size;
+	int m_capacity;
+	T* m_data;
+	//PCK: added this line
+	bool m_ownsMemory;
+
+#ifdef B3_ALLOW_ARRAY_COPY_OPERATOR
+public:
+	B3_FORCE_INLINE b3AlignedObjectArray<T>& operator=(const b3AlignedObjectArray<T>& other)
+	{
+		copyFromArray(other);
+		return *this;
+	}
+#else   //B3_ALLOW_ARRAY_COPY_OPERATOR
+private:
+	B3_FORCE_INLINE b3AlignedObjectArray<T>& operator=(const b3AlignedObjectArray<T>& other);
+#endif  //B3_ALLOW_ARRAY_COPY_OPERATOR
+
+protected:
+	B3_FORCE_INLINE int allocSize(int size)
+	{
+		return (size ? size * 2 : 1);
+	}
+	B3_FORCE_INLINE void copy(int start, int end, T* dest) const
+	{
+		int i;
+		for (i = start; i < end; ++i)
+#ifdef B3_USE_PLACEMENT_NEW
+			new (&dest[i]) T(m_data[i]);
+#else
+			dest[i] = m_data[i];
+#endif  //B3_USE_PLACEMENT_NEW
+	}
+
+	B3_FORCE_INLINE void init()
+	{
+		//PCK: added this line
+		m_ownsMemory = true;
+		m_data = 0;
+		m_size = 0;
+		m_capacity = 0;
+	}
+	B3_FORCE_INLINE void destroy(int first, int last)
+	{
+		int i;
+		for (i = first; i < last; i++)
+		{
+			m_data[i].~T();
+		}
+	}
+
+	B3_FORCE_INLINE void* allocate(int size)
+	{
+		if (size)
+			return m_allocator.allocate(size);
+		return 0;
+	}
+
+	B3_FORCE_INLINE void deallocate()
+	{
+		if (m_data)
+		{
+			//PCK: enclosed the deallocation in this block
+			if (m_ownsMemory)
+			{
+				m_allocator.deallocate(m_data);
+			}
+			m_data = 0;
+		}
+	}
+
+public:
+	b3AlignedObjectArray()
+	{
+		init();
+	}
+
+	~b3AlignedObjectArray()
+	{
+		clear();
+	}
+
+	///Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead.
+	b3AlignedObjectArray(const b3AlignedObjectArray& otherArray)
+	{
+		init();
+
+		int otherSize = otherArray.size();
+		resize(otherSize);
+		otherArray.copy(0, otherSize, m_data);
+	}
+
+	/// return the number of elements in the array
+	B3_FORCE_INLINE int size() const
+	{
+		return m_size;
+	}
+
+	B3_FORCE_INLINE const T& at(int n) const
+	{
+		b3Assert(n >= 0);
+		b3Assert(n < size());
+		return m_data[n];
+	}
+
+	B3_FORCE_INLINE T& at(int n)
+	{
+		b3Assert(n >= 0);
+		b3Assert(n < size());
+		return m_data[n];
+	}
+
+	B3_FORCE_INLINE const T& operator[](int n) const
+	{
+		b3Assert(n >= 0);
+		b3Assert(n < size());
+		return m_data[n];
+	}
+
+	B3_FORCE_INLINE T& operator[](int n)
+	{
+		b3Assert(n >= 0);
+		b3Assert(n < size());
+		return m_data[n];
+	}
+
+	///clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations.
+	B3_FORCE_INLINE void clear()
+	{
+		destroy(0, size());
+
+		deallocate();
+
+		init();
+	}
+
+	B3_FORCE_INLINE void pop_back()
+	{
+		b3Assert(m_size > 0);
+		m_size--;
+		m_data[m_size].~T();
+	}
+
+	///resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument.
+	///when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations.
+	B3_FORCE_INLINE void resizeNoInitialize(int newsize)
+	{
+		int curSize = size();
+
+		if (newsize < curSize)
+		{
+		}
+		else
+		{
+			if (newsize > size())
+			{
+				reserve(newsize);
+			}
+			//leave this uninitialized
+		}
+		m_size = newsize;
+	}
+
+	B3_FORCE_INLINE void resize(int newsize, const T& fillData = T())
+	{
+		int curSize = size();
+
+		if (newsize < curSize)
+		{
+			for (int i = newsize; i < curSize; i++)
+			{
+				m_data[i].~T();
+			}
+		}
+		else
+		{
+			if (newsize > size())
+			{
+				reserve(newsize);
+			}
+#ifdef B3_USE_PLACEMENT_NEW
+			for (int i = curSize; i < newsize; i++)
+			{
+				new (&m_data[i]) T(fillData);
+			}
+#endif  //B3_USE_PLACEMENT_NEW
+		}
+
+		m_size = newsize;
+	}
+	B3_FORCE_INLINE T& expandNonInitializing()
+	{
+		int sz = size();
+		if (sz == capacity())
+		{
+			reserve(allocSize(size()));
+		}
+		m_size++;
+
+		return m_data[sz];
+	}
+
+	B3_FORCE_INLINE T& expand(const T& fillValue = T())
+	{
+		int sz = size();
+		if (sz == capacity())
+		{
+			reserve(allocSize(size()));
+		}
+		m_size++;
+#ifdef B3_USE_PLACEMENT_NEW
+		new (&m_data[sz]) T(fillValue);  //use the in-place new (not really allocating heap memory)
+#endif
+
+		return m_data[sz];
+	}
+
+	B3_FORCE_INLINE void push_back(const T& _Val)
+	{
+		int sz = size();
+		if (sz == capacity())
+		{
+			reserve(allocSize(size()));
+		}
+
+#ifdef B3_USE_PLACEMENT_NEW
+		new (&m_data[m_size]) T(_Val);
+#else
+		m_data[size()] = _Val;
+#endif  //B3_USE_PLACEMENT_NEW
+
+		m_size++;
+	}
+
+	/// return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve()
+	B3_FORCE_INLINE int capacity() const
+	{
+		return m_capacity;
+	}
+
+	B3_FORCE_INLINE void reserve(int _Count)
+	{  // determine new minimum length of allocated storage
+		if (capacity() < _Count)
+		{  // not enough room, reallocate
+			T* s = (T*)allocate(_Count);
+			b3Assert(s);
+			if (s == 0)
+			{
+				b3Error("b3AlignedObjectArray reserve out-of-memory\n");
+				_Count = 0;
+				m_size = 0;
+			}
+			copy(0, size(), s);
+
+			destroy(0, size());
+
+			deallocate();
+
+			//PCK: added this line
+			m_ownsMemory = true;
+
+			m_data = s;
+
+			m_capacity = _Count;
+		}
+	}
+
+	class less
+	{
+	public:
+		bool operator()(const T& a, const T& b)
+		{
+			return (a < b);
+		}
+	};
+
+	template <typename L>
+	void quickSortInternal(const L& CompareFunc, int lo, int hi)
+	{
+		//  lo is the lower index, hi is the upper index
+		//  of the region of array a that is to be sorted
+		int i = lo, j = hi;
+		T x = m_data[(lo + hi) / 2];
+
+		//  partition
+		do
+		{
+			while (CompareFunc(m_data[i], x))
+				i++;
+			while (CompareFunc(x, m_data[j]))
+				j--;
+			if (i <= j)
+			{
+				swap(i, j);
+				i++;
+				j--;
+			}
+		} while (i <= j);
+
+		//  recursion
+		if (lo < j)
+			quickSortInternal(CompareFunc, lo, j);
+		if (i < hi)
+			quickSortInternal(CompareFunc, i, hi);
+	}
+
+	template <typename L>
+	void quickSort(const L& CompareFunc)
+	{
+		//don't sort 0 or 1 elements
+		if (size() > 1)
+		{
+			quickSortInternal(CompareFunc, 0, size() - 1);
+		}
+	}
+
+	///heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/
+	template <typename L>
+	void downHeap(T* pArr, int k, int n, const L& CompareFunc)
+	{
+		/*  PRE: a[k+1..N] is a heap */
+		/* POST:  a[k..N]  is a heap */
+
+		T temp = pArr[k - 1];
+		/* k has child(s) */
+		while (k <= n / 2)
+		{
+			int child = 2 * k;
+
+			if ((child < n) && CompareFunc(pArr[child - 1], pArr[child]))
+			{
+				child++;
+			}
+			/* pick larger child */
+			if (CompareFunc(temp, pArr[child - 1]))
+			{
+				/* move child up */
+				pArr[k - 1] = pArr[child - 1];
+				k = child;
+			}
+			else
+			{
+				break;
+			}
+		}
+		pArr[k - 1] = temp;
+	} /*downHeap*/
+
+	void swap(int index0, int index1)
+	{
+#ifdef B3_USE_MEMCPY
+		char temp[sizeof(T)];
+		memcpy(temp, &m_data[index0], sizeof(T));
+		memcpy(&m_data[index0], &m_data[index1], sizeof(T));
+		memcpy(&m_data[index1], temp, sizeof(T));
+#else
+		T temp = m_data[index0];
+		m_data[index0] = m_data[index1];
+		m_data[index1] = temp;
+#endif  //B3_USE_PLACEMENT_NEW
+	}
+
+	template <typename L>
+	void heapSort(const L& CompareFunc)
+	{
+		/* sort a[0..N-1],  N.B. 0 to N-1 */
+		int k;
+		int n = m_size;
+		for (k = n / 2; k > 0; k--)
+		{
+			downHeap(m_data, k, n, CompareFunc);
+		}
+
+		/* a[1..N] is now a heap */
+		while (n >= 1)
+		{
+			swap(0, n - 1); /* largest of a[0..n-1] */
+
+			n = n - 1;
+			/* restore a[1..i-1] heap */
+			downHeap(m_data, 1, n, CompareFunc);
+		}
+	}
+
+	///non-recursive binary search, assumes sorted array
+	int findBinarySearch(const T& key) const
+	{
+		int first = 0;
+		int last = size() - 1;
+
+		//assume sorted array
+		while (first <= last)
+		{
+			int mid = (first + last) / 2;  // compute mid point.
+			if (key > m_data[mid])
+				first = mid + 1;  // repeat search in top half.
+			else if (key < m_data[mid])
+				last = mid - 1;  // repeat search in bottom half.
+			else
+				return mid;  // found it. return position /////
+		}
+		return size();  // failed to find key
+	}
+
+	int findLinearSearch(const T& key) const
+	{
+		int index = size();
+		int i;
+
+		for (i = 0; i < size(); i++)
+		{
+			if (m_data[i] == key)
+			{
+				index = i;
+				break;
+			}
+		}
+		return index;
+	}
+
+	int findLinearSearch2(const T& key) const
+	{
+		int index = -1;
+		int i;
+
+		for (i = 0; i < size(); i++)
+		{
+			if (m_data[i] == key)
+			{
+				index = i;
+				break;
+			}
+		}
+		return index;
+	}
+
+	void remove(const T& key)
+	{
+		int findIndex = findLinearSearch(key);
+		if (findIndex < size())
+		{
+			swap(findIndex, size() - 1);
+			pop_back();
+		}
+	}
+
+	//PCK: whole function
+	void initializeFromBuffer(void* buffer, int size, int capacity)
+	{
+		clear();
+		m_ownsMemory = false;
+		m_data = (T*)buffer;
+		m_size = size;
+		m_capacity = capacity;
+	}
+
+	void copyFromArray(const b3AlignedObjectArray& otherArray)
+	{
+		int otherSize = otherArray.size();
+		resize(otherSize);
+		otherArray.copy(0, otherSize, m_data);
+	}
+
+	void removeAtIndex(int index)
+	{
+		if (index < size())
+		{
+			swap(index, size() - 1);
+			pop_back();
+		}
+	}
+};
+
+#endif  //B3_OBJECT_ARRAY__
diff --git a/engine/inc/bullet/Bullet3Common/b3CommandLineArgs.h b/engine/inc/bullet/Bullet3Common/b3CommandLineArgs.h
new file mode 100644
index 00000000..5fe4f25f
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Common/b3CommandLineArgs.h
@@ -0,0 +1,106 @@
+#ifndef COMMAND_LINE_ARGS_H
+#define COMMAND_LINE_ARGS_H
+
+/******************************************************************************
+ * Command-line parsing
+ ******************************************************************************/
+#include <map>
+#include <algorithm>
+#include <string>
+#include <cstring>
+#include <sstream>
+class b3CommandLineArgs
+{
+protected:
+	std::map<std::string, std::string> pairs;
+
+public:
+	// Constructor
+	b3CommandLineArgs(int argc, char **argv)
+	{
+		addArgs(argc, argv);
+	}
+
+	void addArgs(int argc, char **argv)
+	{
+		for (int i = 1; i < argc; i++)
+		{
+			std::string arg = argv[i];
+
+			if ((arg.length() < 2) || (arg[0] != '-') || (arg[1] != '-'))
+			{
+				continue;
+			}
+
+			std::string::size_type pos;
+			std::string key, val;
+			if ((pos = arg.find('=')) == std::string::npos)
+			{
+				key = std::string(arg, 2, arg.length() - 2);
+				val = "";
+			}
+			else
+			{
+				key = std::string(arg, 2, pos - 2);
+				val = std::string(arg, pos + 1, arg.length() - 1);
+			}
+
+			//only add new keys, don't replace existing
+			if (pairs.find(key) == pairs.end())
+			{
+				pairs[key] = val;
+			}
+		}
+	}
+
+	bool CheckCmdLineFlag(const char *arg_name)
+	{
+		std::map<std::string, std::string>::iterator itr;
+		if ((itr = pairs.find(arg_name)) != pairs.end())
+		{
+			return true;
+		}
+		return false;
+	}
+
+	template <typename T>
+	bool GetCmdLineArgument(const char *arg_name, T &val);
+
+	int ParsedArgc()
+	{
+		return pairs.size();
+	}
+};
+
+template <typename T>
+inline bool b3CommandLineArgs::GetCmdLineArgument(const char *arg_name, T &val)
+{
+	std::map<std::string, std::string>::iterator itr;
+	if ((itr = pairs.find(arg_name)) != pairs.end())
+	{
+		std::istringstream strstream(itr->second);
+		strstream >> val;
+		return true;
+	}
+	return false;
+}
+
+template <>
+inline bool b3CommandLineArgs::GetCmdLineArgument<char *>(const char *arg_name, char *&val)
+{
+	std::map<std::string, std::string>::iterator itr;
+	if ((itr = pairs.find(arg_name)) != pairs.end())
+	{
+		std::string s = itr->second;
+		val = (char *)malloc(sizeof(char) * (s.length() + 1));
+		std::strcpy(val, s.c_str());
+		return true;
+	}
+	else
+	{
+		val = NULL;
+	}
+	return false;
+}
+
+#endif  //COMMAND_LINE_ARGS_H
diff --git a/engine/inc/bullet/Bullet3Common/b3FileUtils.h b/engine/inc/bullet/Bullet3Common/b3FileUtils.h
new file mode 100644
index 00000000..9ded17ea
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Common/b3FileUtils.h
@@ -0,0 +1,133 @@
+#ifndef B3_FILE_UTILS_H
+#define B3_FILE_UTILS_H
+
+#include <stdio.h>
+#include "b3Scalar.h"
+#include <stddef.h>  //ptrdiff_h
+#include <string.h>
+
+struct b3FileUtils
+{
+	b3FileUtils()
+	{
+	}
+	virtual ~b3FileUtils()
+	{
+	}
+
+	static bool findFile(const char* orgFileName, char* relativeFileName, int maxRelativeFileNameMaxLen)
+	{
+		FILE* f = 0;
+		f = fopen(orgFileName, "rb");
+		if (f)
+		{
+			//printf("original file found: [%s]\n", orgFileName);
+			sprintf(relativeFileName, "%s", orgFileName);
+			fclose(f);
+			return true;
+		}
+
+		//printf("Trying various directories, relative to current working directory\n");
+		const char* prefix[] = {"./", "./data/", "../data/", "../../data/", "../../../data/", "../../../../data/"};
+		int numPrefixes = sizeof(prefix) / sizeof(const char*);
+
+		f = 0;
+		bool fileFound = false;
+
+		for (int i = 0; !f && i < numPrefixes; i++)
+		{
+#ifdef _MSC_VER
+			sprintf_s(relativeFileName, maxRelativeFileNameMaxLen, "%s%s", prefix[i], orgFileName);
+#else
+			sprintf(relativeFileName, "%s%s", prefix[i], orgFileName);
+#endif
+			f = fopen(relativeFileName, "rb");
+			if (f)
+			{
+				fileFound = true;
+				break;
+			}
+		}
+		if (f)
+		{
+			fclose(f);
+		}
+
+		return fileFound;
+	}
+
+	static const char* strip2(const char* name, const char* pattern)
+	{
+		size_t const patlen = strlen(pattern);
+		size_t patcnt = 0;
+		const char* oriptr;
+		const char* patloc;
+		// find how many times the pattern occurs in the original string
+		for (oriptr = name; (patloc = strstr(oriptr, pattern)); oriptr = patloc + patlen)
+		{
+			patcnt++;
+		}
+		return oriptr;
+	}
+
+	static int extractPath(const char* fileName, char* path, int maxPathLength)
+	{
+		const char* stripped = strip2(fileName, "/");
+		stripped = strip2(stripped, "\\");
+
+		ptrdiff_t len = stripped - fileName;
+		b3Assert((len + 1) < maxPathLength);
+
+		if (len && ((len + 1) < maxPathLength))
+		{
+			for (int i = 0; i < len; i++)
+			{
+				path[i] = fileName[i];
+			}
+			path[len] = 0;
+		}
+		else
+		{
+			len = 0;
+			b3Assert(maxPathLength > 0);
+			if (maxPathLength > 0)
+			{
+				path[len] = 0;
+			}
+		}
+		return len;
+	}
+
+	static char toLowerChar(const char t)
+	{
+		if (t >= (char)'A' && t <= (char)'Z')
+			return t + ((char)'a' - (char)'A');
+		else
+			return t;
+	}
+
+	static void toLower(char* str)
+	{
+		int len = strlen(str);
+		for (int i = 0; i < len; i++)
+		{
+			str[i] = toLowerChar(str[i]);
+		}
+	}
+
+	/*static const char* strip2(const char* name, const char* pattern)
+	{
+		size_t const patlen = strlen(pattern);
+		size_t patcnt = 0;
+		const char * oriptr;
+		const char * patloc;
+		// find how many times the pattern occurs in the original string
+		for (oriptr = name; patloc = strstr(oriptr, pattern); oriptr = patloc + patlen)
+		{
+			patcnt++;
+		}
+		return oriptr;
+	}
+	*/
+};
+#endif  //B3_FILE_UTILS_H
diff --git a/engine/inc/bullet/Bullet3Common/b3HashMap.h b/engine/inc/bullet/Bullet3Common/b3HashMap.h
new file mode 100644
index 00000000..3009e2cf
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Common/b3HashMap.h
@@ -0,0 +1,462 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_HASH_MAP_H
+#define B3_HASH_MAP_H
+
+#include "b3AlignedObjectArray.h"
+
+#include <string>
+
+///very basic hashable string implementation, compatible with b3HashMap
+struct b3HashString
+{
+	std::string m_string;
+	unsigned int m_hash;
+
+	B3_FORCE_INLINE unsigned int getHash() const
+	{
+		return m_hash;
+	}
+
+	b3HashString(const char* name)
+		: m_string(name)
+	{
+		/* magic numbers from http://www.isthe.com/chongo/tech/comp/fnv/ */
+		static const unsigned int InitialFNV = 2166136261u;
+		static const unsigned int FNVMultiple = 16777619u;
+
+		/* Fowler / Noll / Vo (FNV) Hash */
+		unsigned int hash = InitialFNV;
+		int len = m_string.length();
+		for (int i = 0; i < len; i++)
+		{
+			hash = hash ^ (m_string[i]); /* xor  the low 8 bits */
+			hash = hash * FNVMultiple;   /* multiply by the magic number */
+		}
+		m_hash = hash;
+	}
+
+	int portableStringCompare(const char* src, const char* dst) const
+	{
+		int ret = 0;
+
+		while (!(ret = *(unsigned char*)src - *(unsigned char*)dst) && *dst)
+			++src, ++dst;
+
+		if (ret < 0)
+			ret = -1;
+		else if (ret > 0)
+			ret = 1;
+
+		return (ret);
+	}
+
+	bool equals(const b3HashString& other) const
+	{
+		return (m_string == other.m_string);
+	}
+};
+
+const int B3_HASH_NULL = 0xffffffff;
+
+class b3HashInt
+{
+	int m_uid;
+
+public:
+	b3HashInt(int uid) : m_uid(uid)
+	{
+	}
+
+	int getUid1() const
+	{
+		return m_uid;
+	}
+
+	void setUid1(int uid)
+	{
+		m_uid = uid;
+	}
+
+	bool equals(const b3HashInt& other) const
+	{
+		return getUid1() == other.getUid1();
+	}
+	//to our success
+	B3_FORCE_INLINE unsigned int getHash() const
+	{
+		int key = m_uid;
+		// Thomas Wang's hash
+		key += ~(key << 15);
+		key ^= (key >> 10);
+		key += (key << 3);
+		key ^= (key >> 6);
+		key += ~(key << 11);
+		key ^= (key >> 16);
+		return key;
+	}
+};
+
+class b3HashPtr
+{
+	union {
+		const void* m_pointer;
+		int m_hashValues[2];
+	};
+
+public:
+	b3HashPtr(const void* ptr)
+		: m_pointer(ptr)
+	{
+	}
+
+	const void* getPointer() const
+	{
+		return m_pointer;
+	}
+
+	bool equals(const b3HashPtr& other) const
+	{
+		return getPointer() == other.getPointer();
+	}
+
+	//to our success
+	B3_FORCE_INLINE unsigned int getHash() const
+	{
+		const bool VOID_IS_8 = ((sizeof(void*) == 8));
+
+		int key = VOID_IS_8 ? m_hashValues[0] + m_hashValues[1] : m_hashValues[0];
+
+		// Thomas Wang's hash
+		key += ~(key << 15);
+		key ^= (key >> 10);
+		key += (key << 3);
+		key ^= (key >> 6);
+		key += ~(key << 11);
+		key ^= (key >> 16);
+		return key;
+	}
+};
+
+template <class Value>
+class b3HashKeyPtr
+{
+	int m_uid;
+
+public:
+	b3HashKeyPtr(int uid) : m_uid(uid)
+	{
+	}
+
+	int getUid1() const
+	{
+		return m_uid;
+	}
+
+	bool equals(const b3HashKeyPtr<Value>& other) const
+	{
+		return getUid1() == other.getUid1();
+	}
+
+	//to our success
+	B3_FORCE_INLINE unsigned int getHash() const
+	{
+		int key = m_uid;
+		// Thomas Wang's hash
+		key += ~(key << 15);
+		key ^= (key >> 10);
+		key += (key << 3);
+		key ^= (key >> 6);
+		key += ~(key << 11);
+		key ^= (key >> 16);
+		return key;
+	}
+};
+
+template <class Value>
+class b3HashKey
+{
+	int m_uid;
+
+public:
+	b3HashKey(int uid) : m_uid(uid)
+	{
+	}
+
+	int getUid1() const
+	{
+		return m_uid;
+	}
+
+	bool equals(const b3HashKey<Value>& other) const
+	{
+		return getUid1() == other.getUid1();
+	}
+	//to our success
+	B3_FORCE_INLINE unsigned int getHash() const
+	{
+		int key = m_uid;
+		// Thomas Wang's hash
+		key += ~(key << 15);
+		key ^= (key >> 10);
+		key += (key << 3);
+		key ^= (key >> 6);
+		key += ~(key << 11);
+		key ^= (key >> 16);
+		return key;
+	}
+};
+
+///The b3HashMap template class implements a generic and lightweight hashmap.
+///A basic sample of how to use b3HashMap is located in Demos\BasicDemo\main.cpp
+template <class Key, class Value>
+class b3HashMap
+{
+protected:
+	b3AlignedObjectArray<int> m_hashTable;
+	b3AlignedObjectArray<int> m_next;
+
+	b3AlignedObjectArray<Value> m_valueArray;
+	b3AlignedObjectArray<Key> m_keyArray;
+
+	void growTables(const Key& /*key*/)
+	{
+		int newCapacity = m_valueArray.capacity();
+
+		if (m_hashTable.size() < newCapacity)
+		{
+			//grow hashtable and next table
+			int curHashtableSize = m_hashTable.size();
+
+			m_hashTable.resize(newCapacity);
+			m_next.resize(newCapacity);
+
+			int i;
+
+			for (i = 0; i < newCapacity; ++i)
+			{
+				m_hashTable[i] = B3_HASH_NULL;
+			}
+			for (i = 0; i < newCapacity; ++i)
+			{
+				m_next[i] = B3_HASH_NULL;
+			}
+
+			for (i = 0; i < curHashtableSize; i++)
+			{
+				//const Value& value = m_valueArray[i];
+				//const Key& key = m_keyArray[i];
+
+				int hashValue = m_keyArray[i].getHash() & (m_valueArray.capacity() - 1);  // New hash value with new mask
+				m_next[i] = m_hashTable[hashValue];
+				m_hashTable[hashValue] = i;
+			}
+		}
+	}
+
+public:
+	void insert(const Key& key, const Value& value)
+	{
+		int hash = key.getHash() & (m_valueArray.capacity() - 1);
+
+		//replace value if the key is already there
+		int index = findIndex(key);
+		if (index != B3_HASH_NULL)
+		{
+			m_valueArray[index] = value;
+			return;
+		}
+
+		int count = m_valueArray.size();
+		int oldCapacity = m_valueArray.capacity();
+		m_valueArray.push_back(value);
+		m_keyArray.push_back(key);
+
+		int newCapacity = m_valueArray.capacity();
+		if (oldCapacity < newCapacity)
+		{
+			growTables(key);
+			//hash with new capacity
+			hash = key.getHash() & (m_valueArray.capacity() - 1);
+		}
+		m_next[count] = m_hashTable[hash];
+		m_hashTable[hash] = count;
+	}
+
+	void remove(const Key& key)
+	{
+		int hash = key.getHash() & (m_valueArray.capacity() - 1);
+
+		int pairIndex = findIndex(key);
+
+		if (pairIndex == B3_HASH_NULL)
+		{
+			return;
+		}
+
+		// Remove the pair from the hash table.
+		int index = m_hashTable[hash];
+		b3Assert(index != B3_HASH_NULL);
+
+		int previous = B3_HASH_NULL;
+		while (index != pairIndex)
+		{
+			previous = index;
+			index = m_next[index];
+		}
+
+		if (previous != B3_HASH_NULL)
+		{
+			b3Assert(m_next[previous] == pairIndex);
+			m_next[previous] = m_next[pairIndex];
+		}
+		else
+		{
+			m_hashTable[hash] = m_next[pairIndex];
+		}
+
+		// We now move the last pair into spot of the
+		// pair being removed. We need to fix the hash
+		// table indices to support the move.
+
+		int lastPairIndex = m_valueArray.size() - 1;
+
+		// If the removed pair is the last pair, we are done.
+		if (lastPairIndex == pairIndex)
+		{
+			m_valueArray.pop_back();
+			m_keyArray.pop_back();
+			return;
+		}
+
+		// Remove the last pair from the hash table.
+		int lastHash = m_keyArray[lastPairIndex].getHash() & (m_valueArray.capacity() - 1);
+
+		index = m_hashTable[lastHash];
+		b3Assert(index != B3_HASH_NULL);
+
+		previous = B3_HASH_NULL;
+		while (index != lastPairIndex)
+		{
+			previous = index;
+			index = m_next[index];
+		}
+
+		if (previous != B3_HASH_NULL)
+		{
+			b3Assert(m_next[previous] == lastPairIndex);
+			m_next[previous] = m_next[lastPairIndex];
+		}
+		else
+		{
+			m_hashTable[lastHash] = m_next[lastPairIndex];
+		}
+
+		// Copy the last pair into the remove pair's spot.
+		m_valueArray[pairIndex] = m_valueArray[lastPairIndex];
+		m_keyArray[pairIndex] = m_keyArray[lastPairIndex];
+
+		// Insert the last pair into the hash table
+		m_next[pairIndex] = m_hashTable[lastHash];
+		m_hashTable[lastHash] = pairIndex;
+
+		m_valueArray.pop_back();
+		m_keyArray.pop_back();
+	}
+
+	int size() const
+	{
+		return m_valueArray.size();
+	}
+
+	const Value* getAtIndex(int index) const
+	{
+		b3Assert(index < m_valueArray.size());
+
+		return &m_valueArray[index];
+	}
+
+	Value* getAtIndex(int index)
+	{
+		b3Assert(index < m_valueArray.size());
+
+		return &m_valueArray[index];
+	}
+
+	Key getKeyAtIndex(int index)
+	{
+		b3Assert(index < m_keyArray.size());
+		return m_keyArray[index];
+	}
+
+	const Key getKeyAtIndex(int index) const
+	{
+		b3Assert(index < m_keyArray.size());
+		return m_keyArray[index];
+	}
+
+	Value* operator[](const Key& key)
+	{
+		return find(key);
+	}
+
+	const Value* find(const Key& key) const
+	{
+		int index = findIndex(key);
+		if (index == B3_HASH_NULL)
+		{
+			return NULL;
+		}
+		return &m_valueArray[index];
+	}
+
+	Value* find(const Key& key)
+	{
+		int index = findIndex(key);
+		if (index == B3_HASH_NULL)
+		{
+			return NULL;
+		}
+		return &m_valueArray[index];
+	}
+
+	int findIndex(const Key& key) const
+	{
+		unsigned int hash = key.getHash() & (m_valueArray.capacity() - 1);
+
+		if (hash >= (unsigned int)m_hashTable.size())
+		{
+			return B3_HASH_NULL;
+		}
+
+		int index = m_hashTable[hash];
+		while ((index != B3_HASH_NULL) && key.equals(m_keyArray[index]) == false)
+		{
+			index = m_next[index];
+		}
+		return index;
+	}
+
+	void clear()
+	{
+		m_hashTable.clear();
+		m_next.clear();
+		m_valueArray.clear();
+		m_keyArray.clear();
+	}
+};
+
+#endif  //B3_HASH_MAP_H
diff --git a/engine/inc/bullet/Bullet3Common/b3Logging.h b/engine/inc/bullet/Bullet3Common/b3Logging.h
new file mode 100644
index 00000000..f61149de
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Common/b3Logging.h
@@ -0,0 +1,74 @@
+
+#ifndef B3_LOGGING_H
+#define B3_LOGGING_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+///We add the do/while so that the statement "if (condition) b3Printf("test"); else {...}" would fail
+///You can also customize the message by uncommenting out a different line below
+#define b3Printf(...) b3OutputPrintfVarArgsInternal(__VA_ARGS__)
+	//#define b3Printf(...) do {b3OutputPrintfVarArgsInternal("b3Printf[%s,%d]:",__FILE__,__LINE__);b3OutputPrintfVarArgsInternal(__VA_ARGS__); } while(0)
+	//#define b3Printf b3OutputPrintfVarArgsInternal
+	//#define b3Printf(...) printf(__VA_ARGS__)
+	//#define b3Printf(...)
+#define b3Warning(...) do{	b3OutputWarningMessageVarArgsInternal("b3Warning[%s,%d]:\n", __FILE__, __LINE__);b3OutputWarningMessageVarArgsInternal(__VA_ARGS__);} while (0)
+#define b3Error(...)do	{b3OutputErrorMessageVarArgsInternal("b3Error[%s,%d]:\n", __FILE__, __LINE__);b3OutputErrorMessageVarArgsInternal(__VA_ARGS__);} while (0)
+#ifndef B3_NO_PROFILE
+
+	void b3EnterProfileZone(const char* name);
+	void b3LeaveProfileZone();
+#ifdef __cplusplus
+
+	class b3ProfileZone
+	{
+	public:
+		b3ProfileZone(const char* name)
+		{
+			b3EnterProfileZone(name);
+		}
+
+		~b3ProfileZone()
+		{
+			b3LeaveProfileZone();
+		}
+	};
+
+#define B3_PROFILE(name) b3ProfileZone __profile(name)
+#endif
+
+#else  //B3_NO_PROFILE
+
+#define B3_PROFILE(name)
+#define b3StartProfile(a)
+#define b3StopProfile
+
+#endif  //#ifndef B3_NO_PROFILE
+
+	typedef void(b3PrintfFunc)(const char* msg);
+	typedef void(b3WarningMessageFunc)(const char* msg);
+	typedef void(b3ErrorMessageFunc)(const char* msg);
+	typedef void(b3EnterProfileZoneFunc)(const char* msg);
+	typedef void(b3LeaveProfileZoneFunc)();
+
+	///The developer can route b3Printf output using their own implementation
+	void b3SetCustomPrintfFunc(b3PrintfFunc* printfFunc);
+	void b3SetCustomWarningMessageFunc(b3WarningMessageFunc* warningMsgFunc);
+	void b3SetCustomErrorMessageFunc(b3ErrorMessageFunc* errorMsgFunc);
+
+	///Set custom profile zone functions (zones can be nested)
+	void b3SetCustomEnterProfileZoneFunc(b3EnterProfileZoneFunc* enterFunc);
+	void b3SetCustomLeaveProfileZoneFunc(b3LeaveProfileZoneFunc* leaveFunc);
+
+	///Don't use those internal functions directly, use the b3Printf or b3SetCustomPrintfFunc instead (or warning/error version)
+	void b3OutputPrintfVarArgsInternal(const char* str, ...);
+	void b3OutputWarningMessageVarArgsInternal(const char* str, ...);
+	void b3OutputErrorMessageVarArgsInternal(const char* str, ...);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  //B3_LOGGING_H
\ No newline at end of file
diff --git a/engine/inc/bullet/Bullet3Common/b3Matrix3x3.h b/engine/inc/bullet/Bullet3Common/b3Matrix3x3.h
new file mode 100644
index 00000000..6c46536a
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Common/b3Matrix3x3.h
@@ -0,0 +1,1354 @@
+/*
+Copyright (c) 2003-2013 Gino van den Bergen / Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_MATRIX3x3_H
+#define B3_MATRIX3x3_H
+
+#include "b3Vector3.h"
+#include "b3Quaternion.h"
+#include <stdio.h>
+
+#ifdef B3_USE_SSE
+//const __m128 B3_ATTRIBUTE_ALIGNED16(b3v2220) = {2.0f, 2.0f, 2.0f, 0.0f};
+const __m128 B3_ATTRIBUTE_ALIGNED16(b3vMPPP) = {-0.0f, +0.0f, +0.0f, +0.0f};
+#endif
+
+#if defined(B3_USE_SSE) || defined(B3_USE_NEON)
+const b3SimdFloat4 B3_ATTRIBUTE_ALIGNED16(b3v1000) = {1.0f, 0.0f, 0.0f, 0.0f};
+const b3SimdFloat4 B3_ATTRIBUTE_ALIGNED16(b3v0100) = {0.0f, 1.0f, 0.0f, 0.0f};
+const b3SimdFloat4 B3_ATTRIBUTE_ALIGNED16(b3v0010) = {0.0f, 0.0f, 1.0f, 0.0f};
+#endif
+
+#ifdef B3_USE_DOUBLE_PRECISION
+#define b3Matrix3x3Data b3Matrix3x3DoubleData
+#else
+#define b3Matrix3x3Data b3Matrix3x3FloatData
+#endif  //B3_USE_DOUBLE_PRECISION
+
+/**@brief The b3Matrix3x3 class implements a 3x3 rotation matrix, to perform linear algebra in combination with b3Quaternion, b3Transform and b3Vector3.
+* Make sure to only include a pure orthogonal matrix without scaling. */
+B3_ATTRIBUTE_ALIGNED16(class)
+b3Matrix3x3
+{
+	///Data storage for the matrix, each vector is a row of the matrix
+	b3Vector3 m_el[3];
+
+public:
+	/** @brief No initializaion constructor */
+	b3Matrix3x3() {}
+
+	//		explicit b3Matrix3x3(const b3Scalar *m) { setFromOpenGLSubMatrix(m); }
+
+	/**@brief Constructor from Quaternion */
+	explicit b3Matrix3x3(const b3Quaternion& q) { setRotation(q); }
+	/*
+	template <typename b3Scalar>
+	Matrix3x3(const b3Scalar& yaw, const b3Scalar& pitch, const b3Scalar& roll)
+	{ 
+	setEulerYPR(yaw, pitch, roll);
+	}
+	*/
+	/** @brief Constructor with row major formatting */
+	b3Matrix3x3(const b3Scalar& xx, const b3Scalar& xy, const b3Scalar& xz,
+				const b3Scalar& yx, const b3Scalar& yy, const b3Scalar& yz,
+				const b3Scalar& zx, const b3Scalar& zy, const b3Scalar& zz)
+	{
+		setValue(xx, xy, xz,
+				 yx, yy, yz,
+				 zx, zy, zz);
+	}
+
+#if (defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)) || defined(B3_USE_NEON)
+	B3_FORCE_INLINE b3Matrix3x3(const b3SimdFloat4 v0, const b3SimdFloat4 v1, const b3SimdFloat4 v2)
+	{
+		m_el[0].mVec128 = v0;
+		m_el[1].mVec128 = v1;
+		m_el[2].mVec128 = v2;
+	}
+
+	B3_FORCE_INLINE b3Matrix3x3(const b3Vector3& v0, const b3Vector3& v1, const b3Vector3& v2)
+	{
+		m_el[0] = v0;
+		m_el[1] = v1;
+		m_el[2] = v2;
+	}
+
+	// Copy constructor
+	B3_FORCE_INLINE b3Matrix3x3(const b3Matrix3x3& rhs)
+	{
+		m_el[0].mVec128 = rhs.m_el[0].mVec128;
+		m_el[1].mVec128 = rhs.m_el[1].mVec128;
+		m_el[2].mVec128 = rhs.m_el[2].mVec128;
+	}
+
+	// Assignment Operator
+	B3_FORCE_INLINE b3Matrix3x3& operator=(const b3Matrix3x3& m)
+	{
+		m_el[0].mVec128 = m.m_el[0].mVec128;
+		m_el[1].mVec128 = m.m_el[1].mVec128;
+		m_el[2].mVec128 = m.m_el[2].mVec128;
+
+		return *this;
+	}
+
+#else
+
+	/** @brief Copy constructor */
+	B3_FORCE_INLINE b3Matrix3x3(const b3Matrix3x3& other)
+	{
+		m_el[0] = other.m_el[0];
+		m_el[1] = other.m_el[1];
+		m_el[2] = other.m_el[2];
+	}
+
+	/** @brief Assignment Operator */
+	B3_FORCE_INLINE b3Matrix3x3& operator=(const b3Matrix3x3& other)
+	{
+		m_el[0] = other.m_el[0];
+		m_el[1] = other.m_el[1];
+		m_el[2] = other.m_el[2];
+		return *this;
+	}
+
+#endif
+
+	/** @brief Get a column of the matrix as a vector 
+	*  @param i Column number 0 indexed */
+	B3_FORCE_INLINE b3Vector3 getColumn(int i) const
+	{
+		return b3MakeVector3(m_el[0][i], m_el[1][i], m_el[2][i]);
+	}
+
+	/** @brief Get a row of the matrix as a vector 
+	*  @param i Row number 0 indexed */
+	B3_FORCE_INLINE const b3Vector3& getRow(int i) const
+	{
+		b3FullAssert(0 <= i && i < 3);
+		return m_el[i];
+	}
+
+	/** @brief Get a mutable reference to a row of the matrix as a vector 
+	*  @param i Row number 0 indexed */
+	B3_FORCE_INLINE b3Vector3& operator[](int i)
+	{
+		b3FullAssert(0 <= i && i < 3);
+		return m_el[i];
+	}
+
+	/** @brief Get a const reference to a row of the matrix as a vector 
+	*  @param i Row number 0 indexed */
+	B3_FORCE_INLINE const b3Vector3& operator[](int i) const
+	{
+		b3FullAssert(0 <= i && i < 3);
+		return m_el[i];
+	}
+
+	/** @brief Multiply by the target matrix on the right
+	*  @param m Rotation matrix to be applied 
+	* Equivilant to this = this * m */
+	b3Matrix3x3& operator*=(const b3Matrix3x3& m);
+
+	/** @brief Adds by the target matrix on the right
+	*  @param m matrix to be applied 
+	* Equivilant to this = this + m */
+	b3Matrix3x3& operator+=(const b3Matrix3x3& m);
+
+	/** @brief Substractss by the target matrix on the right
+	*  @param m matrix to be applied 
+	* Equivilant to this = this - m */
+	b3Matrix3x3& operator-=(const b3Matrix3x3& m);
+
+	/** @brief Set from the rotational part of a 4x4 OpenGL matrix
+	*  @param m A pointer to the beginning of the array of scalars*/
+	void setFromOpenGLSubMatrix(const b3Scalar* m)
+	{
+		m_el[0].setValue(m[0], m[4], m[8]);
+		m_el[1].setValue(m[1], m[5], m[9]);
+		m_el[2].setValue(m[2], m[6], m[10]);
+	}
+	/** @brief Set the values of the matrix explicitly (row major)
+	*  @param xx Top left
+	*  @param xy Top Middle
+	*  @param xz Top Right
+	*  @param yx Middle Left
+	*  @param yy Middle Middle
+	*  @param yz Middle Right
+	*  @param zx Bottom Left
+	*  @param zy Bottom Middle
+	*  @param zz Bottom Right*/
+	void setValue(const b3Scalar& xx, const b3Scalar& xy, const b3Scalar& xz,
+				  const b3Scalar& yx, const b3Scalar& yy, const b3Scalar& yz,
+				  const b3Scalar& zx, const b3Scalar& zy, const b3Scalar& zz)
+	{
+		m_el[0].setValue(xx, xy, xz);
+		m_el[1].setValue(yx, yy, yz);
+		m_el[2].setValue(zx, zy, zz);
+	}
+
+	/** @brief Set the matrix from a quaternion
+	*  @param q The Quaternion to match */
+	void setRotation(const b3Quaternion& q)
+	{
+		b3Scalar d = q.length2();
+		b3FullAssert(d != b3Scalar(0.0));
+		b3Scalar s = b3Scalar(2.0) / d;
+
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+		__m128 vs, Q = q.get128();
+		__m128i Qi = b3CastfTo128i(Q);
+		__m128 Y, Z;
+		__m128 V1, V2, V3;
+		__m128 V11, V21, V31;
+		__m128 NQ = _mm_xor_ps(Q, b3vMzeroMask);
+		__m128i NQi = b3CastfTo128i(NQ);
+
+		V1 = b3CastiTo128f(_mm_shuffle_epi32(Qi, B3_SHUFFLE(1, 0, 2, 3)));  // Y X Z W
+		V2 = _mm_shuffle_ps(NQ, Q, B3_SHUFFLE(0, 0, 1, 3));                 // -X -X  Y  W
+		V3 = b3CastiTo128f(_mm_shuffle_epi32(Qi, B3_SHUFFLE(2, 1, 0, 3)));  // Z Y X W
+		V1 = _mm_xor_ps(V1, b3vMPPP);                                       //	change the sign of the first element
+
+		V11 = b3CastiTo128f(_mm_shuffle_epi32(Qi, B3_SHUFFLE(1, 1, 0, 3)));  // Y Y X W
+		V21 = _mm_unpackhi_ps(Q, Q);                                         //  Z  Z  W  W
+		V31 = _mm_shuffle_ps(Q, NQ, B3_SHUFFLE(0, 2, 0, 3));                 //  X  Z -X -W
+
+		V2 = V2 * V1;   //
+		V1 = V1 * V11;  //
+		V3 = V3 * V31;  //
+
+		V11 = _mm_shuffle_ps(NQ, Q, B3_SHUFFLE(2, 3, 1, 3));                //	-Z -W  Y  W
+		V11 = V11 * V21;                                                    //
+		V21 = _mm_xor_ps(V21, b3vMPPP);                                     //	change the sign of the first element
+		V31 = _mm_shuffle_ps(Q, NQ, B3_SHUFFLE(3, 3, 1, 3));                //	 W  W -Y -W
+		V31 = _mm_xor_ps(V31, b3vMPPP);                                     //	change the sign of the first element
+		Y = b3CastiTo128f(_mm_shuffle_epi32(NQi, B3_SHUFFLE(3, 2, 0, 3)));  // -W -Z -X -W
+		Z = b3CastiTo128f(_mm_shuffle_epi32(Qi, B3_SHUFFLE(1, 0, 1, 3)));   //  Y  X  Y  W
+
+		vs = _mm_load_ss(&s);
+		V21 = V21 * Y;
+		V31 = V31 * Z;
+
+		V1 = V1 + V11;
+		V2 = V2 + V21;
+		V3 = V3 + V31;
+
+		vs = b3_splat3_ps(vs, 0);
+		//	s ready
+		V1 = V1 * vs;
+		V2 = V2 * vs;
+		V3 = V3 * vs;
+
+		V1 = V1 + b3v1000;
+		V2 = V2 + b3v0100;
+		V3 = V3 + b3v0010;
+
+		m_el[0] = b3MakeVector3(V1);
+		m_el[1] = b3MakeVector3(V2);
+		m_el[2] = b3MakeVector3(V3);
+#else
+		b3Scalar xs = q.getX() * s, ys = q.getY() * s, zs = q.getZ() * s;
+		b3Scalar wx = q.getW() * xs, wy = q.getW() * ys, wz = q.getW() * zs;
+		b3Scalar xx = q.getX() * xs, xy = q.getX() * ys, xz = q.getX() * zs;
+		b3Scalar yy = q.getY() * ys, yz = q.getY() * zs, zz = q.getZ() * zs;
+		setValue(
+			b3Scalar(1.0) - (yy + zz), xy - wz, xz + wy,
+			xy + wz, b3Scalar(1.0) - (xx + zz), yz - wx,
+			xz - wy, yz + wx, b3Scalar(1.0) - (xx + yy));
+#endif
+	}
+
+	/** @brief Set the matrix from euler angles using YPR around YXZ respectively
+	*  @param yaw Yaw about Y axis
+	*  @param pitch Pitch about X axis
+	*  @param roll Roll about Z axis 
+	*/
+	void setEulerYPR(const b3Scalar& yaw, const b3Scalar& pitch, const b3Scalar& roll)
+	{
+		setEulerZYX(roll, pitch, yaw);
+	}
+
+	/** @brief Set the matrix from euler angles YPR around ZYX axes
+	* @param eulerX Roll about X axis
+	* @param eulerY Pitch around Y axis
+	* @param eulerZ Yaw aboud Z axis
+	* 
+	* These angles are used to produce a rotation matrix. The euler
+	* angles are applied in ZYX order. I.e a vector is first rotated 
+	* about X then Y and then Z
+	**/
+	void setEulerZYX(b3Scalar eulerX, b3Scalar eulerY, b3Scalar eulerZ)
+	{
+		///@todo proposed to reverse this since it's labeled zyx but takes arguments xyz and it will match all other parts of the code
+		b3Scalar ci(b3Cos(eulerX));
+		b3Scalar cj(b3Cos(eulerY));
+		b3Scalar ch(b3Cos(eulerZ));
+		b3Scalar si(b3Sin(eulerX));
+		b3Scalar sj(b3Sin(eulerY));
+		b3Scalar sh(b3Sin(eulerZ));
+		b3Scalar cc = ci * ch;
+		b3Scalar cs = ci * sh;
+		b3Scalar sc = si * ch;
+		b3Scalar ss = si * sh;
+
+		setValue(cj * ch, sj * sc - cs, sj * cc + ss,
+				 cj * sh, sj * ss + cc, sj * cs - sc,
+				 -sj, cj * si, cj * ci);
+	}
+
+	/**@brief Set the matrix to the identity */
+	void setIdentity()
+	{
+#if (defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)) || defined(B3_USE_NEON)
+		m_el[0] = b3MakeVector3(b3v1000);
+		m_el[1] = b3MakeVector3(b3v0100);
+		m_el[2] = b3MakeVector3(b3v0010);
+#else
+		setValue(b3Scalar(1.0), b3Scalar(0.0), b3Scalar(0.0),
+				 b3Scalar(0.0), b3Scalar(1.0), b3Scalar(0.0),
+				 b3Scalar(0.0), b3Scalar(0.0), b3Scalar(1.0));
+#endif
+	}
+
+	static const b3Matrix3x3& getIdentity()
+	{
+#if (defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)) || defined(B3_USE_NEON)
+		static const b3Matrix3x3
+			identityMatrix(b3v1000, b3v0100, b3v0010);
+#else
+		static const b3Matrix3x3
+			identityMatrix(
+				b3Scalar(1.0), b3Scalar(0.0), b3Scalar(0.0),
+				b3Scalar(0.0), b3Scalar(1.0), b3Scalar(0.0),
+				b3Scalar(0.0), b3Scalar(0.0), b3Scalar(1.0));
+#endif
+		return identityMatrix;
+	}
+
+	/**@brief Fill the rotational part of an OpenGL matrix and clear the shear/perspective
+	* @param m The array to be filled */
+	void getOpenGLSubMatrix(b3Scalar * m) const
+	{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+		__m128 v0 = m_el[0].mVec128;
+		__m128 v1 = m_el[1].mVec128;
+		__m128 v2 = m_el[2].mVec128;  //  x2 y2 z2 w2
+		__m128* vm = (__m128*)m;
+		__m128 vT;
+
+		v2 = _mm_and_ps(v2, b3vFFF0fMask);  //  x2 y2 z2 0
+
+		vT = _mm_unpackhi_ps(v0, v1);  //	z0 z1 * *
+		v0 = _mm_unpacklo_ps(v0, v1);  //	x0 x1 y0 y1
+
+		v1 = _mm_shuffle_ps(v0, v2, B3_SHUFFLE(2, 3, 1, 3));                    // y0 y1 y2 0
+		v0 = _mm_shuffle_ps(v0, v2, B3_SHUFFLE(0, 1, 0, 3));                    // x0 x1 x2 0
+		v2 = b3CastdTo128f(_mm_move_sd(b3CastfTo128d(v2), b3CastfTo128d(vT)));  // z0 z1 z2 0
+
+		vm[0] = v0;
+		vm[1] = v1;
+		vm[2] = v2;
+#elif defined(B3_USE_NEON)
+		// note: zeros the w channel. We can preserve it at the cost of two more vtrn instructions.
+		static const uint32x2_t zMask = (const uint32x2_t){-1, 0};
+		float32x4_t* vm = (float32x4_t*)m;
+		float32x4x2_t top = vtrnq_f32(m_el[0].mVec128, m_el[1].mVec128);               // {x0 x1 z0 z1}, {y0 y1 w0 w1}
+		float32x2x2_t bl = vtrn_f32(vget_low_f32(m_el[2].mVec128), vdup_n_f32(0.0f));  // {x2  0 }, {y2 0}
+		float32x4_t v0 = vcombine_f32(vget_low_f32(top.val[0]), bl.val[0]);
+		float32x4_t v1 = vcombine_f32(vget_low_f32(top.val[1]), bl.val[1]);
+		float32x2_t q = (float32x2_t)vand_u32((uint32x2_t)vget_high_f32(m_el[2].mVec128), zMask);
+		float32x4_t v2 = vcombine_f32(vget_high_f32(top.val[0]), q);  // z0 z1 z2  0
+
+		vm[0] = v0;
+		vm[1] = v1;
+		vm[2] = v2;
+#else
+		m[0] = b3Scalar(m_el[0].getX());
+		m[1] = b3Scalar(m_el[1].getX());
+		m[2] = b3Scalar(m_el[2].getX());
+		m[3] = b3Scalar(0.0);
+		m[4] = b3Scalar(m_el[0].getY());
+		m[5] = b3Scalar(m_el[1].getY());
+		m[6] = b3Scalar(m_el[2].getY());
+		m[7] = b3Scalar(0.0);
+		m[8] = b3Scalar(m_el[0].getZ());
+		m[9] = b3Scalar(m_el[1].getZ());
+		m[10] = b3Scalar(m_el[2].getZ());
+		m[11] = b3Scalar(0.0);
+#endif
+	}
+
+	/**@brief Get the matrix represented as a quaternion 
+	* @param q The quaternion which will be set */
+	void getRotation(b3Quaternion & q) const
+	{
+#if (defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)) || defined(B3_USE_NEON)
+		b3Scalar trace = m_el[0].getX() + m_el[1].getY() + m_el[2].getZ();
+		b3Scalar s, x;
+
+		union {
+			b3SimdFloat4 vec;
+			b3Scalar f[4];
+		} temp;
+
+		if (trace > b3Scalar(0.0))
+		{
+			x = trace + b3Scalar(1.0);
+
+			temp.f[0] = m_el[2].getY() - m_el[1].getZ();
+			temp.f[1] = m_el[0].getZ() - m_el[2].getX();
+			temp.f[2] = m_el[1].getX() - m_el[0].getY();
+			temp.f[3] = x;
+			//temp.f[3]= s * b3Scalar(0.5);
+		}
+		else
+		{
+			int i, j, k;
+			if (m_el[0].getX() < m_el[1].getY())
+			{
+				if (m_el[1].getY() < m_el[2].getZ())
+				{
+					i = 2;
+					j = 0;
+					k = 1;
+				}
+				else
+				{
+					i = 1;
+					j = 2;
+					k = 0;
+				}
+			}
+			else
+			{
+				if (m_el[0].getX() < m_el[2].getZ())
+				{
+					i = 2;
+					j = 0;
+					k = 1;
+				}
+				else
+				{
+					i = 0;
+					j = 1;
+					k = 2;
+				}
+			}
+
+			x = m_el[i][i] - m_el[j][j] - m_el[k][k] + b3Scalar(1.0);
+
+			temp.f[3] = (m_el[k][j] - m_el[j][k]);
+			temp.f[j] = (m_el[j][i] + m_el[i][j]);
+			temp.f[k] = (m_el[k][i] + m_el[i][k]);
+			temp.f[i] = x;
+			//temp.f[i] = s * b3Scalar(0.5);
+		}
+
+		s = b3Sqrt(x);
+		q.set128(temp.vec);
+		s = b3Scalar(0.5) / s;
+
+		q *= s;
+#else
+		b3Scalar trace = m_el[0].getX() + m_el[1].getY() + m_el[2].getZ();
+
+		b3Scalar temp[4];
+
+		if (trace > b3Scalar(0.0))
+		{
+			b3Scalar s = b3Sqrt(trace + b3Scalar(1.0));
+			temp[3] = (s * b3Scalar(0.5));
+			s = b3Scalar(0.5) / s;
+
+			temp[0] = ((m_el[2].getY() - m_el[1].getZ()) * s);
+			temp[1] = ((m_el[0].getZ() - m_el[2].getX()) * s);
+			temp[2] = ((m_el[1].getX() - m_el[0].getY()) * s);
+		}
+		else
+		{
+			int i = m_el[0].getX() < m_el[1].getY() ? (m_el[1].getY() < m_el[2].getZ() ? 2 : 1) : (m_el[0].getX() < m_el[2].getZ() ? 2 : 0);
+			int j = (i + 1) % 3;
+			int k = (i + 2) % 3;
+
+			b3Scalar s = b3Sqrt(m_el[i][i] - m_el[j][j] - m_el[k][k] + b3Scalar(1.0));
+			temp[i] = s * b3Scalar(0.5);
+			s = b3Scalar(0.5) / s;
+
+			temp[3] = (m_el[k][j] - m_el[j][k]) * s;
+			temp[j] = (m_el[j][i] + m_el[i][j]) * s;
+			temp[k] = (m_el[k][i] + m_el[i][k]) * s;
+		}
+		q.setValue(temp[0], temp[1], temp[2], temp[3]);
+#endif
+	}
+
+	/**@brief Get the matrix represented as euler angles around YXZ, roundtrip with setEulerYPR
+	* @param yaw Yaw around Y axis
+	* @param pitch Pitch around X axis
+	* @param roll around Z axis */
+	void getEulerYPR(b3Scalar & yaw, b3Scalar & pitch, b3Scalar & roll) const
+	{
+		// first use the normal calculus
+		yaw = b3Scalar(b3Atan2(m_el[1].getX(), m_el[0].getX()));
+		pitch = b3Scalar(b3Asin(-m_el[2].getX()));
+		roll = b3Scalar(b3Atan2(m_el[2].getY(), m_el[2].getZ()));
+
+		// on pitch = +/-HalfPI
+		if (b3Fabs(pitch) == B3_HALF_PI)
+		{
+			if (yaw > 0)
+				yaw -= B3_PI;
+			else
+				yaw += B3_PI;
+
+			if (roll > 0)
+				roll -= B3_PI;
+			else
+				roll += B3_PI;
+		}
+	};
+
+	/**@brief Get the matrix represented as euler angles around ZYX
+	* @param yaw Yaw around X axis
+	* @param pitch Pitch around Y axis
+	* @param roll around X axis 
+	* @param solution_number Which solution of two possible solutions ( 1 or 2) are possible values*/
+	void getEulerZYX(b3Scalar & yaw, b3Scalar & pitch, b3Scalar & roll, unsigned int solution_number = 1) const
+	{
+		struct Euler
+		{
+			b3Scalar yaw;
+			b3Scalar pitch;
+			b3Scalar roll;
+		};
+
+		Euler euler_out;
+		Euler euler_out2;  //second solution
+		//get the pointer to the raw data
+
+		// Check that pitch is not at a singularity
+		if (b3Fabs(m_el[2].getX()) >= 1)
+		{
+			euler_out.yaw = 0;
+			euler_out2.yaw = 0;
+
+			// From difference of angles formula
+			b3Scalar delta = b3Atan2(m_el[0].getX(), m_el[0].getZ());
+			if (m_el[2].getX() > 0)  //gimbal locked up
+			{
+				euler_out.pitch = B3_PI / b3Scalar(2.0);
+				euler_out2.pitch = B3_PI / b3Scalar(2.0);
+				euler_out.roll = euler_out.pitch + delta;
+				euler_out2.roll = euler_out.pitch + delta;
+			}
+			else  // gimbal locked down
+			{
+				euler_out.pitch = -B3_PI / b3Scalar(2.0);
+				euler_out2.pitch = -B3_PI / b3Scalar(2.0);
+				euler_out.roll = -euler_out.pitch + delta;
+				euler_out2.roll = -euler_out.pitch + delta;
+			}
+		}
+		else
+		{
+			euler_out.pitch = -b3Asin(m_el[2].getX());
+			euler_out2.pitch = B3_PI - euler_out.pitch;
+
+			euler_out.roll = b3Atan2(m_el[2].getY() / b3Cos(euler_out.pitch),
+									 m_el[2].getZ() / b3Cos(euler_out.pitch));
+			euler_out2.roll = b3Atan2(m_el[2].getY() / b3Cos(euler_out2.pitch),
+									  m_el[2].getZ() / b3Cos(euler_out2.pitch));
+
+			euler_out.yaw = b3Atan2(m_el[1].getX() / b3Cos(euler_out.pitch),
+									m_el[0].getX() / b3Cos(euler_out.pitch));
+			euler_out2.yaw = b3Atan2(m_el[1].getX() / b3Cos(euler_out2.pitch),
+									 m_el[0].getX() / b3Cos(euler_out2.pitch));
+		}
+
+		if (solution_number == 1)
+		{
+			yaw = euler_out.yaw;
+			pitch = euler_out.pitch;
+			roll = euler_out.roll;
+		}
+		else
+		{
+			yaw = euler_out2.yaw;
+			pitch = euler_out2.pitch;
+			roll = euler_out2.roll;
+		}
+	}
+
+	/**@brief Create a scaled copy of the matrix 
+	* @param s Scaling vector The elements of the vector will scale each column */
+
+	b3Matrix3x3 scaled(const b3Vector3& s) const
+	{
+#if (defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)) || defined(B3_USE_NEON)
+		return b3Matrix3x3(m_el[0] * s, m_el[1] * s, m_el[2] * s);
+#else
+		return b3Matrix3x3(
+			m_el[0].getX() * s.getX(), m_el[0].getY() * s.getY(), m_el[0].getZ() * s.getZ(),
+			m_el[1].getX() * s.getX(), m_el[1].getY() * s.getY(), m_el[1].getZ() * s.getZ(),
+			m_el[2].getX() * s.getX(), m_el[2].getY() * s.getY(), m_el[2].getZ() * s.getZ());
+#endif
+	}
+
+	/**@brief Return the determinant of the matrix */
+	b3Scalar determinant() const;
+	/**@brief Return the adjoint of the matrix */
+	b3Matrix3x3 adjoint() const;
+	/**@brief Return the matrix with all values non negative */
+	b3Matrix3x3 absolute() const;
+	/**@brief Return the transpose of the matrix */
+	b3Matrix3x3 transpose() const;
+	/**@brief Return the inverse of the matrix */
+	b3Matrix3x3 inverse() const;
+
+	b3Matrix3x3 transposeTimes(const b3Matrix3x3& m) const;
+	b3Matrix3x3 timesTranspose(const b3Matrix3x3& m) const;
+
+	B3_FORCE_INLINE b3Scalar tdotx(const b3Vector3& v) const
+	{
+		return m_el[0].getX() * v.getX() + m_el[1].getX() * v.getY() + m_el[2].getX() * v.getZ();
+	}
+	B3_FORCE_INLINE b3Scalar tdoty(const b3Vector3& v) const
+	{
+		return m_el[0].getY() * v.getX() + m_el[1].getY() * v.getY() + m_el[2].getY() * v.getZ();
+	}
+	B3_FORCE_INLINE b3Scalar tdotz(const b3Vector3& v) const
+	{
+		return m_el[0].getZ() * v.getX() + m_el[1].getZ() * v.getY() + m_el[2].getZ() * v.getZ();
+	}
+
+	/**@brief diagonalizes this matrix by the Jacobi method.
+	* @param rot stores the rotation from the coordinate system in which the matrix is diagonal to the original
+	* coordinate system, i.e., old_this = rot * new_this * rot^T. 
+	* @param threshold See iteration
+	* @param iteration The iteration stops when all off-diagonal elements are less than the threshold multiplied 
+	* by the sum of the absolute values of the diagonal, or when maxSteps have been executed. 
+	* 
+	* Note that this matrix is assumed to be symmetric. 
+	*/
+	void diagonalize(b3Matrix3x3 & rot, b3Scalar threshold, int maxSteps)
+	{
+		rot.setIdentity();
+		for (int step = maxSteps; step > 0; step--)
+		{
+			// find off-diagonal element [p][q] with largest magnitude
+			int p = 0;
+			int q = 1;
+			int r = 2;
+			b3Scalar max = b3Fabs(m_el[0][1]);
+			b3Scalar v = b3Fabs(m_el[0][2]);
+			if (v > max)
+			{
+				q = 2;
+				r = 1;
+				max = v;
+			}
+			v = b3Fabs(m_el[1][2]);
+			if (v > max)
+			{
+				p = 1;
+				q = 2;
+				r = 0;
+				max = v;
+			}
+
+			b3Scalar t = threshold * (b3Fabs(m_el[0][0]) + b3Fabs(m_el[1][1]) + b3Fabs(m_el[2][2]));
+			if (max <= t)
+			{
+				if (max <= B3_EPSILON * t)
+				{
+					return;
+				}
+				step = 1;
+			}
+
+			// compute Jacobi rotation J which leads to a zero for element [p][q]
+			b3Scalar mpq = m_el[p][q];
+			b3Scalar theta = (m_el[q][q] - m_el[p][p]) / (2 * mpq);
+			b3Scalar theta2 = theta * theta;
+			b3Scalar cos;
+			b3Scalar sin;
+			if (theta2 * theta2 < b3Scalar(10 / B3_EPSILON))
+			{
+				t = (theta >= 0) ? 1 / (theta + b3Sqrt(1 + theta2))
+								 : 1 / (theta - b3Sqrt(1 + theta2));
+				cos = 1 / b3Sqrt(1 + t * t);
+				sin = cos * t;
+			}
+			else
+			{
+				// approximation for large theta-value, i.e., a nearly diagonal matrix
+				t = 1 / (theta * (2 + b3Scalar(0.5) / theta2));
+				cos = 1 - b3Scalar(0.5) * t * t;
+				sin = cos * t;
+			}
+
+			// apply rotation to matrix (this = J^T * this * J)
+			m_el[p][q] = m_el[q][p] = 0;
+			m_el[p][p] -= t * mpq;
+			m_el[q][q] += t * mpq;
+			b3Scalar mrp = m_el[r][p];
+			b3Scalar mrq = m_el[r][q];
+			m_el[r][p] = m_el[p][r] = cos * mrp - sin * mrq;
+			m_el[r][q] = m_el[q][r] = cos * mrq + sin * mrp;
+
+			// apply rotation to rot (rot = rot * J)
+			for (int i = 0; i < 3; i++)
+			{
+				b3Vector3& row = rot[i];
+				mrp = row[p];
+				mrq = row[q];
+				row[p] = cos * mrp - sin * mrq;
+				row[q] = cos * mrq + sin * mrp;
+			}
+		}
+	}
+
+	/**@brief Calculate the matrix cofactor 
+	* @param r1 The first row to use for calculating the cofactor
+	* @param c1 The first column to use for calculating the cofactor
+	* @param r1 The second row to use for calculating the cofactor
+	* @param c1 The second column to use for calculating the cofactor
+	* See http://en.wikipedia.org/wiki/Cofactor_(linear_algebra) for more details
+	*/
+	b3Scalar cofac(int r1, int c1, int r2, int c2) const
+	{
+		return m_el[r1][c1] * m_el[r2][c2] - m_el[r1][c2] * m_el[r2][c1];
+	}
+
+	void serialize(struct b3Matrix3x3Data & dataOut) const;
+
+	void serializeFloat(struct b3Matrix3x3FloatData & dataOut) const;
+
+	void deSerialize(const struct b3Matrix3x3Data& dataIn);
+
+	void deSerializeFloat(const struct b3Matrix3x3FloatData& dataIn);
+
+	void deSerializeDouble(const struct b3Matrix3x3DoubleData& dataIn);
+};
+
+B3_FORCE_INLINE b3Matrix3x3&
+b3Matrix3x3::operator*=(const b3Matrix3x3& m)
+{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+	__m128 rv00, rv01, rv02;
+	__m128 rv10, rv11, rv12;
+	__m128 rv20, rv21, rv22;
+	__m128 mv0, mv1, mv2;
+
+	rv02 = m_el[0].mVec128;
+	rv12 = m_el[1].mVec128;
+	rv22 = m_el[2].mVec128;
+
+	mv0 = _mm_and_ps(m[0].mVec128, b3vFFF0fMask);
+	mv1 = _mm_and_ps(m[1].mVec128, b3vFFF0fMask);
+	mv2 = _mm_and_ps(m[2].mVec128, b3vFFF0fMask);
+
+	// rv0
+	rv00 = b3_splat_ps(rv02, 0);
+	rv01 = b3_splat_ps(rv02, 1);
+	rv02 = b3_splat_ps(rv02, 2);
+
+	rv00 = _mm_mul_ps(rv00, mv0);
+	rv01 = _mm_mul_ps(rv01, mv1);
+	rv02 = _mm_mul_ps(rv02, mv2);
+
+	// rv1
+	rv10 = b3_splat_ps(rv12, 0);
+	rv11 = b3_splat_ps(rv12, 1);
+	rv12 = b3_splat_ps(rv12, 2);
+
+	rv10 = _mm_mul_ps(rv10, mv0);
+	rv11 = _mm_mul_ps(rv11, mv1);
+	rv12 = _mm_mul_ps(rv12, mv2);
+
+	// rv2
+	rv20 = b3_splat_ps(rv22, 0);
+	rv21 = b3_splat_ps(rv22, 1);
+	rv22 = b3_splat_ps(rv22, 2);
+
+	rv20 = _mm_mul_ps(rv20, mv0);
+	rv21 = _mm_mul_ps(rv21, mv1);
+	rv22 = _mm_mul_ps(rv22, mv2);
+
+	rv00 = _mm_add_ps(rv00, rv01);
+	rv10 = _mm_add_ps(rv10, rv11);
+	rv20 = _mm_add_ps(rv20, rv21);
+
+	m_el[0].mVec128 = _mm_add_ps(rv00, rv02);
+	m_el[1].mVec128 = _mm_add_ps(rv10, rv12);
+	m_el[2].mVec128 = _mm_add_ps(rv20, rv22);
+
+#elif defined(B3_USE_NEON)
+
+	float32x4_t rv0, rv1, rv2;
+	float32x4_t v0, v1, v2;
+	float32x4_t mv0, mv1, mv2;
+
+	v0 = m_el[0].mVec128;
+	v1 = m_el[1].mVec128;
+	v2 = m_el[2].mVec128;
+
+	mv0 = (float32x4_t)vandq_s32((int32x4_t)m[0].mVec128, b3vFFF0Mask);
+	mv1 = (float32x4_t)vandq_s32((int32x4_t)m[1].mVec128, b3vFFF0Mask);
+	mv2 = (float32x4_t)vandq_s32((int32x4_t)m[2].mVec128, b3vFFF0Mask);
+
+	rv0 = vmulq_lane_f32(mv0, vget_low_f32(v0), 0);
+	rv1 = vmulq_lane_f32(mv0, vget_low_f32(v1), 0);
+	rv2 = vmulq_lane_f32(mv0, vget_low_f32(v2), 0);
+
+	rv0 = vmlaq_lane_f32(rv0, mv1, vget_low_f32(v0), 1);
+	rv1 = vmlaq_lane_f32(rv1, mv1, vget_low_f32(v1), 1);
+	rv2 = vmlaq_lane_f32(rv2, mv1, vget_low_f32(v2), 1);
+
+	rv0 = vmlaq_lane_f32(rv0, mv2, vget_high_f32(v0), 0);
+	rv1 = vmlaq_lane_f32(rv1, mv2, vget_high_f32(v1), 0);
+	rv2 = vmlaq_lane_f32(rv2, mv2, vget_high_f32(v2), 0);
+
+	m_el[0].mVec128 = rv0;
+	m_el[1].mVec128 = rv1;
+	m_el[2].mVec128 = rv2;
+#else
+	setValue(
+		m.tdotx(m_el[0]), m.tdoty(m_el[0]), m.tdotz(m_el[0]),
+		m.tdotx(m_el[1]), m.tdoty(m_el[1]), m.tdotz(m_el[1]),
+		m.tdotx(m_el[2]), m.tdoty(m_el[2]), m.tdotz(m_el[2]));
+#endif
+	return *this;
+}
+
+B3_FORCE_INLINE b3Matrix3x3&
+b3Matrix3x3::operator+=(const b3Matrix3x3& m)
+{
+#if (defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)) || defined(B3_USE_NEON)
+	m_el[0].mVec128 = m_el[0].mVec128 + m.m_el[0].mVec128;
+	m_el[1].mVec128 = m_el[1].mVec128 + m.m_el[1].mVec128;
+	m_el[2].mVec128 = m_el[2].mVec128 + m.m_el[2].mVec128;
+#else
+	setValue(
+		m_el[0][0] + m.m_el[0][0],
+		m_el[0][1] + m.m_el[0][1],
+		m_el[0][2] + m.m_el[0][2],
+		m_el[1][0] + m.m_el[1][0],
+		m_el[1][1] + m.m_el[1][1],
+		m_el[1][2] + m.m_el[1][2],
+		m_el[2][0] + m.m_el[2][0],
+		m_el[2][1] + m.m_el[2][1],
+		m_el[2][2] + m.m_el[2][2]);
+#endif
+	return *this;
+}
+
+B3_FORCE_INLINE b3Matrix3x3
+operator*(const b3Matrix3x3& m, const b3Scalar& k)
+{
+#if (defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE))
+	__m128 vk = b3_splat_ps(_mm_load_ss((float*)&k), 0x80);
+	return b3Matrix3x3(
+		_mm_mul_ps(m[0].mVec128, vk),
+		_mm_mul_ps(m[1].mVec128, vk),
+		_mm_mul_ps(m[2].mVec128, vk));
+#elif defined(B3_USE_NEON)
+	return b3Matrix3x3(
+		vmulq_n_f32(m[0].mVec128, k),
+		vmulq_n_f32(m[1].mVec128, k),
+		vmulq_n_f32(m[2].mVec128, k));
+#else
+	return b3Matrix3x3(
+		m[0].getX() * k, m[0].getY() * k, m[0].getZ() * k,
+		m[1].getX() * k, m[1].getY() * k, m[1].getZ() * k,
+		m[2].getX() * k, m[2].getY() * k, m[2].getZ() * k);
+#endif
+}
+
+B3_FORCE_INLINE b3Matrix3x3
+operator+(const b3Matrix3x3& m1, const b3Matrix3x3& m2)
+{
+#if (defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)) || defined(B3_USE_NEON)
+	return b3Matrix3x3(
+		m1[0].mVec128 + m2[0].mVec128,
+		m1[1].mVec128 + m2[1].mVec128,
+		m1[2].mVec128 + m2[2].mVec128);
+#else
+	return b3Matrix3x3(
+		m1[0][0] + m2[0][0],
+		m1[0][1] + m2[0][1],
+		m1[0][2] + m2[0][2],
+
+		m1[1][0] + m2[1][0],
+		m1[1][1] + m2[1][1],
+		m1[1][2] + m2[1][2],
+
+		m1[2][0] + m2[2][0],
+		m1[2][1] + m2[2][1],
+		m1[2][2] + m2[2][2]);
+#endif
+}
+
+B3_FORCE_INLINE b3Matrix3x3
+operator-(const b3Matrix3x3& m1, const b3Matrix3x3& m2)
+{
+#if (defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)) || defined(B3_USE_NEON)
+	return b3Matrix3x3(
+		m1[0].mVec128 - m2[0].mVec128,
+		m1[1].mVec128 - m2[1].mVec128,
+		m1[2].mVec128 - m2[2].mVec128);
+#else
+	return b3Matrix3x3(
+		m1[0][0] - m2[0][0],
+		m1[0][1] - m2[0][1],
+		m1[0][2] - m2[0][2],
+
+		m1[1][0] - m2[1][0],
+		m1[1][1] - m2[1][1],
+		m1[1][2] - m2[1][2],
+
+		m1[2][0] - m2[2][0],
+		m1[2][1] - m2[2][1],
+		m1[2][2] - m2[2][2]);
+#endif
+}
+
+B3_FORCE_INLINE b3Matrix3x3&
+b3Matrix3x3::operator-=(const b3Matrix3x3& m)
+{
+#if (defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)) || defined(B3_USE_NEON)
+	m_el[0].mVec128 = m_el[0].mVec128 - m.m_el[0].mVec128;
+	m_el[1].mVec128 = m_el[1].mVec128 - m.m_el[1].mVec128;
+	m_el[2].mVec128 = m_el[2].mVec128 - m.m_el[2].mVec128;
+#else
+	setValue(
+		m_el[0][0] - m.m_el[0][0],
+		m_el[0][1] - m.m_el[0][1],
+		m_el[0][2] - m.m_el[0][2],
+		m_el[1][0] - m.m_el[1][0],
+		m_el[1][1] - m.m_el[1][1],
+		m_el[1][2] - m.m_el[1][2],
+		m_el[2][0] - m.m_el[2][0],
+		m_el[2][1] - m.m_el[2][1],
+		m_el[2][2] - m.m_el[2][2]);
+#endif
+	return *this;
+}
+
+B3_FORCE_INLINE b3Scalar
+b3Matrix3x3::determinant() const
+{
+	return b3Triple((*this)[0], (*this)[1], (*this)[2]);
+}
+
+B3_FORCE_INLINE b3Matrix3x3
+b3Matrix3x3::absolute() const
+{
+#if (defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE))
+	return b3Matrix3x3(
+		_mm_and_ps(m_el[0].mVec128, b3vAbsfMask),
+		_mm_and_ps(m_el[1].mVec128, b3vAbsfMask),
+		_mm_and_ps(m_el[2].mVec128, b3vAbsfMask));
+#elif defined(B3_USE_NEON)
+	return b3Matrix3x3(
+		(float32x4_t)vandq_s32((int32x4_t)m_el[0].mVec128, b3v3AbsMask),
+		(float32x4_t)vandq_s32((int32x4_t)m_el[1].mVec128, b3v3AbsMask),
+		(float32x4_t)vandq_s32((int32x4_t)m_el[2].mVec128, b3v3AbsMask));
+#else
+	return b3Matrix3x3(
+		b3Fabs(m_el[0].getX()), b3Fabs(m_el[0].getY()), b3Fabs(m_el[0].getZ()),
+		b3Fabs(m_el[1].getX()), b3Fabs(m_el[1].getY()), b3Fabs(m_el[1].getZ()),
+		b3Fabs(m_el[2].getX()), b3Fabs(m_el[2].getY()), b3Fabs(m_el[2].getZ()));
+#endif
+}
+
+B3_FORCE_INLINE b3Matrix3x3
+b3Matrix3x3::transpose() const
+{
+#if (defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE))
+	__m128 v0 = m_el[0].mVec128;
+	__m128 v1 = m_el[1].mVec128;
+	__m128 v2 = m_el[2].mVec128;  //  x2 y2 z2 w2
+	__m128 vT;
+
+	v2 = _mm_and_ps(v2, b3vFFF0fMask);  //  x2 y2 z2 0
+
+	vT = _mm_unpackhi_ps(v0, v1);  //	z0 z1 * *
+	v0 = _mm_unpacklo_ps(v0, v1);  //	x0 x1 y0 y1
+
+	v1 = _mm_shuffle_ps(v0, v2, B3_SHUFFLE(2, 3, 1, 3));                    // y0 y1 y2 0
+	v0 = _mm_shuffle_ps(v0, v2, B3_SHUFFLE(0, 1, 0, 3));                    // x0 x1 x2 0
+	v2 = b3CastdTo128f(_mm_move_sd(b3CastfTo128d(v2), b3CastfTo128d(vT)));  // z0 z1 z2 0
+
+	return b3Matrix3x3(v0, v1, v2);
+#elif defined(B3_USE_NEON)
+	// note: zeros the w channel. We can preserve it at the cost of two more vtrn instructions.
+	static const uint32x2_t zMask = (const uint32x2_t){-1, 0};
+	float32x4x2_t top = vtrnq_f32(m_el[0].mVec128, m_el[1].mVec128);               // {x0 x1 z0 z1}, {y0 y1 w0 w1}
+	float32x2x2_t bl = vtrn_f32(vget_low_f32(m_el[2].mVec128), vdup_n_f32(0.0f));  // {x2  0 }, {y2 0}
+	float32x4_t v0 = vcombine_f32(vget_low_f32(top.val[0]), bl.val[0]);
+	float32x4_t v1 = vcombine_f32(vget_low_f32(top.val[1]), bl.val[1]);
+	float32x2_t q = (float32x2_t)vand_u32((uint32x2_t)vget_high_f32(m_el[2].mVec128), zMask);
+	float32x4_t v2 = vcombine_f32(vget_high_f32(top.val[0]), q);  // z0 z1 z2  0
+	return b3Matrix3x3(v0, v1, v2);
+#else
+	return b3Matrix3x3(m_el[0].getX(), m_el[1].getX(), m_el[2].getX(),
+					   m_el[0].getY(), m_el[1].getY(), m_el[2].getY(),
+					   m_el[0].getZ(), m_el[1].getZ(), m_el[2].getZ());
+#endif
+}
+
+B3_FORCE_INLINE b3Matrix3x3
+b3Matrix3x3::adjoint() const
+{
+	return b3Matrix3x3(cofac(1, 1, 2, 2), cofac(0, 2, 2, 1), cofac(0, 1, 1, 2),
+					   cofac(1, 2, 2, 0), cofac(0, 0, 2, 2), cofac(0, 2, 1, 0),
+					   cofac(1, 0, 2, 1), cofac(0, 1, 2, 0), cofac(0, 0, 1, 1));
+}
+
+B3_FORCE_INLINE b3Matrix3x3
+b3Matrix3x3::inverse() const
+{
+	b3Vector3 co = b3MakeVector3(cofac(1, 1, 2, 2), cofac(1, 2, 2, 0), cofac(1, 0, 2, 1));
+	b3Scalar det = (*this)[0].dot(co);
+	b3FullAssert(det != b3Scalar(0.0));
+	b3Scalar s = b3Scalar(1.0) / det;
+	return b3Matrix3x3(co.getX() * s, cofac(0, 2, 2, 1) * s, cofac(0, 1, 1, 2) * s,
+					   co.getY() * s, cofac(0, 0, 2, 2) * s, cofac(0, 2, 1, 0) * s,
+					   co.getZ() * s, cofac(0, 1, 2, 0) * s, cofac(0, 0, 1, 1) * s);
+}
+
+B3_FORCE_INLINE b3Matrix3x3
+b3Matrix3x3::transposeTimes(const b3Matrix3x3& m) const
+{
+#if (defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE))
+	// zeros w
+	//    static const __m128i xyzMask = (const __m128i){ -1ULL, 0xffffffffULL };
+	__m128 row = m_el[0].mVec128;
+	__m128 m0 = _mm_and_ps(m.getRow(0).mVec128, b3vFFF0fMask);
+	__m128 m1 = _mm_and_ps(m.getRow(1).mVec128, b3vFFF0fMask);
+	__m128 m2 = _mm_and_ps(m.getRow(2).mVec128, b3vFFF0fMask);
+	__m128 r0 = _mm_mul_ps(m0, _mm_shuffle_ps(row, row, 0));
+	__m128 r1 = _mm_mul_ps(m0, _mm_shuffle_ps(row, row, 0x55));
+	__m128 r2 = _mm_mul_ps(m0, _mm_shuffle_ps(row, row, 0xaa));
+	row = m_el[1].mVec128;
+	r0 = _mm_add_ps(r0, _mm_mul_ps(m1, _mm_shuffle_ps(row, row, 0)));
+	r1 = _mm_add_ps(r1, _mm_mul_ps(m1, _mm_shuffle_ps(row, row, 0x55)));
+	r2 = _mm_add_ps(r2, _mm_mul_ps(m1, _mm_shuffle_ps(row, row, 0xaa)));
+	row = m_el[2].mVec128;
+	r0 = _mm_add_ps(r0, _mm_mul_ps(m2, _mm_shuffle_ps(row, row, 0)));
+	r1 = _mm_add_ps(r1, _mm_mul_ps(m2, _mm_shuffle_ps(row, row, 0x55)));
+	r2 = _mm_add_ps(r2, _mm_mul_ps(m2, _mm_shuffle_ps(row, row, 0xaa)));
+	return b3Matrix3x3(r0, r1, r2);
+
+#elif defined B3_USE_NEON
+	// zeros w
+	static const uint32x4_t xyzMask = (const uint32x4_t){-1, -1, -1, 0};
+	float32x4_t m0 = (float32x4_t)vandq_u32((uint32x4_t)m.getRow(0).mVec128, xyzMask);
+	float32x4_t m1 = (float32x4_t)vandq_u32((uint32x4_t)m.getRow(1).mVec128, xyzMask);
+	float32x4_t m2 = (float32x4_t)vandq_u32((uint32x4_t)m.getRow(2).mVec128, xyzMask);
+	float32x4_t row = m_el[0].mVec128;
+	float32x4_t r0 = vmulq_lane_f32(m0, vget_low_f32(row), 0);
+	float32x4_t r1 = vmulq_lane_f32(m0, vget_low_f32(row), 1);
+	float32x4_t r2 = vmulq_lane_f32(m0, vget_high_f32(row), 0);
+	row = m_el[1].mVec128;
+	r0 = vmlaq_lane_f32(r0, m1, vget_low_f32(row), 0);
+	r1 = vmlaq_lane_f32(r1, m1, vget_low_f32(row), 1);
+	r2 = vmlaq_lane_f32(r2, m1, vget_high_f32(row), 0);
+	row = m_el[2].mVec128;
+	r0 = vmlaq_lane_f32(r0, m2, vget_low_f32(row), 0);
+	r1 = vmlaq_lane_f32(r1, m2, vget_low_f32(row), 1);
+	r2 = vmlaq_lane_f32(r2, m2, vget_high_f32(row), 0);
+	return b3Matrix3x3(r0, r1, r2);
+#else
+	return b3Matrix3x3(
+		m_el[0].getX() * m[0].getX() + m_el[1].getX() * m[1].getX() + m_el[2].getX() * m[2].getX(),
+		m_el[0].getX() * m[0].getY() + m_el[1].getX() * m[1].getY() + m_el[2].getX() * m[2].getY(),
+		m_el[0].getX() * m[0].getZ() + m_el[1].getX() * m[1].getZ() + m_el[2].getX() * m[2].getZ(),
+		m_el[0].getY() * m[0].getX() + m_el[1].getY() * m[1].getX() + m_el[2].getY() * m[2].getX(),
+		m_el[0].getY() * m[0].getY() + m_el[1].getY() * m[1].getY() + m_el[2].getY() * m[2].getY(),
+		m_el[0].getY() * m[0].getZ() + m_el[1].getY() * m[1].getZ() + m_el[2].getY() * m[2].getZ(),
+		m_el[0].getZ() * m[0].getX() + m_el[1].getZ() * m[1].getX() + m_el[2].getZ() * m[2].getX(),
+		m_el[0].getZ() * m[0].getY() + m_el[1].getZ() * m[1].getY() + m_el[2].getZ() * m[2].getY(),
+		m_el[0].getZ() * m[0].getZ() + m_el[1].getZ() * m[1].getZ() + m_el[2].getZ() * m[2].getZ());
+#endif
+}
+
+B3_FORCE_INLINE b3Matrix3x3
+b3Matrix3x3::timesTranspose(const b3Matrix3x3& m) const
+{
+#if (defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE))
+	__m128 a0 = m_el[0].mVec128;
+	__m128 a1 = m_el[1].mVec128;
+	__m128 a2 = m_el[2].mVec128;
+
+	b3Matrix3x3 mT = m.transpose();  // we rely on transpose() zeroing w channel so that we don't have to do it here
+	__m128 mx = mT[0].mVec128;
+	__m128 my = mT[1].mVec128;
+	__m128 mz = mT[2].mVec128;
+
+	__m128 r0 = _mm_mul_ps(mx, _mm_shuffle_ps(a0, a0, 0x00));
+	__m128 r1 = _mm_mul_ps(mx, _mm_shuffle_ps(a1, a1, 0x00));
+	__m128 r2 = _mm_mul_ps(mx, _mm_shuffle_ps(a2, a2, 0x00));
+	r0 = _mm_add_ps(r0, _mm_mul_ps(my, _mm_shuffle_ps(a0, a0, 0x55)));
+	r1 = _mm_add_ps(r1, _mm_mul_ps(my, _mm_shuffle_ps(a1, a1, 0x55)));
+	r2 = _mm_add_ps(r2, _mm_mul_ps(my, _mm_shuffle_ps(a2, a2, 0x55)));
+	r0 = _mm_add_ps(r0, _mm_mul_ps(mz, _mm_shuffle_ps(a0, a0, 0xaa)));
+	r1 = _mm_add_ps(r1, _mm_mul_ps(mz, _mm_shuffle_ps(a1, a1, 0xaa)));
+	r2 = _mm_add_ps(r2, _mm_mul_ps(mz, _mm_shuffle_ps(a2, a2, 0xaa)));
+	return b3Matrix3x3(r0, r1, r2);
+
+#elif defined B3_USE_NEON
+	float32x4_t a0 = m_el[0].mVec128;
+	float32x4_t a1 = m_el[1].mVec128;
+	float32x4_t a2 = m_el[2].mVec128;
+
+	b3Matrix3x3 mT = m.transpose();  // we rely on transpose() zeroing w channel so that we don't have to do it here
+	float32x4_t mx = mT[0].mVec128;
+	float32x4_t my = mT[1].mVec128;
+	float32x4_t mz = mT[2].mVec128;
+
+	float32x4_t r0 = vmulq_lane_f32(mx, vget_low_f32(a0), 0);
+	float32x4_t r1 = vmulq_lane_f32(mx, vget_low_f32(a1), 0);
+	float32x4_t r2 = vmulq_lane_f32(mx, vget_low_f32(a2), 0);
+	r0 = vmlaq_lane_f32(r0, my, vget_low_f32(a0), 1);
+	r1 = vmlaq_lane_f32(r1, my, vget_low_f32(a1), 1);
+	r2 = vmlaq_lane_f32(r2, my, vget_low_f32(a2), 1);
+	r0 = vmlaq_lane_f32(r0, mz, vget_high_f32(a0), 0);
+	r1 = vmlaq_lane_f32(r1, mz, vget_high_f32(a1), 0);
+	r2 = vmlaq_lane_f32(r2, mz, vget_high_f32(a2), 0);
+	return b3Matrix3x3(r0, r1, r2);
+
+#else
+	return b3Matrix3x3(
+		m_el[0].dot(m[0]), m_el[0].dot(m[1]), m_el[0].dot(m[2]),
+		m_el[1].dot(m[0]), m_el[1].dot(m[1]), m_el[1].dot(m[2]),
+		m_el[2].dot(m[0]), m_el[2].dot(m[1]), m_el[2].dot(m[2]));
+#endif
+}
+
+B3_FORCE_INLINE b3Vector3
+operator*(const b3Matrix3x3& m, const b3Vector3& v)
+{
+#if (defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)) || defined(B3_USE_NEON)
+	return v.dot3(m[0], m[1], m[2]);
+#else
+	return b3MakeVector3(m[0].dot(v), m[1].dot(v), m[2].dot(v));
+#endif
+}
+
+B3_FORCE_INLINE b3Vector3
+operator*(const b3Vector3& v, const b3Matrix3x3& m)
+{
+#if (defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE))
+
+	const __m128 vv = v.mVec128;
+
+	__m128 c0 = b3_splat_ps(vv, 0);
+	__m128 c1 = b3_splat_ps(vv, 1);
+	__m128 c2 = b3_splat_ps(vv, 2);
+
+	c0 = _mm_mul_ps(c0, _mm_and_ps(m[0].mVec128, b3vFFF0fMask));
+	c1 = _mm_mul_ps(c1, _mm_and_ps(m[1].mVec128, b3vFFF0fMask));
+	c0 = _mm_add_ps(c0, c1);
+	c2 = _mm_mul_ps(c2, _mm_and_ps(m[2].mVec128, b3vFFF0fMask));
+
+	return b3MakeVector3(_mm_add_ps(c0, c2));
+#elif defined(B3_USE_NEON)
+	const float32x4_t vv = v.mVec128;
+	const float32x2_t vlo = vget_low_f32(vv);
+	const float32x2_t vhi = vget_high_f32(vv);
+
+	float32x4_t c0, c1, c2;
+
+	c0 = (float32x4_t)vandq_s32((int32x4_t)m[0].mVec128, b3vFFF0Mask);
+	c1 = (float32x4_t)vandq_s32((int32x4_t)m[1].mVec128, b3vFFF0Mask);
+	c2 = (float32x4_t)vandq_s32((int32x4_t)m[2].mVec128, b3vFFF0Mask);
+
+	c0 = vmulq_lane_f32(c0, vlo, 0);
+	c1 = vmulq_lane_f32(c1, vlo, 1);
+	c2 = vmulq_lane_f32(c2, vhi, 0);
+	c0 = vaddq_f32(c0, c1);
+	c0 = vaddq_f32(c0, c2);
+
+	return b3MakeVector3(c0);
+#else
+	return b3MakeVector3(m.tdotx(v), m.tdoty(v), m.tdotz(v));
+#endif
+}
+
+B3_FORCE_INLINE b3Matrix3x3
+operator*(const b3Matrix3x3& m1, const b3Matrix3x3& m2)
+{
+#if (defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE))
+
+	__m128 m10 = m1[0].mVec128;
+	__m128 m11 = m1[1].mVec128;
+	__m128 m12 = m1[2].mVec128;
+
+	__m128 m2v = _mm_and_ps(m2[0].mVec128, b3vFFF0fMask);
+
+	__m128 c0 = b3_splat_ps(m10, 0);
+	__m128 c1 = b3_splat_ps(m11, 0);
+	__m128 c2 = b3_splat_ps(m12, 0);
+
+	c0 = _mm_mul_ps(c0, m2v);
+	c1 = _mm_mul_ps(c1, m2v);
+	c2 = _mm_mul_ps(c2, m2v);
+
+	m2v = _mm_and_ps(m2[1].mVec128, b3vFFF0fMask);
+
+	__m128 c0_1 = b3_splat_ps(m10, 1);
+	__m128 c1_1 = b3_splat_ps(m11, 1);
+	__m128 c2_1 = b3_splat_ps(m12, 1);
+
+	c0_1 = _mm_mul_ps(c0_1, m2v);
+	c1_1 = _mm_mul_ps(c1_1, m2v);
+	c2_1 = _mm_mul_ps(c2_1, m2v);
+
+	m2v = _mm_and_ps(m2[2].mVec128, b3vFFF0fMask);
+
+	c0 = _mm_add_ps(c0, c0_1);
+	c1 = _mm_add_ps(c1, c1_1);
+	c2 = _mm_add_ps(c2, c2_1);
+
+	m10 = b3_splat_ps(m10, 2);
+	m11 = b3_splat_ps(m11, 2);
+	m12 = b3_splat_ps(m12, 2);
+
+	m10 = _mm_mul_ps(m10, m2v);
+	m11 = _mm_mul_ps(m11, m2v);
+	m12 = _mm_mul_ps(m12, m2v);
+
+	c0 = _mm_add_ps(c0, m10);
+	c1 = _mm_add_ps(c1, m11);
+	c2 = _mm_add_ps(c2, m12);
+
+	return b3Matrix3x3(c0, c1, c2);
+
+#elif defined(B3_USE_NEON)
+
+	float32x4_t rv0, rv1, rv2;
+	float32x4_t v0, v1, v2;
+	float32x4_t mv0, mv1, mv2;
+
+	v0 = m1[0].mVec128;
+	v1 = m1[1].mVec128;
+	v2 = m1[2].mVec128;
+
+	mv0 = (float32x4_t)vandq_s32((int32x4_t)m2[0].mVec128, b3vFFF0Mask);
+	mv1 = (float32x4_t)vandq_s32((int32x4_t)m2[1].mVec128, b3vFFF0Mask);
+	mv2 = (float32x4_t)vandq_s32((int32x4_t)m2[2].mVec128, b3vFFF0Mask);
+
+	rv0 = vmulq_lane_f32(mv0, vget_low_f32(v0), 0);
+	rv1 = vmulq_lane_f32(mv0, vget_low_f32(v1), 0);
+	rv2 = vmulq_lane_f32(mv0, vget_low_f32(v2), 0);
+
+	rv0 = vmlaq_lane_f32(rv0, mv1, vget_low_f32(v0), 1);
+	rv1 = vmlaq_lane_f32(rv1, mv1, vget_low_f32(v1), 1);
+	rv2 = vmlaq_lane_f32(rv2, mv1, vget_low_f32(v2), 1);
+
+	rv0 = vmlaq_lane_f32(rv0, mv2, vget_high_f32(v0), 0);
+	rv1 = vmlaq_lane_f32(rv1, mv2, vget_high_f32(v1), 0);
+	rv2 = vmlaq_lane_f32(rv2, mv2, vget_high_f32(v2), 0);
+
+	return b3Matrix3x3(rv0, rv1, rv2);
+
+#else
+	return b3Matrix3x3(
+		m2.tdotx(m1[0]), m2.tdoty(m1[0]), m2.tdotz(m1[0]),
+		m2.tdotx(m1[1]), m2.tdoty(m1[1]), m2.tdotz(m1[1]),
+		m2.tdotx(m1[2]), m2.tdoty(m1[2]), m2.tdotz(m1[2]));
+#endif
+}
+
+/*
+B3_FORCE_INLINE b3Matrix3x3 b3MultTransposeLeft(const b3Matrix3x3& m1, const b3Matrix3x3& m2) {
+return b3Matrix3x3(
+m1[0][0] * m2[0][0] + m1[1][0] * m2[1][0] + m1[2][0] * m2[2][0],
+m1[0][0] * m2[0][1] + m1[1][0] * m2[1][1] + m1[2][0] * m2[2][1],
+m1[0][0] * m2[0][2] + m1[1][0] * m2[1][2] + m1[2][0] * m2[2][2],
+m1[0][1] * m2[0][0] + m1[1][1] * m2[1][0] + m1[2][1] * m2[2][0],
+m1[0][1] * m2[0][1] + m1[1][1] * m2[1][1] + m1[2][1] * m2[2][1],
+m1[0][1] * m2[0][2] + m1[1][1] * m2[1][2] + m1[2][1] * m2[2][2],
+m1[0][2] * m2[0][0] + m1[1][2] * m2[1][0] + m1[2][2] * m2[2][0],
+m1[0][2] * m2[0][1] + m1[1][2] * m2[1][1] + m1[2][2] * m2[2][1],
+m1[0][2] * m2[0][2] + m1[1][2] * m2[1][2] + m1[2][2] * m2[2][2]);
+}
+*/
+
+/**@brief Equality operator between two matrices
+* It will test all elements are equal.  */
+B3_FORCE_INLINE bool operator==(const b3Matrix3x3& m1, const b3Matrix3x3& m2)
+{
+#if (defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE))
+
+	__m128 c0, c1, c2;
+
+	c0 = _mm_cmpeq_ps(m1[0].mVec128, m2[0].mVec128);
+	c1 = _mm_cmpeq_ps(m1[1].mVec128, m2[1].mVec128);
+	c2 = _mm_cmpeq_ps(m1[2].mVec128, m2[2].mVec128);
+
+	c0 = _mm_and_ps(c0, c1);
+	c0 = _mm_and_ps(c0, c2);
+
+	return (0x7 == _mm_movemask_ps((__m128)c0));
+#else
+	return (m1[0][0] == m2[0][0] && m1[1][0] == m2[1][0] && m1[2][0] == m2[2][0] &&
+			m1[0][1] == m2[0][1] && m1[1][1] == m2[1][1] && m1[2][1] == m2[2][1] &&
+			m1[0][2] == m2[0][2] && m1[1][2] == m2[1][2] && m1[2][2] == m2[2][2]);
+#endif
+}
+
+///for serialization
+struct b3Matrix3x3FloatData
+{
+	b3Vector3FloatData m_el[3];
+};
+
+///for serialization
+struct b3Matrix3x3DoubleData
+{
+	b3Vector3DoubleData m_el[3];
+};
+
+B3_FORCE_INLINE void b3Matrix3x3::serialize(struct b3Matrix3x3Data& dataOut) const
+{
+	for (int i = 0; i < 3; i++)
+		m_el[i].serialize(dataOut.m_el[i]);
+}
+
+B3_FORCE_INLINE void b3Matrix3x3::serializeFloat(struct b3Matrix3x3FloatData& dataOut) const
+{
+	for (int i = 0; i < 3; i++)
+		m_el[i].serializeFloat(dataOut.m_el[i]);
+}
+
+B3_FORCE_INLINE void b3Matrix3x3::deSerialize(const struct b3Matrix3x3Data& dataIn)
+{
+	for (int i = 0; i < 3; i++)
+		m_el[i].deSerialize(dataIn.m_el[i]);
+}
+
+B3_FORCE_INLINE void b3Matrix3x3::deSerializeFloat(const struct b3Matrix3x3FloatData& dataIn)
+{
+	for (int i = 0; i < 3; i++)
+		m_el[i].deSerializeFloat(dataIn.m_el[i]);
+}
+
+B3_FORCE_INLINE void b3Matrix3x3::deSerializeDouble(const struct b3Matrix3x3DoubleData& dataIn)
+{
+	for (int i = 0; i < 3; i++)
+		m_el[i].deSerializeDouble(dataIn.m_el[i]);
+}
+
+#endif  //B3_MATRIX3x3_H
diff --git a/engine/inc/bullet/Bullet3Common/b3MinMax.h b/engine/inc/bullet/Bullet3Common/b3MinMax.h
new file mode 100644
index 00000000..c09c3db3
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Common/b3MinMax.h
@@ -0,0 +1,69 @@
+/*
+Copyright (c) 2003-2013 Gino van den Bergen / Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_GEN_MINMAX_H
+#define B3_GEN_MINMAX_H
+
+#include "b3Scalar.h"
+
+template <class T>
+B3_FORCE_INLINE const T& b3Min(const T& a, const T& b)
+{
+	return a < b ? a : b;
+}
+
+template <class T>
+B3_FORCE_INLINE const T& b3Max(const T& a, const T& b)
+{
+	return a > b ? a : b;
+}
+
+template <class T>
+B3_FORCE_INLINE const T& b3Clamped(const T& a, const T& lb, const T& ub)
+{
+	return a < lb ? lb : (ub < a ? ub : a);
+}
+
+template <class T>
+B3_FORCE_INLINE void b3SetMin(T& a, const T& b)
+{
+	if (b < a)
+	{
+		a = b;
+	}
+}
+
+template <class T>
+B3_FORCE_INLINE void b3SetMax(T& a, const T& b)
+{
+	if (a < b)
+	{
+		a = b;
+	}
+}
+
+template <class T>
+B3_FORCE_INLINE void b3Clamp(T& a, const T& lb, const T& ub)
+{
+	if (a < lb)
+	{
+		a = lb;
+	}
+	else if (ub < a)
+	{
+		a = ub;
+	}
+}
+
+#endif  //B3_GEN_MINMAX_H
diff --git a/engine/inc/bullet/Bullet3Common/b3PoolAllocator.h b/engine/inc/bullet/Bullet3Common/b3PoolAllocator.h
new file mode 100644
index 00000000..ed56bc62
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Common/b3PoolAllocator.h
@@ -0,0 +1,121 @@
+/*
+Copyright (c) 2003-2013 Gino van den Bergen / Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef _BT_POOL_ALLOCATOR_H
+#define _BT_POOL_ALLOCATOR_H
+
+#include "b3Scalar.h"
+#include "b3AlignedAllocator.h"
+
+///The b3PoolAllocator class allows to efficiently allocate a large pool of objects, instead of dynamically allocating them separately.
+class b3PoolAllocator
+{
+	int m_elemSize;
+	int m_maxElements;
+	int m_freeCount;
+	void* m_firstFree;
+	unsigned char* m_pool;
+
+public:
+	b3PoolAllocator(int elemSize, int maxElements)
+		: m_elemSize(elemSize),
+		  m_maxElements(maxElements)
+	{
+		m_pool = (unsigned char*)b3AlignedAlloc(static_cast<unsigned int>(m_elemSize * m_maxElements), 16);
+
+		unsigned char* p = m_pool;
+		m_firstFree = p;
+		m_freeCount = m_maxElements;
+		int count = m_maxElements;
+		while (--count)
+		{
+			*(void**)p = (p + m_elemSize);
+			p += m_elemSize;
+		}
+		*(void**)p = 0;
+	}
+
+	~b3PoolAllocator()
+	{
+		b3AlignedFree(m_pool);
+	}
+
+	int getFreeCount() const
+	{
+		return m_freeCount;
+	}
+
+	int getUsedCount() const
+	{
+		return m_maxElements - m_freeCount;
+	}
+
+	int getMaxCount() const
+	{
+		return m_maxElements;
+	}
+
+	void* allocate(int size)
+	{
+		// release mode fix
+		(void)size;
+		b3Assert(!size || size <= m_elemSize);
+		b3Assert(m_freeCount > 0);
+		void* result = m_firstFree;
+		m_firstFree = *(void**)m_firstFree;
+		--m_freeCount;
+		return result;
+	}
+
+	bool validPtr(void* ptr)
+	{
+		if (ptr)
+		{
+			if (((unsigned char*)ptr >= m_pool && (unsigned char*)ptr < m_pool + m_maxElements * m_elemSize))
+			{
+				return true;
+			}
+		}
+		return false;
+	}
+
+	void freeMemory(void* ptr)
+	{
+		if (ptr)
+		{
+			b3Assert((unsigned char*)ptr >= m_pool && (unsigned char*)ptr < m_pool + m_maxElements * m_elemSize);
+
+			*(void**)ptr = m_firstFree;
+			m_firstFree = ptr;
+			++m_freeCount;
+		}
+	}
+
+	int getElementSize() const
+	{
+		return m_elemSize;
+	}
+
+	unsigned char* getPoolAddress()
+	{
+		return m_pool;
+	}
+
+	const unsigned char* getPoolAddress() const
+	{
+		return m_pool;
+	}
+};
+
+#endif  //_BT_POOL_ALLOCATOR_H
diff --git a/engine/inc/bullet/Bullet3Common/b3QuadWord.h b/engine/inc/bullet/Bullet3Common/b3QuadWord.h
new file mode 100644
index 00000000..0def305f
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Common/b3QuadWord.h
@@ -0,0 +1,242 @@
+/*
+Copyright (c) 2003-2013 Gino van den Bergen / Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_SIMD_QUADWORD_H
+#define B3_SIMD_QUADWORD_H
+
+#include "b3Scalar.h"
+#include "b3MinMax.h"
+
+#if defined(__CELLOS_LV2) && defined(__SPU__)
+#include <altivec.h>
+#endif
+
+/**@brief The b3QuadWord class is base class for b3Vector3 and b3Quaternion. 
+ * Some issues under PS3 Linux with IBM 2.1 SDK, gcc compiler prevent from using aligned quadword.
+ */
+#ifndef USE_LIBSPE2
+B3_ATTRIBUTE_ALIGNED16(class)
+b3QuadWord
+#else
+class b3QuadWord
+#endif
+{
+protected:
+#if defined(__SPU__) && defined(__CELLOS_LV2__)
+	union {
+		vec_float4 mVec128;
+		b3Scalar m_floats[4];
+	};
+
+public:
+	vec_float4 get128() const
+	{
+		return mVec128;
+	}
+
+#else  //__CELLOS_LV2__ __SPU__
+
+#if defined(B3_USE_SSE) || defined(B3_USE_NEON)
+public:
+	union {
+		b3SimdFloat4 mVec128;
+		b3Scalar m_floats[4];
+		struct
+		{
+			b3Scalar x, y, z, w;
+		};
+	};
+
+public:
+	B3_FORCE_INLINE b3SimdFloat4 get128() const
+	{
+		return mVec128;
+	}
+	B3_FORCE_INLINE void set128(b3SimdFloat4 v128)
+	{
+		mVec128 = v128;
+	}
+#else
+public:
+	union {
+		b3Scalar m_floats[4];
+		struct
+		{
+			b3Scalar x, y, z, w;
+		};
+	};
+#endif  // B3_USE_SSE
+
+#endif  //__CELLOS_LV2__ __SPU__
+
+public:
+#if defined(B3_USE_SSE) || defined(B3_USE_NEON)
+
+	// Set Vector
+	B3_FORCE_INLINE b3QuadWord(const b3SimdFloat4 vec)
+	{
+		mVec128 = vec;
+	}
+
+	// Copy constructor
+	B3_FORCE_INLINE b3QuadWord(const b3QuadWord& rhs)
+	{
+		mVec128 = rhs.mVec128;
+	}
+
+	// Assignment Operator
+	B3_FORCE_INLINE b3QuadWord&
+	operator=(const b3QuadWord& v)
+	{
+		mVec128 = v.mVec128;
+
+		return *this;
+	}
+
+#endif
+
+	/**@brief Return the x value */
+	B3_FORCE_INLINE const b3Scalar& getX() const { return m_floats[0]; }
+	/**@brief Return the y value */
+	B3_FORCE_INLINE const b3Scalar& getY() const { return m_floats[1]; }
+	/**@brief Return the z value */
+	B3_FORCE_INLINE const b3Scalar& getZ() const { return m_floats[2]; }
+	/**@brief Set the x value */
+	B3_FORCE_INLINE void setX(b3Scalar _x) { m_floats[0] = _x; };
+	/**@brief Set the y value */
+	B3_FORCE_INLINE void setY(b3Scalar _y) { m_floats[1] = _y; };
+	/**@brief Set the z value */
+	B3_FORCE_INLINE void setZ(b3Scalar _z) { m_floats[2] = _z; };
+	/**@brief Set the w value */
+	B3_FORCE_INLINE void setW(b3Scalar _w) { m_floats[3] = _w; };
+	/**@brief Return the x value */
+
+	//B3_FORCE_INLINE b3Scalar&       operator[](int i)       { return (&m_floats[0])[i];	}
+	//B3_FORCE_INLINE const b3Scalar& operator[](int i) const { return (&m_floats[0])[i]; }
+	///operator b3Scalar*() replaces operator[], using implicit conversion. We added operator != and operator == to avoid pointer comparisons.
+	B3_FORCE_INLINE operator b3Scalar*() { return &m_floats[0]; }
+	B3_FORCE_INLINE operator const b3Scalar*() const { return &m_floats[0]; }
+
+	B3_FORCE_INLINE bool operator==(const b3QuadWord& other) const
+	{
+#ifdef B3_USE_SSE
+		return (0xf == _mm_movemask_ps((__m128)_mm_cmpeq_ps(mVec128, other.mVec128)));
+#else
+		return ((m_floats[3] == other.m_floats[3]) &&
+				(m_floats[2] == other.m_floats[2]) &&
+				(m_floats[1] == other.m_floats[1]) &&
+				(m_floats[0] == other.m_floats[0]));
+#endif
+	}
+
+	B3_FORCE_INLINE bool operator!=(const b3QuadWord& other) const
+	{
+		return !(*this == other);
+	}
+
+	/**@brief Set x,y,z and zero w 
+   * @param x Value of x
+   * @param y Value of y
+   * @param z Value of z
+   */
+	B3_FORCE_INLINE void setValue(const b3Scalar& _x, const b3Scalar& _y, const b3Scalar& _z)
+	{
+		m_floats[0] = _x;
+		m_floats[1] = _y;
+		m_floats[2] = _z;
+		m_floats[3] = 0.f;
+	}
+
+	/*		void getValue(b3Scalar *m) const 
+		{
+			m[0] = m_floats[0];
+			m[1] = m_floats[1];
+			m[2] = m_floats[2];
+		}
+*/
+	/**@brief Set the values 
+   * @param x Value of x
+   * @param y Value of y
+   * @param z Value of z
+   * @param w Value of w
+   */
+	B3_FORCE_INLINE void setValue(const b3Scalar& _x, const b3Scalar& _y, const b3Scalar& _z, const b3Scalar& _w)
+	{
+		m_floats[0] = _x;
+		m_floats[1] = _y;
+		m_floats[2] = _z;
+		m_floats[3] = _w;
+	}
+	/**@brief No initialization constructor */
+	B3_FORCE_INLINE b3QuadWord()
+	//	:m_floats[0](b3Scalar(0.)),m_floats[1](b3Scalar(0.)),m_floats[2](b3Scalar(0.)),m_floats[3](b3Scalar(0.))
+	{
+	}
+
+	/**@brief Three argument constructor (zeros w)
+   * @param x Value of x
+   * @param y Value of y
+   * @param z Value of z
+   */
+	B3_FORCE_INLINE b3QuadWord(const b3Scalar& _x, const b3Scalar& _y, const b3Scalar& _z)
+	{
+		m_floats[0] = _x, m_floats[1] = _y, m_floats[2] = _z, m_floats[3] = 0.0f;
+	}
+
+	/**@brief Initializing constructor
+   * @param x Value of x
+   * @param y Value of y
+   * @param z Value of z
+   * @param w Value of w
+   */
+	B3_FORCE_INLINE b3QuadWord(const b3Scalar& _x, const b3Scalar& _y, const b3Scalar& _z, const b3Scalar& _w)
+	{
+		m_floats[0] = _x, m_floats[1] = _y, m_floats[2] = _z, m_floats[3] = _w;
+	}
+
+	/**@brief Set each element to the max of the current values and the values of another b3QuadWord
+   * @param other The other b3QuadWord to compare with 
+   */
+	B3_FORCE_INLINE void setMax(const b3QuadWord& other)
+	{
+#ifdef B3_USE_SSE
+		mVec128 = _mm_max_ps(mVec128, other.mVec128);
+#elif defined(B3_USE_NEON)
+		mVec128 = vmaxq_f32(mVec128, other.mVec128);
+#else
+		b3SetMax(m_floats[0], other.m_floats[0]);
+		b3SetMax(m_floats[1], other.m_floats[1]);
+		b3SetMax(m_floats[2], other.m_floats[2]);
+		b3SetMax(m_floats[3], other.m_floats[3]);
+#endif
+	}
+	/**@brief Set each element to the min of the current values and the values of another b3QuadWord
+   * @param other The other b3QuadWord to compare with 
+   */
+	B3_FORCE_INLINE void setMin(const b3QuadWord& other)
+	{
+#ifdef B3_USE_SSE
+		mVec128 = _mm_min_ps(mVec128, other.mVec128);
+#elif defined(B3_USE_NEON)
+		mVec128 = vminq_f32(mVec128, other.mVec128);
+#else
+		b3SetMin(m_floats[0], other.m_floats[0]);
+		b3SetMin(m_floats[1], other.m_floats[1]);
+		b3SetMin(m_floats[2], other.m_floats[2]);
+		b3SetMin(m_floats[3], other.m_floats[3]);
+#endif
+	}
+};
+
+#endif  //B3_SIMD_QUADWORD_H
diff --git a/engine/inc/bullet/Bullet3Common/b3Quaternion.h b/engine/inc/bullet/Bullet3Common/b3Quaternion.h
new file mode 100644
index 00000000..4fdd72dc
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Common/b3Quaternion.h
@@ -0,0 +1,908 @@
+/*
+Copyright (c) 2003-2013 Gino van den Bergen / Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_SIMD__QUATERNION_H_
+#define B3_SIMD__QUATERNION_H_
+
+#include "b3Vector3.h"
+#include "b3QuadWord.h"
+
+#ifdef B3_USE_SSE
+
+const __m128 B3_ATTRIBUTE_ALIGNED16(b3vOnes) = {1.0f, 1.0f, 1.0f, 1.0f};
+
+#endif
+
+#if defined(B3_USE_SSE) || defined(B3_USE_NEON)
+
+const b3SimdFloat4 B3_ATTRIBUTE_ALIGNED16(b3vQInv) = {-0.0f, -0.0f, -0.0f, +0.0f};
+const b3SimdFloat4 B3_ATTRIBUTE_ALIGNED16(b3vPPPM) = {+0.0f, +0.0f, +0.0f, -0.0f};
+
+#endif
+
+/**@brief The b3Quaternion implements quaternion to perform linear algebra rotations in combination with b3Matrix3x3, b3Vector3 and b3Transform. */
+class b3Quaternion : public b3QuadWord
+{
+public:
+	/**@brief No initialization constructor */
+	b3Quaternion() {}
+
+#if (defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)) || defined(B3_USE_NEON)
+	// Set Vector
+	B3_FORCE_INLINE b3Quaternion(const b3SimdFloat4 vec)
+	{
+		mVec128 = vec;
+	}
+
+	// Copy constructor
+	B3_FORCE_INLINE b3Quaternion(const b3Quaternion& rhs)
+	{
+		mVec128 = rhs.mVec128;
+	}
+
+	// Assignment Operator
+	B3_FORCE_INLINE b3Quaternion&
+	operator=(const b3Quaternion& v)
+	{
+		mVec128 = v.mVec128;
+
+		return *this;
+	}
+
+#endif
+
+	//		template <typename b3Scalar>
+	//		explicit Quaternion(const b3Scalar *v) : Tuple4<b3Scalar>(v) {}
+	/**@brief Constructor from scalars */
+	b3Quaternion(const b3Scalar& _x, const b3Scalar& _y, const b3Scalar& _z, const b3Scalar& _w)
+		: b3QuadWord(_x, _y, _z, _w)
+	{
+		//b3Assert(!((_x==1.f) && (_y==0.f) && (_z==0.f) && (_w==0.f)));
+	}
+	/**@brief Axis angle Constructor
+   * @param axis The axis which the rotation is around
+   * @param angle The magnitude of the rotation around the angle (Radians) */
+	b3Quaternion(const b3Vector3& _axis, const b3Scalar& _angle)
+	{
+		setRotation(_axis, _angle);
+	}
+	/**@brief Constructor from Euler angles
+   * @param yaw Angle around Y unless B3_EULER_DEFAULT_ZYX defined then Z
+   * @param pitch Angle around X unless B3_EULER_DEFAULT_ZYX defined then Y
+   * @param roll Angle around Z unless B3_EULER_DEFAULT_ZYX defined then X */
+	b3Quaternion(const b3Scalar& yaw, const b3Scalar& pitch, const b3Scalar& roll)
+	{
+#ifndef B3_EULER_DEFAULT_ZYX
+		setEuler(yaw, pitch, roll);
+#else
+		setEulerZYX(yaw, pitch, roll);
+#endif
+	}
+	/**@brief Set the rotation using axis angle notation 
+   * @param axis The axis around which to rotate
+   * @param angle The magnitude of the rotation in Radians */
+	void setRotation(const b3Vector3& axis1, const b3Scalar& _angle)
+	{
+		b3Vector3 axis = axis1;
+		axis.safeNormalize();
+		
+		b3Scalar d = axis.length();
+		b3Assert(d != b3Scalar(0.0));
+		if (d < B3_EPSILON)
+		{
+			setValue(0, 0, 0, 1);
+		}
+		else
+		{
+			b3Scalar s = b3Sin(_angle * b3Scalar(0.5)) / d;
+			setValue(axis.getX() * s, axis.getY() * s, axis.getZ() * s,
+				b3Cos(_angle * b3Scalar(0.5)));
+		}
+	}
+	/**@brief Set the quaternion using Euler angles
+   * @param yaw Angle around Y
+   * @param pitch Angle around X
+   * @param roll Angle around Z */
+	void setEuler(const b3Scalar& yaw, const b3Scalar& pitch, const b3Scalar& roll)
+	{
+		b3Scalar halfYaw = b3Scalar(yaw) * b3Scalar(0.5);
+		b3Scalar halfPitch = b3Scalar(pitch) * b3Scalar(0.5);
+		b3Scalar halfRoll = b3Scalar(roll) * b3Scalar(0.5);
+		b3Scalar cosYaw = b3Cos(halfYaw);
+		b3Scalar sinYaw = b3Sin(halfYaw);
+		b3Scalar cosPitch = b3Cos(halfPitch);
+		b3Scalar sinPitch = b3Sin(halfPitch);
+		b3Scalar cosRoll = b3Cos(halfRoll);
+		b3Scalar sinRoll = b3Sin(halfRoll);
+		setValue(cosRoll * sinPitch * cosYaw + sinRoll * cosPitch * sinYaw,
+				 cosRoll * cosPitch * sinYaw - sinRoll * sinPitch * cosYaw,
+				 sinRoll * cosPitch * cosYaw - cosRoll * sinPitch * sinYaw,
+				 cosRoll * cosPitch * cosYaw + sinRoll * sinPitch * sinYaw);
+	}
+
+	/**@brief Set the quaternion using euler angles 
+   * @param yaw Angle around Z
+   * @param pitch Angle around Y
+   * @param roll Angle around X */
+	void setEulerZYX(const b3Scalar& yawZ, const b3Scalar& pitchY, const b3Scalar& rollX)
+	{
+		b3Scalar halfYaw = b3Scalar(yawZ) * b3Scalar(0.5);
+		b3Scalar halfPitch = b3Scalar(pitchY) * b3Scalar(0.5);
+		b3Scalar halfRoll = b3Scalar(rollX) * b3Scalar(0.5);
+		b3Scalar cosYaw = b3Cos(halfYaw);
+		b3Scalar sinYaw = b3Sin(halfYaw);
+		b3Scalar cosPitch = b3Cos(halfPitch);
+		b3Scalar sinPitch = b3Sin(halfPitch);
+		b3Scalar cosRoll = b3Cos(halfRoll);
+		b3Scalar sinRoll = b3Sin(halfRoll);
+		setValue(sinRoll * cosPitch * cosYaw - cosRoll * sinPitch * sinYaw,   //x
+				 cosRoll * sinPitch * cosYaw + sinRoll * cosPitch * sinYaw,   //y
+				 cosRoll * cosPitch * sinYaw - sinRoll * sinPitch * cosYaw,   //z
+				 cosRoll * cosPitch * cosYaw + sinRoll * sinPitch * sinYaw);  //formerly yzx
+		normalize();
+	}
+
+	/**@brief Get the euler angles from this quaternion
+	   * @param yaw Angle around Z
+	   * @param pitch Angle around Y
+	   * @param roll Angle around X */
+	void getEulerZYX(b3Scalar& yawZ, b3Scalar& pitchY, b3Scalar& rollX) const
+	{
+		b3Scalar squ;
+		b3Scalar sqx;
+		b3Scalar sqy;
+		b3Scalar sqz;
+		b3Scalar sarg;
+		sqx = m_floats[0] * m_floats[0];
+		sqy = m_floats[1] * m_floats[1];
+		sqz = m_floats[2] * m_floats[2];
+		squ = m_floats[3] * m_floats[3];
+		rollX = b3Atan2(2 * (m_floats[1] * m_floats[2] + m_floats[3] * m_floats[0]), squ - sqx - sqy + sqz);
+		sarg = b3Scalar(-2.) * (m_floats[0] * m_floats[2] - m_floats[3] * m_floats[1]);
+		pitchY = sarg <= b3Scalar(-1.0) ? b3Scalar(-0.5) * B3_PI : (sarg >= b3Scalar(1.0) ? b3Scalar(0.5) * B3_PI : b3Asin(sarg));
+		yawZ = b3Atan2(2 * (m_floats[0] * m_floats[1] + m_floats[3] * m_floats[2]), squ + sqx - sqy - sqz);
+	}
+
+	/**@brief Add two quaternions
+   * @param q The quaternion to add to this one */
+	B3_FORCE_INLINE b3Quaternion& operator+=(const b3Quaternion& q)
+	{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+		mVec128 = _mm_add_ps(mVec128, q.mVec128);
+#elif defined(B3_USE_NEON)
+		mVec128 = vaddq_f32(mVec128, q.mVec128);
+#else
+		m_floats[0] += q.getX();
+		m_floats[1] += q.getY();
+		m_floats[2] += q.getZ();
+		m_floats[3] += q.m_floats[3];
+#endif
+		return *this;
+	}
+
+	/**@brief Subtract out a quaternion
+   * @param q The quaternion to subtract from this one */
+	b3Quaternion& operator-=(const b3Quaternion& q)
+	{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+		mVec128 = _mm_sub_ps(mVec128, q.mVec128);
+#elif defined(B3_USE_NEON)
+		mVec128 = vsubq_f32(mVec128, q.mVec128);
+#else
+		m_floats[0] -= q.getX();
+		m_floats[1] -= q.getY();
+		m_floats[2] -= q.getZ();
+		m_floats[3] -= q.m_floats[3];
+#endif
+		return *this;
+	}
+
+	/**@brief Scale this quaternion
+   * @param s The scalar to scale by */
+	b3Quaternion& operator*=(const b3Scalar& s)
+	{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+		__m128 vs = _mm_load_ss(&s);  //	(S 0 0 0)
+		vs = b3_pshufd_ps(vs, 0);     //	(S S S S)
+		mVec128 = _mm_mul_ps(mVec128, vs);
+#elif defined(B3_USE_NEON)
+		mVec128 = vmulq_n_f32(mVec128, s);
+#else
+		m_floats[0] *= s;
+		m_floats[1] *= s;
+		m_floats[2] *= s;
+		m_floats[3] *= s;
+#endif
+		return *this;
+	}
+
+	/**@brief Multiply this quaternion by q on the right
+   * @param q The other quaternion 
+   * Equivilant to this = this * q */
+	b3Quaternion& operator*=(const b3Quaternion& q)
+	{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+		__m128 vQ2 = q.get128();
+
+		__m128 A1 = b3_pshufd_ps(mVec128, B3_SHUFFLE(0, 1, 2, 0));
+		__m128 B1 = b3_pshufd_ps(vQ2, B3_SHUFFLE(3, 3, 3, 0));
+
+		A1 = A1 * B1;
+
+		__m128 A2 = b3_pshufd_ps(mVec128, B3_SHUFFLE(1, 2, 0, 1));
+		__m128 B2 = b3_pshufd_ps(vQ2, B3_SHUFFLE(2, 0, 1, 1));
+
+		A2 = A2 * B2;
+
+		B1 = b3_pshufd_ps(mVec128, B3_SHUFFLE(2, 0, 1, 2));
+		B2 = b3_pshufd_ps(vQ2, B3_SHUFFLE(1, 2, 0, 2));
+
+		B1 = B1 * B2;  //	A3 *= B3
+
+		mVec128 = b3_splat_ps(mVec128, 3);  //	A0
+		mVec128 = mVec128 * vQ2;            //	A0 * B0
+
+		A1 = A1 + A2;                  //	AB12
+		mVec128 = mVec128 - B1;        //	AB03 = AB0 - AB3
+		A1 = _mm_xor_ps(A1, b3vPPPM);  //	change sign of the last element
+		mVec128 = mVec128 + A1;        //	AB03 + AB12
+
+#elif defined(B3_USE_NEON)
+
+		float32x4_t vQ1 = mVec128;
+		float32x4_t vQ2 = q.get128();
+		float32x4_t A0, A1, B1, A2, B2, A3, B3;
+		float32x2_t vQ1zx, vQ2wx, vQ1yz, vQ2zx, vQ2yz, vQ2xz;
+
+		{
+			float32x2x2_t tmp;
+			tmp = vtrn_f32(vget_high_f32(vQ1), vget_low_f32(vQ1));  // {z x}, {w y}
+			vQ1zx = tmp.val[0];
+
+			tmp = vtrn_f32(vget_high_f32(vQ2), vget_low_f32(vQ2));  // {z x}, {w y}
+			vQ2zx = tmp.val[0];
+		}
+		vQ2wx = vext_f32(vget_high_f32(vQ2), vget_low_f32(vQ2), 1);
+
+		vQ1yz = vext_f32(vget_low_f32(vQ1), vget_high_f32(vQ1), 1);
+
+		vQ2yz = vext_f32(vget_low_f32(vQ2), vget_high_f32(vQ2), 1);
+		vQ2xz = vext_f32(vQ2zx, vQ2zx, 1);
+
+		A1 = vcombine_f32(vget_low_f32(vQ1), vQ1zx);                     // X Y  z x
+		B1 = vcombine_f32(vdup_lane_f32(vget_high_f32(vQ2), 1), vQ2wx);  // W W  W X
+
+		A2 = vcombine_f32(vQ1yz, vget_low_f32(vQ1));
+		B2 = vcombine_f32(vQ2zx, vdup_lane_f32(vget_low_f32(vQ2), 1));
+
+		A3 = vcombine_f32(vQ1zx, vQ1yz);  // Z X Y Z
+		B3 = vcombine_f32(vQ2yz, vQ2xz);  // Y Z x z
+
+		A1 = vmulq_f32(A1, B1);
+		A2 = vmulq_f32(A2, B2);
+		A3 = vmulq_f32(A3, B3);                           //	A3 *= B3
+		A0 = vmulq_lane_f32(vQ2, vget_high_f32(vQ1), 1);  //	A0 * B0
+
+		A1 = vaddq_f32(A1, A2);  //	AB12 = AB1 + AB2
+		A0 = vsubq_f32(A0, A3);  //	AB03 = AB0 - AB3
+
+		//	change the sign of the last element
+		A1 = (b3SimdFloat4)veorq_s32((int32x4_t)A1, (int32x4_t)b3vPPPM);
+		A0 = vaddq_f32(A0, A1);  //	AB03 + AB12
+
+		mVec128 = A0;
+#else
+		setValue(
+			m_floats[3] * q.getX() + m_floats[0] * q.m_floats[3] + m_floats[1] * q.getZ() - m_floats[2] * q.getY(),
+			m_floats[3] * q.getY() + m_floats[1] * q.m_floats[3] + m_floats[2] * q.getX() - m_floats[0] * q.getZ(),
+			m_floats[3] * q.getZ() + m_floats[2] * q.m_floats[3] + m_floats[0] * q.getY() - m_floats[1] * q.getX(),
+			m_floats[3] * q.m_floats[3] - m_floats[0] * q.getX() - m_floats[1] * q.getY() - m_floats[2] * q.getZ());
+#endif
+		return *this;
+	}
+	/**@brief Return the dot product between this quaternion and another
+   * @param q The other quaternion */
+	b3Scalar dot(const b3Quaternion& q) const
+	{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+		__m128 vd;
+
+		vd = _mm_mul_ps(mVec128, q.mVec128);
+
+		__m128 t = _mm_movehl_ps(vd, vd);
+		vd = _mm_add_ps(vd, t);
+		t = _mm_shuffle_ps(vd, vd, 0x55);
+		vd = _mm_add_ss(vd, t);
+
+		return _mm_cvtss_f32(vd);
+#elif defined(B3_USE_NEON)
+		float32x4_t vd = vmulq_f32(mVec128, q.mVec128);
+		float32x2_t x = vpadd_f32(vget_low_f32(vd), vget_high_f32(vd));
+		x = vpadd_f32(x, x);
+		return vget_lane_f32(x, 0);
+#else
+		return m_floats[0] * q.getX() +
+			   m_floats[1] * q.getY() +
+			   m_floats[2] * q.getZ() +
+			   m_floats[3] * q.m_floats[3];
+#endif
+	}
+
+	/**@brief Return the length squared of the quaternion */
+	b3Scalar length2() const
+	{
+		return dot(*this);
+	}
+
+	/**@brief Return the length of the quaternion */
+	b3Scalar length() const
+	{
+		return b3Sqrt(length2());
+	}
+
+	/**@brief Normalize the quaternion 
+   * Such that x^2 + y^2 + z^2 +w^2 = 1 */
+	b3Quaternion& normalize()
+	{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+		__m128 vd;
+
+		vd = _mm_mul_ps(mVec128, mVec128);
+
+		__m128 t = _mm_movehl_ps(vd, vd);
+		vd = _mm_add_ps(vd, t);
+		t = _mm_shuffle_ps(vd, vd, 0x55);
+		vd = _mm_add_ss(vd, t);
+
+		vd = _mm_sqrt_ss(vd);
+		vd = _mm_div_ss(b3vOnes, vd);
+		vd = b3_pshufd_ps(vd, 0);  // splat
+		mVec128 = _mm_mul_ps(mVec128, vd);
+
+		return *this;
+#else
+		return *this /= length();
+#endif
+	}
+
+	/**@brief Return a scaled version of this quaternion
+   * @param s The scale factor */
+	B3_FORCE_INLINE b3Quaternion
+	operator*(const b3Scalar& s) const
+	{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+		__m128 vs = _mm_load_ss(&s);  //	(S 0 0 0)
+		vs = b3_pshufd_ps(vs, 0x00);  //	(S S S S)
+
+		return b3Quaternion(_mm_mul_ps(mVec128, vs));
+#elif defined(B3_USE_NEON)
+		return b3Quaternion(vmulq_n_f32(mVec128, s));
+#else
+		return b3Quaternion(getX() * s, getY() * s, getZ() * s, m_floats[3] * s);
+#endif
+	}
+
+	/**@brief Return an inversely scaled versionof this quaternion
+   * @param s The inverse scale factor */
+	b3Quaternion operator/(const b3Scalar& s) const
+	{
+		b3Assert(s != b3Scalar(0.0));
+		return *this * (b3Scalar(1.0) / s);
+	}
+
+	/**@brief Inversely scale this quaternion
+   * @param s The scale factor */
+	b3Quaternion& operator/=(const b3Scalar& s)
+	{
+		b3Assert(s != b3Scalar(0.0));
+		return *this *= b3Scalar(1.0) / s;
+	}
+
+	/**@brief Return a normalized version of this quaternion */
+	b3Quaternion normalized() const
+	{
+		return *this / length();
+	}
+	/**@brief Return the angle between this quaternion and the other 
+   * @param q The other quaternion */
+	b3Scalar angle(const b3Quaternion& q) const
+	{
+		b3Scalar s = b3Sqrt(length2() * q.length2());
+		b3Assert(s != b3Scalar(0.0));
+		return b3Acos(dot(q) / s);
+	}
+	/**@brief Return the angle of rotation represented by this quaternion */
+	b3Scalar getAngle() const
+	{
+		b3Scalar s = b3Scalar(2.) * b3Acos(m_floats[3]);
+		return s;
+	}
+
+	/**@brief Return the axis of the rotation represented by this quaternion */
+	b3Vector3 getAxis() const
+	{
+		b3Scalar s_squared = 1.f - m_floats[3] * m_floats[3];
+
+		if (s_squared < b3Scalar(10.) * B3_EPSILON)  //Check for divide by zero
+			return b3MakeVector3(1.0, 0.0, 0.0);     // Arbitrary
+		b3Scalar s = 1.f / b3Sqrt(s_squared);
+		return b3MakeVector3(m_floats[0] * s, m_floats[1] * s, m_floats[2] * s);
+	}
+
+	/**@brief Return the inverse of this quaternion */
+	b3Quaternion inverse() const
+	{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+		return b3Quaternion(_mm_xor_ps(mVec128, b3vQInv));
+#elif defined(B3_USE_NEON)
+		return b3Quaternion((b3SimdFloat4)veorq_s32((int32x4_t)mVec128, (int32x4_t)b3vQInv));
+#else
+		return b3Quaternion(-m_floats[0], -m_floats[1], -m_floats[2], m_floats[3]);
+#endif
+	}
+
+	/**@brief Return the sum of this quaternion and the other 
+   * @param q2 The other quaternion */
+	B3_FORCE_INLINE b3Quaternion
+	operator+(const b3Quaternion& q2) const
+	{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+		return b3Quaternion(_mm_add_ps(mVec128, q2.mVec128));
+#elif defined(B3_USE_NEON)
+		return b3Quaternion(vaddq_f32(mVec128, q2.mVec128));
+#else
+		const b3Quaternion& q1 = *this;
+		return b3Quaternion(q1.getX() + q2.getX(), q1.getY() + q2.getY(), q1.getZ() + q2.getZ(), q1.m_floats[3] + q2.m_floats[3]);
+#endif
+	}
+
+	/**@brief Return the difference between this quaternion and the other 
+   * @param q2 The other quaternion */
+	B3_FORCE_INLINE b3Quaternion
+	operator-(const b3Quaternion& q2) const
+	{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+		return b3Quaternion(_mm_sub_ps(mVec128, q2.mVec128));
+#elif defined(B3_USE_NEON)
+		return b3Quaternion(vsubq_f32(mVec128, q2.mVec128));
+#else
+		const b3Quaternion& q1 = *this;
+		return b3Quaternion(q1.getX() - q2.getX(), q1.getY() - q2.getY(), q1.getZ() - q2.getZ(), q1.m_floats[3] - q2.m_floats[3]);
+#endif
+	}
+
+	/**@brief Return the negative of this quaternion 
+   * This simply negates each element */
+	B3_FORCE_INLINE b3Quaternion operator-() const
+	{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+		return b3Quaternion(_mm_xor_ps(mVec128, b3vMzeroMask));
+#elif defined(B3_USE_NEON)
+		return b3Quaternion((b3SimdFloat4)veorq_s32((int32x4_t)mVec128, (int32x4_t)b3vMzeroMask));
+#else
+		const b3Quaternion& q2 = *this;
+		return b3Quaternion(-q2.getX(), -q2.getY(), -q2.getZ(), -q2.m_floats[3]);
+#endif
+	}
+	/**@todo document this and it's use */
+	B3_FORCE_INLINE b3Quaternion farthest(const b3Quaternion& qd) const
+	{
+		b3Quaternion diff, sum;
+		diff = *this - qd;
+		sum = *this + qd;
+		if (diff.dot(diff) > sum.dot(sum))
+			return qd;
+		return (-qd);
+	}
+
+	/**@todo document this and it's use */
+	B3_FORCE_INLINE b3Quaternion nearest(const b3Quaternion& qd) const
+	{
+		b3Quaternion diff, sum;
+		diff = *this - qd;
+		sum = *this + qd;
+		if (diff.dot(diff) < sum.dot(sum))
+			return qd;
+		return (-qd);
+	}
+
+	/**@brief Return the quaternion which is the result of Spherical Linear Interpolation between this and the other quaternion
+   * @param q The other quaternion to interpolate with 
+   * @param t The ratio between this and q to interpolate.  If t = 0 the result is this, if t=1 the result is q.
+   * Slerp interpolates assuming constant velocity.  */
+	b3Quaternion slerp(const b3Quaternion& q, const b3Scalar& t) const
+	{
+		b3Scalar magnitude = b3Sqrt(length2() * q.length2());
+		b3Assert(magnitude > b3Scalar(0));
+
+		b3Scalar product = dot(q) / magnitude;
+		if (b3Fabs(product) < b3Scalar(1))
+		{
+			// Take care of long angle case see http://en.wikipedia.org/wiki/Slerp
+			const b3Scalar sign = (product < 0) ? b3Scalar(-1) : b3Scalar(1);
+
+			const b3Scalar theta = b3Acos(sign * product);
+			const b3Scalar s1 = b3Sin(sign * t * theta);
+			const b3Scalar d = b3Scalar(1.0) / b3Sin(theta);
+			const b3Scalar s0 = b3Sin((b3Scalar(1.0) - t) * theta);
+
+			return b3Quaternion(
+				(m_floats[0] * s0 + q.getX() * s1) * d,
+				(m_floats[1] * s0 + q.getY() * s1) * d,
+				(m_floats[2] * s0 + q.getZ() * s1) * d,
+				(m_floats[3] * s0 + q.m_floats[3] * s1) * d);
+		}
+		else
+		{
+			return *this;
+		}
+	}
+
+	static const b3Quaternion& getIdentity()
+	{
+		static const b3Quaternion identityQuat(b3Scalar(0.), b3Scalar(0.), b3Scalar(0.), b3Scalar(1.));
+		return identityQuat;
+	}
+
+	B3_FORCE_INLINE const b3Scalar& getW() const { return m_floats[3]; }
+};
+
+/**@brief Return the product of two quaternions */
+B3_FORCE_INLINE b3Quaternion
+operator*(const b3Quaternion& q1, const b3Quaternion& q2)
+{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+	__m128 vQ1 = q1.get128();
+	__m128 vQ2 = q2.get128();
+	__m128 A0, A1, B1, A2, B2;
+
+	A1 = b3_pshufd_ps(vQ1, B3_SHUFFLE(0, 1, 2, 0));  // X Y  z x     //      vtrn
+	B1 = b3_pshufd_ps(vQ2, B3_SHUFFLE(3, 3, 3, 0));  // W W  W X     // vdup vext
+
+	A1 = A1 * B1;
+
+	A2 = b3_pshufd_ps(vQ1, B3_SHUFFLE(1, 2, 0, 1));  // Y Z  X Y     // vext
+	B2 = b3_pshufd_ps(vQ2, B3_SHUFFLE(2, 0, 1, 1));  // z x  Y Y     // vtrn vdup
+
+	A2 = A2 * B2;
+
+	B1 = b3_pshufd_ps(vQ1, B3_SHUFFLE(2, 0, 1, 2));  // z x Y Z      // vtrn vext
+	B2 = b3_pshufd_ps(vQ2, B3_SHUFFLE(1, 2, 0, 2));  // Y Z x z      // vext vtrn
+
+	B1 = B1 * B2;  //	A3 *= B3
+
+	A0 = b3_splat_ps(vQ1, 3);  //	A0
+	A0 = A0 * vQ2;             //	A0 * B0
+
+	A1 = A1 + A2;  //	AB12
+	A0 = A0 - B1;  //	AB03 = AB0 - AB3
+
+	A1 = _mm_xor_ps(A1, b3vPPPM);  //	change sign of the last element
+	A0 = A0 + A1;                  //	AB03 + AB12
+
+	return b3Quaternion(A0);
+
+#elif defined(B3_USE_NEON)
+
+	float32x4_t vQ1 = q1.get128();
+	float32x4_t vQ2 = q2.get128();
+	float32x4_t A0, A1, B1, A2, B2, A3, B3;
+	float32x2_t vQ1zx, vQ2wx, vQ1yz, vQ2zx, vQ2yz, vQ2xz;
+
+	{
+		float32x2x2_t tmp;
+		tmp = vtrn_f32(vget_high_f32(vQ1), vget_low_f32(vQ1));  // {z x}, {w y}
+		vQ1zx = tmp.val[0];
+
+		tmp = vtrn_f32(vget_high_f32(vQ2), vget_low_f32(vQ2));  // {z x}, {w y}
+		vQ2zx = tmp.val[0];
+	}
+	vQ2wx = vext_f32(vget_high_f32(vQ2), vget_low_f32(vQ2), 1);
+
+	vQ1yz = vext_f32(vget_low_f32(vQ1), vget_high_f32(vQ1), 1);
+
+	vQ2yz = vext_f32(vget_low_f32(vQ2), vget_high_f32(vQ2), 1);
+	vQ2xz = vext_f32(vQ2zx, vQ2zx, 1);
+
+	A1 = vcombine_f32(vget_low_f32(vQ1), vQ1zx);                     // X Y  z x
+	B1 = vcombine_f32(vdup_lane_f32(vget_high_f32(vQ2), 1), vQ2wx);  // W W  W X
+
+	A2 = vcombine_f32(vQ1yz, vget_low_f32(vQ1));
+	B2 = vcombine_f32(vQ2zx, vdup_lane_f32(vget_low_f32(vQ2), 1));
+
+	A3 = vcombine_f32(vQ1zx, vQ1yz);  // Z X Y Z
+	B3 = vcombine_f32(vQ2yz, vQ2xz);  // Y Z x z
+
+	A1 = vmulq_f32(A1, B1);
+	A2 = vmulq_f32(A2, B2);
+	A3 = vmulq_f32(A3, B3);                           //	A3 *= B3
+	A0 = vmulq_lane_f32(vQ2, vget_high_f32(vQ1), 1);  //	A0 * B0
+
+	A1 = vaddq_f32(A1, A2);  //	AB12 = AB1 + AB2
+	A0 = vsubq_f32(A0, A3);  //	AB03 = AB0 - AB3
+
+	//	change the sign of the last element
+	A1 = (b3SimdFloat4)veorq_s32((int32x4_t)A1, (int32x4_t)b3vPPPM);
+	A0 = vaddq_f32(A0, A1);  //	AB03 + AB12
+
+	return b3Quaternion(A0);
+
+#else
+	return b3Quaternion(
+		q1.getW() * q2.getX() + q1.getX() * q2.getW() + q1.getY() * q2.getZ() - q1.getZ() * q2.getY(),
+		q1.getW() * q2.getY() + q1.getY() * q2.getW() + q1.getZ() * q2.getX() - q1.getX() * q2.getZ(),
+		q1.getW() * q2.getZ() + q1.getZ() * q2.getW() + q1.getX() * q2.getY() - q1.getY() * q2.getX(),
+		q1.getW() * q2.getW() - q1.getX() * q2.getX() - q1.getY() * q2.getY() - q1.getZ() * q2.getZ());
+#endif
+}
+
+B3_FORCE_INLINE b3Quaternion
+operator*(const b3Quaternion& q, const b3Vector3& w)
+{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+	__m128 vQ1 = q.get128();
+	__m128 vQ2 = w.get128();
+	__m128 A1, B1, A2, B2, A3, B3;
+
+	A1 = b3_pshufd_ps(vQ1, B3_SHUFFLE(3, 3, 3, 0));
+	B1 = b3_pshufd_ps(vQ2, B3_SHUFFLE(0, 1, 2, 0));
+
+	A1 = A1 * B1;
+
+	A2 = b3_pshufd_ps(vQ1, B3_SHUFFLE(1, 2, 0, 1));
+	B2 = b3_pshufd_ps(vQ2, B3_SHUFFLE(2, 0, 1, 1));
+
+	A2 = A2 * B2;
+
+	A3 = b3_pshufd_ps(vQ1, B3_SHUFFLE(2, 0, 1, 2));
+	B3 = b3_pshufd_ps(vQ2, B3_SHUFFLE(1, 2, 0, 2));
+
+	A3 = A3 * B3;  //	A3 *= B3
+
+	A1 = A1 + A2;                  //	AB12
+	A1 = _mm_xor_ps(A1, b3vPPPM);  //	change sign of the last element
+	A1 = A1 - A3;                  //	AB123 = AB12 - AB3
+
+	return b3Quaternion(A1);
+
+#elif defined(B3_USE_NEON)
+
+	float32x4_t vQ1 = q.get128();
+	float32x4_t vQ2 = w.get128();
+	float32x4_t A1, B1, A2, B2, A3, B3;
+	float32x2_t vQ1wx, vQ2zx, vQ1yz, vQ2yz, vQ1zx, vQ2xz;
+
+	vQ1wx = vext_f32(vget_high_f32(vQ1), vget_low_f32(vQ1), 1);
+	{
+		float32x2x2_t tmp;
+
+		tmp = vtrn_f32(vget_high_f32(vQ2), vget_low_f32(vQ2));  // {z x}, {w y}
+		vQ2zx = tmp.val[0];
+
+		tmp = vtrn_f32(vget_high_f32(vQ1), vget_low_f32(vQ1));  // {z x}, {w y}
+		vQ1zx = tmp.val[0];
+	}
+
+	vQ1yz = vext_f32(vget_low_f32(vQ1), vget_high_f32(vQ1), 1);
+
+	vQ2yz = vext_f32(vget_low_f32(vQ2), vget_high_f32(vQ2), 1);
+	vQ2xz = vext_f32(vQ2zx, vQ2zx, 1);
+
+	A1 = vcombine_f32(vdup_lane_f32(vget_high_f32(vQ1), 1), vQ1wx);  // W W  W X
+	B1 = vcombine_f32(vget_low_f32(vQ2), vQ2zx);                     // X Y  z x
+
+	A2 = vcombine_f32(vQ1yz, vget_low_f32(vQ1));
+	B2 = vcombine_f32(vQ2zx, vdup_lane_f32(vget_low_f32(vQ2), 1));
+
+	A3 = vcombine_f32(vQ1zx, vQ1yz);  // Z X Y Z
+	B3 = vcombine_f32(vQ2yz, vQ2xz);  // Y Z x z
+
+	A1 = vmulq_f32(A1, B1);
+	A2 = vmulq_f32(A2, B2);
+	A3 = vmulq_f32(A3, B3);  //	A3 *= B3
+
+	A1 = vaddq_f32(A1, A2);  //	AB12 = AB1 + AB2
+
+	//	change the sign of the last element
+	A1 = (b3SimdFloat4)veorq_s32((int32x4_t)A1, (int32x4_t)b3vPPPM);
+
+	A1 = vsubq_f32(A1, A3);  //	AB123 = AB12 - AB3
+
+	return b3Quaternion(A1);
+
+#else
+	return b3Quaternion(
+		q.getW() * w.getX() + q.getY() * w.getZ() - q.getZ() * w.getY(),
+		q.getW() * w.getY() + q.getZ() * w.getX() - q.getX() * w.getZ(),
+		q.getW() * w.getZ() + q.getX() * w.getY() - q.getY() * w.getX(),
+		-q.getX() * w.getX() - q.getY() * w.getY() - q.getZ() * w.getZ());
+#endif
+}
+
+B3_FORCE_INLINE b3Quaternion
+operator*(const b3Vector3& w, const b3Quaternion& q)
+{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+	__m128 vQ1 = w.get128();
+	__m128 vQ2 = q.get128();
+	__m128 A1, B1, A2, B2, A3, B3;
+
+	A1 = b3_pshufd_ps(vQ1, B3_SHUFFLE(0, 1, 2, 0));  // X Y  z x
+	B1 = b3_pshufd_ps(vQ2, B3_SHUFFLE(3, 3, 3, 0));  // W W  W X
+
+	A1 = A1 * B1;
+
+	A2 = b3_pshufd_ps(vQ1, B3_SHUFFLE(1, 2, 0, 1));
+	B2 = b3_pshufd_ps(vQ2, B3_SHUFFLE(2, 0, 1, 1));
+
+	A2 = A2 * B2;
+
+	A3 = b3_pshufd_ps(vQ1, B3_SHUFFLE(2, 0, 1, 2));
+	B3 = b3_pshufd_ps(vQ2, B3_SHUFFLE(1, 2, 0, 2));
+
+	A3 = A3 * B3;  //	A3 *= B3
+
+	A1 = A1 + A2;                  //	AB12
+	A1 = _mm_xor_ps(A1, b3vPPPM);  //	change sign of the last element
+	A1 = A1 - A3;                  //	AB123 = AB12 - AB3
+
+	return b3Quaternion(A1);
+
+#elif defined(B3_USE_NEON)
+
+	float32x4_t vQ1 = w.get128();
+	float32x4_t vQ2 = q.get128();
+	float32x4_t A1, B1, A2, B2, A3, B3;
+	float32x2_t vQ1zx, vQ2wx, vQ1yz, vQ2zx, vQ2yz, vQ2xz;
+
+	{
+		float32x2x2_t tmp;
+
+		tmp = vtrn_f32(vget_high_f32(vQ1), vget_low_f32(vQ1));  // {z x}, {w y}
+		vQ1zx = tmp.val[0];
+
+		tmp = vtrn_f32(vget_high_f32(vQ2), vget_low_f32(vQ2));  // {z x}, {w y}
+		vQ2zx = tmp.val[0];
+	}
+	vQ2wx = vext_f32(vget_high_f32(vQ2), vget_low_f32(vQ2), 1);
+
+	vQ1yz = vext_f32(vget_low_f32(vQ1), vget_high_f32(vQ1), 1);
+
+	vQ2yz = vext_f32(vget_low_f32(vQ2), vget_high_f32(vQ2), 1);
+	vQ2xz = vext_f32(vQ2zx, vQ2zx, 1);
+
+	A1 = vcombine_f32(vget_low_f32(vQ1), vQ1zx);                     // X Y  z x
+	B1 = vcombine_f32(vdup_lane_f32(vget_high_f32(vQ2), 1), vQ2wx);  // W W  W X
+
+	A2 = vcombine_f32(vQ1yz, vget_low_f32(vQ1));
+	B2 = vcombine_f32(vQ2zx, vdup_lane_f32(vget_low_f32(vQ2), 1));
+
+	A3 = vcombine_f32(vQ1zx, vQ1yz);  // Z X Y Z
+	B3 = vcombine_f32(vQ2yz, vQ2xz);  // Y Z x z
+
+	A1 = vmulq_f32(A1, B1);
+	A2 = vmulq_f32(A2, B2);
+	A3 = vmulq_f32(A3, B3);  //	A3 *= B3
+
+	A1 = vaddq_f32(A1, A2);  //	AB12 = AB1 + AB2
+
+	//	change the sign of the last element
+	A1 = (b3SimdFloat4)veorq_s32((int32x4_t)A1, (int32x4_t)b3vPPPM);
+
+	A1 = vsubq_f32(A1, A3);  //	AB123 = AB12 - AB3
+
+	return b3Quaternion(A1);
+
+#else
+	return b3Quaternion(
+		+w.getX() * q.getW() + w.getY() * q.getZ() - w.getZ() * q.getY(),
+		+w.getY() * q.getW() + w.getZ() * q.getX() - w.getX() * q.getZ(),
+		+w.getZ() * q.getW() + w.getX() * q.getY() - w.getY() * q.getX(),
+		-w.getX() * q.getX() - w.getY() * q.getY() - w.getZ() * q.getZ());
+#endif
+}
+
+/**@brief Calculate the dot product between two quaternions */
+B3_FORCE_INLINE b3Scalar
+b3Dot(const b3Quaternion& q1, const b3Quaternion& q2)
+{
+	return q1.dot(q2);
+}
+
+/**@brief Return the length of a quaternion */
+B3_FORCE_INLINE b3Scalar
+b3Length(const b3Quaternion& q)
+{
+	return q.length();
+}
+
+/**@brief Return the angle between two quaternions*/
+B3_FORCE_INLINE b3Scalar
+b3Angle(const b3Quaternion& q1, const b3Quaternion& q2)
+{
+	return q1.angle(q2);
+}
+
+/**@brief Return the inverse of a quaternion*/
+B3_FORCE_INLINE b3Quaternion
+b3Inverse(const b3Quaternion& q)
+{
+	return q.inverse();
+}
+
+/**@brief Return the result of spherical linear interpolation betwen two quaternions 
+ * @param q1 The first quaternion
+ * @param q2 The second quaternion 
+ * @param t The ration between q1 and q2.  t = 0 return q1, t=1 returns q2 
+ * Slerp assumes constant velocity between positions. */
+B3_FORCE_INLINE b3Quaternion
+b3Slerp(const b3Quaternion& q1, const b3Quaternion& q2, const b3Scalar& t)
+{
+	return q1.slerp(q2, t);
+}
+
+B3_FORCE_INLINE b3Quaternion
+b3QuatMul(const b3Quaternion& rot0, const b3Quaternion& rot1)
+{
+	return rot0 * rot1;
+}
+
+B3_FORCE_INLINE b3Quaternion
+b3QuatNormalized(const b3Quaternion& orn)
+{
+	return orn.normalized();
+}
+
+B3_FORCE_INLINE b3Vector3
+b3QuatRotate(const b3Quaternion& rotation, const b3Vector3& v)
+{
+	b3Quaternion q = rotation * v;
+	q *= rotation.inverse();
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+	return b3MakeVector3(_mm_and_ps(q.get128(), b3vFFF0fMask));
+#elif defined(B3_USE_NEON)
+	return b3MakeVector3((float32x4_t)vandq_s32((int32x4_t)q.get128(), b3vFFF0Mask));
+#else
+	return b3MakeVector3(q.getX(), q.getY(), q.getZ());
+#endif
+}
+
+B3_FORCE_INLINE b3Quaternion
+b3ShortestArcQuat(const b3Vector3& v0, const b3Vector3& v1)  // Game Programming Gems 2.10. make sure v0,v1 are normalized
+{
+	b3Vector3 c = v0.cross(v1);
+	b3Scalar d = v0.dot(v1);
+
+	if (d < -1.0 + B3_EPSILON)
+	{
+		b3Vector3 n, unused;
+		b3PlaneSpace1(v0, n, unused);
+		return b3Quaternion(n.getX(), n.getY(), n.getZ(), 0.0f);  // just pick any vector that is orthogonal to v0
+	}
+
+	b3Scalar s = b3Sqrt((1.0f + d) * 2.0f);
+	b3Scalar rs = 1.0f / s;
+
+	return b3Quaternion(c.getX() * rs, c.getY() * rs, c.getZ() * rs, s * 0.5f);
+}
+
+B3_FORCE_INLINE b3Quaternion
+b3ShortestArcQuatNormalize2(b3Vector3& v0, b3Vector3& v1)
+{
+	v0.normalize();
+	v1.normalize();
+	return b3ShortestArcQuat(v0, v1);
+}
+
+#endif  //B3_SIMD__QUATERNION_H_
diff --git a/engine/inc/bullet/Bullet3Common/b3Random.h b/engine/inc/bullet/Bullet3Common/b3Random.h
new file mode 100644
index 00000000..c2e21496
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Common/b3Random.h
@@ -0,0 +1,46 @@
+/*
+Copyright (c) 2003-2013 Gino van den Bergen / Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_GEN_RANDOM_H
+#define B3_GEN_RANDOM_H
+
+#include "b3Scalar.h"
+
+#ifdef MT19937
+
+#include <limits.h>
+#include <mt19937.h>
+
+#define B3_RAND_MAX UINT_MAX
+
+B3_FORCE_INLINE void b3Srand(unsigned int seed) { init_genrand(seed); }
+B3_FORCE_INLINE unsigned int b3rand() { return genrand_int32(); }
+
+#else
+
+#include <stdlib.h>
+
+#define B3_RAND_MAX RAND_MAX
+
+B3_FORCE_INLINE void b3Srand(unsigned int seed) { srand(seed); }
+B3_FORCE_INLINE unsigned int b3rand() { return rand(); }
+
+#endif
+
+inline b3Scalar b3RandRange(b3Scalar minRange, b3Scalar maxRange)
+{
+	return (b3rand() / (b3Scalar(B3_RAND_MAX) + b3Scalar(1.0))) * (maxRange - minRange) + minRange;
+}
+
+#endif  //B3_GEN_RANDOM_H
diff --git a/engine/inc/bullet/Bullet3Common/b3ResizablePool.h b/engine/inc/bullet/Bullet3Common/b3ResizablePool.h
new file mode 100644
index 00000000..cafe3ff3
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Common/b3ResizablePool.h
@@ -0,0 +1,171 @@
+
+#ifndef B3_RESIZABLE_POOL_H
+#define B3_RESIZABLE_POOL_H
+
+#include "Bullet3Common/b3AlignedObjectArray.h"
+
+enum
+{
+	B3_POOL_HANDLE_TERMINAL_FREE = -1,
+	B3_POOL_HANDLE_TERMINAL_USED = -2
+};
+
+template <typename U>
+struct b3PoolBodyHandle : public U
+{
+	B3_DECLARE_ALIGNED_ALLOCATOR();
+
+	int m_nextFreeHandle;
+	void setNextFree(int next)
+	{
+		m_nextFreeHandle = next;
+	}
+	int getNextFree() const
+	{
+		return m_nextFreeHandle;
+	}
+};
+
+template <typename T>
+class b3ResizablePool
+{
+protected:
+	b3AlignedObjectArray<T> m_bodyHandles;
+	int m_numUsedHandles;   // number of active handles
+	int m_firstFreeHandle;  // free handles list
+
+	T* getHandleInternal(int handle)
+	{
+		return &m_bodyHandles[handle];
+	}
+	const T* getHandleInternal(int handle) const
+	{
+		return &m_bodyHandles[handle];
+	}
+
+public:
+	b3ResizablePool()
+	{
+		initHandles();
+	}
+
+	virtual ~b3ResizablePool()
+	{
+		exitHandles();
+	}
+	///handle management
+
+	int getNumHandles() const
+	{
+		return m_bodyHandles.size();
+	}
+
+	void getUsedHandles(b3AlignedObjectArray<int>& usedHandles) const
+	{
+		for (int i = 0; i < m_bodyHandles.size(); i++)
+		{
+			if (m_bodyHandles[i].getNextFree() == B3_POOL_HANDLE_TERMINAL_USED)
+			{
+				usedHandles.push_back(i);
+			}
+		}
+	}
+
+	T* getHandle(int handle)
+	{
+		b3Assert(handle >= 0);
+		b3Assert(handle < m_bodyHandles.size());
+		if ((handle < 0) || (handle >= m_bodyHandles.size()))
+		{
+			return 0;
+		}
+
+		if (m_bodyHandles[handle].getNextFree() == B3_POOL_HANDLE_TERMINAL_USED)
+		{
+			return &m_bodyHandles[handle];
+		}
+		return 0;
+	}
+	const T* getHandle(int handle) const
+	{
+		b3Assert(handle >= 0);
+		b3Assert(handle < m_bodyHandles.size());
+		if ((handle < 0) || (handle >= m_bodyHandles.size()))
+		{
+			return 0;
+		}
+
+		if (m_bodyHandles[handle].getNextFree() == B3_POOL_HANDLE_TERMINAL_USED)
+		{
+			return &m_bodyHandles[handle];
+		}
+		return 0;
+	}
+
+	void increaseHandleCapacity(int extraCapacity)
+	{
+		int curCapacity = m_bodyHandles.size();
+		//b3Assert(curCapacity == m_numUsedHandles);
+		int newCapacity = curCapacity + extraCapacity;
+		m_bodyHandles.resize(newCapacity);
+
+		{
+			for (int i = curCapacity; i < newCapacity; i++)
+				m_bodyHandles[i].setNextFree(i + 1);
+
+			m_bodyHandles[newCapacity - 1].setNextFree(-1);
+		}
+		m_firstFreeHandle = curCapacity;
+	}
+	void initHandles()
+	{
+		m_numUsedHandles = 0;
+		m_firstFreeHandle = -1;
+
+		increaseHandleCapacity(1);
+	}
+
+	void exitHandles()
+	{
+		m_bodyHandles.resize(0);
+		m_firstFreeHandle = -1;
+		m_numUsedHandles = 0;
+	}
+
+	int allocHandle()
+	{
+		b3Assert(m_firstFreeHandle >= 0);
+
+		int handle = m_firstFreeHandle;
+		m_firstFreeHandle = getHandleInternal(handle)->getNextFree();
+		m_numUsedHandles++;
+
+		if (m_firstFreeHandle < 0)
+		{
+			//int curCapacity = m_bodyHandles.size();
+			int additionalCapacity = m_bodyHandles.size();
+			increaseHandleCapacity(additionalCapacity);
+
+			getHandleInternal(handle)->setNextFree(m_firstFreeHandle);
+		}
+		getHandleInternal(handle)->setNextFree(B3_POOL_HANDLE_TERMINAL_USED);
+		getHandleInternal(handle)->clear();
+		return handle;
+	}
+
+	void freeHandle(int handle)
+	{
+		b3Assert(handle >= 0);
+
+		if (m_bodyHandles[handle].getNextFree() == B3_POOL_HANDLE_TERMINAL_USED)
+		{
+			getHandleInternal(handle)->clear();
+			getHandleInternal(handle)->setNextFree(m_firstFreeHandle);
+			m_firstFreeHandle = handle;
+			m_numUsedHandles--;
+		}
+	}
+};
+///end handle management
+
+#endif  //B3_RESIZABLE_POOL_H
diff --git a/engine/inc/bullet/Bullet3Common/b3Scalar.h b/engine/inc/bullet/Bullet3Common/b3Scalar.h
new file mode 100644
index 00000000..eeb70ed6
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Common/b3Scalar.h
@@ -0,0 +1,689 @@
+/*
+Copyright (c) 2003-2013 Gino van den Bergen / Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_SCALAR_H
+#define B3_SCALAR_H
+
+#ifdef B3_MANAGED_CODE
+//Aligned data types not supported in managed code
+#pragma unmanaged
+#endif
+
+#include <math.h>
+#include <stdlib.h>  //size_t for MSVC 6.0
+#include <float.h>
+
+//Original repository is at http://github.com/erwincoumans/bullet3
+#define B3_BULLET_VERSION 300
+
+inline int b3GetVersion()
+{
+	return B3_BULLET_VERSION;
+}
+
+#if defined(DEBUG) || defined(_DEBUG)
+#define B3_DEBUG
+#endif
+
+#include "b3Logging.h"  //for b3Error
+
+#ifdef _WIN32
+
+#if  defined(__GNUC__)	// it should handle both MINGW and CYGWIN
+#define B3_FORCE_INLINE             __inline__ __attribute__((always_inline))
+#define B3_ATTRIBUTE_ALIGNED16(a)   a __attribute__((aligned(16)))
+#define B3_ATTRIBUTE_ALIGNED64(a)   a __attribute__((aligned(64)))
+#define B3_ATTRIBUTE_ALIGNED128(a)  a __attribute__((aligned(128)))
+#elif ( defined(_MSC_VER) && _MSC_VER < 1300 )
+#define B3_FORCE_INLINE inline
+#define B3_ATTRIBUTE_ALIGNED16(a) a
+#define B3_ATTRIBUTE_ALIGNED64(a) a
+#define B3_ATTRIBUTE_ALIGNED128(a) a
+#else
+//#define B3_HAS_ALIGNED_ALLOCATOR
+#pragma warning(disable : 4324)  // disable padding warning
+//			#pragma warning(disable:4530) // Disable the exception disable but used in MSCV Stl warning.
+#pragma warning(disable : 4996)  //Turn off warnings about deprecated C routines
+//			#pragma warning(disable:4786) // Disable the "debug name too long" warning
+
+#define B3_FORCE_INLINE __forceinline
+#define B3_ATTRIBUTE_ALIGNED16(a) __declspec(align(16)) a
+#define B3_ATTRIBUTE_ALIGNED64(a) __declspec(align(64)) a
+#define B3_ATTRIBUTE_ALIGNED128(a) __declspec(align(128)) a
+#ifdef _XBOX
+#define B3_USE_VMX128
+
+#include <ppcintrinsics.h>
+#define B3_HAVE_NATIVE_FSEL
+#define b3Fsel(a, b, c) __fsel((a), (b), (c))
+#else
+
+#if (defined(_WIN32) && (_MSC_VER) && _MSC_VER >= 1400) && (!defined(B3_USE_DOUBLE_PRECISION))
+#if (defined(_M_IX86) || defined(_M_X64))
+
+
+#ifdef __clang__
+//#define B3_NO_SIMD_OPERATOR_OVERLOADS
+#define B3_DISABLE_SSE
+#endif //__clang__
+
+#ifndef B3_DISABLE_SSE
+#define B3_USE_SSE
+#endif //B3_DISABLE_SSE
+
+#ifdef B3_USE_SSE
+//B3_USE_SSE_IN_API is disabled under Windows by default, because
+//it makes it harder to integrate Bullet into your application under Windows
+//(structured embedding Bullet structs/classes need to be 16-byte aligned)
+//with relatively little performance gain
+//If you are not embedded Bullet data in your classes, or make sure that you align those classes on 16-byte boundaries
+//you can manually enable this line or set it in the build system for a bit of performance gain (a few percent, dependent on usage)
+//#define B3_USE_SSE_IN_API
+#endif  //B3_USE_SSE
+#include <emmintrin.h>
+#endif
+#endif
+
+#endif  //_XBOX
+
+#endif  //__MINGW32__
+
+#ifdef B3_DEBUG
+#ifdef _MSC_VER
+#include <stdio.h>
+#define b3Assert(x) { if(!(x)){b3Error("Assert " __FILE__ ":%u (%s)\n", __LINE__, #x);__debugbreak();	}}
+#else  //_MSC_VER
+#include <assert.h>
+#define b3Assert assert
+#endif  //_MSC_VER
+#else
+#define b3Assert(x)
+#endif
+//b3FullAssert is optional, slows down a lot
+#define b3FullAssert(x)
+
+#define b3Likely(_c) _c
+#define b3Unlikely(_c) _c
+
+#else
+
+#if defined(__CELLOS_LV2__)
+#define B3_FORCE_INLINE inline __attribute__((always_inline))
+#define B3_ATTRIBUTE_ALIGNED16(a) a __attribute__((aligned(16)))
+#define B3_ATTRIBUTE_ALIGNED64(a) a __attribute__((aligned(64)))
+#define B3_ATTRIBUTE_ALIGNED128(a) a __attribute__((aligned(128)))
+#ifndef assert
+#include <assert.h>
+#endif
+#ifdef B3_DEBUG
+#ifdef __SPU__
+#include <spu_printf.h>
+#define printf spu_printf
+#define b3Assert(x)               \
+	{                             \
+		if (!(x))                 \
+		{                         \
+			b3Error(              \
+				"Assert "__FILE__ \
+				":%u (" #x ")\n", \
+				__LINE__);        \
+			spu_hcmpeq(0, 0);     \
+		}                         \
+	}
+#else
+#define b3Assert assert
+#endif
+
+#else
+#define b3Assert(x)
+#endif
+//b3FullAssert is optional, slows down a lot
+#define b3FullAssert(x)
+
+#define b3Likely(_c) _c
+#define b3Unlikely(_c) _c
+
+#else
+
+#ifdef USE_LIBSPE2
+
+#define B3_FORCE_INLINE __inline
+#define B3_ATTRIBUTE_ALIGNED16(a) a __attribute__((aligned(16)))
+#define B3_ATTRIBUTE_ALIGNED64(a) a __attribute__((aligned(64)))
+#define B3_ATTRIBUTE_ALIGNED128(a) a __attribute__((aligned(128)))
+#ifndef assert
+#include <assert.h>
+#endif
+#ifdef B3_DEBUG
+#define b3Assert assert
+#else
+#define b3Assert(x)
+#endif
+//b3FullAssert is optional, slows down a lot
+#define b3FullAssert(x)
+
+#define b3Likely(_c) __builtin_expect((_c), 1)
+#define b3Unlikely(_c) __builtin_expect((_c), 0)
+
+#else
+//non-windows systems
+
+#if (defined(__APPLE__) && (!defined(B3_USE_DOUBLE_PRECISION)))
+#if defined(__i386__) || defined(__x86_64__)
+#define B3_USE_SSE
+//B3_USE_SSE_IN_API is enabled on Mac OSX by default, because memory is automatically aligned on 16-byte boundaries
+//if apps run into issues, we will disable the next line
+#define B3_USE_SSE_IN_API
+#ifdef B3_USE_SSE
+// include appropriate SSE level
+#if defined(__SSE4_1__)
+#include <smmintrin.h>
+#elif defined(__SSSE3__)
+#include <tmmintrin.h>
+#elif defined(__SSE3__)
+#include <pmmintrin.h>
+#else
+#include <emmintrin.h>
+#endif
+#endif  //B3_USE_SSE
+#elif defined(__armv7__)
+#ifdef __clang__
+#define B3_USE_NEON 1
+
+#if defined B3_USE_NEON && defined(__clang__)
+#include <arm_neon.h>
+#endif  //B3_USE_NEON
+#endif  //__clang__
+#endif  //__arm__
+
+#define B3_FORCE_INLINE inline __attribute__((always_inline))
+///@todo: check out alignment methods for other platforms/compilers
+#define B3_ATTRIBUTE_ALIGNED16(a) a __attribute__((aligned(16)))
+#define B3_ATTRIBUTE_ALIGNED64(a) a __attribute__((aligned(64)))
+#define B3_ATTRIBUTE_ALIGNED128(a) a __attribute__((aligned(128)))
+#ifndef assert
+#include <assert.h>
+#endif
+
+#if defined(DEBUG) || defined(_DEBUG)
+#if defined(__i386__) || defined(__x86_64__)
+#include <stdio.h>
+#define b3Assert(x)                                                             \
+	{                                                                           \
+		if (!(x))                                                               \
+		{                                                                       \
+			b3Error("Assert %s in line %d, file %s\n", #x, __LINE__, __FILE__); \
+			asm volatile("int3");                                               \
+		}                                                                       \
+	}
+#else  //defined (__i386__) || defined (__x86_64__)
+#define b3Assert assert
+#endif  //defined (__i386__) || defined (__x86_64__)
+#else   //defined(DEBUG) || defined (_DEBUG)
+#define b3Assert(x)
+#endif  //defined(DEBUG) || defined (_DEBUG)
+
+//b3FullAssert is optional, slows down a lot
+#define b3FullAssert(x)
+#define b3Likely(_c) _c
+#define b3Unlikely(_c) _c
+
+#else
+
+#define B3_FORCE_INLINE inline
+///@todo: check out alignment methods for other platforms/compilers
+#define B3_ATTRIBUTE_ALIGNED16(a) a __attribute__((aligned(16)))
+#define B3_ATTRIBUTE_ALIGNED64(a) a __attribute__((aligned(64)))
+#define B3_ATTRIBUTE_ALIGNED128(a) a __attribute__((aligned(128)))
+///#define B3_ATTRIBUTE_ALIGNED16(a) a
+///#define B3_ATTRIBUTE_ALIGNED64(a) a
+///#define B3_ATTRIBUTE_ALIGNED128(a) a
+#ifndef assert
+#include <assert.h>
+#endif
+
+#if defined(DEBUG) || defined(_DEBUG)
+#define b3Assert assert
+#else
+#define b3Assert(x)
+#endif
+
+//b3FullAssert is optional, slows down a lot
+#define b3FullAssert(x)
+#define b3Likely(_c) _c
+#define b3Unlikely(_c) _c
+#endif  //__APPLE__
+
+#endif  // LIBSPE2
+
+#endif  //__CELLOS_LV2__
+#endif
+
+///The b3Scalar type abstracts floating point numbers, to easily switch between double and single floating point precision.
+#if defined(B3_USE_DOUBLE_PRECISION)
+typedef double b3Scalar;
+//this number could be bigger in double precision
+#define B3_LARGE_FLOAT 1e30
+#else
+typedef float b3Scalar;
+//keep B3_LARGE_FLOAT*B3_LARGE_FLOAT < FLT_MAX
+#define B3_LARGE_FLOAT 1e18f
+#endif
+
+#ifdef B3_USE_SSE
+typedef __m128 b3SimdFloat4;
+#endif  //B3_USE_SSE
+
+#if defined B3_USE_SSE_IN_API && defined(B3_USE_SSE)
+#ifdef _WIN32
+
+#ifndef B3_NAN
+static int b3NanMask = 0x7F800001;
+#define B3_NAN (*(float *)&b3NanMask)
+#endif
+
+#ifndef B3_INFINITY_MASK
+static int b3InfinityMask = 0x7F800000;
+#define B3_INFINITY_MASK (*(float *)&b3InfinityMask)
+#endif
+#ifndef B3_NO_SIMD_OPERATOR_OVERLOADS
+inline __m128 operator+(const __m128 A, const __m128 B)
+{
+	return _mm_add_ps(A, B);
+}
+
+inline __m128 operator-(const __m128 A, const __m128 B)
+{
+	return _mm_sub_ps(A, B);
+}
+
+inline __m128 operator*(const __m128 A, const __m128 B)
+{
+	return _mm_mul_ps(A, B);
+}
+#endif //B3_NO_SIMD_OPERATOR_OVERLOADS
+#define b3CastfTo128i(a) (_mm_castps_si128(a))
+#define b3CastfTo128d(a) (_mm_castps_pd(a))
+#define b3CastiTo128f(a) (_mm_castsi128_ps(a))
+#define b3CastdTo128f(a) (_mm_castpd_ps(a))
+#define b3CastdTo128i(a) (_mm_castpd_si128(a))
+#define b3Assign128(r0, r1, r2, r3) _mm_setr_ps(r0, r1, r2, r3)
+
+#else  //_WIN32
+
+#define b3CastfTo128i(a) ((__m128i)(a))
+#define b3CastfTo128d(a) ((__m128d)(a))
+#define b3CastiTo128f(a) ((__m128)(a))
+#define b3CastdTo128f(a) ((__m128)(a))
+#define b3CastdTo128i(a) ((__m128i)(a))
+#define b3Assign128(r0, r1, r2, r3) \
+	(__m128) { r0, r1, r2, r3 }
+#endif  //_WIN32
+#endif  //B3_USE_SSE_IN_API
+
+#ifdef B3_USE_NEON
+#include <arm_neon.h>
+
+typedef float32x4_t b3SimdFloat4;
+#define B3_INFINITY INFINITY
+#define B3_NAN NAN
+#define b3Assign128(r0, r1, r2, r3) \
+	(float32x4_t) { r0, r1, r2, r3 }
+#endif
+
+#define B3_DECLARE_ALIGNED_ALLOCATOR()                                                                   \
+	B3_FORCE_INLINE void *operator new(size_t sizeInBytes) { return b3AlignedAlloc(sizeInBytes, 16); }   \
+	B3_FORCE_INLINE void operator delete(void *ptr) { b3AlignedFree(ptr); }                              \
+	B3_FORCE_INLINE void *operator new(size_t, void *ptr) { return ptr; }                                \
+	B3_FORCE_INLINE void operator delete(void *, void *) {}                                              \
+	B3_FORCE_INLINE void *operator new[](size_t sizeInBytes) { return b3AlignedAlloc(sizeInBytes, 16); } \
+	B3_FORCE_INLINE void operator delete[](void *ptr) { b3AlignedFree(ptr); }                            \
+	B3_FORCE_INLINE void *operator new[](size_t, void *ptr) { return ptr; }                              \
+	B3_FORCE_INLINE void operator delete[](void *, void *) {}
+
+#if defined(B3_USE_DOUBLE_PRECISION) || defined(B3_FORCE_DOUBLE_FUNCTIONS)
+
+B3_FORCE_INLINE b3Scalar b3Sqrt(b3Scalar x)
+{
+	return sqrt(x);
+}
+B3_FORCE_INLINE b3Scalar b3Fabs(b3Scalar x) { return fabs(x); }
+B3_FORCE_INLINE b3Scalar b3Cos(b3Scalar x) { return cos(x); }
+B3_FORCE_INLINE b3Scalar b3Sin(b3Scalar x) { return sin(x); }
+B3_FORCE_INLINE b3Scalar b3Tan(b3Scalar x) { return tan(x); }
+B3_FORCE_INLINE b3Scalar b3Acos(b3Scalar x)
+{
+	if (x < b3Scalar(-1)) x = b3Scalar(-1);
+	if (x > b3Scalar(1)) x = b3Scalar(1);
+	return acos(x);
+}
+B3_FORCE_INLINE b3Scalar b3Asin(b3Scalar x)
+{
+	if (x < b3Scalar(-1)) x = b3Scalar(-1);
+	if (x > b3Scalar(1)) x = b3Scalar(1);
+	return asin(x);
+}
+B3_FORCE_INLINE b3Scalar b3Atan(b3Scalar x) { return atan(x); }
+B3_FORCE_INLINE b3Scalar b3Atan2(b3Scalar x, b3Scalar y) { return atan2(x, y); }
+B3_FORCE_INLINE b3Scalar b3Exp(b3Scalar x) { return exp(x); }
+B3_FORCE_INLINE b3Scalar b3Log(b3Scalar x) { return log(x); }
+B3_FORCE_INLINE b3Scalar b3Pow(b3Scalar x, b3Scalar y) { return pow(x, y); }
+B3_FORCE_INLINE b3Scalar b3Fmod(b3Scalar x, b3Scalar y) { return fmod(x, y); }
+
+#else
+
+B3_FORCE_INLINE b3Scalar b3Sqrt(b3Scalar y)
+{
+#ifdef USE_APPROXIMATION
+	double x, z, tempf;
+	unsigned long *tfptr = ((unsigned long *)&tempf) + 1;
+
+	tempf = y;
+	*tfptr = (0xbfcdd90a - *tfptr) >> 1; /* estimate of 1/sqrt(y) */
+	x = tempf;
+	z = y * b3Scalar(0.5);
+	x = (b3Scalar(1.5) * x) - (x * x) * (x * z); /* iteration formula     */
+	x = (b3Scalar(1.5) * x) - (x * x) * (x * z);
+	x = (b3Scalar(1.5) * x) - (x * x) * (x * z);
+	x = (b3Scalar(1.5) * x) - (x * x) * (x * z);
+	x = (b3Scalar(1.5) * x) - (x * x) * (x * z);
+	return x * y;
+#else
+	return sqrtf(y);
+#endif
+}
+B3_FORCE_INLINE b3Scalar b3Fabs(b3Scalar x) { return fabsf(x); }
+B3_FORCE_INLINE b3Scalar b3Cos(b3Scalar x) { return cosf(x); }
+B3_FORCE_INLINE b3Scalar b3Sin(b3Scalar x) { return sinf(x); }
+B3_FORCE_INLINE b3Scalar b3Tan(b3Scalar x) { return tanf(x); }
+B3_FORCE_INLINE b3Scalar b3Acos(b3Scalar x)
+{
+	if (x < b3Scalar(-1))
+		x = b3Scalar(-1);
+	if (x > b3Scalar(1))
+		x = b3Scalar(1);
+	return acosf(x);
+}
+B3_FORCE_INLINE b3Scalar b3Asin(b3Scalar x)
+{
+	if (x < b3Scalar(-1))
+		x = b3Scalar(-1);
+	if (x > b3Scalar(1))
+		x = b3Scalar(1);
+	return asinf(x);
+}
+B3_FORCE_INLINE b3Scalar b3Atan(b3Scalar x) { return atanf(x); }
+B3_FORCE_INLINE b3Scalar b3Atan2(b3Scalar x, b3Scalar y) { return atan2f(x, y); }
+B3_FORCE_INLINE b3Scalar b3Exp(b3Scalar x) { return expf(x); }
+B3_FORCE_INLINE b3Scalar b3Log(b3Scalar x) { return logf(x); }
+B3_FORCE_INLINE b3Scalar b3Pow(b3Scalar x, b3Scalar y) { return powf(x, y); }
+B3_FORCE_INLINE b3Scalar b3Fmod(b3Scalar x, b3Scalar y) { return fmodf(x, y); }
+
+#endif
+
+#define B3_2_PI b3Scalar(6.283185307179586232)
+#define B3_PI (B3_2_PI * b3Scalar(0.5))
+#define B3_HALF_PI (B3_2_PI * b3Scalar(0.25))
+#define B3_RADS_PER_DEG (B3_2_PI / b3Scalar(360.0))
+#define B3_DEGS_PER_RAD (b3Scalar(360.0) / B3_2_PI)
+#define B3_SQRT12 b3Scalar(0.7071067811865475244008443621048490)
+
+#define b3RecipSqrt(x) ((b3Scalar)(b3Scalar(1.0) / b3Sqrt(b3Scalar(x)))) /* reciprocal square root */
+
+#ifdef B3_USE_DOUBLE_PRECISION
+#define B3_EPSILON DBL_EPSILON
+#define B3_INFINITY DBL_MAX
+#else
+#define B3_EPSILON FLT_EPSILON
+#define B3_INFINITY FLT_MAX
+#endif
+
+B3_FORCE_INLINE b3Scalar b3Atan2Fast(b3Scalar y, b3Scalar x)
+{
+	b3Scalar coeff_1 = B3_PI / 4.0f;
+	b3Scalar coeff_2 = 3.0f * coeff_1;
+	b3Scalar abs_y = b3Fabs(y);
+	b3Scalar angle;
+	if (x >= 0.0f)
+	{
+		b3Scalar r = (x - abs_y) / (x + abs_y);
+		angle = coeff_1 - coeff_1 * r;
+	}
+	else
+	{
+		b3Scalar r = (x + abs_y) / (abs_y - x);
+		angle = coeff_2 - coeff_1 * r;
+	}
+	return (y < 0.0f) ? -angle : angle;
+}
+
+B3_FORCE_INLINE bool b3FuzzyZero(b3Scalar x) { return b3Fabs(x) < B3_EPSILON; }
+
+B3_FORCE_INLINE bool b3Equal(b3Scalar a, b3Scalar eps)
+{
+	return (((a) <= eps) && !((a) < -eps));
+}
+B3_FORCE_INLINE bool b3GreaterEqual(b3Scalar a, b3Scalar eps)
+{
+	return (!((a) <= eps));
+}
+
+B3_FORCE_INLINE int b3IsNegative(b3Scalar x)
+{
+	return x < b3Scalar(0.0) ? 1 : 0;
+}
+
+B3_FORCE_INLINE b3Scalar b3Radians(b3Scalar x) { return x * B3_RADS_PER_DEG; }
+B3_FORCE_INLINE b3Scalar b3Degrees(b3Scalar x) { return x * B3_DEGS_PER_RAD; }
+
+#define B3_DECLARE_HANDLE(name) \
+	typedef struct name##__     \
+	{                           \
+		int unused;             \
+	} * name
+
+#ifndef b3Fsel
+B3_FORCE_INLINE b3Scalar b3Fsel(b3Scalar a, b3Scalar b, b3Scalar c)
+{
+	return a >= 0 ? b : c;
+}
+#endif
+#define b3Fsels(a, b, c) (b3Scalar) b3Fsel(a, b, c)
+
+B3_FORCE_INLINE bool b3MachineIsLittleEndian()
+{
+	long int i = 1;
+	const char *p = (const char *)&i;
+	if (p[0] == 1)  // Lowest address contains the least significant byte
+		return true;
+	else
+		return false;
+}
+
+///b3Select avoids branches, which makes performance much better for consoles like Playstation 3 and XBox 360
+///Thanks Phil Knight. See also http://www.cellperformance.com/articles/2006/04/more_techniques_for_eliminatin_1.html
+B3_FORCE_INLINE unsigned b3Select(unsigned condition, unsigned valueIfConditionNonZero, unsigned valueIfConditionZero)
+{
+	// Set testNz to 0xFFFFFFFF if condition is nonzero, 0x00000000 if condition is zero
+	// Rely on positive value or'ed with its negative having sign bit on
+	// and zero value or'ed with its negative (which is still zero) having sign bit off
+	// Use arithmetic shift right, shifting the sign bit through all 32 bits
+	unsigned testNz = (unsigned)(((int)condition | -(int)condition) >> 31);
+	unsigned testEqz = ~testNz;
+	return ((valueIfConditionNonZero & testNz) | (valueIfConditionZero & testEqz));
+}
+B3_FORCE_INLINE int b3Select(unsigned condition, int valueIfConditionNonZero, int valueIfConditionZero)
+{
+	unsigned testNz = (unsigned)(((int)condition | -(int)condition) >> 31);
+	unsigned testEqz = ~testNz;
+	return static_cast<int>((valueIfConditionNonZero & testNz) | (valueIfConditionZero & testEqz));
+}
+B3_FORCE_INLINE float b3Select(unsigned condition, float valueIfConditionNonZero, float valueIfConditionZero)
+{
+#ifdef B3_HAVE_NATIVE_FSEL
+	return (float)b3Fsel((b3Scalar)condition - b3Scalar(1.0f), valueIfConditionNonZero, valueIfConditionZero);
+#else
+	return (condition != 0) ? valueIfConditionNonZero : valueIfConditionZero;
+#endif
+}
+
+template <typename T>
+B3_FORCE_INLINE void b3Swap(T &a, T &b)
+{
+	T tmp = a;
+	a = b;
+	b = tmp;
+}
+
+//PCK: endian swapping functions
+B3_FORCE_INLINE unsigned b3SwapEndian(unsigned val)
+{
+	return (((val & 0xff000000) >> 24) | ((val & 0x00ff0000) >> 8) | ((val & 0x0000ff00) << 8) | ((val & 0x000000ff) << 24));
+}
+
+B3_FORCE_INLINE unsigned short b3SwapEndian(unsigned short val)
+{
+	return static_cast<unsigned short>(((val & 0xff00) >> 8) | ((val & 0x00ff) << 8));
+}
+
+B3_FORCE_INLINE unsigned b3SwapEndian(int val)
+{
+	return b3SwapEndian((unsigned)val);
+}
+
+B3_FORCE_INLINE unsigned short b3SwapEndian(short val)
+{
+	return b3SwapEndian((unsigned short)val);
+}
+
+///b3SwapFloat uses using char pointers to swap the endianness
+////b3SwapFloat/b3SwapDouble will NOT return a float, because the machine might 'correct' invalid floating point values
+///Not all values of sign/exponent/mantissa are valid floating point numbers according to IEEE 754.
+///When a floating point unit is faced with an invalid value, it may actually change the value, or worse, throw an exception.
+///In most systems, running user mode code, you wouldn't get an exception, but instead the hardware/os/runtime will 'fix' the number for you.
+///so instead of returning a float/double, we return integer/long long integer
+B3_FORCE_INLINE unsigned int b3SwapEndianFloat(float d)
+{
+	unsigned int a = 0;
+	unsigned char *dst = (unsigned char *)&a;
+	unsigned char *src = (unsigned char *)&d;
+
+	dst[0] = src[3];
+	dst[1] = src[2];
+	dst[2] = src[1];
+	dst[3] = src[0];
+	return a;
+}
+
+// unswap using char pointers
+B3_FORCE_INLINE float b3UnswapEndianFloat(unsigned int a)
+{
+	float d = 0.0f;
+	unsigned char *src = (unsigned char *)&a;
+	unsigned char *dst = (unsigned char *)&d;
+
+	dst[0] = src[3];
+	dst[1] = src[2];
+	dst[2] = src[1];
+	dst[3] = src[0];
+
+	return d;
+}
+
+// swap using char pointers
+B3_FORCE_INLINE void b3SwapEndianDouble(double d, unsigned char *dst)
+{
+	unsigned char *src = (unsigned char *)&d;
+
+	dst[0] = src[7];
+	dst[1] = src[6];
+	dst[2] = src[5];
+	dst[3] = src[4];
+	dst[4] = src[3];
+	dst[5] = src[2];
+	dst[6] = src[1];
+	dst[7] = src[0];
+}
+
+// unswap using char pointers
+B3_FORCE_INLINE double b3UnswapEndianDouble(const unsigned char *src)
+{
+	double d = 0.0;
+	unsigned char *dst = (unsigned char *)&d;
+
+	dst[0] = src[7];
+	dst[1] = src[6];
+	dst[2] = src[5];
+	dst[3] = src[4];
+	dst[4] = src[3];
+	dst[5] = src[2];
+	dst[6] = src[1];
+	dst[7] = src[0];
+
+	return d;
+}
+
+// returns normalized value in range [-B3_PI, B3_PI]
+B3_FORCE_INLINE b3Scalar b3NormalizeAngle(b3Scalar angleInRadians)
+{
+	angleInRadians = b3Fmod(angleInRadians, B3_2_PI);
+	if (angleInRadians < -B3_PI)
+	{
+		return angleInRadians + B3_2_PI;
+	}
+	else if (angleInRadians > B3_PI)
+	{
+		return angleInRadians - B3_2_PI;
+	}
+	else
+	{
+		return angleInRadians;
+	}
+}
+
+///rudimentary class to provide type info
+struct b3TypedObject
+{
+	b3TypedObject(int objectType)
+		: m_objectType(objectType)
+	{
+	}
+	int m_objectType;
+	inline int getObjectType() const
+	{
+		return m_objectType;
+	}
+};
+
+///align a pointer to the provided alignment, upwards
+template <typename T>
+T *b3AlignPointer(T *unalignedPtr, size_t alignment)
+{
+	struct b3ConvertPointerSizeT
+	{
+		union {
+			T *ptr;
+			size_t integer;
+		};
+	};
+	b3ConvertPointerSizeT converter;
+
+	const size_t bit_mask = ~(alignment - 1);
+	converter.ptr = unalignedPtr;
+	converter.integer += alignment - 1;
+	converter.integer &= bit_mask;
+	return converter.ptr;
+}
+
+#endif  //B3_SCALAR_H
diff --git a/engine/inc/bullet/Bullet3Common/b3StackAlloc.h b/engine/inc/bullet/Bullet3Common/b3StackAlloc.h
new file mode 100644
index 00000000..4972236a
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Common/b3StackAlloc.h
@@ -0,0 +1,118 @@
+/*
+Copyright (c) 2003-2013 Gino van den Bergen / Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+/*
+StackAlloc extracted from GJK-EPA collision solver by Nathanael Presson
+Nov.2006
+*/
+
+#ifndef B3_STACK_ALLOC
+#define B3_STACK_ALLOC
+
+#include "b3Scalar.h"  //for b3Assert
+#include "b3AlignedAllocator.h"
+
+///The b3Block class is an internal structure for the b3StackAlloc memory allocator.
+struct b3Block
+{
+	b3Block* previous;
+	unsigned char* address;
+};
+
+///The StackAlloc class provides some fast stack-based memory allocator (LIFO last-in first-out)
+class b3StackAlloc
+{
+public:
+	b3StackAlloc(unsigned int size)
+	{
+		ctor();
+		create(size);
+	}
+	~b3StackAlloc() { destroy(); }
+
+	inline void create(unsigned int size)
+	{
+		destroy();
+		data = (unsigned char*)b3AlignedAlloc(size, 16);
+		totalsize = size;
+	}
+	inline void destroy()
+	{
+		b3Assert(usedsize == 0);
+		//Raise(L"StackAlloc is still in use");
+
+		if (usedsize == 0)
+		{
+			if (!ischild && data)
+				b3AlignedFree(data);
+
+			data = 0;
+			usedsize = 0;
+		}
+	}
+
+	int getAvailableMemory() const
+	{
+		return static_cast<int>(totalsize - usedsize);
+	}
+
+	unsigned char* allocate(unsigned int size)
+	{
+		const unsigned int nus(usedsize + size);
+		if (nus < totalsize)
+		{
+			usedsize = nus;
+			return (data + (usedsize - size));
+		}
+		b3Assert(0);
+		//&& (L"Not enough memory"));
+
+		return (0);
+	}
+	B3_FORCE_INLINE b3Block* beginBlock()
+	{
+		b3Block* pb = (b3Block*)allocate(sizeof(b3Block));
+		pb->previous = current;
+		pb->address = data + usedsize;
+		current = pb;
+		return (pb);
+	}
+	B3_FORCE_INLINE void endBlock(b3Block* block)
+	{
+		b3Assert(block == current);
+		//Raise(L"Unmatched blocks");
+		if (block == current)
+		{
+			current = block->previous;
+			usedsize = (unsigned int)((block->address - data) - sizeof(b3Block));
+		}
+	}
+
+private:
+	void ctor()
+	{
+		data = 0;
+		totalsize = 0;
+		usedsize = 0;
+		current = 0;
+		ischild = false;
+	}
+	unsigned char* data;
+	unsigned int totalsize;
+	unsigned int usedsize;
+	b3Block* current;
+	bool ischild;
+};
+
+#endif  //B3_STACK_ALLOC
diff --git a/engine/inc/bullet/Bullet3Common/b3Transform.h b/engine/inc/bullet/Bullet3Common/b3Transform.h
new file mode 100644
index 00000000..149da9d1
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Common/b3Transform.h
@@ -0,0 +1,286 @@
+/*
+Copyright (c) 2003-2013 Gino van den Bergen / Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_TRANSFORM_H
+#define B3_TRANSFORM_H
+
+#include "b3Matrix3x3.h"
+
+#ifdef B3_USE_DOUBLE_PRECISION
+#define b3TransformData b3TransformDoubleData
+#else
+#define b3TransformData b3TransformFloatData
+#endif
+
+/**@brief The b3Transform class supports rigid transforms with only translation and rotation and no scaling/shear.
+ *It can be used in combination with b3Vector3, b3Quaternion and b3Matrix3x3 linear algebra classes. */
+B3_ATTRIBUTE_ALIGNED16(class)
+b3Transform
+{
+	///Storage for the rotation
+	b3Matrix3x3 m_basis;
+	///Storage for the translation
+	b3Vector3 m_origin;
+
+public:
+	/**@brief No initialization constructor */
+	b3Transform() {}
+	/**@brief Constructor from b3Quaternion (optional b3Vector3 )
+   * @param q Rotation from quaternion 
+   * @param c Translation from Vector (default 0,0,0) */
+	explicit B3_FORCE_INLINE b3Transform(const b3Quaternion& q,
+										 const b3Vector3& c = b3MakeVector3(b3Scalar(0), b3Scalar(0), b3Scalar(0)))
+		: m_basis(q),
+		  m_origin(c)
+	{
+	}
+
+	/**@brief Constructor from b3Matrix3x3 (optional b3Vector3)
+   * @param b Rotation from Matrix 
+   * @param c Translation from Vector default (0,0,0)*/
+	explicit B3_FORCE_INLINE b3Transform(const b3Matrix3x3& b,
+										 const b3Vector3& c = b3MakeVector3(b3Scalar(0), b3Scalar(0), b3Scalar(0)))
+		: m_basis(b),
+		  m_origin(c)
+	{
+	}
+	/**@brief Copy constructor */
+	B3_FORCE_INLINE b3Transform(const b3Transform& other)
+		: m_basis(other.m_basis),
+		  m_origin(other.m_origin)
+	{
+	}
+	/**@brief Assignment Operator */
+	B3_FORCE_INLINE b3Transform& operator=(const b3Transform& other)
+	{
+		m_basis = other.m_basis;
+		m_origin = other.m_origin;
+		return *this;
+	}
+
+	/**@brief Set the current transform as the value of the product of two transforms
+   * @param t1 Transform 1
+   * @param t2 Transform 2
+   * This = Transform1 * Transform2 */
+	B3_FORCE_INLINE void mult(const b3Transform& t1, const b3Transform& t2)
+	{
+		m_basis = t1.m_basis * t2.m_basis;
+		m_origin = t1(t2.m_origin);
+	}
+
+	/*		void multInverseLeft(const b3Transform& t1, const b3Transform& t2) {
+			b3Vector3 v = t2.m_origin - t1.m_origin;
+			m_basis = b3MultTransposeLeft(t1.m_basis, t2.m_basis);
+			m_origin = v * t1.m_basis;
+		}
+		*/
+
+	/**@brief Return the transform of the vector */
+	B3_FORCE_INLINE b3Vector3 operator()(const b3Vector3& x) const
+	{
+		return x.dot3(m_basis[0], m_basis[1], m_basis[2]) + m_origin;
+	}
+
+	/**@brief Return the transform of the vector */
+	B3_FORCE_INLINE b3Vector3 operator*(const b3Vector3& x) const
+	{
+		return (*this)(x);
+	}
+
+	/**@brief Return the transform of the b3Quaternion */
+	B3_FORCE_INLINE b3Quaternion operator*(const b3Quaternion& q) const
+	{
+		return getRotation() * q;
+	}
+
+	/**@brief Return the basis matrix for the rotation */
+	B3_FORCE_INLINE b3Matrix3x3& getBasis() { return m_basis; }
+	/**@brief Return the basis matrix for the rotation */
+	B3_FORCE_INLINE const b3Matrix3x3& getBasis() const { return m_basis; }
+
+	/**@brief Return the origin vector translation */
+	B3_FORCE_INLINE b3Vector3& getOrigin() { return m_origin; }
+	/**@brief Return the origin vector translation */
+	B3_FORCE_INLINE const b3Vector3& getOrigin() const { return m_origin; }
+
+	/**@brief Return a quaternion representing the rotation */
+	b3Quaternion getRotation() const
+	{
+		b3Quaternion q;
+		m_basis.getRotation(q);
+		return q;
+	}
+
+	/**@brief Set from an array 
+   * @param m A pointer to a 15 element array (12 rotation(row major padded on the right by 1), and 3 translation */
+	void setFromOpenGLMatrix(const b3Scalar* m)
+	{
+		m_basis.setFromOpenGLSubMatrix(m);
+		m_origin.setValue(m[12], m[13], m[14]);
+	}
+
+	/**@brief Fill an array representation
+   * @param m A pointer to a 15 element array (12 rotation(row major padded on the right by 1), and 3 translation */
+	void getOpenGLMatrix(b3Scalar * m) const
+	{
+		m_basis.getOpenGLSubMatrix(m);
+		m[12] = m_origin.getX();
+		m[13] = m_origin.getY();
+		m[14] = m_origin.getZ();
+		m[15] = b3Scalar(1.0);
+	}
+
+	/**@brief Set the translational element
+   * @param origin The vector to set the translation to */
+	B3_FORCE_INLINE void setOrigin(const b3Vector3& origin)
+	{
+		m_origin = origin;
+	}
+
+	B3_FORCE_INLINE b3Vector3 invXform(const b3Vector3& inVec) const;
+
+	/**@brief Set the rotational element by b3Matrix3x3 */
+	B3_FORCE_INLINE void setBasis(const b3Matrix3x3& basis)
+	{
+		m_basis = basis;
+	}
+
+	/**@brief Set the rotational element by b3Quaternion */
+	B3_FORCE_INLINE void setRotation(const b3Quaternion& q)
+	{
+		m_basis.setRotation(q);
+	}
+
+	/**@brief Set this transformation to the identity */
+	void setIdentity()
+	{
+		m_basis.setIdentity();
+		m_origin.setValue(b3Scalar(0.0), b3Scalar(0.0), b3Scalar(0.0));
+	}
+
+	/**@brief Multiply this Transform by another(this = this * another) 
+   * @param t The other transform */
+	b3Transform& operator*=(const b3Transform& t)
+	{
+		m_origin += m_basis * t.m_origin;
+		m_basis *= t.m_basis;
+		return *this;
+	}
+
+	/**@brief Return the inverse of this transform */
+	b3Transform inverse() const
+	{
+		b3Matrix3x3 inv = m_basis.transpose();
+		return b3Transform(inv, inv * -m_origin);
+	}
+
+	/**@brief Return the inverse of this transform times the other transform
+   * @param t The other transform 
+   * return this.inverse() * the other */
+	b3Transform inverseTimes(const b3Transform& t) const;
+
+	/**@brief Return the product of this transform and the other */
+	b3Transform operator*(const b3Transform& t) const;
+
+	/**@brief Return an identity transform */
+	static const b3Transform& getIdentity()
+	{
+		static const b3Transform identityTransform(b3Matrix3x3::getIdentity());
+		return identityTransform;
+	}
+
+	void serialize(struct b3TransformData & dataOut) const;
+
+	void serializeFloat(struct b3TransformFloatData & dataOut) const;
+
+	void deSerialize(const struct b3TransformData& dataIn);
+
+	void deSerializeDouble(const struct b3TransformDoubleData& dataIn);
+
+	void deSerializeFloat(const struct b3TransformFloatData& dataIn);
+};
+
+B3_FORCE_INLINE b3Vector3
+b3Transform::invXform(const b3Vector3& inVec) const
+{
+	b3Vector3 v = inVec - m_origin;
+	return (m_basis.transpose() * v);
+}
+
+B3_FORCE_INLINE b3Transform
+b3Transform::inverseTimes(const b3Transform& t) const
+{
+	b3Vector3 v = t.getOrigin() - m_origin;
+	return b3Transform(m_basis.transposeTimes(t.m_basis),
+					   v * m_basis);
+}
+
+B3_FORCE_INLINE b3Transform
+	b3Transform::operator*(const b3Transform& t) const
+{
+	return b3Transform(m_basis * t.m_basis,
+					   (*this)(t.m_origin));
+}
+
+/**@brief Test if two transforms have all elements equal */
+B3_FORCE_INLINE bool operator==(const b3Transform& t1, const b3Transform& t2)
+{
+	return (t1.getBasis() == t2.getBasis() &&
+			t1.getOrigin() == t2.getOrigin());
+}
+
+///for serialization
+struct b3TransformFloatData
+{
+	b3Matrix3x3FloatData m_basis;
+	b3Vector3FloatData m_origin;
+};
+
+struct b3TransformDoubleData
+{
+	b3Matrix3x3DoubleData m_basis;
+	b3Vector3DoubleData m_origin;
+};
+
+B3_FORCE_INLINE void b3Transform::serialize(b3TransformData& dataOut) const
+{
+	m_basis.serialize(dataOut.m_basis);
+	m_origin.serialize(dataOut.m_origin);
+}
+
+B3_FORCE_INLINE void b3Transform::serializeFloat(b3TransformFloatData& dataOut) const
+{
+	m_basis.serializeFloat(dataOut.m_basis);
+	m_origin.serializeFloat(dataOut.m_origin);
+}
+
+B3_FORCE_INLINE void b3Transform::deSerialize(const b3TransformData& dataIn)
+{
+	m_basis.deSerialize(dataIn.m_basis);
+	m_origin.deSerialize(dataIn.m_origin);
+}
+
+B3_FORCE_INLINE void b3Transform::deSerializeFloat(const b3TransformFloatData& dataIn)
+{
+	m_basis.deSerializeFloat(dataIn.m_basis);
+	m_origin.deSerializeFloat(dataIn.m_origin);
+}
+
+B3_FORCE_INLINE void b3Transform::deSerializeDouble(const b3TransformDoubleData& dataIn)
+{
+	m_basis.deSerializeDouble(dataIn.m_basis);
+	m_origin.deSerializeDouble(dataIn.m_origin);
+}
+
+#endif  //B3_TRANSFORM_H
diff --git a/engine/inc/bullet/Bullet3Common/b3TransformUtil.h b/engine/inc/bullet/Bullet3Common/b3TransformUtil.h
new file mode 100644
index 00000000..1850a9be
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Common/b3TransformUtil.h
@@ -0,0 +1,210 @@
+/*
+Copyright (c) 2003-2013 Gino van den Bergen / Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_TRANSFORM_UTIL_H
+#define B3_TRANSFORM_UTIL_H
+
+#include "b3Transform.h"
+#define B3_ANGULAR_MOTION_THRESHOLD b3Scalar(0.5) * B3_HALF_PI
+
+B3_FORCE_INLINE b3Vector3 b3AabbSupport(const b3Vector3& halfExtents, const b3Vector3& supportDir)
+{
+	return b3MakeVector3(supportDir.getX() < b3Scalar(0.0) ? -halfExtents.getX() : halfExtents.getX(),
+						 supportDir.getY() < b3Scalar(0.0) ? -halfExtents.getY() : halfExtents.getY(),
+						 supportDir.getZ() < b3Scalar(0.0) ? -halfExtents.getZ() : halfExtents.getZ());
+}
+
+/// Utils related to temporal transforms
+class b3TransformUtil
+{
+public:
+	static void integrateTransform(const b3Transform& curTrans, const b3Vector3& linvel, const b3Vector3& angvel, b3Scalar timeStep, b3Transform& predictedTransform)
+	{
+		predictedTransform.setOrigin(curTrans.getOrigin() + linvel * timeStep);
+		//	#define QUATERNION_DERIVATIVE
+#ifdef QUATERNION_DERIVATIVE
+		b3Quaternion predictedOrn = curTrans.getRotation();
+		predictedOrn += (angvel * predictedOrn) * (timeStep * b3Scalar(0.5));
+		predictedOrn.normalize();
+#else
+		//Exponential map
+		//google for "Practical Parameterization of Rotations Using the Exponential Map", F. Sebastian Grassia
+
+		b3Vector3 axis;
+		b3Scalar fAngle = angvel.length();
+		//limit the angular motion
+		if (fAngle * timeStep > B3_ANGULAR_MOTION_THRESHOLD)
+		{
+			fAngle = B3_ANGULAR_MOTION_THRESHOLD / timeStep;
+		}
+
+		if (fAngle < b3Scalar(0.001))
+		{
+			// use Taylor's expansions of sync function
+			axis = angvel * (b3Scalar(0.5) * timeStep - (timeStep * timeStep * timeStep) * (b3Scalar(0.020833333333)) * fAngle * fAngle);
+		}
+		else
+		{
+			// sync(fAngle) = sin(c*fAngle)/t
+			axis = angvel * (b3Sin(b3Scalar(0.5) * fAngle * timeStep) / fAngle);
+		}
+		b3Quaternion dorn(axis.getX(), axis.getY(), axis.getZ(), b3Cos(fAngle * timeStep * b3Scalar(0.5)));
+		b3Quaternion orn0 = curTrans.getRotation();
+
+		b3Quaternion predictedOrn = dorn * orn0;
+		predictedOrn.normalize();
+#endif
+		predictedTransform.setRotation(predictedOrn);
+	}
+
+	static void calculateVelocityQuaternion(const b3Vector3& pos0, const b3Vector3& pos1, const b3Quaternion& orn0, const b3Quaternion& orn1, b3Scalar timeStep, b3Vector3& linVel, b3Vector3& angVel)
+	{
+		linVel = (pos1 - pos0) / timeStep;
+		b3Vector3 axis;
+		b3Scalar angle;
+		if (orn0 != orn1)
+		{
+			calculateDiffAxisAngleQuaternion(orn0, orn1, axis, angle);
+			angVel = axis * angle / timeStep;
+		}
+		else
+		{
+			angVel.setValue(0, 0, 0);
+		}
+	}
+
+	static void calculateDiffAxisAngleQuaternion(const b3Quaternion& orn0, const b3Quaternion& orn1a, b3Vector3& axis, b3Scalar& angle)
+	{
+		b3Quaternion orn1 = orn0.nearest(orn1a);
+		b3Quaternion dorn = orn1 * orn0.inverse();
+		angle = dorn.getAngle();
+		axis = b3MakeVector3(dorn.getX(), dorn.getY(), dorn.getZ());
+		axis[3] = b3Scalar(0.);
+		//check for axis length
+		b3Scalar len = axis.length2();
+		if (len < B3_EPSILON * B3_EPSILON)
+			axis = b3MakeVector3(b3Scalar(1.), b3Scalar(0.), b3Scalar(0.));
+		else
+			axis /= b3Sqrt(len);
+	}
+
+	static void calculateVelocity(const b3Transform& transform0, const b3Transform& transform1, b3Scalar timeStep, b3Vector3& linVel, b3Vector3& angVel)
+	{
+		linVel = (transform1.getOrigin() - transform0.getOrigin()) / timeStep;
+		b3Vector3 axis;
+		b3Scalar angle;
+		calculateDiffAxisAngle(transform0, transform1, axis, angle);
+		angVel = axis * angle / timeStep;
+	}
+
+	static void calculateDiffAxisAngle(const b3Transform& transform0, const b3Transform& transform1, b3Vector3& axis, b3Scalar& angle)
+	{
+		b3Matrix3x3 dmat = transform1.getBasis() * transform0.getBasis().inverse();
+		b3Quaternion dorn;
+		dmat.getRotation(dorn);
+
+		///floating point inaccuracy can lead to w component > 1..., which breaks
+		dorn.normalize();
+
+		angle = dorn.getAngle();
+		axis = b3MakeVector3(dorn.getX(), dorn.getY(), dorn.getZ());
+		axis[3] = b3Scalar(0.);
+		//check for axis length
+		b3Scalar len = axis.length2();
+		if (len < B3_EPSILON * B3_EPSILON)
+			axis = b3MakeVector3(b3Scalar(1.), b3Scalar(0.), b3Scalar(0.));
+		else
+			axis /= b3Sqrt(len);
+	}
+};
+
+///The b3ConvexSeparatingDistanceUtil can help speed up convex collision detection
+///by conservatively updating a cached separating distance/vector instead of re-calculating the closest distance
+class b3ConvexSeparatingDistanceUtil
+{
+	b3Quaternion m_ornA;
+	b3Quaternion m_ornB;
+	b3Vector3 m_posA;
+	b3Vector3 m_posB;
+
+	b3Vector3 m_separatingNormal;
+
+	b3Scalar m_boundingRadiusA;
+	b3Scalar m_boundingRadiusB;
+	b3Scalar m_separatingDistance;
+
+public:
+	b3ConvexSeparatingDistanceUtil(b3Scalar boundingRadiusA, b3Scalar boundingRadiusB)
+		: m_boundingRadiusA(boundingRadiusA),
+		  m_boundingRadiusB(boundingRadiusB),
+		  m_separatingDistance(0.f)
+	{
+	}
+
+	b3Scalar getConservativeSeparatingDistance()
+	{
+		return m_separatingDistance;
+	}
+
+	void updateSeparatingDistance(const b3Transform& transA, const b3Transform& transB)
+	{
+		const b3Vector3& toPosA = transA.getOrigin();
+		const b3Vector3& toPosB = transB.getOrigin();
+		b3Quaternion toOrnA = transA.getRotation();
+		b3Quaternion toOrnB = transB.getRotation();
+
+		if (m_separatingDistance > 0.f)
+		{
+			b3Vector3 linVelA, angVelA, linVelB, angVelB;
+			b3TransformUtil::calculateVelocityQuaternion(m_posA, toPosA, m_ornA, toOrnA, b3Scalar(1.), linVelA, angVelA);
+			b3TransformUtil::calculateVelocityQuaternion(m_posB, toPosB, m_ornB, toOrnB, b3Scalar(1.), linVelB, angVelB);
+			b3Scalar maxAngularProjectedVelocity = angVelA.length() * m_boundingRadiusA + angVelB.length() * m_boundingRadiusB;
+			b3Vector3 relLinVel = (linVelB - linVelA);
+			b3Scalar relLinVelocLength = relLinVel.dot(m_separatingNormal);
+			if (relLinVelocLength < 0.f)
+			{
+				relLinVelocLength = 0.f;
+			}
+
+			b3Scalar projectedMotion = maxAngularProjectedVelocity + relLinVelocLength;
+			m_separatingDistance -= projectedMotion;
+		}
+
+		m_posA = toPosA;
+		m_posB = toPosB;
+		m_ornA = toOrnA;
+		m_ornB = toOrnB;
+	}
+
+	void initSeparatingDistance(const b3Vector3& separatingVector, b3Scalar separatingDistance, const b3Transform& transA, const b3Transform& transB)
+	{
+		m_separatingDistance = separatingDistance;
+
+		if (m_separatingDistance > 0.f)
+		{
+			m_separatingNormal = separatingVector;
+
+			const b3Vector3& toPosA = transA.getOrigin();
+			const b3Vector3& toPosB = transB.getOrigin();
+			b3Quaternion toOrnA = transA.getRotation();
+			b3Quaternion toOrnB = transB.getRotation();
+			m_posA = toPosA;
+			m_posB = toPosB;
+			m_ornA = toOrnA;
+			m_ornB = toOrnB;
+		}
+	}
+};
+
+#endif  //B3_TRANSFORM_UTIL_H
diff --git a/engine/inc/bullet/Bullet3Common/b3Vector3.h b/engine/inc/bullet/Bullet3Common/b3Vector3.h
new file mode 100644
index 00000000..a70d68d6
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Common/b3Vector3.h
@@ -0,0 +1,1303 @@
+/*
+Copyright (c) 2003-2013 Gino van den Bergen / Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_VECTOR3_H
+#define B3_VECTOR3_H
+
+//#include <stdint.h>
+#include "b3Scalar.h"
+#include "b3MinMax.h"
+#include "b3AlignedAllocator.h"
+
+#ifdef B3_USE_DOUBLE_PRECISION
+#define b3Vector3Data b3Vector3DoubleData
+#define b3Vector3DataName "b3Vector3DoubleData"
+#else
+#define b3Vector3Data b3Vector3FloatData
+#define b3Vector3DataName "b3Vector3FloatData"
+#endif  //B3_USE_DOUBLE_PRECISION
+
+#if defined B3_USE_SSE
+
+//typedef  uint32_t __m128i __attribute__ ((vector_size(16)));
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4556)  // value of intrinsic immediate argument '4294967239' is out of range '0 - 255'
+#endif
+
+#define B3_SHUFFLE(x, y, z, w) (((w) << 6 | (z) << 4 | (y) << 2 | (x)) & 0xff)
+//#define b3_pshufd_ps( _a, _mask ) (__m128) _mm_shuffle_epi32((__m128i)(_a), (_mask) )
+#define b3_pshufd_ps(_a, _mask) _mm_shuffle_ps((_a), (_a), (_mask))
+#define b3_splat3_ps(_a, _i) b3_pshufd_ps((_a), B3_SHUFFLE(_i, _i, _i, 3))
+#define b3_splat_ps(_a, _i) b3_pshufd_ps((_a), B3_SHUFFLE(_i, _i, _i, _i))
+
+#define b3v3AbsiMask (_mm_set_epi32(0x00000000, 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF))
+#define b3vAbsMask (_mm_set_epi32(0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF))
+#define b3vFFF0Mask (_mm_set_epi32(0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF))
+#define b3v3AbsfMask b3CastiTo128f(b3v3AbsiMask)
+#define b3vFFF0fMask b3CastiTo128f(b3vFFF0Mask)
+#define b3vxyzMaskf b3vFFF0fMask
+#define b3vAbsfMask b3CastiTo128f(b3vAbsMask)
+
+const __m128 B3_ATTRIBUTE_ALIGNED16(b3vMzeroMask) = {-0.0f, -0.0f, -0.0f, -0.0f};
+const __m128 B3_ATTRIBUTE_ALIGNED16(b3v1110) = {1.0f, 1.0f, 1.0f, 0.0f};
+const __m128 B3_ATTRIBUTE_ALIGNED16(b3vHalf) = {0.5f, 0.5f, 0.5f, 0.5f};
+const __m128 B3_ATTRIBUTE_ALIGNED16(b3v1_5) = {1.5f, 1.5f, 1.5f, 1.5f};
+
+#endif
+
+#ifdef B3_USE_NEON
+
+const float32x4_t B3_ATTRIBUTE_ALIGNED16(b3vMzeroMask) = (float32x4_t){-0.0f, -0.0f, -0.0f, -0.0f};
+const int32x4_t B3_ATTRIBUTE_ALIGNED16(b3vFFF0Mask) = (int32x4_t){0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0};
+const int32x4_t B3_ATTRIBUTE_ALIGNED16(b3vAbsMask) = (int32x4_t){0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF};
+const int32x4_t B3_ATTRIBUTE_ALIGNED16(b3v3AbsMask) = (int32x4_t){0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF, 0x0};
+
+#endif
+
+class b3Vector3;
+class b3Vector4;
+
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+//#if defined (B3_USE_SSE) || defined (B3_USE_NEON)
+inline b3Vector3 b3MakeVector3(b3SimdFloat4 v);
+inline b3Vector4 b3MakeVector4(b3SimdFloat4 vec);
+#endif
+
+inline b3Vector3 b3MakeVector3(b3Scalar x, b3Scalar y, b3Scalar z);
+inline b3Vector3 b3MakeVector3(b3Scalar x, b3Scalar y, b3Scalar z, b3Scalar w);
+inline b3Vector4 b3MakeVector4(b3Scalar x, b3Scalar y, b3Scalar z, b3Scalar w);
+
+/**@brief b3Vector3 can be used to represent 3D points and vectors.
+ * It has an un-used w component to suit 16-byte alignment when b3Vector3 is stored in containers. This extra component can be used by derived classes (Quaternion?) or by user
+ * Ideally, this class should be replaced by a platform optimized SIMD version that keeps the data in registers
+ */
+B3_ATTRIBUTE_ALIGNED16(class)
+b3Vector3
+{
+public:
+#if defined(B3_USE_SSE) || defined(B3_USE_NEON)  // _WIN32 || ARM
+	union {
+		b3SimdFloat4 mVec128;
+		float m_floats[4];
+		struct
+		{
+			float x, y, z, w;
+		};
+	};
+#else
+	union {
+		float m_floats[4];
+		struct
+		{
+			float x, y, z, w;
+		};
+	};
+#endif
+
+public:
+	B3_DECLARE_ALIGNED_ALLOCATOR();
+
+#if defined(B3_USE_SSE) || defined(B3_USE_NEON)  // _WIN32 || ARM
+
+	/*B3_FORCE_INLINE		b3Vector3()
+	{
+	}
+	*/
+
+	B3_FORCE_INLINE b3SimdFloat4 get128() const
+	{
+		return mVec128;
+	}
+	B3_FORCE_INLINE void set128(b3SimdFloat4 v128)
+	{
+		mVec128 = v128;
+	}
+#endif
+
+public:
+	/**@brief Add a vector to this one
+ * @param The vector to add to this one */
+	B3_FORCE_INLINE b3Vector3& operator+=(const b3Vector3& v)
+	{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+		mVec128 = _mm_add_ps(mVec128, v.mVec128);
+#elif defined(B3_USE_NEON)
+		mVec128 = vaddq_f32(mVec128, v.mVec128);
+#else
+		m_floats[0] += v.m_floats[0];
+		m_floats[1] += v.m_floats[1];
+		m_floats[2] += v.m_floats[2];
+#endif
+		return *this;
+	}
+
+	/**@brief Subtract a vector from this one
+   * @param The vector to subtract */
+	B3_FORCE_INLINE b3Vector3& operator-=(const b3Vector3& v)
+	{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+		mVec128 = _mm_sub_ps(mVec128, v.mVec128);
+#elif defined(B3_USE_NEON)
+		mVec128 = vsubq_f32(mVec128, v.mVec128);
+#else
+		m_floats[0] -= v.m_floats[0];
+		m_floats[1] -= v.m_floats[1];
+		m_floats[2] -= v.m_floats[2];
+#endif
+		return *this;
+	}
+
+	/**@brief Scale the vector
+   * @param s Scale factor */
+	B3_FORCE_INLINE b3Vector3& operator*=(const b3Scalar& s)
+	{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+		__m128 vs = _mm_load_ss(&s);  //	(S 0 0 0)
+		vs = b3_pshufd_ps(vs, 0x80);  //	(S S S 0.0)
+		mVec128 = _mm_mul_ps(mVec128, vs);
+#elif defined(B3_USE_NEON)
+		mVec128 = vmulq_n_f32(mVec128, s);
+#else
+		m_floats[0] *= s;
+		m_floats[1] *= s;
+		m_floats[2] *= s;
+#endif
+		return *this;
+	}
+
+	/**@brief Inversely scale the vector
+   * @param s Scale factor to divide by */
+	B3_FORCE_INLINE b3Vector3& operator/=(const b3Scalar& s)
+	{
+		b3FullAssert(s != b3Scalar(0.0));
+
+#if 0  //defined(B3_USE_SSE_IN_API)
+// this code is not faster !
+		__m128 vs = _mm_load_ss(&s);
+		vs = _mm_div_ss(b3v1110, vs);
+		vs = b3_pshufd_ps(vs, 0x00);	//	(S S S S)
+
+		mVec128 = _mm_mul_ps(mVec128, vs);
+
+		return *this;
+#else
+		return *this *= b3Scalar(1.0) / s;
+#endif
+	}
+
+	/**@brief Return the dot product
+   * @param v The other vector in the dot product */
+	B3_FORCE_INLINE b3Scalar dot(const b3Vector3& v) const
+	{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+		__m128 vd = _mm_mul_ps(mVec128, v.mVec128);
+		__m128 z = _mm_movehl_ps(vd, vd);
+		__m128 y = _mm_shuffle_ps(vd, vd, 0x55);
+		vd = _mm_add_ss(vd, y);
+		vd = _mm_add_ss(vd, z);
+		return _mm_cvtss_f32(vd);
+#elif defined(B3_USE_NEON)
+		float32x4_t vd = vmulq_f32(mVec128, v.mVec128);
+		float32x2_t x = vpadd_f32(vget_low_f32(vd), vget_low_f32(vd));
+		x = vadd_f32(x, vget_high_f32(vd));
+		return vget_lane_f32(x, 0);
+#else
+		return m_floats[0] * v.m_floats[0] +
+			   m_floats[1] * v.m_floats[1] +
+			   m_floats[2] * v.m_floats[2];
+#endif
+	}
+
+	/**@brief Return the length of the vector squared */
+	B3_FORCE_INLINE b3Scalar length2() const
+	{
+		return dot(*this);
+	}
+
+	/**@brief Return the length of the vector */
+	B3_FORCE_INLINE b3Scalar length() const
+	{
+		return b3Sqrt(length2());
+	}
+
+	/**@brief Return the distance squared between the ends of this and another vector
+   * This is symantically treating the vector like a point */
+	B3_FORCE_INLINE b3Scalar distance2(const b3Vector3& v) const;
+
+	/**@brief Return the distance between the ends of this and another vector
+   * This is symantically treating the vector like a point */
+	B3_FORCE_INLINE b3Scalar distance(const b3Vector3& v) const;
+
+	B3_FORCE_INLINE b3Vector3& safeNormalize()
+	{
+		b3Scalar l2 = length2();
+		//triNormal.normalize();
+		if (l2 >= B3_EPSILON * B3_EPSILON)
+		{
+			(*this) /= b3Sqrt(l2);
+		}
+		else
+		{
+			setValue(1, 0, 0);
+		}
+		return *this;
+	}
+
+	/**@brief Normalize this vector
+   * x^2 + y^2 + z^2 = 1 */
+	B3_FORCE_INLINE b3Vector3& normalize()
+	{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+		// dot product first
+		__m128 vd = _mm_mul_ps(mVec128, mVec128);
+		__m128 z = _mm_movehl_ps(vd, vd);
+		__m128 y = _mm_shuffle_ps(vd, vd, 0x55);
+		vd = _mm_add_ss(vd, y);
+		vd = _mm_add_ss(vd, z);
+
+#if 0
+        vd = _mm_sqrt_ss(vd);
+		vd = _mm_div_ss(b3v1110, vd);
+		vd = b3_splat_ps(vd, 0x80);
+		mVec128 = _mm_mul_ps(mVec128, vd);
+#else
+
+		// NR step 1/sqrt(x) - vd is x, y is output
+		y = _mm_rsqrt_ss(vd);  // estimate
+
+		//  one step NR
+		z = b3v1_5;
+		vd = _mm_mul_ss(vd, b3vHalf);  // vd * 0.5
+		//x2 = vd;
+		vd = _mm_mul_ss(vd, y);  // vd * 0.5 * y0
+		vd = _mm_mul_ss(vd, y);  // vd * 0.5 * y0 * y0
+		z = _mm_sub_ss(z, vd);   // 1.5 - vd * 0.5 * y0 * y0
+
+		y = _mm_mul_ss(y, z);  // y0 * (1.5 - vd * 0.5 * y0 * y0)
+
+		y = b3_splat_ps(y, 0x80);
+		mVec128 = _mm_mul_ps(mVec128, y);
+
+#endif
+
+		return *this;
+#else
+		return *this /= length();
+#endif
+	}
+
+	/**@brief Return a normalized version of this vector */
+	B3_FORCE_INLINE b3Vector3 normalized() const;
+
+	/**@brief Return a rotated version of this vector
+   * @param wAxis The axis to rotate about
+   * @param angle The angle to rotate by */
+	B3_FORCE_INLINE b3Vector3 rotate(const b3Vector3& wAxis, const b3Scalar angle) const;
+
+	/**@brief Return the angle between this and another vector
+   * @param v The other vector */
+	B3_FORCE_INLINE b3Scalar angle(const b3Vector3& v) const
+	{
+		b3Scalar s = b3Sqrt(length2() * v.length2());
+		b3FullAssert(s != b3Scalar(0.0));
+		return b3Acos(dot(v) / s);
+	}
+
+	/**@brief Return a vector will the absolute values of each element */
+	B3_FORCE_INLINE b3Vector3 absolute() const
+	{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+		return b3MakeVector3(_mm_and_ps(mVec128, b3v3AbsfMask));
+#elif defined(B3_USE_NEON)
+		return b3Vector3(vabsq_f32(mVec128));
+#else
+		return b3MakeVector3(
+			b3Fabs(m_floats[0]),
+			b3Fabs(m_floats[1]),
+			b3Fabs(m_floats[2]));
+#endif
+	}
+
+	/**@brief Return the cross product between this and another vector
+   * @param v The other vector */
+	B3_FORCE_INLINE b3Vector3 cross(const b3Vector3& v) const
+	{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+		__m128 T, V;
+
+		T = b3_pshufd_ps(mVec128, B3_SHUFFLE(1, 2, 0, 3));    //	(Y Z X 0)
+		V = b3_pshufd_ps(v.mVec128, B3_SHUFFLE(1, 2, 0, 3));  //	(Y Z X 0)
+
+		V = _mm_mul_ps(V, mVec128);
+		T = _mm_mul_ps(T, v.mVec128);
+		V = _mm_sub_ps(V, T);
+
+		V = b3_pshufd_ps(V, B3_SHUFFLE(1, 2, 0, 3));
+		return b3MakeVector3(V);
+#elif defined(B3_USE_NEON)
+		float32x4_t T, V;
+		// form (Y, Z, X, _) of mVec128 and v.mVec128
+		float32x2_t Tlow = vget_low_f32(mVec128);
+		float32x2_t Vlow = vget_low_f32(v.mVec128);
+		T = vcombine_f32(vext_f32(Tlow, vget_high_f32(mVec128), 1), Tlow);
+		V = vcombine_f32(vext_f32(Vlow, vget_high_f32(v.mVec128), 1), Vlow);
+
+		V = vmulq_f32(V, mVec128);
+		T = vmulq_f32(T, v.mVec128);
+		V = vsubq_f32(V, T);
+		Vlow = vget_low_f32(V);
+		// form (Y, Z, X, _);
+		V = vcombine_f32(vext_f32(Vlow, vget_high_f32(V), 1), Vlow);
+		V = (float32x4_t)vandq_s32((int32x4_t)V, b3vFFF0Mask);
+
+		return b3Vector3(V);
+#else
+		return b3MakeVector3(
+			m_floats[1] * v.m_floats[2] - m_floats[2] * v.m_floats[1],
+			m_floats[2] * v.m_floats[0] - m_floats[0] * v.m_floats[2],
+			m_floats[0] * v.m_floats[1] - m_floats[1] * v.m_floats[0]);
+#endif
+	}
+
+	B3_FORCE_INLINE b3Scalar triple(const b3Vector3& v1, const b3Vector3& v2) const
+	{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+		// cross:
+		__m128 T = _mm_shuffle_ps(v1.mVec128, v1.mVec128, B3_SHUFFLE(1, 2, 0, 3));  //	(Y Z X 0)
+		__m128 V = _mm_shuffle_ps(v2.mVec128, v2.mVec128, B3_SHUFFLE(1, 2, 0, 3));  //	(Y Z X 0)
+
+		V = _mm_mul_ps(V, v1.mVec128);
+		T = _mm_mul_ps(T, v2.mVec128);
+		V = _mm_sub_ps(V, T);
+
+		V = _mm_shuffle_ps(V, V, B3_SHUFFLE(1, 2, 0, 3));
+
+		// dot:
+		V = _mm_mul_ps(V, mVec128);
+		__m128 z = _mm_movehl_ps(V, V);
+		__m128 y = _mm_shuffle_ps(V, V, 0x55);
+		V = _mm_add_ss(V, y);
+		V = _mm_add_ss(V, z);
+		return _mm_cvtss_f32(V);
+
+#elif defined(B3_USE_NEON)
+		// cross:
+		float32x4_t T, V;
+		// form (Y, Z, X, _) of mVec128 and v.mVec128
+		float32x2_t Tlow = vget_low_f32(v1.mVec128);
+		float32x2_t Vlow = vget_low_f32(v2.mVec128);
+		T = vcombine_f32(vext_f32(Tlow, vget_high_f32(v1.mVec128), 1), Tlow);
+		V = vcombine_f32(vext_f32(Vlow, vget_high_f32(v2.mVec128), 1), Vlow);
+
+		V = vmulq_f32(V, v1.mVec128);
+		T = vmulq_f32(T, v2.mVec128);
+		V = vsubq_f32(V, T);
+		Vlow = vget_low_f32(V);
+		// form (Y, Z, X, _);
+		V = vcombine_f32(vext_f32(Vlow, vget_high_f32(V), 1), Vlow);
+
+		// dot:
+		V = vmulq_f32(mVec128, V);
+		float32x2_t x = vpadd_f32(vget_low_f32(V), vget_low_f32(V));
+		x = vadd_f32(x, vget_high_f32(V));
+		return vget_lane_f32(x, 0);
+#else
+		return m_floats[0] * (v1.m_floats[1] * v2.m_floats[2] - v1.m_floats[2] * v2.m_floats[1]) +
+			   m_floats[1] * (v1.m_floats[2] * v2.m_floats[0] - v1.m_floats[0] * v2.m_floats[2]) +
+			   m_floats[2] * (v1.m_floats[0] * v2.m_floats[1] - v1.m_floats[1] * v2.m_floats[0]);
+#endif
+	}
+
+	/**@brief Return the axis with the smallest value
+   * Note return values are 0,1,2 for x, y, or z */
+	B3_FORCE_INLINE int minAxis() const
+	{
+		return m_floats[0] < m_floats[1] ? (m_floats[0] < m_floats[2] ? 0 : 2) : (m_floats[1] < m_floats[2] ? 1 : 2);
+	}
+
+	/**@brief Return the axis with the largest value
+   * Note return values are 0,1,2 for x, y, or z */
+	B3_FORCE_INLINE int maxAxis() const
+	{
+		return m_floats[0] < m_floats[1] ? (m_floats[1] < m_floats[2] ? 2 : 1) : (m_floats[0] < m_floats[2] ? 2 : 0);
+	}
+
+	B3_FORCE_INLINE int furthestAxis() const
+	{
+		return absolute().minAxis();
+	}
+
+	B3_FORCE_INLINE int closestAxis() const
+	{
+		return absolute().maxAxis();
+	}
+
+	B3_FORCE_INLINE void setInterpolate3(const b3Vector3& v0, const b3Vector3& v1, b3Scalar rt)
+	{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+		__m128 vrt = _mm_load_ss(&rt);  //	(rt 0 0 0)
+		b3Scalar s = b3Scalar(1.0) - rt;
+		__m128 vs = _mm_load_ss(&s);  //	(S 0 0 0)
+		vs = b3_pshufd_ps(vs, 0x80);  //	(S S S 0.0)
+		__m128 r0 = _mm_mul_ps(v0.mVec128, vs);
+		vrt = b3_pshufd_ps(vrt, 0x80);  //	(rt rt rt 0.0)
+		__m128 r1 = _mm_mul_ps(v1.mVec128, vrt);
+		__m128 tmp3 = _mm_add_ps(r0, r1);
+		mVec128 = tmp3;
+#elif defined(B3_USE_NEON)
+		float32x4_t vl = vsubq_f32(v1.mVec128, v0.mVec128);
+		vl = vmulq_n_f32(vl, rt);
+		mVec128 = vaddq_f32(vl, v0.mVec128);
+#else
+		b3Scalar s = b3Scalar(1.0) - rt;
+		m_floats[0] = s * v0.m_floats[0] + rt * v1.m_floats[0];
+		m_floats[1] = s * v0.m_floats[1] + rt * v1.m_floats[1];
+		m_floats[2] = s * v0.m_floats[2] + rt * v1.m_floats[2];
+		//don't do the unused w component
+		//		m_co[3] = s * v0[3] + rt * v1[3];
+#endif
+	}
+
+	/**@brief Return the linear interpolation between this and another vector
+   * @param v The other vector
+   * @param t The ration of this to v (t = 0 => return this, t=1 => return other) */
+	B3_FORCE_INLINE b3Vector3 lerp(const b3Vector3& v, const b3Scalar& t) const
+	{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+		__m128 vt = _mm_load_ss(&t);  //	(t 0 0 0)
+		vt = b3_pshufd_ps(vt, 0x80);  //	(rt rt rt 0.0)
+		__m128 vl = _mm_sub_ps(v.mVec128, mVec128);
+		vl = _mm_mul_ps(vl, vt);
+		vl = _mm_add_ps(vl, mVec128);
+
+		return b3MakeVector3(vl);
+#elif defined(B3_USE_NEON)
+		float32x4_t vl = vsubq_f32(v.mVec128, mVec128);
+		vl = vmulq_n_f32(vl, t);
+		vl = vaddq_f32(vl, mVec128);
+
+		return b3Vector3(vl);
+#else
+		return b3MakeVector3(m_floats[0] + (v.m_floats[0] - m_floats[0]) * t,
+							 m_floats[1] + (v.m_floats[1] - m_floats[1]) * t,
+							 m_floats[2] + (v.m_floats[2] - m_floats[2]) * t);
+#endif
+	}
+
+	/**@brief Elementwise multiply this vector by the other
+   * @param v The other vector */
+	B3_FORCE_INLINE b3Vector3& operator*=(const b3Vector3& v)
+	{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+		mVec128 = _mm_mul_ps(mVec128, v.mVec128);
+#elif defined(B3_USE_NEON)
+		mVec128 = vmulq_f32(mVec128, v.mVec128);
+#else
+		m_floats[0] *= v.m_floats[0];
+		m_floats[1] *= v.m_floats[1];
+		m_floats[2] *= v.m_floats[2];
+#endif
+		return *this;
+	}
+
+	/**@brief Return the x value */
+	B3_FORCE_INLINE const b3Scalar& getX() const { return m_floats[0]; }
+	/**@brief Return the y value */
+	B3_FORCE_INLINE const b3Scalar& getY() const { return m_floats[1]; }
+	/**@brief Return the z value */
+	B3_FORCE_INLINE const b3Scalar& getZ() const { return m_floats[2]; }
+	/**@brief Return the w value */
+	B3_FORCE_INLINE const b3Scalar& getW() const { return m_floats[3]; }
+
+	/**@brief Set the x value */
+	B3_FORCE_INLINE void setX(b3Scalar _x) { m_floats[0] = _x; };
+	/**@brief Set the y value */
+	B3_FORCE_INLINE void setY(b3Scalar _y) { m_floats[1] = _y; };
+	/**@brief Set the z value */
+	B3_FORCE_INLINE void setZ(b3Scalar _z) { m_floats[2] = _z; };
+	/**@brief Set the w value */
+	B3_FORCE_INLINE void setW(b3Scalar _w) { m_floats[3] = _w; };
+
+	//B3_FORCE_INLINE b3Scalar&       operator[](int i)       { return (&m_floats[0])[i];	}
+	//B3_FORCE_INLINE const b3Scalar& operator[](int i) const { return (&m_floats[0])[i]; }
+	///operator b3Scalar*() replaces operator[], using implicit conversion. We added operator != and operator == to avoid pointer comparisons.
+	B3_FORCE_INLINE operator b3Scalar*() { return &m_floats[0]; }
+	B3_FORCE_INLINE operator const b3Scalar*() const { return &m_floats[0]; }
+
+	B3_FORCE_INLINE bool operator==(const b3Vector3& other) const
+	{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+		return (0xf == _mm_movemask_ps((__m128)_mm_cmpeq_ps(mVec128, other.mVec128)));
+#else
+		return ((m_floats[3] == other.m_floats[3]) &&
+				(m_floats[2] == other.m_floats[2]) &&
+				(m_floats[1] == other.m_floats[1]) &&
+				(m_floats[0] == other.m_floats[0]));
+#endif
+	}
+
+	B3_FORCE_INLINE bool operator!=(const b3Vector3& other) const
+	{
+		return !(*this == other);
+	}
+
+	/**@brief Set each element to the max of the current values and the values of another b3Vector3
+   * @param other The other b3Vector3 to compare with
+   */
+	B3_FORCE_INLINE void setMax(const b3Vector3& other)
+	{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+		mVec128 = _mm_max_ps(mVec128, other.mVec128);
+#elif defined(B3_USE_NEON)
+		mVec128 = vmaxq_f32(mVec128, other.mVec128);
+#else
+		b3SetMax(m_floats[0], other.m_floats[0]);
+		b3SetMax(m_floats[1], other.m_floats[1]);
+		b3SetMax(m_floats[2], other.m_floats[2]);
+		b3SetMax(m_floats[3], other.m_floats[3]);
+#endif
+	}
+
+	/**@brief Set each element to the min of the current values and the values of another b3Vector3
+   * @param other The other b3Vector3 to compare with
+   */
+	B3_FORCE_INLINE void setMin(const b3Vector3& other)
+	{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+		mVec128 = _mm_min_ps(mVec128, other.mVec128);
+#elif defined(B3_USE_NEON)
+		mVec128 = vminq_f32(mVec128, other.mVec128);
+#else
+		b3SetMin(m_floats[0], other.m_floats[0]);
+		b3SetMin(m_floats[1], other.m_floats[1]);
+		b3SetMin(m_floats[2], other.m_floats[2]);
+		b3SetMin(m_floats[3], other.m_floats[3]);
+#endif
+	}
+
+	B3_FORCE_INLINE void setValue(const b3Scalar& _x, const b3Scalar& _y, const b3Scalar& _z)
+	{
+		m_floats[0] = _x;
+		m_floats[1] = _y;
+		m_floats[2] = _z;
+		m_floats[3] = b3Scalar(0.f);
+	}
+
+	void getSkewSymmetricMatrix(b3Vector3 * v0, b3Vector3 * v1, b3Vector3 * v2) const
+	{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+
+		__m128 V = _mm_and_ps(mVec128, b3vFFF0fMask);
+		__m128 V0 = _mm_xor_ps(b3vMzeroMask, V);
+		__m128 V2 = _mm_movelh_ps(V0, V);
+
+		__m128 V1 = _mm_shuffle_ps(V, V0, 0xCE);
+
+		V0 = _mm_shuffle_ps(V0, V, 0xDB);
+		V2 = _mm_shuffle_ps(V2, V, 0xF9);
+
+		v0->mVec128 = V0;
+		v1->mVec128 = V1;
+		v2->mVec128 = V2;
+#else
+		v0->setValue(0., -getZ(), getY());
+		v1->setValue(getZ(), 0., -getX());
+		v2->setValue(-getY(), getX(), 0.);
+#endif
+	}
+
+	void setZero()
+	{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+		mVec128 = (__m128)_mm_xor_ps(mVec128, mVec128);
+#elif defined(B3_USE_NEON)
+		int32x4_t vi = vdupq_n_s32(0);
+		mVec128 = vreinterpretq_f32_s32(vi);
+#else
+		setValue(b3Scalar(0.), b3Scalar(0.), b3Scalar(0.));
+#endif
+	}
+
+	B3_FORCE_INLINE bool isZero() const
+	{
+		return m_floats[0] == b3Scalar(0) && m_floats[1] == b3Scalar(0) && m_floats[2] == b3Scalar(0);
+	}
+
+	B3_FORCE_INLINE bool fuzzyZero() const
+	{
+		return length2() < B3_EPSILON;
+	}
+
+	B3_FORCE_INLINE void serialize(struct b3Vector3Data & dataOut) const;
+
+	B3_FORCE_INLINE void deSerialize(const struct b3Vector3Data& dataIn);
+
+	B3_FORCE_INLINE void serializeFloat(struct b3Vector3FloatData & dataOut) const;
+
+	B3_FORCE_INLINE void deSerializeFloat(const struct b3Vector3FloatData& dataIn);
+
+	B3_FORCE_INLINE void serializeDouble(struct b3Vector3DoubleData & dataOut) const;
+
+	B3_FORCE_INLINE void deSerializeDouble(const struct b3Vector3DoubleData& dataIn);
+
+	/**@brief returns index of maximum dot product between this and vectors in array[]
+         * @param array The other vectors
+         * @param array_count The number of other vectors
+         * @param dotOut The maximum dot product */
+	B3_FORCE_INLINE long maxDot(const b3Vector3* array, long array_count, b3Scalar& dotOut) const;
+
+	/**@brief returns index of minimum dot product between this and vectors in array[]
+         * @param array The other vectors
+         * @param array_count The number of other vectors
+         * @param dotOut The minimum dot product */
+	B3_FORCE_INLINE long minDot(const b3Vector3* array, long array_count, b3Scalar& dotOut) const;
+
+	/* create a vector as  b3Vector3( this->dot( b3Vector3 v0 ), this->dot( b3Vector3 v1), this->dot( b3Vector3 v2 ))  */
+	B3_FORCE_INLINE b3Vector3 dot3(const b3Vector3& v0, const b3Vector3& v1, const b3Vector3& v2) const
+	{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+
+		__m128 a0 = _mm_mul_ps(v0.mVec128, this->mVec128);
+		__m128 a1 = _mm_mul_ps(v1.mVec128, this->mVec128);
+		__m128 a2 = _mm_mul_ps(v2.mVec128, this->mVec128);
+		__m128 b0 = _mm_unpacklo_ps(a0, a1);
+		__m128 b1 = _mm_unpackhi_ps(a0, a1);
+		__m128 b2 = _mm_unpacklo_ps(a2, _mm_setzero_ps());
+		__m128 r = _mm_movelh_ps(b0, b2);
+		r = _mm_add_ps(r, _mm_movehl_ps(b2, b0));
+		a2 = _mm_and_ps(a2, b3vxyzMaskf);
+		r = _mm_add_ps(r, b3CastdTo128f(_mm_move_sd(b3CastfTo128d(a2), b3CastfTo128d(b1))));
+		return b3MakeVector3(r);
+
+#elif defined(B3_USE_NEON)
+		static const uint32x4_t xyzMask = (const uint32x4_t){-1, -1, -1, 0};
+		float32x4_t a0 = vmulq_f32(v0.mVec128, this->mVec128);
+		float32x4_t a1 = vmulq_f32(v1.mVec128, this->mVec128);
+		float32x4_t a2 = vmulq_f32(v2.mVec128, this->mVec128);
+		float32x2x2_t zLo = vtrn_f32(vget_high_f32(a0), vget_high_f32(a1));
+		a2 = (float32x4_t)vandq_u32((uint32x4_t)a2, xyzMask);
+		float32x2_t b0 = vadd_f32(vpadd_f32(vget_low_f32(a0), vget_low_f32(a1)), zLo.val[0]);
+		float32x2_t b1 = vpadd_f32(vpadd_f32(vget_low_f32(a2), vget_high_f32(a2)), vdup_n_f32(0.0f));
+		return b3Vector3(vcombine_f32(b0, b1));
+#else
+		return b3MakeVector3(dot(v0), dot(v1), dot(v2));
+#endif
+	}
+};
+
+/**@brief Return the sum of two vectors (Point symantics)*/
+B3_FORCE_INLINE b3Vector3
+operator+(const b3Vector3& v1, const b3Vector3& v2)
+{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+	return b3MakeVector3(_mm_add_ps(v1.mVec128, v2.mVec128));
+#elif defined(B3_USE_NEON)
+	return b3MakeVector3(vaddq_f32(v1.mVec128, v2.mVec128));
+#else
+	return b3MakeVector3(
+		v1.m_floats[0] + v2.m_floats[0],
+		v1.m_floats[1] + v2.m_floats[1],
+		v1.m_floats[2] + v2.m_floats[2]);
+#endif
+}
+
+/**@brief Return the elementwise product of two vectors */
+B3_FORCE_INLINE b3Vector3
+operator*(const b3Vector3& v1, const b3Vector3& v2)
+{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+	return b3MakeVector3(_mm_mul_ps(v1.mVec128, v2.mVec128));
+#elif defined(B3_USE_NEON)
+	return b3MakeVector3(vmulq_f32(v1.mVec128, v2.mVec128));
+#else
+	return b3MakeVector3(
+		v1.m_floats[0] * v2.m_floats[0],
+		v1.m_floats[1] * v2.m_floats[1],
+		v1.m_floats[2] * v2.m_floats[2]);
+#endif
+}
+
+/**@brief Return the difference between two vectors */
+B3_FORCE_INLINE b3Vector3
+operator-(const b3Vector3& v1, const b3Vector3& v2)
+{
+#if (defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE))
+
+	//	without _mm_and_ps this code causes slowdown in Concave moving
+	__m128 r = _mm_sub_ps(v1.mVec128, v2.mVec128);
+	return b3MakeVector3(_mm_and_ps(r, b3vFFF0fMask));
+#elif defined(B3_USE_NEON)
+	float32x4_t r = vsubq_f32(v1.mVec128, v2.mVec128);
+	return b3MakeVector3((float32x4_t)vandq_s32((int32x4_t)r, b3vFFF0Mask));
+#else
+	return b3MakeVector3(
+		v1.m_floats[0] - v2.m_floats[0],
+		v1.m_floats[1] - v2.m_floats[1],
+		v1.m_floats[2] - v2.m_floats[2]);
+#endif
+}
+
+/**@brief Return the negative of the vector */
+B3_FORCE_INLINE b3Vector3
+operator-(const b3Vector3& v)
+{
+#if (defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE))
+	__m128 r = _mm_xor_ps(v.mVec128, b3vMzeroMask);
+	return b3MakeVector3(_mm_and_ps(r, b3vFFF0fMask));
+#elif defined(B3_USE_NEON)
+	return b3MakeVector3((b3SimdFloat4)veorq_s32((int32x4_t)v.mVec128, (int32x4_t)b3vMzeroMask));
+#else
+	return b3MakeVector3(-v.m_floats[0], -v.m_floats[1], -v.m_floats[2]);
+#endif
+}
+
+/**@brief Return the vector scaled by s */
+B3_FORCE_INLINE b3Vector3
+operator*(const b3Vector3& v, const b3Scalar& s)
+{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+	__m128 vs = _mm_load_ss(&s);  //	(S 0 0 0)
+	vs = b3_pshufd_ps(vs, 0x80);  //	(S S S 0.0)
+	return b3MakeVector3(_mm_mul_ps(v.mVec128, vs));
+#elif defined(B3_USE_NEON)
+	float32x4_t r = vmulq_n_f32(v.mVec128, s);
+	return b3MakeVector3((float32x4_t)vandq_s32((int32x4_t)r, b3vFFF0Mask));
+#else
+	return b3MakeVector3(v.m_floats[0] * s, v.m_floats[1] * s, v.m_floats[2] * s);
+#endif
+}
+
+/**@brief Return the vector scaled by s */
+B3_FORCE_INLINE b3Vector3
+operator*(const b3Scalar& s, const b3Vector3& v)
+{
+	return v * s;
+}
+
+/**@brief Return the vector inversely scaled by s */
+B3_FORCE_INLINE b3Vector3
+operator/(const b3Vector3& v, const b3Scalar& s)
+{
+	b3FullAssert(s != b3Scalar(0.0));
+#if 0  //defined(B3_USE_SSE_IN_API)
+// this code is not faster !
+	__m128 vs = _mm_load_ss(&s);
+    vs = _mm_div_ss(b3v1110, vs);
+	vs = b3_pshufd_ps(vs, 0x00);	//	(S S S S)
+
+	return b3Vector3(_mm_mul_ps(v.mVec128, vs));
+#else
+	return v * (b3Scalar(1.0) / s);
+#endif
+}
+
+/**@brief Return the vector inversely scaled by s */
+B3_FORCE_INLINE b3Vector3
+operator/(const b3Vector3& v1, const b3Vector3& v2)
+{
+#if (defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE))
+	__m128 vec = _mm_div_ps(v1.mVec128, v2.mVec128);
+	vec = _mm_and_ps(vec, b3vFFF0fMask);
+	return b3MakeVector3(vec);
+#elif defined(B3_USE_NEON)
+	float32x4_t x, y, v, m;
+
+	x = v1.mVec128;
+	y = v2.mVec128;
+
+	v = vrecpeq_f32(y);     // v ~ 1/y
+	m = vrecpsq_f32(y, v);  // m = (2-v*y)
+	v = vmulq_f32(v, m);    // vv = v*m ~~ 1/y
+	m = vrecpsq_f32(y, v);  // mm = (2-vv*y)
+	v = vmulq_f32(v, x);    // x*vv
+	v = vmulq_f32(v, m);    // (x*vv)*(2-vv*y) = x*(vv(2-vv*y)) ~~~ x/y
+
+	return b3Vector3(v);
+#else
+	return b3MakeVector3(
+		v1.m_floats[0] / v2.m_floats[0],
+		v1.m_floats[1] / v2.m_floats[1],
+		v1.m_floats[2] / v2.m_floats[2]);
+#endif
+}
+
+/**@brief Return the dot product between two vectors */
+B3_FORCE_INLINE b3Scalar
+b3Dot(const b3Vector3& v1, const b3Vector3& v2)
+{
+	return v1.dot(v2);
+}
+
+/**@brief Return the distance squared between two vectors */
+B3_FORCE_INLINE b3Scalar
+b3Distance2(const b3Vector3& v1, const b3Vector3& v2)
+{
+	return v1.distance2(v2);
+}
+
+/**@brief Return the distance between two vectors */
+B3_FORCE_INLINE b3Scalar
+b3Distance(const b3Vector3& v1, const b3Vector3& v2)
+{
+	return v1.distance(v2);
+}
+
+/**@brief Return the angle between two vectors */
+B3_FORCE_INLINE b3Scalar
+b3Angle(const b3Vector3& v1, const b3Vector3& v2)
+{
+	return v1.angle(v2);
+}
+
+/**@brief Return the cross product of two vectors */
+B3_FORCE_INLINE b3Vector3
+b3Cross(const b3Vector3& v1, const b3Vector3& v2)
+{
+	return v1.cross(v2);
+}
+
+B3_FORCE_INLINE b3Scalar
+b3Triple(const b3Vector3& v1, const b3Vector3& v2, const b3Vector3& v3)
+{
+	return v1.triple(v2, v3);
+}
+
+/**@brief Return the linear interpolation between two vectors
+ * @param v1 One vector
+ * @param v2 The other vector
+ * @param t The ration of this to v (t = 0 => return v1, t=1 => return v2) */
+B3_FORCE_INLINE b3Vector3
+b3Lerp(const b3Vector3& v1, const b3Vector3& v2, const b3Scalar& t)
+{
+	return v1.lerp(v2, t);
+}
+
+B3_FORCE_INLINE b3Scalar b3Vector3::distance2(const b3Vector3& v) const
+{
+	return (v - *this).length2();
+}
+
+B3_FORCE_INLINE b3Scalar b3Vector3::distance(const b3Vector3& v) const
+{
+	return (v - *this).length();
+}
+
+B3_FORCE_INLINE b3Vector3 b3Vector3::normalized() const
+{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+	b3Vector3 norm = *this;
+
+	return norm.normalize();
+#else
+	return *this / length();
+#endif
+}
+
+B3_FORCE_INLINE b3Vector3 b3Vector3::rotate(const b3Vector3& wAxis, const b3Scalar _angle) const
+{
+	// wAxis must be a unit lenght vector
+
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+
+	__m128 O = _mm_mul_ps(wAxis.mVec128, mVec128);
+	b3Scalar ssin = b3Sin(_angle);
+	__m128 C = wAxis.cross(b3MakeVector3(mVec128)).mVec128;
+	O = _mm_and_ps(O, b3vFFF0fMask);
+	b3Scalar scos = b3Cos(_angle);
+
+	__m128 vsin = _mm_load_ss(&ssin);  //	(S 0 0 0)
+	__m128 vcos = _mm_load_ss(&scos);  //	(S 0 0 0)
+
+	__m128 Y = b3_pshufd_ps(O, 0xC9);  //	(Y Z X 0)
+	__m128 Z = b3_pshufd_ps(O, 0xD2);  //	(Z X Y 0)
+	O = _mm_add_ps(O, Y);
+	vsin = b3_pshufd_ps(vsin, 0x80);  //	(S S S 0)
+	O = _mm_add_ps(O, Z);
+	vcos = b3_pshufd_ps(vcos, 0x80);  //	(S S S 0)
+
+	vsin = vsin * C;
+	O = O * wAxis.mVec128;
+	__m128 X = mVec128 - O;
+
+	O = O + vsin;
+	vcos = vcos * X;
+	O = O + vcos;
+
+	return b3MakeVector3(O);
+#else
+	b3Vector3 o = wAxis * wAxis.dot(*this);
+	b3Vector3 _x = *this - o;
+	b3Vector3 _y;
+
+	_y = wAxis.cross(*this);
+
+	return (o + _x * b3Cos(_angle) + _y * b3Sin(_angle));
+#endif
+}
+
+B3_FORCE_INLINE long b3Vector3::maxDot(const b3Vector3* array, long array_count, b3Scalar& dotOut) const
+{
+#if defined(B3_USE_SSE) || defined(B3_USE_NEON)
+#if defined _WIN32 || defined(B3_USE_SSE)
+	const long scalar_cutoff = 10;
+	long b3_maxdot_large(const float* array, const float* vec, unsigned long array_count, float* dotOut);
+#elif defined B3_USE_NEON
+	const long scalar_cutoff = 4;
+	extern long (*_maxdot_large)(const float* array, const float* vec, unsigned long array_count, float* dotOut);
+#endif
+	if (array_count < scalar_cutoff)
+#else
+
+#endif  //B3_USE_SSE || B3_USE_NEON
+	{
+		b3Scalar maxDot = -B3_INFINITY;
+		int i = 0;
+		int ptIndex = -1;
+		for (i = 0; i < array_count; i++)
+		{
+			b3Scalar dot = array[i].dot(*this);
+
+			if (dot > maxDot)
+			{
+				maxDot = dot;
+				ptIndex = i;
+			}
+		}
+
+		b3Assert(ptIndex >= 0);
+		if (ptIndex < 0)
+		{
+			ptIndex = 0;
+		}
+		dotOut = maxDot;
+		return ptIndex;
+	}
+#if defined(B3_USE_SSE) || defined(B3_USE_NEON)
+	return b3_maxdot_large((float*)array, (float*)&m_floats[0], array_count, &dotOut);
+#endif
+}
+
+B3_FORCE_INLINE long b3Vector3::minDot(const b3Vector3* array, long array_count, b3Scalar& dotOut) const
+{
+#if defined(B3_USE_SSE) || defined(B3_USE_NEON)
+#if defined B3_USE_SSE
+	const long scalar_cutoff = 10;
+	long b3_mindot_large(const float* array, const float* vec, unsigned long array_count, float* dotOut);
+#elif defined B3_USE_NEON
+	const long scalar_cutoff = 4;
+	extern long (*b3_mindot_large)(const float* array, const float* vec, unsigned long array_count, float* dotOut);
+#else
+#error unhandled arch!
+#endif
+
+	if (array_count < scalar_cutoff)
+#endif  //B3_USE_SSE || B3_USE_NEON
+	{
+		b3Scalar minDot = B3_INFINITY;
+		int i = 0;
+		int ptIndex = -1;
+
+		for (i = 0; i < array_count; i++)
+		{
+			b3Scalar dot = array[i].dot(*this);
+
+			if (dot < minDot)
+			{
+				minDot = dot;
+				ptIndex = i;
+			}
+		}
+
+		dotOut = minDot;
+
+		return ptIndex;
+	}
+#if defined(B3_USE_SSE) || defined(B3_USE_NEON)
+	return b3_mindot_large((float*)array, (float*)&m_floats[0], array_count, &dotOut);
+#endif
+}
+
+class b3Vector4 : public b3Vector3
+{
+public:
+	B3_FORCE_INLINE b3Vector4 absolute4() const
+	{
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+		return b3MakeVector4(_mm_and_ps(mVec128, b3vAbsfMask));
+#elif defined(B3_USE_NEON)
+		return b3Vector4(vabsq_f32(mVec128));
+#else
+		return b3MakeVector4(
+			b3Fabs(m_floats[0]),
+			b3Fabs(m_floats[1]),
+			b3Fabs(m_floats[2]),
+			b3Fabs(m_floats[3]));
+#endif
+	}
+
+	b3Scalar getW() const { return m_floats[3]; }
+
+	B3_FORCE_INLINE int maxAxis4() const
+	{
+		int maxIndex = -1;
+		b3Scalar maxVal = b3Scalar(-B3_LARGE_FLOAT);
+		if (m_floats[0] > maxVal)
+		{
+			maxIndex = 0;
+			maxVal = m_floats[0];
+		}
+		if (m_floats[1] > maxVal)
+		{
+			maxIndex = 1;
+			maxVal = m_floats[1];
+		}
+		if (m_floats[2] > maxVal)
+		{
+			maxIndex = 2;
+			maxVal = m_floats[2];
+		}
+		if (m_floats[3] > maxVal)
+		{
+			maxIndex = 3;
+		}
+
+		return maxIndex;
+	}
+
+	B3_FORCE_INLINE int minAxis4() const
+	{
+		int minIndex = -1;
+		b3Scalar minVal = b3Scalar(B3_LARGE_FLOAT);
+		if (m_floats[0] < minVal)
+		{
+			minIndex = 0;
+			minVal = m_floats[0];
+		}
+		if (m_floats[1] < minVal)
+		{
+			minIndex = 1;
+			minVal = m_floats[1];
+		}
+		if (m_floats[2] < minVal)
+		{
+			minIndex = 2;
+			minVal = m_floats[2];
+		}
+		if (m_floats[3] < minVal)
+		{
+			minIndex = 3;
+			minVal = m_floats[3];
+		}
+
+		return minIndex;
+	}
+
+	B3_FORCE_INLINE int closestAxis4() const
+	{
+		return absolute4().maxAxis4();
+	}
+
+	/**@brief Set x,y,z and zero w
+   * @param x Value of x
+   * @param y Value of y
+   * @param z Value of z
+   */
+
+	/*		void getValue(b3Scalar *m) const
+		{
+			m[0] = m_floats[0];
+			m[1] = m_floats[1];
+			m[2] =m_floats[2];
+		}
+*/
+	/**@brief Set the values
+   * @param x Value of x
+   * @param y Value of y
+   * @param z Value of z
+   * @param w Value of w
+   */
+	B3_FORCE_INLINE void setValue(const b3Scalar& _x, const b3Scalar& _y, const b3Scalar& _z, const b3Scalar& _w)
+	{
+		m_floats[0] = _x;
+		m_floats[1] = _y;
+		m_floats[2] = _z;
+		m_floats[3] = _w;
+	}
+};
+
+///b3SwapVector3Endian swaps vector endianness, useful for network and cross-platform serialization
+B3_FORCE_INLINE void b3SwapScalarEndian(const b3Scalar& sourceVal, b3Scalar& destVal)
+{
+#ifdef B3_USE_DOUBLE_PRECISION
+	unsigned char* dest = (unsigned char*)&destVal;
+	unsigned char* src = (unsigned char*)&sourceVal;
+	dest[0] = src[7];
+	dest[1] = src[6];
+	dest[2] = src[5];
+	dest[3] = src[4];
+	dest[4] = src[3];
+	dest[5] = src[2];
+	dest[6] = src[1];
+	dest[7] = src[0];
+#else
+	unsigned char* dest = (unsigned char*)&destVal;
+	unsigned char* src = (unsigned char*)&sourceVal;
+	dest[0] = src[3];
+	dest[1] = src[2];
+	dest[2] = src[1];
+	dest[3] = src[0];
+#endif  //B3_USE_DOUBLE_PRECISION
+}
+///b3SwapVector3Endian swaps vector endianness, useful for network and cross-platform serialization
+B3_FORCE_INLINE void b3SwapVector3Endian(const b3Vector3& sourceVec, b3Vector3& destVec)
+{
+	for (int i = 0; i < 4; i++)
+	{
+		b3SwapScalarEndian(sourceVec[i], destVec[i]);
+	}
+}
+
+///b3UnSwapVector3Endian swaps vector endianness, useful for network and cross-platform serialization
+B3_FORCE_INLINE void b3UnSwapVector3Endian(b3Vector3& vector)
+{
+	b3Vector3 swappedVec;
+	for (int i = 0; i < 4; i++)
+	{
+		b3SwapScalarEndian(vector[i], swappedVec[i]);
+	}
+	vector = swappedVec;
+}
+
+template <class T>
+B3_FORCE_INLINE void b3PlaneSpace1(const T& n, T& p, T& q)
+{
+	if (b3Fabs(n[2]) > B3_SQRT12)
+	{
+		// choose p in y-z plane
+		b3Scalar a = n[1] * n[1] + n[2] * n[2];
+		b3Scalar k = b3RecipSqrt(a);
+		p[0] = 0;
+		p[1] = -n[2] * k;
+		p[2] = n[1] * k;
+		// set q = n x p
+		q[0] = a * k;
+		q[1] = -n[0] * p[2];
+		q[2] = n[0] * p[1];
+	}
+	else
+	{
+		// choose p in x-y plane
+		b3Scalar a = n[0] * n[0] + n[1] * n[1];
+		b3Scalar k = b3RecipSqrt(a);
+		p[0] = -n[1] * k;
+		p[1] = n[0] * k;
+		p[2] = 0;
+		// set q = n x p
+		q[0] = -n[2] * p[1];
+		q[1] = n[2] * p[0];
+		q[2] = a * k;
+	}
+}
+
+struct b3Vector3FloatData
+{
+	float m_floats[4];
+};
+
+struct b3Vector3DoubleData
+{
+	double m_floats[4];
+};
+
+B3_FORCE_INLINE void b3Vector3::serializeFloat(struct b3Vector3FloatData& dataOut) const
+{
+	///could also do a memcpy, check if it is worth it
+	for (int i = 0; i < 4; i++)
+		dataOut.m_floats[i] = float(m_floats[i]);
+}
+
+B3_FORCE_INLINE void b3Vector3::deSerializeFloat(const struct b3Vector3FloatData& dataIn)
+{
+	for (int i = 0; i < 4; i++)
+		m_floats[i] = b3Scalar(dataIn.m_floats[i]);
+}
+
+B3_FORCE_INLINE void b3Vector3::serializeDouble(struct b3Vector3DoubleData& dataOut) const
+{
+	///could also do a memcpy, check if it is worth it
+	for (int i = 0; i < 4; i++)
+		dataOut.m_floats[i] = double(m_floats[i]);
+}
+
+B3_FORCE_INLINE void b3Vector3::deSerializeDouble(const struct b3Vector3DoubleData& dataIn)
+{
+	for (int i = 0; i < 4; i++)
+		m_floats[i] = b3Scalar(dataIn.m_floats[i]);
+}
+
+B3_FORCE_INLINE void b3Vector3::serialize(struct b3Vector3Data& dataOut) const
+{
+	///could also do a memcpy, check if it is worth it
+	for (int i = 0; i < 4; i++)
+		dataOut.m_floats[i] = m_floats[i];
+}
+
+B3_FORCE_INLINE void b3Vector3::deSerialize(const struct b3Vector3Data& dataIn)
+{
+	for (int i = 0; i < 4; i++)
+		m_floats[i] = dataIn.m_floats[i];
+}
+
+inline b3Vector3 b3MakeVector3(b3Scalar x, b3Scalar y, b3Scalar z)
+{
+	b3Vector3 tmp;
+	tmp.setValue(x, y, z);
+	return tmp;
+}
+
+inline b3Vector3 b3MakeVector3(b3Scalar x, b3Scalar y, b3Scalar z, b3Scalar w)
+{
+	b3Vector3 tmp;
+	tmp.setValue(x, y, z);
+	tmp.w = w;
+	return tmp;
+}
+
+inline b3Vector4 b3MakeVector4(b3Scalar x, b3Scalar y, b3Scalar z, b3Scalar w)
+{
+	b3Vector4 tmp;
+	tmp.setValue(x, y, z, w);
+	return tmp;
+}
+
+#if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)
+
+inline b3Vector3 b3MakeVector3(b3SimdFloat4 v)
+{
+	b3Vector3 tmp;
+	tmp.set128(v);
+	return tmp;
+}
+
+inline b3Vector4 b3MakeVector4(b3SimdFloat4 vec)
+{
+	b3Vector4 tmp;
+	tmp.set128(vec);
+	return tmp;
+}
+
+#endif
+
+#endif  //B3_VECTOR3_H
diff --git a/engine/inc/bullet/Bullet3Common/shared/b3Float4.h b/engine/inc/bullet/Bullet3Common/shared/b3Float4.h
new file mode 100644
index 00000000..d8a9f474
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Common/shared/b3Float4.h
@@ -0,0 +1,90 @@
+#ifndef B3_FLOAT4_H
+#define B3_FLOAT4_H
+
+#include "Bullet3Common/shared/b3PlatformDefinitions.h"
+
+#ifdef __cplusplus
+#include "Bullet3Common/b3Vector3.h"
+#define b3Float4 b3Vector3
+#define b3Float4ConstArg const b3Vector3&
+#define b3Dot3F4 b3Dot
+#define b3Cross3 b3Cross
+#define b3MakeFloat4 b3MakeVector3
+inline b3Vector3 b3Normalized(const b3Vector3& vec)
+{
+	return vec.normalized();
+}
+
+inline b3Float4 b3FastNormalized3(b3Float4ConstArg v)
+{
+	return v.normalized();
+}
+
+inline b3Float4 b3MaxFloat4(const b3Float4& a, const b3Float4& b)
+{
+	b3Float4 tmp = a;
+	tmp.setMax(b);
+	return tmp;
+}
+inline b3Float4 b3MinFloat4(const b3Float4& a, const b3Float4& b)
+{
+	b3Float4 tmp = a;
+	tmp.setMin(b);
+	return tmp;
+}
+
+#else
+typedef float4 b3Float4;
+#define b3Float4ConstArg const b3Float4
+#define b3MakeFloat4 (float4)
+float b3Dot3F4(b3Float4ConstArg v0, b3Float4ConstArg v1)
+{
+	float4 a1 = b3MakeFloat4(v0.xyz, 0.f);
+	float4 b1 = b3MakeFloat4(v1.xyz, 0.f);
+	return dot(a1, b1);
+}
+b3Float4 b3Cross3(b3Float4ConstArg v0, b3Float4ConstArg v1)
+{
+	float4 a1 = b3MakeFloat4(v0.xyz, 0.f);
+	float4 b1 = b3MakeFloat4(v1.xyz, 0.f);
+	return cross(a1, b1);
+}
+#define b3MinFloat4 min
+#define b3MaxFloat4 max
+
+#define b3Normalized(a) normalize(a)
+
+#endif
+
+inline bool b3IsAlmostZero(b3Float4ConstArg v)
+{
+	if (b3Fabs(v.x) > 1e-6 || b3Fabs(v.y) > 1e-6 || b3Fabs(v.z) > 1e-6)
+		return false;
+	return true;
+}
+
+inline int b3MaxDot(b3Float4ConstArg vec, __global const b3Float4* vecArray, int vecLen, float* dotOut)
+{
+	float maxDot = -B3_INFINITY;
+	int i = 0;
+	int ptIndex = -1;
+	for (i = 0; i < vecLen; i++)
+	{
+		float dot = b3Dot3F4(vecArray[i], vec);
+
+		if (dot > maxDot)
+		{
+			maxDot = dot;
+			ptIndex = i;
+		}
+	}
+	b3Assert(ptIndex >= 0);
+	if (ptIndex < 0)
+	{
+		ptIndex = 0;
+	}
+	*dotOut = maxDot;
+	return ptIndex;
+}
+
+#endif  //B3_FLOAT4_H
diff --git a/engine/inc/bullet/Bullet3Common/shared/b3Int2.h b/engine/inc/bullet/Bullet3Common/shared/b3Int2.h
new file mode 100644
index 00000000..7b84de44
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Common/shared/b3Int2.h
@@ -0,0 +1,63 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_INT2_H
+#define B3_INT2_H
+
+#ifdef __cplusplus
+
+struct b3UnsignedInt2
+{
+	union {
+		struct
+		{
+			unsigned int x, y;
+		};
+		struct
+		{
+			unsigned int s[2];
+		};
+	};
+};
+
+struct b3Int2
+{
+	union {
+		struct
+		{
+			int x, y;
+		};
+		struct
+		{
+			int s[2];
+		};
+	};
+};
+
+inline b3Int2 b3MakeInt2(int x, int y)
+{
+	b3Int2 v;
+	v.s[0] = x;
+	v.s[1] = y;
+	return v;
+}
+#else
+
+#define b3UnsignedInt2 uint2
+#define b3Int2 int2
+#define b3MakeInt2 (int2)
+
+#endif  //__cplusplus
+#endif
\ No newline at end of file
diff --git a/engine/inc/bullet/Bullet3Common/shared/b3Int4.h b/engine/inc/bullet/Bullet3Common/shared/b3Int4.h
new file mode 100644
index 00000000..f6a17542
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Common/shared/b3Int4.h
@@ -0,0 +1,71 @@
+#ifndef B3_INT4_H
+#define B3_INT4_H
+
+#ifdef __cplusplus
+
+#include "Bullet3Common/b3Scalar.h"
+
+B3_ATTRIBUTE_ALIGNED16(struct)
+b3UnsignedInt4
+{
+	B3_DECLARE_ALIGNED_ALLOCATOR();
+
+	union {
+		struct
+		{
+			unsigned int x, y, z, w;
+		};
+		struct
+		{
+			unsigned int s[4];
+		};
+	};
+};
+
+B3_ATTRIBUTE_ALIGNED16(struct)
+b3Int4
+{
+	B3_DECLARE_ALIGNED_ALLOCATOR();
+
+	union {
+		struct
+		{
+			int x, y, z, w;
+		};
+		struct
+		{
+			int s[4];
+		};
+	};
+};
+
+B3_FORCE_INLINE b3Int4 b3MakeInt4(int x, int y, int z, int w = 0)
+{
+	b3Int4 v;
+	v.s[0] = x;
+	v.s[1] = y;
+	v.s[2] = z;
+	v.s[3] = w;
+	return v;
+}
+
+B3_FORCE_INLINE b3UnsignedInt4 b3MakeUnsignedInt4(unsigned int x, unsigned int y, unsigned int z, unsigned int w = 0)
+{
+	b3UnsignedInt4 v;
+	v.s[0] = x;
+	v.s[1] = y;
+	v.s[2] = z;
+	v.s[3] = w;
+	return v;
+}
+
+#else
+
+#define b3UnsignedInt4 uint4
+#define b3Int4 int4
+#define b3MakeInt4 (int4)
+#define b3MakeUnsignedInt4 (uint4)
+
+#endif  //__cplusplus
+
+#endif  //B3_INT4_H
diff --git a/engine/inc/bullet/Bullet3Common/shared/b3Mat3x3.h b/engine/inc/bullet/Bullet3Common/shared/b3Mat3x3.h
new file mode 100644
index 00000000..ce6482b5
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Common/shared/b3Mat3x3.h
@@ -0,0 +1,157 @@
+
+#ifndef B3_MAT3x3_H
+#define B3_MAT3x3_H
+
+#include "Bullet3Common/shared/b3Quat.h"
+
+#ifdef __cplusplus
+
+#include "Bullet3Common/b3Matrix3x3.h"
+
+#define b3Mat3x3 b3Matrix3x3
+#define b3Mat3x3ConstArg const b3Matrix3x3&
+
+inline b3Mat3x3 b3QuatGetRotationMatrix(b3QuatConstArg quat)
+{
+	return b3Mat3x3(quat);
+}
+
+inline b3Mat3x3 b3AbsoluteMat3x3(b3Mat3x3ConstArg mat)
+{
+	return mat.absolute();
+}
+
+#define b3GetRow(m, row) m.getRow(row)
+
+__inline b3Float4 mtMul3(b3Float4ConstArg a, b3Mat3x3ConstArg b)
+{
+	return b * a;
+}
+
+#else
+
+typedef struct
+{
+	b3Float4 m_row[3];
+} b3Mat3x3;
+
+#define b3Mat3x3ConstArg const b3Mat3x3
+#define b3GetRow(m, row) (m.m_row[row])
+
+inline b3Mat3x3 b3QuatGetRotationMatrix(b3Quat quat)
+{
+	b3Float4 quat2 = (b3Float4)(quat.x * quat.x, quat.y * quat.y, quat.z * quat.z, 0.f);
+	b3Mat3x3 out;
+
+	out.m_row[0].x = 1 - 2 * quat2.y - 2 * quat2.z;
+	out.m_row[0].y = 2 * quat.x * quat.y - 2 * quat.w * quat.z;
+	out.m_row[0].z = 2 * quat.x * quat.z + 2 * quat.w * quat.y;
+	out.m_row[0].w = 0.f;
+
+	out.m_row[1].x = 2 * quat.x * quat.y + 2 * quat.w * quat.z;
+	out.m_row[1].y = 1 - 2 * quat2.x - 2 * quat2.z;
+	out.m_row[1].z = 2 * quat.y * quat.z - 2 * quat.w * quat.x;
+	out.m_row[1].w = 0.f;
+
+	out.m_row[2].x = 2 * quat.x * quat.z - 2 * quat.w * quat.y;
+	out.m_row[2].y = 2 * quat.y * quat.z + 2 * quat.w * quat.x;
+	out.m_row[2].z = 1 - 2 * quat2.x - 2 * quat2.y;
+	out.m_row[2].w = 0.f;
+
+	return out;
+}
+
+inline b3Mat3x3 b3AbsoluteMat3x3(b3Mat3x3ConstArg matIn)
+{
+	b3Mat3x3 out;
+	out.m_row[0] = fabs(matIn.m_row[0]);
+	out.m_row[1] = fabs(matIn.m_row[1]);
+	out.m_row[2] = fabs(matIn.m_row[2]);
+	return out;
+}
+
+__inline b3Mat3x3 mtZero();
+
+__inline b3Mat3x3 mtIdentity();
+
+__inline b3Mat3x3 mtTranspose(b3Mat3x3 m);
+
+__inline b3Mat3x3 mtMul(b3Mat3x3 a, b3Mat3x3 b);
+
+__inline b3Float4 mtMul1(b3Mat3x3 a, b3Float4 b);
+
+__inline b3Float4 mtMul3(b3Float4 a, b3Mat3x3 b);
+
+__inline b3Mat3x3 mtZero()
+{
+	b3Mat3x3 m;
+	m.m_row[0] = (b3Float4)(0.f);
+	m.m_row[1] = (b3Float4)(0.f);
+	m.m_row[2] = (b3Float4)(0.f);
+	return m;
+}
+
+__inline b3Mat3x3 mtIdentity()
+{
+	b3Mat3x3 m;
+	m.m_row[0] = (b3Float4)(1, 0, 0, 0);
+	m.m_row[1] = (b3Float4)(0, 1, 0, 0);
+	m.m_row[2] = (b3Float4)(0, 0, 1, 0);
+	return m;
+}
+
+__inline b3Mat3x3 mtTranspose(b3Mat3x3 m)
+{
+	b3Mat3x3 out;
+	out.m_row[0] = (b3Float4)(m.m_row[0].x, m.m_row[1].x, m.m_row[2].x, 0.f);
+	out.m_row[1] = (b3Float4)(m.m_row[0].y, m.m_row[1].y, m.m_row[2].y, 0.f);
+	out.m_row[2] = (b3Float4)(m.m_row[0].z, m.m_row[1].z, m.m_row[2].z, 0.f);
+	return out;
+}
+
+__inline b3Mat3x3 mtMul(b3Mat3x3 a, b3Mat3x3 b)
+{
+	b3Mat3x3 transB;
+	transB = mtTranspose(b);
+	b3Mat3x3 ans;
+	//	why this doesn't run when 0ing in the for{}
+	a.m_row[0].w = 0.f;
+	a.m_row[1].w = 0.f;
+	a.m_row[2].w = 0.f;
+	for (int i = 0; i < 3; i++)
+	{
+		//	a.m_row[i].w = 0.f;
+		ans.m_row[i].x = b3Dot3F4(a.m_row[i], transB.m_row[0]);
+		ans.m_row[i].y = b3Dot3F4(a.m_row[i], transB.m_row[1]);
+		ans.m_row[i].z = b3Dot3F4(a.m_row[i], transB.m_row[2]);
+		ans.m_row[i].w = 0.f;
+	}
+	return ans;
+}
+
+__inline b3Float4 mtMul1(b3Mat3x3 a, b3Float4 b)
+{
+	b3Float4 ans;
+	ans.x = b3Dot3F4(a.m_row[0], b);
+	ans.y = b3Dot3F4(a.m_row[1], b);
+	ans.z = b3Dot3F4(a.m_row[2], b);
+	ans.w = 0.f;
+	return ans;
+}
+
+__inline b3Float4 mtMul3(b3Float4 a, b3Mat3x3 b)
+{
+	b3Float4 colx = b3MakeFloat4(b.m_row[0].x, b.m_row[1].x, b.m_row[2].x, 0);
+	b3Float4 coly = b3MakeFloat4(b.m_row[0].y, b.m_row[1].y, b.m_row[2].y, 0);
+	b3Float4 colz = b3MakeFloat4(b.m_row[0].z, b.m_row[1].z, b.m_row[2].z, 0);
+
+	b3Float4 ans;
+	ans.x = b3Dot3F4(a, colx);
+	ans.y = b3Dot3F4(a, coly);
+	ans.z = b3Dot3F4(a, colz);
+	return ans;
+}
+
+#endif
+
+#endif  //B3_MAT3x3_H
diff --git a/engine/inc/bullet/Bullet3Common/shared/b3PlatformDefinitions.h b/engine/inc/bullet/Bullet3Common/shared/b3PlatformDefinitions.h
new file mode 100644
index 00000000..b72bee93
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Common/shared/b3PlatformDefinitions.h
@@ -0,0 +1,41 @@
+#ifndef B3_PLATFORM_DEFINITIONS_H
+#define B3_PLATFORM_DEFINITIONS_H
+
+struct MyTest
+{
+	int bla;
+};
+
+#ifdef __cplusplus
+//#define b3ConstArray(a) const b3AlignedObjectArray<a>&
+#define b3ConstArray(a) const a *
+#define b3AtomicInc(a) ((*a)++)
+
+inline int b3AtomicAdd(volatile int *p, int val)
+{
+	int oldValue = *p;
+	int newValue = oldValue + val;
+	*p = newValue;
+	return oldValue;
+}
+
+#define __global
+
+#define B3_STATIC static
+#else
+//keep B3_LARGE_FLOAT*B3_LARGE_FLOAT < FLT_MAX
+#define B3_LARGE_FLOAT 1e18f
+#define B3_INFINITY 1e18f
+#define b3Assert(a)
+#define b3ConstArray(a) __global const a *
+#define b3AtomicInc atomic_inc
+#define b3AtomicAdd atomic_add
+#define b3Fabs fabs
+#define b3Sqrt native_sqrt
+#define b3Sin native_sin
+#define b3Cos native_cos
+
+#define B3_STATIC
+#endif
+
+#endif
diff --git a/engine/inc/bullet/Bullet3Common/shared/b3Quat.h b/engine/inc/bullet/Bullet3Common/shared/b3Quat.h
new file mode 100644
index 00000000..940610c7
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Common/shared/b3Quat.h
@@ -0,0 +1,100 @@
+#ifndef B3_QUAT_H
+#define B3_QUAT_H
+
+#include "Bullet3Common/shared/b3PlatformDefinitions.h"
+#include "Bullet3Common/shared/b3Float4.h"
+
+#ifdef __cplusplus
+#include "Bullet3Common/b3Quaternion.h"
+#include "Bullet3Common/b3Transform.h"
+
+#define b3Quat b3Quaternion
+#define b3QuatConstArg const b3Quaternion&
+inline b3Quat b3QuatInverse(b3QuatConstArg orn)
+{
+	return orn.inverse();
+}
+
+inline b3Float4 b3TransformPoint(b3Float4ConstArg point, b3Float4ConstArg translation, b3QuatConstArg orientation)
+{
+	b3Transform tr;
+	tr.setOrigin(translation);
+	tr.setRotation(orientation);
+	return tr(point);
+}
+
+#else
+typedef float4 b3Quat;
+#define b3QuatConstArg const b3Quat
+
+inline float4 b3FastNormalize4(float4 v)
+{
+	v = (float4)(v.xyz, 0.f);
+	return fast_normalize(v);
+}
+
+inline b3Quat b3QuatMul(b3Quat a, b3Quat b);
+inline b3Quat b3QuatNormalized(b3QuatConstArg in);
+inline b3Quat b3QuatRotate(b3QuatConstArg q, b3QuatConstArg vec);
+inline b3Quat b3QuatInvert(b3QuatConstArg q);
+inline b3Quat b3QuatInverse(b3QuatConstArg q);
+
+inline b3Quat b3QuatMul(b3QuatConstArg a, b3QuatConstArg b)
+{
+	b3Quat ans;
+	ans = b3Cross3(a, b);
+	ans += a.w * b + b.w * a;
+	//	ans.w = a.w*b.w - (a.x*b.x+a.y*b.y+a.z*b.z);
+	ans.w = a.w * b.w - b3Dot3F4(a, b);
+	return ans;
+}
+
+inline b3Quat b3QuatNormalized(b3QuatConstArg in)
+{
+	b3Quat q;
+	q = in;
+	//return b3FastNormalize4(in);
+	float len = native_sqrt(dot(q, q));
+	if (len > 0.f)
+	{
+		q *= 1.f / len;
+	}
+	else
+	{
+		q.x = q.y = q.z = 0.f;
+		q.w = 1.f;
+	}
+	return q;
+}
+inline float4 b3QuatRotate(b3QuatConstArg q, b3QuatConstArg vec)
+{
+	b3Quat qInv = b3QuatInvert(q);
+	float4 vcpy = vec;
+	vcpy.w = 0.f;
+	float4 out = b3QuatMul(b3QuatMul(q, vcpy), qInv);
+	return out;
+}
+
+inline b3Quat b3QuatInverse(b3QuatConstArg q)
+{
+	return (b3Quat)(-q.xyz, q.w);
+}
+
+inline b3Quat b3QuatInvert(b3QuatConstArg q)
+{
+	return (b3Quat)(-q.xyz, q.w);
+}
+
+inline float4 b3QuatInvRotate(b3QuatConstArg q, b3QuatConstArg vec)
+{
+	return b3QuatRotate(b3QuatInvert(q), vec);
+}
+
+inline b3Float4 b3TransformPoint(b3Float4ConstArg point, b3Float4ConstArg translation, b3QuatConstArg orientation)
+{
+	return b3QuatRotate(orientation, point) + (translation);
+}
+
+#endif
+
+#endif  //B3_QUAT_H
diff --git a/engine/inc/bullet/Bullet3Dynamics/ConstraintSolver/b3ContactSolverInfo.h b/engine/inc/bullet/Bullet3Dynamics/ConstraintSolver/b3ContactSolverInfo.h
new file mode 100644
index 00000000..049c9116
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Dynamics/ConstraintSolver/b3ContactSolverInfo.h
@@ -0,0 +1,149 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_CONTACT_SOLVER_INFO
+#define B3_CONTACT_SOLVER_INFO
+
+#include "Bullet3Common/b3Scalar.h"
+
+enum b3SolverMode
+{
+	B3_SOLVER_RANDMIZE_ORDER = 1,
+	B3_SOLVER_FRICTION_SEPARATE = 2,
+	B3_SOLVER_USE_WARMSTARTING = 4,
+	B3_SOLVER_USE_2_FRICTION_DIRECTIONS = 16,
+	B3_SOLVER_ENABLE_FRICTION_DIRECTION_CACHING = 32,
+	B3_SOLVER_DISABLE_VELOCITY_DEPENDENT_FRICTION_DIRECTION = 64,
+	B3_SOLVER_CACHE_FRIENDLY = 128,
+	B3_SOLVER_SIMD = 256,
+	B3_SOLVER_INTERLEAVE_CONTACT_AND_FRICTION_CONSTRAINTS = 512,
+	B3_SOLVER_ALLOW_ZERO_LENGTH_FRICTION_DIRECTIONS = 1024
+};
+
+struct b3ContactSolverInfoData
+{
+	b3Scalar m_tau;
+	b3Scalar m_damping;  //global non-contact constraint damping, can be locally overridden by constraints during 'getInfo2'.
+	b3Scalar m_friction;
+	b3Scalar m_timeStep;
+	b3Scalar m_restitution;
+	int m_numIterations;
+	b3Scalar m_maxErrorReduction;
+	b3Scalar m_sor;
+	b3Scalar m_erp;        //used as Baumgarte factor
+	b3Scalar m_erp2;       //used in Split Impulse
+	b3Scalar m_globalCfm;  //constraint force mixing
+	int m_splitImpulse;
+	b3Scalar m_splitImpulsePenetrationThreshold;
+	b3Scalar m_splitImpulseTurnErp;
+	b3Scalar m_linearSlop;
+	b3Scalar m_warmstartingFactor;
+
+	int m_solverMode;
+	int m_restingContactRestitutionThreshold;
+	int m_minimumSolverBatchSize;
+	b3Scalar m_maxGyroscopicForce;
+	b3Scalar m_singleAxisRollingFrictionThreshold;
+};
+
+struct b3ContactSolverInfo : public b3ContactSolverInfoData
+{
+	inline b3ContactSolverInfo()
+	{
+		m_tau = b3Scalar(0.6);
+		m_damping = b3Scalar(1.0);
+		m_friction = b3Scalar(0.3);
+		m_timeStep = b3Scalar(1.f / 60.f);
+		m_restitution = b3Scalar(0.);
+		m_maxErrorReduction = b3Scalar(20.);
+		m_numIterations = 10;
+		m_erp = b3Scalar(0.2);
+		m_erp2 = b3Scalar(0.8);
+		m_globalCfm = b3Scalar(0.);
+		m_sor = b3Scalar(1.);
+		m_splitImpulse = true;
+		m_splitImpulsePenetrationThreshold = -.04f;
+		m_splitImpulseTurnErp = 0.1f;
+		m_linearSlop = b3Scalar(0.0);
+		m_warmstartingFactor = b3Scalar(0.85);
+		//m_solverMode =  B3_SOLVER_USE_WARMSTARTING |  B3_SOLVER_SIMD | B3_SOLVER_DISABLE_VELOCITY_DEPENDENT_FRICTION_DIRECTION|B3_SOLVER_USE_2_FRICTION_DIRECTIONS|B3_SOLVER_ENABLE_FRICTION_DIRECTION_CACHING;// | B3_SOLVER_RANDMIZE_ORDER;
+		m_solverMode = B3_SOLVER_USE_WARMSTARTING | B3_SOLVER_SIMD;  // | B3_SOLVER_RANDMIZE_ORDER;
+		m_restingContactRestitutionThreshold = 2;                    //unused as of 2.81
+		m_minimumSolverBatchSize = 128;                              //try to combine islands until the amount of constraints reaches this limit
+		m_maxGyroscopicForce = 100.f;                                ///only used to clamp forces for bodies that have their B3_ENABLE_GYROPSCOPIC_FORCE flag set (using b3RigidBody::setFlag)
+		m_singleAxisRollingFrictionThreshold = 1e30f;                ///if the velocity is above this threshold, it will use a single constraint row (axis), otherwise 3 rows.
+	}
+};
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct b3ContactSolverInfoDoubleData
+{
+	double m_tau;
+	double m_damping;  //global non-contact constraint damping, can be locally overridden by constraints during 'getInfo2'.
+	double m_friction;
+	double m_timeStep;
+	double m_restitution;
+	double m_maxErrorReduction;
+	double m_sor;
+	double m_erp;        //used as Baumgarte factor
+	double m_erp2;       //used in Split Impulse
+	double m_globalCfm;  //constraint force mixing
+	double m_splitImpulsePenetrationThreshold;
+	double m_splitImpulseTurnErp;
+	double m_linearSlop;
+	double m_warmstartingFactor;
+	double m_maxGyroscopicForce;
+	double m_singleAxisRollingFrictionThreshold;
+
+	int m_numIterations;
+	int m_solverMode;
+	int m_restingContactRestitutionThreshold;
+	int m_minimumSolverBatchSize;
+	int m_splitImpulse;
+	char m_padding[4];
+};
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct b3ContactSolverInfoFloatData
+{
+	float m_tau;
+	float m_damping;  //global non-contact constraint damping, can be locally overridden by constraints during 'getInfo2'.
+	float m_friction;
+	float m_timeStep;
+
+	float m_restitution;
+	float m_maxErrorReduction;
+	float m_sor;
+	float m_erp;  //used as Baumgarte factor
+
+	float m_erp2;       //used in Split Impulse
+	float m_globalCfm;  //constraint force mixing
+	float m_splitImpulsePenetrationThreshold;
+	float m_splitImpulseTurnErp;
+
+	float m_linearSlop;
+	float m_warmstartingFactor;
+	float m_maxGyroscopicForce;
+	float m_singleAxisRollingFrictionThreshold;
+
+	int m_numIterations;
+	int m_solverMode;
+	int m_restingContactRestitutionThreshold;
+	int m_minimumSolverBatchSize;
+
+	int m_splitImpulse;
+	char m_padding[4];
+};
+
+#endif  //B3_CONTACT_SOLVER_INFO
diff --git a/engine/inc/bullet/Bullet3Dynamics/ConstraintSolver/b3FixedConstraint.h b/engine/inc/bullet/Bullet3Dynamics/ConstraintSolver/b3FixedConstraint.h
new file mode 100644
index 00000000..64809666
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Dynamics/ConstraintSolver/b3FixedConstraint.h
@@ -0,0 +1,34 @@
+
+#ifndef B3_FIXED_CONSTRAINT_H
+#define B3_FIXED_CONSTRAINT_H
+
+#include "b3TypedConstraint.h"
+
+B3_ATTRIBUTE_ALIGNED16(class)
+b3FixedConstraint : public b3TypedConstraint
+{
+	b3Vector3 m_pivotInA;
+	b3Vector3 m_pivotInB;
+	b3Quaternion m_relTargetAB;
+
+public:
+	b3FixedConstraint(int rbA, int rbB, const b3Transform& frameInA, const b3Transform& frameInB);
+
+	virtual ~b3FixedConstraint();
+
+	virtual void getInfo1(b3ConstraintInfo1 * info, const b3RigidBodyData* bodies);
+
+	virtual void getInfo2(b3ConstraintInfo2 * info, const b3RigidBodyData* bodies);
+
+	virtual void setParam(int num, b3Scalar value, int axis = -1)
+	{
+		b3Assert(0);
+	}
+	virtual b3Scalar getParam(int num, int axis = -1) const
+	{
+		b3Assert(0);
+		return 0.f;
+	}
+};
+
+#endif  //B3_FIXED_CONSTRAINT_H
diff --git a/engine/inc/bullet/Bullet3Dynamics/ConstraintSolver/b3Generic6DofConstraint.h b/engine/inc/bullet/Bullet3Dynamics/ConstraintSolver/b3Generic6DofConstraint.h
new file mode 100644
index 00000000..1597809d
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Dynamics/ConstraintSolver/b3Generic6DofConstraint.h
@@ -0,0 +1,517 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+/// 2009 March: b3Generic6DofConstraint refactored by Roman Ponomarev
+/// Added support for generic constraint solver through getInfo1/getInfo2 methods
+
+/*
+2007-09-09
+b3Generic6DofConstraint Refactored by Francisco Le?n
+email: projectileman@yahoo.com
+http://gimpact.sf.net
+*/
+
+#ifndef B3_GENERIC_6DOF_CONSTRAINT_H
+#define B3_GENERIC_6DOF_CONSTRAINT_H
+
+#include "Bullet3Common/b3Vector3.h"
+#include "b3JacobianEntry.h"
+#include "b3TypedConstraint.h"
+
+struct b3RigidBodyData;
+
+//! Rotation Limit structure for generic joints
+class b3RotationalLimitMotor
+{
+public:
+	//! limit_parameters
+	//!@{
+	b3Scalar m_loLimit;         //!< joint limit
+	b3Scalar m_hiLimit;         //!< joint limit
+	b3Scalar m_targetVelocity;  //!< target motor velocity
+	b3Scalar m_maxMotorForce;   //!< max force on motor
+	b3Scalar m_maxLimitForce;   //!< max force on limit
+	b3Scalar m_damping;         //!< Damping.
+	b3Scalar m_limitSoftness;   //! Relaxation factor
+	b3Scalar m_normalCFM;       //!< Constraint force mixing factor
+	b3Scalar m_stopERP;         //!< Error tolerance factor when joint is at limit
+	b3Scalar m_stopCFM;         //!< Constraint force mixing factor when joint is at limit
+	b3Scalar m_bounce;          //!< restitution factor
+	bool m_enableMotor;
+
+	//!@}
+
+	//! temp_variables
+	//!@{
+	b3Scalar m_currentLimitError;  //!  How much is violated this limit
+	b3Scalar m_currentPosition;    //!  current value of angle
+	int m_currentLimit;            //!< 0=free, 1=at lo limit, 2=at hi limit
+	b3Scalar m_accumulatedImpulse;
+	//!@}
+
+	b3RotationalLimitMotor()
+	{
+		m_accumulatedImpulse = 0.f;
+		m_targetVelocity = 0;
+		m_maxMotorForce = 6.0f;
+		m_maxLimitForce = 300.0f;
+		m_loLimit = 1.0f;
+		m_hiLimit = -1.0f;
+		m_normalCFM = 0.f;
+		m_stopERP = 0.2f;
+		m_stopCFM = 0.f;
+		m_bounce = 0.0f;
+		m_damping = 1.0f;
+		m_limitSoftness = 0.5f;
+		m_currentLimit = 0;
+		m_currentLimitError = 0;
+		m_enableMotor = false;
+	}
+
+	b3RotationalLimitMotor(const b3RotationalLimitMotor& limot)
+	{
+		m_targetVelocity = limot.m_targetVelocity;
+		m_maxMotorForce = limot.m_maxMotorForce;
+		m_limitSoftness = limot.m_limitSoftness;
+		m_loLimit = limot.m_loLimit;
+		m_hiLimit = limot.m_hiLimit;
+		m_normalCFM = limot.m_normalCFM;
+		m_stopERP = limot.m_stopERP;
+		m_stopCFM = limot.m_stopCFM;
+		m_bounce = limot.m_bounce;
+		m_currentLimit = limot.m_currentLimit;
+		m_currentLimitError = limot.m_currentLimitError;
+		m_enableMotor = limot.m_enableMotor;
+	}
+
+	//! Is limited
+	bool isLimited()
+	{
+		if (m_loLimit > m_hiLimit) return false;
+		return true;
+	}
+
+	//! Need apply correction
+	bool needApplyTorques()
+	{
+		if (m_currentLimit == 0 && m_enableMotor == false) return false;
+		return true;
+	}
+
+	//! calculates  error
+	/*!
+	calculates m_currentLimit and m_currentLimitError.
+	*/
+	int testLimitValue(b3Scalar test_value);
+
+	//! apply the correction impulses for two bodies
+	b3Scalar solveAngularLimits(b3Scalar timeStep, b3Vector3& axis, b3Scalar jacDiagABInv, b3RigidBodyData* body0, b3RigidBodyData* body1);
+};
+
+class b3TranslationalLimitMotor
+{
+public:
+	b3Vector3 m_lowerLimit;  //!< the constraint lower limits
+	b3Vector3 m_upperLimit;  //!< the constraint upper limits
+	b3Vector3 m_accumulatedImpulse;
+	//! Linear_Limit_parameters
+	//!@{
+	b3Vector3 m_normalCFM;          //!< Constraint force mixing factor
+	b3Vector3 m_stopERP;            //!< Error tolerance factor when joint is at limit
+	b3Vector3 m_stopCFM;            //!< Constraint force mixing factor when joint is at limit
+	b3Vector3 m_targetVelocity;     //!< target motor velocity
+	b3Vector3 m_maxMotorForce;      //!< max force on motor
+	b3Vector3 m_currentLimitError;  //!  How much is violated this limit
+	b3Vector3 m_currentLinearDiff;  //!  Current relative offset of constraint frames
+	b3Scalar m_limitSoftness;       //!< Softness for linear limit
+	b3Scalar m_damping;             //!< Damping for linear limit
+	b3Scalar m_restitution;         //! Bounce parameter for linear limit
+	//!@}
+	bool m_enableMotor[3];
+	int m_currentLimit[3];  //!< 0=free, 1=at lower limit, 2=at upper limit
+
+	b3TranslationalLimitMotor()
+	{
+		m_lowerLimit.setValue(0.f, 0.f, 0.f);
+		m_upperLimit.setValue(0.f, 0.f, 0.f);
+		m_accumulatedImpulse.setValue(0.f, 0.f, 0.f);
+		m_normalCFM.setValue(0.f, 0.f, 0.f);
+		m_stopERP.setValue(0.2f, 0.2f, 0.2f);
+		m_stopCFM.setValue(0.f, 0.f, 0.f);
+
+		m_limitSoftness = 0.7f;
+		m_damping = b3Scalar(1.0f);
+		m_restitution = b3Scalar(0.5f);
+		for (int i = 0; i < 3; i++)
+		{
+			m_enableMotor[i] = false;
+			m_targetVelocity[i] = b3Scalar(0.f);
+			m_maxMotorForce[i] = b3Scalar(0.f);
+		}
+	}
+
+	b3TranslationalLimitMotor(const b3TranslationalLimitMotor& other)
+	{
+		m_lowerLimit = other.m_lowerLimit;
+		m_upperLimit = other.m_upperLimit;
+		m_accumulatedImpulse = other.m_accumulatedImpulse;
+
+		m_limitSoftness = other.m_limitSoftness;
+		m_damping = other.m_damping;
+		m_restitution = other.m_restitution;
+		m_normalCFM = other.m_normalCFM;
+		m_stopERP = other.m_stopERP;
+		m_stopCFM = other.m_stopCFM;
+
+		for (int i = 0; i < 3; i++)
+		{
+			m_enableMotor[i] = other.m_enableMotor[i];
+			m_targetVelocity[i] = other.m_targetVelocity[i];
+			m_maxMotorForce[i] = other.m_maxMotorForce[i];
+		}
+	}
+
+	//! Test limit
+	/*!
+    - free means upper < lower,
+    - locked means upper == lower
+    - limited means upper > lower
+    - limitIndex: first 3 are linear, next 3 are angular
+    */
+	inline bool isLimited(int limitIndex)
+	{
+		return (m_upperLimit[limitIndex] >= m_lowerLimit[limitIndex]);
+	}
+	inline bool needApplyForce(int limitIndex)
+	{
+		if (m_currentLimit[limitIndex] == 0 && m_enableMotor[limitIndex] == false) return false;
+		return true;
+	}
+	int testLimitValue(int limitIndex, b3Scalar test_value);
+
+	b3Scalar solveLinearAxis(
+		b3Scalar timeStep,
+		b3Scalar jacDiagABInv,
+		b3RigidBodyData& body1, const b3Vector3& pointInA,
+		b3RigidBodyData& body2, const b3Vector3& pointInB,
+		int limit_index,
+		const b3Vector3& axis_normal_on_a,
+		const b3Vector3& anchorPos);
+};
+
+enum b36DofFlags
+{
+	B3_6DOF_FLAGS_CFM_NORM = 1,
+	B3_6DOF_FLAGS_CFM_STOP = 2,
+	B3_6DOF_FLAGS_ERP_STOP = 4
+};
+#define B3_6DOF_FLAGS_AXIS_SHIFT 3  // bits per axis
+
+/// b3Generic6DofConstraint between two rigidbodies each with a pivotpoint that descibes the axis location in local space
+/*!
+b3Generic6DofConstraint can leave any of the 6 degree of freedom 'free' or 'locked'.
+currently this limit supports rotational motors<br>
+<ul>
+<li> For Linear limits, use b3Generic6DofConstraint.setLinearUpperLimit, b3Generic6DofConstraint.setLinearLowerLimit. You can set the parameters with the b3TranslationalLimitMotor structure accsesible through the b3Generic6DofConstraint.getTranslationalLimitMotor method.
+At this moment translational motors are not supported. May be in the future. </li>
+
+<li> For Angular limits, use the b3RotationalLimitMotor structure for configuring the limit.
+This is accessible through b3Generic6DofConstraint.getLimitMotor method,
+This brings support for limit parameters and motors. </li>
+
+<li> Angulars limits have these possible ranges:
+<table border=1 >
+<tr>
+	<td><b>AXIS</b></td>
+	<td><b>MIN ANGLE</b></td>
+	<td><b>MAX ANGLE</b></td>
+</tr><tr>
+	<td>X</td>
+	<td>-PI</td>
+	<td>PI</td>
+</tr><tr>
+	<td>Y</td>
+	<td>-PI/2</td>
+	<td>PI/2</td>
+</tr><tr>
+	<td>Z</td>
+	<td>-PI</td>
+	<td>PI</td>
+</tr>
+</table>
+</li>
+</ul>
+
+*/
+B3_ATTRIBUTE_ALIGNED16(class)
+b3Generic6DofConstraint : public b3TypedConstraint
+{
+protected:
+	//! relative_frames
+	//!@{
+	b3Transform m_frameInA;  //!< the constraint space w.r.t body A
+	b3Transform m_frameInB;  //!< the constraint space w.r.t body B
+	//!@}
+
+	//! Jacobians
+	//!@{
+	//    b3JacobianEntry	m_jacLinear[3];//!< 3 orthogonal linear constraints
+	//    b3JacobianEntry	m_jacAng[3];//!< 3 orthogonal angular constraints
+	//!@}
+
+	//! Linear_Limit_parameters
+	//!@{
+	b3TranslationalLimitMotor m_linearLimits;
+	//!@}
+
+	//! hinge_parameters
+	//!@{
+	b3RotationalLimitMotor m_angularLimits[3];
+	//!@}
+
+protected:
+	//! temporal variables
+	//!@{
+	b3Transform m_calculatedTransformA;
+	b3Transform m_calculatedTransformB;
+	b3Vector3 m_calculatedAxisAngleDiff;
+	b3Vector3 m_calculatedAxis[3];
+	b3Vector3 m_calculatedLinearDiff;
+	b3Scalar m_timeStep;
+	b3Scalar m_factA;
+	b3Scalar m_factB;
+	bool m_hasStaticBody;
+
+	b3Vector3 m_AnchorPos;  // point betwen pivots of bodies A and B to solve linear axes
+
+	bool m_useLinearReferenceFrameA;
+	bool m_useOffsetForConstraintFrame;
+
+	int m_flags;
+
+	//!@}
+
+	b3Generic6DofConstraint& operator=(b3Generic6DofConstraint& other)
+	{
+		b3Assert(0);
+		(void)other;
+		return *this;
+	}
+
+	int setAngularLimits(b3ConstraintInfo2 * info, int row_offset, const b3Transform& transA, const b3Transform& transB, const b3Vector3& linVelA, const b3Vector3& linVelB, const b3Vector3& angVelA, const b3Vector3& angVelB);
+
+	int setLinearLimits(b3ConstraintInfo2 * info, int row, const b3Transform& transA, const b3Transform& transB, const b3Vector3& linVelA, const b3Vector3& linVelB, const b3Vector3& angVelA, const b3Vector3& angVelB);
+
+	// tests linear limits
+	void calculateLinearInfo();
+
+	//! calcs the euler angles between the two bodies.
+	void calculateAngleInfo();
+
+public:
+	B3_DECLARE_ALIGNED_ALLOCATOR();
+
+	b3Generic6DofConstraint(int rbA, int rbB, const b3Transform& frameInA, const b3Transform& frameInB, bool useLinearReferenceFrameA, const b3RigidBodyData* bodies);
+
+	//! Calcs global transform of the offsets
+	/*!
+	Calcs the global transform for the joint offset for body A an B, and also calcs the agle differences between the bodies.
+	\sa b3Generic6DofConstraint.getCalculatedTransformA , b3Generic6DofConstraint.getCalculatedTransformB, b3Generic6DofConstraint.calculateAngleInfo
+	*/
+	void calculateTransforms(const b3Transform& transA, const b3Transform& transB, const b3RigidBodyData* bodies);
+
+	void calculateTransforms(const b3RigidBodyData* bodies);
+
+	//! Gets the global transform of the offset for body A
+	/*!
+    \sa b3Generic6DofConstraint.getFrameOffsetA, b3Generic6DofConstraint.getFrameOffsetB, b3Generic6DofConstraint.calculateAngleInfo.
+    */
+	const b3Transform& getCalculatedTransformA() const
+	{
+		return m_calculatedTransformA;
+	}
+
+	//! Gets the global transform of the offset for body B
+	/*!
+    \sa b3Generic6DofConstraint.getFrameOffsetA, b3Generic6DofConstraint.getFrameOffsetB, b3Generic6DofConstraint.calculateAngleInfo.
+    */
+	const b3Transform& getCalculatedTransformB() const
+	{
+		return m_calculatedTransformB;
+	}
+
+	const b3Transform& getFrameOffsetA() const
+	{
+		return m_frameInA;
+	}
+
+	const b3Transform& getFrameOffsetB() const
+	{
+		return m_frameInB;
+	}
+
+	b3Transform& getFrameOffsetA()
+	{
+		return m_frameInA;
+	}
+
+	b3Transform& getFrameOffsetB()
+	{
+		return m_frameInB;
+	}
+
+	virtual void getInfo1(b3ConstraintInfo1 * info, const b3RigidBodyData* bodies);
+
+	void getInfo1NonVirtual(b3ConstraintInfo1 * info, const b3RigidBodyData* bodies);
+
+	virtual void getInfo2(b3ConstraintInfo2 * info, const b3RigidBodyData* bodies);
+
+	void getInfo2NonVirtual(b3ConstraintInfo2 * info, const b3Transform& transA, const b3Transform& transB, const b3Vector3& linVelA, const b3Vector3& linVelB, const b3Vector3& angVelA, const b3Vector3& angVelB, const b3RigidBodyData* bodies);
+
+	void updateRHS(b3Scalar timeStep);
+
+	//! Get the rotation axis in global coordinates
+	b3Vector3 getAxis(int axis_index) const;
+
+	//! Get the relative Euler angle
+	/*!
+	\pre b3Generic6DofConstraint::calculateTransforms() must be called previously.
+	*/
+	b3Scalar getAngle(int axis_index) const;
+
+	//! Get the relative position of the constraint pivot
+	/*!
+	\pre b3Generic6DofConstraint::calculateTransforms() must be called previously.
+	*/
+	b3Scalar getRelativePivotPosition(int axis_index) const;
+
+	void setFrames(const b3Transform& frameA, const b3Transform& frameB, const b3RigidBodyData* bodies);
+
+	//! Test angular limit.
+	/*!
+	Calculates angular correction and returns true if limit needs to be corrected.
+	\pre b3Generic6DofConstraint::calculateTransforms() must be called previously.
+	*/
+	bool testAngularLimitMotor(int axis_index);
+
+	void setLinearLowerLimit(const b3Vector3& linearLower)
+	{
+		m_linearLimits.m_lowerLimit = linearLower;
+	}
+
+	void getLinearLowerLimit(b3Vector3 & linearLower)
+	{
+		linearLower = m_linearLimits.m_lowerLimit;
+	}
+
+	void setLinearUpperLimit(const b3Vector3& linearUpper)
+	{
+		m_linearLimits.m_upperLimit = linearUpper;
+	}
+
+	void getLinearUpperLimit(b3Vector3 & linearUpper)
+	{
+		linearUpper = m_linearLimits.m_upperLimit;
+	}
+
+	void setAngularLowerLimit(const b3Vector3& angularLower)
+	{
+		for (int i = 0; i < 3; i++)
+			m_angularLimits[i].m_loLimit = b3NormalizeAngle(angularLower[i]);
+	}
+
+	void getAngularLowerLimit(b3Vector3 & angularLower)
+	{
+		for (int i = 0; i < 3; i++)
+			angularLower[i] = m_angularLimits[i].m_loLimit;
+	}
+
+	void setAngularUpperLimit(const b3Vector3& angularUpper)
+	{
+		for (int i = 0; i < 3; i++)
+			m_angularLimits[i].m_hiLimit = b3NormalizeAngle(angularUpper[i]);
+	}
+
+	void getAngularUpperLimit(b3Vector3 & angularUpper)
+	{
+		for (int i = 0; i < 3; i++)
+			angularUpper[i] = m_angularLimits[i].m_hiLimit;
+	}
+
+	//! Retrieves the angular limit informacion
+	b3RotationalLimitMotor* getRotationalLimitMotor(int index)
+	{
+		return &m_angularLimits[index];
+	}
+
+	//! Retrieves the  limit informacion
+	b3TranslationalLimitMotor* getTranslationalLimitMotor()
+	{
+		return &m_linearLimits;
+	}
+
+	//first 3 are linear, next 3 are angular
+	void setLimit(int axis, b3Scalar lo, b3Scalar hi)
+	{
+		if (axis < 3)
+		{
+			m_linearLimits.m_lowerLimit[axis] = lo;
+			m_linearLimits.m_upperLimit[axis] = hi;
+		}
+		else
+		{
+			lo = b3NormalizeAngle(lo);
+			hi = b3NormalizeAngle(hi);
+			m_angularLimits[axis - 3].m_loLimit = lo;
+			m_angularLimits[axis - 3].m_hiLimit = hi;
+		}
+	}
+
+	//! Test limit
+	/*!
+    - free means upper < lower,
+    - locked means upper == lower
+    - limited means upper > lower
+    - limitIndex: first 3 are linear, next 3 are angular
+    */
+	bool isLimited(int limitIndex)
+	{
+		if (limitIndex < 3)
+		{
+			return m_linearLimits.isLimited(limitIndex);
+		}
+		return m_angularLimits[limitIndex - 3].isLimited();
+	}
+
+	virtual void calcAnchorPos(const b3RigidBodyData* bodies);  // overridable
+
+	int get_limit_motor_info2(b3RotationalLimitMotor * limot,
+							  const b3Transform& transA, const b3Transform& transB, const b3Vector3& linVelA, const b3Vector3& linVelB, const b3Vector3& angVelA, const b3Vector3& angVelB,
+							  b3ConstraintInfo2* info, int row, b3Vector3& ax1, int rotational, int rotAllowed = false);
+
+	// access for UseFrameOffset
+	bool getUseFrameOffset() { return m_useOffsetForConstraintFrame; }
+	void setUseFrameOffset(bool frameOffsetOnOff) { m_useOffsetForConstraintFrame = frameOffsetOnOff; }
+
+	///override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5).
+	///If no axis is provided, it uses the default axis for this constraint.
+	virtual void setParam(int num, b3Scalar value, int axis = -1);
+	///return the local value of parameter
+	virtual b3Scalar getParam(int num, int axis = -1) const;
+
+	void setAxis(const b3Vector3& axis1, const b3Vector3& axis2, const b3RigidBodyData* bodies);
+};
+
+#endif  //B3_GENERIC_6DOF_CONSTRAINT_H
diff --git a/engine/inc/bullet/Bullet3Dynamics/ConstraintSolver/b3JacobianEntry.h b/engine/inc/bullet/Bullet3Dynamics/ConstraintSolver/b3JacobianEntry.h
new file mode 100644
index 00000000..13269deb
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Dynamics/ConstraintSolver/b3JacobianEntry.h
@@ -0,0 +1,150 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_JACOBIAN_ENTRY_H
+#define B3_JACOBIAN_ENTRY_H
+
+#include "Bullet3Common/b3Matrix3x3.h"
+
+//notes:
+// Another memory optimization would be to store m_1MinvJt in the remaining 3 w components
+// which makes the b3JacobianEntry memory layout 16 bytes
+// if you only are interested in angular part, just feed massInvA and massInvB zero
+
+/// Jacobian entry is an abstraction that allows to describe constraints
+/// it can be used in combination with a constraint solver
+/// Can be used to relate the effect of an impulse to the constraint error
+B3_ATTRIBUTE_ALIGNED16(class)
+b3JacobianEntry
+{
+public:
+	b3JacobianEntry(){};
+	//constraint between two different rigidbodies
+	b3JacobianEntry(
+		const b3Matrix3x3& world2A,
+		const b3Matrix3x3& world2B,
+		const b3Vector3& rel_pos1, const b3Vector3& rel_pos2,
+		const b3Vector3& jointAxis,
+		const b3Vector3& inertiaInvA,
+		const b3Scalar massInvA,
+		const b3Vector3& inertiaInvB,
+		const b3Scalar massInvB)
+		: m_linearJointAxis(jointAxis)
+	{
+		m_aJ = world2A * (rel_pos1.cross(m_linearJointAxis));
+		m_bJ = world2B * (rel_pos2.cross(-m_linearJointAxis));
+		m_0MinvJt = inertiaInvA * m_aJ;
+		m_1MinvJt = inertiaInvB * m_bJ;
+		m_Adiag = massInvA + m_0MinvJt.dot(m_aJ) + massInvB + m_1MinvJt.dot(m_bJ);
+
+		b3Assert(m_Adiag > b3Scalar(0.0));
+	}
+
+	//angular constraint between two different rigidbodies
+	b3JacobianEntry(const b3Vector3& jointAxis,
+					const b3Matrix3x3& world2A,
+					const b3Matrix3x3& world2B,
+					const b3Vector3& inertiaInvA,
+					const b3Vector3& inertiaInvB)
+		: m_linearJointAxis(b3MakeVector3(b3Scalar(0.), b3Scalar(0.), b3Scalar(0.)))
+	{
+		m_aJ = world2A * jointAxis;
+		m_bJ = world2B * -jointAxis;
+		m_0MinvJt = inertiaInvA * m_aJ;
+		m_1MinvJt = inertiaInvB * m_bJ;
+		m_Adiag = m_0MinvJt.dot(m_aJ) + m_1MinvJt.dot(m_bJ);
+
+		b3Assert(m_Adiag > b3Scalar(0.0));
+	}
+
+	//angular constraint between two different rigidbodies
+	b3JacobianEntry(const b3Vector3& axisInA,
+					const b3Vector3& axisInB,
+					const b3Vector3& inertiaInvA,
+					const b3Vector3& inertiaInvB)
+		: m_linearJointAxis(b3MakeVector3(b3Scalar(0.), b3Scalar(0.), b3Scalar(0.))), m_aJ(axisInA), m_bJ(-axisInB)
+	{
+		m_0MinvJt = inertiaInvA * m_aJ;
+		m_1MinvJt = inertiaInvB * m_bJ;
+		m_Adiag = m_0MinvJt.dot(m_aJ) + m_1MinvJt.dot(m_bJ);
+
+		b3Assert(m_Adiag > b3Scalar(0.0));
+	}
+
+	//constraint on one rigidbody
+	b3JacobianEntry(
+		const b3Matrix3x3& world2A,
+		const b3Vector3& rel_pos1, const b3Vector3& rel_pos2,
+		const b3Vector3& jointAxis,
+		const b3Vector3& inertiaInvA,
+		const b3Scalar massInvA)
+		: m_linearJointAxis(jointAxis)
+	{
+		m_aJ = world2A * (rel_pos1.cross(jointAxis));
+		m_bJ = world2A * (rel_pos2.cross(-jointAxis));
+		m_0MinvJt = inertiaInvA * m_aJ;
+		m_1MinvJt = b3MakeVector3(b3Scalar(0.), b3Scalar(0.), b3Scalar(0.));
+		m_Adiag = massInvA + m_0MinvJt.dot(m_aJ);
+
+		b3Assert(m_Adiag > b3Scalar(0.0));
+	}
+
+	b3Scalar getDiagonal() const { return m_Adiag; }
+
+	// for two constraints on the same rigidbody (for example vehicle friction)
+	b3Scalar getNonDiagonal(const b3JacobianEntry& jacB, const b3Scalar massInvA) const
+	{
+		const b3JacobianEntry& jacA = *this;
+		b3Scalar lin = massInvA * jacA.m_linearJointAxis.dot(jacB.m_linearJointAxis);
+		b3Scalar ang = jacA.m_0MinvJt.dot(jacB.m_aJ);
+		return lin + ang;
+	}
+
+	// for two constraints on sharing two same rigidbodies (for example two contact points between two rigidbodies)
+	b3Scalar getNonDiagonal(const b3JacobianEntry& jacB, const b3Scalar massInvA, const b3Scalar massInvB) const
+	{
+		const b3JacobianEntry& jacA = *this;
+		b3Vector3 lin = jacA.m_linearJointAxis * jacB.m_linearJointAxis;
+		b3Vector3 ang0 = jacA.m_0MinvJt * jacB.m_aJ;
+		b3Vector3 ang1 = jacA.m_1MinvJt * jacB.m_bJ;
+		b3Vector3 lin0 = massInvA * lin;
+		b3Vector3 lin1 = massInvB * lin;
+		b3Vector3 sum = ang0 + ang1 + lin0 + lin1;
+		return sum[0] + sum[1] + sum[2];
+	}
+
+	b3Scalar getRelativeVelocity(const b3Vector3& linvelA, const b3Vector3& angvelA, const b3Vector3& linvelB, const b3Vector3& angvelB)
+	{
+		b3Vector3 linrel = linvelA - linvelB;
+		b3Vector3 angvela = angvelA * m_aJ;
+		b3Vector3 angvelb = angvelB * m_bJ;
+		linrel *= m_linearJointAxis;
+		angvela += angvelb;
+		angvela += linrel;
+		b3Scalar rel_vel2 = angvela[0] + angvela[1] + angvela[2];
+		return rel_vel2 + B3_EPSILON;
+	}
+	//private:
+
+	b3Vector3 m_linearJointAxis;
+	b3Vector3 m_aJ;
+	b3Vector3 m_bJ;
+	b3Vector3 m_0MinvJt;
+	b3Vector3 m_1MinvJt;
+	//Optimization: can be stored in the w/last component of one of the vectors
+	b3Scalar m_Adiag;
+};
+
+#endif  //B3_JACOBIAN_ENTRY_H
diff --git a/engine/inc/bullet/Bullet3Dynamics/ConstraintSolver/b3PgsJacobiSolver.h b/engine/inc/bullet/Bullet3Dynamics/ConstraintSolver/b3PgsJacobiSolver.h
new file mode 100644
index 00000000..5b616541
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Dynamics/ConstraintSolver/b3PgsJacobiSolver.h
@@ -0,0 +1,133 @@
+#ifndef B3_PGS_JACOBI_SOLVER
+#define B3_PGS_JACOBI_SOLVER
+
+struct b3Contact4;
+struct b3ContactPoint;
+
+class b3Dispatcher;
+
+#include "b3TypedConstraint.h"
+#include "b3ContactSolverInfo.h"
+#include "b3SolverBody.h"
+#include "b3SolverConstraint.h"
+
+struct b3RigidBodyData;
+struct b3InertiaData;
+
+class b3PgsJacobiSolver
+{
+protected:
+	b3AlignedObjectArray<b3SolverBody> m_tmpSolverBodyPool;
+	b3ConstraintArray m_tmpSolverContactConstraintPool;
+	b3ConstraintArray m_tmpSolverNonContactConstraintPool;
+	b3ConstraintArray m_tmpSolverContactFrictionConstraintPool;
+	b3ConstraintArray m_tmpSolverContactRollingFrictionConstraintPool;
+
+	b3AlignedObjectArray<int> m_orderTmpConstraintPool;
+	b3AlignedObjectArray<int> m_orderNonContactConstraintPool;
+	b3AlignedObjectArray<int> m_orderFrictionConstraintPool;
+	b3AlignedObjectArray<b3TypedConstraint::b3ConstraintInfo1> m_tmpConstraintSizesPool;
+
+	b3AlignedObjectArray<int> m_bodyCount;
+	b3AlignedObjectArray<int> m_bodyCountCheck;
+
+	b3AlignedObjectArray<b3Vector3> m_deltaLinearVelocities;
+	b3AlignedObjectArray<b3Vector3> m_deltaAngularVelocities;
+
+	bool m_usePgs;
+	void averageVelocities();
+
+	int m_maxOverrideNumSolverIterations;
+
+	int m_numSplitImpulseRecoveries;
+
+	b3Scalar getContactProcessingThreshold(b3Contact4* contact)
+	{
+		return 0.02f;
+	}
+	void setupFrictionConstraint(b3RigidBodyData* bodies, b3InertiaData* inertias, b3SolverConstraint& solverConstraint, const b3Vector3& normalAxis, int solverBodyIdA, int solverBodyIdB,
+								 b3ContactPoint& cp, const b3Vector3& rel_pos1, const b3Vector3& rel_pos2,
+								 b3RigidBodyData* colObj0, b3RigidBodyData* colObj1, b3Scalar relaxation,
+								 b3Scalar desiredVelocity = 0., b3Scalar cfmSlip = 0.);
+
+	void setupRollingFrictionConstraint(b3RigidBodyData* bodies, b3InertiaData* inertias, b3SolverConstraint& solverConstraint, const b3Vector3& normalAxis, int solverBodyIdA, int solverBodyIdB,
+										b3ContactPoint& cp, const b3Vector3& rel_pos1, const b3Vector3& rel_pos2,
+										b3RigidBodyData* colObj0, b3RigidBodyData* colObj1, b3Scalar relaxation,
+										b3Scalar desiredVelocity = 0., b3Scalar cfmSlip = 0.);
+
+	b3SolverConstraint& addFrictionConstraint(b3RigidBodyData* bodies, b3InertiaData* inertias, const b3Vector3& normalAxis, int solverBodyIdA, int solverBodyIdB, int frictionIndex, b3ContactPoint& cp, const b3Vector3& rel_pos1, const b3Vector3& rel_pos2, b3RigidBodyData* colObj0, b3RigidBodyData* colObj1, b3Scalar relaxation, b3Scalar desiredVelocity = 0., b3Scalar cfmSlip = 0.);
+	b3SolverConstraint& addRollingFrictionConstraint(b3RigidBodyData* bodies, b3InertiaData* inertias, const b3Vector3& normalAxis, int solverBodyIdA, int solverBodyIdB, int frictionIndex, b3ContactPoint& cp, const b3Vector3& rel_pos1, const b3Vector3& rel_pos2, b3RigidBodyData* colObj0, b3RigidBodyData* colObj1, b3Scalar relaxation, b3Scalar desiredVelocity = 0, b3Scalar cfmSlip = 0.f);
+
+	void setupContactConstraint(b3RigidBodyData* bodies, b3InertiaData* inertias,
+								b3SolverConstraint& solverConstraint, int solverBodyIdA, int solverBodyIdB, b3ContactPoint& cp,
+								const b3ContactSolverInfo& infoGlobal, b3Vector3& vel, b3Scalar& rel_vel, b3Scalar& relaxation,
+								b3Vector3& rel_pos1, b3Vector3& rel_pos2);
+
+	void setFrictionConstraintImpulse(b3RigidBodyData* bodies, b3InertiaData* inertias, b3SolverConstraint& solverConstraint, int solverBodyIdA, int solverBodyIdB,
+									  b3ContactPoint& cp, const b3ContactSolverInfo& infoGlobal);
+
+	///m_btSeed2 is used for re-arranging the constraint rows. improves convergence/quality of friction
+	unsigned long m_btSeed2;
+
+	b3Scalar restitutionCurve(b3Scalar rel_vel, b3Scalar restitution);
+
+	void convertContact(b3RigidBodyData* bodies, b3InertiaData* inertias, b3Contact4* manifold, const b3ContactSolverInfo& infoGlobal);
+
+	void resolveSplitPenetrationSIMD(
+		b3SolverBody& bodyA, b3SolverBody& bodyB,
+		const b3SolverConstraint& contactConstraint);
+
+	void resolveSplitPenetrationImpulseCacheFriendly(
+		b3SolverBody& bodyA, b3SolverBody& bodyB,
+		const b3SolverConstraint& contactConstraint);
+
+	//internal method
+	int getOrInitSolverBody(int bodyIndex, b3RigidBodyData* bodies, b3InertiaData* inertias);
+	void initSolverBody(int bodyIndex, b3SolverBody* solverBody, b3RigidBodyData* collisionObject);
+
+	void resolveSingleConstraintRowGeneric(b3SolverBody& bodyA, b3SolverBody& bodyB, const b3SolverConstraint& contactConstraint);
+
+	void resolveSingleConstraintRowGenericSIMD(b3SolverBody& bodyA, b3SolverBody& bodyB, const b3SolverConstraint& contactConstraint);
+
+	void resolveSingleConstraintRowLowerLimit(b3SolverBody& bodyA, b3SolverBody& bodyB, const b3SolverConstraint& contactConstraint);
+
+	void resolveSingleConstraintRowLowerLimitSIMD(b3SolverBody& bodyA, b3SolverBody& bodyB, const b3SolverConstraint& contactConstraint);
+
+protected:
+	virtual b3Scalar solveGroupCacheFriendlySetup(b3RigidBodyData* bodies, b3InertiaData* inertias, int numBodies, b3Contact4* manifoldPtr, int numManifolds, b3TypedConstraint** constraints, int numConstraints, const b3ContactSolverInfo& infoGlobal);
+
+	virtual b3Scalar solveGroupCacheFriendlyIterations(b3TypedConstraint** constraints, int numConstraints, const b3ContactSolverInfo& infoGlobal);
+	virtual void solveGroupCacheFriendlySplitImpulseIterations(b3TypedConstraint** constraints, int numConstraints, const b3ContactSolverInfo& infoGlobal);
+	b3Scalar solveSingleIteration(int iteration, b3TypedConstraint** constraints, int numConstraints, const b3ContactSolverInfo& infoGlobal);
+
+	virtual b3Scalar solveGroupCacheFriendlyFinish(b3RigidBodyData* bodies, b3InertiaData* inertias, int numBodies, const b3ContactSolverInfo& infoGlobal);
+
+public:
+	B3_DECLARE_ALIGNED_ALLOCATOR();
+
+	b3PgsJacobiSolver(bool usePgs);
+	virtual ~b3PgsJacobiSolver();
+
+	//	void	solveContacts(int numBodies, b3RigidBodyData* bodies, b3InertiaData* inertias, int numContacts, b3Contact4* contacts);
+	void solveContacts(int numBodies, b3RigidBodyData* bodies, b3InertiaData* inertias, int numContacts, b3Contact4* contacts, int numConstraints, b3TypedConstraint** constraints);
+
+	b3Scalar solveGroup(b3RigidBodyData* bodies, b3InertiaData* inertias, int numBodies, b3Contact4* manifoldPtr, int numManifolds, b3TypedConstraint** constraints, int numConstraints, const b3ContactSolverInfo& infoGlobal);
+
+	///clear internal cached data and reset random seed
+	virtual void reset();
+
+	unsigned long b3Rand2();
+
+	int b3RandInt2(int n);
+
+	void setRandSeed(unsigned long seed)
+	{
+		m_btSeed2 = seed;
+	}
+	unsigned long getRandSeed() const
+	{
+		return m_btSeed2;
+	}
+};
+
+#endif  //B3_PGS_JACOBI_SOLVER
diff --git a/engine/inc/bullet/Bullet3Dynamics/ConstraintSolver/b3Point2PointConstraint.h b/engine/inc/bullet/Bullet3Dynamics/ConstraintSolver/b3Point2PointConstraint.h
new file mode 100644
index 00000000..14762a3e
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Dynamics/ConstraintSolver/b3Point2PointConstraint.h
@@ -0,0 +1,153 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_POINT2POINTCONSTRAINT_H
+#define B3_POINT2POINTCONSTRAINT_H
+
+#include "Bullet3Common/b3Vector3.h"
+//#include "b3JacobianEntry.h"
+#include "b3TypedConstraint.h"
+
+class b3RigidBody;
+
+#ifdef B3_USE_DOUBLE_PRECISION
+#define b3Point2PointConstraintData b3Point2PointConstraintDoubleData
+#define b3Point2PointConstraintDataName "b3Point2PointConstraintDoubleData"
+#else
+#define b3Point2PointConstraintData b3Point2PointConstraintFloatData
+#define b3Point2PointConstraintDataName "b3Point2PointConstraintFloatData"
+#endif  //B3_USE_DOUBLE_PRECISION
+
+struct b3ConstraintSetting
+{
+	b3ConstraintSetting() : m_tau(b3Scalar(0.3)),
+							m_damping(b3Scalar(1.)),
+							m_impulseClamp(b3Scalar(0.))
+	{
+	}
+	b3Scalar m_tau;
+	b3Scalar m_damping;
+	b3Scalar m_impulseClamp;
+};
+
+enum b3Point2PointFlags
+{
+	B3_P2P_FLAGS_ERP = 1,
+	B3_P2P_FLAGS_CFM = 2
+};
+
+/// point to point constraint between two rigidbodies each with a pivotpoint that descibes the 'ballsocket' location in local space
+B3_ATTRIBUTE_ALIGNED16(class)
+b3Point2PointConstraint : public b3TypedConstraint
+{
+#ifdef IN_PARALLELL_SOLVER
+public:
+#endif
+
+	b3Vector3 m_pivotInA;
+	b3Vector3 m_pivotInB;
+
+	int m_flags;
+	b3Scalar m_erp;
+	b3Scalar m_cfm;
+
+public:
+	B3_DECLARE_ALIGNED_ALLOCATOR();
+
+	b3ConstraintSetting m_setting;
+
+	b3Point2PointConstraint(int rbA, int rbB, const b3Vector3& pivotInA, const b3Vector3& pivotInB);
+
+	//b3Point2PointConstraint(int  rbA,const b3Vector3& pivotInA);
+
+	virtual void getInfo1(b3ConstraintInfo1 * info, const b3RigidBodyData* bodies);
+
+	void getInfo1NonVirtual(b3ConstraintInfo1 * info, const b3RigidBodyData* bodies);
+
+	virtual void getInfo2(b3ConstraintInfo2 * info, const b3RigidBodyData* bodies);
+
+	void getInfo2NonVirtual(b3ConstraintInfo2 * info, const b3Transform& body0_trans, const b3Transform& body1_trans);
+
+	void updateRHS(b3Scalar timeStep);
+
+	void setPivotA(const b3Vector3& pivotA)
+	{
+		m_pivotInA = pivotA;
+	}
+
+	void setPivotB(const b3Vector3& pivotB)
+	{
+		m_pivotInB = pivotB;
+	}
+
+	const b3Vector3& getPivotInA() const
+	{
+		return m_pivotInA;
+	}
+
+	const b3Vector3& getPivotInB() const
+	{
+		return m_pivotInB;
+	}
+
+	///override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5).
+	///If no axis is provided, it uses the default axis for this constraint.
+	virtual void setParam(int num, b3Scalar value, int axis = -1);
+	///return the local value of parameter
+	virtual b3Scalar getParam(int num, int axis = -1) const;
+
+	//	virtual	int	calculateSerializeBufferSize() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	//	virtual	const char*	serialize(void* dataBuffer, b3Serializer* serializer) const;
+};
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct b3Point2PointConstraintFloatData
+{
+	b3TypedConstraintData m_typeConstraintData;
+	b3Vector3FloatData m_pivotInA;
+	b3Vector3FloatData m_pivotInB;
+};
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct b3Point2PointConstraintDoubleData
+{
+	b3TypedConstraintData m_typeConstraintData;
+	b3Vector3DoubleData m_pivotInA;
+	b3Vector3DoubleData m_pivotInB;
+};
+
+/*
+B3_FORCE_INLINE	int	b3Point2PointConstraint::calculateSerializeBufferSize() const
+{
+	return sizeof(b3Point2PointConstraintData);
+
+}
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+B3_FORCE_INLINE	const char*	b3Point2PointConstraint::serialize(void* dataBuffer, b3Serializer* serializer) const
+{
+	b3Point2PointConstraintData* p2pData = (b3Point2PointConstraintData*)dataBuffer;
+
+	b3TypedConstraint::serialize(&p2pData->m_typeConstraintData,serializer);
+	m_pivotInA.serialize(p2pData->m_pivotInA);
+	m_pivotInB.serialize(p2pData->m_pivotInB);
+
+	return b3Point2PointConstraintDataName;
+}
+*/
+
+#endif  //B3_POINT2POINTCONSTRAINT_H
diff --git a/engine/inc/bullet/Bullet3Dynamics/ConstraintSolver/b3SolverBody.h b/engine/inc/bullet/Bullet3Dynamics/ConstraintSolver/b3SolverBody.h
new file mode 100644
index 00000000..196d0e57
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Dynamics/ConstraintSolver/b3SolverBody.h
@@ -0,0 +1,281 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_SOLVER_BODY_H
+#define B3_SOLVER_BODY_H
+
+#include "Bullet3Common/b3Vector3.h"
+#include "Bullet3Common/b3Matrix3x3.h"
+
+#include "Bullet3Common/b3AlignedAllocator.h"
+#include "Bullet3Common/b3TransformUtil.h"
+
+///Until we get other contributions, only use SIMD on Windows, when using Visual Studio 2008 or later, and not double precision
+#ifdef B3_USE_SSE
+#define USE_SIMD 1
+#endif  //
+
+#ifdef USE_SIMD
+
+struct b3SimdScalar
+{
+	B3_FORCE_INLINE b3SimdScalar()
+	{
+	}
+
+	B3_FORCE_INLINE b3SimdScalar(float fl)
+		: m_vec128(_mm_set1_ps(fl))
+	{
+	}
+
+	B3_FORCE_INLINE b3SimdScalar(__m128 v128)
+		: m_vec128(v128)
+	{
+	}
+	union {
+		__m128 m_vec128;
+		float m_floats[4];
+		float x, y, z, w;
+		int m_ints[4];
+		b3Scalar m_unusedPadding;
+	};
+	B3_FORCE_INLINE __m128 get128()
+	{
+		return m_vec128;
+	}
+
+	B3_FORCE_INLINE const __m128 get128() const
+	{
+		return m_vec128;
+	}
+
+	B3_FORCE_INLINE void set128(__m128 v128)
+	{
+		m_vec128 = v128;
+	}
+
+	B3_FORCE_INLINE operator __m128()
+	{
+		return m_vec128;
+	}
+	B3_FORCE_INLINE operator const __m128() const
+	{
+		return m_vec128;
+	}
+
+	B3_FORCE_INLINE operator float() const
+	{
+		return m_floats[0];
+	}
+};
+
+///@brief Return the elementwise product of two b3SimdScalar
+B3_FORCE_INLINE b3SimdScalar
+operator*(const b3SimdScalar& v1, const b3SimdScalar& v2)
+{
+	return b3SimdScalar(_mm_mul_ps(v1.get128(), v2.get128()));
+}
+
+///@brief Return the elementwise product of two b3SimdScalar
+B3_FORCE_INLINE b3SimdScalar
+operator+(const b3SimdScalar& v1, const b3SimdScalar& v2)
+{
+	return b3SimdScalar(_mm_add_ps(v1.get128(), v2.get128()));
+}
+
+#else
+#define b3SimdScalar b3Scalar
+#endif
+
+///The b3SolverBody is an internal datastructure for the constraint solver. Only necessary data is packed to increase cache coherence/performance.
+B3_ATTRIBUTE_ALIGNED16(struct)
+b3SolverBody
+{
+	B3_DECLARE_ALIGNED_ALLOCATOR();
+	b3Transform m_worldTransform;
+	b3Vector3 m_deltaLinearVelocity;
+	b3Vector3 m_deltaAngularVelocity;
+	b3Vector3 m_angularFactor;
+	b3Vector3 m_linearFactor;
+	b3Vector3 m_invMass;
+	b3Vector3 m_pushVelocity;
+	b3Vector3 m_turnVelocity;
+	b3Vector3 m_linearVelocity;
+	b3Vector3 m_angularVelocity;
+
+	union {
+		void* m_originalBody;
+		int m_originalBodyIndex;
+	};
+
+	int padding[3];
+
+	void setWorldTransform(const b3Transform& worldTransform)
+	{
+		m_worldTransform = worldTransform;
+	}
+
+	const b3Transform& getWorldTransform() const
+	{
+		return m_worldTransform;
+	}
+
+	B3_FORCE_INLINE void getVelocityInLocalPointObsolete(const b3Vector3& rel_pos, b3Vector3& velocity) const
+	{
+		if (m_originalBody)
+			velocity = m_linearVelocity + m_deltaLinearVelocity + (m_angularVelocity + m_deltaAngularVelocity).cross(rel_pos);
+		else
+			velocity.setValue(0, 0, 0);
+	}
+
+	B3_FORCE_INLINE void getAngularVelocity(b3Vector3 & angVel) const
+	{
+		if (m_originalBody)
+			angVel = m_angularVelocity + m_deltaAngularVelocity;
+		else
+			angVel.setValue(0, 0, 0);
+	}
+
+	//Optimization for the iterative solver: avoid calculating constant terms involving inertia, normal, relative position
+	B3_FORCE_INLINE void applyImpulse(const b3Vector3& linearComponent, const b3Vector3& angularComponent, const b3Scalar impulseMagnitude)
+	{
+		if (m_originalBody)
+		{
+			m_deltaLinearVelocity += linearComponent * impulseMagnitude * m_linearFactor;
+			m_deltaAngularVelocity += angularComponent * (impulseMagnitude * m_angularFactor);
+		}
+	}
+
+	B3_FORCE_INLINE void internalApplyPushImpulse(const b3Vector3& linearComponent, const b3Vector3& angularComponent, b3Scalar impulseMagnitude)
+	{
+		if (m_originalBody)
+		{
+			m_pushVelocity += linearComponent * impulseMagnitude * m_linearFactor;
+			m_turnVelocity += angularComponent * (impulseMagnitude * m_angularFactor);
+		}
+	}
+
+	const b3Vector3& getDeltaLinearVelocity() const
+	{
+		return m_deltaLinearVelocity;
+	}
+
+	const b3Vector3& getDeltaAngularVelocity() const
+	{
+		return m_deltaAngularVelocity;
+	}
+
+	const b3Vector3& getPushVelocity() const
+	{
+		return m_pushVelocity;
+	}
+
+	const b3Vector3& getTurnVelocity() const
+	{
+		return m_turnVelocity;
+	}
+
+	////////////////////////////////////////////////
+	///some internal methods, don't use them
+
+	b3Vector3& internalGetDeltaLinearVelocity()
+	{
+		return m_deltaLinearVelocity;
+	}
+
+	b3Vector3& internalGetDeltaAngularVelocity()
+	{
+		return m_deltaAngularVelocity;
+	}
+
+	const b3Vector3& internalGetAngularFactor() const
+	{
+		return m_angularFactor;
+	}
+
+	const b3Vector3& internalGetInvMass() const
+	{
+		return m_invMass;
+	}
+
+	void internalSetInvMass(const b3Vector3& invMass)
+	{
+		m_invMass = invMass;
+	}
+
+	b3Vector3& internalGetPushVelocity()
+	{
+		return m_pushVelocity;
+	}
+
+	b3Vector3& internalGetTurnVelocity()
+	{
+		return m_turnVelocity;
+	}
+
+	B3_FORCE_INLINE void internalGetVelocityInLocalPointObsolete(const b3Vector3& rel_pos, b3Vector3& velocity) const
+	{
+		velocity = m_linearVelocity + m_deltaLinearVelocity + (m_angularVelocity + m_deltaAngularVelocity).cross(rel_pos);
+	}
+
+	B3_FORCE_INLINE void internalGetAngularVelocity(b3Vector3 & angVel) const
+	{
+		angVel = m_angularVelocity + m_deltaAngularVelocity;
+	}
+
+	//Optimization for the iterative solver: avoid calculating constant terms involving inertia, normal, relative position
+	B3_FORCE_INLINE void internalApplyImpulse(const b3Vector3& linearComponent, const b3Vector3& angularComponent, const b3Scalar impulseMagnitude)
+	{
+		//if (m_originalBody)
+		{
+			m_deltaLinearVelocity += linearComponent * impulseMagnitude * m_linearFactor;
+			m_deltaAngularVelocity += angularComponent * (impulseMagnitude * m_angularFactor);
+		}
+	}
+
+	void writebackVelocity()
+	{
+		//if (m_originalBody>=0)
+		{
+			m_linearVelocity += m_deltaLinearVelocity;
+			m_angularVelocity += m_deltaAngularVelocity;
+
+			//m_originalBody->setCompanionId(-1);
+		}
+	}
+
+	void writebackVelocityAndTransform(b3Scalar timeStep, b3Scalar splitImpulseTurnErp)
+	{
+		(void)timeStep;
+		if (m_originalBody)
+		{
+			m_linearVelocity += m_deltaLinearVelocity;
+			m_angularVelocity += m_deltaAngularVelocity;
+
+			//correct the position/orientation based on push/turn recovery
+			b3Transform newTransform;
+			if (m_pushVelocity[0] != 0.f || m_pushVelocity[1] != 0 || m_pushVelocity[2] != 0 || m_turnVelocity[0] != 0.f || m_turnVelocity[1] != 0 || m_turnVelocity[2] != 0)
+			{
+				//	b3Quaternion orn = m_worldTransform.getRotation();
+				b3TransformUtil::integrateTransform(m_worldTransform, m_pushVelocity, m_turnVelocity * splitImpulseTurnErp, timeStep, newTransform);
+				m_worldTransform = newTransform;
+			}
+			//m_worldTransform.setRotation(orn);
+			//m_originalBody->setCompanionId(-1);
+		}
+	}
+};
+
+#endif  //B3_SOLVER_BODY_H
diff --git a/engine/inc/bullet/Bullet3Dynamics/ConstraintSolver/b3SolverConstraint.h b/engine/inc/bullet/Bullet3Dynamics/ConstraintSolver/b3SolverConstraint.h
new file mode 100644
index 00000000..4927ae42
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Dynamics/ConstraintSolver/b3SolverConstraint.h
@@ -0,0 +1,73 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_SOLVER_CONSTRAINT_H
+#define B3_SOLVER_CONSTRAINT_H
+
+#include "Bullet3Common/b3Vector3.h"
+#include "Bullet3Common/b3Matrix3x3.h"
+//#include "b3JacobianEntry.h"
+#include "Bullet3Common/b3AlignedObjectArray.h"
+
+//#define NO_FRICTION_TANGENTIALS 1
+#include "b3SolverBody.h"
+
+///1D constraint along a normal axis between bodyA and bodyB. It can be combined to solve contact and friction constraints.
+B3_ATTRIBUTE_ALIGNED16(struct)
+b3SolverConstraint
+{
+	B3_DECLARE_ALIGNED_ALLOCATOR();
+
+	b3Vector3 m_relpos1CrossNormal;
+	b3Vector3 m_contactNormal;
+
+	b3Vector3 m_relpos2CrossNormal;
+	//b3Vector3		m_contactNormal2;//usually m_contactNormal2 == -m_contactNormal
+
+	b3Vector3 m_angularComponentA;
+	b3Vector3 m_angularComponentB;
+
+	mutable b3SimdScalar m_appliedPushImpulse;
+	mutable b3SimdScalar m_appliedImpulse;
+	int m_padding1;
+	int m_padding2;
+	b3Scalar m_friction;
+	b3Scalar m_jacDiagABInv;
+	b3Scalar m_rhs;
+	b3Scalar m_cfm;
+
+	b3Scalar m_lowerLimit;
+	b3Scalar m_upperLimit;
+	b3Scalar m_rhsPenetration;
+	union {
+		void* m_originalContactPoint;
+		b3Scalar m_unusedPadding4;
+	};
+
+	int m_overrideNumSolverIterations;
+	int m_frictionIndex;
+	int m_solverBodyIdA;
+	int m_solverBodyIdB;
+
+	enum b3SolverConstraintType
+	{
+		B3_SOLVER_CONTACT_1D = 0,
+		B3_SOLVER_FRICTION_1D
+	};
+};
+
+typedef b3AlignedObjectArray<b3SolverConstraint> b3ConstraintArray;
+
+#endif  //B3_SOLVER_CONSTRAINT_H
diff --git a/engine/inc/bullet/Bullet3Dynamics/ConstraintSolver/b3TypedConstraint.h b/engine/inc/bullet/Bullet3Dynamics/ConstraintSolver/b3TypedConstraint.h
new file mode 100644
index 00000000..f74aec4d
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Dynamics/ConstraintSolver/b3TypedConstraint.h
@@ -0,0 +1,469 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2010 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_TYPED_CONSTRAINT_H
+#define B3_TYPED_CONSTRAINT_H
+
+#include "Bullet3Common/b3Scalar.h"
+#include "b3SolverConstraint.h"
+
+class b3Serializer;
+
+//Don't change any of the existing enum values, so add enum types at the end for serialization compatibility
+enum b3TypedConstraintType
+{
+	B3_POINT2POINT_CONSTRAINT_TYPE = 3,
+	B3_HINGE_CONSTRAINT_TYPE,
+	B3_CONETWIST_CONSTRAINT_TYPE,
+	B3_D6_CONSTRAINT_TYPE,
+	B3_SLIDER_CONSTRAINT_TYPE,
+	B3_CONTACT_CONSTRAINT_TYPE,
+	B3_D6_SPRING_CONSTRAINT_TYPE,
+	B3_GEAR_CONSTRAINT_TYPE,
+	B3_FIXED_CONSTRAINT_TYPE,
+	B3_MAX_CONSTRAINT_TYPE
+};
+
+enum b3ConstraintParams
+{
+	B3_CONSTRAINT_ERP = 1,
+	B3_CONSTRAINT_STOP_ERP,
+	B3_CONSTRAINT_CFM,
+	B3_CONSTRAINT_STOP_CFM
+};
+
+#if 1
+#define b3AssertConstrParams(_par) b3Assert(_par)
+#else
+#define b3AssertConstrParams(_par)
+#endif
+
+B3_ATTRIBUTE_ALIGNED16(struct)
+b3JointFeedback
+{
+	b3Vector3 m_appliedForceBodyA;
+	b3Vector3 m_appliedTorqueBodyA;
+	b3Vector3 m_appliedForceBodyB;
+	b3Vector3 m_appliedTorqueBodyB;
+};
+
+struct b3RigidBodyData;
+
+///TypedConstraint is the baseclass for Bullet constraints and vehicles
+B3_ATTRIBUTE_ALIGNED16(class)
+b3TypedConstraint : public b3TypedObject
+{
+	int m_userConstraintType;
+
+	union {
+		int m_userConstraintId;
+		void* m_userConstraintPtr;
+	};
+
+	b3Scalar m_breakingImpulseThreshold;
+	bool m_isEnabled;
+	bool m_needsFeedback;
+	int m_overrideNumSolverIterations;
+
+	b3TypedConstraint& operator=(b3TypedConstraint& other)
+	{
+		b3Assert(0);
+		(void)other;
+		return *this;
+	}
+
+protected:
+	int m_rbA;
+	int m_rbB;
+	b3Scalar m_appliedImpulse;
+	b3Scalar m_dbgDrawSize;
+	b3JointFeedback* m_jointFeedback;
+
+	///internal method used by the constraint solver, don't use them directly
+	b3Scalar getMotorFactor(b3Scalar pos, b3Scalar lowLim, b3Scalar uppLim, b3Scalar vel, b3Scalar timeFact);
+
+public:
+	B3_DECLARE_ALIGNED_ALLOCATOR();
+
+	virtual ~b3TypedConstraint(){};
+	b3TypedConstraint(b3TypedConstraintType type, int bodyA, int bodyB);
+
+	struct b3ConstraintInfo1
+	{
+		int m_numConstraintRows, nub;
+	};
+
+	struct b3ConstraintInfo2
+	{
+		// integrator parameters: frames per second (1/stepsize), default error
+		// reduction parameter (0..1).
+		b3Scalar fps, erp;
+
+		// for the first and second body, pointers to two (linear and angular)
+		// n*3 jacobian sub matrices, stored by rows. these matrices will have
+		// been initialized to 0 on entry. if the second body is zero then the
+		// J2xx pointers may be 0.
+		b3Scalar *m_J1linearAxis, *m_J1angularAxis, *m_J2linearAxis, *m_J2angularAxis;
+
+		// elements to jump from one row to the next in J's
+		int rowskip;
+
+		// right hand sides of the equation J*v = c + cfm * lambda. cfm is the
+		// "constraint force mixing" vector. c is set to zero on entry, cfm is
+		// set to a constant value (typically very small or zero) value on entry.
+		b3Scalar *m_constraintError, *cfm;
+
+		// lo and hi limits for variables (set to -/+ infinity on entry).
+		b3Scalar *m_lowerLimit, *m_upperLimit;
+
+		// findex vector for variables. see the LCP solver interface for a
+		// description of what this does. this is set to -1 on entry.
+		// note that the returned indexes are relative to the first index of
+		// the constraint.
+		int* findex;
+		// number of solver iterations
+		int m_numIterations;
+
+		//damping of the velocity
+		b3Scalar m_damping;
+	};
+
+	int getOverrideNumSolverIterations() const
+	{
+		return m_overrideNumSolverIterations;
+	}
+
+	///override the number of constraint solver iterations used to solve this constraint
+	///-1 will use the default number of iterations, as specified in SolverInfo.m_numIterations
+	void setOverrideNumSolverIterations(int overideNumIterations)
+	{
+		m_overrideNumSolverIterations = overideNumIterations;
+	}
+
+	///internal method used by the constraint solver, don't use them directly
+	virtual void setupSolverConstraint(b3ConstraintArray & ca, int solverBodyA, int solverBodyB, b3Scalar timeStep)
+	{
+		(void)ca;
+		(void)solverBodyA;
+		(void)solverBodyB;
+		(void)timeStep;
+	}
+
+	///internal method used by the constraint solver, don't use them directly
+	virtual void getInfo1(b3ConstraintInfo1 * info, const b3RigidBodyData* bodies) = 0;
+
+	///internal method used by the constraint solver, don't use them directly
+	virtual void getInfo2(b3ConstraintInfo2 * info, const b3RigidBodyData* bodies) = 0;
+
+	///internal method used by the constraint solver, don't use them directly
+	void internalSetAppliedImpulse(b3Scalar appliedImpulse)
+	{
+		m_appliedImpulse = appliedImpulse;
+	}
+	///internal method used by the constraint solver, don't use them directly
+	b3Scalar internalGetAppliedImpulse()
+	{
+		return m_appliedImpulse;
+	}
+
+	b3Scalar getBreakingImpulseThreshold() const
+	{
+		return m_breakingImpulseThreshold;
+	}
+
+	void setBreakingImpulseThreshold(b3Scalar threshold)
+	{
+		m_breakingImpulseThreshold = threshold;
+	}
+
+	bool isEnabled() const
+	{
+		return m_isEnabled;
+	}
+
+	void setEnabled(bool enabled)
+	{
+		m_isEnabled = enabled;
+	}
+
+	///internal method used by the constraint solver, don't use them directly
+	virtual void solveConstraintObsolete(b3SolverBody& /*bodyA*/, b3SolverBody& /*bodyB*/, b3Scalar /*timeStep*/){};
+
+	int getRigidBodyA() const
+	{
+		return m_rbA;
+	}
+	int getRigidBodyB() const
+	{
+		return m_rbB;
+	}
+
+	int getRigidBodyA()
+	{
+		return m_rbA;
+	}
+	int getRigidBodyB()
+	{
+		return m_rbB;
+	}
+
+	int getUserConstraintType() const
+	{
+		return m_userConstraintType;
+	}
+
+	void setUserConstraintType(int userConstraintType)
+	{
+		m_userConstraintType = userConstraintType;
+	};
+
+	void setUserConstraintId(int uid)
+	{
+		m_userConstraintId = uid;
+	}
+
+	int getUserConstraintId() const
+	{
+		return m_userConstraintId;
+	}
+
+	void setUserConstraintPtr(void* ptr)
+	{
+		m_userConstraintPtr = ptr;
+	}
+
+	void* getUserConstraintPtr()
+	{
+		return m_userConstraintPtr;
+	}
+
+	void setJointFeedback(b3JointFeedback * jointFeedback)
+	{
+		m_jointFeedback = jointFeedback;
+	}
+
+	const b3JointFeedback* getJointFeedback() const
+	{
+		return m_jointFeedback;
+	}
+
+	b3JointFeedback* getJointFeedback()
+	{
+		return m_jointFeedback;
+	}
+
+	int getUid() const
+	{
+		return m_userConstraintId;
+	}
+
+	bool needsFeedback() const
+	{
+		return m_needsFeedback;
+	}
+
+	///enableFeedback will allow to read the applied linear and angular impulse
+	///use getAppliedImpulse, getAppliedLinearImpulse and getAppliedAngularImpulse to read feedback information
+	void enableFeedback(bool needsFeedback)
+	{
+		m_needsFeedback = needsFeedback;
+	}
+
+	///getAppliedImpulse is an estimated total applied impulse.
+	///This feedback could be used to determine breaking constraints or playing sounds.
+	b3Scalar getAppliedImpulse() const
+	{
+		b3Assert(m_needsFeedback);
+		return m_appliedImpulse;
+	}
+
+	b3TypedConstraintType getConstraintType() const
+	{
+		return b3TypedConstraintType(m_objectType);
+	}
+
+	void setDbgDrawSize(b3Scalar dbgDrawSize)
+	{
+		m_dbgDrawSize = dbgDrawSize;
+	}
+	b3Scalar getDbgDrawSize()
+	{
+		return m_dbgDrawSize;
+	}
+
+	///override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5).
+	///If no axis is provided, it uses the default axis for this constraint.
+	virtual void setParam(int num, b3Scalar value, int axis = -1) = 0;
+
+	///return the local value of parameter
+	virtual b3Scalar getParam(int num, int axis = -1) const = 0;
+
+	//	virtual	int	calculateSerializeBufferSize() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	//virtual	const char*	serialize(void* dataBuffer, b3Serializer* serializer) const;
+};
+
+// returns angle in range [-B3_2_PI, B3_2_PI], closest to one of the limits
+// all arguments should be normalized angles (i.e. in range [-B3_PI, B3_PI])
+B3_FORCE_INLINE b3Scalar b3AdjustAngleToLimits(b3Scalar angleInRadians, b3Scalar angleLowerLimitInRadians, b3Scalar angleUpperLimitInRadians)
+{
+	if (angleLowerLimitInRadians >= angleUpperLimitInRadians)
+	{
+		return angleInRadians;
+	}
+	else if (angleInRadians < angleLowerLimitInRadians)
+	{
+		b3Scalar diffLo = b3Fabs(b3NormalizeAngle(angleLowerLimitInRadians - angleInRadians));
+		b3Scalar diffHi = b3Fabs(b3NormalizeAngle(angleUpperLimitInRadians - angleInRadians));
+		return (diffLo < diffHi) ? angleInRadians : (angleInRadians + B3_2_PI);
+	}
+	else if (angleInRadians > angleUpperLimitInRadians)
+	{
+		b3Scalar diffHi = b3Fabs(b3NormalizeAngle(angleInRadians - angleUpperLimitInRadians));
+		b3Scalar diffLo = b3Fabs(b3NormalizeAngle(angleInRadians - angleLowerLimitInRadians));
+		return (diffLo < diffHi) ? (angleInRadians - B3_2_PI) : angleInRadians;
+	}
+	else
+	{
+		return angleInRadians;
+	}
+}
+
+// clang-format off
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct	b3TypedConstraintData
+{
+	int		m_bodyA;
+	int		m_bodyB;
+	char	*m_name;
+
+	int	m_objectType;
+	int	m_userConstraintType;
+	int	m_userConstraintId;
+	int	m_needsFeedback;
+
+	float	m_appliedImpulse;
+	float	m_dbgDrawSize;
+
+	int	m_disableCollisionsBetweenLinkedBodies;
+	int	m_overrideNumSolverIterations;
+
+	float	m_breakingImpulseThreshold;
+	int		m_isEnabled;
+	
+};
+
+// clang-format on
+
+/*B3_FORCE_INLINE	int	b3TypedConstraint::calculateSerializeBufferSize() const
+{
+	return sizeof(b3TypedConstraintData);
+}
+*/
+
+class b3AngularLimit
+{
+private:
+	b3Scalar
+		m_center,
+		m_halfRange,
+		m_softness,
+		m_biasFactor,
+		m_relaxationFactor,
+		m_correction,
+		m_sign;
+
+	bool
+		m_solveLimit;
+
+public:
+	/// Default constructor initializes limit as inactive, allowing free constraint movement
+	b3AngularLimit()
+		: m_center(0.0f),
+		  m_halfRange(-1.0f),
+		  m_softness(0.9f),
+		  m_biasFactor(0.3f),
+		  m_relaxationFactor(1.0f),
+		  m_correction(0.0f),
+		  m_sign(0.0f),
+		  m_solveLimit(false)
+	{
+	}
+
+	/// Sets all limit's parameters.
+	/// When low > high limit becomes inactive.
+	/// When high - low > 2PI limit is ineffective too becouse no angle can exceed the limit
+	void set(b3Scalar low, b3Scalar high, b3Scalar _softness = 0.9f, b3Scalar _biasFactor = 0.3f, b3Scalar _relaxationFactor = 1.0f);
+
+	/// Checks conastaint angle against limit. If limit is active and the angle violates the limit
+	/// correction is calculated.
+	void test(const b3Scalar angle);
+
+	/// Returns limit's softness
+	inline b3Scalar getSoftness() const
+	{
+		return m_softness;
+	}
+
+	/// Returns limit's bias factor
+	inline b3Scalar getBiasFactor() const
+	{
+		return m_biasFactor;
+	}
+
+	/// Returns limit's relaxation factor
+	inline b3Scalar getRelaxationFactor() const
+	{
+		return m_relaxationFactor;
+	}
+
+	/// Returns correction value evaluated when test() was invoked
+	inline b3Scalar getCorrection() const
+	{
+		return m_correction;
+	}
+
+	/// Returns sign value evaluated when test() was invoked
+	inline b3Scalar getSign() const
+	{
+		return m_sign;
+	}
+
+	/// Gives half of the distance between min and max limit angle
+	inline b3Scalar getHalfRange() const
+	{
+		return m_halfRange;
+	}
+
+	/// Returns true when the last test() invocation recognized limit violation
+	inline bool isLimit() const
+	{
+		return m_solveLimit;
+	}
+
+	/// Checks given angle against limit. If limit is active and angle doesn't fit it, the angle
+	/// returned is modified so it equals to the limit closest to given angle.
+	void fit(b3Scalar& angle) const;
+
+	/// Returns correction value multiplied by sign value
+	b3Scalar getError() const;
+
+	b3Scalar getLow() const;
+
+	b3Scalar getHigh() const;
+};
+
+#endif  //B3_TYPED_CONSTRAINT_H
diff --git a/engine/inc/bullet/Bullet3Dynamics/b3CpuRigidBodyPipeline.h b/engine/inc/bullet/Bullet3Dynamics/b3CpuRigidBodyPipeline.h
new file mode 100644
index 00000000..9c65419f
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Dynamics/b3CpuRigidBodyPipeline.h
@@ -0,0 +1,62 @@
+/*
+Copyright (c) 2013 Advanced Micro Devices, Inc.  
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+//Originally written by Erwin Coumans
+
+#ifndef B3_CPU_RIGIDBODY_PIPELINE_H
+#define B3_CPU_RIGIDBODY_PIPELINE_H
+
+#include "Bullet3Common/b3AlignedObjectArray.h"
+#include "Bullet3Collision/NarrowPhaseCollision/b3RaycastInfo.h"
+
+class b3CpuRigidBodyPipeline
+{
+protected:
+	struct b3CpuRigidBodyPipelineInternalData* m_data;
+
+	int allocateCollidable();
+
+public:
+	b3CpuRigidBodyPipeline(class b3CpuNarrowPhase* narrowphase, struct b3DynamicBvhBroadphase* broadphaseDbvt, const struct b3Config& config);
+	virtual ~b3CpuRigidBodyPipeline();
+
+	virtual void stepSimulation(float deltaTime);
+	virtual void integrate(float timeStep);
+	virtual void updateAabbWorldSpace();
+	virtual void computeOverlappingPairs();
+	virtual void computeContactPoints();
+	virtual void solveContactConstraints();
+
+	int registerConvexPolyhedron(class b3ConvexUtility* convex);
+
+	int registerPhysicsInstance(float mass, const float* position, const float* orientation, int collisionShapeIndex, int userData);
+	void writeAllInstancesToGpu();
+	void copyConstraintsToHost();
+	void setGravity(const float* grav);
+	void reset();
+
+	int createPoint2PointConstraint(int bodyA, int bodyB, const float* pivotInA, const float* pivotInB, float breakingThreshold);
+	int createFixedConstraint(int bodyA, int bodyB, const float* pivotInA, const float* pivotInB, const float* relTargetAB, float breakingThreshold);
+	void removeConstraintByUid(int uid);
+
+	void addConstraint(class b3TypedConstraint* constraint);
+	void removeConstraint(b3TypedConstraint* constraint);
+
+	void castRays(const b3AlignedObjectArray<b3RayInfo>& rays, b3AlignedObjectArray<b3RayHit>& hitResults);
+
+	const struct b3RigidBodyData* getBodyBuffer() const;
+
+	int getNumBodies() const;
+};
+
+#endif  //B3_CPU_RIGIDBODY_PIPELINE_H
\ No newline at end of file
diff --git a/engine/inc/bullet/Bullet3Dynamics/shared/b3ContactConstraint4.h b/engine/inc/bullet/Bullet3Dynamics/shared/b3ContactConstraint4.h
new file mode 100644
index 00000000..cf2eed0e
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Dynamics/shared/b3ContactConstraint4.h
@@ -0,0 +1,31 @@
+#ifndef B3_CONTACT_CONSTRAINT5_H
+#define B3_CONTACT_CONSTRAINT5_H
+
+#include "Bullet3Common/shared/b3Float4.h"
+
+typedef struct b3ContactConstraint4 b3ContactConstraint4_t;
+
+struct b3ContactConstraint4
+{
+	b3Float4 m_linear;  //normal?
+	b3Float4 m_worldPos[4];
+	b3Float4 m_center;  //	friction
+	float m_jacCoeffInv[4];
+	float m_b[4];
+	float m_appliedRambdaDt[4];
+	float m_fJacCoeffInv[2];      //	friction
+	float m_fAppliedRambdaDt[2];  //	friction
+
+	unsigned int m_bodyA;
+	unsigned int m_bodyB;
+	int m_batchIdx;
+	unsigned int m_paddings;
+};
+
+//inline	void setFrictionCoeff(float value) { m_linear[3] = value; }
+inline float b3GetFrictionCoeff(b3ContactConstraint4_t* constraint)
+{
+	return constraint->m_linear.w;
+}
+
+#endif  //B3_CONTACT_CONSTRAINT5_H
diff --git a/engine/inc/bullet/Bullet3Dynamics/shared/b3ConvertConstraint4.h b/engine/inc/bullet/Bullet3Dynamics/shared/b3ConvertConstraint4.h
new file mode 100644
index 00000000..3e72f1c3
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Dynamics/shared/b3ConvertConstraint4.h
@@ -0,0 +1,148 @@
+
+
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3Contact4Data.h"
+#include "Bullet3Dynamics/shared/b3ContactConstraint4.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h"
+
+void b3PlaneSpace1(b3Float4ConstArg n, b3Float4* p, b3Float4* q);
+void b3PlaneSpace1(b3Float4ConstArg n, b3Float4* p, b3Float4* q)
+{
+	if (b3Fabs(n.z) > 0.70710678f)
+	{
+		// choose p in y-z plane
+		float a = n.y * n.y + n.z * n.z;
+		float k = 1.f / sqrt(a);
+		p[0].x = 0;
+		p[0].y = -n.z * k;
+		p[0].z = n.y * k;
+		// set q = n x p
+		q[0].x = a * k;
+		q[0].y = -n.x * p[0].z;
+		q[0].z = n.x * p[0].y;
+	}
+	else
+	{
+		// choose p in x-y plane
+		float a = n.x * n.x + n.y * n.y;
+		float k = 1.f / sqrt(a);
+		p[0].x = -n.y * k;
+		p[0].y = n.x * k;
+		p[0].z = 0;
+		// set q = n x p
+		q[0].x = -n.z * p[0].y;
+		q[0].y = n.z * p[0].x;
+		q[0].z = a * k;
+	}
+}
+
+void setLinearAndAngular(b3Float4ConstArg n, b3Float4ConstArg r0, b3Float4ConstArg r1, b3Float4* linear, b3Float4* angular0, b3Float4* angular1)
+{
+	*linear = b3MakeFloat4(n.x, n.y, n.z, 0.f);
+	*angular0 = b3Cross3(r0, n);
+	*angular1 = -b3Cross3(r1, n);
+}
+
+float calcRelVel(b3Float4ConstArg l0, b3Float4ConstArg l1, b3Float4ConstArg a0, b3Float4ConstArg a1, b3Float4ConstArg linVel0,
+				 b3Float4ConstArg angVel0, b3Float4ConstArg linVel1, b3Float4ConstArg angVel1)
+{
+	return b3Dot3F4(l0, linVel0) + b3Dot3F4(a0, angVel0) + b3Dot3F4(l1, linVel1) + b3Dot3F4(a1, angVel1);
+}
+
+float calcJacCoeff(b3Float4ConstArg linear0, b3Float4ConstArg linear1, b3Float4ConstArg angular0, b3Float4ConstArg angular1,
+				   float invMass0, const b3Mat3x3* invInertia0, float invMass1, const b3Mat3x3* invInertia1)
+{
+	//	linear0,1 are normlized
+	float jmj0 = invMass0;  //b3Dot3F4(linear0, linear0)*invMass0;
+	float jmj1 = b3Dot3F4(mtMul3(angular0, *invInertia0), angular0);
+	float jmj2 = invMass1;  //b3Dot3F4(linear1, linear1)*invMass1;
+	float jmj3 = b3Dot3F4(mtMul3(angular1, *invInertia1), angular1);
+	return -1.f / (jmj0 + jmj1 + jmj2 + jmj3);
+}
+
+void setConstraint4(b3Float4ConstArg posA, b3Float4ConstArg linVelA, b3Float4ConstArg angVelA, float invMassA, b3Mat3x3ConstArg invInertiaA,
+					b3Float4ConstArg posB, b3Float4ConstArg linVelB, b3Float4ConstArg angVelB, float invMassB, b3Mat3x3ConstArg invInertiaB,
+					__global struct b3Contact4Data* src, float dt, float positionDrift, float positionConstraintCoeff,
+					b3ContactConstraint4_t* dstC)
+{
+	dstC->m_bodyA = abs(src->m_bodyAPtrAndSignBit);
+	dstC->m_bodyB = abs(src->m_bodyBPtrAndSignBit);
+
+	float dtInv = 1.f / dt;
+	for (int ic = 0; ic < 4; ic++)
+	{
+		dstC->m_appliedRambdaDt[ic] = 0.f;
+	}
+	dstC->m_fJacCoeffInv[0] = dstC->m_fJacCoeffInv[1] = 0.f;
+
+	dstC->m_linear = src->m_worldNormalOnB;
+	dstC->m_linear.w = 0.7f;  //src->getFrictionCoeff() );
+	for (int ic = 0; ic < 4; ic++)
+	{
+		b3Float4 r0 = src->m_worldPosB[ic] - posA;
+		b3Float4 r1 = src->m_worldPosB[ic] - posB;
+
+		if (ic >= src->m_worldNormalOnB.w)  //npoints
+		{
+			dstC->m_jacCoeffInv[ic] = 0.f;
+			continue;
+		}
+
+		float relVelN;
+		{
+			b3Float4 linear, angular0, angular1;
+			setLinearAndAngular(src->m_worldNormalOnB, r0, r1, &linear, &angular0, &angular1);
+
+			dstC->m_jacCoeffInv[ic] = calcJacCoeff(linear, -linear, angular0, angular1,
+												   invMassA, &invInertiaA, invMassB, &invInertiaB);
+
+			relVelN = calcRelVel(linear, -linear, angular0, angular1,
+								 linVelA, angVelA, linVelB, angVelB);
+
+			float e = 0.f;  //src->getRestituitionCoeff();
+			if (relVelN * relVelN < 0.004f) e = 0.f;
+
+			dstC->m_b[ic] = e * relVelN;
+			//float penetration = src->m_worldPosB[ic].w;
+			dstC->m_b[ic] += (src->m_worldPosB[ic].w + positionDrift) * positionConstraintCoeff * dtInv;
+			dstC->m_appliedRambdaDt[ic] = 0.f;
+		}
+	}
+
+	if (src->m_worldNormalOnB.w > 0)  //npoints
+	{                                 //	prepare friction
+		b3Float4 center = b3MakeFloat4(0.f, 0.f, 0.f, 0.f);
+		for (int i = 0; i < src->m_worldNormalOnB.w; i++)
+			center += src->m_worldPosB[i];
+		center /= (float)src->m_worldNormalOnB.w;
+
+		b3Float4 tangent[2];
+		b3PlaneSpace1(src->m_worldNormalOnB, &tangent[0], &tangent[1]);
+
+		b3Float4 r[2];
+		r[0] = center - posA;
+		r[1] = center - posB;
+
+		for (int i = 0; i < 2; i++)
+		{
+			b3Float4 linear, angular0, angular1;
+			setLinearAndAngular(tangent[i], r[0], r[1], &linear, &angular0, &angular1);
+
+			dstC->m_fJacCoeffInv[i] = calcJacCoeff(linear, -linear, angular0, angular1,
+												   invMassA, &invInertiaA, invMassB, &invInertiaB);
+			dstC->m_fAppliedRambdaDt[i] = 0.f;
+		}
+		dstC->m_center = center;
+	}
+
+	for (int i = 0; i < 4; i++)
+	{
+		if (i < src->m_worldNormalOnB.w)
+		{
+			dstC->m_worldPos[i] = src->m_worldPosB[i];
+		}
+		else
+		{
+			dstC->m_worldPos[i] = b3MakeFloat4(0.f, 0.f, 0.f, 0.f);
+		}
+	}
+}
diff --git a/engine/inc/bullet/Bullet3Dynamics/shared/b3Inertia.h b/engine/inc/bullet/Bullet3Dynamics/shared/b3Inertia.h
new file mode 100644
index 00000000..602a1335
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Dynamics/shared/b3Inertia.h
@@ -0,0 +1,14 @@
+
+
+#ifndef B3_INERTIA_H
+#define B3_INERTIA_H
+
+#include "Bullet3Common/shared/b3Mat3x3.h"
+
+struct b3Inertia
+{
+	b3Mat3x3 m_invInertiaWorld;
+	b3Mat3x3 m_initInvInertia;
+};
+
+#endif  //B3_INERTIA_H
\ No newline at end of file
diff --git a/engine/inc/bullet/Bullet3Dynamics/shared/b3IntegrateTransforms.h b/engine/inc/bullet/Bullet3Dynamics/shared/b3IntegrateTransforms.h
new file mode 100644
index 00000000..56d9118f
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Dynamics/shared/b3IntegrateTransforms.h
@@ -0,0 +1,106 @@
+
+
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h"
+
+inline void integrateSingleTransform(__global b3RigidBodyData_t* bodies, int nodeID, float timeStep, float angularDamping, b3Float4ConstArg gravityAcceleration)
+{
+	if (bodies[nodeID].m_invMass != 0.f)
+	{
+		float BT_GPU_ANGULAR_MOTION_THRESHOLD = (0.25f * 3.14159254f);
+
+		//angular velocity
+		{
+			b3Float4 axis;
+			//add some hardcoded angular damping
+			bodies[nodeID].m_angVel.x *= angularDamping;
+			bodies[nodeID].m_angVel.y *= angularDamping;
+			bodies[nodeID].m_angVel.z *= angularDamping;
+
+			b3Float4 angvel = bodies[nodeID].m_angVel;
+
+			float fAngle = b3Sqrt(b3Dot3F4(angvel, angvel));
+
+			//limit the angular motion
+			if (fAngle * timeStep > BT_GPU_ANGULAR_MOTION_THRESHOLD)
+			{
+				fAngle = BT_GPU_ANGULAR_MOTION_THRESHOLD / timeStep;
+			}
+			if (fAngle < 0.001f)
+			{
+				// use Taylor's expansions of sync function
+				axis = angvel * (0.5f * timeStep - (timeStep * timeStep * timeStep) * 0.020833333333f * fAngle * fAngle);
+			}
+			else
+			{
+				// sync(fAngle) = sin(c*fAngle)/t
+				axis = angvel * (b3Sin(0.5f * fAngle * timeStep) / fAngle);
+			}
+
+			b3Quat dorn;
+			dorn.x = axis.x;
+			dorn.y = axis.y;
+			dorn.z = axis.z;
+			dorn.w = b3Cos(fAngle * timeStep * 0.5f);
+			b3Quat orn0 = bodies[nodeID].m_quat;
+			b3Quat predictedOrn = b3QuatMul(dorn, orn0);
+			predictedOrn = b3QuatNormalized(predictedOrn);
+			bodies[nodeID].m_quat = predictedOrn;
+		}
+		//linear velocity
+		bodies[nodeID].m_pos += bodies[nodeID].m_linVel * timeStep;
+
+		//apply gravity
+		bodies[nodeID].m_linVel += gravityAcceleration * timeStep;
+	}
+}
+
+inline void b3IntegrateTransform(__global b3RigidBodyData_t* body, float timeStep, float angularDamping, b3Float4ConstArg gravityAcceleration)
+{
+	float BT_GPU_ANGULAR_MOTION_THRESHOLD = (0.25f * 3.14159254f);
+
+	if ((body->m_invMass != 0.f))
+	{
+		//angular velocity
+		{
+			b3Float4 axis;
+			//add some hardcoded angular damping
+			body->m_angVel.x *= angularDamping;
+			body->m_angVel.y *= angularDamping;
+			body->m_angVel.z *= angularDamping;
+
+			b3Float4 angvel = body->m_angVel;
+			float fAngle = b3Sqrt(b3Dot3F4(angvel, angvel));
+			//limit the angular motion
+			if (fAngle * timeStep > BT_GPU_ANGULAR_MOTION_THRESHOLD)
+			{
+				fAngle = BT_GPU_ANGULAR_MOTION_THRESHOLD / timeStep;
+			}
+			if (fAngle < 0.001f)
+			{
+				// use Taylor's expansions of sync function
+				axis = angvel * (0.5f * timeStep - (timeStep * timeStep * timeStep) * 0.020833333333f * fAngle * fAngle);
+			}
+			else
+			{
+				// sync(fAngle) = sin(c*fAngle)/t
+				axis = angvel * (b3Sin(0.5f * fAngle * timeStep) / fAngle);
+			}
+			b3Quat dorn;
+			dorn.x = axis.x;
+			dorn.y = axis.y;
+			dorn.z = axis.z;
+			dorn.w = b3Cos(fAngle * timeStep * 0.5f);
+			b3Quat orn0 = body->m_quat;
+
+			b3Quat predictedOrn = b3QuatMul(dorn, orn0);
+			predictedOrn = b3QuatNormalized(predictedOrn);
+			body->m_quat = predictedOrn;
+		}
+
+		//apply gravity
+		body->m_linVel += gravityAcceleration * timeStep;
+
+		//linear velocity
+		body->m_pos += body->m_linVel * timeStep;
+	}
+}
diff --git a/engine/inc/bullet/Bullet3Geometry/b3AabbUtil.h b/engine/inc/bullet/Bullet3Geometry/b3AabbUtil.h
new file mode 100644
index 00000000..396a4014
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Geometry/b3AabbUtil.h
@@ -0,0 +1,217 @@
+/*
+Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_AABB_UTIL2
+#define B3_AABB_UTIL2
+
+#include "Bullet3Common/b3Transform.h"
+#include "Bullet3Common/b3Vector3.h"
+#include "Bullet3Common/b3MinMax.h"
+
+B3_FORCE_INLINE void b3AabbExpand(b3Vector3& aabbMin,
+								  b3Vector3& aabbMax,
+								  const b3Vector3& expansionMin,
+								  const b3Vector3& expansionMax)
+{
+	aabbMin = aabbMin + expansionMin;
+	aabbMax = aabbMax + expansionMax;
+}
+
+/// conservative test for overlap between two aabbs
+B3_FORCE_INLINE bool b3TestPointAgainstAabb2(const b3Vector3& aabbMin1, const b3Vector3& aabbMax1,
+											 const b3Vector3& point)
+{
+	bool overlap = true;
+	overlap = (aabbMin1.getX() > point.getX() || aabbMax1.getX() < point.getX()) ? false : overlap;
+	overlap = (aabbMin1.getZ() > point.getZ() || aabbMax1.getZ() < point.getZ()) ? false : overlap;
+	overlap = (aabbMin1.getY() > point.getY() || aabbMax1.getY() < point.getY()) ? false : overlap;
+	return overlap;
+}
+
+/// conservative test for overlap between two aabbs
+B3_FORCE_INLINE bool b3TestAabbAgainstAabb2(const b3Vector3& aabbMin1, const b3Vector3& aabbMax1,
+											const b3Vector3& aabbMin2, const b3Vector3& aabbMax2)
+{
+	bool overlap = true;
+	overlap = (aabbMin1.getX() > aabbMax2.getX() || aabbMax1.getX() < aabbMin2.getX()) ? false : overlap;
+	overlap = (aabbMin1.getZ() > aabbMax2.getZ() || aabbMax1.getZ() < aabbMin2.getZ()) ? false : overlap;
+	overlap = (aabbMin1.getY() > aabbMax2.getY() || aabbMax1.getY() < aabbMin2.getY()) ? false : overlap;
+	return overlap;
+}
+
+/// conservative test for overlap between triangle and aabb
+B3_FORCE_INLINE bool b3TestTriangleAgainstAabb2(const b3Vector3* vertices,
+												const b3Vector3& aabbMin, const b3Vector3& aabbMax)
+{
+	const b3Vector3& p1 = vertices[0];
+	const b3Vector3& p2 = vertices[1];
+	const b3Vector3& p3 = vertices[2];
+
+	if (b3Min(b3Min(p1[0], p2[0]), p3[0]) > aabbMax[0]) return false;
+	if (b3Max(b3Max(p1[0], p2[0]), p3[0]) < aabbMin[0]) return false;
+
+	if (b3Min(b3Min(p1[2], p2[2]), p3[2]) > aabbMax[2]) return false;
+	if (b3Max(b3Max(p1[2], p2[2]), p3[2]) < aabbMin[2]) return false;
+
+	if (b3Min(b3Min(p1[1], p2[1]), p3[1]) > aabbMax[1]) return false;
+	if (b3Max(b3Max(p1[1], p2[1]), p3[1]) < aabbMin[1]) return false;
+	return true;
+}
+
+B3_FORCE_INLINE int b3Outcode(const b3Vector3& p, const b3Vector3& halfExtent)
+{
+	return (p.getX() < -halfExtent.getX() ? 0x01 : 0x0) |
+		   (p.getX() > halfExtent.getX() ? 0x08 : 0x0) |
+		   (p.getY() < -halfExtent.getY() ? 0x02 : 0x0) |
+		   (p.getY() > halfExtent.getY() ? 0x10 : 0x0) |
+		   (p.getZ() < -halfExtent.getZ() ? 0x4 : 0x0) |
+		   (p.getZ() > halfExtent.getZ() ? 0x20 : 0x0);
+}
+
+B3_FORCE_INLINE bool b3RayAabb2(const b3Vector3& rayFrom,
+								const b3Vector3& rayInvDirection,
+								const unsigned int raySign[3],
+								const b3Vector3 bounds[2],
+								b3Scalar& tmin,
+								b3Scalar lambda_min,
+								b3Scalar lambda_max)
+{
+	b3Scalar tmax, tymin, tymax, tzmin, tzmax;
+	tmin = (bounds[raySign[0]].getX() - rayFrom.getX()) * rayInvDirection.getX();
+	tmax = (bounds[1 - raySign[0]].getX() - rayFrom.getX()) * rayInvDirection.getX();
+	tymin = (bounds[raySign[1]].getY() - rayFrom.getY()) * rayInvDirection.getY();
+	tymax = (bounds[1 - raySign[1]].getY() - rayFrom.getY()) * rayInvDirection.getY();
+
+	if ((tmin > tymax) || (tymin > tmax))
+		return false;
+
+	if (tymin > tmin)
+		tmin = tymin;
+
+	if (tymax < tmax)
+		tmax = tymax;
+
+	tzmin = (bounds[raySign[2]].getZ() - rayFrom.getZ()) * rayInvDirection.getZ();
+	tzmax = (bounds[1 - raySign[2]].getZ() - rayFrom.getZ()) * rayInvDirection.getZ();
+
+	if ((tmin > tzmax) || (tzmin > tmax))
+		return false;
+	if (tzmin > tmin)
+		tmin = tzmin;
+	if (tzmax < tmax)
+		tmax = tzmax;
+	return ((tmin < lambda_max) && (tmax > lambda_min));
+}
+
+B3_FORCE_INLINE bool b3RayAabb(const b3Vector3& rayFrom,
+							   const b3Vector3& rayTo,
+							   const b3Vector3& aabbMin,
+							   const b3Vector3& aabbMax,
+							   b3Scalar& param, b3Vector3& normal)
+{
+	b3Vector3 aabbHalfExtent = (aabbMax - aabbMin) * b3Scalar(0.5);
+	b3Vector3 aabbCenter = (aabbMax + aabbMin) * b3Scalar(0.5);
+	b3Vector3 source = rayFrom - aabbCenter;
+	b3Vector3 target = rayTo - aabbCenter;
+	int sourceOutcode = b3Outcode(source, aabbHalfExtent);
+	int targetOutcode = b3Outcode(target, aabbHalfExtent);
+	if ((sourceOutcode & targetOutcode) == 0x0)
+	{
+		b3Scalar lambda_enter = b3Scalar(0.0);
+		b3Scalar lambda_exit = param;
+		b3Vector3 r = target - source;
+		int i;
+		b3Scalar normSign = 1;
+		b3Vector3 hitNormal = b3MakeVector3(0, 0, 0);
+		int bit = 1;
+
+		for (int j = 0; j < 2; j++)
+		{
+			for (i = 0; i != 3; ++i)
+			{
+				if (sourceOutcode & bit)
+				{
+					b3Scalar lambda = (-source[i] - aabbHalfExtent[i] * normSign) / r[i];
+					if (lambda_enter <= lambda)
+					{
+						lambda_enter = lambda;
+						hitNormal.setValue(0, 0, 0);
+						hitNormal[i] = normSign;
+					}
+				}
+				else if (targetOutcode & bit)
+				{
+					b3Scalar lambda = (-source[i] - aabbHalfExtent[i] * normSign) / r[i];
+					b3SetMin(lambda_exit, lambda);
+				}
+				bit <<= 1;
+			}
+			normSign = b3Scalar(-1.);
+		}
+		if (lambda_enter <= lambda_exit)
+		{
+			param = lambda_enter;
+			normal = hitNormal;
+			return true;
+		}
+	}
+	return false;
+}
+
+B3_FORCE_INLINE void b3TransformAabb(const b3Vector3& halfExtents, b3Scalar margin, const b3Transform& t, b3Vector3& aabbMinOut, b3Vector3& aabbMaxOut)
+{
+	b3Vector3 halfExtentsWithMargin = halfExtents + b3MakeVector3(margin, margin, margin);
+	b3Matrix3x3 abs_b = t.getBasis().absolute();
+	b3Vector3 center = t.getOrigin();
+	b3Vector3 extent = halfExtentsWithMargin.dot3(abs_b[0], abs_b[1], abs_b[2]);
+	aabbMinOut = center - extent;
+	aabbMaxOut = center + extent;
+}
+
+B3_FORCE_INLINE void b3TransformAabb(const b3Vector3& localAabbMin, const b3Vector3& localAabbMax, b3Scalar margin, const b3Transform& trans, b3Vector3& aabbMinOut, b3Vector3& aabbMaxOut)
+{
+	//b3Assert(localAabbMin.getX() <= localAabbMax.getX());
+	//b3Assert(localAabbMin.getY() <= localAabbMax.getY());
+	//b3Assert(localAabbMin.getZ() <= localAabbMax.getZ());
+	b3Vector3 localHalfExtents = b3Scalar(0.5) * (localAabbMax - localAabbMin);
+	localHalfExtents += b3MakeVector3(margin, margin, margin);
+
+	b3Vector3 localCenter = b3Scalar(0.5) * (localAabbMax + localAabbMin);
+	b3Matrix3x3 abs_b = trans.getBasis().absolute();
+	b3Vector3 center = trans(localCenter);
+	b3Vector3 extent = localHalfExtents.dot3(abs_b[0], abs_b[1], abs_b[2]);
+	aabbMinOut = center - extent;
+	aabbMaxOut = center + extent;
+}
+
+#define B3_USE_BANCHLESS 1
+#ifdef B3_USE_BANCHLESS
+//This block replaces the block below and uses no branches, and replaces the 8 bit return with a 32 bit return for improved performance (~3x on XBox 360)
+B3_FORCE_INLINE unsigned b3TestQuantizedAabbAgainstQuantizedAabb(const unsigned short int* aabbMin1, const unsigned short int* aabbMax1, const unsigned short int* aabbMin2, const unsigned short int* aabbMax2)
+{
+	return static_cast<unsigned int>(b3Select((unsigned)((aabbMin1[0] <= aabbMax2[0]) & (aabbMax1[0] >= aabbMin2[0]) & (aabbMin1[2] <= aabbMax2[2]) & (aabbMax1[2] >= aabbMin2[2]) & (aabbMin1[1] <= aabbMax2[1]) & (aabbMax1[1] >= aabbMin2[1])),
+											  1, 0));
+}
+#else
+B3_FORCE_INLINE bool b3TestQuantizedAabbAgainstQuantizedAabb(const unsigned short int* aabbMin1, const unsigned short int* aabbMax1, const unsigned short int* aabbMin2, const unsigned short int* aabbMax2)
+{
+	bool overlap = true;
+	overlap = (aabbMin1[0] > aabbMax2[0] || aabbMax1[0] < aabbMin2[0]) ? false : overlap;
+	overlap = (aabbMin1[2] > aabbMax2[2] || aabbMax1[2] < aabbMin2[2]) ? false : overlap;
+	overlap = (aabbMin1[1] > aabbMax2[1] || aabbMax1[1] < aabbMin2[1]) ? false : overlap;
+	return overlap;
+}
+#endif  //B3_USE_BANCHLESS
+
+#endif  //B3_AABB_UTIL2
diff --git a/engine/inc/bullet/Bullet3Geometry/b3ConvexHullComputer.h b/engine/inc/bullet/Bullet3Geometry/b3ConvexHullComputer.h
new file mode 100644
index 00000000..8852c5a5
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Geometry/b3ConvexHullComputer.h
@@ -0,0 +1,99 @@
+/*
+Copyright (c) 2011 Ole Kniemeyer, MAXON, www.maxon.net
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_CONVEX_HULL_COMPUTER_H
+#define B3_CONVEX_HULL_COMPUTER_H
+
+#include "Bullet3Common/b3Vector3.h"
+#include "Bullet3Common/b3AlignedObjectArray.h"
+
+/// Convex hull implementation based on Preparata and Hong
+/// See http://code.google.com/p/bullet/issues/detail?id=275
+/// Ole Kniemeyer, MAXON Computer GmbH
+class b3ConvexHullComputer
+{
+private:
+	b3Scalar compute(const void* coords, bool doubleCoords, int stride, int count, b3Scalar shrink, b3Scalar shrinkClamp);
+
+public:
+	class Edge
+	{
+	private:
+		int next;
+		int reverse;
+		int targetVertex;
+
+		friend class b3ConvexHullComputer;
+
+	public:
+		int getSourceVertex() const
+		{
+			return (this + reverse)->targetVertex;
+		}
+
+		int getTargetVertex() const
+		{
+			return targetVertex;
+		}
+
+		const Edge* getNextEdgeOfVertex() const  // clockwise list of all edges of a vertex
+		{
+			return this + next;
+		}
+
+		const Edge* getNextEdgeOfFace() const  // counter-clockwise list of all edges of a face
+		{
+			return (this + reverse)->getNextEdgeOfVertex();
+		}
+
+		const Edge* getReverseEdge() const
+		{
+			return this + reverse;
+		}
+	};
+
+	// Vertices of the output hull
+	b3AlignedObjectArray<b3Vector3> vertices;
+
+	// Edges of the output hull
+	b3AlignedObjectArray<Edge> edges;
+
+	// Faces of the convex hull. Each entry is an index into the "edges" array pointing to an edge of the face. Faces are planar n-gons
+	b3AlignedObjectArray<int> faces;
+
+	/*
+		Compute convex hull of "count" vertices stored in "coords". "stride" is the difference in bytes
+		between the addresses of consecutive vertices. If "shrink" is positive, the convex hull is shrunken
+		by that amount (each face is moved by "shrink" length units towards the center along its normal).
+		If "shrinkClamp" is positive, "shrink" is clamped to not exceed "shrinkClamp * innerRadius", where "innerRadius"
+		is the minimum distance of a face to the center of the convex hull.
+
+		The returned value is the amount by which the hull has been shrunken. If it is negative, the amount was so large
+		that the resulting convex hull is empty.
+
+		The output convex hull can be found in the member variables "vertices", "edges", "faces".
+		*/
+	b3Scalar compute(const float* coords, int stride, int count, b3Scalar shrink, b3Scalar shrinkClamp)
+	{
+		return compute(coords, false, stride, count, shrink, shrinkClamp);
+	}
+
+	// same as above, but double precision
+	b3Scalar compute(const double* coords, int stride, int count, b3Scalar shrink, b3Scalar shrinkClamp)
+	{
+		return compute(coords, true, stride, count, shrink, shrinkClamp);
+	}
+};
+
+#endif  //B3_CONVEX_HULL_COMPUTER_H
diff --git a/engine/inc/bullet/Bullet3Geometry/b3GeometryUtil.h b/engine/inc/bullet/Bullet3Geometry/b3GeometryUtil.h
new file mode 100644
index 00000000..967c8d67
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Geometry/b3GeometryUtil.h
@@ -0,0 +1,36 @@
+/*
+Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_GEOMETRY_UTIL_H
+#define B3_GEOMETRY_UTIL_H
+
+#include "Bullet3Common/b3Vector3.h"
+#include "Bullet3Common/b3AlignedObjectArray.h"
+
+///The b3GeometryUtil helper class provides a few methods to convert between plane equations and vertices.
+class b3GeometryUtil
+{
+public:
+	static void getPlaneEquationsFromVertices(b3AlignedObjectArray<b3Vector3>& vertices, b3AlignedObjectArray<b3Vector3>& planeEquationsOut);
+
+	static void getVerticesFromPlaneEquations(const b3AlignedObjectArray<b3Vector3>& planeEquations, b3AlignedObjectArray<b3Vector3>& verticesOut);
+
+	static bool isInside(const b3AlignedObjectArray<b3Vector3>& vertices, const b3Vector3& planeNormal, b3Scalar margin);
+
+	static bool isPointInsidePlanes(const b3AlignedObjectArray<b3Vector3>& planeEquations, const b3Vector3& point, b3Scalar margin);
+
+	static bool areVerticesBehindPlane(const b3Vector3& planeNormal, const b3AlignedObjectArray<b3Vector3>& vertices, b3Scalar margin);
+};
+
+#endif  //B3_GEOMETRY_UTIL_H
diff --git a/engine/inc/bullet/Bullet3Geometry/b3GrahamScan2dConvexHull.h b/engine/inc/bullet/Bullet3Geometry/b3GrahamScan2dConvexHull.h
new file mode 100644
index 00000000..8881c9a6
--- /dev/null
+++ b/engine/inc/bullet/Bullet3Geometry/b3GrahamScan2dConvexHull.h
@@ -0,0 +1,116 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2011 Advanced Micro Devices, Inc.  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_GRAHAM_SCAN_2D_CONVEX_HULL_H
+#define B3_GRAHAM_SCAN_2D_CONVEX_HULL_H
+
+#include "Bullet3Common/b3Vector3.h"
+#include "Bullet3Common/b3AlignedObjectArray.h"
+
+struct b3GrahamVector3 : public b3Vector3
+{
+	b3GrahamVector3(const b3Vector3& org, int orgIndex)
+		: b3Vector3(org),
+		  m_orgIndex(orgIndex)
+	{
+	}
+	b3Scalar m_angle;
+	int m_orgIndex;
+};
+
+struct b3AngleCompareFunc
+{
+	b3Vector3 m_anchor;
+	b3AngleCompareFunc(const b3Vector3& anchor)
+		: m_anchor(anchor)
+	{
+	}
+	bool operator()(const b3GrahamVector3& a, const b3GrahamVector3& b) const
+	{
+		if (a.m_angle != b.m_angle)
+			return a.m_angle < b.m_angle;
+		else
+		{
+			b3Scalar al = (a - m_anchor).length2();
+			b3Scalar bl = (b - m_anchor).length2();
+			if (al != bl)
+				return al < bl;
+			else
+			{
+				return a.m_orgIndex < b.m_orgIndex;
+			}
+		}
+	}
+};
+
+inline void b3GrahamScanConvexHull2D(b3AlignedObjectArray<b3GrahamVector3>& originalPoints, b3AlignedObjectArray<b3GrahamVector3>& hull, const b3Vector3& normalAxis)
+{
+	b3Vector3 axis0, axis1;
+	b3PlaneSpace1(normalAxis, axis0, axis1);
+
+	if (originalPoints.size() <= 1)
+	{
+		for (int i = 0; i < originalPoints.size(); i++)
+			hull.push_back(originalPoints[0]);
+		return;
+	}
+	//step1 : find anchor point with smallest projection on axis0 and move it to first location
+	for (int i = 0; i < originalPoints.size(); i++)
+	{
+		//		const b3Vector3& left = originalPoints[i];
+		//		const b3Vector3& right = originalPoints[0];
+		b3Scalar projL = originalPoints[i].dot(axis0);
+		b3Scalar projR = originalPoints[0].dot(axis0);
+		if (projL < projR)
+		{
+			originalPoints.swap(0, i);
+		}
+	}
+
+	//also precompute angles
+	originalPoints[0].m_angle = -1e30f;
+	for (int i = 1; i < originalPoints.size(); i++)
+	{
+		b3Vector3 xvec = axis0;
+		b3Vector3 ar = originalPoints[i] - originalPoints[0];
+		originalPoints[i].m_angle = b3Cross(xvec, ar).dot(normalAxis) / ar.length();
+	}
+
+	//step 2: sort all points, based on 'angle' with this anchor
+	b3AngleCompareFunc comp(originalPoints[0]);
+	originalPoints.quickSortInternal(comp, 1, originalPoints.size() - 1);
+
+	int i;
+	for (i = 0; i < 2; i++)
+		hull.push_back(originalPoints[i]);
+
+	//step 3: keep all 'convex' points and discard concave points (using back tracking)
+	for (; i != originalPoints.size(); i++)
+	{
+		bool isConvex = false;
+		while (!isConvex && hull.size() > 1)
+		{
+			b3Vector3& a = hull[hull.size() - 2];
+			b3Vector3& b = hull[hull.size() - 1];
+			isConvex = b3Cross(a - b, a - originalPoints[i]).dot(normalAxis) > 0;
+			if (!isConvex)
+				hull.pop_back();
+			else
+				hull.push_back(originalPoints[i]);
+		}
+	}
+}
+
+#endif  //B3_GRAHAM_SCAN_2D_CONVEX_HULL_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/BroadphaseCollision/b3GpuBroadphaseInterface.h b/engine/inc/bullet/Bullet3OpenCL/BroadphaseCollision/b3GpuBroadphaseInterface.h
new file mode 100644
index 00000000..b2969925
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/BroadphaseCollision/b3GpuBroadphaseInterface.h
@@ -0,0 +1,42 @@
+
+#ifndef B3_GPU_BROADPHASE_INTERFACE_H
+#define B3_GPU_BROADPHASE_INTERFACE_H
+
+#include "Bullet3OpenCL/Initialize/b3OpenCLInclude.h"
+#include "Bullet3Common/b3Vector3.h"
+#include "b3SapAabb.h"
+#include "Bullet3Common/shared/b3Int2.h"
+#include "Bullet3Common/shared/b3Int4.h"
+#include "Bullet3OpenCL/ParallelPrimitives/b3OpenCLArray.h"
+
+class b3GpuBroadphaseInterface
+{
+public:
+	typedef class b3GpuBroadphaseInterface*(CreateFunc)(cl_context ctx, cl_device_id device, cl_command_queue q);
+
+	virtual ~b3GpuBroadphaseInterface()
+	{
+	}
+
+	virtual void createProxy(const b3Vector3& aabbMin, const b3Vector3& aabbMax, int userPtr, int collisionFilterGroup, int collisionFilterMask) = 0;
+	virtual void createLargeProxy(const b3Vector3& aabbMin, const b3Vector3& aabbMax, int userPtr, int collisionFilterGroup, int collisionFilterMask) = 0;
+
+	virtual void calculateOverlappingPairs(int maxPairs) = 0;
+	virtual void calculateOverlappingPairsHost(int maxPairs) = 0;
+
+	//call writeAabbsToGpu after done making all changes (createProxy etc)
+	virtual void writeAabbsToGpu() = 0;
+
+	virtual cl_mem getAabbBufferWS() = 0;
+	virtual int getNumOverlap() = 0;
+	virtual cl_mem getOverlappingPairBuffer() = 0;
+
+	virtual b3OpenCLArray<b3SapAabb>& getAllAabbsGPU() = 0;
+	virtual b3AlignedObjectArray<b3SapAabb>& getAllAabbsCPU() = 0;
+
+	virtual b3OpenCLArray<b3Int4>& getOverlappingPairsGPU() = 0;
+	virtual b3OpenCLArray<int>& getSmallAabbIndicesGPU() = 0;
+	virtual b3OpenCLArray<int>& getLargeAabbIndicesGPU() = 0;
+};
+
+#endif  //B3_GPU_BROADPHASE_INTERFACE_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/BroadphaseCollision/b3GpuGridBroadphase.h b/engine/inc/bullet/Bullet3OpenCL/BroadphaseCollision/b3GpuGridBroadphase.h
new file mode 100644
index 00000000..b76cb43b
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/BroadphaseCollision/b3GpuGridBroadphase.h
@@ -0,0 +1,80 @@
+#ifndef B3_GPU_GRID_BROADPHASE_H
+#define B3_GPU_GRID_BROADPHASE_H
+
+#include "b3GpuBroadphaseInterface.h"
+#include "Bullet3OpenCL/ParallelPrimitives/b3RadixSort32CL.h"
+
+struct b3ParamsGridBroadphaseCL
+{
+	float m_invCellSize[4];
+	int m_gridSize[4];
+
+	int getMaxBodiesPerCell() const
+	{
+		return m_gridSize[3];
+	}
+
+	void setMaxBodiesPerCell(int maxOverlap)
+	{
+		m_gridSize[3] = maxOverlap;
+	}
+};
+
+class b3GpuGridBroadphase : public b3GpuBroadphaseInterface
+{
+protected:
+	cl_context m_context;
+	cl_device_id m_device;
+	cl_command_queue m_queue;
+
+	b3OpenCLArray<b3SapAabb> m_allAabbsGPU1;
+	b3AlignedObjectArray<b3SapAabb> m_allAabbsCPU1;
+
+	b3OpenCLArray<int> m_smallAabbsMappingGPU;
+	b3AlignedObjectArray<int> m_smallAabbsMappingCPU;
+
+	b3OpenCLArray<int> m_largeAabbsMappingGPU;
+	b3AlignedObjectArray<int> m_largeAabbsMappingCPU;
+
+	b3AlignedObjectArray<b3Int4> m_hostPairs;
+	b3OpenCLArray<b3Int4> m_gpuPairs;
+
+	b3OpenCLArray<b3SortData> m_hashGpu;
+	b3OpenCLArray<int> m_cellStartGpu;
+
+	b3ParamsGridBroadphaseCL m_paramsCPU;
+	b3OpenCLArray<b3ParamsGridBroadphaseCL> m_paramsGPU;
+
+	class b3RadixSort32CL* m_sorter;
+
+public:
+	b3GpuGridBroadphase(cl_context ctx, cl_device_id device, cl_command_queue q);
+	virtual ~b3GpuGridBroadphase();
+
+	static b3GpuBroadphaseInterface* CreateFunc(cl_context ctx, cl_device_id device, cl_command_queue q)
+	{
+		return new b3GpuGridBroadphase(ctx, device, q);
+	}
+
+	virtual void createProxy(const b3Vector3& aabbMin, const b3Vector3& aabbMax, int userPtr, int collisionFilterGroup, int collisionFilterMask);
+	virtual void createLargeProxy(const b3Vector3& aabbMin, const b3Vector3& aabbMax, int userPtr, int collisionFilterGroup, int collisionFilterMask);
+
+	virtual void calculateOverlappingPairs(int maxPairs);
+	virtual void calculateOverlappingPairsHost(int maxPairs);
+
+	//call writeAabbsToGpu after done making all changes (createProxy etc)
+	virtual void writeAabbsToGpu();
+
+	virtual cl_mem getAabbBufferWS();
+	virtual int getNumOverlap();
+	virtual cl_mem getOverlappingPairBuffer();
+
+	virtual b3OpenCLArray<b3SapAabb>& getAllAabbsGPU();
+	virtual b3AlignedObjectArray<b3SapAabb>& getAllAabbsCPU();
+
+	virtual b3OpenCLArray<b3Int4>& getOverlappingPairsGPU();
+	virtual b3OpenCLArray<int>& getSmallAabbIndicesGPU();
+	virtual b3OpenCLArray<int>& getLargeAabbIndicesGPU();
+};
+
+#endif  //B3_GPU_GRID_BROADPHASE_H
\ No newline at end of file
diff --git a/engine/inc/bullet/Bullet3OpenCL/BroadphaseCollision/b3GpuParallelLinearBvh.h b/engine/inc/bullet/Bullet3OpenCL/BroadphaseCollision/b3GpuParallelLinearBvh.h
new file mode 100644
index 00000000..b3907751
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/BroadphaseCollision/b3GpuParallelLinearBvh.h
@@ -0,0 +1,125 @@
+/*
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+//Initial Author Jackson Lee, 2014
+
+#ifndef B3_GPU_PARALLEL_LINEAR_BVH_H
+#define B3_GPU_PARALLEL_LINEAR_BVH_H
+
+//#include "Bullet3Collision/BroadPhaseCollision/shared/b3Aabb.h"
+#include "Bullet3OpenCL/BroadphaseCollision/b3SapAabb.h"
+#include "Bullet3Common/shared/b3Int2.h"
+#include "Bullet3Common/shared/b3Int4.h"
+#include "Bullet3Collision/NarrowPhaseCollision/b3RaycastInfo.h"
+
+#include "Bullet3OpenCL/ParallelPrimitives/b3FillCL.h"
+#include "Bullet3OpenCL/ParallelPrimitives/b3RadixSort32CL.h"
+#include "Bullet3OpenCL/ParallelPrimitives/b3PrefixScanCL.h"
+
+#include "Bullet3OpenCL/BroadphaseCollision/kernels/parallelLinearBvhKernels.h"
+
+#define b3Int64 cl_long
+
+///@brief GPU Parallel Linearized Bounding Volume Heirarchy(LBVH) that is reconstructed every frame
+///@remarks
+///See presentation in docs/b3GpuParallelLinearBvh.pdf for algorithm details.
+///@par
+///Related papers: \n
+///"Fast BVH Construction on GPUs" [Lauterbach et al. 2009] \n
+///"Maximizing Parallelism in the Construction of BVHs, Octrees, and k-d trees" [Karras 2012] \n
+///@par
+///The basic algorithm for building the BVH as presented in [Lauterbach et al. 2009] consists of 4 stages:
+/// - [fully parallel] Assign morton codes for each AABB using its center (after quantizing the AABB centers into a virtual grid)
+/// - [fully parallel] Sort morton codes
+/// - [somewhat parallel] Build binary radix tree (assign parent/child pointers for internal nodes of the BVH)
+/// - [somewhat parallel] Set internal node AABBs
+///@par
+///[Karras 2012] improves on the algorithm by introducing fully parallel methods for the last 2 stages.
+///The BVH implementation here shares many concepts with [Karras 2012], but a different method is used for constructing the tree.
+///Instead of searching for the child nodes of each internal node, we search for the parent node of each node.
+///Additionally, a non-atomic traversal that starts from the leaf nodes and moves towards the root node is used to set the AABBs.
+class b3GpuParallelLinearBvh
+{
+	cl_command_queue m_queue;
+
+	cl_program m_parallelLinearBvhProgram;
+
+	cl_kernel m_separateAabbsKernel;
+	cl_kernel m_findAllNodesMergedAabbKernel;
+	cl_kernel m_assignMortonCodesAndAabbIndiciesKernel;
+
+	//Binary radix tree construction kernels
+	cl_kernel m_computeAdjacentPairCommonPrefixKernel;
+	cl_kernel m_buildBinaryRadixTreeLeafNodesKernel;
+	cl_kernel m_buildBinaryRadixTreeInternalNodesKernel;
+	cl_kernel m_findDistanceFromRootKernel;
+	cl_kernel m_buildBinaryRadixTreeAabbsRecursiveKernel;
+
+	cl_kernel m_findLeafIndexRangesKernel;
+
+	//Traversal kernels
+	cl_kernel m_plbvhCalculateOverlappingPairsKernel;
+	cl_kernel m_plbvhRayTraverseKernel;
+	cl_kernel m_plbvhLargeAabbAabbTestKernel;
+	cl_kernel m_plbvhLargeAabbRayTestKernel;
+
+	b3RadixSort32CL m_radixSorter;
+
+	//1 element
+	b3OpenCLArray<int> m_rootNodeIndex;        //Most significant bit(0x80000000) is set to indicate internal node
+	b3OpenCLArray<int> m_maxDistanceFromRoot;  //Max number of internal nodes between an internal node and the root node
+	b3OpenCLArray<int> m_temp;                 //Used to hold the number of pairs in calculateOverlappingPairs()
+
+	//1 element per internal node (number_of_internal_nodes == number_of_leaves - 1)
+	b3OpenCLArray<b3SapAabb> m_internalNodeAabbs;
+	b3OpenCLArray<b3Int2> m_internalNodeLeafIndexRanges;  //x == min leaf index, y == max leaf index
+	b3OpenCLArray<b3Int2> m_internalNodeChildNodes;       //x == left child, y == right child; msb(0x80000000) is set to indicate internal node
+	b3OpenCLArray<int> m_internalNodeParentNodes;         //For parent node index, msb(0x80000000) is not set since it is always internal
+
+	//1 element per internal node; for binary radix tree construction
+	b3OpenCLArray<b3Int64> m_commonPrefixes;
+	b3OpenCLArray<int> m_commonPrefixLengths;
+	b3OpenCLArray<int> m_distanceFromRoot;  //Number of internal nodes between this node and the root
+
+	//1 element per leaf node (leaf nodes only include small AABBs)
+	b3OpenCLArray<int> m_leafNodeParentNodes;                //For parent node index, msb(0x80000000) is not set since it is always internal
+	b3OpenCLArray<b3SortData> m_mortonCodesAndAabbIndicies;  //m_key == morton code, m_value == aabb index in m_leafNodeAabbs
+	b3OpenCLArray<b3SapAabb> m_mergedAabb;                   //m_mergedAabb[0] contains the merged AABB of all leaf nodes
+	b3OpenCLArray<b3SapAabb> m_leafNodeAabbs;                //Contains only small AABBs
+
+	//1 element per large AABB, which is not stored in the BVH
+	b3OpenCLArray<b3SapAabb> m_largeAabbs;
+
+public:
+	b3GpuParallelLinearBvh(cl_context context, cl_device_id device, cl_command_queue queue);
+	virtual ~b3GpuParallelLinearBvh();
+
+	///Must be called before any other function
+	void build(const b3OpenCLArray<b3SapAabb>& worldSpaceAabbs, const b3OpenCLArray<int>& smallAabbIndices,
+			   const b3OpenCLArray<int>& largeAabbIndices);
+
+	///calculateOverlappingPairs() uses the worldSpaceAabbs parameter of b3GpuParallelLinearBvh::build() as the query AABBs.
+	///@param out_overlappingPairs The size() of this array is used to determine the max number of pairs.
+	///If the number of overlapping pairs is < out_overlappingPairs.size(), out_overlappingPairs is resized.
+	void calculateOverlappingPairs(b3OpenCLArray<b3Int4>& out_overlappingPairs);
+
+	///@param out_numRigidRayPairs Array of length 1; contains the number of detected ray-rigid AABB intersections;
+	///this value may be greater than out_rayRigidPairs.size() if out_rayRigidPairs is not large enough.
+	///@param out_rayRigidPairs Contains an array of rays intersecting rigid AABBs; x == ray index, y == rigid body index.
+	///If the size of this array is insufficient to hold all ray-rigid AABB intersections, additional intersections are discarded.
+	void testRaysAgainstBvhAabbs(const b3OpenCLArray<b3RayInfo>& rays,
+								 b3OpenCLArray<int>& out_numRayRigidPairs, b3OpenCLArray<b3Int2>& out_rayRigidPairs);
+
+private:
+	void constructBinaryRadixTree();
+};
+
+#endif
diff --git a/engine/inc/bullet/Bullet3OpenCL/BroadphaseCollision/b3GpuParallelLinearBvhBroadphase.h b/engine/inc/bullet/Bullet3OpenCL/BroadphaseCollision/b3GpuParallelLinearBvhBroadphase.h
new file mode 100644
index 00000000..dda0eea7
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/BroadphaseCollision/b3GpuParallelLinearBvhBroadphase.h
@@ -0,0 +1,66 @@
+/*
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+//Initial Author Jackson Lee, 2014
+
+#ifndef B3_GPU_PARALLEL_LINEAR_BVH_BROADPHASE_H
+#define B3_GPU_PARALLEL_LINEAR_BVH_BROADPHASE_H
+
+#include "Bullet3OpenCL/BroadphaseCollision/b3GpuBroadphaseInterface.h"
+
+#include "b3GpuParallelLinearBvh.h"
+
+class b3GpuParallelLinearBvhBroadphase : public b3GpuBroadphaseInterface
+{
+	b3GpuParallelLinearBvh m_plbvh;
+
+	b3OpenCLArray<b3Int4> m_overlappingPairsGpu;
+
+	b3OpenCLArray<b3SapAabb> m_aabbsGpu;
+	b3OpenCLArray<int> m_smallAabbsMappingGpu;
+	b3OpenCLArray<int> m_largeAabbsMappingGpu;
+
+	b3AlignedObjectArray<b3SapAabb> m_aabbsCpu;
+	b3AlignedObjectArray<int> m_smallAabbsMappingCpu;
+	b3AlignedObjectArray<int> m_largeAabbsMappingCpu;
+
+public:
+	b3GpuParallelLinearBvhBroadphase(cl_context context, cl_device_id device, cl_command_queue queue);
+	virtual ~b3GpuParallelLinearBvhBroadphase() {}
+
+	virtual void createProxy(const b3Vector3& aabbMin, const b3Vector3& aabbMax, int userPtr, int collisionFilterGroup, int collisionFilterMask);
+	virtual void createLargeProxy(const b3Vector3& aabbMin, const b3Vector3& aabbMax, int userPtr, int collisionFilterGroup, int collisionFilterMask);
+
+	virtual void calculateOverlappingPairs(int maxPairs);
+	virtual void calculateOverlappingPairsHost(int maxPairs);
+
+	//call writeAabbsToGpu after done making all changes (createProxy etc)
+	virtual void writeAabbsToGpu();
+
+	virtual int getNumOverlap() { return m_overlappingPairsGpu.size(); }
+	virtual cl_mem getOverlappingPairBuffer() { return m_overlappingPairsGpu.getBufferCL(); }
+
+	virtual cl_mem getAabbBufferWS() { return m_aabbsGpu.getBufferCL(); }
+	virtual b3OpenCLArray<b3SapAabb>& getAllAabbsGPU() { return m_aabbsGpu; }
+
+	virtual b3OpenCLArray<b3Int4>& getOverlappingPairsGPU() { return m_overlappingPairsGpu; }
+	virtual b3OpenCLArray<int>& getSmallAabbIndicesGPU() { return m_smallAabbsMappingGpu; }
+	virtual b3OpenCLArray<int>& getLargeAabbIndicesGPU() { return m_largeAabbsMappingGpu; }
+
+	virtual b3AlignedObjectArray<b3SapAabb>& getAllAabbsCPU() { return m_aabbsCpu; }
+
+	static b3GpuBroadphaseInterface* CreateFunc(cl_context context, cl_device_id device, cl_command_queue queue)
+	{
+		return new b3GpuParallelLinearBvhBroadphase(context, device, queue);
+	}
+};
+
+#endif
diff --git a/engine/inc/bullet/Bullet3OpenCL/BroadphaseCollision/b3GpuSapBroadphase.h b/engine/inc/bullet/Bullet3OpenCL/BroadphaseCollision/b3GpuSapBroadphase.h
new file mode 100644
index 00000000..d17590b1
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/BroadphaseCollision/b3GpuSapBroadphase.h
@@ -0,0 +1,143 @@
+#ifndef B3_GPU_SAP_BROADPHASE_H
+#define B3_GPU_SAP_BROADPHASE_H
+
+#include "Bullet3OpenCL/ParallelPrimitives/b3OpenCLArray.h"
+#include "Bullet3OpenCL/ParallelPrimitives/b3FillCL.h"  //b3Int2
+class b3Vector3;
+#include "Bullet3OpenCL/ParallelPrimitives/b3RadixSort32CL.h"
+
+#include "b3SapAabb.h"
+#include "Bullet3Common/shared/b3Int2.h"
+
+#include "b3GpuBroadphaseInterface.h"
+
+class b3GpuSapBroadphase : public b3GpuBroadphaseInterface
+{
+	cl_context m_context;
+	cl_device_id m_device;
+	cl_command_queue m_queue;
+	cl_kernel m_flipFloatKernel;
+	cl_kernel m_scatterKernel;
+	cl_kernel m_copyAabbsKernel;
+	cl_kernel m_sapKernel;
+	cl_kernel m_sap2Kernel;
+	cl_kernel m_prepareSumVarianceKernel;
+
+	class b3RadixSort32CL* m_sorter;
+
+	///test for 3d SAP
+	b3AlignedObjectArray<b3SortData> m_sortedAxisCPU[3][2];
+	b3AlignedObjectArray<b3UnsignedInt2> m_objectMinMaxIndexCPU[3][2];
+	b3OpenCLArray<b3UnsignedInt2> m_objectMinMaxIndexGPUaxis0;
+	b3OpenCLArray<b3UnsignedInt2> m_objectMinMaxIndexGPUaxis1;
+	b3OpenCLArray<b3UnsignedInt2> m_objectMinMaxIndexGPUaxis2;
+	b3OpenCLArray<b3UnsignedInt2> m_objectMinMaxIndexGPUaxis0prev;
+	b3OpenCLArray<b3UnsignedInt2> m_objectMinMaxIndexGPUaxis1prev;
+	b3OpenCLArray<b3UnsignedInt2> m_objectMinMaxIndexGPUaxis2prev;
+
+	b3OpenCLArray<b3SortData> m_sortedAxisGPU0;
+	b3OpenCLArray<b3SortData> m_sortedAxisGPU1;
+	b3OpenCLArray<b3SortData> m_sortedAxisGPU2;
+	b3OpenCLArray<b3SortData> m_sortedAxisGPU0prev;
+	b3OpenCLArray<b3SortData> m_sortedAxisGPU1prev;
+	b3OpenCLArray<b3SortData> m_sortedAxisGPU2prev;
+
+	b3OpenCLArray<b3Int4> m_addedHostPairsGPU;
+	b3OpenCLArray<b3Int4> m_removedHostPairsGPU;
+	b3OpenCLArray<int> m_addedCountGPU;
+	b3OpenCLArray<int> m_removedCountGPU;
+
+	int m_currentBuffer;
+
+public:
+	b3OpenCLArray<int> m_pairCount;
+
+	b3OpenCLArray<b3SapAabb> m_allAabbsGPU;
+	b3AlignedObjectArray<b3SapAabb> m_allAabbsCPU;
+
+	virtual b3OpenCLArray<b3SapAabb>& getAllAabbsGPU()
+	{
+		return m_allAabbsGPU;
+	}
+	virtual b3AlignedObjectArray<b3SapAabb>& getAllAabbsCPU()
+	{
+		return m_allAabbsCPU;
+	}
+
+	b3OpenCLArray<b3Vector3> m_sum;
+	b3OpenCLArray<b3Vector3> m_sum2;
+	b3OpenCLArray<b3Vector3> m_dst;
+
+	b3OpenCLArray<int> m_smallAabbsMappingGPU;
+	b3AlignedObjectArray<int> m_smallAabbsMappingCPU;
+
+	b3OpenCLArray<int> m_largeAabbsMappingGPU;
+	b3AlignedObjectArray<int> m_largeAabbsMappingCPU;
+
+	b3OpenCLArray<b3Int4> m_overlappingPairs;
+
+	//temporary gpu work memory
+	b3OpenCLArray<b3SortData> m_gpuSmallSortData;
+	b3OpenCLArray<b3SapAabb> m_gpuSmallSortedAabbs;
+
+	class b3PrefixScanFloat4CL* m_prefixScanFloat4;
+
+	enum b3GpuSapKernelType
+	{
+		B3_GPU_SAP_KERNEL_BRUTE_FORCE_CPU = 1,
+		B3_GPU_SAP_KERNEL_BRUTE_FORCE_GPU,
+		B3_GPU_SAP_KERNEL_ORIGINAL,
+		B3_GPU_SAP_KERNEL_BARRIER,
+		B3_GPU_SAP_KERNEL_LOCAL_SHARED_MEMORY
+	};
+
+	b3GpuSapBroadphase(cl_context ctx, cl_device_id device, cl_command_queue q, b3GpuSapKernelType kernelType = B3_GPU_SAP_KERNEL_LOCAL_SHARED_MEMORY);
+	virtual ~b3GpuSapBroadphase();
+
+	static b3GpuBroadphaseInterface* CreateFuncBruteForceCpu(cl_context ctx, cl_device_id device, cl_command_queue q)
+	{
+		return new b3GpuSapBroadphase(ctx, device, q, B3_GPU_SAP_KERNEL_BRUTE_FORCE_CPU);
+	}
+
+	static b3GpuBroadphaseInterface* CreateFuncBruteForceGpu(cl_context ctx, cl_device_id device, cl_command_queue q)
+	{
+		return new b3GpuSapBroadphase(ctx, device, q, B3_GPU_SAP_KERNEL_BRUTE_FORCE_GPU);
+	}
+
+	static b3GpuBroadphaseInterface* CreateFuncOriginal(cl_context ctx, cl_device_id device, cl_command_queue q)
+	{
+		return new b3GpuSapBroadphase(ctx, device, q, B3_GPU_SAP_KERNEL_ORIGINAL);
+	}
+	static b3GpuBroadphaseInterface* CreateFuncBarrier(cl_context ctx, cl_device_id device, cl_command_queue q)
+	{
+		return new b3GpuSapBroadphase(ctx, device, q, B3_GPU_SAP_KERNEL_BARRIER);
+	}
+	static b3GpuBroadphaseInterface* CreateFuncLocalMemory(cl_context ctx, cl_device_id device, cl_command_queue q)
+	{
+		return new b3GpuSapBroadphase(ctx, device, q, B3_GPU_SAP_KERNEL_LOCAL_SHARED_MEMORY);
+	}
+
+	virtual void calculateOverlappingPairs(int maxPairs);
+	virtual void calculateOverlappingPairsHost(int maxPairs);
+
+	void reset();
+
+	void init3dSap();
+	virtual void calculateOverlappingPairsHostIncremental3Sap();
+
+	virtual void createProxy(const b3Vector3& aabbMin, const b3Vector3& aabbMax, int userPtr, int collisionFilterGroup, int collisionFilterMask);
+	virtual void createLargeProxy(const b3Vector3& aabbMin, const b3Vector3& aabbMax, int userPtr, int collisionFilterGroup, int collisionFilterMask);
+
+	//call writeAabbsToGpu after done making all changes (createProxy etc)
+	virtual void writeAabbsToGpu();
+
+	virtual cl_mem getAabbBufferWS();
+	virtual int getNumOverlap();
+	virtual cl_mem getOverlappingPairBuffer();
+
+	virtual b3OpenCLArray<b3Int4>& getOverlappingPairsGPU();
+	virtual b3OpenCLArray<int>& getSmallAabbIndicesGPU();
+	virtual b3OpenCLArray<int>& getLargeAabbIndicesGPU();
+};
+
+#endif  //B3_GPU_SAP_BROADPHASE_H
\ No newline at end of file
diff --git a/engine/inc/bullet/Bullet3OpenCL/BroadphaseCollision/b3SapAabb.h b/engine/inc/bullet/Bullet3OpenCL/BroadphaseCollision/b3SapAabb.h
new file mode 100644
index 00000000..60570f26
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/BroadphaseCollision/b3SapAabb.h
@@ -0,0 +1,13 @@
+#ifndef B3_SAP_AABB_H
+#define B3_SAP_AABB_H
+
+#include "Bullet3Common/b3Scalar.h"
+#include "Bullet3Collision/BroadPhaseCollision/shared/b3Aabb.h"
+
+///just make sure that the b3Aabb is 16-byte aligned
+B3_ATTRIBUTE_ALIGNED16(struct)
+b3SapAabb : public b3Aabb{
+
+			};
+
+#endif  //B3_SAP_AABB_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/BroadphaseCollision/kernels/gridBroadphaseKernels.h b/engine/inc/bullet/Bullet3OpenCL/BroadphaseCollision/kernels/gridBroadphaseKernels.h
new file mode 100644
index 00000000..01854177
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/BroadphaseCollision/kernels/gridBroadphaseKernels.h
@@ -0,0 +1,198 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* gridBroadphaseCL =
+	"int getPosHash(int4 gridPos, __global float4* pParams)\n"
+	"{\n"
+	"	int4 gridDim = *((__global int4*)(pParams + 1));\n"
+	"	gridPos.x &= gridDim.x - 1;\n"
+	"	gridPos.y &= gridDim.y - 1;\n"
+	"	gridPos.z &= gridDim.z - 1;\n"
+	"	int hash = gridPos.z * gridDim.y * gridDim.x + gridPos.y * gridDim.x + gridPos.x;\n"
+	"	return hash;\n"
+	"} \n"
+	"int4 getGridPos(float4 worldPos, __global float4* pParams)\n"
+	"{\n"
+	"    int4 gridPos;\n"
+	"	int4 gridDim = *((__global int4*)(pParams + 1));\n"
+	"    gridPos.x = (int)floor(worldPos.x * pParams[0].x) & (gridDim.x - 1);\n"
+	"    gridPos.y = (int)floor(worldPos.y * pParams[0].y) & (gridDim.y - 1);\n"
+	"    gridPos.z = (int)floor(worldPos.z * pParams[0].z) & (gridDim.z - 1);\n"
+	"    return gridPos;\n"
+	"}\n"
+	"// calculate grid hash value for each body using its AABB\n"
+	"__kernel void kCalcHashAABB(int numObjects, __global float4* allpAABB, __global const int* smallAabbMapping, __global int2* pHash, __global float4* pParams )\n"
+	"{\n"
+	"    int index = get_global_id(0);\n"
+	"    if(index >= numObjects)\n"
+	"	{\n"
+	"		return;\n"
+	"	}\n"
+	"	float4 bbMin = allpAABB[smallAabbMapping[index]*2];\n"
+	"	float4 bbMax = allpAABB[smallAabbMapping[index]*2 + 1];\n"
+	"	float4 pos;\n"
+	"	pos.x = (bbMin.x + bbMax.x) * 0.5f;\n"
+	"	pos.y = (bbMin.y + bbMax.y) * 0.5f;\n"
+	"	pos.z = (bbMin.z + bbMax.z) * 0.5f;\n"
+	"	pos.w = 0.f;\n"
+	"    // get address in grid\n"
+	"    int4 gridPos = getGridPos(pos, pParams);\n"
+	"    int gridHash = getPosHash(gridPos, pParams);\n"
+	"    // store grid hash and body index\n"
+	"    int2 hashVal;\n"
+	"    hashVal.x = gridHash;\n"
+	"    hashVal.y = index;\n"
+	"    pHash[index] = hashVal;\n"
+	"}\n"
+	"__kernel void kClearCellStart(	int numCells, \n"
+	"								__global int* pCellStart )\n"
+	"{\n"
+	"    int index = get_global_id(0);\n"
+	"    if(index >= numCells)\n"
+	"	{\n"
+	"		return;\n"
+	"	}\n"
+	"	pCellStart[index] = -1;\n"
+	"}\n"
+	"__kernel void kFindCellStart(int numObjects, __global int2* pHash, __global int* cellStart )\n"
+	"{\n"
+	"	__local int sharedHash[513];\n"
+	"    int index = get_global_id(0);\n"
+	"	int2 sortedData;\n"
+	"    if(index < numObjects)\n"
+	"	{\n"
+	"		sortedData = pHash[index];\n"
+	"		// Load hash data into shared memory so that we can look \n"
+	"		// at neighboring body's hash value without loading\n"
+	"		// two hash values per thread\n"
+	"		sharedHash[get_local_id(0) + 1] = sortedData.x;\n"
+	"		if((index > 0) && (get_local_id(0) == 0))\n"
+	"		{\n"
+	"			// first thread in block must load neighbor body hash\n"
+	"			sharedHash[0] = pHash[index-1].x;\n"
+	"		}\n"
+	"	}\n"
+	"    barrier(CLK_LOCAL_MEM_FENCE);\n"
+	"    if(index < numObjects)\n"
+	"	{\n"
+	"		if((index == 0) || (sortedData.x != sharedHash[get_local_id(0)]))\n"
+	"		{\n"
+	"			cellStart[sortedData.x] = index;\n"
+	"		}\n"
+	"	}\n"
+	"}\n"
+	"int testAABBOverlap(float4 min0, float4 max0, float4 min1, float4 max1)\n"
+	"{\n"
+	"	return	(min0.x <= max1.x)&& (min1.x <= max0.x) && \n"
+	"			(min0.y <= max1.y)&& (min1.y <= max0.y) && \n"
+	"			(min0.z <= max1.z)&& (min1.z <= max0.z); \n"
+	"}\n"
+	"//search for AABB 'index' against other AABBs' in this cell\n"
+	"void findPairsInCell(	int numObjects,\n"
+	"						int4	gridPos,\n"
+	"						int    index,\n"
+	"						__global int2*  pHash,\n"
+	"						__global int*   pCellStart,\n"
+	"						__global float4* allpAABB, \n"
+	"						__global const int* smallAabbMapping,\n"
+	"						__global float4* pParams,\n"
+	"							volatile  __global int* pairCount,\n"
+	"						__global int4*   pPairBuff2,\n"
+	"						int maxPairs\n"
+	"						)\n"
+	"{\n"
+	"	int4 pGridDim = *((__global int4*)(pParams + 1));\n"
+	"	int maxBodiesPerCell = pGridDim.w;\n"
+	"    int gridHash = getPosHash(gridPos, pParams);\n"
+	"    // get start of bucket for this cell\n"
+	"    int bucketStart = pCellStart[gridHash];\n"
+	"    if (bucketStart == -1)\n"
+	"	{\n"
+	"        return;   // cell empty\n"
+	"	}\n"
+	"	// iterate over bodies in this cell\n"
+	"    int2 sortedData = pHash[index];\n"
+	"	int unsorted_indx = sortedData.y;\n"
+	"    float4 min0 = allpAABB[smallAabbMapping[unsorted_indx]*2 + 0]; \n"
+	"	float4 max0 = allpAABB[smallAabbMapping[unsorted_indx]*2 + 1];\n"
+	"	int handleIndex =  as_int(min0.w);\n"
+	"	\n"
+	"	int bucketEnd = bucketStart + maxBodiesPerCell;\n"
+	"	bucketEnd = (bucketEnd > numObjects) ? numObjects : bucketEnd;\n"
+	"	for(int index2 = bucketStart; index2 < bucketEnd; index2++) \n"
+	"	{\n"
+	"        int2 cellData = pHash[index2];\n"
+	"        if (cellData.x != gridHash)\n"
+	"        {\n"
+	"			break;   // no longer in same bucket\n"
+	"		}\n"
+	"		int unsorted_indx2 = cellData.y;\n"
+	"        //if (unsorted_indx2 < unsorted_indx) // check not colliding with self\n"
+	"		if (unsorted_indx2 != unsorted_indx) // check not colliding with self\n"
+	"        {   \n"
+	"			float4 min1 = allpAABB[smallAabbMapping[unsorted_indx2]*2 + 0];\n"
+	"			float4 max1 = allpAABB[smallAabbMapping[unsorted_indx2]*2 + 1];\n"
+	"			if(testAABBOverlap(min0, max0, min1, max1))\n"
+	"			{\n"
+	"				if (pairCount)\n"
+	"				{\n"
+	"					int handleIndex2 = as_int(min1.w);\n"
+	"					if (handleIndex<handleIndex2)\n"
+	"					{\n"
+	"						int curPair = atomic_add(pairCount,1);\n"
+	"						if (curPair<maxPairs)\n"
+	"						{\n"
+	"							int4 newpair;\n"
+	"							newpair.x = handleIndex;\n"
+	"							newpair.y = handleIndex2;\n"
+	"							newpair.z = -1;\n"
+	"							newpair.w = -1;\n"
+	"							pPairBuff2[curPair] = newpair;\n"
+	"						}\n"
+	"					}\n"
+	"				\n"
+	"				}\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"}\n"
+	"__kernel void kFindOverlappingPairs(	int numObjects,\n"
+	"										__global float4* allpAABB, \n"
+	"										__global const int* smallAabbMapping,\n"
+	"										__global int2* pHash, \n"
+	"										__global int* pCellStart, \n"
+	"										__global float4* pParams ,\n"
+	"										volatile  __global int* pairCount,\n"
+	"										__global int4*   pPairBuff2,\n"
+	"										int maxPairs\n"
+	"										)\n"
+	"{\n"
+	"    int index = get_global_id(0);\n"
+	"    if(index >= numObjects)\n"
+	"	{\n"
+	"		return;\n"
+	"	}\n"
+	"    int2 sortedData = pHash[index];\n"
+	"	int unsorted_indx = sortedData.y;\n"
+	"	float4 bbMin = allpAABB[smallAabbMapping[unsorted_indx]*2 + 0];\n"
+	"	float4 bbMax = allpAABB[smallAabbMapping[unsorted_indx]*2 + 1];\n"
+	"	float4 pos;\n"
+	"	pos.x = (bbMin.x + bbMax.x) * 0.5f;\n"
+	"	pos.y = (bbMin.y + bbMax.y) * 0.5f;\n"
+	"	pos.z = (bbMin.z + bbMax.z) * 0.5f;\n"
+	"    // get address in grid\n"
+	"    int4 gridPosA = getGridPos(pos, pParams);\n"
+	"    int4 gridPosB; \n"
+	"    // examine only neighbouring cells\n"
+	"    for(int z=-1; z<=1; z++) \n"
+	"    {\n"
+	"		gridPosB.z = gridPosA.z + z;\n"
+	"        for(int y=-1; y<=1; y++) \n"
+	"        {\n"
+	"			gridPosB.y = gridPosA.y + y;\n"
+	"            for(int x=-1; x<=1; x++) \n"
+	"            {\n"
+	"				gridPosB.x = gridPosA.x + x;\n"
+	"                findPairsInCell(numObjects, gridPosB, index, pHash, pCellStart, allpAABB,smallAabbMapping, pParams, pairCount,pPairBuff2, maxPairs);\n"
+	"            }\n"
+	"        }\n"
+	"    }\n"
+	"}\n";
diff --git a/engine/inc/bullet/Bullet3OpenCL/BroadphaseCollision/kernels/parallelLinearBvhKernels.h b/engine/inc/bullet/Bullet3OpenCL/BroadphaseCollision/kernels/parallelLinearBvhKernels.h
new file mode 100644
index 00000000..c02877dd
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/BroadphaseCollision/kernels/parallelLinearBvhKernels.h
@@ -0,0 +1,728 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* parallelLinearBvhCL =
+	"/*\n"
+	"This software is provided 'as-is', without any express or implied warranty.\n"
+	"In no event will the authors be held liable for any damages arising from the use of this software.\n"
+	"Permission is granted to anyone to use this software for any purpose,\n"
+	"including commercial applications, and to alter it and redistribute it freely,\n"
+	"subject to the following restrictions:\n"
+	"1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.\n"
+	"2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.\n"
+	"3. This notice may not be removed or altered from any source distribution.\n"
+	"*/\n"
+	"//Initial Author Jackson Lee, 2014\n"
+	"typedef float b3Scalar;\n"
+	"typedef float4 b3Vector3;\n"
+	"#define b3Max max\n"
+	"#define b3Min min\n"
+	"#define b3Sqrt sqrt\n"
+	"typedef struct\n"
+	"{\n"
+	"	unsigned int m_key;\n"
+	"	unsigned int m_value;\n"
+	"} SortDataCL;\n"
+	"typedef struct \n"
+	"{\n"
+	"	union\n"
+	"	{\n"
+	"		float4	m_min;\n"
+	"		float   m_minElems[4];\n"
+	"		int			m_minIndices[4];\n"
+	"	};\n"
+	"	union\n"
+	"	{\n"
+	"		float4	m_max;\n"
+	"		float   m_maxElems[4];\n"
+	"		int			m_maxIndices[4];\n"
+	"	};\n"
+	"} b3AabbCL;\n"
+	"unsigned int interleaveBits(unsigned int x)\n"
+	"{\n"
+	"	//........ ........ ......12 3456789A	//x\n"
+	"	//....1..2 ..3..4.. 5..6..7. .8..9..A	//x after interleaving bits\n"
+	"	\n"
+	"	//......12 3456789A ......12 3456789A	//x ^ (x << 16)\n"
+	"	//11111111 ........ ........ 11111111	//0x FF 00 00 FF\n"
+	"	//......12 ........ ........ 3456789A	//x = (x ^ (x << 16)) & 0xFF0000FF;\n"
+	"	\n"
+	"	//......12 ........ 3456789A 3456789A	//x ^ (x <<  8)\n"
+	"	//......11 ........ 1111.... ....1111	//0x 03 00 F0 0F\n"
+	"	//......12 ........ 3456.... ....789A	//x = (x ^ (x <<  8)) & 0x0300F00F;\n"
+	"	\n"
+	"	//..12..12 ....3456 3456.... 789A789A	//x ^ (x <<  4)\n"
+	"	//......11 ....11.. ..11.... 11....11	//0x 03 0C 30 C3\n"
+	"	//......12 ....34.. ..56.... 78....9A	//x = (x ^ (x <<  4)) & 0x030C30C3;\n"
+	"	\n"
+	"	//....1212 ..3434.. 5656..78 78..9A9A	//x ^ (x <<  2)\n"
+	"	//....1..1 ..1..1.. 1..1..1. .1..1..1	//0x 09 24 92 49\n"
+	"	//....1..2 ..3..4.. 5..6..7. .8..9..A	//x = (x ^ (x <<  2)) & 0x09249249;\n"
+	"	\n"
+	"	//........ ........ ......11 11111111	//0x000003FF\n"
+	"	x &= 0x000003FF;		//Clear all bits above bit 10\n"
+	"	\n"
+	"	x = (x ^ (x << 16)) & 0xFF0000FF;\n"
+	"	x = (x ^ (x <<  8)) & 0x0300F00F;\n"
+	"	x = (x ^ (x <<  4)) & 0x030C30C3;\n"
+	"	x = (x ^ (x <<  2)) & 0x09249249;\n"
+	"	\n"
+	"	return x;\n"
+	"}\n"
+	"unsigned int getMortonCode(unsigned int x, unsigned int y, unsigned int z)\n"
+	"{\n"
+	"	return interleaveBits(x) << 0 | interleaveBits(y) << 1 | interleaveBits(z) << 2;\n"
+	"}\n"
+	"__kernel void separateAabbs(__global b3AabbCL* unseparatedAabbs, __global int* aabbIndices, __global b3AabbCL* out_aabbs, int numAabbsToSeparate)\n"
+	"{\n"
+	"	int separatedAabbIndex = get_global_id(0);\n"
+	"	if(separatedAabbIndex >= numAabbsToSeparate) return;\n"
+	"	int unseparatedAabbIndex = aabbIndices[separatedAabbIndex];\n"
+	"	out_aabbs[separatedAabbIndex] = unseparatedAabbs[unseparatedAabbIndex];\n"
+	"}\n"
+	"//Should replace with an optimized parallel reduction\n"
+	"__kernel void findAllNodesMergedAabb(__global b3AabbCL* out_mergedAabb, int numAabbsNeedingMerge)\n"
+	"{\n"
+	"	//Each time this kernel is added to the command queue, \n"
+	"	//the number of AABBs needing to be merged is halved\n"
+	"	//\n"
+	"	//Example with 159 AABBs:\n"
+	"	//	numRemainingAabbs == 159 / 2 + 159 % 2 == 80\n"
+	"	//	numMergedAabbs == 159 - 80 == 79\n"
+	"	//So, indices [0, 78] are merged with [0 + 80, 78 + 80]\n"
+	"	\n"
+	"	int numRemainingAabbs = numAabbsNeedingMerge / 2 + numAabbsNeedingMerge % 2;\n"
+	"	int numMergedAabbs = numAabbsNeedingMerge - numRemainingAabbs;\n"
+	"	\n"
+	"	int aabbIndex = get_global_id(0);\n"
+	"	if(aabbIndex >= numMergedAabbs) return;\n"
+	"	\n"
+	"	int otherAabbIndex = aabbIndex + numRemainingAabbs;\n"
+	"	\n"
+	"	b3AabbCL aabb = out_mergedAabb[aabbIndex];\n"
+	"	b3AabbCL otherAabb = out_mergedAabb[otherAabbIndex];\n"
+	"		\n"
+	"	b3AabbCL mergedAabb;\n"
+	"	mergedAabb.m_min = b3Min(aabb.m_min, otherAabb.m_min);\n"
+	"	mergedAabb.m_max = b3Max(aabb.m_max, otherAabb.m_max);\n"
+	"	out_mergedAabb[aabbIndex] = mergedAabb;\n"
+	"}\n"
+	"__kernel void assignMortonCodesAndAabbIndicies(__global b3AabbCL* worldSpaceAabbs, __global b3AabbCL* mergedAabbOfAllNodes, \n"
+	"												__global SortDataCL* out_mortonCodesAndAabbIndices, int numAabbs)\n"
+	"{\n"
+	"	int leafNodeIndex = get_global_id(0);	//Leaf node index == AABB index\n"
+	"	if(leafNodeIndex >= numAabbs) return;\n"
+	"	\n"
+	"	b3AabbCL mergedAabb = mergedAabbOfAllNodes[0];\n"
+	"	b3Vector3 gridCenter = (mergedAabb.m_min + mergedAabb.m_max) * 0.5f;\n"
+	"	b3Vector3 gridCellSize = (mergedAabb.m_max - mergedAabb.m_min) / (float)1024;\n"
+	"	\n"
+	"	b3AabbCL aabb = worldSpaceAabbs[leafNodeIndex];\n"
+	"	b3Vector3 aabbCenter = (aabb.m_min + aabb.m_max) * 0.5f;\n"
+	"	b3Vector3 aabbCenterRelativeToGrid = aabbCenter - gridCenter;\n"
+	"	\n"
+	"	//Quantize into integer coordinates\n"
+	"	//floor() is needed to prevent the center cell, at (0,0,0) from being twice the size\n"
+	"	b3Vector3 gridPosition = aabbCenterRelativeToGrid / gridCellSize;\n"
+	"	\n"
+	"	int4 discretePosition;\n"
+	"	discretePosition.x = (int)( (gridPosition.x >= 0.0f) ? gridPosition.x : floor(gridPosition.x) );\n"
+	"	discretePosition.y = (int)( (gridPosition.y >= 0.0f) ? gridPosition.y : floor(gridPosition.y) );\n"
+	"	discretePosition.z = (int)( (gridPosition.z >= 0.0f) ? gridPosition.z : floor(gridPosition.z) );\n"
+	"	\n"
+	"	//Clamp coordinates into [-512, 511], then convert range from [-512, 511] to [0, 1023]\n"
+	"	discretePosition = b3Max( -512, b3Min(discretePosition, 511) );\n"
+	"	discretePosition += 512;\n"
+	"	\n"
+	"	//Interleave bits(assign a morton code, also known as a z-curve)\n"
+	"	unsigned int mortonCode = getMortonCode(discretePosition.x, discretePosition.y, discretePosition.z);\n"
+	"	\n"
+	"	//\n"
+	"	SortDataCL mortonCodeIndexPair;\n"
+	"	mortonCodeIndexPair.m_key = mortonCode;\n"
+	"	mortonCodeIndexPair.m_value = leafNodeIndex;\n"
+	"	\n"
+	"	out_mortonCodesAndAabbIndices[leafNodeIndex] = mortonCodeIndexPair;\n"
+	"}\n"
+	"#define B3_PLVBH_TRAVERSE_MAX_STACK_SIZE 128\n"
+	"//The most significant bit(0x80000000) of a int32 is used to distinguish between leaf and internal nodes.\n"
+	"//If it is set, then the index is for an internal node; otherwise, it is a leaf node. \n"
+	"//In both cases, the bit should be cleared to access the actual node index.\n"
+	"int isLeafNode(int index) { return (index >> 31 == 0); }\n"
+	"int getIndexWithInternalNodeMarkerRemoved(int index) { return index & (~0x80000000); }\n"
+	"int getIndexWithInternalNodeMarkerSet(int isLeaf, int index) { return (isLeaf) ? index : (index | 0x80000000); }\n"
+	"//From sap.cl\n"
+	"#define NEW_PAIR_MARKER -1\n"
+	"bool TestAabbAgainstAabb2(const b3AabbCL* aabb1, const b3AabbCL* aabb2)\n"
+	"{\n"
+	"	bool overlap = true;\n"
+	"	overlap = (aabb1->m_min.x > aabb2->m_max.x || aabb1->m_max.x < aabb2->m_min.x) ? false : overlap;\n"
+	"	overlap = (aabb1->m_min.z > aabb2->m_max.z || aabb1->m_max.z < aabb2->m_min.z) ? false : overlap;\n"
+	"	overlap = (aabb1->m_min.y > aabb2->m_max.y || aabb1->m_max.y < aabb2->m_min.y) ? false : overlap;\n"
+	"	return overlap;\n"
+	"}\n"
+	"//From sap.cl\n"
+	"__kernel void plbvhCalculateOverlappingPairs(__global b3AabbCL* rigidAabbs, \n"
+	"											__global int* rootNodeIndex, \n"
+	"											__global int2* internalNodeChildIndices, \n"
+	"											__global b3AabbCL* internalNodeAabbs,\n"
+	"											__global int2* internalNodeLeafIndexRanges,\n"
+	"											\n"
+	"											__global SortDataCL* mortonCodesAndAabbIndices,\n"
+	"											__global int* out_numPairs, __global int4* out_overlappingPairs, \n"
+	"											int maxPairs, int numQueryAabbs)\n"
+	"{\n"
+	"	//Using get_group_id()/get_local_id() is Faster than get_global_id(0) since\n"
+	"	//mortonCodesAndAabbIndices[] contains rigid body indices sorted along the z-curve (more spatially coherent)\n"
+	"	int queryBvhNodeIndex = get_group_id(0) * get_local_size(0) + get_local_id(0);\n"
+	"	if(queryBvhNodeIndex >= numQueryAabbs) return;\n"
+	"	\n"
+	"	int queryRigidIndex = mortonCodesAndAabbIndices[queryBvhNodeIndex].m_value;\n"
+	"	b3AabbCL queryAabb = rigidAabbs[queryRigidIndex];\n"
+	"	\n"
+	"	int stack[B3_PLVBH_TRAVERSE_MAX_STACK_SIZE];\n"
+	"	\n"
+	"	int stackSize = 1;\n"
+	"	stack[0] = *rootNodeIndex;\n"
+	"	\n"
+	"	while(stackSize)\n"
+	"	{\n"
+	"		int internalOrLeafNodeIndex = stack[ stackSize - 1 ];\n"
+	"		--stackSize;\n"
+	"		\n"
+	"		int isLeaf = isLeafNode(internalOrLeafNodeIndex);	//Internal node if false\n"
+	"		int bvhNodeIndex = getIndexWithInternalNodeMarkerRemoved(internalOrLeafNodeIndex);\n"
+	"		\n"
+	"		//Optimization - if the BVH is structured as a binary radix tree, then\n"
+	"		//each internal node corresponds to a contiguous range of leaf nodes(internalNodeLeafIndexRanges[]).\n"
+	"		//This can be used to avoid testing each AABB-AABB pair twice, including preventing each node from colliding with itself.\n"
+	"		{\n"
+	"			int highestLeafIndex = (isLeaf) ? bvhNodeIndex : internalNodeLeafIndexRanges[bvhNodeIndex].y;\n"
+	"			if(highestLeafIndex <= queryBvhNodeIndex) continue;\n"
+	"		}\n"
+	"		\n"
+	"		//bvhRigidIndex is not used if internal node\n"
+	"		int bvhRigidIndex = (isLeaf) ? mortonCodesAndAabbIndices[bvhNodeIndex].m_value : -1;\n"
+	"	\n"
+	"		b3AabbCL bvhNodeAabb = (isLeaf) ? rigidAabbs[bvhRigidIndex] : internalNodeAabbs[bvhNodeIndex];\n"
+	"		if( TestAabbAgainstAabb2(&queryAabb, &bvhNodeAabb) )\n"
+	"		{\n"
+	"			if(isLeaf)\n"
+	"			{\n"
+	"				int4 pair;\n"
+	"				pair.x = rigidAabbs[queryRigidIndex].m_minIndices[3];\n"
+	"				pair.y = rigidAabbs[bvhRigidIndex].m_minIndices[3];\n"
+	"				pair.z = NEW_PAIR_MARKER;\n"
+	"				pair.w = NEW_PAIR_MARKER;\n"
+	"				\n"
+	"				int pairIndex = atomic_inc(out_numPairs);\n"
+	"				if(pairIndex < maxPairs) out_overlappingPairs[pairIndex] = pair;\n"
+	"			}\n"
+	"			\n"
+	"			if(!isLeaf)	//Internal node\n"
+	"			{\n"
+	"				if(stackSize + 2 > B3_PLVBH_TRAVERSE_MAX_STACK_SIZE)\n"
+	"				{\n"
+	"					//Error\n"
+	"				}\n"
+	"				else\n"
+	"				{\n"
+	"					stack[ stackSize++ ] = internalNodeChildIndices[bvhNodeIndex].x;\n"
+	"					stack[ stackSize++ ] = internalNodeChildIndices[bvhNodeIndex].y;\n"
+	"				}\n"
+	"			}\n"
+	"		}\n"
+	"		\n"
+	"	}\n"
+	"}\n"
+	"//From rayCastKernels.cl\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4 m_from;\n"
+	"	float4 m_to;\n"
+	"} b3RayInfo;\n"
+	"//From rayCastKernels.cl\n"
+	"b3Vector3 b3Vector3_normalize(b3Vector3 v)\n"
+	"{\n"
+	"	b3Vector3 normal = (b3Vector3){v.x, v.y, v.z, 0.f};\n"
+	"	return normalize(normal);	//OpenCL normalize == vector4 normalize\n"
+	"}\n"
+	"b3Scalar b3Vector3_length2(b3Vector3 v) { return v.x*v.x + v.y*v.y + v.z*v.z; }\n"
+	"b3Scalar b3Vector3_dot(b3Vector3 a, b3Vector3 b) { return a.x*b.x + a.y*b.y + a.z*b.z; }\n"
+	"int rayIntersectsAabb(b3Vector3 rayOrigin, b3Scalar rayLength, b3Vector3 rayNormalizedDirection, b3AabbCL aabb)\n"
+	"{\n"
+	"	//AABB is considered as 3 pairs of 2 planes( {x_min, x_max}, {y_min, y_max}, {z_min, z_max} ).\n"
+	"	//t_min is the point of intersection with the closer plane, t_max is the point of intersection with the farther plane.\n"
+	"	//\n"
+	"	//if (rayNormalizedDirection.x < 0.0f), then max.x will be the near plane \n"
+	"	//and min.x will be the far plane; otherwise, it is reversed.\n"
+	"	//\n"
+	"	//In order for there to be a collision, the t_min and t_max of each pair must overlap.\n"
+	"	//This can be tested for by selecting the highest t_min and lowest t_max and comparing them.\n"
+	"	\n"
+	"	int4 isNegative = isless( rayNormalizedDirection, ((b3Vector3){0.0f, 0.0f, 0.0f, 0.0f}) );	//isless(x,y) returns (x < y)\n"
+	"	\n"
+	"	//When using vector types, the select() function checks the most signficant bit, \n"
+	"	//but isless() sets the least significant bit.\n"
+	"	isNegative <<= 31;\n"
+	"	//select(b, a, condition) == condition ? a : b\n"
+	"	//When using select() with vector types, (condition[i]) is true if its most significant bit is 1\n"
+	"	b3Vector3 t_min = ( select(aabb.m_min, aabb.m_max, isNegative) - rayOrigin ) / rayNormalizedDirection;\n"
+	"	b3Vector3 t_max = ( select(aabb.m_max, aabb.m_min, isNegative) - rayOrigin ) / rayNormalizedDirection;\n"
+	"	\n"
+	"	b3Scalar t_min_final = 0.0f;\n"
+	"	b3Scalar t_max_final = rayLength;\n"
+	"	\n"
+	"	//Must use fmin()/fmax(); if one of the parameters is NaN, then the parameter that is not NaN is returned. \n"
+	"	//Behavior of min()/max() with NaNs is undefined. (See OpenCL Specification 1.2 [6.12.2] and [6.12.4])\n"
+	"	//Since the innermost fmin()/fmax() is always not NaN, this should never return NaN.\n"
+	"	t_min_final = fmax( t_min.z, fmax(t_min.y, fmax(t_min.x, t_min_final)) );\n"
+	"	t_max_final = fmin( t_max.z, fmin(t_max.y, fmin(t_max.x, t_max_final)) );\n"
+	"	\n"
+	"	return (t_min_final <= t_max_final);\n"
+	"}\n"
+	"__kernel void plbvhRayTraverse(__global b3AabbCL* rigidAabbs,\n"
+	"								__global int* rootNodeIndex, \n"
+	"								__global int2* internalNodeChildIndices, \n"
+	"								__global b3AabbCL* internalNodeAabbs,\n"
+	"								__global int2* internalNodeLeafIndexRanges,\n"
+	"								__global SortDataCL* mortonCodesAndAabbIndices,\n"
+	"								\n"
+	"								__global b3RayInfo* rays,\n"
+	"								\n"
+	"								__global int* out_numRayRigidPairs, \n"
+	"								__global int2* out_rayRigidPairs,\n"
+	"								int maxRayRigidPairs, int numRays)\n"
+	"{\n"
+	"	int rayIndex = get_global_id(0);\n"
+	"	if(rayIndex >= numRays) return;\n"
+	"	\n"
+	"	//\n"
+	"	b3Vector3 rayFrom = rays[rayIndex].m_from;\n"
+	"	b3Vector3 rayTo = rays[rayIndex].m_to;\n"
+	"	b3Vector3 rayNormalizedDirection = b3Vector3_normalize(rayTo - rayFrom);\n"
+	"	b3Scalar rayLength = b3Sqrt( b3Vector3_length2(rayTo - rayFrom) );\n"
+	"	\n"
+	"	//\n"
+	"	int stack[B3_PLVBH_TRAVERSE_MAX_STACK_SIZE];\n"
+	"	\n"
+	"	int stackSize = 1;\n"
+	"	stack[0] = *rootNodeIndex;\n"
+	"	\n"
+	"	while(stackSize)\n"
+	"	{\n"
+	"		int internalOrLeafNodeIndex = stack[ stackSize - 1 ];\n"
+	"		--stackSize;\n"
+	"		\n"
+	"		int isLeaf = isLeafNode(internalOrLeafNodeIndex);	//Internal node if false\n"
+	"		int bvhNodeIndex = getIndexWithInternalNodeMarkerRemoved(internalOrLeafNodeIndex);\n"
+	"		\n"
+	"		//bvhRigidIndex is not used if internal node\n"
+	"		int bvhRigidIndex = (isLeaf) ? mortonCodesAndAabbIndices[bvhNodeIndex].m_value : -1;\n"
+	"	\n"
+	"		b3AabbCL bvhNodeAabb = (isLeaf) ? rigidAabbs[bvhRigidIndex] : internalNodeAabbs[bvhNodeIndex];\n"
+	"		if( rayIntersectsAabb(rayFrom, rayLength, rayNormalizedDirection, bvhNodeAabb)  )\n"
+	"		{\n"
+	"			if(isLeaf)\n"
+	"			{\n"
+	"				int2 rayRigidPair;\n"
+	"				rayRigidPair.x = rayIndex;\n"
+	"				rayRigidPair.y = rigidAabbs[bvhRigidIndex].m_minIndices[3];\n"
+	"				\n"
+	"				int pairIndex = atomic_inc(out_numRayRigidPairs);\n"
+	"				if(pairIndex < maxRayRigidPairs) out_rayRigidPairs[pairIndex] = rayRigidPair;\n"
+	"			}\n"
+	"			\n"
+	"			if(!isLeaf)	//Internal node\n"
+	"			{\n"
+	"				if(stackSize + 2 > B3_PLVBH_TRAVERSE_MAX_STACK_SIZE)\n"
+	"				{\n"
+	"					//Error\n"
+	"				}\n"
+	"				else\n"
+	"				{\n"
+	"					stack[ stackSize++ ] = internalNodeChildIndices[bvhNodeIndex].x;\n"
+	"					stack[ stackSize++ ] = internalNodeChildIndices[bvhNodeIndex].y;\n"
+	"				}\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"}\n"
+	"__kernel void plbvhLargeAabbAabbTest(__global b3AabbCL* smallAabbs, __global b3AabbCL* largeAabbs, \n"
+	"									__global int* out_numPairs, __global int4* out_overlappingPairs, \n"
+	"									int maxPairs, int numLargeAabbRigids, int numSmallAabbRigids)\n"
+	"{\n"
+	"	int smallAabbIndex = get_global_id(0);\n"
+	"	if(smallAabbIndex >= numSmallAabbRigids) return;\n"
+	"	\n"
+	"	b3AabbCL smallAabb = smallAabbs[smallAabbIndex];\n"
+	"	for(int i = 0; i < numLargeAabbRigids; ++i)\n"
+	"	{\n"
+	"		b3AabbCL largeAabb = largeAabbs[i];\n"
+	"		if( TestAabbAgainstAabb2(&smallAabb, &largeAabb) )\n"
+	"		{\n"
+	"			int4 pair;\n"
+	"			pair.x = largeAabb.m_minIndices[3];\n"
+	"			pair.y = smallAabb.m_minIndices[3];\n"
+	"			pair.z = NEW_PAIR_MARKER;\n"
+	"			pair.w = NEW_PAIR_MARKER;\n"
+	"			\n"
+	"			int pairIndex = atomic_inc(out_numPairs);\n"
+	"			if(pairIndex < maxPairs) out_overlappingPairs[pairIndex] = pair;\n"
+	"		}\n"
+	"	}\n"
+	"}\n"
+	"__kernel void plbvhLargeAabbRayTest(__global b3AabbCL* largeRigidAabbs, __global b3RayInfo* rays,\n"
+	"									__global int* out_numRayRigidPairs,  __global int2* out_rayRigidPairs,\n"
+	"									int numLargeAabbRigids, int maxRayRigidPairs, int numRays)\n"
+	"{\n"
+	"	int rayIndex = get_global_id(0);\n"
+	"	if(rayIndex >= numRays) return;\n"
+	"	\n"
+	"	b3Vector3 rayFrom = rays[rayIndex].m_from;\n"
+	"	b3Vector3 rayTo = rays[rayIndex].m_to;\n"
+	"	b3Vector3 rayNormalizedDirection = b3Vector3_normalize(rayTo - rayFrom);\n"
+	"	b3Scalar rayLength = b3Sqrt( b3Vector3_length2(rayTo - rayFrom) );\n"
+	"	\n"
+	"	for(int i = 0; i < numLargeAabbRigids; ++i)\n"
+	"	{\n"
+	"		b3AabbCL rigidAabb = largeRigidAabbs[i];\n"
+	"		if( rayIntersectsAabb(rayFrom, rayLength, rayNormalizedDirection, rigidAabb) )\n"
+	"		{\n"
+	"			int2 rayRigidPair;\n"
+	"			rayRigidPair.x = rayIndex;\n"
+	"			rayRigidPair.y = rigidAabb.m_minIndices[3];\n"
+	"			\n"
+	"			int pairIndex = atomic_inc(out_numRayRigidPairs);\n"
+	"			if(pairIndex < maxRayRigidPairs) out_rayRigidPairs[pairIndex] = rayRigidPair;\n"
+	"		}\n"
+	"	}\n"
+	"}\n"
+	"//Set so that it is always greater than the actual common prefixes, and never selected as a parent node.\n"
+	"//If there are no duplicates, then the highest common prefix is 32 or 64, depending on the number of bits used for the z-curve.\n"
+	"//Duplicate common prefixes increase the highest common prefix at most by the number of bits used to index the leaf node.\n"
+	"//Since 32 bit ints are used to index leaf nodes, the max prefix is 64(32 + 32 bit z-curve) or 96(32 + 64 bit z-curve).\n"
+	"#define B3_PLBVH_INVALID_COMMON_PREFIX 128\n"
+	"#define B3_PLBVH_ROOT_NODE_MARKER -1\n"
+	"#define b3Int64 long\n"
+	"int computeCommonPrefixLength(b3Int64 i, b3Int64 j) { return (int)clz(i ^ j); }\n"
+	"b3Int64 computeCommonPrefix(b3Int64 i, b3Int64 j) \n"
+	"{\n"
+	"	//This function only needs to return (i & j) in order for the algorithm to work,\n"
+	"	//but it may help with debugging to mask out the lower bits.\n"
+	"	b3Int64 commonPrefixLength = (b3Int64)computeCommonPrefixLength(i, j);\n"
+	"	b3Int64 sharedBits = i & j;\n"
+	"	b3Int64 bitmask = ((b3Int64)(~0)) << (64 - commonPrefixLength);	//Set all bits after the common prefix to 0\n"
+	"	\n"
+	"	return sharedBits & bitmask;\n"
+	"}\n"
+	"//Same as computeCommonPrefixLength(), but allows for prefixes with different lengths\n"
+	"int getSharedPrefixLength(b3Int64 prefixA, int prefixLengthA, b3Int64 prefixB, int prefixLengthB)\n"
+	"{\n"
+	"	return b3Min( computeCommonPrefixLength(prefixA, prefixB), b3Min(prefixLengthA, prefixLengthB) );\n"
+	"}\n"
+	"__kernel void computeAdjacentPairCommonPrefix(__global SortDataCL* mortonCodesAndAabbIndices,\n"
+	"											__global b3Int64* out_commonPrefixes,\n"
+	"											__global int* out_commonPrefixLengths,\n"
+	"											int numInternalNodes)\n"
+	"{\n"
+	"	int internalNodeIndex = get_global_id(0);\n"
+	"	if (internalNodeIndex >= numInternalNodes) return;\n"
+	"	\n"
+	"	//Here, (internalNodeIndex + 1) is never out of bounds since it is a leaf node index,\n"
+	"	//and the number of internal nodes is always numLeafNodes - 1\n"
+	"	int leftLeafIndex = internalNodeIndex;\n"
+	"	int rightLeafIndex = internalNodeIndex + 1;\n"
+	"	\n"
+	"	int leftLeafMortonCode = mortonCodesAndAabbIndices[leftLeafIndex].m_key;\n"
+	"	int rightLeafMortonCode = mortonCodesAndAabbIndices[rightLeafIndex].m_key;\n"
+	"	\n"
+	"	//Binary radix tree construction algorithm does not work if there are duplicate morton codes.\n"
+	"	//Append the index of each leaf node to each morton code so that there are no duplicates.\n"
+	"	//The algorithm also requires that the morton codes are sorted in ascending order; this requirement\n"
+	"	//is also satisfied with this method, as (leftLeafIndex < rightLeafIndex) is always true.\n"
+	"	//\n"
+	"	//upsample(a, b) == ( ((b3Int64)a) << 32) | b\n"
+	"	b3Int64 nonduplicateLeftMortonCode = upsample(leftLeafMortonCode, leftLeafIndex);\n"
+	"	b3Int64 nonduplicateRightMortonCode = upsample(rightLeafMortonCode, rightLeafIndex);\n"
+	"	\n"
+	"	out_commonPrefixes[internalNodeIndex] = computeCommonPrefix(nonduplicateLeftMortonCode, nonduplicateRightMortonCode);\n"
+	"	out_commonPrefixLengths[internalNodeIndex] = computeCommonPrefixLength(nonduplicateLeftMortonCode, nonduplicateRightMortonCode);\n"
+	"}\n"
+	"__kernel void buildBinaryRadixTreeLeafNodes(__global int* commonPrefixLengths, __global int* out_leafNodeParentNodes,\n"
+	"											__global int2* out_childNodes, int numLeafNodes)\n"
+	"{\n"
+	"	int leafNodeIndex = get_global_id(0);\n"
+	"	if (leafNodeIndex >= numLeafNodes) return;\n"
+	"	\n"
+	"	int numInternalNodes = numLeafNodes - 1;\n"
+	"	\n"
+	"	int leftSplitIndex = leafNodeIndex - 1;\n"
+	"	int rightSplitIndex = leafNodeIndex;\n"
+	"	\n"
+	"	int leftCommonPrefix = (leftSplitIndex >= 0) ? commonPrefixLengths[leftSplitIndex] : B3_PLBVH_INVALID_COMMON_PREFIX;\n"
+	"	int rightCommonPrefix = (rightSplitIndex < numInternalNodes) ? commonPrefixLengths[rightSplitIndex] : B3_PLBVH_INVALID_COMMON_PREFIX;\n"
+	"	\n"
+	"	//Parent node is the highest adjacent common prefix that is lower than the node's common prefix\n"
+	"	//Leaf nodes are considered as having the highest common prefix\n"
+	"	int isLeftHigherCommonPrefix = (leftCommonPrefix > rightCommonPrefix);\n"
+	"	\n"
+	"	//Handle cases for the edge nodes; the first and last node\n"
+	"	//For leaf nodes, leftCommonPrefix and rightCommonPrefix should never both be B3_PLBVH_INVALID_COMMON_PREFIX\n"
+	"	if(leftCommonPrefix == B3_PLBVH_INVALID_COMMON_PREFIX) isLeftHigherCommonPrefix = false;\n"
+	"	if(rightCommonPrefix == B3_PLBVH_INVALID_COMMON_PREFIX) isLeftHigherCommonPrefix = true;\n"
+	"	\n"
+	"	int parentNodeIndex = (isLeftHigherCommonPrefix) ? leftSplitIndex : rightSplitIndex;\n"
+	"	out_leafNodeParentNodes[leafNodeIndex] = parentNodeIndex;\n"
+	"	\n"
+	"	int isRightChild = (isLeftHigherCommonPrefix);	//If the left node is the parent, then this node is its right child and vice versa\n"
+	"	\n"
+	"	//out_childNodesAsInt[0] == int2.x == left child\n"
+	"	//out_childNodesAsInt[1] == int2.y == right child\n"
+	"	int isLeaf = 1;\n"
+	"	__global int* out_childNodesAsInt = (__global int*)(&out_childNodes[parentNodeIndex]);\n"
+	"	out_childNodesAsInt[isRightChild] = getIndexWithInternalNodeMarkerSet(isLeaf, leafNodeIndex);\n"
+	"}\n"
+	"__kernel void buildBinaryRadixTreeInternalNodes(__global b3Int64* commonPrefixes, __global int* commonPrefixLengths,\n"
+	"												__global int2* out_childNodes,\n"
+	"												__global int* out_internalNodeParentNodes, __global int* out_rootNodeIndex,\n"
+	"												int numInternalNodes)\n"
+	"{\n"
+	"	int internalNodeIndex = get_group_id(0) * get_local_size(0) + get_local_id(0);\n"
+	"	if(internalNodeIndex >= numInternalNodes) return;\n"
+	"	\n"
+	"	b3Int64 nodePrefix = commonPrefixes[internalNodeIndex];\n"
+	"	int nodePrefixLength = commonPrefixLengths[internalNodeIndex];\n"
+	"	\n"
+	"//#define USE_LINEAR_SEARCH\n"
+	"#ifdef USE_LINEAR_SEARCH\n"
+	"	int leftIndex = -1;\n"
+	"	int rightIndex = -1;\n"
+	"	\n"
+	"	//Find nearest element to left with a lower common prefix\n"
+	"	for(int i = internalNodeIndex - 1; i >= 0; --i)\n"
+	"	{\n"
+	"		int nodeLeftSharedPrefixLength = getSharedPrefixLength(nodePrefix, nodePrefixLength, commonPrefixes[i], commonPrefixLengths[i]);\n"
+	"		if(nodeLeftSharedPrefixLength < nodePrefixLength)\n"
+	"		{\n"
+	"			leftIndex = i;\n"
+	"			break;\n"
+	"		}\n"
+	"	}\n"
+	"	\n"
+	"	//Find nearest element to right with a lower common prefix\n"
+	"	for(int i = internalNodeIndex + 1; i < numInternalNodes; ++i)\n"
+	"	{\n"
+	"		int nodeRightSharedPrefixLength = getSharedPrefixLength(nodePrefix, nodePrefixLength, commonPrefixes[i], commonPrefixLengths[i]);\n"
+	"		if(nodeRightSharedPrefixLength < nodePrefixLength)\n"
+	"		{\n"
+	"			rightIndex = i;\n"
+	"			break;\n"
+	"		}\n"
+	"	}\n"
+	"	\n"
+	"#else //Use binary search\n"
+	"	//Find nearest element to left with a lower common prefix\n"
+	"	int leftIndex = -1;\n"
+	"	{\n"
+	"		int lower = 0;\n"
+	"		int upper = internalNodeIndex - 1;\n"
+	"		\n"
+	"		while(lower <= upper)\n"
+	"		{\n"
+	"			int mid = (lower + upper) / 2;\n"
+	"			b3Int64 midPrefix = commonPrefixes[mid];\n"
+	"			int midPrefixLength = commonPrefixLengths[mid];\n"
+	"			\n"
+	"			int nodeMidSharedPrefixLength = getSharedPrefixLength(nodePrefix, nodePrefixLength, midPrefix, midPrefixLength);\n"
+	"			if(nodeMidSharedPrefixLength < nodePrefixLength) \n"
+	"			{\n"
+	"				int right = mid + 1;\n"
+	"				if(right < internalNodeIndex)\n"
+	"				{\n"
+	"					b3Int64 rightPrefix = commonPrefixes[right];\n"
+	"					int rightPrefixLength = commonPrefixLengths[right];\n"
+	"					\n"
+	"					int nodeRightSharedPrefixLength = getSharedPrefixLength(nodePrefix, nodePrefixLength, rightPrefix, rightPrefixLength);\n"
+	"					if(nodeRightSharedPrefixLength < nodePrefixLength) \n"
+	"					{\n"
+	"						lower = right;\n"
+	"						leftIndex = right;\n"
+	"					}\n"
+	"					else \n"
+	"					{\n"
+	"						leftIndex = mid;\n"
+	"						break;\n"
+	"					}\n"
+	"				}\n"
+	"				else \n"
+	"				{\n"
+	"					leftIndex = mid;\n"
+	"					break;\n"
+	"				}\n"
+	"			}\n"
+	"			else upper = mid - 1;\n"
+	"		}\n"
+	"	}\n"
+	"	\n"
+	"	//Find nearest element to right with a lower common prefix\n"
+	"	int rightIndex = -1;\n"
+	"	{\n"
+	"		int lower = internalNodeIndex + 1;\n"
+	"		int upper = numInternalNodes - 1;\n"
+	"		\n"
+	"		while(lower <= upper)\n"
+	"		{\n"
+	"			int mid = (lower + upper) / 2;\n"
+	"			b3Int64 midPrefix = commonPrefixes[mid];\n"
+	"			int midPrefixLength = commonPrefixLengths[mid];\n"
+	"			\n"
+	"			int nodeMidSharedPrefixLength = getSharedPrefixLength(nodePrefix, nodePrefixLength, midPrefix, midPrefixLength);\n"
+	"			if(nodeMidSharedPrefixLength < nodePrefixLength) \n"
+	"			{\n"
+	"				int left = mid - 1;\n"
+	"				if(left > internalNodeIndex)\n"
+	"				{\n"
+	"					b3Int64 leftPrefix = commonPrefixes[left];\n"
+	"					int leftPrefixLength = commonPrefixLengths[left];\n"
+	"				\n"
+	"					int nodeLeftSharedPrefixLength = getSharedPrefixLength(nodePrefix, nodePrefixLength, leftPrefix, leftPrefixLength);\n"
+	"					if(nodeLeftSharedPrefixLength < nodePrefixLength) \n"
+	"					{\n"
+	"						upper = left;\n"
+	"						rightIndex = left;\n"
+	"					}\n"
+	"					else \n"
+	"					{\n"
+	"						rightIndex = mid;\n"
+	"						break;\n"
+	"					}\n"
+	"				}\n"
+	"				else \n"
+	"				{\n"
+	"					rightIndex = mid;\n"
+	"					break;\n"
+	"				}\n"
+	"			}\n"
+	"			else lower = mid + 1;\n"
+	"		}\n"
+	"	}\n"
+	"#endif\n"
+	"	\n"
+	"	//Select parent\n"
+	"	{\n"
+	"		int leftPrefixLength = (leftIndex != -1) ? commonPrefixLengths[leftIndex] : B3_PLBVH_INVALID_COMMON_PREFIX;\n"
+	"		int rightPrefixLength =  (rightIndex != -1) ? commonPrefixLengths[rightIndex] : B3_PLBVH_INVALID_COMMON_PREFIX;\n"
+	"		\n"
+	"		int isLeftHigherPrefixLength = (leftPrefixLength > rightPrefixLength);\n"
+	"		\n"
+	"		if(leftPrefixLength == B3_PLBVH_INVALID_COMMON_PREFIX) isLeftHigherPrefixLength = false;\n"
+	"		else if(rightPrefixLength == B3_PLBVH_INVALID_COMMON_PREFIX) isLeftHigherPrefixLength = true;\n"
+	"		\n"
+	"		int parentNodeIndex = (isLeftHigherPrefixLength) ? leftIndex : rightIndex;\n"
+	"		\n"
+	"		int isRootNode = (leftIndex == -1 && rightIndex == -1);\n"
+	"		out_internalNodeParentNodes[internalNodeIndex] = (!isRootNode) ? parentNodeIndex : B3_PLBVH_ROOT_NODE_MARKER;\n"
+	"		\n"
+	"		int isLeaf = 0;\n"
+	"		if(!isRootNode)\n"
+	"		{\n"
+	"			int isRightChild = (isLeftHigherPrefixLength);	//If the left node is the parent, then this node is its right child and vice versa\n"
+	"			\n"
+	"			//out_childNodesAsInt[0] == int2.x == left child\n"
+	"			//out_childNodesAsInt[1] == int2.y == right child\n"
+	"			__global int* out_childNodesAsInt = (__global int*)(&out_childNodes[parentNodeIndex]);\n"
+	"			out_childNodesAsInt[isRightChild] = getIndexWithInternalNodeMarkerSet(isLeaf, internalNodeIndex);\n"
+	"		}\n"
+	"		else *out_rootNodeIndex = getIndexWithInternalNodeMarkerSet(isLeaf, internalNodeIndex);\n"
+	"	}\n"
+	"}\n"
+	"__kernel void findDistanceFromRoot(__global int* rootNodeIndex, __global int* internalNodeParentNodes,\n"
+	"									__global int* out_maxDistanceFromRoot, __global int* out_distanceFromRoot, int numInternalNodes)\n"
+	"{\n"
+	"	if( get_global_id(0) == 0 ) atomic_xchg(out_maxDistanceFromRoot, 0);\n"
+	"	int internalNodeIndex = get_global_id(0);\n"
+	"	if(internalNodeIndex >= numInternalNodes) return;\n"
+	"	\n"
+	"	//\n"
+	"	int distanceFromRoot = 0;\n"
+	"	{\n"
+	"		int parentIndex = internalNodeParentNodes[internalNodeIndex];\n"
+	"		while(parentIndex != B3_PLBVH_ROOT_NODE_MARKER)\n"
+	"		{\n"
+	"			parentIndex = internalNodeParentNodes[parentIndex];\n"
+	"			++distanceFromRoot;\n"
+	"		}\n"
+	"	}\n"
+	"	out_distanceFromRoot[internalNodeIndex] = distanceFromRoot;\n"
+	"	\n"
+	"	//\n"
+	"	__local int localMaxDistanceFromRoot;\n"
+	"	if( get_local_id(0) == 0 ) localMaxDistanceFromRoot = 0;\n"
+	"	barrier(CLK_LOCAL_MEM_FENCE);\n"
+	"	\n"
+	"	atomic_max(&localMaxDistanceFromRoot, distanceFromRoot);\n"
+	"	barrier(CLK_LOCAL_MEM_FENCE);\n"
+	"	\n"
+	"	if( get_local_id(0) == 0 ) atomic_max(out_maxDistanceFromRoot, localMaxDistanceFromRoot);\n"
+	"}\n"
+	"__kernel void buildBinaryRadixTreeAabbsRecursive(__global int* distanceFromRoot, __global SortDataCL* mortonCodesAndAabbIndices,\n"
+	"												__global int2* childNodes,\n"
+	"												__global b3AabbCL* leafNodeAabbs, __global b3AabbCL* internalNodeAabbs,\n"
+	"												int maxDistanceFromRoot, int processedDistance, int numInternalNodes)\n"
+	"{\n"
+	"	int internalNodeIndex = get_global_id(0);\n"
+	"	if(internalNodeIndex >= numInternalNodes) return;\n"
+	"	\n"
+	"	int distance = distanceFromRoot[internalNodeIndex];\n"
+	"	\n"
+	"	if(distance == processedDistance)\n"
+	"	{\n"
+	"		int leftChildIndex = childNodes[internalNodeIndex].x;\n"
+	"		int rightChildIndex = childNodes[internalNodeIndex].y;\n"
+	"		\n"
+	"		int isLeftChildLeaf = isLeafNode(leftChildIndex);\n"
+	"		int isRightChildLeaf = isLeafNode(rightChildIndex);\n"
+	"		\n"
+	"		leftChildIndex = getIndexWithInternalNodeMarkerRemoved(leftChildIndex);\n"
+	"		rightChildIndex = getIndexWithInternalNodeMarkerRemoved(rightChildIndex);\n"
+	"		\n"
+	"		//leftRigidIndex/rightRigidIndex is not used if internal node\n"
+	"		int leftRigidIndex = (isLeftChildLeaf) ? mortonCodesAndAabbIndices[leftChildIndex].m_value : -1;\n"
+	"		int rightRigidIndex = (isRightChildLeaf) ? mortonCodesAndAabbIndices[rightChildIndex].m_value : -1;\n"
+	"		\n"
+	"		b3AabbCL leftChildAabb = (isLeftChildLeaf) ? leafNodeAabbs[leftRigidIndex] : internalNodeAabbs[leftChildIndex];\n"
+	"		b3AabbCL rightChildAabb = (isRightChildLeaf) ? leafNodeAabbs[rightRigidIndex] : internalNodeAabbs[rightChildIndex];\n"
+	"		\n"
+	"		b3AabbCL mergedAabb;\n"
+	"		mergedAabb.m_min = b3Min(leftChildAabb.m_min, rightChildAabb.m_min);\n"
+	"		mergedAabb.m_max = b3Max(leftChildAabb.m_max, rightChildAabb.m_max);\n"
+	"		internalNodeAabbs[internalNodeIndex] = mergedAabb;\n"
+	"	}\n"
+	"}\n"
+	"__kernel void findLeafIndexRanges(__global int2* internalNodeChildNodes, __global int2* out_leafIndexRanges, int numInternalNodes)\n"
+	"{\n"
+	"	int internalNodeIndex = get_global_id(0);\n"
+	"	if(internalNodeIndex >= numInternalNodes) return;\n"
+	"	\n"
+	"	int numLeafNodes = numInternalNodes + 1;\n"
+	"	\n"
+	"	int2 childNodes = internalNodeChildNodes[internalNodeIndex];\n"
+	"	\n"
+	"	int2 leafIndexRange;	//x == min leaf index, y == max leaf index\n"
+	"	\n"
+	"	//Find lowest leaf index covered by this internal node\n"
+	"	{\n"
+	"		int lowestIndex = childNodes.x;		//childNodes.x == Left child\n"
+	"		while( !isLeafNode(lowestIndex) ) lowestIndex = internalNodeChildNodes[ getIndexWithInternalNodeMarkerRemoved(lowestIndex) ].x;\n"
+	"		leafIndexRange.x = lowestIndex;\n"
+	"	}\n"
+	"	\n"
+	"	//Find highest leaf index covered by this internal node\n"
+	"	{\n"
+	"		int highestIndex = childNodes.y;	//childNodes.y == Right child\n"
+	"		while( !isLeafNode(highestIndex) ) highestIndex = internalNodeChildNodes[ getIndexWithInternalNodeMarkerRemoved(highestIndex) ].y;\n"
+	"		leafIndexRange.y = highestIndex;\n"
+	"	}\n"
+	"	\n"
+	"	//\n"
+	"	out_leafIndexRanges[internalNodeIndex] = leafIndexRange;\n"
+	"}\n";
diff --git a/engine/inc/bullet/Bullet3OpenCL/BroadphaseCollision/kernels/sapKernels.h b/engine/inc/bullet/Bullet3OpenCL/BroadphaseCollision/kernels/sapKernels.h
new file mode 100644
index 00000000..d6999b94
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/BroadphaseCollision/kernels/sapKernels.h
@@ -0,0 +1,341 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* sapCL =
+	"/*\n"
+	"Copyright (c) 2012 Advanced Micro Devices, Inc.  \n"
+	"This software is provided 'as-is', without any express or implied warranty.\n"
+	"In no event will the authors be held liable for any damages arising from the use of this software.\n"
+	"Permission is granted to anyone to use this software for any purpose, \n"
+	"including commercial applications, and to alter it and redistribute it freely, \n"
+	"subject to the following restrictions:\n"
+	"1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.\n"
+	"2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.\n"
+	"3. This notice may not be removed or altered from any source distribution.\n"
+	"*/\n"
+	"//Originally written by Erwin Coumans\n"
+	"#define NEW_PAIR_MARKER -1\n"
+	"typedef struct \n"
+	"{\n"
+	"	union\n"
+	"	{\n"
+	"		float4	m_min;\n"
+	"		float   m_minElems[4];\n"
+	"		int			m_minIndices[4];\n"
+	"	};\n"
+	"	union\n"
+	"	{\n"
+	"		float4	m_max;\n"
+	"		float   m_maxElems[4];\n"
+	"		int			m_maxIndices[4];\n"
+	"	};\n"
+	"} btAabbCL;\n"
+	"/// conservative test for overlap between two aabbs\n"
+	"bool TestAabbAgainstAabb2(const btAabbCL* aabb1, __local const btAabbCL* aabb2);\n"
+	"bool TestAabbAgainstAabb2(const btAabbCL* aabb1, __local const btAabbCL* aabb2)\n"
+	"{\n"
+	"	bool overlap = true;\n"
+	"	overlap = (aabb1->m_min.x > aabb2->m_max.x || aabb1->m_max.x < aabb2->m_min.x) ? false : overlap;\n"
+	"	overlap = (aabb1->m_min.z > aabb2->m_max.z || aabb1->m_max.z < aabb2->m_min.z) ? false : overlap;\n"
+	"	overlap = (aabb1->m_min.y > aabb2->m_max.y || aabb1->m_max.y < aabb2->m_min.y) ? false : overlap;\n"
+	"	return overlap;\n"
+	"}\n"
+	"bool TestAabbAgainstAabb2GlobalGlobal(__global const btAabbCL* aabb1, __global const btAabbCL* aabb2);\n"
+	"bool TestAabbAgainstAabb2GlobalGlobal(__global const btAabbCL* aabb1, __global const btAabbCL* aabb2)\n"
+	"{\n"
+	"	bool overlap = true;\n"
+	"	overlap = (aabb1->m_min.x > aabb2->m_max.x || aabb1->m_max.x < aabb2->m_min.x) ? false : overlap;\n"
+	"	overlap = (aabb1->m_min.z > aabb2->m_max.z || aabb1->m_max.z < aabb2->m_min.z) ? false : overlap;\n"
+	"	overlap = (aabb1->m_min.y > aabb2->m_max.y || aabb1->m_max.y < aabb2->m_min.y) ? false : overlap;\n"
+	"	return overlap;\n"
+	"}\n"
+	"bool TestAabbAgainstAabb2Global(const btAabbCL* aabb1, __global const btAabbCL* aabb2);\n"
+	"bool TestAabbAgainstAabb2Global(const btAabbCL* aabb1, __global const btAabbCL* aabb2)\n"
+	"{\n"
+	"	bool overlap = true;\n"
+	"	overlap = (aabb1->m_min.x > aabb2->m_max.x || aabb1->m_max.x < aabb2->m_min.x) ? false : overlap;\n"
+	"	overlap = (aabb1->m_min.z > aabb2->m_max.z || aabb1->m_max.z < aabb2->m_min.z) ? false : overlap;\n"
+	"	overlap = (aabb1->m_min.y > aabb2->m_max.y || aabb1->m_max.y < aabb2->m_min.y) ? false : overlap;\n"
+	"	return overlap;\n"
+	"}\n"
+	"__kernel void   computePairsKernelTwoArrays( __global const btAabbCL* unsortedAabbs, __global const int* unsortedAabbMapping,  __global const int* unsortedAabbMapping2, volatile __global int4* pairsOut,volatile  __global int* pairCount, int numUnsortedAabbs, int numUnSortedAabbs2, int axis, int maxPairs)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	if (i>=numUnsortedAabbs)\n"
+	"		return;\n"
+	"	int j = get_global_id(1);\n"
+	"	if (j>=numUnSortedAabbs2)\n"
+	"		return;\n"
+	"	__global const btAabbCL* unsortedAabbPtr = &unsortedAabbs[unsortedAabbMapping[i]];\n"
+	"	__global const btAabbCL* unsortedAabbPtr2 = &unsortedAabbs[unsortedAabbMapping2[j]];\n"
+	"	if (TestAabbAgainstAabb2GlobalGlobal(unsortedAabbPtr,unsortedAabbPtr2))\n"
+	"	{\n"
+	"		int4 myPair;\n"
+	"		\n"
+	"		int xIndex = unsortedAabbPtr[0].m_minIndices[3];\n"
+	"		int yIndex = unsortedAabbPtr2[0].m_minIndices[3];\n"
+	"		if (xIndex>yIndex)\n"
+	"		{\n"
+	"			int tmp = xIndex;\n"
+	"			xIndex=yIndex;\n"
+	"			yIndex=tmp;\n"
+	"		}\n"
+	"		\n"
+	"		myPair.x = xIndex;\n"
+	"		myPair.y = yIndex;\n"
+	"		myPair.z = NEW_PAIR_MARKER;\n"
+	"		myPair.w = NEW_PAIR_MARKER;\n"
+	"		int curPair = atomic_inc (pairCount);\n"
+	"		if (curPair<maxPairs)\n"
+	"		{\n"
+	"				pairsOut[curPair] = myPair; //flush to main memory\n"
+	"		}\n"
+	"	}\n"
+	"}\n"
+	"__kernel void   computePairsKernelBruteForce( __global const btAabbCL* aabbs, volatile __global int4* pairsOut,volatile  __global int* pairCount, int numObjects, int axis, int maxPairs)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	if (i>=numObjects)\n"
+	"		return;\n"
+	"	for (int j=i+1;j<numObjects;j++)\n"
+	"	{\n"
+	"		if (TestAabbAgainstAabb2GlobalGlobal(&aabbs[i],&aabbs[j]))\n"
+	"		{\n"
+	"			int4 myPair;\n"
+	"			myPair.x = aabbs[i].m_minIndices[3];\n"
+	"			myPair.y = aabbs[j].m_minIndices[3];\n"
+	"			myPair.z = NEW_PAIR_MARKER;\n"
+	"			myPair.w = NEW_PAIR_MARKER;\n"
+	"			int curPair = atomic_inc (pairCount);\n"
+	"			if (curPair<maxPairs)\n"
+	"			{\n"
+	"					pairsOut[curPair] = myPair; //flush to main memory\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"}\n"
+	"__kernel void   computePairsKernelOriginal( __global const btAabbCL* aabbs, volatile __global int4* pairsOut,volatile  __global int* pairCount, int numObjects, int axis, int maxPairs)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	if (i>=numObjects)\n"
+	"		return;\n"
+	"	for (int j=i+1;j<numObjects;j++)\n"
+	"	{\n"
+	"  	if(aabbs[i].m_maxElems[axis] < (aabbs[j].m_minElems[axis])) \n"
+	"		{\n"
+	"			break;\n"
+	"		}\n"
+	"		if (TestAabbAgainstAabb2GlobalGlobal(&aabbs[i],&aabbs[j]))\n"
+	"		{\n"
+	"			int4 myPair;\n"
+	"			myPair.x = aabbs[i].m_minIndices[3];\n"
+	"			myPair.y = aabbs[j].m_minIndices[3];\n"
+	"			myPair.z = NEW_PAIR_MARKER;\n"
+	"			myPair.w = NEW_PAIR_MARKER;\n"
+	"			int curPair = atomic_inc (pairCount);\n"
+	"			if (curPair<maxPairs)\n"
+	"			{\n"
+	"					pairsOut[curPair] = myPair; //flush to main memory\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"}\n"
+	"__kernel void   computePairsKernelBarrier( __global const btAabbCL* aabbs, volatile __global int4* pairsOut,volatile  __global int* pairCount, int numObjects, int axis, int maxPairs)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	int localId = get_local_id(0);\n"
+	"	__local int numActiveWgItems[1];\n"
+	"	__local int breakRequest[1];\n"
+	"	if (localId==0)\n"
+	"	{\n"
+	"		numActiveWgItems[0] = 0;\n"
+	"		breakRequest[0] = 0;\n"
+	"	}\n"
+	"	barrier(CLK_LOCAL_MEM_FENCE);\n"
+	"	atomic_inc(numActiveWgItems);\n"
+	"	barrier(CLK_LOCAL_MEM_FENCE);\n"
+	"	int localBreak = 0;\n"
+	"	int j=i+1;\n"
+	"	do\n"
+	"	{\n"
+	"		barrier(CLK_LOCAL_MEM_FENCE);\n"
+	"	\n"
+	"		if (j<numObjects)\n"
+	"		{\n"
+	"	  	if(aabbs[i].m_maxElems[axis] < (aabbs[j].m_minElems[axis])) \n"
+	"			{\n"
+	"				if (!localBreak)\n"
+	"				{\n"
+	"					atomic_inc(breakRequest);\n"
+	"					localBreak = 1;\n"
+	"				}\n"
+	"			}\n"
+	"		}\n"
+	"		\n"
+	"		barrier(CLK_LOCAL_MEM_FENCE);\n"
+	"		\n"
+	"		if (j>=numObjects && !localBreak)\n"
+	"		{\n"
+	"			atomic_inc(breakRequest);\n"
+	"			localBreak = 1;\n"
+	"		}\n"
+	"		barrier(CLK_LOCAL_MEM_FENCE);\n"
+	"		\n"
+	"		if (!localBreak)\n"
+	"		{\n"
+	"			if (TestAabbAgainstAabb2GlobalGlobal(&aabbs[i],&aabbs[j]))\n"
+	"			{\n"
+	"				int4 myPair;\n"
+	"				myPair.x = aabbs[i].m_minIndices[3];\n"
+	"				myPair.y = aabbs[j].m_minIndices[3];\n"
+	"				myPair.z = NEW_PAIR_MARKER;\n"
+	"				myPair.w = NEW_PAIR_MARKER;\n"
+	"				int curPair = atomic_inc (pairCount);\n"
+	"				if (curPair<maxPairs)\n"
+	"				{\n"
+	"						pairsOut[curPair] = myPair; //flush to main memory\n"
+	"				}\n"
+	"			}\n"
+	"		}\n"
+	"		j++;\n"
+	"	} while (breakRequest[0]<numActiveWgItems[0]);\n"
+	"}\n"
+	"__kernel void   computePairsKernelLocalSharedMemory( __global const btAabbCL* aabbs, volatile __global int4* pairsOut,volatile  __global int* pairCount, int numObjects, int axis, int maxPairs)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	int localId = get_local_id(0);\n"
+	"	__local int numActiveWgItems[1];\n"
+	"	__local int breakRequest[1];\n"
+	"	__local btAabbCL localAabbs[128];// = aabbs[i];\n"
+	"	\n"
+	"	btAabbCL myAabb;\n"
+	"	\n"
+	"	myAabb = (i<numObjects)? aabbs[i]:aabbs[0];\n"
+	"	float testValue = 	myAabb.m_maxElems[axis];\n"
+	"	\n"
+	"	if (localId==0)\n"
+	"	{\n"
+	"		numActiveWgItems[0] = 0;\n"
+	"		breakRequest[0] = 0;\n"
+	"	}\n"
+	"	int localCount=0;\n"
+	"	int block=0;\n"
+	"	localAabbs[localId] = (i+block)<numObjects? aabbs[i+block] : aabbs[0];\n"
+	"	localAabbs[localId+64] = (i+block+64)<numObjects? aabbs[i+block+64]: aabbs[0];\n"
+	"	\n"
+	"	barrier(CLK_LOCAL_MEM_FENCE);\n"
+	"	atomic_inc(numActiveWgItems);\n"
+	"	barrier(CLK_LOCAL_MEM_FENCE);\n"
+	"	int localBreak = 0;\n"
+	"	\n"
+	"	int j=i+1;\n"
+	"	do\n"
+	"	{\n"
+	"		barrier(CLK_LOCAL_MEM_FENCE);\n"
+	"	\n"
+	"		if (j<numObjects)\n"
+	"		{\n"
+	"	  	if(testValue < (localAabbs[localCount+localId+1].m_minElems[axis])) \n"
+	"			{\n"
+	"				if (!localBreak)\n"
+	"				{\n"
+	"					atomic_inc(breakRequest);\n"
+	"					localBreak = 1;\n"
+	"				}\n"
+	"			}\n"
+	"		}\n"
+	"		\n"
+	"		barrier(CLK_LOCAL_MEM_FENCE);\n"
+	"		\n"
+	"		if (j>=numObjects && !localBreak)\n"
+	"		{\n"
+	"			atomic_inc(breakRequest);\n"
+	"			localBreak = 1;\n"
+	"		}\n"
+	"		barrier(CLK_LOCAL_MEM_FENCE);\n"
+	"		\n"
+	"		if (!localBreak)\n"
+	"		{\n"
+	"			if (TestAabbAgainstAabb2(&myAabb,&localAabbs[localCount+localId+1]))\n"
+	"			{\n"
+	"				int4 myPair;\n"
+	"				myPair.x = myAabb.m_minIndices[3];\n"
+	"				myPair.y = localAabbs[localCount+localId+1].m_minIndices[3];\n"
+	"				myPair.z = NEW_PAIR_MARKER;\n"
+	"				myPair.w = NEW_PAIR_MARKER;\n"
+	"				int curPair = atomic_inc (pairCount);\n"
+	"				if (curPair<maxPairs)\n"
+	"				{\n"
+	"						pairsOut[curPair] = myPair; //flush to main memory\n"
+	"				}\n"
+	"			}\n"
+	"		}\n"
+	"		\n"
+	"		barrier(CLK_LOCAL_MEM_FENCE);\n"
+	"		localCount++;\n"
+	"		if (localCount==64)\n"
+	"		{\n"
+	"			localCount = 0;\n"
+	"			block+=64;			\n"
+	"			localAabbs[localId] = ((i+block)<numObjects) ? aabbs[i+block] : aabbs[0];\n"
+	"			localAabbs[localId+64] = ((i+64+block)<numObjects) ? aabbs[i+block+64] : aabbs[0];\n"
+	"		}\n"
+	"		j++;\n"
+	"		\n"
+	"	} while (breakRequest[0]<numActiveWgItems[0]);\n"
+	"	\n"
+	"}\n"
+	"//http://stereopsis.com/radix.html\n"
+	"unsigned int FloatFlip(float fl);\n"
+	"unsigned int FloatFlip(float fl)\n"
+	"{\n"
+	"	unsigned int f = *(unsigned int*)&fl;\n"
+	"	unsigned int mask = -(int)(f >> 31) | 0x80000000;\n"
+	"	return f ^ mask;\n"
+	"}\n"
+	"float IFloatFlip(unsigned int f);\n"
+	"float IFloatFlip(unsigned int f)\n"
+	"{\n"
+	"	unsigned int mask = ((f >> 31) - 1) | 0x80000000;\n"
+	"	unsigned int fl = f ^ mask;\n"
+	"	return *(float*)&fl;\n"
+	"}\n"
+	"__kernel void   copyAabbsKernel( __global const btAabbCL* allAabbs, __global btAabbCL* destAabbs, int numObjects)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	if (i>=numObjects)\n"
+	"		return;\n"
+	"	int src = destAabbs[i].m_maxIndices[3];\n"
+	"	destAabbs[i] = allAabbs[src];\n"
+	"	destAabbs[i].m_maxIndices[3] = src;\n"
+	"}\n"
+	"__kernel void   flipFloatKernel( __global const btAabbCL* allAabbs, __global const int* smallAabbMapping, __global int2* sortData, int numObjects, int axis)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	if (i>=numObjects)\n"
+	"		return;\n"
+	"	\n"
+	"	\n"
+	"	sortData[i].x = FloatFlip(allAabbs[smallAabbMapping[i]].m_minElems[axis]);\n"
+	"	sortData[i].y = i;\n"
+	"		\n"
+	"}\n"
+	"__kernel void   scatterKernel( __global const btAabbCL* allAabbs, __global const int* smallAabbMapping, volatile __global const int2* sortData, __global btAabbCL* sortedAabbs, int numObjects)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	if (i>=numObjects)\n"
+	"		return;\n"
+	"	\n"
+	"	sortedAabbs[i] = allAabbs[smallAabbMapping[sortData[i].y]];\n"
+	"}\n"
+	"__kernel void   prepareSumVarianceKernel( __global const btAabbCL* allAabbs, __global const int* smallAabbMapping, __global float4* sum, __global float4* sum2,int numAabbs)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	if (i>=numAabbs)\n"
+	"		return;\n"
+	"	\n"
+	"	btAabbCL smallAabb = allAabbs[smallAabbMapping[i]];\n"
+	"	\n"
+	"	float4 s;\n"
+	"	s = (smallAabb.m_max+smallAabb.m_min)*0.5f;\n"
+	"	sum[i]=s;\n"
+	"	sum2[i]=s*s;	\n"
+	"}\n";
diff --git a/engine/inc/bullet/Bullet3OpenCL/Initialize/b3OpenCLInclude.h b/engine/inc/bullet/Bullet3OpenCL/Initialize/b3OpenCLInclude.h
new file mode 100644
index 00000000..61465382
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/Initialize/b3OpenCLInclude.h
@@ -0,0 +1,51 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2011 Advanced Micro Devices, Inc.  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_OPENCL_INCLUDE_H
+#define B3_OPENCL_INCLUDE_H
+
+#ifdef B3_USE_CLEW
+#include "clew/clew.h"
+#else
+
+#ifdef __APPLE__
+#ifdef USE_MINICL
+#include <MiniCL/cl.h>
+#else
+#include <OpenCL/cl.h>
+#include <OpenCL/cl_ext.h>  //clLogMessagesToStderrAPPLE
+#endif
+#else
+#ifdef USE_MINICL
+#include <MiniCL/cl.h>
+#else
+#include <CL/cl.h>
+#ifdef _WIN32
+#include "CL/cl_gl.h"
+#endif  //_WIN32
+#endif
+#endif  //__APPLE__
+#endif  //B3_USE_CLEW
+
+#include <assert.h>
+#include <stdio.h>
+#define oclCHECKERROR(a, b)              \
+	if ((a) != (b))                      \
+	{                                    \
+		printf("OCL Error : %d\n", (a)); \
+		assert((a) == (b));              \
+	}
+
+#endif  //B3_OPENCL_INCLUDE_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/Initialize/b3OpenCLUtils.h b/engine/inc/bullet/Bullet3OpenCL/Initialize/b3OpenCLUtils.h
new file mode 100644
index 00000000..6c82eed2
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/Initialize/b3OpenCLUtils.h
@@ -0,0 +1,190 @@
+/*
+Bullet Continuous Collision Detection and Physics Library, http://bulletphysics.org
+Copyright (C) 2006 - 2011 Sony Computer Entertainment Inc. 
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+//original author: Roman Ponomarev
+//cleanup by Erwin Coumans
+
+#ifndef B3_OPENCL_UTILS_H
+#define B3_OPENCL_UTILS_H
+
+#include "b3OpenCLInclude.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	///C API for OpenCL utilities: convenience functions, see below for C++ API
+
+	/// CL Context optionally takes a GL context. This is a generic type because we don't really want this code
+	/// to have to understand GL types. It is a HGLRC in _WIN32 or a GLXContext otherwise.
+	cl_context b3OpenCLUtils_createContextFromType(cl_device_type deviceType, cl_int* pErrNum, void* pGLCtx, void* pGLDC, int preferredDeviceIndex, int preferredPlatformIndex, cl_platform_id* platformId);
+
+	int b3OpenCLUtils_getNumDevices(cl_context cxMainContext);
+
+	cl_device_id b3OpenCLUtils_getDevice(cl_context cxMainContext, int nr);
+
+	void b3OpenCLUtils_printDeviceInfo(cl_device_id device);
+
+	cl_kernel b3OpenCLUtils_compileCLKernelFromString(cl_context clContext, cl_device_id device, const char* kernelSource, const char* kernelName, cl_int* pErrNum, cl_program prog, const char* additionalMacros);
+
+	//optional
+	cl_program b3OpenCLUtils_compileCLProgramFromString(cl_context clContext, cl_device_id device, const char* kernelSource, cl_int* pErrNum, const char* additionalMacros, const char* srcFileNameForCaching, bool disableBinaryCaching);
+
+	//the following optional APIs provide access using specific platform information
+	int b3OpenCLUtils_getNumPlatforms(cl_int* pErrNum);
+
+	///get the nr'th platform, where nr is in the range [0..getNumPlatforms)
+	cl_platform_id b3OpenCLUtils_getPlatform(int nr, cl_int* pErrNum);
+
+	void b3OpenCLUtils_printPlatformInfo(cl_platform_id platform);
+
+	const char* b3OpenCLUtils_getSdkVendorName();
+
+	///set the path (directory/folder) where the compiled OpenCL kernel are stored
+	void b3OpenCLUtils_setCachePath(const char* path);
+
+	cl_context b3OpenCLUtils_createContextFromPlatform(cl_platform_id platform, cl_device_type deviceType, cl_int* pErrNum, void* pGLCtx, void* pGLDC, int preferredDeviceIndex, int preferredPlatformIndex);
+
+#ifdef __cplusplus
+}
+
+#define B3_MAX_STRING_LENGTH 1024
+
+typedef struct
+{
+	char m_deviceName[B3_MAX_STRING_LENGTH];
+	char m_deviceVendor[B3_MAX_STRING_LENGTH];
+	char m_driverVersion[B3_MAX_STRING_LENGTH];
+	char m_deviceExtensions[B3_MAX_STRING_LENGTH];
+
+	cl_device_type m_deviceType;
+	cl_uint m_computeUnits;
+	size_t m_workitemDims;
+	size_t m_workItemSize[3];
+	size_t m_image2dMaxWidth;
+	size_t m_image2dMaxHeight;
+	size_t m_image3dMaxWidth;
+	size_t m_image3dMaxHeight;
+	size_t m_image3dMaxDepth;
+	size_t m_workgroupSize;
+	cl_uint m_clockFrequency;
+	cl_ulong m_constantBufferSize;
+	cl_ulong m_localMemSize;
+	cl_ulong m_globalMemSize;
+	cl_bool m_errorCorrectionSupport;
+	cl_device_local_mem_type m_localMemType;
+	cl_uint m_maxReadImageArgs;
+	cl_uint m_maxWriteImageArgs;
+
+	cl_uint m_addressBits;
+	cl_ulong m_maxMemAllocSize;
+	cl_command_queue_properties m_queueProperties;
+	cl_bool m_imageSupport;
+	cl_uint m_vecWidthChar;
+	cl_uint m_vecWidthShort;
+	cl_uint m_vecWidthInt;
+	cl_uint m_vecWidthLong;
+	cl_uint m_vecWidthFloat;
+	cl_uint m_vecWidthDouble;
+
+} b3OpenCLDeviceInfo;
+
+struct b3OpenCLPlatformInfo
+{
+	char m_platformVendor[B3_MAX_STRING_LENGTH];
+	char m_platformName[B3_MAX_STRING_LENGTH];
+	char m_platformVersion[B3_MAX_STRING_LENGTH];
+
+	b3OpenCLPlatformInfo()
+	{
+		m_platformVendor[0] = 0;
+		m_platformName[0] = 0;
+		m_platformVersion[0] = 0;
+	}
+};
+
+///C++ API for OpenCL utilities: convenience functions
+struct b3OpenCLUtils
+{
+	/// CL Context optionally takes a GL context. This is a generic type because we don't really want this code
+	/// to have to understand GL types. It is a HGLRC in _WIN32 or a GLXContext otherwise.
+	static inline cl_context createContextFromType(cl_device_type deviceType, cl_int* pErrNum, void* pGLCtx = 0, void* pGLDC = 0, int preferredDeviceIndex = -1, int preferredPlatformIndex = -1, cl_platform_id* platformId = 0)
+	{
+		return b3OpenCLUtils_createContextFromType(deviceType, pErrNum, pGLCtx, pGLDC, preferredDeviceIndex, preferredPlatformIndex, platformId);
+	}
+
+	static inline int getNumDevices(cl_context cxMainContext)
+	{
+		return b3OpenCLUtils_getNumDevices(cxMainContext);
+	}
+	static inline cl_device_id getDevice(cl_context cxMainContext, int nr)
+	{
+		return b3OpenCLUtils_getDevice(cxMainContext, nr);
+	}
+
+	static void getDeviceInfo(cl_device_id device, b3OpenCLDeviceInfo* info);
+
+	static inline void printDeviceInfo(cl_device_id device)
+	{
+		b3OpenCLUtils_printDeviceInfo(device);
+	}
+
+	static inline cl_kernel compileCLKernelFromString(cl_context clContext, cl_device_id device, const char* kernelSource, const char* kernelName, cl_int* pErrNum = 0, cl_program prog = 0, const char* additionalMacros = "")
+	{
+		return b3OpenCLUtils_compileCLKernelFromString(clContext, device, kernelSource, kernelName, pErrNum, prog, additionalMacros);
+	}
+
+	//optional
+	static inline cl_program compileCLProgramFromString(cl_context clContext, cl_device_id device, const char* kernelSource, cl_int* pErrNum = 0, const char* additionalMacros = "", const char* srcFileNameForCaching = 0, bool disableBinaryCaching = false)
+	{
+		return b3OpenCLUtils_compileCLProgramFromString(clContext, device, kernelSource, pErrNum, additionalMacros, srcFileNameForCaching, disableBinaryCaching);
+	}
+
+	//the following optional APIs provide access using specific platform information
+	static inline int getNumPlatforms(cl_int* pErrNum = 0)
+	{
+		return b3OpenCLUtils_getNumPlatforms(pErrNum);
+	}
+	///get the nr'th platform, where nr is in the range [0..getNumPlatforms)
+	static inline cl_platform_id getPlatform(int nr, cl_int* pErrNum = 0)
+	{
+		return b3OpenCLUtils_getPlatform(nr, pErrNum);
+	}
+
+	static void getPlatformInfo(cl_platform_id platform, b3OpenCLPlatformInfo* platformInfo);
+
+	static inline void printPlatformInfo(cl_platform_id platform)
+	{
+		b3OpenCLUtils_printPlatformInfo(platform);
+	}
+
+	static inline const char* getSdkVendorName()
+	{
+		return b3OpenCLUtils_getSdkVendorName();
+	}
+	static inline cl_context createContextFromPlatform(cl_platform_id platform, cl_device_type deviceType, cl_int* pErrNum, void* pGLCtx = 0, void* pGLDC = 0, int preferredDeviceIndex = -1, int preferredPlatformIndex = -1)
+	{
+		return b3OpenCLUtils_createContextFromPlatform(platform, deviceType, pErrNum, pGLCtx, pGLDC, preferredDeviceIndex, preferredPlatformIndex);
+	}
+	static void setCachePath(const char* path)
+	{
+		b3OpenCLUtils_setCachePath(path);
+	}
+};
+
+#endif  //__cplusplus
+
+#endif  // B3_OPENCL_UTILS_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3BvhInfo.h b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3BvhInfo.h
new file mode 100644
index 00000000..27835bb7
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3BvhInfo.h
@@ -0,0 +1,17 @@
+#ifndef B3_BVH_INFO_H
+#define B3_BVH_INFO_H
+
+#include "Bullet3Common/b3Vector3.h"
+
+struct b3BvhInfo
+{
+	b3Vector3 m_aabbMin;
+	b3Vector3 m_aabbMax;
+	b3Vector3 m_quantization;
+	int m_numNodes;
+	int m_numSubTrees;
+	int m_nodeOffset;
+	int m_subTreeOffset;
+};
+
+#endif  //B3_BVH_INFO_H
\ No newline at end of file
diff --git a/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3ContactCache.h b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3ContactCache.h
new file mode 100644
index 00000000..a15fd0b2
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3ContactCache.h
@@ -0,0 +1,62 @@
+
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_CONTACT_CACHE_H
+#define B3_CONTACT_CACHE_H
+
+#include "Bullet3Common/b3Vector3.h"
+#include "Bullet3Common/b3Transform.h"
+#include "Bullet3Common/b3AlignedAllocator.h"
+
+///maximum contact breaking and merging threshold
+extern b3Scalar gContactBreakingThreshold;
+
+#define MANIFOLD_CACHE_SIZE 4
+
+///b3ContactCache is a contact point cache, it stays persistent as long as objects are overlapping in the broadphase.
+///Those contact points are created by the collision narrow phase.
+///The cache can be empty, or hold 1,2,3 or 4 points. Some collision algorithms (GJK) might only add one point at a time.
+///updates/refreshes old contact points, and throw them away if necessary (distance becomes too large)
+///reduces the cache to 4 points, when more then 4 points are added, using following rules:
+///the contact point with deepest penetration is always kept, and it tries to maximuze the area covered by the points
+///note that some pairs of objects might have more then one contact manifold.
+B3_ATTRIBUTE_ALIGNED16(class)
+b3ContactCache
+{
+	/// sort cached points so most isolated points come first
+	int sortCachedPoints(const b3Vector3& pt);
+
+public:
+	B3_DECLARE_ALIGNED_ALLOCATOR();
+
+	int addManifoldPoint(const b3Vector3& newPoint);
+
+	/*void replaceContactPoint(const b3Vector3& newPoint,int insertIndex)
+	{
+		b3Assert(validContactDistance(newPoint));
+		m_pointCache[insertIndex] = newPoint;
+	}
+	*/
+
+	static bool validContactDistance(const b3Vector3& pt);
+
+	/// calculated new worldspace coordinates and depth, and reject points that exceed the collision margin
+	static void refreshContactPoints(const b3Transform& trA, const b3Transform& trB, struct b3Contact4Data& newContactCache);
+
+	static void removeContactPoint(struct b3Contact4Data & newContactCache, int i);
+};
+
+#endif  //B3_CONTACT_CACHE_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3ConvexHullContact.h b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3ConvexHullContact.h
new file mode 100644
index 00000000..53e8c4ed
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3ConvexHullContact.h
@@ -0,0 +1,106 @@
+
+#ifndef _CONVEX_HULL_CONTACT_H
+#define _CONVEX_HULL_CONTACT_H
+
+#include "Bullet3OpenCL/ParallelPrimitives/b3OpenCLArray.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h"
+#include "Bullet3Common/b3AlignedObjectArray.h"
+
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3ConvexPolyhedronData.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h"
+#include "Bullet3Collision/NarrowPhaseCollision/b3Contact4.h"
+#include "Bullet3Common/shared/b3Int2.h"
+#include "Bullet3Common/shared/b3Int4.h"
+#include "b3OptimizedBvh.h"
+#include "b3BvhInfo.h"
+#include "Bullet3Collision/BroadPhaseCollision/shared/b3Aabb.h"
+
+//#include "../../dynamics/basic_demo/Stubs/ChNarrowPhase.h"
+
+struct GpuSatCollision
+{
+	cl_context m_context;
+	cl_device_id m_device;
+	cl_command_queue m_queue;
+	cl_kernel m_findSeparatingAxisKernel;
+	cl_kernel m_mprPenetrationKernel;
+	cl_kernel m_findSeparatingAxisUnitSphereKernel;
+
+	cl_kernel m_findSeparatingAxisVertexFaceKernel;
+	cl_kernel m_findSeparatingAxisEdgeEdgeKernel;
+
+	cl_kernel m_findConcaveSeparatingAxisKernel;
+	cl_kernel m_findConcaveSeparatingAxisVertexFaceKernel;
+	cl_kernel m_findConcaveSeparatingAxisEdgeEdgeKernel;
+
+	cl_kernel m_findCompoundPairsKernel;
+	cl_kernel m_processCompoundPairsKernel;
+
+	cl_kernel m_clipHullHullKernel;
+	cl_kernel m_clipCompoundsHullHullKernel;
+
+	cl_kernel m_clipFacesAndFindContacts;
+	cl_kernel m_findClippingFacesKernel;
+
+	cl_kernel m_clipHullHullConcaveConvexKernel;
+	//	cl_kernel				m_extractManifoldAndAddContactKernel;
+	cl_kernel m_newContactReductionKernel;
+
+	cl_kernel m_bvhTraversalKernel;
+	cl_kernel m_primitiveContactsKernel;
+	cl_kernel m_findConcaveSphereContactsKernel;
+
+	cl_kernel m_processCompoundPairsPrimitivesKernel;
+
+	b3OpenCLArray<b3Vector3> m_unitSphereDirections;
+
+	b3OpenCLArray<int> m_totalContactsOut;
+
+	b3OpenCLArray<b3Vector3> m_sepNormals;
+	b3OpenCLArray<float> m_dmins;
+
+	b3OpenCLArray<int> m_hasSeparatingNormals;
+	b3OpenCLArray<b3Vector3> m_concaveSepNormals;
+	b3OpenCLArray<int> m_concaveHasSeparatingNormals;
+	b3OpenCLArray<int> m_numConcavePairsOut;
+	b3OpenCLArray<b3CompoundOverlappingPair> m_gpuCompoundPairs;
+	b3OpenCLArray<b3Vector3> m_gpuCompoundSepNormals;
+	b3OpenCLArray<int> m_gpuHasCompoundSepNormals;
+	b3OpenCLArray<int> m_numCompoundPairsOut;
+
+	GpuSatCollision(cl_context ctx, cl_device_id device, cl_command_queue q);
+	virtual ~GpuSatCollision();
+
+	void computeConvexConvexContactsGPUSAT(b3OpenCLArray<b3Int4>* pairs, int nPairs,
+										   const b3OpenCLArray<b3RigidBodyData>* bodyBuf,
+										   b3OpenCLArray<b3Contact4>* contactOut, int& nContacts,
+										   const b3OpenCLArray<b3Contact4>* oldContacts,
+										   int maxContactCapacity,
+										   int compoundPairCapacity,
+										   const b3OpenCLArray<b3ConvexPolyhedronData>& hostConvexData,
+										   const b3OpenCLArray<b3Vector3>& vertices,
+										   const b3OpenCLArray<b3Vector3>& uniqueEdges,
+										   const b3OpenCLArray<b3GpuFace>& faces,
+										   const b3OpenCLArray<int>& indices,
+										   const b3OpenCLArray<b3Collidable>& gpuCollidables,
+										   const b3OpenCLArray<b3GpuChildShape>& gpuChildShapes,
+
+										   const b3OpenCLArray<b3Aabb>& clAabbsWorldSpace,
+										   const b3OpenCLArray<b3Aabb>& clAabbsLocalSpace,
+
+										   b3OpenCLArray<b3Vector3>& worldVertsB1GPU,
+										   b3OpenCLArray<b3Int4>& clippingFacesOutGPU,
+										   b3OpenCLArray<b3Vector3>& worldNormalsAGPU,
+										   b3OpenCLArray<b3Vector3>& worldVertsA1GPU,
+										   b3OpenCLArray<b3Vector3>& worldVertsB2GPU,
+										   b3AlignedObjectArray<class b3OptimizedBvh*>& bvhData,
+										   b3OpenCLArray<b3QuantizedBvhNode>* treeNodesGPU,
+										   b3OpenCLArray<b3BvhSubtreeInfo>* subTreesGPU,
+										   b3OpenCLArray<b3BvhInfo>* bvhInfo,
+										   int numObjects,
+										   int maxTriConvexPairCapacity,
+										   b3OpenCLArray<b3Int4>& triangleConvexPairs,
+										   int& numTriConvexPairsOut);
+};
+
+#endif  //_CONVEX_HULL_CONTACT_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3ConvexPolyhedronCL.h b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3ConvexPolyhedronCL.h
new file mode 100644
index 00000000..c4cf7000
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3ConvexPolyhedronCL.h
@@ -0,0 +1,7 @@
+#ifndef CONVEX_POLYHEDRON_CL
+#define CONVEX_POLYHEDRON_CL
+
+#include "Bullet3Common/b3Transform.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3ConvexPolyhedronData.h"
+
+#endif  //CONVEX_POLYHEDRON_CL
diff --git a/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3GjkEpa.h b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3GjkEpa.h
new file mode 100644
index 00000000..7db32c63
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3GjkEpa.h
@@ -0,0 +1,79 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2008 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the
+use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not
+claim that you wrote the original software. If you use this software in a
+product, an acknowledgment in the product documentation would be appreciated
+but is not required.
+2. Altered source versions must be plainly marked as such, and must not be
+misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+/*
+GJK-EPA collision solver by Nathanael Presson, 2008
+*/
+#ifndef B3_GJK_EPA2_H
+#define B3_GJK_EPA2_H
+
+#include "Bullet3Common/b3AlignedObjectArray.h"
+#include "Bullet3Common/b3Transform.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3ConvexPolyhedronData.h"
+
+///btGjkEpaSolver contributed under zlib by Nathanael Presson
+struct b3GjkEpaSolver2
+{
+	struct sResults
+	{
+		enum eStatus
+		{
+			Separated,   /* Shapes doesnt penetrate												*/
+			Penetrating, /* Shapes are penetrating												*/
+			GJK_Failed,  /* GJK phase fail, no big issue, shapes are probably just 'touching'	*/
+			EPA_Failed   /* EPA phase fail, bigger problem, need to save parameters, and debug	*/
+		} status;
+		b3Vector3 witnesses[2];
+		b3Vector3 normal;
+		b3Scalar distance;
+	};
+
+	static int StackSizeRequirement();
+
+	static bool Distance(const b3Transform& transA, const b3Transform& transB,
+						 const b3ConvexPolyhedronData* hullA, const b3ConvexPolyhedronData* hullB,
+						 const b3AlignedObjectArray<b3Vector3>& verticesA,
+						 const b3AlignedObjectArray<b3Vector3>& verticesB,
+						 const b3Vector3& guess,
+						 sResults& results);
+
+	static bool Penetration(const b3Transform& transA, const b3Transform& transB,
+							const b3ConvexPolyhedronData* hullA, const b3ConvexPolyhedronData* hullB,
+							const b3AlignedObjectArray<b3Vector3>& verticesA,
+							const b3AlignedObjectArray<b3Vector3>& verticesB,
+							const b3Vector3& guess,
+							sResults& results,
+							bool usemargins = true);
+#if 0
+static b3Scalar	SignedDistance(	const b3Vector3& position,
+								b3Scalar margin,
+								const btConvexShape* shape,
+								const btTransform& wtrs,
+								sResults& results);
+							
+static bool		SignedDistance(	const btConvexShape* shape0,const btTransform& wtrs0,
+								const btConvexShape* shape1,const btTransform& wtrs1,
+								const b3Vector3& guess,
+								sResults& results);
+#endif
+};
+
+#endif  //B3_GJK_EPA2_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3OptimizedBvh.h b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3OptimizedBvh.h
new file mode 100644
index 00000000..12865529
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3OptimizedBvh.h
@@ -0,0 +1,56 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+///Contains contributions from Disney Studio's
+
+#ifndef B3_OPTIMIZED_BVH_H
+#define B3_OPTIMIZED_BVH_H
+
+#include "b3QuantizedBvh.h"
+
+class b3StridingMeshInterface;
+
+///The b3OptimizedBvh extends the b3QuantizedBvh to create AABB tree for triangle meshes, through the b3StridingMeshInterface.
+B3_ATTRIBUTE_ALIGNED16(class)
+b3OptimizedBvh : public b3QuantizedBvh
+{
+public:
+	B3_DECLARE_ALIGNED_ALLOCATOR();
+
+protected:
+public:
+	b3OptimizedBvh();
+
+	virtual ~b3OptimizedBvh();
+
+	void build(b3StridingMeshInterface * triangles, bool useQuantizedAabbCompression, const b3Vector3& bvhAabbMin, const b3Vector3& bvhAabbMax);
+
+	void refit(b3StridingMeshInterface * triangles, const b3Vector3& aabbMin, const b3Vector3& aabbMax);
+
+	void refitPartial(b3StridingMeshInterface * triangles, const b3Vector3& aabbMin, const b3Vector3& aabbMax);
+
+	void updateBvhNodes(b3StridingMeshInterface * meshInterface, int firstNode, int endNode, int index);
+
+	/// Data buffer MUST be 16 byte aligned
+	virtual bool serializeInPlace(void* o_alignedDataBuffer, unsigned i_dataBufferSize, bool i_swapEndian) const
+	{
+		return b3QuantizedBvh::serialize(o_alignedDataBuffer, i_dataBufferSize, i_swapEndian);
+	}
+
+	///deSerializeInPlace loads and initializes a BVH from a buffer in memory 'in place'
+	static b3OptimizedBvh* deSerializeInPlace(void* i_alignedDataBuffer, unsigned int i_dataBufferSize, bool i_swapEndian);
+};
+
+#endif  //B3_OPTIMIZED_BVH_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3QuantizedBvh.h b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3QuantizedBvh.h
new file mode 100644
index 00000000..48b41abc
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3QuantizedBvh.h
@@ -0,0 +1,511 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_QUANTIZED_BVH_H
+#define B3_QUANTIZED_BVH_H
+
+class b3Serializer;
+
+//#define DEBUG_CHECK_DEQUANTIZATION 1
+#ifdef DEBUG_CHECK_DEQUANTIZATION
+#ifdef __SPU__
+#define printf spu_printf
+#endif  //__SPU__
+
+#include <stdio.h>
+#include <stdlib.h>
+#endif  //DEBUG_CHECK_DEQUANTIZATION
+
+#include "Bullet3Common/b3Vector3.h"
+#include "Bullet3Common/b3AlignedAllocator.h"
+
+#ifdef B3_USE_DOUBLE_PRECISION
+#define b3QuantizedBvhData b3QuantizedBvhDoubleData
+#define b3OptimizedBvhNodeData b3OptimizedBvhNodeDoubleData
+#define b3QuantizedBvhDataName "b3QuantizedBvhDoubleData"
+#else
+#define b3QuantizedBvhData b3QuantizedBvhFloatData
+#define b3OptimizedBvhNodeData b3OptimizedBvhNodeFloatData
+#define b3QuantizedBvhDataName "b3QuantizedBvhFloatData"
+#endif
+
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3QuantizedBvhNodeData.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3BvhSubtreeInfoData.h"
+
+//http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclang/html/vclrf__m128.asp
+
+//Note: currently we have 16 bytes per quantized node
+#define MAX_SUBTREE_SIZE_IN_BYTES 2048
+
+// 10 gives the potential for 1024 parts, with at most 2^21 (2097152) (minus one
+// actually) triangles each (since the sign bit is reserved
+#define MAX_NUM_PARTS_IN_BITS 10
+
+///b3QuantizedBvhNode is a compressed aabb node, 16 bytes.
+///Node can be used for leafnode or internal node. Leafnodes can point to 32-bit triangle index (non-negative range).
+B3_ATTRIBUTE_ALIGNED16(struct)
+b3QuantizedBvhNode : public b3QuantizedBvhNodeData
+{
+	B3_DECLARE_ALIGNED_ALLOCATOR();
+
+	bool isLeafNode() const
+	{
+		//skipindex is negative (internal node), triangleindex >=0 (leafnode)
+		return (m_escapeIndexOrTriangleIndex >= 0);
+	}
+	int getEscapeIndex() const
+	{
+		b3Assert(!isLeafNode());
+		return -m_escapeIndexOrTriangleIndex;
+	}
+	int getTriangleIndex() const
+	{
+		b3Assert(isLeafNode());
+		unsigned int x = 0;
+		unsigned int y = (~(x & 0)) << (31 - MAX_NUM_PARTS_IN_BITS);
+		// Get only the lower bits where the triangle index is stored
+		return (m_escapeIndexOrTriangleIndex & ~(y));
+	}
+	int getPartId() const
+	{
+		b3Assert(isLeafNode());
+		// Get only the highest bits where the part index is stored
+		return (m_escapeIndexOrTriangleIndex >> (31 - MAX_NUM_PARTS_IN_BITS));
+	}
+};
+
+/// b3OptimizedBvhNode contains both internal and leaf node information.
+/// Total node size is 44 bytes / node. You can use the compressed version of 16 bytes.
+B3_ATTRIBUTE_ALIGNED16(struct)
+b3OptimizedBvhNode
+{
+	B3_DECLARE_ALIGNED_ALLOCATOR();
+
+	//32 bytes
+	b3Vector3 m_aabbMinOrg;
+	b3Vector3 m_aabbMaxOrg;
+
+	//4
+	int m_escapeIndex;
+
+	//8
+	//for child nodes
+	int m_subPart;
+	int m_triangleIndex;
+
+	//pad the size to 64 bytes
+	char m_padding[20];
+};
+
+///b3BvhSubtreeInfo provides info to gather a subtree of limited size
+B3_ATTRIBUTE_ALIGNED16(class)
+b3BvhSubtreeInfo : public b3BvhSubtreeInfoData
+{
+public:
+	B3_DECLARE_ALIGNED_ALLOCATOR();
+
+	b3BvhSubtreeInfo()
+	{
+		//memset(&m_padding[0], 0, sizeof(m_padding));
+	}
+
+	void setAabbFromQuantizeNode(const b3QuantizedBvhNode& quantizedNode)
+	{
+		m_quantizedAabbMin[0] = quantizedNode.m_quantizedAabbMin[0];
+		m_quantizedAabbMin[1] = quantizedNode.m_quantizedAabbMin[1];
+		m_quantizedAabbMin[2] = quantizedNode.m_quantizedAabbMin[2];
+		m_quantizedAabbMax[0] = quantizedNode.m_quantizedAabbMax[0];
+		m_quantizedAabbMax[1] = quantizedNode.m_quantizedAabbMax[1];
+		m_quantizedAabbMax[2] = quantizedNode.m_quantizedAabbMax[2];
+	}
+};
+
+class b3NodeOverlapCallback
+{
+public:
+	virtual ~b3NodeOverlapCallback(){};
+
+	virtual void processNode(int subPart, int triangleIndex) = 0;
+};
+
+#include "Bullet3Common/b3AlignedAllocator.h"
+#include "Bullet3Common/b3AlignedObjectArray.h"
+
+///for code readability:
+typedef b3AlignedObjectArray<b3OptimizedBvhNode> NodeArray;
+typedef b3AlignedObjectArray<b3QuantizedBvhNode> QuantizedNodeArray;
+typedef b3AlignedObjectArray<b3BvhSubtreeInfo> BvhSubtreeInfoArray;
+
+///The b3QuantizedBvh class stores an AABB tree that can be quickly traversed on CPU and Cell SPU.
+///It is used by the b3BvhTriangleMeshShape as midphase
+///It is recommended to use quantization for better performance and lower memory requirements.
+B3_ATTRIBUTE_ALIGNED16(class)
+b3QuantizedBvh
+{
+public:
+	enum b3TraversalMode
+	{
+		TRAVERSAL_STACKLESS = 0,
+		TRAVERSAL_STACKLESS_CACHE_FRIENDLY,
+		TRAVERSAL_RECURSIVE
+	};
+
+	b3Vector3 m_bvhAabbMin;
+	b3Vector3 m_bvhAabbMax;
+	b3Vector3 m_bvhQuantization;
+
+protected:
+	int m_bulletVersion;  //for serialization versioning. It could also be used to detect endianess.
+
+	int m_curNodeIndex;
+	//quantization data
+	bool m_useQuantization;
+
+	NodeArray m_leafNodes;
+	NodeArray m_contiguousNodes;
+	QuantizedNodeArray m_quantizedLeafNodes;
+	QuantizedNodeArray m_quantizedContiguousNodes;
+
+	b3TraversalMode m_traversalMode;
+	BvhSubtreeInfoArray m_SubtreeHeaders;
+
+	//This is only used for serialization so we don't have to add serialization directly to b3AlignedObjectArray
+	mutable int m_subtreeHeaderCount;
+
+	///two versions, one for quantized and normal nodes. This allows code-reuse while maintaining readability (no template/macro!)
+	///this might be refactored into a virtual, it is usually not calculated at run-time
+	void setInternalNodeAabbMin(int nodeIndex, const b3Vector3& aabbMin)
+	{
+		if (m_useQuantization)
+		{
+			quantize(&m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[0], aabbMin, 0);
+		}
+		else
+		{
+			m_contiguousNodes[nodeIndex].m_aabbMinOrg = aabbMin;
+		}
+	}
+	void setInternalNodeAabbMax(int nodeIndex, const b3Vector3& aabbMax)
+	{
+		if (m_useQuantization)
+		{
+			quantize(&m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[0], aabbMax, 1);
+		}
+		else
+		{
+			m_contiguousNodes[nodeIndex].m_aabbMaxOrg = aabbMax;
+		}
+	}
+
+	b3Vector3 getAabbMin(int nodeIndex) const
+	{
+		if (m_useQuantization)
+		{
+			return unQuantize(&m_quantizedLeafNodes[nodeIndex].m_quantizedAabbMin[0]);
+		}
+		//non-quantized
+		return m_leafNodes[nodeIndex].m_aabbMinOrg;
+	}
+	b3Vector3 getAabbMax(int nodeIndex) const
+	{
+		if (m_useQuantization)
+		{
+			return unQuantize(&m_quantizedLeafNodes[nodeIndex].m_quantizedAabbMax[0]);
+		}
+		//non-quantized
+		return m_leafNodes[nodeIndex].m_aabbMaxOrg;
+	}
+
+	void setInternalNodeEscapeIndex(int nodeIndex, int escapeIndex)
+	{
+		if (m_useQuantization)
+		{
+			m_quantizedContiguousNodes[nodeIndex].m_escapeIndexOrTriangleIndex = -escapeIndex;
+		}
+		else
+		{
+			m_contiguousNodes[nodeIndex].m_escapeIndex = escapeIndex;
+		}
+	}
+
+	void mergeInternalNodeAabb(int nodeIndex, const b3Vector3& newAabbMin, const b3Vector3& newAabbMax)
+	{
+		if (m_useQuantization)
+		{
+			unsigned short int quantizedAabbMin[3];
+			unsigned short int quantizedAabbMax[3];
+			quantize(quantizedAabbMin, newAabbMin, 0);
+			quantize(quantizedAabbMax, newAabbMax, 1);
+			for (int i = 0; i < 3; i++)
+			{
+				if (m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[i] > quantizedAabbMin[i])
+					m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[i] = quantizedAabbMin[i];
+
+				if (m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[i] < quantizedAabbMax[i])
+					m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[i] = quantizedAabbMax[i];
+			}
+		}
+		else
+		{
+			//non-quantized
+			m_contiguousNodes[nodeIndex].m_aabbMinOrg.setMin(newAabbMin);
+			m_contiguousNodes[nodeIndex].m_aabbMaxOrg.setMax(newAabbMax);
+		}
+	}
+
+	void swapLeafNodes(int firstIndex, int secondIndex);
+
+	void assignInternalNodeFromLeafNode(int internalNode, int leafNodeIndex);
+
+protected:
+	void buildTree(int startIndex, int endIndex);
+
+	int calcSplittingAxis(int startIndex, int endIndex);
+
+	int sortAndCalcSplittingIndex(int startIndex, int endIndex, int splitAxis);
+
+	void walkStacklessTree(b3NodeOverlapCallback * nodeCallback, const b3Vector3& aabbMin, const b3Vector3& aabbMax) const;
+
+	void walkStacklessQuantizedTreeAgainstRay(b3NodeOverlapCallback * nodeCallback, const b3Vector3& raySource, const b3Vector3& rayTarget, const b3Vector3& aabbMin, const b3Vector3& aabbMax, int startNodeIndex, int endNodeIndex) const;
+	void walkStacklessQuantizedTree(b3NodeOverlapCallback * nodeCallback, unsigned short int* quantizedQueryAabbMin, unsigned short int* quantizedQueryAabbMax, int startNodeIndex, int endNodeIndex) const;
+	void walkStacklessTreeAgainstRay(b3NodeOverlapCallback * nodeCallback, const b3Vector3& raySource, const b3Vector3& rayTarget, const b3Vector3& aabbMin, const b3Vector3& aabbMax, int startNodeIndex, int endNodeIndex) const;
+
+	///tree traversal designed for small-memory processors like PS3 SPU
+	void walkStacklessQuantizedTreeCacheFriendly(b3NodeOverlapCallback * nodeCallback, unsigned short int* quantizedQueryAabbMin, unsigned short int* quantizedQueryAabbMax) const;
+
+	///use the 16-byte stackless 'skipindex' node tree to do a recursive traversal
+	void walkRecursiveQuantizedTreeAgainstQueryAabb(const b3QuantizedBvhNode* currentNode, b3NodeOverlapCallback* nodeCallback, unsigned short int* quantizedQueryAabbMin, unsigned short int* quantizedQueryAabbMax) const;
+
+	///use the 16-byte stackless 'skipindex' node tree to do a recursive traversal
+	void walkRecursiveQuantizedTreeAgainstQuantizedTree(const b3QuantizedBvhNode* treeNodeA, const b3QuantizedBvhNode* treeNodeB, b3NodeOverlapCallback* nodeCallback) const;
+
+	void updateSubtreeHeaders(int leftChildNodexIndex, int rightChildNodexIndex);
+
+public:
+	B3_DECLARE_ALIGNED_ALLOCATOR();
+
+	b3QuantizedBvh();
+
+	virtual ~b3QuantizedBvh();
+
+	///***************************************** expert/internal use only *************************
+	void setQuantizationValues(const b3Vector3& bvhAabbMin, const b3Vector3& bvhAabbMax, b3Scalar quantizationMargin = b3Scalar(1.0));
+	QuantizedNodeArray& getLeafNodeArray() { return m_quantizedLeafNodes; }
+	///buildInternal is expert use only: assumes that setQuantizationValues and LeafNodeArray are initialized
+	void buildInternal();
+	///***************************************** expert/internal use only *************************
+
+	void reportAabbOverlappingNodex(b3NodeOverlapCallback * nodeCallback, const b3Vector3& aabbMin, const b3Vector3& aabbMax) const;
+	void reportRayOverlappingNodex(b3NodeOverlapCallback * nodeCallback, const b3Vector3& raySource, const b3Vector3& rayTarget) const;
+	void reportBoxCastOverlappingNodex(b3NodeOverlapCallback * nodeCallback, const b3Vector3& raySource, const b3Vector3& rayTarget, const b3Vector3& aabbMin, const b3Vector3& aabbMax) const;
+
+	B3_FORCE_INLINE void quantize(unsigned short* out, const b3Vector3& point, int isMax) const
+	{
+		b3Assert(m_useQuantization);
+
+		b3Assert(point.getX() <= m_bvhAabbMax.getX());
+		b3Assert(point.getY() <= m_bvhAabbMax.getY());
+		b3Assert(point.getZ() <= m_bvhAabbMax.getZ());
+
+		b3Assert(point.getX() >= m_bvhAabbMin.getX());
+		b3Assert(point.getY() >= m_bvhAabbMin.getY());
+		b3Assert(point.getZ() >= m_bvhAabbMin.getZ());
+
+		b3Vector3 v = (point - m_bvhAabbMin) * m_bvhQuantization;
+		///Make sure rounding is done in a way that unQuantize(quantizeWithClamp(...)) is conservative
+		///end-points always set the first bit, so that they are sorted properly (so that neighbouring AABBs overlap properly)
+		///@todo: double-check this
+		if (isMax)
+		{
+			out[0] = (unsigned short)(((unsigned short)(v.getX() + b3Scalar(1.)) | 1));
+			out[1] = (unsigned short)(((unsigned short)(v.getY() + b3Scalar(1.)) | 1));
+			out[2] = (unsigned short)(((unsigned short)(v.getZ() + b3Scalar(1.)) | 1));
+		}
+		else
+		{
+			out[0] = (unsigned short)(((unsigned short)(v.getX()) & 0xfffe));
+			out[1] = (unsigned short)(((unsigned short)(v.getY()) & 0xfffe));
+			out[2] = (unsigned short)(((unsigned short)(v.getZ()) & 0xfffe));
+		}
+
+#ifdef DEBUG_CHECK_DEQUANTIZATION
+		b3Vector3 newPoint = unQuantize(out);
+		if (isMax)
+		{
+			if (newPoint.getX() < point.getX())
+			{
+				printf("unconservative X, diffX = %f, oldX=%f,newX=%f\n", newPoint.getX() - point.getX(), newPoint.getX(), point.getX());
+			}
+			if (newPoint.getY() < point.getY())
+			{
+				printf("unconservative Y, diffY = %f, oldY=%f,newY=%f\n", newPoint.getY() - point.getY(), newPoint.getY(), point.getY());
+			}
+			if (newPoint.getZ() < point.getZ())
+			{
+				printf("unconservative Z, diffZ = %f, oldZ=%f,newZ=%f\n", newPoint.getZ() - point.getZ(), newPoint.getZ(), point.getZ());
+			}
+		}
+		else
+		{
+			if (newPoint.getX() > point.getX())
+			{
+				printf("unconservative X, diffX = %f, oldX=%f,newX=%f\n", newPoint.getX() - point.getX(), newPoint.getX(), point.getX());
+			}
+			if (newPoint.getY() > point.getY())
+			{
+				printf("unconservative Y, diffY = %f, oldY=%f,newY=%f\n", newPoint.getY() - point.getY(), newPoint.getY(), point.getY());
+			}
+			if (newPoint.getZ() > point.getZ())
+			{
+				printf("unconservative Z, diffZ = %f, oldZ=%f,newZ=%f\n", newPoint.getZ() - point.getZ(), newPoint.getZ(), point.getZ());
+			}
+		}
+#endif  //DEBUG_CHECK_DEQUANTIZATION
+	}
+
+	B3_FORCE_INLINE void quantizeWithClamp(unsigned short* out, const b3Vector3& point2, int isMax) const
+	{
+		b3Assert(m_useQuantization);
+
+		b3Vector3 clampedPoint(point2);
+		clampedPoint.setMax(m_bvhAabbMin);
+		clampedPoint.setMin(m_bvhAabbMax);
+
+		quantize(out, clampedPoint, isMax);
+	}
+
+	B3_FORCE_INLINE b3Vector3 unQuantize(const unsigned short* vecIn) const
+	{
+		b3Vector3 vecOut;
+		vecOut.setValue(
+			(b3Scalar)(vecIn[0]) / (m_bvhQuantization.getX()),
+			(b3Scalar)(vecIn[1]) / (m_bvhQuantization.getY()),
+			(b3Scalar)(vecIn[2]) / (m_bvhQuantization.getZ()));
+		vecOut += m_bvhAabbMin;
+		return vecOut;
+	}
+
+	///setTraversalMode let's you choose between stackless, recursive or stackless cache friendly tree traversal. Note this is only implemented for quantized trees.
+	void setTraversalMode(b3TraversalMode traversalMode)
+	{
+		m_traversalMode = traversalMode;
+	}
+
+	B3_FORCE_INLINE QuantizedNodeArray& getQuantizedNodeArray()
+	{
+		return m_quantizedContiguousNodes;
+	}
+
+	B3_FORCE_INLINE BvhSubtreeInfoArray& getSubtreeInfoArray()
+	{
+		return m_SubtreeHeaders;
+	}
+
+	////////////////////////////////////////////////////////////////////
+
+	/////Calculate space needed to store BVH for serialization
+	unsigned calculateSerializeBufferSize() const;
+
+	/// Data buffer MUST be 16 byte aligned
+	virtual bool serialize(void* o_alignedDataBuffer, unsigned i_dataBufferSize, bool i_swapEndian) const;
+
+	///deSerializeInPlace loads and initializes a BVH from a buffer in memory 'in place'
+	static b3QuantizedBvh* deSerializeInPlace(void* i_alignedDataBuffer, unsigned int i_dataBufferSize, bool i_swapEndian);
+
+	static unsigned int getAlignmentSerializationPadding();
+	//////////////////////////////////////////////////////////////////////
+
+	virtual int calculateSerializeBufferSizeNew() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	virtual const char* serialize(void* dataBuffer, b3Serializer* serializer) const;
+
+	virtual void deSerializeFloat(struct b3QuantizedBvhFloatData & quantizedBvhFloatData);
+
+	virtual void deSerializeDouble(struct b3QuantizedBvhDoubleData & quantizedBvhDoubleData);
+
+	////////////////////////////////////////////////////////////////////
+
+	B3_FORCE_INLINE bool isQuantized()
+	{
+		return m_useQuantization;
+	}
+
+private:
+	// Special "copy" constructor that allows for in-place deserialization
+	// Prevents b3Vector3's default constructor from being called, but doesn't inialize much else
+	// ownsMemory should most likely be false if deserializing, and if you are not, don't call this (it also changes the function signature, which we need)
+	b3QuantizedBvh(b3QuantizedBvh & other, bool ownsMemory);
+};
+
+struct b3OptimizedBvhNodeFloatData
+{
+	b3Vector3FloatData m_aabbMinOrg;
+	b3Vector3FloatData m_aabbMaxOrg;
+	int m_escapeIndex;
+	int m_subPart;
+	int m_triangleIndex;
+	char m_pad[4];
+};
+
+struct b3OptimizedBvhNodeDoubleData
+{
+	b3Vector3DoubleData m_aabbMinOrg;
+	b3Vector3DoubleData m_aabbMaxOrg;
+	int m_escapeIndex;
+	int m_subPart;
+	int m_triangleIndex;
+	char m_pad[4];
+};
+
+struct b3QuantizedBvhFloatData
+{
+	b3Vector3FloatData m_bvhAabbMin;
+	b3Vector3FloatData m_bvhAabbMax;
+	b3Vector3FloatData m_bvhQuantization;
+	int m_curNodeIndex;
+	int m_useQuantization;
+	int m_numContiguousLeafNodes;
+	int m_numQuantizedContiguousNodes;
+	b3OptimizedBvhNodeFloatData* m_contiguousNodesPtr;
+	b3QuantizedBvhNodeData* m_quantizedContiguousNodesPtr;
+	b3BvhSubtreeInfoData* m_subTreeInfoPtr;
+	int m_traversalMode;
+	int m_numSubtreeHeaders;
+};
+
+struct b3QuantizedBvhDoubleData
+{
+	b3Vector3DoubleData m_bvhAabbMin;
+	b3Vector3DoubleData m_bvhAabbMax;
+	b3Vector3DoubleData m_bvhQuantization;
+	int m_curNodeIndex;
+	int m_useQuantization;
+	int m_numContiguousLeafNodes;
+	int m_numQuantizedContiguousNodes;
+	b3OptimizedBvhNodeDoubleData* m_contiguousNodesPtr;
+	b3QuantizedBvhNodeData* m_quantizedContiguousNodesPtr;
+
+	int m_traversalMode;
+	int m_numSubtreeHeaders;
+	b3BvhSubtreeInfoData* m_subTreeInfoPtr;
+};
+
+B3_FORCE_INLINE int b3QuantizedBvh::calculateSerializeBufferSizeNew() const
+{
+	return sizeof(b3QuantizedBvhData);
+}
+
+#endif  //B3_QUANTIZED_BVH_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3StridingMeshInterface.h b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3StridingMeshInterface.h
new file mode 100644
index 00000000..2b1e63be
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3StridingMeshInterface.h
@@ -0,0 +1,158 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_STRIDING_MESHINTERFACE_H
+#define B3_STRIDING_MESHINTERFACE_H
+
+#include "Bullet3Common/b3Vector3.h"
+#include "b3TriangleCallback.h"
+//#include "b3ConcaveShape.h"
+
+enum PHY_ScalarType
+{
+	PHY_FLOAT,
+	PHY_DOUBLE,
+	PHY_INTEGER,
+	PHY_SHORT,
+	PHY_FIXEDPOINT88,
+	PHY_UCHAR
+};
+
+///	The b3StridingMeshInterface is the interface class for high performance generic access to triangle meshes, used in combination with b3BvhTriangleMeshShape and some other collision shapes.
+/// Using index striding of 3*sizeof(integer) it can use triangle arrays, using index striding of 1*sizeof(integer) it can handle triangle strips.
+/// It allows for sharing graphics and collision meshes. Also it provides locking/unlocking of graphics meshes that are in gpu memory.
+B3_ATTRIBUTE_ALIGNED16(class)
+b3StridingMeshInterface
+{
+protected:
+	b3Vector3 m_scaling;
+
+public:
+	B3_DECLARE_ALIGNED_ALLOCATOR();
+
+	b3StridingMeshInterface() : m_scaling(b3MakeVector3(b3Scalar(1.), b3Scalar(1.), b3Scalar(1.)))
+	{
+	}
+
+	virtual ~b3StridingMeshInterface();
+
+	virtual void InternalProcessAllTriangles(b3InternalTriangleIndexCallback * callback, const b3Vector3& aabbMin, const b3Vector3& aabbMax) const;
+
+	///brute force method to calculate aabb
+	void calculateAabbBruteForce(b3Vector3 & aabbMin, b3Vector3 & aabbMax);
+
+	/// get read and write access to a subpart of a triangle mesh
+	/// this subpart has a continuous array of vertices and indices
+	/// in this way the mesh can be handled as chunks of memory with striding
+	/// very similar to OpenGL vertexarray support
+	/// make a call to unLockVertexBase when the read and write access is finished
+	virtual void getLockedVertexIndexBase(unsigned char** vertexbase, int& numverts, PHY_ScalarType& type, int& stride, unsigned char** indexbase, int& indexstride, int& numfaces, PHY_ScalarType& indicestype, int subpart = 0) = 0;
+
+	virtual void getLockedReadOnlyVertexIndexBase(const unsigned char** vertexbase, int& numverts, PHY_ScalarType& type, int& stride, const unsigned char** indexbase, int& indexstride, int& numfaces, PHY_ScalarType& indicestype, int subpart = 0) const = 0;
+
+	/// unLockVertexBase finishes the access to a subpart of the triangle mesh
+	/// make a call to unLockVertexBase when the read and write access (using getLockedVertexIndexBase) is finished
+	virtual void unLockVertexBase(int subpart) = 0;
+
+	virtual void unLockReadOnlyVertexBase(int subpart) const = 0;
+
+	/// getNumSubParts returns the number of separate subparts
+	/// each subpart has a continuous array of vertices and indices
+	virtual int getNumSubParts() const = 0;
+
+	virtual void preallocateVertices(int numverts) = 0;
+	virtual void preallocateIndices(int numindices) = 0;
+
+	virtual bool hasPremadeAabb() const { return false; }
+	virtual void setPremadeAabb(const b3Vector3& aabbMin, const b3Vector3& aabbMax) const
+	{
+		(void)aabbMin;
+		(void)aabbMax;
+	}
+	virtual void getPremadeAabb(b3Vector3 * aabbMin, b3Vector3 * aabbMax) const
+	{
+		(void)aabbMin;
+		(void)aabbMax;
+	}
+
+	const b3Vector3& getScaling() const
+	{
+		return m_scaling;
+	}
+	void setScaling(const b3Vector3& scaling)
+	{
+		m_scaling = scaling;
+	}
+
+	virtual int calculateSerializeBufferSize() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	//virtual	const char*	serialize(void* dataBuffer, b3Serializer* serializer) const;
+};
+
+struct b3IntIndexData
+{
+	int m_value;
+};
+
+struct b3ShortIntIndexData
+{
+	short m_value;
+	char m_pad[2];
+};
+
+struct b3ShortIntIndexTripletData
+{
+	short m_values[3];
+	char m_pad[2];
+};
+
+struct b3CharIndexTripletData
+{
+	unsigned char m_values[3];
+	char m_pad;
+};
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct b3MeshPartData
+{
+	b3Vector3FloatData* m_vertices3f;
+	b3Vector3DoubleData* m_vertices3d;
+
+	b3IntIndexData* m_indices32;
+	b3ShortIntIndexTripletData* m_3indices16;
+	b3CharIndexTripletData* m_3indices8;
+
+	b3ShortIntIndexData* m_indices16;  //backwards compatibility
+
+	int m_numTriangles;  //length of m_indices = m_numTriangles
+	int m_numVertices;
+};
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct b3StridingMeshInterfaceData
+{
+	b3MeshPartData* m_meshPartsPtr;
+	b3Vector3FloatData m_scaling;
+	int m_numMeshParts;
+	char m_padding[4];
+};
+
+B3_FORCE_INLINE int b3StridingMeshInterface::calculateSerializeBufferSize() const
+{
+	return sizeof(b3StridingMeshInterfaceData);
+}
+
+#endif  //B3_STRIDING_MESHINTERFACE_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3SupportMappings.h b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3SupportMappings.h
new file mode 100644
index 00000000..9ca1e229
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3SupportMappings.h
@@ -0,0 +1,34 @@
+
+#ifndef B3_SUPPORT_MAPPINGS_H
+#define B3_SUPPORT_MAPPINGS_H
+
+#include "Bullet3Common/b3Transform.h"
+#include "Bullet3Common/b3AlignedObjectArray.h"
+#include "b3VectorFloat4.h"
+
+struct b3GjkPairDetector;
+
+inline b3Vector3 localGetSupportVertexWithMargin(const float4& supportVec, const struct b3ConvexPolyhedronData* hull,
+												 const b3AlignedObjectArray<b3Vector3>& verticesA, b3Scalar margin)
+{
+	b3Vector3 supVec = b3MakeVector3(b3Scalar(0.), b3Scalar(0.), b3Scalar(0.));
+	b3Scalar maxDot = b3Scalar(-B3_LARGE_FLOAT);
+
+	// Here we take advantage of dot(a, b*c) = dot(a*b, c).  Note: This is true mathematically, but not numerically.
+	if (0 < hull->m_numVertices)
+	{
+		const b3Vector3 scaled = supportVec;
+		int index = (int)scaled.maxDot(&verticesA[hull->m_vertexOffset], hull->m_numVertices, maxDot);
+		return verticesA[hull->m_vertexOffset + index];
+	}
+
+	return supVec;
+}
+
+inline b3Vector3 localGetSupportVertexWithoutMargin(const float4& supportVec, const struct b3ConvexPolyhedronData* hull,
+													const b3AlignedObjectArray<b3Vector3>& verticesA)
+{
+	return localGetSupportVertexWithMargin(supportVec, hull, verticesA, 0.f);
+}
+
+#endif  //B3_SUPPORT_MAPPINGS_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3TriangleCallback.h b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3TriangleCallback.h
new file mode 100644
index 00000000..a0fd3e7a
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3TriangleCallback.h
@@ -0,0 +1,37 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_TRIANGLE_CALLBACK_H
+#define B3_TRIANGLE_CALLBACK_H
+
+#include "Bullet3Common/b3Vector3.h"
+
+///The b3TriangleCallback provides a callback for each overlapping triangle when calling processAllTriangles.
+///This callback is called by processAllTriangles for all b3ConcaveShape derived class, such as  b3BvhTriangleMeshShape, b3StaticPlaneShape and b3HeightfieldTerrainShape.
+class b3TriangleCallback
+{
+public:
+	virtual ~b3TriangleCallback();
+	virtual void processTriangle(b3Vector3* triangle, int partId, int triangleIndex) = 0;
+};
+
+class b3InternalTriangleIndexCallback
+{
+public:
+	virtual ~b3InternalTriangleIndexCallback();
+	virtual void internalProcessTriangleIndex(b3Vector3* triangle, int partId, int triangleIndex) = 0;
+};
+
+#endif  //B3_TRIANGLE_CALLBACK_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3TriangleIndexVertexArray.h b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3TriangleIndexVertexArray.h
new file mode 100644
index 00000000..57cbf03d
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3TriangleIndexVertexArray.h
@@ -0,0 +1,128 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_TRIANGLE_INDEX_VERTEX_ARRAY_H
+#define B3_TRIANGLE_INDEX_VERTEX_ARRAY_H
+
+#include "b3StridingMeshInterface.h"
+#include "Bullet3Common/b3AlignedObjectArray.h"
+#include "Bullet3Common/b3Scalar.h"
+
+///The b3IndexedMesh indexes a single vertex and index array. Multiple b3IndexedMesh objects can be passed into a b3TriangleIndexVertexArray using addIndexedMesh.
+///Instead of the number of indices, we pass the number of triangles.
+B3_ATTRIBUTE_ALIGNED16(struct)
+b3IndexedMesh
+{
+	B3_DECLARE_ALIGNED_ALLOCATOR();
+
+	int m_numTriangles;
+	const unsigned char* m_triangleIndexBase;
+	// Size in byte of the indices for one triangle (3*sizeof(index_type) if the indices are tightly packed)
+	int m_triangleIndexStride;
+	int m_numVertices;
+	const unsigned char* m_vertexBase;
+	// Size of a vertex, in bytes
+	int m_vertexStride;
+
+	// The index type is set when adding an indexed mesh to the
+	// b3TriangleIndexVertexArray, do not set it manually
+	PHY_ScalarType m_indexType;
+
+	// The vertex type has a default type similar to Bullet's precision mode (float or double)
+	// but can be set manually if you for example run Bullet with double precision but have
+	// mesh data in single precision..
+	PHY_ScalarType m_vertexType;
+
+	b3IndexedMesh()
+		: m_indexType(PHY_INTEGER),
+#ifdef B3_USE_DOUBLE_PRECISION
+		  m_vertexType(PHY_DOUBLE)
+#else   // B3_USE_DOUBLE_PRECISION
+		  m_vertexType(PHY_FLOAT)
+#endif  // B3_USE_DOUBLE_PRECISION
+	{
+	}
+};
+
+typedef b3AlignedObjectArray<b3IndexedMesh> IndexedMeshArray;
+
+///The b3TriangleIndexVertexArray allows to access multiple triangle meshes, by indexing into existing triangle/index arrays.
+///Additional meshes can be added using addIndexedMesh
+///No duplcate is made of the vertex/index data, it only indexes into external vertex/index arrays.
+///So keep those arrays around during the lifetime of this b3TriangleIndexVertexArray.
+B3_ATTRIBUTE_ALIGNED16(class)
+b3TriangleIndexVertexArray : public b3StridingMeshInterface
+{
+protected:
+	IndexedMeshArray m_indexedMeshes;
+	int m_pad[2];
+	mutable int m_hasAabb;  // using int instead of bool to maintain alignment
+	mutable b3Vector3 m_aabbMin;
+	mutable b3Vector3 m_aabbMax;
+
+public:
+	B3_DECLARE_ALIGNED_ALLOCATOR();
+
+	b3TriangleIndexVertexArray() : m_hasAabb(0)
+	{
+	}
+
+	virtual ~b3TriangleIndexVertexArray();
+
+	//just to be backwards compatible
+	b3TriangleIndexVertexArray(int numTriangles, int* triangleIndexBase, int triangleIndexStride, int numVertices, b3Scalar* vertexBase, int vertexStride);
+
+	void addIndexedMesh(const b3IndexedMesh& mesh, PHY_ScalarType indexType = PHY_INTEGER)
+	{
+		m_indexedMeshes.push_back(mesh);
+		m_indexedMeshes[m_indexedMeshes.size() - 1].m_indexType = indexType;
+	}
+
+	virtual void getLockedVertexIndexBase(unsigned char** vertexbase, int& numverts, PHY_ScalarType& type, int& vertexStride, unsigned char** indexbase, int& indexstride, int& numfaces, PHY_ScalarType& indicestype, int subpart = 0);
+
+	virtual void getLockedReadOnlyVertexIndexBase(const unsigned char** vertexbase, int& numverts, PHY_ScalarType& type, int& vertexStride, const unsigned char** indexbase, int& indexstride, int& numfaces, PHY_ScalarType& indicestype, int subpart = 0) const;
+
+	/// unLockVertexBase finishes the access to a subpart of the triangle mesh
+	/// make a call to unLockVertexBase when the read and write access (using getLockedVertexIndexBase) is finished
+	virtual void unLockVertexBase(int subpart) { (void)subpart; }
+
+	virtual void unLockReadOnlyVertexBase(int subpart) const { (void)subpart; }
+
+	/// getNumSubParts returns the number of separate subparts
+	/// each subpart has a continuous array of vertices and indices
+	virtual int getNumSubParts() const
+	{
+		return (int)m_indexedMeshes.size();
+	}
+
+	IndexedMeshArray& getIndexedMeshArray()
+	{
+		return m_indexedMeshes;
+	}
+
+	const IndexedMeshArray& getIndexedMeshArray() const
+	{
+		return m_indexedMeshes;
+	}
+
+	virtual void preallocateVertices(int numverts) { (void)numverts; }
+	virtual void preallocateIndices(int numindices) { (void)numindices; }
+
+	virtual bool hasPremadeAabb() const;
+	virtual void setPremadeAabb(const b3Vector3& aabbMin, const b3Vector3& aabbMax) const;
+	virtual void getPremadeAabb(b3Vector3 * aabbMin, b3Vector3 * aabbMax) const;
+};
+
+#endif  //B3_TRIANGLE_INDEX_VERTEX_ARRAY_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3VectorFloat4.h b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3VectorFloat4.h
new file mode 100644
index 00000000..5cc4b5a6
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3VectorFloat4.h
@@ -0,0 +1,10 @@
+#ifndef B3_VECTOR_FLOAT4_H
+#define B3_VECTOR_FLOAT4_H
+
+#include "Bullet3Common/b3Transform.h"
+
+//#define cross3(a,b) (a.cross(b))
+#define float4 b3Vector3
+//#define make_float4(x,y,z,w) b3Vector4(x,y,z,w)
+
+#endif  //B3_VECTOR_FLOAT4_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3VoronoiSimplexSolver.h b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3VoronoiSimplexSolver.h
new file mode 100644
index 00000000..b40b1699
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/b3VoronoiSimplexSolver.h
@@ -0,0 +1,164 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_VORONOI_SIMPLEX_SOLVER_H
+#define B3_VORONOI_SIMPLEX_SOLVER_H
+
+#include "Bullet3Common/b3Vector3.h"
+
+#define VORONOI_SIMPLEX_MAX_VERTS 5
+
+///disable next define, or use defaultCollisionConfiguration->getSimplexSolver()->setEqualVertexThreshold(0.f) to disable/configure
+//#define BT_USE_EQUAL_VERTEX_THRESHOLD
+#define VORONOI_DEFAULT_EQUAL_VERTEX_THRESHOLD 0.0001f
+
+struct b3UsageBitfield
+{
+	b3UsageBitfield()
+	{
+		reset();
+	}
+
+	void reset()
+	{
+		usedVertexA = false;
+		usedVertexB = false;
+		usedVertexC = false;
+		usedVertexD = false;
+	}
+	unsigned short usedVertexA : 1;
+	unsigned short usedVertexB : 1;
+	unsigned short usedVertexC : 1;
+	unsigned short usedVertexD : 1;
+	unsigned short unused1 : 1;
+	unsigned short unused2 : 1;
+	unsigned short unused3 : 1;
+	unsigned short unused4 : 1;
+};
+
+struct b3SubSimplexClosestResult
+{
+	b3Vector3 m_closestPointOnSimplex;
+	//MASK for m_usedVertices
+	//stores the simplex vertex-usage, using the MASK,
+	// if m_usedVertices & MASK then the related vertex is used
+	b3UsageBitfield m_usedVertices;
+	b3Scalar m_barycentricCoords[4];
+	bool m_degenerate;
+
+	void reset()
+	{
+		m_degenerate = false;
+		setBarycentricCoordinates();
+		m_usedVertices.reset();
+	}
+	bool isValid()
+	{
+		bool valid = (m_barycentricCoords[0] >= b3Scalar(0.)) &&
+					 (m_barycentricCoords[1] >= b3Scalar(0.)) &&
+					 (m_barycentricCoords[2] >= b3Scalar(0.)) &&
+					 (m_barycentricCoords[3] >= b3Scalar(0.));
+
+		return valid;
+	}
+	void setBarycentricCoordinates(b3Scalar a = b3Scalar(0.), b3Scalar b = b3Scalar(0.), b3Scalar c = b3Scalar(0.), b3Scalar d = b3Scalar(0.))
+	{
+		m_barycentricCoords[0] = a;
+		m_barycentricCoords[1] = b;
+		m_barycentricCoords[2] = c;
+		m_barycentricCoords[3] = d;
+	}
+};
+
+/// b3VoronoiSimplexSolver is an implementation of the closest point distance algorithm from a 1-4 points simplex to the origin.
+/// Can be used with GJK, as an alternative to Johnson distance algorithm.
+
+B3_ATTRIBUTE_ALIGNED16(class)
+b3VoronoiSimplexSolver
+{
+public:
+	B3_DECLARE_ALIGNED_ALLOCATOR();
+
+	int m_numVertices;
+
+	b3Vector3 m_simplexVectorW[VORONOI_SIMPLEX_MAX_VERTS];
+	b3Vector3 m_simplexPointsP[VORONOI_SIMPLEX_MAX_VERTS];
+	b3Vector3 m_simplexPointsQ[VORONOI_SIMPLEX_MAX_VERTS];
+
+	b3Vector3 m_cachedP1;
+	b3Vector3 m_cachedP2;
+	b3Vector3 m_cachedV;
+	b3Vector3 m_lastW;
+
+	b3Scalar m_equalVertexThreshold;
+	bool m_cachedValidClosest;
+
+	b3SubSimplexClosestResult m_cachedBC;
+
+	bool m_needsUpdate;
+
+	void removeVertex(int index);
+	void reduceVertices(const b3UsageBitfield& usedVerts);
+	bool updateClosestVectorAndPoints();
+
+	bool closestPtPointTetrahedron(const b3Vector3& p, const b3Vector3& a, const b3Vector3& b, const b3Vector3& c, const b3Vector3& d, b3SubSimplexClosestResult& finalResult);
+	int pointOutsideOfPlane(const b3Vector3& p, const b3Vector3& a, const b3Vector3& b, const b3Vector3& c, const b3Vector3& d);
+	bool closestPtPointTriangle(const b3Vector3& p, const b3Vector3& a, const b3Vector3& b, const b3Vector3& c, b3SubSimplexClosestResult& result);
+
+public:
+	b3VoronoiSimplexSolver()
+		: m_equalVertexThreshold(VORONOI_DEFAULT_EQUAL_VERTEX_THRESHOLD)
+	{
+	}
+	void reset();
+
+	void addVertex(const b3Vector3& w, const b3Vector3& p, const b3Vector3& q);
+
+	void setEqualVertexThreshold(b3Scalar threshold)
+	{
+		m_equalVertexThreshold = threshold;
+	}
+
+	b3Scalar getEqualVertexThreshold() const
+	{
+		return m_equalVertexThreshold;
+	}
+
+	bool closest(b3Vector3 & v);
+
+	b3Scalar maxVertex();
+
+	bool fullSimplex() const
+	{
+		return (m_numVertices == 4);
+	}
+
+	int getSimplex(b3Vector3 * pBuf, b3Vector3 * qBuf, b3Vector3 * yBuf) const;
+
+	bool inSimplex(const b3Vector3& w);
+
+	void backup_closest(b3Vector3 & v);
+
+	bool emptySimplex() const;
+
+	void compute_points(b3Vector3 & p1, b3Vector3 & p2);
+
+	int numVertices() const
+	{
+		return m_numVertices;
+	}
+};
+
+#endif  //B3_VORONOI_SIMPLEX_SOLVER_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/kernels/bvhTraversal.h b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/kernels/bvhTraversal.h
new file mode 100644
index 00000000..f1df8a69
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/kernels/bvhTraversal.h
@@ -0,0 +1,257 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* bvhTraversalKernelCL =
+	"//keep this enum in sync with the CPU version (in btCollidable.h)\n"
+	"//written by Erwin Coumans\n"
+	"#define SHAPE_CONVEX_HULL 3\n"
+	"#define SHAPE_CONCAVE_TRIMESH 5\n"
+	"#define TRIANGLE_NUM_CONVEX_FACES 5\n"
+	"#define SHAPE_COMPOUND_OF_CONVEX_HULLS 6\n"
+	"#define SHAPE_SPHERE 7\n"
+	"typedef unsigned int u32;\n"
+	"#define MAX_NUM_PARTS_IN_BITS 10\n"
+	"///btQuantizedBvhNode is a compressed aabb node, 16 bytes.\n"
+	"///Node can be used for leafnode or internal node. Leafnodes can point to 32-bit triangle index (non-negative range).\n"
+	"typedef struct\n"
+	"{\n"
+	"	//12 bytes\n"
+	"	unsigned short int	m_quantizedAabbMin[3];\n"
+	"	unsigned short int	m_quantizedAabbMax[3];\n"
+	"	//4 bytes\n"
+	"	int	m_escapeIndexOrTriangleIndex;\n"
+	"} btQuantizedBvhNode;\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4		m_aabbMin;\n"
+	"	float4		m_aabbMax;\n"
+	"	float4		m_quantization;\n"
+	"	int			m_numNodes;\n"
+	"	int			m_numSubTrees;\n"
+	"	int			m_nodeOffset;\n"
+	"	int			m_subTreeOffset;\n"
+	"} b3BvhInfo;\n"
+	"int	getTriangleIndex(const btQuantizedBvhNode* rootNode)\n"
+	"{\n"
+	"	unsigned int x=0;\n"
+	"	unsigned int y = (~(x&0))<<(31-MAX_NUM_PARTS_IN_BITS);\n"
+	"	// Get only the lower bits where the triangle index is stored\n"
+	"	return (rootNode->m_escapeIndexOrTriangleIndex&~(y));\n"
+	"}\n"
+	"int isLeaf(const btQuantizedBvhNode* rootNode)\n"
+	"{\n"
+	"	//skipindex is negative (internal node), triangleindex >=0 (leafnode)\n"
+	"	return (rootNode->m_escapeIndexOrTriangleIndex >= 0)? 1 : 0;\n"
+	"}\n"
+	"	\n"
+	"int getEscapeIndex(const btQuantizedBvhNode* rootNode)\n"
+	"{\n"
+	"	return -rootNode->m_escapeIndexOrTriangleIndex;\n"
+	"}\n"
+	"typedef struct\n"
+	"{\n"
+	"	//12 bytes\n"
+	"	unsigned short int	m_quantizedAabbMin[3];\n"
+	"	unsigned short int	m_quantizedAabbMax[3];\n"
+	"	//4 bytes, points to the root of the subtree\n"
+	"	int			m_rootNodeIndex;\n"
+	"	//4 bytes\n"
+	"	int			m_subtreeSize;\n"
+	"	int			m_padding[3];\n"
+	"} btBvhSubtreeInfo;\n"
+	"///keep this in sync with btCollidable.h\n"
+	"typedef struct\n"
+	"{\n"
+	"	int m_numChildShapes;\n"
+	"	int blaat2;\n"
+	"	int m_shapeType;\n"
+	"	int m_shapeIndex;\n"
+	"	\n"
+	"} btCollidableGpu;\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4	m_childPosition;\n"
+	"	float4	m_childOrientation;\n"
+	"	int m_shapeIndex;\n"
+	"	int m_unused0;\n"
+	"	int m_unused1;\n"
+	"	int m_unused2;\n"
+	"} btGpuChildShape;\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4 m_pos;\n"
+	"	float4 m_quat;\n"
+	"	float4 m_linVel;\n"
+	"	float4 m_angVel;\n"
+	"	u32 m_collidableIdx;\n"
+	"	float m_invMass;\n"
+	"	float m_restituitionCoeff;\n"
+	"	float m_frictionCoeff;\n"
+	"} BodyData;\n"
+	"typedef struct \n"
+	"{\n"
+	"	union\n"
+	"	{\n"
+	"		float4	m_min;\n"
+	"		float   m_minElems[4];\n"
+	"		int			m_minIndices[4];\n"
+	"	};\n"
+	"	union\n"
+	"	{\n"
+	"		float4	m_max;\n"
+	"		float   m_maxElems[4];\n"
+	"		int			m_maxIndices[4];\n"
+	"	};\n"
+	"} btAabbCL;\n"
+	"int testQuantizedAabbAgainstQuantizedAabb(\n"
+	"								const unsigned short int* aabbMin1,\n"
+	"								const unsigned short int* aabbMax1,\n"
+	"								const unsigned short int* aabbMin2,\n"
+	"								const unsigned short int* aabbMax2)\n"
+	"{\n"
+	"	//int overlap = 1;\n"
+	"	if (aabbMin1[0] > aabbMax2[0])\n"
+	"		return 0;\n"
+	"	if (aabbMax1[0] < aabbMin2[0])\n"
+	"		return 0;\n"
+	"	if (aabbMin1[1] > aabbMax2[1])\n"
+	"		return 0;\n"
+	"	if (aabbMax1[1] < aabbMin2[1])\n"
+	"		return 0;\n"
+	"	if (aabbMin1[2] > aabbMax2[2])\n"
+	"		return 0;\n"
+	"	if (aabbMax1[2] < aabbMin2[2])\n"
+	"		return 0;\n"
+	"	return 1;\n"
+	"	//overlap = ((aabbMin1[0] > aabbMax2[0]) || (aabbMax1[0] < aabbMin2[0])) ? 0 : overlap;\n"
+	"	//overlap = ((aabbMin1[2] > aabbMax2[2]) || (aabbMax1[2] < aabbMin2[2])) ? 0 : overlap;\n"
+	"	//overlap = ((aabbMin1[1] > aabbMax2[1]) || (aabbMax1[1] < aabbMin2[1])) ? 0 : overlap;\n"
+	"	//return overlap;\n"
+	"}\n"
+	"void quantizeWithClamp(unsigned short* out, float4 point2,int isMax, float4 bvhAabbMin, float4 bvhAabbMax, float4 bvhQuantization)\n"
+	"{\n"
+	"	float4 clampedPoint = max(point2,bvhAabbMin);\n"
+	"	clampedPoint = min (clampedPoint, bvhAabbMax);\n"
+	"	float4 v = (clampedPoint - bvhAabbMin) * bvhQuantization;\n"
+	"	if (isMax)\n"
+	"	{\n"
+	"		out[0] = (unsigned short) (((unsigned short)(v.x+1.f) | 1));\n"
+	"		out[1] = (unsigned short) (((unsigned short)(v.y+1.f) | 1));\n"
+	"		out[2] = (unsigned short) (((unsigned short)(v.z+1.f) | 1));\n"
+	"	} else\n"
+	"	{\n"
+	"		out[0] = (unsigned short) (((unsigned short)(v.x) & 0xfffe));\n"
+	"		out[1] = (unsigned short) (((unsigned short)(v.y) & 0xfffe));\n"
+	"		out[2] = (unsigned short) (((unsigned short)(v.z) & 0xfffe));\n"
+	"	}\n"
+	"}\n"
+	"// work-in-progress\n"
+	"__kernel void   bvhTraversalKernel( __global const int4* pairs, \n"
+	"									__global const BodyData* rigidBodies, \n"
+	"									__global const btCollidableGpu* collidables,\n"
+	"									__global btAabbCL* aabbs,\n"
+	"									__global int4* concavePairsOut,\n"
+	"									__global volatile int* numConcavePairsOut,\n"
+	"									__global const btBvhSubtreeInfo* subtreeHeadersRoot,\n"
+	"									__global const btQuantizedBvhNode* quantizedNodesRoot,\n"
+	"									__global const b3BvhInfo* bvhInfos,\n"
+	"									int numPairs,\n"
+	"									int maxNumConcavePairsCapacity)\n"
+	"{\n"
+	"	int id = get_global_id(0);\n"
+	"	if (id>=numPairs)\n"
+	"		return;\n"
+	"	\n"
+	"	int bodyIndexA = pairs[id].x;\n"
+	"	int bodyIndexB = pairs[id].y;\n"
+	"	int collidableIndexA = rigidBodies[bodyIndexA].m_collidableIdx;\n"
+	"	int collidableIndexB = rigidBodies[bodyIndexB].m_collidableIdx;\n"
+	"	\n"
+	"	//once the broadphase avoids static-static pairs, we can remove this test\n"
+	"	if ((rigidBodies[bodyIndexA].m_invMass==0) &&(rigidBodies[bodyIndexB].m_invMass==0))\n"
+	"	{\n"
+	"		return;\n"
+	"	}\n"
+	"		\n"
+	"	if (collidables[collidableIndexA].m_shapeType!=SHAPE_CONCAVE_TRIMESH)\n"
+	"		return;\n"
+	"	int shapeTypeB = collidables[collidableIndexB].m_shapeType;\n"
+	"		\n"
+	"	if (shapeTypeB!=SHAPE_CONVEX_HULL &&\n"
+	"		shapeTypeB!=SHAPE_SPHERE	&&\n"
+	"		shapeTypeB!=SHAPE_COMPOUND_OF_CONVEX_HULLS\n"
+	"		)\n"
+	"		return;\n"
+	"	b3BvhInfo bvhInfo = bvhInfos[collidables[collidableIndexA].m_numChildShapes];\n"
+	"	float4 bvhAabbMin = bvhInfo.m_aabbMin;\n"
+	"	float4 bvhAabbMax = bvhInfo.m_aabbMax;\n"
+	"	float4 bvhQuantization = bvhInfo.m_quantization;\n"
+	"	int numSubtreeHeaders = bvhInfo.m_numSubTrees;\n"
+	"	__global const btBvhSubtreeInfo* subtreeHeaders = &subtreeHeadersRoot[bvhInfo.m_subTreeOffset];\n"
+	"	__global const btQuantizedBvhNode* quantizedNodes = &quantizedNodesRoot[bvhInfo.m_nodeOffset];\n"
+	"	\n"
+	"	unsigned short int quantizedQueryAabbMin[3];\n"
+	"	unsigned short int quantizedQueryAabbMax[3];\n"
+	"	quantizeWithClamp(quantizedQueryAabbMin,aabbs[bodyIndexB].m_min,false,bvhAabbMin, bvhAabbMax,bvhQuantization);\n"
+	"	quantizeWithClamp(quantizedQueryAabbMax,aabbs[bodyIndexB].m_max,true ,bvhAabbMin, bvhAabbMax,bvhQuantization);\n"
+	"	\n"
+	"	for (int i=0;i<numSubtreeHeaders;i++)\n"
+	"	{\n"
+	"		btBvhSubtreeInfo subtree = subtreeHeaders[i];\n"
+	"				\n"
+	"		int overlap = testQuantizedAabbAgainstQuantizedAabb(quantizedQueryAabbMin,quantizedQueryAabbMax,subtree.m_quantizedAabbMin,subtree.m_quantizedAabbMax);\n"
+	"		if (overlap != 0)\n"
+	"		{\n"
+	"			int startNodeIndex = subtree.m_rootNodeIndex;\n"
+	"			int endNodeIndex = subtree.m_rootNodeIndex+subtree.m_subtreeSize;\n"
+	"			int curIndex = startNodeIndex;\n"
+	"			int escapeIndex;\n"
+	"			int isLeafNode;\n"
+	"			int aabbOverlap;\n"
+	"			while (curIndex < endNodeIndex)\n"
+	"			{\n"
+	"				btQuantizedBvhNode rootNode = quantizedNodes[curIndex];\n"
+	"				aabbOverlap = testQuantizedAabbAgainstQuantizedAabb(quantizedQueryAabbMin,quantizedQueryAabbMax,rootNode.m_quantizedAabbMin,rootNode.m_quantizedAabbMax);\n"
+	"				isLeafNode = isLeaf(&rootNode);\n"
+	"				if (aabbOverlap)\n"
+	"				{\n"
+	"					if (isLeafNode)\n"
+	"					{\n"
+	"						int triangleIndex = getTriangleIndex(&rootNode);\n"
+	"						if (shapeTypeB==SHAPE_COMPOUND_OF_CONVEX_HULLS)\n"
+	"						{\n"
+	"								int numChildrenB = collidables[collidableIndexB].m_numChildShapes;\n"
+	"								int pairIdx = atomic_add(numConcavePairsOut,numChildrenB);\n"
+	"								for (int b=0;b<numChildrenB;b++)\n"
+	"								{\n"
+	"									if ((pairIdx+b)<maxNumConcavePairsCapacity)\n"
+	"									{\n"
+	"										int childShapeIndexB = collidables[collidableIndexB].m_shapeIndex+b;\n"
+	"										int4 newPair = (int4)(bodyIndexA,bodyIndexB,triangleIndex,childShapeIndexB);\n"
+	"										concavePairsOut[pairIdx+b] = newPair;\n"
+	"									}\n"
+	"								}\n"
+	"						} else\n"
+	"						{\n"
+	"							int pairIdx = atomic_inc(numConcavePairsOut);\n"
+	"							if (pairIdx<maxNumConcavePairsCapacity)\n"
+	"							{\n"
+	"								int4 newPair = (int4)(bodyIndexA,bodyIndexB,triangleIndex,0);\n"
+	"								concavePairsOut[pairIdx] = newPair;\n"
+	"							}\n"
+	"						}\n"
+	"					} \n"
+	"					curIndex++;\n"
+	"				} else\n"
+	"				{\n"
+	"					if (isLeafNode)\n"
+	"					{\n"
+	"						curIndex++;\n"
+	"					} else\n"
+	"					{\n"
+	"						escapeIndex = getEscapeIndex(&rootNode);\n"
+	"						curIndex += escapeIndex;\n"
+	"					}\n"
+	"				}\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"}\n";
diff --git a/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/kernels/mprKernels.h b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/kernels/mprKernels.h
new file mode 100644
index 00000000..74959a93
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/kernels/mprKernels.h
@@ -0,0 +1,1445 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* mprKernelsCL =
+	"/***\n"
+	" * ---------------------------------\n"
+	" * Copyright (c)2012 Daniel Fiser <danfis@danfis.cz>\n"
+	" *\n"
+	" *  This file was ported from mpr.c file, part of libccd.\n"
+	" *  The Minkoski Portal Refinement implementation was ported \n"
+	" *  to OpenCL by Erwin Coumans for the Bullet 3 Physics library.\n"
+	" *  at http://github.com/erwincoumans/bullet3\n"
+	" *\n"
+	" *  Distributed under the OSI-approved BSD License (the \"License\");\n"
+	" *  see <http://www.opensource.org/licenses/bsd-license.php>.\n"
+	" *  This software is distributed WITHOUT ANY WARRANTY; without even the\n"
+	" *  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
+	" *  See the License for more information.\n"
+	" */\n"
+	"#ifndef B3_MPR_PENETRATION_H\n"
+	"#define B3_MPR_PENETRATION_H\n"
+	"#ifndef B3_PLATFORM_DEFINITIONS_H\n"
+	"#define B3_PLATFORM_DEFINITIONS_H\n"
+	"struct MyTest\n"
+	"{\n"
+	"	int bla;\n"
+	"};\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"//keep B3_LARGE_FLOAT*B3_LARGE_FLOAT < FLT_MAX\n"
+	"#define B3_LARGE_FLOAT 1e18f\n"
+	"#define B3_INFINITY 1e18f\n"
+	"#define b3Assert(a)\n"
+	"#define b3ConstArray(a) __global const a*\n"
+	"#define b3AtomicInc atomic_inc\n"
+	"#define b3AtomicAdd atomic_add\n"
+	"#define b3Fabs fabs\n"
+	"#define b3Sqrt native_sqrt\n"
+	"#define b3Sin native_sin\n"
+	"#define b3Cos native_cos\n"
+	"#define B3_STATIC\n"
+	"#endif\n"
+	"#endif\n"
+	"#ifndef B3_FLOAT4_H\n"
+	"#define B3_FLOAT4_H\n"
+	"#ifndef B3_PLATFORM_DEFINITIONS_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif\n"
+	"#endif\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"	typedef float4	b3Float4;\n"
+	"	#define b3Float4ConstArg const b3Float4\n"
+	"	#define b3MakeFloat4 (float4)\n"
+	"	float b3Dot3F4(b3Float4ConstArg v0,b3Float4ConstArg v1)\n"
+	"	{\n"
+	"		float4 a1 = b3MakeFloat4(v0.xyz,0.f);\n"
+	"		float4 b1 = b3MakeFloat4(v1.xyz,0.f);\n"
+	"		return dot(a1, b1);\n"
+	"	}\n"
+	"	b3Float4 b3Cross3(b3Float4ConstArg v0,b3Float4ConstArg v1)\n"
+	"	{\n"
+	"		float4 a1 = b3MakeFloat4(v0.xyz,0.f);\n"
+	"		float4 b1 = b3MakeFloat4(v1.xyz,0.f);\n"
+	"		return cross(a1, b1);\n"
+	"	}\n"
+	"	#define b3MinFloat4 min\n"
+	"	#define b3MaxFloat4 max\n"
+	"	#define b3Normalized(a) normalize(a)\n"
+	"#endif \n"
+	"		\n"
+	"inline bool b3IsAlmostZero(b3Float4ConstArg v)\n"
+	"{\n"
+	"	if(b3Fabs(v.x)>1e-6 || b3Fabs(v.y)>1e-6 || b3Fabs(v.z)>1e-6)	\n"
+	"		return false;\n"
+	"	return true;\n"
+	"}\n"
+	"inline int    b3MaxDot( b3Float4ConstArg vec, __global const b3Float4* vecArray, int vecLen, float* dotOut )\n"
+	"{\n"
+	"    float maxDot = -B3_INFINITY;\n"
+	"    int i = 0;\n"
+	"    int ptIndex = -1;\n"
+	"    for( i = 0; i < vecLen; i++ )\n"
+	"    {\n"
+	"        float dot = b3Dot3F4(vecArray[i],vec);\n"
+	"            \n"
+	"        if( dot > maxDot )\n"
+	"        {\n"
+	"            maxDot = dot;\n"
+	"            ptIndex = i;\n"
+	"        }\n"
+	"    }\n"
+	"	b3Assert(ptIndex>=0);\n"
+	"    if (ptIndex<0)\n"
+	"	{\n"
+	"		ptIndex = 0;\n"
+	"	}\n"
+	"    *dotOut = maxDot;\n"
+	"    return ptIndex;\n"
+	"}\n"
+	"#endif //B3_FLOAT4_H\n"
+	"#ifndef B3_RIGIDBODY_DATA_H\n"
+	"#define B3_RIGIDBODY_DATA_H\n"
+	"#ifndef B3_FLOAT4_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif \n"
+	"#endif //B3_FLOAT4_H\n"
+	"#ifndef B3_QUAT_H\n"
+	"#define B3_QUAT_H\n"
+	"#ifndef B3_PLATFORM_DEFINITIONS_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif\n"
+	"#endif\n"
+	"#ifndef B3_FLOAT4_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif \n"
+	"#endif //B3_FLOAT4_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"	typedef float4	b3Quat;\n"
+	"	#define b3QuatConstArg const b3Quat\n"
+	"	\n"
+	"	\n"
+	"inline float4 b3FastNormalize4(float4 v)\n"
+	"{\n"
+	"	v = (float4)(v.xyz,0.f);\n"
+	"	return fast_normalize(v);\n"
+	"}\n"
+	"	\n"
+	"inline b3Quat b3QuatMul(b3Quat a, b3Quat b);\n"
+	"inline b3Quat b3QuatNormalized(b3QuatConstArg in);\n"
+	"inline b3Quat b3QuatRotate(b3QuatConstArg q, b3QuatConstArg vec);\n"
+	"inline b3Quat b3QuatInvert(b3QuatConstArg q);\n"
+	"inline b3Quat b3QuatInverse(b3QuatConstArg q);\n"
+	"inline b3Quat b3QuatMul(b3QuatConstArg a, b3QuatConstArg b)\n"
+	"{\n"
+	"	b3Quat ans;\n"
+	"	ans = b3Cross3( a, b );\n"
+	"	ans += a.w*b+b.w*a;\n"
+	"//	ans.w = a.w*b.w - (a.x*b.x+a.y*b.y+a.z*b.z);\n"
+	"	ans.w = a.w*b.w - b3Dot3F4(a, b);\n"
+	"	return ans;\n"
+	"}\n"
+	"inline b3Quat b3QuatNormalized(b3QuatConstArg in)\n"
+	"{\n"
+	"	b3Quat q;\n"
+	"	q=in;\n"
+	"	//return b3FastNormalize4(in);\n"
+	"	float len = native_sqrt(dot(q, q));\n"
+	"	if(len > 0.f)\n"
+	"	{\n"
+	"		q *= 1.f / len;\n"
+	"	}\n"
+	"	else\n"
+	"	{\n"
+	"		q.x = q.y = q.z = 0.f;\n"
+	"		q.w = 1.f;\n"
+	"	}\n"
+	"	return q;\n"
+	"}\n"
+	"inline float4 b3QuatRotate(b3QuatConstArg q, b3QuatConstArg vec)\n"
+	"{\n"
+	"	b3Quat qInv = b3QuatInvert( q );\n"
+	"	float4 vcpy = vec;\n"
+	"	vcpy.w = 0.f;\n"
+	"	float4 out = b3QuatMul(b3QuatMul(q,vcpy),qInv);\n"
+	"	return out;\n"
+	"}\n"
+	"inline b3Quat b3QuatInverse(b3QuatConstArg q)\n"
+	"{\n"
+	"	return (b3Quat)(-q.xyz, q.w);\n"
+	"}\n"
+	"inline b3Quat b3QuatInvert(b3QuatConstArg q)\n"
+	"{\n"
+	"	return (b3Quat)(-q.xyz, q.w);\n"
+	"}\n"
+	"inline float4 b3QuatInvRotate(b3QuatConstArg q, b3QuatConstArg vec)\n"
+	"{\n"
+	"	return b3QuatRotate( b3QuatInvert( q ), vec );\n"
+	"}\n"
+	"inline b3Float4 b3TransformPoint(b3Float4ConstArg point, b3Float4ConstArg translation, b3QuatConstArg  orientation)\n"
+	"{\n"
+	"	return b3QuatRotate( orientation, point ) + (translation);\n"
+	"}\n"
+	"	\n"
+	"#endif \n"
+	"#endif //B3_QUAT_H\n"
+	"#ifndef B3_MAT3x3_H\n"
+	"#define B3_MAT3x3_H\n"
+	"#ifndef B3_QUAT_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif \n"
+	"#endif //B3_QUAT_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"typedef struct\n"
+	"{\n"
+	"	b3Float4 m_row[3];\n"
+	"}b3Mat3x3;\n"
+	"#define b3Mat3x3ConstArg const b3Mat3x3\n"
+	"#define b3GetRow(m,row) (m.m_row[row])\n"
+	"inline b3Mat3x3 b3QuatGetRotationMatrix(b3Quat quat)\n"
+	"{\n"
+	"	b3Float4 quat2 = (b3Float4)(quat.x*quat.x, quat.y*quat.y, quat.z*quat.z, 0.f);\n"
+	"	b3Mat3x3 out;\n"
+	"	out.m_row[0].x=1-2*quat2.y-2*quat2.z;\n"
+	"	out.m_row[0].y=2*quat.x*quat.y-2*quat.w*quat.z;\n"
+	"	out.m_row[0].z=2*quat.x*quat.z+2*quat.w*quat.y;\n"
+	"	out.m_row[0].w = 0.f;\n"
+	"	out.m_row[1].x=2*quat.x*quat.y+2*quat.w*quat.z;\n"
+	"	out.m_row[1].y=1-2*quat2.x-2*quat2.z;\n"
+	"	out.m_row[1].z=2*quat.y*quat.z-2*quat.w*quat.x;\n"
+	"	out.m_row[1].w = 0.f;\n"
+	"	out.m_row[2].x=2*quat.x*quat.z-2*quat.w*quat.y;\n"
+	"	out.m_row[2].y=2*quat.y*quat.z+2*quat.w*quat.x;\n"
+	"	out.m_row[2].z=1-2*quat2.x-2*quat2.y;\n"
+	"	out.m_row[2].w = 0.f;\n"
+	"	return out;\n"
+	"}\n"
+	"inline b3Mat3x3 b3AbsoluteMat3x3(b3Mat3x3ConstArg matIn)\n"
+	"{\n"
+	"	b3Mat3x3 out;\n"
+	"	out.m_row[0] = fabs(matIn.m_row[0]);\n"
+	"	out.m_row[1] = fabs(matIn.m_row[1]);\n"
+	"	out.m_row[2] = fabs(matIn.m_row[2]);\n"
+	"	return out;\n"
+	"}\n"
+	"__inline\n"
+	"b3Mat3x3 mtZero();\n"
+	"__inline\n"
+	"b3Mat3x3 mtIdentity();\n"
+	"__inline\n"
+	"b3Mat3x3 mtTranspose(b3Mat3x3 m);\n"
+	"__inline\n"
+	"b3Mat3x3 mtMul(b3Mat3x3 a, b3Mat3x3 b);\n"
+	"__inline\n"
+	"b3Float4 mtMul1(b3Mat3x3 a, b3Float4 b);\n"
+	"__inline\n"
+	"b3Float4 mtMul3(b3Float4 a, b3Mat3x3 b);\n"
+	"__inline\n"
+	"b3Mat3x3 mtZero()\n"
+	"{\n"
+	"	b3Mat3x3 m;\n"
+	"	m.m_row[0] = (b3Float4)(0.f);\n"
+	"	m.m_row[1] = (b3Float4)(0.f);\n"
+	"	m.m_row[2] = (b3Float4)(0.f);\n"
+	"	return m;\n"
+	"}\n"
+	"__inline\n"
+	"b3Mat3x3 mtIdentity()\n"
+	"{\n"
+	"	b3Mat3x3 m;\n"
+	"	m.m_row[0] = (b3Float4)(1,0,0,0);\n"
+	"	m.m_row[1] = (b3Float4)(0,1,0,0);\n"
+	"	m.m_row[2] = (b3Float4)(0,0,1,0);\n"
+	"	return m;\n"
+	"}\n"
+	"__inline\n"
+	"b3Mat3x3 mtTranspose(b3Mat3x3 m)\n"
+	"{\n"
+	"	b3Mat3x3 out;\n"
+	"	out.m_row[0] = (b3Float4)(m.m_row[0].x, m.m_row[1].x, m.m_row[2].x, 0.f);\n"
+	"	out.m_row[1] = (b3Float4)(m.m_row[0].y, m.m_row[1].y, m.m_row[2].y, 0.f);\n"
+	"	out.m_row[2] = (b3Float4)(m.m_row[0].z, m.m_row[1].z, m.m_row[2].z, 0.f);\n"
+	"	return out;\n"
+	"}\n"
+	"__inline\n"
+	"b3Mat3x3 mtMul(b3Mat3x3 a, b3Mat3x3 b)\n"
+	"{\n"
+	"	b3Mat3x3 transB;\n"
+	"	transB = mtTranspose( b );\n"
+	"	b3Mat3x3 ans;\n"
+	"	//	why this doesn't run when 0ing in the for{}\n"
+	"	a.m_row[0].w = 0.f;\n"
+	"	a.m_row[1].w = 0.f;\n"
+	"	a.m_row[2].w = 0.f;\n"
+	"	for(int i=0; i<3; i++)\n"
+	"	{\n"
+	"//	a.m_row[i].w = 0.f;\n"
+	"		ans.m_row[i].x = b3Dot3F4(a.m_row[i],transB.m_row[0]);\n"
+	"		ans.m_row[i].y = b3Dot3F4(a.m_row[i],transB.m_row[1]);\n"
+	"		ans.m_row[i].z = b3Dot3F4(a.m_row[i],transB.m_row[2]);\n"
+	"		ans.m_row[i].w = 0.f;\n"
+	"	}\n"
+	"	return ans;\n"
+	"}\n"
+	"__inline\n"
+	"b3Float4 mtMul1(b3Mat3x3 a, b3Float4 b)\n"
+	"{\n"
+	"	b3Float4 ans;\n"
+	"	ans.x = b3Dot3F4( a.m_row[0], b );\n"
+	"	ans.y = b3Dot3F4( a.m_row[1], b );\n"
+	"	ans.z = b3Dot3F4( a.m_row[2], b );\n"
+	"	ans.w = 0.f;\n"
+	"	return ans;\n"
+	"}\n"
+	"__inline\n"
+	"b3Float4 mtMul3(b3Float4 a, b3Mat3x3 b)\n"
+	"{\n"
+	"	b3Float4 colx = b3MakeFloat4(b.m_row[0].x, b.m_row[1].x, b.m_row[2].x, 0);\n"
+	"	b3Float4 coly = b3MakeFloat4(b.m_row[0].y, b.m_row[1].y, b.m_row[2].y, 0);\n"
+	"	b3Float4 colz = b3MakeFloat4(b.m_row[0].z, b.m_row[1].z, b.m_row[2].z, 0);\n"
+	"	b3Float4 ans;\n"
+	"	ans.x = b3Dot3F4( a, colx );\n"
+	"	ans.y = b3Dot3F4( a, coly );\n"
+	"	ans.z = b3Dot3F4( a, colz );\n"
+	"	return ans;\n"
+	"}\n"
+	"#endif\n"
+	"#endif //B3_MAT3x3_H\n"
+	"typedef struct b3RigidBodyData b3RigidBodyData_t;\n"
+	"struct b3RigidBodyData\n"
+	"{\n"
+	"	b3Float4				m_pos;\n"
+	"	b3Quat					m_quat;\n"
+	"	b3Float4				m_linVel;\n"
+	"	b3Float4				m_angVel;\n"
+	"	int 					m_collidableIdx;\n"
+	"	float 				m_invMass;\n"
+	"	float 				m_restituitionCoeff;\n"
+	"	float 				m_frictionCoeff;\n"
+	"};\n"
+	"typedef struct b3InertiaData b3InertiaData_t;\n"
+	"struct b3InertiaData\n"
+	"{\n"
+	"	b3Mat3x3 m_invInertiaWorld;\n"
+	"	b3Mat3x3 m_initInvInertia;\n"
+	"};\n"
+	"#endif //B3_RIGIDBODY_DATA_H\n"
+	"	\n"
+	"#ifndef B3_CONVEX_POLYHEDRON_DATA_H\n"
+	"#define B3_CONVEX_POLYHEDRON_DATA_H\n"
+	"#ifndef B3_FLOAT4_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif \n"
+	"#endif //B3_FLOAT4_H\n"
+	"#ifndef B3_QUAT_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif \n"
+	"#endif //B3_QUAT_H\n"
+	"typedef struct b3GpuFace b3GpuFace_t;\n"
+	"struct b3GpuFace\n"
+	"{\n"
+	"	b3Float4 m_plane;\n"
+	"	int m_indexOffset;\n"
+	"	int m_numIndices;\n"
+	"	int m_unusedPadding1;\n"
+	"	int m_unusedPadding2;\n"
+	"};\n"
+	"typedef struct b3ConvexPolyhedronData b3ConvexPolyhedronData_t;\n"
+	"struct b3ConvexPolyhedronData\n"
+	"{\n"
+	"	b3Float4		m_localCenter;\n"
+	"	b3Float4		m_extents;\n"
+	"	b3Float4		mC;\n"
+	"	b3Float4		mE;\n"
+	"	float			m_radius;\n"
+	"	int	m_faceOffset;\n"
+	"	int m_numFaces;\n"
+	"	int	m_numVertices;\n"
+	"	int m_vertexOffset;\n"
+	"	int	m_uniqueEdgesOffset;\n"
+	"	int	m_numUniqueEdges;\n"
+	"	int m_unused;\n"
+	"};\n"
+	"#endif //B3_CONVEX_POLYHEDRON_DATA_H\n"
+	"#ifndef B3_COLLIDABLE_H\n"
+	"#define B3_COLLIDABLE_H\n"
+	"#ifndef B3_FLOAT4_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif \n"
+	"#endif //B3_FLOAT4_H\n"
+	"#ifndef B3_QUAT_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif \n"
+	"#endif //B3_QUAT_H\n"
+	"enum b3ShapeTypes\n"
+	"{\n"
+	"	SHAPE_HEIGHT_FIELD=1,\n"
+	"	SHAPE_CONVEX_HULL=3,\n"
+	"	SHAPE_PLANE=4,\n"
+	"	SHAPE_CONCAVE_TRIMESH=5,\n"
+	"	SHAPE_COMPOUND_OF_CONVEX_HULLS=6,\n"
+	"	SHAPE_SPHERE=7,\n"
+	"	MAX_NUM_SHAPE_TYPES,\n"
+	"};\n"
+	"typedef struct b3Collidable b3Collidable_t;\n"
+	"struct b3Collidable\n"
+	"{\n"
+	"	union {\n"
+	"		int m_numChildShapes;\n"
+	"		int m_bvhIndex;\n"
+	"	};\n"
+	"	union\n"
+	"	{\n"
+	"		float m_radius;\n"
+	"		int	m_compoundBvhIndex;\n"
+	"	};\n"
+	"	int m_shapeType;\n"
+	"	int m_shapeIndex;\n"
+	"};\n"
+	"typedef struct b3GpuChildShape b3GpuChildShape_t;\n"
+	"struct b3GpuChildShape\n"
+	"{\n"
+	"	b3Float4	m_childPosition;\n"
+	"	b3Quat		m_childOrientation;\n"
+	"	int m_shapeIndex;\n"
+	"	int m_unused0;\n"
+	"	int m_unused1;\n"
+	"	int m_unused2;\n"
+	"};\n"
+	"struct b3CompoundOverlappingPair\n"
+	"{\n"
+	"	int m_bodyIndexA;\n"
+	"	int m_bodyIndexB;\n"
+	"//	int	m_pairType;\n"
+	"	int m_childShapeIndexA;\n"
+	"	int m_childShapeIndexB;\n"
+	"};\n"
+	"#endif //B3_COLLIDABLE_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#define B3_MPR_SQRT sqrt\n"
+	"#endif\n"
+	"#define B3_MPR_FMIN(x, y) ((x) < (y) ? (x) : (y))\n"
+	"#define B3_MPR_FABS fabs\n"
+	"#define B3_MPR_TOLERANCE 1E-6f\n"
+	"#define B3_MPR_MAX_ITERATIONS 1000\n"
+	"struct _b3MprSupport_t \n"
+	"{\n"
+	"    b3Float4 v;  //!< Support point in minkowski sum\n"
+	"    b3Float4 v1; //!< Support point in obj1\n"
+	"    b3Float4 v2; //!< Support point in obj2\n"
+	"};\n"
+	"typedef struct _b3MprSupport_t b3MprSupport_t;\n"
+	"struct _b3MprSimplex_t \n"
+	"{\n"
+	"    b3MprSupport_t ps[4];\n"
+	"    int last; //!< index of last added point\n"
+	"};\n"
+	"typedef struct _b3MprSimplex_t b3MprSimplex_t;\n"
+	"inline b3MprSupport_t* b3MprSimplexPointW(b3MprSimplex_t *s, int idx)\n"
+	"{\n"
+	"    return &s->ps[idx];\n"
+	"}\n"
+	"inline void b3MprSimplexSetSize(b3MprSimplex_t *s, int size)\n"
+	"{\n"
+	"    s->last = size - 1;\n"
+	"}\n"
+	"inline int b3MprSimplexSize(const b3MprSimplex_t *s)\n"
+	"{\n"
+	"    return s->last + 1;\n"
+	"}\n"
+	"inline const b3MprSupport_t* b3MprSimplexPoint(const b3MprSimplex_t* s, int idx)\n"
+	"{\n"
+	"    // here is no check on boundaries\n"
+	"    return &s->ps[idx];\n"
+	"}\n"
+	"inline void b3MprSupportCopy(b3MprSupport_t *d, const b3MprSupport_t *s)\n"
+	"{\n"
+	"    *d = *s;\n"
+	"}\n"
+	"inline void b3MprSimplexSet(b3MprSimplex_t *s, size_t pos, const b3MprSupport_t *a)\n"
+	"{\n"
+	"    b3MprSupportCopy(s->ps + pos, a);\n"
+	"}\n"
+	"inline void b3MprSimplexSwap(b3MprSimplex_t *s, size_t pos1, size_t pos2)\n"
+	"{\n"
+	"    b3MprSupport_t supp;\n"
+	"    b3MprSupportCopy(&supp, &s->ps[pos1]);\n"
+	"    b3MprSupportCopy(&s->ps[pos1], &s->ps[pos2]);\n"
+	"    b3MprSupportCopy(&s->ps[pos2], &supp);\n"
+	"}\n"
+	"inline int b3MprIsZero(float val)\n"
+	"{\n"
+	"    return B3_MPR_FABS(val) < FLT_EPSILON;\n"
+	"}\n"
+	"inline int b3MprEq(float _a, float _b)\n"
+	"{\n"
+	"    float ab;\n"
+	"    float a, b;\n"
+	"    ab = B3_MPR_FABS(_a - _b);\n"
+	"    if (B3_MPR_FABS(ab) < FLT_EPSILON)\n"
+	"        return 1;\n"
+	"    a = B3_MPR_FABS(_a);\n"
+	"    b = B3_MPR_FABS(_b);\n"
+	"    if (b > a){\n"
+	"        return ab < FLT_EPSILON * b;\n"
+	"    }else{\n"
+	"        return ab < FLT_EPSILON * a;\n"
+	"    }\n"
+	"}\n"
+	"inline int b3MprVec3Eq(const b3Float4* a, const b3Float4 *b)\n"
+	"{\n"
+	"    return b3MprEq((*a).x, (*b).x)\n"
+	"            && b3MprEq((*a).y, (*b).y)\n"
+	"            && b3MprEq((*a).z, (*b).z);\n"
+	"}\n"
+	"inline b3Float4 b3LocalGetSupportVertex(b3Float4ConstArg supportVec,__global const b3ConvexPolyhedronData_t* hull, 	b3ConstArray(b3Float4) verticesA)\n"
+	"{\n"
+	"	b3Float4 supVec = b3MakeFloat4(0,0,0,0);\n"
+	"	float maxDot = -B3_LARGE_FLOAT;\n"
+	"    if( 0 < hull->m_numVertices )\n"
+	"    {\n"
+	"        const b3Float4 scaled = supportVec;\n"
+	"		int index = b3MaxDot(scaled, &verticesA[hull->m_vertexOffset], hull->m_numVertices, &maxDot);\n"
+	"        return verticesA[hull->m_vertexOffset+index];\n"
+	"    }\n"
+	"    return supVec;\n"
+	"}\n"
+	"B3_STATIC void b3MprConvexSupport(int pairIndex,int bodyIndex,  b3ConstArray(b3RigidBodyData_t) cpuBodyBuf, \n"
+	"													b3ConstArray(b3ConvexPolyhedronData_t) cpuConvexData, \n"
+	"													b3ConstArray(b3Collidable_t)				cpuCollidables,\n"
+	"													b3ConstArray(b3Float4)					cpuVertices,\n"
+	"													__global b3Float4* sepAxis,\n"
+	"														const b3Float4* _dir, b3Float4* outp, int logme)\n"
+	"{\n"
+	"	//dir is in worldspace, move to local space\n"
+	"	\n"
+	"	b3Float4 pos = cpuBodyBuf[bodyIndex].m_pos;\n"
+	"	b3Quat orn = cpuBodyBuf[bodyIndex].m_quat;\n"
+	"	\n"
+	"	b3Float4 dir = b3MakeFloat4((*_dir).x,(*_dir).y,(*_dir).z,0.f);\n"
+	"	\n"
+	"	const b3Float4 localDir = b3QuatRotate(b3QuatInverse(orn),dir);\n"
+	"	\n"
+	"	//find local support vertex\n"
+	"	int colIndex = cpuBodyBuf[bodyIndex].m_collidableIdx;\n"
+	"	\n"
+	"	b3Assert(cpuCollidables[colIndex].m_shapeType==SHAPE_CONVEX_HULL);\n"
+	"	__global const b3ConvexPolyhedronData_t* hull = &cpuConvexData[cpuCollidables[colIndex].m_shapeIndex];\n"
+	"	\n"
+	"	b3Float4 pInA;\n"
+	"	if (logme)\n"
+	"	{\n"
+	"		b3Float4 supVec = b3MakeFloat4(0,0,0,0);\n"
+	"		float maxDot = -B3_LARGE_FLOAT;\n"
+	"		if( 0 < hull->m_numVertices )\n"
+	"		{\n"
+	"			const b3Float4 scaled = localDir;\n"
+	"			int index = b3MaxDot(scaled, &cpuVertices[hull->m_vertexOffset], hull->m_numVertices, &maxDot);\n"
+	"			pInA = cpuVertices[hull->m_vertexOffset+index];\n"
+	"			\n"
+	"		}\n"
+	"	} else\n"
+	"	{\n"
+	"		pInA = b3LocalGetSupportVertex(localDir,hull,cpuVertices);\n"
+	"	}\n"
+	"	//move vertex to world space\n"
+	"	*outp = b3TransformPoint(pInA,pos,orn);\n"
+	"	\n"
+	"}\n"
+	"inline void b3MprSupport(int pairIndex,int bodyIndexA, int bodyIndexB,   b3ConstArray(b3RigidBodyData_t) cpuBodyBuf, \n"
+	"													b3ConstArray(b3ConvexPolyhedronData_t) cpuConvexData, \n"
+	"													b3ConstArray(b3Collidable_t)				cpuCollidables,\n"
+	"													b3ConstArray(b3Float4)					cpuVertices,\n"
+	"													__global b3Float4* sepAxis,\n"
+	"													const b3Float4* _dir, b3MprSupport_t *supp)\n"
+	"{\n"
+	"    b3Float4 dir;\n"
+	"	dir = *_dir;\n"
+	"	b3MprConvexSupport(pairIndex,bodyIndexA,cpuBodyBuf,cpuConvexData,cpuCollidables,cpuVertices,sepAxis,&dir, &supp->v1,0);\n"
+	"    dir = *_dir*-1.f;\n"
+	"	b3MprConvexSupport(pairIndex,bodyIndexB,cpuBodyBuf,cpuConvexData,cpuCollidables,cpuVertices,sepAxis,&dir, &supp->v2,0);\n"
+	"    supp->v = supp->v1 - supp->v2;\n"
+	"}\n"
+	"inline void b3FindOrigin(int bodyIndexA, int bodyIndexB, b3ConstArray(b3RigidBodyData_t) cpuBodyBuf, b3MprSupport_t *center)\n"
+	"{\n"
+	"    center->v1 = cpuBodyBuf[bodyIndexA].m_pos;\n"
+	"	center->v2 = cpuBodyBuf[bodyIndexB].m_pos;\n"
+	"    center->v = center->v1 - center->v2;\n"
+	"}\n"
+	"inline void b3MprVec3Set(b3Float4 *v, float x, float y, float z)\n"
+	"{\n"
+	"	(*v).x = x;\n"
+	"	(*v).y = y;\n"
+	"	(*v).z = z;\n"
+	"	(*v).w = 0.f;\n"
+	"}\n"
+	"inline void b3MprVec3Add(b3Float4 *v, const b3Float4 *w)\n"
+	"{\n"
+	"    (*v).x += (*w).x;\n"
+	"    (*v).y += (*w).y;\n"
+	"    (*v).z += (*w).z;\n"
+	"}\n"
+	"inline void b3MprVec3Copy(b3Float4 *v, const b3Float4 *w)\n"
+	"{\n"
+	"    *v = *w;\n"
+	"}\n"
+	"inline void b3MprVec3Scale(b3Float4 *d, float k)\n"
+	"{\n"
+	"    *d *= k;\n"
+	"}\n"
+	"inline float b3MprVec3Dot(const b3Float4 *a, const b3Float4 *b)\n"
+	"{\n"
+	"    float dot;\n"
+	"	dot = b3Dot3F4(*a,*b);\n"
+	"    return dot;\n"
+	"}\n"
+	"inline float b3MprVec3Len2(const b3Float4 *v)\n"
+	"{\n"
+	"    return b3MprVec3Dot(v, v);\n"
+	"}\n"
+	"inline void b3MprVec3Normalize(b3Float4 *d)\n"
+	"{\n"
+	"    float k = 1.f / B3_MPR_SQRT(b3MprVec3Len2(d));\n"
+	"    b3MprVec3Scale(d, k);\n"
+	"}\n"
+	"inline void b3MprVec3Cross(b3Float4 *d, const b3Float4 *a, const b3Float4 *b)\n"
+	"{\n"
+	"	*d = b3Cross3(*a,*b);\n"
+	"	\n"
+	"}\n"
+	"inline void b3MprVec3Sub2(b3Float4 *d, const b3Float4 *v, const b3Float4 *w)\n"
+	"{\n"
+	"	*d = *v - *w;\n"
+	"}\n"
+	"inline void b3PortalDir(const b3MprSimplex_t *portal, b3Float4 *dir)\n"
+	"{\n"
+	"    b3Float4 v2v1, v3v1;\n"
+	"    b3MprVec3Sub2(&v2v1, &b3MprSimplexPoint(portal, 2)->v,\n"
+	"                       &b3MprSimplexPoint(portal, 1)->v);\n"
+	"    b3MprVec3Sub2(&v3v1, &b3MprSimplexPoint(portal, 3)->v,\n"
+	"                       &b3MprSimplexPoint(portal, 1)->v);\n"
+	"    b3MprVec3Cross(dir, &v2v1, &v3v1);\n"
+	"    b3MprVec3Normalize(dir);\n"
+	"}\n"
+	"inline int portalEncapsulesOrigin(const b3MprSimplex_t *portal,\n"
+	"                                       const b3Float4 *dir)\n"
+	"{\n"
+	"    float dot;\n"
+	"    dot = b3MprVec3Dot(dir, &b3MprSimplexPoint(portal, 1)->v);\n"
+	"    return b3MprIsZero(dot) || dot > 0.f;\n"
+	"}\n"
+	"inline int portalReachTolerance(const b3MprSimplex_t *portal,\n"
+	"                                     const b3MprSupport_t *v4,\n"
+	"                                     const b3Float4 *dir)\n"
+	"{\n"
+	"    float dv1, dv2, dv3, dv4;\n"
+	"    float dot1, dot2, dot3;\n"
+	"    // find the smallest dot product of dir and {v1-v4, v2-v4, v3-v4}\n"
+	"    dv1 = b3MprVec3Dot(&b3MprSimplexPoint(portal, 1)->v, dir);\n"
+	"    dv2 = b3MprVec3Dot(&b3MprSimplexPoint(portal, 2)->v, dir);\n"
+	"    dv3 = b3MprVec3Dot(&b3MprSimplexPoint(portal, 3)->v, dir);\n"
+	"    dv4 = b3MprVec3Dot(&v4->v, dir);\n"
+	"    dot1 = dv4 - dv1;\n"
+	"    dot2 = dv4 - dv2;\n"
+	"    dot3 = dv4 - dv3;\n"
+	"    dot1 = B3_MPR_FMIN(dot1, dot2);\n"
+	"    dot1 = B3_MPR_FMIN(dot1, dot3);\n"
+	"    return b3MprEq(dot1, B3_MPR_TOLERANCE) || dot1 < B3_MPR_TOLERANCE;\n"
+	"}\n"
+	"inline int portalCanEncapsuleOrigin(const b3MprSimplex_t *portal,   \n"
+	"                                         const b3MprSupport_t *v4,\n"
+	"                                         const b3Float4 *dir)\n"
+	"{\n"
+	"    float dot;\n"
+	"    dot = b3MprVec3Dot(&v4->v, dir);\n"
+	"    return b3MprIsZero(dot) || dot > 0.f;\n"
+	"}\n"
+	"inline void b3ExpandPortal(b3MprSimplex_t *portal,\n"
+	"                              const b3MprSupport_t *v4)\n"
+	"{\n"
+	"    float dot;\n"
+	"    b3Float4 v4v0;\n"
+	"    b3MprVec3Cross(&v4v0, &v4->v, &b3MprSimplexPoint(portal, 0)->v);\n"
+	"    dot = b3MprVec3Dot(&b3MprSimplexPoint(portal, 1)->v, &v4v0);\n"
+	"    if (dot > 0.f){\n"
+	"        dot = b3MprVec3Dot(&b3MprSimplexPoint(portal, 2)->v, &v4v0);\n"
+	"        if (dot > 0.f){\n"
+	"            b3MprSimplexSet(portal, 1, v4);\n"
+	"        }else{\n"
+	"            b3MprSimplexSet(portal, 3, v4);\n"
+	"        }\n"
+	"    }else{\n"
+	"        dot = b3MprVec3Dot(&b3MprSimplexPoint(portal, 3)->v, &v4v0);\n"
+	"        if (dot > 0.f){\n"
+	"            b3MprSimplexSet(portal, 2, v4);\n"
+	"        }else{\n"
+	"            b3MprSimplexSet(portal, 1, v4);\n"
+	"        }\n"
+	"    }\n"
+	"}\n"
+	"B3_STATIC int b3DiscoverPortal(int pairIndex, int bodyIndexA, int bodyIndexB,  b3ConstArray(b3RigidBodyData_t) cpuBodyBuf, \n"
+	"													b3ConstArray(b3ConvexPolyhedronData_t) cpuConvexData, \n"
+	"													b3ConstArray(b3Collidable_t)				cpuCollidables,\n"
+	"													b3ConstArray(b3Float4)					cpuVertices,\n"
+	"													__global b3Float4* sepAxis,\n"
+	"													__global int*	hasSepAxis,\n"
+	"													b3MprSimplex_t *portal)\n"
+	"{\n"
+	"    b3Float4 dir, va, vb;\n"
+	"    float dot;\n"
+	"    int cont;\n"
+	"	\n"
+	"	\n"
+	"    // vertex 0 is center of portal\n"
+	"    b3FindOrigin(bodyIndexA,bodyIndexB,cpuBodyBuf, b3MprSimplexPointW(portal, 0));\n"
+	"    // vertex 0 is center of portal\n"
+	"    b3MprSimplexSetSize(portal, 1);\n"
+	"	\n"
+	"	b3Float4 zero = b3MakeFloat4(0,0,0,0);\n"
+	"	b3Float4* b3mpr_vec3_origin = &zero;\n"
+	"    if (b3MprVec3Eq(&b3MprSimplexPoint(portal, 0)->v, b3mpr_vec3_origin)){\n"
+	"        // Portal's center lies on origin (0,0,0) => we know that objects\n"
+	"        // intersect but we would need to know penetration info.\n"
+	"        // So move center little bit...\n"
+	"        b3MprVec3Set(&va, FLT_EPSILON * 10.f, 0.f, 0.f);\n"
+	"        b3MprVec3Add(&b3MprSimplexPointW(portal, 0)->v, &va);\n"
+	"    }\n"
+	"    // vertex 1 = support in direction of origin\n"
+	"    b3MprVec3Copy(&dir, &b3MprSimplexPoint(portal, 0)->v);\n"
+	"    b3MprVec3Scale(&dir, -1.f);\n"
+	"    b3MprVec3Normalize(&dir);\n"
+	"    b3MprSupport(pairIndex,bodyIndexA,bodyIndexB,cpuBodyBuf,cpuConvexData,cpuCollidables,cpuVertices, sepAxis,&dir, b3MprSimplexPointW(portal, 1));\n"
+	"    b3MprSimplexSetSize(portal, 2);\n"
+	"    // test if origin isn't outside of v1\n"
+	"    dot = b3MprVec3Dot(&b3MprSimplexPoint(portal, 1)->v, &dir);\n"
+	"	\n"
+	"    if (b3MprIsZero(dot) || dot < 0.f)\n"
+	"        return -1;\n"
+	"    // vertex 2\n"
+	"    b3MprVec3Cross(&dir, &b3MprSimplexPoint(portal, 0)->v,\n"
+	"                       &b3MprSimplexPoint(portal, 1)->v);\n"
+	"    if (b3MprIsZero(b3MprVec3Len2(&dir))){\n"
+	"        if (b3MprVec3Eq(&b3MprSimplexPoint(portal, 1)->v, b3mpr_vec3_origin)){\n"
+	"            // origin lies on v1\n"
+	"            return 1;\n"
+	"        }else{\n"
+	"            // origin lies on v0-v1 segment\n"
+	"            return 2;\n"
+	"        }\n"
+	"    }\n"
+	"    b3MprVec3Normalize(&dir);\n"
+	"	 b3MprSupport(pairIndex,bodyIndexA,bodyIndexB,cpuBodyBuf,cpuConvexData,cpuCollidables,cpuVertices, sepAxis,&dir, b3MprSimplexPointW(portal, 2));\n"
+	"    \n"
+	"    dot = b3MprVec3Dot(&b3MprSimplexPoint(portal, 2)->v, &dir);\n"
+	"    if (b3MprIsZero(dot) || dot < 0.f)\n"
+	"        return -1;\n"
+	"    b3MprSimplexSetSize(portal, 3);\n"
+	"    // vertex 3 direction\n"
+	"    b3MprVec3Sub2(&va, &b3MprSimplexPoint(portal, 1)->v,\n"
+	"                     &b3MprSimplexPoint(portal, 0)->v);\n"
+	"    b3MprVec3Sub2(&vb, &b3MprSimplexPoint(portal, 2)->v,\n"
+	"                     &b3MprSimplexPoint(portal, 0)->v);\n"
+	"    b3MprVec3Cross(&dir, &va, &vb);\n"
+	"    b3MprVec3Normalize(&dir);\n"
+	"    // it is better to form portal faces to be oriented \"outside\" origin\n"
+	"    dot = b3MprVec3Dot(&dir, &b3MprSimplexPoint(portal, 0)->v);\n"
+	"    if (dot > 0.f){\n"
+	"        b3MprSimplexSwap(portal, 1, 2);\n"
+	"        b3MprVec3Scale(&dir, -1.f);\n"
+	"    }\n"
+	"    while (b3MprSimplexSize(portal) < 4){\n"
+	"		 b3MprSupport(pairIndex,bodyIndexA,bodyIndexB,cpuBodyBuf,cpuConvexData,cpuCollidables,cpuVertices, sepAxis,&dir, b3MprSimplexPointW(portal, 3));\n"
+	"        \n"
+	"        dot = b3MprVec3Dot(&b3MprSimplexPoint(portal, 3)->v, &dir);\n"
+	"        if (b3MprIsZero(dot) || dot < 0.f)\n"
+	"            return -1;\n"
+	"        cont = 0;\n"
+	"        // test if origin is outside (v1, v0, v3) - set v2 as v3 and\n"
+	"        // continue\n"
+	"        b3MprVec3Cross(&va, &b3MprSimplexPoint(portal, 1)->v,\n"
+	"                          &b3MprSimplexPoint(portal, 3)->v);\n"
+	"        dot = b3MprVec3Dot(&va, &b3MprSimplexPoint(portal, 0)->v);\n"
+	"        if (dot < 0.f && !b3MprIsZero(dot)){\n"
+	"            b3MprSimplexSet(portal, 2, b3MprSimplexPoint(portal, 3));\n"
+	"            cont = 1;\n"
+	"        }\n"
+	"        if (!cont){\n"
+	"            // test if origin is outside (v3, v0, v2) - set v1 as v3 and\n"
+	"            // continue\n"
+	"            b3MprVec3Cross(&va, &b3MprSimplexPoint(portal, 3)->v,\n"
+	"                              &b3MprSimplexPoint(portal, 2)->v);\n"
+	"            dot = b3MprVec3Dot(&va, &b3MprSimplexPoint(portal, 0)->v);\n"
+	"            if (dot < 0.f && !b3MprIsZero(dot)){\n"
+	"                b3MprSimplexSet(portal, 1, b3MprSimplexPoint(portal, 3));\n"
+	"                cont = 1;\n"
+	"            }\n"
+	"        }\n"
+	"        if (cont){\n"
+	"            b3MprVec3Sub2(&va, &b3MprSimplexPoint(portal, 1)->v,\n"
+	"                             &b3MprSimplexPoint(portal, 0)->v);\n"
+	"            b3MprVec3Sub2(&vb, &b3MprSimplexPoint(portal, 2)->v,\n"
+	"                             &b3MprSimplexPoint(portal, 0)->v);\n"
+	"            b3MprVec3Cross(&dir, &va, &vb);\n"
+	"            b3MprVec3Normalize(&dir);\n"
+	"        }else{\n"
+	"            b3MprSimplexSetSize(portal, 4);\n"
+	"        }\n"
+	"    }\n"
+	"    return 0;\n"
+	"}\n"
+	"B3_STATIC int b3RefinePortal(int pairIndex,int bodyIndexA, int bodyIndexB,  b3ConstArray(b3RigidBodyData_t) cpuBodyBuf, \n"
+	"													b3ConstArray(b3ConvexPolyhedronData_t) cpuConvexData, \n"
+	"													b3ConstArray(b3Collidable_t)				cpuCollidables,\n"
+	"													b3ConstArray(b3Float4)					cpuVertices,\n"
+	"													__global b3Float4* sepAxis,\n"
+	"													b3MprSimplex_t *portal)\n"
+	"{\n"
+	"    b3Float4 dir;\n"
+	"    b3MprSupport_t v4;\n"
+	"	for (int i=0;i<B3_MPR_MAX_ITERATIONS;i++)\n"
+	"    //while (1)\n"
+	"	{\n"
+	"        // compute direction outside the portal (from v0 throught v1,v2,v3\n"
+	"        // face)\n"
+	"        b3PortalDir(portal, &dir);\n"
+	"        // test if origin is inside the portal\n"
+	"        if (portalEncapsulesOrigin(portal, &dir))\n"
+	"            return 0;\n"
+	"        // get next support point\n"
+	"        \n"
+	"		 b3MprSupport(pairIndex,bodyIndexA,bodyIndexB,cpuBodyBuf,cpuConvexData,cpuCollidables,cpuVertices, sepAxis,&dir, &v4);\n"
+	"        // test if v4 can expand portal to contain origin and if portal\n"
+	"        // expanding doesn't reach given tolerance\n"
+	"        if (!portalCanEncapsuleOrigin(portal, &v4, &dir)\n"
+	"                || portalReachTolerance(portal, &v4, &dir))\n"
+	"		{\n"
+	"            return -1;\n"
+	"        }\n"
+	"        // v1-v2-v3 triangle must be rearranged to face outside Minkowski\n"
+	"        // difference (direction from v0).\n"
+	"        b3ExpandPortal(portal, &v4);\n"
+	"    }\n"
+	"    return -1;\n"
+	"}\n"
+	"B3_STATIC void b3FindPos(const b3MprSimplex_t *portal, b3Float4 *pos)\n"
+	"{\n"
+	"	b3Float4 zero = b3MakeFloat4(0,0,0,0);\n"
+	"	b3Float4* b3mpr_vec3_origin = &zero;\n"
+	"    b3Float4 dir;\n"
+	"    size_t i;\n"
+	"    float b[4], sum, inv;\n"
+	"    b3Float4 vec, p1, p2;\n"
+	"    b3PortalDir(portal, &dir);\n"
+	"    // use barycentric coordinates of tetrahedron to find origin\n"
+	"    b3MprVec3Cross(&vec, &b3MprSimplexPoint(portal, 1)->v,\n"
+	"                       &b3MprSimplexPoint(portal, 2)->v);\n"
+	"    b[0] = b3MprVec3Dot(&vec, &b3MprSimplexPoint(portal, 3)->v);\n"
+	"    b3MprVec3Cross(&vec, &b3MprSimplexPoint(portal, 3)->v,\n"
+	"                       &b3MprSimplexPoint(portal, 2)->v);\n"
+	"    b[1] = b3MprVec3Dot(&vec, &b3MprSimplexPoint(portal, 0)->v);\n"
+	"    b3MprVec3Cross(&vec, &b3MprSimplexPoint(portal, 0)->v,\n"
+	"                       &b3MprSimplexPoint(portal, 1)->v);\n"
+	"    b[2] = b3MprVec3Dot(&vec, &b3MprSimplexPoint(portal, 3)->v);\n"
+	"    b3MprVec3Cross(&vec, &b3MprSimplexPoint(portal, 2)->v,\n"
+	"                       &b3MprSimplexPoint(portal, 1)->v);\n"
+	"    b[3] = b3MprVec3Dot(&vec, &b3MprSimplexPoint(portal, 0)->v);\n"
+	"	sum = b[0] + b[1] + b[2] + b[3];\n"
+	"    if (b3MprIsZero(sum) || sum < 0.f){\n"
+	"		b[0] = 0.f;\n"
+	"        b3MprVec3Cross(&vec, &b3MprSimplexPoint(portal, 2)->v,\n"
+	"                           &b3MprSimplexPoint(portal, 3)->v);\n"
+	"        b[1] = b3MprVec3Dot(&vec, &dir);\n"
+	"        b3MprVec3Cross(&vec, &b3MprSimplexPoint(portal, 3)->v,\n"
+	"                           &b3MprSimplexPoint(portal, 1)->v);\n"
+	"        b[2] = b3MprVec3Dot(&vec, &dir);\n"
+	"        b3MprVec3Cross(&vec, &b3MprSimplexPoint(portal, 1)->v,\n"
+	"                           &b3MprSimplexPoint(portal, 2)->v);\n"
+	"        b[3] = b3MprVec3Dot(&vec, &dir);\n"
+	"		sum = b[1] + b[2] + b[3];\n"
+	"	}\n"
+	"	inv = 1.f / sum;\n"
+	"    b3MprVec3Copy(&p1, b3mpr_vec3_origin);\n"
+	"    b3MprVec3Copy(&p2, b3mpr_vec3_origin);\n"
+	"    for (i = 0; i < 4; i++){\n"
+	"        b3MprVec3Copy(&vec, &b3MprSimplexPoint(portal, i)->v1);\n"
+	"        b3MprVec3Scale(&vec, b[i]);\n"
+	"        b3MprVec3Add(&p1, &vec);\n"
+	"        b3MprVec3Copy(&vec, &b3MprSimplexPoint(portal, i)->v2);\n"
+	"        b3MprVec3Scale(&vec, b[i]);\n"
+	"        b3MprVec3Add(&p2, &vec);\n"
+	"    }\n"
+	"    b3MprVec3Scale(&p1, inv);\n"
+	"    b3MprVec3Scale(&p2, inv);\n"
+	"    b3MprVec3Copy(pos, &p1);\n"
+	"    b3MprVec3Add(pos, &p2);\n"
+	"    b3MprVec3Scale(pos, 0.5);\n"
+	"}\n"
+	"inline float b3MprVec3Dist2(const b3Float4 *a, const b3Float4 *b)\n"
+	"{\n"
+	"    b3Float4 ab;\n"
+	"    b3MprVec3Sub2(&ab, a, b);\n"
+	"    return b3MprVec3Len2(&ab);\n"
+	"}\n"
+	"inline float _b3MprVec3PointSegmentDist2(const b3Float4 *P,\n"
+	"                                                  const b3Float4 *x0,\n"
+	"                                                  const b3Float4 *b,\n"
+	"                                                  b3Float4 *witness)\n"
+	"{\n"
+	"    // The computation comes from solving equation of segment:\n"
+	"    //      S(t) = x0 + t.d\n"
+	"    //          where - x0 is initial point of segment\n"
+	"    //                - d is direction of segment from x0 (|d| > 0)\n"
+	"    //                - t belongs to <0, 1> interval\n"
+	"    // \n"
+	"    // Than, distance from a segment to some point P can be expressed:\n"
+	"    //      D(t) = |x0 + t.d - P|^2\n"
+	"    //          which is distance from any point on segment. Minimization\n"
+	"    //          of this function brings distance from P to segment.\n"
+	"    // Minimization of D(t) leads to simple quadratic equation that's\n"
+	"    // solving is straightforward.\n"
+	"    //\n"
+	"    // Bonus of this method is witness point for free.\n"
+	"    float dist, t;\n"
+	"    b3Float4 d, a;\n"
+	"    // direction of segment\n"
+	"    b3MprVec3Sub2(&d, b, x0);\n"
+	"    // precompute vector from P to x0\n"
+	"    b3MprVec3Sub2(&a, x0, P);\n"
+	"    t  = -1.f * b3MprVec3Dot(&a, &d);\n"
+	"    t /= b3MprVec3Len2(&d);\n"
+	"    if (t < 0.f || b3MprIsZero(t)){\n"
+	"        dist = b3MprVec3Dist2(x0, P);\n"
+	"        if (witness)\n"
+	"            b3MprVec3Copy(witness, x0);\n"
+	"    }else if (t > 1.f || b3MprEq(t, 1.f)){\n"
+	"        dist = b3MprVec3Dist2(b, P);\n"
+	"        if (witness)\n"
+	"            b3MprVec3Copy(witness, b);\n"
+	"    }else{\n"
+	"        if (witness){\n"
+	"            b3MprVec3Copy(witness, &d);\n"
+	"            b3MprVec3Scale(witness, t);\n"
+	"            b3MprVec3Add(witness, x0);\n"
+	"            dist = b3MprVec3Dist2(witness, P);\n"
+	"        }else{\n"
+	"            // recycling variables\n"
+	"            b3MprVec3Scale(&d, t);\n"
+	"            b3MprVec3Add(&d, &a);\n"
+	"            dist = b3MprVec3Len2(&d);\n"
+	"        }\n"
+	"    }\n"
+	"    return dist;\n"
+	"}\n"
+	"inline float b3MprVec3PointTriDist2(const b3Float4 *P,\n"
+	"                                const b3Float4 *x0, const b3Float4 *B,\n"
+	"                                const b3Float4 *C,\n"
+	"                                b3Float4 *witness)\n"
+	"{\n"
+	"    // Computation comes from analytic expression for triangle (x0, B, C)\n"
+	"    //      T(s, t) = x0 + s.d1 + t.d2, where d1 = B - x0 and d2 = C - x0 and\n"
+	"    // Then equation for distance is:\n"
+	"    //      D(s, t) = | T(s, t) - P |^2\n"
+	"    // This leads to minimization of quadratic function of two variables.\n"
+	"    // The solution from is taken only if s is between 0 and 1, t is\n"
+	"    // between 0 and 1 and t + s < 1, otherwise distance from segment is\n"
+	"    // computed.\n"
+	"    b3Float4 d1, d2, a;\n"
+	"    float u, v, w, p, q, r;\n"
+	"    float s, t, dist, dist2;\n"
+	"    b3Float4 witness2;\n"
+	"    b3MprVec3Sub2(&d1, B, x0);\n"
+	"    b3MprVec3Sub2(&d2, C, x0);\n"
+	"    b3MprVec3Sub2(&a, x0, P);\n"
+	"    u = b3MprVec3Dot(&a, &a);\n"
+	"    v = b3MprVec3Dot(&d1, &d1);\n"
+	"    w = b3MprVec3Dot(&d2, &d2);\n"
+	"    p = b3MprVec3Dot(&a, &d1);\n"
+	"    q = b3MprVec3Dot(&a, &d2);\n"
+	"    r = b3MprVec3Dot(&d1, &d2);\n"
+	"    s = (q * r - w * p) / (w * v - r * r);\n"
+	"    t = (-s * r - q) / w;\n"
+	"    if ((b3MprIsZero(s) || s > 0.f)\n"
+	"            && (b3MprEq(s, 1.f) || s < 1.f)\n"
+	"            && (b3MprIsZero(t) || t > 0.f)\n"
+	"            && (b3MprEq(t, 1.f) || t < 1.f)\n"
+	"            && (b3MprEq(t + s, 1.f) || t + s < 1.f)){\n"
+	"        if (witness){\n"
+	"            b3MprVec3Scale(&d1, s);\n"
+	"            b3MprVec3Scale(&d2, t);\n"
+	"            b3MprVec3Copy(witness, x0);\n"
+	"            b3MprVec3Add(witness, &d1);\n"
+	"            b3MprVec3Add(witness, &d2);\n"
+	"            dist = b3MprVec3Dist2(witness, P);\n"
+	"        }else{\n"
+	"            dist  = s * s * v;\n"
+	"            dist += t * t * w;\n"
+	"            dist += 2.f * s * t * r;\n"
+	"            dist += 2.f * s * p;\n"
+	"            dist += 2.f * t * q;\n"
+	"            dist += u;\n"
+	"        }\n"
+	"    }else{\n"
+	"        dist = _b3MprVec3PointSegmentDist2(P, x0, B, witness);\n"
+	"        dist2 = _b3MprVec3PointSegmentDist2(P, x0, C, &witness2);\n"
+	"        if (dist2 < dist){\n"
+	"            dist = dist2;\n"
+	"            if (witness)\n"
+	"                b3MprVec3Copy(witness, &witness2);\n"
+	"        }\n"
+	"        dist2 = _b3MprVec3PointSegmentDist2(P, B, C, &witness2);\n"
+	"        if (dist2 < dist){\n"
+	"            dist = dist2;\n"
+	"            if (witness)\n"
+	"                b3MprVec3Copy(witness, &witness2);\n"
+	"        }\n"
+	"    }\n"
+	"    return dist;\n"
+	"}\n"
+	"B3_STATIC void b3FindPenetr(int pairIndex,int bodyIndexA, int bodyIndexB,  b3ConstArray(b3RigidBodyData_t) cpuBodyBuf, \n"
+	"													b3ConstArray(b3ConvexPolyhedronData_t) cpuConvexData, \n"
+	"													b3ConstArray(b3Collidable_t)				cpuCollidables,\n"
+	"													b3ConstArray(b3Float4)					cpuVertices,\n"
+	"													__global b3Float4* sepAxis,\n"
+	"                       b3MprSimplex_t *portal,\n"
+	"                       float *depth, b3Float4 *pdir, b3Float4 *pos)\n"
+	"{\n"
+	"    b3Float4 dir;\n"
+	"    b3MprSupport_t v4;\n"
+	"    unsigned long iterations;\n"
+	"	b3Float4 zero = b3MakeFloat4(0,0,0,0);\n"
+	"	b3Float4* b3mpr_vec3_origin = &zero;\n"
+	"    iterations = 1UL;\n"
+	"	for (int i=0;i<B3_MPR_MAX_ITERATIONS;i++)\n"
+	"    //while (1)\n"
+	"	{\n"
+	"        // compute portal direction and obtain next support point\n"
+	"        b3PortalDir(portal, &dir);\n"
+	"        \n"
+	"		 b3MprSupport(pairIndex,bodyIndexA,bodyIndexB,cpuBodyBuf,cpuConvexData,cpuCollidables,cpuVertices, sepAxis,&dir, &v4);\n"
+	"        // reached tolerance -> find penetration info\n"
+	"        if (portalReachTolerance(portal, &v4, &dir)\n"
+	"                || iterations ==B3_MPR_MAX_ITERATIONS)\n"
+	"		{\n"
+	"            *depth = b3MprVec3PointTriDist2(b3mpr_vec3_origin,&b3MprSimplexPoint(portal, 1)->v,&b3MprSimplexPoint(portal, 2)->v,&b3MprSimplexPoint(portal, 3)->v,pdir);\n"
+	"            *depth = B3_MPR_SQRT(*depth);\n"
+	"			\n"
+	"			if (b3MprIsZero((*pdir).x) && b3MprIsZero((*pdir).y) && b3MprIsZero((*pdir).z))\n"
+	"			{\n"
+	"				\n"
+	"				*pdir = dir;\n"
+	"			} \n"
+	"			b3MprVec3Normalize(pdir);\n"
+	"			\n"
+	"            // barycentric coordinates:\n"
+	"            b3FindPos(portal, pos);\n"
+	"            return;\n"
+	"        }\n"
+	"        b3ExpandPortal(portal, &v4);\n"
+	"        iterations++;\n"
+	"    }\n"
+	"}\n"
+	"B3_STATIC void b3FindPenetrTouch(b3MprSimplex_t *portal,float *depth, b3Float4 *dir, b3Float4 *pos)\n"
+	"{\n"
+	"    // Touching contact on portal's v1 - so depth is zero and direction\n"
+	"    // is unimportant and pos can be guessed\n"
+	"    *depth = 0.f;\n"
+	"    b3Float4 zero = b3MakeFloat4(0,0,0,0);\n"
+	"	b3Float4* b3mpr_vec3_origin = &zero;\n"
+	"	b3MprVec3Copy(dir, b3mpr_vec3_origin);\n"
+	"    b3MprVec3Copy(pos, &b3MprSimplexPoint(portal, 1)->v1);\n"
+	"    b3MprVec3Add(pos, &b3MprSimplexPoint(portal, 1)->v2);\n"
+	"    b3MprVec3Scale(pos, 0.5);\n"
+	"}\n"
+	"B3_STATIC void b3FindPenetrSegment(b3MprSimplex_t *portal,\n"
+	"                              float *depth, b3Float4 *dir, b3Float4 *pos)\n"
+	"{\n"
+	"    \n"
+	"    // Origin lies on v0-v1 segment.\n"
+	"    // Depth is distance to v1, direction also and position must be\n"
+	"    // computed\n"
+	"    b3MprVec3Copy(pos, &b3MprSimplexPoint(portal, 1)->v1);\n"
+	"    b3MprVec3Add(pos, &b3MprSimplexPoint(portal, 1)->v2);\n"
+	"    b3MprVec3Scale(pos, 0.5f);\n"
+	"    \n"
+	"    b3MprVec3Copy(dir, &b3MprSimplexPoint(portal, 1)->v);\n"
+	"    *depth = B3_MPR_SQRT(b3MprVec3Len2(dir));\n"
+	"    b3MprVec3Normalize(dir);\n"
+	"}\n"
+	"inline int b3MprPenetration(int pairIndex, int bodyIndexA, int bodyIndexB,\n"
+	"					b3ConstArray(b3RigidBodyData_t) cpuBodyBuf,\n"
+	"					b3ConstArray(b3ConvexPolyhedronData_t) cpuConvexData, \n"
+	"					b3ConstArray(b3Collidable_t)	cpuCollidables,\n"
+	"					b3ConstArray(b3Float4)	cpuVertices,\n"
+	"					__global b3Float4* sepAxis,\n"
+	"					__global int*	hasSepAxis,\n"
+	"					float *depthOut, b3Float4* dirOut, b3Float4* posOut)\n"
+	"{\n"
+	"	\n"
+	"	 b3MprSimplex_t portal;\n"
+	"	 \n"
+	"//	if (!hasSepAxis[pairIndex])\n"
+	"	//	return -1;\n"
+	"	\n"
+	"	hasSepAxis[pairIndex] = 0;\n"
+	"	 int res;\n"
+	"    // Phase 1: Portal discovery\n"
+	"    res = b3DiscoverPortal(pairIndex,bodyIndexA,bodyIndexB,cpuBodyBuf,cpuConvexData,cpuCollidables,cpuVertices,sepAxis,hasSepAxis, &portal);\n"
+	"	\n"
+	"	  \n"
+	"	//sepAxis[pairIndex] = *pdir;//or -dir?\n"
+	"	switch (res)\n"
+	"	{\n"
+	"	case 0:\n"
+	"		{\n"
+	"			// Phase 2: Portal refinement\n"
+	"		\n"
+	"			res = b3RefinePortal(pairIndex,bodyIndexA,bodyIndexB,cpuBodyBuf,cpuConvexData,cpuCollidables,cpuVertices, sepAxis,&portal);\n"
+	"			if (res < 0)\n"
+	"				return -1;\n"
+	"			// Phase 3. Penetration info\n"
+	"			b3FindPenetr(pairIndex,bodyIndexA,bodyIndexB,cpuBodyBuf,cpuConvexData,cpuCollidables,cpuVertices, sepAxis,&portal, depthOut, dirOut, posOut);\n"
+	"			hasSepAxis[pairIndex] = 1;\n"
+	"			sepAxis[pairIndex] = -*dirOut;\n"
+	"			break;\n"
+	"		}\n"
+	"	case 1:\n"
+	"		{\n"
+	"			 // Touching contact on portal's v1.\n"
+	"			b3FindPenetrTouch(&portal, depthOut, dirOut, posOut);\n"
+	"			break;\n"
+	"		}\n"
+	"	case 2:\n"
+	"		{\n"
+	"			\n"
+	"			b3FindPenetrSegment( &portal, depthOut, dirOut, posOut);\n"
+	"			break;\n"
+	"		}\n"
+	"	default:\n"
+	"		{\n"
+	"			hasSepAxis[pairIndex]=0;\n"
+	"			//if (res < 0)\n"
+	"			//{\n"
+	"				// Origin isn't inside portal - no collision.\n"
+	"				return -1;\n"
+	"			//}\n"
+	"		}\n"
+	"	};\n"
+	"	\n"
+	"	return 0;\n"
+	"};\n"
+	"#endif //B3_MPR_PENETRATION_H\n"
+	"#ifndef B3_CONTACT4DATA_H\n"
+	"#define B3_CONTACT4DATA_H\n"
+	"#ifndef B3_FLOAT4_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif \n"
+	"#endif //B3_FLOAT4_H\n"
+	"typedef  struct b3Contact4Data b3Contact4Data_t;\n"
+	"struct b3Contact4Data\n"
+	"{\n"
+	"	b3Float4	m_worldPosB[4];\n"
+	"//	b3Float4	m_localPosA[4];\n"
+	"//	b3Float4	m_localPosB[4];\n"
+	"	b3Float4	m_worldNormalOnB;	//	w: m_nPoints\n"
+	"	unsigned short  m_restituitionCoeffCmp;\n"
+	"	unsigned short  m_frictionCoeffCmp;\n"
+	"	int m_batchIdx;\n"
+	"	int m_bodyAPtrAndSignBit;//x:m_bodyAPtr, y:m_bodyBPtr\n"
+	"	int m_bodyBPtrAndSignBit;\n"
+	"	int	m_childIndexA;\n"
+	"	int	m_childIndexB;\n"
+	"	int m_unused1;\n"
+	"	int m_unused2;\n"
+	"};\n"
+	"inline int b3Contact4Data_getNumPoints(const struct b3Contact4Data* contact)\n"
+	"{\n"
+	"	return (int)contact->m_worldNormalOnB.w;\n"
+	"};\n"
+	"inline void b3Contact4Data_setNumPoints(struct b3Contact4Data* contact, int numPoints)\n"
+	"{\n"
+	"	contact->m_worldNormalOnB.w = (float)numPoints;\n"
+	"};\n"
+	"#endif //B3_CONTACT4DATA_H\n"
+	"#define AppendInc(x, out) out = atomic_inc(x)\n"
+	"#define GET_NPOINTS(x) (x).m_worldNormalOnB.w\n"
+	"#ifdef cl_ext_atomic_counters_32\n"
+	"	#pragma OPENCL EXTENSION cl_ext_atomic_counters_32 : enable\n"
+	"#else\n"
+	"	#define counter32_t volatile __global int*\n"
+	"#endif\n"
+	"__kernel void   mprPenetrationKernel( __global int4* pairs,\n"
+	"																					__global const b3RigidBodyData_t* rigidBodies, \n"
+	"																					__global const b3Collidable_t* collidables,\n"
+	"																					__global const b3ConvexPolyhedronData_t* convexShapes, \n"
+	"																					__global const float4* vertices,\n"
+	"																					__global float4* separatingNormals,\n"
+	"																					__global int* hasSeparatingAxis,\n"
+	"																					__global struct b3Contact4Data* restrict globalContactsOut,\n"
+	"																					counter32_t nGlobalContactsOut,\n"
+	"																					int contactCapacity,\n"
+	"																					int numPairs)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	int pairIndex = i;\n"
+	"	if (i<numPairs)\n"
+	"	{\n"
+	"		int bodyIndexA = pairs[i].x;\n"
+	"		int bodyIndexB = pairs[i].y;\n"
+	"		int collidableIndexA = rigidBodies[bodyIndexA].m_collidableIdx;\n"
+	"		int collidableIndexB = rigidBodies[bodyIndexB].m_collidableIdx;\n"
+	"	\n"
+	"		int shapeIndexA = collidables[collidableIndexA].m_shapeIndex;\n"
+	"		int shapeIndexB = collidables[collidableIndexB].m_shapeIndex;\n"
+	"		\n"
+	"		\n"
+	"		//once the broadphase avoids static-static pairs, we can remove this test\n"
+	"		if ((rigidBodies[bodyIndexA].m_invMass==0) &&(rigidBodies[bodyIndexB].m_invMass==0))\n"
+	"		{\n"
+	"			return;\n"
+	"		}\n"
+	"		\n"
+	"		if ((collidables[collidableIndexA].m_shapeType!=SHAPE_CONVEX_HULL) ||(collidables[collidableIndexB].m_shapeType!=SHAPE_CONVEX_HULL))\n"
+	"		{\n"
+	"			return;\n"
+	"		}\n"
+	"		float depthOut;\n"
+	"		b3Float4 dirOut;\n"
+	"		b3Float4 posOut;\n"
+	"		int res = b3MprPenetration(pairIndex, bodyIndexA, bodyIndexB,rigidBodies,convexShapes,collidables,vertices,separatingNormals,hasSeparatingAxis,&depthOut, &dirOut, &posOut);\n"
+	"		\n"
+	"		\n"
+	"		\n"
+	"		\n"
+	"		if (res==0)\n"
+	"		{\n"
+	"			//add a contact\n"
+	"			int dstIdx;\n"
+	"			AppendInc( nGlobalContactsOut, dstIdx );\n"
+	"			if (dstIdx<contactCapacity)\n"
+	"			{\n"
+	"				pairs[pairIndex].z = dstIdx;\n"
+	"				__global struct b3Contact4Data* c = globalContactsOut + dstIdx;\n"
+	"				c->m_worldNormalOnB = -dirOut;//normal;\n"
+	"				c->m_restituitionCoeffCmp = (0.f*0xffff);c->m_frictionCoeffCmp = (0.7f*0xffff);\n"
+	"				c->m_batchIdx = pairIndex;\n"
+	"				int bodyA = pairs[pairIndex].x;\n"
+	"				int bodyB = pairs[pairIndex].y;\n"
+	"				c->m_bodyAPtrAndSignBit = rigidBodies[bodyA].m_invMass==0 ? -bodyA:bodyA;\n"
+	"				c->m_bodyBPtrAndSignBit = rigidBodies[bodyB].m_invMass==0 ? -bodyB:bodyB;\n"
+	"				c->m_childIndexA = -1;\n"
+	"				c->m_childIndexB = -1;\n"
+	"				//for (int i=0;i<nContacts;i++)\n"
+	"				posOut.w = -depthOut;\n"
+	"				c->m_worldPosB[0] = posOut;//localPoints[contactIdx[i]];\n"
+	"				GET_NPOINTS(*c) = 1;//nContacts;\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"}\n"
+	"typedef float4 Quaternion;\n"
+	"#define make_float4 (float4)\n"
+	"__inline\n"
+	"float dot3F4(float4 a, float4 b)\n"
+	"{\n"
+	"	float4 a1 = make_float4(a.xyz,0.f);\n"
+	"	float4 b1 = make_float4(b.xyz,0.f);\n"
+	"	return dot(a1, b1);\n"
+	"}\n"
+	"__inline\n"
+	"float4 cross3(float4 a, float4 b)\n"
+	"{\n"
+	"	return cross(a,b);\n"
+	"}\n"
+	"__inline\n"
+	"Quaternion qtMul(Quaternion a, Quaternion b)\n"
+	"{\n"
+	"	Quaternion ans;\n"
+	"	ans = cross3( a, b );\n"
+	"	ans += a.w*b+b.w*a;\n"
+	"//	ans.w = a.w*b.w - (a.x*b.x+a.y*b.y+a.z*b.z);\n"
+	"	ans.w = a.w*b.w - dot3F4(a, b);\n"
+	"	return ans;\n"
+	"}\n"
+	"__inline\n"
+	"Quaternion qtInvert(Quaternion q)\n"
+	"{\n"
+	"	return (Quaternion)(-q.xyz, q.w);\n"
+	"}\n"
+	"__inline\n"
+	"float4 qtRotate(Quaternion q, float4 vec)\n"
+	"{\n"
+	"	Quaternion qInv = qtInvert( q );\n"
+	"	float4 vcpy = vec;\n"
+	"	vcpy.w = 0.f;\n"
+	"	float4 out = qtMul(qtMul(q,vcpy),qInv);\n"
+	"	return out;\n"
+	"}\n"
+	"__inline\n"
+	"float4 transform(const float4* p, const float4* translation, const Quaternion* orientation)\n"
+	"{\n"
+	"	return qtRotate( *orientation, *p ) + (*translation);\n"
+	"}\n"
+	"__inline\n"
+	"float4 qtInvRotate(const Quaternion q, float4 vec)\n"
+	"{\n"
+	"	return qtRotate( qtInvert( q ), vec );\n"
+	"}\n"
+	"inline void project(__global const b3ConvexPolyhedronData_t* hull,  const float4 pos, const float4 orn, \n"
+	"const float4* dir, __global const float4* vertices, float* min, float* max)\n"
+	"{\n"
+	"	min[0] = FLT_MAX;\n"
+	"	max[0] = -FLT_MAX;\n"
+	"	int numVerts = hull->m_numVertices;\n"
+	"	const float4 localDir = qtInvRotate(orn,*dir);\n"
+	"	float offset = dot(pos,*dir);\n"
+	"	for(int i=0;i<numVerts;i++)\n"
+	"	{\n"
+	"		float dp = dot(vertices[hull->m_vertexOffset+i],localDir);\n"
+	"		if(dp < min[0])	\n"
+	"			min[0] = dp;\n"
+	"		if(dp > max[0])	\n"
+	"			max[0] = dp;\n"
+	"	}\n"
+	"	if(min[0]>max[0])\n"
+	"	{\n"
+	"		float tmp = min[0];\n"
+	"		min[0] = max[0];\n"
+	"		max[0] = tmp;\n"
+	"	}\n"
+	"	min[0] += offset;\n"
+	"	max[0] += offset;\n"
+	"}\n"
+	"bool findSeparatingAxisUnitSphere(	__global const b3ConvexPolyhedronData_t* hullA, __global const b3ConvexPolyhedronData_t* hullB, \n"
+	"	const float4 posA1,\n"
+	"	const float4 ornA,\n"
+	"	const float4 posB1,\n"
+	"	const float4 ornB,\n"
+	"	const float4 DeltaC2,\n"
+	"	__global const float4* vertices,\n"
+	"	__global const float4* unitSphereDirections,\n"
+	"	int numUnitSphereDirections,\n"
+	"	float4* sep,\n"
+	"	float* dmin)\n"
+	"{\n"
+	"	\n"
+	"	float4 posA = posA1;\n"
+	"	posA.w = 0.f;\n"
+	"	float4 posB = posB1;\n"
+	"	posB.w = 0.f;\n"
+	"	int curPlaneTests=0;\n"
+	"	int curEdgeEdge = 0;\n"
+	"	// Test unit sphere directions\n"
+	"	for (int i=0;i<numUnitSphereDirections;i++)\n"
+	"	{\n"
+	"		float4 crossje;\n"
+	"		crossje = unitSphereDirections[i];	\n"
+	"		if (dot3F4(DeltaC2,crossje)>0)\n"
+	"			crossje *= -1.f;\n"
+	"		{\n"
+	"			float dist;\n"
+	"			bool result = true;\n"
+	"			float Min0,Max0;\n"
+	"			float Min1,Max1;\n"
+	"			project(hullA,posA,ornA,&crossje,vertices, &Min0, &Max0);\n"
+	"			project(hullB,posB,ornB,&crossje,vertices, &Min1, &Max1);\n"
+	"		\n"
+	"			if(Max0<Min1 || Max1<Min0)\n"
+	"				return false;\n"
+	"		\n"
+	"			float d0 = Max0 - Min1;\n"
+	"			float d1 = Max1 - Min0;\n"
+	"			dist = d0<d1 ? d0:d1;\n"
+	"			result = true;\n"
+	"	\n"
+	"			if(dist<*dmin)\n"
+	"			{\n"
+	"				*dmin = dist;\n"
+	"				*sep = crossje;\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"	\n"
+	"	if((dot3F4(-DeltaC2,*sep))>0.0f)\n"
+	"	{\n"
+	"		*sep = -(*sep);\n"
+	"	}\n"
+	"	return true;\n"
+	"}\n"
+	"__kernel void   findSeparatingAxisUnitSphereKernel( __global const int4* pairs, \n"
+	"																					__global const b3RigidBodyData_t* rigidBodies, \n"
+	"																					__global const b3Collidable_t* collidables,\n"
+	"																					__global const b3ConvexPolyhedronData_t* convexShapes, \n"
+	"																					__global const float4* vertices,\n"
+	"																					__global const float4* unitSphereDirections,\n"
+	"																					__global  float4* separatingNormals,\n"
+	"																					__global  int* hasSeparatingAxis,\n"
+	"																					__global  float* dmins,\n"
+	"																					int numUnitSphereDirections,\n"
+	"																					int numPairs\n"
+	"																					)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	\n"
+	"	if (i<numPairs)\n"
+	"	{\n"
+	"		if (hasSeparatingAxis[i])\n"
+	"		{\n"
+	"	\n"
+	"			int bodyIndexA = pairs[i].x;\n"
+	"			int bodyIndexB = pairs[i].y;\n"
+	"	\n"
+	"			int collidableIndexA = rigidBodies[bodyIndexA].m_collidableIdx;\n"
+	"			int collidableIndexB = rigidBodies[bodyIndexB].m_collidableIdx;\n"
+	"		\n"
+	"			int shapeIndexA = collidables[collidableIndexA].m_shapeIndex;\n"
+	"			int shapeIndexB = collidables[collidableIndexB].m_shapeIndex;\n"
+	"			\n"
+	"			\n"
+	"			int numFacesA = convexShapes[shapeIndexA].m_numFaces;\n"
+	"	\n"
+	"			float dmin = dmins[i];\n"
+	"	\n"
+	"			float4 posA = rigidBodies[bodyIndexA].m_pos;\n"
+	"			posA.w = 0.f;\n"
+	"			float4 posB = rigidBodies[bodyIndexB].m_pos;\n"
+	"			posB.w = 0.f;\n"
+	"			float4 c0local = convexShapes[shapeIndexA].m_localCenter;\n"
+	"			float4 ornA = rigidBodies[bodyIndexA].m_quat;\n"
+	"			float4 c0 = transform(&c0local, &posA, &ornA);\n"
+	"			float4 c1local = convexShapes[shapeIndexB].m_localCenter;\n"
+	"			float4 ornB =rigidBodies[bodyIndexB].m_quat;\n"
+	"			float4 c1 = transform(&c1local,&posB,&ornB);\n"
+	"			const float4 DeltaC2 = c0 - c1;\n"
+	"			float4 sepNormal = separatingNormals[i];\n"
+	"			\n"
+	"			int numEdgeEdgeDirections = convexShapes[shapeIndexA].m_numUniqueEdges*convexShapes[shapeIndexB].m_numUniqueEdges;\n"
+	"			if (numEdgeEdgeDirections>numUnitSphereDirections)\n"
+	"			{\n"
+	"				bool sepEE = findSeparatingAxisUnitSphere(	&convexShapes[shapeIndexA], &convexShapes[shapeIndexB],posA,ornA,\n"
+	"																										posB,ornB,\n"
+	"																										DeltaC2,\n"
+	"																										vertices,unitSphereDirections,numUnitSphereDirections,&sepNormal,&dmin);\n"
+	"				if (!sepEE)\n"
+	"				{\n"
+	"					hasSeparatingAxis[i] = 0;\n"
+	"				} else\n"
+	"				{\n"
+	"					hasSeparatingAxis[i] = 1;\n"
+	"					separatingNormals[i] = sepNormal;\n"
+	"				}\n"
+	"			}\n"
+	"		}		//if (hasSeparatingAxis[i])\n"
+	"	}//(i<numPairs)\n"
+	"}\n";
diff --git a/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/kernels/primitiveContacts.h b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/kernels/primitiveContacts.h
new file mode 100644
index 00000000..b2e0a2dd
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/kernels/primitiveContacts.h
@@ -0,0 +1,1288 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* primitiveContactsKernelsCL =
+	"#ifndef B3_CONTACT4DATA_H\n"
+	"#define B3_CONTACT4DATA_H\n"
+	"#ifndef B3_FLOAT4_H\n"
+	"#define B3_FLOAT4_H\n"
+	"#ifndef B3_PLATFORM_DEFINITIONS_H\n"
+	"#define B3_PLATFORM_DEFINITIONS_H\n"
+	"struct MyTest\n"
+	"{\n"
+	"	int bla;\n"
+	"};\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"//keep B3_LARGE_FLOAT*B3_LARGE_FLOAT < FLT_MAX\n"
+	"#define B3_LARGE_FLOAT 1e18f\n"
+	"#define B3_INFINITY 1e18f\n"
+	"#define b3Assert(a)\n"
+	"#define b3ConstArray(a) __global const a*\n"
+	"#define b3AtomicInc atomic_inc\n"
+	"#define b3AtomicAdd atomic_add\n"
+	"#define b3Fabs fabs\n"
+	"#define b3Sqrt native_sqrt\n"
+	"#define b3Sin native_sin\n"
+	"#define b3Cos native_cos\n"
+	"#define B3_STATIC\n"
+	"#endif\n"
+	"#endif\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"	typedef float4	b3Float4;\n"
+	"	#define b3Float4ConstArg const b3Float4\n"
+	"	#define b3MakeFloat4 (float4)\n"
+	"	float b3Dot3F4(b3Float4ConstArg v0,b3Float4ConstArg v1)\n"
+	"	{\n"
+	"		float4 a1 = b3MakeFloat4(v0.xyz,0.f);\n"
+	"		float4 b1 = b3MakeFloat4(v1.xyz,0.f);\n"
+	"		return dot(a1, b1);\n"
+	"	}\n"
+	"	b3Float4 b3Cross3(b3Float4ConstArg v0,b3Float4ConstArg v1)\n"
+	"	{\n"
+	"		float4 a1 = b3MakeFloat4(v0.xyz,0.f);\n"
+	"		float4 b1 = b3MakeFloat4(v1.xyz,0.f);\n"
+	"		return cross(a1, b1);\n"
+	"	}\n"
+	"	#define b3MinFloat4 min\n"
+	"	#define b3MaxFloat4 max\n"
+	"	#define b3Normalized(a) normalize(a)\n"
+	"#endif \n"
+	"		\n"
+	"inline bool b3IsAlmostZero(b3Float4ConstArg v)\n"
+	"{\n"
+	"	if(b3Fabs(v.x)>1e-6 || b3Fabs(v.y)>1e-6 || b3Fabs(v.z)>1e-6)	\n"
+	"		return false;\n"
+	"	return true;\n"
+	"}\n"
+	"inline int    b3MaxDot( b3Float4ConstArg vec, __global const b3Float4* vecArray, int vecLen, float* dotOut )\n"
+	"{\n"
+	"    float maxDot = -B3_INFINITY;\n"
+	"    int i = 0;\n"
+	"    int ptIndex = -1;\n"
+	"    for( i = 0; i < vecLen; i++ )\n"
+	"    {\n"
+	"        float dot = b3Dot3F4(vecArray[i],vec);\n"
+	"            \n"
+	"        if( dot > maxDot )\n"
+	"        {\n"
+	"            maxDot = dot;\n"
+	"            ptIndex = i;\n"
+	"        }\n"
+	"    }\n"
+	"	b3Assert(ptIndex>=0);\n"
+	"    if (ptIndex<0)\n"
+	"	{\n"
+	"		ptIndex = 0;\n"
+	"	}\n"
+	"    *dotOut = maxDot;\n"
+	"    return ptIndex;\n"
+	"}\n"
+	"#endif //B3_FLOAT4_H\n"
+	"typedef  struct b3Contact4Data b3Contact4Data_t;\n"
+	"struct b3Contact4Data\n"
+	"{\n"
+	"	b3Float4	m_worldPosB[4];\n"
+	"//	b3Float4	m_localPosA[4];\n"
+	"//	b3Float4	m_localPosB[4];\n"
+	"	b3Float4	m_worldNormalOnB;	//	w: m_nPoints\n"
+	"	unsigned short  m_restituitionCoeffCmp;\n"
+	"	unsigned short  m_frictionCoeffCmp;\n"
+	"	int m_batchIdx;\n"
+	"	int m_bodyAPtrAndSignBit;//x:m_bodyAPtr, y:m_bodyBPtr\n"
+	"	int m_bodyBPtrAndSignBit;\n"
+	"	int	m_childIndexA;\n"
+	"	int	m_childIndexB;\n"
+	"	int m_unused1;\n"
+	"	int m_unused2;\n"
+	"};\n"
+	"inline int b3Contact4Data_getNumPoints(const struct b3Contact4Data* contact)\n"
+	"{\n"
+	"	return (int)contact->m_worldNormalOnB.w;\n"
+	"};\n"
+	"inline void b3Contact4Data_setNumPoints(struct b3Contact4Data* contact, int numPoints)\n"
+	"{\n"
+	"	contact->m_worldNormalOnB.w = (float)numPoints;\n"
+	"};\n"
+	"#endif //B3_CONTACT4DATA_H\n"
+	"#define SHAPE_CONVEX_HULL 3\n"
+	"#define SHAPE_PLANE 4\n"
+	"#define SHAPE_CONCAVE_TRIMESH 5\n"
+	"#define SHAPE_COMPOUND_OF_CONVEX_HULLS 6\n"
+	"#define SHAPE_SPHERE 7\n"
+	"#pragma OPENCL EXTENSION cl_amd_printf : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_local_int32_base_atomics : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_global_int32_base_atomics : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_local_int32_extended_atomics : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_global_int32_extended_atomics : enable\n"
+	"#ifdef cl_ext_atomic_counters_32\n"
+	"#pragma OPENCL EXTENSION cl_ext_atomic_counters_32 : enable\n"
+	"#else\n"
+	"#define counter32_t volatile __global int*\n"
+	"#endif\n"
+	"#define GET_GROUP_IDX get_group_id(0)\n"
+	"#define GET_LOCAL_IDX get_local_id(0)\n"
+	"#define GET_GLOBAL_IDX get_global_id(0)\n"
+	"#define GET_GROUP_SIZE get_local_size(0)\n"
+	"#define GET_NUM_GROUPS get_num_groups(0)\n"
+	"#define GROUP_LDS_BARRIER barrier(CLK_LOCAL_MEM_FENCE)\n"
+	"#define GROUP_MEM_FENCE mem_fence(CLK_LOCAL_MEM_FENCE)\n"
+	"#define AtomInc(x) atom_inc(&(x))\n"
+	"#define AtomInc1(x, out) out = atom_inc(&(x))\n"
+	"#define AppendInc(x, out) out = atomic_inc(x)\n"
+	"#define AtomAdd(x, value) atom_add(&(x), value)\n"
+	"#define AtomCmpxhg(x, cmp, value) atom_cmpxchg( &(x), cmp, value )\n"
+	"#define AtomXhg(x, value) atom_xchg ( &(x), value )\n"
+	"#define max2 max\n"
+	"#define min2 min\n"
+	"typedef unsigned int u32;\n"
+	"typedef struct \n"
+	"{\n"
+	"	union\n"
+	"	{\n"
+	"		float4	m_min;\n"
+	"		float   m_minElems[4];\n"
+	"		int			m_minIndices[4];\n"
+	"	};\n"
+	"	union\n"
+	"	{\n"
+	"		float4	m_max;\n"
+	"		float   m_maxElems[4];\n"
+	"		int			m_maxIndices[4];\n"
+	"	};\n"
+	"} btAabbCL;\n"
+	"///keep this in sync with btCollidable.h\n"
+	"typedef struct\n"
+	"{\n"
+	"	int m_numChildShapes;\n"
+	"	float m_radius;\n"
+	"	int m_shapeType;\n"
+	"	int m_shapeIndex;\n"
+	"	\n"
+	"} btCollidableGpu;\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4	m_childPosition;\n"
+	"	float4	m_childOrientation;\n"
+	"	int m_shapeIndex;\n"
+	"	int m_unused0;\n"
+	"	int m_unused1;\n"
+	"	int m_unused2;\n"
+	"} btGpuChildShape;\n"
+	"#define GET_NPOINTS(x) (x).m_worldNormalOnB.w\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4 m_pos;\n"
+	"	float4 m_quat;\n"
+	"	float4 m_linVel;\n"
+	"	float4 m_angVel;\n"
+	"	u32 m_collidableIdx;	\n"
+	"	float m_invMass;\n"
+	"	float m_restituitionCoeff;\n"
+	"	float m_frictionCoeff;\n"
+	"} BodyData;\n"
+	"typedef struct  \n"
+	"{\n"
+	"	float4		m_localCenter;\n"
+	"	float4		m_extents;\n"
+	"	float4		mC;\n"
+	"	float4		mE;\n"
+	"	\n"
+	"	float			m_radius;\n"
+	"	int	m_faceOffset;\n"
+	"	int m_numFaces;\n"
+	"	int	m_numVertices;\n"
+	"	\n"
+	"	int m_vertexOffset;\n"
+	"	int	m_uniqueEdgesOffset;\n"
+	"	int	m_numUniqueEdges;\n"
+	"	int m_unused;\n"
+	"} ConvexPolyhedronCL;\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4 m_plane;\n"
+	"	int m_indexOffset;\n"
+	"	int m_numIndices;\n"
+	"} btGpuFace;\n"
+	"#define SELECT_UINT4( b, a, condition ) select( b,a,condition )\n"
+	"#define make_float4 (float4)\n"
+	"#define make_float2 (float2)\n"
+	"#define make_uint4 (uint4)\n"
+	"#define make_int4 (int4)\n"
+	"#define make_uint2 (uint2)\n"
+	"#define make_int2 (int2)\n"
+	"__inline\n"
+	"float fastDiv(float numerator, float denominator)\n"
+	"{\n"
+	"	return native_divide(numerator, denominator);	\n"
+	"//	return numerator/denominator;	\n"
+	"}\n"
+	"__inline\n"
+	"float4 fastDiv4(float4 numerator, float4 denominator)\n"
+	"{\n"
+	"	return native_divide(numerator, denominator);	\n"
+	"}\n"
+	"__inline\n"
+	"float4 cross3(float4 a, float4 b)\n"
+	"{\n"
+	"	return cross(a,b);\n"
+	"}\n"
+	"//#define dot3F4 dot\n"
+	"__inline\n"
+	"float dot3F4(float4 a, float4 b)\n"
+	"{\n"
+	"	float4 a1 = make_float4(a.xyz,0.f);\n"
+	"	float4 b1 = make_float4(b.xyz,0.f);\n"
+	"	return dot(a1, b1);\n"
+	"}\n"
+	"__inline\n"
+	"float4 fastNormalize4(float4 v)\n"
+	"{\n"
+	"	return fast_normalize(v);\n"
+	"}\n"
+	"///////////////////////////////////////\n"
+	"//	Quaternion\n"
+	"///////////////////////////////////////\n"
+	"typedef float4 Quaternion;\n"
+	"__inline\n"
+	"Quaternion qtMul(Quaternion a, Quaternion b);\n"
+	"__inline\n"
+	"Quaternion qtNormalize(Quaternion in);\n"
+	"__inline\n"
+	"float4 qtRotate(Quaternion q, float4 vec);\n"
+	"__inline\n"
+	"Quaternion qtInvert(Quaternion q);\n"
+	"__inline\n"
+	"Quaternion qtMul(Quaternion a, Quaternion b)\n"
+	"{\n"
+	"	Quaternion ans;\n"
+	"	ans = cross3( a, b );\n"
+	"	ans += a.w*b+b.w*a;\n"
+	"//	ans.w = a.w*b.w - (a.x*b.x+a.y*b.y+a.z*b.z);\n"
+	"	ans.w = a.w*b.w - dot3F4(a, b);\n"
+	"	return ans;\n"
+	"}\n"
+	"__inline\n"
+	"Quaternion qtNormalize(Quaternion in)\n"
+	"{\n"
+	"	return fastNormalize4(in);\n"
+	"//	in /= length( in );\n"
+	"//	return in;\n"
+	"}\n"
+	"__inline\n"
+	"float4 qtRotate(Quaternion q, float4 vec)\n"
+	"{\n"
+	"	Quaternion qInv = qtInvert( q );\n"
+	"	float4 vcpy = vec;\n"
+	"	vcpy.w = 0.f;\n"
+	"	float4 out = qtMul(qtMul(q,vcpy),qInv);\n"
+	"	return out;\n"
+	"}\n"
+	"__inline\n"
+	"Quaternion qtInvert(Quaternion q)\n"
+	"{\n"
+	"	return (Quaternion)(-q.xyz, q.w);\n"
+	"}\n"
+	"__inline\n"
+	"float4 qtInvRotate(const Quaternion q, float4 vec)\n"
+	"{\n"
+	"	return qtRotate( qtInvert( q ), vec );\n"
+	"}\n"
+	"__inline\n"
+	"float4 transform(const float4* p, const float4* translation, const Quaternion* orientation)\n"
+	"{\n"
+	"	return qtRotate( *orientation, *p ) + (*translation);\n"
+	"}\n"
+	"void	trInverse(float4 translationIn, Quaternion orientationIn,\n"
+	"		float4* translationOut, Quaternion* orientationOut)\n"
+	"{\n"
+	"	*orientationOut = qtInvert(orientationIn);\n"
+	"	*translationOut = qtRotate(*orientationOut, -translationIn);\n"
+	"}\n"
+	"void	trMul(float4 translationA, Quaternion orientationA,\n"
+	"						float4 translationB, Quaternion orientationB,\n"
+	"		float4* translationOut, Quaternion* orientationOut)\n"
+	"{\n"
+	"	*orientationOut = qtMul(orientationA,orientationB);\n"
+	"	*translationOut = transform(&translationB,&translationA,&orientationA);\n"
+	"}\n"
+	"__inline\n"
+	"float4 normalize3(const float4 a)\n"
+	"{\n"
+	"	float4 n = make_float4(a.x, a.y, a.z, 0.f);\n"
+	"	return fastNormalize4( n );\n"
+	"}\n"
+	"__inline float4 lerp3(const float4 a,const float4 b, float  t)\n"
+	"{\n"
+	"	return make_float4(	a.x + (b.x - a.x) * t,\n"
+	"						a.y + (b.y - a.y) * t,\n"
+	"						a.z + (b.z - a.z) * t,\n"
+	"						0.f);\n"
+	"}\n"
+	"float signedDistanceFromPointToPlane(float4 point, float4 planeEqn, float4* closestPointOnFace)\n"
+	"{\n"
+	"	float4 n = (float4)(planeEqn.x, planeEqn.y, planeEqn.z, 0);\n"
+	"	float dist = dot3F4(n, point) + planeEqn.w;\n"
+	"	*closestPointOnFace = point - dist * n;\n"
+	"	return dist;\n"
+	"}\n"
+	"inline bool IsPointInPolygon(float4 p, \n"
+	"							const btGpuFace* face,\n"
+	"							__global const float4* baseVertex,\n"
+	"							__global const  int* convexIndices,\n"
+	"							float4* out)\n"
+	"{\n"
+	"    float4 a;\n"
+	"    float4 b;\n"
+	"    float4 ab;\n"
+	"    float4 ap;\n"
+	"    float4 v;\n"
+	"	float4 plane = make_float4(face->m_plane.x,face->m_plane.y,face->m_plane.z,0.f);\n"
+	"	\n"
+	"	if (face->m_numIndices<2)\n"
+	"		return false;\n"
+	"	\n"
+	"	float4 v0 = baseVertex[convexIndices[face->m_indexOffset + face->m_numIndices-1]];\n"
+	"	\n"
+	"	b = v0;\n"
+	"    for(unsigned i=0; i != face->m_numIndices; ++i)\n"
+	"    {\n"
+	"		a = b;\n"
+	"		float4 vi = baseVertex[convexIndices[face->m_indexOffset + i]];\n"
+	"		b = vi;\n"
+	"        ab = b-a;\n"
+	"        ap = p-a;\n"
+	"        v = cross3(ab,plane);\n"
+	"        if (dot(ap, v) > 0.f)\n"
+	"        {\n"
+	"            float ab_m2 = dot(ab, ab);\n"
+	"            float rt = ab_m2 != 0.f ? dot(ab, ap) / ab_m2 : 0.f;\n"
+	"            if (rt <= 0.f)\n"
+	"            {\n"
+	"                *out = a;\n"
+	"            }\n"
+	"            else if (rt >= 1.f) \n"
+	"            {\n"
+	"                *out = b;\n"
+	"            }\n"
+	"            else\n"
+	"            {\n"
+	"            	float s = 1.f - rt;\n"
+	"				out[0].x = s * a.x + rt * b.x;\n"
+	"				out[0].y = s * a.y + rt * b.y;\n"
+	"				out[0].z = s * a.z + rt * b.z;\n"
+	"            }\n"
+	"            return false;\n"
+	"        }\n"
+	"    }\n"
+	"    return true;\n"
+	"}\n"
+	"void	computeContactSphereConvex(int pairIndex,\n"
+	"																int bodyIndexA, int bodyIndexB, \n"
+	"																int collidableIndexA, int collidableIndexB, \n"
+	"																__global const BodyData* rigidBodies, \n"
+	"																__global const btCollidableGpu* collidables,\n"
+	"																__global const ConvexPolyhedronCL* convexShapes,\n"
+	"																__global const float4* convexVertices,\n"
+	"																__global const int* convexIndices,\n"
+	"																__global const btGpuFace* faces,\n"
+	"																__global struct b3Contact4Data* restrict globalContactsOut,\n"
+	"																counter32_t nGlobalContactsOut,\n"
+	"																int maxContactCapacity,\n"
+	"																float4 spherePos2,\n"
+	"																float radius,\n"
+	"																float4 pos,\n"
+	"																float4 quat\n"
+	"																)\n"
+	"{\n"
+	"	float4 invPos;\n"
+	"	float4 invOrn;\n"
+	"	trInverse(pos,quat, &invPos,&invOrn);\n"
+	"	float4 spherePos = transform(&spherePos2,&invPos,&invOrn);\n"
+	"	int shapeIndex = collidables[collidableIndexB].m_shapeIndex;\n"
+	"	int numFaces = convexShapes[shapeIndex].m_numFaces;\n"
+	"	float4 closestPnt = (float4)(0, 0, 0, 0);\n"
+	"	float4 hitNormalWorld = (float4)(0, 0, 0, 0);\n"
+	"	float minDist = -1000000.f;\n"
+	"	bool bCollide = true;\n"
+	"	for ( int f = 0; f < numFaces; f++ )\n"
+	"	{\n"
+	"		btGpuFace face = faces[convexShapes[shapeIndex].m_faceOffset+f];\n"
+	"		// set up a plane equation \n"
+	"		float4 planeEqn;\n"
+	"		float4 n1 = face.m_plane;\n"
+	"		n1.w = 0.f;\n"
+	"		planeEqn = n1;\n"
+	"		planeEqn.w = face.m_plane.w;\n"
+	"		\n"
+	"	\n"
+	"		// compute a signed distance from the vertex in cloth to the face of rigidbody.\n"
+	"		float4 pntReturn;\n"
+	"		float dist = signedDistanceFromPointToPlane(spherePos, planeEqn, &pntReturn);\n"
+	"		// If the distance is positive, the plane is a separating plane. \n"
+	"		if ( dist > radius )\n"
+	"		{\n"
+	"			bCollide = false;\n"
+	"			break;\n"
+	"		}\n"
+	"		if (dist>0)\n"
+	"		{\n"
+	"			//might hit an edge or vertex\n"
+	"			float4 out;\n"
+	"			float4 zeroPos = make_float4(0,0,0,0);\n"
+	"			bool isInPoly = IsPointInPolygon(spherePos,\n"
+	"					&face,\n"
+	"					&convexVertices[convexShapes[shapeIndex].m_vertexOffset],\n"
+	"					convexIndices,\n"
+	"           &out);\n"
+	"			if (isInPoly)\n"
+	"			{\n"
+	"				if (dist>minDist)\n"
+	"				{\n"
+	"					minDist = dist;\n"
+	"					closestPnt = pntReturn;\n"
+	"					hitNormalWorld = planeEqn;\n"
+	"					\n"
+	"				}\n"
+	"			} else\n"
+	"			{\n"
+	"				float4 tmp = spherePos-out;\n"
+	"				float l2 = dot(tmp,tmp);\n"
+	"				if (l2<radius*radius)\n"
+	"				{\n"
+	"					dist  = sqrt(l2);\n"
+	"					if (dist>minDist)\n"
+	"					{\n"
+	"						minDist = dist;\n"
+	"						closestPnt = out;\n"
+	"						hitNormalWorld = tmp/dist;\n"
+	"						\n"
+	"					}\n"
+	"					\n"
+	"				} else\n"
+	"				{\n"
+	"					bCollide = false;\n"
+	"					break;\n"
+	"				}\n"
+	"			}\n"
+	"		} else\n"
+	"		{\n"
+	"			if ( dist > minDist )\n"
+	"			{\n"
+	"				minDist = dist;\n"
+	"				closestPnt = pntReturn;\n"
+	"				hitNormalWorld.xyz = planeEqn.xyz;\n"
+	"			}\n"
+	"		}\n"
+	"		\n"
+	"	}\n"
+	"	\n"
+	"	if (bCollide && minDist > -10000)\n"
+	"	{\n"
+	"		float4 normalOnSurfaceB1 = qtRotate(quat,-hitNormalWorld);\n"
+	"		float4 pOnB1 = transform(&closestPnt,&pos,&quat);\n"
+	"		\n"
+	"		float actualDepth = minDist-radius;\n"
+	"		if (actualDepth<=0.f)\n"
+	"		{\n"
+	"			\n"
+	"			pOnB1.w = actualDepth;\n"
+	"			int dstIdx;\n"
+	"			AppendInc( nGlobalContactsOut, dstIdx );\n"
+	"		\n"
+	"			\n"
+	"			if (1)//dstIdx < maxContactCapacity)\n"
+	"			{\n"
+	"				__global struct b3Contact4Data* c = &globalContactsOut[dstIdx];\n"
+	"				c->m_worldNormalOnB = -normalOnSurfaceB1;\n"
+	"				c->m_restituitionCoeffCmp = (0.f*0xffff);c->m_frictionCoeffCmp = (0.7f*0xffff);\n"
+	"				c->m_batchIdx = pairIndex;\n"
+	"				c->m_bodyAPtrAndSignBit = rigidBodies[bodyIndexA].m_invMass==0?-bodyIndexA:bodyIndexA;\n"
+	"				c->m_bodyBPtrAndSignBit = rigidBodies[bodyIndexB].m_invMass==0?-bodyIndexB:bodyIndexB;\n"
+	"				c->m_worldPosB[0] = pOnB1;\n"
+	"				c->m_childIndexA = -1;\n"
+	"				c->m_childIndexB = -1;\n"
+	"				GET_NPOINTS(*c) = 1;\n"
+	"			} \n"
+	"		}\n"
+	"	}//if (hasCollision)\n"
+	"}\n"
+	"							\n"
+	"int extractManifoldSequential(const float4* p, int nPoints, float4 nearNormal, int4* contactIdx)\n"
+	"{\n"
+	"	if( nPoints == 0 )\n"
+	"        return 0;\n"
+	"    \n"
+	"    if (nPoints <=4)\n"
+	"        return nPoints;\n"
+	"    \n"
+	"    \n"
+	"    if (nPoints >64)\n"
+	"        nPoints = 64;\n"
+	"    \n"
+	"	float4 center = make_float4(0.f);\n"
+	"	{\n"
+	"		\n"
+	"		for (int i=0;i<nPoints;i++)\n"
+	"			center += p[i];\n"
+	"		center /= (float)nPoints;\n"
+	"	}\n"
+	"    \n"
+	"	\n"
+	"    \n"
+	"	//	sample 4 directions\n"
+	"    \n"
+	"    float4 aVector = p[0] - center;\n"
+	"    float4 u = cross3( nearNormal, aVector );\n"
+	"    float4 v = cross3( nearNormal, u );\n"
+	"    u = normalize3( u );\n"
+	"    v = normalize3( v );\n"
+	"    \n"
+	"    \n"
+	"    //keep point with deepest penetration\n"
+	"    float minW= FLT_MAX;\n"
+	"    \n"
+	"    int minIndex=-1;\n"
+	"    \n"
+	"    float4 maxDots;\n"
+	"    maxDots.x = FLT_MIN;\n"
+	"    maxDots.y = FLT_MIN;\n"
+	"    maxDots.z = FLT_MIN;\n"
+	"    maxDots.w = FLT_MIN;\n"
+	"    \n"
+	"    //	idx, distance\n"
+	"    for(int ie = 0; ie<nPoints; ie++ )\n"
+	"    {\n"
+	"        if (p[ie].w<minW)\n"
+	"        {\n"
+	"            minW = p[ie].w;\n"
+	"            minIndex=ie;\n"
+	"        }\n"
+	"        float f;\n"
+	"        float4 r = p[ie]-center;\n"
+	"        f = dot3F4( u, r );\n"
+	"        if (f<maxDots.x)\n"
+	"        {\n"
+	"            maxDots.x = f;\n"
+	"            contactIdx[0].x = ie;\n"
+	"        }\n"
+	"        \n"
+	"        f = dot3F4( -u, r );\n"
+	"        if (f<maxDots.y)\n"
+	"        {\n"
+	"            maxDots.y = f;\n"
+	"            contactIdx[0].y = ie;\n"
+	"        }\n"
+	"        \n"
+	"        \n"
+	"        f = dot3F4( v, r );\n"
+	"        if (f<maxDots.z)\n"
+	"        {\n"
+	"            maxDots.z = f;\n"
+	"            contactIdx[0].z = ie;\n"
+	"        }\n"
+	"        \n"
+	"        f = dot3F4( -v, r );\n"
+	"        if (f<maxDots.w)\n"
+	"        {\n"
+	"            maxDots.w = f;\n"
+	"            contactIdx[0].w = ie;\n"
+	"        }\n"
+	"        \n"
+	"    }\n"
+	"    \n"
+	"    if (contactIdx[0].x != minIndex && contactIdx[0].y != minIndex && contactIdx[0].z != minIndex && contactIdx[0].w != minIndex)\n"
+	"    {\n"
+	"        //replace the first contact with minimum (todo: replace contact with least penetration)\n"
+	"        contactIdx[0].x = minIndex;\n"
+	"    }\n"
+	"    \n"
+	"    return 4;\n"
+	"    \n"
+	"}\n"
+	"#define MAX_PLANE_CONVEX_POINTS 64\n"
+	"int computeContactPlaneConvex(int pairIndex,\n"
+	"								int bodyIndexA, int bodyIndexB, \n"
+	"								int collidableIndexA, int collidableIndexB, \n"
+	"								__global const BodyData* rigidBodies, \n"
+	"								__global const btCollidableGpu*collidables,\n"
+	"								__global const ConvexPolyhedronCL* convexShapes,\n"
+	"								__global const float4* convexVertices,\n"
+	"								__global const int* convexIndices,\n"
+	"								__global const btGpuFace* faces,\n"
+	"								__global struct b3Contact4Data* restrict globalContactsOut,\n"
+	"								counter32_t nGlobalContactsOut,\n"
+	"								int maxContactCapacity,\n"
+	"								float4 posB,\n"
+	"								Quaternion ornB\n"
+	"								)\n"
+	"{\n"
+	"	int resultIndex=-1;\n"
+	"		int shapeIndex = collidables[collidableIndexB].m_shapeIndex;\n"
+	"	__global const ConvexPolyhedronCL* hullB = &convexShapes[shapeIndex];\n"
+	"	\n"
+	"	float4 posA;\n"
+	"	posA = rigidBodies[bodyIndexA].m_pos;\n"
+	"	Quaternion ornA;\n"
+	"	ornA = rigidBodies[bodyIndexA].m_quat;\n"
+	"	int numContactsOut = 0;\n"
+	"	int numWorldVertsB1= 0;\n"
+	"	float4 planeEq;\n"
+	"	 planeEq = faces[collidables[collidableIndexA].m_shapeIndex].m_plane;\n"
+	"	float4 planeNormal = make_float4(planeEq.x,planeEq.y,planeEq.z,0.f);\n"
+	"	float4 planeNormalWorld;\n"
+	"	planeNormalWorld = qtRotate(ornA,planeNormal);\n"
+	"	float planeConstant = planeEq.w;\n"
+	"	\n"
+	"	float4 invPosA;Quaternion invOrnA;\n"
+	"	float4 convexInPlaneTransPos1; Quaternion convexInPlaneTransOrn1;\n"
+	"	{\n"
+	"		\n"
+	"		trInverse(posA,ornA,&invPosA,&invOrnA);\n"
+	"		trMul(invPosA,invOrnA,posB,ornB,&convexInPlaneTransPos1,&convexInPlaneTransOrn1);\n"
+	"	}\n"
+	"	float4 invPosB;Quaternion invOrnB;\n"
+	"	float4 planeInConvexPos1;	Quaternion planeInConvexOrn1;\n"
+	"	{\n"
+	"		\n"
+	"		trInverse(posB,ornB,&invPosB,&invOrnB);\n"
+	"		trMul(invPosB,invOrnB,posA,ornA,&planeInConvexPos1,&planeInConvexOrn1);	\n"
+	"	}\n"
+	"	\n"
+	"	float4 planeNormalInConvex = qtRotate(planeInConvexOrn1,-planeNormal);\n"
+	"	float maxDot = -1e30;\n"
+	"	int hitVertex=-1;\n"
+	"	float4 hitVtx;\n"
+	"	float4 contactPoints[MAX_PLANE_CONVEX_POINTS];\n"
+	"	int numPoints = 0;\n"
+	"	int4 contactIdx;\n"
+	"	contactIdx=make_int4(0,1,2,3);\n"
+	"    \n"
+	"	\n"
+	"	for (int i=0;i<hullB->m_numVertices;i++)\n"
+	"	{\n"
+	"		float4 vtx = convexVertices[hullB->m_vertexOffset+i];\n"
+	"		float curDot = dot(vtx,planeNormalInConvex);\n"
+	"		if (curDot>maxDot)\n"
+	"		{\n"
+	"			hitVertex=i;\n"
+	"			maxDot=curDot;\n"
+	"			hitVtx = vtx;\n"
+	"			//make sure the deepest points is always included\n"
+	"			if (numPoints==MAX_PLANE_CONVEX_POINTS)\n"
+	"				numPoints--;\n"
+	"		}\n"
+	"		if (numPoints<MAX_PLANE_CONVEX_POINTS)\n"
+	"		{\n"
+	"			float4 vtxWorld = transform(&vtx, &posB, &ornB);\n"
+	"			float4 vtxInPlane = transform(&vtxWorld, &invPosA, &invOrnA);//oplaneTransform.inverse()*vtxWorld;\n"
+	"			float dist = dot(planeNormal,vtxInPlane)-planeConstant;\n"
+	"			if (dist<0.f)\n"
+	"			{\n"
+	"				vtxWorld.w = dist;\n"
+	"				contactPoints[numPoints] = vtxWorld;\n"
+	"				numPoints++;\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"	int numReducedPoints  = numPoints;\n"
+	"	if (numPoints>4)\n"
+	"	{\n"
+	"		numReducedPoints = extractManifoldSequential( contactPoints, numPoints, planeNormalInConvex, &contactIdx);\n"
+	"	}\n"
+	"	if (numReducedPoints>0)\n"
+	"	{\n"
+	"		int dstIdx;\n"
+	"	    AppendInc( nGlobalContactsOut, dstIdx );\n"
+	"		if (dstIdx < maxContactCapacity)\n"
+	"		{\n"
+	"			resultIndex = dstIdx;\n"
+	"			__global struct b3Contact4Data* c = &globalContactsOut[dstIdx];\n"
+	"			c->m_worldNormalOnB = -planeNormalWorld;\n"
+	"			//c->setFrictionCoeff(0.7);\n"
+	"			//c->setRestituitionCoeff(0.f);\n"
+	"			c->m_restituitionCoeffCmp = (0.f*0xffff);c->m_frictionCoeffCmp = (0.7f*0xffff);\n"
+	"			c->m_batchIdx = pairIndex;\n"
+	"			c->m_bodyAPtrAndSignBit = rigidBodies[bodyIndexA].m_invMass==0?-bodyIndexA:bodyIndexA;\n"
+	"			c->m_bodyBPtrAndSignBit = rigidBodies[bodyIndexB].m_invMass==0?-bodyIndexB:bodyIndexB;\n"
+	"			c->m_childIndexA = -1;\n"
+	"			c->m_childIndexB = -1;\n"
+	"			switch (numReducedPoints)\n"
+	"            {\n"
+	"                case 4:\n"
+	"                    c->m_worldPosB[3] = contactPoints[contactIdx.w];\n"
+	"                case 3:\n"
+	"                    c->m_worldPosB[2] = contactPoints[contactIdx.z];\n"
+	"                case 2:\n"
+	"                    c->m_worldPosB[1] = contactPoints[contactIdx.y];\n"
+	"                case 1:\n"
+	"                    c->m_worldPosB[0] = contactPoints[contactIdx.x];\n"
+	"                default:\n"
+	"                {\n"
+	"                }\n"
+	"            };\n"
+	"			\n"
+	"			GET_NPOINTS(*c) = numReducedPoints;\n"
+	"		}//if (dstIdx < numPairs)\n"
+	"	}	\n"
+	"	return resultIndex;\n"
+	"}\n"
+	"void	computeContactPlaneSphere(int pairIndex,\n"
+	"																int bodyIndexA, int bodyIndexB, \n"
+	"																int collidableIndexA, int collidableIndexB, \n"
+	"																__global const BodyData* rigidBodies, \n"
+	"																__global const btCollidableGpu* collidables,\n"
+	"																__global const btGpuFace* faces,\n"
+	"																__global struct b3Contact4Data* restrict globalContactsOut,\n"
+	"																counter32_t nGlobalContactsOut,\n"
+	"																int maxContactCapacity)\n"
+	"{\n"
+	"	float4 planeEq = faces[collidables[collidableIndexA].m_shapeIndex].m_plane;\n"
+	"	float radius = collidables[collidableIndexB].m_radius;\n"
+	"	float4 posA1 = rigidBodies[bodyIndexA].m_pos;\n"
+	"	float4 ornA1 = rigidBodies[bodyIndexA].m_quat;\n"
+	"	float4 posB1 = rigidBodies[bodyIndexB].m_pos;\n"
+	"	float4 ornB1 = rigidBodies[bodyIndexB].m_quat;\n"
+	"	\n"
+	"	bool hasCollision = false;\n"
+	"	float4 planeNormal1 = make_float4(planeEq.x,planeEq.y,planeEq.z,0.f);\n"
+	"	float planeConstant = planeEq.w;\n"
+	"	float4 convexInPlaneTransPos1; Quaternion convexInPlaneTransOrn1;\n"
+	"	{\n"
+	"		float4 invPosA;Quaternion invOrnA;\n"
+	"		trInverse(posA1,ornA1,&invPosA,&invOrnA);\n"
+	"		trMul(invPosA,invOrnA,posB1,ornB1,&convexInPlaneTransPos1,&convexInPlaneTransOrn1);\n"
+	"	}\n"
+	"	float4 planeInConvexPos1;	Quaternion planeInConvexOrn1;\n"
+	"	{\n"
+	"		float4 invPosB;Quaternion invOrnB;\n"
+	"		trInverse(posB1,ornB1,&invPosB,&invOrnB);\n"
+	"		trMul(invPosB,invOrnB,posA1,ornA1,&planeInConvexPos1,&planeInConvexOrn1);	\n"
+	"	}\n"
+	"	float4 vtx1 = qtRotate(planeInConvexOrn1,-planeNormal1)*radius;\n"
+	"	float4 vtxInPlane1 = transform(&vtx1,&convexInPlaneTransPos1,&convexInPlaneTransOrn1);\n"
+	"	float distance = dot3F4(planeNormal1,vtxInPlane1) - planeConstant;\n"
+	"	hasCollision = distance < 0.f;//m_manifoldPtr->getContactBreakingThreshold();\n"
+	"	if (hasCollision)\n"
+	"	{\n"
+	"		float4 vtxInPlaneProjected1 = vtxInPlane1 -   distance*planeNormal1;\n"
+	"		float4 vtxInPlaneWorld1 = transform(&vtxInPlaneProjected1,&posA1,&ornA1);\n"
+	"		float4 normalOnSurfaceB1 = qtRotate(ornA1,planeNormal1);\n"
+	"		float4 pOnB1 = vtxInPlaneWorld1+normalOnSurfaceB1*distance;\n"
+	"		pOnB1.w = distance;\n"
+	"		int dstIdx;\n"
+	"    AppendInc( nGlobalContactsOut, dstIdx );\n"
+	"		\n"
+	"		if (dstIdx < maxContactCapacity)\n"
+	"		{\n"
+	"			__global struct b3Contact4Data* c = &globalContactsOut[dstIdx];\n"
+	"			c->m_worldNormalOnB = -normalOnSurfaceB1;\n"
+	"			c->m_restituitionCoeffCmp = (0.f*0xffff);c->m_frictionCoeffCmp = (0.7f*0xffff);\n"
+	"			c->m_batchIdx = pairIndex;\n"
+	"			c->m_bodyAPtrAndSignBit = rigidBodies[bodyIndexA].m_invMass==0?-bodyIndexA:bodyIndexA;\n"
+	"			c->m_bodyBPtrAndSignBit = rigidBodies[bodyIndexB].m_invMass==0?-bodyIndexB:bodyIndexB;\n"
+	"			c->m_worldPosB[0] = pOnB1;\n"
+	"			c->m_childIndexA = -1;\n"
+	"			c->m_childIndexB = -1;\n"
+	"			GET_NPOINTS(*c) = 1;\n"
+	"		}//if (dstIdx < numPairs)\n"
+	"	}//if (hasCollision)\n"
+	"}\n"
+	"__kernel void   primitiveContactsKernel( __global int4* pairs, \n"
+	"																					__global const BodyData* rigidBodies, \n"
+	"																					__global const btCollidableGpu* collidables,\n"
+	"																					__global const ConvexPolyhedronCL* convexShapes, \n"
+	"																					__global const float4* vertices,\n"
+	"																					__global const float4* uniqueEdges,\n"
+	"																					__global const btGpuFace* faces,\n"
+	"																					__global const int* indices,\n"
+	"																					__global struct b3Contact4Data* restrict globalContactsOut,\n"
+	"																					counter32_t nGlobalContactsOut,\n"
+	"																					int numPairs, int maxContactCapacity)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	int pairIndex = i;\n"
+	"	\n"
+	"	float4 worldVertsB1[64];\n"
+	"	float4 worldVertsB2[64];\n"
+	"	int capacityWorldVerts = 64;	\n"
+	"	float4 localContactsOut[64];\n"
+	"	int localContactCapacity=64;\n"
+	"	\n"
+	"	float minDist = -1e30f;\n"
+	"	float maxDist = 0.02f;\n"
+	"	if (i<numPairs)\n"
+	"	{\n"
+	"		int bodyIndexA = pairs[i].x;\n"
+	"		int bodyIndexB = pairs[i].y;\n"
+	"			\n"
+	"		int collidableIndexA = rigidBodies[bodyIndexA].m_collidableIdx;\n"
+	"		int collidableIndexB = rigidBodies[bodyIndexB].m_collidableIdx;\n"
+	"	\n"
+	"		if (collidables[collidableIndexA].m_shapeType == SHAPE_PLANE &&\n"
+	"			collidables[collidableIndexB].m_shapeType == SHAPE_CONVEX_HULL)\n"
+	"		{\n"
+	"			float4 posB;\n"
+	"			posB = rigidBodies[bodyIndexB].m_pos;\n"
+	"			Quaternion ornB;\n"
+	"			ornB = rigidBodies[bodyIndexB].m_quat;\n"
+	"			int contactIndex = computeContactPlaneConvex(pairIndex, bodyIndexA, bodyIndexB, collidableIndexA, collidableIndexB, \n"
+	"																rigidBodies,collidables,convexShapes,vertices,indices,\n"
+	"																faces,	globalContactsOut, nGlobalContactsOut,maxContactCapacity, posB,ornB);\n"
+	"			if (contactIndex>=0)\n"
+	"				pairs[pairIndex].z = contactIndex;\n"
+	"			return;\n"
+	"		}\n"
+	"		if (collidables[collidableIndexA].m_shapeType == SHAPE_CONVEX_HULL &&\n"
+	"			collidables[collidableIndexB].m_shapeType == SHAPE_PLANE)\n"
+	"		{\n"
+	"			float4 posA;\n"
+	"			posA = rigidBodies[bodyIndexA].m_pos;\n"
+	"			Quaternion ornA;\n"
+	"			ornA = rigidBodies[bodyIndexA].m_quat;\n"
+	"			int contactIndex = computeContactPlaneConvex( pairIndex, bodyIndexB,bodyIndexA,  collidableIndexB,collidableIndexA, \n"
+	"																rigidBodies,collidables,convexShapes,vertices,indices,\n"
+	"																faces,	globalContactsOut, nGlobalContactsOut,maxContactCapacity,posA,ornA);\n"
+	"			if (contactIndex>=0)\n"
+	"				pairs[pairIndex].z = contactIndex;\n"
+	"			return;\n"
+	"		}\n"
+	"		if (collidables[collidableIndexA].m_shapeType == SHAPE_PLANE &&\n"
+	"			collidables[collidableIndexB].m_shapeType == SHAPE_SPHERE)\n"
+	"		{\n"
+	"			computeContactPlaneSphere(pairIndex, bodyIndexA, bodyIndexB, collidableIndexA, collidableIndexB, \n"
+	"																rigidBodies,collidables,faces,	globalContactsOut, nGlobalContactsOut,maxContactCapacity);\n"
+	"			return;\n"
+	"		}\n"
+	"		if (collidables[collidableIndexA].m_shapeType == SHAPE_SPHERE &&\n"
+	"			collidables[collidableIndexB].m_shapeType == SHAPE_PLANE)\n"
+	"		{\n"
+	"			computeContactPlaneSphere( pairIndex, bodyIndexB,bodyIndexA,  collidableIndexB,collidableIndexA, \n"
+	"																rigidBodies,collidables,\n"
+	"																faces,	globalContactsOut, nGlobalContactsOut,maxContactCapacity);\n"
+	"			return;\n"
+	"		}\n"
+	"		\n"
+	"	\n"
+	"		if (collidables[collidableIndexA].m_shapeType == SHAPE_SPHERE &&\n"
+	"			collidables[collidableIndexB].m_shapeType == SHAPE_CONVEX_HULL)\n"
+	"		{\n"
+	"		\n"
+	"			float4 spherePos = rigidBodies[bodyIndexA].m_pos;\n"
+	"			float sphereRadius = collidables[collidableIndexA].m_radius;\n"
+	"			float4 convexPos = rigidBodies[bodyIndexB].m_pos;\n"
+	"			float4 convexOrn = rigidBodies[bodyIndexB].m_quat;\n"
+	"			computeContactSphereConvex(pairIndex, bodyIndexA, bodyIndexB, collidableIndexA, collidableIndexB, \n"
+	"																rigidBodies,collidables,convexShapes,vertices,indices,faces, globalContactsOut, nGlobalContactsOut,maxContactCapacity,\n"
+	"																spherePos,sphereRadius,convexPos,convexOrn);\n"
+	"			return;\n"
+	"		}\n"
+	"		if (collidables[collidableIndexA].m_shapeType == SHAPE_CONVEX_HULL &&\n"
+	"			collidables[collidableIndexB].m_shapeType == SHAPE_SPHERE)\n"
+	"		{\n"
+	"		\n"
+	"			float4 spherePos = rigidBodies[bodyIndexB].m_pos;\n"
+	"			float sphereRadius = collidables[collidableIndexB].m_radius;\n"
+	"			float4 convexPos = rigidBodies[bodyIndexA].m_pos;\n"
+	"			float4 convexOrn = rigidBodies[bodyIndexA].m_quat;\n"
+	"			computeContactSphereConvex(pairIndex, bodyIndexB, bodyIndexA, collidableIndexB, collidableIndexA, \n"
+	"																rigidBodies,collidables,convexShapes,vertices,indices,faces, globalContactsOut, nGlobalContactsOut,maxContactCapacity,\n"
+	"																spherePos,sphereRadius,convexPos,convexOrn);\n"
+	"			return;\n"
+	"		}\n"
+	"	\n"
+	"	\n"
+	"	\n"
+	"		\n"
+	"	\n"
+	"	\n"
+	"		if (collidables[collidableIndexA].m_shapeType == SHAPE_SPHERE &&\n"
+	"			collidables[collidableIndexB].m_shapeType == SHAPE_SPHERE)\n"
+	"		{\n"
+	"			//sphere-sphere\n"
+	"			float radiusA = collidables[collidableIndexA].m_radius;\n"
+	"			float radiusB = collidables[collidableIndexB].m_radius;\n"
+	"			float4 posA = rigidBodies[bodyIndexA].m_pos;\n"
+	"			float4 posB = rigidBodies[bodyIndexB].m_pos;\n"
+	"			float4 diff = posA-posB;\n"
+	"			float len = length(diff);\n"
+	"			\n"
+	"			///iff distance positive, don't generate a new contact\n"
+	"			if ( len <= (radiusA+radiusB))\n"
+	"			{\n"
+	"				///distance (negative means penetration)\n"
+	"				float dist = len - (radiusA+radiusB);\n"
+	"				float4 normalOnSurfaceB = make_float4(1.f,0.f,0.f,0.f);\n"
+	"				if (len > 0.00001)\n"
+	"				{\n"
+	"					normalOnSurfaceB = diff / len;\n"
+	"				}\n"
+	"				float4 contactPosB = posB + normalOnSurfaceB*radiusB;\n"
+	"				contactPosB.w = dist;\n"
+	"								\n"
+	"				int dstIdx;\n"
+	"				 AppendInc( nGlobalContactsOut, dstIdx );\n"
+	"				\n"
+	"				if (dstIdx < maxContactCapacity)\n"
+	"				{\n"
+	"					__global struct b3Contact4Data* c = &globalContactsOut[dstIdx];\n"
+	"					c->m_worldNormalOnB = normalOnSurfaceB;\n"
+	"					c->m_restituitionCoeffCmp = (0.f*0xffff);c->m_frictionCoeffCmp = (0.7f*0xffff);\n"
+	"					c->m_batchIdx = pairIndex;\n"
+	"					int bodyA = pairs[pairIndex].x;\n"
+	"					int bodyB = pairs[pairIndex].y;\n"
+	"					c->m_bodyAPtrAndSignBit = rigidBodies[bodyA].m_invMass==0?-bodyA:bodyA;\n"
+	"					c->m_bodyBPtrAndSignBit = rigidBodies[bodyB].m_invMass==0?-bodyB:bodyB;\n"
+	"					c->m_worldPosB[0] = contactPosB;\n"
+	"					c->m_childIndexA = -1;\n"
+	"					c->m_childIndexB = -1;\n"
+	"					GET_NPOINTS(*c) = 1;\n"
+	"				}//if (dstIdx < numPairs)\n"
+	"			}//if ( len <= (radiusA+radiusB))\n"
+	"			return;\n"
+	"		}//SHAPE_SPHERE SHAPE_SPHERE\n"
+	"	}//	if (i<numPairs)\n"
+	"}\n"
+	"// work-in-progress\n"
+	"__kernel void   processCompoundPairsPrimitivesKernel( __global const int4* gpuCompoundPairs,\n"
+	"													__global const BodyData* rigidBodies, \n"
+	"													__global const btCollidableGpu* collidables,\n"
+	"													__global const ConvexPolyhedronCL* convexShapes, \n"
+	"													__global const float4* vertices,\n"
+	"													__global const float4* uniqueEdges,\n"
+	"													__global const btGpuFace* faces,\n"
+	"													__global const int* indices,\n"
+	"													__global btAabbCL* aabbs,\n"
+	"													__global const btGpuChildShape* gpuChildShapes,\n"
+	"													__global struct b3Contact4Data* restrict globalContactsOut,\n"
+	"													counter32_t nGlobalContactsOut,\n"
+	"													int numCompoundPairs, int maxContactCapacity\n"
+	"													)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	if (i<numCompoundPairs)\n"
+	"	{\n"
+	"		int bodyIndexA = gpuCompoundPairs[i].x;\n"
+	"		int bodyIndexB = gpuCompoundPairs[i].y;\n"
+	"		int childShapeIndexA = gpuCompoundPairs[i].z;\n"
+	"		int childShapeIndexB = gpuCompoundPairs[i].w;\n"
+	"		\n"
+	"		int collidableIndexA = -1;\n"
+	"		int collidableIndexB = -1;\n"
+	"		\n"
+	"		float4 ornA = rigidBodies[bodyIndexA].m_quat;\n"
+	"		float4 posA = rigidBodies[bodyIndexA].m_pos;\n"
+	"		\n"
+	"		float4 ornB = rigidBodies[bodyIndexB].m_quat;\n"
+	"		float4 posB = rigidBodies[bodyIndexB].m_pos;\n"
+	"							\n"
+	"		if (childShapeIndexA >= 0)\n"
+	"		{\n"
+	"			collidableIndexA = gpuChildShapes[childShapeIndexA].m_shapeIndex;\n"
+	"			float4 childPosA = gpuChildShapes[childShapeIndexA].m_childPosition;\n"
+	"			float4 childOrnA = gpuChildShapes[childShapeIndexA].m_childOrientation;\n"
+	"			float4 newPosA = qtRotate(ornA,childPosA)+posA;\n"
+	"			float4 newOrnA = qtMul(ornA,childOrnA);\n"
+	"			posA = newPosA;\n"
+	"			ornA = newOrnA;\n"
+	"		} else\n"
+	"		{\n"
+	"			collidableIndexA = rigidBodies[bodyIndexA].m_collidableIdx;\n"
+	"		}\n"
+	"		\n"
+	"		if (childShapeIndexB>=0)\n"
+	"		{\n"
+	"			collidableIndexB = gpuChildShapes[childShapeIndexB].m_shapeIndex;\n"
+	"			float4 childPosB = gpuChildShapes[childShapeIndexB].m_childPosition;\n"
+	"			float4 childOrnB = gpuChildShapes[childShapeIndexB].m_childOrientation;\n"
+	"			float4 newPosB = transform(&childPosB,&posB,&ornB);\n"
+	"			float4 newOrnB = qtMul(ornB,childOrnB);\n"
+	"			posB = newPosB;\n"
+	"			ornB = newOrnB;\n"
+	"		} else\n"
+	"		{\n"
+	"			collidableIndexB = rigidBodies[bodyIndexB].m_collidableIdx;	\n"
+	"		}\n"
+	"	\n"
+	"		int shapeIndexA = collidables[collidableIndexA].m_shapeIndex;\n"
+	"		int shapeIndexB = collidables[collidableIndexB].m_shapeIndex;\n"
+	"	\n"
+	"		int shapeTypeA = collidables[collidableIndexA].m_shapeType;\n"
+	"		int shapeTypeB = collidables[collidableIndexB].m_shapeType;\n"
+	"		int pairIndex = i;\n"
+	"		if ((shapeTypeA == SHAPE_PLANE) && (shapeTypeB==SHAPE_CONVEX_HULL))\n"
+	"		{\n"
+	"			computeContactPlaneConvex( pairIndex, bodyIndexA,bodyIndexB,  collidableIndexA,collidableIndexB, \n"
+	"																rigidBodies,collidables,convexShapes,vertices,indices,\n"
+	"																faces,	globalContactsOut, nGlobalContactsOut,maxContactCapacity,posB,ornB);\n"
+	"			return;\n"
+	"		}\n"
+	"		if ((shapeTypeA == SHAPE_CONVEX_HULL) && (shapeTypeB==SHAPE_PLANE))\n"
+	"		{\n"
+	"			computeContactPlaneConvex( pairIndex, bodyIndexB,bodyIndexA,  collidableIndexB,collidableIndexA, \n"
+	"																rigidBodies,collidables,convexShapes,vertices,indices,\n"
+	"																faces,	globalContactsOut, nGlobalContactsOut,maxContactCapacity,posA,ornA);\n"
+	"			return;\n"
+	"		}\n"
+	"		if ((shapeTypeA == SHAPE_CONVEX_HULL) && (shapeTypeB == SHAPE_SPHERE))\n"
+	"		{\n"
+	"			float4 spherePos = rigidBodies[bodyIndexB].m_pos;\n"
+	"			float sphereRadius = collidables[collidableIndexB].m_radius;\n"
+	"			float4 convexPos = posA;\n"
+	"			float4 convexOrn = ornA;\n"
+	"			\n"
+	"			computeContactSphereConvex(pairIndex, bodyIndexB, bodyIndexA , collidableIndexB,collidableIndexA, \n"
+	"										rigidBodies,collidables,convexShapes,vertices,indices,faces, globalContactsOut, nGlobalContactsOut,maxContactCapacity,\n"
+	"										spherePos,sphereRadius,convexPos,convexOrn);\n"
+	"	\n"
+	"			return;\n"
+	"		}\n"
+	"		if ((shapeTypeA == SHAPE_SPHERE) && (shapeTypeB == SHAPE_CONVEX_HULL))\n"
+	"		{\n"
+	"			float4 spherePos = rigidBodies[bodyIndexA].m_pos;\n"
+	"			float sphereRadius = collidables[collidableIndexA].m_radius;\n"
+	"			float4 convexPos = posB;\n"
+	"			float4 convexOrn = ornB;\n"
+	"			\n"
+	"			computeContactSphereConvex(pairIndex, bodyIndexA, bodyIndexB, collidableIndexA, collidableIndexB, \n"
+	"										rigidBodies,collidables,convexShapes,vertices,indices,faces, globalContactsOut, nGlobalContactsOut,maxContactCapacity,\n"
+	"										spherePos,sphereRadius,convexPos,convexOrn);\n"
+	"	\n"
+	"			return;\n"
+	"		}\n"
+	"	}//	if (i<numCompoundPairs)\n"
+	"}\n"
+	"bool pointInTriangle(const float4* vertices, const float4* normal, float4 *p )\n"
+	"{\n"
+	"	const float4* p1 = &vertices[0];\n"
+	"	const float4* p2 = &vertices[1];\n"
+	"	const float4* p3 = &vertices[2];\n"
+	"	float4 edge1;	edge1 = (*p2 - *p1);\n"
+	"	float4 edge2;	edge2 = ( *p3 - *p2 );\n"
+	"	float4 edge3;	edge3 = ( *p1 - *p3 );\n"
+	"	\n"
+	"	float4 p1_to_p; p1_to_p = ( *p - *p1 );\n"
+	"	float4 p2_to_p; p2_to_p = ( *p - *p2 );\n"
+	"	float4 p3_to_p; p3_to_p = ( *p - *p3 );\n"
+	"	float4 edge1_normal; edge1_normal = ( cross(edge1,*normal));\n"
+	"	float4 edge2_normal; edge2_normal = ( cross(edge2,*normal));\n"
+	"	float4 edge3_normal; edge3_normal = ( cross(edge3,*normal));\n"
+	"	\n"
+	"	\n"
+	"	float r1, r2, r3;\n"
+	"	r1 = dot(edge1_normal,p1_to_p );\n"
+	"	r2 = dot(edge2_normal,p2_to_p );\n"
+	"	r3 = dot(edge3_normal,p3_to_p );\n"
+	"	\n"
+	"	if ( r1 > 0 && r2 > 0 && r3 > 0 )\n"
+	"		return true;\n"
+	"    if ( r1 <= 0 && r2 <= 0 && r3 <= 0 ) \n"
+	"		return true;\n"
+	"	return false;\n"
+	"}\n"
+	"float segmentSqrDistance(float4 from, float4 to,float4 p, float4* nearest) \n"
+	"{\n"
+	"	float4 diff = p - from;\n"
+	"	float4 v = to - from;\n"
+	"	float t = dot(v,diff);\n"
+	"	\n"
+	"	if (t > 0) \n"
+	"	{\n"
+	"		float dotVV = dot(v,v);\n"
+	"		if (t < dotVV) \n"
+	"		{\n"
+	"			t /= dotVV;\n"
+	"			diff -= t*v;\n"
+	"		} else \n"
+	"		{\n"
+	"			t = 1;\n"
+	"			diff -= v;\n"
+	"		}\n"
+	"	} else\n"
+	"	{\n"
+	"		t = 0;\n"
+	"	}\n"
+	"	*nearest = from + t*v;\n"
+	"	return dot(diff,diff);	\n"
+	"}\n"
+	"void	computeContactSphereTriangle(int pairIndex,\n"
+	"									int bodyIndexA, int bodyIndexB,\n"
+	"									int collidableIndexA, int collidableIndexB, \n"
+	"									__global const BodyData* rigidBodies, \n"
+	"									__global const btCollidableGpu* collidables,\n"
+	"									const float4* triangleVertices,\n"
+	"									__global struct b3Contact4Data* restrict globalContactsOut,\n"
+	"									counter32_t nGlobalContactsOut,\n"
+	"									int maxContactCapacity,\n"
+	"									float4 spherePos2,\n"
+	"									float radius,\n"
+	"									float4 pos,\n"
+	"									float4 quat,\n"
+	"									int faceIndex\n"
+	"									)\n"
+	"{\n"
+	"	float4 invPos;\n"
+	"	float4 invOrn;\n"
+	"	trInverse(pos,quat, &invPos,&invOrn);\n"
+	"	float4 spherePos = transform(&spherePos2,&invPos,&invOrn);\n"
+	"	int numFaces = 3;\n"
+	"	float4 closestPnt = (float4)(0, 0, 0, 0);\n"
+	"	float4 hitNormalWorld = (float4)(0, 0, 0, 0);\n"
+	"	float minDist = -1000000.f;\n"
+	"	bool bCollide = false;\n"
+	"	\n"
+	"	//////////////////////////////////////\n"
+	"	float4 sphereCenter;\n"
+	"	sphereCenter = spherePos;\n"
+	"	const float4* vertices = triangleVertices;\n"
+	"	float contactBreakingThreshold = 0.f;//todo?\n"
+	"	float radiusWithThreshold = radius + contactBreakingThreshold;\n"
+	"	float4 edge10;\n"
+	"	edge10 = vertices[1]-vertices[0];\n"
+	"	edge10.w = 0.f;//is this needed?\n"
+	"	float4 edge20;\n"
+	"	edge20 = vertices[2]-vertices[0];\n"
+	"	edge20.w = 0.f;//is this needed?\n"
+	"	float4 normal = cross3(edge10,edge20);\n"
+	"	normal = normalize(normal);\n"
+	"	float4 p1ToCenter;\n"
+	"	p1ToCenter = sphereCenter - vertices[0];\n"
+	"	\n"
+	"	float distanceFromPlane = dot(p1ToCenter,normal);\n"
+	"	if (distanceFromPlane < 0.f)\n"
+	"	{\n"
+	"		//triangle facing the other way\n"
+	"		distanceFromPlane *= -1.f;\n"
+	"		normal *= -1.f;\n"
+	"	}\n"
+	"	hitNormalWorld = normal;\n"
+	"	bool isInsideContactPlane = distanceFromPlane < radiusWithThreshold;\n"
+	"	\n"
+	"	// Check for contact / intersection\n"
+	"	bool hasContact = false;\n"
+	"	float4 contactPoint;\n"
+	"	if (isInsideContactPlane) \n"
+	"	{\n"
+	"	\n"
+	"		if (pointInTriangle(vertices,&normal, &sphereCenter)) \n"
+	"		{\n"
+	"			// Inside the contact wedge - touches a point on the shell plane\n"
+	"			hasContact = true;\n"
+	"			contactPoint = sphereCenter - normal*distanceFromPlane;\n"
+	"			\n"
+	"		} else {\n"
+	"			// Could be inside one of the contact capsules\n"
+	"			float contactCapsuleRadiusSqr = radiusWithThreshold*radiusWithThreshold;\n"
+	"			float4 nearestOnEdge;\n"
+	"			int numEdges = 3;\n"
+	"			for (int i = 0; i < numEdges; i++) \n"
+	"			{\n"
+	"				float4 pa =vertices[i];\n"
+	"				float4 pb = vertices[(i+1)%3];\n"
+	"				float distanceSqr = segmentSqrDistance(pa,pb,sphereCenter, &nearestOnEdge);\n"
+	"				if (distanceSqr < contactCapsuleRadiusSqr) \n"
+	"				{\n"
+	"					// Yep, we're inside a capsule\n"
+	"					hasContact = true;\n"
+	"					contactPoint = nearestOnEdge;\n"
+	"					\n"
+	"				}\n"
+	"				\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"	if (hasContact) \n"
+	"	{\n"
+	"		closestPnt = contactPoint;\n"
+	"		float4 contactToCenter = sphereCenter - contactPoint;\n"
+	"		minDist = length(contactToCenter);\n"
+	"		if (minDist>FLT_EPSILON)\n"
+	"		{\n"
+	"			hitNormalWorld = normalize(contactToCenter);//*(1./minDist);\n"
+	"			bCollide  = true;\n"
+	"		}\n"
+	"		\n"
+	"	}\n"
+	"	/////////////////////////////////////\n"
+	"	if (bCollide && minDist > -10000)\n"
+	"	{\n"
+	"		\n"
+	"		float4 normalOnSurfaceB1 = qtRotate(quat,-hitNormalWorld);\n"
+	"		float4 pOnB1 = transform(&closestPnt,&pos,&quat);\n"
+	"		float actualDepth = minDist-radius;\n"
+	"		\n"
+	"		if (actualDepth<=0.f)\n"
+	"		{\n"
+	"			pOnB1.w = actualDepth;\n"
+	"			int dstIdx;\n"
+	"			\n"
+	"			float lenSqr = dot3F4(normalOnSurfaceB1,normalOnSurfaceB1);\n"
+	"			if (lenSqr>FLT_EPSILON)\n"
+	"			{\n"
+	"				AppendInc( nGlobalContactsOut, dstIdx );\n"
+	"			\n"
+	"				if (dstIdx < maxContactCapacity)\n"
+	"				{\n"
+	"					__global struct b3Contact4Data* c = &globalContactsOut[dstIdx];\n"
+	"					c->m_worldNormalOnB = -normalOnSurfaceB1;\n"
+	"					c->m_restituitionCoeffCmp = (0.f*0xffff);c->m_frictionCoeffCmp = (0.7f*0xffff);\n"
+	"					c->m_batchIdx = pairIndex;\n"
+	"					c->m_bodyAPtrAndSignBit = rigidBodies[bodyIndexA].m_invMass==0?-bodyIndexA:bodyIndexA;\n"
+	"					c->m_bodyBPtrAndSignBit = rigidBodies[bodyIndexB].m_invMass==0?-bodyIndexB:bodyIndexB;\n"
+	"					c->m_worldPosB[0] = pOnB1;\n"
+	"					c->m_childIndexA = -1;\n"
+	"					c->m_childIndexB = faceIndex;\n"
+	"					GET_NPOINTS(*c) = 1;\n"
+	"				} \n"
+	"			}\n"
+	"		}\n"
+	"	}//if (hasCollision)\n"
+	"}\n"
+	"// work-in-progress\n"
+	"__kernel void   findConcaveSphereContactsKernel( __global int4* concavePairs,\n"
+	"												__global const BodyData* rigidBodies,\n"
+	"												__global const btCollidableGpu* collidables,\n"
+	"												__global const ConvexPolyhedronCL* convexShapes, \n"
+	"												__global const float4* vertices,\n"
+	"												__global const float4* uniqueEdges,\n"
+	"												__global const btGpuFace* faces,\n"
+	"												__global const int* indices,\n"
+	"												__global btAabbCL* aabbs,\n"
+	"												__global struct b3Contact4Data* restrict globalContactsOut,\n"
+	"												counter32_t nGlobalContactsOut,\n"
+	"													int numConcavePairs, int maxContactCapacity\n"
+	"												)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	if (i>=numConcavePairs)\n"
+	"		return;\n"
+	"	int pairIdx = i;\n"
+	"	int bodyIndexA = concavePairs[i].x;\n"
+	"	int bodyIndexB = concavePairs[i].y;\n"
+	"	int collidableIndexA = rigidBodies[bodyIndexA].m_collidableIdx;\n"
+	"	int collidableIndexB = rigidBodies[bodyIndexB].m_collidableIdx;\n"
+	"	int shapeIndexA = collidables[collidableIndexA].m_shapeIndex;\n"
+	"	int shapeIndexB = collidables[collidableIndexB].m_shapeIndex;\n"
+	"	if (collidables[collidableIndexB].m_shapeType==SHAPE_SPHERE)\n"
+	"	{\n"
+	"		int f = concavePairs[i].z;\n"
+	"		btGpuFace face = faces[convexShapes[shapeIndexA].m_faceOffset+f];\n"
+	"		\n"
+	"		float4 verticesA[3];\n"
+	"		for (int i=0;i<3;i++)\n"
+	"		{\n"
+	"			int index = indices[face.m_indexOffset+i];\n"
+	"			float4 vert = vertices[convexShapes[shapeIndexA].m_vertexOffset+index];\n"
+	"			verticesA[i] = vert;\n"
+	"		}\n"
+	"		float4 spherePos = rigidBodies[bodyIndexB].m_pos;\n"
+	"		float sphereRadius = collidables[collidableIndexB].m_radius;\n"
+	"		float4 convexPos = rigidBodies[bodyIndexA].m_pos;\n"
+	"		float4 convexOrn = rigidBodies[bodyIndexA].m_quat;\n"
+	"		computeContactSphereTriangle(i, bodyIndexB, bodyIndexA, collidableIndexB, collidableIndexA, \n"
+	"																rigidBodies,collidables,\n"
+	"																verticesA,\n"
+	"																globalContactsOut, nGlobalContactsOut,maxContactCapacity,\n"
+	"																spherePos,sphereRadius,convexPos,convexOrn, f);\n"
+	"		return;\n"
+	"	}\n"
+	"}\n";
diff --git a/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/kernels/satClipHullContacts.h b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/kernels/satClipHullContacts.h
new file mode 100644
index 00000000..907809d8
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/kernels/satClipHullContacts.h
@@ -0,0 +1,2098 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* satClipKernelsCL =
+	"#define TRIANGLE_NUM_CONVEX_FACES 5\n"
+	"#pragma OPENCL EXTENSION cl_amd_printf : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_local_int32_base_atomics : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_global_int32_base_atomics : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_local_int32_extended_atomics : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_global_int32_extended_atomics : enable\n"
+	"#ifdef cl_ext_atomic_counters_32\n"
+	"#pragma OPENCL EXTENSION cl_ext_atomic_counters_32 : enable\n"
+	"#else\n"
+	"#define counter32_t volatile __global int*\n"
+	"#endif\n"
+	"#define GET_GROUP_IDX get_group_id(0)\n"
+	"#define GET_LOCAL_IDX get_local_id(0)\n"
+	"#define GET_GLOBAL_IDX get_global_id(0)\n"
+	"#define GET_GROUP_SIZE get_local_size(0)\n"
+	"#define GET_NUM_GROUPS get_num_groups(0)\n"
+	"#define GROUP_LDS_BARRIER barrier(CLK_LOCAL_MEM_FENCE)\n"
+	"#define GROUP_MEM_FENCE mem_fence(CLK_LOCAL_MEM_FENCE)\n"
+	"#define AtomInc(x) atom_inc(&(x))\n"
+	"#define AtomInc1(x, out) out = atom_inc(&(x))\n"
+	"#define AppendInc(x, out) out = atomic_inc(x)\n"
+	"#define AtomAdd(x, value) atom_add(&(x), value)\n"
+	"#define AtomCmpxhg(x, cmp, value) atom_cmpxchg( &(x), cmp, value )\n"
+	"#define AtomXhg(x, value) atom_xchg ( &(x), value )\n"
+	"#define max2 max\n"
+	"#define min2 min\n"
+	"typedef unsigned int u32;\n"
+	"#ifndef B3_CONTACT4DATA_H\n"
+	"#define B3_CONTACT4DATA_H\n"
+	"#ifndef B3_FLOAT4_H\n"
+	"#define B3_FLOAT4_H\n"
+	"#ifndef B3_PLATFORM_DEFINITIONS_H\n"
+	"#define B3_PLATFORM_DEFINITIONS_H\n"
+	"struct MyTest\n"
+	"{\n"
+	"	int bla;\n"
+	"};\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"//keep B3_LARGE_FLOAT*B3_LARGE_FLOAT < FLT_MAX\n"
+	"#define B3_LARGE_FLOAT 1e18f\n"
+	"#define B3_INFINITY 1e18f\n"
+	"#define b3Assert(a)\n"
+	"#define b3ConstArray(a) __global const a*\n"
+	"#define b3AtomicInc atomic_inc\n"
+	"#define b3AtomicAdd atomic_add\n"
+	"#define b3Fabs fabs\n"
+	"#define b3Sqrt native_sqrt\n"
+	"#define b3Sin native_sin\n"
+	"#define b3Cos native_cos\n"
+	"#define B3_STATIC\n"
+	"#endif\n"
+	"#endif\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"	typedef float4	b3Float4;\n"
+	"	#define b3Float4ConstArg const b3Float4\n"
+	"	#define b3MakeFloat4 (float4)\n"
+	"	float b3Dot3F4(b3Float4ConstArg v0,b3Float4ConstArg v1)\n"
+	"	{\n"
+	"		float4 a1 = b3MakeFloat4(v0.xyz,0.f);\n"
+	"		float4 b1 = b3MakeFloat4(v1.xyz,0.f);\n"
+	"		return dot(a1, b1);\n"
+	"	}\n"
+	"	b3Float4 b3Cross3(b3Float4ConstArg v0,b3Float4ConstArg v1)\n"
+	"	{\n"
+	"		float4 a1 = b3MakeFloat4(v0.xyz,0.f);\n"
+	"		float4 b1 = b3MakeFloat4(v1.xyz,0.f);\n"
+	"		return cross(a1, b1);\n"
+	"	}\n"
+	"	#define b3MinFloat4 min\n"
+	"	#define b3MaxFloat4 max\n"
+	"	#define b3Normalized(a) normalize(a)\n"
+	"#endif \n"
+	"		\n"
+	"inline bool b3IsAlmostZero(b3Float4ConstArg v)\n"
+	"{\n"
+	"	if(b3Fabs(v.x)>1e-6 || b3Fabs(v.y)>1e-6 || b3Fabs(v.z)>1e-6)	\n"
+	"		return false;\n"
+	"	return true;\n"
+	"}\n"
+	"inline int    b3MaxDot( b3Float4ConstArg vec, __global const b3Float4* vecArray, int vecLen, float* dotOut )\n"
+	"{\n"
+	"    float maxDot = -B3_INFINITY;\n"
+	"    int i = 0;\n"
+	"    int ptIndex = -1;\n"
+	"    for( i = 0; i < vecLen; i++ )\n"
+	"    {\n"
+	"        float dot = b3Dot3F4(vecArray[i],vec);\n"
+	"            \n"
+	"        if( dot > maxDot )\n"
+	"        {\n"
+	"            maxDot = dot;\n"
+	"            ptIndex = i;\n"
+	"        }\n"
+	"    }\n"
+	"	b3Assert(ptIndex>=0);\n"
+	"    if (ptIndex<0)\n"
+	"	{\n"
+	"		ptIndex = 0;\n"
+	"	}\n"
+	"    *dotOut = maxDot;\n"
+	"    return ptIndex;\n"
+	"}\n"
+	"#endif //B3_FLOAT4_H\n"
+	"typedef  struct b3Contact4Data b3Contact4Data_t;\n"
+	"struct b3Contact4Data\n"
+	"{\n"
+	"	b3Float4	m_worldPosB[4];\n"
+	"//	b3Float4	m_localPosA[4];\n"
+	"//	b3Float4	m_localPosB[4];\n"
+	"	b3Float4	m_worldNormalOnB;	//	w: m_nPoints\n"
+	"	unsigned short  m_restituitionCoeffCmp;\n"
+	"	unsigned short  m_frictionCoeffCmp;\n"
+	"	int m_batchIdx;\n"
+	"	int m_bodyAPtrAndSignBit;//x:m_bodyAPtr, y:m_bodyBPtr\n"
+	"	int m_bodyBPtrAndSignBit;\n"
+	"	int	m_childIndexA;\n"
+	"	int	m_childIndexB;\n"
+	"	int m_unused1;\n"
+	"	int m_unused2;\n"
+	"};\n"
+	"inline int b3Contact4Data_getNumPoints(const struct b3Contact4Data* contact)\n"
+	"{\n"
+	"	return (int)contact->m_worldNormalOnB.w;\n"
+	"};\n"
+	"inline void b3Contact4Data_setNumPoints(struct b3Contact4Data* contact, int numPoints)\n"
+	"{\n"
+	"	contact->m_worldNormalOnB.w = (float)numPoints;\n"
+	"};\n"
+	"#endif //B3_CONTACT4DATA_H\n"
+	"#ifndef B3_CONVEX_POLYHEDRON_DATA_H\n"
+	"#define B3_CONVEX_POLYHEDRON_DATA_H\n"
+	"#ifndef B3_FLOAT4_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif \n"
+	"#endif //B3_FLOAT4_H\n"
+	"#ifndef B3_QUAT_H\n"
+	"#define B3_QUAT_H\n"
+	"#ifndef B3_PLATFORM_DEFINITIONS_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif\n"
+	"#endif\n"
+	"#ifndef B3_FLOAT4_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif \n"
+	"#endif //B3_FLOAT4_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"	typedef float4	b3Quat;\n"
+	"	#define b3QuatConstArg const b3Quat\n"
+	"	\n"
+	"	\n"
+	"inline float4 b3FastNormalize4(float4 v)\n"
+	"{\n"
+	"	v = (float4)(v.xyz,0.f);\n"
+	"	return fast_normalize(v);\n"
+	"}\n"
+	"	\n"
+	"inline b3Quat b3QuatMul(b3Quat a, b3Quat b);\n"
+	"inline b3Quat b3QuatNormalized(b3QuatConstArg in);\n"
+	"inline b3Quat b3QuatRotate(b3QuatConstArg q, b3QuatConstArg vec);\n"
+	"inline b3Quat b3QuatInvert(b3QuatConstArg q);\n"
+	"inline b3Quat b3QuatInverse(b3QuatConstArg q);\n"
+	"inline b3Quat b3QuatMul(b3QuatConstArg a, b3QuatConstArg b)\n"
+	"{\n"
+	"	b3Quat ans;\n"
+	"	ans = b3Cross3( a, b );\n"
+	"	ans += a.w*b+b.w*a;\n"
+	"//	ans.w = a.w*b.w - (a.x*b.x+a.y*b.y+a.z*b.z);\n"
+	"	ans.w = a.w*b.w - b3Dot3F4(a, b);\n"
+	"	return ans;\n"
+	"}\n"
+	"inline b3Quat b3QuatNormalized(b3QuatConstArg in)\n"
+	"{\n"
+	"	b3Quat q;\n"
+	"	q=in;\n"
+	"	//return b3FastNormalize4(in);\n"
+	"	float len = native_sqrt(dot(q, q));\n"
+	"	if(len > 0.f)\n"
+	"	{\n"
+	"		q *= 1.f / len;\n"
+	"	}\n"
+	"	else\n"
+	"	{\n"
+	"		q.x = q.y = q.z = 0.f;\n"
+	"		q.w = 1.f;\n"
+	"	}\n"
+	"	return q;\n"
+	"}\n"
+	"inline float4 b3QuatRotate(b3QuatConstArg q, b3QuatConstArg vec)\n"
+	"{\n"
+	"	b3Quat qInv = b3QuatInvert( q );\n"
+	"	float4 vcpy = vec;\n"
+	"	vcpy.w = 0.f;\n"
+	"	float4 out = b3QuatMul(b3QuatMul(q,vcpy),qInv);\n"
+	"	return out;\n"
+	"}\n"
+	"inline b3Quat b3QuatInverse(b3QuatConstArg q)\n"
+	"{\n"
+	"	return (b3Quat)(-q.xyz, q.w);\n"
+	"}\n"
+	"inline b3Quat b3QuatInvert(b3QuatConstArg q)\n"
+	"{\n"
+	"	return (b3Quat)(-q.xyz, q.w);\n"
+	"}\n"
+	"inline float4 b3QuatInvRotate(b3QuatConstArg q, b3QuatConstArg vec)\n"
+	"{\n"
+	"	return b3QuatRotate( b3QuatInvert( q ), vec );\n"
+	"}\n"
+	"inline b3Float4 b3TransformPoint(b3Float4ConstArg point, b3Float4ConstArg translation, b3QuatConstArg  orientation)\n"
+	"{\n"
+	"	return b3QuatRotate( orientation, point ) + (translation);\n"
+	"}\n"
+	"	\n"
+	"#endif \n"
+	"#endif //B3_QUAT_H\n"
+	"typedef struct b3GpuFace b3GpuFace_t;\n"
+	"struct b3GpuFace\n"
+	"{\n"
+	"	b3Float4 m_plane;\n"
+	"	int m_indexOffset;\n"
+	"	int m_numIndices;\n"
+	"	int m_unusedPadding1;\n"
+	"	int m_unusedPadding2;\n"
+	"};\n"
+	"typedef struct b3ConvexPolyhedronData b3ConvexPolyhedronData_t;\n"
+	"struct b3ConvexPolyhedronData\n"
+	"{\n"
+	"	b3Float4		m_localCenter;\n"
+	"	b3Float4		m_extents;\n"
+	"	b3Float4		mC;\n"
+	"	b3Float4		mE;\n"
+	"	float			m_radius;\n"
+	"	int	m_faceOffset;\n"
+	"	int m_numFaces;\n"
+	"	int	m_numVertices;\n"
+	"	int m_vertexOffset;\n"
+	"	int	m_uniqueEdgesOffset;\n"
+	"	int	m_numUniqueEdges;\n"
+	"	int m_unused;\n"
+	"};\n"
+	"#endif //B3_CONVEX_POLYHEDRON_DATA_H\n"
+	"#ifndef B3_COLLIDABLE_H\n"
+	"#define B3_COLLIDABLE_H\n"
+	"#ifndef B3_FLOAT4_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif \n"
+	"#endif //B3_FLOAT4_H\n"
+	"#ifndef B3_QUAT_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif \n"
+	"#endif //B3_QUAT_H\n"
+	"enum b3ShapeTypes\n"
+	"{\n"
+	"	SHAPE_HEIGHT_FIELD=1,\n"
+	"	SHAPE_CONVEX_HULL=3,\n"
+	"	SHAPE_PLANE=4,\n"
+	"	SHAPE_CONCAVE_TRIMESH=5,\n"
+	"	SHAPE_COMPOUND_OF_CONVEX_HULLS=6,\n"
+	"	SHAPE_SPHERE=7,\n"
+	"	MAX_NUM_SHAPE_TYPES,\n"
+	"};\n"
+	"typedef struct b3Collidable b3Collidable_t;\n"
+	"struct b3Collidable\n"
+	"{\n"
+	"	union {\n"
+	"		int m_numChildShapes;\n"
+	"		int m_bvhIndex;\n"
+	"	};\n"
+	"	union\n"
+	"	{\n"
+	"		float m_radius;\n"
+	"		int	m_compoundBvhIndex;\n"
+	"	};\n"
+	"	int m_shapeType;\n"
+	"	int m_shapeIndex;\n"
+	"};\n"
+	"typedef struct b3GpuChildShape b3GpuChildShape_t;\n"
+	"struct b3GpuChildShape\n"
+	"{\n"
+	"	b3Float4	m_childPosition;\n"
+	"	b3Quat		m_childOrientation;\n"
+	"	int m_shapeIndex;\n"
+	"	int m_unused0;\n"
+	"	int m_unused1;\n"
+	"	int m_unused2;\n"
+	"};\n"
+	"struct b3CompoundOverlappingPair\n"
+	"{\n"
+	"	int m_bodyIndexA;\n"
+	"	int m_bodyIndexB;\n"
+	"//	int	m_pairType;\n"
+	"	int m_childShapeIndexA;\n"
+	"	int m_childShapeIndexB;\n"
+	"};\n"
+	"#endif //B3_COLLIDABLE_H\n"
+	"#ifndef B3_RIGIDBODY_DATA_H\n"
+	"#define B3_RIGIDBODY_DATA_H\n"
+	"#ifndef B3_FLOAT4_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif \n"
+	"#endif //B3_FLOAT4_H\n"
+	"#ifndef B3_QUAT_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif \n"
+	"#endif //B3_QUAT_H\n"
+	"#ifndef B3_MAT3x3_H\n"
+	"#define B3_MAT3x3_H\n"
+	"#ifndef B3_QUAT_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif \n"
+	"#endif //B3_QUAT_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"typedef struct\n"
+	"{\n"
+	"	b3Float4 m_row[3];\n"
+	"}b3Mat3x3;\n"
+	"#define b3Mat3x3ConstArg const b3Mat3x3\n"
+	"#define b3GetRow(m,row) (m.m_row[row])\n"
+	"inline b3Mat3x3 b3QuatGetRotationMatrix(b3Quat quat)\n"
+	"{\n"
+	"	b3Float4 quat2 = (b3Float4)(quat.x*quat.x, quat.y*quat.y, quat.z*quat.z, 0.f);\n"
+	"	b3Mat3x3 out;\n"
+	"	out.m_row[0].x=1-2*quat2.y-2*quat2.z;\n"
+	"	out.m_row[0].y=2*quat.x*quat.y-2*quat.w*quat.z;\n"
+	"	out.m_row[0].z=2*quat.x*quat.z+2*quat.w*quat.y;\n"
+	"	out.m_row[0].w = 0.f;\n"
+	"	out.m_row[1].x=2*quat.x*quat.y+2*quat.w*quat.z;\n"
+	"	out.m_row[1].y=1-2*quat2.x-2*quat2.z;\n"
+	"	out.m_row[1].z=2*quat.y*quat.z-2*quat.w*quat.x;\n"
+	"	out.m_row[1].w = 0.f;\n"
+	"	out.m_row[2].x=2*quat.x*quat.z-2*quat.w*quat.y;\n"
+	"	out.m_row[2].y=2*quat.y*quat.z+2*quat.w*quat.x;\n"
+	"	out.m_row[2].z=1-2*quat2.x-2*quat2.y;\n"
+	"	out.m_row[2].w = 0.f;\n"
+	"	return out;\n"
+	"}\n"
+	"inline b3Mat3x3 b3AbsoluteMat3x3(b3Mat3x3ConstArg matIn)\n"
+	"{\n"
+	"	b3Mat3x3 out;\n"
+	"	out.m_row[0] = fabs(matIn.m_row[0]);\n"
+	"	out.m_row[1] = fabs(matIn.m_row[1]);\n"
+	"	out.m_row[2] = fabs(matIn.m_row[2]);\n"
+	"	return out;\n"
+	"}\n"
+	"__inline\n"
+	"b3Mat3x3 mtZero();\n"
+	"__inline\n"
+	"b3Mat3x3 mtIdentity();\n"
+	"__inline\n"
+	"b3Mat3x3 mtTranspose(b3Mat3x3 m);\n"
+	"__inline\n"
+	"b3Mat3x3 mtMul(b3Mat3x3 a, b3Mat3x3 b);\n"
+	"__inline\n"
+	"b3Float4 mtMul1(b3Mat3x3 a, b3Float4 b);\n"
+	"__inline\n"
+	"b3Float4 mtMul3(b3Float4 a, b3Mat3x3 b);\n"
+	"__inline\n"
+	"b3Mat3x3 mtZero()\n"
+	"{\n"
+	"	b3Mat3x3 m;\n"
+	"	m.m_row[0] = (b3Float4)(0.f);\n"
+	"	m.m_row[1] = (b3Float4)(0.f);\n"
+	"	m.m_row[2] = (b3Float4)(0.f);\n"
+	"	return m;\n"
+	"}\n"
+	"__inline\n"
+	"b3Mat3x3 mtIdentity()\n"
+	"{\n"
+	"	b3Mat3x3 m;\n"
+	"	m.m_row[0] = (b3Float4)(1,0,0,0);\n"
+	"	m.m_row[1] = (b3Float4)(0,1,0,0);\n"
+	"	m.m_row[2] = (b3Float4)(0,0,1,0);\n"
+	"	return m;\n"
+	"}\n"
+	"__inline\n"
+	"b3Mat3x3 mtTranspose(b3Mat3x3 m)\n"
+	"{\n"
+	"	b3Mat3x3 out;\n"
+	"	out.m_row[0] = (b3Float4)(m.m_row[0].x, m.m_row[1].x, m.m_row[2].x, 0.f);\n"
+	"	out.m_row[1] = (b3Float4)(m.m_row[0].y, m.m_row[1].y, m.m_row[2].y, 0.f);\n"
+	"	out.m_row[2] = (b3Float4)(m.m_row[0].z, m.m_row[1].z, m.m_row[2].z, 0.f);\n"
+	"	return out;\n"
+	"}\n"
+	"__inline\n"
+	"b3Mat3x3 mtMul(b3Mat3x3 a, b3Mat3x3 b)\n"
+	"{\n"
+	"	b3Mat3x3 transB;\n"
+	"	transB = mtTranspose( b );\n"
+	"	b3Mat3x3 ans;\n"
+	"	//	why this doesn't run when 0ing in the for{}\n"
+	"	a.m_row[0].w = 0.f;\n"
+	"	a.m_row[1].w = 0.f;\n"
+	"	a.m_row[2].w = 0.f;\n"
+	"	for(int i=0; i<3; i++)\n"
+	"	{\n"
+	"//	a.m_row[i].w = 0.f;\n"
+	"		ans.m_row[i].x = b3Dot3F4(a.m_row[i],transB.m_row[0]);\n"
+	"		ans.m_row[i].y = b3Dot3F4(a.m_row[i],transB.m_row[1]);\n"
+	"		ans.m_row[i].z = b3Dot3F4(a.m_row[i],transB.m_row[2]);\n"
+	"		ans.m_row[i].w = 0.f;\n"
+	"	}\n"
+	"	return ans;\n"
+	"}\n"
+	"__inline\n"
+	"b3Float4 mtMul1(b3Mat3x3 a, b3Float4 b)\n"
+	"{\n"
+	"	b3Float4 ans;\n"
+	"	ans.x = b3Dot3F4( a.m_row[0], b );\n"
+	"	ans.y = b3Dot3F4( a.m_row[1], b );\n"
+	"	ans.z = b3Dot3F4( a.m_row[2], b );\n"
+	"	ans.w = 0.f;\n"
+	"	return ans;\n"
+	"}\n"
+	"__inline\n"
+	"b3Float4 mtMul3(b3Float4 a, b3Mat3x3 b)\n"
+	"{\n"
+	"	b3Float4 colx = b3MakeFloat4(b.m_row[0].x, b.m_row[1].x, b.m_row[2].x, 0);\n"
+	"	b3Float4 coly = b3MakeFloat4(b.m_row[0].y, b.m_row[1].y, b.m_row[2].y, 0);\n"
+	"	b3Float4 colz = b3MakeFloat4(b.m_row[0].z, b.m_row[1].z, b.m_row[2].z, 0);\n"
+	"	b3Float4 ans;\n"
+	"	ans.x = b3Dot3F4( a, colx );\n"
+	"	ans.y = b3Dot3F4( a, coly );\n"
+	"	ans.z = b3Dot3F4( a, colz );\n"
+	"	return ans;\n"
+	"}\n"
+	"#endif\n"
+	"#endif //B3_MAT3x3_H\n"
+	"typedef struct b3RigidBodyData b3RigidBodyData_t;\n"
+	"struct b3RigidBodyData\n"
+	"{\n"
+	"	b3Float4				m_pos;\n"
+	"	b3Quat					m_quat;\n"
+	"	b3Float4				m_linVel;\n"
+	"	b3Float4				m_angVel;\n"
+	"	int 					m_collidableIdx;\n"
+	"	float 				m_invMass;\n"
+	"	float 				m_restituitionCoeff;\n"
+	"	float 				m_frictionCoeff;\n"
+	"};\n"
+	"typedef struct b3InertiaData b3InertiaData_t;\n"
+	"struct b3InertiaData\n"
+	"{\n"
+	"	b3Mat3x3 m_invInertiaWorld;\n"
+	"	b3Mat3x3 m_initInvInertia;\n"
+	"};\n"
+	"#endif //B3_RIGIDBODY_DATA_H\n"
+	"	\n"
+	"#define GET_NPOINTS(x) (x).m_worldNormalOnB.w\n"
+	"#define SELECT_UINT4( b, a, condition ) select( b,a,condition )\n"
+	"#define make_float4 (float4)\n"
+	"#define make_float2 (float2)\n"
+	"#define make_uint4 (uint4)\n"
+	"#define make_int4 (int4)\n"
+	"#define make_uint2 (uint2)\n"
+	"#define make_int2 (int2)\n"
+	"__inline\n"
+	"float fastDiv(float numerator, float denominator)\n"
+	"{\n"
+	"	return native_divide(numerator, denominator);	\n"
+	"//	return numerator/denominator;	\n"
+	"}\n"
+	"__inline\n"
+	"float4 fastDiv4(float4 numerator, float4 denominator)\n"
+	"{\n"
+	"	return native_divide(numerator, denominator);	\n"
+	"}\n"
+	"__inline\n"
+	"float4 cross3(float4 a, float4 b)\n"
+	"{\n"
+	"	return cross(a,b);\n"
+	"}\n"
+	"//#define dot3F4 dot\n"
+	"__inline\n"
+	"float dot3F4(float4 a, float4 b)\n"
+	"{\n"
+	"	float4 a1 = make_float4(a.xyz,0.f);\n"
+	"	float4 b1 = make_float4(b.xyz,0.f);\n"
+	"	return dot(a1, b1);\n"
+	"}\n"
+	"__inline\n"
+	"float4 fastNormalize4(float4 v)\n"
+	"{\n"
+	"	return fast_normalize(v);\n"
+	"}\n"
+	"///////////////////////////////////////\n"
+	"//	Quaternion\n"
+	"///////////////////////////////////////\n"
+	"typedef float4 Quaternion;\n"
+	"__inline\n"
+	"Quaternion qtMul(Quaternion a, Quaternion b);\n"
+	"__inline\n"
+	"Quaternion qtNormalize(Quaternion in);\n"
+	"__inline\n"
+	"float4 qtRotate(Quaternion q, float4 vec);\n"
+	"__inline\n"
+	"Quaternion qtInvert(Quaternion q);\n"
+	"__inline\n"
+	"Quaternion qtMul(Quaternion a, Quaternion b)\n"
+	"{\n"
+	"	Quaternion ans;\n"
+	"	ans = cross3( a, b );\n"
+	"	ans += a.w*b+b.w*a;\n"
+	"//	ans.w = a.w*b.w - (a.x*b.x+a.y*b.y+a.z*b.z);\n"
+	"	ans.w = a.w*b.w - dot3F4(a, b);\n"
+	"	return ans;\n"
+	"}\n"
+	"__inline\n"
+	"Quaternion qtNormalize(Quaternion in)\n"
+	"{\n"
+	"	return fastNormalize4(in);\n"
+	"//	in /= length( in );\n"
+	"//	return in;\n"
+	"}\n"
+	"__inline\n"
+	"float4 qtRotate(Quaternion q, float4 vec)\n"
+	"{\n"
+	"	Quaternion qInv = qtInvert( q );\n"
+	"	float4 vcpy = vec;\n"
+	"	vcpy.w = 0.f;\n"
+	"	float4 out = qtMul(qtMul(q,vcpy),qInv);\n"
+	"	return out;\n"
+	"}\n"
+	"__inline\n"
+	"Quaternion qtInvert(Quaternion q)\n"
+	"{\n"
+	"	return (Quaternion)(-q.xyz, q.w);\n"
+	"}\n"
+	"__inline\n"
+	"float4 qtInvRotate(const Quaternion q, float4 vec)\n"
+	"{\n"
+	"	return qtRotate( qtInvert( q ), vec );\n"
+	"}\n"
+	"__inline\n"
+	"float4 transform(const float4* p, const float4* translation, const Quaternion* orientation)\n"
+	"{\n"
+	"	return qtRotate( *orientation, *p ) + (*translation);\n"
+	"}\n"
+	"__inline\n"
+	"float4 normalize3(const float4 a)\n"
+	"{\n"
+	"	float4 n = make_float4(a.x, a.y, a.z, 0.f);\n"
+	"	return fastNormalize4( n );\n"
+	"}\n"
+	"__inline float4 lerp3(const float4 a,const float4 b, float  t)\n"
+	"{\n"
+	"	return make_float4(	a.x + (b.x - a.x) * t,\n"
+	"						a.y + (b.y - a.y) * t,\n"
+	"						a.z + (b.z - a.z) * t,\n"
+	"						0.f);\n"
+	"}\n"
+	"// Clips a face to the back of a plane, return the number of vertices out, stored in ppVtxOut\n"
+	"int clipFaceGlobal(__global const float4* pVtxIn, int numVertsIn, float4 planeNormalWS,float planeEqWS, __global float4* ppVtxOut)\n"
+	"{\n"
+	"	\n"
+	"	int ve;\n"
+	"	float ds, de;\n"
+	"	int numVertsOut = 0;\n"
+	"    //double-check next test\n"
+	"    	if (numVertsIn < 2)\n"
+	"    		return 0;\n"
+	"    \n"
+	"	float4 firstVertex=pVtxIn[numVertsIn-1];\n"
+	"	float4 endVertex = pVtxIn[0];\n"
+	"	\n"
+	"	ds = dot3F4(planeNormalWS,firstVertex)+planeEqWS;\n"
+	"    \n"
+	"	for (ve = 0; ve < numVertsIn; ve++)\n"
+	"	{\n"
+	"		endVertex=pVtxIn[ve];\n"
+	"		de = dot3F4(planeNormalWS,endVertex)+planeEqWS;\n"
+	"		if (ds<0)\n"
+	"		{\n"
+	"			if (de<0)\n"
+	"			{\n"
+	"				// Start < 0, end < 0, so output endVertex\n"
+	"				ppVtxOut[numVertsOut++] = endVertex;\n"
+	"			}\n"
+	"			else\n"
+	"			{\n"
+	"				// Start < 0, end >= 0, so output intersection\n"
+	"				ppVtxOut[numVertsOut++] = lerp3(firstVertex, endVertex,(ds * 1.f/(ds - de)) );\n"
+	"			}\n"
+	"		}\n"
+	"		else\n"
+	"		{\n"
+	"			if (de<0)\n"
+	"			{\n"
+	"				// Start >= 0, end < 0 so output intersection and end\n"
+	"				ppVtxOut[numVertsOut++] = lerp3(firstVertex, endVertex,(ds * 1.f/(ds - de)) );\n"
+	"				ppVtxOut[numVertsOut++] = endVertex;\n"
+	"			}\n"
+	"		}\n"
+	"		firstVertex = endVertex;\n"
+	"		ds = de;\n"
+	"	}\n"
+	"	return numVertsOut;\n"
+	"}\n"
+	"// Clips a face to the back of a plane, return the number of vertices out, stored in ppVtxOut\n"
+	"int clipFace(const float4* pVtxIn, int numVertsIn, float4 planeNormalWS,float planeEqWS, float4* ppVtxOut)\n"
+	"{\n"
+	"	\n"
+	"	int ve;\n"
+	"	float ds, de;\n"
+	"	int numVertsOut = 0;\n"
+	"//double-check next test\n"
+	"	if (numVertsIn < 2)\n"
+	"		return 0;\n"
+	"	float4 firstVertex=pVtxIn[numVertsIn-1];\n"
+	"	float4 endVertex = pVtxIn[0];\n"
+	"	\n"
+	"	ds = dot3F4(planeNormalWS,firstVertex)+planeEqWS;\n"
+	"	for (ve = 0; ve < numVertsIn; ve++)\n"
+	"	{\n"
+	"		endVertex=pVtxIn[ve];\n"
+	"		de = dot3F4(planeNormalWS,endVertex)+planeEqWS;\n"
+	"		if (ds<0)\n"
+	"		{\n"
+	"			if (de<0)\n"
+	"			{\n"
+	"				// Start < 0, end < 0, so output endVertex\n"
+	"				ppVtxOut[numVertsOut++] = endVertex;\n"
+	"			}\n"
+	"			else\n"
+	"			{\n"
+	"				// Start < 0, end >= 0, so output intersection\n"
+	"				ppVtxOut[numVertsOut++] = lerp3(firstVertex, endVertex,(ds * 1.f/(ds - de)) );\n"
+	"			}\n"
+	"		}\n"
+	"		else\n"
+	"		{\n"
+	"			if (de<0)\n"
+	"			{\n"
+	"				// Start >= 0, end < 0 so output intersection and end\n"
+	"				ppVtxOut[numVertsOut++] = lerp3(firstVertex, endVertex,(ds * 1.f/(ds - de)) );\n"
+	"				ppVtxOut[numVertsOut++] = endVertex;\n"
+	"			}\n"
+	"		}\n"
+	"		firstVertex = endVertex;\n"
+	"		ds = de;\n"
+	"	}\n"
+	"	return numVertsOut;\n"
+	"}\n"
+	"int clipFaceAgainstHull(const float4 separatingNormal, __global const b3ConvexPolyhedronData_t* hullA,  \n"
+	"	const float4 posA, const Quaternion ornA, float4* worldVertsB1, int numWorldVertsB1,\n"
+	"	float4* worldVertsB2, int capacityWorldVertsB2,\n"
+	"	const float minDist, float maxDist,\n"
+	"	__global const float4* vertices,\n"
+	"	__global const b3GpuFace_t* faces,\n"
+	"	__global const int* indices,\n"
+	"	float4* contactsOut,\n"
+	"	int contactCapacity)\n"
+	"{\n"
+	"	int numContactsOut = 0;\n"
+	"	float4* pVtxIn = worldVertsB1;\n"
+	"	float4* pVtxOut = worldVertsB2;\n"
+	"	\n"
+	"	int numVertsIn = numWorldVertsB1;\n"
+	"	int numVertsOut = 0;\n"
+	"	int closestFaceA=-1;\n"
+	"	{\n"
+	"		float dmin = FLT_MAX;\n"
+	"		for(int face=0;face<hullA->m_numFaces;face++)\n"
+	"		{\n"
+	"			const float4 Normal = make_float4(\n"
+	"				faces[hullA->m_faceOffset+face].m_plane.x, \n"
+	"				faces[hullA->m_faceOffset+face].m_plane.y, \n"
+	"				faces[hullA->m_faceOffset+face].m_plane.z,0.f);\n"
+	"			const float4 faceANormalWS = qtRotate(ornA,Normal);\n"
+	"		\n"
+	"			float d = dot3F4(faceANormalWS,separatingNormal);\n"
+	"			if (d < dmin)\n"
+	"			{\n"
+	"				dmin = d;\n"
+	"				closestFaceA = face;\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"	if (closestFaceA<0)\n"
+	"		return numContactsOut;\n"
+	"	b3GpuFace_t polyA = faces[hullA->m_faceOffset+closestFaceA];\n"
+	"	// clip polygon to back of planes of all faces of hull A that are adjacent to witness face\n"
+	"	int numVerticesA = polyA.m_numIndices;\n"
+	"	for(int e0=0;e0<numVerticesA;e0++)\n"
+	"	{\n"
+	"		const float4 a = vertices[hullA->m_vertexOffset+indices[polyA.m_indexOffset+e0]];\n"
+	"		const float4 b = vertices[hullA->m_vertexOffset+indices[polyA.m_indexOffset+((e0+1)%numVerticesA)]];\n"
+	"		const float4 edge0 = a - b;\n"
+	"		const float4 WorldEdge0 = qtRotate(ornA,edge0);\n"
+	"		float4 planeNormalA = make_float4(polyA.m_plane.x,polyA.m_plane.y,polyA.m_plane.z,0.f);\n"
+	"		float4 worldPlaneAnormal1 = qtRotate(ornA,planeNormalA);\n"
+	"		float4 planeNormalWS1 = -cross3(WorldEdge0,worldPlaneAnormal1);\n"
+	"		float4 worldA1 = transform(&a,&posA,&ornA);\n"
+	"		float planeEqWS1 = -dot3F4(worldA1,planeNormalWS1);\n"
+	"		\n"
+	"		float4 planeNormalWS = planeNormalWS1;\n"
+	"		float planeEqWS=planeEqWS1;\n"
+	"		\n"
+	"		//clip face\n"
+	"		//clipFace(*pVtxIn, *pVtxOut,planeNormalWS,planeEqWS);\n"
+	"		numVertsOut = clipFace(pVtxIn, numVertsIn, planeNormalWS,planeEqWS, pVtxOut);\n"
+	"		//btSwap(pVtxIn,pVtxOut);\n"
+	"		float4* tmp = pVtxOut;\n"
+	"		pVtxOut = pVtxIn;\n"
+	"		pVtxIn = tmp;\n"
+	"		numVertsIn = numVertsOut;\n"
+	"		numVertsOut = 0;\n"
+	"	}\n"
+	"	\n"
+	"	// only keep points that are behind the witness face\n"
+	"	{\n"
+	"		float4 localPlaneNormal  = make_float4(polyA.m_plane.x,polyA.m_plane.y,polyA.m_plane.z,0.f);\n"
+	"		float localPlaneEq = polyA.m_plane.w;\n"
+	"		float4 planeNormalWS = qtRotate(ornA,localPlaneNormal);\n"
+	"		float planeEqWS=localPlaneEq-dot3F4(planeNormalWS,posA);\n"
+	"		for (int i=0;i<numVertsIn;i++)\n"
+	"		{\n"
+	"			float depth = dot3F4(planeNormalWS,pVtxIn[i])+planeEqWS;\n"
+	"			if (depth <=minDist)\n"
+	"			{\n"
+	"				depth = minDist;\n"
+	"			}\n"
+	"			if (depth <=maxDist)\n"
+	"			{\n"
+	"				float4 pointInWorld = pVtxIn[i];\n"
+	"				//resultOut.addContactPoint(separatingNormal,point,depth);\n"
+	"				contactsOut[numContactsOut++] = make_float4(pointInWorld.x,pointInWorld.y,pointInWorld.z,depth);\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"	return numContactsOut;\n"
+	"}\n"
+	"int clipFaceAgainstHullLocalA(const float4 separatingNormal, const b3ConvexPolyhedronData_t* hullA,  \n"
+	"	const float4 posA, const Quaternion ornA, float4* worldVertsB1, int numWorldVertsB1,\n"
+	"	float4* worldVertsB2, int capacityWorldVertsB2,\n"
+	"	const float minDist, float maxDist,\n"
+	"	const float4* verticesA,\n"
+	"	const b3GpuFace_t* facesA,\n"
+	"	const int* indicesA,\n"
+	"	__global const float4* verticesB,\n"
+	"	__global const b3GpuFace_t* facesB,\n"
+	"	__global const int* indicesB,\n"
+	"	float4* contactsOut,\n"
+	"	int contactCapacity)\n"
+	"{\n"
+	"	int numContactsOut = 0;\n"
+	"	float4* pVtxIn = worldVertsB1;\n"
+	"	float4* pVtxOut = worldVertsB2;\n"
+	"	\n"
+	"	int numVertsIn = numWorldVertsB1;\n"
+	"	int numVertsOut = 0;\n"
+	"	int closestFaceA=-1;\n"
+	"	{\n"
+	"		float dmin = FLT_MAX;\n"
+	"		for(int face=0;face<hullA->m_numFaces;face++)\n"
+	"		{\n"
+	"			const float4 Normal = make_float4(\n"
+	"				facesA[hullA->m_faceOffset+face].m_plane.x, \n"
+	"				facesA[hullA->m_faceOffset+face].m_plane.y, \n"
+	"				facesA[hullA->m_faceOffset+face].m_plane.z,0.f);\n"
+	"			const float4 faceANormalWS = qtRotate(ornA,Normal);\n"
+	"		\n"
+	"			float d = dot3F4(faceANormalWS,separatingNormal);\n"
+	"			if (d < dmin)\n"
+	"			{\n"
+	"				dmin = d;\n"
+	"				closestFaceA = face;\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"	if (closestFaceA<0)\n"
+	"		return numContactsOut;\n"
+	"	b3GpuFace_t polyA = facesA[hullA->m_faceOffset+closestFaceA];\n"
+	"	// clip polygon to back of planes of all faces of hull A that are adjacent to witness face\n"
+	"	int numVerticesA = polyA.m_numIndices;\n"
+	"	for(int e0=0;e0<numVerticesA;e0++)\n"
+	"	{\n"
+	"		const float4 a = verticesA[hullA->m_vertexOffset+indicesA[polyA.m_indexOffset+e0]];\n"
+	"		const float4 b = verticesA[hullA->m_vertexOffset+indicesA[polyA.m_indexOffset+((e0+1)%numVerticesA)]];\n"
+	"		const float4 edge0 = a - b;\n"
+	"		const float4 WorldEdge0 = qtRotate(ornA,edge0);\n"
+	"		float4 planeNormalA = make_float4(polyA.m_plane.x,polyA.m_plane.y,polyA.m_plane.z,0.f);\n"
+	"		float4 worldPlaneAnormal1 = qtRotate(ornA,planeNormalA);\n"
+	"		float4 planeNormalWS1 = -cross3(WorldEdge0,worldPlaneAnormal1);\n"
+	"		float4 worldA1 = transform(&a,&posA,&ornA);\n"
+	"		float planeEqWS1 = -dot3F4(worldA1,planeNormalWS1);\n"
+	"		\n"
+	"		float4 planeNormalWS = planeNormalWS1;\n"
+	"		float planeEqWS=planeEqWS1;\n"
+	"		\n"
+	"		//clip face\n"
+	"		//clipFace(*pVtxIn, *pVtxOut,planeNormalWS,planeEqWS);\n"
+	"		numVertsOut = clipFace(pVtxIn, numVertsIn, planeNormalWS,planeEqWS, pVtxOut);\n"
+	"		//btSwap(pVtxIn,pVtxOut);\n"
+	"		float4* tmp = pVtxOut;\n"
+	"		pVtxOut = pVtxIn;\n"
+	"		pVtxIn = tmp;\n"
+	"		numVertsIn = numVertsOut;\n"
+	"		numVertsOut = 0;\n"
+	"	}\n"
+	"	\n"
+	"	// only keep points that are behind the witness face\n"
+	"	{\n"
+	"		float4 localPlaneNormal  = make_float4(polyA.m_plane.x,polyA.m_plane.y,polyA.m_plane.z,0.f);\n"
+	"		float localPlaneEq = polyA.m_plane.w;\n"
+	"		float4 planeNormalWS = qtRotate(ornA,localPlaneNormal);\n"
+	"		float planeEqWS=localPlaneEq-dot3F4(planeNormalWS,posA);\n"
+	"		for (int i=0;i<numVertsIn;i++)\n"
+	"		{\n"
+	"			float depth = dot3F4(planeNormalWS,pVtxIn[i])+planeEqWS;\n"
+	"			if (depth <=minDist)\n"
+	"			{\n"
+	"				depth = minDist;\n"
+	"			}\n"
+	"			if (depth <=maxDist)\n"
+	"			{\n"
+	"				float4 pointInWorld = pVtxIn[i];\n"
+	"				//resultOut.addContactPoint(separatingNormal,point,depth);\n"
+	"				contactsOut[numContactsOut++] = make_float4(pointInWorld.x,pointInWorld.y,pointInWorld.z,depth);\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"	return numContactsOut;\n"
+	"}\n"
+	"int	clipHullAgainstHull(const float4 separatingNormal,\n"
+	"	__global const b3ConvexPolyhedronData_t* hullA, __global const b3ConvexPolyhedronData_t* hullB, \n"
+	"	const float4 posA, const Quaternion ornA,const float4 posB, const Quaternion ornB, \n"
+	"	float4* worldVertsB1, float4* worldVertsB2, int capacityWorldVerts,\n"
+	"	const float minDist, float maxDist,\n"
+	"	__global const float4* vertices,\n"
+	"	__global const b3GpuFace_t* faces,\n"
+	"	__global const int* indices,\n"
+	"	float4*	localContactsOut,\n"
+	"	int localContactCapacity)\n"
+	"{\n"
+	"	int numContactsOut = 0;\n"
+	"	int numWorldVertsB1= 0;\n"
+	"	int closestFaceB=-1;\n"
+	"	float dmax = -FLT_MAX;\n"
+	"	{\n"
+	"		for(int face=0;face<hullB->m_numFaces;face++)\n"
+	"		{\n"
+	"			const float4 Normal = make_float4(faces[hullB->m_faceOffset+face].m_plane.x, \n"
+	"				faces[hullB->m_faceOffset+face].m_plane.y, faces[hullB->m_faceOffset+face].m_plane.z,0.f);\n"
+	"			const float4 WorldNormal = qtRotate(ornB, Normal);\n"
+	"			float d = dot3F4(WorldNormal,separatingNormal);\n"
+	"			if (d > dmax)\n"
+	"			{\n"
+	"				dmax = d;\n"
+	"				closestFaceB = face;\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"	{\n"
+	"		const b3GpuFace_t polyB = faces[hullB->m_faceOffset+closestFaceB];\n"
+	"		const int numVertices = polyB.m_numIndices;\n"
+	"		for(int e0=0;e0<numVertices;e0++)\n"
+	"		{\n"
+	"			const float4 b = vertices[hullB->m_vertexOffset+indices[polyB.m_indexOffset+e0]];\n"
+	"			worldVertsB1[numWorldVertsB1++] = transform(&b,&posB,&ornB);\n"
+	"		}\n"
+	"	}\n"
+	"	if (closestFaceB>=0)\n"
+	"	{\n"
+	"		numContactsOut = clipFaceAgainstHull(separatingNormal, hullA, \n"
+	"				posA,ornA,\n"
+	"				worldVertsB1,numWorldVertsB1,worldVertsB2,capacityWorldVerts, minDist, maxDist,vertices,\n"
+	"				faces,\n"
+	"				indices,localContactsOut,localContactCapacity);\n"
+	"	}\n"
+	"	return numContactsOut;\n"
+	"}\n"
+	"int	clipHullAgainstHullLocalA(const float4 separatingNormal,\n"
+	"	const b3ConvexPolyhedronData_t* hullA, __global const b3ConvexPolyhedronData_t* hullB, \n"
+	"	const float4 posA, const Quaternion ornA,const float4 posB, const Quaternion ornB, \n"
+	"	float4* worldVertsB1, float4* worldVertsB2, int capacityWorldVerts,\n"
+	"	const float minDist, float maxDist,\n"
+	"	const float4* verticesA,\n"
+	"	const b3GpuFace_t* facesA,\n"
+	"	const int* indicesA,\n"
+	"	__global const float4* verticesB,\n"
+	"	__global const b3GpuFace_t* facesB,\n"
+	"	__global const int* indicesB,\n"
+	"	float4*	localContactsOut,\n"
+	"	int localContactCapacity)\n"
+	"{\n"
+	"	int numContactsOut = 0;\n"
+	"	int numWorldVertsB1= 0;\n"
+	"	int closestFaceB=-1;\n"
+	"	float dmax = -FLT_MAX;\n"
+	"	{\n"
+	"		for(int face=0;face<hullB->m_numFaces;face++)\n"
+	"		{\n"
+	"			const float4 Normal = make_float4(facesB[hullB->m_faceOffset+face].m_plane.x, \n"
+	"				facesB[hullB->m_faceOffset+face].m_plane.y, facesB[hullB->m_faceOffset+face].m_plane.z,0.f);\n"
+	"			const float4 WorldNormal = qtRotate(ornB, Normal);\n"
+	"			float d = dot3F4(WorldNormal,separatingNormal);\n"
+	"			if (d > dmax)\n"
+	"			{\n"
+	"				dmax = d;\n"
+	"				closestFaceB = face;\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"	{\n"
+	"		const b3GpuFace_t polyB = facesB[hullB->m_faceOffset+closestFaceB];\n"
+	"		const int numVertices = polyB.m_numIndices;\n"
+	"		for(int e0=0;e0<numVertices;e0++)\n"
+	"		{\n"
+	"			const float4 b = verticesB[hullB->m_vertexOffset+indicesB[polyB.m_indexOffset+e0]];\n"
+	"			worldVertsB1[numWorldVertsB1++] = transform(&b,&posB,&ornB);\n"
+	"		}\n"
+	"	}\n"
+	"	if (closestFaceB>=0)\n"
+	"	{\n"
+	"		numContactsOut = clipFaceAgainstHullLocalA(separatingNormal, hullA, \n"
+	"				posA,ornA,\n"
+	"				worldVertsB1,numWorldVertsB1,worldVertsB2,capacityWorldVerts, minDist, maxDist,\n"
+	"				verticesA,facesA,indicesA,\n"
+	"				verticesB,facesB,indicesB,\n"
+	"				localContactsOut,localContactCapacity);\n"
+	"	}\n"
+	"	return numContactsOut;\n"
+	"}\n"
+	"#define PARALLEL_SUM(v, n) for(int j=1; j<n; j++) v[0] += v[j];\n"
+	"#define PARALLEL_DO(execution, n) for(int ie=0; ie<n; ie++){execution;}\n"
+	"#define REDUCE_MAX(v, n) {int i=0; for(int offset=0; offset<n; offset++) v[i] = (v[i].y > v[i+offset].y)? v[i]: v[i+offset]; }\n"
+	"#define REDUCE_MIN(v, n) {int i=0; for(int offset=0; offset<n; offset++) v[i] = (v[i].y < v[i+offset].y)? v[i]: v[i+offset]; }\n"
+	"int extractManifoldSequentialGlobal(__global const float4* p, int nPoints, float4 nearNormal, int4* contactIdx)\n"
+	"{\n"
+	"	if( nPoints == 0 )\n"
+	"        return 0;\n"
+	"    \n"
+	"    if (nPoints <=4)\n"
+	"        return nPoints;\n"
+	"    \n"
+	"    \n"
+	"    if (nPoints >64)\n"
+	"        nPoints = 64;\n"
+	"    \n"
+	"	float4 center = make_float4(0.f);\n"
+	"	{\n"
+	"		\n"
+	"		for (int i=0;i<nPoints;i++)\n"
+	"			center += p[i];\n"
+	"		center /= (float)nPoints;\n"
+	"	}\n"
+	"    \n"
+	"	\n"
+	"    \n"
+	"	//	sample 4 directions\n"
+	"    \n"
+	"    float4 aVector = p[0] - center;\n"
+	"    float4 u = cross3( nearNormal, aVector );\n"
+	"    float4 v = cross3( nearNormal, u );\n"
+	"    u = normalize3( u );\n"
+	"    v = normalize3( v );\n"
+	"    \n"
+	"    \n"
+	"    //keep point with deepest penetration\n"
+	"    float minW= FLT_MAX;\n"
+	"    \n"
+	"    int minIndex=-1;\n"
+	"    \n"
+	"    float4 maxDots;\n"
+	"    maxDots.x = FLT_MIN;\n"
+	"    maxDots.y = FLT_MIN;\n"
+	"    maxDots.z = FLT_MIN;\n"
+	"    maxDots.w = FLT_MIN;\n"
+	"    \n"
+	"    //	idx, distance\n"
+	"    for(int ie = 0; ie<nPoints; ie++ )\n"
+	"    {\n"
+	"        if (p[ie].w<minW)\n"
+	"        {\n"
+	"            minW = p[ie].w;\n"
+	"            minIndex=ie;\n"
+	"        }\n"
+	"        float f;\n"
+	"        float4 r = p[ie]-center;\n"
+	"        f = dot3F4( u, r );\n"
+	"        if (f<maxDots.x)\n"
+	"        {\n"
+	"            maxDots.x = f;\n"
+	"            contactIdx[0].x = ie;\n"
+	"        }\n"
+	"        \n"
+	"        f = dot3F4( -u, r );\n"
+	"        if (f<maxDots.y)\n"
+	"        {\n"
+	"            maxDots.y = f;\n"
+	"            contactIdx[0].y = ie;\n"
+	"        }\n"
+	"        \n"
+	"        \n"
+	"        f = dot3F4( v, r );\n"
+	"        if (f<maxDots.z)\n"
+	"        {\n"
+	"            maxDots.z = f;\n"
+	"            contactIdx[0].z = ie;\n"
+	"        }\n"
+	"        \n"
+	"        f = dot3F4( -v, r );\n"
+	"        if (f<maxDots.w)\n"
+	"        {\n"
+	"            maxDots.w = f;\n"
+	"            contactIdx[0].w = ie;\n"
+	"        }\n"
+	"        \n"
+	"    }\n"
+	"    \n"
+	"    if (contactIdx[0].x != minIndex && contactIdx[0].y != minIndex && contactIdx[0].z != minIndex && contactIdx[0].w != minIndex)\n"
+	"    {\n"
+	"        //replace the first contact with minimum (todo: replace contact with least penetration)\n"
+	"        contactIdx[0].x = minIndex;\n"
+	"    }\n"
+	"    \n"
+	"    return 4;\n"
+	"    \n"
+	"}\n"
+	"int extractManifoldSequentialGlobalFake(__global const float4* p, int nPoints, float4 nearNormal, int* contactIdx)\n"
+	"{\n"
+	"    contactIdx[0] = 0;\n"
+	"    contactIdx[1] = 1;\n"
+	"    contactIdx[2] = 2;\n"
+	"    contactIdx[3] = 3;\n"
+	"    \n"
+	"	if( nPoints == 0 ) return 0;\n"
+	"    \n"
+	"	nPoints = min2( nPoints, 4 );\n"
+	"    return nPoints;\n"
+	"    \n"
+	"}\n"
+	"int extractManifoldSequential(const float4* p, int nPoints, float4 nearNormal, int* contactIdx)\n"
+	"{\n"
+	"	if( nPoints == 0 ) return 0;\n"
+	"	nPoints = min2( nPoints, 64 );\n"
+	"	float4 center = make_float4(0.f);\n"
+	"	{\n"
+	"		float4 v[64];\n"
+	"		for (int i=0;i<nPoints;i++)\n"
+	"			v[i] = p[i];\n"
+	"		//memcpy( v, p, nPoints*sizeof(float4) );\n"
+	"		PARALLEL_SUM( v, nPoints );\n"
+	"		center = v[0]/(float)nPoints;\n"
+	"	}\n"
+	"	\n"
+	"	{	//	sample 4 directions\n"
+	"		if( nPoints < 4 )\n"
+	"		{\n"
+	"			for(int i=0; i<nPoints; i++) \n"
+	"				contactIdx[i] = i;\n"
+	"			return nPoints;\n"
+	"		}\n"
+	"		float4 aVector = p[0] - center;\n"
+	"		float4 u = cross3( nearNormal, aVector );\n"
+	"		float4 v = cross3( nearNormal, u );\n"
+	"		u = normalize3( u );\n"
+	"		v = normalize3( v );\n"
+	"		int idx[4];\n"
+	"		float2 max00 = make_float2(0,FLT_MAX);\n"
+	"		{\n"
+	"			//	idx, distance\n"
+	"			{\n"
+	"				{\n"
+	"					int4 a[64];\n"
+	"					for(int ie = 0; ie<nPoints; ie++ )\n"
+	"					{\n"
+	"						\n"
+	"						\n"
+	"						float f;\n"
+	"						float4 r = p[ie]-center;\n"
+	"						f = dot3F4( u, r );\n"
+	"						a[ie].x = ((*(u32*)&f) & 0xffffff00) | (0xff & ie);\n"
+	"						f = dot3F4( -u, r );\n"
+	"						a[ie].y = ((*(u32*)&f) & 0xffffff00) | (0xff & ie);\n"
+	"						f = dot3F4( v, r );\n"
+	"						a[ie].z = ((*(u32*)&f) & 0xffffff00) | (0xff & ie);\n"
+	"						f = dot3F4( -v, r );\n"
+	"						a[ie].w = ((*(u32*)&f) & 0xffffff00) | (0xff & ie);\n"
+	"					}\n"
+	"					for(int ie=0; ie<nPoints; ie++)\n"
+	"					{\n"
+	"						a[0].x = (a[0].x > a[ie].x )? a[0].x: a[ie].x;\n"
+	"						a[0].y = (a[0].y > a[ie].y )? a[0].y: a[ie].y;\n"
+	"						a[0].z = (a[0].z > a[ie].z )? a[0].z: a[ie].z;\n"
+	"						a[0].w = (a[0].w > a[ie].w )? a[0].w: a[ie].w;\n"
+	"					}\n"
+	"					idx[0] = (int)a[0].x & 0xff;\n"
+	"					idx[1] = (int)a[0].y & 0xff;\n"
+	"					idx[2] = (int)a[0].z & 0xff;\n"
+	"					idx[3] = (int)a[0].w & 0xff;\n"
+	"				}\n"
+	"			}\n"
+	"			{\n"
+	"				float2 h[64];\n"
+	"				PARALLEL_DO( h[ie] = make_float2((float)ie, p[ie].w), nPoints );\n"
+	"				REDUCE_MIN( h, nPoints );\n"
+	"				max00 = h[0];\n"
+	"			}\n"
+	"		}\n"
+	"		contactIdx[0] = idx[0];\n"
+	"		contactIdx[1] = idx[1];\n"
+	"		contactIdx[2] = idx[2];\n"
+	"		contactIdx[3] = idx[3];\n"
+	"		return 4;\n"
+	"	}\n"
+	"}\n"
+	"__kernel void   extractManifoldAndAddContactKernel(__global const int4* pairs, \n"
+	"																	__global const b3RigidBodyData_t* rigidBodies, \n"
+	"																	__global const float4* closestPointsWorld,\n"
+	"																	__global const float4* separatingNormalsWorld,\n"
+	"																	__global const int* contactCounts,\n"
+	"																	__global const int* contactOffsets,\n"
+	"																	__global struct b3Contact4Data* restrict contactsOut,\n"
+	"																	counter32_t nContactsOut,\n"
+	"																	int contactCapacity,\n"
+	"																	int numPairs,\n"
+	"																	int pairIndex\n"
+	"																	)\n"
+	"{\n"
+	"	int idx = get_global_id(0);\n"
+	"	\n"
+	"	if (idx<numPairs)\n"
+	"	{\n"
+	"		float4 normal = separatingNormalsWorld[idx];\n"
+	"		int nPoints = contactCounts[idx];\n"
+	"		__global const float4* pointsIn = &closestPointsWorld[contactOffsets[idx]];\n"
+	"		float4 localPoints[64];\n"
+	"		for (int i=0;i<nPoints;i++)\n"
+	"		{\n"
+	"			localPoints[i] = pointsIn[i];\n"
+	"		}\n"
+	"		int contactIdx[4];// = {-1,-1,-1,-1};\n"
+	"		contactIdx[0] = -1;\n"
+	"		contactIdx[1] = -1;\n"
+	"		contactIdx[2] = -1;\n"
+	"		contactIdx[3] = -1;\n"
+	"		int nContacts = extractManifoldSequential(localPoints, nPoints, normal, contactIdx);\n"
+	"		int dstIdx;\n"
+	"		AppendInc( nContactsOut, dstIdx );\n"
+	"		if (dstIdx<contactCapacity)\n"
+	"		{\n"
+	"			__global struct b3Contact4Data* c = contactsOut + dstIdx;\n"
+	"			c->m_worldNormalOnB = -normal;\n"
+	"			c->m_restituitionCoeffCmp = (0.f*0xffff);c->m_frictionCoeffCmp = (0.7f*0xffff);\n"
+	"			c->m_batchIdx = idx;\n"
+	"			int bodyA = pairs[pairIndex].x;\n"
+	"			int bodyB = pairs[pairIndex].y;\n"
+	"			c->m_bodyAPtrAndSignBit = rigidBodies[bodyA].m_invMass==0 ? -bodyA:bodyA;\n"
+	"			c->m_bodyBPtrAndSignBit = rigidBodies[bodyB].m_invMass==0 ? -bodyB:bodyB;\n"
+	"			c->m_childIndexA = -1;\n"
+	"			c->m_childIndexB = -1;\n"
+	"			for (int i=0;i<nContacts;i++)\n"
+	"			{\n"
+	"				c->m_worldPosB[i] = localPoints[contactIdx[i]];\n"
+	"			}\n"
+	"			GET_NPOINTS(*c) = nContacts;\n"
+	"		}\n"
+	"	}\n"
+	"}\n"
+	"void	trInverse(float4 translationIn, Quaternion orientationIn,\n"
+	"		float4* translationOut, Quaternion* orientationOut)\n"
+	"{\n"
+	"	*orientationOut = qtInvert(orientationIn);\n"
+	"	*translationOut = qtRotate(*orientationOut, -translationIn);\n"
+	"}\n"
+	"void	trMul(float4 translationA, Quaternion orientationA,\n"
+	"						float4 translationB, Quaternion orientationB,\n"
+	"		float4* translationOut, Quaternion* orientationOut)\n"
+	"{\n"
+	"	*orientationOut = qtMul(orientationA,orientationB);\n"
+	"	*translationOut = transform(&translationB,&translationA,&orientationA);\n"
+	"}\n"
+	"__kernel void   clipHullHullKernel( __global int4* pairs, \n"
+	"																					__global const b3RigidBodyData_t* rigidBodies, \n"
+	"																					__global const b3Collidable_t* collidables,\n"
+	"																					__global const b3ConvexPolyhedronData_t* convexShapes, \n"
+	"																					__global const float4* vertices,\n"
+	"																					__global const float4* uniqueEdges,\n"
+	"																					__global const b3GpuFace_t* faces,\n"
+	"																					__global const int* indices,\n"
+	"																					__global const float4* separatingNormals,\n"
+	"																					__global const int* hasSeparatingAxis,\n"
+	"																					__global struct b3Contact4Data* restrict globalContactsOut,\n"
+	"																					counter32_t nGlobalContactsOut,\n"
+	"																					int numPairs,\n"
+	"																					int contactCapacity)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	int pairIndex = i;\n"
+	"	\n"
+	"	float4 worldVertsB1[64];\n"
+	"	float4 worldVertsB2[64];\n"
+	"	int capacityWorldVerts = 64;	\n"
+	"	float4 localContactsOut[64];\n"
+	"	int localContactCapacity=64;\n"
+	"	\n"
+	"	float minDist = -1e30f;\n"
+	"	float maxDist = 0.02f;\n"
+	"	if (i<numPairs)\n"
+	"	{\n"
+	"		int bodyIndexA = pairs[i].x;\n"
+	"		int bodyIndexB = pairs[i].y;\n"
+	"			\n"
+	"		int collidableIndexA = rigidBodies[bodyIndexA].m_collidableIdx;\n"
+	"		int collidableIndexB = rigidBodies[bodyIndexB].m_collidableIdx;\n"
+	"		if (hasSeparatingAxis[i])\n"
+	"		{\n"
+	"			\n"
+	"			int shapeIndexA = collidables[collidableIndexA].m_shapeIndex;\n"
+	"			int shapeIndexB = collidables[collidableIndexB].m_shapeIndex;\n"
+	"			\n"
+	"		\n"
+	"			int numLocalContactsOut = clipHullAgainstHull(separatingNormals[i],\n"
+	"														&convexShapes[shapeIndexA], &convexShapes[shapeIndexB],\n"
+	"														rigidBodies[bodyIndexA].m_pos,rigidBodies[bodyIndexA].m_quat,\n"
+	"													  rigidBodies[bodyIndexB].m_pos,rigidBodies[bodyIndexB].m_quat,\n"
+	"													  worldVertsB1,worldVertsB2,capacityWorldVerts,\n"
+	"														minDist, maxDist,\n"
+	"														vertices,faces,indices,\n"
+	"														localContactsOut,localContactCapacity);\n"
+	"												\n"
+	"		if (numLocalContactsOut>0)\n"
+	"		{\n"
+	"				float4 normal = -separatingNormals[i];\n"
+	"				int nPoints = numLocalContactsOut;\n"
+	"				float4* pointsIn = localContactsOut;\n"
+	"				int contactIdx[4];// = {-1,-1,-1,-1};\n"
+	"				contactIdx[0] = -1;\n"
+	"				contactIdx[1] = -1;\n"
+	"				contactIdx[2] = -1;\n"
+	"				contactIdx[3] = -1;\n"
+	"		\n"
+	"				int nReducedContacts = extractManifoldSequential(pointsIn, nPoints, normal, contactIdx);\n"
+	"		\n"
+	"				\n"
+	"				int mprContactIndex = pairs[pairIndex].z;\n"
+	"				int dstIdx = mprContactIndex;\n"
+	"				if (dstIdx<0)\n"
+	"				{\n"
+	"					AppendInc( nGlobalContactsOut, dstIdx );\n"
+	"				}\n"
+	"				if (dstIdx<contactCapacity)\n"
+	"				{\n"
+	"					pairs[pairIndex].z = dstIdx;\n"
+	"					__global struct b3Contact4Data* c = globalContactsOut+ dstIdx;\n"
+	"					c->m_worldNormalOnB = -normal;\n"
+	"					c->m_restituitionCoeffCmp = (0.f*0xffff);c->m_frictionCoeffCmp = (0.7f*0xffff);\n"
+	"					c->m_batchIdx = pairIndex;\n"
+	"					int bodyA = pairs[pairIndex].x;\n"
+	"					int bodyB = pairs[pairIndex].y;\n"
+	"					c->m_bodyAPtrAndSignBit = rigidBodies[bodyA].m_invMass==0?-bodyA:bodyA;\n"
+	"					c->m_bodyBPtrAndSignBit = rigidBodies[bodyB].m_invMass==0?-bodyB:bodyB;\n"
+	"					c->m_childIndexA = -1;\n"
+	"					c->m_childIndexB = -1;\n"
+	"					for (int i=0;i<nReducedContacts;i++)\n"
+	"					{\n"
+	"					//this condition means: overwrite contact point, unless at index i==0 we have a valid 'mpr' contact\n"
+	"						if (i>0||(mprContactIndex<0))\n"
+	"						{\n"
+	"							c->m_worldPosB[i] = pointsIn[contactIdx[i]];\n"
+	"						}\n"
+	"					}\n"
+	"					GET_NPOINTS(*c) = nReducedContacts;\n"
+	"				}\n"
+	"				\n"
+	"			}//		if (numContactsOut>0)\n"
+	"		}//		if (hasSeparatingAxis[i])\n"
+	"	}//	if (i<numPairs)\n"
+	"}\n"
+	"__kernel void   clipCompoundsHullHullKernel( __global const int4* gpuCompoundPairs, \n"
+	"																					__global const b3RigidBodyData_t* rigidBodies, \n"
+	"																					__global const b3Collidable_t* collidables,\n"
+	"																					__global const b3ConvexPolyhedronData_t* convexShapes, \n"
+	"																					__global const float4* vertices,\n"
+	"																					__global const float4* uniqueEdges,\n"
+	"																					__global const b3GpuFace_t* faces,\n"
+	"																					__global const int* indices,\n"
+	"																					__global const b3GpuChildShape_t* gpuChildShapes,\n"
+	"																					__global const float4* gpuCompoundSepNormalsOut,\n"
+	"																					__global const int* gpuHasCompoundSepNormalsOut,\n"
+	"																					__global struct b3Contact4Data* restrict globalContactsOut,\n"
+	"																					counter32_t nGlobalContactsOut,\n"
+	"																					int numCompoundPairs, int maxContactCapacity)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	int pairIndex = i;\n"
+	"	\n"
+	"	float4 worldVertsB1[64];\n"
+	"	float4 worldVertsB2[64];\n"
+	"	int capacityWorldVerts = 64;	\n"
+	"	float4 localContactsOut[64];\n"
+	"	int localContactCapacity=64;\n"
+	"	\n"
+	"	float minDist = -1e30f;\n"
+	"	float maxDist = 0.02f;\n"
+	"	if (i<numCompoundPairs)\n"
+	"	{\n"
+	"		if (gpuHasCompoundSepNormalsOut[i])\n"
+	"		{\n"
+	"			int bodyIndexA = gpuCompoundPairs[i].x;\n"
+	"			int bodyIndexB = gpuCompoundPairs[i].y;\n"
+	"			\n"
+	"			int childShapeIndexA = gpuCompoundPairs[i].z;\n"
+	"			int childShapeIndexB = gpuCompoundPairs[i].w;\n"
+	"			\n"
+	"			int collidableIndexA = -1;\n"
+	"			int collidableIndexB = -1;\n"
+	"			\n"
+	"			float4 ornA = rigidBodies[bodyIndexA].m_quat;\n"
+	"			float4 posA = rigidBodies[bodyIndexA].m_pos;\n"
+	"			\n"
+	"			float4 ornB = rigidBodies[bodyIndexB].m_quat;\n"
+	"			float4 posB = rigidBodies[bodyIndexB].m_pos;\n"
+	"								\n"
+	"			if (childShapeIndexA >= 0)\n"
+	"			{\n"
+	"				collidableIndexA = gpuChildShapes[childShapeIndexA].m_shapeIndex;\n"
+	"				float4 childPosA = gpuChildShapes[childShapeIndexA].m_childPosition;\n"
+	"				float4 childOrnA = gpuChildShapes[childShapeIndexA].m_childOrientation;\n"
+	"				float4 newPosA = qtRotate(ornA,childPosA)+posA;\n"
+	"				float4 newOrnA = qtMul(ornA,childOrnA);\n"
+	"				posA = newPosA;\n"
+	"				ornA = newOrnA;\n"
+	"			} else\n"
+	"			{\n"
+	"				collidableIndexA = rigidBodies[bodyIndexA].m_collidableIdx;\n"
+	"			}\n"
+	"			\n"
+	"			if (childShapeIndexB>=0)\n"
+	"			{\n"
+	"				collidableIndexB = gpuChildShapes[childShapeIndexB].m_shapeIndex;\n"
+	"				float4 childPosB = gpuChildShapes[childShapeIndexB].m_childPosition;\n"
+	"				float4 childOrnB = gpuChildShapes[childShapeIndexB].m_childOrientation;\n"
+	"				float4 newPosB = transform(&childPosB,&posB,&ornB);\n"
+	"				float4 newOrnB = qtMul(ornB,childOrnB);\n"
+	"				posB = newPosB;\n"
+	"				ornB = newOrnB;\n"
+	"			} else\n"
+	"			{\n"
+	"				collidableIndexB = rigidBodies[bodyIndexB].m_collidableIdx;	\n"
+	"			}\n"
+	"			\n"
+	"			int shapeIndexA = collidables[collidableIndexA].m_shapeIndex;\n"
+	"			int shapeIndexB = collidables[collidableIndexB].m_shapeIndex;\n"
+	"		\n"
+	"			int numLocalContactsOut = clipHullAgainstHull(gpuCompoundSepNormalsOut[i],\n"
+	"														&convexShapes[shapeIndexA], &convexShapes[shapeIndexB],\n"
+	"														posA,ornA,\n"
+	"													  posB,ornB,\n"
+	"													  worldVertsB1,worldVertsB2,capacityWorldVerts,\n"
+	"														minDist, maxDist,\n"
+	"														vertices,faces,indices,\n"
+	"														localContactsOut,localContactCapacity);\n"
+	"												\n"
+	"		if (numLocalContactsOut>0)\n"
+	"		{\n"
+	"				float4 normal = -gpuCompoundSepNormalsOut[i];\n"
+	"				int nPoints = numLocalContactsOut;\n"
+	"				float4* pointsIn = localContactsOut;\n"
+	"				int contactIdx[4];// = {-1,-1,-1,-1};\n"
+	"				contactIdx[0] = -1;\n"
+	"				contactIdx[1] = -1;\n"
+	"				contactIdx[2] = -1;\n"
+	"				contactIdx[3] = -1;\n"
+	"		\n"
+	"				int nReducedContacts = extractManifoldSequential(pointsIn, nPoints, normal, contactIdx);\n"
+	"		\n"
+	"				int dstIdx;\n"
+	"				AppendInc( nGlobalContactsOut, dstIdx );\n"
+	"				if ((dstIdx+nReducedContacts) < maxContactCapacity)\n"
+	"				{\n"
+	"					__global struct b3Contact4Data* c = globalContactsOut+ dstIdx;\n"
+	"					c->m_worldNormalOnB = -normal;\n"
+	"					c->m_restituitionCoeffCmp = (0.f*0xffff);c->m_frictionCoeffCmp = (0.7f*0xffff);\n"
+	"					c->m_batchIdx = pairIndex;\n"
+	"					int bodyA = gpuCompoundPairs[pairIndex].x;\n"
+	"					int bodyB = gpuCompoundPairs[pairIndex].y;\n"
+	"					c->m_bodyAPtrAndSignBit = rigidBodies[bodyA].m_invMass==0?-bodyA:bodyA;\n"
+	"					c->m_bodyBPtrAndSignBit = rigidBodies[bodyB].m_invMass==0?-bodyB:bodyB;\n"
+	"					c->m_childIndexA = childShapeIndexA;\n"
+	"					c->m_childIndexB = childShapeIndexB;\n"
+	"					for (int i=0;i<nReducedContacts;i++)\n"
+	"					{\n"
+	"						c->m_worldPosB[i] = pointsIn[contactIdx[i]];\n"
+	"					}\n"
+	"					GET_NPOINTS(*c) = nReducedContacts;\n"
+	"				}\n"
+	"				\n"
+	"			}//		if (numContactsOut>0)\n"
+	"		}//		if (gpuHasCompoundSepNormalsOut[i])\n"
+	"	}//	if (i<numCompoundPairs)\n"
+	"}\n"
+	"__kernel void   sphereSphereCollisionKernel( __global const int4* pairs, \n"
+	"																					__global const b3RigidBodyData_t* rigidBodies, \n"
+	"																					__global const b3Collidable_t* collidables,\n"
+	"																					__global const float4* separatingNormals,\n"
+	"																					__global const int* hasSeparatingAxis,\n"
+	"																					__global struct b3Contact4Data* restrict globalContactsOut,\n"
+	"																					counter32_t nGlobalContactsOut,\n"
+	"																					int contactCapacity,\n"
+	"																					int numPairs)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	int pairIndex = i;\n"
+	"	\n"
+	"	if (i<numPairs)\n"
+	"	{\n"
+	"		int bodyIndexA = pairs[i].x;\n"
+	"		int bodyIndexB = pairs[i].y;\n"
+	"			\n"
+	"		int collidableIndexA = rigidBodies[bodyIndexA].m_collidableIdx;\n"
+	"		int collidableIndexB = rigidBodies[bodyIndexB].m_collidableIdx;\n"
+	"		if (collidables[collidableIndexA].m_shapeType == SHAPE_SPHERE &&\n"
+	"			collidables[collidableIndexB].m_shapeType == SHAPE_SPHERE)\n"
+	"		{\n"
+	"			//sphere-sphere\n"
+	"			float radiusA = collidables[collidableIndexA].m_radius;\n"
+	"			float radiusB = collidables[collidableIndexB].m_radius;\n"
+	"			float4 posA = rigidBodies[bodyIndexA].m_pos;\n"
+	"			float4 posB = rigidBodies[bodyIndexB].m_pos;\n"
+	"			float4 diff = posA-posB;\n"
+	"			float len = length(diff);\n"
+	"			\n"
+	"			///iff distance positive, don't generate a new contact\n"
+	"			if ( len <= (radiusA+radiusB))\n"
+	"			{\n"
+	"				///distance (negative means penetration)\n"
+	"				float dist = len - (radiusA+radiusB);\n"
+	"				float4 normalOnSurfaceB = make_float4(1.f,0.f,0.f,0.f);\n"
+	"				if (len > 0.00001)\n"
+	"				{\n"
+	"					normalOnSurfaceB = diff / len;\n"
+	"				}\n"
+	"				float4 contactPosB = posB + normalOnSurfaceB*radiusB;\n"
+	"				contactPosB.w = dist;\n"
+	"								\n"
+	"				int dstIdx;\n"
+	"				AppendInc( nGlobalContactsOut, dstIdx );\n"
+	"				if (dstIdx < contactCapacity)\n"
+	"				{\n"
+	"					__global struct b3Contact4Data* c = &globalContactsOut[dstIdx];\n"
+	"					c->m_worldNormalOnB = -normalOnSurfaceB;\n"
+	"					c->m_restituitionCoeffCmp = (0.f*0xffff);c->m_frictionCoeffCmp = (0.7f*0xffff);\n"
+	"					c->m_batchIdx = pairIndex;\n"
+	"					int bodyA = pairs[pairIndex].x;\n"
+	"					int bodyB = pairs[pairIndex].y;\n"
+	"					c->m_bodyAPtrAndSignBit = rigidBodies[bodyA].m_invMass==0?-bodyA:bodyA;\n"
+	"					c->m_bodyBPtrAndSignBit = rigidBodies[bodyB].m_invMass==0?-bodyB:bodyB;\n"
+	"					c->m_worldPosB[0] = contactPosB;\n"
+	"					c->m_childIndexA = -1;\n"
+	"					c->m_childIndexB = -1;\n"
+	"					GET_NPOINTS(*c) = 1;\n"
+	"				}//if (dstIdx < numPairs)\n"
+	"			}//if ( len <= (radiusA+radiusB))\n"
+	"		}//SHAPE_SPHERE SHAPE_SPHERE\n"
+	"	}//if (i<numPairs)\n"
+	"}				\n"
+	"__kernel void   clipHullHullConcaveConvexKernel( __global int4* concavePairsIn,\n"
+	"																					__global const b3RigidBodyData_t* rigidBodies, \n"
+	"																					__global const b3Collidable_t* collidables,\n"
+	"																					__global const b3ConvexPolyhedronData_t* convexShapes, \n"
+	"																					__global const float4* vertices,\n"
+	"																					__global const float4* uniqueEdges,\n"
+	"																					__global const b3GpuFace_t* faces,\n"
+	"																					__global const int* indices,\n"
+	"																					__global const b3GpuChildShape_t* gpuChildShapes,\n"
+	"																					__global const float4* separatingNormals,\n"
+	"																					__global struct b3Contact4Data* restrict globalContactsOut,\n"
+	"																					counter32_t nGlobalContactsOut,\n"
+	"																					int contactCapacity,\n"
+	"																					int numConcavePairs)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	int pairIndex = i;\n"
+	"	\n"
+	"	float4 worldVertsB1[64];\n"
+	"	float4 worldVertsB2[64];\n"
+	"	int capacityWorldVerts = 64;	\n"
+	"	float4 localContactsOut[64];\n"
+	"	int localContactCapacity=64;\n"
+	"	\n"
+	"	float minDist = -1e30f;\n"
+	"	float maxDist = 0.02f;\n"
+	"	if (i<numConcavePairs)\n"
+	"	{\n"
+	"		//negative value means that the pair is invalid\n"
+	"		if (concavePairsIn[i].w<0)\n"
+	"			return;\n"
+	"		int bodyIndexA = concavePairsIn[i].x;\n"
+	"		int bodyIndexB = concavePairsIn[i].y;\n"
+	"		int f = concavePairsIn[i].z;\n"
+	"		int childShapeIndexA = f;\n"
+	"		\n"
+	"		int collidableIndexA = rigidBodies[bodyIndexA].m_collidableIdx;\n"
+	"		int collidableIndexB = rigidBodies[bodyIndexB].m_collidableIdx;\n"
+	"		\n"
+	"		int shapeIndexA = collidables[collidableIndexA].m_shapeIndex;\n"
+	"		int shapeIndexB = collidables[collidableIndexB].m_shapeIndex;\n"
+	"		\n"
+	"		///////////////////////////////////////////////////////////////\n"
+	"		\n"
+	"	\n"
+	"		bool overlap = false;\n"
+	"		\n"
+	"		b3ConvexPolyhedronData_t convexPolyhedronA;\n"
+	"	//add 3 vertices of the triangle\n"
+	"		convexPolyhedronA.m_numVertices = 3;\n"
+	"		convexPolyhedronA.m_vertexOffset = 0;\n"
+	"		float4	localCenter = make_float4(0.f,0.f,0.f,0.f);\n"
+	"		b3GpuFace_t face = faces[convexShapes[shapeIndexA].m_faceOffset+f];\n"
+	"		\n"
+	"		float4 verticesA[3];\n"
+	"		for (int i=0;i<3;i++)\n"
+	"		{\n"
+	"			int index = indices[face.m_indexOffset+i];\n"
+	"			float4 vert = vertices[convexShapes[shapeIndexA].m_vertexOffset+index];\n"
+	"			verticesA[i] = vert;\n"
+	"			localCenter += vert;\n"
+	"		}\n"
+	"		float dmin = FLT_MAX;\n"
+	"		int localCC=0;\n"
+	"		//a triangle has 3 unique edges\n"
+	"		convexPolyhedronA.m_numUniqueEdges = 3;\n"
+	"		convexPolyhedronA.m_uniqueEdgesOffset = 0;\n"
+	"		float4 uniqueEdgesA[3];\n"
+	"		\n"
+	"		uniqueEdgesA[0] = (verticesA[1]-verticesA[0]);\n"
+	"		uniqueEdgesA[1] = (verticesA[2]-verticesA[1]);\n"
+	"		uniqueEdgesA[2] = (verticesA[0]-verticesA[2]);\n"
+	"		convexPolyhedronA.m_faceOffset = 0;\n"
+	"                                  \n"
+	"		float4 normal = make_float4(face.m_plane.x,face.m_plane.y,face.m_plane.z,0.f);\n"
+	"                             \n"
+	"		b3GpuFace_t facesA[TRIANGLE_NUM_CONVEX_FACES];\n"
+	"		int indicesA[3+3+2+2+2];\n"
+	"		int curUsedIndices=0;\n"
+	"		int fidx=0;\n"
+	"		//front size of triangle\n"
+	"		{\n"
+	"			facesA[fidx].m_indexOffset=curUsedIndices;\n"
+	"			indicesA[0] = 0;\n"
+	"			indicesA[1] = 1;\n"
+	"			indicesA[2] = 2;\n"
+	"			curUsedIndices+=3;\n"
+	"			float c = face.m_plane.w;\n"
+	"			facesA[fidx].m_plane.x = normal.x;\n"
+	"			facesA[fidx].m_plane.y = normal.y;\n"
+	"			facesA[fidx].m_plane.z = normal.z;\n"
+	"			facesA[fidx].m_plane.w = c;\n"
+	"			facesA[fidx].m_numIndices=3;\n"
+	"		}\n"
+	"		fidx++;\n"
+	"		//back size of triangle\n"
+	"		{\n"
+	"			facesA[fidx].m_indexOffset=curUsedIndices;\n"
+	"			indicesA[3]=2;\n"
+	"			indicesA[4]=1;\n"
+	"			indicesA[5]=0;\n"
+	"			curUsedIndices+=3;\n"
+	"			float c = dot3F4(normal,verticesA[0]);\n"
+	"			float c1 = -face.m_plane.w;\n"
+	"			facesA[fidx].m_plane.x = -normal.x;\n"
+	"			facesA[fidx].m_plane.y = -normal.y;\n"
+	"			facesA[fidx].m_plane.z = -normal.z;\n"
+	"			facesA[fidx].m_plane.w = c;\n"
+	"			facesA[fidx].m_numIndices=3;\n"
+	"		}\n"
+	"		fidx++;\n"
+	"		bool addEdgePlanes = true;\n"
+	"		if (addEdgePlanes)\n"
+	"		{\n"
+	"			int numVertices=3;\n"
+	"			int prevVertex = numVertices-1;\n"
+	"			for (int i=0;i<numVertices;i++)\n"
+	"			{\n"
+	"				float4 v0 = verticesA[i];\n"
+	"				float4 v1 = verticesA[prevVertex];\n"
+	"                                            \n"
+	"				float4 edgeNormal = normalize(cross(normal,v1-v0));\n"
+	"				float c = -dot3F4(edgeNormal,v0);\n"
+	"				facesA[fidx].m_numIndices = 2;\n"
+	"				facesA[fidx].m_indexOffset=curUsedIndices;\n"
+	"				indicesA[curUsedIndices++]=i;\n"
+	"				indicesA[curUsedIndices++]=prevVertex;\n"
+	"                                            \n"
+	"				facesA[fidx].m_plane.x = edgeNormal.x;\n"
+	"				facesA[fidx].m_plane.y = edgeNormal.y;\n"
+	"				facesA[fidx].m_plane.z = edgeNormal.z;\n"
+	"				facesA[fidx].m_plane.w = c;\n"
+	"				fidx++;\n"
+	"				prevVertex = i;\n"
+	"			}\n"
+	"		}\n"
+	"		convexPolyhedronA.m_numFaces = TRIANGLE_NUM_CONVEX_FACES;\n"
+	"		convexPolyhedronA.m_localCenter = localCenter*(1.f/3.f);\n"
+	"		float4 posA = rigidBodies[bodyIndexA].m_pos;\n"
+	"		posA.w = 0.f;\n"
+	"		float4 posB = rigidBodies[bodyIndexB].m_pos;\n"
+	"		posB.w = 0.f;\n"
+	"		float4 ornA = rigidBodies[bodyIndexA].m_quat;\n"
+	"		float4 ornB =rigidBodies[bodyIndexB].m_quat;\n"
+	"		float4 sepAxis = separatingNormals[i];\n"
+	"		\n"
+	"		int shapeTypeB = collidables[collidableIndexB].m_shapeType;\n"
+	"		int childShapeIndexB =-1;\n"
+	"		if (shapeTypeB==SHAPE_COMPOUND_OF_CONVEX_HULLS)\n"
+	"		{\n"
+	"			///////////////////\n"
+	"			///compound shape support\n"
+	"			\n"
+	"			childShapeIndexB = concavePairsIn[pairIndex].w;\n"
+	"			int childColIndexB = gpuChildShapes[childShapeIndexB].m_shapeIndex;\n"
+	"			shapeIndexB = collidables[childColIndexB].m_shapeIndex;\n"
+	"			float4 childPosB = gpuChildShapes[childShapeIndexB].m_childPosition;\n"
+	"			float4 childOrnB = gpuChildShapes[childShapeIndexB].m_childOrientation;\n"
+	"			float4 newPosB = transform(&childPosB,&posB,&ornB);\n"
+	"			float4 newOrnB = qtMul(ornB,childOrnB);\n"
+	"			posB = newPosB;\n"
+	"			ornB = newOrnB;\n"
+	"			\n"
+	"		}\n"
+	"		\n"
+	"		////////////////////////////////////////\n"
+	"		\n"
+	"		\n"
+	"		\n"
+	"		int numLocalContactsOut = clipHullAgainstHullLocalA(sepAxis,\n"
+	"														&convexPolyhedronA, &convexShapes[shapeIndexB],\n"
+	"														posA,ornA,\n"
+	"													  posB,ornB,\n"
+	"													  worldVertsB1,worldVertsB2,capacityWorldVerts,\n"
+	"														minDist, maxDist,\n"
+	"														&verticesA,&facesA,&indicesA,\n"
+	"														vertices,faces,indices,\n"
+	"														localContactsOut,localContactCapacity);\n"
+	"												\n"
+	"		if (numLocalContactsOut>0)\n"
+	"		{\n"
+	"			float4 normal = -separatingNormals[i];\n"
+	"			int nPoints = numLocalContactsOut;\n"
+	"			float4* pointsIn = localContactsOut;\n"
+	"			int contactIdx[4];// = {-1,-1,-1,-1};\n"
+	"			contactIdx[0] = -1;\n"
+	"			contactIdx[1] = -1;\n"
+	"			contactIdx[2] = -1;\n"
+	"			contactIdx[3] = -1;\n"
+	"	\n"
+	"			int nReducedContacts = extractManifoldSequential(pointsIn, nPoints, normal, contactIdx);\n"
+	"	\n"
+	"			int dstIdx;\n"
+	"			AppendInc( nGlobalContactsOut, dstIdx );\n"
+	"			if (dstIdx<contactCapacity)\n"
+	"			{\n"
+	"				__global struct b3Contact4Data* c = globalContactsOut+ dstIdx;\n"
+	"				c->m_worldNormalOnB = -normal;\n"
+	"				c->m_restituitionCoeffCmp = (0.f*0xffff);c->m_frictionCoeffCmp = (0.7f*0xffff);\n"
+	"				c->m_batchIdx = pairIndex;\n"
+	"				int bodyA = concavePairsIn[pairIndex].x;\n"
+	"				int bodyB = concavePairsIn[pairIndex].y;\n"
+	"				c->m_bodyAPtrAndSignBit = rigidBodies[bodyA].m_invMass==0?-bodyA:bodyA;\n"
+	"				c->m_bodyBPtrAndSignBit = rigidBodies[bodyB].m_invMass==0?-bodyB:bodyB;\n"
+	"				c->m_childIndexA = childShapeIndexA;\n"
+	"				c->m_childIndexB = childShapeIndexB;\n"
+	"				for (int i=0;i<nReducedContacts;i++)\n"
+	"				{\n"
+	"					c->m_worldPosB[i] = pointsIn[contactIdx[i]];\n"
+	"				}\n"
+	"				GET_NPOINTS(*c) = nReducedContacts;\n"
+	"			}\n"
+	"				\n"
+	"		}//		if (numContactsOut>0)\n"
+	"	}//	if (i<numPairs)\n"
+	"}\n"
+	"int	findClippingFaces(const float4 separatingNormal,\n"
+	"                      __global const b3ConvexPolyhedronData_t* hullA, __global const b3ConvexPolyhedronData_t* hullB,\n"
+	"                      const float4 posA, const Quaternion ornA,const float4 posB, const Quaternion ornB,\n"
+	"                       __global float4* worldVertsA1,\n"
+	"                      __global float4* worldNormalsA1,\n"
+	"                      __global float4* worldVertsB1,\n"
+	"                      int capacityWorldVerts,\n"
+	"                      const float minDist, float maxDist,\n"
+	"                      __global const float4* vertices,\n"
+	"                      __global const b3GpuFace_t* faces,\n"
+	"                      __global const int* indices,\n"
+	"                      __global int4* clippingFaces, int pairIndex)\n"
+	"{\n"
+	"	int numContactsOut = 0;\n"
+	"	int numWorldVertsB1= 0;\n"
+	"    \n"
+	"    \n"
+	"	int closestFaceB=-1;\n"
+	"	float dmax = -FLT_MAX;\n"
+	"    \n"
+	"	{\n"
+	"		for(int face=0;face<hullB->m_numFaces;face++)\n"
+	"		{\n"
+	"			const float4 Normal = make_float4(faces[hullB->m_faceOffset+face].m_plane.x,\n"
+	"                                              faces[hullB->m_faceOffset+face].m_plane.y, faces[hullB->m_faceOffset+face].m_plane.z,0.f);\n"
+	"			const float4 WorldNormal = qtRotate(ornB, Normal);\n"
+	"			float d = dot3F4(WorldNormal,separatingNormal);\n"
+	"			if (d > dmax)\n"
+	"			{\n"
+	"				dmax = d;\n"
+	"				closestFaceB = face;\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"    \n"
+	"	{\n"
+	"		const b3GpuFace_t polyB = faces[hullB->m_faceOffset+closestFaceB];\n"
+	"		const int numVertices = polyB.m_numIndices;\n"
+	"		for(int e0=0;e0<numVertices;e0++)\n"
+	"		{\n"
+	"			const float4 b = vertices[hullB->m_vertexOffset+indices[polyB.m_indexOffset+e0]];\n"
+	"			worldVertsB1[pairIndex*capacityWorldVerts+numWorldVertsB1++] = transform(&b,&posB,&ornB);\n"
+	"		}\n"
+	"	}\n"
+	"    \n"
+	"    int closestFaceA=-1;\n"
+	"	{\n"
+	"		float dmin = FLT_MAX;\n"
+	"		for(int face=0;face<hullA->m_numFaces;face++)\n"
+	"		{\n"
+	"			const float4 Normal = make_float4(\n"
+	"                                              faces[hullA->m_faceOffset+face].m_plane.x,\n"
+	"                                              faces[hullA->m_faceOffset+face].m_plane.y,\n"
+	"                                              faces[hullA->m_faceOffset+face].m_plane.z,\n"
+	"                                              0.f);\n"
+	"			const float4 faceANormalWS = qtRotate(ornA,Normal);\n"
+	"            \n"
+	"			float d = dot3F4(faceANormalWS,separatingNormal);\n"
+	"			if (d < dmin)\n"
+	"			{\n"
+	"				dmin = d;\n"
+	"				closestFaceA = face;\n"
+	"                worldNormalsA1[pairIndex] = faceANormalWS;\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"    \n"
+	"    int numVerticesA = faces[hullA->m_faceOffset+closestFaceA].m_numIndices;\n"
+	"	for(int e0=0;e0<numVerticesA;e0++)\n"
+	"	{\n"
+	"        const float4 a = vertices[hullA->m_vertexOffset+indices[faces[hullA->m_faceOffset+closestFaceA].m_indexOffset+e0]];\n"
+	"        worldVertsA1[pairIndex*capacityWorldVerts+e0] = transform(&a, &posA,&ornA);\n"
+	"    }\n"
+	"    \n"
+	"    clippingFaces[pairIndex].x = closestFaceA;\n"
+	"    clippingFaces[pairIndex].y = closestFaceB;\n"
+	"    clippingFaces[pairIndex].z = numVerticesA;\n"
+	"    clippingFaces[pairIndex].w = numWorldVertsB1;\n"
+	"    \n"
+	"    \n"
+	"	return numContactsOut;\n"
+	"}\n"
+	"int clipFaces(__global float4* worldVertsA1,\n"
+	"              __global float4* worldNormalsA1,\n"
+	"              __global float4* worldVertsB1,\n"
+	"              __global float4* worldVertsB2, \n"
+	"              int capacityWorldVertsB2,\n"
+	"              const float minDist, float maxDist,\n"
+	"              __global int4* clippingFaces,\n"
+	"              int pairIndex)\n"
+	"{\n"
+	"	int numContactsOut = 0;\n"
+	"    \n"
+	"    int closestFaceA = clippingFaces[pairIndex].x;\n"
+	"    int closestFaceB = clippingFaces[pairIndex].y;\n"
+	"	int numVertsInA = clippingFaces[pairIndex].z;\n"
+	"	int numVertsInB = clippingFaces[pairIndex].w;\n"
+	"    \n"
+	"	int numVertsOut = 0;\n"
+	"    \n"
+	"	if (closestFaceA<0)\n"
+	"		return numContactsOut;\n"
+	"    \n"
+	"    __global float4* pVtxIn = &worldVertsB1[pairIndex*capacityWorldVertsB2];\n"
+	"    __global float4* pVtxOut = &worldVertsB2[pairIndex*capacityWorldVertsB2];\n"
+	"    \n"
+	"    \n"
+	"	\n"
+	"	// clip polygon to back of planes of all faces of hull A that are adjacent to witness face\n"
+	"    \n"
+	"	for(int e0=0;e0<numVertsInA;e0++)\n"
+	"	{\n"
+	"		const float4 aw = worldVertsA1[pairIndex*capacityWorldVertsB2+e0];\n"
+	"		const float4 bw = worldVertsA1[pairIndex*capacityWorldVertsB2+((e0+1)%numVertsInA)];\n"
+	"		const float4 WorldEdge0 = aw - bw;\n"
+	"		float4 worldPlaneAnormal1 = worldNormalsA1[pairIndex];\n"
+	"		float4 planeNormalWS1 = -cross3(WorldEdge0,worldPlaneAnormal1);\n"
+	"		float4 worldA1 = aw;\n"
+	"		float planeEqWS1 = -dot3F4(worldA1,planeNormalWS1);\n"
+	"		float4 planeNormalWS = planeNormalWS1;\n"
+	"		float planeEqWS=planeEqWS1;\n"
+	"		numVertsOut = clipFaceGlobal(pVtxIn, numVertsInB, planeNormalWS,planeEqWS, pVtxOut);\n"
+	"		__global float4* tmp = pVtxOut;\n"
+	"		pVtxOut = pVtxIn;\n"
+	"		pVtxIn = tmp;\n"
+	"		numVertsInB = numVertsOut;\n"
+	"		numVertsOut = 0;\n"
+	"	}\n"
+	"    \n"
+	"    //float4 planeNormalWS = worldNormalsA1[pairIndex];\n"
+	"    //float planeEqWS=-dot3F4(planeNormalWS,worldVertsA1[pairIndex*capacityWorldVertsB2]);\n"
+	"    \n"
+	"    /*for (int i=0;i<numVertsInB;i++)\n"
+	"    {\n"
+	"        pVtxOut[i] = pVtxIn[i];\n"
+	"    }*/\n"
+	"    \n"
+	"    \n"
+	"    \n"
+	"    \n"
+	"    //numVertsInB=0;\n"
+	"	\n"
+	"    float4 planeNormalWS = worldNormalsA1[pairIndex];\n"
+	"    float planeEqWS=-dot3F4(planeNormalWS,worldVertsA1[pairIndex*capacityWorldVertsB2]);\n"
+	"    for (int i=0;i<numVertsInB;i++)\n"
+	"    {\n"
+	"        float depth = dot3F4(planeNormalWS,pVtxIn[i])+planeEqWS;\n"
+	"        if (depth <=minDist)\n"
+	"        {\n"
+	"            depth = minDist;\n"
+	"        }\n"
+	"        \n"
+	"        if (depth <=maxDist)\n"
+	"        {\n"
+	"            float4 pointInWorld = pVtxIn[i];\n"
+	"            pVtxOut[numContactsOut++] = make_float4(pointInWorld.x,pointInWorld.y,pointInWorld.z,depth);\n"
+	"        }\n"
+	"    }\n"
+	"   \n"
+	"    clippingFaces[pairIndex].w =numContactsOut;\n"
+	"   \n"
+	"    \n"
+	"	return numContactsOut;\n"
+	"}\n"
+	"__kernel void   findClippingFacesKernel(  __global const int4* pairs,\n"
+	"                                        __global const b3RigidBodyData_t* rigidBodies,\n"
+	"                                        __global const b3Collidable_t* collidables,\n"
+	"                                        __global const b3ConvexPolyhedronData_t* convexShapes,\n"
+	"                                        __global const float4* vertices,\n"
+	"                                        __global const float4* uniqueEdges,\n"
+	"                                        __global const b3GpuFace_t* faces,\n"
+	"                                        __global const int* indices,\n"
+	"                                        __global const float4* separatingNormals,\n"
+	"                                        __global const int* hasSeparatingAxis,\n"
+	"                                        __global int4* clippingFacesOut,\n"
+	"                                        __global float4* worldVertsA1,\n"
+	"                                        __global float4* worldNormalsA1,\n"
+	"                                        __global float4* worldVertsB1,\n"
+	"                                        int capacityWorldVerts,\n"
+	"                                        int numPairs\n"
+	"                                        )\n"
+	"{\n"
+	"    \n"
+	"	int i = get_global_id(0);\n"
+	"	int pairIndex = i;\n"
+	"    \n"
+	"	\n"
+	"	float minDist = -1e30f;\n"
+	"	float maxDist = 0.02f;\n"
+	"    \n"
+	"	if (i<numPairs)\n"
+	"	{\n"
+	"        \n"
+	"		if (hasSeparatingAxis[i])\n"
+	"		{\n"
+	"            \n"
+	"			int bodyIndexA = pairs[i].x;\n"
+	"			int bodyIndexB = pairs[i].y;\n"
+	"			\n"
+	"			int collidableIndexA = rigidBodies[bodyIndexA].m_collidableIdx;\n"
+	"			int collidableIndexB = rigidBodies[bodyIndexB].m_collidableIdx;\n"
+	"			\n"
+	"			int shapeIndexA = collidables[collidableIndexA].m_shapeIndex;\n"
+	"			int shapeIndexB = collidables[collidableIndexB].m_shapeIndex;\n"
+	"			\n"
+	"            \n"
+	"            \n"
+	"			int numLocalContactsOut = findClippingFaces(separatingNormals[i],\n"
+	"                                                        &convexShapes[shapeIndexA], &convexShapes[shapeIndexB],\n"
+	"                                                        rigidBodies[bodyIndexA].m_pos,rigidBodies[bodyIndexA].m_quat,\n"
+	"                                                        rigidBodies[bodyIndexB].m_pos,rigidBodies[bodyIndexB].m_quat,\n"
+	"                                                        worldVertsA1,\n"
+	"                                                        worldNormalsA1,\n"
+	"                                                        worldVertsB1,capacityWorldVerts,\n"
+	"                                                        minDist, maxDist,\n"
+	"                                                        vertices,faces,indices,\n"
+	"                                                        clippingFacesOut,i);\n"
+	"            \n"
+	"            \n"
+	"		}//		if (hasSeparatingAxis[i])\n"
+	"	}//	if (i<numPairs)\n"
+	"    \n"
+	"}\n"
+	"__kernel void   clipFacesAndFindContactsKernel(    __global const float4* separatingNormals,\n"
+	"                                                   __global const int* hasSeparatingAxis,\n"
+	"                                                   __global int4* clippingFacesOut,\n"
+	"                                                   __global float4* worldVertsA1,\n"
+	"                                                   __global float4* worldNormalsA1,\n"
+	"                                                   __global float4* worldVertsB1,\n"
+	"                                                   __global float4* worldVertsB2,\n"
+	"                                                    int vertexFaceCapacity,\n"
+	"                                                   int numPairs,\n"
+	"					                                        int debugMode\n"
+	"                                                   )\n"
+	"{\n"
+	"    int i = get_global_id(0);\n"
+	"	int pairIndex = i;\n"
+	"	\n"
+	"    \n"
+	"	float minDist = -1e30f;\n"
+	"	float maxDist = 0.02f;\n"
+	"    \n"
+	"	if (i<numPairs)\n"
+	"	{\n"
+	"        \n"
+	"		if (hasSeparatingAxis[i])\n"
+	"		{\n"
+	"            \n"
+	"//			int bodyIndexA = pairs[i].x;\n"
+	"	//		int bodyIndexB = pairs[i].y;\n"
+	"		    \n"
+	"            int numLocalContactsOut = 0;\n"
+	"            int capacityWorldVertsB2 = vertexFaceCapacity;\n"
+	"            \n"
+	"            __global float4* pVtxIn = &worldVertsB1[pairIndex*capacityWorldVertsB2];\n"
+	"            __global float4* pVtxOut = &worldVertsB2[pairIndex*capacityWorldVertsB2];\n"
+	"            \n"
+	"            {\n"
+	"                __global int4* clippingFaces = clippingFacesOut;\n"
+	"            \n"
+	"                \n"
+	"                int closestFaceA = clippingFaces[pairIndex].x;\n"
+	"                int closestFaceB = clippingFaces[pairIndex].y;\n"
+	"                int numVertsInA = clippingFaces[pairIndex].z;\n"
+	"                int numVertsInB = clippingFaces[pairIndex].w;\n"
+	"                \n"
+	"                int numVertsOut = 0;\n"
+	"                \n"
+	"                if (closestFaceA>=0)\n"
+	"                {\n"
+	"                    \n"
+	"                    \n"
+	"                    \n"
+	"                    // clip polygon to back of planes of all faces of hull A that are adjacent to witness face\n"
+	"                    \n"
+	"                    for(int e0=0;e0<numVertsInA;e0++)\n"
+	"                    {\n"
+	"                        const float4 aw = worldVertsA1[pairIndex*capacityWorldVertsB2+e0];\n"
+	"                        const float4 bw = worldVertsA1[pairIndex*capacityWorldVertsB2+((e0+1)%numVertsInA)];\n"
+	"                        const float4 WorldEdge0 = aw - bw;\n"
+	"                        float4 worldPlaneAnormal1 = worldNormalsA1[pairIndex];\n"
+	"                        float4 planeNormalWS1 = -cross3(WorldEdge0,worldPlaneAnormal1);\n"
+	"                        float4 worldA1 = aw;\n"
+	"                        float planeEqWS1 = -dot3F4(worldA1,planeNormalWS1);\n"
+	"                        float4 planeNormalWS = planeNormalWS1;\n"
+	"                        float planeEqWS=planeEqWS1;\n"
+	"                        numVertsOut = clipFaceGlobal(pVtxIn, numVertsInB, planeNormalWS,planeEqWS, pVtxOut);\n"
+	"                        __global float4* tmp = pVtxOut;\n"
+	"                        pVtxOut = pVtxIn;\n"
+	"                        pVtxIn = tmp;\n"
+	"                        numVertsInB = numVertsOut;\n"
+	"                        numVertsOut = 0;\n"
+	"                    }\n"
+	"                    \n"
+	"                    float4 planeNormalWS = worldNormalsA1[pairIndex];\n"
+	"                    float planeEqWS=-dot3F4(planeNormalWS,worldVertsA1[pairIndex*capacityWorldVertsB2]);\n"
+	"                    \n"
+	"                    for (int i=0;i<numVertsInB;i++)\n"
+	"                    {\n"
+	"                        float depth = dot3F4(planeNormalWS,pVtxIn[i])+planeEqWS;\n"
+	"                        if (depth <=minDist)\n"
+	"                        {\n"
+	"                            depth = minDist;\n"
+	"                        }\n"
+	"                        \n"
+	"                        if (depth <=maxDist)\n"
+	"                        {\n"
+	"                            float4 pointInWorld = pVtxIn[i];\n"
+	"                            pVtxOut[numLocalContactsOut++] = make_float4(pointInWorld.x,pointInWorld.y,pointInWorld.z,depth);\n"
+	"                        }\n"
+	"                    }\n"
+	"                    \n"
+	"                }\n"
+	"                clippingFaces[pairIndex].w =numLocalContactsOut;\n"
+	"                \n"
+	"            }\n"
+	"            \n"
+	"            for (int i=0;i<numLocalContactsOut;i++)\n"
+	"                pVtxIn[i] = pVtxOut[i];\n"
+	"                \n"
+	"		}//		if (hasSeparatingAxis[i])\n"
+	"	}//	if (i<numPairs)\n"
+	"    \n"
+	"}\n"
+	"__kernel void   newContactReductionKernel( __global int4* pairs,\n"
+	"                                                   __global const b3RigidBodyData_t* rigidBodies,\n"
+	"                                                   __global const float4* separatingNormals,\n"
+	"                                                   __global const int* hasSeparatingAxis,\n"
+	"                                                   __global struct b3Contact4Data* globalContactsOut,\n"
+	"                                                   __global int4* clippingFaces,\n"
+	"                                                   __global float4* worldVertsB2,\n"
+	"                                                   volatile __global int* nGlobalContactsOut,\n"
+	"                                                   int vertexFaceCapacity,\n"
+	"												   int contactCapacity,\n"
+	"                                                   int numPairs\n"
+	"                                                   )\n"
+	"{\n"
+	"    int i = get_global_id(0);\n"
+	"	int pairIndex = i;\n"
+	"	\n"
+	"    int4 contactIdx;\n"
+	"    contactIdx=make_int4(0,1,2,3);\n"
+	"    \n"
+	"	if (i<numPairs)\n"
+	"	{\n"
+	"        \n"
+	"		if (hasSeparatingAxis[i])\n"
+	"		{\n"
+	"            \n"
+	"			\n"
+	"            \n"
+	"            \n"
+	"			int nPoints = clippingFaces[pairIndex].w;\n"
+	"           \n"
+	"            if (nPoints>0)\n"
+	"            {\n"
+	"                 __global float4* pointsIn = &worldVertsB2[pairIndex*vertexFaceCapacity];\n"
+	"                float4 normal = -separatingNormals[i];\n"
+	"                \n"
+	"                int nReducedContacts = extractManifoldSequentialGlobal(pointsIn, nPoints, normal, &contactIdx);\n"
+	"            \n"
+	"				int mprContactIndex = pairs[pairIndex].z;\n"
+	"                int dstIdx = mprContactIndex;\n"
+	"				if (dstIdx<0)\n"
+	"				{\n"
+	"	                AppendInc( nGlobalContactsOut, dstIdx );\n"
+	"				}\n"
+	"//#if 0\n"
+	"                \n"
+	"				if (dstIdx < contactCapacity)\n"
+	"				{\n"
+	"					__global struct b3Contact4Data* c = &globalContactsOut[dstIdx];\n"
+	"					c->m_worldNormalOnB = -normal;\n"
+	"					c->m_restituitionCoeffCmp = (0.f*0xffff);c->m_frictionCoeffCmp = (0.7f*0xffff);\n"
+	"					c->m_batchIdx = pairIndex;\n"
+	"					int bodyA = pairs[pairIndex].x;\n"
+	"					int bodyB = pairs[pairIndex].y;\n"
+	"					pairs[pairIndex].w = dstIdx;\n"
+	"					c->m_bodyAPtrAndSignBit = rigidBodies[bodyA].m_invMass==0?-bodyA:bodyA;\n"
+	"					c->m_bodyBPtrAndSignBit = rigidBodies[bodyB].m_invMass==0?-bodyB:bodyB;\n"
+	"                    c->m_childIndexA =-1;\n"
+	"					c->m_childIndexB =-1;\n"
+	"                    switch (nReducedContacts)\n"
+	"                    {\n"
+	"                        case 4:\n"
+	"                            c->m_worldPosB[3] = pointsIn[contactIdx.w];\n"
+	"                        case 3:\n"
+	"                            c->m_worldPosB[2] = pointsIn[contactIdx.z];\n"
+	"                        case 2:\n"
+	"                            c->m_worldPosB[1] = pointsIn[contactIdx.y];\n"
+	"                        case 1:\n"
+	"							if (mprContactIndex<0)//test\n"
+	"	                            c->m_worldPosB[0] = pointsIn[contactIdx.x];\n"
+	"                        default:\n"
+	"                        {\n"
+	"                        }\n"
+	"                    };\n"
+	"                    \n"
+	"					GET_NPOINTS(*c) = nReducedContacts;\n"
+	"                    \n"
+	"                 }\n"
+	"                 \n"
+	"                \n"
+	"//#endif\n"
+	"				\n"
+	"			}//		if (numContactsOut>0)\n"
+	"		}//		if (hasSeparatingAxis[i])\n"
+	"	}//	if (i<numPairs)\n"
+	"    \n"
+	"    \n"
+	"}\n";
diff --git a/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/kernels/satConcaveKernels.h b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/kernels/satConcaveKernels.h
new file mode 100644
index 00000000..a60702ca
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/kernels/satConcaveKernels.h
@@ -0,0 +1,1456 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* satConcaveKernelsCL =
+	"//keep this enum in sync with the CPU version (in btCollidable.h)\n"
+	"//written by Erwin Coumans\n"
+	"#define SHAPE_CONVEX_HULL 3\n"
+	"#define SHAPE_CONCAVE_TRIMESH 5\n"
+	"#define TRIANGLE_NUM_CONVEX_FACES 5\n"
+	"#define SHAPE_COMPOUND_OF_CONVEX_HULLS 6\n"
+	"#define B3_MAX_STACK_DEPTH 256\n"
+	"typedef unsigned int u32;\n"
+	"///keep this in sync with btCollidable.h\n"
+	"typedef struct\n"
+	"{\n"
+	"	union {\n"
+	"		int m_numChildShapes;\n"
+	"		int m_bvhIndex;\n"
+	"	};\n"
+	"	union\n"
+	"	{\n"
+	"		float m_radius;\n"
+	"		int	m_compoundBvhIndex;\n"
+	"	};\n"
+	"	\n"
+	"	int m_shapeType;\n"
+	"	int m_shapeIndex;\n"
+	"	\n"
+	"} btCollidableGpu;\n"
+	"#define MAX_NUM_PARTS_IN_BITS 10\n"
+	"///b3QuantizedBvhNode is a compressed aabb node, 16 bytes.\n"
+	"///Node can be used for leafnode or internal node. Leafnodes can point to 32-bit triangle index (non-negative range).\n"
+	"typedef struct\n"
+	"{\n"
+	"	//12 bytes\n"
+	"	unsigned short int	m_quantizedAabbMin[3];\n"
+	"	unsigned short int	m_quantizedAabbMax[3];\n"
+	"	//4 bytes\n"
+	"	int	m_escapeIndexOrTriangleIndex;\n"
+	"} b3QuantizedBvhNode;\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4		m_aabbMin;\n"
+	"	float4		m_aabbMax;\n"
+	"	float4		m_quantization;\n"
+	"	int			m_numNodes;\n"
+	"	int			m_numSubTrees;\n"
+	"	int			m_nodeOffset;\n"
+	"	int			m_subTreeOffset;\n"
+	"} b3BvhInfo;\n"
+	"int	getTriangleIndex(const b3QuantizedBvhNode* rootNode)\n"
+	"{\n"
+	"	unsigned int x=0;\n"
+	"	unsigned int y = (~(x&0))<<(31-MAX_NUM_PARTS_IN_BITS);\n"
+	"	// Get only the lower bits where the triangle index is stored\n"
+	"	return (rootNode->m_escapeIndexOrTriangleIndex&~(y));\n"
+	"}\n"
+	"int	getTriangleIndexGlobal(__global const b3QuantizedBvhNode* rootNode)\n"
+	"{\n"
+	"	unsigned int x=0;\n"
+	"	unsigned int y = (~(x&0))<<(31-MAX_NUM_PARTS_IN_BITS);\n"
+	"	// Get only the lower bits where the triangle index is stored\n"
+	"	return (rootNode->m_escapeIndexOrTriangleIndex&~(y));\n"
+	"}\n"
+	"int isLeafNode(const b3QuantizedBvhNode* rootNode)\n"
+	"{\n"
+	"	//skipindex is negative (internal node), triangleindex >=0 (leafnode)\n"
+	"	return (rootNode->m_escapeIndexOrTriangleIndex >= 0)? 1 : 0;\n"
+	"}\n"
+	"int isLeafNodeGlobal(__global const b3QuantizedBvhNode* rootNode)\n"
+	"{\n"
+	"	//skipindex is negative (internal node), triangleindex >=0 (leafnode)\n"
+	"	return (rootNode->m_escapeIndexOrTriangleIndex >= 0)? 1 : 0;\n"
+	"}\n"
+	"	\n"
+	"int getEscapeIndex(const b3QuantizedBvhNode* rootNode)\n"
+	"{\n"
+	"	return -rootNode->m_escapeIndexOrTriangleIndex;\n"
+	"}\n"
+	"int getEscapeIndexGlobal(__global const b3QuantizedBvhNode* rootNode)\n"
+	"{\n"
+	"	return -rootNode->m_escapeIndexOrTriangleIndex;\n"
+	"}\n"
+	"typedef struct\n"
+	"{\n"
+	"	//12 bytes\n"
+	"	unsigned short int	m_quantizedAabbMin[3];\n"
+	"	unsigned short int	m_quantizedAabbMax[3];\n"
+	"	//4 bytes, points to the root of the subtree\n"
+	"	int			m_rootNodeIndex;\n"
+	"	//4 bytes\n"
+	"	int			m_subtreeSize;\n"
+	"	int			m_padding[3];\n"
+	"} b3BvhSubtreeInfo;\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4	m_childPosition;\n"
+	"	float4	m_childOrientation;\n"
+	"	int m_shapeIndex;\n"
+	"	int m_unused0;\n"
+	"	int m_unused1;\n"
+	"	int m_unused2;\n"
+	"} btGpuChildShape;\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4 m_pos;\n"
+	"	float4 m_quat;\n"
+	"	float4 m_linVel;\n"
+	"	float4 m_angVel;\n"
+	"	u32 m_collidableIdx;\n"
+	"	float m_invMass;\n"
+	"	float m_restituitionCoeff;\n"
+	"	float m_frictionCoeff;\n"
+	"} BodyData;\n"
+	"typedef struct  \n"
+	"{\n"
+	"	float4		m_localCenter;\n"
+	"	float4		m_extents;\n"
+	"	float4		mC;\n"
+	"	float4		mE;\n"
+	"	\n"
+	"	float			m_radius;\n"
+	"	int	m_faceOffset;\n"
+	"	int m_numFaces;\n"
+	"	int	m_numVertices;\n"
+	"	int m_vertexOffset;\n"
+	"	int	m_uniqueEdgesOffset;\n"
+	"	int	m_numUniqueEdges;\n"
+	"	int m_unused;\n"
+	"} ConvexPolyhedronCL;\n"
+	"typedef struct \n"
+	"{\n"
+	"	union\n"
+	"	{\n"
+	"		float4	m_min;\n"
+	"		float   m_minElems[4];\n"
+	"		int			m_minIndices[4];\n"
+	"	};\n"
+	"	union\n"
+	"	{\n"
+	"		float4	m_max;\n"
+	"		float   m_maxElems[4];\n"
+	"		int			m_maxIndices[4];\n"
+	"	};\n"
+	"} btAabbCL;\n"
+	"#ifndef B3_AABB_H\n"
+	"#define B3_AABB_H\n"
+	"#ifndef B3_FLOAT4_H\n"
+	"#define B3_FLOAT4_H\n"
+	"#ifndef B3_PLATFORM_DEFINITIONS_H\n"
+	"#define B3_PLATFORM_DEFINITIONS_H\n"
+	"struct MyTest\n"
+	"{\n"
+	"	int bla;\n"
+	"};\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"//keep B3_LARGE_FLOAT*B3_LARGE_FLOAT < FLT_MAX\n"
+	"#define B3_LARGE_FLOAT 1e18f\n"
+	"#define B3_INFINITY 1e18f\n"
+	"#define b3Assert(a)\n"
+	"#define b3ConstArray(a) __global const a*\n"
+	"#define b3AtomicInc atomic_inc\n"
+	"#define b3AtomicAdd atomic_add\n"
+	"#define b3Fabs fabs\n"
+	"#define b3Sqrt native_sqrt\n"
+	"#define b3Sin native_sin\n"
+	"#define b3Cos native_cos\n"
+	"#define B3_STATIC\n"
+	"#endif\n"
+	"#endif\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"	typedef float4	b3Float4;\n"
+	"	#define b3Float4ConstArg const b3Float4\n"
+	"	#define b3MakeFloat4 (float4)\n"
+	"	float b3Dot3F4(b3Float4ConstArg v0,b3Float4ConstArg v1)\n"
+	"	{\n"
+	"		float4 a1 = b3MakeFloat4(v0.xyz,0.f);\n"
+	"		float4 b1 = b3MakeFloat4(v1.xyz,0.f);\n"
+	"		return dot(a1, b1);\n"
+	"	}\n"
+	"	b3Float4 b3Cross3(b3Float4ConstArg v0,b3Float4ConstArg v1)\n"
+	"	{\n"
+	"		float4 a1 = b3MakeFloat4(v0.xyz,0.f);\n"
+	"		float4 b1 = b3MakeFloat4(v1.xyz,0.f);\n"
+	"		return cross(a1, b1);\n"
+	"	}\n"
+	"	#define b3MinFloat4 min\n"
+	"	#define b3MaxFloat4 max\n"
+	"	#define b3Normalized(a) normalize(a)\n"
+	"#endif \n"
+	"		\n"
+	"inline bool b3IsAlmostZero(b3Float4ConstArg v)\n"
+	"{\n"
+	"	if(b3Fabs(v.x)>1e-6 || b3Fabs(v.y)>1e-6 || b3Fabs(v.z)>1e-6)	\n"
+	"		return false;\n"
+	"	return true;\n"
+	"}\n"
+	"inline int    b3MaxDot( b3Float4ConstArg vec, __global const b3Float4* vecArray, int vecLen, float* dotOut )\n"
+	"{\n"
+	"    float maxDot = -B3_INFINITY;\n"
+	"    int i = 0;\n"
+	"    int ptIndex = -1;\n"
+	"    for( i = 0; i < vecLen; i++ )\n"
+	"    {\n"
+	"        float dot = b3Dot3F4(vecArray[i],vec);\n"
+	"            \n"
+	"        if( dot > maxDot )\n"
+	"        {\n"
+	"            maxDot = dot;\n"
+	"            ptIndex = i;\n"
+	"        }\n"
+	"    }\n"
+	"	b3Assert(ptIndex>=0);\n"
+	"    if (ptIndex<0)\n"
+	"	{\n"
+	"		ptIndex = 0;\n"
+	"	}\n"
+	"    *dotOut = maxDot;\n"
+	"    return ptIndex;\n"
+	"}\n"
+	"#endif //B3_FLOAT4_H\n"
+	"#ifndef B3_MAT3x3_H\n"
+	"#define B3_MAT3x3_H\n"
+	"#ifndef B3_QUAT_H\n"
+	"#define B3_QUAT_H\n"
+	"#ifndef B3_PLATFORM_DEFINITIONS_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif\n"
+	"#endif\n"
+	"#ifndef B3_FLOAT4_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif \n"
+	"#endif //B3_FLOAT4_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"	typedef float4	b3Quat;\n"
+	"	#define b3QuatConstArg const b3Quat\n"
+	"	\n"
+	"	\n"
+	"inline float4 b3FastNormalize4(float4 v)\n"
+	"{\n"
+	"	v = (float4)(v.xyz,0.f);\n"
+	"	return fast_normalize(v);\n"
+	"}\n"
+	"	\n"
+	"inline b3Quat b3QuatMul(b3Quat a, b3Quat b);\n"
+	"inline b3Quat b3QuatNormalized(b3QuatConstArg in);\n"
+	"inline b3Quat b3QuatRotate(b3QuatConstArg q, b3QuatConstArg vec);\n"
+	"inline b3Quat b3QuatInvert(b3QuatConstArg q);\n"
+	"inline b3Quat b3QuatInverse(b3QuatConstArg q);\n"
+	"inline b3Quat b3QuatMul(b3QuatConstArg a, b3QuatConstArg b)\n"
+	"{\n"
+	"	b3Quat ans;\n"
+	"	ans = b3Cross3( a, b );\n"
+	"	ans += a.w*b+b.w*a;\n"
+	"//	ans.w = a.w*b.w - (a.x*b.x+a.y*b.y+a.z*b.z);\n"
+	"	ans.w = a.w*b.w - b3Dot3F4(a, b);\n"
+	"	return ans;\n"
+	"}\n"
+	"inline b3Quat b3QuatNormalized(b3QuatConstArg in)\n"
+	"{\n"
+	"	b3Quat q;\n"
+	"	q=in;\n"
+	"	//return b3FastNormalize4(in);\n"
+	"	float len = native_sqrt(dot(q, q));\n"
+	"	if(len > 0.f)\n"
+	"	{\n"
+	"		q *= 1.f / len;\n"
+	"	}\n"
+	"	else\n"
+	"	{\n"
+	"		q.x = q.y = q.z = 0.f;\n"
+	"		q.w = 1.f;\n"
+	"	}\n"
+	"	return q;\n"
+	"}\n"
+	"inline float4 b3QuatRotate(b3QuatConstArg q, b3QuatConstArg vec)\n"
+	"{\n"
+	"	b3Quat qInv = b3QuatInvert( q );\n"
+	"	float4 vcpy = vec;\n"
+	"	vcpy.w = 0.f;\n"
+	"	float4 out = b3QuatMul(b3QuatMul(q,vcpy),qInv);\n"
+	"	return out;\n"
+	"}\n"
+	"inline b3Quat b3QuatInverse(b3QuatConstArg q)\n"
+	"{\n"
+	"	return (b3Quat)(-q.xyz, q.w);\n"
+	"}\n"
+	"inline b3Quat b3QuatInvert(b3QuatConstArg q)\n"
+	"{\n"
+	"	return (b3Quat)(-q.xyz, q.w);\n"
+	"}\n"
+	"inline float4 b3QuatInvRotate(b3QuatConstArg q, b3QuatConstArg vec)\n"
+	"{\n"
+	"	return b3QuatRotate( b3QuatInvert( q ), vec );\n"
+	"}\n"
+	"inline b3Float4 b3TransformPoint(b3Float4ConstArg point, b3Float4ConstArg translation, b3QuatConstArg  orientation)\n"
+	"{\n"
+	"	return b3QuatRotate( orientation, point ) + (translation);\n"
+	"}\n"
+	"	\n"
+	"#endif \n"
+	"#endif //B3_QUAT_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"typedef struct\n"
+	"{\n"
+	"	b3Float4 m_row[3];\n"
+	"}b3Mat3x3;\n"
+	"#define b3Mat3x3ConstArg const b3Mat3x3\n"
+	"#define b3GetRow(m,row) (m.m_row[row])\n"
+	"inline b3Mat3x3 b3QuatGetRotationMatrix(b3Quat quat)\n"
+	"{\n"
+	"	b3Float4 quat2 = (b3Float4)(quat.x*quat.x, quat.y*quat.y, quat.z*quat.z, 0.f);\n"
+	"	b3Mat3x3 out;\n"
+	"	out.m_row[0].x=1-2*quat2.y-2*quat2.z;\n"
+	"	out.m_row[0].y=2*quat.x*quat.y-2*quat.w*quat.z;\n"
+	"	out.m_row[0].z=2*quat.x*quat.z+2*quat.w*quat.y;\n"
+	"	out.m_row[0].w = 0.f;\n"
+	"	out.m_row[1].x=2*quat.x*quat.y+2*quat.w*quat.z;\n"
+	"	out.m_row[1].y=1-2*quat2.x-2*quat2.z;\n"
+	"	out.m_row[1].z=2*quat.y*quat.z-2*quat.w*quat.x;\n"
+	"	out.m_row[1].w = 0.f;\n"
+	"	out.m_row[2].x=2*quat.x*quat.z-2*quat.w*quat.y;\n"
+	"	out.m_row[2].y=2*quat.y*quat.z+2*quat.w*quat.x;\n"
+	"	out.m_row[2].z=1-2*quat2.x-2*quat2.y;\n"
+	"	out.m_row[2].w = 0.f;\n"
+	"	return out;\n"
+	"}\n"
+	"inline b3Mat3x3 b3AbsoluteMat3x3(b3Mat3x3ConstArg matIn)\n"
+	"{\n"
+	"	b3Mat3x3 out;\n"
+	"	out.m_row[0] = fabs(matIn.m_row[0]);\n"
+	"	out.m_row[1] = fabs(matIn.m_row[1]);\n"
+	"	out.m_row[2] = fabs(matIn.m_row[2]);\n"
+	"	return out;\n"
+	"}\n"
+	"__inline\n"
+	"b3Mat3x3 mtZero();\n"
+	"__inline\n"
+	"b3Mat3x3 mtIdentity();\n"
+	"__inline\n"
+	"b3Mat3x3 mtTranspose(b3Mat3x3 m);\n"
+	"__inline\n"
+	"b3Mat3x3 mtMul(b3Mat3x3 a, b3Mat3x3 b);\n"
+	"__inline\n"
+	"b3Float4 mtMul1(b3Mat3x3 a, b3Float4 b);\n"
+	"__inline\n"
+	"b3Float4 mtMul3(b3Float4 a, b3Mat3x3 b);\n"
+	"__inline\n"
+	"b3Mat3x3 mtZero()\n"
+	"{\n"
+	"	b3Mat3x3 m;\n"
+	"	m.m_row[0] = (b3Float4)(0.f);\n"
+	"	m.m_row[1] = (b3Float4)(0.f);\n"
+	"	m.m_row[2] = (b3Float4)(0.f);\n"
+	"	return m;\n"
+	"}\n"
+	"__inline\n"
+	"b3Mat3x3 mtIdentity()\n"
+	"{\n"
+	"	b3Mat3x3 m;\n"
+	"	m.m_row[0] = (b3Float4)(1,0,0,0);\n"
+	"	m.m_row[1] = (b3Float4)(0,1,0,0);\n"
+	"	m.m_row[2] = (b3Float4)(0,0,1,0);\n"
+	"	return m;\n"
+	"}\n"
+	"__inline\n"
+	"b3Mat3x3 mtTranspose(b3Mat3x3 m)\n"
+	"{\n"
+	"	b3Mat3x3 out;\n"
+	"	out.m_row[0] = (b3Float4)(m.m_row[0].x, m.m_row[1].x, m.m_row[2].x, 0.f);\n"
+	"	out.m_row[1] = (b3Float4)(m.m_row[0].y, m.m_row[1].y, m.m_row[2].y, 0.f);\n"
+	"	out.m_row[2] = (b3Float4)(m.m_row[0].z, m.m_row[1].z, m.m_row[2].z, 0.f);\n"
+	"	return out;\n"
+	"}\n"
+	"__inline\n"
+	"b3Mat3x3 mtMul(b3Mat3x3 a, b3Mat3x3 b)\n"
+	"{\n"
+	"	b3Mat3x3 transB;\n"
+	"	transB = mtTranspose( b );\n"
+	"	b3Mat3x3 ans;\n"
+	"	//	why this doesn't run when 0ing in the for{}\n"
+	"	a.m_row[0].w = 0.f;\n"
+	"	a.m_row[1].w = 0.f;\n"
+	"	a.m_row[2].w = 0.f;\n"
+	"	for(int i=0; i<3; i++)\n"
+	"	{\n"
+	"//	a.m_row[i].w = 0.f;\n"
+	"		ans.m_row[i].x = b3Dot3F4(a.m_row[i],transB.m_row[0]);\n"
+	"		ans.m_row[i].y = b3Dot3F4(a.m_row[i],transB.m_row[1]);\n"
+	"		ans.m_row[i].z = b3Dot3F4(a.m_row[i],transB.m_row[2]);\n"
+	"		ans.m_row[i].w = 0.f;\n"
+	"	}\n"
+	"	return ans;\n"
+	"}\n"
+	"__inline\n"
+	"b3Float4 mtMul1(b3Mat3x3 a, b3Float4 b)\n"
+	"{\n"
+	"	b3Float4 ans;\n"
+	"	ans.x = b3Dot3F4( a.m_row[0], b );\n"
+	"	ans.y = b3Dot3F4( a.m_row[1], b );\n"
+	"	ans.z = b3Dot3F4( a.m_row[2], b );\n"
+	"	ans.w = 0.f;\n"
+	"	return ans;\n"
+	"}\n"
+	"__inline\n"
+	"b3Float4 mtMul3(b3Float4 a, b3Mat3x3 b)\n"
+	"{\n"
+	"	b3Float4 colx = b3MakeFloat4(b.m_row[0].x, b.m_row[1].x, b.m_row[2].x, 0);\n"
+	"	b3Float4 coly = b3MakeFloat4(b.m_row[0].y, b.m_row[1].y, b.m_row[2].y, 0);\n"
+	"	b3Float4 colz = b3MakeFloat4(b.m_row[0].z, b.m_row[1].z, b.m_row[2].z, 0);\n"
+	"	b3Float4 ans;\n"
+	"	ans.x = b3Dot3F4( a, colx );\n"
+	"	ans.y = b3Dot3F4( a, coly );\n"
+	"	ans.z = b3Dot3F4( a, colz );\n"
+	"	return ans;\n"
+	"}\n"
+	"#endif\n"
+	"#endif //B3_MAT3x3_H\n"
+	"typedef struct b3Aabb b3Aabb_t;\n"
+	"struct b3Aabb\n"
+	"{\n"
+	"	union\n"
+	"	{\n"
+	"		float m_min[4];\n"
+	"		b3Float4 m_minVec;\n"
+	"		int m_minIndices[4];\n"
+	"	};\n"
+	"	union\n"
+	"	{\n"
+	"		float	m_max[4];\n"
+	"		b3Float4 m_maxVec;\n"
+	"		int m_signedMaxIndices[4];\n"
+	"	};\n"
+	"};\n"
+	"inline void b3TransformAabb2(b3Float4ConstArg localAabbMin,b3Float4ConstArg localAabbMax, float margin,\n"
+	"						b3Float4ConstArg pos,\n"
+	"						b3QuatConstArg orn,\n"
+	"						b3Float4* aabbMinOut,b3Float4* aabbMaxOut)\n"
+	"{\n"
+	"		b3Float4 localHalfExtents = 0.5f*(localAabbMax-localAabbMin);\n"
+	"		localHalfExtents+=b3MakeFloat4(margin,margin,margin,0.f);\n"
+	"		b3Float4 localCenter = 0.5f*(localAabbMax+localAabbMin);\n"
+	"		b3Mat3x3 m;\n"
+	"		m = b3QuatGetRotationMatrix(orn);\n"
+	"		b3Mat3x3 abs_b = b3AbsoluteMat3x3(m);\n"
+	"		b3Float4 center = b3TransformPoint(localCenter,pos,orn);\n"
+	"		\n"
+	"		b3Float4 extent = b3MakeFloat4(b3Dot3F4(localHalfExtents,b3GetRow(abs_b,0)),\n"
+	"										 b3Dot3F4(localHalfExtents,b3GetRow(abs_b,1)),\n"
+	"										 b3Dot3F4(localHalfExtents,b3GetRow(abs_b,2)),\n"
+	"										 0.f);\n"
+	"		*aabbMinOut = center-extent;\n"
+	"		*aabbMaxOut = center+extent;\n"
+	"}\n"
+	"/// conservative test for overlap between two aabbs\n"
+	"inline bool b3TestAabbAgainstAabb(b3Float4ConstArg aabbMin1,b3Float4ConstArg aabbMax1,\n"
+	"								b3Float4ConstArg aabbMin2, b3Float4ConstArg aabbMax2)\n"
+	"{\n"
+	"	bool overlap = true;\n"
+	"	overlap = (aabbMin1.x > aabbMax2.x || aabbMax1.x < aabbMin2.x) ? false : overlap;\n"
+	"	overlap = (aabbMin1.z > aabbMax2.z || aabbMax1.z < aabbMin2.z) ? false : overlap;\n"
+	"	overlap = (aabbMin1.y > aabbMax2.y || aabbMax1.y < aabbMin2.y) ? false : overlap;\n"
+	"	return overlap;\n"
+	"}\n"
+	"#endif //B3_AABB_H\n"
+	"/*\n"
+	"Bullet Continuous Collision Detection and Physics Library\n"
+	"Copyright (c) 2003-2013 Erwin Coumans  http://bulletphysics.org\n"
+	"This software is provided 'as-is', without any express or implied warranty.\n"
+	"In no event will the authors be held liable for any damages arising from the use of this software.\n"
+	"Permission is granted to anyone to use this software for any purpose,\n"
+	"including commercial applications, and to alter it and redistribute it freely,\n"
+	"subject to the following restrictions:\n"
+	"1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.\n"
+	"2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.\n"
+	"3. This notice may not be removed or altered from any source distribution.\n"
+	"*/\n"
+	"#ifndef B3_INT2_H\n"
+	"#define B3_INT2_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#define b3UnsignedInt2 uint2\n"
+	"#define b3Int2 int2\n"
+	"#define b3MakeInt2 (int2)\n"
+	"#endif //__cplusplus\n"
+	"#endif\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4 m_plane;\n"
+	"	int m_indexOffset;\n"
+	"	int m_numIndices;\n"
+	"} btGpuFace;\n"
+	"#define make_float4 (float4)\n"
+	"__inline\n"
+	"float4 cross3(float4 a, float4 b)\n"
+	"{\n"
+	"	return cross(a,b);\n"
+	"	\n"
+	"//	float4 a1 = make_float4(a.xyz,0.f);\n"
+	"//	float4 b1 = make_float4(b.xyz,0.f);\n"
+	"//	return cross(a1,b1);\n"
+	"//float4 c = make_float4(a.y*b.z - a.z*b.y,a.z*b.x - a.x*b.z,a.x*b.y - a.y*b.x,0.f);\n"
+	"	\n"
+	"	//	float4 c = make_float4(a.y*b.z - a.z*b.y,1.f,a.x*b.y - a.y*b.x,0.f);\n"
+	"	\n"
+	"	//return c;\n"
+	"}\n"
+	"__inline\n"
+	"float dot3F4(float4 a, float4 b)\n"
+	"{\n"
+	"	float4 a1 = make_float4(a.xyz,0.f);\n"
+	"	float4 b1 = make_float4(b.xyz,0.f);\n"
+	"	return dot(a1, b1);\n"
+	"}\n"
+	"__inline\n"
+	"float4 fastNormalize4(float4 v)\n"
+	"{\n"
+	"	v = make_float4(v.xyz,0.f);\n"
+	"	return fast_normalize(v);\n"
+	"}\n"
+	"///////////////////////////////////////\n"
+	"//	Quaternion\n"
+	"///////////////////////////////////////\n"
+	"typedef float4 Quaternion;\n"
+	"__inline\n"
+	"Quaternion qtMul(Quaternion a, Quaternion b);\n"
+	"__inline\n"
+	"Quaternion qtNormalize(Quaternion in);\n"
+	"__inline\n"
+	"float4 qtRotate(Quaternion q, float4 vec);\n"
+	"__inline\n"
+	"Quaternion qtInvert(Quaternion q);\n"
+	"__inline\n"
+	"Quaternion qtMul(Quaternion a, Quaternion b)\n"
+	"{\n"
+	"	Quaternion ans;\n"
+	"	ans = cross3( a, b );\n"
+	"	ans += a.w*b+b.w*a;\n"
+	"//	ans.w = a.w*b.w - (a.x*b.x+a.y*b.y+a.z*b.z);\n"
+	"	ans.w = a.w*b.w - dot3F4(a, b);\n"
+	"	return ans;\n"
+	"}\n"
+	"__inline\n"
+	"Quaternion qtNormalize(Quaternion in)\n"
+	"{\n"
+	"	return fastNormalize4(in);\n"
+	"//	in /= length( in );\n"
+	"//	return in;\n"
+	"}\n"
+	"__inline\n"
+	"float4 qtRotate(Quaternion q, float4 vec)\n"
+	"{\n"
+	"	Quaternion qInv = qtInvert( q );\n"
+	"	float4 vcpy = vec;\n"
+	"	vcpy.w = 0.f;\n"
+	"	float4 out = qtMul(qtMul(q,vcpy),qInv);\n"
+	"	return out;\n"
+	"}\n"
+	"__inline\n"
+	"Quaternion qtInvert(Quaternion q)\n"
+	"{\n"
+	"	return (Quaternion)(-q.xyz, q.w);\n"
+	"}\n"
+	"__inline\n"
+	"float4 qtInvRotate(const Quaternion q, float4 vec)\n"
+	"{\n"
+	"	return qtRotate( qtInvert( q ), vec );\n"
+	"}\n"
+	"__inline\n"
+	"float4 transform(const float4* p, const float4* translation, const Quaternion* orientation)\n"
+	"{\n"
+	"	return qtRotate( *orientation, *p ) + (*translation);\n"
+	"}\n"
+	"__inline\n"
+	"float4 normalize3(const float4 a)\n"
+	"{\n"
+	"	float4 n = make_float4(a.x, a.y, a.z, 0.f);\n"
+	"	return fastNormalize4( n );\n"
+	"}\n"
+	"inline void projectLocal(const ConvexPolyhedronCL* hull,  const float4 pos, const float4 orn, \n"
+	"const float4* dir, const float4* vertices, float* min, float* max)\n"
+	"{\n"
+	"	min[0] = FLT_MAX;\n"
+	"	max[0] = -FLT_MAX;\n"
+	"	int numVerts = hull->m_numVertices;\n"
+	"	const float4 localDir = qtInvRotate(orn,*dir);\n"
+	"	float offset = dot(pos,*dir);\n"
+	"	for(int i=0;i<numVerts;i++)\n"
+	"	{\n"
+	"		float dp = dot(vertices[hull->m_vertexOffset+i],localDir);\n"
+	"		if(dp < min[0])	\n"
+	"			min[0] = dp;\n"
+	"		if(dp > max[0])	\n"
+	"			max[0] = dp;\n"
+	"	}\n"
+	"	if(min[0]>max[0])\n"
+	"	{\n"
+	"		float tmp = min[0];\n"
+	"		min[0] = max[0];\n"
+	"		max[0] = tmp;\n"
+	"	}\n"
+	"	min[0] += offset;\n"
+	"	max[0] += offset;\n"
+	"}\n"
+	"inline void project(__global const ConvexPolyhedronCL* hull,  const float4 pos, const float4 orn, \n"
+	"const float4* dir, __global const float4* vertices, float* min, float* max)\n"
+	"{\n"
+	"	min[0] = FLT_MAX;\n"
+	"	max[0] = -FLT_MAX;\n"
+	"	int numVerts = hull->m_numVertices;\n"
+	"	const float4 localDir = qtInvRotate(orn,*dir);\n"
+	"	float offset = dot(pos,*dir);\n"
+	"	for(int i=0;i<numVerts;i++)\n"
+	"	{\n"
+	"		float dp = dot(vertices[hull->m_vertexOffset+i],localDir);\n"
+	"		if(dp < min[0])	\n"
+	"			min[0] = dp;\n"
+	"		if(dp > max[0])	\n"
+	"			max[0] = dp;\n"
+	"	}\n"
+	"	if(min[0]>max[0])\n"
+	"	{\n"
+	"		float tmp = min[0];\n"
+	"		min[0] = max[0];\n"
+	"		max[0] = tmp;\n"
+	"	}\n"
+	"	min[0] += offset;\n"
+	"	max[0] += offset;\n"
+	"}\n"
+	"inline bool TestSepAxisLocalA(const ConvexPolyhedronCL* hullA, __global const ConvexPolyhedronCL* hullB, \n"
+	"	const float4 posA,const float4 ornA,\n"
+	"	const float4 posB,const float4 ornB,\n"
+	"	float4* sep_axis, const float4* verticesA, __global const float4* verticesB,float* depth)\n"
+	"{\n"
+	"	float Min0,Max0;\n"
+	"	float Min1,Max1;\n"
+	"	projectLocal(hullA,posA,ornA,sep_axis,verticesA, &Min0, &Max0);\n"
+	"	project(hullB,posB,ornB, sep_axis,verticesB, &Min1, &Max1);\n"
+	"	if(Max0<Min1 || Max1<Min0)\n"
+	"		return false;\n"
+	"	float d0 = Max0 - Min1;\n"
+	"	float d1 = Max1 - Min0;\n"
+	"	*depth = d0<d1 ? d0:d1;\n"
+	"	return true;\n"
+	"}\n"
+	"inline bool IsAlmostZero(const float4 v)\n"
+	"{\n"
+	"	if(fabs(v.x)>1e-6f || fabs(v.y)>1e-6f || fabs(v.z)>1e-6f)\n"
+	"		return false;\n"
+	"	return true;\n"
+	"}\n"
+	"bool findSeparatingAxisLocalA(	const ConvexPolyhedronCL* hullA, __global const ConvexPolyhedronCL* hullB, \n"
+	"	const float4 posA1,\n"
+	"	const float4 ornA,\n"
+	"	const float4 posB1,\n"
+	"	const float4 ornB,\n"
+	"	const float4 DeltaC2,\n"
+	"	\n"
+	"	const float4* verticesA, \n"
+	"	const float4* uniqueEdgesA, \n"
+	"	const btGpuFace* facesA,\n"
+	"	const int*  indicesA,\n"
+	"	__global const float4* verticesB, \n"
+	"	__global const float4* uniqueEdgesB, \n"
+	"	__global const btGpuFace* facesB,\n"
+	"	__global const int*  indicesB,\n"
+	"	float4* sep,\n"
+	"	float* dmin)\n"
+	"{\n"
+	"	\n"
+	"	float4 posA = posA1;\n"
+	"	posA.w = 0.f;\n"
+	"	float4 posB = posB1;\n"
+	"	posB.w = 0.f;\n"
+	"	int curPlaneTests=0;\n"
+	"	{\n"
+	"		int numFacesA = hullA->m_numFaces;\n"
+	"		// Test normals from hullA\n"
+	"		for(int i=0;i<numFacesA;i++)\n"
+	"		{\n"
+	"			const float4 normal = facesA[hullA->m_faceOffset+i].m_plane;\n"
+	"			float4 faceANormalWS = qtRotate(ornA,normal);\n"
+	"			if (dot3F4(DeltaC2,faceANormalWS)<0)\n"
+	"				faceANormalWS*=-1.f;\n"
+	"			curPlaneTests++;\n"
+	"			float d;\n"
+	"			if(!TestSepAxisLocalA( hullA, hullB, posA,ornA,posB,ornB,&faceANormalWS, verticesA, verticesB,&d))\n"
+	"				return false;\n"
+	"			if(d<*dmin)\n"
+	"			{\n"
+	"				*dmin = d;\n"
+	"				*sep = faceANormalWS;\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"	if((dot3F4(-DeltaC2,*sep))>0.0f)\n"
+	"	{\n"
+	"		*sep = -(*sep);\n"
+	"	}\n"
+	"	return true;\n"
+	"}\n"
+	"bool findSeparatingAxisLocalB(	__global const ConvexPolyhedronCL* hullA,  const ConvexPolyhedronCL* hullB, \n"
+	"	const float4 posA1,\n"
+	"	const float4 ornA,\n"
+	"	const float4 posB1,\n"
+	"	const float4 ornB,\n"
+	"	const float4 DeltaC2,\n"
+	"	__global const float4* verticesA, \n"
+	"	__global const float4* uniqueEdgesA, \n"
+	"	__global const btGpuFace* facesA,\n"
+	"	__global const int*  indicesA,\n"
+	"	const float4* verticesB,\n"
+	"	const float4* uniqueEdgesB, \n"
+	"	const btGpuFace* facesB,\n"
+	"	const int*  indicesB,\n"
+	"	float4* sep,\n"
+	"	float* dmin)\n"
+	"{\n"
+	"	float4 posA = posA1;\n"
+	"	posA.w = 0.f;\n"
+	"	float4 posB = posB1;\n"
+	"	posB.w = 0.f;\n"
+	"	int curPlaneTests=0;\n"
+	"	{\n"
+	"		int numFacesA = hullA->m_numFaces;\n"
+	"		// Test normals from hullA\n"
+	"		for(int i=0;i<numFacesA;i++)\n"
+	"		{\n"
+	"			const float4 normal = facesA[hullA->m_faceOffset+i].m_plane;\n"
+	"			float4 faceANormalWS = qtRotate(ornA,normal);\n"
+	"			if (dot3F4(DeltaC2,faceANormalWS)<0)\n"
+	"				faceANormalWS *= -1.f;\n"
+	"			curPlaneTests++;\n"
+	"			float d;\n"
+	"			if(!TestSepAxisLocalA( hullB, hullA, posB,ornB,posA,ornA, &faceANormalWS, verticesB,verticesA, &d))\n"
+	"				return false;\n"
+	"			if(d<*dmin)\n"
+	"			{\n"
+	"				*dmin = d;\n"
+	"				*sep = faceANormalWS;\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"	if((dot3F4(-DeltaC2,*sep))>0.0f)\n"
+	"	{\n"
+	"		*sep = -(*sep);\n"
+	"	}\n"
+	"	return true;\n"
+	"}\n"
+	"bool findSeparatingAxisEdgeEdgeLocalA(	const ConvexPolyhedronCL* hullA, __global const ConvexPolyhedronCL* hullB, \n"
+	"	const float4 posA1,\n"
+	"	const float4 ornA,\n"
+	"	const float4 posB1,\n"
+	"	const float4 ornB,\n"
+	"	const float4 DeltaC2,\n"
+	"	const float4* verticesA, \n"
+	"	const float4* uniqueEdgesA, \n"
+	"	const btGpuFace* facesA,\n"
+	"	const int*  indicesA,\n"
+	"	__global const float4* verticesB, \n"
+	"	__global const float4* uniqueEdgesB, \n"
+	"	__global const btGpuFace* facesB,\n"
+	"	__global const int*  indicesB,\n"
+	"		float4* sep,\n"
+	"	float* dmin)\n"
+	"{\n"
+	"	float4 posA = posA1;\n"
+	"	posA.w = 0.f;\n"
+	"	float4 posB = posB1;\n"
+	"	posB.w = 0.f;\n"
+	"	int curPlaneTests=0;\n"
+	"	int curEdgeEdge = 0;\n"
+	"	// Test edges\n"
+	"	for(int e0=0;e0<hullA->m_numUniqueEdges;e0++)\n"
+	"	{\n"
+	"		const float4 edge0 = uniqueEdgesA[hullA->m_uniqueEdgesOffset+e0];\n"
+	"		float4 edge0World = qtRotate(ornA,edge0);\n"
+	"		for(int e1=0;e1<hullB->m_numUniqueEdges;e1++)\n"
+	"		{\n"
+	"			const float4 edge1 = uniqueEdgesB[hullB->m_uniqueEdgesOffset+e1];\n"
+	"			float4 edge1World = qtRotate(ornB,edge1);\n"
+	"			float4 crossje = cross3(edge0World,edge1World);\n"
+	"			curEdgeEdge++;\n"
+	"			if(!IsAlmostZero(crossje))\n"
+	"			{\n"
+	"				crossje = normalize3(crossje);\n"
+	"				if (dot3F4(DeltaC2,crossje)<0)\n"
+	"					crossje *= -1.f;\n"
+	"				float dist;\n"
+	"				bool result = true;\n"
+	"				{\n"
+	"					float Min0,Max0;\n"
+	"					float Min1,Max1;\n"
+	"					projectLocal(hullA,posA,ornA,&crossje,verticesA, &Min0, &Max0);\n"
+	"					project(hullB,posB,ornB,&crossje,verticesB, &Min1, &Max1);\n"
+	"				\n"
+	"					if(Max0<Min1 || Max1<Min0)\n"
+	"						result = false;\n"
+	"				\n"
+	"					float d0 = Max0 - Min1;\n"
+	"					float d1 = Max1 - Min0;\n"
+	"					dist = d0<d1 ? d0:d1;\n"
+	"					result = true;\n"
+	"				}\n"
+	"				\n"
+	"				if(dist<*dmin)\n"
+	"				{\n"
+	"					*dmin = dist;\n"
+	"					*sep = crossje;\n"
+	"				}\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"	\n"
+	"	if((dot3F4(-DeltaC2,*sep))>0.0f)\n"
+	"	{\n"
+	"		*sep = -(*sep);\n"
+	"	}\n"
+	"	return true;\n"
+	"}\n"
+	"inline int	findClippingFaces(const float4 separatingNormal,\n"
+	"                      const ConvexPolyhedronCL* hullA, \n"
+	"					  __global const ConvexPolyhedronCL* hullB,\n"
+	"                      const float4 posA, const Quaternion ornA,const float4 posB, const Quaternion ornB,\n"
+	"                       __global float4* worldVertsA1,\n"
+	"                      __global float4* worldNormalsA1,\n"
+	"                      __global float4* worldVertsB1,\n"
+	"                      int capacityWorldVerts,\n"
+	"                      const float minDist, float maxDist,\n"
+	"					  const float4* verticesA,\n"
+	"                      const btGpuFace* facesA,\n"
+	"                      const int* indicesA,\n"
+	"					  __global const float4* verticesB,\n"
+	"                      __global const btGpuFace* facesB,\n"
+	"                      __global const int* indicesB,\n"
+	"                      __global int4* clippingFaces, int pairIndex)\n"
+	"{\n"
+	"	int numContactsOut = 0;\n"
+	"	int numWorldVertsB1= 0;\n"
+	"    \n"
+	"    \n"
+	"	int closestFaceB=0;\n"
+	"	float dmax = -FLT_MAX;\n"
+	"    \n"
+	"	{\n"
+	"		for(int face=0;face<hullB->m_numFaces;face++)\n"
+	"		{\n"
+	"			const float4 Normal = make_float4(facesB[hullB->m_faceOffset+face].m_plane.x,\n"
+	"                                              facesB[hullB->m_faceOffset+face].m_plane.y, facesB[hullB->m_faceOffset+face].m_plane.z,0.f);\n"
+	"			const float4 WorldNormal = qtRotate(ornB, Normal);\n"
+	"			float d = dot3F4(WorldNormal,separatingNormal);\n"
+	"			if (d > dmax)\n"
+	"			{\n"
+	"				dmax = d;\n"
+	"				closestFaceB = face;\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"    \n"
+	"	{\n"
+	"		const btGpuFace polyB = facesB[hullB->m_faceOffset+closestFaceB];\n"
+	"		int numVertices = polyB.m_numIndices;\n"
+	"        if (numVertices>capacityWorldVerts)\n"
+	"            numVertices = capacityWorldVerts;\n"
+	"        if (numVertices<0)\n"
+	"            numVertices = 0;\n"
+	"        \n"
+	"		for(int e0=0;e0<numVertices;e0++)\n"
+	"		{\n"
+	"            if (e0<capacityWorldVerts)\n"
+	"            {\n"
+	"                const float4 b = verticesB[hullB->m_vertexOffset+indicesB[polyB.m_indexOffset+e0]];\n"
+	"                worldVertsB1[pairIndex*capacityWorldVerts+numWorldVertsB1++] = transform(&b,&posB,&ornB);\n"
+	"            }\n"
+	"		}\n"
+	"	}\n"
+	"    \n"
+	"    int closestFaceA=0;\n"
+	"	{\n"
+	"		float dmin = FLT_MAX;\n"
+	"		for(int face=0;face<hullA->m_numFaces;face++)\n"
+	"		{\n"
+	"			const float4 Normal = make_float4(\n"
+	"                                              facesA[hullA->m_faceOffset+face].m_plane.x,\n"
+	"                                              facesA[hullA->m_faceOffset+face].m_plane.y,\n"
+	"                                              facesA[hullA->m_faceOffset+face].m_plane.z,\n"
+	"                                              0.f);\n"
+	"			const float4 faceANormalWS = qtRotate(ornA,Normal);\n"
+	"            \n"
+	"			float d = dot3F4(faceANormalWS,separatingNormal);\n"
+	"			if (d < dmin)\n"
+	"			{\n"
+	"				dmin = d;\n"
+	"				closestFaceA = face;\n"
+	"                worldNormalsA1[pairIndex] = faceANormalWS;\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"    \n"
+	"    int numVerticesA = facesA[hullA->m_faceOffset+closestFaceA].m_numIndices;\n"
+	"    if (numVerticesA>capacityWorldVerts)\n"
+	"       numVerticesA = capacityWorldVerts;\n"
+	"    if (numVerticesA<0)\n"
+	"        numVerticesA=0;\n"
+	"    \n"
+	"	for(int e0=0;e0<numVerticesA;e0++)\n"
+	"	{\n"
+	"        if (e0<capacityWorldVerts)\n"
+	"        {\n"
+	"            const float4 a = verticesA[hullA->m_vertexOffset+indicesA[facesA[hullA->m_faceOffset+closestFaceA].m_indexOffset+e0]];\n"
+	"            worldVertsA1[pairIndex*capacityWorldVerts+e0] = transform(&a, &posA,&ornA);\n"
+	"        }\n"
+	"    }\n"
+	"    \n"
+	"    clippingFaces[pairIndex].x = closestFaceA;\n"
+	"    clippingFaces[pairIndex].y = closestFaceB;\n"
+	"    clippingFaces[pairIndex].z = numVerticesA;\n"
+	"    clippingFaces[pairIndex].w = numWorldVertsB1;\n"
+	"    \n"
+	"    \n"
+	"	return numContactsOut;\n"
+	"}\n"
+	"// work-in-progress\n"
+	"__kernel void   findConcaveSeparatingAxisVertexFaceKernel( __global int4* concavePairs,\n"
+	"                                                __global const BodyData* rigidBodies,\n"
+	"                                                __global const btCollidableGpu* collidables,\n"
+	"                                                __global const ConvexPolyhedronCL* convexShapes,\n"
+	"                                                __global const float4* vertices,\n"
+	"                                                __global const float4* uniqueEdges,\n"
+	"                                                __global const btGpuFace* faces,\n"
+	"                                                __global const int* indices,\n"
+	"                                                __global const btGpuChildShape* gpuChildShapes,\n"
+	"                                                __global btAabbCL* aabbs,\n"
+	"                                                __global float4* concaveSeparatingNormalsOut,\n"
+	"                                                __global int* concaveHasSeparatingNormals,\n"
+	"                                                __global int4* clippingFacesOut,\n"
+	"                                                __global float4* worldVertsA1GPU,\n"
+	"                                                __global float4*  worldNormalsAGPU,\n"
+	"                                                __global float4* worldVertsB1GPU,\n"
+	"                                                __global float* dmins,\n"
+	"                                                int vertexFaceCapacity,\n"
+	"                                                int numConcavePairs\n"
+	"                                                )\n"
+	"{\n"
+	"    \n"
+	"	int i = get_global_id(0);\n"
+	"	if (i>=numConcavePairs)\n"
+	"		return;\n"
+	"    \n"
+	"	concaveHasSeparatingNormals[i] = 0;\n"
+	"    \n"
+	"	int pairIdx = i;\n"
+	"    \n"
+	"	int bodyIndexA = concavePairs[i].x;\n"
+	"	int bodyIndexB = concavePairs[i].y;\n"
+	"    \n"
+	"	int collidableIndexA = rigidBodies[bodyIndexA].m_collidableIdx;\n"
+	"	int collidableIndexB = rigidBodies[bodyIndexB].m_collidableIdx;\n"
+	"    \n"
+	"	int shapeIndexA = collidables[collidableIndexA].m_shapeIndex;\n"
+	"	int shapeIndexB = collidables[collidableIndexB].m_shapeIndex;\n"
+	"    \n"
+	"	if (collidables[collidableIndexB].m_shapeType!=SHAPE_CONVEX_HULL&&\n"
+	"		collidables[collidableIndexB].m_shapeType!=SHAPE_COMPOUND_OF_CONVEX_HULLS)\n"
+	"	{\n"
+	"		concavePairs[pairIdx].w = -1;\n"
+	"		return;\n"
+	"	}\n"
+	"    \n"
+	"    \n"
+	"    \n"
+	"	int numFacesA = convexShapes[shapeIndexA].m_numFaces;\n"
+	"	int numActualConcaveConvexTests = 0;\n"
+	"	\n"
+	"	int f = concavePairs[i].z;\n"
+	"	\n"
+	"	bool overlap = false;\n"
+	"	\n"
+	"	ConvexPolyhedronCL convexPolyhedronA;\n"
+	"    \n"
+	"	//add 3 vertices of the triangle\n"
+	"	convexPolyhedronA.m_numVertices = 3;\n"
+	"	convexPolyhedronA.m_vertexOffset = 0;\n"
+	"	float4	localCenter = make_float4(0.f,0.f,0.f,0.f);\n"
+	"    \n"
+	"	btGpuFace face = faces[convexShapes[shapeIndexA].m_faceOffset+f];\n"
+	"	float4 triMinAabb, triMaxAabb;\n"
+	"	btAabbCL triAabb;\n"
+	"	triAabb.m_min = make_float4(1e30f,1e30f,1e30f,0.f);\n"
+	"	triAabb.m_max = make_float4(-1e30f,-1e30f,-1e30f,0.f);\n"
+	"	\n"
+	"	float4 verticesA[3];\n"
+	"	for (int i=0;i<3;i++)\n"
+	"	{\n"
+	"		int index = indices[face.m_indexOffset+i];\n"
+	"		float4 vert = vertices[convexShapes[shapeIndexA].m_vertexOffset+index];\n"
+	"		verticesA[i] = vert;\n"
+	"		localCenter += vert;\n"
+	"        \n"
+	"		triAabb.m_min = min(triAabb.m_min,vert);\n"
+	"		triAabb.m_max = max(triAabb.m_max,vert);\n"
+	"        \n"
+	"	}\n"
+	"    \n"
+	"	overlap = true;\n"
+	"	overlap = (triAabb.m_min.x > aabbs[bodyIndexB].m_max.x || triAabb.m_max.x < aabbs[bodyIndexB].m_min.x) ? false : overlap;\n"
+	"	overlap = (triAabb.m_min.z > aabbs[bodyIndexB].m_max.z || triAabb.m_max.z < aabbs[bodyIndexB].m_min.z) ? false : overlap;\n"
+	"	overlap = (triAabb.m_min.y > aabbs[bodyIndexB].m_max.y || triAabb.m_max.y < aabbs[bodyIndexB].m_min.y) ? false : overlap;\n"
+	"    \n"
+	"	if (overlap)\n"
+	"	{\n"
+	"		float dmin = FLT_MAX;\n"
+	"		int hasSeparatingAxis=5;\n"
+	"		float4 sepAxis=make_float4(1,2,3,4);\n"
+	"        \n"
+	"		int localCC=0;\n"
+	"		numActualConcaveConvexTests++;\n"
+	"        \n"
+	"		//a triangle has 3 unique edges\n"
+	"		convexPolyhedronA.m_numUniqueEdges = 3;\n"
+	"		convexPolyhedronA.m_uniqueEdgesOffset = 0;\n"
+	"		float4 uniqueEdgesA[3];\n"
+	"		\n"
+	"		uniqueEdgesA[0] = (verticesA[1]-verticesA[0]);\n"
+	"		uniqueEdgesA[1] = (verticesA[2]-verticesA[1]);\n"
+	"		uniqueEdgesA[2] = (verticesA[0]-verticesA[2]);\n"
+	"        \n"
+	"        \n"
+	"		convexPolyhedronA.m_faceOffset = 0;\n"
+	"        \n"
+	"		float4 normal = make_float4(face.m_plane.x,face.m_plane.y,face.m_plane.z,0.f);\n"
+	"        \n"
+	"		btGpuFace facesA[TRIANGLE_NUM_CONVEX_FACES];\n"
+	"		int indicesA[3+3+2+2+2];\n"
+	"		int curUsedIndices=0;\n"
+	"		int fidx=0;\n"
+	"        \n"
+	"		//front size of triangle\n"
+	"		{\n"
+	"			facesA[fidx].m_indexOffset=curUsedIndices;\n"
+	"			indicesA[0] = 0;\n"
+	"			indicesA[1] = 1;\n"
+	"			indicesA[2] = 2;\n"
+	"			curUsedIndices+=3;\n"
+	"			float c = face.m_plane.w;\n"
+	"			facesA[fidx].m_plane.x = normal.x;\n"
+	"			facesA[fidx].m_plane.y = normal.y;\n"
+	"			facesA[fidx].m_plane.z = normal.z;\n"
+	"			facesA[fidx].m_plane.w = c;\n"
+	"			facesA[fidx].m_numIndices=3;\n"
+	"		}\n"
+	"		fidx++;\n"
+	"		//back size of triangle\n"
+	"		{\n"
+	"			facesA[fidx].m_indexOffset=curUsedIndices;\n"
+	"			indicesA[3]=2;\n"
+	"			indicesA[4]=1;\n"
+	"			indicesA[5]=0;\n"
+	"			curUsedIndices+=3;\n"
+	"			float c = dot(normal,verticesA[0]);\n"
+	"			float c1 = -face.m_plane.w;\n"
+	"			facesA[fidx].m_plane.x = -normal.x;\n"
+	"			facesA[fidx].m_plane.y = -normal.y;\n"
+	"			facesA[fidx].m_plane.z = -normal.z;\n"
+	"			facesA[fidx].m_plane.w = c;\n"
+	"			facesA[fidx].m_numIndices=3;\n"
+	"		}\n"
+	"		fidx++;\n"
+	"        \n"
+	"		bool addEdgePlanes = true;\n"
+	"		if (addEdgePlanes)\n"
+	"		{\n"
+	"			int numVertices=3;\n"
+	"			int prevVertex = numVertices-1;\n"
+	"			for (int i=0;i<numVertices;i++)\n"
+	"			{\n"
+	"				float4 v0 = verticesA[i];\n"
+	"				float4 v1 = verticesA[prevVertex];\n"
+	"                \n"
+	"				float4 edgeNormal = normalize(cross(normal,v1-v0));\n"
+	"				float c = -dot(edgeNormal,v0);\n"
+	"                \n"
+	"				facesA[fidx].m_numIndices = 2;\n"
+	"				facesA[fidx].m_indexOffset=curUsedIndices;\n"
+	"				indicesA[curUsedIndices++]=i;\n"
+	"				indicesA[curUsedIndices++]=prevVertex;\n"
+	"                \n"
+	"				facesA[fidx].m_plane.x = edgeNormal.x;\n"
+	"				facesA[fidx].m_plane.y = edgeNormal.y;\n"
+	"				facesA[fidx].m_plane.z = edgeNormal.z;\n"
+	"				facesA[fidx].m_plane.w = c;\n"
+	"				fidx++;\n"
+	"				prevVertex = i;\n"
+	"			}\n"
+	"		}\n"
+	"		convexPolyhedronA.m_numFaces = TRIANGLE_NUM_CONVEX_FACES;\n"
+	"		convexPolyhedronA.m_localCenter = localCenter*(1.f/3.f);\n"
+	"        \n"
+	"        \n"
+	"		float4 posA = rigidBodies[bodyIndexA].m_pos;\n"
+	"		posA.w = 0.f;\n"
+	"		float4 posB = rigidBodies[bodyIndexB].m_pos;\n"
+	"		posB.w = 0.f;\n"
+	"        \n"
+	"		float4 ornA = rigidBodies[bodyIndexA].m_quat;\n"
+	"		float4 ornB =rigidBodies[bodyIndexB].m_quat;\n"
+	"        \n"
+	"		\n"
+	"        \n"
+	"        \n"
+	"		///////////////////\n"
+	"		///compound shape support\n"
+	"        \n"
+	"		if (collidables[collidableIndexB].m_shapeType==SHAPE_COMPOUND_OF_CONVEX_HULLS)\n"
+	"		{\n"
+	"			int compoundChild = concavePairs[pairIdx].w;\n"
+	"			int childShapeIndexB = compoundChild;//collidables[collidableIndexB].m_shapeIndex+compoundChild;\n"
+	"			int childColIndexB = gpuChildShapes[childShapeIndexB].m_shapeIndex;\n"
+	"			float4 childPosB = gpuChildShapes[childShapeIndexB].m_childPosition;\n"
+	"			float4 childOrnB = gpuChildShapes[childShapeIndexB].m_childOrientation;\n"
+	"			float4 newPosB = transform(&childPosB,&posB,&ornB);\n"
+	"			float4 newOrnB = qtMul(ornB,childOrnB);\n"
+	"			posB = newPosB;\n"
+	"			ornB = newOrnB;\n"
+	"			shapeIndexB = collidables[childColIndexB].m_shapeIndex;\n"
+	"		}\n"
+	"		//////////////////\n"
+	"        \n"
+	"		float4 c0local = convexPolyhedronA.m_localCenter;\n"
+	"		float4 c0 = transform(&c0local, &posA, &ornA);\n"
+	"		float4 c1local = convexShapes[shapeIndexB].m_localCenter;\n"
+	"		float4 c1 = transform(&c1local,&posB,&ornB);\n"
+	"		const float4 DeltaC2 = c0 - c1;\n"
+	"        \n"
+	"        \n"
+	"		bool sepA = findSeparatingAxisLocalA(	&convexPolyhedronA, &convexShapes[shapeIndexB],\n"
+	"                                             posA,ornA,\n"
+	"                                             posB,ornB,\n"
+	"                                             DeltaC2,\n"
+	"                                             verticesA,uniqueEdgesA,facesA,indicesA,\n"
+	"                                             vertices,uniqueEdges,faces,indices,\n"
+	"                                             &sepAxis,&dmin);\n"
+	"		hasSeparatingAxis = 4;\n"
+	"		if (!sepA)\n"
+	"		{\n"
+	"			hasSeparatingAxis = 0;\n"
+	"		} else\n"
+	"		{\n"
+	"			bool sepB = findSeparatingAxisLocalB(	&convexShapes[shapeIndexB],&convexPolyhedronA,\n"
+	"                                                 posB,ornB,\n"
+	"                                                 posA,ornA,\n"
+	"                                                 DeltaC2,\n"
+	"                                                 vertices,uniqueEdges,faces,indices,\n"
+	"                                                 verticesA,uniqueEdgesA,facesA,indicesA,\n"
+	"                                                 &sepAxis,&dmin);\n"
+	"            \n"
+	"			if (!sepB)\n"
+	"			{\n"
+	"				hasSeparatingAxis = 0;\n"
+	"			} else\n"
+	"			{\n"
+	"				hasSeparatingAxis = 1;\n"
+	"			}\n"
+	"		}	\n"
+	"		\n"
+	"		if (hasSeparatingAxis)\n"
+	"		{\n"
+	"            dmins[i] = dmin;\n"
+	"			concaveSeparatingNormalsOut[pairIdx]=sepAxis;\n"
+	"			concaveHasSeparatingNormals[i]=1;\n"
+	"            \n"
+	"		} else\n"
+	"		{	\n"
+	"			//mark this pair as in-active\n"
+	"			concavePairs[pairIdx].w = -1;\n"
+	"		}\n"
+	"	}\n"
+	"	else\n"
+	"	{	\n"
+	"		//mark this pair as in-active\n"
+	"		concavePairs[pairIdx].w = -1;\n"
+	"	}\n"
+	"}\n"
+	"// work-in-progress\n"
+	"__kernel void   findConcaveSeparatingAxisEdgeEdgeKernel( __global int4* concavePairs,\n"
+	"                                                          __global const BodyData* rigidBodies,\n"
+	"                                                          __global const btCollidableGpu* collidables,\n"
+	"                                                          __global const ConvexPolyhedronCL* convexShapes,\n"
+	"                                                          __global const float4* vertices,\n"
+	"                                                          __global const float4* uniqueEdges,\n"
+	"                                                          __global const btGpuFace* faces,\n"
+	"                                                          __global const int* indices,\n"
+	"                                                          __global const btGpuChildShape* gpuChildShapes,\n"
+	"                                                          __global btAabbCL* aabbs,\n"
+	"                                                          __global float4* concaveSeparatingNormalsOut,\n"
+	"                                                          __global int* concaveHasSeparatingNormals,\n"
+	"                                                          __global int4* clippingFacesOut,\n"
+	"                                                          __global float4* worldVertsA1GPU,\n"
+	"                                                          __global float4*  worldNormalsAGPU,\n"
+	"                                                          __global float4* worldVertsB1GPU,\n"
+	"                                                          __global float* dmins,\n"
+	"                                                          int vertexFaceCapacity,\n"
+	"                                                          int numConcavePairs\n"
+	"                                                          )\n"
+	"{\n"
+	"    \n"
+	"	int i = get_global_id(0);\n"
+	"	if (i>=numConcavePairs)\n"
+	"		return;\n"
+	"    \n"
+	"	if (!concaveHasSeparatingNormals[i])\n"
+	"        return;\n"
+	"    \n"
+	"	int pairIdx = i;\n"
+	"    \n"
+	"	int bodyIndexA = concavePairs[i].x;\n"
+	"	int bodyIndexB = concavePairs[i].y;\n"
+	"    \n"
+	"	int collidableIndexA = rigidBodies[bodyIndexA].m_collidableIdx;\n"
+	"	int collidableIndexB = rigidBodies[bodyIndexB].m_collidableIdx;\n"
+	"    \n"
+	"	int shapeIndexA = collidables[collidableIndexA].m_shapeIndex;\n"
+	"	int shapeIndexB = collidables[collidableIndexB].m_shapeIndex;\n"
+	"    \n"
+	"    \n"
+	"	int numFacesA = convexShapes[shapeIndexA].m_numFaces;\n"
+	"	int numActualConcaveConvexTests = 0;\n"
+	"	\n"
+	"	int f = concavePairs[i].z;\n"
+	"	\n"
+	"	bool overlap = false;\n"
+	"	\n"
+	"	ConvexPolyhedronCL convexPolyhedronA;\n"
+	"    \n"
+	"	//add 3 vertices of the triangle\n"
+	"	convexPolyhedronA.m_numVertices = 3;\n"
+	"	convexPolyhedronA.m_vertexOffset = 0;\n"
+	"	float4	localCenter = make_float4(0.f,0.f,0.f,0.f);\n"
+	"    \n"
+	"	btGpuFace face = faces[convexShapes[shapeIndexA].m_faceOffset+f];\n"
+	"	float4 triMinAabb, triMaxAabb;\n"
+	"	btAabbCL triAabb;\n"
+	"	triAabb.m_min = make_float4(1e30f,1e30f,1e30f,0.f);\n"
+	"	triAabb.m_max = make_float4(-1e30f,-1e30f,-1e30f,0.f);\n"
+	"	\n"
+	"	float4 verticesA[3];\n"
+	"	for (int i=0;i<3;i++)\n"
+	"	{\n"
+	"		int index = indices[face.m_indexOffset+i];\n"
+	"		float4 vert = vertices[convexShapes[shapeIndexA].m_vertexOffset+index];\n"
+	"		verticesA[i] = vert;\n"
+	"		localCenter += vert;\n"
+	"        \n"
+	"		triAabb.m_min = min(triAabb.m_min,vert);\n"
+	"		triAabb.m_max = max(triAabb.m_max,vert);\n"
+	"        \n"
+	"	}\n"
+	"    \n"
+	"	overlap = true;\n"
+	"	overlap = (triAabb.m_min.x > aabbs[bodyIndexB].m_max.x || triAabb.m_max.x < aabbs[bodyIndexB].m_min.x) ? false : overlap;\n"
+	"	overlap = (triAabb.m_min.z > aabbs[bodyIndexB].m_max.z || triAabb.m_max.z < aabbs[bodyIndexB].m_min.z) ? false : overlap;\n"
+	"	overlap = (triAabb.m_min.y > aabbs[bodyIndexB].m_max.y || triAabb.m_max.y < aabbs[bodyIndexB].m_min.y) ? false : overlap;\n"
+	"    \n"
+	"	if (overlap)\n"
+	"	{\n"
+	"		float dmin = dmins[i];\n"
+	"		int hasSeparatingAxis=5;\n"
+	"		float4 sepAxis=make_float4(1,2,3,4);\n"
+	"        sepAxis = concaveSeparatingNormalsOut[pairIdx];\n"
+	"        \n"
+	"		int localCC=0;\n"
+	"		numActualConcaveConvexTests++;\n"
+	"        \n"
+	"		//a triangle has 3 unique edges\n"
+	"		convexPolyhedronA.m_numUniqueEdges = 3;\n"
+	"		convexPolyhedronA.m_uniqueEdgesOffset = 0;\n"
+	"		float4 uniqueEdgesA[3];\n"
+	"		\n"
+	"		uniqueEdgesA[0] = (verticesA[1]-verticesA[0]);\n"
+	"		uniqueEdgesA[1] = (verticesA[2]-verticesA[1]);\n"
+	"		uniqueEdgesA[2] = (verticesA[0]-verticesA[2]);\n"
+	"        \n"
+	"        \n"
+	"		convexPolyhedronA.m_faceOffset = 0;\n"
+	"        \n"
+	"		float4 normal = make_float4(face.m_plane.x,face.m_plane.y,face.m_plane.z,0.f);\n"
+	"        \n"
+	"		btGpuFace facesA[TRIANGLE_NUM_CONVEX_FACES];\n"
+	"		int indicesA[3+3+2+2+2];\n"
+	"		int curUsedIndices=0;\n"
+	"		int fidx=0;\n"
+	"        \n"
+	"		//front size of triangle\n"
+	"		{\n"
+	"			facesA[fidx].m_indexOffset=curUsedIndices;\n"
+	"			indicesA[0] = 0;\n"
+	"			indicesA[1] = 1;\n"
+	"			indicesA[2] = 2;\n"
+	"			curUsedIndices+=3;\n"
+	"			float c = face.m_plane.w;\n"
+	"			facesA[fidx].m_plane.x = normal.x;\n"
+	"			facesA[fidx].m_plane.y = normal.y;\n"
+	"			facesA[fidx].m_plane.z = normal.z;\n"
+	"			facesA[fidx].m_plane.w = c;\n"
+	"			facesA[fidx].m_numIndices=3;\n"
+	"		}\n"
+	"		fidx++;\n"
+	"		//back size of triangle\n"
+	"		{\n"
+	"			facesA[fidx].m_indexOffset=curUsedIndices;\n"
+	"			indicesA[3]=2;\n"
+	"			indicesA[4]=1;\n"
+	"			indicesA[5]=0;\n"
+	"			curUsedIndices+=3;\n"
+	"			float c = dot(normal,verticesA[0]);\n"
+	"			float c1 = -face.m_plane.w;\n"
+	"			facesA[fidx].m_plane.x = -normal.x;\n"
+	"			facesA[fidx].m_plane.y = -normal.y;\n"
+	"			facesA[fidx].m_plane.z = -normal.z;\n"
+	"			facesA[fidx].m_plane.w = c;\n"
+	"			facesA[fidx].m_numIndices=3;\n"
+	"		}\n"
+	"		fidx++;\n"
+	"        \n"
+	"		bool addEdgePlanes = true;\n"
+	"		if (addEdgePlanes)\n"
+	"		{\n"
+	"			int numVertices=3;\n"
+	"			int prevVertex = numVertices-1;\n"
+	"			for (int i=0;i<numVertices;i++)\n"
+	"			{\n"
+	"				float4 v0 = verticesA[i];\n"
+	"				float4 v1 = verticesA[prevVertex];\n"
+	"                \n"
+	"				float4 edgeNormal = normalize(cross(normal,v1-v0));\n"
+	"				float c = -dot(edgeNormal,v0);\n"
+	"                \n"
+	"				facesA[fidx].m_numIndices = 2;\n"
+	"				facesA[fidx].m_indexOffset=curUsedIndices;\n"
+	"				indicesA[curUsedIndices++]=i;\n"
+	"				indicesA[curUsedIndices++]=prevVertex;\n"
+	"                \n"
+	"				facesA[fidx].m_plane.x = edgeNormal.x;\n"
+	"				facesA[fidx].m_plane.y = edgeNormal.y;\n"
+	"				facesA[fidx].m_plane.z = edgeNormal.z;\n"
+	"				facesA[fidx].m_plane.w = c;\n"
+	"				fidx++;\n"
+	"				prevVertex = i;\n"
+	"			}\n"
+	"		}\n"
+	"		convexPolyhedronA.m_numFaces = TRIANGLE_NUM_CONVEX_FACES;\n"
+	"		convexPolyhedronA.m_localCenter = localCenter*(1.f/3.f);\n"
+	"        \n"
+	"        \n"
+	"		float4 posA = rigidBodies[bodyIndexA].m_pos;\n"
+	"		posA.w = 0.f;\n"
+	"		float4 posB = rigidBodies[bodyIndexB].m_pos;\n"
+	"		posB.w = 0.f;\n"
+	"        \n"
+	"		float4 ornA = rigidBodies[bodyIndexA].m_quat;\n"
+	"		float4 ornB =rigidBodies[bodyIndexB].m_quat;\n"
+	"        \n"
+	"		\n"
+	"        \n"
+	"        \n"
+	"		///////////////////\n"
+	"		///compound shape support\n"
+	"        \n"
+	"		if (collidables[collidableIndexB].m_shapeType==SHAPE_COMPOUND_OF_CONVEX_HULLS)\n"
+	"		{\n"
+	"			int compoundChild = concavePairs[pairIdx].w;\n"
+	"			int childShapeIndexB = compoundChild;//collidables[collidableIndexB].m_shapeIndex+compoundChild;\n"
+	"			int childColIndexB = gpuChildShapes[childShapeIndexB].m_shapeIndex;\n"
+	"			float4 childPosB = gpuChildShapes[childShapeIndexB].m_childPosition;\n"
+	"			float4 childOrnB = gpuChildShapes[childShapeIndexB].m_childOrientation;\n"
+	"			float4 newPosB = transform(&childPosB,&posB,&ornB);\n"
+	"			float4 newOrnB = qtMul(ornB,childOrnB);\n"
+	"			posB = newPosB;\n"
+	"			ornB = newOrnB;\n"
+	"			shapeIndexB = collidables[childColIndexB].m_shapeIndex;\n"
+	"		}\n"
+	"		//////////////////\n"
+	"        \n"
+	"		float4 c0local = convexPolyhedronA.m_localCenter;\n"
+	"		float4 c0 = transform(&c0local, &posA, &ornA);\n"
+	"		float4 c1local = convexShapes[shapeIndexB].m_localCenter;\n"
+	"		float4 c1 = transform(&c1local,&posB,&ornB);\n"
+	"		const float4 DeltaC2 = c0 - c1;\n"
+	"        \n"
+	"        \n"
+	"		{\n"
+	"			bool sepEE = findSeparatingAxisEdgeEdgeLocalA(	&convexPolyhedronA, &convexShapes[shapeIndexB],\n"
+	"                                                              posA,ornA,\n"
+	"                                                              posB,ornB,\n"
+	"                                                              DeltaC2,\n"
+	"                                                              verticesA,uniqueEdgesA,facesA,indicesA,\n"
+	"                                                              vertices,uniqueEdges,faces,indices,\n"
+	"                                                              &sepAxis,&dmin);\n"
+	"                \n"
+	"			if (!sepEE)\n"
+	"			{\n"
+	"				hasSeparatingAxis = 0;\n"
+	"			} else\n"
+	"			{\n"
+	"				hasSeparatingAxis = 1;\n"
+	"			}\n"
+	"		}\n"
+	"		\n"
+	"		\n"
+	"		if (hasSeparatingAxis)\n"
+	"		{\n"
+	"			sepAxis.w = dmin;\n"
+	"            dmins[i] = dmin;\n"
+	"			concaveSeparatingNormalsOut[pairIdx]=sepAxis;\n"
+	"			concaveHasSeparatingNormals[i]=1;\n"
+	"           \n"
+	" 	float minDist = -1e30f;\n"
+	"			float maxDist = 0.02f;\n"
+	"            \n"
+	"            findClippingFaces(sepAxis,\n"
+	"                              &convexPolyhedronA,\n"
+	"                              &convexShapes[shapeIndexB],\n"
+	"                              posA,ornA,\n"
+	"                              posB,ornB,\n"
+	"                              worldVertsA1GPU,\n"
+	"                              worldNormalsAGPU,\n"
+	"                              worldVertsB1GPU,\n"
+	"                              vertexFaceCapacity,\n"
+	"                              minDist, maxDist,\n"
+	"                              verticesA,\n"
+	"                              facesA,\n"
+	"                              indicesA,\n"
+	"                              vertices,\n"
+	"                              faces,\n"
+	"                              indices,\n"
+	"                              clippingFacesOut, pairIdx);\n"
+	"	           \n"
+	"            \n"
+	"		} else\n"
+	"		{	\n"
+	"			//mark this pair as in-active\n"
+	"			concavePairs[pairIdx].w = -1;\n"
+	"		}\n"
+	"	}\n"
+	"	else\n"
+	"	{	\n"
+	"		//mark this pair as in-active\n"
+	"		concavePairs[pairIdx].w = -1;\n"
+	"	}\n"
+	"	\n"
+	"	concavePairs[i].z = -1;//for the next stage, z is used to determine existing contact points\n"
+	"}\n";
diff --git a/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/kernels/satKernels.h b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/kernels/satKernels.h
new file mode 100644
index 00000000..e627af27
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/NarrowphaseCollision/kernels/satKernels.h
@@ -0,0 +1,2103 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* satKernelsCL =
+	"//keep this enum in sync with the CPU version (in btCollidable.h)\n"
+	"//written by Erwin Coumans\n"
+	"#define SHAPE_CONVEX_HULL 3\n"
+	"#define SHAPE_CONCAVE_TRIMESH 5\n"
+	"#define TRIANGLE_NUM_CONVEX_FACES 5\n"
+	"#define SHAPE_COMPOUND_OF_CONVEX_HULLS 6\n"
+	"#define B3_MAX_STACK_DEPTH 256\n"
+	"typedef unsigned int u32;\n"
+	"///keep this in sync with btCollidable.h\n"
+	"typedef struct\n"
+	"{\n"
+	"	union {\n"
+	"		int m_numChildShapes;\n"
+	"		int m_bvhIndex;\n"
+	"	};\n"
+	"	union\n"
+	"	{\n"
+	"		float m_radius;\n"
+	"		int	m_compoundBvhIndex;\n"
+	"	};\n"
+	"	\n"
+	"	int m_shapeType;\n"
+	"	int m_shapeIndex;\n"
+	"	\n"
+	"} btCollidableGpu;\n"
+	"#define MAX_NUM_PARTS_IN_BITS 10\n"
+	"///b3QuantizedBvhNode is a compressed aabb node, 16 bytes.\n"
+	"///Node can be used for leafnode or internal node. Leafnodes can point to 32-bit triangle index (non-negative range).\n"
+	"typedef struct\n"
+	"{\n"
+	"	//12 bytes\n"
+	"	unsigned short int	m_quantizedAabbMin[3];\n"
+	"	unsigned short int	m_quantizedAabbMax[3];\n"
+	"	//4 bytes\n"
+	"	int	m_escapeIndexOrTriangleIndex;\n"
+	"} b3QuantizedBvhNode;\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4		m_aabbMin;\n"
+	"	float4		m_aabbMax;\n"
+	"	float4		m_quantization;\n"
+	"	int			m_numNodes;\n"
+	"	int			m_numSubTrees;\n"
+	"	int			m_nodeOffset;\n"
+	"	int			m_subTreeOffset;\n"
+	"} b3BvhInfo;\n"
+	"int	getTriangleIndex(const b3QuantizedBvhNode* rootNode)\n"
+	"{\n"
+	"	unsigned int x=0;\n"
+	"	unsigned int y = (~(x&0))<<(31-MAX_NUM_PARTS_IN_BITS);\n"
+	"	// Get only the lower bits where the triangle index is stored\n"
+	"	return (rootNode->m_escapeIndexOrTriangleIndex&~(y));\n"
+	"}\n"
+	"int	getTriangleIndexGlobal(__global const b3QuantizedBvhNode* rootNode)\n"
+	"{\n"
+	"	unsigned int x=0;\n"
+	"	unsigned int y = (~(x&0))<<(31-MAX_NUM_PARTS_IN_BITS);\n"
+	"	// Get only the lower bits where the triangle index is stored\n"
+	"	return (rootNode->m_escapeIndexOrTriangleIndex&~(y));\n"
+	"}\n"
+	"int isLeafNode(const b3QuantizedBvhNode* rootNode)\n"
+	"{\n"
+	"	//skipindex is negative (internal node), triangleindex >=0 (leafnode)\n"
+	"	return (rootNode->m_escapeIndexOrTriangleIndex >= 0)? 1 : 0;\n"
+	"}\n"
+	"int isLeafNodeGlobal(__global const b3QuantizedBvhNode* rootNode)\n"
+	"{\n"
+	"	//skipindex is negative (internal node), triangleindex >=0 (leafnode)\n"
+	"	return (rootNode->m_escapeIndexOrTriangleIndex >= 0)? 1 : 0;\n"
+	"}\n"
+	"	\n"
+	"int getEscapeIndex(const b3QuantizedBvhNode* rootNode)\n"
+	"{\n"
+	"	return -rootNode->m_escapeIndexOrTriangleIndex;\n"
+	"}\n"
+	"int getEscapeIndexGlobal(__global const b3QuantizedBvhNode* rootNode)\n"
+	"{\n"
+	"	return -rootNode->m_escapeIndexOrTriangleIndex;\n"
+	"}\n"
+	"typedef struct\n"
+	"{\n"
+	"	//12 bytes\n"
+	"	unsigned short int	m_quantizedAabbMin[3];\n"
+	"	unsigned short int	m_quantizedAabbMax[3];\n"
+	"	//4 bytes, points to the root of the subtree\n"
+	"	int			m_rootNodeIndex;\n"
+	"	//4 bytes\n"
+	"	int			m_subtreeSize;\n"
+	"	int			m_padding[3];\n"
+	"} b3BvhSubtreeInfo;\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4	m_childPosition;\n"
+	"	float4	m_childOrientation;\n"
+	"	int m_shapeIndex;\n"
+	"	int m_unused0;\n"
+	"	int m_unused1;\n"
+	"	int m_unused2;\n"
+	"} btGpuChildShape;\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4 m_pos;\n"
+	"	float4 m_quat;\n"
+	"	float4 m_linVel;\n"
+	"	float4 m_angVel;\n"
+	"	u32 m_collidableIdx;\n"
+	"	float m_invMass;\n"
+	"	float m_restituitionCoeff;\n"
+	"	float m_frictionCoeff;\n"
+	"} BodyData;\n"
+	"typedef struct  \n"
+	"{\n"
+	"	float4		m_localCenter;\n"
+	"	float4		m_extents;\n"
+	"	float4		mC;\n"
+	"	float4		mE;\n"
+	"	\n"
+	"	float			m_radius;\n"
+	"	int	m_faceOffset;\n"
+	"	int m_numFaces;\n"
+	"	int	m_numVertices;\n"
+	"	int m_vertexOffset;\n"
+	"	int	m_uniqueEdgesOffset;\n"
+	"	int	m_numUniqueEdges;\n"
+	"	int m_unused;\n"
+	"} ConvexPolyhedronCL;\n"
+	"typedef struct \n"
+	"{\n"
+	"	union\n"
+	"	{\n"
+	"		float4	m_min;\n"
+	"		float   m_minElems[4];\n"
+	"		int			m_minIndices[4];\n"
+	"	};\n"
+	"	union\n"
+	"	{\n"
+	"		float4	m_max;\n"
+	"		float   m_maxElems[4];\n"
+	"		int			m_maxIndices[4];\n"
+	"	};\n"
+	"} btAabbCL;\n"
+	"#ifndef B3_AABB_H\n"
+	"#define B3_AABB_H\n"
+	"#ifndef B3_FLOAT4_H\n"
+	"#define B3_FLOAT4_H\n"
+	"#ifndef B3_PLATFORM_DEFINITIONS_H\n"
+	"#define B3_PLATFORM_DEFINITIONS_H\n"
+	"struct MyTest\n"
+	"{\n"
+	"	int bla;\n"
+	"};\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"//keep B3_LARGE_FLOAT*B3_LARGE_FLOAT < FLT_MAX\n"
+	"#define B3_LARGE_FLOAT 1e18f\n"
+	"#define B3_INFINITY 1e18f\n"
+	"#define b3Assert(a)\n"
+	"#define b3ConstArray(a) __global const a*\n"
+	"#define b3AtomicInc atomic_inc\n"
+	"#define b3AtomicAdd atomic_add\n"
+	"#define b3Fabs fabs\n"
+	"#define b3Sqrt native_sqrt\n"
+	"#define b3Sin native_sin\n"
+	"#define b3Cos native_cos\n"
+	"#define B3_STATIC\n"
+	"#endif\n"
+	"#endif\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"	typedef float4	b3Float4;\n"
+	"	#define b3Float4ConstArg const b3Float4\n"
+	"	#define b3MakeFloat4 (float4)\n"
+	"	float b3Dot3F4(b3Float4ConstArg v0,b3Float4ConstArg v1)\n"
+	"	{\n"
+	"		float4 a1 = b3MakeFloat4(v0.xyz,0.f);\n"
+	"		float4 b1 = b3MakeFloat4(v1.xyz,0.f);\n"
+	"		return dot(a1, b1);\n"
+	"	}\n"
+	"	b3Float4 b3Cross3(b3Float4ConstArg v0,b3Float4ConstArg v1)\n"
+	"	{\n"
+	"		float4 a1 = b3MakeFloat4(v0.xyz,0.f);\n"
+	"		float4 b1 = b3MakeFloat4(v1.xyz,0.f);\n"
+	"		return cross(a1, b1);\n"
+	"	}\n"
+	"	#define b3MinFloat4 min\n"
+	"	#define b3MaxFloat4 max\n"
+	"	#define b3Normalized(a) normalize(a)\n"
+	"#endif \n"
+	"		\n"
+	"inline bool b3IsAlmostZero(b3Float4ConstArg v)\n"
+	"{\n"
+	"	if(b3Fabs(v.x)>1e-6 || b3Fabs(v.y)>1e-6 || b3Fabs(v.z)>1e-6)	\n"
+	"		return false;\n"
+	"	return true;\n"
+	"}\n"
+	"inline int    b3MaxDot( b3Float4ConstArg vec, __global const b3Float4* vecArray, int vecLen, float* dotOut )\n"
+	"{\n"
+	"    float maxDot = -B3_INFINITY;\n"
+	"    int i = 0;\n"
+	"    int ptIndex = -1;\n"
+	"    for( i = 0; i < vecLen; i++ )\n"
+	"    {\n"
+	"        float dot = b3Dot3F4(vecArray[i],vec);\n"
+	"            \n"
+	"        if( dot > maxDot )\n"
+	"        {\n"
+	"            maxDot = dot;\n"
+	"            ptIndex = i;\n"
+	"        }\n"
+	"    }\n"
+	"	b3Assert(ptIndex>=0);\n"
+	"    if (ptIndex<0)\n"
+	"	{\n"
+	"		ptIndex = 0;\n"
+	"	}\n"
+	"    *dotOut = maxDot;\n"
+	"    return ptIndex;\n"
+	"}\n"
+	"#endif //B3_FLOAT4_H\n"
+	"#ifndef B3_MAT3x3_H\n"
+	"#define B3_MAT3x3_H\n"
+	"#ifndef B3_QUAT_H\n"
+	"#define B3_QUAT_H\n"
+	"#ifndef B3_PLATFORM_DEFINITIONS_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif\n"
+	"#endif\n"
+	"#ifndef B3_FLOAT4_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif \n"
+	"#endif //B3_FLOAT4_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"	typedef float4	b3Quat;\n"
+	"	#define b3QuatConstArg const b3Quat\n"
+	"	\n"
+	"	\n"
+	"inline float4 b3FastNormalize4(float4 v)\n"
+	"{\n"
+	"	v = (float4)(v.xyz,0.f);\n"
+	"	return fast_normalize(v);\n"
+	"}\n"
+	"	\n"
+	"inline b3Quat b3QuatMul(b3Quat a, b3Quat b);\n"
+	"inline b3Quat b3QuatNormalized(b3QuatConstArg in);\n"
+	"inline b3Quat b3QuatRotate(b3QuatConstArg q, b3QuatConstArg vec);\n"
+	"inline b3Quat b3QuatInvert(b3QuatConstArg q);\n"
+	"inline b3Quat b3QuatInverse(b3QuatConstArg q);\n"
+	"inline b3Quat b3QuatMul(b3QuatConstArg a, b3QuatConstArg b)\n"
+	"{\n"
+	"	b3Quat ans;\n"
+	"	ans = b3Cross3( a, b );\n"
+	"	ans += a.w*b+b.w*a;\n"
+	"//	ans.w = a.w*b.w - (a.x*b.x+a.y*b.y+a.z*b.z);\n"
+	"	ans.w = a.w*b.w - b3Dot3F4(a, b);\n"
+	"	return ans;\n"
+	"}\n"
+	"inline b3Quat b3QuatNormalized(b3QuatConstArg in)\n"
+	"{\n"
+	"	b3Quat q;\n"
+	"	q=in;\n"
+	"	//return b3FastNormalize4(in);\n"
+	"	float len = native_sqrt(dot(q, q));\n"
+	"	if(len > 0.f)\n"
+	"	{\n"
+	"		q *= 1.f / len;\n"
+	"	}\n"
+	"	else\n"
+	"	{\n"
+	"		q.x = q.y = q.z = 0.f;\n"
+	"		q.w = 1.f;\n"
+	"	}\n"
+	"	return q;\n"
+	"}\n"
+	"inline float4 b3QuatRotate(b3QuatConstArg q, b3QuatConstArg vec)\n"
+	"{\n"
+	"	b3Quat qInv = b3QuatInvert( q );\n"
+	"	float4 vcpy = vec;\n"
+	"	vcpy.w = 0.f;\n"
+	"	float4 out = b3QuatMul(b3QuatMul(q,vcpy),qInv);\n"
+	"	return out;\n"
+	"}\n"
+	"inline b3Quat b3QuatInverse(b3QuatConstArg q)\n"
+	"{\n"
+	"	return (b3Quat)(-q.xyz, q.w);\n"
+	"}\n"
+	"inline b3Quat b3QuatInvert(b3QuatConstArg q)\n"
+	"{\n"
+	"	return (b3Quat)(-q.xyz, q.w);\n"
+	"}\n"
+	"inline float4 b3QuatInvRotate(b3QuatConstArg q, b3QuatConstArg vec)\n"
+	"{\n"
+	"	return b3QuatRotate( b3QuatInvert( q ), vec );\n"
+	"}\n"
+	"inline b3Float4 b3TransformPoint(b3Float4ConstArg point, b3Float4ConstArg translation, b3QuatConstArg  orientation)\n"
+	"{\n"
+	"	return b3QuatRotate( orientation, point ) + (translation);\n"
+	"}\n"
+	"	\n"
+	"#endif \n"
+	"#endif //B3_QUAT_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"typedef struct\n"
+	"{\n"
+	"	b3Float4 m_row[3];\n"
+	"}b3Mat3x3;\n"
+	"#define b3Mat3x3ConstArg const b3Mat3x3\n"
+	"#define b3GetRow(m,row) (m.m_row[row])\n"
+	"inline b3Mat3x3 b3QuatGetRotationMatrix(b3Quat quat)\n"
+	"{\n"
+	"	b3Float4 quat2 = (b3Float4)(quat.x*quat.x, quat.y*quat.y, quat.z*quat.z, 0.f);\n"
+	"	b3Mat3x3 out;\n"
+	"	out.m_row[0].x=1-2*quat2.y-2*quat2.z;\n"
+	"	out.m_row[0].y=2*quat.x*quat.y-2*quat.w*quat.z;\n"
+	"	out.m_row[0].z=2*quat.x*quat.z+2*quat.w*quat.y;\n"
+	"	out.m_row[0].w = 0.f;\n"
+	"	out.m_row[1].x=2*quat.x*quat.y+2*quat.w*quat.z;\n"
+	"	out.m_row[1].y=1-2*quat2.x-2*quat2.z;\n"
+	"	out.m_row[1].z=2*quat.y*quat.z-2*quat.w*quat.x;\n"
+	"	out.m_row[1].w = 0.f;\n"
+	"	out.m_row[2].x=2*quat.x*quat.z-2*quat.w*quat.y;\n"
+	"	out.m_row[2].y=2*quat.y*quat.z+2*quat.w*quat.x;\n"
+	"	out.m_row[2].z=1-2*quat2.x-2*quat2.y;\n"
+	"	out.m_row[2].w = 0.f;\n"
+	"	return out;\n"
+	"}\n"
+	"inline b3Mat3x3 b3AbsoluteMat3x3(b3Mat3x3ConstArg matIn)\n"
+	"{\n"
+	"	b3Mat3x3 out;\n"
+	"	out.m_row[0] = fabs(matIn.m_row[0]);\n"
+	"	out.m_row[1] = fabs(matIn.m_row[1]);\n"
+	"	out.m_row[2] = fabs(matIn.m_row[2]);\n"
+	"	return out;\n"
+	"}\n"
+	"__inline\n"
+	"b3Mat3x3 mtZero();\n"
+	"__inline\n"
+	"b3Mat3x3 mtIdentity();\n"
+	"__inline\n"
+	"b3Mat3x3 mtTranspose(b3Mat3x3 m);\n"
+	"__inline\n"
+	"b3Mat3x3 mtMul(b3Mat3x3 a, b3Mat3x3 b);\n"
+	"__inline\n"
+	"b3Float4 mtMul1(b3Mat3x3 a, b3Float4 b);\n"
+	"__inline\n"
+	"b3Float4 mtMul3(b3Float4 a, b3Mat3x3 b);\n"
+	"__inline\n"
+	"b3Mat3x3 mtZero()\n"
+	"{\n"
+	"	b3Mat3x3 m;\n"
+	"	m.m_row[0] = (b3Float4)(0.f);\n"
+	"	m.m_row[1] = (b3Float4)(0.f);\n"
+	"	m.m_row[2] = (b3Float4)(0.f);\n"
+	"	return m;\n"
+	"}\n"
+	"__inline\n"
+	"b3Mat3x3 mtIdentity()\n"
+	"{\n"
+	"	b3Mat3x3 m;\n"
+	"	m.m_row[0] = (b3Float4)(1,0,0,0);\n"
+	"	m.m_row[1] = (b3Float4)(0,1,0,0);\n"
+	"	m.m_row[2] = (b3Float4)(0,0,1,0);\n"
+	"	return m;\n"
+	"}\n"
+	"__inline\n"
+	"b3Mat3x3 mtTranspose(b3Mat3x3 m)\n"
+	"{\n"
+	"	b3Mat3x3 out;\n"
+	"	out.m_row[0] = (b3Float4)(m.m_row[0].x, m.m_row[1].x, m.m_row[2].x, 0.f);\n"
+	"	out.m_row[1] = (b3Float4)(m.m_row[0].y, m.m_row[1].y, m.m_row[2].y, 0.f);\n"
+	"	out.m_row[2] = (b3Float4)(m.m_row[0].z, m.m_row[1].z, m.m_row[2].z, 0.f);\n"
+	"	return out;\n"
+	"}\n"
+	"__inline\n"
+	"b3Mat3x3 mtMul(b3Mat3x3 a, b3Mat3x3 b)\n"
+	"{\n"
+	"	b3Mat3x3 transB;\n"
+	"	transB = mtTranspose( b );\n"
+	"	b3Mat3x3 ans;\n"
+	"	//	why this doesn't run when 0ing in the for{}\n"
+	"	a.m_row[0].w = 0.f;\n"
+	"	a.m_row[1].w = 0.f;\n"
+	"	a.m_row[2].w = 0.f;\n"
+	"	for(int i=0; i<3; i++)\n"
+	"	{\n"
+	"//	a.m_row[i].w = 0.f;\n"
+	"		ans.m_row[i].x = b3Dot3F4(a.m_row[i],transB.m_row[0]);\n"
+	"		ans.m_row[i].y = b3Dot3F4(a.m_row[i],transB.m_row[1]);\n"
+	"		ans.m_row[i].z = b3Dot3F4(a.m_row[i],transB.m_row[2]);\n"
+	"		ans.m_row[i].w = 0.f;\n"
+	"	}\n"
+	"	return ans;\n"
+	"}\n"
+	"__inline\n"
+	"b3Float4 mtMul1(b3Mat3x3 a, b3Float4 b)\n"
+	"{\n"
+	"	b3Float4 ans;\n"
+	"	ans.x = b3Dot3F4( a.m_row[0], b );\n"
+	"	ans.y = b3Dot3F4( a.m_row[1], b );\n"
+	"	ans.z = b3Dot3F4( a.m_row[2], b );\n"
+	"	ans.w = 0.f;\n"
+	"	return ans;\n"
+	"}\n"
+	"__inline\n"
+	"b3Float4 mtMul3(b3Float4 a, b3Mat3x3 b)\n"
+	"{\n"
+	"	b3Float4 colx = b3MakeFloat4(b.m_row[0].x, b.m_row[1].x, b.m_row[2].x, 0);\n"
+	"	b3Float4 coly = b3MakeFloat4(b.m_row[0].y, b.m_row[1].y, b.m_row[2].y, 0);\n"
+	"	b3Float4 colz = b3MakeFloat4(b.m_row[0].z, b.m_row[1].z, b.m_row[2].z, 0);\n"
+	"	b3Float4 ans;\n"
+	"	ans.x = b3Dot3F4( a, colx );\n"
+	"	ans.y = b3Dot3F4( a, coly );\n"
+	"	ans.z = b3Dot3F4( a, colz );\n"
+	"	return ans;\n"
+	"}\n"
+	"#endif\n"
+	"#endif //B3_MAT3x3_H\n"
+	"typedef struct b3Aabb b3Aabb_t;\n"
+	"struct b3Aabb\n"
+	"{\n"
+	"	union\n"
+	"	{\n"
+	"		float m_min[4];\n"
+	"		b3Float4 m_minVec;\n"
+	"		int m_minIndices[4];\n"
+	"	};\n"
+	"	union\n"
+	"	{\n"
+	"		float	m_max[4];\n"
+	"		b3Float4 m_maxVec;\n"
+	"		int m_signedMaxIndices[4];\n"
+	"	};\n"
+	"};\n"
+	"inline void b3TransformAabb2(b3Float4ConstArg localAabbMin,b3Float4ConstArg localAabbMax, float margin,\n"
+	"						b3Float4ConstArg pos,\n"
+	"						b3QuatConstArg orn,\n"
+	"						b3Float4* aabbMinOut,b3Float4* aabbMaxOut)\n"
+	"{\n"
+	"		b3Float4 localHalfExtents = 0.5f*(localAabbMax-localAabbMin);\n"
+	"		localHalfExtents+=b3MakeFloat4(margin,margin,margin,0.f);\n"
+	"		b3Float4 localCenter = 0.5f*(localAabbMax+localAabbMin);\n"
+	"		b3Mat3x3 m;\n"
+	"		m = b3QuatGetRotationMatrix(orn);\n"
+	"		b3Mat3x3 abs_b = b3AbsoluteMat3x3(m);\n"
+	"		b3Float4 center = b3TransformPoint(localCenter,pos,orn);\n"
+	"		\n"
+	"		b3Float4 extent = b3MakeFloat4(b3Dot3F4(localHalfExtents,b3GetRow(abs_b,0)),\n"
+	"										 b3Dot3F4(localHalfExtents,b3GetRow(abs_b,1)),\n"
+	"										 b3Dot3F4(localHalfExtents,b3GetRow(abs_b,2)),\n"
+	"										 0.f);\n"
+	"		*aabbMinOut = center-extent;\n"
+	"		*aabbMaxOut = center+extent;\n"
+	"}\n"
+	"/// conservative test for overlap between two aabbs\n"
+	"inline bool b3TestAabbAgainstAabb(b3Float4ConstArg aabbMin1,b3Float4ConstArg aabbMax1,\n"
+	"								b3Float4ConstArg aabbMin2, b3Float4ConstArg aabbMax2)\n"
+	"{\n"
+	"	bool overlap = true;\n"
+	"	overlap = (aabbMin1.x > aabbMax2.x || aabbMax1.x < aabbMin2.x) ? false : overlap;\n"
+	"	overlap = (aabbMin1.z > aabbMax2.z || aabbMax1.z < aabbMin2.z) ? false : overlap;\n"
+	"	overlap = (aabbMin1.y > aabbMax2.y || aabbMax1.y < aabbMin2.y) ? false : overlap;\n"
+	"	return overlap;\n"
+	"}\n"
+	"#endif //B3_AABB_H\n"
+	"/*\n"
+	"Bullet Continuous Collision Detection and Physics Library\n"
+	"Copyright (c) 2003-2013 Erwin Coumans  http://bulletphysics.org\n"
+	"This software is provided 'as-is', without any express or implied warranty.\n"
+	"In no event will the authors be held liable for any damages arising from the use of this software.\n"
+	"Permission is granted to anyone to use this software for any purpose,\n"
+	"including commercial applications, and to alter it and redistribute it freely,\n"
+	"subject to the following restrictions:\n"
+	"1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.\n"
+	"2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.\n"
+	"3. This notice may not be removed or altered from any source distribution.\n"
+	"*/\n"
+	"#ifndef B3_INT2_H\n"
+	"#define B3_INT2_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#define b3UnsignedInt2 uint2\n"
+	"#define b3Int2 int2\n"
+	"#define b3MakeInt2 (int2)\n"
+	"#endif //__cplusplus\n"
+	"#endif\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4 m_plane;\n"
+	"	int m_indexOffset;\n"
+	"	int m_numIndices;\n"
+	"} btGpuFace;\n"
+	"#define make_float4 (float4)\n"
+	"__inline\n"
+	"float4 cross3(float4 a, float4 b)\n"
+	"{\n"
+	"	return cross(a,b);\n"
+	"	\n"
+	"//	float4 a1 = make_float4(a.xyz,0.f);\n"
+	"//	float4 b1 = make_float4(b.xyz,0.f);\n"
+	"//	return cross(a1,b1);\n"
+	"//float4 c = make_float4(a.y*b.z - a.z*b.y,a.z*b.x - a.x*b.z,a.x*b.y - a.y*b.x,0.f);\n"
+	"	\n"
+	"	//	float4 c = make_float4(a.y*b.z - a.z*b.y,1.f,a.x*b.y - a.y*b.x,0.f);\n"
+	"	\n"
+	"	//return c;\n"
+	"}\n"
+	"__inline\n"
+	"float dot3F4(float4 a, float4 b)\n"
+	"{\n"
+	"	float4 a1 = make_float4(a.xyz,0.f);\n"
+	"	float4 b1 = make_float4(b.xyz,0.f);\n"
+	"	return dot(a1, b1);\n"
+	"}\n"
+	"__inline\n"
+	"float4 fastNormalize4(float4 v)\n"
+	"{\n"
+	"	v = make_float4(v.xyz,0.f);\n"
+	"	return fast_normalize(v);\n"
+	"}\n"
+	"///////////////////////////////////////\n"
+	"//	Quaternion\n"
+	"///////////////////////////////////////\n"
+	"typedef float4 Quaternion;\n"
+	"__inline\n"
+	"Quaternion qtMul(Quaternion a, Quaternion b);\n"
+	"__inline\n"
+	"Quaternion qtNormalize(Quaternion in);\n"
+	"__inline\n"
+	"float4 qtRotate(Quaternion q, float4 vec);\n"
+	"__inline\n"
+	"Quaternion qtInvert(Quaternion q);\n"
+	"__inline\n"
+	"Quaternion qtMul(Quaternion a, Quaternion b)\n"
+	"{\n"
+	"	Quaternion ans;\n"
+	"	ans = cross3( a, b );\n"
+	"	ans += a.w*b+b.w*a;\n"
+	"//	ans.w = a.w*b.w - (a.x*b.x+a.y*b.y+a.z*b.z);\n"
+	"	ans.w = a.w*b.w - dot3F4(a, b);\n"
+	"	return ans;\n"
+	"}\n"
+	"__inline\n"
+	"Quaternion qtNormalize(Quaternion in)\n"
+	"{\n"
+	"	return fastNormalize4(in);\n"
+	"//	in /= length( in );\n"
+	"//	return in;\n"
+	"}\n"
+	"__inline\n"
+	"float4 qtRotate(Quaternion q, float4 vec)\n"
+	"{\n"
+	"	Quaternion qInv = qtInvert( q );\n"
+	"	float4 vcpy = vec;\n"
+	"	vcpy.w = 0.f;\n"
+	"	float4 out = qtMul(qtMul(q,vcpy),qInv);\n"
+	"	return out;\n"
+	"}\n"
+	"__inline\n"
+	"Quaternion qtInvert(Quaternion q)\n"
+	"{\n"
+	"	return (Quaternion)(-q.xyz, q.w);\n"
+	"}\n"
+	"__inline\n"
+	"float4 qtInvRotate(const Quaternion q, float4 vec)\n"
+	"{\n"
+	"	return qtRotate( qtInvert( q ), vec );\n"
+	"}\n"
+	"__inline\n"
+	"float4 transform(const float4* p, const float4* translation, const Quaternion* orientation)\n"
+	"{\n"
+	"	return qtRotate( *orientation, *p ) + (*translation);\n"
+	"}\n"
+	"__inline\n"
+	"float4 normalize3(const float4 a)\n"
+	"{\n"
+	"	float4 n = make_float4(a.x, a.y, a.z, 0.f);\n"
+	"	return fastNormalize4( n );\n"
+	"}\n"
+	"inline void projectLocal(const ConvexPolyhedronCL* hull,  const float4 pos, const float4 orn, \n"
+	"const float4* dir, const float4* vertices, float* min, float* max)\n"
+	"{\n"
+	"	min[0] = FLT_MAX;\n"
+	"	max[0] = -FLT_MAX;\n"
+	"	int numVerts = hull->m_numVertices;\n"
+	"	const float4 localDir = qtInvRotate(orn,*dir);\n"
+	"	float offset = dot(pos,*dir);\n"
+	"	for(int i=0;i<numVerts;i++)\n"
+	"	{\n"
+	"		float dp = dot(vertices[hull->m_vertexOffset+i],localDir);\n"
+	"		if(dp < min[0])	\n"
+	"			min[0] = dp;\n"
+	"		if(dp > max[0])	\n"
+	"			max[0] = dp;\n"
+	"	}\n"
+	"	if(min[0]>max[0])\n"
+	"	{\n"
+	"		float tmp = min[0];\n"
+	"		min[0] = max[0];\n"
+	"		max[0] = tmp;\n"
+	"	}\n"
+	"	min[0] += offset;\n"
+	"	max[0] += offset;\n"
+	"}\n"
+	"inline void project(__global const ConvexPolyhedronCL* hull,  const float4 pos, const float4 orn, \n"
+	"const float4* dir, __global const float4* vertices, float* min, float* max)\n"
+	"{\n"
+	"	min[0] = FLT_MAX;\n"
+	"	max[0] = -FLT_MAX;\n"
+	"	int numVerts = hull->m_numVertices;\n"
+	"	const float4 localDir = qtInvRotate(orn,*dir);\n"
+	"	float offset = dot(pos,*dir);\n"
+	"	for(int i=0;i<numVerts;i++)\n"
+	"	{\n"
+	"		float dp = dot(vertices[hull->m_vertexOffset+i],localDir);\n"
+	"		if(dp < min[0])	\n"
+	"			min[0] = dp;\n"
+	"		if(dp > max[0])	\n"
+	"			max[0] = dp;\n"
+	"	}\n"
+	"	if(min[0]>max[0])\n"
+	"	{\n"
+	"		float tmp = min[0];\n"
+	"		min[0] = max[0];\n"
+	"		max[0] = tmp;\n"
+	"	}\n"
+	"	min[0] += offset;\n"
+	"	max[0] += offset;\n"
+	"}\n"
+	"inline bool TestSepAxisLocalA(const ConvexPolyhedronCL* hullA, __global const ConvexPolyhedronCL* hullB, \n"
+	"	const float4 posA,const float4 ornA,\n"
+	"	const float4 posB,const float4 ornB,\n"
+	"	float4* sep_axis, const float4* verticesA, __global const float4* verticesB,float* depth)\n"
+	"{\n"
+	"	float Min0,Max0;\n"
+	"	float Min1,Max1;\n"
+	"	projectLocal(hullA,posA,ornA,sep_axis,verticesA, &Min0, &Max0);\n"
+	"	project(hullB,posB,ornB, sep_axis,verticesB, &Min1, &Max1);\n"
+	"	if(Max0<Min1 || Max1<Min0)\n"
+	"		return false;\n"
+	"	float d0 = Max0 - Min1;\n"
+	"	float d1 = Max1 - Min0;\n"
+	"	*depth = d0<d1 ? d0:d1;\n"
+	"	return true;\n"
+	"}\n"
+	"inline bool IsAlmostZero(const float4 v)\n"
+	"{\n"
+	"	if(fabs(v.x)>1e-6f || fabs(v.y)>1e-6f || fabs(v.z)>1e-6f)\n"
+	"		return false;\n"
+	"	return true;\n"
+	"}\n"
+	"bool findSeparatingAxisLocalA(	const ConvexPolyhedronCL* hullA, __global const ConvexPolyhedronCL* hullB, \n"
+	"	const float4 posA1,\n"
+	"	const float4 ornA,\n"
+	"	const float4 posB1,\n"
+	"	const float4 ornB,\n"
+	"	const float4 DeltaC2,\n"
+	"	\n"
+	"	const float4* verticesA, \n"
+	"	const float4* uniqueEdgesA, \n"
+	"	const btGpuFace* facesA,\n"
+	"	const int*  indicesA,\n"
+	"	__global const float4* verticesB, \n"
+	"	__global const float4* uniqueEdgesB, \n"
+	"	__global const btGpuFace* facesB,\n"
+	"	__global const int*  indicesB,\n"
+	"	float4* sep,\n"
+	"	float* dmin)\n"
+	"{\n"
+	"	\n"
+	"	float4 posA = posA1;\n"
+	"	posA.w = 0.f;\n"
+	"	float4 posB = posB1;\n"
+	"	posB.w = 0.f;\n"
+	"	int curPlaneTests=0;\n"
+	"	{\n"
+	"		int numFacesA = hullA->m_numFaces;\n"
+	"		// Test normals from hullA\n"
+	"		for(int i=0;i<numFacesA;i++)\n"
+	"		{\n"
+	"			const float4 normal = facesA[hullA->m_faceOffset+i].m_plane;\n"
+	"			float4 faceANormalWS = qtRotate(ornA,normal);\n"
+	"			if (dot3F4(DeltaC2,faceANormalWS)<0)\n"
+	"				faceANormalWS*=-1.f;\n"
+	"			curPlaneTests++;\n"
+	"			float d;\n"
+	"			if(!TestSepAxisLocalA( hullA, hullB, posA,ornA,posB,ornB,&faceANormalWS, verticesA, verticesB,&d))\n"
+	"				return false;\n"
+	"			if(d<*dmin)\n"
+	"			{\n"
+	"				*dmin = d;\n"
+	"				*sep = faceANormalWS;\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"	if((dot3F4(-DeltaC2,*sep))>0.0f)\n"
+	"	{\n"
+	"		*sep = -(*sep);\n"
+	"	}\n"
+	"	return true;\n"
+	"}\n"
+	"bool findSeparatingAxisLocalB(	__global const ConvexPolyhedronCL* hullA,  const ConvexPolyhedronCL* hullB, \n"
+	"	const float4 posA1,\n"
+	"	const float4 ornA,\n"
+	"	const float4 posB1,\n"
+	"	const float4 ornB,\n"
+	"	const float4 DeltaC2,\n"
+	"	__global const float4* verticesA, \n"
+	"	__global const float4* uniqueEdgesA, \n"
+	"	__global const btGpuFace* facesA,\n"
+	"	__global const int*  indicesA,\n"
+	"	const float4* verticesB,\n"
+	"	const float4* uniqueEdgesB, \n"
+	"	const btGpuFace* facesB,\n"
+	"	const int*  indicesB,\n"
+	"	float4* sep,\n"
+	"	float* dmin)\n"
+	"{\n"
+	"	float4 posA = posA1;\n"
+	"	posA.w = 0.f;\n"
+	"	float4 posB = posB1;\n"
+	"	posB.w = 0.f;\n"
+	"	int curPlaneTests=0;\n"
+	"	{\n"
+	"		int numFacesA = hullA->m_numFaces;\n"
+	"		// Test normals from hullA\n"
+	"		for(int i=0;i<numFacesA;i++)\n"
+	"		{\n"
+	"			const float4 normal = facesA[hullA->m_faceOffset+i].m_plane;\n"
+	"			float4 faceANormalWS = qtRotate(ornA,normal);\n"
+	"			if (dot3F4(DeltaC2,faceANormalWS)<0)\n"
+	"				faceANormalWS *= -1.f;\n"
+	"			curPlaneTests++;\n"
+	"			float d;\n"
+	"			if(!TestSepAxisLocalA( hullB, hullA, posB,ornB,posA,ornA, &faceANormalWS, verticesB,verticesA, &d))\n"
+	"				return false;\n"
+	"			if(d<*dmin)\n"
+	"			{\n"
+	"				*dmin = d;\n"
+	"				*sep = faceANormalWS;\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"	if((dot3F4(-DeltaC2,*sep))>0.0f)\n"
+	"	{\n"
+	"		*sep = -(*sep);\n"
+	"	}\n"
+	"	return true;\n"
+	"}\n"
+	"bool findSeparatingAxisEdgeEdgeLocalA(	const ConvexPolyhedronCL* hullA, __global const ConvexPolyhedronCL* hullB, \n"
+	"	const float4 posA1,\n"
+	"	const float4 ornA,\n"
+	"	const float4 posB1,\n"
+	"	const float4 ornB,\n"
+	"	const float4 DeltaC2,\n"
+	"	const float4* verticesA, \n"
+	"	const float4* uniqueEdgesA, \n"
+	"	const btGpuFace* facesA,\n"
+	"	const int*  indicesA,\n"
+	"	__global const float4* verticesB, \n"
+	"	__global const float4* uniqueEdgesB, \n"
+	"	__global const btGpuFace* facesB,\n"
+	"	__global const int*  indicesB,\n"
+	"		float4* sep,\n"
+	"	float* dmin)\n"
+	"{\n"
+	"	float4 posA = posA1;\n"
+	"	posA.w = 0.f;\n"
+	"	float4 posB = posB1;\n"
+	"	posB.w = 0.f;\n"
+	"	int curPlaneTests=0;\n"
+	"	int curEdgeEdge = 0;\n"
+	"	// Test edges\n"
+	"	for(int e0=0;e0<hullA->m_numUniqueEdges;e0++)\n"
+	"	{\n"
+	"		const float4 edge0 = uniqueEdgesA[hullA->m_uniqueEdgesOffset+e0];\n"
+	"		float4 edge0World = qtRotate(ornA,edge0);\n"
+	"		for(int e1=0;e1<hullB->m_numUniqueEdges;e1++)\n"
+	"		{\n"
+	"			const float4 edge1 = uniqueEdgesB[hullB->m_uniqueEdgesOffset+e1];\n"
+	"			float4 edge1World = qtRotate(ornB,edge1);\n"
+	"			float4 crossje = cross3(edge0World,edge1World);\n"
+	"			curEdgeEdge++;\n"
+	"			if(!IsAlmostZero(crossje))\n"
+	"			{\n"
+	"				crossje = normalize3(crossje);\n"
+	"				if (dot3F4(DeltaC2,crossje)<0)\n"
+	"					crossje *= -1.f;\n"
+	"				float dist;\n"
+	"				bool result = true;\n"
+	"				{\n"
+	"					float Min0,Max0;\n"
+	"					float Min1,Max1;\n"
+	"					projectLocal(hullA,posA,ornA,&crossje,verticesA, &Min0, &Max0);\n"
+	"					project(hullB,posB,ornB,&crossje,verticesB, &Min1, &Max1);\n"
+	"				\n"
+	"					if(Max0<Min1 || Max1<Min0)\n"
+	"						result = false;\n"
+	"				\n"
+	"					float d0 = Max0 - Min1;\n"
+	"					float d1 = Max1 - Min0;\n"
+	"					dist = d0<d1 ? d0:d1;\n"
+	"					result = true;\n"
+	"				}\n"
+	"				\n"
+	"				if(dist<*dmin)\n"
+	"				{\n"
+	"					*dmin = dist;\n"
+	"					*sep = crossje;\n"
+	"				}\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"	\n"
+	"	if((dot3F4(-DeltaC2,*sep))>0.0f)\n"
+	"	{\n"
+	"		*sep = -(*sep);\n"
+	"	}\n"
+	"	return true;\n"
+	"}\n"
+	"inline bool TestSepAxis(__global const ConvexPolyhedronCL* hullA, __global const ConvexPolyhedronCL* hullB, \n"
+	"	const float4 posA,const float4 ornA,\n"
+	"	const float4 posB,const float4 ornB,\n"
+	"	float4* sep_axis, __global const float4* vertices,float* depth)\n"
+	"{\n"
+	"	float Min0,Max0;\n"
+	"	float Min1,Max1;\n"
+	"	project(hullA,posA,ornA,sep_axis,vertices, &Min0, &Max0);\n"
+	"	project(hullB,posB,ornB, sep_axis,vertices, &Min1, &Max1);\n"
+	"	if(Max0<Min1 || Max1<Min0)\n"
+	"		return false;\n"
+	"	float d0 = Max0 - Min1;\n"
+	"	float d1 = Max1 - Min0;\n"
+	"	*depth = d0<d1 ? d0:d1;\n"
+	"	return true;\n"
+	"}\n"
+	"bool findSeparatingAxis(	__global const ConvexPolyhedronCL* hullA, __global const ConvexPolyhedronCL* hullB, \n"
+	"	const float4 posA1,\n"
+	"	const float4 ornA,\n"
+	"	const float4 posB1,\n"
+	"	const float4 ornB,\n"
+	"	const float4 DeltaC2,\n"
+	"	__global const float4* vertices, \n"
+	"	__global const float4* uniqueEdges, \n"
+	"	__global const btGpuFace* faces,\n"
+	"	__global const int*  indices,\n"
+	"	float4* sep,\n"
+	"	float* dmin)\n"
+	"{\n"
+	"	\n"
+	"	float4 posA = posA1;\n"
+	"	posA.w = 0.f;\n"
+	"	float4 posB = posB1;\n"
+	"	posB.w = 0.f;\n"
+	"	\n"
+	"	int curPlaneTests=0;\n"
+	"	{\n"
+	"		int numFacesA = hullA->m_numFaces;\n"
+	"		// Test normals from hullA\n"
+	"		for(int i=0;i<numFacesA;i++)\n"
+	"		{\n"
+	"			const float4 normal = faces[hullA->m_faceOffset+i].m_plane;\n"
+	"			float4 faceANormalWS = qtRotate(ornA,normal);\n"
+	"	\n"
+	"			if (dot3F4(DeltaC2,faceANormalWS)<0)\n"
+	"				faceANormalWS*=-1.f;\n"
+	"				\n"
+	"			curPlaneTests++;\n"
+	"	\n"
+	"			float d;\n"
+	"			if(!TestSepAxis( hullA, hullB, posA,ornA,posB,ornB,&faceANormalWS, vertices,&d))\n"
+	"				return false;\n"
+	"	\n"
+	"			if(d<*dmin)\n"
+	"			{\n"
+	"				*dmin = d;\n"
+	"				*sep = faceANormalWS;\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"		if((dot3F4(-DeltaC2,*sep))>0.0f)\n"
+	"		{\n"
+	"			*sep = -(*sep);\n"
+	"		}\n"
+	"	\n"
+	"	return true;\n"
+	"}\n"
+	"bool findSeparatingAxisUnitSphere(	__global const ConvexPolyhedronCL* hullA, __global const ConvexPolyhedronCL* hullB, \n"
+	"	const float4 posA1,\n"
+	"	const float4 ornA,\n"
+	"	const float4 posB1,\n"
+	"	const float4 ornB,\n"
+	"	const float4 DeltaC2,\n"
+	"	__global const float4* vertices,\n"
+	"	__global const float4* unitSphereDirections,\n"
+	"	int numUnitSphereDirections,\n"
+	"	float4* sep,\n"
+	"	float* dmin)\n"
+	"{\n"
+	"	\n"
+	"	float4 posA = posA1;\n"
+	"	posA.w = 0.f;\n"
+	"	float4 posB = posB1;\n"
+	"	posB.w = 0.f;\n"
+	"	int curPlaneTests=0;\n"
+	"	int curEdgeEdge = 0;\n"
+	"	// Test unit sphere directions\n"
+	"	for (int i=0;i<numUnitSphereDirections;i++)\n"
+	"	{\n"
+	"		float4 crossje;\n"
+	"		crossje = unitSphereDirections[i];	\n"
+	"		if (dot3F4(DeltaC2,crossje)>0)\n"
+	"			crossje *= -1.f;\n"
+	"		{\n"
+	"			float dist;\n"
+	"			bool result = true;\n"
+	"			float Min0,Max0;\n"
+	"			float Min1,Max1;\n"
+	"			project(hullA,posA,ornA,&crossje,vertices, &Min0, &Max0);\n"
+	"			project(hullB,posB,ornB,&crossje,vertices, &Min1, &Max1);\n"
+	"		\n"
+	"			if(Max0<Min1 || Max1<Min0)\n"
+	"				return false;\n"
+	"		\n"
+	"			float d0 = Max0 - Min1;\n"
+	"			float d1 = Max1 - Min0;\n"
+	"			dist = d0<d1 ? d0:d1;\n"
+	"			result = true;\n"
+	"	\n"
+	"			if(dist<*dmin)\n"
+	"			{\n"
+	"				*dmin = dist;\n"
+	"				*sep = crossje;\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"	\n"
+	"	if((dot3F4(-DeltaC2,*sep))>0.0f)\n"
+	"	{\n"
+	"		*sep = -(*sep);\n"
+	"	}\n"
+	"	return true;\n"
+	"}\n"
+	"bool findSeparatingAxisEdgeEdge(	__global const ConvexPolyhedronCL* hullA, __global const ConvexPolyhedronCL* hullB, \n"
+	"	const float4 posA1,\n"
+	"	const float4 ornA,\n"
+	"	const float4 posB1,\n"
+	"	const float4 ornB,\n"
+	"	const float4 DeltaC2,\n"
+	"	__global const float4* vertices, \n"
+	"	__global const float4* uniqueEdges, \n"
+	"	__global const btGpuFace* faces,\n"
+	"	__global const int*  indices,\n"
+	"	float4* sep,\n"
+	"	float* dmin)\n"
+	"{\n"
+	"	\n"
+	"	float4 posA = posA1;\n"
+	"	posA.w = 0.f;\n"
+	"	float4 posB = posB1;\n"
+	"	posB.w = 0.f;\n"
+	"	int curPlaneTests=0;\n"
+	"	int curEdgeEdge = 0;\n"
+	"	// Test edges\n"
+	"	for(int e0=0;e0<hullA->m_numUniqueEdges;e0++)\n"
+	"	{\n"
+	"		const float4 edge0 = uniqueEdges[hullA->m_uniqueEdgesOffset+e0];\n"
+	"		float4 edge0World = qtRotate(ornA,edge0);\n"
+	"		for(int e1=0;e1<hullB->m_numUniqueEdges;e1++)\n"
+	"		{\n"
+	"			const float4 edge1 = uniqueEdges[hullB->m_uniqueEdgesOffset+e1];\n"
+	"			float4 edge1World = qtRotate(ornB,edge1);\n"
+	"			float4 crossje = cross3(edge0World,edge1World);\n"
+	"			curEdgeEdge++;\n"
+	"			if(!IsAlmostZero(crossje))\n"
+	"			{\n"
+	"				crossje = normalize3(crossje);\n"
+	"				if (dot3F4(DeltaC2,crossje)<0)\n"
+	"					crossje*=-1.f;\n"
+	"					\n"
+	"				float dist;\n"
+	"				bool result = true;\n"
+	"				{\n"
+	"					float Min0,Max0;\n"
+	"					float Min1,Max1;\n"
+	"					project(hullA,posA,ornA,&crossje,vertices, &Min0, &Max0);\n"
+	"					project(hullB,posB,ornB,&crossje,vertices, &Min1, &Max1);\n"
+	"				\n"
+	"					if(Max0<Min1 || Max1<Min0)\n"
+	"						return false;\n"
+	"				\n"
+	"					float d0 = Max0 - Min1;\n"
+	"					float d1 = Max1 - Min0;\n"
+	"					dist = d0<d1 ? d0:d1;\n"
+	"					result = true;\n"
+	"				}\n"
+	"				\n"
+	"				if(dist<*dmin)\n"
+	"				{\n"
+	"					*dmin = dist;\n"
+	"					*sep = crossje;\n"
+	"				}\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"	\n"
+	"	if((dot3F4(-DeltaC2,*sep))>0.0f)\n"
+	"	{\n"
+	"		*sep = -(*sep);\n"
+	"	}\n"
+	"	return true;\n"
+	"}\n"
+	"// work-in-progress\n"
+	"__kernel void   processCompoundPairsKernel( __global const int4* gpuCompoundPairs,\n"
+	"																					__global const BodyData* rigidBodies, \n"
+	"																					__global const btCollidableGpu* collidables,\n"
+	"																					__global const ConvexPolyhedronCL* convexShapes, \n"
+	"																					__global const float4* vertices,\n"
+	"																					__global const float4* uniqueEdges,\n"
+	"																					__global const btGpuFace* faces,\n"
+	"																					__global const int* indices,\n"
+	"																					__global btAabbCL* aabbs,\n"
+	"																					__global const btGpuChildShape* gpuChildShapes,\n"
+	"																					__global volatile float4* gpuCompoundSepNormalsOut,\n"
+	"																					__global volatile int* gpuHasCompoundSepNormalsOut,\n"
+	"																					int numCompoundPairs\n"
+	"																					)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	if (i<numCompoundPairs)\n"
+	"	{\n"
+	"		int bodyIndexA = gpuCompoundPairs[i].x;\n"
+	"		int bodyIndexB = gpuCompoundPairs[i].y;\n"
+	"		int childShapeIndexA = gpuCompoundPairs[i].z;\n"
+	"		int childShapeIndexB = gpuCompoundPairs[i].w;\n"
+	"		\n"
+	"		int collidableIndexA = -1;\n"
+	"		int collidableIndexB = -1;\n"
+	"		\n"
+	"		float4 ornA = rigidBodies[bodyIndexA].m_quat;\n"
+	"		float4 posA = rigidBodies[bodyIndexA].m_pos;\n"
+	"		\n"
+	"		float4 ornB = rigidBodies[bodyIndexB].m_quat;\n"
+	"		float4 posB = rigidBodies[bodyIndexB].m_pos;\n"
+	"							\n"
+	"		if (childShapeIndexA >= 0)\n"
+	"		{\n"
+	"			collidableIndexA = gpuChildShapes[childShapeIndexA].m_shapeIndex;\n"
+	"			float4 childPosA = gpuChildShapes[childShapeIndexA].m_childPosition;\n"
+	"			float4 childOrnA = gpuChildShapes[childShapeIndexA].m_childOrientation;\n"
+	"			float4 newPosA = qtRotate(ornA,childPosA)+posA;\n"
+	"			float4 newOrnA = qtMul(ornA,childOrnA);\n"
+	"			posA = newPosA;\n"
+	"			ornA = newOrnA;\n"
+	"		} else\n"
+	"		{\n"
+	"			collidableIndexA = rigidBodies[bodyIndexA].m_collidableIdx;\n"
+	"		}\n"
+	"		\n"
+	"		if (childShapeIndexB>=0)\n"
+	"		{\n"
+	"			collidableIndexB = gpuChildShapes[childShapeIndexB].m_shapeIndex;\n"
+	"			float4 childPosB = gpuChildShapes[childShapeIndexB].m_childPosition;\n"
+	"			float4 childOrnB = gpuChildShapes[childShapeIndexB].m_childOrientation;\n"
+	"			float4 newPosB = transform(&childPosB,&posB,&ornB);\n"
+	"			float4 newOrnB = qtMul(ornB,childOrnB);\n"
+	"			posB = newPosB;\n"
+	"			ornB = newOrnB;\n"
+	"		} else\n"
+	"		{\n"
+	"			collidableIndexB = rigidBodies[bodyIndexB].m_collidableIdx;	\n"
+	"		}\n"
+	"	\n"
+	"		gpuHasCompoundSepNormalsOut[i] = 0;\n"
+	"	\n"
+	"		int shapeIndexA = collidables[collidableIndexA].m_shapeIndex;\n"
+	"		int shapeIndexB = collidables[collidableIndexB].m_shapeIndex;\n"
+	"	\n"
+	"		int shapeTypeA = collidables[collidableIndexA].m_shapeType;\n"
+	"		int shapeTypeB = collidables[collidableIndexB].m_shapeType;\n"
+	"	\n"
+	"		if ((shapeTypeA != SHAPE_CONVEX_HULL) || (shapeTypeB != SHAPE_CONVEX_HULL))\n"
+	"		{\n"
+	"			return;\n"
+	"		}\n"
+	"		int hasSeparatingAxis = 5;\n"
+	"							\n"
+	"		int numFacesA = convexShapes[shapeIndexA].m_numFaces;\n"
+	"		float dmin = FLT_MAX;\n"
+	"		posA.w = 0.f;\n"
+	"		posB.w = 0.f;\n"
+	"		float4 c0local = convexShapes[shapeIndexA].m_localCenter;\n"
+	"		float4 c0 = transform(&c0local, &posA, &ornA);\n"
+	"		float4 c1local = convexShapes[shapeIndexB].m_localCenter;\n"
+	"		float4 c1 = transform(&c1local,&posB,&ornB);\n"
+	"		const float4 DeltaC2 = c0 - c1;\n"
+	"		float4 sepNormal = make_float4(1,0,0,0);\n"
+	"		bool sepA = findSeparatingAxis(	&convexShapes[shapeIndexA], &convexShapes[shapeIndexB],posA,ornA,posB,ornB,DeltaC2,vertices,uniqueEdges,faces,indices,&sepNormal,&dmin);\n"
+	"		hasSeparatingAxis = 4;\n"
+	"		if (!sepA)\n"
+	"		{\n"
+	"			hasSeparatingAxis = 0;\n"
+	"		} else\n"
+	"		{\n"
+	"			bool sepB = findSeparatingAxis(	&convexShapes[shapeIndexB],&convexShapes[shapeIndexA],posB,ornB,posA,ornA,DeltaC2,vertices,uniqueEdges,faces,indices,&sepNormal,&dmin);\n"
+	"			if (!sepB)\n"
+	"			{\n"
+	"				hasSeparatingAxis = 0;\n"
+	"			} else//(!sepB)\n"
+	"			{\n"
+	"				bool sepEE = findSeparatingAxisEdgeEdge(	&convexShapes[shapeIndexA], &convexShapes[shapeIndexB],posA,ornA,posB,ornB,DeltaC2,vertices,uniqueEdges,faces,indices,&sepNormal,&dmin);\n"
+	"				if (sepEE)\n"
+	"				{\n"
+	"						gpuCompoundSepNormalsOut[i] = sepNormal;//fastNormalize4(sepNormal);\n"
+	"						gpuHasCompoundSepNormalsOut[i] = 1;\n"
+	"				}//sepEE\n"
+	"			}//(!sepB)\n"
+	"		}//(!sepA)\n"
+	"		\n"
+	"		\n"
+	"	}\n"
+	"		\n"
+	"}\n"
+	"inline b3Float4 MyUnQuantize(const unsigned short* vecIn, b3Float4 quantization, b3Float4 bvhAabbMin)\n"
+	"{\n"
+	"		b3Float4 vecOut;\n"
+	"		vecOut = b3MakeFloat4(\n"
+	"			(float)(vecIn[0]) / (quantization.x),\n"
+	"			(float)(vecIn[1]) / (quantization.y),\n"
+	"			(float)(vecIn[2]) / (quantization.z),\n"
+	"			0.f);\n"
+	"		vecOut += bvhAabbMin;\n"
+	"		return vecOut;\n"
+	"}\n"
+	"inline b3Float4 MyUnQuantizeGlobal(__global const unsigned short* vecIn, b3Float4 quantization, b3Float4 bvhAabbMin)\n"
+	"{\n"
+	"		b3Float4 vecOut;\n"
+	"		vecOut = b3MakeFloat4(\n"
+	"			(float)(vecIn[0]) / (quantization.x),\n"
+	"			(float)(vecIn[1]) / (quantization.y),\n"
+	"			(float)(vecIn[2]) / (quantization.z),\n"
+	"			0.f);\n"
+	"		vecOut += bvhAabbMin;\n"
+	"		return vecOut;\n"
+	"}\n"
+	"// work-in-progress\n"
+	"__kernel void   findCompoundPairsKernel( __global const int4* pairs, \n"
+	"	__global const BodyData* rigidBodies, \n"
+	"	__global const btCollidableGpu* collidables,\n"
+	"	__global const ConvexPolyhedronCL* convexShapes, \n"
+	"	__global const float4* vertices,\n"
+	"	__global const float4* uniqueEdges,\n"
+	"	__global const btGpuFace* faces,\n"
+	"	__global const int* indices,\n"
+	"	__global b3Aabb_t* aabbLocalSpace,\n"
+	"	__global const btGpuChildShape* gpuChildShapes,\n"
+	"	__global volatile int4* gpuCompoundPairsOut,\n"
+	"	__global volatile int* numCompoundPairsOut,\n"
+	"	__global const b3BvhSubtreeInfo* subtrees,\n"
+	"	__global const b3QuantizedBvhNode* quantizedNodes,\n"
+	"	__global const b3BvhInfo* bvhInfos,\n"
+	"	int numPairs,\n"
+	"	int maxNumCompoundPairsCapacity\n"
+	"	)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	if (i<numPairs)\n"
+	"	{\n"
+	"		int bodyIndexA = pairs[i].x;\n"
+	"		int bodyIndexB = pairs[i].y;\n"
+	"		int collidableIndexA = rigidBodies[bodyIndexA].m_collidableIdx;\n"
+	"		int collidableIndexB = rigidBodies[bodyIndexB].m_collidableIdx;\n"
+	"		int shapeIndexA = collidables[collidableIndexA].m_shapeIndex;\n"
+	"		int shapeIndexB = collidables[collidableIndexB].m_shapeIndex;\n"
+	"		//once the broadphase avoids static-static pairs, we can remove this test\n"
+	"		if ((rigidBodies[bodyIndexA].m_invMass==0) &&(rigidBodies[bodyIndexB].m_invMass==0))\n"
+	"		{\n"
+	"			return;\n"
+	"		}\n"
+	"		if ((collidables[collidableIndexA].m_shapeType==SHAPE_COMPOUND_OF_CONVEX_HULLS) &&(collidables[collidableIndexB].m_shapeType==SHAPE_COMPOUND_OF_CONVEX_HULLS))\n"
+	"		{\n"
+	"			int bvhA = collidables[collidableIndexA].m_compoundBvhIndex;\n"
+	"			int bvhB = collidables[collidableIndexB].m_compoundBvhIndex;\n"
+	"			int numSubTreesA = bvhInfos[bvhA].m_numSubTrees;\n"
+	"			int subTreesOffsetA = bvhInfos[bvhA].m_subTreeOffset;\n"
+	"			int subTreesOffsetB = bvhInfos[bvhB].m_subTreeOffset;\n"
+	"			int numSubTreesB = bvhInfos[bvhB].m_numSubTrees;\n"
+	"			\n"
+	"			float4 posA = rigidBodies[bodyIndexA].m_pos;\n"
+	"			b3Quat ornA = rigidBodies[bodyIndexA].m_quat;\n"
+	"			b3Quat ornB = rigidBodies[bodyIndexB].m_quat;\n"
+	"			float4 posB = rigidBodies[bodyIndexB].m_pos;\n"
+	"			\n"
+	"			for (int p=0;p<numSubTreesA;p++)\n"
+	"			{\n"
+	"				b3BvhSubtreeInfo subtreeA = subtrees[subTreesOffsetA+p];\n"
+	"				//bvhInfos[bvhA].m_quantization\n"
+	"				b3Float4 treeAminLocal = MyUnQuantize(subtreeA.m_quantizedAabbMin,bvhInfos[bvhA].m_quantization,bvhInfos[bvhA].m_aabbMin);\n"
+	"				b3Float4 treeAmaxLocal = MyUnQuantize(subtreeA.m_quantizedAabbMax,bvhInfos[bvhA].m_quantization,bvhInfos[bvhA].m_aabbMin);\n"
+	"				b3Float4 aabbAMinOut,aabbAMaxOut;\n"
+	"				float margin=0.f;\n"
+	"				b3TransformAabb2(treeAminLocal,treeAmaxLocal, margin,posA,ornA,&aabbAMinOut,&aabbAMaxOut);\n"
+	"				\n"
+	"				for (int q=0;q<numSubTreesB;q++)\n"
+	"				{\n"
+	"					b3BvhSubtreeInfo subtreeB = subtrees[subTreesOffsetB+q];\n"
+	"					b3Float4 treeBminLocal = MyUnQuantize(subtreeB.m_quantizedAabbMin,bvhInfos[bvhB].m_quantization,bvhInfos[bvhB].m_aabbMin);\n"
+	"					b3Float4 treeBmaxLocal = MyUnQuantize(subtreeB.m_quantizedAabbMax,bvhInfos[bvhB].m_quantization,bvhInfos[bvhB].m_aabbMin);\n"
+	"					b3Float4 aabbBMinOut,aabbBMaxOut;\n"
+	"					float margin=0.f;\n"
+	"					b3TransformAabb2(treeBminLocal,treeBmaxLocal, margin,posB,ornB,&aabbBMinOut,&aabbBMaxOut);\n"
+	"					\n"
+	"					\n"
+	"					bool aabbOverlap = b3TestAabbAgainstAabb(aabbAMinOut,aabbAMaxOut,aabbBMinOut,aabbBMaxOut);\n"
+	"					if (aabbOverlap)\n"
+	"					{\n"
+	"						\n"
+	"						int startNodeIndexA = subtreeA.m_rootNodeIndex+bvhInfos[bvhA].m_nodeOffset;\n"
+	"						int endNodeIndexA = startNodeIndexA+subtreeA.m_subtreeSize;\n"
+	"						int startNodeIndexB = subtreeB.m_rootNodeIndex+bvhInfos[bvhB].m_nodeOffset;\n"
+	"						int endNodeIndexB = startNodeIndexB+subtreeB.m_subtreeSize;\n"
+	"						b3Int2 nodeStack[B3_MAX_STACK_DEPTH];\n"
+	"						b3Int2 node0;\n"
+	"						node0.x = startNodeIndexA;\n"
+	"						node0.y = startNodeIndexB;\n"
+	"						int maxStackDepth = B3_MAX_STACK_DEPTH;\n"
+	"						int depth=0;\n"
+	"						nodeStack[depth++]=node0;\n"
+	"						do\n"
+	"						{\n"
+	"							b3Int2 node = nodeStack[--depth];\n"
+	"							b3Float4 aMinLocal = MyUnQuantizeGlobal(quantizedNodes[node.x].m_quantizedAabbMin,bvhInfos[bvhA].m_quantization,bvhInfos[bvhA].m_aabbMin);\n"
+	"							b3Float4 aMaxLocal = MyUnQuantizeGlobal(quantizedNodes[node.x].m_quantizedAabbMax,bvhInfos[bvhA].m_quantization,bvhInfos[bvhA].m_aabbMin);\n"
+	"							b3Float4 bMinLocal = MyUnQuantizeGlobal(quantizedNodes[node.y].m_quantizedAabbMin,bvhInfos[bvhB].m_quantization,bvhInfos[bvhB].m_aabbMin);\n"
+	"							b3Float4 bMaxLocal = MyUnQuantizeGlobal(quantizedNodes[node.y].m_quantizedAabbMax,bvhInfos[bvhB].m_quantization,bvhInfos[bvhB].m_aabbMin);\n"
+	"							float margin=0.f;\n"
+	"							b3Float4 aabbAMinOut,aabbAMaxOut;\n"
+	"							b3TransformAabb2(aMinLocal,aMaxLocal, margin,posA,ornA,&aabbAMinOut,&aabbAMaxOut);\n"
+	"							b3Float4 aabbBMinOut,aabbBMaxOut;\n"
+	"							b3TransformAabb2(bMinLocal,bMaxLocal, margin,posB,ornB,&aabbBMinOut,&aabbBMaxOut);\n"
+	"							\n"
+	"							bool nodeOverlap = b3TestAabbAgainstAabb(aabbAMinOut,aabbAMaxOut,aabbBMinOut,aabbBMaxOut);\n"
+	"							if (nodeOverlap)\n"
+	"							{\n"
+	"								bool isLeafA = isLeafNodeGlobal(&quantizedNodes[node.x]);\n"
+	"								bool isLeafB = isLeafNodeGlobal(&quantizedNodes[node.y]);\n"
+	"								bool isInternalA = !isLeafA;\n"
+	"								bool isInternalB = !isLeafB;\n"
+	"								//fail, even though it might hit two leaf nodes\n"
+	"								if (depth+4>maxStackDepth && !(isLeafA && isLeafB))\n"
+	"								{\n"
+	"									//printf(\"Error: traversal exceeded maxStackDepth\");\n"
+	"									continue;\n"
+	"								}\n"
+	"								if(isInternalA)\n"
+	"								{\n"
+	"									int nodeAleftChild = node.x+1;\n"
+	"									bool isNodeALeftChildLeaf = isLeafNodeGlobal(&quantizedNodes[node.x+1]);\n"
+	"									int nodeArightChild = isNodeALeftChildLeaf? node.x+2 : node.x+1 + getEscapeIndexGlobal(&quantizedNodes[node.x+1]);\n"
+	"									if(isInternalB)\n"
+	"									{					\n"
+	"										int nodeBleftChild = node.y+1;\n"
+	"										bool isNodeBLeftChildLeaf = isLeafNodeGlobal(&quantizedNodes[node.y+1]);\n"
+	"										int nodeBrightChild = isNodeBLeftChildLeaf? node.y+2 : node.y+1 + getEscapeIndexGlobal(&quantizedNodes[node.y+1]);\n"
+	"										nodeStack[depth++] = b3MakeInt2(nodeAleftChild, nodeBleftChild);\n"
+	"										nodeStack[depth++] = b3MakeInt2(nodeArightChild, nodeBleftChild);\n"
+	"										nodeStack[depth++] = b3MakeInt2(nodeAleftChild, nodeBrightChild);\n"
+	"										nodeStack[depth++] = b3MakeInt2(nodeArightChild, nodeBrightChild);\n"
+	"									}\n"
+	"									else\n"
+	"									{\n"
+	"										nodeStack[depth++] = b3MakeInt2(nodeAleftChild,node.y);\n"
+	"										nodeStack[depth++] = b3MakeInt2(nodeArightChild,node.y);\n"
+	"									}\n"
+	"								}\n"
+	"								else\n"
+	"								{\n"
+	"									if(isInternalB)\n"
+	"									{\n"
+	"										int nodeBleftChild = node.y+1;\n"
+	"										bool isNodeBLeftChildLeaf = isLeafNodeGlobal(&quantizedNodes[node.y+1]);\n"
+	"										int nodeBrightChild = isNodeBLeftChildLeaf? node.y+2 : node.y+1 + getEscapeIndexGlobal(&quantizedNodes[node.y+1]);\n"
+	"										nodeStack[depth++] = b3MakeInt2(node.x,nodeBleftChild);\n"
+	"										nodeStack[depth++] = b3MakeInt2(node.x,nodeBrightChild);\n"
+	"									}\n"
+	"									else\n"
+	"									{\n"
+	"										int compoundPairIdx = atomic_inc(numCompoundPairsOut);\n"
+	"										if (compoundPairIdx<maxNumCompoundPairsCapacity)\n"
+	"										{\n"
+	"											int childShapeIndexA = getTriangleIndexGlobal(&quantizedNodes[node.x]);\n"
+	"											int childShapeIndexB = getTriangleIndexGlobal(&quantizedNodes[node.y]);\n"
+	"											gpuCompoundPairsOut[compoundPairIdx]  = (int4)(bodyIndexA,bodyIndexB,childShapeIndexA,childShapeIndexB);\n"
+	"										}\n"
+	"									}\n"
+	"								}\n"
+	"							}\n"
+	"						} while (depth);\n"
+	"					}\n"
+	"				}\n"
+	"			}\n"
+	"			\n"
+	"			return;\n"
+	"		}\n"
+	"		if ((collidables[collidableIndexA].m_shapeType==SHAPE_COMPOUND_OF_CONVEX_HULLS) ||(collidables[collidableIndexB].m_shapeType==SHAPE_COMPOUND_OF_CONVEX_HULLS))\n"
+	"		{\n"
+	"			if (collidables[collidableIndexA].m_shapeType==SHAPE_COMPOUND_OF_CONVEX_HULLS) \n"
+	"			{\n"
+	"				int numChildrenA = collidables[collidableIndexA].m_numChildShapes;\n"
+	"				for (int c=0;c<numChildrenA;c++)\n"
+	"				{\n"
+	"					int childShapeIndexA = collidables[collidableIndexA].m_shapeIndex+c;\n"
+	"					int childColIndexA = gpuChildShapes[childShapeIndexA].m_shapeIndex;\n"
+	"					float4 posA = rigidBodies[bodyIndexA].m_pos;\n"
+	"					float4 ornA = rigidBodies[bodyIndexA].m_quat;\n"
+	"					float4 childPosA = gpuChildShapes[childShapeIndexA].m_childPosition;\n"
+	"					float4 childOrnA = gpuChildShapes[childShapeIndexA].m_childOrientation;\n"
+	"					float4 newPosA = qtRotate(ornA,childPosA)+posA;\n"
+	"					float4 newOrnA = qtMul(ornA,childOrnA);\n"
+	"					int shapeIndexA = collidables[childColIndexA].m_shapeIndex;\n"
+	"					b3Aabb_t aabbAlocal = aabbLocalSpace[shapeIndexA];\n"
+	"					float margin = 0.f;\n"
+	"					\n"
+	"					b3Float4 aabbAMinWS;\n"
+	"					b3Float4 aabbAMaxWS;\n"
+	"					\n"
+	"					b3TransformAabb2(aabbAlocal.m_minVec,aabbAlocal.m_maxVec,margin,\n"
+	"						newPosA,\n"
+	"						newOrnA,\n"
+	"						&aabbAMinWS,&aabbAMaxWS);\n"
+	"						\n"
+	"					\n"
+	"					if (collidables[collidableIndexB].m_shapeType==SHAPE_COMPOUND_OF_CONVEX_HULLS)\n"
+	"					{\n"
+	"						int numChildrenB = collidables[collidableIndexB].m_numChildShapes;\n"
+	"						for (int b=0;b<numChildrenB;b++)\n"
+	"						{\n"
+	"							int childShapeIndexB = collidables[collidableIndexB].m_shapeIndex+b;\n"
+	"							int childColIndexB = gpuChildShapes[childShapeIndexB].m_shapeIndex;\n"
+	"							float4 ornB = rigidBodies[bodyIndexB].m_quat;\n"
+	"							float4 posB = rigidBodies[bodyIndexB].m_pos;\n"
+	"							float4 childPosB = gpuChildShapes[childShapeIndexB].m_childPosition;\n"
+	"							float4 childOrnB = gpuChildShapes[childShapeIndexB].m_childOrientation;\n"
+	"							float4 newPosB = transform(&childPosB,&posB,&ornB);\n"
+	"							float4 newOrnB = qtMul(ornB,childOrnB);\n"
+	"							int shapeIndexB = collidables[childColIndexB].m_shapeIndex;\n"
+	"							b3Aabb_t aabbBlocal = aabbLocalSpace[shapeIndexB];\n"
+	"							\n"
+	"							b3Float4 aabbBMinWS;\n"
+	"							b3Float4 aabbBMaxWS;\n"
+	"							\n"
+	"							b3TransformAabb2(aabbBlocal.m_minVec,aabbBlocal.m_maxVec,margin,\n"
+	"								newPosB,\n"
+	"								newOrnB,\n"
+	"								&aabbBMinWS,&aabbBMaxWS);\n"
+	"								\n"
+	"								\n"
+	"							\n"
+	"							bool aabbOverlap = b3TestAabbAgainstAabb(aabbAMinWS,aabbAMaxWS,aabbBMinWS,aabbBMaxWS);\n"
+	"							if (aabbOverlap)\n"
+	"							{\n"
+	"								int numFacesA = convexShapes[shapeIndexA].m_numFaces;\n"
+	"								float dmin = FLT_MAX;\n"
+	"								float4 posA = newPosA;\n"
+	"								posA.w = 0.f;\n"
+	"								float4 posB = newPosB;\n"
+	"								posB.w = 0.f;\n"
+	"								float4 c0local = convexShapes[shapeIndexA].m_localCenter;\n"
+	"								float4 ornA = newOrnA;\n"
+	"								float4 c0 = transform(&c0local, &posA, &ornA);\n"
+	"								float4 c1local = convexShapes[shapeIndexB].m_localCenter;\n"
+	"								float4 ornB =newOrnB;\n"
+	"								float4 c1 = transform(&c1local,&posB,&ornB);\n"
+	"								const float4 DeltaC2 = c0 - c1;\n"
+	"								{//\n"
+	"									int compoundPairIdx = atomic_inc(numCompoundPairsOut);\n"
+	"									if (compoundPairIdx<maxNumCompoundPairsCapacity)\n"
+	"									{\n"
+	"										gpuCompoundPairsOut[compoundPairIdx]  = (int4)(bodyIndexA,bodyIndexB,childShapeIndexA,childShapeIndexB);\n"
+	"									}\n"
+	"								}//\n"
+	"							}//fi(1)\n"
+	"						} //for (int b=0\n"
+	"					}//if (collidables[collidableIndexB].\n"
+	"					else//if (collidables[collidableIndexB].m_shapeType==SHAPE_COMPOUND_OF_CONVEX_HULLS)\n"
+	"					{\n"
+	"						if (1)\n"
+	"						{\n"
+	"							int numFacesA = convexShapes[shapeIndexA].m_numFaces;\n"
+	"							float dmin = FLT_MAX;\n"
+	"							float4 posA = newPosA;\n"
+	"							posA.w = 0.f;\n"
+	"							float4 posB = rigidBodies[bodyIndexB].m_pos;\n"
+	"							posB.w = 0.f;\n"
+	"							float4 c0local = convexShapes[shapeIndexA].m_localCenter;\n"
+	"							float4 ornA = newOrnA;\n"
+	"							float4 c0 = transform(&c0local, &posA, &ornA);\n"
+	"							float4 c1local = convexShapes[shapeIndexB].m_localCenter;\n"
+	"							float4 ornB = rigidBodies[bodyIndexB].m_quat;\n"
+	"							float4 c1 = transform(&c1local,&posB,&ornB);\n"
+	"							const float4 DeltaC2 = c0 - c1;\n"
+	"							{\n"
+	"								int compoundPairIdx = atomic_inc(numCompoundPairsOut);\n"
+	"								if (compoundPairIdx<maxNumCompoundPairsCapacity)\n"
+	"								{\n"
+	"									gpuCompoundPairsOut[compoundPairIdx] = (int4)(bodyIndexA,bodyIndexB,childShapeIndexA,-1);\n"
+	"								}//if (compoundPairIdx<maxNumCompoundPairsCapacity)\n"
+	"							}//\n"
+	"						}//fi (1)\n"
+	"					}//if (collidables[collidableIndexB].m_shapeType==SHAPE_COMPOUND_OF_CONVEX_HULLS)\n"
+	"				}//for (int b=0;b<numChildrenB;b++)	\n"
+	"				return;\n"
+	"			}//if (collidables[collidableIndexB].m_shapeType==SHAPE_COMPOUND_OF_CONVEX_HULLS)\n"
+	"			if ((collidables[collidableIndexA].m_shapeType!=SHAPE_CONCAVE_TRIMESH) \n"
+	"				&& (collidables[collidableIndexB].m_shapeType==SHAPE_COMPOUND_OF_CONVEX_HULLS))\n"
+	"			{\n"
+	"				int numChildrenB = collidables[collidableIndexB].m_numChildShapes;\n"
+	"				for (int b=0;b<numChildrenB;b++)\n"
+	"				{\n"
+	"					int childShapeIndexB = collidables[collidableIndexB].m_shapeIndex+b;\n"
+	"					int childColIndexB = gpuChildShapes[childShapeIndexB].m_shapeIndex;\n"
+	"					float4 ornB = rigidBodies[bodyIndexB].m_quat;\n"
+	"					float4 posB = rigidBodies[bodyIndexB].m_pos;\n"
+	"					float4 childPosB = gpuChildShapes[childShapeIndexB].m_childPosition;\n"
+	"					float4 childOrnB = gpuChildShapes[childShapeIndexB].m_childOrientation;\n"
+	"					float4 newPosB = qtRotate(ornB,childPosB)+posB;\n"
+	"					float4 newOrnB = qtMul(ornB,childOrnB);\n"
+	"					int shapeIndexB = collidables[childColIndexB].m_shapeIndex;\n"
+	"					//////////////////////////////////////\n"
+	"					if (1)\n"
+	"					{\n"
+	"						int numFacesA = convexShapes[shapeIndexA].m_numFaces;\n"
+	"						float dmin = FLT_MAX;\n"
+	"						float4 posA = rigidBodies[bodyIndexA].m_pos;\n"
+	"						posA.w = 0.f;\n"
+	"						float4 posB = newPosB;\n"
+	"						posB.w = 0.f;\n"
+	"						float4 c0local = convexShapes[shapeIndexA].m_localCenter;\n"
+	"						float4 ornA = rigidBodies[bodyIndexA].m_quat;\n"
+	"						float4 c0 = transform(&c0local, &posA, &ornA);\n"
+	"						float4 c1local = convexShapes[shapeIndexB].m_localCenter;\n"
+	"						float4 ornB =newOrnB;\n"
+	"						float4 c1 = transform(&c1local,&posB,&ornB);\n"
+	"						const float4 DeltaC2 = c0 - c1;\n"
+	"						{//\n"
+	"							int compoundPairIdx = atomic_inc(numCompoundPairsOut);\n"
+	"							if (compoundPairIdx<maxNumCompoundPairsCapacity)\n"
+	"							{\n"
+	"								gpuCompoundPairsOut[compoundPairIdx] = (int4)(bodyIndexA,bodyIndexB,-1,childShapeIndexB);\n"
+	"							}//fi (compoundPairIdx<maxNumCompoundPairsCapacity)\n"
+	"						}//\n"
+	"					}//fi (1)	\n"
+	"				}//for (int b=0;b<numChildrenB;b++)\n"
+	"				return;\n"
+	"			}//if (collidables[collidableIndexB].m_shapeType==SHAPE_COMPOUND_OF_CONVEX_HULLS)\n"
+	"			return;\n"
+	"		}//fi ((collidables[collidableIndexA].m_shapeType==SHAPE_COMPOUND_OF_CONVEX_HULLS) ||(collidables[collidableIndexB].m_shapeType==SHAPE_COMPOUND_OF_CONVEX_HULLS))\n"
+	"	}//i<numPairs\n"
+	"}\n"
+	"// work-in-progress\n"
+	"__kernel void   findSeparatingAxisKernel( __global const int4* pairs, \n"
+	"																					__global const BodyData* rigidBodies, \n"
+	"																					__global const btCollidableGpu* collidables,\n"
+	"																					__global const ConvexPolyhedronCL* convexShapes, \n"
+	"																					__global const float4* vertices,\n"
+	"																					__global const float4* uniqueEdges,\n"
+	"																					__global const btGpuFace* faces,\n"
+	"																					__global const int* indices,\n"
+	"																					__global btAabbCL* aabbs,\n"
+	"																					__global volatile float4* separatingNormals,\n"
+	"																					__global volatile int* hasSeparatingAxis,\n"
+	"																					int numPairs\n"
+	"																					)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	\n"
+	"	if (i<numPairs)\n"
+	"	{\n"
+	"	\n"
+	"		int bodyIndexA = pairs[i].x;\n"
+	"		int bodyIndexB = pairs[i].y;\n"
+	"		int collidableIndexA = rigidBodies[bodyIndexA].m_collidableIdx;\n"
+	"		int collidableIndexB = rigidBodies[bodyIndexB].m_collidableIdx;\n"
+	"	\n"
+	"		int shapeIndexA = collidables[collidableIndexA].m_shapeIndex;\n"
+	"		int shapeIndexB = collidables[collidableIndexB].m_shapeIndex;\n"
+	"		\n"
+	"		\n"
+	"		//once the broadphase avoids static-static pairs, we can remove this test\n"
+	"		if ((rigidBodies[bodyIndexA].m_invMass==0) &&(rigidBodies[bodyIndexB].m_invMass==0))\n"
+	"		{\n"
+	"			hasSeparatingAxis[i] = 0;\n"
+	"			return;\n"
+	"		}\n"
+	"		\n"
+	"		if ((collidables[collidableIndexA].m_shapeType!=SHAPE_CONVEX_HULL) ||(collidables[collidableIndexB].m_shapeType!=SHAPE_CONVEX_HULL))\n"
+	"		{\n"
+	"			hasSeparatingAxis[i] = 0;\n"
+	"			return;\n"
+	"		}\n"
+	"			\n"
+	"		if ((collidables[collidableIndexA].m_shapeType==SHAPE_CONCAVE_TRIMESH))\n"
+	"		{\n"
+	"			hasSeparatingAxis[i] = 0;\n"
+	"			return;\n"
+	"		}\n"
+	"		int numFacesA = convexShapes[shapeIndexA].m_numFaces;\n"
+	"		float dmin = FLT_MAX;\n"
+	"		float4 posA = rigidBodies[bodyIndexA].m_pos;\n"
+	"		posA.w = 0.f;\n"
+	"		float4 posB = rigidBodies[bodyIndexB].m_pos;\n"
+	"		posB.w = 0.f;\n"
+	"		float4 c0local = convexShapes[shapeIndexA].m_localCenter;\n"
+	"		float4 ornA = rigidBodies[bodyIndexA].m_quat;\n"
+	"		float4 c0 = transform(&c0local, &posA, &ornA);\n"
+	"		float4 c1local = convexShapes[shapeIndexB].m_localCenter;\n"
+	"		float4 ornB =rigidBodies[bodyIndexB].m_quat;\n"
+	"		float4 c1 = transform(&c1local,&posB,&ornB);\n"
+	"		const float4 DeltaC2 = c0 - c1;\n"
+	"		float4 sepNormal;\n"
+	"		\n"
+	"		bool sepA = findSeparatingAxis(	&convexShapes[shapeIndexA], &convexShapes[shapeIndexB],posA,ornA,\n"
+	"																								posB,ornB,\n"
+	"																								DeltaC2,\n"
+	"																								vertices,uniqueEdges,faces,\n"
+	"																								indices,&sepNormal,&dmin);\n"
+	"		hasSeparatingAxis[i] = 4;\n"
+	"		if (!sepA)\n"
+	"		{\n"
+	"			hasSeparatingAxis[i] = 0;\n"
+	"		} else\n"
+	"		{\n"
+	"			bool sepB = findSeparatingAxis(	&convexShapes[shapeIndexB],&convexShapes[shapeIndexA],posB,ornB,\n"
+	"																									posA,ornA,\n"
+	"																									DeltaC2,\n"
+	"																									vertices,uniqueEdges,faces,\n"
+	"																									indices,&sepNormal,&dmin);\n"
+	"			if (!sepB)\n"
+	"			{\n"
+	"				hasSeparatingAxis[i] = 0;\n"
+	"			} else\n"
+	"			{\n"
+	"				bool sepEE = findSeparatingAxisEdgeEdge(	&convexShapes[shapeIndexA], &convexShapes[shapeIndexB],posA,ornA,\n"
+	"																									posB,ornB,\n"
+	"																									DeltaC2,\n"
+	"																									vertices,uniqueEdges,faces,\n"
+	"																									indices,&sepNormal,&dmin);\n"
+	"				if (!sepEE)\n"
+	"				{\n"
+	"					hasSeparatingAxis[i] = 0;\n"
+	"				} else\n"
+	"				{\n"
+	"					hasSeparatingAxis[i] = 1;\n"
+	"					separatingNormals[i] = sepNormal;\n"
+	"				}\n"
+	"			}\n"
+	"		}\n"
+	"		\n"
+	"	}\n"
+	"}\n"
+	"__kernel void   findSeparatingAxisVertexFaceKernel( __global const int4* pairs, \n"
+	"																					__global const BodyData* rigidBodies, \n"
+	"																					__global const btCollidableGpu* collidables,\n"
+	"																					__global const ConvexPolyhedronCL* convexShapes, \n"
+	"																					__global const float4* vertices,\n"
+	"																					__global const float4* uniqueEdges,\n"
+	"																					__global const btGpuFace* faces,\n"
+	"																					__global const int* indices,\n"
+	"																					__global btAabbCL* aabbs,\n"
+	"																					__global volatile float4* separatingNormals,\n"
+	"																					__global volatile int* hasSeparatingAxis,\n"
+	"																					__global  float* dmins,\n"
+	"																					int numPairs\n"
+	"																					)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	\n"
+	"	if (i<numPairs)\n"
+	"	{\n"
+	"	\n"
+	"		int bodyIndexA = pairs[i].x;\n"
+	"		int bodyIndexB = pairs[i].y;\n"
+	"		int collidableIndexA = rigidBodies[bodyIndexA].m_collidableIdx;\n"
+	"		int collidableIndexB = rigidBodies[bodyIndexB].m_collidableIdx;\n"
+	"	\n"
+	"		int shapeIndexA = collidables[collidableIndexA].m_shapeIndex;\n"
+	"		int shapeIndexB = collidables[collidableIndexB].m_shapeIndex;\n"
+	"	\n"
+	"		hasSeparatingAxis[i] = 0;	\n"
+	"		\n"
+	"		//once the broadphase avoids static-static pairs, we can remove this test\n"
+	"		if ((rigidBodies[bodyIndexA].m_invMass==0) &&(rigidBodies[bodyIndexB].m_invMass==0))\n"
+	"		{\n"
+	"			return;\n"
+	"		}\n"
+	"		\n"
+	"		if ((collidables[collidableIndexA].m_shapeType!=SHAPE_CONVEX_HULL) ||(collidables[collidableIndexB].m_shapeType!=SHAPE_CONVEX_HULL))\n"
+	"		{\n"
+	"			return;\n"
+	"		}\n"
+	"			\n"
+	"		int numFacesA = convexShapes[shapeIndexA].m_numFaces;\n"
+	"		float dmin = FLT_MAX;\n"
+	"		dmins[i] = dmin;\n"
+	"		\n"
+	"		float4 posA = rigidBodies[bodyIndexA].m_pos;\n"
+	"		posA.w = 0.f;\n"
+	"		float4 posB = rigidBodies[bodyIndexB].m_pos;\n"
+	"		posB.w = 0.f;\n"
+	"		float4 c0local = convexShapes[shapeIndexA].m_localCenter;\n"
+	"		float4 ornA = rigidBodies[bodyIndexA].m_quat;\n"
+	"		float4 c0 = transform(&c0local, &posA, &ornA);\n"
+	"		float4 c1local = convexShapes[shapeIndexB].m_localCenter;\n"
+	"		float4 ornB =rigidBodies[bodyIndexB].m_quat;\n"
+	"		float4 c1 = transform(&c1local,&posB,&ornB);\n"
+	"		const float4 DeltaC2 = c0 - c1;\n"
+	"		float4 sepNormal;\n"
+	"		\n"
+	"		bool sepA = findSeparatingAxis(	&convexShapes[shapeIndexA], &convexShapes[shapeIndexB],posA,ornA,\n"
+	"																								posB,ornB,\n"
+	"																								DeltaC2,\n"
+	"																								vertices,uniqueEdges,faces,\n"
+	"																								indices,&sepNormal,&dmin);\n"
+	"		hasSeparatingAxis[i] = 4;\n"
+	"		if (!sepA)\n"
+	"		{\n"
+	"			hasSeparatingAxis[i] = 0;\n"
+	"		} else\n"
+	"		{\n"
+	"			bool sepB = findSeparatingAxis(	&convexShapes[shapeIndexB],&convexShapes[shapeIndexA],posB,ornB,\n"
+	"																									posA,ornA,\n"
+	"																									DeltaC2,\n"
+	"																									vertices,uniqueEdges,faces,\n"
+	"																									indices,&sepNormal,&dmin);\n"
+	"			if (sepB)\n"
+	"			{\n"
+	"				dmins[i] = dmin;\n"
+	"				hasSeparatingAxis[i] = 1;\n"
+	"				separatingNormals[i] = sepNormal;\n"
+	"			}\n"
+	"		}\n"
+	"		\n"
+	"	}\n"
+	"}\n"
+	"__kernel void   findSeparatingAxisEdgeEdgeKernel( __global const int4* pairs, \n"
+	"																					__global const BodyData* rigidBodies, \n"
+	"																					__global const btCollidableGpu* collidables,\n"
+	"																					__global const ConvexPolyhedronCL* convexShapes, \n"
+	"																					__global const float4* vertices,\n"
+	"																					__global const float4* uniqueEdges,\n"
+	"																					__global const btGpuFace* faces,\n"
+	"																					__global const int* indices,\n"
+	"																					__global btAabbCL* aabbs,\n"
+	"																					__global  float4* separatingNormals,\n"
+	"																					__global  int* hasSeparatingAxis,\n"
+	"																					__global  float* dmins,\n"
+	"																					__global const float4* unitSphereDirections,\n"
+	"																					int numUnitSphereDirections,\n"
+	"																					int numPairs\n"
+	"																					)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	\n"
+	"	if (i<numPairs)\n"
+	"	{\n"
+	"		if (hasSeparatingAxis[i])\n"
+	"		{\n"
+	"	\n"
+	"			int bodyIndexA = pairs[i].x;\n"
+	"			int bodyIndexB = pairs[i].y;\n"
+	"	\n"
+	"			int collidableIndexA = rigidBodies[bodyIndexA].m_collidableIdx;\n"
+	"			int collidableIndexB = rigidBodies[bodyIndexB].m_collidableIdx;\n"
+	"		\n"
+	"			int shapeIndexA = collidables[collidableIndexA].m_shapeIndex;\n"
+	"			int shapeIndexB = collidables[collidableIndexB].m_shapeIndex;\n"
+	"			\n"
+	"			\n"
+	"			int numFacesA = convexShapes[shapeIndexA].m_numFaces;\n"
+	"	\n"
+	"			float dmin = dmins[i];\n"
+	"	\n"
+	"			float4 posA = rigidBodies[bodyIndexA].m_pos;\n"
+	"			posA.w = 0.f;\n"
+	"			float4 posB = rigidBodies[bodyIndexB].m_pos;\n"
+	"			posB.w = 0.f;\n"
+	"			float4 c0local = convexShapes[shapeIndexA].m_localCenter;\n"
+	"			float4 ornA = rigidBodies[bodyIndexA].m_quat;\n"
+	"			float4 c0 = transform(&c0local, &posA, &ornA);\n"
+	"			float4 c1local = convexShapes[shapeIndexB].m_localCenter;\n"
+	"			float4 ornB =rigidBodies[bodyIndexB].m_quat;\n"
+	"			float4 c1 = transform(&c1local,&posB,&ornB);\n"
+	"			const float4 DeltaC2 = c0 - c1;\n"
+	"			float4 sepNormal = separatingNormals[i];\n"
+	"			\n"
+	"			\n"
+	"			\n"
+	"			bool sepEE = false;\n"
+	"			int numEdgeEdgeDirections = convexShapes[shapeIndexA].m_numUniqueEdges*convexShapes[shapeIndexB].m_numUniqueEdges;\n"
+	"			if (numEdgeEdgeDirections<=numUnitSphereDirections)\n"
+	"			{\n"
+	"				sepEE = findSeparatingAxisEdgeEdge(	&convexShapes[shapeIndexA], &convexShapes[shapeIndexB],posA,ornA,\n"
+	"																									posB,ornB,\n"
+	"																									DeltaC2,\n"
+	"																									vertices,uniqueEdges,faces,\n"
+	"																									indices,&sepNormal,&dmin);\n"
+	"																									\n"
+	"					if (!sepEE)\n"
+	"					{\n"
+	"						hasSeparatingAxis[i] = 0;\n"
+	"					} else\n"
+	"					{\n"
+	"						hasSeparatingAxis[i] = 1;\n"
+	"						separatingNormals[i] = sepNormal;\n"
+	"					}\n"
+	"			}\n"
+	"			/*\n"
+	"			///else case is a separate kernel, to make Mac OSX OpenCL compiler happy\n"
+	"			else\n"
+	"			{\n"
+	"				sepEE = findSeparatingAxisUnitSphere(&convexShapes[shapeIndexA], &convexShapes[shapeIndexB],posA,ornA,\n"
+	"																									posB,ornB,\n"
+	"																									DeltaC2,\n"
+	"																									vertices,unitSphereDirections,numUnitSphereDirections,\n"
+	"																									&sepNormal,&dmin);\n"
+	"					if (!sepEE)\n"
+	"					{\n"
+	"						hasSeparatingAxis[i] = 0;\n"
+	"					} else\n"
+	"					{\n"
+	"						hasSeparatingAxis[i] = 1;\n"
+	"						separatingNormals[i] = sepNormal;\n"
+	"					}\n"
+	"			}\n"
+	"			*/\n"
+	"		}		//if (hasSeparatingAxis[i])\n"
+	"	}//(i<numPairs)\n"
+	"}\n"
+	"inline int	findClippingFaces(const float4 separatingNormal,\n"
+	"                      const ConvexPolyhedronCL* hullA, \n"
+	"					  __global const ConvexPolyhedronCL* hullB,\n"
+	"                      const float4 posA, const Quaternion ornA,const float4 posB, const Quaternion ornB,\n"
+	"                       __global float4* worldVertsA1,\n"
+	"                      __global float4* worldNormalsA1,\n"
+	"                      __global float4* worldVertsB1,\n"
+	"                      int capacityWorldVerts,\n"
+	"                      const float minDist, float maxDist,\n"
+	"					  const float4* verticesA,\n"
+	"                      const btGpuFace* facesA,\n"
+	"                      const int* indicesA,\n"
+	"					  __global const float4* verticesB,\n"
+	"                      __global const btGpuFace* facesB,\n"
+	"                      __global const int* indicesB,\n"
+	"                      __global int4* clippingFaces, int pairIndex)\n"
+	"{\n"
+	"	int numContactsOut = 0;\n"
+	"	int numWorldVertsB1= 0;\n"
+	"    \n"
+	"    \n"
+	"	int closestFaceB=0;\n"
+	"	float dmax = -FLT_MAX;\n"
+	"    \n"
+	"	{\n"
+	"		for(int face=0;face<hullB->m_numFaces;face++)\n"
+	"		{\n"
+	"			const float4 Normal = make_float4(facesB[hullB->m_faceOffset+face].m_plane.x,\n"
+	"                                              facesB[hullB->m_faceOffset+face].m_plane.y, facesB[hullB->m_faceOffset+face].m_plane.z,0.f);\n"
+	"			const float4 WorldNormal = qtRotate(ornB, Normal);\n"
+	"			float d = dot3F4(WorldNormal,separatingNormal);\n"
+	"			if (d > dmax)\n"
+	"			{\n"
+	"				dmax = d;\n"
+	"				closestFaceB = face;\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"    \n"
+	"	{\n"
+	"		const btGpuFace polyB = facesB[hullB->m_faceOffset+closestFaceB];\n"
+	"		int numVertices = polyB.m_numIndices;\n"
+	"        if (numVertices>capacityWorldVerts)\n"
+	"            numVertices = capacityWorldVerts;\n"
+	"        \n"
+	"		for(int e0=0;e0<numVertices;e0++)\n"
+	"		{\n"
+	"            if (e0<capacityWorldVerts)\n"
+	"            {\n"
+	"                const float4 b = verticesB[hullB->m_vertexOffset+indicesB[polyB.m_indexOffset+e0]];\n"
+	"                worldVertsB1[pairIndex*capacityWorldVerts+numWorldVertsB1++] = transform(&b,&posB,&ornB);\n"
+	"            }\n"
+	"		}\n"
+	"	}\n"
+	"    \n"
+	"    int closestFaceA=0;\n"
+	"	{\n"
+	"		float dmin = FLT_MAX;\n"
+	"		for(int face=0;face<hullA->m_numFaces;face++)\n"
+	"		{\n"
+	"			const float4 Normal = make_float4(\n"
+	"                                              facesA[hullA->m_faceOffset+face].m_plane.x,\n"
+	"                                              facesA[hullA->m_faceOffset+face].m_plane.y,\n"
+	"                                              facesA[hullA->m_faceOffset+face].m_plane.z,\n"
+	"                                              0.f);\n"
+	"			const float4 faceANormalWS = qtRotate(ornA,Normal);\n"
+	"            \n"
+	"			float d = dot3F4(faceANormalWS,separatingNormal);\n"
+	"			if (d < dmin)\n"
+	"			{\n"
+	"				dmin = d;\n"
+	"				closestFaceA = face;\n"
+	"                worldNormalsA1[pairIndex] = faceANormalWS;\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"    \n"
+	"    int numVerticesA = facesA[hullA->m_faceOffset+closestFaceA].m_numIndices;\n"
+	"    if (numVerticesA>capacityWorldVerts)\n"
+	"       numVerticesA = capacityWorldVerts;\n"
+	"    \n"
+	"	for(int e0=0;e0<numVerticesA;e0++)\n"
+	"	{\n"
+	"        if (e0<capacityWorldVerts)\n"
+	"        {\n"
+	"            const float4 a = verticesA[hullA->m_vertexOffset+indicesA[facesA[hullA->m_faceOffset+closestFaceA].m_indexOffset+e0]];\n"
+	"            worldVertsA1[pairIndex*capacityWorldVerts+e0] = transform(&a, &posA,&ornA);\n"
+	"        }\n"
+	"    }\n"
+	"    \n"
+	"    clippingFaces[pairIndex].x = closestFaceA;\n"
+	"    clippingFaces[pairIndex].y = closestFaceB;\n"
+	"    clippingFaces[pairIndex].z = numVerticesA;\n"
+	"    clippingFaces[pairIndex].w = numWorldVertsB1;\n"
+	"    \n"
+	"    \n"
+	"	return numContactsOut;\n"
+	"}\n"
+	"// work-in-progress\n"
+	"__kernel void   findConcaveSeparatingAxisKernel( __global int4* concavePairs,\n"
+	"																					__global const BodyData* rigidBodies,\n"
+	"																					__global const btCollidableGpu* collidables,\n"
+	"																					__global const ConvexPolyhedronCL* convexShapes, \n"
+	"																					__global const float4* vertices,\n"
+	"																					__global const float4* uniqueEdges,\n"
+	"																					__global const btGpuFace* faces,\n"
+	"																					__global const int* indices,\n"
+	"																					__global const btGpuChildShape* gpuChildShapes,\n"
+	"																					__global btAabbCL* aabbs,\n"
+	"																					__global float4* concaveSeparatingNormalsOut,\n"
+	"																					__global int* concaveHasSeparatingNormals,\n"
+	"																					__global int4* clippingFacesOut,\n"
+	"																					__global float4* worldVertsA1GPU,\n"
+	"																					__global float4*  worldNormalsAGPU,\n"
+	"																					__global float4* worldVertsB1GPU,\n"
+	"																					int vertexFaceCapacity,\n"
+	"																					int numConcavePairs\n"
+	"																					)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	if (i>=numConcavePairs)\n"
+	"		return;\n"
+	"	concaveHasSeparatingNormals[i] = 0;\n"
+	"	int pairIdx = i;\n"
+	"	int bodyIndexA = concavePairs[i].x;\n"
+	"	int bodyIndexB = concavePairs[i].y;\n"
+	"	int collidableIndexA = rigidBodies[bodyIndexA].m_collidableIdx;\n"
+	"	int collidableIndexB = rigidBodies[bodyIndexB].m_collidableIdx;\n"
+	"	int shapeIndexA = collidables[collidableIndexA].m_shapeIndex;\n"
+	"	int shapeIndexB = collidables[collidableIndexB].m_shapeIndex;\n"
+	"	if (collidables[collidableIndexB].m_shapeType!=SHAPE_CONVEX_HULL&&\n"
+	"		collidables[collidableIndexB].m_shapeType!=SHAPE_COMPOUND_OF_CONVEX_HULLS)\n"
+	"	{\n"
+	"		concavePairs[pairIdx].w = -1;\n"
+	"		return;\n"
+	"	}\n"
+	"	int numFacesA = convexShapes[shapeIndexA].m_numFaces;\n"
+	"	int numActualConcaveConvexTests = 0;\n"
+	"	\n"
+	"	int f = concavePairs[i].z;\n"
+	"	\n"
+	"	bool overlap = false;\n"
+	"	\n"
+	"	ConvexPolyhedronCL convexPolyhedronA;\n"
+	"	//add 3 vertices of the triangle\n"
+	"	convexPolyhedronA.m_numVertices = 3;\n"
+	"	convexPolyhedronA.m_vertexOffset = 0;\n"
+	"	float4	localCenter = make_float4(0.f,0.f,0.f,0.f);\n"
+	"	btGpuFace face = faces[convexShapes[shapeIndexA].m_faceOffset+f];\n"
+	"	float4 triMinAabb, triMaxAabb;\n"
+	"	btAabbCL triAabb;\n"
+	"	triAabb.m_min = make_float4(1e30f,1e30f,1e30f,0.f);\n"
+	"	triAabb.m_max = make_float4(-1e30f,-1e30f,-1e30f,0.f);\n"
+	"	\n"
+	"	float4 verticesA[3];\n"
+	"	for (int i=0;i<3;i++)\n"
+	"	{\n"
+	"		int index = indices[face.m_indexOffset+i];\n"
+	"		float4 vert = vertices[convexShapes[shapeIndexA].m_vertexOffset+index];\n"
+	"		verticesA[i] = vert;\n"
+	"		localCenter += vert;\n"
+	"			\n"
+	"		triAabb.m_min = min(triAabb.m_min,vert);		\n"
+	"		triAabb.m_max = max(triAabb.m_max,vert);		\n"
+	"	}\n"
+	"	overlap = true;\n"
+	"	overlap = (triAabb.m_min.x > aabbs[bodyIndexB].m_max.x || triAabb.m_max.x < aabbs[bodyIndexB].m_min.x) ? false : overlap;\n"
+	"	overlap = (triAabb.m_min.z > aabbs[bodyIndexB].m_max.z || triAabb.m_max.z < aabbs[bodyIndexB].m_min.z) ? false : overlap;\n"
+	"	overlap = (triAabb.m_min.y > aabbs[bodyIndexB].m_max.y || triAabb.m_max.y < aabbs[bodyIndexB].m_min.y) ? false : overlap;\n"
+	"		\n"
+	"	if (overlap)\n"
+	"	{\n"
+	"		float dmin = FLT_MAX;\n"
+	"		int hasSeparatingAxis=5;\n"
+	"		float4 sepAxis=make_float4(1,2,3,4);\n"
+	"		int localCC=0;\n"
+	"		numActualConcaveConvexTests++;\n"
+	"		//a triangle has 3 unique edges\n"
+	"		convexPolyhedronA.m_numUniqueEdges = 3;\n"
+	"		convexPolyhedronA.m_uniqueEdgesOffset = 0;\n"
+	"		float4 uniqueEdgesA[3];\n"
+	"		\n"
+	"		uniqueEdgesA[0] = (verticesA[1]-verticesA[0]);\n"
+	"		uniqueEdgesA[1] = (verticesA[2]-verticesA[1]);\n"
+	"		uniqueEdgesA[2] = (verticesA[0]-verticesA[2]);\n"
+	"		convexPolyhedronA.m_faceOffset = 0;\n"
+	"                                  \n"
+	"		float4 normal = make_float4(face.m_plane.x,face.m_plane.y,face.m_plane.z,0.f);\n"
+	"                             \n"
+	"		btGpuFace facesA[TRIANGLE_NUM_CONVEX_FACES];\n"
+	"		int indicesA[3+3+2+2+2];\n"
+	"		int curUsedIndices=0;\n"
+	"		int fidx=0;\n"
+	"		//front size of triangle\n"
+	"		{\n"
+	"			facesA[fidx].m_indexOffset=curUsedIndices;\n"
+	"			indicesA[0] = 0;\n"
+	"			indicesA[1] = 1;\n"
+	"			indicesA[2] = 2;\n"
+	"			curUsedIndices+=3;\n"
+	"			float c = face.m_plane.w;\n"
+	"			facesA[fidx].m_plane.x = normal.x;\n"
+	"			facesA[fidx].m_plane.y = normal.y;\n"
+	"			facesA[fidx].m_plane.z = normal.z;\n"
+	"			facesA[fidx].m_plane.w = c;\n"
+	"			facesA[fidx].m_numIndices=3;\n"
+	"		}\n"
+	"		fidx++;\n"
+	"		//back size of triangle\n"
+	"		{\n"
+	"			facesA[fidx].m_indexOffset=curUsedIndices;\n"
+	"			indicesA[3]=2;\n"
+	"			indicesA[4]=1;\n"
+	"			indicesA[5]=0;\n"
+	"			curUsedIndices+=3;\n"
+	"			float c = dot(normal,verticesA[0]);\n"
+	"			float c1 = -face.m_plane.w;\n"
+	"			facesA[fidx].m_plane.x = -normal.x;\n"
+	"			facesA[fidx].m_plane.y = -normal.y;\n"
+	"			facesA[fidx].m_plane.z = -normal.z;\n"
+	"			facesA[fidx].m_plane.w = c;\n"
+	"			facesA[fidx].m_numIndices=3;\n"
+	"		}\n"
+	"		fidx++;\n"
+	"		bool addEdgePlanes = true;\n"
+	"		if (addEdgePlanes)\n"
+	"		{\n"
+	"			int numVertices=3;\n"
+	"			int prevVertex = numVertices-1;\n"
+	"			for (int i=0;i<numVertices;i++)\n"
+	"			{\n"
+	"				float4 v0 = verticesA[i];\n"
+	"				float4 v1 = verticesA[prevVertex];\n"
+	"                                            \n"
+	"				float4 edgeNormal = normalize(cross(normal,v1-v0));\n"
+	"				float c = -dot(edgeNormal,v0);\n"
+	"				facesA[fidx].m_numIndices = 2;\n"
+	"				facesA[fidx].m_indexOffset=curUsedIndices;\n"
+	"				indicesA[curUsedIndices++]=i;\n"
+	"				indicesA[curUsedIndices++]=prevVertex;\n"
+	"                                            \n"
+	"				facesA[fidx].m_plane.x = edgeNormal.x;\n"
+	"				facesA[fidx].m_plane.y = edgeNormal.y;\n"
+	"				facesA[fidx].m_plane.z = edgeNormal.z;\n"
+	"				facesA[fidx].m_plane.w = c;\n"
+	"				fidx++;\n"
+	"				prevVertex = i;\n"
+	"			}\n"
+	"		}\n"
+	"		convexPolyhedronA.m_numFaces = TRIANGLE_NUM_CONVEX_FACES;\n"
+	"		convexPolyhedronA.m_localCenter = localCenter*(1.f/3.f);\n"
+	"		float4 posA = rigidBodies[bodyIndexA].m_pos;\n"
+	"		posA.w = 0.f;\n"
+	"		float4 posB = rigidBodies[bodyIndexB].m_pos;\n"
+	"		posB.w = 0.f;\n"
+	"		float4 ornA = rigidBodies[bodyIndexA].m_quat;\n"
+	"		float4 ornB =rigidBodies[bodyIndexB].m_quat;\n"
+	"		\n"
+	"		///////////////////\n"
+	"		///compound shape support\n"
+	"		if (collidables[collidableIndexB].m_shapeType==SHAPE_COMPOUND_OF_CONVEX_HULLS)\n"
+	"		{\n"
+	"			int compoundChild = concavePairs[pairIdx].w;\n"
+	"			int childShapeIndexB = compoundChild;//collidables[collidableIndexB].m_shapeIndex+compoundChild;\n"
+	"			int childColIndexB = gpuChildShapes[childShapeIndexB].m_shapeIndex;\n"
+	"			float4 childPosB = gpuChildShapes[childShapeIndexB].m_childPosition;\n"
+	"			float4 childOrnB = gpuChildShapes[childShapeIndexB].m_childOrientation;\n"
+	"			float4 newPosB = transform(&childPosB,&posB,&ornB);\n"
+	"			float4 newOrnB = qtMul(ornB,childOrnB);\n"
+	"			posB = newPosB;\n"
+	"			ornB = newOrnB;\n"
+	"			shapeIndexB = collidables[childColIndexB].m_shapeIndex;\n"
+	"		}\n"
+	"		//////////////////\n"
+	"		float4 c0local = convexPolyhedronA.m_localCenter;\n"
+	"		float4 c0 = transform(&c0local, &posA, &ornA);\n"
+	"		float4 c1local = convexShapes[shapeIndexB].m_localCenter;\n"
+	"		float4 c1 = transform(&c1local,&posB,&ornB);\n"
+	"		const float4 DeltaC2 = c0 - c1;\n"
+	"		bool sepA = findSeparatingAxisLocalA(	&convexPolyhedronA, &convexShapes[shapeIndexB],\n"
+	"												posA,ornA,\n"
+	"												posB,ornB,\n"
+	"												DeltaC2,\n"
+	"												verticesA,uniqueEdgesA,facesA,indicesA,\n"
+	"												vertices,uniqueEdges,faces,indices,\n"
+	"												&sepAxis,&dmin);\n"
+	"		hasSeparatingAxis = 4;\n"
+	"		if (!sepA)\n"
+	"		{\n"
+	"			hasSeparatingAxis = 0;\n"
+	"		} else\n"
+	"		{\n"
+	"			bool sepB = findSeparatingAxisLocalB(	&convexShapes[shapeIndexB],&convexPolyhedronA,\n"
+	"												posB,ornB,\n"
+	"												posA,ornA,\n"
+	"												DeltaC2,\n"
+	"												vertices,uniqueEdges,faces,indices,\n"
+	"												verticesA,uniqueEdgesA,facesA,indicesA,\n"
+	"												&sepAxis,&dmin);\n"
+	"			if (!sepB)\n"
+	"			{\n"
+	"				hasSeparatingAxis = 0;\n"
+	"			} else\n"
+	"			{\n"
+	"				bool sepEE = findSeparatingAxisEdgeEdgeLocalA(	&convexPolyhedronA, &convexShapes[shapeIndexB],\n"
+	"															posA,ornA,\n"
+	"															posB,ornB,\n"
+	"															DeltaC2,\n"
+	"															verticesA,uniqueEdgesA,facesA,indicesA,\n"
+	"															vertices,uniqueEdges,faces,indices,\n"
+	"															&sepAxis,&dmin);\n"
+	"	\n"
+	"				if (!sepEE)\n"
+	"				{\n"
+	"					hasSeparatingAxis = 0;\n"
+	"				} else\n"
+	"				{\n"
+	"					hasSeparatingAxis = 1;\n"
+	"				}\n"
+	"			}\n"
+	"		}	\n"
+	"		\n"
+	"		if (hasSeparatingAxis)\n"
+	"		{\n"
+	"			sepAxis.w = dmin;\n"
+	"			concaveSeparatingNormalsOut[pairIdx]=sepAxis;\n"
+	"			concaveHasSeparatingNormals[i]=1;\n"
+	"			float minDist = -1e30f;\n"
+	"			float maxDist = 0.02f;\n"
+	"		\n"
+	"			findClippingFaces(sepAxis,\n"
+	"                     &convexPolyhedronA,\n"
+	"					 &convexShapes[shapeIndexB],\n"
+	"					 posA,ornA,\n"
+	"					 posB,ornB,\n"
+	"                      worldVertsA1GPU,\n"
+	"                      worldNormalsAGPU,\n"
+	"                      worldVertsB1GPU,\n"
+	"					  vertexFaceCapacity,\n"
+	"                      minDist, maxDist,\n"
+	"                      verticesA,\n"
+	"                      facesA,\n"
+	"                      indicesA,\n"
+	" 					  vertices,\n"
+	"                      faces,\n"
+	"                      indices,\n"
+	"                      clippingFacesOut, pairIdx);\n"
+	"		} else\n"
+	"		{	\n"
+	"			//mark this pair as in-active\n"
+	"			concavePairs[pairIdx].w = -1;\n"
+	"		}\n"
+	"	}\n"
+	"	else\n"
+	"	{	\n"
+	"		//mark this pair as in-active\n"
+	"		concavePairs[pairIdx].w = -1;\n"
+	"	}\n"
+	"	\n"
+	"	concavePairs[pairIdx].z = -1;//now z is used for existing/persistent contacts\n"
+	"}\n";
diff --git a/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/b3BoundSearchCL.h b/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/b3BoundSearchCL.h
new file mode 100644
index 00000000..0d633e3d
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/b3BoundSearchCL.h
@@ -0,0 +1,64 @@
+/*
+Copyright (c) 2012 Advanced Micro Devices, Inc.  
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+//Originally written by Takahiro Harada
+
+#ifndef B3_BOUNDSEARCH_H
+#define B3_BOUNDSEARCH_H
+
+#pragma once
+
+/*#include <Adl/Adl.h>
+#include <AdlPrimitives/Math/Math.h>
+#include <AdlPrimitives/Sort/SortData.h>
+#include <AdlPrimitives/Fill/Fill.h>
+*/
+
+#include "b3OpenCLArray.h"
+#include "b3FillCL.h"
+#include "b3RadixSort32CL.h"  //for b3SortData (perhaps move it?)
+class b3BoundSearchCL
+{
+public:
+	enum Option
+	{
+		BOUND_LOWER,
+		BOUND_UPPER,
+		COUNT,
+	};
+
+	cl_context m_context;
+	cl_device_id m_device;
+	cl_command_queue m_queue;
+
+	cl_kernel m_lowerSortDataKernel;
+	cl_kernel m_upperSortDataKernel;
+	cl_kernel m_subtractKernel;
+
+	b3OpenCLArray<b3Int4>* m_constbtOpenCLArray;
+	b3OpenCLArray<unsigned int>* m_lower;
+	b3OpenCLArray<unsigned int>* m_upper;
+
+	b3FillCL* m_filler;
+
+	b3BoundSearchCL(cl_context context, cl_device_id device, cl_command_queue queue, int size);
+
+	virtual ~b3BoundSearchCL();
+
+	//	src has to be src[i].m_key <= src[i+1].m_key
+	void execute(b3OpenCLArray<b3SortData>& src, int nSrc, b3OpenCLArray<unsigned int>& dst, int nDst, Option option = BOUND_LOWER);
+
+	void executeHost(b3AlignedObjectArray<b3SortData>& src, int nSrc, b3AlignedObjectArray<unsigned int>& dst, int nDst, Option option = BOUND_LOWER);
+};
+
+#endif  //B3_BOUNDSEARCH_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/b3BufferInfoCL.h b/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/b3BufferInfoCL.h
new file mode 100644
index 00000000..35fc467b
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/b3BufferInfoCL.h
@@ -0,0 +1,18 @@
+
+#ifndef B3_BUFFER_INFO_CL_H
+#define B3_BUFFER_INFO_CL_H
+
+#include "b3OpenCLArray.h"
+
+struct b3BufferInfoCL
+{
+	//b3BufferInfoCL(){}
+
+	//	template<typename T>
+	b3BufferInfoCL(cl_mem buff, bool isReadOnly = false) : m_clBuffer(buff), m_isReadOnly(isReadOnly) {}
+
+	cl_mem m_clBuffer;
+	bool m_isReadOnly;
+};
+
+#endif  //B3_BUFFER_INFO_CL_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/b3FillCL.h b/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/b3FillCL.h
new file mode 100644
index 00000000..c92c3e51
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/b3FillCL.h
@@ -0,0 +1,52 @@
+#ifndef B3_FILL_CL_H
+#define B3_FILL_CL_H
+
+#include "b3OpenCLArray.h"
+#include "Bullet3Common/b3Scalar.h"
+
+#include "Bullet3Common/shared/b3Int2.h"
+#include "Bullet3Common/shared/b3Int4.h"
+
+class b3FillCL
+{
+	cl_command_queue m_commandQueue;
+
+	cl_kernel m_fillKernelInt2;
+	cl_kernel m_fillIntKernel;
+	cl_kernel m_fillUnsignedIntKernel;
+	cl_kernel m_fillFloatKernel;
+
+public:
+	struct b3ConstData
+	{
+		union {
+			b3Int4 m_data;
+			b3UnsignedInt4 m_UnsignedData;
+		};
+		int m_offset;
+		int m_n;
+		int m_padding[2];
+	};
+
+protected:
+public:
+	b3FillCL(cl_context ctx, cl_device_id device, cl_command_queue queue);
+
+	virtual ~b3FillCL();
+
+	void execute(b3OpenCLArray<unsigned int>& src, const unsigned int value, int n, int offset = 0);
+
+	void execute(b3OpenCLArray<int>& src, const int value, int n, int offset = 0);
+
+	void execute(b3OpenCLArray<float>& src, const float value, int n, int offset = 0);
+
+	void execute(b3OpenCLArray<b3Int2>& src, const b3Int2& value, int n, int offset = 0);
+
+	void executeHost(b3AlignedObjectArray<b3Int2>& src, const b3Int2& value, int n, int offset);
+
+	void executeHost(b3AlignedObjectArray<int>& src, const int value, int n, int offset);
+
+	//	void execute(b3OpenCLArray<b3Int4>& src, const b3Int4& value, int n, int offset = 0);
+};
+
+#endif  //B3_FILL_CL_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/b3LauncherCL.h b/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/b3LauncherCL.h
new file mode 100644
index 00000000..18e9c1db
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/b3LauncherCL.h
@@ -0,0 +1,128 @@
+
+#ifndef B3_LAUNCHER_CL_H
+#define B3_LAUNCHER_CL_H
+
+#include "b3BufferInfoCL.h"
+#include "Bullet3Common/b3MinMax.h"
+#include "b3OpenCLArray.h"
+#include <stdio.h>
+
+#define B3_DEBUG_SERIALIZE_CL
+
+#ifdef _WIN32
+#pragma warning(disable : 4996)
+#endif
+#define B3_CL_MAX_ARG_SIZE 16
+B3_ATTRIBUTE_ALIGNED16(struct)
+b3KernelArgData
+{
+	int m_isBuffer;
+	int m_argIndex;
+	int m_argSizeInBytes;
+	int m_unusedPadding;
+	union {
+		cl_mem m_clBuffer;
+		unsigned char m_argData[B3_CL_MAX_ARG_SIZE];
+	};
+};
+
+class b3LauncherCL
+{
+	cl_command_queue m_commandQueue;
+	cl_kernel m_kernel;
+	int m_idx;
+
+	b3AlignedObjectArray<b3KernelArgData> m_kernelArguments;
+	int m_serializationSizeInBytes;
+	bool m_enableSerialization;
+
+	const char* m_name;
+
+public:
+	b3AlignedObjectArray<b3OpenCLArray<unsigned char>*> m_arrays;
+
+	b3LauncherCL(cl_command_queue queue, cl_kernel kernel, const char* name);
+
+	virtual ~b3LauncherCL();
+
+	void setBuffer(cl_mem clBuffer);
+
+	void setBuffers(b3BufferInfoCL* buffInfo, int n);
+
+	int getSerializationBufferSize() const
+	{
+		return m_serializationSizeInBytes;
+	}
+
+	int deserializeArgs(unsigned char* buf, int bufSize, cl_context ctx);
+
+	inline int validateResults(unsigned char* goldBuffer, int goldBufferCapacity, cl_context ctx);
+
+	int serializeArguments(unsigned char* destBuffer, int destBufferCapacity);
+
+	int getNumArguments() const
+	{
+		return m_kernelArguments.size();
+	}
+
+	b3KernelArgData getArgument(int index)
+	{
+		return m_kernelArguments[index];
+	}
+
+	void serializeToFile(const char* fileName, int numWorkItems);
+
+	template <typename T>
+	inline void setConst(const T& consts)
+	{
+		int sz = sizeof(T);
+		b3Assert(sz <= B3_CL_MAX_ARG_SIZE);
+
+		if (m_enableSerialization)
+		{
+			b3KernelArgData kernelArg;
+			kernelArg.m_argIndex = m_idx;
+			kernelArg.m_isBuffer = 0;
+			T* destArg = (T*)kernelArg.m_argData;
+			*destArg = consts;
+			kernelArg.m_argSizeInBytes = sizeof(T);
+			m_kernelArguments.push_back(kernelArg);
+			m_serializationSizeInBytes += sizeof(b3KernelArgData);
+		}
+
+		cl_int status = clSetKernelArg(m_kernel, m_idx++, sz, &consts);
+		b3Assert(status == CL_SUCCESS);
+	}
+
+	inline void launch1D(int numThreads, int localSize = 64)
+	{
+		launch2D(numThreads, 1, localSize, 1);
+	}
+
+	inline void launch2D(int numThreadsX, int numThreadsY, int localSizeX, int localSizeY)
+	{
+		size_t gRange[3] = {1, 1, 1};
+		size_t lRange[3] = {1, 1, 1};
+		lRange[0] = localSizeX;
+		lRange[1] = localSizeY;
+		gRange[0] = b3Max((size_t)1, (numThreadsX / lRange[0]) + (!(numThreadsX % lRange[0]) ? 0 : 1));
+		gRange[0] *= lRange[0];
+		gRange[1] = b3Max((size_t)1, (numThreadsY / lRange[1]) + (!(numThreadsY % lRange[1]) ? 0 : 1));
+		gRange[1] *= lRange[1];
+
+		cl_int status = clEnqueueNDRangeKernel(m_commandQueue,
+											   m_kernel, 2, NULL, gRange, lRange, 0, 0, 0);
+		if (status != CL_SUCCESS)
+		{
+			printf("Error: OpenCL status = %d\n", status);
+		}
+		b3Assert(status == CL_SUCCESS);
+	}
+
+	void enableSerialization(bool serialize)
+	{
+		m_enableSerialization = serialize;
+	}
+};
+
+#endif  //B3_LAUNCHER_CL_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/b3OpenCLArray.h b/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/b3OpenCLArray.h
new file mode 100644
index 00000000..e837cceb
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/b3OpenCLArray.h
@@ -0,0 +1,300 @@
+#ifndef B3_OPENCL_ARRAY_H
+#define B3_OPENCL_ARRAY_H
+
+#include "Bullet3Common/b3AlignedObjectArray.h"
+#include "Bullet3OpenCL/Initialize/b3OpenCLInclude.h"
+
+template <typename T>
+class b3OpenCLArray
+{
+	size_t m_size;
+	size_t m_capacity;
+	cl_mem m_clBuffer;
+
+	cl_context m_clContext;
+	cl_command_queue m_commandQueue;
+
+	bool m_ownsMemory;
+
+	bool m_allowGrowingCapacity;
+
+	void deallocate()
+	{
+		if (m_clBuffer && m_ownsMemory)
+		{
+			clReleaseMemObject(m_clBuffer);
+		}
+		m_clBuffer = 0;
+		m_capacity = 0;
+	}
+
+	b3OpenCLArray<T>& operator=(const b3OpenCLArray<T>& src);
+
+	B3_FORCE_INLINE size_t allocSize(size_t size)
+	{
+		return (size ? size * 2 : 1);
+	}
+
+public:
+	b3OpenCLArray(cl_context ctx, cl_command_queue queue, size_t initialCapacity = 0, bool allowGrowingCapacity = true)
+		: m_size(0), m_capacity(0), m_clBuffer(0), m_clContext(ctx), m_commandQueue(queue), m_ownsMemory(true), m_allowGrowingCapacity(true)
+	{
+		if (initialCapacity)
+		{
+			reserve(initialCapacity);
+		}
+		m_allowGrowingCapacity = allowGrowingCapacity;
+	}
+
+	///this is an error-prone method with no error checking, be careful!
+	void setFromOpenCLBuffer(cl_mem buffer, size_t sizeInElements)
+	{
+		deallocate();
+		m_ownsMemory = false;
+		m_allowGrowingCapacity = false;
+		m_clBuffer = buffer;
+		m_size = sizeInElements;
+		m_capacity = sizeInElements;
+	}
+
+	// we could enable this assignment, but need to make sure to avoid accidental deep copies
+	//	b3OpenCLArray<T>& operator=(const b3AlignedObjectArray<T>& src)
+	//	{
+	//		copyFromArray(src);
+	//		return *this;
+	//	}
+
+	cl_mem getBufferCL() const
+	{
+		return m_clBuffer;
+	}
+
+	virtual ~b3OpenCLArray()
+	{
+		deallocate();
+		m_size = 0;
+		m_capacity = 0;
+	}
+
+	B3_FORCE_INLINE bool push_back(const T& _Val, bool waitForCompletion = true)
+	{
+		bool result = true;
+		size_t sz = size();
+		if (sz == capacity())
+		{
+			result = reserve(allocSize(size()));
+		}
+		copyFromHostPointer(&_Val, 1, sz, waitForCompletion);
+		m_size++;
+		return result;
+	}
+
+	B3_FORCE_INLINE T forcedAt(size_t n) const
+	{
+		b3Assert(n >= 0);
+		b3Assert(n < capacity());
+		T elem;
+		copyToHostPointer(&elem, 1, n, true);
+		return elem;
+	}
+
+	B3_FORCE_INLINE T at(size_t n) const
+	{
+		b3Assert(n >= 0);
+		b3Assert(n < size());
+		T elem;
+		copyToHostPointer(&elem, 1, n, true);
+		return elem;
+	}
+
+	B3_FORCE_INLINE bool resize(size_t newsize, bool copyOldContents = true)
+	{
+		bool result = true;
+		size_t curSize = size();
+
+		if (newsize < curSize)
+		{
+			//leave the OpenCL memory for now
+		}
+		else
+		{
+			if (newsize > size())
+			{
+				result = reserve(newsize, copyOldContents);
+			}
+
+			//leave new data uninitialized (init in debug mode?)
+			//for (size_t i=curSize;i<newsize;i++) ...
+		}
+
+		if (result)
+		{
+			m_size = newsize;
+		}
+		else
+		{
+			m_size = 0;
+		}
+		return result;
+	}
+
+	B3_FORCE_INLINE size_t size() const
+	{
+		return m_size;
+	}
+
+	B3_FORCE_INLINE size_t capacity() const
+	{
+		return m_capacity;
+	}
+
+	B3_FORCE_INLINE bool reserve(size_t _Count, bool copyOldContents = true)
+	{
+		bool result = true;
+		// determine new minimum length of allocated storage
+		if (capacity() < _Count)
+		{  // not enough room, reallocate
+
+			if (m_allowGrowingCapacity)
+			{
+				cl_int ciErrNum;
+				//create a new OpenCL buffer
+				size_t memSizeInBytes = sizeof(T) * _Count;
+				cl_mem buf = clCreateBuffer(m_clContext, CL_MEM_READ_WRITE, memSizeInBytes, NULL, &ciErrNum);
+				if (ciErrNum != CL_SUCCESS)
+				{
+					b3Error("OpenCL out-of-memory\n");
+					_Count = 0;
+					result = false;
+				}
+//#define B3_ALWAYS_INITIALIZE_OPENCL_BUFFERS
+#ifdef B3_ALWAYS_INITIALIZE_OPENCL_BUFFERS
+				unsigned char* src = (unsigned char*)malloc(memSizeInBytes);
+				for (size_t i = 0; i < memSizeInBytes; i++)
+					src[i] = 0xbb;
+				ciErrNum = clEnqueueWriteBuffer(m_commandQueue, buf, CL_TRUE, 0, memSizeInBytes, src, 0, 0, 0);
+				b3Assert(ciErrNum == CL_SUCCESS);
+				clFinish(m_commandQueue);
+				free(src);
+#endif  //B3_ALWAYS_INITIALIZE_OPENCL_BUFFERS
+
+				if (result)
+				{
+					if (copyOldContents)
+						copyToCL(buf, size());
+				}
+
+				//deallocate the old buffer
+				deallocate();
+
+				m_clBuffer = buf;
+
+				m_capacity = _Count;
+			}
+			else
+			{
+				//fail: assert and
+				b3Assert(0);
+				deallocate();
+				result = false;
+			}
+		}
+		return result;
+	}
+
+	void copyToCL(cl_mem destination, size_t numElements, size_t firstElem = 0, size_t dstOffsetInElems = 0) const
+	{
+		if (numElements <= 0)
+			return;
+
+		b3Assert(m_clBuffer);
+		b3Assert(destination);
+
+		//likely some error, destination is same as source
+		b3Assert(m_clBuffer != destination);
+
+		b3Assert((firstElem + numElements) <= m_size);
+
+		cl_int status = 0;
+
+		b3Assert(numElements > 0);
+		b3Assert(numElements <= m_size);
+
+		size_t srcOffsetBytes = sizeof(T) * firstElem;
+		size_t dstOffsetInBytes = sizeof(T) * dstOffsetInElems;
+
+		status = clEnqueueCopyBuffer(m_commandQueue, m_clBuffer, destination,
+									 srcOffsetBytes, dstOffsetInBytes, sizeof(T) * numElements, 0, 0, 0);
+
+		b3Assert(status == CL_SUCCESS);
+	}
+
+	void copyFromHost(const b3AlignedObjectArray<T>& srcArray, bool waitForCompletion = true)
+	{
+		size_t newSize = srcArray.size();
+
+		bool copyOldContents = false;
+		resize(newSize, copyOldContents);
+		if (newSize)
+			copyFromHostPointer(&srcArray[0], newSize, 0, waitForCompletion);
+	}
+
+	void copyFromHostPointer(const T* src, size_t numElems, size_t destFirstElem = 0, bool waitForCompletion = true)
+	{
+		b3Assert(numElems + destFirstElem <= capacity());
+
+		if (numElems + destFirstElem)
+		{
+			cl_int status = 0;
+			size_t sizeInBytes = sizeof(T) * numElems;
+			status = clEnqueueWriteBuffer(m_commandQueue, m_clBuffer, 0, sizeof(T) * destFirstElem, sizeInBytes,
+										  src, 0, 0, 0);
+			b3Assert(status == CL_SUCCESS);
+			if (waitForCompletion)
+				clFinish(m_commandQueue);
+		}
+		else
+		{
+			b3Error("copyFromHostPointer invalid range\n");
+		}
+	}
+
+	void copyToHost(b3AlignedObjectArray<T>& destArray, bool waitForCompletion = true) const
+	{
+		destArray.resize(this->size());
+		if (size())
+			copyToHostPointer(&destArray[0], size(), 0, waitForCompletion);
+	}
+
+	void copyToHostPointer(T* destPtr, size_t numElem, size_t srcFirstElem = 0, bool waitForCompletion = true) const
+	{
+		b3Assert(numElem + srcFirstElem <= capacity());
+
+		if (numElem + srcFirstElem <= capacity())
+		{
+			cl_int status = 0;
+			status = clEnqueueReadBuffer(m_commandQueue, m_clBuffer, 0, sizeof(T) * srcFirstElem, sizeof(T) * numElem,
+										 destPtr, 0, 0, 0);
+			b3Assert(status == CL_SUCCESS);
+
+			if (waitForCompletion)
+				clFinish(m_commandQueue);
+		}
+		else
+		{
+			b3Error("copyToHostPointer invalid range\n");
+		}
+	}
+
+	void copyFromOpenCLArray(const b3OpenCLArray& src)
+	{
+		size_t newSize = src.size();
+		resize(newSize);
+		if (size())
+		{
+			src.copyToCL(m_clBuffer, size());
+		}
+	}
+};
+
+#endif  //B3_OPENCL_ARRAY_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/b3PrefixScanCL.h b/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/b3PrefixScanCL.h
new file mode 100644
index 00000000..346efa0c
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/b3PrefixScanCL.h
@@ -0,0 +1,35 @@
+
+#ifndef B3_PREFIX_SCAN_CL_H
+#define B3_PREFIX_SCAN_CL_H
+
+#include "b3OpenCLArray.h"
+#include "b3BufferInfoCL.h"
+#include "Bullet3Common/b3AlignedObjectArray.h"
+
+class b3PrefixScanCL
+{
+	enum
+	{
+		BLOCK_SIZE = 128
+	};
+
+	//	Option m_option;
+
+	cl_command_queue m_commandQueue;
+
+	cl_kernel m_localScanKernel;
+	cl_kernel m_blockSumKernel;
+	cl_kernel m_propagationKernel;
+
+	b3OpenCLArray<unsigned int>* m_workBuffer;
+
+public:
+	b3PrefixScanCL(cl_context ctx, cl_device_id device, cl_command_queue queue, int size = 0);
+
+	virtual ~b3PrefixScanCL();
+
+	void execute(b3OpenCLArray<unsigned int>& src, b3OpenCLArray<unsigned int>& dst, int n, unsigned int* sum = 0);
+	void executeHost(b3AlignedObjectArray<unsigned int>& src, b3AlignedObjectArray<unsigned int>& dst, int n, unsigned int* sum = 0);
+};
+
+#endif  //B3_PREFIX_SCAN_CL_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/b3PrefixScanFloat4CL.h b/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/b3PrefixScanFloat4CL.h
new file mode 100644
index 00000000..122b0bfd
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/b3PrefixScanFloat4CL.h
@@ -0,0 +1,36 @@
+
+#ifndef B3_PREFIX_SCAN_CL_H
+#define B3_PREFIX_SCAN_CL_H
+
+#include "b3OpenCLArray.h"
+#include "b3BufferInfoCL.h"
+#include "Bullet3Common/b3AlignedObjectArray.h"
+#include "Bullet3Common/b3Vector3.h"
+
+class b3PrefixScanFloat4CL
+{
+	enum
+	{
+		BLOCK_SIZE = 128
+	};
+
+	//	Option m_option;
+
+	cl_command_queue m_commandQueue;
+
+	cl_kernel m_localScanKernel;
+	cl_kernel m_blockSumKernel;
+	cl_kernel m_propagationKernel;
+
+	b3OpenCLArray<b3Vector3>* m_workBuffer;
+
+public:
+	b3PrefixScanFloat4CL(cl_context ctx, cl_device_id device, cl_command_queue queue, int size = 0);
+
+	virtual ~b3PrefixScanFloat4CL();
+
+	void execute(b3OpenCLArray<b3Vector3>& src, b3OpenCLArray<b3Vector3>& dst, int n, b3Vector3* sum = 0);
+	void executeHost(b3AlignedObjectArray<b3Vector3>& src, b3AlignedObjectArray<b3Vector3>& dst, int n, b3Vector3* sum);
+};
+
+#endif  //B3_PREFIX_SCAN_CL_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/b3RadixSort32CL.h b/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/b3RadixSort32CL.h
new file mode 100644
index 00000000..69caf182
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/b3RadixSort32CL.h
@@ -0,0 +1,84 @@
+
+#ifndef B3_RADIXSORT32_H
+#define B3_RADIXSORT32_H
+
+#include "b3OpenCLArray.h"
+
+struct b3SortData
+{
+	union {
+		unsigned int m_key;
+		unsigned int x;
+	};
+
+	union {
+		unsigned int m_value;
+		unsigned int y;
+	};
+};
+#include "b3BufferInfoCL.h"
+
+class b3RadixSort32CL
+{
+	b3OpenCLArray<unsigned int>* m_workBuffer1;
+	b3OpenCLArray<unsigned int>* m_workBuffer2;
+
+	b3OpenCLArray<b3SortData>* m_workBuffer3;
+	b3OpenCLArray<b3SortData>* m_workBuffer4;
+
+	b3OpenCLArray<unsigned int>* m_workBuffer3a;
+	b3OpenCLArray<unsigned int>* m_workBuffer4a;
+
+	cl_command_queue m_commandQueue;
+
+	cl_kernel m_streamCountSortDataKernel;
+	cl_kernel m_streamCountKernel;
+
+	cl_kernel m_prefixScanKernel;
+	cl_kernel m_sortAndScatterSortDataKernel;
+	cl_kernel m_sortAndScatterKernel;
+
+	bool m_deviceCPU;
+
+	class b3PrefixScanCL* m_scan;
+	class b3FillCL* m_fill;
+
+public:
+	struct b3ConstData
+	{
+		int m_n;
+		int m_nWGs;
+		int m_startBit;
+		int m_nBlocksPerWG;
+	};
+	enum
+	{
+		DATA_ALIGNMENT = 256,
+		WG_SIZE = 64,
+		BLOCK_SIZE = 256,
+		ELEMENTS_PER_WORK_ITEM = (BLOCK_SIZE / WG_SIZE),
+		BITS_PER_PASS = 4,
+		NUM_BUCKET = (1 << BITS_PER_PASS),
+		//	if you change this, change nPerWI in kernel as well
+		NUM_WGS = 20 * 6,  //	cypress
+						   //			NUM_WGS = 24*6,	//	cayman
+						   //			NUM_WGS = 32*4,	//	nv
+	};
+
+private:
+public:
+	b3RadixSort32CL(cl_context ctx, cl_device_id device, cl_command_queue queue, int initialCapacity = 0);
+
+	virtual ~b3RadixSort32CL();
+
+	void execute(b3OpenCLArray<unsigned int>& keysIn, b3OpenCLArray<unsigned int>& keysOut, b3OpenCLArray<unsigned int>& valuesIn,
+				 b3OpenCLArray<unsigned int>& valuesOut, int n, int sortBits = 32);
+
+	///keys only
+	void execute(b3OpenCLArray<unsigned int>& keysInOut, int sortBits = 32);
+
+	void execute(b3OpenCLArray<b3SortData>& keyValuesInOut, int sortBits = 32);
+	void executeHost(b3OpenCLArray<b3SortData>& keyValuesInOut, int sortBits = 32);
+	void executeHost(b3AlignedObjectArray<b3SortData>& keyValuesInOut, int sortBits = 32);
+};
+#endif  //B3_RADIXSORT32_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/kernels/BoundSearchKernelsCL.h b/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/kernels/BoundSearchKernelsCL.h
new file mode 100644
index 00000000..1758dd41
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/kernels/BoundSearchKernelsCL.h
@@ -0,0 +1,86 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* boundSearchKernelsCL =
+	"/*\n"
+	"Copyright (c) 2012 Advanced Micro Devices, Inc.  \n"
+	"This software is provided 'as-is', without any express or implied warranty.\n"
+	"In no event will the authors be held liable for any damages arising from the use of this software.\n"
+	"Permission is granted to anyone to use this software for any purpose, \n"
+	"including commercial applications, and to alter it and redistribute it freely, \n"
+	"subject to the following restrictions:\n"
+	"1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.\n"
+	"2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.\n"
+	"3. This notice may not be removed or altered from any source distribution.\n"
+	"*/\n"
+	"//Originally written by Takahiro Harada\n"
+	"typedef unsigned int u32;\n"
+	"#define GET_GROUP_IDX get_group_id(0)\n"
+	"#define GET_LOCAL_IDX get_local_id(0)\n"
+	"#define GET_GLOBAL_IDX get_global_id(0)\n"
+	"#define GET_GROUP_SIZE get_local_size(0)\n"
+	"#define GROUP_LDS_BARRIER barrier(CLK_LOCAL_MEM_FENCE)\n"
+	"typedef struct\n"
+	"{\n"
+	"	u32 m_key; \n"
+	"	u32 m_value;\n"
+	"}SortData;\n"
+	"typedef struct\n"
+	"{\n"
+	"	u32 m_nSrc;\n"
+	"	u32 m_nDst;\n"
+	"	u32 m_padding[2];\n"
+	"} ConstBuffer;\n"
+	"__attribute__((reqd_work_group_size(64,1,1)))\n"
+	"__kernel\n"
+	"void SearchSortDataLowerKernel(__global SortData* src, __global u32 *dst, \n"
+	"					unsigned int nSrc, unsigned int nDst)\n"
+	"{\n"
+	"	int gIdx = GET_GLOBAL_IDX;\n"
+	"	if( gIdx < nSrc )\n"
+	"	{\n"
+	"		SortData first; first.m_key = (u32)(-1); first.m_value = (u32)(-1);\n"
+	"		SortData end; end.m_key = nDst; end.m_value = nDst;\n"
+	"		SortData iData = (gIdx==0)? first: src[gIdx-1];\n"
+	"		SortData jData = (gIdx==nSrc)? end: src[gIdx];\n"
+	"		if( iData.m_key != jData.m_key )\n"
+	"		{\n"
+	"//			for(u32 k=iData.m_key+1; k<=min(jData.m_key, nDst-1); k++)\n"
+	"			u32 k = jData.m_key;\n"
+	"			{\n"
+	"				dst[k] = gIdx;\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"}\n"
+	"__attribute__((reqd_work_group_size(64,1,1)))\n"
+	"__kernel\n"
+	"void SearchSortDataUpperKernel(__global SortData* src, __global u32 *dst, \n"
+	"					unsigned int nSrc, unsigned int nDst)\n"
+	"{\n"
+	"	int gIdx = GET_GLOBAL_IDX+1;\n"
+	"	if( gIdx < nSrc+1 )\n"
+	"	{\n"
+	"		SortData first; first.m_key = 0; first.m_value = 0;\n"
+	"		SortData end; end.m_key = nDst; end.m_value = nDst;\n"
+	"		SortData iData = src[gIdx-1];\n"
+	"		SortData jData = (gIdx==nSrc)? end: src[gIdx];\n"
+	"		if( iData.m_key != jData.m_key )\n"
+	"		{\n"
+	"			u32 k = iData.m_key;\n"
+	"			{\n"
+	"				dst[k] = gIdx;\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"}\n"
+	"__attribute__((reqd_work_group_size(64,1,1)))\n"
+	"__kernel\n"
+	"void SubtractKernel(__global u32* A, __global u32 *B, __global u32 *C, \n"
+	"					unsigned int nSrc, unsigned int nDst)\n"
+	"{\n"
+	"	int gIdx = GET_GLOBAL_IDX;\n"
+	"	\n"
+	"	if( gIdx < nDst )\n"
+	"	{\n"
+	"		C[gIdx] = A[gIdx] - B[gIdx];\n"
+	"	}\n"
+	"}\n";
diff --git a/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/kernels/CopyKernelsCL.h b/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/kernels/CopyKernelsCL.h
new file mode 100644
index 00000000..33c92794
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/kernels/CopyKernelsCL.h
@@ -0,0 +1,131 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* copyKernelsCL =
+	"/*\n"
+	"Copyright (c) 2012 Advanced Micro Devices, Inc.  \n"
+	"\n"
+	"This software is provided 'as-is', without any express or implied warranty.\n"
+	"In no event will the authors be held liable for any damages arising from the use of this software.\n"
+	"Permission is granted to anyone to use this software for any purpose, \n"
+	"including commercial applications, and to alter it and redistribute it freely, \n"
+	"subject to the following restrictions:\n"
+	"\n"
+	"1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.\n"
+	"2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.\n"
+	"3. This notice may not be removed or altered from any source distribution.\n"
+	"*/\n"
+	"//Originally written by Takahiro Harada\n"
+	"\n"
+	"#pragma OPENCL EXTENSION cl_amd_printf : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_local_int32_base_atomics : enable\n"
+	"\n"
+	"typedef unsigned int u32;\n"
+	"#define GET_GROUP_IDX get_group_id(0)\n"
+	"#define GET_LOCAL_IDX get_local_id(0)\n"
+	"#define GET_GLOBAL_IDX get_global_id(0)\n"
+	"#define GET_GROUP_SIZE get_local_size(0)\n"
+	"#define GROUP_LDS_BARRIER barrier(CLK_LOCAL_MEM_FENCE)\n"
+	"#define GROUP_MEM_FENCE mem_fence(CLK_LOCAL_MEM_FENCE)\n"
+	"#define AtomInc(x) atom_inc(&(x))\n"
+	"#define AtomInc1(x, out) out = atom_inc(&(x))\n"
+	"\n"
+	"#define make_uint4 (uint4)\n"
+	"#define make_uint2 (uint2)\n"
+	"#define make_int2 (int2)\n"
+	"\n"
+	"typedef struct\n"
+	"{\n"
+	"	int m_n;\n"
+	"	int m_padding[3];\n"
+	"} ConstBuffer;\n"
+	"\n"
+	"\n"
+	"\n"
+	"__kernel\n"
+	"__attribute__((reqd_work_group_size(64,1,1)))\n"
+	"void Copy1F4Kernel(__global float4* dst, __global float4* src, \n"
+	"					ConstBuffer cb)\n"
+	"{\n"
+	"	int gIdx = GET_GLOBAL_IDX;\n"
+	"\n"
+	"	if( gIdx < cb.m_n )\n"
+	"	{\n"
+	"		float4 a0 = src[gIdx];\n"
+	"\n"
+	"		dst[ gIdx ] = a0;\n"
+	"	}\n"
+	"}\n"
+	"\n"
+	"__kernel\n"
+	"__attribute__((reqd_work_group_size(64,1,1)))\n"
+	"void Copy2F4Kernel(__global float4* dst, __global float4* src, \n"
+	"					ConstBuffer cb)\n"
+	"{\n"
+	"	int gIdx = GET_GLOBAL_IDX;\n"
+	"\n"
+	"	if( 2*gIdx <= cb.m_n )\n"
+	"	{\n"
+	"		float4 a0 = src[gIdx*2+0];\n"
+	"		float4 a1 = src[gIdx*2+1];\n"
+	"\n"
+	"		dst[ gIdx*2+0 ] = a0;\n"
+	"		dst[ gIdx*2+1 ] = a1;\n"
+	"	}\n"
+	"}\n"
+	"\n"
+	"__kernel\n"
+	"__attribute__((reqd_work_group_size(64,1,1)))\n"
+	"void Copy4F4Kernel(__global float4* dst, __global float4* src, \n"
+	"					ConstBuffer cb)\n"
+	"{\n"
+	"	int gIdx = GET_GLOBAL_IDX;\n"
+	"\n"
+	"	if( 4*gIdx <= cb.m_n )\n"
+	"	{\n"
+	"		int idx0 = gIdx*4+0;\n"
+	"		int idx1 = gIdx*4+1;\n"
+	"		int idx2 = gIdx*4+2;\n"
+	"		int idx3 = gIdx*4+3;\n"
+	"\n"
+	"		float4 a0 = src[idx0];\n"
+	"		float4 a1 = src[idx1];\n"
+	"		float4 a2 = src[idx2];\n"
+	"		float4 a3 = src[idx3];\n"
+	"\n"
+	"		dst[ idx0 ] = a0;\n"
+	"		dst[ idx1 ] = a1;\n"
+	"		dst[ idx2 ] = a2;\n"
+	"		dst[ idx3 ] = a3;\n"
+	"	}\n"
+	"}\n"
+	"\n"
+	"__kernel\n"
+	"__attribute__((reqd_work_group_size(64,1,1)))\n"
+	"void CopyF1Kernel(__global float* dstF1, __global float* srcF1, \n"
+	"					ConstBuffer cb)\n"
+	"{\n"
+	"	int gIdx = GET_GLOBAL_IDX;\n"
+	"\n"
+	"	if( gIdx < cb.m_n )\n"
+	"	{\n"
+	"		float a0 = srcF1[gIdx];\n"
+	"\n"
+	"		dstF1[ gIdx ] = a0;\n"
+	"	}\n"
+	"}\n"
+	"\n"
+	"__kernel\n"
+	"__attribute__((reqd_work_group_size(64,1,1)))\n"
+	"void CopyF2Kernel(__global float2* dstF2, __global float2* srcF2, \n"
+	"					ConstBuffer cb)\n"
+	"{\n"
+	"	int gIdx = GET_GLOBAL_IDX;\n"
+	"\n"
+	"	if( gIdx < cb.m_n )\n"
+	"	{\n"
+	"		float2 a0 = srcF2[gIdx];\n"
+	"\n"
+	"		dstF2[ gIdx ] = a0;\n"
+	"	}\n"
+	"}\n"
+	"\n"
+	"\n";
diff --git a/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/kernels/FillKernelsCL.h b/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/kernels/FillKernelsCL.h
new file mode 100644
index 00000000..983e6522
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/kernels/FillKernelsCL.h
@@ -0,0 +1,90 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* fillKernelsCL =
+	"/*\n"
+	"Copyright (c) 2012 Advanced Micro Devices, Inc.  \n"
+	"This software is provided 'as-is', without any express or implied warranty.\n"
+	"In no event will the authors be held liable for any damages arising from the use of this software.\n"
+	"Permission is granted to anyone to use this software for any purpose, \n"
+	"including commercial applications, and to alter it and redistribute it freely, \n"
+	"subject to the following restrictions:\n"
+	"1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.\n"
+	"2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.\n"
+	"3. This notice may not be removed or altered from any source distribution.\n"
+	"*/\n"
+	"//Originally written by Takahiro Harada\n"
+	"#pragma OPENCL EXTENSION cl_amd_printf : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_local_int32_base_atomics : enable\n"
+	"typedef unsigned int u32;\n"
+	"#define GET_GROUP_IDX get_group_id(0)\n"
+	"#define GET_LOCAL_IDX get_local_id(0)\n"
+	"#define GET_GLOBAL_IDX get_global_id(0)\n"
+	"#define GET_GROUP_SIZE get_local_size(0)\n"
+	"#define GROUP_LDS_BARRIER barrier(CLK_LOCAL_MEM_FENCE)\n"
+	"#define GROUP_MEM_FENCE mem_fence(CLK_LOCAL_MEM_FENCE)\n"
+	"#define AtomInc(x) atom_inc(&(x))\n"
+	"#define AtomInc1(x, out) out = atom_inc(&(x))\n"
+	"#define make_uint4 (uint4)\n"
+	"#define make_uint2 (uint2)\n"
+	"#define make_int2 (int2)\n"
+	"typedef struct\n"
+	"{\n"
+	"	union\n"
+	"	{\n"
+	"		int4 m_data;\n"
+	"		uint4 m_unsignedData;\n"
+	"		float	m_floatData;\n"
+	"	};\n"
+	"	int m_offset;\n"
+	"	int m_n;\n"
+	"	int m_padding[2];\n"
+	"} ConstBuffer;\n"
+	"__kernel\n"
+	"__attribute__((reqd_work_group_size(64,1,1)))\n"
+	"void FillIntKernel(__global int* dstInt, 			int num_elements, int value, const int offset)\n"
+	"{\n"
+	"	int gIdx = GET_GLOBAL_IDX;\n"
+	"	if( gIdx < num_elements )\n"
+	"	{\n"
+	"		dstInt[ offset+gIdx ] = value;\n"
+	"	}\n"
+	"}\n"
+	"__kernel\n"
+	"__attribute__((reqd_work_group_size(64,1,1)))\n"
+	"void FillFloatKernel(__global float* dstFloat, 	int num_elements, float value, const int offset)\n"
+	"{\n"
+	"	int gIdx = GET_GLOBAL_IDX;\n"
+	"	if( gIdx < num_elements )\n"
+	"	{\n"
+	"		dstFloat[ offset+gIdx ] = value;\n"
+	"	}\n"
+	"}\n"
+	"__kernel\n"
+	"__attribute__((reqd_work_group_size(64,1,1)))\n"
+	"void FillUnsignedIntKernel(__global unsigned int* dstInt, const int num, const unsigned int value, const int offset)\n"
+	"{\n"
+	"	int gIdx = GET_GLOBAL_IDX;\n"
+	"	if( gIdx < num )\n"
+	"	{\n"
+	"		dstInt[ offset+gIdx ] = value;\n"
+	"	}\n"
+	"}\n"
+	"__kernel\n"
+	"__attribute__((reqd_work_group_size(64,1,1)))\n"
+	"void FillInt2Kernel(__global int2* dstInt2, 	const int num, const int2 value, const int offset)\n"
+	"{\n"
+	"	int gIdx = GET_GLOBAL_IDX;\n"
+	"	if( gIdx < num )\n"
+	"	{\n"
+	"		dstInt2[ gIdx + offset] = make_int2( value.x, value.y );\n"
+	"	}\n"
+	"}\n"
+	"__kernel\n"
+	"__attribute__((reqd_work_group_size(64,1,1)))\n"
+	"void FillInt4Kernel(__global int4* dstInt4, 		const int num, const int4 value, const int offset)\n"
+	"{\n"
+	"	int gIdx = GET_GLOBAL_IDX;\n"
+	"	if( gIdx < num )\n"
+	"	{\n"
+	"		dstInt4[ offset+gIdx ] = value;\n"
+	"	}\n"
+	"}\n";
diff --git a/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/kernels/PrefixScanKernelsCL.h b/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/kernels/PrefixScanKernelsCL.h
new file mode 100644
index 00000000..fc5e7b86
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/kernels/PrefixScanKernelsCL.h
@@ -0,0 +1,128 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* prefixScanKernelsCL =
+	"/*\n"
+	"Copyright (c) 2012 Advanced Micro Devices, Inc.  \n"
+	"This software is provided 'as-is', without any express or implied warranty.\n"
+	"In no event will the authors be held liable for any damages arising from the use of this software.\n"
+	"Permission is granted to anyone to use this software for any purpose, \n"
+	"including commercial applications, and to alter it and redistribute it freely, \n"
+	"subject to the following restrictions:\n"
+	"1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.\n"
+	"2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.\n"
+	"3. This notice may not be removed or altered from any source distribution.\n"
+	"*/\n"
+	"//Originally written by Takahiro Harada\n"
+	"typedef unsigned int u32;\n"
+	"#define GET_GROUP_IDX get_group_id(0)\n"
+	"#define GET_LOCAL_IDX get_local_id(0)\n"
+	"#define GET_GLOBAL_IDX get_global_id(0)\n"
+	"#define GET_GROUP_SIZE get_local_size(0)\n"
+	"#define GROUP_LDS_BARRIER barrier(CLK_LOCAL_MEM_FENCE)\n"
+	"// takahiro end\n"
+	"#define WG_SIZE 128 \n"
+	"#define m_numElems x\n"
+	"#define m_numBlocks y\n"
+	"#define m_numScanBlocks z\n"
+	"/*typedef struct\n"
+	"{\n"
+	"	uint m_numElems;\n"
+	"	uint m_numBlocks;\n"
+	"	uint m_numScanBlocks;\n"
+	"	uint m_padding[1];\n"
+	"} ConstBuffer;\n"
+	"*/\n"
+	"u32 ScanExclusive(__local u32* data, u32 n, int lIdx, int lSize)\n"
+	"{\n"
+	"	u32 blocksum;\n"
+	"    int offset = 1;\n"
+	"    for(int nActive=n>>1; nActive>0; nActive>>=1, offset<<=1)\n"
+	"    {\n"
+	"        GROUP_LDS_BARRIER;\n"
+	"        for(int iIdx=lIdx; iIdx<nActive; iIdx+=lSize)\n"
+	"        {\n"
+	"            int ai = offset*(2*iIdx+1)-1;\n"
+	"            int bi = offset*(2*iIdx+2)-1;\n"
+	"            data[bi] += data[ai];\n"
+	"        }\n"
+	"	}\n"
+	"    GROUP_LDS_BARRIER;\n"
+	"    if( lIdx == 0 )\n"
+	"	{\n"
+	"		blocksum = data[ n-1 ];\n"
+	"        data[ n-1 ] = 0;\n"
+	"	}\n"
+	"	GROUP_LDS_BARRIER;\n"
+	"	offset >>= 1;\n"
+	"    for(int nActive=1; nActive<n; nActive<<=1, offset>>=1 )\n"
+	"    {\n"
+	"        GROUP_LDS_BARRIER;\n"
+	"        for( int iIdx = lIdx; iIdx<nActive; iIdx += lSize )\n"
+	"        {\n"
+	"            int ai = offset*(2*iIdx+1)-1;\n"
+	"            int bi = offset*(2*iIdx+2)-1;\n"
+	"            u32 temp = data[ai];\n"
+	"            data[ai] = data[bi];\n"
+	"            data[bi] += temp;\n"
+	"        }\n"
+	"	}\n"
+	"	GROUP_LDS_BARRIER;\n"
+	"	return blocksum;\n"
+	"}\n"
+	"__attribute__((reqd_work_group_size(WG_SIZE,1,1)))\n"
+	"__kernel\n"
+	"void LocalScanKernel(__global u32* dst, __global u32 *src, __global u32 *sumBuffer,\n"
+	"		uint4 cb)\n"
+	"{\n"
+	"	__local u32 ldsData[WG_SIZE*2];\n"
+	"	int gIdx = GET_GLOBAL_IDX;\n"
+	"	int lIdx = GET_LOCAL_IDX;\n"
+	"	ldsData[2*lIdx]     = ( 2*gIdx < cb.m_numElems )? src[2*gIdx]: 0;\n"
+	"	ldsData[2*lIdx + 1] = ( 2*gIdx+1 < cb.m_numElems )? src[2*gIdx + 1]: 0;\n"
+	"	u32 sum = ScanExclusive(ldsData, WG_SIZE*2, GET_LOCAL_IDX, GET_GROUP_SIZE);\n"
+	"	if( lIdx == 0 ) sumBuffer[GET_GROUP_IDX] = sum;\n"
+	"	if( (2*gIdx) < cb.m_numElems )\n"
+	"    {\n"
+	"        dst[2*gIdx]     = ldsData[2*lIdx];\n"
+	"	}\n"
+	"	if( (2*gIdx + 1) < cb.m_numElems )\n"
+	"	{\n"
+	"        dst[2*gIdx + 1] = ldsData[2*lIdx + 1];\n"
+	"    }\n"
+	"}\n"
+	"__attribute__((reqd_work_group_size(WG_SIZE,1,1)))\n"
+	"__kernel\n"
+	"void AddOffsetKernel(__global u32 *dst, __global u32 *blockSum, uint4 cb)\n"
+	"{\n"
+	"	const u32 blockSize = WG_SIZE*2;\n"
+	"	int myIdx = GET_GROUP_IDX+1;\n"
+	"	int lIdx = GET_LOCAL_IDX;\n"
+	"	u32 iBlockSum = blockSum[myIdx];\n"
+	"	int endValue = min((myIdx+1)*(blockSize), cb.m_numElems);\n"
+	"	for(int i=myIdx*blockSize+lIdx; i<endValue; i+=GET_GROUP_SIZE)\n"
+	"	{\n"
+	"		dst[i] += iBlockSum;\n"
+	"	}\n"
+	"}\n"
+	"__attribute__((reqd_work_group_size(WG_SIZE,1,1)))\n"
+	"__kernel\n"
+	"void TopLevelScanKernel(__global u32* dst, uint4 cb)\n"
+	"{\n"
+	"	__local u32 ldsData[2048];\n"
+	"	int gIdx = GET_GLOBAL_IDX;\n"
+	"	int lIdx = GET_LOCAL_IDX;\n"
+	"	int lSize = GET_GROUP_SIZE;\n"
+	"	for(int i=lIdx; i<cb.m_numScanBlocks; i+=lSize )\n"
+	"	{\n"
+	"		ldsData[i] = (i<cb.m_numBlocks)? dst[i]:0;\n"
+	"	}\n"
+	"	GROUP_LDS_BARRIER;\n"
+	"	u32 sum = ScanExclusive(ldsData, cb.m_numScanBlocks, GET_LOCAL_IDX, GET_GROUP_SIZE);\n"
+	"	for(int i=lIdx; i<cb.m_numBlocks; i+=lSize )\n"
+	"	{\n"
+	"		dst[i] = ldsData[i];\n"
+	"	}\n"
+	"	if( gIdx == 0 )\n"
+	"	{\n"
+	"		dst[cb.m_numBlocks] = sum;\n"
+	"	}\n"
+	"}\n";
diff --git a/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/kernels/PrefixScanKernelsFloat4CL.h b/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/kernels/PrefixScanKernelsFloat4CL.h
new file mode 100644
index 00000000..15d1bc51
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/kernels/PrefixScanKernelsFloat4CL.h
@@ -0,0 +1,128 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* prefixScanKernelsFloat4CL =
+	"/*\n"
+	"Copyright (c) 2012 Advanced Micro Devices, Inc.  \n"
+	"This software is provided 'as-is', without any express or implied warranty.\n"
+	"In no event will the authors be held liable for any damages arising from the use of this software.\n"
+	"Permission is granted to anyone to use this software for any purpose, \n"
+	"including commercial applications, and to alter it and redistribute it freely, \n"
+	"subject to the following restrictions:\n"
+	"1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.\n"
+	"2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.\n"
+	"3. This notice may not be removed or altered from any source distribution.\n"
+	"*/\n"
+	"//Originally written by Takahiro Harada\n"
+	"typedef unsigned int u32;\n"
+	"#define GET_GROUP_IDX get_group_id(0)\n"
+	"#define GET_LOCAL_IDX get_local_id(0)\n"
+	"#define GET_GLOBAL_IDX get_global_id(0)\n"
+	"#define GET_GROUP_SIZE get_local_size(0)\n"
+	"#define GROUP_LDS_BARRIER barrier(CLK_LOCAL_MEM_FENCE)\n"
+	"// takahiro end\n"
+	"#define WG_SIZE 128 \n"
+	"#define m_numElems x\n"
+	"#define m_numBlocks y\n"
+	"#define m_numScanBlocks z\n"
+	"/*typedef struct\n"
+	"{\n"
+	"	uint m_numElems;\n"
+	"	uint m_numBlocks;\n"
+	"	uint m_numScanBlocks;\n"
+	"	uint m_padding[1];\n"
+	"} ConstBuffer;\n"
+	"*/\n"
+	"float4 ScanExclusiveFloat4(__local float4* data, u32 n, int lIdx, int lSize)\n"
+	"{\n"
+	"	float4 blocksum;\n"
+	"    int offset = 1;\n"
+	"    for(int nActive=n>>1; nActive>0; nActive>>=1, offset<<=1)\n"
+	"    {\n"
+	"        GROUP_LDS_BARRIER;\n"
+	"        for(int iIdx=lIdx; iIdx<nActive; iIdx+=lSize)\n"
+	"        {\n"
+	"            int ai = offset*(2*iIdx+1)-1;\n"
+	"            int bi = offset*(2*iIdx+2)-1;\n"
+	"            data[bi] += data[ai];\n"
+	"        }\n"
+	"	}\n"
+	"    GROUP_LDS_BARRIER;\n"
+	"    if( lIdx == 0 )\n"
+	"	{\n"
+	"		blocksum = data[ n-1 ];\n"
+	"    data[ n-1 ] = 0;\n"
+	"	}\n"
+	"	GROUP_LDS_BARRIER;\n"
+	"	offset >>= 1;\n"
+	"    for(int nActive=1; nActive<n; nActive<<=1, offset>>=1 )\n"
+	"    {\n"
+	"        GROUP_LDS_BARRIER;\n"
+	"        for( int iIdx = lIdx; iIdx<nActive; iIdx += lSize )\n"
+	"        {\n"
+	"            int ai = offset*(2*iIdx+1)-1;\n"
+	"            int bi = offset*(2*iIdx+2)-1;\n"
+	"            float4 temp = data[ai];\n"
+	"            data[ai] = data[bi];\n"
+	"            data[bi] += temp;\n"
+	"        }\n"
+	"	}\n"
+	"	GROUP_LDS_BARRIER;\n"
+	"	return blocksum;\n"
+	"}\n"
+	"__attribute__((reqd_work_group_size(WG_SIZE,1,1)))\n"
+	"__kernel\n"
+	"void LocalScanKernel(__global float4* dst, __global float4* src, __global float4* sumBuffer,	uint4 cb)\n"
+	"{\n"
+	"	__local float4 ldsData[WG_SIZE*2];\n"
+	"	int gIdx = GET_GLOBAL_IDX;\n"
+	"	int lIdx = GET_LOCAL_IDX;\n"
+	"	ldsData[2*lIdx]     = ( 2*gIdx < cb.m_numElems )? src[2*gIdx]: 0;\n"
+	"	ldsData[2*lIdx + 1] = ( 2*gIdx+1 < cb.m_numElems )? src[2*gIdx + 1]: 0;\n"
+	"	float4 sum = ScanExclusiveFloat4(ldsData, WG_SIZE*2, GET_LOCAL_IDX, GET_GROUP_SIZE);\n"
+	"	if( lIdx == 0 ) \n"
+	"		sumBuffer[GET_GROUP_IDX] = sum;\n"
+	"	if( (2*gIdx) < cb.m_numElems )\n"
+	"    {\n"
+	"        dst[2*gIdx]     = ldsData[2*lIdx];\n"
+	"	}\n"
+	"	if( (2*gIdx + 1) < cb.m_numElems )\n"
+	"	{\n"
+	"        dst[2*gIdx + 1] = ldsData[2*lIdx + 1];\n"
+	"    }\n"
+	"}\n"
+	"__attribute__((reqd_work_group_size(WG_SIZE,1,1)))\n"
+	"__kernel\n"
+	"void AddOffsetKernel(__global float4* dst, __global float4* blockSum, uint4 cb)\n"
+	"{\n"
+	"	const u32 blockSize = WG_SIZE*2;\n"
+	"	int myIdx = GET_GROUP_IDX+1;\n"
+	"	int lIdx = GET_LOCAL_IDX;\n"
+	"	float4 iBlockSum = blockSum[myIdx];\n"
+	"	int endValue = min((myIdx+1)*(blockSize), cb.m_numElems);\n"
+	"	for(int i=myIdx*blockSize+lIdx; i<endValue; i+=GET_GROUP_SIZE)\n"
+	"	{\n"
+	"		dst[i] += iBlockSum;\n"
+	"	}\n"
+	"}\n"
+	"__attribute__((reqd_work_group_size(WG_SIZE,1,1)))\n"
+	"__kernel\n"
+	"void TopLevelScanKernel(__global float4* dst, uint4 cb)\n"
+	"{\n"
+	"	__local float4 ldsData[2048];\n"
+	"	int gIdx = GET_GLOBAL_IDX;\n"
+	"	int lIdx = GET_LOCAL_IDX;\n"
+	"	int lSize = GET_GROUP_SIZE;\n"
+	"	for(int i=lIdx; i<cb.m_numScanBlocks; i+=lSize )\n"
+	"	{\n"
+	"		ldsData[i] = (i<cb.m_numBlocks)? dst[i]:0;\n"
+	"	}\n"
+	"	GROUP_LDS_BARRIER;\n"
+	"	float4 sum = ScanExclusiveFloat4(ldsData, cb.m_numScanBlocks, GET_LOCAL_IDX, GET_GROUP_SIZE);\n"
+	"	for(int i=lIdx; i<cb.m_numBlocks; i+=lSize )\n"
+	"	{\n"
+	"		dst[i] = ldsData[i];\n"
+	"	}\n"
+	"	if( gIdx == 0 )\n"
+	"	{\n"
+	"		dst[cb.m_numBlocks] = sum;\n"
+	"	}\n"
+	"}\n";
diff --git a/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/kernels/RadixSort32KernelsCL.h b/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/kernels/RadixSort32KernelsCL.h
new file mode 100644
index 00000000..fb4bdda3
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/ParallelPrimitives/kernels/RadixSort32KernelsCL.h
@@ -0,0 +1,909 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* radixSort32KernelsCL =
+	"/*\n"
+	"Bullet Continuous Collision Detection and Physics Library\n"
+	"Copyright (c) 2011 Advanced Micro Devices, Inc.  http://bulletphysics.org\n"
+	"This software is provided 'as-is', without any express or implied warranty.\n"
+	"In no event will the authors be held liable for any damages arising from the use of this software.\n"
+	"Permission is granted to anyone to use this software for any purpose, \n"
+	"including commercial applications, and to alter it and redistribute it freely, \n"
+	"subject to the following restrictions:\n"
+	"1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.\n"
+	"2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.\n"
+	"3. This notice may not be removed or altered from any source distribution.\n"
+	"*/\n"
+	"//Author Takahiro Harada\n"
+	"//#pragma OPENCL EXTENSION cl_amd_printf : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_local_int32_base_atomics : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_global_int32_base_atomics : enable\n"
+	"typedef unsigned int u32;\n"
+	"#define GET_GROUP_IDX get_group_id(0)\n"
+	"#define GET_LOCAL_IDX get_local_id(0)\n"
+	"#define GET_GLOBAL_IDX get_global_id(0)\n"
+	"#define GET_GROUP_SIZE get_local_size(0)\n"
+	"#define GROUP_LDS_BARRIER barrier(CLK_LOCAL_MEM_FENCE)\n"
+	"#define GROUP_MEM_FENCE mem_fence(CLK_LOCAL_MEM_FENCE)\n"
+	"#define AtomInc(x) atom_inc(&(x))\n"
+	"#define AtomInc1(x, out) out = atom_inc(&(x))\n"
+	"#define AtomAdd(x, value) atom_add(&(x), value)\n"
+	"#define SELECT_UINT4( b, a, condition ) select( b,a,condition )\n"
+	"#define make_uint4 (uint4)\n"
+	"#define make_uint2 (uint2)\n"
+	"#define make_int2 (int2)\n"
+	"#define WG_SIZE 64\n"
+	"#define ELEMENTS_PER_WORK_ITEM (256/WG_SIZE)\n"
+	"#define BITS_PER_PASS 4\n"
+	"#define NUM_BUCKET (1<<BITS_PER_PASS)\n"
+	"typedef uchar u8;\n"
+	"//	this isn't optimization for VLIW. But just reducing writes. \n"
+	"#define USE_2LEVEL_REDUCE 1\n"
+	"//#define CHECK_BOUNDARY 1\n"
+	"//#define NV_GPU 1\n"
+	"//	Cypress\n"
+	"#define nPerWI 16\n"
+	"//	Cayman\n"
+	"//#define nPerWI 20\n"
+	"#define m_n x\n"
+	"#define m_nWGs y\n"
+	"#define m_startBit z\n"
+	"#define m_nBlocksPerWG w\n"
+	"/*\n"
+	"typedef struct\n"
+	"{\n"
+	"	int m_n;\n"
+	"	int m_nWGs;\n"
+	"	int m_startBit;\n"
+	"	int m_nBlocksPerWG;\n"
+	"} ConstBuffer;\n"
+	"*/\n"
+	"typedef struct\n"
+	"{\n"
+	"	unsigned int m_key;\n"
+	"	unsigned int m_value;\n"
+	"} SortDataCL;\n"
+	"uint prefixScanVectorEx( uint4* data )\n"
+	"{\n"
+	"	u32 sum = 0;\n"
+	"	u32 tmp = data[0].x;\n"
+	"	data[0].x = sum;\n"
+	"	sum += tmp;\n"
+	"	tmp = data[0].y;\n"
+	"	data[0].y = sum;\n"
+	"	sum += tmp;\n"
+	"	tmp = data[0].z;\n"
+	"	data[0].z = sum;\n"
+	"	sum += tmp;\n"
+	"	tmp = data[0].w;\n"
+	"	data[0].w = sum;\n"
+	"	sum += tmp;\n"
+	"	return sum;\n"
+	"}\n"
+	"u32 localPrefixSum( u32 pData, uint lIdx, uint* totalSum, __local u32* sorterSharedMemory, int wgSize /*64 or 128*/ )\n"
+	"{\n"
+	"	{	//	Set data\n"
+	"		sorterSharedMemory[lIdx] = 0;\n"
+	"		sorterSharedMemory[lIdx+wgSize] = pData;\n"
+	"	}\n"
+	"	GROUP_LDS_BARRIER;\n"
+	"	{	//	Prefix sum\n"
+	"		int idx = 2*lIdx + (wgSize+1);\n"
+	"#if defined(USE_2LEVEL_REDUCE)\n"
+	"		if( lIdx < 64 )\n"
+	"		{\n"
+	"			u32 u0, u1, u2;\n"
+	"			u0 = sorterSharedMemory[idx-3];\n"
+	"			u1 = sorterSharedMemory[idx-2];\n"
+	"			u2 = sorterSharedMemory[idx-1];\n"
+	"			AtomAdd( sorterSharedMemory[idx], u0+u1+u2 );			\n"
+	"			GROUP_MEM_FENCE;\n"
+	"			u0 = sorterSharedMemory[idx-12];\n"
+	"			u1 = sorterSharedMemory[idx-8];\n"
+	"			u2 = sorterSharedMemory[idx-4];\n"
+	"			AtomAdd( sorterSharedMemory[idx], u0+u1+u2 );			\n"
+	"			GROUP_MEM_FENCE;\n"
+	"			u0 = sorterSharedMemory[idx-48];\n"
+	"			u1 = sorterSharedMemory[idx-32];\n"
+	"			u2 = sorterSharedMemory[idx-16];\n"
+	"			AtomAdd( sorterSharedMemory[idx], u0+u1+u2 );			\n"
+	"			GROUP_MEM_FENCE;\n"
+	"			if( wgSize > 64 )\n"
+	"			{\n"
+	"				sorterSharedMemory[idx] += sorterSharedMemory[idx-64];\n"
+	"				GROUP_MEM_FENCE;\n"
+	"			}\n"
+	"			sorterSharedMemory[idx-1] += sorterSharedMemory[idx-2];\n"
+	"			GROUP_MEM_FENCE;\n"
+	"		}\n"
+	"#else\n"
+	"		if( lIdx < 64 )\n"
+	"		{\n"
+	"			sorterSharedMemory[idx] += sorterSharedMemory[idx-1];\n"
+	"			GROUP_MEM_FENCE;\n"
+	"			sorterSharedMemory[idx] += sorterSharedMemory[idx-2];			\n"
+	"			GROUP_MEM_FENCE;\n"
+	"			sorterSharedMemory[idx] += sorterSharedMemory[idx-4];\n"
+	"			GROUP_MEM_FENCE;\n"
+	"			sorterSharedMemory[idx] += sorterSharedMemory[idx-8];\n"
+	"			GROUP_MEM_FENCE;\n"
+	"			sorterSharedMemory[idx] += sorterSharedMemory[idx-16];\n"
+	"			GROUP_MEM_FENCE;\n"
+	"			sorterSharedMemory[idx] += sorterSharedMemory[idx-32];\n"
+	"			GROUP_MEM_FENCE;\n"
+	"			if( wgSize > 64 )\n"
+	"			{\n"
+	"				sorterSharedMemory[idx] += sorterSharedMemory[idx-64];\n"
+	"				GROUP_MEM_FENCE;\n"
+	"			}\n"
+	"			sorterSharedMemory[idx-1] += sorterSharedMemory[idx-2];\n"
+	"			GROUP_MEM_FENCE;\n"
+	"		}\n"
+	"#endif\n"
+	"	}\n"
+	"	GROUP_LDS_BARRIER;\n"
+	"	*totalSum = sorterSharedMemory[wgSize*2-1];\n"
+	"	u32 addValue = sorterSharedMemory[lIdx+wgSize-1];\n"
+	"	return addValue;\n"
+	"}\n"
+	"//__attribute__((reqd_work_group_size(128,1,1)))\n"
+	"uint4 localPrefixSum128V( uint4 pData, uint lIdx, uint* totalSum, __local u32* sorterSharedMemory )\n"
+	"{\n"
+	"	u32 s4 = prefixScanVectorEx( &pData );\n"
+	"	u32 rank = localPrefixSum( s4, lIdx, totalSum, sorterSharedMemory, 128 );\n"
+	"	return pData + make_uint4( rank, rank, rank, rank );\n"
+	"}\n"
+	"//__attribute__((reqd_work_group_size(64,1,1)))\n"
+	"uint4 localPrefixSum64V( uint4 pData, uint lIdx, uint* totalSum, __local u32* sorterSharedMemory )\n"
+	"{\n"
+	"	u32 s4 = prefixScanVectorEx( &pData );\n"
+	"	u32 rank = localPrefixSum( s4, lIdx, totalSum, sorterSharedMemory, 64 );\n"
+	"	return pData + make_uint4( rank, rank, rank, rank );\n"
+	"}\n"
+	"u32 unpack4Key( u32 key, int keyIdx ){ return (key>>(keyIdx*8)) & 0xff;}\n"
+	"u32 bit8Scan(u32 v)\n"
+	"{\n"
+	"	return (v<<8) + (v<<16) + (v<<24);\n"
+	"}\n"
+	"//===\n"
+	"#define MY_HISTOGRAM(idx) localHistogramMat[(idx)*WG_SIZE+lIdx]\n"
+	"__kernel\n"
+	"__attribute__((reqd_work_group_size(WG_SIZE,1,1)))\n"
+	"void StreamCountKernel( __global u32* gSrc, __global u32* histogramOut, int4 cb )\n"
+	"{\n"
+	"	__local u32 localHistogramMat[NUM_BUCKET*WG_SIZE];\n"
+	"	u32 gIdx = GET_GLOBAL_IDX;\n"
+	"	u32 lIdx = GET_LOCAL_IDX;\n"
+	"	u32 wgIdx = GET_GROUP_IDX;\n"
+	"	u32 wgSize = GET_GROUP_SIZE;\n"
+	"	const int startBit = cb.m_startBit;\n"
+	"	const int n = cb.m_n;\n"
+	"	const int nWGs = cb.m_nWGs;\n"
+	"	const int nBlocksPerWG = cb.m_nBlocksPerWG;\n"
+	"	for(int i=0; i<NUM_BUCKET; i++)\n"
+	"	{\n"
+	"		MY_HISTOGRAM(i) = 0;\n"
+	"	}\n"
+	"	GROUP_LDS_BARRIER;\n"
+	"	const int blockSize = ELEMENTS_PER_WORK_ITEM*WG_SIZE;\n"
+	"	u32 localKey;\n"
+	"	int nBlocks = (n)/blockSize - nBlocksPerWG*wgIdx;\n"
+	"	int addr = blockSize*nBlocksPerWG*wgIdx + ELEMENTS_PER_WORK_ITEM*lIdx;\n"
+	"	for(int iblock=0; iblock<min(nBlocksPerWG, nBlocks); iblock++, addr+=blockSize)\n"
+	"	{\n"
+	"		//	MY_HISTOGRAM( localKeys.x ) ++ is much expensive than atomic add as it requires read and write while atomics can just add on AMD\n"
+	"		//	Using registers didn't perform well. It seems like use localKeys to address requires a lot of alu ops\n"
+	"		//	AMD: AtomInc performs better while NV prefers ++\n"
+	"		for(int i=0; i<ELEMENTS_PER_WORK_ITEM; i++)\n"
+	"		{\n"
+	"#if defined(CHECK_BOUNDARY)\n"
+	"			if( addr+i < n )\n"
+	"#endif\n"
+	"			{\n"
+	"				localKey = (gSrc[addr+i]>>startBit) & 0xf;\n"
+	"#if defined(NV_GPU)\n"
+	"				MY_HISTOGRAM( localKey )++;\n"
+	"#else\n"
+	"				AtomInc( MY_HISTOGRAM( localKey ) );\n"
+	"#endif\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"	GROUP_LDS_BARRIER;\n"
+	"	\n"
+	"	if( lIdx < NUM_BUCKET )\n"
+	"	{\n"
+	"		u32 sum = 0;\n"
+	"		for(int i=0; i<GET_GROUP_SIZE; i++)\n"
+	"		{\n"
+	"			sum += localHistogramMat[lIdx*WG_SIZE+(i+lIdx)%GET_GROUP_SIZE];\n"
+	"		}\n"
+	"		histogramOut[lIdx*nWGs+wgIdx] = sum;\n"
+	"	}\n"
+	"}\n"
+	"__kernel\n"
+	"__attribute__((reqd_work_group_size(WG_SIZE,1,1)))\n"
+	"void StreamCountSortDataKernel( __global SortDataCL* gSrc, __global u32* histogramOut, int4  cb )\n"
+	"{\n"
+	"	__local u32 localHistogramMat[NUM_BUCKET*WG_SIZE];\n"
+	"	u32 gIdx = GET_GLOBAL_IDX;\n"
+	"	u32 lIdx = GET_LOCAL_IDX;\n"
+	"	u32 wgIdx = GET_GROUP_IDX;\n"
+	"	u32 wgSize = GET_GROUP_SIZE;\n"
+	"	const int startBit = cb.m_startBit;\n"
+	"	const int n = cb.m_n;\n"
+	"	const int nWGs = cb.m_nWGs;\n"
+	"	const int nBlocksPerWG = cb.m_nBlocksPerWG;\n"
+	"	for(int i=0; i<NUM_BUCKET; i++)\n"
+	"	{\n"
+	"		MY_HISTOGRAM(i) = 0;\n"
+	"	}\n"
+	"	GROUP_LDS_BARRIER;\n"
+	"	const int blockSize = ELEMENTS_PER_WORK_ITEM*WG_SIZE;\n"
+	"	u32 localKey;\n"
+	"	int nBlocks = (n)/blockSize - nBlocksPerWG*wgIdx;\n"
+	"	int addr = blockSize*nBlocksPerWG*wgIdx + ELEMENTS_PER_WORK_ITEM*lIdx;\n"
+	"	for(int iblock=0; iblock<min(nBlocksPerWG, nBlocks); iblock++, addr+=blockSize)\n"
+	"	{\n"
+	"		//	MY_HISTOGRAM( localKeys.x ) ++ is much expensive than atomic add as it requires read and write while atomics can just add on AMD\n"
+	"		//	Using registers didn't perform well. It seems like use localKeys to address requires a lot of alu ops\n"
+	"		//	AMD: AtomInc performs better while NV prefers ++\n"
+	"		for(int i=0; i<ELEMENTS_PER_WORK_ITEM; i++)\n"
+	"		{\n"
+	"#if defined(CHECK_BOUNDARY)\n"
+	"			if( addr+i < n )\n"
+	"#endif\n"
+	"			{\n"
+	"				localKey = (gSrc[addr+i].m_key>>startBit) & 0xf;\n"
+	"#if defined(NV_GPU)\n"
+	"				MY_HISTOGRAM( localKey )++;\n"
+	"#else\n"
+	"				AtomInc( MY_HISTOGRAM( localKey ) );\n"
+	"#endif\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"	GROUP_LDS_BARRIER;\n"
+	"	\n"
+	"	if( lIdx < NUM_BUCKET )\n"
+	"	{\n"
+	"		u32 sum = 0;\n"
+	"		for(int i=0; i<GET_GROUP_SIZE; i++)\n"
+	"		{\n"
+	"			sum += localHistogramMat[lIdx*WG_SIZE+(i+lIdx)%GET_GROUP_SIZE];\n"
+	"		}\n"
+	"		histogramOut[lIdx*nWGs+wgIdx] = sum;\n"
+	"	}\n"
+	"}\n"
+	"#define nPerLane (nPerWI/4)\n"
+	"//	NUM_BUCKET*nWGs < 128*nPerWI\n"
+	"__kernel\n"
+	"__attribute__((reqd_work_group_size(128,1,1)))\n"
+	"void PrefixScanKernel( __global u32* wHistogram1, int4  cb )\n"
+	"{\n"
+	"	__local u32 ldsTopScanData[128*2];\n"
+	"	u32 lIdx = GET_LOCAL_IDX;\n"
+	"	u32 wgIdx = GET_GROUP_IDX;\n"
+	"	const int nWGs = cb.m_nWGs;\n"
+	"	u32 data[nPerWI];\n"
+	"	for(int i=0; i<nPerWI; i++)\n"
+	"	{\n"
+	"		data[i] = 0;\n"
+	"		if( (nPerWI*lIdx+i) < NUM_BUCKET*nWGs )\n"
+	"			data[i] = wHistogram1[nPerWI*lIdx+i];\n"
+	"	}\n"
+	"	uint4 myData = make_uint4(0,0,0,0);\n"
+	"	for(int i=0; i<nPerLane; i++)\n"
+	"	{\n"
+	"		myData.x += data[nPerLane*0+i];\n"
+	"		myData.y += data[nPerLane*1+i];\n"
+	"		myData.z += data[nPerLane*2+i];\n"
+	"		myData.w += data[nPerLane*3+i];\n"
+	"	}\n"
+	"	uint totalSum;\n"
+	"	uint4 scanned = localPrefixSum128V( myData, lIdx, &totalSum, ldsTopScanData );\n"
+	"//	for(int j=0; j<4; j++) //	somehow it introduces a lot of branches\n"
+	"	{	int j = 0;\n"
+	"		u32 sum = 0;\n"
+	"		for(int i=0; i<nPerLane; i++)\n"
+	"		{\n"
+	"			u32 tmp = data[nPerLane*j+i];\n"
+	"			data[nPerLane*j+i] = sum;\n"
+	"			sum += tmp;\n"
+	"		}\n"
+	"	}\n"
+	"	{	int j = 1;\n"
+	"		u32 sum = 0;\n"
+	"		for(int i=0; i<nPerLane; i++)\n"
+	"		{\n"
+	"			u32 tmp = data[nPerLane*j+i];\n"
+	"			data[nPerLane*j+i] = sum;\n"
+	"			sum += tmp;\n"
+	"		}\n"
+	"	}\n"
+	"	{	int j = 2;\n"
+	"		u32 sum = 0;\n"
+	"		for(int i=0; i<nPerLane; i++)\n"
+	"		{\n"
+	"			u32 tmp = data[nPerLane*j+i];\n"
+	"			data[nPerLane*j+i] = sum;\n"
+	"			sum += tmp;\n"
+	"		}\n"
+	"	}\n"
+	"	{	int j = 3;\n"
+	"		u32 sum = 0;\n"
+	"		for(int i=0; i<nPerLane; i++)\n"
+	"		{\n"
+	"			u32 tmp = data[nPerLane*j+i];\n"
+	"			data[nPerLane*j+i] = sum;\n"
+	"			sum += tmp;\n"
+	"		}\n"
+	"	}\n"
+	"	for(int i=0; i<nPerLane; i++)\n"
+	"	{\n"
+	"		data[nPerLane*0+i] += scanned.x;\n"
+	"		data[nPerLane*1+i] += scanned.y;\n"
+	"		data[nPerLane*2+i] += scanned.z;\n"
+	"		data[nPerLane*3+i] += scanned.w;\n"
+	"	}\n"
+	"	for(int i=0; i<nPerWI; i++)\n"
+	"	{\n"
+	"		int index = nPerWI*lIdx+i;\n"
+	"		if (index < NUM_BUCKET*nWGs)\n"
+	"			wHistogram1[nPerWI*lIdx+i] = data[i];\n"
+	"	}\n"
+	"}\n"
+	"//	4 scan, 4 exchange\n"
+	"void sort4Bits(u32 sortData[4], int startBit, int lIdx, __local u32* ldsSortData)\n"
+	"{\n"
+	"	for(int bitIdx=0; bitIdx<BITS_PER_PASS; bitIdx++)\n"
+	"	{\n"
+	"		u32 mask = (1<<bitIdx);\n"
+	"		uint4 cmpResult = make_uint4( (sortData[0]>>startBit) & mask, (sortData[1]>>startBit) & mask, (sortData[2]>>startBit) & mask, (sortData[3]>>startBit) & mask );\n"
+	"		uint4 prefixSum = SELECT_UINT4( make_uint4(1,1,1,1), make_uint4(0,0,0,0), cmpResult != make_uint4(0,0,0,0) );\n"
+	"		u32 total;\n"
+	"		prefixSum = localPrefixSum64V( prefixSum, lIdx, &total, ldsSortData );\n"
+	"		{\n"
+	"			uint4 localAddr = make_uint4(lIdx*4+0,lIdx*4+1,lIdx*4+2,lIdx*4+3);\n"
+	"			uint4 dstAddr = localAddr - prefixSum + make_uint4( total, total, total, total );\n"
+	"			dstAddr = SELECT_UINT4( prefixSum, dstAddr, cmpResult != make_uint4(0, 0, 0, 0) );\n"
+	"			GROUP_LDS_BARRIER;\n"
+	"			ldsSortData[dstAddr.x] = sortData[0];\n"
+	"			ldsSortData[dstAddr.y] = sortData[1];\n"
+	"			ldsSortData[dstAddr.z] = sortData[2];\n"
+	"			ldsSortData[dstAddr.w] = sortData[3];\n"
+	"			GROUP_LDS_BARRIER;\n"
+	"			sortData[0] = ldsSortData[localAddr.x];\n"
+	"			sortData[1] = ldsSortData[localAddr.y];\n"
+	"			sortData[2] = ldsSortData[localAddr.z];\n"
+	"			sortData[3] = ldsSortData[localAddr.w];\n"
+	"			GROUP_LDS_BARRIER;\n"
+	"		}\n"
+	"	}\n"
+	"}\n"
+	"//	2 scan, 2 exchange\n"
+	"void sort4Bits1(u32 sortData[4], int startBit, int lIdx, __local u32* ldsSortData)\n"
+	"{\n"
+	"	for(uint ibit=0; ibit<BITS_PER_PASS; ibit+=2)\n"
+	"	{\n"
+	"		uint4 b = make_uint4((sortData[0]>>(startBit+ibit)) & 0x3, \n"
+	"			(sortData[1]>>(startBit+ibit)) & 0x3, \n"
+	"			(sortData[2]>>(startBit+ibit)) & 0x3, \n"
+	"			(sortData[3]>>(startBit+ibit)) & 0x3);\n"
+	"		u32 key4;\n"
+	"		u32 sKeyPacked[4] = { 0, 0, 0, 0 };\n"
+	"		{\n"
+	"			sKeyPacked[0] |= 1<<(8*b.x);\n"
+	"			sKeyPacked[1] |= 1<<(8*b.y);\n"
+	"			sKeyPacked[2] |= 1<<(8*b.z);\n"
+	"			sKeyPacked[3] |= 1<<(8*b.w);\n"
+	"			key4 = sKeyPacked[0] + sKeyPacked[1] + sKeyPacked[2] + sKeyPacked[3];\n"
+	"		}\n"
+	"		u32 rankPacked;\n"
+	"		u32 sumPacked;\n"
+	"		{\n"
+	"			rankPacked = localPrefixSum( key4, lIdx, &sumPacked, ldsSortData, WG_SIZE );\n"
+	"		}\n"
+	"		GROUP_LDS_BARRIER;\n"
+	"		u32 newOffset[4] = { 0,0,0,0 };\n"
+	"		{\n"
+	"			u32 sumScanned = bit8Scan( sumPacked );\n"
+	"			u32 scannedKeys[4];\n"
+	"			scannedKeys[0] = 1<<(8*b.x);\n"
+	"			scannedKeys[1] = 1<<(8*b.y);\n"
+	"			scannedKeys[2] = 1<<(8*b.z);\n"
+	"			scannedKeys[3] = 1<<(8*b.w);\n"
+	"			{	//	4 scans at once\n"
+	"				u32 sum4 = 0;\n"
+	"				for(int ie=0; ie<4; ie++)\n"
+	"				{\n"
+	"					u32 tmp = scannedKeys[ie];\n"
+	"					scannedKeys[ie] = sum4;\n"
+	"					sum4 += tmp;\n"
+	"				}\n"
+	"			}\n"
+	"			{\n"
+	"				u32 sumPlusRank = sumScanned + rankPacked;\n"
+	"				{	u32 ie = b.x;\n"
+	"					scannedKeys[0] += sumPlusRank;\n"
+	"					newOffset[0] = unpack4Key( scannedKeys[0], ie );\n"
+	"				}\n"
+	"				{	u32 ie = b.y;\n"
+	"					scannedKeys[1] += sumPlusRank;\n"
+	"					newOffset[1] = unpack4Key( scannedKeys[1], ie );\n"
+	"				}\n"
+	"				{	u32 ie = b.z;\n"
+	"					scannedKeys[2] += sumPlusRank;\n"
+	"					newOffset[2] = unpack4Key( scannedKeys[2], ie );\n"
+	"				}\n"
+	"				{	u32 ie = b.w;\n"
+	"					scannedKeys[3] += sumPlusRank;\n"
+	"					newOffset[3] = unpack4Key( scannedKeys[3], ie );\n"
+	"				}\n"
+	"			}\n"
+	"		}\n"
+	"		GROUP_LDS_BARRIER;\n"
+	"		{\n"
+	"			ldsSortData[newOffset[0]] = sortData[0];\n"
+	"			ldsSortData[newOffset[1]] = sortData[1];\n"
+	"			ldsSortData[newOffset[2]] = sortData[2];\n"
+	"			ldsSortData[newOffset[3]] = sortData[3];\n"
+	"			GROUP_LDS_BARRIER;\n"
+	"			u32 dstAddr = 4*lIdx;\n"
+	"			sortData[0] = ldsSortData[dstAddr+0];\n"
+	"			sortData[1] = ldsSortData[dstAddr+1];\n"
+	"			sortData[2] = ldsSortData[dstAddr+2];\n"
+	"			sortData[3] = ldsSortData[dstAddr+3];\n"
+	"			GROUP_LDS_BARRIER;\n"
+	"		}\n"
+	"	}\n"
+	"}\n"
+	"#define SET_HISTOGRAM(setIdx, key) ldsSortData[(setIdx)*NUM_BUCKET+key]\n"
+	"__kernel\n"
+	"__attribute__((reqd_work_group_size(WG_SIZE,1,1)))\n"
+	"void SortAndScatterKernel( __global const u32* restrict gSrc, __global const u32* rHistogram, __global u32* restrict gDst, int4  cb )\n"
+	"{\n"
+	"	__local u32 ldsSortData[WG_SIZE*ELEMENTS_PER_WORK_ITEM+16];\n"
+	"	__local u32 localHistogramToCarry[NUM_BUCKET];\n"
+	"	__local u32 localHistogram[NUM_BUCKET*2];\n"
+	"	u32 gIdx = GET_GLOBAL_IDX;\n"
+	"	u32 lIdx = GET_LOCAL_IDX;\n"
+	"	u32 wgIdx = GET_GROUP_IDX;\n"
+	"	u32 wgSize = GET_GROUP_SIZE;\n"
+	"	const int n = cb.m_n;\n"
+	"	const int nWGs = cb.m_nWGs;\n"
+	"	const int startBit = cb.m_startBit;\n"
+	"	const int nBlocksPerWG = cb.m_nBlocksPerWG;\n"
+	"	if( lIdx < (NUM_BUCKET) )\n"
+	"	{\n"
+	"		localHistogramToCarry[lIdx] = rHistogram[lIdx*nWGs + wgIdx];\n"
+	"	}\n"
+	"	GROUP_LDS_BARRIER;\n"
+	"	const int blockSize = ELEMENTS_PER_WORK_ITEM*WG_SIZE;\n"
+	"	int nBlocks = n/blockSize - nBlocksPerWG*wgIdx;\n"
+	"	int addr = blockSize*nBlocksPerWG*wgIdx + ELEMENTS_PER_WORK_ITEM*lIdx;\n"
+	"	for(int iblock=0; iblock<min(nBlocksPerWG, nBlocks); iblock++, addr+=blockSize)\n"
+	"	{\n"
+	"		u32 myHistogram = 0;\n"
+	"		u32 sortData[ELEMENTS_PER_WORK_ITEM];\n"
+	"		for(int i=0; i<ELEMENTS_PER_WORK_ITEM; i++)\n"
+	"#if defined(CHECK_BOUNDARY)\n"
+	"			sortData[i] = ( addr+i < n )? gSrc[ addr+i ] : 0xffffffff;\n"
+	"#else\n"
+	"			sortData[i] = gSrc[ addr+i ];\n"
+	"#endif\n"
+	"		sort4Bits(sortData, startBit, lIdx, ldsSortData);\n"
+	"		u32 keys[ELEMENTS_PER_WORK_ITEM];\n"
+	"		for(int i=0; i<ELEMENTS_PER_WORK_ITEM; i++)\n"
+	"			keys[i] = (sortData[i]>>startBit) & 0xf;\n"
+	"		{	//	create histogram\n"
+	"			u32 setIdx = lIdx/16;\n"
+	"			if( lIdx < NUM_BUCKET )\n"
+	"			{\n"
+	"				localHistogram[lIdx] = 0;\n"
+	"			}\n"
+	"			ldsSortData[lIdx] = 0;\n"
+	"			GROUP_LDS_BARRIER;\n"
+	"			for(int i=0; i<ELEMENTS_PER_WORK_ITEM; i++)\n"
+	"#if defined(CHECK_BOUNDARY)\n"
+	"				if( addr+i < n )\n"
+	"#endif\n"
+	"#if defined(NV_GPU)\n"
+	"				SET_HISTOGRAM( setIdx, keys[i] )++;\n"
+	"#else\n"
+	"				AtomInc( SET_HISTOGRAM( setIdx, keys[i] ) );\n"
+	"#endif\n"
+	"			\n"
+	"			GROUP_LDS_BARRIER;\n"
+	"			\n"
+	"			uint hIdx = NUM_BUCKET+lIdx;\n"
+	"			if( lIdx < NUM_BUCKET )\n"
+	"			{\n"
+	"				u32 sum = 0;\n"
+	"				for(int i=0; i<WG_SIZE/16; i++)\n"
+	"				{\n"
+	"					sum += SET_HISTOGRAM( i, lIdx );\n"
+	"				}\n"
+	"				myHistogram = sum;\n"
+	"				localHistogram[hIdx] = sum;\n"
+	"			}\n"
+	"			GROUP_LDS_BARRIER;\n"
+	"#if defined(USE_2LEVEL_REDUCE)\n"
+	"			if( lIdx < NUM_BUCKET )\n"
+	"			{\n"
+	"				localHistogram[hIdx] = localHistogram[hIdx-1];\n"
+	"				GROUP_MEM_FENCE;\n"
+	"				u32 u0, u1, u2;\n"
+	"				u0 = localHistogram[hIdx-3];\n"
+	"				u1 = localHistogram[hIdx-2];\n"
+	"				u2 = localHistogram[hIdx-1];\n"
+	"				AtomAdd( localHistogram[hIdx], u0 + u1 + u2 );\n"
+	"				GROUP_MEM_FENCE;\n"
+	"				u0 = localHistogram[hIdx-12];\n"
+	"				u1 = localHistogram[hIdx-8];\n"
+	"				u2 = localHistogram[hIdx-4];\n"
+	"				AtomAdd( localHistogram[hIdx], u0 + u1 + u2 );\n"
+	"				GROUP_MEM_FENCE;\n"
+	"			}\n"
+	"#else\n"
+	"			if( lIdx < NUM_BUCKET )\n"
+	"			{\n"
+	"				localHistogram[hIdx] = localHistogram[hIdx-1];\n"
+	"				GROUP_MEM_FENCE;\n"
+	"				localHistogram[hIdx] += localHistogram[hIdx-1];\n"
+	"				GROUP_MEM_FENCE;\n"
+	"				localHistogram[hIdx] += localHistogram[hIdx-2];\n"
+	"				GROUP_MEM_FENCE;\n"
+	"				localHistogram[hIdx] += localHistogram[hIdx-4];\n"
+	"				GROUP_MEM_FENCE;\n"
+	"				localHistogram[hIdx] += localHistogram[hIdx-8];\n"
+	"				GROUP_MEM_FENCE;\n"
+	"			}\n"
+	"#endif\n"
+	"			GROUP_LDS_BARRIER;\n"
+	"		}\n"
+	"		{\n"
+	"			for(int ie=0; ie<ELEMENTS_PER_WORK_ITEM; ie++)\n"
+	"			{\n"
+	"				int dataIdx = ELEMENTS_PER_WORK_ITEM*lIdx+ie;\n"
+	"				int binIdx = keys[ie];\n"
+	"				int groupOffset = localHistogramToCarry[binIdx];\n"
+	"				int myIdx = dataIdx - localHistogram[NUM_BUCKET+binIdx];\n"
+	"#if defined(CHECK_BOUNDARY)\n"
+	"				if( addr+ie < n )\n"
+	"#endif\n"
+	"				gDst[ groupOffset + myIdx ] = sortData[ie];\n"
+	"			}\n"
+	"		}\n"
+	"		GROUP_LDS_BARRIER;\n"
+	"		if( lIdx < NUM_BUCKET )\n"
+	"		{\n"
+	"			localHistogramToCarry[lIdx] += myHistogram;\n"
+	"		}\n"
+	"		GROUP_LDS_BARRIER;\n"
+	"	}\n"
+	"}\n"
+	"//	2 scan, 2 exchange\n"
+	"void sort4Bits1KeyValue(u32 sortData[4], int sortVal[4], int startBit, int lIdx, __local u32* ldsSortData, __local int *ldsSortVal)\n"
+	"{\n"
+	"	for(uint ibit=0; ibit<BITS_PER_PASS; ibit+=2)\n"
+	"	{\n"
+	"		uint4 b = make_uint4((sortData[0]>>(startBit+ibit)) & 0x3, \n"
+	"			(sortData[1]>>(startBit+ibit)) & 0x3, \n"
+	"			(sortData[2]>>(startBit+ibit)) & 0x3, \n"
+	"			(sortData[3]>>(startBit+ibit)) & 0x3);\n"
+	"		u32 key4;\n"
+	"		u32 sKeyPacked[4] = { 0, 0, 0, 0 };\n"
+	"		{\n"
+	"			sKeyPacked[0] |= 1<<(8*b.x);\n"
+	"			sKeyPacked[1] |= 1<<(8*b.y);\n"
+	"			sKeyPacked[2] |= 1<<(8*b.z);\n"
+	"			sKeyPacked[3] |= 1<<(8*b.w);\n"
+	"			key4 = sKeyPacked[0] + sKeyPacked[1] + sKeyPacked[2] + sKeyPacked[3];\n"
+	"		}\n"
+	"		u32 rankPacked;\n"
+	"		u32 sumPacked;\n"
+	"		{\n"
+	"			rankPacked = localPrefixSum( key4, lIdx, &sumPacked, ldsSortData, WG_SIZE );\n"
+	"		}\n"
+	"		GROUP_LDS_BARRIER;\n"
+	"		u32 newOffset[4] = { 0,0,0,0 };\n"
+	"		{\n"
+	"			u32 sumScanned = bit8Scan( sumPacked );\n"
+	"			u32 scannedKeys[4];\n"
+	"			scannedKeys[0] = 1<<(8*b.x);\n"
+	"			scannedKeys[1] = 1<<(8*b.y);\n"
+	"			scannedKeys[2] = 1<<(8*b.z);\n"
+	"			scannedKeys[3] = 1<<(8*b.w);\n"
+	"			{	//	4 scans at once\n"
+	"				u32 sum4 = 0;\n"
+	"				for(int ie=0; ie<4; ie++)\n"
+	"				{\n"
+	"					u32 tmp = scannedKeys[ie];\n"
+	"					scannedKeys[ie] = sum4;\n"
+	"					sum4 += tmp;\n"
+	"				}\n"
+	"			}\n"
+	"			{\n"
+	"				u32 sumPlusRank = sumScanned + rankPacked;\n"
+	"				{	u32 ie = b.x;\n"
+	"					scannedKeys[0] += sumPlusRank;\n"
+	"					newOffset[0] = unpack4Key( scannedKeys[0], ie );\n"
+	"				}\n"
+	"				{	u32 ie = b.y;\n"
+	"					scannedKeys[1] += sumPlusRank;\n"
+	"					newOffset[1] = unpack4Key( scannedKeys[1], ie );\n"
+	"				}\n"
+	"				{	u32 ie = b.z;\n"
+	"					scannedKeys[2] += sumPlusRank;\n"
+	"					newOffset[2] = unpack4Key( scannedKeys[2], ie );\n"
+	"				}\n"
+	"				{	u32 ie = b.w;\n"
+	"					scannedKeys[3] += sumPlusRank;\n"
+	"					newOffset[3] = unpack4Key( scannedKeys[3], ie );\n"
+	"				}\n"
+	"			}\n"
+	"		}\n"
+	"		GROUP_LDS_BARRIER;\n"
+	"		{\n"
+	"			ldsSortData[newOffset[0]] = sortData[0];\n"
+	"			ldsSortData[newOffset[1]] = sortData[1];\n"
+	"			ldsSortData[newOffset[2]] = sortData[2];\n"
+	"			ldsSortData[newOffset[3]] = sortData[3];\n"
+	"			ldsSortVal[newOffset[0]] = sortVal[0];\n"
+	"			ldsSortVal[newOffset[1]] = sortVal[1];\n"
+	"			ldsSortVal[newOffset[2]] = sortVal[2];\n"
+	"			ldsSortVal[newOffset[3]] = sortVal[3];\n"
+	"			GROUP_LDS_BARRIER;\n"
+	"			u32 dstAddr = 4*lIdx;\n"
+	"			sortData[0] = ldsSortData[dstAddr+0];\n"
+	"			sortData[1] = ldsSortData[dstAddr+1];\n"
+	"			sortData[2] = ldsSortData[dstAddr+2];\n"
+	"			sortData[3] = ldsSortData[dstAddr+3];\n"
+	"			sortVal[0] = ldsSortVal[dstAddr+0];\n"
+	"			sortVal[1] = ldsSortVal[dstAddr+1];\n"
+	"			sortVal[2] = ldsSortVal[dstAddr+2];\n"
+	"			sortVal[3] = ldsSortVal[dstAddr+3];\n"
+	"			GROUP_LDS_BARRIER;\n"
+	"		}\n"
+	"	}\n"
+	"}\n"
+	"__kernel\n"
+	"__attribute__((reqd_work_group_size(WG_SIZE,1,1)))\n"
+	"void SortAndScatterSortDataKernel( __global const SortDataCL* restrict gSrc, __global const u32* rHistogram, __global SortDataCL* restrict gDst, int4 cb)\n"
+	"{\n"
+	"	__local int ldsSortData[WG_SIZE*ELEMENTS_PER_WORK_ITEM+16];\n"
+	"	__local int ldsSortVal[WG_SIZE*ELEMENTS_PER_WORK_ITEM+16];\n"
+	"	__local u32 localHistogramToCarry[NUM_BUCKET];\n"
+	"	__local u32 localHistogram[NUM_BUCKET*2];\n"
+	"	u32 gIdx = GET_GLOBAL_IDX;\n"
+	"	u32 lIdx = GET_LOCAL_IDX;\n"
+	"	u32 wgIdx = GET_GROUP_IDX;\n"
+	"	u32 wgSize = GET_GROUP_SIZE;\n"
+	"	const int n = cb.m_n;\n"
+	"	const int nWGs = cb.m_nWGs;\n"
+	"	const int startBit = cb.m_startBit;\n"
+	"	const int nBlocksPerWG = cb.m_nBlocksPerWG;\n"
+	"	if( lIdx < (NUM_BUCKET) )\n"
+	"	{\n"
+	"		localHistogramToCarry[lIdx] = rHistogram[lIdx*nWGs + wgIdx];\n"
+	"	}\n"
+	"	GROUP_LDS_BARRIER;\n"
+	"    \n"
+	"	const int blockSize = ELEMENTS_PER_WORK_ITEM*WG_SIZE;\n"
+	"	int nBlocks = n/blockSize - nBlocksPerWG*wgIdx;\n"
+	"	int addr = blockSize*nBlocksPerWG*wgIdx + ELEMENTS_PER_WORK_ITEM*lIdx;\n"
+	"	for(int iblock=0; iblock<min(nBlocksPerWG, nBlocks); iblock++, addr+=blockSize)\n"
+	"	{\n"
+	"		u32 myHistogram = 0;\n"
+	"		int sortData[ELEMENTS_PER_WORK_ITEM];\n"
+	"		int sortVal[ELEMENTS_PER_WORK_ITEM];\n"
+	"		for(int i=0; i<ELEMENTS_PER_WORK_ITEM; i++)\n"
+	"#if defined(CHECK_BOUNDARY)\n"
+	"		{\n"
+	"			sortData[i] = ( addr+i < n )? gSrc[ addr+i ].m_key : 0xffffffff;\n"
+	"			sortVal[i] = ( addr+i < n )? gSrc[ addr+i ].m_value : 0xffffffff;\n"
+	"		}\n"
+	"#else\n"
+	"		{\n"
+	"			sortData[i] = gSrc[ addr+i ].m_key;\n"
+	"			sortVal[i] = gSrc[ addr+i ].m_value;\n"
+	"		}\n"
+	"#endif\n"
+	"		sort4Bits1KeyValue(sortData, sortVal, startBit, lIdx, ldsSortData, ldsSortVal);\n"
+	"		u32 keys[ELEMENTS_PER_WORK_ITEM];\n"
+	"		for(int i=0; i<ELEMENTS_PER_WORK_ITEM; i++)\n"
+	"			keys[i] = (sortData[i]>>startBit) & 0xf;\n"
+	"		{	//	create histogram\n"
+	"			u32 setIdx = lIdx/16;\n"
+	"			if( lIdx < NUM_BUCKET )\n"
+	"			{\n"
+	"				localHistogram[lIdx] = 0;\n"
+	"			}\n"
+	"			ldsSortData[lIdx] = 0;\n"
+	"			GROUP_LDS_BARRIER;\n"
+	"			for(int i=0; i<ELEMENTS_PER_WORK_ITEM; i++)\n"
+	"#if defined(CHECK_BOUNDARY)\n"
+	"				if( addr+i < n )\n"
+	"#endif\n"
+	"#if defined(NV_GPU)\n"
+	"				SET_HISTOGRAM( setIdx, keys[i] )++;\n"
+	"#else\n"
+	"				AtomInc( SET_HISTOGRAM( setIdx, keys[i] ) );\n"
+	"#endif\n"
+	"			\n"
+	"			GROUP_LDS_BARRIER;\n"
+	"			\n"
+	"			uint hIdx = NUM_BUCKET+lIdx;\n"
+	"			if( lIdx < NUM_BUCKET )\n"
+	"			{\n"
+	"				u32 sum = 0;\n"
+	"				for(int i=0; i<WG_SIZE/16; i++)\n"
+	"				{\n"
+	"					sum += SET_HISTOGRAM( i, lIdx );\n"
+	"				}\n"
+	"				myHistogram = sum;\n"
+	"				localHistogram[hIdx] = sum;\n"
+	"			}\n"
+	"			GROUP_LDS_BARRIER;\n"
+	"#if defined(USE_2LEVEL_REDUCE)\n"
+	"			if( lIdx < NUM_BUCKET )\n"
+	"			{\n"
+	"				localHistogram[hIdx] = localHistogram[hIdx-1];\n"
+	"				GROUP_MEM_FENCE;\n"
+	"				u32 u0, u1, u2;\n"
+	"				u0 = localHistogram[hIdx-3];\n"
+	"				u1 = localHistogram[hIdx-2];\n"
+	"				u2 = localHistogram[hIdx-1];\n"
+	"				AtomAdd( localHistogram[hIdx], u0 + u1 + u2 );\n"
+	"				GROUP_MEM_FENCE;\n"
+	"				u0 = localHistogram[hIdx-12];\n"
+	"				u1 = localHistogram[hIdx-8];\n"
+	"				u2 = localHistogram[hIdx-4];\n"
+	"				AtomAdd( localHistogram[hIdx], u0 + u1 + u2 );\n"
+	"				GROUP_MEM_FENCE;\n"
+	"			}\n"
+	"#else\n"
+	"			if( lIdx < NUM_BUCKET )\n"
+	"			{\n"
+	"				localHistogram[hIdx] = localHistogram[hIdx-1];\n"
+	"				GROUP_MEM_FENCE;\n"
+	"				localHistogram[hIdx] += localHistogram[hIdx-1];\n"
+	"				GROUP_MEM_FENCE;\n"
+	"				localHistogram[hIdx] += localHistogram[hIdx-2];\n"
+	"				GROUP_MEM_FENCE;\n"
+	"				localHistogram[hIdx] += localHistogram[hIdx-4];\n"
+	"				GROUP_MEM_FENCE;\n"
+	"				localHistogram[hIdx] += localHistogram[hIdx-8];\n"
+	"				GROUP_MEM_FENCE;\n"
+	"			}\n"
+	"#endif\n"
+	"			GROUP_LDS_BARRIER;\n"
+	"		}\n"
+	"    	{\n"
+	"			for(int ie=0; ie<ELEMENTS_PER_WORK_ITEM; ie++)\n"
+	"			{\n"
+	"				int dataIdx = ELEMENTS_PER_WORK_ITEM*lIdx+ie;\n"
+	"				int binIdx = keys[ie];\n"
+	"				int groupOffset = localHistogramToCarry[binIdx];\n"
+	"				int myIdx = dataIdx - localHistogram[NUM_BUCKET+binIdx];\n"
+	"#if defined(CHECK_BOUNDARY)\n"
+	"				if( addr+ie < n )\n"
+	"				{\n"
+	"                    if ((groupOffset + myIdx)<n)\n"
+	"                    {\n"
+	"                        if (sortData[ie]==sortVal[ie])\n"
+	"                        {\n"
+	"                            \n"
+	"                            SortDataCL tmp;\n"
+	"                            tmp.m_key = sortData[ie];\n"
+	"                            tmp.m_value = sortVal[ie];\n"
+	"                            if (tmp.m_key == tmp.m_value)\n"
+	"                                gDst[groupOffset + myIdx ] = tmp;\n"
+	"                        }\n"
+	"                        \n"
+	"                    }\n"
+	"				}\n"
+	"#else\n"
+	"                if ((groupOffset + myIdx)<n)\n"
+	"                {\n"
+	"                    gDst[ groupOffset + myIdx ].m_key = sortData[ie];\n"
+	"                    gDst[ groupOffset + myIdx ].m_value = sortVal[ie];\n"
+	"                }\n"
+	"#endif\n"
+	"			}\n"
+	"		}\n"
+	"		GROUP_LDS_BARRIER;\n"
+	"		if( lIdx < NUM_BUCKET )\n"
+	"		{\n"
+	"			localHistogramToCarry[lIdx] += myHistogram;\n"
+	"		}\n"
+	"		GROUP_LDS_BARRIER;\n"
+	"	}\n"
+	"}\n"
+	"__kernel\n"
+	"__attribute__((reqd_work_group_size(WG_SIZE,1,1)))\n"
+	"void SortAndScatterSortDataKernelSerial( __global const SortDataCL* restrict gSrc, __global const u32* rHistogram, __global SortDataCL* restrict gDst, int4 cb)\n"
+	"{\n"
+	"    \n"
+	"	u32 gIdx = GET_GLOBAL_IDX;\n"
+	"	u32 realLocalIdx = GET_LOCAL_IDX;\n"
+	"	u32 wgIdx = GET_GROUP_IDX;\n"
+	"	u32 wgSize = GET_GROUP_SIZE;\n"
+	"	const int startBit = cb.m_startBit;\n"
+	"	const int n = cb.m_n;\n"
+	"	const int nWGs = cb.m_nWGs;\n"
+	"	const int nBlocksPerWG = cb.m_nBlocksPerWG;\n"
+	"    int counter[NUM_BUCKET];\n"
+	"    \n"
+	"    if (realLocalIdx>0)\n"
+	"        return;\n"
+	"    \n"
+	"    for (int c=0;c<NUM_BUCKET;c++)\n"
+	"        counter[c]=0;\n"
+	"    const int blockSize = ELEMENTS_PER_WORK_ITEM*WG_SIZE;\n"
+	"	\n"
+	"	int nBlocks = (n)/blockSize - nBlocksPerWG*wgIdx;\n"
+	"   for(int iblock=0; iblock<min(nBlocksPerWG, nBlocks); iblock++)\n"
+	"  {\n"
+	"     for (int lIdx=0;lIdx<WG_SIZE;lIdx++)\n"
+	" 	{\n"
+	"        int addr2 = iblock*blockSize + blockSize*nBlocksPerWG*wgIdx + ELEMENTS_PER_WORK_ITEM*lIdx;\n"
+	"        \n"
+	"		for(int j=0; j<ELEMENTS_PER_WORK_ITEM; j++)\n"
+	"		{\n"
+	"            int i = addr2+j;\n"
+	"			if( i < n )\n"
+	"			{\n"
+	"                int tableIdx;\n"
+	"				tableIdx = (gSrc[i].m_key>>startBit) & 0xf;//0xf = NUM_TABLES-1\n"
+	"                gDst[rHistogram[tableIdx*nWGs+wgIdx] + counter[tableIdx]] = gSrc[i];\n"
+	"                counter[tableIdx] ++;\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"  }\n"
+	"    \n"
+	"}\n"
+	"__kernel\n"
+	"__attribute__((reqd_work_group_size(WG_SIZE,1,1)))\n"
+	"void SortAndScatterKernelSerial( __global const u32* restrict gSrc, __global const u32* rHistogram, __global u32* restrict gDst, int4  cb )\n"
+	"{\n"
+	"    \n"
+	"	u32 gIdx = GET_GLOBAL_IDX;\n"
+	"	u32 realLocalIdx = GET_LOCAL_IDX;\n"
+	"	u32 wgIdx = GET_GROUP_IDX;\n"
+	"	u32 wgSize = GET_GROUP_SIZE;\n"
+	"	const int startBit = cb.m_startBit;\n"
+	"	const int n = cb.m_n;\n"
+	"	const int nWGs = cb.m_nWGs;\n"
+	"	const int nBlocksPerWG = cb.m_nBlocksPerWG;\n"
+	"    int counter[NUM_BUCKET];\n"
+	"    \n"
+	"    if (realLocalIdx>0)\n"
+	"        return;\n"
+	"    \n"
+	"    for (int c=0;c<NUM_BUCKET;c++)\n"
+	"        counter[c]=0;\n"
+	"    const int blockSize = ELEMENTS_PER_WORK_ITEM*WG_SIZE;\n"
+	"	\n"
+	"	int nBlocks = (n)/blockSize - nBlocksPerWG*wgIdx;\n"
+	"   for(int iblock=0; iblock<min(nBlocksPerWG, nBlocks); iblock++)\n"
+	"  {\n"
+	"     for (int lIdx=0;lIdx<WG_SIZE;lIdx++)\n"
+	" 	{\n"
+	"        int addr2 = iblock*blockSize + blockSize*nBlocksPerWG*wgIdx + ELEMENTS_PER_WORK_ITEM*lIdx;\n"
+	"        \n"
+	"		for(int j=0; j<ELEMENTS_PER_WORK_ITEM; j++)\n"
+	"		{\n"
+	"            int i = addr2+j;\n"
+	"			if( i < n )\n"
+	"			{\n"
+	"                int tableIdx;\n"
+	"				tableIdx = (gSrc[i]>>startBit) & 0xf;//0xf = NUM_TABLES-1\n"
+	"                gDst[rHistogram[tableIdx*nWGs+wgIdx] + counter[tableIdx]] = gSrc[i];\n"
+	"                counter[tableIdx] ++;\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"  }\n"
+	"    \n"
+	"}\n";
diff --git a/engine/inc/bullet/Bullet3OpenCL/Raycast/b3GpuRaycast.h b/engine/inc/bullet/Bullet3OpenCL/Raycast/b3GpuRaycast.h
new file mode 100644
index 00000000..f1f6ffd4
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/Raycast/b3GpuRaycast.h
@@ -0,0 +1,28 @@
+#ifndef B3_GPU_RAYCAST_H
+#define B3_GPU_RAYCAST_H
+
+#include "Bullet3Common/b3Vector3.h"
+#include "Bullet3OpenCL/Initialize/b3OpenCLInclude.h"
+
+#include "Bullet3Common/b3AlignedObjectArray.h"
+#include "Bullet3Collision/NarrowPhaseCollision/b3RaycastInfo.h"
+
+class b3GpuRaycast
+{
+protected:
+	struct b3GpuRaycastInternalData* m_data;
+
+public:
+	b3GpuRaycast(cl_context ctx, cl_device_id device, cl_command_queue q);
+	virtual ~b3GpuRaycast();
+
+	void castRaysHost(const b3AlignedObjectArray<b3RayInfo>& raysIn, b3AlignedObjectArray<b3RayHit>& hitResults,
+					  int numBodies, const struct b3RigidBodyData* bodies, int numCollidables, const struct b3Collidable* collidables,
+					  const struct b3GpuNarrowPhaseInternalData* narrowphaseData);
+
+	void castRays(const b3AlignedObjectArray<b3RayInfo>& rays, b3AlignedObjectArray<b3RayHit>& hitResults,
+				  int numBodies, const struct b3RigidBodyData* bodies, int numCollidables, const struct b3Collidable* collidables,
+				  const struct b3GpuNarrowPhaseInternalData* narrowphaseData, class b3GpuBroadphaseInterface* broadphase);
+};
+
+#endif  //B3_GPU_RAYCAST_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/Raycast/kernels/rayCastKernels.h b/engine/inc/bullet/Bullet3OpenCL/Raycast/kernels/rayCastKernels.h
new file mode 100644
index 00000000..94f6a8eb
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/Raycast/kernels/rayCastKernels.h
@@ -0,0 +1,380 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* rayCastKernelCL =
+	"#define SHAPE_CONVEX_HULL 3\n"
+	"#define SHAPE_PLANE 4\n"
+	"#define SHAPE_CONCAVE_TRIMESH 5\n"
+	"#define SHAPE_COMPOUND_OF_CONVEX_HULLS 6\n"
+	"#define SHAPE_SPHERE 7\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4 m_from;\n"
+	"	float4 m_to;\n"
+	"} b3RayInfo;\n"
+	"typedef struct\n"
+	"{\n"
+	"	float m_hitFraction;\n"
+	"	int	m_hitResult0;\n"
+	"	int	m_hitResult1;\n"
+	"	int	m_hitResult2;\n"
+	"	float4	m_hitPoint;\n"
+	"	float4	m_hitNormal;\n"
+	"} b3RayHit;\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4 m_pos;\n"
+	"	float4 m_quat;\n"
+	"	float4 m_linVel;\n"
+	"	float4 m_angVel;\n"
+	"	unsigned int m_collidableIdx;\n"
+	"	float m_invMass;\n"
+	"	float m_restituitionCoeff;\n"
+	"	float m_frictionCoeff;\n"
+	"} Body;\n"
+	"typedef struct Collidable\n"
+	"{\n"
+	"	union {\n"
+	"		int m_numChildShapes;\n"
+	"		int m_bvhIndex;\n"
+	"	};\n"
+	"	float m_radius;\n"
+	"	int m_shapeType;\n"
+	"	int m_shapeIndex;\n"
+	"} Collidable;\n"
+	"typedef struct  \n"
+	"{\n"
+	"	float4		m_localCenter;\n"
+	"	float4		m_extents;\n"
+	"	float4		mC;\n"
+	"	float4		mE;\n"
+	"	float			m_radius;\n"
+	"	int	m_faceOffset;\n"
+	"	int m_numFaces;\n"
+	"	int	m_numVertices;\n"
+	"	int m_vertexOffset;\n"
+	"	int	m_uniqueEdgesOffset;\n"
+	"	int	m_numUniqueEdges;\n"
+	"	int m_unused;\n"
+	"} ConvexPolyhedronCL;\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4 m_plane;\n"
+	"	int m_indexOffset;\n"
+	"	int m_numIndices;\n"
+	"} b3GpuFace;\n"
+	"///////////////////////////////////////\n"
+	"//	Quaternion\n"
+	"///////////////////////////////////////\n"
+	"typedef float4 Quaternion;\n"
+	"__inline\n"
+	"	Quaternion qtMul(Quaternion a, Quaternion b);\n"
+	"__inline\n"
+	"	Quaternion qtNormalize(Quaternion in);\n"
+	"__inline\n"
+	"	Quaternion qtInvert(Quaternion q);\n"
+	"__inline\n"
+	"	float dot3F4(float4 a, float4 b)\n"
+	"{\n"
+	"	float4 a1 = (float4)(a.xyz,0.f);\n"
+	"	float4 b1 = (float4)(b.xyz,0.f);\n"
+	"	return dot(a1, b1);\n"
+	"}\n"
+	"__inline\n"
+	"	Quaternion qtMul(Quaternion a, Quaternion b)\n"
+	"{\n"
+	"	Quaternion ans;\n"
+	"	ans = cross( a, b );\n"
+	"	ans += a.w*b+b.w*a;\n"
+	"	//	ans.w = a.w*b.w - (a.x*b.x+a.y*b.y+a.z*b.z);\n"
+	"	ans.w = a.w*b.w - dot3F4(a, b);\n"
+	"	return ans;\n"
+	"}\n"
+	"__inline\n"
+	"	Quaternion qtNormalize(Quaternion in)\n"
+	"{\n"
+	"	return fast_normalize(in);\n"
+	"	//	in /= length( in );\n"
+	"	//	return in;\n"
+	"}\n"
+	"__inline\n"
+	"	float4 qtRotate(Quaternion q, float4 vec)\n"
+	"{\n"
+	"	Quaternion qInv = qtInvert( q );\n"
+	"	float4 vcpy = vec;\n"
+	"	vcpy.w = 0.f;\n"
+	"	float4 out = qtMul(q,vcpy);\n"
+	"	out = qtMul(out,qInv);\n"
+	"	return out;\n"
+	"}\n"
+	"__inline\n"
+	"	Quaternion qtInvert(Quaternion q)\n"
+	"{\n"
+	"	return (Quaternion)(-q.xyz, q.w);\n"
+	"}\n"
+	"__inline\n"
+	"	float4 qtInvRotate(const Quaternion q, float4 vec)\n"
+	"{\n"
+	"	return qtRotate( qtInvert( q ), vec );\n"
+	"}\n"
+	"void	trInverse(float4 translationIn, Quaternion orientationIn,\n"
+	"	float4* translationOut, Quaternion* orientationOut)\n"
+	"{\n"
+	"	*orientationOut = qtInvert(orientationIn);\n"
+	"	*translationOut = qtRotate(*orientationOut, -translationIn);\n"
+	"}\n"
+	"bool rayConvex(float4 rayFromLocal, float4 rayToLocal, int numFaces, int faceOffset,\n"
+	"	__global const b3GpuFace* faces, float* hitFraction, float4* hitNormal)\n"
+	"{\n"
+	"	rayFromLocal.w = 0.f;\n"
+	"	rayToLocal.w = 0.f;\n"
+	"	bool result = true;\n"
+	"	float exitFraction = hitFraction[0];\n"
+	"	float enterFraction = -0.3f;\n"
+	"	float4 curHitNormal = (float4)(0,0,0,0);\n"
+	"	for (int i=0;i<numFaces && result;i++)\n"
+	"	{\n"
+	"		b3GpuFace face = faces[faceOffset+i];\n"
+	"		float fromPlaneDist = dot(rayFromLocal,face.m_plane)+face.m_plane.w;\n"
+	"		float toPlaneDist = dot(rayToLocal,face.m_plane)+face.m_plane.w;\n"
+	"		if (fromPlaneDist<0.f)\n"
+	"		{\n"
+	"			if (toPlaneDist >= 0.f)\n"
+	"			{\n"
+	"				float fraction = fromPlaneDist / (fromPlaneDist-toPlaneDist);\n"
+	"				if (exitFraction>fraction)\n"
+	"				{\n"
+	"					exitFraction = fraction;\n"
+	"				}\n"
+	"			} 			\n"
+	"		} else\n"
+	"		{\n"
+	"			if (toPlaneDist<0.f)\n"
+	"			{\n"
+	"				float fraction = fromPlaneDist / (fromPlaneDist-toPlaneDist);\n"
+	"				if (enterFraction <= fraction)\n"
+	"				{\n"
+	"					enterFraction = fraction;\n"
+	"					curHitNormal = face.m_plane;\n"
+	"					curHitNormal.w = 0.f;\n"
+	"				}\n"
+	"			} else\n"
+	"			{\n"
+	"				result = false;\n"
+	"			}\n"
+	"		}\n"
+	"		if (exitFraction <= enterFraction)\n"
+	"			result = false;\n"
+	"	}\n"
+	"	if (enterFraction < 0.f)\n"
+	"	{\n"
+	"		result = false;\n"
+	"	}\n"
+	"	if (result)\n"
+	"	{	\n"
+	"		hitFraction[0] = enterFraction;\n"
+	"		hitNormal[0] = curHitNormal;\n"
+	"	}\n"
+	"	return result;\n"
+	"}\n"
+	"bool sphere_intersect(float4 spherePos,  float radius, float4 rayFrom, float4 rayTo, float* hitFraction)\n"
+	"{\n"
+	"	float4 rs = rayFrom - spherePos;\n"
+	"	rs.w = 0.f;\n"
+	"	float4 rayDir = rayTo-rayFrom;\n"
+	"	rayDir.w = 0.f;\n"
+	"	float A = dot(rayDir,rayDir);\n"
+	"	float B = dot(rs, rayDir);\n"
+	"	float C = dot(rs, rs) - (radius * radius);\n"
+	"	float D = B * B - A*C;\n"
+	"	if (D > 0.0f)\n"
+	"	{\n"
+	"		float t = (-B - sqrt(D))/A;\n"
+	"		if ( (t >= 0.0f) && (t < (*hitFraction)) )\n"
+	"		{\n"
+	"			*hitFraction = t;\n"
+	"			return true;\n"
+	"		}\n"
+	"	}\n"
+	"	return false;\n"
+	"}\n"
+	"float4 setInterpolate3(float4 from, float4 to, float t)\n"
+	"{\n"
+	"	float s = 1.0f - t;\n"
+	"	float4 result;\n"
+	"	result = s * from + t * to;\n"
+	"	result.w = 0.f;	\n"
+	"	return result;	\n"
+	"}\n"
+	"__kernel void rayCastKernel(  \n"
+	"	int numRays, \n"
+	"	const __global b3RayInfo* rays, \n"
+	"	__global b3RayHit* hitResults, \n"
+	"	const int numBodies, \n"
+	"	__global Body* bodies,\n"
+	"	__global Collidable* collidables,\n"
+	"	__global const b3GpuFace* faces,\n"
+	"	__global const ConvexPolyhedronCL* convexShapes	)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	if (i>=numRays)\n"
+	"		return;\n"
+	"	hitResults[i].m_hitFraction = 1.f;\n"
+	"	float4 rayFrom = rays[i].m_from;\n"
+	"	float4 rayTo = rays[i].m_to;\n"
+	"	float hitFraction = 1.f;\n"
+	"	float4 hitPoint;\n"
+	"	float4 hitNormal;\n"
+	"	int hitBodyIndex= -1;\n"
+	"	int cachedCollidableIndex = -1;\n"
+	"	Collidable cachedCollidable;\n"
+	"	for (int b=0;b<numBodies;b++)\n"
+	"	{\n"
+	"		if (hitResults[i].m_hitResult2==b)\n"
+	"			continue;\n"
+	"		Body body = bodies[b];\n"
+	"		float4 pos = body.m_pos;\n"
+	"		float4 orn = body.m_quat;\n"
+	"		if (cachedCollidableIndex != body.m_collidableIdx)\n"
+	"		{\n"
+	"			cachedCollidableIndex = body.m_collidableIdx;\n"
+	"			cachedCollidable = collidables[cachedCollidableIndex];\n"
+	"		}\n"
+	"		if (cachedCollidable.m_shapeType == SHAPE_CONVEX_HULL)\n"
+	"		{\n"
+	"			float4 invPos = (float4)(0,0,0,0);\n"
+	"			float4 invOrn = (float4)(0,0,0,0);\n"
+	"			float4 rayFromLocal = (float4)(0,0,0,0);\n"
+	"			float4 rayToLocal = (float4)(0,0,0,0);\n"
+	"			invOrn = qtInvert(orn);\n"
+	"			invPos = qtRotate(invOrn, -pos);\n"
+	"			rayFromLocal = qtRotate( invOrn, rayFrom ) + invPos;\n"
+	"			rayToLocal = qtRotate( invOrn, rayTo) + invPos;\n"
+	"			rayFromLocal.w = 0.f;\n"
+	"			rayToLocal.w = 0.f;\n"
+	"			int numFaces = convexShapes[cachedCollidable.m_shapeIndex].m_numFaces;\n"
+	"			int faceOffset = convexShapes[cachedCollidable.m_shapeIndex].m_faceOffset;\n"
+	"			if (numFaces)\n"
+	"			{\n"
+	"				if (rayConvex(rayFromLocal, rayToLocal, numFaces, faceOffset,faces, &hitFraction, &hitNormal))\n"
+	"				{\n"
+	"					hitBodyIndex = b;\n"
+	"					\n"
+	"				}\n"
+	"			}\n"
+	"		}\n"
+	"		if (cachedCollidable.m_shapeType == SHAPE_SPHERE)\n"
+	"		{\n"
+	"			float radius = cachedCollidable.m_radius;\n"
+	"		\n"
+	"			if (sphere_intersect(pos,  radius, rayFrom, rayTo, &hitFraction))\n"
+	"			{\n"
+	"				hitBodyIndex = b;\n"
+	"				hitNormal = (float4) (hitPoint-bodies[b].m_pos);\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"	if (hitBodyIndex>=0)\n"
+	"	{\n"
+	"		hitPoint = setInterpolate3(rayFrom, rayTo,hitFraction);\n"
+	"		hitResults[i].m_hitFraction = hitFraction;\n"
+	"		hitResults[i].m_hitPoint = hitPoint;\n"
+	"		hitResults[i].m_hitNormal = normalize(hitNormal);\n"
+	"		hitResults[i].m_hitResult0 = hitBodyIndex;\n"
+	"	}\n"
+	"}\n"
+	"__kernel void findRayRigidPairIndexRanges(__global int2* rayRigidPairs, \n"
+	"											__global int* out_firstRayRigidPairIndexPerRay,\n"
+	"											__global int* out_numRayRigidPairsPerRay,\n"
+	"											int numRayRigidPairs)\n"
+	"{\n"
+	"	int rayRigidPairIndex = get_global_id(0);\n"
+	"	if (rayRigidPairIndex >= numRayRigidPairs) return;\n"
+	"	\n"
+	"	int rayIndex = rayRigidPairs[rayRigidPairIndex].x;\n"
+	"	\n"
+	"	atomic_min(&out_firstRayRigidPairIndexPerRay[rayIndex], rayRigidPairIndex);\n"
+	"	atomic_inc(&out_numRayRigidPairsPerRay[rayIndex]);\n"
+	"}\n"
+	"__kernel void rayCastPairsKernel(const __global b3RayInfo* rays, \n"
+	"								__global b3RayHit* hitResults, \n"
+	"								__global int* firstRayRigidPairIndexPerRay,\n"
+	"								__global int* numRayRigidPairsPerRay,\n"
+	"									\n"
+	"								__global Body* bodies,\n"
+	"								__global Collidable* collidables,\n"
+	"								__global const b3GpuFace* faces,\n"
+	"								__global const ConvexPolyhedronCL* convexShapes,\n"
+	"								\n"
+	"								__global int2* rayRigidPairs,\n"
+	"								int numRays)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	if (i >= numRays) return;\n"
+	"	\n"
+	"	float4 rayFrom = rays[i].m_from;\n"
+	"	float4 rayTo = rays[i].m_to;\n"
+	"		\n"
+	"	hitResults[i].m_hitFraction = 1.f;\n"
+	"		\n"
+	"	float hitFraction = 1.f;\n"
+	"	float4 hitPoint;\n"
+	"	float4 hitNormal;\n"
+	"	int hitBodyIndex = -1;\n"
+	"		\n"
+	"	//\n"
+	"	for(int pair = 0; pair < numRayRigidPairsPerRay[i]; ++pair)\n"
+	"	{\n"
+	"		int rayRigidPairIndex = pair + firstRayRigidPairIndexPerRay[i];\n"
+	"		int b = rayRigidPairs[rayRigidPairIndex].y;\n"
+	"		\n"
+	"		if (hitResults[i].m_hitResult2 == b) continue;\n"
+	"		\n"
+	"		Body body = bodies[b];\n"
+	"		Collidable rigidCollidable = collidables[body.m_collidableIdx];\n"
+	"		\n"
+	"		float4 pos = body.m_pos;\n"
+	"		float4 orn = body.m_quat;\n"
+	"		\n"
+	"		if (rigidCollidable.m_shapeType == SHAPE_CONVEX_HULL)\n"
+	"		{\n"
+	"			float4 invPos = (float4)(0,0,0,0);\n"
+	"			float4 invOrn = (float4)(0,0,0,0);\n"
+	"			float4 rayFromLocal = (float4)(0,0,0,0);\n"
+	"			float4 rayToLocal = (float4)(0,0,0,0);\n"
+	"			invOrn = qtInvert(orn);\n"
+	"			invPos = qtRotate(invOrn, -pos);\n"
+	"			rayFromLocal = qtRotate( invOrn, rayFrom ) + invPos;\n"
+	"			rayToLocal = qtRotate( invOrn, rayTo) + invPos;\n"
+	"			rayFromLocal.w = 0.f;\n"
+	"			rayToLocal.w = 0.f;\n"
+	"			int numFaces = convexShapes[rigidCollidable.m_shapeIndex].m_numFaces;\n"
+	"			int faceOffset = convexShapes[rigidCollidable.m_shapeIndex].m_faceOffset;\n"
+	"			\n"
+	"			if (numFaces && rayConvex(rayFromLocal, rayToLocal, numFaces, faceOffset,faces, &hitFraction, &hitNormal))\n"
+	"			{\n"
+	"				hitBodyIndex = b;\n"
+	"				hitPoint = setInterpolate3(rayFrom, rayTo, hitFraction);\n"
+	"			}\n"
+	"		}\n"
+	"		\n"
+	"		if (rigidCollidable.m_shapeType == SHAPE_SPHERE)\n"
+	"		{\n"
+	"			float radius = rigidCollidable.m_radius;\n"
+	"		\n"
+	"			if (sphere_intersect(pos, radius, rayFrom, rayTo, &hitFraction))\n"
+	"			{\n"
+	"				hitBodyIndex = b;\n"
+	"				hitPoint = setInterpolate3(rayFrom, rayTo, hitFraction);\n"
+	"				hitNormal = (float4) (hitPoint - bodies[b].m_pos);\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"	\n"
+	"	if (hitBodyIndex >= 0)\n"
+	"	{\n"
+	"		hitResults[i].m_hitFraction = hitFraction;\n"
+	"		hitResults[i].m_hitPoint = hitPoint;\n"
+	"		hitResults[i].m_hitNormal = normalize(hitNormal);\n"
+	"		hitResults[i].m_hitResult0 = hitBodyIndex;\n"
+	"	}\n"
+	"	\n"
+	"}\n";
diff --git a/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuConstraint4.h b/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuConstraint4.h
new file mode 100644
index 00000000..89c0142a
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuConstraint4.h
@@ -0,0 +1,17 @@
+
+#ifndef B3_CONSTRAINT4_h
+#define B3_CONSTRAINT4_h
+#include "Bullet3Common/b3Vector3.h"
+
+#include "Bullet3Dynamics/shared/b3ContactConstraint4.h"
+
+B3_ATTRIBUTE_ALIGNED16(struct)
+b3GpuConstraint4 : public b3ContactConstraint4
+{
+	B3_DECLARE_ALIGNED_ALLOCATOR();
+
+	inline void setFrictionCoeff(float value) { m_linear[3] = value; }
+	inline float getFrictionCoeff() const { return m_linear[3]; }
+};
+
+#endif  //B3_CONSTRAINT4_h
diff --git a/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuGenericConstraint.h b/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuGenericConstraint.h
new file mode 100644
index 00000000..1f163ba7
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuGenericConstraint.h
@@ -0,0 +1,128 @@
+/*
+Copyright (c) 2013 Advanced Micro Devices, Inc.  
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+//Originally written by Erwin Coumans
+
+#ifndef B3_GPU_GENERIC_CONSTRAINT_H
+#define B3_GPU_GENERIC_CONSTRAINT_H
+
+#include "Bullet3Common/b3Quaternion.h"
+struct b3RigidBodyData;
+enum B3_CONSTRAINT_FLAGS
+{
+	B3_CONSTRAINT_FLAG_ENABLED = 1,
+};
+
+enum b3GpuGenericConstraintType
+{
+	B3_GPU_POINT2POINT_CONSTRAINT_TYPE = 3,
+	B3_GPU_FIXED_CONSTRAINT_TYPE = 4,
+	//	B3_HINGE_CONSTRAINT_TYPE,
+	//	B3_CONETWIST_CONSTRAINT_TYPE,
+	//	B3_D6_CONSTRAINT_TYPE,
+	//	B3_SLIDER_CONSTRAINT_TYPE,
+	//	B3_CONTACT_CONSTRAINT_TYPE,
+	//	B3_D6_SPRING_CONSTRAINT_TYPE,
+	//	B3_GEAR_CONSTRAINT_TYPE,
+
+	B3_GPU_MAX_CONSTRAINT_TYPE
+};
+
+struct b3GpuConstraintInfo2
+{
+	// integrator parameters: frames per second (1/stepsize), default error
+	// reduction parameter (0..1).
+	b3Scalar fps, erp;
+
+	// for the first and second body, pointers to two (linear and angular)
+	// n*3 jacobian sub matrices, stored by rows. these matrices will have
+	// been initialized to 0 on entry. if the second body is zero then the
+	// J2xx pointers may be 0.
+	b3Scalar *m_J1linearAxis, *m_J1angularAxis, *m_J2linearAxis, *m_J2angularAxis;
+
+	// elements to jump from one row to the next in J's
+	int rowskip;
+
+	// right hand sides of the equation J*v = c + cfm * lambda. cfm is the
+	// "constraint force mixing" vector. c is set to zero on entry, cfm is
+	// set to a constant value (typically very small or zero) value on entry.
+	b3Scalar *m_constraintError, *cfm;
+
+	// lo and hi limits for variables (set to -/+ infinity on entry).
+	b3Scalar *m_lowerLimit, *m_upperLimit;
+
+	// findex vector for variables. see the LCP solver interface for a
+	// description of what this does. this is set to -1 on entry.
+	// note that the returned indexes are relative to the first index of
+	// the constraint.
+	int* findex;
+	// number of solver iterations
+	int m_numIterations;
+
+	//damping of the velocity
+	b3Scalar m_damping;
+};
+
+B3_ATTRIBUTE_ALIGNED16(struct)
+b3GpuGenericConstraint
+{
+	int m_constraintType;
+	int m_rbA;
+	int m_rbB;
+	float m_breakingImpulseThreshold;
+
+	b3Vector3 m_pivotInA;
+	b3Vector3 m_pivotInB;
+	b3Quaternion m_relTargetAB;
+
+	int m_flags;
+	int m_uid;
+	int m_padding[2];
+
+	int getRigidBodyA() const
+	{
+		return m_rbA;
+	}
+	int getRigidBodyB() const
+	{
+		return m_rbB;
+	}
+
+	const b3Vector3& getPivotInA() const
+	{
+		return m_pivotInA;
+	}
+
+	const b3Vector3& getPivotInB() const
+	{
+		return m_pivotInB;
+	}
+
+	int isEnabled() const
+	{
+		return m_flags & B3_CONSTRAINT_FLAG_ENABLED;
+	}
+
+	float getBreakingImpulseThreshold() const
+	{
+		return m_breakingImpulseThreshold;
+	}
+
+	///internal method used by the constraint solver, don't use them directly
+	void getInfo1(unsigned int* info, const b3RigidBodyData* bodies);
+
+	///internal method used by the constraint solver, don't use them directly
+	void getInfo2(b3GpuConstraintInfo2 * info, const b3RigidBodyData* bodies);
+};
+
+#endif  //B3_GPU_GENERIC_CONSTRAINT_H
\ No newline at end of file
diff --git a/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuJacobiContactSolver.h b/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuJacobiContactSolver.h
new file mode 100644
index 00000000..8281aee0
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuJacobiContactSolver.h
@@ -0,0 +1,56 @@
+
+#ifndef B3_GPU_JACOBI_CONTACT_SOLVER_H
+#define B3_GPU_JACOBI_CONTACT_SOLVER_H
+#include "Bullet3OpenCL/Initialize/b3OpenCLInclude.h"
+//#include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h"
+
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3Contact4Data.h"
+#include "Bullet3OpenCL/ParallelPrimitives/b3OpenCLArray.h"
+
+//struct b3InertiaData;
+//b3InertiaData
+
+class b3TypedConstraint;
+
+struct b3JacobiSolverInfo
+{
+	int m_fixedBodyIndex;
+
+	float m_deltaTime;
+	float m_positionDrift;
+	float m_positionConstraintCoeff;
+	int m_numIterations;
+
+	b3JacobiSolverInfo()
+		: m_fixedBodyIndex(0),
+		  m_deltaTime(1. / 60.f),
+		  m_positionDrift(0.005f),
+		  m_positionConstraintCoeff(0.99f),
+		  m_numIterations(7)
+	{
+	}
+};
+class b3GpuJacobiContactSolver
+{
+protected:
+	struct b3GpuJacobiSolverInternalData* m_data;
+
+	cl_context m_context;
+	cl_device_id m_device;
+	cl_command_queue m_queue;
+
+public:
+	b3GpuJacobiContactSolver(cl_context ctx, cl_device_id device, cl_command_queue queue, int pairCapacity);
+	virtual ~b3GpuJacobiContactSolver();
+
+	void solveContacts(int numBodies, cl_mem bodyBuf, cl_mem inertiaBuf, int numContacts, cl_mem contactBuf, const struct b3Config& config, int static0Index);
+	void solveGroupHost(b3RigidBodyData* bodies, b3InertiaData* inertias, int numBodies, struct b3Contact4* manifoldPtr, int numManifolds, const b3JacobiSolverInfo& solverInfo);
+	//void  solveGroupHost(btRigidBodyCL* bodies,b3InertiaData* inertias,int numBodies,btContact4* manifoldPtr, int numManifolds,btTypedConstraint** constraints,int numConstraints,const btJacobiSolverInfo& solverInfo);
+
+	//b3Scalar solveGroup(b3OpenCLArray<b3RigidBodyData>* gpuBodies,b3OpenCLArray<b3InertiaData>* gpuInertias, int numBodies,b3OpenCLArray<b3GpuGenericConstraint>* gpuConstraints,int numConstraints,const b3ContactSolverInfo& infoGlobal);
+
+	//void  solveGroup(btOpenCLArray<btRigidBodyCL>* bodies,btOpenCLArray<btInertiaCL>* inertias,btOpenCLArray<btContact4>* manifoldPtr,const btJacobiSolverInfo& solverInfo);
+	//void  solveGroupMixed(btOpenCLArray<btRigidBodyCL>* bodies,btOpenCLArray<btInertiaCL>* inertias,btOpenCLArray<btContact4>* manifoldPtr,const btJacobiSolverInfo& solverInfo);
+};
+#endif  //B3_GPU_JACOBI_CONTACT_SOLVER_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuNarrowPhase.h b/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuNarrowPhase.h
new file mode 100644
index 00000000..21a68de3
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuNarrowPhase.h
@@ -0,0 +1,101 @@
+#ifndef B3_GPU_NARROWPHASE_H
+#define B3_GPU_NARROWPHASE_H
+
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h"
+#include "Bullet3OpenCL/Initialize/b3OpenCLInclude.h"
+#include "Bullet3Common/b3AlignedObjectArray.h"
+#include "Bullet3Common/b3Vector3.h"
+
+class b3GpuNarrowPhase
+{
+protected:
+	struct b3GpuNarrowPhaseInternalData* m_data;
+	int m_acceleratedCompanionShapeIndex;
+	int m_planeBodyIndex;
+	int m_static0Index;
+
+	cl_context m_context;
+	cl_device_id m_device;
+	cl_command_queue m_queue;
+
+	int registerConvexHullShapeInternal(class b3ConvexUtility* convexPtr, b3Collidable& col);
+	int registerConcaveMeshShape(b3AlignedObjectArray<b3Vector3>* vertices, b3AlignedObjectArray<int>* indices, b3Collidable& col, const float* scaling);
+
+public:
+	b3GpuNarrowPhase(cl_context vtx, cl_device_id dev, cl_command_queue q, const struct b3Config& config);
+
+	virtual ~b3GpuNarrowPhase(void);
+
+	int registerSphereShape(float radius);
+	int registerPlaneShape(const b3Vector3& planeNormal, float planeConstant);
+
+	int registerCompoundShape(b3AlignedObjectArray<b3GpuChildShape>* childShapes);
+	int registerFace(const b3Vector3& faceNormal, float faceConstant);
+
+	int registerConcaveMesh(b3AlignedObjectArray<b3Vector3>* vertices, b3AlignedObjectArray<int>* indices, const float* scaling);
+
+	//do they need to be merged?
+
+	int registerConvexHullShape(b3ConvexUtility* utilPtr);
+	int registerConvexHullShape(const float* vertices, int strideInBytes, int numVertices, const float* scaling);
+
+	int registerRigidBody(int collidableIndex, float mass, const float* position, const float* orientation, const float* aabbMin, const float* aabbMax, bool writeToGpu);
+	void setObjectTransform(const float* position, const float* orientation, int bodyIndex);
+
+	void writeAllBodiesToGpu();
+	void reset();
+	void readbackAllBodiesToCpu();
+	bool getObjectTransformFromCpu(float* position, float* orientation, int bodyIndex) const;
+
+	void setObjectTransformCpu(float* position, float* orientation, int bodyIndex);
+	void setObjectVelocityCpu(float* linVel, float* angVel, int bodyIndex);
+
+	virtual void computeContacts(cl_mem broadphasePairs, int numBroadphasePairs, cl_mem aabbsWorldSpace, int numObjects);
+
+	cl_mem getBodiesGpu();
+	const struct b3RigidBodyData* getBodiesCpu() const;
+	//struct b3RigidBodyData* getBodiesCpu();
+
+	int getNumBodiesGpu() const;
+
+	cl_mem getBodyInertiasGpu();
+	int getNumBodyInertiasGpu() const;
+
+	cl_mem getCollidablesGpu();
+	const struct b3Collidable* getCollidablesCpu() const;
+	int getNumCollidablesGpu() const;
+
+	const struct b3SapAabb* getLocalSpaceAabbsCpu() const;
+
+	const struct b3Contact4* getContactsCPU() const;
+
+	cl_mem getContactsGpu();
+	int getNumContactsGpu() const;
+
+	cl_mem getAabbLocalSpaceBufferGpu();
+
+	int getNumRigidBodies() const;
+
+	int allocateCollidable();
+
+	int getStatic0Index() const
+	{
+		return m_static0Index;
+	}
+	b3Collidable& getCollidableCpu(int collidableIndex);
+	const b3Collidable& getCollidableCpu(int collidableIndex) const;
+
+	const b3GpuNarrowPhaseInternalData* getInternalData() const
+	{
+		return m_data;
+	}
+
+	b3GpuNarrowPhaseInternalData* getInternalData()
+	{
+		return m_data;
+	}
+
+	const struct b3SapAabb& getLocalSpaceAabb(int collidableIndex) const;
+};
+
+#endif  //B3_GPU_NARROWPHASE_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuNarrowPhaseInternalData.h b/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuNarrowPhaseInternalData.h
new file mode 100644
index 00000000..716a5ea0
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuNarrowPhaseInternalData.h
@@ -0,0 +1,89 @@
+
+#ifndef B3_GPU_NARROWPHASE_INTERNAL_DATA_H
+#define B3_GPU_NARROWPHASE_INTERNAL_DATA_H
+
+#include "Bullet3OpenCL/ParallelPrimitives/b3OpenCLArray.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3ConvexPolyhedronData.h"
+#include "Bullet3Collision/NarrowPhaseCollision/b3Config.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h"
+
+#include "Bullet3OpenCL/Initialize/b3OpenCLInclude.h"
+#include "Bullet3Common/b3AlignedObjectArray.h"
+#include "Bullet3Common/b3Vector3.h"
+
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h"
+#include "Bullet3Collision/NarrowPhaseCollision/b3Contact4.h"
+#include "Bullet3OpenCL/BroadphaseCollision/b3SapAabb.h"
+
+#include "Bullet3OpenCL/NarrowphaseCollision/b3QuantizedBvh.h"
+#include "Bullet3OpenCL/NarrowphaseCollision/b3BvhInfo.h"
+#include "Bullet3Common/shared/b3Int4.h"
+#include "Bullet3Common/shared/b3Int2.h"
+
+class b3ConvexUtility;
+
+struct b3GpuNarrowPhaseInternalData
+{
+	b3AlignedObjectArray<b3ConvexUtility*>* m_convexData;
+
+	b3AlignedObjectArray<b3ConvexPolyhedronData> m_convexPolyhedra;
+	b3AlignedObjectArray<b3Vector3> m_uniqueEdges;
+	b3AlignedObjectArray<b3Vector3> m_convexVertices;
+	b3AlignedObjectArray<int> m_convexIndices;
+
+	b3OpenCLArray<b3ConvexPolyhedronData>* m_convexPolyhedraGPU;
+	b3OpenCLArray<b3Vector3>* m_uniqueEdgesGPU;
+	b3OpenCLArray<b3Vector3>* m_convexVerticesGPU;
+	b3OpenCLArray<int>* m_convexIndicesGPU;
+
+	b3OpenCLArray<b3Vector3>* m_worldVertsB1GPU;
+	b3OpenCLArray<b3Int4>* m_clippingFacesOutGPU;
+	b3OpenCLArray<b3Vector3>* m_worldNormalsAGPU;
+	b3OpenCLArray<b3Vector3>* m_worldVertsA1GPU;
+	b3OpenCLArray<b3Vector3>* m_worldVertsB2GPU;
+
+	b3AlignedObjectArray<b3GpuChildShape> m_cpuChildShapes;
+	b3OpenCLArray<b3GpuChildShape>* m_gpuChildShapes;
+
+	b3AlignedObjectArray<b3GpuFace> m_convexFaces;
+	b3OpenCLArray<b3GpuFace>* m_convexFacesGPU;
+
+	struct GpuSatCollision* m_gpuSatCollision;
+
+	b3OpenCLArray<b3Int4>* m_triangleConvexPairs;
+
+	b3OpenCLArray<b3Contact4>* m_pBufContactBuffersGPU[2];
+	int m_currentContactBuffer;
+	b3AlignedObjectArray<b3Contact4>* m_pBufContactOutCPU;
+
+	b3AlignedObjectArray<b3RigidBodyData>* m_bodyBufferCPU;
+	b3OpenCLArray<b3RigidBodyData>* m_bodyBufferGPU;
+
+	b3AlignedObjectArray<b3InertiaData>* m_inertiaBufferCPU;
+	b3OpenCLArray<b3InertiaData>* m_inertiaBufferGPU;
+
+	int m_numAcceleratedShapes;
+	int m_numAcceleratedRigidBodies;
+
+	b3AlignedObjectArray<b3Collidable> m_collidablesCPU;
+	b3OpenCLArray<b3Collidable>* m_collidablesGPU;
+
+	b3OpenCLArray<b3SapAabb>* m_localShapeAABBGPU;
+	b3AlignedObjectArray<b3SapAabb>* m_localShapeAABBCPU;
+
+	b3AlignedObjectArray<class b3OptimizedBvh*> m_bvhData;
+	b3AlignedObjectArray<class b3TriangleIndexVertexArray*> m_meshInterfaces;
+
+	b3AlignedObjectArray<b3QuantizedBvhNode> m_treeNodesCPU;
+	b3AlignedObjectArray<b3BvhSubtreeInfo> m_subTreesCPU;
+
+	b3AlignedObjectArray<b3BvhInfo> m_bvhInfoCPU;
+	b3OpenCLArray<b3BvhInfo>* m_bvhInfoGPU;
+
+	b3OpenCLArray<b3QuantizedBvhNode>* m_treeNodesGPU;
+	b3OpenCLArray<b3BvhSubtreeInfo>* m_subTreesGPU;
+
+	b3Config m_config;
+};
+
+#endif  //B3_GPU_NARROWPHASE_INTERNAL_DATA_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuPgsConstraintSolver.h b/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuPgsConstraintSolver.h
new file mode 100644
index 00000000..00bc544f
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuPgsConstraintSolver.h
@@ -0,0 +1,76 @@
+/*
+Copyright (c) 2013 Advanced Micro Devices, Inc.  
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+//Originally written by Erwin Coumans
+
+#ifndef B3_GPU_PGS_CONSTRAINT_SOLVER_H
+#define B3_GPU_PGS_CONSTRAINT_SOLVER_H
+
+struct b3Contact4;
+struct b3ContactPoint;
+
+class b3Dispatcher;
+
+#include "Bullet3Dynamics/ConstraintSolver/b3TypedConstraint.h"
+#include "Bullet3Dynamics/ConstraintSolver/b3ContactSolverInfo.h"
+#include "b3GpuSolverBody.h"
+#include "b3GpuSolverConstraint.h"
+#include "Bullet3OpenCL/ParallelPrimitives/b3OpenCLArray.h"
+struct b3RigidBodyData;
+struct b3InertiaData;
+
+#include "Bullet3OpenCL/Initialize/b3OpenCLInclude.h"
+#include "b3GpuGenericConstraint.h"
+
+class b3GpuPgsConstraintSolver
+{
+protected:
+	int m_staticIdx;
+	struct b3GpuPgsJacobiSolverInternalData* m_gpuData;
+
+protected:
+	b3AlignedObjectArray<b3GpuSolverBody> m_tmpSolverBodyPool;
+	b3GpuConstraintArray m_tmpSolverContactConstraintPool;
+	b3GpuConstraintArray m_tmpSolverNonContactConstraintPool;
+	b3GpuConstraintArray m_tmpSolverContactFrictionConstraintPool;
+	b3GpuConstraintArray m_tmpSolverContactRollingFrictionConstraintPool;
+
+	b3AlignedObjectArray<unsigned int> m_tmpConstraintSizesPool;
+
+	bool m_usePgs;
+	void averageVelocities();
+
+	int m_maxOverrideNumSolverIterations;
+
+	int m_numSplitImpulseRecoveries;
+
+	//	int	getOrInitSolverBody(int bodyIndex, b3RigidBodyData* bodies,b3InertiaData* inertias);
+	void initSolverBody(int bodyIndex, b3GpuSolverBody* solverBody, b3RigidBodyData* rb);
+
+public:
+	b3GpuPgsConstraintSolver(cl_context ctx, cl_device_id device, cl_command_queue queue, bool usePgs);
+	virtual ~b3GpuPgsConstraintSolver();
+
+	virtual b3Scalar solveGroupCacheFriendlyIterations(b3OpenCLArray<b3GpuGenericConstraint>* gpuConstraints1, int numConstraints, const b3ContactSolverInfo& infoGlobal);
+	virtual b3Scalar solveGroupCacheFriendlySetup(b3OpenCLArray<b3RigidBodyData>* gpuBodies, b3OpenCLArray<b3InertiaData>* gpuInertias, int numBodies, b3OpenCLArray<b3GpuGenericConstraint>* gpuConstraints, int numConstraints, const b3ContactSolverInfo& infoGlobal);
+	b3Scalar solveGroupCacheFriendlyFinish(b3OpenCLArray<b3RigidBodyData>* gpuBodies, b3OpenCLArray<b3InertiaData>* gpuInertias, int numBodies, b3OpenCLArray<b3GpuGenericConstraint>* gpuConstraints, int numConstraints, const b3ContactSolverInfo& infoGlobal);
+
+	b3Scalar solveGroup(b3OpenCLArray<b3RigidBodyData>* gpuBodies, b3OpenCLArray<b3InertiaData>* gpuInertias, int numBodies, b3OpenCLArray<b3GpuGenericConstraint>* gpuConstraints, int numConstraints, const b3ContactSolverInfo& infoGlobal);
+	void solveJoints(int numBodies, b3OpenCLArray<b3RigidBodyData>* gpuBodies, b3OpenCLArray<b3InertiaData>* gpuInertias,
+					 int numConstraints, b3OpenCLArray<b3GpuGenericConstraint>* gpuConstraints);
+
+	int sortConstraintByBatch3(struct b3BatchConstraint* cs, int numConstraints, int simdWidth, int staticIdx, int numBodies);
+	void recomputeBatches();
+};
+
+#endif  //B3_GPU_PGS_CONSTRAINT_SOLVER_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuPgsContactSolver.h b/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuPgsContactSolver.h
new file mode 100644
index 00000000..6ab7502a
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuPgsContactSolver.h
@@ -0,0 +1,37 @@
+
+#ifndef B3_GPU_BATCHING_PGS_SOLVER_H
+#define B3_GPU_BATCHING_PGS_SOLVER_H
+
+#include "Bullet3OpenCL/Initialize/b3OpenCLInclude.h"
+#include "Bullet3OpenCL/ParallelPrimitives/b3OpenCLArray.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h"
+#include "Bullet3Collision/NarrowPhaseCollision/b3Contact4.h"
+#include "b3GpuConstraint4.h"
+
+class b3GpuPgsContactSolver
+{
+protected:
+	int m_debugOutput;
+
+	struct b3GpuBatchingPgsSolverInternalData* m_data;
+
+	void batchContacts(b3OpenCLArray<b3Contact4>* contacts, int nContacts, b3OpenCLArray<unsigned int>* n, b3OpenCLArray<unsigned int>* offsets, int staticIdx);
+
+	inline int sortConstraintByBatch(b3Contact4* cs, int n, int simdWidth, int staticIdx, int numBodies);
+	inline int sortConstraintByBatch2(b3Contact4* cs, int n, int simdWidth, int staticIdx, int numBodies);
+	inline int sortConstraintByBatch3(b3Contact4* cs, int n, int simdWidth, int staticIdx, int numBodies, int* batchSizes);
+
+	void solveContactConstraintBatchSizes(const b3OpenCLArray<b3RigidBodyData>* bodyBuf, const b3OpenCLArray<b3InertiaData>* shapeBuf,
+										  b3OpenCLArray<b3GpuConstraint4>* constraint, void* additionalData, int n, int maxNumBatches, int numIterations, const b3AlignedObjectArray<int>* batchSizes);  //const b3OpenCLArray<int>* gpuBatchSizes);
+
+	void solveContactConstraint(const b3OpenCLArray<b3RigidBodyData>* bodyBuf, const b3OpenCLArray<b3InertiaData>* shapeBuf,
+								b3OpenCLArray<b3GpuConstraint4>* constraint, void* additionalData, int n, int maxNumBatches, int numIterations, const b3AlignedObjectArray<int>* batchSizes);  //const b3OpenCLArray<int>* gpuBatchSizes);
+
+public:
+	b3GpuPgsContactSolver(cl_context ctx, cl_device_id device, cl_command_queue q, int pairCapacity);
+	virtual ~b3GpuPgsContactSolver();
+
+	void solveContacts(int numBodies, cl_mem bodyBuf, cl_mem inertiaBuf, int numContacts, cl_mem contactBuf, const struct b3Config& config, int static0Index);
+};
+
+#endif  //B3_GPU_BATCHING_PGS_SOLVER_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipeline.h b/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipeline.h
new file mode 100644
index 00000000..0e5c6fec
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipeline.h
@@ -0,0 +1,70 @@
+/*
+Copyright (c) 2013 Advanced Micro Devices, Inc.  
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+//Originally written by Erwin Coumans
+
+#ifndef B3_GPU_RIGIDBODY_PIPELINE_H
+#define B3_GPU_RIGIDBODY_PIPELINE_H
+
+#include "Bullet3OpenCL/Initialize/b3OpenCLInclude.h"
+#include "Bullet3Collision/NarrowPhaseCollision/b3Config.h"
+
+#include "Bullet3Common/b3AlignedObjectArray.h"
+#include "Bullet3Collision/NarrowPhaseCollision/b3RaycastInfo.h"
+
+class b3GpuRigidBodyPipeline
+{
+protected:
+	struct b3GpuRigidBodyPipelineInternalData* m_data;
+
+	int allocateCollidable();
+
+public:
+	b3GpuRigidBodyPipeline(cl_context ctx, cl_device_id device, cl_command_queue q, class b3GpuNarrowPhase* narrowphase, class b3GpuBroadphaseInterface* broadphaseSap, struct b3DynamicBvhBroadphase* broadphaseDbvt, const b3Config& config);
+	virtual ~b3GpuRigidBodyPipeline();
+
+	void stepSimulation(float deltaTime);
+	void integrate(float timeStep);
+	void setupGpuAabbsFull();
+
+	int registerConvexPolyhedron(class b3ConvexUtility* convex);
+
+	//int		registerConvexPolyhedron(const float* vertices, int strideInBytes, int numVertices, const float* scaling);
+	//int		registerSphereShape(float radius);
+	//int		registerPlaneShape(const b3Vector3& planeNormal, float planeConstant);
+
+	//int		registerConcaveMesh(b3AlignedObjectArray<b3Vector3>* vertices, b3AlignedObjectArray<int>* indices, const float* scaling);
+	//int		registerCompoundShape(b3AlignedObjectArray<b3GpuChildShape>* childShapes);
+
+	int registerPhysicsInstance(float mass, const float* position, const float* orientation, int collisionShapeIndex, int userData, bool writeInstanceToGpu);
+	//if you passed "writeInstanceToGpu" false in the registerPhysicsInstance method (for performance) you need to call writeAllInstancesToGpu after all instances are registered
+	void writeAllInstancesToGpu();
+	void copyConstraintsToHost();
+	void setGravity(const float* grav);
+	void reset();
+
+	int createPoint2PointConstraint(int bodyA, int bodyB, const float* pivotInA, const float* pivotInB, float breakingThreshold);
+	int createFixedConstraint(int bodyA, int bodyB, const float* pivotInA, const float* pivotInB, const float* relTargetAB, float breakingThreshold);
+	void removeConstraintByUid(int uid);
+
+	void addConstraint(class b3TypedConstraint* constraint);
+	void removeConstraint(b3TypedConstraint* constraint);
+
+	void castRays(const b3AlignedObjectArray<b3RayInfo>& rays, b3AlignedObjectArray<b3RayHit>& hitResults);
+
+	cl_mem getBodyBuffer();
+
+	int getNumBodies() const;
+};
+
+#endif  //B3_GPU_RIGIDBODY_PIPELINE_H
\ No newline at end of file
diff --git a/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipelineInternalData.h b/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipelineInternalData.h
new file mode 100644
index 00000000..e0a26fda
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipelineInternalData.h
@@ -0,0 +1,68 @@
+/*
+Copyright (c) 2013 Advanced Micro Devices, Inc.  
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+//Originally written by Erwin Coumans
+
+#ifndef B3_GPU_RIGIDBODY_PIPELINE_INTERNAL_DATA_H
+#define B3_GPU_RIGIDBODY_PIPELINE_INTERNAL_DATA_H
+
+#include "Bullet3OpenCL/Initialize/b3OpenCLInclude.h"
+#include "Bullet3Common/b3AlignedObjectArray.h"
+
+#include "Bullet3OpenCL/ParallelPrimitives/b3OpenCLArray.h"
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h"
+
+#include "Bullet3OpenCL/BroadphaseCollision/b3SapAabb.h"
+#include "Bullet3Dynamics/ConstraintSolver/b3TypedConstraint.h"
+#include "Bullet3Collision/NarrowPhaseCollision/b3Config.h"
+
+#include "Bullet3Collision/BroadPhaseCollision/b3OverlappingPair.h"
+#include "Bullet3OpenCL/RigidBody/b3GpuGenericConstraint.h"
+
+struct b3GpuRigidBodyPipelineInternalData
+{
+	cl_context m_context;
+	cl_device_id m_device;
+	cl_command_queue m_queue;
+
+	cl_kernel m_integrateTransformsKernel;
+	cl_kernel m_updateAabbsKernel;
+	cl_kernel m_clearOverlappingPairsKernel;
+
+	class b3PgsJacobiSolver* m_solver;
+
+	class b3GpuPgsConstraintSolver* m_gpuSolver;
+
+	class b3GpuPgsContactSolver* m_solver2;
+	class b3GpuJacobiContactSolver* m_solver3;
+	class b3GpuRaycast* m_raycaster;
+
+	class b3GpuBroadphaseInterface* m_broadphaseSap;
+
+	struct b3DynamicBvhBroadphase* m_broadphaseDbvt;
+	b3OpenCLArray<b3SapAabb>* m_allAabbsGPU;
+	b3AlignedObjectArray<b3SapAabb> m_allAabbsCPU;
+	b3OpenCLArray<b3BroadphasePair>* m_overlappingPairsGPU;
+
+	b3OpenCLArray<b3GpuGenericConstraint>* m_gpuConstraints;
+	b3AlignedObjectArray<b3GpuGenericConstraint> m_cpuConstraints;
+
+	b3AlignedObjectArray<b3TypedConstraint*> m_joints;
+	int m_constraintUid;
+	class b3GpuNarrowPhase* m_narrowphase;
+	b3Vector3 m_gravity;
+
+	b3Config m_config;
+};
+
+#endif  //B3_GPU_RIGIDBODY_PIPELINE_INTERNAL_DATA_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuSolverBody.h b/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuSolverBody.h
new file mode 100644
index 00000000..db815d9b
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuSolverBody.h
@@ -0,0 +1,210 @@
+/*
+Copyright (c) 2013 Advanced Micro Devices, Inc.  
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+//Originally written by Erwin Coumans
+
+#ifndef B3_GPU_SOLVER_BODY_H
+#define B3_GPU_SOLVER_BODY_H
+
+#include "Bullet3Common/b3Vector3.h"
+#include "Bullet3Common/b3Matrix3x3.h"
+
+#include "Bullet3Common/b3AlignedAllocator.h"
+#include "Bullet3Common/b3TransformUtil.h"
+
+///Until we get other contributions, only use SIMD on Windows, when using Visual Studio 2008 or later, and not double precision
+#ifdef B3_USE_SSE
+#define USE_SIMD 1
+#endif  //
+
+///The b3SolverBody is an internal datastructure for the constraint solver. Only necessary data is packed to increase cache coherence/performance.
+B3_ATTRIBUTE_ALIGNED16(struct)
+b3GpuSolverBody
+{
+	B3_DECLARE_ALIGNED_ALLOCATOR();
+	//	b3Transform		m_worldTransformUnused;
+	b3Vector3 m_deltaLinearVelocity;
+	b3Vector3 m_deltaAngularVelocity;
+	b3Vector3 m_angularFactor;
+	b3Vector3 m_linearFactor;
+	b3Vector3 m_invMass;
+	b3Vector3 m_pushVelocity;
+	b3Vector3 m_turnVelocity;
+	b3Vector3 m_linearVelocity;
+	b3Vector3 m_angularVelocity;
+
+	union {
+		void* m_originalBody;
+		int m_originalBodyIndex;
+	};
+
+	int padding[3];
+
+	/*
+	void	setWorldTransform(const b3Transform& worldTransform)
+	{
+		m_worldTransform = worldTransform;
+	}
+
+	const b3Transform& getWorldTransform() const
+	{
+		return m_worldTransform;
+	}
+	*/
+	B3_FORCE_INLINE void getVelocityInLocalPointObsolete(const b3Vector3& rel_pos, b3Vector3& velocity) const
+	{
+		if (m_originalBody)
+			velocity = m_linearVelocity + m_deltaLinearVelocity + (m_angularVelocity + m_deltaAngularVelocity).cross(rel_pos);
+		else
+			velocity.setValue(0, 0, 0);
+	}
+
+	B3_FORCE_INLINE void getAngularVelocity(b3Vector3 & angVel) const
+	{
+		if (m_originalBody)
+			angVel = m_angularVelocity + m_deltaAngularVelocity;
+		else
+			angVel.setValue(0, 0, 0);
+	}
+
+	//Optimization for the iterative solver: avoid calculating constant terms involving inertia, normal, relative position
+	B3_FORCE_INLINE void applyImpulse(const b3Vector3& linearComponent, const b3Vector3& angularComponent, const b3Scalar impulseMagnitude)
+	{
+		if (m_originalBody)
+		{
+			m_deltaLinearVelocity += linearComponent * impulseMagnitude * m_linearFactor;
+			m_deltaAngularVelocity += angularComponent * (impulseMagnitude * m_angularFactor);
+		}
+	}
+
+	B3_FORCE_INLINE void internalApplyPushImpulse(const b3Vector3& linearComponent, const b3Vector3& angularComponent, b3Scalar impulseMagnitude)
+	{
+		if (m_originalBody)
+		{
+			m_pushVelocity += linearComponent * impulseMagnitude * m_linearFactor;
+			m_turnVelocity += angularComponent * (impulseMagnitude * m_angularFactor);
+		}
+	}
+
+	const b3Vector3& getDeltaLinearVelocity() const
+	{
+		return m_deltaLinearVelocity;
+	}
+
+	const b3Vector3& getDeltaAngularVelocity() const
+	{
+		return m_deltaAngularVelocity;
+	}
+
+	const b3Vector3& getPushVelocity() const
+	{
+		return m_pushVelocity;
+	}
+
+	const b3Vector3& getTurnVelocity() const
+	{
+		return m_turnVelocity;
+	}
+
+	////////////////////////////////////////////////
+	///some internal methods, don't use them
+
+	b3Vector3& internalGetDeltaLinearVelocity()
+	{
+		return m_deltaLinearVelocity;
+	}
+
+	b3Vector3& internalGetDeltaAngularVelocity()
+	{
+		return m_deltaAngularVelocity;
+	}
+
+	const b3Vector3& internalGetAngularFactor() const
+	{
+		return m_angularFactor;
+	}
+
+	const b3Vector3& internalGetInvMass() const
+	{
+		return m_invMass;
+	}
+
+	void internalSetInvMass(const b3Vector3& invMass)
+	{
+		m_invMass = invMass;
+	}
+
+	b3Vector3& internalGetPushVelocity()
+	{
+		return m_pushVelocity;
+	}
+
+	b3Vector3& internalGetTurnVelocity()
+	{
+		return m_turnVelocity;
+	}
+
+	B3_FORCE_INLINE void internalGetVelocityInLocalPointObsolete(const b3Vector3& rel_pos, b3Vector3& velocity) const
+	{
+		velocity = m_linearVelocity + m_deltaLinearVelocity + (m_angularVelocity + m_deltaAngularVelocity).cross(rel_pos);
+	}
+
+	B3_FORCE_INLINE void internalGetAngularVelocity(b3Vector3 & angVel) const
+	{
+		angVel = m_angularVelocity + m_deltaAngularVelocity;
+	}
+
+	//Optimization for the iterative solver: avoid calculating constant terms involving inertia, normal, relative position
+	B3_FORCE_INLINE void internalApplyImpulse(const b3Vector3& linearComponent, const b3Vector3& angularComponent, const b3Scalar impulseMagnitude)
+	{
+		//if (m_originalBody)
+		{
+			m_deltaLinearVelocity += linearComponent * impulseMagnitude * m_linearFactor;
+			m_deltaAngularVelocity += angularComponent * (impulseMagnitude * m_angularFactor);
+		}
+	}
+
+	void writebackVelocity()
+	{
+		//if (m_originalBody>=0)
+		{
+			m_linearVelocity += m_deltaLinearVelocity;
+			m_angularVelocity += m_deltaAngularVelocity;
+
+			//m_originalBody->setCompanionId(-1);
+		}
+	}
+
+	void writebackVelocityAndTransform(b3Scalar timeStep, b3Scalar splitImpulseTurnErp)
+	{
+		(void)timeStep;
+		if (m_originalBody)
+		{
+			m_linearVelocity += m_deltaLinearVelocity;
+			m_angularVelocity += m_deltaAngularVelocity;
+
+			//correct the position/orientation based on push/turn recovery
+			b3Transform newTransform;
+			if (m_pushVelocity[0] != 0.f || m_pushVelocity[1] != 0 || m_pushVelocity[2] != 0 || m_turnVelocity[0] != 0.f || m_turnVelocity[1] != 0 || m_turnVelocity[2] != 0)
+			{
+				//	b3Quaternion orn = m_worldTransform.getRotation();
+				//				b3TransformUtil::integrateTransform(m_worldTransform,m_pushVelocity,m_turnVelocity*splitImpulseTurnErp,timeStep,newTransform);
+				//				m_worldTransform = newTransform;
+			}
+			//m_worldTransform.setRotation(orn);
+			//m_originalBody->setCompanionId(-1);
+		}
+	}
+};
+
+#endif  //B3_SOLVER_BODY_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuSolverConstraint.h b/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuSolverConstraint.h
new file mode 100644
index 00000000..7d9eea24
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3GpuSolverConstraint.h
@@ -0,0 +1,73 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2013 Erwin Coumans http://github.com/erwincoumans/bullet3
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_GPU_SOLVER_CONSTRAINT_H
+#define B3_GPU_SOLVER_CONSTRAINT_H
+
+#include "Bullet3Common/b3Vector3.h"
+#include "Bullet3Common/b3Matrix3x3.h"
+//#include "b3JacobianEntry.h"
+#include "Bullet3Common/b3AlignedObjectArray.h"
+
+//#define NO_FRICTION_TANGENTIALS 1
+
+///1D constraint along a normal axis between bodyA and bodyB. It can be combined to solve contact and friction constraints.
+B3_ATTRIBUTE_ALIGNED16(struct)
+b3GpuSolverConstraint
+{
+	B3_DECLARE_ALIGNED_ALLOCATOR();
+
+	b3Vector3 m_relpos1CrossNormal;
+	b3Vector3 m_contactNormal;
+
+	b3Vector3 m_relpos2CrossNormal;
+	//b3Vector3		m_contactNormal2;//usually m_contactNormal2 == -m_contactNormal
+
+	b3Vector3 m_angularComponentA;
+	b3Vector3 m_angularComponentB;
+
+	mutable b3Scalar m_appliedPushImpulse;
+	mutable b3Scalar m_appliedImpulse;
+	int m_padding1;
+	int m_padding2;
+	b3Scalar m_friction;
+	b3Scalar m_jacDiagABInv;
+	b3Scalar m_rhs;
+	b3Scalar m_cfm;
+
+	b3Scalar m_lowerLimit;
+	b3Scalar m_upperLimit;
+	b3Scalar m_rhsPenetration;
+	union {
+		void* m_originalContactPoint;
+		int m_originalConstraintIndex;
+		b3Scalar m_unusedPadding4;
+	};
+
+	int m_overrideNumSolverIterations;
+	int m_frictionIndex;
+	int m_solverBodyIdA;
+	int m_solverBodyIdB;
+
+	enum b3SolverConstraintType
+	{
+		B3_SOLVER_CONTACT_1D = 0,
+		B3_SOLVER_FRICTION_1D
+	};
+};
+
+typedef b3AlignedObjectArray<b3GpuSolverConstraint> b3GpuConstraintArray;
+
+#endif  //B3_GPU_SOLVER_CONSTRAINT_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3Solver.h b/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3Solver.h
new file mode 100644
index 00000000..ee63531d
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/RigidBody/b3Solver.h
@@ -0,0 +1,110 @@
+/*
+Copyright (c) 2012 Advanced Micro Devices, Inc.  
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+//Originally written by Takahiro Harada
+
+#ifndef __ADL_SOLVER_H
+#define __ADL_SOLVER_H
+
+#include "Bullet3OpenCL/ParallelPrimitives/b3OpenCLArray.h"
+#include "b3GpuConstraint4.h"
+
+#include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h"
+#include "Bullet3Collision/NarrowPhaseCollision/b3Contact4.h"
+
+#include "Bullet3OpenCL/ParallelPrimitives/b3PrefixScanCL.h"
+#include "Bullet3OpenCL/ParallelPrimitives/b3RadixSort32CL.h"
+#include "Bullet3OpenCL/ParallelPrimitives/b3BoundSearchCL.h"
+
+#include "Bullet3OpenCL/Initialize/b3OpenCLUtils.h"
+
+#define B3NEXTMULTIPLEOF(num, alignment) (((num) / (alignment) + (((num) % (alignment) == 0) ? 0 : 1)) * (alignment))
+
+enum
+{
+	B3_SOLVER_N_SPLIT_X = 8,  //16,//4,
+	B3_SOLVER_N_SPLIT_Y = 4,  //16,//4,
+	B3_SOLVER_N_SPLIT_Z = 8,  //,
+	B3_SOLVER_N_CELLS = B3_SOLVER_N_SPLIT_X * B3_SOLVER_N_SPLIT_Y * B3_SOLVER_N_SPLIT_Z,
+	B3_SOLVER_N_BATCHES = 8,  //4,//8,//4,
+	B3_MAX_NUM_BATCHES = 128,
+};
+
+class b3SolverBase
+{
+public:
+	struct ConstraintCfg
+	{
+		ConstraintCfg(float dt = 0.f) : m_positionDrift(0.005f), m_positionConstraintCoeff(0.2f), m_dt(dt), m_staticIdx(-1) {}
+
+		float m_positionDrift;
+		float m_positionConstraintCoeff;
+		float m_dt;
+		bool m_enableParallelSolve;
+		float m_batchCellSize;
+		int m_staticIdx;
+	};
+};
+
+class b3Solver : public b3SolverBase
+{
+public:
+	cl_context m_context;
+	cl_device_id m_device;
+	cl_command_queue m_queue;
+
+	b3OpenCLArray<unsigned int>* m_numConstraints;
+	b3OpenCLArray<unsigned int>* m_offsets;
+	b3OpenCLArray<int> m_batchSizes;
+
+	int m_nIterations;
+	cl_kernel m_batchingKernel;
+	cl_kernel m_batchingKernelNew;
+	cl_kernel m_solveContactKernel;
+	cl_kernel m_solveFrictionKernel;
+	cl_kernel m_contactToConstraintKernel;
+	cl_kernel m_setSortDataKernel;
+	cl_kernel m_reorderContactKernel;
+	cl_kernel m_copyConstraintKernel;
+
+	class b3RadixSort32CL* m_sort32;
+	class b3BoundSearchCL* m_search;
+	class b3PrefixScanCL* m_scan;
+
+	b3OpenCLArray<b3SortData>* m_sortDataBuffer;
+	b3OpenCLArray<b3Contact4>* m_contactBuffer2;
+
+	enum
+	{
+		DYNAMIC_CONTACT_ALLOCATION_THRESHOLD = 2000000,
+	};
+
+	b3Solver(cl_context ctx, cl_device_id device, cl_command_queue queue, int pairCapacity);
+
+	virtual ~b3Solver();
+
+	void solveContactConstraint(const b3OpenCLArray<b3RigidBodyData>* bodyBuf, const b3OpenCLArray<b3InertiaData>* inertiaBuf,
+								b3OpenCLArray<b3GpuConstraint4>* constraint, void* additionalData, int n, int maxNumBatches);
+
+	void solveContactConstraintHost(b3OpenCLArray<b3RigidBodyData>* bodyBuf, b3OpenCLArray<b3InertiaData>* shapeBuf,
+									b3OpenCLArray<b3GpuConstraint4>* constraint, void* additionalData, int n, int maxNumBatches, b3AlignedObjectArray<int>* batchSizes);
+
+	void convertToConstraints(const b3OpenCLArray<b3RigidBodyData>* bodyBuf,
+							  const b3OpenCLArray<b3InertiaData>* shapeBuf,
+							  b3OpenCLArray<b3Contact4>* contactsIn, b3OpenCLArray<b3GpuConstraint4>* contactCOut, void* additionalData,
+							  int nContacts, const ConstraintCfg& cfg);
+
+	void batchContacts(b3OpenCLArray<b3Contact4>* contacts, int nContacts, b3OpenCLArray<unsigned int>* n, b3OpenCLArray<unsigned int>* offsets, int staticIdx);
+};
+
+#endif  //__ADL_SOLVER_H
diff --git a/engine/inc/bullet/Bullet3OpenCL/RigidBody/kernels/batchingKernels.h b/engine/inc/bullet/Bullet3OpenCL/RigidBody/kernels/batchingKernels.h
new file mode 100644
index 00000000..7c73c96b
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/RigidBody/kernels/batchingKernels.h
@@ -0,0 +1,387 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* batchingKernelsCL =
+	"/*\n"
+	"Copyright (c) 2012 Advanced Micro Devices, Inc.  \n"
+	"This software is provided 'as-is', without any express or implied warranty.\n"
+	"In no event will the authors be held liable for any damages arising from the use of this software.\n"
+	"Permission is granted to anyone to use this software for any purpose, \n"
+	"including commercial applications, and to alter it and redistribute it freely, \n"
+	"subject to the following restrictions:\n"
+	"1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.\n"
+	"2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.\n"
+	"3. This notice may not be removed or altered from any source distribution.\n"
+	"*/\n"
+	"//Originally written by Takahiro Harada\n"
+	"#ifndef B3_CONTACT4DATA_H\n"
+	"#define B3_CONTACT4DATA_H\n"
+	"#ifndef B3_FLOAT4_H\n"
+	"#define B3_FLOAT4_H\n"
+	"#ifndef B3_PLATFORM_DEFINITIONS_H\n"
+	"#define B3_PLATFORM_DEFINITIONS_H\n"
+	"struct MyTest\n"
+	"{\n"
+	"	int bla;\n"
+	"};\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"//keep B3_LARGE_FLOAT*B3_LARGE_FLOAT < FLT_MAX\n"
+	"#define B3_LARGE_FLOAT 1e18f\n"
+	"#define B3_INFINITY 1e18f\n"
+	"#define b3Assert(a)\n"
+	"#define b3ConstArray(a) __global const a*\n"
+	"#define b3AtomicInc atomic_inc\n"
+	"#define b3AtomicAdd atomic_add\n"
+	"#define b3Fabs fabs\n"
+	"#define b3Sqrt native_sqrt\n"
+	"#define b3Sin native_sin\n"
+	"#define b3Cos native_cos\n"
+	"#define B3_STATIC\n"
+	"#endif\n"
+	"#endif\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"	typedef float4	b3Float4;\n"
+	"	#define b3Float4ConstArg const b3Float4\n"
+	"	#define b3MakeFloat4 (float4)\n"
+	"	float b3Dot3F4(b3Float4ConstArg v0,b3Float4ConstArg v1)\n"
+	"	{\n"
+	"		float4 a1 = b3MakeFloat4(v0.xyz,0.f);\n"
+	"		float4 b1 = b3MakeFloat4(v1.xyz,0.f);\n"
+	"		return dot(a1, b1);\n"
+	"	}\n"
+	"	b3Float4 b3Cross3(b3Float4ConstArg v0,b3Float4ConstArg v1)\n"
+	"	{\n"
+	"		float4 a1 = b3MakeFloat4(v0.xyz,0.f);\n"
+	"		float4 b1 = b3MakeFloat4(v1.xyz,0.f);\n"
+	"		return cross(a1, b1);\n"
+	"	}\n"
+	"	#define b3MinFloat4 min\n"
+	"	#define b3MaxFloat4 max\n"
+	"	#define b3Normalized(a) normalize(a)\n"
+	"#endif \n"
+	"		\n"
+	"inline bool b3IsAlmostZero(b3Float4ConstArg v)\n"
+	"{\n"
+	"	if(b3Fabs(v.x)>1e-6 || b3Fabs(v.y)>1e-6 || b3Fabs(v.z)>1e-6)	\n"
+	"		return false;\n"
+	"	return true;\n"
+	"}\n"
+	"inline int    b3MaxDot( b3Float4ConstArg vec, __global const b3Float4* vecArray, int vecLen, float* dotOut )\n"
+	"{\n"
+	"    float maxDot = -B3_INFINITY;\n"
+	"    int i = 0;\n"
+	"    int ptIndex = -1;\n"
+	"    for( i = 0; i < vecLen; i++ )\n"
+	"    {\n"
+	"        float dot = b3Dot3F4(vecArray[i],vec);\n"
+	"            \n"
+	"        if( dot > maxDot )\n"
+	"        {\n"
+	"            maxDot = dot;\n"
+	"            ptIndex = i;\n"
+	"        }\n"
+	"    }\n"
+	"	b3Assert(ptIndex>=0);\n"
+	"    if (ptIndex<0)\n"
+	"	{\n"
+	"		ptIndex = 0;\n"
+	"	}\n"
+	"    *dotOut = maxDot;\n"
+	"    return ptIndex;\n"
+	"}\n"
+	"#endif //B3_FLOAT4_H\n"
+	"typedef  struct b3Contact4Data b3Contact4Data_t;\n"
+	"struct b3Contact4Data\n"
+	"{\n"
+	"	b3Float4	m_worldPosB[4];\n"
+	"//	b3Float4	m_localPosA[4];\n"
+	"//	b3Float4	m_localPosB[4];\n"
+	"	b3Float4	m_worldNormalOnB;	//	w: m_nPoints\n"
+	"	unsigned short  m_restituitionCoeffCmp;\n"
+	"	unsigned short  m_frictionCoeffCmp;\n"
+	"	int m_batchIdx;\n"
+	"	int m_bodyAPtrAndSignBit;//x:m_bodyAPtr, y:m_bodyBPtr\n"
+	"	int m_bodyBPtrAndSignBit;\n"
+	"	int	m_childIndexA;\n"
+	"	int	m_childIndexB;\n"
+	"	int m_unused1;\n"
+	"	int m_unused2;\n"
+	"};\n"
+	"inline int b3Contact4Data_getNumPoints(const struct b3Contact4Data* contact)\n"
+	"{\n"
+	"	return (int)contact->m_worldNormalOnB.w;\n"
+	"};\n"
+	"inline void b3Contact4Data_setNumPoints(struct b3Contact4Data* contact, int numPoints)\n"
+	"{\n"
+	"	contact->m_worldNormalOnB.w = (float)numPoints;\n"
+	"};\n"
+	"#endif //B3_CONTACT4DATA_H\n"
+	"#pragma OPENCL EXTENSION cl_amd_printf : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_local_int32_base_atomics : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_global_int32_base_atomics : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_local_int32_extended_atomics : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_global_int32_extended_atomics : enable\n"
+	"#ifdef cl_ext_atomic_counters_32\n"
+	"#pragma OPENCL EXTENSION cl_ext_atomic_counters_32 : enable\n"
+	"#else\n"
+	"#define counter32_t volatile __global int*\n"
+	"#endif\n"
+	"typedef unsigned int u32;\n"
+	"typedef unsigned short u16;\n"
+	"typedef unsigned char u8;\n"
+	"#define GET_GROUP_IDX get_group_id(0)\n"
+	"#define GET_LOCAL_IDX get_local_id(0)\n"
+	"#define GET_GLOBAL_IDX get_global_id(0)\n"
+	"#define GET_GROUP_SIZE get_local_size(0)\n"
+	"#define GET_NUM_GROUPS get_num_groups(0)\n"
+	"#define GROUP_LDS_BARRIER barrier(CLK_LOCAL_MEM_FENCE)\n"
+	"#define GROUP_MEM_FENCE mem_fence(CLK_LOCAL_MEM_FENCE)\n"
+	"#define AtomInc(x) atom_inc(&(x))\n"
+	"#define AtomInc1(x, out) out = atom_inc(&(x))\n"
+	"#define AppendInc(x, out) out = atomic_inc(x)\n"
+	"#define AtomAdd(x, value) atom_add(&(x), value)\n"
+	"#define AtomCmpxhg(x, cmp, value) atom_cmpxchg( &(x), cmp, value )\n"
+	"#define AtomXhg(x, value) atom_xchg ( &(x), value )\n"
+	"#define SELECT_UINT4( b, a, condition ) select( b,a,condition )\n"
+	"#define make_float4 (float4)\n"
+	"#define make_float2 (float2)\n"
+	"#define make_uint4 (uint4)\n"
+	"#define make_int4 (int4)\n"
+	"#define make_uint2 (uint2)\n"
+	"#define make_int2 (int2)\n"
+	"#define max2 max\n"
+	"#define min2 min\n"
+	"#define WG_SIZE 64\n"
+	"typedef struct \n"
+	"{\n"
+	"	int m_n;\n"
+	"	int m_start;\n"
+	"	int m_staticIdx;\n"
+	"	int m_paddings[1];\n"
+	"} ConstBuffer;\n"
+	"typedef struct \n"
+	"{\n"
+	"	int m_a;\n"
+	"	int m_b;\n"
+	"	u32 m_idx;\n"
+	"}Elem;\n"
+	"#define STACK_SIZE (WG_SIZE*10)\n"
+	"//#define STACK_SIZE (WG_SIZE)\n"
+	"#define RING_SIZE 1024\n"
+	"#define RING_SIZE_MASK (RING_SIZE-1)\n"
+	"#define CHECK_SIZE (WG_SIZE)\n"
+	"#define GET_RING_CAPACITY (RING_SIZE - ldsRingEnd)\n"
+	"#define RING_END ldsTmp\n"
+	"u32 readBuf(__local u32* buff, int idx)\n"
+	"{\n"
+	"	idx = idx % (32*CHECK_SIZE);\n"
+	"	int bitIdx = idx%32;\n"
+	"	int bufIdx = idx/32;\n"
+	"	return buff[bufIdx] & (1<<bitIdx);\n"
+	"}\n"
+	"void writeBuf(__local u32* buff, int idx)\n"
+	"{\n"
+	"	idx = idx % (32*CHECK_SIZE);\n"
+	"	int bitIdx = idx%32;\n"
+	"	int bufIdx = idx/32;\n"
+	"//	buff[bufIdx] |= (1<<bitIdx);\n"
+	"	atom_or( &buff[bufIdx], (1<<bitIdx) );\n"
+	"}\n"
+	"u32 tryWrite(__local u32* buff, int idx)\n"
+	"{\n"
+	"	idx = idx % (32*CHECK_SIZE);\n"
+	"	int bitIdx = idx%32;\n"
+	"	int bufIdx = idx/32;\n"
+	"	u32 ans = (u32)atom_or( &buff[bufIdx], (1<<bitIdx) );\n"
+	"	return ((ans >> bitIdx)&1) == 0;\n"
+	"}\n"
+	"//	batching on the GPU\n"
+	"__kernel void CreateBatches( __global const struct b3Contact4Data* gConstraints, __global struct b3Contact4Data* gConstraintsOut,\n"
+	"		__global const u32* gN, __global const u32* gStart, __global int* batchSizes, \n"
+	"		int m_staticIdx )\n"
+	"{\n"
+	"	__local u32 ldsStackIdx[STACK_SIZE];\n"
+	"	__local u32 ldsStackEnd;\n"
+	"	__local Elem ldsRingElem[RING_SIZE];\n"
+	"	__local u32 ldsRingEnd;\n"
+	"	__local u32 ldsTmp;\n"
+	"	__local u32 ldsCheckBuffer[CHECK_SIZE];\n"
+	"	__local u32 ldsFixedBuffer[CHECK_SIZE];\n"
+	"	__local u32 ldsGEnd;\n"
+	"	__local u32 ldsDstEnd;\n"
+	"	int wgIdx = GET_GROUP_IDX;\n"
+	"	int lIdx = GET_LOCAL_IDX;\n"
+	"	\n"
+	"	const int m_n = gN[wgIdx];\n"
+	"	const int m_start = gStart[wgIdx];\n"
+	"		\n"
+	"	if( lIdx == 0 )\n"
+	"	{\n"
+	"		ldsRingEnd = 0;\n"
+	"		ldsGEnd = 0;\n"
+	"		ldsStackEnd = 0;\n"
+	"		ldsDstEnd = m_start;\n"
+	"	}\n"
+	"	\n"
+	"	\n"
+	"	\n"
+	"//	while(1)\n"
+	"//was 250\n"
+	"	int ie=0;\n"
+	"	int maxBatch = 0;\n"
+	"	for(ie=0; ie<50; ie++)\n"
+	"	{\n"
+	"		ldsFixedBuffer[lIdx] = 0;\n"
+	"		for(int giter=0; giter<4; giter++)\n"
+	"		{\n"
+	"			int ringCap = GET_RING_CAPACITY;\n"
+	"		\n"
+	"			//	1. fill ring\n"
+	"			if( ldsGEnd < m_n )\n"
+	"			{\n"
+	"				while( ringCap > WG_SIZE )\n"
+	"				{\n"
+	"					if( ldsGEnd >= m_n ) break;\n"
+	"					if( lIdx < ringCap - WG_SIZE )\n"
+	"					{\n"
+	"						int srcIdx;\n"
+	"						AtomInc1( ldsGEnd, srcIdx );\n"
+	"						if( srcIdx < m_n )\n"
+	"						{\n"
+	"							int dstIdx;\n"
+	"							AtomInc1( ldsRingEnd, dstIdx );\n"
+	"							\n"
+	"							int a = gConstraints[m_start+srcIdx].m_bodyAPtrAndSignBit;\n"
+	"							int b = gConstraints[m_start+srcIdx].m_bodyBPtrAndSignBit;\n"
+	"							ldsRingElem[dstIdx].m_a = (a>b)? b:a;\n"
+	"							ldsRingElem[dstIdx].m_b = (a>b)? a:b;\n"
+	"							ldsRingElem[dstIdx].m_idx = srcIdx;\n"
+	"						}\n"
+	"					}\n"
+	"					ringCap = GET_RING_CAPACITY;\n"
+	"				}\n"
+	"			}\n"
+	"			GROUP_LDS_BARRIER;\n"
+	"	\n"
+	"			//	2. fill stack\n"
+	"			__local Elem* dst = ldsRingElem;\n"
+	"			if( lIdx == 0 ) RING_END = 0;\n"
+	"			int srcIdx=lIdx;\n"
+	"			int end = ldsRingEnd;\n"
+	"			{\n"
+	"				for(int ii=0; ii<end; ii+=WG_SIZE, srcIdx+=WG_SIZE)\n"
+	"				{\n"
+	"					Elem e;\n"
+	"					if(srcIdx<end) e = ldsRingElem[srcIdx];\n"
+	"					bool done = (srcIdx<end)?false:true;\n"
+	"					for(int i=lIdx; i<CHECK_SIZE; i+=WG_SIZE) ldsCheckBuffer[lIdx] = 0;\n"
+	"					\n"
+	"					if( !done )\n"
+	"					{\n"
+	"						int aUsed = readBuf( ldsFixedBuffer, abs(e.m_a));\n"
+	"						int bUsed = readBuf( ldsFixedBuffer, abs(e.m_b));\n"
+	"						if( aUsed==0 && bUsed==0 )\n"
+	"						{\n"
+	"							int aAvailable=1;\n"
+	"							int bAvailable=1;\n"
+	"							int ea = abs(e.m_a);\n"
+	"							int eb = abs(e.m_b);\n"
+	"							bool aStatic = (e.m_a<0) ||(ea==m_staticIdx);\n"
+	"							bool bStatic = (e.m_b<0) ||(eb==m_staticIdx);\n"
+	"							\n"
+	"							if (!aStatic)\n"
+	"								aAvailable = tryWrite( ldsCheckBuffer, ea );\n"
+	"							if (!bStatic)\n"
+	"								bAvailable = tryWrite( ldsCheckBuffer, eb );\n"
+	"							\n"
+	"							//aAvailable = aStatic? 1: aAvailable;\n"
+	"							//bAvailable = bStatic? 1: bAvailable;\n"
+	"							bool success = (aAvailable && bAvailable);\n"
+	"							if(success)\n"
+	"							{\n"
+	"							\n"
+	"								if (!aStatic)\n"
+	"									writeBuf( ldsFixedBuffer, ea );\n"
+	"								if (!bStatic)\n"
+	"									writeBuf( ldsFixedBuffer, eb );\n"
+	"							}\n"
+	"							done = success;\n"
+	"						}\n"
+	"					}\n"
+	"					//	put it aside\n"
+	"					if(srcIdx<end)\n"
+	"					{\n"
+	"						if( done )\n"
+	"						{\n"
+	"							int dstIdx; AtomInc1( ldsStackEnd, dstIdx );\n"
+	"							if( dstIdx < STACK_SIZE )\n"
+	"								ldsStackIdx[dstIdx] = e.m_idx;\n"
+	"							else{\n"
+	"								done = false;\n"
+	"								AtomAdd( ldsStackEnd, -1 );\n"
+	"							}\n"
+	"						}\n"
+	"						if( !done )\n"
+	"						{\n"
+	"							int dstIdx; AtomInc1( RING_END, dstIdx );\n"
+	"							dst[dstIdx] = e;\n"
+	"						}\n"
+	"					}\n"
+	"					//	if filled, flush\n"
+	"					if( ldsStackEnd == STACK_SIZE )\n"
+	"					{\n"
+	"						for(int i=lIdx; i<STACK_SIZE; i+=WG_SIZE)\n"
+	"						{\n"
+	"							int idx = m_start + ldsStackIdx[i];\n"
+	"							int dstIdx; AtomInc1( ldsDstEnd, dstIdx );\n"
+	"							gConstraintsOut[ dstIdx ] = gConstraints[ idx ];\n"
+	"							gConstraintsOut[ dstIdx ].m_batchIdx = ie;\n"
+	"						}\n"
+	"						if( lIdx == 0 ) ldsStackEnd = 0;\n"
+	"						//for(int i=lIdx; i<CHECK_SIZE; i+=WG_SIZE) \n"
+	"						ldsFixedBuffer[lIdx] = 0;\n"
+	"					}\n"
+	"				}\n"
+	"			}\n"
+	"			if( lIdx == 0 ) ldsRingEnd = RING_END;\n"
+	"		}\n"
+	"		GROUP_LDS_BARRIER;\n"
+	"		for(int i=lIdx; i<ldsStackEnd; i+=WG_SIZE)\n"
+	"		{\n"
+	"			int idx = m_start + ldsStackIdx[i];\n"
+	"			int dstIdx; AtomInc1( ldsDstEnd, dstIdx );\n"
+	"			gConstraintsOut[ dstIdx ] = gConstraints[ idx ];\n"
+	"			gConstraintsOut[ dstIdx ].m_batchIdx = ie;\n"
+	"		}\n"
+	"		//	in case it couldn't consume any pair. Flush them\n"
+	"		//	todo. Serial batch worth while?\n"
+	"		if( ldsStackEnd == 0 )\n"
+	"		{\n"
+	"			for(int i=lIdx; i<ldsRingEnd; i+=WG_SIZE)\n"
+	"			{\n"
+	"				int idx = m_start + ldsRingElem[i].m_idx;\n"
+	"				int dstIdx; AtomInc1( ldsDstEnd, dstIdx );\n"
+	"				gConstraintsOut[ dstIdx ] = gConstraints[ idx ];\n"
+	"				int curBatch = 100+i;\n"
+	"				if (maxBatch < curBatch)\n"
+	"					maxBatch = curBatch;\n"
+	"				\n"
+	"				gConstraintsOut[ dstIdx ].m_batchIdx = curBatch;\n"
+	"				\n"
+	"			}\n"
+	"			GROUP_LDS_BARRIER;\n"
+	"			if( lIdx == 0 ) ldsRingEnd = 0;\n"
+	"		}\n"
+	"		if( lIdx == 0 ) ldsStackEnd = 0;\n"
+	"		GROUP_LDS_BARRIER;\n"
+	"		//	termination\n"
+	"		if( ldsGEnd == m_n && ldsRingEnd == 0 )\n"
+	"			break;\n"
+	"	}\n"
+	"	if( lIdx == 0 )\n"
+	"	{\n"
+	"		if (maxBatch < ie)\n"
+	"			maxBatch=ie;\n"
+	"		batchSizes[wgIdx]=maxBatch;\n"
+	"	}\n"
+	"}\n";
diff --git a/engine/inc/bullet/Bullet3OpenCL/RigidBody/kernels/batchingKernelsNew.h b/engine/inc/bullet/Bullet3OpenCL/RigidBody/kernels/batchingKernelsNew.h
new file mode 100644
index 00000000..05800656
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/RigidBody/kernels/batchingKernelsNew.h
@@ -0,0 +1,290 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* batchingKernelsNewCL =
+	"/*\n"
+	"Copyright (c) 2012 Advanced Micro Devices, Inc.  \n"
+	"This software is provided 'as-is', without any express or implied warranty.\n"
+	"In no event will the authors be held liable for any damages arising from the use of this software.\n"
+	"Permission is granted to anyone to use this software for any purpose, \n"
+	"including commercial applications, and to alter it and redistribute it freely, \n"
+	"subject to the following restrictions:\n"
+	"1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.\n"
+	"2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.\n"
+	"3. This notice may not be removed or altered from any source distribution.\n"
+	"*/\n"
+	"//Originally written by Erwin Coumans\n"
+	"#ifndef B3_CONTACT4DATA_H\n"
+	"#define B3_CONTACT4DATA_H\n"
+	"#ifndef B3_FLOAT4_H\n"
+	"#define B3_FLOAT4_H\n"
+	"#ifndef B3_PLATFORM_DEFINITIONS_H\n"
+	"#define B3_PLATFORM_DEFINITIONS_H\n"
+	"struct MyTest\n"
+	"{\n"
+	"	int bla;\n"
+	"};\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"//keep B3_LARGE_FLOAT*B3_LARGE_FLOAT < FLT_MAX\n"
+	"#define B3_LARGE_FLOAT 1e18f\n"
+	"#define B3_INFINITY 1e18f\n"
+	"#define b3Assert(a)\n"
+	"#define b3ConstArray(a) __global const a*\n"
+	"#define b3AtomicInc atomic_inc\n"
+	"#define b3AtomicAdd atomic_add\n"
+	"#define b3Fabs fabs\n"
+	"#define b3Sqrt native_sqrt\n"
+	"#define b3Sin native_sin\n"
+	"#define b3Cos native_cos\n"
+	"#define B3_STATIC\n"
+	"#endif\n"
+	"#endif\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"	typedef float4	b3Float4;\n"
+	"	#define b3Float4ConstArg const b3Float4\n"
+	"	#define b3MakeFloat4 (float4)\n"
+	"	float b3Dot3F4(b3Float4ConstArg v0,b3Float4ConstArg v1)\n"
+	"	{\n"
+	"		float4 a1 = b3MakeFloat4(v0.xyz,0.f);\n"
+	"		float4 b1 = b3MakeFloat4(v1.xyz,0.f);\n"
+	"		return dot(a1, b1);\n"
+	"	}\n"
+	"	b3Float4 b3Cross3(b3Float4ConstArg v0,b3Float4ConstArg v1)\n"
+	"	{\n"
+	"		float4 a1 = b3MakeFloat4(v0.xyz,0.f);\n"
+	"		float4 b1 = b3MakeFloat4(v1.xyz,0.f);\n"
+	"		return cross(a1, b1);\n"
+	"	}\n"
+	"	#define b3MinFloat4 min\n"
+	"	#define b3MaxFloat4 max\n"
+	"	#define b3Normalized(a) normalize(a)\n"
+	"#endif \n"
+	"		\n"
+	"inline bool b3IsAlmostZero(b3Float4ConstArg v)\n"
+	"{\n"
+	"	if(b3Fabs(v.x)>1e-6 || b3Fabs(v.y)>1e-6 || b3Fabs(v.z)>1e-6)	\n"
+	"		return false;\n"
+	"	return true;\n"
+	"}\n"
+	"inline int    b3MaxDot( b3Float4ConstArg vec, __global const b3Float4* vecArray, int vecLen, float* dotOut )\n"
+	"{\n"
+	"    float maxDot = -B3_INFINITY;\n"
+	"    int i = 0;\n"
+	"    int ptIndex = -1;\n"
+	"    for( i = 0; i < vecLen; i++ )\n"
+	"    {\n"
+	"        float dot = b3Dot3F4(vecArray[i],vec);\n"
+	"            \n"
+	"        if( dot > maxDot )\n"
+	"        {\n"
+	"            maxDot = dot;\n"
+	"            ptIndex = i;\n"
+	"        }\n"
+	"    }\n"
+	"	b3Assert(ptIndex>=0);\n"
+	"    if (ptIndex<0)\n"
+	"	{\n"
+	"		ptIndex = 0;\n"
+	"	}\n"
+	"    *dotOut = maxDot;\n"
+	"    return ptIndex;\n"
+	"}\n"
+	"#endif //B3_FLOAT4_H\n"
+	"typedef  struct b3Contact4Data b3Contact4Data_t;\n"
+	"struct b3Contact4Data\n"
+	"{\n"
+	"	b3Float4	m_worldPosB[4];\n"
+	"//	b3Float4	m_localPosA[4];\n"
+	"//	b3Float4	m_localPosB[4];\n"
+	"	b3Float4	m_worldNormalOnB;	//	w: m_nPoints\n"
+	"	unsigned short  m_restituitionCoeffCmp;\n"
+	"	unsigned short  m_frictionCoeffCmp;\n"
+	"	int m_batchIdx;\n"
+	"	int m_bodyAPtrAndSignBit;//x:m_bodyAPtr, y:m_bodyBPtr\n"
+	"	int m_bodyBPtrAndSignBit;\n"
+	"	int	m_childIndexA;\n"
+	"	int	m_childIndexB;\n"
+	"	int m_unused1;\n"
+	"	int m_unused2;\n"
+	"};\n"
+	"inline int b3Contact4Data_getNumPoints(const struct b3Contact4Data* contact)\n"
+	"{\n"
+	"	return (int)contact->m_worldNormalOnB.w;\n"
+	"};\n"
+	"inline void b3Contact4Data_setNumPoints(struct b3Contact4Data* contact, int numPoints)\n"
+	"{\n"
+	"	contact->m_worldNormalOnB.w = (float)numPoints;\n"
+	"};\n"
+	"#endif //B3_CONTACT4DATA_H\n"
+	"#pragma OPENCL EXTENSION cl_amd_printf : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_local_int32_base_atomics : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_global_int32_base_atomics : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_local_int32_extended_atomics : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_global_int32_extended_atomics : enable\n"
+	"#ifdef cl_ext_atomic_counters_32\n"
+	"#pragma OPENCL EXTENSION cl_ext_atomic_counters_32 : enable\n"
+	"#else\n"
+	"#define counter32_t volatile __global int*\n"
+	"#endif\n"
+	"#define SIMD_WIDTH 64\n"
+	"typedef unsigned int u32;\n"
+	"typedef unsigned short u16;\n"
+	"typedef unsigned char u8;\n"
+	"#define GET_GROUP_IDX get_group_id(0)\n"
+	"#define GET_LOCAL_IDX get_local_id(0)\n"
+	"#define GET_GLOBAL_IDX get_global_id(0)\n"
+	"#define GET_GROUP_SIZE get_local_size(0)\n"
+	"#define GET_NUM_GROUPS get_num_groups(0)\n"
+	"#define GROUP_LDS_BARRIER barrier(CLK_LOCAL_MEM_FENCE)\n"
+	"#define GROUP_MEM_FENCE mem_fence(CLK_LOCAL_MEM_FENCE)\n"
+	"#define AtomInc(x) atom_inc(&(x))\n"
+	"#define AtomInc1(x, out) out = atom_inc(&(x))\n"
+	"#define AppendInc(x, out) out = atomic_inc(x)\n"
+	"#define AtomAdd(x, value) atom_add(&(x), value)\n"
+	"#define AtomCmpxhg(x, cmp, value) atom_cmpxchg( &(x), cmp, value )\n"
+	"#define AtomXhg(x, value) atom_xchg ( &(x), value )\n"
+	"#define SELECT_UINT4( b, a, condition ) select( b,a,condition )\n"
+	"#define make_float4 (float4)\n"
+	"#define make_float2 (float2)\n"
+	"#define make_uint4 (uint4)\n"
+	"#define make_int4 (int4)\n"
+	"#define make_uint2 (uint2)\n"
+	"#define make_int2 (int2)\n"
+	"#define max2 max\n"
+	"#define min2 min\n"
+	"#define WG_SIZE 64\n"
+	"typedef struct \n"
+	"{\n"
+	"	int m_n;\n"
+	"	int m_start;\n"
+	"	int m_staticIdx;\n"
+	"	int m_paddings[1];\n"
+	"} ConstBuffer;\n"
+	"typedef struct \n"
+	"{\n"
+	"	int m_a;\n"
+	"	int m_b;\n"
+	"	u32 m_idx;\n"
+	"}Elem;\n"
+	"//	batching on the GPU\n"
+	"__kernel void CreateBatchesBruteForce( __global struct b3Contact4Data* gConstraints, 	__global const u32* gN, __global const u32* gStart, int m_staticIdx )\n"
+	"{\n"
+	"	int wgIdx = GET_GROUP_IDX;\n"
+	"	int lIdx = GET_LOCAL_IDX;\n"
+	"	\n"
+	"	const int m_n = gN[wgIdx];\n"
+	"	const int m_start = gStart[wgIdx];\n"
+	"		\n"
+	"	if( lIdx == 0 )\n"
+	"	{\n"
+	"		for (int i=0;i<m_n;i++)\n"
+	"		{\n"
+	"			int srcIdx = i+m_start;\n"
+	"			int batchIndex = i;\n"
+	"			gConstraints[ srcIdx ].m_batchIdx = batchIndex;	\n"
+	"		}\n"
+	"	}\n"
+	"}\n"
+	"#define CHECK_SIZE (WG_SIZE)\n"
+	"u32 readBuf(__local u32* buff, int idx)\n"
+	"{\n"
+	"	idx = idx % (32*CHECK_SIZE);\n"
+	"	int bitIdx = idx%32;\n"
+	"	int bufIdx = idx/32;\n"
+	"	return buff[bufIdx] & (1<<bitIdx);\n"
+	"}\n"
+	"void writeBuf(__local u32* buff, int idx)\n"
+	"{\n"
+	"	idx = idx % (32*CHECK_SIZE);\n"
+	"	int bitIdx = idx%32;\n"
+	"	int bufIdx = idx/32;\n"
+	"	buff[bufIdx] |= (1<<bitIdx);\n"
+	"	//atom_or( &buff[bufIdx], (1<<bitIdx) );\n"
+	"}\n"
+	"u32 tryWrite(__local u32* buff, int idx)\n"
+	"{\n"
+	"	idx = idx % (32*CHECK_SIZE);\n"
+	"	int bitIdx = idx%32;\n"
+	"	int bufIdx = idx/32;\n"
+	"	u32 ans = (u32)atom_or( &buff[bufIdx], (1<<bitIdx) );\n"
+	"	return ((ans >> bitIdx)&1) == 0;\n"
+	"}\n"
+	"//	batching on the GPU\n"
+	"__kernel void CreateBatchesNew( __global struct b3Contact4Data* gConstraints, __global const u32* gN, __global const u32* gStart, __global int* batchSizes, int staticIdx )\n"
+	"{\n"
+	"	int wgIdx = GET_GROUP_IDX;\n"
+	"	int lIdx = GET_LOCAL_IDX;\n"
+	"	const int numConstraints = gN[wgIdx];\n"
+	"	const int m_start = gStart[wgIdx];\n"
+	"	b3Contact4Data_t tmp;\n"
+	"	\n"
+	"	__local u32 ldsFixedBuffer[CHECK_SIZE];\n"
+	"		\n"
+	"	\n"
+	"	\n"
+	"	\n"
+	"	\n"
+	"	if( lIdx == 0 )\n"
+	"	{\n"
+	"	\n"
+	"		\n"
+	"		__global struct b3Contact4Data* cs = &gConstraints[m_start];	\n"
+	"	\n"
+	"		\n"
+	"		int numValidConstraints = 0;\n"
+	"		int batchIdx = 0;\n"
+	"		while( numValidConstraints < numConstraints)\n"
+	"		{\n"
+	"			int nCurrentBatch = 0;\n"
+	"			//	clear flag\n"
+	"	\n"
+	"			for(int i=0; i<CHECK_SIZE; i++) \n"
+	"				ldsFixedBuffer[i] = 0;		\n"
+	"			for(int i=numValidConstraints; i<numConstraints; i++)\n"
+	"			{\n"
+	"				int bodyAS = cs[i].m_bodyAPtrAndSignBit;\n"
+	"				int bodyBS = cs[i].m_bodyBPtrAndSignBit;\n"
+	"				int bodyA = abs(bodyAS);\n"
+	"				int bodyB = abs(bodyBS);\n"
+	"				bool aIsStatic = (bodyAS<0) || bodyAS==staticIdx;\n"
+	"				bool bIsStatic = (bodyBS<0) || bodyBS==staticIdx;\n"
+	"				int aUnavailable = aIsStatic ? 0 : readBuf( ldsFixedBuffer, bodyA);\n"
+	"				int bUnavailable = bIsStatic ? 0 : readBuf( ldsFixedBuffer, bodyB);\n"
+	"				\n"
+	"				if( aUnavailable==0 && bUnavailable==0 ) // ok\n"
+	"				{\n"
+	"					if (!aIsStatic)\n"
+	"					{\n"
+	"						writeBuf( ldsFixedBuffer, bodyA );\n"
+	"					}\n"
+	"					if (!bIsStatic)\n"
+	"					{\n"
+	"						writeBuf( ldsFixedBuffer, bodyB );\n"
+	"					}\n"
+	"					cs[i].m_batchIdx = batchIdx;\n"
+	"					if (i!=numValidConstraints)\n"
+	"					{\n"
+	"						tmp = cs[i];\n"
+	"						cs[i] = cs[numValidConstraints];\n"
+	"						cs[numValidConstraints]  = tmp;\n"
+	"					}\n"
+	"					numValidConstraints++;\n"
+	"					\n"
+	"					nCurrentBatch++;\n"
+	"					if( nCurrentBatch == SIMD_WIDTH)\n"
+	"					{\n"
+	"						nCurrentBatch = 0;\n"
+	"						for(int i=0; i<CHECK_SIZE; i++) \n"
+	"							ldsFixedBuffer[i] = 0;\n"
+	"						\n"
+	"					}\n"
+	"				}\n"
+	"			}//for\n"
+	"			batchIdx ++;\n"
+	"		}//while\n"
+	"		\n"
+	"		batchSizes[wgIdx] = batchIdx;\n"
+	"	}//if( lIdx == 0 )\n"
+	"	\n"
+	"	//return batchIdx;\n"
+	"}\n";
diff --git a/engine/inc/bullet/Bullet3OpenCL/RigidBody/kernels/integrateKernel.h b/engine/inc/bullet/Bullet3OpenCL/RigidBody/kernels/integrateKernel.h
new file mode 100644
index 00000000..6e9c53e1
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/RigidBody/kernels/integrateKernel.h
@@ -0,0 +1,432 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* integrateKernelCL =
+	"/*\n"
+	"Copyright (c) 2013 Advanced Micro Devices, Inc.  \n"
+	"This software is provided 'as-is', without any express or implied warranty.\n"
+	"In no event will the authors be held liable for any damages arising from the use of this software.\n"
+	"Permission is granted to anyone to use this software for any purpose, \n"
+	"including commercial applications, and to alter it and redistribute it freely, \n"
+	"subject to the following restrictions:\n"
+	"1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.\n"
+	"2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.\n"
+	"3. This notice may not be removed or altered from any source distribution.\n"
+	"*/\n"
+	"//Originally written by Erwin Coumans\n"
+	"#ifndef B3_RIGIDBODY_DATA_H\n"
+	"#define B3_RIGIDBODY_DATA_H\n"
+	"#ifndef B3_FLOAT4_H\n"
+	"#define B3_FLOAT4_H\n"
+	"#ifndef B3_PLATFORM_DEFINITIONS_H\n"
+	"#define B3_PLATFORM_DEFINITIONS_H\n"
+	"struct MyTest\n"
+	"{\n"
+	"	int bla;\n"
+	"};\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"//keep B3_LARGE_FLOAT*B3_LARGE_FLOAT < FLT_MAX\n"
+	"#define B3_LARGE_FLOAT 1e18f\n"
+	"#define B3_INFINITY 1e18f\n"
+	"#define b3Assert(a)\n"
+	"#define b3ConstArray(a) __global const a*\n"
+	"#define b3AtomicInc atomic_inc\n"
+	"#define b3AtomicAdd atomic_add\n"
+	"#define b3Fabs fabs\n"
+	"#define b3Sqrt native_sqrt\n"
+	"#define b3Sin native_sin\n"
+	"#define b3Cos native_cos\n"
+	"#define B3_STATIC\n"
+	"#endif\n"
+	"#endif\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"	typedef float4	b3Float4;\n"
+	"	#define b3Float4ConstArg const b3Float4\n"
+	"	#define b3MakeFloat4 (float4)\n"
+	"	float b3Dot3F4(b3Float4ConstArg v0,b3Float4ConstArg v1)\n"
+	"	{\n"
+	"		float4 a1 = b3MakeFloat4(v0.xyz,0.f);\n"
+	"		float4 b1 = b3MakeFloat4(v1.xyz,0.f);\n"
+	"		return dot(a1, b1);\n"
+	"	}\n"
+	"	b3Float4 b3Cross3(b3Float4ConstArg v0,b3Float4ConstArg v1)\n"
+	"	{\n"
+	"		float4 a1 = b3MakeFloat4(v0.xyz,0.f);\n"
+	"		float4 b1 = b3MakeFloat4(v1.xyz,0.f);\n"
+	"		return cross(a1, b1);\n"
+	"	}\n"
+	"	#define b3MinFloat4 min\n"
+	"	#define b3MaxFloat4 max\n"
+	"	#define b3Normalized(a) normalize(a)\n"
+	"#endif \n"
+	"		\n"
+	"inline bool b3IsAlmostZero(b3Float4ConstArg v)\n"
+	"{\n"
+	"	if(b3Fabs(v.x)>1e-6 || b3Fabs(v.y)>1e-6 || b3Fabs(v.z)>1e-6)	\n"
+	"		return false;\n"
+	"	return true;\n"
+	"}\n"
+	"inline int    b3MaxDot( b3Float4ConstArg vec, __global const b3Float4* vecArray, int vecLen, float* dotOut )\n"
+	"{\n"
+	"    float maxDot = -B3_INFINITY;\n"
+	"    int i = 0;\n"
+	"    int ptIndex = -1;\n"
+	"    for( i = 0; i < vecLen; i++ )\n"
+	"    {\n"
+	"        float dot = b3Dot3F4(vecArray[i],vec);\n"
+	"            \n"
+	"        if( dot > maxDot )\n"
+	"        {\n"
+	"            maxDot = dot;\n"
+	"            ptIndex = i;\n"
+	"        }\n"
+	"    }\n"
+	"	b3Assert(ptIndex>=0);\n"
+	"    if (ptIndex<0)\n"
+	"	{\n"
+	"		ptIndex = 0;\n"
+	"	}\n"
+	"    *dotOut = maxDot;\n"
+	"    return ptIndex;\n"
+	"}\n"
+	"#endif //B3_FLOAT4_H\n"
+	"#ifndef B3_QUAT_H\n"
+	"#define B3_QUAT_H\n"
+	"#ifndef B3_PLATFORM_DEFINITIONS_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif\n"
+	"#endif\n"
+	"#ifndef B3_FLOAT4_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif \n"
+	"#endif //B3_FLOAT4_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"	typedef float4	b3Quat;\n"
+	"	#define b3QuatConstArg const b3Quat\n"
+	"	\n"
+	"	\n"
+	"inline float4 b3FastNormalize4(float4 v)\n"
+	"{\n"
+	"	v = (float4)(v.xyz,0.f);\n"
+	"	return fast_normalize(v);\n"
+	"}\n"
+	"	\n"
+	"inline b3Quat b3QuatMul(b3Quat a, b3Quat b);\n"
+	"inline b3Quat b3QuatNormalized(b3QuatConstArg in);\n"
+	"inline b3Quat b3QuatRotate(b3QuatConstArg q, b3QuatConstArg vec);\n"
+	"inline b3Quat b3QuatInvert(b3QuatConstArg q);\n"
+	"inline b3Quat b3QuatInverse(b3QuatConstArg q);\n"
+	"inline b3Quat b3QuatMul(b3QuatConstArg a, b3QuatConstArg b)\n"
+	"{\n"
+	"	b3Quat ans;\n"
+	"	ans = b3Cross3( a, b );\n"
+	"	ans += a.w*b+b.w*a;\n"
+	"//	ans.w = a.w*b.w - (a.x*b.x+a.y*b.y+a.z*b.z);\n"
+	"	ans.w = a.w*b.w - b3Dot3F4(a, b);\n"
+	"	return ans;\n"
+	"}\n"
+	"inline b3Quat b3QuatNormalized(b3QuatConstArg in)\n"
+	"{\n"
+	"	b3Quat q;\n"
+	"	q=in;\n"
+	"	//return b3FastNormalize4(in);\n"
+	"	float len = native_sqrt(dot(q, q));\n"
+	"	if(len > 0.f)\n"
+	"	{\n"
+	"		q *= 1.f / len;\n"
+	"	}\n"
+	"	else\n"
+	"	{\n"
+	"		q.x = q.y = q.z = 0.f;\n"
+	"		q.w = 1.f;\n"
+	"	}\n"
+	"	return q;\n"
+	"}\n"
+	"inline float4 b3QuatRotate(b3QuatConstArg q, b3QuatConstArg vec)\n"
+	"{\n"
+	"	b3Quat qInv = b3QuatInvert( q );\n"
+	"	float4 vcpy = vec;\n"
+	"	vcpy.w = 0.f;\n"
+	"	float4 out = b3QuatMul(b3QuatMul(q,vcpy),qInv);\n"
+	"	return out;\n"
+	"}\n"
+	"inline b3Quat b3QuatInverse(b3QuatConstArg q)\n"
+	"{\n"
+	"	return (b3Quat)(-q.xyz, q.w);\n"
+	"}\n"
+	"inline b3Quat b3QuatInvert(b3QuatConstArg q)\n"
+	"{\n"
+	"	return (b3Quat)(-q.xyz, q.w);\n"
+	"}\n"
+	"inline float4 b3QuatInvRotate(b3QuatConstArg q, b3QuatConstArg vec)\n"
+	"{\n"
+	"	return b3QuatRotate( b3QuatInvert( q ), vec );\n"
+	"}\n"
+	"inline b3Float4 b3TransformPoint(b3Float4ConstArg point, b3Float4ConstArg translation, b3QuatConstArg  orientation)\n"
+	"{\n"
+	"	return b3QuatRotate( orientation, point ) + (translation);\n"
+	"}\n"
+	"	\n"
+	"#endif \n"
+	"#endif //B3_QUAT_H\n"
+	"#ifndef B3_MAT3x3_H\n"
+	"#define B3_MAT3x3_H\n"
+	"#ifndef B3_QUAT_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif \n"
+	"#endif //B3_QUAT_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"typedef struct\n"
+	"{\n"
+	"	b3Float4 m_row[3];\n"
+	"}b3Mat3x3;\n"
+	"#define b3Mat3x3ConstArg const b3Mat3x3\n"
+	"#define b3GetRow(m,row) (m.m_row[row])\n"
+	"inline b3Mat3x3 b3QuatGetRotationMatrix(b3Quat quat)\n"
+	"{\n"
+	"	b3Float4 quat2 = (b3Float4)(quat.x*quat.x, quat.y*quat.y, quat.z*quat.z, 0.f);\n"
+	"	b3Mat3x3 out;\n"
+	"	out.m_row[0].x=1-2*quat2.y-2*quat2.z;\n"
+	"	out.m_row[0].y=2*quat.x*quat.y-2*quat.w*quat.z;\n"
+	"	out.m_row[0].z=2*quat.x*quat.z+2*quat.w*quat.y;\n"
+	"	out.m_row[0].w = 0.f;\n"
+	"	out.m_row[1].x=2*quat.x*quat.y+2*quat.w*quat.z;\n"
+	"	out.m_row[1].y=1-2*quat2.x-2*quat2.z;\n"
+	"	out.m_row[1].z=2*quat.y*quat.z-2*quat.w*quat.x;\n"
+	"	out.m_row[1].w = 0.f;\n"
+	"	out.m_row[2].x=2*quat.x*quat.z-2*quat.w*quat.y;\n"
+	"	out.m_row[2].y=2*quat.y*quat.z+2*quat.w*quat.x;\n"
+	"	out.m_row[2].z=1-2*quat2.x-2*quat2.y;\n"
+	"	out.m_row[2].w = 0.f;\n"
+	"	return out;\n"
+	"}\n"
+	"inline b3Mat3x3 b3AbsoluteMat3x3(b3Mat3x3ConstArg matIn)\n"
+	"{\n"
+	"	b3Mat3x3 out;\n"
+	"	out.m_row[0] = fabs(matIn.m_row[0]);\n"
+	"	out.m_row[1] = fabs(matIn.m_row[1]);\n"
+	"	out.m_row[2] = fabs(matIn.m_row[2]);\n"
+	"	return out;\n"
+	"}\n"
+	"__inline\n"
+	"b3Mat3x3 mtZero();\n"
+	"__inline\n"
+	"b3Mat3x3 mtIdentity();\n"
+	"__inline\n"
+	"b3Mat3x3 mtTranspose(b3Mat3x3 m);\n"
+	"__inline\n"
+	"b3Mat3x3 mtMul(b3Mat3x3 a, b3Mat3x3 b);\n"
+	"__inline\n"
+	"b3Float4 mtMul1(b3Mat3x3 a, b3Float4 b);\n"
+	"__inline\n"
+	"b3Float4 mtMul3(b3Float4 a, b3Mat3x3 b);\n"
+	"__inline\n"
+	"b3Mat3x3 mtZero()\n"
+	"{\n"
+	"	b3Mat3x3 m;\n"
+	"	m.m_row[0] = (b3Float4)(0.f);\n"
+	"	m.m_row[1] = (b3Float4)(0.f);\n"
+	"	m.m_row[2] = (b3Float4)(0.f);\n"
+	"	return m;\n"
+	"}\n"
+	"__inline\n"
+	"b3Mat3x3 mtIdentity()\n"
+	"{\n"
+	"	b3Mat3x3 m;\n"
+	"	m.m_row[0] = (b3Float4)(1,0,0,0);\n"
+	"	m.m_row[1] = (b3Float4)(0,1,0,0);\n"
+	"	m.m_row[2] = (b3Float4)(0,0,1,0);\n"
+	"	return m;\n"
+	"}\n"
+	"__inline\n"
+	"b3Mat3x3 mtTranspose(b3Mat3x3 m)\n"
+	"{\n"
+	"	b3Mat3x3 out;\n"
+	"	out.m_row[0] = (b3Float4)(m.m_row[0].x, m.m_row[1].x, m.m_row[2].x, 0.f);\n"
+	"	out.m_row[1] = (b3Float4)(m.m_row[0].y, m.m_row[1].y, m.m_row[2].y, 0.f);\n"
+	"	out.m_row[2] = (b3Float4)(m.m_row[0].z, m.m_row[1].z, m.m_row[2].z, 0.f);\n"
+	"	return out;\n"
+	"}\n"
+	"__inline\n"
+	"b3Mat3x3 mtMul(b3Mat3x3 a, b3Mat3x3 b)\n"
+	"{\n"
+	"	b3Mat3x3 transB;\n"
+	"	transB = mtTranspose( b );\n"
+	"	b3Mat3x3 ans;\n"
+	"	//	why this doesn't run when 0ing in the for{}\n"
+	"	a.m_row[0].w = 0.f;\n"
+	"	a.m_row[1].w = 0.f;\n"
+	"	a.m_row[2].w = 0.f;\n"
+	"	for(int i=0; i<3; i++)\n"
+	"	{\n"
+	"//	a.m_row[i].w = 0.f;\n"
+	"		ans.m_row[i].x = b3Dot3F4(a.m_row[i],transB.m_row[0]);\n"
+	"		ans.m_row[i].y = b3Dot3F4(a.m_row[i],transB.m_row[1]);\n"
+	"		ans.m_row[i].z = b3Dot3F4(a.m_row[i],transB.m_row[2]);\n"
+	"		ans.m_row[i].w = 0.f;\n"
+	"	}\n"
+	"	return ans;\n"
+	"}\n"
+	"__inline\n"
+	"b3Float4 mtMul1(b3Mat3x3 a, b3Float4 b)\n"
+	"{\n"
+	"	b3Float4 ans;\n"
+	"	ans.x = b3Dot3F4( a.m_row[0], b );\n"
+	"	ans.y = b3Dot3F4( a.m_row[1], b );\n"
+	"	ans.z = b3Dot3F4( a.m_row[2], b );\n"
+	"	ans.w = 0.f;\n"
+	"	return ans;\n"
+	"}\n"
+	"__inline\n"
+	"b3Float4 mtMul3(b3Float4 a, b3Mat3x3 b)\n"
+	"{\n"
+	"	b3Float4 colx = b3MakeFloat4(b.m_row[0].x, b.m_row[1].x, b.m_row[2].x, 0);\n"
+	"	b3Float4 coly = b3MakeFloat4(b.m_row[0].y, b.m_row[1].y, b.m_row[2].y, 0);\n"
+	"	b3Float4 colz = b3MakeFloat4(b.m_row[0].z, b.m_row[1].z, b.m_row[2].z, 0);\n"
+	"	b3Float4 ans;\n"
+	"	ans.x = b3Dot3F4( a, colx );\n"
+	"	ans.y = b3Dot3F4( a, coly );\n"
+	"	ans.z = b3Dot3F4( a, colz );\n"
+	"	return ans;\n"
+	"}\n"
+	"#endif\n"
+	"#endif //B3_MAT3x3_H\n"
+	"typedef struct b3RigidBodyData b3RigidBodyData_t;\n"
+	"struct b3RigidBodyData\n"
+	"{\n"
+	"	b3Float4				m_pos;\n"
+	"	b3Quat					m_quat;\n"
+	"	b3Float4				m_linVel;\n"
+	"	b3Float4				m_angVel;\n"
+	"	int 					m_collidableIdx;\n"
+	"	float 				m_invMass;\n"
+	"	float 				m_restituitionCoeff;\n"
+	"	float 				m_frictionCoeff;\n"
+	"};\n"
+	"typedef struct b3InertiaData b3InertiaData_t;\n"
+	"struct b3InertiaData\n"
+	"{\n"
+	"	b3Mat3x3 m_invInertiaWorld;\n"
+	"	b3Mat3x3 m_initInvInertia;\n"
+	"};\n"
+	"#endif //B3_RIGIDBODY_DATA_H\n"
+	"	\n"
+	"#ifndef B3_RIGIDBODY_DATA_H\n"
+	"#endif //B3_RIGIDBODY_DATA_H\n"
+	"	\n"
+	"inline void integrateSingleTransform( __global b3RigidBodyData_t* bodies,int nodeID, float timeStep, float angularDamping, b3Float4ConstArg gravityAcceleration)\n"
+	"{\n"
+	"	\n"
+	"	if (bodies[nodeID].m_invMass != 0.f)\n"
+	"	{\n"
+	"		float BT_GPU_ANGULAR_MOTION_THRESHOLD = (0.25f * 3.14159254f);\n"
+	"		//angular velocity\n"
+	"		{\n"
+	"			b3Float4 axis;\n"
+	"			//add some hardcoded angular damping\n"
+	"			bodies[nodeID].m_angVel.x *= angularDamping;\n"
+	"			bodies[nodeID].m_angVel.y *= angularDamping;\n"
+	"			bodies[nodeID].m_angVel.z *= angularDamping;\n"
+	"			\n"
+	"			b3Float4 angvel = bodies[nodeID].m_angVel;\n"
+	"			float fAngle = b3Sqrt(b3Dot3F4(angvel, angvel));\n"
+	"			\n"
+	"			//limit the angular motion\n"
+	"			if(fAngle*timeStep > BT_GPU_ANGULAR_MOTION_THRESHOLD)\n"
+	"			{\n"
+	"				fAngle = BT_GPU_ANGULAR_MOTION_THRESHOLD / timeStep;\n"
+	"			}\n"
+	"			if(fAngle < 0.001f)\n"
+	"			{\n"
+	"				// use Taylor's expansions of sync function\n"
+	"				axis = angvel * (0.5f*timeStep-(timeStep*timeStep*timeStep)*0.020833333333f * fAngle * fAngle);\n"
+	"			}\n"
+	"			else\n"
+	"			{\n"
+	"				// sync(fAngle) = sin(c*fAngle)/t\n"
+	"				axis = angvel * ( b3Sin(0.5f * fAngle * timeStep) / fAngle);\n"
+	"			}\n"
+	"			\n"
+	"			b3Quat dorn;\n"
+	"			dorn.x = axis.x;\n"
+	"			dorn.y = axis.y;\n"
+	"			dorn.z = axis.z;\n"
+	"			dorn.w = b3Cos(fAngle * timeStep * 0.5f);\n"
+	"			b3Quat orn0 = bodies[nodeID].m_quat;\n"
+	"			b3Quat predictedOrn = b3QuatMul(dorn, orn0);\n"
+	"			predictedOrn = b3QuatNormalized(predictedOrn);\n"
+	"			bodies[nodeID].m_quat=predictedOrn;\n"
+	"		}\n"
+	"		//linear velocity		\n"
+	"		bodies[nodeID].m_pos +=  bodies[nodeID].m_linVel * timeStep;\n"
+	"		\n"
+	"		//apply gravity\n"
+	"		bodies[nodeID].m_linVel += gravityAcceleration * timeStep;\n"
+	"		\n"
+	"	}\n"
+	"	\n"
+	"}\n"
+	"inline void b3IntegrateTransform( __global b3RigidBodyData_t* body, float timeStep, float angularDamping, b3Float4ConstArg gravityAcceleration)\n"
+	"{\n"
+	"	float BT_GPU_ANGULAR_MOTION_THRESHOLD = (0.25f * 3.14159254f);\n"
+	"	\n"
+	"	if( (body->m_invMass != 0.f))\n"
+	"	{\n"
+	"		//angular velocity\n"
+	"		{\n"
+	"			b3Float4 axis;\n"
+	"			//add some hardcoded angular damping\n"
+	"			body->m_angVel.x *= angularDamping;\n"
+	"			body->m_angVel.y *= angularDamping;\n"
+	"			body->m_angVel.z *= angularDamping;\n"
+	"			\n"
+	"			b3Float4 angvel = body->m_angVel;\n"
+	"			float fAngle = b3Sqrt(b3Dot3F4(angvel, angvel));\n"
+	"			//limit the angular motion\n"
+	"			if(fAngle*timeStep > BT_GPU_ANGULAR_MOTION_THRESHOLD)\n"
+	"			{\n"
+	"				fAngle = BT_GPU_ANGULAR_MOTION_THRESHOLD / timeStep;\n"
+	"			}\n"
+	"			if(fAngle < 0.001f)\n"
+	"			{\n"
+	"				// use Taylor's expansions of sync function\n"
+	"				axis = angvel * (0.5f*timeStep-(timeStep*timeStep*timeStep)*0.020833333333f * fAngle * fAngle);\n"
+	"			}\n"
+	"			else\n"
+	"			{\n"
+	"				// sync(fAngle) = sin(c*fAngle)/t\n"
+	"				axis = angvel * ( b3Sin(0.5f * fAngle * timeStep) / fAngle);\n"
+	"			}\n"
+	"			b3Quat dorn;\n"
+	"			dorn.x = axis.x;\n"
+	"			dorn.y = axis.y;\n"
+	"			dorn.z = axis.z;\n"
+	"			dorn.w = b3Cos(fAngle * timeStep * 0.5f);\n"
+	"			b3Quat orn0 = body->m_quat;\n"
+	"			b3Quat predictedOrn = b3QuatMul(dorn, orn0);\n"
+	"			predictedOrn = b3QuatNormalized(predictedOrn);\n"
+	"			body->m_quat=predictedOrn;\n"
+	"		}\n"
+	"		//apply gravity\n"
+	"		body->m_linVel += gravityAcceleration * timeStep;\n"
+	"		//linear velocity		\n"
+	"		body->m_pos +=  body->m_linVel * timeStep;\n"
+	"		\n"
+	"	}\n"
+	"	\n"
+	"}\n"
+	"__kernel void \n"
+	"  integrateTransformsKernel( __global b3RigidBodyData_t* bodies,const int numNodes, float timeStep, float angularDamping, float4 gravityAcceleration)\n"
+	"{\n"
+	"	int nodeID = get_global_id(0);\n"
+	"	\n"
+	"	if( nodeID < numNodes)\n"
+	"	{\n"
+	"		integrateSingleTransform(bodies,nodeID, timeStep, angularDamping,gravityAcceleration);\n"
+	"	}\n"
+	"}\n";
diff --git a/engine/inc/bullet/Bullet3OpenCL/RigidBody/kernels/jointSolver.h b/engine/inc/bullet/Bullet3OpenCL/RigidBody/kernels/jointSolver.h
new file mode 100644
index 00000000..c94b5585
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/RigidBody/kernels/jointSolver.h
@@ -0,0 +1,720 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* solveConstraintRowsCL =
+	"/*\n"
+	"Copyright (c) 2013 Advanced Micro Devices, Inc.  \n"
+	"This software is provided 'as-is', without any express or implied warranty.\n"
+	"In no event will the authors be held liable for any damages arising from the use of this software.\n"
+	"Permission is granted to anyone to use this software for any purpose, \n"
+	"including commercial applications, and to alter it and redistribute it freely, \n"
+	"subject to the following restrictions:\n"
+	"1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.\n"
+	"2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.\n"
+	"3. This notice may not be removed or altered from any source distribution.\n"
+	"*/\n"
+	"//Originally written by Erwin Coumans\n"
+	"#define B3_CONSTRAINT_FLAG_ENABLED 1\n"
+	"#define B3_GPU_POINT2POINT_CONSTRAINT_TYPE 3\n"
+	"#define B3_GPU_FIXED_CONSTRAINT_TYPE 4\n"
+	"#define MOTIONCLAMP 100000 //unused, for debugging/safety in case constraint solver fails\n"
+	"#define B3_INFINITY 1e30f\n"
+	"#define mymake_float4 (float4)\n"
+	"__inline float dot3F4(float4 a, float4 b)\n"
+	"{\n"
+	"	float4 a1 = mymake_float4(a.xyz,0.f);\n"
+	"	float4 b1 = mymake_float4(b.xyz,0.f);\n"
+	"	return dot(a1, b1);\n"
+	"}\n"
+	"typedef float4 Quaternion;\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4 m_row[3];\n"
+	"}Matrix3x3;\n"
+	"__inline\n"
+	"float4 mtMul1(Matrix3x3 a, float4 b);\n"
+	"__inline\n"
+	"float4 mtMul3(float4 a, Matrix3x3 b);\n"
+	"__inline\n"
+	"float4 mtMul1(Matrix3x3 a, float4 b)\n"
+	"{\n"
+	"	float4 ans;\n"
+	"	ans.x = dot3F4( a.m_row[0], b );\n"
+	"	ans.y = dot3F4( a.m_row[1], b );\n"
+	"	ans.z = dot3F4( a.m_row[2], b );\n"
+	"	ans.w = 0.f;\n"
+	"	return ans;\n"
+	"}\n"
+	"__inline\n"
+	"float4 mtMul3(float4 a, Matrix3x3 b)\n"
+	"{\n"
+	"	float4 colx = mymake_float4(b.m_row[0].x, b.m_row[1].x, b.m_row[2].x, 0);\n"
+	"	float4 coly = mymake_float4(b.m_row[0].y, b.m_row[1].y, b.m_row[2].y, 0);\n"
+	"	float4 colz = mymake_float4(b.m_row[0].z, b.m_row[1].z, b.m_row[2].z, 0);\n"
+	"	float4 ans;\n"
+	"	ans.x = dot3F4( a, colx );\n"
+	"	ans.y = dot3F4( a, coly );\n"
+	"	ans.z = dot3F4( a, colz );\n"
+	"	return ans;\n"
+	"}\n"
+	"typedef struct\n"
+	"{\n"
+	"	Matrix3x3 m_invInertiaWorld;\n"
+	"	Matrix3x3 m_initInvInertia;\n"
+	"} BodyInertia;\n"
+	"typedef struct\n"
+	"{\n"
+	"	Matrix3x3 m_basis;//orientation\n"
+	"	float4	m_origin;//transform\n"
+	"}b3Transform;\n"
+	"typedef struct\n"
+	"{\n"
+	"//	b3Transform		m_worldTransformUnused;\n"
+	"	float4		m_deltaLinearVelocity;\n"
+	"	float4		m_deltaAngularVelocity;\n"
+	"	float4		m_angularFactor;\n"
+	"	float4		m_linearFactor;\n"
+	"	float4		m_invMass;\n"
+	"	float4		m_pushVelocity;\n"
+	"	float4		m_turnVelocity;\n"
+	"	float4		m_linearVelocity;\n"
+	"	float4		m_angularVelocity;\n"
+	"	union \n"
+	"	{\n"
+	"		void*	m_originalBody;\n"
+	"		int		m_originalBodyIndex;\n"
+	"	};\n"
+	"	int padding[3];\n"
+	"} b3GpuSolverBody;\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4 m_pos;\n"
+	"	Quaternion m_quat;\n"
+	"	float4 m_linVel;\n"
+	"	float4 m_angVel;\n"
+	"	unsigned int m_shapeIdx;\n"
+	"	float m_invMass;\n"
+	"	float m_restituitionCoeff;\n"
+	"	float m_frictionCoeff;\n"
+	"} b3RigidBodyCL;\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4		m_relpos1CrossNormal;\n"
+	"	float4		m_contactNormal;\n"
+	"	float4		m_relpos2CrossNormal;\n"
+	"	//float4		m_contactNormal2;//usually m_contactNormal2 == -m_contactNormal\n"
+	"	float4		m_angularComponentA;\n"
+	"	float4		m_angularComponentB;\n"
+	"	\n"
+	"	float	m_appliedPushImpulse;\n"
+	"	float	m_appliedImpulse;\n"
+	"	int	m_padding1;\n"
+	"	int	m_padding2;\n"
+	"	float	m_friction;\n"
+	"	float	m_jacDiagABInv;\n"
+	"	float		m_rhs;\n"
+	"	float		m_cfm;\n"
+	"	\n"
+	"    float		m_lowerLimit;\n"
+	"	float		m_upperLimit;\n"
+	"	float		m_rhsPenetration;\n"
+	"	int			m_originalConstraint;\n"
+	"	int	m_overrideNumSolverIterations;\n"
+	"    int			m_frictionIndex;\n"
+	"	int m_solverBodyIdA;\n"
+	"	int m_solverBodyIdB;\n"
+	"} b3SolverConstraint;\n"
+	"typedef struct \n"
+	"{\n"
+	"	int m_bodyAPtrAndSignBit;\n"
+	"	int m_bodyBPtrAndSignBit;\n"
+	"	int m_originalConstraintIndex;\n"
+	"	int m_batchId;\n"
+	"} b3BatchConstraint;\n"
+	"typedef struct \n"
+	"{\n"
+	"	int				m_constraintType;\n"
+	"	int				m_rbA;\n"
+	"	int				m_rbB;\n"
+	"	float			m_breakingImpulseThreshold;\n"
+	"	float4 m_pivotInA;\n"
+	"	float4 m_pivotInB;\n"
+	"	Quaternion m_relTargetAB;\n"
+	"	int	m_flags;\n"
+	"	int m_padding[3];\n"
+	"} b3GpuGenericConstraint;\n"
+	"/*b3Transform	getWorldTransform(b3RigidBodyCL* rb)\n"
+	"{\n"
+	"	b3Transform newTrans;\n"
+	"	newTrans.setOrigin(rb->m_pos);\n"
+	"	newTrans.setRotation(rb->m_quat);\n"
+	"	return newTrans;\n"
+	"}*/\n"
+	"__inline\n"
+	"float4 cross3(float4 a, float4 b)\n"
+	"{\n"
+	"	return cross(a,b);\n"
+	"}\n"
+	"__inline\n"
+	"float4 fastNormalize4(float4 v)\n"
+	"{\n"
+	"	v = mymake_float4(v.xyz,0.f);\n"
+	"	return fast_normalize(v);\n"
+	"}\n"
+	"__inline\n"
+	"Quaternion qtMul(Quaternion a, Quaternion b);\n"
+	"__inline\n"
+	"Quaternion qtNormalize(Quaternion in);\n"
+	"__inline\n"
+	"float4 qtRotate(Quaternion q, float4 vec);\n"
+	"__inline\n"
+	"Quaternion qtInvert(Quaternion q);\n"
+	"__inline\n"
+	"Quaternion qtMul(Quaternion a, Quaternion b)\n"
+	"{\n"
+	"	Quaternion ans;\n"
+	"	ans = cross3( a, b );\n"
+	"	ans += a.w*b+b.w*a;\n"
+	"//	ans.w = a.w*b.w - (a.x*b.x+a.y*b.y+a.z*b.z);\n"
+	"	ans.w = a.w*b.w - dot3F4(a, b);\n"
+	"	return ans;\n"
+	"}\n"
+	"__inline\n"
+	"Quaternion qtNormalize(Quaternion in)\n"
+	"{\n"
+	"	return fastNormalize4(in);\n"
+	"//	in /= length( in );\n"
+	"//	return in;\n"
+	"}\n"
+	"__inline\n"
+	"float4 qtRotate(Quaternion q, float4 vec)\n"
+	"{\n"
+	"	Quaternion qInv = qtInvert( q );\n"
+	"	float4 vcpy = vec;\n"
+	"	vcpy.w = 0.f;\n"
+	"	float4 out = qtMul(qtMul(q,vcpy),qInv);\n"
+	"	return out;\n"
+	"}\n"
+	"__inline\n"
+	"Quaternion qtInvert(Quaternion q)\n"
+	"{\n"
+	"	return (Quaternion)(-q.xyz, q.w);\n"
+	"}\n"
+	"__inline void internalApplyImpulse(__global b3GpuSolverBody* body,  float4 linearComponent, float4 angularComponent,float impulseMagnitude)\n"
+	"{\n"
+	"	body->m_deltaLinearVelocity += linearComponent*impulseMagnitude*body->m_linearFactor;\n"
+	"	body->m_deltaAngularVelocity += angularComponent*(impulseMagnitude*body->m_angularFactor);\n"
+	"}\n"
+	"void resolveSingleConstraintRowGeneric(__global b3GpuSolverBody* body1, __global b3GpuSolverBody* body2, __global b3SolverConstraint* c)\n"
+	"{\n"
+	"	float deltaImpulse = c->m_rhs-c->m_appliedImpulse*c->m_cfm;\n"
+	"	float deltaVel1Dotn	=	dot3F4(c->m_contactNormal,body1->m_deltaLinearVelocity) 	+ dot3F4(c->m_relpos1CrossNormal,body1->m_deltaAngularVelocity);\n"
+	"	float deltaVel2Dotn	=	-dot3F4(c->m_contactNormal,body2->m_deltaLinearVelocity) + dot3F4(c->m_relpos2CrossNormal,body2->m_deltaAngularVelocity);\n"
+	"	deltaImpulse	-=	deltaVel1Dotn*c->m_jacDiagABInv;\n"
+	"	deltaImpulse	-=	deltaVel2Dotn*c->m_jacDiagABInv;\n"
+	"	float sum = c->m_appliedImpulse + deltaImpulse;\n"
+	"	if (sum < c->m_lowerLimit)\n"
+	"	{\n"
+	"		deltaImpulse = c->m_lowerLimit-c->m_appliedImpulse;\n"
+	"		c->m_appliedImpulse = c->m_lowerLimit;\n"
+	"	}\n"
+	"	else if (sum > c->m_upperLimit) \n"
+	"	{\n"
+	"		deltaImpulse = c->m_upperLimit-c->m_appliedImpulse;\n"
+	"		c->m_appliedImpulse = c->m_upperLimit;\n"
+	"	}\n"
+	"	else\n"
+	"	{\n"
+	"		c->m_appliedImpulse = sum;\n"
+	"	}\n"
+	"	internalApplyImpulse(body1,c->m_contactNormal*body1->m_invMass,c->m_angularComponentA,deltaImpulse);\n"
+	"	internalApplyImpulse(body2,-c->m_contactNormal*body2->m_invMass,c->m_angularComponentB,deltaImpulse);\n"
+	"}\n"
+	"__kernel void solveJointConstraintRows(__global b3GpuSolverBody* solverBodies,\n"
+	"					  __global b3BatchConstraint* batchConstraints,\n"
+	"					  	__global b3SolverConstraint* rows,\n"
+	"						__global unsigned int* numConstraintRowsInfo1, \n"
+	"						__global unsigned int* rowOffsets,\n"
+	"						__global b3GpuGenericConstraint* constraints,\n"
+	"						int batchOffset,\n"
+	"						int numConstraintsInBatch\n"
+	"                      )\n"
+	"{\n"
+	"	int b = get_global_id(0);\n"
+	"	if (b>=numConstraintsInBatch)\n"
+	"		return;\n"
+	"	__global b3BatchConstraint* c = &batchConstraints[b+batchOffset];\n"
+	"	int originalConstraintIndex = c->m_originalConstraintIndex;\n"
+	"	if (constraints[originalConstraintIndex].m_flags&B3_CONSTRAINT_FLAG_ENABLED)\n"
+	"	{\n"
+	"		int numConstraintRows = numConstraintRowsInfo1[originalConstraintIndex];\n"
+	"		int rowOffset = rowOffsets[originalConstraintIndex];\n"
+	"		for (int jj=0;jj<numConstraintRows;jj++)\n"
+	"		{\n"
+	"			__global b3SolverConstraint* constraint = &rows[rowOffset+jj];\n"
+	"			resolveSingleConstraintRowGeneric(&solverBodies[constraint->m_solverBodyIdA],&solverBodies[constraint->m_solverBodyIdB],constraint);\n"
+	"		}\n"
+	"	}\n"
+	"};\n"
+	"__kernel void initSolverBodies(__global b3GpuSolverBody* solverBodies,__global b3RigidBodyCL* bodiesCL, int numBodies)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	if (i>=numBodies)\n"
+	"		return;\n"
+	"	__global b3GpuSolverBody* solverBody = &solverBodies[i];\n"
+	"	__global b3RigidBodyCL* bodyCL = &bodiesCL[i];\n"
+	"	solverBody->m_deltaLinearVelocity = (float4)(0.f,0.f,0.f,0.f);\n"
+	"	solverBody->m_deltaAngularVelocity  = (float4)(0.f,0.f,0.f,0.f);\n"
+	"	solverBody->m_pushVelocity = (float4)(0.f,0.f,0.f,0.f);\n"
+	"	solverBody->m_pushVelocity = (float4)(0.f,0.f,0.f,0.f);\n"
+	"	solverBody->m_invMass = (float4)(bodyCL->m_invMass,bodyCL->m_invMass,bodyCL->m_invMass,0.f);\n"
+	"	solverBody->m_originalBodyIndex = i;\n"
+	"	solverBody->m_angularFactor = (float4)(1,1,1,0);\n"
+	"	solverBody->m_linearFactor = (float4) (1,1,1,0);\n"
+	"	solverBody->m_linearVelocity = bodyCL->m_linVel;\n"
+	"	solverBody->m_angularVelocity = bodyCL->m_angVel;\n"
+	"}\n"
+	"__kernel void breakViolatedConstraintsKernel(__global b3GpuGenericConstraint* constraints, __global unsigned int* numConstraintRows, __global unsigned int* rowOffsets, __global b3SolverConstraint* rows, int numConstraints)\n"
+	"{\n"
+	"	int cid = get_global_id(0);\n"
+	"	if (cid>=numConstraints)\n"
+	"		return;\n"
+	"	int numRows = numConstraintRows[cid];\n"
+	"	if (numRows)\n"
+	"	{\n"
+	"		for (int i=0;i<numRows;i++)\n"
+	"		{\n"
+	"			int rowIndex = rowOffsets[cid]+i;\n"
+	"			float breakingThreshold = constraints[cid].m_breakingImpulseThreshold;\n"
+	"			if (fabs(rows[rowIndex].m_appliedImpulse) >= breakingThreshold)\n"
+	"			{\n"
+	"				constraints[cid].m_flags =0;//&= ~B3_CONSTRAINT_FLAG_ENABLED;\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"}\n"
+	"__kernel void getInfo1Kernel(__global unsigned int* infos, __global b3GpuGenericConstraint* constraints, int numConstraints)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	if (i>=numConstraints)\n"
+	"		return;\n"
+	"	__global b3GpuGenericConstraint* constraint = &constraints[i];\n"
+	"	switch (constraint->m_constraintType)\n"
+	"	{\n"
+	"		case B3_GPU_POINT2POINT_CONSTRAINT_TYPE:\n"
+	"		{\n"
+	"			infos[i] = 3;\n"
+	"			break;\n"
+	"		}\n"
+	"		case B3_GPU_FIXED_CONSTRAINT_TYPE:\n"
+	"		{\n"
+	"			infos[i] = 6;\n"
+	"			break;\n"
+	"		}\n"
+	"		default:\n"
+	"		{\n"
+	"		}\n"
+	"	}\n"
+	"}\n"
+	"__kernel void initBatchConstraintsKernel(__global unsigned int* numConstraintRows, __global unsigned int* rowOffsets, \n"
+	"										__global b3BatchConstraint* batchConstraints, \n"
+	"										__global b3GpuGenericConstraint* constraints,\n"
+	"										__global b3RigidBodyCL* bodies,\n"
+	"										int numConstraints)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	if (i>=numConstraints)\n"
+	"		return;\n"
+	"	int rbA = constraints[i].m_rbA;\n"
+	"	int rbB = constraints[i].m_rbB;\n"
+	"	batchConstraints[i].m_bodyAPtrAndSignBit = bodies[rbA].m_invMass != 0.f ? rbA : -rbA;\n"
+	"	batchConstraints[i].m_bodyBPtrAndSignBit = bodies[rbB].m_invMass != 0.f ? rbB : -rbB;\n"
+	"	batchConstraints[i].m_batchId = -1;\n"
+	"	batchConstraints[i].m_originalConstraintIndex = i;\n"
+	"}\n"
+	"typedef struct\n"
+	"{\n"
+	"	// integrator parameters: frames per second (1/stepsize), default error\n"
+	"	// reduction parameter (0..1).\n"
+	"	float fps,erp;\n"
+	"	// for the first and second body, pointers to two (linear and angular)\n"
+	"	// n*3 jacobian sub matrices, stored by rows. these matrices will have\n"
+	"	// been initialized to 0 on entry. if the second body is zero then the\n"
+	"	// J2xx pointers may be 0.\n"
+	"	union \n"
+	"	{\n"
+	"		__global float4* m_J1linearAxisFloat4;\n"
+	"		__global float* m_J1linearAxis;\n"
+	"	};\n"
+	"	union\n"
+	"	{\n"
+	"		__global float4* m_J1angularAxisFloat4;\n"
+	"		__global float* m_J1angularAxis;\n"
+	"	};\n"
+	"	union\n"
+	"	{\n"
+	"	__global float4* m_J2linearAxisFloat4;\n"
+	"	__global float* m_J2linearAxis;\n"
+	"	};\n"
+	"	union\n"
+	"	{\n"
+	"		__global float4* m_J2angularAxisFloat4;\n"
+	"		__global float* m_J2angularAxis;\n"
+	"	};\n"
+	"	// elements to jump from one row to the next in J's\n"
+	"	int rowskip;\n"
+	"	// right hand sides of the equation J*v = c + cfm * lambda. cfm is the\n"
+	"	// \"constraint force mixing\" vector. c is set to zero on entry, cfm is\n"
+	"	// set to a constant value (typically very small or zero) value on entry.\n"
+	"	__global float* m_constraintError;\n"
+	"	__global float* cfm;\n"
+	"	// lo and hi limits for variables (set to -/+ infinity on entry).\n"
+	"	__global float* m_lowerLimit;\n"
+	"	__global float* m_upperLimit;\n"
+	"	// findex vector for variables. see the LCP solver interface for a\n"
+	"	// description of what this does. this is set to -1 on entry.\n"
+	"	// note that the returned indexes are relative to the first index of\n"
+	"	// the constraint.\n"
+	"	__global int *findex;\n"
+	"	// number of solver iterations\n"
+	"	int m_numIterations;\n"
+	"	//damping of the velocity\n"
+	"	float	m_damping;\n"
+	"} b3GpuConstraintInfo2;\n"
+	"void	getSkewSymmetricMatrix(float4 vecIn, __global float4* v0,__global float4* v1,__global float4* v2)\n"
+	"{\n"
+	"	*v0 = (float4)(0.		,-vecIn.z		,vecIn.y,0.f);\n"
+	"	*v1 = (float4)(vecIn.z	,0.			,-vecIn.x,0.f);\n"
+	"	*v2 = (float4)(-vecIn.y	,vecIn.x	,0.f,0.f);\n"
+	"}\n"
+	"void getInfo2Point2Point(__global b3GpuGenericConstraint* constraint,b3GpuConstraintInfo2* info,__global b3RigidBodyCL* bodies)\n"
+	"{\n"
+	"	float4 posA = bodies[constraint->m_rbA].m_pos;\n"
+	"	Quaternion rotA = bodies[constraint->m_rbA].m_quat;\n"
+	"	float4 posB = bodies[constraint->m_rbB].m_pos;\n"
+	"	Quaternion rotB = bodies[constraint->m_rbB].m_quat;\n"
+	"		// anchor points in global coordinates with respect to body PORs.\n"
+	"   \n"
+	"    // set jacobian\n"
+	"    info->m_J1linearAxis[0] = 1;\n"
+	"	info->m_J1linearAxis[info->rowskip+1] = 1;\n"
+	"	info->m_J1linearAxis[2*info->rowskip+2] = 1;\n"
+	"	float4 a1 = qtRotate(rotA,constraint->m_pivotInA);\n"
+	"	{\n"
+	"		__global float4* angular0 = (__global float4*)(info->m_J1angularAxis);\n"
+	"		__global float4* angular1 = (__global float4*)(info->m_J1angularAxis+info->rowskip);\n"
+	"		__global float4* angular2 = (__global float4*)(info->m_J1angularAxis+2*info->rowskip);\n"
+	"		float4 a1neg = -a1;\n"
+	"		getSkewSymmetricMatrix(a1neg,angular0,angular1,angular2);\n"
+	"	}\n"
+	"	if (info->m_J2linearAxis)\n"
+	"	{\n"
+	"		info->m_J2linearAxis[0] = -1;\n"
+	"		info->m_J2linearAxis[info->rowskip+1] = -1;\n"
+	"		info->m_J2linearAxis[2*info->rowskip+2] = -1;\n"
+	"	}\n"
+	"	\n"
+	"	float4 a2 = qtRotate(rotB,constraint->m_pivotInB);\n"
+	"   \n"
+	"	{\n"
+	"	//	float4 a2n = -a2;\n"
+	"		__global float4* angular0 = (__global float4*)(info->m_J2angularAxis);\n"
+	"		__global float4* angular1 = (__global float4*)(info->m_J2angularAxis+info->rowskip);\n"
+	"		__global float4* angular2 = (__global float4*)(info->m_J2angularAxis+2*info->rowskip);\n"
+	"		getSkewSymmetricMatrix(a2,angular0,angular1,angular2);\n"
+	"	}\n"
+	"    \n"
+	"    // set right hand side\n"
+	"//	float currERP = (m_flags & B3_P2P_FLAGS_ERP) ? m_erp : info->erp;\n"
+	"	float currERP = info->erp;\n"
+	"	float k = info->fps * currERP;\n"
+	"    int j;\n"
+	"	float4 result = a2 + posB - a1 - posA;\n"
+	"	float* resultPtr = &result;\n"
+	"	for (j=0; j<3; j++)\n"
+	"    {\n"
+	"        info->m_constraintError[j*info->rowskip] = k * (resultPtr[j]);\n"
+	"    }\n"
+	"}\n"
+	"Quaternion nearest( Quaternion first, Quaternion qd)\n"
+	"{\n"
+	"	Quaternion diff,sum;\n"
+	"	diff = first- qd;\n"
+	"	sum = first + qd;\n"
+	"	\n"
+	"	if( dot(diff,diff) < dot(sum,sum) )\n"
+	"		return qd;\n"
+	"	return (-qd);\n"
+	"}\n"
+	"float b3Acos(float x) \n"
+	"{ \n"
+	"	if (x<-1)	\n"
+	"		x=-1; \n"
+	"	if (x>1)	\n"
+	"		x=1;\n"
+	"	return acos(x); \n"
+	"}\n"
+	"float getAngle(Quaternion orn)\n"
+	"{\n"
+	"	if (orn.w>=1.f)\n"
+	"		orn.w=1.f;\n"
+	"	float s = 2.f * b3Acos(orn.w);\n"
+	"	return s;\n"
+	"}\n"
+	"void calculateDiffAxisAngleQuaternion( Quaternion orn0,Quaternion orn1a,float4* axis,float* angle)\n"
+	"{\n"
+	"	Quaternion orn1 = nearest(orn0,orn1a);\n"
+	"	\n"
+	"	Quaternion dorn = qtMul(orn1,qtInvert(orn0));\n"
+	"	*angle = getAngle(dorn);\n"
+	"	*axis = (float4)(dorn.x,dorn.y,dorn.z,0.f);\n"
+	"	\n"
+	"	//check for axis length\n"
+	"	float len = dot3F4(*axis,*axis);\n"
+	"	if (len < FLT_EPSILON*FLT_EPSILON)\n"
+	"		*axis = (float4)(1,0,0,0);\n"
+	"	else\n"
+	"		*axis /= sqrt(len);\n"
+	"}\n"
+	"void getInfo2FixedOrientation(__global b3GpuGenericConstraint* constraint,b3GpuConstraintInfo2* info,__global b3RigidBodyCL* bodies, int start_row)\n"
+	"{\n"
+	"	Quaternion worldOrnA = bodies[constraint->m_rbA].m_quat;\n"
+	"	Quaternion worldOrnB = bodies[constraint->m_rbB].m_quat;\n"
+	"	int s = info->rowskip;\n"
+	"	int start_index = start_row * s;\n"
+	"	// 3 rows to make body rotations equal\n"
+	"	info->m_J1angularAxis[start_index] = 1;\n"
+	"	info->m_J1angularAxis[start_index + s + 1] = 1;\n"
+	"	info->m_J1angularAxis[start_index + s*2+2] = 1;\n"
+	"	if ( info->m_J2angularAxis)\n"
+	"	{\n"
+	"		info->m_J2angularAxis[start_index] = -1;\n"
+	"		info->m_J2angularAxis[start_index + s+1] = -1;\n"
+	"		info->m_J2angularAxis[start_index + s*2+2] = -1;\n"
+	"	}\n"
+	"	\n"
+	"	float currERP = info->erp;\n"
+	"	float k = info->fps * currERP;\n"
+	"	float4 diff;\n"
+	"	float angle;\n"
+	"	float4 qrelCur = qtMul(worldOrnA,qtInvert(worldOrnB));\n"
+	"	\n"
+	"	calculateDiffAxisAngleQuaternion(constraint->m_relTargetAB,qrelCur,&diff,&angle);\n"
+	"	diff*=-angle;\n"
+	"		\n"
+	"	float* resultPtr = &diff;\n"
+	"	\n"
+	"	for (int j=0; j<3; j++)\n"
+	"    {\n"
+	"        info->m_constraintError[(3+j)*info->rowskip] = k * resultPtr[j];\n"
+	"    }\n"
+	"	\n"
+	"}\n"
+	"__kernel void writeBackVelocitiesKernel(__global b3RigidBodyCL* bodies,__global b3GpuSolverBody* solverBodies,int numBodies)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	if (i>=numBodies)\n"
+	"		return;\n"
+	"	if (bodies[i].m_invMass)\n"
+	"	{\n"
+	"//		if (length(solverBodies[i].m_deltaLinearVelocity)<MOTIONCLAMP)\n"
+	"		{\n"
+	"			bodies[i].m_linVel += solverBodies[i].m_deltaLinearVelocity;\n"
+	"		}\n"
+	"//		if (length(solverBodies[i].m_deltaAngularVelocity)<MOTIONCLAMP)\n"
+	"		{\n"
+	"			bodies[i].m_angVel += solverBodies[i].m_deltaAngularVelocity;\n"
+	"		} \n"
+	"	}\n"
+	"}\n"
+	"__kernel void getInfo2Kernel(__global b3SolverConstraint* solverConstraintRows, \n"
+	"							__global unsigned int* infos, \n"
+	"							__global unsigned int* constraintRowOffsets, \n"
+	"							__global b3GpuGenericConstraint* constraints, \n"
+	"							__global b3BatchConstraint* batchConstraints, \n"
+	"							__global b3RigidBodyCL* bodies,\n"
+	"							__global BodyInertia* inertias,\n"
+	"							__global b3GpuSolverBody* solverBodies,\n"
+	"							float timeStep,\n"
+	"							float globalErp,\n"
+	"							float globalCfm,\n"
+	"							float globalDamping,\n"
+	"							int globalNumIterations,\n"
+	"							int numConstraints)\n"
+	"{\n"
+	"	int i = get_global_id(0);\n"
+	"	if (i>=numConstraints)\n"
+	"		return;\n"
+	"		\n"
+	"	//for now, always initialize the batch info\n"
+	"	int info1 = infos[i];\n"
+	"			\n"
+	"	__global b3SolverConstraint* currentConstraintRow = &solverConstraintRows[constraintRowOffsets[i]];\n"
+	"	__global b3GpuGenericConstraint* constraint = &constraints[i];\n"
+	"	__global b3RigidBodyCL* rbA = &bodies[ constraint->m_rbA];\n"
+	"	__global b3RigidBodyCL* rbB = &bodies[ constraint->m_rbB];\n"
+	"	int solverBodyIdA = constraint->m_rbA;\n"
+	"	int solverBodyIdB = constraint->m_rbB;\n"
+	"	__global b3GpuSolverBody* bodyAPtr = &solverBodies[solverBodyIdA];\n"
+	"	__global b3GpuSolverBody* bodyBPtr = &solverBodies[solverBodyIdB];\n"
+	"	if (rbA->m_invMass)\n"
+	"	{\n"
+	"		batchConstraints[i].m_bodyAPtrAndSignBit = solverBodyIdA;\n"
+	"	} else\n"
+	"	{\n"
+	"//			if (!solverBodyIdA)\n"
+	"//				m_staticIdx = 0;\n"
+	"		batchConstraints[i].m_bodyAPtrAndSignBit = -solverBodyIdA;\n"
+	"	}\n"
+	"	if (rbB->m_invMass)\n"
+	"	{\n"
+	"		batchConstraints[i].m_bodyBPtrAndSignBit = solverBodyIdB;\n"
+	"	} else\n"
+	"	{\n"
+	"//			if (!solverBodyIdB)\n"
+	"//				m_staticIdx = 0;\n"
+	"		batchConstraints[i].m_bodyBPtrAndSignBit = -solverBodyIdB;\n"
+	"	}\n"
+	"	if (info1)\n"
+	"	{\n"
+	"		int overrideNumSolverIterations = 0;//constraint->getOverrideNumSolverIterations() > 0 ? constraint->getOverrideNumSolverIterations() : infoGlobal.m_numIterations;\n"
+	"//		if (overrideNumSolverIterations>m_maxOverrideNumSolverIterations)\n"
+	"	//		m_maxOverrideNumSolverIterations = overrideNumSolverIterations;\n"
+	"		int j;\n"
+	"		for ( j=0;j<info1;j++)\n"
+	"		{\n"
+	"//			memset(&currentConstraintRow[j],0,sizeof(b3SolverConstraint));\n"
+	"			currentConstraintRow[j].m_angularComponentA = (float4)(0,0,0,0);\n"
+	"			currentConstraintRow[j].m_angularComponentB = (float4)(0,0,0,0);\n"
+	"			currentConstraintRow[j].m_appliedImpulse = 0.f;\n"
+	"			currentConstraintRow[j].m_appliedPushImpulse = 0.f;\n"
+	"			currentConstraintRow[j].m_cfm = 0.f;\n"
+	"			currentConstraintRow[j].m_contactNormal = (float4)(0,0,0,0);\n"
+	"			currentConstraintRow[j].m_friction = 0.f;\n"
+	"			currentConstraintRow[j].m_frictionIndex = 0;\n"
+	"			currentConstraintRow[j].m_jacDiagABInv = 0.f;\n"
+	"			currentConstraintRow[j].m_lowerLimit = 0.f;\n"
+	"			currentConstraintRow[j].m_upperLimit = 0.f;\n"
+	"			currentConstraintRow[j].m_originalConstraint = i;\n"
+	"			currentConstraintRow[j].m_overrideNumSolverIterations = 0;\n"
+	"			currentConstraintRow[j].m_relpos1CrossNormal = (float4)(0,0,0,0);\n"
+	"			currentConstraintRow[j].m_relpos2CrossNormal = (float4)(0,0,0,0);\n"
+	"			currentConstraintRow[j].m_rhs = 0.f;\n"
+	"			currentConstraintRow[j].m_rhsPenetration = 0.f;\n"
+	"			currentConstraintRow[j].m_solverBodyIdA = 0;\n"
+	"			currentConstraintRow[j].m_solverBodyIdB = 0;\n"
+	"							\n"
+	"			currentConstraintRow[j].m_lowerLimit = -B3_INFINITY;\n"
+	"			currentConstraintRow[j].m_upperLimit = B3_INFINITY;\n"
+	"			currentConstraintRow[j].m_appliedImpulse = 0.f;\n"
+	"			currentConstraintRow[j].m_appliedPushImpulse = 0.f;\n"
+	"			currentConstraintRow[j].m_solverBodyIdA = solverBodyIdA;\n"
+	"			currentConstraintRow[j].m_solverBodyIdB = solverBodyIdB;\n"
+	"			currentConstraintRow[j].m_overrideNumSolverIterations = overrideNumSolverIterations;		\n"
+	"		}\n"
+	"		bodyAPtr->m_deltaLinearVelocity = (float4)(0,0,0,0);\n"
+	"		bodyAPtr->m_deltaAngularVelocity = (float4)(0,0,0,0);\n"
+	"		bodyAPtr->m_pushVelocity = (float4)(0,0,0,0);\n"
+	"		bodyAPtr->m_turnVelocity = (float4)(0,0,0,0);\n"
+	"		bodyBPtr->m_deltaLinearVelocity = (float4)(0,0,0,0);\n"
+	"		bodyBPtr->m_deltaAngularVelocity = (float4)(0,0,0,0);\n"
+	"		bodyBPtr->m_pushVelocity = (float4)(0,0,0,0);\n"
+	"		bodyBPtr->m_turnVelocity  = (float4)(0,0,0,0);\n"
+	"		int rowskip = sizeof(b3SolverConstraint)/sizeof(float);//check this\n"
+	"		\n"
+	"		b3GpuConstraintInfo2 info2;\n"
+	"		info2.fps = 1.f/timeStep;\n"
+	"		info2.erp = globalErp;\n"
+	"		info2.m_J1linearAxisFloat4 = &currentConstraintRow->m_contactNormal;\n"
+	"		info2.m_J1angularAxisFloat4 = &currentConstraintRow->m_relpos1CrossNormal;\n"
+	"		info2.m_J2linearAxisFloat4 = 0;\n"
+	"		info2.m_J2angularAxisFloat4 = &currentConstraintRow->m_relpos2CrossNormal;\n"
+	"		info2.rowskip = sizeof(b3SolverConstraint)/sizeof(float);//check this\n"
+	"		///the size of b3SolverConstraint needs be a multiple of float\n"
+	"//		b3Assert(info2.rowskip*sizeof(float)== sizeof(b3SolverConstraint));\n"
+	"		info2.m_constraintError = &currentConstraintRow->m_rhs;\n"
+	"		currentConstraintRow->m_cfm = globalCfm;\n"
+	"		info2.m_damping = globalDamping;\n"
+	"		info2.cfm = &currentConstraintRow->m_cfm;\n"
+	"		info2.m_lowerLimit = &currentConstraintRow->m_lowerLimit;\n"
+	"		info2.m_upperLimit = &currentConstraintRow->m_upperLimit;\n"
+	"		info2.m_numIterations = globalNumIterations;\n"
+	"		switch (constraint->m_constraintType)\n"
+	"		{\n"
+	"			case B3_GPU_POINT2POINT_CONSTRAINT_TYPE:\n"
+	"			{\n"
+	"				getInfo2Point2Point(constraint,&info2,bodies);\n"
+	"				break;\n"
+	"			}\n"
+	"			case B3_GPU_FIXED_CONSTRAINT_TYPE:\n"
+	"			{\n"
+	"				getInfo2Point2Point(constraint,&info2,bodies);\n"
+	"				getInfo2FixedOrientation(constraint,&info2,bodies,3);\n"
+	"				break;\n"
+	"			}\n"
+	"			default:\n"
+	"			{\n"
+	"			}\n"
+	"		}\n"
+	"		///finalize the constraint setup\n"
+	"		for ( j=0;j<info1;j++)\n"
+	"		{\n"
+	"			__global b3SolverConstraint* solverConstraint = &currentConstraintRow[j];\n"
+	"			if (solverConstraint->m_upperLimit>=constraint->m_breakingImpulseThreshold)\n"
+	"			{\n"
+	"				solverConstraint->m_upperLimit = constraint->m_breakingImpulseThreshold;\n"
+	"			}\n"
+	"			if (solverConstraint->m_lowerLimit<=-constraint->m_breakingImpulseThreshold)\n"
+	"			{\n"
+	"				solverConstraint->m_lowerLimit = -constraint->m_breakingImpulseThreshold;\n"
+	"			}\n"
+	"//						solverConstraint->m_originalContactPoint = constraint;\n"
+	"							\n"
+	"			Matrix3x3 invInertiaWorldA= inertias[constraint->m_rbA].m_invInertiaWorld;\n"
+	"			{\n"
+	"				//float4 angularFactorA(1,1,1);\n"
+	"				float4 ftorqueAxis1 = solverConstraint->m_relpos1CrossNormal;\n"
+	"				solverConstraint->m_angularComponentA = mtMul1(invInertiaWorldA,ftorqueAxis1);//*angularFactorA;\n"
+	"			}\n"
+	"						\n"
+	"			Matrix3x3 invInertiaWorldB= inertias[constraint->m_rbB].m_invInertiaWorld;\n"
+	"			{\n"
+	"				float4 ftorqueAxis2 = solverConstraint->m_relpos2CrossNormal;\n"
+	"				solverConstraint->m_angularComponentB = mtMul1(invInertiaWorldB,ftorqueAxis2);//*constraint->m_rbB.getAngularFactor();\n"
+	"			}\n"
+	"			{\n"
+	"				//it is ok to use solverConstraint->m_contactNormal instead of -solverConstraint->m_contactNormal\n"
+	"				//because it gets multiplied iMJlB\n"
+	"				float4 iMJlA = solverConstraint->m_contactNormal*rbA->m_invMass;\n"
+	"				float4 iMJaA = mtMul3(solverConstraint->m_relpos1CrossNormal,invInertiaWorldA);\n"
+	"				float4 iMJlB = solverConstraint->m_contactNormal*rbB->m_invMass;//sign of normal?\n"
+	"				float4 iMJaB = mtMul3(solverConstraint->m_relpos2CrossNormal,invInertiaWorldB);\n"
+	"				float sum = dot3F4(iMJlA,solverConstraint->m_contactNormal);\n"
+	"				sum += dot3F4(iMJaA,solverConstraint->m_relpos1CrossNormal);\n"
+	"				sum += dot3F4(iMJlB,solverConstraint->m_contactNormal);\n"
+	"				sum += dot3F4(iMJaB,solverConstraint->m_relpos2CrossNormal);\n"
+	"				float fsum = fabs(sum);\n"
+	"				if (fsum>FLT_EPSILON)\n"
+	"				{\n"
+	"					solverConstraint->m_jacDiagABInv = 1.f/sum;\n"
+	"				} else\n"
+	"				{\n"
+	"					solverConstraint->m_jacDiagABInv = 0.f;\n"
+	"				}\n"
+	"			}\n"
+	"			///fix rhs\n"
+	"			///todo: add force/torque accelerators\n"
+	"			{\n"
+	"				float rel_vel;\n"
+	"				float vel1Dotn = dot3F4(solverConstraint->m_contactNormal,rbA->m_linVel) + dot3F4(solverConstraint->m_relpos1CrossNormal,rbA->m_angVel);\n"
+	"				float vel2Dotn = -dot3F4(solverConstraint->m_contactNormal,rbB->m_linVel) + dot3F4(solverConstraint->m_relpos2CrossNormal,rbB->m_angVel);\n"
+	"				rel_vel = vel1Dotn+vel2Dotn;\n"
+	"				float restitution = 0.f;\n"
+	"				float positionalError = solverConstraint->m_rhs;//already filled in by getConstraintInfo2\n"
+	"				float	velocityError = restitution - rel_vel * info2.m_damping;\n"
+	"				float	penetrationImpulse = positionalError*solverConstraint->m_jacDiagABInv;\n"
+	"				float	velocityImpulse = velocityError *solverConstraint->m_jacDiagABInv;\n"
+	"				solverConstraint->m_rhs = penetrationImpulse+velocityImpulse;\n"
+	"				solverConstraint->m_appliedImpulse = 0.f;\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"}\n";
diff --git a/engine/inc/bullet/Bullet3OpenCL/RigidBody/kernels/solveContact.h b/engine/inc/bullet/Bullet3OpenCL/RigidBody/kernels/solveContact.h
new file mode 100644
index 00000000..6e14ad51
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/RigidBody/kernels/solveContact.h
@@ -0,0 +1,392 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* solveContactCL =
+	"/*\n"
+	"Copyright (c) 2012 Advanced Micro Devices, Inc.  \n"
+	"This software is provided 'as-is', without any express or implied warranty.\n"
+	"In no event will the authors be held liable for any damages arising from the use of this software.\n"
+	"Permission is granted to anyone to use this software for any purpose, \n"
+	"including commercial applications, and to alter it and redistribute it freely, \n"
+	"subject to the following restrictions:\n"
+	"1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.\n"
+	"2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.\n"
+	"3. This notice may not be removed or altered from any source distribution.\n"
+	"*/\n"
+	"//Originally written by Takahiro Harada\n"
+	"//#pragma OPENCL EXTENSION cl_amd_printf : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_local_int32_base_atomics : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_global_int32_base_atomics : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_local_int32_extended_atomics : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_global_int32_extended_atomics : enable\n"
+	"#ifdef cl_ext_atomic_counters_32\n"
+	"#pragma OPENCL EXTENSION cl_ext_atomic_counters_32 : enable\n"
+	"#else\n"
+	"#define counter32_t volatile global int*\n"
+	"#endif\n"
+	"typedef unsigned int u32;\n"
+	"typedef unsigned short u16;\n"
+	"typedef unsigned char u8;\n"
+	"#define GET_GROUP_IDX get_group_id(0)\n"
+	"#define GET_LOCAL_IDX get_local_id(0)\n"
+	"#define GET_GLOBAL_IDX get_global_id(0)\n"
+	"#define GET_GROUP_SIZE get_local_size(0)\n"
+	"#define GET_NUM_GROUPS get_num_groups(0)\n"
+	"#define GROUP_LDS_BARRIER barrier(CLK_LOCAL_MEM_FENCE)\n"
+	"#define GROUP_MEM_FENCE mem_fence(CLK_LOCAL_MEM_FENCE)\n"
+	"#define AtomInc(x) atom_inc(&(x))\n"
+	"#define AtomInc1(x, out) out = atom_inc(&(x))\n"
+	"#define AppendInc(x, out) out = atomic_inc(x)\n"
+	"#define AtomAdd(x, value) atom_add(&(x), value)\n"
+	"#define AtomCmpxhg(x, cmp, value) atom_cmpxchg( &(x), cmp, value )\n"
+	"#define AtomXhg(x, value) atom_xchg ( &(x), value )\n"
+	"#define SELECT_UINT4( b, a, condition ) select( b,a,condition )\n"
+	"#define mymake_float4 (float4)\n"
+	"//#define make_float2 (float2)\n"
+	"//#define make_uint4 (uint4)\n"
+	"//#define make_int4 (int4)\n"
+	"//#define make_uint2 (uint2)\n"
+	"//#define make_int2 (int2)\n"
+	"#define max2 max\n"
+	"#define min2 min\n"
+	"///////////////////////////////////////\n"
+	"//	Vector\n"
+	"///////////////////////////////////////\n"
+	"__inline\n"
+	"float4 fastNormalize4(float4 v)\n"
+	"{\n"
+	"	return fast_normalize(v);\n"
+	"}\n"
+	"__inline\n"
+	"float4 cross3(float4 a, float4 b)\n"
+	"{\n"
+	"	return cross(a,b);\n"
+	"}\n"
+	"__inline\n"
+	"float dot3F4(float4 a, float4 b)\n"
+	"{\n"
+	"	float4 a1 = mymake_float4(a.xyz,0.f);\n"
+	"	float4 b1 = mymake_float4(b.xyz,0.f);\n"
+	"	return dot(a1, b1);\n"
+	"}\n"
+	"__inline\n"
+	"float4 normalize3(const float4 a)\n"
+	"{\n"
+	"	float4 n = mymake_float4(a.x, a.y, a.z, 0.f);\n"
+	"	return fastNormalize4( n );\n"
+	"//	float length = sqrtf(dot3F4(a, a));\n"
+	"//	return 1.f/length * a;\n"
+	"}\n"
+	"///////////////////////////////////////\n"
+	"//	Matrix3x3\n"
+	"///////////////////////////////////////\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4 m_row[3];\n"
+	"}Matrix3x3;\n"
+	"__inline\n"
+	"float4 mtMul1(Matrix3x3 a, float4 b);\n"
+	"__inline\n"
+	"float4 mtMul3(float4 a, Matrix3x3 b);\n"
+	"__inline\n"
+	"float4 mtMul1(Matrix3x3 a, float4 b)\n"
+	"{\n"
+	"	float4 ans;\n"
+	"	ans.x = dot3F4( a.m_row[0], b );\n"
+	"	ans.y = dot3F4( a.m_row[1], b );\n"
+	"	ans.z = dot3F4( a.m_row[2], b );\n"
+	"	ans.w = 0.f;\n"
+	"	return ans;\n"
+	"}\n"
+	"__inline\n"
+	"float4 mtMul3(float4 a, Matrix3x3 b)\n"
+	"{\n"
+	"	float4 colx = mymake_float4(b.m_row[0].x, b.m_row[1].x, b.m_row[2].x, 0);\n"
+	"	float4 coly = mymake_float4(b.m_row[0].y, b.m_row[1].y, b.m_row[2].y, 0);\n"
+	"	float4 colz = mymake_float4(b.m_row[0].z, b.m_row[1].z, b.m_row[2].z, 0);\n"
+	"	float4 ans;\n"
+	"	ans.x = dot3F4( a, colx );\n"
+	"	ans.y = dot3F4( a, coly );\n"
+	"	ans.z = dot3F4( a, colz );\n"
+	"	return ans;\n"
+	"}\n"
+	"///////////////////////////////////////\n"
+	"//	Quaternion\n"
+	"///////////////////////////////////////\n"
+	"typedef float4 Quaternion;\n"
+	"#define WG_SIZE 64\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4 m_pos;\n"
+	"	Quaternion m_quat;\n"
+	"	float4 m_linVel;\n"
+	"	float4 m_angVel;\n"
+	"	u32 m_shapeIdx;\n"
+	"	float m_invMass;\n"
+	"	float m_restituitionCoeff;\n"
+	"	float m_frictionCoeff;\n"
+	"} Body;\n"
+	"typedef struct\n"
+	"{\n"
+	"	Matrix3x3 m_invInertia;\n"
+	"	Matrix3x3 m_initInvInertia;\n"
+	"} Shape;\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4 m_linear;\n"
+	"	float4 m_worldPos[4];\n"
+	"	float4 m_center;	\n"
+	"	float m_jacCoeffInv[4];\n"
+	"	float m_b[4];\n"
+	"	float m_appliedRambdaDt[4];\n"
+	"	float m_fJacCoeffInv[2];	\n"
+	"	float m_fAppliedRambdaDt[2];	\n"
+	"	u32 m_bodyA;\n"
+	"	u32 m_bodyB;\n"
+	"	int m_batchIdx;\n"
+	"	u32 m_paddings[1];\n"
+	"} Constraint4;\n"
+	"typedef struct\n"
+	"{\n"
+	"	int m_nConstraints;\n"
+	"	int m_start;\n"
+	"	int m_batchIdx;\n"
+	"	int m_nSplit;\n"
+	"//	int m_paddings[1];\n"
+	"} ConstBuffer;\n"
+	"typedef struct\n"
+	"{\n"
+	"	int m_solveFriction;\n"
+	"	int m_maxBatch;	//	long batch really kills the performance\n"
+	"	int m_batchIdx;\n"
+	"	int m_nSplit;\n"
+	"//	int m_paddings[1];\n"
+	"} ConstBufferBatchSolve;\n"
+	"void setLinearAndAngular( float4 n, float4 r0, float4 r1, float4* linear, float4* angular0, float4* angular1);\n"
+	"void setLinearAndAngular( float4 n, float4 r0, float4 r1, float4* linear, float4* angular0, float4* angular1)\n"
+	"{\n"
+	"	*linear = mymake_float4(-n.xyz,0.f);\n"
+	"	*angular0 = -cross3(r0, n);\n"
+	"	*angular1 = cross3(r1, n);\n"
+	"}\n"
+	"float calcRelVel( float4 l0, float4 l1, float4 a0, float4 a1, float4 linVel0, float4 angVel0, float4 linVel1, float4 angVel1 );\n"
+	"float calcRelVel( float4 l0, float4 l1, float4 a0, float4 a1, float4 linVel0, float4 angVel0, float4 linVel1, float4 angVel1 )\n"
+	"{\n"
+	"	return dot3F4(l0, linVel0) + dot3F4(a0, angVel0) + dot3F4(l1, linVel1) + dot3F4(a1, angVel1);\n"
+	"}\n"
+	"float calcJacCoeff(const float4 linear0, const float4 linear1, const float4 angular0, const float4 angular1,\n"
+	"				   float invMass0, const Matrix3x3* invInertia0, float invMass1, const Matrix3x3* invInertia1);\n"
+	"float calcJacCoeff(const float4 linear0, const float4 linear1, const float4 angular0, const float4 angular1,\n"
+	"					float invMass0, const Matrix3x3* invInertia0, float invMass1, const Matrix3x3* invInertia1)\n"
+	"{\n"
+	"	//	linear0,1 are normlized\n"
+	"	float jmj0 = invMass0;//dot3F4(linear0, linear0)*invMass0;\n"
+	"	float jmj1 = dot3F4(mtMul3(angular0,*invInertia0), angular0);\n"
+	"	float jmj2 = invMass1;//dot3F4(linear1, linear1)*invMass1;\n"
+	"	float jmj3 = dot3F4(mtMul3(angular1,*invInertia1), angular1);\n"
+	"	return -1.f/(jmj0+jmj1+jmj2+jmj3);\n"
+	"}\n"
+	"void solveContact(__global Constraint4* cs,\n"
+	"				  float4 posA, float4* linVelA, float4* angVelA, float invMassA, Matrix3x3 invInertiaA,\n"
+	"				  float4 posB, float4* linVelB, float4* angVelB, float invMassB, Matrix3x3 invInertiaB);\n"
+	"void solveContact(__global Constraint4* cs,\n"
+	"			float4 posA, float4* linVelA, float4* angVelA, float invMassA, Matrix3x3 invInertiaA,\n"
+	"			float4 posB, float4* linVelB, float4* angVelB, float invMassB, Matrix3x3 invInertiaB)\n"
+	"{\n"
+	"	float minRambdaDt = 0;\n"
+	"	float maxRambdaDt = FLT_MAX;\n"
+	"	for(int ic=0; ic<4; ic++)\n"
+	"	{\n"
+	"		if( cs->m_jacCoeffInv[ic] == 0.f ) continue;\n"
+	"		float4 angular0, angular1, linear;\n"
+	"		float4 r0 = cs->m_worldPos[ic] - posA;\n"
+	"		float4 r1 = cs->m_worldPos[ic] - posB;\n"
+	"		setLinearAndAngular( -cs->m_linear, r0, r1, &linear, &angular0, &angular1 );\n"
+	"		float rambdaDt = calcRelVel( cs->m_linear, -cs->m_linear, angular0, angular1, \n"
+	"			*linVelA, *angVelA, *linVelB, *angVelB ) + cs->m_b[ic];\n"
+	"		rambdaDt *= cs->m_jacCoeffInv[ic];\n"
+	"		{\n"
+	"			float prevSum = cs->m_appliedRambdaDt[ic];\n"
+	"			float updated = prevSum;\n"
+	"			updated += rambdaDt;\n"
+	"			updated = max2( updated, minRambdaDt );\n"
+	"			updated = min2( updated, maxRambdaDt );\n"
+	"			rambdaDt = updated - prevSum;\n"
+	"			cs->m_appliedRambdaDt[ic] = updated;\n"
+	"		}\n"
+	"		float4 linImp0 = invMassA*linear*rambdaDt;\n"
+	"		float4 linImp1 = invMassB*(-linear)*rambdaDt;\n"
+	"		float4 angImp0 = mtMul1(invInertiaA, angular0)*rambdaDt;\n"
+	"		float4 angImp1 = mtMul1(invInertiaB, angular1)*rambdaDt;\n"
+	"		*linVelA += linImp0;\n"
+	"		*angVelA += angImp0;\n"
+	"		*linVelB += linImp1;\n"
+	"		*angVelB += angImp1;\n"
+	"	}\n"
+	"}\n"
+	"void btPlaneSpace1 (const float4* n, float4* p, float4* q);\n"
+	" void btPlaneSpace1 (const float4* n, float4* p, float4* q)\n"
+	"{\n"
+	"  if (fabs(n[0].z) > 0.70710678f) {\n"
+	"    // choose p in y-z plane\n"
+	"    float a = n[0].y*n[0].y + n[0].z*n[0].z;\n"
+	"    float k = 1.f/sqrt(a);\n"
+	"    p[0].x = 0;\n"
+	"	p[0].y = -n[0].z*k;\n"
+	"	p[0].z = n[0].y*k;\n"
+	"    // set q = n x p\n"
+	"    q[0].x = a*k;\n"
+	"	q[0].y = -n[0].x*p[0].z;\n"
+	"	q[0].z = n[0].x*p[0].y;\n"
+	"  }\n"
+	"  else {\n"
+	"    // choose p in x-y plane\n"
+	"    float a = n[0].x*n[0].x + n[0].y*n[0].y;\n"
+	"    float k = 1.f/sqrt(a);\n"
+	"    p[0].x = -n[0].y*k;\n"
+	"	p[0].y = n[0].x*k;\n"
+	"	p[0].z = 0;\n"
+	"    // set q = n x p\n"
+	"    q[0].x = -n[0].z*p[0].y;\n"
+	"	q[0].y = n[0].z*p[0].x;\n"
+	"	q[0].z = a*k;\n"
+	"  }\n"
+	"}\n"
+	"void solveContactConstraint(__global Body* gBodies, __global Shape* gShapes, __global Constraint4* ldsCs);\n"
+	"void solveContactConstraint(__global Body* gBodies, __global Shape* gShapes, __global Constraint4* ldsCs)\n"
+	"{\n"
+	"	//float frictionCoeff = ldsCs[0].m_linear.w;\n"
+	"	int aIdx = ldsCs[0].m_bodyA;\n"
+	"	int bIdx = ldsCs[0].m_bodyB;\n"
+	"	float4 posA = gBodies[aIdx].m_pos;\n"
+	"	float4 linVelA = gBodies[aIdx].m_linVel;\n"
+	"	float4 angVelA = gBodies[aIdx].m_angVel;\n"
+	"	float invMassA = gBodies[aIdx].m_invMass;\n"
+	"	Matrix3x3 invInertiaA = gShapes[aIdx].m_invInertia;\n"
+	"	float4 posB = gBodies[bIdx].m_pos;\n"
+	"	float4 linVelB = gBodies[bIdx].m_linVel;\n"
+	"	float4 angVelB = gBodies[bIdx].m_angVel;\n"
+	"	float invMassB = gBodies[bIdx].m_invMass;\n"
+	"	Matrix3x3 invInertiaB = gShapes[bIdx].m_invInertia;\n"
+	"	solveContact( ldsCs, posA, &linVelA, &angVelA, invMassA, invInertiaA,\n"
+	"			posB, &linVelB, &angVelB, invMassB, invInertiaB );\n"
+	"  if (gBodies[aIdx].m_invMass)\n"
+	"  {\n"
+	"		gBodies[aIdx].m_linVel = linVelA;\n"
+	"		gBodies[aIdx].m_angVel = angVelA;\n"
+	"	} else\n"
+	"	{\n"
+	"		gBodies[aIdx].m_linVel = mymake_float4(0,0,0,0);\n"
+	"		gBodies[aIdx].m_angVel = mymake_float4(0,0,0,0);\n"
+	"	\n"
+	"	}\n"
+	"	if (gBodies[bIdx].m_invMass)\n"
+	"  {\n"
+	"		gBodies[bIdx].m_linVel = linVelB;\n"
+	"		gBodies[bIdx].m_angVel = angVelB;\n"
+	"	} else\n"
+	"	{\n"
+	"		gBodies[bIdx].m_linVel = mymake_float4(0,0,0,0);\n"
+	"		gBodies[bIdx].m_angVel = mymake_float4(0,0,0,0);\n"
+	"	\n"
+	"	}\n"
+	"}\n"
+	"typedef struct \n"
+	"{\n"
+	"	int m_valInt0;\n"
+	"	int m_valInt1;\n"
+	"	int m_valInt2;\n"
+	"	int m_valInt3;\n"
+	"	float m_val0;\n"
+	"	float m_val1;\n"
+	"	float m_val2;\n"
+	"	float m_val3;\n"
+	"} SolverDebugInfo;\n"
+	"__kernel\n"
+	"__attribute__((reqd_work_group_size(WG_SIZE,1,1)))\n"
+	"void BatchSolveKernelContact(__global Body* gBodies,\n"
+	"                      __global Shape* gShapes,\n"
+	"                      __global Constraint4* gConstraints,\n"
+	"                      __global int* gN,\n"
+	"                      __global int* gOffsets,\n"
+	"                      __global	int* batchSizes,\n"
+	"                       int maxBatch1,\n"
+	"                       int cellBatch,\n"
+	"                       int4 nSplit\n"
+	"                      )\n"
+	"{\n"
+	"	//__local int ldsBatchIdx[WG_SIZE+1];\n"
+	"	__local int ldsCurBatch;\n"
+	"	__local int ldsNextBatch;\n"
+	"	__local int ldsStart;\n"
+	"	int lIdx = GET_LOCAL_IDX;\n"
+	"	int wgIdx = GET_GROUP_IDX;\n"
+	"//	int gIdx = GET_GLOBAL_IDX;\n"
+	"//	debugInfo[gIdx].m_valInt0 = gIdx;\n"
+	"	//debugInfo[gIdx].m_valInt1 = GET_GROUP_SIZE;\n"
+	"	\n"
+	"	\n"
+	"	int zIdx = (wgIdx/((nSplit.x*nSplit.y)/4))*2+((cellBatch&4)>>2);\n"
+	"	int remain= (wgIdx%((nSplit.x*nSplit.y)/4));\n"
+	"	int yIdx = (remain/(nSplit.x/2))*2 + ((cellBatch&2)>>1);\n"
+	"	int xIdx = (remain%(nSplit.x/2))*2 + (cellBatch&1);\n"
+	"	int cellIdx = xIdx+yIdx*nSplit.x+zIdx*(nSplit.x*nSplit.y);\n"
+	"	//int xIdx = (wgIdx/(nSplit/2))*2 + (bIdx&1);\n"
+	"	//int yIdx = (wgIdx%(nSplit/2))*2 + (bIdx>>1);\n"
+	"	//int cellIdx = xIdx+yIdx*nSplit;\n"
+	"	\n"
+	"	if( gN[cellIdx] == 0 ) \n"
+	"		return;\n"
+	"	int maxBatch = batchSizes[cellIdx];\n"
+	"	\n"
+	"	\n"
+	"	const int start = gOffsets[cellIdx];\n"
+	"	const int end = start + gN[cellIdx];\n"
+	"	\n"
+	"	\n"
+	"	\n"
+	"	if( lIdx == 0 )\n"
+	"	{\n"
+	"		ldsCurBatch = 0;\n"
+	"		ldsNextBatch = 0;\n"
+	"		ldsStart = start;\n"
+	"	}\n"
+	"	GROUP_LDS_BARRIER;\n"
+	"	int idx=ldsStart+lIdx;\n"
+	"	while (ldsCurBatch < maxBatch)\n"
+	"	{\n"
+	"		for(; idx<end; )\n"
+	"		{\n"
+	"			if (gConstraints[idx].m_batchIdx == ldsCurBatch)\n"
+	"			{\n"
+	"					solveContactConstraint( gBodies, gShapes, &gConstraints[idx] );\n"
+	"				 idx+=64;\n"
+	"			} else\n"
+	"			{\n"
+	"				break;\n"
+	"			}\n"
+	"		}\n"
+	"		GROUP_LDS_BARRIER;\n"
+	"	\n"
+	"		if( lIdx == 0 )\n"
+	"		{\n"
+	"			ldsCurBatch++;\n"
+	"		}\n"
+	"		GROUP_LDS_BARRIER;\n"
+	"	}\n"
+	"	\n"
+	"    \n"
+	"}\n"
+	"__kernel void solveSingleContactKernel(__global Body* gBodies,\n"
+	"                      __global Shape* gShapes,\n"
+	"                      __global Constraint4* gConstraints,\n"
+	"                       int cellIdx,\n"
+	"                       int batchOffset,\n"
+	"                       int numConstraintsInBatch\n"
+	"                      )\n"
+	"{\n"
+	"	int index = get_global_id(0);\n"
+	"	if (index < numConstraintsInBatch)\n"
+	"	{\n"
+	"		int idx=batchOffset+index;\n"
+	"		solveContactConstraint( gBodies, gShapes, &gConstraints[idx] );\n"
+	"	}    \n"
+	"}\n";
diff --git a/engine/inc/bullet/Bullet3OpenCL/RigidBody/kernels/solveFriction.h b/engine/inc/bullet/Bullet3OpenCL/RigidBody/kernels/solveFriction.h
new file mode 100644
index 00000000..9707cdb2
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/RigidBody/kernels/solveFriction.h
@@ -0,0 +1,420 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* solveFrictionCL =
+	"/*\n"
+	"Copyright (c) 2012 Advanced Micro Devices, Inc.  \n"
+	"This software is provided 'as-is', without any express or implied warranty.\n"
+	"In no event will the authors be held liable for any damages arising from the use of this software.\n"
+	"Permission is granted to anyone to use this software for any purpose, \n"
+	"including commercial applications, and to alter it and redistribute it freely, \n"
+	"subject to the following restrictions:\n"
+	"1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.\n"
+	"2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.\n"
+	"3. This notice may not be removed or altered from any source distribution.\n"
+	"*/\n"
+	"//Originally written by Takahiro Harada\n"
+	"//#pragma OPENCL EXTENSION cl_amd_printf : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_local_int32_base_atomics : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_global_int32_base_atomics : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_local_int32_extended_atomics : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_global_int32_extended_atomics : enable\n"
+	"#ifdef cl_ext_atomic_counters_32\n"
+	"#pragma OPENCL EXTENSION cl_ext_atomic_counters_32 : enable\n"
+	"#else\n"
+	"#define counter32_t volatile global int*\n"
+	"#endif\n"
+	"typedef unsigned int u32;\n"
+	"typedef unsigned short u16;\n"
+	"typedef unsigned char u8;\n"
+	"#define GET_GROUP_IDX get_group_id(0)\n"
+	"#define GET_LOCAL_IDX get_local_id(0)\n"
+	"#define GET_GLOBAL_IDX get_global_id(0)\n"
+	"#define GET_GROUP_SIZE get_local_size(0)\n"
+	"#define GET_NUM_GROUPS get_num_groups(0)\n"
+	"#define GROUP_LDS_BARRIER barrier(CLK_LOCAL_MEM_FENCE)\n"
+	"#define GROUP_MEM_FENCE mem_fence(CLK_LOCAL_MEM_FENCE)\n"
+	"#define AtomInc(x) atom_inc(&(x))\n"
+	"#define AtomInc1(x, out) out = atom_inc(&(x))\n"
+	"#define AppendInc(x, out) out = atomic_inc(x)\n"
+	"#define AtomAdd(x, value) atom_add(&(x), value)\n"
+	"#define AtomCmpxhg(x, cmp, value) atom_cmpxchg( &(x), cmp, value )\n"
+	"#define AtomXhg(x, value) atom_xchg ( &(x), value )\n"
+	"#define SELECT_UINT4( b, a, condition ) select( b,a,condition )\n"
+	"#define mymake_float4 (float4)\n"
+	"//#define make_float2 (float2)\n"
+	"//#define make_uint4 (uint4)\n"
+	"//#define make_int4 (int4)\n"
+	"//#define make_uint2 (uint2)\n"
+	"//#define make_int2 (int2)\n"
+	"#define max2 max\n"
+	"#define min2 min\n"
+	"///////////////////////////////////////\n"
+	"//	Vector\n"
+	"///////////////////////////////////////\n"
+	"__inline\n"
+	"float4 fastNormalize4(float4 v)\n"
+	"{\n"
+	"	return fast_normalize(v);\n"
+	"}\n"
+	"__inline\n"
+	"float4 cross3(float4 a, float4 b)\n"
+	"{\n"
+	"	return cross(a,b);\n"
+	"}\n"
+	"__inline\n"
+	"float dot3F4(float4 a, float4 b)\n"
+	"{\n"
+	"	float4 a1 = mymake_float4(a.xyz,0.f);\n"
+	"	float4 b1 = mymake_float4(b.xyz,0.f);\n"
+	"	return dot(a1, b1);\n"
+	"}\n"
+	"__inline\n"
+	"float4 normalize3(const float4 a)\n"
+	"{\n"
+	"	float4 n = mymake_float4(a.x, a.y, a.z, 0.f);\n"
+	"	return fastNormalize4( n );\n"
+	"//	float length = sqrtf(dot3F4(a, a));\n"
+	"//	return 1.f/length * a;\n"
+	"}\n"
+	"///////////////////////////////////////\n"
+	"//	Matrix3x3\n"
+	"///////////////////////////////////////\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4 m_row[3];\n"
+	"}Matrix3x3;\n"
+	"__inline\n"
+	"float4 mtMul1(Matrix3x3 a, float4 b);\n"
+	"__inline\n"
+	"float4 mtMul3(float4 a, Matrix3x3 b);\n"
+	"__inline\n"
+	"float4 mtMul1(Matrix3x3 a, float4 b)\n"
+	"{\n"
+	"	float4 ans;\n"
+	"	ans.x = dot3F4( a.m_row[0], b );\n"
+	"	ans.y = dot3F4( a.m_row[1], b );\n"
+	"	ans.z = dot3F4( a.m_row[2], b );\n"
+	"	ans.w = 0.f;\n"
+	"	return ans;\n"
+	"}\n"
+	"__inline\n"
+	"float4 mtMul3(float4 a, Matrix3x3 b)\n"
+	"{\n"
+	"	float4 colx = mymake_float4(b.m_row[0].x, b.m_row[1].x, b.m_row[2].x, 0);\n"
+	"	float4 coly = mymake_float4(b.m_row[0].y, b.m_row[1].y, b.m_row[2].y, 0);\n"
+	"	float4 colz = mymake_float4(b.m_row[0].z, b.m_row[1].z, b.m_row[2].z, 0);\n"
+	"	float4 ans;\n"
+	"	ans.x = dot3F4( a, colx );\n"
+	"	ans.y = dot3F4( a, coly );\n"
+	"	ans.z = dot3F4( a, colz );\n"
+	"	return ans;\n"
+	"}\n"
+	"///////////////////////////////////////\n"
+	"//	Quaternion\n"
+	"///////////////////////////////////////\n"
+	"typedef float4 Quaternion;\n"
+	"#define WG_SIZE 64\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4 m_pos;\n"
+	"	Quaternion m_quat;\n"
+	"	float4 m_linVel;\n"
+	"	float4 m_angVel;\n"
+	"	u32 m_shapeIdx;\n"
+	"	float m_invMass;\n"
+	"	float m_restituitionCoeff;\n"
+	"	float m_frictionCoeff;\n"
+	"} Body;\n"
+	"typedef struct\n"
+	"{\n"
+	"	Matrix3x3 m_invInertia;\n"
+	"	Matrix3x3 m_initInvInertia;\n"
+	"} Shape;\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4 m_linear;\n"
+	"	float4 m_worldPos[4];\n"
+	"	float4 m_center;	\n"
+	"	float m_jacCoeffInv[4];\n"
+	"	float m_b[4];\n"
+	"	float m_appliedRambdaDt[4];\n"
+	"	float m_fJacCoeffInv[2];	\n"
+	"	float m_fAppliedRambdaDt[2];	\n"
+	"	u32 m_bodyA;\n"
+	"	u32 m_bodyB;\n"
+	"	int m_batchIdx;\n"
+	"	u32 m_paddings[1];\n"
+	"} Constraint4;\n"
+	"typedef struct\n"
+	"{\n"
+	"	int m_nConstraints;\n"
+	"	int m_start;\n"
+	"	int m_batchIdx;\n"
+	"	int m_nSplit;\n"
+	"//	int m_paddings[1];\n"
+	"} ConstBuffer;\n"
+	"typedef struct\n"
+	"{\n"
+	"	int m_solveFriction;\n"
+	"	int m_maxBatch;	//	long batch really kills the performance\n"
+	"	int m_batchIdx;\n"
+	"	int m_nSplit;\n"
+	"//	int m_paddings[1];\n"
+	"} ConstBufferBatchSolve;\n"
+	"void setLinearAndAngular( float4 n, float4 r0, float4 r1, float4* linear, float4* angular0, float4* angular1);\n"
+	"void setLinearAndAngular( float4 n, float4 r0, float4 r1, float4* linear, float4* angular0, float4* angular1)\n"
+	"{\n"
+	"	*linear = mymake_float4(-n.xyz,0.f);\n"
+	"	*angular0 = -cross3(r0, n);\n"
+	"	*angular1 = cross3(r1, n);\n"
+	"}\n"
+	"float calcRelVel( float4 l0, float4 l1, float4 a0, float4 a1, float4 linVel0, float4 angVel0, float4 linVel1, float4 angVel1 );\n"
+	"float calcRelVel( float4 l0, float4 l1, float4 a0, float4 a1, float4 linVel0, float4 angVel0, float4 linVel1, float4 angVel1 )\n"
+	"{\n"
+	"	return dot3F4(l0, linVel0) + dot3F4(a0, angVel0) + dot3F4(l1, linVel1) + dot3F4(a1, angVel1);\n"
+	"}\n"
+	"float calcJacCoeff(const float4 linear0, const float4 linear1, const float4 angular0, const float4 angular1,\n"
+	"				   float invMass0, const Matrix3x3* invInertia0, float invMass1, const Matrix3x3* invInertia1);\n"
+	"float calcJacCoeff(const float4 linear0, const float4 linear1, const float4 angular0, const float4 angular1,\n"
+	"					float invMass0, const Matrix3x3* invInertia0, float invMass1, const Matrix3x3* invInertia1)\n"
+	"{\n"
+	"	//	linear0,1 are normlized\n"
+	"	float jmj0 = invMass0;//dot3F4(linear0, linear0)*invMass0;\n"
+	"	float jmj1 = dot3F4(mtMul3(angular0,*invInertia0), angular0);\n"
+	"	float jmj2 = invMass1;//dot3F4(linear1, linear1)*invMass1;\n"
+	"	float jmj3 = dot3F4(mtMul3(angular1,*invInertia1), angular1);\n"
+	"	return -1.f/(jmj0+jmj1+jmj2+jmj3);\n"
+	"}\n"
+	"void btPlaneSpace1 (const float4* n, float4* p, float4* q);\n"
+	" void btPlaneSpace1 (const float4* n, float4* p, float4* q)\n"
+	"{\n"
+	"  if (fabs(n[0].z) > 0.70710678f) {\n"
+	"    // choose p in y-z plane\n"
+	"    float a = n[0].y*n[0].y + n[0].z*n[0].z;\n"
+	"    float k = 1.f/sqrt(a);\n"
+	"    p[0].x = 0;\n"
+	"	p[0].y = -n[0].z*k;\n"
+	"	p[0].z = n[0].y*k;\n"
+	"    // set q = n x p\n"
+	"    q[0].x = a*k;\n"
+	"	q[0].y = -n[0].x*p[0].z;\n"
+	"	q[0].z = n[0].x*p[0].y;\n"
+	"  }\n"
+	"  else {\n"
+	"    // choose p in x-y plane\n"
+	"    float a = n[0].x*n[0].x + n[0].y*n[0].y;\n"
+	"    float k = 1.f/sqrt(a);\n"
+	"    p[0].x = -n[0].y*k;\n"
+	"	p[0].y = n[0].x*k;\n"
+	"	p[0].z = 0;\n"
+	"    // set q = n x p\n"
+	"    q[0].x = -n[0].z*p[0].y;\n"
+	"	q[0].y = n[0].z*p[0].x;\n"
+	"	q[0].z = a*k;\n"
+	"  }\n"
+	"}\n"
+	"void solveFrictionConstraint(__global Body* gBodies, __global Shape* gShapes, __global Constraint4* ldsCs);\n"
+	"void solveFrictionConstraint(__global Body* gBodies, __global Shape* gShapes, __global Constraint4* ldsCs)\n"
+	"{\n"
+	"	float frictionCoeff = ldsCs[0].m_linear.w;\n"
+	"	int aIdx = ldsCs[0].m_bodyA;\n"
+	"	int bIdx = ldsCs[0].m_bodyB;\n"
+	"	float4 posA = gBodies[aIdx].m_pos;\n"
+	"	float4 linVelA = gBodies[aIdx].m_linVel;\n"
+	"	float4 angVelA = gBodies[aIdx].m_angVel;\n"
+	"	float invMassA = gBodies[aIdx].m_invMass;\n"
+	"	Matrix3x3 invInertiaA = gShapes[aIdx].m_invInertia;\n"
+	"	float4 posB = gBodies[bIdx].m_pos;\n"
+	"	float4 linVelB = gBodies[bIdx].m_linVel;\n"
+	"	float4 angVelB = gBodies[bIdx].m_angVel;\n"
+	"	float invMassB = gBodies[bIdx].m_invMass;\n"
+	"	Matrix3x3 invInertiaB = gShapes[bIdx].m_invInertia;\n"
+	"	\n"
+	"	{\n"
+	"		float maxRambdaDt[4] = {FLT_MAX,FLT_MAX,FLT_MAX,FLT_MAX};\n"
+	"		float minRambdaDt[4] = {0.f,0.f,0.f,0.f};\n"
+	"		float sum = 0;\n"
+	"		for(int j=0; j<4; j++)\n"
+	"		{\n"
+	"			sum +=ldsCs[0].m_appliedRambdaDt[j];\n"
+	"		}\n"
+	"		frictionCoeff = 0.7f;\n"
+	"		for(int j=0; j<4; j++)\n"
+	"		{\n"
+	"			maxRambdaDt[j] = frictionCoeff*sum;\n"
+	"			minRambdaDt[j] = -maxRambdaDt[j];\n"
+	"		}\n"
+	"		\n"
+	"//		solveFriction( ldsCs, posA, &linVelA, &angVelA, invMassA, invInertiaA,\n"
+	"//			posB, &linVelB, &angVelB, invMassB, invInertiaB, maxRambdaDt, minRambdaDt );\n"
+	"		\n"
+	"		\n"
+	"		{\n"
+	"			\n"
+	"			__global Constraint4* cs = ldsCs;\n"
+	"			\n"
+	"			if( cs->m_fJacCoeffInv[0] == 0 && cs->m_fJacCoeffInv[0] == 0 ) return;\n"
+	"			const float4 center = cs->m_center;\n"
+	"			\n"
+	"			float4 n = -cs->m_linear;\n"
+	"			\n"
+	"			float4 tangent[2];\n"
+	"			btPlaneSpace1(&n,&tangent[0],&tangent[1]);\n"
+	"			float4 angular0, angular1, linear;\n"
+	"			float4 r0 = center - posA;\n"
+	"			float4 r1 = center - posB;\n"
+	"			for(int i=0; i<2; i++)\n"
+	"			{\n"
+	"				setLinearAndAngular( tangent[i], r0, r1, &linear, &angular0, &angular1 );\n"
+	"				float rambdaDt = calcRelVel(linear, -linear, angular0, angular1,\n"
+	"											linVelA, angVelA, linVelB, angVelB );\n"
+	"				rambdaDt *= cs->m_fJacCoeffInv[i];\n"
+	"				\n"
+	"				{\n"
+	"					float prevSum = cs->m_fAppliedRambdaDt[i];\n"
+	"					float updated = prevSum;\n"
+	"					updated += rambdaDt;\n"
+	"					updated = max2( updated, minRambdaDt[i] );\n"
+	"					updated = min2( updated, maxRambdaDt[i] );\n"
+	"					rambdaDt = updated - prevSum;\n"
+	"					cs->m_fAppliedRambdaDt[i] = updated;\n"
+	"				}\n"
+	"				\n"
+	"				float4 linImp0 = invMassA*linear*rambdaDt;\n"
+	"				float4 linImp1 = invMassB*(-linear)*rambdaDt;\n"
+	"				float4 angImp0 = mtMul1(invInertiaA, angular0)*rambdaDt;\n"
+	"				float4 angImp1 = mtMul1(invInertiaB, angular1)*rambdaDt;\n"
+	"				\n"
+	"				linVelA += linImp0;\n"
+	"				angVelA += angImp0;\n"
+	"				linVelB += linImp1;\n"
+	"				angVelB += angImp1;\n"
+	"			}\n"
+	"			{	//	angular damping for point constraint\n"
+	"				float4 ab = normalize3( posB - posA );\n"
+	"				float4 ac = normalize3( center - posA );\n"
+	"				if( dot3F4( ab, ac ) > 0.95f  || (invMassA == 0.f || invMassB == 0.f))\n"
+	"				{\n"
+	"					float angNA = dot3F4( n, angVelA );\n"
+	"					float angNB = dot3F4( n, angVelB );\n"
+	"					\n"
+	"					angVelA -= (angNA*0.1f)*n;\n"
+	"					angVelB -= (angNB*0.1f)*n;\n"
+	"				}\n"
+	"			}\n"
+	"		}\n"
+	"		\n"
+	"		\n"
+	"	}\n"
+	"	if (gBodies[aIdx].m_invMass)\n"
+	"	{\n"
+	"		gBodies[aIdx].m_linVel = linVelA;\n"
+	"		gBodies[aIdx].m_angVel = angVelA;\n"
+	"	} else\n"
+	"	{\n"
+	"		gBodies[aIdx].m_linVel = mymake_float4(0,0,0,0);\n"
+	"		gBodies[aIdx].m_angVel = mymake_float4(0,0,0,0);\n"
+	"	}\n"
+	"	if (gBodies[bIdx].m_invMass)\n"
+	"	{\n"
+	"		gBodies[bIdx].m_linVel = linVelB;\n"
+	"		gBodies[bIdx].m_angVel = angVelB;\n"
+	"	} else\n"
+	"	{\n"
+	"		gBodies[bIdx].m_linVel = mymake_float4(0,0,0,0);\n"
+	"		gBodies[bIdx].m_angVel = mymake_float4(0,0,0,0);\n"
+	"	}\n"
+	" \n"
+	"}\n"
+	"typedef struct \n"
+	"{\n"
+	"	int m_valInt0;\n"
+	"	int m_valInt1;\n"
+	"	int m_valInt2;\n"
+	"	int m_valInt3;\n"
+	"	float m_val0;\n"
+	"	float m_val1;\n"
+	"	float m_val2;\n"
+	"	float m_val3;\n"
+	"} SolverDebugInfo;\n"
+	"__kernel\n"
+	"__attribute__((reqd_work_group_size(WG_SIZE,1,1)))\n"
+	"void BatchSolveKernelFriction(__global Body* gBodies,\n"
+	"                      __global Shape* gShapes,\n"
+	"                      __global Constraint4* gConstraints,\n"
+	"                      __global int* gN,\n"
+	"                      __global int* gOffsets,\n"
+	"                      __global int* batchSizes,\n"
+	"                       int maxBatch1,\n"
+	"                       int cellBatch,\n"
+	"                       int4 nSplit\n"
+	"                      )\n"
+	"{\n"
+	"	//__local int ldsBatchIdx[WG_SIZE+1];\n"
+	"	__local int ldsCurBatch;\n"
+	"	__local int ldsNextBatch;\n"
+	"	__local int ldsStart;\n"
+	"	int lIdx = GET_LOCAL_IDX;\n"
+	"	int wgIdx = GET_GROUP_IDX;\n"
+	"//	int gIdx = GET_GLOBAL_IDX;\n"
+	"//	debugInfo[gIdx].m_valInt0 = gIdx;\n"
+	"	//debugInfo[gIdx].m_valInt1 = GET_GROUP_SIZE;\n"
+	"	int zIdx = (wgIdx/((nSplit.x*nSplit.y)/4))*2+((cellBatch&4)>>2);\n"
+	"	int remain= (wgIdx%((nSplit.x*nSplit.y)/4));\n"
+	"	int yIdx = (remain/(nSplit.x/2))*2 + ((cellBatch&2)>>1);\n"
+	"	int xIdx = (remain%(nSplit.x/2))*2 + (cellBatch&1);\n"
+	"	int cellIdx = xIdx+yIdx*nSplit.x+zIdx*(nSplit.x*nSplit.y);\n"
+	"	\n"
+	"	if( gN[cellIdx] == 0 ) \n"
+	"		return;\n"
+	"	int maxBatch = batchSizes[cellIdx];\n"
+	"	const int start = gOffsets[cellIdx];\n"
+	"	const int end = start + gN[cellIdx];\n"
+	"	\n"
+	"	if( lIdx == 0 )\n"
+	"	{\n"
+	"		ldsCurBatch = 0;\n"
+	"		ldsNextBatch = 0;\n"
+	"		ldsStart = start;\n"
+	"	}\n"
+	"	GROUP_LDS_BARRIER;\n"
+	"	int idx=ldsStart+lIdx;\n"
+	"	while (ldsCurBatch < maxBatch)\n"
+	"	{\n"
+	"		for(; idx<end; )\n"
+	"		{\n"
+	"			if (gConstraints[idx].m_batchIdx == ldsCurBatch)\n"
+	"			{\n"
+	"					solveFrictionConstraint( gBodies, gShapes, &gConstraints[idx] );\n"
+	"				 idx+=64;\n"
+	"			} else\n"
+	"			{\n"
+	"				break;\n"
+	"			}\n"
+	"		}\n"
+	"		GROUP_LDS_BARRIER;\n"
+	"		if( lIdx == 0 )\n"
+	"		{\n"
+	"			ldsCurBatch++;\n"
+	"		}\n"
+	"		GROUP_LDS_BARRIER;\n"
+	"	}\n"
+	"	\n"
+	"    \n"
+	"}\n"
+	"__kernel void solveSingleFrictionKernel(__global Body* gBodies,\n"
+	"                      __global Shape* gShapes,\n"
+	"                      __global Constraint4* gConstraints,\n"
+	"                       int cellIdx,\n"
+	"                       int batchOffset,\n"
+	"                       int numConstraintsInBatch\n"
+	"                      )\n"
+	"{\n"
+	"	int index = get_global_id(0);\n"
+	"	if (index < numConstraintsInBatch)\n"
+	"	{\n"
+	"		\n"
+	"		int idx=batchOffset+index;\n"
+	"	\n"
+	"		solveFrictionConstraint( gBodies, gShapes, &gConstraints[idx] );\n"
+	"	}    \n"
+	"}\n";
diff --git a/engine/inc/bullet/Bullet3OpenCL/RigidBody/kernels/solverSetup.h b/engine/inc/bullet/Bullet3OpenCL/RigidBody/kernels/solverSetup.h
new file mode 100644
index 00000000..d53db031
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/RigidBody/kernels/solverSetup.h
@@ -0,0 +1,702 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* solverSetupCL =
+	"/*\n"
+	"Copyright (c) 2012 Advanced Micro Devices, Inc.  \n"
+	"This software is provided 'as-is', without any express or implied warranty.\n"
+	"In no event will the authors be held liable for any damages arising from the use of this software.\n"
+	"Permission is granted to anyone to use this software for any purpose, \n"
+	"including commercial applications, and to alter it and redistribute it freely, \n"
+	"subject to the following restrictions:\n"
+	"1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.\n"
+	"2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.\n"
+	"3. This notice may not be removed or altered from any source distribution.\n"
+	"*/\n"
+	"//Originally written by Takahiro Harada\n"
+	"#ifndef B3_CONTACT4DATA_H\n"
+	"#define B3_CONTACT4DATA_H\n"
+	"#ifndef B3_FLOAT4_H\n"
+	"#define B3_FLOAT4_H\n"
+	"#ifndef B3_PLATFORM_DEFINITIONS_H\n"
+	"#define B3_PLATFORM_DEFINITIONS_H\n"
+	"struct MyTest\n"
+	"{\n"
+	"	int bla;\n"
+	"};\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"//keep B3_LARGE_FLOAT*B3_LARGE_FLOAT < FLT_MAX\n"
+	"#define B3_LARGE_FLOAT 1e18f\n"
+	"#define B3_INFINITY 1e18f\n"
+	"#define b3Assert(a)\n"
+	"#define b3ConstArray(a) __global const a*\n"
+	"#define b3AtomicInc atomic_inc\n"
+	"#define b3AtomicAdd atomic_add\n"
+	"#define b3Fabs fabs\n"
+	"#define b3Sqrt native_sqrt\n"
+	"#define b3Sin native_sin\n"
+	"#define b3Cos native_cos\n"
+	"#define B3_STATIC\n"
+	"#endif\n"
+	"#endif\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"	typedef float4	b3Float4;\n"
+	"	#define b3Float4ConstArg const b3Float4\n"
+	"	#define b3MakeFloat4 (float4)\n"
+	"	float b3Dot3F4(b3Float4ConstArg v0,b3Float4ConstArg v1)\n"
+	"	{\n"
+	"		float4 a1 = b3MakeFloat4(v0.xyz,0.f);\n"
+	"		float4 b1 = b3MakeFloat4(v1.xyz,0.f);\n"
+	"		return dot(a1, b1);\n"
+	"	}\n"
+	"	b3Float4 b3Cross3(b3Float4ConstArg v0,b3Float4ConstArg v1)\n"
+	"	{\n"
+	"		float4 a1 = b3MakeFloat4(v0.xyz,0.f);\n"
+	"		float4 b1 = b3MakeFloat4(v1.xyz,0.f);\n"
+	"		return cross(a1, b1);\n"
+	"	}\n"
+	"	#define b3MinFloat4 min\n"
+	"	#define b3MaxFloat4 max\n"
+	"	#define b3Normalized(a) normalize(a)\n"
+	"#endif \n"
+	"		\n"
+	"inline bool b3IsAlmostZero(b3Float4ConstArg v)\n"
+	"{\n"
+	"	if(b3Fabs(v.x)>1e-6 || b3Fabs(v.y)>1e-6 || b3Fabs(v.z)>1e-6)	\n"
+	"		return false;\n"
+	"	return true;\n"
+	"}\n"
+	"inline int    b3MaxDot( b3Float4ConstArg vec, __global const b3Float4* vecArray, int vecLen, float* dotOut )\n"
+	"{\n"
+	"    float maxDot = -B3_INFINITY;\n"
+	"    int i = 0;\n"
+	"    int ptIndex = -1;\n"
+	"    for( i = 0; i < vecLen; i++ )\n"
+	"    {\n"
+	"        float dot = b3Dot3F4(vecArray[i],vec);\n"
+	"            \n"
+	"        if( dot > maxDot )\n"
+	"        {\n"
+	"            maxDot = dot;\n"
+	"            ptIndex = i;\n"
+	"        }\n"
+	"    }\n"
+	"	b3Assert(ptIndex>=0);\n"
+	"    if (ptIndex<0)\n"
+	"	{\n"
+	"		ptIndex = 0;\n"
+	"	}\n"
+	"    *dotOut = maxDot;\n"
+	"    return ptIndex;\n"
+	"}\n"
+	"#endif //B3_FLOAT4_H\n"
+	"typedef  struct b3Contact4Data b3Contact4Data_t;\n"
+	"struct b3Contact4Data\n"
+	"{\n"
+	"	b3Float4	m_worldPosB[4];\n"
+	"//	b3Float4	m_localPosA[4];\n"
+	"//	b3Float4	m_localPosB[4];\n"
+	"	b3Float4	m_worldNormalOnB;	//	w: m_nPoints\n"
+	"	unsigned short  m_restituitionCoeffCmp;\n"
+	"	unsigned short  m_frictionCoeffCmp;\n"
+	"	int m_batchIdx;\n"
+	"	int m_bodyAPtrAndSignBit;//x:m_bodyAPtr, y:m_bodyBPtr\n"
+	"	int m_bodyBPtrAndSignBit;\n"
+	"	int	m_childIndexA;\n"
+	"	int	m_childIndexB;\n"
+	"	int m_unused1;\n"
+	"	int m_unused2;\n"
+	"};\n"
+	"inline int b3Contact4Data_getNumPoints(const struct b3Contact4Data* contact)\n"
+	"{\n"
+	"	return (int)contact->m_worldNormalOnB.w;\n"
+	"};\n"
+	"inline void b3Contact4Data_setNumPoints(struct b3Contact4Data* contact, int numPoints)\n"
+	"{\n"
+	"	contact->m_worldNormalOnB.w = (float)numPoints;\n"
+	"};\n"
+	"#endif //B3_CONTACT4DATA_H\n"
+	"#ifndef B3_CONTACT_CONSTRAINT5_H\n"
+	"#define B3_CONTACT_CONSTRAINT5_H\n"
+	"#ifndef B3_FLOAT4_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif \n"
+	"#endif //B3_FLOAT4_H\n"
+	"typedef struct b3ContactConstraint4 b3ContactConstraint4_t;\n"
+	"struct b3ContactConstraint4\n"
+	"{\n"
+	"	b3Float4 m_linear;//normal?\n"
+	"	b3Float4 m_worldPos[4];\n"
+	"	b3Float4 m_center;	//	friction\n"
+	"	float m_jacCoeffInv[4];\n"
+	"	float m_b[4];\n"
+	"	float m_appliedRambdaDt[4];\n"
+	"	float m_fJacCoeffInv[2];	//	friction\n"
+	"	float m_fAppliedRambdaDt[2];	//	friction\n"
+	"	unsigned int m_bodyA;\n"
+	"	unsigned int m_bodyB;\n"
+	"	int			m_batchIdx;\n"
+	"	unsigned int m_paddings;\n"
+	"};\n"
+	"//inline	void setFrictionCoeff(float value) { m_linear[3] = value; }\n"
+	"inline	float b3GetFrictionCoeff(b3ContactConstraint4_t* constraint) \n"
+	"{\n"
+	"	return constraint->m_linear.w; \n"
+	"}\n"
+	"#endif //B3_CONTACT_CONSTRAINT5_H\n"
+	"#ifndef B3_RIGIDBODY_DATA_H\n"
+	"#define B3_RIGIDBODY_DATA_H\n"
+	"#ifndef B3_FLOAT4_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif \n"
+	"#endif //B3_FLOAT4_H\n"
+	"#ifndef B3_QUAT_H\n"
+	"#define B3_QUAT_H\n"
+	"#ifndef B3_PLATFORM_DEFINITIONS_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif\n"
+	"#endif\n"
+	"#ifndef B3_FLOAT4_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif \n"
+	"#endif //B3_FLOAT4_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"	typedef float4	b3Quat;\n"
+	"	#define b3QuatConstArg const b3Quat\n"
+	"	\n"
+	"	\n"
+	"inline float4 b3FastNormalize4(float4 v)\n"
+	"{\n"
+	"	v = (float4)(v.xyz,0.f);\n"
+	"	return fast_normalize(v);\n"
+	"}\n"
+	"	\n"
+	"inline b3Quat b3QuatMul(b3Quat a, b3Quat b);\n"
+	"inline b3Quat b3QuatNormalized(b3QuatConstArg in);\n"
+	"inline b3Quat b3QuatRotate(b3QuatConstArg q, b3QuatConstArg vec);\n"
+	"inline b3Quat b3QuatInvert(b3QuatConstArg q);\n"
+	"inline b3Quat b3QuatInverse(b3QuatConstArg q);\n"
+	"inline b3Quat b3QuatMul(b3QuatConstArg a, b3QuatConstArg b)\n"
+	"{\n"
+	"	b3Quat ans;\n"
+	"	ans = b3Cross3( a, b );\n"
+	"	ans += a.w*b+b.w*a;\n"
+	"//	ans.w = a.w*b.w - (a.x*b.x+a.y*b.y+a.z*b.z);\n"
+	"	ans.w = a.w*b.w - b3Dot3F4(a, b);\n"
+	"	return ans;\n"
+	"}\n"
+	"inline b3Quat b3QuatNormalized(b3QuatConstArg in)\n"
+	"{\n"
+	"	b3Quat q;\n"
+	"	q=in;\n"
+	"	//return b3FastNormalize4(in);\n"
+	"	float len = native_sqrt(dot(q, q));\n"
+	"	if(len > 0.f)\n"
+	"	{\n"
+	"		q *= 1.f / len;\n"
+	"	}\n"
+	"	else\n"
+	"	{\n"
+	"		q.x = q.y = q.z = 0.f;\n"
+	"		q.w = 1.f;\n"
+	"	}\n"
+	"	return q;\n"
+	"}\n"
+	"inline float4 b3QuatRotate(b3QuatConstArg q, b3QuatConstArg vec)\n"
+	"{\n"
+	"	b3Quat qInv = b3QuatInvert( q );\n"
+	"	float4 vcpy = vec;\n"
+	"	vcpy.w = 0.f;\n"
+	"	float4 out = b3QuatMul(b3QuatMul(q,vcpy),qInv);\n"
+	"	return out;\n"
+	"}\n"
+	"inline b3Quat b3QuatInverse(b3QuatConstArg q)\n"
+	"{\n"
+	"	return (b3Quat)(-q.xyz, q.w);\n"
+	"}\n"
+	"inline b3Quat b3QuatInvert(b3QuatConstArg q)\n"
+	"{\n"
+	"	return (b3Quat)(-q.xyz, q.w);\n"
+	"}\n"
+	"inline float4 b3QuatInvRotate(b3QuatConstArg q, b3QuatConstArg vec)\n"
+	"{\n"
+	"	return b3QuatRotate( b3QuatInvert( q ), vec );\n"
+	"}\n"
+	"inline b3Float4 b3TransformPoint(b3Float4ConstArg point, b3Float4ConstArg translation, b3QuatConstArg  orientation)\n"
+	"{\n"
+	"	return b3QuatRotate( orientation, point ) + (translation);\n"
+	"}\n"
+	"	\n"
+	"#endif \n"
+	"#endif //B3_QUAT_H\n"
+	"#ifndef B3_MAT3x3_H\n"
+	"#define B3_MAT3x3_H\n"
+	"#ifndef B3_QUAT_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif \n"
+	"#endif //B3_QUAT_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"typedef struct\n"
+	"{\n"
+	"	b3Float4 m_row[3];\n"
+	"}b3Mat3x3;\n"
+	"#define b3Mat3x3ConstArg const b3Mat3x3\n"
+	"#define b3GetRow(m,row) (m.m_row[row])\n"
+	"inline b3Mat3x3 b3QuatGetRotationMatrix(b3Quat quat)\n"
+	"{\n"
+	"	b3Float4 quat2 = (b3Float4)(quat.x*quat.x, quat.y*quat.y, quat.z*quat.z, 0.f);\n"
+	"	b3Mat3x3 out;\n"
+	"	out.m_row[0].x=1-2*quat2.y-2*quat2.z;\n"
+	"	out.m_row[0].y=2*quat.x*quat.y-2*quat.w*quat.z;\n"
+	"	out.m_row[0].z=2*quat.x*quat.z+2*quat.w*quat.y;\n"
+	"	out.m_row[0].w = 0.f;\n"
+	"	out.m_row[1].x=2*quat.x*quat.y+2*quat.w*quat.z;\n"
+	"	out.m_row[1].y=1-2*quat2.x-2*quat2.z;\n"
+	"	out.m_row[1].z=2*quat.y*quat.z-2*quat.w*quat.x;\n"
+	"	out.m_row[1].w = 0.f;\n"
+	"	out.m_row[2].x=2*quat.x*quat.z-2*quat.w*quat.y;\n"
+	"	out.m_row[2].y=2*quat.y*quat.z+2*quat.w*quat.x;\n"
+	"	out.m_row[2].z=1-2*quat2.x-2*quat2.y;\n"
+	"	out.m_row[2].w = 0.f;\n"
+	"	return out;\n"
+	"}\n"
+	"inline b3Mat3x3 b3AbsoluteMat3x3(b3Mat3x3ConstArg matIn)\n"
+	"{\n"
+	"	b3Mat3x3 out;\n"
+	"	out.m_row[0] = fabs(matIn.m_row[0]);\n"
+	"	out.m_row[1] = fabs(matIn.m_row[1]);\n"
+	"	out.m_row[2] = fabs(matIn.m_row[2]);\n"
+	"	return out;\n"
+	"}\n"
+	"__inline\n"
+	"b3Mat3x3 mtZero();\n"
+	"__inline\n"
+	"b3Mat3x3 mtIdentity();\n"
+	"__inline\n"
+	"b3Mat3x3 mtTranspose(b3Mat3x3 m);\n"
+	"__inline\n"
+	"b3Mat3x3 mtMul(b3Mat3x3 a, b3Mat3x3 b);\n"
+	"__inline\n"
+	"b3Float4 mtMul1(b3Mat3x3 a, b3Float4 b);\n"
+	"__inline\n"
+	"b3Float4 mtMul3(b3Float4 a, b3Mat3x3 b);\n"
+	"__inline\n"
+	"b3Mat3x3 mtZero()\n"
+	"{\n"
+	"	b3Mat3x3 m;\n"
+	"	m.m_row[0] = (b3Float4)(0.f);\n"
+	"	m.m_row[1] = (b3Float4)(0.f);\n"
+	"	m.m_row[2] = (b3Float4)(0.f);\n"
+	"	return m;\n"
+	"}\n"
+	"__inline\n"
+	"b3Mat3x3 mtIdentity()\n"
+	"{\n"
+	"	b3Mat3x3 m;\n"
+	"	m.m_row[0] = (b3Float4)(1,0,0,0);\n"
+	"	m.m_row[1] = (b3Float4)(0,1,0,0);\n"
+	"	m.m_row[2] = (b3Float4)(0,0,1,0);\n"
+	"	return m;\n"
+	"}\n"
+	"__inline\n"
+	"b3Mat3x3 mtTranspose(b3Mat3x3 m)\n"
+	"{\n"
+	"	b3Mat3x3 out;\n"
+	"	out.m_row[0] = (b3Float4)(m.m_row[0].x, m.m_row[1].x, m.m_row[2].x, 0.f);\n"
+	"	out.m_row[1] = (b3Float4)(m.m_row[0].y, m.m_row[1].y, m.m_row[2].y, 0.f);\n"
+	"	out.m_row[2] = (b3Float4)(m.m_row[0].z, m.m_row[1].z, m.m_row[2].z, 0.f);\n"
+	"	return out;\n"
+	"}\n"
+	"__inline\n"
+	"b3Mat3x3 mtMul(b3Mat3x3 a, b3Mat3x3 b)\n"
+	"{\n"
+	"	b3Mat3x3 transB;\n"
+	"	transB = mtTranspose( b );\n"
+	"	b3Mat3x3 ans;\n"
+	"	//	why this doesn't run when 0ing in the for{}\n"
+	"	a.m_row[0].w = 0.f;\n"
+	"	a.m_row[1].w = 0.f;\n"
+	"	a.m_row[2].w = 0.f;\n"
+	"	for(int i=0; i<3; i++)\n"
+	"	{\n"
+	"//	a.m_row[i].w = 0.f;\n"
+	"		ans.m_row[i].x = b3Dot3F4(a.m_row[i],transB.m_row[0]);\n"
+	"		ans.m_row[i].y = b3Dot3F4(a.m_row[i],transB.m_row[1]);\n"
+	"		ans.m_row[i].z = b3Dot3F4(a.m_row[i],transB.m_row[2]);\n"
+	"		ans.m_row[i].w = 0.f;\n"
+	"	}\n"
+	"	return ans;\n"
+	"}\n"
+	"__inline\n"
+	"b3Float4 mtMul1(b3Mat3x3 a, b3Float4 b)\n"
+	"{\n"
+	"	b3Float4 ans;\n"
+	"	ans.x = b3Dot3F4( a.m_row[0], b );\n"
+	"	ans.y = b3Dot3F4( a.m_row[1], b );\n"
+	"	ans.z = b3Dot3F4( a.m_row[2], b );\n"
+	"	ans.w = 0.f;\n"
+	"	return ans;\n"
+	"}\n"
+	"__inline\n"
+	"b3Float4 mtMul3(b3Float4 a, b3Mat3x3 b)\n"
+	"{\n"
+	"	b3Float4 colx = b3MakeFloat4(b.m_row[0].x, b.m_row[1].x, b.m_row[2].x, 0);\n"
+	"	b3Float4 coly = b3MakeFloat4(b.m_row[0].y, b.m_row[1].y, b.m_row[2].y, 0);\n"
+	"	b3Float4 colz = b3MakeFloat4(b.m_row[0].z, b.m_row[1].z, b.m_row[2].z, 0);\n"
+	"	b3Float4 ans;\n"
+	"	ans.x = b3Dot3F4( a, colx );\n"
+	"	ans.y = b3Dot3F4( a, coly );\n"
+	"	ans.z = b3Dot3F4( a, colz );\n"
+	"	return ans;\n"
+	"}\n"
+	"#endif\n"
+	"#endif //B3_MAT3x3_H\n"
+	"typedef struct b3RigidBodyData b3RigidBodyData_t;\n"
+	"struct b3RigidBodyData\n"
+	"{\n"
+	"	b3Float4				m_pos;\n"
+	"	b3Quat					m_quat;\n"
+	"	b3Float4				m_linVel;\n"
+	"	b3Float4				m_angVel;\n"
+	"	int 					m_collidableIdx;\n"
+	"	float 				m_invMass;\n"
+	"	float 				m_restituitionCoeff;\n"
+	"	float 				m_frictionCoeff;\n"
+	"};\n"
+	"typedef struct b3InertiaData b3InertiaData_t;\n"
+	"struct b3InertiaData\n"
+	"{\n"
+	"	b3Mat3x3 m_invInertiaWorld;\n"
+	"	b3Mat3x3 m_initInvInertia;\n"
+	"};\n"
+	"#endif //B3_RIGIDBODY_DATA_H\n"
+	"	\n"
+	"void b3PlaneSpace1 (b3Float4ConstArg n, b3Float4* p, b3Float4* q);\n"
+	" void b3PlaneSpace1 (b3Float4ConstArg n, b3Float4* p, b3Float4* q)\n"
+	"{\n"
+	"  if (b3Fabs(n.z) > 0.70710678f) {\n"
+	"    // choose p in y-z plane\n"
+	"    float a = n.y*n.y + n.z*n.z;\n"
+	"    float k = 1.f/sqrt(a);\n"
+	"    p[0].x = 0;\n"
+	"	p[0].y = -n.z*k;\n"
+	"	p[0].z = n.y*k;\n"
+	"    // set q = n x p\n"
+	"    q[0].x = a*k;\n"
+	"	q[0].y = -n.x*p[0].z;\n"
+	"	q[0].z = n.x*p[0].y;\n"
+	"  }\n"
+	"  else {\n"
+	"    // choose p in x-y plane\n"
+	"    float a = n.x*n.x + n.y*n.y;\n"
+	"    float k = 1.f/sqrt(a);\n"
+	"    p[0].x = -n.y*k;\n"
+	"	p[0].y = n.x*k;\n"
+	"	p[0].z = 0;\n"
+	"    // set q = n x p\n"
+	"    q[0].x = -n.z*p[0].y;\n"
+	"	q[0].y = n.z*p[0].x;\n"
+	"	q[0].z = a*k;\n"
+	"  }\n"
+	"}\n"
+	" \n"
+	"void setLinearAndAngular( b3Float4ConstArg n, b3Float4ConstArg r0, b3Float4ConstArg r1, b3Float4* linear, b3Float4* angular0, b3Float4* angular1)\n"
+	"{\n"
+	"	*linear = b3MakeFloat4(n.x,n.y,n.z,0.f);\n"
+	"	*angular0 = b3Cross3(r0, n);\n"
+	"	*angular1 = -b3Cross3(r1, n);\n"
+	"}\n"
+	"float calcRelVel( b3Float4ConstArg l0, b3Float4ConstArg l1, b3Float4ConstArg a0, b3Float4ConstArg a1, b3Float4ConstArg linVel0,\n"
+	"	b3Float4ConstArg angVel0, b3Float4ConstArg linVel1, b3Float4ConstArg angVel1 )\n"
+	"{\n"
+	"	return b3Dot3F4(l0, linVel0) + b3Dot3F4(a0, angVel0) + b3Dot3F4(l1, linVel1) + b3Dot3F4(a1, angVel1);\n"
+	"}\n"
+	"float calcJacCoeff(b3Float4ConstArg linear0, b3Float4ConstArg linear1, b3Float4ConstArg angular0, b3Float4ConstArg angular1,\n"
+	"					float invMass0, const b3Mat3x3* invInertia0, float invMass1, const b3Mat3x3* invInertia1)\n"
+	"{\n"
+	"	//	linear0,1 are normlized\n"
+	"	float jmj0 = invMass0;//b3Dot3F4(linear0, linear0)*invMass0;\n"
+	"	float jmj1 = b3Dot3F4(mtMul3(angular0,*invInertia0), angular0);\n"
+	"	float jmj2 = invMass1;//b3Dot3F4(linear1, linear1)*invMass1;\n"
+	"	float jmj3 = b3Dot3F4(mtMul3(angular1,*invInertia1), angular1);\n"
+	"	return -1.f/(jmj0+jmj1+jmj2+jmj3);\n"
+	"}\n"
+	"void setConstraint4( b3Float4ConstArg posA, b3Float4ConstArg linVelA, b3Float4ConstArg angVelA, float invMassA, b3Mat3x3ConstArg invInertiaA,\n"
+	"	b3Float4ConstArg posB, b3Float4ConstArg linVelB, b3Float4ConstArg angVelB, float invMassB, b3Mat3x3ConstArg invInertiaB, \n"
+	"	__global struct b3Contact4Data* src, float dt, float positionDrift, float positionConstraintCoeff,\n"
+	"	b3ContactConstraint4_t* dstC )\n"
+	"{\n"
+	"	dstC->m_bodyA = abs(src->m_bodyAPtrAndSignBit);\n"
+	"	dstC->m_bodyB = abs(src->m_bodyBPtrAndSignBit);\n"
+	"	float dtInv = 1.f/dt;\n"
+	"	for(int ic=0; ic<4; ic++)\n"
+	"	{\n"
+	"		dstC->m_appliedRambdaDt[ic] = 0.f;\n"
+	"	}\n"
+	"	dstC->m_fJacCoeffInv[0] = dstC->m_fJacCoeffInv[1] = 0.f;\n"
+	"	dstC->m_linear = src->m_worldNormalOnB;\n"
+	"	dstC->m_linear.w = 0.7f ;//src->getFrictionCoeff() );\n"
+	"	for(int ic=0; ic<4; ic++)\n"
+	"	{\n"
+	"		b3Float4 r0 = src->m_worldPosB[ic] - posA;\n"
+	"		b3Float4 r1 = src->m_worldPosB[ic] - posB;\n"
+	"		if( ic >= src->m_worldNormalOnB.w )//npoints\n"
+	"		{\n"
+	"			dstC->m_jacCoeffInv[ic] = 0.f;\n"
+	"			continue;\n"
+	"		}\n"
+	"		float relVelN;\n"
+	"		{\n"
+	"			b3Float4 linear, angular0, angular1;\n"
+	"			setLinearAndAngular(src->m_worldNormalOnB, r0, r1, &linear, &angular0, &angular1);\n"
+	"			dstC->m_jacCoeffInv[ic] = calcJacCoeff(linear, -linear, angular0, angular1,\n"
+	"				invMassA, &invInertiaA, invMassB, &invInertiaB );\n"
+	"			relVelN = calcRelVel(linear, -linear, angular0, angular1,\n"
+	"				linVelA, angVelA, linVelB, angVelB);\n"
+	"			float e = 0.f;//src->getRestituitionCoeff();\n"
+	"			if( relVelN*relVelN < 0.004f ) e = 0.f;\n"
+	"			dstC->m_b[ic] = e*relVelN;\n"
+	"			//float penetration = src->m_worldPosB[ic].w;\n"
+	"			dstC->m_b[ic] += (src->m_worldPosB[ic].w + positionDrift)*positionConstraintCoeff*dtInv;\n"
+	"			dstC->m_appliedRambdaDt[ic] = 0.f;\n"
+	"		}\n"
+	"	}\n"
+	"	if( src->m_worldNormalOnB.w > 0 )//npoints\n"
+	"	{	//	prepare friction\n"
+	"		b3Float4 center = b3MakeFloat4(0.f,0.f,0.f,0.f);\n"
+	"		for(int i=0; i<src->m_worldNormalOnB.w; i++) \n"
+	"			center += src->m_worldPosB[i];\n"
+	"		center /= (float)src->m_worldNormalOnB.w;\n"
+	"		b3Float4 tangent[2];\n"
+	"		b3PlaneSpace1(src->m_worldNormalOnB,&tangent[0],&tangent[1]);\n"
+	"		\n"
+	"		b3Float4 r[2];\n"
+	"		r[0] = center - posA;\n"
+	"		r[1] = center - posB;\n"
+	"		for(int i=0; i<2; i++)\n"
+	"		{\n"
+	"			b3Float4 linear, angular0, angular1;\n"
+	"			setLinearAndAngular(tangent[i], r[0], r[1], &linear, &angular0, &angular1);\n"
+	"			dstC->m_fJacCoeffInv[i] = calcJacCoeff(linear, -linear, angular0, angular1,\n"
+	"				invMassA, &invInertiaA, invMassB, &invInertiaB );\n"
+	"			dstC->m_fAppliedRambdaDt[i] = 0.f;\n"
+	"		}\n"
+	"		dstC->m_center = center;\n"
+	"	}\n"
+	"	for(int i=0; i<4; i++)\n"
+	"	{\n"
+	"		if( i<src->m_worldNormalOnB.w )\n"
+	"		{\n"
+	"			dstC->m_worldPos[i] = src->m_worldPosB[i];\n"
+	"		}\n"
+	"		else\n"
+	"		{\n"
+	"			dstC->m_worldPos[i] = b3MakeFloat4(0.f,0.f,0.f,0.f);\n"
+	"		}\n"
+	"	}\n"
+	"}\n"
+	"#pragma OPENCL EXTENSION cl_amd_printf : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_local_int32_base_atomics : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_global_int32_base_atomics : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_local_int32_extended_atomics : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_global_int32_extended_atomics : enable\n"
+	"#ifdef cl_ext_atomic_counters_32\n"
+	"#pragma OPENCL EXTENSION cl_ext_atomic_counters_32 : enable\n"
+	"#else\n"
+	"#define counter32_t volatile global int*\n"
+	"#endif\n"
+	"typedef unsigned int u32;\n"
+	"typedef unsigned short u16;\n"
+	"typedef unsigned char u8;\n"
+	"#define GET_GROUP_IDX get_group_id(0)\n"
+	"#define GET_LOCAL_IDX get_local_id(0)\n"
+	"#define GET_GLOBAL_IDX get_global_id(0)\n"
+	"#define GET_GROUP_SIZE get_local_size(0)\n"
+	"#define GET_NUM_GROUPS get_num_groups(0)\n"
+	"#define GROUP_LDS_BARRIER barrier(CLK_LOCAL_MEM_FENCE)\n"
+	"#define GROUP_MEM_FENCE mem_fence(CLK_LOCAL_MEM_FENCE)\n"
+	"#define AtomInc(x) atom_inc(&(x))\n"
+	"#define AtomInc1(x, out) out = atom_inc(&(x))\n"
+	"#define AppendInc(x, out) out = atomic_inc(x)\n"
+	"#define AtomAdd(x, value) atom_add(&(x), value)\n"
+	"#define AtomCmpxhg(x, cmp, value) atom_cmpxchg( &(x), cmp, value )\n"
+	"#define AtomXhg(x, value) atom_xchg ( &(x), value )\n"
+	"#define SELECT_UINT4( b, a, condition ) select( b,a,condition )\n"
+	"#define make_float4 (float4)\n"
+	"#define make_float2 (float2)\n"
+	"#define make_uint4 (uint4)\n"
+	"#define make_int4 (int4)\n"
+	"#define make_uint2 (uint2)\n"
+	"#define make_int2 (int2)\n"
+	"#define max2 max\n"
+	"#define min2 min\n"
+	"///////////////////////////////////////\n"
+	"//	Vector\n"
+	"///////////////////////////////////////\n"
+	"__inline\n"
+	"float fastDiv(float numerator, float denominator)\n"
+	"{\n"
+	"	return native_divide(numerator, denominator);	\n"
+	"//	return numerator/denominator;	\n"
+	"}\n"
+	"__inline\n"
+	"float4 fastDiv4(float4 numerator, float4 denominator)\n"
+	"{\n"
+	"	return native_divide(numerator, denominator);	\n"
+	"}\n"
+	"__inline\n"
+	"float fastSqrtf(float f2)\n"
+	"{\n"
+	"	return native_sqrt(f2);\n"
+	"//	return sqrt(f2);\n"
+	"}\n"
+	"__inline\n"
+	"float fastRSqrt(float f2)\n"
+	"{\n"
+	"	return native_rsqrt(f2);\n"
+	"}\n"
+	"__inline\n"
+	"float fastLength4(float4 v)\n"
+	"{\n"
+	"	return fast_length(v);\n"
+	"}\n"
+	"__inline\n"
+	"float4 fastNormalize4(float4 v)\n"
+	"{\n"
+	"	return fast_normalize(v);\n"
+	"}\n"
+	"__inline\n"
+	"float sqrtf(float a)\n"
+	"{\n"
+	"//	return sqrt(a);\n"
+	"	return native_sqrt(a);\n"
+	"}\n"
+	"__inline\n"
+	"float4 cross3(float4 a, float4 b)\n"
+	"{\n"
+	"	return cross(a,b);\n"
+	"}\n"
+	"__inline\n"
+	"float dot3F4(float4 a, float4 b)\n"
+	"{\n"
+	"	float4 a1 = make_float4(a.xyz,0.f);\n"
+	"	float4 b1 = make_float4(b.xyz,0.f);\n"
+	"	return dot(a1, b1);\n"
+	"}\n"
+	"__inline\n"
+	"float length3(const float4 a)\n"
+	"{\n"
+	"	return sqrtf(dot3F4(a,a));\n"
+	"}\n"
+	"__inline\n"
+	"float dot4(const float4 a, const float4 b)\n"
+	"{\n"
+	"	return dot( a, b );\n"
+	"}\n"
+	"//	for height\n"
+	"__inline\n"
+	"float dot3w1(const float4 point, const float4 eqn)\n"
+	"{\n"
+	"	return dot3F4(point,eqn) + eqn.w;\n"
+	"}\n"
+	"__inline\n"
+	"float4 normalize3(const float4 a)\n"
+	"{\n"
+	"	float4 n = make_float4(a.x, a.y, a.z, 0.f);\n"
+	"	return fastNormalize4( n );\n"
+	"//	float length = sqrtf(dot3F4(a, a));\n"
+	"//	return 1.f/length * a;\n"
+	"}\n"
+	"__inline\n"
+	"float4 normalize4(const float4 a)\n"
+	"{\n"
+	"	float length = sqrtf(dot4(a, a));\n"
+	"	return 1.f/length * a;\n"
+	"}\n"
+	"__inline\n"
+	"float4 createEquation(const float4 a, const float4 b, const float4 c)\n"
+	"{\n"
+	"	float4 eqn;\n"
+	"	float4 ab = b-a;\n"
+	"	float4 ac = c-a;\n"
+	"	eqn = normalize3( cross3(ab, ac) );\n"
+	"	eqn.w = -dot3F4(eqn,a);\n"
+	"	return eqn;\n"
+	"}\n"
+	"#define WG_SIZE 64\n"
+	"typedef struct\n"
+	"{\n"
+	"	int m_nConstraints;\n"
+	"	int m_start;\n"
+	"	int m_batchIdx;\n"
+	"	int m_nSplit;\n"
+	"//	int m_paddings[1];\n"
+	"} ConstBuffer;\n"
+	"typedef struct\n"
+	"{\n"
+	"	int m_solveFriction;\n"
+	"	int m_maxBatch;	//	long batch really kills the performance\n"
+	"	int m_batchIdx;\n"
+	"	int m_nSplit;\n"
+	"//	int m_paddings[1];\n"
+	"} ConstBufferBatchSolve;\n"
+	" \n"
+	"typedef struct \n"
+	"{\n"
+	"	int m_valInt0;\n"
+	"	int m_valInt1;\n"
+	"	int m_valInt2;\n"
+	"	int m_valInt3;\n"
+	"	float m_val0;\n"
+	"	float m_val1;\n"
+	"	float m_val2;\n"
+	"	float m_val3;\n"
+	"} SolverDebugInfo;\n"
+	"typedef struct\n"
+	"{\n"
+	"	int m_nContacts;\n"
+	"	float m_dt;\n"
+	"	float m_positionDrift;\n"
+	"	float m_positionConstraintCoeff;\n"
+	"} ConstBufferCTC;\n"
+	"__kernel\n"
+	"__attribute__((reqd_work_group_size(WG_SIZE,1,1)))\n"
+	"void ContactToConstraintKernel(__global struct b3Contact4Data* gContact, __global b3RigidBodyData_t* gBodies, __global b3InertiaData_t* gShapes, __global b3ContactConstraint4_t* gConstraintOut, \n"
+	"int nContacts,\n"
+	"float dt,\n"
+	"float positionDrift,\n"
+	"float positionConstraintCoeff\n"
+	")\n"
+	"{\n"
+	"	int gIdx = GET_GLOBAL_IDX;\n"
+	"	\n"
+	"	if( gIdx < nContacts )\n"
+	"	{\n"
+	"		int aIdx = abs(gContact[gIdx].m_bodyAPtrAndSignBit);\n"
+	"		int bIdx = abs(gContact[gIdx].m_bodyBPtrAndSignBit);\n"
+	"		float4 posA = gBodies[aIdx].m_pos;\n"
+	"		float4 linVelA = gBodies[aIdx].m_linVel;\n"
+	"		float4 angVelA = gBodies[aIdx].m_angVel;\n"
+	"		float invMassA = gBodies[aIdx].m_invMass;\n"
+	"		b3Mat3x3 invInertiaA = gShapes[aIdx].m_initInvInertia;\n"
+	"		float4 posB = gBodies[bIdx].m_pos;\n"
+	"		float4 linVelB = gBodies[bIdx].m_linVel;\n"
+	"		float4 angVelB = gBodies[bIdx].m_angVel;\n"
+	"		float invMassB = gBodies[bIdx].m_invMass;\n"
+	"		b3Mat3x3 invInertiaB = gShapes[bIdx].m_initInvInertia;\n"
+	"		b3ContactConstraint4_t cs;\n"
+	"    	setConstraint4( posA, linVelA, angVelA, invMassA, invInertiaA, posB, linVelB, angVelB, invMassB, invInertiaB,\n"
+	"			&gContact[gIdx], dt, positionDrift, positionConstraintCoeff,\n"
+	"			&cs );\n"
+	"		\n"
+	"		cs.m_batchIdx = gContact[gIdx].m_batchIdx;\n"
+	"		gConstraintOut[gIdx] = cs;\n"
+	"	}\n"
+	"}\n";
diff --git a/engine/inc/bullet/Bullet3OpenCL/RigidBody/kernels/solverSetup2.h b/engine/inc/bullet/Bullet3OpenCL/RigidBody/kernels/solverSetup2.h
new file mode 100644
index 00000000..1e6e3579
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/RigidBody/kernels/solverSetup2.h
@@ -0,0 +1,600 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* solverSetup2CL =
+	"/*\n"
+	"Copyright (c) 2012 Advanced Micro Devices, Inc.  \n"
+	"This software is provided 'as-is', without any express or implied warranty.\n"
+	"In no event will the authors be held liable for any damages arising from the use of this software.\n"
+	"Permission is granted to anyone to use this software for any purpose, \n"
+	"including commercial applications, and to alter it and redistribute it freely, \n"
+	"subject to the following restrictions:\n"
+	"1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.\n"
+	"2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.\n"
+	"3. This notice may not be removed or altered from any source distribution.\n"
+	"*/\n"
+	"//Originally written by Takahiro Harada\n"
+	"#ifndef B3_CONTACT4DATA_H\n"
+	"#define B3_CONTACT4DATA_H\n"
+	"#ifndef B3_FLOAT4_H\n"
+	"#define B3_FLOAT4_H\n"
+	"#ifndef B3_PLATFORM_DEFINITIONS_H\n"
+	"#define B3_PLATFORM_DEFINITIONS_H\n"
+	"struct MyTest\n"
+	"{\n"
+	"	int bla;\n"
+	"};\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"//keep B3_LARGE_FLOAT*B3_LARGE_FLOAT < FLT_MAX\n"
+	"#define B3_LARGE_FLOAT 1e18f\n"
+	"#define B3_INFINITY 1e18f\n"
+	"#define b3Assert(a)\n"
+	"#define b3ConstArray(a) __global const a*\n"
+	"#define b3AtomicInc atomic_inc\n"
+	"#define b3AtomicAdd atomic_add\n"
+	"#define b3Fabs fabs\n"
+	"#define b3Sqrt native_sqrt\n"
+	"#define b3Sin native_sin\n"
+	"#define b3Cos native_cos\n"
+	"#define B3_STATIC\n"
+	"#endif\n"
+	"#endif\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"	typedef float4	b3Float4;\n"
+	"	#define b3Float4ConstArg const b3Float4\n"
+	"	#define b3MakeFloat4 (float4)\n"
+	"	float b3Dot3F4(b3Float4ConstArg v0,b3Float4ConstArg v1)\n"
+	"	{\n"
+	"		float4 a1 = b3MakeFloat4(v0.xyz,0.f);\n"
+	"		float4 b1 = b3MakeFloat4(v1.xyz,0.f);\n"
+	"		return dot(a1, b1);\n"
+	"	}\n"
+	"	b3Float4 b3Cross3(b3Float4ConstArg v0,b3Float4ConstArg v1)\n"
+	"	{\n"
+	"		float4 a1 = b3MakeFloat4(v0.xyz,0.f);\n"
+	"		float4 b1 = b3MakeFloat4(v1.xyz,0.f);\n"
+	"		return cross(a1, b1);\n"
+	"	}\n"
+	"	#define b3MinFloat4 min\n"
+	"	#define b3MaxFloat4 max\n"
+	"	#define b3Normalized(a) normalize(a)\n"
+	"#endif \n"
+	"		\n"
+	"inline bool b3IsAlmostZero(b3Float4ConstArg v)\n"
+	"{\n"
+	"	if(b3Fabs(v.x)>1e-6 || b3Fabs(v.y)>1e-6 || b3Fabs(v.z)>1e-6)	\n"
+	"		return false;\n"
+	"	return true;\n"
+	"}\n"
+	"inline int    b3MaxDot( b3Float4ConstArg vec, __global const b3Float4* vecArray, int vecLen, float* dotOut )\n"
+	"{\n"
+	"    float maxDot = -B3_INFINITY;\n"
+	"    int i = 0;\n"
+	"    int ptIndex = -1;\n"
+	"    for( i = 0; i < vecLen; i++ )\n"
+	"    {\n"
+	"        float dot = b3Dot3F4(vecArray[i],vec);\n"
+	"            \n"
+	"        if( dot > maxDot )\n"
+	"        {\n"
+	"            maxDot = dot;\n"
+	"            ptIndex = i;\n"
+	"        }\n"
+	"    }\n"
+	"	b3Assert(ptIndex>=0);\n"
+	"    if (ptIndex<0)\n"
+	"	{\n"
+	"		ptIndex = 0;\n"
+	"	}\n"
+	"    *dotOut = maxDot;\n"
+	"    return ptIndex;\n"
+	"}\n"
+	"#endif //B3_FLOAT4_H\n"
+	"typedef  struct b3Contact4Data b3Contact4Data_t;\n"
+	"struct b3Contact4Data\n"
+	"{\n"
+	"	b3Float4	m_worldPosB[4];\n"
+	"//	b3Float4	m_localPosA[4];\n"
+	"//	b3Float4	m_localPosB[4];\n"
+	"	b3Float4	m_worldNormalOnB;	//	w: m_nPoints\n"
+	"	unsigned short  m_restituitionCoeffCmp;\n"
+	"	unsigned short  m_frictionCoeffCmp;\n"
+	"	int m_batchIdx;\n"
+	"	int m_bodyAPtrAndSignBit;//x:m_bodyAPtr, y:m_bodyBPtr\n"
+	"	int m_bodyBPtrAndSignBit;\n"
+	"	int	m_childIndexA;\n"
+	"	int	m_childIndexB;\n"
+	"	int m_unused1;\n"
+	"	int m_unused2;\n"
+	"};\n"
+	"inline int b3Contact4Data_getNumPoints(const struct b3Contact4Data* contact)\n"
+	"{\n"
+	"	return (int)contact->m_worldNormalOnB.w;\n"
+	"};\n"
+	"inline void b3Contact4Data_setNumPoints(struct b3Contact4Data* contact, int numPoints)\n"
+	"{\n"
+	"	contact->m_worldNormalOnB.w = (float)numPoints;\n"
+	"};\n"
+	"#endif //B3_CONTACT4DATA_H\n"
+	"#pragma OPENCL EXTENSION cl_amd_printf : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_local_int32_base_atomics : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_global_int32_base_atomics : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_local_int32_extended_atomics : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_global_int32_extended_atomics : enable\n"
+	"#ifdef cl_ext_atomic_counters_32\n"
+	"#pragma OPENCL EXTENSION cl_ext_atomic_counters_32 : enable\n"
+	"#else\n"
+	"#define counter32_t volatile global int*\n"
+	"#endif\n"
+	"typedef unsigned int u32;\n"
+	"typedef unsigned short u16;\n"
+	"typedef unsigned char u8;\n"
+	"#define GET_GROUP_IDX get_group_id(0)\n"
+	"#define GET_LOCAL_IDX get_local_id(0)\n"
+	"#define GET_GLOBAL_IDX get_global_id(0)\n"
+	"#define GET_GROUP_SIZE get_local_size(0)\n"
+	"#define GET_NUM_GROUPS get_num_groups(0)\n"
+	"#define GROUP_LDS_BARRIER barrier(CLK_LOCAL_MEM_FENCE)\n"
+	"#define GROUP_MEM_FENCE mem_fence(CLK_LOCAL_MEM_FENCE)\n"
+	"#define AtomInc(x) atom_inc(&(x))\n"
+	"#define AtomInc1(x, out) out = atom_inc(&(x))\n"
+	"#define AppendInc(x, out) out = atomic_inc(x)\n"
+	"#define AtomAdd(x, value) atom_add(&(x), value)\n"
+	"#define AtomCmpxhg(x, cmp, value) atom_cmpxchg( &(x), cmp, value )\n"
+	"#define AtomXhg(x, value) atom_xchg ( &(x), value )\n"
+	"#define SELECT_UINT4( b, a, condition ) select( b,a,condition )\n"
+	"#define make_float4 (float4)\n"
+	"#define make_float2 (float2)\n"
+	"#define make_uint4 (uint4)\n"
+	"#define make_int4 (int4)\n"
+	"#define make_uint2 (uint2)\n"
+	"#define make_int2 (int2)\n"
+	"#define max2 max\n"
+	"#define min2 min\n"
+	"///////////////////////////////////////\n"
+	"//	Vector\n"
+	"///////////////////////////////////////\n"
+	"__inline\n"
+	"float fastDiv(float numerator, float denominator)\n"
+	"{\n"
+	"	return native_divide(numerator, denominator);	\n"
+	"//	return numerator/denominator;	\n"
+	"}\n"
+	"__inline\n"
+	"float4 fastDiv4(float4 numerator, float4 denominator)\n"
+	"{\n"
+	"	return native_divide(numerator, denominator);	\n"
+	"}\n"
+	"__inline\n"
+	"float fastSqrtf(float f2)\n"
+	"{\n"
+	"	return native_sqrt(f2);\n"
+	"//	return sqrt(f2);\n"
+	"}\n"
+	"__inline\n"
+	"float fastRSqrt(float f2)\n"
+	"{\n"
+	"	return native_rsqrt(f2);\n"
+	"}\n"
+	"__inline\n"
+	"float fastLength4(float4 v)\n"
+	"{\n"
+	"	return fast_length(v);\n"
+	"}\n"
+	"__inline\n"
+	"float4 fastNormalize4(float4 v)\n"
+	"{\n"
+	"	return fast_normalize(v);\n"
+	"}\n"
+	"__inline\n"
+	"float sqrtf(float a)\n"
+	"{\n"
+	"//	return sqrt(a);\n"
+	"	return native_sqrt(a);\n"
+	"}\n"
+	"__inline\n"
+	"float4 cross3(float4 a, float4 b)\n"
+	"{\n"
+	"	return cross(a,b);\n"
+	"}\n"
+	"__inline\n"
+	"float dot3F4(float4 a, float4 b)\n"
+	"{\n"
+	"	float4 a1 = make_float4(a.xyz,0.f);\n"
+	"	float4 b1 = make_float4(b.xyz,0.f);\n"
+	"	return dot(a1, b1);\n"
+	"}\n"
+	"__inline\n"
+	"float length3(const float4 a)\n"
+	"{\n"
+	"	return sqrtf(dot3F4(a,a));\n"
+	"}\n"
+	"__inline\n"
+	"float dot4(const float4 a, const float4 b)\n"
+	"{\n"
+	"	return dot( a, b );\n"
+	"}\n"
+	"//	for height\n"
+	"__inline\n"
+	"float dot3w1(const float4 point, const float4 eqn)\n"
+	"{\n"
+	"	return dot3F4(point,eqn) + eqn.w;\n"
+	"}\n"
+	"__inline\n"
+	"float4 normalize3(const float4 a)\n"
+	"{\n"
+	"	float4 n = make_float4(a.x, a.y, a.z, 0.f);\n"
+	"	return fastNormalize4( n );\n"
+	"//	float length = sqrtf(dot3F4(a, a));\n"
+	"//	return 1.f/length * a;\n"
+	"}\n"
+	"__inline\n"
+	"float4 normalize4(const float4 a)\n"
+	"{\n"
+	"	float length = sqrtf(dot4(a, a));\n"
+	"	return 1.f/length * a;\n"
+	"}\n"
+	"__inline\n"
+	"float4 createEquation(const float4 a, const float4 b, const float4 c)\n"
+	"{\n"
+	"	float4 eqn;\n"
+	"	float4 ab = b-a;\n"
+	"	float4 ac = c-a;\n"
+	"	eqn = normalize3( cross3(ab, ac) );\n"
+	"	eqn.w = -dot3F4(eqn,a);\n"
+	"	return eqn;\n"
+	"}\n"
+	"///////////////////////////////////////\n"
+	"//	Matrix3x3\n"
+	"///////////////////////////////////////\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4 m_row[3];\n"
+	"}Matrix3x3;\n"
+	"__inline\n"
+	"Matrix3x3 mtZero();\n"
+	"__inline\n"
+	"Matrix3x3 mtIdentity();\n"
+	"__inline\n"
+	"Matrix3x3 mtTranspose(Matrix3x3 m);\n"
+	"__inline\n"
+	"Matrix3x3 mtMul(Matrix3x3 a, Matrix3x3 b);\n"
+	"__inline\n"
+	"float4 mtMul1(Matrix3x3 a, float4 b);\n"
+	"__inline\n"
+	"float4 mtMul3(float4 a, Matrix3x3 b);\n"
+	"__inline\n"
+	"Matrix3x3 mtZero()\n"
+	"{\n"
+	"	Matrix3x3 m;\n"
+	"	m.m_row[0] = (float4)(0.f);\n"
+	"	m.m_row[1] = (float4)(0.f);\n"
+	"	m.m_row[2] = (float4)(0.f);\n"
+	"	return m;\n"
+	"}\n"
+	"__inline\n"
+	"Matrix3x3 mtIdentity()\n"
+	"{\n"
+	"	Matrix3x3 m;\n"
+	"	m.m_row[0] = (float4)(1,0,0,0);\n"
+	"	m.m_row[1] = (float4)(0,1,0,0);\n"
+	"	m.m_row[2] = (float4)(0,0,1,0);\n"
+	"	return m;\n"
+	"}\n"
+	"__inline\n"
+	"Matrix3x3 mtTranspose(Matrix3x3 m)\n"
+	"{\n"
+	"	Matrix3x3 out;\n"
+	"	out.m_row[0] = (float4)(m.m_row[0].x, m.m_row[1].x, m.m_row[2].x, 0.f);\n"
+	"	out.m_row[1] = (float4)(m.m_row[0].y, m.m_row[1].y, m.m_row[2].y, 0.f);\n"
+	"	out.m_row[2] = (float4)(m.m_row[0].z, m.m_row[1].z, m.m_row[2].z, 0.f);\n"
+	"	return out;\n"
+	"}\n"
+	"__inline\n"
+	"Matrix3x3 mtMul(Matrix3x3 a, Matrix3x3 b)\n"
+	"{\n"
+	"	Matrix3x3 transB;\n"
+	"	transB = mtTranspose( b );\n"
+	"	Matrix3x3 ans;\n"
+	"	//	why this doesn't run when 0ing in the for{}\n"
+	"	a.m_row[0].w = 0.f;\n"
+	"	a.m_row[1].w = 0.f;\n"
+	"	a.m_row[2].w = 0.f;\n"
+	"	for(int i=0; i<3; i++)\n"
+	"	{\n"
+	"//	a.m_row[i].w = 0.f;\n"
+	"		ans.m_row[i].x = dot3F4(a.m_row[i],transB.m_row[0]);\n"
+	"		ans.m_row[i].y = dot3F4(a.m_row[i],transB.m_row[1]);\n"
+	"		ans.m_row[i].z = dot3F4(a.m_row[i],transB.m_row[2]);\n"
+	"		ans.m_row[i].w = 0.f;\n"
+	"	}\n"
+	"	return ans;\n"
+	"}\n"
+	"__inline\n"
+	"float4 mtMul1(Matrix3x3 a, float4 b)\n"
+	"{\n"
+	"	float4 ans;\n"
+	"	ans.x = dot3F4( a.m_row[0], b );\n"
+	"	ans.y = dot3F4( a.m_row[1], b );\n"
+	"	ans.z = dot3F4( a.m_row[2], b );\n"
+	"	ans.w = 0.f;\n"
+	"	return ans;\n"
+	"}\n"
+	"__inline\n"
+	"float4 mtMul3(float4 a, Matrix3x3 b)\n"
+	"{\n"
+	"	float4 colx = make_float4(b.m_row[0].x, b.m_row[1].x, b.m_row[2].x, 0);\n"
+	"	float4 coly = make_float4(b.m_row[0].y, b.m_row[1].y, b.m_row[2].y, 0);\n"
+	"	float4 colz = make_float4(b.m_row[0].z, b.m_row[1].z, b.m_row[2].z, 0);\n"
+	"	float4 ans;\n"
+	"	ans.x = dot3F4( a, colx );\n"
+	"	ans.y = dot3F4( a, coly );\n"
+	"	ans.z = dot3F4( a, colz );\n"
+	"	return ans;\n"
+	"}\n"
+	"///////////////////////////////////////\n"
+	"//	Quaternion\n"
+	"///////////////////////////////////////\n"
+	"typedef float4 Quaternion;\n"
+	"__inline\n"
+	"Quaternion qtMul(Quaternion a, Quaternion b);\n"
+	"__inline\n"
+	"Quaternion qtNormalize(Quaternion in);\n"
+	"__inline\n"
+	"float4 qtRotate(Quaternion q, float4 vec);\n"
+	"__inline\n"
+	"Quaternion qtInvert(Quaternion q);\n"
+	"__inline\n"
+	"Quaternion qtMul(Quaternion a, Quaternion b)\n"
+	"{\n"
+	"	Quaternion ans;\n"
+	"	ans = cross3( a, b );\n"
+	"	ans += a.w*b+b.w*a;\n"
+	"//	ans.w = a.w*b.w - (a.x*b.x+a.y*b.y+a.z*b.z);\n"
+	"	ans.w = a.w*b.w - dot3F4(a, b);\n"
+	"	return ans;\n"
+	"}\n"
+	"__inline\n"
+	"Quaternion qtNormalize(Quaternion in)\n"
+	"{\n"
+	"	return fastNormalize4(in);\n"
+	"//	in /= length( in );\n"
+	"//	return in;\n"
+	"}\n"
+	"__inline\n"
+	"float4 qtRotate(Quaternion q, float4 vec)\n"
+	"{\n"
+	"	Quaternion qInv = qtInvert( q );\n"
+	"	float4 vcpy = vec;\n"
+	"	vcpy.w = 0.f;\n"
+	"	float4 out = qtMul(qtMul(q,vcpy),qInv);\n"
+	"	return out;\n"
+	"}\n"
+	"__inline\n"
+	"Quaternion qtInvert(Quaternion q)\n"
+	"{\n"
+	"	return (Quaternion)(-q.xyz, q.w);\n"
+	"}\n"
+	"__inline\n"
+	"float4 qtInvRotate(const Quaternion q, float4 vec)\n"
+	"{\n"
+	"	return qtRotate( qtInvert( q ), vec );\n"
+	"}\n"
+	"#define WG_SIZE 64\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4 m_pos;\n"
+	"	Quaternion m_quat;\n"
+	"	float4 m_linVel;\n"
+	"	float4 m_angVel;\n"
+	"	u32 m_shapeIdx;\n"
+	"	float m_invMass;\n"
+	"	float m_restituitionCoeff;\n"
+	"	float m_frictionCoeff;\n"
+	"} Body;\n"
+	"typedef struct\n"
+	"{\n"
+	"	Matrix3x3 m_invInertia;\n"
+	"	Matrix3x3 m_initInvInertia;\n"
+	"} Shape;\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4 m_linear;\n"
+	"	float4 m_worldPos[4];\n"
+	"	float4 m_center;	\n"
+	"	float m_jacCoeffInv[4];\n"
+	"	float m_b[4];\n"
+	"	float m_appliedRambdaDt[4];\n"
+	"	float m_fJacCoeffInv[2];	\n"
+	"	float m_fAppliedRambdaDt[2];	\n"
+	"	u32 m_bodyA;\n"
+	"	u32 m_bodyB;\n"
+	"	int m_batchIdx;\n"
+	"	u32 m_paddings[1];\n"
+	"} Constraint4;\n"
+	"typedef struct\n"
+	"{\n"
+	"	int m_nConstraints;\n"
+	"	int m_start;\n"
+	"	int m_batchIdx;\n"
+	"	int m_nSplit;\n"
+	"//	int m_paddings[1];\n"
+	"} ConstBuffer;\n"
+	"typedef struct\n"
+	"{\n"
+	"	int m_solveFriction;\n"
+	"	int m_maxBatch;	//	long batch really kills the performance\n"
+	"	int m_batchIdx;\n"
+	"	int m_nSplit;\n"
+	"//	int m_paddings[1];\n"
+	"} ConstBufferBatchSolve;\n"
+	" \n"
+	"typedef struct \n"
+	"{\n"
+	"	int m_valInt0;\n"
+	"	int m_valInt1;\n"
+	"	int m_valInt2;\n"
+	"	int m_valInt3;\n"
+	"	float m_val0;\n"
+	"	float m_val1;\n"
+	"	float m_val2;\n"
+	"	float m_val3;\n"
+	"} SolverDebugInfo;\n"
+	"//	others\n"
+	"__kernel\n"
+	"__attribute__((reqd_work_group_size(WG_SIZE,1,1)))\n"
+	"void ReorderContactKernel(__global struct b3Contact4Data* in, __global struct b3Contact4Data* out, __global int2* sortData, int4 cb )\n"
+	"{\n"
+	"	int nContacts = cb.x;\n"
+	"	int gIdx = GET_GLOBAL_IDX;\n"
+	"	if( gIdx < nContacts )\n"
+	"	{\n"
+	"		int srcIdx = sortData[gIdx].y;\n"
+	"		out[gIdx] = in[srcIdx];\n"
+	"	}\n"
+	"}\n"
+	"__kernel __attribute__((reqd_work_group_size(WG_SIZE,1,1)))\n"
+	"void SetDeterminismSortDataChildShapeB(__global struct b3Contact4Data* contactsIn, __global int2* sortDataOut, int nContacts)\n"
+	"{\n"
+	"	int gIdx = GET_GLOBAL_IDX;\n"
+	"	if( gIdx < nContacts )\n"
+	"	{\n"
+	"		int2 sd;\n"
+	"		sd.x = contactsIn[gIdx].m_childIndexB;\n"
+	"		sd.y = gIdx;\n"
+	"		sortDataOut[gIdx] = sd;\n"
+	"	}\n"
+	"}\n"
+	"__kernel __attribute__((reqd_work_group_size(WG_SIZE,1,1)))\n"
+	"void SetDeterminismSortDataChildShapeA(__global struct b3Contact4Data* contactsIn, __global int2* sortDataInOut, int nContacts)\n"
+	"{\n"
+	"	int gIdx = GET_GLOBAL_IDX;\n"
+	"	if( gIdx < nContacts )\n"
+	"	{\n"
+	"		int2 sdIn;\n"
+	"		sdIn = sortDataInOut[gIdx];\n"
+	"		int2 sdOut;\n"
+	"		sdOut.x = contactsIn[sdIn.y].m_childIndexA;\n"
+	"		sdOut.y = sdIn.y;\n"
+	"		sortDataInOut[gIdx] = sdOut;\n"
+	"	}\n"
+	"}\n"
+	"__kernel __attribute__((reqd_work_group_size(WG_SIZE,1,1)))\n"
+	"void SetDeterminismSortDataBodyA(__global struct b3Contact4Data* contactsIn, __global int2* sortDataInOut, int nContacts)\n"
+	"{\n"
+	"	int gIdx = GET_GLOBAL_IDX;\n"
+	"	if( gIdx < nContacts )\n"
+	"	{\n"
+	"		int2 sdIn;\n"
+	"		sdIn = sortDataInOut[gIdx];\n"
+	"		int2 sdOut;\n"
+	"		sdOut.x = contactsIn[sdIn.y].m_bodyAPtrAndSignBit;\n"
+	"		sdOut.y = sdIn.y;\n"
+	"		sortDataInOut[gIdx] = sdOut;\n"
+	"	}\n"
+	"}\n"
+	"__kernel\n"
+	"__attribute__((reqd_work_group_size(WG_SIZE,1,1)))\n"
+	"void SetDeterminismSortDataBodyB(__global struct b3Contact4Data* contactsIn, __global int2* sortDataInOut, int nContacts)\n"
+	"{\n"
+	"	int gIdx = GET_GLOBAL_IDX;\n"
+	"	if( gIdx < nContacts )\n"
+	"	{\n"
+	"		int2 sdIn;\n"
+	"		sdIn = sortDataInOut[gIdx];\n"
+	"		int2 sdOut;\n"
+	"		sdOut.x = contactsIn[sdIn.y].m_bodyBPtrAndSignBit;\n"
+	"		sdOut.y = sdIn.y;\n"
+	"		sortDataInOut[gIdx] = sdOut;\n"
+	"	}\n"
+	"}\n"
+	"typedef struct\n"
+	"{\n"
+	"	int m_nContacts;\n"
+	"	int m_staticIdx;\n"
+	"	float m_scale;\n"
+	"	int m_nSplit;\n"
+	"} ConstBufferSSD;\n"
+	"__constant const int gridTable4x4[] = \n"
+	"{\n"
+	"    0,1,17,16,\n"
+	"	1,2,18,19,\n"
+	"	17,18,32,3,\n"
+	"	16,19,3,34\n"
+	"};\n"
+	"__constant const int gridTable8x8[] = \n"
+	"{\n"
+	"	  0,  2,  3, 16, 17, 18, 19,  1,\n"
+	"	 66, 64, 80, 67, 82, 81, 65, 83,\n"
+	"	131,144,128,130,147,129,145,146,\n"
+	"	208,195,194,192,193,211,210,209,\n"
+	"	 21, 22, 23,  5,  4,  6,  7, 20,\n"
+	"	 86, 85, 69, 87, 70, 68, 84, 71,\n"
+	"	151,133,149,150,135,148,132,134,\n"
+	"	197,27,214,213,212,199,198,196\n"
+	"	\n"
+	"};\n"
+	"#define USE_SPATIAL_BATCHING 1\n"
+	"#define USE_4x4_GRID 1\n"
+	"__kernel\n"
+	"__attribute__((reqd_work_group_size(WG_SIZE,1,1)))\n"
+	"void SetSortDataKernel(__global struct b3Contact4Data* gContact, __global Body* gBodies, __global int2* gSortDataOut, \n"
+	"int nContacts,float scale,int4 nSplit,int staticIdx)\n"
+	"{\n"
+	"	int gIdx = GET_GLOBAL_IDX;\n"
+	"	\n"
+	"	if( gIdx < nContacts )\n"
+	"	{\n"
+	"		int aPtrAndSignBit  = gContact[gIdx].m_bodyAPtrAndSignBit;\n"
+	"		int bPtrAndSignBit  = gContact[gIdx].m_bodyBPtrAndSignBit;\n"
+	"		int aIdx = abs(aPtrAndSignBit );\n"
+	"		int bIdx = abs(bPtrAndSignBit);\n"
+	"		bool aStatic = (aPtrAndSignBit<0) ||(aPtrAndSignBit==staticIdx);\n"
+	"		bool bStatic = (bPtrAndSignBit<0) ||(bPtrAndSignBit==staticIdx);\n"
+	"#if USE_SPATIAL_BATCHING		\n"
+	"		int idx = (aStatic)? bIdx: aIdx;\n"
+	"		float4 p = gBodies[idx].m_pos;\n"
+	"		int xIdx = (int)((p.x-((p.x<0.f)?1.f:0.f))*scale) & (nSplit.x-1);\n"
+	"		int yIdx = (int)((p.y-((p.y<0.f)?1.f:0.f))*scale) & (nSplit.y-1);\n"
+	"		int zIdx = (int)((p.z-((p.z<0.f)?1.f:0.f))*scale) & (nSplit.z-1);\n"
+	"		int newIndex = (xIdx+yIdx*nSplit.x+zIdx*nSplit.x*nSplit.y);\n"
+	"		\n"
+	"#else//USE_SPATIAL_BATCHING\n"
+	"	#if USE_4x4_GRID\n"
+	"		int aa = aIdx&3;\n"
+	"		int bb = bIdx&3;\n"
+	"		if (aStatic)\n"
+	"			aa = bb;\n"
+	"		if (bStatic)\n"
+	"			bb = aa;\n"
+	"		int gridIndex = aa + bb*4;\n"
+	"		int newIndex = gridTable4x4[gridIndex];\n"
+	"	#else//USE_4x4_GRID\n"
+	"		int aa = aIdx&7;\n"
+	"		int bb = bIdx&7;\n"
+	"		if (aStatic)\n"
+	"			aa = bb;\n"
+	"		if (bStatic)\n"
+	"			bb = aa;\n"
+	"		int gridIndex = aa + bb*8;\n"
+	"		int newIndex = gridTable8x8[gridIndex];\n"
+	"	#endif//USE_4x4_GRID\n"
+	"#endif//USE_SPATIAL_BATCHING\n"
+	"		gSortDataOut[gIdx].x = newIndex;\n"
+	"		gSortDataOut[gIdx].y = gIdx;\n"
+	"	}\n"
+	"	else\n"
+	"	{\n"
+	"		gSortDataOut[gIdx].x = 0xffffffff;\n"
+	"	}\n"
+	"}\n"
+	"__kernel\n"
+	"__attribute__((reqd_work_group_size(WG_SIZE,1,1)))\n"
+	"void CopyConstraintKernel(__global struct b3Contact4Data* gIn, __global struct b3Contact4Data* gOut, int4 cb )\n"
+	"{\n"
+	"	int gIdx = GET_GLOBAL_IDX;\n"
+	"	if( gIdx < cb.x )\n"
+	"	{\n"
+	"		gOut[gIdx] = gIn[gIdx];\n"
+	"	}\n"
+	"}\n";
diff --git a/engine/inc/bullet/Bullet3OpenCL/RigidBody/kernels/solverUtils.h b/engine/inc/bullet/Bullet3OpenCL/RigidBody/kernels/solverUtils.h
new file mode 100644
index 00000000..f4d98d99
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/RigidBody/kernels/solverUtils.h
@@ -0,0 +1,908 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* solverUtilsCL =
+	"/*\n"
+	"Copyright (c) 2013 Advanced Micro Devices, Inc.  \n"
+	"This software is provided 'as-is', without any express or implied warranty.\n"
+	"In no event will the authors be held liable for any damages arising from the use of this software.\n"
+	"Permission is granted to anyone to use this software for any purpose, \n"
+	"including commercial applications, and to alter it and redistribute it freely, \n"
+	"subject to the following restrictions:\n"
+	"1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.\n"
+	"2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.\n"
+	"3. This notice may not be removed or altered from any source distribution.\n"
+	"*/\n"
+	"//Originally written by Erwin Coumans\n"
+	"#ifndef B3_CONTACT4DATA_H\n"
+	"#define B3_CONTACT4DATA_H\n"
+	"#ifndef B3_FLOAT4_H\n"
+	"#define B3_FLOAT4_H\n"
+	"#ifndef B3_PLATFORM_DEFINITIONS_H\n"
+	"#define B3_PLATFORM_DEFINITIONS_H\n"
+	"struct MyTest\n"
+	"{\n"
+	"	int bla;\n"
+	"};\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"//keep B3_LARGE_FLOAT*B3_LARGE_FLOAT < FLT_MAX\n"
+	"#define B3_LARGE_FLOAT 1e18f\n"
+	"#define B3_INFINITY 1e18f\n"
+	"#define b3Assert(a)\n"
+	"#define b3ConstArray(a) __global const a*\n"
+	"#define b3AtomicInc atomic_inc\n"
+	"#define b3AtomicAdd atomic_add\n"
+	"#define b3Fabs fabs\n"
+	"#define b3Sqrt native_sqrt\n"
+	"#define b3Sin native_sin\n"
+	"#define b3Cos native_cos\n"
+	"#define B3_STATIC\n"
+	"#endif\n"
+	"#endif\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"	typedef float4	b3Float4;\n"
+	"	#define b3Float4ConstArg const b3Float4\n"
+	"	#define b3MakeFloat4 (float4)\n"
+	"	float b3Dot3F4(b3Float4ConstArg v0,b3Float4ConstArg v1)\n"
+	"	{\n"
+	"		float4 a1 = b3MakeFloat4(v0.xyz,0.f);\n"
+	"		float4 b1 = b3MakeFloat4(v1.xyz,0.f);\n"
+	"		return dot(a1, b1);\n"
+	"	}\n"
+	"	b3Float4 b3Cross3(b3Float4ConstArg v0,b3Float4ConstArg v1)\n"
+	"	{\n"
+	"		float4 a1 = b3MakeFloat4(v0.xyz,0.f);\n"
+	"		float4 b1 = b3MakeFloat4(v1.xyz,0.f);\n"
+	"		return cross(a1, b1);\n"
+	"	}\n"
+	"	#define b3MinFloat4 min\n"
+	"	#define b3MaxFloat4 max\n"
+	"	#define b3Normalized(a) normalize(a)\n"
+	"#endif \n"
+	"		\n"
+	"inline bool b3IsAlmostZero(b3Float4ConstArg v)\n"
+	"{\n"
+	"	if(b3Fabs(v.x)>1e-6 || b3Fabs(v.y)>1e-6 || b3Fabs(v.z)>1e-6)	\n"
+	"		return false;\n"
+	"	return true;\n"
+	"}\n"
+	"inline int    b3MaxDot( b3Float4ConstArg vec, __global const b3Float4* vecArray, int vecLen, float* dotOut )\n"
+	"{\n"
+	"    float maxDot = -B3_INFINITY;\n"
+	"    int i = 0;\n"
+	"    int ptIndex = -1;\n"
+	"    for( i = 0; i < vecLen; i++ )\n"
+	"    {\n"
+	"        float dot = b3Dot3F4(vecArray[i],vec);\n"
+	"            \n"
+	"        if( dot > maxDot )\n"
+	"        {\n"
+	"            maxDot = dot;\n"
+	"            ptIndex = i;\n"
+	"        }\n"
+	"    }\n"
+	"	b3Assert(ptIndex>=0);\n"
+	"    if (ptIndex<0)\n"
+	"	{\n"
+	"		ptIndex = 0;\n"
+	"	}\n"
+	"    *dotOut = maxDot;\n"
+	"    return ptIndex;\n"
+	"}\n"
+	"#endif //B3_FLOAT4_H\n"
+	"typedef  struct b3Contact4Data b3Contact4Data_t;\n"
+	"struct b3Contact4Data\n"
+	"{\n"
+	"	b3Float4	m_worldPosB[4];\n"
+	"//	b3Float4	m_localPosA[4];\n"
+	"//	b3Float4	m_localPosB[4];\n"
+	"	b3Float4	m_worldNormalOnB;	//	w: m_nPoints\n"
+	"	unsigned short  m_restituitionCoeffCmp;\n"
+	"	unsigned short  m_frictionCoeffCmp;\n"
+	"	int m_batchIdx;\n"
+	"	int m_bodyAPtrAndSignBit;//x:m_bodyAPtr, y:m_bodyBPtr\n"
+	"	int m_bodyBPtrAndSignBit;\n"
+	"	int	m_childIndexA;\n"
+	"	int	m_childIndexB;\n"
+	"	int m_unused1;\n"
+	"	int m_unused2;\n"
+	"};\n"
+	"inline int b3Contact4Data_getNumPoints(const struct b3Contact4Data* contact)\n"
+	"{\n"
+	"	return (int)contact->m_worldNormalOnB.w;\n"
+	"};\n"
+	"inline void b3Contact4Data_setNumPoints(struct b3Contact4Data* contact, int numPoints)\n"
+	"{\n"
+	"	contact->m_worldNormalOnB.w = (float)numPoints;\n"
+	"};\n"
+	"#endif //B3_CONTACT4DATA_H\n"
+	"#pragma OPENCL EXTENSION cl_amd_printf : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_local_int32_base_atomics : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_global_int32_base_atomics : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_local_int32_extended_atomics : enable\n"
+	"#pragma OPENCL EXTENSION cl_khr_global_int32_extended_atomics : enable\n"
+	"#ifdef cl_ext_atomic_counters_32\n"
+	"#pragma OPENCL EXTENSION cl_ext_atomic_counters_32 : enable\n"
+	"#else\n"
+	"#define counter32_t volatile global int*\n"
+	"#endif\n"
+	"typedef unsigned int u32;\n"
+	"typedef unsigned short u16;\n"
+	"typedef unsigned char u8;\n"
+	"#define GET_GROUP_IDX get_group_id(0)\n"
+	"#define GET_LOCAL_IDX get_local_id(0)\n"
+	"#define GET_GLOBAL_IDX get_global_id(0)\n"
+	"#define GET_GROUP_SIZE get_local_size(0)\n"
+	"#define GET_NUM_GROUPS get_num_groups(0)\n"
+	"#define GROUP_LDS_BARRIER barrier(CLK_LOCAL_MEM_FENCE)\n"
+	"#define GROUP_MEM_FENCE mem_fence(CLK_LOCAL_MEM_FENCE)\n"
+	"#define AtomInc(x) atom_inc(&(x))\n"
+	"#define AtomInc1(x, out) out = atom_inc(&(x))\n"
+	"#define AppendInc(x, out) out = atomic_inc(x)\n"
+	"#define AtomAdd(x, value) atom_add(&(x), value)\n"
+	"#define AtomCmpxhg(x, cmp, value) atom_cmpxchg( &(x), cmp, value )\n"
+	"#define AtomXhg(x, value) atom_xchg ( &(x), value )\n"
+	"#define SELECT_UINT4( b, a, condition ) select( b,a,condition )\n"
+	"#define make_float4 (float4)\n"
+	"#define make_float2 (float2)\n"
+	"#define make_uint4 (uint4)\n"
+	"#define make_int4 (int4)\n"
+	"#define make_uint2 (uint2)\n"
+	"#define make_int2 (int2)\n"
+	"#define max2 max\n"
+	"#define min2 min\n"
+	"///////////////////////////////////////\n"
+	"//	Vector\n"
+	"///////////////////////////////////////\n"
+	"__inline\n"
+	"float fastDiv(float numerator, float denominator)\n"
+	"{\n"
+	"	return native_divide(numerator, denominator);	\n"
+	"//	return numerator/denominator;	\n"
+	"}\n"
+	"__inline\n"
+	"float4 fastDiv4(float4 numerator, float4 denominator)\n"
+	"{\n"
+	"	return native_divide(numerator, denominator);	\n"
+	"}\n"
+	"__inline\n"
+	"float fastSqrtf(float f2)\n"
+	"{\n"
+	"	return native_sqrt(f2);\n"
+	"//	return sqrt(f2);\n"
+	"}\n"
+	"__inline\n"
+	"float fastRSqrt(float f2)\n"
+	"{\n"
+	"	return native_rsqrt(f2);\n"
+	"}\n"
+	"__inline\n"
+	"float fastLength4(float4 v)\n"
+	"{\n"
+	"	return fast_length(v);\n"
+	"}\n"
+	"__inline\n"
+	"float4 fastNormalize4(float4 v)\n"
+	"{\n"
+	"	return fast_normalize(v);\n"
+	"}\n"
+	"__inline\n"
+	"float sqrtf(float a)\n"
+	"{\n"
+	"//	return sqrt(a);\n"
+	"	return native_sqrt(a);\n"
+	"}\n"
+	"__inline\n"
+	"float4 cross3(float4 a1, float4 b1)\n"
+	"{\n"
+	"	float4 	a=make_float4(a1.xyz,0.f);\n"
+	"	float4 	b=make_float4(b1.xyz,0.f);\n"
+	"	//float4 	a=a1;\n"
+	"	//float4 	b=b1;\n"
+	"	return cross(a,b);\n"
+	"}\n"
+	"__inline\n"
+	"float dot3F4(float4 a, float4 b)\n"
+	"{\n"
+	"	float4 a1 = make_float4(a.xyz,0.f);\n"
+	"	float4 b1 = make_float4(b.xyz,0.f);\n"
+	"	return dot(a1, b1);\n"
+	"}\n"
+	"__inline\n"
+	"float length3(const float4 a)\n"
+	"{\n"
+	"	return sqrtf(dot3F4(a,a));\n"
+	"}\n"
+	"__inline\n"
+	"float dot4(const float4 a, const float4 b)\n"
+	"{\n"
+	"	return dot( a, b );\n"
+	"}\n"
+	"//	for height\n"
+	"__inline\n"
+	"float dot3w1(const float4 point, const float4 eqn)\n"
+	"{\n"
+	"	return dot3F4(point,eqn) + eqn.w;\n"
+	"}\n"
+	"__inline\n"
+	"float4 normalize3(const float4 a)\n"
+	"{\n"
+	"	float4 n = make_float4(a.x, a.y, a.z, 0.f);\n"
+	"	return fastNormalize4( n );\n"
+	"//	float length = sqrtf(dot3F4(a, a));\n"
+	"//	return 1.f/length * a;\n"
+	"}\n"
+	"__inline\n"
+	"float4 normalize4(const float4 a)\n"
+	"{\n"
+	"	float length = sqrtf(dot4(a, a));\n"
+	"	return 1.f/length * a;\n"
+	"}\n"
+	"__inline\n"
+	"float4 createEquation(const float4 a, const float4 b, const float4 c)\n"
+	"{\n"
+	"	float4 eqn;\n"
+	"	float4 ab = b-a;\n"
+	"	float4 ac = c-a;\n"
+	"	eqn = normalize3( cross3(ab, ac) );\n"
+	"	eqn.w = -dot3F4(eqn,a);\n"
+	"	return eqn;\n"
+	"}\n"
+	"///////////////////////////////////////\n"
+	"//	Matrix3x3\n"
+	"///////////////////////////////////////\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4 m_row[3];\n"
+	"}Matrix3x3;\n"
+	"__inline\n"
+	"Matrix3x3 mtZero();\n"
+	"__inline\n"
+	"Matrix3x3 mtIdentity();\n"
+	"__inline\n"
+	"Matrix3x3 mtTranspose(Matrix3x3 m);\n"
+	"__inline\n"
+	"Matrix3x3 mtMul(Matrix3x3 a, Matrix3x3 b);\n"
+	"__inline\n"
+	"float4 mtMul1(Matrix3x3 a, float4 b);\n"
+	"__inline\n"
+	"float4 mtMul3(float4 a, Matrix3x3 b);\n"
+	"__inline\n"
+	"Matrix3x3 mtZero()\n"
+	"{\n"
+	"	Matrix3x3 m;\n"
+	"	m.m_row[0] = (float4)(0.f);\n"
+	"	m.m_row[1] = (float4)(0.f);\n"
+	"	m.m_row[2] = (float4)(0.f);\n"
+	"	return m;\n"
+	"}\n"
+	"__inline\n"
+	"Matrix3x3 mtIdentity()\n"
+	"{\n"
+	"	Matrix3x3 m;\n"
+	"	m.m_row[0] = (float4)(1,0,0,0);\n"
+	"	m.m_row[1] = (float4)(0,1,0,0);\n"
+	"	m.m_row[2] = (float4)(0,0,1,0);\n"
+	"	return m;\n"
+	"}\n"
+	"__inline\n"
+	"Matrix3x3 mtTranspose(Matrix3x3 m)\n"
+	"{\n"
+	"	Matrix3x3 out;\n"
+	"	out.m_row[0] = (float4)(m.m_row[0].x, m.m_row[1].x, m.m_row[2].x, 0.f);\n"
+	"	out.m_row[1] = (float4)(m.m_row[0].y, m.m_row[1].y, m.m_row[2].y, 0.f);\n"
+	"	out.m_row[2] = (float4)(m.m_row[0].z, m.m_row[1].z, m.m_row[2].z, 0.f);\n"
+	"	return out;\n"
+	"}\n"
+	"__inline\n"
+	"Matrix3x3 mtMul(Matrix3x3 a, Matrix3x3 b)\n"
+	"{\n"
+	"	Matrix3x3 transB;\n"
+	"	transB = mtTranspose( b );\n"
+	"	Matrix3x3 ans;\n"
+	"	//	why this doesn't run when 0ing in the for{}\n"
+	"	a.m_row[0].w = 0.f;\n"
+	"	a.m_row[1].w = 0.f;\n"
+	"	a.m_row[2].w = 0.f;\n"
+	"	for(int i=0; i<3; i++)\n"
+	"	{\n"
+	"//	a.m_row[i].w = 0.f;\n"
+	"		ans.m_row[i].x = dot3F4(a.m_row[i],transB.m_row[0]);\n"
+	"		ans.m_row[i].y = dot3F4(a.m_row[i],transB.m_row[1]);\n"
+	"		ans.m_row[i].z = dot3F4(a.m_row[i],transB.m_row[2]);\n"
+	"		ans.m_row[i].w = 0.f;\n"
+	"	}\n"
+	"	return ans;\n"
+	"}\n"
+	"__inline\n"
+	"float4 mtMul1(Matrix3x3 a, float4 b)\n"
+	"{\n"
+	"	float4 ans;\n"
+	"	ans.x = dot3F4( a.m_row[0], b );\n"
+	"	ans.y = dot3F4( a.m_row[1], b );\n"
+	"	ans.z = dot3F4( a.m_row[2], b );\n"
+	"	ans.w = 0.f;\n"
+	"	return ans;\n"
+	"}\n"
+	"__inline\n"
+	"float4 mtMul3(float4 a, Matrix3x3 b)\n"
+	"{\n"
+	"	float4 colx = make_float4(b.m_row[0].x, b.m_row[1].x, b.m_row[2].x, 0);\n"
+	"	float4 coly = make_float4(b.m_row[0].y, b.m_row[1].y, b.m_row[2].y, 0);\n"
+	"	float4 colz = make_float4(b.m_row[0].z, b.m_row[1].z, b.m_row[2].z, 0);\n"
+	"	float4 ans;\n"
+	"	ans.x = dot3F4( a, colx );\n"
+	"	ans.y = dot3F4( a, coly );\n"
+	"	ans.z = dot3F4( a, colz );\n"
+	"	return ans;\n"
+	"}\n"
+	"///////////////////////////////////////\n"
+	"//	Quaternion\n"
+	"///////////////////////////////////////\n"
+	"typedef float4 Quaternion;\n"
+	"__inline\n"
+	"Quaternion qtMul(Quaternion a, Quaternion b);\n"
+	"__inline\n"
+	"Quaternion qtNormalize(Quaternion in);\n"
+	"__inline\n"
+	"float4 qtRotate(Quaternion q, float4 vec);\n"
+	"__inline\n"
+	"Quaternion qtInvert(Quaternion q);\n"
+	"__inline\n"
+	"Quaternion qtMul(Quaternion a, Quaternion b)\n"
+	"{\n"
+	"	Quaternion ans;\n"
+	"	ans = cross3( a, b );\n"
+	"	ans += a.w*b+b.w*a;\n"
+	"//	ans.w = a.w*b.w - (a.x*b.x+a.y*b.y+a.z*b.z);\n"
+	"	ans.w = a.w*b.w - dot3F4(a, b);\n"
+	"	return ans;\n"
+	"}\n"
+	"__inline\n"
+	"Quaternion qtNormalize(Quaternion in)\n"
+	"{\n"
+	"	return fastNormalize4(in);\n"
+	"//	in /= length( in );\n"
+	"//	return in;\n"
+	"}\n"
+	"__inline\n"
+	"float4 qtRotate(Quaternion q, float4 vec)\n"
+	"{\n"
+	"	Quaternion qInv = qtInvert( q );\n"
+	"	float4 vcpy = vec;\n"
+	"	vcpy.w = 0.f;\n"
+	"	float4 out = qtMul(qtMul(q,vcpy),qInv);\n"
+	"	return out;\n"
+	"}\n"
+	"__inline\n"
+	"Quaternion qtInvert(Quaternion q)\n"
+	"{\n"
+	"	return (Quaternion)(-q.xyz, q.w);\n"
+	"}\n"
+	"__inline\n"
+	"float4 qtInvRotate(const Quaternion q, float4 vec)\n"
+	"{\n"
+	"	return qtRotate( qtInvert( q ), vec );\n"
+	"}\n"
+	"#define WG_SIZE 64\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4 m_pos;\n"
+	"	Quaternion m_quat;\n"
+	"	float4 m_linVel;\n"
+	"	float4 m_angVel;\n"
+	"	u32 m_shapeIdx;\n"
+	"	float m_invMass;\n"
+	"	float m_restituitionCoeff;\n"
+	"	float m_frictionCoeff;\n"
+	"} Body;\n"
+	"typedef struct\n"
+	"{\n"
+	"	Matrix3x3 m_invInertia;\n"
+	"	Matrix3x3 m_initInvInertia;\n"
+	"} Shape;\n"
+	"typedef struct\n"
+	"{\n"
+	"	float4 m_linear;\n"
+	"	float4 m_worldPos[4];\n"
+	"	float4 m_center;	\n"
+	"	float m_jacCoeffInv[4];\n"
+	"	float m_b[4];\n"
+	"	float m_appliedRambdaDt[4];\n"
+	"	float m_fJacCoeffInv[2];	\n"
+	"	float m_fAppliedRambdaDt[2];	\n"
+	"	u32 m_bodyA;\n"
+	"	u32 m_bodyB;\n"
+	"	int m_batchIdx;\n"
+	"	u32 m_paddings;\n"
+	"} Constraint4;\n"
+	"__kernel void CountBodiesKernel(__global struct b3Contact4Data* manifoldPtr, __global unsigned int* bodyCount, __global int2* contactConstraintOffsets, int numContactManifolds, int fixedBodyIndex)\n"
+	"{\n"
+	"	int i = GET_GLOBAL_IDX;\n"
+	"	\n"
+	"	if( i < numContactManifolds)\n"
+	"	{\n"
+	"		int pa = manifoldPtr[i].m_bodyAPtrAndSignBit;\n"
+	"		bool isFixedA = (pa <0) || (pa == fixedBodyIndex);\n"
+	"		int bodyIndexA = abs(pa);\n"
+	"		if (!isFixedA)\n"
+	"		{\n"
+	"			 AtomInc1(bodyCount[bodyIndexA],contactConstraintOffsets[i].x);\n"
+	"		}\n"
+	"		barrier(CLK_GLOBAL_MEM_FENCE);\n"
+	"		int pb = manifoldPtr[i].m_bodyBPtrAndSignBit;\n"
+	"		bool isFixedB = (pb <0) || (pb == fixedBodyIndex);\n"
+	"		int bodyIndexB = abs(pb);\n"
+	"		if (!isFixedB)\n"
+	"		{\n"
+	"			AtomInc1(bodyCount[bodyIndexB],contactConstraintOffsets[i].y);\n"
+	"		} \n"
+	"	}\n"
+	"}\n"
+	"__kernel void ClearVelocitiesKernel(__global float4* linearVelocities,__global float4* angularVelocities, int numSplitBodies)\n"
+	"{\n"
+	"	int i = GET_GLOBAL_IDX;\n"
+	"	\n"
+	"	if( i < numSplitBodies)\n"
+	"	{\n"
+	"		linearVelocities[i] = make_float4(0);\n"
+	"		angularVelocities[i] = make_float4(0);\n"
+	"	}\n"
+	"}\n"
+	"__kernel void AverageVelocitiesKernel(__global Body* gBodies,__global int* offsetSplitBodies,__global const unsigned int* bodyCount,\n"
+	"__global float4* deltaLinearVelocities, __global float4* deltaAngularVelocities, int numBodies)\n"
+	"{\n"
+	"	int i = GET_GLOBAL_IDX;\n"
+	"	if (i<numBodies)\n"
+	"	{\n"
+	"		if (gBodies[i].m_invMass)\n"
+	"		{\n"
+	"			int bodyOffset = offsetSplitBodies[i];\n"
+	"			int count = bodyCount[i];\n"
+	"			float factor = 1.f/((float)count);\n"
+	"			float4 averageLinVel = make_float4(0.f);\n"
+	"			float4 averageAngVel = make_float4(0.f);\n"
+	"			\n"
+	"			for (int j=0;j<count;j++)\n"
+	"			{\n"
+	"				averageLinVel += deltaLinearVelocities[bodyOffset+j]*factor;\n"
+	"				averageAngVel += deltaAngularVelocities[bodyOffset+j]*factor;\n"
+	"			}\n"
+	"			\n"
+	"			for (int j=0;j<count;j++)\n"
+	"			{\n"
+	"				deltaLinearVelocities[bodyOffset+j] = averageLinVel;\n"
+	"				deltaAngularVelocities[bodyOffset+j] = averageAngVel;\n"
+	"			}\n"
+	"			\n"
+	"		}//bodies[i].m_invMass\n"
+	"	}//i<numBodies\n"
+	"}\n"
+	"void setLinearAndAngular( float4 n, float4 r0, float4 r1, float4* linear, float4* angular0, float4* angular1)\n"
+	"{\n"
+	"	*linear = make_float4(n.xyz,0.f);\n"
+	"	*angular0 = cross3(r0, n);\n"
+	"	*angular1 = -cross3(r1, n);\n"
+	"}\n"
+	"float calcRelVel( float4 l0, float4 l1, float4 a0, float4 a1, float4 linVel0, float4 angVel0, float4 linVel1, float4 angVel1 )\n"
+	"{\n"
+	"	return dot3F4(l0, linVel0) + dot3F4(a0, angVel0) + dot3F4(l1, linVel1) + dot3F4(a1, angVel1);\n"
+	"}\n"
+	"float calcJacCoeff(const float4 linear0, const float4 linear1, const float4 angular0, const float4 angular1,\n"
+	"					float invMass0, const Matrix3x3* invInertia0, float invMass1, const Matrix3x3* invInertia1, float countA, float countB)\n"
+	"{\n"
+	"	//	linear0,1 are normlized\n"
+	"	float jmj0 = invMass0;//dot3F4(linear0, linear0)*invMass0;\n"
+	"	float jmj1 = dot3F4(mtMul3(angular0,*invInertia0), angular0);\n"
+	"	float jmj2 = invMass1;//dot3F4(linear1, linear1)*invMass1;\n"
+	"	float jmj3 = dot3F4(mtMul3(angular1,*invInertia1), angular1);\n"
+	"	return -1.f/((jmj0+jmj1)*countA+(jmj2+jmj3)*countB);\n"
+	"}\n"
+	"void btPlaneSpace1 (float4 n, float4* p, float4* q);\n"
+	" void btPlaneSpace1 (float4 n, float4* p, float4* q)\n"
+	"{\n"
+	"  if (fabs(n.z) > 0.70710678f) {\n"
+	"    // choose p in y-z plane\n"
+	"    float a = n.y*n.y + n.z*n.z;\n"
+	"    float k = 1.f/sqrt(a);\n"
+	"    p[0].x = 0;\n"
+	"	p[0].y = -n.z*k;\n"
+	"	p[0].z = n.y*k;\n"
+	"    // set q = n x p\n"
+	"    q[0].x = a*k;\n"
+	"	q[0].y = -n.x*p[0].z;\n"
+	"	q[0].z = n.x*p[0].y;\n"
+	"  }\n"
+	"  else {\n"
+	"    // choose p in x-y plane\n"
+	"    float a = n.x*n.x + n.y*n.y;\n"
+	"    float k = 1.f/sqrt(a);\n"
+	"    p[0].x = -n.y*k;\n"
+	"	p[0].y = n.x*k;\n"
+	"	p[0].z = 0;\n"
+	"    // set q = n x p\n"
+	"    q[0].x = -n.z*p[0].y;\n"
+	"	q[0].y = n.z*p[0].x;\n"
+	"	q[0].z = a*k;\n"
+	"  }\n"
+	"}\n"
+	"void solveContact(__global Constraint4* cs,\n"
+	"			float4 posA, float4* linVelA, float4* angVelA, float invMassA, Matrix3x3 invInertiaA,\n"
+	"			float4 posB, float4* linVelB, float4* angVelB, float invMassB, Matrix3x3 invInertiaB,\n"
+	"			float4* dLinVelA, float4* dAngVelA, float4* dLinVelB, float4* dAngVelB)\n"
+	"{\n"
+	"	float minRambdaDt = 0;\n"
+	"	float maxRambdaDt = FLT_MAX;\n"
+	"	for(int ic=0; ic<4; ic++)\n"
+	"	{\n"
+	"		if( cs->m_jacCoeffInv[ic] == 0.f ) continue;\n"
+	"		float4 angular0, angular1, linear;\n"
+	"		float4 r0 = cs->m_worldPos[ic] - posA;\n"
+	"		float4 r1 = cs->m_worldPos[ic] - posB;\n"
+	"		setLinearAndAngular( cs->m_linear, r0, r1, &linear, &angular0, &angular1 );\n"
+	"	\n"
+	"		float rambdaDt = calcRelVel( cs->m_linear, -cs->m_linear, angular0, angular1, \n"
+	"			*linVelA+*dLinVelA, *angVelA+*dAngVelA, *linVelB+*dLinVelB, *angVelB+*dAngVelB ) + cs->m_b[ic];\n"
+	"		rambdaDt *= cs->m_jacCoeffInv[ic];\n"
+	"		\n"
+	"		{\n"
+	"			float prevSum = cs->m_appliedRambdaDt[ic];\n"
+	"			float updated = prevSum;\n"
+	"			updated += rambdaDt;\n"
+	"			updated = max2( updated, minRambdaDt );\n"
+	"			updated = min2( updated, maxRambdaDt );\n"
+	"			rambdaDt = updated - prevSum;\n"
+	"			cs->m_appliedRambdaDt[ic] = updated;\n"
+	"		}\n"
+	"			\n"
+	"		float4 linImp0 = invMassA*linear*rambdaDt;\n"
+	"		float4 linImp1 = invMassB*(-linear)*rambdaDt;\n"
+	"		float4 angImp0 = mtMul1(invInertiaA, angular0)*rambdaDt;\n"
+	"		float4 angImp1 = mtMul1(invInertiaB, angular1)*rambdaDt;\n"
+	"		\n"
+	"		if (invMassA)\n"
+	"		{\n"
+	"			*dLinVelA += linImp0;\n"
+	"			*dAngVelA += angImp0;\n"
+	"		}\n"
+	"		if (invMassB)\n"
+	"		{\n"
+	"			*dLinVelB += linImp1;\n"
+	"			*dAngVelB += angImp1;\n"
+	"		}\n"
+	"	}\n"
+	"}\n"
+	"//	solveContactConstraint( gBodies, gShapes, &gConstraints[i] ,contactConstraintOffsets,offsetSplitBodies, deltaLinearVelocities, deltaAngularVelocities);\n"
+	"void solveContactConstraint(__global Body* gBodies, __global Shape* gShapes, __global Constraint4* ldsCs, \n"
+	"__global int2* contactConstraintOffsets,__global unsigned int* offsetSplitBodies,\n"
+	"__global float4* deltaLinearVelocities, __global float4* deltaAngularVelocities)\n"
+	"{\n"
+	"	//float frictionCoeff = ldsCs[0].m_linear.w;\n"
+	"	int aIdx = ldsCs[0].m_bodyA;\n"
+	"	int bIdx = ldsCs[0].m_bodyB;\n"
+	"	float4 posA = gBodies[aIdx].m_pos;\n"
+	"	float4 linVelA = gBodies[aIdx].m_linVel;\n"
+	"	float4 angVelA = gBodies[aIdx].m_angVel;\n"
+	"	float invMassA = gBodies[aIdx].m_invMass;\n"
+	"	Matrix3x3 invInertiaA = gShapes[aIdx].m_invInertia;\n"
+	"	float4 posB = gBodies[bIdx].m_pos;\n"
+	"	float4 linVelB = gBodies[bIdx].m_linVel;\n"
+	"	float4 angVelB = gBodies[bIdx].m_angVel;\n"
+	"	float invMassB = gBodies[bIdx].m_invMass;\n"
+	"	Matrix3x3 invInertiaB = gShapes[bIdx].m_invInertia;\n"
+	"			\n"
+	"	float4 dLinVelA = make_float4(0,0,0,0);\n"
+	"	float4 dAngVelA = make_float4(0,0,0,0);\n"
+	"	float4 dLinVelB = make_float4(0,0,0,0);\n"
+	"	float4 dAngVelB = make_float4(0,0,0,0);\n"
+	"			\n"
+	"	int bodyOffsetA = offsetSplitBodies[aIdx];\n"
+	"	int constraintOffsetA = contactConstraintOffsets[0].x;\n"
+	"	int splitIndexA = bodyOffsetA+constraintOffsetA;\n"
+	"	\n"
+	"	if (invMassA)\n"
+	"	{\n"
+	"		dLinVelA = deltaLinearVelocities[splitIndexA];\n"
+	"		dAngVelA = deltaAngularVelocities[splitIndexA];\n"
+	"	}\n"
+	"	int bodyOffsetB = offsetSplitBodies[bIdx];\n"
+	"	int constraintOffsetB = contactConstraintOffsets[0].y;\n"
+	"	int splitIndexB= bodyOffsetB+constraintOffsetB;\n"
+	"	if (invMassB)\n"
+	"	{\n"
+	"		dLinVelB = deltaLinearVelocities[splitIndexB];\n"
+	"		dAngVelB = deltaAngularVelocities[splitIndexB];\n"
+	"	}\n"
+	"	solveContact( ldsCs, posA, &linVelA, &angVelA, invMassA, invInertiaA,\n"
+	"			posB, &linVelB, &angVelB, invMassB, invInertiaB ,&dLinVelA, &dAngVelA, &dLinVelB, &dAngVelB);\n"
+	"	if (invMassA)\n"
+	"	{\n"
+	"		deltaLinearVelocities[splitIndexA] = dLinVelA;\n"
+	"		deltaAngularVelocities[splitIndexA] = dAngVelA;\n"
+	"	} \n"
+	"	if (invMassB)\n"
+	"	{\n"
+	"		deltaLinearVelocities[splitIndexB] = dLinVelB;\n"
+	"		deltaAngularVelocities[splitIndexB] = dAngVelB;\n"
+	"	}\n"
+	"}\n"
+	"__kernel void SolveContactJacobiKernel(__global Constraint4* gConstraints, __global Body* gBodies, __global Shape* gShapes ,\n"
+	"__global int2* contactConstraintOffsets,__global unsigned int* offsetSplitBodies,__global float4* deltaLinearVelocities, __global float4* deltaAngularVelocities,\n"
+	"float deltaTime, float positionDrift, float positionConstraintCoeff, int fixedBodyIndex, int numManifolds\n"
+	")\n"
+	"{\n"
+	"	int i = GET_GLOBAL_IDX;\n"
+	"	if (i<numManifolds)\n"
+	"	{\n"
+	"		solveContactConstraint( gBodies, gShapes, &gConstraints[i] ,&contactConstraintOffsets[i],offsetSplitBodies, deltaLinearVelocities, deltaAngularVelocities);\n"
+	"	}\n"
+	"}\n"
+	"void solveFrictionConstraint(__global Body* gBodies, __global Shape* gShapes, __global Constraint4* ldsCs,\n"
+	"							__global int2* contactConstraintOffsets,__global unsigned int* offsetSplitBodies,\n"
+	"							__global float4* deltaLinearVelocities, __global float4* deltaAngularVelocities)\n"
+	"{\n"
+	"	float frictionCoeff = 0.7f;//ldsCs[0].m_linear.w;\n"
+	"	int aIdx = ldsCs[0].m_bodyA;\n"
+	"	int bIdx = ldsCs[0].m_bodyB;\n"
+	"	float4 posA = gBodies[aIdx].m_pos;\n"
+	"	float4 linVelA = gBodies[aIdx].m_linVel;\n"
+	"	float4 angVelA = gBodies[aIdx].m_angVel;\n"
+	"	float invMassA = gBodies[aIdx].m_invMass;\n"
+	"	Matrix3x3 invInertiaA = gShapes[aIdx].m_invInertia;\n"
+	"	float4 posB = gBodies[bIdx].m_pos;\n"
+	"	float4 linVelB = gBodies[bIdx].m_linVel;\n"
+	"	float4 angVelB = gBodies[bIdx].m_angVel;\n"
+	"	float invMassB = gBodies[bIdx].m_invMass;\n"
+	"	Matrix3x3 invInertiaB = gShapes[bIdx].m_invInertia;\n"
+	"	\n"
+	"	float4 dLinVelA = make_float4(0,0,0,0);\n"
+	"	float4 dAngVelA = make_float4(0,0,0,0);\n"
+	"	float4 dLinVelB = make_float4(0,0,0,0);\n"
+	"	float4 dAngVelB = make_float4(0,0,0,0);\n"
+	"			\n"
+	"	int bodyOffsetA = offsetSplitBodies[aIdx];\n"
+	"	int constraintOffsetA = contactConstraintOffsets[0].x;\n"
+	"	int splitIndexA = bodyOffsetA+constraintOffsetA;\n"
+	"	\n"
+	"	if (invMassA)\n"
+	"	{\n"
+	"		dLinVelA = deltaLinearVelocities[splitIndexA];\n"
+	"		dAngVelA = deltaAngularVelocities[splitIndexA];\n"
+	"	}\n"
+	"	int bodyOffsetB = offsetSplitBodies[bIdx];\n"
+	"	int constraintOffsetB = contactConstraintOffsets[0].y;\n"
+	"	int splitIndexB= bodyOffsetB+constraintOffsetB;\n"
+	"	if (invMassB)\n"
+	"	{\n"
+	"		dLinVelB = deltaLinearVelocities[splitIndexB];\n"
+	"		dAngVelB = deltaAngularVelocities[splitIndexB];\n"
+	"	}\n"
+	"	{\n"
+	"		float maxRambdaDt[4] = {FLT_MAX,FLT_MAX,FLT_MAX,FLT_MAX};\n"
+	"		float minRambdaDt[4] = {0.f,0.f,0.f,0.f};\n"
+	"		float sum = 0;\n"
+	"		for(int j=0; j<4; j++)\n"
+	"		{\n"
+	"			sum +=ldsCs[0].m_appliedRambdaDt[j];\n"
+	"		}\n"
+	"		frictionCoeff = 0.7f;\n"
+	"		for(int j=0; j<4; j++)\n"
+	"		{\n"
+	"			maxRambdaDt[j] = frictionCoeff*sum;\n"
+	"			minRambdaDt[j] = -maxRambdaDt[j];\n"
+	"		}\n"
+	"		\n"
+	"//		solveFriction( ldsCs, posA, &linVelA, &angVelA, invMassA, invInertiaA,\n"
+	"//			posB, &linVelB, &angVelB, invMassB, invInertiaB, maxRambdaDt, minRambdaDt );\n"
+	"		\n"
+	"		\n"
+	"		{\n"
+	"			\n"
+	"			__global Constraint4* cs = ldsCs;\n"
+	"			\n"
+	"			if( cs->m_fJacCoeffInv[0] == 0 && cs->m_fJacCoeffInv[0] == 0 ) return;\n"
+	"			const float4 center = cs->m_center;\n"
+	"			\n"
+	"			float4 n = -cs->m_linear;\n"
+	"			\n"
+	"			float4 tangent[2];\n"
+	"			btPlaneSpace1(n,&tangent[0],&tangent[1]);\n"
+	"			float4 angular0, angular1, linear;\n"
+	"			float4 r0 = center - posA;\n"
+	"			float4 r1 = center - posB;\n"
+	"			for(int i=0; i<2; i++)\n"
+	"			{\n"
+	"				setLinearAndAngular( tangent[i], r0, r1, &linear, &angular0, &angular1 );\n"
+	"				float rambdaDt = calcRelVel(linear, -linear, angular0, angular1,\n"
+	"											linVelA+dLinVelA, angVelA+dAngVelA, linVelB+dLinVelB, angVelB+dAngVelB );\n"
+	"				rambdaDt *= cs->m_fJacCoeffInv[i];\n"
+	"				\n"
+	"				{\n"
+	"					float prevSum = cs->m_fAppliedRambdaDt[i];\n"
+	"					float updated = prevSum;\n"
+	"					updated += rambdaDt;\n"
+	"					updated = max2( updated, minRambdaDt[i] );\n"
+	"					updated = min2( updated, maxRambdaDt[i] );\n"
+	"					rambdaDt = updated - prevSum;\n"
+	"					cs->m_fAppliedRambdaDt[i] = updated;\n"
+	"				}\n"
+	"				\n"
+	"				float4 linImp0 = invMassA*linear*rambdaDt;\n"
+	"				float4 linImp1 = invMassB*(-linear)*rambdaDt;\n"
+	"				float4 angImp0 = mtMul1(invInertiaA, angular0)*rambdaDt;\n"
+	"				float4 angImp1 = mtMul1(invInertiaB, angular1)*rambdaDt;\n"
+	"				\n"
+	"				dLinVelA += linImp0;\n"
+	"				dAngVelA += angImp0;\n"
+	"				dLinVelB += linImp1;\n"
+	"				dAngVelB += angImp1;\n"
+	"			}\n"
+	"			{	//	angular damping for point constraint\n"
+	"				float4 ab = normalize3( posB - posA );\n"
+	"				float4 ac = normalize3( center - posA );\n"
+	"				if( dot3F4( ab, ac ) > 0.95f  || (invMassA == 0.f || invMassB == 0.f))\n"
+	"				{\n"
+	"					float angNA = dot3F4( n, angVelA );\n"
+	"					float angNB = dot3F4( n, angVelB );\n"
+	"					\n"
+	"					dAngVelA -= (angNA*0.1f)*n;\n"
+	"					dAngVelB -= (angNB*0.1f)*n;\n"
+	"				}\n"
+	"			}\n"
+	"		}\n"
+	"		\n"
+	"		\n"
+	"	}\n"
+	"	if (invMassA)\n"
+	"	{\n"
+	"		deltaLinearVelocities[splitIndexA] = dLinVelA;\n"
+	"		deltaAngularVelocities[splitIndexA] = dAngVelA;\n"
+	"	} \n"
+	"	if (invMassB)\n"
+	"	{\n"
+	"		deltaLinearVelocities[splitIndexB] = dLinVelB;\n"
+	"		deltaAngularVelocities[splitIndexB] = dAngVelB;\n"
+	"	}\n"
+	" \n"
+	"}\n"
+	"__kernel void SolveFrictionJacobiKernel(__global Constraint4* gConstraints, __global Body* gBodies, __global Shape* gShapes ,\n"
+	"										__global int2* contactConstraintOffsets,__global unsigned int* offsetSplitBodies,\n"
+	"										__global float4* deltaLinearVelocities, __global float4* deltaAngularVelocities,\n"
+	"										float deltaTime, float positionDrift, float positionConstraintCoeff, int fixedBodyIndex, int numManifolds\n"
+	")\n"
+	"{\n"
+	"	int i = GET_GLOBAL_IDX;\n"
+	"	if (i<numManifolds)\n"
+	"	{\n"
+	"		solveFrictionConstraint( gBodies, gShapes, &gConstraints[i] ,&contactConstraintOffsets[i],offsetSplitBodies, deltaLinearVelocities, deltaAngularVelocities);\n"
+	"	}\n"
+	"}\n"
+	"__kernel void UpdateBodyVelocitiesKernel(__global Body* gBodies,__global int* offsetSplitBodies,__global const unsigned int* bodyCount,\n"
+	"									__global float4* deltaLinearVelocities, __global float4* deltaAngularVelocities, int numBodies)\n"
+	"{\n"
+	"	int i = GET_GLOBAL_IDX;\n"
+	"	if (i<numBodies)\n"
+	"	{\n"
+	"		if (gBodies[i].m_invMass)\n"
+	"		{\n"
+	"			int bodyOffset = offsetSplitBodies[i];\n"
+	"			int count = bodyCount[i];\n"
+	"			if (count)\n"
+	"			{\n"
+	"				gBodies[i].m_linVel += deltaLinearVelocities[bodyOffset];\n"
+	"				gBodies[i].m_angVel += deltaAngularVelocities[bodyOffset];\n"
+	"			}\n"
+	"		}\n"
+	"	}\n"
+	"}\n"
+	"void setConstraint4( const float4 posA, const float4 linVelA, const float4 angVelA, float invMassA, const Matrix3x3 invInertiaA,\n"
+	"	const float4 posB, const float4 linVelB, const float4 angVelB, float invMassB, const Matrix3x3 invInertiaB, \n"
+	"	__global struct b3Contact4Data* src, float dt, float positionDrift, float positionConstraintCoeff,float countA, float countB,\n"
+	"	Constraint4* dstC )\n"
+	"{\n"
+	"	dstC->m_bodyA = abs(src->m_bodyAPtrAndSignBit);\n"
+	"	dstC->m_bodyB = abs(src->m_bodyBPtrAndSignBit);\n"
+	"	float dtInv = 1.f/dt;\n"
+	"	for(int ic=0; ic<4; ic++)\n"
+	"	{\n"
+	"		dstC->m_appliedRambdaDt[ic] = 0.f;\n"
+	"	}\n"
+	"	dstC->m_fJacCoeffInv[0] = dstC->m_fJacCoeffInv[1] = 0.f;\n"
+	"	dstC->m_linear = src->m_worldNormalOnB;\n"
+	"	dstC->m_linear.w = 0.7f ;//src->getFrictionCoeff() );\n"
+	"	for(int ic=0; ic<4; ic++)\n"
+	"	{\n"
+	"		float4 r0 = src->m_worldPosB[ic] - posA;\n"
+	"		float4 r1 = src->m_worldPosB[ic] - posB;\n"
+	"		if( ic >= src->m_worldNormalOnB.w )//npoints\n"
+	"		{\n"
+	"			dstC->m_jacCoeffInv[ic] = 0.f;\n"
+	"			continue;\n"
+	"		}\n"
+	"		float relVelN;\n"
+	"		{\n"
+	"			float4 linear, angular0, angular1;\n"
+	"			setLinearAndAngular(src->m_worldNormalOnB, r0, r1, &linear, &angular0, &angular1);\n"
+	"			dstC->m_jacCoeffInv[ic] = calcJacCoeff(linear, -linear, angular0, angular1,\n"
+	"				invMassA, &invInertiaA, invMassB, &invInertiaB , countA, countB);\n"
+	"			relVelN = calcRelVel(linear, -linear, angular0, angular1,\n"
+	"				linVelA, angVelA, linVelB, angVelB);\n"
+	"			float e = 0.f;//src->getRestituitionCoeff();\n"
+	"			if( relVelN*relVelN < 0.004f ) e = 0.f;\n"
+	"			dstC->m_b[ic] = e*relVelN;\n"
+	"			//float penetration = src->m_worldPosB[ic].w;\n"
+	"			dstC->m_b[ic] += (src->m_worldPosB[ic].w + positionDrift)*positionConstraintCoeff*dtInv;\n"
+	"			dstC->m_appliedRambdaDt[ic] = 0.f;\n"
+	"		}\n"
+	"	}\n"
+	"	if( src->m_worldNormalOnB.w > 0 )//npoints\n"
+	"	{	//	prepare friction\n"
+	"		float4 center = make_float4(0.f);\n"
+	"		for(int i=0; i<src->m_worldNormalOnB.w; i++) \n"
+	"			center += src->m_worldPosB[i];\n"
+	"		center /= (float)src->m_worldNormalOnB.w;\n"
+	"		float4 tangent[2];\n"
+	"		btPlaneSpace1(-src->m_worldNormalOnB,&tangent[0],&tangent[1]);\n"
+	"		\n"
+	"		float4 r[2];\n"
+	"		r[0] = center - posA;\n"
+	"		r[1] = center - posB;\n"
+	"		for(int i=0; i<2; i++)\n"
+	"		{\n"
+	"			float4 linear, angular0, angular1;\n"
+	"			setLinearAndAngular(tangent[i], r[0], r[1], &linear, &angular0, &angular1);\n"
+	"			dstC->m_fJacCoeffInv[i] = calcJacCoeff(linear, -linear, angular0, angular1,\n"
+	"				invMassA, &invInertiaA, invMassB, &invInertiaB ,countA, countB);\n"
+	"			dstC->m_fAppliedRambdaDt[i] = 0.f;\n"
+	"		}\n"
+	"		dstC->m_center = center;\n"
+	"	}\n"
+	"	for(int i=0; i<4; i++)\n"
+	"	{\n"
+	"		if( i<src->m_worldNormalOnB.w )\n"
+	"		{\n"
+	"			dstC->m_worldPos[i] = src->m_worldPosB[i];\n"
+	"		}\n"
+	"		else\n"
+	"		{\n"
+	"			dstC->m_worldPos[i] = make_float4(0.f);\n"
+	"		}\n"
+	"	}\n"
+	"}\n"
+	"__kernel\n"
+	"__attribute__((reqd_work_group_size(WG_SIZE,1,1)))\n"
+	"void ContactToConstraintSplitKernel(__global const struct b3Contact4Data* gContact, __global const Body* gBodies, __global const Shape* gShapes, __global Constraint4* gConstraintOut, \n"
+	"__global const unsigned int* bodyCount,\n"
+	"int nContacts,\n"
+	"float dt,\n"
+	"float positionDrift,\n"
+	"float positionConstraintCoeff\n"
+	")\n"
+	"{\n"
+	"	int gIdx = GET_GLOBAL_IDX;\n"
+	"	\n"
+	"	if( gIdx < nContacts )\n"
+	"	{\n"
+	"		int aIdx = abs(gContact[gIdx].m_bodyAPtrAndSignBit);\n"
+	"		int bIdx = abs(gContact[gIdx].m_bodyBPtrAndSignBit);\n"
+	"		float4 posA = gBodies[aIdx].m_pos;\n"
+	"		float4 linVelA = gBodies[aIdx].m_linVel;\n"
+	"		float4 angVelA = gBodies[aIdx].m_angVel;\n"
+	"		float invMassA = gBodies[aIdx].m_invMass;\n"
+	"		Matrix3x3 invInertiaA = gShapes[aIdx].m_invInertia;\n"
+	"		float4 posB = gBodies[bIdx].m_pos;\n"
+	"		float4 linVelB = gBodies[bIdx].m_linVel;\n"
+	"		float4 angVelB = gBodies[bIdx].m_angVel;\n"
+	"		float invMassB = gBodies[bIdx].m_invMass;\n"
+	"		Matrix3x3 invInertiaB = gShapes[bIdx].m_invInertia;\n"
+	"		Constraint4 cs;\n"
+	"		float countA = invMassA != 0.f ? (float)bodyCount[aIdx] : 1;\n"
+	"		float countB = invMassB != 0.f ? (float)bodyCount[bIdx] : 1;\n"
+	"    	setConstraint4( posA, linVelA, angVelA, invMassA, invInertiaA, posB, linVelB, angVelB, invMassB, invInertiaB,\n"
+	"			&gContact[gIdx], dt, positionDrift, positionConstraintCoeff,countA,countB,\n"
+	"			&cs  );\n"
+	"		\n"
+	"		cs.m_batchIdx = gContact[gIdx].m_batchIdx;\n"
+	"		gConstraintOut[gIdx] = cs;\n"
+	"	}\n"
+	"}\n";
diff --git a/engine/inc/bullet/Bullet3OpenCL/RigidBody/kernels/updateAabbsKernel.h b/engine/inc/bullet/Bullet3OpenCL/RigidBody/kernels/updateAabbsKernel.h
new file mode 100644
index 00000000..bb949b20
--- /dev/null
+++ b/engine/inc/bullet/Bullet3OpenCL/RigidBody/kernels/updateAabbsKernel.h
@@ -0,0 +1,482 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* updateAabbsKernelCL =
+	"#ifndef B3_UPDATE_AABBS_H\n"
+	"#define B3_UPDATE_AABBS_H\n"
+	"#ifndef B3_AABB_H\n"
+	"#define B3_AABB_H\n"
+	"#ifndef B3_FLOAT4_H\n"
+	"#define B3_FLOAT4_H\n"
+	"#ifndef B3_PLATFORM_DEFINITIONS_H\n"
+	"#define B3_PLATFORM_DEFINITIONS_H\n"
+	"struct MyTest\n"
+	"{\n"
+	"	int bla;\n"
+	"};\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"//keep B3_LARGE_FLOAT*B3_LARGE_FLOAT < FLT_MAX\n"
+	"#define B3_LARGE_FLOAT 1e18f\n"
+	"#define B3_INFINITY 1e18f\n"
+	"#define b3Assert(a)\n"
+	"#define b3ConstArray(a) __global const a*\n"
+	"#define b3AtomicInc atomic_inc\n"
+	"#define b3AtomicAdd atomic_add\n"
+	"#define b3Fabs fabs\n"
+	"#define b3Sqrt native_sqrt\n"
+	"#define b3Sin native_sin\n"
+	"#define b3Cos native_cos\n"
+	"#define B3_STATIC\n"
+	"#endif\n"
+	"#endif\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"	typedef float4	b3Float4;\n"
+	"	#define b3Float4ConstArg const b3Float4\n"
+	"	#define b3MakeFloat4 (float4)\n"
+	"	float b3Dot3F4(b3Float4ConstArg v0,b3Float4ConstArg v1)\n"
+	"	{\n"
+	"		float4 a1 = b3MakeFloat4(v0.xyz,0.f);\n"
+	"		float4 b1 = b3MakeFloat4(v1.xyz,0.f);\n"
+	"		return dot(a1, b1);\n"
+	"	}\n"
+	"	b3Float4 b3Cross3(b3Float4ConstArg v0,b3Float4ConstArg v1)\n"
+	"	{\n"
+	"		float4 a1 = b3MakeFloat4(v0.xyz,0.f);\n"
+	"		float4 b1 = b3MakeFloat4(v1.xyz,0.f);\n"
+	"		return cross(a1, b1);\n"
+	"	}\n"
+	"	#define b3MinFloat4 min\n"
+	"	#define b3MaxFloat4 max\n"
+	"	#define b3Normalized(a) normalize(a)\n"
+	"#endif \n"
+	"		\n"
+	"inline bool b3IsAlmostZero(b3Float4ConstArg v)\n"
+	"{\n"
+	"	if(b3Fabs(v.x)>1e-6 || b3Fabs(v.y)>1e-6 || b3Fabs(v.z)>1e-6)	\n"
+	"		return false;\n"
+	"	return true;\n"
+	"}\n"
+	"inline int    b3MaxDot( b3Float4ConstArg vec, __global const b3Float4* vecArray, int vecLen, float* dotOut )\n"
+	"{\n"
+	"    float maxDot = -B3_INFINITY;\n"
+	"    int i = 0;\n"
+	"    int ptIndex = -1;\n"
+	"    for( i = 0; i < vecLen; i++ )\n"
+	"    {\n"
+	"        float dot = b3Dot3F4(vecArray[i],vec);\n"
+	"            \n"
+	"        if( dot > maxDot )\n"
+	"        {\n"
+	"            maxDot = dot;\n"
+	"            ptIndex = i;\n"
+	"        }\n"
+	"    }\n"
+	"	b3Assert(ptIndex>=0);\n"
+	"    if (ptIndex<0)\n"
+	"	{\n"
+	"		ptIndex = 0;\n"
+	"	}\n"
+	"    *dotOut = maxDot;\n"
+	"    return ptIndex;\n"
+	"}\n"
+	"#endif //B3_FLOAT4_H\n"
+	"#ifndef B3_MAT3x3_H\n"
+	"#define B3_MAT3x3_H\n"
+	"#ifndef B3_QUAT_H\n"
+	"#define B3_QUAT_H\n"
+	"#ifndef B3_PLATFORM_DEFINITIONS_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif\n"
+	"#endif\n"
+	"#ifndef B3_FLOAT4_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif \n"
+	"#endif //B3_FLOAT4_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"	typedef float4	b3Quat;\n"
+	"	#define b3QuatConstArg const b3Quat\n"
+	"	\n"
+	"	\n"
+	"inline float4 b3FastNormalize4(float4 v)\n"
+	"{\n"
+	"	v = (float4)(v.xyz,0.f);\n"
+	"	return fast_normalize(v);\n"
+	"}\n"
+	"	\n"
+	"inline b3Quat b3QuatMul(b3Quat a, b3Quat b);\n"
+	"inline b3Quat b3QuatNormalized(b3QuatConstArg in);\n"
+	"inline b3Quat b3QuatRotate(b3QuatConstArg q, b3QuatConstArg vec);\n"
+	"inline b3Quat b3QuatInvert(b3QuatConstArg q);\n"
+	"inline b3Quat b3QuatInverse(b3QuatConstArg q);\n"
+	"inline b3Quat b3QuatMul(b3QuatConstArg a, b3QuatConstArg b)\n"
+	"{\n"
+	"	b3Quat ans;\n"
+	"	ans = b3Cross3( a, b );\n"
+	"	ans += a.w*b+b.w*a;\n"
+	"//	ans.w = a.w*b.w - (a.x*b.x+a.y*b.y+a.z*b.z);\n"
+	"	ans.w = a.w*b.w - b3Dot3F4(a, b);\n"
+	"	return ans;\n"
+	"}\n"
+	"inline b3Quat b3QuatNormalized(b3QuatConstArg in)\n"
+	"{\n"
+	"	b3Quat q;\n"
+	"	q=in;\n"
+	"	//return b3FastNormalize4(in);\n"
+	"	float len = native_sqrt(dot(q, q));\n"
+	"	if(len > 0.f)\n"
+	"	{\n"
+	"		q *= 1.f / len;\n"
+	"	}\n"
+	"	else\n"
+	"	{\n"
+	"		q.x = q.y = q.z = 0.f;\n"
+	"		q.w = 1.f;\n"
+	"	}\n"
+	"	return q;\n"
+	"}\n"
+	"inline float4 b3QuatRotate(b3QuatConstArg q, b3QuatConstArg vec)\n"
+	"{\n"
+	"	b3Quat qInv = b3QuatInvert( q );\n"
+	"	float4 vcpy = vec;\n"
+	"	vcpy.w = 0.f;\n"
+	"	float4 out = b3QuatMul(b3QuatMul(q,vcpy),qInv);\n"
+	"	return out;\n"
+	"}\n"
+	"inline b3Quat b3QuatInverse(b3QuatConstArg q)\n"
+	"{\n"
+	"	return (b3Quat)(-q.xyz, q.w);\n"
+	"}\n"
+	"inline b3Quat b3QuatInvert(b3QuatConstArg q)\n"
+	"{\n"
+	"	return (b3Quat)(-q.xyz, q.w);\n"
+	"}\n"
+	"inline float4 b3QuatInvRotate(b3QuatConstArg q, b3QuatConstArg vec)\n"
+	"{\n"
+	"	return b3QuatRotate( b3QuatInvert( q ), vec );\n"
+	"}\n"
+	"inline b3Float4 b3TransformPoint(b3Float4ConstArg point, b3Float4ConstArg translation, b3QuatConstArg  orientation)\n"
+	"{\n"
+	"	return b3QuatRotate( orientation, point ) + (translation);\n"
+	"}\n"
+	"	\n"
+	"#endif \n"
+	"#endif //B3_QUAT_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"typedef struct\n"
+	"{\n"
+	"	b3Float4 m_row[3];\n"
+	"}b3Mat3x3;\n"
+	"#define b3Mat3x3ConstArg const b3Mat3x3\n"
+	"#define b3GetRow(m,row) (m.m_row[row])\n"
+	"inline b3Mat3x3 b3QuatGetRotationMatrix(b3Quat quat)\n"
+	"{\n"
+	"	b3Float4 quat2 = (b3Float4)(quat.x*quat.x, quat.y*quat.y, quat.z*quat.z, 0.f);\n"
+	"	b3Mat3x3 out;\n"
+	"	out.m_row[0].x=1-2*quat2.y-2*quat2.z;\n"
+	"	out.m_row[0].y=2*quat.x*quat.y-2*quat.w*quat.z;\n"
+	"	out.m_row[0].z=2*quat.x*quat.z+2*quat.w*quat.y;\n"
+	"	out.m_row[0].w = 0.f;\n"
+	"	out.m_row[1].x=2*quat.x*quat.y+2*quat.w*quat.z;\n"
+	"	out.m_row[1].y=1-2*quat2.x-2*quat2.z;\n"
+	"	out.m_row[1].z=2*quat.y*quat.z-2*quat.w*quat.x;\n"
+	"	out.m_row[1].w = 0.f;\n"
+	"	out.m_row[2].x=2*quat.x*quat.z-2*quat.w*quat.y;\n"
+	"	out.m_row[2].y=2*quat.y*quat.z+2*quat.w*quat.x;\n"
+	"	out.m_row[2].z=1-2*quat2.x-2*quat2.y;\n"
+	"	out.m_row[2].w = 0.f;\n"
+	"	return out;\n"
+	"}\n"
+	"inline b3Mat3x3 b3AbsoluteMat3x3(b3Mat3x3ConstArg matIn)\n"
+	"{\n"
+	"	b3Mat3x3 out;\n"
+	"	out.m_row[0] = fabs(matIn.m_row[0]);\n"
+	"	out.m_row[1] = fabs(matIn.m_row[1]);\n"
+	"	out.m_row[2] = fabs(matIn.m_row[2]);\n"
+	"	return out;\n"
+	"}\n"
+	"__inline\n"
+	"b3Mat3x3 mtZero();\n"
+	"__inline\n"
+	"b3Mat3x3 mtIdentity();\n"
+	"__inline\n"
+	"b3Mat3x3 mtTranspose(b3Mat3x3 m);\n"
+	"__inline\n"
+	"b3Mat3x3 mtMul(b3Mat3x3 a, b3Mat3x3 b);\n"
+	"__inline\n"
+	"b3Float4 mtMul1(b3Mat3x3 a, b3Float4 b);\n"
+	"__inline\n"
+	"b3Float4 mtMul3(b3Float4 a, b3Mat3x3 b);\n"
+	"__inline\n"
+	"b3Mat3x3 mtZero()\n"
+	"{\n"
+	"	b3Mat3x3 m;\n"
+	"	m.m_row[0] = (b3Float4)(0.f);\n"
+	"	m.m_row[1] = (b3Float4)(0.f);\n"
+	"	m.m_row[2] = (b3Float4)(0.f);\n"
+	"	return m;\n"
+	"}\n"
+	"__inline\n"
+	"b3Mat3x3 mtIdentity()\n"
+	"{\n"
+	"	b3Mat3x3 m;\n"
+	"	m.m_row[0] = (b3Float4)(1,0,0,0);\n"
+	"	m.m_row[1] = (b3Float4)(0,1,0,0);\n"
+	"	m.m_row[2] = (b3Float4)(0,0,1,0);\n"
+	"	return m;\n"
+	"}\n"
+	"__inline\n"
+	"b3Mat3x3 mtTranspose(b3Mat3x3 m)\n"
+	"{\n"
+	"	b3Mat3x3 out;\n"
+	"	out.m_row[0] = (b3Float4)(m.m_row[0].x, m.m_row[1].x, m.m_row[2].x, 0.f);\n"
+	"	out.m_row[1] = (b3Float4)(m.m_row[0].y, m.m_row[1].y, m.m_row[2].y, 0.f);\n"
+	"	out.m_row[2] = (b3Float4)(m.m_row[0].z, m.m_row[1].z, m.m_row[2].z, 0.f);\n"
+	"	return out;\n"
+	"}\n"
+	"__inline\n"
+	"b3Mat3x3 mtMul(b3Mat3x3 a, b3Mat3x3 b)\n"
+	"{\n"
+	"	b3Mat3x3 transB;\n"
+	"	transB = mtTranspose( b );\n"
+	"	b3Mat3x3 ans;\n"
+	"	//	why this doesn't run when 0ing in the for{}\n"
+	"	a.m_row[0].w = 0.f;\n"
+	"	a.m_row[1].w = 0.f;\n"
+	"	a.m_row[2].w = 0.f;\n"
+	"	for(int i=0; i<3; i++)\n"
+	"	{\n"
+	"//	a.m_row[i].w = 0.f;\n"
+	"		ans.m_row[i].x = b3Dot3F4(a.m_row[i],transB.m_row[0]);\n"
+	"		ans.m_row[i].y = b3Dot3F4(a.m_row[i],transB.m_row[1]);\n"
+	"		ans.m_row[i].z = b3Dot3F4(a.m_row[i],transB.m_row[2]);\n"
+	"		ans.m_row[i].w = 0.f;\n"
+	"	}\n"
+	"	return ans;\n"
+	"}\n"
+	"__inline\n"
+	"b3Float4 mtMul1(b3Mat3x3 a, b3Float4 b)\n"
+	"{\n"
+	"	b3Float4 ans;\n"
+	"	ans.x = b3Dot3F4( a.m_row[0], b );\n"
+	"	ans.y = b3Dot3F4( a.m_row[1], b );\n"
+	"	ans.z = b3Dot3F4( a.m_row[2], b );\n"
+	"	ans.w = 0.f;\n"
+	"	return ans;\n"
+	"}\n"
+	"__inline\n"
+	"b3Float4 mtMul3(b3Float4 a, b3Mat3x3 b)\n"
+	"{\n"
+	"	b3Float4 colx = b3MakeFloat4(b.m_row[0].x, b.m_row[1].x, b.m_row[2].x, 0);\n"
+	"	b3Float4 coly = b3MakeFloat4(b.m_row[0].y, b.m_row[1].y, b.m_row[2].y, 0);\n"
+	"	b3Float4 colz = b3MakeFloat4(b.m_row[0].z, b.m_row[1].z, b.m_row[2].z, 0);\n"
+	"	b3Float4 ans;\n"
+	"	ans.x = b3Dot3F4( a, colx );\n"
+	"	ans.y = b3Dot3F4( a, coly );\n"
+	"	ans.z = b3Dot3F4( a, colz );\n"
+	"	return ans;\n"
+	"}\n"
+	"#endif\n"
+	"#endif //B3_MAT3x3_H\n"
+	"typedef struct b3Aabb b3Aabb_t;\n"
+	"struct b3Aabb\n"
+	"{\n"
+	"	union\n"
+	"	{\n"
+	"		float m_min[4];\n"
+	"		b3Float4 m_minVec;\n"
+	"		int m_minIndices[4];\n"
+	"	};\n"
+	"	union\n"
+	"	{\n"
+	"		float	m_max[4];\n"
+	"		b3Float4 m_maxVec;\n"
+	"		int m_signedMaxIndices[4];\n"
+	"	};\n"
+	"};\n"
+	"inline void b3TransformAabb2(b3Float4ConstArg localAabbMin,b3Float4ConstArg localAabbMax, float margin,\n"
+	"						b3Float4ConstArg pos,\n"
+	"						b3QuatConstArg orn,\n"
+	"						b3Float4* aabbMinOut,b3Float4* aabbMaxOut)\n"
+	"{\n"
+	"		b3Float4 localHalfExtents = 0.5f*(localAabbMax-localAabbMin);\n"
+	"		localHalfExtents+=b3MakeFloat4(margin,margin,margin,0.f);\n"
+	"		b3Float4 localCenter = 0.5f*(localAabbMax+localAabbMin);\n"
+	"		b3Mat3x3 m;\n"
+	"		m = b3QuatGetRotationMatrix(orn);\n"
+	"		b3Mat3x3 abs_b = b3AbsoluteMat3x3(m);\n"
+	"		b3Float4 center = b3TransformPoint(localCenter,pos,orn);\n"
+	"		\n"
+	"		b3Float4 extent = b3MakeFloat4(b3Dot3F4(localHalfExtents,b3GetRow(abs_b,0)),\n"
+	"										 b3Dot3F4(localHalfExtents,b3GetRow(abs_b,1)),\n"
+	"										 b3Dot3F4(localHalfExtents,b3GetRow(abs_b,2)),\n"
+	"										 0.f);\n"
+	"		*aabbMinOut = center-extent;\n"
+	"		*aabbMaxOut = center+extent;\n"
+	"}\n"
+	"/// conservative test for overlap between two aabbs\n"
+	"inline bool b3TestAabbAgainstAabb(b3Float4ConstArg aabbMin1,b3Float4ConstArg aabbMax1,\n"
+	"								b3Float4ConstArg aabbMin2, b3Float4ConstArg aabbMax2)\n"
+	"{\n"
+	"	bool overlap = true;\n"
+	"	overlap = (aabbMin1.x > aabbMax2.x || aabbMax1.x < aabbMin2.x) ? false : overlap;\n"
+	"	overlap = (aabbMin1.z > aabbMax2.z || aabbMax1.z < aabbMin2.z) ? false : overlap;\n"
+	"	overlap = (aabbMin1.y > aabbMax2.y || aabbMax1.y < aabbMin2.y) ? false : overlap;\n"
+	"	return overlap;\n"
+	"}\n"
+	"#endif //B3_AABB_H\n"
+	"#ifndef B3_COLLIDABLE_H\n"
+	"#define B3_COLLIDABLE_H\n"
+	"#ifndef B3_FLOAT4_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif \n"
+	"#endif //B3_FLOAT4_H\n"
+	"#ifndef B3_QUAT_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif \n"
+	"#endif //B3_QUAT_H\n"
+	"enum b3ShapeTypes\n"
+	"{\n"
+	"	SHAPE_HEIGHT_FIELD=1,\n"
+	"	SHAPE_CONVEX_HULL=3,\n"
+	"	SHAPE_PLANE=4,\n"
+	"	SHAPE_CONCAVE_TRIMESH=5,\n"
+	"	SHAPE_COMPOUND_OF_CONVEX_HULLS=6,\n"
+	"	SHAPE_SPHERE=7,\n"
+	"	MAX_NUM_SHAPE_TYPES,\n"
+	"};\n"
+	"typedef struct b3Collidable b3Collidable_t;\n"
+	"struct b3Collidable\n"
+	"{\n"
+	"	union {\n"
+	"		int m_numChildShapes;\n"
+	"		int m_bvhIndex;\n"
+	"	};\n"
+	"	union\n"
+	"	{\n"
+	"		float m_radius;\n"
+	"		int	m_compoundBvhIndex;\n"
+	"	};\n"
+	"	int m_shapeType;\n"
+	"	union\n"
+	"	{\n"
+	"		int m_shapeIndex;\n"
+	"		float m_height;\n"
+	"	};\n"
+	"};\n"
+	"typedef struct b3GpuChildShape b3GpuChildShape_t;\n"
+	"struct b3GpuChildShape\n"
+	"{\n"
+	"	b3Float4	m_childPosition;\n"
+	"	b3Quat		m_childOrientation;\n"
+	"	union\n"
+	"	{\n"
+	"		int			m_shapeIndex;//used for SHAPE_COMPOUND_OF_CONVEX_HULLS\n"
+	"		int			m_capsuleAxis;\n"
+	"	};\n"
+	"	union \n"
+	"	{\n"
+	"		float		m_radius;//used for childshape of SHAPE_COMPOUND_OF_SPHERES or SHAPE_COMPOUND_OF_CAPSULES\n"
+	"		int			m_numChildShapes;//used for compound shape\n"
+	"	};\n"
+	"	union \n"
+	"	{\n"
+	"		float		m_height;//used for childshape of SHAPE_COMPOUND_OF_CAPSULES\n"
+	"		int	m_collidableShapeIndex;\n"
+	"	};\n"
+	"	int			m_shapeType;\n"
+	"};\n"
+	"struct b3CompoundOverlappingPair\n"
+	"{\n"
+	"	int m_bodyIndexA;\n"
+	"	int m_bodyIndexB;\n"
+	"//	int	m_pairType;\n"
+	"	int m_childShapeIndexA;\n"
+	"	int m_childShapeIndexB;\n"
+	"};\n"
+	"#endif //B3_COLLIDABLE_H\n"
+	"#ifndef B3_RIGIDBODY_DATA_H\n"
+	"#define B3_RIGIDBODY_DATA_H\n"
+	"#ifndef B3_FLOAT4_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif \n"
+	"#endif //B3_FLOAT4_H\n"
+	"#ifndef B3_QUAT_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif \n"
+	"#endif //B3_QUAT_H\n"
+	"#ifndef B3_MAT3x3_H\n"
+	"#ifdef __cplusplus\n"
+	"#else\n"
+	"#endif\n"
+	"#endif //B3_MAT3x3_H\n"
+	"typedef struct b3RigidBodyData b3RigidBodyData_t;\n"
+	"struct b3RigidBodyData\n"
+	"{\n"
+	"	b3Float4				m_pos;\n"
+	"	b3Quat					m_quat;\n"
+	"	b3Float4				m_linVel;\n"
+	"	b3Float4				m_angVel;\n"
+	"	int 					m_collidableIdx;\n"
+	"	float 				m_invMass;\n"
+	"	float 				m_restituitionCoeff;\n"
+	"	float 				m_frictionCoeff;\n"
+	"};\n"
+	"typedef struct b3InertiaData b3InertiaData_t;\n"
+	"struct b3InertiaData\n"
+	"{\n"
+	"	b3Mat3x3 m_invInertiaWorld;\n"
+	"	b3Mat3x3 m_initInvInertia;\n"
+	"};\n"
+	"#endif //B3_RIGIDBODY_DATA_H\n"
+	"	\n"
+	"void b3ComputeWorldAabb(  int bodyId, __global const b3RigidBodyData_t* bodies, __global const  b3Collidable_t* collidables, __global const  b3Aabb_t* localShapeAABB, __global b3Aabb_t* worldAabbs)\n"
+	"{\n"
+	"	__global const b3RigidBodyData_t* body = &bodies[bodyId];\n"
+	"	b3Float4 position = body->m_pos;\n"
+	"	b3Quat	orientation = body->m_quat;\n"
+	"	\n"
+	"	int collidableIndex = body->m_collidableIdx;\n"
+	"	int shapeIndex = collidables[collidableIndex].m_shapeIndex;\n"
+	"		\n"
+	"	if (shapeIndex>=0)\n"
+	"	{\n"
+	"				\n"
+	"		b3Aabb_t localAabb = localShapeAABB[collidableIndex];\n"
+	"		b3Aabb_t worldAabb;\n"
+	"		\n"
+	"		b3Float4 aabbAMinOut,aabbAMaxOut;	\n"
+	"		float margin = 0.f;\n"
+	"		b3TransformAabb2(localAabb.m_minVec,localAabb.m_maxVec,margin,position,orientation,&aabbAMinOut,&aabbAMaxOut);\n"
+	"		\n"
+	"		worldAabb.m_minVec =aabbAMinOut;\n"
+	"		worldAabb.m_minIndices[3] = bodyId;\n"
+	"		worldAabb.m_maxVec = aabbAMaxOut;\n"
+	"		worldAabb.m_signedMaxIndices[3] = body[bodyId].m_invMass==0.f? 0 : 1;\n"
+	"		worldAabbs[bodyId] = worldAabb;\n"
+	"	}\n"
+	"}\n"
+	"#endif //B3_UPDATE_AABBS_H\n"
+	"__kernel void initializeGpuAabbsFull(  const int numNodes, __global b3RigidBodyData_t* gBodies,__global b3Collidable_t* collidables, __global b3Aabb_t* plocalShapeAABB, __global b3Aabb_t* pAABB)\n"
+	"{\n"
+	"	int nodeID = get_global_id(0);\n"
+	"	if( nodeID < numNodes )\n"
+	"	{\n"
+	"		b3ComputeWorldAabb(nodeID, gBodies, collidables, plocalShapeAABB,pAABB);\n"
+	"	}\n"
+	"}\n"
+	"__kernel void clearOverlappingPairsKernel(  __global int4* pairs, int numPairs)\n"
+	"{\n"
+	"	int pairId = get_global_id(0);\n"
+	"	if( pairId< numPairs )\n"
+	"	{\n"
+	"		pairs[pairId].z = 0xffffffff;\n"
+	"	}\n"
+	"}\n";
diff --git a/engine/inc/bullet/BulletCollision/BroadphaseCollision/btAxisSweep3.h b/engine/inc/bullet/BulletCollision/BroadphaseCollision/btAxisSweep3.h
new file mode 100644
index 00000000..1e42f25f
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/BroadphaseCollision/btAxisSweep3.h
@@ -0,0 +1,48 @@
+//Bullet Continuous Collision Detection and Physics Library
+//Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+//
+// btAxisSweep3.h
+//
+// Copyright (c) 2006 Simon Hobbs
+//
+// This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+
+#ifndef BT_AXIS_SWEEP_3_H
+#define BT_AXIS_SWEEP_3_H
+
+#include "LinearMath/btVector3.h"
+#include "btOverlappingPairCache.h"
+#include "btBroadphaseInterface.h"
+#include "btBroadphaseProxy.h"
+#include "btOverlappingPairCallback.h"
+#include "btDbvtBroadphase.h"
+#include "btAxisSweep3Internal.h"
+
+/// The btAxisSweep3 is an efficient implementation of the 3d axis sweep and prune broadphase.
+/// It uses arrays rather then lists for storage of the 3 axis. Also it operates using 16 bit integer coordinates instead of floats.
+/// For large worlds and many objects, use bt32BitAxisSweep3 or btDbvtBroadphase instead. bt32BitAxisSweep3 has higher precision and allows more then 16384 objects at the cost of more memory and bit of performance.
+class btAxisSweep3 : public btAxisSweep3Internal<unsigned short int>
+{
+public:
+	btAxisSweep3(const btVector3& worldAabbMin, const btVector3& worldAabbMax, unsigned short int maxHandles = 16384, btOverlappingPairCache* pairCache = 0, bool disableRaycastAccelerator = false);
+};
+
+/// The bt32BitAxisSweep3 allows higher precision quantization and more objects compared to the btAxisSweep3 sweep and prune.
+/// This comes at the cost of more memory per handle, and a bit slower performance.
+/// It uses arrays rather then lists for storage of the 3 axis.
+class bt32BitAxisSweep3 : public btAxisSweep3Internal<unsigned int>
+{
+public:
+	bt32BitAxisSweep3(const btVector3& worldAabbMin, const btVector3& worldAabbMax, unsigned int maxHandles = 1500000, btOverlappingPairCache* pairCache = 0, bool disableRaycastAccelerator = false);
+};
+
+#endif
diff --git a/engine/inc/bullet/BulletCollision/BroadphaseCollision/btAxisSweep3Internal.h b/engine/inc/bullet/BulletCollision/BroadphaseCollision/btAxisSweep3Internal.h
new file mode 100644
index 00000000..2ee35528
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/BroadphaseCollision/btAxisSweep3Internal.h
@@ -0,0 +1,954 @@
+//Bullet Continuous Collision Detection and Physics Library
+//Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+//
+// btAxisSweep3.h
+//
+// Copyright (c) 2006 Simon Hobbs
+//
+// This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+
+#ifndef BT_AXIS_SWEEP_3_INTERNAL_H
+#define BT_AXIS_SWEEP_3_INTERNAL_H
+
+#include "LinearMath/btVector3.h"
+#include "btOverlappingPairCache.h"
+#include "btBroadphaseInterface.h"
+#include "btBroadphaseProxy.h"
+#include "btOverlappingPairCallback.h"
+#include "btDbvtBroadphase.h"
+
+//#define DEBUG_BROADPHASE 1
+#define USE_OVERLAP_TEST_ON_REMOVES 1
+
+/// The internal templace class btAxisSweep3Internal implements the sweep and prune broadphase.
+/// It uses quantized integers to represent the begin and end points for each of the 3 axis.
+/// Dont use this class directly, use btAxisSweep3 or bt32BitAxisSweep3 instead.
+template <typename BP_FP_INT_TYPE>
+class btAxisSweep3Internal : public btBroadphaseInterface
+{
+protected:
+	BP_FP_INT_TYPE m_bpHandleMask;
+	BP_FP_INT_TYPE m_handleSentinel;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	class Edge
+	{
+	public:
+		BP_FP_INT_TYPE m_pos;  // low bit is min/max
+		BP_FP_INT_TYPE m_handle;
+
+		BP_FP_INT_TYPE IsMax() const { return static_cast<BP_FP_INT_TYPE>(m_pos & 1); }
+	};
+
+public:
+	class Handle : public btBroadphaseProxy
+	{
+	public:
+		BT_DECLARE_ALIGNED_ALLOCATOR();
+
+		// indexes into the edge arrays
+		BP_FP_INT_TYPE m_minEdges[3], m_maxEdges[3];  // 6 * 2 = 12
+													  //		BP_FP_INT_TYPE m_uniqueId;
+		btBroadphaseProxy* m_dbvtProxy;               //for faster raycast
+		//void* m_pOwner; this is now in btBroadphaseProxy.m_clientObject
+
+		SIMD_FORCE_INLINE void SetNextFree(BP_FP_INT_TYPE next) { m_minEdges[0] = next; }
+		SIMD_FORCE_INLINE BP_FP_INT_TYPE GetNextFree() const { return m_minEdges[0]; }
+	};  // 24 bytes + 24 for Edge structures = 44 bytes total per entry
+
+protected:
+	btVector3 m_worldAabbMin;  // overall system bounds
+	btVector3 m_worldAabbMax;  // overall system bounds
+
+	btVector3 m_quantize;  // scaling factor for quantization
+
+	BP_FP_INT_TYPE m_numHandles;  // number of active handles
+	BP_FP_INT_TYPE m_maxHandles;  // max number of handles
+	Handle* m_pHandles;           // handles pool
+
+	BP_FP_INT_TYPE m_firstFreeHandle;  // free handles list
+
+	Edge* m_pEdges[3];  // edge arrays for the 3 axes (each array has m_maxHandles * 2 + 2 sentinel entries)
+	void* m_pEdgesRawPtr[3];
+
+	btOverlappingPairCache* m_pairCache;
+
+	///btOverlappingPairCallback is an additional optional user callback for adding/removing overlapping pairs, similar interface to btOverlappingPairCache.
+	btOverlappingPairCallback* m_userPairCallback;
+
+	bool m_ownsPairCache;
+
+	int m_invalidPair;
+
+	///additional dynamic aabb structure, used to accelerate ray cast queries.
+	///can be disabled using a optional argument in the constructor
+	btDbvtBroadphase* m_raycastAccelerator;
+	btOverlappingPairCache* m_nullPairCache;
+
+	// allocation/deallocation
+	BP_FP_INT_TYPE allocHandle();
+	void freeHandle(BP_FP_INT_TYPE handle);
+
+	bool testOverlap2D(const Handle* pHandleA, const Handle* pHandleB, int axis0, int axis1);
+
+#ifdef DEBUG_BROADPHASE
+	void debugPrintAxis(int axis, bool checkCardinality = true);
+#endif  //DEBUG_BROADPHASE
+
+	//Overlap* AddOverlap(BP_FP_INT_TYPE handleA, BP_FP_INT_TYPE handleB);
+	//void RemoveOverlap(BP_FP_INT_TYPE handleA, BP_FP_INT_TYPE handleB);
+
+	void sortMinDown(int axis, BP_FP_INT_TYPE edge, btDispatcher* dispatcher, bool updateOverlaps);
+	void sortMinUp(int axis, BP_FP_INT_TYPE edge, btDispatcher* dispatcher, bool updateOverlaps);
+	void sortMaxDown(int axis, BP_FP_INT_TYPE edge, btDispatcher* dispatcher, bool updateOverlaps);
+	void sortMaxUp(int axis, BP_FP_INT_TYPE edge, btDispatcher* dispatcher, bool updateOverlaps);
+
+public:
+	btAxisSweep3Internal(const btVector3& worldAabbMin, const btVector3& worldAabbMax, BP_FP_INT_TYPE handleMask, BP_FP_INT_TYPE handleSentinel, BP_FP_INT_TYPE maxHandles = 16384, btOverlappingPairCache* pairCache = 0, bool disableRaycastAccelerator = false);
+
+	virtual ~btAxisSweep3Internal();
+
+	BP_FP_INT_TYPE getNumHandles() const
+	{
+		return m_numHandles;
+	}
+
+	virtual void calculateOverlappingPairs(btDispatcher* dispatcher);
+
+	BP_FP_INT_TYPE addHandle(const btVector3& aabbMin, const btVector3& aabbMax, void* pOwner, int collisionFilterGroup, int collisionFilterMask, btDispatcher* dispatcher);
+	void removeHandle(BP_FP_INT_TYPE handle, btDispatcher* dispatcher);
+	void updateHandle(BP_FP_INT_TYPE handle, const btVector3& aabbMin, const btVector3& aabbMax, btDispatcher* dispatcher);
+	SIMD_FORCE_INLINE Handle* getHandle(BP_FP_INT_TYPE index) const { return m_pHandles + index; }
+
+	virtual void resetPool(btDispatcher* dispatcher);
+
+	void processAllOverlappingPairs(btOverlapCallback* callback);
+
+	//Broadphase Interface
+	virtual btBroadphaseProxy* createProxy(const btVector3& aabbMin, const btVector3& aabbMax, int shapeType, void* userPtr, int collisionFilterGroup, int collisionFilterMask, btDispatcher* dispatcher);
+	virtual void destroyProxy(btBroadphaseProxy* proxy, btDispatcher* dispatcher);
+	virtual void setAabb(btBroadphaseProxy* proxy, const btVector3& aabbMin, const btVector3& aabbMax, btDispatcher* dispatcher);
+	virtual void getAabb(btBroadphaseProxy* proxy, btVector3& aabbMin, btVector3& aabbMax) const;
+
+	virtual void rayTest(const btVector3& rayFrom, const btVector3& rayTo, btBroadphaseRayCallback& rayCallback, const btVector3& aabbMin = btVector3(0, 0, 0), const btVector3& aabbMax = btVector3(0, 0, 0));
+	virtual void aabbTest(const btVector3& aabbMin, const btVector3& aabbMax, btBroadphaseAabbCallback& callback);
+
+	void quantize(BP_FP_INT_TYPE* out, const btVector3& point, int isMax) const;
+	///unQuantize should be conservative: aabbMin/aabbMax should be larger then 'getAabb' result
+	void unQuantize(btBroadphaseProxy* proxy, btVector3& aabbMin, btVector3& aabbMax) const;
+
+	bool testAabbOverlap(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1);
+
+	btOverlappingPairCache* getOverlappingPairCache()
+	{
+		return m_pairCache;
+	}
+	const btOverlappingPairCache* getOverlappingPairCache() const
+	{
+		return m_pairCache;
+	}
+
+	void setOverlappingPairUserCallback(btOverlappingPairCallback* pairCallback)
+	{
+		m_userPairCallback = pairCallback;
+	}
+	const btOverlappingPairCallback* getOverlappingPairUserCallback() const
+	{
+		return m_userPairCallback;
+	}
+
+	///getAabb returns the axis aligned bounding box in the 'global' coordinate frame
+	///will add some transform later
+	virtual void getBroadphaseAabb(btVector3& aabbMin, btVector3& aabbMax) const
+	{
+		aabbMin = m_worldAabbMin;
+		aabbMax = m_worldAabbMax;
+	}
+
+	virtual void printStats()
+	{
+		/*		printf("btAxisSweep3.h\n");
+		printf("numHandles = %d, maxHandles = %d\n",m_numHandles,m_maxHandles);
+		printf("aabbMin=%f,%f,%f,aabbMax=%f,%f,%f\n",m_worldAabbMin.getX(),m_worldAabbMin.getY(),m_worldAabbMin.getZ(),
+			m_worldAabbMax.getX(),m_worldAabbMax.getY(),m_worldAabbMax.getZ());
+			*/
+	}
+};
+
+////////////////////////////////////////////////////////////////////
+
+#ifdef DEBUG_BROADPHASE
+#include <stdio.h>
+
+template <typename BP_FP_INT_TYPE>
+void btAxisSweep3<BP_FP_INT_TYPE>::debugPrintAxis(int axis, bool checkCardinality)
+{
+	int numEdges = m_pHandles[0].m_maxEdges[axis];
+	printf("SAP Axis %d, numEdges=%d\n", axis, numEdges);
+
+	int i;
+	for (i = 0; i < numEdges + 1; i++)
+	{
+		Edge* pEdge = m_pEdges[axis] + i;
+		Handle* pHandlePrev = getHandle(pEdge->m_handle);
+		int handleIndex = pEdge->IsMax() ? pHandlePrev->m_maxEdges[axis] : pHandlePrev->m_minEdges[axis];
+		char beginOrEnd;
+		beginOrEnd = pEdge->IsMax() ? 'E' : 'B';
+		printf("	[%c,h=%d,p=%x,i=%d]\n", beginOrEnd, pEdge->m_handle, pEdge->m_pos, handleIndex);
+	}
+
+	if (checkCardinality)
+		btAssert(numEdges == m_numHandles * 2 + 1);
+}
+#endif  //DEBUG_BROADPHASE
+
+template <typename BP_FP_INT_TYPE>
+btBroadphaseProxy* btAxisSweep3Internal<BP_FP_INT_TYPE>::createProxy(const btVector3& aabbMin, const btVector3& aabbMax, int shapeType, void* userPtr, int collisionFilterGroup, int collisionFilterMask, btDispatcher* dispatcher)
+{
+	(void)shapeType;
+	BP_FP_INT_TYPE handleId = addHandle(aabbMin, aabbMax, userPtr, collisionFilterGroup, collisionFilterMask, dispatcher);
+
+	Handle* handle = getHandle(handleId);
+
+	if (m_raycastAccelerator)
+	{
+		btBroadphaseProxy* rayProxy = m_raycastAccelerator->createProxy(aabbMin, aabbMax, shapeType, userPtr, collisionFilterGroup, collisionFilterMask, dispatcher);
+		handle->m_dbvtProxy = rayProxy;
+	}
+	return handle;
+}
+
+template <typename BP_FP_INT_TYPE>
+void btAxisSweep3Internal<BP_FP_INT_TYPE>::destroyProxy(btBroadphaseProxy* proxy, btDispatcher* dispatcher)
+{
+	Handle* handle = static_cast<Handle*>(proxy);
+	if (m_raycastAccelerator)
+		m_raycastAccelerator->destroyProxy(handle->m_dbvtProxy, dispatcher);
+	removeHandle(static_cast<BP_FP_INT_TYPE>(handle->m_uniqueId), dispatcher);
+}
+
+template <typename BP_FP_INT_TYPE>
+void btAxisSweep3Internal<BP_FP_INT_TYPE>::setAabb(btBroadphaseProxy* proxy, const btVector3& aabbMin, const btVector3& aabbMax, btDispatcher* dispatcher)
+{
+	Handle* handle = static_cast<Handle*>(proxy);
+	handle->m_aabbMin = aabbMin;
+	handle->m_aabbMax = aabbMax;
+	updateHandle(static_cast<BP_FP_INT_TYPE>(handle->m_uniqueId), aabbMin, aabbMax, dispatcher);
+	if (m_raycastAccelerator)
+		m_raycastAccelerator->setAabb(handle->m_dbvtProxy, aabbMin, aabbMax, dispatcher);
+}
+
+template <typename BP_FP_INT_TYPE>
+void btAxisSweep3Internal<BP_FP_INT_TYPE>::rayTest(const btVector3& rayFrom, const btVector3& rayTo, btBroadphaseRayCallback& rayCallback, const btVector3& aabbMin, const btVector3& aabbMax)
+{
+	if (m_raycastAccelerator)
+	{
+		m_raycastAccelerator->rayTest(rayFrom, rayTo, rayCallback, aabbMin, aabbMax);
+	}
+	else
+	{
+		//choose axis?
+		BP_FP_INT_TYPE axis = 0;
+		//for each proxy
+		for (BP_FP_INT_TYPE i = 1; i < m_numHandles * 2 + 1; i++)
+		{
+			if (m_pEdges[axis][i].IsMax())
+			{
+				rayCallback.process(getHandle(m_pEdges[axis][i].m_handle));
+			}
+		}
+	}
+}
+
+template <typename BP_FP_INT_TYPE>
+void btAxisSweep3Internal<BP_FP_INT_TYPE>::aabbTest(const btVector3& aabbMin, const btVector3& aabbMax, btBroadphaseAabbCallback& callback)
+{
+	if (m_raycastAccelerator)
+	{
+		m_raycastAccelerator->aabbTest(aabbMin, aabbMax, callback);
+	}
+	else
+	{
+		//choose axis?
+		BP_FP_INT_TYPE axis = 0;
+		//for each proxy
+		for (BP_FP_INT_TYPE i = 1; i < m_numHandles * 2 + 1; i++)
+		{
+			if (m_pEdges[axis][i].IsMax())
+			{
+				Handle* handle = getHandle(m_pEdges[axis][i].m_handle);
+				if (TestAabbAgainstAabb2(aabbMin, aabbMax, handle->m_aabbMin, handle->m_aabbMax))
+				{
+					callback.process(handle);
+				}
+			}
+		}
+	}
+}
+
+template <typename BP_FP_INT_TYPE>
+void btAxisSweep3Internal<BP_FP_INT_TYPE>::getAabb(btBroadphaseProxy* proxy, btVector3& aabbMin, btVector3& aabbMax) const
+{
+	Handle* pHandle = static_cast<Handle*>(proxy);
+	aabbMin = pHandle->m_aabbMin;
+	aabbMax = pHandle->m_aabbMax;
+}
+
+template <typename BP_FP_INT_TYPE>
+void btAxisSweep3Internal<BP_FP_INT_TYPE>::unQuantize(btBroadphaseProxy* proxy, btVector3& aabbMin, btVector3& aabbMax) const
+{
+	Handle* pHandle = static_cast<Handle*>(proxy);
+
+	unsigned short vecInMin[3];
+	unsigned short vecInMax[3];
+
+	vecInMin[0] = m_pEdges[0][pHandle->m_minEdges[0]].m_pos;
+	vecInMax[0] = m_pEdges[0][pHandle->m_maxEdges[0]].m_pos + 1;
+	vecInMin[1] = m_pEdges[1][pHandle->m_minEdges[1]].m_pos;
+	vecInMax[1] = m_pEdges[1][pHandle->m_maxEdges[1]].m_pos + 1;
+	vecInMin[2] = m_pEdges[2][pHandle->m_minEdges[2]].m_pos;
+	vecInMax[2] = m_pEdges[2][pHandle->m_maxEdges[2]].m_pos + 1;
+
+	aabbMin.setValue((btScalar)(vecInMin[0]) / (m_quantize.getX()), (btScalar)(vecInMin[1]) / (m_quantize.getY()), (btScalar)(vecInMin[2]) / (m_quantize.getZ()));
+	aabbMin += m_worldAabbMin;
+
+	aabbMax.setValue((btScalar)(vecInMax[0]) / (m_quantize.getX()), (btScalar)(vecInMax[1]) / (m_quantize.getY()), (btScalar)(vecInMax[2]) / (m_quantize.getZ()));
+	aabbMax += m_worldAabbMin;
+}
+
+template <typename BP_FP_INT_TYPE>
+btAxisSweep3Internal<BP_FP_INT_TYPE>::btAxisSweep3Internal(const btVector3& worldAabbMin, const btVector3& worldAabbMax, BP_FP_INT_TYPE handleMask, BP_FP_INT_TYPE handleSentinel, BP_FP_INT_TYPE userMaxHandles, btOverlappingPairCache* pairCache, bool disableRaycastAccelerator)
+	: m_bpHandleMask(handleMask),
+	  m_handleSentinel(handleSentinel),
+	  m_pairCache(pairCache),
+	  m_userPairCallback(0),
+	  m_ownsPairCache(false),
+	  m_invalidPair(0),
+	  m_raycastAccelerator(0)
+{
+	BP_FP_INT_TYPE maxHandles = static_cast<BP_FP_INT_TYPE>(userMaxHandles + 1);  //need to add one sentinel handle
+
+	if (!m_pairCache)
+	{
+		void* ptr = btAlignedAlloc(sizeof(btHashedOverlappingPairCache), 16);
+		m_pairCache = new (ptr) btHashedOverlappingPairCache();
+		m_ownsPairCache = true;
+	}
+
+	if (!disableRaycastAccelerator)
+	{
+		m_nullPairCache = new (btAlignedAlloc(sizeof(btNullPairCache), 16)) btNullPairCache();
+		m_raycastAccelerator = new (btAlignedAlloc(sizeof(btDbvtBroadphase), 16)) btDbvtBroadphase(m_nullPairCache);  //m_pairCache);
+		m_raycastAccelerator->m_deferedcollide = true;                                                                //don't add/remove pairs
+	}
+
+	//btAssert(bounds.HasVolume());
+
+	// init bounds
+	m_worldAabbMin = worldAabbMin;
+	m_worldAabbMax = worldAabbMax;
+
+	btVector3 aabbSize = m_worldAabbMax - m_worldAabbMin;
+
+	BP_FP_INT_TYPE maxInt = m_handleSentinel;
+
+	m_quantize = btVector3(btScalar(maxInt), btScalar(maxInt), btScalar(maxInt)) / aabbSize;
+
+	// allocate handles buffer, using btAlignedAlloc, and put all handles on free list
+	m_pHandles = new Handle[maxHandles];
+
+	m_maxHandles = maxHandles;
+	m_numHandles = 0;
+
+	// handle 0 is reserved as the null index, and is also used as the sentinel
+	m_firstFreeHandle = 1;
+	{
+		for (BP_FP_INT_TYPE i = m_firstFreeHandle; i < maxHandles; i++)
+			m_pHandles[i].SetNextFree(static_cast<BP_FP_INT_TYPE>(i + 1));
+		m_pHandles[maxHandles - 1].SetNextFree(0);
+	}
+
+	{
+		// allocate edge buffers
+		for (int i = 0; i < 3; i++)
+		{
+			m_pEdgesRawPtr[i] = btAlignedAlloc(sizeof(Edge) * maxHandles * 2, 16);
+			m_pEdges[i] = new (m_pEdgesRawPtr[i]) Edge[maxHandles * 2];
+		}
+	}
+	//removed overlap management
+
+	// make boundary sentinels
+
+	m_pHandles[0].m_clientObject = 0;
+
+	for (int axis = 0; axis < 3; axis++)
+	{
+		m_pHandles[0].m_minEdges[axis] = 0;
+		m_pHandles[0].m_maxEdges[axis] = 1;
+
+		m_pEdges[axis][0].m_pos = 0;
+		m_pEdges[axis][0].m_handle = 0;
+		m_pEdges[axis][1].m_pos = m_handleSentinel;
+		m_pEdges[axis][1].m_handle = 0;
+#ifdef DEBUG_BROADPHASE
+		debugPrintAxis(axis);
+#endif  //DEBUG_BROADPHASE
+	}
+}
+
+template <typename BP_FP_INT_TYPE>
+btAxisSweep3Internal<BP_FP_INT_TYPE>::~btAxisSweep3Internal()
+{
+	if (m_raycastAccelerator)
+	{
+		m_nullPairCache->~btOverlappingPairCache();
+		btAlignedFree(m_nullPairCache);
+		m_raycastAccelerator->~btDbvtBroadphase();
+		btAlignedFree(m_raycastAccelerator);
+	}
+
+	for (int i = 2; i >= 0; i--)
+	{
+		btAlignedFree(m_pEdgesRawPtr[i]);
+	}
+	delete[] m_pHandles;
+
+	if (m_ownsPairCache)
+	{
+		m_pairCache->~btOverlappingPairCache();
+		btAlignedFree(m_pairCache);
+	}
+}
+
+template <typename BP_FP_INT_TYPE>
+void btAxisSweep3Internal<BP_FP_INT_TYPE>::quantize(BP_FP_INT_TYPE* out, const btVector3& point, int isMax) const
+{
+#ifdef OLD_CLAMPING_METHOD
+	///problem with this clamping method is that the floating point during quantization might still go outside the range [(0|isMax) .. (m_handleSentinel&m_bpHandleMask]|isMax]
+	///see http://code.google.com/p/bullet/issues/detail?id=87
+	btVector3 clampedPoint(point);
+	clampedPoint.setMax(m_worldAabbMin);
+	clampedPoint.setMin(m_worldAabbMax);
+	btVector3 v = (clampedPoint - m_worldAabbMin) * m_quantize;
+	out[0] = (BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v.getX() & m_bpHandleMask) | isMax);
+	out[1] = (BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v.getY() & m_bpHandleMask) | isMax);
+	out[2] = (BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v.getZ() & m_bpHandleMask) | isMax);
+#else
+	btVector3 v = (point - m_worldAabbMin) * m_quantize;
+	out[0] = (v[0] <= 0) ? (BP_FP_INT_TYPE)isMax : (v[0] >= m_handleSentinel) ? (BP_FP_INT_TYPE)((m_handleSentinel & m_bpHandleMask) | isMax) : (BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v[0] & m_bpHandleMask) | isMax);
+	out[1] = (v[1] <= 0) ? (BP_FP_INT_TYPE)isMax : (v[1] >= m_handleSentinel) ? (BP_FP_INT_TYPE)((m_handleSentinel & m_bpHandleMask) | isMax) : (BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v[1] & m_bpHandleMask) | isMax);
+	out[2] = (v[2] <= 0) ? (BP_FP_INT_TYPE)isMax : (v[2] >= m_handleSentinel) ? (BP_FP_INT_TYPE)((m_handleSentinel & m_bpHandleMask) | isMax) : (BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v[2] & m_bpHandleMask) | isMax);
+#endif  //OLD_CLAMPING_METHOD
+}
+
+template <typename BP_FP_INT_TYPE>
+BP_FP_INT_TYPE btAxisSweep3Internal<BP_FP_INT_TYPE>::allocHandle()
+{
+	btAssert(m_firstFreeHandle);
+
+	BP_FP_INT_TYPE handle = m_firstFreeHandle;
+	m_firstFreeHandle = getHandle(handle)->GetNextFree();
+	m_numHandles++;
+
+	return handle;
+}
+
+template <typename BP_FP_INT_TYPE>
+void btAxisSweep3Internal<BP_FP_INT_TYPE>::freeHandle(BP_FP_INT_TYPE handle)
+{
+	btAssert(handle > 0 && handle < m_maxHandles);
+
+	getHandle(handle)->SetNextFree(m_firstFreeHandle);
+	m_firstFreeHandle = handle;
+
+	m_numHandles--;
+}
+
+template <typename BP_FP_INT_TYPE>
+BP_FP_INT_TYPE btAxisSweep3Internal<BP_FP_INT_TYPE>::addHandle(const btVector3& aabbMin, const btVector3& aabbMax, void* pOwner, int collisionFilterGroup, int collisionFilterMask, btDispatcher* dispatcher)
+{
+	// quantize the bounds
+	BP_FP_INT_TYPE min[3], max[3];
+	quantize(min, aabbMin, 0);
+	quantize(max, aabbMax, 1);
+
+	// allocate a handle
+	BP_FP_INT_TYPE handle = allocHandle();
+
+	Handle* pHandle = getHandle(handle);
+
+	pHandle->m_uniqueId = static_cast<int>(handle);
+	//pHandle->m_pOverlaps = 0;
+	pHandle->m_clientObject = pOwner;
+	pHandle->m_collisionFilterGroup = collisionFilterGroup;
+	pHandle->m_collisionFilterMask = collisionFilterMask;
+
+	// compute current limit of edge arrays
+	BP_FP_INT_TYPE limit = static_cast<BP_FP_INT_TYPE>(m_numHandles * 2);
+
+	// insert new edges just inside the max boundary edge
+	for (BP_FP_INT_TYPE axis = 0; axis < 3; axis++)
+	{
+		m_pHandles[0].m_maxEdges[axis] += 2;
+
+		m_pEdges[axis][limit + 1] = m_pEdges[axis][limit - 1];
+
+		m_pEdges[axis][limit - 1].m_pos = min[axis];
+		m_pEdges[axis][limit - 1].m_handle = handle;
+
+		m_pEdges[axis][limit].m_pos = max[axis];
+		m_pEdges[axis][limit].m_handle = handle;
+
+		pHandle->m_minEdges[axis] = static_cast<BP_FP_INT_TYPE>(limit - 1);
+		pHandle->m_maxEdges[axis] = limit;
+	}
+
+	// now sort the new edges to their correct position
+	sortMinDown(0, pHandle->m_minEdges[0], dispatcher, false);
+	sortMaxDown(0, pHandle->m_maxEdges[0], dispatcher, false);
+	sortMinDown(1, pHandle->m_minEdges[1], dispatcher, false);
+	sortMaxDown(1, pHandle->m_maxEdges[1], dispatcher, false);
+	sortMinDown(2, pHandle->m_minEdges[2], dispatcher, true);
+	sortMaxDown(2, pHandle->m_maxEdges[2], dispatcher, true);
+
+	return handle;
+}
+
+template <typename BP_FP_INT_TYPE>
+void btAxisSweep3Internal<BP_FP_INT_TYPE>::removeHandle(BP_FP_INT_TYPE handle, btDispatcher* dispatcher)
+{
+	Handle* pHandle = getHandle(handle);
+
+	//explicitly remove the pairs containing the proxy
+	//we could do it also in the sortMinUp (passing true)
+	///@todo: compare performance
+	if (!m_pairCache->hasDeferredRemoval())
+	{
+		m_pairCache->removeOverlappingPairsContainingProxy(pHandle, dispatcher);
+	}
+
+	// compute current limit of edge arrays
+	int limit = static_cast<int>(m_numHandles * 2);
+
+	int axis;
+
+	for (axis = 0; axis < 3; axis++)
+	{
+		m_pHandles[0].m_maxEdges[axis] -= 2;
+	}
+
+	// remove the edges by sorting them up to the end of the list
+	for (axis = 0; axis < 3; axis++)
+	{
+		Edge* pEdges = m_pEdges[axis];
+		BP_FP_INT_TYPE max = pHandle->m_maxEdges[axis];
+		pEdges[max].m_pos = m_handleSentinel;
+
+		sortMaxUp(axis, max, dispatcher, false);
+
+		BP_FP_INT_TYPE i = pHandle->m_minEdges[axis];
+		pEdges[i].m_pos = m_handleSentinel;
+
+		sortMinUp(axis, i, dispatcher, false);
+
+		pEdges[limit - 1].m_handle = 0;
+		pEdges[limit - 1].m_pos = m_handleSentinel;
+
+#ifdef DEBUG_BROADPHASE
+		debugPrintAxis(axis, false);
+#endif  //DEBUG_BROADPHASE
+	}
+
+	// free the handle
+	freeHandle(handle);
+}
+
+template <typename BP_FP_INT_TYPE>
+void btAxisSweep3Internal<BP_FP_INT_TYPE>::resetPool(btDispatcher* /*dispatcher*/)
+{
+	if (m_numHandles == 0)
+	{
+		m_firstFreeHandle = 1;
+		{
+			for (BP_FP_INT_TYPE i = m_firstFreeHandle; i < m_maxHandles; i++)
+				m_pHandles[i].SetNextFree(static_cast<BP_FP_INT_TYPE>(i + 1));
+			m_pHandles[m_maxHandles - 1].SetNextFree(0);
+		}
+	}
+}
+
+//#include <stdio.h>
+
+template <typename BP_FP_INT_TYPE>
+void btAxisSweep3Internal<BP_FP_INT_TYPE>::calculateOverlappingPairs(btDispatcher* dispatcher)
+{
+	if (m_pairCache->hasDeferredRemoval())
+	{
+		btBroadphasePairArray& overlappingPairArray = m_pairCache->getOverlappingPairArray();
+
+		//perform a sort, to find duplicates and to sort 'invalid' pairs to the end
+		overlappingPairArray.quickSort(btBroadphasePairSortPredicate());
+
+		overlappingPairArray.resize(overlappingPairArray.size() - m_invalidPair);
+		m_invalidPair = 0;
+
+		int i;
+
+		btBroadphasePair previousPair;
+		previousPair.m_pProxy0 = 0;
+		previousPair.m_pProxy1 = 0;
+		previousPair.m_algorithm = 0;
+
+		for (i = 0; i < overlappingPairArray.size(); i++)
+		{
+			btBroadphasePair& pair = overlappingPairArray[i];
+
+			bool isDuplicate = (pair == previousPair);
+
+			previousPair = pair;
+
+			bool needsRemoval = false;
+
+			if (!isDuplicate)
+			{
+				///important to use an AABB test that is consistent with the broadphase
+				bool hasOverlap = testAabbOverlap(pair.m_pProxy0, pair.m_pProxy1);
+
+				if (hasOverlap)
+				{
+					needsRemoval = false;  //callback->processOverlap(pair);
+				}
+				else
+				{
+					needsRemoval = true;
+				}
+			}
+			else
+			{
+				//remove duplicate
+				needsRemoval = true;
+				//should have no algorithm
+				btAssert(!pair.m_algorithm);
+			}
+
+			if (needsRemoval)
+			{
+				m_pairCache->cleanOverlappingPair(pair, dispatcher);
+
+				//		m_overlappingPairArray.swap(i,m_overlappingPairArray.size()-1);
+				//		m_overlappingPairArray.pop_back();
+				pair.m_pProxy0 = 0;
+				pair.m_pProxy1 = 0;
+				m_invalidPair++;
+			}
+		}
+
+///if you don't like to skip the invalid pairs in the array, execute following code:
+#define CLEAN_INVALID_PAIRS 1
+#ifdef CLEAN_INVALID_PAIRS
+
+		//perform a sort, to sort 'invalid' pairs to the end
+		overlappingPairArray.quickSort(btBroadphasePairSortPredicate());
+
+		overlappingPairArray.resize(overlappingPairArray.size() - m_invalidPair);
+		m_invalidPair = 0;
+#endif  //CLEAN_INVALID_PAIRS
+
+		//printf("overlappingPairArray.size()=%d\n",overlappingPairArray.size());
+	}
+}
+
+template <typename BP_FP_INT_TYPE>
+bool btAxisSweep3Internal<BP_FP_INT_TYPE>::testAabbOverlap(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1)
+{
+	const Handle* pHandleA = static_cast<Handle*>(proxy0);
+	const Handle* pHandleB = static_cast<Handle*>(proxy1);
+
+	//optimization 1: check the array index (memory address), instead of the m_pos
+
+	for (int axis = 0; axis < 3; axis++)
+	{
+		if (pHandleA->m_maxEdges[axis] < pHandleB->m_minEdges[axis] ||
+			pHandleB->m_maxEdges[axis] < pHandleA->m_minEdges[axis])
+		{
+			return false;
+		}
+	}
+	return true;
+}
+
+template <typename BP_FP_INT_TYPE>
+bool btAxisSweep3Internal<BP_FP_INT_TYPE>::testOverlap2D(const Handle* pHandleA, const Handle* pHandleB, int axis0, int axis1)
+{
+	//optimization 1: check the array index (memory address), instead of the m_pos
+
+	if (pHandleA->m_maxEdges[axis0] < pHandleB->m_minEdges[axis0] ||
+		pHandleB->m_maxEdges[axis0] < pHandleA->m_minEdges[axis0] ||
+		pHandleA->m_maxEdges[axis1] < pHandleB->m_minEdges[axis1] ||
+		pHandleB->m_maxEdges[axis1] < pHandleA->m_minEdges[axis1])
+	{
+		return false;
+	}
+	return true;
+}
+
+template <typename BP_FP_INT_TYPE>
+void btAxisSweep3Internal<BP_FP_INT_TYPE>::updateHandle(BP_FP_INT_TYPE handle, const btVector3& aabbMin, const btVector3& aabbMax, btDispatcher* dispatcher)
+{
+	//	btAssert(bounds.IsFinite());
+	//btAssert(bounds.HasVolume());
+
+	Handle* pHandle = getHandle(handle);
+
+	// quantize the new bounds
+	BP_FP_INT_TYPE min[3], max[3];
+	quantize(min, aabbMin, 0);
+	quantize(max, aabbMax, 1);
+
+	// update changed edges
+	for (int axis = 0; axis < 3; axis++)
+	{
+		BP_FP_INT_TYPE emin = pHandle->m_minEdges[axis];
+		BP_FP_INT_TYPE emax = pHandle->m_maxEdges[axis];
+
+		int dmin = (int)min[axis] - (int)m_pEdges[axis][emin].m_pos;
+		int dmax = (int)max[axis] - (int)m_pEdges[axis][emax].m_pos;
+
+		m_pEdges[axis][emin].m_pos = min[axis];
+		m_pEdges[axis][emax].m_pos = max[axis];
+
+		// expand (only adds overlaps)
+		if (dmin < 0)
+			sortMinDown(axis, emin, dispatcher, true);
+
+		if (dmax > 0)
+			sortMaxUp(axis, emax, dispatcher, true);
+
+		// shrink (only removes overlaps)
+		if (dmin > 0)
+			sortMinUp(axis, emin, dispatcher, true);
+
+		if (dmax < 0)
+			sortMaxDown(axis, emax, dispatcher, true);
+
+#ifdef DEBUG_BROADPHASE
+		debugPrintAxis(axis);
+#endif  //DEBUG_BROADPHASE
+	}
+}
+
+// sorting a min edge downwards can only ever *add* overlaps
+template <typename BP_FP_INT_TYPE>
+void btAxisSweep3Internal<BP_FP_INT_TYPE>::sortMinDown(int axis, BP_FP_INT_TYPE edge, btDispatcher* /* dispatcher */, bool updateOverlaps)
+{
+	Edge* pEdge = m_pEdges[axis] + edge;
+	Edge* pPrev = pEdge - 1;
+	Handle* pHandleEdge = getHandle(pEdge->m_handle);
+
+	while (pEdge->m_pos < pPrev->m_pos)
+	{
+		Handle* pHandlePrev = getHandle(pPrev->m_handle);
+
+		if (pPrev->IsMax())
+		{
+			// if previous edge is a maximum check the bounds and add an overlap if necessary
+			const int axis1 = (1 << axis) & 3;
+			const int axis2 = (1 << axis1) & 3;
+			if (updateOverlaps && testOverlap2D(pHandleEdge, pHandlePrev, axis1, axis2))
+			{
+				m_pairCache->addOverlappingPair(pHandleEdge, pHandlePrev);
+				if (m_userPairCallback)
+					m_userPairCallback->addOverlappingPair(pHandleEdge, pHandlePrev);
+
+				//AddOverlap(pEdge->m_handle, pPrev->m_handle);
+			}
+
+			// update edge reference in other handle
+			pHandlePrev->m_maxEdges[axis]++;
+		}
+		else
+			pHandlePrev->m_minEdges[axis]++;
+
+		pHandleEdge->m_minEdges[axis]--;
+
+		// swap the edges
+		Edge swap = *pEdge;
+		*pEdge = *pPrev;
+		*pPrev = swap;
+
+		// decrement
+		pEdge--;
+		pPrev--;
+	}
+
+#ifdef DEBUG_BROADPHASE
+	debugPrintAxis(axis);
+#endif  //DEBUG_BROADPHASE
+}
+
+// sorting a min edge upwards can only ever *remove* overlaps
+template <typename BP_FP_INT_TYPE>
+void btAxisSweep3Internal<BP_FP_INT_TYPE>::sortMinUp(int axis, BP_FP_INT_TYPE edge, btDispatcher* dispatcher, bool updateOverlaps)
+{
+	Edge* pEdge = m_pEdges[axis] + edge;
+	Edge* pNext = pEdge + 1;
+	Handle* pHandleEdge = getHandle(pEdge->m_handle);
+
+	while (pNext->m_handle && (pEdge->m_pos >= pNext->m_pos))
+	{
+		Handle* pHandleNext = getHandle(pNext->m_handle);
+
+		if (pNext->IsMax())
+		{
+			Handle* handle0 = getHandle(pEdge->m_handle);
+			Handle* handle1 = getHandle(pNext->m_handle);
+			const int axis1 = (1 << axis) & 3;
+			const int axis2 = (1 << axis1) & 3;
+
+			// if next edge is maximum remove any overlap between the two handles
+			if (updateOverlaps
+#ifdef USE_OVERLAP_TEST_ON_REMOVES
+				&& testOverlap2D(handle0, handle1, axis1, axis2)
+#endif  //USE_OVERLAP_TEST_ON_REMOVES
+			)
+			{
+				m_pairCache->removeOverlappingPair(handle0, handle1, dispatcher);
+				if (m_userPairCallback)
+					m_userPairCallback->removeOverlappingPair(handle0, handle1, dispatcher);
+			}
+
+			// update edge reference in other handle
+			pHandleNext->m_maxEdges[axis]--;
+		}
+		else
+			pHandleNext->m_minEdges[axis]--;
+
+		pHandleEdge->m_minEdges[axis]++;
+
+		// swap the edges
+		Edge swap = *pEdge;
+		*pEdge = *pNext;
+		*pNext = swap;
+
+		// increment
+		pEdge++;
+		pNext++;
+	}
+}
+
+// sorting a max edge downwards can only ever *remove* overlaps
+template <typename BP_FP_INT_TYPE>
+void btAxisSweep3Internal<BP_FP_INT_TYPE>::sortMaxDown(int axis, BP_FP_INT_TYPE edge, btDispatcher* dispatcher, bool updateOverlaps)
+{
+	Edge* pEdge = m_pEdges[axis] + edge;
+	Edge* pPrev = pEdge - 1;
+	Handle* pHandleEdge = getHandle(pEdge->m_handle);
+
+	while (pEdge->m_pos < pPrev->m_pos)
+	{
+		Handle* pHandlePrev = getHandle(pPrev->m_handle);
+
+		if (!pPrev->IsMax())
+		{
+			// if previous edge was a minimum remove any overlap between the two handles
+			Handle* handle0 = getHandle(pEdge->m_handle);
+			Handle* handle1 = getHandle(pPrev->m_handle);
+			const int axis1 = (1 << axis) & 3;
+			const int axis2 = (1 << axis1) & 3;
+
+			if (updateOverlaps
+#ifdef USE_OVERLAP_TEST_ON_REMOVES
+				&& testOverlap2D(handle0, handle1, axis1, axis2)
+#endif  //USE_OVERLAP_TEST_ON_REMOVES
+			)
+			{
+				//this is done during the overlappingpairarray iteration/narrowphase collision
+
+				m_pairCache->removeOverlappingPair(handle0, handle1, dispatcher);
+				if (m_userPairCallback)
+					m_userPairCallback->removeOverlappingPair(handle0, handle1, dispatcher);
+			}
+
+			// update edge reference in other handle
+			pHandlePrev->m_minEdges[axis]++;
+			;
+		}
+		else
+			pHandlePrev->m_maxEdges[axis]++;
+
+		pHandleEdge->m_maxEdges[axis]--;
+
+		// swap the edges
+		Edge swap = *pEdge;
+		*pEdge = *pPrev;
+		*pPrev = swap;
+
+		// decrement
+		pEdge--;
+		pPrev--;
+	}
+
+#ifdef DEBUG_BROADPHASE
+	debugPrintAxis(axis);
+#endif  //DEBUG_BROADPHASE
+}
+
+// sorting a max edge upwards can only ever *add* overlaps
+template <typename BP_FP_INT_TYPE>
+void btAxisSweep3Internal<BP_FP_INT_TYPE>::sortMaxUp(int axis, BP_FP_INT_TYPE edge, btDispatcher* /* dispatcher */, bool updateOverlaps)
+{
+	Edge* pEdge = m_pEdges[axis] + edge;
+	Edge* pNext = pEdge + 1;
+	Handle* pHandleEdge = getHandle(pEdge->m_handle);
+
+	while (pNext->m_handle && (pEdge->m_pos >= pNext->m_pos))
+	{
+		Handle* pHandleNext = getHandle(pNext->m_handle);
+
+		const int axis1 = (1 << axis) & 3;
+		const int axis2 = (1 << axis1) & 3;
+
+		if (!pNext->IsMax())
+		{
+			// if next edge is a minimum check the bounds and add an overlap if necessary
+			if (updateOverlaps && testOverlap2D(pHandleEdge, pHandleNext, axis1, axis2))
+			{
+				Handle* handle0 = getHandle(pEdge->m_handle);
+				Handle* handle1 = getHandle(pNext->m_handle);
+				m_pairCache->addOverlappingPair(handle0, handle1);
+				if (m_userPairCallback)
+					m_userPairCallback->addOverlappingPair(handle0, handle1);
+			}
+
+			// update edge reference in other handle
+			pHandleNext->m_minEdges[axis]--;
+		}
+		else
+			pHandleNext->m_maxEdges[axis]--;
+
+		pHandleEdge->m_maxEdges[axis]++;
+
+		// swap the edges
+		Edge swap = *pEdge;
+		*pEdge = *pNext;
+		*pNext = swap;
+
+		// increment
+		pEdge++;
+		pNext++;
+	}
+}
+
+#endif
diff --git a/engine/inc/bullet/BulletCollision/BroadphaseCollision/btBroadphaseInterface.h b/engine/inc/bullet/BulletCollision/BroadphaseCollision/btBroadphaseInterface.h
new file mode 100644
index 00000000..b097eca5
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/BroadphaseCollision/btBroadphaseInterface.h
@@ -0,0 +1,79 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_BROADPHASE_INTERFACE_H
+#define BT_BROADPHASE_INTERFACE_H
+
+struct btDispatcherInfo;
+class btDispatcher;
+#include "btBroadphaseProxy.h"
+
+class btOverlappingPairCache;
+
+struct btBroadphaseAabbCallback
+{
+	virtual ~btBroadphaseAabbCallback() {}
+	virtual bool process(const btBroadphaseProxy* proxy) = 0;
+};
+
+struct btBroadphaseRayCallback : public btBroadphaseAabbCallback
+{
+	///added some cached data to accelerate ray-AABB tests
+	btVector3 m_rayDirectionInverse;
+	unsigned int m_signs[3];
+	btScalar m_lambda_max;
+
+	virtual ~btBroadphaseRayCallback() {}
+
+protected:
+	btBroadphaseRayCallback() {}
+};
+
+#include "LinearMath/btVector3.h"
+
+///The btBroadphaseInterface class provides an interface to detect aabb-overlapping object pairs.
+///Some implementations for this broadphase interface include btAxisSweep3, bt32BitAxisSweep3 and btDbvtBroadphase.
+///The actual overlapping pair management, storage, adding and removing of pairs is dealt by the btOverlappingPairCache class.
+class btBroadphaseInterface
+{
+public:
+	virtual ~btBroadphaseInterface() {}
+
+	virtual btBroadphaseProxy* createProxy(const btVector3& aabbMin, const btVector3& aabbMax, int shapeType, void* userPtr, int collisionFilterGroup, int collisionFilterMask, btDispatcher* dispatcher) = 0;
+	virtual void destroyProxy(btBroadphaseProxy* proxy, btDispatcher* dispatcher) = 0;
+	virtual void setAabb(btBroadphaseProxy* proxy, const btVector3& aabbMin, const btVector3& aabbMax, btDispatcher* dispatcher) = 0;
+	virtual void getAabb(btBroadphaseProxy* proxy, btVector3& aabbMin, btVector3& aabbMax) const = 0;
+
+	virtual void rayTest(const btVector3& rayFrom, const btVector3& rayTo, btBroadphaseRayCallback& rayCallback, const btVector3& aabbMin = btVector3(0, 0, 0), const btVector3& aabbMax = btVector3(0, 0, 0)) = 0;
+
+	virtual void aabbTest(const btVector3& aabbMin, const btVector3& aabbMax, btBroadphaseAabbCallback& callback) = 0;
+
+	///calculateOverlappingPairs is optional: incremental algorithms (sweep and prune) might do it during the set aabb
+	virtual void calculateOverlappingPairs(btDispatcher* dispatcher) = 0;
+
+	virtual btOverlappingPairCache* getOverlappingPairCache() = 0;
+	virtual const btOverlappingPairCache* getOverlappingPairCache() const = 0;
+
+	///getAabb returns the axis aligned bounding box in the 'global' coordinate frame
+	///will add some transform later
+	virtual void getBroadphaseAabb(btVector3& aabbMin, btVector3& aabbMax) const = 0;
+
+	///reset broadphase internal structures, to ensure determinism/reproducability
+	virtual void resetPool(btDispatcher* dispatcher) { (void)dispatcher; };
+
+	virtual void printStats() = 0;
+};
+
+#endif  //BT_BROADPHASE_INTERFACE_H
diff --git a/engine/inc/bullet/BulletCollision/BroadphaseCollision/btBroadphaseProxy.h b/engine/inc/bullet/BulletCollision/BroadphaseCollision/btBroadphaseProxy.h
new file mode 100644
index 00000000..bc0742ad
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/BroadphaseCollision/btBroadphaseProxy.h
@@ -0,0 +1,248 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_BROADPHASE_PROXY_H
+#define BT_BROADPHASE_PROXY_H
+
+#include "LinearMath/btScalar.h"  //for SIMD_FORCE_INLINE
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btAlignedAllocator.h"
+
+/// btDispatcher uses these types
+/// IMPORTANT NOTE:The types are ordered polyhedral, implicit convex and concave
+/// to facilitate type checking
+/// CUSTOM_POLYHEDRAL_SHAPE_TYPE,CUSTOM_CONVEX_SHAPE_TYPE and CUSTOM_CONCAVE_SHAPE_TYPE can be used to extend Bullet without modifying source code
+enum BroadphaseNativeTypes
+{
+	// polyhedral convex shapes
+	BOX_SHAPE_PROXYTYPE,
+	TRIANGLE_SHAPE_PROXYTYPE,
+	TETRAHEDRAL_SHAPE_PROXYTYPE,
+	CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE,
+	CONVEX_HULL_SHAPE_PROXYTYPE,
+	CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE,
+	CUSTOM_POLYHEDRAL_SHAPE_TYPE,
+	//implicit convex shapes
+	IMPLICIT_CONVEX_SHAPES_START_HERE,
+	SPHERE_SHAPE_PROXYTYPE,
+	MULTI_SPHERE_SHAPE_PROXYTYPE,
+	CAPSULE_SHAPE_PROXYTYPE,
+	CONE_SHAPE_PROXYTYPE,
+	CONVEX_SHAPE_PROXYTYPE,
+	CYLINDER_SHAPE_PROXYTYPE,
+	UNIFORM_SCALING_SHAPE_PROXYTYPE,
+	MINKOWSKI_SUM_SHAPE_PROXYTYPE,
+	MINKOWSKI_DIFFERENCE_SHAPE_PROXYTYPE,
+	BOX_2D_SHAPE_PROXYTYPE,
+	CONVEX_2D_SHAPE_PROXYTYPE,
+	CUSTOM_CONVEX_SHAPE_TYPE,
+	//concave shapes
+	CONCAVE_SHAPES_START_HERE,
+	//keep all the convex shapetype below here, for the check IsConvexShape in broadphase proxy!
+	TRIANGLE_MESH_SHAPE_PROXYTYPE,
+	SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE,
+	///used for demo integration FAST/Swift collision library and Bullet
+	FAST_CONCAVE_MESH_PROXYTYPE,
+	//terrain
+	TERRAIN_SHAPE_PROXYTYPE,
+	///Used for GIMPACT Trimesh integration
+	GIMPACT_SHAPE_PROXYTYPE,
+	///Multimaterial mesh
+	MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE,
+
+	EMPTY_SHAPE_PROXYTYPE,
+	STATIC_PLANE_PROXYTYPE,
+	CUSTOM_CONCAVE_SHAPE_TYPE,
+	SDF_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE,
+	CONCAVE_SHAPES_END_HERE,
+
+	COMPOUND_SHAPE_PROXYTYPE,
+
+	SOFTBODY_SHAPE_PROXYTYPE,
+	HFFLUID_SHAPE_PROXYTYPE,
+	HFFLUID_BUOYANT_CONVEX_SHAPE_PROXYTYPE,
+	INVALID_SHAPE_PROXYTYPE,
+
+	MAX_BROADPHASE_COLLISION_TYPES
+
+};
+
+///The btBroadphaseProxy is the main class that can be used with the Bullet broadphases.
+///It stores collision shape type information, collision filter information and a client object, typically a btCollisionObject or btRigidBody.
+ATTRIBUTE_ALIGNED16(struct)
+btBroadphaseProxy
+{
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	///optional filtering to cull potential collisions
+	enum CollisionFilterGroups
+	{
+		DefaultFilter = 1,
+		StaticFilter = 2,
+		KinematicFilter = 4,
+		DebrisFilter = 8,
+		SensorTrigger = 16,
+		CharacterFilter = 32,
+		AllFilter = -1  //all bits sets: DefaultFilter | StaticFilter | KinematicFilter | DebrisFilter | SensorTrigger
+	};
+
+	//Usually the client btCollisionObject or Rigidbody class
+	void* m_clientObject;
+	int m_collisionFilterGroup;
+	int m_collisionFilterMask;
+
+	int m_uniqueId;  //m_uniqueId is introduced for paircache. could get rid of this, by calculating the address offset etc.
+
+	btVector3 m_aabbMin;
+	btVector3 m_aabbMax;
+
+	SIMD_FORCE_INLINE int getUid() const
+	{
+		return m_uniqueId;
+	}
+
+	//used for memory pools
+	btBroadphaseProxy() : m_clientObject(0)
+	{
+	}
+
+	btBroadphaseProxy(const btVector3& aabbMin, const btVector3& aabbMax, void* userPtr, int collisionFilterGroup, int collisionFilterMask)
+		: m_clientObject(userPtr),
+		  m_collisionFilterGroup(collisionFilterGroup),
+		  m_collisionFilterMask(collisionFilterMask),
+		  m_aabbMin(aabbMin),
+		  m_aabbMax(aabbMax)
+	{
+	}
+
+	static SIMD_FORCE_INLINE bool isPolyhedral(int proxyType)
+	{
+		return (proxyType < IMPLICIT_CONVEX_SHAPES_START_HERE);
+	}
+
+	static SIMD_FORCE_INLINE bool isConvex(int proxyType)
+	{
+		return (proxyType < CONCAVE_SHAPES_START_HERE);
+	}
+
+	static SIMD_FORCE_INLINE bool isNonMoving(int proxyType)
+	{
+		return (isConcave(proxyType) && !(proxyType == GIMPACT_SHAPE_PROXYTYPE));
+	}
+
+	static SIMD_FORCE_INLINE bool isConcave(int proxyType)
+	{
+		return ((proxyType > CONCAVE_SHAPES_START_HERE) &&
+				(proxyType < CONCAVE_SHAPES_END_HERE));
+	}
+	static SIMD_FORCE_INLINE bool isCompound(int proxyType)
+	{
+		return (proxyType == COMPOUND_SHAPE_PROXYTYPE);
+	}
+
+	static SIMD_FORCE_INLINE bool isSoftBody(int proxyType)
+	{
+		return (proxyType == SOFTBODY_SHAPE_PROXYTYPE);
+	}
+
+	static SIMD_FORCE_INLINE bool isInfinite(int proxyType)
+	{
+		return (proxyType == STATIC_PLANE_PROXYTYPE);
+	}
+
+	static SIMD_FORCE_INLINE bool isConvex2d(int proxyType)
+	{
+		return (proxyType == BOX_2D_SHAPE_PROXYTYPE) || (proxyType == CONVEX_2D_SHAPE_PROXYTYPE);
+	}
+};
+
+class btCollisionAlgorithm;
+
+struct btBroadphaseProxy;
+
+///The btBroadphasePair class contains a pair of aabb-overlapping objects.
+///A btDispatcher can search a btCollisionAlgorithm that performs exact/narrowphase collision detection on the actual collision shapes.
+ATTRIBUTE_ALIGNED16(struct)
+btBroadphasePair
+{
+	btBroadphasePair()
+		: m_pProxy0(0),
+		  m_pProxy1(0),
+		  m_algorithm(0),
+		  m_internalInfo1(0)
+	{
+	}
+
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btBroadphasePair(btBroadphaseProxy & proxy0, btBroadphaseProxy & proxy1)
+	{
+		//keep them sorted, so the std::set operations work
+		if (proxy0.m_uniqueId < proxy1.m_uniqueId)
+		{
+			m_pProxy0 = &proxy0;
+			m_pProxy1 = &proxy1;
+		}
+		else
+		{
+			m_pProxy0 = &proxy1;
+			m_pProxy1 = &proxy0;
+		}
+
+		m_algorithm = 0;
+		m_internalInfo1 = 0;
+	}
+
+	btBroadphaseProxy* m_pProxy0;
+	btBroadphaseProxy* m_pProxy1;
+
+	mutable btCollisionAlgorithm* m_algorithm;
+	union {
+		void* m_internalInfo1;
+		int m_internalTmpValue;
+	};  //don't use this data, it will be removed in future version.
+};
+
+/*
+//comparison for set operation, see Solid DT_Encounter
+SIMD_FORCE_INLINE bool operator<(const btBroadphasePair& a, const btBroadphasePair& b) 
+{ 
+    return a.m_pProxy0 < b.m_pProxy0 || 
+        (a.m_pProxy0 == b.m_pProxy0 && a.m_pProxy1 < b.m_pProxy1); 
+}
+*/
+
+class btBroadphasePairSortPredicate
+{
+public:
+	bool operator()(const btBroadphasePair& a, const btBroadphasePair& b) const
+	{
+		const int uidA0 = a.m_pProxy0 ? a.m_pProxy0->m_uniqueId : -1;
+		const int uidB0 = b.m_pProxy0 ? b.m_pProxy0->m_uniqueId : -1;
+		const int uidA1 = a.m_pProxy1 ? a.m_pProxy1->m_uniqueId : -1;
+		const int uidB1 = b.m_pProxy1 ? b.m_pProxy1->m_uniqueId : -1;
+
+		return uidA0 > uidB0 ||
+			   (a.m_pProxy0 == b.m_pProxy0 && uidA1 > uidB1) ||
+			   (a.m_pProxy0 == b.m_pProxy0 && a.m_pProxy1 == b.m_pProxy1 && a.m_algorithm > b.m_algorithm);
+	}
+};
+
+SIMD_FORCE_INLINE bool operator==(const btBroadphasePair& a, const btBroadphasePair& b)
+{
+	return (a.m_pProxy0 == b.m_pProxy0) && (a.m_pProxy1 == b.m_pProxy1);
+}
+
+#endif  //BT_BROADPHASE_PROXY_H
diff --git a/engine/inc/bullet/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h b/engine/inc/bullet/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h
new file mode 100644
index 00000000..b00c0b1b
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h
@@ -0,0 +1,75 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_COLLISION_ALGORITHM_H
+#define BT_COLLISION_ALGORITHM_H
+
+#include "LinearMath/btScalar.h"
+#include "LinearMath/btAlignedObjectArray.h"
+
+struct btBroadphaseProxy;
+class btDispatcher;
+class btManifoldResult;
+class btCollisionObject;
+struct btCollisionObjectWrapper;
+struct btDispatcherInfo;
+class btPersistentManifold;
+
+typedef btAlignedObjectArray<btPersistentManifold*> btManifoldArray;
+
+struct btCollisionAlgorithmConstructionInfo
+{
+	btCollisionAlgorithmConstructionInfo()
+		: m_dispatcher1(0),
+		  m_manifold(0)
+	{
+	}
+	btCollisionAlgorithmConstructionInfo(btDispatcher* dispatcher, int temp)
+		: m_dispatcher1(dispatcher)
+	{
+		(void)temp;
+	}
+
+	btDispatcher* m_dispatcher1;
+	btPersistentManifold* m_manifold;
+
+	//	int	getDispatcherId();
+};
+
+///btCollisionAlgorithm is an collision interface that is compatible with the Broadphase and btDispatcher.
+///It is persistent over frames
+class btCollisionAlgorithm
+{
+protected:
+	btDispatcher* m_dispatcher;
+
+protected:
+	//	int	getDispatcherId();
+
+public:
+	btCollisionAlgorithm(){};
+
+	btCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci);
+
+	virtual ~btCollisionAlgorithm(){};
+
+	virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut) = 0;
+
+	virtual btScalar calculateTimeOfImpact(btCollisionObject* body0, btCollisionObject* body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut) = 0;
+
+	virtual void getAllContactManifolds(btManifoldArray& manifoldArray) = 0;
+};
+
+#endif  //BT_COLLISION_ALGORITHM_H
diff --git a/engine/inc/bullet/BulletCollision/BroadphaseCollision/btDbvt.h b/engine/inc/bullet/BulletCollision/BroadphaseCollision/btDbvt.h
new file mode 100644
index 00000000..55daa7fb
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/BroadphaseCollision/btDbvt.h
@@ -0,0 +1,1578 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2007 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+///btDbvt implementation by Nathanael Presson
+
+#ifndef BT_DYNAMIC_BOUNDING_VOLUME_TREE_H
+#define BT_DYNAMIC_BOUNDING_VOLUME_TREE_H
+
+#include "LinearMath/btAlignedObjectArray.h"
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btAabbUtil2.h"
+//
+// Compile time configuration
+//
+
+// Implementation profiles
+#define DBVT_IMPL_GENERIC 0  // Generic implementation
+#define DBVT_IMPL_SSE 1      // SSE
+
+// Template implementation of ICollide
+#ifdef _WIN32
+#if (defined(_MSC_VER) && _MSC_VER >= 1400)
+#define DBVT_USE_TEMPLATE 1
+#else
+#define DBVT_USE_TEMPLATE 0
+#endif
+#else
+#define DBVT_USE_TEMPLATE 0
+#endif
+
+// Use only intrinsics instead of inline asm
+#define DBVT_USE_INTRINSIC_SSE 1
+
+// Using memmov for collideOCL
+#define DBVT_USE_MEMMOVE 1
+
+// Enable benchmarking code
+#define DBVT_ENABLE_BENCHMARK 0
+
+// Inlining
+#define DBVT_INLINE SIMD_FORCE_INLINE
+
+// Specific methods implementation
+
+//SSE gives errors on a MSVC 7.1
+#if defined(BT_USE_SSE)  //&& defined (_WIN32)
+#define DBVT_SELECT_IMPL DBVT_IMPL_SSE
+#define DBVT_MERGE_IMPL DBVT_IMPL_SSE
+#define DBVT_INT0_IMPL DBVT_IMPL_SSE
+#else
+#define DBVT_SELECT_IMPL DBVT_IMPL_GENERIC
+#define DBVT_MERGE_IMPL DBVT_IMPL_GENERIC
+#define DBVT_INT0_IMPL DBVT_IMPL_GENERIC
+#endif
+
+#if (DBVT_SELECT_IMPL == DBVT_IMPL_SSE) || \
+	(DBVT_MERGE_IMPL == DBVT_IMPL_SSE) ||  \
+	(DBVT_INT0_IMPL == DBVT_IMPL_SSE)
+#include <emmintrin.h>
+#endif
+
+//
+// Auto config and checks
+//
+
+#if DBVT_USE_TEMPLATE
+#define DBVT_VIRTUAL
+#define DBVT_VIRTUAL_DTOR(a)
+#define DBVT_PREFIX template <typename T>
+#define DBVT_IPOLICY T& policy
+#define DBVT_CHECKTYPE                           \
+	static const ICollide& typechecker = *(T*)1; \
+	(void)typechecker;
+#else
+#define DBVT_VIRTUAL_DTOR(a) \
+	virtual ~a() {}
+#define DBVT_VIRTUAL virtual
+#define DBVT_PREFIX
+#define DBVT_IPOLICY ICollide& policy
+#define DBVT_CHECKTYPE
+#endif
+
+#if DBVT_USE_MEMMOVE
+#if !defined(__CELLOS_LV2__) && !defined(__MWERKS__)
+#include <memory.h>
+#endif
+#include <string.h>
+#endif
+
+#ifndef DBVT_USE_TEMPLATE
+#error "DBVT_USE_TEMPLATE undefined"
+#endif
+
+#ifndef DBVT_USE_MEMMOVE
+#error "DBVT_USE_MEMMOVE undefined"
+#endif
+
+#ifndef DBVT_ENABLE_BENCHMARK
+#error "DBVT_ENABLE_BENCHMARK undefined"
+#endif
+
+#ifndef DBVT_SELECT_IMPL
+#error "DBVT_SELECT_IMPL undefined"
+#endif
+
+#ifndef DBVT_MERGE_IMPL
+#error "DBVT_MERGE_IMPL undefined"
+#endif
+
+#ifndef DBVT_INT0_IMPL
+#error "DBVT_INT0_IMPL undefined"
+#endif
+
+//
+// Defaults volumes
+//
+
+/* btDbvtAabbMm			*/
+struct btDbvtAabbMm
+{
+    DBVT_INLINE btDbvtAabbMm(){}
+	DBVT_INLINE btVector3 Center() const { return ((mi + mx) / 2); }
+	DBVT_INLINE btVector3 Lengths() const { return (mx - mi); }
+	DBVT_INLINE btVector3 Extents() const { return ((mx - mi) / 2); }
+	DBVT_INLINE const btVector3& Mins() const { return (mi); }
+	DBVT_INLINE const btVector3& Maxs() const { return (mx); }
+	static inline btDbvtAabbMm FromCE(const btVector3& c, const btVector3& e);
+	static inline btDbvtAabbMm FromCR(const btVector3& c, btScalar r);
+	static inline btDbvtAabbMm FromMM(const btVector3& mi, const btVector3& mx);
+	static inline btDbvtAabbMm FromPoints(const btVector3* pts, int n);
+	static inline btDbvtAabbMm FromPoints(const btVector3** ppts, int n);
+	DBVT_INLINE void Expand(const btVector3& e);
+	DBVT_INLINE void SignedExpand(const btVector3& e);
+	DBVT_INLINE bool Contain(const btDbvtAabbMm& a) const;
+	DBVT_INLINE int Classify(const btVector3& n, btScalar o, int s) const;
+	DBVT_INLINE btScalar ProjectMinimum(const btVector3& v, unsigned signs) const;
+	DBVT_INLINE friend bool Intersect(const btDbvtAabbMm& a,
+									  const btDbvtAabbMm& b);
+
+	DBVT_INLINE friend bool Intersect(const btDbvtAabbMm& a,
+									  const btVector3& b);
+
+	DBVT_INLINE friend btScalar Proximity(const btDbvtAabbMm& a,
+										  const btDbvtAabbMm& b);
+	DBVT_INLINE friend int Select(const btDbvtAabbMm& o,
+								  const btDbvtAabbMm& a,
+								  const btDbvtAabbMm& b);
+	DBVT_INLINE friend void Merge(const btDbvtAabbMm& a,
+								  const btDbvtAabbMm& b,
+								  btDbvtAabbMm& r);
+	DBVT_INLINE friend bool NotEqual(const btDbvtAabbMm& a,
+									 const btDbvtAabbMm& b);
+
+	DBVT_INLINE btVector3& tMins() { return (mi); }
+	DBVT_INLINE btVector3& tMaxs() { return (mx); }
+
+private:
+	DBVT_INLINE void AddSpan(const btVector3& d, btScalar& smi, btScalar& smx) const;
+
+private:
+	btVector3 mi, mx;
+};
+
+// Types
+typedef btDbvtAabbMm btDbvtVolume;
+
+/* btDbvtNode				*/
+struct btDbvtNode
+{
+	btDbvtVolume volume;
+	btDbvtNode* parent;
+	DBVT_INLINE bool isleaf() const { return (childs[1] == 0); }
+	DBVT_INLINE bool isinternal() const { return (!isleaf()); }
+	union {
+		btDbvtNode* childs[2];
+		void* data;
+		int dataAsInt;
+	};
+};
+
+/* btDbv(normal)tNode                */
+struct btDbvntNode
+{
+    btDbvtVolume volume;
+    btVector3 normal;
+    btScalar angle;
+    DBVT_INLINE bool isleaf() const { return (childs[1] == 0); }
+    DBVT_INLINE bool isinternal() const { return (!isleaf()); }
+    btDbvntNode* childs[2];
+    void* data;
+
+    btDbvntNode(const btDbvtNode* n)
+    : volume(n->volume)
+    , normal(0,0,0)
+    , angle(0)
+    , data(n->data)
+    {
+        childs[0] = 0;
+        childs[1] = 0;
+    }
+    
+    ~btDbvntNode()
+    {
+        if (childs[0])
+            delete childs[0];
+        if (childs[1])
+            delete childs[1];
+    }
+};
+
+typedef btAlignedObjectArray<const btDbvtNode*> btNodeStack;
+
+///The btDbvt class implements a fast dynamic bounding volume tree based on axis aligned bounding boxes (aabb tree).
+///This btDbvt is used for soft body collision detection and for the btDbvtBroadphase. It has a fast insert, remove and update of nodes.
+///Unlike the btQuantizedBvh, nodes can be dynamically moved around, which allows for change in topology of the underlying data structure.
+struct btDbvt
+{
+	/* Stack element	*/
+	struct sStkNN
+	{
+		const btDbvtNode* a;
+		const btDbvtNode* b;
+		sStkNN() {}
+		sStkNN(const btDbvtNode* na, const btDbvtNode* nb) : a(na), b(nb) {}
+	};
+	struct sStkNP
+	{
+		const btDbvtNode* node;
+		int mask;
+		sStkNP(const btDbvtNode* n, unsigned m) : node(n), mask(m) {}
+	};
+	struct sStkNPS
+	{
+		const btDbvtNode* node;
+		int mask;
+		btScalar value;
+		sStkNPS() {}
+		sStkNPS(const btDbvtNode* n, unsigned m, btScalar v) : node(n), mask(m), value(v) {}
+	};
+	struct sStkCLN
+	{
+		const btDbvtNode* node;
+		btDbvtNode* parent;
+		sStkCLN(const btDbvtNode* n, btDbvtNode* p) : node(n), parent(p) {}
+	};
+    
+    struct sStknNN
+    {
+        const btDbvntNode* a;
+        const btDbvntNode* b;
+        sStknNN() {}
+        sStknNN(const btDbvntNode* na, const btDbvntNode* nb) : a(na), b(nb) {}
+    };
+	// Policies/Interfaces
+
+	/* ICollide	*/
+	struct ICollide
+	{
+		DBVT_VIRTUAL_DTOR(ICollide)
+		DBVT_VIRTUAL void Process(const btDbvtNode*, const btDbvtNode*) {}
+		DBVT_VIRTUAL void Process(const btDbvtNode*) {}
+		DBVT_VIRTUAL void Process(const btDbvtNode* n, btScalar) { Process(n); }
+        DBVT_VIRTUAL void Process(const btDbvntNode*, const btDbvntNode*) {}
+		DBVT_VIRTUAL bool Descent(const btDbvtNode*) { return (true); }
+		DBVT_VIRTUAL bool AllLeaves(const btDbvtNode*) { return (true); }
+	};
+	/* IWriter	*/
+	struct IWriter
+	{
+		virtual ~IWriter() {}
+		virtual void Prepare(const btDbvtNode* root, int numnodes) = 0;
+		virtual void WriteNode(const btDbvtNode*, int index, int parent, int child0, int child1) = 0;
+		virtual void WriteLeaf(const btDbvtNode*, int index, int parent) = 0;
+	};
+	/* IClone	*/
+	struct IClone
+	{
+		virtual ~IClone() {}
+		virtual void CloneLeaf(btDbvtNode*) {}
+	};
+
+	// Constants
+	enum
+	{
+		SIMPLE_STACKSIZE = 64,
+		DOUBLE_STACKSIZE = SIMPLE_STACKSIZE * 2
+	};
+
+	// Fields
+	btDbvtNode* m_root;
+	btDbvtNode* m_free;
+	int m_lkhd;
+	int m_leaves;
+	unsigned m_opath;
+
+	btAlignedObjectArray<sStkNN> m_stkStack;
+
+	// Methods
+	btDbvt();
+	~btDbvt();
+	void clear();
+	bool empty() const { return (0 == m_root); }
+	void optimizeBottomUp();
+	void optimizeTopDown(int bu_treshold = 128);
+	void optimizeIncremental(int passes);
+	btDbvtNode* insert(const btDbvtVolume& box, void* data);
+	void update(btDbvtNode* leaf, int lookahead = -1);
+	void update(btDbvtNode* leaf, btDbvtVolume& volume);
+	bool update(btDbvtNode* leaf, btDbvtVolume& volume, const btVector3& velocity, btScalar margin);
+	bool update(btDbvtNode* leaf, btDbvtVolume& volume, const btVector3& velocity);
+	bool update(btDbvtNode* leaf, btDbvtVolume& volume, btScalar margin);
+	void remove(btDbvtNode* leaf);
+	void write(IWriter* iwriter) const;
+	void clone(btDbvt& dest, IClone* iclone = 0) const;
+	static int maxdepth(const btDbvtNode* node);
+	static int countLeaves(const btDbvtNode* node);
+	static void extractLeaves(const btDbvtNode* node, btAlignedObjectArray<const btDbvtNode*>& leaves);
+#if DBVT_ENABLE_BENCHMARK
+	static void benchmark();
+#else
+	static void benchmark()
+	{
+	}
+#endif
+	// DBVT_IPOLICY must support ICollide policy/interface
+	DBVT_PREFIX
+	static void enumNodes(const btDbvtNode* root,
+						  DBVT_IPOLICY);
+	DBVT_PREFIX
+	static void enumLeaves(const btDbvtNode* root,
+						   DBVT_IPOLICY);
+	DBVT_PREFIX
+	void collideTT(const btDbvtNode* root0,
+				   const btDbvtNode* root1,
+				   DBVT_IPOLICY);
+    DBVT_PREFIX
+    void selfCollideT(const btDbvntNode* root,
+                   DBVT_IPOLICY);
+    DBVT_PREFIX
+    void selfCollideTT(const btDbvtNode* root,
+                      DBVT_IPOLICY);
+
+	DBVT_PREFIX
+	void collideTTpersistentStack(const btDbvtNode* root0,
+								  const btDbvtNode* root1,
+								  DBVT_IPOLICY);
+#if 0
+	DBVT_PREFIX
+		void		collideTT(	const btDbvtNode* root0,
+		const btDbvtNode* root1,
+		const btTransform& xform,
+		DBVT_IPOLICY);
+	DBVT_PREFIX
+		void		collideTT(	const btDbvtNode* root0,
+		const btTransform& xform0,
+		const btDbvtNode* root1,
+		const btTransform& xform1,
+		DBVT_IPOLICY);
+#endif
+
+	DBVT_PREFIX
+	void collideTV(const btDbvtNode* root,
+				   const btDbvtVolume& volume,
+				   DBVT_IPOLICY) const;
+
+	DBVT_PREFIX
+	void collideTVNoStackAlloc(const btDbvtNode* root,
+							   const btDbvtVolume& volume,
+							   btNodeStack& stack,
+							   DBVT_IPOLICY) const;
+
+	///rayTest is a re-entrant ray test, and can be called in parallel as long as the btAlignedAlloc is thread-safe (uses locking etc)
+	///rayTest is slower than rayTestInternal, because it builds a local stack, using memory allocations, and it recomputes signs/rayDirectionInverses each time
+	DBVT_PREFIX
+	static void rayTest(const btDbvtNode* root,
+						const btVector3& rayFrom,
+						const btVector3& rayTo,
+						DBVT_IPOLICY);
+	///rayTestInternal is faster than rayTest, because it uses a persistent stack (to reduce dynamic memory allocations to a minimum) and it uses precomputed signs/rayInverseDirections
+	///rayTestInternal is used by btDbvtBroadphase to accelerate world ray casts
+	DBVT_PREFIX
+	void rayTestInternal(const btDbvtNode* root,
+						 const btVector3& rayFrom,
+						 const btVector3& rayTo,
+						 const btVector3& rayDirectionInverse,
+						 unsigned int signs[3],
+						 btScalar lambda_max,
+						 const btVector3& aabbMin,
+						 const btVector3& aabbMax,
+						 btAlignedObjectArray<const btDbvtNode*>& stack,
+						 DBVT_IPOLICY) const;
+
+	DBVT_PREFIX
+	static void collideKDOP(const btDbvtNode* root,
+							const btVector3* normals,
+							const btScalar* offsets,
+							int count,
+							DBVT_IPOLICY);
+	DBVT_PREFIX
+	static void collideOCL(const btDbvtNode* root,
+						   const btVector3* normals,
+						   const btScalar* offsets,
+						   const btVector3& sortaxis,
+						   int count,
+						   DBVT_IPOLICY,
+						   bool fullsort = true);
+	DBVT_PREFIX
+	static void collideTU(const btDbvtNode* root,
+						  DBVT_IPOLICY);
+	// Helpers
+	static DBVT_INLINE int nearest(const int* i, const btDbvt::sStkNPS* a, btScalar v, int l, int h)
+	{
+		int m = 0;
+		while (l < h)
+		{
+			m = (l + h) >> 1;
+			if (a[i[m]].value >= v)
+				l = m + 1;
+			else
+				h = m;
+		}
+		return (h);
+	}
+	static DBVT_INLINE int allocate(btAlignedObjectArray<int>& ifree,
+									btAlignedObjectArray<sStkNPS>& stock,
+									const sStkNPS& value)
+	{
+		int i;
+		if (ifree.size() > 0)
+		{
+			i = ifree[ifree.size() - 1];
+			ifree.pop_back();
+			stock[i] = value;
+		}
+		else
+		{
+			i = stock.size();
+			stock.push_back(value);
+		}
+		return (i);
+	}
+	//
+private:
+	btDbvt(const btDbvt&) {}
+};
+
+//
+// Inline's
+//
+
+//
+inline btDbvtAabbMm btDbvtAabbMm::FromCE(const btVector3& c, const btVector3& e)
+{
+	btDbvtAabbMm box;
+	box.mi = c - e;
+	box.mx = c + e;
+	return (box);
+}
+
+//
+inline btDbvtAabbMm btDbvtAabbMm::FromCR(const btVector3& c, btScalar r)
+{
+	return (FromCE(c, btVector3(r, r, r)));
+}
+
+//
+inline btDbvtAabbMm btDbvtAabbMm::FromMM(const btVector3& mi, const btVector3& mx)
+{
+	btDbvtAabbMm box;
+	box.mi = mi;
+	box.mx = mx;
+	return (box);
+}
+
+//
+inline btDbvtAabbMm btDbvtAabbMm::FromPoints(const btVector3* pts, int n)
+{
+	btDbvtAabbMm box;
+	box.mi = box.mx = pts[0];
+	for (int i = 1; i < n; ++i)
+	{
+		box.mi.setMin(pts[i]);
+		box.mx.setMax(pts[i]);
+	}
+	return (box);
+}
+
+//
+inline btDbvtAabbMm btDbvtAabbMm::FromPoints(const btVector3** ppts, int n)
+{
+	btDbvtAabbMm box;
+	box.mi = box.mx = *ppts[0];
+	for (int i = 1; i < n; ++i)
+	{
+		box.mi.setMin(*ppts[i]);
+		box.mx.setMax(*ppts[i]);
+	}
+	return (box);
+}
+
+//
+DBVT_INLINE void btDbvtAabbMm::Expand(const btVector3& e)
+{
+	mi -= e;
+	mx += e;
+}
+
+//
+DBVT_INLINE void btDbvtAabbMm::SignedExpand(const btVector3& e)
+{
+	if (e.x() > 0)
+		mx.setX(mx.x() + e[0]);
+	else
+		mi.setX(mi.x() + e[0]);
+	if (e.y() > 0)
+		mx.setY(mx.y() + e[1]);
+	else
+		mi.setY(mi.y() + e[1]);
+	if (e.z() > 0)
+		mx.setZ(mx.z() + e[2]);
+	else
+		mi.setZ(mi.z() + e[2]);
+}
+
+//
+DBVT_INLINE bool btDbvtAabbMm::Contain(const btDbvtAabbMm& a) const
+{
+	return ((mi.x() <= a.mi.x()) &&
+			(mi.y() <= a.mi.y()) &&
+			(mi.z() <= a.mi.z()) &&
+			(mx.x() >= a.mx.x()) &&
+			(mx.y() >= a.mx.y()) &&
+			(mx.z() >= a.mx.z()));
+}
+
+//
+DBVT_INLINE int btDbvtAabbMm::Classify(const btVector3& n, btScalar o, int s) const
+{
+	btVector3 pi, px;
+	switch (s)
+	{
+		case (0 + 0 + 0):
+			px = btVector3(mi.x(), mi.y(), mi.z());
+			pi = btVector3(mx.x(), mx.y(), mx.z());
+			break;
+		case (1 + 0 + 0):
+			px = btVector3(mx.x(), mi.y(), mi.z());
+			pi = btVector3(mi.x(), mx.y(), mx.z());
+			break;
+		case (0 + 2 + 0):
+			px = btVector3(mi.x(), mx.y(), mi.z());
+			pi = btVector3(mx.x(), mi.y(), mx.z());
+			break;
+		case (1 + 2 + 0):
+			px = btVector3(mx.x(), mx.y(), mi.z());
+			pi = btVector3(mi.x(), mi.y(), mx.z());
+			break;
+		case (0 + 0 + 4):
+			px = btVector3(mi.x(), mi.y(), mx.z());
+			pi = btVector3(mx.x(), mx.y(), mi.z());
+			break;
+		case (1 + 0 + 4):
+			px = btVector3(mx.x(), mi.y(), mx.z());
+			pi = btVector3(mi.x(), mx.y(), mi.z());
+			break;
+		case (0 + 2 + 4):
+			px = btVector3(mi.x(), mx.y(), mx.z());
+			pi = btVector3(mx.x(), mi.y(), mi.z());
+			break;
+		case (1 + 2 + 4):
+			px = btVector3(mx.x(), mx.y(), mx.z());
+			pi = btVector3(mi.x(), mi.y(), mi.z());
+			break;
+	}
+	if ((btDot(n, px) + o) < 0) return (-1);
+	if ((btDot(n, pi) + o) >= 0) return (+1);
+	return (0);
+}
+
+//
+DBVT_INLINE btScalar btDbvtAabbMm::ProjectMinimum(const btVector3& v, unsigned signs) const
+{
+	const btVector3* b[] = {&mx, &mi};
+	const btVector3 p(b[(signs >> 0) & 1]->x(),
+					  b[(signs >> 1) & 1]->y(),
+					  b[(signs >> 2) & 1]->z());
+	return (btDot(p, v));
+}
+
+//
+DBVT_INLINE void btDbvtAabbMm::AddSpan(const btVector3& d, btScalar& smi, btScalar& smx) const
+{
+	for (int i = 0; i < 3; ++i)
+	{
+		if (d[i] < 0)
+		{
+			smi += mx[i] * d[i];
+			smx += mi[i] * d[i];
+		}
+		else
+		{
+			smi += mi[i] * d[i];
+			smx += mx[i] * d[i];
+		}
+	}
+}
+
+//
+DBVT_INLINE bool Intersect(const btDbvtAabbMm& a,
+						   const btDbvtAabbMm& b)
+{
+#if DBVT_INT0_IMPL == DBVT_IMPL_SSE
+	const __m128 rt(_mm_or_ps(_mm_cmplt_ps(_mm_load_ps(b.mx), _mm_load_ps(a.mi)),
+							  _mm_cmplt_ps(_mm_load_ps(a.mx), _mm_load_ps(b.mi))));
+#if defined(_WIN32)
+	const __int32* pu((const __int32*)&rt);
+#else
+	const int* pu((const int*)&rt);
+#endif
+	return ((pu[0] | pu[1] | pu[2]) == 0);
+#else
+	return ((a.mi.x() <= b.mx.x()) &&
+			(a.mx.x() >= b.mi.x()) &&
+			(a.mi.y() <= b.mx.y()) &&
+			(a.mx.y() >= b.mi.y()) &&
+			(a.mi.z() <= b.mx.z()) &&
+			(a.mx.z() >= b.mi.z()));
+#endif
+}
+
+//
+DBVT_INLINE bool Intersect(const btDbvtAabbMm& a,
+						   const btVector3& b)
+{
+	return ((b.x() >= a.mi.x()) &&
+			(b.y() >= a.mi.y()) &&
+			(b.z() >= a.mi.z()) &&
+			(b.x() <= a.mx.x()) &&
+			(b.y() <= a.mx.y()) &&
+			(b.z() <= a.mx.z()));
+}
+
+//////////////////////////////////////
+
+//
+DBVT_INLINE btScalar Proximity(const btDbvtAabbMm& a,
+							   const btDbvtAabbMm& b)
+{
+	const btVector3 d = (a.mi + a.mx) - (b.mi + b.mx);
+	return (btFabs(d.x()) + btFabs(d.y()) + btFabs(d.z()));
+}
+
+//
+DBVT_INLINE int Select(const btDbvtAabbMm& o,
+					   const btDbvtAabbMm& a,
+					   const btDbvtAabbMm& b)
+{
+#if DBVT_SELECT_IMPL == DBVT_IMPL_SSE
+
+#if defined(_WIN32)
+	static ATTRIBUTE_ALIGNED16(const unsigned __int32) mask[] = {0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff};
+#else
+	static ATTRIBUTE_ALIGNED16(const unsigned int) mask[] = {0x7fffffff, 0x7fffffff, 0x7fffffff, 0x00000000 /*0x7fffffff*/};
+#endif
+	///@todo: the intrinsic version is 11% slower
+#if DBVT_USE_INTRINSIC_SSE
+
+	union btSSEUnion  ///NOTE: if we use more intrinsics, move btSSEUnion into the LinearMath directory
+	{
+		__m128 ssereg;
+		float floats[4];
+		int ints[4];
+	};
+
+	__m128 omi(_mm_load_ps(o.mi));
+	omi = _mm_add_ps(omi, _mm_load_ps(o.mx));
+	__m128 ami(_mm_load_ps(a.mi));
+	ami = _mm_add_ps(ami, _mm_load_ps(a.mx));
+	ami = _mm_sub_ps(ami, omi);
+	ami = _mm_and_ps(ami, _mm_load_ps((const float*)mask));
+	__m128 bmi(_mm_load_ps(b.mi));
+	bmi = _mm_add_ps(bmi, _mm_load_ps(b.mx));
+	bmi = _mm_sub_ps(bmi, omi);
+	bmi = _mm_and_ps(bmi, _mm_load_ps((const float*)mask));
+	__m128 t0(_mm_movehl_ps(ami, ami));
+	ami = _mm_add_ps(ami, t0);
+	ami = _mm_add_ss(ami, _mm_shuffle_ps(ami, ami, 1));
+	__m128 t1(_mm_movehl_ps(bmi, bmi));
+	bmi = _mm_add_ps(bmi, t1);
+	bmi = _mm_add_ss(bmi, _mm_shuffle_ps(bmi, bmi, 1));
+
+	btSSEUnion tmp;
+	tmp.ssereg = _mm_cmple_ss(bmi, ami);
+	return tmp.ints[0] & 1;
+
+#else
+	ATTRIBUTE_ALIGNED16(__int32 r[1]);
+	__asm
+	{
+		mov		eax,o
+			mov		ecx,a
+			mov		edx,b
+			movaps	xmm0,[eax]
+		movaps	xmm5,mask
+			addps	xmm0,[eax+16]	
+		movaps	xmm1,[ecx]
+		movaps	xmm2,[edx]
+		addps	xmm1,[ecx+16]
+		addps	xmm2,[edx+16]
+		subps	xmm1,xmm0
+			subps	xmm2,xmm0
+			andps	xmm1,xmm5
+			andps	xmm2,xmm5
+			movhlps	xmm3,xmm1
+			movhlps	xmm4,xmm2
+			addps	xmm1,xmm3
+			addps	xmm2,xmm4
+			pshufd	xmm3,xmm1,1
+			pshufd	xmm4,xmm2,1
+			addss	xmm1,xmm3
+			addss	xmm2,xmm4
+			cmpless	xmm2,xmm1
+			movss	r,xmm2
+	}
+	return (r[0] & 1);
+#endif
+#else
+	return (Proximity(o, a) < Proximity(o, b) ? 0 : 1);
+#endif
+}
+
+//
+DBVT_INLINE void Merge(const btDbvtAabbMm& a,
+					   const btDbvtAabbMm& b,
+					   btDbvtAabbMm& r)
+{
+#if DBVT_MERGE_IMPL == DBVT_IMPL_SSE
+	__m128 ami(_mm_load_ps(a.mi));
+	__m128 amx(_mm_load_ps(a.mx));
+	__m128 bmi(_mm_load_ps(b.mi));
+	__m128 bmx(_mm_load_ps(b.mx));
+	ami = _mm_min_ps(ami, bmi);
+	amx = _mm_max_ps(amx, bmx);
+	_mm_store_ps(r.mi, ami);
+	_mm_store_ps(r.mx, amx);
+#else
+	for (int i = 0; i < 3; ++i)
+	{
+		if (a.mi[i] < b.mi[i])
+			r.mi[i] = a.mi[i];
+		else
+			r.mi[i] = b.mi[i];
+		if (a.mx[i] > b.mx[i])
+			r.mx[i] = a.mx[i];
+		else
+			r.mx[i] = b.mx[i];
+	}
+#endif
+}
+
+//
+DBVT_INLINE bool NotEqual(const btDbvtAabbMm& a,
+						  const btDbvtAabbMm& b)
+{
+	return ((a.mi.x() != b.mi.x()) ||
+			(a.mi.y() != b.mi.y()) ||
+			(a.mi.z() != b.mi.z()) ||
+			(a.mx.x() != b.mx.x()) ||
+			(a.mx.y() != b.mx.y()) ||
+			(a.mx.z() != b.mx.z()));
+}
+
+//
+// Inline's
+//
+
+//
+DBVT_PREFIX
+inline void btDbvt::enumNodes(const btDbvtNode* root,
+							  DBVT_IPOLICY)
+{
+	DBVT_CHECKTYPE
+	policy.Process(root);
+	if (root->isinternal())
+	{
+		enumNodes(root->childs[0], policy);
+		enumNodes(root->childs[1], policy);
+	}
+}
+
+//
+DBVT_PREFIX
+inline void btDbvt::enumLeaves(const btDbvtNode* root,
+							   DBVT_IPOLICY)
+{
+	DBVT_CHECKTYPE
+	if (root->isinternal())
+	{
+		enumLeaves(root->childs[0], policy);
+		enumLeaves(root->childs[1], policy);
+	}
+	else
+	{
+		policy.Process(root);
+	}
+}
+
+//
+DBVT_PREFIX
+inline void btDbvt::collideTT(const btDbvtNode* root0,
+							  const btDbvtNode* root1,
+							  DBVT_IPOLICY)
+{
+	DBVT_CHECKTYPE
+	if (root0 && root1)
+	{
+		int depth = 1;
+		int treshold = DOUBLE_STACKSIZE - 4;
+		btAlignedObjectArray<sStkNN> stkStack;
+		stkStack.resize(DOUBLE_STACKSIZE);
+		stkStack[0] = sStkNN(root0, root1);
+		do
+		{
+			sStkNN p = stkStack[--depth];
+			if (depth > treshold)
+			{
+				stkStack.resize(stkStack.size() * 2);
+				treshold = stkStack.size() - 4;
+			}
+			if (p.a == p.b)
+			{
+				if (p.a->isinternal())
+				{
+					stkStack[depth++] = sStkNN(p.a->childs[0], p.a->childs[0]);
+					stkStack[depth++] = sStkNN(p.a->childs[1], p.a->childs[1]);
+					stkStack[depth++] = sStkNN(p.a->childs[0], p.a->childs[1]);
+				}
+			}
+			else if (Intersect(p.a->volume, p.b->volume))
+			{
+				if (p.a->isinternal())
+				{
+					if (p.b->isinternal())
+					{
+						stkStack[depth++] = sStkNN(p.a->childs[0], p.b->childs[0]);
+						stkStack[depth++] = sStkNN(p.a->childs[1], p.b->childs[0]);
+						stkStack[depth++] = sStkNN(p.a->childs[0], p.b->childs[1]);
+						stkStack[depth++] = sStkNN(p.a->childs[1], p.b->childs[1]);
+					}
+					else
+					{
+						stkStack[depth++] = sStkNN(p.a->childs[0], p.b);
+						stkStack[depth++] = sStkNN(p.a->childs[1], p.b);
+					}
+				}
+				else
+				{
+					if (p.b->isinternal())
+					{
+						stkStack[depth++] = sStkNN(p.a, p.b->childs[0]);
+						stkStack[depth++] = sStkNN(p.a, p.b->childs[1]);
+					}
+					else
+					{
+						policy.Process(p.a, p.b);
+					}
+				}
+			}
+		} while (depth);
+	}
+}
+
+//
+DBVT_PREFIX
+inline void btDbvt::selfCollideT(const btDbvntNode* root,
+                              DBVT_IPOLICY)
+{
+    DBVT_CHECKTYPE
+    if (root)
+    {
+        int depth = 1;
+        int treshold = DOUBLE_STACKSIZE - 4;
+        btAlignedObjectArray<sStknNN> stkStack;
+        stkStack.resize(DOUBLE_STACKSIZE);
+        stkStack[0] = sStknNN(root, root);
+        do
+        {
+            sStknNN p = stkStack[--depth];
+            if (depth > treshold)
+            {
+                stkStack.resize(stkStack.size() * 2);
+                treshold = stkStack.size() - 4;
+            }
+            if (p.a == p.b)
+            {
+                if (p.a->isinternal() && p.a->angle > SIMD_PI)
+                {
+                    stkStack[depth++] = sStknNN(p.a->childs[0], p.a->childs[0]);
+                    stkStack[depth++] = sStknNN(p.a->childs[1], p.a->childs[1]);
+                    stkStack[depth++] = sStknNN(p.a->childs[0], p.a->childs[1]);
+                }
+            }
+            else if (Intersect(p.a->volume, p.b->volume))
+            {
+                if (p.a->isinternal())
+                {
+                    if (p.b->isinternal())
+                    {
+                        stkStack[depth++] = sStknNN(p.a->childs[0], p.b->childs[0]);
+                        stkStack[depth++] = sStknNN(p.a->childs[1], p.b->childs[0]);
+                        stkStack[depth++] = sStknNN(p.a->childs[0], p.b->childs[1]);
+                        stkStack[depth++] = sStknNN(p.a->childs[1], p.b->childs[1]);
+                    }
+                    else
+                    {
+                        stkStack[depth++] = sStknNN(p.a->childs[0], p.b);
+                        stkStack[depth++] = sStknNN(p.a->childs[1], p.b);
+                    }
+                }
+                else
+                {
+                    if (p.b->isinternal())
+                    {
+                        stkStack[depth++] = sStknNN(p.a, p.b->childs[0]);
+                        stkStack[depth++] = sStknNN(p.a, p.b->childs[1]);
+                    }
+                    else
+                    {
+                        policy.Process(p.a, p.b);
+                    }
+                }
+            }
+        } while (depth);
+    }
+}
+
+//
+DBVT_PREFIX
+inline void btDbvt::selfCollideTT(const btDbvtNode* root,
+                                 DBVT_IPOLICY)
+{
+    DBVT_CHECKTYPE
+    if (root)
+    {
+        int depth = 1;
+        int treshold = DOUBLE_STACKSIZE - 4;
+        btAlignedObjectArray<sStkNN> stkStack;
+        stkStack.resize(DOUBLE_STACKSIZE);
+        stkStack[0] = sStkNN(root, root);
+        do
+        {
+            sStkNN p = stkStack[--depth];
+            if (depth > treshold)
+            {
+                stkStack.resize(stkStack.size() * 2);
+                treshold = stkStack.size() - 4;
+            }
+            if (p.a == p.b)
+            {
+                if (p.a->isinternal())
+                {
+                    stkStack[depth++] = sStkNN(p.a->childs[0], p.a->childs[0]);
+                    stkStack[depth++] = sStkNN(p.a->childs[1], p.a->childs[1]);
+                    stkStack[depth++] = sStkNN(p.a->childs[0], p.a->childs[1]);
+                }
+            }
+            else if (Intersect(p.a->volume, p.b->volume))
+            {
+                if (p.a->isinternal())
+                {
+                    if (p.b->isinternal())
+                    {
+                        stkStack[depth++] = sStkNN(p.a->childs[0], p.b->childs[0]);
+                        stkStack[depth++] = sStkNN(p.a->childs[1], p.b->childs[0]);
+                        stkStack[depth++] = sStkNN(p.a->childs[0], p.b->childs[1]);
+                        stkStack[depth++] = sStkNN(p.a->childs[1], p.b->childs[1]);
+                    }
+                    else
+                    {
+                        stkStack[depth++] = sStkNN(p.a->childs[0], p.b);
+                        stkStack[depth++] = sStkNN(p.a->childs[1], p.b);
+                    }
+                }
+                else
+                {
+                    if (p.b->isinternal())
+                    {
+                        stkStack[depth++] = sStkNN(p.a, p.b->childs[0]);
+                        stkStack[depth++] = sStkNN(p.a, p.b->childs[1]);
+                    }
+                    else
+                    {
+                        policy.Process(p.a, p.b);
+                    }
+                }
+            }
+        } while (depth);
+    }
+}
+
+
+DBVT_PREFIX
+inline void btDbvt::collideTTpersistentStack(const btDbvtNode* root0,
+											 const btDbvtNode* root1,
+											 DBVT_IPOLICY)
+{
+	DBVT_CHECKTYPE
+	if (root0 && root1)
+	{
+		int depth = 1;
+		int treshold = DOUBLE_STACKSIZE - 4;
+
+		m_stkStack.resize(DOUBLE_STACKSIZE);
+		m_stkStack[0] = sStkNN(root0, root1);
+		do
+		{
+			sStkNN p = m_stkStack[--depth];
+			if (depth > treshold)
+			{
+				m_stkStack.resize(m_stkStack.size() * 2);
+				treshold = m_stkStack.size() - 4;
+			}
+			if (p.a == p.b)
+			{
+				if (p.a->isinternal())
+				{
+					m_stkStack[depth++] = sStkNN(p.a->childs[0], p.a->childs[0]);
+					m_stkStack[depth++] = sStkNN(p.a->childs[1], p.a->childs[1]);
+					m_stkStack[depth++] = sStkNN(p.a->childs[0], p.a->childs[1]);
+				}
+			}
+			else if (Intersect(p.a->volume, p.b->volume))
+			{
+				if (p.a->isinternal())
+				{
+					if (p.b->isinternal())
+					{
+						m_stkStack[depth++] = sStkNN(p.a->childs[0], p.b->childs[0]);
+						m_stkStack[depth++] = sStkNN(p.a->childs[1], p.b->childs[0]);
+						m_stkStack[depth++] = sStkNN(p.a->childs[0], p.b->childs[1]);
+						m_stkStack[depth++] = sStkNN(p.a->childs[1], p.b->childs[1]);
+					}
+					else
+					{
+						m_stkStack[depth++] = sStkNN(p.a->childs[0], p.b);
+						m_stkStack[depth++] = sStkNN(p.a->childs[1], p.b);
+					}
+				}
+				else
+				{
+					if (p.b->isinternal())
+					{
+						m_stkStack[depth++] = sStkNN(p.a, p.b->childs[0]);
+						m_stkStack[depth++] = sStkNN(p.a, p.b->childs[1]);
+					}
+					else
+					{
+						policy.Process(p.a, p.b);
+					}
+				}
+			}
+		} while (depth);
+	}
+}
+
+#if 0
+//
+DBVT_PREFIX
+inline void		btDbvt::collideTT(	const btDbvtNode* root0,
+								  const btDbvtNode* root1,
+								  const btTransform& xform,
+								  DBVT_IPOLICY)
+{
+	DBVT_CHECKTYPE
+		if(root0&&root1)
+		{
+			int								depth=1;
+			int								treshold=DOUBLE_STACKSIZE-4;
+			btAlignedObjectArray<sStkNN>	stkStack;
+			stkStack.resize(DOUBLE_STACKSIZE);
+			stkStack[0]=sStkNN(root0,root1);
+			do	{
+				sStkNN	p=stkStack[--depth];
+				if(Intersect(p.a->volume,p.b->volume,xform))
+				{
+					if(depth>treshold)
+					{
+						stkStack.resize(stkStack.size()*2);
+						treshold=stkStack.size()-4;
+					}
+					if(p.a->isinternal())
+					{
+						if(p.b->isinternal())
+						{					
+							stkStack[depth++]=sStkNN(p.a->childs[0],p.b->childs[0]);
+							stkStack[depth++]=sStkNN(p.a->childs[1],p.b->childs[0]);
+							stkStack[depth++]=sStkNN(p.a->childs[0],p.b->childs[1]);
+							stkStack[depth++]=sStkNN(p.a->childs[1],p.b->childs[1]);
+						}
+						else
+						{
+							stkStack[depth++]=sStkNN(p.a->childs[0],p.b);
+							stkStack[depth++]=sStkNN(p.a->childs[1],p.b);
+						}
+					}
+					else
+					{
+						if(p.b->isinternal())
+						{
+							stkStack[depth++]=sStkNN(p.a,p.b->childs[0]);
+							stkStack[depth++]=sStkNN(p.a,p.b->childs[1]);
+						}
+						else
+						{
+							policy.Process(p.a,p.b);
+						}
+					}
+				}
+			} while(depth);
+		}
+}
+//
+DBVT_PREFIX
+inline void		btDbvt::collideTT(	const btDbvtNode* root0,
+								  const btTransform& xform0,
+								  const btDbvtNode* root1,
+								  const btTransform& xform1,
+								  DBVT_IPOLICY)
+{
+	const btTransform	xform=xform0.inverse()*xform1;
+	collideTT(root0,root1,xform,policy);
+}
+#endif
+
+DBVT_PREFIX
+inline void btDbvt::collideTV(const btDbvtNode* root,
+							  const btDbvtVolume& vol,
+							  DBVT_IPOLICY) const
+{
+	DBVT_CHECKTYPE
+	if (root)
+	{
+		ATTRIBUTE_ALIGNED16(btDbvtVolume)
+		volume(vol);
+		btAlignedObjectArray<const btDbvtNode*> stack;
+		stack.resize(0);
+#ifndef BT_DISABLE_STACK_TEMP_MEMORY
+		char tempmemory[SIMPLE_STACKSIZE * sizeof(const btDbvtNode*)];
+		stack.initializeFromBuffer(tempmemory, 0, SIMPLE_STACKSIZE);
+#else
+		stack.reserve(SIMPLE_STACKSIZE);
+#endif  //BT_DISABLE_STACK_TEMP_MEMORY
+
+		stack.push_back(root);
+		do
+		{
+			const btDbvtNode* n = stack[stack.size() - 1];
+			stack.pop_back();
+			if (Intersect(n->volume, volume))
+			{
+				if (n->isinternal())
+				{
+					stack.push_back(n->childs[0]);
+					stack.push_back(n->childs[1]);
+				}
+				else
+				{
+					policy.Process(n);
+				}
+			}
+		} while (stack.size() > 0);
+	}
+}
+
+//
+DBVT_PREFIX
+inline void btDbvt::collideTVNoStackAlloc(const btDbvtNode* root,
+										  const btDbvtVolume& vol,
+										  btNodeStack& stack,
+										  DBVT_IPOLICY) const
+{
+	DBVT_CHECKTYPE
+	if (root)
+	{
+		ATTRIBUTE_ALIGNED16(btDbvtVolume)
+		volume(vol);
+		stack.resize(0);
+		stack.reserve(SIMPLE_STACKSIZE);
+		stack.push_back(root);
+		do
+		{
+			const btDbvtNode* n = stack[stack.size() - 1];
+			stack.pop_back();
+			if (Intersect(n->volume, volume))
+			{
+				if (n->isinternal())
+				{
+					stack.push_back(n->childs[0]);
+					stack.push_back(n->childs[1]);
+				}
+				else
+				{
+					policy.Process(n);
+				}
+			}
+		} while (stack.size() > 0);
+	}
+}
+
+DBVT_PREFIX
+inline void btDbvt::rayTestInternal(const btDbvtNode* root,
+									const btVector3& rayFrom,
+									const btVector3& rayTo,
+									const btVector3& rayDirectionInverse,
+									unsigned int signs[3],
+									btScalar lambda_max,
+									const btVector3& aabbMin,
+									const btVector3& aabbMax,
+									btAlignedObjectArray<const btDbvtNode*>& stack,
+									DBVT_IPOLICY) const
+{
+	(void)rayTo;
+	DBVT_CHECKTYPE
+	if (root)
+	{
+		btVector3 resultNormal;
+
+		int depth = 1;
+		int treshold = DOUBLE_STACKSIZE - 2;
+		stack.resize(DOUBLE_STACKSIZE);
+		stack[0] = root;
+		btVector3 bounds[2];
+		do
+		{
+			const btDbvtNode* node = stack[--depth];
+			bounds[0] = node->volume.Mins() - aabbMax;
+			bounds[1] = node->volume.Maxs() - aabbMin;
+			btScalar tmin = 1.f, lambda_min = 0.f;
+			unsigned int result1 = false;
+			result1 = btRayAabb2(rayFrom, rayDirectionInverse, signs, bounds, tmin, lambda_min, lambda_max);
+			if (result1)
+			{
+				if (node->isinternal())
+				{
+					if (depth > treshold)
+					{
+						stack.resize(stack.size() * 2);
+						treshold = stack.size() - 2;
+					}
+					stack[depth++] = node->childs[0];
+					stack[depth++] = node->childs[1];
+				}
+				else
+				{
+					policy.Process(node);
+				}
+			}
+		} while (depth);
+	}
+}
+
+//
+DBVT_PREFIX
+inline void btDbvt::rayTest(const btDbvtNode* root,
+							const btVector3& rayFrom,
+							const btVector3& rayTo,
+							DBVT_IPOLICY)
+{
+	DBVT_CHECKTYPE
+	if (root)
+	{
+		btVector3 rayDir = (rayTo - rayFrom);
+		rayDir.normalize();
+
+		///what about division by zero? --> just set rayDirection[i] to INF/BT_LARGE_FLOAT
+		btVector3 rayDirectionInverse;
+		rayDirectionInverse[0] = rayDir[0] == btScalar(0.0) ? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDir[0];
+		rayDirectionInverse[1] = rayDir[1] == btScalar(0.0) ? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDir[1];
+		rayDirectionInverse[2] = rayDir[2] == btScalar(0.0) ? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDir[2];
+		unsigned int signs[3] = {rayDirectionInverse[0] < 0.0, rayDirectionInverse[1] < 0.0, rayDirectionInverse[2] < 0.0};
+
+		btScalar lambda_max = rayDir.dot(rayTo - rayFrom);
+
+		btVector3 resultNormal;
+
+		btAlignedObjectArray<const btDbvtNode*> stack;
+
+		int depth = 1;
+		int treshold = DOUBLE_STACKSIZE - 2;
+
+		char tempmemory[DOUBLE_STACKSIZE * sizeof(const btDbvtNode*)];
+#ifndef BT_DISABLE_STACK_TEMP_MEMORY
+		stack.initializeFromBuffer(tempmemory, DOUBLE_STACKSIZE, DOUBLE_STACKSIZE);
+#else   //BT_DISABLE_STACK_TEMP_MEMORY
+		stack.resize(DOUBLE_STACKSIZE);
+#endif  //BT_DISABLE_STACK_TEMP_MEMORY
+		stack[0] = root;
+		btVector3 bounds[2];
+		do
+		{
+			const btDbvtNode* node = stack[--depth];
+
+			bounds[0] = node->volume.Mins();
+			bounds[1] = node->volume.Maxs();
+
+			btScalar tmin = 1.f, lambda_min = 0.f;
+			unsigned int result1 = btRayAabb2(rayFrom, rayDirectionInverse, signs, bounds, tmin, lambda_min, lambda_max);
+
+#ifdef COMPARE_BTRAY_AABB2
+			btScalar param = 1.f;
+			bool result2 = btRayAabb(rayFrom, rayTo, node->volume.Mins(), node->volume.Maxs(), param, resultNormal);
+			btAssert(result1 == result2);
+#endif  //TEST_BTRAY_AABB2
+
+			if (result1)
+			{
+				if (node->isinternal())
+				{
+					if (depth > treshold)
+					{
+						stack.resize(stack.size() * 2);
+						treshold = stack.size() - 2;
+					}
+					stack[depth++] = node->childs[0];
+					stack[depth++] = node->childs[1];
+				}
+				else
+				{
+					policy.Process(node);
+				}
+			}
+		} while (depth);
+	}
+}
+
+//
+DBVT_PREFIX
+inline void btDbvt::collideKDOP(const btDbvtNode* root,
+								const btVector3* normals,
+								const btScalar* offsets,
+								int count,
+								DBVT_IPOLICY)
+{
+	DBVT_CHECKTYPE
+	if (root)
+	{
+		const int inside = (1 << count) - 1;
+		btAlignedObjectArray<sStkNP> stack;
+		int signs[sizeof(unsigned) * 8];
+		btAssert(count < int(sizeof(signs) / sizeof(signs[0])));
+		for (int i = 0; i < count; ++i)
+		{
+			signs[i] = ((normals[i].x() >= 0) ? 1 : 0) +
+					   ((normals[i].y() >= 0) ? 2 : 0) +
+					   ((normals[i].z() >= 0) ? 4 : 0);
+		}
+		stack.reserve(SIMPLE_STACKSIZE);
+		stack.push_back(sStkNP(root, 0));
+		do
+		{
+			sStkNP se = stack[stack.size() - 1];
+			bool out = false;
+			stack.pop_back();
+			for (int i = 0, j = 1; (!out) && (i < count); ++i, j <<= 1)
+			{
+				if (0 == (se.mask & j))
+				{
+					const int side = se.node->volume.Classify(normals[i], offsets[i], signs[i]);
+					switch (side)
+					{
+						case -1:
+							out = true;
+							break;
+						case +1:
+							se.mask |= j;
+							break;
+					}
+				}
+			}
+			if (!out)
+			{
+				if ((se.mask != inside) && (se.node->isinternal()))
+				{
+					stack.push_back(sStkNP(se.node->childs[0], se.mask));
+					stack.push_back(sStkNP(se.node->childs[1], se.mask));
+				}
+				else
+				{
+					if (policy.AllLeaves(se.node)) enumLeaves(se.node, policy);
+				}
+			}
+		} while (stack.size());
+	}
+}
+
+//
+DBVT_PREFIX
+inline void btDbvt::collideOCL(const btDbvtNode* root,
+							   const btVector3* normals,
+							   const btScalar* offsets,
+							   const btVector3& sortaxis,
+							   int count,
+							   DBVT_IPOLICY,
+							   bool fsort)
+{
+	DBVT_CHECKTYPE
+	if (root)
+	{
+		const unsigned srtsgns = (sortaxis[0] >= 0 ? 1 : 0) +
+								 (sortaxis[1] >= 0 ? 2 : 0) +
+								 (sortaxis[2] >= 0 ? 4 : 0);
+		const int inside = (1 << count) - 1;
+		btAlignedObjectArray<sStkNPS> stock;
+		btAlignedObjectArray<int> ifree;
+		btAlignedObjectArray<int> stack;
+		int signs[sizeof(unsigned) * 8];
+		btAssert(count < int(sizeof(signs) / sizeof(signs[0])));
+		for (int i = 0; i < count; ++i)
+		{
+			signs[i] = ((normals[i].x() >= 0) ? 1 : 0) +
+					   ((normals[i].y() >= 0) ? 2 : 0) +
+					   ((normals[i].z() >= 0) ? 4 : 0);
+		}
+		stock.reserve(SIMPLE_STACKSIZE);
+		stack.reserve(SIMPLE_STACKSIZE);
+		ifree.reserve(SIMPLE_STACKSIZE);
+		stack.push_back(allocate(ifree, stock, sStkNPS(root, 0, root->volume.ProjectMinimum(sortaxis, srtsgns))));
+		do
+		{
+			const int id = stack[stack.size() - 1];
+			sStkNPS se = stock[id];
+			stack.pop_back();
+			ifree.push_back(id);
+			if (se.mask != inside)
+			{
+				bool out = false;
+				for (int i = 0, j = 1; (!out) && (i < count); ++i, j <<= 1)
+				{
+					if (0 == (se.mask & j))
+					{
+						const int side = se.node->volume.Classify(normals[i], offsets[i], signs[i]);
+						switch (side)
+						{
+							case -1:
+								out = true;
+								break;
+							case +1:
+								se.mask |= j;
+								break;
+						}
+					}
+				}
+				if (out) continue;
+			}
+			if (policy.Descent(se.node))
+			{
+				if (se.node->isinternal())
+				{
+					const btDbvtNode* pns[] = {se.node->childs[0], se.node->childs[1]};
+					sStkNPS nes[] = {sStkNPS(pns[0], se.mask, pns[0]->volume.ProjectMinimum(sortaxis, srtsgns)),
+									 sStkNPS(pns[1], se.mask, pns[1]->volume.ProjectMinimum(sortaxis, srtsgns))};
+					const int q = nes[0].value < nes[1].value ? 1 : 0;
+					int j = stack.size();
+					if (fsort && (j > 0))
+					{
+						/* Insert 0	*/
+						j = nearest(&stack[0], &stock[0], nes[q].value, 0, stack.size());
+						stack.push_back(0);
+
+						//void * memmove ( void * destination, const void * source, size_t num );
+
+#if DBVT_USE_MEMMOVE
+						{
+							int num_items_to_move = stack.size() - 1 - j;
+							if (num_items_to_move > 0)
+								memmove(&stack[j + 1], &stack[j], sizeof(int) * num_items_to_move);
+						}
+#else
+						for (int k = stack.size() - 1; k > j; --k)
+						{
+							stack[k] = stack[k - 1];
+						}
+#endif
+						stack[j] = allocate(ifree, stock, nes[q]);
+						/* Insert 1	*/
+						j = nearest(&stack[0], &stock[0], nes[1 - q].value, j, stack.size());
+						stack.push_back(0);
+#if DBVT_USE_MEMMOVE
+						{
+							int num_items_to_move = stack.size() - 1 - j;
+							if (num_items_to_move > 0)
+								memmove(&stack[j + 1], &stack[j], sizeof(int) * num_items_to_move);
+						}
+#else
+						for (int k = stack.size() - 1; k > j; --k)
+						{
+							stack[k] = stack[k - 1];
+						}
+#endif
+						stack[j] = allocate(ifree, stock, nes[1 - q]);
+					}
+					else
+					{
+						stack.push_back(allocate(ifree, stock, nes[q]));
+						stack.push_back(allocate(ifree, stock, nes[1 - q]));
+					}
+				}
+				else
+				{
+					policy.Process(se.node, se.value);
+				}
+			}
+		} while (stack.size());
+	}
+}
+
+//
+DBVT_PREFIX
+inline void btDbvt::collideTU(const btDbvtNode* root,
+							  DBVT_IPOLICY)
+{
+	DBVT_CHECKTYPE
+	if (root)
+	{
+		btAlignedObjectArray<const btDbvtNode*> stack;
+		stack.reserve(SIMPLE_STACKSIZE);
+		stack.push_back(root);
+		do
+		{
+			const btDbvtNode* n = stack[stack.size() - 1];
+			stack.pop_back();
+			if (policy.Descent(n))
+			{
+				if (n->isinternal())
+				{
+					stack.push_back(n->childs[0]);
+					stack.push_back(n->childs[1]);
+				}
+				else
+				{
+					policy.Process(n);
+				}
+			}
+		} while (stack.size() > 0);
+	}
+}
+
+//
+// PP Cleanup
+//
+
+#undef DBVT_USE_MEMMOVE
+#undef DBVT_USE_TEMPLATE
+#undef DBVT_VIRTUAL_DTOR
+#undef DBVT_VIRTUAL
+#undef DBVT_PREFIX
+#undef DBVT_IPOLICY
+#undef DBVT_CHECKTYPE
+#undef DBVT_IMPL_GENERIC
+#undef DBVT_IMPL_SSE
+#undef DBVT_USE_INTRINSIC_SSE
+#undef DBVT_SELECT_IMPL
+#undef DBVT_MERGE_IMPL
+#undef DBVT_INT0_IMPL
+
+#endif
diff --git a/engine/inc/bullet/BulletCollision/BroadphaseCollision/btDbvtBroadphase.h b/engine/inc/bullet/BulletCollision/BroadphaseCollision/btDbvtBroadphase.h
new file mode 100644
index 00000000..a71feef5
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/BroadphaseCollision/btDbvtBroadphase.h
@@ -0,0 +1,146 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+///btDbvtBroadphase implementation by Nathanael Presson
+#ifndef BT_DBVT_BROADPHASE_H
+#define BT_DBVT_BROADPHASE_H
+
+#include "BulletCollision/BroadphaseCollision/btDbvt.h"
+#include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h"
+
+//
+// Compile time config
+//
+
+#define DBVT_BP_PROFILE 0
+//#define DBVT_BP_SORTPAIRS				1
+#define DBVT_BP_PREVENTFALSEUPDATE 0
+#define DBVT_BP_ACCURATESLEEPING 0
+#define DBVT_BP_ENABLE_BENCHMARK 0
+//#define DBVT_BP_MARGIN					(btScalar)0.05
+extern btScalar gDbvtMargin;
+
+#if DBVT_BP_PROFILE
+#define DBVT_BP_PROFILING_RATE 256
+#include "LinearMath/btQuickprof.h"
+#endif
+
+//
+// btDbvtProxy
+//
+struct btDbvtProxy : btBroadphaseProxy
+{
+	/* Fields		*/
+	//btDbvtAabbMm	aabb;
+	btDbvtNode* leaf;
+	btDbvtProxy* links[2];
+	int stage;
+	/* ctor			*/
+	btDbvtProxy(const btVector3& aabbMin, const btVector3& aabbMax, void* userPtr, int collisionFilterGroup, int collisionFilterMask) : btBroadphaseProxy(aabbMin, aabbMax, userPtr, collisionFilterGroup, collisionFilterMask)
+	{
+		links[0] = links[1] = 0;
+	}
+};
+
+typedef btAlignedObjectArray<btDbvtProxy*> btDbvtProxyArray;
+
+///The btDbvtBroadphase implements a broadphase using two dynamic AABB bounding volume hierarchies/trees (see btDbvt).
+///One tree is used for static/non-moving objects, and another tree is used for dynamic objects. Objects can move from one tree to the other.
+///This is a very fast broadphase, especially for very dynamic worlds where many objects are moving. Its insert/add and remove of objects is generally faster than the sweep and prune broadphases btAxisSweep3 and bt32BitAxisSweep3.
+struct btDbvtBroadphase : btBroadphaseInterface
+{
+	/* Config		*/
+	enum
+	{
+		DYNAMIC_SET = 0, /* Dynamic set index	*/
+		FIXED_SET = 1,   /* Fixed set index		*/
+		STAGECOUNT = 2   /* Number of stages		*/
+	};
+	/* Fields		*/
+	btDbvt m_sets[2];                           // Dbvt sets
+	btDbvtProxy* m_stageRoots[STAGECOUNT + 1];  // Stages list
+	btOverlappingPairCache* m_paircache;        // Pair cache
+	btScalar m_prediction;                      // Velocity prediction
+	int m_stageCurrent;                         // Current stage
+	int m_fupdates;                             // % of fixed updates per frame
+	int m_dupdates;                             // % of dynamic updates per frame
+	int m_cupdates;                             // % of cleanup updates per frame
+	int m_newpairs;                             // Number of pairs created
+	int m_fixedleft;                            // Fixed optimization left
+	unsigned m_updates_call;                    // Number of updates call
+	unsigned m_updates_done;                    // Number of updates done
+	btScalar m_updates_ratio;                   // m_updates_done/m_updates_call
+	int m_pid;                                  // Parse id
+	int m_cid;                                  // Cleanup index
+	int m_gid;                                  // Gen id
+	bool m_releasepaircache;                    // Release pair cache on delete
+	bool m_deferedcollide;                      // Defere dynamic/static collision to collide call
+	bool m_needcleanup;                         // Need to run cleanup?
+	btAlignedObjectArray<btAlignedObjectArray<const btDbvtNode*> > m_rayTestStacks;
+#if DBVT_BP_PROFILE
+	btClock m_clock;
+	struct
+	{
+		unsigned long m_total;
+		unsigned long m_ddcollide;
+		unsigned long m_fdcollide;
+		unsigned long m_cleanup;
+		unsigned long m_jobcount;
+	} m_profiling;
+#endif
+	/* Methods		*/
+	btDbvtBroadphase(btOverlappingPairCache* paircache = 0);
+	~btDbvtBroadphase();
+	void collide(btDispatcher* dispatcher);
+	void optimize();
+
+	/* btBroadphaseInterface Implementation	*/
+	btBroadphaseProxy* createProxy(const btVector3& aabbMin, const btVector3& aabbMax, int shapeType, void* userPtr, int collisionFilterGroup, int collisionFilterMask, btDispatcher* dispatcher);
+	virtual void destroyProxy(btBroadphaseProxy* proxy, btDispatcher* dispatcher);
+	virtual void setAabb(btBroadphaseProxy* proxy, const btVector3& aabbMin, const btVector3& aabbMax, btDispatcher* dispatcher);
+	virtual void rayTest(const btVector3& rayFrom, const btVector3& rayTo, btBroadphaseRayCallback& rayCallback, const btVector3& aabbMin = btVector3(0, 0, 0), const btVector3& aabbMax = btVector3(0, 0, 0));
+	virtual void aabbTest(const btVector3& aabbMin, const btVector3& aabbMax, btBroadphaseAabbCallback& callback);
+
+	virtual void getAabb(btBroadphaseProxy* proxy, btVector3& aabbMin, btVector3& aabbMax) const;
+	virtual void calculateOverlappingPairs(btDispatcher* dispatcher);
+	virtual btOverlappingPairCache* getOverlappingPairCache();
+	virtual const btOverlappingPairCache* getOverlappingPairCache() const;
+	virtual void getBroadphaseAabb(btVector3& aabbMin, btVector3& aabbMax) const;
+	virtual void printStats();
+
+	///reset broadphase internal structures, to ensure determinism/reproducability
+	virtual void resetPool(btDispatcher* dispatcher);
+
+	void performDeferredRemoval(btDispatcher* dispatcher);
+
+	void setVelocityPrediction(btScalar prediction)
+	{
+		m_prediction = prediction;
+	}
+	btScalar getVelocityPrediction() const
+	{
+		return m_prediction;
+	}
+
+	///this setAabbForceUpdate is similar to setAabb but always forces the aabb update.
+	///it is not part of the btBroadphaseInterface but specific to btDbvtBroadphase.
+	///it bypasses certain optimizations that prevent aabb updates (when the aabb shrinks), see
+	///http://code.google.com/p/bullet/issues/detail?id=223
+	void setAabbForceUpdate(btBroadphaseProxy* absproxy, const btVector3& aabbMin, const btVector3& aabbMax, btDispatcher* /*dispatcher*/);
+
+	static void benchmark(btBroadphaseInterface*);
+};
+
+#endif
diff --git a/engine/inc/bullet/BulletCollision/BroadphaseCollision/btDispatcher.h b/engine/inc/bullet/BulletCollision/BroadphaseCollision/btDispatcher.h
new file mode 100644
index 00000000..b09b7d4d
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/BroadphaseCollision/btDispatcher.h
@@ -0,0 +1,110 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_DISPATCHER_H
+#define BT_DISPATCHER_H
+#include "LinearMath/btScalar.h"
+
+class btCollisionAlgorithm;
+struct btBroadphaseProxy;
+class btRigidBody;
+class btCollisionObject;
+class btOverlappingPairCache;
+struct btCollisionObjectWrapper;
+
+class btPersistentManifold;
+class btPoolAllocator;
+
+struct btDispatcherInfo
+{
+	enum DispatchFunc
+	{
+		DISPATCH_DISCRETE = 1,
+		DISPATCH_CONTINUOUS
+	};
+	btDispatcherInfo()
+		: m_timeStep(btScalar(0.)),
+		  m_stepCount(0),
+		  m_dispatchFunc(DISPATCH_DISCRETE),
+		  m_timeOfImpact(btScalar(1.)),
+		  m_useContinuous(true),
+		  m_debugDraw(0),
+		  m_enableSatConvex(false),
+		  m_enableSPU(true),
+		  m_useEpa(true),
+		  m_allowedCcdPenetration(btScalar(0.04)),
+		  m_useConvexConservativeDistanceUtil(false),
+		  m_convexConservativeDistanceThreshold(0.0f),
+		  m_deterministicOverlappingPairs(false)
+	{
+	}
+	btScalar m_timeStep;
+	int m_stepCount;
+	int m_dispatchFunc;
+	mutable btScalar m_timeOfImpact;
+	bool m_useContinuous;
+	class btIDebugDraw* m_debugDraw;
+	bool m_enableSatConvex;
+	bool m_enableSPU;
+	bool m_useEpa;
+	btScalar m_allowedCcdPenetration;
+	bool m_useConvexConservativeDistanceUtil;
+	btScalar m_convexConservativeDistanceThreshold;
+	bool m_deterministicOverlappingPairs;
+};
+
+enum ebtDispatcherQueryType
+{
+	BT_CONTACT_POINT_ALGORITHMS = 1,
+	BT_CLOSEST_POINT_ALGORITHMS = 2
+};
+
+///The btDispatcher interface class can be used in combination with broadphase to dispatch calculations for overlapping pairs.
+///For example for pairwise collision detection, calculating contact points stored in btPersistentManifold or user callbacks (game logic).
+class btDispatcher
+{
+public:
+	virtual ~btDispatcher();
+
+	virtual btCollisionAlgorithm* findAlgorithm(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, btPersistentManifold* sharedManifold, ebtDispatcherQueryType queryType) = 0;
+
+	virtual btPersistentManifold* getNewManifold(const btCollisionObject* b0, const btCollisionObject* b1) = 0;
+
+	virtual void releaseManifold(btPersistentManifold* manifold) = 0;
+
+	virtual void clearManifold(btPersistentManifold* manifold) = 0;
+
+	virtual bool needsCollision(const btCollisionObject* body0, const btCollisionObject* body1) = 0;
+
+	virtual bool needsResponse(const btCollisionObject* body0, const btCollisionObject* body1) = 0;
+
+	virtual void dispatchAllCollisionPairs(btOverlappingPairCache* pairCache, const btDispatcherInfo& dispatchInfo, btDispatcher* dispatcher) = 0;
+
+	virtual int getNumManifolds() const = 0;
+
+	virtual btPersistentManifold* getManifoldByIndexInternal(int index) = 0;
+
+	virtual btPersistentManifold** getInternalManifoldPointer() = 0;
+
+	virtual btPoolAllocator* getInternalManifoldPool() = 0;
+
+	virtual const btPoolAllocator* getInternalManifoldPool() const = 0;
+
+	virtual void* allocateCollisionAlgorithm(int size) = 0;
+
+	virtual void freeCollisionAlgorithm(void* ptr) = 0;
+};
+
+#endif  //BT_DISPATCHER_H
diff --git a/engine/inc/bullet/BulletCollision/BroadphaseCollision/btOverlappingPairCache.h b/engine/inc/bullet/BulletCollision/BroadphaseCollision/btOverlappingPairCache.h
new file mode 100644
index 00000000..56011899
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/BroadphaseCollision/btOverlappingPairCache.h
@@ -0,0 +1,434 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_OVERLAPPING_PAIR_CACHE_H
+#define BT_OVERLAPPING_PAIR_CACHE_H
+
+#include "btBroadphaseInterface.h"
+#include "btBroadphaseProxy.h"
+#include "btOverlappingPairCallback.h"
+
+#include "LinearMath/btAlignedObjectArray.h"
+class btDispatcher;
+
+typedef btAlignedObjectArray<btBroadphasePair> btBroadphasePairArray;
+
+struct btOverlapCallback
+{
+	virtual ~btOverlapCallback()
+	{
+	}
+	//return true for deletion of the pair
+	virtual bool processOverlap(btBroadphasePair& pair) = 0;
+};
+
+struct btOverlapFilterCallback
+{
+	virtual ~btOverlapFilterCallback()
+	{
+	}
+	// return true when pairs need collision
+	virtual bool needBroadphaseCollision(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1) const = 0;
+};
+
+const int BT_NULL_PAIR = 0xffffffff;
+
+///The btOverlappingPairCache provides an interface for overlapping pair management (add, remove, storage), used by the btBroadphaseInterface broadphases.
+///The btHashedOverlappingPairCache and btSortedOverlappingPairCache classes are two implementations.
+class btOverlappingPairCache : public btOverlappingPairCallback
+{
+public:
+	virtual ~btOverlappingPairCache() {}  // this is needed so we can get to the derived class destructor
+
+	virtual btBroadphasePair* getOverlappingPairArrayPtr() = 0;
+
+	virtual const btBroadphasePair* getOverlappingPairArrayPtr() const = 0;
+
+	virtual btBroadphasePairArray& getOverlappingPairArray() = 0;
+
+	virtual void cleanOverlappingPair(btBroadphasePair& pair, btDispatcher* dispatcher) = 0;
+
+	virtual int getNumOverlappingPairs() const = 0;
+	virtual bool needsBroadphaseCollision(btBroadphaseProxy * proxy0, btBroadphaseProxy * proxy1) const = 0;
+	virtual btOverlapFilterCallback* getOverlapFilterCallback() = 0;
+	virtual void cleanProxyFromPairs(btBroadphaseProxy* proxy, btDispatcher* dispatcher) = 0;
+
+	virtual void setOverlapFilterCallback(btOverlapFilterCallback* callback) = 0;
+
+	virtual void processAllOverlappingPairs(btOverlapCallback*, btDispatcher* dispatcher) = 0;
+
+	virtual void processAllOverlappingPairs(btOverlapCallback* callback, btDispatcher* dispatcher, const struct btDispatcherInfo& /*dispatchInfo*/)
+	{
+		processAllOverlappingPairs(callback, dispatcher);
+	}
+	virtual btBroadphasePair* findPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1) = 0;
+
+	virtual bool hasDeferredRemoval() = 0;
+
+	virtual void setInternalGhostPairCallback(btOverlappingPairCallback* ghostPairCallback) = 0;
+
+	virtual void sortOverlappingPairs(btDispatcher* dispatcher) = 0;
+};
+
+/// Hash-space based Pair Cache, thanks to Erin Catto, Box2D, http://www.box2d.org, and Pierre Terdiman, Codercorner, http://codercorner.com
+
+ATTRIBUTE_ALIGNED16(class)
+btHashedOverlappingPairCache : public btOverlappingPairCache
+{
+	btBroadphasePairArray m_overlappingPairArray;
+	btOverlapFilterCallback* m_overlapFilterCallback;
+
+protected:
+	btAlignedObjectArray<int> m_hashTable;
+	btAlignedObjectArray<int> m_next;
+	btOverlappingPairCallback* m_ghostPairCallback;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btHashedOverlappingPairCache();
+	virtual ~btHashedOverlappingPairCache();
+
+	void removeOverlappingPairsContainingProxy(btBroadphaseProxy * proxy, btDispatcher * dispatcher);
+
+	virtual void* removeOverlappingPair(btBroadphaseProxy * proxy0, btBroadphaseProxy * proxy1, btDispatcher * dispatcher);
+
+	SIMD_FORCE_INLINE bool needsBroadphaseCollision(btBroadphaseProxy * proxy0, btBroadphaseProxy * proxy1) const
+	{
+		if (m_overlapFilterCallback)
+			return m_overlapFilterCallback->needBroadphaseCollision(proxy0, proxy1);
+
+		bool collides = (proxy0->m_collisionFilterGroup & proxy1->m_collisionFilterMask) != 0;
+		collides = collides && (proxy1->m_collisionFilterGroup & proxy0->m_collisionFilterMask);
+
+		return collides;
+	}
+
+	// Add a pair and return the new pair. If the pair already exists,
+	// no new pair is created and the old one is returned.
+	virtual btBroadphasePair* addOverlappingPair(btBroadphaseProxy * proxy0, btBroadphaseProxy * proxy1)
+	{
+		if (!needsBroadphaseCollision(proxy0, proxy1))
+			return 0;
+
+		return internalAddPair(proxy0, proxy1);
+	}
+
+	void cleanProxyFromPairs(btBroadphaseProxy * proxy, btDispatcher * dispatcher);
+
+	virtual void processAllOverlappingPairs(btOverlapCallback*, btDispatcher * dispatcher);
+
+	virtual void processAllOverlappingPairs(btOverlapCallback * callback, btDispatcher * dispatcher, const struct btDispatcherInfo& dispatchInfo);
+
+	virtual btBroadphasePair* getOverlappingPairArrayPtr()
+	{
+		return &m_overlappingPairArray[0];
+	}
+
+	const btBroadphasePair* getOverlappingPairArrayPtr() const
+	{
+		return &m_overlappingPairArray[0];
+	}
+
+	btBroadphasePairArray& getOverlappingPairArray()
+	{
+		return m_overlappingPairArray;
+	}
+
+	const btBroadphasePairArray& getOverlappingPairArray() const
+	{
+		return m_overlappingPairArray;
+	}
+
+	void cleanOverlappingPair(btBroadphasePair & pair, btDispatcher * dispatcher);
+
+	btBroadphasePair* findPair(btBroadphaseProxy * proxy0, btBroadphaseProxy * proxy1);
+
+	int GetCount() const { return m_overlappingPairArray.size(); }
+	//	btBroadphasePair* GetPairs() { return m_pairs; }
+
+	btOverlapFilterCallback* getOverlapFilterCallback()
+	{
+		return m_overlapFilterCallback;
+	}
+
+	void setOverlapFilterCallback(btOverlapFilterCallback * callback)
+	{
+		m_overlapFilterCallback = callback;
+	}
+
+	int getNumOverlappingPairs() const
+	{
+		return m_overlappingPairArray.size();
+	}
+
+private:
+	btBroadphasePair* internalAddPair(btBroadphaseProxy * proxy0, btBroadphaseProxy * proxy1);
+
+	void growTables();
+
+	SIMD_FORCE_INLINE bool equalsPair(const btBroadphasePair& pair, int proxyId1, int proxyId2)
+	{
+		return pair.m_pProxy0->getUid() == proxyId1 && pair.m_pProxy1->getUid() == proxyId2;
+	}
+
+	/*
+	// Thomas Wang's hash, see: http://www.concentric.net/~Ttwang/tech/inthash.htm
+	// This assumes proxyId1 and proxyId2 are 16-bit.
+	SIMD_FORCE_INLINE int getHash(int proxyId1, int proxyId2)
+	{
+		int key = (proxyId2 << 16) | proxyId1;
+		key = ~key + (key << 15);
+		key = key ^ (key >> 12);
+		key = key + (key << 2);
+		key = key ^ (key >> 4);
+		key = key * 2057;
+		key = key ^ (key >> 16);
+		return key;
+	}
+	*/
+
+	SIMD_FORCE_INLINE unsigned int getHash(unsigned int proxyId1, unsigned int proxyId2)
+	{
+		unsigned int key = proxyId1 | (proxyId2 << 16);
+		// Thomas Wang's hash
+
+		key += ~(key << 15);
+		key ^= (key >> 10);
+		key += (key << 3);
+		key ^= (key >> 6);
+		key += ~(key << 11);
+		key ^= (key >> 16);
+		return key;
+	}
+
+	SIMD_FORCE_INLINE btBroadphasePair* internalFindPair(btBroadphaseProxy * proxy0, btBroadphaseProxy * proxy1, int hash)
+	{
+		int proxyId1 = proxy0->getUid();
+		int proxyId2 = proxy1->getUid();
+#if 0  // wrong, 'equalsPair' use unsorted uids, copy-past devil striked again. Nat.
+		if (proxyId1 > proxyId2) 
+			btSwap(proxyId1, proxyId2);
+#endif
+
+		int index = m_hashTable[hash];
+
+		while (index != BT_NULL_PAIR && equalsPair(m_overlappingPairArray[index], proxyId1, proxyId2) == false)
+		{
+			index = m_next[index];
+		}
+
+		if (index == BT_NULL_PAIR)
+		{
+			return NULL;
+		}
+
+		btAssert(index < m_overlappingPairArray.size());
+
+		return &m_overlappingPairArray[index];
+	}
+
+	virtual bool hasDeferredRemoval()
+	{
+		return false;
+	}
+
+	virtual void setInternalGhostPairCallback(btOverlappingPairCallback * ghostPairCallback)
+	{
+		m_ghostPairCallback = ghostPairCallback;
+	}
+
+	virtual void sortOverlappingPairs(btDispatcher * dispatcher);
+};
+
+///btSortedOverlappingPairCache maintains the objects with overlapping AABB
+///Typically managed by the Broadphase, Axis3Sweep or btSimpleBroadphase
+class btSortedOverlappingPairCache : public btOverlappingPairCache
+{
+protected:
+	//avoid brute-force finding all the time
+	btBroadphasePairArray m_overlappingPairArray;
+
+	//during the dispatch, check that user doesn't destroy/create proxy
+	bool m_blockedForChanges;
+
+	///by default, do the removal during the pair traversal
+	bool m_hasDeferredRemoval;
+
+	//if set, use the callback instead of the built in filter in needBroadphaseCollision
+	btOverlapFilterCallback* m_overlapFilterCallback;
+
+	btOverlappingPairCallback* m_ghostPairCallback;
+
+public:
+	btSortedOverlappingPairCache();
+	virtual ~btSortedOverlappingPairCache();
+
+	virtual void processAllOverlappingPairs(btOverlapCallback*, btDispatcher* dispatcher);
+
+	void* removeOverlappingPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1, btDispatcher* dispatcher);
+
+	void cleanOverlappingPair(btBroadphasePair& pair, btDispatcher* dispatcher);
+
+	btBroadphasePair* addOverlappingPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1);
+
+	btBroadphasePair* findPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1);
+
+	void cleanProxyFromPairs(btBroadphaseProxy* proxy, btDispatcher* dispatcher);
+
+	void removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy, btDispatcher* dispatcher);
+
+	inline bool needsBroadphaseCollision(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1) const
+	{
+		if (m_overlapFilterCallback)
+			return m_overlapFilterCallback->needBroadphaseCollision(proxy0, proxy1);
+
+		bool collides = (proxy0->m_collisionFilterGroup & proxy1->m_collisionFilterMask) != 0;
+		collides = collides && (proxy1->m_collisionFilterGroup & proxy0->m_collisionFilterMask);
+
+		return collides;
+	}
+
+	btBroadphasePairArray& getOverlappingPairArray()
+	{
+		return m_overlappingPairArray;
+	}
+
+	const btBroadphasePairArray& getOverlappingPairArray() const
+	{
+		return m_overlappingPairArray;
+	}
+
+	btBroadphasePair* getOverlappingPairArrayPtr()
+	{
+		return &m_overlappingPairArray[0];
+	}
+
+	const btBroadphasePair* getOverlappingPairArrayPtr() const
+	{
+		return &m_overlappingPairArray[0];
+	}
+
+	int getNumOverlappingPairs() const
+	{
+		return m_overlappingPairArray.size();
+	}
+
+	btOverlapFilterCallback* getOverlapFilterCallback()
+	{
+		return m_overlapFilterCallback;
+	}
+
+	void setOverlapFilterCallback(btOverlapFilterCallback* callback)
+	{
+		m_overlapFilterCallback = callback;
+	}
+
+	virtual bool hasDeferredRemoval()
+	{
+		return m_hasDeferredRemoval;
+	}
+
+	virtual void setInternalGhostPairCallback(btOverlappingPairCallback* ghostPairCallback)
+	{
+		m_ghostPairCallback = ghostPairCallback;
+	}
+
+	virtual void sortOverlappingPairs(btDispatcher* dispatcher);
+};
+
+///btNullPairCache skips add/removal of overlapping pairs. Userful for benchmarking and unit testing.
+class btNullPairCache : public btOverlappingPairCache
+{
+	btBroadphasePairArray m_overlappingPairArray;
+
+public:
+	virtual btBroadphasePair* getOverlappingPairArrayPtr()
+	{
+		return &m_overlappingPairArray[0];
+	}
+	const btBroadphasePair* getOverlappingPairArrayPtr() const
+	{
+		return &m_overlappingPairArray[0];
+	}
+	btBroadphasePairArray& getOverlappingPairArray()
+	{
+		return m_overlappingPairArray;
+	}
+
+	virtual void cleanOverlappingPair(btBroadphasePair& /*pair*/, btDispatcher* /*dispatcher*/)
+	{
+	}
+
+	virtual int getNumOverlappingPairs() const
+	{
+		return 0;
+	}
+
+	virtual void cleanProxyFromPairs(btBroadphaseProxy* /*proxy*/, btDispatcher* /*dispatcher*/)
+	{
+	}
+
+	bool needsBroadphaseCollision(btBroadphaseProxy*, btBroadphaseProxy*) const
+	{
+		return true;
+	}
+	btOverlapFilterCallback* getOverlapFilterCallback()
+	{
+		return 0;
+	}
+	virtual void setOverlapFilterCallback(btOverlapFilterCallback* /*callback*/)
+	{
+	}
+
+	virtual void processAllOverlappingPairs(btOverlapCallback*, btDispatcher* /*dispatcher*/)
+	{
+	}
+
+	virtual btBroadphasePair* findPair(btBroadphaseProxy* /*proxy0*/, btBroadphaseProxy* /*proxy1*/)
+	{
+		return 0;
+	}
+
+	virtual bool hasDeferredRemoval()
+	{
+		return true;
+	}
+
+	virtual void setInternalGhostPairCallback(btOverlappingPairCallback* /* ghostPairCallback */)
+	{
+	}
+
+	virtual btBroadphasePair* addOverlappingPair(btBroadphaseProxy* /*proxy0*/, btBroadphaseProxy* /*proxy1*/)
+	{
+		return 0;
+	}
+
+	virtual void* removeOverlappingPair(btBroadphaseProxy* /*proxy0*/, btBroadphaseProxy* /*proxy1*/, btDispatcher* /*dispatcher*/)
+	{
+		return 0;
+	}
+
+	virtual void removeOverlappingPairsContainingProxy(btBroadphaseProxy* /*proxy0*/, btDispatcher* /*dispatcher*/)
+	{
+	}
+
+	virtual void sortOverlappingPairs(btDispatcher* dispatcher)
+	{
+		(void)dispatcher;
+	}
+};
+
+#endif  //BT_OVERLAPPING_PAIR_CACHE_H
diff --git a/engine/inc/bullet/BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h b/engine/inc/bullet/BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h
new file mode 100644
index 00000000..d16c7254
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h
@@ -0,0 +1,41 @@
+
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef OVERLAPPING_PAIR_CALLBACK_H
+#define OVERLAPPING_PAIR_CALLBACK_H
+
+class btDispatcher;
+struct btBroadphasePair;
+
+///The btOverlappingPairCallback class is an additional optional broadphase user callback for adding/removing overlapping pairs, similar interface to btOverlappingPairCache.
+class btOverlappingPairCallback
+{
+protected:
+	btOverlappingPairCallback() {}
+
+public:
+	virtual ~btOverlappingPairCallback()
+	{
+	}
+
+	virtual btBroadphasePair* addOverlappingPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1) = 0;
+
+	virtual void* removeOverlappingPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1, btDispatcher* dispatcher) = 0;
+
+	virtual void removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy0, btDispatcher* dispatcher) = 0;
+};
+
+#endif  //OVERLAPPING_PAIR_CALLBACK_H
diff --git a/engine/inc/bullet/BulletCollision/BroadphaseCollision/btQuantizedBvh.h b/engine/inc/bullet/BulletCollision/BroadphaseCollision/btQuantizedBvh.h
new file mode 100644
index 00000000..1c47b9cc
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/BroadphaseCollision/btQuantizedBvh.h
@@ -0,0 +1,543 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_QUANTIZED_BVH_H
+#define BT_QUANTIZED_BVH_H
+
+class btSerializer;
+
+//#define DEBUG_CHECK_DEQUANTIZATION 1
+#ifdef DEBUG_CHECK_DEQUANTIZATION
+#ifdef __SPU__
+#define printf spu_printf
+#endif  //__SPU__
+
+#include <stdio.h>
+#include <stdlib.h>
+#endif  //DEBUG_CHECK_DEQUANTIZATION
+
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btAlignedAllocator.h"
+
+#ifdef BT_USE_DOUBLE_PRECISION
+#define btQuantizedBvhData btQuantizedBvhDoubleData
+#define btOptimizedBvhNodeData btOptimizedBvhNodeDoubleData
+#define btQuantizedBvhDataName "btQuantizedBvhDoubleData"
+#else
+#define btQuantizedBvhData btQuantizedBvhFloatData
+#define btOptimizedBvhNodeData btOptimizedBvhNodeFloatData
+#define btQuantizedBvhDataName "btQuantizedBvhFloatData"
+#endif
+
+//http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclang/html/vclrf__m128.asp
+
+//Note: currently we have 16 bytes per quantized node
+#define MAX_SUBTREE_SIZE_IN_BYTES 2048
+
+// 10 gives the potential for 1024 parts, with at most 2^21 (2097152) (minus one
+// actually) triangles each (since the sign bit is reserved
+#define MAX_NUM_PARTS_IN_BITS 10
+
+///btQuantizedBvhNode is a compressed aabb node, 16 bytes.
+///Node can be used for leafnode or internal node. Leafnodes can point to 32-bit triangle index (non-negative range).
+ATTRIBUTE_ALIGNED16(struct)
+btQuantizedBvhNode
+{
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	//12 bytes
+	unsigned short int m_quantizedAabbMin[3];
+	unsigned short int m_quantizedAabbMax[3];
+	//4 bytes
+	int m_escapeIndexOrTriangleIndex;
+
+	bool isLeafNode() const
+	{
+		//skipindex is negative (internal node), triangleindex >=0 (leafnode)
+		return (m_escapeIndexOrTriangleIndex >= 0);
+	}
+	int getEscapeIndex() const
+	{
+		btAssert(!isLeafNode());
+		return -m_escapeIndexOrTriangleIndex;
+	}
+	int getTriangleIndex() const
+	{
+		btAssert(isLeafNode());
+		unsigned int x = 0;
+		unsigned int y = (~(x & 0)) << (31 - MAX_NUM_PARTS_IN_BITS);
+		// Get only the lower bits where the triangle index is stored
+		return (m_escapeIndexOrTriangleIndex & ~(y));
+	}
+	int getPartId() const
+	{
+		btAssert(isLeafNode());
+		// Get only the highest bits where the part index is stored
+		return (m_escapeIndexOrTriangleIndex >> (31 - MAX_NUM_PARTS_IN_BITS));
+	}
+};
+
+/// btOptimizedBvhNode contains both internal and leaf node information.
+/// Total node size is 44 bytes / node. You can use the compressed version of 16 bytes.
+ATTRIBUTE_ALIGNED16(struct)
+btOptimizedBvhNode
+{
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	//32 bytes
+	btVector3 m_aabbMinOrg;
+	btVector3 m_aabbMaxOrg;
+
+	//4
+	int m_escapeIndex;
+
+	//8
+	//for child nodes
+	int m_subPart;
+	int m_triangleIndex;
+
+	//pad the size to 64 bytes
+	char m_padding[20];
+};
+
+///btBvhSubtreeInfo provides info to gather a subtree of limited size
+ATTRIBUTE_ALIGNED16(class)
+btBvhSubtreeInfo
+{
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	//12 bytes
+	unsigned short int m_quantizedAabbMin[3];
+	unsigned short int m_quantizedAabbMax[3];
+	//4 bytes, points to the root of the subtree
+	int m_rootNodeIndex;
+	//4 bytes
+	int m_subtreeSize;
+	int m_padding[3];
+
+	btBvhSubtreeInfo()
+	{
+		//memset(&m_padding[0], 0, sizeof(m_padding));
+	}
+
+	void setAabbFromQuantizeNode(const btQuantizedBvhNode& quantizedNode)
+	{
+		m_quantizedAabbMin[0] = quantizedNode.m_quantizedAabbMin[0];
+		m_quantizedAabbMin[1] = quantizedNode.m_quantizedAabbMin[1];
+		m_quantizedAabbMin[2] = quantizedNode.m_quantizedAabbMin[2];
+		m_quantizedAabbMax[0] = quantizedNode.m_quantizedAabbMax[0];
+		m_quantizedAabbMax[1] = quantizedNode.m_quantizedAabbMax[1];
+		m_quantizedAabbMax[2] = quantizedNode.m_quantizedAabbMax[2];
+	}
+};
+
+class btNodeOverlapCallback
+{
+public:
+	virtual ~btNodeOverlapCallback(){};
+
+	virtual void processNode(int subPart, int triangleIndex) = 0;
+};
+
+#include "LinearMath/btAlignedAllocator.h"
+#include "LinearMath/btAlignedObjectArray.h"
+
+///for code readability:
+typedef btAlignedObjectArray<btOptimizedBvhNode> NodeArray;
+typedef btAlignedObjectArray<btQuantizedBvhNode> QuantizedNodeArray;
+typedef btAlignedObjectArray<btBvhSubtreeInfo> BvhSubtreeInfoArray;
+
+///The btQuantizedBvh class stores an AABB tree that can be quickly traversed on CPU and Cell SPU.
+///It is used by the btBvhTriangleMeshShape as midphase.
+///It is recommended to use quantization for better performance and lower memory requirements.
+ATTRIBUTE_ALIGNED16(class)
+btQuantizedBvh
+{
+public:
+	enum btTraversalMode
+	{
+		TRAVERSAL_STACKLESS = 0,
+		TRAVERSAL_STACKLESS_CACHE_FRIENDLY,
+		TRAVERSAL_RECURSIVE
+	};
+
+protected:
+	btVector3 m_bvhAabbMin;
+	btVector3 m_bvhAabbMax;
+	btVector3 m_bvhQuantization;
+
+	int m_bulletVersion;  //for serialization versioning. It could also be used to detect endianess.
+
+	int m_curNodeIndex;
+	//quantization data
+	bool m_useQuantization;
+
+	NodeArray m_leafNodes;
+	NodeArray m_contiguousNodes;
+	QuantizedNodeArray m_quantizedLeafNodes;
+	QuantizedNodeArray m_quantizedContiguousNodes;
+
+	btTraversalMode m_traversalMode;
+	BvhSubtreeInfoArray m_SubtreeHeaders;
+
+	//This is only used for serialization so we don't have to add serialization directly to btAlignedObjectArray
+	mutable int m_subtreeHeaderCount;
+
+	///two versions, one for quantized and normal nodes. This allows code-reuse while maintaining readability (no template/macro!)
+	///this might be refactored into a virtual, it is usually not calculated at run-time
+	void setInternalNodeAabbMin(int nodeIndex, const btVector3& aabbMin)
+	{
+		if (m_useQuantization)
+		{
+			quantize(&m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[0], aabbMin, 0);
+		}
+		else
+		{
+			m_contiguousNodes[nodeIndex].m_aabbMinOrg = aabbMin;
+		}
+	}
+	void setInternalNodeAabbMax(int nodeIndex, const btVector3& aabbMax)
+	{
+		if (m_useQuantization)
+		{
+			quantize(&m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[0], aabbMax, 1);
+		}
+		else
+		{
+			m_contiguousNodes[nodeIndex].m_aabbMaxOrg = aabbMax;
+		}
+	}
+
+	btVector3 getAabbMin(int nodeIndex) const
+	{
+		if (m_useQuantization)
+		{
+			return unQuantize(&m_quantizedLeafNodes[nodeIndex].m_quantizedAabbMin[0]);
+		}
+		//non-quantized
+		return m_leafNodes[nodeIndex].m_aabbMinOrg;
+	}
+	btVector3 getAabbMax(int nodeIndex) const
+	{
+		if (m_useQuantization)
+		{
+			return unQuantize(&m_quantizedLeafNodes[nodeIndex].m_quantizedAabbMax[0]);
+		}
+		//non-quantized
+		return m_leafNodes[nodeIndex].m_aabbMaxOrg;
+	}
+
+	void setInternalNodeEscapeIndex(int nodeIndex, int escapeIndex)
+	{
+		if (m_useQuantization)
+		{
+			m_quantizedContiguousNodes[nodeIndex].m_escapeIndexOrTriangleIndex = -escapeIndex;
+		}
+		else
+		{
+			m_contiguousNodes[nodeIndex].m_escapeIndex = escapeIndex;
+		}
+	}
+
+	void mergeInternalNodeAabb(int nodeIndex, const btVector3& newAabbMin, const btVector3& newAabbMax)
+	{
+		if (m_useQuantization)
+		{
+			unsigned short int quantizedAabbMin[3];
+			unsigned short int quantizedAabbMax[3];
+			quantize(quantizedAabbMin, newAabbMin, 0);
+			quantize(quantizedAabbMax, newAabbMax, 1);
+			for (int i = 0; i < 3; i++)
+			{
+				if (m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[i] > quantizedAabbMin[i])
+					m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[i] = quantizedAabbMin[i];
+
+				if (m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[i] < quantizedAabbMax[i])
+					m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[i] = quantizedAabbMax[i];
+			}
+		}
+		else
+		{
+			//non-quantized
+			m_contiguousNodes[nodeIndex].m_aabbMinOrg.setMin(newAabbMin);
+			m_contiguousNodes[nodeIndex].m_aabbMaxOrg.setMax(newAabbMax);
+		}
+	}
+
+	void swapLeafNodes(int firstIndex, int secondIndex);
+
+	void assignInternalNodeFromLeafNode(int internalNode, int leafNodeIndex);
+
+protected:
+	void buildTree(int startIndex, int endIndex);
+
+	int calcSplittingAxis(int startIndex, int endIndex);
+
+	int sortAndCalcSplittingIndex(int startIndex, int endIndex, int splitAxis);
+
+	void walkStacklessTree(btNodeOverlapCallback * nodeCallback, const btVector3& aabbMin, const btVector3& aabbMax) const;
+
+	void walkStacklessQuantizedTreeAgainstRay(btNodeOverlapCallback * nodeCallback, const btVector3& raySource, const btVector3& rayTarget, const btVector3& aabbMin, const btVector3& aabbMax, int startNodeIndex, int endNodeIndex) const;
+	void walkStacklessQuantizedTree(btNodeOverlapCallback * nodeCallback, unsigned short int* quantizedQueryAabbMin, unsigned short int* quantizedQueryAabbMax, int startNodeIndex, int endNodeIndex) const;
+	void walkStacklessTreeAgainstRay(btNodeOverlapCallback * nodeCallback, const btVector3& raySource, const btVector3& rayTarget, const btVector3& aabbMin, const btVector3& aabbMax, int startNodeIndex, int endNodeIndex) const;
+
+	///tree traversal designed for small-memory processors like PS3 SPU
+	void walkStacklessQuantizedTreeCacheFriendly(btNodeOverlapCallback * nodeCallback, unsigned short int* quantizedQueryAabbMin, unsigned short int* quantizedQueryAabbMax) const;
+
+	///use the 16-byte stackless 'skipindex' node tree to do a recursive traversal
+	void walkRecursiveQuantizedTreeAgainstQueryAabb(const btQuantizedBvhNode* currentNode, btNodeOverlapCallback* nodeCallback, unsigned short int* quantizedQueryAabbMin, unsigned short int* quantizedQueryAabbMax) const;
+
+	///use the 16-byte stackless 'skipindex' node tree to do a recursive traversal
+	void walkRecursiveQuantizedTreeAgainstQuantizedTree(const btQuantizedBvhNode* treeNodeA, const btQuantizedBvhNode* treeNodeB, btNodeOverlapCallback* nodeCallback) const;
+
+	void updateSubtreeHeaders(int leftChildNodexIndex, int rightChildNodexIndex);
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btQuantizedBvh();
+
+	virtual ~btQuantizedBvh();
+
+	///***************************************** expert/internal use only *************************
+	void setQuantizationValues(const btVector3& bvhAabbMin, const btVector3& bvhAabbMax, btScalar quantizationMargin = btScalar(1.0));
+	QuantizedNodeArray& getLeafNodeArray() { return m_quantizedLeafNodes; }
+	///buildInternal is expert use only: assumes that setQuantizationValues and LeafNodeArray are initialized
+	void buildInternal();
+	///***************************************** expert/internal use only *************************
+
+	void reportAabbOverlappingNodex(btNodeOverlapCallback * nodeCallback, const btVector3& aabbMin, const btVector3& aabbMax) const;
+	void reportRayOverlappingNodex(btNodeOverlapCallback * nodeCallback, const btVector3& raySource, const btVector3& rayTarget) const;
+	void reportBoxCastOverlappingNodex(btNodeOverlapCallback * nodeCallback, const btVector3& raySource, const btVector3& rayTarget, const btVector3& aabbMin, const btVector3& aabbMax) const;
+
+	SIMD_FORCE_INLINE void quantize(unsigned short* out, const btVector3& point, int isMax) const
+	{
+		btAssert(m_useQuantization);
+
+		btAssert(point.getX() <= m_bvhAabbMax.getX());
+		btAssert(point.getY() <= m_bvhAabbMax.getY());
+		btAssert(point.getZ() <= m_bvhAabbMax.getZ());
+
+		btAssert(point.getX() >= m_bvhAabbMin.getX());
+		btAssert(point.getY() >= m_bvhAabbMin.getY());
+		btAssert(point.getZ() >= m_bvhAabbMin.getZ());
+
+		btVector3 v = (point - m_bvhAabbMin) * m_bvhQuantization;
+		///Make sure rounding is done in a way that unQuantize(quantizeWithClamp(...)) is conservative
+		///end-points always set the first bit, so that they are sorted properly (so that neighbouring AABBs overlap properly)
+		///@todo: double-check this
+		if (isMax)
+		{
+			out[0] = (unsigned short)(((unsigned short)(v.getX() + btScalar(1.)) | 1));
+			out[1] = (unsigned short)(((unsigned short)(v.getY() + btScalar(1.)) | 1));
+			out[2] = (unsigned short)(((unsigned short)(v.getZ() + btScalar(1.)) | 1));
+		}
+		else
+		{
+			out[0] = (unsigned short)(((unsigned short)(v.getX()) & 0xfffe));
+			out[1] = (unsigned short)(((unsigned short)(v.getY()) & 0xfffe));
+			out[2] = (unsigned short)(((unsigned short)(v.getZ()) & 0xfffe));
+		}
+
+#ifdef DEBUG_CHECK_DEQUANTIZATION
+		btVector3 newPoint = unQuantize(out);
+		if (isMax)
+		{
+			if (newPoint.getX() < point.getX())
+			{
+				printf("unconservative X, diffX = %f, oldX=%f,newX=%f\n", newPoint.getX() - point.getX(), newPoint.getX(), point.getX());
+			}
+			if (newPoint.getY() < point.getY())
+			{
+				printf("unconservative Y, diffY = %f, oldY=%f,newY=%f\n", newPoint.getY() - point.getY(), newPoint.getY(), point.getY());
+			}
+			if (newPoint.getZ() < point.getZ())
+			{
+				printf("unconservative Z, diffZ = %f, oldZ=%f,newZ=%f\n", newPoint.getZ() - point.getZ(), newPoint.getZ(), point.getZ());
+			}
+		}
+		else
+		{
+			if (newPoint.getX() > point.getX())
+			{
+				printf("unconservative X, diffX = %f, oldX=%f,newX=%f\n", newPoint.getX() - point.getX(), newPoint.getX(), point.getX());
+			}
+			if (newPoint.getY() > point.getY())
+			{
+				printf("unconservative Y, diffY = %f, oldY=%f,newY=%f\n", newPoint.getY() - point.getY(), newPoint.getY(), point.getY());
+			}
+			if (newPoint.getZ() > point.getZ())
+			{
+				printf("unconservative Z, diffZ = %f, oldZ=%f,newZ=%f\n", newPoint.getZ() - point.getZ(), newPoint.getZ(), point.getZ());
+			}
+		}
+#endif  //DEBUG_CHECK_DEQUANTIZATION
+	}
+
+	SIMD_FORCE_INLINE void quantizeWithClamp(unsigned short* out, const btVector3& point2, int isMax) const
+	{
+		btAssert(m_useQuantization);
+
+		btVector3 clampedPoint(point2);
+		clampedPoint.setMax(m_bvhAabbMin);
+		clampedPoint.setMin(m_bvhAabbMax);
+
+		quantize(out, clampedPoint, isMax);
+	}
+
+	SIMD_FORCE_INLINE btVector3 unQuantize(const unsigned short* vecIn) const
+	{
+		btVector3 vecOut;
+		vecOut.setValue(
+			(btScalar)(vecIn[0]) / (m_bvhQuantization.getX()),
+			(btScalar)(vecIn[1]) / (m_bvhQuantization.getY()),
+			(btScalar)(vecIn[2]) / (m_bvhQuantization.getZ()));
+		vecOut += m_bvhAabbMin;
+		return vecOut;
+	}
+
+	///setTraversalMode let's you choose between stackless, recursive or stackless cache friendly tree traversal. Note this is only implemented for quantized trees.
+	void setTraversalMode(btTraversalMode traversalMode)
+	{
+		m_traversalMode = traversalMode;
+	}
+
+	SIMD_FORCE_INLINE QuantizedNodeArray& getQuantizedNodeArray()
+	{
+		return m_quantizedContiguousNodes;
+	}
+
+	SIMD_FORCE_INLINE BvhSubtreeInfoArray& getSubtreeInfoArray()
+	{
+		return m_SubtreeHeaders;
+	}
+
+	////////////////////////////////////////////////////////////////////
+
+	/////Calculate space needed to store BVH for serialization
+	unsigned calculateSerializeBufferSize() const;
+
+	/// Data buffer MUST be 16 byte aligned
+	virtual bool serialize(void* o_alignedDataBuffer, unsigned i_dataBufferSize, bool i_swapEndian) const;
+
+	///deSerializeInPlace loads and initializes a BVH from a buffer in memory 'in place'
+	static btQuantizedBvh* deSerializeInPlace(void* i_alignedDataBuffer, unsigned int i_dataBufferSize, bool i_swapEndian);
+
+	static unsigned int getAlignmentSerializationPadding();
+	//////////////////////////////////////////////////////////////////////
+
+	virtual int calculateSerializeBufferSizeNew() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
+
+	virtual void deSerializeFloat(struct btQuantizedBvhFloatData & quantizedBvhFloatData);
+
+	virtual void deSerializeDouble(struct btQuantizedBvhDoubleData & quantizedBvhDoubleData);
+
+	////////////////////////////////////////////////////////////////////
+
+	SIMD_FORCE_INLINE bool isQuantized()
+	{
+		return m_useQuantization;
+	}
+
+private:
+	// Special "copy" constructor that allows for in-place deserialization
+	// Prevents btVector3's default constructor from being called, but doesn't inialize much else
+	// ownsMemory should most likely be false if deserializing, and if you are not, don't call this (it also changes the function signature, which we need)
+	btQuantizedBvh(btQuantizedBvh & other, bool ownsMemory);
+};
+
+// clang-format off
+// parser needs * with the name
+struct btBvhSubtreeInfoData
+{
+	int m_rootNodeIndex;
+	int m_subtreeSize;
+	unsigned short m_quantizedAabbMin[3];
+	unsigned short m_quantizedAabbMax[3];
+};
+
+struct btOptimizedBvhNodeFloatData
+{
+	btVector3FloatData m_aabbMinOrg;
+	btVector3FloatData m_aabbMaxOrg;
+	int m_escapeIndex;
+	int m_subPart;
+	int m_triangleIndex;
+	char m_pad[4];
+};
+
+struct btOptimizedBvhNodeDoubleData
+{
+	btVector3DoubleData m_aabbMinOrg;
+	btVector3DoubleData m_aabbMaxOrg;
+	int m_escapeIndex;
+	int m_subPart;
+	int m_triangleIndex;
+	char m_pad[4];
+};
+
+
+struct btQuantizedBvhNodeData
+{
+	unsigned short m_quantizedAabbMin[3];
+	unsigned short m_quantizedAabbMax[3];
+	int	m_escapeIndexOrTriangleIndex;
+};
+
+struct	btQuantizedBvhFloatData
+{
+	btVector3FloatData			m_bvhAabbMin;
+	btVector3FloatData			m_bvhAabbMax;
+	btVector3FloatData			m_bvhQuantization;
+	int					m_curNodeIndex;
+	int					m_useQuantization;
+	int					m_numContiguousLeafNodes;
+	int					m_numQuantizedContiguousNodes;
+	btOptimizedBvhNodeFloatData	*m_contiguousNodesPtr;
+	btQuantizedBvhNodeData		*m_quantizedContiguousNodesPtr;
+	btBvhSubtreeInfoData	*m_subTreeInfoPtr;
+	int					m_traversalMode;
+	int					m_numSubtreeHeaders;
+	
+};
+
+struct	btQuantizedBvhDoubleData
+{
+	btVector3DoubleData			m_bvhAabbMin;
+	btVector3DoubleData			m_bvhAabbMax;
+	btVector3DoubleData			m_bvhQuantization;
+	int							m_curNodeIndex;
+	int							m_useQuantization;
+	int							m_numContiguousLeafNodes;
+	int							m_numQuantizedContiguousNodes;
+	btOptimizedBvhNodeDoubleData	*m_contiguousNodesPtr;
+	btQuantizedBvhNodeData			*m_quantizedContiguousNodesPtr;
+
+	int							m_traversalMode;
+	int							m_numSubtreeHeaders;
+	btBvhSubtreeInfoData		*m_subTreeInfoPtr;
+};
+// clang-format on
+
+SIMD_FORCE_INLINE int btQuantizedBvh::calculateSerializeBufferSizeNew() const
+{
+	return sizeof(btQuantizedBvhData);
+}
+
+#endif  //BT_QUANTIZED_BVH_H
diff --git a/engine/inc/bullet/BulletCollision/BroadphaseCollision/btSimpleBroadphase.h b/engine/inc/bullet/BulletCollision/BroadphaseCollision/btSimpleBroadphase.h
new file mode 100644
index 00000000..3e02fdc0
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/BroadphaseCollision/btSimpleBroadphase.h
@@ -0,0 +1,148 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SIMPLE_BROADPHASE_H
+#define BT_SIMPLE_BROADPHASE_H
+
+#include "btOverlappingPairCache.h"
+
+struct btSimpleBroadphaseProxy : public btBroadphaseProxy
+{
+	int m_nextFree;
+
+	//	int			m_handleId;
+
+	btSimpleBroadphaseProxy(){};
+
+	btSimpleBroadphaseProxy(const btVector3& minpt, const btVector3& maxpt, int shapeType, void* userPtr, int collisionFilterGroup, int collisionFilterMask)
+		: btBroadphaseProxy(minpt, maxpt, userPtr, collisionFilterGroup, collisionFilterMask)
+	{
+		(void)shapeType;
+	}
+
+	SIMD_FORCE_INLINE void SetNextFree(int next) { m_nextFree = next; }
+	SIMD_FORCE_INLINE int GetNextFree() const { return m_nextFree; }
+};
+
+///The SimpleBroadphase is just a unit-test for btAxisSweep3, bt32BitAxisSweep3, or btDbvtBroadphase, so use those classes instead.
+///It is a brute force aabb culling broadphase based on O(n^2) aabb checks
+class btSimpleBroadphase : public btBroadphaseInterface
+{
+protected:
+	int m_numHandles;  // number of active handles
+	int m_maxHandles;  // max number of handles
+	int m_LastHandleIndex;
+
+	btSimpleBroadphaseProxy* m_pHandles;  // handles pool
+
+	void* m_pHandlesRawPtr;
+	int m_firstFreeHandle;  // free handles list
+
+	int allocHandle()
+	{
+		btAssert(m_numHandles < m_maxHandles);
+		int freeHandle = m_firstFreeHandle;
+		m_firstFreeHandle = m_pHandles[freeHandle].GetNextFree();
+		m_numHandles++;
+		if (freeHandle > m_LastHandleIndex)
+		{
+			m_LastHandleIndex = freeHandle;
+		}
+		return freeHandle;
+	}
+
+	void freeHandle(btSimpleBroadphaseProxy* proxy)
+	{
+		int handle = int(proxy - m_pHandles);
+		btAssert(handle >= 0 && handle < m_maxHandles);
+		if (handle == m_LastHandleIndex)
+		{
+			m_LastHandleIndex--;
+		}
+		proxy->SetNextFree(m_firstFreeHandle);
+		m_firstFreeHandle = handle;
+
+		proxy->m_clientObject = 0;
+
+		m_numHandles--;
+	}
+
+	btOverlappingPairCache* m_pairCache;
+	bool m_ownsPairCache;
+
+	int m_invalidPair;
+
+	inline btSimpleBroadphaseProxy* getSimpleProxyFromProxy(btBroadphaseProxy* proxy)
+	{
+		btSimpleBroadphaseProxy* proxy0 = static_cast<btSimpleBroadphaseProxy*>(proxy);
+		return proxy0;
+	}
+
+	inline const btSimpleBroadphaseProxy* getSimpleProxyFromProxy(btBroadphaseProxy* proxy) const
+	{
+		const btSimpleBroadphaseProxy* proxy0 = static_cast<const btSimpleBroadphaseProxy*>(proxy);
+		return proxy0;
+	}
+
+	///reset broadphase internal structures, to ensure determinism/reproducability
+	virtual void resetPool(btDispatcher* dispatcher);
+
+	void validate();
+
+protected:
+public:
+	btSimpleBroadphase(int maxProxies = 16384, btOverlappingPairCache* overlappingPairCache = 0);
+	virtual ~btSimpleBroadphase();
+
+	static bool aabbOverlap(btSimpleBroadphaseProxy* proxy0, btSimpleBroadphaseProxy* proxy1);
+
+	virtual btBroadphaseProxy* createProxy(const btVector3& aabbMin, const btVector3& aabbMax, int shapeType, void* userPtr, int collisionFilterGroup, int collisionFilterMask, btDispatcher* dispatcher);
+
+	virtual void calculateOverlappingPairs(btDispatcher* dispatcher);
+
+	virtual void destroyProxy(btBroadphaseProxy* proxy, btDispatcher* dispatcher);
+	virtual void setAabb(btBroadphaseProxy* proxy, const btVector3& aabbMin, const btVector3& aabbMax, btDispatcher* dispatcher);
+	virtual void getAabb(btBroadphaseProxy* proxy, btVector3& aabbMin, btVector3& aabbMax) const;
+
+	virtual void rayTest(const btVector3& rayFrom, const btVector3& rayTo, btBroadphaseRayCallback& rayCallback, const btVector3& aabbMin = btVector3(0, 0, 0), const btVector3& aabbMax = btVector3(0, 0, 0));
+	virtual void aabbTest(const btVector3& aabbMin, const btVector3& aabbMax, btBroadphaseAabbCallback& callback);
+
+	btOverlappingPairCache* getOverlappingPairCache()
+	{
+		return m_pairCache;
+	}
+	const btOverlappingPairCache* getOverlappingPairCache() const
+	{
+		return m_pairCache;
+	}
+
+	bool testAabbOverlap(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1);
+
+	///getAabb returns the axis aligned bounding box in the 'global' coordinate frame
+	///will add some transform later
+	virtual void getBroadphaseAabb(btVector3& aabbMin, btVector3& aabbMax) const
+	{
+		aabbMin.setValue(-BT_LARGE_FLOAT, -BT_LARGE_FLOAT, -BT_LARGE_FLOAT);
+		aabbMax.setValue(BT_LARGE_FLOAT, BT_LARGE_FLOAT, BT_LARGE_FLOAT);
+	}
+
+	virtual void printStats()
+	{
+		//		printf("btSimpleBroadphase.h\n");
+		//		printf("numHandles = %d, maxHandles = %d\n",m_numHandles,m_maxHandles);
+	}
+};
+
+#endif  //BT_SIMPLE_BROADPHASE_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionDispatch/SphereTriangleDetector.h b/engine/inc/bullet/BulletCollision/CollisionDispatch/SphereTriangleDetector.h
new file mode 100644
index 00000000..d47e4753
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionDispatch/SphereTriangleDetector.h
@@ -0,0 +1,43 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SPHERE_TRIANGLE_DETECTOR_H
+#define BT_SPHERE_TRIANGLE_DETECTOR_H
+
+#include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h"
+
+class btSphereShape;
+class btTriangleShape;
+
+/// sphere-triangle to match the btDiscreteCollisionDetectorInterface
+struct SphereTriangleDetector : public btDiscreteCollisionDetectorInterface
+{
+	virtual void getClosestPoints(const ClosestPointInput& input, Result& output, class btIDebugDraw* debugDraw, bool swapResults = false);
+
+	SphereTriangleDetector(btSphereShape* sphere, btTriangleShape* triangle, btScalar contactBreakingThreshold);
+
+	virtual ~SphereTriangleDetector(){};
+
+	bool collide(const btVector3& sphereCenter, btVector3& point, btVector3& resultNormal, btScalar& depth, btScalar& timeOfImpact, btScalar contactBreakingThreshold);
+
+private:
+	bool pointInTriangle(const btVector3 vertices[], const btVector3& normal, btVector3* p);
+	bool facecontains(const btVector3& p, const btVector3* vertices, btVector3& normal);
+
+	btSphereShape* m_sphere;
+	btTriangleShape* m_triangle;
+	btScalar m_contactBreakingThreshold;
+};
+#endif  //BT_SPHERE_TRIANGLE_DETECTOR_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h b/engine/inc/bullet/BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h
new file mode 100644
index 00000000..86206057
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h
@@ -0,0 +1,35 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2008 Erwin Coumans  http://bulletphysics.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef __BT_ACTIVATING_COLLISION_ALGORITHM_H
+#define __BT_ACTIVATING_COLLISION_ALGORITHM_H
+
+#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+
+///This class is not enabled yet (work-in-progress) to more aggressively activate objects.
+class btActivatingCollisionAlgorithm : public btCollisionAlgorithm
+{
+	//	btCollisionObject* m_colObj0;
+	//	btCollisionObject* m_colObj1;
+
+protected:
+	btActivatingCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci);
+
+	btActivatingCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap);
+
+public:
+	virtual ~btActivatingCollisionAlgorithm();
+};
+#endif  //__BT_ACTIVATING_COLLISION_ALGORITHM_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.h b/engine/inc/bullet/BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.h
new file mode 100644
index 00000000..3b66d1fd
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.h
@@ -0,0 +1,63 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_BOX_2D_BOX_2D__COLLISION_ALGORITHM_H
+#define BT_BOX_2D_BOX_2D__COLLISION_ALGORITHM_H
+
+#include "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+#include "BulletCollision/BroadphaseCollision/btDispatcher.h"
+#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
+
+class btPersistentManifold;
+
+///box-box collision detection
+class btBox2dBox2dCollisionAlgorithm : public btActivatingCollisionAlgorithm
+{
+	bool m_ownManifold;
+	btPersistentManifold* m_manifoldPtr;
+
+public:
+	btBox2dBox2dCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci)
+		: btActivatingCollisionAlgorithm(ci) {}
+
+	virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	virtual btScalar calculateTimeOfImpact(btCollisionObject* body0, btCollisionObject* body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	btBox2dBox2dCollisionAlgorithm(btPersistentManifold* mf, const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap);
+
+	virtual ~btBox2dBox2dCollisionAlgorithm();
+
+	virtual void getAllContactManifolds(btManifoldArray& manifoldArray)
+	{
+		if (m_manifoldPtr && m_ownManifold)
+		{
+			manifoldArray.push_back(m_manifoldPtr);
+		}
+	}
+
+	struct CreateFunc : public btCollisionAlgorithmCreateFunc
+	{
+		virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap)
+		{
+			int bbsize = sizeof(btBox2dBox2dCollisionAlgorithm);
+			void* ptr = ci.m_dispatcher1->allocateCollisionAlgorithm(bbsize);
+			return new (ptr) btBox2dBox2dCollisionAlgorithm(0, ci, body0Wrap, body1Wrap);
+		}
+	};
+};
+
+#endif  //BT_BOX_2D_BOX_2D__COLLISION_ALGORITHM_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.h b/engine/inc/bullet/BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.h
new file mode 100644
index 00000000..eb210657
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.h
@@ -0,0 +1,63 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_BOX_BOX__COLLISION_ALGORITHM_H
+#define BT_BOX_BOX__COLLISION_ALGORITHM_H
+
+#include "btActivatingCollisionAlgorithm.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+#include "BulletCollision/BroadphaseCollision/btDispatcher.h"
+#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
+
+class btPersistentManifold;
+
+///box-box collision detection
+class btBoxBoxCollisionAlgorithm : public btActivatingCollisionAlgorithm
+{
+	bool m_ownManifold;
+	btPersistentManifold* m_manifoldPtr;
+
+public:
+	btBoxBoxCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci)
+		: btActivatingCollisionAlgorithm(ci) {}
+
+	virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	virtual btScalar calculateTimeOfImpact(btCollisionObject* body0, btCollisionObject* body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	btBoxBoxCollisionAlgorithm(btPersistentManifold* mf, const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap);
+
+	virtual ~btBoxBoxCollisionAlgorithm();
+
+	virtual void getAllContactManifolds(btManifoldArray& manifoldArray)
+	{
+		if (m_manifoldPtr && m_ownManifold)
+		{
+			manifoldArray.push_back(m_manifoldPtr);
+		}
+	}
+
+	struct CreateFunc : public btCollisionAlgorithmCreateFunc
+	{
+		virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap)
+		{
+			int bbsize = sizeof(btBoxBoxCollisionAlgorithm);
+			void* ptr = ci.m_dispatcher1->allocateCollisionAlgorithm(bbsize);
+			return new (ptr) btBoxBoxCollisionAlgorithm(0, ci, body0Wrap, body1Wrap);
+		}
+	};
+};
+
+#endif  //BT_BOX_BOX__COLLISION_ALGORITHM_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionDispatch/btBoxBoxDetector.h b/engine/inc/bullet/BulletCollision/CollisionDispatch/btBoxBoxDetector.h
new file mode 100644
index 00000000..9f7d988f
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionDispatch/btBoxBoxDetector.h
@@ -0,0 +1,40 @@
+/*
+ * Box-Box collision detection re-distributed under the ZLib license with permission from Russell L. Smith
+ * Original version is from Open Dynamics Engine, Copyright (C) 2001,2002 Russell L. Smith.
+ * All rights reserved.  Email: russ@q12.org   Web: www.q12.org
+
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef BT_BOX_BOX_DETECTOR_H
+#define BT_BOX_BOX_DETECTOR_H
+
+class btBoxShape;
+#include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h"
+
+/// btBoxBoxDetector wraps the ODE box-box collision detector
+/// re-distributed under the Zlib license with permission from Russell L. Smith
+struct btBoxBoxDetector : public btDiscreteCollisionDetectorInterface
+{
+	const btBoxShape* m_box1;
+	const btBoxShape* m_box2;
+
+public:
+	btBoxBoxDetector(const btBoxShape* box1, const btBoxShape* box2);
+
+	virtual ~btBoxBoxDetector(){};
+
+	virtual void getClosestPoints(const ClosestPointInput& input, Result& output, class btIDebugDraw* debugDraw, bool swapResults = false);
+};
+
+#endif  //BT_BOX_BOX_DETECTOR_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionDispatch/btCollisionConfiguration.h b/engine/inc/bullet/BulletCollision/CollisionDispatch/btCollisionConfiguration.h
new file mode 100644
index 00000000..d6e15f55
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionDispatch/btCollisionConfiguration.h
@@ -0,0 +1,43 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_COLLISION_CONFIGURATION
+#define BT_COLLISION_CONFIGURATION
+
+struct btCollisionAlgorithmCreateFunc;
+
+class btPoolAllocator;
+
+///btCollisionConfiguration allows to configure Bullet collision detection
+///stack allocator size, default collision algorithms and persistent manifold pool size
+///@todo: describe the meaning
+class btCollisionConfiguration
+{
+public:
+	virtual ~btCollisionConfiguration()
+	{
+	}
+
+	///memory pools
+	virtual btPoolAllocator* getPersistentManifoldPool() = 0;
+
+	virtual btPoolAllocator* getCollisionAlgorithmPool() = 0;
+
+	virtual btCollisionAlgorithmCreateFunc* getCollisionAlgorithmCreateFunc(int proxyType0, int proxyType1) = 0;
+
+	virtual btCollisionAlgorithmCreateFunc* getClosestPointsAlgorithmCreateFunc(int proxyType0, int proxyType1) = 0;
+};
+
+#endif  //BT_COLLISION_CONFIGURATION
diff --git a/engine/inc/bullet/BulletCollision/CollisionDispatch/btCollisionCreateFunc.h b/engine/inc/bullet/BulletCollision/CollisionDispatch/btCollisionCreateFunc.h
new file mode 100644
index 00000000..bd812849
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionDispatch/btCollisionCreateFunc.h
@@ -0,0 +1,43 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_COLLISION_CREATE_FUNC
+#define BT_COLLISION_CREATE_FUNC
+
+#include "LinearMath/btAlignedObjectArray.h"
+class btCollisionAlgorithm;
+class btCollisionObject;
+struct btCollisionObjectWrapper;
+struct btCollisionAlgorithmConstructionInfo;
+
+///Used by the btCollisionDispatcher to register and create instances for btCollisionAlgorithm
+struct btCollisionAlgorithmCreateFunc
+{
+	bool m_swapped;
+
+	btCollisionAlgorithmCreateFunc()
+		: m_swapped(false)
+	{
+	}
+	virtual ~btCollisionAlgorithmCreateFunc(){};
+
+	virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo&, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap)
+	{
+		(void)body0Wrap;
+		(void)body1Wrap;
+		return 0;
+	}
+};
+#endif  //BT_COLLISION_CREATE_FUNC
diff --git a/engine/inc/bullet/BulletCollision/CollisionDispatch/btCollisionDispatcher.h b/engine/inc/bullet/BulletCollision/CollisionDispatch/btCollisionDispatcher.h
new file mode 100644
index 00000000..04309670
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionDispatch/btCollisionDispatcher.h
@@ -0,0 +1,169 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_COLLISION__DISPATCHER_H
+#define BT_COLLISION__DISPATCHER_H
+
+#include "BulletCollision/BroadphaseCollision/btDispatcher.h"
+#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
+
+#include "BulletCollision/CollisionDispatch/btManifoldResult.h"
+
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+#include "LinearMath/btAlignedObjectArray.h"
+
+class btIDebugDraw;
+class btOverlappingPairCache;
+class btPoolAllocator;
+class btCollisionConfiguration;
+
+#include "btCollisionCreateFunc.h"
+
+#define USE_DISPATCH_REGISTRY_ARRAY 1
+
+class btCollisionDispatcher;
+///user can override this nearcallback for collision filtering and more finegrained control over collision detection
+typedef void (*btNearCallback)(btBroadphasePair& collisionPair, btCollisionDispatcher& dispatcher, const btDispatcherInfo& dispatchInfo);
+
+///btCollisionDispatcher supports algorithms that handle ConvexConvex and ConvexConcave collision pairs.
+///Time of Impact, Closest Points and Penetration Depth.
+class btCollisionDispatcher : public btDispatcher
+{
+protected:
+	int m_dispatcherFlags;
+
+	btAlignedObjectArray<btPersistentManifold*> m_manifoldsPtr;
+
+	btNearCallback m_nearCallback;
+
+	btPoolAllocator* m_collisionAlgorithmPoolAllocator;
+
+	btPoolAllocator* m_persistentManifoldPoolAllocator;
+
+	btCollisionAlgorithmCreateFunc* m_doubleDispatchContactPoints[MAX_BROADPHASE_COLLISION_TYPES][MAX_BROADPHASE_COLLISION_TYPES];
+
+	btCollisionAlgorithmCreateFunc* m_doubleDispatchClosestPoints[MAX_BROADPHASE_COLLISION_TYPES][MAX_BROADPHASE_COLLISION_TYPES];
+
+	btCollisionConfiguration* m_collisionConfiguration;
+
+public:
+	enum DispatcherFlags
+	{
+		CD_STATIC_STATIC_REPORTED = 1,
+		CD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD = 2,
+		CD_DISABLE_CONTACTPOOL_DYNAMIC_ALLOCATION = 4
+	};
+
+	int getDispatcherFlags() const
+	{
+		return m_dispatcherFlags;
+	}
+
+	void setDispatcherFlags(int flags)
+	{
+		m_dispatcherFlags = flags;
+	}
+
+	///registerCollisionCreateFunc allows registration of custom/alternative collision create functions
+	void registerCollisionCreateFunc(int proxyType0, int proxyType1, btCollisionAlgorithmCreateFunc* createFunc);
+
+	void registerClosestPointsCreateFunc(int proxyType0, int proxyType1, btCollisionAlgorithmCreateFunc* createFunc);
+
+	int getNumManifolds() const
+	{
+		return int(m_manifoldsPtr.size());
+	}
+
+	btPersistentManifold** getInternalManifoldPointer()
+	{
+		return m_manifoldsPtr.size() ? &m_manifoldsPtr[0] : 0;
+	}
+
+	btPersistentManifold* getManifoldByIndexInternal(int index)
+	{
+		btAssert(index>=0);
+		btAssert(index<m_manifoldsPtr.size());
+		return m_manifoldsPtr[index];
+	}
+
+	const btPersistentManifold* getManifoldByIndexInternal(int index) const
+	{
+		btAssert(index>=0);
+		btAssert(index<m_manifoldsPtr.size());
+		return m_manifoldsPtr[index];
+	}
+
+	btCollisionDispatcher(btCollisionConfiguration* collisionConfiguration);
+
+	virtual ~btCollisionDispatcher();
+
+	virtual btPersistentManifold* getNewManifold(const btCollisionObject* b0, const btCollisionObject* b1);
+
+	virtual void releaseManifold(btPersistentManifold* manifold);
+
+	virtual void clearManifold(btPersistentManifold* manifold);
+
+	btCollisionAlgorithm* findAlgorithm(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, btPersistentManifold* sharedManifold, ebtDispatcherQueryType queryType);
+
+	virtual bool needsCollision(const btCollisionObject* body0, const btCollisionObject* body1);
+
+	virtual bool needsResponse(const btCollisionObject* body0, const btCollisionObject* body1);
+
+	virtual void dispatchAllCollisionPairs(btOverlappingPairCache* pairCache, const btDispatcherInfo& dispatchInfo, btDispatcher* dispatcher);
+
+	void setNearCallback(btNearCallback nearCallback)
+	{
+		m_nearCallback = nearCallback;
+	}
+
+	btNearCallback getNearCallback() const
+	{
+		return m_nearCallback;
+	}
+
+	//by default, Bullet will use this near callback
+	static void defaultNearCallback(btBroadphasePair& collisionPair, btCollisionDispatcher& dispatcher, const btDispatcherInfo& dispatchInfo);
+
+	virtual void* allocateCollisionAlgorithm(int size);
+
+	virtual void freeCollisionAlgorithm(void* ptr);
+
+	btCollisionConfiguration* getCollisionConfiguration()
+	{
+		return m_collisionConfiguration;
+	}
+
+	const btCollisionConfiguration* getCollisionConfiguration() const
+	{
+		return m_collisionConfiguration;
+	}
+
+	void setCollisionConfiguration(btCollisionConfiguration* config)
+	{
+		m_collisionConfiguration = config;
+	}
+
+	virtual btPoolAllocator* getInternalManifoldPool()
+	{
+		return m_persistentManifoldPoolAllocator;
+	}
+
+	virtual const btPoolAllocator* getInternalManifoldPool() const
+	{
+		return m_persistentManifoldPoolAllocator;
+	}
+};
+
+#endif  //BT_COLLISION__DISPATCHER_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionDispatch/btCollisionDispatcherMt.h b/engine/inc/bullet/BulletCollision/CollisionDispatch/btCollisionDispatcherMt.h
new file mode 100644
index 00000000..1155de2c
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionDispatch/btCollisionDispatcherMt.h
@@ -0,0 +1,38 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_COLLISION_DISPATCHER_MT_H
+#define BT_COLLISION_DISPATCHER_MT_H
+
+#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h"
+#include "LinearMath/btThreads.h"
+
+class btCollisionDispatcherMt : public btCollisionDispatcher
+{
+public:
+	btCollisionDispatcherMt(btCollisionConfiguration* config, int grainSize = 40);
+
+	virtual btPersistentManifold* getNewManifold(const btCollisionObject* body0, const btCollisionObject* body1) BT_OVERRIDE;
+	virtual void releaseManifold(btPersistentManifold* manifold) BT_OVERRIDE;
+
+	virtual void dispatchAllCollisionPairs(btOverlappingPairCache* pairCache, const btDispatcherInfo& info, btDispatcher* dispatcher) BT_OVERRIDE;
+
+protected:
+	btAlignedObjectArray<btAlignedObjectArray<btPersistentManifold*> > m_batchManifoldsPtr;
+	bool m_batchUpdating;
+	int m_grainSize;
+};
+
+#endif  //BT_COLLISION_DISPATCHER_MT_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionDispatch/btCollisionObject.h b/engine/inc/bullet/BulletCollision/CollisionDispatch/btCollisionObject.h
new file mode 100644
index 00000000..e085c408
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionDispatch/btCollisionObject.h
@@ -0,0 +1,689 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_COLLISION_OBJECT_H
+#define BT_COLLISION_OBJECT_H
+
+#include "LinearMath/btTransform.h"
+
+//island management, m_activationState1
+#define ACTIVE_TAG 1
+#define ISLAND_SLEEPING 2
+#define WANTS_DEACTIVATION 3
+#define DISABLE_DEACTIVATION 4
+#define DISABLE_SIMULATION 5
+
+struct btBroadphaseProxy;
+class btCollisionShape;
+struct btCollisionShapeData;
+#include "LinearMath/btMotionState.h"
+#include "LinearMath/btAlignedAllocator.h"
+#include "LinearMath/btAlignedObjectArray.h"
+
+typedef btAlignedObjectArray<class btCollisionObject*> btCollisionObjectArray;
+
+#ifdef BT_USE_DOUBLE_PRECISION
+#define btCollisionObjectData btCollisionObjectDoubleData
+#define btCollisionObjectDataName "btCollisionObjectDoubleData"
+#else
+#define btCollisionObjectData btCollisionObjectFloatData
+#define btCollisionObjectDataName "btCollisionObjectFloatData"
+#endif
+
+/// btCollisionObject can be used to manage collision detection objects.
+/// btCollisionObject maintains all information that is needed for a collision detection: Shape, Transform and AABB proxy.
+/// They can be added to the btCollisionWorld.
+ATTRIBUTE_ALIGNED16(class)
+btCollisionObject
+{
+protected:
+	btTransform m_worldTransform;
+
+	///m_interpolationWorldTransform is used for CCD and interpolation
+	///it can be either previous or future (predicted) transform
+	btTransform m_interpolationWorldTransform;
+	//those two are experimental: just added for bullet time effect, so you can still apply impulses (directly modifying velocities)
+	//without destroying the continuous interpolated motion (which uses this interpolation velocities)
+	btVector3 m_interpolationLinearVelocity;
+	btVector3 m_interpolationAngularVelocity;
+
+	btVector3 m_anisotropicFriction;
+	int m_hasAnisotropicFriction;
+	btScalar m_contactProcessingThreshold;
+
+	btBroadphaseProxy* m_broadphaseHandle;
+	btCollisionShape* m_collisionShape;
+	///m_extensionPointer is used by some internal low-level Bullet extensions.
+	void* m_extensionPointer;
+
+	///m_rootCollisionShape is temporarily used to store the original collision shape
+	///The m_collisionShape might be temporarily replaced by a child collision shape during collision detection purposes
+	///If it is NULL, the m_collisionShape is not temporarily replaced.
+	btCollisionShape* m_rootCollisionShape;
+
+	int m_collisionFlags;
+
+	int m_islandTag1;
+	int m_companionId;
+	int m_worldArrayIndex;  // index of object in world's collisionObjects array
+
+	mutable int m_activationState1;
+	mutable btScalar m_deactivationTime;
+
+	btScalar m_friction;
+	btScalar m_restitution;
+	btScalar m_rollingFriction;   //torsional friction orthogonal to contact normal (useful to stop spheres rolling forever)
+	btScalar m_spinningFriction;  // torsional friction around the contact normal (useful for grasping)
+	btScalar m_contactDamping;
+	btScalar m_contactStiffness;
+
+	///m_internalType is reserved to distinguish Bullet's btCollisionObject, btRigidBody, btSoftBody, btGhostObject etc.
+	///do not assign your own m_internalType unless you write a new dynamics object class.
+	int m_internalType;
+
+	///users can point to their objects, m_userPointer is not used by Bullet, see setUserPointer/getUserPointer
+
+	void* m_userObjectPointer;
+
+	int m_userIndex2;
+
+	int m_userIndex;
+
+	int m_userIndex3;
+
+	///time of impact calculation
+	btScalar m_hitFraction;
+
+	///Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
+	btScalar m_ccdSweptSphereRadius;
+
+	/// Don't do continuous collision detection if the motion (in one step) is less then m_ccdMotionThreshold
+	btScalar m_ccdMotionThreshold;
+
+	/// If some object should have elaborate collision filtering by sub-classes
+	int m_checkCollideWith;
+
+	btAlignedObjectArray<const btCollisionObject*> m_objectsWithoutCollisionCheck;
+
+	///internal update revision number. It will be increased when the object changes. This allows some subsystems to perform lazy evaluation.
+	int m_updateRevision;
+
+	btVector3 m_customDebugColorRGB;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	enum CollisionFlags
+	{
+		CF_DYNAMIC_OBJECT = 0,
+		CF_STATIC_OBJECT = 1,
+		CF_KINEMATIC_OBJECT = 2,
+		CF_NO_CONTACT_RESPONSE = 4,
+		CF_CUSTOM_MATERIAL_CALLBACK = 8,  //this allows per-triangle material (friction/restitution)
+		CF_CHARACTER_OBJECT = 16,
+		CF_DISABLE_VISUALIZE_OBJECT = 32,          //disable debug drawing
+		CF_DISABLE_SPU_COLLISION_PROCESSING = 64,  //disable parallel/SPU processing
+		CF_HAS_CONTACT_STIFFNESS_DAMPING = 128,
+		CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR = 256,
+		CF_HAS_FRICTION_ANCHOR = 512,
+		CF_HAS_COLLISION_SOUND_TRIGGER = 1024
+	};
+
+	enum CollisionObjectTypes
+	{
+		CO_COLLISION_OBJECT = 1,
+		CO_RIGID_BODY = 2,
+		///CO_GHOST_OBJECT keeps track of all objects overlapping its AABB and that pass its collision filter
+		///It is useful for collision sensors, explosion objects, character controller etc.
+		CO_GHOST_OBJECT = 4,
+		CO_SOFT_BODY = 8,
+		CO_HF_FLUID = 16,
+		CO_USER_TYPE = 32,
+		CO_FEATHERSTONE_LINK = 64
+	};
+
+	enum AnisotropicFrictionFlags
+	{
+		CF_ANISOTROPIC_FRICTION_DISABLED = 0,
+		CF_ANISOTROPIC_FRICTION = 1,
+		CF_ANISOTROPIC_ROLLING_FRICTION = 2
+	};
+
+	SIMD_FORCE_INLINE bool mergesSimulationIslands() const
+	{
+		///static objects, kinematic and object without contact response don't merge islands
+		return ((m_collisionFlags & (CF_STATIC_OBJECT | CF_KINEMATIC_OBJECT | CF_NO_CONTACT_RESPONSE)) == 0);
+	}
+
+	const btVector3& getAnisotropicFriction() const
+	{
+		return m_anisotropicFriction;
+	}
+	void setAnisotropicFriction(const btVector3& anisotropicFriction, int frictionMode = CF_ANISOTROPIC_FRICTION)
+	{
+		m_anisotropicFriction = anisotropicFriction;
+		bool isUnity = (anisotropicFriction[0] != 1.f) || (anisotropicFriction[1] != 1.f) || (anisotropicFriction[2] != 1.f);
+		m_hasAnisotropicFriction = isUnity ? frictionMode : 0;
+	}
+	bool hasAnisotropicFriction(int frictionMode = CF_ANISOTROPIC_FRICTION) const
+	{
+		return (m_hasAnisotropicFriction & frictionMode) != 0;
+	}
+
+	///the constraint solver can discard solving contacts, if the distance is above this threshold. 0 by default.
+	///Note that using contacts with positive distance can improve stability. It increases, however, the chance of colliding with degerate contacts, such as 'interior' triangle edges
+	void setContactProcessingThreshold(btScalar contactProcessingThreshold)
+	{
+		m_contactProcessingThreshold = contactProcessingThreshold;
+	}
+	btScalar getContactProcessingThreshold() const
+	{
+		return m_contactProcessingThreshold;
+	}
+
+	SIMD_FORCE_INLINE bool isStaticObject() const
+	{
+		return (m_collisionFlags & CF_STATIC_OBJECT) != 0;
+	}
+
+	SIMD_FORCE_INLINE bool isKinematicObject() const
+	{
+		return (m_collisionFlags & CF_KINEMATIC_OBJECT) != 0;
+	}
+
+	SIMD_FORCE_INLINE bool isStaticOrKinematicObject() const
+	{
+		return (m_collisionFlags & (CF_KINEMATIC_OBJECT | CF_STATIC_OBJECT)) != 0;
+	}
+
+	SIMD_FORCE_INLINE bool hasContactResponse() const
+	{
+		return (m_collisionFlags & CF_NO_CONTACT_RESPONSE) == 0;
+	}
+
+	btCollisionObject();
+
+	virtual ~btCollisionObject();
+
+	virtual void setCollisionShape(btCollisionShape * collisionShape)
+	{
+		m_updateRevision++;
+		m_collisionShape = collisionShape;
+		m_rootCollisionShape = collisionShape;
+	}
+
+	SIMD_FORCE_INLINE const btCollisionShape* getCollisionShape() const
+	{
+		return m_collisionShape;
+	}
+
+	SIMD_FORCE_INLINE btCollisionShape* getCollisionShape()
+	{
+		return m_collisionShape;
+	}
+
+	void setIgnoreCollisionCheck(const btCollisionObject* co, bool ignoreCollisionCheck)
+	{
+		if (ignoreCollisionCheck)
+		{
+			//We don't check for duplicates. Is it ok to leave that up to the user of this API?
+			//int index = m_objectsWithoutCollisionCheck.findLinearSearch(co);
+			//if (index == m_objectsWithoutCollisionCheck.size())
+			//{
+			m_objectsWithoutCollisionCheck.push_back(co);
+			//}
+		}
+		else
+		{
+			m_objectsWithoutCollisionCheck.remove(co);
+		}
+		m_checkCollideWith = m_objectsWithoutCollisionCheck.size() > 0;
+	}
+
+        int getNumObjectsWithoutCollision() const
+	{
+		return m_objectsWithoutCollisionCheck.size();
+	}
+
+	const btCollisionObject* getObjectWithoutCollision(int index)
+	{
+		return m_objectsWithoutCollisionCheck[index];
+	}
+
+	virtual bool checkCollideWithOverride(const btCollisionObject* co) const
+	{
+		int index = m_objectsWithoutCollisionCheck.findLinearSearch(co);
+		if (index < m_objectsWithoutCollisionCheck.size())
+		{
+			return false;
+		}
+		return true;
+	}
+
+	///Avoid using this internal API call, the extension pointer is used by some Bullet extensions.
+	///If you need to store your own user pointer, use 'setUserPointer/getUserPointer' instead.
+	void* internalGetExtensionPointer() const
+	{
+		return m_extensionPointer;
+	}
+	///Avoid using this internal API call, the extension pointer is used by some Bullet extensions
+	///If you need to store your own user pointer, use 'setUserPointer/getUserPointer' instead.
+	void internalSetExtensionPointer(void* pointer)
+	{
+		m_extensionPointer = pointer;
+	}
+
+	SIMD_FORCE_INLINE int getActivationState() const { return m_activationState1; }
+
+	void setActivationState(int newState) const;
+
+	void setDeactivationTime(btScalar time)
+	{
+		m_deactivationTime = time;
+	}
+	btScalar getDeactivationTime() const
+	{
+		return m_deactivationTime;
+	}
+
+	void forceActivationState(int newState) const;
+
+	void activate(bool forceActivation = false) const;
+
+	SIMD_FORCE_INLINE bool isActive() const
+	{
+		return ((getActivationState() != ISLAND_SLEEPING) && (getActivationState() != DISABLE_SIMULATION));
+	}
+
+	void setRestitution(btScalar rest)
+	{
+		m_updateRevision++;
+		m_restitution = rest;
+	}
+	btScalar getRestitution() const
+	{
+		return m_restitution;
+	}
+	void setFriction(btScalar frict)
+	{
+		m_updateRevision++;
+		m_friction = frict;
+	}
+	btScalar getFriction() const
+	{
+		return m_friction;
+	}
+
+	void setRollingFriction(btScalar frict)
+	{
+		m_updateRevision++;
+		m_rollingFriction = frict;
+	}
+	btScalar getRollingFriction() const
+	{
+		return m_rollingFriction;
+	}
+	void setSpinningFriction(btScalar frict)
+	{
+		m_updateRevision++;
+		m_spinningFriction = frict;
+	}
+	btScalar getSpinningFriction() const
+	{
+		return m_spinningFriction;
+	}
+	void setContactStiffnessAndDamping(btScalar stiffness, btScalar damping)
+	{
+		m_updateRevision++;
+		m_contactStiffness = stiffness;
+		m_contactDamping = damping;
+
+		m_collisionFlags |= CF_HAS_CONTACT_STIFFNESS_DAMPING;
+
+		//avoid divisions by zero...
+		if (m_contactStiffness < SIMD_EPSILON)
+		{
+			m_contactStiffness = SIMD_EPSILON;
+		}
+	}
+
+	btScalar getContactStiffness() const
+	{
+		return m_contactStiffness;
+	}
+
+	btScalar getContactDamping() const
+	{
+		return m_contactDamping;
+	}
+
+	///reserved for Bullet internal usage
+	int getInternalType() const
+	{
+		return m_internalType;
+	}
+
+	btTransform& getWorldTransform()
+	{
+		return m_worldTransform;
+	}
+
+	const btTransform& getWorldTransform() const
+	{
+		return m_worldTransform;
+	}
+
+	void setWorldTransform(const btTransform& worldTrans)
+	{
+		m_updateRevision++;
+		m_worldTransform = worldTrans;
+	}
+
+	SIMD_FORCE_INLINE btBroadphaseProxy* getBroadphaseHandle()
+	{
+		return m_broadphaseHandle;
+	}
+
+	SIMD_FORCE_INLINE const btBroadphaseProxy* getBroadphaseHandle() const
+	{
+		return m_broadphaseHandle;
+	}
+
+	void setBroadphaseHandle(btBroadphaseProxy * handle)
+	{
+		m_broadphaseHandle = handle;
+	}
+
+	const btTransform& getInterpolationWorldTransform() const
+	{
+		return m_interpolationWorldTransform;
+	}
+
+	btTransform& getInterpolationWorldTransform()
+	{
+		return m_interpolationWorldTransform;
+	}
+
+	void setInterpolationWorldTransform(const btTransform& trans)
+	{
+		m_updateRevision++;
+		m_interpolationWorldTransform = trans;
+	}
+
+	void setInterpolationLinearVelocity(const btVector3& linvel)
+	{
+		m_updateRevision++;
+		m_interpolationLinearVelocity = linvel;
+	}
+
+	void setInterpolationAngularVelocity(const btVector3& angvel)
+	{
+		m_updateRevision++;
+		m_interpolationAngularVelocity = angvel;
+	}
+
+	const btVector3& getInterpolationLinearVelocity() const
+	{
+		return m_interpolationLinearVelocity;
+	}
+
+	const btVector3& getInterpolationAngularVelocity() const
+	{
+		return m_interpolationAngularVelocity;
+	}
+
+	SIMD_FORCE_INLINE int getIslandTag() const
+	{
+		return m_islandTag1;
+	}
+
+	void setIslandTag(int tag)
+	{
+		m_islandTag1 = tag;
+	}
+
+	SIMD_FORCE_INLINE int getCompanionId() const
+	{
+		return m_companionId;
+	}
+
+	void setCompanionId(int id)
+	{
+		m_companionId = id;
+	}
+
+	SIMD_FORCE_INLINE int getWorldArrayIndex() const
+	{
+		return m_worldArrayIndex;
+	}
+
+	// only should be called by CollisionWorld
+	void setWorldArrayIndex(int ix)
+	{
+		m_worldArrayIndex = ix;
+	}
+
+	SIMD_FORCE_INLINE btScalar getHitFraction() const
+	{
+		return m_hitFraction;
+	}
+
+	void setHitFraction(btScalar hitFraction)
+	{
+		m_hitFraction = hitFraction;
+	}
+
+	SIMD_FORCE_INLINE int getCollisionFlags() const
+	{
+		return m_collisionFlags;
+	}
+
+	void setCollisionFlags(int flags)
+	{
+		m_collisionFlags = flags;
+	}
+
+	///Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
+	btScalar getCcdSweptSphereRadius() const
+	{
+		return m_ccdSweptSphereRadius;
+	}
+
+	///Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
+	void setCcdSweptSphereRadius(btScalar radius)
+	{
+		m_ccdSweptSphereRadius = radius;
+	}
+
+	btScalar getCcdMotionThreshold() const
+	{
+		return m_ccdMotionThreshold;
+	}
+
+	btScalar getCcdSquareMotionThreshold() const
+	{
+		return m_ccdMotionThreshold * m_ccdMotionThreshold;
+	}
+
+	/// Don't do continuous collision detection if the motion (in one step) is less then m_ccdMotionThreshold
+	void setCcdMotionThreshold(btScalar ccdMotionThreshold)
+	{
+		m_ccdMotionThreshold = ccdMotionThreshold;
+	}
+
+	///users can point to their objects, userPointer is not used by Bullet
+	void* getUserPointer() const
+	{
+		return m_userObjectPointer;
+	}
+
+	int getUserIndex() const
+	{
+		return m_userIndex;
+	}
+
+	int getUserIndex2() const
+	{
+		return m_userIndex2;
+	}
+
+	int getUserIndex3() const
+	{
+		return m_userIndex3;
+	}
+
+	///users can point to their objects, userPointer is not used by Bullet
+	void setUserPointer(void* userPointer)
+	{
+		m_userObjectPointer = userPointer;
+	}
+
+	///users can point to their objects, userPointer is not used by Bullet
+	void setUserIndex(int index)
+	{
+		m_userIndex = index;
+	}
+
+	void setUserIndex2(int index)
+	{
+		m_userIndex2 = index;
+	}
+
+	void setUserIndex3(int index)
+	{
+		m_userIndex3 = index;
+	}
+
+	int getUpdateRevisionInternal() const
+	{
+		return m_updateRevision;
+	}
+
+	void setCustomDebugColor(const btVector3& colorRGB)
+	{
+		m_customDebugColorRGB = colorRGB;
+		m_collisionFlags |= CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR;
+	}
+
+	void removeCustomDebugColor()
+	{
+		m_collisionFlags &= ~CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR;
+	}
+
+	bool getCustomDebugColor(btVector3 & colorRGB) const
+	{
+		bool hasCustomColor = (0 != (m_collisionFlags & CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR));
+		if (hasCustomColor)
+		{
+			colorRGB = m_customDebugColorRGB;
+		}
+		return hasCustomColor;
+	}
+
+	inline bool checkCollideWith(const btCollisionObject* co) const
+	{
+		if (m_checkCollideWith)
+			return checkCollideWithOverride(co);
+
+		return true;
+	}
+
+	virtual int calculateSerializeBufferSize() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	virtual const char* serialize(void* dataBuffer, class btSerializer* serializer) const;
+
+	virtual void serializeSingleObject(class btSerializer * serializer) const;
+};
+
+// clang-format off
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct	btCollisionObjectDoubleData
+{
+	void					*m_broadphaseHandle;
+	void					*m_collisionShape;
+	btCollisionShapeData	*m_rootCollisionShape;
+	char					*m_name;
+
+	btTransformDoubleData	m_worldTransform;
+	btTransformDoubleData	m_interpolationWorldTransform;
+	btVector3DoubleData		m_interpolationLinearVelocity;
+	btVector3DoubleData		m_interpolationAngularVelocity;
+	btVector3DoubleData		m_anisotropicFriction;
+	double					m_contactProcessingThreshold;	
+	double					m_deactivationTime;
+	double					m_friction;
+	double					m_rollingFriction;
+	double                  m_contactDamping;
+	double                  m_contactStiffness;
+	double					m_restitution;
+	double					m_hitFraction; 
+	double					m_ccdSweptSphereRadius;
+	double					m_ccdMotionThreshold;
+	int						m_hasAnisotropicFriction;
+	int						m_collisionFlags;
+	int						m_islandTag1;
+	int						m_companionId;
+	int						m_activationState1;
+	int						m_internalType;
+	int						m_checkCollideWith;
+	int						m_collisionFilterGroup;
+	int						m_collisionFilterMask;
+	int						m_uniqueId;//m_uniqueId is introduced for paircache. could get rid of this, by calculating the address offset etc.
+};
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct	btCollisionObjectFloatData
+{
+	void					*m_broadphaseHandle;
+	void					*m_collisionShape;
+	btCollisionShapeData	*m_rootCollisionShape;
+	char					*m_name;
+
+	btTransformFloatData	m_worldTransform;
+	btTransformFloatData	m_interpolationWorldTransform;
+	btVector3FloatData		m_interpolationLinearVelocity;
+	btVector3FloatData		m_interpolationAngularVelocity;
+	btVector3FloatData		m_anisotropicFriction;
+	float					m_contactProcessingThreshold;	
+	float					m_deactivationTime;
+	float					m_friction;
+	float					m_rollingFriction;
+	float                   m_contactDamping;
+    float                   m_contactStiffness;
+	float					m_restitution;
+	float					m_hitFraction; 
+	float					m_ccdSweptSphereRadius;
+	float					m_ccdMotionThreshold;
+	int						m_hasAnisotropicFriction;
+	int						m_collisionFlags;
+	int						m_islandTag1;
+	int						m_companionId;
+	int						m_activationState1;
+	int						m_internalType;
+	int						m_checkCollideWith;
+	int						m_collisionFilterGroup;
+	int						m_collisionFilterMask;
+	int						m_uniqueId;
+};
+// clang-format on
+
+SIMD_FORCE_INLINE int btCollisionObject::calculateSerializeBufferSize() const
+{
+	return sizeof(btCollisionObjectData);
+}
+
+#endif  //BT_COLLISION_OBJECT_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h b/engine/inc/bullet/BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h
new file mode 100644
index 00000000..56341b7d
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h
@@ -0,0 +1,49 @@
+#ifndef BT_COLLISION_OBJECT_WRAPPER_H
+#define BT_COLLISION_OBJECT_WRAPPER_H
+
+///btCollisionObjectWrapperis an internal data structure.
+///Most users can ignore this and use btCollisionObject and btCollisionShape instead
+class btCollisionShape;
+class btCollisionObject;
+class btTransform;
+#include "LinearMath/btScalar.h"  // for SIMD_FORCE_INLINE definition
+
+#define BT_DECLARE_STACK_ONLY_OBJECT \
+private:                             \
+	void* operator new(size_t size); \
+	void operator delete(void*);
+
+struct btCollisionObjectWrapper;
+struct btCollisionObjectWrapper
+{
+	BT_DECLARE_STACK_ONLY_OBJECT
+
+private:
+	btCollisionObjectWrapper(const btCollisionObjectWrapper&);  // not implemented. Not allowed.
+	btCollisionObjectWrapper* operator=(const btCollisionObjectWrapper&);
+
+public:
+	const btCollisionObjectWrapper* m_parent;
+	const btCollisionShape* m_shape;
+	const btCollisionObject* m_collisionObject;
+	const btTransform& m_worldTransform;
+    const btTransform* m_preTransform;
+	int m_partId;
+	int m_index;
+
+	btCollisionObjectWrapper(const btCollisionObjectWrapper* parent, const btCollisionShape* shape, const btCollisionObject* collisionObject, const btTransform& worldTransform, int partId, int index)
+		: m_parent(parent), m_shape(shape), m_collisionObject(collisionObject), m_worldTransform(worldTransform), m_preTransform(NULL), m_partId(partId), m_index(index)
+	{
+	}
+    
+    btCollisionObjectWrapper(const btCollisionObjectWrapper* parent, const btCollisionShape* shape, const btCollisionObject* collisionObject, const btTransform& worldTransform, const btTransform& preTransform, int partId, int index)
+    : m_parent(parent), m_shape(shape), m_collisionObject(collisionObject), m_worldTransform(worldTransform), m_preTransform(&preTransform), m_partId(partId), m_index(index)
+    {
+    }
+
+	SIMD_FORCE_INLINE const btTransform& getWorldTransform() const { return m_worldTransform; }
+	SIMD_FORCE_INLINE const btCollisionObject* getCollisionObject() const { return m_collisionObject; }
+	SIMD_FORCE_INLINE const btCollisionShape* getCollisionShape() const { return m_shape; }
+};
+
+#endif  //BT_COLLISION_OBJECT_WRAPPER_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionDispatch/btCollisionWorld.h b/engine/inc/bullet/BulletCollision/CollisionDispatch/btCollisionWorld.h
new file mode 100644
index 00000000..fd0e5b9b
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionDispatch/btCollisionWorld.h
@@ -0,0 +1,513 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+/**
+ * @mainpage Bullet Documentation
+ *
+ * @section intro_sec Introduction
+ * Bullet is a Collision Detection and Rigid Body Dynamics Library. The Library is Open Source and free for commercial use, under the ZLib license ( http://opensource.org/licenses/zlib-license.php ).
+ *
+ * The main documentation is Bullet_User_Manual.pdf, included in the source code distribution.
+ * There is the Physics Forum for feedback and general Collision Detection and Physics discussions.
+ * Please visit http://www.bulletphysics.org
+ *
+ * @section install_sec Installation
+ *
+ * @subsection step1 Step 1: Download
+ * You can download the Bullet Physics Library from the github repository: https://github.com/bulletphysics/bullet3/releases 
+ *
+ * @subsection step2 Step 2: Building
+ * Bullet has multiple build systems, including premake, cmake and autotools. Premake and cmake support all platforms.
+ * Premake is included in the Bullet/build folder for Windows, Mac OSX and Linux. 
+ * Under Windows you can click on Bullet/build/vs2010.bat to create Microsoft Visual Studio projects. 
+ * On Mac OSX and Linux you can open a terminal and generate Makefile, codeblocks or Xcode4 projects:
+ * cd Bullet/build
+ * ./premake4_osx gmake or ./premake4_linux gmake or ./premake4_linux64 gmake or (for Mac) ./premake4_osx xcode4
+ * cd Bullet/build/gmake
+ * make
+ * 
+ * An alternative to premake is cmake. You can download cmake from http://www.cmake.org
+ * cmake can autogenerate projectfiles for Microsoft Visual Studio, Apple Xcode, KDevelop and Unix Makefiles.
+ * The easiest is to run the CMake cmake-gui graphical user interface and choose the options and generate projectfiles.
+ * You can also use cmake in the command-line. Here are some examples for various platforms:
+ * cmake . -G "Visual Studio 9 2008"
+ * cmake . -G Xcode
+ * cmake . -G "Unix Makefiles"
+ * Although cmake is recommended, you can also use autotools for UNIX: ./autogen.sh ./configure to create a Makefile and then run make.
+ * 
+ * @subsection step3 Step 3: Testing demos
+ * Try to run and experiment with BasicDemo executable as a starting point.
+ * Bullet can be used in several ways, as Full Rigid Body simulation, as Collision Detector Library or Low Level / Snippets like the GJK Closest Point calculation.
+ * The Dependencies can be seen in this documentation under Directories
+ * 
+ * @subsection step4 Step 4: Integrating in your application, full Rigid Body and Soft Body simulation
+ * Check out BasicDemo how to create a btDynamicsWorld, btRigidBody and btCollisionShape, Stepping the simulation and synchronizing your graphics object transform.
+ * Check out SoftDemo how to use soft body dynamics, using btSoftRigidDynamicsWorld.
+ * @subsection step5 Step 5 : Integrate the Collision Detection Library (without Dynamics and other Extras)
+ * Bullet Collision Detection can also be used without the Dynamics/Extras.
+ * Check out btCollisionWorld and btCollisionObject, and the CollisionInterfaceDemo.
+ * @subsection step6 Step 6 : Use Snippets like the GJK Closest Point calculation.
+ * Bullet has been designed in a modular way keeping dependencies to a minimum. The ConvexHullDistance demo demonstrates direct use of btGjkPairDetector.
+ *
+ * @section copyright Copyright
+ * For up-to-data information and copyright and contributors list check out the Bullet_User_Manual.pdf
+ * 
+ */
+
+#ifndef BT_COLLISION_WORLD_H
+#define BT_COLLISION_WORLD_H
+
+class btCollisionShape;
+class btConvexShape;
+class btBroadphaseInterface;
+class btSerializer;
+
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btTransform.h"
+#include "btCollisionObject.h"
+#include "btCollisionDispatcher.h"
+#include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h"
+#include "LinearMath/btAlignedObjectArray.h"
+
+///CollisionWorld is interface and container for the collision detection
+class btCollisionWorld
+{
+protected:
+	btAlignedObjectArray<btCollisionObject*> m_collisionObjects;
+
+	btDispatcher* m_dispatcher1;
+
+	btDispatcherInfo m_dispatchInfo;
+
+	btBroadphaseInterface* m_broadphasePairCache;
+
+	btIDebugDraw* m_debugDrawer;
+
+	///m_forceUpdateAllAabbs can be set to false as an optimization to only update active object AABBs
+	///it is true by default, because it is error-prone (setting the position of static objects wouldn't update their AABB)
+	bool m_forceUpdateAllAabbs;
+
+	void serializeCollisionObjects(btSerializer* serializer);
+
+	void serializeContactManifolds(btSerializer* serializer);
+
+public:
+	//this constructor doesn't own the dispatcher and paircache/broadphase
+	btCollisionWorld(btDispatcher* dispatcher, btBroadphaseInterface* broadphasePairCache, btCollisionConfiguration* collisionConfiguration);
+
+	virtual ~btCollisionWorld();
+
+	void setBroadphase(btBroadphaseInterface* pairCache)
+	{
+		m_broadphasePairCache = pairCache;
+	}
+
+	const btBroadphaseInterface* getBroadphase() const
+	{
+		return m_broadphasePairCache;
+	}
+
+	btBroadphaseInterface* getBroadphase()
+	{
+		return m_broadphasePairCache;
+	}
+
+	btOverlappingPairCache* getPairCache()
+	{
+		return m_broadphasePairCache->getOverlappingPairCache();
+	}
+
+	btDispatcher* getDispatcher()
+	{
+		return m_dispatcher1;
+	}
+
+	const btDispatcher* getDispatcher() const
+	{
+		return m_dispatcher1;
+	}
+
+	void updateSingleAabb(btCollisionObject* colObj);
+
+	virtual void updateAabbs();
+
+	///the computeOverlappingPairs is usually already called by performDiscreteCollisionDetection (or stepSimulation)
+	///it can be useful to use if you perform ray tests without collision detection/simulation
+	virtual void computeOverlappingPairs();
+
+	virtual void setDebugDrawer(btIDebugDraw* debugDrawer)
+	{
+		m_debugDrawer = debugDrawer;
+	}
+
+	virtual btIDebugDraw* getDebugDrawer()
+	{
+		return m_debugDrawer;
+	}
+
+	virtual void debugDrawWorld();
+
+	virtual void debugDrawObject(const btTransform& worldTransform, const btCollisionShape* shape, const btVector3& color);
+
+	///LocalShapeInfo gives extra information for complex shapes
+	///Currently, only btTriangleMeshShape is available, so it just contains triangleIndex and subpart
+	struct LocalShapeInfo
+	{
+		int m_shapePart;
+		int m_triangleIndex;
+
+		//const btCollisionShape*	m_shapeTemp;
+		//const btTransform*	m_shapeLocalTransform;
+	};
+
+	struct LocalRayResult
+	{
+		LocalRayResult(const btCollisionObject* collisionObject,
+					   LocalShapeInfo* localShapeInfo,
+					   const btVector3& hitNormalLocal,
+					   btScalar hitFraction)
+			: m_collisionObject(collisionObject),
+			  m_localShapeInfo(localShapeInfo),
+			  m_hitNormalLocal(hitNormalLocal),
+			  m_hitFraction(hitFraction)
+		{
+		}
+
+		const btCollisionObject* m_collisionObject;
+		LocalShapeInfo* m_localShapeInfo;
+		btVector3 m_hitNormalLocal;
+		btScalar m_hitFraction;
+	};
+
+	///RayResultCallback is used to report new raycast results
+	struct RayResultCallback
+	{
+		btScalar m_closestHitFraction;
+		const btCollisionObject* m_collisionObject;
+		int m_collisionFilterGroup;
+		int m_collisionFilterMask;
+		//@BP Mod - Custom flags, currently used to enable backface culling on tri-meshes, see btRaycastCallback.h. Apply any of the EFlags defined there on m_flags here to invoke.
+		unsigned int m_flags;
+
+		virtual ~RayResultCallback()
+		{
+		}
+		bool hasHit() const
+		{
+			return (m_collisionObject != 0);
+		}
+
+		RayResultCallback()
+			: m_closestHitFraction(btScalar(1.)),
+			  m_collisionObject(0),
+			  m_collisionFilterGroup(btBroadphaseProxy::DefaultFilter),
+			  m_collisionFilterMask(btBroadphaseProxy::AllFilter),
+			  //@BP Mod
+			  m_flags(0)
+		{
+		}
+
+		virtual bool needsCollision(btBroadphaseProxy* proxy0) const
+		{
+			bool collides = (proxy0->m_collisionFilterGroup & m_collisionFilterMask) != 0;
+			collides = collides && (m_collisionFilterGroup & proxy0->m_collisionFilterMask);
+			return collides;
+		}
+
+		virtual btScalar addSingleResult(LocalRayResult& rayResult, bool normalInWorldSpace) = 0;
+	};
+
+	struct ClosestRayResultCallback : public RayResultCallback
+	{
+		ClosestRayResultCallback(const btVector3& rayFromWorld, const btVector3& rayToWorld)
+			: m_rayFromWorld(rayFromWorld),
+			  m_rayToWorld(rayToWorld)
+		{
+		}
+
+		btVector3 m_rayFromWorld;  //used to calculate hitPointWorld from hitFraction
+		btVector3 m_rayToWorld;
+
+		btVector3 m_hitNormalWorld;
+		btVector3 m_hitPointWorld;
+
+		virtual btScalar addSingleResult(LocalRayResult& rayResult, bool normalInWorldSpace)
+		{
+			//caller already does the filter on the m_closestHitFraction
+			btAssert(rayResult.m_hitFraction <= m_closestHitFraction);
+
+			m_closestHitFraction = rayResult.m_hitFraction;
+			m_collisionObject = rayResult.m_collisionObject;
+			if (normalInWorldSpace)
+			{
+				m_hitNormalWorld = rayResult.m_hitNormalLocal;
+			}
+			else
+			{
+				///need to transform normal into worldspace
+				m_hitNormalWorld = m_collisionObject->getWorldTransform().getBasis() * rayResult.m_hitNormalLocal;
+			}
+			m_hitPointWorld.setInterpolate3(m_rayFromWorld, m_rayToWorld, rayResult.m_hitFraction);
+			return rayResult.m_hitFraction;
+		}
+	};
+
+	struct AllHitsRayResultCallback : public RayResultCallback
+	{
+		AllHitsRayResultCallback(const btVector3& rayFromWorld, const btVector3& rayToWorld)
+			: m_rayFromWorld(rayFromWorld),
+			  m_rayToWorld(rayToWorld)
+		{
+		}
+
+		btAlignedObjectArray<const btCollisionObject*> m_collisionObjects;
+
+		btVector3 m_rayFromWorld;  //used to calculate hitPointWorld from hitFraction
+		btVector3 m_rayToWorld;
+
+		btAlignedObjectArray<btVector3> m_hitNormalWorld;
+		btAlignedObjectArray<btVector3> m_hitPointWorld;
+		btAlignedObjectArray<btScalar> m_hitFractions;
+
+		virtual btScalar addSingleResult(LocalRayResult& rayResult, bool normalInWorldSpace)
+		{
+			m_collisionObject = rayResult.m_collisionObject;
+			m_collisionObjects.push_back(rayResult.m_collisionObject);
+			btVector3 hitNormalWorld;
+			if (normalInWorldSpace)
+			{
+				hitNormalWorld = rayResult.m_hitNormalLocal;
+			}
+			else
+			{
+				///need to transform normal into worldspace
+				hitNormalWorld = m_collisionObject->getWorldTransform().getBasis() * rayResult.m_hitNormalLocal;
+			}
+			m_hitNormalWorld.push_back(hitNormalWorld);
+			btVector3 hitPointWorld;
+			hitPointWorld.setInterpolate3(m_rayFromWorld, m_rayToWorld, rayResult.m_hitFraction);
+			m_hitPointWorld.push_back(hitPointWorld);
+			m_hitFractions.push_back(rayResult.m_hitFraction);
+			return m_closestHitFraction;
+		}
+	};
+
+	struct LocalConvexResult
+	{
+		LocalConvexResult(const btCollisionObject* hitCollisionObject,
+						  LocalShapeInfo* localShapeInfo,
+						  const btVector3& hitNormalLocal,
+						  const btVector3& hitPointLocal,
+						  btScalar hitFraction)
+			: m_hitCollisionObject(hitCollisionObject),
+			  m_localShapeInfo(localShapeInfo),
+			  m_hitNormalLocal(hitNormalLocal),
+			  m_hitPointLocal(hitPointLocal),
+			  m_hitFraction(hitFraction)
+		{
+		}
+
+		const btCollisionObject* m_hitCollisionObject;
+		LocalShapeInfo* m_localShapeInfo;
+		btVector3 m_hitNormalLocal;
+		btVector3 m_hitPointLocal;
+		btScalar m_hitFraction;
+	};
+
+	///RayResultCallback is used to report new raycast results
+	struct ConvexResultCallback
+	{
+		btScalar m_closestHitFraction;
+		int m_collisionFilterGroup;
+		int m_collisionFilterMask;
+
+		ConvexResultCallback()
+			: m_closestHitFraction(btScalar(1.)),
+			  m_collisionFilterGroup(btBroadphaseProxy::DefaultFilter),
+			  m_collisionFilterMask(btBroadphaseProxy::AllFilter)
+		{
+		}
+
+		virtual ~ConvexResultCallback()
+		{
+		}
+
+		bool hasHit() const
+		{
+			return (m_closestHitFraction < btScalar(1.));
+		}
+
+		virtual bool needsCollision(btBroadphaseProxy* proxy0) const
+		{
+			bool collides = (proxy0->m_collisionFilterGroup & m_collisionFilterMask) != 0;
+			collides = collides && (m_collisionFilterGroup & proxy0->m_collisionFilterMask);
+			return collides;
+		}
+
+		virtual btScalar addSingleResult(LocalConvexResult& convexResult, bool normalInWorldSpace) = 0;
+	};
+
+	struct ClosestConvexResultCallback : public ConvexResultCallback
+	{
+		ClosestConvexResultCallback(const btVector3& convexFromWorld, const btVector3& convexToWorld)
+			: m_convexFromWorld(convexFromWorld),
+			  m_convexToWorld(convexToWorld),
+			  m_hitCollisionObject(0)
+		{
+		}
+
+		btVector3 m_convexFromWorld;  //used to calculate hitPointWorld from hitFraction
+		btVector3 m_convexToWorld;
+
+		btVector3 m_hitNormalWorld;
+		btVector3 m_hitPointWorld;
+		const btCollisionObject* m_hitCollisionObject;
+
+		virtual btScalar addSingleResult(LocalConvexResult& convexResult, bool normalInWorldSpace)
+		{
+			//caller already does the filter on the m_closestHitFraction
+			btAssert(convexResult.m_hitFraction <= m_closestHitFraction);
+
+			m_closestHitFraction = convexResult.m_hitFraction;
+			m_hitCollisionObject = convexResult.m_hitCollisionObject;
+			if (normalInWorldSpace)
+			{
+				m_hitNormalWorld = convexResult.m_hitNormalLocal;
+			}
+			else
+			{
+				///need to transform normal into worldspace
+				m_hitNormalWorld = m_hitCollisionObject->getWorldTransform().getBasis() * convexResult.m_hitNormalLocal;
+			}
+			m_hitPointWorld = convexResult.m_hitPointLocal;
+			return convexResult.m_hitFraction;
+		}
+	};
+
+	///ContactResultCallback is used to report contact points
+	struct ContactResultCallback
+	{
+		int m_collisionFilterGroup;
+		int m_collisionFilterMask;
+		btScalar m_closestDistanceThreshold;
+
+		ContactResultCallback()
+			: m_collisionFilterGroup(btBroadphaseProxy::DefaultFilter),
+			  m_collisionFilterMask(btBroadphaseProxy::AllFilter),
+			  m_closestDistanceThreshold(0)
+		{
+		}
+
+		virtual ~ContactResultCallback()
+		{
+		}
+
+		virtual bool needsCollision(btBroadphaseProxy* proxy0) const
+		{
+			bool collides = (proxy0->m_collisionFilterGroup & m_collisionFilterMask) != 0;
+			collides = collides && (m_collisionFilterGroup & proxy0->m_collisionFilterMask);
+			return collides;
+		}
+
+		virtual btScalar addSingleResult(btManifoldPoint& cp, const btCollisionObjectWrapper* colObj0Wrap, int partId0, int index0, const btCollisionObjectWrapper* colObj1Wrap, int partId1, int index1) = 0;
+	};
+
+	int getNumCollisionObjects() const
+	{
+		return int(m_collisionObjects.size());
+	}
+
+	/// rayTest performs a raycast on all objects in the btCollisionWorld, and calls the resultCallback
+	/// This allows for several queries: first hit, all hits, any hit, dependent on the value returned by the callback.
+	virtual void rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback) const;
+
+	/// convexTest performs a swept convex cast on all objects in the btCollisionWorld, and calls the resultCallback
+	/// This allows for several queries: first hit, all hits, any hit, dependent on the value return by the callback.
+	void convexSweepTest(const btConvexShape* castShape, const btTransform& from, const btTransform& to, ConvexResultCallback& resultCallback, btScalar allowedCcdPenetration = btScalar(0.)) const;
+
+	///contactTest performs a discrete collision test between colObj against all objects in the btCollisionWorld, and calls the resultCallback.
+	///it reports one or more contact points for every overlapping object (including the one with deepest penetration)
+	void contactTest(btCollisionObject* colObj, ContactResultCallback& resultCallback);
+
+	///contactTest performs a discrete collision test between two collision objects and calls the resultCallback if overlap if detected.
+	///it reports one or more contact points (including the one with deepest penetration)
+	void contactPairTest(btCollisionObject* colObjA, btCollisionObject* colObjB, ContactResultCallback& resultCallback);
+
+	/// rayTestSingle performs a raycast call and calls the resultCallback. It is used internally by rayTest.
+	/// In a future implementation, we consider moving the ray test as a virtual method in btCollisionShape.
+	/// This allows more customization.
+	static void rayTestSingle(const btTransform& rayFromTrans, const btTransform& rayToTrans,
+							  btCollisionObject* collisionObject,
+							  const btCollisionShape* collisionShape,
+							  const btTransform& colObjWorldTransform,
+							  RayResultCallback& resultCallback);
+
+	static void rayTestSingleInternal(const btTransform& rayFromTrans, const btTransform& rayToTrans,
+									  const btCollisionObjectWrapper* collisionObjectWrap,
+									  RayResultCallback& resultCallback);
+
+	/// objectQuerySingle performs a collision detection query and calls the resultCallback. It is used internally by rayTest.
+	static void objectQuerySingle(const btConvexShape* castShape, const btTransform& rayFromTrans, const btTransform& rayToTrans,
+								  btCollisionObject* collisionObject,
+								  const btCollisionShape* collisionShape,
+								  const btTransform& colObjWorldTransform,
+								  ConvexResultCallback& resultCallback, btScalar allowedPenetration);
+
+	static void objectQuerySingleInternal(const btConvexShape* castShape, const btTransform& convexFromTrans, const btTransform& convexToTrans,
+										  const btCollisionObjectWrapper* colObjWrap,
+										  ConvexResultCallback& resultCallback, btScalar allowedPenetration);
+
+	virtual void addCollisionObject(btCollisionObject* collisionObject, int collisionFilterGroup = btBroadphaseProxy::DefaultFilter, int collisionFilterMask = btBroadphaseProxy::AllFilter);
+
+	virtual void refreshBroadphaseProxy(btCollisionObject* collisionObject);
+
+	btCollisionObjectArray& getCollisionObjectArray()
+	{
+		return m_collisionObjects;
+	}
+
+	const btCollisionObjectArray& getCollisionObjectArray() const
+	{
+		return m_collisionObjects;
+	}
+
+	virtual void removeCollisionObject(btCollisionObject* collisionObject);
+
+	virtual void performDiscreteCollisionDetection();
+
+	btDispatcherInfo& getDispatchInfo()
+	{
+		return m_dispatchInfo;
+	}
+
+	const btDispatcherInfo& getDispatchInfo() const
+	{
+		return m_dispatchInfo;
+	}
+
+	bool getForceUpdateAllAabbs() const
+	{
+		return m_forceUpdateAllAabbs;
+	}
+	void setForceUpdateAllAabbs(bool forceUpdateAllAabbs)
+	{
+		m_forceUpdateAllAabbs = forceUpdateAllAabbs;
+	}
+
+	///Preliminary serialization test for Bullet 2.76. Loading those files requires a separate parser (Bullet/Demos/SerializeDemo)
+	virtual void serialize(btSerializer* serializer);
+};
+
+#endif  //BT_COLLISION_WORLD_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionDispatch/btCollisionWorldImporter.h b/engine/inc/bullet/BulletCollision/CollisionDispatch/btCollisionWorldImporter.h
new file mode 100644
index 00000000..5e8bc953
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionDispatch/btCollisionWorldImporter.h
@@ -0,0 +1,169 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2014 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_COLLISION_WORLD_IMPORTER_H
+#define BT_COLLISION_WORLD_IMPORTER_H
+
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btAlignedObjectArray.h"
+#include "LinearMath/btHashMap.h"
+
+class btCollisionShape;
+class btCollisionObject;
+struct btBulletSerializedArrays;
+
+struct ConstraintInput;
+class btCollisionWorld;
+struct btCollisionShapeData;
+class btTriangleIndexVertexArray;
+class btStridingMeshInterface;
+struct btStridingMeshInterfaceData;
+class btGImpactMeshShape;
+class btOptimizedBvh;
+struct btTriangleInfoMap;
+class btBvhTriangleMeshShape;
+class btPoint2PointConstraint;
+class btHingeConstraint;
+class btConeTwistConstraint;
+class btGeneric6DofConstraint;
+class btGeneric6DofSpringConstraint;
+class btSliderConstraint;
+class btGearConstraint;
+struct btContactSolverInfo;
+
+class btCollisionWorldImporter
+{
+protected:
+	btCollisionWorld* m_collisionWorld;
+
+	int m_verboseMode;
+
+	btAlignedObjectArray<btCollisionShape*> m_allocatedCollisionShapes;
+	btAlignedObjectArray<btCollisionObject*> m_allocatedRigidBodies;
+
+	btAlignedObjectArray<btOptimizedBvh*> m_allocatedBvhs;
+	btAlignedObjectArray<btTriangleInfoMap*> m_allocatedTriangleInfoMaps;
+	btAlignedObjectArray<btTriangleIndexVertexArray*> m_allocatedTriangleIndexArrays;
+	btAlignedObjectArray<btStridingMeshInterfaceData*> m_allocatedbtStridingMeshInterfaceDatas;
+	btAlignedObjectArray<btCollisionObject*> m_allocatedCollisionObjects;
+
+	btAlignedObjectArray<char*> m_allocatedNames;
+
+	btAlignedObjectArray<int*> m_indexArrays;
+	btAlignedObjectArray<short int*> m_shortIndexArrays;
+	btAlignedObjectArray<unsigned char*> m_charIndexArrays;
+
+	btAlignedObjectArray<btVector3FloatData*> m_floatVertexArrays;
+	btAlignedObjectArray<btVector3DoubleData*> m_doubleVertexArrays;
+
+	btHashMap<btHashPtr, btOptimizedBvh*> m_bvhMap;
+	btHashMap<btHashPtr, btTriangleInfoMap*> m_timMap;
+
+	btHashMap<btHashString, btCollisionShape*> m_nameShapeMap;
+	btHashMap<btHashString, btCollisionObject*> m_nameColObjMap;
+
+	btHashMap<btHashPtr, const char*> m_objectNameMap;
+
+	btHashMap<btHashPtr, btCollisionShape*> m_shapeMap;
+	btHashMap<btHashPtr, btCollisionObject*> m_bodyMap;
+
+	//methods
+
+	char* duplicateName(const char* name);
+
+	btCollisionShape* convertCollisionShape(btCollisionShapeData* shapeData);
+
+public:
+	btCollisionWorldImporter(btCollisionWorld* world);
+
+	virtual ~btCollisionWorldImporter();
+
+	bool convertAllObjects(btBulletSerializedArrays* arrays);
+
+	///delete all memory collision shapes, rigid bodies, constraints etc. allocated during the load.
+	///make sure you don't use the dynamics world containing objects after you call this method
+	virtual void deleteAllData();
+
+	void setVerboseMode(int verboseMode)
+	{
+		m_verboseMode = verboseMode;
+	}
+
+	int getVerboseMode() const
+	{
+		return m_verboseMode;
+	}
+
+	// query for data
+	int getNumCollisionShapes() const;
+	btCollisionShape* getCollisionShapeByIndex(int index);
+	int getNumRigidBodies() const;
+	btCollisionObject* getRigidBodyByIndex(int index) const;
+
+	int getNumBvhs() const;
+	btOptimizedBvh* getBvhByIndex(int index) const;
+	int getNumTriangleInfoMaps() const;
+	btTriangleInfoMap* getTriangleInfoMapByIndex(int index) const;
+
+	// queris involving named objects
+	btCollisionShape* getCollisionShapeByName(const char* name);
+	btCollisionObject* getCollisionObjectByName(const char* name);
+
+	const char* getNameForPointer(const void* ptr) const;
+
+	///those virtuals are called by load and can be overridden by the user
+
+	//bodies
+
+	virtual btCollisionObject* createCollisionObject(const btTransform& startTransform, btCollisionShape* shape, const char* bodyName);
+
+	///shapes
+
+	virtual btCollisionShape* createPlaneShape(const btVector3& planeNormal, btScalar planeConstant);
+	virtual btCollisionShape* createBoxShape(const btVector3& halfExtents);
+	virtual btCollisionShape* createSphereShape(btScalar radius);
+	virtual btCollisionShape* createCapsuleShapeX(btScalar radius, btScalar height);
+	virtual btCollisionShape* createCapsuleShapeY(btScalar radius, btScalar height);
+	virtual btCollisionShape* createCapsuleShapeZ(btScalar radius, btScalar height);
+
+	virtual btCollisionShape* createCylinderShapeX(btScalar radius, btScalar height);
+	virtual btCollisionShape* createCylinderShapeY(btScalar radius, btScalar height);
+	virtual btCollisionShape* createCylinderShapeZ(btScalar radius, btScalar height);
+	virtual btCollisionShape* createConeShapeX(btScalar radius, btScalar height);
+	virtual btCollisionShape* createConeShapeY(btScalar radius, btScalar height);
+	virtual btCollisionShape* createConeShapeZ(btScalar radius, btScalar height);
+	virtual class btTriangleIndexVertexArray* createTriangleMeshContainer();
+	virtual btBvhTriangleMeshShape* createBvhTriangleMeshShape(btStridingMeshInterface* trimesh, btOptimizedBvh* bvh);
+	virtual btCollisionShape* createConvexTriangleMeshShape(btStridingMeshInterface* trimesh);
+#ifdef SUPPORT_GIMPACT_SHAPE_IMPORT
+	virtual btGImpactMeshShape* createGimpactShape(btStridingMeshInterface* trimesh);
+#endif  //SUPPORT_GIMPACT_SHAPE_IMPORT
+	virtual btStridingMeshInterfaceData* createStridingMeshInterfaceData(btStridingMeshInterfaceData* interfaceData);
+
+	virtual class btConvexHullShape* createConvexHullShape();
+	virtual class btCompoundShape* createCompoundShape();
+	virtual class btScaledBvhTriangleMeshShape* createScaledTrangleMeshShape(btBvhTriangleMeshShape* meshShape, const btVector3& localScalingbtBvhTriangleMeshShape);
+
+	virtual class btMultiSphereShape* createMultiSphereShape(const btVector3* positions, const btScalar* radi, int numSpheres);
+
+	virtual btTriangleIndexVertexArray* createMeshInterface(btStridingMeshInterfaceData& meshData);
+
+	///acceleration and connectivity structures
+	virtual btOptimizedBvh* createOptimizedBvh();
+	virtual btTriangleInfoMap* createTriangleInfoMap();
+};
+
+#endif  //BT_WORLD_IMPORTER_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h b/engine/inc/bullet/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h
new file mode 100644
index 00000000..4ea5e771
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h
@@ -0,0 +1,99 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+
+*/
+
+#ifndef BT_COMPOUND_COLLISION_ALGORITHM_H
+#define BT_COMPOUND_COLLISION_ALGORITHM_H
+
+#include "btActivatingCollisionAlgorithm.h"
+#include "BulletCollision/BroadphaseCollision/btDispatcher.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h"
+
+#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
+class btDispatcher;
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+#include "btCollisionCreateFunc.h"
+#include "LinearMath/btAlignedObjectArray.h"
+#include "BulletCollision/BroadphaseCollision/btDbvt.h"
+class btDispatcher;
+class btCollisionObject;
+
+class btCollisionShape;
+typedef bool (*btShapePairCallback)(const btCollisionShape* pShape0, const btCollisionShape* pShape1);
+extern btShapePairCallback gCompoundChildShapePairCallback;
+
+/// btCompoundCollisionAlgorithm  supports collision between CompoundCollisionShapes and other collision shapes
+class btCompoundCollisionAlgorithm : public btActivatingCollisionAlgorithm
+{
+	btNodeStack stack2;
+	btManifoldArray manifoldArray;
+
+protected:
+	btAlignedObjectArray<btCollisionAlgorithm*> m_childCollisionAlgorithms;
+	bool m_isSwapped;
+
+	class btPersistentManifold* m_sharedManifold;
+	bool m_ownsManifold;
+
+	int m_compoundShapeRevision;  //to keep track of changes, so that childAlgorithm array can be updated
+
+	void removeChildAlgorithms();
+
+	void preallocateChildAlgorithms(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap);
+
+public:
+	btCompoundCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, bool isSwapped);
+
+	virtual ~btCompoundCollisionAlgorithm();
+
+	btCollisionAlgorithm* getChildAlgorithm(int n) const
+	{
+		return m_childCollisionAlgorithms[n];
+	}
+
+	virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	btScalar calculateTimeOfImpact(btCollisionObject* body0, btCollisionObject* body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	virtual void getAllContactManifolds(btManifoldArray& manifoldArray)
+	{
+		int i;
+		for (i = 0; i < m_childCollisionAlgorithms.size(); i++)
+		{
+			if (m_childCollisionAlgorithms[i])
+				m_childCollisionAlgorithms[i]->getAllContactManifolds(manifoldArray);
+		}
+	}
+
+	struct CreateFunc : public btCollisionAlgorithmCreateFunc
+	{
+		virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap)
+		{
+			void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btCompoundCollisionAlgorithm));
+			return new (mem) btCompoundCollisionAlgorithm(ci, body0Wrap, body1Wrap, false);
+		}
+	};
+
+	struct SwappedCreateFunc : public btCollisionAlgorithmCreateFunc
+	{
+		virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap)
+		{
+			void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btCompoundCollisionAlgorithm));
+			return new (mem) btCompoundCollisionAlgorithm(ci, body0Wrap, body1Wrap, true);
+		}
+	};
+};
+
+#endif  //BT_COMPOUND_COLLISION_ALGORITHM_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.h b/engine/inc/bullet/BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.h
new file mode 100644
index 00000000..a940d840
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.h
@@ -0,0 +1,82 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+
+*/
+
+#ifndef BT_COMPOUND_COMPOUND_COLLISION_ALGORITHM_H
+#define BT_COMPOUND_COMPOUND_COLLISION_ALGORITHM_H
+
+#include "btCompoundCollisionAlgorithm.h"
+
+#include "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h"
+#include "BulletCollision/BroadphaseCollision/btDispatcher.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h"
+
+#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
+class btDispatcher;
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
+#include "LinearMath/btAlignedObjectArray.h"
+#include "BulletCollision/CollisionDispatch/btHashedSimplePairCache.h"
+class btDispatcher;
+class btCollisionObject;
+
+class btCollisionShape;
+
+extern btShapePairCallback gCompoundCompoundChildShapePairCallback;
+
+/// btCompoundCompoundCollisionAlgorithm  supports collision between two btCompoundCollisionShape shapes
+class btCompoundCompoundCollisionAlgorithm : public btCompoundCollisionAlgorithm
+{
+	class btHashedSimplePairCache* m_childCollisionAlgorithmCache;
+	btSimplePairArray m_removePairs;
+
+	int m_compoundShapeRevision0;  //to keep track of changes, so that childAlgorithm array can be updated
+	int m_compoundShapeRevision1;
+
+	void removeChildAlgorithms();
+
+	//	void	preallocateChildAlgorithms(const btCollisionObjectWrapper* body0Wrap,const btCollisionObjectWrapper* body1Wrap);
+
+public:
+	btCompoundCompoundCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, bool isSwapped);
+
+	virtual ~btCompoundCompoundCollisionAlgorithm();
+
+	virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	btScalar calculateTimeOfImpact(btCollisionObject* body0, btCollisionObject* body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	virtual void getAllContactManifolds(btManifoldArray& manifoldArray);
+
+	struct CreateFunc : public btCollisionAlgorithmCreateFunc
+	{
+		virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap)
+		{
+			void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btCompoundCompoundCollisionAlgorithm));
+			return new (mem) btCompoundCompoundCollisionAlgorithm(ci, body0Wrap, body1Wrap, false);
+		}
+	};
+
+	struct SwappedCreateFunc : public btCollisionAlgorithmCreateFunc
+	{
+		virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap)
+		{
+			void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btCompoundCompoundCollisionAlgorithm));
+			return new (mem) btCompoundCompoundCollisionAlgorithm(ci, body0Wrap, body1Wrap, true);
+		}
+	};
+};
+
+#endif  //BT_COMPOUND_COMPOUND_COLLISION_ALGORITHM_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.h b/engine/inc/bullet/BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.h
new file mode 100644
index 00000000..9fca463f
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.h
@@ -0,0 +1,83 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_CONVEX_2D_CONVEX_2D_ALGORITHM_H
+#define BT_CONVEX_2D_CONVEX_2D_ALGORITHM_H
+
+#include "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h"
+#include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h"
+#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+#include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h"
+#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
+#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h"
+#include "LinearMath/btTransformUtil.h"  //for btConvexSeparatingDistanceUtil
+
+class btConvexPenetrationDepthSolver;
+
+///The convex2dConvex2dAlgorithm collision algorithm support 2d collision detection for btConvex2dShape
+///Currently it requires the btMinkowskiPenetrationDepthSolver, it has support for 2d penetration depth computation
+class btConvex2dConvex2dAlgorithm : public btActivatingCollisionAlgorithm
+{
+	btSimplexSolverInterface* m_simplexSolver;
+	btConvexPenetrationDepthSolver* m_pdSolver;
+
+	bool m_ownManifold;
+	btPersistentManifold* m_manifoldPtr;
+	bool m_lowLevelOfDetail;
+
+public:
+	btConvex2dConvex2dAlgorithm(btPersistentManifold* mf, const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* pdSolver, int numPerturbationIterations, int minimumPointsPerturbationThreshold);
+
+	virtual ~btConvex2dConvex2dAlgorithm();
+
+	virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	virtual btScalar calculateTimeOfImpact(btCollisionObject* body0, btCollisionObject* body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	virtual void getAllContactManifolds(btManifoldArray& manifoldArray)
+	{
+		///should we use m_ownManifold to avoid adding duplicates?
+		if (m_manifoldPtr && m_ownManifold)
+			manifoldArray.push_back(m_manifoldPtr);
+	}
+
+	void setLowLevelOfDetail(bool useLowLevel);
+
+	const btPersistentManifold* getManifold()
+	{
+		return m_manifoldPtr;
+	}
+
+	struct CreateFunc : public btCollisionAlgorithmCreateFunc
+	{
+		btConvexPenetrationDepthSolver* m_pdSolver;
+		btSimplexSolverInterface* m_simplexSolver;
+		int m_numPerturbationIterations;
+		int m_minimumPointsPerturbationThreshold;
+
+		CreateFunc(btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* pdSolver);
+
+		virtual ~CreateFunc();
+
+		virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap)
+		{
+			void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btConvex2dConvex2dAlgorithm));
+			return new (mem) btConvex2dConvex2dAlgorithm(ci.m_manifold, ci, body0Wrap, body1Wrap, m_simplexSolver, m_pdSolver, m_numPerturbationIterations, m_minimumPointsPerturbationThreshold);
+		}
+	};
+};
+
+#endif  //BT_CONVEX_2D_CONVEX_2D_ALGORITHM_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h b/engine/inc/bullet/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h
new file mode 100644
index 00000000..b72e4029
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h
@@ -0,0 +1,117 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_CONVEX_CONCAVE_COLLISION_ALGORITHM_H
+#define BT_CONVEX_CONCAVE_COLLISION_ALGORITHM_H
+
+#include "btActivatingCollisionAlgorithm.h"
+#include "BulletCollision/BroadphaseCollision/btDispatcher.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h"
+#include "BulletCollision/CollisionShapes/btTriangleCallback.h"
+#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
+class btDispatcher;
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+#include "btCollisionCreateFunc.h"
+
+///For each triangle in the concave mesh that overlaps with the AABB of a convex (m_convexProxy), processTriangle is called.
+ATTRIBUTE_ALIGNED16(class)
+btConvexTriangleCallback : public btTriangleCallback
+{
+	btVector3 m_aabbMin;
+	btVector3 m_aabbMax;
+
+	const btCollisionObjectWrapper* m_convexBodyWrap;
+	const btCollisionObjectWrapper* m_triBodyWrap;
+
+	btManifoldResult* m_resultOut;
+	btDispatcher* m_dispatcher;
+	const btDispatcherInfo* m_dispatchInfoPtr;
+	btScalar m_collisionMarginTriangle;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	int m_triangleCount;
+
+	btPersistentManifold* m_manifoldPtr;
+
+	btConvexTriangleCallback(btDispatcher * dispatcher, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, bool isSwapped);
+
+	void setTimeStepAndCounters(btScalar collisionMarginTriangle, const btDispatcherInfo& dispatchInfo, const btCollisionObjectWrapper* convexBodyWrap, const btCollisionObjectWrapper* triBodyWrap, btManifoldResult* resultOut);
+
+	void clearWrapperData()
+	{
+		m_convexBodyWrap = 0;
+		m_triBodyWrap = 0;
+	}
+	virtual ~btConvexTriangleCallback();
+
+	virtual void processTriangle(btVector3 * triangle, int partId, int triangleIndex);
+
+	void clearCache();
+
+	SIMD_FORCE_INLINE const btVector3& getAabbMin() const
+	{
+		return m_aabbMin;
+	}
+	SIMD_FORCE_INLINE const btVector3& getAabbMax() const
+	{
+		return m_aabbMax;
+	}
+};
+
+/// btConvexConcaveCollisionAlgorithm  supports collision between convex shapes and (concave) trianges meshes.
+ATTRIBUTE_ALIGNED16(class)
+btConvexConcaveCollisionAlgorithm : public btActivatingCollisionAlgorithm
+{
+	btConvexTriangleCallback m_btConvexTriangleCallback;
+
+	bool m_isSwapped;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btConvexConcaveCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, bool isSwapped);
+
+	virtual ~btConvexConcaveCollisionAlgorithm();
+
+	virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	btScalar calculateTimeOfImpact(btCollisionObject * body0, btCollisionObject * body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	virtual void getAllContactManifolds(btManifoldArray & manifoldArray);
+
+	void clearCache();
+
+	struct CreateFunc : public btCollisionAlgorithmCreateFunc
+	{
+		virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap)
+		{
+			void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btConvexConcaveCollisionAlgorithm));
+			return new (mem) btConvexConcaveCollisionAlgorithm(ci, body0Wrap, body1Wrap, false);
+		}
+	};
+
+	struct SwappedCreateFunc : public btCollisionAlgorithmCreateFunc
+	{
+		virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap)
+		{
+			void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btConvexConcaveCollisionAlgorithm));
+			return new (mem) btConvexConcaveCollisionAlgorithm(ci, body0Wrap, body1Wrap, true);
+		}
+	};
+};
+
+#endif  //BT_CONVEX_CONCAVE_COLLISION_ALGORITHM_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h b/engine/inc/bullet/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h
new file mode 100644
index 00000000..eac5b4d8
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h
@@ -0,0 +1,101 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_CONVEX_CONVEX_ALGORITHM_H
+#define BT_CONVEX_CONVEX_ALGORITHM_H
+
+#include "btActivatingCollisionAlgorithm.h"
+#include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h"
+#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+#include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h"
+#include "btCollisionCreateFunc.h"
+#include "btCollisionDispatcher.h"
+#include "LinearMath/btTransformUtil.h"  //for btConvexSeparatingDistanceUtil
+#include "BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.h"
+
+class btConvexPenetrationDepthSolver;
+
+///Enabling USE_SEPDISTANCE_UTIL2 requires 100% reliable distance computation. However, when using large size ratios GJK can be imprecise
+///so the distance is not conservative. In that case, enabling this USE_SEPDISTANCE_UTIL2 would result in failing/missing collisions.
+///Either improve GJK for large size ratios (testing a 100 units versus a 0.1 unit object) or only enable the util
+///for certain pairs that have a small size ratio
+
+//#define USE_SEPDISTANCE_UTIL2 1
+
+///The convexConvexAlgorithm collision algorithm implements time of impact, convex closest points and penetration depth calculations between two convex objects.
+///Multiple contact points are calculated by perturbing the orientation of the smallest object orthogonal to the separating normal.
+///This idea was described by Gino van den Bergen in this forum topic http://www.bulletphysics.com/Bullet/phpBB3/viewtopic.php?f=4&t=288&p=888#p888
+class btConvexConvexAlgorithm : public btActivatingCollisionAlgorithm
+{
+#ifdef USE_SEPDISTANCE_UTIL2
+	btConvexSeparatingDistanceUtil m_sepDistance;
+#endif
+	btConvexPenetrationDepthSolver* m_pdSolver;
+
+	btVertexArray worldVertsB1;
+	btVertexArray worldVertsB2;
+
+	bool m_ownManifold;
+	btPersistentManifold* m_manifoldPtr;
+	bool m_lowLevelOfDetail;
+
+	int m_numPerturbationIterations;
+	int m_minimumPointsPerturbationThreshold;
+
+	///cache separating vector to speedup collision detection
+
+public:
+	btConvexConvexAlgorithm(btPersistentManifold* mf, const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, btConvexPenetrationDepthSolver* pdSolver, int numPerturbationIterations, int minimumPointsPerturbationThreshold);
+
+	virtual ~btConvexConvexAlgorithm();
+
+	virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	virtual btScalar calculateTimeOfImpact(btCollisionObject* body0, btCollisionObject* body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	virtual void getAllContactManifolds(btManifoldArray& manifoldArray)
+	{
+		///should we use m_ownManifold to avoid adding duplicates?
+		if (m_manifoldPtr && m_ownManifold)
+			manifoldArray.push_back(m_manifoldPtr);
+	}
+
+	void setLowLevelOfDetail(bool useLowLevel);
+
+	const btPersistentManifold* getManifold()
+	{
+		return m_manifoldPtr;
+	}
+
+	struct CreateFunc : public btCollisionAlgorithmCreateFunc
+	{
+		btConvexPenetrationDepthSolver* m_pdSolver;
+		int m_numPerturbationIterations;
+		int m_minimumPointsPerturbationThreshold;
+
+		CreateFunc(btConvexPenetrationDepthSolver* pdSolver);
+
+		virtual ~CreateFunc();
+
+		virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap)
+		{
+			void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btConvexConvexAlgorithm));
+			return new (mem) btConvexConvexAlgorithm(ci.m_manifold, ci, body0Wrap, body1Wrap, m_pdSolver, m_numPerturbationIterations, m_minimumPointsPerturbationThreshold);
+		}
+	};
+};
+
+#endif  //BT_CONVEX_CONVEX_ALGORITHM_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.h b/engine/inc/bullet/BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.h
new file mode 100644
index 00000000..b693da11
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.h
@@ -0,0 +1,82 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_CONVEX_PLANE_COLLISION_ALGORITHM_H
+#define BT_CONVEX_PLANE_COLLISION_ALGORITHM_H
+
+#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
+class btPersistentManifold;
+#include "btCollisionDispatcher.h"
+
+#include "LinearMath/btVector3.h"
+
+/// btSphereBoxCollisionAlgorithm  provides sphere-box collision detection.
+/// Other features are frame-coherency (persistent data) and collision response.
+class btConvexPlaneCollisionAlgorithm : public btCollisionAlgorithm
+{
+	bool m_ownManifold;
+	btPersistentManifold* m_manifoldPtr;
+	bool m_isSwapped;
+	int m_numPerturbationIterations;
+	int m_minimumPointsPerturbationThreshold;
+
+public:
+	btConvexPlaneCollisionAlgorithm(btPersistentManifold* mf, const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, bool isSwapped, int numPerturbationIterations, int minimumPointsPerturbationThreshold);
+
+	virtual ~btConvexPlaneCollisionAlgorithm();
+
+	virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	void collideSingleContact(const btQuaternion& perturbeRot, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	virtual btScalar calculateTimeOfImpact(btCollisionObject* body0, btCollisionObject* body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	virtual void getAllContactManifolds(btManifoldArray& manifoldArray)
+	{
+		if (m_manifoldPtr && m_ownManifold)
+		{
+			manifoldArray.push_back(m_manifoldPtr);
+		}
+	}
+
+	struct CreateFunc : public btCollisionAlgorithmCreateFunc
+	{
+		int m_numPerturbationIterations;
+		int m_minimumPointsPerturbationThreshold;
+
+		CreateFunc()
+			: m_numPerturbationIterations(1),
+			  m_minimumPointsPerturbationThreshold(0)
+		{
+		}
+
+		virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap)
+		{
+			void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btConvexPlaneCollisionAlgorithm));
+			if (!m_swapped)
+			{
+				return new (mem) btConvexPlaneCollisionAlgorithm(0, ci, body0Wrap, body1Wrap, false, m_numPerturbationIterations, m_minimumPointsPerturbationThreshold);
+			}
+			else
+			{
+				return new (mem) btConvexPlaneCollisionAlgorithm(0, ci, body0Wrap, body1Wrap, true, m_numPerturbationIterations, m_minimumPointsPerturbationThreshold);
+			}
+		}
+	};
+};
+
+#endif  //BT_CONVEX_PLANE_COLLISION_ALGORITHM_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h b/engine/inc/bullet/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h
new file mode 100644
index 00000000..b39a3f41
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h
@@ -0,0 +1,111 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_DEFAULT_COLLISION_CONFIGURATION
+#define BT_DEFAULT_COLLISION_CONFIGURATION
+
+#include "btCollisionConfiguration.h"
+class btVoronoiSimplexSolver;
+class btConvexPenetrationDepthSolver;
+
+struct btDefaultCollisionConstructionInfo
+{
+	btPoolAllocator* m_persistentManifoldPool;
+	btPoolAllocator* m_collisionAlgorithmPool;
+	int m_defaultMaxPersistentManifoldPoolSize;
+	int m_defaultMaxCollisionAlgorithmPoolSize;
+	int m_customCollisionAlgorithmMaxElementSize;
+	int m_useEpaPenetrationAlgorithm;
+
+	btDefaultCollisionConstructionInfo()
+		: m_persistentManifoldPool(0),
+		  m_collisionAlgorithmPool(0),
+		  m_defaultMaxPersistentManifoldPoolSize(4096),
+		  m_defaultMaxCollisionAlgorithmPoolSize(4096),
+		  m_customCollisionAlgorithmMaxElementSize(0),
+		  m_useEpaPenetrationAlgorithm(true)
+	{
+	}
+};
+
+///btCollisionConfiguration allows to configure Bullet collision detection
+///stack allocator, pool memory allocators
+///@todo: describe the meaning
+class btDefaultCollisionConfiguration : public btCollisionConfiguration
+{
+protected:
+	int m_persistentManifoldPoolSize;
+
+	btPoolAllocator* m_persistentManifoldPool;
+	bool m_ownsPersistentManifoldPool;
+
+	btPoolAllocator* m_collisionAlgorithmPool;
+	bool m_ownsCollisionAlgorithmPool;
+
+	//default penetration depth solver
+	btConvexPenetrationDepthSolver* m_pdSolver;
+
+	//default CreationFunctions, filling the m_doubleDispatch table
+	btCollisionAlgorithmCreateFunc* m_convexConvexCreateFunc;
+	btCollisionAlgorithmCreateFunc* m_convexConcaveCreateFunc;
+	btCollisionAlgorithmCreateFunc* m_swappedConvexConcaveCreateFunc;
+	btCollisionAlgorithmCreateFunc* m_compoundCreateFunc;
+	btCollisionAlgorithmCreateFunc* m_compoundCompoundCreateFunc;
+
+	btCollisionAlgorithmCreateFunc* m_swappedCompoundCreateFunc;
+	btCollisionAlgorithmCreateFunc* m_emptyCreateFunc;
+	btCollisionAlgorithmCreateFunc* m_sphereSphereCF;
+	btCollisionAlgorithmCreateFunc* m_sphereBoxCF;
+	btCollisionAlgorithmCreateFunc* m_boxSphereCF;
+
+	btCollisionAlgorithmCreateFunc* m_boxBoxCF;
+	btCollisionAlgorithmCreateFunc* m_sphereTriangleCF;
+	btCollisionAlgorithmCreateFunc* m_triangleSphereCF;
+	btCollisionAlgorithmCreateFunc* m_planeConvexCF;
+	btCollisionAlgorithmCreateFunc* m_convexPlaneCF;
+
+public:
+	btDefaultCollisionConfiguration(const btDefaultCollisionConstructionInfo& constructionInfo = btDefaultCollisionConstructionInfo());
+
+	virtual ~btDefaultCollisionConfiguration();
+
+	///memory pools
+	virtual btPoolAllocator* getPersistentManifoldPool()
+	{
+		return m_persistentManifoldPool;
+	}
+
+	virtual btPoolAllocator* getCollisionAlgorithmPool()
+	{
+		return m_collisionAlgorithmPool;
+	}
+
+	virtual btCollisionAlgorithmCreateFunc* getCollisionAlgorithmCreateFunc(int proxyType0, int proxyType1);
+
+	virtual btCollisionAlgorithmCreateFunc* getClosestPointsAlgorithmCreateFunc(int proxyType0, int proxyType1);
+
+	///Use this method to allow to generate multiple contact points between at once, between two objects using the generic convex-convex algorithm.
+	///By default, this feature is disabled for best performance.
+	///@param numPerturbationIterations controls the number of collision queries. Set it to zero to disable the feature.
+	///@param minimumPointsPerturbationThreshold is the minimum number of points in the contact cache, above which the feature is disabled
+	///3 is a good value for both params, if you want to enable the feature. This is because the default contact cache contains a maximum of 4 points, and one collision query at the unperturbed orientation is performed first.
+	///See Bullet/Demos/CollisionDemo for an example how this feature gathers multiple points.
+	///@todo we could add a per-object setting of those parameters, for level-of-detail collision detection.
+	void setConvexConvexMultipointIterations(int numPerturbationIterations = 3, int minimumPointsPerturbationThreshold = 3);
+
+	void setPlaneConvexMultipointIterations(int numPerturbationIterations = 3, int minimumPointsPerturbationThreshold = 3);
+};
+
+#endif  //BT_DEFAULT_COLLISION_CONFIGURATION
diff --git a/engine/inc/bullet/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h b/engine/inc/bullet/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h
new file mode 100644
index 00000000..65ef83e0
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h
@@ -0,0 +1,52 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_EMPTY_ALGORITH
+#define BT_EMPTY_ALGORITH
+#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+#include "btCollisionCreateFunc.h"
+#include "btCollisionDispatcher.h"
+
+#define ATTRIBUTE_ALIGNED(a)
+
+///EmptyAlgorithm is a stub for unsupported collision pairs.
+///The dispatcher can dispatch a persistent btEmptyAlgorithm to avoid a search every frame.
+class btEmptyAlgorithm : public btCollisionAlgorithm
+{
+public:
+	btEmptyAlgorithm(const btCollisionAlgorithmConstructionInfo& ci);
+
+	virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	virtual btScalar calculateTimeOfImpact(btCollisionObject* body0, btCollisionObject* body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	virtual void getAllContactManifolds(btManifoldArray& manifoldArray)
+	{
+	}
+
+	struct CreateFunc : public btCollisionAlgorithmCreateFunc
+	{
+		virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap)
+		{
+			(void)body0Wrap;
+			(void)body1Wrap;
+			void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btEmptyAlgorithm));
+			return new (mem) btEmptyAlgorithm(ci);
+		}
+	};
+
+} ATTRIBUTE_ALIGNED(16);
+
+#endif  //BT_EMPTY_ALGORITH
diff --git a/engine/inc/bullet/BulletCollision/CollisionDispatch/btGhostObject.h b/engine/inc/bullet/BulletCollision/CollisionDispatch/btGhostObject.h
new file mode 100644
index 00000000..aa7f48d5
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionDispatch/btGhostObject.h
@@ -0,0 +1,162 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2008 Erwin Coumans  http://bulletphysics.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_GHOST_OBJECT_H
+#define BT_GHOST_OBJECT_H
+
+#include "btCollisionObject.h"
+#include "BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h"
+#include "LinearMath/btAlignedAllocator.h"
+#include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h"
+#include "btCollisionWorld.h"
+
+class btConvexShape;
+
+class btDispatcher;
+
+///The btGhostObject can keep track of all objects that are overlapping
+///By default, this overlap is based on the AABB
+///This is useful for creating a character controller, collision sensors/triggers, explosions etc.
+///We plan on adding rayTest and other queries for the btGhostObject
+ATTRIBUTE_ALIGNED16(class)
+btGhostObject : public btCollisionObject
+{
+protected:
+	btAlignedObjectArray<btCollisionObject*> m_overlappingObjects;
+
+public:
+	btGhostObject();
+
+	virtual ~btGhostObject();
+
+	void convexSweepTest(const class btConvexShape* castShape, const btTransform& convexFromWorld, const btTransform& convexToWorld, btCollisionWorld::ConvexResultCallback& resultCallback, btScalar allowedCcdPenetration = 0.f) const;
+
+	void rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, btCollisionWorld::RayResultCallback& resultCallback) const;
+
+	///this method is mainly for expert/internal use only.
+	virtual void addOverlappingObjectInternal(btBroadphaseProxy * otherProxy, btBroadphaseProxy* thisProxy = 0);
+	///this method is mainly for expert/internal use only.
+	virtual void removeOverlappingObjectInternal(btBroadphaseProxy * otherProxy, btDispatcher * dispatcher, btBroadphaseProxy* thisProxy = 0);
+
+	int getNumOverlappingObjects() const
+	{
+		return m_overlappingObjects.size();
+	}
+
+	btCollisionObject* getOverlappingObject(int index)
+	{
+		return m_overlappingObjects[index];
+	}
+
+	const btCollisionObject* getOverlappingObject(int index) const
+	{
+		return m_overlappingObjects[index];
+	}
+
+	btAlignedObjectArray<btCollisionObject*>& getOverlappingPairs()
+	{
+		return m_overlappingObjects;
+	}
+
+	const btAlignedObjectArray<btCollisionObject*> getOverlappingPairs() const
+	{
+		return m_overlappingObjects;
+	}
+
+	//
+	// internal cast
+	//
+
+	static const btGhostObject* upcast(const btCollisionObject* colObj)
+	{
+		if (colObj->getInternalType() == CO_GHOST_OBJECT)
+			return (const btGhostObject*)colObj;
+		return 0;
+	}
+	static btGhostObject* upcast(btCollisionObject * colObj)
+	{
+		if (colObj->getInternalType() == CO_GHOST_OBJECT)
+			return (btGhostObject*)colObj;
+		return 0;
+	}
+};
+
+class btPairCachingGhostObject : public btGhostObject
+{
+	btHashedOverlappingPairCache* m_hashPairCache;
+
+public:
+	btPairCachingGhostObject();
+
+	virtual ~btPairCachingGhostObject();
+
+	///this method is mainly for expert/internal use only.
+	virtual void addOverlappingObjectInternal(btBroadphaseProxy* otherProxy, btBroadphaseProxy* thisProxy = 0);
+
+	virtual void removeOverlappingObjectInternal(btBroadphaseProxy* otherProxy, btDispatcher* dispatcher, btBroadphaseProxy* thisProxy = 0);
+
+	btHashedOverlappingPairCache* getOverlappingPairCache()
+	{
+		return m_hashPairCache;
+	}
+};
+
+///The btGhostPairCallback interfaces and forwards adding and removal of overlapping pairs from the btBroadphaseInterface to btGhostObject.
+class btGhostPairCallback : public btOverlappingPairCallback
+{
+public:
+	btGhostPairCallback()
+	{
+	}
+
+	virtual ~btGhostPairCallback()
+	{
+	}
+
+	virtual btBroadphasePair* addOverlappingPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1)
+	{
+		btCollisionObject* colObj0 = (btCollisionObject*)proxy0->m_clientObject;
+		btCollisionObject* colObj1 = (btCollisionObject*)proxy1->m_clientObject;
+		btGhostObject* ghost0 = btGhostObject::upcast(colObj0);
+		btGhostObject* ghost1 = btGhostObject::upcast(colObj1);
+		if (ghost0)
+			ghost0->addOverlappingObjectInternal(proxy1, proxy0);
+		if (ghost1)
+			ghost1->addOverlappingObjectInternal(proxy0, proxy1);
+		return 0;
+	}
+
+	virtual void* removeOverlappingPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1, btDispatcher* dispatcher)
+	{
+		btCollisionObject* colObj0 = (btCollisionObject*)proxy0->m_clientObject;
+		btCollisionObject* colObj1 = (btCollisionObject*)proxy1->m_clientObject;
+		btGhostObject* ghost0 = btGhostObject::upcast(colObj0);
+		btGhostObject* ghost1 = btGhostObject::upcast(colObj1);
+		if (ghost0)
+			ghost0->removeOverlappingObjectInternal(proxy1, dispatcher, proxy0);
+		if (ghost1)
+			ghost1->removeOverlappingObjectInternal(proxy0, dispatcher, proxy1);
+		return 0;
+	}
+
+	virtual void removeOverlappingPairsContainingProxy(btBroadphaseProxy* /*proxy0*/, btDispatcher* /*dispatcher*/)
+	{
+		btAssert(0);
+		//need to keep track of all ghost objects and call them here
+		//m_hashPairCache->removeOverlappingPairsContainingProxy(proxy0,dispatcher);
+	}
+};
+
+#endif
diff --git a/engine/inc/bullet/BulletCollision/CollisionDispatch/btHashedSimplePairCache.h b/engine/inc/bullet/BulletCollision/CollisionDispatch/btHashedSimplePairCache.h
new file mode 100644
index 00000000..fd38a4f0
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionDispatch/btHashedSimplePairCache.h
@@ -0,0 +1,149 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_HASHED_SIMPLE_PAIR_CACHE_H
+#define BT_HASHED_SIMPLE_PAIR_CACHE_H
+
+#include "LinearMath/btAlignedObjectArray.h"
+
+const int BT_SIMPLE_NULL_PAIR = 0xffffffff;
+
+struct btSimplePair
+{
+	btSimplePair(int indexA, int indexB)
+		: m_indexA(indexA),
+		  m_indexB(indexB),
+		  m_userPointer(0)
+	{
+	}
+
+	int m_indexA;
+	int m_indexB;
+	union {
+		void* m_userPointer;
+		int m_userValue;
+	};
+};
+
+typedef btAlignedObjectArray<btSimplePair> btSimplePairArray;
+
+#ifdef BT_DEBUG_COLLISION_PAIRS
+extern int gOverlappingSimplePairs;
+extern int gRemoveSimplePairs;
+extern int gAddedSimplePairs;
+extern int gFindSimplePairs;
+#endif  //BT_DEBUG_COLLISION_PAIRS
+
+class btHashedSimplePairCache
+{
+	btSimplePairArray m_overlappingPairArray;
+
+protected:
+	btAlignedObjectArray<int> m_hashTable;
+	btAlignedObjectArray<int> m_next;
+
+public:
+	btHashedSimplePairCache();
+	virtual ~btHashedSimplePairCache();
+
+	void removeAllPairs();
+
+	virtual void* removeOverlappingPair(int indexA, int indexB);
+
+	// Add a pair and return the new pair. If the pair already exists,
+	// no new pair is created and the old one is returned.
+	virtual btSimplePair* addOverlappingPair(int indexA, int indexB)
+	{
+#ifdef BT_DEBUG_COLLISION_PAIRS
+		gAddedSimplePairs++;
+#endif
+
+		return internalAddPair(indexA, indexB);
+	}
+
+	virtual btSimplePair* getOverlappingPairArrayPtr()
+	{
+		return &m_overlappingPairArray[0];
+	}
+
+	const btSimplePair* getOverlappingPairArrayPtr() const
+	{
+		return &m_overlappingPairArray[0];
+	}
+
+	btSimplePairArray& getOverlappingPairArray()
+	{
+		return m_overlappingPairArray;
+	}
+
+	const btSimplePairArray& getOverlappingPairArray() const
+	{
+		return m_overlappingPairArray;
+	}
+
+	btSimplePair* findPair(int indexA, int indexB);
+
+	int GetCount() const { return m_overlappingPairArray.size(); }
+
+	int getNumOverlappingPairs() const
+	{
+		return m_overlappingPairArray.size();
+	}
+
+private:
+	btSimplePair* internalAddPair(int indexA, int indexB);
+
+	void growTables();
+
+	SIMD_FORCE_INLINE bool equalsPair(const btSimplePair& pair, int indexA, int indexB)
+	{
+		return pair.m_indexA == indexA && pair.m_indexB == indexB;
+	}
+
+	SIMD_FORCE_INLINE unsigned int getHash(unsigned int indexA, unsigned int indexB)
+	{
+		unsigned int key = indexA | (indexB << 16);
+		// Thomas Wang's hash
+
+		key += ~(key << 15);
+		key ^= (key >> 10);
+		key += (key << 3);
+		key ^= (key >> 6);
+		key += ~(key << 11);
+		key ^= (key >> 16);
+		return key;
+	}
+
+	SIMD_FORCE_INLINE btSimplePair* internalFindPair(int proxyIdA, int proxyIdB, int hash)
+	{
+		int index = m_hashTable[hash];
+
+		while (index != BT_SIMPLE_NULL_PAIR && equalsPair(m_overlappingPairArray[index], proxyIdA, proxyIdB) == false)
+		{
+			index = m_next[index];
+		}
+
+		if (index == BT_SIMPLE_NULL_PAIR)
+		{
+			return NULL;
+		}
+
+		btAssert(index < m_overlappingPairArray.size());
+
+		return &m_overlappingPairArray[index];
+	}
+};
+
+#endif  //BT_HASHED_SIMPLE_PAIR_CACHE_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionDispatch/btInternalEdgeUtility.h b/engine/inc/bullet/BulletCollision/CollisionDispatch/btInternalEdgeUtility.h
new file mode 100644
index 00000000..cc6d11c2
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionDispatch/btInternalEdgeUtility.h
@@ -0,0 +1,44 @@
+
+#ifndef BT_INTERNAL_EDGE_UTILITY_H
+#define BT_INTERNAL_EDGE_UTILITY_H
+
+#include "LinearMath/btHashMap.h"
+#include "LinearMath/btVector3.h"
+
+#include "BulletCollision/CollisionShapes/btTriangleInfoMap.h"
+
+///The btInternalEdgeUtility helps to avoid or reduce artifacts due to wrong collision normals caused by internal edges.
+///See also http://code.google.com/p/bullet/issues/detail?id=27
+
+class btBvhTriangleMeshShape;
+class btCollisionObject;
+struct btCollisionObjectWrapper;
+class btManifoldPoint;
+class btIDebugDraw;
+class btHeightfieldTerrainShape;
+
+enum btInternalEdgeAdjustFlags
+{
+	BT_TRIANGLE_CONVEX_BACKFACE_MODE = 1,
+	BT_TRIANGLE_CONCAVE_DOUBLE_SIDED = 2,  //double sided options are experimental, single sided is recommended
+	BT_TRIANGLE_CONVEX_DOUBLE_SIDED = 4
+};
+
+///Call btGenerateInternalEdgeInfo to create triangle info, store in the shape 'userInfo'
+void btGenerateInternalEdgeInfo(btBvhTriangleMeshShape* trimeshShape, btTriangleInfoMap* triangleInfoMap);
+
+void btGenerateInternalEdgeInfo(btHeightfieldTerrainShape* trimeshShape, btTriangleInfoMap* triangleInfoMap);
+
+///Call the btFixMeshNormal to adjust the collision normal, using the triangle info map (generated using btGenerateInternalEdgeInfo)
+///If this info map is missing, or the triangle is not store in this map, nothing will be done
+void btAdjustInternalEdgeContacts(btManifoldPoint& cp, const btCollisionObjectWrapper* trimeshColObj0Wrap, const btCollisionObjectWrapper* otherColObj1Wrap, int partId0, int index0, int normalAdjustFlags = 0);
+
+///Enable the BT_INTERNAL_EDGE_DEBUG_DRAW define and call btSetDebugDrawer, to get visual info to see if the internal edge utility works properly.
+///If the utility doesn't work properly, you might have to adjust the threshold values in btTriangleInfoMap
+//#define BT_INTERNAL_EDGE_DEBUG_DRAW
+
+#ifdef BT_INTERNAL_EDGE_DEBUG_DRAW
+void btSetDebugDrawer(btIDebugDraw* debugDrawer);
+#endif  //BT_INTERNAL_EDGE_DEBUG_DRAW
+
+#endif  //BT_INTERNAL_EDGE_UTILITY_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionDispatch/btManifoldResult.h b/engine/inc/bullet/BulletCollision/CollisionDispatch/btManifoldResult.h
new file mode 100644
index 00000000..6c0a2d9a
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionDispatch/btManifoldResult.h
@@ -0,0 +1,163 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_MANIFOLD_RESULT_H
+#define BT_MANIFOLD_RESULT_H
+
+class btCollisionObject;
+struct btCollisionObjectWrapper;
+
+#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
+class btManifoldPoint;
+
+#include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h"
+
+#include "LinearMath/btTransform.h"
+#include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h"
+#include "BulletCollision/CollisionDispatch/btCollisionObject.h"
+
+typedef bool (*ContactAddedCallback)(btManifoldPoint& cp, const btCollisionObjectWrapper* colObj0Wrap, int partId0, int index0, const btCollisionObjectWrapper* colObj1Wrap, int partId1, int index1);
+extern ContactAddedCallback gContactAddedCallback;
+
+//#define DEBUG_PART_INDEX 1
+
+/// These callbacks are used to customize the algorith that combine restitution, friction, damping, Stiffness
+typedef btScalar (*CalculateCombinedCallback)(const btCollisionObject* body0, const btCollisionObject* body1);
+
+extern CalculateCombinedCallback gCalculateCombinedRestitutionCallback;
+extern CalculateCombinedCallback gCalculateCombinedFrictionCallback;
+extern CalculateCombinedCallback gCalculateCombinedRollingFrictionCallback;
+extern CalculateCombinedCallback gCalculateCombinedSpinningFrictionCallback;
+extern CalculateCombinedCallback gCalculateCombinedContactDampingCallback;
+extern CalculateCombinedCallback gCalculateCombinedContactStiffnessCallback;
+
+///btManifoldResult is a helper class to manage  contact results.
+class btManifoldResult : public btDiscreteCollisionDetectorInterface::Result
+{
+protected:
+	btPersistentManifold* m_manifoldPtr;
+
+	const btCollisionObjectWrapper* m_body0Wrap;
+	const btCollisionObjectWrapper* m_body1Wrap;
+	int m_partId0;
+	int m_partId1;
+	int m_index0;
+	int m_index1;
+
+public:
+	btManifoldResult()
+		:
+#ifdef DEBUG_PART_INDEX
+
+		  m_partId0(-1),
+		  m_partId1(-1),
+		  m_index0(-1),
+		  m_index1(-1)
+#endif  //DEBUG_PART_INDEX
+			  m_closestPointDistanceThreshold(0)
+	{
+	}
+
+	btManifoldResult(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap);
+
+	virtual ~btManifoldResult(){};
+
+	void setPersistentManifold(btPersistentManifold* manifoldPtr)
+	{
+		m_manifoldPtr = manifoldPtr;
+	}
+
+	const btPersistentManifold* getPersistentManifold() const
+	{
+		return m_manifoldPtr;
+	}
+	btPersistentManifold* getPersistentManifold()
+	{
+		return m_manifoldPtr;
+	}
+
+	virtual void setShapeIdentifiersA(int partId0, int index0)
+	{
+		m_partId0 = partId0;
+		m_index0 = index0;
+	}
+
+	virtual void setShapeIdentifiersB(int partId1, int index1)
+	{
+		m_partId1 = partId1;
+		m_index1 = index1;
+	}
+
+	virtual void addContactPoint(const btVector3& normalOnBInWorld, const btVector3& pointInWorld, btScalar depth);
+
+	SIMD_FORCE_INLINE void refreshContactPoints()
+	{
+		btAssert(m_manifoldPtr);
+		if (!m_manifoldPtr->getNumContacts())
+			return;
+
+		bool isSwapped = m_manifoldPtr->getBody0() != m_body0Wrap->getCollisionObject();
+
+		if (isSwapped)
+		{
+			m_manifoldPtr->refreshContactPoints(m_body1Wrap->getCollisionObject()->getWorldTransform(), m_body0Wrap->getCollisionObject()->getWorldTransform());
+		}
+		else
+		{
+			m_manifoldPtr->refreshContactPoints(m_body0Wrap->getCollisionObject()->getWorldTransform(), m_body1Wrap->getCollisionObject()->getWorldTransform());
+		}
+	}
+
+	const btCollisionObjectWrapper* getBody0Wrap() const
+	{
+		return m_body0Wrap;
+	}
+	const btCollisionObjectWrapper* getBody1Wrap() const
+	{
+		return m_body1Wrap;
+	}
+
+	void setBody0Wrap(const btCollisionObjectWrapper* obj0Wrap)
+	{
+		m_body0Wrap = obj0Wrap;
+	}
+
+	void setBody1Wrap(const btCollisionObjectWrapper* obj1Wrap)
+	{
+		m_body1Wrap = obj1Wrap;
+	}
+
+	const btCollisionObject* getBody0Internal() const
+	{
+		return m_body0Wrap->getCollisionObject();
+	}
+
+	const btCollisionObject* getBody1Internal() const
+	{
+		return m_body1Wrap->getCollisionObject();
+	}
+
+	btScalar m_closestPointDistanceThreshold;
+
+	/// in the future we can let the user override the methods to combine restitution and friction
+	static btScalar calculateCombinedRestitution(const btCollisionObject* body0, const btCollisionObject* body1);
+	static btScalar calculateCombinedFriction(const btCollisionObject* body0, const btCollisionObject* body1);
+	static btScalar calculateCombinedRollingFriction(const btCollisionObject* body0, const btCollisionObject* body1);
+	static btScalar calculateCombinedSpinningFriction(const btCollisionObject* body0, const btCollisionObject* body1);
+	static btScalar calculateCombinedContactDamping(const btCollisionObject* body0, const btCollisionObject* body1);
+	static btScalar calculateCombinedContactStiffness(const btCollisionObject* body0, const btCollisionObject* body1);
+};
+
+#endif  //BT_MANIFOLD_RESULT_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionDispatch/btSimulationIslandManager.h b/engine/inc/bullet/BulletCollision/CollisionDispatch/btSimulationIslandManager.h
new file mode 100644
index 00000000..197bb457
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionDispatch/btSimulationIslandManager.h
@@ -0,0 +1,75 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SIMULATION_ISLAND_MANAGER_H
+#define BT_SIMULATION_ISLAND_MANAGER_H
+
+#include "BulletCollision/CollisionDispatch/btUnionFind.h"
+#include "btCollisionCreateFunc.h"
+#include "LinearMath/btAlignedObjectArray.h"
+#include "btCollisionObject.h"
+
+class btCollisionObject;
+class btCollisionWorld;
+class btDispatcher;
+class btPersistentManifold;
+
+///SimulationIslandManager creates and handles simulation islands, using btUnionFind
+class btSimulationIslandManager
+{
+	btUnionFind m_unionFind;
+
+	btAlignedObjectArray<btPersistentManifold*> m_islandmanifold;
+	btAlignedObjectArray<btCollisionObject*> m_islandBodies;
+
+	bool m_splitIslands;
+
+public:
+	btSimulationIslandManager();
+	virtual ~btSimulationIslandManager();
+
+	void initUnionFind(int n);
+
+	btUnionFind& getUnionFind() { return m_unionFind; }
+
+	virtual void updateActivationState(btCollisionWorld* colWorld, btDispatcher* dispatcher);
+	virtual void storeIslandActivationState(btCollisionWorld* world);
+
+	void findUnions(btDispatcher* dispatcher, btCollisionWorld* colWorld);
+
+	struct IslandCallback
+	{
+		virtual ~IslandCallback(){};
+
+		virtual void processIsland(btCollisionObject** bodies, int numBodies, class btPersistentManifold** manifolds, int numManifolds, int islandId) = 0;
+	};
+
+	void buildAndProcessIslands(btDispatcher* dispatcher, btCollisionWorld* collisionWorld, IslandCallback* callback);
+    
+	void buildIslands(btDispatcher* dispatcher, btCollisionWorld* colWorld);
+
+    void processIslands(btDispatcher* dispatcher, btCollisionWorld* collisionWorld, IslandCallback* callback);
+    
+	bool getSplitIslands()
+	{
+		return m_splitIslands;
+	}
+	void setSplitIslands(bool doSplitIslands)
+	{
+		m_splitIslands = doSplitIslands;
+	}
+};
+
+#endif  //BT_SIMULATION_ISLAND_MANAGER_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h b/engine/inc/bullet/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h
new file mode 100644
index 00000000..3348bc89
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h
@@ -0,0 +1,73 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SPHERE_BOX_COLLISION_ALGORITHM_H
+#define BT_SPHERE_BOX_COLLISION_ALGORITHM_H
+
+#include "btActivatingCollisionAlgorithm.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
+class btPersistentManifold;
+#include "btCollisionDispatcher.h"
+
+#include "LinearMath/btVector3.h"
+
+/// btSphereBoxCollisionAlgorithm  provides sphere-box collision detection.
+/// Other features are frame-coherency (persistent data) and collision response.
+class btSphereBoxCollisionAlgorithm : public btActivatingCollisionAlgorithm
+{
+	bool m_ownManifold;
+	btPersistentManifold* m_manifoldPtr;
+	bool m_isSwapped;
+
+public:
+	btSphereBoxCollisionAlgorithm(btPersistentManifold* mf, const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, bool isSwapped);
+
+	virtual ~btSphereBoxCollisionAlgorithm();
+
+	virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	virtual btScalar calculateTimeOfImpact(btCollisionObject* body0, btCollisionObject* body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	virtual void getAllContactManifolds(btManifoldArray& manifoldArray)
+	{
+		if (m_manifoldPtr && m_ownManifold)
+		{
+			manifoldArray.push_back(m_manifoldPtr);
+		}
+	}
+
+	bool getSphereDistance(const btCollisionObjectWrapper* boxObjWrap, btVector3& v3PointOnBox, btVector3& normal, btScalar& penetrationDepth, const btVector3& v3SphereCenter, btScalar fRadius, btScalar maxContactDistance);
+
+	btScalar getSpherePenetration(btVector3 const& boxHalfExtent, btVector3 const& sphereRelPos, btVector3& closestPoint, btVector3& normal);
+
+	struct CreateFunc : public btCollisionAlgorithmCreateFunc
+	{
+		virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap)
+		{
+			void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btSphereBoxCollisionAlgorithm));
+			if (!m_swapped)
+			{
+				return new (mem) btSphereBoxCollisionAlgorithm(0, ci, body0Wrap, body1Wrap, false);
+			}
+			else
+			{
+				return new (mem) btSphereBoxCollisionAlgorithm(0, ci, body0Wrap, body1Wrap, true);
+			}
+		}
+	};
+};
+
+#endif  //BT_SPHERE_BOX_COLLISION_ALGORITHM_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h b/engine/inc/bullet/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h
new file mode 100644
index 00000000..b08d0df7
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h
@@ -0,0 +1,64 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H
+#define BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H
+
+#include "btActivatingCollisionAlgorithm.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
+#include "btCollisionDispatcher.h"
+
+class btPersistentManifold;
+
+/// btSphereSphereCollisionAlgorithm  provides sphere-sphere collision detection.
+/// Other features are frame-coherency (persistent data) and collision response.
+/// Also provides the most basic sample for custom/user btCollisionAlgorithm
+class btSphereSphereCollisionAlgorithm : public btActivatingCollisionAlgorithm
+{
+	bool m_ownManifold;
+	btPersistentManifold* m_manifoldPtr;
+
+public:
+	btSphereSphereCollisionAlgorithm(btPersistentManifold* mf, const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* col0Wrap, const btCollisionObjectWrapper* col1Wrap);
+
+	btSphereSphereCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci)
+		: btActivatingCollisionAlgorithm(ci) {}
+
+	virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	virtual btScalar calculateTimeOfImpact(btCollisionObject* body0, btCollisionObject* body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	virtual void getAllContactManifolds(btManifoldArray& manifoldArray)
+	{
+		if (m_manifoldPtr && m_ownManifold)
+		{
+			manifoldArray.push_back(m_manifoldPtr);
+		}
+	}
+
+	virtual ~btSphereSphereCollisionAlgorithm();
+
+	struct CreateFunc : public btCollisionAlgorithmCreateFunc
+	{
+		virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* col0Wrap, const btCollisionObjectWrapper* col1Wrap)
+		{
+			void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btSphereSphereCollisionAlgorithm));
+			return new (mem) btSphereSphereCollisionAlgorithm(0, ci, col0Wrap, col1Wrap);
+		}
+	};
+};
+
+#endif  //BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.h b/engine/inc/bullet/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.h
new file mode 100644
index 00000000..d660222f
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.h
@@ -0,0 +1,65 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SPHERE_TRIANGLE_COLLISION_ALGORITHM_H
+#define BT_SPHERE_TRIANGLE_COLLISION_ALGORITHM_H
+
+#include "btActivatingCollisionAlgorithm.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
+class btPersistentManifold;
+#include "btCollisionDispatcher.h"
+
+/// btSphereSphereCollisionAlgorithm  provides sphere-sphere collision detection.
+/// Other features are frame-coherency (persistent data) and collision response.
+/// Also provides the most basic sample for custom/user btCollisionAlgorithm
+class btSphereTriangleCollisionAlgorithm : public btActivatingCollisionAlgorithm
+{
+	bool m_ownManifold;
+	btPersistentManifold* m_manifoldPtr;
+	bool m_swapped;
+
+public:
+	btSphereTriangleCollisionAlgorithm(btPersistentManifold* mf, const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, bool swapped);
+
+	btSphereTriangleCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci)
+		: btActivatingCollisionAlgorithm(ci) {}
+
+	virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	virtual btScalar calculateTimeOfImpact(btCollisionObject* body0, btCollisionObject* body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	virtual void getAllContactManifolds(btManifoldArray& manifoldArray)
+	{
+		if (m_manifoldPtr && m_ownManifold)
+		{
+			manifoldArray.push_back(m_manifoldPtr);
+		}
+	}
+
+	virtual ~btSphereTriangleCollisionAlgorithm();
+
+	struct CreateFunc : public btCollisionAlgorithmCreateFunc
+	{
+		virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap)
+		{
+			void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btSphereTriangleCollisionAlgorithm));
+
+			return new (mem) btSphereTriangleCollisionAlgorithm(ci.m_manifold, ci, body0Wrap, body1Wrap, m_swapped);
+		}
+	};
+};
+
+#endif  //BT_SPHERE_TRIANGLE_COLLISION_ALGORITHM_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionDispatch/btUnionFind.h b/engine/inc/bullet/BulletCollision/CollisionDispatch/btUnionFind.h
new file mode 100644
index 00000000..d422ef55
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionDispatch/btUnionFind.h
@@ -0,0 +1,123 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_UNION_FIND_H
+#define BT_UNION_FIND_H
+
+#include "LinearMath/btAlignedObjectArray.h"
+
+#define USE_PATH_COMPRESSION 1
+
+///see for discussion of static island optimizations by Vroonsh here: http://code.google.com/p/bullet/issues/detail?id=406
+#define STATIC_SIMULATION_ISLAND_OPTIMIZATION 1
+
+struct btElement
+{
+	int m_id;
+	int m_sz;
+};
+
+///UnionFind calculates connected subsets
+// Implements weighted Quick Union with path compression
+// optimization: could use short ints instead of ints (halving memory, would limit the number of rigid bodies to 64k, sounds reasonable)
+class btUnionFind
+{
+private:
+	btAlignedObjectArray<btElement> m_elements;
+
+public:
+	btUnionFind();
+	~btUnionFind();
+
+	//this is a special operation, destroying the content of btUnionFind.
+	//it sorts the elements, based on island id, in order to make it easy to iterate over islands
+	void sortIslands();
+
+	void reset(int N);
+
+	SIMD_FORCE_INLINE int getNumElements() const
+	{
+		return int(m_elements.size());
+	}
+	SIMD_FORCE_INLINE bool isRoot(int x) const
+	{
+		return (x == m_elements[x].m_id);
+	}
+
+	btElement& getElement(int index)
+	{
+		return m_elements[index];
+	}
+	const btElement& getElement(int index) const
+	{
+		return m_elements[index];
+	}
+
+	void allocate(int N);
+	void Free();
+
+	int find(int p, int q)
+	{
+		return (find(p) == find(q));
+	}
+
+	void unite(int p, int q)
+	{
+		int i = find(p), j = find(q);
+		if (i == j)
+			return;
+
+#ifndef USE_PATH_COMPRESSION
+		//weighted quick union, this keeps the 'trees' balanced, and keeps performance of unite O( log(n) )
+		if (m_elements[i].m_sz < m_elements[j].m_sz)
+		{
+			m_elements[i].m_id = j;
+			m_elements[j].m_sz += m_elements[i].m_sz;
+		}
+		else
+		{
+			m_elements[j].m_id = i;
+			m_elements[i].m_sz += m_elements[j].m_sz;
+		}
+#else
+		m_elements[i].m_id = j;
+		m_elements[j].m_sz += m_elements[i].m_sz;
+#endif  //USE_PATH_COMPRESSION
+	}
+
+	int find(int x)
+	{
+		//btAssert(x < m_N);
+		//btAssert(x >= 0);
+
+		while (x != m_elements[x].m_id)
+		{
+			//not really a reason not to use path compression, and it flattens the trees/improves find performance dramatically
+
+#ifdef USE_PATH_COMPRESSION
+			const btElement* elementPtr = &m_elements[m_elements[x].m_id];
+			m_elements[x].m_id = elementPtr->m_id;
+			x = elementPtr->m_id;
+#else  //
+			x = m_elements[x].m_id;
+#endif
+			//btAssert(x < m_N);
+			//btAssert(x >= 0);
+		}
+		return x;
+	}
+};
+
+#endif  //BT_UNION_FIND_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btBox2dShape.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btBox2dShape.h
new file mode 100644
index 00000000..7e085f9e
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btBox2dShape.h
@@ -0,0 +1,339 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_OBB_BOX_2D_SHAPE_H
+#define BT_OBB_BOX_2D_SHAPE_H
+
+#include "BulletCollision/CollisionShapes/btPolyhedralConvexShape.h"
+#include "BulletCollision/CollisionShapes/btCollisionMargin.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btMinMax.h"
+
+///The btBox2dShape is a box primitive around the origin, its sides axis aligned with length specified by half extents, in local shape coordinates. When used as part of a btCollisionObject or btRigidBody it will be an oriented box in world space.
+ATTRIBUTE_ALIGNED16(class)
+btBox2dShape : public btPolyhedralConvexShape
+{
+	//btVector3	m_boxHalfExtents1; //use m_implicitShapeDimensions instead
+
+	btVector3 m_centroid;
+	btVector3 m_vertices[4];
+	btVector3 m_normals[4];
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btVector3 getHalfExtentsWithMargin() const
+	{
+		btVector3 halfExtents = getHalfExtentsWithoutMargin();
+		btVector3 margin(getMargin(), getMargin(), getMargin());
+		halfExtents += margin;
+		return halfExtents;
+	}
+
+	const btVector3& getHalfExtentsWithoutMargin() const
+	{
+		return m_implicitShapeDimensions;  //changed in Bullet 2.63: assume the scaling and margin are included
+	}
+
+	virtual btVector3 localGetSupportingVertex(const btVector3& vec) const
+	{
+		btVector3 halfExtents = getHalfExtentsWithoutMargin();
+		btVector3 margin(getMargin(), getMargin(), getMargin());
+		halfExtents += margin;
+
+		return btVector3(btFsels(vec.x(), halfExtents.x(), -halfExtents.x()),
+						 btFsels(vec.y(), halfExtents.y(), -halfExtents.y()),
+						 btFsels(vec.z(), halfExtents.z(), -halfExtents.z()));
+	}
+
+	SIMD_FORCE_INLINE btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const
+	{
+		const btVector3& halfExtents = getHalfExtentsWithoutMargin();
+
+		return btVector3(btFsels(vec.x(), halfExtents.x(), -halfExtents.x()),
+						 btFsels(vec.y(), halfExtents.y(), -halfExtents.y()),
+						 btFsels(vec.z(), halfExtents.z(), -halfExtents.z()));
+	}
+
+	virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const
+	{
+		const btVector3& halfExtents = getHalfExtentsWithoutMargin();
+
+		for (int i = 0; i < numVectors; i++)
+		{
+			const btVector3& vec = vectors[i];
+			supportVerticesOut[i].setValue(btFsels(vec.x(), halfExtents.x(), -halfExtents.x()),
+										   btFsels(vec.y(), halfExtents.y(), -halfExtents.y()),
+										   btFsels(vec.z(), halfExtents.z(), -halfExtents.z()));
+		}
+	}
+
+	///a btBox2dShape is a flat 2D box in the X-Y plane (Z extents are zero)
+	btBox2dShape(const btVector3& boxHalfExtents)
+		: btPolyhedralConvexShape(),
+		  m_centroid(0, 0, 0)
+	{
+		m_vertices[0].setValue(-boxHalfExtents.getX(), -boxHalfExtents.getY(), 0);
+		m_vertices[1].setValue(boxHalfExtents.getX(), -boxHalfExtents.getY(), 0);
+		m_vertices[2].setValue(boxHalfExtents.getX(), boxHalfExtents.getY(), 0);
+		m_vertices[3].setValue(-boxHalfExtents.getX(), boxHalfExtents.getY(), 0);
+
+		m_normals[0].setValue(0, -1, 0);
+		m_normals[1].setValue(1, 0, 0);
+		m_normals[2].setValue(0, 1, 0);
+		m_normals[3].setValue(-1, 0, 0);
+
+		btScalar minDimension = boxHalfExtents.getX();
+		if (minDimension > boxHalfExtents.getY())
+			minDimension = boxHalfExtents.getY();
+
+		m_shapeType = BOX_2D_SHAPE_PROXYTYPE;
+		btVector3 margin(getMargin(), getMargin(), getMargin());
+		m_implicitShapeDimensions = (boxHalfExtents * m_localScaling) - margin;
+
+		setSafeMargin(minDimension);
+	};
+
+	virtual void setMargin(btScalar collisionMargin)
+	{
+		//correct the m_implicitShapeDimensions for the margin
+		btVector3 oldMargin(getMargin(), getMargin(), getMargin());
+		btVector3 implicitShapeDimensionsWithMargin = m_implicitShapeDimensions + oldMargin;
+
+		btConvexInternalShape::setMargin(collisionMargin);
+		btVector3 newMargin(getMargin(), getMargin(), getMargin());
+		m_implicitShapeDimensions = implicitShapeDimensionsWithMargin - newMargin;
+	}
+	virtual void setLocalScaling(const btVector3& scaling)
+	{
+		btVector3 oldMargin(getMargin(), getMargin(), getMargin());
+		btVector3 implicitShapeDimensionsWithMargin = m_implicitShapeDimensions + oldMargin;
+		btVector3 unScaledImplicitShapeDimensionsWithMargin = implicitShapeDimensionsWithMargin / m_localScaling;
+
+		btConvexInternalShape::setLocalScaling(scaling);
+
+		m_implicitShapeDimensions = (unScaledImplicitShapeDimensionsWithMargin * m_localScaling) - oldMargin;
+	}
+
+	virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const;
+
+	virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const;
+
+	int getVertexCount() const
+	{
+		return 4;
+	}
+
+	virtual int getNumVertices() const
+	{
+		return 4;
+	}
+
+	const btVector3* getVertices() const
+	{
+		return &m_vertices[0];
+	}
+
+	const btVector3* getNormals() const
+	{
+		return &m_normals[0];
+	}
+
+	virtual void getPlane(btVector3 & planeNormal, btVector3 & planeSupport, int i) const
+	{
+		//this plane might not be aligned...
+		btVector4 plane;
+		getPlaneEquation(plane, i);
+		planeNormal = btVector3(plane.getX(), plane.getY(), plane.getZ());
+		planeSupport = localGetSupportingVertex(-planeNormal);
+	}
+
+	const btVector3& getCentroid() const
+	{
+		return m_centroid;
+	}
+
+	virtual int getNumPlanes() const
+	{
+		return 6;
+	}
+
+	virtual int getNumEdges() const
+	{
+		return 12;
+	}
+
+	virtual void getVertex(int i, btVector3& vtx) const
+	{
+		btVector3 halfExtents = getHalfExtentsWithoutMargin();
+
+		vtx = btVector3(
+			halfExtents.x() * (1 - (i & 1)) - halfExtents.x() * (i & 1),
+			halfExtents.y() * (1 - ((i & 2) >> 1)) - halfExtents.y() * ((i & 2) >> 1),
+			halfExtents.z() * (1 - ((i & 4) >> 2)) - halfExtents.z() * ((i & 4) >> 2));
+	}
+
+	virtual void getPlaneEquation(btVector4 & plane, int i) const
+	{
+		btVector3 halfExtents = getHalfExtentsWithoutMargin();
+
+		switch (i)
+		{
+			case 0:
+				plane.setValue(btScalar(1.), btScalar(0.), btScalar(0.), -halfExtents.x());
+				break;
+			case 1:
+				plane.setValue(btScalar(-1.), btScalar(0.), btScalar(0.), -halfExtents.x());
+				break;
+			case 2:
+				plane.setValue(btScalar(0.), btScalar(1.), btScalar(0.), -halfExtents.y());
+				break;
+			case 3:
+				plane.setValue(btScalar(0.), btScalar(-1.), btScalar(0.), -halfExtents.y());
+				break;
+			case 4:
+				plane.setValue(btScalar(0.), btScalar(0.), btScalar(1.), -halfExtents.z());
+				break;
+			case 5:
+				plane.setValue(btScalar(0.), btScalar(0.), btScalar(-1.), -halfExtents.z());
+				break;
+			default:
+				btAssert(0);
+		}
+	}
+
+	virtual void getEdge(int i, btVector3& pa, btVector3& pb) const
+	//virtual void getEdge(int i,Edge& edge) const
+	{
+		int edgeVert0 = 0;
+		int edgeVert1 = 0;
+
+		switch (i)
+		{
+			case 0:
+				edgeVert0 = 0;
+				edgeVert1 = 1;
+				break;
+			case 1:
+				edgeVert0 = 0;
+				edgeVert1 = 2;
+				break;
+			case 2:
+				edgeVert0 = 1;
+				edgeVert1 = 3;
+
+				break;
+			case 3:
+				edgeVert0 = 2;
+				edgeVert1 = 3;
+				break;
+			case 4:
+				edgeVert0 = 0;
+				edgeVert1 = 4;
+				break;
+			case 5:
+				edgeVert0 = 1;
+				edgeVert1 = 5;
+
+				break;
+			case 6:
+				edgeVert0 = 2;
+				edgeVert1 = 6;
+				break;
+			case 7:
+				edgeVert0 = 3;
+				edgeVert1 = 7;
+				break;
+			case 8:
+				edgeVert0 = 4;
+				edgeVert1 = 5;
+				break;
+			case 9:
+				edgeVert0 = 4;
+				edgeVert1 = 6;
+				break;
+			case 10:
+				edgeVert0 = 5;
+				edgeVert1 = 7;
+				break;
+			case 11:
+				edgeVert0 = 6;
+				edgeVert1 = 7;
+				break;
+			default:
+				btAssert(0);
+		}
+
+		getVertex(edgeVert0, pa);
+		getVertex(edgeVert1, pb);
+	}
+
+	virtual bool isInside(const btVector3& pt, btScalar tolerance) const
+	{
+		btVector3 halfExtents = getHalfExtentsWithoutMargin();
+
+		//btScalar minDist = 2*tolerance;
+
+		bool result = (pt.x() <= (halfExtents.x() + tolerance)) &&
+					  (pt.x() >= (-halfExtents.x() - tolerance)) &&
+					  (pt.y() <= (halfExtents.y() + tolerance)) &&
+					  (pt.y() >= (-halfExtents.y() - tolerance)) &&
+					  (pt.z() <= (halfExtents.z() + tolerance)) &&
+					  (pt.z() >= (-halfExtents.z() - tolerance));
+
+		return result;
+	}
+
+	//debugging
+	virtual const char* getName() const
+	{
+		return "Box2d";
+	}
+
+	virtual int getNumPreferredPenetrationDirections() const
+	{
+		return 6;
+	}
+
+	virtual void getPreferredPenetrationDirection(int index, btVector3& penetrationVector) const
+	{
+		switch (index)
+		{
+			case 0:
+				penetrationVector.setValue(btScalar(1.), btScalar(0.), btScalar(0.));
+				break;
+			case 1:
+				penetrationVector.setValue(btScalar(-1.), btScalar(0.), btScalar(0.));
+				break;
+			case 2:
+				penetrationVector.setValue(btScalar(0.), btScalar(1.), btScalar(0.));
+				break;
+			case 3:
+				penetrationVector.setValue(btScalar(0.), btScalar(-1.), btScalar(0.));
+				break;
+			case 4:
+				penetrationVector.setValue(btScalar(0.), btScalar(0.), btScalar(1.));
+				break;
+			case 5:
+				penetrationVector.setValue(btScalar(0.), btScalar(0.), btScalar(-1.));
+				break;
+			default:
+				btAssert(0);
+		}
+	}
+};
+
+#endif  //BT_OBB_BOX_2D_SHAPE_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btBoxShape.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btBoxShape.h
new file mode 100644
index 00000000..3c65505d
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btBoxShape.h
@@ -0,0 +1,291 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_OBB_BOX_MINKOWSKI_H
+#define BT_OBB_BOX_MINKOWSKI_H
+
+#include "btPolyhedralConvexShape.h"
+#include "btCollisionMargin.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btMinMax.h"
+
+///The btBoxShape is a box primitive around the origin, its sides axis aligned with length specified by half extents, in local shape coordinates. When used as part of a btCollisionObject or btRigidBody it will be an oriented box in world space.
+ATTRIBUTE_ALIGNED16(class)
+btBoxShape : public btPolyhedralConvexShape
+{
+	//btVector3	m_boxHalfExtents1; //use m_implicitShapeDimensions instead
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btVector3 getHalfExtentsWithMargin() const
+	{
+		btVector3 halfExtents = getHalfExtentsWithoutMargin();
+		btVector3 margin(getMargin(), getMargin(), getMargin());
+		halfExtents += margin;
+		return halfExtents;
+	}
+
+	const btVector3& getHalfExtentsWithoutMargin() const
+	{
+		return m_implicitShapeDimensions;  //scaling is included, margin is not
+	}
+
+	virtual btVector3 localGetSupportingVertex(const btVector3& vec) const
+	{
+		btVector3 halfExtents = getHalfExtentsWithoutMargin();
+		btVector3 margin(getMargin(), getMargin(), getMargin());
+		halfExtents += margin;
+
+		return btVector3(btFsels(vec.x(), halfExtents.x(), -halfExtents.x()),
+						 btFsels(vec.y(), halfExtents.y(), -halfExtents.y()),
+						 btFsels(vec.z(), halfExtents.z(), -halfExtents.z()));
+	}
+
+	SIMD_FORCE_INLINE btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const
+	{
+		const btVector3& halfExtents = getHalfExtentsWithoutMargin();
+
+		return btVector3(btFsels(vec.x(), halfExtents.x(), -halfExtents.x()),
+						 btFsels(vec.y(), halfExtents.y(), -halfExtents.y()),
+						 btFsels(vec.z(), halfExtents.z(), -halfExtents.z()));
+	}
+
+	virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const
+	{
+		const btVector3& halfExtents = getHalfExtentsWithoutMargin();
+
+		for (int i = 0; i < numVectors; i++)
+		{
+			const btVector3& vec = vectors[i];
+			supportVerticesOut[i].setValue(btFsels(vec.x(), halfExtents.x(), -halfExtents.x()),
+										   btFsels(vec.y(), halfExtents.y(), -halfExtents.y()),
+										   btFsels(vec.z(), halfExtents.z(), -halfExtents.z()));
+		}
+	}
+
+	btBoxShape(const btVector3& boxHalfExtents);
+
+	virtual void setMargin(btScalar collisionMargin)
+	{
+		//correct the m_implicitShapeDimensions for the margin
+		btVector3 oldMargin(getMargin(), getMargin(), getMargin());
+		btVector3 implicitShapeDimensionsWithMargin = m_implicitShapeDimensions + oldMargin;
+
+		btConvexInternalShape::setMargin(collisionMargin);
+		btVector3 newMargin(getMargin(), getMargin(), getMargin());
+		m_implicitShapeDimensions = implicitShapeDimensionsWithMargin - newMargin;
+	}
+	virtual void setLocalScaling(const btVector3& scaling)
+	{
+		btVector3 oldMargin(getMargin(), getMargin(), getMargin());
+		btVector3 implicitShapeDimensionsWithMargin = m_implicitShapeDimensions + oldMargin;
+		btVector3 unScaledImplicitShapeDimensionsWithMargin = implicitShapeDimensionsWithMargin / m_localScaling;
+
+		btConvexInternalShape::setLocalScaling(scaling);
+
+		m_implicitShapeDimensions = (unScaledImplicitShapeDimensionsWithMargin * m_localScaling) - oldMargin;
+	}
+
+	virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const;
+
+	virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const;
+
+	virtual void getPlane(btVector3 & planeNormal, btVector3 & planeSupport, int i) const
+	{
+		//this plane might not be aligned...
+		btVector4 plane;
+		getPlaneEquation(plane, i);
+		planeNormal = btVector3(plane.getX(), plane.getY(), plane.getZ());
+		planeSupport = localGetSupportingVertex(-planeNormal);
+	}
+
+	virtual int getNumPlanes() const
+	{
+		return 6;
+	}
+
+	virtual int getNumVertices() const
+	{
+		return 8;
+	}
+
+	virtual int getNumEdges() const
+	{
+		return 12;
+	}
+
+	virtual void getVertex(int i, btVector3& vtx) const
+	{
+		btVector3 halfExtents = getHalfExtentsWithMargin();
+
+		vtx = btVector3(
+			halfExtents.x() * (1 - (i & 1)) - halfExtents.x() * (i & 1),
+			halfExtents.y() * (1 - ((i & 2) >> 1)) - halfExtents.y() * ((i & 2) >> 1),
+			halfExtents.z() * (1 - ((i & 4) >> 2)) - halfExtents.z() * ((i & 4) >> 2));
+	}
+
+	virtual void getPlaneEquation(btVector4 & plane, int i) const
+	{
+		btVector3 halfExtents = getHalfExtentsWithoutMargin();
+
+		switch (i)
+		{
+			case 0:
+				plane.setValue(btScalar(1.), btScalar(0.), btScalar(0.), -halfExtents.x());
+				break;
+			case 1:
+				plane.setValue(btScalar(-1.), btScalar(0.), btScalar(0.), -halfExtents.x());
+				break;
+			case 2:
+				plane.setValue(btScalar(0.), btScalar(1.), btScalar(0.), -halfExtents.y());
+				break;
+			case 3:
+				plane.setValue(btScalar(0.), btScalar(-1.), btScalar(0.), -halfExtents.y());
+				break;
+			case 4:
+				plane.setValue(btScalar(0.), btScalar(0.), btScalar(1.), -halfExtents.z());
+				break;
+			case 5:
+				plane.setValue(btScalar(0.), btScalar(0.), btScalar(-1.), -halfExtents.z());
+				break;
+			default:
+				btAssert(0);
+		}
+	}
+
+	virtual void getEdge(int i, btVector3& pa, btVector3& pb) const
+	//virtual void getEdge(int i,Edge& edge) const
+	{
+		int edgeVert0 = 0;
+		int edgeVert1 = 0;
+
+		switch (i)
+		{
+			case 0:
+				edgeVert0 = 0;
+				edgeVert1 = 1;
+				break;
+			case 1:
+				edgeVert0 = 0;
+				edgeVert1 = 2;
+				break;
+			case 2:
+				edgeVert0 = 1;
+				edgeVert1 = 3;
+
+				break;
+			case 3:
+				edgeVert0 = 2;
+				edgeVert1 = 3;
+				break;
+			case 4:
+				edgeVert0 = 0;
+				edgeVert1 = 4;
+				break;
+			case 5:
+				edgeVert0 = 1;
+				edgeVert1 = 5;
+
+				break;
+			case 6:
+				edgeVert0 = 2;
+				edgeVert1 = 6;
+				break;
+			case 7:
+				edgeVert0 = 3;
+				edgeVert1 = 7;
+				break;
+			case 8:
+				edgeVert0 = 4;
+				edgeVert1 = 5;
+				break;
+			case 9:
+				edgeVert0 = 4;
+				edgeVert1 = 6;
+				break;
+			case 10:
+				edgeVert0 = 5;
+				edgeVert1 = 7;
+				break;
+			case 11:
+				edgeVert0 = 6;
+				edgeVert1 = 7;
+				break;
+			default:
+				btAssert(0);
+		}
+
+		getVertex(edgeVert0, pa);
+		getVertex(edgeVert1, pb);
+	}
+
+	virtual bool isInside(const btVector3& pt, btScalar tolerance) const
+	{
+		btVector3 halfExtents = getHalfExtentsWithoutMargin();
+
+		//btScalar minDist = 2*tolerance;
+
+		bool result = (pt.x() <= (halfExtents.x() + tolerance)) &&
+					  (pt.x() >= (-halfExtents.x() - tolerance)) &&
+					  (pt.y() <= (halfExtents.y() + tolerance)) &&
+					  (pt.y() >= (-halfExtents.y() - tolerance)) &&
+					  (pt.z() <= (halfExtents.z() + tolerance)) &&
+					  (pt.z() >= (-halfExtents.z() - tolerance));
+
+		return result;
+	}
+
+	//debugging
+	virtual const char* getName() const
+	{
+		return "Box";
+	}
+
+	virtual int getNumPreferredPenetrationDirections() const
+	{
+		return 6;
+	}
+
+	virtual void getPreferredPenetrationDirection(int index, btVector3& penetrationVector) const
+	{
+		switch (index)
+		{
+			case 0:
+				penetrationVector.setValue(btScalar(1.), btScalar(0.), btScalar(0.));
+				break;
+			case 1:
+				penetrationVector.setValue(btScalar(-1.), btScalar(0.), btScalar(0.));
+				break;
+			case 2:
+				penetrationVector.setValue(btScalar(0.), btScalar(1.), btScalar(0.));
+				break;
+			case 3:
+				penetrationVector.setValue(btScalar(0.), btScalar(-1.), btScalar(0.));
+				break;
+			case 4:
+				penetrationVector.setValue(btScalar(0.), btScalar(0.), btScalar(1.));
+				break;
+			case 5:
+				penetrationVector.setValue(btScalar(0.), btScalar(0.), btScalar(-1.));
+				break;
+			default:
+				btAssert(0);
+		}
+	}
+};
+
+#endif  //BT_OBB_BOX_MINKOWSKI_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h
new file mode 100644
index 00000000..8b2f2ee8
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h
@@ -0,0 +1,144 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_BVH_TRIANGLE_MESH_SHAPE_H
+#define BT_BVH_TRIANGLE_MESH_SHAPE_H
+
+#include "btTriangleMeshShape.h"
+#include "btOptimizedBvh.h"
+#include "LinearMath/btAlignedAllocator.h"
+#include "btTriangleInfoMap.h"
+
+///The btBvhTriangleMeshShape is a static-triangle mesh shape, it can only be used for fixed/non-moving objects.
+///If you required moving concave triangle meshes, it is recommended to perform convex decomposition
+///using HACD, see Bullet/Demos/ConvexDecompositionDemo.
+///Alternatively, you can use btGimpactMeshShape for moving concave triangle meshes.
+///btBvhTriangleMeshShape has several optimizations, such as bounding volume hierarchy and
+///cache friendly traversal for PlayStation 3 Cell SPU.
+///It is recommended to enable useQuantizedAabbCompression for better memory usage.
+///It takes a triangle mesh as input, for example a btTriangleMesh or btTriangleIndexVertexArray. The btBvhTriangleMeshShape class allows for triangle mesh deformations by a refit or partialRefit method.
+///Instead of building the bounding volume hierarchy acceleration structure, it is also possible to serialize (save) and deserialize (load) the structure from disk.
+///See Demos\ConcaveDemo\ConcavePhysicsDemo.cpp for an example.
+ATTRIBUTE_ALIGNED16(class)
+btBvhTriangleMeshShape : public btTriangleMeshShape
+{
+	btOptimizedBvh* m_bvh;
+	btTriangleInfoMap* m_triangleInfoMap;
+
+	bool m_useQuantizedAabbCompression;
+	bool m_ownsBvh;
+#ifdef __clang__
+	bool m_pad[11] __attribute__((unused));  ////need padding due to alignment
+#else
+	bool m_pad[11];  ////need padding due to alignment
+#endif
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btBvhTriangleMeshShape(btStridingMeshInterface * meshInterface, bool useQuantizedAabbCompression, bool buildBvh = true);
+
+	///optionally pass in a larger bvh aabb, used for quantization. This allows for deformations within this aabb
+	btBvhTriangleMeshShape(btStridingMeshInterface * meshInterface, bool useQuantizedAabbCompression, const btVector3& bvhAabbMin, const btVector3& bvhAabbMax, bool buildBvh = true);
+
+	virtual ~btBvhTriangleMeshShape();
+
+	bool getOwnsBvh() const
+	{
+		return m_ownsBvh;
+	}
+
+	void performRaycast(btTriangleCallback * callback, const btVector3& raySource, const btVector3& rayTarget);
+	void performConvexcast(btTriangleCallback * callback, const btVector3& boxSource, const btVector3& boxTarget, const btVector3& boxMin, const btVector3& boxMax);
+
+	virtual void processAllTriangles(btTriangleCallback * callback, const btVector3& aabbMin, const btVector3& aabbMax) const;
+
+	void refitTree(const btVector3& aabbMin, const btVector3& aabbMax);
+
+	///for a fast incremental refit of parts of the tree. Note: the entire AABB of the tree will become more conservative, it never shrinks
+	void partialRefitTree(const btVector3& aabbMin, const btVector3& aabbMax);
+
+	//debugging
+	virtual const char* getName() const { return "BVHTRIANGLEMESH"; }
+
+	virtual void setLocalScaling(const btVector3& scaling);
+
+	btOptimizedBvh* getOptimizedBvh()
+	{
+		return m_bvh;
+	}
+
+	void setOptimizedBvh(btOptimizedBvh * bvh, const btVector3& localScaling = btVector3(1, 1, 1));
+
+	void buildOptimizedBvh();
+
+	bool usesQuantizedAabbCompression() const
+	{
+		return m_useQuantizedAabbCompression;
+	}
+
+	void setTriangleInfoMap(btTriangleInfoMap * triangleInfoMap)
+	{
+		m_triangleInfoMap = triangleInfoMap;
+	}
+
+	const btTriangleInfoMap* getTriangleInfoMap() const
+	{
+		return m_triangleInfoMap;
+	}
+
+	btTriangleInfoMap* getTriangleInfoMap()
+	{
+		return m_triangleInfoMap;
+	}
+
+	virtual int calculateSerializeBufferSize() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
+
+	virtual void serializeSingleBvh(btSerializer * serializer) const;
+
+	virtual void serializeSingleTriangleInfoMap(btSerializer * serializer) const;
+};
+
+// clang-format off
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct	btTriangleMeshShapeData
+{
+	btCollisionShapeData	m_collisionShapeData;
+
+	btStridingMeshInterfaceData m_meshInterface;
+
+	btQuantizedBvhFloatData		*m_quantizedFloatBvh;
+	btQuantizedBvhDoubleData	*m_quantizedDoubleBvh;
+
+	btTriangleInfoMapData	*m_triangleInfoMap;
+	
+	float	m_collisionMargin;
+
+	char m_pad3[4];
+	
+};
+
+// clang-format on
+
+SIMD_FORCE_INLINE int btBvhTriangleMeshShape::calculateSerializeBufferSize() const
+{
+	return sizeof(btTriangleMeshShapeData);
+}
+
+#endif  //BT_BVH_TRIANGLE_MESH_SHAPE_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btCapsuleShape.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btCapsuleShape.h
new file mode 100644
index 00000000..138d0c0f
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btCapsuleShape.h
@@ -0,0 +1,182 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_CAPSULE_SHAPE_H
+#define BT_CAPSULE_SHAPE_H
+
+#include "btConvexInternalShape.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"  // for the types
+
+///The btCapsuleShape represents a capsule around the Y axis, there is also the btCapsuleShapeX aligned around the X axis and btCapsuleShapeZ around the Z axis.
+///The total height is height+2*radius, so the height is just the height between the center of each 'sphere' of the capsule caps.
+///The btCapsuleShape is a convex hull of two spheres. The btMultiSphereShape is a more general collision shape that takes the convex hull of multiple sphere, so it can also represent a capsule when just using two spheres.
+ATTRIBUTE_ALIGNED16(class)
+btCapsuleShape : public btConvexInternalShape
+{
+protected:
+	int m_upAxis;
+
+protected:
+	///only used for btCapsuleShapeZ and btCapsuleShapeX subclasses.
+	btCapsuleShape() : btConvexInternalShape() { m_shapeType = CAPSULE_SHAPE_PROXYTYPE; };
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btCapsuleShape(btScalar radius, btScalar height);
+
+	///CollisionShape Interface
+	virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const;
+
+	/// btConvexShape Interface
+	virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const;
+
+	virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const;
+
+	virtual void setMargin(btScalar collisionMargin)
+	{
+		//don't override the margin for capsules, their entire radius == margin
+		(void)collisionMargin;
+	}
+
+	virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const
+	{
+		btVector3 halfExtents(getRadius(), getRadius(), getRadius());
+		halfExtents[m_upAxis] = getRadius() + getHalfHeight();
+		btMatrix3x3 abs_b = t.getBasis().absolute();
+		btVector3 center = t.getOrigin();
+		btVector3 extent = halfExtents.dot3(abs_b[0], abs_b[1], abs_b[2]);
+
+		aabbMin = center - extent;
+		aabbMax = center + extent;
+	}
+
+	virtual const char* getName() const
+	{
+		return "CapsuleShape";
+	}
+
+	int getUpAxis() const
+	{
+		return m_upAxis;
+	}
+
+	btScalar getRadius() const
+	{
+		int radiusAxis = (m_upAxis + 2) % 3;
+		return m_implicitShapeDimensions[radiusAxis];
+	}
+
+	btScalar getHalfHeight() const
+	{
+		return m_implicitShapeDimensions[m_upAxis];
+	}
+
+	virtual void setLocalScaling(const btVector3& scaling)
+	{
+		btVector3 unScaledImplicitShapeDimensions = m_implicitShapeDimensions / m_localScaling;
+		btConvexInternalShape::setLocalScaling(scaling);
+		m_implicitShapeDimensions = (unScaledImplicitShapeDimensions * scaling);
+		//update m_collisionMargin, since entire radius==margin
+		int radiusAxis = (m_upAxis + 2) % 3;
+		m_collisionMargin = m_implicitShapeDimensions[radiusAxis];
+	}
+
+	virtual btVector3 getAnisotropicRollingFrictionDirection() const
+	{
+		btVector3 aniDir(0, 0, 0);
+		aniDir[getUpAxis()] = 1;
+		return aniDir;
+	}
+
+	virtual int calculateSerializeBufferSize() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
+
+	SIMD_FORCE_INLINE void deSerializeFloat(struct btCapsuleShapeData * dataBuffer);
+};
+
+///btCapsuleShapeX represents a capsule around the Z axis
+///the total height is height+2*radius, so the height is just the height between the center of each 'sphere' of the capsule caps.
+class btCapsuleShapeX : public btCapsuleShape
+{
+public:
+	btCapsuleShapeX(btScalar radius, btScalar height);
+
+	//debugging
+	virtual const char* getName() const
+	{
+		return "CapsuleX";
+	}
+};
+
+///btCapsuleShapeZ represents a capsule around the Z axis
+///the total height is height+2*radius, so the height is just the height between the center of each 'sphere' of the capsule caps.
+class btCapsuleShapeZ : public btCapsuleShape
+{
+public:
+	btCapsuleShapeZ(btScalar radius, btScalar height);
+
+	//debugging
+	virtual const char* getName() const
+	{
+		return "CapsuleZ";
+	}
+};
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct btCapsuleShapeData
+{
+	btConvexInternalShapeData m_convexInternalShapeData;
+
+	int m_upAxis;
+
+	char m_padding[4];
+};
+
+SIMD_FORCE_INLINE int btCapsuleShape::calculateSerializeBufferSize() const
+{
+	return sizeof(btCapsuleShapeData);
+}
+
+///fills the dataBuffer and returns the struct name (and 0 on failure)
+SIMD_FORCE_INLINE const char* btCapsuleShape::serialize(void* dataBuffer, btSerializer* serializer) const
+{
+	btCapsuleShapeData* shapeData = (btCapsuleShapeData*)dataBuffer;
+
+	btConvexInternalShape::serialize(&shapeData->m_convexInternalShapeData, serializer);
+
+	shapeData->m_upAxis = m_upAxis;
+
+	// Fill padding with zeros to appease msan.
+	shapeData->m_padding[0] = 0;
+	shapeData->m_padding[1] = 0;
+	shapeData->m_padding[2] = 0;
+	shapeData->m_padding[3] = 0;
+
+	return "btCapsuleShapeData";
+}
+
+SIMD_FORCE_INLINE void btCapsuleShape::deSerializeFloat(btCapsuleShapeData* dataBuffer)
+{
+	m_implicitShapeDimensions.deSerializeFloat(dataBuffer->m_convexInternalShapeData.m_implicitShapeDimensions);
+	m_collisionMargin = dataBuffer->m_convexInternalShapeData.m_collisionMargin;
+	m_localScaling.deSerializeFloat(dataBuffer->m_convexInternalShapeData.m_localScaling);
+	//it is best to already pre-allocate the matching btCapsuleShape*(X/Z) version to match m_upAxis
+	m_upAxis = dataBuffer->m_upAxis;
+}
+
+#endif  //BT_CAPSULE_SHAPE_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btCollisionMargin.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btCollisionMargin.h
new file mode 100644
index 00000000..abd8ab3e
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btCollisionMargin.h
@@ -0,0 +1,24 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_COLLISION_MARGIN_H
+#define BT_COLLISION_MARGIN_H
+
+///The CONVEX_DISTANCE_MARGIN is a default collision margin for convex collision shapes derived from btConvexInternalShape.
+///This collision margin is used by Gjk and some other algorithms
+///Note that when creating small objects, you need to make sure to set a smaller collision margin, using the 'setMargin' API
+#define CONVEX_DISTANCE_MARGIN btScalar(0.04)  // btScalar(0.1)//;//btScalar(0.01)
+
+#endif  //BT_COLLISION_MARGIN_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btCollisionShape.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btCollisionShape.h
new file mode 100644
index 00000000..16f9e0c7
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btCollisionShape.h
@@ -0,0 +1,174 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_COLLISION_SHAPE_H
+#define BT_COLLISION_SHAPE_H
+
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btMatrix3x3.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"  //for the shape types
+class btSerializer;
+
+///The btCollisionShape class provides an interface for collision shapes that can be shared among btCollisionObjects.
+ATTRIBUTE_ALIGNED16(class)
+btCollisionShape
+{
+protected:
+	int m_shapeType;
+	void* m_userPointer;
+	int m_userIndex;
+	int m_userIndex2;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btCollisionShape() : m_shapeType(INVALID_SHAPE_PROXYTYPE), m_userPointer(0), m_userIndex(-1), m_userIndex2(-1)
+	{
+	}
+
+	virtual ~btCollisionShape()
+	{
+	}
+
+	///getAabb returns the axis aligned bounding box in the coordinate frame of the given transform t.
+	virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const = 0;
+
+	virtual void getBoundingSphere(btVector3 & center, btScalar & radius) const;
+
+	///getAngularMotionDisc returns the maximum radius needed for Conservative Advancement to handle time-of-impact with rotations.
+	virtual btScalar getAngularMotionDisc() const;
+
+	virtual btScalar getContactBreakingThreshold(btScalar defaultContactThresholdFactor) const;
+
+	///calculateTemporalAabb calculates the enclosing aabb for the moving object over interval [0..timeStep)
+	///result is conservative
+	void calculateTemporalAabb(const btTransform& curTrans, const btVector3& linvel, const btVector3& angvel, btScalar timeStep, btVector3& temporalAabbMin, btVector3& temporalAabbMax) const;
+
+	SIMD_FORCE_INLINE bool isPolyhedral() const
+	{
+		return btBroadphaseProxy::isPolyhedral(getShapeType());
+	}
+
+	SIMD_FORCE_INLINE bool isConvex2d() const
+	{
+		return btBroadphaseProxy::isConvex2d(getShapeType());
+	}
+
+	SIMD_FORCE_INLINE bool isConvex() const
+	{
+		return btBroadphaseProxy::isConvex(getShapeType());
+	}
+	SIMD_FORCE_INLINE bool isNonMoving() const
+	{
+		return btBroadphaseProxy::isNonMoving(getShapeType());
+	}
+	SIMD_FORCE_INLINE bool isConcave() const
+	{
+		return btBroadphaseProxy::isConcave(getShapeType());
+	}
+	SIMD_FORCE_INLINE bool isCompound() const
+	{
+		return btBroadphaseProxy::isCompound(getShapeType());
+	}
+
+	SIMD_FORCE_INLINE bool isSoftBody() const
+	{
+		return btBroadphaseProxy::isSoftBody(getShapeType());
+	}
+
+	///isInfinite is used to catch simulation error (aabb check)
+	SIMD_FORCE_INLINE bool isInfinite() const
+	{
+		return btBroadphaseProxy::isInfinite(getShapeType());
+	}
+
+#ifndef __SPU__
+	virtual void setLocalScaling(const btVector3& scaling) = 0;
+	virtual const btVector3& getLocalScaling() const = 0;
+	virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const = 0;
+
+	//debugging support
+	virtual const char* getName() const = 0;
+#endif  //__SPU__
+
+	int getShapeType() const
+	{
+		return m_shapeType;
+	}
+
+	///the getAnisotropicRollingFrictionDirection can be used in combination with setAnisotropicFriction
+	///See Bullet/Demos/RollingFrictionDemo for an example
+	virtual btVector3 getAnisotropicRollingFrictionDirection() const
+	{
+		return btVector3(1, 1, 1);
+	}
+	virtual void setMargin(btScalar margin) = 0;
+	virtual btScalar getMargin() const = 0;
+
+	///optional user data pointer
+	void setUserPointer(void* userPtr)
+	{
+		m_userPointer = userPtr;
+	}
+
+	void* getUserPointer() const
+	{
+		return m_userPointer;
+	}
+	void setUserIndex(int index)
+	{
+		m_userIndex = index;
+	}
+
+	int getUserIndex() const
+	{
+		return m_userIndex;
+	}
+
+	void setUserIndex2(int index)
+	{
+		m_userIndex2 = index;
+	}
+
+	int getUserIndex2() const
+	{
+		return m_userIndex2;
+	}
+
+	virtual int calculateSerializeBufferSize() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
+
+	virtual void serializeSingleShape(btSerializer * serializer) const;
+};
+
+// clang-format off
+// parser needs * with the name
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct	btCollisionShapeData
+{
+	char	*m_name;
+	int		m_shapeType;
+	char	m_padding[4];
+};
+// clang-format on
+SIMD_FORCE_INLINE int btCollisionShape::calculateSerializeBufferSize() const
+{
+	return sizeof(btCollisionShapeData);
+}
+
+#endif  //BT_COLLISION_SHAPE_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btCompoundShape.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btCompoundShape.h
new file mode 100644
index 00000000..7e2d0eb8
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btCompoundShape.h
@@ -0,0 +1,207 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_COMPOUND_SHAPE_H
+#define BT_COMPOUND_SHAPE_H
+
+#include "btCollisionShape.h"
+
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btMatrix3x3.h"
+#include "btCollisionMargin.h"
+#include "LinearMath/btAlignedObjectArray.h"
+
+//class btOptimizedBvh;
+struct btDbvt;
+
+ATTRIBUTE_ALIGNED16(struct)
+btCompoundShapeChild
+{
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btTransform m_transform;
+	btCollisionShape* m_childShape;
+	int m_childShapeType;
+	btScalar m_childMargin;
+	struct btDbvtNode* m_node;
+};
+
+SIMD_FORCE_INLINE bool operator==(const btCompoundShapeChild& c1, const btCompoundShapeChild& c2)
+{
+	return (c1.m_transform == c2.m_transform &&
+			c1.m_childShape == c2.m_childShape &&
+			c1.m_childShapeType == c2.m_childShapeType &&
+			c1.m_childMargin == c2.m_childMargin);
+}
+
+/// The btCompoundShape allows to store multiple other btCollisionShapes
+/// This allows for moving concave collision objects. This is more general then the static concave btBvhTriangleMeshShape.
+/// It has an (optional) dynamic aabb tree to accelerate early rejection tests.
+/// @todo: This aabb tree can also be use to speed up ray tests on btCompoundShape, see http://code.google.com/p/bullet/issues/detail?id=25
+/// Currently, removal of child shapes is only supported when disabling the aabb tree (pass 'false' in the constructor of btCompoundShape)
+ATTRIBUTE_ALIGNED16(class)
+btCompoundShape : public btCollisionShape
+{
+protected:
+	btAlignedObjectArray<btCompoundShapeChild> m_children;
+	btVector3 m_localAabbMin;
+	btVector3 m_localAabbMax;
+
+	btDbvt* m_dynamicAabbTree;
+
+	///increment m_updateRevision when adding/removing/replacing child shapes, so that some caches can be updated
+	int m_updateRevision;
+
+	btScalar m_collisionMargin;
+
+	btVector3 m_localScaling;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	explicit btCompoundShape(bool enableDynamicAabbTree = true, const int initialChildCapacity = 0);
+
+	virtual ~btCompoundShape();
+
+	void addChildShape(const btTransform& localTransform, btCollisionShape* shape);
+
+	/// Remove all children shapes that contain the specified shape
+	virtual void removeChildShape(btCollisionShape * shape);
+
+	void removeChildShapeByIndex(int childShapeindex);
+
+	int getNumChildShapes() const
+	{
+		return int(m_children.size());
+	}
+
+	btCollisionShape* getChildShape(int index)
+	{
+		return m_children[index].m_childShape;
+	}
+	const btCollisionShape* getChildShape(int index) const
+	{
+		return m_children[index].m_childShape;
+	}
+
+	btTransform& getChildTransform(int index)
+	{
+		return m_children[index].m_transform;
+	}
+	const btTransform& getChildTransform(int index) const
+	{
+		return m_children[index].m_transform;
+	}
+
+	///set a new transform for a child, and update internal data structures (local aabb and dynamic tree)
+	void updateChildTransform(int childIndex, const btTransform& newChildTransform, bool shouldRecalculateLocalAabb = true);
+
+	btCompoundShapeChild* getChildList()
+	{
+		return &m_children[0];
+	}
+
+	///getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version
+	virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const;
+
+	/** Re-calculate the local Aabb. Is called at the end of removeChildShapes. 
+	Use this yourself if you modify the children or their transforms. */
+	virtual void recalculateLocalAabb();
+
+	virtual void setLocalScaling(const btVector3& scaling);
+
+	virtual const btVector3& getLocalScaling() const
+	{
+		return m_localScaling;
+	}
+
+	virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const;
+
+	virtual void setMargin(btScalar margin)
+	{
+		m_collisionMargin = margin;
+	}
+	virtual btScalar getMargin() const
+	{
+		return m_collisionMargin;
+	}
+	virtual const char* getName() const
+	{
+		return "Compound";
+	}
+
+	const btDbvt* getDynamicAabbTree() const
+	{
+		return m_dynamicAabbTree;
+	}
+
+	btDbvt* getDynamicAabbTree()
+	{
+		return m_dynamicAabbTree;
+	}
+
+	void createAabbTreeFromChildren();
+
+	///computes the exact moment of inertia and the transform from the coordinate system defined by the principal axes of the moment of inertia
+	///and the center of mass to the current coordinate system. "masses" points to an array of masses of the children. The resulting transform
+	///"principal" has to be applied inversely to all children transforms in order for the local coordinate system of the compound
+	///shape to be centered at the center of mass and to coincide with the principal axes. This also necessitates a correction of the world transform
+	///of the collision object by the principal transform.
+	void calculatePrincipalAxisTransform(const btScalar* masses, btTransform& principal, btVector3& inertia) const;
+
+	int getUpdateRevision() const
+	{
+		return m_updateRevision;
+	}
+
+	virtual int calculateSerializeBufferSize() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
+};
+
+// clang-format off
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct btCompoundShapeChildData
+{
+	btTransformFloatData	m_transform;
+	btCollisionShapeData	*m_childShape;
+	int						m_childShapeType;
+	float					m_childMargin;
+};
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct	btCompoundShapeData
+{
+	btCollisionShapeData		m_collisionShapeData;
+
+	btCompoundShapeChildData	*m_childShapePtr;
+
+	int							m_numChildShapes;
+
+	float	m_collisionMargin;
+
+};
+
+// clang-format on
+
+SIMD_FORCE_INLINE int btCompoundShape::calculateSerializeBufferSize() const
+{
+	return sizeof(btCompoundShapeData);
+}
+
+#endif  //BT_COMPOUND_SHAPE_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btConcaveShape.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btConcaveShape.h
new file mode 100644
index 00000000..716624e1
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btConcaveShape.h
@@ -0,0 +1,62 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_CONCAVE_SHAPE_H
+#define BT_CONCAVE_SHAPE_H
+
+#include "btCollisionShape.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"  // for the types
+#include "btTriangleCallback.h"
+
+/// PHY_ScalarType enumerates possible scalar types.
+/// See the btStridingMeshInterface or btHeightfieldTerrainShape for its use
+typedef enum PHY_ScalarType
+{
+	PHY_FLOAT,
+	PHY_DOUBLE,
+	PHY_INTEGER,
+	PHY_SHORT,
+	PHY_FIXEDPOINT88,
+	PHY_UCHAR
+} PHY_ScalarType;
+
+///The btConcaveShape class provides an interface for non-moving (static) concave shapes.
+///It has been implemented by the btStaticPlaneShape, btBvhTriangleMeshShape and btHeightfieldTerrainShape.
+ATTRIBUTE_ALIGNED16(class)
+btConcaveShape : public btCollisionShape
+{
+protected:
+	btScalar m_collisionMargin;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btConcaveShape();
+
+	virtual ~btConcaveShape();
+
+	virtual void processAllTriangles(btTriangleCallback * callback, const btVector3& aabbMin, const btVector3& aabbMax) const = 0;
+
+	virtual btScalar getMargin() const
+	{
+		return m_collisionMargin;
+	}
+	virtual void setMargin(btScalar collisionMargin)
+	{
+		m_collisionMargin = collisionMargin;
+	}
+};
+
+#endif  //BT_CONCAVE_SHAPE_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btConeShape.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btConeShape.h
new file mode 100644
index 00000000..49f26bc4
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btConeShape.h
@@ -0,0 +1,175 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_CONE_MINKOWSKI_H
+#define BT_CONE_MINKOWSKI_H
+
+#include "btConvexInternalShape.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"  // for the types
+
+///The btConeShape implements a cone shape primitive, centered around the origin and aligned with the Y axis. The btConeShapeX is aligned around the X axis and btConeShapeZ around the Z axis.
+ATTRIBUTE_ALIGNED16(class)
+btConeShape : public btConvexInternalShape
+
+{
+	btScalar m_sinAngle;
+	btScalar m_radius;
+	btScalar m_height;
+	int m_coneIndices[3];
+	btVector3 coneLocalSupport(const btVector3& v) const;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btConeShape(btScalar radius, btScalar height);
+
+	virtual btVector3 localGetSupportingVertex(const btVector3& vec) const;
+	virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const;
+	virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const;
+
+	btScalar getRadius() const { return m_radius; }
+	btScalar getHeight() const { return m_height; }
+
+	void setRadius(const btScalar radius)
+	{
+		m_radius = radius;
+	}
+	void setHeight(const btScalar height)
+	{
+		m_height = height;
+	}
+
+	virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const
+	{
+		btTransform identity;
+		identity.setIdentity();
+		btVector3 aabbMin, aabbMax;
+		getAabb(identity, aabbMin, aabbMax);
+
+		btVector3 halfExtents = (aabbMax - aabbMin) * btScalar(0.5);
+
+		btScalar margin = getMargin();
+
+		btScalar lx = btScalar(2.) * (halfExtents.x() + margin);
+		btScalar ly = btScalar(2.) * (halfExtents.y() + margin);
+		btScalar lz = btScalar(2.) * (halfExtents.z() + margin);
+		const btScalar x2 = lx * lx;
+		const btScalar y2 = ly * ly;
+		const btScalar z2 = lz * lz;
+		const btScalar scaledmass = mass * btScalar(0.08333333);
+
+		inertia = scaledmass * (btVector3(y2 + z2, x2 + z2, x2 + y2));
+
+		//		inertia.x() = scaledmass * (y2+z2);
+		//		inertia.y() = scaledmass * (x2+z2);
+		//		inertia.z() = scaledmass * (x2+y2);
+	}
+
+	virtual const char* getName() const
+	{
+		return "Cone";
+	}
+
+	///choose upAxis index
+	void setConeUpIndex(int upIndex);
+
+	int getConeUpIndex() const
+	{
+		return m_coneIndices[1];
+	}
+
+	virtual btVector3 getAnisotropicRollingFrictionDirection() const
+	{
+		return btVector3(0, 1, 0);
+	}
+
+	virtual void setLocalScaling(const btVector3& scaling);
+
+	virtual int calculateSerializeBufferSize() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
+};
+
+///btConeShape implements a Cone shape, around the X axis
+class btConeShapeX : public btConeShape
+{
+public:
+	btConeShapeX(btScalar radius, btScalar height);
+
+	virtual btVector3 getAnisotropicRollingFrictionDirection() const
+	{
+		return btVector3(1, 0, 0);
+	}
+
+	//debugging
+	virtual const char* getName() const
+	{
+		return "ConeX";
+	}
+};
+
+///btConeShapeZ implements a Cone shape, around the Z axis
+class btConeShapeZ : public btConeShape
+{
+public:
+	btConeShapeZ(btScalar radius, btScalar height);
+
+	virtual btVector3 getAnisotropicRollingFrictionDirection() const
+	{
+		return btVector3(0, 0, 1);
+	}
+
+	//debugging
+	virtual const char* getName() const
+	{
+		return "ConeZ";
+	}
+};
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct btConeShapeData
+{
+	btConvexInternalShapeData m_convexInternalShapeData;
+
+	int m_upIndex;
+
+	char m_padding[4];
+};
+
+SIMD_FORCE_INLINE int btConeShape::calculateSerializeBufferSize() const
+{
+	return sizeof(btConeShapeData);
+}
+
+///fills the dataBuffer and returns the struct name (and 0 on failure)
+SIMD_FORCE_INLINE const char* btConeShape::serialize(void* dataBuffer, btSerializer* serializer) const
+{
+	btConeShapeData* shapeData = (btConeShapeData*)dataBuffer;
+
+	btConvexInternalShape::serialize(&shapeData->m_convexInternalShapeData, serializer);
+
+	shapeData->m_upIndex = m_coneIndices[1];
+
+	// Fill padding with zeros to appease msan.
+	shapeData->m_padding[0] = 0;
+	shapeData->m_padding[1] = 0;
+	shapeData->m_padding[2] = 0;
+	shapeData->m_padding[3] = 0;
+
+	return "btConeShapeData";
+}
+
+#endif  //BT_CONE_MINKOWSKI_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btConvex2dShape.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btConvex2dShape.h
new file mode 100644
index 00000000..cd4f1ef7
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btConvex2dShape.h
@@ -0,0 +1,77 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_CONVEX_2D_SHAPE_H
+#define BT_CONVEX_2D_SHAPE_H
+
+#include "BulletCollision/CollisionShapes/btConvexShape.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"  // for the types
+
+///The btConvex2dShape allows to use arbitrary convex shapes as 2d convex shapes, with the Z component assumed to be 0.
+///For 2d boxes, the btBox2dShape is recommended.
+ATTRIBUTE_ALIGNED16(class)
+btConvex2dShape : public btConvexShape
+{
+	btConvexShape* m_childConvexShape;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btConvex2dShape(btConvexShape * convexChildShape);
+
+	virtual ~btConvex2dShape();
+
+	virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const;
+
+	virtual btVector3 localGetSupportingVertex(const btVector3& vec) const;
+
+	virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const;
+
+	virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const;
+
+	btConvexShape* getChildShape()
+	{
+		return m_childConvexShape;
+	}
+
+	const btConvexShape* getChildShape() const
+	{
+		return m_childConvexShape;
+	}
+
+	virtual const char* getName() const
+	{
+		return "Convex2dShape";
+	}
+
+	///////////////////////////
+
+	///getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version
+	void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const;
+
+	virtual void getAabbSlow(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const;
+
+	virtual void setLocalScaling(const btVector3& scaling);
+	virtual const btVector3& getLocalScaling() const;
+
+	virtual void setMargin(btScalar margin);
+	virtual btScalar getMargin() const;
+
+	virtual int getNumPreferredPenetrationDirections() const;
+
+	virtual void getPreferredPenetrationDirection(int index, btVector3& penetrationVector) const;
+};
+
+#endif  //BT_CONVEX_2D_SHAPE_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btConvexHullShape.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btConvexHullShape.h
new file mode 100644
index 00000000..96136d7d
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btConvexHullShape.h
@@ -0,0 +1,116 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_CONVEX_HULL_SHAPE_H
+#define BT_CONVEX_HULL_SHAPE_H
+
+#include "btPolyhedralConvexShape.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"  // for the types
+#include "LinearMath/btAlignedObjectArray.h"
+
+///The btConvexHullShape implements an implicit convex hull of an array of vertices.
+///Bullet provides a general and fast collision detector for convex shapes based on GJK and EPA using localGetSupportingVertex.
+ATTRIBUTE_ALIGNED16(class)
+btConvexHullShape : public btPolyhedralConvexAabbCachingShape
+{
+	btAlignedObjectArray<btVector3> m_unscaledPoints;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	///this constructor optionally takes in a pointer to points. Each point is assumed to be 3 consecutive btScalar (x,y,z), the striding defines the number of bytes between each point, in memory.
+	///It is easier to not pass any points in the constructor, and just add one point at a time, using addPoint.
+	///btConvexHullShape make an internal copy of the points.
+	btConvexHullShape(const btScalar* points = 0, int numPoints = 0, int stride = sizeof(btVector3));
+
+	void addPoint(const btVector3& point, bool recalculateLocalAabb = true);
+
+	btVector3* getUnscaledPoints()
+	{
+		return &m_unscaledPoints[0];
+	}
+
+	const btVector3* getUnscaledPoints() const
+	{
+		return &m_unscaledPoints[0];
+	}
+
+	///getPoints is obsolete, please use getUnscaledPoints
+	const btVector3* getPoints() const
+	{
+		return getUnscaledPoints();
+	}
+
+	void optimizeConvexHull();
+
+	SIMD_FORCE_INLINE btVector3 getScaledPoint(int i) const
+	{
+		return m_unscaledPoints[i] * m_localScaling;
+	}
+
+	SIMD_FORCE_INLINE int getNumPoints() const
+	{
+		return m_unscaledPoints.size();
+	}
+
+	virtual btVector3 localGetSupportingVertex(const btVector3& vec) const;
+	virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const;
+	virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const;
+
+	virtual void project(const btTransform& trans, const btVector3& dir, btScalar& minProj, btScalar& maxProj, btVector3& witnesPtMin, btVector3& witnesPtMax) const;
+
+	//debugging
+	virtual const char* getName() const { return "Convex"; }
+
+	virtual int getNumVertices() const;
+	virtual int getNumEdges() const;
+	virtual void getEdge(int i, btVector3& pa, btVector3& pb) const;
+	virtual void getVertex(int i, btVector3& vtx) const;
+	virtual int getNumPlanes() const;
+	virtual void getPlane(btVector3 & planeNormal, btVector3 & planeSupport, int i) const;
+	virtual bool isInside(const btVector3& pt, btScalar tolerance) const;
+
+	///in case we receive negative scaling
+	virtual void setLocalScaling(const btVector3& scaling);
+
+	virtual int calculateSerializeBufferSize() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
+};
+
+// clang-format off
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct	btConvexHullShapeData
+{
+	btConvexInternalShapeData	m_convexInternalShapeData;
+
+	btVector3FloatData	*m_unscaledPointsFloatPtr;
+	btVector3DoubleData	*m_unscaledPointsDoublePtr;
+
+	int		m_numUnscaledPoints;
+	char m_padding3[4];
+
+};
+
+// clang-format on
+
+SIMD_FORCE_INLINE int btConvexHullShape::calculateSerializeBufferSize() const
+{
+	return sizeof(btConvexHullShapeData);
+}
+
+#endif  //BT_CONVEX_HULL_SHAPE_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btConvexInternalShape.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btConvexInternalShape.h
new file mode 100644
index 00000000..a28c57de
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btConvexInternalShape.h
@@ -0,0 +1,208 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_CONVEX_INTERNAL_SHAPE_H
+#define BT_CONVEX_INTERNAL_SHAPE_H
+
+#include "btConvexShape.h"
+#include "LinearMath/btAabbUtil2.h"
+
+///The btConvexInternalShape is an internal base class, shared by most convex shape implementations.
+///The btConvexInternalShape uses a default collision margin set to CONVEX_DISTANCE_MARGIN.
+///This collision margin used by Gjk and some other algorithms, see also btCollisionMargin.h
+///Note that when creating small shapes (derived from btConvexInternalShape),
+///you need to make sure to set a smaller collision margin, using the 'setMargin' API
+///There is a automatic mechanism 'setSafeMargin' used by btBoxShape and btCylinderShape
+ATTRIBUTE_ALIGNED16(class)
+btConvexInternalShape : public btConvexShape
+{
+protected:
+	//local scaling. collisionMargin is not scaled !
+	btVector3 m_localScaling;
+
+	btVector3 m_implicitShapeDimensions;
+
+	btScalar m_collisionMargin;
+
+	btScalar m_padding;
+
+	btConvexInternalShape();
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	virtual ~btConvexInternalShape()
+	{
+	}
+
+	virtual btVector3 localGetSupportingVertex(const btVector3& vec) const;
+
+	const btVector3& getImplicitShapeDimensions() const
+	{
+		return m_implicitShapeDimensions;
+	}
+
+	///warning: use setImplicitShapeDimensions with care
+	///changing a collision shape while the body is in the world is not recommended,
+	///it is best to remove the body from the world, then make the change, and re-add it
+	///alternatively flush the contact points, see documentation for 'cleanProxyFromPairs'
+	void setImplicitShapeDimensions(const btVector3& dimensions)
+	{
+		m_implicitShapeDimensions = dimensions;
+	}
+
+	void setSafeMargin(btScalar minDimension, btScalar defaultMarginMultiplier = 0.1f)
+	{
+		btScalar safeMargin = defaultMarginMultiplier * minDimension;
+		if (safeMargin < getMargin())
+		{
+			setMargin(safeMargin);
+		}
+	}
+	void setSafeMargin(const btVector3& halfExtents, btScalar defaultMarginMultiplier = 0.1f)
+	{
+		//see http://code.google.com/p/bullet/issues/detail?id=349
+		//this margin check could could be added to other collision shapes too,
+		//or add some assert/warning somewhere
+		btScalar minDimension = halfExtents[halfExtents.minAxis()];
+		setSafeMargin(minDimension, defaultMarginMultiplier);
+	}
+
+	///getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version
+	void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const
+	{
+		getAabbSlow(t, aabbMin, aabbMax);
+	}
+
+	virtual void getAabbSlow(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const;
+
+	virtual void setLocalScaling(const btVector3& scaling);
+	virtual const btVector3& getLocalScaling() const
+	{
+		return m_localScaling;
+	}
+
+	const btVector3& getLocalScalingNV() const
+	{
+		return m_localScaling;
+	}
+
+	virtual void setMargin(btScalar margin)
+	{
+		m_collisionMargin = margin;
+	}
+	virtual btScalar getMargin() const
+	{
+		return m_collisionMargin;
+	}
+
+	btScalar getMarginNV() const
+	{
+		return m_collisionMargin;
+	}
+
+	virtual int getNumPreferredPenetrationDirections() const
+	{
+		return 0;
+	}
+
+	virtual void getPreferredPenetrationDirection(int index, btVector3& penetrationVector) const
+	{
+		(void)penetrationVector;
+		(void)index;
+		btAssert(0);
+	}
+
+	virtual int calculateSerializeBufferSize() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
+};
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct btConvexInternalShapeData
+{
+	btCollisionShapeData m_collisionShapeData;
+
+	btVector3FloatData m_localScaling;
+
+	btVector3FloatData m_implicitShapeDimensions;
+
+	float m_collisionMargin;
+
+	int m_padding;
+};
+
+SIMD_FORCE_INLINE int btConvexInternalShape::calculateSerializeBufferSize() const
+{
+	return sizeof(btConvexInternalShapeData);
+}
+
+///fills the dataBuffer and returns the struct name (and 0 on failure)
+SIMD_FORCE_INLINE const char* btConvexInternalShape::serialize(void* dataBuffer, btSerializer* serializer) const
+{
+	btConvexInternalShapeData* shapeData = (btConvexInternalShapeData*)dataBuffer;
+	btCollisionShape::serialize(&shapeData->m_collisionShapeData, serializer);
+
+	m_implicitShapeDimensions.serializeFloat(shapeData->m_implicitShapeDimensions);
+	m_localScaling.serializeFloat(shapeData->m_localScaling);
+	shapeData->m_collisionMargin = float(m_collisionMargin);
+
+	// Fill padding with zeros to appease msan.
+	shapeData->m_padding = 0;
+
+	return "btConvexInternalShapeData";
+}
+
+///btConvexInternalAabbCachingShape adds local aabb caching for convex shapes, to avoid expensive bounding box calculations
+class btConvexInternalAabbCachingShape : public btConvexInternalShape
+{
+	btVector3 m_localAabbMin;
+	btVector3 m_localAabbMax;
+	bool m_isLocalAabbValid;
+
+protected:
+	btConvexInternalAabbCachingShape();
+
+	void setCachedLocalAabb(const btVector3& aabbMin, const btVector3& aabbMax)
+	{
+		m_isLocalAabbValid = true;
+		m_localAabbMin = aabbMin;
+		m_localAabbMax = aabbMax;
+	}
+
+	inline void getCachedLocalAabb(btVector3& aabbMin, btVector3& aabbMax) const
+	{
+		btAssert(m_isLocalAabbValid);
+		aabbMin = m_localAabbMin;
+		aabbMax = m_localAabbMax;
+	}
+
+	inline void getNonvirtualAabb(const btTransform& trans, btVector3& aabbMin, btVector3& aabbMax, btScalar margin) const
+	{
+		//lazy evaluation of local aabb
+		btAssert(m_isLocalAabbValid);
+		btTransformAabb(m_localAabbMin, m_localAabbMax, margin, trans, aabbMin, aabbMax);
+	}
+
+public:
+	virtual void setLocalScaling(const btVector3& scaling);
+
+	virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const;
+
+	void recalcLocalAabb();
+};
+
+#endif  //BT_CONVEX_INTERNAL_SHAPE_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btConvexPointCloudShape.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btConvexPointCloudShape.h
new file mode 100644
index 00000000..c7d554a4
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btConvexPointCloudShape.h
@@ -0,0 +1,103 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_CONVEX_POINT_CLOUD_SHAPE_H
+#define BT_CONVEX_POINT_CLOUD_SHAPE_H
+
+#include "btPolyhedralConvexShape.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"  // for the types
+#include "LinearMath/btAlignedObjectArray.h"
+
+///The btConvexPointCloudShape implements an implicit convex hull of an array of vertices.
+ATTRIBUTE_ALIGNED16(class)
+btConvexPointCloudShape : public btPolyhedralConvexAabbCachingShape
+{
+	btVector3* m_unscaledPoints;
+	int m_numPoints;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btConvexPointCloudShape()
+	{
+		m_localScaling.setValue(1.f, 1.f, 1.f);
+		m_shapeType = CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE;
+		m_unscaledPoints = 0;
+		m_numPoints = 0;
+	}
+
+	btConvexPointCloudShape(btVector3 * points, int numPoints, const btVector3& localScaling, bool computeAabb = true)
+	{
+		m_localScaling = localScaling;
+		m_shapeType = CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE;
+		m_unscaledPoints = points;
+		m_numPoints = numPoints;
+
+		if (computeAabb)
+			recalcLocalAabb();
+	}
+
+	void setPoints(btVector3 * points, int numPoints, bool computeAabb = true, const btVector3& localScaling = btVector3(1.f, 1.f, 1.f))
+	{
+		m_unscaledPoints = points;
+		m_numPoints = numPoints;
+		m_localScaling = localScaling;
+
+		if (computeAabb)
+			recalcLocalAabb();
+	}
+
+	SIMD_FORCE_INLINE btVector3* getUnscaledPoints()
+	{
+		return m_unscaledPoints;
+	}
+
+	SIMD_FORCE_INLINE const btVector3* getUnscaledPoints() const
+	{
+		return m_unscaledPoints;
+	}
+
+	SIMD_FORCE_INLINE int getNumPoints() const
+	{
+		return m_numPoints;
+	}
+
+	SIMD_FORCE_INLINE btVector3 getScaledPoint(int index) const
+	{
+		return m_unscaledPoints[index] * m_localScaling;
+	}
+
+#ifndef __SPU__
+	virtual btVector3 localGetSupportingVertex(const btVector3& vec) const;
+	virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const;
+	virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const;
+#endif
+
+	//debugging
+	virtual const char* getName() const { return "ConvexPointCloud"; }
+
+	virtual int getNumVertices() const;
+	virtual int getNumEdges() const;
+	virtual void getEdge(int i, btVector3& pa, btVector3& pb) const;
+	virtual void getVertex(int i, btVector3& vtx) const;
+	virtual int getNumPlanes() const;
+	virtual void getPlane(btVector3 & planeNormal, btVector3 & planeSupport, int i) const;
+	virtual bool isInside(const btVector3& pt, btScalar tolerance) const;
+
+	///in case we receive negative scaling
+	virtual void setLocalScaling(const btVector3& scaling);
+};
+
+#endif  //BT_CONVEX_POINT_CLOUD_SHAPE_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btConvexPolyhedron.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btConvexPolyhedron.h
new file mode 100644
index 00000000..638aa9b3
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btConvexPolyhedron.h
@@ -0,0 +1,59 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2011 Advanced Micro Devices, Inc.  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+///This file was written by Erwin Coumans
+
+#ifndef _BT_POLYHEDRAL_FEATURES_H
+#define _BT_POLYHEDRAL_FEATURES_H
+
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btAlignedObjectArray.h"
+
+#define TEST_INTERNAL_OBJECTS 1
+
+struct btFace
+{
+	btAlignedObjectArray<int> m_indices;
+	//	btAlignedObjectArray<int>	m_connectedFaces;
+	btScalar m_plane[4];
+};
+
+ATTRIBUTE_ALIGNED16(class)
+btConvexPolyhedron
+{
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btConvexPolyhedron();
+	virtual ~btConvexPolyhedron();
+
+	btAlignedObjectArray<btVector3> m_vertices;
+	btAlignedObjectArray<btFace> m_faces;
+	btAlignedObjectArray<btVector3> m_uniqueEdges;
+
+	btVector3 m_localCenter;
+	btVector3 m_extents;
+	btScalar m_radius;
+	btVector3 mC;
+	btVector3 mE;
+
+	void initialize();
+	void initialize2();
+	bool testContainment() const;
+
+	void project(const btTransform& trans, const btVector3& dir, btScalar& minProj, btScalar& maxProj, btVector3& witnesPtMin, btVector3& witnesPtMax) const;
+};
+
+#endif  //_BT_POLYHEDRAL_FEATURES_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btConvexShape.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btConvexShape.h
new file mode 100644
index 00000000..d3b3ed81
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btConvexShape.h
@@ -0,0 +1,75 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_CONVEX_SHAPE_INTERFACE1
+#define BT_CONVEX_SHAPE_INTERFACE1
+
+#include "btCollisionShape.h"
+
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btMatrix3x3.h"
+#include "btCollisionMargin.h"
+#include "LinearMath/btAlignedAllocator.h"
+
+#define MAX_PREFERRED_PENETRATION_DIRECTIONS 10
+
+/// The btConvexShape is an abstract shape interface, implemented by all convex shapes such as btBoxShape, btConvexHullShape etc.
+/// It describes general convex shapes using the localGetSupportingVertex interface, used by collision detectors such as btGjkPairDetector.
+ATTRIBUTE_ALIGNED16(class)
+btConvexShape : public btCollisionShape
+{
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btConvexShape();
+
+	virtual ~btConvexShape();
+
+	virtual btVector3 localGetSupportingVertex(const btVector3& vec) const = 0;
+
+////////
+#ifndef __SPU__
+	virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const = 0;
+#endif  //#ifndef __SPU__
+
+	btVector3 localGetSupportVertexWithoutMarginNonVirtual(const btVector3& vec) const;
+	btVector3 localGetSupportVertexNonVirtual(const btVector3& vec) const;
+	btScalar getMarginNonVirtual() const;
+	void getAabbNonVirtual(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const;
+
+	virtual void project(const btTransform& trans, const btVector3& dir, btScalar& minProj, btScalar& maxProj, btVector3& witnesPtMin, btVector3& witnesPtMax) const;
+
+	//notice that the vectors should be unit length
+	virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const = 0;
+
+	///getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version
+	void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const = 0;
+
+	virtual void getAabbSlow(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const = 0;
+
+	virtual void setLocalScaling(const btVector3& scaling) = 0;
+	virtual const btVector3& getLocalScaling() const = 0;
+
+	virtual void setMargin(btScalar margin) = 0;
+
+	virtual btScalar getMargin() const = 0;
+
+	virtual int getNumPreferredPenetrationDirections() const = 0;
+
+	virtual void getPreferredPenetrationDirection(int index, btVector3& penetrationVector) const = 0;
+};
+
+#endif  //BT_CONVEX_SHAPE_INTERFACE1
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h
new file mode 100644
index 00000000..6dac9fff
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h
@@ -0,0 +1,68 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef BT_CONVEX_TRIANGLEMESH_SHAPE_H
+#define BT_CONVEX_TRIANGLEMESH_SHAPE_H
+
+#include "btPolyhedralConvexShape.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"  // for the types
+
+/// The btConvexTriangleMeshShape is a convex hull of a triangle mesh, but the performance is not as good as btConvexHullShape.
+/// A small benefit of this class is that it uses the btStridingMeshInterface, so you can avoid the duplication of the triangle mesh data. Nevertheless, most users should use the much better performing btConvexHullShape instead.
+ATTRIBUTE_ALIGNED16(class)
+btConvexTriangleMeshShape : public btPolyhedralConvexAabbCachingShape
+{
+	class btStridingMeshInterface* m_stridingMesh;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btConvexTriangleMeshShape(btStridingMeshInterface * meshInterface, bool calcAabb = true);
+
+	class btStridingMeshInterface* getMeshInterface()
+	{
+		return m_stridingMesh;
+	}
+	const class btStridingMeshInterface* getMeshInterface() const
+	{
+		return m_stridingMesh;
+	}
+
+	virtual btVector3 localGetSupportingVertex(const btVector3& vec) const;
+	virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const;
+	virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const;
+
+	//debugging
+	virtual const char* getName() const { return "ConvexTrimesh"; }
+
+	virtual int getNumVertices() const;
+	virtual int getNumEdges() const;
+	virtual void getEdge(int i, btVector3& pa, btVector3& pb) const;
+	virtual void getVertex(int i, btVector3& vtx) const;
+	virtual int getNumPlanes() const;
+	virtual void getPlane(btVector3 & planeNormal, btVector3 & planeSupport, int i) const;
+	virtual bool isInside(const btVector3& pt, btScalar tolerance) const;
+
+	virtual void setLocalScaling(const btVector3& scaling);
+	virtual const btVector3& getLocalScaling() const;
+
+	///computes the exact moment of inertia and the transform from the coordinate system defined by the principal axes of the moment of inertia
+	///and the center of mass to the current coordinate system. A mass of 1 is assumed, for other masses just multiply the computed "inertia"
+	///by the mass. The resulting transform "principal" has to be applied inversely to the mesh in order for the local coordinate system of the
+	///shape to be centered at the center of mass and to coincide with the principal axes. This also necessitates a correction of the world transform
+	///of the collision object by the principal transform. This method also computes the volume of the convex mesh.
+	void calculatePrincipalAxisTransform(btTransform & principal, btVector3 & inertia, btScalar & volume) const;
+};
+
+#endif  //BT_CONVEX_TRIANGLEMESH_SHAPE_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btCylinderShape.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btCylinderShape.h
new file mode 100644
index 00000000..d3f64508
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btCylinderShape.h
@@ -0,0 +1,206 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_CYLINDER_MINKOWSKI_H
+#define BT_CYLINDER_MINKOWSKI_H
+
+#include "btBoxShape.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"  // for the types
+#include "LinearMath/btVector3.h"
+
+/// The btCylinderShape class implements a cylinder shape primitive, centered around the origin. Its central axis aligned with the Y axis. btCylinderShapeX is aligned with the X axis and btCylinderShapeZ around the Z axis.
+ATTRIBUTE_ALIGNED16(class)
+btCylinderShape : public btConvexInternalShape
+
+{
+protected:
+	int m_upAxis;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btVector3 getHalfExtentsWithMargin() const
+	{
+		btVector3 halfExtents = getHalfExtentsWithoutMargin();
+		btVector3 margin(getMargin(), getMargin(), getMargin());
+		halfExtents += margin;
+		return halfExtents;
+	}
+
+	const btVector3& getHalfExtentsWithoutMargin() const
+	{
+		return m_implicitShapeDimensions;  //changed in Bullet 2.63: assume the scaling and margin are included
+	}
+
+	btCylinderShape(const btVector3& halfExtents);
+
+	void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const;
+
+	virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const;
+
+	virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const;
+
+	virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const;
+
+	virtual void setMargin(btScalar collisionMargin)
+	{
+		//correct the m_implicitShapeDimensions for the margin
+		btVector3 oldMargin(getMargin(), getMargin(), getMargin());
+		btVector3 implicitShapeDimensionsWithMargin = m_implicitShapeDimensions + oldMargin;
+
+		btConvexInternalShape::setMargin(collisionMargin);
+		btVector3 newMargin(getMargin(), getMargin(), getMargin());
+		m_implicitShapeDimensions = implicitShapeDimensionsWithMargin - newMargin;
+	}
+
+	virtual btVector3 localGetSupportingVertex(const btVector3& vec) const
+	{
+		btVector3 supVertex;
+		supVertex = localGetSupportingVertexWithoutMargin(vec);
+
+		if (getMargin() != btScalar(0.))
+		{
+			btVector3 vecnorm = vec;
+			if (vecnorm.length2() < (SIMD_EPSILON * SIMD_EPSILON))
+			{
+				vecnorm.setValue(btScalar(-1.), btScalar(-1.), btScalar(-1.));
+			}
+			vecnorm.normalize();
+			supVertex += getMargin() * vecnorm;
+		}
+		return supVertex;
+	}
+
+	//use box inertia
+	//	virtual void	calculateLocalInertia(btScalar mass,btVector3& inertia) const;
+
+	int getUpAxis() const
+	{
+		return m_upAxis;
+	}
+
+	virtual btVector3 getAnisotropicRollingFrictionDirection() const
+	{
+		btVector3 aniDir(0, 0, 0);
+		aniDir[getUpAxis()] = 1;
+		return aniDir;
+	}
+
+	virtual btScalar getRadius() const
+	{
+		return getHalfExtentsWithMargin().getX();
+	}
+
+	virtual void setLocalScaling(const btVector3& scaling)
+	{
+		btVector3 oldMargin(getMargin(), getMargin(), getMargin());
+		btVector3 implicitShapeDimensionsWithMargin = m_implicitShapeDimensions + oldMargin;
+		btVector3 unScaledImplicitShapeDimensionsWithMargin = implicitShapeDimensionsWithMargin / m_localScaling;
+
+		btConvexInternalShape::setLocalScaling(scaling);
+
+		m_implicitShapeDimensions = (unScaledImplicitShapeDimensionsWithMargin * m_localScaling) - oldMargin;
+	}
+
+	//debugging
+	virtual const char* getName() const
+	{
+		return "CylinderY";
+	}
+
+	virtual int calculateSerializeBufferSize() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
+};
+
+class btCylinderShapeX : public btCylinderShape
+{
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btCylinderShapeX(const btVector3& halfExtents);
+
+	virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const;
+	virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const;
+
+	//debugging
+	virtual const char* getName() const
+	{
+		return "CylinderX";
+	}
+
+	virtual btScalar getRadius() const
+	{
+		return getHalfExtentsWithMargin().getY();
+	}
+};
+
+class btCylinderShapeZ : public btCylinderShape
+{
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btCylinderShapeZ(const btVector3& halfExtents);
+
+	virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const;
+	virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const;
+
+	//debugging
+	virtual const char* getName() const
+	{
+		return "CylinderZ";
+	}
+
+	virtual btScalar getRadius() const
+	{
+		return getHalfExtentsWithMargin().getX();
+	}
+};
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct btCylinderShapeData
+{
+	btConvexInternalShapeData m_convexInternalShapeData;
+
+	int m_upAxis;
+
+	char m_padding[4];
+};
+
+SIMD_FORCE_INLINE int btCylinderShape::calculateSerializeBufferSize() const
+{
+	return sizeof(btCylinderShapeData);
+}
+
+///fills the dataBuffer and returns the struct name (and 0 on failure)
+SIMD_FORCE_INLINE const char* btCylinderShape::serialize(void* dataBuffer, btSerializer* serializer) const
+{
+	btCylinderShapeData* shapeData = (btCylinderShapeData*)dataBuffer;
+
+	btConvexInternalShape::serialize(&shapeData->m_convexInternalShapeData, serializer);
+
+	shapeData->m_upAxis = m_upAxis;
+
+	// Fill padding with zeros to appease msan.
+	shapeData->m_padding[0] = 0;
+	shapeData->m_padding[1] = 0;
+	shapeData->m_padding[2] = 0;
+	shapeData->m_padding[3] = 0;
+
+	return "btCylinderShapeData";
+}
+
+#endif  //BT_CYLINDER_MINKOWSKI_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btEmptyShape.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btEmptyShape.h
new file mode 100644
index 00000000..d2e21173
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btEmptyShape.h
@@ -0,0 +1,65 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_EMPTY_SHAPE_H
+#define BT_EMPTY_SHAPE_H
+
+#include "btConcaveShape.h"
+
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btMatrix3x3.h"
+#include "btCollisionMargin.h"
+
+/// The btEmptyShape is a collision shape without actual collision detection shape, so most users should ignore this class.
+/// It can be replaced by another shape during runtime, but the inertia tensor should be recomputed.
+ATTRIBUTE_ALIGNED16(class)
+btEmptyShape : public btConcaveShape
+{
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btEmptyShape();
+
+	virtual ~btEmptyShape();
+
+	///getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version
+	void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const;
+
+	virtual void setLocalScaling(const btVector3& scaling)
+	{
+		m_localScaling = scaling;
+	}
+	virtual const btVector3& getLocalScaling() const
+	{
+		return m_localScaling;
+	}
+
+	virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const;
+
+	virtual const char* getName() const
+	{
+		return "Empty";
+	}
+
+	virtual void processAllTriangles(btTriangleCallback*, const btVector3&, const btVector3&) const
+	{
+	}
+
+protected:
+	btVector3 m_localScaling;
+};
+
+#endif  //BT_EMPTY_SHAPE_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h
new file mode 100644
index 00000000..2cf3c007
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h
@@ -0,0 +1,221 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_HEIGHTFIELD_TERRAIN_SHAPE_H
+#define BT_HEIGHTFIELD_TERRAIN_SHAPE_H
+
+#include "btConcaveShape.h"
+#include "LinearMath/btAlignedObjectArray.h"
+
+///btHeightfieldTerrainShape simulates a 2D heightfield terrain
+/**
+  The caller is responsible for maintaining the heightfield array; this
+  class does not make a copy.
+
+  The heightfield can be dynamic so long as the min/max height values
+  capture the extremes (heights must always be in that range).
+
+  The local origin of the heightfield is assumed to be the exact
+  center (as determined by width and length and height, with each
+  axis multiplied by the localScaling).
+
+  \b NOTE: be careful with coordinates.  If you have a heightfield with a local
+  min height of -100m, and a max height of +500m, you may be tempted to place it
+  at the origin (0,0) and expect the heights in world coordinates to be
+  -100 to +500 meters.
+  Actually, the heights will be -300 to +300m, because bullet will re-center
+  the heightfield based on its AABB (which is determined by the min/max
+  heights).  So keep in mind that once you create a btHeightfieldTerrainShape
+  object, the heights will be adjusted relative to the center of the AABB.  This
+  is different to the behavior of many rendering engines, but is useful for
+  physics engines.
+
+  Most (but not all) rendering and heightfield libraries assume upAxis = 1
+  (that is, the y-axis is "up").  This class allows any of the 3 coordinates
+  to be "up".  Make sure your choice of axis is consistent with your rendering
+  system.
+
+  The heightfield heights are determined from the data type used for the
+  heightfieldData array.  
+
+   - PHY_UCHAR: height at a point is the uchar value at the
+       grid point, multipled by heightScale.  uchar isn't recommended
+       because of its inability to deal with negative values, and
+       low resolution (8-bit).
+
+   - PHY_SHORT: height at a point is the short int value at that grid
+       point, multipled by heightScale.
+
+   - PHY_FLOAT: height at a point is the float value at that grid
+       point.  heightScale is ignored when using the float heightfield
+       data type.
+
+  Whatever the caller specifies as minHeight and maxHeight will be honored.
+  The class will not inspect the heightfield to discover the actual minimum
+  or maximum heights.  These values are used to determine the heightfield's
+  axis-aligned bounding box, multiplied by localScaling.
+
+  For usage and testing see the TerrainDemo.
+ */
+ATTRIBUTE_ALIGNED16(class)
+btHeightfieldTerrainShape : public btConcaveShape
+{
+public:
+	struct Range
+	{
+		btScalar min;
+		btScalar max;
+	};
+
+protected:
+	btVector3 m_localAabbMin;
+	btVector3 m_localAabbMax;
+	btVector3 m_localOrigin;
+
+	///terrain data
+	int m_heightStickWidth;
+	int m_heightStickLength;
+	btScalar m_minHeight;
+	btScalar m_maxHeight;
+	btScalar m_width;
+	btScalar m_length;
+	btScalar m_heightScale;
+	union {
+		const unsigned char* m_heightfieldDataUnsignedChar;
+		const short* m_heightfieldDataShort;
+		const btScalar* m_heightfieldDataFloat;
+		const void* m_heightfieldDataUnknown;
+	};
+
+	PHY_ScalarType m_heightDataType;
+	bool m_flipQuadEdges;
+	bool m_useDiamondSubdivision;
+	bool m_useZigzagSubdivision;
+	bool m_flipTriangleWinding;
+	int m_upAxis;
+
+	btVector3 m_localScaling;
+
+	// Accelerator
+	btAlignedObjectArray<Range> m_vboundsGrid;
+	int m_vboundsGridWidth;
+	int m_vboundsGridLength;
+	int m_vboundsChunkSize;
+
+	
+	btScalar m_userValue3;
+
+	struct btTriangleInfoMap* m_triangleInfoMap;
+
+	virtual btScalar getRawHeightFieldValue(int x, int y) const;
+	void quantizeWithClamp(int* out, const btVector3& point, int isMax) const;
+
+	/// protected initialization
+	/**
+	  Handles the work of constructors so that public constructors can be
+	  backwards-compatible without a lot of copy/paste.
+	 */
+	void initialize(int heightStickWidth, int heightStickLength,
+					const void* heightfieldData, btScalar heightScale,
+					btScalar minHeight, btScalar maxHeight, int upAxis,
+					PHY_ScalarType heightDataType, bool flipQuadEdges);
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	/// preferred constructor
+	/**
+	  This constructor supports a range of heightfield
+	  data types, and allows for a non-zero minimum height value.
+	  heightScale is needed for any integer-based heightfield data types.
+	 */
+	btHeightfieldTerrainShape(int heightStickWidth, int heightStickLength,
+							  const void* heightfieldData, btScalar heightScale,
+							  btScalar minHeight, btScalar maxHeight,
+							  int upAxis, PHY_ScalarType heightDataType,
+							  bool flipQuadEdges);
+
+	/// legacy constructor
+	/**
+	  The legacy constructor assumes the heightfield has a minimum height
+	  of zero.  Only unsigned char or floats are supported.  For legacy
+	  compatibility reasons, heightScale is calculated as maxHeight / 65535 
+	  (and is only used when useFloatData = false).
+ 	 */
+	btHeightfieldTerrainShape(int heightStickWidth, int heightStickLength, const void* heightfieldData, btScalar maxHeight, int upAxis, bool useFloatData, bool flipQuadEdges);
+
+	virtual ~btHeightfieldTerrainShape();
+
+	void setUseDiamondSubdivision(bool useDiamondSubdivision = true) { m_useDiamondSubdivision = useDiamondSubdivision; }
+
+	///could help compatibility with Ogre heightfields. See https://code.google.com/p/bullet/issues/detail?id=625
+	void setUseZigzagSubdivision(bool useZigzagSubdivision = true) { m_useZigzagSubdivision = useZigzagSubdivision; }
+
+	void setFlipTriangleWinding(bool flipTriangleWinding)
+	{
+		m_flipTriangleWinding = flipTriangleWinding;
+	}
+	virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const;
+
+	virtual void processAllTriangles(btTriangleCallback * callback, const btVector3& aabbMin, const btVector3& aabbMax) const;
+
+	virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const;
+
+	virtual void setLocalScaling(const btVector3& scaling);
+
+	virtual const btVector3& getLocalScaling() const;
+
+	void getVertex(int x, int y, btVector3& vertex) const;
+
+	void performRaycast(btTriangleCallback * callback, const btVector3& raySource, const btVector3& rayTarget) const;
+
+	void buildAccelerator(int chunkSize = 16);
+	void clearAccelerator();
+
+	int getUpAxis() const
+	{
+		return m_upAxis;
+	}
+	//debugging
+	virtual const char* getName() const { return "HEIGHTFIELD"; }
+
+	
+	void setUserValue3(btScalar value)
+	{
+		m_userValue3 = value;
+	}
+	btScalar getUserValue3() const
+	{
+		return m_userValue3;
+	}
+	const struct btTriangleInfoMap* getTriangleInfoMap() const
+	{
+		return m_triangleInfoMap;
+	}
+	struct btTriangleInfoMap* getTriangleInfoMap()
+	{
+		return m_triangleInfoMap;
+	}
+	void setTriangleInfoMap(btTriangleInfoMap* map)
+	{
+		m_triangleInfoMap = map;
+	}
+	const unsigned char* getHeightfieldRawData() const
+	{
+		return m_heightfieldDataUnsignedChar;
+	}
+};
+
+#endif  //BT_HEIGHTFIELD_TERRAIN_SHAPE_H
\ No newline at end of file
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btMaterial.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btMaterial.h
new file mode 100644
index 00000000..c9a436bf
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btMaterial.h
@@ -0,0 +1,38 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+/// This file was created by Alex Silverman
+
+#ifndef BT_MATERIAL_H
+#define BT_MATERIAL_H
+
+// Material class to be used by btMultimaterialTriangleMeshShape to store triangle properties
+class btMaterial
+{
+	// public members so that materials can change due to world events
+public:
+	btScalar m_friction;
+	btScalar m_restitution;
+	int pad[2];
+
+	btMaterial() {}
+	btMaterial(btScalar fric, btScalar rest)
+	{
+		m_friction = fric;
+		m_restitution = rest;
+	}
+};
+
+#endif  // BT_MATERIAL_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btMiniSDF.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btMiniSDF.h
new file mode 100644
index 00000000..b60fd102
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btMiniSDF.h
@@ -0,0 +1,127 @@
+#ifndef MINISDF_H
+#define MINISDF_H
+
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btAabbUtil2.h"
+#include "LinearMath/btAlignedObjectArray.h"
+
+struct btMultiIndex
+{
+	unsigned int ijk[3];
+};
+
+struct btAlignedBox3d
+{
+	btVector3 m_min;
+	btVector3 m_max;
+
+	const btVector3& min() const
+	{
+		return m_min;
+	}
+
+	const btVector3& max() const
+	{
+		return m_max;
+	}
+
+	bool contains(const btVector3& x) const
+	{
+		return TestPointAgainstAabb2(m_min, m_max, x);
+	}
+
+	btAlignedBox3d(const btVector3& mn, const btVector3& mx)
+		: m_min(mn),
+		  m_max(mx)
+	{
+	}
+
+	btAlignedBox3d()
+	{
+	}
+};
+
+struct btShapeMatrix
+{
+	double m_vec[32];
+
+	inline double& operator[](int i)
+	{
+		return m_vec[i];
+	}
+
+	inline const double& operator[](int i) const
+	{
+		return m_vec[i];
+	}
+};
+
+struct btShapeGradients
+{
+	btVector3 m_vec[32];
+
+	void topRowsDivide(int row, double denom)
+	{
+		for (int i = 0; i < row; i++)
+		{
+			m_vec[i] /= denom;
+		}
+	}
+
+	void bottomRowsMul(int row, double val)
+	{
+		for (int i = 32 - row; i < 32; i++)
+		{
+			m_vec[i] *= val;
+		}
+	}
+
+	inline btScalar& operator()(int i, int j)
+	{
+		return m_vec[i][j];
+	}
+};
+
+struct btCell32
+{
+	unsigned int m_cells[32];
+};
+
+struct btMiniSDF
+{
+	btAlignedBox3d m_domain;
+	unsigned int m_resolution[3];
+	btVector3 m_cell_size;
+	btVector3 m_inv_cell_size;
+	std::size_t m_n_cells;
+	std::size_t m_n_fields;
+	bool m_isValid;
+
+	btAlignedObjectArray<btAlignedObjectArray<double> > m_nodes;
+	btAlignedObjectArray<btAlignedObjectArray<btCell32> > m_cells;
+	btAlignedObjectArray<btAlignedObjectArray<unsigned int> > m_cell_map;
+
+	btMiniSDF()
+		: m_isValid(false)
+	{
+	}
+	bool load(const char* data, int size);
+	bool isValid() const
+	{
+		return m_isValid;
+	}
+	unsigned int multiToSingleIndex(btMultiIndex const& ijk) const;
+
+	btAlignedBox3d subdomain(btMultiIndex const& ijk) const;
+
+	btMultiIndex singleToMultiIndex(unsigned int l) const;
+
+	btAlignedBox3d subdomain(unsigned int l) const;
+
+	btShapeMatrix
+	shape_function_(btVector3 const& xi, btShapeGradients* gradient = 0) const;
+
+	bool interpolate(unsigned int field_id, double& dist, btVector3 const& x, btVector3* gradient) const;
+};
+
+#endif  //MINISDF_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btMinkowskiSumShape.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btMinkowskiSumShape.h
new file mode 100644
index 00000000..3b5150f6
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btMinkowskiSumShape.h
@@ -0,0 +1,59 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_MINKOWSKI_SUM_SHAPE_H
+#define BT_MINKOWSKI_SUM_SHAPE_H
+
+#include "btConvexInternalShape.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"  // for the types
+
+/// The btMinkowskiSumShape is only for advanced users. This shape represents implicit based minkowski sum of two convex implicit shapes.
+ATTRIBUTE_ALIGNED16(class)
+btMinkowskiSumShape : public btConvexInternalShape
+{
+	btTransform m_transA;
+	btTransform m_transB;
+	const btConvexShape* m_shapeA;
+	const btConvexShape* m_shapeB;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btMinkowskiSumShape(const btConvexShape* shapeA, const btConvexShape* shapeB);
+
+	virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const;
+
+	virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const;
+
+	virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const;
+
+	void setTransformA(const btTransform& transA) { m_transA = transA; }
+	void setTransformB(const btTransform& transB) { m_transB = transB; }
+
+	const btTransform& getTransformA() const { return m_transA; }
+	const btTransform& GetTransformB() const { return m_transB; }
+
+	virtual btScalar getMargin() const;
+
+	const btConvexShape* getShapeA() const { return m_shapeA; }
+	const btConvexShape* getShapeB() const { return m_shapeB; }
+
+	virtual const char* getName() const
+	{
+		return "MinkowskiSum";
+	}
+};
+
+#endif  //BT_MINKOWSKI_SUM_SHAPE_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btMultiSphereShape.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btMultiSphereShape.h
new file mode 100644
index 00000000..2d79c07c
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btMultiSphereShape.h
@@ -0,0 +1,95 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_MULTI_SPHERE_MINKOWSKI_H
+#define BT_MULTI_SPHERE_MINKOWSKI_H
+
+#include "btConvexInternalShape.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"  // for the types
+#include "LinearMath/btAlignedObjectArray.h"
+#include "LinearMath/btAabbUtil2.h"
+
+///The btMultiSphereShape represents the convex hull of a collection of spheres. You can create special capsules or other smooth volumes.
+///It is possible to animate the spheres for deformation, but call 'recalcLocalAabb' after changing any sphere position/radius
+ATTRIBUTE_ALIGNED16(class)
+btMultiSphereShape : public btConvexInternalAabbCachingShape
+{
+	btAlignedObjectArray<btVector3> m_localPositionArray;
+	btAlignedObjectArray<btScalar> m_radiArray;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btMultiSphereShape(const btVector3* positions, const btScalar* radi, int numSpheres);
+
+	///CollisionShape Interface
+	virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const;
+
+	/// btConvexShape Interface
+	virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const;
+
+	virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const;
+
+	int getSphereCount() const
+	{
+		return m_localPositionArray.size();
+	}
+
+	const btVector3& getSpherePosition(int index) const
+	{
+		return m_localPositionArray[index];
+	}
+
+	btScalar getSphereRadius(int index) const
+	{
+		return m_radiArray[index];
+	}
+
+	virtual const char* getName() const
+	{
+		return "MultiSphere";
+	}
+
+	virtual int calculateSerializeBufferSize() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
+};
+
+struct btPositionAndRadius
+{
+	btVector3FloatData m_pos;
+	float m_radius;
+};
+
+// clang-format off
+
+struct	btMultiSphereShapeData
+{
+	btConvexInternalShapeData	m_convexInternalShapeData;
+
+	btPositionAndRadius	*m_localPositionArrayPtr;
+	int				m_localPositionArraySize;
+	char	m_padding[4];
+};
+
+// clang-format on
+
+SIMD_FORCE_INLINE int btMultiSphereShape::calculateSerializeBufferSize() const
+{
+	return sizeof(btMultiSphereShapeData);
+}
+
+#endif  //BT_MULTI_SPHERE_MINKOWSKI_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btMultimaterialTriangleMeshShape.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btMultimaterialTriangleMeshShape.h
new file mode 100644
index 00000000..d1d42f8e
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btMultimaterialTriangleMeshShape.h
@@ -0,0 +1,115 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+/// This file was created by Alex Silverman
+
+#ifndef BT_BVH_TRIANGLE_MATERIAL_MESH_SHAPE_H
+#define BT_BVH_TRIANGLE_MATERIAL_MESH_SHAPE_H
+
+#include "btBvhTriangleMeshShape.h"
+#include "btMaterial.h"
+
+///The BvhTriangleMaterialMeshShape extends the btBvhTriangleMeshShape. Its main contribution is the interface into a material array, which allows per-triangle friction and restitution.
+ATTRIBUTE_ALIGNED16(class)
+btMultimaterialTriangleMeshShape : public btBvhTriangleMeshShape
+{
+	btAlignedObjectArray<btMaterial *> m_materialList;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btMultimaterialTriangleMeshShape(btStridingMeshInterface * meshInterface, bool useQuantizedAabbCompression, bool buildBvh = true) : btBvhTriangleMeshShape(meshInterface, useQuantizedAabbCompression, buildBvh)
+	{
+		m_shapeType = MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE;
+
+		const unsigned char *vertexbase;
+		int numverts;
+		PHY_ScalarType type;
+		int stride;
+		const unsigned char *indexbase;
+		int indexstride;
+		int numfaces;
+		PHY_ScalarType indicestype;
+
+		//m_materialLookup = (int**)(btAlignedAlloc(sizeof(int*) * meshInterface->getNumSubParts(), 16));
+
+		for (int i = 0; i < meshInterface->getNumSubParts(); i++)
+		{
+			m_meshInterface->getLockedReadOnlyVertexIndexBase(
+				&vertexbase,
+				numverts,
+				type,
+				stride,
+				&indexbase,
+				indexstride,
+				numfaces,
+				indicestype,
+				i);
+			//m_materialLookup[i] = (int*)(btAlignedAlloc(sizeof(int) * numfaces, 16));
+		}
+	}
+
+	///optionally pass in a larger bvh aabb, used for quantization. This allows for deformations within this aabb
+	btMultimaterialTriangleMeshShape(btStridingMeshInterface * meshInterface, bool useQuantizedAabbCompression, const btVector3 &bvhAabbMin, const btVector3 &bvhAabbMax, bool buildBvh = true) : btBvhTriangleMeshShape(meshInterface, useQuantizedAabbCompression, bvhAabbMin, bvhAabbMax, buildBvh)
+	{
+		m_shapeType = MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE;
+
+		const unsigned char *vertexbase;
+		int numverts;
+		PHY_ScalarType type;
+		int stride;
+		const unsigned char *indexbase;
+		int indexstride;
+		int numfaces;
+		PHY_ScalarType indicestype;
+
+		//m_materialLookup = (int**)(btAlignedAlloc(sizeof(int*) * meshInterface->getNumSubParts(), 16));
+
+		for (int i = 0; i < meshInterface->getNumSubParts(); i++)
+		{
+			m_meshInterface->getLockedReadOnlyVertexIndexBase(
+				&vertexbase,
+				numverts,
+				type,
+				stride,
+				&indexbase,
+				indexstride,
+				numfaces,
+				indicestype,
+				i);
+			//m_materialLookup[i] = (int*)(btAlignedAlloc(sizeof(int) * numfaces * 2, 16));
+		}
+	}
+
+	virtual ~btMultimaterialTriangleMeshShape()
+	{
+		/*
+        for(int i = 0; i < m_meshInterface->getNumSubParts(); i++)
+        {
+            btAlignedFree(m_materialValues[i]);
+            m_materialLookup[i] = NULL;
+        }
+        btAlignedFree(m_materialValues);
+        m_materialLookup = NULL;
+*/
+	}
+	//debugging
+	virtual const char *getName() const { return "MULTIMATERIALTRIANGLEMESH"; }
+
+	///Obtains the material for a specific triangle
+	const btMaterial *getMaterialProperties(int partID, int triIndex);
+};
+
+#endif  //BT_BVH_TRIANGLE_MATERIAL_MESH_SHAPE_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btOptimizedBvh.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btOptimizedBvh.h
new file mode 100644
index 00000000..22f131c8
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btOptimizedBvh.h
@@ -0,0 +1,56 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+///Contains contributions from Disney Studio's
+
+#ifndef BT_OPTIMIZED_BVH_H
+#define BT_OPTIMIZED_BVH_H
+
+#include "BulletCollision/BroadphaseCollision/btQuantizedBvh.h"
+
+class btStridingMeshInterface;
+
+///The btOptimizedBvh extends the btQuantizedBvh to create AABB tree for triangle meshes, through the btStridingMeshInterface.
+ATTRIBUTE_ALIGNED16(class)
+btOptimizedBvh : public btQuantizedBvh
+{
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+protected:
+public:
+	btOptimizedBvh();
+
+	virtual ~btOptimizedBvh();
+
+	void build(btStridingMeshInterface * triangles, bool useQuantizedAabbCompression, const btVector3& bvhAabbMin, const btVector3& bvhAabbMax);
+
+	void refit(btStridingMeshInterface * triangles, const btVector3& aabbMin, const btVector3& aabbMax);
+
+	void refitPartial(btStridingMeshInterface * triangles, const btVector3& aabbMin, const btVector3& aabbMax);
+
+	void updateBvhNodes(btStridingMeshInterface * meshInterface, int firstNode, int endNode, int index);
+
+	/// Data buffer MUST be 16 byte aligned
+	virtual bool serializeInPlace(void* o_alignedDataBuffer, unsigned i_dataBufferSize, bool i_swapEndian) const
+	{
+		return btQuantizedBvh::serialize(o_alignedDataBuffer, i_dataBufferSize, i_swapEndian);
+	}
+
+	///deSerializeInPlace loads and initializes a BVH from a buffer in memory 'in place'
+	static btOptimizedBvh* deSerializeInPlace(void* i_alignedDataBuffer, unsigned int i_dataBufferSize, bool i_swapEndian);
+};
+
+#endif  //BT_OPTIMIZED_BVH_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btPolyhedralConvexShape.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btPolyhedralConvexShape.h
new file mode 100644
index 00000000..b3ffab7a
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btPolyhedralConvexShape.h
@@ -0,0 +1,106 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_POLYHEDRAL_CONVEX_SHAPE_H
+#define BT_POLYHEDRAL_CONVEX_SHAPE_H
+
+#include "LinearMath/btMatrix3x3.h"
+#include "btConvexInternalShape.h"
+class btConvexPolyhedron;
+
+///The btPolyhedralConvexShape is an internal interface class for polyhedral convex shapes.
+ATTRIBUTE_ALIGNED16(class)
+btPolyhedralConvexShape : public btConvexInternalShape
+{
+protected:
+	btConvexPolyhedron* m_polyhedron;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btPolyhedralConvexShape();
+
+	virtual ~btPolyhedralConvexShape();
+
+	///optional method mainly used to generate multiple contact points by clipping polyhedral features (faces/edges)
+	///experimental/work-in-progress
+	virtual bool initializePolyhedralFeatures(int shiftVerticesByMargin = 0);
+
+	virtual void setPolyhedralFeatures(btConvexPolyhedron & polyhedron);
+
+	const btConvexPolyhedron* getConvexPolyhedron() const
+	{
+		return m_polyhedron;
+	}
+
+	//brute force implementations
+
+	virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const;
+	virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const;
+
+	virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const;
+
+	virtual int getNumVertices() const = 0;
+	virtual int getNumEdges() const = 0;
+	virtual void getEdge(int i, btVector3& pa, btVector3& pb) const = 0;
+	virtual void getVertex(int i, btVector3& vtx) const = 0;
+	virtual int getNumPlanes() const = 0;
+	virtual void getPlane(btVector3 & planeNormal, btVector3 & planeSupport, int i) const = 0;
+	//	virtual int getIndex(int i) const = 0 ;
+
+	virtual bool isInside(const btVector3& pt, btScalar tolerance) const = 0;
+};
+
+///The btPolyhedralConvexAabbCachingShape adds aabb caching to the btPolyhedralConvexShape
+class btPolyhedralConvexAabbCachingShape : public btPolyhedralConvexShape
+{
+	btVector3 m_localAabbMin;
+	btVector3 m_localAabbMax;
+	bool m_isLocalAabbValid;
+
+protected:
+	void setCachedLocalAabb(const btVector3& aabbMin, const btVector3& aabbMax)
+	{
+		m_isLocalAabbValid = true;
+		m_localAabbMin = aabbMin;
+		m_localAabbMax = aabbMax;
+	}
+
+	inline void getCachedLocalAabb(btVector3& aabbMin, btVector3& aabbMax) const
+	{
+		btAssert(m_isLocalAabbValid);
+		aabbMin = m_localAabbMin;
+		aabbMax = m_localAabbMax;
+	}
+
+protected:
+	btPolyhedralConvexAabbCachingShape();
+
+public:
+	inline void getNonvirtualAabb(const btTransform& trans, btVector3& aabbMin, btVector3& aabbMax, btScalar margin) const
+	{
+		//lazy evaluation of local aabb
+		btAssert(m_isLocalAabbValid);
+		btTransformAabb(m_localAabbMin, m_localAabbMax, margin, trans, aabbMin, aabbMax);
+	}
+
+	virtual void setLocalScaling(const btVector3& scaling);
+
+	virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const;
+
+	void recalcLocalAabb();
+};
+
+#endif  //BT_POLYHEDRAL_CONVEX_SHAPE_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h
new file mode 100644
index 00000000..4d6feb61
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h
@@ -0,0 +1,86 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SCALED_BVH_TRIANGLE_MESH_SHAPE_H
+#define BT_SCALED_BVH_TRIANGLE_MESH_SHAPE_H
+
+#include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h"
+
+///The btScaledBvhTriangleMeshShape allows to instance a scaled version of an existing btBvhTriangleMeshShape.
+///Note that each btBvhTriangleMeshShape still can have its own local scaling, independent from this btScaledBvhTriangleMeshShape 'localScaling'
+ATTRIBUTE_ALIGNED16(class)
+btScaledBvhTriangleMeshShape : public btConcaveShape
+{
+	btVector3 m_localScaling;
+
+	btBvhTriangleMeshShape* m_bvhTriMeshShape;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btScaledBvhTriangleMeshShape(btBvhTriangleMeshShape * childShape, const btVector3& localScaling);
+
+	virtual ~btScaledBvhTriangleMeshShape();
+
+	virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const;
+	virtual void setLocalScaling(const btVector3& scaling);
+	virtual const btVector3& getLocalScaling() const;
+	virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const;
+
+	virtual void processAllTriangles(btTriangleCallback * callback, const btVector3& aabbMin, const btVector3& aabbMax) const;
+
+	btBvhTriangleMeshShape* getChildShape()
+	{
+		return m_bvhTriMeshShape;
+	}
+
+	const btBvhTriangleMeshShape* getChildShape() const
+	{
+		return m_bvhTriMeshShape;
+	}
+
+	//debugging
+	virtual const char* getName() const { return "SCALEDBVHTRIANGLEMESH"; }
+
+	virtual int calculateSerializeBufferSize() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
+};
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct btScaledTriangleMeshShapeData
+{
+	btTriangleMeshShapeData m_trimeshShapeData;
+
+	btVector3FloatData m_localScaling;
+};
+
+SIMD_FORCE_INLINE int btScaledBvhTriangleMeshShape::calculateSerializeBufferSize() const
+{
+	return sizeof(btScaledTriangleMeshShapeData);
+}
+
+///fills the dataBuffer and returns the struct name (and 0 on failure)
+SIMD_FORCE_INLINE const char* btScaledBvhTriangleMeshShape::serialize(void* dataBuffer, btSerializer* serializer) const
+{
+	btScaledTriangleMeshShapeData* scaledMeshData = (btScaledTriangleMeshShapeData*)dataBuffer;
+	m_bvhTriMeshShape->serialize(&scaledMeshData->m_trimeshShapeData, serializer);
+	scaledMeshData->m_trimeshShapeData.m_collisionShapeData.m_shapeType = SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE;
+	m_localScaling.serializeFloat(scaledMeshData->m_localScaling);
+	return "btScaledTriangleMeshShapeData";
+}
+
+#endif  //BT_SCALED_BVH_TRIANGLE_MESH_SHAPE_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btSdfCollisionShape.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btSdfCollisionShape.h
new file mode 100644
index 00000000..3989d624
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btSdfCollisionShape.h
@@ -0,0 +1,29 @@
+#ifndef BT_SDF_COLLISION_SHAPE_H
+#define BT_SDF_COLLISION_SHAPE_H
+
+#include "btConcaveShape.h"
+
+class btSdfCollisionShape : public btConcaveShape
+{
+	struct btSdfCollisionShapeInternalData* m_data;
+
+public:
+	btSdfCollisionShape();
+	virtual ~btSdfCollisionShape();
+
+	bool initializeSDF(const char* sdfData, int sizeInBytes);
+
+	virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const;
+	virtual void setLocalScaling(const btVector3& scaling);
+	virtual const btVector3& getLocalScaling() const;
+	virtual void calculateLocalInertia(btScalar mass, btVector3& inertia) const;
+	virtual const char* getName() const;
+	virtual void setMargin(btScalar margin);
+	virtual btScalar getMargin() const;
+
+	virtual void processAllTriangles(btTriangleCallback* callback, const btVector3& aabbMin, const btVector3& aabbMax) const;
+
+	bool queryPoint(const btVector3& ptInSDF, btScalar& distOut, btVector3& normal);
+};
+
+#endif  //BT_SDF_COLLISION_SHAPE_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btShapeHull.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btShapeHull.h
new file mode 100644
index 00000000..54439f9c
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btShapeHull.h
@@ -0,0 +1,60 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+///btShapeHull implemented by John McCutchan.
+
+#ifndef BT_SHAPE_HULL_H
+#define BT_SHAPE_HULL_H
+
+#include "LinearMath/btAlignedObjectArray.h"
+#include "BulletCollision/CollisionShapes/btConvexShape.h"
+
+///The btShapeHull class takes a btConvexShape, builds a simplified convex hull using btConvexHull and provides triangle indices and vertices.
+///It can be useful for to simplify a complex convex object and for visualization of a non-polyhedral convex object.
+///It approximates the convex hull using the supporting vertex of 42 directions.
+ATTRIBUTE_ALIGNED16(class)
+btShapeHull
+{
+protected:
+	btAlignedObjectArray<btVector3> m_vertices;
+	btAlignedObjectArray<unsigned int> m_indices;
+	unsigned int m_numIndices;
+	const btConvexShape* m_shape;
+
+	static btVector3* getUnitSpherePoints(int highres = 0);
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btShapeHull(const btConvexShape* shape);
+	~btShapeHull();
+
+	bool buildHull(btScalar margin, int highres = 0);
+
+	int numTriangles() const;
+	int numVertices() const;
+	int numIndices() const;
+
+	const btVector3* getVertexPointer() const
+	{
+		return &m_vertices[0];
+	}
+	const unsigned int* getIndexPointer() const
+	{
+		return &m_indices[0];
+	}
+};
+
+#endif  //BT_SHAPE_HULL_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btSphereShape.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btSphereShape.h
new file mode 100644
index 00000000..75e4fd8e
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btSphereShape.h
@@ -0,0 +1,71 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef BT_SPHERE_MINKOWSKI_H
+#define BT_SPHERE_MINKOWSKI_H
+
+#include "btConvexInternalShape.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"  // for the types
+
+///The btSphereShape implements an implicit sphere, centered around a local origin with radius.
+ATTRIBUTE_ALIGNED16(class)
+btSphereShape : public btConvexInternalShape
+
+{
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btSphereShape(btScalar radius) : btConvexInternalShape()
+	{
+		m_shapeType = SPHERE_SHAPE_PROXYTYPE;
+		m_localScaling.setValue(1.0, 1.0, 1.0);
+		m_implicitShapeDimensions.setZero();
+		m_implicitShapeDimensions.setX(radius);
+		m_collisionMargin = radius;
+		m_padding = 0;
+	}
+
+	virtual btVector3 localGetSupportingVertex(const btVector3& vec) const;
+	virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const;
+	//notice that the vectors should be unit length
+	virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const;
+
+	virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const;
+
+	virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const;
+
+	btScalar getRadius() const { return m_implicitShapeDimensions.getX() * m_localScaling.getX(); }
+
+	void setUnscaledRadius(btScalar radius)
+	{
+		m_implicitShapeDimensions.setX(radius);
+		btConvexInternalShape::setMargin(radius);
+	}
+
+	//debugging
+	virtual const char* getName() const { return "SPHERE"; }
+
+	virtual void setMargin(btScalar margin)
+	{
+		btConvexInternalShape::setMargin(margin);
+	}
+	virtual btScalar getMargin() const
+	{
+		//to improve gjk behaviour, use radius+margin as the full margin, so never get into the penetration case
+		//this means, non-uniform scaling is not supported anymore
+		return getRadius();
+	}
+};
+
+#endif  //BT_SPHERE_MINKOWSKI_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btStaticPlaneShape.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btStaticPlaneShape.h
new file mode 100644
index 00000000..1cda8bbc
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btStaticPlaneShape.h
@@ -0,0 +1,103 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_STATIC_PLANE_SHAPE_H
+#define BT_STATIC_PLANE_SHAPE_H
+
+#include "btConcaveShape.h"
+
+///The btStaticPlaneShape simulates an infinite non-moving (static) collision plane.
+ATTRIBUTE_ALIGNED16(class)
+btStaticPlaneShape : public btConcaveShape
+{
+protected:
+	btVector3 m_localAabbMin;
+	btVector3 m_localAabbMax;
+
+	btVector3 m_planeNormal;
+	btScalar m_planeConstant;
+	btVector3 m_localScaling;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btStaticPlaneShape(const btVector3& planeNormal, btScalar planeConstant);
+
+	virtual ~btStaticPlaneShape();
+
+	virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const;
+
+	virtual void processAllTriangles(btTriangleCallback * callback, const btVector3& aabbMin, const btVector3& aabbMax) const;
+
+	virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const;
+
+	virtual void setLocalScaling(const btVector3& scaling);
+	virtual const btVector3& getLocalScaling() const;
+
+	const btVector3& getPlaneNormal() const
+	{
+		return m_planeNormal;
+	}
+
+	const btScalar& getPlaneConstant() const
+	{
+		return m_planeConstant;
+	}
+
+	//debugging
+	virtual const char* getName() const { return "STATICPLANE"; }
+
+	virtual int calculateSerializeBufferSize() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
+};
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct btStaticPlaneShapeData
+{
+	btCollisionShapeData m_collisionShapeData;
+
+	btVector3FloatData m_localScaling;
+	btVector3FloatData m_planeNormal;
+	float m_planeConstant;
+	char m_pad[4];
+};
+
+SIMD_FORCE_INLINE int btStaticPlaneShape::calculateSerializeBufferSize() const
+{
+	return sizeof(btStaticPlaneShapeData);
+}
+
+///fills the dataBuffer and returns the struct name (and 0 on failure)
+SIMD_FORCE_INLINE const char* btStaticPlaneShape::serialize(void* dataBuffer, btSerializer* serializer) const
+{
+	btStaticPlaneShapeData* planeData = (btStaticPlaneShapeData*)dataBuffer;
+	btCollisionShape::serialize(&planeData->m_collisionShapeData, serializer);
+
+	m_localScaling.serializeFloat(planeData->m_localScaling);
+	m_planeNormal.serializeFloat(planeData->m_planeNormal);
+	planeData->m_planeConstant = float(m_planeConstant);
+
+	// Fill padding with zeros to appease msan.
+	planeData->m_pad[0] = 0;
+	planeData->m_pad[1] = 0;
+	planeData->m_pad[2] = 0;
+	planeData->m_pad[3] = 0;
+
+	return "btStaticPlaneShapeData";
+}
+
+#endif  //BT_STATIC_PLANE_SHAPE_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btStridingMeshInterface.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btStridingMeshInterface.h
new file mode 100644
index 00000000..68a41dfb
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btStridingMeshInterface.h
@@ -0,0 +1,153 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_STRIDING_MESHINTERFACE_H
+#define BT_STRIDING_MESHINTERFACE_H
+
+#include "LinearMath/btVector3.h"
+#include "btTriangleCallback.h"
+#include "btConcaveShape.h"
+
+///	The btStridingMeshInterface is the interface class for high performance generic access to triangle meshes, used in combination with btBvhTriangleMeshShape and some other collision shapes.
+/// Using index striding of 3*sizeof(integer) it can use triangle arrays, using index striding of 1*sizeof(integer) it can handle triangle strips.
+/// It allows for sharing graphics and collision meshes. Also it provides locking/unlocking of graphics meshes that are in gpu memory.
+ATTRIBUTE_ALIGNED16(class)
+btStridingMeshInterface
+{
+protected:
+	btVector3 m_scaling;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btStridingMeshInterface() : m_scaling(btScalar(1.), btScalar(1.), btScalar(1.))
+	{
+	}
+
+	virtual ~btStridingMeshInterface();
+
+	virtual void InternalProcessAllTriangles(btInternalTriangleIndexCallback * callback, const btVector3& aabbMin, const btVector3& aabbMax) const;
+
+	///brute force method to calculate aabb
+	void calculateAabbBruteForce(btVector3 & aabbMin, btVector3 & aabbMax);
+
+	/// get read and write access to a subpart of a triangle mesh
+	/// this subpart has a continuous array of vertices and indices
+	/// in this way the mesh can be handled as chunks of memory with striding
+	/// very similar to OpenGL vertexarray support
+	/// make a call to unLockVertexBase when the read and write access is finished
+	virtual void getLockedVertexIndexBase(unsigned char** vertexbase, int& numverts, PHY_ScalarType& type, int& stride, unsigned char** indexbase, int& indexstride, int& numfaces, PHY_ScalarType& indicestype, int subpart = 0) = 0;
+
+	virtual void getLockedReadOnlyVertexIndexBase(const unsigned char** vertexbase, int& numverts, PHY_ScalarType& type, int& stride, const unsigned char** indexbase, int& indexstride, int& numfaces, PHY_ScalarType& indicestype, int subpart = 0) const = 0;
+
+	/// unLockVertexBase finishes the access to a subpart of the triangle mesh
+	/// make a call to unLockVertexBase when the read and write access (using getLockedVertexIndexBase) is finished
+	virtual void unLockVertexBase(int subpart) = 0;
+
+	virtual void unLockReadOnlyVertexBase(int subpart) const = 0;
+
+	/// getNumSubParts returns the number of separate subparts
+	/// each subpart has a continuous array of vertices and indices
+	virtual int getNumSubParts() const = 0;
+
+	virtual void preallocateVertices(int numverts) = 0;
+	virtual void preallocateIndices(int numindices) = 0;
+
+	virtual bool hasPremadeAabb() const { return false; }
+	virtual void setPremadeAabb(const btVector3& aabbMin, const btVector3& aabbMax) const
+	{
+		(void)aabbMin;
+		(void)aabbMax;
+	}
+	virtual void getPremadeAabb(btVector3 * aabbMin, btVector3 * aabbMax) const
+	{
+		(void)aabbMin;
+		(void)aabbMax;
+	}
+
+	const btVector3& getScaling() const
+	{
+		return m_scaling;
+	}
+	void setScaling(const btVector3& scaling)
+	{
+		m_scaling = scaling;
+	}
+
+	virtual int calculateSerializeBufferSize() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
+};
+
+struct btIntIndexData
+{
+	int m_value;
+};
+
+struct btShortIntIndexData
+{
+	short m_value;
+	char m_pad[2];
+};
+
+struct btShortIntIndexTripletData
+{
+	short m_values[3];
+	char m_pad[2];
+};
+
+struct btCharIndexTripletData
+{
+	unsigned char m_values[3];
+	char m_pad;
+};
+
+// clang-format off
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct	btMeshPartData
+{
+	btVector3FloatData			*m_vertices3f;
+	btVector3DoubleData			*m_vertices3d;
+
+	btIntIndexData				*m_indices32;
+	btShortIntIndexTripletData	*m_3indices16;
+	btCharIndexTripletData		*m_3indices8;
+
+	btShortIntIndexData			*m_indices16;//backwards compatibility
+
+	int                     m_numTriangles;//length of m_indices = m_numTriangles
+	int                     m_numVertices;
+};
+
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct	btStridingMeshInterfaceData
+{
+	btMeshPartData	*m_meshPartsPtr;
+	btVector3FloatData	m_scaling;
+	int	m_numMeshParts;
+	char m_padding[4];
+};
+
+// clang-format on
+
+SIMD_FORCE_INLINE int btStridingMeshInterface::calculateSerializeBufferSize() const
+{
+	return sizeof(btStridingMeshInterfaceData);
+}
+
+#endif  //BT_STRIDING_MESHINTERFACE_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btTetrahedronShape.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btTetrahedronShape.h
new file mode 100644
index 00000000..f5e2209e
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btTetrahedronShape.h
@@ -0,0 +1,71 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SIMPLEX_1TO4_SHAPE
+#define BT_SIMPLEX_1TO4_SHAPE
+
+#include "btPolyhedralConvexShape.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+
+///The btBU_Simplex1to4 implements tetrahedron, triangle, line, vertex collision shapes. In most cases it is better to use btConvexHullShape instead.
+ATTRIBUTE_ALIGNED16(class)
+btBU_Simplex1to4 : public btPolyhedralConvexAabbCachingShape
+{
+protected:
+	int m_numVertices;
+	btVector3 m_vertices[4];
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btBU_Simplex1to4();
+
+	btBU_Simplex1to4(const btVector3& pt0);
+	btBU_Simplex1to4(const btVector3& pt0, const btVector3& pt1);
+	btBU_Simplex1to4(const btVector3& pt0, const btVector3& pt1, const btVector3& pt2);
+	btBU_Simplex1to4(const btVector3& pt0, const btVector3& pt1, const btVector3& pt2, const btVector3& pt3);
+
+	void reset()
+	{
+		m_numVertices = 0;
+	}
+
+	virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const;
+
+	void addVertex(const btVector3& pt);
+
+	//PolyhedralConvexShape interface
+
+	virtual int getNumVertices() const;
+
+	virtual int getNumEdges() const;
+
+	virtual void getEdge(int i, btVector3& pa, btVector3& pb) const;
+
+	virtual void getVertex(int i, btVector3& vtx) const;
+
+	virtual int getNumPlanes() const;
+
+	virtual void getPlane(btVector3 & planeNormal, btVector3 & planeSupport, int i) const;
+
+	virtual int getIndex(int i) const;
+
+	virtual bool isInside(const btVector3& pt, btScalar tolerance) const;
+
+	///getName is for debugging
+	virtual const char* getName() const { return "btBU_Simplex1to4"; }
+};
+
+#endif  //BT_SIMPLEX_1TO4_SHAPE
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btTriangleBuffer.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btTriangleBuffer.h
new file mode 100644
index 00000000..a89b9cd8
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btTriangleBuffer.h
@@ -0,0 +1,63 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_TRIANGLE_BUFFER_H
+#define BT_TRIANGLE_BUFFER_H
+
+#include "btTriangleCallback.h"
+#include "LinearMath/btAlignedObjectArray.h"
+
+struct btTriangle
+{
+	btVector3 m_vertex0;
+	btVector3 m_vertex1;
+	btVector3 m_vertex2;
+	int m_partId;
+	int m_triangleIndex;
+};
+
+///The btTriangleBuffer callback can be useful to collect and store overlapping triangles between AABB and concave objects that support 'processAllTriangles'
+///Example usage of this class:
+///			btTriangleBuffer	triBuf;
+///			concaveShape->processAllTriangles(&triBuf,aabbMin, aabbMax);
+///			for (int i=0;i<triBuf.getNumTriangles();i++)
+///			{
+///				const btTriangle& tri = triBuf.getTriangle(i);
+///				//do something useful here with the triangle
+///			}
+class btTriangleBuffer : public btTriangleCallback
+{
+	btAlignedObjectArray<btTriangle> m_triangleBuffer;
+
+public:
+	virtual void processTriangle(btVector3* triangle, int partId, int triangleIndex);
+
+	int getNumTriangles() const
+	{
+		return int(m_triangleBuffer.size());
+	}
+
+	const btTriangle& getTriangle(int index) const
+	{
+		return m_triangleBuffer[index];
+	}
+
+	void clearBuffer()
+	{
+		m_triangleBuffer.clear();
+	}
+};
+
+#endif  //BT_TRIANGLE_BUFFER_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btTriangleCallback.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btTriangleCallback.h
new file mode 100644
index 00000000..d3644891
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btTriangleCallback.h
@@ -0,0 +1,37 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_TRIANGLE_CALLBACK_H
+#define BT_TRIANGLE_CALLBACK_H
+
+#include "LinearMath/btVector3.h"
+
+///The btTriangleCallback provides a callback for each overlapping triangle when calling processAllTriangles.
+///This callback is called by processAllTriangles for all btConcaveShape derived class, such as  btBvhTriangleMeshShape, btStaticPlaneShape and btHeightfieldTerrainShape.
+class btTriangleCallback
+{
+public:
+	virtual ~btTriangleCallback();
+	virtual void processTriangle(btVector3* triangle, int partId, int triangleIndex) = 0;
+};
+
+class btInternalTriangleIndexCallback
+{
+public:
+	virtual ~btInternalTriangleIndexCallback();
+	virtual void internalProcessTriangleIndex(btVector3* triangle, int partId, int triangleIndex) = 0;
+};
+
+#endif  //BT_TRIANGLE_CALLBACK_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h
new file mode 100644
index 00000000..556aa3fe
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h
@@ -0,0 +1,128 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_TRIANGLE_INDEX_VERTEX_ARRAY_H
+#define BT_TRIANGLE_INDEX_VERTEX_ARRAY_H
+
+#include "btStridingMeshInterface.h"
+#include "LinearMath/btAlignedObjectArray.h"
+#include "LinearMath/btScalar.h"
+
+///The btIndexedMesh indexes a single vertex and index array. Multiple btIndexedMesh objects can be passed into a btTriangleIndexVertexArray using addIndexedMesh.
+///Instead of the number of indices, we pass the number of triangles.
+ATTRIBUTE_ALIGNED16(struct)
+btIndexedMesh
+{
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	int m_numTriangles;
+	const unsigned char* m_triangleIndexBase;
+	// Size in byte of the indices for one triangle (3*sizeof(index_type) if the indices are tightly packed)
+	int m_triangleIndexStride;
+	int m_numVertices;
+	const unsigned char* m_vertexBase;
+	// Size of a vertex, in bytes
+	int m_vertexStride;
+
+	// The index type is set when adding an indexed mesh to the
+	// btTriangleIndexVertexArray, do not set it manually
+	PHY_ScalarType m_indexType;
+
+	// The vertex type has a default type similar to Bullet's precision mode (float or double)
+	// but can be set manually if you for example run Bullet with double precision but have
+	// mesh data in single precision..
+	PHY_ScalarType m_vertexType;
+
+	btIndexedMesh()
+		: m_indexType(PHY_INTEGER),
+#ifdef BT_USE_DOUBLE_PRECISION
+		  m_vertexType(PHY_DOUBLE)
+#else   // BT_USE_DOUBLE_PRECISION
+		  m_vertexType(PHY_FLOAT)
+#endif  // BT_USE_DOUBLE_PRECISION
+	{
+	}
+};
+
+typedef btAlignedObjectArray<btIndexedMesh> IndexedMeshArray;
+
+///The btTriangleIndexVertexArray allows to access multiple triangle meshes, by indexing into existing triangle/index arrays.
+///Additional meshes can be added using addIndexedMesh
+///No duplicate is made of the vertex/index data, it only indexes into external vertex/index arrays.
+///So keep those arrays around during the lifetime of this btTriangleIndexVertexArray.
+ATTRIBUTE_ALIGNED16(class)
+btTriangleIndexVertexArray : public btStridingMeshInterface
+{
+protected:
+	IndexedMeshArray m_indexedMeshes;
+	int m_pad[2];
+	mutable int m_hasAabb;  // using int instead of bool to maintain alignment
+	mutable btVector3 m_aabbMin;
+	mutable btVector3 m_aabbMax;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btTriangleIndexVertexArray() : m_hasAabb(0)
+	{
+	}
+
+	virtual ~btTriangleIndexVertexArray();
+
+	//just to be backwards compatible
+	btTriangleIndexVertexArray(int numTriangles, int* triangleIndexBase, int triangleIndexStride, int numVertices, btScalar* vertexBase, int vertexStride);
+
+	void addIndexedMesh(const btIndexedMesh& mesh, PHY_ScalarType indexType = PHY_INTEGER)
+	{
+		m_indexedMeshes.push_back(mesh);
+		m_indexedMeshes[m_indexedMeshes.size() - 1].m_indexType = indexType;
+	}
+
+	virtual void getLockedVertexIndexBase(unsigned char** vertexbase, int& numverts, PHY_ScalarType& type, int& vertexStride, unsigned char** indexbase, int& indexstride, int& numfaces, PHY_ScalarType& indicestype, int subpart = 0);
+
+	virtual void getLockedReadOnlyVertexIndexBase(const unsigned char** vertexbase, int& numverts, PHY_ScalarType& type, int& vertexStride, const unsigned char** indexbase, int& indexstride, int& numfaces, PHY_ScalarType& indicestype, int subpart = 0) const;
+
+	/// unLockVertexBase finishes the access to a subpart of the triangle mesh
+	/// make a call to unLockVertexBase when the read and write access (using getLockedVertexIndexBase) is finished
+	virtual void unLockVertexBase(int subpart) { (void)subpart; }
+
+	virtual void unLockReadOnlyVertexBase(int subpart) const { (void)subpart; }
+
+	/// getNumSubParts returns the number of separate subparts
+	/// each subpart has a continuous array of vertices and indices
+	virtual int getNumSubParts() const
+	{
+		return (int)m_indexedMeshes.size();
+	}
+
+	IndexedMeshArray& getIndexedMeshArray()
+	{
+		return m_indexedMeshes;
+	}
+
+	const IndexedMeshArray& getIndexedMeshArray() const
+	{
+		return m_indexedMeshes;
+	}
+
+	virtual void preallocateVertices(int numverts) { (void)numverts; }
+	virtual void preallocateIndices(int numindices) { (void)numindices; }
+
+	virtual bool hasPremadeAabb() const;
+	virtual void setPremadeAabb(const btVector3& aabbMin, const btVector3& aabbMax) const;
+	virtual void getPremadeAabb(btVector3 * aabbMin, btVector3 * aabbMax) const;
+};
+
+#endif  //BT_TRIANGLE_INDEX_VERTEX_ARRAY_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btTriangleIndexVertexMaterialArray.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btTriangleIndexVertexMaterialArray.h
new file mode 100644
index 00000000..315b1e21
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btTriangleIndexVertexMaterialArray.h
@@ -0,0 +1,83 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+///This file was created by Alex Silverman
+
+#ifndef BT_MULTIMATERIAL_TRIANGLE_INDEX_VERTEX_ARRAY_H
+#define BT_MULTIMATERIAL_TRIANGLE_INDEX_VERTEX_ARRAY_H
+
+#include "btTriangleIndexVertexArray.h"
+
+ATTRIBUTE_ALIGNED16(struct)
+btMaterialProperties
+{
+	///m_materialBase ==========> 2 btScalar values make up one material, friction then restitution
+	int m_numMaterials;
+	const unsigned char* m_materialBase;
+	int m_materialStride;
+	PHY_ScalarType m_materialType;
+	///m_numTriangles <=========== This exists in the btIndexedMesh object for the same subpart, but since we're
+	///                           padding the structure, it can be reproduced at no real cost
+	///m_triangleMaterials =====> 1 integer value makes up one entry
+	///                           eg: m_triangleMaterials[1] = 5; // This will set triangle 2 to use material 5
+	int m_numTriangles;
+	const unsigned char* m_triangleMaterialsBase;
+	int m_triangleMaterialStride;
+	///m_triangleType <========== Automatically set in addMaterialProperties
+	PHY_ScalarType m_triangleType;
+};
+
+typedef btAlignedObjectArray<btMaterialProperties> MaterialArray;
+
+///Teh btTriangleIndexVertexMaterialArray is built on TriangleIndexVertexArray
+///The addition of a material array allows for the utilization of the partID and
+///triangleIndex that are returned in the ContactAddedCallback.  As with
+///TriangleIndexVertexArray, no duplicate is made of the material data, so it
+///is the users responsibility to maintain the array during the lifetime of the
+///TriangleIndexVertexMaterialArray.
+ATTRIBUTE_ALIGNED16(class)
+btTriangleIndexVertexMaterialArray : public btTriangleIndexVertexArray
+{
+protected:
+	MaterialArray m_materials;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btTriangleIndexVertexMaterialArray()
+	{
+	}
+
+	btTriangleIndexVertexMaterialArray(int numTriangles, int* triangleIndexBase, int triangleIndexStride,
+									   int numVertices, btScalar* vertexBase, int vertexStride,
+									   int numMaterials, unsigned char* materialBase, int materialStride,
+									   int* triangleMaterialsBase, int materialIndexStride);
+
+	virtual ~btTriangleIndexVertexMaterialArray() {}
+
+	void addMaterialProperties(const btMaterialProperties& mat, PHY_ScalarType triangleType = PHY_INTEGER)
+	{
+		m_materials.push_back(mat);
+		m_materials[m_materials.size() - 1].m_triangleType = triangleType;
+	}
+
+	virtual void getLockedMaterialBase(unsigned char** materialBase, int& numMaterials, PHY_ScalarType& materialType, int& materialStride,
+									   unsigned char** triangleMaterialBase, int& numTriangles, int& triangleMaterialStride, PHY_ScalarType& triangleType, int subpart = 0);
+
+	virtual void getLockedReadOnlyMaterialBase(const unsigned char** materialBase, int& numMaterials, PHY_ScalarType& materialType, int& materialStride,
+											   const unsigned char** triangleMaterialBase, int& numTriangles, int& triangleMaterialStride, PHY_ScalarType& triangleType, int subpart = 0);
+};
+
+#endif  //BT_MULTIMATERIAL_TRIANGLE_INDEX_VERTEX_ARRAY_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btTriangleInfoMap.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btTriangleInfoMap.h
new file mode 100644
index 00000000..8ee35ef5
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btTriangleInfoMap.h
@@ -0,0 +1,238 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2010 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef _BT_TRIANGLE_INFO_MAP_H
+#define _BT_TRIANGLE_INFO_MAP_H
+
+#include "LinearMath/btHashMap.h"
+#include "LinearMath/btSerializer.h"
+
+///for btTriangleInfo m_flags
+#define TRI_INFO_V0V1_CONVEX 1
+#define TRI_INFO_V1V2_CONVEX 2
+#define TRI_INFO_V2V0_CONVEX 4
+
+#define TRI_INFO_V0V1_SWAP_NORMALB 8
+#define TRI_INFO_V1V2_SWAP_NORMALB 16
+#define TRI_INFO_V2V0_SWAP_NORMALB 32
+
+///The btTriangleInfo structure stores information to adjust collision normals to avoid collisions against internal edges
+///it can be generated using
+struct btTriangleInfo
+{
+	btTriangleInfo()
+	{
+		m_edgeV0V1Angle = SIMD_2_PI;
+		m_edgeV1V2Angle = SIMD_2_PI;
+		m_edgeV2V0Angle = SIMD_2_PI;
+		m_flags = 0;
+	}
+
+	int m_flags;
+
+	btScalar m_edgeV0V1Angle;
+	btScalar m_edgeV1V2Angle;
+	btScalar m_edgeV2V0Angle;
+};
+
+typedef btHashMap<btHashInt, btTriangleInfo> btInternalTriangleInfoMap;
+
+///The btTriangleInfoMap stores edge angle information for some triangles. You can compute this information yourself or using btGenerateInternalEdgeInfo.
+struct btTriangleInfoMap : public btInternalTriangleInfoMap
+{
+	btScalar m_convexEpsilon;          ///used to determine if an edge or contact normal is convex, using the dot product
+	btScalar m_planarEpsilon;          ///used to determine if a triangle edge is planar with zero angle
+	btScalar m_equalVertexThreshold;   ///used to compute connectivity: if the distance between two vertices is smaller than m_equalVertexThreshold, they are considered to be 'shared'
+	btScalar m_edgeDistanceThreshold;  ///used to determine edge contacts: if the closest distance between a contact point and an edge is smaller than this distance threshold it is considered to "hit the edge"
+	btScalar m_maxEdgeAngleThreshold;  //ignore edges that connect triangles at an angle larger than this m_maxEdgeAngleThreshold
+	btScalar m_zeroAreaThreshold;      ///used to determine if a triangle is degenerate (length squared of cross product of 2 triangle edges < threshold)
+
+	btTriangleInfoMap()
+	{
+		m_convexEpsilon = 0.00f;
+		m_planarEpsilon = 0.0001f;
+		m_equalVertexThreshold = btScalar(0.0001) * btScalar(0.0001);
+		m_edgeDistanceThreshold = btScalar(0.1);
+		m_zeroAreaThreshold = btScalar(0.0001) * btScalar(0.0001);
+		m_maxEdgeAngleThreshold = SIMD_2_PI;
+	}
+	virtual ~btTriangleInfoMap() {}
+
+	virtual int calculateSerializeBufferSize() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
+
+	void deSerialize(struct btTriangleInfoMapData& data);
+};
+
+// clang-format off
+
+///those fields have to be float and not btScalar for the serialization to work properly
+struct	btTriangleInfoData
+{
+	int			m_flags;
+	float	m_edgeV0V1Angle;
+	float	m_edgeV1V2Angle;
+	float	m_edgeV2V0Angle;
+};
+
+struct	btTriangleInfoMapData
+{
+	int					*m_hashTablePtr;
+	int					*m_nextPtr;
+	btTriangleInfoData	*m_valueArrayPtr;
+	int					*m_keyArrayPtr;
+
+	float	m_convexEpsilon;
+	float	m_planarEpsilon;
+	float	m_equalVertexThreshold; 
+	float	m_edgeDistanceThreshold;
+	float	m_zeroAreaThreshold;
+
+	int		m_nextSize;
+	int		m_hashTableSize;
+	int		m_numValues;
+	int		m_numKeys;
+	char	m_padding[4];
+};
+
+// clang-format on
+
+SIMD_FORCE_INLINE int btTriangleInfoMap::calculateSerializeBufferSize() const
+{
+	return sizeof(btTriangleInfoMapData);
+}
+
+///fills the dataBuffer and returns the struct name (and 0 on failure)
+SIMD_FORCE_INLINE const char* btTriangleInfoMap::serialize(void* dataBuffer, btSerializer* serializer) const
+{
+	btTriangleInfoMapData* tmapData = (btTriangleInfoMapData*)dataBuffer;
+	tmapData->m_convexEpsilon = (float)m_convexEpsilon;
+	tmapData->m_planarEpsilon = (float)m_planarEpsilon;
+	tmapData->m_equalVertexThreshold = (float)m_equalVertexThreshold;
+	tmapData->m_edgeDistanceThreshold = (float)m_edgeDistanceThreshold;
+	tmapData->m_zeroAreaThreshold = (float)m_zeroAreaThreshold;
+
+	tmapData->m_hashTableSize = m_hashTable.size();
+
+	tmapData->m_hashTablePtr = tmapData->m_hashTableSize ? (int*)serializer->getUniquePointer((void*)&m_hashTable[0]) : 0;
+	if (tmapData->m_hashTablePtr)
+	{
+		//serialize an int buffer
+		int sz = sizeof(int);
+		int numElem = tmapData->m_hashTableSize;
+		btChunk* chunk = serializer->allocate(sz, numElem);
+		int* memPtr = (int*)chunk->m_oldPtr;
+		for (int i = 0; i < numElem; i++, memPtr++)
+		{
+			*memPtr = m_hashTable[i];
+		}
+		serializer->finalizeChunk(chunk, "int", BT_ARRAY_CODE, (void*)&m_hashTable[0]);
+	}
+
+	tmapData->m_nextSize = m_next.size();
+	tmapData->m_nextPtr = tmapData->m_nextSize ? (int*)serializer->getUniquePointer((void*)&m_next[0]) : 0;
+	if (tmapData->m_nextPtr)
+	{
+		int sz = sizeof(int);
+		int numElem = tmapData->m_nextSize;
+		btChunk* chunk = serializer->allocate(sz, numElem);
+		int* memPtr = (int*)chunk->m_oldPtr;
+		for (int i = 0; i < numElem; i++, memPtr++)
+		{
+			*memPtr = m_next[i];
+		}
+		serializer->finalizeChunk(chunk, "int", BT_ARRAY_CODE, (void*)&m_next[0]);
+	}
+
+	tmapData->m_numValues = m_valueArray.size();
+	tmapData->m_valueArrayPtr = tmapData->m_numValues ? (btTriangleInfoData*)serializer->getUniquePointer((void*)&m_valueArray[0]) : 0;
+	if (tmapData->m_valueArrayPtr)
+	{
+		int sz = sizeof(btTriangleInfoData);
+		int numElem = tmapData->m_numValues;
+		btChunk* chunk = serializer->allocate(sz, numElem);
+		btTriangleInfoData* memPtr = (btTriangleInfoData*)chunk->m_oldPtr;
+		for (int i = 0; i < numElem; i++, memPtr++)
+		{
+			memPtr->m_edgeV0V1Angle = (float)m_valueArray[i].m_edgeV0V1Angle;
+			memPtr->m_edgeV1V2Angle = (float)m_valueArray[i].m_edgeV1V2Angle;
+			memPtr->m_edgeV2V0Angle = (float)m_valueArray[i].m_edgeV2V0Angle;
+			memPtr->m_flags = m_valueArray[i].m_flags;
+		}
+		serializer->finalizeChunk(chunk, "btTriangleInfoData", BT_ARRAY_CODE, (void*)&m_valueArray[0]);
+	}
+
+	tmapData->m_numKeys = m_keyArray.size();
+	tmapData->m_keyArrayPtr = tmapData->m_numKeys ? (int*)serializer->getUniquePointer((void*)&m_keyArray[0]) : 0;
+	if (tmapData->m_keyArrayPtr)
+	{
+		int sz = sizeof(int);
+		int numElem = tmapData->m_numValues;
+		btChunk* chunk = serializer->allocate(sz, numElem);
+		int* memPtr = (int*)chunk->m_oldPtr;
+		for (int i = 0; i < numElem; i++, memPtr++)
+		{
+			*memPtr = m_keyArray[i].getUid1();
+		}
+		serializer->finalizeChunk(chunk, "int", BT_ARRAY_CODE, (void*)&m_keyArray[0]);
+	}
+
+	// Fill padding with zeros to appease msan.
+	tmapData->m_padding[0] = 0;
+	tmapData->m_padding[1] = 0;
+	tmapData->m_padding[2] = 0;
+	tmapData->m_padding[3] = 0;
+
+	return "btTriangleInfoMapData";
+}
+
+///fills the dataBuffer and returns the struct name (and 0 on failure)
+SIMD_FORCE_INLINE void btTriangleInfoMap::deSerialize(btTriangleInfoMapData& tmapData)
+{
+	m_convexEpsilon = tmapData.m_convexEpsilon;
+	m_planarEpsilon = tmapData.m_planarEpsilon;
+	m_equalVertexThreshold = tmapData.m_equalVertexThreshold;
+	m_edgeDistanceThreshold = tmapData.m_edgeDistanceThreshold;
+	m_zeroAreaThreshold = tmapData.m_zeroAreaThreshold;
+	m_hashTable.resize(tmapData.m_hashTableSize);
+	int i = 0;
+	for (i = 0; i < tmapData.m_hashTableSize; i++)
+	{
+		m_hashTable[i] = tmapData.m_hashTablePtr[i];
+	}
+	m_next.resize(tmapData.m_nextSize);
+	for (i = 0; i < tmapData.m_nextSize; i++)
+	{
+		m_next[i] = tmapData.m_nextPtr[i];
+	}
+	m_valueArray.resize(tmapData.m_numValues);
+	for (i = 0; i < tmapData.m_numValues; i++)
+	{
+		m_valueArray[i].m_edgeV0V1Angle = tmapData.m_valueArrayPtr[i].m_edgeV0V1Angle;
+		m_valueArray[i].m_edgeV1V2Angle = tmapData.m_valueArrayPtr[i].m_edgeV1V2Angle;
+		m_valueArray[i].m_edgeV2V0Angle = tmapData.m_valueArrayPtr[i].m_edgeV2V0Angle;
+		m_valueArray[i].m_flags = tmapData.m_valueArrayPtr[i].m_flags;
+	}
+
+	m_keyArray.resize(tmapData.m_numKeys, btHashInt(0));
+	for (i = 0; i < tmapData.m_numKeys; i++)
+	{
+		m_keyArray[i].setUid1(tmapData.m_keyArrayPtr[i]);
+	}
+}
+
+#endif  //_BT_TRIANGLE_INFO_MAP_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btTriangleMesh.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btTriangleMesh.h
new file mode 100644
index 00000000..a8a36235
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btTriangleMesh.h
@@ -0,0 +1,69 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_TRIANGLE_MESH_H
+#define BT_TRIANGLE_MESH_H
+
+#include "btTriangleIndexVertexArray.h"
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btAlignedObjectArray.h"
+
+///The btTriangleMesh class is a convenience class derived from btTriangleIndexVertexArray, that provides storage for a concave triangle mesh. It can be used as data for the btBvhTriangleMeshShape.
+///It allows either 32bit or 16bit indices, and 4 (x-y-z-w) or 3 (x-y-z) component vertices.
+///If you want to share triangle/index data between graphics mesh and collision mesh (btBvhTriangleMeshShape), you can directly use btTriangleIndexVertexArray or derive your own class from btStridingMeshInterface.
+///Performance of btTriangleMesh and btTriangleIndexVertexArray used in a btBvhTriangleMeshShape is the same.
+class btTriangleMesh : public btTriangleIndexVertexArray
+{
+	btAlignedObjectArray<btVector3> m_4componentVertices;
+	btAlignedObjectArray<btScalar> m_3componentVertices;
+
+	btAlignedObjectArray<unsigned int> m_32bitIndices;
+	btAlignedObjectArray<unsigned short int> m_16bitIndices;
+	bool m_use32bitIndices;
+	bool m_use4componentVertices;
+
+public:
+	btScalar m_weldingThreshold;
+
+	btTriangleMesh(bool use32bitIndices = true, bool use4componentVertices = true);
+
+	bool getUse32bitIndices() const
+	{
+		return m_use32bitIndices;
+	}
+
+	bool getUse4componentVertices() const
+	{
+		return m_use4componentVertices;
+	}
+	///By default addTriangle won't search for duplicate vertices, because the search is very slow for large triangle meshes.
+	///In general it is better to directly use btTriangleIndexVertexArray instead.
+	void addTriangle(const btVector3& vertex0, const btVector3& vertex1, const btVector3& vertex2, bool removeDuplicateVertices = false);
+
+	///Add a triangle using its indices. Make sure the indices are pointing within the vertices array, so add the vertices first (and to be sure, avoid removal of duplicate vertices)
+	void addTriangleIndices(int index1, int index2, int index3);
+
+	int getNumTriangles() const;
+
+	virtual void preallocateVertices(int numverts);
+	virtual void preallocateIndices(int numindices);
+
+	///findOrAddVertex is an internal method, use addTriangle instead
+	int findOrAddVertex(const btVector3& vertex, bool removeDuplicateVertices);
+	///addIndex is an internal method, use addTriangle instead
+	void addIndex(int index);
+};
+
+#endif  //BT_TRIANGLE_MESH_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btTriangleMeshShape.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btTriangleMeshShape.h
new file mode 100644
index 00000000..4a70e283
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btTriangleMeshShape.h
@@ -0,0 +1,82 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_TRIANGLE_MESH_SHAPE_H
+#define BT_TRIANGLE_MESH_SHAPE_H
+
+#include "btConcaveShape.h"
+#include "btStridingMeshInterface.h"
+
+///The btTriangleMeshShape is an internal concave triangle mesh interface. Don't use this class directly, use btBvhTriangleMeshShape instead.
+ATTRIBUTE_ALIGNED16(class)
+btTriangleMeshShape : public btConcaveShape
+{
+protected:
+	btVector3 m_localAabbMin;
+	btVector3 m_localAabbMax;
+	btStridingMeshInterface* m_meshInterface;
+
+	///btTriangleMeshShape constructor has been disabled/protected, so that users will not mistakenly use this class.
+	///Don't use btTriangleMeshShape but use btBvhTriangleMeshShape instead!
+	btTriangleMeshShape(btStridingMeshInterface * meshInterface);
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	virtual ~btTriangleMeshShape();
+
+	virtual btVector3 localGetSupportingVertex(const btVector3& vec) const;
+
+	virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const
+	{
+		btAssert(0);
+		return localGetSupportingVertex(vec);
+	}
+
+	void recalcLocalAabb();
+
+	virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const;
+
+	virtual void processAllTriangles(btTriangleCallback * callback, const btVector3& aabbMin, const btVector3& aabbMax) const;
+
+	virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const;
+
+	virtual void setLocalScaling(const btVector3& scaling);
+	virtual const btVector3& getLocalScaling() const;
+
+	btStridingMeshInterface* getMeshInterface()
+	{
+		return m_meshInterface;
+	}
+
+	const btStridingMeshInterface* getMeshInterface() const
+	{
+		return m_meshInterface;
+	}
+
+	const btVector3& getLocalAabbMin() const
+	{
+		return m_localAabbMin;
+	}
+	const btVector3& getLocalAabbMax() const
+	{
+		return m_localAabbMax;
+	}
+
+	//debugging
+	virtual const char* getName() const { return "TRIANGLEMESH"; }
+};
+
+#endif  //BT_TRIANGLE_MESH_SHAPE_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btTriangleShape.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btTriangleShape.h
new file mode 100644
index 00000000..190cbdae
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btTriangleShape.h
@@ -0,0 +1,175 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_OBB_TRIANGLE_MINKOWSKI_H
+#define BT_OBB_TRIANGLE_MINKOWSKI_H
+
+#include "btConvexShape.h"
+#include "btBoxShape.h"
+
+ATTRIBUTE_ALIGNED16(class)
+btTriangleShape : public btPolyhedralConvexShape
+{
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btVector3 m_vertices1[3];
+
+	virtual int getNumVertices() const
+	{
+		return 3;
+	}
+
+	btVector3& getVertexPtr(int index)
+	{
+		return m_vertices1[index];
+	}
+
+	const btVector3& getVertexPtr(int index) const
+	{
+		return m_vertices1[index];
+	}
+	virtual void getVertex(int index, btVector3& vert) const
+	{
+		vert = m_vertices1[index];
+	}
+
+	virtual int getNumEdges() const
+	{
+		return 3;
+	}
+
+	virtual void getEdge(int i, btVector3& pa, btVector3& pb) const
+	{
+		getVertex(i, pa);
+		getVertex((i + 1) % 3, pb);
+	}
+
+	virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const
+	{
+		//		btAssert(0);
+		getAabbSlow(t, aabbMin, aabbMax);
+	}
+
+	btVector3 localGetSupportingVertexWithoutMargin(const btVector3& dir) const
+	{
+		btVector3 dots = dir.dot3(m_vertices1[0], m_vertices1[1], m_vertices1[2]);
+		return m_vertices1[dots.maxAxis()];
+	}
+
+	virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const
+	{
+		for (int i = 0; i < numVectors; i++)
+		{
+			const btVector3& dir = vectors[i];
+			btVector3 dots = dir.dot3(m_vertices1[0], m_vertices1[1], m_vertices1[2]);
+			supportVerticesOut[i] = m_vertices1[dots.maxAxis()];
+		}
+	}
+
+	btTriangleShape() : btPolyhedralConvexShape()
+	{
+		m_shapeType = TRIANGLE_SHAPE_PROXYTYPE;
+	}
+
+	btTriangleShape(const btVector3& p0, const btVector3& p1, const btVector3& p2) : btPolyhedralConvexShape()
+	{
+		m_shapeType = TRIANGLE_SHAPE_PROXYTYPE;
+		m_vertices1[0] = p0;
+		m_vertices1[1] = p1;
+		m_vertices1[2] = p2;
+	}
+
+	virtual void getPlane(btVector3 & planeNormal, btVector3 & planeSupport, int i) const
+	{
+		getPlaneEquation(i, planeNormal, planeSupport);
+	}
+
+	virtual int getNumPlanes() const
+	{
+		return 1;
+	}
+
+	void calcNormal(btVector3 & normal) const
+	{
+		normal = (m_vertices1[1] - m_vertices1[0]).cross(m_vertices1[2] - m_vertices1[0]);
+		normal.normalize();
+	}
+
+	virtual void getPlaneEquation(int i, btVector3& planeNormal, btVector3& planeSupport) const
+	{
+		(void)i;
+		calcNormal(planeNormal);
+		planeSupport = m_vertices1[0];
+	}
+
+	virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const
+	{
+		(void)mass;
+		btAssert(0);
+		inertia.setValue(btScalar(0.), btScalar(0.), btScalar(0.));
+	}
+
+	virtual bool isInside(const btVector3& pt, btScalar tolerance) const
+	{
+		btVector3 normal;
+		calcNormal(normal);
+		//distance to plane
+		btScalar dist = pt.dot(normal);
+		btScalar planeconst = m_vertices1[0].dot(normal);
+		dist -= planeconst;
+		if (dist >= -tolerance && dist <= tolerance)
+		{
+			//inside check on edge-planes
+			int i;
+			for (i = 0; i < 3; i++)
+			{
+				btVector3 pa, pb;
+				getEdge(i, pa, pb);
+				btVector3 edge = pb - pa;
+				btVector3 edgeNormal = edge.cross(normal);
+				edgeNormal.normalize();
+				btScalar dist = pt.dot(edgeNormal);
+				btScalar edgeConst = pa.dot(edgeNormal);
+				dist -= edgeConst;
+				if (dist < -tolerance)
+					return false;
+			}
+
+			return true;
+		}
+
+		return false;
+	}
+	//debugging
+	virtual const char* getName() const
+	{
+		return "Triangle";
+	}
+
+	virtual int getNumPreferredPenetrationDirections() const
+	{
+		return 2;
+	}
+
+	virtual void getPreferredPenetrationDirection(int index, btVector3& penetrationVector) const
+	{
+		calcNormal(penetrationVector);
+		if (index)
+			penetrationVector *= btScalar(-1.);
+	}
+};
+
+#endif  //BT_OBB_TRIANGLE_MINKOWSKI_H
diff --git a/engine/inc/bullet/BulletCollision/CollisionShapes/btUniformScalingShape.h b/engine/inc/bullet/BulletCollision/CollisionShapes/btUniformScalingShape.h
new file mode 100644
index 00000000..4dfe34ef
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/CollisionShapes/btUniformScalingShape.h
@@ -0,0 +1,84 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_UNIFORM_SCALING_SHAPE_H
+#define BT_UNIFORM_SCALING_SHAPE_H
+
+#include "btConvexShape.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"  // for the types
+
+///The btUniformScalingShape allows to re-use uniform scaled instances of btConvexShape in a memory efficient way.
+///Istead of using btUniformScalingShape, it is better to use the non-uniform setLocalScaling method on convex shapes that implement it.
+ATTRIBUTE_ALIGNED16(class)
+btUniformScalingShape : public btConvexShape
+{
+	btConvexShape* m_childConvexShape;
+
+	btScalar m_uniformScalingFactor;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btUniformScalingShape(btConvexShape * convexChildShape, btScalar uniformScalingFactor);
+
+	virtual ~btUniformScalingShape();
+
+	virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const;
+
+	virtual btVector3 localGetSupportingVertex(const btVector3& vec) const;
+
+	virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const;
+
+	virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const;
+
+	btScalar getUniformScalingFactor() const
+	{
+		return m_uniformScalingFactor;
+	}
+
+	btConvexShape* getChildShape()
+	{
+		return m_childConvexShape;
+	}
+
+	const btConvexShape* getChildShape() const
+	{
+		return m_childConvexShape;
+	}
+
+	virtual const char* getName() const
+	{
+		return "UniformScalingShape";
+	}
+
+	///////////////////////////
+
+	///getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version
+	void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const;
+
+	virtual void getAabbSlow(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const;
+
+	virtual void setLocalScaling(const btVector3& scaling);
+	virtual const btVector3& getLocalScaling() const;
+
+	virtual void setMargin(btScalar margin);
+	virtual btScalar getMargin() const;
+
+	virtual int getNumPreferredPenetrationDirections() const;
+
+	virtual void getPreferredPenetrationDirection(int index, btVector3& penetrationVector) const;
+};
+
+#endif  //BT_UNIFORM_SCALING_SHAPE_H
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/btBoxCollision.h b/engine/inc/bullet/BulletCollision/Gimpact/btBoxCollision.h
new file mode 100644
index 00000000..182835c3
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/btBoxCollision.h
@@ -0,0 +1,620 @@
+#ifndef BT_BOX_COLLISION_H_INCLUDED
+#define BT_BOX_COLLISION_H_INCLUDED
+
+/*! \file gim_box_collision.h
+\author Francisco Leon Najera
+*/
+/*
+This source file is part of GIMPACT Library.
+
+For the latest info, see http://gimpact.sourceforge.net/
+
+Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371.
+email: projectileman@yahoo.com
+
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "LinearMath/btTransform.h"
+
+///Swap numbers
+#define BT_SWAP_NUMBERS(a, b) \
+	{                         \
+		a = a + b;            \
+		b = a - b;            \
+		a = a - b;            \
+	}
+
+#define BT_MAX(a, b) (a < b ? b : a)
+#define BT_MIN(a, b) (a > b ? b : a)
+
+#define BT_GREATER(x, y) btFabs(x) > (y)
+
+#define BT_MAX3(a, b, c) BT_MAX(a, BT_MAX(b, c))
+#define BT_MIN3(a, b, c) BT_MIN(a, BT_MIN(b, c))
+
+enum eBT_PLANE_INTERSECTION_TYPE
+{
+	BT_CONST_BACK_PLANE = 0,
+	BT_CONST_COLLIDE_PLANE,
+	BT_CONST_FRONT_PLANE
+};
+
+//SIMD_FORCE_INLINE bool test_cross_edge_box(
+//	const btVector3 & edge,
+//	const btVector3 & absolute_edge,
+//	const btVector3 & pointa,
+//	const btVector3 & pointb, const btVector3 & extend,
+//	int dir_index0,
+//	int dir_index1
+//	int component_index0,
+//	int component_index1)
+//{
+//	// dir coords are -z and y
+//
+//	const btScalar dir0 = -edge[dir_index0];
+//	const btScalar dir1 = edge[dir_index1];
+//	btScalar pmin = pointa[component_index0]*dir0 + pointa[component_index1]*dir1;
+//	btScalar pmax = pointb[component_index0]*dir0 + pointb[component_index1]*dir1;
+//	//find minmax
+//	if(pmin>pmax)
+//	{
+//		BT_SWAP_NUMBERS(pmin,pmax);
+//	}
+//	//find extends
+//	const btScalar rad = extend[component_index0] * absolute_edge[dir_index0] +
+//					extend[component_index1] * absolute_edge[dir_index1];
+//
+//	if(pmin>rad || -rad>pmax) return false;
+//	return true;
+//}
+//
+//SIMD_FORCE_INLINE bool test_cross_edge_box_X_axis(
+//	const btVector3 & edge,
+//	const btVector3 & absolute_edge,
+//	const btVector3 & pointa,
+//	const btVector3 & pointb, btVector3 & extend)
+//{
+//
+//	return test_cross_edge_box(edge,absolute_edge,pointa,pointb,extend,2,1,1,2);
+//}
+//
+//
+//SIMD_FORCE_INLINE bool test_cross_edge_box_Y_axis(
+//	const btVector3 & edge,
+//	const btVector3 & absolute_edge,
+//	const btVector3 & pointa,
+//	const btVector3 & pointb, btVector3 & extend)
+//{
+//
+//	return test_cross_edge_box(edge,absolute_edge,pointa,pointb,extend,0,2,2,0);
+//}
+//
+//SIMD_FORCE_INLINE bool test_cross_edge_box_Z_axis(
+//	const btVector3 & edge,
+//	const btVector3 & absolute_edge,
+//	const btVector3 & pointa,
+//	const btVector3 & pointb, btVector3 & extend)
+//{
+//
+//	return test_cross_edge_box(edge,absolute_edge,pointa,pointb,extend,1,0,0,1);
+//}
+
+#define TEST_CROSS_EDGE_BOX_MCR(edge, absolute_edge, pointa, pointb, _extend, i_dir_0, i_dir_1, i_comp_0, i_comp_1) \
+	{                                                                                                               \
+		const btScalar dir0 = -edge[i_dir_0];                                                                       \
+		const btScalar dir1 = edge[i_dir_1];                                                                        \
+		btScalar pmin = pointa[i_comp_0] * dir0 + pointa[i_comp_1] * dir1;                                          \
+		btScalar pmax = pointb[i_comp_0] * dir0 + pointb[i_comp_1] * dir1;                                          \
+		if (pmin > pmax)                                                                                            \
+		{                                                                                                           \
+			BT_SWAP_NUMBERS(pmin, pmax);                                                                            \
+		}                                                                                                           \
+		const btScalar abs_dir0 = absolute_edge[i_dir_0];                                                           \
+		const btScalar abs_dir1 = absolute_edge[i_dir_1];                                                           \
+		const btScalar rad = _extend[i_comp_0] * abs_dir0 + _extend[i_comp_1] * abs_dir1;                           \
+		if (pmin > rad || -rad > pmax) return false;                                                                \
+	}
+
+#define TEST_CROSS_EDGE_BOX_X_AXIS_MCR(edge, absolute_edge, pointa, pointb, _extend)       \
+	{                                                                                      \
+		TEST_CROSS_EDGE_BOX_MCR(edge, absolute_edge, pointa, pointb, _extend, 2, 1, 1, 2); \
+	}
+
+#define TEST_CROSS_EDGE_BOX_Y_AXIS_MCR(edge, absolute_edge, pointa, pointb, _extend)       \
+	{                                                                                      \
+		TEST_CROSS_EDGE_BOX_MCR(edge, absolute_edge, pointa, pointb, _extend, 0, 2, 2, 0); \
+	}
+
+#define TEST_CROSS_EDGE_BOX_Z_AXIS_MCR(edge, absolute_edge, pointa, pointb, _extend)       \
+	{                                                                                      \
+		TEST_CROSS_EDGE_BOX_MCR(edge, absolute_edge, pointa, pointb, _extend, 1, 0, 0, 1); \
+	}
+
+//! Returns the dot product between a vec3f and the col of a matrix
+SIMD_FORCE_INLINE btScalar bt_mat3_dot_col(
+	const btMatrix3x3 &mat, const btVector3 &vec3, int colindex)
+{
+	return vec3[0] * mat[0][colindex] + vec3[1] * mat[1][colindex] + vec3[2] * mat[2][colindex];
+}
+
+//!  Class for transforming a model1 to the space of model0
+ATTRIBUTE_ALIGNED16(class)
+BT_BOX_BOX_TRANSFORM_CACHE
+{
+public:
+	btVector3 m_T1to0;    //!< Transforms translation of model1 to model 0
+	btMatrix3x3 m_R1to0;  //!< Transforms Rotation of model1 to model 0, equal  to R0' * R1
+	btMatrix3x3 m_AR;     //!< Absolute value of m_R1to0
+
+	SIMD_FORCE_INLINE void calc_absolute_matrix()
+	{
+		//		static const btVector3 vepsi(1e-6f,1e-6f,1e-6f);
+		//		m_AR[0] = vepsi + m_R1to0[0].absolute();
+		//		m_AR[1] = vepsi + m_R1to0[1].absolute();
+		//		m_AR[2] = vepsi + m_R1to0[2].absolute();
+
+		int i, j;
+
+		for (i = 0; i < 3; i++)
+		{
+			for (j = 0; j < 3; j++)
+			{
+				m_AR[i][j] = 1e-6f + btFabs(m_R1to0[i][j]);
+			}
+		}
+	}
+
+	BT_BOX_BOX_TRANSFORM_CACHE()
+	{
+	}
+
+	//! Calc the transformation relative  1 to 0. Inverts matrics by transposing
+	SIMD_FORCE_INLINE void calc_from_homogenic(const btTransform &trans0, const btTransform &trans1)
+	{
+		btTransform temp_trans = trans0.inverse();
+		temp_trans = temp_trans * trans1;
+
+		m_T1to0 = temp_trans.getOrigin();
+		m_R1to0 = temp_trans.getBasis();
+
+		calc_absolute_matrix();
+	}
+
+	//! Calcs the full invertion of the matrices. Useful for scaling matrices
+	SIMD_FORCE_INLINE void calc_from_full_invert(const btTransform &trans0, const btTransform &trans1)
+	{
+		m_R1to0 = trans0.getBasis().inverse();
+		m_T1to0 = m_R1to0 * (-trans0.getOrigin());
+
+		m_T1to0 += m_R1to0 * trans1.getOrigin();
+		m_R1to0 *= trans1.getBasis();
+
+		calc_absolute_matrix();
+	}
+
+	SIMD_FORCE_INLINE btVector3 transform(const btVector3 &point) const
+	{
+		return point.dot3(m_R1to0[0], m_R1to0[1], m_R1to0[2]) + m_T1to0;
+	}
+};
+
+#define BOX_PLANE_EPSILON 0.000001f
+
+//! Axis aligned box
+ATTRIBUTE_ALIGNED16(class)
+btAABB
+{
+public:
+	btVector3 m_min;
+	btVector3 m_max;
+
+	btAABB()
+	{
+	}
+
+	btAABB(const btVector3 &V1,
+		   const btVector3 &V2,
+		   const btVector3 &V3)
+	{
+		m_min[0] = BT_MIN3(V1[0], V2[0], V3[0]);
+		m_min[1] = BT_MIN3(V1[1], V2[1], V3[1]);
+		m_min[2] = BT_MIN3(V1[2], V2[2], V3[2]);
+
+		m_max[0] = BT_MAX3(V1[0], V2[0], V3[0]);
+		m_max[1] = BT_MAX3(V1[1], V2[1], V3[1]);
+		m_max[2] = BT_MAX3(V1[2], V2[2], V3[2]);
+	}
+
+	btAABB(const btVector3 &V1,
+		   const btVector3 &V2,
+		   const btVector3 &V3,
+		   btScalar margin)
+	{
+		m_min[0] = BT_MIN3(V1[0], V2[0], V3[0]);
+		m_min[1] = BT_MIN3(V1[1], V2[1], V3[1]);
+		m_min[2] = BT_MIN3(V1[2], V2[2], V3[2]);
+
+		m_max[0] = BT_MAX3(V1[0], V2[0], V3[0]);
+		m_max[1] = BT_MAX3(V1[1], V2[1], V3[1]);
+		m_max[2] = BT_MAX3(V1[2], V2[2], V3[2]);
+
+		m_min[0] -= margin;
+		m_min[1] -= margin;
+		m_min[2] -= margin;
+		m_max[0] += margin;
+		m_max[1] += margin;
+		m_max[2] += margin;
+	}
+
+	btAABB(const btAABB &other) : m_min(other.m_min), m_max(other.m_max)
+	{
+	}
+
+	btAABB(const btAABB &other, btScalar margin) : m_min(other.m_min), m_max(other.m_max)
+	{
+		m_min[0] -= margin;
+		m_min[1] -= margin;
+		m_min[2] -= margin;
+		m_max[0] += margin;
+		m_max[1] += margin;
+		m_max[2] += margin;
+	}
+
+	SIMD_FORCE_INLINE void invalidate()
+	{
+		m_min[0] = SIMD_INFINITY;
+		m_min[1] = SIMD_INFINITY;
+		m_min[2] = SIMD_INFINITY;
+		m_max[0] = -SIMD_INFINITY;
+		m_max[1] = -SIMD_INFINITY;
+		m_max[2] = -SIMD_INFINITY;
+	}
+
+	SIMD_FORCE_INLINE void increment_margin(btScalar margin)
+	{
+		m_min[0] -= margin;
+		m_min[1] -= margin;
+		m_min[2] -= margin;
+		m_max[0] += margin;
+		m_max[1] += margin;
+		m_max[2] += margin;
+	}
+
+	SIMD_FORCE_INLINE void copy_with_margin(const btAABB &other, btScalar margin)
+	{
+		m_min[0] = other.m_min[0] - margin;
+		m_min[1] = other.m_min[1] - margin;
+		m_min[2] = other.m_min[2] - margin;
+
+		m_max[0] = other.m_max[0] + margin;
+		m_max[1] = other.m_max[1] + margin;
+		m_max[2] = other.m_max[2] + margin;
+	}
+
+	template <typename CLASS_POINT>
+	SIMD_FORCE_INLINE void calc_from_triangle(
+		const CLASS_POINT &V1,
+		const CLASS_POINT &V2,
+		const CLASS_POINT &V3)
+	{
+		m_min[0] = BT_MIN3(V1[0], V2[0], V3[0]);
+		m_min[1] = BT_MIN3(V1[1], V2[1], V3[1]);
+		m_min[2] = BT_MIN3(V1[2], V2[2], V3[2]);
+
+		m_max[0] = BT_MAX3(V1[0], V2[0], V3[0]);
+		m_max[1] = BT_MAX3(V1[1], V2[1], V3[1]);
+		m_max[2] = BT_MAX3(V1[2], V2[2], V3[2]);
+	}
+
+	template <typename CLASS_POINT>
+	SIMD_FORCE_INLINE void calc_from_triangle_margin(
+		const CLASS_POINT &V1,
+		const CLASS_POINT &V2,
+		const CLASS_POINT &V3, btScalar margin)
+	{
+		m_min[0] = BT_MIN3(V1[0], V2[0], V3[0]);
+		m_min[1] = BT_MIN3(V1[1], V2[1], V3[1]);
+		m_min[2] = BT_MIN3(V1[2], V2[2], V3[2]);
+
+		m_max[0] = BT_MAX3(V1[0], V2[0], V3[0]);
+		m_max[1] = BT_MAX3(V1[1], V2[1], V3[1]);
+		m_max[2] = BT_MAX3(V1[2], V2[2], V3[2]);
+
+		m_min[0] -= margin;
+		m_min[1] -= margin;
+		m_min[2] -= margin;
+		m_max[0] += margin;
+		m_max[1] += margin;
+		m_max[2] += margin;
+	}
+
+	//! Apply a transform to an AABB
+	SIMD_FORCE_INLINE void appy_transform(const btTransform &trans)
+	{
+		btVector3 center = (m_max + m_min) * 0.5f;
+		btVector3 extends = m_max - center;
+		// Compute new center
+		center = trans(center);
+
+		btVector3 textends = extends.dot3(trans.getBasis().getRow(0).absolute(),
+										  trans.getBasis().getRow(1).absolute(),
+										  trans.getBasis().getRow(2).absolute());
+
+		m_min = center - textends;
+		m_max = center + textends;
+	}
+
+	//! Apply a transform to an AABB
+	SIMD_FORCE_INLINE void appy_transform_trans_cache(const BT_BOX_BOX_TRANSFORM_CACHE &trans)
+	{
+		btVector3 center = (m_max + m_min) * 0.5f;
+		btVector3 extends = m_max - center;
+		// Compute new center
+		center = trans.transform(center);
+
+		btVector3 textends = extends.dot3(trans.m_R1to0.getRow(0).absolute(),
+										  trans.m_R1to0.getRow(1).absolute(),
+										  trans.m_R1to0.getRow(2).absolute());
+
+		m_min = center - textends;
+		m_max = center + textends;
+	}
+
+	//! Merges a Box
+	SIMD_FORCE_INLINE void merge(const btAABB &box)
+	{
+		m_min[0] = BT_MIN(m_min[0], box.m_min[0]);
+		m_min[1] = BT_MIN(m_min[1], box.m_min[1]);
+		m_min[2] = BT_MIN(m_min[2], box.m_min[2]);
+
+		m_max[0] = BT_MAX(m_max[0], box.m_max[0]);
+		m_max[1] = BT_MAX(m_max[1], box.m_max[1]);
+		m_max[2] = BT_MAX(m_max[2], box.m_max[2]);
+	}
+
+	//! Merges a point
+	template <typename CLASS_POINT>
+	SIMD_FORCE_INLINE void merge_point(const CLASS_POINT &point)
+	{
+		m_min[0] = BT_MIN(m_min[0], point[0]);
+		m_min[1] = BT_MIN(m_min[1], point[1]);
+		m_min[2] = BT_MIN(m_min[2], point[2]);
+
+		m_max[0] = BT_MAX(m_max[0], point[0]);
+		m_max[1] = BT_MAX(m_max[1], point[1]);
+		m_max[2] = BT_MAX(m_max[2], point[2]);
+	}
+
+	//! Gets the extend and center
+	SIMD_FORCE_INLINE void get_center_extend(btVector3 & center, btVector3 & extend) const
+	{
+		center = (m_max + m_min) * 0.5f;
+		extend = m_max - center;
+	}
+
+	//! Finds the intersecting box between this box and the other.
+	SIMD_FORCE_INLINE void find_intersection(const btAABB &other, btAABB &intersection) const
+	{
+		intersection.m_min[0] = BT_MAX(other.m_min[0], m_min[0]);
+		intersection.m_min[1] = BT_MAX(other.m_min[1], m_min[1]);
+		intersection.m_min[2] = BT_MAX(other.m_min[2], m_min[2]);
+
+		intersection.m_max[0] = BT_MIN(other.m_max[0], m_max[0]);
+		intersection.m_max[1] = BT_MIN(other.m_max[1], m_max[1]);
+		intersection.m_max[2] = BT_MIN(other.m_max[2], m_max[2]);
+	}
+
+	SIMD_FORCE_INLINE bool has_collision(const btAABB &other) const
+	{
+		if (m_min[0] > other.m_max[0] ||
+			m_max[0] < other.m_min[0] ||
+			m_min[1] > other.m_max[1] ||
+			m_max[1] < other.m_min[1] ||
+			m_min[2] > other.m_max[2] ||
+			m_max[2] < other.m_min[2])
+		{
+			return false;
+		}
+		return true;
+	}
+
+	/*! \brief Finds the Ray intersection parameter.
+	\param aabb Aligned box
+	\param vorigin A vec3f with the origin of the ray
+	\param vdir A vec3f with the direction of the ray
+	*/
+	SIMD_FORCE_INLINE bool collide_ray(const btVector3 &vorigin, const btVector3 &vdir) const
+	{
+		btVector3 extents, center;
+		this->get_center_extend(center, extents);
+		;
+
+		btScalar Dx = vorigin[0] - center[0];
+		if (BT_GREATER(Dx, extents[0]) && Dx * vdir[0] >= 0.0f) return false;
+		btScalar Dy = vorigin[1] - center[1];
+		if (BT_GREATER(Dy, extents[1]) && Dy * vdir[1] >= 0.0f) return false;
+		btScalar Dz = vorigin[2] - center[2];
+		if (BT_GREATER(Dz, extents[2]) && Dz * vdir[2] >= 0.0f) return false;
+
+		btScalar f = vdir[1] * Dz - vdir[2] * Dy;
+		if (btFabs(f) > extents[1] * btFabs(vdir[2]) + extents[2] * btFabs(vdir[1])) return false;
+		f = vdir[2] * Dx - vdir[0] * Dz;
+		if (btFabs(f) > extents[0] * btFabs(vdir[2]) + extents[2] * btFabs(vdir[0])) return false;
+		f = vdir[0] * Dy - vdir[1] * Dx;
+		if (btFabs(f) > extents[0] * btFabs(vdir[1]) + extents[1] * btFabs(vdir[0])) return false;
+		return true;
+	}
+
+	SIMD_FORCE_INLINE void projection_interval(const btVector3 &direction, btScalar &vmin, btScalar &vmax) const
+	{
+		btVector3 center = (m_max + m_min) * 0.5f;
+		btVector3 extend = m_max - center;
+
+		btScalar _fOrigin = direction.dot(center);
+		btScalar _fMaximumExtent = extend.dot(direction.absolute());
+		vmin = _fOrigin - _fMaximumExtent;
+		vmax = _fOrigin + _fMaximumExtent;
+	}
+
+	SIMD_FORCE_INLINE eBT_PLANE_INTERSECTION_TYPE plane_classify(const btVector4 &plane) const
+	{
+		btScalar _fmin, _fmax;
+		this->projection_interval(plane, _fmin, _fmax);
+
+		if (plane[3] > _fmax + BOX_PLANE_EPSILON)
+		{
+			return BT_CONST_BACK_PLANE;  // 0
+		}
+
+		if (plane[3] + BOX_PLANE_EPSILON >= _fmin)
+		{
+			return BT_CONST_COLLIDE_PLANE;  //1
+		}
+		return BT_CONST_FRONT_PLANE;  //2
+	}
+
+	SIMD_FORCE_INLINE bool overlapping_trans_conservative(const btAABB &box, btTransform &trans1_to_0) const
+	{
+		btAABB tbox = box;
+		tbox.appy_transform(trans1_to_0);
+		return has_collision(tbox);
+	}
+
+	SIMD_FORCE_INLINE bool overlapping_trans_conservative2(const btAABB &box,
+														   const BT_BOX_BOX_TRANSFORM_CACHE &trans1_to_0) const
+	{
+		btAABB tbox = box;
+		tbox.appy_transform_trans_cache(trans1_to_0);
+		return has_collision(tbox);
+	}
+
+	//! transcache is the transformation cache from box to this AABB
+	SIMD_FORCE_INLINE bool overlapping_trans_cache(
+		const btAABB &box, const BT_BOX_BOX_TRANSFORM_CACHE &transcache, bool fulltest) const
+	{
+		//Taken from OPCODE
+		btVector3 ea, eb;  //extends
+		btVector3 ca, cb;  //extends
+		get_center_extend(ca, ea);
+		box.get_center_extend(cb, eb);
+
+		btVector3 T;
+		btScalar t, t2;
+		int i;
+
+		// Class I : A's basis vectors
+		for (i = 0; i < 3; i++)
+		{
+			T[i] = transcache.m_R1to0[i].dot(cb) + transcache.m_T1to0[i] - ca[i];
+			t = transcache.m_AR[i].dot(eb) + ea[i];
+			if (BT_GREATER(T[i], t)) return false;
+		}
+		// Class II : B's basis vectors
+		for (i = 0; i < 3; i++)
+		{
+			t = bt_mat3_dot_col(transcache.m_R1to0, T, i);
+			t2 = bt_mat3_dot_col(transcache.m_AR, ea, i) + eb[i];
+			if (BT_GREATER(t, t2)) return false;
+		}
+		// Class III : 9 cross products
+		if (fulltest)
+		{
+			int j, m, n, o, p, q, r;
+			for (i = 0; i < 3; i++)
+			{
+				m = (i + 1) % 3;
+				n = (i + 2) % 3;
+				o = i == 0 ? 1 : 0;
+				p = i == 2 ? 1 : 2;
+				for (j = 0; j < 3; j++)
+				{
+					q = j == 2 ? 1 : 2;
+					r = j == 0 ? 1 : 0;
+					t = T[n] * transcache.m_R1to0[m][j] - T[m] * transcache.m_R1to0[n][j];
+					t2 = ea[o] * transcache.m_AR[p][j] + ea[p] * transcache.m_AR[o][j] +
+						 eb[r] * transcache.m_AR[i][q] + eb[q] * transcache.m_AR[i][r];
+					if (BT_GREATER(t, t2)) return false;
+				}
+			}
+		}
+		return true;
+	}
+
+	//! Simple test for planes.
+	SIMD_FORCE_INLINE bool collide_plane(
+		const btVector4 &plane) const
+	{
+		eBT_PLANE_INTERSECTION_TYPE classify = plane_classify(plane);
+		return (classify == BT_CONST_COLLIDE_PLANE);
+	}
+
+	//! test for a triangle, with edges
+	SIMD_FORCE_INLINE bool collide_triangle_exact(
+		const btVector3 &p1,
+		const btVector3 &p2,
+		const btVector3 &p3,
+		const btVector4 &triangle_plane) const
+	{
+		if (!collide_plane(triangle_plane)) return false;
+
+		btVector3 center, extends;
+		this->get_center_extend(center, extends);
+
+		const btVector3 v1(p1 - center);
+		const btVector3 v2(p2 - center);
+		const btVector3 v3(p3 - center);
+
+		//First axis
+		btVector3 diff(v2 - v1);
+		btVector3 abs_diff = diff.absolute();
+		//Test With X axis
+		TEST_CROSS_EDGE_BOX_X_AXIS_MCR(diff, abs_diff, v1, v3, extends);
+		//Test With Y axis
+		TEST_CROSS_EDGE_BOX_Y_AXIS_MCR(diff, abs_diff, v1, v3, extends);
+		//Test With Z axis
+		TEST_CROSS_EDGE_BOX_Z_AXIS_MCR(diff, abs_diff, v1, v3, extends);
+
+		diff = v3 - v2;
+		abs_diff = diff.absolute();
+		//Test With X axis
+		TEST_CROSS_EDGE_BOX_X_AXIS_MCR(diff, abs_diff, v2, v1, extends);
+		//Test With Y axis
+		TEST_CROSS_EDGE_BOX_Y_AXIS_MCR(diff, abs_diff, v2, v1, extends);
+		//Test With Z axis
+		TEST_CROSS_EDGE_BOX_Z_AXIS_MCR(diff, abs_diff, v2, v1, extends);
+
+		diff = v1 - v3;
+		abs_diff = diff.absolute();
+		//Test With X axis
+		TEST_CROSS_EDGE_BOX_X_AXIS_MCR(diff, abs_diff, v3, v2, extends);
+		//Test With Y axis
+		TEST_CROSS_EDGE_BOX_Y_AXIS_MCR(diff, abs_diff, v3, v2, extends);
+		//Test With Z axis
+		TEST_CROSS_EDGE_BOX_Z_AXIS_MCR(diff, abs_diff, v3, v2, extends);
+
+		return true;
+	}
+};
+
+//! Compairison of transformation objects
+SIMD_FORCE_INLINE bool btCompareTransformsEqual(const btTransform &t1, const btTransform &t2)
+{
+	if (!(t1.getOrigin() == t2.getOrigin())) return false;
+
+	if (!(t1.getBasis().getRow(0) == t2.getBasis().getRow(0))) return false;
+	if (!(t1.getBasis().getRow(1) == t2.getBasis().getRow(1))) return false;
+	if (!(t1.getBasis().getRow(2) == t2.getBasis().getRow(2))) return false;
+	return true;
+}
+
+#endif  // GIM_BOX_COLLISION_H_INCLUDED
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/btClipPolygon.h b/engine/inc/bullet/BulletCollision/Gimpact/btClipPolygon.h
new file mode 100644
index 00000000..38c23e22
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/btClipPolygon.h
@@ -0,0 +1,173 @@
+#ifndef BT_CLIP_POLYGON_H_INCLUDED
+#define BT_CLIP_POLYGON_H_INCLUDED
+
+/*! \file btClipPolygon.h
+\author Francisco Leon Najera
+*/
+/*
+This source file is part of GIMPACT Library.
+
+For the latest info, see http://gimpact.sourceforge.net/
+
+Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371.
+email: projectileman@yahoo.com
+
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btGeometryUtil.h"
+
+SIMD_FORCE_INLINE btScalar bt_distance_point_plane(const btVector4 &plane, const btVector3 &point)
+{
+	return point.dot(plane) - plane[3];
+}
+
+/*! Vector blending
+Takes two vectors a, b, blends them together*/
+SIMD_FORCE_INLINE void bt_vec_blend(btVector3 &vr, const btVector3 &va, const btVector3 &vb, btScalar blend_factor)
+{
+	vr = (1 - blend_factor) * va + blend_factor * vb;
+}
+
+//! This function calcs the distance from a 3D plane
+SIMD_FORCE_INLINE void bt_plane_clip_polygon_collect(
+	const btVector3 &point0,
+	const btVector3 &point1,
+	btScalar dist0,
+	btScalar dist1,
+	btVector3 *clipped,
+	int &clipped_count)
+{
+	bool _prevclassif = (dist0 > SIMD_EPSILON);
+	bool _classif = (dist1 > SIMD_EPSILON);
+	if (_classif != _prevclassif)
+	{
+		btScalar blendfactor = -dist0 / (dist1 - dist0);
+		bt_vec_blend(clipped[clipped_count], point0, point1, blendfactor);
+		clipped_count++;
+	}
+	if (!_classif)
+	{
+		clipped[clipped_count] = point1;
+		clipped_count++;
+	}
+}
+
+//! Clips a polygon by a plane
+/*!
+*\return The count of the clipped counts
+*/
+SIMD_FORCE_INLINE int bt_plane_clip_polygon(
+	const btVector4 &plane,
+	const btVector3 *polygon_points,
+	int polygon_point_count,
+	btVector3 *clipped)
+{
+	int clipped_count = 0;
+
+	//clip first point
+	btScalar firstdist = bt_distance_point_plane(plane, polygon_points[0]);
+	;
+	if (!(firstdist > SIMD_EPSILON))
+	{
+		clipped[clipped_count] = polygon_points[0];
+		clipped_count++;
+	}
+
+	btScalar olddist = firstdist;
+	for (int i = 1; i < polygon_point_count; i++)
+	{
+		btScalar dist = bt_distance_point_plane(plane, polygon_points[i]);
+
+		bt_plane_clip_polygon_collect(
+			polygon_points[i - 1], polygon_points[i],
+			olddist,
+			dist,
+			clipped,
+			clipped_count);
+
+		olddist = dist;
+	}
+
+	//RETURN TO FIRST  point
+
+	bt_plane_clip_polygon_collect(
+		polygon_points[polygon_point_count - 1], polygon_points[0],
+		olddist,
+		firstdist,
+		clipped,
+		clipped_count);
+
+	return clipped_count;
+}
+
+//! Clips a polygon by a plane
+/*!
+*\param clipped must be an array of 16 points.
+*\return The count of the clipped counts
+*/
+SIMD_FORCE_INLINE int bt_plane_clip_triangle(
+	const btVector4 &plane,
+	const btVector3 &point0,
+	const btVector3 &point1,
+	const btVector3 &point2,
+	btVector3 *clipped  // an allocated array of 16 points at least
+)
+{
+	int clipped_count = 0;
+
+	//clip first point0
+	btScalar firstdist = bt_distance_point_plane(plane, point0);
+	;
+	if (!(firstdist > SIMD_EPSILON))
+	{
+		clipped[clipped_count] = point0;
+		clipped_count++;
+	}
+
+	// point 1
+	btScalar olddist = firstdist;
+	btScalar dist = bt_distance_point_plane(plane, point1);
+
+	bt_plane_clip_polygon_collect(
+		point0, point1,
+		olddist,
+		dist,
+		clipped,
+		clipped_count);
+
+	olddist = dist;
+
+	// point 2
+	dist = bt_distance_point_plane(plane, point2);
+
+	bt_plane_clip_polygon_collect(
+		point1, point2,
+		olddist,
+		dist,
+		clipped,
+		clipped_count);
+	olddist = dist;
+
+	//RETURN TO FIRST  point0
+	bt_plane_clip_polygon_collect(
+		point2, point0,
+		olddist,
+		firstdist,
+		clipped,
+		clipped_count);
+
+	return clipped_count;
+}
+
+#endif  // GIM_TRI_COLLISION_H_INCLUDED
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/btCompoundFromGimpact.h b/engine/inc/bullet/BulletCollision/Gimpact/btCompoundFromGimpact.h
new file mode 100644
index 00000000..ede59e8a
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/btCompoundFromGimpact.h
@@ -0,0 +1,105 @@
+#ifndef BT_COMPOUND_FROM_GIMPACT
+#define BT_COMPOUND_FROM_GIMPACT
+
+#include "BulletCollision/CollisionShapes/btCompoundShape.h"
+#include "btGImpactShape.h"
+#include "BulletCollision/NarrowPhaseCollision/btRaycastCallback.h"
+
+ATTRIBUTE_ALIGNED16(class)
+btCompoundFromGimpactShape : public btCompoundShape
+{
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	virtual ~btCompoundFromGimpactShape()
+	{
+		/*delete all the btBU_Simplex1to4 ChildShapes*/
+		for (int i = 0; i < m_children.size(); i++)
+		{
+			delete m_children[i].m_childShape;
+		}
+	}
+};
+
+struct MyCallback : public btTriangleRaycastCallback
+{
+	int m_ignorePart;
+	int m_ignoreTriangleIndex;
+
+	MyCallback(const btVector3& from, const btVector3& to, int ignorePart, int ignoreTriangleIndex)
+		: btTriangleRaycastCallback(from, to),
+		  m_ignorePart(ignorePart),
+		  m_ignoreTriangleIndex(ignoreTriangleIndex)
+	{
+	}
+	virtual btScalar reportHit(const btVector3& hitNormalLocal, btScalar hitFraction, int partId, int triangleIndex)
+	{
+		if (partId != m_ignorePart || triangleIndex != m_ignoreTriangleIndex)
+		{
+			if (hitFraction < m_hitFraction)
+				return hitFraction;
+		}
+
+		return m_hitFraction;
+	}
+};
+struct MyInternalTriangleIndexCallback : public btInternalTriangleIndexCallback
+{
+	const btGImpactMeshShape* m_gimpactShape;
+	btCompoundShape* m_colShape;
+	btScalar m_depth;
+
+	MyInternalTriangleIndexCallback(btCompoundShape* colShape, const btGImpactMeshShape* meshShape, btScalar depth)
+		: m_colShape(colShape),
+		  m_gimpactShape(meshShape),
+		  m_depth(depth)
+	{
+	}
+
+	virtual void internalProcessTriangleIndex(btVector3* triangle, int partId, int triangleIndex)
+	{
+		btVector3 scale = m_gimpactShape->getLocalScaling();
+		btVector3 v0 = triangle[0] * scale;
+		btVector3 v1 = triangle[1] * scale;
+		btVector3 v2 = triangle[2] * scale;
+
+		btVector3 centroid = (v0 + v1 + v2) / 3;
+		btVector3 normal = (v1 - v0).cross(v2 - v0);
+		normal.normalize();
+		btVector3 rayFrom = centroid;
+		btVector3 rayTo = centroid - normal * m_depth;
+
+		MyCallback cb(rayFrom, rayTo, partId, triangleIndex);
+
+		m_gimpactShape->processAllTrianglesRay(&cb, rayFrom, rayTo);
+		if (cb.m_hitFraction < 1)
+		{
+			rayTo.setInterpolate3(cb.m_from, cb.m_to, cb.m_hitFraction);
+			//rayTo = cb.m_from;
+			//rayTo = rayTo.lerp(cb.m_to,cb.m_hitFraction);
+			//gDebugDraw.drawLine(tr(centroid),tr(centroid+normal),btVector3(1,0,0));
+		}
+
+		btBU_Simplex1to4* tet = new btBU_Simplex1to4(v0, v1, v2, rayTo);
+		btTransform ident;
+		ident.setIdentity();
+		m_colShape->addChildShape(ident, tet);
+	}
+};
+
+btCompoundShape* btCreateCompoundFromGimpactShape(const btGImpactMeshShape* gimpactMesh, btScalar depth)
+{
+	btCompoundShape* colShape = new btCompoundFromGimpactShape();
+
+	btTransform tr;
+	tr.setIdentity();
+
+	MyInternalTriangleIndexCallback cb(colShape, gimpactMesh, depth);
+	btVector3 aabbMin, aabbMax;
+	gimpactMesh->getAabb(tr, aabbMin, aabbMax);
+	gimpactMesh->getMeshInterface()->InternalProcessAllTriangles(&cb, aabbMin, aabbMax);
+
+	return colShape;
+}
+
+#endif  //BT_COMPOUND_FROM_GIMPACT
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/btContactProcessing.h b/engine/inc/bullet/BulletCollision/Gimpact/btContactProcessing.h
new file mode 100644
index 00000000..4ff09d7c
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/btContactProcessing.h
@@ -0,0 +1,65 @@
+#ifndef BT_CONTACT_H_INCLUDED
+#define BT_CONTACT_H_INCLUDED
+
+/*! \file gim_contact.h
+\author Francisco Leon Najera
+*/
+/*
+This source file is part of GIMPACT Library.
+
+For the latest info, see http://gimpact.sourceforge.net/
+
+Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371.
+email: projectileman@yahoo.com
+
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btAlignedObjectArray.h"
+#include "btTriangleShapeEx.h"
+#include "btContactProcessingStructs.h"
+
+class btContactArray : public btAlignedObjectArray<GIM_CONTACT>
+{
+public:
+	btContactArray()
+	{
+		reserve(64);
+	}
+
+	SIMD_FORCE_INLINE void push_contact(
+		const btVector3 &point, const btVector3 &normal,
+		btScalar depth, int feature1, int feature2)
+	{
+		push_back(GIM_CONTACT(point, normal, depth, feature1, feature2));
+	}
+
+	SIMD_FORCE_INLINE void push_triangle_contacts(
+		const GIM_TRIANGLE_CONTACT &tricontact,
+		int feature1, int feature2)
+	{
+		for (int i = 0; i < tricontact.m_point_count; i++)
+		{
+			push_contact(
+				tricontact.m_points[i],
+				tricontact.m_separating_normal,
+				tricontact.m_penetration_depth, feature1, feature2);
+		}
+	}
+
+	void merge_contacts(const btContactArray &contacts, bool normal_contact_average = true);
+
+	void merge_contacts_unique(const btContactArray &contacts);
+};
+
+#endif  // GIM_CONTACT_H_INCLUDED
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/btContactProcessingStructs.h b/engine/inc/bullet/BulletCollision/Gimpact/btContactProcessingStructs.h
new file mode 100644
index 00000000..bc8a7092
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/btContactProcessingStructs.h
@@ -0,0 +1,105 @@
+#ifndef BT_CONTACT_H_STRUCTS_INCLUDED
+#define BT_CONTACT_H_STRUCTS_INCLUDED
+
+/*! \file gim_contact.h
+\author Francisco Leon Najera
+*/
+/*
+This source file is part of GIMPACT Library.
+
+For the latest info, see http://gimpact.sourceforge.net/
+
+Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371.
+email: projectileman@yahoo.com
+
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btAlignedObjectArray.h"
+#include "btTriangleShapeEx.h"
+
+/**
+Configuration var for applying interpolation of  contact normals
+*/
+#define NORMAL_CONTACT_AVERAGE 1
+
+#define CONTACT_DIFF_EPSILON 0.00001f
+
+///The GIM_CONTACT is an internal GIMPACT structure, similar to btManifoldPoint.
+///@todo: remove and replace GIM_CONTACT by btManifoldPoint.
+class GIM_CONTACT
+{
+public:
+	btVector3 m_point;
+	btVector3 m_normal;
+	btScalar m_depth;     //Positive value indicates interpenetration
+	btScalar m_distance;  //Padding not for use
+	int m_feature1;       //Face number
+	int m_feature2;       //Face number
+public:
+	GIM_CONTACT()
+	{
+	}
+
+	GIM_CONTACT(const GIM_CONTACT &contact) : m_point(contact.m_point),
+											  m_normal(contact.m_normal),
+											  m_depth(contact.m_depth),
+											  m_feature1(contact.m_feature1),
+											  m_feature2(contact.m_feature2)
+	{
+	}
+
+	GIM_CONTACT(const btVector3 &point, const btVector3 &normal,
+				btScalar depth, int feature1, int feature2) : m_point(point),
+															  m_normal(normal),
+															  m_depth(depth),
+															  m_feature1(feature1),
+															  m_feature2(feature2)
+	{
+	}
+
+	//! Calcs key for coord classification
+	SIMD_FORCE_INLINE unsigned int calc_key_contact() const
+	{
+		int _coords[] = {
+			(int)(m_point[0] * 1000.0f + 1.0f),
+			(int)(m_point[1] * 1333.0f),
+			(int)(m_point[2] * 2133.0f + 3.0f)};
+		unsigned int _hash = 0;
+		unsigned int *_uitmp = (unsigned int *)(&_coords[0]);
+		_hash = *_uitmp;
+		_uitmp++;
+		_hash += (*_uitmp) << 4;
+		_uitmp++;
+		_hash += (*_uitmp) << 8;
+		return _hash;
+	}
+
+	SIMD_FORCE_INLINE void interpolate_normals(btVector3 *normals, int normal_count)
+	{
+		btVector3 vec_sum(m_normal);
+		for (int i = 0; i < normal_count; i++)
+		{
+			vec_sum += normals[i];
+		}
+
+		btScalar vec_sum_len = vec_sum.length2();
+		if (vec_sum_len < CONTACT_DIFF_EPSILON) return;
+
+		//GIM_INV_SQRT(vec_sum_len,vec_sum_len); // 1/sqrt(vec_sum_len)
+
+		m_normal = vec_sum / btSqrt(vec_sum_len);
+	}
+};
+
+#endif  // BT_CONTACT_H_STRUCTS_INCLUDED
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/btGImpactBvh.h b/engine/inc/bullet/BulletCollision/Gimpact/btGImpactBvh.h
new file mode 100644
index 00000000..3cd8fa24
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/btGImpactBvh.h
@@ -0,0 +1,309 @@
+#ifndef BT_GIMPACT_BVH_H_INCLUDED
+#define BT_GIMPACT_BVH_H_INCLUDED
+
+/*! \file gim_box_set.h
+\author Francisco Leon Najera
+*/
+/*
+This source file is part of GIMPACT Library.
+
+For the latest info, see http://gimpact.sourceforge.net/
+
+Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371.
+email: projectileman@yahoo.com
+
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "LinearMath/btAlignedObjectArray.h"
+
+#include "btBoxCollision.h"
+#include "btTriangleShapeEx.h"
+#include "btGImpactBvhStructs.h"
+
+//! A pairset array
+class btPairSet : public btAlignedObjectArray<GIM_PAIR>
+{
+public:
+	btPairSet()
+	{
+		reserve(32);
+	}
+	inline void push_pair(int index1, int index2)
+	{
+		push_back(GIM_PAIR(index1, index2));
+	}
+
+	inline void push_pair_inv(int index1, int index2)
+	{
+		push_back(GIM_PAIR(index2, index1));
+	}
+};
+
+class GIM_BVH_DATA_ARRAY : public btAlignedObjectArray<GIM_BVH_DATA>
+{
+};
+
+class GIM_BVH_TREE_NODE_ARRAY : public btAlignedObjectArray<GIM_BVH_TREE_NODE>
+{
+};
+
+//! Basic Box tree structure
+class btBvhTree
+{
+protected:
+	int m_num_nodes;
+	GIM_BVH_TREE_NODE_ARRAY m_node_array;
+
+protected:
+	int _sort_and_calc_splitting_index(
+		GIM_BVH_DATA_ARRAY& primitive_boxes,
+		int startIndex, int endIndex, int splitAxis);
+
+	int _calc_splitting_axis(GIM_BVH_DATA_ARRAY& primitive_boxes, int startIndex, int endIndex);
+
+	void _build_sub_tree(GIM_BVH_DATA_ARRAY& primitive_boxes, int startIndex, int endIndex);
+
+public:
+	btBvhTree()
+	{
+		m_num_nodes = 0;
+	}
+
+	//! prototype functions for box tree management
+	//!@{
+	void build_tree(GIM_BVH_DATA_ARRAY& primitive_boxes);
+
+	SIMD_FORCE_INLINE void clearNodes()
+	{
+		m_node_array.clear();
+		m_num_nodes = 0;
+	}
+
+	//! node count
+	SIMD_FORCE_INLINE int getNodeCount() const
+	{
+		return m_num_nodes;
+	}
+
+	//! tells if the node is a leaf
+	SIMD_FORCE_INLINE bool isLeafNode(int nodeindex) const
+	{
+		return m_node_array[nodeindex].isLeafNode();
+	}
+
+	SIMD_FORCE_INLINE int getNodeData(int nodeindex) const
+	{
+		return m_node_array[nodeindex].getDataIndex();
+	}
+
+	SIMD_FORCE_INLINE void getNodeBound(int nodeindex, btAABB& bound) const
+	{
+		bound = m_node_array[nodeindex].m_bound;
+	}
+
+	SIMD_FORCE_INLINE void setNodeBound(int nodeindex, const btAABB& bound)
+	{
+		m_node_array[nodeindex].m_bound = bound;
+	}
+
+	SIMD_FORCE_INLINE int getLeftNode(int nodeindex) const
+	{
+		return nodeindex + 1;
+	}
+
+	SIMD_FORCE_INLINE int getRightNode(int nodeindex) const
+	{
+		if (m_node_array[nodeindex + 1].isLeafNode()) return nodeindex + 2;
+		return nodeindex + 1 + m_node_array[nodeindex + 1].getEscapeIndex();
+	}
+
+	SIMD_FORCE_INLINE int getEscapeNodeIndex(int nodeindex) const
+	{
+		return m_node_array[nodeindex].getEscapeIndex();
+	}
+
+	SIMD_FORCE_INLINE const GIM_BVH_TREE_NODE* get_node_pointer(int index = 0) const
+	{
+		return &m_node_array[index];
+	}
+
+	//!@}
+};
+
+//! Prototype Base class for primitive classification
+/*!
+This class is a wrapper for primitive collections.
+This tells relevant info for the Bounding Box set classes, which take care of space classification.
+This class can manage Compound shapes and trimeshes, and if it is managing trimesh then the  Hierarchy Bounding Box classes will take advantage of primitive Vs Box overlapping tests for getting optimal results and less Per Box compairisons.
+*/
+class btPrimitiveManagerBase
+{
+public:
+	virtual ~btPrimitiveManagerBase() {}
+
+	//! determines if this manager consist on only triangles, which special case will be optimized
+	virtual bool is_trimesh() const = 0;
+	virtual int get_primitive_count() const = 0;
+	virtual void get_primitive_box(int prim_index, btAABB& primbox) const = 0;
+	//! retrieves only the points of the triangle, and the collision margin
+	virtual void get_primitive_triangle(int prim_index, btPrimitiveTriangle& triangle) const = 0;
+};
+
+//! Structure for containing Boxes
+/*!
+This class offers an structure for managing a box tree of primitives.
+Requires a Primitive prototype (like btPrimitiveManagerBase )
+*/
+class btGImpactBvh
+{
+protected:
+	btBvhTree m_box_tree;
+	btPrimitiveManagerBase* m_primitive_manager;
+
+protected:
+	//stackless refit
+	void refit();
+
+public:
+	//! this constructor doesn't build the tree. you must call	buildSet
+	btGImpactBvh()
+	{
+		m_primitive_manager = NULL;
+	}
+
+	//! this constructor doesn't build the tree. you must call	buildSet
+	btGImpactBvh(btPrimitiveManagerBase* primitive_manager)
+	{
+		m_primitive_manager = primitive_manager;
+	}
+
+	SIMD_FORCE_INLINE btAABB getGlobalBox() const
+	{
+		btAABB totalbox;
+		getNodeBound(0, totalbox);
+		return totalbox;
+	}
+
+	SIMD_FORCE_INLINE void setPrimitiveManager(btPrimitiveManagerBase* primitive_manager)
+	{
+		m_primitive_manager = primitive_manager;
+	}
+
+	SIMD_FORCE_INLINE btPrimitiveManagerBase* getPrimitiveManager() const
+	{
+		return m_primitive_manager;
+	}
+
+	//! node manager prototype functions
+	///@{
+
+	//! this attemps to refit the box set.
+	SIMD_FORCE_INLINE void update()
+	{
+		refit();
+	}
+
+	//! this rebuild the entire set
+	void buildSet();
+
+	//! returns the indices of the primitives in the m_primitive_manager
+	bool boxQuery(const btAABB& box, btAlignedObjectArray<int>& collided_results) const;
+
+	//! returns the indices of the primitives in the m_primitive_manager
+	SIMD_FORCE_INLINE bool boxQueryTrans(const btAABB& box,
+										 const btTransform& transform, btAlignedObjectArray<int>& collided_results) const
+	{
+		btAABB transbox = box;
+		transbox.appy_transform(transform);
+		return boxQuery(transbox, collided_results);
+	}
+
+	//! returns the indices of the primitives in the m_primitive_manager
+	bool rayQuery(
+		const btVector3& ray_dir, const btVector3& ray_origin,
+		btAlignedObjectArray<int>& collided_results) const;
+
+	//! tells if this set has hierarcht
+	SIMD_FORCE_INLINE bool hasHierarchy() const
+	{
+		return true;
+	}
+
+	//! tells if this set is a trimesh
+	SIMD_FORCE_INLINE bool isTrimesh() const
+	{
+		return m_primitive_manager->is_trimesh();
+	}
+
+	//! node count
+	SIMD_FORCE_INLINE int getNodeCount() const
+	{
+		return m_box_tree.getNodeCount();
+	}
+
+	//! tells if the node is a leaf
+	SIMD_FORCE_INLINE bool isLeafNode(int nodeindex) const
+	{
+		return m_box_tree.isLeafNode(nodeindex);
+	}
+
+	SIMD_FORCE_INLINE int getNodeData(int nodeindex) const
+	{
+		return m_box_tree.getNodeData(nodeindex);
+	}
+
+	SIMD_FORCE_INLINE void getNodeBound(int nodeindex, btAABB& bound) const
+	{
+		m_box_tree.getNodeBound(nodeindex, bound);
+	}
+
+	SIMD_FORCE_INLINE void setNodeBound(int nodeindex, const btAABB& bound)
+	{
+		m_box_tree.setNodeBound(nodeindex, bound);
+	}
+
+	SIMD_FORCE_INLINE int getLeftNode(int nodeindex) const
+	{
+		return m_box_tree.getLeftNode(nodeindex);
+	}
+
+	SIMD_FORCE_INLINE int getRightNode(int nodeindex) const
+	{
+		return m_box_tree.getRightNode(nodeindex);
+	}
+
+	SIMD_FORCE_INLINE int getEscapeNodeIndex(int nodeindex) const
+	{
+		return m_box_tree.getEscapeNodeIndex(nodeindex);
+	}
+
+	SIMD_FORCE_INLINE void getNodeTriangle(int nodeindex, btPrimitiveTriangle& triangle) const
+	{
+		m_primitive_manager->get_primitive_triangle(getNodeData(nodeindex), triangle);
+	}
+
+	SIMD_FORCE_INLINE const GIM_BVH_TREE_NODE* get_node_pointer(int index = 0) const
+	{
+		return m_box_tree.get_node_pointer(index);
+	}
+
+#ifdef TRI_COLLISION_PROFILING
+	static float getAverageTreeCollisionTime();
+#endif  //TRI_COLLISION_PROFILING
+
+	static void find_collision(btGImpactBvh* boxset1, const btTransform& trans1,
+							   btGImpactBvh* boxset2, const btTransform& trans2,
+							   btPairSet& collision_pairs);
+};
+
+#endif  // BT_GIMPACT_BVH_H_INCLUDED
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/btGImpactBvhStructs.h b/engine/inc/bullet/BulletCollision/Gimpact/btGImpactBvhStructs.h
new file mode 100644
index 00000000..8f78c234
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/btGImpactBvhStructs.h
@@ -0,0 +1,85 @@
+#ifndef GIM_BOX_SET_STRUCT_H_INCLUDED
+#define GIM_BOX_SET_STRUCT_H_INCLUDED
+
+/*! \file gim_box_set.h
+\author Francisco Leon Najera
+*/
+/*
+This source file is part of GIMPACT Library.
+
+For the latest info, see http://gimpact.sourceforge.net/
+
+Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371.
+email: projectileman@yahoo.com
+
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "LinearMath/btAlignedObjectArray.h"
+
+#include "btBoxCollision.h"
+#include "btTriangleShapeEx.h"
+#include "gim_pair.h" //for GIM_PAIR
+
+///GIM_BVH_DATA is an internal GIMPACT collision structure to contain axis aligned bounding box
+struct GIM_BVH_DATA
+{
+	btAABB m_bound;
+	int m_data;
+};
+
+//! Node Structure for trees
+class GIM_BVH_TREE_NODE
+{
+public:
+	btAABB m_bound;
+
+protected:
+	int m_escapeIndexOrDataIndex;
+
+public:
+	GIM_BVH_TREE_NODE()
+	{
+		m_escapeIndexOrDataIndex = 0;
+	}
+
+	SIMD_FORCE_INLINE bool isLeafNode() const
+	{
+		//skipindex is negative (internal node), triangleindex >=0 (leafnode)
+		return (m_escapeIndexOrDataIndex >= 0);
+	}
+
+	SIMD_FORCE_INLINE int getEscapeIndex() const
+	{
+		//btAssert(m_escapeIndexOrDataIndex < 0);
+		return -m_escapeIndexOrDataIndex;
+	}
+
+	SIMD_FORCE_INLINE void setEscapeIndex(int index)
+	{
+		m_escapeIndexOrDataIndex = -index;
+	}
+
+	SIMD_FORCE_INLINE int getDataIndex() const
+	{
+		//btAssert(m_escapeIndexOrDataIndex >= 0);
+
+		return m_escapeIndexOrDataIndex;
+	}
+
+	SIMD_FORCE_INLINE void setDataIndex(int index)
+	{
+		m_escapeIndexOrDataIndex = index;
+	}
+};
+
+#endif  // GIM_BOXPRUNING_H_INCLUDED
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/btGImpactCollisionAlgorithm.h b/engine/inc/bullet/BulletCollision/Gimpact/btGImpactCollisionAlgorithm.h
new file mode 100644
index 00000000..a368c8a0
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/btGImpactCollisionAlgorithm.h
@@ -0,0 +1,288 @@
+/*! \file btGImpactShape.h
+\author Francisco Leon Najera
+*/
+/*
+This source file is part of GIMPACT Library.
+
+For the latest info, see http://gimpact.sourceforge.net/
+
+Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371.
+email: projectileman@yahoo.com
+
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_GIMPACT_BVH_CONCAVE_COLLISION_ALGORITHM_H
+#define BT_GIMPACT_BVH_CONCAVE_COLLISION_ALGORITHM_H
+
+#include "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h"
+#include "BulletCollision/BroadphaseCollision/btDispatcher.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h"
+#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
+class btDispatcher;
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
+#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h"
+
+#include "LinearMath/btAlignedObjectArray.h"
+
+#include "btGImpactShape.h"
+#include "BulletCollision/CollisionShapes/btStaticPlaneShape.h"
+#include "BulletCollision/CollisionShapes/btCompoundShape.h"
+#include "BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h"
+#include "LinearMath/btIDebugDraw.h"
+#include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h"
+
+//! Collision Algorithm for GImpact Shapes
+/*!
+For register this algorithm in Bullet, proceed as following:
+ \code
+btCollisionDispatcher * dispatcher = static_cast<btCollisionDispatcher *>(m_dynamicsWorld ->getDispatcher());
+btGImpactCollisionAlgorithm::registerAlgorithm(dispatcher);
+ \endcode
+*/
+class btGImpactCollisionAlgorithm : public btActivatingCollisionAlgorithm
+{
+protected:
+	btCollisionAlgorithm* m_convex_algorithm;
+	btPersistentManifold* m_manifoldPtr;
+	btManifoldResult* m_resultOut;
+	const btDispatcherInfo* m_dispatchInfo;
+	int m_triface0;
+	int m_part0;
+	int m_triface1;
+	int m_part1;
+
+	//! Creates a new contact point
+	SIMD_FORCE_INLINE btPersistentManifold* newContactManifold(const btCollisionObject* body0, const btCollisionObject* body1)
+	{
+		m_manifoldPtr = m_dispatcher->getNewManifold(body0, body1);
+		return m_manifoldPtr;
+	}
+
+	SIMD_FORCE_INLINE void destroyConvexAlgorithm()
+	{
+		if (m_convex_algorithm)
+		{
+			m_convex_algorithm->~btCollisionAlgorithm();
+			m_dispatcher->freeCollisionAlgorithm(m_convex_algorithm);
+			m_convex_algorithm = NULL;
+		}
+	}
+
+	SIMD_FORCE_INLINE void destroyContactManifolds()
+	{
+		if (m_manifoldPtr == NULL) return;
+		m_dispatcher->releaseManifold(m_manifoldPtr);
+		m_manifoldPtr = NULL;
+	}
+
+	SIMD_FORCE_INLINE void clearCache()
+	{
+		destroyContactManifolds();
+		destroyConvexAlgorithm();
+
+		m_triface0 = -1;
+		m_part0 = -1;
+		m_triface1 = -1;
+		m_part1 = -1;
+	}
+
+	SIMD_FORCE_INLINE btPersistentManifold* getLastManifold()
+	{
+		return m_manifoldPtr;
+	}
+
+	// Call before process collision
+	SIMD_FORCE_INLINE void checkManifold(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap)
+	{
+		if (getLastManifold() == 0)
+		{
+			newContactManifold(body0Wrap->getCollisionObject(), body1Wrap->getCollisionObject());
+		}
+
+		m_resultOut->setPersistentManifold(getLastManifold());
+	}
+
+	// Call before process collision
+	SIMD_FORCE_INLINE btCollisionAlgorithm* newAlgorithm(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap)
+	{
+		checkManifold(body0Wrap, body1Wrap);
+
+		btCollisionAlgorithm* convex_algorithm = m_dispatcher->findAlgorithm(
+			body0Wrap, body1Wrap, getLastManifold(), BT_CONTACT_POINT_ALGORITHMS);
+		return convex_algorithm;
+	}
+
+	// Call before process collision
+	SIMD_FORCE_INLINE void checkConvexAlgorithm(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap)
+	{
+		if (m_convex_algorithm) return;
+		m_convex_algorithm = newAlgorithm(body0Wrap, body1Wrap);
+	}
+
+	void addContactPoint(const btCollisionObjectWrapper* body0Wrap,
+						 const btCollisionObjectWrapper* body1Wrap,
+						 const btVector3& point,
+						 const btVector3& normal,
+						 btScalar distance);
+
+	//! Collision routines
+	//!@{
+
+	void collide_gjk_triangles(const btCollisionObjectWrapper* body0Wrap,
+							   const btCollisionObjectWrapper* body1Wrap,
+							   const btGImpactMeshShapePart* shape0,
+							   const btGImpactMeshShapePart* shape1,
+							   const int* pairs, int pair_count);
+
+	void collide_sat_triangles(const btCollisionObjectWrapper* body0Wrap,
+							   const btCollisionObjectWrapper* body1Wrap,
+							   const btGImpactMeshShapePart* shape0,
+							   const btGImpactMeshShapePart* shape1,
+							   const int* pairs, int pair_count);
+
+	void shape_vs_shape_collision(
+		const btCollisionObjectWrapper* body0,
+		const btCollisionObjectWrapper* body1,
+		const btCollisionShape* shape0,
+		const btCollisionShape* shape1);
+
+	void convex_vs_convex_collision(const btCollisionObjectWrapper* body0Wrap,
+									const btCollisionObjectWrapper* body1Wrap,
+									const btCollisionShape* shape0,
+									const btCollisionShape* shape1);
+
+	void gimpact_vs_gimpact_find_pairs(
+		const btTransform& trans0,
+		const btTransform& trans1,
+		const btGImpactShapeInterface* shape0,
+		const btGImpactShapeInterface* shape1, btPairSet& pairset);
+
+	void gimpact_vs_shape_find_pairs(
+		const btTransform& trans0,
+		const btTransform& trans1,
+		const btGImpactShapeInterface* shape0,
+		const btCollisionShape* shape1,
+		btAlignedObjectArray<int>& collided_primitives);
+
+	void gimpacttrimeshpart_vs_plane_collision(
+		const btCollisionObjectWrapper* body0Wrap,
+		const btCollisionObjectWrapper* body1Wrap,
+		const btGImpactMeshShapePart* shape0,
+		const btStaticPlaneShape* shape1, bool swapped);
+
+public:
+	btGImpactCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap);
+
+	virtual ~btGImpactCollisionAlgorithm();
+
+	virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	btScalar calculateTimeOfImpact(btCollisionObject* body0, btCollisionObject* body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	virtual void getAllContactManifolds(btManifoldArray& manifoldArray)
+	{
+		if (m_manifoldPtr)
+			manifoldArray.push_back(m_manifoldPtr);
+	}
+
+	btManifoldResult* internalGetResultOut()
+	{
+		return m_resultOut;
+	}
+
+	struct CreateFunc : public btCollisionAlgorithmCreateFunc
+	{
+		virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap)
+		{
+			void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btGImpactCollisionAlgorithm));
+			return new (mem) btGImpactCollisionAlgorithm(ci, body0Wrap, body1Wrap);
+		}
+	};
+
+	//! Use this function for register the algorithm externally
+	static void registerAlgorithm(btCollisionDispatcher* dispatcher);
+#ifdef TRI_COLLISION_PROFILING
+	//! Gets the average time in miliseconds of tree collisions
+	static float getAverageTreeCollisionTime();
+
+	//! Gets the average time in miliseconds of triangle collisions
+	static float getAverageTriangleCollisionTime();
+#endif  //TRI_COLLISION_PROFILING
+
+	//! Collides two gimpact shapes
+	/*!
+	\pre shape0 and shape1 couldn't be btGImpactMeshShape objects
+	*/
+
+	void gimpact_vs_gimpact(const btCollisionObjectWrapper* body0Wrap,
+							const btCollisionObjectWrapper* body1Wrap,
+							const btGImpactShapeInterface* shape0,
+							const btGImpactShapeInterface* shape1);
+
+	void gimpact_vs_shape(const btCollisionObjectWrapper* body0Wrap,
+						  const btCollisionObjectWrapper* body1Wrap,
+						  const btGImpactShapeInterface* shape0,
+						  const btCollisionShape* shape1, bool swapped);
+
+	void gimpact_vs_compoundshape(const btCollisionObjectWrapper* body0Wrap,
+								  const btCollisionObjectWrapper* body1Wrap,
+								  const btGImpactShapeInterface* shape0,
+								  const btCompoundShape* shape1, bool swapped);
+
+	void gimpact_vs_concave(
+		const btCollisionObjectWrapper* body0Wrap,
+		const btCollisionObjectWrapper* body1Wrap,
+		const btGImpactShapeInterface* shape0,
+		const btConcaveShape* shape1, bool swapped);
+
+	/// Accessor/Mutator pairs for Part and triangleID
+	void setFace0(int value)
+	{
+		m_triface0 = value;
+	}
+	int getFace0()
+	{
+		return m_triface0;
+	}
+	void setFace1(int value)
+	{
+		m_triface1 = value;
+	}
+	int getFace1()
+	{
+		return m_triface1;
+	}
+	void setPart0(int value)
+	{
+		m_part0 = value;
+	}
+	int getPart0()
+	{
+		return m_part0;
+	}
+	void setPart1(int value)
+	{
+		m_part1 = value;
+	}
+	int getPart1()
+	{
+		return m_part1;
+	}
+};
+
+//algorithm details
+//#define BULLET_TRIANGLE_COLLISION 1
+#define GIMPACT_VS_PLANE_COLLISION 1
+
+#endif  //BT_GIMPACT_BVH_CONCAVE_COLLISION_ALGORITHM_H
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/btGImpactMassUtil.h b/engine/inc/bullet/BulletCollision/Gimpact/btGImpactMassUtil.h
new file mode 100644
index 00000000..1cde46ed
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/btGImpactMassUtil.h
@@ -0,0 +1,56 @@
+/*! \file btGImpactMassUtil.h
+\author Francisco Leon Najera
+*/
+/*
+This source file is part of GIMPACT Library.
+
+For the latest info, see http://gimpact.sourceforge.net/
+
+Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371.
+email: projectileman@yahoo.com
+
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef GIMPACT_MASS_UTIL_H
+#define GIMPACT_MASS_UTIL_H
+
+#include "LinearMath/btTransform.h"
+
+SIMD_FORCE_INLINE btVector3 gim_inertia_add_transformed(
+	const btVector3& source_inertia, const btVector3& added_inertia, const btTransform& transform)
+{
+	btMatrix3x3 rotatedTensor = transform.getBasis().scaled(added_inertia) * transform.getBasis().transpose();
+
+	btScalar x2 = transform.getOrigin()[0];
+	x2 *= x2;
+	btScalar y2 = transform.getOrigin()[1];
+	y2 *= y2;
+	btScalar z2 = transform.getOrigin()[2];
+	z2 *= z2;
+
+	btScalar ix = rotatedTensor[0][0] * (y2 + z2);
+	btScalar iy = rotatedTensor[1][1] * (x2 + z2);
+	btScalar iz = rotatedTensor[2][2] * (x2 + y2);
+
+	return btVector3(source_inertia[0] + ix, source_inertia[1] + iy, source_inertia[2] + iz);
+}
+
+SIMD_FORCE_INLINE btVector3 gim_get_point_inertia(const btVector3& point, btScalar mass)
+{
+	btScalar x2 = point[0] * point[0];
+	btScalar y2 = point[1] * point[1];
+	btScalar z2 = point[2] * point[2];
+	return btVector3(mass * (y2 + z2), mass * (x2 + z2), mass * (x2 + y2));
+}
+
+#endif  //GIMPACT_MESH_SHAPE_H
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/btGImpactQuantizedBvh.h b/engine/inc/bullet/BulletCollision/Gimpact/btGImpactQuantizedBvh.h
new file mode 100644
index 00000000..b231c1e8
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/btGImpactQuantizedBvh.h
@@ -0,0 +1,298 @@
+#ifndef GIM_QUANTIZED_SET_H_INCLUDED
+#define GIM_QUANTIZED_SET_H_INCLUDED
+
+/*! \file btGImpactQuantizedBvh.h
+\author Francisco Leon Najera
+*/
+/*
+This source file is part of GIMPACT Library.
+
+For the latest info, see http://gimpact.sourceforge.net/
+
+Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371.
+email: projectileman@yahoo.com
+
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "btGImpactBvh.h"
+#include "btQuantization.h"
+#include "btGImpactQuantizedBvhStructs.h"
+
+class GIM_QUANTIZED_BVH_NODE_ARRAY : public btAlignedObjectArray<BT_QUANTIZED_BVH_NODE>
+{
+};
+
+//! Basic Box tree structure
+class btQuantizedBvhTree
+{
+protected:
+	int m_num_nodes;
+	GIM_QUANTIZED_BVH_NODE_ARRAY m_node_array;
+	btAABB m_global_bound;
+	btVector3 m_bvhQuantization;
+
+protected:
+	void calc_quantization(GIM_BVH_DATA_ARRAY& primitive_boxes, btScalar boundMargin = btScalar(1.0));
+
+	int _sort_and_calc_splitting_index(
+		GIM_BVH_DATA_ARRAY& primitive_boxes,
+		int startIndex, int endIndex, int splitAxis);
+
+	int _calc_splitting_axis(GIM_BVH_DATA_ARRAY& primitive_boxes, int startIndex, int endIndex);
+
+	void _build_sub_tree(GIM_BVH_DATA_ARRAY& primitive_boxes, int startIndex, int endIndex);
+
+public:
+	btQuantizedBvhTree()
+	{
+		m_num_nodes = 0;
+	}
+
+	//! prototype functions for box tree management
+	//!@{
+	void build_tree(GIM_BVH_DATA_ARRAY& primitive_boxes);
+
+	SIMD_FORCE_INLINE void quantizePoint(
+		unsigned short* quantizedpoint, const btVector3& point) const
+	{
+		bt_quantize_clamp(quantizedpoint, point, m_global_bound.m_min, m_global_bound.m_max, m_bvhQuantization);
+	}
+
+	SIMD_FORCE_INLINE bool testQuantizedBoxOverlapp(
+		int node_index,
+		unsigned short* quantizedMin, unsigned short* quantizedMax) const
+	{
+		return m_node_array[node_index].testQuantizedBoxOverlapp(quantizedMin, quantizedMax);
+	}
+
+	SIMD_FORCE_INLINE void clearNodes()
+	{
+		m_node_array.clear();
+		m_num_nodes = 0;
+	}
+
+	//! node count
+	SIMD_FORCE_INLINE int getNodeCount() const
+	{
+		return m_num_nodes;
+	}
+
+	//! tells if the node is a leaf
+	SIMD_FORCE_INLINE bool isLeafNode(int nodeindex) const
+	{
+		return m_node_array[nodeindex].isLeafNode();
+	}
+
+	SIMD_FORCE_INLINE int getNodeData(int nodeindex) const
+	{
+		return m_node_array[nodeindex].getDataIndex();
+	}
+
+	SIMD_FORCE_INLINE void getNodeBound(int nodeindex, btAABB& bound) const
+	{
+		bound.m_min = bt_unquantize(
+			m_node_array[nodeindex].m_quantizedAabbMin,
+			m_global_bound.m_min, m_bvhQuantization);
+
+		bound.m_max = bt_unquantize(
+			m_node_array[nodeindex].m_quantizedAabbMax,
+			m_global_bound.m_min, m_bvhQuantization);
+	}
+
+	SIMD_FORCE_INLINE void setNodeBound(int nodeindex, const btAABB& bound)
+	{
+		bt_quantize_clamp(m_node_array[nodeindex].m_quantizedAabbMin,
+						  bound.m_min,
+						  m_global_bound.m_min,
+						  m_global_bound.m_max,
+						  m_bvhQuantization);
+
+		bt_quantize_clamp(m_node_array[nodeindex].m_quantizedAabbMax,
+						  bound.m_max,
+						  m_global_bound.m_min,
+						  m_global_bound.m_max,
+						  m_bvhQuantization);
+	}
+
+	SIMD_FORCE_INLINE int getLeftNode(int nodeindex) const
+	{
+		return nodeindex + 1;
+	}
+
+	SIMD_FORCE_INLINE int getRightNode(int nodeindex) const
+	{
+		if (m_node_array[nodeindex + 1].isLeafNode()) return nodeindex + 2;
+		return nodeindex + 1 + m_node_array[nodeindex + 1].getEscapeIndex();
+	}
+
+	SIMD_FORCE_INLINE int getEscapeNodeIndex(int nodeindex) const
+	{
+		return m_node_array[nodeindex].getEscapeIndex();
+	}
+
+	SIMD_FORCE_INLINE const BT_QUANTIZED_BVH_NODE* get_node_pointer(int index = 0) const
+	{
+		return &m_node_array[index];
+	}
+
+	//!@}
+};
+
+//! Structure for containing Boxes
+/*!
+This class offers an structure for managing a box tree of primitives.
+Requires a Primitive prototype (like btPrimitiveManagerBase )
+*/
+class btGImpactQuantizedBvh
+{
+protected:
+	btQuantizedBvhTree m_box_tree;
+	btPrimitiveManagerBase* m_primitive_manager;
+
+protected:
+	//stackless refit
+	void refit();
+
+public:
+	//! this constructor doesn't build the tree. you must call	buildSet
+	btGImpactQuantizedBvh()
+	{
+		m_primitive_manager = NULL;
+	}
+
+	//! this constructor doesn't build the tree. you must call	buildSet
+	btGImpactQuantizedBvh(btPrimitiveManagerBase* primitive_manager)
+	{
+		m_primitive_manager = primitive_manager;
+	}
+
+	SIMD_FORCE_INLINE btAABB getGlobalBox() const
+	{
+		btAABB totalbox;
+		getNodeBound(0, totalbox);
+		return totalbox;
+	}
+
+	SIMD_FORCE_INLINE void setPrimitiveManager(btPrimitiveManagerBase* primitive_manager)
+	{
+		m_primitive_manager = primitive_manager;
+	}
+
+	SIMD_FORCE_INLINE btPrimitiveManagerBase* getPrimitiveManager() const
+	{
+		return m_primitive_manager;
+	}
+
+	//! node manager prototype functions
+	///@{
+
+	//! this attemps to refit the box set.
+	SIMD_FORCE_INLINE void update()
+	{
+		refit();
+	}
+
+	//! this rebuild the entire set
+	void buildSet();
+
+	//! returns the indices of the primitives in the m_primitive_manager
+	bool boxQuery(const btAABB& box, btAlignedObjectArray<int>& collided_results) const;
+
+	//! returns the indices of the primitives in the m_primitive_manager
+	SIMD_FORCE_INLINE bool boxQueryTrans(const btAABB& box,
+										 const btTransform& transform, btAlignedObjectArray<int>& collided_results) const
+	{
+		btAABB transbox = box;
+		transbox.appy_transform(transform);
+		return boxQuery(transbox, collided_results);
+	}
+
+	//! returns the indices of the primitives in the m_primitive_manager
+	bool rayQuery(
+		const btVector3& ray_dir, const btVector3& ray_origin,
+		btAlignedObjectArray<int>& collided_results) const;
+
+	//! tells if this set has hierarcht
+	SIMD_FORCE_INLINE bool hasHierarchy() const
+	{
+		return true;
+	}
+
+	//! tells if this set is a trimesh
+	SIMD_FORCE_INLINE bool isTrimesh() const
+	{
+		return m_primitive_manager->is_trimesh();
+	}
+
+	//! node count
+	SIMD_FORCE_INLINE int getNodeCount() const
+	{
+		return m_box_tree.getNodeCount();
+	}
+
+	//! tells if the node is a leaf
+	SIMD_FORCE_INLINE bool isLeafNode(int nodeindex) const
+	{
+		return m_box_tree.isLeafNode(nodeindex);
+	}
+
+	SIMD_FORCE_INLINE int getNodeData(int nodeindex) const
+	{
+		return m_box_tree.getNodeData(nodeindex);
+	}
+
+	SIMD_FORCE_INLINE void getNodeBound(int nodeindex, btAABB& bound) const
+	{
+		m_box_tree.getNodeBound(nodeindex, bound);
+	}
+
+	SIMD_FORCE_INLINE void setNodeBound(int nodeindex, const btAABB& bound)
+	{
+		m_box_tree.setNodeBound(nodeindex, bound);
+	}
+
+	SIMD_FORCE_INLINE int getLeftNode(int nodeindex) const
+	{
+		return m_box_tree.getLeftNode(nodeindex);
+	}
+
+	SIMD_FORCE_INLINE int getRightNode(int nodeindex) const
+	{
+		return m_box_tree.getRightNode(nodeindex);
+	}
+
+	SIMD_FORCE_INLINE int getEscapeNodeIndex(int nodeindex) const
+	{
+		return m_box_tree.getEscapeNodeIndex(nodeindex);
+	}
+
+	SIMD_FORCE_INLINE void getNodeTriangle(int nodeindex, btPrimitiveTriangle& triangle) const
+	{
+		m_primitive_manager->get_primitive_triangle(getNodeData(nodeindex), triangle);
+	}
+
+	SIMD_FORCE_INLINE const BT_QUANTIZED_BVH_NODE* get_node_pointer(int index = 0) const
+	{
+		return m_box_tree.get_node_pointer(index);
+	}
+
+#ifdef TRI_COLLISION_PROFILING
+	static float getAverageTreeCollisionTime();
+#endif  //TRI_COLLISION_PROFILING
+
+	static void find_collision(const btGImpactQuantizedBvh* boxset1, const btTransform& trans1,
+							   const btGImpactQuantizedBvh* boxset2, const btTransform& trans2,
+							   btPairSet& collision_pairs);
+};
+
+#endif  // GIM_BOXPRUNING_H_INCLUDED
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/btGImpactQuantizedBvhStructs.h b/engine/inc/bullet/BulletCollision/Gimpact/btGImpactQuantizedBvhStructs.h
new file mode 100644
index 00000000..bd50cb5b
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/btGImpactQuantizedBvhStructs.h
@@ -0,0 +1,91 @@
+#ifndef GIM_QUANTIZED_SET_STRUCTS_H_INCLUDED
+#define GIM_QUANTIZED_SET_STRUCTS_H_INCLUDED
+
+/*! \file btGImpactQuantizedBvh.h
+\author Francisco Leon Najera
+*/
+/*
+This source file is part of GIMPACT Library.
+
+For the latest info, see http://gimpact.sourceforge.net/
+
+Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371.
+email: projectileman@yahoo.com
+
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "btGImpactBvh.h"
+#include "btQuantization.h"
+
+///btQuantizedBvhNode is a compressed aabb node, 16 bytes.
+///Node can be used for leafnode or internal node. Leafnodes can point to 32-bit triangle index (non-negative range).
+ATTRIBUTE_ALIGNED16(struct)
+BT_QUANTIZED_BVH_NODE
+{
+	//12 bytes
+	unsigned short int m_quantizedAabbMin[3];
+	unsigned short int m_quantizedAabbMax[3];
+	//4 bytes
+	int m_escapeIndexOrDataIndex;
+
+	BT_QUANTIZED_BVH_NODE()
+	{
+		m_escapeIndexOrDataIndex = 0;
+	}
+
+	SIMD_FORCE_INLINE bool isLeafNode() const
+	{
+		//skipindex is negative (internal node), triangleindex >=0 (leafnode)
+		return (m_escapeIndexOrDataIndex >= 0);
+	}
+
+	SIMD_FORCE_INLINE int getEscapeIndex() const
+	{
+		//btAssert(m_escapeIndexOrDataIndex < 0);
+		return -m_escapeIndexOrDataIndex;
+	}
+
+	SIMD_FORCE_INLINE void setEscapeIndex(int index)
+	{
+		m_escapeIndexOrDataIndex = -index;
+	}
+
+	SIMD_FORCE_INLINE int getDataIndex() const
+	{
+		//btAssert(m_escapeIndexOrDataIndex >= 0);
+
+		return m_escapeIndexOrDataIndex;
+	}
+
+	SIMD_FORCE_INLINE void setDataIndex(int index)
+	{
+		m_escapeIndexOrDataIndex = index;
+	}
+
+	SIMD_FORCE_INLINE bool testQuantizedBoxOverlapp(
+		unsigned short* quantizedMin, unsigned short* quantizedMax) const
+	{
+		if (m_quantizedAabbMin[0] > quantizedMax[0] ||
+			m_quantizedAabbMax[0] < quantizedMin[0] ||
+			m_quantizedAabbMin[1] > quantizedMax[1] ||
+			m_quantizedAabbMax[1] < quantizedMin[1] ||
+			m_quantizedAabbMin[2] > quantizedMax[2] ||
+			m_quantizedAabbMax[2] < quantizedMin[2])
+		{
+			return false;
+		}
+		return true;
+	}
+};
+
+#endif  // GIM_QUANTIZED_SET_STRUCTS_H_INCLUDED
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/btGImpactShape.h b/engine/inc/bullet/BulletCollision/Gimpact/btGImpactShape.h
new file mode 100644
index 00000000..cc910795
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/btGImpactShape.h
@@ -0,0 +1,1115 @@
+/*! \file btGImpactShape.h
+\author Francisco Len Nßjera
+*/
+/*
+This source file is part of GIMPACT Library.
+
+For the latest info, see http://gimpact.sourceforge.net/
+
+Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371.
+email: projectileman@yahoo.com
+
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef GIMPACT_SHAPE_H
+#define GIMPACT_SHAPE_H
+
+#include "BulletCollision/CollisionShapes/btCollisionShape.h"
+#include "BulletCollision/CollisionShapes/btTriangleShape.h"
+#include "BulletCollision/CollisionShapes/btStridingMeshInterface.h"
+#include "BulletCollision/CollisionShapes/btCollisionMargin.h"
+#include "BulletCollision/CollisionDispatch/btCollisionWorld.h"
+#include "BulletCollision/CollisionShapes/btConcaveShape.h"
+#include "BulletCollision/CollisionShapes/btTetrahedronShape.h"
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btMatrix3x3.h"
+#include "LinearMath/btAlignedObjectArray.h"
+
+#include "btGImpactQuantizedBvh.h"  // box tree class
+
+//! declare Quantized trees, (you can change to float based trees)
+typedef btGImpactQuantizedBvh btGImpactBoxSet;
+
+enum eGIMPACT_SHAPE_TYPE
+{
+	CONST_GIMPACT_COMPOUND_SHAPE = 0,
+	CONST_GIMPACT_TRIMESH_SHAPE_PART,
+	CONST_GIMPACT_TRIMESH_SHAPE
+};
+
+//! Helper class for tetrahedrons
+class btTetrahedronShapeEx : public btBU_Simplex1to4
+{
+public:
+	btTetrahedronShapeEx()
+	{
+		m_numVertices = 4;
+	}
+
+	SIMD_FORCE_INLINE void setVertices(
+		const btVector3& v0, const btVector3& v1,
+		const btVector3& v2, const btVector3& v3)
+	{
+		m_vertices[0] = v0;
+		m_vertices[1] = v1;
+		m_vertices[2] = v2;
+		m_vertices[3] = v3;
+		recalcLocalAabb();
+	}
+};
+
+//! Base class for gimpact shapes
+class btGImpactShapeInterface : public btConcaveShape
+{
+protected:
+	btAABB m_localAABB;
+	bool m_needs_update;
+	btVector3 localScaling;
+	btGImpactBoxSet m_box_set;  // optionally boxset
+
+	//! use this function for perfofm refit in bounding boxes
+	//! use this function for perfofm refit in bounding boxes
+	virtual void calcLocalAABB()
+	{
+		lockChildShapes();
+		if (m_box_set.getNodeCount() == 0)
+		{
+			m_box_set.buildSet();
+		}
+		else
+		{
+			m_box_set.update();
+		}
+		unlockChildShapes();
+
+		m_localAABB = m_box_set.getGlobalBox();
+	}
+
+public:
+	btGImpactShapeInterface()
+	{
+		m_shapeType = GIMPACT_SHAPE_PROXYTYPE;
+		m_localAABB.invalidate();
+		m_needs_update = true;
+		localScaling.setValue(1.f, 1.f, 1.f);
+	}
+
+	//! performs refit operation
+	/*!
+	Updates the entire Box set of this shape.
+	\pre postUpdate() must be called for attemps to calculating the box set, else this function
+		will does nothing.
+	\post if m_needs_update == true, then it calls calcLocalAABB();
+	*/
+	SIMD_FORCE_INLINE void updateBound()
+	{
+		if (!m_needs_update) return;
+		calcLocalAABB();
+		m_needs_update = false;
+	}
+
+	//! If the Bounding box is not updated, then this class attemps to calculate it.
+	/*!
+    \post Calls updateBound() for update the box set.
+    */
+	void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const
+	{
+		btAABB transformedbox = m_localAABB;
+		transformedbox.appy_transform(t);
+		aabbMin = transformedbox.m_min;
+		aabbMax = transformedbox.m_max;
+	}
+
+	//! Tells to this object that is needed to refit the box set
+	virtual void postUpdate()
+	{
+		m_needs_update = true;
+	}
+
+	//! Obtains the local box, which is the global calculated box of the total of subshapes
+	SIMD_FORCE_INLINE const btAABB& getLocalBox()
+	{
+		return m_localAABB;
+	}
+
+	virtual int getShapeType() const
+	{
+		return GIMPACT_SHAPE_PROXYTYPE;
+	}
+
+	/*!
+	\post You must call updateBound() for update the box set.
+	*/
+	virtual void setLocalScaling(const btVector3& scaling)
+	{
+		localScaling = scaling;
+		postUpdate();
+	}
+
+	virtual const btVector3& getLocalScaling() const
+	{
+		return localScaling;
+	}
+
+	virtual void setMargin(btScalar margin)
+	{
+		m_collisionMargin = margin;
+		int i = getNumChildShapes();
+		while (i--)
+		{
+			btCollisionShape* child = getChildShape(i);
+			child->setMargin(margin);
+		}
+
+		m_needs_update = true;
+	}
+
+	//! Subshape member functions
+	//!@{
+
+	//! Base method for determinig which kind of GIMPACT shape we get
+	virtual eGIMPACT_SHAPE_TYPE getGImpactShapeType() const = 0;
+
+	//! gets boxset
+	SIMD_FORCE_INLINE const btGImpactBoxSet* getBoxSet() const
+	{
+		return &m_box_set;
+	}
+
+	//! Determines if this class has a hierarchy structure for sorting its primitives
+	SIMD_FORCE_INLINE bool hasBoxSet() const
+	{
+		if (m_box_set.getNodeCount() == 0) return false;
+		return true;
+	}
+
+	//! Obtains the primitive manager
+	virtual const btPrimitiveManagerBase* getPrimitiveManager() const = 0;
+
+	//! Gets the number of children
+	virtual int getNumChildShapes() const = 0;
+
+	//! if true, then its children must get transforms.
+	virtual bool childrenHasTransform() const = 0;
+
+	//! Determines if this shape has triangles
+	virtual bool needsRetrieveTriangles() const = 0;
+
+	//! Determines if this shape has tetrahedrons
+	virtual bool needsRetrieveTetrahedrons() const = 0;
+
+	virtual void getBulletTriangle(int prim_index, btTriangleShapeEx& triangle) const = 0;
+
+	virtual void getBulletTetrahedron(int prim_index, btTetrahedronShapeEx& tetrahedron) const = 0;
+
+	//! call when reading child shapes
+	virtual void lockChildShapes() const
+	{
+	}
+
+	virtual void unlockChildShapes() const
+	{
+	}
+
+	//! if this trimesh
+	SIMD_FORCE_INLINE void getPrimitiveTriangle(int index, btPrimitiveTriangle& triangle) const
+	{
+		getPrimitiveManager()->get_primitive_triangle(index, triangle);
+	}
+
+	//! Retrieves the bound from a child
+	/*!
+    */
+	virtual void getChildAabb(int child_index, const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const
+	{
+		btAABB child_aabb;
+		getPrimitiveManager()->get_primitive_box(child_index, child_aabb);
+		child_aabb.appy_transform(t);
+		aabbMin = child_aabb.m_min;
+		aabbMax = child_aabb.m_max;
+	}
+
+	//! Gets the children
+	virtual btCollisionShape* getChildShape(int index) = 0;
+
+	//! Gets the child
+	virtual const btCollisionShape* getChildShape(int index) const = 0;
+
+	//! Gets the children transform
+	virtual btTransform getChildTransform(int index) const = 0;
+
+	//! Sets the children transform
+	/*!
+	\post You must call updateBound() for update the box set.
+	*/
+	virtual void setChildTransform(int index, const btTransform& transform) = 0;
+
+	//!@}
+
+	//! virtual method for ray collision
+	virtual void rayTest(const btVector3& rayFrom, const btVector3& rayTo, btCollisionWorld::RayResultCallback& resultCallback) const
+	{
+		(void)rayFrom;
+		(void)rayTo;
+		(void)resultCallback;
+	}
+
+	//! Function for retrieve triangles.
+	/*!
+	It gives the triangles in local space
+	*/
+	virtual void processAllTriangles(btTriangleCallback* callback, const btVector3& aabbMin, const btVector3& aabbMax) const
+	{
+		(void)callback;
+		(void)aabbMin;
+		(void)aabbMax;
+	}
+
+	//! Function for retrieve triangles.
+	/*!
+	It gives the triangles in local space
+	*/
+	virtual void processAllTrianglesRay(btTriangleCallback* /*callback*/, const btVector3& /*rayFrom*/, const btVector3& /*rayTo*/) const
+	{
+	}
+
+	//!@}
+};
+
+//! btGImpactCompoundShape allows to handle multiple btCollisionShape objects at once
+/*!
+This class only can manage Convex subshapes
+*/
+class btGImpactCompoundShape : public btGImpactShapeInterface
+{
+public:
+	//! compound primitive manager
+	class CompoundPrimitiveManager : public btPrimitiveManagerBase
+	{
+	public:
+		virtual ~CompoundPrimitiveManager() {}
+		btGImpactCompoundShape* m_compoundShape;
+
+		CompoundPrimitiveManager(const CompoundPrimitiveManager& compound)
+			: btPrimitiveManagerBase()
+		{
+			m_compoundShape = compound.m_compoundShape;
+		}
+
+		CompoundPrimitiveManager(btGImpactCompoundShape* compoundShape)
+		{
+			m_compoundShape = compoundShape;
+		}
+
+		CompoundPrimitiveManager()
+		{
+			m_compoundShape = NULL;
+		}
+
+		virtual bool is_trimesh() const
+		{
+			return false;
+		}
+
+		virtual int get_primitive_count() const
+		{
+			return (int)m_compoundShape->getNumChildShapes();
+		}
+
+		virtual void get_primitive_box(int prim_index, btAABB& primbox) const
+		{
+			btTransform prim_trans;
+			if (m_compoundShape->childrenHasTransform())
+			{
+				prim_trans = m_compoundShape->getChildTransform(prim_index);
+			}
+			else
+			{
+				prim_trans.setIdentity();
+			}
+			const btCollisionShape* shape = m_compoundShape->getChildShape(prim_index);
+			shape->getAabb(prim_trans, primbox.m_min, primbox.m_max);
+		}
+
+		virtual void get_primitive_triangle(int prim_index, btPrimitiveTriangle& triangle) const
+		{
+			btAssert(0);
+			(void)prim_index;
+			(void)triangle;
+		}
+	};
+
+protected:
+	CompoundPrimitiveManager m_primitive_manager;
+	btAlignedObjectArray<btTransform> m_childTransforms;
+	btAlignedObjectArray<btCollisionShape*> m_childShapes;
+
+public:
+	btGImpactCompoundShape(bool children_has_transform = true)
+	{
+		(void)children_has_transform;
+		m_primitive_manager.m_compoundShape = this;
+		m_box_set.setPrimitiveManager(&m_primitive_manager);
+	}
+
+	virtual ~btGImpactCompoundShape()
+	{
+	}
+
+	//! if true, then its children must get transforms.
+	virtual bool childrenHasTransform() const
+	{
+		if (m_childTransforms.size() == 0) return false;
+		return true;
+	}
+
+	//! Obtains the primitive manager
+	virtual const btPrimitiveManagerBase* getPrimitiveManager() const
+	{
+		return &m_primitive_manager;
+	}
+
+	//! Obtains the compopund primitive manager
+	SIMD_FORCE_INLINE CompoundPrimitiveManager* getCompoundPrimitiveManager()
+	{
+		return &m_primitive_manager;
+	}
+
+	//! Gets the number of children
+	virtual int getNumChildShapes() const
+	{
+		return m_childShapes.size();
+	}
+
+	//! Use this method for adding children. Only Convex shapes are allowed.
+	void addChildShape(const btTransform& localTransform, btCollisionShape* shape)
+	{
+		btAssert(shape->isConvex());
+		m_childTransforms.push_back(localTransform);
+		m_childShapes.push_back(shape);
+	}
+
+	//! Use this method for adding children. Only Convex shapes are allowed.
+	void addChildShape(btCollisionShape* shape)
+	{
+		btAssert(shape->isConvex());
+		m_childShapes.push_back(shape);
+	}
+
+	//! Gets the children
+	virtual btCollisionShape* getChildShape(int index)
+	{
+		return m_childShapes[index];
+	}
+
+	//! Gets the children
+	virtual const btCollisionShape* getChildShape(int index) const
+	{
+		return m_childShapes[index];
+	}
+
+	//! Retrieves the bound from a child
+	/*!
+    */
+	virtual void getChildAabb(int child_index, const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const
+	{
+		if (childrenHasTransform())
+		{
+			m_childShapes[child_index]->getAabb(t * m_childTransforms[child_index], aabbMin, aabbMax);
+		}
+		else
+		{
+			m_childShapes[child_index]->getAabb(t, aabbMin, aabbMax);
+		}
+	}
+
+	//! Gets the children transform
+	virtual btTransform getChildTransform(int index) const
+	{
+		btAssert(m_childTransforms.size() == m_childShapes.size());
+		return m_childTransforms[index];
+	}
+
+	//! Sets the children transform
+	/*!
+	\post You must call updateBound() for update the box set.
+	*/
+	virtual void setChildTransform(int index, const btTransform& transform)
+	{
+		btAssert(m_childTransforms.size() == m_childShapes.size());
+		m_childTransforms[index] = transform;
+		postUpdate();
+	}
+
+	//! Determines if this shape has triangles
+	virtual bool needsRetrieveTriangles() const
+	{
+		return false;
+	}
+
+	//! Determines if this shape has tetrahedrons
+	virtual bool needsRetrieveTetrahedrons() const
+	{
+		return false;
+	}
+
+	virtual void getBulletTriangle(int prim_index, btTriangleShapeEx& triangle) const
+	{
+		(void)prim_index;
+		(void)triangle;
+		btAssert(0);
+	}
+
+	virtual void getBulletTetrahedron(int prim_index, btTetrahedronShapeEx& tetrahedron) const
+	{
+		(void)prim_index;
+		(void)tetrahedron;
+		btAssert(0);
+	}
+
+	//! Calculates the exact inertia tensor for this shape
+	virtual void calculateLocalInertia(btScalar mass, btVector3& inertia) const;
+
+	virtual const char* getName() const
+	{
+		return "GImpactCompound";
+	}
+
+	virtual eGIMPACT_SHAPE_TYPE getGImpactShapeType() const
+	{
+		return CONST_GIMPACT_COMPOUND_SHAPE;
+	}
+};
+
+//! This class manages a sub part of a mesh supplied by the btStridingMeshInterface interface.
+/*!
+- Simply create this shape by passing the btStridingMeshInterface to the constructor btGImpactMeshShapePart, then you must call updateBound() after creating the mesh
+- When making operations with this shape, you must call <b>lock</b> before accessing to the trimesh primitives, and then call <b>unlock</b>
+- You can handle deformable meshes with this shape, by calling postUpdate() every time when changing the mesh vertices.
+
+*/
+class btGImpactMeshShapePart : public btGImpactShapeInterface
+{
+public:
+	//! Trimesh primitive manager
+	/*!
+	Manages the info from btStridingMeshInterface object and controls the Lock/Unlock mechanism
+	*/
+	class TrimeshPrimitiveManager : public btPrimitiveManagerBase
+	{
+	public:
+		btScalar m_margin;
+		btStridingMeshInterface* m_meshInterface;
+		btVector3 m_scale;
+		int m_part;
+		int m_lock_count;
+		const unsigned char* vertexbase;
+		int numverts;
+		PHY_ScalarType type;
+		int stride;
+		const unsigned char* indexbase;
+		int indexstride;
+		int numfaces;
+		PHY_ScalarType indicestype;
+
+		TrimeshPrimitiveManager()
+		{
+			m_meshInterface = NULL;
+			m_part = 0;
+			m_margin = 0.01f;
+			m_scale = btVector3(1.f, 1.f, 1.f);
+			m_lock_count = 0;
+			vertexbase = 0;
+			numverts = 0;
+			stride = 0;
+			indexbase = 0;
+			indexstride = 0;
+			numfaces = 0;
+		}
+
+		TrimeshPrimitiveManager(const TrimeshPrimitiveManager& manager)
+			: btPrimitiveManagerBase()
+		{
+			m_meshInterface = manager.m_meshInterface;
+			m_part = manager.m_part;
+			m_margin = manager.m_margin;
+			m_scale = manager.m_scale;
+			m_lock_count = 0;
+			vertexbase = 0;
+			numverts = 0;
+			stride = 0;
+			indexbase = 0;
+			indexstride = 0;
+			numfaces = 0;
+		}
+
+		TrimeshPrimitiveManager(
+			btStridingMeshInterface* meshInterface, int part)
+		{
+			m_meshInterface = meshInterface;
+			m_part = part;
+			m_scale = m_meshInterface->getScaling();
+			m_margin = 0.1f;
+			m_lock_count = 0;
+			vertexbase = 0;
+			numverts = 0;
+			stride = 0;
+			indexbase = 0;
+			indexstride = 0;
+			numfaces = 0;
+		}
+
+		virtual ~TrimeshPrimitiveManager() {}
+
+		void lock()
+		{
+			if (m_lock_count > 0)
+			{
+				m_lock_count++;
+				return;
+			}
+			m_meshInterface->getLockedReadOnlyVertexIndexBase(
+				&vertexbase, numverts,
+				type, stride, &indexbase, indexstride, numfaces, indicestype, m_part);
+
+			m_lock_count = 1;
+		}
+
+		void unlock()
+		{
+			if (m_lock_count == 0) return;
+			if (m_lock_count > 1)
+			{
+				--m_lock_count;
+				return;
+			}
+			m_meshInterface->unLockReadOnlyVertexBase(m_part);
+			vertexbase = NULL;
+			m_lock_count = 0;
+		}
+
+		virtual bool is_trimesh() const
+		{
+			return true;
+		}
+
+		virtual int get_primitive_count() const
+		{
+			return (int)numfaces;
+		}
+
+		SIMD_FORCE_INLINE int get_vertex_count() const
+		{
+			return (int)numverts;
+		}
+
+		SIMD_FORCE_INLINE void get_indices(int face_index, unsigned int& i0, unsigned int& i1, unsigned int& i2) const
+		{
+			if (indicestype == PHY_SHORT)
+			{
+				unsigned short* s_indices = (unsigned short*)(indexbase + face_index * indexstride);
+				i0 = s_indices[0];
+				i1 = s_indices[1];
+				i2 = s_indices[2];
+			}
+			else if (indicestype == PHY_INTEGER)
+			{
+				unsigned int* i_indices = (unsigned int*)(indexbase + face_index * indexstride);
+				i0 = i_indices[0];
+				i1 = i_indices[1];
+				i2 = i_indices[2];
+			}
+			else
+			{
+				btAssert(indicestype == PHY_UCHAR);
+				unsigned char* i_indices = (unsigned char*)(indexbase + face_index * indexstride);
+				i0 = i_indices[0];
+				i1 = i_indices[1];
+				i2 = i_indices[2];
+			}
+		}
+
+		SIMD_FORCE_INLINE void get_vertex(unsigned int vertex_index, btVector3& vertex) const
+		{
+			if (type == PHY_DOUBLE)
+			{
+				double* dvertices = (double*)(vertexbase + vertex_index * stride);
+				vertex[0] = btScalar(dvertices[0] * m_scale[0]);
+				vertex[1] = btScalar(dvertices[1] * m_scale[1]);
+				vertex[2] = btScalar(dvertices[2] * m_scale[2]);
+			}
+			else
+			{
+				float* svertices = (float*)(vertexbase + vertex_index * stride);
+				vertex[0] = svertices[0] * m_scale[0];
+				vertex[1] = svertices[1] * m_scale[1];
+				vertex[2] = svertices[2] * m_scale[2];
+			}
+		}
+
+		virtual void get_primitive_box(int prim_index, btAABB& primbox) const
+		{
+			btPrimitiveTriangle triangle;
+			get_primitive_triangle(prim_index, triangle);
+			primbox.calc_from_triangle_margin(
+				triangle.m_vertices[0],
+				triangle.m_vertices[1], triangle.m_vertices[2], triangle.m_margin);
+		}
+
+		virtual void get_primitive_triangle(int prim_index, btPrimitiveTriangle& triangle) const
+		{
+			unsigned int indices[3];
+			get_indices(prim_index, indices[0], indices[1], indices[2]);
+			get_vertex(indices[0], triangle.m_vertices[0]);
+			get_vertex(indices[1], triangle.m_vertices[1]);
+			get_vertex(indices[2], triangle.m_vertices[2]);
+			triangle.m_margin = m_margin;
+		}
+
+		SIMD_FORCE_INLINE void get_bullet_triangle(int prim_index, btTriangleShapeEx& triangle) const
+		{
+			unsigned int indices[3];
+			get_indices(prim_index, indices[0], indices[1], indices[2]);
+			get_vertex(indices[0], triangle.m_vertices1[0]);
+			get_vertex(indices[1], triangle.m_vertices1[1]);
+			get_vertex(indices[2], triangle.m_vertices1[2]);
+			triangle.setMargin(m_margin);
+		}
+	};
+
+protected:
+	TrimeshPrimitiveManager m_primitive_manager;
+
+public:
+	btGImpactMeshShapePart()
+	{
+		m_box_set.setPrimitiveManager(&m_primitive_manager);
+	}
+
+	btGImpactMeshShapePart(btStridingMeshInterface* meshInterface, int part);
+	virtual ~btGImpactMeshShapePart();
+
+	//! if true, then its children must get transforms.
+	virtual bool childrenHasTransform() const
+	{
+		return false;
+	}
+
+	//! call when reading child shapes
+	virtual void lockChildShapes() const;
+	virtual void unlockChildShapes() const;
+
+	//! Gets the number of children
+	virtual int getNumChildShapes() const
+	{
+		return m_primitive_manager.get_primitive_count();
+	}
+
+	//! Gets the children
+	virtual btCollisionShape* getChildShape(int index)
+	{
+		(void)index;
+		btAssert(0);
+		return NULL;
+	}
+
+	//! Gets the child
+	virtual const btCollisionShape* getChildShape(int index) const
+	{
+		(void)index;
+		btAssert(0);
+		return NULL;
+	}
+
+	//! Gets the children transform
+	virtual btTransform getChildTransform(int index) const
+	{
+		(void)index;
+		btAssert(0);
+		return btTransform();
+	}
+
+	//! Sets the children transform
+	/*!
+	\post You must call updateBound() for update the box set.
+	*/
+	virtual void setChildTransform(int index, const btTransform& transform)
+	{
+		(void)index;
+		(void)transform;
+		btAssert(0);
+	}
+
+	//! Obtains the primitive manager
+	virtual const btPrimitiveManagerBase* getPrimitiveManager() const
+	{
+		return &m_primitive_manager;
+	}
+
+	SIMD_FORCE_INLINE TrimeshPrimitiveManager* getTrimeshPrimitiveManager()
+	{
+		return &m_primitive_manager;
+	}
+
+	virtual void calculateLocalInertia(btScalar mass, btVector3& inertia) const;
+
+	virtual const char* getName() const
+	{
+		return "GImpactMeshShapePart";
+	}
+
+	virtual eGIMPACT_SHAPE_TYPE getGImpactShapeType() const
+	{
+		return CONST_GIMPACT_TRIMESH_SHAPE_PART;
+	}
+
+	//! Determines if this shape has triangles
+	virtual bool needsRetrieveTriangles() const
+	{
+		return true;
+	}
+
+	//! Determines if this shape has tetrahedrons
+	virtual bool needsRetrieveTetrahedrons() const
+	{
+		return false;
+	}
+
+	virtual void getBulletTriangle(int prim_index, btTriangleShapeEx& triangle) const
+	{
+		m_primitive_manager.get_bullet_triangle(prim_index, triangle);
+	}
+
+	virtual void getBulletTetrahedron(int prim_index, btTetrahedronShapeEx& tetrahedron) const
+	{
+		(void)prim_index;
+		(void)tetrahedron;
+		btAssert(0);
+	}
+
+	SIMD_FORCE_INLINE int getVertexCount() const
+	{
+		return m_primitive_manager.get_vertex_count();
+	}
+
+	SIMD_FORCE_INLINE void getVertex(int vertex_index, btVector3& vertex) const
+	{
+		m_primitive_manager.get_vertex(vertex_index, vertex);
+	}
+
+	SIMD_FORCE_INLINE void setMargin(btScalar margin)
+	{
+		m_primitive_manager.m_margin = margin;
+		postUpdate();
+	}
+
+	SIMD_FORCE_INLINE btScalar getMargin() const
+	{
+		return m_primitive_manager.m_margin;
+	}
+
+	virtual void setLocalScaling(const btVector3& scaling)
+	{
+		m_primitive_manager.m_scale = scaling;
+		postUpdate();
+	}
+
+	virtual const btVector3& getLocalScaling() const
+	{
+		return m_primitive_manager.m_scale;
+	}
+
+	SIMD_FORCE_INLINE int getPart() const
+	{
+		return (int)m_primitive_manager.m_part;
+	}
+
+	virtual void processAllTriangles(btTriangleCallback* callback, const btVector3& aabbMin, const btVector3& aabbMax) const;
+	virtual void processAllTrianglesRay(btTriangleCallback* callback, const btVector3& rayFrom, const btVector3& rayTo) const;
+};
+
+//! This class manages a mesh supplied by the btStridingMeshInterface interface.
+/*!
+Set of btGImpactMeshShapePart parts
+- Simply create this shape by passing the btStridingMeshInterface to the constructor btGImpactMeshShape, then you must call updateBound() after creating the mesh
+
+- You can handle deformable meshes with this shape, by calling postUpdate() every time when changing the mesh vertices.
+
+*/
+class btGImpactMeshShape : public btGImpactShapeInterface
+{
+	btStridingMeshInterface* m_meshInterface;
+
+protected:
+	btAlignedObjectArray<btGImpactMeshShapePart*> m_mesh_parts;
+	void buildMeshParts(btStridingMeshInterface* meshInterface)
+	{
+		for (int i = 0; i < meshInterface->getNumSubParts(); ++i)
+		{
+			btGImpactMeshShapePart* newpart = new btGImpactMeshShapePart(meshInterface, i);
+			m_mesh_parts.push_back(newpart);
+		}
+	}
+
+	//! use this function for perfofm refit in bounding boxes
+	virtual void calcLocalAABB()
+	{
+		m_localAABB.invalidate();
+		int i = m_mesh_parts.size();
+		while (i--)
+		{
+			m_mesh_parts[i]->updateBound();
+			m_localAABB.merge(m_mesh_parts[i]->getLocalBox());
+		}
+	}
+
+public:
+	btGImpactMeshShape(btStridingMeshInterface* meshInterface)
+	{
+		m_meshInterface = meshInterface;
+		buildMeshParts(meshInterface);
+	}
+
+	virtual ~btGImpactMeshShape()
+	{
+		int i = m_mesh_parts.size();
+		while (i--)
+		{
+			btGImpactMeshShapePart* part = m_mesh_parts[i];
+			delete part;
+		}
+		m_mesh_parts.clear();
+	}
+
+	btStridingMeshInterface* getMeshInterface()
+	{
+		return m_meshInterface;
+	}
+
+	const btStridingMeshInterface* getMeshInterface() const
+	{
+		return m_meshInterface;
+	}
+
+	int getMeshPartCount() const
+	{
+		return m_mesh_parts.size();
+	}
+
+	btGImpactMeshShapePart* getMeshPart(int index)
+	{
+		return m_mesh_parts[index];
+	}
+
+	const btGImpactMeshShapePart* getMeshPart(int index) const
+	{
+		return m_mesh_parts[index];
+	}
+
+	virtual void setLocalScaling(const btVector3& scaling)
+	{
+		localScaling = scaling;
+
+		int i = m_mesh_parts.size();
+		while (i--)
+		{
+			btGImpactMeshShapePart* part = m_mesh_parts[i];
+			part->setLocalScaling(scaling);
+		}
+
+		m_needs_update = true;
+	}
+
+	virtual void setMargin(btScalar margin)
+	{
+		m_collisionMargin = margin;
+
+		int i = m_mesh_parts.size();
+		while (i--)
+		{
+			btGImpactMeshShapePart* part = m_mesh_parts[i];
+			part->setMargin(margin);
+		}
+
+		m_needs_update = true;
+	}
+
+	//! Tells to this object that is needed to refit all the meshes
+	virtual void postUpdate()
+	{
+		int i = m_mesh_parts.size();
+		while (i--)
+		{
+			btGImpactMeshShapePart* part = m_mesh_parts[i];
+			part->postUpdate();
+		}
+
+		m_needs_update = true;
+	}
+
+	virtual void calculateLocalInertia(btScalar mass, btVector3& inertia) const;
+
+	//! Obtains the primitive manager
+	virtual const btPrimitiveManagerBase* getPrimitiveManager() const
+	{
+		btAssert(0);
+		return NULL;
+	}
+
+	//! Gets the number of children
+	virtual int getNumChildShapes() const
+	{
+		btAssert(0);
+		return 0;
+	}
+
+	//! if true, then its children must get transforms.
+	virtual bool childrenHasTransform() const
+	{
+		btAssert(0);
+		return false;
+	}
+
+	//! Determines if this shape has triangles
+	virtual bool needsRetrieveTriangles() const
+	{
+		btAssert(0);
+		return false;
+	}
+
+	//! Determines if this shape has tetrahedrons
+	virtual bool needsRetrieveTetrahedrons() const
+	{
+		btAssert(0);
+		return false;
+	}
+
+	virtual void getBulletTriangle(int prim_index, btTriangleShapeEx& triangle) const
+	{
+		(void)prim_index;
+		(void)triangle;
+		btAssert(0);
+	}
+
+	virtual void getBulletTetrahedron(int prim_index, btTetrahedronShapeEx& tetrahedron) const
+	{
+		(void)prim_index;
+		(void)tetrahedron;
+		btAssert(0);
+	}
+
+	//! call when reading child shapes
+	virtual void lockChildShapes() const
+	{
+		btAssert(0);
+	}
+
+	virtual void unlockChildShapes() const
+	{
+		btAssert(0);
+	}
+
+	//! Retrieves the bound from a child
+	/*!
+    */
+	virtual void getChildAabb(int child_index, const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const
+	{
+		(void)child_index;
+		(void)t;
+		(void)aabbMin;
+		(void)aabbMax;
+		btAssert(0);
+	}
+
+	//! Gets the children
+	virtual btCollisionShape* getChildShape(int index)
+	{
+		(void)index;
+		btAssert(0);
+		return NULL;
+	}
+
+	//! Gets the child
+	virtual const btCollisionShape* getChildShape(int index) const
+	{
+		(void)index;
+		btAssert(0);
+		return NULL;
+	}
+
+	//! Gets the children transform
+	virtual btTransform getChildTransform(int index) const
+	{
+		(void)index;
+		btAssert(0);
+		return btTransform();
+	}
+
+	//! Sets the children transform
+	/*!
+	\post You must call updateBound() for update the box set.
+	*/
+	virtual void setChildTransform(int index, const btTransform& transform)
+	{
+		(void)index;
+		(void)transform;
+		btAssert(0);
+	}
+
+	virtual eGIMPACT_SHAPE_TYPE getGImpactShapeType() const
+	{
+		return CONST_GIMPACT_TRIMESH_SHAPE;
+	}
+
+	virtual const char* getName() const
+	{
+		return "GImpactMesh";
+	}
+
+	virtual void rayTest(const btVector3& rayFrom, const btVector3& rayTo, btCollisionWorld::RayResultCallback& resultCallback) const;
+
+	//! Function for retrieve triangles.
+	/*!
+	It gives the triangles in local space
+	*/
+	virtual void processAllTriangles(btTriangleCallback* callback, const btVector3& aabbMin, const btVector3& aabbMax) const;
+
+	virtual void processAllTrianglesRay(btTriangleCallback* callback, const btVector3& rayFrom, const btVector3& rayTo) const;
+
+	virtual int calculateSerializeBufferSize() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
+};
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct btGImpactMeshShapeData
+{
+	btCollisionShapeData m_collisionShapeData;
+
+	btStridingMeshInterfaceData m_meshInterface;
+
+	btVector3FloatData m_localScaling;
+
+	float m_collisionMargin;
+
+	int m_gimpactSubType;
+};
+
+SIMD_FORCE_INLINE int btGImpactMeshShape::calculateSerializeBufferSize() const
+{
+	return sizeof(btGImpactMeshShapeData);
+}
+
+#endif  //GIMPACT_MESH_SHAPE_H
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/btGenericPoolAllocator.h b/engine/inc/bullet/BulletCollision/Gimpact/btGenericPoolAllocator.h
new file mode 100644
index 00000000..a535088e
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/btGenericPoolAllocator.h
@@ -0,0 +1,153 @@
+/*! \file btGenericPoolAllocator.h
+\author Francisco Leon Najera. email projectileman@yahoo.com
+
+General purpose allocator class
+*/
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_GENERIC_POOL_ALLOCATOR_H
+#define BT_GENERIC_POOL_ALLOCATOR_H
+
+#include <limits.h>
+#include <stdio.h>
+#include <string.h>
+#include "LinearMath/btAlignedAllocator.h"
+
+#define BT_UINT_MAX UINT_MAX
+#define BT_DEFAULT_MAX_POOLS 16
+
+//! Generic Pool class
+class btGenericMemoryPool
+{
+public:
+	unsigned char *m_pool;      //[m_element_size*m_max_element_count];
+	size_t *m_free_nodes;       //[m_max_element_count];//! free nodes
+	size_t *m_allocated_sizes;  //[m_max_element_count];//! Number of elements allocated per node
+	size_t m_allocated_count;
+	size_t m_free_nodes_count;
+
+protected:
+	size_t m_element_size;
+	size_t m_max_element_count;
+
+	size_t allocate_from_free_nodes(size_t num_elements);
+	size_t allocate_from_pool(size_t num_elements);
+
+public:
+	void init_pool(size_t element_size, size_t element_count);
+
+	void end_pool();
+
+	btGenericMemoryPool(size_t element_size, size_t element_count)
+	{
+		init_pool(element_size, element_count);
+	}
+
+	~btGenericMemoryPool()
+	{
+		end_pool();
+	}
+
+	inline size_t get_pool_capacity()
+	{
+		return m_element_size * m_max_element_count;
+	}
+
+	inline size_t gem_element_size()
+	{
+		return m_element_size;
+	}
+
+	inline size_t get_max_element_count()
+	{
+		return m_max_element_count;
+	}
+
+	inline size_t get_allocated_count()
+	{
+		return m_allocated_count;
+	}
+
+	inline size_t get_free_positions_count()
+	{
+		return m_free_nodes_count;
+	}
+
+	inline void *get_element_data(size_t element_index)
+	{
+		return &m_pool[element_index * m_element_size];
+	}
+
+	//! Allocates memory in pool
+	/*!
+	\param size_bytes size in bytes of the buffer
+	*/
+	void *allocate(size_t size_bytes);
+
+	bool freeMemory(void *pointer);
+};
+
+//! Generic Allocator with pools
+/*!
+General purpose Allocator which can create Memory Pools dynamiacally as needed.
+*/
+class btGenericPoolAllocator
+{
+protected:
+	size_t m_pool_element_size;
+	size_t m_pool_element_count;
+
+public:
+	btGenericMemoryPool *m_pools[BT_DEFAULT_MAX_POOLS];
+	size_t m_pool_count;
+
+	inline size_t get_pool_capacity()
+	{
+		return m_pool_element_size * m_pool_element_count;
+	}
+
+protected:
+	// creates a pool
+	btGenericMemoryPool *push_new_pool();
+
+	void *failback_alloc(size_t size_bytes);
+
+	bool failback_free(void *pointer);
+
+public:
+	btGenericPoolAllocator(size_t pool_element_size, size_t pool_element_count)
+	{
+		m_pool_count = 0;
+		m_pool_element_size = pool_element_size;
+		m_pool_element_count = pool_element_count;
+	}
+
+	virtual ~btGenericPoolAllocator();
+
+	//! Allocates memory in pool
+	/*!
+	\param size_bytes size in bytes of the buffer
+	*/
+	void *allocate(size_t size_bytes);
+
+	bool freeMemory(void *pointer);
+};
+
+void *btPoolAlloc(size_t size);
+void *btPoolRealloc(void *ptr, size_t oldsize, size_t newsize);
+void btPoolFree(void *ptr);
+
+#endif
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/btGeometryOperations.h b/engine/inc/bullet/BulletCollision/Gimpact/btGeometryOperations.h
new file mode 100644
index 00000000..6a1ee6dc
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/btGeometryOperations.h
@@ -0,0 +1,198 @@
+#ifndef BT_BASIC_GEOMETRY_OPERATIONS_H_INCLUDED
+#define BT_BASIC_GEOMETRY_OPERATIONS_H_INCLUDED
+
+/*! \file btGeometryOperations.h
+*\author Francisco Leon Najera
+
+*/
+/*
+This source file is part of GIMPACT Library.
+
+For the latest info, see http://gimpact.sourceforge.net/
+
+Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371.
+email: projectileman@yahoo.com
+
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "btBoxCollision.h"
+
+#define PLANEDIREPSILON 0.0000001f
+#define PARALELENORMALS 0.000001f
+
+#define BT_CLAMP(number, minval, maxval) (number < minval ? minval : (number > maxval ? maxval : number))
+
+/// Calc a plane from a triangle edge an a normal. plane is a vec4f
+SIMD_FORCE_INLINE void bt_edge_plane(const btVector3 &e1, const btVector3 &e2, const btVector3 &normal, btVector4 &plane)
+{
+	btVector3 planenormal = (e2 - e1).cross(normal);
+	planenormal.normalize();
+	plane.setValue(planenormal[0], planenormal[1], planenormal[2], e2.dot(planenormal));
+}
+
+//***************** SEGMENT and LINE FUNCTIONS **********************************///
+
+/*! Finds the closest point(cp) to (v) on a segment (e1,e2)
+ */
+SIMD_FORCE_INLINE void bt_closest_point_on_segment(
+	btVector3 &cp, const btVector3 &v,
+	const btVector3 &e1, const btVector3 &e2)
+{
+	btVector3 n = e2 - e1;
+	cp = v - e1;
+	btScalar _scalar = cp.dot(n) / n.dot(n);
+	if (_scalar < 0.0f)
+	{
+		cp = e1;
+	}
+	else if (_scalar > 1.0f)
+	{
+		cp = e2;
+	}
+	else
+	{
+		cp = _scalar * n + e1;
+	}
+}
+
+//! line plane collision
+/*!
+*\return
+	-0  if the ray never intersects
+	-1 if the ray collides in front
+	-2 if the ray collides in back
+*/
+
+SIMD_FORCE_INLINE int bt_line_plane_collision(
+	const btVector4 &plane,
+	const btVector3 &vDir,
+	const btVector3 &vPoint,
+	btVector3 &pout,
+	btScalar &tparam,
+	btScalar tmin, btScalar tmax)
+{
+	btScalar _dotdir = vDir.dot(plane);
+
+	if (btFabs(_dotdir) < PLANEDIREPSILON)
+	{
+		tparam = tmax;
+		return 0;
+	}
+
+	btScalar _dis = bt_distance_point_plane(plane, vPoint);
+	char returnvalue = _dis < 0.0f ? 2 : 1;
+	tparam = -_dis / _dotdir;
+
+	if (tparam < tmin)
+	{
+		returnvalue = 0;
+		tparam = tmin;
+	}
+	else if (tparam > tmax)
+	{
+		returnvalue = 0;
+		tparam = tmax;
+	}
+	pout = tparam * vDir + vPoint;
+	return returnvalue;
+}
+
+//! Find closest points on segments
+SIMD_FORCE_INLINE void bt_segment_collision(
+	const btVector3 &vA1,
+	const btVector3 &vA2,
+	const btVector3 &vB1,
+	const btVector3 &vB2,
+	btVector3 &vPointA,
+	btVector3 &vPointB)
+{
+	btVector3 AD = vA2 - vA1;
+	btVector3 BD = vB2 - vB1;
+	btVector3 N = AD.cross(BD);
+	btScalar tp = N.length2();
+
+	btVector4 _M;  //plane
+
+	if (tp < SIMD_EPSILON)  //ARE PARALELE
+	{
+		//project B over A
+		bool invert_b_order = false;
+		_M[0] = vB1.dot(AD);
+		_M[1] = vB2.dot(AD);
+
+		if (_M[0] > _M[1])
+		{
+			invert_b_order = true;
+			BT_SWAP_NUMBERS(_M[0], _M[1]);
+		}
+		_M[2] = vA1.dot(AD);
+		_M[3] = vA2.dot(AD);
+		//mid points
+		N[0] = (_M[0] + _M[1]) * 0.5f;
+		N[1] = (_M[2] + _M[3]) * 0.5f;
+
+		if (N[0] < N[1])
+		{
+			if (_M[1] < _M[2])
+			{
+				vPointB = invert_b_order ? vB1 : vB2;
+				vPointA = vA1;
+			}
+			else if (_M[1] < _M[3])
+			{
+				vPointB = invert_b_order ? vB1 : vB2;
+				bt_closest_point_on_segment(vPointA, vPointB, vA1, vA2);
+			}
+			else
+			{
+				vPointA = vA2;
+				bt_closest_point_on_segment(vPointB, vPointA, vB1, vB2);
+			}
+		}
+		else
+		{
+			if (_M[3] < _M[0])
+			{
+				vPointB = invert_b_order ? vB2 : vB1;
+				vPointA = vA2;
+			}
+			else if (_M[3] < _M[1])
+			{
+				vPointA = vA2;
+				bt_closest_point_on_segment(vPointB, vPointA, vB1, vB2);
+			}
+			else
+			{
+				vPointB = invert_b_order ? vB1 : vB2;
+				bt_closest_point_on_segment(vPointA, vPointB, vA1, vA2);
+			}
+		}
+		return;
+	}
+
+	N = N.cross(BD);
+	_M.setValue(N[0], N[1], N[2], vB1.dot(N));
+
+	// get point A as the plane collision point
+	bt_line_plane_collision(_M, AD, vA1, vPointA, tp, btScalar(0), btScalar(1));
+
+	/*Closest point on segment*/
+	vPointB = vPointA - vB1;
+	tp = vPointB.dot(BD);
+	tp /= BD.dot(BD);
+	tp = BT_CLAMP(tp, 0.0f, 1.0f);
+
+	vPointB = tp * BD + vB1;
+}
+
+#endif  // GIM_VECTOR_H_INCLUDED
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/btQuantization.h b/engine/inc/bullet/BulletCollision/Gimpact/btQuantization.h
new file mode 100644
index 00000000..19a02a21
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/btQuantization.h
@@ -0,0 +1,79 @@
+#ifndef BT_GIMPACT_QUANTIZATION_H_INCLUDED
+#define BT_GIMPACT_QUANTIZATION_H_INCLUDED
+
+/*! \file btQuantization.h
+*\author Francisco Leon Najera
+
+*/
+/*
+This source file is part of GIMPACT Library.
+
+For the latest info, see http://gimpact.sourceforge.net/
+
+Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371.
+email: projectileman@yahoo.com
+
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "LinearMath/btTransform.h"
+
+SIMD_FORCE_INLINE void bt_calc_quantization_parameters(
+	btVector3& outMinBound,
+	btVector3& outMaxBound,
+	btVector3& bvhQuantization,
+	const btVector3& srcMinBound, const btVector3& srcMaxBound,
+	btScalar quantizationMargin)
+{
+	//enlarge the AABB to avoid division by zero when initializing the quantization values
+	btVector3 clampValue(quantizationMargin, quantizationMargin, quantizationMargin);
+	outMinBound = srcMinBound - clampValue;
+	outMaxBound = srcMaxBound + clampValue;
+	btVector3 aabbSize = outMaxBound - outMinBound;
+	bvhQuantization = btVector3(btScalar(65535.0),
+								btScalar(65535.0),
+								btScalar(65535.0)) /
+					  aabbSize;
+}
+
+SIMD_FORCE_INLINE void bt_quantize_clamp(
+	unsigned short* out,
+	const btVector3& point,
+	const btVector3& min_bound,
+	const btVector3& max_bound,
+	const btVector3& bvhQuantization)
+{
+	btVector3 clampedPoint(point);
+	clampedPoint.setMax(min_bound);
+	clampedPoint.setMin(max_bound);
+
+	btVector3 v = (clampedPoint - min_bound) * bvhQuantization;
+	out[0] = (unsigned short)(v.getX() + 0.5f);
+	out[1] = (unsigned short)(v.getY() + 0.5f);
+	out[2] = (unsigned short)(v.getZ() + 0.5f);
+}
+
+SIMD_FORCE_INLINE btVector3 bt_unquantize(
+	const unsigned short* vecIn,
+	const btVector3& offset,
+	const btVector3& bvhQuantization)
+{
+	btVector3 vecOut;
+	vecOut.setValue(
+		(btScalar)(vecIn[0]) / (bvhQuantization.getX()),
+		(btScalar)(vecIn[1]) / (bvhQuantization.getY()),
+		(btScalar)(vecIn[2]) / (bvhQuantization.getZ()));
+	vecOut += offset;
+	return vecOut;
+}
+
+#endif  // BT_GIMPACT_QUANTIZATION_H_INCLUDED
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/btTriangleShapeEx.h b/engine/inc/bullet/BulletCollision/Gimpact/btTriangleShapeEx.h
new file mode 100644
index 00000000..568a1ce8
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/btTriangleShapeEx.h
@@ -0,0 +1,169 @@
+/*! \file btGImpactShape.h
+\author Francisco Leon Najera
+*/
+/*
+This source file is part of GIMPACT Library.
+
+For the latest info, see http://gimpact.sourceforge.net/
+
+Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371.
+email: projectileman@yahoo.com
+
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef GIMPACT_TRIANGLE_SHAPE_EX_H
+#define GIMPACT_TRIANGLE_SHAPE_EX_H
+
+#include "BulletCollision/CollisionShapes/btCollisionShape.h"
+#include "BulletCollision/CollisionShapes/btTriangleShape.h"
+#include "btBoxCollision.h"
+#include "btClipPolygon.h"
+#include "btGeometryOperations.h"
+
+#define MAX_TRI_CLIPPING 16
+
+//! Structure for collision
+struct GIM_TRIANGLE_CONTACT
+{
+	btScalar m_penetration_depth;
+	int m_point_count;
+	btVector4 m_separating_normal;
+	btVector3 m_points[MAX_TRI_CLIPPING];
+
+	SIMD_FORCE_INLINE void copy_from(const GIM_TRIANGLE_CONTACT& other)
+	{
+		m_penetration_depth = other.m_penetration_depth;
+		m_separating_normal = other.m_separating_normal;
+		m_point_count = other.m_point_count;
+		int i = m_point_count;
+		while (i--)
+		{
+			m_points[i] = other.m_points[i];
+		}
+	}
+
+	GIM_TRIANGLE_CONTACT()
+	{
+	}
+
+	GIM_TRIANGLE_CONTACT(const GIM_TRIANGLE_CONTACT& other)
+	{
+		copy_from(other);
+	}
+
+	//! classify points that are closer
+	void merge_points(const btVector4& plane,
+					  btScalar margin, const btVector3* points, int point_count);
+};
+
+class btPrimitiveTriangle
+{
+public:
+	btVector3 m_vertices[3];
+	btVector4 m_plane;
+	btScalar m_margin;
+	btScalar m_dummy;
+	btPrimitiveTriangle() : m_margin(0.01f)
+	{
+	}
+
+	SIMD_FORCE_INLINE void buildTriPlane()
+	{
+		btVector3 normal = (m_vertices[1] - m_vertices[0]).cross(m_vertices[2] - m_vertices[0]);
+		normal.normalize();
+		m_plane.setValue(normal[0], normal[1], normal[2], m_vertices[0].dot(normal));
+	}
+
+	//! Test if triangles could collide
+	bool overlap_test_conservative(const btPrimitiveTriangle& other);
+
+	//! Calcs the plane which is paralele to the edge and perpendicular to the triangle plane
+	/*!
+	\pre this triangle must have its plane calculated.
+	*/
+	SIMD_FORCE_INLINE void get_edge_plane(int edge_index, btVector4& plane) const
+	{
+		const btVector3& e0 = m_vertices[edge_index];
+		const btVector3& e1 = m_vertices[(edge_index + 1) % 3];
+		bt_edge_plane(e0, e1, m_plane, plane);
+	}
+
+	void applyTransform(const btTransform& t)
+	{
+		m_vertices[0] = t(m_vertices[0]);
+		m_vertices[1] = t(m_vertices[1]);
+		m_vertices[2] = t(m_vertices[2]);
+	}
+
+	//! Clips the triangle against this
+	/*!
+	\pre clipped_points must have MAX_TRI_CLIPPING size, and this triangle must have its plane calculated.
+	\return the number of clipped points
+	*/
+	int clip_triangle(btPrimitiveTriangle& other, btVector3* clipped_points);
+
+	//! Find collision using the clipping method
+	/*!
+	\pre this triangle and other must have their triangles calculated
+	*/
+	bool find_triangle_collision_clip_method(btPrimitiveTriangle& other, GIM_TRIANGLE_CONTACT& contacts);
+};
+
+//! Helper class for colliding Bullet Triangle Shapes
+/*!
+This class implements a better getAabb method than the previous btTriangleShape class
+*/
+class btTriangleShapeEx : public btTriangleShape
+{
+public:
+	btTriangleShapeEx() : btTriangleShape(btVector3(0, 0, 0), btVector3(0, 0, 0), btVector3(0, 0, 0))
+	{
+	}
+
+	btTriangleShapeEx(const btVector3& p0, const btVector3& p1, const btVector3& p2) : btTriangleShape(p0, p1, p2)
+	{
+	}
+
+	btTriangleShapeEx(const btTriangleShapeEx& other) : btTriangleShape(other.m_vertices1[0], other.m_vertices1[1], other.m_vertices1[2])
+	{
+	}
+
+	virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const
+	{
+		btVector3 tv0 = t(m_vertices1[0]);
+		btVector3 tv1 = t(m_vertices1[1]);
+		btVector3 tv2 = t(m_vertices1[2]);
+
+		btAABB trianglebox(tv0, tv1, tv2, m_collisionMargin);
+		aabbMin = trianglebox.m_min;
+		aabbMax = trianglebox.m_max;
+	}
+
+	void applyTransform(const btTransform& t)
+	{
+		m_vertices1[0] = t(m_vertices1[0]);
+		m_vertices1[1] = t(m_vertices1[1]);
+		m_vertices1[2] = t(m_vertices1[2]);
+	}
+
+	SIMD_FORCE_INLINE void buildTriPlane(btVector4& plane) const
+	{
+		btVector3 normal = (m_vertices1[1] - m_vertices1[0]).cross(m_vertices1[2] - m_vertices1[0]);
+		normal.normalize();
+		plane.setValue(normal[0], normal[1], normal[2], m_vertices1[0].dot(normal));
+	}
+
+	bool overlap_test_conservative(const btTriangleShapeEx& other);
+};
+
+#endif  //GIMPACT_TRIANGLE_MESH_SHAPE_H
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/gim_array.h b/engine/inc/bullet/BulletCollision/Gimpact/gim_array.h
new file mode 100644
index 00000000..fc2dc38a
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/gim_array.h
@@ -0,0 +1,318 @@
+#ifndef GIM_ARRAY_H_INCLUDED
+#define GIM_ARRAY_H_INCLUDED
+/*! \file gim_array.h
+\author Francisco Leon Najera
+*/
+/*
+-----------------------------------------------------------------------------
+This source file is part of GIMPACT Library.
+
+For the latest info, see http://gimpact.sourceforge.net/
+
+Copyright (c) 2006 Francisco Leon Najera. C.C. 80087371.
+email: projectileman@yahoo.com
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of EITHER:
+   (1) The GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 2.1 of the License, or (at
+       your option) any later version. The text of the GNU Lesser
+       General Public License is included with this library in the
+       file GIMPACT-LICENSE-LGPL.TXT.
+   (2) The BSD-style license that is included with this library in
+       the file GIMPACT-LICENSE-BSD.TXT.
+   (3) The zlib/libpng license that is included with this library in
+       the file GIMPACT-LICENSE-ZLIB.TXT.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files
+ GIMPACT-LICENSE-LGPL.TXT, GIMPACT-LICENSE-ZLIB.TXT and GIMPACT-LICENSE-BSD.TXT for more details.
+
+-----------------------------------------------------------------------------
+*/
+
+#include "gim_memory.h"
+
+#define GIM_ARRAY_GROW_INCREMENT 2
+#define GIM_ARRAY_GROW_FACTOR 2
+
+//!	Very simple array container with fast access and simd memory
+template <typename T>
+class gim_array
+{
+public:
+	//! properties
+	//!@{
+	T* m_data;
+	GUINT m_size;
+	GUINT m_allocated_size;
+	//!@}
+	//! protected operations
+	//!@{
+
+	inline void destroyData()
+	{
+		m_allocated_size = 0;
+		if (m_data == NULL) return;
+		gim_free(m_data);
+		m_data = NULL;
+	}
+
+	inline bool resizeData(GUINT newsize)
+	{
+		if (newsize == 0)
+		{
+			destroyData();
+			return true;
+		}
+
+		if (m_size > 0)
+		{
+			m_data = (T*)gim_realloc(m_data, m_size * sizeof(T), newsize * sizeof(T));
+		}
+		else
+		{
+			m_data = (T*)gim_alloc(newsize * sizeof(T));
+		}
+		m_allocated_size = newsize;
+		return true;
+	}
+
+	inline bool growingCheck()
+	{
+		if (m_allocated_size <= m_size)
+		{
+			GUINT requestsize = m_size;
+			m_size = m_allocated_size;
+			if (resizeData((requestsize + GIM_ARRAY_GROW_INCREMENT) * GIM_ARRAY_GROW_FACTOR) == false) return false;
+		}
+		return true;
+	}
+
+	//!@}
+	//! public operations
+	//!@{
+	inline bool reserve(GUINT size)
+	{
+		if (m_allocated_size >= size) return false;
+		return resizeData(size);
+	}
+
+	inline void clear_range(GUINT start_range)
+	{
+		while (m_size > start_range)
+		{
+			m_data[--m_size].~T();
+		}
+	}
+
+	inline void clear()
+	{
+		if (m_size == 0) return;
+		clear_range(0);
+	}
+
+	inline void clear_memory()
+	{
+		clear();
+		destroyData();
+	}
+
+	gim_array()
+	{
+		m_data = 0;
+		m_size = 0;
+		m_allocated_size = 0;
+	}
+
+	gim_array(GUINT reservesize)
+	{
+		m_data = 0;
+		m_size = 0;
+
+		m_allocated_size = 0;
+		reserve(reservesize);
+	}
+
+	~gim_array()
+	{
+		clear_memory();
+	}
+
+	inline GUINT size() const
+	{
+		return m_size;
+	}
+
+	inline GUINT max_size() const
+	{
+		return m_allocated_size;
+	}
+
+	inline T& operator[](size_t i)
+	{
+		return m_data[i];
+	}
+	inline const T& operator[](size_t i) const
+	{
+		return m_data[i];
+	}
+
+	inline T* pointer() { return m_data; }
+	inline const T* pointer() const
+	{
+		return m_data;
+	}
+
+	inline T* get_pointer_at(GUINT i)
+	{
+		return m_data + i;
+	}
+
+	inline const T* get_pointer_at(GUINT i) const
+	{
+		return m_data + i;
+	}
+
+	inline T& at(GUINT i)
+	{
+		return m_data[i];
+	}
+
+	inline const T& at(GUINT i) const
+	{
+		return m_data[i];
+	}
+
+	inline T& front()
+	{
+		return *m_data;
+	}
+
+	inline const T& front() const
+	{
+		return *m_data;
+	}
+
+	inline T& back()
+	{
+		return m_data[m_size - 1];
+	}
+
+	inline const T& back() const
+	{
+		return m_data[m_size - 1];
+	}
+
+	inline void swap(GUINT i, GUINT j)
+	{
+		gim_swap_elements(m_data, i, j);
+	}
+
+	inline void push_back(const T& obj)
+	{
+		this->growingCheck();
+		m_data[m_size] = obj;
+		m_size++;
+	}
+
+	//!Simply increase the m_size, doesn't call the new element constructor
+	inline void push_back_mem()
+	{
+		this->growingCheck();
+		m_size++;
+	}
+
+	inline void push_back_memcpy(const T& obj)
+	{
+		this->growingCheck();
+		gim_simd_memcpy(&m_data[m_size], &obj, sizeof(T));
+		m_size++;
+	}
+
+	inline void pop_back()
+	{
+		m_size--;
+		m_data[m_size].~T();
+	}
+
+	//!Simply decrease the m_size, doesn't call the deleted element destructor
+	inline void pop_back_mem()
+	{
+		m_size--;
+	}
+
+	//! fast erase
+	inline void erase(GUINT index)
+	{
+		if (index < m_size - 1)
+		{
+			swap(index, m_size - 1);
+		}
+		pop_back();
+	}
+
+	inline void erase_sorted_mem(GUINT index)
+	{
+		m_size--;
+		for (GUINT i = index; i < m_size; i++)
+		{
+			gim_simd_memcpy(m_data + i, m_data + i + 1, sizeof(T));
+		}
+	}
+
+	inline void erase_sorted(GUINT index)
+	{
+		m_data[index].~T();
+		erase_sorted_mem(index);
+	}
+
+	inline void insert_mem(GUINT index)
+	{
+		this->growingCheck();
+		for (GUINT i = m_size; i > index; i--)
+		{
+			gim_simd_memcpy(m_data + i, m_data + i - 1, sizeof(T));
+		}
+		m_size++;
+	}
+
+	inline void insert(const T& obj, GUINT index)
+	{
+		insert_mem(index);
+		m_data[index] = obj;
+	}
+
+	inline void resize(GUINT size, bool call_constructor = true, const T& fillData = T())
+	{
+		if (size > m_size)
+		{
+			reserve(size);
+			if (call_constructor)
+			{
+				while (m_size < size)
+				{
+					m_data[m_size] = fillData;
+					m_size++;
+				}
+			}
+			else
+			{
+				m_size = size;
+			}
+		}
+		else if (size < m_size)
+		{
+			if (call_constructor) clear_range(size);
+			m_size = size;
+		}
+	}
+
+	inline void refit()
+	{
+		resizeData(m_size);
+	}
+};
+
+#endif  // GIM_CONTAINERS_H_INCLUDED
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/gim_basic_geometry_operations.h b/engine/inc/bullet/BulletCollision/Gimpact/gim_basic_geometry_operations.h
new file mode 100644
index 00000000..7ab78367
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/gim_basic_geometry_operations.h
@@ -0,0 +1,536 @@
+#ifndef GIM_BASIC_GEOMETRY_OPERATIONS_H_INCLUDED
+#define GIM_BASIC_GEOMETRY_OPERATIONS_H_INCLUDED
+
+/*! \file gim_basic_geometry_operations.h
+*\author Francisco Leon Najera
+type independant geometry routines
+
+*/
+/*
+-----------------------------------------------------------------------------
+This source file is part of GIMPACT Library.
+
+For the latest info, see http://gimpact.sourceforge.net/
+
+Copyright (c) 2006 Francisco Leon Najera. C.C. 80087371.
+email: projectileman@yahoo.com
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of EITHER:
+   (1) The GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 2.1 of the License, or (at
+       your option) any later version. The text of the GNU Lesser
+       General Public License is included with this library in the
+       file GIMPACT-LICENSE-LGPL.TXT.
+   (2) The BSD-style license that is included with this library in
+       the file GIMPACT-LICENSE-BSD.TXT.
+   (3) The zlib/libpng license that is included with this library in
+       the file GIMPACT-LICENSE-ZLIB.TXT.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files
+ GIMPACT-LICENSE-LGPL.TXT, GIMPACT-LICENSE-ZLIB.TXT and GIMPACT-LICENSE-BSD.TXT for more details.
+
+-----------------------------------------------------------------------------
+*/
+
+#include "gim_linear_math.h"
+
+#ifndef PLANEDIREPSILON
+#define PLANEDIREPSILON 0.0000001f
+#endif
+
+#ifndef PARALELENORMALS
+#define PARALELENORMALS 0.000001f
+#endif
+
+#define TRIANGLE_NORMAL(v1, v2, v3, n) \
+	{                                  \
+		vec3f _dif1, _dif2;            \
+		VEC_DIFF(_dif1, v2, v1);       \
+		VEC_DIFF(_dif2, v3, v1);       \
+		VEC_CROSS(n, _dif1, _dif2);    \
+		VEC_NORMALIZE(n);              \
+	}
+
+#define TRIANGLE_NORMAL_FAST(v1, v2, v3, n) \
+	{                                       \
+		vec3f _dif1, _dif2;                 \
+		VEC_DIFF(_dif1, v2, v1);            \
+		VEC_DIFF(_dif2, v3, v1);            \
+		VEC_CROSS(n, _dif1, _dif2);         \
+	}
+
+/// plane is a vec4f
+#define TRIANGLE_PLANE(v1, v2, v3, plane)   \
+	{                                       \
+		TRIANGLE_NORMAL(v1, v2, v3, plane); \
+		plane[3] = VEC_DOT(v1, plane);      \
+	}
+
+/// plane is a vec4f
+#define TRIANGLE_PLANE_FAST(v1, v2, v3, plane)   \
+	{                                            \
+		TRIANGLE_NORMAL_FAST(v1, v2, v3, plane); \
+		plane[3] = VEC_DOT(v1, plane);           \
+	}
+
+/// Calc a plane from an edge an a normal. plane is a vec4f
+#define EDGE_PLANE(e1, e2, n, plane)   \
+	{                                  \
+		vec3f _dif;                    \
+		VEC_DIFF(_dif, e2, e1);        \
+		VEC_CROSS(plane, _dif, n);     \
+		VEC_NORMALIZE(plane);          \
+		plane[3] = VEC_DOT(e1, plane); \
+	}
+
+#define DISTANCE_PLANE_POINT(plane, point) (VEC_DOT(plane, point) - plane[3])
+
+#define PROJECT_POINT_PLANE(point, plane, projected) \
+	{                                                \
+		GREAL _dis;                                  \
+		_dis = DISTANCE_PLANE_POINT(plane, point);   \
+		VEC_SCALE(projected, -_dis, plane);          \
+		VEC_SUM(projected, projected, point);        \
+	}
+
+//! Verifies if a point is in the plane hull
+template <typename CLASS_POINT, typename CLASS_PLANE>
+SIMD_FORCE_INLINE bool POINT_IN_HULL(
+	const CLASS_POINT &point, const CLASS_PLANE *planes, GUINT plane_count)
+{
+	GREAL _dis;
+	for (GUINT _i = 0; _i < plane_count; ++_i)
+	{
+		_dis = DISTANCE_PLANE_POINT(planes[_i], point);
+		if (_dis > 0.0f) return false;
+	}
+	return true;
+}
+
+template <typename CLASS_POINT, typename CLASS_PLANE>
+SIMD_FORCE_INLINE void PLANE_CLIP_SEGMENT(
+	const CLASS_POINT &s1,
+	const CLASS_POINT &s2, const CLASS_PLANE &plane, CLASS_POINT &clipped)
+{
+	GREAL _dis1, _dis2;
+	_dis1 = DISTANCE_PLANE_POINT(plane, s1);
+	VEC_DIFF(clipped, s2, s1);
+	_dis2 = VEC_DOT(clipped, plane);
+	VEC_SCALE(clipped, -_dis1 / _dis2, clipped);
+	VEC_SUM(clipped, clipped, s1);
+}
+
+enum ePLANE_INTERSECTION_TYPE
+{
+	G_BACK_PLANE = 0,
+	G_COLLIDE_PLANE,
+	G_FRONT_PLANE
+};
+
+enum eLINE_PLANE_INTERSECTION_TYPE
+{
+	G_FRONT_PLANE_S1 = 0,
+	G_FRONT_PLANE_S2,
+	G_BACK_PLANE_S1,
+	G_BACK_PLANE_S2,
+	G_COLLIDE_PLANE_S1,
+	G_COLLIDE_PLANE_S2
+};
+
+//! Confirms if the plane intersect the edge or nor
+/*!
+intersection type must have the following values
+<ul>
+<li> 0 : Segment in front of plane, s1 closest
+<li> 1 : Segment in front of plane, s2 closest
+<li> 2 : Segment in back of plane, s1 closest
+<li> 3 : Segment in back of plane, s2 closest
+<li> 4 : Segment collides plane, s1 in back
+<li> 5 : Segment collides plane, s2 in back
+</ul>
+*/
+
+template <typename CLASS_POINT, typename CLASS_PLANE>
+SIMD_FORCE_INLINE eLINE_PLANE_INTERSECTION_TYPE PLANE_CLIP_SEGMENT2(
+	const CLASS_POINT &s1,
+	const CLASS_POINT &s2,
+	const CLASS_PLANE &plane, CLASS_POINT &clipped)
+{
+	GREAL _dis1 = DISTANCE_PLANE_POINT(plane, s1);
+	GREAL _dis2 = DISTANCE_PLANE_POINT(plane, s2);
+	if (_dis1 > -G_EPSILON && _dis2 > -G_EPSILON)
+	{
+		if (_dis1 < _dis2) return G_FRONT_PLANE_S1;
+		return G_FRONT_PLANE_S2;
+	}
+	else if (_dis1 < G_EPSILON && _dis2 < G_EPSILON)
+	{
+		if (_dis1 > _dis2) return G_BACK_PLANE_S1;
+		return G_BACK_PLANE_S2;
+	}
+
+	VEC_DIFF(clipped, s2, s1);
+	_dis2 = VEC_DOT(clipped, plane);
+	VEC_SCALE(clipped, -_dis1 / _dis2, clipped);
+	VEC_SUM(clipped, clipped, s1);
+	if (_dis1 < _dis2) return G_COLLIDE_PLANE_S1;
+	return G_COLLIDE_PLANE_S2;
+}
+
+//! Confirms if the plane intersect the edge or not
+/*!
+clipped1 and clipped2 are the vertices behind the plane.
+clipped1 is the closest
+
+intersection_type must have the following values
+<ul>
+<li> 0 : Segment in front of plane, s1 closest
+<li> 1 : Segment in front of plane, s2 closest
+<li> 2 : Segment in back of plane, s1 closest
+<li> 3 : Segment in back of plane, s2 closest
+<li> 4 : Segment collides plane, s1 in back
+<li> 5 : Segment collides plane, s2 in back
+</ul>
+*/
+template <typename CLASS_POINT, typename CLASS_PLANE>
+SIMD_FORCE_INLINE eLINE_PLANE_INTERSECTION_TYPE PLANE_CLIP_SEGMENT_CLOSEST(
+	const CLASS_POINT &s1,
+	const CLASS_POINT &s2,
+	const CLASS_PLANE &plane,
+	CLASS_POINT &clipped1, CLASS_POINT &clipped2)
+{
+	eLINE_PLANE_INTERSECTION_TYPE intersection_type = PLANE_CLIP_SEGMENT2(s1, s2, plane, clipped1);
+	switch (intersection_type)
+	{
+		case G_FRONT_PLANE_S1:
+			VEC_COPY(clipped1, s1);
+			VEC_COPY(clipped2, s2);
+			break;
+		case G_FRONT_PLANE_S2:
+			VEC_COPY(clipped1, s2);
+			VEC_COPY(clipped2, s1);
+			break;
+		case G_BACK_PLANE_S1:
+			VEC_COPY(clipped1, s1);
+			VEC_COPY(clipped2, s2);
+			break;
+		case G_BACK_PLANE_S2:
+			VEC_COPY(clipped1, s2);
+			VEC_COPY(clipped2, s1);
+			break;
+		case G_COLLIDE_PLANE_S1:
+			VEC_COPY(clipped2, s1);
+			break;
+		case G_COLLIDE_PLANE_S2:
+			VEC_COPY(clipped2, s2);
+			break;
+	}
+	return intersection_type;
+}
+
+//! Finds the 2 smallest cartesian coordinates of a plane normal
+#define PLANE_MINOR_AXES(plane, i0, i1) VEC_MINOR_AXES(plane, i0, i1)
+
+//! Ray plane collision in one way
+/*!
+Intersects plane in one way only. The ray must face the plane (normals must be in opossite directions).<br/>
+It uses the PLANEDIREPSILON constant.
+*/
+template <typename T, typename CLASS_POINT, typename CLASS_PLANE>
+SIMD_FORCE_INLINE bool RAY_PLANE_COLLISION(
+	const CLASS_PLANE &plane,
+	const CLASS_POINT &vDir,
+	const CLASS_POINT &vPoint,
+	CLASS_POINT &pout, T &tparam)
+{
+	GREAL _dis, _dotdir;
+	_dotdir = VEC_DOT(plane, vDir);
+	if (_dotdir < PLANEDIREPSILON)
+	{
+		return false;
+	}
+	_dis = DISTANCE_PLANE_POINT(plane, vPoint);
+	tparam = -_dis / _dotdir;
+	VEC_SCALE(pout, tparam, vDir);
+	VEC_SUM(pout, vPoint, pout);
+	return true;
+}
+
+//! line collision
+/*!
+*\return
+	-0  if the ray never intersects
+	-1 if the ray collides in front
+	-2 if the ray collides in back
+*/
+template <typename T, typename CLASS_POINT, typename CLASS_PLANE>
+SIMD_FORCE_INLINE GUINT LINE_PLANE_COLLISION(
+	const CLASS_PLANE &plane,
+	const CLASS_POINT &vDir,
+	const CLASS_POINT &vPoint,
+	CLASS_POINT &pout,
+	T &tparam,
+	T tmin, T tmax)
+{
+	GREAL _dis, _dotdir;
+	_dotdir = VEC_DOT(plane, vDir);
+	if (btFabs(_dotdir) < PLANEDIREPSILON)
+	{
+		tparam = tmax;
+		return 0;
+	}
+	_dis = DISTANCE_PLANE_POINT(plane, vPoint);
+	char returnvalue = _dis < 0.0f ? 2 : 1;
+	tparam = -_dis / _dotdir;
+
+	if (tparam < tmin)
+	{
+		returnvalue = 0;
+		tparam = tmin;
+	}
+	else if (tparam > tmax)
+	{
+		returnvalue = 0;
+		tparam = tmax;
+	}
+
+	VEC_SCALE(pout, tparam, vDir);
+	VEC_SUM(pout, vPoint, pout);
+	return returnvalue;
+}
+
+/*! \brief Returns the Ray on which 2 planes intersect if they do.
+    Written by Rodrigo Hernandez on ODE convex collision
+
+  \param p1 Plane 1
+  \param p2 Plane 2
+  \param p Contains the origin of the ray upon returning if planes intersect
+  \param d Contains the direction of the ray upon returning if planes intersect
+  \return true if the planes intersect, 0 if paralell.
+
+*/
+template <typename CLASS_POINT, typename CLASS_PLANE>
+SIMD_FORCE_INLINE bool INTERSECT_PLANES(
+	const CLASS_PLANE &p1,
+	const CLASS_PLANE &p2,
+	CLASS_POINT &p,
+	CLASS_POINT &d)
+{
+	VEC_CROSS(d, p1, p2);
+	GREAL denom = VEC_DOT(d, d);
+	if (GIM_IS_ZERO(denom)) return false;
+	vec3f _n;
+	_n[0] = p1[3] * p2[0] - p2[3] * p1[0];
+	_n[1] = p1[3] * p2[1] - p2[3] * p1[1];
+	_n[2] = p1[3] * p2[2] - p2[3] * p1[2];
+	VEC_CROSS(p, _n, d);
+	p[0] /= denom;
+	p[1] /= denom;
+	p[2] /= denom;
+	return true;
+}
+
+//***************** SEGMENT and LINE FUNCTIONS **********************************///
+
+/*! Finds the closest point(cp) to (v) on a segment (e1,e2)
+ */
+template <typename CLASS_POINT>
+SIMD_FORCE_INLINE void CLOSEST_POINT_ON_SEGMENT(
+	CLASS_POINT &cp, const CLASS_POINT &v,
+	const CLASS_POINT &e1, const CLASS_POINT &e2)
+{
+	vec3f _n;
+	VEC_DIFF(_n, e2, e1);
+	VEC_DIFF(cp, v, e1);
+	GREAL _scalar = VEC_DOT(cp, _n);
+	_scalar /= VEC_DOT(_n, _n);
+	if (_scalar < 0.0f)
+	{
+		VEC_COPY(cp, e1);
+	}
+	else if (_scalar > 1.0f)
+	{
+		VEC_COPY(cp, e2);
+	}
+	else
+	{
+		VEC_SCALE(cp, _scalar, _n);
+		VEC_SUM(cp, cp, e1);
+	}
+}
+
+/*! \brief Finds the line params where these lines intersect.
+
+\param dir1 Direction of line 1
+\param point1 Point of line 1
+\param dir2 Direction of line 2
+\param point2 Point of line 2
+\param t1 Result Parameter for line 1
+\param t2 Result Parameter for line 2
+\param dointersect  0  if the lines won't intersect, else 1
+
+*/
+template <typename T, typename CLASS_POINT>
+SIMD_FORCE_INLINE bool LINE_INTERSECTION_PARAMS(
+	const CLASS_POINT &dir1,
+	CLASS_POINT &point1,
+	const CLASS_POINT &dir2,
+	CLASS_POINT &point2,
+	T &t1, T &t2)
+{
+	GREAL det;
+	GREAL e1e1 = VEC_DOT(dir1, dir1);
+	GREAL e1e2 = VEC_DOT(dir1, dir2);
+	GREAL e2e2 = VEC_DOT(dir2, dir2);
+	vec3f p1p2;
+	VEC_DIFF(p1p2, point1, point2);
+	GREAL p1p2e1 = VEC_DOT(p1p2, dir1);
+	GREAL p1p2e2 = VEC_DOT(p1p2, dir2);
+	det = e1e2 * e1e2 - e1e1 * e2e2;
+	if (GIM_IS_ZERO(det)) return false;
+	t1 = (e1e2 * p1p2e2 - e2e2 * p1p2e1) / det;
+	t2 = (e1e1 * p1p2e2 - e1e2 * p1p2e1) / det;
+	return true;
+}
+
+//! Find closest points on segments
+template <typename CLASS_POINT>
+SIMD_FORCE_INLINE void SEGMENT_COLLISION(
+	const CLASS_POINT &vA1,
+	const CLASS_POINT &vA2,
+	const CLASS_POINT &vB1,
+	const CLASS_POINT &vB2,
+	CLASS_POINT &vPointA,
+	CLASS_POINT &vPointB)
+{
+	CLASS_POINT _AD, _BD, n;
+	vec4f _M;  //plane
+	VEC_DIFF(_AD, vA2, vA1);
+	VEC_DIFF(_BD, vB2, vB1);
+	VEC_CROSS(n, _AD, _BD);
+	GREAL _tp = VEC_DOT(n, n);
+	if (_tp < G_EPSILON)  //ARE PARALELE
+	{
+		//project B over A
+		bool invert_b_order = false;
+		_M[0] = VEC_DOT(vB1, _AD);
+		_M[1] = VEC_DOT(vB2, _AD);
+		if (_M[0] > _M[1])
+		{
+			invert_b_order = true;
+			GIM_SWAP_NUMBERS(_M[0], _M[1]);
+		}
+		_M[2] = VEC_DOT(vA1, _AD);
+		_M[3] = VEC_DOT(vA2, _AD);
+		//mid points
+		n[0] = (_M[0] + _M[1]) * 0.5f;
+		n[1] = (_M[2] + _M[3]) * 0.5f;
+
+		if (n[0] < n[1])
+		{
+			if (_M[1] < _M[2])
+			{
+				vPointB = invert_b_order ? vB1 : vB2;
+				vPointA = vA1;
+			}
+			else if (_M[1] < _M[3])
+			{
+				vPointB = invert_b_order ? vB1 : vB2;
+				CLOSEST_POINT_ON_SEGMENT(vPointA, vPointB, vA1, vA2);
+			}
+			else
+			{
+				vPointA = vA2;
+				CLOSEST_POINT_ON_SEGMENT(vPointB, vPointA, vB1, vB2);
+			}
+		}
+		else
+		{
+			if (_M[3] < _M[0])
+			{
+				vPointB = invert_b_order ? vB2 : vB1;
+				vPointA = vA2;
+			}
+			else if (_M[3] < _M[1])
+			{
+				vPointA = vA2;
+				CLOSEST_POINT_ON_SEGMENT(vPointB, vPointA, vB1, vB2);
+			}
+			else
+			{
+				vPointB = invert_b_order ? vB1 : vB2;
+				CLOSEST_POINT_ON_SEGMENT(vPointA, vPointB, vA1, vA2);
+			}
+		}
+		return;
+	}
+
+	VEC_CROSS(_M, n, _BD);
+	_M[3] = VEC_DOT(_M, vB1);
+
+	LINE_PLANE_COLLISION(_M, _AD, vA1, vPointA, _tp, btScalar(0), btScalar(1));
+	/*Closest point on segment*/
+	VEC_DIFF(vPointB, vPointA, vB1);
+	_tp = VEC_DOT(vPointB, _BD);
+	_tp /= VEC_DOT(_BD, _BD);
+	_tp = GIM_CLAMP(_tp, 0.0f, 1.0f);
+	VEC_SCALE(vPointB, _tp, _BD);
+	VEC_SUM(vPointB, vPointB, vB1);
+}
+
+//! Line box intersection in one dimension
+/*!
+
+*\param pos Position of the ray
+*\param dir Projection of the Direction of the ray
+*\param bmin Minimum bound of the box
+*\param bmax Maximum bound of the box
+*\param tfirst the minimum projection. Assign to 0 at first.
+*\param tlast the maximum projection. Assign to INFINITY at first.
+*\return true if there is an intersection.
+*/
+template <typename T>
+SIMD_FORCE_INLINE bool BOX_AXIS_INTERSECT(T pos, T dir, T bmin, T bmax, T &tfirst, T &tlast)
+{
+	if (GIM_IS_ZERO(dir))
+	{
+		return !(pos < bmin || pos > bmax);
+	}
+	GREAL a0 = (bmin - pos) / dir;
+	GREAL a1 = (bmax - pos) / dir;
+	if (a0 > a1) GIM_SWAP_NUMBERS(a0, a1);
+	tfirst = GIM_MAX(a0, tfirst);
+	tlast = GIM_MIN(a1, tlast);
+	if (tlast < tfirst) return false;
+	return true;
+}
+
+//! Sorts 3 componets
+template <typename T>
+SIMD_FORCE_INLINE void SORT_3_INDICES(
+	const T *values,
+	GUINT *order_indices)
+{
+	//get minimum
+	order_indices[0] = values[0] < values[1] ? (values[0] < values[2] ? 0 : 2) : (values[1] < values[2] ? 1 : 2);
+
+	//get second and third
+	GUINT i0 = (order_indices[0] + 1) % 3;
+	GUINT i1 = (i0 + 1) % 3;
+
+	if (values[i0] < values[i1])
+	{
+		order_indices[1] = i0;
+		order_indices[2] = i1;
+	}
+	else
+	{
+		order_indices[1] = i1;
+		order_indices[2] = i0;
+	}
+}
+
+#endif  // GIM_VECTOR_H_INCLUDED
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/gim_bitset.h b/engine/inc/bullet/BulletCollision/Gimpact/gim_bitset.h
new file mode 100644
index 00000000..c1fb41a5
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/gim_bitset.h
@@ -0,0 +1,117 @@
+#ifndef GIM_BITSET_H_INCLUDED
+#define GIM_BITSET_H_INCLUDED
+/*! \file gim_bitset.h
+\author Francisco Leon Najera
+*/
+/*
+-----------------------------------------------------------------------------
+This source file is part of GIMPACT Library.
+
+For the latest info, see http://gimpact.sourceforge.net/
+
+Copyright (c) 2006 Francisco Leon Najera. C.C. 80087371.
+email: projectileman@yahoo.com
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of EITHER:
+   (1) The GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 2.1 of the License, or (at
+       your option) any later version. The text of the GNU Lesser
+       General Public License is included with this library in the
+       file GIMPACT-LICENSE-LGPL.TXT.
+   (2) The BSD-style license that is included with this library in
+       the file GIMPACT-LICENSE-BSD.TXT.
+   (3) The zlib/libpng license that is included with this library in
+       the file GIMPACT-LICENSE-ZLIB.TXT.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files
+ GIMPACT-LICENSE-LGPL.TXT, GIMPACT-LICENSE-ZLIB.TXT and GIMPACT-LICENSE-BSD.TXT for more details.
+
+-----------------------------------------------------------------------------
+*/
+
+#include "gim_array.h"
+
+#define GUINT_BIT_COUNT 32
+#define GUINT_EXPONENT 5
+
+class gim_bitset
+{
+public:
+	gim_array<GUINT> m_container;
+
+	gim_bitset()
+	{
+	}
+
+	gim_bitset(GUINT bits_count)
+	{
+		resize(bits_count);
+	}
+
+	~gim_bitset()
+	{
+	}
+
+	inline bool resize(GUINT newsize)
+	{
+		GUINT oldsize = m_container.size();
+		m_container.resize(newsize / GUINT_BIT_COUNT + 1, false);
+		while (oldsize < m_container.size())
+		{
+			m_container[oldsize] = 0;
+		}
+		return true;
+	}
+
+	inline GUINT size()
+	{
+		return m_container.size() * GUINT_BIT_COUNT;
+	}
+
+	inline void set_all()
+	{
+		for (GUINT i = 0; i < m_container.size(); ++i)
+		{
+			m_container[i] = 0xffffffff;
+		}
+	}
+
+	inline void clear_all()
+	{
+		for (GUINT i = 0; i < m_container.size(); ++i)
+		{
+			m_container[i] = 0;
+		}
+	}
+
+	inline void set(GUINT bit_index)
+	{
+		if (bit_index >= size())
+		{
+			resize(bit_index);
+		}
+		m_container[bit_index >> GUINT_EXPONENT] |= (1 << (bit_index & (GUINT_BIT_COUNT - 1)));
+	}
+
+	///Return 0 or 1
+	inline char get(GUINT bit_index)
+	{
+		if (bit_index >= size())
+		{
+			return 0;
+		}
+		char value = m_container[bit_index >> GUINT_EXPONENT] &
+					 (1 << (bit_index & (GUINT_BIT_COUNT - 1)));
+		return value;
+	}
+
+	inline void clear(GUINT bit_index)
+	{
+		m_container[bit_index >> GUINT_EXPONENT] &= ~(1 << (bit_index & (GUINT_BIT_COUNT - 1)));
+	}
+};
+
+#endif  // GIM_CONTAINERS_H_INCLUDED
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/gim_box_collision.h b/engine/inc/bullet/BulletCollision/Gimpact/gim_box_collision.h
new file mode 100644
index 00000000..9f7cbe73
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/gim_box_collision.h
@@ -0,0 +1,578 @@
+#ifndef GIM_BOX_COLLISION_H_INCLUDED
+#define GIM_BOX_COLLISION_H_INCLUDED
+
+/*! \file gim_box_collision.h
+\author Francisco Leon Najera
+*/
+/*
+-----------------------------------------------------------------------------
+This source file is part of GIMPACT Library.
+
+For the latest info, see http://gimpact.sourceforge.net/
+
+Copyright (c) 2006 Francisco Leon Najera. C.C. 80087371.
+email: projectileman@yahoo.com
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of EITHER:
+   (1) The GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 2.1 of the License, or (at
+       your option) any later version. The text of the GNU Lesser
+       General Public License is included with this library in the
+       file GIMPACT-LICENSE-LGPL.TXT.
+   (2) The BSD-style license that is included with this library in
+       the file GIMPACT-LICENSE-BSD.TXT.
+   (3) The zlib/libpng license that is included with this library in
+       the file GIMPACT-LICENSE-ZLIB.TXT.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files
+ GIMPACT-LICENSE-LGPL.TXT, GIMPACT-LICENSE-ZLIB.TXT and GIMPACT-LICENSE-BSD.TXT for more details.
+
+-----------------------------------------------------------------------------
+*/
+#include "gim_basic_geometry_operations.h"
+#include "LinearMath/btTransform.h"
+
+//SIMD_FORCE_INLINE bool test_cross_edge_box(
+//	const btVector3 & edge,
+//	const btVector3 & absolute_edge,
+//	const btVector3 & pointa,
+//	const btVector3 & pointb, const btVector3 & extend,
+//	int dir_index0,
+//	int dir_index1
+//	int component_index0,
+//	int component_index1)
+//{
+//	// dir coords are -z and y
+//
+//	const btScalar dir0 = -edge[dir_index0];
+//	const btScalar dir1 = edge[dir_index1];
+//	btScalar pmin = pointa[component_index0]*dir0 + pointa[component_index1]*dir1;
+//	btScalar pmax = pointb[component_index0]*dir0 + pointb[component_index1]*dir1;
+//	//find minmax
+//	if(pmin>pmax)
+//	{
+//		GIM_SWAP_NUMBERS(pmin,pmax);
+//	}
+//	//find extends
+//	const btScalar rad = extend[component_index0] * absolute_edge[dir_index0] +
+//					extend[component_index1] * absolute_edge[dir_index1];
+//
+//	if(pmin>rad || -rad>pmax) return false;
+//	return true;
+//}
+//
+//SIMD_FORCE_INLINE bool test_cross_edge_box_X_axis(
+//	const btVector3 & edge,
+//	const btVector3 & absolute_edge,
+//	const btVector3 & pointa,
+//	const btVector3 & pointb, btVector3 & extend)
+//{
+//
+//	return test_cross_edge_box(edge,absolute_edge,pointa,pointb,extend,2,1,1,2);
+//}
+//
+//
+//SIMD_FORCE_INLINE bool test_cross_edge_box_Y_axis(
+//	const btVector3 & edge,
+//	const btVector3 & absolute_edge,
+//	const btVector3 & pointa,
+//	const btVector3 & pointb, btVector3 & extend)
+//{
+//
+//	return test_cross_edge_box(edge,absolute_edge,pointa,pointb,extend,0,2,2,0);
+//}
+//
+//SIMD_FORCE_INLINE bool test_cross_edge_box_Z_axis(
+//	const btVector3 & edge,
+//	const btVector3 & absolute_edge,
+//	const btVector3 & pointa,
+//	const btVector3 & pointb, btVector3 & extend)
+//{
+//
+//	return test_cross_edge_box(edge,absolute_edge,pointa,pointb,extend,1,0,0,1);
+//}
+
+#ifndef TEST_CROSS_EDGE_BOX_MCR
+
+#define TEST_CROSS_EDGE_BOX_MCR(edge, absolute_edge, pointa, pointb, _extend, i_dir_0, i_dir_1, i_comp_0, i_comp_1) \
+	{                                                                                                               \
+		const btScalar dir0 = -edge[i_dir_0];                                                                       \
+		const btScalar dir1 = edge[i_dir_1];                                                                        \
+		btScalar pmin = pointa[i_comp_0] * dir0 + pointa[i_comp_1] * dir1;                                          \
+		btScalar pmax = pointb[i_comp_0] * dir0 + pointb[i_comp_1] * dir1;                                          \
+		if (pmin > pmax)                                                                                            \
+		{                                                                                                           \
+			GIM_SWAP_NUMBERS(pmin, pmax);                                                                           \
+		}                                                                                                           \
+		const btScalar abs_dir0 = absolute_edge[i_dir_0];                                                           \
+		const btScalar abs_dir1 = absolute_edge[i_dir_1];                                                           \
+		const btScalar rad = _extend[i_comp_0] * abs_dir0 + _extend[i_comp_1] * abs_dir1;                           \
+		if (pmin > rad || -rad > pmax) return false;                                                                \
+	}
+
+#endif
+
+#define TEST_CROSS_EDGE_BOX_X_AXIS_MCR(edge, absolute_edge, pointa, pointb, _extend)       \
+	{                                                                                      \
+		TEST_CROSS_EDGE_BOX_MCR(edge, absolute_edge, pointa, pointb, _extend, 2, 1, 1, 2); \
+	}
+
+#define TEST_CROSS_EDGE_BOX_Y_AXIS_MCR(edge, absolute_edge, pointa, pointb, _extend)       \
+	{                                                                                      \
+		TEST_CROSS_EDGE_BOX_MCR(edge, absolute_edge, pointa, pointb, _extend, 0, 2, 2, 0); \
+	}
+
+#define TEST_CROSS_EDGE_BOX_Z_AXIS_MCR(edge, absolute_edge, pointa, pointb, _extend)       \
+	{                                                                                      \
+		TEST_CROSS_EDGE_BOX_MCR(edge, absolute_edge, pointa, pointb, _extend, 1, 0, 0, 1); \
+	}
+
+//!  Class for transforming a model1 to the space of model0
+class GIM_BOX_BOX_TRANSFORM_CACHE
+{
+public:
+	btVector3 m_T1to0;    //!< Transforms translation of model1 to model 0
+	btMatrix3x3 m_R1to0;  //!< Transforms Rotation of model1 to model 0, equal  to R0' * R1
+	btMatrix3x3 m_AR;     //!< Absolute value of m_R1to0
+
+	SIMD_FORCE_INLINE void calc_absolute_matrix()
+	{
+		static const btVector3 vepsi(1e-6f, 1e-6f, 1e-6f);
+		m_AR[0] = vepsi + m_R1to0[0].absolute();
+		m_AR[1] = vepsi + m_R1to0[1].absolute();
+		m_AR[2] = vepsi + m_R1to0[2].absolute();
+	}
+
+	GIM_BOX_BOX_TRANSFORM_CACHE()
+	{
+	}
+
+	GIM_BOX_BOX_TRANSFORM_CACHE(mat4f trans1_to_0)
+	{
+		COPY_MATRIX_3X3(m_R1to0, trans1_to_0)
+		MAT_GET_TRANSLATION(trans1_to_0, m_T1to0)
+		calc_absolute_matrix();
+	}
+
+	//! Calc the transformation relative  1 to 0. Inverts matrics by transposing
+	SIMD_FORCE_INLINE void calc_from_homogenic(const btTransform &trans0, const btTransform &trans1)
+	{
+		m_R1to0 = trans0.getBasis().transpose();
+		m_T1to0 = m_R1to0 * (-trans0.getOrigin());
+
+		m_T1to0 += m_R1to0 * trans1.getOrigin();
+		m_R1to0 *= trans1.getBasis();
+
+		calc_absolute_matrix();
+	}
+
+	//! Calcs the full invertion of the matrices. Useful for scaling matrices
+	SIMD_FORCE_INLINE void calc_from_full_invert(const btTransform &trans0, const btTransform &trans1)
+	{
+		m_R1to0 = trans0.getBasis().inverse();
+		m_T1to0 = m_R1to0 * (-trans0.getOrigin());
+
+		m_T1to0 += m_R1to0 * trans1.getOrigin();
+		m_R1to0 *= trans1.getBasis();
+
+		calc_absolute_matrix();
+	}
+
+	SIMD_FORCE_INLINE btVector3 transform(const btVector3 &point)
+	{
+		return point.dot3(m_R1to0[0], m_R1to0[1], m_R1to0[2]) + m_T1to0;
+	}
+};
+
+#ifndef BOX_PLANE_EPSILON
+#define BOX_PLANE_EPSILON 0.000001f
+#endif
+
+//! Axis aligned box
+class GIM_AABB
+{
+public:
+	btVector3 m_min;
+	btVector3 m_max;
+
+	GIM_AABB()
+	{
+	}
+
+	GIM_AABB(const btVector3 &V1,
+			 const btVector3 &V2,
+			 const btVector3 &V3)
+	{
+		m_min[0] = GIM_MIN3(V1[0], V2[0], V3[0]);
+		m_min[1] = GIM_MIN3(V1[1], V2[1], V3[1]);
+		m_min[2] = GIM_MIN3(V1[2], V2[2], V3[2]);
+
+		m_max[0] = GIM_MAX3(V1[0], V2[0], V3[0]);
+		m_max[1] = GIM_MAX3(V1[1], V2[1], V3[1]);
+		m_max[2] = GIM_MAX3(V1[2], V2[2], V3[2]);
+	}
+
+	GIM_AABB(const btVector3 &V1,
+			 const btVector3 &V2,
+			 const btVector3 &V3,
+			 GREAL margin)
+	{
+		m_min[0] = GIM_MIN3(V1[0], V2[0], V3[0]);
+		m_min[1] = GIM_MIN3(V1[1], V2[1], V3[1]);
+		m_min[2] = GIM_MIN3(V1[2], V2[2], V3[2]);
+
+		m_max[0] = GIM_MAX3(V1[0], V2[0], V3[0]);
+		m_max[1] = GIM_MAX3(V1[1], V2[1], V3[1]);
+		m_max[2] = GIM_MAX3(V1[2], V2[2], V3[2]);
+
+		m_min[0] -= margin;
+		m_min[1] -= margin;
+		m_min[2] -= margin;
+		m_max[0] += margin;
+		m_max[1] += margin;
+		m_max[2] += margin;
+	}
+
+	GIM_AABB(const GIM_AABB &other) : m_min(other.m_min), m_max(other.m_max)
+	{
+	}
+
+	GIM_AABB(const GIM_AABB &other, btScalar margin) : m_min(other.m_min), m_max(other.m_max)
+	{
+		m_min[0] -= margin;
+		m_min[1] -= margin;
+		m_min[2] -= margin;
+		m_max[0] += margin;
+		m_max[1] += margin;
+		m_max[2] += margin;
+	}
+
+	SIMD_FORCE_INLINE void invalidate()
+	{
+		m_min[0] = G_REAL_INFINITY;
+		m_min[1] = G_REAL_INFINITY;
+		m_min[2] = G_REAL_INFINITY;
+		m_max[0] = -G_REAL_INFINITY;
+		m_max[1] = -G_REAL_INFINITY;
+		m_max[2] = -G_REAL_INFINITY;
+	}
+
+	SIMD_FORCE_INLINE void increment_margin(btScalar margin)
+	{
+		m_min[0] -= margin;
+		m_min[1] -= margin;
+		m_min[2] -= margin;
+		m_max[0] += margin;
+		m_max[1] += margin;
+		m_max[2] += margin;
+	}
+
+	SIMD_FORCE_INLINE void copy_with_margin(const GIM_AABB &other, btScalar margin)
+	{
+		m_min[0] = other.m_min[0] - margin;
+		m_min[1] = other.m_min[1] - margin;
+		m_min[2] = other.m_min[2] - margin;
+
+		m_max[0] = other.m_max[0] + margin;
+		m_max[1] = other.m_max[1] + margin;
+		m_max[2] = other.m_max[2] + margin;
+	}
+
+	template <typename CLASS_POINT>
+	SIMD_FORCE_INLINE void calc_from_triangle(
+		const CLASS_POINT &V1,
+		const CLASS_POINT &V2,
+		const CLASS_POINT &V3)
+	{
+		m_min[0] = GIM_MIN3(V1[0], V2[0], V3[0]);
+		m_min[1] = GIM_MIN3(V1[1], V2[1], V3[1]);
+		m_min[2] = GIM_MIN3(V1[2], V2[2], V3[2]);
+
+		m_max[0] = GIM_MAX3(V1[0], V2[0], V3[0]);
+		m_max[1] = GIM_MAX3(V1[1], V2[1], V3[1]);
+		m_max[2] = GIM_MAX3(V1[2], V2[2], V3[2]);
+	}
+
+	template <typename CLASS_POINT>
+	SIMD_FORCE_INLINE void calc_from_triangle_margin(
+		const CLASS_POINT &V1,
+		const CLASS_POINT &V2,
+		const CLASS_POINT &V3, btScalar margin)
+	{
+		m_min[0] = GIM_MIN3(V1[0], V2[0], V3[0]);
+		m_min[1] = GIM_MIN3(V1[1], V2[1], V3[1]);
+		m_min[2] = GIM_MIN3(V1[2], V2[2], V3[2]);
+
+		m_max[0] = GIM_MAX3(V1[0], V2[0], V3[0]);
+		m_max[1] = GIM_MAX3(V1[1], V2[1], V3[1]);
+		m_max[2] = GIM_MAX3(V1[2], V2[2], V3[2]);
+
+		m_min[0] -= margin;
+		m_min[1] -= margin;
+		m_min[2] -= margin;
+		m_max[0] += margin;
+		m_max[1] += margin;
+		m_max[2] += margin;
+	}
+
+	//! Apply a transform to an AABB
+	SIMD_FORCE_INLINE void appy_transform(const btTransform &trans)
+	{
+		btVector3 center = (m_max + m_min) * 0.5f;
+		btVector3 extends = m_max - center;
+		// Compute new center
+		center = trans(center);
+
+		btVector3 textends = extends.dot3(trans.getBasis().getRow(0).absolute(),
+										  trans.getBasis().getRow(1).absolute(),
+										  trans.getBasis().getRow(2).absolute());
+
+		m_min = center - textends;
+		m_max = center + textends;
+	}
+
+	//! Merges a Box
+	SIMD_FORCE_INLINE void merge(const GIM_AABB &box)
+	{
+		m_min[0] = GIM_MIN(m_min[0], box.m_min[0]);
+		m_min[1] = GIM_MIN(m_min[1], box.m_min[1]);
+		m_min[2] = GIM_MIN(m_min[2], box.m_min[2]);
+
+		m_max[0] = GIM_MAX(m_max[0], box.m_max[0]);
+		m_max[1] = GIM_MAX(m_max[1], box.m_max[1]);
+		m_max[2] = GIM_MAX(m_max[2], box.m_max[2]);
+	}
+
+	//! Merges a point
+	template <typename CLASS_POINT>
+	SIMD_FORCE_INLINE void merge_point(const CLASS_POINT &point)
+	{
+		m_min[0] = GIM_MIN(m_min[0], point[0]);
+		m_min[1] = GIM_MIN(m_min[1], point[1]);
+		m_min[2] = GIM_MIN(m_min[2], point[2]);
+
+		m_max[0] = GIM_MAX(m_max[0], point[0]);
+		m_max[1] = GIM_MAX(m_max[1], point[1]);
+		m_max[2] = GIM_MAX(m_max[2], point[2]);
+	}
+
+	//! Gets the extend and center
+	SIMD_FORCE_INLINE void get_center_extend(btVector3 &center, btVector3 &extend) const
+	{
+		center = (m_max + m_min) * 0.5f;
+		extend = m_max - center;
+	}
+
+	//! Finds the intersecting box between this box and the other.
+	SIMD_FORCE_INLINE void find_intersection(const GIM_AABB &other, GIM_AABB &intersection) const
+	{
+		intersection.m_min[0] = GIM_MAX(other.m_min[0], m_min[0]);
+		intersection.m_min[1] = GIM_MAX(other.m_min[1], m_min[1]);
+		intersection.m_min[2] = GIM_MAX(other.m_min[2], m_min[2]);
+
+		intersection.m_max[0] = GIM_MIN(other.m_max[0], m_max[0]);
+		intersection.m_max[1] = GIM_MIN(other.m_max[1], m_max[1]);
+		intersection.m_max[2] = GIM_MIN(other.m_max[2], m_max[2]);
+	}
+
+	SIMD_FORCE_INLINE bool has_collision(const GIM_AABB &other) const
+	{
+		if (m_min[0] > other.m_max[0] ||
+			m_max[0] < other.m_min[0] ||
+			m_min[1] > other.m_max[1] ||
+			m_max[1] < other.m_min[1] ||
+			m_min[2] > other.m_max[2] ||
+			m_max[2] < other.m_min[2])
+		{
+			return false;
+		}
+		return true;
+	}
+
+	/*! \brief Finds the Ray intersection parameter.
+	\param aabb Aligned box
+	\param vorigin A vec3f with the origin of the ray
+	\param vdir A vec3f with the direction of the ray
+	*/
+	SIMD_FORCE_INLINE bool collide_ray(const btVector3 &vorigin, const btVector3 &vdir)
+	{
+		btVector3 extents, center;
+		this->get_center_extend(center, extents);
+		;
+
+		btScalar Dx = vorigin[0] - center[0];
+		if (GIM_GREATER(Dx, extents[0]) && Dx * vdir[0] >= 0.0f) return false;
+		btScalar Dy = vorigin[1] - center[1];
+		if (GIM_GREATER(Dy, extents[1]) && Dy * vdir[1] >= 0.0f) return false;
+		btScalar Dz = vorigin[2] - center[2];
+		if (GIM_GREATER(Dz, extents[2]) && Dz * vdir[2] >= 0.0f) return false;
+
+		btScalar f = vdir[1] * Dz - vdir[2] * Dy;
+		if (btFabs(f) > extents[1] * btFabs(vdir[2]) + extents[2] * btFabs(vdir[1])) return false;
+		f = vdir[2] * Dx - vdir[0] * Dz;
+		if (btFabs(f) > extents[0] * btFabs(vdir[2]) + extents[2] * btFabs(vdir[0])) return false;
+		f = vdir[0] * Dy - vdir[1] * Dx;
+		if (btFabs(f) > extents[0] * btFabs(vdir[1]) + extents[1] * btFabs(vdir[0])) return false;
+		return true;
+	}
+
+	SIMD_FORCE_INLINE void projection_interval(const btVector3 &direction, btScalar &vmin, btScalar &vmax) const
+	{
+		btVector3 center = (m_max + m_min) * 0.5f;
+		btVector3 extend = m_max - center;
+
+		btScalar _fOrigin = direction.dot(center);
+		btScalar _fMaximumExtent = extend.dot(direction.absolute());
+		vmin = _fOrigin - _fMaximumExtent;
+		vmax = _fOrigin + _fMaximumExtent;
+	}
+
+	SIMD_FORCE_INLINE ePLANE_INTERSECTION_TYPE plane_classify(const btVector4 &plane) const
+	{
+		btScalar _fmin, _fmax;
+		this->projection_interval(plane, _fmin, _fmax);
+
+		if (plane[3] > _fmax + BOX_PLANE_EPSILON)
+		{
+			return G_BACK_PLANE;  // 0
+		}
+
+		if (plane[3] + BOX_PLANE_EPSILON >= _fmin)
+		{
+			return G_COLLIDE_PLANE;  //1
+		}
+		return G_FRONT_PLANE;  //2
+	}
+
+	SIMD_FORCE_INLINE bool overlapping_trans_conservative(const GIM_AABB &box, btTransform &trans1_to_0)
+	{
+		GIM_AABB tbox = box;
+		tbox.appy_transform(trans1_to_0);
+		return has_collision(tbox);
+	}
+
+	//! transcache is the transformation cache from box to this AABB
+	SIMD_FORCE_INLINE bool overlapping_trans_cache(
+		const GIM_AABB &box, const GIM_BOX_BOX_TRANSFORM_CACHE &transcache, bool fulltest)
+	{
+		//Taken from OPCODE
+		btVector3 ea, eb;  //extends
+		btVector3 ca, cb;  //extends
+		get_center_extend(ca, ea);
+		box.get_center_extend(cb, eb);
+
+		btVector3 T;
+		btScalar t, t2;
+		int i;
+
+		// Class I : A's basis vectors
+		for (i = 0; i < 3; i++)
+		{
+			T[i] = transcache.m_R1to0[i].dot(cb) + transcache.m_T1to0[i] - ca[i];
+			t = transcache.m_AR[i].dot(eb) + ea[i];
+			if (GIM_GREATER(T[i], t)) return false;
+		}
+		// Class II : B's basis vectors
+		for (i = 0; i < 3; i++)
+		{
+			t = MAT_DOT_COL(transcache.m_R1to0, T, i);
+			t2 = MAT_DOT_COL(transcache.m_AR, ea, i) + eb[i];
+			if (GIM_GREATER(t, t2)) return false;
+		}
+		// Class III : 9 cross products
+		if (fulltest)
+		{
+			int j, m, n, o, p, q, r;
+			for (i = 0; i < 3; i++)
+			{
+				m = (i + 1) % 3;
+				n = (i + 2) % 3;
+				o = i == 0 ? 1 : 0;
+				p = i == 2 ? 1 : 2;
+				for (j = 0; j < 3; j++)
+				{
+					q = j == 2 ? 1 : 2;
+					r = j == 0 ? 1 : 0;
+					t = T[n] * transcache.m_R1to0[m][j] - T[m] * transcache.m_R1to0[n][j];
+					t2 = ea[o] * transcache.m_AR[p][j] + ea[p] * transcache.m_AR[o][j] +
+						 eb[r] * transcache.m_AR[i][q] + eb[q] * transcache.m_AR[i][r];
+					if (GIM_GREATER(t, t2)) return false;
+				}
+			}
+		}
+		return true;
+	}
+
+	//! Simple test for planes.
+	SIMD_FORCE_INLINE bool collide_plane(
+		const btVector4 &plane)
+	{
+		ePLANE_INTERSECTION_TYPE classify = plane_classify(plane);
+		return (classify == G_COLLIDE_PLANE);
+	}
+
+	//! test for a triangle, with edges
+	SIMD_FORCE_INLINE bool collide_triangle_exact(
+		const btVector3 &p1,
+		const btVector3 &p2,
+		const btVector3 &p3,
+		const btVector4 &triangle_plane)
+	{
+		if (!collide_plane(triangle_plane)) return false;
+
+		btVector3 center, extends;
+		this->get_center_extend(center, extends);
+
+		const btVector3 v1(p1 - center);
+		const btVector3 v2(p2 - center);
+		const btVector3 v3(p3 - center);
+
+		//First axis
+		btVector3 diff(v2 - v1);
+		btVector3 abs_diff = diff.absolute();
+		//Test With X axis
+		TEST_CROSS_EDGE_BOX_X_AXIS_MCR(diff, abs_diff, v1, v3, extends);
+		//Test With Y axis
+		TEST_CROSS_EDGE_BOX_Y_AXIS_MCR(diff, abs_diff, v1, v3, extends);
+		//Test With Z axis
+		TEST_CROSS_EDGE_BOX_Z_AXIS_MCR(diff, abs_diff, v1, v3, extends);
+
+		diff = v3 - v2;
+		abs_diff = diff.absolute();
+		//Test With X axis
+		TEST_CROSS_EDGE_BOX_X_AXIS_MCR(diff, abs_diff, v2, v1, extends);
+		//Test With Y axis
+		TEST_CROSS_EDGE_BOX_Y_AXIS_MCR(diff, abs_diff, v2, v1, extends);
+		//Test With Z axis
+		TEST_CROSS_EDGE_BOX_Z_AXIS_MCR(diff, abs_diff, v2, v1, extends);
+
+		diff = v1 - v3;
+		abs_diff = diff.absolute();
+		//Test With X axis
+		TEST_CROSS_EDGE_BOX_X_AXIS_MCR(diff, abs_diff, v3, v2, extends);
+		//Test With Y axis
+		TEST_CROSS_EDGE_BOX_Y_AXIS_MCR(diff, abs_diff, v3, v2, extends);
+		//Test With Z axis
+		TEST_CROSS_EDGE_BOX_Z_AXIS_MCR(diff, abs_diff, v3, v2, extends);
+
+		return true;
+	}
+};
+
+#ifndef BT_BOX_COLLISION_H_INCLUDED
+//! Compairison of transformation objects
+SIMD_FORCE_INLINE bool btCompareTransformsEqual(const btTransform &t1, const btTransform &t2)
+{
+	if (!(t1.getOrigin() == t2.getOrigin())) return false;
+
+	if (!(t1.getBasis().getRow(0) == t2.getBasis().getRow(0))) return false;
+	if (!(t1.getBasis().getRow(1) == t2.getBasis().getRow(1))) return false;
+	if (!(t1.getBasis().getRow(2) == t2.getBasis().getRow(2))) return false;
+	return true;
+}
+#endif
+
+#endif  // GIM_BOX_COLLISION_H_INCLUDED
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/gim_box_set.h b/engine/inc/bullet/BulletCollision/Gimpact/gim_box_set.h
new file mode 100644
index 00000000..afc591da
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/gim_box_set.h
@@ -0,0 +1,640 @@
+#ifndef GIM_BOX_SET_H_INCLUDED
+#define GIM_BOX_SET_H_INCLUDED
+
+/*! \file gim_box_set.h
+\author Francisco Leon Najera
+*/
+/*
+-----------------------------------------------------------------------------
+This source file is part of GIMPACT Library.
+
+For the latest info, see http://gimpact.sourceforge.net/
+
+Copyright (c) 2006 Francisco Leon Najera. C.C. 80087371.
+email: projectileman@yahoo.com
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of EITHER:
+   (1) The GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 2.1 of the License, or (at
+       your option) any later version. The text of the GNU Lesser
+       General Public License is included with this library in the
+       file GIMPACT-LICENSE-LGPL.TXT.
+   (2) The BSD-style license that is included with this library in
+       the file GIMPACT-LICENSE-BSD.TXT.
+   (3) The zlib/libpng license that is included with this library in
+       the file GIMPACT-LICENSE-ZLIB.TXT.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files
+ GIMPACT-LICENSE-LGPL.TXT, GIMPACT-LICENSE-ZLIB.TXT and GIMPACT-LICENSE-BSD.TXT for more details.
+
+-----------------------------------------------------------------------------
+*/
+
+#include "gim_array.h"
+#include "gim_radixsort.h"
+#include "gim_box_collision.h"
+#include "gim_tri_collision.h"
+#include "gim_pair.h"
+
+//! A pairset array
+class gim_pair_set : public gim_array<GIM_PAIR>
+{
+public:
+	gim_pair_set() : gim_array<GIM_PAIR>(32)
+	{
+	}
+	inline void push_pair(GUINT index1, GUINT index2)
+	{
+		push_back(GIM_PAIR(index1, index2));
+	}
+
+	inline void push_pair_inv(GUINT index1, GUINT index2)
+	{
+		push_back(GIM_PAIR(index2, index1));
+	}
+};
+
+//! Prototype Base class for primitive classification
+/*!
+This class is a wrapper for primitive collections.
+This tells relevant info for the Bounding Box set classes, which take care of space classification.
+This class can manage Compound shapes and trimeshes, and if it is managing trimesh then the  Hierarchy Bounding Box classes will take advantage of primitive Vs Box overlapping tests for getting optimal results and less Per Box compairisons.
+*/
+class GIM_PRIMITIVE_MANAGER_PROTOTYPE
+{
+public:
+	virtual ~GIM_PRIMITIVE_MANAGER_PROTOTYPE() {}
+	//! determines if this manager consist on only triangles, which special case will be optimized
+	virtual bool is_trimesh() = 0;
+	virtual GUINT get_primitive_count() = 0;
+	virtual void get_primitive_box(GUINT prim_index, GIM_AABB& primbox) = 0;
+	virtual void get_primitive_triangle(GUINT prim_index, GIM_TRIANGLE& triangle) = 0;
+};
+
+struct GIM_AABB_DATA
+{
+	GIM_AABB m_bound;
+	GUINT m_data;
+};
+
+//! Node Structure for trees
+struct GIM_BOX_TREE_NODE
+{
+	GIM_AABB m_bound;
+	GUINT m_left;         //!< Left subtree
+	GUINT m_right;        //!< Right subtree
+	GUINT m_escapeIndex;  //!< Scape index for traversing
+	GUINT m_data;         //!< primitive index if apply
+
+	GIM_BOX_TREE_NODE()
+	{
+		m_left = 0;
+		m_right = 0;
+		m_escapeIndex = 0;
+		m_data = 0;
+	}
+
+	SIMD_FORCE_INLINE bool is_leaf_node() const
+	{
+		return (!m_left && !m_right);
+	}
+};
+
+//! Basic Box tree structure
+class GIM_BOX_TREE
+{
+protected:
+	GUINT m_num_nodes;
+	gim_array<GIM_BOX_TREE_NODE> m_node_array;
+
+protected:
+	GUINT _sort_and_calc_splitting_index(
+		gim_array<GIM_AABB_DATA>& primitive_boxes,
+		GUINT startIndex, GUINT endIndex, GUINT splitAxis);
+
+	GUINT _calc_splitting_axis(gim_array<GIM_AABB_DATA>& primitive_boxes, GUINT startIndex, GUINT endIndex);
+
+	void _build_sub_tree(gim_array<GIM_AABB_DATA>& primitive_boxes, GUINT startIndex, GUINT endIndex);
+
+public:
+	GIM_BOX_TREE()
+	{
+		m_num_nodes = 0;
+	}
+
+	//! prototype functions for box tree management
+	//!@{
+	void build_tree(gim_array<GIM_AABB_DATA>& primitive_boxes);
+
+	SIMD_FORCE_INLINE void clearNodes()
+	{
+		m_node_array.clear();
+		m_num_nodes = 0;
+	}
+
+	//! node count
+	SIMD_FORCE_INLINE GUINT getNodeCount() const
+	{
+		return m_num_nodes;
+	}
+
+	//! tells if the node is a leaf
+	SIMD_FORCE_INLINE bool isLeafNode(GUINT nodeindex) const
+	{
+		return m_node_array[nodeindex].is_leaf_node();
+	}
+
+	SIMD_FORCE_INLINE GUINT getNodeData(GUINT nodeindex) const
+	{
+		return m_node_array[nodeindex].m_data;
+	}
+
+	SIMD_FORCE_INLINE void getNodeBound(GUINT nodeindex, GIM_AABB& bound) const
+	{
+		bound = m_node_array[nodeindex].m_bound;
+	}
+
+	SIMD_FORCE_INLINE void setNodeBound(GUINT nodeindex, const GIM_AABB& bound)
+	{
+		m_node_array[nodeindex].m_bound = bound;
+	}
+
+	SIMD_FORCE_INLINE GUINT getLeftNodeIndex(GUINT nodeindex) const
+	{
+		return m_node_array[nodeindex].m_left;
+	}
+
+	SIMD_FORCE_INLINE GUINT getRightNodeIndex(GUINT nodeindex) const
+	{
+		return m_node_array[nodeindex].m_right;
+	}
+
+	SIMD_FORCE_INLINE GUINT getScapeNodeIndex(GUINT nodeindex) const
+	{
+		return m_node_array[nodeindex].m_escapeIndex;
+	}
+
+	//!@}
+};
+
+//! Generic Box Tree Template
+/*!
+This class offers an structure for managing a box tree of primitives.
+Requires a Primitive prototype (like GIM_PRIMITIVE_MANAGER_PROTOTYPE ) and
+a Box tree structure ( like GIM_BOX_TREE).
+*/
+template <typename _GIM_PRIMITIVE_MANAGER_PROTOTYPE, typename _GIM_BOX_TREE_PROTOTYPE>
+class GIM_BOX_TREE_TEMPLATE_SET
+{
+protected:
+	_GIM_PRIMITIVE_MANAGER_PROTOTYPE m_primitive_manager;
+	_GIM_BOX_TREE_PROTOTYPE m_box_tree;
+
+protected:
+	//stackless refit
+	SIMD_FORCE_INLINE void refit()
+	{
+		GUINT nodecount = getNodeCount();
+		while (nodecount--)
+		{
+			if (isLeafNode(nodecount))
+			{
+				GIM_AABB leafbox;
+				m_primitive_manager.get_primitive_box(getNodeData(nodecount), leafbox);
+				setNodeBound(nodecount, leafbox);
+			}
+			else
+			{
+				//get left bound
+				GUINT childindex = getLeftNodeIndex(nodecount);
+				GIM_AABB bound;
+				getNodeBound(childindex, bound);
+				//get right bound
+				childindex = getRightNodeIndex(nodecount);
+				GIM_AABB bound2;
+				getNodeBound(childindex, bound2);
+				bound.merge(bound2);
+
+				setNodeBound(nodecount, bound);
+			}
+		}
+	}
+
+public:
+	GIM_BOX_TREE_TEMPLATE_SET()
+	{
+	}
+
+	SIMD_FORCE_INLINE GIM_AABB getGlobalBox() const
+	{
+		GIM_AABB totalbox;
+		getNodeBound(0, totalbox);
+		return totalbox;
+	}
+
+	SIMD_FORCE_INLINE void setPrimitiveManager(const _GIM_PRIMITIVE_MANAGER_PROTOTYPE& primitive_manager)
+	{
+		m_primitive_manager = primitive_manager;
+	}
+
+	const _GIM_PRIMITIVE_MANAGER_PROTOTYPE& getPrimitiveManager() const
+	{
+		return m_primitive_manager;
+	}
+
+	_GIM_PRIMITIVE_MANAGER_PROTOTYPE& getPrimitiveManager()
+	{
+		return m_primitive_manager;
+	}
+
+	//! node manager prototype functions
+	///@{
+
+	//! this attemps to refit the box set.
+	SIMD_FORCE_INLINE void update()
+	{
+		refit();
+	}
+
+	//! this rebuild the entire set
+	SIMD_FORCE_INLINE void buildSet()
+	{
+		//obtain primitive boxes
+		gim_array<GIM_AABB_DATA> primitive_boxes;
+		primitive_boxes.resize(m_primitive_manager.get_primitive_count(), false);
+
+		for (GUINT i = 0; i < primitive_boxes.size(); i++)
+		{
+			m_primitive_manager.get_primitive_box(i, primitive_boxes[i].m_bound);
+			primitive_boxes[i].m_data = i;
+		}
+
+		m_box_tree.build_tree(primitive_boxes);
+	}
+
+	//! returns the indices of the primitives in the m_primitive_manager
+	SIMD_FORCE_INLINE bool boxQuery(const GIM_AABB& box, gim_array<GUINT>& collided_results) const
+	{
+		GUINT curIndex = 0;
+		GUINT numNodes = getNodeCount();
+
+		while (curIndex < numNodes)
+		{
+			GIM_AABB bound;
+			getNodeBound(curIndex, bound);
+
+			//catch bugs in tree data
+
+			bool aabbOverlap = bound.has_collision(box);
+			bool isleafnode = isLeafNode(curIndex);
+
+			if (isleafnode && aabbOverlap)
+			{
+				collided_results.push_back(getNodeData(curIndex));
+			}
+
+			if (aabbOverlap || isleafnode)
+			{
+				//next subnode
+				curIndex++;
+			}
+			else
+			{
+				//skip node
+				curIndex += getScapeNodeIndex(curIndex);
+			}
+		}
+		if (collided_results.size() > 0) return true;
+		return false;
+	}
+
+	//! returns the indices of the primitives in the m_primitive_manager
+	SIMD_FORCE_INLINE bool boxQueryTrans(const GIM_AABB& box,
+										 const btTransform& transform, gim_array<GUINT>& collided_results) const
+	{
+		GIM_AABB transbox = box;
+		transbox.appy_transform(transform);
+		return boxQuery(transbox, collided_results);
+	}
+
+	//! returns the indices of the primitives in the m_primitive_manager
+	SIMD_FORCE_INLINE bool rayQuery(
+		const btVector3& ray_dir, const btVector3& ray_origin,
+		gim_array<GUINT>& collided_results) const
+	{
+		GUINT curIndex = 0;
+		GUINT numNodes = getNodeCount();
+
+		while (curIndex < numNodes)
+		{
+			GIM_AABB bound;
+			getNodeBound(curIndex, bound);
+
+			//catch bugs in tree data
+
+			bool aabbOverlap = bound.collide_ray(ray_origin, ray_dir);
+			bool isleafnode = isLeafNode(curIndex);
+
+			if (isleafnode && aabbOverlap)
+			{
+				collided_results.push_back(getNodeData(curIndex));
+			}
+
+			if (aabbOverlap || isleafnode)
+			{
+				//next subnode
+				curIndex++;
+			}
+			else
+			{
+				//skip node
+				curIndex += getScapeNodeIndex(curIndex);
+			}
+		}
+		if (collided_results.size() > 0) return true;
+		return false;
+	}
+
+	//! tells if this set has hierarcht
+	SIMD_FORCE_INLINE bool hasHierarchy() const
+	{
+		return true;
+	}
+
+	//! tells if this set is a trimesh
+	SIMD_FORCE_INLINE bool isTrimesh() const
+	{
+		return m_primitive_manager.is_trimesh();
+	}
+
+	//! node count
+	SIMD_FORCE_INLINE GUINT getNodeCount() const
+	{
+		return m_box_tree.getNodeCount();
+	}
+
+	//! tells if the node is a leaf
+	SIMD_FORCE_INLINE bool isLeafNode(GUINT nodeindex) const
+	{
+		return m_box_tree.isLeafNode(nodeindex);
+	}
+
+	SIMD_FORCE_INLINE GUINT getNodeData(GUINT nodeindex) const
+	{
+		return m_box_tree.getNodeData(nodeindex);
+	}
+
+	SIMD_FORCE_INLINE void getNodeBound(GUINT nodeindex, GIM_AABB& bound) const
+	{
+		m_box_tree.getNodeBound(nodeindex, bound);
+	}
+
+	SIMD_FORCE_INLINE void setNodeBound(GUINT nodeindex, const GIM_AABB& bound)
+	{
+		m_box_tree.setNodeBound(nodeindex, bound);
+	}
+
+	SIMD_FORCE_INLINE GUINT getLeftNodeIndex(GUINT nodeindex) const
+	{
+		return m_box_tree.getLeftNodeIndex(nodeindex);
+	}
+
+	SIMD_FORCE_INLINE GUINT getRightNodeIndex(GUINT nodeindex) const
+	{
+		return m_box_tree.getRightNodeIndex(nodeindex);
+	}
+
+	SIMD_FORCE_INLINE GUINT getScapeNodeIndex(GUINT nodeindex) const
+	{
+		return m_box_tree.getScapeNodeIndex(nodeindex);
+	}
+
+	SIMD_FORCE_INLINE void getNodeTriangle(GUINT nodeindex, GIM_TRIANGLE& triangle) const
+	{
+		m_primitive_manager.get_primitive_triangle(getNodeData(nodeindex), triangle);
+	}
+};
+
+//! Class for Box Tree Sets
+/*!
+this has the GIM_BOX_TREE implementation for bounding boxes.
+*/
+template <typename _GIM_PRIMITIVE_MANAGER_PROTOTYPE>
+class GIM_BOX_TREE_SET : public GIM_BOX_TREE_TEMPLATE_SET<_GIM_PRIMITIVE_MANAGER_PROTOTYPE, GIM_BOX_TREE>
+{
+public:
+};
+
+/// GIM_BOX_SET collision methods
+template <typename BOX_SET_CLASS0, typename BOX_SET_CLASS1>
+class GIM_TREE_TREE_COLLIDER
+{
+public:
+	gim_pair_set* m_collision_pairs;
+	BOX_SET_CLASS0* m_boxset0;
+	BOX_SET_CLASS1* m_boxset1;
+	GUINT current_node0;
+	GUINT current_node1;
+	bool node0_is_leaf;
+	bool node1_is_leaf;
+	bool t0_is_trimesh;
+	bool t1_is_trimesh;
+	bool node0_has_triangle;
+	bool node1_has_triangle;
+	GIM_AABB m_box0;
+	GIM_AABB m_box1;
+	GIM_BOX_BOX_TRANSFORM_CACHE trans_cache_1to0;
+	btTransform trans_cache_0to1;
+	GIM_TRIANGLE m_tri0;
+	btVector4 m_tri0_plane;
+	GIM_TRIANGLE m_tri1;
+	btVector4 m_tri1_plane;
+
+public:
+	GIM_TREE_TREE_COLLIDER()
+	{
+		current_node0 = G_UINT_INFINITY;
+		current_node1 = G_UINT_INFINITY;
+	}
+
+protected:
+	SIMD_FORCE_INLINE void retrieve_node0_triangle(GUINT node0)
+	{
+		if (node0_has_triangle) return;
+		m_boxset0->getNodeTriangle(node0, m_tri0);
+		//transform triangle
+		m_tri0.m_vertices[0] = trans_cache_0to1(m_tri0.m_vertices[0]);
+		m_tri0.m_vertices[1] = trans_cache_0to1(m_tri0.m_vertices[1]);
+		m_tri0.m_vertices[2] = trans_cache_0to1(m_tri0.m_vertices[2]);
+		m_tri0.get_plane(m_tri0_plane);
+
+		node0_has_triangle = true;
+	}
+
+	SIMD_FORCE_INLINE void retrieve_node1_triangle(GUINT node1)
+	{
+		if (node1_has_triangle) return;
+		m_boxset1->getNodeTriangle(node1, m_tri1);
+		//transform triangle
+		m_tri1.m_vertices[0] = trans_cache_1to0.transform(m_tri1.m_vertices[0]);
+		m_tri1.m_vertices[1] = trans_cache_1to0.transform(m_tri1.m_vertices[1]);
+		m_tri1.m_vertices[2] = trans_cache_1to0.transform(m_tri1.m_vertices[2]);
+		m_tri1.get_plane(m_tri1_plane);
+
+		node1_has_triangle = true;
+	}
+
+	SIMD_FORCE_INLINE void retrieve_node0_info(GUINT node0)
+	{
+		if (node0 == current_node0) return;
+		m_boxset0->getNodeBound(node0, m_box0);
+		node0_is_leaf = m_boxset0->isLeafNode(node0);
+		node0_has_triangle = false;
+		current_node0 = node0;
+	}
+
+	SIMD_FORCE_INLINE void retrieve_node1_info(GUINT node1)
+	{
+		if (node1 == current_node1) return;
+		m_boxset1->getNodeBound(node1, m_box1);
+		node1_is_leaf = m_boxset1->isLeafNode(node1);
+		node1_has_triangle = false;
+		current_node1 = node1;
+	}
+
+	SIMD_FORCE_INLINE bool node_collision(GUINT node0, GUINT node1)
+	{
+		retrieve_node0_info(node0);
+		retrieve_node1_info(node1);
+		bool result = m_box0.overlapping_trans_cache(m_box1, trans_cache_1to0, true);
+		if (!result) return false;
+
+		if (t0_is_trimesh && node0_is_leaf)
+		{
+			//perform primitive vs box collision
+			retrieve_node0_triangle(node0);
+			//do triangle vs box collision
+			m_box1.increment_margin(m_tri0.m_margin);
+
+			result = m_box1.collide_triangle_exact(
+				m_tri0.m_vertices[0], m_tri0.m_vertices[1], m_tri0.m_vertices[2], m_tri0_plane);
+
+			m_box1.increment_margin(-m_tri0.m_margin);
+
+			if (!result) return false;
+			return true;
+		}
+		else if (t1_is_trimesh && node1_is_leaf)
+		{
+			//perform primitive vs box collision
+			retrieve_node1_triangle(node1);
+			//do triangle vs box collision
+			m_box0.increment_margin(m_tri1.m_margin);
+
+			result = m_box0.collide_triangle_exact(
+				m_tri1.m_vertices[0], m_tri1.m_vertices[1], m_tri1.m_vertices[2], m_tri1_plane);
+
+			m_box0.increment_margin(-m_tri1.m_margin);
+
+			if (!result) return false;
+			return true;
+		}
+		return true;
+	}
+
+	//stackless collision routine
+	void find_collision_pairs()
+	{
+		gim_pair_set stack_collisions;
+		stack_collisions.reserve(32);
+
+		//add the first pair
+		stack_collisions.push_pair(0, 0);
+
+		while (stack_collisions.size())
+		{
+			//retrieve the last pair and pop
+			GUINT node0 = stack_collisions.back().m_index1;
+			GUINT node1 = stack_collisions.back().m_index2;
+			stack_collisions.pop_back();
+			if (node_collision(node0, node1))  // a collision is found
+			{
+				if (node0_is_leaf)
+				{
+					if (node1_is_leaf)
+					{
+						m_collision_pairs->push_pair(m_boxset0->getNodeData(node0), m_boxset1->getNodeData(node1));
+					}
+					else
+					{
+						//collide left
+						stack_collisions.push_pair(node0, m_boxset1->getLeftNodeIndex(node1));
+
+						//collide right
+						stack_collisions.push_pair(node0, m_boxset1->getRightNodeIndex(node1));
+					}
+				}
+				else
+				{
+					if (node1_is_leaf)
+					{
+						//collide left
+						stack_collisions.push_pair(m_boxset0->getLeftNodeIndex(node0), node1);
+						//collide right
+						stack_collisions.push_pair(m_boxset0->getRightNodeIndex(node0), node1);
+					}
+					else
+					{
+						GUINT left0 = m_boxset0->getLeftNodeIndex(node0);
+						GUINT right0 = m_boxset0->getRightNodeIndex(node0);
+						GUINT left1 = m_boxset1->getLeftNodeIndex(node1);
+						GUINT right1 = m_boxset1->getRightNodeIndex(node1);
+						//collide left
+						stack_collisions.push_pair(left0, left1);
+						//collide right
+						stack_collisions.push_pair(left0, right1);
+						//collide left
+						stack_collisions.push_pair(right0, left1);
+						//collide right
+						stack_collisions.push_pair(right0, right1);
+
+					}  // else if node1 is not a leaf
+				}      // else if node0 is not a leaf
+
+			}  // if(node_collision(node0,node1))
+		}      //while(stack_collisions.size())
+	}
+
+public:
+	void find_collision(BOX_SET_CLASS0* boxset1, const btTransform& trans1,
+						BOX_SET_CLASS1* boxset2, const btTransform& trans2,
+						gim_pair_set& collision_pairs, bool complete_primitive_tests = true)
+	{
+		m_collision_pairs = &collision_pairs;
+		m_boxset0 = boxset1;
+		m_boxset1 = boxset2;
+
+		trans_cache_1to0.calc_from_homogenic(trans1, trans2);
+
+		trans_cache_0to1 = trans2.inverse();
+		trans_cache_0to1 *= trans1;
+
+		if (complete_primitive_tests)
+		{
+			t0_is_trimesh = boxset1->getPrimitiveManager().is_trimesh();
+			t1_is_trimesh = boxset2->getPrimitiveManager().is_trimesh();
+		}
+		else
+		{
+			t0_is_trimesh = false;
+			t1_is_trimesh = false;
+		}
+
+		find_collision_pairs();
+	}
+};
+
+#endif  // GIM_BOXPRUNING_H_INCLUDED
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/gim_clip_polygon.h b/engine/inc/bullet/BulletCollision/Gimpact/gim_clip_polygon.h
new file mode 100644
index 00000000..57b9c5c9
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/gim_clip_polygon.h
@@ -0,0 +1,199 @@
+#ifndef GIM_CLIP_POLYGON_H_INCLUDED
+#define GIM_CLIP_POLYGON_H_INCLUDED
+
+/*! \file gim_tri_collision.h
+\author Francisco Leon Najera
+*/
+/*
+-----------------------------------------------------------------------------
+This source file is part of GIMPACT Library.
+
+For the latest info, see http://gimpact.sourceforge.net/
+
+Copyright (c) 2006 Francisco Leon Najera. C.C. 80087371.
+email: projectileman@yahoo.com
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of EITHER:
+   (1) The GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 2.1 of the License, or (at
+       your option) any later version. The text of the GNU Lesser
+       General Public License is included with this library in the
+       file GIMPACT-LICENSE-LGPL.TXT.
+   (2) The BSD-style license that is included with this library in
+       the file GIMPACT-LICENSE-BSD.TXT.
+   (3) The zlib/libpng license that is included with this library in
+       the file GIMPACT-LICENSE-ZLIB.TXT.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files
+ GIMPACT-LICENSE-LGPL.TXT, GIMPACT-LICENSE-ZLIB.TXT and GIMPACT-LICENSE-BSD.TXT for more details.
+
+-----------------------------------------------------------------------------
+*/
+
+//! This function calcs the distance from a 3D plane
+class DISTANCE_PLANE_3D_FUNC
+{
+public:
+	template <typename CLASS_POINT, typename CLASS_PLANE>
+	inline GREAL operator()(const CLASS_PLANE& plane, const CLASS_POINT& point)
+	{
+		return DISTANCE_PLANE_POINT(plane, point);
+	}
+};
+
+template <typename CLASS_POINT>
+SIMD_FORCE_INLINE void PLANE_CLIP_POLYGON_COLLECT(
+	const CLASS_POINT& point0,
+	const CLASS_POINT& point1,
+	GREAL dist0,
+	GREAL dist1,
+	CLASS_POINT* clipped,
+	GUINT& clipped_count)
+{
+	GUINT _prevclassif = (dist0 > G_EPSILON);
+	GUINT _classif = (dist1 > G_EPSILON);
+	if (_classif != _prevclassif)
+	{
+		GREAL blendfactor = -dist0 / (dist1 - dist0);
+		VEC_BLEND(clipped[clipped_count], point0, point1, blendfactor);
+		clipped_count++;
+	}
+	if (!_classif)
+	{
+		VEC_COPY(clipped[clipped_count], point1);
+		clipped_count++;
+	}
+}
+
+//! Clips a polygon by a plane
+/*!
+*\return The count of the clipped counts
+*/
+template <typename CLASS_POINT, typename CLASS_PLANE, typename DISTANCE_PLANE_FUNC>
+SIMD_FORCE_INLINE GUINT PLANE_CLIP_POLYGON_GENERIC(
+	const CLASS_PLANE& plane,
+	const CLASS_POINT* polygon_points,
+	GUINT polygon_point_count,
+	CLASS_POINT* clipped, DISTANCE_PLANE_FUNC distance_func)
+{
+	GUINT clipped_count = 0;
+
+	//clip first point
+	GREAL firstdist = distance_func(plane, polygon_points[0]);
+	;
+	if (!(firstdist > G_EPSILON))
+	{
+		VEC_COPY(clipped[clipped_count], polygon_points[0]);
+		clipped_count++;
+	}
+
+	GREAL olddist = firstdist;
+	for (GUINT _i = 1; _i < polygon_point_count; _i++)
+	{
+		GREAL dist = distance_func(plane, polygon_points[_i]);
+
+		PLANE_CLIP_POLYGON_COLLECT(
+			polygon_points[_i - 1], polygon_points[_i],
+			olddist,
+			dist,
+			clipped,
+			clipped_count);
+
+		olddist = dist;
+	}
+
+	//RETURN TO FIRST  point
+
+	PLANE_CLIP_POLYGON_COLLECT(
+		polygon_points[polygon_point_count - 1], polygon_points[0],
+		olddist,
+		firstdist,
+		clipped,
+		clipped_count);
+
+	return clipped_count;
+}
+
+//! Clips a polygon by a plane
+/*!
+*\return The count of the clipped counts
+*/
+template <typename CLASS_POINT, typename CLASS_PLANE, typename DISTANCE_PLANE_FUNC>
+SIMD_FORCE_INLINE GUINT PLANE_CLIP_TRIANGLE_GENERIC(
+	const CLASS_PLANE& plane,
+	const CLASS_POINT& point0,
+	const CLASS_POINT& point1,
+	const CLASS_POINT& point2,
+	CLASS_POINT* clipped, DISTANCE_PLANE_FUNC distance_func)
+{
+	GUINT clipped_count = 0;
+
+	//clip first point
+	GREAL firstdist = distance_func(plane, point0);
+	;
+	if (!(firstdist > G_EPSILON))
+	{
+		VEC_COPY(clipped[clipped_count], point0);
+		clipped_count++;
+	}
+
+	// point 1
+	GREAL olddist = firstdist;
+	GREAL dist = distance_func(plane, point1);
+
+	PLANE_CLIP_POLYGON_COLLECT(
+		point0, point1,
+		olddist,
+		dist,
+		clipped,
+		clipped_count);
+
+	olddist = dist;
+
+	// point 2
+	dist = distance_func(plane, point2);
+
+	PLANE_CLIP_POLYGON_COLLECT(
+		point1, point2,
+		olddist,
+		dist,
+		clipped,
+		clipped_count);
+	olddist = dist;
+
+	//RETURN TO FIRST  point
+	PLANE_CLIP_POLYGON_COLLECT(
+		point2, point0,
+		olddist,
+		firstdist,
+		clipped,
+		clipped_count);
+
+	return clipped_count;
+}
+
+template <typename CLASS_POINT, typename CLASS_PLANE>
+SIMD_FORCE_INLINE GUINT PLANE_CLIP_POLYGON3D(
+	const CLASS_PLANE& plane,
+	const CLASS_POINT* polygon_points,
+	GUINT polygon_point_count,
+	CLASS_POINT* clipped)
+{
+	return PLANE_CLIP_POLYGON_GENERIC<CLASS_POINT, CLASS_PLANE>(plane, polygon_points, polygon_point_count, clipped, DISTANCE_PLANE_3D_FUNC());
+}
+
+template <typename CLASS_POINT, typename CLASS_PLANE>
+SIMD_FORCE_INLINE GUINT PLANE_CLIP_TRIANGLE3D(
+	const CLASS_PLANE& plane,
+	const CLASS_POINT& point0,
+	const CLASS_POINT& point1,
+	const CLASS_POINT& point2,
+	CLASS_POINT* clipped)
+{
+	return PLANE_CLIP_TRIANGLE_GENERIC<CLASS_POINT, CLASS_PLANE>(plane, point0, point1, point2, clipped, DISTANCE_PLANE_3D_FUNC());
+}
+
+#endif  // GIM_TRI_COLLISION_H_INCLUDED
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/gim_contact.h b/engine/inc/bullet/BulletCollision/Gimpact/gim_contact.h
new file mode 100644
index 00000000..9deb28a2
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/gim_contact.h
@@ -0,0 +1,168 @@
+#ifndef GIM_CONTACT_H_INCLUDED
+#define GIM_CONTACT_H_INCLUDED
+
+/*! \file gim_contact.h
+\author Francisco Leon Najera
+*/
+/*
+-----------------------------------------------------------------------------
+This source file is part of GIMPACT Library.
+
+For the latest info, see http://gimpact.sourceforge.net/
+
+Copyright (c) 2006 Francisco Leon Najera. C.C. 80087371.
+email: projectileman@yahoo.com
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of EITHER:
+   (1) The GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 2.1 of the License, or (at
+       your option) any later version. The text of the GNU Lesser
+       General Public License is included with this library in the
+       file GIMPACT-LICENSE-LGPL.TXT.
+   (2) The BSD-style license that is included with this library in
+       the file GIMPACT-LICENSE-BSD.TXT.
+   (3) The zlib/libpng license that is included with this library in
+       the file GIMPACT-LICENSE-ZLIB.TXT.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files
+ GIMPACT-LICENSE-LGPL.TXT, GIMPACT-LICENSE-ZLIB.TXT and GIMPACT-LICENSE-BSD.TXT for more details.
+
+-----------------------------------------------------------------------------
+*/
+#include "gim_geometry.h"
+#include "gim_radixsort.h"
+#include "gim_array.h"
+
+/**
+Configuration var for applying interpolation of  contact normals
+*/
+#ifndef NORMAL_CONTACT_AVERAGE
+#define NORMAL_CONTACT_AVERAGE 1
+#endif
+
+#ifndef CONTACT_DIFF_EPSILON
+#define CONTACT_DIFF_EPSILON 0.00001f
+#endif
+
+#ifndef BT_CONTACT_H_STRUCTS_INCLUDED
+
+/// Structure for collision results
+///Functions for managing and sorting contacts resulting from a collision query.
+///Contact lists must be create by calling \ref GIM_CREATE_CONTACT_LIST
+///After querys, contact lists must be destroy by calling \ref GIM_DYNARRAY_DESTROY
+///Contacts can be merge for avoid duplicate results by calling \ref gim_merge_contacts
+class GIM_CONTACT
+{
+public:
+	btVector3 m_point;
+	btVector3 m_normal;
+	GREAL m_depth;     //Positive value indicates interpenetration
+	GREAL m_distance;  //Padding not for use
+	GUINT m_feature1;  //Face number
+	GUINT m_feature2;  //Face number
+public:
+	GIM_CONTACT()
+	{
+	}
+
+	GIM_CONTACT(const GIM_CONTACT &contact) : m_point(contact.m_point),
+											  m_normal(contact.m_normal),
+											  m_depth(contact.m_depth),
+											  m_feature1(contact.m_feature1),
+											  m_feature2(contact.m_feature2)
+	{
+		m_point = contact.m_point;
+		m_normal = contact.m_normal;
+		m_depth = contact.m_depth;
+		m_feature1 = contact.m_feature1;
+		m_feature2 = contact.m_feature2;
+	}
+
+	GIM_CONTACT(const btVector3 &point, const btVector3 &normal,
+				GREAL depth, GUINT feature1, GUINT feature2) : m_point(point),
+															   m_normal(normal),
+															   m_depth(depth),
+															   m_feature1(feature1),
+															   m_feature2(feature2)
+	{
+	}
+
+	//! Calcs key for coord classification
+	SIMD_FORCE_INLINE GUINT calc_key_contact() const
+	{
+		GINT _coords[] = {
+			(GINT)(m_point[0] * 1000.0f + 1.0f),
+			(GINT)(m_point[1] * 1333.0f),
+			(GINT)(m_point[2] * 2133.0f + 3.0f)};
+		GUINT _hash = 0;
+		GUINT *_uitmp = (GUINT *)(&_coords[0]);
+		_hash = *_uitmp;
+		_uitmp++;
+		_hash += (*_uitmp) << 4;
+		_uitmp++;
+		_hash += (*_uitmp) << 8;
+		return _hash;
+	}
+
+	SIMD_FORCE_INLINE void interpolate_normals(btVector3 *normals, GUINT normal_count)
+	{
+		btVector3 vec_sum(m_normal);
+		for (GUINT i = 0; i < normal_count; i++)
+		{
+			vec_sum += normals[i];
+		}
+
+		GREAL vec_sum_len = vec_sum.length2();
+		if (vec_sum_len < CONTACT_DIFF_EPSILON) return;
+
+		GIM_INV_SQRT(vec_sum_len, vec_sum_len);  // 1/sqrt(vec_sum_len)
+
+		m_normal = vec_sum * vec_sum_len;
+	}
+};
+
+#endif
+
+class gim_contact_array : public gim_array<GIM_CONTACT>
+{
+public:
+	gim_contact_array() : gim_array<GIM_CONTACT>(64)
+	{
+	}
+
+	SIMD_FORCE_INLINE void push_contact(const btVector3 &point, const btVector3 &normal,
+										GREAL depth, GUINT feature1, GUINT feature2)
+	{
+		push_back_mem();
+		GIM_CONTACT &newele = back();
+		newele.m_point = point;
+		newele.m_normal = normal;
+		newele.m_depth = depth;
+		newele.m_feature1 = feature1;
+		newele.m_feature2 = feature2;
+	}
+
+	SIMD_FORCE_INLINE void push_triangle_contacts(
+		const GIM_TRIANGLE_CONTACT_DATA &tricontact,
+		GUINT feature1, GUINT feature2)
+	{
+		for (GUINT i = 0; i < tricontact.m_point_count; i++)
+		{
+			push_back_mem();
+			GIM_CONTACT &newele = back();
+			newele.m_point = tricontact.m_points[i];
+			newele.m_normal = tricontact.m_separating_normal;
+			newele.m_depth = tricontact.m_penetration_depth;
+			newele.m_feature1 = feature1;
+			newele.m_feature2 = feature2;
+		}
+	}
+
+	void merge_contacts(const gim_contact_array &contacts, bool normal_contact_average = true);
+	void merge_contacts_unique(const gim_contact_array &contacts);
+};
+
+#endif  // GIM_CONTACT_H_INCLUDED
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/gim_geom_types.h b/engine/inc/bullet/BulletCollision/Gimpact/gim_geom_types.h
new file mode 100644
index 00000000..9dc48f35
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/gim_geom_types.h
@@ -0,0 +1,92 @@
+#ifndef GIM_GEOM_TYPES_H_INCLUDED
+#define GIM_GEOM_TYPES_H_INCLUDED
+
+/*! \file gim_geom_types.h
+\author Francisco Leon Najera
+*/
+/*
+-----------------------------------------------------------------------------
+This source file is part of GIMPACT Library.
+
+For the latest info, see http://gimpact.sourceforge.net/
+
+Copyright (c) 2006 Francisco Leon Najera. C.C. 80087371.
+email: projectileman@yahoo.com
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of EITHER:
+   (1) The GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 2.1 of the License, or (at
+       your option) any later version. The text of the GNU Lesser
+       General Public License is included with this library in the
+       file GIMPACT-LICENSE-LGPL.TXT.
+   (2) The BSD-style license that is included with this library in
+       the file GIMPACT-LICENSE-BSD.TXT.
+   (3) The zlib/libpng license that is included with this library in
+       the file GIMPACT-LICENSE-ZLIB.TXT.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files
+ GIMPACT-LICENSE-LGPL.TXT, GIMPACT-LICENSE-ZLIB.TXT and GIMPACT-LICENSE-BSD.TXT for more details.
+
+-----------------------------------------------------------------------------
+*/
+
+#include "gim_math.h"
+
+//! Short Integer vector 2D
+typedef GSHORT vec2s[2];
+//! Integer vector 3D
+typedef GSHORT vec3s[3];
+//! Integer vector 4D
+typedef GSHORT vec4s[4];
+
+//! Short Integer vector 2D
+typedef GUSHORT vec2us[2];
+//! Integer vector 3D
+typedef GUSHORT vec3us[3];
+//! Integer vector 4D
+typedef GUSHORT vec4us[4];
+
+//! Integer vector 2D
+typedef GINT vec2i[2];
+//! Integer vector 3D
+typedef GINT vec3i[3];
+//! Integer vector 4D
+typedef GINT vec4i[4];
+
+//! Unsigned Integer vector 2D
+typedef GUINT vec2ui[2];
+//! Unsigned Integer vector 3D
+typedef GUINT vec3ui[3];
+//! Unsigned Integer vector 4D
+typedef GUINT vec4ui[4];
+
+//! Float vector 2D
+typedef GREAL vec2f[2];
+//! Float vector 3D
+typedef GREAL vec3f[3];
+//! Float vector 4D
+typedef GREAL vec4f[4];
+
+//! Double vector 2D
+typedef GREAL2 vec2d[2];
+//! Float vector 3D
+typedef GREAL2 vec3d[3];
+//! Float vector 4D
+typedef GREAL2 vec4d[4];
+
+//! Matrix 2D, row ordered
+typedef GREAL mat2f[2][2];
+//! Matrix 3D, row ordered
+typedef GREAL mat3f[3][3];
+//! Matrix 4D, row ordered
+typedef GREAL mat4f[4][4];
+
+//! Quaternion
+typedef GREAL quatf[4];
+
+//typedef struct _aabb3f aabb3f;
+
+#endif  // GIM_GEOM_TYPES_H_INCLUDED
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/gim_geometry.h b/engine/inc/bullet/BulletCollision/Gimpact/gim_geometry.h
new file mode 100644
index 00000000..4a7ac3c4
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/gim_geometry.h
@@ -0,0 +1,42 @@
+#ifndef GIM_GEOMETRY_H_INCLUDED
+#define GIM_GEOMETRY_H_INCLUDED
+
+/*! \file gim_geometry.h
+\author Francisco Leon Najera
+*/
+/*
+-----------------------------------------------------------------------------
+This source file is part of GIMPACT Library.
+
+For the latest info, see http://gimpact.sourceforge.net/
+
+Copyright (c) 2006 Francisco Leon Najera. C.C. 80087371.
+email: projectileman@yahoo.com
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of EITHER:
+   (1) The GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 2.1 of the License, or (at
+       your option) any later version. The text of the GNU Lesser
+       General Public License is included with this library in the
+       file GIMPACT-LICENSE-LGPL.TXT.
+   (2) The BSD-style license that is included with this library in
+       the file GIMPACT-LICENSE-BSD.TXT.
+   (3) The zlib/libpng license that is included with this library in
+       the file GIMPACT-LICENSE-ZLIB.TXT.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files
+ GIMPACT-LICENSE-LGPL.TXT, GIMPACT-LICENSE-ZLIB.TXT and GIMPACT-LICENSE-BSD.TXT for more details.
+
+-----------------------------------------------------------------------------
+*/
+
+///Additional Headers for Collision
+#include "gim_basic_geometry_operations.h"
+#include "gim_clip_polygon.h"
+#include "gim_box_collision.h"
+#include "gim_tri_collision.h"
+
+#endif  // GIM_VECTOR_H_INCLUDED
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/gim_hash_table.h b/engine/inc/bullet/BulletCollision/Gimpact/gim_hash_table.h
new file mode 100644
index 00000000..abf88d31
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/gim_hash_table.h
@@ -0,0 +1,857 @@
+#ifndef GIM_HASH_TABLE_H_INCLUDED
+#define GIM_HASH_TABLE_H_INCLUDED
+/*! \file gim_trimesh_data.h
+\author Francisco Leon Najera
+*/
+/*
+-----------------------------------------------------------------------------
+This source file is part of GIMPACT Library.
+
+For the latest info, see http://gimpact.sourceforge.net/
+
+Copyright (c) 2006 Francisco Leon Najera. C.C. 80087371.
+email: projectileman@yahoo.com
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of EITHER:
+   (1) The GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 2.1 of the License, or (at
+       your option) any later version. The text of the GNU Lesser
+       General Public License is included with this library in the
+       file GIMPACT-LICENSE-LGPL.TXT.
+   (2) The BSD-style license that is included with this library in
+       the file GIMPACT-LICENSE-BSD.TXT.
+   (3) The zlib/libpng license that is included with this library in
+       the file GIMPACT-LICENSE-ZLIB.TXT.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files
+ GIMPACT-LICENSE-LGPL.TXT, GIMPACT-LICENSE-ZLIB.TXT and GIMPACT-LICENSE-BSD.TXT for more details.
+
+-----------------------------------------------------------------------------
+*/
+
+#include "gim_radixsort.h"
+
+#define GIM_INVALID_HASH 0xffffffff  //!< A very very high value
+#define GIM_DEFAULT_HASH_TABLE_SIZE 380
+#define GIM_DEFAULT_HASH_TABLE_NODE_SIZE 4
+#define GIM_HASH_TABLE_GROW_FACTOR 2
+
+#define GIM_MIN_RADIX_SORT_SIZE 860  //!< calibrated on a PIII
+
+template <typename T>
+struct GIM_HASH_TABLE_NODE
+{
+	GUINT m_key;
+	T m_data;
+	GIM_HASH_TABLE_NODE()
+	{
+	}
+
+	GIM_HASH_TABLE_NODE(const GIM_HASH_TABLE_NODE& value)
+	{
+		m_key = value.m_key;
+		m_data = value.m_data;
+	}
+
+	GIM_HASH_TABLE_NODE(GUINT key, const T& data)
+	{
+		m_key = key;
+		m_data = data;
+	}
+
+	bool operator<(const GIM_HASH_TABLE_NODE<T>& other) const
+	{
+		///inverse order, further objects are first
+		if (m_key < other.m_key) return true;
+		return false;
+	}
+
+	bool operator>(const GIM_HASH_TABLE_NODE<T>& other) const
+	{
+		///inverse order, further objects are first
+		if (m_key > other.m_key) return true;
+		return false;
+	}
+
+	bool operator==(const GIM_HASH_TABLE_NODE<T>& other) const
+	{
+		///inverse order, further objects are first
+		if (m_key == other.m_key) return true;
+		return false;
+	}
+};
+
+///Macro for getting the key
+class GIM_HASH_NODE_GET_KEY
+{
+public:
+	template <class T>
+	inline GUINT operator()(const T& a)
+	{
+		return a.m_key;
+	}
+};
+
+///Macro for comparing the key and the element
+class GIM_HASH_NODE_CMP_KEY_MACRO
+{
+public:
+	template <class T>
+	inline int operator()(const T& a, GUINT key)
+	{
+		return ((int)(a.m_key - key));
+	}
+};
+
+///Macro for comparing Hash nodes
+class GIM_HASH_NODE_CMP_MACRO
+{
+public:
+	template <class T>
+	inline int operator()(const T& a, const T& b)
+	{
+		return ((int)(a.m_key - b.m_key));
+	}
+};
+
+//! Sorting for hash table
+/*!
+switch automatically between quicksort and radixsort
+*/
+template <typename T>
+void gim_sort_hash_node_array(T* array, GUINT array_count)
+{
+	if (array_count < GIM_MIN_RADIX_SORT_SIZE)
+	{
+		gim_heap_sort(array, array_count, GIM_HASH_NODE_CMP_MACRO());
+	}
+	else
+	{
+		memcopy_elements_func cmpfunc;
+		gim_radix_sort(array, array_count, GIM_HASH_NODE_GET_KEY(), cmpfunc);
+	}
+}
+
+// Note: assumes long is at least 32 bits.
+#define GIM_NUM_PRIME 28
+
+static const GUINT gim_prime_list[GIM_NUM_PRIME] =
+	{
+		53ul, 97ul, 193ul, 389ul, 769ul,
+		1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
+		49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
+		1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul,
+		50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,
+		1610612741ul, 3221225473ul, 4294967291ul};
+
+inline GUINT gim_next_prime(GUINT number)
+{
+	//Find nearest upper prime
+	GUINT result_ind = 0;
+	gim_binary_search(gim_prime_list, 0, (GIM_NUM_PRIME - 2), number, result_ind);
+
+	// inv: result_ind < 28
+	return gim_prime_list[result_ind];
+}
+
+//! A compact hash table implementation
+/*!
+A memory aligned compact hash table that coud be treated as an array.
+It could be a simple sorted array without the overhead of the hash key bucked, or could
+be a formely hash table with an array of keys.
+You can use switch_to_hashtable() and switch_to_sorted_array for saving space or increase speed.
+</br>
+
+<ul>
+<li> if node_size = 0, then this container becomes a simple sorted array allocator. reserve_size is used for reserve memory in m_nodes.
+When the array size reaches the size equivalent to 'min_hash_table_size', then it becomes a hash table by calling check_for_switching_to_hashtable.
+<li> If node_size != 0, then this container becomes a hash table for ever
+</ul>
+
+*/
+template <class T>
+class gim_hash_table
+{
+protected:
+	typedef GIM_HASH_TABLE_NODE<T> _node_type;
+
+	//!The nodes
+	//array< _node_type, SuperAllocator<_node_type> > m_nodes;
+	gim_array<_node_type> m_nodes;
+	//SuperBufferedArray< _node_type > m_nodes;
+	bool m_sorted;
+
+	///Hash table data management. The hash table has the indices to the corresponding m_nodes array
+	GUINT* m_hash_table;  //!<
+	GUINT m_table_size;   //!<
+	GUINT m_node_size;    //!<
+	GUINT m_min_hash_table_size;
+
+	//! Returns the cell index
+	inline GUINT _find_cell(GUINT hashkey)
+	{
+		_node_type* nodesptr = m_nodes.pointer();
+		GUINT start_index = (hashkey % m_table_size) * m_node_size;
+		GUINT end_index = start_index + m_node_size;
+
+		while (start_index < end_index)
+		{
+			GUINT value = m_hash_table[start_index];
+			if (value != GIM_INVALID_HASH)
+			{
+				if (nodesptr[value].m_key == hashkey) return start_index;
+			}
+			start_index++;
+		}
+		return GIM_INVALID_HASH;
+	}
+
+	//! Find the avaliable cell for the hashkey, and return an existing cell if it has the same hash key
+	inline GUINT _find_avaliable_cell(GUINT hashkey)
+	{
+		_node_type* nodesptr = m_nodes.pointer();
+		GUINT avaliable_index = GIM_INVALID_HASH;
+		GUINT start_index = (hashkey % m_table_size) * m_node_size;
+		GUINT end_index = start_index + m_node_size;
+
+		while (start_index < end_index)
+		{
+			GUINT value = m_hash_table[start_index];
+			if (value == GIM_INVALID_HASH)
+			{
+				if (avaliable_index == GIM_INVALID_HASH)
+				{
+					avaliable_index = start_index;
+				}
+			}
+			else if (nodesptr[value].m_key == hashkey)
+			{
+				return start_index;
+			}
+			start_index++;
+		}
+		return avaliable_index;
+	}
+
+	//! reserves the memory for the hash table.
+	/*!
+    \pre hash table must be empty
+    \post reserves the memory for the hash table, an initializes all elements to GIM_INVALID_HASH.
+    */
+	inline void _reserve_table_memory(GUINT newtablesize)
+	{
+		if (newtablesize == 0) return;
+		if (m_node_size == 0) return;
+
+		//Get a Prime size
+
+		m_table_size = gim_next_prime(newtablesize);
+
+		GUINT datasize = m_table_size * m_node_size;
+		//Alloc the data buffer
+		m_hash_table = (GUINT*)gim_alloc(datasize * sizeof(GUINT));
+	}
+
+	inline void _invalidate_keys()
+	{
+		GUINT datasize = m_table_size * m_node_size;
+		for (GUINT i = 0; i < datasize; i++)
+		{
+			m_hash_table[i] = GIM_INVALID_HASH;  // invalidate keys
+		}
+	}
+
+	//! Clear all memory for the hash table
+	inline void _clear_table_memory()
+	{
+		if (m_hash_table == NULL) return;
+		gim_free(m_hash_table);
+		m_hash_table = NULL;
+		m_table_size = 0;
+	}
+
+	//! Invalidates the keys (Assigning GIM_INVALID_HASH to all) Reorders the hash keys
+	inline void _rehash()
+	{
+		_invalidate_keys();
+
+		_node_type* nodesptr = m_nodes.pointer();
+		for (GUINT i = 0; i < (GUINT)m_nodes.size(); i++)
+		{
+			GUINT nodekey = nodesptr[i].m_key;
+			if (nodekey != GIM_INVALID_HASH)
+			{
+				//Search for the avaliable cell in buffer
+				GUINT index = _find_avaliable_cell(nodekey);
+
+				if (m_hash_table[index] != GIM_INVALID_HASH)
+				{  //The new index is alreade used... discard this new incomming object, repeated key
+					btAssert(m_hash_table[index] == nodekey);
+					nodesptr[i].m_key = GIM_INVALID_HASH;
+				}
+				else
+				{
+					//;
+					//Assign the value for alloc
+					m_hash_table[index] = i;
+				}
+			}
+		}
+	}
+
+	//! Resize hash table indices
+	inline void _resize_table(GUINT newsize)
+	{
+		//Clear memory
+		_clear_table_memory();
+		//Alloc the data
+		_reserve_table_memory(newsize);
+		//Invalidate keys and rehash
+		_rehash();
+	}
+
+	//! Destroy hash table memory
+	inline void _destroy()
+	{
+		if (m_hash_table == NULL) return;
+		_clear_table_memory();
+	}
+
+	//! Finds an avaliable hash table cell, and resizes the table if there isn't space
+	inline GUINT _assign_hash_table_cell(GUINT hashkey)
+	{
+		GUINT cell_index = _find_avaliable_cell(hashkey);
+
+		if (cell_index == GIM_INVALID_HASH)
+		{
+			//rehashing
+			_resize_table(m_table_size + 1);
+			GUINT cell_index = _find_avaliable_cell(hashkey);
+			btAssert(cell_index != GIM_INVALID_HASH);
+		}
+		return cell_index;
+	}
+
+	//! erase by index in hash table
+	inline bool _erase_by_index_hash_table(GUINT index)
+	{
+		if (index >= m_nodes.size()) return false;
+		if (m_nodes[index].m_key != GIM_INVALID_HASH)
+		{
+			//Search for the avaliable cell in buffer
+			GUINT cell_index = _find_cell(m_nodes[index].m_key);
+
+			btAssert(cell_index != GIM_INVALID_HASH);
+			btAssert(m_hash_table[cell_index] == index);
+
+			m_hash_table[cell_index] = GIM_INVALID_HASH;
+		}
+
+		return this->_erase_unsorted(index);
+	}
+
+	//! erase by key in hash table
+	inline bool _erase_hash_table(GUINT hashkey)
+	{
+		if (hashkey == GIM_INVALID_HASH) return false;
+
+		//Search for the avaliable cell in buffer
+		GUINT cell_index = _find_cell(hashkey);
+		if (cell_index == GIM_INVALID_HASH) return false;
+
+		GUINT index = m_hash_table[cell_index];
+		m_hash_table[cell_index] = GIM_INVALID_HASH;
+
+		return this->_erase_unsorted(index);
+	}
+
+	//! insert an element in hash table
+	/*!
+    If the element exists, this won't insert the element
+    \return the index in the array of the existing element,or GIM_INVALID_HASH if the element has been inserted
+    If so, the element has been inserted at the last position of the array.
+    */
+	inline GUINT _insert_hash_table(GUINT hashkey, const T& value)
+	{
+		if (hashkey == GIM_INVALID_HASH)
+		{
+			//Insert anyway
+			_insert_unsorted(hashkey, value);
+			return GIM_INVALID_HASH;
+		}
+
+		GUINT cell_index = _assign_hash_table_cell(hashkey);
+
+		GUINT value_key = m_hash_table[cell_index];
+
+		if (value_key != GIM_INVALID_HASH) return value_key;  // Not overrited
+
+		m_hash_table[cell_index] = m_nodes.size();
+
+		_insert_unsorted(hashkey, value);
+		return GIM_INVALID_HASH;
+	}
+
+	//! insert an element in hash table.
+	/*!
+    If the element exists, this replaces the element.
+    \return the index in the array of the existing element,or GIM_INVALID_HASH if the element has been inserted
+    If so, the element has been inserted at the last position of the array.
+    */
+	inline GUINT _insert_hash_table_replace(GUINT hashkey, const T& value)
+	{
+		if (hashkey == GIM_INVALID_HASH)
+		{
+			//Insert anyway
+			_insert_unsorted(hashkey, value);
+			return GIM_INVALID_HASH;
+		}
+
+		GUINT cell_index = _assign_hash_table_cell(hashkey);
+
+		GUINT value_key = m_hash_table[cell_index];
+
+		if (value_key != GIM_INVALID_HASH)
+		{  //replaces the existing
+			m_nodes[value_key] = _node_type(hashkey, value);
+			return value_key;  // index of the replaced element
+		}
+
+		m_hash_table[cell_index] = m_nodes.size();
+
+		_insert_unsorted(hashkey, value);
+		return GIM_INVALID_HASH;
+	}
+
+	///Sorted array data management. The hash table has the indices to the corresponding m_nodes array
+	inline bool _erase_sorted(GUINT index)
+	{
+		if (index >= (GUINT)m_nodes.size()) return false;
+		m_nodes.erase_sorted(index);
+		if (m_nodes.size() < 2) m_sorted = false;
+		return true;
+	}
+
+	//! faster, but unsorted
+	inline bool _erase_unsorted(GUINT index)
+	{
+		if (index >= m_nodes.size()) return false;
+
+		GUINT lastindex = m_nodes.size() - 1;
+		if (index < lastindex && m_hash_table != 0)
+		{
+			GUINT hashkey = m_nodes[lastindex].m_key;
+			if (hashkey != GIM_INVALID_HASH)
+			{
+				//update the new position of the last element
+				GUINT cell_index = _find_cell(hashkey);
+				btAssert(cell_index != GIM_INVALID_HASH);
+				//new position of the last element which will be swaped
+				m_hash_table[cell_index] = index;
+			}
+		}
+		m_nodes.erase(index);
+		m_sorted = false;
+		return true;
+	}
+
+	//! Insert in position ordered
+	/*!
+    Also checks if it is needed to transform this container to a hash table, by calling check_for_switching_to_hashtable
+    */
+	inline void _insert_in_pos(GUINT hashkey, const T& value, GUINT pos)
+	{
+		m_nodes.insert(_node_type(hashkey, value), pos);
+		this->check_for_switching_to_hashtable();
+	}
+
+	//! Insert an element in an ordered array
+	inline GUINT _insert_sorted(GUINT hashkey, const T& value)
+	{
+		if (hashkey == GIM_INVALID_HASH || size() == 0)
+		{
+			m_nodes.push_back(_node_type(hashkey, value));
+			return GIM_INVALID_HASH;
+		}
+		//Insert at last position
+		//Sort element
+
+		GUINT result_ind = 0;
+		GUINT last_index = m_nodes.size() - 1;
+		_node_type* ptr = m_nodes.pointer();
+
+		bool found = gim_binary_search_ex(
+			ptr, 0, last_index, result_ind, hashkey, GIM_HASH_NODE_CMP_KEY_MACRO());
+
+		//Insert before found index
+		if (found)
+		{
+			return result_ind;
+		}
+		else
+		{
+			_insert_in_pos(hashkey, value, result_ind);
+		}
+		return GIM_INVALID_HASH;
+	}
+
+	inline GUINT _insert_sorted_replace(GUINT hashkey, const T& value)
+	{
+		if (hashkey == GIM_INVALID_HASH || size() == 0)
+		{
+			m_nodes.push_back(_node_type(hashkey, value));
+			return GIM_INVALID_HASH;
+		}
+		//Insert at last position
+		//Sort element
+		GUINT result_ind;
+		GUINT last_index = m_nodes.size() - 1;
+		_node_type* ptr = m_nodes.pointer();
+
+		bool found = gim_binary_search_ex(
+			ptr, 0, last_index, result_ind, hashkey, GIM_HASH_NODE_CMP_KEY_MACRO());
+
+		//Insert before found index
+		if (found)
+		{
+			m_nodes[result_ind] = _node_type(hashkey, value);
+		}
+		else
+		{
+			_insert_in_pos(hashkey, value, result_ind);
+		}
+		return result_ind;
+	}
+
+	//! Fast insertion in m_nodes array
+	inline GUINT _insert_unsorted(GUINT hashkey, const T& value)
+	{
+		m_nodes.push_back(_node_type(hashkey, value));
+		m_sorted = false;
+		return GIM_INVALID_HASH;
+	}
+
+public:
+	/*!
+        <li> if node_size = 0, then this container becomes a simple sorted array allocator. reserve_size is used for reserve memory in m_nodes.
+        When the array size reaches the size equivalent to 'min_hash_table_size', then it becomes a hash table by calling check_for_switching_to_hashtable.
+        <li> If node_size != 0, then this container becomes a hash table for ever
+        </ul>
+    */
+	gim_hash_table(GUINT reserve_size = GIM_DEFAULT_HASH_TABLE_SIZE,
+				   GUINT node_size = GIM_DEFAULT_HASH_TABLE_NODE_SIZE,
+				   GUINT min_hash_table_size = GIM_INVALID_HASH)
+	{
+		m_hash_table = NULL;
+		m_table_size = 0;
+		m_sorted = false;
+		m_node_size = node_size;
+		m_min_hash_table_size = min_hash_table_size;
+
+		if (m_node_size != 0)
+		{
+			if (reserve_size != 0)
+			{
+				m_nodes.reserve(reserve_size);
+				_reserve_table_memory(reserve_size);
+				_invalidate_keys();
+			}
+			else
+			{
+				m_nodes.reserve(GIM_DEFAULT_HASH_TABLE_SIZE);
+				_reserve_table_memory(GIM_DEFAULT_HASH_TABLE_SIZE);
+				_invalidate_keys();
+			}
+		}
+		else if (reserve_size != 0)
+		{
+			m_nodes.reserve(reserve_size);
+		}
+	}
+
+	~gim_hash_table()
+	{
+		_destroy();
+	}
+
+	inline bool is_hash_table()
+	{
+		if (m_hash_table) return true;
+		return false;
+	}
+
+	inline bool is_sorted()
+	{
+		if (size() < 2) return true;
+		return m_sorted;
+	}
+
+	bool sort()
+	{
+		if (is_sorted()) return true;
+		if (m_nodes.size() < 2) return false;
+
+		_node_type* ptr = m_nodes.pointer();
+		GUINT siz = m_nodes.size();
+		gim_sort_hash_node_array(ptr, siz);
+		m_sorted = true;
+
+		if (m_hash_table)
+		{
+			_rehash();
+		}
+		return true;
+	}
+
+	bool switch_to_hashtable()
+	{
+		if (m_hash_table) return false;
+		if (m_node_size == 0) m_node_size = GIM_DEFAULT_HASH_TABLE_NODE_SIZE;
+		if (m_nodes.size() < GIM_DEFAULT_HASH_TABLE_SIZE)
+		{
+			_resize_table(GIM_DEFAULT_HASH_TABLE_SIZE);
+		}
+		else
+		{
+			_resize_table(m_nodes.size() + 1);
+		}
+
+		return true;
+	}
+
+	bool switch_to_sorted_array()
+	{
+		if (m_hash_table == NULL) return true;
+		_clear_table_memory();
+		return sort();
+	}
+
+	//!If the container reaches the
+	bool check_for_switching_to_hashtable()
+	{
+		if (this->m_hash_table) return true;
+
+		if (!(m_nodes.size() < m_min_hash_table_size))
+		{
+			if (m_node_size == 0)
+			{
+				m_node_size = GIM_DEFAULT_HASH_TABLE_NODE_SIZE;
+			}
+
+			_resize_table(m_nodes.size() + 1);
+			return true;
+		}
+		return false;
+	}
+
+	inline void set_sorted(bool value)
+	{
+		m_sorted = value;
+	}
+
+	//! Retrieves the amount of keys.
+	inline GUINT size() const
+	{
+		return m_nodes.size();
+	}
+
+	//! Retrieves the hash key.
+	inline GUINT get_key(GUINT index) const
+	{
+		return m_nodes[index].m_key;
+	}
+
+	//! Retrieves the value by index
+	/*!
+    */
+	inline T* get_value_by_index(GUINT index)
+	{
+		return &m_nodes[index].m_data;
+	}
+
+	inline const T& operator[](GUINT index) const
+	{
+		return m_nodes[index].m_data;
+	}
+
+	inline T& operator[](GUINT index)
+	{
+		return m_nodes[index].m_data;
+	}
+
+	//! Finds the index of the element with the key
+	/*!
+    \return the index in the array of the existing element,or GIM_INVALID_HASH if the element has been inserted
+    If so, the element has been inserted at the last position of the array.
+    */
+	inline GUINT find(GUINT hashkey)
+	{
+		if (m_hash_table)
+		{
+			GUINT cell_index = _find_cell(hashkey);
+			if (cell_index == GIM_INVALID_HASH) return GIM_INVALID_HASH;
+			return m_hash_table[cell_index];
+		}
+		GUINT last_index = m_nodes.size();
+		if (last_index < 2)
+		{
+			if (last_index == 0) return GIM_INVALID_HASH;
+			if (m_nodes[0].m_key == hashkey) return 0;
+			return GIM_INVALID_HASH;
+		}
+		else if (m_sorted)
+		{
+			//Binary search
+			GUINT result_ind = 0;
+			last_index--;
+			_node_type* ptr = m_nodes.pointer();
+
+			bool found = gim_binary_search_ex(ptr, 0, last_index, result_ind, hashkey, GIM_HASH_NODE_CMP_KEY_MACRO());
+
+			if (found) return result_ind;
+		}
+		return GIM_INVALID_HASH;
+	}
+
+	//! Retrieves the value associated with the index
+	/*!
+    \return the found element, or null
+    */
+	inline T* get_value(GUINT hashkey)
+	{
+		GUINT index = find(hashkey);
+		if (index == GIM_INVALID_HASH) return NULL;
+		return &m_nodes[index].m_data;
+	}
+
+	/*!
+    */
+	inline bool erase_by_index(GUINT index)
+	{
+		if (index > m_nodes.size()) return false;
+
+		if (m_hash_table == NULL)
+		{
+			if (is_sorted())
+			{
+				return this->_erase_sorted(index);
+			}
+			else
+			{
+				return this->_erase_unsorted(index);
+			}
+		}
+		else
+		{
+			return this->_erase_by_index_hash_table(index);
+		}
+		return false;
+	}
+
+	inline bool erase_by_index_unsorted(GUINT index)
+	{
+		if (index > m_nodes.size()) return false;
+
+		if (m_hash_table == NULL)
+		{
+			return this->_erase_unsorted(index);
+		}
+		else
+		{
+			return this->_erase_by_index_hash_table(index);
+		}
+		return false;
+	}
+
+	/*!
+
+    */
+	inline bool erase_by_key(GUINT hashkey)
+	{
+		if (size() == 0) return false;
+
+		if (m_hash_table)
+		{
+			return this->_erase_hash_table(hashkey);
+		}
+		//Binary search
+
+		if (is_sorted() == false) return false;
+
+		GUINT result_ind = find(hashkey);
+		if (result_ind != GIM_INVALID_HASH)
+		{
+			return this->_erase_sorted(result_ind);
+		}
+		return false;
+	}
+
+	void clear()
+	{
+		m_nodes.clear();
+
+		if (m_hash_table == NULL) return;
+		GUINT datasize = m_table_size * m_node_size;
+		//Initialize the hashkeys.
+		GUINT i;
+		for (i = 0; i < datasize; i++)
+		{
+			m_hash_table[i] = GIM_INVALID_HASH;  // invalidate keys
+		}
+		m_sorted = false;
+	}
+
+	//! Insert an element into the hash
+	/*!
+    \return If GIM_INVALID_HASH, the object has been inserted succesfully. Else it returns the position
+    of the existing element.
+    */
+	inline GUINT insert(GUINT hashkey, const T& element)
+	{
+		if (m_hash_table)
+		{
+			return this->_insert_hash_table(hashkey, element);
+		}
+		if (this->is_sorted())
+		{
+			return this->_insert_sorted(hashkey, element);
+		}
+		return this->_insert_unsorted(hashkey, element);
+	}
+
+	//! Insert an element into the hash, and could overrite an existing object with the same hash.
+	/*!
+    \return If GIM_INVALID_HASH, the object has been inserted succesfully. Else it returns the position
+    of the replaced element.
+    */
+	inline GUINT insert_override(GUINT hashkey, const T& element)
+	{
+		if (m_hash_table)
+		{
+			return this->_insert_hash_table_replace(hashkey, element);
+		}
+		if (this->is_sorted())
+		{
+			return this->_insert_sorted_replace(hashkey, element);
+		}
+		this->_insert_unsorted(hashkey, element);
+		return m_nodes.size();
+	}
+
+	//! Insert an element into the hash,But if this container is a sorted array, this inserts it unsorted
+	/*!
+    */
+	inline GUINT insert_unsorted(GUINT hashkey, const T& element)
+	{
+		if (m_hash_table)
+		{
+			return this->_insert_hash_table(hashkey, element);
+		}
+		return this->_insert_unsorted(hashkey, element);
+	}
+};
+
+#endif  // GIM_CONTAINERS_H_INCLUDED
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/gim_linear_math.h b/engine/inc/bullet/BulletCollision/Gimpact/gim_linear_math.h
new file mode 100644
index 00000000..98401a40
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/gim_linear_math.h
@@ -0,0 +1,1488 @@
+#ifndef GIM_LINEAR_H_INCLUDED
+#define GIM_LINEAR_H_INCLUDED
+
+/*! \file gim_linear_math.h
+*\author Francisco Leon Najera
+Type Independant Vector and matrix operations.
+*/
+/*
+-----------------------------------------------------------------------------
+This source file is part of GIMPACT Library.
+
+For the latest info, see http://gimpact.sourceforge.net/
+
+Copyright (c) 2006 Francisco Leon Najera. C.C. 80087371.
+email: projectileman@yahoo.com
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of EITHER:
+   (1) The GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 2.1 of the License, or (at
+       your option) any later version. The text of the GNU Lesser
+       General Public License is included with this library in the
+       file GIMPACT-LICENSE-LGPL.TXT.
+   (2) The BSD-style license that is included with this library in
+       the file GIMPACT-LICENSE-BSD.TXT.
+   (3) The zlib/libpng license that is included with this library in
+       the file GIMPACT-LICENSE-ZLIB.TXT.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files
+ GIMPACT-LICENSE-LGPL.TXT, GIMPACT-LICENSE-ZLIB.TXT and GIMPACT-LICENSE-BSD.TXT for more details.
+
+-----------------------------------------------------------------------------
+*/
+
+#include "gim_math.h"
+#include "gim_geom_types.h"
+
+//! Zero out a 2D vector
+#define VEC_ZERO_2(a)           \
+	{                           \
+		(a)[0] = (a)[1] = 0.0f; \
+	}
+
+//! Zero out a 3D vector
+#define VEC_ZERO(a)                      \
+	{                                    \
+		(a)[0] = (a)[1] = (a)[2] = 0.0f; \
+	}
+
+/// Zero out a 4D vector
+#define VEC_ZERO_4(a)                             \
+	{                                             \
+		(a)[0] = (a)[1] = (a)[2] = (a)[3] = 0.0f; \
+	}
+
+/// Vector copy
+#define VEC_COPY_2(b, a) \
+	{                    \
+		(b)[0] = (a)[0]; \
+		(b)[1] = (a)[1]; \
+	}
+
+/// Copy 3D vector
+#define VEC_COPY(b, a)   \
+	{                    \
+		(b)[0] = (a)[0]; \
+		(b)[1] = (a)[1]; \
+		(b)[2] = (a)[2]; \
+	}
+
+/// Copy 4D vector
+#define VEC_COPY_4(b, a) \
+	{                    \
+		(b)[0] = (a)[0]; \
+		(b)[1] = (a)[1]; \
+		(b)[2] = (a)[2]; \
+		(b)[3] = (a)[3]; \
+	}
+
+/// VECTOR SWAP
+#define VEC_SWAP(b, a)                    \
+	{                                     \
+		GIM_SWAP_NUMBERS((b)[0], (a)[0]); \
+		GIM_SWAP_NUMBERS((b)[1], (a)[1]); \
+		GIM_SWAP_NUMBERS((b)[2], (a)[2]); \
+	}
+
+/// Vector difference
+#define VEC_DIFF_2(v21, v2, v1)       \
+	{                                 \
+		(v21)[0] = (v2)[0] - (v1)[0]; \
+		(v21)[1] = (v2)[1] - (v1)[1]; \
+	}
+
+/// Vector difference
+#define VEC_DIFF(v21, v2, v1)         \
+	{                                 \
+		(v21)[0] = (v2)[0] - (v1)[0]; \
+		(v21)[1] = (v2)[1] - (v1)[1]; \
+		(v21)[2] = (v2)[2] - (v1)[2]; \
+	}
+
+/// Vector difference
+#define VEC_DIFF_4(v21, v2, v1)       \
+	{                                 \
+		(v21)[0] = (v2)[0] - (v1)[0]; \
+		(v21)[1] = (v2)[1] - (v1)[1]; \
+		(v21)[2] = (v2)[2] - (v1)[2]; \
+		(v21)[3] = (v2)[3] - (v1)[3]; \
+	}
+
+/// Vector sum
+#define VEC_SUM_2(v21, v2, v1)        \
+	{                                 \
+		(v21)[0] = (v2)[0] + (v1)[0]; \
+		(v21)[1] = (v2)[1] + (v1)[1]; \
+	}
+
+/// Vector sum
+#define VEC_SUM(v21, v2, v1)          \
+	{                                 \
+		(v21)[0] = (v2)[0] + (v1)[0]; \
+		(v21)[1] = (v2)[1] + (v1)[1]; \
+		(v21)[2] = (v2)[2] + (v1)[2]; \
+	}
+
+/// Vector sum
+#define VEC_SUM_4(v21, v2, v1)        \
+	{                                 \
+		(v21)[0] = (v2)[0] + (v1)[0]; \
+		(v21)[1] = (v2)[1] + (v1)[1]; \
+		(v21)[2] = (v2)[2] + (v1)[2]; \
+		(v21)[3] = (v2)[3] + (v1)[3]; \
+	}
+
+/// scalar times vector
+#define VEC_SCALE_2(c, a, b)   \
+	{                          \
+		(c)[0] = (a) * (b)[0]; \
+		(c)[1] = (a) * (b)[1]; \
+	}
+
+/// scalar times vector
+#define VEC_SCALE(c, a, b)     \
+	{                          \
+		(c)[0] = (a) * (b)[0]; \
+		(c)[1] = (a) * (b)[1]; \
+		(c)[2] = (a) * (b)[2]; \
+	}
+
+/// scalar times vector
+#define VEC_SCALE_4(c, a, b)   \
+	{                          \
+		(c)[0] = (a) * (b)[0]; \
+		(c)[1] = (a) * (b)[1]; \
+		(c)[2] = (a) * (b)[2]; \
+		(c)[3] = (a) * (b)[3]; \
+	}
+
+/// accumulate scaled vector
+#define VEC_ACCUM_2(c, a, b)    \
+	{                           \
+		(c)[0] += (a) * (b)[0]; \
+		(c)[1] += (a) * (b)[1]; \
+	}
+
+/// accumulate scaled vector
+#define VEC_ACCUM(c, a, b)      \
+	{                           \
+		(c)[0] += (a) * (b)[0]; \
+		(c)[1] += (a) * (b)[1]; \
+		(c)[2] += (a) * (b)[2]; \
+	}
+
+/// accumulate scaled vector
+#define VEC_ACCUM_4(c, a, b)    \
+	{                           \
+		(c)[0] += (a) * (b)[0]; \
+		(c)[1] += (a) * (b)[1]; \
+		(c)[2] += (a) * (b)[2]; \
+		(c)[3] += (a) * (b)[3]; \
+	}
+
+/// Vector dot product
+#define VEC_DOT_2(a, b) ((a)[0] * (b)[0] + (a)[1] * (b)[1])
+
+/// Vector dot product
+#define VEC_DOT(a, b) ((a)[0] * (b)[0] + (a)[1] * (b)[1] + (a)[2] * (b)[2])
+
+/// Vector dot product
+#define VEC_DOT_4(a, b) ((a)[0] * (b)[0] + (a)[1] * (b)[1] + (a)[2] * (b)[2] + (a)[3] * (b)[3])
+
+/// vector impact parameter (squared)
+#define VEC_IMPACT_SQ(bsq, direction, position)              \
+	{                                                        \
+		GREAL _llel_ = VEC_DOT(direction, position);         \
+		bsq = VEC_DOT(position, position) - _llel_ * _llel_; \
+	}
+
+/// vector impact parameter
+#define VEC_IMPACT(bsq, direction, position)     \
+	{                                            \
+		VEC_IMPACT_SQ(bsq, direction, position); \
+		GIM_SQRT(bsq, bsq);                      \
+	}
+
+/// Vector length
+#define VEC_LENGTH_2(a, l)           \
+	{                                \
+		GREAL _pp = VEC_DOT_2(a, a); \
+		GIM_SQRT(_pp, l);            \
+	}
+
+/// Vector length
+#define VEC_LENGTH(a, l)           \
+	{                              \
+		GREAL _pp = VEC_DOT(a, a); \
+		GIM_SQRT(_pp, l);          \
+	}
+
+/// Vector length
+#define VEC_LENGTH_4(a, l)           \
+	{                                \
+		GREAL _pp = VEC_DOT_4(a, a); \
+		GIM_SQRT(_pp, l);            \
+	}
+
+/// Vector inv length
+#define VEC_INV_LENGTH_2(a, l)       \
+	{                                \
+		GREAL _pp = VEC_DOT_2(a, a); \
+		GIM_INV_SQRT(_pp, l);        \
+	}
+
+/// Vector inv length
+#define VEC_INV_LENGTH(a, l)       \
+	{                              \
+		GREAL _pp = VEC_DOT(a, a); \
+		GIM_INV_SQRT(_pp, l);      \
+	}
+
+/// Vector inv length
+#define VEC_INV_LENGTH_4(a, l)       \
+	{                                \
+		GREAL _pp = VEC_DOT_4(a, a); \
+		GIM_INV_SQRT(_pp, l);        \
+	}
+
+/// distance between two points
+#define VEC_DISTANCE(_len, _va, _vb) \
+	{                                \
+		vec3f _tmp_;                 \
+		VEC_DIFF(_tmp_, _vb, _va);   \
+		VEC_LENGTH(_tmp_, _len);     \
+	}
+
+/// Vector length
+#define VEC_CONJUGATE_LENGTH(a, l)                                 \
+	{                                                              \
+		GREAL _pp = 1.0 - a[0] * a[0] - a[1] * a[1] - a[2] * a[2]; \
+		GIM_SQRT(_pp, l);                                          \
+	}
+
+/// Vector length
+#define VEC_NORMALIZE(a)           \
+	{                              \
+		GREAL len;                 \
+		VEC_INV_LENGTH(a, len);    \
+		if (len < G_REAL_INFINITY) \
+		{                          \
+			a[0] *= len;           \
+			a[1] *= len;           \
+			a[2] *= len;           \
+		}                          \
+	}
+
+/// Set Vector size
+#define VEC_RENORMALIZE(a, newlen) \
+	{                              \
+		GREAL len;                 \
+		VEC_INV_LENGTH(a, len);    \
+		if (len < G_REAL_INFINITY) \
+		{                          \
+			len *= newlen;         \
+			a[0] *= len;           \
+			a[1] *= len;           \
+			a[2] *= len;           \
+		}                          \
+	}
+
+/// Vector cross
+#define VEC_CROSS(c, a, b)                        \
+	{                                             \
+		c[0] = (a)[1] * (b)[2] - (a)[2] * (b)[1]; \
+		c[1] = (a)[2] * (b)[0] - (a)[0] * (b)[2]; \
+		c[2] = (a)[0] * (b)[1] - (a)[1] * (b)[0]; \
+	}
+
+/*! Vector perp -- assumes that n is of unit length
+ * accepts vector v, subtracts out any component parallel to n */
+#define VEC_PERPENDICULAR(vp, v, n)    \
+	{                                  \
+		GREAL dot = VEC_DOT(v, n);     \
+		vp[0] = (v)[0] - dot * (n)[0]; \
+		vp[1] = (v)[1] - dot * (n)[1]; \
+		vp[2] = (v)[2] - dot * (n)[2]; \
+	}
+
+/*! Vector parallel -- assumes that n is of unit length */
+#define VEC_PARALLEL(vp, v, n)     \
+	{                              \
+		GREAL dot = VEC_DOT(v, n); \
+		vp[0] = (dot) * (n)[0];    \
+		vp[1] = (dot) * (n)[1];    \
+		vp[2] = (dot) * (n)[2];    \
+	}
+
+/*! Same as Vector parallel --  n can have any length
+ * accepts vector v, subtracts out any component perpendicular to n */
+#define VEC_PROJECT(vp, v, n)         \
+	{                                 \
+		GREAL scalar = VEC_DOT(v, n); \
+		scalar /= VEC_DOT(n, n);      \
+		vp[0] = (scalar) * (n)[0];    \
+		vp[1] = (scalar) * (n)[1];    \
+		vp[2] = (scalar) * (n)[2];    \
+	}
+
+/*! accepts vector v*/
+#define VEC_UNPROJECT(vp, v, n)          \
+	{                                    \
+		GREAL scalar = VEC_DOT(v, n);    \
+		scalar = VEC_DOT(n, n) / scalar; \
+		vp[0] = (scalar) * (n)[0];       \
+		vp[1] = (scalar) * (n)[1];       \
+		vp[2] = (scalar) * (n)[2];       \
+	}
+
+/*! Vector reflection -- assumes n is of unit length
+ Takes vector v, reflects it against reflector n, and returns vr */
+#define VEC_REFLECT(vr, v, n)                  \
+	{                                          \
+		GREAL dot = VEC_DOT(v, n);             \
+		vr[0] = (v)[0] - 2.0 * (dot) * (n)[0]; \
+		vr[1] = (v)[1] - 2.0 * (dot) * (n)[1]; \
+		vr[2] = (v)[2] - 2.0 * (dot) * (n)[2]; \
+	}
+
+/*! Vector blending
+Takes two vectors a, b, blends them together with two scalars */
+#define VEC_BLEND_AB(vr, sa, a, sb, b)         \
+	{                                          \
+		vr[0] = (sa) * (a)[0] + (sb) * (b)[0]; \
+		vr[1] = (sa) * (a)[1] + (sb) * (b)[1]; \
+		vr[2] = (sa) * (a)[2] + (sb) * (b)[2]; \
+	}
+
+/*! Vector blending
+Takes two vectors a, b, blends them together with s <=1 */
+#define VEC_BLEND(vr, a, b, s) VEC_BLEND_AB(vr, (1 - s), a, s, b)
+
+#define VEC_SET3(a, b, op, c) \
+	a[0] = b[0] op c[0];      \
+	a[1] = b[1] op c[1];      \
+	a[2] = b[2] op c[2];
+
+//! Finds the bigger cartesian coordinate from a vector
+#define VEC_MAYOR_COORD(vec, maxc)                                          \
+	{                                                                       \
+		GREAL A[] = {fabs(vec[0]), fabs(vec[1]), fabs(vec[2])};             \
+		maxc = A[0] > A[1] ? (A[0] > A[2] ? 0 : 2) : (A[1] > A[2] ? 1 : 2); \
+	}
+
+//! Finds the 2 smallest cartesian coordinates from a vector
+#define VEC_MINOR_AXES(vec, i0, i1) \
+	{                               \
+		VEC_MAYOR_COORD(vec, i0);   \
+		i0 = (i0 + 1) % 3;          \
+		i1 = (i0 + 1) % 3;          \
+	}
+
+#define VEC_EQUAL(v1, v2) (v1[0] == v2[0] && v1[1] == v2[1] && v1[2] == v2[2])
+
+#define VEC_NEAR_EQUAL(v1, v2) (GIM_NEAR_EQUAL(v1[0], v2[0]) && GIM_NEAR_EQUAL(v1[1], v2[1]) && GIM_NEAR_EQUAL(v1[2], v2[2]))
+
+/// Vector cross
+#define X_AXIS_CROSS_VEC(dst, src) \
+	{                              \
+		dst[0] = 0.0f;             \
+		dst[1] = -src[2];          \
+		dst[2] = src[1];           \
+	}
+
+#define Y_AXIS_CROSS_VEC(dst, src) \
+	{                              \
+		dst[0] = src[2];           \
+		dst[1] = 0.0f;             \
+		dst[2] = -src[0];          \
+	}
+
+#define Z_AXIS_CROSS_VEC(dst, src) \
+	{                              \
+		dst[0] = -src[1];          \
+		dst[1] = src[0];           \
+		dst[2] = 0.0f;             \
+	}
+
+/// initialize matrix
+#define IDENTIFY_MATRIX_3X3(m) \
+	{                          \
+		m[0][0] = 1.0;         \
+		m[0][1] = 0.0;         \
+		m[0][2] = 0.0;         \
+                               \
+		m[1][0] = 0.0;         \
+		m[1][1] = 1.0;         \
+		m[1][2] = 0.0;         \
+                               \
+		m[2][0] = 0.0;         \
+		m[2][1] = 0.0;         \
+		m[2][2] = 1.0;         \
+	}
+
+/*! initialize matrix */
+#define IDENTIFY_MATRIX_4X4(m) \
+	{                          \
+		m[0][0] = 1.0;         \
+		m[0][1] = 0.0;         \
+		m[0][2] = 0.0;         \
+		m[0][3] = 0.0;         \
+                               \
+		m[1][0] = 0.0;         \
+		m[1][1] = 1.0;         \
+		m[1][2] = 0.0;         \
+		m[1][3] = 0.0;         \
+                               \
+		m[2][0] = 0.0;         \
+		m[2][1] = 0.0;         \
+		m[2][2] = 1.0;         \
+		m[2][3] = 0.0;         \
+                               \
+		m[3][0] = 0.0;         \
+		m[3][1] = 0.0;         \
+		m[3][2] = 0.0;         \
+		m[3][3] = 1.0;         \
+	}
+
+/*! initialize matrix */
+#define ZERO_MATRIX_4X4(m) \
+	{                      \
+		m[0][0] = 0.0;     \
+		m[0][1] = 0.0;     \
+		m[0][2] = 0.0;     \
+		m[0][3] = 0.0;     \
+                           \
+		m[1][0] = 0.0;     \
+		m[1][1] = 0.0;     \
+		m[1][2] = 0.0;     \
+		m[1][3] = 0.0;     \
+                           \
+		m[2][0] = 0.0;     \
+		m[2][1] = 0.0;     \
+		m[2][2] = 0.0;     \
+		m[2][3] = 0.0;     \
+                           \
+		m[3][0] = 0.0;     \
+		m[3][1] = 0.0;     \
+		m[3][2] = 0.0;     \
+		m[3][3] = 0.0;     \
+	}
+
+/*! matrix rotation  X */
+#define ROTX_CS(m, cosine, sine)        \
+	{                                   \
+		/* rotation about the x-axis */ \
+                                        \
+		m[0][0] = 1.0;                  \
+		m[0][1] = 0.0;                  \
+		m[0][2] = 0.0;                  \
+		m[0][3] = 0.0;                  \
+                                        \
+		m[1][0] = 0.0;                  \
+		m[1][1] = (cosine);             \
+		m[1][2] = (sine);               \
+		m[1][3] = 0.0;                  \
+                                        \
+		m[2][0] = 0.0;                  \
+		m[2][1] = -(sine);              \
+		m[2][2] = (cosine);             \
+		m[2][3] = 0.0;                  \
+                                        \
+		m[3][0] = 0.0;                  \
+		m[3][1] = 0.0;                  \
+		m[3][2] = 0.0;                  \
+		m[3][3] = 1.0;                  \
+	}
+
+/*! matrix rotation  Y */
+#define ROTY_CS(m, cosine, sine)        \
+	{                                   \
+		/* rotation about the y-axis */ \
+                                        \
+		m[0][0] = (cosine);             \
+		m[0][1] = 0.0;                  \
+		m[0][2] = -(sine);              \
+		m[0][3] = 0.0;                  \
+                                        \
+		m[1][0] = 0.0;                  \
+		m[1][1] = 1.0;                  \
+		m[1][2] = 0.0;                  \
+		m[1][3] = 0.0;                  \
+                                        \
+		m[2][0] = (sine);               \
+		m[2][1] = 0.0;                  \
+		m[2][2] = (cosine);             \
+		m[2][3] = 0.0;                  \
+                                        \
+		m[3][0] = 0.0;                  \
+		m[3][1] = 0.0;                  \
+		m[3][2] = 0.0;                  \
+		m[3][3] = 1.0;                  \
+	}
+
+/*! matrix rotation  Z */
+#define ROTZ_CS(m, cosine, sine)        \
+	{                                   \
+		/* rotation about the z-axis */ \
+                                        \
+		m[0][0] = (cosine);             \
+		m[0][1] = (sine);               \
+		m[0][2] = 0.0;                  \
+		m[0][3] = 0.0;                  \
+                                        \
+		m[1][0] = -(sine);              \
+		m[1][1] = (cosine);             \
+		m[1][2] = 0.0;                  \
+		m[1][3] = 0.0;                  \
+                                        \
+		m[2][0] = 0.0;                  \
+		m[2][1] = 0.0;                  \
+		m[2][2] = 1.0;                  \
+		m[2][3] = 0.0;                  \
+                                        \
+		m[3][0] = 0.0;                  \
+		m[3][1] = 0.0;                  \
+		m[3][2] = 0.0;                  \
+		m[3][3] = 1.0;                  \
+	}
+
+/*! matrix copy */
+#define COPY_MATRIX_2X2(b, a) \
+	{                         \
+		b[0][0] = a[0][0];    \
+		b[0][1] = a[0][1];    \
+                              \
+		b[1][0] = a[1][0];    \
+		b[1][1] = a[1][1];    \
+	}
+
+/*! matrix copy */
+#define COPY_MATRIX_2X3(b, a) \
+	{                         \
+		b[0][0] = a[0][0];    \
+		b[0][1] = a[0][1];    \
+		b[0][2] = a[0][2];    \
+                              \
+		b[1][0] = a[1][0];    \
+		b[1][1] = a[1][1];    \
+		b[1][2] = a[1][2];    \
+	}
+
+/*! matrix copy */
+#define COPY_MATRIX_3X3(b, a) \
+	{                         \
+		b[0][0] = a[0][0];    \
+		b[0][1] = a[0][1];    \
+		b[0][2] = a[0][2];    \
+                              \
+		b[1][0] = a[1][0];    \
+		b[1][1] = a[1][1];    \
+		b[1][2] = a[1][2];    \
+                              \
+		b[2][0] = a[2][0];    \
+		b[2][1] = a[2][1];    \
+		b[2][2] = a[2][2];    \
+	}
+
+/*! matrix copy */
+#define COPY_MATRIX_4X4(b, a) \
+	{                         \
+		b[0][0] = a[0][0];    \
+		b[0][1] = a[0][1];    \
+		b[0][2] = a[0][2];    \
+		b[0][3] = a[0][3];    \
+                              \
+		b[1][0] = a[1][0];    \
+		b[1][1] = a[1][1];    \
+		b[1][2] = a[1][2];    \
+		b[1][3] = a[1][3];    \
+                              \
+		b[2][0] = a[2][0];    \
+		b[2][1] = a[2][1];    \
+		b[2][2] = a[2][2];    \
+		b[2][3] = a[2][3];    \
+                              \
+		b[3][0] = a[3][0];    \
+		b[3][1] = a[3][1];    \
+		b[3][2] = a[3][2];    \
+		b[3][3] = a[3][3];    \
+	}
+
+/*! matrix transpose */
+#define TRANSPOSE_MATRIX_2X2(b, a) \
+	{                              \
+		b[0][0] = a[0][0];         \
+		b[0][1] = a[1][0];         \
+                                   \
+		b[1][0] = a[0][1];         \
+		b[1][1] = a[1][1];         \
+	}
+
+/*! matrix transpose */
+#define TRANSPOSE_MATRIX_3X3(b, a) \
+	{                              \
+		b[0][0] = a[0][0];         \
+		b[0][1] = a[1][0];         \
+		b[0][2] = a[2][0];         \
+                                   \
+		b[1][0] = a[0][1];         \
+		b[1][1] = a[1][1];         \
+		b[1][2] = a[2][1];         \
+                                   \
+		b[2][0] = a[0][2];         \
+		b[2][1] = a[1][2];         \
+		b[2][2] = a[2][2];         \
+	}
+
+/*! matrix transpose */
+#define TRANSPOSE_MATRIX_4X4(b, a) \
+	{                              \
+		b[0][0] = a[0][0];         \
+		b[0][1] = a[1][0];         \
+		b[0][2] = a[2][0];         \
+		b[0][3] = a[3][0];         \
+                                   \
+		b[1][0] = a[0][1];         \
+		b[1][1] = a[1][1];         \
+		b[1][2] = a[2][1];         \
+		b[1][3] = a[3][1];         \
+                                   \
+		b[2][0] = a[0][2];         \
+		b[2][1] = a[1][2];         \
+		b[2][2] = a[2][2];         \
+		b[2][3] = a[3][2];         \
+                                   \
+		b[3][0] = a[0][3];         \
+		b[3][1] = a[1][3];         \
+		b[3][2] = a[2][3];         \
+		b[3][3] = a[3][3];         \
+	}
+
+/*! multiply matrix by scalar */
+#define SCALE_MATRIX_2X2(b, s, a) \
+	{                             \
+		b[0][0] = (s)*a[0][0];    \
+		b[0][1] = (s)*a[0][1];    \
+                                  \
+		b[1][0] = (s)*a[1][0];    \
+		b[1][1] = (s)*a[1][1];    \
+	}
+
+/*! multiply matrix by scalar */
+#define SCALE_MATRIX_3X3(b, s, a) \
+	{                             \
+		b[0][0] = (s)*a[0][0];    \
+		b[0][1] = (s)*a[0][1];    \
+		b[0][2] = (s)*a[0][2];    \
+                                  \
+		b[1][0] = (s)*a[1][0];    \
+		b[1][1] = (s)*a[1][1];    \
+		b[1][2] = (s)*a[1][2];    \
+                                  \
+		b[2][0] = (s)*a[2][0];    \
+		b[2][1] = (s)*a[2][1];    \
+		b[2][2] = (s)*a[2][2];    \
+	}
+
+/*! multiply matrix by scalar */
+#define SCALE_MATRIX_4X4(b, s, a) \
+	{                             \
+		b[0][0] = (s)*a[0][0];    \
+		b[0][1] = (s)*a[0][1];    \
+		b[0][2] = (s)*a[0][2];    \
+		b[0][3] = (s)*a[0][3];    \
+                                  \
+		b[1][0] = (s)*a[1][0];    \
+		b[1][1] = (s)*a[1][1];    \
+		b[1][2] = (s)*a[1][2];    \
+		b[1][3] = (s)*a[1][3];    \
+                                  \
+		b[2][0] = (s)*a[2][0];    \
+		b[2][1] = (s)*a[2][1];    \
+		b[2][2] = (s)*a[2][2];    \
+		b[2][3] = (s)*a[2][3];    \
+                                  \
+		b[3][0] = s * a[3][0];    \
+		b[3][1] = s * a[3][1];    \
+		b[3][2] = s * a[3][2];    \
+		b[3][3] = s * a[3][3];    \
+	}
+
+/*! multiply matrix by scalar */
+#define SCALE_VEC_MATRIX_2X2(b, svec, a) \
+	{                                    \
+		b[0][0] = svec[0] * a[0][0];     \
+		b[1][0] = svec[0] * a[1][0];     \
+                                         \
+		b[0][1] = svec[1] * a[0][1];     \
+		b[1][1] = svec[1] * a[1][1];     \
+	}
+
+/*! multiply matrix by scalar. Each columns is scaled by each scalar vector component */
+#define SCALE_VEC_MATRIX_3X3(b, svec, a) \
+	{                                    \
+		b[0][0] = svec[0] * a[0][0];     \
+		b[1][0] = svec[0] * a[1][0];     \
+		b[2][0] = svec[0] * a[2][0];     \
+                                         \
+		b[0][1] = svec[1] * a[0][1];     \
+		b[1][1] = svec[1] * a[1][1];     \
+		b[2][1] = svec[1] * a[2][1];     \
+                                         \
+		b[0][2] = svec[2] * a[0][2];     \
+		b[1][2] = svec[2] * a[1][2];     \
+		b[2][2] = svec[2] * a[2][2];     \
+	}
+
+/*! multiply matrix by scalar */
+#define SCALE_VEC_MATRIX_4X4(b, svec, a) \
+	{                                    \
+		b[0][0] = svec[0] * a[0][0];     \
+		b[1][0] = svec[0] * a[1][0];     \
+		b[2][0] = svec[0] * a[2][0];     \
+		b[3][0] = svec[0] * a[3][0];     \
+                                         \
+		b[0][1] = svec[1] * a[0][1];     \
+		b[1][1] = svec[1] * a[1][1];     \
+		b[2][1] = svec[1] * a[2][1];     \
+		b[3][1] = svec[1] * a[3][1];     \
+                                         \
+		b[0][2] = svec[2] * a[0][2];     \
+		b[1][2] = svec[2] * a[1][2];     \
+		b[2][2] = svec[2] * a[2][2];     \
+		b[3][2] = svec[2] * a[3][2];     \
+                                         \
+		b[0][3] = svec[3] * a[0][3];     \
+		b[1][3] = svec[3] * a[1][3];     \
+		b[2][3] = svec[3] * a[2][3];     \
+		b[3][3] = svec[3] * a[3][3];     \
+	}
+
+/*! multiply matrix by scalar */
+#define ACCUM_SCALE_MATRIX_2X2(b, s, a) \
+	{                                   \
+		b[0][0] += (s)*a[0][0];         \
+		b[0][1] += (s)*a[0][1];         \
+                                        \
+		b[1][0] += (s)*a[1][0];         \
+		b[1][1] += (s)*a[1][1];         \
+	}
+
+/*! multiply matrix by scalar */
+#define ACCUM_SCALE_MATRIX_3X3(b, s, a) \
+	{                                   \
+		b[0][0] += (s)*a[0][0];         \
+		b[0][1] += (s)*a[0][1];         \
+		b[0][2] += (s)*a[0][2];         \
+                                        \
+		b[1][0] += (s)*a[1][0];         \
+		b[1][1] += (s)*a[1][1];         \
+		b[1][2] += (s)*a[1][2];         \
+                                        \
+		b[2][0] += (s)*a[2][0];         \
+		b[2][1] += (s)*a[2][1];         \
+		b[2][2] += (s)*a[2][2];         \
+	}
+
+/*! multiply matrix by scalar */
+#define ACCUM_SCALE_MATRIX_4X4(b, s, a) \
+	{                                   \
+		b[0][0] += (s)*a[0][0];         \
+		b[0][1] += (s)*a[0][1];         \
+		b[0][2] += (s)*a[0][2];         \
+		b[0][3] += (s)*a[0][3];         \
+                                        \
+		b[1][0] += (s)*a[1][0];         \
+		b[1][1] += (s)*a[1][1];         \
+		b[1][2] += (s)*a[1][2];         \
+		b[1][3] += (s)*a[1][3];         \
+                                        \
+		b[2][0] += (s)*a[2][0];         \
+		b[2][1] += (s)*a[2][1];         \
+		b[2][2] += (s)*a[2][2];         \
+		b[2][3] += (s)*a[2][3];         \
+                                        \
+		b[3][0] += (s)*a[3][0];         \
+		b[3][1] += (s)*a[3][1];         \
+		b[3][2] += (s)*a[3][2];         \
+		b[3][3] += (s)*a[3][3];         \
+	}
+
+/*! matrix product */
+/*! c[x][y] = a[x][0]*b[0][y]+a[x][1]*b[1][y]+a[x][2]*b[2][y]+a[x][3]*b[3][y];*/
+#define MATRIX_PRODUCT_2X2(c, a, b)                      \
+	{                                                    \
+		c[0][0] = a[0][0] * b[0][0] + a[0][1] * b[1][0]; \
+		c[0][1] = a[0][0] * b[0][1] + a[0][1] * b[1][1]; \
+                                                         \
+		c[1][0] = a[1][0] * b[0][0] + a[1][1] * b[1][0]; \
+		c[1][1] = a[1][0] * b[0][1] + a[1][1] * b[1][1]; \
+	}
+
+/*! matrix product */
+/*! c[x][y] = a[x][0]*b[0][y]+a[x][1]*b[1][y]+a[x][2]*b[2][y]+a[x][3]*b[3][y];*/
+#define MATRIX_PRODUCT_3X3(c, a, b)                                          \
+	{                                                                        \
+		c[0][0] = a[0][0] * b[0][0] + a[0][1] * b[1][0] + a[0][2] * b[2][0]; \
+		c[0][1] = a[0][0] * b[0][1] + a[0][1] * b[1][1] + a[0][2] * b[2][1]; \
+		c[0][2] = a[0][0] * b[0][2] + a[0][1] * b[1][2] + a[0][2] * b[2][2]; \
+                                                                             \
+		c[1][0] = a[1][0] * b[0][0] + a[1][1] * b[1][0] + a[1][2] * b[2][0]; \
+		c[1][1] = a[1][0] * b[0][1] + a[1][1] * b[1][1] + a[1][2] * b[2][1]; \
+		c[1][2] = a[1][0] * b[0][2] + a[1][1] * b[1][2] + a[1][2] * b[2][2]; \
+                                                                             \
+		c[2][0] = a[2][0] * b[0][0] + a[2][1] * b[1][0] + a[2][2] * b[2][0]; \
+		c[2][1] = a[2][0] * b[0][1] + a[2][1] * b[1][1] + a[2][2] * b[2][1]; \
+		c[2][2] = a[2][0] * b[0][2] + a[2][1] * b[1][2] + a[2][2] * b[2][2]; \
+	}
+
+/*! matrix product */
+/*! c[x][y] = a[x][0]*b[0][y]+a[x][1]*b[1][y]+a[x][2]*b[2][y]+a[x][3]*b[3][y];*/
+#define MATRIX_PRODUCT_4X4(c, a, b)                                                              \
+	{                                                                                            \
+		c[0][0] = a[0][0] * b[0][0] + a[0][1] * b[1][0] + a[0][2] * b[2][0] + a[0][3] * b[3][0]; \
+		c[0][1] = a[0][0] * b[0][1] + a[0][1] * b[1][1] + a[0][2] * b[2][1] + a[0][3] * b[3][1]; \
+		c[0][2] = a[0][0] * b[0][2] + a[0][1] * b[1][2] + a[0][2] * b[2][2] + a[0][3] * b[3][2]; \
+		c[0][3] = a[0][0] * b[0][3] + a[0][1] * b[1][3] + a[0][2] * b[2][3] + a[0][3] * b[3][3]; \
+                                                                                                 \
+		c[1][0] = a[1][0] * b[0][0] + a[1][1] * b[1][0] + a[1][2] * b[2][0] + a[1][3] * b[3][0]; \
+		c[1][1] = a[1][0] * b[0][1] + a[1][1] * b[1][1] + a[1][2] * b[2][1] + a[1][3] * b[3][1]; \
+		c[1][2] = a[1][0] * b[0][2] + a[1][1] * b[1][2] + a[1][2] * b[2][2] + a[1][3] * b[3][2]; \
+		c[1][3] = a[1][0] * b[0][3] + a[1][1] * b[1][3] + a[1][2] * b[2][3] + a[1][3] * b[3][3]; \
+                                                                                                 \
+		c[2][0] = a[2][0] * b[0][0] + a[2][1] * b[1][0] + a[2][2] * b[2][0] + a[2][3] * b[3][0]; \
+		c[2][1] = a[2][0] * b[0][1] + a[2][1] * b[1][1] + a[2][2] * b[2][1] + a[2][3] * b[3][1]; \
+		c[2][2] = a[2][0] * b[0][2] + a[2][1] * b[1][2] + a[2][2] * b[2][2] + a[2][3] * b[3][2]; \
+		c[2][3] = a[2][0] * b[0][3] + a[2][1] * b[1][3] + a[2][2] * b[2][3] + a[2][3] * b[3][3]; \
+                                                                                                 \
+		c[3][0] = a[3][0] * b[0][0] + a[3][1] * b[1][0] + a[3][2] * b[2][0] + a[3][3] * b[3][0]; \
+		c[3][1] = a[3][0] * b[0][1] + a[3][1] * b[1][1] + a[3][2] * b[2][1] + a[3][3] * b[3][1]; \
+		c[3][2] = a[3][0] * b[0][2] + a[3][1] * b[1][2] + a[3][2] * b[2][2] + a[3][3] * b[3][2]; \
+		c[3][3] = a[3][0] * b[0][3] + a[3][1] * b[1][3] + a[3][2] * b[2][3] + a[3][3] * b[3][3]; \
+	}
+
+/*! matrix times vector */
+#define MAT_DOT_VEC_2X2(p, m, v)                \
+	{                                           \
+		p[0] = m[0][0] * v[0] + m[0][1] * v[1]; \
+		p[1] = m[1][0] * v[0] + m[1][1] * v[1]; \
+	}
+
+/*! matrix times vector */
+#define MAT_DOT_VEC_3X3(p, m, v)                                 \
+	{                                                            \
+		p[0] = m[0][0] * v[0] + m[0][1] * v[1] + m[0][2] * v[2]; \
+		p[1] = m[1][0] * v[0] + m[1][1] * v[1] + m[1][2] * v[2]; \
+		p[2] = m[2][0] * v[0] + m[2][1] * v[1] + m[2][2] * v[2]; \
+	}
+
+/*! matrix times vector
+v is a vec4f
+*/
+#define MAT_DOT_VEC_4X4(p, m, v)                                                  \
+	{                                                                             \
+		p[0] = m[0][0] * v[0] + m[0][1] * v[1] + m[0][2] * v[2] + m[0][3] * v[3]; \
+		p[1] = m[1][0] * v[0] + m[1][1] * v[1] + m[1][2] * v[2] + m[1][3] * v[3]; \
+		p[2] = m[2][0] * v[0] + m[2][1] * v[1] + m[2][2] * v[2] + m[2][3] * v[3]; \
+		p[3] = m[3][0] * v[0] + m[3][1] * v[1] + m[3][2] * v[2] + m[3][3] * v[3]; \
+	}
+
+/*! matrix times vector
+v is a vec3f
+and m is a mat4f<br>
+Last column is added as the position
+*/
+#define MAT_DOT_VEC_3X4(p, m, v)                                           \
+	{                                                                      \
+		p[0] = m[0][0] * v[0] + m[0][1] * v[1] + m[0][2] * v[2] + m[0][3]; \
+		p[1] = m[1][0] * v[0] + m[1][1] * v[1] + m[1][2] * v[2] + m[1][3]; \
+		p[2] = m[2][0] * v[0] + m[2][1] * v[1] + m[2][2] * v[2] + m[2][3]; \
+	}
+
+/*! vector transpose times matrix */
+/*! p[j] = v[0]*m[0][j] + v[1]*m[1][j] + v[2]*m[2][j]; */
+#define VEC_DOT_MAT_3X3(p, v, m)                                 \
+	{                                                            \
+		p[0] = v[0] * m[0][0] + v[1] * m[1][0] + v[2] * m[2][0]; \
+		p[1] = v[0] * m[0][1] + v[1] * m[1][1] + v[2] * m[2][1]; \
+		p[2] = v[0] * m[0][2] + v[1] * m[1][2] + v[2] * m[2][2]; \
+	}
+
+/*! affine matrix times vector */
+/** The matrix is assumed to be an affine matrix, with last two
+ * entries representing a translation */
+#define MAT_DOT_VEC_2X3(p, m, v)                          \
+	{                                                     \
+		p[0] = m[0][0] * v[0] + m[0][1] * v[1] + m[0][2]; \
+		p[1] = m[1][0] * v[0] + m[1][1] * v[1] + m[1][2]; \
+	}
+
+//! Transform a plane
+#define MAT_TRANSFORM_PLANE_4X4(pout, m, plane)                                         \
+	{                                                                                   \
+		pout[0] = m[0][0] * plane[0] + m[0][1] * plane[1] + m[0][2] * plane[2];         \
+		pout[1] = m[1][0] * plane[0] + m[1][1] * plane[1] + m[1][2] * plane[2];         \
+		pout[2] = m[2][0] * plane[0] + m[2][1] * plane[1] + m[2][2] * plane[2];         \
+		pout[3] = m[0][3] * pout[0] + m[1][3] * pout[1] + m[2][3] * pout[2] + plane[3]; \
+	}
+
+/** inverse transpose of matrix times vector
+ *
+ * This macro computes inverse transpose of matrix m,
+ * and multiplies vector v into it, to yeild vector p
+ *
+ * DANGER !!! Do Not use this on normal vectors!!!
+ * It will leave normals the wrong length !!!
+ * See macro below for use on normals.
+ */
+#define INV_TRANSP_MAT_DOT_VEC_2X2(p, m, v)                                 \
+	{                                                                       \
+		GREAL det;                                                          \
+                                                                            \
+		det = m[0][0] * m[1][1] - m[0][1] * m[1][0];                        \
+		p[0] = m[1][1] * v[0] - m[1][0] * v[1];                             \
+		p[1] = -m[0][1] * v[0] + m[0][0] * v[1];                            \
+                                                                            \
+		/* if matrix not singular, and not orthonormal, then renormalize */ \
+		if ((det != 1.0f) && (det != 0.0f))                                 \
+		{                                                                   \
+			det = 1.0f / det;                                               \
+			p[0] *= det;                                                    \
+			p[1] *= det;                                                    \
+		}                                                                   \
+	}
+
+/** transform normal vector by inverse transpose of matrix
+ * and then renormalize the vector
+ *
+ * This macro computes inverse transpose of matrix m,
+ * and multiplies vector v into it, to yeild vector p
+ * Vector p is then normalized.
+ */
+#define NORM_XFORM_2X2(p, m, v)                                           \
+	{                                                                     \
+		GREAL len;                                                        \
+                                                                          \
+		/* do nothing if off-diagonals are zero and diagonals are 	\
+    * equal */      \
+		if ((m[0][1] != 0.0) || (m[1][0] != 0.0) || (m[0][0] != m[1][1])) \
+		{                                                                 \
+			p[0] = m[1][1] * v[0] - m[1][0] * v[1];                       \
+			p[1] = -m[0][1] * v[0] + m[0][0] * v[1];                      \
+                                                                          \
+			len = p[0] * p[0] + p[1] * p[1];                              \
+			GIM_INV_SQRT(len, len);                                       \
+			p[0] *= len;                                                  \
+			p[1] *= len;                                                  \
+		}                                                                 \
+		else                                                              \
+		{                                                                 \
+			VEC_COPY_2(p, v);                                             \
+		}                                                                 \
+	}
+
+/** outer product of vector times vector transpose
+ *
+ * The outer product of vector v and vector transpose t yeilds
+ * dyadic matrix m.
+ */
+#define OUTER_PRODUCT_2X2(m, v, t) \
+	{                              \
+		m[0][0] = v[0] * t[0];     \
+		m[0][1] = v[0] * t[1];     \
+                                   \
+		m[1][0] = v[1] * t[0];     \
+		m[1][1] = v[1] * t[1];     \
+	}
+
+/** outer product of vector times vector transpose
+ *
+ * The outer product of vector v and vector transpose t yeilds
+ * dyadic matrix m.
+ */
+#define OUTER_PRODUCT_3X3(m, v, t) \
+	{                              \
+		m[0][0] = v[0] * t[0];     \
+		m[0][1] = v[0] * t[1];     \
+		m[0][2] = v[0] * t[2];     \
+                                   \
+		m[1][0] = v[1] * t[0];     \
+		m[1][1] = v[1] * t[1];     \
+		m[1][2] = v[1] * t[2];     \
+                                   \
+		m[2][0] = v[2] * t[0];     \
+		m[2][1] = v[2] * t[1];     \
+		m[2][2] = v[2] * t[2];     \
+	}
+
+/** outer product of vector times vector transpose
+ *
+ * The outer product of vector v and vector transpose t yeilds
+ * dyadic matrix m.
+ */
+#define OUTER_PRODUCT_4X4(m, v, t) \
+	{                              \
+		m[0][0] = v[0] * t[0];     \
+		m[0][1] = v[0] * t[1];     \
+		m[0][2] = v[0] * t[2];     \
+		m[0][3] = v[0] * t[3];     \
+                                   \
+		m[1][0] = v[1] * t[0];     \
+		m[1][1] = v[1] * t[1];     \
+		m[1][2] = v[1] * t[2];     \
+		m[1][3] = v[1] * t[3];     \
+                                   \
+		m[2][0] = v[2] * t[0];     \
+		m[2][1] = v[2] * t[1];     \
+		m[2][2] = v[2] * t[2];     \
+		m[2][3] = v[2] * t[3];     \
+                                   \
+		m[3][0] = v[3] * t[0];     \
+		m[3][1] = v[3] * t[1];     \
+		m[3][2] = v[3] * t[2];     \
+		m[3][3] = v[3] * t[3];     \
+	}
+
+/** outer product of vector times vector transpose
+ *
+ * The outer product of vector v and vector transpose t yeilds
+ * dyadic matrix m.
+ */
+#define ACCUM_OUTER_PRODUCT_2X2(m, v, t) \
+	{                                    \
+		m[0][0] += v[0] * t[0];          \
+		m[0][1] += v[0] * t[1];          \
+                                         \
+		m[1][0] += v[1] * t[0];          \
+		m[1][1] += v[1] * t[1];          \
+	}
+
+/** outer product of vector times vector transpose
+ *
+ * The outer product of vector v and vector transpose t yeilds
+ * dyadic matrix m.
+ */
+#define ACCUM_OUTER_PRODUCT_3X3(m, v, t) \
+	{                                    \
+		m[0][0] += v[0] * t[0];          \
+		m[0][1] += v[0] * t[1];          \
+		m[0][2] += v[0] * t[2];          \
+                                         \
+		m[1][0] += v[1] * t[0];          \
+		m[1][1] += v[1] * t[1];          \
+		m[1][2] += v[1] * t[2];          \
+                                         \
+		m[2][0] += v[2] * t[0];          \
+		m[2][1] += v[2] * t[1];          \
+		m[2][2] += v[2] * t[2];          \
+	}
+
+/** outer product of vector times vector transpose
+ *
+ * The outer product of vector v and vector transpose t yeilds
+ * dyadic matrix m.
+ */
+#define ACCUM_OUTER_PRODUCT_4X4(m, v, t) \
+	{                                    \
+		m[0][0] += v[0] * t[0];          \
+		m[0][1] += v[0] * t[1];          \
+		m[0][2] += v[0] * t[2];          \
+		m[0][3] += v[0] * t[3];          \
+                                         \
+		m[1][0] += v[1] * t[0];          \
+		m[1][1] += v[1] * t[1];          \
+		m[1][2] += v[1] * t[2];          \
+		m[1][3] += v[1] * t[3];          \
+                                         \
+		m[2][0] += v[2] * t[0];          \
+		m[2][1] += v[2] * t[1];          \
+		m[2][2] += v[2] * t[2];          \
+		m[2][3] += v[2] * t[3];          \
+                                         \
+		m[3][0] += v[3] * t[0];          \
+		m[3][1] += v[3] * t[1];          \
+		m[3][2] += v[3] * t[2];          \
+		m[3][3] += v[3] * t[3];          \
+	}
+
+/** determinant of matrix
+ *
+ * Computes determinant of matrix m, returning d
+ */
+#define DETERMINANT_2X2(d, m)                      \
+	{                                              \
+		d = m[0][0] * m[1][1] - m[0][1] * m[1][0]; \
+	}
+
+/** determinant of matrix
+ *
+ * Computes determinant of matrix m, returning d
+ */
+#define DETERMINANT_3X3(d, m)                                   \
+	{                                                           \
+		d = m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1]);  \
+		d -= m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0]); \
+		d += m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0]); \
+	}
+
+/** i,j,th cofactor of a 4x4 matrix
+ *
+ */
+#define COFACTOR_4X4_IJ(fac, m, i, j)                                                                                           \
+	{                                                                                                                           \
+		GUINT __ii[4], __jj[4], __k;                                                                                            \
+                                                                                                                                \
+		for (__k = 0; __k < i; __k++) __ii[__k] = __k;                                                                          \
+		for (__k = i; __k < 3; __k++) __ii[__k] = __k + 1;                                                                      \
+		for (__k = 0; __k < j; __k++) __jj[__k] = __k;                                                                          \
+		for (__k = j; __k < 3; __k++) __jj[__k] = __k + 1;                                                                      \
+                                                                                                                                \
+		(fac) = m[__ii[0]][__jj[0]] * (m[__ii[1]][__jj[1]] * m[__ii[2]][__jj[2]] - m[__ii[1]][__jj[2]] * m[__ii[2]][__jj[1]]);  \
+		(fac) -= m[__ii[0]][__jj[1]] * (m[__ii[1]][__jj[0]] * m[__ii[2]][__jj[2]] - m[__ii[1]][__jj[2]] * m[__ii[2]][__jj[0]]); \
+		(fac) += m[__ii[0]][__jj[2]] * (m[__ii[1]][__jj[0]] * m[__ii[2]][__jj[1]] - m[__ii[1]][__jj[1]] * m[__ii[2]][__jj[0]]); \
+                                                                                                                                \
+		__k = i + j;                                                                                                            \
+		if (__k != (__k / 2) * 2)                                                                                               \
+		{                                                                                                                       \
+			(fac) = -(fac);                                                                                                     \
+		}                                                                                                                       \
+	}
+
+/** determinant of matrix
+ *
+ * Computes determinant of matrix m, returning d
+ */
+#define DETERMINANT_4X4(d, m)            \
+	{                                    \
+		GREAL cofac;                     \
+		COFACTOR_4X4_IJ(cofac, m, 0, 0); \
+		d = m[0][0] * cofac;             \
+		COFACTOR_4X4_IJ(cofac, m, 0, 1); \
+		d += m[0][1] * cofac;            \
+		COFACTOR_4X4_IJ(cofac, m, 0, 2); \
+		d += m[0][2] * cofac;            \
+		COFACTOR_4X4_IJ(cofac, m, 0, 3); \
+		d += m[0][3] * cofac;            \
+	}
+
+/** cofactor of matrix
+ *
+ * Computes cofactor of matrix m, returning a
+ */
+#define COFACTOR_2X2(a, m)    \
+	{                         \
+		a[0][0] = (m)[1][1];  \
+		a[0][1] = -(m)[1][0]; \
+		a[1][0] = -(m)[0][1]; \
+		a[1][1] = (m)[0][0];  \
+	}
+
+/** cofactor of matrix
+ *
+ * Computes cofactor of matrix m, returning a
+ */
+#define COFACTOR_3X3(a, m)                                  \
+	{                                                       \
+		a[0][0] = m[1][1] * m[2][2] - m[1][2] * m[2][1];    \
+		a[0][1] = -(m[1][0] * m[2][2] - m[2][0] * m[1][2]); \
+		a[0][2] = m[1][0] * m[2][1] - m[1][1] * m[2][0];    \
+		a[1][0] = -(m[0][1] * m[2][2] - m[0][2] * m[2][1]); \
+		a[1][1] = m[0][0] * m[2][2] - m[0][2] * m[2][0];    \
+		a[1][2] = -(m[0][0] * m[2][1] - m[0][1] * m[2][0]); \
+		a[2][0] = m[0][1] * m[1][2] - m[0][2] * m[1][1];    \
+		a[2][1] = -(m[0][0] * m[1][2] - m[0][2] * m[1][0]); \
+   a[2][2] = m[0][0]*m[1][1] - m[0][1]*m[1][0]);            \
+	}
+
+/** cofactor of matrix
+ *
+ * Computes cofactor of matrix m, returning a
+ */
+#define COFACTOR_4X4(a, m)                         \
+	{                                              \
+		int i, j;                                  \
+                                                   \
+		for (i = 0; i < 4; i++)                    \
+		{                                          \
+			for (j = 0; j < 4; j++)                \
+			{                                      \
+				COFACTOR_4X4_IJ(a[i][j], m, i, j); \
+			}                                      \
+		}                                          \
+	}
+
+/** adjoint of matrix
+ *
+ * Computes adjoint of matrix m, returning a
+ * (Note that adjoint is just the transpose of the cofactor matrix)
+ */
+#define ADJOINT_2X2(a, m)     \
+	{                         \
+		a[0][0] = (m)[1][1];  \
+		a[1][0] = -(m)[1][0]; \
+		a[0][1] = -(m)[0][1]; \
+		a[1][1] = (m)[0][0];  \
+	}
+
+/** adjoint of matrix
+ *
+ * Computes adjoint of matrix m, returning a
+ * (Note that adjoint is just the transpose of the cofactor matrix)
+ */
+#define ADJOINT_3X3(a, m)                                   \
+	{                                                       \
+		a[0][0] = m[1][1] * m[2][2] - m[1][2] * m[2][1];    \
+		a[1][0] = -(m[1][0] * m[2][2] - m[2][0] * m[1][2]); \
+		a[2][0] = m[1][0] * m[2][1] - m[1][1] * m[2][0];    \
+		a[0][1] = -(m[0][1] * m[2][2] - m[0][2] * m[2][1]); \
+		a[1][1] = m[0][0] * m[2][2] - m[0][2] * m[2][0];    \
+		a[2][1] = -(m[0][0] * m[2][1] - m[0][1] * m[2][0]); \
+		a[0][2] = m[0][1] * m[1][2] - m[0][2] * m[1][1];    \
+		a[1][2] = -(m[0][0] * m[1][2] - m[0][2] * m[1][0]); \
+   a[2][2] = m[0][0]*m[1][1] - m[0][1]*m[1][0]);            \
+	}
+
+/** adjoint of matrix
+ *
+ * Computes adjoint of matrix m, returning a
+ * (Note that adjoint is just the transpose of the cofactor matrix)
+ */
+#define ADJOINT_4X4(a, m)                                  \
+	{                                                      \
+		char _i_, _j_;                                     \
+                                                           \
+		for (_i_ = 0; _i_ < 4; _i_++)                      \
+		{                                                  \
+			for (_j_ = 0; _j_ < 4; _j_++)                  \
+			{                                              \
+				COFACTOR_4X4_IJ(a[_j_][_i_], m, _i_, _j_); \
+			}                                              \
+		}                                                  \
+	}
+
+/** compute adjoint of matrix and scale
+ *
+ * Computes adjoint of matrix m, scales it by s, returning a
+ */
+#define SCALE_ADJOINT_2X2(a, s, m) \
+	{                              \
+		a[0][0] = (s)*m[1][1];     \
+		a[1][0] = -(s)*m[1][0];    \
+		a[0][1] = -(s)*m[0][1];    \
+		a[1][1] = (s)*m[0][0];     \
+	}
+
+/** compute adjoint of matrix and scale
+ *
+ * Computes adjoint of matrix m, scales it by s, returning a
+ */
+#define SCALE_ADJOINT_3X3(a, s, m)                               \
+	{                                                            \
+		a[0][0] = (s) * (m[1][1] * m[2][2] - m[1][2] * m[2][1]); \
+		a[1][0] = (s) * (m[1][2] * m[2][0] - m[1][0] * m[2][2]); \
+		a[2][0] = (s) * (m[1][0] * m[2][1] - m[1][1] * m[2][0]); \
+                                                                 \
+		a[0][1] = (s) * (m[0][2] * m[2][1] - m[0][1] * m[2][2]); \
+		a[1][1] = (s) * (m[0][0] * m[2][2] - m[0][2] * m[2][0]); \
+		a[2][1] = (s) * (m[0][1] * m[2][0] - m[0][0] * m[2][1]); \
+                                                                 \
+		a[0][2] = (s) * (m[0][1] * m[1][2] - m[0][2] * m[1][1]); \
+		a[1][2] = (s) * (m[0][2] * m[1][0] - m[0][0] * m[1][2]); \
+		a[2][2] = (s) * (m[0][0] * m[1][1] - m[0][1] * m[1][0]); \
+	}
+
+/** compute adjoint of matrix and scale
+ *
+ * Computes adjoint of matrix m, scales it by s, returning a
+ */
+#define SCALE_ADJOINT_4X4(a, s, m)                         \
+	{                                                      \
+		char _i_, _j_;                                     \
+		for (_i_ = 0; _i_ < 4; _i_++)                      \
+		{                                                  \
+			for (_j_ = 0; _j_ < 4; _j_++)                  \
+			{                                              \
+				COFACTOR_4X4_IJ(a[_j_][_i_], m, _i_, _j_); \
+				a[_j_][_i_] *= s;                          \
+			}                                              \
+		}                                                  \
+	}
+
+/** inverse of matrix
+ *
+ * Compute inverse of matrix a, returning determinant m and
+ * inverse b
+ */
+#define INVERT_2X2(b, det, a)           \
+	{                                   \
+		GREAL _tmp_;                    \
+		DETERMINANT_2X2(det, a);        \
+		_tmp_ = 1.0 / (det);            \
+		SCALE_ADJOINT_2X2(b, _tmp_, a); \
+	}
+
+/** inverse of matrix
+ *
+ * Compute inverse of matrix a, returning determinant m and
+ * inverse b
+ */
+#define INVERT_3X3(b, det, a)           \
+	{                                   \
+		GREAL _tmp_;                    \
+		DETERMINANT_3X3(det, a);        \
+		_tmp_ = 1.0 / (det);            \
+		SCALE_ADJOINT_3X3(b, _tmp_, a); \
+	}
+
+/** inverse of matrix
+ *
+ * Compute inverse of matrix a, returning determinant m and
+ * inverse b
+ */
+#define INVERT_4X4(b, det, a)           \
+	{                                   \
+		GREAL _tmp_;                    \
+		DETERMINANT_4X4(det, a);        \
+		_tmp_ = 1.0 / (det);            \
+		SCALE_ADJOINT_4X4(b, _tmp_, a); \
+	}
+
+//! Get the triple(3) row of a transform matrix
+#define MAT_GET_ROW(mat, vec3, rowindex) \
+	{                                    \
+		vec3[0] = mat[rowindex][0];      \
+		vec3[1] = mat[rowindex][1];      \
+		vec3[2] = mat[rowindex][2];      \
+	}
+
+//! Get the tuple(2) row of a transform matrix
+#define MAT_GET_ROW2(mat, vec2, rowindex) \
+	{                                     \
+		vec2[0] = mat[rowindex][0];       \
+		vec2[1] = mat[rowindex][1];       \
+	}
+
+//! Get the quad (4) row of a transform matrix
+#define MAT_GET_ROW4(mat, vec4, rowindex) \
+	{                                     \
+		vec4[0] = mat[rowindex][0];       \
+		vec4[1] = mat[rowindex][1];       \
+		vec4[2] = mat[rowindex][2];       \
+		vec4[3] = mat[rowindex][3];       \
+	}
+
+//! Get the triple(3) col of a transform matrix
+#define MAT_GET_COL(mat, vec3, colindex) \
+	{                                    \
+		vec3[0] = mat[0][colindex];      \
+		vec3[1] = mat[1][colindex];      \
+		vec3[2] = mat[2][colindex];      \
+	}
+
+//! Get the tuple(2) col of a transform matrix
+#define MAT_GET_COL2(mat, vec2, colindex) \
+	{                                     \
+		vec2[0] = mat[0][colindex];       \
+		vec2[1] = mat[1][colindex];       \
+	}
+
+//! Get the quad (4) col of a transform matrix
+#define MAT_GET_COL4(mat, vec4, colindex) \
+	{                                     \
+		vec4[0] = mat[0][colindex];       \
+		vec4[1] = mat[1][colindex];       \
+		vec4[2] = mat[2][colindex];       \
+		vec4[3] = mat[3][colindex];       \
+	}
+
+//! Get the triple(3) col of a transform matrix
+#define MAT_GET_X(mat, vec3)       \
+	{                              \
+		MAT_GET_COL(mat, vec3, 0); \
+	}
+
+//! Get the triple(3) col of a transform matrix
+#define MAT_GET_Y(mat, vec3)       \
+	{                              \
+		MAT_GET_COL(mat, vec3, 1); \
+	}
+
+//! Get the triple(3) col of a transform matrix
+#define MAT_GET_Z(mat, vec3)       \
+	{                              \
+		MAT_GET_COL(mat, vec3, 2); \
+	}
+
+//! Get the triple(3) col of a transform matrix
+#define MAT_SET_X(mat, vec3) \
+	{                        \
+		mat[0][0] = vec3[0]; \
+		mat[1][0] = vec3[1]; \
+		mat[2][0] = vec3[2]; \
+	}
+
+//! Get the triple(3) col of a transform matrix
+#define MAT_SET_Y(mat, vec3) \
+	{                        \
+		mat[0][1] = vec3[0]; \
+		mat[1][1] = vec3[1]; \
+		mat[2][1] = vec3[2]; \
+	}
+
+//! Get the triple(3) col of a transform matrix
+#define MAT_SET_Z(mat, vec3) \
+	{                        \
+		mat[0][2] = vec3[0]; \
+		mat[1][2] = vec3[1]; \
+		mat[2][2] = vec3[2]; \
+	}
+
+//! Get the triple(3) col of a transform matrix
+#define MAT_GET_TRANSLATION(mat, vec3) \
+	{                                  \
+		vec3[0] = mat[0][3];           \
+		vec3[1] = mat[1][3];           \
+		vec3[2] = mat[2][3];           \
+	}
+
+//! Set the triple(3) col of a transform matrix
+#define MAT_SET_TRANSLATION(mat, vec3) \
+	{                                  \
+		mat[0][3] = vec3[0];           \
+		mat[1][3] = vec3[1];           \
+		mat[2][3] = vec3[2];           \
+	}
+
+//! Returns the dot product between a vec3f and the row of a matrix
+#define MAT_DOT_ROW(mat, vec3, rowindex) (vec3[0] * mat[rowindex][0] + vec3[1] * mat[rowindex][1] + vec3[2] * mat[rowindex][2])
+
+//! Returns the dot product between a vec2f and the row of a matrix
+#define MAT_DOT_ROW2(mat, vec2, rowindex) (vec2[0] * mat[rowindex][0] + vec2[1] * mat[rowindex][1])
+
+//! Returns the dot product between a vec4f and the row of a matrix
+#define MAT_DOT_ROW4(mat, vec4, rowindex) (vec4[0] * mat[rowindex][0] + vec4[1] * mat[rowindex][1] + vec4[2] * mat[rowindex][2] + vec4[3] * mat[rowindex][3])
+
+//! Returns the dot product between a vec3f and the col of a matrix
+#define MAT_DOT_COL(mat, vec3, colindex) (vec3[0] * mat[0][colindex] + vec3[1] * mat[1][colindex] + vec3[2] * mat[2][colindex])
+
+//! Returns the dot product between a vec2f and the col of a matrix
+#define MAT_DOT_COL2(mat, vec2, colindex) (vec2[0] * mat[0][colindex] + vec2[1] * mat[1][colindex])
+
+//! Returns the dot product between a vec4f and the col of a matrix
+#define MAT_DOT_COL4(mat, vec4, colindex) (vec4[0] * mat[0][colindex] + vec4[1] * mat[1][colindex] + vec4[2] * mat[2][colindex] + vec4[3] * mat[3][colindex])
+
+/*!Transpose matrix times vector
+v is a vec3f
+and m is a mat4f<br>
+*/
+#define INV_MAT_DOT_VEC_3X3(p, m, v) \
+	{                                \
+		p[0] = MAT_DOT_COL(m, v, 0); \
+		p[1] = MAT_DOT_COL(m, v, 1); \
+		p[2] = MAT_DOT_COL(m, v, 2); \
+	}
+
+#endif  // GIM_VECTOR_H_INCLUDED
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/gim_math.h b/engine/inc/bullet/BulletCollision/Gimpact/gim_math.h
new file mode 100644
index 00000000..3c4f821a
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/gim_math.h
@@ -0,0 +1,148 @@
+#ifndef GIM_MATH_H_INCLUDED
+#define GIM_MATH_H_INCLUDED
+/*! \file gim_math.h
+\author Francisco Leon Najera
+*/
+/*
+-----------------------------------------------------------------------------
+This source file is part of GIMPACT Library.
+
+For the latest info, see http://gimpact.sourceforge.net/
+
+Copyright (c) 2006 Francisco Leon Najera. C.C. 80087371.
+email: projectileman@yahoo.com
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of EITHER:
+   (1) The GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 2.1 of the License, or (at
+       your option) any later version. The text of the GNU Lesser
+       General Public License is included with this library in the
+       file GIMPACT-LICENSE-LGPL.TXT.
+   (2) The BSD-style license that is included with this library in
+       the file GIMPACT-LICENSE-BSD.TXT.
+   (3) The zlib/libpng license that is included with this library in
+       the file GIMPACT-LICENSE-ZLIB.TXT.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files
+ GIMPACT-LICENSE-LGPL.TXT, GIMPACT-LICENSE-ZLIB.TXT and GIMPACT-LICENSE-BSD.TXT for more details.
+
+-----------------------------------------------------------------------------
+*/
+
+#include "LinearMath/btScalar.h"
+
+#define GREAL btScalar
+#define GREAL2 double
+#define GINT int
+#define GUINT unsigned int
+#define GSHORT short
+#define GUSHORT unsigned short
+#define GINT64 long long
+#define GUINT64 unsigned long long
+
+#define G_PI 3.14159265358979f
+#define G_HALF_PI 1.5707963f
+//267948966
+#define G_TWO_PI 6.28318530f
+//71795864
+#define G_ROOT3 1.73205f
+#define G_ROOT2 1.41421f
+#define G_UINT_INFINITY 0xffffffff  //!< A very very high value
+#define G_REAL_INFINITY FLT_MAX
+#define G_SIGN_BITMASK 0x80000000
+#define G_EPSILON SIMD_EPSILON
+
+enum GIM_SCALAR_TYPES
+{
+	G_STYPE_REAL = 0,
+	G_STYPE_REAL2,
+	G_STYPE_SHORT,
+	G_STYPE_USHORT,
+	G_STYPE_INT,
+	G_STYPE_UINT,
+	G_STYPE_INT64,
+	G_STYPE_UINT64
+};
+
+#define G_DEGTORAD(X) ((X)*3.1415926f / 180.0f)
+#define G_RADTODEG(X) ((X)*180.0f / 3.1415926f)
+
+//! Integer representation of a floating-point value.
+#define GIM_IR(x) ((GUINT&)(x))
+
+//! Signed integer representation of a floating-point value.
+#define GIM_SIR(x) ((GINT&)(x))
+
+//! Absolute integer representation of a floating-point value
+#define GIM_AIR(x) (GIM_IR(x) & 0x7fffffff)
+
+//! Floating-point representation of an integer value.
+#define GIM_FR(x) ((GREAL&)(x))
+
+#define GIM_MAX(a, b) (a < b ? b : a)
+#define GIM_MIN(a, b) (a > b ? b : a)
+
+#define GIM_MAX3(a, b, c) GIM_MAX(a, GIM_MAX(b, c))
+#define GIM_MIN3(a, b, c) GIM_MIN(a, GIM_MIN(b, c))
+
+#define GIM_IS_ZERO(value) (value < G_EPSILON && value > -G_EPSILON)
+
+#define GIM_IS_NEGATIVE(value) (value <= -G_EPSILON)
+
+#define GIM_IS_POSISITVE(value) (value >= G_EPSILON)
+
+#define GIM_NEAR_EQUAL(v1, v2) GIM_IS_ZERO((v1 - v2))
+
+///returns a clamped number
+#define GIM_CLAMP(number, minval, maxval) (number < minval ? minval : (number > maxval ? maxval : number))
+
+#define GIM_GREATER(x, y) btFabs(x) > (y)
+
+///Swap numbers
+#define GIM_SWAP_NUMBERS(a, b) \
+	{                          \
+		a = a + b;             \
+		b = a - b;             \
+		a = a - b;             \
+	}
+
+#define GIM_INV_SQRT(va, isva)                         \
+	{                                                  \
+		if (va <= 0.0000001f)                          \
+		{                                              \
+			isva = G_REAL_INFINITY;                    \
+		}                                              \
+		else                                           \
+		{                                              \
+			GREAL _x = va * 0.5f;                      \
+			GUINT _y = 0x5f3759df - (GIM_IR(va) >> 1); \
+			isva = GIM_FR(_y);                         \
+			isva = isva * (1.5f - (_x * isva * isva)); \
+		}                                              \
+	}
+
+#define GIM_SQRT(va, sva)      \
+	{                          \
+		GIM_INV_SQRT(va, sva); \
+		sva = 1.0f / sva;      \
+	}
+
+//! Computes 1.0f / sqrtf(x). Comes from Quake3. See http://www.magic-software.com/3DGEDInvSqrt.html
+inline GREAL gim_inv_sqrt(GREAL f)
+{
+	GREAL r;
+	GIM_INV_SQRT(f, r);
+	return r;
+}
+
+inline GREAL gim_sqrt(GREAL f)
+{
+	GREAL r;
+	GIM_SQRT(f, r);
+	return r;
+}
+
+#endif  // GIM_MATH_H_INCLUDED
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/gim_memory.h b/engine/inc/bullet/BulletCollision/Gimpact/gim_memory.h
new file mode 100644
index 00000000..fffbfa23
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/gim_memory.h
@@ -0,0 +1,177 @@
+#ifndef GIM_MEMORY_H_INCLUDED
+#define GIM_MEMORY_H_INCLUDED
+/*! \file gim_memory.h
+\author Francisco Leon Najera
+*/
+/*
+-----------------------------------------------------------------------------
+This source file is part of GIMPACT Library.
+
+For the latest info, see http://gimpact.sourceforge.net/
+
+Copyright (c) 2006 Francisco Leon Najera. C.C. 80087371.
+email: projectileman@yahoo.com
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of EITHER:
+   (1) The GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 2.1 of the License, or (at
+       your option) any later version. The text of the GNU Lesser
+       General Public License is included with this library in the
+       file GIMPACT-LICENSE-LGPL.TXT.
+   (2) The BSD-style license that is included with this library in
+       the file GIMPACT-LICENSE-BSD.TXT.
+   (3) The zlib/libpng license that is included with this library in
+       the file GIMPACT-LICENSE-ZLIB.TXT.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files
+ GIMPACT-LICENSE-LGPL.TXT, GIMPACT-LICENSE-ZLIB.TXT and GIMPACT-LICENSE-BSD.TXT for more details.
+
+-----------------------------------------------------------------------------
+*/
+
+#include "gim_math.h"
+#include <string.h>
+
+#ifdef PREFETCH
+#include <xmmintrin.h>  // for prefetch
+#define pfval 64
+#define pfval2 128
+//! Prefetch 64
+#define pf(_x, _i) _mm_prefetch((void *)(_x + _i + pfval), 0)
+//! Prefetch 128
+#define pf2(_x, _i) _mm_prefetch((void *)(_x + _i + pfval2), 0)
+#else
+//! Prefetch 64
+#define pf(_x, _i)
+//! Prefetch 128
+#define pf2(_x, _i)
+#endif
+
+///Functions for manip packed arrays of numbers
+#define GIM_COPY_ARRAYS(dest_array, source_array, element_count) \
+	{                                                            \
+		for (GUINT _i_ = 0; _i_ < element_count; ++_i_)          \
+		{                                                        \
+			dest_array[_i_] = source_array[_i_];                 \
+		}                                                        \
+	}
+
+#define GIM_COPY_ARRAYS_1(dest_array, source_array, element_count, copy_macro) \
+	{                                                                          \
+		for (GUINT _i_ = 0; _i_ < element_count; ++_i_)                        \
+		{                                                                      \
+			copy_macro(dest_array[_i_], source_array[_i_]);                    \
+		}                                                                      \
+	}
+
+#define GIM_ZERO_ARRAY(array, element_count)            \
+	{                                                   \
+		for (GUINT _i_ = 0; _i_ < element_count; ++_i_) \
+		{                                               \
+			array[_i_] = 0;                             \
+		}                                               \
+	}
+
+#define GIM_CONSTANT_ARRAY(array, element_count, constant) \
+	{                                                      \
+		for (GUINT _i_ = 0; _i_ < element_count; ++_i_)    \
+		{                                                  \
+			array[_i_] = constant;                         \
+		}                                                  \
+	}
+
+///Function prototypes to allocate and free memory.
+typedef void *gim_alloc_function(size_t size);
+typedef void *gim_alloca_function(size_t size);  //Allocs on the heap
+typedef void *gim_realloc_function(void *ptr, size_t oldsize, size_t newsize);
+typedef void gim_free_function(void *ptr);
+
+///Memory Function Handlers
+///set new memory management functions. if fn is 0, the default handlers are used.
+void gim_set_alloc_handler(gim_alloc_function *fn);
+void gim_set_alloca_handler(gim_alloca_function *fn);
+void gim_set_realloc_handler(gim_realloc_function *fn);
+void gim_set_free_handler(gim_free_function *fn);
+
+///get current memory management functions.
+gim_alloc_function *gim_get_alloc_handler(void);
+gim_alloca_function *gim_get_alloca_handler(void);
+gim_realloc_function *gim_get_realloc_handler(void);
+gim_free_function *gim_get_free_handler(void);
+
+///Standar Memory functions
+void *gim_alloc(size_t size);
+void *gim_alloca(size_t size);
+void *gim_realloc(void *ptr, size_t oldsize, size_t newsize);
+void gim_free(void *ptr);
+
+#if defined(_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
+#define GIM_SIMD_MEMORY 1
+#endif
+
+//! SIMD POINTER INTEGER
+#define SIMD_T GUINT64
+//! SIMD INTEGER SIZE
+#define SIMD_T_SIZE sizeof(SIMD_T)
+
+inline void gim_simd_memcpy(void *dst, const void *src, size_t copysize)
+{
+#ifdef GIM_SIMD_MEMORY
+	/*
+//'long long int' is incompatible with visual studio 6...
+    //copy words
+    SIMD_T * ui_src_ptr = (SIMD_T *)src;
+    SIMD_T * ui_dst_ptr = (SIMD_T *)dst;
+    while(copysize>=SIMD_T_SIZE)
+    {
+        *(ui_dst_ptr++) = *(ui_src_ptr++);
+        copysize-=SIMD_T_SIZE;
+    }
+    if(copysize==0) return;
+*/
+
+	char *c_src_ptr = (char *)src;
+	char *c_dst_ptr = (char *)dst;
+	while (copysize > 0)
+	{
+		*(c_dst_ptr++) = *(c_src_ptr++);
+		copysize--;
+	}
+	return;
+#else
+	memcpy(dst, src, copysize);
+#endif
+}
+
+template <class T>
+inline void gim_swap_elements(T *_array, size_t _i, size_t _j)
+{
+	T _e_tmp_ = _array[_i];
+	_array[_i] = _array[_j];
+	_array[_j] = _e_tmp_;
+}
+
+template <class T>
+inline void gim_swap_elements_memcpy(T *_array, size_t _i, size_t _j)
+{
+	char _e_tmp_[sizeof(T)];
+	gim_simd_memcpy(_e_tmp_, &_array[_i], sizeof(T));
+	gim_simd_memcpy(&_array[_i], &_array[_j], sizeof(T));
+	gim_simd_memcpy(&_array[_j], _e_tmp_, sizeof(T));
+}
+
+template <int SIZE>
+inline void gim_swap_elements_ptr(char *_array, size_t _i, size_t _j)
+{
+	char _e_tmp_[SIZE];
+	_i *= SIZE;
+	_j *= SIZE;
+	gim_simd_memcpy(_e_tmp_, _array + _i, SIZE);
+	gim_simd_memcpy(_array + _i, _array + _j, SIZE);
+	gim_simd_memcpy(_array + _j, _e_tmp_, SIZE);
+}
+
+#endif  // GIM_MEMORY_H_INCLUDED
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/gim_pair.h b/engine/inc/bullet/BulletCollision/Gimpact/gim_pair.h
new file mode 100644
index 00000000..56c185a5
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/gim_pair.h
@@ -0,0 +1,28 @@
+#ifndef GIM_PAIR_H
+#define GIM_PAIR_H
+
+
+//! Overlapping pair
+struct GIM_PAIR
+{
+        int m_index1;
+        int m_index2;
+        GIM_PAIR()
+        {
+        }
+
+        GIM_PAIR(const GIM_PAIR& p)
+        {
+                m_index1 = p.m_index1;
+                m_index2 = p.m_index2;
+        }
+
+        GIM_PAIR(int index1, int index2)
+        {
+                m_index1 = index1;
+                m_index2 = index2;
+        }
+};
+
+#endif //GIM_PAIR_H
+
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/gim_radixsort.h b/engine/inc/bullet/BulletCollision/Gimpact/gim_radixsort.h
new file mode 100644
index 00000000..ff7907ad
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/gim_radixsort.h
@@ -0,0 +1,386 @@
+#ifndef GIM_RADIXSORT_H_INCLUDED
+#define GIM_RADIXSORT_H_INCLUDED
+/*! \file gim_radixsort.h
+\author Francisco Leon Najera.
+Based on the work of Michael Herf : "fast floating-point radix sort"
+Avaliable on http://www.stereopsis.com/radix.html
+*/
+/*
+-----------------------------------------------------------------------------
+This source file is part of GIMPACT Library.
+
+For the latest info, see http://gimpact.sourceforge.net/
+
+Copyright (c) 2006 Francisco Leon Najera. C.C. 80087371.
+email: projectileman@yahoo.com
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of EITHER:
+   (1) The GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 2.1 of the License, or (at
+       your option) any later version. The text of the GNU Lesser
+       General Public License is included with this library in the
+       file GIMPACT-LICENSE-LGPL.TXT.
+   (2) The BSD-style license that is included with this library in
+       the file GIMPACT-LICENSE-BSD.TXT.
+   (3) The zlib/libpng license that is included with this library in
+       the file GIMPACT-LICENSE-ZLIB.TXT.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files
+ GIMPACT-LICENSE-LGPL.TXT, GIMPACT-LICENSE-ZLIB.TXT and GIMPACT-LICENSE-BSD.TXT for more details.
+
+-----------------------------------------------------------------------------
+*/
+
+#include "gim_memory.h"
+
+///Macros for sorting.
+//! Prototype for comparators
+class less_comparator
+{
+public:
+	template <class T, class Z>
+	inline int operator()(const T& a, const Z& b)
+	{
+		return (a < b ? -1 : (a > b ? 1 : 0));
+	}
+};
+
+//! Prototype for comparators
+class integer_comparator
+{
+public:
+	template <class T>
+	inline int operator()(const T& a, const T& b)
+	{
+		return (int)(a - b);
+	}
+};
+
+//!Prototype for getting the integer representation of an object
+class uint_key_func
+{
+public:
+	template <class T>
+	inline GUINT operator()(const T& a)
+	{
+		return (GUINT)a;
+	}
+};
+
+//!Prototype for copying elements
+class copy_elements_func
+{
+public:
+	template <class T>
+	inline void operator()(T& a, T& b)
+	{
+		a = b;
+	}
+};
+
+//!Prototype for copying elements
+class memcopy_elements_func
+{
+public:
+	template <class T>
+	inline void operator()(T& a, T& b)
+	{
+		gim_simd_memcpy(&a, &b, sizeof(T));
+	}
+};
+
+//! @{
+struct GIM_RSORT_TOKEN
+{
+	GUINT m_key;
+	GUINT m_value;
+	GIM_RSORT_TOKEN()
+	{
+	}
+	GIM_RSORT_TOKEN(const GIM_RSORT_TOKEN& rtoken)
+	{
+		m_key = rtoken.m_key;
+		m_value = rtoken.m_value;
+	}
+
+	inline bool operator<(const GIM_RSORT_TOKEN& other) const
+	{
+		return (m_key < other.m_key);
+	}
+
+	inline bool operator>(const GIM_RSORT_TOKEN& other) const
+	{
+		return (m_key > other.m_key);
+	}
+};
+
+//! Prototype for comparators
+class GIM_RSORT_TOKEN_COMPARATOR
+{
+public:
+	inline int operator()(const GIM_RSORT_TOKEN& a, const GIM_RSORT_TOKEN& b)
+	{
+		return (int)((a.m_key) - (b.m_key));
+	}
+};
+
+#define kHist 2048
+// ---- utils for accessing 11-bit quantities
+#define D11_0(x) (x & 0x7FF)
+#define D11_1(x) (x >> 11 & 0x7FF)
+#define D11_2(x) (x >> 22)
+
+///Radix sort for unsigned integer keys
+inline void gim_radix_sort_rtokens(
+	GIM_RSORT_TOKEN* array,
+	GIM_RSORT_TOKEN* sorted, GUINT element_count)
+{
+	GUINT i;
+	GUINT b0[kHist * 3];
+	GUINT* b1 = b0 + kHist;
+	GUINT* b2 = b1 + kHist;
+	for (i = 0; i < kHist * 3; ++i)
+	{
+		b0[i] = 0;
+	}
+	GUINT fi;
+	GUINT pos;
+	for (i = 0; i < element_count; ++i)
+	{
+		fi = array[i].m_key;
+		b0[D11_0(fi)]++;
+		b1[D11_1(fi)]++;
+		b2[D11_2(fi)]++;
+	}
+	{
+		GUINT sum0 = 0, sum1 = 0, sum2 = 0;
+		GUINT tsum;
+		for (i = 0; i < kHist; ++i)
+		{
+			tsum = b0[i] + sum0;
+			b0[i] = sum0 - 1;
+			sum0 = tsum;
+			tsum = b1[i] + sum1;
+			b1[i] = sum1 - 1;
+			sum1 = tsum;
+			tsum = b2[i] + sum2;
+			b2[i] = sum2 - 1;
+			sum2 = tsum;
+		}
+	}
+	for (i = 0; i < element_count; ++i)
+	{
+		fi = array[i].m_key;
+		pos = D11_0(fi);
+		pos = ++b0[pos];
+		sorted[pos].m_key = array[i].m_key;
+		sorted[pos].m_value = array[i].m_value;
+	}
+	for (i = 0; i < element_count; ++i)
+	{
+		fi = sorted[i].m_key;
+		pos = D11_1(fi);
+		pos = ++b1[pos];
+		array[pos].m_key = sorted[i].m_key;
+		array[pos].m_value = sorted[i].m_value;
+	}
+	for (i = 0; i < element_count; ++i)
+	{
+		fi = array[i].m_key;
+		pos = D11_2(fi);
+		pos = ++b2[pos];
+		sorted[pos].m_key = array[i].m_key;
+		sorted[pos].m_value = array[i].m_value;
+	}
+}
+
+/// Get the sorted tokens from an array. For generic use. Tokens are IRR_RSORT_TOKEN
+/*!
+*\param array Array of elements to sort
+*\param sorted_tokens Tokens of sorted elements
+*\param element_count element count
+*\param uintkey_macro Functor which retrieves the integer representation of an array element
+*/
+template <typename T, class GETKEY_CLASS>
+void gim_radix_sort_array_tokens(
+	T* array,
+	GIM_RSORT_TOKEN* sorted_tokens,
+	GUINT element_count, GETKEY_CLASS uintkey_macro)
+{
+	GIM_RSORT_TOKEN* _unsorted = (GIM_RSORT_TOKEN*)gim_alloc(sizeof(GIM_RSORT_TOKEN) * element_count);
+	for (GUINT _i = 0; _i < element_count; ++_i)
+	{
+		_unsorted[_i].m_key = uintkey_macro(array[_i]);
+		_unsorted[_i].m_value = _i;
+	}
+	gim_radix_sort_rtokens(_unsorted, sorted_tokens, element_count);
+	gim_free(_unsorted);
+	gim_free(_unsorted);
+}
+
+/// Sorts array in place. For generic use
+/*!
+\param type Type of the array
+\param array
+\param element_count
+\param get_uintkey_macro Macro for extract the Integer value of the element. Similar to SIMPLE_GET_UINTKEY
+\param copy_elements_macro Macro for copy elements, similar to SIMPLE_COPY_ELEMENTS
+*/
+template <typename T, class GETKEY_CLASS, class COPY_CLASS>
+void gim_radix_sort(
+	T* array, GUINT element_count,
+	GETKEY_CLASS get_uintkey_macro, COPY_CLASS copy_elements_macro)
+{
+	GIM_RSORT_TOKEN* _sorted = (GIM_RSORT_TOKEN*)gim_alloc(sizeof(GIM_RSORT_TOKEN) * element_count);
+	gim_radix_sort_array_tokens(array, _sorted, element_count, get_uintkey_macro);
+	T* _original_array = (T*)gim_alloc(sizeof(T) * element_count);
+	gim_simd_memcpy(_original_array, array, sizeof(T) * element_count);
+	for (GUINT _i = 0; _i < element_count; ++_i)
+	{
+		copy_elements_macro(array[_i], _original_array[_sorted[_i].m_value]);
+	}
+	gim_free(_original_array);
+	gim_free(_sorted);
+}
+
+//! Failsafe Iterative binary search,
+/*!
+If the element is not found, it returns the nearest upper element position, may be the further position after the last element.
+\param _array
+\param _start_i the beginning of the array
+\param _end_i the ending  index of the array
+\param _search_key Value to find
+\param _comp_macro macro for comparing elements
+\param _found If true the value has found. Boolean
+\param _result_index the index of the found element, or if not found then it will get the index of the  closest bigger value
+*/
+template <class T, typename KEYCLASS, typename COMP_CLASS>
+bool gim_binary_search_ex(
+	const T* _array, GUINT _start_i,
+	GUINT _end_i, GUINT& _result_index,
+	const KEYCLASS& _search_key,
+	COMP_CLASS _comp_macro)
+{
+	GUINT _k;
+	int _comp_result;
+	GUINT _i = _start_i;
+	GUINT _j = _end_i + 1;
+	while (_i < _j)
+	{
+		_k = (_j + _i - 1) / 2;
+		_comp_result = _comp_macro(_array[_k], _search_key);
+		if (_comp_result == 0)
+		{
+			_result_index = _k;
+			return true;
+		}
+		else if (_comp_result < 0)
+		{
+			_i = _k + 1;
+		}
+		else
+		{
+			_j = _k;
+		}
+	}
+	_result_index = _i;
+	return false;
+}
+
+//! Failsafe Iterative binary search,Template version
+/*!
+If the element is not found, it returns the nearest upper element position, may be the further position after the last element.
+\param _array
+\param _start_i the beginning of the array
+\param _end_i the ending  index of the array
+\param _search_key Value to find
+\param _result_index the index of the found element, or if not found then it will get the index of the  closest bigger value
+\return true if found, else false
+*/
+template <class T>
+bool gim_binary_search(
+	const T* _array, GUINT _start_i,
+	GUINT _end_i, const T& _search_key,
+	GUINT& _result_index)
+{
+	GUINT _i = _start_i;
+	GUINT _j = _end_i + 1;
+	GUINT _k;
+	while (_i < _j)
+	{
+		_k = (_j + _i - 1) / 2;
+		if (_array[_k] == _search_key)
+		{
+			_result_index = _k;
+			return true;
+		}
+		else if (_array[_k] < _search_key)
+		{
+			_i = _k + 1;
+		}
+		else
+		{
+			_j = _k;
+		}
+	}
+	_result_index = _i;
+	return false;
+}
+
+///heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/
+template <typename T, typename COMP_CLASS>
+void gim_down_heap(T* pArr, GUINT k, GUINT n, COMP_CLASS CompareFunc)
+{
+	/*  PRE: a[k+1..N] is a heap */
+	/* POST:  a[k..N]  is a heap */
+
+	T temp = pArr[k - 1];
+	/* k has child(s) */
+	while (k <= n / 2)
+	{
+		int child = 2 * k;
+
+		if ((child < (int)n) && CompareFunc(pArr[child - 1], pArr[child]) < 0)
+		{
+			child++;
+		}
+		/* pick larger child */
+		if (CompareFunc(temp, pArr[child - 1]) < 0)
+		{
+			/* move child up */
+			pArr[k - 1] = pArr[child - 1];
+			k = child;
+		}
+		else
+		{
+			break;
+		}
+	}
+	pArr[k - 1] = temp;
+} /*downHeap*/
+
+template <typename T, typename COMP_CLASS>
+void gim_heap_sort(T* pArr, GUINT element_count, COMP_CLASS CompareFunc)
+{
+	/* sort a[0..N-1],  N.B. 0 to N-1 */
+	GUINT k;
+	GUINT n = element_count;
+	for (k = n / 2; k > 0; k--)
+	{
+		gim_down_heap(pArr, k, n, CompareFunc);
+	}
+
+	/* a[1..N] is now a heap */
+	while (n >= 2)
+	{
+		gim_swap_elements(pArr, 0, n - 1); /* largest of a[0..n-1] */
+		--n;
+		/* restore a[1..i-1] heap */
+		gim_down_heap(pArr, 1, n, CompareFunc);
+	}
+}
+
+#endif  // GIM_RADIXSORT_H_INCLUDED
diff --git a/engine/inc/bullet/BulletCollision/Gimpact/gim_tri_collision.h b/engine/inc/bullet/BulletCollision/Gimpact/gim_tri_collision.h
new file mode 100644
index 00000000..e6d4bf54
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/Gimpact/gim_tri_collision.h
@@ -0,0 +1,368 @@
+#ifndef GIM_TRI_COLLISION_H_INCLUDED
+#define GIM_TRI_COLLISION_H_INCLUDED
+
+/*! \file gim_tri_collision.h
+\author Francisco Leon Najera
+*/
+/*
+-----------------------------------------------------------------------------
+This source file is part of GIMPACT Library.
+
+For the latest info, see http://gimpact.sourceforge.net/
+
+Copyright (c) 2006 Francisco Leon Najera. C.C. 80087371.
+email: projectileman@yahoo.com
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of EITHER:
+   (1) The GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 2.1 of the License, or (at
+       your option) any later version. The text of the GNU Lesser
+       General Public License is included with this library in the
+       file GIMPACT-LICENSE-LGPL.TXT.
+   (2) The BSD-style license that is included with this library in
+       the file GIMPACT-LICENSE-BSD.TXT.
+   (3) The zlib/libpng license that is included with this library in
+       the file GIMPACT-LICENSE-ZLIB.TXT.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files
+ GIMPACT-LICENSE-LGPL.TXT, GIMPACT-LICENSE-ZLIB.TXT and GIMPACT-LICENSE-BSD.TXT for more details.
+
+-----------------------------------------------------------------------------
+*/
+
+#include "gim_box_collision.h"
+#include "gim_clip_polygon.h"
+
+#ifndef MAX_TRI_CLIPPING
+#define MAX_TRI_CLIPPING 16
+#endif
+
+//! Structure for collision
+struct GIM_TRIANGLE_CONTACT_DATA
+{
+	GREAL m_penetration_depth;
+	GUINT m_point_count;
+	btVector4 m_separating_normal;
+	btVector3 m_points[MAX_TRI_CLIPPING];
+
+	SIMD_FORCE_INLINE void copy_from(const GIM_TRIANGLE_CONTACT_DATA &other)
+	{
+		m_penetration_depth = other.m_penetration_depth;
+		m_separating_normal = other.m_separating_normal;
+		m_point_count = other.m_point_count;
+		GUINT i = m_point_count;
+		while (i--)
+		{
+			m_points[i] = other.m_points[i];
+		}
+	}
+
+	GIM_TRIANGLE_CONTACT_DATA()
+	{
+	}
+
+	GIM_TRIANGLE_CONTACT_DATA(const GIM_TRIANGLE_CONTACT_DATA &other)
+	{
+		copy_from(other);
+	}
+
+	//! classify points that are closer
+	template <typename DISTANCE_FUNC, typename CLASS_PLANE>
+	SIMD_FORCE_INLINE void mergepoints_generic(const CLASS_PLANE &plane,
+											   GREAL margin, const btVector3 *points, GUINT point_count, DISTANCE_FUNC distance_func)
+	{
+		m_point_count = 0;
+		m_penetration_depth = -1000.0f;
+
+		GUINT point_indices[MAX_TRI_CLIPPING];
+
+		GUINT _k;
+
+		for (_k = 0; _k < point_count; _k++)
+		{
+			GREAL _dist = -distance_func(plane, points[_k]) + margin;
+
+			if (_dist >= 0.0f)
+			{
+				if (_dist > m_penetration_depth)
+				{
+					m_penetration_depth = _dist;
+					point_indices[0] = _k;
+					m_point_count = 1;
+				}
+				else if ((_dist + G_EPSILON) >= m_penetration_depth)
+				{
+					point_indices[m_point_count] = _k;
+					m_point_count++;
+				}
+			}
+		}
+
+		for (_k = 0; _k < m_point_count; _k++)
+		{
+			m_points[_k] = points[point_indices[_k]];
+		}
+	}
+
+	//! classify points that are closer
+	SIMD_FORCE_INLINE void merge_points(const btVector4 &plane, GREAL margin,
+										const btVector3 *points, GUINT point_count)
+	{
+		m_separating_normal = plane;
+		mergepoints_generic(plane, margin, points, point_count, DISTANCE_PLANE_3D_FUNC());
+	}
+};
+
+//! Class for colliding triangles
+class GIM_TRIANGLE
+{
+public:
+	btScalar m_margin;
+	btVector3 m_vertices[3];
+
+	GIM_TRIANGLE() : m_margin(0.1f)
+	{
+	}
+
+	SIMD_FORCE_INLINE GIM_AABB get_box() const
+	{
+		return GIM_AABB(m_vertices[0], m_vertices[1], m_vertices[2], m_margin);
+	}
+
+	SIMD_FORCE_INLINE void get_normal(btVector3 &normal) const
+	{
+		TRIANGLE_NORMAL(m_vertices[0], m_vertices[1], m_vertices[2], normal);
+	}
+
+	SIMD_FORCE_INLINE void get_plane(btVector4 &plane) const
+	{
+		TRIANGLE_PLANE(m_vertices[0], m_vertices[1], m_vertices[2], plane);
+		;
+	}
+
+	SIMD_FORCE_INLINE void apply_transform(const btTransform &trans)
+	{
+		m_vertices[0] = trans(m_vertices[0]);
+		m_vertices[1] = trans(m_vertices[1]);
+		m_vertices[2] = trans(m_vertices[2]);
+	}
+
+	SIMD_FORCE_INLINE void get_edge_plane(GUINT edge_index, const btVector3 &triangle_normal, btVector4 &plane) const
+	{
+		const btVector3 &e0 = m_vertices[edge_index];
+		const btVector3 &e1 = m_vertices[(edge_index + 1) % 3];
+		EDGE_PLANE(e0, e1, triangle_normal, plane);
+	}
+
+	//! Gets the relative transformation of this triangle
+	/*!
+    The transformation is oriented to the triangle normal , and aligned to the 1st edge of this triangle. The position corresponds to vertice 0:
+    - triangle normal corresponds to Z axis.
+    - 1st normalized edge corresponds to X axis,
+
+    */
+	SIMD_FORCE_INLINE void get_triangle_transform(btTransform &triangle_transform) const
+	{
+		btMatrix3x3 &matrix = triangle_transform.getBasis();
+
+		btVector3 zaxis;
+		get_normal(zaxis);
+		MAT_SET_Z(matrix, zaxis);
+
+		btVector3 xaxis = m_vertices[1] - m_vertices[0];
+		VEC_NORMALIZE(xaxis);
+		MAT_SET_X(matrix, xaxis);
+
+		//y axis
+		xaxis = zaxis.cross(xaxis);
+		MAT_SET_Y(matrix, xaxis);
+
+		triangle_transform.setOrigin(m_vertices[0]);
+	}
+
+	//! Test triangles by finding separating axis
+	/*!
+	\param other Triangle for collide
+	\param contact_data Structure for holding contact points, normal and penetration depth; The normal is pointing toward this triangle from the other triangle
+	*/
+	bool collide_triangle_hard_test(
+		const GIM_TRIANGLE &other,
+		GIM_TRIANGLE_CONTACT_DATA &contact_data) const;
+
+	//! Test boxes before doing hard test
+	/*!
+	\param other Triangle for collide
+	\param contact_data Structure for holding contact points, normal and penetration depth; The normal is pointing toward this triangle from the other triangle
+	\
+	*/
+	SIMD_FORCE_INLINE bool collide_triangle(
+		const GIM_TRIANGLE &other,
+		GIM_TRIANGLE_CONTACT_DATA &contact_data) const
+	{
+		//test box collisioin
+		GIM_AABB boxu(m_vertices[0], m_vertices[1], m_vertices[2], m_margin);
+		GIM_AABB boxv(other.m_vertices[0], other.m_vertices[1], other.m_vertices[2], other.m_margin);
+		if (!boxu.has_collision(boxv)) return false;
+
+		//do hard test
+		return collide_triangle_hard_test(other, contact_data);
+	}
+
+	/*!
+
+	Solve the System for u,v parameters:
+
+	u*axe1[i1] + v*axe2[i1] = vecproj[i1]
+	u*axe1[i2] + v*axe2[i2] = vecproj[i2]
+
+	sustitute:
+	v = (vecproj[i2] - u*axe1[i2])/axe2[i2]
+
+	then the first equation in terms of 'u':
+
+	--> u*axe1[i1] + ((vecproj[i2] - u*axe1[i2])/axe2[i2])*axe2[i1] = vecproj[i1]
+
+	--> u*axe1[i1] + vecproj[i2]*axe2[i1]/axe2[i2] - u*axe1[i2]*axe2[i1]/axe2[i2] = vecproj[i1]
+
+	--> u*(axe1[i1]  - axe1[i2]*axe2[i1]/axe2[i2]) = vecproj[i1] - vecproj[i2]*axe2[i1]/axe2[i2]
+
+	--> u*((axe1[i1]*axe2[i2]  - axe1[i2]*axe2[i1])/axe2[i2]) = (vecproj[i1]*axe2[i2] - vecproj[i2]*axe2[i1])/axe2[i2]
+
+	--> u*(axe1[i1]*axe2[i2]  - axe1[i2]*axe2[i1]) = vecproj[i1]*axe2[i2] - vecproj[i2]*axe2[i1]
+
+	--> u = (vecproj[i1]*axe2[i2] - vecproj[i2]*axe2[i1]) /(axe1[i1]*axe2[i2]  - axe1[i2]*axe2[i1])
+
+if 0.0<= u+v <=1.0 then they are inside of triangle
+
+	\return false if the point is outside of triangle.This function  doesn't take the margin
+	*/
+	SIMD_FORCE_INLINE bool get_uv_parameters(
+		const btVector3 &point,
+		const btVector3 &tri_plane,
+		GREAL &u, GREAL &v) const
+	{
+		btVector3 _axe1 = m_vertices[1] - m_vertices[0];
+		btVector3 _axe2 = m_vertices[2] - m_vertices[0];
+		btVector3 _vecproj = point - m_vertices[0];
+		GUINT _i1 = (tri_plane.closestAxis() + 1) % 3;
+		GUINT _i2 = (_i1 + 1) % 3;
+		if (btFabs(_axe2[_i2]) < G_EPSILON)
+		{
+			u = (_vecproj[_i2] * _axe2[_i1] - _vecproj[_i1] * _axe2[_i2]) / (_axe1[_i2] * _axe2[_i1] - _axe1[_i1] * _axe2[_i2]);
+			v = (_vecproj[_i1] - u * _axe1[_i1]) / _axe2[_i1];
+		}
+		else
+		{
+			u = (_vecproj[_i1] * _axe2[_i2] - _vecproj[_i2] * _axe2[_i1]) / (_axe1[_i1] * _axe2[_i2] - _axe1[_i2] * _axe2[_i1]);
+			v = (_vecproj[_i2] - u * _axe1[_i2]) / _axe2[_i2];
+		}
+
+		if (u < -G_EPSILON)
+		{
+			return false;
+		}
+		else if (v < -G_EPSILON)
+		{
+			return false;
+		}
+		else
+		{
+			btScalar sumuv;
+			sumuv = u + v;
+			if (sumuv < -G_EPSILON)
+			{
+				return false;
+			}
+			else if (sumuv - 1.0f > G_EPSILON)
+			{
+				return false;
+			}
+		}
+		return true;
+	}
+
+	//! is point in triangle beam?
+	/*!
+	Test if point is in triangle, with m_margin tolerance
+	*/
+	SIMD_FORCE_INLINE bool is_point_inside(const btVector3 &point, const btVector3 &tri_normal) const
+	{
+		//Test with edge 0
+		btVector4 edge_plane;
+		this->get_edge_plane(0, tri_normal, edge_plane);
+		GREAL dist = DISTANCE_PLANE_POINT(edge_plane, point);
+		if (dist - m_margin > 0.0f) return false;  // outside plane
+
+		this->get_edge_plane(1, tri_normal, edge_plane);
+		dist = DISTANCE_PLANE_POINT(edge_plane, point);
+		if (dist - m_margin > 0.0f) return false;  // outside plane
+
+		this->get_edge_plane(2, tri_normal, edge_plane);
+		dist = DISTANCE_PLANE_POINT(edge_plane, point);
+		if (dist - m_margin > 0.0f) return false;  // outside plane
+		return true;
+	}
+
+	//! Bidireccional ray collision
+	SIMD_FORCE_INLINE bool ray_collision(
+		const btVector3 &vPoint,
+		const btVector3 &vDir, btVector3 &pout, btVector3 &triangle_normal,
+		GREAL &tparam, GREAL tmax = G_REAL_INFINITY)
+	{
+		btVector4 faceplane;
+		{
+			btVector3 dif1 = m_vertices[1] - m_vertices[0];
+			btVector3 dif2 = m_vertices[2] - m_vertices[0];
+			VEC_CROSS(faceplane, dif1, dif2);
+			faceplane[3] = m_vertices[0].dot(faceplane);
+		}
+
+		GUINT res = LINE_PLANE_COLLISION(faceplane, vDir, vPoint, pout, tparam, btScalar(0), tmax);
+		if (res == 0) return false;
+		if (!is_point_inside(pout, faceplane)) return false;
+
+		if (res == 2)  //invert normal
+		{
+			triangle_normal.setValue(-faceplane[0], -faceplane[1], -faceplane[2]);
+		}
+		else
+		{
+			triangle_normal.setValue(faceplane[0], faceplane[1], faceplane[2]);
+		}
+
+		VEC_NORMALIZE(triangle_normal);
+
+		return true;
+	}
+
+	//! one direccion ray collision
+	SIMD_FORCE_INLINE bool ray_collision_front_side(
+		const btVector3 &vPoint,
+		const btVector3 &vDir, btVector3 &pout, btVector3 &triangle_normal,
+		GREAL &tparam, GREAL tmax = G_REAL_INFINITY)
+	{
+		btVector4 faceplane;
+		{
+			btVector3 dif1 = m_vertices[1] - m_vertices[0];
+			btVector3 dif2 = m_vertices[2] - m_vertices[0];
+			VEC_CROSS(faceplane, dif1, dif2);
+			faceplane[3] = m_vertices[0].dot(faceplane);
+		}
+
+		GUINT res = LINE_PLANE_COLLISION(faceplane, vDir, vPoint, pout, tparam, btScalar(0), tmax);
+		if (res != 1) return false;
+
+		if (!is_point_inside(pout, faceplane)) return false;
+
+		triangle_normal.setValue(faceplane[0], faceplane[1], faceplane[2]);
+
+		VEC_NORMALIZE(triangle_normal);
+
+		return true;
+	}
+};
+
+#endif  // GIM_TRI_COLLISION_H_INCLUDED
diff --git a/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btComputeGjkEpaPenetration.h b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btComputeGjkEpaPenetration.h
new file mode 100644
index 00000000..3c821330
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btComputeGjkEpaPenetration.h
@@ -0,0 +1,354 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2014 Erwin Coumans http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_GJK_EPA_PENETATION_CONVEX_COLLISION_H
+#define BT_GJK_EPA_PENETATION_CONVEX_COLLISION_H
+
+#include "LinearMath/btTransform.h"  // Note that btVector3 might be double precision...
+#include "btGjkEpa3.h"
+#include "btGjkCollisionDescription.h"
+#include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h"
+
+template <typename btConvexTemplate>
+bool btGjkEpaCalcPenDepth(const btConvexTemplate& a, const btConvexTemplate& b,
+						  const btGjkCollisionDescription& colDesc,
+						  btVector3& v, btVector3& wWitnessOnA, btVector3& wWitnessOnB)
+{
+	(void)v;
+
+	//	const btScalar				radialmargin(btScalar(0.));
+
+	btVector3 guessVector(b.getWorldTransform().getOrigin() - a.getWorldTransform().getOrigin());  //?? why not use the GJK input?
+
+	btGjkEpaSolver3::sResults results;
+
+	if (btGjkEpaSolver3_Penetration(a, b, guessVector, results))
+
+	{
+		//	debugDraw->drawLine(results.witnesses[1],results.witnesses[1]+results.normal,btVector3(255,0,0));
+		//resultOut->addContactPoint(results.normal,results.witnesses[1],-results.depth);
+		wWitnessOnA = results.witnesses[0];
+		wWitnessOnB = results.witnesses[1];
+		v = results.normal;
+		return true;
+	}
+	else
+	{
+		if (btGjkEpaSolver3_Distance(a, b, guessVector, results))
+		{
+			wWitnessOnA = results.witnesses[0];
+			wWitnessOnB = results.witnesses[1];
+			v = results.normal;
+			return false;
+		}
+	}
+	return false;
+}
+
+template <typename btConvexTemplate, typename btGjkDistanceTemplate>
+int btComputeGjkEpaPenetration(const btConvexTemplate& a, const btConvexTemplate& b, const btGjkCollisionDescription& colDesc, btVoronoiSimplexSolver& simplexSolver, btGjkDistanceTemplate* distInfo)
+{
+	bool m_catchDegeneracies = true;
+	btScalar m_cachedSeparatingDistance = 0.f;
+
+	btScalar distance = btScalar(0.);
+	btVector3 normalInB(btScalar(0.), btScalar(0.), btScalar(0.));
+
+	btVector3 pointOnA, pointOnB;
+	btTransform localTransA = a.getWorldTransform();
+	btTransform localTransB = b.getWorldTransform();
+
+	btScalar marginA = a.getMargin();
+	btScalar marginB = b.getMargin();
+
+	int m_curIter = 0;
+	int gGjkMaxIter = colDesc.m_maxGjkIterations;  //this is to catch invalid input, perhaps check for #NaN?
+	btVector3 m_cachedSeparatingAxis = colDesc.m_firstDir;
+
+	bool isValid = false;
+	bool checkSimplex = false;
+	bool checkPenetration = true;
+	int m_degenerateSimplex = 0;
+
+	int m_lastUsedMethod = -1;
+
+	{
+		btScalar squaredDistance = BT_LARGE_FLOAT;
+		btScalar delta = btScalar(0.);
+
+		btScalar margin = marginA + marginB;
+
+		simplexSolver.reset();
+
+		for (;;)
+		//while (true)
+		{
+			btVector3 separatingAxisInA = (-m_cachedSeparatingAxis) * localTransA.getBasis();
+			btVector3 separatingAxisInB = m_cachedSeparatingAxis * localTransB.getBasis();
+
+			btVector3 pInA = a.getLocalSupportWithoutMargin(separatingAxisInA);
+			btVector3 qInB = b.getLocalSupportWithoutMargin(separatingAxisInB);
+
+			btVector3 pWorld = localTransA(pInA);
+			btVector3 qWorld = localTransB(qInB);
+
+			btVector3 w = pWorld - qWorld;
+			delta = m_cachedSeparatingAxis.dot(w);
+
+			// potential exit, they don't overlap
+			if ((delta > btScalar(0.0)) && (delta * delta > squaredDistance * colDesc.m_maximumDistanceSquared))
+			{
+				m_degenerateSimplex = 10;
+				checkSimplex = true;
+				//checkPenetration = false;
+				break;
+			}
+
+			//exit 0: the new point is already in the simplex, or we didn't come any closer
+			if (simplexSolver.inSimplex(w))
+			{
+				m_degenerateSimplex = 1;
+				checkSimplex = true;
+				break;
+			}
+			// are we getting any closer ?
+			btScalar f0 = squaredDistance - delta;
+			btScalar f1 = squaredDistance * colDesc.m_gjkRelError2;
+
+			if (f0 <= f1)
+			{
+				if (f0 <= btScalar(0.))
+				{
+					m_degenerateSimplex = 2;
+				}
+				else
+				{
+					m_degenerateSimplex = 11;
+				}
+				checkSimplex = true;
+				break;
+			}
+
+			//add current vertex to simplex
+			simplexSolver.addVertex(w, pWorld, qWorld);
+			btVector3 newCachedSeparatingAxis;
+
+			//calculate the closest point to the origin (update vector v)
+			if (!simplexSolver.closest(newCachedSeparatingAxis))
+			{
+				m_degenerateSimplex = 3;
+				checkSimplex = true;
+				break;
+			}
+
+			if (newCachedSeparatingAxis.length2() < colDesc.m_gjkRelError2)
+			{
+				m_cachedSeparatingAxis = newCachedSeparatingAxis;
+				m_degenerateSimplex = 6;
+				checkSimplex = true;
+				break;
+			}
+
+			btScalar previousSquaredDistance = squaredDistance;
+			squaredDistance = newCachedSeparatingAxis.length2();
+#if 0
+            ///warning: this termination condition leads to some problems in 2d test case see Bullet/Demos/Box2dDemo
+            if (squaredDistance>previousSquaredDistance)
+            {
+                m_degenerateSimplex = 7;
+                squaredDistance = previousSquaredDistance;
+                checkSimplex = false;
+                break;
+            }
+#endif  //
+
+			//redundant m_simplexSolver->compute_points(pointOnA, pointOnB);
+
+			//are we getting any closer ?
+			if (previousSquaredDistance - squaredDistance <= SIMD_EPSILON * previousSquaredDistance)
+			{
+				//				m_simplexSolver->backup_closest(m_cachedSeparatingAxis);
+				checkSimplex = true;
+				m_degenerateSimplex = 12;
+
+				break;
+			}
+
+			m_cachedSeparatingAxis = newCachedSeparatingAxis;
+
+			//degeneracy, this is typically due to invalid/uninitialized worldtransforms for a btCollisionObject
+			if (m_curIter++ > gGjkMaxIter)
+			{
+#if defined(DEBUG) || defined(_DEBUG)
+
+				printf("btGjkPairDetector maxIter exceeded:%i\n", m_curIter);
+				printf("sepAxis=(%f,%f,%f), squaredDistance = %f\n",
+					   m_cachedSeparatingAxis.getX(),
+					   m_cachedSeparatingAxis.getY(),
+					   m_cachedSeparatingAxis.getZ(),
+					   squaredDistance);
+#endif
+
+				break;
+			}
+
+			bool check = (!simplexSolver.fullSimplex());
+			//bool check = (!m_simplexSolver->fullSimplex() && squaredDistance > SIMD_EPSILON * m_simplexSolver->maxVertex());
+
+			if (!check)
+			{
+				//do we need this backup_closest here ?
+				//				m_simplexSolver->backup_closest(m_cachedSeparatingAxis);
+				m_degenerateSimplex = 13;
+				break;
+			}
+		}
+
+		if (checkSimplex)
+		{
+			simplexSolver.compute_points(pointOnA, pointOnB);
+			normalInB = m_cachedSeparatingAxis;
+
+			btScalar lenSqr = m_cachedSeparatingAxis.length2();
+
+			//valid normal
+			if (lenSqr < 0.0001)
+			{
+				m_degenerateSimplex = 5;
+			}
+			if (lenSqr > SIMD_EPSILON * SIMD_EPSILON)
+			{
+				btScalar rlen = btScalar(1.) / btSqrt(lenSqr);
+				normalInB *= rlen;  //normalize
+
+				btScalar s = btSqrt(squaredDistance);
+
+				btAssert(s > btScalar(0.0));
+				pointOnA -= m_cachedSeparatingAxis * (marginA / s);
+				pointOnB += m_cachedSeparatingAxis * (marginB / s);
+				distance = ((btScalar(1.) / rlen) - margin);
+				isValid = true;
+
+				m_lastUsedMethod = 1;
+			}
+			else
+			{
+				m_lastUsedMethod = 2;
+			}
+		}
+
+		bool catchDegeneratePenetrationCase =
+			(m_catchDegeneracies && m_degenerateSimplex && ((distance + margin) < 0.01));
+
+		//if (checkPenetration && !isValid)
+		if (checkPenetration && (!isValid || catchDegeneratePenetrationCase))
+		{
+			//penetration case
+
+			//if there is no way to handle penetrations, bail out
+
+			// Penetration depth case.
+			btVector3 tmpPointOnA, tmpPointOnB;
+
+			m_cachedSeparatingAxis.setZero();
+
+			bool isValid2 = btGjkEpaCalcPenDepth(a, b,
+												 colDesc,
+												 m_cachedSeparatingAxis, tmpPointOnA, tmpPointOnB);
+
+			if (isValid2)
+			{
+				btVector3 tmpNormalInB = tmpPointOnB - tmpPointOnA;
+				btScalar lenSqr = tmpNormalInB.length2();
+				if (lenSqr <= (SIMD_EPSILON * SIMD_EPSILON))
+				{
+					tmpNormalInB = m_cachedSeparatingAxis;
+					lenSqr = m_cachedSeparatingAxis.length2();
+				}
+
+				if (lenSqr > (SIMD_EPSILON * SIMD_EPSILON))
+				{
+					tmpNormalInB /= btSqrt(lenSqr);
+					btScalar distance2 = -(tmpPointOnA - tmpPointOnB).length();
+					//only replace valid penetrations when the result is deeper (check)
+					if (!isValid || (distance2 < distance))
+					{
+						distance = distance2;
+						pointOnA = tmpPointOnA;
+						pointOnB = tmpPointOnB;
+						normalInB = tmpNormalInB;
+
+						isValid = true;
+						m_lastUsedMethod = 3;
+					}
+					else
+					{
+						m_lastUsedMethod = 8;
+					}
+				}
+				else
+				{
+					m_lastUsedMethod = 9;
+				}
+			}
+			else
+
+			{
+				///this is another degenerate case, where the initial GJK calculation reports a degenerate case
+				///EPA reports no penetration, and the second GJK (using the supporting vector without margin)
+				///reports a valid positive distance. Use the results of the second GJK instead of failing.
+				///thanks to Jacob.Langford for the reproduction case
+				///http://code.google.com/p/bullet/issues/detail?id=250
+
+				if (m_cachedSeparatingAxis.length2() > btScalar(0.))
+				{
+					btScalar distance2 = (tmpPointOnA - tmpPointOnB).length() - margin;
+					//only replace valid distances when the distance is less
+					if (!isValid || (distance2 < distance))
+					{
+						distance = distance2;
+						pointOnA = tmpPointOnA;
+						pointOnB = tmpPointOnB;
+						pointOnA -= m_cachedSeparatingAxis * marginA;
+						pointOnB += m_cachedSeparatingAxis * marginB;
+						normalInB = m_cachedSeparatingAxis;
+						normalInB.normalize();
+
+						isValid = true;
+						m_lastUsedMethod = 6;
+					}
+					else
+					{
+						m_lastUsedMethod = 5;
+					}
+				}
+			}
+		}
+	}
+
+	if (isValid && ((distance < 0) || (distance * distance < colDesc.m_maximumDistanceSquared)))
+	{
+		m_cachedSeparatingAxis = normalInB;
+		m_cachedSeparatingDistance = distance;
+		distInfo->m_distance = distance;
+		distInfo->m_normalBtoA = normalInB;
+		distInfo->m_pointOnB = pointOnB;
+		distInfo->m_pointOnA = pointOnB + normalInB * distance;
+		return 0;
+	}
+	return -m_lastUsedMethod;
+}
+
+#endif  //BT_GJK_EPA_PENETATION_CONVEX_COLLISION_H
diff --git a/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h
new file mode 100644
index 00000000..67b2205c
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h
@@ -0,0 +1,53 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_CONTINUOUS_COLLISION_CONVEX_CAST_H
+#define BT_CONTINUOUS_COLLISION_CONVEX_CAST_H
+
+#include "btConvexCast.h"
+#include "btSimplexSolverInterface.h"
+class btConvexPenetrationDepthSolver;
+class btConvexShape;
+class btStaticPlaneShape;
+
+/// btContinuousConvexCollision implements angular and linear time of impact for convex objects.
+/// Based on Brian Mirtich's Conservative Advancement idea (PhD thesis).
+/// Algorithm operates in worldspace, in order to keep in between motion globally consistent.
+/// It uses GJK at the moment. Future improvement would use minkowski sum / supporting vertex, merging innerloops
+class btContinuousConvexCollision : public btConvexCast
+{
+	btSimplexSolverInterface* m_simplexSolver;
+	btConvexPenetrationDepthSolver* m_penetrationDepthSolver;
+	const btConvexShape* m_convexA;
+	//second object is either a convex or a plane (code sharing)
+	const btConvexShape* m_convexB1;
+	const btStaticPlaneShape* m_planeShape;
+
+	void computeClosestPoints(const btTransform& transA, const btTransform& transB, struct btPointCollector& pointCollector);
+
+public:
+	btContinuousConvexCollision(const btConvexShape* shapeA, const btConvexShape* shapeB, btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* penetrationDepthSolver);
+
+	btContinuousConvexCollision(const btConvexShape* shapeA, const btStaticPlaneShape* plane);
+
+	virtual bool calcTimeOfImpact(
+		const btTransform& fromA,
+		const btTransform& toA,
+		const btTransform& fromB,
+		const btTransform& toB,
+		CastResult& result);
+};
+
+#endif  //BT_CONTINUOUS_COLLISION_CONVEX_CAST_H
diff --git a/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btConvexCast.h b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btConvexCast.h
new file mode 100644
index 00000000..77b19be5
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btConvexCast.h
@@ -0,0 +1,90 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_CONVEX_CAST_H
+#define BT_CONVEX_CAST_H
+
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btScalar.h"
+class btMinkowskiSumShape;
+#include "LinearMath/btIDebugDraw.h"
+
+#ifdef BT_USE_DOUBLE_PRECISION
+#define MAX_CONVEX_CAST_ITERATIONS 64
+#define MAX_CONVEX_CAST_EPSILON (SIMD_EPSILON * 10)
+#else
+#define MAX_CONVEX_CAST_ITERATIONS 32
+#define MAX_CONVEX_CAST_EPSILON btScalar(0.0001)
+#endif
+///Typically the conservative advancement reaches solution in a few iterations, clip it to 32 for degenerate cases.
+///See discussion about this here http://continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=565
+//will need to digg deeper to make the algorithm more robust
+//since, a large epsilon can cause an early termination with false
+//positive results (ray intersections that shouldn't be there)
+
+/// btConvexCast is an interface for Casting
+class btConvexCast
+{
+public:
+	virtual ~btConvexCast();
+
+	///RayResult stores the closest result
+	/// alternatively, add a callback method to decide about closest/all results
+	struct CastResult
+	{
+		//virtual bool	addRayResult(const btVector3& normal,btScalar	fraction) = 0;
+
+		virtual void DebugDraw(btScalar fraction) { (void)fraction; }
+		virtual void drawCoordSystem(const btTransform& trans) { (void)trans; }
+		virtual void reportFailure(int errNo, int numIterations)
+		{
+			(void)errNo;
+			(void)numIterations;
+		}
+		CastResult()
+			: m_fraction(btScalar(BT_LARGE_FLOAT)),
+			  m_debugDrawer(0),
+			  m_allowedPenetration(btScalar(0)),
+			  m_subSimplexCastMaxIterations(MAX_CONVEX_CAST_ITERATIONS),
+			  m_subSimplexCastEpsilon(MAX_CONVEX_CAST_EPSILON)
+		{
+		}
+
+		virtual ~CastResult(){};
+
+		btTransform m_hitTransformA;
+		btTransform m_hitTransformB;
+		btVector3 m_normal;
+		btVector3 m_hitPoint;
+		btScalar m_fraction;  //input and output
+		btIDebugDraw* m_debugDrawer;
+		btScalar m_allowedPenetration;
+		
+		int m_subSimplexCastMaxIterations;
+		btScalar m_subSimplexCastEpsilon;
+
+	};
+
+	/// cast a convex against another convex object
+	virtual bool calcTimeOfImpact(
+		const btTransform& fromA,
+		const btTransform& toA,
+		const btTransform& fromB,
+		const btTransform& toB,
+		CastResult& result) = 0;
+};
+
+#endif  //BT_CONVEX_CAST_H
diff --git a/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h
new file mode 100644
index 00000000..65c9df93
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h
@@ -0,0 +1,35 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_CONVEX_PENETRATION_DEPTH_H
+#define BT_CONVEX_PENETRATION_DEPTH_H
+
+class btVector3;
+#include "btSimplexSolverInterface.h"
+class btConvexShape;
+class btTransform;
+
+///ConvexPenetrationDepthSolver provides an interface for penetration depth calculation.
+class btConvexPenetrationDepthSolver
+{
+public:
+	virtual ~btConvexPenetrationDepthSolver(){};
+	virtual bool calcPenDepth(btSimplexSolverInterface& simplexSolver,
+							  const btConvexShape* convexA, const btConvexShape* convexB,
+							  const btTransform& transA, const btTransform& transB,
+							  btVector3& v, btVector3& pa, btVector3& pb,
+							  class btIDebugDraw* debugDraw) = 0;
+};
+#endif  //BT_CONVEX_PENETRATION_DEPTH_H
diff --git a/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h
new file mode 100644
index 00000000..d1bbb1a4
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h
@@ -0,0 +1,85 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_DISCRETE_COLLISION_DETECTOR1_INTERFACE_H
+#define BT_DISCRETE_COLLISION_DETECTOR1_INTERFACE_H
+
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btVector3.h"
+
+/// This interface is made to be used by an iterative approach to do TimeOfImpact calculations
+/// This interface allows to query for closest points and penetration depth between two (convex) objects
+/// the closest point is on the second object (B), and the normal points from the surface on B towards A.
+/// distance is between closest points on B and closest point on A. So you can calculate closest point on A
+/// by taking closestPointInA = closestPointInB + m_distance * m_normalOnSurfaceB
+struct btDiscreteCollisionDetectorInterface
+{
+	struct Result
+	{
+		virtual ~Result() {}
+
+		///setShapeIdentifiersA/B provides experimental support for per-triangle material / custom material combiner
+		virtual void setShapeIdentifiersA(int partId0, int index0) = 0;
+		virtual void setShapeIdentifiersB(int partId1, int index1) = 0;
+		virtual void addContactPoint(const btVector3& normalOnBInWorld, const btVector3& pointInWorld, btScalar depth) = 0;
+	};
+
+	struct ClosestPointInput
+	{
+		ClosestPointInput()
+			: m_maximumDistanceSquared(btScalar(BT_LARGE_FLOAT))
+		{
+		}
+
+		btTransform m_transformA;
+		btTransform m_transformB;
+		btScalar m_maximumDistanceSquared;
+	};
+
+	virtual ~btDiscreteCollisionDetectorInterface(){};
+
+	//
+	// give either closest points (distance > 0) or penetration (distance)
+	// the normal always points from B towards A
+	//
+	virtual void getClosestPoints(const ClosestPointInput& input, Result& output, class btIDebugDraw* debugDraw, bool swapResults = false) = 0;
+};
+
+struct btStorageResult : public btDiscreteCollisionDetectorInterface::Result
+{
+	btVector3 m_normalOnSurfaceB;
+	btVector3 m_closestPointInB;
+	btScalar m_distance;  //negative means penetration !
+
+protected:
+	btStorageResult() : m_distance(btScalar(BT_LARGE_FLOAT))
+	{
+	}
+
+public:
+	virtual ~btStorageResult(){};
+
+	virtual void addContactPoint(const btVector3& normalOnBInWorld, const btVector3& pointInWorld, btScalar depth)
+	{
+		if (depth < m_distance)
+		{
+			m_normalOnSurfaceB = normalOnBInWorld;
+			m_closestPointInB = pointInWorld;
+			m_distance = depth;
+		}
+	}
+};
+
+#endif  //BT_DISCRETE_COLLISION_DETECTOR1_INTERFACE_H
diff --git a/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btGjkCollisionDescription.h b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btGjkCollisionDescription.h
new file mode 100644
index 00000000..c9fd84be
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btGjkCollisionDescription.h
@@ -0,0 +1,39 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2014 Erwin Coumans http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef GJK_COLLISION_DESCRIPTION_H
+#define GJK_COLLISION_DESCRIPTION_H
+
+#include "LinearMath/btVector3.h"
+
+struct btGjkCollisionDescription
+{
+	btVector3 m_firstDir;
+	int m_maxGjkIterations;
+	btScalar m_maximumDistanceSquared;
+	btScalar m_gjkRelError2;
+	btGjkCollisionDescription()
+		: m_firstDir(0, 1, 0),
+		  m_maxGjkIterations(1000),
+		  m_maximumDistanceSquared(1e30f),
+		  m_gjkRelError2(1.0e-6)
+	{
+	}
+	virtual ~btGjkCollisionDescription()
+	{
+	}
+};
+
+#endif  //GJK_COLLISION_DESCRIPTION_H
diff --git a/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h
new file mode 100644
index 00000000..ef597917
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h
@@ -0,0 +1,46 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_GJK_CONVEX_CAST_H
+#define BT_GJK_CONVEX_CAST_H
+
+#include "BulletCollision/CollisionShapes/btCollisionMargin.h"
+
+#include "LinearMath/btVector3.h"
+#include "btConvexCast.h"
+class btConvexShape;
+class btMinkowskiSumShape;
+#include "btSimplexSolverInterface.h"
+
+///GjkConvexCast performs a raycast on a convex object using support mapping.
+class btGjkConvexCast : public btConvexCast
+{
+	btSimplexSolverInterface* m_simplexSolver;
+	const btConvexShape* m_convexA;
+	const btConvexShape* m_convexB;
+
+public:
+	btGjkConvexCast(const btConvexShape* convexA, const btConvexShape* convexB, btSimplexSolverInterface* simplexSolver);
+
+	/// cast a convex against another convex object
+	virtual bool calcTimeOfImpact(
+		const btTransform& fromA,
+		const btTransform& toA,
+		const btTransform& fromB,
+		const btTransform& toB,
+		CastResult& result);
+};
+
+#endif  //BT_GJK_CONVEX_CAST_H
diff --git a/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btGjkEpa2.h b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btGjkEpa2.h
new file mode 100644
index 00000000..893daea3
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btGjkEpa2.h
@@ -0,0 +1,73 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2008 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the
+use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not
+claim that you wrote the original software. If you use this software in a
+product, an acknowledgment in the product documentation would be appreciated
+but is not required.
+2. Altered source versions must be plainly marked as such, and must not be
+misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+/*
+GJK-EPA collision solver by Nathanael Presson, 2008
+*/
+#ifndef BT_GJK_EPA2_H
+#define BT_GJK_EPA2_H
+
+#include "BulletCollision/CollisionShapes/btConvexShape.h"
+
+///btGjkEpaSolver contributed under zlib by Nathanael Presson
+struct btGjkEpaSolver2
+{
+	struct sResults
+	{
+		enum eStatus
+		{
+			Separated,   /* Shapes doesnt penetrate												*/
+			Penetrating, /* Shapes are penetrating												*/
+			GJK_Failed,  /* GJK phase fail, no big issue, shapes are probably just 'touching'	*/
+			EPA_Failed   /* EPA phase fail, bigger problem, need to save parameters, and debug	*/
+		} status;
+		btVector3 witnesses[2];
+		btVector3 normal;
+		btScalar distance;
+	};
+
+	static int StackSizeRequirement();
+
+	static bool Distance(const btConvexShape* shape0, const btTransform& wtrs0,
+						 const btConvexShape* shape1, const btTransform& wtrs1,
+						 const btVector3& guess,
+						 sResults& results);
+
+	static bool Penetration(const btConvexShape* shape0, const btTransform& wtrs0,
+							const btConvexShape* shape1, const btTransform& wtrs1,
+							const btVector3& guess,
+							sResults& results,
+							bool usemargins = true);
+#ifndef __SPU__
+	static btScalar SignedDistance(const btVector3& position,
+								   btScalar margin,
+								   const btConvexShape* shape,
+								   const btTransform& wtrs,
+								   sResults& results);
+
+	static bool SignedDistance(const btConvexShape* shape0, const btTransform& wtrs0,
+							   const btConvexShape* shape1, const btTransform& wtrs1,
+							   const btVector3& guess,
+							   sResults& results);
+#endif  //__SPU__
+};
+
+#endif  //BT_GJK_EPA2_H
diff --git a/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btGjkEpa3.h b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btGjkEpa3.h
new file mode 100644
index 00000000..6fedbbb3
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btGjkEpa3.h
@@ -0,0 +1,1063 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2014 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the
+use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not
+claim that you wrote the original software. If you use this software in a
+product, an acknowledgment in the product documentation would be appreciated
+but is not required.
+2. Altered source versions must be plainly marked as such, and must not be
+misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+/*
+Initial GJK-EPA collision solver by Nathanael Presson, 2008
+Improvements and refactoring by Erwin Coumans, 2008-2014
+*/
+#ifndef BT_GJK_EPA3_H
+#define BT_GJK_EPA3_H
+
+#include "LinearMath/btTransform.h"
+#include "btGjkCollisionDescription.h"
+
+struct btGjkEpaSolver3
+{
+	struct sResults
+	{
+		enum eStatus
+		{
+			Separated,   /* Shapes doesnt penetrate												*/
+			Penetrating, /* Shapes are penetrating												*/
+			GJK_Failed,  /* GJK phase fail, no big issue, shapes are probably just 'touching'	*/
+			EPA_Failed   /* EPA phase fail, bigger problem, need to save parameters, and debug	*/
+		} status;
+		btVector3 witnesses[2];
+		btVector3 normal;
+		btScalar distance;
+	};
+};
+
+#if defined(DEBUG) || defined(_DEBUG)
+#include <stdio.h>  //for debug printf
+#ifdef __SPU__
+#include <spu_printf.h>
+#define printf spu_printf
+#endif  //__SPU__
+#endif
+
+// Config
+
+/* GJK	*/
+#define GJK_MAX_ITERATIONS 128
+#define GJK_ACCURARY ((btScalar)0.0001)
+#define GJK_MIN_DISTANCE ((btScalar)0.0001)
+#define GJK_DUPLICATED_EPS ((btScalar)0.0001)
+#define GJK_SIMPLEX2_EPS ((btScalar)0.0)
+#define GJK_SIMPLEX3_EPS ((btScalar)0.0)
+#define GJK_SIMPLEX4_EPS ((btScalar)0.0)
+
+/* EPA	*/
+#define EPA_MAX_VERTICES 64
+#define EPA_MAX_FACES (EPA_MAX_VERTICES * 2)
+#define EPA_MAX_ITERATIONS 255
+#define EPA_ACCURACY ((btScalar)0.0001)
+#define EPA_FALLBACK (10 * EPA_ACCURACY)
+#define EPA_PLANE_EPS ((btScalar)0.00001)
+#define EPA_INSIDE_EPS ((btScalar)0.01)
+
+// Shorthands
+typedef unsigned int U;
+typedef unsigned char U1;
+
+// MinkowskiDiff
+template <typename btConvexTemplate>
+struct MinkowskiDiff
+{
+	const btConvexTemplate* m_convexAPtr;
+	const btConvexTemplate* m_convexBPtr;
+
+	btMatrix3x3 m_toshape1;
+	btTransform m_toshape0;
+
+	bool m_enableMargin;
+
+	MinkowskiDiff(const btConvexTemplate& a, const btConvexTemplate& b)
+		: m_convexAPtr(&a),
+		  m_convexBPtr(&b)
+	{
+	}
+
+	void EnableMargin(bool enable)
+	{
+		m_enableMargin = enable;
+	}
+	inline btVector3 Support0(const btVector3& d) const
+	{
+		return m_convexAPtr->getLocalSupportWithMargin(d);
+	}
+	inline btVector3 Support1(const btVector3& d) const
+	{
+		return m_toshape0 * m_convexBPtr->getLocalSupportWithMargin(m_toshape1 * d);
+	}
+
+	inline btVector3 Support(const btVector3& d) const
+	{
+		return (Support0(d) - Support1(-d));
+	}
+	btVector3 Support(const btVector3& d, U index) const
+	{
+		if (index)
+			return (Support1(d));
+		else
+			return (Support0(d));
+	}
+};
+
+enum eGjkStatus
+{
+	eGjkValid,
+	eGjkInside,
+	eGjkFailed
+};
+
+// GJK
+template <typename btConvexTemplate>
+struct GJK
+{
+	/* Types		*/
+	struct sSV
+	{
+		btVector3 d, w;
+	};
+	struct sSimplex
+	{
+		sSV* c[4];
+		btScalar p[4];
+		U rank;
+	};
+
+	/* Fields		*/
+
+	MinkowskiDiff<btConvexTemplate> m_shape;
+	btVector3 m_ray;
+	btScalar m_distance;
+	sSimplex m_simplices[2];
+	sSV m_store[4];
+	sSV* m_free[4];
+	U m_nfree;
+	U m_current;
+	sSimplex* m_simplex;
+	eGjkStatus m_status;
+	/* Methods		*/
+
+	GJK(const btConvexTemplate& a, const btConvexTemplate& b)
+		: m_shape(a, b)
+	{
+		Initialize();
+	}
+	void Initialize()
+	{
+		m_ray = btVector3(0, 0, 0);
+		m_nfree = 0;
+		m_status = eGjkFailed;
+		m_current = 0;
+		m_distance = 0;
+	}
+	eGjkStatus Evaluate(const MinkowskiDiff<btConvexTemplate>& shapearg, const btVector3& guess)
+	{
+		U iterations = 0;
+		btScalar sqdist = 0;
+		btScalar alpha = 0;
+		btVector3 lastw[4];
+		U clastw = 0;
+		/* Initialize solver		*/
+		m_free[0] = &m_store[0];
+		m_free[1] = &m_store[1];
+		m_free[2] = &m_store[2];
+		m_free[3] = &m_store[3];
+		m_nfree = 4;
+		m_current = 0;
+		m_status = eGjkValid;
+		m_shape = shapearg;
+		m_distance = 0;
+		/* Initialize simplex		*/
+		m_simplices[0].rank = 0;
+		m_ray = guess;
+		const btScalar sqrl = m_ray.length2();
+		appendvertice(m_simplices[0], sqrl > 0 ? -m_ray : btVector3(1, 0, 0));
+		m_simplices[0].p[0] = 1;
+		m_ray = m_simplices[0].c[0]->w;
+		sqdist = sqrl;
+		lastw[0] =
+			lastw[1] =
+				lastw[2] =
+					lastw[3] = m_ray;
+		/* Loop						*/
+		do
+		{
+			const U next = 1 - m_current;
+			sSimplex& cs = m_simplices[m_current];
+			sSimplex& ns = m_simplices[next];
+			/* Check zero							*/
+			const btScalar rl = m_ray.length();
+			if (rl < GJK_MIN_DISTANCE)
+			{ /* Touching or inside				*/
+				m_status = eGjkInside;
+				break;
+			}
+			/* Append new vertice in -'v' direction	*/
+			appendvertice(cs, -m_ray);
+			const btVector3& w = cs.c[cs.rank - 1]->w;
+			bool found = false;
+			for (U i = 0; i < 4; ++i)
+			{
+				if ((w - lastw[i]).length2() < GJK_DUPLICATED_EPS)
+				{
+					found = true;
+					break;
+				}
+			}
+			if (found)
+			{ /* Return old simplex				*/
+				removevertice(m_simplices[m_current]);
+				break;
+			}
+			else
+			{ /* Update lastw					*/
+				lastw[clastw = (clastw + 1) & 3] = w;
+			}
+			/* Check for termination				*/
+			const btScalar omega = btDot(m_ray, w) / rl;
+			alpha = btMax(omega, alpha);
+			if (((rl - alpha) - (GJK_ACCURARY * rl)) <= 0)
+			{ /* Return old simplex				*/
+				removevertice(m_simplices[m_current]);
+				break;
+			}
+			/* Reduce simplex						*/
+			btScalar weights[4];
+			U mask = 0;
+			switch (cs.rank)
+			{
+				case 2:
+					sqdist = projectorigin(cs.c[0]->w,
+										   cs.c[1]->w,
+										   weights, mask);
+					break;
+				case 3:
+					sqdist = projectorigin(cs.c[0]->w,
+										   cs.c[1]->w,
+										   cs.c[2]->w,
+										   weights, mask);
+					break;
+				case 4:
+					sqdist = projectorigin(cs.c[0]->w,
+										   cs.c[1]->w,
+										   cs.c[2]->w,
+										   cs.c[3]->w,
+										   weights, mask);
+					break;
+			}
+			if (sqdist >= 0)
+			{ /* Valid	*/
+				ns.rank = 0;
+				m_ray = btVector3(0, 0, 0);
+				m_current = next;
+				for (U i = 0, ni = cs.rank; i < ni; ++i)
+				{
+					if (mask & (1 << i))
+					{
+						ns.c[ns.rank] = cs.c[i];
+						ns.p[ns.rank++] = weights[i];
+						m_ray += cs.c[i]->w * weights[i];
+					}
+					else
+					{
+						m_free[m_nfree++] = cs.c[i];
+					}
+				}
+				if (mask == 15) m_status = eGjkInside;
+			}
+			else
+			{ /* Return old simplex				*/
+				removevertice(m_simplices[m_current]);
+				break;
+			}
+			m_status = ((++iterations) < GJK_MAX_ITERATIONS) ? m_status : eGjkFailed;
+		} while (m_status == eGjkValid);
+		m_simplex = &m_simplices[m_current];
+		switch (m_status)
+		{
+			case eGjkValid:
+				m_distance = m_ray.length();
+				break;
+			case eGjkInside:
+				m_distance = 0;
+				break;
+			default:
+			{
+			}
+		}
+		return (m_status);
+	}
+	bool EncloseOrigin()
+	{
+		switch (m_simplex->rank)
+		{
+			case 1:
+			{
+				for (U i = 0; i < 3; ++i)
+				{
+					btVector3 axis = btVector3(0, 0, 0);
+					axis[i] = 1;
+					appendvertice(*m_simplex, axis);
+					if (EncloseOrigin()) return (true);
+					removevertice(*m_simplex);
+					appendvertice(*m_simplex, -axis);
+					if (EncloseOrigin()) return (true);
+					removevertice(*m_simplex);
+				}
+			}
+			break;
+			case 2:
+			{
+				const btVector3 d = m_simplex->c[1]->w - m_simplex->c[0]->w;
+				for (U i = 0; i < 3; ++i)
+				{
+					btVector3 axis = btVector3(0, 0, 0);
+					axis[i] = 1;
+					const btVector3 p = btCross(d, axis);
+					if (p.length2() > 0)
+					{
+						appendvertice(*m_simplex, p);
+						if (EncloseOrigin()) return (true);
+						removevertice(*m_simplex);
+						appendvertice(*m_simplex, -p);
+						if (EncloseOrigin()) return (true);
+						removevertice(*m_simplex);
+					}
+				}
+			}
+			break;
+			case 3:
+			{
+				const btVector3 n = btCross(m_simplex->c[1]->w - m_simplex->c[0]->w,
+											m_simplex->c[2]->w - m_simplex->c[0]->w);
+				if (n.length2() > 0)
+				{
+					appendvertice(*m_simplex, n);
+					if (EncloseOrigin()) return (true);
+					removevertice(*m_simplex);
+					appendvertice(*m_simplex, -n);
+					if (EncloseOrigin()) return (true);
+					removevertice(*m_simplex);
+				}
+			}
+			break;
+			case 4:
+			{
+				if (btFabs(det(m_simplex->c[0]->w - m_simplex->c[3]->w,
+							   m_simplex->c[1]->w - m_simplex->c[3]->w,
+							   m_simplex->c[2]->w - m_simplex->c[3]->w)) > 0)
+					return (true);
+			}
+			break;
+		}
+		return (false);
+	}
+	/* Internals	*/
+	void getsupport(const btVector3& d, sSV& sv) const
+	{
+		sv.d = d / d.length();
+		sv.w = m_shape.Support(sv.d);
+	}
+	void removevertice(sSimplex& simplex)
+	{
+		m_free[m_nfree++] = simplex.c[--simplex.rank];
+	}
+	void appendvertice(sSimplex& simplex, const btVector3& v)
+	{
+		simplex.p[simplex.rank] = 0;
+		simplex.c[simplex.rank] = m_free[--m_nfree];
+		getsupport(v, *simplex.c[simplex.rank++]);
+	}
+	static btScalar det(const btVector3& a, const btVector3& b, const btVector3& c)
+	{
+		return (a.y() * b.z() * c.x() + a.z() * b.x() * c.y() -
+				a.x() * b.z() * c.y() - a.y() * b.x() * c.z() +
+				a.x() * b.y() * c.z() - a.z() * b.y() * c.x());
+	}
+	static btScalar projectorigin(const btVector3& a,
+								  const btVector3& b,
+								  btScalar* w, U& m)
+	{
+		const btVector3 d = b - a;
+		const btScalar l = d.length2();
+		if (l > GJK_SIMPLEX2_EPS)
+		{
+			const btScalar t(l > 0 ? -btDot(a, d) / l : 0);
+			if (t >= 1)
+			{
+				w[0] = 0;
+				w[1] = 1;
+				m = 2;
+				return (b.length2());
+			}
+			else if (t <= 0)
+			{
+				w[0] = 1;
+				w[1] = 0;
+				m = 1;
+				return (a.length2());
+			}
+			else
+			{
+				w[0] = 1 - (w[1] = t);
+				m = 3;
+				return ((a + d * t).length2());
+			}
+		}
+		return (-1);
+	}
+	static btScalar projectorigin(const btVector3& a,
+								  const btVector3& b,
+								  const btVector3& c,
+								  btScalar* w, U& m)
+	{
+		static const U imd3[] = {1, 2, 0};
+		const btVector3* vt[] = {&a, &b, &c};
+		const btVector3 dl[] = {a - b, b - c, c - a};
+		const btVector3 n = btCross(dl[0], dl[1]);
+		const btScalar l = n.length2();
+		if (l > GJK_SIMPLEX3_EPS)
+		{
+			btScalar mindist = -1;
+			btScalar subw[2] = {0.f, 0.f};
+			U subm(0);
+			for (U i = 0; i < 3; ++i)
+			{
+				if (btDot(*vt[i], btCross(dl[i], n)) > 0)
+				{
+					const U j = imd3[i];
+					const btScalar subd(projectorigin(*vt[i], *vt[j], subw, subm));
+					if ((mindist < 0) || (subd < mindist))
+					{
+						mindist = subd;
+						m = static_cast<U>(((subm & 1) ? 1 << i : 0) + ((subm & 2) ? 1 << j : 0));
+						w[i] = subw[0];
+						w[j] = subw[1];
+						w[imd3[j]] = 0;
+					}
+				}
+			}
+			if (mindist < 0)
+			{
+				const btScalar d = btDot(a, n);
+				const btScalar s = btSqrt(l);
+				const btVector3 p = n * (d / l);
+				mindist = p.length2();
+				m = 7;
+				w[0] = (btCross(dl[1], b - p)).length() / s;
+				w[1] = (btCross(dl[2], c - p)).length() / s;
+				w[2] = 1 - (w[0] + w[1]);
+			}
+			return (mindist);
+		}
+		return (-1);
+	}
+	static btScalar projectorigin(const btVector3& a,
+								  const btVector3& b,
+								  const btVector3& c,
+								  const btVector3& d,
+								  btScalar* w, U& m)
+	{
+		static const U imd3[] = {1, 2, 0};
+		const btVector3* vt[] = {&a, &b, &c, &d};
+		const btVector3 dl[] = {a - d, b - d, c - d};
+		const btScalar vl = det(dl[0], dl[1], dl[2]);
+		const bool ng = (vl * btDot(a, btCross(b - c, a - b))) <= 0;
+		if (ng && (btFabs(vl) > GJK_SIMPLEX4_EPS))
+		{
+			btScalar mindist = -1;
+			btScalar subw[3] = {0.f, 0.f, 0.f};
+			U subm(0);
+			for (U i = 0; i < 3; ++i)
+			{
+				const U j = imd3[i];
+				const btScalar s = vl * btDot(d, btCross(dl[i], dl[j]));
+				if (s > 0)
+				{
+					const btScalar subd = projectorigin(*vt[i], *vt[j], d, subw, subm);
+					if ((mindist < 0) || (subd < mindist))
+					{
+						mindist = subd;
+						m = static_cast<U>((subm & 1 ? 1 << i : 0) +
+										   (subm & 2 ? 1 << j : 0) +
+										   (subm & 4 ? 8 : 0));
+						w[i] = subw[0];
+						w[j] = subw[1];
+						w[imd3[j]] = 0;
+						w[3] = subw[2];
+					}
+				}
+			}
+			if (mindist < 0)
+			{
+				mindist = 0;
+				m = 15;
+				w[0] = det(c, b, d) / vl;
+				w[1] = det(a, c, d) / vl;
+				w[2] = det(b, a, d) / vl;
+				w[3] = 1 - (w[0] + w[1] + w[2]);
+			}
+			return (mindist);
+		}
+		return (-1);
+	}
+};
+
+enum eEpaStatus
+{
+	eEpaValid,
+	eEpaTouching,
+	eEpaDegenerated,
+	eEpaNonConvex,
+	eEpaInvalidHull,
+	eEpaOutOfFaces,
+	eEpaOutOfVertices,
+	eEpaAccuraryReached,
+	eEpaFallBack,
+	eEpaFailed
+};
+
+// EPA
+template <typename btConvexTemplate>
+struct EPA
+{
+	/* Types		*/
+
+	struct sFace
+	{
+		btVector3 n;
+		btScalar d;
+		typename GJK<btConvexTemplate>::sSV* c[3];
+		sFace* f[3];
+		sFace* l[2];
+		U1 e[3];
+		U1 pass;
+	};
+	struct sList
+	{
+		sFace* root;
+		U count;
+		sList() : root(0), count(0) {}
+	};
+	struct sHorizon
+	{
+		sFace* cf;
+		sFace* ff;
+		U nf;
+		sHorizon() : cf(0), ff(0), nf(0) {}
+	};
+
+	/* Fields		*/
+	eEpaStatus m_status;
+	typename GJK<btConvexTemplate>::sSimplex m_result;
+	btVector3 m_normal;
+	btScalar m_depth;
+	typename GJK<btConvexTemplate>::sSV m_sv_store[EPA_MAX_VERTICES];
+	sFace m_fc_store[EPA_MAX_FACES];
+	U m_nextsv;
+	sList m_hull;
+	sList m_stock;
+	/* Methods		*/
+	EPA()
+	{
+		Initialize();
+	}
+
+	static inline void bind(sFace* fa, U ea, sFace* fb, U eb)
+	{
+		fa->e[ea] = (U1)eb;
+		fa->f[ea] = fb;
+		fb->e[eb] = (U1)ea;
+		fb->f[eb] = fa;
+	}
+	static inline void append(sList& list, sFace* face)
+	{
+		face->l[0] = 0;
+		face->l[1] = list.root;
+		if (list.root) list.root->l[0] = face;
+		list.root = face;
+		++list.count;
+	}
+	static inline void remove(sList& list, sFace* face)
+	{
+		if (face->l[1]) face->l[1]->l[0] = face->l[0];
+		if (face->l[0]) face->l[0]->l[1] = face->l[1];
+		if (face == list.root) list.root = face->l[1];
+		--list.count;
+	}
+
+	void Initialize()
+	{
+		m_status = eEpaFailed;
+		m_normal = btVector3(0, 0, 0);
+		m_depth = 0;
+		m_nextsv = 0;
+		for (U i = 0; i < EPA_MAX_FACES; ++i)
+		{
+			append(m_stock, &m_fc_store[EPA_MAX_FACES - i - 1]);
+		}
+	}
+	eEpaStatus Evaluate(GJK<btConvexTemplate>& gjk, const btVector3& guess)
+	{
+		typename GJK<btConvexTemplate>::sSimplex& simplex = *gjk.m_simplex;
+		if ((simplex.rank > 1) && gjk.EncloseOrigin())
+		{
+			/* Clean up				*/
+			while (m_hull.root)
+			{
+				sFace* f = m_hull.root;
+				remove(m_hull, f);
+				append(m_stock, f);
+			}
+			m_status = eEpaValid;
+			m_nextsv = 0;
+			/* Orient simplex		*/
+			if (gjk.det(simplex.c[0]->w - simplex.c[3]->w,
+						simplex.c[1]->w - simplex.c[3]->w,
+						simplex.c[2]->w - simplex.c[3]->w) < 0)
+			{
+				btSwap(simplex.c[0], simplex.c[1]);
+				btSwap(simplex.p[0], simplex.p[1]);
+			}
+			/* Build initial hull	*/
+			sFace* tetra[] = {newface(simplex.c[0], simplex.c[1], simplex.c[2], true),
+							  newface(simplex.c[1], simplex.c[0], simplex.c[3], true),
+							  newface(simplex.c[2], simplex.c[1], simplex.c[3], true),
+							  newface(simplex.c[0], simplex.c[2], simplex.c[3], true)};
+			if (m_hull.count == 4)
+			{
+				sFace* best = findbest();
+				sFace outer = *best;
+				U pass = 0;
+				U iterations = 0;
+				bind(tetra[0], 0, tetra[1], 0);
+				bind(tetra[0], 1, tetra[2], 0);
+				bind(tetra[0], 2, tetra[3], 0);
+				bind(tetra[1], 1, tetra[3], 2);
+				bind(tetra[1], 2, tetra[2], 1);
+				bind(tetra[2], 2, tetra[3], 1);
+				m_status = eEpaValid;
+				for (; iterations < EPA_MAX_ITERATIONS; ++iterations)
+				{
+					if (m_nextsv < EPA_MAX_VERTICES)
+					{
+						sHorizon horizon;
+						typename GJK<btConvexTemplate>::sSV* w = &m_sv_store[m_nextsv++];
+						bool valid = true;
+						best->pass = (U1)(++pass);
+						gjk.getsupport(best->n, *w);
+						const btScalar wdist = btDot(best->n, w->w) - best->d;
+						if (wdist > EPA_ACCURACY)
+						{
+							for (U j = 0; (j < 3) && valid; ++j)
+							{
+								valid &= expand(pass, w,
+												best->f[j], best->e[j],
+												horizon);
+							}
+							if (valid && (horizon.nf >= 3))
+							{
+								bind(horizon.cf, 1, horizon.ff, 2);
+								remove(m_hull, best);
+								append(m_stock, best);
+								best = findbest();
+								outer = *best;
+							}
+							else
+							{
+								m_status = eEpaInvalidHull;
+								break;
+							}
+						}
+						else
+						{
+							m_status = eEpaAccuraryReached;
+							break;
+						}
+					}
+					else
+					{
+						m_status = eEpaOutOfVertices;
+						break;
+					}
+				}
+				const btVector3 projection = outer.n * outer.d;
+				m_normal = outer.n;
+				m_depth = outer.d;
+				m_result.rank = 3;
+				m_result.c[0] = outer.c[0];
+				m_result.c[1] = outer.c[1];
+				m_result.c[2] = outer.c[2];
+				m_result.p[0] = btCross(outer.c[1]->w - projection,
+										outer.c[2]->w - projection)
+									.length();
+				m_result.p[1] = btCross(outer.c[2]->w - projection,
+										outer.c[0]->w - projection)
+									.length();
+				m_result.p[2] = btCross(outer.c[0]->w - projection,
+										outer.c[1]->w - projection)
+									.length();
+				const btScalar sum = m_result.p[0] + m_result.p[1] + m_result.p[2];
+				m_result.p[0] /= sum;
+				m_result.p[1] /= sum;
+				m_result.p[2] /= sum;
+				return (m_status);
+			}
+		}
+		/* Fallback		*/
+		m_status = eEpaFallBack;
+		m_normal = -guess;
+		const btScalar nl = m_normal.length();
+		if (nl > 0)
+			m_normal = m_normal / nl;
+		else
+			m_normal = btVector3(1, 0, 0);
+		m_depth = 0;
+		m_result.rank = 1;
+		m_result.c[0] = simplex.c[0];
+		m_result.p[0] = 1;
+		return (m_status);
+	}
+	bool getedgedist(sFace* face, typename GJK<btConvexTemplate>::sSV* a, typename GJK<btConvexTemplate>::sSV* b, btScalar& dist)
+	{
+		const btVector3 ba = b->w - a->w;
+		const btVector3 n_ab = btCross(ba, face->n);   // Outward facing edge normal direction, on triangle plane
+		const btScalar a_dot_nab = btDot(a->w, n_ab);  // Only care about the sign to determine inside/outside, so not normalization required
+
+		if (a_dot_nab < 0)
+		{
+			// Outside of edge a->b
+
+			const btScalar ba_l2 = ba.length2();
+			const btScalar a_dot_ba = btDot(a->w, ba);
+			const btScalar b_dot_ba = btDot(b->w, ba);
+
+			if (a_dot_ba > 0)
+			{
+				// Pick distance vertex a
+				dist = a->w.length();
+			}
+			else if (b_dot_ba < 0)
+			{
+				// Pick distance vertex b
+				dist = b->w.length();
+			}
+			else
+			{
+				// Pick distance to edge a->b
+				const btScalar a_dot_b = btDot(a->w, b->w);
+				dist = btSqrt(btMax((a->w.length2() * b->w.length2() - a_dot_b * a_dot_b) / ba_l2, (btScalar)0));
+			}
+
+			return true;
+		}
+
+		return false;
+	}
+	sFace* newface(typename GJK<btConvexTemplate>::sSV* a, typename GJK<btConvexTemplate>::sSV* b, typename GJK<btConvexTemplate>::sSV* c, bool forced)
+	{
+		if (m_stock.root)
+		{
+			sFace* face = m_stock.root;
+			remove(m_stock, face);
+			append(m_hull, face);
+			face->pass = 0;
+			face->c[0] = a;
+			face->c[1] = b;
+			face->c[2] = c;
+			face->n = btCross(b->w - a->w, c->w - a->w);
+			const btScalar l = face->n.length();
+			const bool v = l > EPA_ACCURACY;
+
+			if (v)
+			{
+				if (!(getedgedist(face, a, b, face->d) ||
+					  getedgedist(face, b, c, face->d) ||
+					  getedgedist(face, c, a, face->d)))
+				{
+					// Origin projects to the interior of the triangle
+					// Use distance to triangle plane
+					face->d = btDot(a->w, face->n) / l;
+				}
+
+				face->n /= l;
+				if (forced || (face->d >= -EPA_PLANE_EPS))
+				{
+					return face;
+				}
+				else
+					m_status = eEpaNonConvex;
+			}
+			else
+				m_status = eEpaDegenerated;
+
+			remove(m_hull, face);
+			append(m_stock, face);
+			return 0;
+		}
+		m_status = m_stock.root ? eEpaOutOfVertices : eEpaOutOfFaces;
+		return 0;
+	}
+	sFace* findbest()
+	{
+		sFace* minf = m_hull.root;
+		btScalar mind = minf->d * minf->d;
+		for (sFace* f = minf->l[1]; f; f = f->l[1])
+		{
+			const btScalar sqd = f->d * f->d;
+			if (sqd < mind)
+			{
+				minf = f;
+				mind = sqd;
+			}
+		}
+		return (minf);
+	}
+	bool expand(U pass, typename GJK<btConvexTemplate>::sSV* w, sFace* f, U e, sHorizon& horizon)
+	{
+		static const U i1m3[] = {1, 2, 0};
+		static const U i2m3[] = {2, 0, 1};
+		if (f->pass != pass)
+		{
+			const U e1 = i1m3[e];
+			if ((btDot(f->n, w->w) - f->d) < -EPA_PLANE_EPS)
+			{
+				sFace* nf = newface(f->c[e1], f->c[e], w, false);
+				if (nf)
+				{
+					bind(nf, 0, f, e);
+					if (horizon.cf)
+						bind(horizon.cf, 1, nf, 2);
+					else
+						horizon.ff = nf;
+					horizon.cf = nf;
+					++horizon.nf;
+					return (true);
+				}
+			}
+			else
+			{
+				const U e2 = i2m3[e];
+				f->pass = (U1)pass;
+				if (expand(pass, w, f->f[e1], f->e[e1], horizon) &&
+					expand(pass, w, f->f[e2], f->e[e2], horizon))
+				{
+					remove(m_hull, f);
+					append(m_stock, f);
+					return (true);
+				}
+			}
+		}
+		return (false);
+	}
+};
+
+template <typename btConvexTemplate>
+static void Initialize(const btConvexTemplate& a, const btConvexTemplate& b,
+					   btGjkEpaSolver3::sResults& results,
+					   MinkowskiDiff<btConvexTemplate>& shape)
+{
+	/* Results		*/
+	results.witnesses[0] =
+		results.witnesses[1] = btVector3(0, 0, 0);
+	results.status = btGjkEpaSolver3::sResults::Separated;
+	/* Shape		*/
+
+	shape.m_toshape1 = b.getWorldTransform().getBasis().transposeTimes(a.getWorldTransform().getBasis());
+	shape.m_toshape0 = a.getWorldTransform().inverseTimes(b.getWorldTransform());
+}
+
+//
+// Api
+//
+
+//
+template <typename btConvexTemplate>
+bool btGjkEpaSolver3_Distance(const btConvexTemplate& a, const btConvexTemplate& b,
+							  const btVector3& guess,
+							  btGjkEpaSolver3::sResults& results)
+{
+	MinkowskiDiff<btConvexTemplate> shape(a, b);
+	Initialize(a, b, results, shape);
+	GJK<btConvexTemplate> gjk(a, b);
+	eGjkStatus gjk_status = gjk.Evaluate(shape, guess);
+	if (gjk_status == eGjkValid)
+	{
+		btVector3 w0 = btVector3(0, 0, 0);
+		btVector3 w1 = btVector3(0, 0, 0);
+		for (U i = 0; i < gjk.m_simplex->rank; ++i)
+		{
+			const btScalar p = gjk.m_simplex->p[i];
+			w0 += shape.Support(gjk.m_simplex->c[i]->d, 0) * p;
+			w1 += shape.Support(-gjk.m_simplex->c[i]->d, 1) * p;
+		}
+		results.witnesses[0] = a.getWorldTransform() * w0;
+		results.witnesses[1] = a.getWorldTransform() * w1;
+		results.normal = w0 - w1;
+		results.distance = results.normal.length();
+		results.normal /= results.distance > GJK_MIN_DISTANCE ? results.distance : 1;
+		return (true);
+	}
+	else
+	{
+		results.status = gjk_status == eGjkInside ? btGjkEpaSolver3::sResults::Penetrating : btGjkEpaSolver3::sResults::GJK_Failed;
+		return (false);
+	}
+}
+
+template <typename btConvexTemplate>
+bool btGjkEpaSolver3_Penetration(const btConvexTemplate& a,
+								 const btConvexTemplate& b,
+								 const btVector3& guess,
+								 btGjkEpaSolver3::sResults& results)
+{
+	MinkowskiDiff<btConvexTemplate> shape(a, b);
+	Initialize(a, b, results, shape);
+	GJK<btConvexTemplate> gjk(a, b);
+	eGjkStatus gjk_status = gjk.Evaluate(shape, -guess);
+	switch (gjk_status)
+	{
+		case eGjkInside:
+		{
+			EPA<btConvexTemplate> epa;
+			eEpaStatus epa_status = epa.Evaluate(gjk, -guess);
+			if (epa_status != eEpaFailed)
+			{
+				btVector3 w0 = btVector3(0, 0, 0);
+				for (U i = 0; i < epa.m_result.rank; ++i)
+				{
+					w0 += shape.Support(epa.m_result.c[i]->d, 0) * epa.m_result.p[i];
+				}
+				results.status = btGjkEpaSolver3::sResults::Penetrating;
+				results.witnesses[0] = a.getWorldTransform() * w0;
+				results.witnesses[1] = a.getWorldTransform() * (w0 - epa.m_normal * epa.m_depth);
+				results.normal = -epa.m_normal;
+				results.distance = -epa.m_depth;
+				return (true);
+			}
+			else
+				results.status = btGjkEpaSolver3::sResults::EPA_Failed;
+		}
+		break;
+		case eGjkFailed:
+			results.status = btGjkEpaSolver3::sResults::GJK_Failed;
+			break;
+		default:
+		{
+		}
+	}
+	return (false);
+}
+
+#if 0
+int	btComputeGjkEpaPenetration2(const btCollisionDescription& colDesc, btDistanceInfo* distInfo)
+{
+    btGjkEpaSolver3::sResults results;
+    btVector3 guess = colDesc.m_firstDir;
+    
+    bool res = btGjkEpaSolver3::Penetration(colDesc.m_objA,colDesc.m_objB,
+                                            colDesc.m_transformA,colDesc.m_transformB,
+                                            colDesc.m_localSupportFuncA,colDesc.m_localSupportFuncB,
+                                            guess,
+                                            results);
+    if (res)
+    {
+        if ((results.status==btGjkEpaSolver3::sResults::Penetrating) || results.status==GJK::eStatus::Inside)
+        {
+            //normal could be 'swapped'
+            
+            distInfo->m_distance = results.distance;
+            distInfo->m_normalBtoA = results.normal;
+            btVector3 tmpNormalInB = results.witnesses[1]-results.witnesses[0];
+            btScalar lenSqr = tmpNormalInB.length2();
+            if (lenSqr <= (SIMD_EPSILON*SIMD_EPSILON))
+            {
+                tmpNormalInB = results.normal;
+                lenSqr = results.normal.length2();
+            }
+            
+            if (lenSqr > (SIMD_EPSILON*SIMD_EPSILON))
+            {
+                tmpNormalInB /= btSqrt(lenSqr);
+                btScalar distance2 = -(results.witnesses[0]-results.witnesses[1]).length();
+                //only replace valid penetrations when the result is deeper (check)
+                //if ((distance2 < results.distance))
+                {
+                    distInfo->m_distance = distance2;
+                    distInfo->m_pointOnA= results.witnesses[0];
+                    distInfo->m_pointOnB= results.witnesses[1];
+                    distInfo->m_normalBtoA= tmpNormalInB;
+                    return 0;
+                }
+            }
+        }
+        
+    }
+    
+    return -1;
+}
+#endif
+
+template <typename btConvexTemplate, typename btDistanceInfoTemplate>
+int btComputeGjkDistance(const btConvexTemplate& a, const btConvexTemplate& b,
+						 const btGjkCollisionDescription& colDesc, btDistanceInfoTemplate* distInfo)
+{
+	btGjkEpaSolver3::sResults results;
+	btVector3 guess = colDesc.m_firstDir;
+
+	bool isSeparated = btGjkEpaSolver3_Distance(a, b,
+												guess,
+												results);
+	if (isSeparated)
+	{
+		distInfo->m_distance = results.distance;
+		distInfo->m_pointOnA = results.witnesses[0];
+		distInfo->m_pointOnB = results.witnesses[1];
+		distInfo->m_normalBtoA = results.normal;
+		return 0;
+	}
+
+	return -1;
+}
+
+/* Symbols cleanup		*/
+
+#undef GJK_MAX_ITERATIONS
+#undef GJK_ACCURARY
+#undef GJK_MIN_DISTANCE
+#undef GJK_DUPLICATED_EPS
+#undef GJK_SIMPLEX2_EPS
+#undef GJK_SIMPLEX3_EPS
+#undef GJK_SIMPLEX4_EPS
+
+#undef EPA_MAX_VERTICES
+#undef EPA_MAX_FACES
+#undef EPA_MAX_ITERATIONS
+#undef EPA_ACCURACY
+#undef EPA_FALLBACK
+#undef EPA_PLANE_EPS
+#undef EPA_INSIDE_EPS
+
+#endif  //BT_GJK_EPA3_H
diff --git a/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h
new file mode 100644
index 00000000..92d6df17
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h
@@ -0,0 +1,40 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+EPA Copyright (c) Ricardo Padrela 2006 
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef BT_GJP_EPA_PENETRATION_DEPTH_H
+#define BT_GJP_EPA_PENETRATION_DEPTH_H
+
+#include "btConvexPenetrationDepthSolver.h"
+
+///EpaPenetrationDepthSolver uses the Expanding Polytope Algorithm to
+///calculate the penetration depth between two convex shapes.
+class btGjkEpaPenetrationDepthSolver : public btConvexPenetrationDepthSolver
+{
+public:
+	btGjkEpaPenetrationDepthSolver()
+	{
+	}
+
+	bool calcPenDepth(btSimplexSolverInterface& simplexSolver,
+					  const btConvexShape* pConvexA, const btConvexShape* pConvexB,
+					  const btTransform& transformA, const btTransform& transformB,
+					  btVector3& v, btVector3& wWitnessOnA, btVector3& wWitnessOnB,
+					  class btIDebugDraw* debugDraw);
+
+private:
+};
+
+#endif  // BT_GJP_EPA_PENETRATION_DEPTH_H
diff --git a/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h
new file mode 100644
index 00000000..faa02287
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h
@@ -0,0 +1,93 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_GJK_PAIR_DETECTOR_H
+#define BT_GJK_PAIR_DETECTOR_H
+
+#include "btDiscreteCollisionDetectorInterface.h"
+#include "BulletCollision/CollisionShapes/btCollisionMargin.h"
+
+class btConvexShape;
+#include "btSimplexSolverInterface.h"
+class btConvexPenetrationDepthSolver;
+
+/// btGjkPairDetector uses GJK to implement the btDiscreteCollisionDetectorInterface
+class btGjkPairDetector : public btDiscreteCollisionDetectorInterface
+{
+	btVector3 m_cachedSeparatingAxis;
+	btConvexPenetrationDepthSolver* m_penetrationDepthSolver;
+	btSimplexSolverInterface* m_simplexSolver;
+	const btConvexShape* m_minkowskiA;
+	const btConvexShape* m_minkowskiB;
+	int m_shapeTypeA;
+	int m_shapeTypeB;
+	btScalar m_marginA;
+	btScalar m_marginB;
+
+	bool m_ignoreMargin;
+	btScalar m_cachedSeparatingDistance;
+
+public:
+	//some debugging to fix degeneracy problems
+	int m_lastUsedMethod;
+	int m_curIter;
+	int m_degenerateSimplex;
+	int m_catchDegeneracies;
+	int m_fixContactNormalDirection;
+
+	btGjkPairDetector(const btConvexShape* objectA, const btConvexShape* objectB, btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* penetrationDepthSolver);
+	btGjkPairDetector(const btConvexShape* objectA, const btConvexShape* objectB, int shapeTypeA, int shapeTypeB, btScalar marginA, btScalar marginB, btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* penetrationDepthSolver);
+	virtual ~btGjkPairDetector(){};
+
+	virtual void getClosestPoints(const ClosestPointInput& input, Result& output, class btIDebugDraw* debugDraw, bool swapResults = false);
+
+	void getClosestPointsNonVirtual(const ClosestPointInput& input, Result& output, class btIDebugDraw* debugDraw);
+
+	void setMinkowskiA(const btConvexShape* minkA)
+	{
+		m_minkowskiA = minkA;
+	}
+
+	void setMinkowskiB(const btConvexShape* minkB)
+	{
+		m_minkowskiB = minkB;
+	}
+	void setCachedSeparatingAxis(const btVector3& separatingAxis)
+	{
+		m_cachedSeparatingAxis = separatingAxis;
+	}
+
+	const btVector3& getCachedSeparatingAxis() const
+	{
+		return m_cachedSeparatingAxis;
+	}
+	btScalar getCachedSeparatingDistance() const
+	{
+		return m_cachedSeparatingDistance;
+	}
+
+	void setPenetrationDepthSolver(btConvexPenetrationDepthSolver* penetrationDepthSolver)
+	{
+		m_penetrationDepthSolver = penetrationDepthSolver;
+	}
+
+	///don't use setIgnoreMargin, it's for Bullet's internal use
+	void setIgnoreMargin(bool ignoreMargin)
+	{
+		m_ignoreMargin = ignoreMargin;
+	}
+};
+
+#endif  //BT_GJK_PAIR_DETECTOR_H
diff --git a/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btManifoldPoint.h b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btManifoldPoint.h
new file mode 100644
index 00000000..573fc86b
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btManifoldPoint.h
@@ -0,0 +1,174 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_MANIFOLD_CONTACT_POINT_H
+#define BT_MANIFOLD_CONTACT_POINT_H
+
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btTransformUtil.h"
+
+#ifdef PFX_USE_FREE_VECTORMATH
+#include "physics_effects/base_level/solver/pfx_constraint_row.h"
+typedef sce::PhysicsEffects::PfxConstraintRow btConstraintRow;
+#else
+// Don't change following order of parameters
+ATTRIBUTE_ALIGNED16(struct)
+btConstraintRow
+{
+	btScalar m_normal[3];
+	btScalar m_rhs;
+	btScalar m_jacDiagInv;
+	btScalar m_lowerLimit;
+	btScalar m_upperLimit;
+	btScalar m_accumImpulse;
+};
+typedef btConstraintRow PfxConstraintRow;
+#endif  //PFX_USE_FREE_VECTORMATH
+
+enum btContactPointFlags
+{
+	BT_CONTACT_FLAG_LATERAL_FRICTION_INITIALIZED = 1,
+	BT_CONTACT_FLAG_HAS_CONTACT_CFM = 2,
+	BT_CONTACT_FLAG_HAS_CONTACT_ERP = 4,
+	BT_CONTACT_FLAG_CONTACT_STIFFNESS_DAMPING = 8,
+	BT_CONTACT_FLAG_FRICTION_ANCHOR = 16,
+};
+
+/// ManifoldContactPoint collects and maintains persistent contactpoints.
+/// used to improve stability and performance of rigidbody dynamics response.
+class btManifoldPoint
+{
+public:
+	btManifoldPoint()
+		: m_userPersistentData(0),
+		  m_contactPointFlags(0),
+		  m_appliedImpulse(0.f),
+		  m_prevRHS(0.f),
+		  m_appliedImpulseLateral1(0.f),
+		  m_appliedImpulseLateral2(0.f),
+		  m_contactMotion1(0.f),
+		  m_contactMotion2(0.f),
+		  m_contactCFM(0.f),
+		  m_contactERP(0.f),
+		  m_frictionCFM(0.f),
+		  m_lifeTime(0)
+	{
+	}
+
+	btManifoldPoint(const btVector3& pointA, const btVector3& pointB,
+					const btVector3& normal,
+					btScalar distance) : m_localPointA(pointA),
+										 m_localPointB(pointB),
+										 m_normalWorldOnB(normal),
+										 m_distance1(distance),
+										 m_combinedFriction(btScalar(0.)),
+										 m_combinedRollingFriction(btScalar(0.)),
+										 m_combinedSpinningFriction(btScalar(0.)),
+										 m_combinedRestitution(btScalar(0.)),
+										 m_userPersistentData(0),
+										 m_contactPointFlags(0),
+										 m_appliedImpulse(0.f),
+										 m_prevRHS(0.f),
+										 m_appliedImpulseLateral1(0.f),
+										 m_appliedImpulseLateral2(0.f),
+										 m_contactMotion1(0.f),
+										 m_contactMotion2(0.f),
+										 m_contactCFM(0.f),
+										 m_contactERP(0.f),
+										 m_frictionCFM(0.f),
+										 m_lifeTime(0)
+	{
+	}
+
+	btVector3 m_localPointA;
+	btVector3 m_localPointB;
+	btVector3 m_positionWorldOnB;
+	///m_positionWorldOnA is redundant information, see getPositionWorldOnA(), but for clarity
+	btVector3 m_positionWorldOnA;
+	btVector3 m_normalWorldOnB;
+
+	btScalar m_distance1;
+	btScalar m_combinedFriction;
+	btScalar m_combinedRollingFriction;   //torsional friction orthogonal to contact normal, useful to make spheres stop rolling forever
+	btScalar m_combinedSpinningFriction;  //torsional friction around contact normal, useful for grasping objects
+	btScalar m_combinedRestitution;
+
+	//BP mod, store contact triangles.
+	int m_partId0;
+	int m_partId1;
+	int m_index0;
+	int m_index1;
+
+	mutable void* m_userPersistentData;
+	//bool			m_lateralFrictionInitialized;
+	int m_contactPointFlags;
+
+	btScalar m_appliedImpulse;
+	btScalar m_prevRHS;
+	btScalar m_appliedImpulseLateral1;
+	btScalar m_appliedImpulseLateral2;
+	btScalar m_contactMotion1;
+	btScalar m_contactMotion2;
+
+	union {
+		btScalar m_contactCFM;
+		btScalar m_combinedContactStiffness1;
+	};
+
+	union {
+		btScalar m_contactERP;
+		btScalar m_combinedContactDamping1;
+	};
+
+	btScalar m_frictionCFM;
+
+	int m_lifeTime;  //lifetime of the contactpoint in frames
+
+	btVector3 m_lateralFrictionDir1;
+	btVector3 m_lateralFrictionDir2;
+
+	btScalar getDistance() const
+	{
+		return m_distance1;
+	}
+	int getLifeTime() const
+	{
+		return m_lifeTime;
+	}
+
+	const btVector3& getPositionWorldOnA() const
+	{
+		return m_positionWorldOnA;
+		//				return m_positionWorldOnB + m_normalWorldOnB * m_distance1;
+	}
+
+	const btVector3& getPositionWorldOnB() const
+	{
+		return m_positionWorldOnB;
+	}
+
+	void setDistance(btScalar dist)
+	{
+		m_distance1 = dist;
+	}
+
+	///this returns the most recent applied impulse, to satisfy contact constraints by the constraint solver
+	btScalar getAppliedImpulse() const
+	{
+		return m_appliedImpulse;
+	}
+};
+
+#endif  //BT_MANIFOLD_CONTACT_POINT_H
diff --git a/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h
new file mode 100644
index 00000000..8e3e3932
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h
@@ -0,0 +1,36 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_MINKOWSKI_PENETRATION_DEPTH_SOLVER_H
+#define BT_MINKOWSKI_PENETRATION_DEPTH_SOLVER_H
+
+#include "btConvexPenetrationDepthSolver.h"
+
+///MinkowskiPenetrationDepthSolver implements bruteforce penetration depth estimation.
+///Implementation is based on sampling the depth using support mapping, and using GJK step to get the witness points.
+class btMinkowskiPenetrationDepthSolver : public btConvexPenetrationDepthSolver
+{
+protected:
+	static btVector3* getPenetrationDirections();
+
+public:
+	virtual bool calcPenDepth(btSimplexSolverInterface& simplexSolver,
+							  const btConvexShape* convexA, const btConvexShape* convexB,
+							  const btTransform& transA, const btTransform& transB,
+							  btVector3& v, btVector3& pa, btVector3& pb,
+							  class btIDebugDraw* debugDraw);
+};
+
+#endif  //BT_MINKOWSKI_PENETRATION_DEPTH_SOLVER_H
diff --git a/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btMprPenetration.h b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btMprPenetration.h
new file mode 100644
index 00000000..534a66d3
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btMprPenetration.h
@@ -0,0 +1,884 @@
+
+/***
+ * ---------------------------------
+ * Copyright (c)2012 Daniel Fiser <danfis@danfis.cz>
+ *
+ *  This file was ported from mpr.c file, part of libccd.
+ *  The Minkoski Portal Refinement implementation was ported 
+ *  to OpenCL by Erwin Coumans for the Bullet 3 Physics library.
+ *  The original MPR idea and implementation is by Gary Snethen
+ *  in XenoCollide, see http://github.com/erwincoumans/xenocollide
+ *
+ *  Distributed under the OSI-approved BSD License (the "License");
+ *  see <http://www.opensource.org/licenses/bsd-license.php>.
+ *  This software is distributed WITHOUT ANY WARRANTY; without even the
+ *  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *  See the License for more information.
+ */
+
+///2014 Oct, Erwin Coumans, Use templates to avoid void* casts
+
+#ifndef BT_MPR_PENETRATION_H
+#define BT_MPR_PENETRATION_H
+
+#define BT_DEBUG_MPR1
+
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btAlignedObjectArray.h"
+
+//#define MPR_AVERAGE_CONTACT_POSITIONS
+
+struct btMprCollisionDescription
+{
+	btVector3 m_firstDir;
+	int m_maxGjkIterations;
+	btScalar m_maximumDistanceSquared;
+	btScalar m_gjkRelError2;
+
+	btMprCollisionDescription()
+		: m_firstDir(0, 1, 0),
+		  m_maxGjkIterations(1000),
+		  m_maximumDistanceSquared(1e30f),
+		  m_gjkRelError2(1.0e-6)
+	{
+	}
+	virtual ~btMprCollisionDescription()
+	{
+	}
+};
+
+struct btMprDistanceInfo
+{
+	btVector3 m_pointOnA;
+	btVector3 m_pointOnB;
+	btVector3 m_normalBtoA;
+	btScalar m_distance;
+};
+
+#ifdef __cplusplus
+#define BT_MPR_SQRT sqrtf
+#else
+#define BT_MPR_SQRT sqrt
+#endif
+#define BT_MPR_FMIN(x, y) ((x) < (y) ? (x) : (y))
+#define BT_MPR_FABS fabs
+
+#define BT_MPR_TOLERANCE 1E-6f
+#define BT_MPR_MAX_ITERATIONS 1000
+
+struct _btMprSupport_t
+{
+	btVector3 v;   //!< Support point in minkowski sum
+	btVector3 v1;  //!< Support point in obj1
+	btVector3 v2;  //!< Support point in obj2
+};
+typedef struct _btMprSupport_t btMprSupport_t;
+
+struct _btMprSimplex_t
+{
+	btMprSupport_t ps[4];
+	int last;  //!< index of last added point
+};
+typedef struct _btMprSimplex_t btMprSimplex_t;
+
+inline btMprSupport_t *btMprSimplexPointW(btMprSimplex_t *s, int idx)
+{
+	return &s->ps[idx];
+}
+
+inline void btMprSimplexSetSize(btMprSimplex_t *s, int size)
+{
+	s->last = size - 1;
+}
+
+#ifdef DEBUG_MPR
+inline void btPrintPortalVertex(_btMprSimplex_t *portal, int index)
+{
+	printf("portal[%d].v = %f,%f,%f, v1=%f,%f,%f, v2=%f,%f,%f\n", index, portal->ps[index].v.x(), portal->ps[index].v.y(), portal->ps[index].v.z(),
+		   portal->ps[index].v1.x(), portal->ps[index].v1.y(), portal->ps[index].v1.z(),
+		   portal->ps[index].v2.x(), portal->ps[index].v2.y(), portal->ps[index].v2.z());
+}
+#endif  //DEBUG_MPR
+
+inline int btMprSimplexSize(const btMprSimplex_t *s)
+{
+	return s->last + 1;
+}
+
+inline const btMprSupport_t *btMprSimplexPoint(const btMprSimplex_t *s, int idx)
+{
+	// here is no check on boundaries
+	return &s->ps[idx];
+}
+
+inline void btMprSupportCopy(btMprSupport_t *d, const btMprSupport_t *s)
+{
+	*d = *s;
+}
+
+inline void btMprSimplexSet(btMprSimplex_t *s, size_t pos, const btMprSupport_t *a)
+{
+	btMprSupportCopy(s->ps + pos, a);
+}
+
+inline void btMprSimplexSwap(btMprSimplex_t *s, size_t pos1, size_t pos2)
+{
+	btMprSupport_t supp;
+
+	btMprSupportCopy(&supp, &s->ps[pos1]);
+	btMprSupportCopy(&s->ps[pos1], &s->ps[pos2]);
+	btMprSupportCopy(&s->ps[pos2], &supp);
+}
+
+inline int btMprIsZero(float val)
+{
+	return BT_MPR_FABS(val) < FLT_EPSILON;
+}
+
+inline int btMprEq(float _a, float _b)
+{
+	float ab;
+	float a, b;
+
+	ab = BT_MPR_FABS(_a - _b);
+	if (BT_MPR_FABS(ab) < FLT_EPSILON)
+		return 1;
+
+	a = BT_MPR_FABS(_a);
+	b = BT_MPR_FABS(_b);
+	if (b > a)
+	{
+		return ab < FLT_EPSILON * b;
+	}
+	else
+	{
+		return ab < FLT_EPSILON * a;
+	}
+}
+
+inline int btMprVec3Eq(const btVector3 *a, const btVector3 *b)
+{
+	return btMprEq((*a).x(), (*b).x()) && btMprEq((*a).y(), (*b).y()) && btMprEq((*a).z(), (*b).z());
+}
+
+template <typename btConvexTemplate>
+inline void btFindOrigin(const btConvexTemplate &a, const btConvexTemplate &b, const btMprCollisionDescription &colDesc, btMprSupport_t *center)
+{
+	center->v1 = a.getObjectCenterInWorld();
+	center->v2 = b.getObjectCenterInWorld();
+	center->v = center->v1 - center->v2;
+}
+
+inline void btMprVec3Set(btVector3 *v, float x, float y, float z)
+{
+	v->setValue(x, y, z);
+}
+
+inline void btMprVec3Add(btVector3 *v, const btVector3 *w)
+{
+	*v += *w;
+}
+
+inline void btMprVec3Copy(btVector3 *v, const btVector3 *w)
+{
+	*v = *w;
+}
+
+inline void btMprVec3Scale(btVector3 *d, float k)
+{
+	*d *= k;
+}
+
+inline float btMprVec3Dot(const btVector3 *a, const btVector3 *b)
+{
+	float dot;
+
+	dot = btDot(*a, *b);
+	return dot;
+}
+
+inline float btMprVec3Len2(const btVector3 *v)
+{
+	return btMprVec3Dot(v, v);
+}
+
+inline void btMprVec3Normalize(btVector3 *d)
+{
+	float k = 1.f / BT_MPR_SQRT(btMprVec3Len2(d));
+	btMprVec3Scale(d, k);
+}
+
+inline void btMprVec3Cross(btVector3 *d, const btVector3 *a, const btVector3 *b)
+{
+	*d = btCross(*a, *b);
+}
+
+inline void btMprVec3Sub2(btVector3 *d, const btVector3 *v, const btVector3 *w)
+{
+	*d = *v - *w;
+}
+
+inline void btPortalDir(const btMprSimplex_t *portal, btVector3 *dir)
+{
+	btVector3 v2v1, v3v1;
+
+	btMprVec3Sub2(&v2v1, &btMprSimplexPoint(portal, 2)->v,
+				  &btMprSimplexPoint(portal, 1)->v);
+	btMprVec3Sub2(&v3v1, &btMprSimplexPoint(portal, 3)->v,
+				  &btMprSimplexPoint(portal, 1)->v);
+	btMprVec3Cross(dir, &v2v1, &v3v1);
+	btMprVec3Normalize(dir);
+}
+
+inline int portalEncapsulesOrigin(const btMprSimplex_t *portal,
+								  const btVector3 *dir)
+{
+	float dot;
+	dot = btMprVec3Dot(dir, &btMprSimplexPoint(portal, 1)->v);
+	return btMprIsZero(dot) || dot > 0.f;
+}
+
+inline int portalReachTolerance(const btMprSimplex_t *portal,
+								const btMprSupport_t *v4,
+								const btVector3 *dir)
+{
+	float dv1, dv2, dv3, dv4;
+	float dot1, dot2, dot3;
+
+	// find the smallest dot product of dir and {v1-v4, v2-v4, v3-v4}
+
+	dv1 = btMprVec3Dot(&btMprSimplexPoint(portal, 1)->v, dir);
+	dv2 = btMprVec3Dot(&btMprSimplexPoint(portal, 2)->v, dir);
+	dv3 = btMprVec3Dot(&btMprSimplexPoint(portal, 3)->v, dir);
+	dv4 = btMprVec3Dot(&v4->v, dir);
+
+	dot1 = dv4 - dv1;
+	dot2 = dv4 - dv2;
+	dot3 = dv4 - dv3;
+
+	dot1 = BT_MPR_FMIN(dot1, dot2);
+	dot1 = BT_MPR_FMIN(dot1, dot3);
+
+	return btMprEq(dot1, BT_MPR_TOLERANCE) || dot1 < BT_MPR_TOLERANCE;
+}
+
+inline int portalCanEncapsuleOrigin(const btMprSimplex_t *portal,
+									const btMprSupport_t *v4,
+									const btVector3 *dir)
+{
+	float dot;
+	dot = btMprVec3Dot(&v4->v, dir);
+	return btMprIsZero(dot) || dot > 0.f;
+}
+
+inline void btExpandPortal(btMprSimplex_t *portal,
+						   const btMprSupport_t *v4)
+{
+	float dot;
+	btVector3 v4v0;
+
+	btMprVec3Cross(&v4v0, &v4->v, &btMprSimplexPoint(portal, 0)->v);
+	dot = btMprVec3Dot(&btMprSimplexPoint(portal, 1)->v, &v4v0);
+	if (dot > 0.f)
+	{
+		dot = btMprVec3Dot(&btMprSimplexPoint(portal, 2)->v, &v4v0);
+		if (dot > 0.f)
+		{
+			btMprSimplexSet(portal, 1, v4);
+		}
+		else
+		{
+			btMprSimplexSet(portal, 3, v4);
+		}
+	}
+	else
+	{
+		dot = btMprVec3Dot(&btMprSimplexPoint(portal, 3)->v, &v4v0);
+		if (dot > 0.f)
+		{
+			btMprSimplexSet(portal, 2, v4);
+		}
+		else
+		{
+			btMprSimplexSet(portal, 1, v4);
+		}
+	}
+}
+template <typename btConvexTemplate>
+inline void btMprSupport(const btConvexTemplate &a, const btConvexTemplate &b,
+						 const btMprCollisionDescription &colDesc,
+						 const btVector3 &dir, btMprSupport_t *supp)
+{
+	btVector3 separatingAxisInA = dir * a.getWorldTransform().getBasis();
+	btVector3 separatingAxisInB = -dir * b.getWorldTransform().getBasis();
+
+	btVector3 pInA = a.getLocalSupportWithMargin(separatingAxisInA);
+	btVector3 qInB = b.getLocalSupportWithMargin(separatingAxisInB);
+
+	supp->v1 = a.getWorldTransform()(pInA);
+	supp->v2 = b.getWorldTransform()(qInB);
+	supp->v = supp->v1 - supp->v2;
+}
+
+template <typename btConvexTemplate>
+static int btDiscoverPortal(const btConvexTemplate &a, const btConvexTemplate &b,
+							const btMprCollisionDescription &colDesc,
+							btMprSimplex_t *portal)
+{
+	btVector3 dir, va, vb;
+	float dot;
+	int cont;
+
+	// vertex 0 is center of portal
+	btFindOrigin(a, b, colDesc, btMprSimplexPointW(portal, 0));
+
+	// vertex 0 is center of portal
+	btMprSimplexSetSize(portal, 1);
+
+	btVector3 zero = btVector3(0, 0, 0);
+	btVector3 *org = &zero;
+
+	if (btMprVec3Eq(&btMprSimplexPoint(portal, 0)->v, org))
+	{
+		// Portal's center lies on origin (0,0,0) => we know that objects
+		// intersect but we would need to know penetration info.
+		// So move center little bit...
+		btMprVec3Set(&va, FLT_EPSILON * 10.f, 0.f, 0.f);
+		btMprVec3Add(&btMprSimplexPointW(portal, 0)->v, &va);
+	}
+
+	// vertex 1 = support in direction of origin
+	btMprVec3Copy(&dir, &btMprSimplexPoint(portal, 0)->v);
+	btMprVec3Scale(&dir, -1.f);
+	btMprVec3Normalize(&dir);
+
+	btMprSupport(a, b, colDesc, dir, btMprSimplexPointW(portal, 1));
+
+	btMprSimplexSetSize(portal, 2);
+
+	// test if origin isn't outside of v1
+	dot = btMprVec3Dot(&btMprSimplexPoint(portal, 1)->v, &dir);
+
+	if (btMprIsZero(dot) || dot < 0.f)
+		return -1;
+
+	// vertex 2
+	btMprVec3Cross(&dir, &btMprSimplexPoint(portal, 0)->v,
+				   &btMprSimplexPoint(portal, 1)->v);
+	if (btMprIsZero(btMprVec3Len2(&dir)))
+	{
+		if (btMprVec3Eq(&btMprSimplexPoint(portal, 1)->v, org))
+		{
+			// origin lies on v1
+			return 1;
+		}
+		else
+		{
+			// origin lies on v0-v1 segment
+			return 2;
+		}
+	}
+
+	btMprVec3Normalize(&dir);
+	btMprSupport(a, b, colDesc, dir, btMprSimplexPointW(portal, 2));
+
+	dot = btMprVec3Dot(&btMprSimplexPoint(portal, 2)->v, &dir);
+	if (btMprIsZero(dot) || dot < 0.f)
+		return -1;
+
+	btMprSimplexSetSize(portal, 3);
+
+	// vertex 3 direction
+	btMprVec3Sub2(&va, &btMprSimplexPoint(portal, 1)->v,
+				  &btMprSimplexPoint(portal, 0)->v);
+	btMprVec3Sub2(&vb, &btMprSimplexPoint(portal, 2)->v,
+				  &btMprSimplexPoint(portal, 0)->v);
+	btMprVec3Cross(&dir, &va, &vb);
+	btMprVec3Normalize(&dir);
+
+	// it is better to form portal faces to be oriented "outside" origin
+	dot = btMprVec3Dot(&dir, &btMprSimplexPoint(portal, 0)->v);
+	if (dot > 0.f)
+	{
+		btMprSimplexSwap(portal, 1, 2);
+		btMprVec3Scale(&dir, -1.f);
+	}
+
+	while (btMprSimplexSize(portal) < 4)
+	{
+		btMprSupport(a, b, colDesc, dir, btMprSimplexPointW(portal, 3));
+
+		dot = btMprVec3Dot(&btMprSimplexPoint(portal, 3)->v, &dir);
+		if (btMprIsZero(dot) || dot < 0.f)
+			return -1;
+
+		cont = 0;
+
+		// test if origin is outside (v1, v0, v3) - set v2 as v3 and
+		// continue
+		btMprVec3Cross(&va, &btMprSimplexPoint(portal, 1)->v,
+					   &btMprSimplexPoint(portal, 3)->v);
+		dot = btMprVec3Dot(&va, &btMprSimplexPoint(portal, 0)->v);
+		if (dot < 0.f && !btMprIsZero(dot))
+		{
+			btMprSimplexSet(portal, 2, btMprSimplexPoint(portal, 3));
+			cont = 1;
+		}
+
+		if (!cont)
+		{
+			// test if origin is outside (v3, v0, v2) - set v1 as v3 and
+			// continue
+			btMprVec3Cross(&va, &btMprSimplexPoint(portal, 3)->v,
+						   &btMprSimplexPoint(portal, 2)->v);
+			dot = btMprVec3Dot(&va, &btMprSimplexPoint(portal, 0)->v);
+			if (dot < 0.f && !btMprIsZero(dot))
+			{
+				btMprSimplexSet(portal, 1, btMprSimplexPoint(portal, 3));
+				cont = 1;
+			}
+		}
+
+		if (cont)
+		{
+			btMprVec3Sub2(&va, &btMprSimplexPoint(portal, 1)->v,
+						  &btMprSimplexPoint(portal, 0)->v);
+			btMprVec3Sub2(&vb, &btMprSimplexPoint(portal, 2)->v,
+						  &btMprSimplexPoint(portal, 0)->v);
+			btMprVec3Cross(&dir, &va, &vb);
+			btMprVec3Normalize(&dir);
+		}
+		else
+		{
+			btMprSimplexSetSize(portal, 4);
+		}
+	}
+
+	return 0;
+}
+
+template <typename btConvexTemplate>
+static int btRefinePortal(const btConvexTemplate &a, const btConvexTemplate &b, const btMprCollisionDescription &colDesc,
+						  btMprSimplex_t *portal)
+{
+	btVector3 dir;
+	btMprSupport_t v4;
+
+	for (int i = 0; i < BT_MPR_MAX_ITERATIONS; i++)
+	//while (1)
+	{
+		// compute direction outside the portal (from v0 through v1,v2,v3
+		// face)
+		btPortalDir(portal, &dir);
+
+		// test if origin is inside the portal
+		if (portalEncapsulesOrigin(portal, &dir))
+			return 0;
+
+		// get next support point
+
+		btMprSupport(a, b, colDesc, dir, &v4);
+
+		// test if v4 can expand portal to contain origin and if portal
+		// expanding doesn't reach given tolerance
+		if (!portalCanEncapsuleOrigin(portal, &v4, &dir) || portalReachTolerance(portal, &v4, &dir))
+		{
+			return -1;
+		}
+
+		// v1-v2-v3 triangle must be rearranged to face outside Minkowski
+		// difference (direction from v0).
+		btExpandPortal(portal, &v4);
+	}
+
+	return -1;
+}
+
+static void btFindPos(const btMprSimplex_t *portal, btVector3 *pos)
+{
+	btVector3 zero = btVector3(0, 0, 0);
+	btVector3 *origin = &zero;
+
+	btVector3 dir;
+	size_t i;
+	float b[4], sum, inv;
+	btVector3 vec, p1, p2;
+
+	btPortalDir(portal, &dir);
+
+	// use barycentric coordinates of tetrahedron to find origin
+	btMprVec3Cross(&vec, &btMprSimplexPoint(portal, 1)->v,
+				   &btMprSimplexPoint(portal, 2)->v);
+	b[0] = btMprVec3Dot(&vec, &btMprSimplexPoint(portal, 3)->v);
+
+	btMprVec3Cross(&vec, &btMprSimplexPoint(portal, 3)->v,
+				   &btMprSimplexPoint(portal, 2)->v);
+	b[1] = btMprVec3Dot(&vec, &btMprSimplexPoint(portal, 0)->v);
+
+	btMprVec3Cross(&vec, &btMprSimplexPoint(portal, 0)->v,
+				   &btMprSimplexPoint(portal, 1)->v);
+	b[2] = btMprVec3Dot(&vec, &btMprSimplexPoint(portal, 3)->v);
+
+	btMprVec3Cross(&vec, &btMprSimplexPoint(portal, 2)->v,
+				   &btMprSimplexPoint(portal, 1)->v);
+	b[3] = btMprVec3Dot(&vec, &btMprSimplexPoint(portal, 0)->v);
+
+	sum = b[0] + b[1] + b[2] + b[3];
+
+	if (btMprIsZero(sum) || sum < 0.f)
+	{
+		b[0] = 0.f;
+
+		btMprVec3Cross(&vec, &btMprSimplexPoint(portal, 2)->v,
+					   &btMprSimplexPoint(portal, 3)->v);
+		b[1] = btMprVec3Dot(&vec, &dir);
+		btMprVec3Cross(&vec, &btMprSimplexPoint(portal, 3)->v,
+					   &btMprSimplexPoint(portal, 1)->v);
+		b[2] = btMprVec3Dot(&vec, &dir);
+		btMprVec3Cross(&vec, &btMprSimplexPoint(portal, 1)->v,
+					   &btMprSimplexPoint(portal, 2)->v);
+		b[3] = btMprVec3Dot(&vec, &dir);
+
+		sum = b[1] + b[2] + b[3];
+	}
+
+	inv = 1.f / sum;
+
+	btMprVec3Copy(&p1, origin);
+	btMprVec3Copy(&p2, origin);
+	for (i = 0; i < 4; i++)
+	{
+		btMprVec3Copy(&vec, &btMprSimplexPoint(portal, i)->v1);
+		btMprVec3Scale(&vec, b[i]);
+		btMprVec3Add(&p1, &vec);
+
+		btMprVec3Copy(&vec, &btMprSimplexPoint(portal, i)->v2);
+		btMprVec3Scale(&vec, b[i]);
+		btMprVec3Add(&p2, &vec);
+	}
+	btMprVec3Scale(&p1, inv);
+	btMprVec3Scale(&p2, inv);
+#ifdef MPR_AVERAGE_CONTACT_POSITIONS
+	btMprVec3Copy(pos, &p1);
+	btMprVec3Add(pos, &p2);
+	btMprVec3Scale(pos, 0.5);
+#else
+	btMprVec3Copy(pos, &p2);
+#endif  //MPR_AVERAGE_CONTACT_POSITIONS
+}
+
+inline float btMprVec3Dist2(const btVector3 *a, const btVector3 *b)
+{
+	btVector3 ab;
+	btMprVec3Sub2(&ab, a, b);
+	return btMprVec3Len2(&ab);
+}
+
+inline float _btMprVec3PointSegmentDist2(const btVector3 *P,
+										 const btVector3 *x0,
+										 const btVector3 *b,
+										 btVector3 *witness)
+{
+	// The computation comes from solving equation of segment:
+	//      S(t) = x0 + t.d
+	//          where - x0 is initial point of segment
+	//                - d is direction of segment from x0 (|d| > 0)
+	//                - t belongs to <0, 1> interval
+	//
+	// Than, distance from a segment to some point P can be expressed:
+	//      D(t) = |x0 + t.d - P|^2
+	//          which is distance from any point on segment. Minimization
+	//          of this function brings distance from P to segment.
+	// Minimization of D(t) leads to simple quadratic equation that's
+	// solving is straightforward.
+	//
+	// Bonus of this method is witness point for free.
+
+	float dist, t;
+	btVector3 d, a;
+
+	// direction of segment
+	btMprVec3Sub2(&d, b, x0);
+
+	// precompute vector from P to x0
+	btMprVec3Sub2(&a, x0, P);
+
+	t = -1.f * btMprVec3Dot(&a, &d);
+	t /= btMprVec3Len2(&d);
+
+	if (t < 0.f || btMprIsZero(t))
+	{
+		dist = btMprVec3Dist2(x0, P);
+		if (witness)
+			btMprVec3Copy(witness, x0);
+	}
+	else if (t > 1.f || btMprEq(t, 1.f))
+	{
+		dist = btMprVec3Dist2(b, P);
+		if (witness)
+			btMprVec3Copy(witness, b);
+	}
+	else
+	{
+		if (witness)
+		{
+			btMprVec3Copy(witness, &d);
+			btMprVec3Scale(witness, t);
+			btMprVec3Add(witness, x0);
+			dist = btMprVec3Dist2(witness, P);
+		}
+		else
+		{
+			// recycling variables
+			btMprVec3Scale(&d, t);
+			btMprVec3Add(&d, &a);
+			dist = btMprVec3Len2(&d);
+		}
+	}
+
+	return dist;
+}
+
+inline float btMprVec3PointTriDist2(const btVector3 *P,
+									const btVector3 *x0, const btVector3 *B,
+									const btVector3 *C,
+									btVector3 *witness)
+{
+	// Computation comes from analytic expression for triangle (x0, B, C)
+	//      T(s, t) = x0 + s.d1 + t.d2, where d1 = B - x0 and d2 = C - x0 and
+	// Then equation for distance is:
+	//      D(s, t) = | T(s, t) - P |^2
+	// This leads to minimization of quadratic function of two variables.
+	// The solution from is taken only if s is between 0 and 1, t is
+	// between 0 and 1 and t + s < 1, otherwise distance from segment is
+	// computed.
+
+	btVector3 d1, d2, a;
+	float u, v, w, p, q, r;
+	float s, t, dist, dist2;
+	btVector3 witness2;
+
+	btMprVec3Sub2(&d1, B, x0);
+	btMprVec3Sub2(&d2, C, x0);
+	btMprVec3Sub2(&a, x0, P);
+
+	u = btMprVec3Dot(&a, &a);
+	v = btMprVec3Dot(&d1, &d1);
+	w = btMprVec3Dot(&d2, &d2);
+	p = btMprVec3Dot(&a, &d1);
+	q = btMprVec3Dot(&a, &d2);
+	r = btMprVec3Dot(&d1, &d2);
+
+	btScalar div = (w * v - r * r);
+	if (btMprIsZero(div))
+	{
+		s = -1;
+	}
+	else
+	{
+		s = (q * r - w * p) / div;
+		t = (-s * r - q) / w;
+	}
+
+	if ((btMprIsZero(s) || s > 0.f) && (btMprEq(s, 1.f) || s < 1.f) && (btMprIsZero(t) || t > 0.f) && (btMprEq(t, 1.f) || t < 1.f) && (btMprEq(t + s, 1.f) || t + s < 1.f))
+	{
+		if (witness)
+		{
+			btMprVec3Scale(&d1, s);
+			btMprVec3Scale(&d2, t);
+			btMprVec3Copy(witness, x0);
+			btMprVec3Add(witness, &d1);
+			btMprVec3Add(witness, &d2);
+
+			dist = btMprVec3Dist2(witness, P);
+		}
+		else
+		{
+			dist = s * s * v;
+			dist += t * t * w;
+			dist += 2.f * s * t * r;
+			dist += 2.f * s * p;
+			dist += 2.f * t * q;
+			dist += u;
+		}
+	}
+	else
+	{
+		dist = _btMprVec3PointSegmentDist2(P, x0, B, witness);
+
+		dist2 = _btMprVec3PointSegmentDist2(P, x0, C, &witness2);
+		if (dist2 < dist)
+		{
+			dist = dist2;
+			if (witness)
+				btMprVec3Copy(witness, &witness2);
+		}
+
+		dist2 = _btMprVec3PointSegmentDist2(P, B, C, &witness2);
+		if (dist2 < dist)
+		{
+			dist = dist2;
+			if (witness)
+				btMprVec3Copy(witness, &witness2);
+		}
+	}
+
+	return dist;
+}
+
+template <typename btConvexTemplate>
+static void btFindPenetr(const btConvexTemplate &a, const btConvexTemplate &b,
+						 const btMprCollisionDescription &colDesc,
+						 btMprSimplex_t *portal,
+						 float *depth, btVector3 *pdir, btVector3 *pos)
+{
+	btVector3 dir;
+	btMprSupport_t v4;
+	unsigned long iterations;
+
+	btVector3 zero = btVector3(0, 0, 0);
+	btVector3 *origin = &zero;
+
+	iterations = 1UL;
+	for (int i = 0; i < BT_MPR_MAX_ITERATIONS; i++)
+	//while (1)
+	{
+		// compute portal direction and obtain next support point
+		btPortalDir(portal, &dir);
+
+		btMprSupport(a, b, colDesc, dir, &v4);
+
+		// reached tolerance -> find penetration info
+		if (portalReachTolerance(portal, &v4, &dir) || iterations == BT_MPR_MAX_ITERATIONS)
+		{
+			*depth = btMprVec3PointTriDist2(origin, &btMprSimplexPoint(portal, 1)->v, &btMprSimplexPoint(portal, 2)->v, &btMprSimplexPoint(portal, 3)->v, pdir);
+			*depth = BT_MPR_SQRT(*depth);
+
+			if (btMprIsZero((*pdir).x()) && btMprIsZero((*pdir).y()) && btMprIsZero((*pdir).z()))
+			{
+				*pdir = dir;
+			}
+			btMprVec3Normalize(pdir);
+
+			// barycentric coordinates:
+			btFindPos(portal, pos);
+
+			return;
+		}
+
+		btExpandPortal(portal, &v4);
+
+		iterations++;
+	}
+}
+
+static void btFindPenetrTouch(btMprSimplex_t *portal, float *depth, btVector3 *dir, btVector3 *pos)
+{
+	// Touching contact on portal's v1 - so depth is zero and direction
+	// is unimportant and pos can be guessed
+	*depth = 0.f;
+	btVector3 zero = btVector3(0, 0, 0);
+	btVector3 *origin = &zero;
+
+	btMprVec3Copy(dir, origin);
+#ifdef MPR_AVERAGE_CONTACT_POSITIONS
+	btMprVec3Copy(pos, &btMprSimplexPoint(portal, 1)->v1);
+	btMprVec3Add(pos, &btMprSimplexPoint(portal, 1)->v2);
+	btMprVec3Scale(pos, 0.5);
+#else
+	btMprVec3Copy(pos, &btMprSimplexPoint(portal, 1)->v2);
+#endif
+}
+
+static void btFindPenetrSegment(btMprSimplex_t *portal,
+								float *depth, btVector3 *dir, btVector3 *pos)
+{
+	// Origin lies on v0-v1 segment.
+	// Depth is distance to v1, direction also and position must be
+	// computed
+#ifdef MPR_AVERAGE_CONTACT_POSITIONS
+	btMprVec3Copy(pos, &btMprSimplexPoint(portal, 1)->v1);
+	btMprVec3Add(pos, &btMprSimplexPoint(portal, 1)->v2);
+	btMprVec3Scale(pos, 0.5f);
+#else
+	btMprVec3Copy(pos, &btMprSimplexPoint(portal, 1)->v2);
+#endif  //MPR_AVERAGE_CONTACT_POSITIONS
+
+	btMprVec3Copy(dir, &btMprSimplexPoint(portal, 1)->v);
+	*depth = BT_MPR_SQRT(btMprVec3Len2(dir));
+	btMprVec3Normalize(dir);
+}
+
+template <typename btConvexTemplate>
+inline int btMprPenetration(const btConvexTemplate &a, const btConvexTemplate &b,
+							const btMprCollisionDescription &colDesc,
+							float *depthOut, btVector3 *dirOut, btVector3 *posOut)
+{
+	btMprSimplex_t portal;
+
+	// Phase 1: Portal discovery
+	int result = btDiscoverPortal(a, b, colDesc, &portal);
+
+	//sepAxis[pairIndex] = *pdir;//or -dir?
+
+	switch (result)
+	{
+		case 0:
+		{
+			// Phase 2: Portal refinement
+
+			result = btRefinePortal(a, b, colDesc, &portal);
+			if (result < 0)
+				return -1;
+
+			// Phase 3. Penetration info
+			btFindPenetr(a, b, colDesc, &portal, depthOut, dirOut, posOut);
+
+			break;
+		}
+		case 1:
+		{
+			// Touching contact on portal's v1.
+			btFindPenetrTouch(&portal, depthOut, dirOut, posOut);
+			result = 0;
+			break;
+		}
+		case 2:
+		{
+			btFindPenetrSegment(&portal, depthOut, dirOut, posOut);
+			result = 0;
+			break;
+		}
+		default:
+		{
+			//if (res < 0)
+			//{
+			// Origin isn't inside portal - no collision.
+			result = -1;
+			//}
+		}
+	};
+
+	return result;
+};
+
+template <typename btConvexTemplate, typename btMprDistanceTemplate>
+inline int btComputeMprPenetration(const btConvexTemplate &a, const btConvexTemplate &b, const btMprCollisionDescription &colDesc, btMprDistanceTemplate *distInfo)
+{
+	btVector3 dir, pos;
+	float depth;
+
+	int res = btMprPenetration(a, b, colDesc, &depth, &dir, &pos);
+	if (res == 0)
+	{
+		distInfo->m_distance = -depth;
+		distInfo->m_pointOnB = pos;
+		distInfo->m_normalBtoA = -dir;
+		distInfo->m_pointOnA = pos - distInfo->m_distance * dir;
+		return 0;
+	}
+
+	return -1;
+}
+
+#endif  //BT_MPR_PENETRATION_H
diff --git a/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btPersistentManifold.h b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btPersistentManifold.h
new file mode 100644
index 00000000..0e26da0e
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btPersistentManifold.h
@@ -0,0 +1,374 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_PERSISTENT_MANIFOLD_H
+#define BT_PERSISTENT_MANIFOLD_H
+
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btTransform.h"
+#include "btManifoldPoint.h"
+class btCollisionObject;
+#include "LinearMath/btAlignedAllocator.h"
+
+struct btCollisionResult;
+struct btCollisionObjectDoubleData;
+struct btCollisionObjectFloatData;
+
+///maximum contact breaking and merging threshold
+extern btScalar gContactBreakingThreshold;
+
+#ifndef SWIG
+class btPersistentManifold;
+
+typedef bool (*ContactDestroyedCallback)(void* userPersistentData);
+typedef bool (*ContactProcessedCallback)(btManifoldPoint& cp, void* body0, void* body1);
+typedef void (*ContactStartedCallback)(btPersistentManifold* const& manifold);
+typedef void (*ContactEndedCallback)(btPersistentManifold* const& manifold);
+extern ContactDestroyedCallback gContactDestroyedCallback;
+extern ContactProcessedCallback gContactProcessedCallback;
+extern ContactStartedCallback gContactStartedCallback;
+extern ContactEndedCallback gContactEndedCallback;
+#endif  //SWIG
+
+//the enum starts at 1024 to avoid type conflicts with btTypedConstraint
+enum btContactManifoldTypes
+{
+	MIN_CONTACT_MANIFOLD_TYPE = 1024,
+	BT_PERSISTENT_MANIFOLD_TYPE
+};
+
+#define MANIFOLD_CACHE_SIZE 4
+
+///btPersistentManifold is a contact point cache, it stays persistent as long as objects are overlapping in the broadphase.
+///Those contact points are created by the collision narrow phase.
+///The cache can be empty, or hold 1,2,3 or 4 points. Some collision algorithms (GJK) might only add one point at a time.
+///updates/refreshes old contact points, and throw them away if necessary (distance becomes too large)
+///reduces the cache to 4 points, when more then 4 points are added, using following rules:
+///the contact point with deepest penetration is always kept, and it tries to maximuze the area covered by the points
+///note that some pairs of objects might have more then one contact manifold.
+
+//ATTRIBUTE_ALIGNED128( class) btPersistentManifold : public btTypedObject
+ATTRIBUTE_ALIGNED16(class)
+btPersistentManifold : public btTypedObject
+{
+	btManifoldPoint m_pointCache[MANIFOLD_CACHE_SIZE];
+
+	/// this two body pointers can point to the physics rigidbody class.
+	const btCollisionObject* m_body0;
+	const btCollisionObject* m_body1;
+
+	int m_cachedPoints;
+
+	btScalar m_contactBreakingThreshold;
+	btScalar m_contactProcessingThreshold;
+
+	/// sort cached points so most isolated points come first
+	int sortCachedPoints(const btManifoldPoint& pt);
+
+	int findContactPoint(const btManifoldPoint* unUsed, int numUnused, const btManifoldPoint& pt);
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	int m_companionIdA;
+	int m_companionIdB;
+
+	int m_index1a;
+
+	btPersistentManifold();
+
+	btPersistentManifold(const btCollisionObject* body0, const btCollisionObject* body1, int, btScalar contactBreakingThreshold, btScalar contactProcessingThreshold)
+		: btTypedObject(BT_PERSISTENT_MANIFOLD_TYPE),
+		  m_body0(body0),
+		  m_body1(body1),
+		  m_cachedPoints(0),
+		  m_contactBreakingThreshold(contactBreakingThreshold),
+		  m_contactProcessingThreshold(contactProcessingThreshold),
+		  m_companionIdA(0),
+		  m_companionIdB(0),
+		  m_index1a(0)
+	{
+	}
+
+	SIMD_FORCE_INLINE const btCollisionObject* getBody0() const { return m_body0; }
+	SIMD_FORCE_INLINE const btCollisionObject* getBody1() const { return m_body1; }
+
+	void setBodies(const btCollisionObject* body0, const btCollisionObject* body1)
+	{
+		m_body0 = body0;
+		m_body1 = body1;
+	}
+
+	void clearUserCache(btManifoldPoint & pt);
+
+#ifdef DEBUG_PERSISTENCY
+	void DebugPersistency();
+#endif  //
+
+	SIMD_FORCE_INLINE int getNumContacts() const
+	{
+		return m_cachedPoints;
+	}
+	/// the setNumContacts API is usually not used, except when you gather/fill all contacts manually
+	void setNumContacts(int cachedPoints)
+	{
+		m_cachedPoints = cachedPoints;
+	}
+
+	SIMD_FORCE_INLINE const btManifoldPoint& getContactPoint(int index) const
+	{
+		btAssert(index < m_cachedPoints);
+		return m_pointCache[index];
+	}
+
+	SIMD_FORCE_INLINE btManifoldPoint& getContactPoint(int index)
+	{
+		btAssert(index < m_cachedPoints);
+		return m_pointCache[index];
+	}
+
+	///@todo: get this margin from the current physics / collision environment
+	btScalar getContactBreakingThreshold() const;
+
+	btScalar getContactProcessingThreshold() const
+	{
+		return m_contactProcessingThreshold;
+	}
+
+	void setContactBreakingThreshold(btScalar contactBreakingThreshold)
+	{
+		m_contactBreakingThreshold = contactBreakingThreshold;
+	}
+
+	void setContactProcessingThreshold(btScalar contactProcessingThreshold)
+	{
+		m_contactProcessingThreshold = contactProcessingThreshold;
+	}
+
+	int getCacheEntry(const btManifoldPoint& newPoint) const;
+
+	int addManifoldPoint(const btManifoldPoint& newPoint, bool isPredictive = false);
+
+	void removeContactPoint(int index)
+	{
+		clearUserCache(m_pointCache[index]);
+
+		int lastUsedIndex = getNumContacts() - 1;
+		//		m_pointCache[index] = m_pointCache[lastUsedIndex];
+		if (index != lastUsedIndex)
+		{
+			m_pointCache[index] = m_pointCache[lastUsedIndex];
+			//get rid of duplicated userPersistentData pointer
+			m_pointCache[lastUsedIndex].m_userPersistentData = 0;
+			m_pointCache[lastUsedIndex].m_appliedImpulse = 0.f;
+			m_pointCache[lastUsedIndex].m_prevRHS = 0.f;
+			m_pointCache[lastUsedIndex].m_contactPointFlags = 0;
+			m_pointCache[lastUsedIndex].m_appliedImpulseLateral1 = 0.f;
+			m_pointCache[lastUsedIndex].m_appliedImpulseLateral2 = 0.f;
+			m_pointCache[lastUsedIndex].m_lifeTime = 0;
+		}
+
+		btAssert(m_pointCache[lastUsedIndex].m_userPersistentData == 0);
+		m_cachedPoints--;
+
+		if (gContactEndedCallback && m_cachedPoints == 0)
+		{
+			gContactEndedCallback(this);
+		}
+	}
+	void replaceContactPoint(const btManifoldPoint& newPoint, int insertIndex)
+	{
+		btAssert(validContactDistance(newPoint));
+
+#define MAINTAIN_PERSISTENCY 1
+#ifdef MAINTAIN_PERSISTENCY
+		int lifeTime = m_pointCache[insertIndex].getLifeTime();
+		btScalar appliedImpulse = m_pointCache[insertIndex].m_appliedImpulse;
+		btScalar prevRHS = m_pointCache[insertIndex].m_prevRHS;
+		btScalar appliedLateralImpulse1 = m_pointCache[insertIndex].m_appliedImpulseLateral1;
+		btScalar appliedLateralImpulse2 = m_pointCache[insertIndex].m_appliedImpulseLateral2;
+
+		bool replacePoint = true;
+		///we keep existing contact points for friction anchors
+		///if the friction force is within the Coulomb friction cone
+		if (newPoint.m_contactPointFlags & BT_CONTACT_FLAG_FRICTION_ANCHOR)
+		{
+			//   printf("appliedImpulse=%f\n", appliedImpulse);
+			//   printf("appliedLateralImpulse1=%f\n", appliedLateralImpulse1);
+			//   printf("appliedLateralImpulse2=%f\n", appliedLateralImpulse2);
+			//   printf("mu = %f\n", m_pointCache[insertIndex].m_combinedFriction);
+			btScalar mu = m_pointCache[insertIndex].m_combinedFriction;
+			btScalar eps = 0;  //we could allow to enlarge or shrink the tolerance to check against the friction cone a bit, say 1e-7
+			btScalar a = appliedLateralImpulse1 * appliedLateralImpulse1 + appliedLateralImpulse2 * appliedLateralImpulse2;
+			btScalar b = eps + mu * appliedImpulse;
+			b = b * b;
+			replacePoint = (a) > (b);
+		}
+
+		if (replacePoint)
+		{
+			btAssert(lifeTime >= 0);
+			void* cache = m_pointCache[insertIndex].m_userPersistentData;
+
+			m_pointCache[insertIndex] = newPoint;
+			m_pointCache[insertIndex].m_userPersistentData = cache;
+			m_pointCache[insertIndex].m_appliedImpulse = appliedImpulse;
+			m_pointCache[insertIndex].m_prevRHS = prevRHS;
+			m_pointCache[insertIndex].m_appliedImpulseLateral1 = appliedLateralImpulse1;
+			m_pointCache[insertIndex].m_appliedImpulseLateral2 = appliedLateralImpulse2;
+		}
+
+		m_pointCache[insertIndex].m_lifeTime = lifeTime;
+#else
+		clearUserCache(m_pointCache[insertIndex]);
+		m_pointCache[insertIndex] = newPoint;
+
+#endif
+	}
+
+	bool validContactDistance(const btManifoldPoint& pt) const
+	{
+		return pt.m_distance1 <= getContactBreakingThreshold();
+	}
+	/// calculated new worldspace coordinates and depth, and reject points that exceed the collision margin
+	void refreshContactPoints(const btTransform& trA, const btTransform& trB);
+
+	SIMD_FORCE_INLINE void clearManifold()
+	{
+		int i;
+		for (i = 0; i < m_cachedPoints; i++)
+		{
+			clearUserCache(m_pointCache[i]);
+		}
+
+		if (gContactEndedCallback && m_cachedPoints)
+		{
+			gContactEndedCallback(this);
+		}
+		m_cachedPoints = 0;
+	}
+
+	int calculateSerializeBufferSize() const;
+	const char* serialize(const class btPersistentManifold* manifold, void* dataBuffer, class btSerializer* serializer) const;
+	void deSerialize(const struct btPersistentManifoldDoubleData* manifoldDataPtr);
+	void deSerialize(const struct btPersistentManifoldFloatData* manifoldDataPtr);
+};
+
+// clang-format off
+
+struct btPersistentManifoldDoubleData
+{
+	btVector3DoubleData m_pointCacheLocalPointA[4];
+	btVector3DoubleData m_pointCacheLocalPointB[4];
+	btVector3DoubleData m_pointCachePositionWorldOnA[4];
+	btVector3DoubleData m_pointCachePositionWorldOnB[4];
+	btVector3DoubleData m_pointCacheNormalWorldOnB[4];
+	btVector3DoubleData	m_pointCacheLateralFrictionDir1[4];
+	btVector3DoubleData	m_pointCacheLateralFrictionDir2[4];
+	double m_pointCacheDistance[4];
+	double m_pointCacheAppliedImpulse[4];
+	double m_pointCachePrevRHS[4];
+	 double m_pointCacheCombinedFriction[4];
+	double m_pointCacheCombinedRollingFriction[4];
+	double m_pointCacheCombinedSpinningFriction[4];
+	double m_pointCacheCombinedRestitution[4];
+	int	m_pointCachePartId0[4];
+	int	m_pointCachePartId1[4];
+	int	m_pointCacheIndex0[4];
+	int	m_pointCacheIndex1[4];
+	int m_pointCacheContactPointFlags[4];
+	double m_pointCacheAppliedImpulseLateral1[4];
+	double m_pointCacheAppliedImpulseLateral2[4];
+	double m_pointCacheContactMotion1[4];
+	double m_pointCacheContactMotion2[4];
+	double m_pointCacheContactCFM[4];
+	double m_pointCacheCombinedContactStiffness1[4];
+	double m_pointCacheContactERP[4];
+	double m_pointCacheCombinedContactDamping1[4];
+	double m_pointCacheFrictionCFM[4];
+	int m_pointCacheLifeTime[4];
+
+	int m_numCachedPoints;
+	int m_companionIdA;
+	int m_companionIdB;
+	int m_index1a;
+
+	int m_objectType;
+	double	m_contactBreakingThreshold;
+	double	m_contactProcessingThreshold;
+	int m_padding;
+
+	btCollisionObjectDoubleData *m_body0;
+	btCollisionObjectDoubleData *m_body1;
+};
+
+
+struct btPersistentManifoldFloatData
+{
+	btVector3FloatData m_pointCacheLocalPointA[4];
+	btVector3FloatData m_pointCacheLocalPointB[4];
+	btVector3FloatData m_pointCachePositionWorldOnA[4];
+	btVector3FloatData m_pointCachePositionWorldOnB[4];
+	btVector3FloatData m_pointCacheNormalWorldOnB[4];
+	btVector3FloatData	m_pointCacheLateralFrictionDir1[4];
+	btVector3FloatData	m_pointCacheLateralFrictionDir2[4];
+	float m_pointCacheDistance[4];
+	float m_pointCacheAppliedImpulse[4];
+	float m_pointCachePrevRHS[4];
+	float m_pointCacheCombinedFriction[4];
+	float m_pointCacheCombinedRollingFriction[4];
+	float m_pointCacheCombinedSpinningFriction[4];
+	float m_pointCacheCombinedRestitution[4];
+	int	m_pointCachePartId0[4];
+	int	m_pointCachePartId1[4];
+	int	m_pointCacheIndex0[4];
+	int	m_pointCacheIndex1[4];
+	int m_pointCacheContactPointFlags[4];
+	float m_pointCacheAppliedImpulseLateral1[4];
+	float m_pointCacheAppliedImpulseLateral2[4];
+	float m_pointCacheContactMotion1[4];
+	float m_pointCacheContactMotion2[4];
+	float m_pointCacheContactCFM[4];
+	float m_pointCacheCombinedContactStiffness1[4];
+	float m_pointCacheContactERP[4];
+	float m_pointCacheCombinedContactDamping1[4];
+	float m_pointCacheFrictionCFM[4];
+	int m_pointCacheLifeTime[4];
+
+	int m_numCachedPoints;
+	int m_companionIdA;
+	int m_companionIdB;
+	int m_index1a;
+
+	int m_objectType;
+	float	m_contactBreakingThreshold;
+	float	m_contactProcessingThreshold;
+	int m_padding;
+
+	btCollisionObjectFloatData *m_body0;
+	btCollisionObjectFloatData *m_body1;
+};
+
+// clang-format on
+
+#ifdef BT_USE_DOUBLE_PRECISION
+#define btPersistentManifoldData btPersistentManifoldDoubleData
+#define btPersistentManifoldDataName "btPersistentManifoldDoubleData"
+#else
+#define btPersistentManifoldData btPersistentManifoldFloatData
+#define btPersistentManifoldDataName "btPersistentManifoldFloatData"
+#endif  //BT_USE_DOUBLE_PRECISION
+
+#endif  //BT_PERSISTENT_MANIFOLD_H
diff --git a/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btPointCollector.h b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btPointCollector.h
new file mode 100644
index 00000000..0900eb6e
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btPointCollector.h
@@ -0,0 +1,58 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_POINT_COLLECTOR_H
+#define BT_POINT_COLLECTOR_H
+
+#include "btDiscreteCollisionDetectorInterface.h"
+
+struct btPointCollector : public btDiscreteCollisionDetectorInterface::Result
+{
+	btVector3 m_normalOnBInWorld;
+	btVector3 m_pointInWorld;
+	btScalar m_distance;  //negative means penetration
+
+	bool m_hasResult;
+
+	btPointCollector()
+		: m_distance(btScalar(BT_LARGE_FLOAT)), m_hasResult(false)
+	{
+	}
+
+	virtual void setShapeIdentifiersA(int partId0, int index0)
+	{
+		(void)partId0;
+		(void)index0;
+	}
+	virtual void setShapeIdentifiersB(int partId1, int index1)
+	{
+		(void)partId1;
+		(void)index1;
+	}
+
+	virtual void addContactPoint(const btVector3& normalOnBInWorld, const btVector3& pointInWorld, btScalar depth)
+	{
+		if (depth < m_distance)
+		{
+			m_hasResult = true;
+			m_normalOnBInWorld = normalOnBInWorld;
+			m_pointInWorld = pointInWorld;
+			//negative means penetration
+			m_distance = depth;
+		}
+	}
+};
+
+#endif  //BT_POINT_COLLECTOR_H
diff --git a/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.h b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.h
new file mode 100644
index 00000000..328f6424
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.h
@@ -0,0 +1,42 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2011 Advanced Micro Devices, Inc.  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+///This file was written by Erwin Coumans
+
+#ifndef BT_POLYHEDRAL_CONTACT_CLIPPING_H
+#define BT_POLYHEDRAL_CONTACT_CLIPPING_H
+
+#include "LinearMath/btAlignedObjectArray.h"
+#include "LinearMath/btTransform.h"
+#include "btDiscreteCollisionDetectorInterface.h"
+
+class btConvexPolyhedron;
+
+typedef btAlignedObjectArray<btVector3> btVertexArray;
+
+// Clips a face to the back of a plane
+struct btPolyhedralContactClipping
+{
+	static void clipHullAgainstHull(const btVector3& separatingNormal1, const btConvexPolyhedron& hullA, const btConvexPolyhedron& hullB, const btTransform& transA, const btTransform& transB, const btScalar minDist, btScalar maxDist, btVertexArray& worldVertsB1, btVertexArray& worldVertsB2, btDiscreteCollisionDetectorInterface::Result& resultOut);
+
+	static void clipFaceAgainstHull(const btVector3& separatingNormal, const btConvexPolyhedron& hullA, const btTransform& transA, btVertexArray& worldVertsB1, btVertexArray& worldVertsB2, const btScalar minDist, btScalar maxDist, btDiscreteCollisionDetectorInterface::Result& resultOut);
+
+	static bool findSeparatingAxis(const btConvexPolyhedron& hullA, const btConvexPolyhedron& hullB, const btTransform& transA, const btTransform& transB, btVector3& sep, btDiscreteCollisionDetectorInterface::Result& resultOut);
+
+	///the clipFace method is used internally
+	static void clipFace(const btVertexArray& pVtxIn, btVertexArray& ppVtxOut, const btVector3& planeNormalWS, btScalar planeEqWS);
+};
+
+#endif  // BT_POLYHEDRAL_CONTACT_CLIPPING_H
diff --git a/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btRaycastCallback.h b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btRaycastCallback.h
new file mode 100644
index 00000000..2d0df718
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btRaycastCallback.h
@@ -0,0 +1,72 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_RAYCAST_TRI_CALLBACK_H
+#define BT_RAYCAST_TRI_CALLBACK_H
+
+#include "BulletCollision/CollisionShapes/btTriangleCallback.h"
+#include "LinearMath/btTransform.h"
+struct btBroadphaseProxy;
+class btConvexShape;
+
+class btTriangleRaycastCallback : public btTriangleCallback
+{
+public:
+	//input
+	btVector3 m_from;
+	btVector3 m_to;
+
+	//@BP Mod - allow backface filtering and unflipped normals
+	enum EFlags
+	{
+		kF_None = 0,
+		kF_FilterBackfaces = 1 << 0,
+		kF_KeepUnflippedNormal = 1 << 1,             // Prevents returned face normal getting flipped when a ray hits a back-facing triangle
+													 ///SubSimplexConvexCastRaytest is the default, even if kF_None is set.
+		kF_UseSubSimplexConvexCastRaytest = 1 << 2,  // Uses an approximate but faster ray versus convex intersection algorithm
+		kF_UseGjkConvexCastRaytest = 1 << 3,
+		kF_DisableHeightfieldAccelerator  = 1 << 4, //don't use the heightfield raycast accelerator. See https://github.com/bulletphysics/bullet3/pull/2062
+		kF_Terminator = 0xFFFFFFFF
+	};
+	unsigned int m_flags;
+
+	btScalar m_hitFraction;
+
+	btTriangleRaycastCallback(const btVector3& from, const btVector3& to, unsigned int flags = 0);
+
+	virtual void processTriangle(btVector3* triangle, int partId, int triangleIndex);
+
+	virtual btScalar reportHit(const btVector3& hitNormalLocal, btScalar hitFraction, int partId, int triangleIndex) = 0;
+};
+
+class btTriangleConvexcastCallback : public btTriangleCallback
+{
+public:
+	const btConvexShape* m_convexShape;
+	btTransform m_convexShapeFrom;
+	btTransform m_convexShapeTo;
+	btTransform m_triangleToWorld;
+	btScalar m_hitFraction;
+	btScalar m_triangleCollisionMargin;
+	btScalar m_allowedPenetration;
+
+	btTriangleConvexcastCallback(const btConvexShape* convexShape, const btTransform& convexShapeFrom, const btTransform& convexShapeTo, const btTransform& triangleToWorld, const btScalar triangleCollisionMargin);
+
+	virtual void processTriangle(btVector3* triangle, int partId, int triangleIndex);
+
+	virtual btScalar reportHit(const btVector3& hitNormalLocal, const btVector3& hitPointLocal, btScalar hitFraction, int partId, int triangleIndex) = 0;
+};
+
+#endif  //BT_RAYCAST_TRI_CALLBACK_H
diff --git a/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btSimplexSolverInterface.h b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btSimplexSolverInterface.h
new file mode 100644
index 00000000..ccd22710
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btSimplexSolverInterface.h
@@ -0,0 +1,58 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SIMPLEX_SOLVER_INTERFACE_H
+#define BT_SIMPLEX_SOLVER_INTERFACE_H
+
+#include "LinearMath/btVector3.h"
+
+#define NO_VIRTUAL_INTERFACE 1
+#ifdef NO_VIRTUAL_INTERFACE
+#include "btVoronoiSimplexSolver.h"
+#define btSimplexSolverInterface btVoronoiSimplexSolver
+#else
+
+/// btSimplexSolverInterface can incrementally calculate distance between origin and up to 4 vertices
+/// Used by GJK or Linear Casting. Can be implemented by the Johnson-algorithm or alternative approaches based on
+/// voronoi regions or barycentric coordinates
+class btSimplexSolverInterface
+{
+public:
+	virtual ~btSimplexSolverInterface(){};
+
+	virtual void reset() = 0;
+
+	virtual void addVertex(const btVector3& w, const btVector3& p, const btVector3& q) = 0;
+
+	virtual bool closest(btVector3& v) = 0;
+
+	virtual btScalar maxVertex() = 0;
+
+	virtual bool fullSimplex() const = 0;
+
+	virtual int getSimplex(btVector3* pBuf, btVector3* qBuf, btVector3* yBuf) const = 0;
+
+	virtual bool inSimplex(const btVector3& w) = 0;
+
+	virtual void backup_closest(btVector3& v) = 0;
+
+	virtual bool emptySimplex() const = 0;
+
+	virtual void compute_points(btVector3& p1, btVector3& p2) = 0;
+
+	virtual int numVertices() const = 0;
+};
+#endif
+#endif  //BT_SIMPLEX_SOLVER_INTERFACE_H
diff --git a/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h
new file mode 100644
index 00000000..0638a30e
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h
@@ -0,0 +1,47 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SUBSIMPLEX_CONVEX_CAST_H
+#define BT_SUBSIMPLEX_CONVEX_CAST_H
+
+#include "btConvexCast.h"
+#include "btSimplexSolverInterface.h"
+class btConvexShape;
+
+/// btSubsimplexConvexCast implements Gino van den Bergens' paper
+///"Ray Casting against bteral Convex Objects with Application to Continuous Collision Detection"
+/// GJK based Ray Cast, optimized version
+/// Objects should not start in overlap, otherwise results are not defined.
+class btSubsimplexConvexCast : public btConvexCast
+{
+	btSimplexSolverInterface* m_simplexSolver;
+	const btConvexShape* m_convexA;
+	const btConvexShape* m_convexB;
+
+public:
+	btSubsimplexConvexCast(const btConvexShape* shapeA, const btConvexShape* shapeB, btSimplexSolverInterface* simplexSolver);
+
+	//virtual ~btSubsimplexConvexCast();
+	///SimsimplexConvexCast calculateTimeOfImpact calculates the time of impact+normal for the linear cast (sweep) between two moving objects.
+	///Precondition is that objects should not penetration/overlap at the start from the interval. Overlap can be tested using btGjkPairDetector.
+	virtual bool calcTimeOfImpact(
+		const btTransform& fromA,
+		const btTransform& toA,
+		const btTransform& fromB,
+		const btTransform& toB,
+		CastResult& result);
+};
+
+#endif  //BT_SUBSIMPLEX_CONVEX_CAST_H
diff --git a/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h
new file mode 100644
index 00000000..24a0a8f2
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h
@@ -0,0 +1,173 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_VORONOI_SIMPLEX_SOLVER_H
+#define BT_VORONOI_SIMPLEX_SOLVER_H
+
+#include "btSimplexSolverInterface.h"
+
+#define VORONOI_SIMPLEX_MAX_VERTS 5
+
+///disable next define, or use defaultCollisionConfiguration->getSimplexSolver()->setEqualVertexThreshold(0.f) to disable/configure
+#define BT_USE_EQUAL_VERTEX_THRESHOLD
+
+#ifdef BT_USE_DOUBLE_PRECISION
+#define VORONOI_DEFAULT_EQUAL_VERTEX_THRESHOLD 1e-12f
+#else
+#define VORONOI_DEFAULT_EQUAL_VERTEX_THRESHOLD 0.0001f
+#endif  //BT_USE_DOUBLE_PRECISION
+
+struct btUsageBitfield
+{
+	btUsageBitfield()
+	{
+		reset();
+	}
+
+	void reset()
+	{
+		usedVertexA = false;
+		usedVertexB = false;
+		usedVertexC = false;
+		usedVertexD = false;
+	}
+	unsigned short usedVertexA : 1;
+	unsigned short usedVertexB : 1;
+	unsigned short usedVertexC : 1;
+	unsigned short usedVertexD : 1;
+	unsigned short unused1 : 1;
+	unsigned short unused2 : 1;
+	unsigned short unused3 : 1;
+	unsigned short unused4 : 1;
+};
+
+struct btSubSimplexClosestResult
+{
+	btVector3 m_closestPointOnSimplex;
+	//MASK for m_usedVertices
+	//stores the simplex vertex-usage, using the MASK,
+	// if m_usedVertices & MASK then the related vertex is used
+	btUsageBitfield m_usedVertices;
+	btScalar m_barycentricCoords[4];
+	bool m_degenerate;
+
+	void reset()
+	{
+		m_degenerate = false;
+		setBarycentricCoordinates();
+		m_usedVertices.reset();
+	}
+	bool isValid()
+	{
+		bool valid = (m_barycentricCoords[0] >= btScalar(0.)) &&
+					 (m_barycentricCoords[1] >= btScalar(0.)) &&
+					 (m_barycentricCoords[2] >= btScalar(0.)) &&
+					 (m_barycentricCoords[3] >= btScalar(0.));
+
+		return valid;
+	}
+	void setBarycentricCoordinates(btScalar a = btScalar(0.), btScalar b = btScalar(0.), btScalar c = btScalar(0.), btScalar d = btScalar(0.))
+	{
+		m_barycentricCoords[0] = a;
+		m_barycentricCoords[1] = b;
+		m_barycentricCoords[2] = c;
+		m_barycentricCoords[3] = d;
+	}
+};
+
+/// btVoronoiSimplexSolver is an implementation of the closest point distance algorithm from a 1-4 points simplex to the origin.
+/// Can be used with GJK, as an alternative to Johnson distance algorithm.
+#ifdef NO_VIRTUAL_INTERFACE
+ATTRIBUTE_ALIGNED16(class)
+btVoronoiSimplexSolver
+#else
+ATTRIBUTE_ALIGNED16(class)
+btVoronoiSimplexSolver : public btSimplexSolverInterface
+#endif
+{
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	int m_numVertices;
+
+	btVector3 m_simplexVectorW[VORONOI_SIMPLEX_MAX_VERTS];
+	btVector3 m_simplexPointsP[VORONOI_SIMPLEX_MAX_VERTS];
+	btVector3 m_simplexPointsQ[VORONOI_SIMPLEX_MAX_VERTS];
+
+	btVector3 m_cachedP1;
+	btVector3 m_cachedP2;
+	btVector3 m_cachedV;
+	btVector3 m_lastW;
+
+	btScalar m_equalVertexThreshold;
+	bool m_cachedValidClosest;
+
+	btSubSimplexClosestResult m_cachedBC;
+
+	bool m_needsUpdate;
+
+	void removeVertex(int index);
+	void reduceVertices(const btUsageBitfield& usedVerts);
+	bool updateClosestVectorAndPoints();
+
+	bool closestPtPointTetrahedron(const btVector3& p, const btVector3& a, const btVector3& b, const btVector3& c, const btVector3& d, btSubSimplexClosestResult& finalResult);
+	int pointOutsideOfPlane(const btVector3& p, const btVector3& a, const btVector3& b, const btVector3& c, const btVector3& d);
+	bool closestPtPointTriangle(const btVector3& p, const btVector3& a, const btVector3& b, const btVector3& c, btSubSimplexClosestResult& result);
+
+public:
+	btVoronoiSimplexSolver()
+		: m_equalVertexThreshold(VORONOI_DEFAULT_EQUAL_VERTEX_THRESHOLD)
+	{
+	}
+	void reset();
+
+	void addVertex(const btVector3& w, const btVector3& p, const btVector3& q);
+
+	void setEqualVertexThreshold(btScalar threshold)
+	{
+		m_equalVertexThreshold = threshold;
+	}
+
+	btScalar getEqualVertexThreshold() const
+	{
+		return m_equalVertexThreshold;
+	}
+
+	bool closest(btVector3 & v);
+
+	btScalar maxVertex();
+
+	bool fullSimplex() const
+	{
+		return (m_numVertices == 4);
+	}
+
+	int getSimplex(btVector3 * pBuf, btVector3 * qBuf, btVector3 * yBuf) const;
+
+	bool inSimplex(const btVector3& w);
+
+	void backup_closest(btVector3 & v);
+
+	bool emptySimplex() const;
+
+	void compute_points(btVector3 & p1, btVector3 & p2);
+
+	int numVertices() const
+	{
+		return m_numVertices;
+	}
+};
+
+#endif  //BT_VORONOI_SIMPLEX_SOLVER_H
diff --git a/engine/inc/bullet/BulletCollision/btBulletCollisionCommon.h b/engine/inc/bullet/BulletCollision/btBulletCollisionCommon.h
new file mode 100644
index 00000000..4f523756
--- /dev/null
+++ b/engine/inc/bullet/BulletCollision/btBulletCollisionCommon.h
@@ -0,0 +1,65 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BULLET_COLLISION_COMMON_H
+#define BULLET_COLLISION_COMMON_H
+
+///Common headerfile includes for Bullet Collision Detection
+
+///Bullet's btCollisionWorld and btCollisionObject definitions
+#include "BulletCollision/CollisionDispatch/btCollisionWorld.h"
+#include "BulletCollision/CollisionDispatch/btCollisionObject.h"
+
+///Collision Shapes
+#include "BulletCollision/CollisionShapes/btBoxShape.h"
+#include "BulletCollision/CollisionShapes/btSphereShape.h"
+#include "BulletCollision/CollisionShapes/btCapsuleShape.h"
+#include "BulletCollision/CollisionShapes/btCylinderShape.h"
+#include "BulletCollision/CollisionShapes/btConeShape.h"
+#include "BulletCollision/CollisionShapes/btStaticPlaneShape.h"
+#include "BulletCollision/CollisionShapes/btConvexHullShape.h"
+#include "BulletCollision/CollisionShapes/btTriangleMesh.h"
+#include "BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h"
+#include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h"
+#include "BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h"
+#include "BulletCollision/CollisionShapes/btTriangleMeshShape.h"
+#include "BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h"
+#include "BulletCollision/CollisionShapes/btCompoundShape.h"
+#include "BulletCollision/CollisionShapes/btTetrahedronShape.h"
+#include "BulletCollision/CollisionShapes/btEmptyShape.h"
+#include "BulletCollision/CollisionShapes/btMultiSphereShape.h"
+#include "BulletCollision/CollisionShapes/btUniformScalingShape.h"
+
+///Narrowphase Collision Detector
+#include "BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h"
+
+//#include "BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h"
+#include "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h"
+
+///Dispatching and generation of collision pairs (broadphase)
+#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h"
+#include "BulletCollision/BroadphaseCollision/btSimpleBroadphase.h"
+#include "BulletCollision/BroadphaseCollision/btAxisSweep3.h"
+#include "BulletCollision/BroadphaseCollision/btDbvtBroadphase.h"
+
+///Math library & Utils
+#include "LinearMath/btQuaternion.h"
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btDefaultMotionState.h"
+#include "LinearMath/btQuickprof.h"
+#include "LinearMath/btIDebugDraw.h"
+#include "LinearMath/btSerializer.h"
+
+#endif  //BULLET_COLLISION_COMMON_H
diff --git a/engine/inc/bullet/BulletDynamics/Character/btCharacterControllerInterface.h b/engine/inc/bullet/BulletDynamics/Character/btCharacterControllerInterface.h
new file mode 100644
index 00000000..2ccf317b
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/Character/btCharacterControllerInterface.h
@@ -0,0 +1,46 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2008 Erwin Coumans  http://bulletphysics.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_CHARACTER_CONTROLLER_INTERFACE_H
+#define BT_CHARACTER_CONTROLLER_INTERFACE_H
+
+#include "LinearMath/btVector3.h"
+#include "BulletDynamics/Dynamics/btActionInterface.h"
+
+class btCollisionShape;
+class btRigidBody;
+class btCollisionWorld;
+
+class btCharacterControllerInterface : public btActionInterface
+{
+public:
+	btCharacterControllerInterface(){};
+	virtual ~btCharacterControllerInterface(){};
+
+	virtual void setWalkDirection(const btVector3& walkDirection) = 0;
+	virtual void setVelocityForTimeInterval(const btVector3& velocity, btScalar timeInterval) = 0;
+	virtual void reset(btCollisionWorld* collisionWorld) = 0;
+	virtual void warp(const btVector3& origin) = 0;
+
+	virtual void preStep(btCollisionWorld* collisionWorld) = 0;
+	virtual void playerStep(btCollisionWorld* collisionWorld, btScalar dt) = 0;
+	virtual bool canJump() const = 0;
+	virtual void jump(const btVector3& dir = btVector3(0, 0, 0)) = 0;
+
+	virtual bool onGround() const = 0;
+	virtual void setUpInterpolate(bool value) = 0;
+};
+
+#endif  //BT_CHARACTER_CONTROLLER_INTERFACE_H
diff --git a/engine/inc/bullet/BulletDynamics/Character/btKinematicCharacterController.h b/engine/inc/bullet/BulletDynamics/Character/btKinematicCharacterController.h
new file mode 100644
index 00000000..ff34fc87
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/Character/btKinematicCharacterController.h
@@ -0,0 +1,200 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2008 Erwin Coumans  http://bulletphysics.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_KINEMATIC_CHARACTER_CONTROLLER_H
+#define BT_KINEMATIC_CHARACTER_CONTROLLER_H
+
+#include "LinearMath/btVector3.h"
+
+#include "btCharacterControllerInterface.h"
+
+#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+
+class btCollisionShape;
+class btConvexShape;
+class btRigidBody;
+class btCollisionWorld;
+class btCollisionDispatcher;
+class btPairCachingGhostObject;
+
+///btKinematicCharacterController is an object that supports a sliding motion in a world.
+///It uses a ghost object and convex sweep test to test for upcoming collisions. This is combined with discrete collision detection to recover from penetrations.
+///Interaction between btKinematicCharacterController and dynamic rigid bodies needs to be explicity implemented by the user.
+ATTRIBUTE_ALIGNED16(class)
+btKinematicCharacterController : public btCharacterControllerInterface
+{
+protected:
+	btScalar m_halfHeight;
+
+	btPairCachingGhostObject* m_ghostObject;
+	btConvexShape* m_convexShape;  //is also in m_ghostObject, but it needs to be convex, so we store it here to avoid upcast
+
+	btScalar m_maxPenetrationDepth;
+	btScalar m_verticalVelocity;
+	btScalar m_verticalOffset;
+	btScalar m_fallSpeed;
+	btScalar m_jumpSpeed;
+	btScalar m_SetjumpSpeed;
+	btScalar m_maxJumpHeight;
+	btScalar m_maxSlopeRadians;  // Slope angle that is set (used for returning the exact value)
+	btScalar m_maxSlopeCosine;   // Cosine equivalent of m_maxSlopeRadians (calculated once when set, for optimization)
+	btScalar m_gravity;
+
+	btScalar m_turnAngle;
+
+	btScalar m_stepHeight;
+
+	btScalar m_addedMargin;  //@todo: remove this and fix the code
+
+	///this is the desired walk direction, set by the user
+	btVector3 m_walkDirection;
+	btVector3 m_normalizedDirection;
+	btVector3 m_AngVel;
+
+	btVector3 m_jumpPosition;
+
+	//some internal variables
+	btVector3 m_currentPosition;
+	btScalar m_currentStepOffset;
+	btVector3 m_targetPosition;
+
+	btQuaternion m_currentOrientation;
+	btQuaternion m_targetOrientation;
+
+	///keep track of the contact manifolds
+	btManifoldArray m_manifoldArray;
+
+	bool m_touchingContact;
+	btVector3 m_touchingNormal;
+
+	btScalar m_linearDamping;
+	btScalar m_angularDamping;
+
+	bool m_wasOnGround;
+	bool m_wasJumping;
+	bool m_useGhostObjectSweepTest;
+	bool m_useWalkDirection;
+	btScalar m_velocityTimeInterval;
+	btVector3 m_up;
+	btVector3 m_jumpAxis;
+
+	static btVector3* getUpAxisDirections();
+	bool m_interpolateUp;
+	bool full_drop;
+	bool bounce_fix;
+
+	btVector3 computeReflectionDirection(const btVector3& direction, const btVector3& normal);
+	btVector3 parallelComponent(const btVector3& direction, const btVector3& normal);
+	btVector3 perpindicularComponent(const btVector3& direction, const btVector3& normal);
+
+	bool recoverFromPenetration(btCollisionWorld * collisionWorld);
+	void stepUp(btCollisionWorld * collisionWorld);
+	void updateTargetPositionBasedOnCollision(const btVector3& hit_normal, btScalar tangentMag = btScalar(0.0), btScalar normalMag = btScalar(1.0));
+	void stepForwardAndStrafe(btCollisionWorld * collisionWorld, const btVector3& walkMove);
+	void stepDown(btCollisionWorld * collisionWorld, btScalar dt);
+
+	virtual bool needsCollision(const btCollisionObject* body0, const btCollisionObject* body1);
+
+	void setUpVector(const btVector3& up);
+
+	btQuaternion getRotation(btVector3 & v0, btVector3 & v1) const;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btKinematicCharacterController(btPairCachingGhostObject * ghostObject, btConvexShape * convexShape, btScalar stepHeight, const btVector3& up = btVector3(1.0, 0.0, 0.0));
+	~btKinematicCharacterController();
+
+	///btActionInterface interface
+	virtual void updateAction(btCollisionWorld * collisionWorld, btScalar deltaTime)
+	{
+		preStep(collisionWorld);
+		playerStep(collisionWorld, deltaTime);
+	}
+
+	///btActionInterface interface
+	void debugDraw(btIDebugDraw * debugDrawer);
+
+	void setUp(const btVector3& up);
+
+	const btVector3& getUp() { return m_up; }
+
+	/// This should probably be called setPositionIncrementPerSimulatorStep.
+	/// This is neither a direction nor a velocity, but the amount to
+	///	increment the position each simulation iteration, regardless
+	///	of dt.
+	/// This call will reset any velocity set by setVelocityForTimeInterval().
+	virtual void setWalkDirection(const btVector3& walkDirection);
+
+	/// Caller provides a velocity with which the character should move for
+	///	the given time period.  After the time period, velocity is reset
+	///	to zero.
+	/// This call will reset any walk direction set by setWalkDirection().
+	/// Negative time intervals will result in no motion.
+	virtual void setVelocityForTimeInterval(const btVector3& velocity,
+											btScalar timeInterval);
+
+	virtual void setAngularVelocity(const btVector3& velocity);
+	virtual const btVector3& getAngularVelocity() const;
+
+	virtual void setLinearVelocity(const btVector3& velocity);
+	virtual btVector3 getLinearVelocity() const;
+
+	void setLinearDamping(btScalar d) { m_linearDamping = btClamped(d, (btScalar)btScalar(0.0), (btScalar)btScalar(1.0)); }
+	btScalar getLinearDamping() const { return m_linearDamping; }
+	void setAngularDamping(btScalar d) { m_angularDamping = btClamped(d, (btScalar)btScalar(0.0), (btScalar)btScalar(1.0)); }
+	btScalar getAngularDamping() const { return m_angularDamping; }
+
+	void reset(btCollisionWorld * collisionWorld);
+	void warp(const btVector3& origin);
+
+	void preStep(btCollisionWorld * collisionWorld);
+	void playerStep(btCollisionWorld * collisionWorld, btScalar dt);
+
+	void setStepHeight(btScalar h);
+	btScalar getStepHeight() const { return m_stepHeight; }
+	void setFallSpeed(btScalar fallSpeed);
+	btScalar getFallSpeed() const { return m_fallSpeed; }
+	void setJumpSpeed(btScalar jumpSpeed);
+	btScalar getJumpSpeed() const { return m_jumpSpeed; }
+	void setMaxJumpHeight(btScalar maxJumpHeight);
+	bool canJump() const;
+
+	void jump(const btVector3& v = btVector3(0, 0, 0));
+
+	void applyImpulse(const btVector3& v) { jump(v); }
+
+	void setGravity(const btVector3& gravity);
+	btVector3 getGravity() const;
+
+	/// The max slope determines the maximum angle that the controller can walk up.
+	/// The slope angle is measured in radians.
+	void setMaxSlope(btScalar slopeRadians);
+	btScalar getMaxSlope() const;
+
+	void setMaxPenetrationDepth(btScalar d);
+	btScalar getMaxPenetrationDepth() const;
+
+	btPairCachingGhostObject* getGhostObject();
+	void setUseGhostSweepTest(bool useGhostObjectSweepTest)
+	{
+		m_useGhostObjectSweepTest = useGhostObjectSweepTest;
+	}
+
+	bool onGround() const;
+	void setUpInterpolate(bool value);
+};
+
+#endif  // BT_KINEMATIC_CHARACTER_CONTROLLER_H
diff --git a/engine/inc/bullet/BulletDynamics/ConstraintSolver/btBatchedConstraints.h b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btBatchedConstraints.h
new file mode 100644
index 00000000..5d982ca3
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btBatchedConstraints.h
@@ -0,0 +1,62 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_BATCHED_CONSTRAINTS_H
+#define BT_BATCHED_CONSTRAINTS_H
+
+#include "LinearMath/btThreads.h"
+#include "LinearMath/btAlignedObjectArray.h"
+#include "BulletDynamics/ConstraintSolver/btSolverBody.h"
+#include "BulletDynamics/ConstraintSolver/btSolverConstraint.h"
+
+class btIDebugDraw;
+
+struct btBatchedConstraints
+{
+	enum BatchingMethod
+	{
+		BATCHING_METHOD_SPATIAL_GRID_2D,
+		BATCHING_METHOD_SPATIAL_GRID_3D,
+		BATCHING_METHOD_COUNT
+	};
+	struct Range
+	{
+		int begin;
+		int end;
+
+		Range() : begin(0), end(0) {}
+		Range(int _beg, int _end) : begin(_beg), end(_end) {}
+	};
+
+	btAlignedObjectArray<int> m_constraintIndices;
+	btAlignedObjectArray<Range> m_batches;        // each batch is a range of indices in the m_constraintIndices array
+	btAlignedObjectArray<Range> m_phases;         // each phase is range of indices in the m_batches array
+	btAlignedObjectArray<char> m_phaseGrainSize;  // max grain size for each phase
+	btAlignedObjectArray<int> m_phaseOrder;       // phases can be done in any order, so we can randomize the order here
+	btIDebugDraw* m_debugDrawer;
+
+	static bool s_debugDrawBatches;
+
+	btBatchedConstraints() { m_debugDrawer = NULL; }
+	void setup(btConstraintArray* constraints,
+			   const btAlignedObjectArray<btSolverBody>& bodies,
+			   BatchingMethod batchingMethod,
+			   int minBatchSize,
+			   int maxBatchSize,
+			   btAlignedObjectArray<char>* scratchMemory);
+	bool validate(btConstraintArray* constraints, const btAlignedObjectArray<btSolverBody>& bodies) const;
+};
+
+#endif  // BT_BATCHED_CONSTRAINTS_H
diff --git a/engine/inc/bullet/BulletDynamics/ConstraintSolver/btConeTwistConstraint.h b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btConeTwistConstraint.h
new file mode 100644
index 00000000..64f44df1
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btConeTwistConstraint.h
@@ -0,0 +1,423 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+btConeTwistConstraint is Copyright (c) 2007 Starbreeze Studios
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+
+Written by: Marcus Hennix
+*/
+
+/*
+Overview:
+
+btConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc).
+It is a fixed translation, 3 degree-of-freedom (DOF) rotational "joint".
+It divides the 3 rotational DOFs into swing (movement within a cone) and twist.
+Swing is divided into swing1 and swing2 which can have different limits, giving an elliptical shape.
+(Note: the cone's base isn't flat, so this ellipse is "embedded" on the surface of a sphere.)
+
+In the contraint's frame of reference:
+twist is along the x-axis,
+and swing 1 and 2 are along the z and y axes respectively.
+*/
+
+#ifndef BT_CONETWISTCONSTRAINT_H
+#define BT_CONETWISTCONSTRAINT_H
+
+#include "LinearMath/btVector3.h"
+#include "btJacobianEntry.h"
+#include "btTypedConstraint.h"
+
+#ifdef BT_USE_DOUBLE_PRECISION
+#define btConeTwistConstraintData2 btConeTwistConstraintDoubleData
+#define btConeTwistConstraintDataName "btConeTwistConstraintDoubleData"
+#else
+#define btConeTwistConstraintData2 btConeTwistConstraintData
+#define btConeTwistConstraintDataName "btConeTwistConstraintData"
+#endif  //BT_USE_DOUBLE_PRECISION
+
+class btRigidBody;
+
+enum btConeTwistFlags
+{
+	BT_CONETWIST_FLAGS_LIN_CFM = 1,
+	BT_CONETWIST_FLAGS_LIN_ERP = 2,
+	BT_CONETWIST_FLAGS_ANG_CFM = 4
+};
+
+///btConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc)
+ATTRIBUTE_ALIGNED16(class)
+btConeTwistConstraint : public btTypedConstraint
+{
+#ifdef IN_PARALLELL_SOLVER
+public:
+#endif
+	btJacobianEntry m_jac[3];  //3 orthogonal linear constraints
+
+	btTransform m_rbAFrame;
+	btTransform m_rbBFrame;
+
+	btScalar m_limitSoftness;
+	btScalar m_biasFactor;
+	btScalar m_relaxationFactor;
+
+	btScalar m_damping;
+
+	btScalar m_swingSpan1;
+	btScalar m_swingSpan2;
+	btScalar m_twistSpan;
+
+	btScalar m_fixThresh;
+
+	btVector3 m_swingAxis;
+	btVector3 m_twistAxis;
+
+	btScalar m_kSwing;
+	btScalar m_kTwist;
+
+	btScalar m_twistLimitSign;
+	btScalar m_swingCorrection;
+	btScalar m_twistCorrection;
+
+	btScalar m_twistAngle;
+
+	btScalar m_accSwingLimitImpulse;
+	btScalar m_accTwistLimitImpulse;
+
+	bool m_angularOnly;
+	bool m_solveTwistLimit;
+	bool m_solveSwingLimit;
+
+	bool m_useSolveConstraintObsolete;
+
+	// not yet used...
+	btScalar m_swingLimitRatio;
+	btScalar m_twistLimitRatio;
+	btVector3 m_twistAxisA;
+
+	// motor
+	bool m_bMotorEnabled;
+	bool m_bNormalizedMotorStrength;
+	btQuaternion m_qTarget;
+	btScalar m_maxMotorImpulse;
+	btVector3 m_accMotorImpulse;
+
+	// parameters
+	int m_flags;
+	btScalar m_linCFM;
+	btScalar m_linERP;
+	btScalar m_angCFM;
+
+protected:
+	void init();
+
+	void computeConeLimitInfo(const btQuaternion& qCone,                                           // in
+							  btScalar& swingAngle, btVector3& vSwingAxis, btScalar& swingLimit);  // all outs
+
+	void computeTwistLimitInfo(const btQuaternion& qTwist,                    // in
+							   btScalar& twistAngle, btVector3& vTwistAxis);  // all outs
+
+	void adjustSwingAxisToUseEllipseNormal(btVector3 & vSwingAxis) const;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btConeTwistConstraint(btRigidBody & rbA, btRigidBody & rbB, const btTransform& rbAFrame, const btTransform& rbBFrame);
+
+	btConeTwistConstraint(btRigidBody & rbA, const btTransform& rbAFrame);
+
+	virtual void buildJacobian();
+
+	virtual void getInfo1(btConstraintInfo1 * info);
+
+	void getInfo1NonVirtual(btConstraintInfo1 * info);
+
+	virtual void getInfo2(btConstraintInfo2 * info);
+
+	void getInfo2NonVirtual(btConstraintInfo2 * info, const btTransform& transA, const btTransform& transB, const btMatrix3x3& invInertiaWorldA, const btMatrix3x3& invInertiaWorldB);
+
+	virtual void solveConstraintObsolete(btSolverBody & bodyA, btSolverBody & bodyB, btScalar timeStep);
+
+	void updateRHS(btScalar timeStep);
+
+	const btRigidBody& getRigidBodyA() const
+	{
+		return m_rbA;
+	}
+	const btRigidBody& getRigidBodyB() const
+	{
+		return m_rbB;
+	}
+
+	void setAngularOnly(bool angularOnly)
+	{
+		m_angularOnly = angularOnly;
+	}
+
+	bool getAngularOnly() const
+	{
+		return m_angularOnly;
+	}
+
+	void setLimit(int limitIndex, btScalar limitValue)
+	{
+		switch (limitIndex)
+		{
+			case 3:
+			{
+				m_twistSpan = limitValue;
+				break;
+			}
+			case 4:
+			{
+				m_swingSpan2 = limitValue;
+				break;
+			}
+			case 5:
+			{
+				m_swingSpan1 = limitValue;
+				break;
+			}
+			default:
+			{
+			}
+		};
+	}
+
+	btScalar getLimit(int limitIndex) const
+	{
+		switch (limitIndex)
+		{
+			case 3:
+			{
+				return m_twistSpan;
+				break;
+			}
+			case 4:
+			{
+				return m_swingSpan2;
+				break;
+			}
+			case 5:
+			{
+				return m_swingSpan1;
+				break;
+			}
+			default:
+			{
+				btAssert(0 && "Invalid limitIndex specified for btConeTwistConstraint");
+				return 0.0;
+			}
+		};
+	}
+
+	// setLimit(), a few notes:
+	// _softness:
+	//		0->1, recommend ~0.8->1.
+	//		describes % of limits where movement is free.
+	//		beyond this softness %, the limit is gradually enforced until the "hard" (1.0) limit is reached.
+	// _biasFactor:
+	//		0->1?, recommend 0.3 +/-0.3 or so.
+	//		strength with which constraint resists zeroth order (angular, not angular velocity) limit violation.
+	// __relaxationFactor:
+	//		0->1, recommend to stay near 1.
+	//		the lower the value, the less the constraint will fight velocities which violate the angular limits.
+	void setLimit(btScalar _swingSpan1, btScalar _swingSpan2, btScalar _twistSpan, btScalar _softness = 1.f, btScalar _biasFactor = 0.3f, btScalar _relaxationFactor = 1.0f)
+	{
+		m_swingSpan1 = _swingSpan1;
+		m_swingSpan2 = _swingSpan2;
+		m_twistSpan = _twistSpan;
+
+		m_limitSoftness = _softness;
+		m_biasFactor = _biasFactor;
+		m_relaxationFactor = _relaxationFactor;
+	}
+
+	const btTransform& getAFrame() const { return m_rbAFrame; };
+	const btTransform& getBFrame() const { return m_rbBFrame; };
+
+	inline int getSolveTwistLimit()
+	{
+		return m_solveTwistLimit;
+	}
+
+	inline int getSolveSwingLimit()
+	{
+		return m_solveSwingLimit;
+	}
+
+	inline btScalar getTwistLimitSign()
+	{
+		return m_twistLimitSign;
+	}
+
+	void calcAngleInfo();
+	void calcAngleInfo2(const btTransform& transA, const btTransform& transB, const btMatrix3x3& invInertiaWorldA, const btMatrix3x3& invInertiaWorldB);
+
+	inline btScalar getSwingSpan1() const
+	{
+		return m_swingSpan1;
+	}
+	inline btScalar getSwingSpan2() const
+	{
+		return m_swingSpan2;
+	}
+	inline btScalar getTwistSpan() const
+	{
+		return m_twistSpan;
+	}
+	inline btScalar getLimitSoftness() const
+	{
+		return m_limitSoftness;
+	}
+	inline btScalar getBiasFactor() const
+	{
+		return m_biasFactor;
+	}
+	inline btScalar getRelaxationFactor() const
+	{
+		return m_relaxationFactor;
+	}
+	inline btScalar getTwistAngle() const
+	{
+		return m_twistAngle;
+	}
+	bool isPastSwingLimit() { return m_solveSwingLimit; }
+
+	btScalar getDamping() const { return m_damping; }
+	void setDamping(btScalar damping) { m_damping = damping; }
+
+	void enableMotor(bool b) { m_bMotorEnabled = b; }
+	bool isMotorEnabled() const { return m_bMotorEnabled; }
+	btScalar getMaxMotorImpulse() const { return m_maxMotorImpulse; }
+	bool isMaxMotorImpulseNormalized() const { return m_bNormalizedMotorStrength; }
+	void setMaxMotorImpulse(btScalar maxMotorImpulse)
+	{
+		m_maxMotorImpulse = maxMotorImpulse;
+		m_bNormalizedMotorStrength = false;
+	}
+	void setMaxMotorImpulseNormalized(btScalar maxMotorImpulse)
+	{
+		m_maxMotorImpulse = maxMotorImpulse;
+		m_bNormalizedMotorStrength = true;
+	}
+
+	btScalar getFixThresh() { return m_fixThresh; }
+	void setFixThresh(btScalar fixThresh) { m_fixThresh = fixThresh; }
+
+	// setMotorTarget:
+	// q: the desired rotation of bodyA wrt bodyB.
+	// note: if q violates the joint limits, the internal target is clamped to avoid conflicting impulses (very bad for stability)
+	// note: don't forget to enableMotor()
+	void setMotorTarget(const btQuaternion& q);
+	const btQuaternion& getMotorTarget() const { return m_qTarget; }
+
+	// same as above, but q is the desired rotation of frameA wrt frameB in constraint space
+	void setMotorTargetInConstraintSpace(const btQuaternion& q);
+
+	btVector3 GetPointForAngle(btScalar fAngleInRadians, btScalar fLength) const;
+
+	///override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5).
+	///If no axis is provided, it uses the default axis for this constraint.
+	virtual void setParam(int num, btScalar value, int axis = -1);
+
+	virtual void setFrames(const btTransform& frameA, const btTransform& frameB);
+
+	const btTransform& getFrameOffsetA() const
+	{
+		return m_rbAFrame;
+	}
+
+	const btTransform& getFrameOffsetB() const
+	{
+		return m_rbBFrame;
+	}
+
+	///return the local value of parameter
+	virtual btScalar getParam(int num, int axis = -1) const;
+
+	int getFlags() const
+	{
+		return m_flags;
+	}
+
+	virtual int calculateSerializeBufferSize() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
+};
+
+struct btConeTwistConstraintDoubleData
+{
+	btTypedConstraintDoubleData m_typeConstraintData;
+	btTransformDoubleData m_rbAFrame;
+	btTransformDoubleData m_rbBFrame;
+
+	//limits
+	double m_swingSpan1;
+	double m_swingSpan2;
+	double m_twistSpan;
+	double m_limitSoftness;
+	double m_biasFactor;
+	double m_relaxationFactor;
+
+	double m_damping;
+};
+
+#ifdef BT_BACKWARDS_COMPATIBLE_SERIALIZATION
+///this structure is not used, except for loading pre-2.82 .bullet files
+struct btConeTwistConstraintData
+{
+	btTypedConstraintData m_typeConstraintData;
+	btTransformFloatData m_rbAFrame;
+	btTransformFloatData m_rbBFrame;
+
+	//limits
+	float m_swingSpan1;
+	float m_swingSpan2;
+	float m_twistSpan;
+	float m_limitSoftness;
+	float m_biasFactor;
+	float m_relaxationFactor;
+
+	float m_damping;
+
+	char m_pad[4];
+};
+#endif  //BT_BACKWARDS_COMPATIBLE_SERIALIZATION
+//
+
+SIMD_FORCE_INLINE int btConeTwistConstraint::calculateSerializeBufferSize() const
+{
+	return sizeof(btConeTwistConstraintData2);
+}
+
+///fills the dataBuffer and returns the struct name (and 0 on failure)
+SIMD_FORCE_INLINE const char* btConeTwistConstraint::serialize(void* dataBuffer, btSerializer* serializer) const
+{
+	btConeTwistConstraintData2* cone = (btConeTwistConstraintData2*)dataBuffer;
+	btTypedConstraint::serialize(&cone->m_typeConstraintData, serializer);
+
+	m_rbAFrame.serialize(cone->m_rbAFrame);
+	m_rbBFrame.serialize(cone->m_rbBFrame);
+
+	cone->m_swingSpan1 = m_swingSpan1;
+	cone->m_swingSpan2 = m_swingSpan2;
+	cone->m_twistSpan = m_twistSpan;
+	cone->m_limitSoftness = m_limitSoftness;
+	cone->m_biasFactor = m_biasFactor;
+	cone->m_relaxationFactor = m_relaxationFactor;
+	cone->m_damping = m_damping;
+
+	return btConeTwistConstraintDataName;
+}
+
+#endif  //BT_CONETWISTCONSTRAINT_H
diff --git a/engine/inc/bullet/BulletDynamics/ConstraintSolver/btConstraintSolver.h b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btConstraintSolver.h
new file mode 100644
index 00000000..68a4a07a
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btConstraintSolver.h
@@ -0,0 +1,59 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_CONSTRAINT_SOLVER_H
+#define BT_CONSTRAINT_SOLVER_H
+
+#include "LinearMath/btScalar.h"
+
+class btPersistentManifold;
+class btRigidBody;
+class btCollisionObject;
+class btTypedConstraint;
+struct btContactSolverInfo;
+struct btBroadphaseProxy;
+class btIDebugDraw;
+class btStackAlloc;
+class btDispatcher;
+/// btConstraintSolver provides solver interface
+
+enum btConstraintSolverType
+{
+	BT_SEQUENTIAL_IMPULSE_SOLVER = 1,
+	BT_MLCP_SOLVER = 2,
+	BT_NNCG_SOLVER = 4,
+	BT_MULTIBODY_SOLVER = 8,
+	BT_BLOCK_SOLVER = 16,
+};
+
+class btConstraintSolver
+{
+public:
+	virtual ~btConstraintSolver() {}
+
+	virtual void prepareSolve(int /* numBodies */, int /* numManifolds */) { ; }
+
+	///solve a group of constraints
+	virtual btScalar solveGroup(btCollisionObject** bodies, int numBodies, btPersistentManifold** manifold, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& info, class btIDebugDraw* debugDrawer, btDispatcher* dispatcher) = 0;
+
+	virtual void allSolved(const btContactSolverInfo& /* info */, class btIDebugDraw* /* debugDrawer */) { ; }
+
+	///clear internal cached data and reset random seed
+	virtual void reset() = 0;
+
+	virtual btConstraintSolverType getSolverType() const = 0;
+};
+
+#endif  //BT_CONSTRAINT_SOLVER_H
diff --git a/engine/inc/bullet/BulletDynamics/ConstraintSolver/btContactConstraint.h b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btContactConstraint.h
new file mode 100644
index 00000000..255489be
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btContactConstraint.h
@@ -0,0 +1,65 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_CONTACT_CONSTRAINT_H
+#define BT_CONTACT_CONSTRAINT_H
+
+#include "LinearMath/btVector3.h"
+#include "btJacobianEntry.h"
+#include "btTypedConstraint.h"
+#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
+
+///btContactConstraint can be automatically created to solve contact constraints using the unified btTypedConstraint interface
+ATTRIBUTE_ALIGNED16(class)
+btContactConstraint : public btTypedConstraint
+{
+protected:
+	btPersistentManifold m_contactManifold;
+
+protected:
+	btContactConstraint(btPersistentManifold * contactManifold, btRigidBody & rbA, btRigidBody & rbB);
+
+public:
+	void setContactManifold(btPersistentManifold * contactManifold);
+
+	btPersistentManifold* getContactManifold()
+	{
+		return &m_contactManifold;
+	}
+
+	const btPersistentManifold* getContactManifold() const
+	{
+		return &m_contactManifold;
+	}
+
+	virtual ~btContactConstraint();
+
+	virtual void getInfo1(btConstraintInfo1 * info);
+
+	virtual void getInfo2(btConstraintInfo2 * info);
+
+	///obsolete methods
+	virtual void buildJacobian();
+};
+
+///very basic collision resolution without friction
+btScalar resolveSingleCollision(btRigidBody* body1, class btCollisionObject* colObj2, const btVector3& contactPositionWorld, const btVector3& contactNormalOnB, const struct btContactSolverInfo& solverInfo, btScalar distance);
+
+///resolveSingleBilateral is an obsolete methods used for vehicle friction between two dynamic objects
+void resolveSingleBilateral(btRigidBody& body1, const btVector3& pos1,
+							btRigidBody& body2, const btVector3& pos2,
+							btScalar distance, const btVector3& normal, btScalar& impulse, btScalar timeStep);
+
+#endif  //BT_CONTACT_CONSTRAINT_H
diff --git a/engine/inc/bullet/BulletDynamics/ConstraintSolver/btContactSolverInfo.h b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btContactSolverInfo.h
new file mode 100644
index 00000000..3316403a
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btContactSolverInfo.h
@@ -0,0 +1,177 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_CONTACT_SOLVER_INFO
+#define BT_CONTACT_SOLVER_INFO
+
+#include "LinearMath/btScalar.h"
+
+enum btSolverMode
+{
+	SOLVER_RANDMIZE_ORDER = 1,
+	SOLVER_FRICTION_SEPARATE = 2,
+	SOLVER_USE_WARMSTARTING = 4,
+	SOLVER_USE_2_FRICTION_DIRECTIONS = 16,
+	SOLVER_ENABLE_FRICTION_DIRECTION_CACHING = 32,
+	SOLVER_DISABLE_VELOCITY_DEPENDENT_FRICTION_DIRECTION = 64,
+	SOLVER_CACHE_FRIENDLY = 128,
+	SOLVER_SIMD = 256,
+	SOLVER_INTERLEAVE_CONTACT_AND_FRICTION_CONSTRAINTS = 512,
+	SOLVER_ALLOW_ZERO_LENGTH_FRICTION_DIRECTIONS = 1024,
+	SOLVER_DISABLE_IMPLICIT_CONE_FRICTION = 2048,
+	SOLVER_USE_ARTICULATED_WARMSTARTING = 4096,
+};
+
+struct btContactSolverInfoData
+{
+	btScalar m_tau;
+	btScalar m_damping;  //global non-contact constraint damping, can be locally overridden by constraints during 'getInfo2'.
+	btScalar m_friction;
+	btScalar m_timeStep;
+	btScalar m_restitution;
+	int m_numIterations;
+	btScalar m_maxErrorReduction;
+	btScalar m_sor;          //successive over-relaxation term
+	btScalar m_erp;          //error reduction for non-contact constraints
+	btScalar m_erp2;         //error reduction for contact constraints
+	btScalar m_deformable_erp;          //error reduction for deformable constraints
+	btScalar m_deformable_cfm;          //constraint force mixing for deformable constraints
+	btScalar m_deformable_maxErrorReduction; // maxErrorReduction for deformable contact
+	btScalar m_globalCfm;    //constraint force mixing for contacts and non-contacts
+	btScalar m_frictionERP;  //error reduction for friction constraints
+	btScalar m_frictionCFM;  //constraint force mixing for friction constraints
+
+	int m_splitImpulse;
+	btScalar m_splitImpulsePenetrationThreshold;
+	btScalar m_splitImpulseTurnErp;
+	btScalar m_linearSlop;
+	btScalar m_warmstartingFactor;
+	btScalar m_articulatedWarmstartingFactor;
+	int m_solverMode;
+	int m_restingContactRestitutionThreshold;
+	int m_minimumSolverBatchSize;
+	btScalar m_maxGyroscopicForce;
+	btScalar m_singleAxisRollingFrictionThreshold;
+	btScalar m_leastSquaresResidualThreshold;
+	btScalar m_restitutionVelocityThreshold;
+	bool m_jointFeedbackInWorldSpace;
+	bool m_jointFeedbackInJointFrame;
+	int m_reportSolverAnalytics;
+	int m_numNonContactInnerIterations;
+};
+
+struct btContactSolverInfo : public btContactSolverInfoData
+{
+	inline btContactSolverInfo()
+	{
+		m_tau = btScalar(0.6);
+		m_damping = btScalar(1.0);
+		m_friction = btScalar(0.3);
+		m_timeStep = btScalar(1.f / 60.f);
+		m_restitution = btScalar(0.);
+		m_maxErrorReduction = btScalar(20.);
+		m_numIterations = 10;
+		m_erp = btScalar(0.2);
+		m_erp2 = btScalar(0.2);
+		m_deformable_erp = btScalar(0.06);
+		m_deformable_cfm = btScalar(0.01);
+		m_deformable_maxErrorReduction = btScalar(0.1);
+		m_globalCfm = btScalar(0.);
+		m_frictionERP = btScalar(0.2);  //positional friction 'anchors' are disabled by default
+		m_frictionCFM = btScalar(0.);
+		m_sor = btScalar(1.);
+		m_splitImpulse = true;
+		m_splitImpulsePenetrationThreshold = -.04f;
+		m_splitImpulseTurnErp = 0.1f;
+		m_linearSlop = btScalar(0.0);
+		m_warmstartingFactor = btScalar(0.85);
+		m_articulatedWarmstartingFactor = btScalar(0.85);
+		//m_solverMode =  SOLVER_USE_WARMSTARTING |  SOLVER_SIMD | SOLVER_DISABLE_VELOCITY_DEPENDENT_FRICTION_DIRECTION|SOLVER_USE_2_FRICTION_DIRECTIONS|SOLVER_ENABLE_FRICTION_DIRECTION_CACHING;// | SOLVER_RANDMIZE_ORDER;
+		m_solverMode = SOLVER_USE_WARMSTARTING | SOLVER_SIMD;  // | SOLVER_RANDMIZE_ORDER;
+		m_restingContactRestitutionThreshold = 2;              //unused as of 2.81
+		m_minimumSolverBatchSize = 128;                        //try to combine islands until the amount of constraints reaches this limit
+		m_maxGyroscopicForce = 100.f;                          ///it is only used for 'explicit' version of gyroscopic force
+		m_singleAxisRollingFrictionThreshold = 1e30f;          ///if the velocity is above this threshold, it will use a single constraint row (axis), otherwise 3 rows.
+		m_leastSquaresResidualThreshold = 0.f;
+		m_restitutionVelocityThreshold = 0.2f;  //if the relative velocity is below this threshold, there is zero restitution
+		m_jointFeedbackInWorldSpace = false;
+		m_jointFeedbackInJointFrame = false;
+		m_reportSolverAnalytics = 0;
+		m_numNonContactInnerIterations = 1;   // the number of inner iterations for solving motor constraint in a single iteration of the constraint solve
+	}
+};
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct btContactSolverInfoDoubleData
+{
+	double m_tau;
+	double m_damping;  //global non-contact constraint damping, can be locally overridden by constraints during 'getInfo2'.
+	double m_friction;
+	double m_timeStep;
+	double m_restitution;
+	double m_maxErrorReduction;
+	double m_sor;
+	double m_erp;        //used as Baumgarte factor
+	double m_erp2;       //used in Split Impulse
+	double m_globalCfm;  //constraint force mixing
+	double m_splitImpulsePenetrationThreshold;
+	double m_splitImpulseTurnErp;
+	double m_linearSlop;
+	double m_warmstartingFactor;
+	double m_articulatedWarmstartingFactor;
+	double m_maxGyroscopicForce;  ///it is only used for 'explicit' version of gyroscopic force
+	double m_singleAxisRollingFrictionThreshold;
+
+	int m_numIterations;
+	int m_solverMode;
+	int m_restingContactRestitutionThreshold;
+	int m_minimumSolverBatchSize;
+	int m_splitImpulse;
+	char m_padding[4];
+};
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct btContactSolverInfoFloatData
+{
+	float m_tau;
+	float m_damping;  //global non-contact constraint damping, can be locally overridden by constraints during 'getInfo2'.
+	float m_friction;
+	float m_timeStep;
+
+	float m_restitution;
+	float m_maxErrorReduction;
+	float m_sor;
+	float m_erp;  //used as Baumgarte factor
+
+	float m_erp2;       //used in Split Impulse
+	float m_globalCfm;  //constraint force mixing
+	float m_splitImpulsePenetrationThreshold;
+	float m_splitImpulseTurnErp;
+
+	float m_linearSlop;
+	float m_warmstartingFactor;
+	float m_articulatedWarmstartingFactor;
+	float m_maxGyroscopicForce;
+
+	float m_singleAxisRollingFrictionThreshold;
+	int m_numIterations;
+	int m_solverMode;
+	int m_restingContactRestitutionThreshold;
+
+	int m_minimumSolverBatchSize;
+	int m_splitImpulse;
+	
+};
+
+#endif  //BT_CONTACT_SOLVER_INFO
diff --git a/engine/inc/bullet/BulletDynamics/ConstraintSolver/btFixedConstraint.h b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btFixedConstraint.h
new file mode 100644
index 00000000..6d474ea8
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btFixedConstraint.h
@@ -0,0 +1,30 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_FIXED_CONSTRAINT_H
+#define BT_FIXED_CONSTRAINT_H
+
+#include "btGeneric6DofSpring2Constraint.h"
+
+ATTRIBUTE_ALIGNED16(class)
+btFixedConstraint : public btGeneric6DofSpring2Constraint
+{
+public:
+	btFixedConstraint(btRigidBody & rbA, btRigidBody & rbB, const btTransform& frameInA, const btTransform& frameInB);
+
+	virtual ~btFixedConstraint();
+};
+
+#endif  //BT_FIXED_CONSTRAINT_H
diff --git a/engine/inc/bullet/BulletDynamics/ConstraintSolver/btGearConstraint.h b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btGearConstraint.h
new file mode 100644
index 00000000..64b15dfb
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btGearConstraint.h
@@ -0,0 +1,146 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2012 Advanced Micro Devices, Inc.  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_GEAR_CONSTRAINT_H
+#define BT_GEAR_CONSTRAINT_H
+
+#include "BulletDynamics/ConstraintSolver/btTypedConstraint.h"
+
+#ifdef BT_USE_DOUBLE_PRECISION
+#define btGearConstraintData btGearConstraintDoubleData
+#define btGearConstraintDataName "btGearConstraintDoubleData"
+#else
+#define btGearConstraintData btGearConstraintFloatData
+#define btGearConstraintDataName "btGearConstraintFloatData"
+#endif  //BT_USE_DOUBLE_PRECISION
+
+///The btGeatConstraint will couple the angular velocity for two bodies around given local axis and ratio.
+///See Bullet/Demos/ConstraintDemo for an example use.
+class btGearConstraint : public btTypedConstraint
+{
+protected:
+	btVector3 m_axisInA;
+	btVector3 m_axisInB;
+	bool m_useFrameA;
+	btScalar m_ratio;
+
+public:
+	btGearConstraint(btRigidBody& rbA, btRigidBody& rbB, const btVector3& axisInA, const btVector3& axisInB, btScalar ratio = 1.f);
+	virtual ~btGearConstraint();
+
+	///internal method used by the constraint solver, don't use them directly
+	virtual void getInfo1(btConstraintInfo1* info);
+
+	///internal method used by the constraint solver, don't use them directly
+	virtual void getInfo2(btConstraintInfo2* info);
+
+	void setAxisA(btVector3& axisA)
+	{
+		m_axisInA = axisA;
+	}
+	void setAxisB(btVector3& axisB)
+	{
+		m_axisInB = axisB;
+	}
+	void setRatio(btScalar ratio)
+	{
+		m_ratio = ratio;
+	}
+	const btVector3& getAxisA() const
+	{
+		return m_axisInA;
+	}
+	const btVector3& getAxisB() const
+	{
+		return m_axisInB;
+	}
+	btScalar getRatio() const
+	{
+		return m_ratio;
+	}
+
+	virtual void setParam(int num, btScalar value, int axis = -1)
+	{
+		(void)num;
+		(void)value;
+		(void)axis;
+		btAssert(0);
+	}
+
+	///return the local value of parameter
+	virtual btScalar getParam(int num, int axis = -1) const
+	{
+		(void)num;
+		(void)axis;
+		btAssert(0);
+		return 0.f;
+	}
+
+	virtual int calculateSerializeBufferSize() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
+};
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct btGearConstraintFloatData
+{
+	btTypedConstraintFloatData m_typeConstraintData;
+
+	btVector3FloatData m_axisInA;
+	btVector3FloatData m_axisInB;
+
+	float m_ratio;
+	char m_padding[4];
+};
+
+struct btGearConstraintDoubleData
+{
+	btTypedConstraintDoubleData m_typeConstraintData;
+
+	btVector3DoubleData m_axisInA;
+	btVector3DoubleData m_axisInB;
+
+	double m_ratio;
+};
+
+SIMD_FORCE_INLINE int btGearConstraint::calculateSerializeBufferSize() const
+{
+	return sizeof(btGearConstraintData);
+}
+
+///fills the dataBuffer and returns the struct name (and 0 on failure)
+SIMD_FORCE_INLINE const char* btGearConstraint::serialize(void* dataBuffer, btSerializer* serializer) const
+{
+	btGearConstraintData* gear = (btGearConstraintData*)dataBuffer;
+	btTypedConstraint::serialize(&gear->m_typeConstraintData, serializer);
+
+	m_axisInA.serialize(gear->m_axisInA);
+	m_axisInB.serialize(gear->m_axisInB);
+
+	gear->m_ratio = m_ratio;
+
+	// Fill padding with zeros to appease msan.
+#ifndef BT_USE_DOUBLE_PRECISION
+	gear->m_padding[0] = 0;
+	gear->m_padding[1] = 0;
+	gear->m_padding[2] = 0;
+	gear->m_padding[3] = 0;
+#endif
+
+	return btGearConstraintDataName;
+}
+
+#endif  //BT_GEAR_CONSTRAINT_H
diff --git a/engine/inc/bullet/BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h
new file mode 100644
index 00000000..b9e762e1
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h
@@ -0,0 +1,615 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+/// 2009 March: btGeneric6DofConstraint refactored by Roman Ponomarev
+/// Added support for generic constraint solver through getInfo1/getInfo2 methods
+
+/*
+2007-09-09
+btGeneric6DofConstraint Refactored by Francisco Le?n
+email: projectileman@yahoo.com
+http://gimpact.sf.net
+*/
+
+#ifndef BT_GENERIC_6DOF_CONSTRAINT_H
+#define BT_GENERIC_6DOF_CONSTRAINT_H
+
+#include "LinearMath/btVector3.h"
+#include "btJacobianEntry.h"
+#include "btTypedConstraint.h"
+
+class btRigidBody;
+
+#ifdef BT_USE_DOUBLE_PRECISION
+#define btGeneric6DofConstraintData2 btGeneric6DofConstraintDoubleData2
+#define btGeneric6DofConstraintDataName "btGeneric6DofConstraintDoubleData2"
+#else
+#define btGeneric6DofConstraintData2 btGeneric6DofConstraintData
+#define btGeneric6DofConstraintDataName "btGeneric6DofConstraintData"
+#endif  //BT_USE_DOUBLE_PRECISION
+
+//! Rotation Limit structure for generic joints
+class btRotationalLimitMotor
+{
+public:
+	//! limit_parameters
+	//!@{
+	btScalar m_loLimit;         //!< joint limit
+	btScalar m_hiLimit;         //!< joint limit
+	btScalar m_targetVelocity;  //!< target motor velocity
+	btScalar m_maxMotorForce;   //!< max force on motor
+	btScalar m_maxLimitForce;   //!< max force on limit
+	btScalar m_damping;         //!< Damping.
+	btScalar m_limitSoftness;   //! Relaxation factor
+	btScalar m_normalCFM;       //!< Constraint force mixing factor
+	btScalar m_stopERP;         //!< Error tolerance factor when joint is at limit
+	btScalar m_stopCFM;         //!< Constraint force mixing factor when joint is at limit
+	btScalar m_bounce;          //!< restitution factor
+	bool m_enableMotor;
+
+	//!@}
+
+	//! temp_variables
+	//!@{
+	btScalar m_currentLimitError;  //!  How much is violated this limit
+	btScalar m_currentPosition;    //!  current value of angle
+	int m_currentLimit;            //!< 0=free, 1=at lo limit, 2=at hi limit
+	btScalar m_accumulatedImpulse;
+	//!@}
+
+	btRotationalLimitMotor()
+	{
+		m_accumulatedImpulse = 0.f;
+		m_targetVelocity = 0;
+		m_maxMotorForce = 6.0f;
+		m_maxLimitForce = 300.0f;
+		m_loLimit = 1.0f;
+		m_hiLimit = -1.0f;
+		m_normalCFM = 0.f;
+		m_stopERP = 0.2f;
+		m_stopCFM = 0.f;
+		m_bounce = 0.0f;
+		m_damping = 1.0f;
+		m_limitSoftness = 0.5f;
+		m_currentLimit = 0;
+		m_currentLimitError = 0;
+		m_enableMotor = false;
+	}
+
+	btRotationalLimitMotor(const btRotationalLimitMotor& limot)
+	{
+		m_targetVelocity = limot.m_targetVelocity;
+		m_maxMotorForce = limot.m_maxMotorForce;
+		m_limitSoftness = limot.m_limitSoftness;
+		m_loLimit = limot.m_loLimit;
+		m_hiLimit = limot.m_hiLimit;
+		m_normalCFM = limot.m_normalCFM;
+		m_stopERP = limot.m_stopERP;
+		m_stopCFM = limot.m_stopCFM;
+		m_bounce = limot.m_bounce;
+		m_currentLimit = limot.m_currentLimit;
+		m_currentLimitError = limot.m_currentLimitError;
+		m_enableMotor = limot.m_enableMotor;
+	}
+
+	//! Is limited
+	bool isLimited() const
+	{
+		if (m_loLimit > m_hiLimit) return false;
+		return true;
+	}
+
+	//! Need apply correction
+	bool needApplyTorques() const
+	{
+		if (m_currentLimit == 0 && m_enableMotor == false) return false;
+		return true;
+	}
+
+	//! calculates  error
+	/*!
+	calculates m_currentLimit and m_currentLimitError.
+	*/
+	int testLimitValue(btScalar test_value);
+
+	//! apply the correction impulses for two bodies
+	btScalar solveAngularLimits(btScalar timeStep, btVector3& axis, btScalar jacDiagABInv, btRigidBody* body0, btRigidBody* body1);
+};
+
+class btTranslationalLimitMotor
+{
+public:
+	btVector3 m_lowerLimit;  //!< the constraint lower limits
+	btVector3 m_upperLimit;  //!< the constraint upper limits
+	btVector3 m_accumulatedImpulse;
+	//! Linear_Limit_parameters
+	//!@{
+	btScalar m_limitSoftness;  //!< Softness for linear limit
+	btScalar m_damping;        //!< Damping for linear limit
+	btScalar m_restitution;    //! Bounce parameter for linear limit
+	btVector3 m_normalCFM;     //!< Constraint force mixing factor
+	btVector3 m_stopERP;       //!< Error tolerance factor when joint is at limit
+	btVector3 m_stopCFM;       //!< Constraint force mixing factor when joint is at limit
+							   //!@}
+	bool m_enableMotor[3];
+	btVector3 m_targetVelocity;     //!< target motor velocity
+	btVector3 m_maxMotorForce;      //!< max force on motor
+	btVector3 m_currentLimitError;  //!  How much is violated this limit
+	btVector3 m_currentLinearDiff;  //!  Current relative offset of constraint frames
+	int m_currentLimit[3];          //!< 0=free, 1=at lower limit, 2=at upper limit
+
+	btTranslationalLimitMotor()
+	{
+		m_lowerLimit.setValue(0.f, 0.f, 0.f);
+		m_upperLimit.setValue(0.f, 0.f, 0.f);
+		m_accumulatedImpulse.setValue(0.f, 0.f, 0.f);
+		m_normalCFM.setValue(0.f, 0.f, 0.f);
+		m_stopERP.setValue(0.2f, 0.2f, 0.2f);
+		m_stopCFM.setValue(0.f, 0.f, 0.f);
+
+		m_limitSoftness = 0.7f;
+		m_damping = btScalar(1.0f);
+		m_restitution = btScalar(0.5f);
+		for (int i = 0; i < 3; i++)
+		{
+			m_enableMotor[i] = false;
+			m_targetVelocity[i] = btScalar(0.f);
+			m_maxMotorForce[i] = btScalar(0.f);
+		}
+	}
+
+	btTranslationalLimitMotor(const btTranslationalLimitMotor& other)
+	{
+		m_lowerLimit = other.m_lowerLimit;
+		m_upperLimit = other.m_upperLimit;
+		m_accumulatedImpulse = other.m_accumulatedImpulse;
+
+		m_limitSoftness = other.m_limitSoftness;
+		m_damping = other.m_damping;
+		m_restitution = other.m_restitution;
+		m_normalCFM = other.m_normalCFM;
+		m_stopERP = other.m_stopERP;
+		m_stopCFM = other.m_stopCFM;
+
+		for (int i = 0; i < 3; i++)
+		{
+			m_enableMotor[i] = other.m_enableMotor[i];
+			m_targetVelocity[i] = other.m_targetVelocity[i];
+			m_maxMotorForce[i] = other.m_maxMotorForce[i];
+		}
+	}
+
+	//! Test limit
+	/*!
+    - free means upper < lower,
+    - locked means upper == lower
+    - limited means upper > lower
+    - limitIndex: first 3 are linear, next 3 are angular
+    */
+	inline bool isLimited(int limitIndex) const
+	{
+		return (m_upperLimit[limitIndex] >= m_lowerLimit[limitIndex]);
+	}
+	inline bool needApplyForce(int limitIndex) const
+	{
+		if (m_currentLimit[limitIndex] == 0 && m_enableMotor[limitIndex] == false) return false;
+		return true;
+	}
+	int testLimitValue(int limitIndex, btScalar test_value);
+
+	btScalar solveLinearAxis(
+		btScalar timeStep,
+		btScalar jacDiagABInv,
+		btRigidBody& body1, const btVector3& pointInA,
+		btRigidBody& body2, const btVector3& pointInB,
+		int limit_index,
+		const btVector3& axis_normal_on_a,
+		const btVector3& anchorPos);
+};
+
+enum bt6DofFlags
+{
+	BT_6DOF_FLAGS_CFM_NORM = 1,
+	BT_6DOF_FLAGS_CFM_STOP = 2,
+	BT_6DOF_FLAGS_ERP_STOP = 4
+};
+#define BT_6DOF_FLAGS_AXIS_SHIFT 3  // bits per axis
+
+/// btGeneric6DofConstraint between two rigidbodies each with a pivotpoint that descibes the axis location in local space
+/*!
+btGeneric6DofConstraint can leave any of the 6 degree of freedom 'free' or 'locked'.
+currently this limit supports rotational motors<br>
+<ul>
+<li> For Linear limits, use btGeneric6DofConstraint.setLinearUpperLimit, btGeneric6DofConstraint.setLinearLowerLimit. You can set the parameters with the btTranslationalLimitMotor structure accsesible through the btGeneric6DofConstraint.getTranslationalLimitMotor method.
+At this moment translational motors are not supported. May be in the future. </li>
+
+<li> For Angular limits, use the btRotationalLimitMotor structure for configuring the limit.
+This is accessible through btGeneric6DofConstraint.getLimitMotor method,
+This brings support for limit parameters and motors. </li>
+
+<li> Angulars limits have these possible ranges:
+<table border=1 >
+<tr>
+	<td><b>AXIS</b></td>
+	<td><b>MIN ANGLE</b></td>
+	<td><b>MAX ANGLE</b></td>
+</tr><tr>
+	<td>X</td>
+	<td>-PI</td>
+	<td>PI</td>
+</tr><tr>
+	<td>Y</td>
+	<td>-PI/2</td>
+	<td>PI/2</td>
+</tr><tr>
+	<td>Z</td>
+	<td>-PI</td>
+	<td>PI</td>
+</tr>
+</table>
+</li>
+</ul>
+
+*/
+ATTRIBUTE_ALIGNED16(class)
+btGeneric6DofConstraint : public btTypedConstraint
+{
+protected:
+	//! relative_frames
+	//!@{
+	btTransform m_frameInA;  //!< the constraint space w.r.t body A
+	btTransform m_frameInB;  //!< the constraint space w.r.t body B
+	//!@}
+
+	//! Jacobians
+	//!@{
+	btJacobianEntry m_jacLinear[3];  //!< 3 orthogonal linear constraints
+	btJacobianEntry m_jacAng[3];     //!< 3 orthogonal angular constraints
+	//!@}
+
+	//! Linear_Limit_parameters
+	//!@{
+	btTranslationalLimitMotor m_linearLimits;
+	//!@}
+
+	//! hinge_parameters
+	//!@{
+	btRotationalLimitMotor m_angularLimits[3];
+	//!@}
+
+protected:
+	//! temporal variables
+	//!@{
+	btScalar m_timeStep;
+	btTransform m_calculatedTransformA;
+	btTransform m_calculatedTransformB;
+	btVector3 m_calculatedAxisAngleDiff;
+	btVector3 m_calculatedAxis[3];
+	btVector3 m_calculatedLinearDiff;
+	btScalar m_factA;
+	btScalar m_factB;
+	bool m_hasStaticBody;
+
+	btVector3 m_AnchorPos;  // point betwen pivots of bodies A and B to solve linear axes
+
+	bool m_useLinearReferenceFrameA;
+	bool m_useOffsetForConstraintFrame;
+
+	int m_flags;
+
+	//!@}
+
+	btGeneric6DofConstraint& operator=(btGeneric6DofConstraint& other)
+	{
+		btAssert(0);
+		(void)other;
+		return *this;
+	}
+
+	int setAngularLimits(btConstraintInfo2 * info, int row_offset, const btTransform& transA, const btTransform& transB, const btVector3& linVelA, const btVector3& linVelB, const btVector3& angVelA, const btVector3& angVelB);
+
+	int setLinearLimits(btConstraintInfo2 * info, int row, const btTransform& transA, const btTransform& transB, const btVector3& linVelA, const btVector3& linVelB, const btVector3& angVelA, const btVector3& angVelB);
+
+	void buildLinearJacobian(
+		btJacobianEntry & jacLinear, const btVector3& normalWorld,
+		const btVector3& pivotAInW, const btVector3& pivotBInW);
+
+	void buildAngularJacobian(btJacobianEntry & jacAngular, const btVector3& jointAxisW);
+
+	// tests linear limits
+	void calculateLinearInfo();
+
+	//! calcs the euler angles between the two bodies.
+	void calculateAngleInfo();
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	///for backwards compatibility during the transition to 'getInfo/getInfo2'
+	bool m_useSolveConstraintObsolete;
+
+	btGeneric6DofConstraint(btRigidBody & rbA, btRigidBody & rbB, const btTransform& frameInA, const btTransform& frameInB, bool useLinearReferenceFrameA);
+	btGeneric6DofConstraint(btRigidBody & rbB, const btTransform& frameInB, bool useLinearReferenceFrameB);
+
+	//! Calcs global transform of the offsets
+	/*!
+	Calcs the global transform for the joint offset for body A an B, and also calcs the agle differences between the bodies.
+	\sa btGeneric6DofConstraint.getCalculatedTransformA , btGeneric6DofConstraint.getCalculatedTransformB, btGeneric6DofConstraint.calculateAngleInfo
+	*/
+	void calculateTransforms(const btTransform& transA, const btTransform& transB);
+
+	void calculateTransforms();
+
+	//! Gets the global transform of the offset for body A
+	/*!
+    \sa btGeneric6DofConstraint.getFrameOffsetA, btGeneric6DofConstraint.getFrameOffsetB, btGeneric6DofConstraint.calculateAngleInfo.
+    */
+	const btTransform& getCalculatedTransformA() const
+	{
+		return m_calculatedTransformA;
+	}
+
+	//! Gets the global transform of the offset for body B
+	/*!
+    \sa btGeneric6DofConstraint.getFrameOffsetA, btGeneric6DofConstraint.getFrameOffsetB, btGeneric6DofConstraint.calculateAngleInfo.
+    */
+	const btTransform& getCalculatedTransformB() const
+	{
+		return m_calculatedTransformB;
+	}
+
+	const btTransform& getFrameOffsetA() const
+	{
+		return m_frameInA;
+	}
+
+	const btTransform& getFrameOffsetB() const
+	{
+		return m_frameInB;
+	}
+
+	btTransform& getFrameOffsetA()
+	{
+		return m_frameInA;
+	}
+
+	btTransform& getFrameOffsetB()
+	{
+		return m_frameInB;
+	}
+
+	//! performs Jacobian calculation, and also calculates angle differences and axis
+	virtual void buildJacobian();
+
+	virtual void getInfo1(btConstraintInfo1 * info);
+
+	void getInfo1NonVirtual(btConstraintInfo1 * info);
+
+	virtual void getInfo2(btConstraintInfo2 * info);
+
+	void getInfo2NonVirtual(btConstraintInfo2 * info, const btTransform& transA, const btTransform& transB, const btVector3& linVelA, const btVector3& linVelB, const btVector3& angVelA, const btVector3& angVelB);
+
+	void updateRHS(btScalar timeStep);
+
+	//! Get the rotation axis in global coordinates
+	/*!
+	\pre btGeneric6DofConstraint.buildJacobian must be called previously.
+	*/
+	btVector3 getAxis(int axis_index) const;
+
+	//! Get the relative Euler angle
+	/*!
+	\pre btGeneric6DofConstraint::calculateTransforms() must be called previously.
+	*/
+	btScalar getAngle(int axis_index) const;
+
+	//! Get the relative position of the constraint pivot
+	/*!
+	\pre btGeneric6DofConstraint::calculateTransforms() must be called previously.
+	*/
+	btScalar getRelativePivotPosition(int axis_index) const;
+
+	void setFrames(const btTransform& frameA, const btTransform& frameB);
+
+	//! Test angular limit.
+	/*!
+	Calculates angular correction and returns true if limit needs to be corrected.
+	\pre btGeneric6DofConstraint::calculateTransforms() must be called previously.
+	*/
+	bool testAngularLimitMotor(int axis_index);
+
+	void setLinearLowerLimit(const btVector3& linearLower)
+	{
+		m_linearLimits.m_lowerLimit = linearLower;
+	}
+
+	void getLinearLowerLimit(btVector3 & linearLower) const
+	{
+		linearLower = m_linearLimits.m_lowerLimit;
+	}
+
+	void setLinearUpperLimit(const btVector3& linearUpper)
+	{
+		m_linearLimits.m_upperLimit = linearUpper;
+	}
+
+	void getLinearUpperLimit(btVector3 & linearUpper) const
+	{
+		linearUpper = m_linearLimits.m_upperLimit;
+	}
+
+	void setAngularLowerLimit(const btVector3& angularLower)
+	{
+		for (int i = 0; i < 3; i++)
+			m_angularLimits[i].m_loLimit = btNormalizeAngle(angularLower[i]);
+	}
+
+	void getAngularLowerLimit(btVector3 & angularLower) const
+	{
+		for (int i = 0; i < 3; i++)
+			angularLower[i] = m_angularLimits[i].m_loLimit;
+	}
+
+	void setAngularUpperLimit(const btVector3& angularUpper)
+	{
+		for (int i = 0; i < 3; i++)
+			m_angularLimits[i].m_hiLimit = btNormalizeAngle(angularUpper[i]);
+	}
+
+	void getAngularUpperLimit(btVector3 & angularUpper) const
+	{
+		for (int i = 0; i < 3; i++)
+			angularUpper[i] = m_angularLimits[i].m_hiLimit;
+	}
+
+	//! Retrieves the angular limit informacion
+	btRotationalLimitMotor* getRotationalLimitMotor(int index)
+	{
+		return &m_angularLimits[index];
+	}
+
+	//! Retrieves the  limit informacion
+	btTranslationalLimitMotor* getTranslationalLimitMotor()
+	{
+		return &m_linearLimits;
+	}
+
+	//first 3 are linear, next 3 are angular
+	void setLimit(int axis, btScalar lo, btScalar hi)
+	{
+		if (axis < 3)
+		{
+			m_linearLimits.m_lowerLimit[axis] = lo;
+			m_linearLimits.m_upperLimit[axis] = hi;
+		}
+		else
+		{
+			lo = btNormalizeAngle(lo);
+			hi = btNormalizeAngle(hi);
+			m_angularLimits[axis - 3].m_loLimit = lo;
+			m_angularLimits[axis - 3].m_hiLimit = hi;
+		}
+	}
+
+	//! Test limit
+	/*!
+    - free means upper < lower,
+    - locked means upper == lower
+    - limited means upper > lower
+    - limitIndex: first 3 are linear, next 3 are angular
+    */
+	bool isLimited(int limitIndex) const
+	{
+		if (limitIndex < 3)
+		{
+			return m_linearLimits.isLimited(limitIndex);
+		}
+		return m_angularLimits[limitIndex - 3].isLimited();
+	}
+
+	virtual void calcAnchorPos(void);  // overridable
+
+	int get_limit_motor_info2(btRotationalLimitMotor * limot,
+							  const btTransform& transA, const btTransform& transB, const btVector3& linVelA, const btVector3& linVelB, const btVector3& angVelA, const btVector3& angVelB,
+							  btConstraintInfo2* info, int row, btVector3& ax1, int rotational, int rotAllowed = false);
+
+	// access for UseFrameOffset
+	bool getUseFrameOffset() const { return m_useOffsetForConstraintFrame; }
+	void setUseFrameOffset(bool frameOffsetOnOff) { m_useOffsetForConstraintFrame = frameOffsetOnOff; }
+
+	bool getUseLinearReferenceFrameA() const { return m_useLinearReferenceFrameA; }
+	void setUseLinearReferenceFrameA(bool linearReferenceFrameA) { m_useLinearReferenceFrameA = linearReferenceFrameA; }
+
+	///override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5).
+	///If no axis is provided, it uses the default axis for this constraint.
+	virtual void setParam(int num, btScalar value, int axis = -1);
+	///return the local value of parameter
+	virtual btScalar getParam(int num, int axis = -1) const;
+
+	void setAxis(const btVector3& axis1, const btVector3& axis2);
+
+	virtual int getFlags() const
+	{
+		return m_flags;
+	}
+
+	virtual int calculateSerializeBufferSize() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
+};
+
+struct btGeneric6DofConstraintData
+{
+	btTypedConstraintData m_typeConstraintData;
+	btTransformFloatData m_rbAFrame;  // constraint axii. Assumes z is hinge axis.
+	btTransformFloatData m_rbBFrame;
+
+	btVector3FloatData m_linearUpperLimit;
+	btVector3FloatData m_linearLowerLimit;
+
+	btVector3FloatData m_angularUpperLimit;
+	btVector3FloatData m_angularLowerLimit;
+
+	int m_useLinearReferenceFrameA;
+	int m_useOffsetForConstraintFrame;
+};
+
+struct btGeneric6DofConstraintDoubleData2
+{
+	btTypedConstraintDoubleData m_typeConstraintData;
+	btTransformDoubleData m_rbAFrame;  // constraint axii. Assumes z is hinge axis.
+	btTransformDoubleData m_rbBFrame;
+
+	btVector3DoubleData m_linearUpperLimit;
+	btVector3DoubleData m_linearLowerLimit;
+
+	btVector3DoubleData m_angularUpperLimit;
+	btVector3DoubleData m_angularLowerLimit;
+
+	int m_useLinearReferenceFrameA;
+	int m_useOffsetForConstraintFrame;
+};
+
+SIMD_FORCE_INLINE int btGeneric6DofConstraint::calculateSerializeBufferSize() const
+{
+	return sizeof(btGeneric6DofConstraintData2);
+}
+
+///fills the dataBuffer and returns the struct name (and 0 on failure)
+SIMD_FORCE_INLINE const char* btGeneric6DofConstraint::serialize(void* dataBuffer, btSerializer* serializer) const
+{
+	btGeneric6DofConstraintData2* dof = (btGeneric6DofConstraintData2*)dataBuffer;
+	btTypedConstraint::serialize(&dof->m_typeConstraintData, serializer);
+
+	m_frameInA.serialize(dof->m_rbAFrame);
+	m_frameInB.serialize(dof->m_rbBFrame);
+
+	int i;
+	for (i = 0; i < 3; i++)
+	{
+		dof->m_angularLowerLimit.m_floats[i] = m_angularLimits[i].m_loLimit;
+		dof->m_angularUpperLimit.m_floats[i] = m_angularLimits[i].m_hiLimit;
+		dof->m_linearLowerLimit.m_floats[i] = m_linearLimits.m_lowerLimit[i];
+		dof->m_linearUpperLimit.m_floats[i] = m_linearLimits.m_upperLimit[i];
+	}
+
+	dof->m_useLinearReferenceFrameA = m_useLinearReferenceFrameA ? 1 : 0;
+	dof->m_useOffsetForConstraintFrame = m_useOffsetForConstraintFrame ? 1 : 0;
+
+	return btGeneric6DofConstraintDataName;
+}
+
+#endif  //BT_GENERIC_6DOF_CONSTRAINT_H
diff --git a/engine/inc/bullet/BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.h b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.h
new file mode 100644
index 00000000..c86dc373
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.h
@@ -0,0 +1,667 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+/*
+2014 May: btGeneric6DofSpring2Constraint is created from the original (2.82.2712) btGeneric6DofConstraint by Gabor Puhr and Tamas Umenhoffer
+Pros:
+- Much more accurate and stable in a lot of situation. (Especially when a sleeping chain of RBs connected with 6dof2 is pulled)
+- Stable and accurate spring with minimal energy loss that works with all of the solvers. (latter is not true for the original 6dof spring)
+- Servo motor functionality
+- Much more accurate bouncing. 0 really means zero bouncing (not true for the original 6odf) and there is only a minimal energy loss when the value is 1 (because of the solvers' precision)
+- Rotation order for the Euler system can be set. (One axis' freedom is still limited to pi/2)
+
+Cons:
+- It is slower than the original 6dof. There is no exact ratio, but half speed is a good estimation.
+- At bouncing the correct velocity is calculated, but not the correct position. (it is because of the solver can correct position or velocity, but not both.)
+*/
+
+/// 2009 March: btGeneric6DofConstraint refactored by Roman Ponomarev
+/// Added support for generic constraint solver through getInfo1/getInfo2 methods
+
+/*
+2007-09-09
+btGeneric6DofConstraint Refactored by Francisco Le?n
+email: projectileman@yahoo.com
+http://gimpact.sf.net
+*/
+
+#ifndef BT_GENERIC_6DOF_CONSTRAINT2_H
+#define BT_GENERIC_6DOF_CONSTRAINT2_H
+
+#include "LinearMath/btVector3.h"
+#include "btJacobianEntry.h"
+#include "btTypedConstraint.h"
+
+class btRigidBody;
+
+#ifdef BT_USE_DOUBLE_PRECISION
+#define btGeneric6DofSpring2ConstraintData2 btGeneric6DofSpring2ConstraintDoubleData2
+#define btGeneric6DofSpring2ConstraintDataName "btGeneric6DofSpring2ConstraintDoubleData2"
+#else
+#define btGeneric6DofSpring2ConstraintData2 btGeneric6DofSpring2ConstraintData
+#define btGeneric6DofSpring2ConstraintDataName "btGeneric6DofSpring2ConstraintData"
+#endif  //BT_USE_DOUBLE_PRECISION
+
+enum RotateOrder
+{
+	RO_XYZ = 0,
+	RO_XZY,
+	RO_YXZ,
+	RO_YZX,
+	RO_ZXY,
+	RO_ZYX
+};
+
+class btRotationalLimitMotor2
+{
+public:
+	// upper < lower means free
+	// upper == lower means locked
+	// upper > lower means limited
+	btScalar m_loLimit;
+	btScalar m_hiLimit;
+	btScalar m_bounce;
+	btScalar m_stopERP;
+	btScalar m_stopCFM;
+	btScalar m_motorERP;
+	btScalar m_motorCFM;
+	bool m_enableMotor;
+	btScalar m_targetVelocity;
+	btScalar m_maxMotorForce;
+	bool m_servoMotor;
+	btScalar m_servoTarget;
+	bool m_enableSpring;
+	btScalar m_springStiffness;
+	bool m_springStiffnessLimited;
+	btScalar m_springDamping;
+	bool m_springDampingLimited;
+	btScalar m_equilibriumPoint;
+
+	btScalar m_currentLimitError;
+	btScalar m_currentLimitErrorHi;
+	btScalar m_currentPosition;
+	int m_currentLimit;
+
+	btRotationalLimitMotor2()
+	{
+		m_loLimit = 1.0f;
+		m_hiLimit = -1.0f;
+		m_bounce = 0.0f;
+		m_stopERP = 0.2f;
+		m_stopCFM = 0.f;
+		m_motorERP = 0.9f;
+		m_motorCFM = 0.f;
+		m_enableMotor = false;
+		m_targetVelocity = 0;
+		m_maxMotorForce = 6.0f;
+		m_servoMotor = false;
+		m_servoTarget = 0;
+		m_enableSpring = false;
+		m_springStiffness = 0;
+		m_springStiffnessLimited = false;
+		m_springDamping = 0;
+		m_springDampingLimited = false;
+		m_equilibriumPoint = 0;
+
+		m_currentLimitError = 0;
+		m_currentLimitErrorHi = 0;
+		m_currentPosition = 0;
+		m_currentLimit = 0;
+	}
+
+	btRotationalLimitMotor2(const btRotationalLimitMotor2& limot)
+	{
+		m_loLimit = limot.m_loLimit;
+		m_hiLimit = limot.m_hiLimit;
+		m_bounce = limot.m_bounce;
+		m_stopERP = limot.m_stopERP;
+		m_stopCFM = limot.m_stopCFM;
+		m_motorERP = limot.m_motorERP;
+		m_motorCFM = limot.m_motorCFM;
+		m_enableMotor = limot.m_enableMotor;
+		m_targetVelocity = limot.m_targetVelocity;
+		m_maxMotorForce = limot.m_maxMotorForce;
+		m_servoMotor = limot.m_servoMotor;
+		m_servoTarget = limot.m_servoTarget;
+		m_enableSpring = limot.m_enableSpring;
+		m_springStiffness = limot.m_springStiffness;
+		m_springStiffnessLimited = limot.m_springStiffnessLimited;
+		m_springDamping = limot.m_springDamping;
+		m_springDampingLimited = limot.m_springDampingLimited;
+		m_equilibriumPoint = limot.m_equilibriumPoint;
+
+		m_currentLimitError = limot.m_currentLimitError;
+		m_currentLimitErrorHi = limot.m_currentLimitErrorHi;
+		m_currentPosition = limot.m_currentPosition;
+		m_currentLimit = limot.m_currentLimit;
+	}
+
+	bool isLimited()
+	{
+		if (m_loLimit > m_hiLimit) return false;
+		return true;
+	}
+
+	void testLimitValue(btScalar test_value);
+};
+
+class btTranslationalLimitMotor2
+{
+public:
+	// upper < lower means free
+	// upper == lower means locked
+	// upper > lower means limited
+	btVector3 m_lowerLimit;
+	btVector3 m_upperLimit;
+	btVector3 m_bounce;
+	btVector3 m_stopERP;
+	btVector3 m_stopCFM;
+	btVector3 m_motorERP;
+	btVector3 m_motorCFM;
+	bool m_enableMotor[3];
+	bool m_servoMotor[3];
+	bool m_enableSpring[3];
+	btVector3 m_servoTarget;
+	btVector3 m_springStiffness;
+	bool m_springStiffnessLimited[3];
+	btVector3 m_springDamping;
+	bool m_springDampingLimited[3];
+	btVector3 m_equilibriumPoint;
+	btVector3 m_targetVelocity;
+	btVector3 m_maxMotorForce;
+
+	btVector3 m_currentLimitError;
+	btVector3 m_currentLimitErrorHi;
+	btVector3 m_currentLinearDiff;
+	int m_currentLimit[3];
+
+	btTranslationalLimitMotor2()
+	{
+		m_lowerLimit.setValue(0.f, 0.f, 0.f);
+		m_upperLimit.setValue(0.f, 0.f, 0.f);
+		m_bounce.setValue(0.f, 0.f, 0.f);
+		m_stopERP.setValue(0.2f, 0.2f, 0.2f);
+		m_stopCFM.setValue(0.f, 0.f, 0.f);
+		m_motorERP.setValue(0.9f, 0.9f, 0.9f);
+		m_motorCFM.setValue(0.f, 0.f, 0.f);
+
+		m_currentLimitError.setValue(0.f, 0.f, 0.f);
+		m_currentLimitErrorHi.setValue(0.f, 0.f, 0.f);
+		m_currentLinearDiff.setValue(0.f, 0.f, 0.f);
+
+		for (int i = 0; i < 3; i++)
+		{
+			m_enableMotor[i] = false;
+			m_servoMotor[i] = false;
+			m_enableSpring[i] = false;
+			m_servoTarget[i] = btScalar(0.f);
+			m_springStiffness[i] = btScalar(0.f);
+			m_springStiffnessLimited[i] = false;
+			m_springDamping[i] = btScalar(0.f);
+			m_springDampingLimited[i] = false;
+			m_equilibriumPoint[i] = btScalar(0.f);
+			m_targetVelocity[i] = btScalar(0.f);
+			m_maxMotorForce[i] = btScalar(0.f);
+
+			m_currentLimit[i] = 0;
+		}
+	}
+
+	btTranslationalLimitMotor2(const btTranslationalLimitMotor2& other)
+	{
+		m_lowerLimit = other.m_lowerLimit;
+		m_upperLimit = other.m_upperLimit;
+		m_bounce = other.m_bounce;
+		m_stopERP = other.m_stopERP;
+		m_stopCFM = other.m_stopCFM;
+		m_motorERP = other.m_motorERP;
+		m_motorCFM = other.m_motorCFM;
+
+		m_currentLimitError = other.m_currentLimitError;
+		m_currentLimitErrorHi = other.m_currentLimitErrorHi;
+		m_currentLinearDiff = other.m_currentLinearDiff;
+
+		for (int i = 0; i < 3; i++)
+		{
+			m_enableMotor[i] = other.m_enableMotor[i];
+			m_servoMotor[i] = other.m_servoMotor[i];
+			m_enableSpring[i] = other.m_enableSpring[i];
+			m_servoTarget[i] = other.m_servoTarget[i];
+			m_springStiffness[i] = other.m_springStiffness[i];
+			m_springStiffnessLimited[i] = other.m_springStiffnessLimited[i];
+			m_springDamping[i] = other.m_springDamping[i];
+			m_springDampingLimited[i] = other.m_springDampingLimited[i];
+			m_equilibriumPoint[i] = other.m_equilibriumPoint[i];
+			m_targetVelocity[i] = other.m_targetVelocity[i];
+			m_maxMotorForce[i] = other.m_maxMotorForce[i];
+
+			m_currentLimit[i] = other.m_currentLimit[i];
+		}
+	}
+
+	inline bool isLimited(int limitIndex)
+	{
+		return (m_upperLimit[limitIndex] >= m_lowerLimit[limitIndex]);
+	}
+
+	void testLimitValue(int limitIndex, btScalar test_value);
+};
+
+enum bt6DofFlags2
+{
+	BT_6DOF_FLAGS_CFM_STOP2 = 1,
+	BT_6DOF_FLAGS_ERP_STOP2 = 2,
+	BT_6DOF_FLAGS_CFM_MOTO2 = 4,
+	BT_6DOF_FLAGS_ERP_MOTO2 = 8,
+	BT_6DOF_FLAGS_USE_INFINITE_ERROR = (1<<16)
+};
+#define BT_6DOF_FLAGS_AXIS_SHIFT2 4  // bits per axis
+
+ATTRIBUTE_ALIGNED16(class)
+btGeneric6DofSpring2Constraint : public btTypedConstraint
+{
+protected:
+	btTransform m_frameInA;
+	btTransform m_frameInB;
+
+	btJacobianEntry m_jacLinear[3];
+	btJacobianEntry m_jacAng[3];
+
+	btTranslationalLimitMotor2 m_linearLimits;
+	btRotationalLimitMotor2 m_angularLimits[3];
+
+	RotateOrder m_rotateOrder;
+
+protected:
+	btTransform m_calculatedTransformA;
+	btTransform m_calculatedTransformB;
+	btVector3 m_calculatedAxisAngleDiff;
+	btVector3 m_calculatedAxis[3];
+	btVector3 m_calculatedLinearDiff;
+	btScalar m_factA;
+	btScalar m_factB;
+	bool m_hasStaticBody;
+	int m_flags;
+
+	btGeneric6DofSpring2Constraint& operator=(const btGeneric6DofSpring2Constraint&)
+	{
+		btAssert(0);
+		return *this;
+	}
+
+	int setAngularLimits(btConstraintInfo2 * info, int row_offset, const btTransform& transA, const btTransform& transB, const btVector3& linVelA, const btVector3& linVelB, const btVector3& angVelA, const btVector3& angVelB);
+	int setLinearLimits(btConstraintInfo2 * info, int row, const btTransform& transA, const btTransform& transB, const btVector3& linVelA, const btVector3& linVelB, const btVector3& angVelA, const btVector3& angVelB);
+
+	void calculateLinearInfo();
+	void calculateAngleInfo();
+	void testAngularLimitMotor(int axis_index);
+
+	void calculateJacobi(btRotationalLimitMotor2 * limot, const btTransform& transA, const btTransform& transB, btConstraintInfo2* info, int srow, btVector3& ax1, int rotational, int rotAllowed);
+	int get_limit_motor_info2(btRotationalLimitMotor2 * limot,
+							  const btTransform& transA, const btTransform& transB, const btVector3& linVelA, const btVector3& linVelB, const btVector3& angVelA, const btVector3& angVelB,
+							  btConstraintInfo2* info, int row, btVector3& ax1, int rotational, int rotAllowed = false);
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btGeneric6DofSpring2Constraint(btRigidBody & rbA, btRigidBody & rbB, const btTransform& frameInA, const btTransform& frameInB, RotateOrder rotOrder = RO_XYZ);
+	btGeneric6DofSpring2Constraint(btRigidBody & rbB, const btTransform& frameInB, RotateOrder rotOrder = RO_XYZ);
+
+	virtual void buildJacobian() {}
+	virtual void getInfo1(btConstraintInfo1 * info);
+	virtual void getInfo2(btConstraintInfo2 * info);
+	virtual int calculateSerializeBufferSize() const;
+	virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
+
+	btRotationalLimitMotor2* getRotationalLimitMotor(int index) { return &m_angularLimits[index]; }
+	btTranslationalLimitMotor2* getTranslationalLimitMotor() { return &m_linearLimits; }
+
+	// Calculates the global transform for the joint offset for body A an B, and also calculates the angle differences between the bodies.
+	void calculateTransforms(const btTransform& transA, const btTransform& transB);
+	void calculateTransforms();
+
+	// Gets the global transform of the offset for body A
+	const btTransform& getCalculatedTransformA() const { return m_calculatedTransformA; }
+	// Gets the global transform of the offset for body B
+	const btTransform& getCalculatedTransformB() const { return m_calculatedTransformB; }
+
+	const btTransform& getFrameOffsetA() const { return m_frameInA; }
+	const btTransform& getFrameOffsetB() const { return m_frameInB; }
+
+	btTransform& getFrameOffsetA() { return m_frameInA; }
+	btTransform& getFrameOffsetB() { return m_frameInB; }
+
+	// Get the rotation axis in global coordinates ( btGeneric6DofSpring2Constraint::calculateTransforms() must be called previously )
+	btVector3 getAxis(int axis_index) const { return m_calculatedAxis[axis_index]; }
+
+	// Get the relative Euler angle ( btGeneric6DofSpring2Constraint::calculateTransforms() must be called previously )
+	btScalar getAngle(int axis_index) const { return m_calculatedAxisAngleDiff[axis_index]; }
+
+	// Get the relative position of the constraint pivot ( btGeneric6DofSpring2Constraint::calculateTransforms() must be called previously )
+	btScalar getRelativePivotPosition(int axis_index) const { return m_calculatedLinearDiff[axis_index]; }
+
+	void setFrames(const btTransform& frameA, const btTransform& frameB);
+
+	void setLinearLowerLimit(const btVector3& linearLower) { m_linearLimits.m_lowerLimit = linearLower; }
+	void getLinearLowerLimit(btVector3 & linearLower) { linearLower = m_linearLimits.m_lowerLimit; }
+	void setLinearUpperLimit(const btVector3& linearUpper) { m_linearLimits.m_upperLimit = linearUpper; }
+	void getLinearUpperLimit(btVector3 & linearUpper) { linearUpper = m_linearLimits.m_upperLimit; }
+
+	void setAngularLowerLimit(const btVector3& angularLower)
+	{
+		for (int i = 0; i < 3; i++)
+			m_angularLimits[i].m_loLimit = btNormalizeAngle(angularLower[i]);
+	}
+
+	void setAngularLowerLimitReversed(const btVector3& angularLower)
+	{
+		for (int i = 0; i < 3; i++)
+			m_angularLimits[i].m_hiLimit = btNormalizeAngle(-angularLower[i]);
+	}
+
+	void getAngularLowerLimit(btVector3 & angularLower)
+	{
+		for (int i = 0; i < 3; i++)
+			angularLower[i] = m_angularLimits[i].m_loLimit;
+	}
+
+	void getAngularLowerLimitReversed(btVector3 & angularLower)
+	{
+		for (int i = 0; i < 3; i++)
+			angularLower[i] = -m_angularLimits[i].m_hiLimit;
+	}
+
+	void setAngularUpperLimit(const btVector3& angularUpper)
+	{
+		for (int i = 0; i < 3; i++)
+			m_angularLimits[i].m_hiLimit = btNormalizeAngle(angularUpper[i]);
+	}
+
+	void setAngularUpperLimitReversed(const btVector3& angularUpper)
+	{
+		for (int i = 0; i < 3; i++)
+			m_angularLimits[i].m_loLimit = btNormalizeAngle(-angularUpper[i]);
+	}
+
+	void getAngularUpperLimit(btVector3 & angularUpper)
+	{
+		for (int i = 0; i < 3; i++)
+			angularUpper[i] = m_angularLimits[i].m_hiLimit;
+	}
+
+	void getAngularUpperLimitReversed(btVector3 & angularUpper)
+	{
+		for (int i = 0; i < 3; i++)
+			angularUpper[i] = -m_angularLimits[i].m_loLimit;
+	}
+
+	//first 3 are linear, next 3 are angular
+
+	void setLimit(int axis, btScalar lo, btScalar hi)
+	{
+		if (axis < 3)
+		{
+			m_linearLimits.m_lowerLimit[axis] = lo;
+			m_linearLimits.m_upperLimit[axis] = hi;
+		}
+		else
+		{
+			lo = btNormalizeAngle(lo);
+			hi = btNormalizeAngle(hi);
+			m_angularLimits[axis - 3].m_loLimit = lo;
+			m_angularLimits[axis - 3].m_hiLimit = hi;
+		}
+	}
+
+	void setLimitReversed(int axis, btScalar lo, btScalar hi)
+	{
+		if (axis < 3)
+		{
+			m_linearLimits.m_lowerLimit[axis] = lo;
+			m_linearLimits.m_upperLimit[axis] = hi;
+		}
+		else
+		{
+			lo = btNormalizeAngle(lo);
+			hi = btNormalizeAngle(hi);
+			m_angularLimits[axis - 3].m_hiLimit = -lo;
+			m_angularLimits[axis - 3].m_loLimit = -hi;
+		}
+	}
+
+	bool isLimited(int limitIndex)
+	{
+		if (limitIndex < 3)
+		{
+			return m_linearLimits.isLimited(limitIndex);
+		}
+		return m_angularLimits[limitIndex - 3].isLimited();
+	}
+
+	void setRotationOrder(RotateOrder order) { m_rotateOrder = order; }
+	RotateOrder getRotationOrder() { return m_rotateOrder; }
+
+	void setAxis(const btVector3& axis1, const btVector3& axis2);
+
+	void setBounce(int index, btScalar bounce);
+
+	void enableMotor(int index, bool onOff);
+	void setServo(int index, bool onOff);  // set the type of the motor (servo or not) (the motor has to be turned on for servo also)
+	void setTargetVelocity(int index, btScalar velocity);
+	void setServoTarget(int index, btScalar target);
+	void setMaxMotorForce(int index, btScalar force);
+
+	void enableSpring(int index, bool onOff);
+	void setStiffness(int index, btScalar stiffness, bool limitIfNeeded = true);  // if limitIfNeeded is true the system will automatically limit the stiffness in necessary situations where otherwise the spring would move unrealistically too widely
+	void setDamping(int index, btScalar damping, bool limitIfNeeded = true);      // if limitIfNeeded is true the system will automatically limit the damping in necessary situations where otherwise the spring would blow up
+	void setEquilibriumPoint();                                                   // set the current constraint position/orientation as an equilibrium point for all DOF
+	void setEquilibriumPoint(int index);                                          // set the current constraint position/orientation as an equilibrium point for given DOF
+	void setEquilibriumPoint(int index, btScalar val);
+
+	//override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5).
+	//If no axis is provided, it uses the default axis for this constraint.
+	virtual void setParam(int num, btScalar value, int axis = -1);
+	virtual btScalar getParam(int num, int axis = -1) const;
+
+	static btScalar btGetMatrixElem(const btMatrix3x3& mat, int index);
+	static bool matrixToEulerXYZ(const btMatrix3x3& mat, btVector3& xyz);
+	static bool matrixToEulerXZY(const btMatrix3x3& mat, btVector3& xyz);
+	static bool matrixToEulerYXZ(const btMatrix3x3& mat, btVector3& xyz);
+	static bool matrixToEulerYZX(const btMatrix3x3& mat, btVector3& xyz);
+	static bool matrixToEulerZXY(const btMatrix3x3& mat, btVector3& xyz);
+	static bool matrixToEulerZYX(const btMatrix3x3& mat, btVector3& xyz);
+};
+
+struct btGeneric6DofSpring2ConstraintData
+{
+	btTypedConstraintData m_typeConstraintData;
+	btTransformFloatData m_rbAFrame;
+	btTransformFloatData m_rbBFrame;
+
+	btVector3FloatData m_linearUpperLimit;
+	btVector3FloatData m_linearLowerLimit;
+	btVector3FloatData m_linearBounce;
+	btVector3FloatData m_linearStopERP;
+	btVector3FloatData m_linearStopCFM;
+	btVector3FloatData m_linearMotorERP;
+	btVector3FloatData m_linearMotorCFM;
+	btVector3FloatData m_linearTargetVelocity;
+	btVector3FloatData m_linearMaxMotorForce;
+	btVector3FloatData m_linearServoTarget;
+	btVector3FloatData m_linearSpringStiffness;
+	btVector3FloatData m_linearSpringDamping;
+	btVector3FloatData m_linearEquilibriumPoint;
+	char m_linearEnableMotor[4];
+	char m_linearServoMotor[4];
+	char m_linearEnableSpring[4];
+	char m_linearSpringStiffnessLimited[4];
+	char m_linearSpringDampingLimited[4];
+	char m_padding1[4];
+
+	btVector3FloatData m_angularUpperLimit;
+	btVector3FloatData m_angularLowerLimit;
+	btVector3FloatData m_angularBounce;
+	btVector3FloatData m_angularStopERP;
+	btVector3FloatData m_angularStopCFM;
+	btVector3FloatData m_angularMotorERP;
+	btVector3FloatData m_angularMotorCFM;
+	btVector3FloatData m_angularTargetVelocity;
+	btVector3FloatData m_angularMaxMotorForce;
+	btVector3FloatData m_angularServoTarget;
+	btVector3FloatData m_angularSpringStiffness;
+	btVector3FloatData m_angularSpringDamping;
+	btVector3FloatData m_angularEquilibriumPoint;
+	char m_angularEnableMotor[4];
+	char m_angularServoMotor[4];
+	char m_angularEnableSpring[4];
+	char m_angularSpringStiffnessLimited[4];
+	char m_angularSpringDampingLimited[4];
+
+	int m_rotateOrder;
+};
+
+struct btGeneric6DofSpring2ConstraintDoubleData2
+{
+	btTypedConstraintDoubleData m_typeConstraintData;
+	btTransformDoubleData m_rbAFrame;
+	btTransformDoubleData m_rbBFrame;
+
+	btVector3DoubleData m_linearUpperLimit;
+	btVector3DoubleData m_linearLowerLimit;
+	btVector3DoubleData m_linearBounce;
+	btVector3DoubleData m_linearStopERP;
+	btVector3DoubleData m_linearStopCFM;
+	btVector3DoubleData m_linearMotorERP;
+	btVector3DoubleData m_linearMotorCFM;
+	btVector3DoubleData m_linearTargetVelocity;
+	btVector3DoubleData m_linearMaxMotorForce;
+	btVector3DoubleData m_linearServoTarget;
+	btVector3DoubleData m_linearSpringStiffness;
+	btVector3DoubleData m_linearSpringDamping;
+	btVector3DoubleData m_linearEquilibriumPoint;
+	char m_linearEnableMotor[4];
+	char m_linearServoMotor[4];
+	char m_linearEnableSpring[4];
+	char m_linearSpringStiffnessLimited[4];
+	char m_linearSpringDampingLimited[4];
+	char m_padding1[4];
+
+	btVector3DoubleData m_angularUpperLimit;
+	btVector3DoubleData m_angularLowerLimit;
+	btVector3DoubleData m_angularBounce;
+	btVector3DoubleData m_angularStopERP;
+	btVector3DoubleData m_angularStopCFM;
+	btVector3DoubleData m_angularMotorERP;
+	btVector3DoubleData m_angularMotorCFM;
+	btVector3DoubleData m_angularTargetVelocity;
+	btVector3DoubleData m_angularMaxMotorForce;
+	btVector3DoubleData m_angularServoTarget;
+	btVector3DoubleData m_angularSpringStiffness;
+	btVector3DoubleData m_angularSpringDamping;
+	btVector3DoubleData m_angularEquilibriumPoint;
+	char m_angularEnableMotor[4];
+	char m_angularServoMotor[4];
+	char m_angularEnableSpring[4];
+	char m_angularSpringStiffnessLimited[4];
+	char m_angularSpringDampingLimited[4];
+
+	int m_rotateOrder;
+};
+
+SIMD_FORCE_INLINE int btGeneric6DofSpring2Constraint::calculateSerializeBufferSize() const
+{
+	return sizeof(btGeneric6DofSpring2ConstraintData2);
+}
+
+SIMD_FORCE_INLINE const char* btGeneric6DofSpring2Constraint::serialize(void* dataBuffer, btSerializer* serializer) const
+{
+	btGeneric6DofSpring2ConstraintData2* dof = (btGeneric6DofSpring2ConstraintData2*)dataBuffer;
+	btTypedConstraint::serialize(&dof->m_typeConstraintData, serializer);
+
+	m_frameInA.serialize(dof->m_rbAFrame);
+	m_frameInB.serialize(dof->m_rbBFrame);
+
+	int i;
+	for (i = 0; i < 3; i++)
+	{
+		dof->m_angularLowerLimit.m_floats[i] = m_angularLimits[i].m_loLimit;
+		dof->m_angularUpperLimit.m_floats[i] = m_angularLimits[i].m_hiLimit;
+		dof->m_angularBounce.m_floats[i] = m_angularLimits[i].m_bounce;
+		dof->m_angularStopERP.m_floats[i] = m_angularLimits[i].m_stopERP;
+		dof->m_angularStopCFM.m_floats[i] = m_angularLimits[i].m_stopCFM;
+		dof->m_angularMotorERP.m_floats[i] = m_angularLimits[i].m_motorERP;
+		dof->m_angularMotorCFM.m_floats[i] = m_angularLimits[i].m_motorCFM;
+		dof->m_angularTargetVelocity.m_floats[i] = m_angularLimits[i].m_targetVelocity;
+		dof->m_angularMaxMotorForce.m_floats[i] = m_angularLimits[i].m_maxMotorForce;
+		dof->m_angularServoTarget.m_floats[i] = m_angularLimits[i].m_servoTarget;
+		dof->m_angularSpringStiffness.m_floats[i] = m_angularLimits[i].m_springStiffness;
+		dof->m_angularSpringDamping.m_floats[i] = m_angularLimits[i].m_springDamping;
+		dof->m_angularEquilibriumPoint.m_floats[i] = m_angularLimits[i].m_equilibriumPoint;
+	}
+	dof->m_angularLowerLimit.m_floats[3] = 0;
+	dof->m_angularUpperLimit.m_floats[3] = 0;
+	dof->m_angularBounce.m_floats[3] = 0;
+	dof->m_angularStopERP.m_floats[3] = 0;
+	dof->m_angularStopCFM.m_floats[3] = 0;
+	dof->m_angularMotorERP.m_floats[3] = 0;
+	dof->m_angularMotorCFM.m_floats[3] = 0;
+	dof->m_angularTargetVelocity.m_floats[3] = 0;
+	dof->m_angularMaxMotorForce.m_floats[3] = 0;
+	dof->m_angularServoTarget.m_floats[3] = 0;
+	dof->m_angularSpringStiffness.m_floats[3] = 0;
+	dof->m_angularSpringDamping.m_floats[3] = 0;
+	dof->m_angularEquilibriumPoint.m_floats[3] = 0;
+	for (i = 0; i < 4; i++)
+	{
+		dof->m_angularEnableMotor[i] = i < 3 ? (m_angularLimits[i].m_enableMotor ? 1 : 0) : 0;
+		dof->m_angularServoMotor[i] = i < 3 ? (m_angularLimits[i].m_servoMotor ? 1 : 0) : 0;
+		dof->m_angularEnableSpring[i] = i < 3 ? (m_angularLimits[i].m_enableSpring ? 1 : 0) : 0;
+		dof->m_angularSpringStiffnessLimited[i] = i < 3 ? (m_angularLimits[i].m_springStiffnessLimited ? 1 : 0) : 0;
+		dof->m_angularSpringDampingLimited[i] = i < 3 ? (m_angularLimits[i].m_springDampingLimited ? 1 : 0) : 0;
+	}
+
+	m_linearLimits.m_lowerLimit.serialize(dof->m_linearLowerLimit);
+	m_linearLimits.m_upperLimit.serialize(dof->m_linearUpperLimit);
+	m_linearLimits.m_bounce.serialize(dof->m_linearBounce);
+	m_linearLimits.m_stopERP.serialize(dof->m_linearStopERP);
+	m_linearLimits.m_stopCFM.serialize(dof->m_linearStopCFM);
+	m_linearLimits.m_motorERP.serialize(dof->m_linearMotorERP);
+	m_linearLimits.m_motorCFM.serialize(dof->m_linearMotorCFM);
+	m_linearLimits.m_targetVelocity.serialize(dof->m_linearTargetVelocity);
+	m_linearLimits.m_maxMotorForce.serialize(dof->m_linearMaxMotorForce);
+	m_linearLimits.m_servoTarget.serialize(dof->m_linearServoTarget);
+	m_linearLimits.m_springStiffness.serialize(dof->m_linearSpringStiffness);
+	m_linearLimits.m_springDamping.serialize(dof->m_linearSpringDamping);
+	m_linearLimits.m_equilibriumPoint.serialize(dof->m_linearEquilibriumPoint);
+	for (i = 0; i < 4; i++)
+	{
+		dof->m_linearEnableMotor[i] = i < 3 ? (m_linearLimits.m_enableMotor[i] ? 1 : 0) : 0;
+		dof->m_linearServoMotor[i] = i < 3 ? (m_linearLimits.m_servoMotor[i] ? 1 : 0) : 0;
+		dof->m_linearEnableSpring[i] = i < 3 ? (m_linearLimits.m_enableSpring[i] ? 1 : 0) : 0;
+		dof->m_linearSpringStiffnessLimited[i] = i < 3 ? (m_linearLimits.m_springStiffnessLimited[i] ? 1 : 0) : 0;
+		dof->m_linearSpringDampingLimited[i] = i < 3 ? (m_linearLimits.m_springDampingLimited[i] ? 1 : 0) : 0;
+	}
+
+	dof->m_rotateOrder = m_rotateOrder;
+
+	dof->m_padding1[0] = 0;
+	dof->m_padding1[1] = 0;
+	dof->m_padding1[2] = 0;
+	dof->m_padding1[3] = 0;
+
+	return btGeneric6DofSpring2ConstraintDataName;
+}
+
+#endif  //BT_GENERIC_6DOF_CONSTRAINT_H
diff --git a/engine/inc/bullet/BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.h b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.h
new file mode 100644
index 00000000..02b9d4d0
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.h
@@ -0,0 +1,135 @@
+/*
+Bullet Continuous Collision Detection and Physics Library, http://bulletphysics.org
+Copyright (C) 2006, 2007 Sony Computer Entertainment Inc. 
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_GENERIC_6DOF_SPRING_CONSTRAINT_H
+#define BT_GENERIC_6DOF_SPRING_CONSTRAINT_H
+
+#include "LinearMath/btVector3.h"
+#include "btTypedConstraint.h"
+#include "btGeneric6DofConstraint.h"
+
+#ifdef BT_USE_DOUBLE_PRECISION
+#define btGeneric6DofSpringConstraintData2 btGeneric6DofSpringConstraintDoubleData2
+#define btGeneric6DofSpringConstraintDataName "btGeneric6DofSpringConstraintDoubleData2"
+#else
+#define btGeneric6DofSpringConstraintData2 btGeneric6DofSpringConstraintData
+#define btGeneric6DofSpringConstraintDataName "btGeneric6DofSpringConstraintData"
+#endif  //BT_USE_DOUBLE_PRECISION
+
+/// Generic 6 DOF constraint that allows to set spring motors to any translational and rotational DOF
+
+/// DOF index used in enableSpring() and setStiffness() means:
+/// 0 : translation X
+/// 1 : translation Y
+/// 2 : translation Z
+/// 3 : rotation X (3rd Euler rotational around new position of X axis, range [-PI+epsilon, PI-epsilon] )
+/// 4 : rotation Y (2nd Euler rotational around new position of Y axis, range [-PI/2+epsilon, PI/2-epsilon] )
+/// 5 : rotation Z (1st Euler rotational around Z axis, range [-PI+epsilon, PI-epsilon] )
+
+ATTRIBUTE_ALIGNED16(class)
+btGeneric6DofSpringConstraint : public btGeneric6DofConstraint
+{
+protected:
+	bool m_springEnabled[6];
+	btScalar m_equilibriumPoint[6];
+	btScalar m_springStiffness[6];
+	btScalar m_springDamping[6];  // between 0 and 1 (1 == no damping)
+	void init();
+	void internalUpdateSprings(btConstraintInfo2 * info);
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btGeneric6DofSpringConstraint(btRigidBody & rbA, btRigidBody & rbB, const btTransform& frameInA, const btTransform& frameInB, bool useLinearReferenceFrameA);
+	btGeneric6DofSpringConstraint(btRigidBody & rbB, const btTransform& frameInB, bool useLinearReferenceFrameB);
+	void enableSpring(int index, bool onOff);
+	void setStiffness(int index, btScalar stiffness);
+	void setDamping(int index, btScalar damping);
+	void setEquilibriumPoint();           // set the current constraint position/orientation as an equilibrium point for all DOF
+	void setEquilibriumPoint(int index);  // set the current constraint position/orientation as an equilibrium point for given DOF
+	void setEquilibriumPoint(int index, btScalar val);
+
+	bool isSpringEnabled(int index) const
+	{
+		return m_springEnabled[index];
+	}
+
+	btScalar getStiffness(int index) const
+	{
+		return m_springStiffness[index];
+	}
+
+	btScalar getDamping(int index) const
+	{
+		return m_springDamping[index];
+	}
+
+	btScalar getEquilibriumPoint(int index) const
+	{
+		return m_equilibriumPoint[index];
+	}
+
+	virtual void setAxis(const btVector3& axis1, const btVector3& axis2);
+
+	virtual void getInfo2(btConstraintInfo2 * info);
+
+	virtual int calculateSerializeBufferSize() const;
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
+};
+
+struct btGeneric6DofSpringConstraintData
+{
+	btGeneric6DofConstraintData m_6dofData;
+
+	int m_springEnabled[6];
+	float m_equilibriumPoint[6];
+	float m_springStiffness[6];
+	float m_springDamping[6];
+};
+
+struct btGeneric6DofSpringConstraintDoubleData2
+{
+	btGeneric6DofConstraintDoubleData2 m_6dofData;
+
+	int m_springEnabled[6];
+	double m_equilibriumPoint[6];
+	double m_springStiffness[6];
+	double m_springDamping[6];
+};
+
+SIMD_FORCE_INLINE int btGeneric6DofSpringConstraint::calculateSerializeBufferSize() const
+{
+	return sizeof(btGeneric6DofSpringConstraintData2);
+}
+
+///fills the dataBuffer and returns the struct name (and 0 on failure)
+SIMD_FORCE_INLINE const char* btGeneric6DofSpringConstraint::serialize(void* dataBuffer, btSerializer* serializer) const
+{
+	btGeneric6DofSpringConstraintData2* dof = (btGeneric6DofSpringConstraintData2*)dataBuffer;
+	btGeneric6DofConstraint::serialize(&dof->m_6dofData, serializer);
+
+	int i;
+	for (i = 0; i < 6; i++)
+	{
+		dof->m_equilibriumPoint[i] = m_equilibriumPoint[i];
+		dof->m_springDamping[i] = m_springDamping[i];
+		dof->m_springEnabled[i] = m_springEnabled[i] ? 1 : 0;
+		dof->m_springStiffness[i] = m_springStiffness[i];
+	}
+	return btGeneric6DofSpringConstraintDataName;
+}
+
+#endif  // BT_GENERIC_6DOF_SPRING_CONSTRAINT_H
diff --git a/engine/inc/bullet/BulletDynamics/ConstraintSolver/btHinge2Constraint.h b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btHinge2Constraint.h
new file mode 100644
index 00000000..95f604a8
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btHinge2Constraint.h
@@ -0,0 +1,55 @@
+/*
+Bullet Continuous Collision Detection and Physics Library, http://bulletphysics.org
+Copyright (C) 2006, 2007 Sony Computer Entertainment Inc. 
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_HINGE2_CONSTRAINT_H
+#define BT_HINGE2_CONSTRAINT_H
+
+#include "LinearMath/btVector3.h"
+#include "btTypedConstraint.h"
+#include "btGeneric6DofSpring2Constraint.h"
+
+// Constraint similar to ODE Hinge2 Joint
+// has 3 degrees of frredom:
+// 2 rotational degrees of freedom, similar to Euler rotations around Z (axis 1) and X (axis 2)
+// 1 translational (along axis Z) with suspension spring
+
+ATTRIBUTE_ALIGNED16(class)
+btHinge2Constraint : public btGeneric6DofSpring2Constraint
+{
+protected:
+	btVector3 m_anchor;
+	btVector3 m_axis1;
+	btVector3 m_axis2;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	// constructor
+	// anchor, axis1 and axis2 are in world coordinate system
+	// axis1 must be orthogonal to axis2
+	btHinge2Constraint(btRigidBody & rbA, btRigidBody & rbB, btVector3 & anchor, btVector3 & axis1, btVector3 & axis2);
+	// access
+	const btVector3& getAnchor() { return m_calculatedTransformA.getOrigin(); }
+	const btVector3& getAnchor2() { return m_calculatedTransformB.getOrigin(); }
+	const btVector3& getAxis1() { return m_axis1; }
+	const btVector3& getAxis2() { return m_axis2; }
+	btScalar getAngle1() { return getAngle(2); }
+	btScalar getAngle2() { return getAngle(0); }
+	// limits
+	void setUpperLimit(btScalar ang1max) { setAngularUpperLimit(btVector3(-1.f, 0.f, ang1max)); }
+	void setLowerLimit(btScalar ang1min) { setAngularLowerLimit(btVector3(1.f, 0.f, ang1min)); }
+};
+
+#endif  // BT_HINGE2_CONSTRAINT_H
diff --git a/engine/inc/bullet/BulletDynamics/ConstraintSolver/btHingeConstraint.h b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btHingeConstraint.h
new file mode 100644
index 00000000..c7509e30
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btHingeConstraint.h
@@ -0,0 +1,480 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+/* Hinge Constraint by Dirk Gregorius. Limits added by Marcus Hennix at Starbreeze Studios */
+
+#ifndef BT_HINGECONSTRAINT_H
+#define BT_HINGECONSTRAINT_H
+
+#define _BT_USE_CENTER_LIMIT_ 1
+
+#include "LinearMath/btVector3.h"
+#include "btJacobianEntry.h"
+#include "btTypedConstraint.h"
+
+class btRigidBody;
+
+#ifdef BT_USE_DOUBLE_PRECISION
+#define btHingeConstraintData btHingeConstraintDoubleData2  //rename to 2 for backwards compatibility, so we can still load the 'btHingeConstraintDoubleData' version
+#define btHingeConstraintDataName "btHingeConstraintDoubleData2"
+#else
+#define btHingeConstraintData btHingeConstraintFloatData
+#define btHingeConstraintDataName "btHingeConstraintFloatData"
+#endif  //BT_USE_DOUBLE_PRECISION
+
+enum btHingeFlags
+{
+	BT_HINGE_FLAGS_CFM_STOP = 1,
+	BT_HINGE_FLAGS_ERP_STOP = 2,
+	BT_HINGE_FLAGS_CFM_NORM = 4,
+	BT_HINGE_FLAGS_ERP_NORM = 8
+};
+
+/// hinge constraint between two rigidbodies each with a pivotpoint that descibes the axis location in local space
+/// axis defines the orientation of the hinge axis
+ATTRIBUTE_ALIGNED16(class)
+btHingeConstraint : public btTypedConstraint
+{
+#ifdef IN_PARALLELL_SOLVER
+public:
+#endif
+	btJacobianEntry m_jac[3];     //3 orthogonal linear constraints
+	btJacobianEntry m_jacAng[3];  //2 orthogonal angular constraints+ 1 for limit/motor
+
+	btTransform m_rbAFrame;  // constraint axii. Assumes z is hinge axis.
+	btTransform m_rbBFrame;
+
+	btScalar m_motorTargetVelocity;
+	btScalar m_maxMotorImpulse;
+
+#ifdef _BT_USE_CENTER_LIMIT_
+	btAngularLimit m_limit;
+#else
+	btScalar m_lowerLimit;
+	btScalar m_upperLimit;
+	btScalar m_limitSign;
+	btScalar m_correction;
+
+	btScalar m_limitSoftness;
+	btScalar m_biasFactor;
+	btScalar m_relaxationFactor;
+
+	bool m_solveLimit;
+#endif
+
+	btScalar m_kHinge;
+
+	btScalar m_accLimitImpulse;
+	btScalar m_hingeAngle;
+	btScalar m_referenceSign;
+
+	bool m_angularOnly;
+	bool m_enableAngularMotor;
+	bool m_useSolveConstraintObsolete;
+	bool m_useOffsetForConstraintFrame;
+	bool m_useReferenceFrameA;
+
+	btScalar m_accMotorImpulse;
+
+	int m_flags;
+	btScalar m_normalCFM;
+	btScalar m_normalERP;
+	btScalar m_stopCFM;
+	btScalar m_stopERP;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btHingeConstraint(btRigidBody & rbA, btRigidBody & rbB, const btVector3& pivotInA, const btVector3& pivotInB, const btVector3& axisInA, const btVector3& axisInB, bool useReferenceFrameA = false);
+
+	btHingeConstraint(btRigidBody & rbA, const btVector3& pivotInA, const btVector3& axisInA, bool useReferenceFrameA = false);
+
+	btHingeConstraint(btRigidBody & rbA, btRigidBody & rbB, const btTransform& rbAFrame, const btTransform& rbBFrame, bool useReferenceFrameA = false);
+
+	btHingeConstraint(btRigidBody & rbA, const btTransform& rbAFrame, bool useReferenceFrameA = false);
+
+	virtual void buildJacobian();
+
+	virtual void getInfo1(btConstraintInfo1 * info);
+
+	void getInfo1NonVirtual(btConstraintInfo1 * info);
+
+	virtual void getInfo2(btConstraintInfo2 * info);
+
+	void getInfo2NonVirtual(btConstraintInfo2 * info, const btTransform& transA, const btTransform& transB, const btVector3& angVelA, const btVector3& angVelB);
+
+	void getInfo2Internal(btConstraintInfo2 * info, const btTransform& transA, const btTransform& transB, const btVector3& angVelA, const btVector3& angVelB);
+	void getInfo2InternalUsingFrameOffset(btConstraintInfo2 * info, const btTransform& transA, const btTransform& transB, const btVector3& angVelA, const btVector3& angVelB);
+
+	void updateRHS(btScalar timeStep);
+
+	const btRigidBody& getRigidBodyA() const
+	{
+		return m_rbA;
+	}
+	const btRigidBody& getRigidBodyB() const
+	{
+		return m_rbB;
+	}
+
+	btRigidBody& getRigidBodyA()
+	{
+		return m_rbA;
+	}
+
+	btRigidBody& getRigidBodyB()
+	{
+		return m_rbB;
+	}
+
+	btTransform& getFrameOffsetA()
+	{
+		return m_rbAFrame;
+	}
+
+	btTransform& getFrameOffsetB()
+	{
+		return m_rbBFrame;
+	}
+
+	void setFrames(const btTransform& frameA, const btTransform& frameB);
+
+	void setAngularOnly(bool angularOnly)
+	{
+		m_angularOnly = angularOnly;
+	}
+
+	void enableAngularMotor(bool enableMotor, btScalar targetVelocity, btScalar maxMotorImpulse)
+	{
+		m_enableAngularMotor = enableMotor;
+		m_motorTargetVelocity = targetVelocity;
+		m_maxMotorImpulse = maxMotorImpulse;
+	}
+
+	// extra motor API, including ability to set a target rotation (as opposed to angular velocity)
+	// note: setMotorTarget sets angular velocity under the hood, so you must call it every tick to
+	//       maintain a given angular target.
+	void enableMotor(bool enableMotor) { m_enableAngularMotor = enableMotor; }
+	void setMaxMotorImpulse(btScalar maxMotorImpulse) { m_maxMotorImpulse = maxMotorImpulse; }
+	void setMotorTargetVelocity(btScalar motorTargetVelocity) { m_motorTargetVelocity = motorTargetVelocity; }
+	void setMotorTarget(const btQuaternion& qAinB, btScalar dt);  // qAinB is rotation of body A wrt body B.
+	void setMotorTarget(btScalar targetAngle, btScalar dt);
+
+	void setLimit(btScalar low, btScalar high, btScalar _softness = 0.9f, btScalar _biasFactor = 0.3f, btScalar _relaxationFactor = 1.0f)
+	{
+#ifdef _BT_USE_CENTER_LIMIT_
+		m_limit.set(low, high, _softness, _biasFactor, _relaxationFactor);
+#else
+		m_lowerLimit = btNormalizeAngle(low);
+		m_upperLimit = btNormalizeAngle(high);
+		m_limitSoftness = _softness;
+		m_biasFactor = _biasFactor;
+		m_relaxationFactor = _relaxationFactor;
+#endif
+	}
+
+	btScalar getLimitSoftness() const
+	{
+#ifdef _BT_USE_CENTER_LIMIT_
+		return m_limit.getSoftness();
+#else
+		return m_limitSoftness;
+#endif
+	}
+
+	btScalar getLimitBiasFactor() const
+	{
+#ifdef _BT_USE_CENTER_LIMIT_
+		return m_limit.getBiasFactor();
+#else
+		return m_biasFactor;
+#endif
+	}
+
+	btScalar getLimitRelaxationFactor() const
+	{
+#ifdef _BT_USE_CENTER_LIMIT_
+		return m_limit.getRelaxationFactor();
+#else
+		return m_relaxationFactor;
+#endif
+	}
+
+	void setAxis(btVector3 & axisInA)
+	{
+		btVector3 rbAxisA1, rbAxisA2;
+		btPlaneSpace1(axisInA, rbAxisA1, rbAxisA2);
+		btVector3 pivotInA = m_rbAFrame.getOrigin();
+		//		m_rbAFrame.getOrigin() = pivotInA;
+		m_rbAFrame.getBasis().setValue(rbAxisA1.getX(), rbAxisA2.getX(), axisInA.getX(),
+									   rbAxisA1.getY(), rbAxisA2.getY(), axisInA.getY(),
+									   rbAxisA1.getZ(), rbAxisA2.getZ(), axisInA.getZ());
+
+		btVector3 axisInB = m_rbA.getCenterOfMassTransform().getBasis() * axisInA;
+
+		btQuaternion rotationArc = shortestArcQuat(axisInA, axisInB);
+		btVector3 rbAxisB1 = quatRotate(rotationArc, rbAxisA1);
+		btVector3 rbAxisB2 = axisInB.cross(rbAxisB1);
+
+		m_rbBFrame.getOrigin() = m_rbB.getCenterOfMassTransform().inverse()(m_rbA.getCenterOfMassTransform()(pivotInA));
+
+		m_rbBFrame.getBasis().setValue(rbAxisB1.getX(), rbAxisB2.getX(), axisInB.getX(),
+									   rbAxisB1.getY(), rbAxisB2.getY(), axisInB.getY(),
+									   rbAxisB1.getZ(), rbAxisB2.getZ(), axisInB.getZ());
+		m_rbBFrame.getBasis() = m_rbB.getCenterOfMassTransform().getBasis().inverse() * m_rbBFrame.getBasis();
+	}
+
+	bool hasLimit() const
+	{
+#ifdef _BT_USE_CENTER_LIMIT_
+		return m_limit.getHalfRange() > 0;
+#else
+		return m_lowerLimit <= m_upperLimit;
+#endif
+	}
+
+	btScalar getLowerLimit() const
+	{
+#ifdef _BT_USE_CENTER_LIMIT_
+		return m_limit.getLow();
+#else
+		return m_lowerLimit;
+#endif
+	}
+
+	btScalar getUpperLimit() const
+	{
+#ifdef _BT_USE_CENTER_LIMIT_
+		return m_limit.getHigh();
+#else
+		return m_upperLimit;
+#endif
+	}
+
+	///The getHingeAngle gives the hinge angle in range [-PI,PI]
+	btScalar getHingeAngle();
+
+	btScalar getHingeAngle(const btTransform& transA, const btTransform& transB);
+
+	void testLimit(const btTransform& transA, const btTransform& transB);
+
+	const btTransform& getAFrame() const { return m_rbAFrame; };
+	const btTransform& getBFrame() const { return m_rbBFrame; };
+
+	btTransform& getAFrame() { return m_rbAFrame; };
+	btTransform& getBFrame() { return m_rbBFrame; };
+
+	inline int getSolveLimit()
+	{
+#ifdef _BT_USE_CENTER_LIMIT_
+		return m_limit.isLimit();
+#else
+		return m_solveLimit;
+#endif
+	}
+
+	inline btScalar getLimitSign()
+	{
+#ifdef _BT_USE_CENTER_LIMIT_
+		return m_limit.getSign();
+#else
+		return m_limitSign;
+#endif
+	}
+
+	inline bool getAngularOnly()
+	{
+		return m_angularOnly;
+	}
+	inline bool getEnableAngularMotor()
+	{
+		return m_enableAngularMotor;
+	}
+	inline btScalar getMotorTargetVelocity()
+	{
+		return m_motorTargetVelocity;
+	}
+	inline btScalar getMaxMotorImpulse()
+	{
+		return m_maxMotorImpulse;
+	}
+	// access for UseFrameOffset
+	bool getUseFrameOffset() { return m_useOffsetForConstraintFrame; }
+	void setUseFrameOffset(bool frameOffsetOnOff) { m_useOffsetForConstraintFrame = frameOffsetOnOff; }
+	// access for UseReferenceFrameA
+	bool getUseReferenceFrameA() const { return m_useReferenceFrameA; }
+	void setUseReferenceFrameA(bool useReferenceFrameA) { m_useReferenceFrameA = useReferenceFrameA; }
+
+	///override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5).
+	///If no axis is provided, it uses the default axis for this constraint.
+	virtual void setParam(int num, btScalar value, int axis = -1);
+	///return the local value of parameter
+	virtual btScalar getParam(int num, int axis = -1) const;
+
+	virtual int getFlags() const
+	{
+		return m_flags;
+	}
+
+	virtual int calculateSerializeBufferSize() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
+};
+
+//only for backward compatibility
+#ifdef BT_BACKWARDS_COMPATIBLE_SERIALIZATION
+///this structure is not used, except for loading pre-2.82 .bullet files
+struct btHingeConstraintDoubleData
+{
+	btTypedConstraintData m_typeConstraintData;
+	btTransformDoubleData m_rbAFrame;  // constraint axii. Assumes z is hinge axis.
+	btTransformDoubleData m_rbBFrame;
+	int m_useReferenceFrameA;
+	int m_angularOnly;
+	int m_enableAngularMotor;
+	float m_motorTargetVelocity;
+	float m_maxMotorImpulse;
+
+	float m_lowerLimit;
+	float m_upperLimit;
+	float m_limitSoftness;
+	float m_biasFactor;
+	float m_relaxationFactor;
+};
+#endif  //BT_BACKWARDS_COMPATIBLE_SERIALIZATION
+
+///The getAccumulatedHingeAngle returns the accumulated hinge angle, taking rotation across the -PI/PI boundary into account
+ATTRIBUTE_ALIGNED16(class)
+btHingeAccumulatedAngleConstraint : public btHingeConstraint
+{
+protected:
+	btScalar m_accumulatedAngle;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btHingeAccumulatedAngleConstraint(btRigidBody & rbA, btRigidBody & rbB, const btVector3& pivotInA, const btVector3& pivotInB, const btVector3& axisInA, const btVector3& axisInB, bool useReferenceFrameA = false)
+		: btHingeConstraint(rbA, rbB, pivotInA, pivotInB, axisInA, axisInB, useReferenceFrameA)
+	{
+		m_accumulatedAngle = getHingeAngle();
+	}
+
+	btHingeAccumulatedAngleConstraint(btRigidBody & rbA, const btVector3& pivotInA, const btVector3& axisInA, bool useReferenceFrameA = false)
+		: btHingeConstraint(rbA, pivotInA, axisInA, useReferenceFrameA)
+	{
+		m_accumulatedAngle = getHingeAngle();
+	}
+
+	btHingeAccumulatedAngleConstraint(btRigidBody & rbA, btRigidBody & rbB, const btTransform& rbAFrame, const btTransform& rbBFrame, bool useReferenceFrameA = false)
+		: btHingeConstraint(rbA, rbB, rbAFrame, rbBFrame, useReferenceFrameA)
+	{
+		m_accumulatedAngle = getHingeAngle();
+	}
+
+	btHingeAccumulatedAngleConstraint(btRigidBody & rbA, const btTransform& rbAFrame, bool useReferenceFrameA = false)
+		: btHingeConstraint(rbA, rbAFrame, useReferenceFrameA)
+	{
+		m_accumulatedAngle = getHingeAngle();
+	}
+	btScalar getAccumulatedHingeAngle();
+	void setAccumulatedHingeAngle(btScalar accAngle);
+	virtual void getInfo1(btConstraintInfo1 * info);
+};
+
+struct btHingeConstraintFloatData
+{
+	btTypedConstraintData m_typeConstraintData;
+	btTransformFloatData m_rbAFrame;  // constraint axii. Assumes z is hinge axis.
+	btTransformFloatData m_rbBFrame;
+	int m_useReferenceFrameA;
+	int m_angularOnly;
+
+	int m_enableAngularMotor;
+	float m_motorTargetVelocity;
+	float m_maxMotorImpulse;
+
+	float m_lowerLimit;
+	float m_upperLimit;
+	float m_limitSoftness;
+	float m_biasFactor;
+	float m_relaxationFactor;
+};
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct btHingeConstraintDoubleData2
+{
+	btTypedConstraintDoubleData m_typeConstraintData;
+	btTransformDoubleData m_rbAFrame;  // constraint axii. Assumes z is hinge axis.
+	btTransformDoubleData m_rbBFrame;
+	int m_useReferenceFrameA;
+	int m_angularOnly;
+	int m_enableAngularMotor;
+	double m_motorTargetVelocity;
+	double m_maxMotorImpulse;
+
+	double m_lowerLimit;
+	double m_upperLimit;
+	double m_limitSoftness;
+	double m_biasFactor;
+	double m_relaxationFactor;
+	char m_padding1[4];
+};
+
+SIMD_FORCE_INLINE int btHingeConstraint::calculateSerializeBufferSize() const
+{
+	return sizeof(btHingeConstraintData);
+}
+
+///fills the dataBuffer and returns the struct name (and 0 on failure)
+SIMD_FORCE_INLINE const char* btHingeConstraint::serialize(void* dataBuffer, btSerializer* serializer) const
+{
+	btHingeConstraintData* hingeData = (btHingeConstraintData*)dataBuffer;
+	btTypedConstraint::serialize(&hingeData->m_typeConstraintData, serializer);
+
+	m_rbAFrame.serialize(hingeData->m_rbAFrame);
+	m_rbBFrame.serialize(hingeData->m_rbBFrame);
+
+	hingeData->m_angularOnly = m_angularOnly;
+	hingeData->m_enableAngularMotor = m_enableAngularMotor;
+	hingeData->m_maxMotorImpulse = float(m_maxMotorImpulse);
+	hingeData->m_motorTargetVelocity = float(m_motorTargetVelocity);
+	hingeData->m_useReferenceFrameA = m_useReferenceFrameA;
+#ifdef _BT_USE_CENTER_LIMIT_
+	hingeData->m_lowerLimit = float(m_limit.getLow());
+	hingeData->m_upperLimit = float(m_limit.getHigh());
+	hingeData->m_limitSoftness = float(m_limit.getSoftness());
+	hingeData->m_biasFactor = float(m_limit.getBiasFactor());
+	hingeData->m_relaxationFactor = float(m_limit.getRelaxationFactor());
+#else
+	hingeData->m_lowerLimit = float(m_lowerLimit);
+	hingeData->m_upperLimit = float(m_upperLimit);
+	hingeData->m_limitSoftness = float(m_limitSoftness);
+	hingeData->m_biasFactor = float(m_biasFactor);
+	hingeData->m_relaxationFactor = float(m_relaxationFactor);
+#endif
+
+	// Fill padding with zeros to appease msan.
+#ifdef BT_USE_DOUBLE_PRECISION
+	hingeData->m_padding1[0] = 0;
+	hingeData->m_padding1[1] = 0;
+	hingeData->m_padding1[2] = 0;
+	hingeData->m_padding1[3] = 0;
+#endif
+
+	return btHingeConstraintDataName;
+}
+
+#endif  //BT_HINGECONSTRAINT_H
diff --git a/engine/inc/bullet/BulletDynamics/ConstraintSolver/btJacobianEntry.h b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btJacobianEntry.h
new file mode 100644
index 00000000..438456fe
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btJacobianEntry.h
@@ -0,0 +1,150 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_JACOBIAN_ENTRY_H
+#define BT_JACOBIAN_ENTRY_H
+
+#include "LinearMath/btMatrix3x3.h"
+
+//notes:
+// Another memory optimization would be to store m_1MinvJt in the remaining 3 w components
+// which makes the btJacobianEntry memory layout 16 bytes
+// if you only are interested in angular part, just feed massInvA and massInvB zero
+
+/// Jacobian entry is an abstraction that allows to describe constraints
+/// it can be used in combination with a constraint solver
+/// Can be used to relate the effect of an impulse to the constraint error
+ATTRIBUTE_ALIGNED16(class)
+btJacobianEntry
+{
+public:
+	btJacobianEntry(){};
+	//constraint between two different rigidbodies
+	btJacobianEntry(
+		const btMatrix3x3& world2A,
+		const btMatrix3x3& world2B,
+		const btVector3& rel_pos1, const btVector3& rel_pos2,
+		const btVector3& jointAxis,
+		const btVector3& inertiaInvA,
+		const btScalar massInvA,
+		const btVector3& inertiaInvB,
+		const btScalar massInvB)
+		: m_linearJointAxis(jointAxis)
+	{
+		m_aJ = world2A * (rel_pos1.cross(m_linearJointAxis));
+		m_bJ = world2B * (rel_pos2.cross(-m_linearJointAxis));
+		m_0MinvJt = inertiaInvA * m_aJ;
+		m_1MinvJt = inertiaInvB * m_bJ;
+		m_Adiag = massInvA + m_0MinvJt.dot(m_aJ) + massInvB + m_1MinvJt.dot(m_bJ);
+
+		btAssert(m_Adiag > btScalar(0.0));
+	}
+
+	//angular constraint between two different rigidbodies
+	btJacobianEntry(const btVector3& jointAxis,
+					const btMatrix3x3& world2A,
+					const btMatrix3x3& world2B,
+					const btVector3& inertiaInvA,
+					const btVector3& inertiaInvB)
+		: m_linearJointAxis(btVector3(btScalar(0.), btScalar(0.), btScalar(0.)))
+	{
+		m_aJ = world2A * jointAxis;
+		m_bJ = world2B * -jointAxis;
+		m_0MinvJt = inertiaInvA * m_aJ;
+		m_1MinvJt = inertiaInvB * m_bJ;
+		m_Adiag = m_0MinvJt.dot(m_aJ) + m_1MinvJt.dot(m_bJ);
+
+		btAssert(m_Adiag > btScalar(0.0));
+	}
+
+	//angular constraint between two different rigidbodies
+	btJacobianEntry(const btVector3& axisInA,
+					const btVector3& axisInB,
+					const btVector3& inertiaInvA,
+					const btVector3& inertiaInvB)
+		: m_linearJointAxis(btVector3(btScalar(0.), btScalar(0.), btScalar(0.))), m_aJ(axisInA), m_bJ(-axisInB)
+	{
+		m_0MinvJt = inertiaInvA * m_aJ;
+		m_1MinvJt = inertiaInvB * m_bJ;
+		m_Adiag = m_0MinvJt.dot(m_aJ) + m_1MinvJt.dot(m_bJ);
+
+		btAssert(m_Adiag > btScalar(0.0));
+	}
+
+	//constraint on one rigidbody
+	btJacobianEntry(
+		const btMatrix3x3& world2A,
+		const btVector3& rel_pos1, const btVector3& rel_pos2,
+		const btVector3& jointAxis,
+		const btVector3& inertiaInvA,
+		const btScalar massInvA)
+		: m_linearJointAxis(jointAxis)
+	{
+		m_aJ = world2A * (rel_pos1.cross(jointAxis));
+		m_bJ = world2A * (rel_pos2.cross(-jointAxis));
+		m_0MinvJt = inertiaInvA * m_aJ;
+		m_1MinvJt = btVector3(btScalar(0.), btScalar(0.), btScalar(0.));
+		m_Adiag = massInvA + m_0MinvJt.dot(m_aJ);
+
+		btAssert(m_Adiag > btScalar(0.0));
+	}
+
+	btScalar getDiagonal() const { return m_Adiag; }
+
+	// for two constraints on the same rigidbody (for example vehicle friction)
+	btScalar getNonDiagonal(const btJacobianEntry& jacB, const btScalar massInvA) const
+	{
+		const btJacobianEntry& jacA = *this;
+		btScalar lin = massInvA * jacA.m_linearJointAxis.dot(jacB.m_linearJointAxis);
+		btScalar ang = jacA.m_0MinvJt.dot(jacB.m_aJ);
+		return lin + ang;
+	}
+
+	// for two constraints on sharing two same rigidbodies (for example two contact points between two rigidbodies)
+	btScalar getNonDiagonal(const btJacobianEntry& jacB, const btScalar massInvA, const btScalar massInvB) const
+	{
+		const btJacobianEntry& jacA = *this;
+		btVector3 lin = jacA.m_linearJointAxis * jacB.m_linearJointAxis;
+		btVector3 ang0 = jacA.m_0MinvJt * jacB.m_aJ;
+		btVector3 ang1 = jacA.m_1MinvJt * jacB.m_bJ;
+		btVector3 lin0 = massInvA * lin;
+		btVector3 lin1 = massInvB * lin;
+		btVector3 sum = ang0 + ang1 + lin0 + lin1;
+		return sum[0] + sum[1] + sum[2];
+	}
+
+	btScalar getRelativeVelocity(const btVector3& linvelA, const btVector3& angvelA, const btVector3& linvelB, const btVector3& angvelB)
+	{
+		btVector3 linrel = linvelA - linvelB;
+		btVector3 angvela = angvelA * m_aJ;
+		btVector3 angvelb = angvelB * m_bJ;
+		linrel *= m_linearJointAxis;
+		angvela += angvelb;
+		angvela += linrel;
+		btScalar rel_vel2 = angvela[0] + angvela[1] + angvela[2];
+		return rel_vel2 + SIMD_EPSILON;
+	}
+	//private:
+
+	btVector3 m_linearJointAxis;
+	btVector3 m_aJ;
+	btVector3 m_bJ;
+	btVector3 m_0MinvJt;
+	btVector3 m_1MinvJt;
+	//Optimization: can be stored in the w/last component of one of the vectors
+	btScalar m_Adiag;
+};
+
+#endif  //BT_JACOBIAN_ENTRY_H
diff --git a/engine/inc/bullet/BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.h b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.h
new file mode 100644
index 00000000..c84f274a
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.h
@@ -0,0 +1,57 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_NNCG_CONSTRAINT_SOLVER_H
+#define BT_NNCG_CONSTRAINT_SOLVER_H
+
+#include "btSequentialImpulseConstraintSolver.h"
+
+ATTRIBUTE_ALIGNED16(class)
+btNNCGConstraintSolver : public btSequentialImpulseConstraintSolver
+{
+protected:
+	btScalar m_deltafLengthSqrPrev;
+
+	btAlignedObjectArray<btScalar> m_pNC;   // p for None Contact constraints
+	btAlignedObjectArray<btScalar> m_pC;    // p for Contact constraints
+	btAlignedObjectArray<btScalar> m_pCF;   // p for ContactFriction constraints
+	btAlignedObjectArray<btScalar> m_pCRF;  // p for ContactRollingFriction constraints
+
+	//These are recalculated in every iterations. We just keep these to prevent reallocation in each iteration.
+	btAlignedObjectArray<btScalar> m_deltafNC;   // deltaf for NoneContact constraints
+	btAlignedObjectArray<btScalar> m_deltafC;    // deltaf for Contact constraints
+	btAlignedObjectArray<btScalar> m_deltafCF;   // deltaf for ContactFriction constraints
+	btAlignedObjectArray<btScalar> m_deltafCRF;  // deltaf for ContactRollingFriction constraints
+
+protected:
+	virtual btScalar solveGroupCacheFriendlyFinish(btCollisionObject * *bodies, int numBodies, const btContactSolverInfo& infoGlobal);
+	virtual btScalar solveSingleIteration(int iteration, btCollisionObject** bodies, int numBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer);
+
+	virtual btScalar solveGroupCacheFriendlySetup(btCollisionObject * *bodies, int numBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer);
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btNNCGConstraintSolver() : btSequentialImpulseConstraintSolver(), m_onlyForNoneContact(false) {}
+
+	virtual btConstraintSolverType getSolverType() const
+	{
+		return BT_NNCG_SOLVER;
+	}
+
+	bool m_onlyForNoneContact;
+};
+
+#endif  //BT_NNCG_CONSTRAINT_SOLVER_H
diff --git a/engine/inc/bullet/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h
new file mode 100644
index 00000000..4717e198
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h
@@ -0,0 +1,173 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_POINT2POINTCONSTRAINT_H
+#define BT_POINT2POINTCONSTRAINT_H
+
+#include "LinearMath/btVector3.h"
+#include "btJacobianEntry.h"
+#include "btTypedConstraint.h"
+
+class btRigidBody;
+
+#ifdef BT_USE_DOUBLE_PRECISION
+#define btPoint2PointConstraintData2 btPoint2PointConstraintDoubleData2
+#define btPoint2PointConstraintDataName "btPoint2PointConstraintDoubleData2"
+#else
+#define btPoint2PointConstraintData2 btPoint2PointConstraintFloatData
+#define btPoint2PointConstraintDataName "btPoint2PointConstraintFloatData"
+#endif  //BT_USE_DOUBLE_PRECISION
+
+struct btConstraintSetting
+{
+	btConstraintSetting() : m_tau(btScalar(0.3)),
+							m_damping(btScalar(1.)),
+							m_impulseClamp(btScalar(0.))
+	{
+	}
+	btScalar m_tau;
+	btScalar m_damping;
+	btScalar m_impulseClamp;
+};
+
+enum btPoint2PointFlags
+{
+	BT_P2P_FLAGS_ERP = 1,
+	BT_P2P_FLAGS_CFM = 2
+};
+
+/// point to point constraint between two rigidbodies each with a pivotpoint that descibes the 'ballsocket' location in local space
+ATTRIBUTE_ALIGNED16(class)
+btPoint2PointConstraint : public btTypedConstraint
+{
+#ifdef IN_PARALLELL_SOLVER
+public:
+#endif
+	btJacobianEntry m_jac[3];  //3 orthogonal linear constraints
+
+	btVector3 m_pivotInA;
+	btVector3 m_pivotInB;
+
+	int m_flags;
+	btScalar m_erp;
+	btScalar m_cfm;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	///for backwards compatibility during the transition to 'getInfo/getInfo2'
+	bool m_useSolveConstraintObsolete;
+
+	btConstraintSetting m_setting;
+
+	btPoint2PointConstraint(btRigidBody & rbA, btRigidBody & rbB, const btVector3& pivotInA, const btVector3& pivotInB);
+
+	btPoint2PointConstraint(btRigidBody & rbA, const btVector3& pivotInA);
+
+	virtual void buildJacobian();
+
+	virtual void getInfo1(btConstraintInfo1 * info);
+
+	void getInfo1NonVirtual(btConstraintInfo1 * info);
+
+	virtual void getInfo2(btConstraintInfo2 * info);
+
+	void getInfo2NonVirtual(btConstraintInfo2 * info, const btTransform& body0_trans, const btTransform& body1_trans);
+
+	void updateRHS(btScalar timeStep);
+
+	void setPivotA(const btVector3& pivotA)
+	{
+		m_pivotInA = pivotA;
+	}
+
+	void setPivotB(const btVector3& pivotB)
+	{
+		m_pivotInB = pivotB;
+	}
+
+	const btVector3& getPivotInA() const
+	{
+		return m_pivotInA;
+	}
+
+	const btVector3& getPivotInB() const
+	{
+		return m_pivotInB;
+	}
+
+	///override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5).
+	///If no axis is provided, it uses the default axis for this constraint.
+	virtual void setParam(int num, btScalar value, int axis = -1);
+	///return the local value of parameter
+	virtual btScalar getParam(int num, int axis = -1) const;
+
+	virtual int getFlags() const
+	{
+		return m_flags;
+	}
+
+	virtual int calculateSerializeBufferSize() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
+};
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct btPoint2PointConstraintFloatData
+{
+	btTypedConstraintData m_typeConstraintData;
+	btVector3FloatData m_pivotInA;
+	btVector3FloatData m_pivotInB;
+};
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct btPoint2PointConstraintDoubleData2
+{
+	btTypedConstraintDoubleData m_typeConstraintData;
+	btVector3DoubleData m_pivotInA;
+	btVector3DoubleData m_pivotInB;
+};
+
+#ifdef BT_BACKWARDS_COMPATIBLE_SERIALIZATION
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+///this structure is not used, except for loading pre-2.82 .bullet files
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct btPoint2PointConstraintDoubleData
+{
+	btTypedConstraintData m_typeConstraintData;
+	btVector3DoubleData m_pivotInA;
+	btVector3DoubleData m_pivotInB;
+};
+#endif  //BT_BACKWARDS_COMPATIBLE_SERIALIZATION
+
+SIMD_FORCE_INLINE int btPoint2PointConstraint::calculateSerializeBufferSize() const
+{
+	return sizeof(btPoint2PointConstraintData2);
+}
+
+///fills the dataBuffer and returns the struct name (and 0 on failure)
+SIMD_FORCE_INLINE const char* btPoint2PointConstraint::serialize(void* dataBuffer, btSerializer* serializer) const
+{
+	btPoint2PointConstraintData2* p2pData = (btPoint2PointConstraintData2*)dataBuffer;
+
+	btTypedConstraint::serialize(&p2pData->m_typeConstraintData, serializer);
+	m_pivotInA.serialize(p2pData->m_pivotInA);
+	m_pivotInB.serialize(p2pData->m_pivotInB);
+
+	return btPoint2PointConstraintDataName;
+}
+
+#endif  //BT_POINT2POINTCONSTRAINT_H
diff --git a/engine/inc/bullet/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h
new file mode 100644
index 00000000..f3ef02fc
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h
@@ -0,0 +1,215 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H
+#define BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H
+
+class btIDebugDraw;
+class btPersistentManifold;
+class btDispatcher;
+class btCollisionObject;
+#include "BulletDynamics/ConstraintSolver/btTypedConstraint.h"
+#include "BulletDynamics/ConstraintSolver/btContactSolverInfo.h"
+#include "BulletDynamics/ConstraintSolver/btSolverBody.h"
+#include "BulletDynamics/ConstraintSolver/btSolverConstraint.h"
+#include "BulletCollision/NarrowPhaseCollision/btManifoldPoint.h"
+#include "BulletDynamics/ConstraintSolver/btConstraintSolver.h"
+
+typedef btScalar (*btSingleConstraintRowSolver)(btSolverBody&, btSolverBody&, const btSolverConstraint&);
+
+struct btSolverAnalyticsData
+{
+	btSolverAnalyticsData()
+	{
+		m_numSolverCalls = 0;
+		m_numIterationsUsed = -1;
+		m_remainingLeastSquaresResidual = -1;
+		m_islandId = -2;
+	}
+	int m_islandId;
+	int m_numBodies;
+	int m_numContactManifolds;
+	int m_numSolverCalls;
+	int m_numIterationsUsed;
+	double m_remainingLeastSquaresResidual;
+};
+
+///The btSequentialImpulseConstraintSolver is a fast SIMD implementation of the Projected Gauss Seidel (iterative LCP) method.
+ATTRIBUTE_ALIGNED16(class)
+btSequentialImpulseConstraintSolver : public btConstraintSolver
+{
+	
+
+protected:
+	btAlignedObjectArray<btSolverBody> m_tmpSolverBodyPool;
+	btConstraintArray m_tmpSolverContactConstraintPool;
+	btConstraintArray m_tmpSolverNonContactConstraintPool;
+	btConstraintArray m_tmpSolverContactFrictionConstraintPool;
+	btConstraintArray m_tmpSolverContactRollingFrictionConstraintPool;
+
+	btAlignedObjectArray<int> m_orderTmpConstraintPool;
+	btAlignedObjectArray<int> m_orderNonContactConstraintPool;
+	btAlignedObjectArray<int> m_orderFrictionConstraintPool;
+	btAlignedObjectArray<btTypedConstraint::btConstraintInfo1> m_tmpConstraintSizesPool;
+	int m_maxOverrideNumSolverIterations;
+	int m_fixedBodyId;
+	// When running solvers on multiple threads, a race condition exists for Kinematic objects that
+	// participate in more than one solver.
+	// The getOrInitSolverBody() function writes the companionId of each body (storing the index of the solver body
+	// for the current solver). For normal dynamic bodies it isn't an issue because they can only be in one island
+	// (and therefore one thread) at a time. But kinematic bodies can be in multiple islands at once.
+	// To avoid this race condition, this solver does not write the companionId, instead it stores the solver body
+	// index in this solver-local table, indexed by the uniqueId of the body.
+	btAlignedObjectArray<int> m_kinematicBodyUniqueIdToSolverBodyTable;  // only used for multithreading
+
+	btSingleConstraintRowSolver m_resolveSingleConstraintRowGeneric;
+	btSingleConstraintRowSolver m_resolveSingleConstraintRowLowerLimit;
+	btSingleConstraintRowSolver m_resolveSplitPenetrationImpulse;
+	int m_cachedSolverMode;  // used to check if SOLVER_SIMD flag has been changed
+	void setupSolverFunctions(bool useSimd);
+
+	btScalar m_leastSquaresResidual;
+
+	void setupFrictionConstraint(btSolverConstraint & solverConstraint, const btVector3& normalAxis, int solverBodyIdA, int solverBodyIdB,
+		btManifoldPoint& cp, const btVector3& rel_pos1, const btVector3& rel_pos2,
+		btCollisionObject* colObj0, btCollisionObject* colObj1, btScalar relaxation,
+		const btContactSolverInfo& infoGlobal,
+		btScalar desiredVelocity = 0., btScalar cfmSlip = 0.);
+
+	void setupTorsionalFrictionConstraint(btSolverConstraint & solverConstraint, const btVector3& normalAxis, int solverBodyIdA, int solverBodyIdB,
+		btManifoldPoint& cp, btScalar combinedTorsionalFriction, const btVector3& rel_pos1, const btVector3& rel_pos2,
+		btCollisionObject* colObj0, btCollisionObject* colObj1, btScalar relaxation,
+		btScalar desiredVelocity = 0., btScalar cfmSlip = 0.);
+
+	btSolverConstraint& addFrictionConstraint(const btVector3& normalAxis, int solverBodyIdA, int solverBodyIdB, int frictionIndex, btManifoldPoint& cp, const btVector3& rel_pos1, const btVector3& rel_pos2, btCollisionObject* colObj0, btCollisionObject* colObj1, btScalar relaxation, const btContactSolverInfo& infoGlobal, btScalar desiredVelocity = 0., btScalar cfmSlip = 0.);
+	btSolverConstraint& addTorsionalFrictionConstraint(const btVector3& normalAxis, int solverBodyIdA, int solverBodyIdB, int frictionIndex, btManifoldPoint& cp, btScalar torsionalFriction, const btVector3& rel_pos1, const btVector3& rel_pos2, btCollisionObject* colObj0, btCollisionObject* colObj1, btScalar relaxation, btScalar desiredVelocity = 0, btScalar cfmSlip = 0.f);
+
+	void setupContactConstraint(btSolverConstraint & solverConstraint, int solverBodyIdA, int solverBodyIdB, btManifoldPoint& cp,
+		const btContactSolverInfo& infoGlobal, btScalar& relaxation, const btVector3& rel_pos1, const btVector3& rel_pos2);
+
+	static void applyAnisotropicFriction(btCollisionObject * colObj, btVector3 & frictionDirection, int frictionMode);
+
+	void setFrictionConstraintImpulse(btSolverConstraint & solverConstraint, int solverBodyIdA, int solverBodyIdB,
+		btManifoldPoint& cp, const btContactSolverInfo& infoGlobal);
+
+	///m_btSeed2 is used for re-arranging the constraint rows. improves convergence/quality of friction
+	unsigned long m_btSeed2;
+
+	btScalar restitutionCurve(btScalar rel_vel, btScalar restitution, btScalar velocityThreshold);
+
+	virtual void convertContacts(btPersistentManifold * *manifoldPtr, int numManifolds, const btContactSolverInfo& infoGlobal);
+
+	void convertContact(btPersistentManifold * manifold, const btContactSolverInfo& infoGlobal);
+
+	virtual void convertJoints(btTypedConstraint * *constraints, int numConstraints, const btContactSolverInfo& infoGlobal);
+	void convertJoint(btSolverConstraint * currentConstraintRow, btTypedConstraint * constraint, const btTypedConstraint::btConstraintInfo1& info1, int solverBodyIdA, int solverBodyIdB, const btContactSolverInfo& infoGlobal);
+
+	virtual void convertBodies(btCollisionObject * *bodies, int numBodies, const btContactSolverInfo& infoGlobal);
+
+	btScalar resolveSplitPenetrationSIMD(btSolverBody & bodyA, btSolverBody & bodyB, const btSolverConstraint& contactConstraint)
+	{
+		return m_resolveSplitPenetrationImpulse(bodyA, bodyB, contactConstraint);
+	}
+
+	btScalar resolveSplitPenetrationImpulseCacheFriendly(btSolverBody & bodyA, btSolverBody & bodyB, const btSolverConstraint& contactConstraint)
+	{
+		return m_resolveSplitPenetrationImpulse(bodyA, bodyB, contactConstraint);
+	}
+
+	//internal method
+	int getOrInitSolverBody(btCollisionObject & body, btScalar timeStep);
+	void initSolverBody(btSolverBody * solverBody, btCollisionObject * collisionObject, btScalar timeStep);
+
+	btScalar resolveSingleConstraintRowGeneric(btSolverBody & bodyA, btSolverBody & bodyB, const btSolverConstraint& contactConstraint);
+	btScalar resolveSingleConstraintRowGenericSIMD(btSolverBody & bodyA, btSolverBody & bodyB, const btSolverConstraint& contactConstraint);
+	btScalar resolveSingleConstraintRowLowerLimit(btSolverBody & bodyA, btSolverBody & bodyB, const btSolverConstraint& contactConstraint);
+	btScalar resolveSingleConstraintRowLowerLimitSIMD(btSolverBody & bodyA, btSolverBody & bodyB, const btSolverConstraint& contactConstraint);
+	btScalar resolveSplitPenetrationImpulse(btSolverBody & bodyA, btSolverBody & bodyB, const btSolverConstraint& contactConstraint)
+	{
+		return m_resolveSplitPenetrationImpulse(bodyA, bodyB, contactConstraint);
+	}
+
+protected:
+	void writeBackContacts(int iBegin, int iEnd, const btContactSolverInfo& infoGlobal);
+	void writeBackJoints(int iBegin, int iEnd, const btContactSolverInfo& infoGlobal);
+	void writeBackBodies(int iBegin, int iEnd, const btContactSolverInfo& infoGlobal);
+	virtual void solveGroupCacheFriendlySplitImpulseIterations(btCollisionObject * *bodies, int numBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer);
+	virtual btScalar solveGroupCacheFriendlyFinish(btCollisionObject * *bodies, int numBodies, const btContactSolverInfo& infoGlobal);
+	virtual btScalar solveSingleIteration(int iteration, btCollisionObject** bodies, int numBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer);
+
+	virtual btScalar solveGroupCacheFriendlySetup(btCollisionObject * *bodies, int numBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer);
+	virtual btScalar solveGroupCacheFriendlyIterations(btCollisionObject * *bodies, int numBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer);
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btSequentialImpulseConstraintSolver();
+	virtual ~btSequentialImpulseConstraintSolver();
+
+	virtual btScalar solveGroup(btCollisionObject * *bodies, int numBodies, btPersistentManifold** manifold, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& info, btIDebugDraw* debugDrawer, btDispatcher* dispatcher);
+
+	///clear internal cached data and reset random seed
+	virtual void reset();
+
+	unsigned long btRand2();
+
+	int btRandInt2(int n);
+
+	void setRandSeed(unsigned long seed)
+	{
+		m_btSeed2 = seed;
+	}
+	unsigned long getRandSeed() const
+	{
+		return m_btSeed2;
+	}
+
+	virtual btConstraintSolverType getSolverType() const
+	{
+		return BT_SEQUENTIAL_IMPULSE_SOLVER;
+	}
+
+	btSingleConstraintRowSolver getActiveConstraintRowSolverGeneric()
+	{
+		return m_resolveSingleConstraintRowGeneric;
+	}
+	void setConstraintRowSolverGeneric(btSingleConstraintRowSolver rowSolver)
+	{
+		m_resolveSingleConstraintRowGeneric = rowSolver;
+	}
+	btSingleConstraintRowSolver getActiveConstraintRowSolverLowerLimit()
+	{
+		return m_resolveSingleConstraintRowLowerLimit;
+	}
+	void setConstraintRowSolverLowerLimit(btSingleConstraintRowSolver rowSolver)
+	{
+		m_resolveSingleConstraintRowLowerLimit = rowSolver;
+	}
+
+
+
+	///Various implementations of solving a single constraint row using a generic equality constraint, using scalar reference, SSE2 or SSE4
+	btSingleConstraintRowSolver getScalarConstraintRowSolverGeneric();
+	btSingleConstraintRowSolver getSSE2ConstraintRowSolverGeneric();
+	btSingleConstraintRowSolver getSSE4_1ConstraintRowSolverGeneric();
+
+	///Various implementations of solving a single constraint row using an inequality (lower limit) constraint, using scalar reference, SSE2 or SSE4
+	btSingleConstraintRowSolver getScalarConstraintRowSolverLowerLimit();
+	btSingleConstraintRowSolver getSSE2ConstraintRowSolverLowerLimit();
+	btSingleConstraintRowSolver getSSE4_1ConstraintRowSolverLowerLimit();
+	btSolverAnalyticsData m_analyticsData;
+};
+
+#endif  //BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H
diff --git a/engine/inc/bullet/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.h b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.h
new file mode 100644
index 00000000..1861ddd7
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.h
@@ -0,0 +1,150 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_MT_H
+#define BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_MT_H
+
+#include "btSequentialImpulseConstraintSolver.h"
+#include "btBatchedConstraints.h"
+#include "LinearMath/btThreads.h"
+
+///
+/// btSequentialImpulseConstraintSolverMt
+///
+///  A multithreaded variant of the sequential impulse constraint solver. The constraints to be solved are grouped into
+///  batches and phases where each batch of constraints within a given phase can be solved in parallel with the rest.
+///  Ideally we want as few phases as possible, and each phase should have many batches, and all of the batches should
+///  have about the same number of constraints.
+///  This method works best on a large island of many constraints.
+///
+///  Supports all of the features of the normal sequential impulse solver such as:
+///    - split penetration impulse
+///    - rolling friction
+///    - interleaving constraints
+///    - warmstarting
+///    - 2 friction directions
+///    - randomized constraint ordering
+///    - early termination when leastSquaresResidualThreshold is satisfied
+///
+///  When the SOLVER_INTERLEAVE_CONTACT_AND_FRICTION_CONSTRAINTS flag is enabled, unlike the normal SequentialImpulse solver,
+///  the rolling friction is interleaved as well.
+///  Interleaving the contact penetration constraints with friction reduces the number of parallel loops that need to be done,
+///  which reduces threading overhead so it can be a performance win, however, it does seem to produce a less stable simulation,
+///  at least on stacks of blocks.
+///
+///  When the SOLVER_RANDMIZE_ORDER flag is enabled, the ordering of phases, and the ordering of constraints within each batch
+///  is randomized, however it does not swap constraints between batches.
+///  This is to avoid regenerating the batches for each solver iteration which would be quite costly in performance.
+///
+///  Note that a non-zero leastSquaresResidualThreshold could possibly affect the determinism of the simulation
+///  if the task scheduler's parallelSum operation is non-deterministic. The parallelSum operation can be non-deterministic
+///  because floating point addition is not associative due to rounding errors.
+///  The task scheduler can and should ensure that the result of any parallelSum operation is deterministic.
+///
+ATTRIBUTE_ALIGNED16(class)
+btSequentialImpulseConstraintSolverMt : public btSequentialImpulseConstraintSolver
+{
+public:
+	virtual void solveGroupCacheFriendlySplitImpulseIterations(btCollisionObject * *bodies, int numBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer) BT_OVERRIDE;
+	virtual btScalar solveSingleIteration(int iteration, btCollisionObject** bodies, int numBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer) BT_OVERRIDE;
+	virtual btScalar solveGroupCacheFriendlySetup(btCollisionObject * *bodies, int numBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer) BT_OVERRIDE;
+	virtual btScalar solveGroupCacheFriendlyFinish(btCollisionObject * *bodies, int numBodies, const btContactSolverInfo& infoGlobal) BT_OVERRIDE;
+
+	// temp struct used to collect info from persistent manifolds into a cache-friendly struct using multiple threads
+	struct btContactManifoldCachedInfo
+	{
+		static const int MAX_NUM_CONTACT_POINTS = 4;
+
+		int numTouchingContacts;
+		int solverBodyIds[2];
+		int contactIndex;
+		int rollingFrictionIndex;
+		bool contactHasRollingFriction[MAX_NUM_CONTACT_POINTS];
+		btManifoldPoint* contactPoints[MAX_NUM_CONTACT_POINTS];
+	};
+	// temp struct used for setting up joint constraints in parallel
+	struct JointParams
+	{
+		int m_solverConstraint;
+		int m_solverBodyA;
+		int m_solverBodyB;
+	};
+	void internalInitMultipleJoints(btTypedConstraint * *constraints, int iBegin, int iEnd);
+	void internalConvertMultipleJoints(const btAlignedObjectArray<JointParams>& jointParamsArray, btTypedConstraint** constraints, int iBegin, int iEnd, const btContactSolverInfo& infoGlobal);
+
+	// parameters to control batching
+	static bool s_allowNestedParallelForLoops;        // whether to allow nested parallel operations
+	static int s_minimumContactManifoldsForBatching;  // don't even try to batch if fewer manifolds than this
+	static btBatchedConstraints::BatchingMethod s_contactBatchingMethod;
+	static btBatchedConstraints::BatchingMethod s_jointBatchingMethod;
+	static int s_minBatchSize;  // desired number of constraints per batch
+	static int s_maxBatchSize;
+
+protected:
+	static const int CACHE_LINE_SIZE = 64;
+
+	btBatchedConstraints m_batchedContactConstraints;
+	btBatchedConstraints m_batchedJointConstraints;
+	int m_numFrictionDirections;
+	bool m_useBatching;
+	bool m_useObsoleteJointConstraints;
+	btAlignedObjectArray<btContactManifoldCachedInfo> m_manifoldCachedInfoArray;
+	btAlignedObjectArray<int> m_rollingFrictionIndexTable;  // lookup table mapping contact index to rolling friction index
+	btSpinMutex m_bodySolverArrayMutex;
+	char m_antiFalseSharingPadding[CACHE_LINE_SIZE];  // padding to keep mutexes in separate cachelines
+	btSpinMutex m_kinematicBodyUniqueIdToSolverBodyTableMutex;
+	btAlignedObjectArray<char> m_scratchMemory;
+
+	virtual void randomizeConstraintOrdering(int iteration, int numIterations);
+	virtual btScalar resolveAllJointConstraints(int iteration);
+	virtual btScalar resolveAllContactConstraints();
+	virtual btScalar resolveAllContactFrictionConstraints();
+	virtual btScalar resolveAllContactConstraintsInterleaved();
+	virtual btScalar resolveAllRollingFrictionConstraints();
+
+	virtual void setupBatchedContactConstraints();
+	virtual void setupBatchedJointConstraints();
+	virtual void convertJoints(btTypedConstraint * *constraints, int numConstraints, const btContactSolverInfo& infoGlobal) BT_OVERRIDE;
+	virtual void convertContacts(btPersistentManifold * *manifoldPtr, int numManifolds, const btContactSolverInfo& infoGlobal) BT_OVERRIDE;
+	virtual void convertBodies(btCollisionObject * *bodies, int numBodies, const btContactSolverInfo& infoGlobal) BT_OVERRIDE;
+
+	int getOrInitSolverBodyThreadsafe(btCollisionObject & body, btScalar timeStep);
+	void allocAllContactConstraints(btPersistentManifold * *manifoldPtr, int numManifolds, const btContactSolverInfo& infoGlobal);
+	void setupAllContactConstraints(const btContactSolverInfo& infoGlobal);
+	void randomizeBatchedConstraintOrdering(btBatchedConstraints * batchedConstraints);
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btSequentialImpulseConstraintSolverMt();
+	virtual ~btSequentialImpulseConstraintSolverMt();
+
+	btScalar resolveMultipleJointConstraints(const btAlignedObjectArray<int>& consIndices, int batchBegin, int batchEnd, int iteration);
+	btScalar resolveMultipleContactConstraints(const btAlignedObjectArray<int>& consIndices, int batchBegin, int batchEnd);
+	btScalar resolveMultipleContactSplitPenetrationImpulseConstraints(const btAlignedObjectArray<int>& consIndices, int batchBegin, int batchEnd);
+	btScalar resolveMultipleContactFrictionConstraints(const btAlignedObjectArray<int>& consIndices, int batchBegin, int batchEnd);
+	btScalar resolveMultipleContactRollingFrictionConstraints(const btAlignedObjectArray<int>& consIndices, int batchBegin, int batchEnd);
+	btScalar resolveMultipleContactConstraintsInterleaved(const btAlignedObjectArray<int>& contactIndices, int batchBegin, int batchEnd);
+
+	void internalCollectContactManifoldCachedInfo(btContactManifoldCachedInfo * cachedInfoArray, btPersistentManifold * *manifoldPtr, int numManifolds, const btContactSolverInfo& infoGlobal);
+	void internalAllocContactConstraints(const btContactManifoldCachedInfo* cachedInfoArray, int numManifolds);
+	void internalSetupContactConstraints(int iContactConstraint, const btContactSolverInfo& infoGlobal);
+	void internalConvertBodies(btCollisionObject * *bodies, int iBegin, int iEnd, const btContactSolverInfo& infoGlobal);
+	void internalWriteBackContacts(int iBegin, int iEnd, const btContactSolverInfo& infoGlobal);
+	void internalWriteBackJoints(int iBegin, int iEnd, const btContactSolverInfo& infoGlobal);
+	void internalWriteBackBodies(int iBegin, int iEnd, const btContactSolverInfo& infoGlobal);
+};
+
+#endif  //BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_MT_H
diff --git a/engine/inc/bullet/BulletDynamics/ConstraintSolver/btSliderConstraint.h b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btSliderConstraint.h
new file mode 100644
index 00000000..75ca34e9
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btSliderConstraint.h
@@ -0,0 +1,349 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+/*
+Added by Roman Ponomarev (rponom@gmail.com)
+April 04, 2008
+
+TODO:
+ - add clamping od accumulated impulse to improve stability
+ - add conversion for ODE constraint solver
+*/
+
+#ifndef BT_SLIDER_CONSTRAINT_H
+#define BT_SLIDER_CONSTRAINT_H
+
+#include "LinearMath/btScalar.h"  //for BT_USE_DOUBLE_PRECISION
+
+#ifdef BT_USE_DOUBLE_PRECISION
+#define btSliderConstraintData2 btSliderConstraintDoubleData
+#define btSliderConstraintDataName "btSliderConstraintDoubleData"
+#else
+#define btSliderConstraintData2 btSliderConstraintData
+#define btSliderConstraintDataName "btSliderConstraintData"
+#endif  //BT_USE_DOUBLE_PRECISION
+
+#include "LinearMath/btVector3.h"
+#include "btJacobianEntry.h"
+#include "btTypedConstraint.h"
+
+class btRigidBody;
+
+#define SLIDER_CONSTRAINT_DEF_SOFTNESS (btScalar(1.0))
+#define SLIDER_CONSTRAINT_DEF_DAMPING (btScalar(1.0))
+#define SLIDER_CONSTRAINT_DEF_RESTITUTION (btScalar(0.7))
+#define SLIDER_CONSTRAINT_DEF_CFM (btScalar(0.f))
+
+enum btSliderFlags
+{
+	BT_SLIDER_FLAGS_CFM_DIRLIN = (1 << 0),
+	BT_SLIDER_FLAGS_ERP_DIRLIN = (1 << 1),
+	BT_SLIDER_FLAGS_CFM_DIRANG = (1 << 2),
+	BT_SLIDER_FLAGS_ERP_DIRANG = (1 << 3),
+	BT_SLIDER_FLAGS_CFM_ORTLIN = (1 << 4),
+	BT_SLIDER_FLAGS_ERP_ORTLIN = (1 << 5),
+	BT_SLIDER_FLAGS_CFM_ORTANG = (1 << 6),
+	BT_SLIDER_FLAGS_ERP_ORTANG = (1 << 7),
+	BT_SLIDER_FLAGS_CFM_LIMLIN = (1 << 8),
+	BT_SLIDER_FLAGS_ERP_LIMLIN = (1 << 9),
+	BT_SLIDER_FLAGS_CFM_LIMANG = (1 << 10),
+	BT_SLIDER_FLAGS_ERP_LIMANG = (1 << 11)
+};
+
+ATTRIBUTE_ALIGNED16(class)
+btSliderConstraint : public btTypedConstraint
+{
+protected:
+	///for backwards compatibility during the transition to 'getInfo/getInfo2'
+	bool m_useSolveConstraintObsolete;
+	bool m_useOffsetForConstraintFrame;
+	btTransform m_frameInA;
+	btTransform m_frameInB;
+	// use frameA fo define limits, if true
+	bool m_useLinearReferenceFrameA;
+	// linear limits
+	btScalar m_lowerLinLimit;
+	btScalar m_upperLinLimit;
+	// angular limits
+	btScalar m_lowerAngLimit;
+	btScalar m_upperAngLimit;
+	// softness, restitution and damping for different cases
+	// DirLin - moving inside linear limits
+	// LimLin - hitting linear limit
+	// DirAng - moving inside angular limits
+	// LimAng - hitting angular limit
+	// OrthoLin, OrthoAng - against constraint axis
+	btScalar m_softnessDirLin;
+	btScalar m_restitutionDirLin;
+	btScalar m_dampingDirLin;
+	btScalar m_cfmDirLin;
+
+	btScalar m_softnessDirAng;
+	btScalar m_restitutionDirAng;
+	btScalar m_dampingDirAng;
+	btScalar m_cfmDirAng;
+
+	btScalar m_softnessLimLin;
+	btScalar m_restitutionLimLin;
+	btScalar m_dampingLimLin;
+	btScalar m_cfmLimLin;
+
+	btScalar m_softnessLimAng;
+	btScalar m_restitutionLimAng;
+	btScalar m_dampingLimAng;
+	btScalar m_cfmLimAng;
+
+	btScalar m_softnessOrthoLin;
+	btScalar m_restitutionOrthoLin;
+	btScalar m_dampingOrthoLin;
+	btScalar m_cfmOrthoLin;
+
+	btScalar m_softnessOrthoAng;
+	btScalar m_restitutionOrthoAng;
+	btScalar m_dampingOrthoAng;
+	btScalar m_cfmOrthoAng;
+
+	// for interlal use
+	bool m_solveLinLim;
+	bool m_solveAngLim;
+
+	int m_flags;
+
+	btJacobianEntry m_jacLin[3];
+	btScalar m_jacLinDiagABInv[3];
+
+	btJacobianEntry m_jacAng[3];
+
+	btScalar m_timeStep;
+	btTransform m_calculatedTransformA;
+	btTransform m_calculatedTransformB;
+
+	btVector3 m_sliderAxis;
+	btVector3 m_realPivotAInW;
+	btVector3 m_realPivotBInW;
+	btVector3 m_projPivotInW;
+	btVector3 m_delta;
+	btVector3 m_depth;
+	btVector3 m_relPosA;
+	btVector3 m_relPosB;
+
+	btScalar m_linPos;
+	btScalar m_angPos;
+
+	btScalar m_angDepth;
+	btScalar m_kAngle;
+
+	bool m_poweredLinMotor;
+	btScalar m_targetLinMotorVelocity;
+	btScalar m_maxLinMotorForce;
+	btScalar m_accumulatedLinMotorImpulse;
+
+	bool m_poweredAngMotor;
+	btScalar m_targetAngMotorVelocity;
+	btScalar m_maxAngMotorForce;
+	btScalar m_accumulatedAngMotorImpulse;
+
+	//------------------------
+	void initParams();
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	// constructors
+	btSliderConstraint(btRigidBody & rbA, btRigidBody & rbB, const btTransform& frameInA, const btTransform& frameInB, bool useLinearReferenceFrameA);
+	btSliderConstraint(btRigidBody & rbB, const btTransform& frameInB, bool useLinearReferenceFrameA);
+
+	// overrides
+
+	virtual void getInfo1(btConstraintInfo1 * info);
+
+	void getInfo1NonVirtual(btConstraintInfo1 * info);
+
+	virtual void getInfo2(btConstraintInfo2 * info);
+
+	void getInfo2NonVirtual(btConstraintInfo2 * info, const btTransform& transA, const btTransform& transB, const btVector3& linVelA, const btVector3& linVelB, btScalar rbAinvMass, btScalar rbBinvMass);
+
+	// access
+	const btRigidBody& getRigidBodyA() const { return m_rbA; }
+	const btRigidBody& getRigidBodyB() const { return m_rbB; }
+	const btTransform& getCalculatedTransformA() const { return m_calculatedTransformA; }
+	const btTransform& getCalculatedTransformB() const { return m_calculatedTransformB; }
+	const btTransform& getFrameOffsetA() const { return m_frameInA; }
+	const btTransform& getFrameOffsetB() const { return m_frameInB; }
+	btTransform& getFrameOffsetA() { return m_frameInA; }
+	btTransform& getFrameOffsetB() { return m_frameInB; }
+	btScalar getLowerLinLimit() { return m_lowerLinLimit; }
+	void setLowerLinLimit(btScalar lowerLimit) { m_lowerLinLimit = lowerLimit; }
+	btScalar getUpperLinLimit() { return m_upperLinLimit; }
+	void setUpperLinLimit(btScalar upperLimit) { m_upperLinLimit = upperLimit; }
+	btScalar getLowerAngLimit() { return m_lowerAngLimit; }
+	void setLowerAngLimit(btScalar lowerLimit) { m_lowerAngLimit = btNormalizeAngle(lowerLimit); }
+	btScalar getUpperAngLimit() { return m_upperAngLimit; }
+	void setUpperAngLimit(btScalar upperLimit) { m_upperAngLimit = btNormalizeAngle(upperLimit); }
+	bool getUseLinearReferenceFrameA() { return m_useLinearReferenceFrameA; }
+	btScalar getSoftnessDirLin() { return m_softnessDirLin; }
+	btScalar getRestitutionDirLin() { return m_restitutionDirLin; }
+	btScalar getDampingDirLin() { return m_dampingDirLin; }
+	btScalar getSoftnessDirAng() { return m_softnessDirAng; }
+	btScalar getRestitutionDirAng() { return m_restitutionDirAng; }
+	btScalar getDampingDirAng() { return m_dampingDirAng; }
+	btScalar getSoftnessLimLin() { return m_softnessLimLin; }
+	btScalar getRestitutionLimLin() { return m_restitutionLimLin; }
+	btScalar getDampingLimLin() { return m_dampingLimLin; }
+	btScalar getSoftnessLimAng() { return m_softnessLimAng; }
+	btScalar getRestitutionLimAng() { return m_restitutionLimAng; }
+	btScalar getDampingLimAng() { return m_dampingLimAng; }
+	btScalar getSoftnessOrthoLin() { return m_softnessOrthoLin; }
+	btScalar getRestitutionOrthoLin() { return m_restitutionOrthoLin; }
+	btScalar getDampingOrthoLin() { return m_dampingOrthoLin; }
+	btScalar getSoftnessOrthoAng() { return m_softnessOrthoAng; }
+	btScalar getRestitutionOrthoAng() { return m_restitutionOrthoAng; }
+	btScalar getDampingOrthoAng() { return m_dampingOrthoAng; }
+	void setSoftnessDirLin(btScalar softnessDirLin) { m_softnessDirLin = softnessDirLin; }
+	void setRestitutionDirLin(btScalar restitutionDirLin) { m_restitutionDirLin = restitutionDirLin; }
+	void setDampingDirLin(btScalar dampingDirLin) { m_dampingDirLin = dampingDirLin; }
+	void setSoftnessDirAng(btScalar softnessDirAng) { m_softnessDirAng = softnessDirAng; }
+	void setRestitutionDirAng(btScalar restitutionDirAng) { m_restitutionDirAng = restitutionDirAng; }
+	void setDampingDirAng(btScalar dampingDirAng) { m_dampingDirAng = dampingDirAng; }
+	void setSoftnessLimLin(btScalar softnessLimLin) { m_softnessLimLin = softnessLimLin; }
+	void setRestitutionLimLin(btScalar restitutionLimLin) { m_restitutionLimLin = restitutionLimLin; }
+	void setDampingLimLin(btScalar dampingLimLin) { m_dampingLimLin = dampingLimLin; }
+	void setSoftnessLimAng(btScalar softnessLimAng) { m_softnessLimAng = softnessLimAng; }
+	void setRestitutionLimAng(btScalar restitutionLimAng) { m_restitutionLimAng = restitutionLimAng; }
+	void setDampingLimAng(btScalar dampingLimAng) { m_dampingLimAng = dampingLimAng; }
+	void setSoftnessOrthoLin(btScalar softnessOrthoLin) { m_softnessOrthoLin = softnessOrthoLin; }
+	void setRestitutionOrthoLin(btScalar restitutionOrthoLin) { m_restitutionOrthoLin = restitutionOrthoLin; }
+	void setDampingOrthoLin(btScalar dampingOrthoLin) { m_dampingOrthoLin = dampingOrthoLin; }
+	void setSoftnessOrthoAng(btScalar softnessOrthoAng) { m_softnessOrthoAng = softnessOrthoAng; }
+	void setRestitutionOrthoAng(btScalar restitutionOrthoAng) { m_restitutionOrthoAng = restitutionOrthoAng; }
+	void setDampingOrthoAng(btScalar dampingOrthoAng) { m_dampingOrthoAng = dampingOrthoAng; }
+	void setPoweredLinMotor(bool onOff) { m_poweredLinMotor = onOff; }
+	bool getPoweredLinMotor() { return m_poweredLinMotor; }
+	void setTargetLinMotorVelocity(btScalar targetLinMotorVelocity) { m_targetLinMotorVelocity = targetLinMotorVelocity; }
+	btScalar getTargetLinMotorVelocity() { return m_targetLinMotorVelocity; }
+	void setMaxLinMotorForce(btScalar maxLinMotorForce) { m_maxLinMotorForce = maxLinMotorForce; }
+	btScalar getMaxLinMotorForce() { return m_maxLinMotorForce; }
+	void setPoweredAngMotor(bool onOff) { m_poweredAngMotor = onOff; }
+	bool getPoweredAngMotor() { return m_poweredAngMotor; }
+	void setTargetAngMotorVelocity(btScalar targetAngMotorVelocity) { m_targetAngMotorVelocity = targetAngMotorVelocity; }
+	btScalar getTargetAngMotorVelocity() { return m_targetAngMotorVelocity; }
+	void setMaxAngMotorForce(btScalar maxAngMotorForce) { m_maxAngMotorForce = maxAngMotorForce; }
+	btScalar getMaxAngMotorForce() { return m_maxAngMotorForce; }
+
+	btScalar getLinearPos() const { return m_linPos; }
+	btScalar getAngularPos() const { return m_angPos; }
+
+	// access for ODE solver
+	bool getSolveLinLimit() { return m_solveLinLim; }
+	btScalar getLinDepth() { return m_depth[0]; }
+	bool getSolveAngLimit() { return m_solveAngLim; }
+	btScalar getAngDepth() { return m_angDepth; }
+	// shared code used by ODE solver
+	void calculateTransforms(const btTransform& transA, const btTransform& transB);
+	void testLinLimits();
+	void testAngLimits();
+	// access for PE Solver
+	btVector3 getAncorInA();
+	btVector3 getAncorInB();
+	// access for UseFrameOffset
+	bool getUseFrameOffset() { return m_useOffsetForConstraintFrame; }
+	void setUseFrameOffset(bool frameOffsetOnOff) { m_useOffsetForConstraintFrame = frameOffsetOnOff; }
+
+	void setFrames(const btTransform& frameA, const btTransform& frameB)
+	{
+		m_frameInA = frameA;
+		m_frameInB = frameB;
+		calculateTransforms(m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform());
+		buildJacobian();
+	}
+
+	///override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5).
+	///If no axis is provided, it uses the default axis for this constraint.
+	virtual void setParam(int num, btScalar value, int axis = -1);
+	///return the local value of parameter
+	virtual btScalar getParam(int num, int axis = -1) const;
+
+	virtual int getFlags() const
+	{
+		return m_flags;
+	}
+
+	virtual int calculateSerializeBufferSize() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
+};
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+
+struct btSliderConstraintData
+{
+	btTypedConstraintData m_typeConstraintData;
+	btTransformFloatData m_rbAFrame;  // constraint axii. Assumes z is hinge axis.
+	btTransformFloatData m_rbBFrame;
+
+	float m_linearUpperLimit;
+	float m_linearLowerLimit;
+
+	float m_angularUpperLimit;
+	float m_angularLowerLimit;
+
+	int m_useLinearReferenceFrameA;
+	int m_useOffsetForConstraintFrame;
+};
+
+struct btSliderConstraintDoubleData
+{
+	btTypedConstraintDoubleData m_typeConstraintData;
+	btTransformDoubleData m_rbAFrame;  // constraint axii. Assumes z is hinge axis.
+	btTransformDoubleData m_rbBFrame;
+
+	double m_linearUpperLimit;
+	double m_linearLowerLimit;
+
+	double m_angularUpperLimit;
+	double m_angularLowerLimit;
+
+	int m_useLinearReferenceFrameA;
+	int m_useOffsetForConstraintFrame;
+};
+
+SIMD_FORCE_INLINE int btSliderConstraint::calculateSerializeBufferSize() const
+{
+	return sizeof(btSliderConstraintData2);
+}
+
+///fills the dataBuffer and returns the struct name (and 0 on failure)
+SIMD_FORCE_INLINE const char* btSliderConstraint::serialize(void* dataBuffer, btSerializer* serializer) const
+{
+	btSliderConstraintData2* sliderData = (btSliderConstraintData2*)dataBuffer;
+	btTypedConstraint::serialize(&sliderData->m_typeConstraintData, serializer);
+
+	m_frameInA.serialize(sliderData->m_rbAFrame);
+	m_frameInB.serialize(sliderData->m_rbBFrame);
+
+	sliderData->m_linearUpperLimit = m_upperLinLimit;
+	sliderData->m_linearLowerLimit = m_lowerLinLimit;
+
+	sliderData->m_angularUpperLimit = m_upperAngLimit;
+	sliderData->m_angularLowerLimit = m_lowerAngLimit;
+
+	sliderData->m_useLinearReferenceFrameA = m_useLinearReferenceFrameA;
+	sliderData->m_useOffsetForConstraintFrame = m_useOffsetForConstraintFrame;
+
+	return btSliderConstraintDataName;
+}
+
+#endif  //BT_SLIDER_CONSTRAINT_H
diff --git a/engine/inc/bullet/BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.h b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.h
new file mode 100644
index 00000000..fca8ecec
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.h
@@ -0,0 +1,101 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SOLVE_2LINEAR_CONSTRAINT_H
+#define BT_SOLVE_2LINEAR_CONSTRAINT_H
+
+#include "LinearMath/btMatrix3x3.h"
+#include "LinearMath/btVector3.h"
+
+class btRigidBody;
+
+/// constraint class used for lateral tyre friction.
+class btSolve2LinearConstraint
+{
+	btScalar m_tau;
+	btScalar m_damping;
+
+public:
+	btSolve2LinearConstraint(btScalar tau, btScalar damping)
+	{
+		m_tau = tau;
+		m_damping = damping;
+	}
+	//
+	// solve unilateral constraint (equality, direct method)
+	//
+	void resolveUnilateralPairConstraint(
+		btRigidBody* body0,
+		btRigidBody* body1,
+
+		const btMatrix3x3& world2A,
+		const btMatrix3x3& world2B,
+
+		const btVector3& invInertiaADiag,
+		const btScalar invMassA,
+		const btVector3& linvelA, const btVector3& angvelA,
+		const btVector3& rel_posA1,
+		const btVector3& invInertiaBDiag,
+		const btScalar invMassB,
+		const btVector3& linvelB, const btVector3& angvelB,
+		const btVector3& rel_posA2,
+
+		btScalar depthA, const btVector3& normalA,
+		const btVector3& rel_posB1, const btVector3& rel_posB2,
+		btScalar depthB, const btVector3& normalB,
+		btScalar& imp0, btScalar& imp1);
+
+	//
+	// solving 2x2 lcp problem (inequality, direct solution )
+	//
+	void resolveBilateralPairConstraint(
+		btRigidBody* body0,
+		btRigidBody* body1,
+		const btMatrix3x3& world2A,
+		const btMatrix3x3& world2B,
+
+		const btVector3& invInertiaADiag,
+		const btScalar invMassA,
+		const btVector3& linvelA, const btVector3& angvelA,
+		const btVector3& rel_posA1,
+		const btVector3& invInertiaBDiag,
+		const btScalar invMassB,
+		const btVector3& linvelB, const btVector3& angvelB,
+		const btVector3& rel_posA2,
+
+		btScalar depthA, const btVector3& normalA,
+		const btVector3& rel_posB1, const btVector3& rel_posB2,
+		btScalar depthB, const btVector3& normalB,
+		btScalar& imp0, btScalar& imp1);
+
+	/*
+	void resolveAngularConstraint(	const btMatrix3x3& invInertiaAWS,
+						const btScalar invMassA,
+						const btVector3& linvelA,const btVector3& angvelA,
+						const btVector3& rel_posA1,
+						const btMatrix3x3& invInertiaBWS,
+						const btScalar invMassB,
+						const btVector3& linvelB,const btVector3& angvelB,
+						const btVector3& rel_posA2,
+
+					  btScalar depthA, const btVector3& normalA, 
+					  const btVector3& rel_posB1,const btVector3& rel_posB2,
+					  btScalar depthB, const btVector3& normalB, 
+					  btScalar& imp0,btScalar& imp1);
+
+*/
+};
+
+#endif  //BT_SOLVE_2LINEAR_CONSTRAINT_H
diff --git a/engine/inc/bullet/BulletDynamics/ConstraintSolver/btSolverBody.h b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btSolverBody.h
new file mode 100644
index 00000000..409aa8a0
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btSolverBody.h
@@ -0,0 +1,285 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SOLVER_BODY_H
+#define BT_SOLVER_BODY_H
+
+class btRigidBody;
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btMatrix3x3.h"
+
+#include "LinearMath/btAlignedAllocator.h"
+#include "LinearMath/btTransformUtil.h"
+
+///Until we get other contributions, only use SIMD on Windows, when using Visual Studio 2008 or later, and not double precision
+#ifdef BT_USE_SSE
+#define USE_SIMD 1
+#endif  //
+
+#ifdef USE_SIMD
+
+struct btSimdScalar
+{
+	SIMD_FORCE_INLINE btSimdScalar()
+	{
+	}
+
+	SIMD_FORCE_INLINE btSimdScalar(float fl)
+		: m_vec128(_mm_set1_ps(fl))
+	{
+	}
+
+	SIMD_FORCE_INLINE btSimdScalar(__m128 v128)
+		: m_vec128(v128)
+	{
+	}
+	union {
+		__m128 m_vec128;
+		float m_floats[4];
+		int m_ints[4];
+		btScalar m_unusedPadding;
+	};
+	SIMD_FORCE_INLINE __m128 get128()
+	{
+		return m_vec128;
+	}
+
+	SIMD_FORCE_INLINE const __m128 get128() const
+	{
+		return m_vec128;
+	}
+
+	SIMD_FORCE_INLINE void set128(__m128 v128)
+	{
+		m_vec128 = v128;
+	}
+
+	SIMD_FORCE_INLINE operator __m128()
+	{
+		return m_vec128;
+	}
+	SIMD_FORCE_INLINE operator const __m128() const
+	{
+		return m_vec128;
+	}
+
+	SIMD_FORCE_INLINE operator float() const
+	{
+		return m_floats[0];
+	}
+};
+
+///@brief Return the elementwise product of two btSimdScalar
+SIMD_FORCE_INLINE btSimdScalar
+operator*(const btSimdScalar& v1, const btSimdScalar& v2)
+{
+	return btSimdScalar(_mm_mul_ps(v1.get128(), v2.get128()));
+}
+
+///@brief Return the elementwise product of two btSimdScalar
+SIMD_FORCE_INLINE btSimdScalar
+operator+(const btSimdScalar& v1, const btSimdScalar& v2)
+{
+	return btSimdScalar(_mm_add_ps(v1.get128(), v2.get128()));
+}
+
+#else
+#define btSimdScalar btScalar
+#endif
+
+///The btSolverBody is an internal datastructure for the constraint solver. Only necessary data is packed to increase cache coherence/performance.
+ATTRIBUTE_ALIGNED16(struct)
+btSolverBody
+{
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+	btTransform m_worldTransform;
+	btVector3 m_deltaLinearVelocity;
+	btVector3 m_deltaAngularVelocity;
+	btVector3 m_angularFactor;
+	btVector3 m_linearFactor;
+	btVector3 m_invMass;
+	btVector3 m_pushVelocity;
+	btVector3 m_turnVelocity;
+	btVector3 m_linearVelocity;
+	btVector3 m_angularVelocity;
+	btVector3 m_externalForceImpulse;
+	btVector3 m_externalTorqueImpulse;
+
+	btRigidBody* m_originalBody;
+	void setWorldTransform(const btTransform& worldTransform)
+	{
+		m_worldTransform = worldTransform;
+	}
+
+	const btTransform& getWorldTransform() const
+	{
+		return m_worldTransform;
+	}
+
+	SIMD_FORCE_INLINE void getVelocityInLocalPointNoDelta(const btVector3& rel_pos, btVector3& velocity) const
+	{
+		if (m_originalBody)
+			velocity = m_linearVelocity + m_externalForceImpulse + (m_angularVelocity + m_externalTorqueImpulse).cross(rel_pos);
+		else
+			velocity.setValue(0, 0, 0);
+	}
+
+	SIMD_FORCE_INLINE void getVelocityInLocalPointObsolete(const btVector3& rel_pos, btVector3& velocity) const
+	{
+		if (m_originalBody)
+			velocity = m_linearVelocity + m_deltaLinearVelocity + (m_angularVelocity + m_deltaAngularVelocity).cross(rel_pos);
+		else
+			velocity.setValue(0, 0, 0);
+	}
+
+	SIMD_FORCE_INLINE void getAngularVelocity(btVector3 & angVel) const
+	{
+		if (m_originalBody)
+			angVel = m_angularVelocity + m_deltaAngularVelocity;
+		else
+			angVel.setValue(0, 0, 0);
+	}
+
+	//Optimization for the iterative solver: avoid calculating constant terms involving inertia, normal, relative position
+	SIMD_FORCE_INLINE void applyImpulse(const btVector3& linearComponent, const btVector3& angularComponent, const btScalar impulseMagnitude)
+	{
+		if (m_originalBody)
+		{
+			m_deltaLinearVelocity += linearComponent * impulseMagnitude * m_linearFactor;
+			m_deltaAngularVelocity += angularComponent * (impulseMagnitude * m_angularFactor);
+		}
+	}
+
+	SIMD_FORCE_INLINE void internalApplyPushImpulse(const btVector3& linearComponent, const btVector3& angularComponent, btScalar impulseMagnitude)
+	{
+		if (m_originalBody)
+		{
+			m_pushVelocity += linearComponent * impulseMagnitude * m_linearFactor;
+			m_turnVelocity += angularComponent * (impulseMagnitude * m_angularFactor);
+		}
+	}
+
+	const btVector3& getDeltaLinearVelocity() const
+	{
+		return m_deltaLinearVelocity;
+	}
+
+	const btVector3& getDeltaAngularVelocity() const
+	{
+		return m_deltaAngularVelocity;
+	}
+
+	const btVector3& getPushVelocity() const
+	{
+		return m_pushVelocity;
+	}
+
+	const btVector3& getTurnVelocity() const
+	{
+		return m_turnVelocity;
+	}
+
+	////////////////////////////////////////////////
+	///some internal methods, don't use them
+
+	btVector3& internalGetDeltaLinearVelocity()
+	{
+		return m_deltaLinearVelocity;
+	}
+
+	btVector3& internalGetDeltaAngularVelocity()
+	{
+		return m_deltaAngularVelocity;
+	}
+
+	const btVector3& internalGetAngularFactor() const
+	{
+		return m_angularFactor;
+	}
+
+	const btVector3& internalGetInvMass() const
+	{
+		return m_invMass;
+	}
+
+	void internalSetInvMass(const btVector3& invMass)
+	{
+		m_invMass = invMass;
+	}
+
+	btVector3& internalGetPushVelocity()
+	{
+		return m_pushVelocity;
+	}
+
+	btVector3& internalGetTurnVelocity()
+	{
+		return m_turnVelocity;
+	}
+
+	SIMD_FORCE_INLINE void internalGetVelocityInLocalPointObsolete(const btVector3& rel_pos, btVector3& velocity) const
+	{
+		velocity = m_linearVelocity + m_deltaLinearVelocity + (m_angularVelocity + m_deltaAngularVelocity).cross(rel_pos);
+	}
+
+	SIMD_FORCE_INLINE void internalGetAngularVelocity(btVector3 & angVel) const
+	{
+		angVel = m_angularVelocity + m_deltaAngularVelocity;
+	}
+
+	//Optimization for the iterative solver: avoid calculating constant terms involving inertia, normal, relative position
+	SIMD_FORCE_INLINE void internalApplyImpulse(const btVector3& linearComponent, const btVector3& angularComponent, const btScalar impulseMagnitude)
+	{
+		if (m_originalBody)
+		{
+			m_deltaLinearVelocity += linearComponent * impulseMagnitude * m_linearFactor;
+			m_deltaAngularVelocity += angularComponent * (impulseMagnitude * m_angularFactor);
+		}
+	}
+
+	void writebackVelocity()
+	{
+		if (m_originalBody)
+		{
+			m_linearVelocity += m_deltaLinearVelocity;
+			m_angularVelocity += m_deltaAngularVelocity;
+
+			//m_originalBody->setCompanionId(-1);
+		}
+	}
+
+	void writebackVelocityAndTransform(btScalar timeStep, btScalar splitImpulseTurnErp)
+	{
+		(void)timeStep;
+		if (m_originalBody)
+		{
+			m_linearVelocity += m_deltaLinearVelocity;
+			m_angularVelocity += m_deltaAngularVelocity;
+
+			//correct the position/orientation based on push/turn recovery
+			btTransform newTransform;
+			if (m_pushVelocity[0] != 0.f || m_pushVelocity[1] != 0 || m_pushVelocity[2] != 0 || m_turnVelocity[0] != 0.f || m_turnVelocity[1] != 0 || m_turnVelocity[2] != 0)
+			{
+				//	btQuaternion orn = m_worldTransform.getRotation();
+				btTransformUtil::integrateTransform(m_worldTransform, m_pushVelocity, m_turnVelocity * splitImpulseTurnErp, timeStep, newTransform);
+				m_worldTransform = newTransform;
+			}
+			//m_worldTransform.setRotation(orn);
+			//m_originalBody->setCompanionId(-1);
+		}
+	}
+};
+
+#endif  //BT_SOLVER_BODY_H
diff --git a/engine/inc/bullet/BulletDynamics/ConstraintSolver/btSolverConstraint.h b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btSolverConstraint.h
new file mode 100644
index 00000000..c7938df8
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btSolverConstraint.h
@@ -0,0 +1,74 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SOLVER_CONSTRAINT_H
+#define BT_SOLVER_CONSTRAINT_H
+
+class btRigidBody;
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btMatrix3x3.h"
+#include "btJacobianEntry.h"
+#include "LinearMath/btAlignedObjectArray.h"
+
+//#define NO_FRICTION_TANGENTIALS 1
+#include "btSolverBody.h"
+
+///1D constraint along a normal axis between bodyA and bodyB. It can be combined to solve contact and friction constraints.
+ATTRIBUTE_ALIGNED16(struct)
+btSolverConstraint
+{
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btVector3 m_relpos1CrossNormal;
+	btVector3 m_contactNormal1;
+
+	btVector3 m_relpos2CrossNormal;
+	btVector3 m_contactNormal2;  //usually m_contactNormal2 == -m_contactNormal1, but not always
+
+	btVector3 m_angularComponentA;
+	btVector3 m_angularComponentB;
+
+	mutable btSimdScalar m_appliedPushImpulse;
+	mutable btSimdScalar m_appliedImpulse;
+
+	btScalar m_friction;
+	btScalar m_jacDiagABInv;
+	btScalar m_rhs;
+	btScalar m_cfm;
+
+	btScalar m_lowerLimit;
+	btScalar m_upperLimit;
+	btScalar m_rhsPenetration;
+	union {
+		void* m_originalContactPoint;
+		btScalar m_unusedPadding4;
+		int m_numRowsForNonContactConstraint;
+	};
+
+	int m_overrideNumSolverIterations;
+	int m_frictionIndex;
+	int m_solverBodyIdA;
+	int m_solverBodyIdB;
+
+	enum btSolverConstraintType
+	{
+		BT_SOLVER_CONTACT_1D = 0,
+		BT_SOLVER_FRICTION_1D
+	};
+};
+
+typedef btAlignedObjectArray<btSolverConstraint> btConstraintArray;
+
+#endif  //BT_SOLVER_CONSTRAINT_H
diff --git a/engine/inc/bullet/BulletDynamics/ConstraintSolver/btTypedConstraint.h b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btTypedConstraint.h
new file mode 100644
index 00000000..d30f3dee
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btTypedConstraint.h
@@ -0,0 +1,532 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2010 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_TYPED_CONSTRAINT_H
+#define BT_TYPED_CONSTRAINT_H
+
+#include "LinearMath/btScalar.h"
+#include "btSolverConstraint.h"
+#include "BulletDynamics/Dynamics/btRigidBody.h"
+
+#ifdef BT_USE_DOUBLE_PRECISION
+#define btTypedConstraintData2 btTypedConstraintDoubleData
+#define btTypedConstraintDataName "btTypedConstraintDoubleData"
+#else
+#define btTypedConstraintData2 btTypedConstraintFloatData
+#define btTypedConstraintDataName "btTypedConstraintFloatData"
+#endif  //BT_USE_DOUBLE_PRECISION
+
+class btSerializer;
+
+//Don't change any of the existing enum values, so add enum types at the end for serialization compatibility
+enum btTypedConstraintType
+{
+	POINT2POINT_CONSTRAINT_TYPE = 3,
+	HINGE_CONSTRAINT_TYPE,
+	CONETWIST_CONSTRAINT_TYPE,
+	D6_CONSTRAINT_TYPE,
+	SLIDER_CONSTRAINT_TYPE,
+	CONTACT_CONSTRAINT_TYPE,
+	D6_SPRING_CONSTRAINT_TYPE,
+	GEAR_CONSTRAINT_TYPE,
+	FIXED_CONSTRAINT_TYPE,
+	D6_SPRING_2_CONSTRAINT_TYPE,
+	MAX_CONSTRAINT_TYPE
+};
+
+enum btConstraintParams
+{
+	BT_CONSTRAINT_ERP = 1,
+	BT_CONSTRAINT_STOP_ERP,
+	BT_CONSTRAINT_CFM,
+	BT_CONSTRAINT_STOP_CFM
+};
+
+#if 1
+#define btAssertConstrParams(_par) btAssert(_par)
+#else
+#define btAssertConstrParams(_par)
+#endif
+
+ATTRIBUTE_ALIGNED16(struct)
+btJointFeedback
+{
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+	btVector3 m_appliedForceBodyA;
+	btVector3 m_appliedTorqueBodyA;
+	btVector3 m_appliedForceBodyB;
+	btVector3 m_appliedTorqueBodyB;
+};
+
+///TypedConstraint is the baseclass for Bullet constraints and vehicles
+ATTRIBUTE_ALIGNED16(class)
+btTypedConstraint : public btTypedObject
+{
+	int m_userConstraintType;
+
+	union {
+		int m_userConstraintId;
+		void* m_userConstraintPtr;
+	};
+
+	btScalar m_breakingImpulseThreshold;
+	bool m_isEnabled;
+	bool m_needsFeedback;
+	int m_overrideNumSolverIterations;
+
+	btTypedConstraint& operator=(btTypedConstraint& other)
+	{
+		btAssert(0);
+		(void)other;
+		return *this;
+	}
+
+protected:
+	btRigidBody& m_rbA;
+	btRigidBody& m_rbB;
+	btScalar m_appliedImpulse;
+	btScalar m_dbgDrawSize;
+	btJointFeedback* m_jointFeedback;
+
+	///internal method used by the constraint solver, don't use them directly
+	btScalar getMotorFactor(btScalar pos, btScalar lowLim, btScalar uppLim, btScalar vel, btScalar timeFact);
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	virtual ~btTypedConstraint(){};
+	btTypedConstraint(btTypedConstraintType type, btRigidBody & rbA);
+	btTypedConstraint(btTypedConstraintType type, btRigidBody & rbA, btRigidBody & rbB);
+
+	struct btConstraintInfo1
+	{
+		int m_numConstraintRows, nub;
+	};
+
+	static btRigidBody& getFixedBody();
+
+	struct btConstraintInfo2
+	{
+		// integrator parameters: frames per second (1/stepsize), default error
+		// reduction parameter (0..1).
+		btScalar fps, erp;
+
+		// for the first and second body, pointers to two (linear and angular)
+		// n*3 jacobian sub matrices, stored by rows. these matrices will have
+		// been initialized to 0 on entry. if the second body is zero then the
+		// J2xx pointers may be 0.
+		btScalar *m_J1linearAxis, *m_J1angularAxis, *m_J2linearAxis, *m_J2angularAxis;
+
+		// elements to jump from one row to the next in J's
+		int rowskip;
+
+		// right hand sides of the equation J*v = c + cfm * lambda. cfm is the
+		// "constraint force mixing" vector. c is set to zero on entry, cfm is
+		// set to a constant value (typically very small or zero) value on entry.
+		btScalar *m_constraintError, *cfm;
+
+		// lo and hi limits for variables (set to -/+ infinity on entry).
+		btScalar *m_lowerLimit, *m_upperLimit;
+
+		// number of solver iterations
+		int m_numIterations;
+
+		//damping of the velocity
+		btScalar m_damping;
+	};
+
+	int getOverrideNumSolverIterations() const
+	{
+		return m_overrideNumSolverIterations;
+	}
+
+	///override the number of constraint solver iterations used to solve this constraint
+	///-1 will use the default number of iterations, as specified in SolverInfo.m_numIterations
+	void setOverrideNumSolverIterations(int overideNumIterations)
+	{
+		m_overrideNumSolverIterations = overideNumIterations;
+	}
+
+	///internal method used by the constraint solver, don't use them directly
+	virtual void buildJacobian(){};
+
+	///internal method used by the constraint solver, don't use them directly
+	virtual void setupSolverConstraint(btConstraintArray & ca, int solverBodyA, int solverBodyB, btScalar timeStep)
+	{
+		(void)ca;
+		(void)solverBodyA;
+		(void)solverBodyB;
+		(void)timeStep;
+	}
+
+	///internal method used by the constraint solver, don't use them directly
+	virtual void getInfo1(btConstraintInfo1 * info) = 0;
+
+	///internal method used by the constraint solver, don't use them directly
+	virtual void getInfo2(btConstraintInfo2 * info) = 0;
+
+	///internal method used by the constraint solver, don't use them directly
+	void internalSetAppliedImpulse(btScalar appliedImpulse)
+	{
+		m_appliedImpulse = appliedImpulse;
+	}
+	///internal method used by the constraint solver, don't use them directly
+	btScalar internalGetAppliedImpulse()
+	{
+		return m_appliedImpulse;
+	}
+
+	btScalar getBreakingImpulseThreshold() const
+	{
+		return m_breakingImpulseThreshold;
+	}
+
+	void setBreakingImpulseThreshold(btScalar threshold)
+	{
+		m_breakingImpulseThreshold = threshold;
+	}
+
+	bool isEnabled() const
+	{
+		return m_isEnabled;
+	}
+
+	void setEnabled(bool enabled)
+	{
+		m_isEnabled = enabled;
+	}
+
+	///internal method used by the constraint solver, don't use them directly
+	virtual void solveConstraintObsolete(btSolverBody& /*bodyA*/, btSolverBody& /*bodyB*/, btScalar /*timeStep*/){};
+
+	const btRigidBody& getRigidBodyA() const
+	{
+		return m_rbA;
+	}
+	const btRigidBody& getRigidBodyB() const
+	{
+		return m_rbB;
+	}
+
+	btRigidBody& getRigidBodyA()
+	{
+		return m_rbA;
+	}
+	btRigidBody& getRigidBodyB()
+	{
+		return m_rbB;
+	}
+
+	int getUserConstraintType() const
+	{
+		return m_userConstraintType;
+	}
+
+	void setUserConstraintType(int userConstraintType)
+	{
+		m_userConstraintType = userConstraintType;
+	};
+
+	void setUserConstraintId(int uid)
+	{
+		m_userConstraintId = uid;
+	}
+
+	int getUserConstraintId() const
+	{
+		return m_userConstraintId;
+	}
+
+	void setUserConstraintPtr(void* ptr)
+	{
+		m_userConstraintPtr = ptr;
+	}
+
+	void* getUserConstraintPtr()
+	{
+		return m_userConstraintPtr;
+	}
+
+	void setJointFeedback(btJointFeedback * jointFeedback)
+	{
+		m_jointFeedback = jointFeedback;
+	}
+
+	const btJointFeedback* getJointFeedback() const
+	{
+		return m_jointFeedback;
+	}
+
+	btJointFeedback* getJointFeedback()
+	{
+		return m_jointFeedback;
+	}
+
+	int getUid() const
+	{
+		return m_userConstraintId;
+	}
+
+	bool needsFeedback() const
+	{
+		return m_needsFeedback;
+	}
+
+	///enableFeedback will allow to read the applied linear and angular impulse
+	///use getAppliedImpulse, getAppliedLinearImpulse and getAppliedAngularImpulse to read feedback information
+	void enableFeedback(bool needsFeedback)
+	{
+		m_needsFeedback = needsFeedback;
+	}
+
+	///getAppliedImpulse is an estimated total applied impulse.
+	///This feedback could be used to determine breaking constraints or playing sounds.
+	btScalar getAppliedImpulse() const
+	{
+		btAssert(m_needsFeedback);
+		return m_appliedImpulse;
+	}
+
+	btTypedConstraintType getConstraintType() const
+	{
+		return btTypedConstraintType(m_objectType);
+	}
+
+	void setDbgDrawSize(btScalar dbgDrawSize)
+	{
+		m_dbgDrawSize = dbgDrawSize;
+	}
+	btScalar getDbgDrawSize()
+	{
+		return m_dbgDrawSize;
+	}
+
+	///override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5).
+	///If no axis is provided, it uses the default axis for this constraint.
+	virtual void setParam(int num, btScalar value, int axis = -1) = 0;
+
+	///return the local value of parameter
+	virtual btScalar getParam(int num, int axis = -1) const = 0;
+
+	virtual int calculateSerializeBufferSize() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
+};
+
+// returns angle in range [-SIMD_2_PI, SIMD_2_PI], closest to one of the limits
+// all arguments should be normalized angles (i.e. in range [-SIMD_PI, SIMD_PI])
+SIMD_FORCE_INLINE btScalar btAdjustAngleToLimits(btScalar angleInRadians, btScalar angleLowerLimitInRadians, btScalar angleUpperLimitInRadians)
+{
+	if (angleLowerLimitInRadians >= angleUpperLimitInRadians)
+	{
+		return angleInRadians;
+	}
+	else if (angleInRadians < angleLowerLimitInRadians)
+	{
+		btScalar diffLo = btFabs(btNormalizeAngle(angleLowerLimitInRadians - angleInRadians));
+		btScalar diffHi = btFabs(btNormalizeAngle(angleUpperLimitInRadians - angleInRadians));
+		return (diffLo < diffHi) ? angleInRadians : (angleInRadians + SIMD_2_PI);
+	}
+	else if (angleInRadians > angleUpperLimitInRadians)
+	{
+		btScalar diffHi = btFabs(btNormalizeAngle(angleInRadians - angleUpperLimitInRadians));
+		btScalar diffLo = btFabs(btNormalizeAngle(angleInRadians - angleLowerLimitInRadians));
+		return (diffLo < diffHi) ? (angleInRadians - SIMD_2_PI) : angleInRadians;
+	}
+	else
+	{
+		return angleInRadians;
+	}
+}
+
+// clang-format off
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct	btTypedConstraintFloatData
+{
+	btRigidBodyFloatData		*m_rbA;
+	btRigidBodyFloatData		*m_rbB;
+	char	*m_name;
+
+	int	m_objectType;
+	int	m_userConstraintType;
+	int	m_userConstraintId;
+	int	m_needsFeedback;
+
+	float	m_appliedImpulse;
+	float	m_dbgDrawSize;
+
+	int	m_disableCollisionsBetweenLinkedBodies;
+	int	m_overrideNumSolverIterations;
+
+	float	m_breakingImpulseThreshold;
+	int		m_isEnabled;
+	
+};
+
+
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+
+#define BT_BACKWARDS_COMPATIBLE_SERIALIZATION
+#ifdef BT_BACKWARDS_COMPATIBLE_SERIALIZATION
+///this structure is not used, except for loading pre-2.82 .bullet files
+struct	btTypedConstraintData
+{
+	btRigidBodyData		*m_rbA;
+	btRigidBodyData		*m_rbB;
+	char	*m_name;
+
+	int	m_objectType;
+	int	m_userConstraintType;
+	int	m_userConstraintId;
+	int	m_needsFeedback;
+
+	float	m_appliedImpulse;
+	float	m_dbgDrawSize;
+
+	int	m_disableCollisionsBetweenLinkedBodies;
+	int	m_overrideNumSolverIterations;
+
+	float	m_breakingImpulseThreshold;
+	int		m_isEnabled;
+	
+};
+#endif //BACKWARDS_COMPATIBLE
+
+struct	btTypedConstraintDoubleData
+{
+	btRigidBodyDoubleData		*m_rbA;
+	btRigidBodyDoubleData		*m_rbB;
+	char	*m_name;
+
+	int	m_objectType;
+	int	m_userConstraintType;
+	int	m_userConstraintId;
+	int	m_needsFeedback;
+
+	double	m_appliedImpulse;
+	double	m_dbgDrawSize;
+
+	int	m_disableCollisionsBetweenLinkedBodies;
+	int	m_overrideNumSolverIterations;
+
+	double	m_breakingImpulseThreshold;
+	int		m_isEnabled;
+	char	padding[4];
+	
+};
+
+// clang-format on
+
+SIMD_FORCE_INLINE int btTypedConstraint::calculateSerializeBufferSize() const
+{
+	return sizeof(btTypedConstraintData2);
+}
+
+class btAngularLimit
+{
+private:
+	btScalar
+		m_center,
+		m_halfRange,
+		m_softness,
+		m_biasFactor,
+		m_relaxationFactor,
+		m_correction,
+		m_sign;
+
+	bool
+		m_solveLimit;
+
+public:
+	/// Default constructor initializes limit as inactive, allowing free constraint movement
+	btAngularLimit()
+		: m_center(0.0f),
+		  m_halfRange(-1.0f),
+		  m_softness(0.9f),
+		  m_biasFactor(0.3f),
+		  m_relaxationFactor(1.0f),
+		  m_correction(0.0f),
+		  m_sign(0.0f),
+		  m_solveLimit(false)
+	{
+	}
+
+	/// Sets all limit's parameters.
+	/// When low > high limit becomes inactive.
+	/// When high - low > 2PI limit is ineffective too becouse no angle can exceed the limit
+	void set(btScalar low, btScalar high, btScalar _softness = 0.9f, btScalar _biasFactor = 0.3f, btScalar _relaxationFactor = 1.0f);
+
+	/// Checks conastaint angle against limit. If limit is active and the angle violates the limit
+	/// correction is calculated.
+	void test(const btScalar angle);
+
+	/// Returns limit's softness
+	inline btScalar getSoftness() const
+	{
+		return m_softness;
+	}
+
+	/// Returns limit's bias factor
+	inline btScalar getBiasFactor() const
+	{
+		return m_biasFactor;
+	}
+
+	/// Returns limit's relaxation factor
+	inline btScalar getRelaxationFactor() const
+	{
+		return m_relaxationFactor;
+	}
+
+	/// Returns correction value evaluated when test() was invoked
+	inline btScalar getCorrection() const
+	{
+		return m_correction;
+	}
+
+	/// Returns sign value evaluated when test() was invoked
+	inline btScalar getSign() const
+	{
+		return m_sign;
+	}
+
+	/// Gives half of the distance between min and max limit angle
+	inline btScalar getHalfRange() const
+	{
+		return m_halfRange;
+	}
+
+	/// Returns true when the last test() invocation recognized limit violation
+	inline bool isLimit() const
+	{
+		return m_solveLimit;
+	}
+
+	/// Checks given angle against limit. If limit is active and angle doesn't fit it, the angle
+	/// returned is modified so it equals to the limit closest to given angle.
+	void fit(btScalar& angle) const;
+
+	/// Returns correction value multiplied by sign value
+	btScalar getError() const;
+
+	btScalar getLow() const;
+
+	btScalar getHigh() const;
+};
+
+#endif  //BT_TYPED_CONSTRAINT_H
diff --git a/engine/inc/bullet/BulletDynamics/ConstraintSolver/btUniversalConstraint.h b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btUniversalConstraint.h
new file mode 100644
index 00000000..8c24d93a
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/ConstraintSolver/btUniversalConstraint.h
@@ -0,0 +1,59 @@
+/*
+Bullet Continuous Collision Detection and Physics Library, http://bulletphysics.org
+Copyright (C) 2006, 2007 Sony Computer Entertainment Inc. 
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_UNIVERSAL_CONSTRAINT_H
+#define BT_UNIVERSAL_CONSTRAINT_H
+
+#include "LinearMath/btVector3.h"
+#include "btTypedConstraint.h"
+#include "btGeneric6DofConstraint.h"
+
+/// Constraint similar to ODE Universal Joint
+/// has 2 rotatioonal degrees of freedom, similar to Euler rotations around Z (axis 1)
+/// and Y (axis 2)
+/// Description from ODE manual :
+/// "Given axis 1 on body 1, and axis 2 on body 2 that is perpendicular to axis 1, it keeps them perpendicular.
+/// In other words, rotation of the two bodies about the direction perpendicular to the two axes will be equal."
+
+ATTRIBUTE_ALIGNED16(class)
+btUniversalConstraint : public btGeneric6DofConstraint
+{
+protected:
+	btVector3 m_anchor;
+	btVector3 m_axis1;
+	btVector3 m_axis2;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	// constructor
+	// anchor, axis1 and axis2 are in world coordinate system
+	// axis1 must be orthogonal to axis2
+	btUniversalConstraint(btRigidBody & rbA, btRigidBody & rbB, const btVector3& anchor, const btVector3& axis1, const btVector3& axis2);
+	// access
+	const btVector3& getAnchor() { return m_calculatedTransformA.getOrigin(); }
+	const btVector3& getAnchor2() { return m_calculatedTransformB.getOrigin(); }
+	const btVector3& getAxis1() { return m_axis1; }
+	const btVector3& getAxis2() { return m_axis2; }
+	btScalar getAngle1() { return getAngle(2); }
+	btScalar getAngle2() { return getAngle(1); }
+	// limits
+	void setUpperLimit(btScalar ang1max, btScalar ang2max) { setAngularUpperLimit(btVector3(0.f, ang1max, ang2max)); }
+	void setLowerLimit(btScalar ang1min, btScalar ang2min) { setAngularLowerLimit(btVector3(0.f, ang1min, ang2min)); }
+
+	void setAxis(const btVector3& axis1, const btVector3& axis2);
+};
+
+#endif  // BT_UNIVERSAL_CONSTRAINT_H
diff --git a/engine/inc/bullet/BulletDynamics/Dynamics/btActionInterface.h b/engine/inc/bullet/BulletDynamics/Dynamics/btActionInterface.h
new file mode 100644
index 00000000..b5cac56c
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/Dynamics/btActionInterface.h
@@ -0,0 +1,41 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef _BT_ACTION_INTERFACE_H
+#define _BT_ACTION_INTERFACE_H
+
+class btIDebugDraw;
+class btCollisionWorld;
+
+#include "LinearMath/btScalar.h"
+#include "btRigidBody.h"
+
+///Basic interface to allow actions such as vehicles and characters to be updated inside a btDynamicsWorld
+class btActionInterface
+{
+protected:
+	static btRigidBody& getFixedBody();
+
+public:
+	virtual ~btActionInterface()
+	{
+	}
+
+	virtual void updateAction(btCollisionWorld* collisionWorld, btScalar deltaTimeStep) = 0;
+
+	virtual void debugDraw(btIDebugDraw* debugDrawer) = 0;
+};
+
+#endif  //_BT_ACTION_INTERFACE_H
diff --git a/engine/inc/bullet/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h b/engine/inc/bullet/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h
new file mode 100644
index 00000000..73607c61
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h
@@ -0,0 +1,244 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_DISCRETE_DYNAMICS_WORLD_H
+#define BT_DISCRETE_DYNAMICS_WORLD_H
+
+#include "btDynamicsWorld.h"
+class btDispatcher;
+class btOverlappingPairCache;
+class btConstraintSolver;
+class btSimulationIslandManager;
+class btTypedConstraint;
+class btActionInterface;
+class btPersistentManifold;
+class btIDebugDraw;
+
+struct InplaceSolverIslandCallback;
+
+#include "LinearMath/btAlignedObjectArray.h"
+#include "LinearMath/btThreads.h"
+
+///btDiscreteDynamicsWorld provides discrete rigid body simulation
+///those classes replace the obsolete CcdPhysicsEnvironment/CcdPhysicsController
+ATTRIBUTE_ALIGNED16(class)
+btDiscreteDynamicsWorld : public btDynamicsWorld
+{
+protected:
+	btAlignedObjectArray<btTypedConstraint*> m_sortedConstraints;
+	InplaceSolverIslandCallback* m_solverIslandCallback;
+
+	btConstraintSolver* m_constraintSolver;
+
+	btSimulationIslandManager* m_islandManager;
+
+	btAlignedObjectArray<btTypedConstraint*> m_constraints;
+
+	btAlignedObjectArray<btRigidBody*> m_nonStaticRigidBodies;
+
+	btVector3 m_gravity;
+
+	//for variable timesteps
+	btScalar m_localTime;
+	btScalar m_fixedTimeStep;
+	//for variable timesteps
+
+	bool m_ownsIslandManager;
+	bool m_ownsConstraintSolver;
+	bool m_synchronizeAllMotionStates;
+	bool m_applySpeculativeContactRestitution;
+
+	btAlignedObjectArray<btActionInterface*> m_actions;
+
+	int m_profileTimings;
+
+	bool m_latencyMotionStateInterpolation;
+
+	btAlignedObjectArray<btPersistentManifold*> m_predictiveManifolds;
+	btSpinMutex m_predictiveManifoldsMutex;  // used to synchronize threads creating predictive contacts
+
+	virtual void predictUnconstraintMotion(btScalar timeStep);
+
+	void integrateTransformsInternal(btRigidBody * *bodies, int numBodies, btScalar timeStep);  // can be called in parallel
+	virtual void integrateTransforms(btScalar timeStep);
+
+	virtual void calculateSimulationIslands();
+
+	
+
+	virtual void updateActivationState(btScalar timeStep);
+
+	void updateActions(btScalar timeStep);
+
+	void startProfiling(btScalar timeStep);
+
+	virtual void internalSingleStepSimulation(btScalar timeStep);
+
+	void releasePredictiveContacts();
+	void createPredictiveContactsInternal(btRigidBody * *bodies, int numBodies, btScalar timeStep);  // can be called in parallel
+	virtual void createPredictiveContacts(btScalar timeStep);
+
+	virtual void saveKinematicState(btScalar timeStep);
+
+	void serializeRigidBodies(btSerializer * serializer);
+
+	void serializeDynamicsWorldInfo(btSerializer * serializer);
+    
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	///this btDiscreteDynamicsWorld constructor gets created objects from the user, and will not delete those
+	btDiscreteDynamicsWorld(btDispatcher * dispatcher, btBroadphaseInterface * pairCache, btConstraintSolver * constraintSolver, btCollisionConfiguration * collisionConfiguration);
+
+	virtual ~btDiscreteDynamicsWorld();
+
+	///if maxSubSteps > 0, it will interpolate motion between fixedTimeStep's
+	virtual int stepSimulation(btScalar timeStep, int maxSubSteps = 1, btScalar fixedTimeStep = btScalar(1.) / btScalar(60.));
+
+    virtual void solveConstraints(btContactSolverInfo & solverInfo);
+    
+	virtual void synchronizeMotionStates();
+
+	///this can be useful to synchronize a single rigid body -> graphics object
+	void synchronizeSingleMotionState(btRigidBody * body);
+
+	virtual void addConstraint(btTypedConstraint * constraint, bool disableCollisionsBetweenLinkedBodies = false);
+
+	virtual void removeConstraint(btTypedConstraint * constraint);
+
+	virtual void addAction(btActionInterface*);
+
+	virtual void removeAction(btActionInterface*);
+
+	btSimulationIslandManager* getSimulationIslandManager()
+	{
+		return m_islandManager;
+	}
+
+	const btSimulationIslandManager* getSimulationIslandManager() const
+	{
+		return m_islandManager;
+	}
+
+	btCollisionWorld* getCollisionWorld()
+	{
+		return this;
+	}
+
+	virtual void setGravity(const btVector3& gravity);
+
+	virtual btVector3 getGravity() const;
+
+	virtual void addCollisionObject(btCollisionObject * collisionObject, int collisionFilterGroup = btBroadphaseProxy::StaticFilter, int collisionFilterMask = btBroadphaseProxy::AllFilter ^ btBroadphaseProxy::StaticFilter);
+
+	virtual void addRigidBody(btRigidBody * body);
+
+	virtual void addRigidBody(btRigidBody * body, int group, int mask);
+
+	virtual void removeRigidBody(btRigidBody * body);
+
+	///removeCollisionObject will first check if it is a rigid body, if so call removeRigidBody otherwise call btCollisionWorld::removeCollisionObject
+	virtual void removeCollisionObject(btCollisionObject * collisionObject);
+
+	virtual void debugDrawConstraint(btTypedConstraint * constraint);
+
+	virtual void debugDrawWorld();
+
+	virtual void setConstraintSolver(btConstraintSolver * solver);
+
+	virtual btConstraintSolver* getConstraintSolver();
+
+	virtual int getNumConstraints() const;
+
+	virtual btTypedConstraint* getConstraint(int index);
+
+	virtual const btTypedConstraint* getConstraint(int index) const;
+
+	virtual btDynamicsWorldType getWorldType() const
+	{
+		return BT_DISCRETE_DYNAMICS_WORLD;
+	}
+
+	///the forces on each rigidbody is accumulating together with gravity. clear this after each timestep.
+	virtual void clearForces();
+
+	///apply gravity, call this once per timestep
+	virtual void applyGravity();
+
+	virtual void setNumTasks(int numTasks)
+	{
+		(void)numTasks;
+	}
+
+	///obsolete, use updateActions instead
+	virtual void updateVehicles(btScalar timeStep)
+	{
+		updateActions(timeStep);
+	}
+
+	///obsolete, use addAction instead
+	virtual void addVehicle(btActionInterface * vehicle);
+	///obsolete, use removeAction instead
+	virtual void removeVehicle(btActionInterface * vehicle);
+	///obsolete, use addAction instead
+	virtual void addCharacter(btActionInterface * character);
+	///obsolete, use removeAction instead
+	virtual void removeCharacter(btActionInterface * character);
+
+	void setSynchronizeAllMotionStates(bool synchronizeAll)
+	{
+		m_synchronizeAllMotionStates = synchronizeAll;
+	}
+	bool getSynchronizeAllMotionStates() const
+	{
+		return m_synchronizeAllMotionStates;
+	}
+
+	void setApplySpeculativeContactRestitution(bool enable)
+	{
+		m_applySpeculativeContactRestitution = enable;
+	}
+
+	bool getApplySpeculativeContactRestitution() const
+	{
+		return m_applySpeculativeContactRestitution;
+	}
+
+	///Preliminary serialization test for Bullet 2.76. Loading those files requires a separate parser (see Bullet/Demos/SerializeDemo)
+	virtual void serialize(btSerializer * serializer);
+
+	///Interpolate motion state between previous and current transform, instead of current and next transform.
+	///This can relieve discontinuities in the rendering, due to penetrations
+	void setLatencyMotionStateInterpolation(bool latencyInterpolation)
+	{
+		m_latencyMotionStateInterpolation = latencyInterpolation;
+	}
+	bool getLatencyMotionStateInterpolation() const
+	{
+		return m_latencyMotionStateInterpolation;
+	}
+    
+    btAlignedObjectArray<btRigidBody*>& getNonStaticRigidBodies()
+    {
+        return m_nonStaticRigidBodies;
+    }
+    
+    const btAlignedObjectArray<btRigidBody*>& getNonStaticRigidBodies() const
+    {
+        return m_nonStaticRigidBodies;
+    }
+};
+
+#endif  //BT_DISCRETE_DYNAMICS_WORLD_H
diff --git a/engine/inc/bullet/BulletDynamics/Dynamics/btDiscreteDynamicsWorldMt.h b/engine/inc/bullet/BulletDynamics/Dynamics/btDiscreteDynamicsWorldMt.h
new file mode 100644
index 00000000..dccf35d7
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/Dynamics/btDiscreteDynamicsWorldMt.h
@@ -0,0 +1,131 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_DISCRETE_DYNAMICS_WORLD_MT_H
+#define BT_DISCRETE_DYNAMICS_WORLD_MT_H
+
+#include "btDiscreteDynamicsWorld.h"
+#include "btSimulationIslandManagerMt.h"
+#include "BulletDynamics/ConstraintSolver/btConstraintSolver.h"
+
+///
+/// btConstraintSolverPoolMt - masquerades as a constraint solver, but really it is a threadsafe pool of them.
+///
+///  Each solver in the pool is protected by a mutex.  When solveGroup is called from a thread,
+///  the pool looks for a solver that isn't being used by another thread, locks it, and dispatches the
+///  call to the solver.
+///  So long as there are at least as many solvers as there are hardware threads, it should never need to
+///  spin wait.
+///
+class btConstraintSolverPoolMt : public btConstraintSolver
+{
+public:
+	// create the solvers for me
+	explicit btConstraintSolverPoolMt(int numSolvers);
+
+	// pass in fully constructed solvers (destructor will delete them)
+	btConstraintSolverPoolMt(btConstraintSolver** solvers, int numSolvers);
+
+	virtual ~btConstraintSolverPoolMt();
+
+	///solve a group of constraints
+	virtual btScalar solveGroup(btCollisionObject** bodies,
+								int numBodies,
+								btPersistentManifold** manifolds,
+								int numManifolds,
+								btTypedConstraint** constraints,
+								int numConstraints,
+								const btContactSolverInfo& info,
+								btIDebugDraw* debugDrawer,
+								btDispatcher* dispatcher) BT_OVERRIDE;
+
+	virtual void reset() BT_OVERRIDE;
+	virtual btConstraintSolverType getSolverType() const BT_OVERRIDE { return m_solverType; }
+
+private:
+	const static size_t kCacheLineSize = 128;
+	struct ThreadSolver
+	{
+		btConstraintSolver* solver;
+		btSpinMutex mutex;
+		char _cachelinePadding[kCacheLineSize - sizeof(btSpinMutex) - sizeof(void*)];  // keep mutexes from sharing a cache line
+	};
+	btAlignedObjectArray<ThreadSolver> m_solvers;
+	btConstraintSolverType m_solverType;
+
+	ThreadSolver* getAndLockThreadSolver();
+	void init(btConstraintSolver** solvers, int numSolvers);
+};
+
+///
+/// btDiscreteDynamicsWorldMt -- a version of DiscreteDynamicsWorld with some minor changes to support
+///                              solving simulation islands on multiple threads.
+///
+///  Should function exactly like btDiscreteDynamicsWorld.
+///  Also 3 methods that iterate over all of the rigidbodies can run in parallel:
+///     - predictUnconstraintMotion
+///     - integrateTransforms
+///     - createPredictiveContacts
+///
+ATTRIBUTE_ALIGNED16(class)
+btDiscreteDynamicsWorldMt : public btDiscreteDynamicsWorld
+{
+protected:
+	btConstraintSolver* m_constraintSolverMt;
+
+	virtual void solveConstraints(btContactSolverInfo & solverInfo) BT_OVERRIDE;
+
+	virtual void predictUnconstraintMotion(btScalar timeStep) BT_OVERRIDE;
+
+	struct UpdaterCreatePredictiveContacts : public btIParallelForBody
+	{
+		btScalar timeStep;
+		btRigidBody** rigidBodies;
+		btDiscreteDynamicsWorldMt* world;
+
+		void forLoop(int iBegin, int iEnd) const BT_OVERRIDE
+		{
+			world->createPredictiveContactsInternal(&rigidBodies[iBegin], iEnd - iBegin, timeStep);
+		}
+	};
+	virtual void createPredictiveContacts(btScalar timeStep) BT_OVERRIDE;
+
+	struct UpdaterIntegrateTransforms : public btIParallelForBody
+	{
+		btScalar timeStep;
+		btRigidBody** rigidBodies;
+		btDiscreteDynamicsWorldMt* world;
+
+		void forLoop(int iBegin, int iEnd) const BT_OVERRIDE
+		{
+			world->integrateTransformsInternal(&rigidBodies[iBegin], iEnd - iBegin, timeStep);
+		}
+	};
+	virtual void integrateTransforms(btScalar timeStep) BT_OVERRIDE;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btDiscreteDynamicsWorldMt(btDispatcher * dispatcher,
+							  btBroadphaseInterface * pairCache,
+							  btConstraintSolverPoolMt * solverPool,        // Note this should be a solver-pool for multi-threading
+							  btConstraintSolver * constraintSolverMt,      // single multi-threaded solver for large islands (or NULL)
+							  btCollisionConfiguration * collisionConfiguration);
+	virtual ~btDiscreteDynamicsWorldMt();
+
+	virtual int stepSimulation(btScalar timeStep, int maxSubSteps, btScalar fixedTimeStep) BT_OVERRIDE;
+};
+
+#endif  //BT_DISCRETE_DYNAMICS_WORLD_H
diff --git a/engine/inc/bullet/BulletDynamics/Dynamics/btDynamicsWorld.h b/engine/inc/bullet/BulletDynamics/Dynamics/btDynamicsWorld.h
new file mode 100644
index 00000000..3c55234a
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/Dynamics/btDynamicsWorld.h
@@ -0,0 +1,174 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_DYNAMICS_WORLD_H
+#define BT_DYNAMICS_WORLD_H
+
+#include "BulletCollision/CollisionDispatch/btCollisionWorld.h"
+#include "BulletDynamics/ConstraintSolver/btContactSolverInfo.h"
+
+class btTypedConstraint;
+class btActionInterface;
+class btConstraintSolver;
+class btDynamicsWorld;
+
+/// Type for the callback for each tick
+typedef void (*btInternalTickCallback)(btDynamicsWorld* world, btScalar timeStep);
+
+enum btDynamicsWorldType
+{
+	BT_SIMPLE_DYNAMICS_WORLD = 1,
+	BT_DISCRETE_DYNAMICS_WORLD = 2,
+	BT_CONTINUOUS_DYNAMICS_WORLD = 3,
+	BT_SOFT_RIGID_DYNAMICS_WORLD = 4,
+	BT_GPU_DYNAMICS_WORLD = 5,
+	BT_SOFT_MULTIBODY_DYNAMICS_WORLD = 6,
+    BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD = 7
+};
+
+///The btDynamicsWorld is the interface class for several dynamics implementation, basic, discrete, parallel, and continuous etc.
+class btDynamicsWorld : public btCollisionWorld
+{
+protected:
+	btInternalTickCallback m_internalTickCallback;
+	btInternalTickCallback m_internalPreTickCallback;
+	void* m_worldUserInfo;
+
+	btContactSolverInfo m_solverInfo;
+
+public:
+	btDynamicsWorld(btDispatcher* dispatcher, btBroadphaseInterface* broadphase, btCollisionConfiguration* collisionConfiguration)
+		: btCollisionWorld(dispatcher, broadphase, collisionConfiguration), m_internalTickCallback(0), m_internalPreTickCallback(0), m_worldUserInfo(0)
+	{
+	}
+
+	virtual ~btDynamicsWorld()
+	{
+	}
+
+	///stepSimulation proceeds the simulation over 'timeStep', units in preferably in seconds.
+	///By default, Bullet will subdivide the timestep in constant substeps of each 'fixedTimeStep'.
+	///in order to keep the simulation real-time, the maximum number of substeps can be clamped to 'maxSubSteps'.
+	///You can disable subdividing the timestep/substepping by passing maxSubSteps=0 as second argument to stepSimulation, but in that case you have to keep the timeStep constant.
+	virtual int stepSimulation(btScalar timeStep, int maxSubSteps = 1, btScalar fixedTimeStep = btScalar(1.) / btScalar(60.)) = 0;
+
+	virtual void debugDrawWorld() = 0;
+
+	virtual void addConstraint(btTypedConstraint* constraint, bool disableCollisionsBetweenLinkedBodies = false)
+	{
+		(void)constraint;
+		(void)disableCollisionsBetweenLinkedBodies;
+	}
+
+	virtual void removeConstraint(btTypedConstraint* constraint) { (void)constraint; }
+
+	virtual void addAction(btActionInterface* action) = 0;
+
+	virtual void removeAction(btActionInterface* action) = 0;
+
+	//once a rigidbody is added to the dynamics world, it will get this gravity assigned
+	//existing rigidbodies in the world get gravity assigned too, during this method
+	virtual void setGravity(const btVector3& gravity) = 0;
+	virtual btVector3 getGravity() const = 0;
+
+	virtual void synchronizeMotionStates() = 0;
+
+	virtual void addRigidBody(btRigidBody* body) = 0;
+
+	virtual void addRigidBody(btRigidBody* body, int group, int mask) = 0;
+
+	virtual void removeRigidBody(btRigidBody* body) = 0;
+
+	virtual void setConstraintSolver(btConstraintSolver* solver) = 0;
+
+	virtual btConstraintSolver* getConstraintSolver() = 0;
+
+	virtual int getNumConstraints() const { return 0; }
+
+	virtual btTypedConstraint* getConstraint(int index)
+	{
+		(void)index;
+		return 0;
+	}
+
+	virtual const btTypedConstraint* getConstraint(int index) const
+	{
+		(void)index;
+		return 0;
+	}
+
+	virtual btDynamicsWorldType getWorldType() const = 0;
+
+	virtual void clearForces() = 0;
+
+	/// Set the callback for when an internal tick (simulation substep) happens, optional user info
+	void setInternalTickCallback(btInternalTickCallback cb, void* worldUserInfo = 0, bool isPreTick = false)
+	{
+		if (isPreTick)
+		{
+			m_internalPreTickCallback = cb;
+		}
+		else
+		{
+			m_internalTickCallback = cb;
+		}
+		m_worldUserInfo = worldUserInfo;
+	}
+
+	void setWorldUserInfo(void* worldUserInfo)
+	{
+		m_worldUserInfo = worldUserInfo;
+	}
+
+	void* getWorldUserInfo() const
+	{
+		return m_worldUserInfo;
+	}
+
+	btContactSolverInfo& getSolverInfo()
+	{
+		return m_solverInfo;
+	}
+
+	const btContactSolverInfo& getSolverInfo() const
+	{
+		return m_solverInfo;
+	}
+
+	///obsolete, use addAction instead.
+	virtual void addVehicle(btActionInterface* vehicle) { (void)vehicle; }
+	///obsolete, use removeAction instead
+	virtual void removeVehicle(btActionInterface* vehicle) { (void)vehicle; }
+	///obsolete, use addAction instead.
+	virtual void addCharacter(btActionInterface* character) { (void)character; }
+	///obsolete, use removeAction instead
+	virtual void removeCharacter(btActionInterface* character) { (void)character; }
+};
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct btDynamicsWorldDoubleData
+{
+	btContactSolverInfoDoubleData m_solverInfo;
+	btVector3DoubleData m_gravity;
+};
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct btDynamicsWorldFloatData
+{
+	btContactSolverInfoFloatData m_solverInfo;
+	btVector3FloatData m_gravity;
+};
+
+#endif  //BT_DYNAMICS_WORLD_H
diff --git a/engine/inc/bullet/BulletDynamics/Dynamics/btRigidBody.h b/engine/inc/bullet/BulletDynamics/Dynamics/btRigidBody.h
new file mode 100644
index 00000000..7442dd1e
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/Dynamics/btRigidBody.h
@@ -0,0 +1,687 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_RIGIDBODY_H
+#define BT_RIGIDBODY_H
+
+#include "LinearMath/btAlignedObjectArray.h"
+#include "LinearMath/btTransform.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+#include "BulletCollision/CollisionDispatch/btCollisionObject.h"
+
+class btCollisionShape;
+class btMotionState;
+class btTypedConstraint;
+
+extern btScalar gDeactivationTime;
+extern bool gDisableDeactivation;
+
+#ifdef BT_USE_DOUBLE_PRECISION
+#define btRigidBodyData btRigidBodyDoubleData
+#define btRigidBodyDataName "btRigidBodyDoubleData"
+#else
+#define btRigidBodyData btRigidBodyFloatData
+#define btRigidBodyDataName "btRigidBodyFloatData"
+#endif  //BT_USE_DOUBLE_PRECISION
+
+enum btRigidBodyFlags
+{
+	BT_DISABLE_WORLD_GRAVITY = 1,
+	///BT_ENABLE_GYROPSCOPIC_FORCE flags is enabled by default in Bullet 2.83 and onwards.
+	///and it BT_ENABLE_GYROPSCOPIC_FORCE becomes equivalent to BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY
+	///See Demos/GyroscopicDemo and computeGyroscopicImpulseImplicit
+	BT_ENABLE_GYROSCOPIC_FORCE_EXPLICIT = 2,
+	BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_WORLD = 4,
+	BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY = 8,
+	BT_ENABLE_GYROPSCOPIC_FORCE = BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY,
+};
+
+///The btRigidBody is the main class for rigid body objects. It is derived from btCollisionObject, so it keeps a pointer to a btCollisionShape.
+///It is recommended for performance and memory use to share btCollisionShape objects whenever possible.
+///There are 3 types of rigid bodies:
+///- A) Dynamic rigid bodies, with positive mass. Motion is controlled by rigid body dynamics.
+///- B) Fixed objects with zero mass. They are not moving (basically collision objects)
+///- C) Kinematic objects, which are objects without mass, but the user can move them. There is one-way interaction, and Bullet calculates a velocity based on the timestep and previous and current world transform.
+///Bullet automatically deactivates dynamic rigid bodies, when the velocity is below a threshold for a given time.
+///Deactivated (sleeping) rigid bodies don't take any processing time, except a minor broadphase collision detection impact (to allow active objects to activate/wake up sleeping objects)
+class btRigidBody : public btCollisionObject
+{
+	btMatrix3x3 m_invInertiaTensorWorld;
+	btVector3 m_linearVelocity;
+	btVector3 m_angularVelocity;
+	btScalar m_inverseMass;
+	btVector3 m_linearFactor;
+
+	btVector3 m_gravity;
+	btVector3 m_gravity_acceleration;
+	btVector3 m_invInertiaLocal;
+	btVector3 m_totalForce;
+	btVector3 m_totalTorque;
+
+	btScalar m_linearDamping;
+	btScalar m_angularDamping;
+
+	bool m_additionalDamping;
+	btScalar m_additionalDampingFactor;
+	btScalar m_additionalLinearDampingThresholdSqr;
+	btScalar m_additionalAngularDampingThresholdSqr;
+	btScalar m_additionalAngularDampingFactor;
+
+	btScalar m_linearSleepingThreshold;
+	btScalar m_angularSleepingThreshold;
+
+	//m_optionalMotionState allows to automatic synchronize the world transform for active objects
+	btMotionState* m_optionalMotionState;
+
+	//keep track of typed constraints referencing this rigid body, to disable collision between linked bodies
+	btAlignedObjectArray<btTypedConstraint*> m_constraintRefs;
+
+	int m_rigidbodyFlags;
+
+	int m_debugBodyId;
+
+protected:
+	ATTRIBUTE_ALIGNED16(btVector3 m_deltaLinearVelocity);
+	btVector3 m_deltaAngularVelocity;
+	btVector3 m_angularFactor;
+	btVector3 m_invMass;
+	btVector3 m_pushVelocity;
+	btVector3 m_turnVelocity;
+
+public:
+	///The btRigidBodyConstructionInfo structure provides information to create a rigid body. Setting mass to zero creates a fixed (non-dynamic) rigid body.
+	///For dynamic objects, you can use the collision shape to approximate the local inertia tensor, otherwise use the zero vector (default argument)
+	///You can use the motion state to synchronize the world transform between physics and graphics objects.
+	///And if the motion state is provided, the rigid body will initialize its initial world transform from the motion state,
+	///m_startWorldTransform is only used when you don't provide a motion state.
+	struct btRigidBodyConstructionInfo
+	{
+		btScalar m_mass;
+
+		///When a motionState is provided, the rigid body will initialize its world transform from the motion state
+		///In this case, m_startWorldTransform is ignored.
+		btMotionState* m_motionState;
+		btTransform m_startWorldTransform;
+
+		btCollisionShape* m_collisionShape;
+		btVector3 m_localInertia;
+		btScalar m_linearDamping;
+		btScalar m_angularDamping;
+
+		///best simulation results when friction is non-zero
+		btScalar m_friction;
+		///the m_rollingFriction prevents rounded shapes, such as spheres, cylinders and capsules from rolling forever.
+		///See Bullet/Demos/RollingFrictionDemo for usage
+		btScalar m_rollingFriction;
+		btScalar m_spinningFriction;  //torsional friction around contact normal
+
+		///best simulation results using zero restitution.
+		btScalar m_restitution;
+
+		btScalar m_linearSleepingThreshold;
+		btScalar m_angularSleepingThreshold;
+
+		//Additional damping can help avoiding lowpass jitter motion, help stability for ragdolls etc.
+		//Such damping is undesirable, so once the overall simulation quality of the rigid body dynamics system has improved, this should become obsolete
+		bool m_additionalDamping;
+		btScalar m_additionalDampingFactor;
+		btScalar m_additionalLinearDampingThresholdSqr;
+		btScalar m_additionalAngularDampingThresholdSqr;
+		btScalar m_additionalAngularDampingFactor;
+
+		btRigidBodyConstructionInfo(btScalar mass, btMotionState* motionState, btCollisionShape* collisionShape, const btVector3& localInertia = btVector3(0, 0, 0)) : m_mass(mass),
+																																									   m_motionState(motionState),
+																																									   m_collisionShape(collisionShape),
+																																									   m_localInertia(localInertia),
+																																									   m_linearDamping(btScalar(0.)),
+																																									   m_angularDamping(btScalar(0.)),
+																																									   m_friction(btScalar(0.5)),
+																																									   m_rollingFriction(btScalar(0)),
+																																									   m_spinningFriction(btScalar(0)),
+																																									   m_restitution(btScalar(0.)),
+																																									   m_linearSleepingThreshold(btScalar(0.8)),
+																																									   m_angularSleepingThreshold(btScalar(1.f)),
+																																									   m_additionalDamping(false),
+																																									   m_additionalDampingFactor(btScalar(0.005)),
+																																									   m_additionalLinearDampingThresholdSqr(btScalar(0.01)),
+																																									   m_additionalAngularDampingThresholdSqr(btScalar(0.01)),
+																																									   m_additionalAngularDampingFactor(btScalar(0.01))
+		{
+			m_startWorldTransform.setIdentity();
+		}
+	};
+
+	///btRigidBody constructor using construction info
+	btRigidBody(const btRigidBodyConstructionInfo& constructionInfo);
+
+	///btRigidBody constructor for backwards compatibility.
+	///To specify friction (etc) during rigid body construction, please use the other constructor (using btRigidBodyConstructionInfo)
+	btRigidBody(btScalar mass, btMotionState* motionState, btCollisionShape* collisionShape, const btVector3& localInertia = btVector3(0, 0, 0));
+
+	virtual ~btRigidBody()
+	{
+		//No constraints should point to this rigidbody
+		//Remove constraints from the dynamics world before you delete the related rigidbodies.
+		btAssert(m_constraintRefs.size() == 0);
+	}
+
+protected:
+	///setupRigidBody is only used internally by the constructor
+	void setupRigidBody(const btRigidBodyConstructionInfo& constructionInfo);
+
+public:
+	void proceedToTransform(const btTransform& newTrans);
+
+	///to keep collision detection and dynamics separate we don't store a rigidbody pointer
+	///but a rigidbody is derived from btCollisionObject, so we can safely perform an upcast
+	static const btRigidBody* upcast(const btCollisionObject* colObj)
+	{
+		if (colObj->getInternalType() & btCollisionObject::CO_RIGID_BODY)
+			return (const btRigidBody*)colObj;
+		return 0;
+	}
+	static btRigidBody* upcast(btCollisionObject* colObj)
+	{
+		if (colObj->getInternalType() & btCollisionObject::CO_RIGID_BODY)
+			return (btRigidBody*)colObj;
+		return 0;
+	}
+
+	/// continuous collision detection needs prediction
+	void predictIntegratedTransform(btScalar step, btTransform& predictedTransform);
+
+	void saveKinematicState(btScalar step);
+
+	void applyGravity();
+    
+    void clearGravity();
+
+	void setGravity(const btVector3& acceleration);
+
+	const btVector3& getGravity() const
+	{
+		return m_gravity_acceleration;
+	}
+
+	void setDamping(btScalar lin_damping, btScalar ang_damping);
+
+	btScalar getLinearDamping() const
+	{
+		return m_linearDamping;
+	}
+
+	btScalar getAngularDamping() const
+	{
+		return m_angularDamping;
+	}
+
+	btScalar getLinearSleepingThreshold() const
+	{
+		return m_linearSleepingThreshold;
+	}
+
+	btScalar getAngularSleepingThreshold() const
+	{
+		return m_angularSleepingThreshold;
+	}
+
+	void applyDamping(btScalar timeStep);
+
+	SIMD_FORCE_INLINE const btCollisionShape* getCollisionShape() const
+	{
+		return m_collisionShape;
+	}
+
+	SIMD_FORCE_INLINE btCollisionShape* getCollisionShape()
+	{
+		return m_collisionShape;
+	}
+
+	void setMassProps(btScalar mass, const btVector3& inertia);
+
+	const btVector3& getLinearFactor() const
+	{
+		return m_linearFactor;
+	}
+	void setLinearFactor(const btVector3& linearFactor)
+	{
+		m_linearFactor = linearFactor;
+		m_invMass = m_linearFactor * m_inverseMass;
+	}
+	btScalar getInvMass() const { return m_inverseMass; }
+	btScalar getMass() const { return m_inverseMass == btScalar(0.) ? btScalar(0.) : btScalar(1.0) / m_inverseMass; }
+	const btMatrix3x3& getInvInertiaTensorWorld() const
+	{
+		return m_invInertiaTensorWorld;
+	}
+
+	void integrateVelocities(btScalar step);
+
+	void setCenterOfMassTransform(const btTransform& xform);
+
+	void applyCentralForce(const btVector3& force)
+	{
+		m_totalForce += force * m_linearFactor;
+	}
+
+	const btVector3& getTotalForce() const
+	{
+		return m_totalForce;
+	};
+
+	const btVector3& getTotalTorque() const
+	{
+		return m_totalTorque;
+	};
+
+	const btVector3& getInvInertiaDiagLocal() const
+	{
+		return m_invInertiaLocal;
+	};
+
+	void setInvInertiaDiagLocal(const btVector3& diagInvInertia)
+	{
+		m_invInertiaLocal = diagInvInertia;
+	}
+
+	void setSleepingThresholds(btScalar linear, btScalar angular)
+	{
+		m_linearSleepingThreshold = linear;
+		m_angularSleepingThreshold = angular;
+	}
+
+	void applyTorque(const btVector3& torque)
+	{
+		m_totalTorque += torque * m_angularFactor;
+		#if defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0
+		clampVelocity(m_totalTorque);
+		#endif
+	}
+
+	void applyForce(const btVector3& force, const btVector3& rel_pos)
+	{
+		applyCentralForce(force);
+		applyTorque(rel_pos.cross(force * m_linearFactor));
+	}
+
+	void applyCentralImpulse(const btVector3& impulse)
+	{
+		m_linearVelocity += impulse * m_linearFactor * m_inverseMass;
+		#if defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0
+		clampVelocity(m_linearVelocity);
+		#endif
+	}
+
+	void applyTorqueImpulse(const btVector3& torque)
+	{
+		m_angularVelocity += m_invInertiaTensorWorld * torque * m_angularFactor;
+		#if defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0
+		clampVelocity(m_angularVelocity);
+		#endif
+	}
+
+	void applyImpulse(const btVector3& impulse, const btVector3& rel_pos)
+	{
+		if (m_inverseMass != btScalar(0.))
+		{
+			applyCentralImpulse(impulse);
+			if (m_angularFactor)
+			{
+				applyTorqueImpulse(rel_pos.cross(impulse * m_linearFactor));
+			}
+		}
+	}
+    
+    void applyPushImpulse(const btVector3& impulse, const btVector3& rel_pos)
+    {
+        if (m_inverseMass != btScalar(0.))
+        {
+            applyCentralPushImpulse(impulse);
+            if (m_angularFactor)
+            {
+                applyTorqueTurnImpulse(rel_pos.cross(impulse * m_linearFactor));
+            }
+        }
+    }
+    
+    btVector3 getPushVelocity() const
+    {
+        return m_pushVelocity;
+    }
+    
+    btVector3 getTurnVelocity() const
+    {
+        return m_turnVelocity;
+    }
+    
+    void setPushVelocity(const btVector3& v)
+    {
+        m_pushVelocity = v;
+    }
+
+    #if defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0
+    void clampVelocity(btVector3& v) const {
+        v.setX(
+            fmax(-BT_CLAMP_VELOCITY_TO,
+                 fmin(BT_CLAMP_VELOCITY_TO, v.getX()))
+        );
+        v.setY(
+            fmax(-BT_CLAMP_VELOCITY_TO,
+                 fmin(BT_CLAMP_VELOCITY_TO, v.getY()))
+        );
+        v.setZ(
+            fmax(-BT_CLAMP_VELOCITY_TO,
+                 fmin(BT_CLAMP_VELOCITY_TO, v.getZ()))
+        );
+    }
+    #endif
+
+    void setTurnVelocity(const btVector3& v)
+    {
+        m_turnVelocity = v;
+        #if defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0
+        clampVelocity(m_turnVelocity);
+        #endif
+    }
+    
+    void applyCentralPushImpulse(const btVector3& impulse)
+    {
+        m_pushVelocity += impulse * m_linearFactor * m_inverseMass;
+        #if defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0
+        clampVelocity(m_pushVelocity);
+        #endif
+    }
+    
+    void applyTorqueTurnImpulse(const btVector3& torque)
+    {
+        m_turnVelocity += m_invInertiaTensorWorld * torque * m_angularFactor;
+        #if defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0
+        clampVelocity(m_turnVelocity);
+        #endif
+    }
+
+	void clearForces()
+	{
+		m_totalForce.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0));
+		m_totalTorque.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0));
+	}
+
+	void updateInertiaTensor();
+
+	const btVector3& getCenterOfMassPosition() const
+	{
+		return m_worldTransform.getOrigin();
+	}
+	btQuaternion getOrientation() const;
+
+	const btTransform& getCenterOfMassTransform() const
+	{
+		return m_worldTransform;
+	}
+	const btVector3& getLinearVelocity() const
+	{
+		return m_linearVelocity;
+	}
+	const btVector3& getAngularVelocity() const
+	{
+		return m_angularVelocity;
+	}
+
+	inline void setLinearVelocity(const btVector3& lin_vel)
+	{
+		m_updateRevision++;
+		m_linearVelocity = lin_vel;
+		#if defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0
+		clampVelocity(m_linearVelocity);
+		#endif
+	}
+
+	inline void setAngularVelocity(const btVector3& ang_vel)
+	{
+		m_updateRevision++;
+		m_angularVelocity = ang_vel;
+		#if defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0
+		clampVelocity(m_angularVelocity);
+		#endif
+	}
+
+	btVector3 getVelocityInLocalPoint(const btVector3& rel_pos) const
+	{
+		//we also calculate lin/ang velocity for kinematic objects
+		return m_linearVelocity + m_angularVelocity.cross(rel_pos);
+
+		//for kinematic objects, we could also use use:
+		//		return 	(m_worldTransform(rel_pos) - m_interpolationWorldTransform(rel_pos)) / m_kinematicTimeStep;
+	}
+    
+    btVector3 getPushVelocityInLocalPoint(const btVector3& rel_pos) const
+    {
+        //we also calculate lin/ang velocity for kinematic objects
+        return m_pushVelocity + m_turnVelocity.cross(rel_pos);
+    }
+
+	void translate(const btVector3& v)
+	{
+		m_worldTransform.getOrigin() += v;
+	}
+
+	void getAabb(btVector3& aabbMin, btVector3& aabbMax) const;
+
+	SIMD_FORCE_INLINE btScalar computeImpulseDenominator(const btVector3& pos, const btVector3& normal) const
+	{
+		btVector3 r0 = pos - getCenterOfMassPosition();
+
+		btVector3 c0 = (r0).cross(normal);
+
+		btVector3 vec = (c0 * getInvInertiaTensorWorld()).cross(r0);
+
+		return m_inverseMass + normal.dot(vec);
+	}
+
+	SIMD_FORCE_INLINE btScalar computeAngularImpulseDenominator(const btVector3& axis) const
+	{
+		btVector3 vec = axis * getInvInertiaTensorWorld();
+		return axis.dot(vec);
+	}
+
+	SIMD_FORCE_INLINE void updateDeactivation(btScalar timeStep)
+	{
+		if ((getActivationState() == ISLAND_SLEEPING) || (getActivationState() == DISABLE_DEACTIVATION))
+			return;
+
+		if ((getLinearVelocity().length2() < m_linearSleepingThreshold * m_linearSleepingThreshold) &&
+			(getAngularVelocity().length2() < m_angularSleepingThreshold * m_angularSleepingThreshold))
+		{
+			m_deactivationTime += timeStep;
+		}
+		else
+		{
+			m_deactivationTime = btScalar(0.);
+			setActivationState(0);
+		}
+	}
+
+	SIMD_FORCE_INLINE bool wantsSleeping()
+	{
+		if (getActivationState() == DISABLE_DEACTIVATION)
+			return false;
+
+		//disable deactivation
+		if (gDisableDeactivation || (gDeactivationTime == btScalar(0.)))
+			return false;
+
+		if ((getActivationState() == ISLAND_SLEEPING) || (getActivationState() == WANTS_DEACTIVATION))
+			return true;
+
+		if (m_deactivationTime > gDeactivationTime)
+		{
+			return true;
+		}
+		return false;
+	}
+
+	const btBroadphaseProxy* getBroadphaseProxy() const
+	{
+		return m_broadphaseHandle;
+	}
+	btBroadphaseProxy* getBroadphaseProxy()
+	{
+		return m_broadphaseHandle;
+	}
+	void setNewBroadphaseProxy(btBroadphaseProxy* broadphaseProxy)
+	{
+		m_broadphaseHandle = broadphaseProxy;
+	}
+
+	//btMotionState allows to automatic synchronize the world transform for active objects
+	btMotionState* getMotionState()
+	{
+		return m_optionalMotionState;
+	}
+	const btMotionState* getMotionState() const
+	{
+		return m_optionalMotionState;
+	}
+	void setMotionState(btMotionState* motionState)
+	{
+		m_optionalMotionState = motionState;
+		if (m_optionalMotionState)
+			motionState->getWorldTransform(m_worldTransform);
+	}
+
+	//for experimental overriding of friction/contact solver func
+	int m_contactSolverType;
+	int m_frictionSolverType;
+
+	void setAngularFactor(const btVector3& angFac)
+	{
+		m_updateRevision++;
+		m_angularFactor = angFac;
+	}
+
+	void setAngularFactor(btScalar angFac)
+	{
+		m_updateRevision++;
+		m_angularFactor.setValue(angFac, angFac, angFac);
+	}
+	const btVector3& getAngularFactor() const
+	{
+		return m_angularFactor;
+	}
+
+	//is this rigidbody added to a btCollisionWorld/btDynamicsWorld/btBroadphase?
+	bool isInWorld() const
+	{
+		return (getBroadphaseProxy() != 0);
+	}
+
+	void addConstraintRef(btTypedConstraint* c);
+	void removeConstraintRef(btTypedConstraint* c);
+
+	btTypedConstraint* getConstraintRef(int index)
+	{
+		return m_constraintRefs[index];
+	}
+
+	int getNumConstraintRefs() const
+	{
+		return m_constraintRefs.size();
+	}
+
+	void setFlags(int flags)
+	{
+		m_rigidbodyFlags = flags;
+	}
+
+	int getFlags() const
+	{
+		return m_rigidbodyFlags;
+	}
+
+	///perform implicit force computation in world space
+	btVector3 computeGyroscopicImpulseImplicit_World(btScalar dt) const;
+
+	///perform implicit force computation in body space (inertial frame)
+	btVector3 computeGyroscopicImpulseImplicit_Body(btScalar step) const;
+
+	///explicit version is best avoided, it gains energy
+	btVector3 computeGyroscopicForceExplicit(btScalar maxGyroscopicForce) const;
+	btVector3 getLocalInertia() const;
+
+	///////////////////////////////////////////////
+
+	virtual int calculateSerializeBufferSize() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	virtual const char* serialize(void* dataBuffer, class btSerializer* serializer) const;
+
+	virtual void serializeSingleObject(class btSerializer* serializer) const;
+};
+
+//@todo add m_optionalMotionState and m_constraintRefs to btRigidBodyData
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct btRigidBodyFloatData
+{
+	btCollisionObjectFloatData m_collisionObjectData;
+	btMatrix3x3FloatData m_invInertiaTensorWorld;
+	btVector3FloatData m_linearVelocity;
+	btVector3FloatData m_angularVelocity;
+	btVector3FloatData m_angularFactor;
+	btVector3FloatData m_linearFactor;
+	btVector3FloatData m_gravity;
+	btVector3FloatData m_gravity_acceleration;
+	btVector3FloatData m_invInertiaLocal;
+	btVector3FloatData m_totalForce;
+	btVector3FloatData m_totalTorque;
+	float m_inverseMass;
+	float m_linearDamping;
+	float m_angularDamping;
+	float m_additionalDampingFactor;
+	float m_additionalLinearDampingThresholdSqr;
+	float m_additionalAngularDampingThresholdSqr;
+	float m_additionalAngularDampingFactor;
+	float m_linearSleepingThreshold;
+	float m_angularSleepingThreshold;
+	int m_additionalDamping;
+};
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct btRigidBodyDoubleData
+{
+	btCollisionObjectDoubleData m_collisionObjectData;
+	btMatrix3x3DoubleData m_invInertiaTensorWorld;
+	btVector3DoubleData m_linearVelocity;
+	btVector3DoubleData m_angularVelocity;
+	btVector3DoubleData m_angularFactor;
+	btVector3DoubleData m_linearFactor;
+	btVector3DoubleData m_gravity;
+	btVector3DoubleData m_gravity_acceleration;
+	btVector3DoubleData m_invInertiaLocal;
+	btVector3DoubleData m_totalForce;
+	btVector3DoubleData m_totalTorque;
+	double m_inverseMass;
+	double m_linearDamping;
+	double m_angularDamping;
+	double m_additionalDampingFactor;
+	double m_additionalLinearDampingThresholdSqr;
+	double m_additionalAngularDampingThresholdSqr;
+	double m_additionalAngularDampingFactor;
+	double m_linearSleepingThreshold;
+	double m_angularSleepingThreshold;
+	int m_additionalDamping;
+	char m_padding[4];
+};
+
+#endif  //BT_RIGIDBODY_H
diff --git a/engine/inc/bullet/BulletDynamics/Dynamics/btSimpleDynamicsWorld.h b/engine/inc/bullet/BulletDynamics/Dynamics/btSimpleDynamicsWorld.h
new file mode 100644
index 00000000..12be231c
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/Dynamics/btSimpleDynamicsWorld.h
@@ -0,0 +1,84 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SIMPLE_DYNAMICS_WORLD_H
+#define BT_SIMPLE_DYNAMICS_WORLD_H
+
+#include "btDynamicsWorld.h"
+
+class btDispatcher;
+class btOverlappingPairCache;
+class btConstraintSolver;
+
+///The btSimpleDynamicsWorld serves as unit-test and to verify more complicated and optimized dynamics worlds.
+///Please use btDiscreteDynamicsWorld instead
+class btSimpleDynamicsWorld : public btDynamicsWorld
+{
+protected:
+	btConstraintSolver* m_constraintSolver;
+
+	bool m_ownsConstraintSolver;
+
+	void predictUnconstraintMotion(btScalar timeStep);
+
+	void integrateTransforms(btScalar timeStep);
+
+	btVector3 m_gravity;
+
+public:
+	///this btSimpleDynamicsWorld constructor creates dispatcher, broadphase pairCache and constraintSolver
+	btSimpleDynamicsWorld(btDispatcher* dispatcher, btBroadphaseInterface* pairCache, btConstraintSolver* constraintSolver, btCollisionConfiguration* collisionConfiguration);
+
+	virtual ~btSimpleDynamicsWorld();
+
+	///maxSubSteps/fixedTimeStep for interpolation is currently ignored for btSimpleDynamicsWorld, use btDiscreteDynamicsWorld instead
+	virtual int stepSimulation(btScalar timeStep, int maxSubSteps = 1, btScalar fixedTimeStep = btScalar(1.) / btScalar(60.));
+
+	virtual void setGravity(const btVector3& gravity);
+
+	virtual btVector3 getGravity() const;
+
+	virtual void addRigidBody(btRigidBody* body);
+
+	virtual void addRigidBody(btRigidBody* body, int group, int mask);
+
+	virtual void removeRigidBody(btRigidBody* body);
+
+	virtual void debugDrawWorld();
+
+	virtual void addAction(btActionInterface* action);
+
+	virtual void removeAction(btActionInterface* action);
+
+	///removeCollisionObject will first check if it is a rigid body, if so call removeRigidBody otherwise call btCollisionWorld::removeCollisionObject
+	virtual void removeCollisionObject(btCollisionObject* collisionObject);
+
+	virtual void updateAabbs();
+
+	virtual void synchronizeMotionStates();
+
+	virtual void setConstraintSolver(btConstraintSolver* solver);
+
+	virtual btConstraintSolver* getConstraintSolver();
+
+	virtual btDynamicsWorldType getWorldType() const
+	{
+		return BT_SIMPLE_DYNAMICS_WORLD;
+	}
+
+	virtual void clearForces();
+};
+
+#endif  //BT_SIMPLE_DYNAMICS_WORLD_H
diff --git a/engine/inc/bullet/BulletDynamics/Dynamics/btSimulationIslandManagerMt.h b/engine/inc/bullet/BulletDynamics/Dynamics/btSimulationIslandManagerMt.h
new file mode 100644
index 00000000..ab73a899
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/Dynamics/btSimulationIslandManagerMt.h
@@ -0,0 +1,112 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SIMULATION_ISLAND_MANAGER_MT_H
+#define BT_SIMULATION_ISLAND_MANAGER_MT_H
+
+#include "BulletCollision/CollisionDispatch/btSimulationIslandManager.h"
+
+class btTypedConstraint;
+class btConstraintSolver;
+struct btContactSolverInfo;
+class btIDebugDraw;
+
+///
+/// SimulationIslandManagerMt -- Multithread capable version of SimulationIslandManager
+///                       Splits the world up into islands which can be solved in parallel.
+///                       In order to solve islands in parallel, an IslandDispatch function
+///                       must be provided which will dispatch calls to multiple threads.
+///                       The amount of parallelism that can be achieved depends on the number
+///                       of islands. If only a single island exists, then no parallelism is
+///                       possible.
+///
+class btSimulationIslandManagerMt : public btSimulationIslandManager
+{
+public:
+	struct Island
+	{
+		// a simulation island consisting of bodies, manifolds and constraints,
+		// to be passed into a constraint solver.
+		btAlignedObjectArray<btCollisionObject*> bodyArray;
+		btAlignedObjectArray<btPersistentManifold*> manifoldArray;
+		btAlignedObjectArray<btTypedConstraint*> constraintArray;
+		int id;  // island id
+		bool isSleeping;
+
+		void append(const Island& other);  // add bodies, manifolds, constraints to my own
+	};
+	struct SolverParams
+	{
+		btConstraintSolver* m_solverPool;
+		btConstraintSolver* m_solverMt;
+		btContactSolverInfo* m_solverInfo;
+		btIDebugDraw* m_debugDrawer;
+		btDispatcher* m_dispatcher;
+	};
+	static void solveIsland(btConstraintSolver* solver, Island& island, const SolverParams& solverParams);
+
+	typedef void (*IslandDispatchFunc)(btAlignedObjectArray<Island*>* islands, const SolverParams& solverParams);
+	static void serialIslandDispatch(btAlignedObjectArray<Island*>* islandsPtr, const SolverParams& solverParams);
+	static void parallelIslandDispatch(btAlignedObjectArray<Island*>* islandsPtr, const SolverParams& solverParams);
+
+protected:
+	btAlignedObjectArray<Island*> m_allocatedIslands;    // owner of all Islands
+	btAlignedObjectArray<Island*> m_activeIslands;       // islands actively in use
+	btAlignedObjectArray<Island*> m_freeIslands;         // islands ready to be reused
+	btAlignedObjectArray<Island*> m_lookupIslandFromId;  // big lookup table to map islandId to Island pointer
+	Island* m_batchIsland;
+	int m_minimumSolverBatchSize;
+	int m_batchIslandMinBodyCount;
+	IslandDispatchFunc m_islandDispatch;
+
+	Island* getIsland(int id);
+	virtual Island* allocateIsland(int id, int numBodies);
+	virtual void initIslandPools();
+	virtual void addBodiesToIslands(btCollisionWorld* collisionWorld);
+	virtual void addManifoldsToIslands(btDispatcher* dispatcher);
+	virtual void addConstraintsToIslands(btAlignedObjectArray<btTypedConstraint*>& constraints);
+	virtual void mergeIslands();
+
+public:
+	btSimulationIslandManagerMt();
+	virtual ~btSimulationIslandManagerMt();
+
+	virtual void buildAndProcessIslands(btDispatcher* dispatcher,
+										btCollisionWorld* collisionWorld,
+										btAlignedObjectArray<btTypedConstraint*>& constraints,
+										const SolverParams& solverParams);
+
+	virtual void buildIslands(btDispatcher* dispatcher, btCollisionWorld* colWorld);
+
+	int getMinimumSolverBatchSize() const
+	{
+		return m_minimumSolverBatchSize;
+	}
+	void setMinimumSolverBatchSize(int sz)
+	{
+		m_minimumSolverBatchSize = sz;
+	}
+	IslandDispatchFunc getIslandDispatchFunction() const
+	{
+		return m_islandDispatch;
+	}
+	// allow users to set their own dispatch function for multithreaded dispatch
+	void setIslandDispatchFunction(IslandDispatchFunc func)
+	{
+		m_islandDispatch = func;
+	}
+};
+
+#endif  //BT_SIMULATION_ISLAND_MANAGER_H
diff --git a/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBody.h b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBody.h
new file mode 100644
index 00000000..25112a68
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBody.h
@@ -0,0 +1,934 @@
+/*
+ * PURPOSE:
+ *   Class representing an articulated rigid body. Stores the body's
+ *   current state, allows forces and torques to be set, handles
+ *   timestepping and implements Featherstone's algorithm.
+ *   
+ * COPYRIGHT:
+ *   Copyright (C) Stephen Thompson, <stephen@solarflare.org.uk>, 2011-2013
+ *   Portions written By Erwin Coumans: connection to LCP solver, various multibody constraints, replacing Eigen math library by Bullet LinearMath and a dedicated 6x6 matrix inverse (solveImatrix)
+ *   Portions written By Jakub Stepien: support for multi-DOF constraints, introduction of spatial algebra and several other improvements
+
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ 
+ */
+
+#ifndef BT_MULTIBODY_H
+#define BT_MULTIBODY_H
+
+#include "LinearMath/btScalar.h"
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btQuaternion.h"
+#include "LinearMath/btMatrix3x3.h"
+#include "LinearMath/btAlignedObjectArray.h"
+
+///serialization data, don't change them if you are not familiar with the details of the serialization mechanisms
+#ifdef BT_USE_DOUBLE_PRECISION
+#define btMultiBodyData btMultiBodyDoubleData
+#define btMultiBodyDataName "btMultiBodyDoubleData"
+#define btMultiBodyLinkData btMultiBodyLinkDoubleData
+#define btMultiBodyLinkDataName "btMultiBodyLinkDoubleData"
+#else
+#define btMultiBodyData btMultiBodyFloatData
+#define btMultiBodyDataName "btMultiBodyFloatData"
+#define btMultiBodyLinkData btMultiBodyLinkFloatData
+#define btMultiBodyLinkDataName "btMultiBodyLinkFloatData"
+#endif  //BT_USE_DOUBLE_PRECISION
+
+#include "btMultiBodyLink.h"
+class btMultiBodyLinkCollider;
+
+ATTRIBUTE_ALIGNED16(class)
+btMultiBody
+{
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	//
+	// initialization
+	//
+
+	btMultiBody(int n_links,               // NOT including the base
+				btScalar mass,             // mass of base
+				const btVector3 &inertia,  // inertia of base, in base frame; assumed diagonal
+				bool fixedBase,            // whether the base is fixed (true) or can move (false)
+				bool canSleep, bool deprecatedMultiDof = true);
+
+	virtual ~btMultiBody();
+
+	//note: fixed link collision with parent is always disabled
+	void setupFixed(int i, //linkIndex
+					btScalar mass,
+					const btVector3 &inertia,
+					int parent,
+					const btQuaternion &rotParentToThis,
+					const btVector3 &parentComToThisPivotOffset,
+					const btVector3 &thisPivotToThisComOffset, bool deprecatedDisableParentCollision = true);
+
+	void setupPrismatic(int i,
+						btScalar mass,
+						const btVector3 &inertia,
+						int parent,
+						const btQuaternion &rotParentToThis,
+						const btVector3 &jointAxis,
+						const btVector3 &parentComToThisPivotOffset,
+						const btVector3 &thisPivotToThisComOffset,
+						bool disableParentCollision);
+
+	void setupRevolute(int i,  // 0 to num_links-1
+					   btScalar mass,
+					   const btVector3 &inertia,
+					   int parentIndex,
+					   const btQuaternion &rotParentToThis,          // rotate points in parent frame to this frame, when q = 0
+					   const btVector3 &jointAxis,                   // in my frame
+					   const btVector3 &parentComToThisPivotOffset,  // vector from parent COM to joint axis, in PARENT frame
+					   const btVector3 &thisPivotToThisComOffset,    // vector from joint axis to my COM, in MY frame
+					   bool disableParentCollision = false);
+
+	void setupSpherical(int i,  // linkIndex, 0 to num_links-1
+						btScalar mass,
+						const btVector3 &inertia,
+						int parent,
+						const btQuaternion &rotParentToThis,          // rotate points in parent frame to this frame, when q = 0
+						const btVector3 &parentComToThisPivotOffset,  // vector from parent COM to joint axis, in PARENT frame
+						const btVector3 &thisPivotToThisComOffset,    // vector from joint axis to my COM, in MY frame
+						bool disableParentCollision = false);
+
+	void setupPlanar(int i,  // 0 to num_links-1
+					 btScalar mass,
+					 const btVector3 &inertia,
+					 int parent,
+					 const btQuaternion &rotParentToThis,  // rotate points in parent frame to this frame, when q = 0
+					 const btVector3 &rotationAxis,
+					 const btVector3 &parentComToThisComOffset,  // vector from parent COM to this COM, in PARENT frame
+					 bool disableParentCollision = false);
+
+	const btMultibodyLink &getLink(int index) const
+	{
+		return m_links[index];
+	}
+
+	btMultibodyLink &getLink(int index)
+	{
+		return m_links[index];
+	}
+
+	void setBaseCollider(btMultiBodyLinkCollider * collider)  //collider can be NULL to disable collision for the base
+	{
+		m_baseCollider = collider;
+	}
+	const btMultiBodyLinkCollider *getBaseCollider() const
+	{
+		return m_baseCollider;
+	}
+	btMultiBodyLinkCollider *getBaseCollider()
+	{
+		return m_baseCollider;
+	}
+
+	const btMultiBodyLinkCollider *getLinkCollider(int index) const
+	{
+		if (index >= 0 && index < getNumLinks())
+		{
+			return getLink(index).m_collider;
+		}
+		return 0;
+	}
+
+	btMultiBodyLinkCollider *getLinkCollider(int index)
+	{
+		if (index >= 0 && index < getNumLinks())
+		{
+			return getLink(index).m_collider;
+		}
+		return 0;
+	}
+
+	//
+	// get parent
+	// input: link num from 0 to num_links-1
+	// output: link num from 0 to num_links-1, OR -1 to mean the base.
+	//
+	int getParent(int link_num) const;
+
+	//
+	// get number of m_links, masses, moments of inertia
+	//
+
+	int getNumLinks() const { return m_links.size(); }
+	int getNumDofs() const { return m_dofCount; }
+	int getNumPosVars() const { return m_posVarCnt; }
+	btScalar getBaseMass() const { return m_baseMass; }
+	const btVector3 &getBaseInertia() const { return m_baseInertia; }
+	btScalar getLinkMass(int i) const;
+	const btVector3 &getLinkInertia(int i) const;
+
+	//
+	// change mass (incomplete: can only change base mass and inertia at present)
+	//
+
+	void setBaseMass(btScalar mass) { m_baseMass = mass; }
+	void setBaseInertia(const btVector3 &inertia) { m_baseInertia = inertia; }
+
+	//
+	// get/set pos/vel/rot/omega for the base link
+	//
+
+	const btVector3 &getBasePos() const 
+	{ 
+		return m_basePos; 
+	}  // in world frame
+	const btVector3 getBaseVel() const
+	{
+		return btVector3(m_realBuf[3], m_realBuf[4], m_realBuf[5]);
+	}  // in world frame
+	const btQuaternion &getWorldToBaseRot() const
+	{
+		return m_baseQuat;
+	}
+    
+    const btVector3 &getInterpolateBasePos() const
+    {
+        return m_basePos_interpolate;
+    }  // in world frame
+    const btQuaternion &getInterpolateWorldToBaseRot() const
+    {
+        return m_baseQuat_interpolate;
+    }
+    
+    // rotates world vectors into base frame
+	btVector3 getBaseOmega() const { return btVector3(m_realBuf[0], m_realBuf[1], m_realBuf[2]); }  // in world frame
+
+	void setBasePos(const btVector3 &pos)
+	{
+		m_basePos = pos;
+		if(!isBaseKinematic())
+			m_basePos_interpolate = pos;
+	}
+
+	void setInterpolateBasePos(const btVector3 &pos)
+	{
+		m_basePos_interpolate = pos;
+	}
+
+	void setBaseWorldTransform(const btTransform &tr)
+	{
+		setBasePos(tr.getOrigin());
+		setWorldToBaseRot(tr.getRotation().inverse());
+	}
+
+	btTransform getBaseWorldTransform() const
+	{
+		btTransform tr;
+		tr.setOrigin(getBasePos());
+		tr.setRotation(getWorldToBaseRot().inverse());
+		return tr;
+	}
+
+	void setInterpolateBaseWorldTransform(const btTransform &tr)
+	{
+		setInterpolateBasePos(tr.getOrigin());
+		setInterpolateWorldToBaseRot(tr.getRotation().inverse());
+	}
+
+	btTransform getInterpolateBaseWorldTransform() const
+	{
+		btTransform tr;
+		tr.setOrigin(getInterpolateBasePos());
+		tr.setRotation(getInterpolateWorldToBaseRot().inverse());
+		return tr;
+	}
+
+	void setBaseVel(const btVector3 &vel)
+	{
+		m_realBuf[3] = vel[0];
+		m_realBuf[4] = vel[1];
+		m_realBuf[5] = vel[2];
+	}
+
+	void setWorldToBaseRot(const btQuaternion &rot)
+	{
+		m_baseQuat = rot;  //m_baseQuat asumed to ba alias!?
+		if(!isBaseKinematic())
+			m_baseQuat_interpolate = rot;
+	}
+
+	void setInterpolateWorldToBaseRot(const btQuaternion &rot)
+	{
+		m_baseQuat_interpolate = rot;
+	}
+
+	void setBaseOmega(const btVector3 &omega)
+	{
+		m_realBuf[0] = omega[0];
+		m_realBuf[1] = omega[1];
+		m_realBuf[2] = omega[2];
+	}
+
+	void saveKinematicState(btScalar timeStep);
+
+	//
+	// get/set pos/vel for child m_links (i = 0 to num_links-1)
+	//
+
+	btScalar getJointPos(int i) const;
+	btScalar getJointVel(int i) const;
+
+	btScalar *getJointVelMultiDof(int i);
+	btScalar *getJointPosMultiDof(int i);
+
+	const btScalar *getJointVelMultiDof(int i) const;
+	const btScalar *getJointPosMultiDof(int i) const;
+
+	void setJointPos(int i, btScalar q);
+	void setJointVel(int i, btScalar qdot);
+	void setJointPosMultiDof(int i, const double *q);
+	void setJointVelMultiDof(int i, const double *qdot);
+	void setJointPosMultiDof(int i, const float *q);
+	void setJointVelMultiDof(int i, const float *qdot);
+
+	//
+	// direct access to velocities as a vector of 6 + num_links elements.
+	// (omega first, then v, then joint velocities.)
+	//
+	const btScalar *getVelocityVector() const
+	{
+		return &m_realBuf[0];
+	}
+    
+    const btScalar *getDeltaVelocityVector() const
+    {
+        return &m_deltaV[0];
+    }
+    
+    const btScalar *getSplitVelocityVector() const
+    {
+        return &m_splitV[0];
+    }
+	/*    btScalar * getVelocityVector() 
+	{ 
+		return &real_buf[0]; 
+	}
+  */
+
+	//
+	// get the frames of reference (positions and orientations) of the child m_links
+	// (i = 0 to num_links-1)
+	//
+
+	const btVector3 &getRVector(int i) const;              // vector from COM(parent(i)) to COM(i), in frame i's coords
+	const btQuaternion &getParentToLocalRot(int i) const;  // rotates vectors in frame parent(i) to vectors in frame i.
+    const btVector3 &getInterpolateRVector(int i) const;              // vector from COM(parent(i)) to COM(i), in frame i's coords
+    const btQuaternion &getInterpolateParentToLocalRot(int i) const;  // rotates vectors in frame parent(i) to vectors in frame i.
+
+	//
+	// transform vectors in local frame of link i to world frame (or vice versa)
+	//
+	btVector3 localPosToWorld(int i, const btVector3 &local_pos) const;
+	btVector3 localDirToWorld(int i, const btVector3 &local_dir) const;
+	btVector3 worldPosToLocal(int i, const btVector3 &world_pos) const;
+	btVector3 worldDirToLocal(int i, const btVector3 &world_dir) const;
+
+	//
+	// transform a frame in local coordinate to a frame in world coordinate
+	//
+	btMatrix3x3 localFrameToWorld(int i, const btMatrix3x3 &local_frame) const;
+
+
+	//
+	// set external forces and torques. Note all external forces/torques are given in the WORLD frame.
+	//
+
+	void clearForcesAndTorques();
+	void clearConstraintForces();
+
+	void clearVelocities();
+
+	void addBaseForce(const btVector3 &f)
+	{
+		m_baseForce += f;
+	}
+	void addBaseTorque(const btVector3 &t) { m_baseTorque += t; }
+	void addLinkForce(int i, const btVector3 &f);
+	void addLinkTorque(int i, const btVector3 &t);
+
+	void addBaseConstraintForce(const btVector3 &f)
+	{
+		m_baseConstraintForce += f;
+	}
+	void addBaseConstraintTorque(const btVector3 &t) { m_baseConstraintTorque += t; }
+	void addLinkConstraintForce(int i, const btVector3 &f);
+	void addLinkConstraintTorque(int i, const btVector3 &t);
+
+	void addJointTorque(int i, btScalar Q);
+	void addJointTorqueMultiDof(int i, int dof, btScalar Q);
+	void addJointTorqueMultiDof(int i, const btScalar *Q);
+
+	const btVector3 &getBaseForce() const { return m_baseForce; }
+	const btVector3 &getBaseTorque() const { return m_baseTorque; }
+	const btVector3 &getLinkForce(int i) const;
+	const btVector3 &getLinkTorque(int i) const;
+	btScalar getJointTorque(int i) const;
+	btScalar *getJointTorqueMultiDof(int i);
+
+	//
+	// dynamics routines.
+	//
+
+	// timestep the velocities (given the external forces/torques set using addBaseForce etc).
+	// also sets up caches for calcAccelerationDeltas.
+	//
+	// Note: the caller must provide three vectors which are used as
+	// temporary scratch space. The idea here is to reduce dynamic
+	// memory allocation: the same scratch vectors can be re-used
+	// again and again for different Multibodies, instead of each
+	// btMultiBody allocating (and then deallocating) their own
+	// individual scratch buffers. This gives a considerable speed
+	// improvement, at least on Windows (where dynamic memory
+	// allocation appears to be fairly slow).
+	//
+
+	void computeAccelerationsArticulatedBodyAlgorithmMultiDof(btScalar dt,
+															  btAlignedObjectArray<btScalar> & scratch_r,
+															  btAlignedObjectArray<btVector3> & scratch_v,
+															  btAlignedObjectArray<btMatrix3x3> & scratch_m,
+															  bool isConstraintPass,
+                                                              bool jointFeedbackInWorldSpace,
+                                                              bool jointFeedbackInJointFrame
+                                                              );
+
+	///stepVelocitiesMultiDof is deprecated, use computeAccelerationsArticulatedBodyAlgorithmMultiDof instead
+	//void stepVelocitiesMultiDof(btScalar dt,
+	//							btAlignedObjectArray<btScalar> & scratch_r,
+	//							btAlignedObjectArray<btVector3> & scratch_v,
+	//							btAlignedObjectArray<btMatrix3x3> & scratch_m,
+	//							bool isConstraintPass = false)
+	//{
+	//	computeAccelerationsArticulatedBodyAlgorithmMultiDof(dt, scratch_r, scratch_v, scratch_m, isConstraintPass, false, false);
+	//}
+
+	// calcAccelerationDeltasMultiDof
+	// input: force vector (in same format as jacobian, i.e.:
+	//                      3 torque values, 3 force values, num_links joint torque values)
+	// output: 3 omegadot values, 3 vdot values, num_links q_double_dot values
+	// (existing contents of output array are replaced)
+	// calcAccelerationDeltasMultiDof must have been called first.
+	void calcAccelerationDeltasMultiDof(const btScalar *force, btScalar *output,
+										btAlignedObjectArray<btScalar> &scratch_r,
+										btAlignedObjectArray<btVector3> &scratch_v) const;
+
+	void applyDeltaVeeMultiDof2(const btScalar *delta_vee, btScalar multiplier)
+	{
+		for (int dof = 0; dof < 6 + getNumDofs(); ++dof)
+		{
+			m_deltaV[dof] += delta_vee[dof] * multiplier;
+		}
+	}
+    void applyDeltaSplitVeeMultiDof(const btScalar *delta_vee, btScalar multiplier)
+    {
+        for (int dof = 0; dof < 6 + getNumDofs(); ++dof)
+        {
+            m_splitV[dof] += delta_vee[dof] * multiplier;
+        }
+    }
+    void addSplitV()
+    {
+        applyDeltaVeeMultiDof(&m_splitV[0], 1);
+    }
+    void substractSplitV()
+    {
+        applyDeltaVeeMultiDof(&m_splitV[0], -1);
+        
+        for (int dof = 0; dof < 6 + getNumDofs(); ++dof)
+        {
+            m_splitV[dof] = 0.f;
+        }
+    }
+	void processDeltaVeeMultiDof2()
+	{
+		applyDeltaVeeMultiDof(&m_deltaV[0], 1);
+
+		for (int dof = 0; dof < 6 + getNumDofs(); ++dof)
+		{
+			m_deltaV[dof] = 0.f;
+		}
+	}
+
+	void applyDeltaVeeMultiDof(const btScalar *delta_vee, btScalar multiplier)
+	{
+		//for (int dof = 0; dof < 6 + getNumDofs(); ++dof)
+		//	printf("%.4f ", delta_vee[dof]*multiplier);
+		//printf("\n");
+
+		//btScalar sum = 0;
+		//for (int dof = 0; dof < 6 + getNumDofs(); ++dof)
+		//{
+		//	sum += delta_vee[dof]*multiplier*delta_vee[dof]*multiplier;
+		//}
+		//btScalar l = btSqrt(sum);
+
+		//if (l>m_maxAppliedImpulse)
+		//{
+		//	multiplier *= m_maxAppliedImpulse/l;
+		//}
+
+		for (int dof = 0; dof < 6 + getNumDofs(); ++dof)
+		{
+			m_realBuf[dof] += delta_vee[dof] * multiplier;
+			btClamp(m_realBuf[dof], -m_maxCoordinateVelocity, m_maxCoordinateVelocity);
+		}
+	}
+
+	// timestep the positions (given current velocities).
+	void stepPositionsMultiDof(btScalar dt, btScalar *pq = 0, btScalar *pqd = 0);
+    
+    // predict the positions
+    void predictPositionsMultiDof(btScalar dt);
+
+	//
+	// contacts
+	//
+
+	// This routine fills out a contact constraint jacobian for this body.
+	// the 'normal' supplied must be -n for body1 or +n for body2 of the contact.
+	// 'normal' & 'contact_point' are both given in world coordinates.
+
+	void fillContactJacobianMultiDof(int link,
+									 const btVector3 &contact_point,
+									 const btVector3 &normal,
+									 btScalar *jac,
+									 btAlignedObjectArray<btScalar> &scratch_r,
+									 btAlignedObjectArray<btVector3> &scratch_v,
+									 btAlignedObjectArray<btMatrix3x3> &scratch_m) const { fillConstraintJacobianMultiDof(link, contact_point, btVector3(0, 0, 0), normal, jac, scratch_r, scratch_v, scratch_m); }
+
+	//a more general version of fillContactJacobianMultiDof which does not assume..
+	//.. that the constraint in question is contact or, to be more precise, constrains linear velocity only
+	void fillConstraintJacobianMultiDof(int link,
+										const btVector3 &contact_point,
+										const btVector3 &normal_ang,
+										const btVector3 &normal_lin,
+										btScalar *jac,
+										btAlignedObjectArray<btScalar> &scratch_r,
+										btAlignedObjectArray<btVector3> &scratch_v,
+										btAlignedObjectArray<btMatrix3x3> &scratch_m) const;
+
+	//
+	// sleeping
+	//
+	void setCanSleep(bool canSleep)
+	{
+		if (m_canWakeup)
+		{
+			m_canSleep = canSleep;
+		}
+	}
+
+	bool getCanSleep() const
+	{
+		return m_canSleep;
+	}
+
+	bool getCanWakeup() const
+	{
+		return m_canWakeup;
+	}
+	
+	void setCanWakeup(bool canWakeup) 
+	{
+		m_canWakeup = canWakeup;
+	}
+	bool isAwake() const { return m_awake; }
+	void wakeUp();
+	void goToSleep();
+	void checkMotionAndSleepIfRequired(btScalar timestep);
+
+	bool hasFixedBase() const;
+
+	bool isBaseKinematic() const;
+
+	bool isBaseStaticOrKinematic() const;
+
+	// set the dynamic type in the base's collision flags.
+	void setBaseDynamicType(int dynamicType);
+
+	void setFixedBase(bool fixedBase)
+	{
+		m_fixedBase = fixedBase;
+		if(m_fixedBase)
+			setBaseDynamicType(btCollisionObject::CF_STATIC_OBJECT);
+		else
+			setBaseDynamicType(btCollisionObject::CF_DYNAMIC_OBJECT);
+	}
+
+	int getCompanionId() const
+	{
+		return m_companionId;
+	}
+	void setCompanionId(int id)
+	{
+		//printf("for %p setCompanionId(%d)\n",this, id);
+		m_companionId = id;
+	}
+
+	void setNumLinks(int numLinks)  //careful: when changing the number of m_links, make sure to re-initialize or update existing m_links
+	{
+		m_links.resize(numLinks);
+	}
+
+	btScalar getLinearDamping() const
+	{
+		return m_linearDamping;
+	}
+	void setLinearDamping(btScalar damp)
+	{
+		m_linearDamping = damp;
+	}
+	btScalar getAngularDamping() const
+	{
+		return m_angularDamping;
+	}
+	void setAngularDamping(btScalar damp)
+	{
+		m_angularDamping = damp;
+	}
+
+	bool getUseGyroTerm() const
+	{
+		return m_useGyroTerm;
+	}
+	void setUseGyroTerm(bool useGyro)
+	{
+		m_useGyroTerm = useGyro;
+	}
+	btScalar getMaxCoordinateVelocity() const
+	{
+		return m_maxCoordinateVelocity;
+	}
+	void setMaxCoordinateVelocity(btScalar maxVel)
+	{
+		m_maxCoordinateVelocity = maxVel;
+	}
+
+	btScalar getMaxAppliedImpulse() const
+	{
+		return m_maxAppliedImpulse;
+	}
+	void setMaxAppliedImpulse(btScalar maxImp)
+	{
+		m_maxAppliedImpulse = maxImp;
+	}
+	void setHasSelfCollision(bool hasSelfCollision)
+	{
+		m_hasSelfCollision = hasSelfCollision;
+	}
+	bool hasSelfCollision() const
+	{
+		return m_hasSelfCollision;
+	}
+
+	void finalizeMultiDof();
+
+	void useRK4Integration(bool use) { m_useRK4 = use; }
+	bool isUsingRK4Integration() const { return m_useRK4; }
+	void useGlobalVelocities(bool use) { m_useGlobalVelocities = use; }
+	bool isUsingGlobalVelocities() const { return m_useGlobalVelocities; }
+
+	bool isPosUpdated() const
+	{
+		return __posUpdated;
+	}
+	void setPosUpdated(bool updated)
+	{
+		__posUpdated = updated;
+	}
+
+	//internalNeedsJointFeedback is for internal use only
+	bool internalNeedsJointFeedback() const
+	{
+		return m_internalNeedsJointFeedback;
+	}
+	void forwardKinematics(btAlignedObjectArray<btQuaternion>& world_to_local, btAlignedObjectArray<btVector3> & local_origin);
+
+	void compTreeLinkVelocities(btVector3 * omega, btVector3 * vel) const;
+
+	void updateCollisionObjectWorldTransforms(btAlignedObjectArray<btQuaternion> & world_to_local, btAlignedObjectArray<btVector3> & local_origin);
+    void updateCollisionObjectInterpolationWorldTransforms(btAlignedObjectArray<btQuaternion> & world_to_local, btAlignedObjectArray<btVector3> & local_origin);
+
+	virtual int calculateSerializeBufferSize() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	virtual const char *serialize(void *dataBuffer, class btSerializer *serializer) const;
+
+	const char *getBaseName() const
+	{
+		return m_baseName;
+	}
+	///memory of setBaseName needs to be manager by user
+	void setBaseName(const char *name)
+	{
+		m_baseName = name;
+	}
+
+	///users can point to their objects, userPointer is not used by Bullet
+	void *getUserPointer() const
+	{
+		return m_userObjectPointer;
+	}
+
+	int getUserIndex() const
+	{
+		return m_userIndex;
+	}
+
+	int getUserIndex2() const
+	{
+		return m_userIndex2;
+	}
+	///users can point to their objects, userPointer is not used by Bullet
+	void setUserPointer(void *userPointer)
+	{
+		m_userObjectPointer = userPointer;
+	}
+
+	///users can point to their objects, userPointer is not used by Bullet
+	void setUserIndex(int index)
+	{
+		m_userIndex = index;
+	}
+
+	void setUserIndex2(int index)
+	{
+		m_userIndex2 = index;
+	}
+
+	static void spatialTransform(const btMatrix3x3 &rotation_matrix,  // rotates vectors in 'from' frame to vectors in 'to' frame
+		const btVector3 &displacement,     // vector from origin of 'from' frame to origin of 'to' frame, in 'to' coordinates
+		const btVector3 &top_in,       // top part of input vector
+		const btVector3 &bottom_in,    // bottom part of input vector
+		btVector3 &top_out,         // top part of output vector
+		btVector3 &bottom_out);      // bottom part of output vector
+
+	void setLinkDynamicType(const int i, int type);
+
+	bool isLinkStaticOrKinematic(const int i) const;
+
+	bool isLinkKinematic(const int i) const;
+
+	bool isLinkAndAllAncestorsStaticOrKinematic(const int i) const;
+
+	bool isLinkAndAllAncestorsKinematic(const int i) const;
+
+private:
+	btMultiBody(const btMultiBody &);     // not implemented
+	void operator=(const btMultiBody &);  // not implemented
+
+	void solveImatrix(const btVector3 &rhs_top, const btVector3 &rhs_bot, btScalar result[6]) const;
+	void solveImatrix(const btSpatialForceVector &rhs, btSpatialMotionVector &result) const;
+
+	void updateLinksDofOffsets()
+	{
+		int dofOffset = 0, cfgOffset = 0;
+		for (int bidx = 0; bidx < m_links.size(); ++bidx)
+		{
+			m_links[bidx].m_dofOffset = dofOffset;
+			m_links[bidx].m_cfgOffset = cfgOffset;
+			dofOffset += m_links[bidx].m_dofCount;
+			cfgOffset += m_links[bidx].m_posVarCount;
+		}
+	}
+
+	void mulMatrix(btScalar * pA, btScalar * pB, int rowsA, int colsA, int rowsB, int colsB, btScalar *pC) const;
+
+private:
+	btMultiBodyLinkCollider *m_baseCollider;  //can be NULL
+	const char *m_baseName;                   //memory needs to be manager by user!
+
+	btVector3 m_basePos;      // position of COM of base (world frame)
+    btVector3 m_basePos_interpolate;      // position of interpolated COM of base (world frame)
+	btQuaternion m_baseQuat;  // rotates world points into base frame
+    btQuaternion m_baseQuat_interpolate;  
+
+	btScalar m_baseMass;      // mass of the base
+	btVector3 m_baseInertia;  // inertia of the base (in local frame; diagonal)
+
+	btVector3 m_baseForce;   // external force applied to base. World frame.
+	btVector3 m_baseTorque;  // external torque applied to base. World frame.
+
+	btVector3 m_baseConstraintForce;   // external force applied to base. World frame.
+	btVector3 m_baseConstraintTorque;  // external torque applied to base. World frame.
+
+	btAlignedObjectArray<btMultibodyLink> m_links;  // array of m_links, excluding the base. index from 0 to num_links-1.
+
+	//
+	// realBuf:
+	//  offset         size            array
+	//   0              6 + num_links   v (base_omega; base_vel; joint_vels)					MULTIDOF [sysdof x sysdof for D matrices (TOO MUCH!) + pos_delta which is sys-cfg sized]
+	//   6+num_links    num_links       D
+	//
+	// vectorBuf:
+	//  offset         size         array
+	//   0              num_links    h_top
+	//   num_links      num_links    h_bottom
+	//
+	// matrixBuf:
+	//  offset         size         array
+	//   0              num_links+1  rot_from_parent
+	//
+    btAlignedObjectArray<btScalar> m_splitV;
+	btAlignedObjectArray<btScalar> m_deltaV;
+	btAlignedObjectArray<btScalar> m_realBuf;
+	btAlignedObjectArray<btVector3> m_vectorBuf;
+	btAlignedObjectArray<btMatrix3x3> m_matrixBuf;
+
+	btMatrix3x3 m_cachedInertiaTopLeft;
+	btMatrix3x3 m_cachedInertiaTopRight;
+	btMatrix3x3 m_cachedInertiaLowerLeft;
+	btMatrix3x3 m_cachedInertiaLowerRight;
+	bool m_cachedInertiaValid;
+
+	bool m_fixedBase;
+
+	// Sleep parameters.
+	bool m_awake;
+	bool m_canSleep;
+	bool m_canWakeup;
+	btScalar m_sleepTimer;
+
+	void *m_userObjectPointer;
+	int m_userIndex2;
+	int m_userIndex;
+
+	int m_companionId;
+	btScalar m_linearDamping;
+	btScalar m_angularDamping;
+	bool m_useGyroTerm;
+	btScalar m_maxAppliedImpulse;
+	btScalar m_maxCoordinateVelocity;
+	bool m_hasSelfCollision;
+
+	bool __posUpdated;
+	int m_dofCount, m_posVarCnt;
+
+	bool m_useRK4, m_useGlobalVelocities;
+	//for global velocities, see 8.3.2B Proposed resolution in Jakub Stepien PhD Thesis
+	//https://drive.google.com/file/d/0Bz3vEa19XOYGNWdZWGpMdUdqVmZ5ZVBOaEh4ZnpNaUxxZFNV/view?usp=sharing
+
+	///the m_needsJointFeedback gets updated/computed during the stepVelocitiesMultiDof and it for internal usage only
+	bool m_internalNeedsJointFeedback;
+};
+
+struct btMultiBodyLinkDoubleData
+{
+	btQuaternionDoubleData m_zeroRotParentToThis;
+	btVector3DoubleData m_parentComToThisPivotOffset;
+	btVector3DoubleData m_thisPivotToThisComOffset;
+	btVector3DoubleData m_jointAxisTop[6];
+	btVector3DoubleData m_jointAxisBottom[6];
+
+	btVector3DoubleData m_linkInertia;  // inertia of the base (in local frame; diagonal)
+	btVector3DoubleData m_absFrameTotVelocityTop;
+	btVector3DoubleData m_absFrameTotVelocityBottom;
+	btVector3DoubleData m_absFrameLocVelocityTop;
+	btVector3DoubleData m_absFrameLocVelocityBottom;
+
+	double m_linkMass;
+	int m_parentIndex;
+	int m_jointType;
+
+	int m_dofCount;
+	int m_posVarCount;
+	double m_jointPos[7];
+	double m_jointVel[6];
+	double m_jointTorque[6];
+
+	double m_jointDamping;
+	double m_jointFriction;
+	double m_jointLowerLimit;
+	double m_jointUpperLimit;
+	double m_jointMaxForce;
+	double m_jointMaxVelocity;
+
+	char *m_linkName;
+	char *m_jointName;
+	btCollisionObjectDoubleData *m_linkCollider;
+	char *m_paddingPtr;
+};
+
+struct btMultiBodyLinkFloatData
+{
+	btQuaternionFloatData m_zeroRotParentToThis;
+	btVector3FloatData m_parentComToThisPivotOffset;
+	btVector3FloatData m_thisPivotToThisComOffset;
+	btVector3FloatData m_jointAxisTop[6];
+	btVector3FloatData m_jointAxisBottom[6];
+	btVector3FloatData m_linkInertia;  // inertia of the base (in local frame; diagonal)
+	btVector3FloatData m_absFrameTotVelocityTop;
+	btVector3FloatData m_absFrameTotVelocityBottom;
+	btVector3FloatData m_absFrameLocVelocityTop;
+	btVector3FloatData m_absFrameLocVelocityBottom;
+
+	int m_dofCount;
+	float m_linkMass;
+	int m_parentIndex;
+	int m_jointType;
+
+	float m_jointPos[7];
+	float m_jointVel[6];
+	float m_jointTorque[6];
+	int m_posVarCount;
+	float m_jointDamping;
+	float m_jointFriction;
+	float m_jointLowerLimit;
+	float m_jointUpperLimit;
+	float m_jointMaxForce;
+	float m_jointMaxVelocity;
+
+	char *m_linkName;
+	char *m_jointName;
+	btCollisionObjectFloatData *m_linkCollider;
+	char *m_paddingPtr;
+};
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct btMultiBodyDoubleData
+{
+	btVector3DoubleData m_baseWorldPosition;
+	btQuaternionDoubleData m_baseWorldOrientation;
+	btVector3DoubleData m_baseLinearVelocity;
+	btVector3DoubleData m_baseAngularVelocity;
+	btVector3DoubleData m_baseInertia;  // inertia of the base (in local frame; diagonal)
+	double m_baseMass;
+	int m_numLinks;
+	char m_padding[4];
+
+	char *m_baseName;
+	btMultiBodyLinkDoubleData *m_links;
+	btCollisionObjectDoubleData *m_baseCollider;
+};
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct btMultiBodyFloatData
+{
+	btVector3FloatData m_baseWorldPosition;
+	btQuaternionFloatData m_baseWorldOrientation;
+	btVector3FloatData m_baseLinearVelocity;
+	btVector3FloatData m_baseAngularVelocity;
+
+	btVector3FloatData m_baseInertia;  // inertia of the base (in local frame; diagonal)
+	float m_baseMass;
+	int m_numLinks;
+
+	char *m_baseName;
+	btMultiBodyLinkFloatData *m_links;
+	btCollisionObjectFloatData *m_baseCollider;
+};
+
+#endif
diff --git a/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyConstraint.h b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyConstraint.h
new file mode 100644
index 00000000..4a6007ee
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyConstraint.h
@@ -0,0 +1,215 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_MULTIBODY_CONSTRAINT_H
+#define BT_MULTIBODY_CONSTRAINT_H
+
+#include "LinearMath/btScalar.h"
+#include "LinearMath/btAlignedObjectArray.h"
+#include "btMultiBody.h"
+
+
+//Don't change any of the existing enum values, so add enum types at the end for serialization compatibility
+enum btTypedMultiBodyConstraintType
+{
+	MULTIBODY_CONSTRAINT_LIMIT=3,
+	MULTIBODY_CONSTRAINT_1DOF_JOINT_MOTOR,
+	MULTIBODY_CONSTRAINT_GEAR,
+	MULTIBODY_CONSTRAINT_POINT_TO_POINT,
+	MULTIBODY_CONSTRAINT_SLIDER,
+	MULTIBODY_CONSTRAINT_SPHERICAL_MOTOR,
+	MULTIBODY_CONSTRAINT_FIXED,
+	
+	MAX_MULTIBODY_CONSTRAINT_TYPE,
+};
+
+class btMultiBody;
+struct btSolverInfo;
+
+#include "btMultiBodySolverConstraint.h"
+
+struct btMultiBodyJacobianData
+{
+	btAlignedObjectArray<btScalar> m_jacobians;
+	btAlignedObjectArray<btScalar> m_deltaVelocitiesUnitImpulse;  //holds the joint-space response of the corresp. tree to the test impulse in each constraint space dimension
+	btAlignedObjectArray<btScalar> m_deltaVelocities;             //holds joint-space vectors of all the constrained trees accumulating the effect of corrective impulses applied in SI
+	btAlignedObjectArray<btScalar> scratch_r;
+	btAlignedObjectArray<btVector3> scratch_v;
+	btAlignedObjectArray<btMatrix3x3> scratch_m;
+	btAlignedObjectArray<btSolverBody>* m_solverBodyPool;
+	int m_fixedBodyId;
+};
+
+ATTRIBUTE_ALIGNED16(class)
+btMultiBodyConstraint
+{
+protected:
+	btMultiBody* m_bodyA;
+	btMultiBody* m_bodyB;
+	int m_linkA;
+	int m_linkB;
+
+	int m_type; //btTypedMultiBodyConstraintType
+
+	int m_numRows;
+	int m_jacSizeA;
+	int m_jacSizeBoth;
+	int m_posOffset;
+
+	bool m_isUnilateral;
+	int m_numDofsFinalized;
+	btScalar m_maxAppliedImpulse;
+
+	// warning: the data block lay out is not consistent for all constraints
+	// data block laid out as follows:
+	// cached impulses. (one per row.)
+	// jacobians. (interleaved, row1 body1 then row1 body2 then row2 body 1 etc)
+	// positions. (one per row.)
+	btAlignedObjectArray<btScalar> m_data;
+
+	void applyDeltaVee(btMultiBodyJacobianData & data, btScalar * delta_vee, btScalar impulse, int velocityIndex, int ndof);
+
+	btScalar fillMultiBodyConstraint(btMultiBodySolverConstraint & solverConstraint,
+									 btMultiBodyJacobianData & data,
+									 btScalar * jacOrgA, btScalar * jacOrgB,
+									 const btVector3& constraintNormalAng,
+
+									 const btVector3& constraintNormalLin,
+									 const btVector3& posAworld, const btVector3& posBworld,
+									 btScalar posError,
+									 const btContactSolverInfo& infoGlobal,
+									 btScalar lowerLimit, btScalar upperLimit,
+									 bool angConstraint = false,
+
+									 btScalar relaxation = 1.f,
+									 bool isFriction = false, btScalar desiredVelocity = 0, btScalar cfmSlip = 0);
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btMultiBodyConstraint(btMultiBody * bodyA, btMultiBody * bodyB, int linkA, int linkB, int numRows, bool isUnilateral, int type);
+	virtual ~btMultiBodyConstraint();
+
+	void updateJacobianSizes();
+	void allocateJacobiansMultiDof();
+
+	int getConstraintType() const
+	{
+		return m_type;
+	}
+	//many constraints have setFrameInB/setPivotInB. Will use 'getConstraintType' later.
+	virtual void setFrameInB(const btMatrix3x3& frameInB) {}
+	virtual void setPivotInB(const btVector3& pivotInB) {}
+
+	virtual void finalizeMultiDof() = 0;
+
+	virtual int getIslandIdA() const = 0;
+	virtual int getIslandIdB() const = 0;
+
+	virtual void createConstraintRows(btMultiBodyConstraintArray & constraintRows,
+									  btMultiBodyJacobianData & data,
+									  const btContactSolverInfo& infoGlobal) = 0;
+
+	int getNumRows() const
+	{
+		return m_numRows;
+	}
+
+	btMultiBody* getMultiBodyA()
+	{
+		return m_bodyA;
+	}
+	btMultiBody* getMultiBodyB()
+	{
+		return m_bodyB;
+	}
+
+	int getLinkA() const
+	{
+		return m_linkA;
+	}
+	int getLinkB() const
+	{
+		return m_linkB;
+	}
+	void internalSetAppliedImpulse(int dof, btScalar appliedImpulse)
+	{
+		btAssert(dof >= 0);
+		btAssert(dof < getNumRows());
+		m_data[dof] = appliedImpulse;
+	}
+
+	btScalar getAppliedImpulse(int dof)
+	{
+		btAssert(dof >= 0);
+		btAssert(dof < getNumRows());
+		return m_data[dof];
+	}
+	// current constraint position
+	// constraint is pos >= 0 for unilateral, or pos = 0 for bilateral
+	// NOTE: ignored position for friction rows.
+	btScalar getPosition(int row) const
+	{
+		return m_data[m_posOffset + row];
+	}
+
+	void setPosition(int row, btScalar pos)
+	{
+		m_data[m_posOffset + row] = pos;
+	}
+
+	bool isUnilateral() const
+	{
+		return m_isUnilateral;
+	}
+
+	// jacobian blocks.
+	// each of size 6 + num_links. (jacobian2 is null if no body2.)
+	// format: 3 'omega' coefficients, 3 'v' coefficients, then the 'qdot' coefficients.
+	btScalar* jacobianA(int row)
+	{
+		return &m_data[m_numRows + row * m_jacSizeBoth];
+	}
+	const btScalar* jacobianA(int row) const
+	{
+		return &m_data[m_numRows + (row * m_jacSizeBoth)];
+	}
+	btScalar* jacobianB(int row)
+	{
+		return &m_data[m_numRows + (row * m_jacSizeBoth) + m_jacSizeA];
+	}
+	const btScalar* jacobianB(int row) const
+	{
+		return &m_data[m_numRows + (row * m_jacSizeBoth) + m_jacSizeA];
+	}
+
+	btScalar getMaxAppliedImpulse() const
+	{
+		return m_maxAppliedImpulse;
+	}
+	void setMaxAppliedImpulse(btScalar maxImp)
+	{
+		m_maxAppliedImpulse = maxImp;
+	}
+
+	virtual void debugDraw(class btIDebugDraw * drawer) = 0;
+
+	virtual void setGearRatio(btScalar ratio) {}
+	virtual void setGearAuxLink(int gearAuxLink) {}
+	virtual void setRelativePositionTarget(btScalar relPosTarget) {}
+	virtual void setErp(btScalar erp) {}
+};
+
+#endif  //BT_MULTIBODY_CONSTRAINT_H
diff --git a/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h
new file mode 100644
index 00000000..f584360e
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h
@@ -0,0 +1,101 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_MULTIBODY_CONSTRAINT_SOLVER_H
+#define BT_MULTIBODY_CONSTRAINT_SOLVER_H
+
+#include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h"
+#include "btMultiBodySolverConstraint.h"
+
+#define DIRECTLY_UPDATE_VELOCITY_DURING_SOLVER_ITERATIONS
+
+class btMultiBody;
+
+#include "btMultiBodyConstraint.h"
+
+ATTRIBUTE_ALIGNED16(class)
+btMultiBodyConstraintSolver : public btSequentialImpulseConstraintSolver
+{
+protected:
+	btMultiBodyConstraintArray m_multiBodyNonContactConstraints;
+
+	btMultiBodyConstraintArray m_multiBodyNormalContactConstraints;
+	btMultiBodyConstraintArray m_multiBodyFrictionContactConstraints;
+	btMultiBodyConstraintArray m_multiBodyTorsionalFrictionContactConstraints;
+	btMultiBodyConstraintArray m_multiBodySpinningFrictionContactConstraints;
+
+	btMultiBodyJacobianData m_data;
+
+	//temp storage for multi body constraints for a specific island/group called by 'solveGroup'
+	btMultiBodyConstraint** m_tmpMultiBodyConstraints;
+	int m_tmpNumMultiBodyConstraints;
+
+	btScalar resolveSingleConstraintRowGeneric(const btMultiBodySolverConstraint& c);
+
+	//solve 2 friction directions and clamp against the implicit friction cone
+	btScalar resolveConeFrictionConstraintRows(const btMultiBodySolverConstraint& cA1, const btMultiBodySolverConstraint& cB);
+
+	void convertContacts(btPersistentManifold * *manifoldPtr, int numManifolds, const btContactSolverInfo& infoGlobal);
+
+	btMultiBodySolverConstraint& addMultiBodyFrictionConstraint(const btVector3& normalAxis, const btScalar& appliedImpulse, btPersistentManifold* manifold, int frictionIndex, btManifoldPoint& cp, btCollisionObject* colObj0, btCollisionObject* colObj1, btScalar relaxation, const btContactSolverInfo& infoGlobal, btScalar desiredVelocity = 0, btScalar cfmSlip = 0);
+
+	btMultiBodySolverConstraint& addMultiBodyTorsionalFrictionConstraint(const btVector3& normalAxis, btPersistentManifold* manifold, int frictionIndex, btManifoldPoint& cp,
+																		 btScalar combinedTorsionalFriction,
+																		 btCollisionObject* colObj0, btCollisionObject* colObj1, btScalar relaxation, const btContactSolverInfo& infoGlobal, btScalar desiredVelocity = 0, btScalar cfmSlip = 0);
+
+	btMultiBodySolverConstraint& addMultiBodySpinningFrictionConstraint(const btVector3& normalAxis, btPersistentManifold* manifold, int frictionIndex, btManifoldPoint& cp,
+		btScalar combinedTorsionalFriction,
+		btCollisionObject* colObj0, btCollisionObject* colObj1, btScalar relaxation, const btContactSolverInfo& infoGlobal, btScalar desiredVelocity = 0, btScalar cfmSlip = 0);
+
+	void setupMultiBodyJointLimitConstraint(btMultiBodySolverConstraint & constraintRow,
+											btScalar * jacA, btScalar * jacB,
+											btScalar penetration, btScalar combinedFrictionCoeff, btScalar combinedRestitutionCoeff,
+											const btContactSolverInfo& infoGlobal);
+
+	void setupMultiBodyContactConstraint(btMultiBodySolverConstraint & solverConstraint,
+										 const btVector3& contactNormal,
+                     const btScalar& appliedImpulse,
+										 btManifoldPoint& cp,
+                     const btContactSolverInfo& infoGlobal,
+										 btScalar& relaxation,
+										 bool isFriction, btScalar desiredVelocity = 0, btScalar cfmSlip = 0);
+
+	//either rolling or spinning friction
+	void setupMultiBodyTorsionalFrictionConstraint(btMultiBodySolverConstraint & solverConstraint,
+												   const btVector3& contactNormal,
+												   btManifoldPoint& cp,
+												   btScalar combinedTorsionalFriction,
+												   const btContactSolverInfo& infoGlobal,
+												   btScalar& relaxation,
+												   bool isFriction, btScalar desiredVelocity = 0, btScalar cfmSlip = 0);
+
+	void convertMultiBodyContact(btPersistentManifold * manifold, const btContactSolverInfo& infoGlobal);
+	virtual btScalar solveGroupCacheFriendlySetup(btCollisionObject * *bodies, int numBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer);
+	//	virtual btScalar solveGroupCacheFriendlyIterations(btCollisionObject** bodies,int numBodies,btPersistentManifold** manifoldPtr, int numManifolds,btTypedConstraint** constraints,int numConstraints,const btContactSolverInfo& infoGlobal,btIDebugDraw* debugDrawer);
+	virtual btScalar solveSingleIteration(int iteration, btCollisionObject** bodies, int numBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer);
+	void applyDeltaVee(btScalar * deltaV, btScalar impulse, int velocityIndex, int ndof);
+	void writeBackSolverBodyToMultiBody(btMultiBodySolverConstraint & constraint, btScalar deltaTime);
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	///this method should not be called, it was just used during porting/integration of Featherstone btMultiBody, providing backwards compatibility but no support for btMultiBodyConstraint (only contact constraints)
+	virtual btScalar solveGroup(btCollisionObject * *bodies, int numBodies, btPersistentManifold** manifold, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& info, btIDebugDraw* debugDrawer, btDispatcher* dispatcher);
+	virtual btScalar solveGroupCacheFriendlyFinish(btCollisionObject * *bodies, int numBodies, const btContactSolverInfo& infoGlobal);
+
+	virtual void solveMultiBodyGroup(btCollisionObject * *bodies, int numBodies, btPersistentManifold** manifold, int numManifolds, btTypedConstraint** constraints, int numConstraints, btMultiBodyConstraint** multiBodyConstraints, int numMultiBodyConstraints, const btContactSolverInfo& info, btIDebugDraw* debugDrawer, btDispatcher* dispatcher);
+};
+
+#endif  //BT_MULTIBODY_CONSTRAINT_SOLVER_H
diff --git a/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyDynamicsWorld.h b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyDynamicsWorld.h
new file mode 100644
index 00000000..d2d76c8b
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyDynamicsWorld.h
@@ -0,0 +1,126 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_MULTIBODY_DYNAMICS_WORLD_H
+#define BT_MULTIBODY_DYNAMICS_WORLD_H
+
+#include "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h"
+#include "BulletDynamics/Featherstone/btMultiBodyInplaceSolverIslandCallback.h"
+
+#define BT_USE_VIRTUAL_CLEARFORCES_AND_GRAVITY
+
+class btMultiBody;
+class btMultiBodyConstraint;
+class btMultiBodyConstraintSolver;
+struct MultiBodyInplaceSolverIslandCallback;
+
+///The btMultiBodyDynamicsWorld adds Featherstone multi body dynamics to Bullet
+///This implementation is still preliminary/experimental.
+class btMultiBodyDynamicsWorld : public btDiscreteDynamicsWorld
+{
+protected:
+	btAlignedObjectArray<btMultiBody*> m_multiBodies;
+	btAlignedObjectArray<btMultiBodyConstraint*> m_multiBodyConstraints;
+	btAlignedObjectArray<btMultiBodyConstraint*> m_sortedMultiBodyConstraints;
+	btMultiBodyConstraintSolver* m_multiBodyConstraintSolver;
+	MultiBodyInplaceSolverIslandCallback* m_solverMultiBodyIslandCallback;
+
+	//cached data to avoid memory allocations
+	btAlignedObjectArray<btQuaternion> m_scratch_world_to_local;
+	btAlignedObjectArray<btVector3> m_scratch_local_origin;
+	btAlignedObjectArray<btQuaternion> m_scratch_world_to_local1;
+	btAlignedObjectArray<btVector3> m_scratch_local_origin1;
+	btAlignedObjectArray<btScalar> m_scratch_r;
+	btAlignedObjectArray<btVector3> m_scratch_v;
+	btAlignedObjectArray<btMatrix3x3> m_scratch_m;
+
+	virtual void calculateSimulationIslands();
+	virtual void updateActivationState(btScalar timeStep);
+	
+
+	virtual void serializeMultiBodies(btSerializer* serializer);
+
+public:
+	btMultiBodyDynamicsWorld(btDispatcher* dispatcher, btBroadphaseInterface* pairCache, btMultiBodyConstraintSolver* constraintSolver, btCollisionConfiguration* collisionConfiguration);
+
+	virtual ~btMultiBodyDynamicsWorld();
+    
+    virtual void solveConstraints(btContactSolverInfo& solverInfo);
+    
+	virtual void addMultiBody(btMultiBody* body, int group = btBroadphaseProxy::DefaultFilter, int mask = btBroadphaseProxy::AllFilter);
+
+	virtual void removeMultiBody(btMultiBody* body);
+
+	virtual int getNumMultibodies() const
+	{
+		return m_multiBodies.size();
+	}
+
+	btMultiBody* getMultiBody(int mbIndex)
+	{
+		return m_multiBodies[mbIndex];
+	}
+
+	const btMultiBody* getMultiBody(int mbIndex) const
+	{
+		return m_multiBodies[mbIndex];
+	}
+
+	virtual void addMultiBodyConstraint(btMultiBodyConstraint* constraint);
+
+	virtual int getNumMultiBodyConstraints() const
+	{
+		return m_multiBodyConstraints.size();
+	}
+
+	virtual btMultiBodyConstraint* getMultiBodyConstraint(int constraintIndex)
+	{
+		return m_multiBodyConstraints[constraintIndex];
+	}
+
+	virtual const btMultiBodyConstraint* getMultiBodyConstraint(int constraintIndex) const
+	{
+		return m_multiBodyConstraints[constraintIndex];
+	}
+
+	virtual void removeMultiBodyConstraint(btMultiBodyConstraint* constraint);
+
+	virtual void integrateTransforms(btScalar timeStep);
+    void integrateMultiBodyTransforms(btScalar timeStep);
+    void predictMultiBodyTransforms(btScalar timeStep);
+    
+    virtual void predictUnconstraintMotion(btScalar timeStep);
+	virtual void debugDrawWorld();
+
+	virtual void debugDrawMultiBodyConstraint(btMultiBodyConstraint* constraint);
+
+	void forwardKinematics();
+	virtual void clearForces();
+	virtual void clearMultiBodyConstraintForces();
+	virtual void clearMultiBodyForces();
+	virtual void applyGravity();
+
+	virtual void serialize(btSerializer* serializer);
+	virtual void setMultiBodyConstraintSolver(btMultiBodyConstraintSolver* solver);
+	virtual void setConstraintSolver(btConstraintSolver* solver);
+	virtual void getAnalyticsData(btAlignedObjectArray<struct btSolverAnalyticsData>& m_islandAnalyticsData) const;
+    
+    virtual void solveExternalForces(btContactSolverInfo& solverInfo);
+    virtual void solveInternalConstraints(btContactSolverInfo& solverInfo);
+    void buildIslands();
+
+	virtual void saveKinematicState(btScalar timeStep);
+};
+#endif  //BT_MULTIBODY_DYNAMICS_WORLD_H
diff --git a/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyFixedConstraint.h b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyFixedConstraint.h
new file mode 100644
index 00000000..adb1cb47
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyFixedConstraint.h
@@ -0,0 +1,91 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+///This file was written by Erwin Coumans
+
+#ifndef BT_MULTIBODY_FIXED_CONSTRAINT_H
+#define BT_MULTIBODY_FIXED_CONSTRAINT_H
+
+#include "btMultiBodyConstraint.h"
+
+class btMultiBodyFixedConstraint : public btMultiBodyConstraint
+{
+protected:
+	btRigidBody* m_rigidBodyA;
+	btRigidBody* m_rigidBodyB;
+	btVector3 m_pivotInA;
+	btVector3 m_pivotInB;
+	btMatrix3x3 m_frameInA;
+	btMatrix3x3 m_frameInB;
+
+public:
+	btMultiBodyFixedConstraint(btMultiBody* body, int link, btRigidBody* bodyB, const btVector3& pivotInA, const btVector3& pivotInB, const btMatrix3x3& frameInA, const btMatrix3x3& frameInB);
+	btMultiBodyFixedConstraint(btMultiBody* bodyA, int linkA, btMultiBody* bodyB, int linkB, const btVector3& pivotInA, const btVector3& pivotInB, const btMatrix3x3& frameInA, const btMatrix3x3& frameInB);
+
+	virtual ~btMultiBodyFixedConstraint();
+
+	virtual void finalizeMultiDof();
+
+	virtual int getIslandIdA() const;
+	virtual int getIslandIdB() const;
+
+	virtual void createConstraintRows(btMultiBodyConstraintArray& constraintRows,
+									  btMultiBodyJacobianData& data,
+									  const btContactSolverInfo& infoGlobal);
+
+	const btVector3& getPivotInA() const
+	{
+		return m_pivotInA;
+	}
+
+	void setPivotInA(const btVector3& pivotInA)
+	{
+		m_pivotInA = pivotInA;
+	}
+
+	const btVector3& getPivotInB() const
+	{
+		return m_pivotInB;
+	}
+
+	virtual void setPivotInB(const btVector3& pivotInB)
+	{
+		m_pivotInB = pivotInB;
+	}
+
+	const btMatrix3x3& getFrameInA() const
+	{
+		return m_frameInA;
+	}
+
+	void setFrameInA(const btMatrix3x3& frameInA)
+	{
+		m_frameInA = frameInA;
+	}
+
+	const btMatrix3x3& getFrameInB() const
+	{
+		return m_frameInB;
+	}
+
+	virtual void setFrameInB(const btMatrix3x3& frameInB)
+	{
+		m_frameInB = frameInB;
+	}
+
+	virtual void debugDraw(class btIDebugDraw* drawer);
+};
+
+#endif  //BT_MULTIBODY_FIXED_CONSTRAINT_H
diff --git a/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyGearConstraint.h b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyGearConstraint.h
new file mode 100644
index 00000000..31888fbc
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyGearConstraint.h
@@ -0,0 +1,115 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+///This file was written by Erwin Coumans
+
+#ifndef BT_MULTIBODY_GEAR_CONSTRAINT_H
+#define BT_MULTIBODY_GEAR_CONSTRAINT_H
+
+#include "btMultiBodyConstraint.h"
+
+class btMultiBodyGearConstraint : public btMultiBodyConstraint
+{
+protected:
+	btRigidBody* m_rigidBodyA;
+	btRigidBody* m_rigidBodyB;
+	btVector3 m_pivotInA;
+	btVector3 m_pivotInB;
+	btMatrix3x3 m_frameInA;
+	btMatrix3x3 m_frameInB;
+	btScalar m_gearRatio;
+	int m_gearAuxLink;
+	btScalar m_erp;
+	btScalar m_relativePositionTarget;
+
+public:
+	//btMultiBodyGearConstraint(btMultiBody* body, int link, btRigidBody* bodyB, const btVector3& pivotInA, const btVector3& pivotInB, const btMatrix3x3& frameInA, const btMatrix3x3& frameInB);
+	btMultiBodyGearConstraint(btMultiBody* bodyA, int linkA, btMultiBody* bodyB, int linkB, const btVector3& pivotInA, const btVector3& pivotInB, const btMatrix3x3& frameInA, const btMatrix3x3& frameInB);
+
+	virtual ~btMultiBodyGearConstraint();
+
+	virtual void finalizeMultiDof();
+
+	virtual int getIslandIdA() const;
+	virtual int getIslandIdB() const;
+
+	virtual void createConstraintRows(btMultiBodyConstraintArray& constraintRows,
+									  btMultiBodyJacobianData& data,
+									  const btContactSolverInfo& infoGlobal);
+
+	const btVector3& getPivotInA() const
+	{
+		return m_pivotInA;
+	}
+
+	void setPivotInA(const btVector3& pivotInA)
+	{
+		m_pivotInA = pivotInA;
+	}
+
+	const btVector3& getPivotInB() const
+	{
+		return m_pivotInB;
+	}
+
+	virtual void setPivotInB(const btVector3& pivotInB)
+	{
+		m_pivotInB = pivotInB;
+	}
+
+	const btMatrix3x3& getFrameInA() const
+	{
+		return m_frameInA;
+	}
+
+	void setFrameInA(const btMatrix3x3& frameInA)
+	{
+		m_frameInA = frameInA;
+	}
+
+	const btMatrix3x3& getFrameInB() const
+	{
+		return m_frameInB;
+	}
+
+	virtual void setFrameInB(const btMatrix3x3& frameInB)
+	{
+		m_frameInB = frameInB;
+	}
+
+	virtual void debugDraw(class btIDebugDraw* drawer)
+	{
+		//todo(erwincoumans)
+	}
+
+	virtual void setGearRatio(btScalar gearRatio)
+	{
+		m_gearRatio = gearRatio;
+	}
+	virtual void setGearAuxLink(int gearAuxLink)
+	{
+		m_gearAuxLink = gearAuxLink;
+	}
+	virtual void setRelativePositionTarget(btScalar relPosTarget)
+	{
+		m_relativePositionTarget = relPosTarget;
+	}
+	virtual void setErp(btScalar erp)
+	{
+		m_erp = erp;
+	}
+};
+
+#endif  //BT_MULTIBODY_GEAR_CONSTRAINT_H
diff --git a/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyInplaceSolverIslandCallback.h b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyInplaceSolverIslandCallback.h
new file mode 100644
index 00000000..3169b86e
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyInplaceSolverIslandCallback.h
@@ -0,0 +1,247 @@
+/*
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef BT_MULTIBODY_INPLACE_SOLVER_ISLAND_CALLBACK_H
+#define BT_MULTIBODY_INPLACE_SOLVER_ISLAND_CALLBACK_H
+
+#include "BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h"
+#include "BulletCollision/CollisionDispatch/btSimulationIslandManager.h"
+#include "BulletDynamics/Featherstone/btMultiBodyDynamicsWorld.h"
+#include "btMultiBodyConstraintSolver.h"
+
+SIMD_FORCE_INLINE int btGetConstraintIslandId2(const btTypedConstraint* lhs)
+{
+    int islandId;
+    
+    const btCollisionObject& rcolObj0 = lhs->getRigidBodyA();
+    const btCollisionObject& rcolObj1 = lhs->getRigidBodyB();
+    islandId = rcolObj0.getIslandTag() >= 0 ? rcolObj0.getIslandTag() : rcolObj1.getIslandTag();
+    return islandId;
+}
+class btSortConstraintOnIslandPredicate2
+{
+public:
+    bool operator()(const btTypedConstraint* lhs, const btTypedConstraint* rhs) const
+    {
+        int rIslandId0, lIslandId0;
+        rIslandId0 = btGetConstraintIslandId2(rhs);
+        lIslandId0 = btGetConstraintIslandId2(lhs);
+        return lIslandId0 < rIslandId0;
+    }
+};
+
+SIMD_FORCE_INLINE int btGetMultiBodyConstraintIslandId(const btMultiBodyConstraint* lhs)
+{
+    int islandId;
+    
+    int islandTagA = lhs->getIslandIdA();
+    int islandTagB = lhs->getIslandIdB();
+    islandId = islandTagA >= 0 ? islandTagA : islandTagB;
+    return islandId;
+}
+
+class btSortMultiBodyConstraintOnIslandPredicate
+{
+public:
+    bool operator()(const btMultiBodyConstraint* lhs, const btMultiBodyConstraint* rhs) const
+    {
+        int rIslandId0, lIslandId0;
+        rIslandId0 = btGetMultiBodyConstraintIslandId(rhs);
+        lIslandId0 = btGetMultiBodyConstraintIslandId(lhs);
+        return lIslandId0 < rIslandId0;
+    }
+};
+
+struct MultiBodyInplaceSolverIslandCallback : public btSimulationIslandManager::IslandCallback
+{
+
+    btContactSolverInfo* m_solverInfo;
+    btMultiBodyConstraintSolver* m_solver;
+    btMultiBodyConstraint** m_multiBodySortedConstraints;
+    int m_numMultiBodyConstraints;
+    
+    btTypedConstraint** m_sortedConstraints;
+    int m_numConstraints;
+    btIDebugDraw* m_debugDrawer;
+    btDispatcher* m_dispatcher;
+    
+    btAlignedObjectArray<btCollisionObject*> m_bodies;
+	btAlignedObjectArray<btCollisionObject*> m_softBodies;
+    btAlignedObjectArray<btPersistentManifold*> m_manifolds;
+    btAlignedObjectArray<btTypedConstraint*> m_constraints;
+    btAlignedObjectArray<btMultiBodyConstraint*> m_multiBodyConstraints;
+    
+    btAlignedObjectArray<btSolverAnalyticsData> m_islandAnalyticsData;
+    
+    MultiBodyInplaceSolverIslandCallback(btMultiBodyConstraintSolver* solver,
+                                         btDispatcher* dispatcher)
+    : m_solverInfo(NULL),
+    m_solver(solver),
+    m_multiBodySortedConstraints(NULL),
+    m_numConstraints(0),
+    m_debugDrawer(NULL),
+    m_dispatcher(dispatcher)
+    {
+    }
+    
+    MultiBodyInplaceSolverIslandCallback& operator=(const MultiBodyInplaceSolverIslandCallback& other)
+    {
+        btAssert(0);
+        (void)other;
+        return *this;
+    }
+    
+    SIMD_FORCE_INLINE virtual void setup(btContactSolverInfo* solverInfo, btTypedConstraint** sortedConstraints, int numConstraints, btMultiBodyConstraint** sortedMultiBodyConstraints, int numMultiBodyConstraints, btIDebugDraw* debugDrawer)
+    {
+        m_islandAnalyticsData.clear();
+        btAssert(solverInfo);
+        m_solverInfo = solverInfo;
+        
+        m_multiBodySortedConstraints = sortedMultiBodyConstraints;
+        m_numMultiBodyConstraints = numMultiBodyConstraints;
+        m_sortedConstraints = sortedConstraints;
+        m_numConstraints = numConstraints;
+        
+        m_debugDrawer = debugDrawer;
+        m_bodies.resize(0);
+        m_manifolds.resize(0);
+        m_constraints.resize(0);
+        m_multiBodyConstraints.resize(0);
+    }
+    
+    void setMultiBodyConstraintSolver(btMultiBodyConstraintSolver* solver)
+    {
+        m_solver = solver;
+    }
+    
+    virtual void processIsland(btCollisionObject** bodies, int numBodies, btPersistentManifold** manifolds, int numManifolds, int islandId)
+    {
+        if (islandId < 0)
+        {
+            ///we don't split islands, so all constraints/contact manifolds/bodies are passed into the solver regardless the island id
+            m_solver->solveMultiBodyGroup(bodies, numBodies, manifolds, numManifolds, m_sortedConstraints, m_numConstraints, &m_multiBodySortedConstraints[0], m_numConstraints, *m_solverInfo, m_debugDrawer, m_dispatcher);
+            if (m_solverInfo->m_reportSolverAnalytics&1)
+            {
+                m_solver->m_analyticsData.m_islandId = islandId;
+                m_islandAnalyticsData.push_back(m_solver->m_analyticsData);
+            }
+        }
+        else
+        {
+            //also add all non-contact constraints/joints for this island
+            btTypedConstraint** startConstraint = 0;
+            btMultiBodyConstraint** startMultiBodyConstraint = 0;
+            
+            int numCurConstraints = 0;
+            int numCurMultiBodyConstraints = 0;
+            
+            int i;
+            
+            //find the first constraint for this island
+            
+            for (i = 0; i < m_numConstraints; i++)
+            {
+                if (btGetConstraintIslandId2(m_sortedConstraints[i]) == islandId)
+                {
+                    startConstraint = &m_sortedConstraints[i];
+                    break;
+                }
+            }
+            //count the number of constraints in this island
+            for (; i < m_numConstraints; i++)
+            {
+                if (btGetConstraintIslandId2(m_sortedConstraints[i]) == islandId)
+                {
+                    numCurConstraints++;
+                }
+            }
+            
+            for (i = 0; i < m_numMultiBodyConstraints; i++)
+            {
+                if (btGetMultiBodyConstraintIslandId(m_multiBodySortedConstraints[i]) == islandId)
+                {
+                    startMultiBodyConstraint = &m_multiBodySortedConstraints[i];
+                    break;
+                }
+            }
+            //count the number of multi body constraints in this island
+            for (; i < m_numMultiBodyConstraints; i++)
+            {
+                if (btGetMultiBodyConstraintIslandId(m_multiBodySortedConstraints[i]) == islandId)
+                {
+                    numCurMultiBodyConstraints++;
+                }
+            }
+            
+            //if (m_solverInfo->m_minimumSolverBatchSize<=1)
+            //{
+            //    m_solver->solveGroup( bodies,numBodies,manifolds, numManifolds,startConstraint,numCurConstraints,*m_solverInfo,m_debugDrawer,m_dispatcher);
+            //} else
+            {
+                for (i = 0; i < numBodies; i++)
+				{
+					bool isSoftBodyType = (bodies[i]->getInternalType() & btCollisionObject::CO_SOFT_BODY);
+					if (!isSoftBodyType)
+					{
+						m_bodies.push_back(bodies[i]);
+					}
+					else
+					{
+						m_softBodies.push_back(bodies[i]);
+					}
+				}
+                for (i = 0; i < numManifolds; i++)
+                    m_manifolds.push_back(manifolds[i]);
+                for (i = 0; i < numCurConstraints; i++)
+                    m_constraints.push_back(startConstraint[i]);
+                
+                for (i = 0; i < numCurMultiBodyConstraints; i++)
+                    m_multiBodyConstraints.push_back(startMultiBodyConstraint[i]);
+                
+                if ((m_multiBodyConstraints.size() + m_constraints.size() + m_manifolds.size()) > m_solverInfo->m_minimumSolverBatchSize)
+                {
+                    processConstraints(islandId);
+                }
+                else
+                {
+                    //printf("deferred\n");
+                }
+            }
+        }
+    }
+    
+    virtual void processConstraints(int islandId=-1)
+    {
+        btCollisionObject** bodies = m_bodies.size() ? &m_bodies[0] : 0;
+        btPersistentManifold** manifold = m_manifolds.size() ? &m_manifolds[0] : 0;
+        btTypedConstraint** constraints = m_constraints.size() ? &m_constraints[0] : 0;
+        btMultiBodyConstraint** multiBodyConstraints = m_multiBodyConstraints.size() ? &m_multiBodyConstraints[0] : 0;
+        
+        //printf("mb contacts = %d, mb constraints = %d\n", mbContacts, m_multiBodyConstraints.size());
+        
+        m_solver->solveMultiBodyGroup(bodies, m_bodies.size(), manifold, m_manifolds.size(), constraints, m_constraints.size(), multiBodyConstraints, m_multiBodyConstraints.size(), *m_solverInfo, m_debugDrawer, m_dispatcher);
+        if (m_bodies.size() && (m_solverInfo->m_reportSolverAnalytics&1))
+        {
+            m_solver->m_analyticsData.m_islandId = islandId;
+            m_islandAnalyticsData.push_back(m_solver->m_analyticsData);
+        }
+        m_bodies.resize(0);
+		m_softBodies.resize(0);
+        m_manifolds.resize(0);
+        m_constraints.resize(0);
+        m_multiBodyConstraints.resize(0);
+    }
+};
+
+
+#endif /*BT_MULTIBODY_INPLACE_SOLVER_ISLAND_CALLBACK_H */
diff --git a/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyJointFeedback.h b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyJointFeedback.h
new file mode 100644
index 00000000..d943019e
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyJointFeedback.h
@@ -0,0 +1,25 @@
+/*
+Copyright (c) 2015 Google Inc.
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_MULTIBODY_JOINT_FEEDBACK_H
+#define BT_MULTIBODY_JOINT_FEEDBACK_H
+
+#include "LinearMath/btSpatialAlgebra.h"
+
+struct btMultiBodyJointFeedback
+{
+	btSpatialForceVector m_reactionForces;
+};
+
+#endif  //BT_MULTIBODY_JOINT_FEEDBACK_H
diff --git a/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyJointLimitConstraint.h b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyJointLimitConstraint.h
new file mode 100644
index 00000000..b810692b
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyJointLimitConstraint.h
@@ -0,0 +1,63 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_MULTIBODY_JOINT_LIMIT_CONSTRAINT_H
+#define BT_MULTIBODY_JOINT_LIMIT_CONSTRAINT_H
+
+#include "btMultiBodyConstraint.h"
+struct btSolverInfo;
+
+class btMultiBodyJointLimitConstraint : public btMultiBodyConstraint
+{
+protected:
+	btScalar m_lowerBound;
+	btScalar m_upperBound;
+
+public:
+	btMultiBodyJointLimitConstraint(btMultiBody* body, int link, btScalar lower, btScalar upper);
+	virtual ~btMultiBodyJointLimitConstraint();
+
+	virtual void finalizeMultiDof();
+
+	virtual int getIslandIdA() const;
+	virtual int getIslandIdB() const;
+
+	virtual void createConstraintRows(btMultiBodyConstraintArray& constraintRows,
+									  btMultiBodyJacobianData& data,
+									  const btContactSolverInfo& infoGlobal);
+
+	virtual void debugDraw(class btIDebugDraw* drawer)
+	{
+		//todo(erwincoumans)
+	}
+	btScalar getLowerBound() const
+	{
+		return m_lowerBound;
+	}
+	btScalar getUpperBound() const
+	{
+		return m_upperBound;
+	}
+	void setLowerBound(btScalar lower)
+	{
+		m_lowerBound = lower;
+	}
+	void setUpperBound(btScalar upper)
+	{
+		m_upperBound = upper;
+	}
+};
+
+#endif  //BT_MULTIBODY_JOINT_LIMIT_CONSTRAINT_H
diff --git a/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyJointMotor.h b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyJointMotor.h
new file mode 100644
index 00000000..1aca3635
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyJointMotor.h
@@ -0,0 +1,77 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+///This file was written by Erwin Coumans
+
+#ifndef BT_MULTIBODY_JOINT_MOTOR_H
+#define BT_MULTIBODY_JOINT_MOTOR_H
+
+#include "btMultiBodyConstraint.h"
+struct btSolverInfo;
+
+class btMultiBodyJointMotor : public btMultiBodyConstraint
+{
+protected:
+	btScalar m_desiredVelocity;
+	btScalar m_desiredPosition;
+	btScalar m_kd;
+	btScalar m_kp;
+	btScalar m_erp;
+	btScalar m_rhsClamp;  //maximum error
+
+public:
+	btMultiBodyJointMotor(btMultiBody* body, int link, btScalar desiredVelocity, btScalar maxMotorImpulse);
+	btMultiBodyJointMotor(btMultiBody* body, int link, int linkDoF, btScalar desiredVelocity, btScalar maxMotorImpulse);
+	virtual ~btMultiBodyJointMotor();
+	virtual void finalizeMultiDof();
+
+	virtual int getIslandIdA() const;
+	virtual int getIslandIdB() const;
+
+	virtual void createConstraintRows(btMultiBodyConstraintArray& constraintRows,
+									  btMultiBodyJacobianData& data,
+									  const btContactSolverInfo& infoGlobal);
+
+	virtual void setVelocityTarget(btScalar velTarget, btScalar kd = 1.f)
+	{
+		m_desiredVelocity = velTarget;
+		m_kd = kd;
+	}
+
+	virtual void setPositionTarget(btScalar posTarget, btScalar kp = 1.f)
+	{
+		m_desiredPosition = posTarget;
+		m_kp = kp;
+	}
+
+	virtual void setErp(btScalar erp)
+	{
+		m_erp = erp;
+	}
+	virtual btScalar getErp() const
+	{
+		return m_erp;
+	}
+	virtual void setRhsClamp(btScalar rhsClamp)
+	{
+		m_rhsClamp = rhsClamp;
+	}
+	virtual void debugDraw(class btIDebugDraw* drawer)
+	{
+		//todo(erwincoumans)
+	}
+};
+
+#endif  //BT_MULTIBODY_JOINT_MOTOR_H
diff --git a/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyLink.h b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyLink.h
new file mode 100644
index 00000000..5a142934
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyLink.h
@@ -0,0 +1,303 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_MULTIBODY_LINK_H
+#define BT_MULTIBODY_LINK_H
+
+#include "LinearMath/btQuaternion.h"
+#include "LinearMath/btVector3.h"
+#include "BulletCollision/CollisionDispatch/btCollisionObject.h"
+
+enum btMultiBodyLinkFlags
+{
+	BT_MULTIBODYLINKFLAGS_DISABLE_PARENT_COLLISION = 1,
+	BT_MULTIBODYLINKFLAGS_DISABLE_ALL_PARENT_COLLISION = 2,
+};
+
+//both defines are now permanently enabled
+#define BT_MULTIBODYLINK_INCLUDE_PLANAR_JOINTS
+#define TEST_SPATIAL_ALGEBRA_LAYER
+
+//
+// Various spatial helper functions
+//
+
+//namespace {
+
+#include "LinearMath/btSpatialAlgebra.h"
+
+//}
+
+//
+// Link struct
+//
+
+struct btMultibodyLink
+{
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btScalar m_mass;           // mass of link
+	btVector3 m_inertiaLocal;  // inertia of link (local frame; diagonal)
+
+	int m_parent;  // index of the parent link (assumed to be < index of this link), or -1 if parent is the base link.
+
+	btQuaternion m_zeroRotParentToThis;  // rotates vectors in parent-frame to vectors in local-frame (when q=0). constant.
+
+	btVector3 m_dVector;  // vector from the inboard joint pos to this link's COM. (local frame.) constant.
+						  //this is set to zero for planar joint (see also m_eVector comment)
+
+	// m_eVector is constant, but depends on the joint type:
+	// revolute, fixed, prismatic, spherical: vector from parent's COM to the pivot point, in PARENT's frame.
+	// planar: vector from COM of parent to COM of this link, WHEN Q = 0. (local frame.)
+	// todo: fix the planar so it is consistent with the other joints
+
+	btVector3 m_eVector;
+
+	btSpatialMotionVector m_absFrameTotVelocity, m_absFrameLocVelocity;
+
+	enum eFeatherstoneJointType
+	{
+		eRevolute = 0,
+		ePrismatic = 1,
+		eSpherical = 2,
+		ePlanar = 3,
+		eFixed = 4,
+		eInvalid
+	};
+
+	// "axis" = spatial joint axis (Mirtich Defn 9 p104). (expressed in local frame.) constant.
+	// for prismatic: m_axesTop[0] = zero;
+	//                m_axesBottom[0] = unit vector along the joint axis.
+	// for revolute: m_axesTop[0] = unit vector along the rotation axis (u);
+	//               m_axesBottom[0] = u cross m_dVector (i.e. COM linear motion due to the rotation at the joint)
+	//
+	// for spherical: m_axesTop[0][1][2] (u1,u2,u3) form a 3x3 identity matrix (3 rotation axes)
+	//				  m_axesBottom[0][1][2] cross u1,u2,u3 (i.e. COM linear motion due to the rotation at the joint)
+	//
+	// for planar: m_axesTop[0] = unit vector along the rotation axis (u); defines the plane of motion
+	//			   m_axesTop[1][2] = zero
+	//			   m_axesBottom[0] = zero
+	//			   m_axesBottom[1][2] = unit vectors along the translational axes on that plane
+	btSpatialMotionVector m_axes[6];
+	void setAxisTop(int dof, const btVector3 &axis) { m_axes[dof].m_topVec = axis; }
+	void setAxisBottom(int dof, const btVector3 &axis)
+	{
+		m_axes[dof].m_bottomVec = axis;
+	}
+	void setAxisTop(int dof, const btScalar &x, const btScalar &y, const btScalar &z)
+	{
+		m_axes[dof].m_topVec.setValue(x, y, z);
+	}
+	void setAxisBottom(int dof, const btScalar &x, const btScalar &y, const btScalar &z)
+	{
+		m_axes[dof].m_bottomVec.setValue(x, y, z);
+	}
+	const btVector3 &getAxisTop(int dof) const { return m_axes[dof].m_topVec; }
+	const btVector3 &getAxisBottom(int dof) const { return m_axes[dof].m_bottomVec; }
+
+	int m_dofOffset, m_cfgOffset;
+
+	btQuaternion m_cachedRotParentToThis;  // rotates vectors in parent frame to vectors in local frame
+	btVector3 m_cachedRVector;             // vector from COM of parent to COM of this link, in local frame.
+    
+    // predicted verstion
+    btQuaternion m_cachedRotParentToThis_interpolate;  // rotates vectors in parent frame to vectors in local frame
+    btVector3 m_cachedRVector_interpolate;             // vector from COM of parent to COM of this link, in local frame.
+
+	btVector3 m_appliedForce;   // In WORLD frame
+	btVector3 m_appliedTorque;  // In WORLD frame
+
+	btVector3 m_appliedConstraintForce;   // In WORLD frame
+	btVector3 m_appliedConstraintTorque;  // In WORLD frame
+
+	btScalar m_jointPos[7];
+    btScalar m_jointPos_interpolate[7];
+
+	//m_jointTorque is the joint torque applied by the user using 'addJointTorque'.
+	//It gets set to zero after each internal stepSimulation call
+	btScalar m_jointTorque[6];
+
+	class btMultiBodyLinkCollider *m_collider;
+	int m_flags;
+
+	int m_dofCount, m_posVarCount;  //redundant but handy
+
+	eFeatherstoneJointType m_jointType;
+
+	struct btMultiBodyJointFeedback *m_jointFeedback;
+
+	btTransform m_cachedWorldTransform;  //this cache is updated when calling btMultiBody::forwardKinematics
+
+	const char *m_linkName;   //m_linkName memory needs to be managed by the developer/user!
+	const char *m_jointName;  //m_jointName memory needs to be managed by the developer/user!
+	const void *m_userPtr;    //m_userPtr ptr needs to be managed by the developer/user!
+
+	btScalar m_jointDamping;      //todo: implement this internally. It is unused for now, it is set by a URDF loader. User can apply manual damping.
+	btScalar m_jointFriction;     //todo: implement this internally. It is unused for now, it is set by a URDF loader. User can apply manual friction using a velocity motor.
+	btScalar m_jointLowerLimit;   //todo: implement this internally. It is unused for now, it is set by a URDF loader.
+	btScalar m_jointUpperLimit;   //todo: implement this internally. It is unused for now, it is set by a URDF loader.
+	btScalar m_jointMaxForce;     //todo: implement this internally. It is unused for now, it is set by a URDF loader.
+	btScalar m_jointMaxVelocity;  //todo: implement this internally. It is unused for now, it is set by a URDF loader.
+
+	// ctor: set some sensible defaults
+	btMultibodyLink()
+		: m_mass(1),
+		  m_parent(-1),
+		  m_zeroRotParentToThis(0, 0, 0, 1),
+		  m_cachedRotParentToThis(0, 0, 0, 1),
+          m_cachedRotParentToThis_interpolate(0, 0, 0, 1),
+		  m_collider(0),
+		  m_flags(0),
+		  m_dofCount(0),
+		  m_posVarCount(0),
+		  m_jointType(btMultibodyLink::eInvalid),
+		  m_jointFeedback(0),
+		  m_linkName(0),
+		  m_jointName(0),
+		  m_userPtr(0),
+		  m_jointDamping(0),
+		  m_jointFriction(0),
+		  m_jointLowerLimit(0),
+		  m_jointUpperLimit(0),
+		  m_jointMaxForce(0),
+		  m_jointMaxVelocity(0)
+	{
+		m_inertiaLocal.setValue(1, 1, 1);
+		setAxisTop(0, 0., 0., 0.);
+		setAxisBottom(0, 1., 0., 0.);
+		m_dVector.setValue(0, 0, 0);
+		m_eVector.setValue(0, 0, 0);
+		m_cachedRVector.setValue(0, 0, 0);
+        m_cachedRVector_interpolate.setValue(0, 0, 0);
+		m_appliedForce.setValue(0, 0, 0);
+		m_appliedTorque.setValue(0, 0, 0);
+		m_appliedConstraintForce.setValue(0, 0, 0);
+		m_appliedConstraintTorque.setValue(0, 0, 0);
+		//
+		m_jointPos[0] = m_jointPos[1] = m_jointPos[2] = m_jointPos[4] = m_jointPos[5] = m_jointPos[6] = 0.f;
+		m_jointPos[3] = 1.f;  //"quat.w"
+		m_jointTorque[0] = m_jointTorque[1] = m_jointTorque[2] = m_jointTorque[3] = m_jointTorque[4] = m_jointTorque[5] = 0.f;
+		m_cachedWorldTransform.setIdentity();
+	}
+
+	// routine to update m_cachedRotParentToThis and m_cachedRVector
+	void updateCacheMultiDof(btScalar *pq = 0)
+	{
+        btScalar *pJointPos = (pq ? pq : &m_jointPos[0]);
+        btQuaternion& cachedRot = m_cachedRotParentToThis;
+        btVector3& cachedVector = m_cachedRVector;
+		switch (m_jointType)
+		{
+			case eRevolute:
+			{
+				cachedRot = btQuaternion(getAxisTop(0), -pJointPos[0]) * m_zeroRotParentToThis;
+				cachedVector = m_dVector + quatRotate(m_cachedRotParentToThis, m_eVector);
+
+				break;
+			}
+			case ePrismatic:
+			{
+				// m_cachedRotParentToThis never changes, so no need to update
+				cachedVector = m_dVector + quatRotate(m_cachedRotParentToThis, m_eVector) + pJointPos[0] * getAxisBottom(0);
+
+				break;
+			}
+			case eSpherical:
+			{
+				cachedRot = btQuaternion(pJointPos[0], pJointPos[1], pJointPos[2], -pJointPos[3]) * m_zeroRotParentToThis;
+				cachedVector = m_dVector + quatRotate(cachedRot, m_eVector);
+
+				break;
+			}
+			case ePlanar:
+			{
+				cachedRot = btQuaternion(getAxisTop(0), -pJointPos[0]) * m_zeroRotParentToThis;
+				cachedVector = quatRotate(btQuaternion(getAxisTop(0), -pJointPos[0]), pJointPos[1] * getAxisBottom(1) + pJointPos[2] * getAxisBottom(2)) + quatRotate(cachedRot, m_eVector);
+
+				break;
+			}
+			case eFixed:
+			{
+				cachedRot = m_zeroRotParentToThis;
+				cachedVector = m_dVector + quatRotate(cachedRot, m_eVector);
+
+				break;
+			}
+			default:
+			{
+				//invalid type
+				btAssert(0);
+			}
+		}
+        m_cachedRotParentToThis_interpolate = m_cachedRotParentToThis;
+        m_cachedRVector_interpolate = m_cachedRVector;
+	}
+    
+    void updateInterpolationCacheMultiDof()
+    {
+        btScalar *pJointPos = &m_jointPos_interpolate[0];
+        
+        btQuaternion& cachedRot = m_cachedRotParentToThis_interpolate;
+        btVector3& cachedVector = m_cachedRVector_interpolate;
+        switch (m_jointType)
+        {
+            case eRevolute:
+            {
+                cachedRot = btQuaternion(getAxisTop(0), -pJointPos[0]) * m_zeroRotParentToThis;
+                cachedVector = m_dVector + quatRotate(m_cachedRotParentToThis, m_eVector);
+                
+                break;
+            }
+            case ePrismatic:
+            {
+                // m_cachedRotParentToThis never changes, so no need to update
+                cachedVector = m_dVector + quatRotate(m_cachedRotParentToThis, m_eVector) + pJointPos[0] * getAxisBottom(0);
+                
+                break;
+            }
+            case eSpherical:
+            {
+                cachedRot = btQuaternion(pJointPos[0], pJointPos[1], pJointPos[2], -pJointPos[3]) * m_zeroRotParentToThis;
+                cachedVector = m_dVector + quatRotate(cachedRot, m_eVector);
+                
+                break;
+            }
+            case ePlanar:
+            {
+                cachedRot = btQuaternion(getAxisTop(0), -pJointPos[0]) * m_zeroRotParentToThis;
+                cachedVector = quatRotate(btQuaternion(getAxisTop(0), -pJointPos[0]), pJointPos[1] * getAxisBottom(1) + pJointPos[2] * getAxisBottom(2)) + quatRotate(cachedRot, m_eVector);
+                
+                break;
+            }
+            case eFixed:
+            {
+                cachedRot = m_zeroRotParentToThis;
+                cachedVector = m_dVector + quatRotate(cachedRot, m_eVector);
+                
+                break;
+            }
+            default:
+            {
+                //invalid type
+                btAssert(0);
+            }
+        }
+    }
+
+ 
+
+};
+
+#endif  //BT_MULTIBODY_LINK_H
diff --git a/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyLinkCollider.h b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyLinkCollider.h
new file mode 100644
index 00000000..3dc35a58
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyLinkCollider.h
@@ -0,0 +1,195 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_FEATHERSTONE_LINK_COLLIDER_H
+#define BT_FEATHERSTONE_LINK_COLLIDER_H
+
+#include "BulletCollision/CollisionDispatch/btCollisionObject.h"
+
+#include "btMultiBody.h"
+#include "LinearMath/btSerializer.h"
+
+#ifdef BT_USE_DOUBLE_PRECISION
+#define btMultiBodyLinkColliderData btMultiBodyLinkColliderDoubleData
+#define btMultiBodyLinkColliderDataName "btMultiBodyLinkColliderDoubleData"
+#else
+#define btMultiBodyLinkColliderData btMultiBodyLinkColliderFloatData
+#define btMultiBodyLinkColliderDataName "btMultiBodyLinkColliderFloatData"
+#endif
+
+class btMultiBodyLinkCollider : public btCollisionObject
+{
+	//protected:
+public:
+	btMultiBody* m_multiBody;
+	int m_link;
+
+	virtual ~btMultiBodyLinkCollider()
+	{
+
+	}
+	btMultiBodyLinkCollider(btMultiBody* multiBody, int link)
+		: m_multiBody(multiBody),
+		  m_link(link)
+	{
+		m_checkCollideWith = true;
+		//we need to remove the 'CF_STATIC_OBJECT' flag, otherwise links/base doesn't merge islands
+		//this means that some constraints might point to bodies that are not in the islands, causing crashes
+		//if (link>=0 || (multiBody && !multiBody->hasFixedBase()))
+		{
+			m_collisionFlags &= (~btCollisionObject::CF_STATIC_OBJECT);
+		}
+		// else
+		//{
+		//	m_collisionFlags |= (btCollisionObject::CF_STATIC_OBJECT);
+		//}
+
+		m_internalType = CO_FEATHERSTONE_LINK;
+	}
+	static btMultiBodyLinkCollider* upcast(btCollisionObject* colObj)
+	{
+		if (colObj->getInternalType() & btCollisionObject::CO_FEATHERSTONE_LINK)
+			return (btMultiBodyLinkCollider*)colObj;
+		return 0;
+	}
+	static const btMultiBodyLinkCollider* upcast(const btCollisionObject* colObj)
+	{
+		if (colObj->getInternalType() & btCollisionObject::CO_FEATHERSTONE_LINK)
+			return (btMultiBodyLinkCollider*)colObj;
+		return 0;
+	}
+
+	virtual bool checkCollideWithOverride(const btCollisionObject* co) const
+	{
+		const btMultiBodyLinkCollider* other = btMultiBodyLinkCollider::upcast(co);
+		if (!other)
+			return true;
+		if (other->m_multiBody != this->m_multiBody)
+			return true;
+		if (!m_multiBody->hasSelfCollision())
+			return false;
+
+		//check if 'link' has collision disabled
+		if (m_link >= 0)
+		{
+			const btMultibodyLink& link = m_multiBody->getLink(this->m_link);
+			if (link.m_flags & BT_MULTIBODYLINKFLAGS_DISABLE_ALL_PARENT_COLLISION)
+			{
+				int parent_of_this = m_link;
+				while (1)
+				{
+					if (parent_of_this == -1)
+						break;
+					parent_of_this = m_multiBody->getLink(parent_of_this).m_parent;
+					if (parent_of_this == other->m_link)
+					{
+						return false;
+					}
+				}
+			}
+			else if (link.m_flags & BT_MULTIBODYLINKFLAGS_DISABLE_PARENT_COLLISION)
+			{
+				if (link.m_parent == other->m_link)
+					return false;
+			}
+		}
+
+		if (other->m_link >= 0)
+		{
+			const btMultibodyLink& otherLink = other->m_multiBody->getLink(other->m_link);
+			if (otherLink.m_flags & BT_MULTIBODYLINKFLAGS_DISABLE_ALL_PARENT_COLLISION)
+			{
+				int parent_of_other = other->m_link;
+				while (1)
+				{
+					if (parent_of_other == -1)
+						break;
+					parent_of_other = m_multiBody->getLink(parent_of_other).m_parent;
+					if (parent_of_other == this->m_link)
+						return false;
+				}
+			}
+			else if (otherLink.m_flags & BT_MULTIBODYLINKFLAGS_DISABLE_PARENT_COLLISION)
+			{
+				if (otherLink.m_parent == this->m_link)
+					return false;
+			}
+		}
+		return true;
+	}
+
+	bool isStaticOrKinematic() const
+	{
+		return isStaticOrKinematicObject();
+	}
+
+	bool isKinematic() const
+	{
+		return isKinematicObject();
+	}
+
+	void setDynamicType(int dynamicType)
+	{
+		int oldFlags = getCollisionFlags();
+		oldFlags &= ~(btCollisionObject::CF_STATIC_OBJECT | btCollisionObject::CF_KINEMATIC_OBJECT);
+		setCollisionFlags(oldFlags | dynamicType);
+	}
+
+	virtual int calculateSerializeBufferSize() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	virtual const char* serialize(void* dataBuffer, class btSerializer* serializer) const;
+};
+
+// clang-format off
+
+struct	btMultiBodyLinkColliderFloatData
+{
+	btCollisionObjectFloatData m_colObjData;
+	btMultiBodyFloatData	*m_multiBody;
+	int			m_link;
+	char		m_padding[4];
+};
+
+struct	btMultiBodyLinkColliderDoubleData
+{
+	btCollisionObjectDoubleData m_colObjData;
+	btMultiBodyDoubleData		*m_multiBody;
+	int			m_link;
+	char		m_padding[4];
+};
+
+// clang-format on
+
+SIMD_FORCE_INLINE int btMultiBodyLinkCollider::calculateSerializeBufferSize() const
+{
+	return sizeof(btMultiBodyLinkColliderData);
+}
+
+SIMD_FORCE_INLINE const char* btMultiBodyLinkCollider::serialize(void* dataBuffer, class btSerializer* serializer) const
+{
+	btMultiBodyLinkColliderData* dataOut = (btMultiBodyLinkColliderData*)dataBuffer;
+	btCollisionObject::serialize(&dataOut->m_colObjData, serializer);
+
+	dataOut->m_link = this->m_link;
+	dataOut->m_multiBody = (btMultiBodyData*)serializer->getUniquePointer(m_multiBody);
+
+	// Fill padding with zeros to appease msan.
+	memset(dataOut->m_padding, 0, sizeof(dataOut->m_padding));
+
+	return btMultiBodyLinkColliderDataName;
+}
+
+#endif  //BT_FEATHERSTONE_LINK_COLLIDER_H
diff --git a/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyMLCPConstraintSolver.h b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyMLCPConstraintSolver.h
new file mode 100644
index 00000000..77fdb86b
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyMLCPConstraintSolver.h
@@ -0,0 +1,187 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2018 Google Inc. http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_MULTIBODY_MLCP_CONSTRAINT_SOLVER_H
+#define BT_MULTIBODY_MLCP_CONSTRAINT_SOLVER_H
+
+#include "LinearMath/btMatrixX.h"
+#include "LinearMath/btThreads.h"
+#include "BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h"
+
+class btMLCPSolverInterface;
+class btMultiBody;
+
+class btMultiBodyMLCPConstraintSolver : public btMultiBodyConstraintSolver
+{
+protected:
+	/// \name MLCP Formulation for Rigid Bodies
+	/// \{
+
+	/// A matrix in the MLCP formulation
+	btMatrixXu m_A;
+
+	/// b vector in the MLCP formulation.
+	btVectorXu m_b;
+
+	/// Constraint impulse, which is an output of MLCP solving.
+	btVectorXu m_x;
+
+	/// Lower bound of constraint impulse, \c m_x.
+	btVectorXu m_lo;
+
+	/// Upper bound of constraint impulse, \c m_x.
+	btVectorXu m_hi;
+
+	/// \}
+
+	/// \name Cache Variables for Split Impulse for Rigid Bodies
+	/// When using 'split impulse' we solve two separate (M)LCPs
+	/// \{
+
+	/// Split impulse Cache vector corresponding to \c m_b.
+	btVectorXu m_bSplit;
+
+	/// Split impulse cache vector corresponding to \c m_x.
+	btVectorXu m_xSplit;
+
+	/// \}
+
+	/// \name MLCP Formulation for Multibodies
+	/// \{
+
+	/// A matrix in the MLCP formulation
+	btMatrixXu m_multiBodyA;
+
+	/// b vector in the MLCP formulation.
+	btVectorXu m_multiBodyB;
+
+	/// Constraint impulse, which is an output of MLCP solving.
+	btVectorXu m_multiBodyX;
+
+	/// Lower bound of constraint impulse, \c m_x.
+	btVectorXu m_multiBodyLo;
+
+	/// Upper bound of constraint impulse, \c m_x.
+	btVectorXu m_multiBodyHi;
+
+	/// \}
+
+	/// Indices of normal contact constraint associated with frictional contact constraint for rigid bodies.
+	///
+	/// This is used by the MLCP solver to update the upper bounds of frictional contact impulse given intermediate
+	/// normal contact impulse. For example, i-th element represents the index of a normal constraint that is
+	/// accosiated with i-th frictional contact constraint if i-th constraint is a frictional contact constraint.
+	/// Otherwise, -1.
+	btAlignedObjectArray<int> m_limitDependencies;
+
+	/// Indices of normal contact constraint associated with frictional contact constraint for multibodies.
+	///
+	/// This is used by the MLCP solver to update the upper bounds of frictional contact impulse given intermediate
+	/// normal contact impulse. For example, i-th element represents the index of a normal constraint that is
+	/// accosiated with i-th frictional contact constraint if i-th constraint is a frictional contact constraint.
+	/// Otherwise, -1.
+	btAlignedObjectArray<int> m_multiBodyLimitDependencies;
+
+	/// Array of all the rigid body constraints
+	btAlignedObjectArray<btSolverConstraint*> m_allConstraintPtrArray;
+
+	/// Array of all the multibody constraints
+	btAlignedObjectArray<btMultiBodySolverConstraint*> m_multiBodyAllConstraintPtrArray;
+
+	/// MLCP solver
+	btMLCPSolverInterface* m_solver;
+
+	/// Count of fallbacks of using btSequentialImpulseConstraintSolver, which happens when the MLCP solver fails.
+	int m_fallback;
+
+	/// \name MLCP Scratch Variables
+	/// The following scratch variables are not stateful -- contents are cleared prior to each use.
+	/// They are only cached here to avoid extra memory allocations and deallocations and to ensure
+	/// that multiple instances of the solver can be run in parallel.
+	///
+	/// \{
+
+	/// Cache variable for constraint Jacobian matrix.
+	btMatrixXu m_scratchJ3;
+
+	/// Cache variable for constraint Jacobian times inverse mass matrix.
+	btMatrixXu m_scratchJInvM3;
+
+	/// Cache variable for offsets.
+	btAlignedObjectArray<int> m_scratchOfs;
+
+	/// \}
+
+	/// Constructs MLCP terms, which are \c m_A, \c m_b, \c m_lo, and \c m_hi.
+	virtual void createMLCPFast(const btContactSolverInfo& infoGlobal);
+
+	/// Constructs MLCP terms for constraints of two rigid bodies
+	void createMLCPFastRigidBody(const btContactSolverInfo& infoGlobal);
+
+	/// Constructs MLCP terms for constraints of two multi-bodies or one rigid body and one multibody
+	void createMLCPFastMultiBody(const btContactSolverInfo& infoGlobal);
+
+	/// Solves MLCP and returns the success
+	virtual bool solveMLCP(const btContactSolverInfo& infoGlobal);
+
+	// Documentation inherited
+	btScalar solveGroupCacheFriendlySetup(
+		btCollisionObject** bodies,
+		int numBodies,
+		btPersistentManifold** manifoldPtr,
+		int numManifolds,
+		btTypedConstraint** constraints,
+		int numConstraints,
+		const btContactSolverInfo& infoGlobal,
+		btIDebugDraw* debugDrawer) BT_OVERRIDE;
+
+	// Documentation inherited
+	btScalar solveGroupCacheFriendlyIterations(
+		btCollisionObject** bodies,
+		int numBodies,
+		btPersistentManifold** manifoldPtr,
+		int numManifolds,
+		btTypedConstraint** constraints,
+		int numConstraints,
+		const btContactSolverInfo& infoGlobal,
+		btIDebugDraw* debugDrawer) ;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR()
+
+	/// Constructor
+	///
+	/// \param[in] solver MLCP solver. Assumed it's not null.
+	/// \param[in] maxLCPSize Maximum size of LCP to solve using MLCP solver. If the MLCP size exceeds this number, sequaltial impulse method will be used.
+	explicit btMultiBodyMLCPConstraintSolver(btMLCPSolverInterface* solver);
+
+	/// Destructor
+	virtual ~btMultiBodyMLCPConstraintSolver();
+
+	/// Sets MLCP solver. Assumed it's not null.
+	void setMLCPSolver(btMLCPSolverInterface* solver);
+
+	/// Returns the number of fallbacks of using btSequentialImpulseConstraintSolver, which happens when the MLCP
+	/// solver fails.
+	int getNumFallbacks() const;
+
+	/// Sets the number of fallbacks. This function may be used to reset the number to zero.
+	void setNumFallbacks(int num);
+
+	/// Returns the constraint solver type.
+	virtual btConstraintSolverType getSolverType() const;
+};
+
+#endif  // BT_MULTIBODY_MLCP_CONSTRAINT_SOLVER_H
diff --git a/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyPoint2Point.h b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyPoint2Point.h
new file mode 100644
index 00000000..ef03a557
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodyPoint2Point.h
@@ -0,0 +1,64 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+///This file was written by Erwin Coumans
+
+#ifndef BT_MULTIBODY_POINT2POINT_H
+#define BT_MULTIBODY_POINT2POINT_H
+
+#include "btMultiBodyConstraint.h"
+
+//#define BTMBP2PCONSTRAINT_BLOCK_ANGULAR_MOTION_TEST
+
+ATTRIBUTE_ALIGNED16(class)
+btMultiBodyPoint2Point : public btMultiBodyConstraint
+{
+protected:
+	btRigidBody* m_rigidBodyA;
+	btRigidBody* m_rigidBodyB;
+	btVector3 m_pivotInA;
+	btVector3 m_pivotInB;
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btMultiBodyPoint2Point(btMultiBody * body, int link, btRigidBody* bodyB, const btVector3& pivotInA, const btVector3& pivotInB);
+	btMultiBodyPoint2Point(btMultiBody * bodyA, int linkA, btMultiBody* bodyB, int linkB, const btVector3& pivotInA, const btVector3& pivotInB);
+
+	virtual ~btMultiBodyPoint2Point();
+
+	virtual void finalizeMultiDof();
+
+	virtual int getIslandIdA() const;
+	virtual int getIslandIdB() const;
+
+	virtual void createConstraintRows(btMultiBodyConstraintArray & constraintRows,
+									  btMultiBodyJacobianData & data,
+									  const btContactSolverInfo& infoGlobal);
+
+	const btVector3& getPivotInB() const
+	{
+		return m_pivotInB;
+	}
+
+	virtual void setPivotInB(const btVector3& pivotInB)
+	{
+		m_pivotInB = pivotInB;
+	}
+
+	virtual void debugDraw(class btIDebugDraw * drawer);
+};
+
+#endif  //BT_MULTIBODY_POINT2POINT_H
diff --git a/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodySliderConstraint.h b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodySliderConstraint.h
new file mode 100644
index 00000000..b192b6f8
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodySliderConstraint.h
@@ -0,0 +1,102 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+///This file was written by Erwin Coumans
+
+#ifndef BT_MULTIBODY_SLIDER_CONSTRAINT_H
+#define BT_MULTIBODY_SLIDER_CONSTRAINT_H
+
+#include "btMultiBodyConstraint.h"
+
+class btMultiBodySliderConstraint : public btMultiBodyConstraint
+{
+protected:
+	btRigidBody* m_rigidBodyA;
+	btRigidBody* m_rigidBodyB;
+	btVector3 m_pivotInA;
+	btVector3 m_pivotInB;
+	btMatrix3x3 m_frameInA;
+	btMatrix3x3 m_frameInB;
+	btVector3 m_jointAxis;
+
+public:
+	btMultiBodySliderConstraint(btMultiBody* body, int link, btRigidBody* bodyB, const btVector3& pivotInA, const btVector3& pivotInB, const btMatrix3x3& frameInA, const btMatrix3x3& frameInB, const btVector3& jointAxis);
+	btMultiBodySliderConstraint(btMultiBody* bodyA, int linkA, btMultiBody* bodyB, int linkB, const btVector3& pivotInA, const btVector3& pivotInB, const btMatrix3x3& frameInA, const btMatrix3x3& frameInB, const btVector3& jointAxis);
+
+	virtual ~btMultiBodySliderConstraint();
+
+	virtual void finalizeMultiDof();
+
+	virtual int getIslandIdA() const;
+	virtual int getIslandIdB() const;
+
+	virtual void createConstraintRows(btMultiBodyConstraintArray& constraintRows,
+									  btMultiBodyJacobianData& data,
+									  const btContactSolverInfo& infoGlobal);
+
+	const btVector3& getPivotInA() const
+	{
+		return m_pivotInA;
+	}
+
+	void setPivotInA(const btVector3& pivotInA)
+	{
+		m_pivotInA = pivotInA;
+	}
+
+	const btVector3& getPivotInB() const
+	{
+		return m_pivotInB;
+	}
+
+	virtual void setPivotInB(const btVector3& pivotInB)
+	{
+		m_pivotInB = pivotInB;
+	}
+
+	const btMatrix3x3& getFrameInA() const
+	{
+		return m_frameInA;
+	}
+
+	void setFrameInA(const btMatrix3x3& frameInA)
+	{
+		m_frameInA = frameInA;
+	}
+
+	const btMatrix3x3& getFrameInB() const
+	{
+		return m_frameInB;
+	}
+
+	virtual void setFrameInB(const btMatrix3x3& frameInB)
+	{
+		m_frameInB = frameInB;
+	}
+
+	const btVector3& getJointAxis() const
+	{
+		return m_jointAxis;
+	}
+
+	void setJointAxis(const btVector3& jointAxis)
+	{
+		m_jointAxis = jointAxis;
+	}
+
+	virtual void debugDraw(class btIDebugDraw* drawer);
+};
+
+#endif  //BT_MULTIBODY_SLIDER_CONSTRAINT_H
diff --git a/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodySolverConstraint.h b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodySolverConstraint.h
new file mode 100644
index 00000000..deed3e2a
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodySolverConstraint.h
@@ -0,0 +1,90 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_MULTIBODY_SOLVER_CONSTRAINT_H
+#define BT_MULTIBODY_SOLVER_CONSTRAINT_H
+
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btAlignedObjectArray.h"
+
+class btMultiBody;
+class btMultiBodyConstraint;
+#include "BulletDynamics/ConstraintSolver/btSolverBody.h"
+#include "BulletDynamics/ConstraintSolver/btContactSolverInfo.h"
+
+///1D constraint along a normal axis between bodyA and bodyB. It can be combined to solve contact and friction constraints.
+ATTRIBUTE_ALIGNED16(struct)
+btMultiBodySolverConstraint
+{
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btMultiBodySolverConstraint() : m_solverBodyIdA(-1), m_multiBodyA(0), m_linkA(-1), m_solverBodyIdB(-1), m_multiBodyB(0), m_linkB(-1), m_orgConstraint(0), m_orgDofIndex(-1)
+	{
+	}
+
+	int m_deltaVelAindex;  //more generic version of m_relpos1CrossNormal/m_contactNormal1
+	int m_jacAindex;
+	int m_deltaVelBindex;
+	int m_jacBindex;
+
+	btVector3 m_relpos1CrossNormal;
+	btVector3 m_contactNormal1;
+	btVector3 m_relpos2CrossNormal;
+	btVector3 m_contactNormal2;  //usually m_contactNormal2 == -m_contactNormal1, but not always
+
+	btVector3 m_angularComponentA;
+	btVector3 m_angularComponentB;
+
+	mutable btSimdScalar m_appliedPushImpulse;
+	mutable btSimdScalar m_appliedImpulse;
+
+	btScalar m_friction;
+	btScalar m_jacDiagABInv;
+	btScalar m_rhs;
+	btScalar m_cfm;
+
+	btScalar m_lowerLimit;
+	btScalar m_upperLimit;
+	btScalar m_rhsPenetration;
+	union {
+		void* m_originalContactPoint;
+		btScalar m_unusedPadding4;
+	};
+
+	int m_overrideNumSolverIterations;
+	int m_frictionIndex;
+
+	int m_solverBodyIdA;
+	btMultiBody* m_multiBodyA;
+	int m_linkA;
+
+	int m_solverBodyIdB;
+	btMultiBody* m_multiBodyB;
+	int m_linkB;
+
+	//for writing back applied impulses
+	btMultiBodyConstraint* m_orgConstraint;
+	int m_orgDofIndex;
+
+	enum btSolverConstraintType
+	{
+		BT_SOLVER_CONTACT_1D = 0,
+		BT_SOLVER_FRICTION_1D
+	};
+};
+
+typedef btAlignedObjectArray<btMultiBodySolverConstraint> btMultiBodyConstraintArray;
+
+#endif  //BT_MULTIBODY_SOLVER_CONSTRAINT_H
diff --git a/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodySphericalJointMotor.h b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodySphericalJointMotor.h
new file mode 100644
index 00000000..621beab5
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/Featherstone/btMultiBodySphericalJointMotor.h
@@ -0,0 +1,77 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2018 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+///This file was written by Erwin Coumans
+
+#ifndef BT_MULTIBODY_SPHERICAL_JOINT_MOTOR_H
+#define BT_MULTIBODY_SPHERICAL_JOINT_MOTOR_H
+
+#include "btMultiBodyConstraint.h"
+struct btSolverInfo;
+
+class btMultiBodySphericalJointMotor : public btMultiBodyConstraint
+{
+protected:
+	btVector3 m_desiredVelocity;
+	btQuaternion m_desiredPosition;
+	btScalar m_kd;
+	btScalar m_kp;
+	btScalar m_erp;
+	btScalar m_rhsClamp;  //maximum error
+
+public:
+	btMultiBodySphericalJointMotor(btMultiBody* body, int link, btScalar maxMotorImpulse);
+	
+	virtual ~btMultiBodySphericalJointMotor();
+	virtual void finalizeMultiDof();
+
+	virtual int getIslandIdA() const;
+	virtual int getIslandIdB() const;
+
+	virtual void createConstraintRows(btMultiBodyConstraintArray& constraintRows,
+									  btMultiBodyJacobianData& data,
+									  const btContactSolverInfo& infoGlobal);
+
+	virtual void setVelocityTarget(const btVector3& velTarget, btScalar kd = 1.f)
+	{
+		m_desiredVelocity = velTarget;
+		m_kd = kd;
+	}
+
+	virtual void setPositionTarget(const btQuaternion& posTarget, btScalar kp = 1.f)
+	{
+		m_desiredPosition = posTarget;
+		m_kp = kp;
+	}
+
+	virtual void setErp(btScalar erp)
+	{
+		m_erp = erp;
+	}
+	virtual btScalar getErp() const
+	{
+		return m_erp;
+	}
+	virtual void setRhsClamp(btScalar rhsClamp)
+	{
+		m_rhsClamp = rhsClamp;
+	}
+	virtual void debugDraw(class btIDebugDraw* drawer)
+	{
+		//todo(erwincoumans)
+	}
+};
+
+#endif  //BT_MULTIBODY_SPHERICAL_JOINT_MOTOR_H
diff --git a/engine/inc/bullet/BulletDynamics/MLCPSolvers/btDantzigLCP.h b/engine/inc/bullet/BulletDynamics/MLCPSolvers/btDantzigLCP.h
new file mode 100644
index 00000000..8d9b2a13
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/MLCPSolvers/btDantzigLCP.h
@@ -0,0 +1,73 @@
+/*************************************************************************
+ *                                                                       *
+ * Open Dynamics Engine, Copyright (C) 2001,2002 Russell L. Smith.       *
+ * All rights reserved.  Email: russ@q12.org   Web: www.q12.org          *
+ *                                                                       *
+ * This library is free software; you can redistribute it and/or         *
+ * modify it under the terms of                                          * 
+ *   The BSD-style license that is included with this library in         *
+ *   the file LICENSE-BSD.TXT.                                           *
+ *                                                                       *
+ * This library is distributed in the hope that it will be useful,       *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files    *
+ * LICENSE.TXT and LICENSE-BSD.TXT for more details.                     *
+ *                                                                       *
+ *************************************************************************/
+
+/*
+
+given (A,b,lo,hi), solve the LCP problem: A*x = b+w, where each x(i),w(i)
+satisfies one of
+	(1) x = lo, w >= 0
+	(2) x = hi, w <= 0
+	(3) lo < x < hi, w = 0
+A is a matrix of dimension n*n, everything else is a vector of size n*1.
+lo and hi can be +/- dInfinity as needed. the first `nub' variables are
+unbounded, i.e. hi and lo are assumed to be +/- dInfinity.
+
+we restrict lo(i) <= 0 and hi(i) >= 0.
+
+the original data (A,b) may be modified by this function.
+
+if the `findex' (friction index) parameter is nonzero, it points to an array
+of index values. in this case constraints that have findex[i] >= 0 are
+special. all non-special constraints are solved for, then the lo and hi values
+for the special constraints are set:
+  hi[i] = abs( hi[i] * x[findex[i]] )
+  lo[i] = -hi[i]
+and the solution continues. this mechanism allows a friction approximation
+to be implemented. the first `nub' variables are assumed to have findex < 0.
+
+*/
+
+#ifndef _BT_LCP_H_
+#define _BT_LCP_H_
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <assert.h>
+
+#include "LinearMath/btScalar.h"
+#include "LinearMath/btAlignedObjectArray.h"
+
+struct btDantzigScratchMemory
+{
+	btAlignedObjectArray<btScalar> m_scratch;
+	btAlignedObjectArray<btScalar> L;
+	btAlignedObjectArray<btScalar> d;
+	btAlignedObjectArray<btScalar> delta_w;
+	btAlignedObjectArray<btScalar> delta_x;
+	btAlignedObjectArray<btScalar> Dell;
+	btAlignedObjectArray<btScalar> ell;
+	btAlignedObjectArray<btScalar *> Arows;
+	btAlignedObjectArray<int> p;
+	btAlignedObjectArray<int> C;
+	btAlignedObjectArray<bool> state;
+};
+
+//return false if solving failed
+bool btSolveDantzigLCP(int n, btScalar *A, btScalar *x, btScalar *b, btScalar *w,
+					   int nub, btScalar *lo, btScalar *hi, int *findex, btDantzigScratchMemory &scratch);
+
+#endif  //_BT_LCP_H_
diff --git a/engine/inc/bullet/BulletDynamics/MLCPSolvers/btDantzigSolver.h b/engine/inc/bullet/BulletDynamics/MLCPSolvers/btDantzigSolver.h
new file mode 100644
index 00000000..1f669751
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/MLCPSolvers/btDantzigSolver.h
@@ -0,0 +1,106 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+///original version written by Erwin Coumans, October 2013
+
+#ifndef BT_DANTZIG_SOLVER_H
+#define BT_DANTZIG_SOLVER_H
+
+#include "btMLCPSolverInterface.h"
+#include "btDantzigLCP.h"
+
+class btDantzigSolver : public btMLCPSolverInterface
+{
+protected:
+	btScalar m_acceptableUpperLimitSolution;
+
+	btAlignedObjectArray<char> m_tempBuffer;
+
+	btAlignedObjectArray<btScalar> m_A;
+	btAlignedObjectArray<btScalar> m_b;
+	btAlignedObjectArray<btScalar> m_x;
+	btAlignedObjectArray<btScalar> m_lo;
+	btAlignedObjectArray<btScalar> m_hi;
+	btAlignedObjectArray<int> m_dependencies;
+	btDantzigScratchMemory m_scratchMemory;
+
+public:
+	btDantzigSolver()
+		: m_acceptableUpperLimitSolution(btScalar(1000))
+	{
+	}
+
+	virtual bool solveMLCP(const btMatrixXu& A, const btVectorXu& b, btVectorXu& x, const btVectorXu& lo, const btVectorXu& hi, const btAlignedObjectArray<int>& limitDependency, int numIterations, bool useSparsity = true)
+	{
+		bool result = true;
+		int n = b.rows();
+		if (n)
+		{
+			int nub = 0;
+			btAlignedObjectArray<btScalar> ww;
+			ww.resize(n);
+
+			const btScalar* Aptr = A.getBufferPointer();
+			m_A.resize(n * n);
+			for (int i = 0; i < n * n; i++)
+			{
+				m_A[i] = Aptr[i];
+			}
+
+			m_b.resize(n);
+			m_x.resize(n);
+			m_lo.resize(n);
+			m_hi.resize(n);
+			m_dependencies.resize(n);
+			for (int i = 0; i < n; i++)
+			{
+				m_lo[i] = lo[i];
+				m_hi[i] = hi[i];
+				m_b[i] = b[i];
+				m_x[i] = x[i];
+				m_dependencies[i] = limitDependency[i];
+			}
+
+			result = btSolveDantzigLCP(n, &m_A[0], &m_x[0], &m_b[0], &ww[0], nub, &m_lo[0], &m_hi[0], &m_dependencies[0], m_scratchMemory);
+			if (!result)
+				return result;
+
+			//			printf("numAllocas = %d\n",numAllocas);
+			for (int i = 0; i < n; i++)
+			{
+				volatile btScalar xx = m_x[i];
+				if (xx != m_x[i])
+					return false;
+				if (x[i] >= m_acceptableUpperLimitSolution)
+				{
+					return false;
+				}
+
+				if (x[i] <= -m_acceptableUpperLimitSolution)
+				{
+					return false;
+				}
+			}
+
+			for (int i = 0; i < n; i++)
+			{
+				x[i] = m_x[i];
+			}
+		}
+
+		return result;
+	}
+};
+
+#endif  //BT_DANTZIG_SOLVER_H
diff --git a/engine/inc/bullet/BulletDynamics/MLCPSolvers/btLemkeAlgorithm.h b/engine/inc/bullet/BulletDynamics/MLCPSolvers/btLemkeAlgorithm.h
new file mode 100644
index 00000000..3c6bf72a
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/MLCPSolvers/btLemkeAlgorithm.h
@@ -0,0 +1,102 @@
+/* Copyright (C) 2004-2013 MBSim Development Team
+
+Code was converted for the Bullet Continuous Collision Detection and Physics Library
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+//The original version is here
+//https://code.google.com/p/mbsim-env/source/browse/trunk/kernel/mbsim/numerics/linear_complementarity_problem/lemke_algorithm.cc
+//This file is re-distributed under the ZLib license, with permission of the original author (Kilian Grundl)
+//Math library was replaced from fmatvec to a the file src/LinearMath/btMatrixX.h
+//STL/std::vector replaced by btAlignedObjectArray
+
+#ifndef BT_NUMERICS_LEMKE_ALGORITHM_H_
+#define BT_NUMERICS_LEMKE_ALGORITHM_H_
+
+#include "LinearMath/btMatrixX.h"
+
+#include <vector>  //todo: replace by btAlignedObjectArray
+
+class btLemkeAlgorithm
+{
+public:
+	btLemkeAlgorithm(const btMatrixXu& M_, const btVectorXu& q_, const int& DEBUGLEVEL_ = 0) : DEBUGLEVEL(DEBUGLEVEL_)
+	{
+		setSystem(M_, q_);
+	}
+
+	/* GETTER / SETTER */
+	/**
+   * \brief return info of solution process
+   */
+	int getInfo()
+	{
+		return info;
+	}
+
+	/**
+   * \brief get the number of steps until the solution was found
+   */
+	int getSteps(void)
+	{
+		return steps;
+	}
+
+	/**
+   * \brief set system with Matrix M and vector q
+   */
+	void setSystem(const btMatrixXu& M_, const btVectorXu& q_)
+	{
+		m_M = M_;
+		m_q = q_;
+	}
+	/***************************************************/
+
+	/**
+   * \brief solve algorithm adapted from : Fast Implementation of Lemke’s Algorithm for Rigid Body Contact Simulation (John E. Lloyd)
+   */
+	btVectorXu solve(unsigned int maxloops = 0);
+
+	virtual ~btLemkeAlgorithm()
+	{
+	}
+
+protected:
+	int findLexicographicMinimum(const btMatrixXu& A, const int& pivotColIndex);
+	bool LexicographicPositive(const btVectorXu& v);
+	void GaussJordanEliminationStep(btMatrixXu& A, int pivotRowIndex, int pivotColumnIndex, const btAlignedObjectArray<int>& basis);
+	bool greaterZero(const btVectorXu& vector);
+	bool validBasis(const btAlignedObjectArray<int>& basis);
+
+	btMatrixXu m_M;
+	btVectorXu m_q;
+
+	/**
+   * \brief number of steps until the Lemke algorithm found a solution
+   */
+	unsigned int steps;
+
+	/**
+   * \brief define level of debug output
+   */
+	int DEBUGLEVEL;
+
+	/**
+   * \brief did the algorithm find a solution
+   *
+   * -1 : not successful
+   *  0 : successful
+   */
+	int info;
+};
+
+#endif /* BT_NUMERICS_LEMKE_ALGORITHM_H_ */
diff --git a/engine/inc/bullet/BulletDynamics/MLCPSolvers/btLemkeSolver.h b/engine/inc/bullet/BulletDynamics/MLCPSolvers/btLemkeSolver.h
new file mode 100644
index 00000000..f18c4ea4
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/MLCPSolvers/btLemkeSolver.h
@@ -0,0 +1,338 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+///original version written by Erwin Coumans, October 2013
+
+#ifndef BT_LEMKE_SOLVER_H
+#define BT_LEMKE_SOLVER_H
+
+#include "btMLCPSolverInterface.h"
+#include "btLemkeAlgorithm.h"
+
+///The btLemkeSolver is based on "Fast Implementation of Lemke’s Algorithm for Rigid Body Contact Simulation (John E. Lloyd) "
+///It is a slower but more accurate solver. Increase the m_maxLoops for better convergence, at the cost of more CPU time.
+///The original implementation of the btLemkeAlgorithm was done by Kilian Grundl from the MBSim team
+class btLemkeSolver : public btMLCPSolverInterface
+{
+protected:
+public:
+	btScalar m_maxValue;
+	int m_debugLevel;
+	int m_maxLoops;
+	bool m_useLoHighBounds;
+
+	btLemkeSolver()
+		: m_maxValue(100000),
+		  m_debugLevel(0),
+		  m_maxLoops(1000),
+		  m_useLoHighBounds(true)
+	{
+	}
+	virtual bool solveMLCP(const btMatrixXu& A, const btVectorXu& b, btVectorXu& x, const btVectorXu& lo, const btVectorXu& hi, const btAlignedObjectArray<int>& limitDependency, int numIterations, bool useSparsity = true)
+	{
+		if (m_useLoHighBounds)
+		{
+			BT_PROFILE("btLemkeSolver::solveMLCP");
+			int n = A.rows();
+			if (0 == n)
+				return true;
+
+			bool fail = false;
+
+			btVectorXu solution(n);
+			btVectorXu q1;
+			q1.resize(n);
+			for (int row = 0; row < n; row++)
+			{
+				q1[row] = -b[row];
+			}
+
+			//		cout << "A" << endl;
+			//		cout << A << endl;
+
+			/////////////////////////////////////
+
+			//slow matrix inversion, replace with LU decomposition
+			btMatrixXu A1;
+			btMatrixXu B(n, n);
+			{
+				//BT_PROFILE("inverse(slow)");
+				A1.resize(A.rows(), A.cols());
+				for (int row = 0; row < A.rows(); row++)
+				{
+					for (int col = 0; col < A.cols(); col++)
+					{
+						A1.setElem(row, col, A(row, col));
+					}
+				}
+
+				btMatrixXu matrix;
+				matrix.resize(n, 2 * n);
+				for (int row = 0; row < n; row++)
+				{
+					for (int col = 0; col < n; col++)
+					{
+						matrix.setElem(row, col, A1(row, col));
+					}
+				}
+
+				btScalar ratio, a;
+				int i, j, k;
+				for (i = 0; i < n; i++)
+				{
+					for (j = n; j < 2 * n; j++)
+					{
+						if (i == (j - n))
+							matrix.setElem(i, j, 1.0);
+						else
+							matrix.setElem(i, j, 0.0);
+					}
+				}
+				for (i = 0; i < n; i++)
+				{
+					for (j = 0; j < n; j++)
+					{
+						if (i != j)
+						{
+							btScalar v = matrix(i, i);
+							if (btFuzzyZero(v))
+							{
+								a = 0.000001f;
+							}
+							ratio = matrix(j, i) / matrix(i, i);
+							for (k = 0; k < 2 * n; k++)
+							{
+								matrix.addElem(j, k, -ratio * matrix(i, k));
+							}
+						}
+					}
+				}
+				for (i = 0; i < n; i++)
+				{
+					a = matrix(i, i);
+					if (btFuzzyZero(a))
+					{
+						a = 0.000001f;
+					}
+					btScalar invA = 1.f / a;
+					for (j = 0; j < 2 * n; j++)
+					{
+						matrix.mulElem(i, j, invA);
+					}
+				}
+
+				for (int row = 0; row < n; row++)
+				{
+					for (int col = 0; col < n; col++)
+					{
+						B.setElem(row, col, matrix(row, n + col));
+					}
+				}
+			}
+
+			btMatrixXu b1(n, 1);
+
+			btMatrixXu M(n * 2, n * 2);
+			for (int row = 0; row < n; row++)
+			{
+				b1.setElem(row, 0, -b[row]);
+				for (int col = 0; col < n; col++)
+				{
+					btScalar v = B(row, col);
+					M.setElem(row, col, v);
+					M.setElem(n + row, n + col, v);
+					M.setElem(n + row, col, -v);
+					M.setElem(row, n + col, -v);
+				}
+			}
+
+			btMatrixXu Bb1 = B * b1;
+			//		q = [ (-B*b1 - lo)'   (hi + B*b1)' ]'
+
+			btVectorXu qq;
+			qq.resize(n * 2);
+			for (int row = 0; row < n; row++)
+			{
+				qq[row] = -Bb1(row, 0) - lo[row];
+				qq[n + row] = Bb1(row, 0) + hi[row];
+			}
+
+			btVectorXu z1;
+
+			btMatrixXu y1;
+			y1.resize(n, 1);
+			btLemkeAlgorithm lemke(M, qq, m_debugLevel);
+			{
+				//BT_PROFILE("lemke.solve");
+				lemke.setSystem(M, qq);
+				z1 = lemke.solve(m_maxLoops);
+			}
+			for (int row = 0; row < n; row++)
+			{
+				y1.setElem(row, 0, z1[2 * n + row] - z1[3 * n + row]);
+			}
+			btMatrixXu y1_b1(n, 1);
+			for (int i = 0; i < n; i++)
+			{
+				y1_b1.setElem(i, 0, y1(i, 0) - b1(i, 0));
+			}
+
+			btMatrixXu x1;
+
+			x1 = B * (y1_b1);
+
+			for (int row = 0; row < n; row++)
+			{
+				solution[row] = x1(row, 0);  //n];
+			}
+
+			int errorIndexMax = -1;
+			int errorIndexMin = -1;
+			float errorValueMax = -1e30;
+			float errorValueMin = 1e30;
+
+			for (int i = 0; i < n; i++)
+			{
+				x[i] = solution[i];
+				volatile btScalar check = x[i];
+				if (x[i] != check)
+				{
+					//printf("Lemke result is #NAN\n");
+					x.setZero();
+					return false;
+				}
+
+				//this is some hack/safety mechanism, to discard invalid solutions from the Lemke solver
+				//we need to figure out why it happens, and fix it, or detect it properly)
+				if (x[i] > m_maxValue)
+				{
+					if (x[i] > errorValueMax)
+					{
+						fail = true;
+						errorIndexMax = i;
+						errorValueMax = x[i];
+					}
+					////printf("x[i] = %f,",x[i]);
+				}
+				if (x[i] < -m_maxValue)
+				{
+					if (x[i] < errorValueMin)
+					{
+						errorIndexMin = i;
+						errorValueMin = x[i];
+						fail = true;
+						//printf("x[i] = %f,",x[i]);
+					}
+				}
+			}
+			if (fail)
+			{
+				int m_errorCountTimes = 0;
+				if (errorIndexMin < 0)
+					errorValueMin = 0.f;
+				if (errorIndexMax < 0)
+					errorValueMax = 0.f;
+				m_errorCountTimes++;
+				//	printf("Error (x[%d] = %f, x[%d] = %f), resetting %d times\n", errorIndexMin,errorValueMin, errorIndexMax, errorValueMax, errorCountTimes++);
+				for (int i = 0; i < n; i++)
+				{
+					x[i] = 0.f;
+				}
+			}
+			return !fail;
+		}
+		else
+
+		{
+			int dimension = A.rows();
+			if (0 == dimension)
+				return true;
+
+			//		printf("================ solving using Lemke/Newton/Fixpoint\n");
+
+			btVectorXu q;
+			q.resize(dimension);
+			for (int row = 0; row < dimension; row++)
+			{
+				q[row] = -b[row];
+			}
+
+			btLemkeAlgorithm lemke(A, q, m_debugLevel);
+
+			lemke.setSystem(A, q);
+
+			btVectorXu solution = lemke.solve(m_maxLoops);
+
+			//check solution
+
+			bool fail = false;
+			int errorIndexMax = -1;
+			int errorIndexMin = -1;
+			float errorValueMax = -1e30;
+			float errorValueMin = 1e30;
+
+			for (int i = 0; i < dimension; i++)
+			{
+				x[i] = solution[i + dimension];
+				volatile btScalar check = x[i];
+				if (x[i] != check)
+				{
+					x.setZero();
+					return false;
+				}
+
+				//this is some hack/safety mechanism, to discard invalid solutions from the Lemke solver
+				//we need to figure out why it happens, and fix it, or detect it properly)
+				if (x[i] > m_maxValue)
+				{
+					if (x[i] > errorValueMax)
+					{
+						fail = true;
+						errorIndexMax = i;
+						errorValueMax = x[i];
+					}
+					////printf("x[i] = %f,",x[i]);
+				}
+				if (x[i] < -m_maxValue)
+				{
+					if (x[i] < errorValueMin)
+					{
+						errorIndexMin = i;
+						errorValueMin = x[i];
+						fail = true;
+						//printf("x[i] = %f,",x[i]);
+					}
+				}
+			}
+			if (fail)
+			{
+				static int errorCountTimes = 0;
+				if (errorIndexMin < 0)
+					errorValueMin = 0.f;
+				if (errorIndexMax < 0)
+					errorValueMax = 0.f;
+				printf("Error (x[%d] = %f, x[%d] = %f), resetting %d times\n", errorIndexMin, errorValueMin, errorIndexMax, errorValueMax, errorCountTimes++);
+				for (int i = 0; i < dimension; i++)
+				{
+					x[i] = 0.f;
+				}
+			}
+
+			return !fail;
+		}
+		return true;
+	}
+};
+
+#endif  //BT_LEMKE_SOLVER_H
diff --git a/engine/inc/bullet/BulletDynamics/MLCPSolvers/btMLCPSolver.h b/engine/inc/bullet/BulletDynamics/MLCPSolvers/btMLCPSolver.h
new file mode 100644
index 00000000..510ae59e
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/MLCPSolvers/btMLCPSolver.h
@@ -0,0 +1,88 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+///original version written by Erwin Coumans, October 2013
+
+#ifndef BT_MLCP_SOLVER_H
+#define BT_MLCP_SOLVER_H
+
+#include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h"
+#include "LinearMath/btMatrixX.h"
+#include "BulletDynamics/MLCPSolvers/btMLCPSolverInterface.h"
+
+class btMLCPSolver : public btSequentialImpulseConstraintSolver
+{
+protected:
+	btMatrixXu m_A;
+	btVectorXu m_b;
+	btVectorXu m_x;
+	btVectorXu m_lo;
+	btVectorXu m_hi;
+
+	///when using 'split impulse' we solve two separate (M)LCPs
+	btVectorXu m_bSplit;
+	btVectorXu m_xSplit;
+	btVectorXu m_bSplit1;
+	btVectorXu m_xSplit2;
+
+	btAlignedObjectArray<int> m_limitDependencies;
+	btAlignedObjectArray<btSolverConstraint*> m_allConstraintPtrArray;
+	btMLCPSolverInterface* m_solver;
+	int m_fallback;
+
+	/// The following scratch variables are not stateful -- contents are cleared prior to each use.
+	/// They are only cached here to avoid extra memory allocations and deallocations and to ensure
+	/// that multiple instances of the solver can be run in parallel.
+	btMatrixXu m_scratchJ3;
+	btMatrixXu m_scratchJInvM3;
+	btAlignedObjectArray<int> m_scratchOfs;
+	btMatrixXu m_scratchMInv;
+	btMatrixXu m_scratchJ;
+	btMatrixXu m_scratchJTranspose;
+	btMatrixXu m_scratchTmp;
+
+	virtual btScalar solveGroupCacheFriendlySetup(btCollisionObject** bodies, int numBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer);
+	virtual btScalar solveGroupCacheFriendlyIterations(btCollisionObject** bodies, int numBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer);
+
+	virtual void createMLCP(const btContactSolverInfo& infoGlobal);
+	virtual void createMLCPFast(const btContactSolverInfo& infoGlobal);
+
+	//return true is it solves the problem successfully
+	virtual bool solveMLCP(const btContactSolverInfo& infoGlobal);
+
+public:
+	btMLCPSolver(btMLCPSolverInterface* solver);
+	virtual ~btMLCPSolver();
+
+	void setMLCPSolver(btMLCPSolverInterface* solver)
+	{
+		m_solver = solver;
+	}
+
+	int getNumFallbacks() const
+	{
+		return m_fallback;
+	}
+	void setNumFallbacks(int num)
+	{
+		m_fallback = num;
+	}
+
+	virtual btConstraintSolverType getSolverType() const
+	{
+		return BT_MLCP_SOLVER;
+	}
+};
+
+#endif  //BT_MLCP_SOLVER_H
diff --git a/engine/inc/bullet/BulletDynamics/MLCPSolvers/btMLCPSolverInterface.h b/engine/inc/bullet/BulletDynamics/MLCPSolvers/btMLCPSolverInterface.h
new file mode 100644
index 00000000..6b0465b8
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/MLCPSolvers/btMLCPSolverInterface.h
@@ -0,0 +1,33 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+///original version written by Erwin Coumans, October 2013
+
+#ifndef BT_MLCP_SOLVER_INTERFACE_H
+#define BT_MLCP_SOLVER_INTERFACE_H
+
+#include "LinearMath/btMatrixX.h"
+
+class btMLCPSolverInterface
+{
+public:
+	virtual ~btMLCPSolverInterface()
+	{
+	}
+
+	//return true is it solves the problem successfully
+	virtual bool solveMLCP(const btMatrixXu& A, const btVectorXu& b, btVectorXu& x, const btVectorXu& lo, const btVectorXu& hi, const btAlignedObjectArray<int>& limitDependency, int numIterations, bool useSparsity = true) = 0;
+};
+
+#endif  //BT_MLCP_SOLVER_INTERFACE_H
diff --git a/engine/inc/bullet/BulletDynamics/MLCPSolvers/btPATHSolver.h b/engine/inc/bullet/BulletDynamics/MLCPSolvers/btPATHSolver.h
new file mode 100644
index 00000000..7f8eec3f
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/MLCPSolvers/btPATHSolver.h
@@ -0,0 +1,142 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+///original version written by Erwin Coumans, October 2013
+
+#ifndef BT_PATH_SOLVER_H
+#define BT_PATH_SOLVER_H
+
+//#define BT_USE_PATH
+#ifdef BT_USE_PATH
+
+extern "C"
+{
+#include "PATH/SimpleLCP.h"
+#include "PATH/License.h"
+#include "PATH/Error_Interface.h"
+};
+void __stdcall MyError(Void *data, Char *msg)
+{
+	printf("Path Error: %s\n", msg);
+}
+void __stdcall MyWarning(Void *data, Char *msg)
+{
+	printf("Path Warning: %s\n", msg);
+}
+
+Error_Interface e;
+
+#include "btMLCPSolverInterface.h"
+#include "Dantzig/lcp.h"
+
+class btPathSolver : public btMLCPSolverInterface
+{
+public:
+	btPathSolver()
+	{
+		License_SetString("2069810742&Courtesy_License&&&USR&2013&14_12_2011&1000&PATH&GEN&31_12_2013&0_0_0&0&0_0");
+		e.error_data = 0;
+		e.warning = MyWarning;
+		e.error = MyError;
+		Error_SetInterface(&e);
+	}
+
+	virtual bool solveMLCP(const btMatrixXu &A, const btVectorXu &b, btVectorXu &x, const btVectorXu &lo, const btVectorXu &hi, const btAlignedObjectArray<int> &limitDependency, int numIterations, bool useSparsity = true)
+	{
+		MCP_Termination status;
+
+		int numVariables = b.rows();
+		if (0 == numVariables)
+			return true;
+
+		/*	 - variables - the number of variables in the problem
+			- m_nnz - the number of nonzeros in the M matrix
+			- m_i - a vector of size m_nnz containing the row indices for M
+			- m_j - a vector of size m_nnz containing the column indices for M
+			- m_ij - a vector of size m_nnz containing the data for M
+			- q - a vector of size variables
+			- lb - a vector of size variables containing the lower bounds on x
+			- ub - a vector of size variables containing the upper bounds on x
+			*/
+		btAlignedObjectArray<double> values;
+		btAlignedObjectArray<int> rowIndices;
+		btAlignedObjectArray<int> colIndices;
+
+		for (int i = 0; i < A.rows(); i++)
+		{
+			for (int j = 0; j < A.cols(); j++)
+			{
+				if (A(i, j) != 0.f)
+				{
+					//add 1, because Path starts at 1, instead of 0
+					rowIndices.push_back(i + 1);
+					colIndices.push_back(j + 1);
+					values.push_back(A(i, j));
+				}
+			}
+		}
+		int numNonZero = rowIndices.size();
+		btAlignedObjectArray<double> zResult;
+		zResult.resize(numVariables);
+		btAlignedObjectArray<double> rhs;
+		btAlignedObjectArray<double> upperBounds;
+		btAlignedObjectArray<double> lowerBounds;
+		for (int i = 0; i < numVariables; i++)
+		{
+			upperBounds.push_back(hi[i]);
+			lowerBounds.push_back(lo[i]);
+			rhs.push_back(-b[i]);
+		}
+
+		SimpleLCP(numVariables, numNonZero, &rowIndices[0], &colIndices[0], &values[0], &rhs[0], &lowerBounds[0], &upperBounds[0], &status, &zResult[0]);
+
+		if (status != MCP_Solved)
+		{
+			static const char *gReturnMsgs[] = {
+				"Invalid return",
+				"MCP_Solved: The problem was solved",
+				"MCP_NoProgress: A stationary point was found",
+				"MCP_MajorIterationLimit: Major iteration limit met",
+				"MCP_MinorIterationLimit: Cumulative minor iteration limit met",
+				"MCP_TimeLimit: Ran out of time",
+				"MCP_UserInterrupt: Control-C, typically",
+				"MCP_BoundError: Problem has a bound error",
+				"MCP_DomainError: Could not find starting point",
+				"MCP_Infeasible: Problem has no solution",
+				"MCP_Error: An error occurred within the code",
+				"MCP_LicenseError: License could not be found",
+				"MCP_OK"};
+
+			printf("ERROR: The PATH MCP solver failed: %s\n", gReturnMsgs[(unsigned int)status]);  // << std::endl;
+			printf("using Projected Gauss Seidel fallback\n");
+
+			return false;
+		}
+		else
+		{
+			for (int i = 0; i < numVariables; i++)
+			{
+				x[i] = zResult[i];
+				//check for #NAN
+				if (x[i] != zResult[i])
+					return false;
+			}
+			return true;
+		}
+	}
+};
+
+#endif  //BT_USE_PATH
+
+#endif  //BT_PATH_SOLVER_H
diff --git a/engine/inc/bullet/BulletDynamics/MLCPSolvers/btSolveProjectedGaussSeidel.h b/engine/inc/bullet/BulletDynamics/MLCPSolvers/btSolveProjectedGaussSeidel.h
new file mode 100644
index 00000000..c3f4ec39
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/MLCPSolvers/btSolveProjectedGaussSeidel.h
@@ -0,0 +1,107 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+///original version written by Erwin Coumans, October 2013
+
+#ifndef BT_SOLVE_PROJECTED_GAUSS_SEIDEL_H
+#define BT_SOLVE_PROJECTED_GAUSS_SEIDEL_H
+
+#include "btMLCPSolverInterface.h"
+
+///This solver is mainly for debug/learning purposes: it is functionally equivalent to the btSequentialImpulseConstraintSolver solver, but much slower (it builds the full LCP matrix)
+class btSolveProjectedGaussSeidel : public btMLCPSolverInterface
+{
+public:
+	btScalar m_leastSquaresResidualThreshold;
+	btScalar m_leastSquaresResidual;
+
+	btSolveProjectedGaussSeidel()
+		: m_leastSquaresResidualThreshold(0),
+		  m_leastSquaresResidual(0)
+	{
+	}
+
+	virtual bool solveMLCP(const btMatrixXu& A, const btVectorXu& b, btVectorXu& x, const btVectorXu& lo, const btVectorXu& hi, const btAlignedObjectArray<int>& limitDependency, int numIterations, bool useSparsity = true)
+	{
+		if (!A.rows())
+			return true;
+		//the A matrix is sparse, so compute the non-zero elements
+		A.rowComputeNonZeroElements();
+
+		//A is a m-n matrix, m rows, n columns
+		btAssert(A.rows() == b.rows());
+
+		int i, j, numRows = A.rows();
+
+		btScalar delta;
+
+		for (int k = 0; k < numIterations; k++)
+		{
+			m_leastSquaresResidual = 0.f;
+			for (i = 0; i < numRows; i++)
+			{
+				delta = 0.0f;
+				if (useSparsity)
+				{
+					for (int h = 0; h < A.m_rowNonZeroElements1[i].size(); h++)
+					{
+						j = A.m_rowNonZeroElements1[i][h];
+						if (j != i)  //skip main diagonal
+						{
+							delta += A(i, j) * x[j];
+						}
+					}
+				}
+				else
+				{
+					for (j = 0; j < i; j++)
+						delta += A(i, j) * x[j];
+					for (j = i + 1; j < numRows; j++)
+						delta += A(i, j) * x[j];
+				}
+
+				btScalar aDiag = A(i, i);
+				btScalar xOld = x[i];
+				x[i] = (b[i] - delta) / aDiag;
+				btScalar s = 1.f;
+
+				if (limitDependency[i] >= 0)
+				{
+					s = x[limitDependency[i]];
+					if (s < 0)
+						s = 1;
+				}
+
+				if (x[i] < lo[i] * s)
+					x[i] = lo[i] * s;
+				if (x[i] > hi[i] * s)
+					x[i] = hi[i] * s;
+				btScalar diff = x[i] - xOld;
+				m_leastSquaresResidual += diff * diff;
+			}
+
+			btScalar eps = m_leastSquaresResidualThreshold;
+			if ((m_leastSquaresResidual < eps) || (k >= (numIterations - 1)))
+			{
+#ifdef VERBOSE_PRINTF_RESIDUAL
+				printf("totalLenSqr = %f at iteration #%d\n", m_leastSquaresResidual, k);
+#endif
+				break;
+			}
+		}
+		return true;
+	}
+};
+
+#endif  //BT_SOLVE_PROJECTED_GAUSS_SEIDEL_H
diff --git a/engine/inc/bullet/BulletDynamics/Vehicle/btRaycastVehicle.h b/engine/inc/bullet/BulletDynamics/Vehicle/btRaycastVehicle.h
new file mode 100644
index 00000000..99d6894e
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/Vehicle/btRaycastVehicle.h
@@ -0,0 +1,218 @@
+/*
+ * Copyright (c) 2005 Erwin Coumans http://continuousphysics.com/Bullet/
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies.
+ * Erwin Coumans makes no representations about the suitability 
+ * of this software for any purpose.  
+ * It is provided "as is" without express or implied warranty.
+*/
+#ifndef BT_RAYCASTVEHICLE_H
+#define BT_RAYCASTVEHICLE_H
+
+#include "BulletDynamics/Dynamics/btRigidBody.h"
+#include "BulletDynamics/ConstraintSolver/btTypedConstraint.h"
+#include "btVehicleRaycaster.h"
+class btDynamicsWorld;
+#include "LinearMath/btAlignedObjectArray.h"
+#include "btWheelInfo.h"
+#include "BulletDynamics/Dynamics/btActionInterface.h"
+
+//class btVehicleTuning;
+
+///rayCast vehicle, very special constraint that turn a rigidbody into a vehicle.
+class btRaycastVehicle : public btActionInterface
+{
+	btAlignedObjectArray<btVector3> m_forwardWS;
+	btAlignedObjectArray<btVector3> m_axle;
+	btAlignedObjectArray<btScalar> m_forwardImpulse;
+	btAlignedObjectArray<btScalar> m_sideImpulse;
+
+	///backwards compatibility
+	int m_userConstraintType;
+	int m_userConstraintId;
+
+public:
+	class btVehicleTuning
+	{
+	public:
+		btVehicleTuning()
+			: m_suspensionStiffness(btScalar(5.88)),
+			  m_suspensionCompression(btScalar(0.83)),
+			  m_suspensionDamping(btScalar(0.88)),
+			  m_maxSuspensionTravelCm(btScalar(500.)),
+			  m_frictionSlip(btScalar(10.5)),
+			  m_maxSuspensionForce(btScalar(6000.))
+		{
+		}
+		btScalar m_suspensionStiffness;
+		btScalar m_suspensionCompression;
+		btScalar m_suspensionDamping;
+		btScalar m_maxSuspensionTravelCm;
+		btScalar m_frictionSlip;
+		btScalar m_maxSuspensionForce;
+	};
+
+private:
+	btVehicleRaycaster* m_vehicleRaycaster;
+	btScalar m_pitchControl;
+	btScalar m_steeringValue;
+	btScalar m_currentVehicleSpeedKmHour;
+
+	btRigidBody* m_chassisBody;
+
+	int m_indexRightAxis;
+	int m_indexUpAxis;
+	int m_indexForwardAxis;
+
+	void defaultInit(const btVehicleTuning& tuning);
+
+public:
+	//constructor to create a car from an existing rigidbody
+	btRaycastVehicle(const btVehicleTuning& tuning, btRigidBody* chassis, btVehicleRaycaster* raycaster);
+
+	virtual ~btRaycastVehicle();
+
+	///btActionInterface interface
+	virtual void updateAction(btCollisionWorld* collisionWorld, btScalar step)
+	{
+		(void)collisionWorld;
+		updateVehicle(step);
+	}
+
+	///btActionInterface interface
+	void debugDraw(btIDebugDraw* debugDrawer);
+
+	const btTransform& getChassisWorldTransform() const;
+
+	btScalar rayCast(btWheelInfo& wheel);
+
+	virtual void updateVehicle(btScalar step);
+
+	void resetSuspension();
+
+	btScalar getSteeringValue(int wheel) const;
+
+	void setSteeringValue(btScalar steering, int wheel);
+
+	void applyEngineForce(btScalar force, int wheel);
+
+	const btTransform& getWheelTransformWS(int wheelIndex) const;
+
+	void updateWheelTransform(int wheelIndex, bool interpolatedTransform = true);
+
+	//	void	setRaycastWheelInfo( int wheelIndex , bool isInContact, const btVector3& hitPoint, const btVector3& hitNormal,btScalar depth);
+
+	btWheelInfo& addWheel(const btVector3& connectionPointCS0, const btVector3& wheelDirectionCS0, const btVector3& wheelAxleCS, btScalar suspensionRestLength, btScalar wheelRadius, const btVehicleTuning& tuning, bool isFrontWheel);
+
+	inline int getNumWheels() const
+	{
+		return int(m_wheelInfo.size());
+	}
+
+	btAlignedObjectArray<btWheelInfo> m_wheelInfo;
+
+	const btWheelInfo& getWheelInfo(int index) const;
+
+	btWheelInfo& getWheelInfo(int index);
+
+	void updateWheelTransformsWS(btWheelInfo& wheel, bool interpolatedTransform = true);
+
+	void setBrake(btScalar brake, int wheelIndex);
+
+	void setPitchControl(btScalar pitch)
+	{
+		m_pitchControl = pitch;
+	}
+
+	void updateSuspension(btScalar deltaTime);
+
+	virtual void updateFriction(btScalar timeStep);
+
+	inline btRigidBody* getRigidBody()
+	{
+		return m_chassisBody;
+	}
+
+	const btRigidBody* getRigidBody() const
+	{
+		return m_chassisBody;
+	}
+
+	inline int getRightAxis() const
+	{
+		return m_indexRightAxis;
+	}
+	inline int getUpAxis() const
+	{
+		return m_indexUpAxis;
+	}
+
+	inline int getForwardAxis() const
+	{
+		return m_indexForwardAxis;
+	}
+
+	///Worldspace forward vector
+	btVector3 getForwardVector() const
+	{
+		const btTransform& chassisTrans = getChassisWorldTransform();
+
+		btVector3 forwardW(
+			chassisTrans.getBasis()[0][m_indexForwardAxis],
+			chassisTrans.getBasis()[1][m_indexForwardAxis],
+			chassisTrans.getBasis()[2][m_indexForwardAxis]);
+
+		return forwardW;
+	}
+
+	///Velocity of vehicle (positive if velocity vector has same direction as foward vector)
+	btScalar getCurrentSpeedKmHour() const
+	{
+		return m_currentVehicleSpeedKmHour;
+	}
+
+	virtual void setCoordinateSystem(int rightIndex, int upIndex, int forwardIndex)
+	{
+		m_indexRightAxis = rightIndex;
+		m_indexUpAxis = upIndex;
+		m_indexForwardAxis = forwardIndex;
+	}
+
+	///backwards compatibility
+	int getUserConstraintType() const
+	{
+		return m_userConstraintType;
+	}
+
+	void setUserConstraintType(int userConstraintType)
+	{
+		m_userConstraintType = userConstraintType;
+	};
+
+	void setUserConstraintId(int uid)
+	{
+		m_userConstraintId = uid;
+	}
+
+	int getUserConstraintId() const
+	{
+		return m_userConstraintId;
+	}
+};
+
+class btDefaultVehicleRaycaster : public btVehicleRaycaster
+{
+	btDynamicsWorld* m_dynamicsWorld;
+
+public:
+	btDefaultVehicleRaycaster(btDynamicsWorld* world)
+		: m_dynamicsWorld(world)
+	{
+	}
+
+	virtual void* castRay(const btVector3& from, const btVector3& to, btVehicleRaycasterResult& result);
+};
+
+#endif  //BT_RAYCASTVEHICLE_H
diff --git a/engine/inc/bullet/BulletDynamics/Vehicle/btVehicleRaycaster.h b/engine/inc/bullet/BulletDynamics/Vehicle/btVehicleRaycaster.h
new file mode 100644
index 00000000..2c44ce54
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/Vehicle/btVehicleRaycaster.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2005 Erwin Coumans http://bulletphysics.org
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies.
+ * Erwin Coumans makes no representations about the suitability 
+ * of this software for any purpose.  
+ * It is provided "as is" without express or implied warranty.
+*/
+#ifndef BT_VEHICLE_RAYCASTER_H
+#define BT_VEHICLE_RAYCASTER_H
+
+#include "LinearMath/btVector3.h"
+
+/// btVehicleRaycaster is provides interface for between vehicle simulation and raycasting
+struct btVehicleRaycaster
+{
+	virtual ~btVehicleRaycaster()
+	{
+	}
+	struct btVehicleRaycasterResult
+	{
+		btVehicleRaycasterResult() : m_distFraction(btScalar(-1.)){};
+		btVector3 m_hitPointInWorld;
+		btVector3 m_hitNormalInWorld;
+		btScalar m_distFraction;
+	};
+
+	virtual void* castRay(const btVector3& from, const btVector3& to, btVehicleRaycasterResult& result) = 0;
+};
+
+#endif  //BT_VEHICLE_RAYCASTER_H
diff --git a/engine/inc/bullet/BulletDynamics/Vehicle/btWheelInfo.h b/engine/inc/bullet/BulletDynamics/Vehicle/btWheelInfo.h
new file mode 100644
index 00000000..af88b8ff
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/Vehicle/btWheelInfo.h
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2005 Erwin Coumans http://continuousphysics.com/Bullet/
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies.
+ * Erwin Coumans makes no representations about the suitability 
+ * of this software for any purpose.  
+ * It is provided "as is" without express or implied warranty.
+*/
+#ifndef BT_WHEEL_INFO_H
+#define BT_WHEEL_INFO_H
+
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btTransform.h"
+
+class btRigidBody;
+
+struct btWheelInfoConstructionInfo
+{
+	btVector3 m_chassisConnectionCS;
+	btVector3 m_wheelDirectionCS;
+	btVector3 m_wheelAxleCS;
+	btScalar m_suspensionRestLength;
+	btScalar m_maxSuspensionTravelCm;
+	btScalar m_wheelRadius;
+
+	btScalar m_suspensionStiffness;
+	btScalar m_wheelsDampingCompression;
+	btScalar m_wheelsDampingRelaxation;
+	btScalar m_frictionSlip;
+	btScalar m_maxSuspensionForce;
+	bool m_bIsFrontWheel;
+};
+
+/// btWheelInfo contains information per wheel about friction and suspension.
+struct btWheelInfo
+{
+	struct RaycastInfo
+	{
+		//set by raycaster
+		btVector3 m_contactNormalWS;  //contactnormal
+		btVector3 m_contactPointWS;   //raycast hitpoint
+		btScalar m_suspensionLength;
+		btVector3 m_hardPointWS;       //raycast starting point
+		btVector3 m_wheelDirectionWS;  //direction in worldspace
+		btVector3 m_wheelAxleWS;       // axle in worldspace
+		bool m_isInContact;
+		void* m_groundObject;  //could be general void* ptr
+	};
+
+	RaycastInfo m_raycastInfo;
+
+	btTransform m_worldTransform;
+
+	btVector3 m_chassisConnectionPointCS;  //const
+	btVector3 m_wheelDirectionCS;          //const
+	btVector3 m_wheelAxleCS;               // const or modified by steering
+	btScalar m_suspensionRestLength1;      //const
+	btScalar m_maxSuspensionTravelCm;
+	btScalar getSuspensionRestLength() const;
+	btScalar m_wheelsRadius;              //const
+	btScalar m_suspensionStiffness;       //const
+	btScalar m_wheelsDampingCompression;  //const
+	btScalar m_wheelsDampingRelaxation;   //const
+	btScalar m_frictionSlip;
+	btScalar m_steering;
+	btScalar m_rotation;
+	btScalar m_deltaRotation;
+	btScalar m_rollInfluence;
+	btScalar m_maxSuspensionForce;
+
+	btScalar m_engineForce;
+
+	btScalar m_brake;
+
+	bool m_bIsFrontWheel;
+
+	void* m_clientInfo;  //can be used to store pointer to sync transforms...
+
+	btWheelInfo() {}
+
+	btWheelInfo(btWheelInfoConstructionInfo& ci)
+
+	{
+		m_suspensionRestLength1 = ci.m_suspensionRestLength;
+		m_maxSuspensionTravelCm = ci.m_maxSuspensionTravelCm;
+
+		m_wheelsRadius = ci.m_wheelRadius;
+		m_suspensionStiffness = ci.m_suspensionStiffness;
+		m_wheelsDampingCompression = ci.m_wheelsDampingCompression;
+		m_wheelsDampingRelaxation = ci.m_wheelsDampingRelaxation;
+		m_chassisConnectionPointCS = ci.m_chassisConnectionCS;
+		m_wheelDirectionCS = ci.m_wheelDirectionCS;
+		m_wheelAxleCS = ci.m_wheelAxleCS;
+		m_frictionSlip = ci.m_frictionSlip;
+		m_steering = btScalar(0.);
+		m_engineForce = btScalar(0.);
+		m_rotation = btScalar(0.);
+		m_deltaRotation = btScalar(0.);
+		m_brake = btScalar(0.);
+		m_rollInfluence = btScalar(0.1);
+		m_bIsFrontWheel = ci.m_bIsFrontWheel;
+		m_maxSuspensionForce = ci.m_maxSuspensionForce;
+	}
+
+	void updateWheel(const btRigidBody& chassis, RaycastInfo& raycastInfo);
+
+	btScalar m_clippedInvContactDotSuspension;
+	btScalar m_suspensionRelativeVelocity;
+	//calculated by suspension
+	btScalar m_wheelsSuspensionForce;
+	btScalar m_skidInfo;
+};
+
+#endif  //BT_WHEEL_INFO_H
diff --git a/engine/inc/bullet/BulletDynamics/btBulletDynamicsCommon.h b/engine/inc/bullet/BulletDynamics/btBulletDynamicsCommon.h
new file mode 100644
index 00000000..a421fa44
--- /dev/null
+++ b/engine/inc/bullet/BulletDynamics/btBulletDynamicsCommon.h
@@ -0,0 +1,43 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BULLET_DYNAMICS_COMMON_H
+#define BULLET_DYNAMICS_COMMON_H
+
+///Common headerfile includes for Bullet Dynamics, including Collision Detection
+#include "btBulletCollisionCommon.h"
+
+#include "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h"
+
+#include "BulletDynamics/Dynamics/btSimpleDynamicsWorld.h"
+#include "BulletDynamics/Dynamics/btRigidBody.h"
+
+#include "BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h"
+#include "BulletDynamics/ConstraintSolver/btHingeConstraint.h"
+#include "BulletDynamics/ConstraintSolver/btConeTwistConstraint.h"
+#include "BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h"
+#include "BulletDynamics/ConstraintSolver/btSliderConstraint.h"
+#include "BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.h"
+#include "BulletDynamics/ConstraintSolver/btUniversalConstraint.h"
+#include "BulletDynamics/ConstraintSolver/btHinge2Constraint.h"
+#include "BulletDynamics/ConstraintSolver/btGearConstraint.h"
+#include "BulletDynamics/ConstraintSolver/btFixedConstraint.h"
+
+#include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h"
+
+///Vehicle simulation, with wheel contact simulated by raycasts
+#include "BulletDynamics/Vehicle/btRaycastVehicle.h"
+
+#endif  //BULLET_DYNAMICS_COMMON_H
diff --git a/engine/inc/bullet/BulletFileLoader/autogenerated/bullet.h b/engine/inc/bullet/BulletFileLoader/autogenerated/bullet.h
new file mode 100644
index 00000000..bfec77bb
--- /dev/null
+++ b/engine/inc/bullet/BulletFileLoader/autogenerated/bullet.h
@@ -0,0 +1,1580 @@
+/* Copyright (C) 2011 Erwin Coumans & Charlie C
+*
+* This software is provided 'as-is', without any express or implied
+* warranty.  In no event will the authors be held liable for any damages
+* arising from the use of this software.
+*
+* Permission is granted to anyone to use this software for any purpose,
+* including commercial applications, and to alter it and redistribute it
+* freely, subject to the following restrictions:
+*
+* 1. The origin of this software must not be misrepresented; you must not
+*    claim that you wrote the original software. If you use this software
+*    in a product, an acknowledgment in the product documentation would be
+*    appreciated but is not required.
+* 2. Altered source versions must be plainly marked as such, and must not be
+*    misrepresented as being the original software.
+* 3. This notice may not be removed or altered from any source distribution.
+*/
+// Auto generated from Bullet/Extras/HeaderGenerator/bulletGenerate.py
+#ifndef __BULLET_H__
+#define __BULLET_H__
+namespace Bullet {
+
+// put an empty struct in the case
+typedef struct bInvalidHandle {
+	int unused;
+}bInvalidHandle;
+
+    class PointerArray;
+    class btPhysicsSystem;
+    class ListBase;
+    class btVector3FloatData;
+    class btVector3DoubleData;
+    class btQuaternionFloatData;
+    class btQuaternionDoubleData;
+    class btMatrix3x3FloatData;
+    class btMatrix3x3DoubleData;
+    class btTransformFloatData;
+    class btTransformDoubleData;
+    class btBvhSubtreeInfoData;
+    class btOptimizedBvhNodeFloatData;
+    class btOptimizedBvhNodeDoubleData;
+    class btQuantizedBvhNodeData;
+    class btQuantizedBvhFloatData;
+    class btQuantizedBvhDoubleData;
+    class btCollisionShapeData;
+    class btStaticPlaneShapeData;
+    class btConvexInternalShapeData;
+    class btPositionAndRadius;
+    class btMultiSphereShapeData;
+    class btIntIndexData;
+    class btShortIntIndexData;
+    class btShortIntIndexTripletData;
+    class btCharIndexTripletData;
+    class btMeshPartData;
+    class btStridingMeshInterfaceData;
+    class btTriangleMeshShapeData;
+    class btScaledTriangleMeshShapeData;
+    class btCompoundShapeChildData;
+    class btCompoundShapeData;
+    class btCylinderShapeData;
+    class btConeShapeData;
+    class btCapsuleShapeData;
+    class btTriangleInfoData;
+    class btTriangleInfoMapData;
+    class btPersistentManifoldDoubleData;
+    class btPersistentManifoldFloatData;
+    class btGImpactMeshShapeData;
+    class btConvexHullShapeData;
+    class btCollisionObjectDoubleData;
+    class btCollisionObjectFloatData;
+    class btContactSolverInfoDoubleData;
+    class btContactSolverInfoFloatData;
+    class btDynamicsWorldDoubleData;
+    class btDynamicsWorldFloatData;
+    class btRigidBodyFloatData;
+    class btRigidBodyDoubleData;
+    class btConstraintInfo1;
+    class btTypedConstraintFloatData;
+    class btTypedConstraintData;
+    class btTypedConstraintDoubleData;
+    class btPoint2PointConstraintFloatData;
+    class btPoint2PointConstraintDoubleData2;
+    class btPoint2PointConstraintDoubleData;
+    class btHingeConstraintDoubleData;
+    class btHingeConstraintFloatData;
+    class btHingeConstraintDoubleData2;
+    class btConeTwistConstraintDoubleData;
+    class btConeTwistConstraintData;
+    class btGeneric6DofConstraintData;
+    class btGeneric6DofConstraintDoubleData2;
+    class btGeneric6DofSpringConstraintData;
+    class btGeneric6DofSpringConstraintDoubleData2;
+    class btGeneric6DofSpring2ConstraintData;
+    class btGeneric6DofSpring2ConstraintDoubleData2;
+    class btSliderConstraintData;
+    class btSliderConstraintDoubleData;
+    class btGearConstraintFloatData;
+    class btGearConstraintDoubleData;
+    class SoftBodyMaterialData;
+    class SoftBodyNodeData;
+    class SoftBodyLinkData;
+    class SoftBodyFaceData;
+    class SoftBodyTetraData;
+    class SoftRigidAnchorData;
+    class SoftBodyConfigData;
+    class SoftBodyPoseData;
+    class SoftBodyClusterData;
+    class btSoftBodyJointData;
+    class btSoftBodyFloatData;
+    class btMultiBodyLinkDoubleData;
+    class btMultiBodyLinkFloatData;
+    class btMultiBodyDoubleData;
+    class btMultiBodyFloatData;
+    class btMultiBodyLinkColliderFloatData;
+    class btMultiBodyLinkColliderDoubleData;
+// -------------------------------------------------- //
+    class PointerArray
+    {
+    public:
+        int m_size;
+        int m_capacity;
+        void *m_data;
+    };
+
+
+// -------------------------------------------------- //
+    class btPhysicsSystem
+    {
+    public:
+        PointerArray m_collisionShapes;
+        PointerArray m_collisionObjects;
+        PointerArray m_constraints;
+    };
+
+
+// -------------------------------------------------- //
+    class ListBase
+    {
+    public:
+        void *first;
+        void *last;
+    };
+
+
+// -------------------------------------------------- //
+    class btVector3FloatData
+    {
+    public:
+        float m_floats[4];
+    };
+
+
+// -------------------------------------------------- //
+    class btVector3DoubleData
+    {
+    public:
+        double m_floats[4];
+    };
+
+
+// -------------------------------------------------- //
+    class btQuaternionFloatData
+    {
+    public:
+        float m_floats[4];
+    };
+
+
+// -------------------------------------------------- //
+    class btQuaternionDoubleData
+    {
+    public:
+        double m_floats[4];
+    };
+
+
+// -------------------------------------------------- //
+    class btMatrix3x3FloatData
+    {
+    public:
+        btVector3FloatData m_el[3];
+    };
+
+
+// -------------------------------------------------- //
+    class btMatrix3x3DoubleData
+    {
+    public:
+        btVector3DoubleData m_el[3];
+    };
+
+
+// -------------------------------------------------- //
+    class btTransformFloatData
+    {
+    public:
+        btMatrix3x3FloatData m_basis;
+        btVector3FloatData m_origin;
+    };
+
+
+// -------------------------------------------------- //
+    class btTransformDoubleData
+    {
+    public:
+        btMatrix3x3DoubleData m_basis;
+        btVector3DoubleData m_origin;
+    };
+
+
+// -------------------------------------------------- //
+    class btBvhSubtreeInfoData
+    {
+    public:
+        int m_rootNodeIndex;
+        int m_subtreeSize;
+        short m_quantizedAabbMin[3];
+        short m_quantizedAabbMax[3];
+    };
+
+
+// -------------------------------------------------- //
+    class btOptimizedBvhNodeFloatData
+    {
+    public:
+        btVector3FloatData m_aabbMinOrg;
+        btVector3FloatData m_aabbMaxOrg;
+        int m_escapeIndex;
+        int m_subPart;
+        int m_triangleIndex;
+        char m_pad[4];
+    };
+
+
+// -------------------------------------------------- //
+    class btOptimizedBvhNodeDoubleData
+    {
+    public:
+        btVector3DoubleData m_aabbMinOrg;
+        btVector3DoubleData m_aabbMaxOrg;
+        int m_escapeIndex;
+        int m_subPart;
+        int m_triangleIndex;
+        char m_pad[4];
+    };
+
+
+// -------------------------------------------------- //
+    class btQuantizedBvhNodeData
+    {
+    public:
+        short m_quantizedAabbMin[3];
+        short m_quantizedAabbMax[3];
+        int m_escapeIndexOrTriangleIndex;
+    };
+
+
+// -------------------------------------------------- //
+    class btQuantizedBvhFloatData
+    {
+    public:
+        btVector3FloatData m_bvhAabbMin;
+        btVector3FloatData m_bvhAabbMax;
+        btVector3FloatData m_bvhQuantization;
+        int m_curNodeIndex;
+        int m_useQuantization;
+        int m_numContiguousLeafNodes;
+        int m_numQuantizedContiguousNodes;
+        btOptimizedBvhNodeFloatData *m_contiguousNodesPtr;
+        btQuantizedBvhNodeData *m_quantizedContiguousNodesPtr;
+        btBvhSubtreeInfoData *m_subTreeInfoPtr;
+        int m_traversalMode;
+        int m_numSubtreeHeaders;
+    };
+
+
+// -------------------------------------------------- //
+    class btQuantizedBvhDoubleData
+    {
+    public:
+        btVector3DoubleData m_bvhAabbMin;
+        btVector3DoubleData m_bvhAabbMax;
+        btVector3DoubleData m_bvhQuantization;
+        int m_curNodeIndex;
+        int m_useQuantization;
+        int m_numContiguousLeafNodes;
+        int m_numQuantizedContiguousNodes;
+        btOptimizedBvhNodeDoubleData *m_contiguousNodesPtr;
+        btQuantizedBvhNodeData *m_quantizedContiguousNodesPtr;
+        int m_traversalMode;
+        int m_numSubtreeHeaders;
+        btBvhSubtreeInfoData *m_subTreeInfoPtr;
+    };
+
+
+// -------------------------------------------------- //
+    class btCollisionShapeData
+    {
+    public:
+        char *m_name;
+        int m_shapeType;
+        char m_padding[4];
+    };
+
+
+// -------------------------------------------------- //
+    class btStaticPlaneShapeData
+    {
+    public:
+        btCollisionShapeData m_collisionShapeData;
+        btVector3FloatData m_localScaling;
+        btVector3FloatData m_planeNormal;
+        float m_planeConstant;
+        char m_pad[4];
+    };
+
+
+// -------------------------------------------------- //
+    class btConvexInternalShapeData
+    {
+    public:
+        btCollisionShapeData m_collisionShapeData;
+        btVector3FloatData m_localScaling;
+        btVector3FloatData m_implicitShapeDimensions;
+        float m_collisionMargin;
+        int m_padding;
+    };
+
+
+// -------------------------------------------------- //
+    class btPositionAndRadius
+    {
+    public:
+        btVector3FloatData m_pos;
+        float m_radius;
+    };
+
+
+// -------------------------------------------------- //
+    class btMultiSphereShapeData
+    {
+    public:
+        btConvexInternalShapeData m_convexInternalShapeData;
+        btPositionAndRadius *m_localPositionArrayPtr;
+        int m_localPositionArraySize;
+        char m_padding[4];
+    };
+
+
+// -------------------------------------------------- //
+    class btIntIndexData
+    {
+    public:
+        int m_value;
+    };
+
+
+// -------------------------------------------------- //
+    class btShortIntIndexData
+    {
+    public:
+        short m_value;
+        char m_pad[2];
+    };
+
+
+// -------------------------------------------------- //
+    class btShortIntIndexTripletData
+    {
+    public:
+        short m_values[3];
+        char m_pad[2];
+    };
+
+
+// -------------------------------------------------- //
+    class btCharIndexTripletData
+    {
+    public:
+        char m_values[3];
+        char m_pad;
+    };
+
+
+// -------------------------------------------------- //
+    class btMeshPartData
+    {
+    public:
+        btVector3FloatData *m_vertices3f;
+        btVector3DoubleData *m_vertices3d;
+        btIntIndexData *m_indices32;
+        btShortIntIndexTripletData *m_3indices16;
+        btCharIndexTripletData *m_3indices8;
+        btShortIntIndexData *m_indices16;
+        int m_numTriangles;
+        int m_numVertices;
+    };
+
+
+// -------------------------------------------------- //
+    class btStridingMeshInterfaceData
+    {
+    public:
+        btMeshPartData *m_meshPartsPtr;
+        btVector3FloatData m_scaling;
+        int m_numMeshParts;
+        char m_padding[4];
+    };
+
+
+// -------------------------------------------------- //
+    class btTriangleMeshShapeData
+    {
+    public:
+        btCollisionShapeData m_collisionShapeData;
+        btStridingMeshInterfaceData m_meshInterface;
+        btQuantizedBvhFloatData *m_quantizedFloatBvh;
+        btQuantizedBvhDoubleData *m_quantizedDoubleBvh;
+        btTriangleInfoMapData *m_triangleInfoMap;
+        float m_collisionMargin;
+        char m_pad3[4];
+    };
+
+
+// -------------------------------------------------- //
+    class btScaledTriangleMeshShapeData
+    {
+    public:
+        btTriangleMeshShapeData m_trimeshShapeData;
+        btVector3FloatData m_localScaling;
+    };
+
+
+// -------------------------------------------------- //
+    class btCompoundShapeChildData
+    {
+    public:
+        btTransformFloatData m_transform;
+        btCollisionShapeData *m_childShape;
+        int m_childShapeType;
+        float m_childMargin;
+    };
+
+
+// -------------------------------------------------- //
+    class btCompoundShapeData
+    {
+    public:
+        btCollisionShapeData m_collisionShapeData;
+        btCompoundShapeChildData *m_childShapePtr;
+        int m_numChildShapes;
+        float m_collisionMargin;
+    };
+
+
+// -------------------------------------------------- //
+    class btCylinderShapeData
+    {
+    public:
+        btConvexInternalShapeData m_convexInternalShapeData;
+        int m_upAxis;
+        char m_padding[4];
+    };
+
+
+// -------------------------------------------------- //
+    class btConeShapeData
+    {
+    public:
+        btConvexInternalShapeData m_convexInternalShapeData;
+        int m_upIndex;
+        char m_padding[4];
+    };
+
+
+// -------------------------------------------------- //
+    class btCapsuleShapeData
+    {
+    public:
+        btConvexInternalShapeData m_convexInternalShapeData;
+        int m_upAxis;
+        char m_padding[4];
+    };
+
+
+// -------------------------------------------------- //
+    class btTriangleInfoData
+    {
+    public:
+        int m_flags;
+        float m_edgeV0V1Angle;
+        float m_edgeV1V2Angle;
+        float m_edgeV2V0Angle;
+    };
+
+
+// -------------------------------------------------- //
+    class btTriangleInfoMapData
+    {
+    public:
+        int *m_hashTablePtr;
+        int *m_nextPtr;
+        btTriangleInfoData *m_valueArrayPtr;
+        int *m_keyArrayPtr;
+        float m_convexEpsilon;
+        float m_planarEpsilon;
+        float m_equalVertexThreshold;
+        float m_edgeDistanceThreshold;
+        float m_zeroAreaThreshold;
+        int m_nextSize;
+        int m_hashTableSize;
+        int m_numValues;
+        int m_numKeys;
+        char m_padding[4];
+    };
+
+
+// -------------------------------------------------- //
+    class btPersistentManifoldDoubleData
+    {
+    public:
+        btVector3DoubleData m_pointCacheLocalPointA[4];
+        btVector3DoubleData m_pointCacheLocalPointB[4];
+        btVector3DoubleData m_pointCachePositionWorldOnA[4];
+        btVector3DoubleData m_pointCachePositionWorldOnB[4];
+        btVector3DoubleData m_pointCacheNormalWorldOnB[4];
+        btVector3DoubleData m_pointCacheLateralFrictionDir1[4];
+        btVector3DoubleData m_pointCacheLateralFrictionDir2[4];
+        double m_pointCacheDistance[4];
+        double m_pointCacheAppliedImpulse[4];
+        double m_pointCachePrevRHS[4];
+        double m_pointCacheCombinedFriction[4];
+        double m_pointCacheCombinedRollingFriction[4];
+        double m_pointCacheCombinedSpinningFriction[4];
+        double m_pointCacheCombinedRestitution[4];
+        int m_pointCachePartId0[4];
+        int m_pointCachePartId1[4];
+        int m_pointCacheIndex0[4];
+        int m_pointCacheIndex1[4];
+        int m_pointCacheContactPointFlags[4];
+        double m_pointCacheAppliedImpulseLateral1[4];
+        double m_pointCacheAppliedImpulseLateral2[4];
+        double m_pointCacheContactMotion1[4];
+        double m_pointCacheContactMotion2[4];
+        double m_pointCacheContactCFM[4];
+        double m_pointCacheCombinedContactStiffness1[4];
+        double m_pointCacheContactERP[4];
+        double m_pointCacheCombinedContactDamping1[4];
+        double m_pointCacheFrictionCFM[4];
+        int m_pointCacheLifeTime[4];
+        int m_numCachedPoints;
+        int m_companionIdA;
+        int m_companionIdB;
+        int m_index1a;
+        int m_objectType;
+        double m_contactBreakingThreshold;
+        double m_contactProcessingThreshold;
+        int m_padding;
+        btCollisionObjectDoubleData *m_body0;
+        btCollisionObjectDoubleData *m_body1;
+    };
+
+
+// -------------------------------------------------- //
+    class btPersistentManifoldFloatData
+    {
+    public:
+        btVector3FloatData m_pointCacheLocalPointA[4];
+        btVector3FloatData m_pointCacheLocalPointB[4];
+        btVector3FloatData m_pointCachePositionWorldOnA[4];
+        btVector3FloatData m_pointCachePositionWorldOnB[4];
+        btVector3FloatData m_pointCacheNormalWorldOnB[4];
+        btVector3FloatData m_pointCacheLateralFrictionDir1[4];
+        btVector3FloatData m_pointCacheLateralFrictionDir2[4];
+        float m_pointCacheDistance[4];
+        float m_pointCacheAppliedImpulse[4];
+        float m_pointCachePrevRHS[4];
+        float m_pointCacheCombinedFriction[4];
+        float m_pointCacheCombinedRollingFriction[4];
+        float m_pointCacheCombinedSpinningFriction[4];
+        float m_pointCacheCombinedRestitution[4];
+        int m_pointCachePartId0[4];
+        int m_pointCachePartId1[4];
+        int m_pointCacheIndex0[4];
+        int m_pointCacheIndex1[4];
+        int m_pointCacheContactPointFlags[4];
+        float m_pointCacheAppliedImpulseLateral1[4];
+        float m_pointCacheAppliedImpulseLateral2[4];
+        float m_pointCacheContactMotion1[4];
+        float m_pointCacheContactMotion2[4];
+        float m_pointCacheContactCFM[4];
+        float m_pointCacheCombinedContactStiffness1[4];
+        float m_pointCacheContactERP[4];
+        float m_pointCacheCombinedContactDamping1[4];
+        float m_pointCacheFrictionCFM[4];
+        int m_pointCacheLifeTime[4];
+        int m_numCachedPoints;
+        int m_companionIdA;
+        int m_companionIdB;
+        int m_index1a;
+        int m_objectType;
+        float m_contactBreakingThreshold;
+        float m_contactProcessingThreshold;
+        int m_padding;
+        btCollisionObjectFloatData *m_body0;
+        btCollisionObjectFloatData *m_body1;
+    };
+
+
+// -------------------------------------------------- //
+    class btGImpactMeshShapeData
+    {
+    public:
+        btCollisionShapeData m_collisionShapeData;
+        btStridingMeshInterfaceData m_meshInterface;
+        btVector3FloatData m_localScaling;
+        float m_collisionMargin;
+        int m_gimpactSubType;
+    };
+
+
+// -------------------------------------------------- //
+    class btConvexHullShapeData
+    {
+    public:
+        btConvexInternalShapeData m_convexInternalShapeData;
+        btVector3FloatData *m_unscaledPointsFloatPtr;
+        btVector3DoubleData *m_unscaledPointsDoublePtr;
+        int m_numUnscaledPoints;
+        char m_padding3[4];
+    };
+
+
+// -------------------------------------------------- //
+    class btCollisionObjectDoubleData
+    {
+    public:
+        void *m_broadphaseHandle;
+        void *m_collisionShape;
+        btCollisionShapeData *m_rootCollisionShape;
+        char *m_name;
+        btTransformDoubleData m_worldTransform;
+        btTransformDoubleData m_interpolationWorldTransform;
+        btVector3DoubleData m_interpolationLinearVelocity;
+        btVector3DoubleData m_interpolationAngularVelocity;
+        btVector3DoubleData m_anisotropicFriction;
+        double m_contactProcessingThreshold;
+        double m_deactivationTime;
+        double m_friction;
+        double m_rollingFriction;
+        double m_contactDamping;
+        double m_contactStiffness;
+        double m_restitution;
+        double m_hitFraction;
+        double m_ccdSweptSphereRadius;
+        double m_ccdMotionThreshold;
+        int m_hasAnisotropicFriction;
+        int m_collisionFlags;
+        int m_islandTag1;
+        int m_companionId;
+        int m_activationState1;
+        int m_internalType;
+        int m_checkCollideWith;
+        int m_collisionFilterGroup;
+        int m_collisionFilterMask;
+        int m_uniqueId;
+    };
+
+
+// -------------------------------------------------- //
+    class btCollisionObjectFloatData
+    {
+    public:
+        void *m_broadphaseHandle;
+        void *m_collisionShape;
+        btCollisionShapeData *m_rootCollisionShape;
+        char *m_name;
+        btTransformFloatData m_worldTransform;
+        btTransformFloatData m_interpolationWorldTransform;
+        btVector3FloatData m_interpolationLinearVelocity;
+        btVector3FloatData m_interpolationAngularVelocity;
+        btVector3FloatData m_anisotropicFriction;
+        float m_contactProcessingThreshold;
+        float m_deactivationTime;
+        float m_friction;
+        float m_rollingFriction;
+        float m_contactDamping;
+        float m_contactStiffness;
+        float m_restitution;
+        float m_hitFraction;
+        float m_ccdSweptSphereRadius;
+        float m_ccdMotionThreshold;
+        int m_hasAnisotropicFriction;
+        int m_collisionFlags;
+        int m_islandTag1;
+        int m_companionId;
+        int m_activationState1;
+        int m_internalType;
+        int m_checkCollideWith;
+        int m_collisionFilterGroup;
+        int m_collisionFilterMask;
+        int m_uniqueId;
+    };
+
+
+// -------------------------------------------------- //
+    class btContactSolverInfoDoubleData
+    {
+    public:
+        double m_tau;
+        double m_damping;
+        double m_friction;
+        double m_timeStep;
+        double m_restitution;
+        double m_maxErrorReduction;
+        double m_sor;
+        double m_erp;
+        double m_erp2;
+        double m_globalCfm;
+        double m_splitImpulsePenetrationThreshold;
+        double m_splitImpulseTurnErp;
+        double m_linearSlop;
+        double m_warmstartingFactor;
+        double m_articulatedWarmstartingFactor;
+        double m_maxGyroscopicForce;
+        double m_singleAxisRollingFrictionThreshold;
+        int m_numIterations;
+        int m_solverMode;
+        int m_restingContactRestitutionThreshold;
+        int m_minimumSolverBatchSize;
+        int m_splitImpulse;
+        char m_padding[4];
+    };
+
+
+// -------------------------------------------------- //
+    class btContactSolverInfoFloatData
+    {
+    public:
+        float m_tau;
+        float m_damping;
+        float m_friction;
+        float m_timeStep;
+        float m_restitution;
+        float m_maxErrorReduction;
+        float m_sor;
+        float m_erp;
+        float m_erp2;
+        float m_globalCfm;
+        float m_splitImpulsePenetrationThreshold;
+        float m_splitImpulseTurnErp;
+        float m_linearSlop;
+        float m_warmstartingFactor;
+        float m_articulatedWarmstartingFactor;
+        float m_maxGyroscopicForce;
+        float m_singleAxisRollingFrictionThreshold;
+        int m_numIterations;
+        int m_solverMode;
+        int m_restingContactRestitutionThreshold;
+        int m_minimumSolverBatchSize;
+        int m_splitImpulse;
+    };
+
+
+// -------------------------------------------------- //
+    class btDynamicsWorldDoubleData
+    {
+    public:
+        btContactSolverInfoDoubleData m_solverInfo;
+        btVector3DoubleData m_gravity;
+    };
+
+
+// -------------------------------------------------- //
+    class btDynamicsWorldFloatData
+    {
+    public:
+        btContactSolverInfoFloatData m_solverInfo;
+        btVector3FloatData m_gravity;
+    };
+
+
+// -------------------------------------------------- //
+    class btRigidBodyFloatData
+    {
+    public:
+        btCollisionObjectFloatData m_collisionObjectData;
+        btMatrix3x3FloatData m_invInertiaTensorWorld;
+        btVector3FloatData m_linearVelocity;
+        btVector3FloatData m_angularVelocity;
+        btVector3FloatData m_angularFactor;
+        btVector3FloatData m_linearFactor;
+        btVector3FloatData m_gravity;
+        btVector3FloatData m_gravity_acceleration;
+        btVector3FloatData m_invInertiaLocal;
+        btVector3FloatData m_totalForce;
+        btVector3FloatData m_totalTorque;
+        float m_inverseMass;
+        float m_linearDamping;
+        float m_angularDamping;
+        float m_additionalDampingFactor;
+        float m_additionalLinearDampingThresholdSqr;
+        float m_additionalAngularDampingThresholdSqr;
+        float m_additionalAngularDampingFactor;
+        float m_linearSleepingThreshold;
+        float m_angularSleepingThreshold;
+        int m_additionalDamping;
+    };
+
+
+// -------------------------------------------------- //
+    class btRigidBodyDoubleData
+    {
+    public:
+        btCollisionObjectDoubleData m_collisionObjectData;
+        btMatrix3x3DoubleData m_invInertiaTensorWorld;
+        btVector3DoubleData m_linearVelocity;
+        btVector3DoubleData m_angularVelocity;
+        btVector3DoubleData m_angularFactor;
+        btVector3DoubleData m_linearFactor;
+        btVector3DoubleData m_gravity;
+        btVector3DoubleData m_gravity_acceleration;
+        btVector3DoubleData m_invInertiaLocal;
+        btVector3DoubleData m_totalForce;
+        btVector3DoubleData m_totalTorque;
+        double m_inverseMass;
+        double m_linearDamping;
+        double m_angularDamping;
+        double m_additionalDampingFactor;
+        double m_additionalLinearDampingThresholdSqr;
+        double m_additionalAngularDampingThresholdSqr;
+        double m_additionalAngularDampingFactor;
+        double m_linearSleepingThreshold;
+        double m_angularSleepingThreshold;
+        int m_additionalDamping;
+        char m_padding[4];
+    };
+
+
+// -------------------------------------------------- //
+    class btConstraintInfo1
+    {
+    public:
+        int m_numConstraintRows;
+        int nub;
+    };
+
+
+// -------------------------------------------------- //
+    class btTypedConstraintFloatData
+    {
+    public:
+        btRigidBodyFloatData *m_rbA;
+        btRigidBodyFloatData *m_rbB;
+        char *m_name;
+        int m_objectType;
+        int m_userConstraintType;
+        int m_userConstraintId;
+        int m_needsFeedback;
+        float m_appliedImpulse;
+        float m_dbgDrawSize;
+        int m_disableCollisionsBetweenLinkedBodies;
+        int m_overrideNumSolverIterations;
+        float m_breakingImpulseThreshold;
+        int m_isEnabled;
+    };
+
+
+// -------------------------------------------------- //
+    class btTypedConstraintData
+    {
+    public:
+        bInvalidHandle *m_rbA;
+        bInvalidHandle *m_rbB;
+        char *m_name;
+        int m_objectType;
+        int m_userConstraintType;
+        int m_userConstraintId;
+        int m_needsFeedback;
+        float m_appliedImpulse;
+        float m_dbgDrawSize;
+        int m_disableCollisionsBetweenLinkedBodies;
+        int m_overrideNumSolverIterations;
+        float m_breakingImpulseThreshold;
+        int m_isEnabled;
+    };
+
+
+// -------------------------------------------------- //
+    class btTypedConstraintDoubleData
+    {
+    public:
+        btRigidBodyDoubleData *m_rbA;
+        btRigidBodyDoubleData *m_rbB;
+        char *m_name;
+        int m_objectType;
+        int m_userConstraintType;
+        int m_userConstraintId;
+        int m_needsFeedback;
+        double m_appliedImpulse;
+        double m_dbgDrawSize;
+        int m_disableCollisionsBetweenLinkedBodies;
+        int m_overrideNumSolverIterations;
+        double m_breakingImpulseThreshold;
+        int m_isEnabled;
+        char padding[4];
+    };
+
+
+// -------------------------------------------------- //
+    class btPoint2PointConstraintFloatData
+    {
+    public:
+        btTypedConstraintData m_typeConstraintData;
+        btVector3FloatData m_pivotInA;
+        btVector3FloatData m_pivotInB;
+    };
+
+
+// -------------------------------------------------- //
+    class btPoint2PointConstraintDoubleData2
+    {
+    public:
+        btTypedConstraintDoubleData m_typeConstraintData;
+        btVector3DoubleData m_pivotInA;
+        btVector3DoubleData m_pivotInB;
+    };
+
+
+// -------------------------------------------------- //
+    class btPoint2PointConstraintDoubleData
+    {
+    public:
+        btTypedConstraintData m_typeConstraintData;
+        btVector3DoubleData m_pivotInA;
+        btVector3DoubleData m_pivotInB;
+    };
+
+
+// -------------------------------------------------- //
+    class btHingeConstraintDoubleData
+    {
+    public:
+        btTypedConstraintData m_typeConstraintData;
+        btTransformDoubleData m_rbAFrame;
+        btTransformDoubleData m_rbBFrame;
+        int m_useReferenceFrameA;
+        int m_angularOnly;
+        int m_enableAngularMotor;
+        float m_motorTargetVelocity;
+        float m_maxMotorImpulse;
+        float m_lowerLimit;
+        float m_upperLimit;
+        float m_limitSoftness;
+        float m_biasFactor;
+        float m_relaxationFactor;
+    };
+
+
+// -------------------------------------------------- //
+    class btHingeConstraintFloatData
+    {
+    public:
+        btTypedConstraintData m_typeConstraintData;
+        btTransformFloatData m_rbAFrame;
+        btTransformFloatData m_rbBFrame;
+        int m_useReferenceFrameA;
+        int m_angularOnly;
+        int m_enableAngularMotor;
+        float m_motorTargetVelocity;
+        float m_maxMotorImpulse;
+        float m_lowerLimit;
+        float m_upperLimit;
+        float m_limitSoftness;
+        float m_biasFactor;
+        float m_relaxationFactor;
+    };
+
+
+// -------------------------------------------------- //
+    class btHingeConstraintDoubleData2
+    {
+    public:
+        btTypedConstraintDoubleData m_typeConstraintData;
+        btTransformDoubleData m_rbAFrame;
+        btTransformDoubleData m_rbBFrame;
+        int m_useReferenceFrameA;
+        int m_angularOnly;
+        int m_enableAngularMotor;
+        double m_motorTargetVelocity;
+        double m_maxMotorImpulse;
+        double m_lowerLimit;
+        double m_upperLimit;
+        double m_limitSoftness;
+        double m_biasFactor;
+        double m_relaxationFactor;
+        char m_padding1[4];
+    };
+
+
+// -------------------------------------------------- //
+    class btConeTwistConstraintDoubleData
+    {
+    public:
+        btTypedConstraintDoubleData m_typeConstraintData;
+        btTransformDoubleData m_rbAFrame;
+        btTransformDoubleData m_rbBFrame;
+        double m_swingSpan1;
+        double m_swingSpan2;
+        double m_twistSpan;
+        double m_limitSoftness;
+        double m_biasFactor;
+        double m_relaxationFactor;
+        double m_damping;
+    };
+
+
+// -------------------------------------------------- //
+    class btConeTwistConstraintData
+    {
+    public:
+        btTypedConstraintData m_typeConstraintData;
+        btTransformFloatData m_rbAFrame;
+        btTransformFloatData m_rbBFrame;
+        float m_swingSpan1;
+        float m_swingSpan2;
+        float m_twistSpan;
+        float m_limitSoftness;
+        float m_biasFactor;
+        float m_relaxationFactor;
+        float m_damping;
+        char m_pad[4];
+    };
+
+
+// -------------------------------------------------- //
+    class btGeneric6DofConstraintData
+    {
+    public:
+        btTypedConstraintData m_typeConstraintData;
+        btTransformFloatData m_rbAFrame;
+        btTransformFloatData m_rbBFrame;
+        btVector3FloatData m_linearUpperLimit;
+        btVector3FloatData m_linearLowerLimit;
+        btVector3FloatData m_angularUpperLimit;
+        btVector3FloatData m_angularLowerLimit;
+        int m_useLinearReferenceFrameA;
+        int m_useOffsetForConstraintFrame;
+    };
+
+
+// -------------------------------------------------- //
+    class btGeneric6DofConstraintDoubleData2
+    {
+    public:
+        btTypedConstraintDoubleData m_typeConstraintData;
+        btTransformDoubleData m_rbAFrame;
+        btTransformDoubleData m_rbBFrame;
+        btVector3DoubleData m_linearUpperLimit;
+        btVector3DoubleData m_linearLowerLimit;
+        btVector3DoubleData m_angularUpperLimit;
+        btVector3DoubleData m_angularLowerLimit;
+        int m_useLinearReferenceFrameA;
+        int m_useOffsetForConstraintFrame;
+    };
+
+
+// -------------------------------------------------- //
+    class btGeneric6DofSpringConstraintData
+    {
+    public:
+        btGeneric6DofConstraintData m_6dofData;
+        int m_springEnabled[6];
+        float m_equilibriumPoint[6];
+        float m_springStiffness[6];
+        float m_springDamping[6];
+    };
+
+
+// -------------------------------------------------- //
+    class btGeneric6DofSpringConstraintDoubleData2
+    {
+    public:
+        btGeneric6DofConstraintDoubleData2 m_6dofData;
+        int m_springEnabled[6];
+        double m_equilibriumPoint[6];
+        double m_springStiffness[6];
+        double m_springDamping[6];
+    };
+
+
+// -------------------------------------------------- //
+    class btGeneric6DofSpring2ConstraintData
+    {
+    public:
+        btTypedConstraintData m_typeConstraintData;
+        btTransformFloatData m_rbAFrame;
+        btTransformFloatData m_rbBFrame;
+        btVector3FloatData m_linearUpperLimit;
+        btVector3FloatData m_linearLowerLimit;
+        btVector3FloatData m_linearBounce;
+        btVector3FloatData m_linearStopERP;
+        btVector3FloatData m_linearStopCFM;
+        btVector3FloatData m_linearMotorERP;
+        btVector3FloatData m_linearMotorCFM;
+        btVector3FloatData m_linearTargetVelocity;
+        btVector3FloatData m_linearMaxMotorForce;
+        btVector3FloatData m_linearServoTarget;
+        btVector3FloatData m_linearSpringStiffness;
+        btVector3FloatData m_linearSpringDamping;
+        btVector3FloatData m_linearEquilibriumPoint;
+        char m_linearEnableMotor[4];
+        char m_linearServoMotor[4];
+        char m_linearEnableSpring[4];
+        char m_linearSpringStiffnessLimited[4];
+        char m_linearSpringDampingLimited[4];
+        char m_padding1[4];
+        btVector3FloatData m_angularUpperLimit;
+        btVector3FloatData m_angularLowerLimit;
+        btVector3FloatData m_angularBounce;
+        btVector3FloatData m_angularStopERP;
+        btVector3FloatData m_angularStopCFM;
+        btVector3FloatData m_angularMotorERP;
+        btVector3FloatData m_angularMotorCFM;
+        btVector3FloatData m_angularTargetVelocity;
+        btVector3FloatData m_angularMaxMotorForce;
+        btVector3FloatData m_angularServoTarget;
+        btVector3FloatData m_angularSpringStiffness;
+        btVector3FloatData m_angularSpringDamping;
+        btVector3FloatData m_angularEquilibriumPoint;
+        char m_angularEnableMotor[4];
+        char m_angularServoMotor[4];
+        char m_angularEnableSpring[4];
+        char m_angularSpringStiffnessLimited[4];
+        char m_angularSpringDampingLimited[4];
+        int m_rotateOrder;
+    };
+
+
+// -------------------------------------------------- //
+    class btGeneric6DofSpring2ConstraintDoubleData2
+    {
+    public:
+        btTypedConstraintDoubleData m_typeConstraintData;
+        btTransformDoubleData m_rbAFrame;
+        btTransformDoubleData m_rbBFrame;
+        btVector3DoubleData m_linearUpperLimit;
+        btVector3DoubleData m_linearLowerLimit;
+        btVector3DoubleData m_linearBounce;
+        btVector3DoubleData m_linearStopERP;
+        btVector3DoubleData m_linearStopCFM;
+        btVector3DoubleData m_linearMotorERP;
+        btVector3DoubleData m_linearMotorCFM;
+        btVector3DoubleData m_linearTargetVelocity;
+        btVector3DoubleData m_linearMaxMotorForce;
+        btVector3DoubleData m_linearServoTarget;
+        btVector3DoubleData m_linearSpringStiffness;
+        btVector3DoubleData m_linearSpringDamping;
+        btVector3DoubleData m_linearEquilibriumPoint;
+        char m_linearEnableMotor[4];
+        char m_linearServoMotor[4];
+        char m_linearEnableSpring[4];
+        char m_linearSpringStiffnessLimited[4];
+        char m_linearSpringDampingLimited[4];
+        char m_padding1[4];
+        btVector3DoubleData m_angularUpperLimit;
+        btVector3DoubleData m_angularLowerLimit;
+        btVector3DoubleData m_angularBounce;
+        btVector3DoubleData m_angularStopERP;
+        btVector3DoubleData m_angularStopCFM;
+        btVector3DoubleData m_angularMotorERP;
+        btVector3DoubleData m_angularMotorCFM;
+        btVector3DoubleData m_angularTargetVelocity;
+        btVector3DoubleData m_angularMaxMotorForce;
+        btVector3DoubleData m_angularServoTarget;
+        btVector3DoubleData m_angularSpringStiffness;
+        btVector3DoubleData m_angularSpringDamping;
+        btVector3DoubleData m_angularEquilibriumPoint;
+        char m_angularEnableMotor[4];
+        char m_angularServoMotor[4];
+        char m_angularEnableSpring[4];
+        char m_angularSpringStiffnessLimited[4];
+        char m_angularSpringDampingLimited[4];
+        int m_rotateOrder;
+    };
+
+
+// -------------------------------------------------- //
+    class btSliderConstraintData
+    {
+    public:
+        btTypedConstraintData m_typeConstraintData;
+        btTransformFloatData m_rbAFrame;
+        btTransformFloatData m_rbBFrame;
+        float m_linearUpperLimit;
+        float m_linearLowerLimit;
+        float m_angularUpperLimit;
+        float m_angularLowerLimit;
+        int m_useLinearReferenceFrameA;
+        int m_useOffsetForConstraintFrame;
+    };
+
+
+// -------------------------------------------------- //
+    class btSliderConstraintDoubleData
+    {
+    public:
+        btTypedConstraintDoubleData m_typeConstraintData;
+        btTransformDoubleData m_rbAFrame;
+        btTransformDoubleData m_rbBFrame;
+        double m_linearUpperLimit;
+        double m_linearLowerLimit;
+        double m_angularUpperLimit;
+        double m_angularLowerLimit;
+        int m_useLinearReferenceFrameA;
+        int m_useOffsetForConstraintFrame;
+    };
+
+
+// -------------------------------------------------- //
+    class btGearConstraintFloatData
+    {
+    public:
+        btTypedConstraintFloatData m_typeConstraintData;
+        btVector3FloatData m_axisInA;
+        btVector3FloatData m_axisInB;
+        float m_ratio;
+        char m_padding[4];
+    };
+
+
+// -------------------------------------------------- //
+    class btGearConstraintDoubleData
+    {
+    public:
+        btTypedConstraintDoubleData m_typeConstraintData;
+        btVector3DoubleData m_axisInA;
+        btVector3DoubleData m_axisInB;
+        double m_ratio;
+    };
+
+
+// -------------------------------------------------- //
+    class SoftBodyMaterialData
+    {
+    public:
+        float m_linearStiffness;
+        float m_angularStiffness;
+        float m_volumeStiffness;
+        int m_flags;
+    };
+
+
+// -------------------------------------------------- //
+    class SoftBodyNodeData
+    {
+    public:
+        SoftBodyMaterialData *m_material;
+        btVector3FloatData m_position;
+        btVector3FloatData m_previousPosition;
+        btVector3FloatData m_velocity;
+        btVector3FloatData m_accumulatedForce;
+        btVector3FloatData m_normal;
+        float m_inverseMass;
+        float m_area;
+        int m_attach;
+        int m_pad;
+    };
+
+
+// -------------------------------------------------- //
+    class SoftBodyLinkData
+    {
+    public:
+        SoftBodyMaterialData *m_material;
+        int m_nodeIndices[2];
+        float m_restLength;
+        int m_bbending;
+    };
+
+
+// -------------------------------------------------- //
+    class SoftBodyFaceData
+    {
+    public:
+        btVector3FloatData m_normal;
+        SoftBodyMaterialData *m_material;
+        int m_nodeIndices[3];
+        float m_restArea;
+    };
+
+
+// -------------------------------------------------- //
+    class SoftBodyTetraData
+    {
+    public:
+        btVector3FloatData m_c0[4];
+        SoftBodyMaterialData *m_material;
+        int m_nodeIndices[4];
+        float m_restVolume;
+        float m_c1;
+        float m_c2;
+        int m_pad;
+    };
+
+
+// -------------------------------------------------- //
+    class SoftRigidAnchorData
+    {
+    public:
+        btMatrix3x3FloatData m_c0;
+        btVector3FloatData m_c1;
+        btVector3FloatData m_localFrame;
+        bInvalidHandle *m_rigidBody;
+        int m_nodeIndex;
+        float m_c2;
+    };
+
+
+// -------------------------------------------------- //
+    class SoftBodyConfigData
+    {
+    public:
+        int m_aeroModel;
+        float m_baumgarte;
+        float m_damping;
+        float m_drag;
+        float m_lift;
+        float m_pressure;
+        float m_volume;
+        float m_dynamicFriction;
+        float m_poseMatch;
+        float m_rigidContactHardness;
+        float m_kineticContactHardness;
+        float m_softContactHardness;
+        float m_anchorHardness;
+        float m_softRigidClusterHardness;
+        float m_softKineticClusterHardness;
+        float m_softSoftClusterHardness;
+        float m_softRigidClusterImpulseSplit;
+        float m_softKineticClusterImpulseSplit;
+        float m_softSoftClusterImpulseSplit;
+        float m_maxVolume;
+        float m_timeScale;
+        int m_velocityIterations;
+        int m_positionIterations;
+        int m_driftIterations;
+        int m_clusterIterations;
+        int m_collisionFlags;
+    };
+
+
+// -------------------------------------------------- //
+    class SoftBodyPoseData
+    {
+    public:
+        btMatrix3x3FloatData m_rot;
+        btMatrix3x3FloatData m_scale;
+        btMatrix3x3FloatData m_aqq;
+        btVector3FloatData m_com;
+        btVector3FloatData *m_positions;
+        float *m_weights;
+        int m_numPositions;
+        int m_numWeigts;
+        int m_bvolume;
+        int m_bframe;
+        float m_restVolume;
+        int m_pad;
+    };
+
+
+// -------------------------------------------------- //
+    class SoftBodyClusterData
+    {
+    public:
+        btTransformFloatData m_framexform;
+        btMatrix3x3FloatData m_locii;
+        btMatrix3x3FloatData m_invwi;
+        btVector3FloatData m_com;
+        btVector3FloatData m_vimpulses[2];
+        btVector3FloatData m_dimpulses[2];
+        btVector3FloatData m_lv;
+        btVector3FloatData m_av;
+        btVector3FloatData *m_framerefs;
+        int *m_nodeIndices;
+        float *m_masses;
+        int m_numFrameRefs;
+        int m_numNodes;
+        int m_numMasses;
+        float m_idmass;
+        float m_imass;
+        int m_nvimpulses;
+        int m_ndimpulses;
+        float m_ndamping;
+        float m_ldamping;
+        float m_adamping;
+        float m_matching;
+        float m_maxSelfCollisionImpulse;
+        float m_selfCollisionImpulseFactor;
+        int m_containsAnchor;
+        int m_collide;
+        int m_clusterIndex;
+    };
+
+
+// -------------------------------------------------- //
+    class btSoftBodyJointData
+    {
+    public:
+        void *m_bodyA;
+        void *m_bodyB;
+        btVector3FloatData m_refs[2];
+        float m_cfm;
+        float m_erp;
+        float m_split;
+        int m_delete;
+        btVector3FloatData m_relPosition[2];
+        int m_bodyAtype;
+        int m_bodyBtype;
+        int m_jointType;
+        int m_pad;
+    };
+
+
+// -------------------------------------------------- //
+    class btSoftBodyFloatData
+    {
+    public:
+        btCollisionObjectFloatData m_collisionObjectData;
+        SoftBodyPoseData *m_pose;
+        SoftBodyMaterialData **m_materials;
+        SoftBodyNodeData *m_nodes;
+        SoftBodyLinkData *m_links;
+        SoftBodyFaceData *m_faces;
+        SoftBodyTetraData *m_tetrahedra;
+        SoftRigidAnchorData *m_anchors;
+        SoftBodyClusterData *m_clusters;
+        btSoftBodyJointData *m_joints;
+        int m_numMaterials;
+        int m_numNodes;
+        int m_numLinks;
+        int m_numFaces;
+        int m_numTetrahedra;
+        int m_numAnchors;
+        int m_numClusters;
+        int m_numJoints;
+        SoftBodyConfigData m_config;
+    };
+
+
+// -------------------------------------------------- //
+    class btMultiBodyLinkDoubleData
+    {
+    public:
+        btQuaternionDoubleData m_zeroRotParentToThis;
+        btVector3DoubleData m_parentComToThisPivotOffset;
+        btVector3DoubleData m_thisPivotToThisComOffset;
+        btVector3DoubleData m_jointAxisTop[6];
+        btVector3DoubleData m_jointAxisBottom[6];
+        btVector3DoubleData m_linkInertia;
+        btVector3DoubleData m_absFrameTotVelocityTop;
+        btVector3DoubleData m_absFrameTotVelocityBottom;
+        btVector3DoubleData m_absFrameLocVelocityTop;
+        btVector3DoubleData m_absFrameLocVelocityBottom;
+        double m_linkMass;
+        int m_parentIndex;
+        int m_jointType;
+        int m_dofCount;
+        int m_posVarCount;
+        double m_jointPos[7];
+        double m_jointVel[6];
+        double m_jointTorque[6];
+        double m_jointDamping;
+        double m_jointFriction;
+        double m_jointLowerLimit;
+        double m_jointUpperLimit;
+        double m_jointMaxForce;
+        double m_jointMaxVelocity;
+        char *m_linkName;
+        char *m_jointName;
+        btCollisionObjectDoubleData *m_linkCollider;
+        char *m_paddingPtr;
+    };
+
+
+// -------------------------------------------------- //
+    class btMultiBodyLinkFloatData
+    {
+    public:
+        btQuaternionFloatData m_zeroRotParentToThis;
+        btVector3FloatData m_parentComToThisPivotOffset;
+        btVector3FloatData m_thisPivotToThisComOffset;
+        btVector3FloatData m_jointAxisTop[6];
+        btVector3FloatData m_jointAxisBottom[6];
+        btVector3FloatData m_linkInertia;
+        btVector3FloatData m_absFrameTotVelocityTop;
+        btVector3FloatData m_absFrameTotVelocityBottom;
+        btVector3FloatData m_absFrameLocVelocityTop;
+        btVector3FloatData m_absFrameLocVelocityBottom;
+        int m_dofCount;
+        float m_linkMass;
+        int m_parentIndex;
+        int m_jointType;
+        float m_jointPos[7];
+        float m_jointVel[6];
+        float m_jointTorque[6];
+        int m_posVarCount;
+        float m_jointDamping;
+        float m_jointFriction;
+        float m_jointLowerLimit;
+        float m_jointUpperLimit;
+        float m_jointMaxForce;
+        float m_jointMaxVelocity;
+        char *m_linkName;
+        char *m_jointName;
+        btCollisionObjectFloatData *m_linkCollider;
+        char *m_paddingPtr;
+    };
+
+
+// -------------------------------------------------- //
+    class btMultiBodyDoubleData
+    {
+    public:
+        btVector3DoubleData m_baseWorldPosition;
+        btQuaternionDoubleData m_baseWorldOrientation;
+        btVector3DoubleData m_baseLinearVelocity;
+        btVector3DoubleData m_baseAngularVelocity;
+        btVector3DoubleData m_baseInertia;
+        double m_baseMass;
+        int m_numLinks;
+        char m_padding[4];
+        char *m_baseName;
+        btMultiBodyLinkDoubleData *m_links;
+        btCollisionObjectDoubleData *m_baseCollider;
+    };
+
+
+// -------------------------------------------------- //
+    class btMultiBodyFloatData
+    {
+    public:
+        btVector3FloatData m_baseWorldPosition;
+        btQuaternionFloatData m_baseWorldOrientation;
+        btVector3FloatData m_baseLinearVelocity;
+        btVector3FloatData m_baseAngularVelocity;
+        btVector3FloatData m_baseInertia;
+        float m_baseMass;
+        int m_numLinks;
+        char *m_baseName;
+        btMultiBodyLinkFloatData *m_links;
+        btCollisionObjectFloatData *m_baseCollider;
+    };
+
+
+// -------------------------------------------------- //
+    class btMultiBodyLinkColliderFloatData
+    {
+    public:
+        btCollisionObjectFloatData m_colObjData;
+        btMultiBodyFloatData *m_multiBody;
+        int m_link;
+        char m_padding[4];
+    };
+
+
+// -------------------------------------------------- //
+    class btMultiBodyLinkColliderDoubleData
+    {
+    public:
+        btCollisionObjectDoubleData m_colObjData;
+        btMultiBodyDoubleData *m_multiBody;
+        int m_link;
+        char m_padding[4];
+    };
+
+
+}
+#endif//__BULLET_H__
\ No newline at end of file
diff --git a/engine/inc/bullet/BulletFileLoader/bChunk.h b/engine/inc/bullet/BulletFileLoader/bChunk.h
new file mode 100644
index 00000000..514a35a3
--- /dev/null
+++ b/engine/inc/bullet/BulletFileLoader/bChunk.h
@@ -0,0 +1,84 @@
+/*
+bParse
+Copyright (c) 2006-2009 Charlie C & Erwin Coumans  http://gamekit.googlecode.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef __BCHUNK_H__
+#define __BCHUNK_H__
+
+#if defined(_WIN32) && !defined(__MINGW32__)
+#define long64 __int64
+#elif defined(__MINGW32__)
+#include <stdint.h>
+#define long64 int64_t
+#else
+#define long64 long long
+#endif
+
+namespace bParse
+{
+// ----------------------------------------------------- //
+class bChunkPtr4
+{
+public:
+	bChunkPtr4() {}
+	int code;
+	int len;
+	union {
+		int m_uniqueInt;
+	};
+	int dna_nr;
+	int nr;
+};
+
+// ----------------------------------------------------- //
+class bChunkPtr8
+{
+public:
+	bChunkPtr8() {}
+	int code, len;
+	union {
+		long64 oldPrev;
+		int m_uniqueInts[2];
+	};
+	int dna_nr, nr;
+};
+
+// ----------------------------------------------------- //
+class bChunkInd
+{
+public:
+	bChunkInd() {}
+	int code, len;
+	void *oldPtr;
+	int dna_nr, nr;
+};
+
+// ----------------------------------------------------- //
+class ChunkUtils
+{
+public:
+	// file chunk offset
+	static int getOffset(int flags);
+
+	// endian utils
+	static short swapShort(short sht);
+	static int swapInt(int inte);
+	static long64 swapLong64(long64 lng);
+};
+
+const int CHUNK_HEADER_LEN = ((sizeof(bChunkInd)));
+const bool VOID_IS_8 = ((sizeof(void *) == 8));
+}  // namespace bParse
+
+#endif  //__BCHUNK_H__
diff --git a/engine/inc/bullet/BulletFileLoader/bCommon.h b/engine/inc/bullet/BulletFileLoader/bCommon.h
new file mode 100644
index 00000000..a3f599f8
--- /dev/null
+++ b/engine/inc/bullet/BulletFileLoader/bCommon.h
@@ -0,0 +1,40 @@
+/*
+bParse
+Copyright (c) 2006-2009 Charlie C & Erwin Coumans  http://gamekit.googlecode.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef __BCOMMON_H__
+#define __BCOMMON_H__
+
+#include <assert.h>
+//#include "bLog.h"
+#include "LinearMath/btAlignedObjectArray.h"
+#include "LinearMath/btHashMap.h"
+
+namespace bParse
+{
+class bMain;
+class bFileData;
+class bFile;
+class bDNA;
+
+// delete void* undefined
+typedef struct bStructHandle
+{
+	int unused;
+} bStructHandle;
+typedef btAlignedObjectArray<bStructHandle*> bListBasePtr;
+typedef btHashMap<btHashPtr, bStructHandle*> bPtrMap;
+}  // namespace bParse
+
+#endif  //__BCOMMON_H__
diff --git a/engine/inc/bullet/BulletFileLoader/bDNA.h b/engine/inc/bullet/BulletFileLoader/bDNA.h
new file mode 100644
index 00000000..4b1c530f
--- /dev/null
+++ b/engine/inc/bullet/BulletFileLoader/bDNA.h
@@ -0,0 +1,101 @@
+/*
+bParse
+Copyright (c) 2006-2009 Charlie C & Erwin Coumans  http://gamekit.googlecode.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef __BDNA_H__
+#define __BDNA_H__
+
+#include "bCommon.h"
+
+namespace bParse
+{
+struct bNameInfo
+{
+	char *m_name;
+	bool m_isPointer;
+	int m_dim0;
+	int m_dim1;
+};
+
+class bDNA
+{
+public:
+	bDNA();
+	~bDNA();
+
+	void init(char *data, int len, bool swap = false);
+
+	int getArraySize(char *str);
+	int getArraySizeNew(short name)
+	{
+		const bNameInfo &nameInfo = m_Names[name];
+		return nameInfo.m_dim0 * nameInfo.m_dim1;
+	}
+	int getElementSize(short type, short name)
+	{
+		const bNameInfo &nameInfo = m_Names[name];
+		int size = nameInfo.m_isPointer ? mPtrLen * nameInfo.m_dim0 * nameInfo.m_dim1 : mTlens[type] * nameInfo.m_dim0 * nameInfo.m_dim1;
+		return size;
+	}
+
+	int getNumNames() const
+	{
+		return m_Names.size();
+	}
+
+	char *getName(int ind);
+	char *getType(int ind);
+	short *getStruct(int ind);
+	short getLength(int ind);
+	int getReverseType(short type);
+	int getReverseType(const char *type);
+
+	int getNumStructs();
+
+	//
+	bool lessThan(bDNA *other);
+
+	void initCmpFlags(bDNA *memDNA);
+	bool flagNotEqual(int dna_nr);
+	bool flagEqual(int dna_nr);
+	bool flagNone(int dna_nr);
+
+	int getPointerSize();
+
+	void dumpTypeDefinitions();
+
+private:
+	enum FileDNAFlags
+	{
+		FDF_NONE = 0,
+		FDF_STRUCT_NEQU,
+		FDF_STRUCT_EQU
+	};
+
+	void initRecurseCmpFlags(int i);
+
+	btAlignedObjectArray<int> mCMPFlags;
+
+	btAlignedObjectArray<bNameInfo> m_Names;
+	btAlignedObjectArray<char *> mTypes;
+	btAlignedObjectArray<short *> mStructs;
+	btAlignedObjectArray<short> mTlens;
+	btHashMap<btHashInt, int> mStructReverse;
+	btHashMap<btHashString, int> mTypeLookup;
+
+	int mPtrLen;
+};
+}  // namespace bParse
+
+#endif  //__BDNA_H__
diff --git a/engine/inc/bullet/BulletFileLoader/bDefines.h b/engine/inc/bullet/BulletFileLoader/bDefines.h
new file mode 100644
index 00000000..c5ad20ac
--- /dev/null
+++ b/engine/inc/bullet/BulletFileLoader/bDefines.h
@@ -0,0 +1,152 @@
+/* Copyright (C) 2006-2009 Charlie C & Erwin Coumans http://gamekit.googlecode.com
+*
+* This software is provided 'as-is', without any express or implied
+* warranty.  In no event will the authors be held liable for any damages
+* arising from the use of this software.
+*
+* Permission is granted to anyone to use this software for any purpose,
+* including commercial applications, and to alter it and redistribute it
+* freely, subject to the following restrictions:
+*
+* 1. The origin of this software must not be misrepresented; you must not
+*    claim that you wrote the original software. If you use this software
+*    in a product, an acknowledgment in the product documentation would be
+*    appreciated but is not required.
+* 2. Altered source versions must be plainly marked as such, and must not be
+*    misrepresented as being the original software.
+* 3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef __B_DEFINES_H__
+#define __B_DEFINES_H__
+
+// MISC defines, see BKE_global.h, BKE_utildefines.h
+#define SIZEOFBLENDERHEADER 12
+
+// ------------------------------------------------------------
+#if defined(__sgi) || defined(__sparc) || defined(__sparc__) || defined(__PPC__) || defined(__ppc__) || defined(__BIG_ENDIAN__)
+#define MAKE_ID(a, b, c, d) ((int)(a) << 24 | (int)(b) << 16 | (c) << 8 | (d))
+#else
+#define MAKE_ID(a, b, c, d) ((int)(d) << 24 | (int)(c) << 16 | (b) << 8 | (a))
+#endif
+
+// ------------------------------------------------------------
+#if defined(__sgi) || defined(__sparc) || defined(__sparc__) || defined(__PPC__) || defined(__ppc__) || defined(__BIG_ENDIAN__)
+#define MAKE_ID2(c, d) ((c) << 8 | (d))
+#define MOST_SIG_BYTE 0
+#define BBIG_ENDIAN
+#else
+#define MAKE_ID2(c, d) ((d) << 8 | (c))
+#define MOST_SIG_BYTE 1
+#define BLITTLE_ENDIAN
+#endif
+
+// ------------------------------------------------------------
+#define ID_SCE MAKE_ID2('S', 'C')
+#define ID_LI MAKE_ID2('L', 'I')
+#define ID_OB MAKE_ID2('O', 'B')
+#define ID_ME MAKE_ID2('M', 'E')
+#define ID_CU MAKE_ID2('C', 'U')
+#define ID_MB MAKE_ID2('M', 'B')
+#define ID_MA MAKE_ID2('M', 'A')
+#define ID_TE MAKE_ID2('T', 'E')
+#define ID_IM MAKE_ID2('I', 'M')
+#define ID_IK MAKE_ID2('I', 'K')
+#define ID_WV MAKE_ID2('W', 'V')
+#define ID_LT MAKE_ID2('L', 'T')
+#define ID_SE MAKE_ID2('S', 'E')
+#define ID_LF MAKE_ID2('L', 'F')
+#define ID_LA MAKE_ID2('L', 'A')
+#define ID_CA MAKE_ID2('C', 'A')
+#define ID_IP MAKE_ID2('I', 'P')
+#define ID_KE MAKE_ID2('K', 'E')
+#define ID_WO MAKE_ID2('W', 'O')
+#define ID_SCR MAKE_ID2('S', 'R')
+#define ID_VF MAKE_ID2('V', 'F')
+#define ID_TXT MAKE_ID2('T', 'X')
+#define ID_SO MAKE_ID2('S', 'O')
+#define ID_SAMPLE MAKE_ID2('S', 'A')
+#define ID_GR MAKE_ID2('G', 'R')
+#define ID_ID MAKE_ID2('I', 'D')
+#define ID_AR MAKE_ID2('A', 'R')
+#define ID_AC MAKE_ID2('A', 'C')
+#define ID_SCRIPT MAKE_ID2('P', 'Y')
+#define ID_FLUIDSIM MAKE_ID2('F', 'S')
+#define ID_NT MAKE_ID2('N', 'T')
+#define ID_BR MAKE_ID2('B', 'R')
+
+#define ID_SEQ MAKE_ID2('S', 'Q')
+#define ID_CO MAKE_ID2('C', 'O')
+#define ID_PO MAKE_ID2('A', 'C')
+#define ID_NLA MAKE_ID2('N', 'L')
+
+#define ID_VS MAKE_ID2('V', 'S')
+#define ID_VN MAKE_ID2('V', 'N')
+
+// ------------------------------------------------------------
+#define FORM MAKE_ID('F', 'O', 'R', 'M')
+#define DDG1 MAKE_ID('3', 'D', 'G', '1')
+#define DDG2 MAKE_ID('3', 'D', 'G', '2')
+#define DDG3 MAKE_ID('3', 'D', 'G', '3')
+#define DDG4 MAKE_ID('3', 'D', 'G', '4')
+#define GOUR MAKE_ID('G', 'O', 'U', 'R')
+#define BLEN MAKE_ID('B', 'L', 'E', 'N')
+#define DER_ MAKE_ID('D', 'E', 'R', '_')
+#define V100 MAKE_ID('V', '1', '0', '0')
+#define DATA MAKE_ID('D', 'A', 'T', 'A')
+#define GLOB MAKE_ID('G', 'L', 'O', 'B')
+#define IMAG MAKE_ID('I', 'M', 'A', 'G')
+#define USER MAKE_ID('U', 'S', 'E', 'R')
+
+// ------------------------------------------------------------
+#define DNA1 MAKE_ID('D', 'N', 'A', '1')
+#define REND MAKE_ID('R', 'E', 'N', 'D')
+#define ENDB MAKE_ID('E', 'N', 'D', 'B')
+#define NAME MAKE_ID('N', 'A', 'M', 'E')
+#define SDNA MAKE_ID('S', 'D', 'N', 'A')
+#define TYPE MAKE_ID('T', 'Y', 'P', 'E')
+#define TLEN MAKE_ID('T', 'L', 'E', 'N')
+#define STRC MAKE_ID('S', 'T', 'R', 'C')
+
+// ------------------------------------------------------------
+#define SWITCH_INT(a)       \
+	{                       \
+		char s_i, *p_i;     \
+		p_i = (char *)&(a); \
+		s_i = p_i[0];       \
+		p_i[0] = p_i[3];    \
+		p_i[3] = s_i;       \
+		s_i = p_i[1];       \
+		p_i[1] = p_i[2];    \
+		p_i[2] = s_i;       \
+	}
+
+// ------------------------------------------------------------
+#define SWITCH_SHORT(a)     \
+	{                       \
+		char s_i, *p_i;     \
+		p_i = (char *)&(a); \
+		s_i = p_i[0];       \
+		p_i[0] = p_i[1];    \
+		p_i[1] = s_i;       \
+	}
+
+// ------------------------------------------------------------
+#define SWITCH_LONGINT(a)   \
+	{                       \
+		char s_i, *p_i;     \
+		p_i = (char *)&(a); \
+		s_i = p_i[0];       \
+		p_i[0] = p_i[7];    \
+		p_i[7] = s_i;       \
+		s_i = p_i[1];       \
+		p_i[1] = p_i[6];    \
+		p_i[6] = s_i;       \
+		s_i = p_i[2];       \
+		p_i[2] = p_i[5];    \
+		p_i[5] = s_i;       \
+		s_i = p_i[3];       \
+		p_i[3] = p_i[4];    \
+		p_i[4] = s_i;       \
+	}
+
+#endif  //__B_DEFINES_H__
diff --git a/engine/inc/bullet/BulletFileLoader/bFile.h b/engine/inc/bullet/BulletFileLoader/bFile.h
new file mode 100644
index 00000000..f6fae97e
--- /dev/null
+++ b/engine/inc/bullet/BulletFileLoader/bFile.h
@@ -0,0 +1,166 @@
+/*
+bParse
+Copyright (c) 2006-2009 Charlie C & Erwin Coumans  http://gamekit.googlecode.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef __BFILE_H__
+#define __BFILE_H__
+
+#include "bCommon.h"
+#include "bChunk.h"
+#include <stdio.h>
+
+namespace bParse
+{
+// ----------------------------------------------------- //
+enum bFileFlags
+{
+	FD_INVALID = 0,
+	FD_OK = 1,
+	FD_VOID_IS_8 = 2,
+	FD_ENDIAN_SWAP = 4,
+	FD_FILE_64 = 8,
+	FD_BITS_VARIES = 16,
+	FD_VERSION_VARIES = 32,
+	FD_DOUBLE_PRECISION = 64,
+	FD_BROKEN_DNA = 128,
+	FD_FILEDNA_IS_MEMDNA = 256
+};
+
+enum bFileVerboseMode
+{
+	FD_VERBOSE_EXPORT_XML = 1,
+	FD_VERBOSE_DUMP_DNA_TYPE_DEFINITIONS = 2,
+	FD_VERBOSE_DUMP_CHUNKS = 4,
+	FD_VERBOSE_DUMP_FILE_INFO = 8,
+};
+// ----------------------------------------------------- //
+class bFile
+{
+protected:
+	char m_headerString[7];
+
+	bool mOwnsBuffer;
+	char* mFileBuffer;
+	int mFileLen;
+	int mVersion;
+
+	bPtrMap mLibPointers;
+
+	int mDataStart;
+	bDNA* mFileDNA;
+	bDNA* mMemoryDNA;
+
+	btAlignedObjectArray<char*> m_pointerFixupArray;
+	btAlignedObjectArray<char*> m_pointerPtrFixupArray;
+
+	btAlignedObjectArray<bChunkInd> m_chunks;
+	btHashMap<btHashPtr, bChunkInd> m_chunkPtrPtrMap;
+
+	//
+
+	bPtrMap mDataPointers;
+
+	int mFlags;
+
+	// ////////////////////////////////////////////////////////////////////////////
+
+	// buffer offset util
+	int getNextBlock(bChunkInd* dataChunk, const char* dataPtr, const int flags);
+	void safeSwapPtr(char* dst, const char* src);
+
+	virtual void parseHeader();
+
+	virtual void parseData() = 0;
+
+	void resolvePointersMismatch();
+	void resolvePointersChunk(const bChunkInd& dataChunk, int verboseMode);
+
+	int resolvePointersStructRecursive(char* strcPtr, int old_dna, int verboseMode, int recursion);
+	//void swapPtr(char *dst, char *src);
+
+	void parseStruct(char* strcPtr, char* dtPtr, int old_dna, int new_dna, bool fixupPointers);
+	void getMatchingFileDNA(short* old, const char* lookupName, const char* lookupType, char* strcData, char* data, bool fixupPointers);
+	char* getFileElement(short* firstStruct, char* lookupName, char* lookupType, char* data, short** foundPos);
+
+	void swap(char* head, class bChunkInd& ch, bool ignoreEndianFlag);
+	void swapData(char* data, short type, int arraySize, bool ignoreEndianFlag);
+	void swapStruct(int dna_nr, char* data, bool ignoreEndianFlag);
+	void swapLen(char* dataPtr);
+	void swapDNA(char* ptr);
+
+	char* readStruct(char* head, class bChunkInd& chunk);
+	char* getAsString(int code);
+
+	virtual void parseInternal(int verboseMode, char* memDna, int memDnaLength);
+
+public:
+	bFile(const char* filename, const char headerString[7]);
+
+	//todo: make memoryBuffer const char
+	//bFile( const char *memoryBuffer, int len);
+	bFile(char* memoryBuffer, int len, const char headerString[7]);
+	virtual ~bFile();
+
+	bDNA* getFileDNA()
+	{
+		return mFileDNA;
+	}
+
+	virtual void addDataBlock(char* dataBlock) = 0;
+
+	int getFlags() const
+	{
+		return mFlags;
+	}
+
+	void setFileDNAisMemoryDNA()
+	{
+		mFlags |= FD_FILEDNA_IS_MEMDNA;
+	}
+
+	bPtrMap& getLibPointers()
+	{
+		return mLibPointers;
+	}
+
+	void* findLibPointer(void* ptr);
+
+	bool ok();
+
+	virtual void parse(int verboseMode) = 0;
+
+	virtual int write(const char* fileName, bool fixupPointers = false) = 0;
+
+	virtual void writeChunks(FILE* fp, bool fixupPointers);
+
+	virtual void writeDNA(FILE* fp) = 0;
+
+	void updateOldPointers();
+	void resolvePointers(int verboseMode);
+
+	void dumpChunks(bDNA* dna);
+
+	virtual void setFileDNA(int verboseMode, char* buffer, int len);
+
+	int getVersion() const
+	{
+		return mVersion;
+	}
+	//pre-swap the endianness, so that data loaded on a target with different endianness doesn't need to be swapped
+	void preSwap();
+	void writeFile(const char* fileName);
+};
+}  // namespace bParse
+
+#endif  //__BFILE_H__
diff --git a/engine/inc/bullet/BulletFileLoader/btBulletFile.h b/engine/inc/bullet/BulletFileLoader/btBulletFile.h
new file mode 100644
index 00000000..d7c1cb7e
--- /dev/null
+++ b/engine/inc/bullet/BulletFileLoader/btBulletFile.h
@@ -0,0 +1,80 @@
+/*
+bParse
+Copyright (c) 2006-2010 Charlie C & Erwin Coumans  http://gamekit.googlecode.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_BULLET_FILE_H
+#define BT_BULLET_FILE_H
+
+#include "bFile.h"
+#include "LinearMath/btAlignedObjectArray.h"
+#include "bDefines.h"
+
+#include "LinearMath/btSerializer.h"
+
+namespace bParse
+{
+// ----------------------------------------------------- //
+class btBulletFile : public bFile
+{
+protected:
+	char* m_DnaCopy;
+
+public:
+	btAlignedObjectArray<bStructHandle*> m_multiBodies;
+
+	btAlignedObjectArray<bStructHandle*> m_multiBodyLinkColliders;
+
+	btAlignedObjectArray<bStructHandle*> m_softBodies;
+
+	btAlignedObjectArray<bStructHandle*> m_rigidBodies;
+
+	btAlignedObjectArray<bStructHandle*> m_collisionObjects;
+
+	btAlignedObjectArray<bStructHandle*> m_collisionShapes;
+
+	btAlignedObjectArray<bStructHandle*> m_constraints;
+
+	btAlignedObjectArray<bStructHandle*> m_bvhs;
+
+	btAlignedObjectArray<bStructHandle*> m_triangleInfoMaps;
+
+	btAlignedObjectArray<bStructHandle*> m_dynamicsWorldInfo;
+
+	btAlignedObjectArray<bStructHandle*> m_contactManifolds;
+
+	btAlignedObjectArray<char*> m_dataBlocks;
+	btBulletFile();
+
+	btBulletFile(const char* fileName);
+
+	btBulletFile(char* memoryBuffer, int len);
+
+	virtual ~btBulletFile();
+
+	virtual void addDataBlock(char* dataBlock);
+
+	// experimental
+	virtual int write(const char* fileName, bool fixupPointers = false);
+
+	virtual void parse(int verboseMode);
+
+	virtual void parseData();
+
+	virtual void writeDNA(FILE* fp);
+
+	void addStruct(const char* structType, void* data, int len, void* oldPtr, int code);
+};
+};  // namespace bParse
+
+#endif  //BT_BULLET_FILE_H
diff --git a/engine/inc/bullet/BulletInverseDynamics/btBulletCollisionCommon.h b/engine/inc/bullet/BulletInverseDynamics/btBulletCollisionCommon.h
new file mode 100644
index 00000000..4f523756
--- /dev/null
+++ b/engine/inc/bullet/BulletInverseDynamics/btBulletCollisionCommon.h
@@ -0,0 +1,65 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BULLET_COLLISION_COMMON_H
+#define BULLET_COLLISION_COMMON_H
+
+///Common headerfile includes for Bullet Collision Detection
+
+///Bullet's btCollisionWorld and btCollisionObject definitions
+#include "BulletCollision/CollisionDispatch/btCollisionWorld.h"
+#include "BulletCollision/CollisionDispatch/btCollisionObject.h"
+
+///Collision Shapes
+#include "BulletCollision/CollisionShapes/btBoxShape.h"
+#include "BulletCollision/CollisionShapes/btSphereShape.h"
+#include "BulletCollision/CollisionShapes/btCapsuleShape.h"
+#include "BulletCollision/CollisionShapes/btCylinderShape.h"
+#include "BulletCollision/CollisionShapes/btConeShape.h"
+#include "BulletCollision/CollisionShapes/btStaticPlaneShape.h"
+#include "BulletCollision/CollisionShapes/btConvexHullShape.h"
+#include "BulletCollision/CollisionShapes/btTriangleMesh.h"
+#include "BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h"
+#include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h"
+#include "BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h"
+#include "BulletCollision/CollisionShapes/btTriangleMeshShape.h"
+#include "BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h"
+#include "BulletCollision/CollisionShapes/btCompoundShape.h"
+#include "BulletCollision/CollisionShapes/btTetrahedronShape.h"
+#include "BulletCollision/CollisionShapes/btEmptyShape.h"
+#include "BulletCollision/CollisionShapes/btMultiSphereShape.h"
+#include "BulletCollision/CollisionShapes/btUniformScalingShape.h"
+
+///Narrowphase Collision Detector
+#include "BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h"
+
+//#include "BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h"
+#include "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h"
+
+///Dispatching and generation of collision pairs (broadphase)
+#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h"
+#include "BulletCollision/BroadphaseCollision/btSimpleBroadphase.h"
+#include "BulletCollision/BroadphaseCollision/btAxisSweep3.h"
+#include "BulletCollision/BroadphaseCollision/btDbvtBroadphase.h"
+
+///Math library & Utils
+#include "LinearMath/btQuaternion.h"
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btDefaultMotionState.h"
+#include "LinearMath/btQuickprof.h"
+#include "LinearMath/btIDebugDraw.h"
+#include "LinearMath/btSerializer.h"
+
+#endif  //BULLET_COLLISION_COMMON_H
diff --git a/engine/inc/bullet/BulletRobotics/BoxStack.h b/engine/inc/bullet/BulletRobotics/BoxStack.h
new file mode 100644
index 00000000..289b4b03
--- /dev/null
+++ b/engine/inc/bullet/BulletRobotics/BoxStack.h
@@ -0,0 +1,21 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2016 Google Inc. http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BOX_STACK_EXAMPLE_H
+#define BOX_STACK_EXAMPLE_H
+
+class CommonExampleInterface* BoxStackExampleCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //BOX_STACK_EXAMPLE_H
diff --git a/engine/inc/bullet/BulletRobotics/FixJointBoxes.h b/engine/inc/bullet/BulletRobotics/FixJointBoxes.h
new file mode 100644
index 00000000..c8a305df
--- /dev/null
+++ b/engine/inc/bullet/BulletRobotics/FixJointBoxes.h
@@ -0,0 +1,21 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2016 Google Inc. http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef FIX_JOINT_BOXES_H
+#define FIX_JOINT_BOXES_H
+
+class CommonExampleInterface* FixJointBoxesCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //FIX_JOINT_BOXES_H
diff --git a/engine/inc/bullet/BulletRobotics/JointLimit.h b/engine/inc/bullet/BulletRobotics/JointLimit.h
new file mode 100644
index 00000000..c8a125e5
--- /dev/null
+++ b/engine/inc/bullet/BulletRobotics/JointLimit.h
@@ -0,0 +1,21 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2016 Google Inc. http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef JOINT_LIMIT_EXAMPLE_H
+#define JOINT_LIMIT_EXAMPLE_H
+
+class CommonExampleInterface* JointLimitCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //JOINT_LIMIT_EXAMPLE_H
diff --git a/engine/inc/bullet/BulletSoftBody/DeformableBodyInplaceSolverIslandCallback.h b/engine/inc/bullet/BulletSoftBody/DeformableBodyInplaceSolverIslandCallback.h
new file mode 100644
index 00000000..01c7e93a
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/DeformableBodyInplaceSolverIslandCallback.h
@@ -0,0 +1,45 @@
+//
+//  DeformableBodyInplaceSolverIslandCallback.h
+//  BulletSoftBody
+//
+//  Created by Xuchen Han on 12/16/19.
+//
+
+#ifndef DeformableBodyInplaceSolverIslandCallback_h
+#define DeformableBodyInplaceSolverIslandCallback_h
+
+struct DeformableBodyInplaceSolverIslandCallback : public MultiBodyInplaceSolverIslandCallback
+{
+	btDeformableMultiBodyConstraintSolver* m_deformableSolver;
+
+	DeformableBodyInplaceSolverIslandCallback(btDeformableMultiBodyConstraintSolver* solver,
+											  btDispatcher* dispatcher)
+		: MultiBodyInplaceSolverIslandCallback(solver, dispatcher), m_deformableSolver(solver)
+	{
+	}
+
+	virtual void processConstraints(int islandId = -1)
+	{
+		btCollisionObject** bodies = m_bodies.size() ? &m_bodies[0] : 0;
+		btCollisionObject** softBodies = m_softBodies.size() ? &m_softBodies[0] : 0;
+		btPersistentManifold** manifold = m_manifolds.size() ? &m_manifolds[0] : 0;
+		btTypedConstraint** constraints = m_constraints.size() ? &m_constraints[0] : 0;
+		btMultiBodyConstraint** multiBodyConstraints = m_multiBodyConstraints.size() ? &m_multiBodyConstraints[0] : 0;
+
+		//printf("mb contacts = %d, mb constraints = %d\n", mbContacts, m_multiBodyConstraints.size());
+
+		m_deformableSolver->solveDeformableBodyGroup(bodies, m_bodies.size(), softBodies, m_softBodies.size(), manifold, m_manifolds.size(), constraints, m_constraints.size(), multiBodyConstraints, m_multiBodyConstraints.size(), *m_solverInfo, m_debugDrawer, m_dispatcher);
+		if (m_bodies.size() && (m_solverInfo->m_reportSolverAnalytics & 1))
+		{
+			m_deformableSolver->m_analyticsData.m_islandId = islandId;
+			m_islandAnalyticsData.push_back(m_solver->m_analyticsData);
+		}
+		m_bodies.resize(0);
+		m_softBodies.resize(0);
+		m_manifolds.resize(0);
+		m_constraints.resize(0);
+		m_multiBodyConstraints.resize(0);
+	}
+};
+
+#endif /* DeformableBodyInplaceSolverIslandCallback_h */
diff --git a/engine/inc/bullet/BulletSoftBody/btCGProjection.h b/engine/inc/bullet/BulletSoftBody/btCGProjection.h
new file mode 100644
index 00000000..e0597066
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btCGProjection.h
@@ -0,0 +1,104 @@
+/*
+ Written by Xuchen Han <xuchenhan2015@u.northwestern.edu>
+ 
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef BT_CG_PROJECTION_H
+#define BT_CG_PROJECTION_H
+
+#include "btSoftBody.h"
+#include "BulletDynamics/Featherstone/btMultiBodyLinkCollider.h"
+#include "BulletDynamics/Featherstone/btMultiBodyConstraint.h"
+
+struct DeformableContactConstraint
+{
+	const btSoftBody::Node* m_node;
+	btAlignedObjectArray<const btSoftBody::RContact*> m_contact;
+	btAlignedObjectArray<btVector3> m_total_normal_dv;
+	btAlignedObjectArray<btVector3> m_total_tangent_dv;
+	btAlignedObjectArray<bool> m_static;
+	btAlignedObjectArray<bool> m_can_be_dynamic;
+
+	DeformableContactConstraint(const btSoftBody::RContact& rcontact) : m_node(rcontact.m_node)
+	{
+		append(rcontact);
+	}
+
+	DeformableContactConstraint() : m_node(NULL)
+	{
+		m_contact.push_back(NULL);
+	}
+
+	void append(const btSoftBody::RContact& rcontact)
+	{
+		m_contact.push_back(&rcontact);
+		m_total_normal_dv.push_back(btVector3(0, 0, 0));
+		m_total_tangent_dv.push_back(btVector3(0, 0, 0));
+		m_static.push_back(false);
+		m_can_be_dynamic.push_back(true);
+	}
+
+	void replace(const btSoftBody::RContact& rcontact)
+	{
+		m_contact.clear();
+		m_total_normal_dv.clear();
+		m_total_tangent_dv.clear();
+		m_static.clear();
+		m_can_be_dynamic.clear();
+		append(rcontact);
+	}
+
+	~DeformableContactConstraint()
+	{
+	}
+};
+
+class btCGProjection
+{
+public:
+	typedef btAlignedObjectArray<btVector3> TVStack;
+	typedef btAlignedObjectArray<btAlignedObjectArray<btVector3> > TVArrayStack;
+	typedef btAlignedObjectArray<btAlignedObjectArray<btScalar> > TArrayStack;
+	btAlignedObjectArray<btSoftBody*>& m_softBodies;
+	const btScalar& m_dt;
+	// map from node indices to node pointers
+	const btAlignedObjectArray<btSoftBody::Node*>* m_nodes;
+
+	btCGProjection(btAlignedObjectArray<btSoftBody*>& softBodies, const btScalar& dt)
+		: m_softBodies(softBodies), m_dt(dt)
+	{
+	}
+
+	virtual ~btCGProjection()
+	{
+	}
+
+	// apply the constraints
+	virtual void project(TVStack& x) = 0;
+
+	virtual void setConstraints() = 0;
+
+	// update the constraints
+	virtual btScalar update() = 0;
+
+	virtual void reinitialize(bool nodeUpdated)
+	{
+	}
+
+	virtual void setIndices(const btAlignedObjectArray<btSoftBody::Node*>* nodes)
+	{
+		m_nodes = nodes;
+	}
+};
+
+#endif /* btCGProjection_h */
diff --git a/engine/inc/bullet/BulletSoftBody/btConjugateGradient.h b/engine/inc/bullet/BulletSoftBody/btConjugateGradient.h
new file mode 100644
index 00000000..bcd5e6b5
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btConjugateGradient.h
@@ -0,0 +1,117 @@
+/*
+ Written by Xuchen Han <xuchenhan2015@u.northwestern.edu>
+ 
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef BT_CONJUGATE_GRADIENT_H
+#define BT_CONJUGATE_GRADIENT_H
+#include "btKrylovSolver.h"
+template <class MatrixX>
+class btConjugateGradient : public btKrylovSolver<MatrixX>
+{
+	typedef btAlignedObjectArray<btVector3> TVStack;
+	typedef btKrylovSolver<MatrixX> Base;
+	TVStack r, p, z, temp;
+
+public:
+	btConjugateGradient(const int max_it_in)
+		: btKrylovSolver<MatrixX>(max_it_in, SIMD_EPSILON)
+	{
+	}
+
+	virtual ~btConjugateGradient() {}
+
+	// return the number of iterations taken
+	int solve(MatrixX& A, TVStack& x, const TVStack& b, bool verbose = false)
+	{
+		BT_PROFILE("CGSolve");
+		btAssert(x.size() == b.size());
+		reinitialize(b);
+		temp = b;
+		A.project(temp);
+		p = temp;
+		A.precondition(p, z);
+		btScalar d0 = this->dot(z, temp);
+		d0 = btMin(btScalar(1), d0);
+		// r = b - A * x --with assigned dof zeroed out
+		A.multiply(x, temp);
+		r = this->sub(b, temp);
+		A.project(r);
+		// z = M^(-1) * r
+		A.precondition(r, z);
+		A.project(z);
+		btScalar r_dot_z = this->dot(z, r);
+		if (r_dot_z <= Base::m_tolerance * d0)
+		{
+			if (verbose)
+			{
+				std::cout << "Iteration = 0" << std::endl;
+				std::cout << "Two norm of the residual = " << r_dot_z << std::endl;
+			}
+			return 0;
+		}
+		p = z;
+		btScalar r_dot_z_new = r_dot_z;
+		for (int k = 1; k <= Base::m_maxIterations; k++)
+		{
+			// temp = A*p
+			A.multiply(p, temp);
+			A.project(temp);
+			if (this->dot(p, temp) < 0)
+			{
+				if (verbose)
+					std::cout << "Encountered negative direction in CG!" << std::endl;
+				if (k == 1)
+				{
+					x = b;
+				}
+				return k;
+			}
+			// alpha = r^T * z / (p^T * A * p)
+			btScalar alpha = r_dot_z_new / this->dot(p, temp);
+			//  x += alpha * p;
+			this->multAndAddTo(alpha, p, x);
+			//  r -= alpha * temp;
+			this->multAndAddTo(-alpha, temp, r);
+			// z = M^(-1) * r
+			A.precondition(r, z);
+			r_dot_z = r_dot_z_new;
+			r_dot_z_new = this->dot(r, z);
+			if (r_dot_z_new < Base::m_tolerance * d0)
+			{
+				if (verbose)
+				{
+					std::cout << "ConjugateGradient iterations " << k << " residual = " << r_dot_z_new << std::endl;
+				}
+				return k;
+			}
+
+			btScalar beta = r_dot_z_new / r_dot_z;
+			p = this->multAndAdd(beta, p, z);
+		}
+		if (verbose)
+		{
+			std::cout << "ConjugateGradient max iterations reached " << Base::m_maxIterations << " error = " << r_dot_z_new << std::endl;
+		}
+		return Base::m_maxIterations;
+	}
+
+	void reinitialize(const TVStack& b)
+	{
+		r.resize(b.size());
+		p.resize(b.size());
+		z.resize(b.size());
+		temp.resize(b.size());
+	}
+};
+#endif /* btConjugateGradient_h */
diff --git a/engine/inc/bullet/BulletSoftBody/btConjugateResidual.h b/engine/inc/bullet/BulletSoftBody/btConjugateResidual.h
new file mode 100644
index 00000000..61461203
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btConjugateResidual.h
@@ -0,0 +1,112 @@
+/*
+ Written by Xuchen Han <xuchenhan2015@u.northwestern.edu>
+ 
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef BT_CONJUGATE_RESIDUAL_H
+#define BT_CONJUGATE_RESIDUAL_H
+#include "btKrylovSolver.h"
+
+template <class MatrixX>
+class btConjugateResidual : public btKrylovSolver<MatrixX>
+{
+	typedef btAlignedObjectArray<btVector3> TVStack;
+	typedef btKrylovSolver<MatrixX> Base;
+	TVStack r, p, z, temp_p, temp_r, best_x;
+	// temp_r = A*r
+	// temp_p = A*p
+	// z = M^(-1) * temp_p = M^(-1) * A * p
+	btScalar best_r;
+
+public:
+	btConjugateResidual(const int max_it_in)
+		: Base(max_it_in, 1e-8)
+	{
+	}
+
+	virtual ~btConjugateResidual() {}
+
+	// return the number of iterations taken
+	int solve(MatrixX& A, TVStack& x, const TVStack& b, bool verbose = false)
+	{
+		BT_PROFILE("CRSolve");
+		btAssert(x.size() == b.size());
+		reinitialize(b);
+		// r = b - A * x --with assigned dof zeroed out
+		A.multiply(x, temp_r);  // borrow temp_r here to store A*x
+		r = this->sub(b, temp_r);
+		// z = M^(-1) * r
+		A.precondition(r, z);  // borrow z to store preconditioned r
+		r = z;
+		btScalar residual_norm = this->norm(r);
+		if (residual_norm <= Base::m_tolerance)
+		{
+			return 0;
+		}
+		p = r;
+		btScalar r_dot_Ar, r_dot_Ar_new;
+		// temp_p = A*p
+		A.multiply(p, temp_p);
+		// temp_r = A*r
+		temp_r = temp_p;
+		r_dot_Ar = this->dot(r, temp_r);
+		for (int k = 1; k <= Base::m_maxIterations; k++)
+		{
+			// z = M^(-1) * Ap
+			A.precondition(temp_p, z);
+			// alpha = r^T * A * r / (Ap)^T * M^-1 * Ap)
+			btScalar alpha = r_dot_Ar / this->dot(temp_p, z);
+			//  x += alpha * p;
+			this->multAndAddTo(alpha, p, x);
+			//  r -= alpha * z;
+			this->multAndAddTo(-alpha, z, r);
+			btScalar norm_r = this->norm(r);
+			if (norm_r < best_r)
+			{
+				best_x = x;
+				best_r = norm_r;
+				if (norm_r < Base::m_tolerance)
+				{
+					return k;
+				}
+			}
+			// temp_r = A * r;
+			A.multiply(r, temp_r);
+			r_dot_Ar_new = this->dot(r, temp_r);
+			btScalar beta = r_dot_Ar_new / r_dot_Ar;
+			r_dot_Ar = r_dot_Ar_new;
+			// p = beta*p + r;
+			p = this->multAndAdd(beta, p, r);
+			// temp_p = beta*temp_p + temp_r;
+			temp_p = this->multAndAdd(beta, temp_p, temp_r);
+		}
+		if (verbose)
+		{
+			std::cout << "ConjugateResidual max iterations reached, residual = " << best_r << std::endl;
+		}
+		x = best_x;
+		return Base::m_maxIterations;
+	}
+
+	void reinitialize(const TVStack& b)
+	{
+		r.resize(b.size());
+		p.resize(b.size());
+		z.resize(b.size());
+		temp_p.resize(b.size());
+		temp_r.resize(b.size());
+		best_x.resize(b.size());
+		best_r = SIMD_INFINITY;
+	}
+};
+#endif /* btConjugateResidual_h */
diff --git a/engine/inc/bullet/BulletSoftBody/btDefaultSoftBodySolver.h b/engine/inc/bullet/BulletSoftBody/btDefaultSoftBodySolver.h
new file mode 100644
index 00000000..3965b07c
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btDefaultSoftBodySolver.h
@@ -0,0 +1,60 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SOFT_BODY_DEFAULT_SOLVER_H
+#define BT_SOFT_BODY_DEFAULT_SOLVER_H
+
+#include "BulletSoftBody/btSoftBodySolvers.h"
+#include "btSoftBodySolverVertexBuffer.h"
+struct btCollisionObjectWrapper;
+
+class btDefaultSoftBodySolver : public btSoftBodySolver
+{
+protected:
+	/** Variable to define whether we need to update solver constants on the next iteration */
+	bool m_updateSolverConstants;
+
+	btAlignedObjectArray<btSoftBody *> m_softBodySet;
+
+public:
+	btDefaultSoftBodySolver();
+
+	virtual ~btDefaultSoftBodySolver();
+
+	virtual SolverTypes getSolverType() const
+	{
+		return DEFAULT_SOLVER;
+	}
+
+	virtual bool checkInitialized();
+
+	virtual void updateSoftBodies();
+
+	virtual void optimize(btAlignedObjectArray<btSoftBody *> &softBodies, bool forceUpdate = false);
+
+	virtual void copyBackToSoftBodies(bool bMove = true);
+
+	virtual void solveConstraints(btScalar solverdt);
+
+	virtual void predictMotion(btScalar solverdt);
+
+	virtual void copySoftBodyToVertexBuffer(const btSoftBody *const softBody, btVertexBufferDescriptor *vertexBuffer);
+
+	virtual void processCollision(btSoftBody *, const btCollisionObjectWrapper *);
+
+	virtual void processCollision(btSoftBody *, btSoftBody *);
+};
+
+#endif  // #ifndef BT_ACCELERATED_SOFT_BODY_CPU_SOLVER_H
diff --git a/engine/inc/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.h b/engine/inc/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.h
new file mode 100644
index 00000000..eb05b9f0
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.h
@@ -0,0 +1,198 @@
+/*
+ Written by Xuchen Han <xuchenhan2015@u.northwestern.edu>
+ 
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef BT_BACKWARD_EULER_OBJECTIVE_H
+#define BT_BACKWARD_EULER_OBJECTIVE_H
+//#include "btConjugateGradient.h"
+#include "btDeformableLagrangianForce.h"
+#include "btDeformableMassSpringForce.h"
+#include "btDeformableGravityForce.h"
+#include "btDeformableCorotatedForce.h"
+#include "btDeformableMousePickingForce.h"
+#include "btDeformableLinearElasticityForce.h"
+#include "btDeformableNeoHookeanForce.h"
+#include "btDeformableContactProjection.h"
+#include "btPreconditioner.h"
+#include "btDeformableMultiBodyDynamicsWorld.h"
+#include "LinearMath/btQuickprof.h"
+
+class btDeformableBackwardEulerObjective
+{
+public:
+	typedef btAlignedObjectArray<btVector3> TVStack;
+	btScalar m_dt;
+	btAlignedObjectArray<btDeformableLagrangianForce*> m_lf;
+	btAlignedObjectArray<btSoftBody*>& m_softBodies;
+	Preconditioner* m_preconditioner;
+	btDeformableContactProjection m_projection;
+	const TVStack& m_backupVelocity;
+	btAlignedObjectArray<btSoftBody::Node*> m_nodes;
+	bool m_implicit;
+	MassPreconditioner* m_massPreconditioner;
+	KKTPreconditioner* m_KKTPreconditioner;
+
+	btDeformableBackwardEulerObjective(btAlignedObjectArray<btSoftBody*>& softBodies, const TVStack& backup_v);
+
+	virtual ~btDeformableBackwardEulerObjective();
+
+	void initialize() {}
+
+	// compute the rhs for CG solve, i.e, add the dt scaled implicit force to residual
+	void computeResidual(btScalar dt, TVStack& residual);
+
+	// add explicit force to the velocity
+	void applyExplicitForce(TVStack& force);
+
+	// apply force to velocity and optionally reset the force to zero
+	void applyForce(TVStack& force, bool setZero);
+
+	// compute the norm of the residual
+	btScalar computeNorm(const TVStack& residual) const;
+
+	// compute one step of the solve (there is only one solve if the system is linear)
+	void computeStep(TVStack& dv, const TVStack& residual, const btScalar& dt);
+
+	// perform A*x = b
+	void multiply(const TVStack& x, TVStack& b) const;
+
+	// set initial guess for CG solve
+	void initialGuess(TVStack& dv, const TVStack& residual);
+
+	// reset data structure and reset dt
+	void reinitialize(bool nodeUpdated, btScalar dt);
+
+	void setDt(btScalar dt);
+
+	// add friction force to residual
+	void applyDynamicFriction(TVStack& r);
+
+	// add dv to velocity
+	void updateVelocity(const TVStack& dv);
+
+	//set constraints as projections
+	void setConstraints(const btContactSolverInfo& infoGlobal);
+
+	// update the projections and project the residual
+	void project(TVStack& r)
+	{
+		BT_PROFILE("project");
+		m_projection.project(r);
+	}
+
+	// perform precondition M^(-1) x = b
+	void precondition(const TVStack& x, TVStack& b)
+	{
+		m_preconditioner->operator()(x, b);
+	}
+
+	// reindex all the vertices
+	virtual void updateId()
+	{
+		size_t node_id = 0;
+		size_t face_id = 0;
+		m_nodes.clear();
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			btSoftBody* psb = m_softBodies[i];
+			for (int j = 0; j < psb->m_nodes.size(); ++j)
+			{
+				psb->m_nodes[j].index = node_id;
+				m_nodes.push_back(&psb->m_nodes[j]);
+				++node_id;
+			}
+			for (int j = 0; j < psb->m_faces.size(); ++j)
+			{
+				psb->m_faces[j].m_index = face_id;
+				++face_id;
+			}
+		}
+	}
+
+	const btAlignedObjectArray<btSoftBody::Node*>* getIndices() const
+	{
+		return &m_nodes;
+	}
+
+	void setImplicit(bool implicit)
+	{
+		m_implicit = implicit;
+	}
+
+	// Calculate the total potential energy in the system
+	btScalar totalEnergy(btScalar dt);
+
+	void addLagrangeMultiplier(const TVStack& vec, TVStack& extended_vec)
+	{
+		extended_vec.resize(vec.size() + m_projection.m_lagrangeMultipliers.size());
+		for (int i = 0; i < vec.size(); ++i)
+		{
+			extended_vec[i] = vec[i];
+		}
+		int offset = vec.size();
+		for (int i = 0; i < m_projection.m_lagrangeMultipliers.size(); ++i)
+		{
+			extended_vec[offset + i].setZero();
+		}
+	}
+
+	void addLagrangeMultiplierRHS(const TVStack& residual, const TVStack& m_dv, TVStack& extended_residual)
+	{
+		extended_residual.resize(residual.size() + m_projection.m_lagrangeMultipliers.size());
+		for (int i = 0; i < residual.size(); ++i)
+		{
+			extended_residual[i] = residual[i];
+		}
+		int offset = residual.size();
+		for (int i = 0; i < m_projection.m_lagrangeMultipliers.size(); ++i)
+		{
+			const LagrangeMultiplier& lm = m_projection.m_lagrangeMultipliers[i];
+			extended_residual[offset + i].setZero();
+			for (int d = 0; d < lm.m_num_constraints; ++d)
+			{
+				for (int n = 0; n < lm.m_num_nodes; ++n)
+				{
+					extended_residual[offset + i][d] += lm.m_weights[n] * m_dv[lm.m_indices[n]].dot(lm.m_dirs[d]);
+				}
+			}
+		}
+	}
+
+	void calculateContactForce(const TVStack& dv, const TVStack& rhs, TVStack& f)
+	{
+		size_t counter = 0;
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			btSoftBody* psb = m_softBodies[i];
+			for (int j = 0; j < psb->m_nodes.size(); ++j)
+			{
+				const btSoftBody::Node& node = psb->m_nodes[j];
+				f[counter] = (node.m_im == 0) ? btVector3(0, 0, 0) : dv[counter] / node.m_im;
+				++counter;
+			}
+		}
+		for (int i = 0; i < m_lf.size(); ++i)
+		{
+			// add damping matrix
+			m_lf[i]->addScaledDampingForceDifferential(-m_dt, dv, f);
+		}
+		counter = 0;
+		for (; counter < f.size(); ++counter)
+		{
+			f[counter] = rhs[counter] - f[counter];
+		}
+	}
+};
+
+#endif /* btBackwardEulerObjective_h */
diff --git a/engine/inc/bullet/BulletSoftBody/btDeformableBodySolver.h b/engine/inc/bullet/BulletSoftBody/btDeformableBodySolver.h
new file mode 100644
index 00000000..ae674d6e
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btDeformableBodySolver.h
@@ -0,0 +1,160 @@
+/*
+ Written by Xuchen Han <xuchenhan2015@u.northwestern.edu>
+ 
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef BT_DEFORMABLE_BODY_SOLVERS_H
+#define BT_DEFORMABLE_BODY_SOLVERS_H
+
+#include "btSoftBodySolvers.h"
+#include "btDeformableBackwardEulerObjective.h"
+#include "btDeformableMultiBodyDynamicsWorld.h"
+#include "BulletDynamics/Featherstone/btMultiBodyLinkCollider.h"
+#include "BulletDynamics/Featherstone/btMultiBodyConstraint.h"
+#include "btConjugateResidual.h"
+#include "btConjugateGradient.h"
+struct btCollisionObjectWrapper;
+class btDeformableBackwardEulerObjective;
+class btDeformableMultiBodyDynamicsWorld;
+
+class btDeformableBodySolver : public btSoftBodySolver
+{
+	typedef btAlignedObjectArray<btVector3> TVStack;
+
+protected:
+	int m_numNodes;                                                // total number of deformable body nodes
+	TVStack m_dv;                                                  // v_{n+1} - v_n
+	TVStack m_backup_dv;                                           // backed up dv
+	TVStack m_ddv;                                                 // incremental dv
+	TVStack m_residual;                                            // rhs of the linear solve
+	btAlignedObjectArray<btSoftBody*> m_softBodies;                // all deformable bodies
+	TVStack m_backupVelocity;                                      // backed up v, equals v_n for implicit, equals v_{n+1}^* for explicit
+	btScalar m_dt;                                                 // dt
+	btConjugateGradient<btDeformableBackwardEulerObjective> m_cg;  // CG solver
+	btConjugateResidual<btDeformableBackwardEulerObjective> m_cr;  // CR solver
+	bool m_implicit;                                               // use implicit scheme if true, explicit scheme if false
+	int m_maxNewtonIterations;                                     // max number of newton iterations
+	btScalar m_newtonTolerance;                                    // stop newton iterations if f(x) < m_newtonTolerance
+	bool m_lineSearch;                                             // If true, use newton's method with line search under implicit scheme
+public:
+	// handles data related to objective function
+	btDeformableBackwardEulerObjective* m_objective;
+	bool m_useProjection;
+
+	btDeformableBodySolver();
+
+	virtual ~btDeformableBodySolver();
+
+	virtual SolverTypes getSolverType() const
+	{
+		return DEFORMABLE_SOLVER;
+	}
+
+	// update soft body normals
+	virtual void updateSoftBodies();
+
+	virtual btScalar solveContactConstraints(btCollisionObject** deformableBodies, int numDeformableBodies, const btContactSolverInfo& infoGlobal);
+
+	// solve the momentum equation
+	virtual void solveDeformableConstraints(btScalar solverdt);
+
+	// resize/clear data structures
+	void reinitialize(const btAlignedObjectArray<btSoftBody*>& softBodies, btScalar dt);
+
+	// set up contact constraints
+	void setConstraints(const btContactSolverInfo& infoGlobal);
+
+	// add in elastic forces and gravity to obtain v_{n+1}^* and calls predictDeformableMotion
+	virtual void predictMotion(btScalar solverdt);
+
+	// move to temporary position x_{n+1}^* = x_n + dt * v_{n+1}^*
+	// x_{n+1}^* is stored in m_q
+	void predictDeformableMotion(btSoftBody* psb, btScalar dt);
+
+	// save the current velocity to m_backupVelocity
+	void backupVelocity();
+
+	// set m_dv and m_backupVelocity to desired value to prepare for momentum solve
+	void setupDeformableSolve(bool implicit);
+
+	// set the current velocity to that backed up in m_backupVelocity
+	void revertVelocity();
+
+	// set velocity to m_dv + m_backupVelocity
+	void updateVelocity();
+
+	// update the node count
+	bool updateNodes();
+
+	// calculate the change in dv resulting from the momentum solve
+	void computeStep(TVStack& ddv, const TVStack& residual);
+
+	// calculate the change in dv resulting from the momentum solve when line search is turned on
+	btScalar computeDescentStep(TVStack& ddv, const TVStack& residual, bool verbose = false);
+
+	virtual void copySoftBodyToVertexBuffer(const btSoftBody* const softBody, btVertexBufferDescriptor* vertexBuffer) {}
+
+	// process collision between deformable and rigid
+	virtual void processCollision(btSoftBody* softBody, const btCollisionObjectWrapper* collisionObjectWrap)
+	{
+		softBody->defaultCollisionHandler(collisionObjectWrap);
+	}
+
+	// process collision between deformable and deformable
+	virtual void processCollision(btSoftBody* softBody, btSoftBody* otherSoftBody)
+	{
+		softBody->defaultCollisionHandler(otherSoftBody);
+	}
+
+	// If true, implicit time stepping scheme is used.
+	// Otherwise, explicit time stepping scheme is used
+	void setImplicit(bool implicit);
+
+	// If true, newton's method with line search is used when implicit time stepping scheme is turned on
+	void setLineSearch(bool lineSearch);
+
+	// set temporary position x^* = x_n + dt * v
+	// update the deformation gradient at position x^*
+	void updateState();
+
+	// set dv = dv + scale * ddv
+	void updateDv(btScalar scale = 1);
+
+	// set temporary position x^* = x_n + dt * v^*
+	void updateTempPosition();
+
+	// save the current dv to m_backup_dv;
+	void backupDv();
+
+	// set dv to the backed-up value
+	void revertDv();
+
+	// set dv = dv + scale * ddv
+	// set v^* = v_n + dv
+	// set temporary position x^* = x_n + dt * v^*
+	// update the deformation gradient at position x^*
+	void updateEnergy(btScalar scale);
+
+	// calculates the appropriately scaled kinetic energy in the system, which is
+	// 1/2 * dv^T * M * dv
+	// used in line search
+	btScalar kineticEnergy();
+
+	// unused functions
+	virtual void optimize(btAlignedObjectArray<btSoftBody*>& softBodies, bool forceUpdate = false) {}
+	virtual void solveConstraints(btScalar dt) {}
+	virtual bool checkInitialized() { return true; }
+	virtual void copyBackToSoftBodies(bool bMove = true) {}
+};
+
+#endif /* btDeformableBodySolver_h */
diff --git a/engine/inc/bullet/BulletSoftBody/btDeformableContactConstraint.h b/engine/inc/bullet/BulletSoftBody/btDeformableContactConstraint.h
new file mode 100644
index 00000000..1e2c9f5b
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btDeformableContactConstraint.h
@@ -0,0 +1,284 @@
+/*
+ Written by Xuchen Han <xuchenhan2015@u.northwestern.edu>
+ 
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef BT_DEFORMABLE_CONTACT_CONSTRAINT_H
+#define BT_DEFORMABLE_CONTACT_CONSTRAINT_H
+#include "btSoftBody.h"
+
+// btDeformableContactConstraint is an abstract class specifying the method that each type of contact constraint needs to implement
+class btDeformableContactConstraint
+{
+public:
+	// True if the friction is static
+	// False if the friction is dynamic
+	bool m_static;
+	const btContactSolverInfo* m_infoGlobal;
+
+	// normal of the contact
+	btVector3 m_normal;
+
+	btDeformableContactConstraint(const btVector3& normal, const btContactSolverInfo& infoGlobal) : m_static(false), m_normal(normal), m_infoGlobal(&infoGlobal)
+	{
+	}
+
+	btDeformableContactConstraint(bool isStatic, const btVector3& normal, const btContactSolverInfo& infoGlobal) : m_static(isStatic), m_normal(normal), m_infoGlobal(&infoGlobal)
+	{
+	}
+
+	btDeformableContactConstraint() {}
+
+	btDeformableContactConstraint(const btDeformableContactConstraint& other)
+		: m_static(other.m_static), m_normal(other.m_normal), m_infoGlobal(other.m_infoGlobal)
+	{
+	}
+
+	virtual ~btDeformableContactConstraint() {}
+
+	// solve the constraint with inelastic impulse and return the error, which is the square of normal component of velocity diffrerence
+	// the constraint is solved by calculating the impulse between object A and B in the contact and apply the impulse to both objects involved in the contact
+	virtual btScalar solveConstraint(const btContactSolverInfo& infoGlobal) = 0;
+
+	// get the velocity of the object A in the contact
+	virtual btVector3 getVa() const = 0;
+
+	// get the velocity of the object B in the contact
+	virtual btVector3 getVb() const = 0;
+
+	// get the velocity change of the soft body node in the constraint
+	virtual btVector3 getDv(const btSoftBody::Node*) const = 0;
+
+	// apply impulse to the soft body node and/or face involved
+	virtual void applyImpulse(const btVector3& impulse) = 0;
+
+	// scale the penetration depth by erp
+	virtual void setPenetrationScale(btScalar scale) = 0;
+};
+
+//
+// Constraint that a certain node in the deformable objects cannot move
+class btDeformableStaticConstraint : public btDeformableContactConstraint
+{
+public:
+	btSoftBody::Node* m_node;
+
+	btDeformableStaticConstraint(btSoftBody::Node* node, const btContactSolverInfo& infoGlobal) : m_node(node), btDeformableContactConstraint(false, btVector3(0, 0, 0), infoGlobal)
+	{
+	}
+	btDeformableStaticConstraint() {}
+	btDeformableStaticConstraint(const btDeformableStaticConstraint& other)
+		: m_node(other.m_node), btDeformableContactConstraint(other)
+	{
+	}
+
+	virtual ~btDeformableStaticConstraint() {}
+
+	virtual btScalar solveConstraint(const btContactSolverInfo& infoGlobal)
+	{
+		return 0;
+	}
+
+	virtual btVector3 getVa() const
+	{
+		return btVector3(0, 0, 0);
+	}
+
+	virtual btVector3 getVb() const
+	{
+		return btVector3(0, 0, 0);
+	}
+
+	virtual btVector3 getDv(const btSoftBody::Node* n) const
+	{
+		return btVector3(0, 0, 0);
+	}
+
+	virtual void applyImpulse(const btVector3& impulse) {}
+	virtual void setPenetrationScale(btScalar scale) {}
+};
+
+//
+// Anchor Constraint between rigid and deformable node
+class btDeformableNodeAnchorConstraint : public btDeformableContactConstraint
+{
+public:
+	const btSoftBody::DeformableNodeRigidAnchor* m_anchor;
+
+	btDeformableNodeAnchorConstraint(const btSoftBody::DeformableNodeRigidAnchor& c, const btContactSolverInfo& infoGlobal);
+	btDeformableNodeAnchorConstraint(const btDeformableNodeAnchorConstraint& other);
+	btDeformableNodeAnchorConstraint() {}
+	virtual ~btDeformableNodeAnchorConstraint()
+	{
+	}
+	virtual btScalar solveConstraint(const btContactSolverInfo& infoGlobal);
+
+	// object A is the rigid/multi body, and object B is the deformable node/face
+	virtual btVector3 getVa() const;
+	// get the velocity of the deformable node in contact
+	virtual btVector3 getVb() const;
+	virtual btVector3 getDv(const btSoftBody::Node* n) const
+	{
+		return btVector3(0, 0, 0);
+	}
+	virtual void applyImpulse(const btVector3& impulse);
+
+	virtual void setPenetrationScale(btScalar scale) {}
+};
+
+//
+// Constraint between rigid/multi body and deformable objects
+class btDeformableRigidContactConstraint : public btDeformableContactConstraint
+{
+public:
+	btVector3 m_total_normal_dv;
+	btVector3 m_total_tangent_dv;
+	btScalar m_penetration;
+	btScalar m_total_split_impulse;
+	bool m_binding;
+	const btSoftBody::DeformableRigidContact* m_contact;
+
+	btDeformableRigidContactConstraint(const btSoftBody::DeformableRigidContact& c, const btContactSolverInfo& infoGlobal);
+	btDeformableRigidContactConstraint(const btDeformableRigidContactConstraint& other);
+	btDeformableRigidContactConstraint() {}
+	virtual ~btDeformableRigidContactConstraint()
+	{
+	}
+
+	// object A is the rigid/multi body, and object B is the deformable node/face
+	virtual btVector3 getVa() const;
+
+	// get the split impulse velocity of the deformable face at the contact point
+	virtual btVector3 getSplitVb() const = 0;
+
+	// get the split impulse velocity of the rigid/multibdoy at the contaft
+	virtual btVector3 getSplitVa() const;
+
+	virtual btScalar solveConstraint(const btContactSolverInfo& infoGlobal);
+
+	virtual void setPenetrationScale(btScalar scale)
+	{
+		m_penetration *= scale;
+	}
+
+	btScalar solveSplitImpulse(const btContactSolverInfo& infoGlobal);
+
+	virtual void applySplitImpulse(const btVector3& impulse) = 0;
+};
+
+//
+// Constraint between rigid/multi body and deformable objects nodes
+class btDeformableNodeRigidContactConstraint : public btDeformableRigidContactConstraint
+{
+public:
+	// the deformable node in contact
+	btSoftBody::Node* m_node;
+
+	btDeformableNodeRigidContactConstraint(const btSoftBody::DeformableNodeRigidContact& contact, const btContactSolverInfo& infoGlobal);
+	btDeformableNodeRigidContactConstraint(const btDeformableNodeRigidContactConstraint& other);
+	btDeformableNodeRigidContactConstraint() {}
+	virtual ~btDeformableNodeRigidContactConstraint()
+	{
+	}
+
+	// get the velocity of the deformable node in contact
+	virtual btVector3 getVb() const;
+
+	// get the split impulse velocity of the deformable face at the contact point
+	virtual btVector3 getSplitVb() const;
+
+	// get the velocity change of the input soft body node in the constraint
+	virtual btVector3 getDv(const btSoftBody::Node*) const;
+
+	// cast the contact to the desired type
+	const btSoftBody::DeformableNodeRigidContact* getContact() const
+	{
+		return static_cast<const btSoftBody::DeformableNodeRigidContact*>(m_contact);
+	}
+
+	virtual void applyImpulse(const btVector3& impulse);
+
+	virtual void applySplitImpulse(const btVector3& impulse);
+};
+
+//
+// Constraint between rigid/multi body and deformable objects faces
+class btDeformableFaceRigidContactConstraint : public btDeformableRigidContactConstraint
+{
+public:
+	btSoftBody::Face* m_face;
+	bool m_useStrainLimiting;
+	btDeformableFaceRigidContactConstraint(const btSoftBody::DeformableFaceRigidContact& contact, const btContactSolverInfo& infoGlobal, bool useStrainLimiting);
+	btDeformableFaceRigidContactConstraint(const btDeformableFaceRigidContactConstraint& other);
+	btDeformableFaceRigidContactConstraint() : m_useStrainLimiting(false) {}
+	virtual ~btDeformableFaceRigidContactConstraint()
+	{
+	}
+
+	// get the velocity of the deformable face at the contact point
+	virtual btVector3 getVb() const;
+
+	// get the split impulse velocity of the deformable face at the contact point
+	virtual btVector3 getSplitVb() const;
+
+	// get the velocity change of the input soft body node in the constraint
+	virtual btVector3 getDv(const btSoftBody::Node*) const;
+
+	// cast the contact to the desired type
+	const btSoftBody::DeformableFaceRigidContact* getContact() const
+	{
+		return static_cast<const btSoftBody::DeformableFaceRigidContact*>(m_contact);
+	}
+
+	virtual void applyImpulse(const btVector3& impulse);
+
+	virtual void applySplitImpulse(const btVector3& impulse);
+};
+
+//
+// Constraint between  deformable objects faces and deformable objects nodes
+class btDeformableFaceNodeContactConstraint : public btDeformableContactConstraint
+{
+public:
+	btSoftBody::Node* m_node;
+	btSoftBody::Face* m_face;
+	const btSoftBody::DeformableFaceNodeContact* m_contact;
+	btVector3 m_total_normal_dv;
+	btVector3 m_total_tangent_dv;
+
+	btDeformableFaceNodeContactConstraint(const btSoftBody::DeformableFaceNodeContact& contact, const btContactSolverInfo& infoGlobal);
+	btDeformableFaceNodeContactConstraint() {}
+	virtual ~btDeformableFaceNodeContactConstraint() {}
+
+	virtual btScalar solveConstraint(const btContactSolverInfo& infoGlobal);
+
+	// get the velocity of the object A in the contact
+	virtual btVector3 getVa() const;
+
+	// get the velocity of the object B in the contact
+	virtual btVector3 getVb() const;
+
+	// get the velocity change of the input soft body node in the constraint
+	virtual btVector3 getDv(const btSoftBody::Node*) const;
+
+	// cast the contact to the desired type
+	const btSoftBody::DeformableFaceNodeContact* getContact() const
+	{
+		return static_cast<const btSoftBody::DeformableFaceNodeContact*>(m_contact);
+	}
+
+	virtual void applyImpulse(const btVector3& impulse);
+
+	virtual void setPenetrationScale(btScalar scale) {}
+};
+#endif /* BT_DEFORMABLE_CONTACT_CONSTRAINT_H */
diff --git a/engine/inc/bullet/BulletSoftBody/btDeformableContactProjection.h b/engine/inc/bullet/BulletSoftBody/btDeformableContactProjection.h
new file mode 100644
index 00000000..4964eaf9
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btDeformableContactProjection.h
@@ -0,0 +1,99 @@
+/*
+ Written by Xuchen Han <xuchenhan2015@u.northwestern.edu>
+ 
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef BT_CONTACT_PROJECTION_H
+#define BT_CONTACT_PROJECTION_H
+#include "btCGProjection.h"
+#include "btSoftBody.h"
+#include "BulletDynamics/Featherstone/btMultiBodyLinkCollider.h"
+#include "BulletDynamics/Featherstone/btMultiBodyConstraint.h"
+#include "btDeformableContactConstraint.h"
+#include "LinearMath/btHashMap.h"
+#include "LinearMath/btReducedVector.h"
+#include "LinearMath/btModifiedGramSchmidt.h"
+#include <vector>
+
+struct LagrangeMultiplier
+{
+	int m_num_constraints;  // Number of constraints
+	int m_num_nodes;        // Number of nodes in these constraints
+	btScalar m_weights[3];  // weights of the nodes involved, same size as m_num_nodes
+	btVector3 m_dirs[3];    // Constraint directions, same size of m_num_constraints;
+	int m_indices[3];       // indices of the nodes involved, same size as m_num_nodes;
+};
+
+class btDeformableContactProjection
+{
+public:
+	typedef btAlignedObjectArray<btVector3> TVStack;
+	btAlignedObjectArray<btSoftBody*>& m_softBodies;
+
+	// all constraints involving face
+	btAlignedObjectArray<btDeformableContactConstraint*> m_allFaceConstraints;
+#ifndef USE_MGS
+	// map from node index to projection directions
+	btHashMap<btHashInt, btAlignedObjectArray<btVector3> > m_projectionsDict;
+#else
+	btAlignedObjectArray<btReducedVector> m_projections;
+#endif
+
+	btAlignedObjectArray<LagrangeMultiplier> m_lagrangeMultipliers;
+
+	// map from node index to static constraint
+	btAlignedObjectArray<btAlignedObjectArray<btDeformableStaticConstraint> > m_staticConstraints;
+	// map from node index to node rigid constraint
+	btAlignedObjectArray<btAlignedObjectArray<btDeformableNodeRigidContactConstraint> > m_nodeRigidConstraints;
+	// map from node index to face rigid constraint
+	btAlignedObjectArray<btAlignedObjectArray<btDeformableFaceRigidContactConstraint> > m_faceRigidConstraints;
+	// map from node index to deformable constraint
+	btAlignedObjectArray<btAlignedObjectArray<btDeformableFaceNodeContactConstraint> > m_deformableConstraints;
+	// map from node index to node anchor constraint
+	btAlignedObjectArray<btAlignedObjectArray<btDeformableNodeAnchorConstraint> > m_nodeAnchorConstraints;
+
+	bool m_useStrainLimiting;
+
+	btDeformableContactProjection(btAlignedObjectArray<btSoftBody*>& softBodies)
+		: m_softBodies(softBodies)
+	{
+	}
+
+	virtual ~btDeformableContactProjection()
+	{
+	}
+
+	// apply the constraints to the rhs of the linear solve
+	virtual void project(TVStack& x);
+
+	// add friction force to the rhs of the linear solve
+	virtual void applyDynamicFriction(TVStack& f);
+
+	// update and solve the constraints
+	virtual btScalar update(btCollisionObject** deformableBodies, int numDeformableBodies, const btContactSolverInfo& infoGlobal);
+
+	// Add constraints to m_constraints. In addition, the constraints that each vertex own are recorded in m_constraintsDict.
+	virtual void setConstraints(const btContactSolverInfo& infoGlobal);
+
+	// Set up projections for each vertex by adding the projection direction to
+	virtual void setProjection();
+
+	virtual void reinitialize(bool nodeUpdated);
+
+	btScalar solveSplitImpulse(btCollisionObject** deformableBodies, int numDeformableBodies, const btContactSolverInfo& infoGlobal);
+
+	virtual void setLagrangeMultiplier();
+
+	void checkConstraints(const TVStack& x);
+};
+#endif /* btDeformableContactProjection_h */
diff --git a/engine/inc/bullet/BulletSoftBody/btDeformableCorotatedForce.h b/engine/inc/bullet/BulletSoftBody/btDeformableCorotatedForce.h
new file mode 100644
index 00000000..dfd85523
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btDeformableCorotatedForce.h
@@ -0,0 +1,124 @@
+/*
+ Written by Xuchen Han <xuchenhan2015@u.northwestern.edu>
+ 
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef BT_COROTATED_H
+#define BT_COROTATED_H
+
+#include "btDeformableLagrangianForce.h"
+#include "LinearMath/btPolarDecomposition.h"
+
+static inline int PolarDecomposition(const btMatrix3x3& m, btMatrix3x3& q, btMatrix3x3& s)
+{
+	static const btPolarDecomposition polar;
+	return polar.decompose(m, q, s);
+}
+
+class btDeformableCorotatedForce : public btDeformableLagrangianForce
+{
+public:
+	typedef btAlignedObjectArray<btVector3> TVStack;
+	btScalar m_mu, m_lambda;
+	btDeformableCorotatedForce() : m_mu(1), m_lambda(1)
+	{
+	}
+
+	btDeformableCorotatedForce(btScalar mu, btScalar lambda) : m_mu(mu), m_lambda(lambda)
+	{
+	}
+
+	virtual void addScaledForces(btScalar scale, TVStack& force)
+	{
+		addScaledElasticForce(scale, force);
+	}
+
+	virtual void addScaledExplicitForce(btScalar scale, TVStack& force)
+	{
+		addScaledElasticForce(scale, force);
+	}
+
+	virtual void addScaledDampingForce(btScalar scale, TVStack& force)
+	{
+	}
+
+	virtual void addScaledElasticForce(btScalar scale, TVStack& force)
+	{
+		int numNodes = getNumNodes();
+		btAssert(numNodes <= force.size());
+		btVector3 grad_N_hat_1st_col = btVector3(-1, -1, -1);
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			btSoftBody* psb = m_softBodies[i];
+			for (int j = 0; j < psb->m_tetras.size(); ++j)
+			{
+				btSoftBody::Tetra& tetra = psb->m_tetras[j];
+				btMatrix3x3 P;
+				firstPiola(tetra.m_F, P);
+				btVector3 force_on_node0 = P * (tetra.m_Dm_inverse.transpose() * grad_N_hat_1st_col);
+				btMatrix3x3 force_on_node123 = P * tetra.m_Dm_inverse.transpose();
+
+				btSoftBody::Node* node0 = tetra.m_n[0];
+				btSoftBody::Node* node1 = tetra.m_n[1];
+				btSoftBody::Node* node2 = tetra.m_n[2];
+				btSoftBody::Node* node3 = tetra.m_n[3];
+				size_t id0 = node0->index;
+				size_t id1 = node1->index;
+				size_t id2 = node2->index;
+				size_t id3 = node3->index;
+
+				// elastic force
+				// explicit elastic force
+				btScalar scale1 = scale * tetra.m_element_measure;
+				force[id0] -= scale1 * force_on_node0;
+				force[id1] -= scale1 * force_on_node123.getColumn(0);
+				force[id2] -= scale1 * force_on_node123.getColumn(1);
+				force[id3] -= scale1 * force_on_node123.getColumn(2);
+			}
+		}
+	}
+
+	void firstPiola(const btMatrix3x3& F, btMatrix3x3& P)
+	{
+		// btMatrix3x3 JFinvT = F.adjoint();
+		btScalar J = F.determinant();
+		P = F.adjoint().transpose() * (m_lambda * (J - 1));
+		if (m_mu > SIMD_EPSILON)
+		{
+			btMatrix3x3 R, S;
+			if (J < 1024 * SIMD_EPSILON)
+				R.setIdentity();
+			else
+				PolarDecomposition(F, R, S);  // this QR is not robust, consider using implicit shift svd
+			/*https://fuchuyuan.github.io/research/svd/paper.pdf*/
+			P += (F - R) * 2 * m_mu;
+		}
+	}
+
+	virtual void addScaledElasticForceDifferential(btScalar scale, const TVStack& dx, TVStack& df)
+	{
+	}
+
+	virtual void addScaledDampingForceDifferential(btScalar scale, const TVStack& dv, TVStack& df)
+	{
+	}
+
+	virtual void buildDampingForceDifferentialDiagonal(btScalar scale, TVStack& diagA) {}
+
+	virtual btDeformableLagrangianForceType getForceType()
+	{
+		return BT_COROTATED_FORCE;
+	}
+};
+
+#endif /* btCorotated_h */
diff --git a/engine/inc/bullet/BulletSoftBody/btDeformableGravityForce.h b/engine/inc/bullet/BulletSoftBody/btDeformableGravityForce.h
new file mode 100644
index 00000000..d91867f4
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btDeformableGravityForce.h
@@ -0,0 +1,105 @@
+/*
+ Written by Xuchen Han <xuchenhan2015@u.northwestern.edu>
+ 
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef BT_DEFORMABLE_GRAVITY_FORCE_H
+#define BT_DEFORMABLE_GRAVITY_FORCE_H
+
+#include "btDeformableLagrangianForce.h"
+
+class btDeformableGravityForce : public btDeformableLagrangianForce
+{
+public:
+	typedef btAlignedObjectArray<btVector3> TVStack;
+	btVector3 m_gravity;
+
+	btDeformableGravityForce(const btVector3& g) : m_gravity(g)
+	{
+	}
+
+	virtual void addScaledForces(btScalar scale, TVStack& force)
+	{
+		addScaledGravityForce(scale, force);
+	}
+
+	virtual void addScaledExplicitForce(btScalar scale, TVStack& force)
+	{
+		addScaledGravityForce(scale, force);
+	}
+
+	virtual void addScaledDampingForce(btScalar scale, TVStack& force)
+	{
+	}
+
+	virtual void addScaledElasticForceDifferential(btScalar scale, const TVStack& dx, TVStack& df)
+	{
+	}
+
+	virtual void addScaledDampingForceDifferential(btScalar scale, const TVStack& dv, TVStack& df)
+	{
+	}
+
+	virtual void buildDampingForceDifferentialDiagonal(btScalar scale, TVStack& diagA) {}
+
+	virtual void addScaledGravityForce(btScalar scale, TVStack& force)
+	{
+		int numNodes = getNumNodes();
+		btAssert(numNodes <= force.size());
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			btSoftBody* psb = m_softBodies[i];
+			if (!psb->isActive())
+			{
+				continue;
+			}
+			for (int j = 0; j < psb->m_nodes.size(); ++j)
+			{
+				btSoftBody::Node& n = psb->m_nodes[j];
+				size_t id = n.index;
+				btScalar mass = (n.m_im == 0) ? 0 : 1. / n.m_im;
+				btVector3 scaled_force = scale * m_gravity * mass * m_softBodies[i]->m_gravityFactor;
+				force[id] += scaled_force;
+			}
+		}
+	}
+
+	virtual btDeformableLagrangianForceType getForceType()
+	{
+		return BT_GRAVITY_FORCE;
+	}
+
+	// the gravitational potential energy
+	virtual double totalEnergy(btScalar dt)
+	{
+		double e = 0;
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			btSoftBody* psb = m_softBodies[i];
+			if (!psb->isActive())
+			{
+				continue;
+			}
+			for (int j = 0; j < psb->m_nodes.size(); ++j)
+			{
+				const btSoftBody::Node& node = psb->m_nodes[j];
+				if (node.m_im > 0)
+				{
+					e -= m_gravity.dot(node.m_q) / node.m_im;
+				}
+			}
+		}
+		return e;
+	}
+};
+#endif /* BT_DEFORMABLE_GRAVITY_FORCE_H */
diff --git a/engine/inc/bullet/BulletSoftBody/btDeformableLagrangianForce.h b/engine/inc/bullet/BulletSoftBody/btDeformableLagrangianForce.h
new file mode 100644
index 00000000..d58d825d
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btDeformableLagrangianForce.h
@@ -0,0 +1,372 @@
+/*
+ Written by Xuchen Han <xuchenhan2015@u.northwestern.edu>
+ 
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef BT_DEFORMABLE_LAGRANGIAN_FORCE_H
+#define BT_DEFORMABLE_LAGRANGIAN_FORCE_H
+
+#include "btSoftBody.h"
+#include <LinearMath/btHashMap.h>
+#include <iostream>
+
+enum btDeformableLagrangianForceType
+{
+	BT_GRAVITY_FORCE = 1,
+	BT_MASSSPRING_FORCE = 2,
+	BT_COROTATED_FORCE = 3,
+	BT_NEOHOOKEAN_FORCE = 4,
+	BT_LINEAR_ELASTICITY_FORCE = 5,
+	BT_MOUSE_PICKING_FORCE = 6
+};
+
+static inline double randomDouble(double low, double high)
+{
+	return low + static_cast<double>(rand()) / RAND_MAX * (high - low);
+}
+
+class btDeformableLagrangianForce
+{
+public:
+	typedef btAlignedObjectArray<btVector3> TVStack;
+	btAlignedObjectArray<btSoftBody*> m_softBodies;
+	const btAlignedObjectArray<btSoftBody::Node*>* m_nodes;
+
+	btDeformableLagrangianForce()
+	{
+	}
+
+	virtual ~btDeformableLagrangianForce() {}
+
+	// add all forces
+	virtual void addScaledForces(btScalar scale, TVStack& force) = 0;
+
+	// add damping df
+	virtual void addScaledDampingForceDifferential(btScalar scale, const TVStack& dv, TVStack& df) = 0;
+
+	// build diagonal of A matrix
+	virtual void buildDampingForceDifferentialDiagonal(btScalar scale, TVStack& diagA) = 0;
+
+	// add elastic df
+	virtual void addScaledElasticForceDifferential(btScalar scale, const TVStack& dx, TVStack& df) = 0;
+
+	// add all forces that are explicit in explicit solve
+	virtual void addScaledExplicitForce(btScalar scale, TVStack& force) = 0;
+
+	// add all damping forces
+	virtual void addScaledDampingForce(btScalar scale, TVStack& force) = 0;
+
+	virtual void addScaledHessian(btScalar scale) {}
+
+	virtual btDeformableLagrangianForceType getForceType() = 0;
+
+	virtual void reinitialize(bool nodeUpdated)
+	{
+	}
+
+	// get number of nodes that have the force
+	virtual int getNumNodes()
+	{
+		int numNodes = 0;
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			numNodes += m_softBodies[i]->m_nodes.size();
+		}
+		return numNodes;
+	}
+
+	// add a soft body to be affected by the particular lagrangian force
+	virtual void addSoftBody(btSoftBody* psb)
+	{
+		m_softBodies.push_back(psb);
+	}
+
+	virtual void removeSoftBody(btSoftBody* psb)
+	{
+		m_softBodies.remove(psb);
+	}
+
+	virtual void setIndices(const btAlignedObjectArray<btSoftBody::Node*>* nodes)
+	{
+		m_nodes = nodes;
+	}
+
+	// Calculate the incremental deformable generated from the input dx
+	virtual btMatrix3x3 Ds(int id0, int id1, int id2, int id3, const TVStack& dx)
+	{
+		btVector3 c1 = dx[id1] - dx[id0];
+		btVector3 c2 = dx[id2] - dx[id0];
+		btVector3 c3 = dx[id3] - dx[id0];
+		return btMatrix3x3(c1, c2, c3).transpose();
+	}
+
+	// Calculate the incremental deformable generated from the current velocity
+	virtual btMatrix3x3 DsFromVelocity(const btSoftBody::Node* n0, const btSoftBody::Node* n1, const btSoftBody::Node* n2, const btSoftBody::Node* n3)
+	{
+		btVector3 c1 = n1->m_v - n0->m_v;
+		btVector3 c2 = n2->m_v - n0->m_v;
+		btVector3 c3 = n3->m_v - n0->m_v;
+		return btMatrix3x3(c1, c2, c3).transpose();
+	}
+
+	// test for addScaledElasticForce function
+	virtual void testDerivative()
+	{
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			btSoftBody* psb = m_softBodies[i];
+			for (int j = 0; j < psb->m_nodes.size(); ++j)
+			{
+				psb->m_nodes[j].m_q += btVector3(randomDouble(-.1, .1), randomDouble(-.1, .1), randomDouble(-.1, .1));
+			}
+			psb->updateDeformation();
+		}
+
+		TVStack dx;
+		dx.resize(getNumNodes());
+		TVStack dphi_dx;
+		dphi_dx.resize(dx.size());
+		for (int i = 0; i < dphi_dx.size(); ++i)
+		{
+			dphi_dx[i].setZero();
+		}
+		addScaledForces(-1, dphi_dx);
+
+		// write down the current position
+		TVStack x;
+		x.resize(dx.size());
+		int counter = 0;
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			btSoftBody* psb = m_softBodies[i];
+			for (int j = 0; j < psb->m_nodes.size(); ++j)
+			{
+				x[counter] = psb->m_nodes[j].m_q;
+				counter++;
+			}
+		}
+		counter = 0;
+
+		// populate dx with random vectors
+		for (int i = 0; i < dx.size(); ++i)
+		{
+			dx[i].setX(randomDouble(-1, 1));
+			dx[i].setY(randomDouble(-1, 1));
+			dx[i].setZ(randomDouble(-1, 1));
+		}
+
+		btAlignedObjectArray<double> errors;
+		for (int it = 0; it < 10; ++it)
+		{
+			for (int i = 0; i < dx.size(); ++i)
+			{
+				dx[i] *= 0.5;
+			}
+
+			// get dphi/dx * dx
+			double dphi = 0;
+			for (int i = 0; i < dx.size(); ++i)
+			{
+				dphi += dphi_dx[i].dot(dx[i]);
+			}
+
+			for (int i = 0; i < m_softBodies.size(); ++i)
+			{
+				btSoftBody* psb = m_softBodies[i];
+				for (int j = 0; j < psb->m_nodes.size(); ++j)
+				{
+					psb->m_nodes[j].m_q = x[counter] + dx[counter];
+					counter++;
+				}
+				psb->updateDeformation();
+			}
+			counter = 0;
+			double f1 = totalElasticEnergy(0);
+
+			for (int i = 0; i < m_softBodies.size(); ++i)
+			{
+				btSoftBody* psb = m_softBodies[i];
+				for (int j = 0; j < psb->m_nodes.size(); ++j)
+				{
+					psb->m_nodes[j].m_q = x[counter] - dx[counter];
+					counter++;
+				}
+				psb->updateDeformation();
+			}
+			counter = 0;
+
+			double f2 = totalElasticEnergy(0);
+
+			//restore m_q
+			for (int i = 0; i < m_softBodies.size(); ++i)
+			{
+				btSoftBody* psb = m_softBodies[i];
+				for (int j = 0; j < psb->m_nodes.size(); ++j)
+				{
+					psb->m_nodes[j].m_q = x[counter];
+					counter++;
+				}
+				psb->updateDeformation();
+			}
+			counter = 0;
+			double error = f1 - f2 - 2 * dphi;
+			errors.push_back(error);
+			std::cout << "Iteration = " << it << ", f1 = " << f1 << ", f2 = " << f2 << ", error = " << error << std::endl;
+		}
+		for (int i = 1; i < errors.size(); ++i)
+		{
+			std::cout << "Iteration = " << i << ", ratio = " << errors[i - 1] / errors[i] << std::endl;
+		}
+	}
+
+	// test for addScaledElasticForce function
+	virtual void testHessian()
+	{
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			btSoftBody* psb = m_softBodies[i];
+			for (int j = 0; j < psb->m_nodes.size(); ++j)
+			{
+				psb->m_nodes[j].m_q += btVector3(randomDouble(-.1, .1), randomDouble(-.1, .1), randomDouble(-.1, .1));
+			}
+			psb->updateDeformation();
+		}
+
+		TVStack dx;
+		dx.resize(getNumNodes());
+		TVStack df;
+		df.resize(dx.size());
+		TVStack f1;
+		f1.resize(dx.size());
+		TVStack f2;
+		f2.resize(dx.size());
+
+		// write down the current position
+		TVStack x;
+		x.resize(dx.size());
+		int counter = 0;
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			btSoftBody* psb = m_softBodies[i];
+			for (int j = 0; j < psb->m_nodes.size(); ++j)
+			{
+				x[counter] = psb->m_nodes[j].m_q;
+				counter++;
+			}
+		}
+		counter = 0;
+
+		// populate dx with random vectors
+		for (int i = 0; i < dx.size(); ++i)
+		{
+			dx[i].setX(randomDouble(-1, 1));
+			dx[i].setY(randomDouble(-1, 1));
+			dx[i].setZ(randomDouble(-1, 1));
+		}
+
+		btAlignedObjectArray<double> errors;
+		for (int it = 0; it < 10; ++it)
+		{
+			for (int i = 0; i < dx.size(); ++i)
+			{
+				dx[i] *= 0.5;
+			}
+
+			// get df
+			for (int i = 0; i < df.size(); ++i)
+			{
+				df[i].setZero();
+				f1[i].setZero();
+				f2[i].setZero();
+			}
+
+			//set df
+			addScaledElasticForceDifferential(-1, dx, df);
+
+			for (int i = 0; i < m_softBodies.size(); ++i)
+			{
+				btSoftBody* psb = m_softBodies[i];
+				for (int j = 0; j < psb->m_nodes.size(); ++j)
+				{
+					psb->m_nodes[j].m_q = x[counter] + dx[counter];
+					counter++;
+				}
+				psb->updateDeformation();
+			}
+			counter = 0;
+
+			//set f1
+			addScaledForces(-1, f1);
+
+			for (int i = 0; i < m_softBodies.size(); ++i)
+			{
+				btSoftBody* psb = m_softBodies[i];
+				for (int j = 0; j < psb->m_nodes.size(); ++j)
+				{
+					psb->m_nodes[j].m_q = x[counter] - dx[counter];
+					counter++;
+				}
+				psb->updateDeformation();
+			}
+			counter = 0;
+
+			//set f2
+			addScaledForces(-1, f2);
+
+			//restore m_q
+			for (int i = 0; i < m_softBodies.size(); ++i)
+			{
+				btSoftBody* psb = m_softBodies[i];
+				for (int j = 0; j < psb->m_nodes.size(); ++j)
+				{
+					psb->m_nodes[j].m_q = x[counter];
+					counter++;
+				}
+				psb->updateDeformation();
+			}
+			counter = 0;
+			double error = 0;
+			for (int i = 0; i < df.size(); ++i)
+			{
+				btVector3 error_vector = f1[i] - f2[i] - 2 * df[i];
+				error += error_vector.length2();
+			}
+			error = btSqrt(error);
+			errors.push_back(error);
+			std::cout << "Iteration = " << it << ", error = " << error << std::endl;
+		}
+		for (int i = 1; i < errors.size(); ++i)
+		{
+			std::cout << "Iteration = " << i << ", ratio = " << errors[i - 1] / errors[i] << std::endl;
+		}
+	}
+
+	//
+	virtual double totalElasticEnergy(btScalar dt)
+	{
+		return 0;
+	}
+
+	//
+	virtual double totalDampingEnergy(btScalar dt)
+	{
+		return 0;
+	}
+
+	// total Energy takes dt as input because certain energies depend on dt
+	virtual double totalEnergy(btScalar dt)
+	{
+		return totalElasticEnergy(dt) + totalDampingEnergy(dt);
+	}
+};
+#endif /* BT_DEFORMABLE_LAGRANGIAN_FORCE */
diff --git a/engine/inc/bullet/BulletSoftBody/btDeformableLinearElasticityForce.h b/engine/inc/bullet/BulletSoftBody/btDeformableLinearElasticityForce.h
new file mode 100644
index 00000000..97119205
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btDeformableLinearElasticityForce.h
@@ -0,0 +1,462 @@
+/*
+ Written by Xuchen Han <xuchenhan2015@u.northwestern.edu>
+ 
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef BT_LINEAR_ELASTICITY_H
+#define BT_LINEAR_ELASTICITY_H
+
+#include "btDeformableLagrangianForce.h"
+#include "LinearMath/btQuickprof.h"
+#include "btSoftBodyInternals.h"
+#define TETRA_FLAT_THRESHOLD 0.01
+class btDeformableLinearElasticityForce : public btDeformableLagrangianForce
+{
+public:
+	typedef btAlignedObjectArray<btVector3> TVStack;
+	btScalar m_mu, m_lambda;
+	btScalar m_E, m_nu;  // Young's modulus and Poisson ratio
+	btScalar m_damping_alpha, m_damping_beta;
+	btDeformableLinearElasticityForce() : m_mu(1), m_lambda(1), m_damping_alpha(0.01), m_damping_beta(0.01)
+	{
+		updateYoungsModulusAndPoissonRatio();
+	}
+
+	btDeformableLinearElasticityForce(btScalar mu, btScalar lambda, btScalar damping_alpha = 0.01, btScalar damping_beta = 0.01) : m_mu(mu), m_lambda(lambda), m_damping_alpha(damping_alpha), m_damping_beta(damping_beta)
+	{
+		updateYoungsModulusAndPoissonRatio();
+	}
+
+	void updateYoungsModulusAndPoissonRatio()
+	{
+		// conversion from Lame Parameters to Young's modulus and Poisson ratio
+		// https://en.wikipedia.org/wiki/Lam%C3%A9_parameters
+		m_E = m_mu * (3 * m_lambda + 2 * m_mu) / (m_lambda + m_mu);
+		m_nu = m_lambda * 0.5 / (m_mu + m_lambda);
+	}
+
+	void updateLameParameters()
+	{
+		// conversion from Young's modulus and Poisson ratio to Lame Parameters
+		// https://en.wikipedia.org/wiki/Lam%C3%A9_parameters
+		m_mu = m_E * 0.5 / (1 + m_nu);
+		m_lambda = m_E * m_nu / ((1 + m_nu) * (1 - 2 * m_nu));
+	}
+
+	void setYoungsModulus(btScalar E)
+	{
+		m_E = E;
+		updateLameParameters();
+	}
+
+	void setPoissonRatio(btScalar nu)
+	{
+		m_nu = nu;
+		updateLameParameters();
+	}
+
+	void setDamping(btScalar damping_alpha, btScalar damping_beta)
+	{
+		m_damping_alpha = damping_alpha;
+		m_damping_beta = damping_beta;
+	}
+
+	void setLameParameters(btScalar mu, btScalar lambda)
+	{
+		m_mu = mu;
+		m_lambda = lambda;
+		updateYoungsModulusAndPoissonRatio();
+	}
+
+	virtual void addScaledForces(btScalar scale, TVStack& force)
+	{
+		addScaledDampingForce(scale, force);
+		addScaledElasticForce(scale, force);
+	}
+
+	virtual void addScaledExplicitForce(btScalar scale, TVStack& force)
+	{
+		addScaledElasticForce(scale, force);
+	}
+
+	// The damping matrix is calculated using the time n state as described in https://www.math.ucla.edu/~jteran/papers/GSSJT15.pdf to allow line search
+	virtual void addScaledDampingForce(btScalar scale, TVStack& force)
+	{
+		if (m_damping_alpha == 0 && m_damping_beta == 0)
+			return;
+		btScalar mu_damp = m_damping_beta * m_mu;
+		btScalar lambda_damp = m_damping_beta * m_lambda;
+		int numNodes = getNumNodes();
+		btAssert(numNodes <= force.size());
+		btVector3 grad_N_hat_1st_col = btVector3(-1, -1, -1);
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			btSoftBody* psb = m_softBodies[i];
+			if (!psb->isActive())
+			{
+				continue;
+			}
+			for (int j = 0; j < psb->m_tetras.size(); ++j)
+			{
+				bool close_to_flat = (psb->m_tetraScratches[j].m_J < TETRA_FLAT_THRESHOLD);
+				btSoftBody::Tetra& tetra = psb->m_tetras[j];
+				btSoftBody::Node* node0 = tetra.m_n[0];
+				btSoftBody::Node* node1 = tetra.m_n[1];
+				btSoftBody::Node* node2 = tetra.m_n[2];
+				btSoftBody::Node* node3 = tetra.m_n[3];
+				size_t id0 = node0->index;
+				size_t id1 = node1->index;
+				size_t id2 = node2->index;
+				size_t id3 = node3->index;
+				btMatrix3x3 dF = DsFromVelocity(node0, node1, node2, node3) * tetra.m_Dm_inverse;
+				if (!close_to_flat)
+				{
+					dF = psb->m_tetraScratches[j].m_corotation.transpose() * dF;
+				}
+				btMatrix3x3 I;
+				I.setIdentity();
+				btMatrix3x3 dP = (dF + dF.transpose()) * mu_damp + I * ((dF[0][0] + dF[1][1] + dF[2][2]) * lambda_damp);
+				btMatrix3x3 df_on_node123 = dP * tetra.m_Dm_inverse.transpose();
+				if (!close_to_flat)
+				{
+					df_on_node123 = psb->m_tetraScratches[j].m_corotation * df_on_node123;
+				}
+				btVector3 df_on_node0 = df_on_node123 * grad_N_hat_1st_col;
+				// damping force differential
+				btScalar scale1 = scale * tetra.m_element_measure;
+				force[id0] -= scale1 * df_on_node0;
+				force[id1] -= scale1 * df_on_node123.getColumn(0);
+				force[id2] -= scale1 * df_on_node123.getColumn(1);
+				force[id3] -= scale1 * df_on_node123.getColumn(2);
+			}
+			for (int j = 0; j < psb->m_nodes.size(); ++j)
+			{
+				const btSoftBody::Node& node = psb->m_nodes[j];
+				size_t id = node.index;
+				if (node.m_im > 0)
+				{
+					force[id] -= scale * node.m_v / node.m_im * m_damping_alpha;
+				}
+			}
+		}
+	}
+
+	virtual double totalElasticEnergy(btScalar dt)
+	{
+		double energy = 0;
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			btSoftBody* psb = m_softBodies[i];
+			if (!psb->isActive())
+			{
+				continue;
+			}
+			for (int j = 0; j < psb->m_tetraScratches.size(); ++j)
+			{
+				btSoftBody::Tetra& tetra = psb->m_tetras[j];
+				btSoftBody::TetraScratch& s = psb->m_tetraScratches[j];
+				energy += tetra.m_element_measure * elasticEnergyDensity(s);
+			}
+		}
+		return energy;
+	}
+
+	// The damping energy is formulated as in https://www.math.ucla.edu/~jteran/papers/GSSJT15.pdf to allow line search
+	virtual double totalDampingEnergy(btScalar dt)
+	{
+		double energy = 0;
+		int sz = 0;
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			btSoftBody* psb = m_softBodies[i];
+			if (!psb->isActive())
+			{
+				continue;
+			}
+			for (int j = 0; j < psb->m_nodes.size(); ++j)
+			{
+				sz = btMax(sz, psb->m_nodes[j].index);
+			}
+		}
+		TVStack dampingForce;
+		dampingForce.resize(sz + 1);
+		for (int i = 0; i < dampingForce.size(); ++i)
+			dampingForce[i].setZero();
+		addScaledDampingForce(0.5, dampingForce);
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			btSoftBody* psb = m_softBodies[i];
+			for (int j = 0; j < psb->m_nodes.size(); ++j)
+			{
+				const btSoftBody::Node& node = psb->m_nodes[j];
+				energy -= dampingForce[node.index].dot(node.m_v) / dt;
+			}
+		}
+		return energy;
+	}
+
+	double elasticEnergyDensity(const btSoftBody::TetraScratch& s)
+	{
+		double density = 0;
+		btMatrix3x3 epsilon = (s.m_F + s.m_F.transpose()) * 0.5 - btMatrix3x3::getIdentity();
+		btScalar trace = epsilon[0][0] + epsilon[1][1] + epsilon[2][2];
+		density += m_mu * (epsilon[0].length2() + epsilon[1].length2() + epsilon[2].length2());
+		density += m_lambda * trace * trace * 0.5;
+		return density;
+	}
+
+	virtual void addScaledElasticForce(btScalar scale, TVStack& force)
+	{
+		int numNodes = getNumNodes();
+		btAssert(numNodes <= force.size());
+		btVector3 grad_N_hat_1st_col = btVector3(-1, -1, -1);
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			btSoftBody* psb = m_softBodies[i];
+			if (!psb->isActive())
+			{
+				continue;
+			}
+			btScalar max_p = psb->m_cfg.m_maxStress;
+			for (int j = 0; j < psb->m_tetras.size(); ++j)
+			{
+				btSoftBody::Tetra& tetra = psb->m_tetras[j];
+				btMatrix3x3 P;
+				firstPiola(psb->m_tetraScratches[j], P);
+#if USE_SVD
+				if (max_p > 0)
+				{
+					// since we want to clamp the principal stress to max_p, we only need to
+					// calculate SVD when sigma_0^2 + sigma_1^2 + sigma_2^2 > max_p * max_p
+					btScalar trPTP = (P[0].length2() + P[1].length2() + P[2].length2());
+					if (trPTP > max_p * max_p)
+					{
+						btMatrix3x3 U, V;
+						btVector3 sigma;
+						singularValueDecomposition(P, U, sigma, V);
+						sigma[0] = btMin(sigma[0], max_p);
+						sigma[1] = btMin(sigma[1], max_p);
+						sigma[2] = btMin(sigma[2], max_p);
+						sigma[0] = btMax(sigma[0], -max_p);
+						sigma[1] = btMax(sigma[1], -max_p);
+						sigma[2] = btMax(sigma[2], -max_p);
+						btMatrix3x3 Sigma;
+						Sigma.setIdentity();
+						Sigma[0][0] = sigma[0];
+						Sigma[1][1] = sigma[1];
+						Sigma[2][2] = sigma[2];
+						P = U * Sigma * V.transpose();
+					}
+				}
+#endif
+				//                btVector3 force_on_node0 = P * (tetra.m_Dm_inverse.transpose()*grad_N_hat_1st_col);
+				btMatrix3x3 force_on_node123 = psb->m_tetraScratches[j].m_corotation * P * tetra.m_Dm_inverse.transpose();
+				btVector3 force_on_node0 = force_on_node123 * grad_N_hat_1st_col;
+
+				btSoftBody::Node* node0 = tetra.m_n[0];
+				btSoftBody::Node* node1 = tetra.m_n[1];
+				btSoftBody::Node* node2 = tetra.m_n[2];
+				btSoftBody::Node* node3 = tetra.m_n[3];
+				size_t id0 = node0->index;
+				size_t id1 = node1->index;
+				size_t id2 = node2->index;
+				size_t id3 = node3->index;
+
+				// elastic force
+				btScalar scale1 = scale * tetra.m_element_measure;
+				force[id0] -= scale1 * force_on_node0;
+				force[id1] -= scale1 * force_on_node123.getColumn(0);
+				force[id2] -= scale1 * force_on_node123.getColumn(1);
+				force[id3] -= scale1 * force_on_node123.getColumn(2);
+			}
+		}
+	}
+
+	virtual void buildDampingForceDifferentialDiagonal(btScalar scale, TVStack& diagA) {}
+
+	// The damping matrix is calculated using the time n state as described in https://www.math.ucla.edu/~jteran/papers/GSSJT15.pdf to allow line search
+	virtual void addScaledDampingForceDifferential(btScalar scale, const TVStack& dv, TVStack& df)
+	{
+		if (m_damping_alpha == 0 && m_damping_beta == 0)
+			return;
+		btScalar mu_damp = m_damping_beta * m_mu;
+		btScalar lambda_damp = m_damping_beta * m_lambda;
+		int numNodes = getNumNodes();
+		btAssert(numNodes <= df.size());
+		btVector3 grad_N_hat_1st_col = btVector3(-1, -1, -1);
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			btSoftBody* psb = m_softBodies[i];
+			if (!psb->isActive())
+			{
+				continue;
+			}
+			for (int j = 0; j < psb->m_tetras.size(); ++j)
+			{
+				bool close_to_flat = (psb->m_tetraScratches[j].m_J < TETRA_FLAT_THRESHOLD);
+				btSoftBody::Tetra& tetra = psb->m_tetras[j];
+				btSoftBody::Node* node0 = tetra.m_n[0];
+				btSoftBody::Node* node1 = tetra.m_n[1];
+				btSoftBody::Node* node2 = tetra.m_n[2];
+				btSoftBody::Node* node3 = tetra.m_n[3];
+				size_t id0 = node0->index;
+				size_t id1 = node1->index;
+				size_t id2 = node2->index;
+				size_t id3 = node3->index;
+				btMatrix3x3 dF = Ds(id0, id1, id2, id3, dv) * tetra.m_Dm_inverse;
+				if (!close_to_flat)
+				{
+					dF = psb->m_tetraScratches[j].m_corotation.transpose() * dF;
+				}
+				btMatrix3x3 I;
+				I.setIdentity();
+				btMatrix3x3 dP = (dF + dF.transpose()) * mu_damp + I * ((dF[0][0] + dF[1][1] + dF[2][2]) * lambda_damp);
+				btMatrix3x3 df_on_node123 = dP * tetra.m_Dm_inverse.transpose();
+				if (!close_to_flat)
+				{
+					df_on_node123 = psb->m_tetraScratches[j].m_corotation * df_on_node123;
+				}
+				btVector3 df_on_node0 = df_on_node123 * grad_N_hat_1st_col;
+
+				// damping force differential
+				btScalar scale1 = scale * tetra.m_element_measure;
+				df[id0] -= scale1 * df_on_node0;
+				df[id1] -= scale1 * df_on_node123.getColumn(0);
+				df[id2] -= scale1 * df_on_node123.getColumn(1);
+				df[id3] -= scale1 * df_on_node123.getColumn(2);
+			}
+			for (int j = 0; j < psb->m_nodes.size(); ++j)
+			{
+				const btSoftBody::Node& node = psb->m_nodes[j];
+				size_t id = node.index;
+				if (node.m_im > 0)
+				{
+					df[id] -= scale * dv[id] / node.m_im * m_damping_alpha;
+				}
+			}
+		}
+	}
+
+	virtual void addScaledElasticForceDifferential(btScalar scale, const TVStack& dx, TVStack& df)
+	{
+		int numNodes = getNumNodes();
+		btAssert(numNodes <= df.size());
+		btVector3 grad_N_hat_1st_col = btVector3(-1, -1, -1);
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			btSoftBody* psb = m_softBodies[i];
+			if (!psb->isActive())
+			{
+				continue;
+			}
+			for (int j = 0; j < psb->m_tetras.size(); ++j)
+			{
+				btSoftBody::Tetra& tetra = psb->m_tetras[j];
+				btSoftBody::Node* node0 = tetra.m_n[0];
+				btSoftBody::Node* node1 = tetra.m_n[1];
+				btSoftBody::Node* node2 = tetra.m_n[2];
+				btSoftBody::Node* node3 = tetra.m_n[3];
+				size_t id0 = node0->index;
+				size_t id1 = node1->index;
+				size_t id2 = node2->index;
+				size_t id3 = node3->index;
+				btMatrix3x3 dF = psb->m_tetraScratches[j].m_corotation.transpose() * Ds(id0, id1, id2, id3, dx) * tetra.m_Dm_inverse;
+				btMatrix3x3 dP;
+				firstPiolaDifferential(psb->m_tetraScratches[j], dF, dP);
+				//                btVector3 df_on_node0 = dP * (tetra.m_Dm_inverse.transpose()*grad_N_hat_1st_col);
+				btMatrix3x3 df_on_node123 = psb->m_tetraScratches[j].m_corotation * dP * tetra.m_Dm_inverse.transpose();
+				btVector3 df_on_node0 = df_on_node123 * grad_N_hat_1st_col;
+
+				// elastic force differential
+				btScalar scale1 = scale * tetra.m_element_measure;
+				df[id0] -= scale1 * df_on_node0;
+				df[id1] -= scale1 * df_on_node123.getColumn(0);
+				df[id2] -= scale1 * df_on_node123.getColumn(1);
+				df[id3] -= scale1 * df_on_node123.getColumn(2);
+			}
+		}
+	}
+
+	void firstPiola(const btSoftBody::TetraScratch& s, btMatrix3x3& P)
+	{
+		btMatrix3x3 corotated_F = s.m_corotation.transpose() * s.m_F;
+
+		btMatrix3x3 epsilon = (corotated_F + corotated_F.transpose()) * 0.5 - btMatrix3x3::getIdentity();
+		btScalar trace = epsilon[0][0] + epsilon[1][1] + epsilon[2][2];
+		P = epsilon * btScalar(2) * m_mu + btMatrix3x3::getIdentity() * m_lambda * trace;
+	}
+
+	// Let P be the first piola stress.
+	// This function calculates the dP = dP/dF * dF
+	void firstPiolaDifferential(const btSoftBody::TetraScratch& s, const btMatrix3x3& dF, btMatrix3x3& dP)
+	{
+		btScalar trace = (dF[0][0] + dF[1][1] + dF[2][2]);
+		dP = (dF + dF.transpose()) * m_mu + btMatrix3x3::getIdentity() * m_lambda * trace;
+	}
+
+	// Let Q be the damping stress.
+	// This function calculates the dP = dQ/dF * dF
+	void firstPiolaDampingDifferential(const btSoftBody::TetraScratch& s, const btMatrix3x3& dF, btMatrix3x3& dP)
+	{
+		btScalar mu_damp = m_damping_beta * m_mu;
+		btScalar lambda_damp = m_damping_beta * m_lambda;
+		btScalar trace = (dF[0][0] + dF[1][1] + dF[2][2]);
+		dP = (dF + dF.transpose()) * mu_damp + btMatrix3x3::getIdentity() * lambda_damp * trace;
+	}
+
+	virtual void addScaledHessian(btScalar scale)
+	{
+		btVector3 grad_N_hat_1st_col = btVector3(-1, -1, -1);
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			btSoftBody* psb = m_softBodies[i];
+			if (!psb->isActive())
+			{
+				continue;
+			}
+			for (int j = 0; j < psb->m_tetras.size(); ++j)
+			{
+				btSoftBody::Tetra& tetra = psb->m_tetras[j];
+				btMatrix3x3 P;
+				firstPiola(psb->m_tetraScratches[j], P);  // make sure scratch is evaluated at x_n + dt * vn
+				btMatrix3x3 force_on_node123 = psb->m_tetraScratches[j].m_corotation * P * tetra.m_Dm_inverse.transpose();
+				btVector3 force_on_node0 = force_on_node123 * grad_N_hat_1st_col;
+				btSoftBody::Node* node0 = tetra.m_n[0];
+				btSoftBody::Node* node1 = tetra.m_n[1];
+				btSoftBody::Node* node2 = tetra.m_n[2];
+				btSoftBody::Node* node3 = tetra.m_n[3];
+				btScalar scale1 = scale * (scale + m_damping_beta) * tetra.m_element_measure;  // stiff and stiffness-damping terms;
+				node0->m_effectiveMass += OuterProduct(force_on_node0, force_on_node0) * scale1;
+				node1->m_effectiveMass += OuterProduct(force_on_node123.getColumn(0), force_on_node123.getColumn(0)) * scale1;
+				node2->m_effectiveMass += OuterProduct(force_on_node123.getColumn(1), force_on_node123.getColumn(1)) * scale1;
+				node3->m_effectiveMass += OuterProduct(force_on_node123.getColumn(2), force_on_node123.getColumn(2)) * scale1;
+			}
+			for (int j = 0; j < psb->m_nodes.size(); ++j)
+			{
+				btSoftBody::Node& node = psb->m_nodes[j];
+				if (node.m_im > 0)
+				{
+					btMatrix3x3 I;
+					I.setIdentity();
+					node.m_effectiveMass += I * (scale * (1.0 / node.m_im) * m_damping_alpha);
+				}
+			}
+		}
+	}
+
+	virtual btDeformableLagrangianForceType getForceType()
+	{
+		return BT_LINEAR_ELASTICITY_FORCE;
+	}
+};
+#endif /* BT_LINEAR_ELASTICITY_H */
diff --git a/engine/inc/bullet/BulletSoftBody/btDeformableMassSpringForce.h b/engine/inc/bullet/BulletSoftBody/btDeformableMassSpringForce.h
new file mode 100644
index 00000000..8c97bd1b
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btDeformableMassSpringForce.h
@@ -0,0 +1,301 @@
+/*
+ Written by Xuchen Han <xuchenhan2015@u.northwestern.edu>
+ 
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef BT_MASS_SPRING_H
+#define BT_MASS_SPRING_H
+
+#include "btDeformableLagrangianForce.h"
+
+class btDeformableMassSpringForce : public btDeformableLagrangianForce
+{
+	// If true, the damping force will be in the direction of the spring
+	// If false, the damping force will be in the direction of the velocity
+	bool m_momentum_conserving;
+	btScalar m_elasticStiffness, m_dampingStiffness, m_bendingStiffness;
+
+public:
+	typedef btAlignedObjectArray<btVector3> TVStack;
+	btDeformableMassSpringForce() : m_momentum_conserving(false), m_elasticStiffness(1), m_dampingStiffness(0.05)
+	{
+	}
+	btDeformableMassSpringForce(btScalar k, btScalar d, bool conserve_angular = true, double bending_k = -1) : m_momentum_conserving(conserve_angular), m_elasticStiffness(k), m_dampingStiffness(d), m_bendingStiffness(bending_k)
+	{
+		if (m_bendingStiffness < btScalar(0))
+		{
+			m_bendingStiffness = m_elasticStiffness;
+		}
+	}
+
+	virtual void addScaledForces(btScalar scale, TVStack& force)
+	{
+		addScaledDampingForce(scale, force);
+		addScaledElasticForce(scale, force);
+	}
+
+	virtual void addScaledExplicitForce(btScalar scale, TVStack& force)
+	{
+		addScaledElasticForce(scale, force);
+	}
+
+	virtual void addScaledDampingForce(btScalar scale, TVStack& force)
+	{
+		int numNodes = getNumNodes();
+		btAssert(numNodes <= force.size());
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			const btSoftBody* psb = m_softBodies[i];
+			if (!psb->isActive())
+			{
+				continue;
+			}
+			for (int j = 0; j < psb->m_links.size(); ++j)
+			{
+				const btSoftBody::Link& link = psb->m_links[j];
+				btSoftBody::Node* node1 = link.m_n[0];
+				btSoftBody::Node* node2 = link.m_n[1];
+				size_t id1 = node1->index;
+				size_t id2 = node2->index;
+
+				// damping force
+				btVector3 v_diff = (node2->m_v - node1->m_v);
+				btVector3 scaled_force = scale * m_dampingStiffness * v_diff;
+				if (m_momentum_conserving)
+				{
+					if ((node2->m_x - node1->m_x).norm() > SIMD_EPSILON)
+					{
+						btVector3 dir = (node2->m_x - node1->m_x).normalized();
+						scaled_force = scale * m_dampingStiffness * v_diff.dot(dir) * dir;
+					}
+				}
+				force[id1] += scaled_force;
+				force[id2] -= scaled_force;
+			}
+		}
+	}
+
+	virtual void addScaledElasticForce(btScalar scale, TVStack& force)
+	{
+		int numNodes = getNumNodes();
+		btAssert(numNodes <= force.size());
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			const btSoftBody* psb = m_softBodies[i];
+			if (!psb->isActive())
+			{
+				continue;
+			}
+			for (int j = 0; j < psb->m_links.size(); ++j)
+			{
+				const btSoftBody::Link& link = psb->m_links[j];
+				btSoftBody::Node* node1 = link.m_n[0];
+				btSoftBody::Node* node2 = link.m_n[1];
+				btScalar r = link.m_rl;
+				size_t id1 = node1->index;
+				size_t id2 = node2->index;
+
+				// elastic force
+				btVector3 dir = (node2->m_q - node1->m_q);
+				btVector3 dir_normalized = (dir.norm() > SIMD_EPSILON) ? dir.normalized() : btVector3(0, 0, 0);
+				btScalar scaled_stiffness = scale * (link.m_bbending ? m_bendingStiffness : m_elasticStiffness);
+				btVector3 scaled_force = scaled_stiffness * (dir - dir_normalized * r);
+				force[id1] += scaled_force;
+				force[id2] -= scaled_force;
+			}
+		}
+	}
+
+	virtual void addScaledDampingForceDifferential(btScalar scale, const TVStack& dv, TVStack& df)
+	{
+		// implicit damping force differential
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			btSoftBody* psb = m_softBodies[i];
+			if (!psb->isActive())
+			{
+				continue;
+			}
+			btScalar scaled_k_damp = m_dampingStiffness * scale;
+			for (int j = 0; j < psb->m_links.size(); ++j)
+			{
+				const btSoftBody::Link& link = psb->m_links[j];
+				btSoftBody::Node* node1 = link.m_n[0];
+				btSoftBody::Node* node2 = link.m_n[1];
+				size_t id1 = node1->index;
+				size_t id2 = node2->index;
+
+				btVector3 local_scaled_df = scaled_k_damp * (dv[id2] - dv[id1]);
+				if (m_momentum_conserving)
+				{
+					if ((node2->m_x - node1->m_x).norm() > SIMD_EPSILON)
+					{
+						btVector3 dir = (node2->m_x - node1->m_x).normalized();
+						local_scaled_df = scaled_k_damp * (dv[id2] - dv[id1]).dot(dir) * dir;
+					}
+				}
+				df[id1] += local_scaled_df;
+				df[id2] -= local_scaled_df;
+			}
+		}
+	}
+
+	virtual void buildDampingForceDifferentialDiagonal(btScalar scale, TVStack& diagA)
+	{
+		// implicit damping force differential
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			btSoftBody* psb = m_softBodies[i];
+			if (!psb->isActive())
+			{
+				continue;
+			}
+			btScalar scaled_k_damp = m_dampingStiffness * scale;
+			for (int j = 0; j < psb->m_links.size(); ++j)
+			{
+				const btSoftBody::Link& link = psb->m_links[j];
+				btSoftBody::Node* node1 = link.m_n[0];
+				btSoftBody::Node* node2 = link.m_n[1];
+				size_t id1 = node1->index;
+				size_t id2 = node2->index;
+				if (m_momentum_conserving)
+				{
+					if ((node2->m_x - node1->m_x).norm() > SIMD_EPSILON)
+					{
+						btVector3 dir = (node2->m_x - node1->m_x).normalized();
+						for (int d = 0; d < 3; ++d)
+						{
+							if (node1->m_im > 0)
+								diagA[id1][d] -= scaled_k_damp * dir[d] * dir[d];
+							if (node2->m_im > 0)
+								diagA[id2][d] -= scaled_k_damp * dir[d] * dir[d];
+						}
+					}
+				}
+				else
+				{
+					for (int d = 0; d < 3; ++d)
+					{
+						if (node1->m_im > 0)
+							diagA[id1][d] -= scaled_k_damp;
+						if (node2->m_im > 0)
+							diagA[id2][d] -= scaled_k_damp;
+					}
+				}
+			}
+		}
+	}
+
+	virtual double totalElasticEnergy(btScalar dt)
+	{
+		double energy = 0;
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			const btSoftBody* psb = m_softBodies[i];
+			if (!psb->isActive())
+			{
+				continue;
+			}
+			for (int j = 0; j < psb->m_links.size(); ++j)
+			{
+				const btSoftBody::Link& link = psb->m_links[j];
+				btSoftBody::Node* node1 = link.m_n[0];
+				btSoftBody::Node* node2 = link.m_n[1];
+				btScalar r = link.m_rl;
+
+				// elastic force
+				btVector3 dir = (node2->m_q - node1->m_q);
+				energy += 0.5 * m_elasticStiffness * (dir.norm() - r) * (dir.norm() - r);
+			}
+		}
+		return energy;
+	}
+
+	virtual double totalDampingEnergy(btScalar dt)
+	{
+		double energy = 0;
+		int sz = 0;
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			btSoftBody* psb = m_softBodies[i];
+			if (!psb->isActive())
+			{
+				continue;
+			}
+			for (int j = 0; j < psb->m_nodes.size(); ++j)
+			{
+				sz = btMax(sz, psb->m_nodes[j].index);
+			}
+		}
+		TVStack dampingForce;
+		dampingForce.resize(sz + 1);
+		for (int i = 0; i < dampingForce.size(); ++i)
+			dampingForce[i].setZero();
+		addScaledDampingForce(0.5, dampingForce);
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			btSoftBody* psb = m_softBodies[i];
+			for (int j = 0; j < psb->m_nodes.size(); ++j)
+			{
+				const btSoftBody::Node& node = psb->m_nodes[j];
+				energy -= dampingForce[node.index].dot(node.m_v) / dt;
+			}
+		}
+		return energy;
+	}
+
+	virtual void addScaledElasticForceDifferential(btScalar scale, const TVStack& dx, TVStack& df)
+	{
+		// implicit damping force differential
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			const btSoftBody* psb = m_softBodies[i];
+			if (!psb->isActive())
+			{
+				continue;
+			}
+			for (int j = 0; j < psb->m_links.size(); ++j)
+			{
+				const btSoftBody::Link& link = psb->m_links[j];
+				btSoftBody::Node* node1 = link.m_n[0];
+				btSoftBody::Node* node2 = link.m_n[1];
+				size_t id1 = node1->index;
+				size_t id2 = node2->index;
+				btScalar r = link.m_rl;
+
+				btVector3 dir = (node1->m_q - node2->m_q);
+				btScalar dir_norm = dir.norm();
+				btVector3 dir_normalized = (dir_norm > SIMD_EPSILON) ? dir.normalized() : btVector3(0, 0, 0);
+				btVector3 dx_diff = dx[id1] - dx[id2];
+				btVector3 scaled_df = btVector3(0, 0, 0);
+				btScalar scaled_k = scale * (link.m_bbending ? m_bendingStiffness : m_elasticStiffness);
+				if (dir_norm > SIMD_EPSILON)
+				{
+					scaled_df -= scaled_k * dir_normalized.dot(dx_diff) * dir_normalized;
+					scaled_df += scaled_k * dir_normalized.dot(dx_diff) * ((dir_norm - r) / dir_norm) * dir_normalized;
+					scaled_df -= scaled_k * ((dir_norm - r) / dir_norm) * dx_diff;
+				}
+
+				df[id1] += scaled_df;
+				df[id2] -= scaled_df;
+			}
+		}
+	}
+
+	virtual btDeformableLagrangianForceType getForceType()
+	{
+		return BT_MASSSPRING_FORCE;
+	}
+};
+
+#endif /* btMassSpring_h */
diff --git a/engine/inc/bullet/BulletSoftBody/btDeformableMousePickingForce.h b/engine/inc/bullet/BulletSoftBody/btDeformableMousePickingForce.h
new file mode 100644
index 00000000..d218d962
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btDeformableMousePickingForce.h
@@ -0,0 +1,162 @@
+/*
+ Written by Xuchen Han <xuchenhan2015@u.northwestern.edu>
+ 
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef BT_MOUSE_PICKING_FORCE_H
+#define BT_MOUSE_PICKING_FORCE_H
+
+#include "btDeformableLagrangianForce.h"
+
+class btDeformableMousePickingForce : public btDeformableLagrangianForce
+{
+	// If true, the damping force will be in the direction of the spring
+	// If false, the damping force will be in the direction of the velocity
+	btScalar m_elasticStiffness, m_dampingStiffness;
+	const btSoftBody::Face& m_face;
+	btVector3 m_mouse_pos;
+	btScalar m_maxForce;
+
+public:
+	typedef btAlignedObjectArray<btVector3> TVStack;
+	btDeformableMousePickingForce(btScalar k, btScalar d, const btSoftBody::Face& face, btVector3 mouse_pos, btScalar maxForce = 0.3) : m_elasticStiffness(k), m_dampingStiffness(d), m_face(face), m_mouse_pos(mouse_pos), m_maxForce(maxForce)
+	{
+	}
+
+	virtual void addScaledForces(btScalar scale, TVStack& force)
+	{
+		addScaledDampingForce(scale, force);
+		addScaledElasticForce(scale, force);
+	}
+
+	virtual void addScaledExplicitForce(btScalar scale, TVStack& force)
+	{
+		addScaledElasticForce(scale, force);
+	}
+
+	virtual void addScaledDampingForce(btScalar scale, TVStack& force)
+	{
+		for (int i = 0; i < 3; ++i)
+		{
+			btVector3 v_diff = m_face.m_n[i]->m_v;
+			btVector3 scaled_force = scale * m_dampingStiffness * v_diff;
+			if ((m_face.m_n[i]->m_x - m_mouse_pos).norm() > SIMD_EPSILON)
+			{
+				btVector3 dir = (m_face.m_n[i]->m_x - m_mouse_pos).normalized();
+				scaled_force = scale * m_dampingStiffness * v_diff.dot(dir) * dir;
+			}
+			force[m_face.m_n[i]->index] -= scaled_force;
+		}
+	}
+
+	virtual void addScaledElasticForce(btScalar scale, TVStack& force)
+	{
+		btScalar scaled_stiffness = scale * m_elasticStiffness;
+		for (int i = 0; i < 3; ++i)
+		{
+			btVector3 dir = (m_face.m_n[i]->m_q - m_mouse_pos);
+			btVector3 scaled_force = scaled_stiffness * dir;
+			if (scaled_force.safeNorm() > m_maxForce)
+			{
+				scaled_force.safeNormalize();
+				scaled_force *= m_maxForce;
+			}
+			force[m_face.m_n[i]->index] -= scaled_force;
+		}
+	}
+
+	virtual void addScaledDampingForceDifferential(btScalar scale, const TVStack& dv, TVStack& df)
+	{
+		btScalar scaled_k_damp = m_dampingStiffness * scale;
+		for (int i = 0; i < 3; ++i)
+		{
+			btVector3 local_scaled_df = scaled_k_damp * dv[m_face.m_n[i]->index];
+			if ((m_face.m_n[i]->m_x - m_mouse_pos).norm() > SIMD_EPSILON)
+			{
+				btVector3 dir = (m_face.m_n[i]->m_x - m_mouse_pos).normalized();
+				local_scaled_df = scaled_k_damp * dv[m_face.m_n[i]->index].dot(dir) * dir;
+			}
+			df[m_face.m_n[i]->index] -= local_scaled_df;
+		}
+	}
+
+	virtual void buildDampingForceDifferentialDiagonal(btScalar scale, TVStack& diagA) {}
+
+	virtual double totalElasticEnergy(btScalar dt)
+	{
+		double energy = 0;
+		for (int i = 0; i < 3; ++i)
+		{
+			btVector3 dir = (m_face.m_n[i]->m_q - m_mouse_pos);
+			btVector3 scaled_force = m_elasticStiffness * dir;
+			if (scaled_force.safeNorm() > m_maxForce)
+			{
+				scaled_force.safeNormalize();
+				scaled_force *= m_maxForce;
+			}
+			energy += 0.5 * scaled_force.dot(dir);
+		}
+		return energy;
+	}
+
+	virtual double totalDampingEnergy(btScalar dt)
+	{
+		double energy = 0;
+		for (int i = 0; i < 3; ++i)
+		{
+			btVector3 v_diff = m_face.m_n[i]->m_v;
+			btVector3 scaled_force = m_dampingStiffness * v_diff;
+			if ((m_face.m_n[i]->m_x - m_mouse_pos).norm() > SIMD_EPSILON)
+			{
+				btVector3 dir = (m_face.m_n[i]->m_x - m_mouse_pos).normalized();
+				scaled_force = m_dampingStiffness * v_diff.dot(dir) * dir;
+			}
+			energy -= scaled_force.dot(m_face.m_n[i]->m_v) / dt;
+		}
+		return energy;
+	}
+
+	virtual void addScaledElasticForceDifferential(btScalar scale, const TVStack& dx, TVStack& df)
+	{
+		btScalar scaled_stiffness = scale * m_elasticStiffness;
+		for (int i = 0; i < 3; ++i)
+		{
+			btVector3 dir = (m_face.m_n[i]->m_q - m_mouse_pos);
+			btScalar dir_norm = dir.norm();
+			btVector3 dir_normalized = (dir_norm > SIMD_EPSILON) ? dir.normalized() : btVector3(0, 0, 0);
+			int id = m_face.m_n[i]->index;
+			btVector3 dx_diff = dx[id];
+			btScalar r = 0;  // rest length is 0 for picking spring
+			btVector3 scaled_df = btVector3(0, 0, 0);
+			if (dir_norm > SIMD_EPSILON)
+			{
+				scaled_df -= scaled_stiffness * dir_normalized.dot(dx_diff) * dir_normalized;
+				scaled_df += scaled_stiffness * dir_normalized.dot(dx_diff) * ((dir_norm - r) / dir_norm) * dir_normalized;
+				scaled_df -= scaled_stiffness * ((dir_norm - r) / dir_norm) * dx_diff;
+			}
+			df[id] += scaled_df;
+		}
+	}
+
+	void setMousePos(const btVector3& p)
+	{
+		m_mouse_pos = p;
+	}
+
+	virtual btDeformableLagrangianForceType getForceType()
+	{
+		return BT_MOUSE_PICKING_FORCE;
+	}
+};
+
+#endif /* btMassSpring_h */
diff --git a/engine/inc/bullet/BulletSoftBody/btDeformableMultiBodyConstraintSolver.h b/engine/inc/bullet/BulletSoftBody/btDeformableMultiBodyConstraintSolver.h
new file mode 100644
index 00000000..94aabce8
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btDeformableMultiBodyConstraintSolver.h
@@ -0,0 +1,61 @@
+/*
+ Written by Xuchen Han <xuchenhan2015@u.northwestern.edu>
+ 
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef BT_DEFORMABLE_MULTIBODY_CONSTRAINT_SOLVER_H
+#define BT_DEFORMABLE_MULTIBODY_CONSTRAINT_SOLVER_H
+
+#include "btDeformableBodySolver.h"
+#include "BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h"
+
+class btDeformableBodySolver;
+
+// btDeformableMultiBodyConstraintSolver extendsn btMultiBodyConstraintSolver to solve for the contact among rigid/multibody and deformable bodies. Notice that the following constraints
+// 1. rigid/multibody against rigid/multibody
+// 2. rigid/multibody against deforamble
+// 3. deformable against deformable
+// 4. deformable self collision
+// 5. joint constraints
+// are all coupled in this solve.
+ATTRIBUTE_ALIGNED16(class)
+btDeformableMultiBodyConstraintSolver : public btMultiBodyConstraintSolver
+{
+	btDeformableBodySolver* m_deformableSolver;
+
+protected:
+	// override the iterations method to include deformable/multibody contact
+	//    virtual btScalar solveGroupCacheFriendlyIterations(btCollisionObject** bodies,int numBodies,btPersistentManifold** manifoldPtr, int numManifolds,btTypedConstraint** constraints,int numConstraints,const btContactSolverInfo& infoGlobal,btIDebugDraw* debugDrawer);
+
+	// write the velocity of the the solver body to the underlying rigid body
+	void solverBodyWriteBack(const btContactSolverInfo& infoGlobal);
+
+	// write the velocity of the underlying rigid body to the the the solver body
+	void writeToSolverBody(btCollisionObject * *bodies, int numBodies, const btContactSolverInfo& infoGlobal);
+
+	virtual void solveGroupCacheFriendlySplitImpulseIterations(btCollisionObject * *bodies, int numBodies, btCollisionObject** deformableBodies, int numDeformableBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer);
+
+	virtual btScalar solveDeformableGroupIterations(btCollisionObject * *bodies, int numBodies, btCollisionObject** deformableBodies, int numDeformableBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer);
+
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	void setDeformableSolver(btDeformableBodySolver * deformableSolver)
+	{
+		m_deformableSolver = deformableSolver;
+	}
+
+	virtual void solveDeformableBodyGroup(btCollisionObject * *bodies, int numBodies, btCollisionObject** deformableBodies, int numDeformableBodies, btPersistentManifold** manifold, int numManifolds, btTypedConstraint** constraints, int numConstraints, btMultiBodyConstraint** multiBodyConstraints, int numMultiBodyConstraints, const btContactSolverInfo& info, btIDebugDraw* debugDrawer, btDispatcher* dispatcher);
+};
+
+#endif /* BT_DEFORMABLE_MULTIBODY_CONSTRAINT_SOLVER_H */
diff --git a/engine/inc/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.h b/engine/inc/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.h
new file mode 100644
index 00000000..4b7069aa
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.h
@@ -0,0 +1,316 @@
+/*
+ Written by Xuchen Han <xuchenhan2015@u.northwestern.edu>
+ 
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD_H
+#define BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD_H
+
+#include "btSoftMultiBodyDynamicsWorld.h"
+#include "btDeformableLagrangianForce.h"
+#include "btDeformableMassSpringForce.h"
+#include "btDeformableBodySolver.h"
+#include "btDeformableMultiBodyConstraintSolver.h"
+#include "btSoftBodyHelpers.h"
+#include "BulletCollision/CollisionDispatch/btSimulationIslandManager.h"
+#include <functional>
+typedef btAlignedObjectArray<btSoftBody*> btSoftBodyArray;
+
+class btDeformableBodySolver;
+class btDeformableLagrangianForce;
+struct MultiBodyInplaceSolverIslandCallback;
+struct DeformableBodyInplaceSolverIslandCallback;
+class btDeformableMultiBodyConstraintSolver;
+
+typedef btAlignedObjectArray<btSoftBody*> btSoftBodyArray;
+
+class btDeformableMultiBodyDynamicsWorld : public btMultiBodyDynamicsWorld
+{
+	typedef btAlignedObjectArray<btVector3> TVStack;
+	///Solver classes that encapsulate multiple deformable bodies for solving
+	btDeformableBodySolver* m_deformableBodySolver;
+	btSoftBodyArray m_softBodies;
+	int m_drawFlags;
+	bool m_drawNodeTree;
+	bool m_drawFaceTree;
+	bool m_drawClusterTree;
+	btSoftBodyWorldInfo m_sbi;
+	btScalar m_internalTime;
+	int m_ccdIterations;
+	bool m_implicit;
+	bool m_lineSearch;
+	bool m_useProjection;
+	DeformableBodyInplaceSolverIslandCallback* m_solverDeformableBodyIslandCallback;
+
+	typedef void (*btSolverCallback)(btScalar time, btDeformableMultiBodyDynamicsWorld* world);
+	btSolverCallback m_solverCallback;
+
+protected:
+	virtual void internalSingleStepSimulation(btScalar timeStep);
+
+	virtual void integrateTransforms(btScalar timeStep);
+
+	void positionCorrection(btScalar timeStep);
+
+	void solveConstraints(btScalar timeStep);
+
+	void updateActivationState(btScalar timeStep);
+
+	void clearGravity();
+
+public:
+	btDeformableMultiBodyDynamicsWorld(btDispatcher* dispatcher, btBroadphaseInterface* pairCache, btDeformableMultiBodyConstraintSolver* constraintSolver, btCollisionConfiguration* collisionConfiguration, btDeformableBodySolver* deformableBodySolver = 0);
+
+	virtual int stepSimulation(btScalar timeStep, int maxSubSteps = 1, btScalar fixedTimeStep = btScalar(1.) / btScalar(60.));
+
+	virtual void debugDrawWorld();
+
+	void setSolverCallback(btSolverCallback cb)
+	{
+		m_solverCallback = cb;
+	}
+
+	virtual ~btDeformableMultiBodyDynamicsWorld();
+
+	virtual btMultiBodyDynamicsWorld* getMultiBodyDynamicsWorld()
+	{
+		return (btMultiBodyDynamicsWorld*)(this);
+	}
+
+	virtual const btMultiBodyDynamicsWorld* getMultiBodyDynamicsWorld() const
+	{
+		return (const btMultiBodyDynamicsWorld*)(this);
+	}
+
+	virtual btDynamicsWorldType getWorldType() const
+	{
+		return BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD;
+	}
+
+	virtual void predictUnconstraintMotion(btScalar timeStep);
+
+	virtual void addSoftBody(btSoftBody* body, int collisionFilterGroup = btBroadphaseProxy::DefaultFilter, int collisionFilterMask = btBroadphaseProxy::AllFilter);
+
+	btSoftBodyArray& getSoftBodyArray()
+	{
+		return m_softBodies;
+	}
+
+	const btSoftBodyArray& getSoftBodyArray() const
+	{
+		return m_softBodies;
+	}
+
+	btSoftBodyWorldInfo& getWorldInfo()
+	{
+		return m_sbi;
+	}
+
+	const btSoftBodyWorldInfo& getWorldInfo() const
+	{
+		return m_sbi;
+	}
+
+	void reinitialize(btScalar timeStep);
+
+	void applyRigidBodyGravity(btScalar timeStep);
+
+	void beforeSolverCallbacks(btScalar timeStep);
+
+	void afterSolverCallbacks(btScalar timeStep);
+
+	void addForce(btSoftBody* psb, btDeformableLagrangianForce* force);
+
+	void removeForce(btSoftBody* psb, btDeformableLagrangianForce* force);
+
+	void removeSoftBodyForce(btSoftBody* psb);
+
+	void removeSoftBody(btSoftBody* body);
+
+	void removeCollisionObject(btCollisionObject* collisionObject);
+
+	int getDrawFlags() const { return (m_drawFlags); }
+	void setDrawFlags(int f) { m_drawFlags = f; }
+
+	void setupConstraints();
+
+	void performDeformableCollisionDetection();
+
+	void solveMultiBodyConstraints();
+
+	void solveContactConstraints();
+
+	void sortConstraints();
+
+	void softBodySelfCollision();
+
+	void setImplicit(bool implicit)
+	{
+		m_implicit = implicit;
+	}
+
+	void setLineSearch(bool lineSearch)
+	{
+		m_lineSearch = lineSearch;
+	}
+
+	void setUseProjection(bool useProjection)
+	{
+		m_useProjection = useProjection;
+	}
+
+	void applyRepulsionForce(btScalar timeStep);
+
+	void performGeometricCollisions(btScalar timeStep);
+
+	struct btDeformableSingleRayCallback : public btBroadphaseRayCallback
+	{
+		btVector3 m_rayFromWorld;
+		btVector3 m_rayToWorld;
+		btTransform m_rayFromTrans;
+		btTransform m_rayToTrans;
+		btVector3 m_hitNormal;
+
+		const btDeformableMultiBodyDynamicsWorld* m_world;
+		btCollisionWorld::RayResultCallback& m_resultCallback;
+
+		btDeformableSingleRayCallback(const btVector3& rayFromWorld, const btVector3& rayToWorld, const btDeformableMultiBodyDynamicsWorld* world, btCollisionWorld::RayResultCallback& resultCallback)
+			: m_rayFromWorld(rayFromWorld),
+			  m_rayToWorld(rayToWorld),
+			  m_world(world),
+			  m_resultCallback(resultCallback)
+		{
+			m_rayFromTrans.setIdentity();
+			m_rayFromTrans.setOrigin(m_rayFromWorld);
+			m_rayToTrans.setIdentity();
+			m_rayToTrans.setOrigin(m_rayToWorld);
+
+			btVector3 rayDir = (rayToWorld - rayFromWorld);
+
+			rayDir.normalize();
+			///what about division by zero? --> just set rayDirection[i] to INF/1e30
+			m_rayDirectionInverse[0] = rayDir[0] == btScalar(0.0) ? btScalar(1e30) : btScalar(1.0) / rayDir[0];
+			m_rayDirectionInverse[1] = rayDir[1] == btScalar(0.0) ? btScalar(1e30) : btScalar(1.0) / rayDir[1];
+			m_rayDirectionInverse[2] = rayDir[2] == btScalar(0.0) ? btScalar(1e30) : btScalar(1.0) / rayDir[2];
+			m_signs[0] = m_rayDirectionInverse[0] < 0.0;
+			m_signs[1] = m_rayDirectionInverse[1] < 0.0;
+			m_signs[2] = m_rayDirectionInverse[2] < 0.0;
+
+			m_lambda_max = rayDir.dot(m_rayToWorld - m_rayFromWorld);
+		}
+
+		virtual bool process(const btBroadphaseProxy* proxy)
+		{
+			///terminate further ray tests, once the closestHitFraction reached zero
+			if (m_resultCallback.m_closestHitFraction == btScalar(0.f))
+				return false;
+
+			btCollisionObject* collisionObject = (btCollisionObject*)proxy->m_clientObject;
+
+			//only perform raycast if filterMask matches
+			if (m_resultCallback.needsCollision(collisionObject->getBroadphaseHandle()))
+			{
+				//RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject();
+				//btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
+#if 0
+#ifdef RECALCULATE_AABB
+                btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
+                collisionObject->getCollisionShape()->getAabb(collisionObject->getWorldTransform(),collisionObjectAabbMin,collisionObjectAabbMax);
+#else
+                //getBroadphase()->getAabb(collisionObject->getBroadphaseHandle(),collisionObjectAabbMin,collisionObjectAabbMax);
+                const btVector3& collisionObjectAabbMin = collisionObject->getBroadphaseHandle()->m_aabbMin;
+                const btVector3& collisionObjectAabbMax = collisionObject->getBroadphaseHandle()->m_aabbMax;
+#endif
+#endif
+				//btScalar hitLambda = m_resultCallback.m_closestHitFraction;
+				//culling already done by broadphase
+				//if (btRayAabb(m_rayFromWorld,m_rayToWorld,collisionObjectAabbMin,collisionObjectAabbMax,hitLambda,m_hitNormal))
+				{
+					m_world->rayTestSingle(m_rayFromTrans, m_rayToTrans,
+										   collisionObject,
+										   collisionObject->getCollisionShape(),
+										   collisionObject->getWorldTransform(),
+										   m_resultCallback);
+				}
+			}
+			return true;
+		}
+	};
+
+	void rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback) const
+	{
+		BT_PROFILE("rayTest");
+		/// use the broadphase to accelerate the search for objects, based on their aabb
+		/// and for each object with ray-aabb overlap, perform an exact ray test
+		btDeformableSingleRayCallback rayCB(rayFromWorld, rayToWorld, this, resultCallback);
+
+#ifndef USE_BRUTEFORCE_RAYBROADPHASE
+		m_broadphasePairCache->rayTest(rayFromWorld, rayToWorld, rayCB);
+#else
+		for (int i = 0; i < this->getNumCollisionObjects(); i++)
+		{
+			rayCB.process(m_collisionObjects[i]->getBroadphaseHandle());
+		}
+#endif  //USE_BRUTEFORCE_RAYBROADPHASE
+	}
+
+	void rayTestSingle(const btTransform& rayFromTrans, const btTransform& rayToTrans,
+					   btCollisionObject* collisionObject,
+					   const btCollisionShape* collisionShape,
+					   const btTransform& colObjWorldTransform,
+					   RayResultCallback& resultCallback) const
+	{
+		if (collisionShape->isSoftBody())
+		{
+			btSoftBody* softBody = btSoftBody::upcast(collisionObject);
+			if (softBody)
+			{
+				btSoftBody::sRayCast softResult;
+				if (softBody->rayFaceTest(rayFromTrans.getOrigin(), rayToTrans.getOrigin(), softResult))
+				{
+					if (softResult.fraction <= resultCallback.m_closestHitFraction)
+					{
+						btCollisionWorld::LocalShapeInfo shapeInfo;
+						shapeInfo.m_shapePart = 0;
+						shapeInfo.m_triangleIndex = softResult.index;
+						// get the normal
+						btVector3 rayDir = rayToTrans.getOrigin() - rayFromTrans.getOrigin();
+						btVector3 normal = -rayDir;
+						normal.normalize();
+						{
+							normal = softBody->m_faces[softResult.index].m_normal;
+							if (normal.dot(rayDir) > 0)
+							{
+								// normal always point toward origin of the ray
+								normal = -normal;
+							}
+						}
+
+						btCollisionWorld::LocalRayResult rayResult(collisionObject,
+																   &shapeInfo,
+																   normal,
+																   softResult.fraction);
+						bool normalInWorldSpace = true;
+						resultCallback.addSingleResult(rayResult, normalInWorldSpace);
+					}
+				}
+			}
+		}
+		else
+		{
+			btCollisionWorld::rayTestSingle(rayFromTrans, rayToTrans, collisionObject, collisionShape, colObjWorldTransform, resultCallback);
+		}
+	}
+};
+
+#endif  //BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD_H
diff --git a/engine/inc/bullet/BulletSoftBody/btDeformableNeoHookeanForce.h b/engine/inc/bullet/BulletSoftBody/btDeformableNeoHookeanForce.h
new file mode 100644
index 00000000..60798c5b
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btDeformableNeoHookeanForce.h
@@ -0,0 +1,420 @@
+/*
+Written by Xuchen Han <xuchenhan2015@u.northwestern.edu>
+
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2019 Google Inc. http://bulletphysics.org
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_NEOHOOKEAN_H
+#define BT_NEOHOOKEAN_H
+
+#include "btDeformableLagrangianForce.h"
+#include "LinearMath/btQuickprof.h"
+#include "LinearMath/btImplicitQRSVD.h"
+// This energy is as described in https://graphics.pixar.com/library/StableElasticity/paper.pdf
+class btDeformableNeoHookeanForce : public btDeformableLagrangianForce
+{
+public:
+	typedef btAlignedObjectArray<btVector3> TVStack;
+	btScalar m_mu, m_lambda;  // Lame Parameters
+	btScalar m_E, m_nu;       // Young's modulus and Poisson ratio
+	btScalar m_mu_damp, m_lambda_damp;
+	btDeformableNeoHookeanForce() : m_mu(1), m_lambda(1)
+	{
+		btScalar damping = 0.05;
+		m_mu_damp = damping * m_mu;
+		m_lambda_damp = damping * m_lambda;
+		updateYoungsModulusAndPoissonRatio();
+	}
+
+	btDeformableNeoHookeanForce(btScalar mu, btScalar lambda, btScalar damping = 0.05) : m_mu(mu), m_lambda(lambda)
+	{
+		m_mu_damp = damping * m_mu;
+		m_lambda_damp = damping * m_lambda;
+		updateYoungsModulusAndPoissonRatio();
+	}
+
+	void updateYoungsModulusAndPoissonRatio()
+	{
+		// conversion from Lame Parameters to Young's modulus and Poisson ratio
+		// https://en.wikipedia.org/wiki/Lam%C3%A9_parameters
+		m_E = m_mu * (3 * m_lambda + 2 * m_mu) / (m_lambda + m_mu);
+		m_nu = m_lambda * 0.5 / (m_mu + m_lambda);
+	}
+
+	void updateLameParameters()
+	{
+		// conversion from Young's modulus and Poisson ratio to Lame Parameters
+		// https://en.wikipedia.org/wiki/Lam%C3%A9_parameters
+		m_mu = m_E * 0.5 / (1 + m_nu);
+		m_lambda = m_E * m_nu / ((1 + m_nu) * (1 - 2 * m_nu));
+	}
+
+	void setYoungsModulus(btScalar E)
+	{
+		m_E = E;
+		updateLameParameters();
+	}
+
+	void setPoissonRatio(btScalar nu)
+	{
+		m_nu = nu;
+		updateLameParameters();
+	}
+
+	void setDamping(btScalar damping)
+	{
+		m_mu_damp = damping * m_mu;
+		m_lambda_damp = damping * m_lambda;
+	}
+
+	void setLameParameters(btScalar mu, btScalar lambda)
+	{
+		m_mu = mu;
+		m_lambda = lambda;
+		updateYoungsModulusAndPoissonRatio();
+	}
+
+	virtual void addScaledForces(btScalar scale, TVStack& force)
+	{
+		addScaledDampingForce(scale, force);
+		addScaledElasticForce(scale, force);
+	}
+
+	virtual void addScaledExplicitForce(btScalar scale, TVStack& force)
+	{
+		addScaledElasticForce(scale, force);
+	}
+
+	// The damping matrix is calculated using the time n state as described in https://www.math.ucla.edu/~jteran/papers/GSSJT15.pdf to allow line search
+	virtual void addScaledDampingForce(btScalar scale, TVStack& force)
+	{
+		if (m_mu_damp == 0 && m_lambda_damp == 0)
+			return;
+		int numNodes = getNumNodes();
+		btAssert(numNodes <= force.size());
+		btVector3 grad_N_hat_1st_col = btVector3(-1, -1, -1);
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			btSoftBody* psb = m_softBodies[i];
+			if (!psb->isActive())
+			{
+				continue;
+			}
+			for (int j = 0; j < psb->m_tetras.size(); ++j)
+			{
+				btSoftBody::Tetra& tetra = psb->m_tetras[j];
+				btSoftBody::Node* node0 = tetra.m_n[0];
+				btSoftBody::Node* node1 = tetra.m_n[1];
+				btSoftBody::Node* node2 = tetra.m_n[2];
+				btSoftBody::Node* node3 = tetra.m_n[3];
+				size_t id0 = node0->index;
+				size_t id1 = node1->index;
+				size_t id2 = node2->index;
+				size_t id3 = node3->index;
+				btMatrix3x3 dF = DsFromVelocity(node0, node1, node2, node3) * tetra.m_Dm_inverse;
+				btMatrix3x3 I;
+				I.setIdentity();
+				btMatrix3x3 dP = (dF + dF.transpose()) * m_mu_damp + I * (dF[0][0] + dF[1][1] + dF[2][2]) * m_lambda_damp;
+				//                firstPiolaDampingDifferential(psb->m_tetraScratchesTn[j], dF, dP);
+				btVector3 df_on_node0 = dP * (tetra.m_Dm_inverse.transpose() * grad_N_hat_1st_col);
+				btMatrix3x3 df_on_node123 = dP * tetra.m_Dm_inverse.transpose();
+
+				// damping force differential
+				btScalar scale1 = scale * tetra.m_element_measure;
+				force[id0] -= scale1 * df_on_node0;
+				force[id1] -= scale1 * df_on_node123.getColumn(0);
+				force[id2] -= scale1 * df_on_node123.getColumn(1);
+				force[id3] -= scale1 * df_on_node123.getColumn(2);
+			}
+		}
+	}
+
+	virtual double totalElasticEnergy(btScalar dt)
+	{
+		double energy = 0;
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			btSoftBody* psb = m_softBodies[i];
+			if (!psb->isActive())
+			{
+				continue;
+			}
+			for (int j = 0; j < psb->m_tetraScratches.size(); ++j)
+			{
+				btSoftBody::Tetra& tetra = psb->m_tetras[j];
+				btSoftBody::TetraScratch& s = psb->m_tetraScratches[j];
+				energy += tetra.m_element_measure * elasticEnergyDensity(s);
+			}
+		}
+		return energy;
+	}
+
+	// The damping energy is formulated as in https://www.math.ucla.edu/~jteran/papers/GSSJT15.pdf to allow line search
+	virtual double totalDampingEnergy(btScalar dt)
+	{
+		double energy = 0;
+		int sz = 0;
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			btSoftBody* psb = m_softBodies[i];
+			if (!psb->isActive())
+			{
+				continue;
+			}
+			for (int j = 0; j < psb->m_nodes.size(); ++j)
+			{
+				sz = btMax(sz, psb->m_nodes[j].index);
+			}
+		}
+		TVStack dampingForce;
+		dampingForce.resize(sz + 1);
+		for (int i = 0; i < dampingForce.size(); ++i)
+			dampingForce[i].setZero();
+		addScaledDampingForce(0.5, dampingForce);
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			btSoftBody* psb = m_softBodies[i];
+			for (int j = 0; j < psb->m_nodes.size(); ++j)
+			{
+				const btSoftBody::Node& node = psb->m_nodes[j];
+				energy -= dampingForce[node.index].dot(node.m_v) / dt;
+			}
+		}
+		return energy;
+	}
+
+	double elasticEnergyDensity(const btSoftBody::TetraScratch& s)
+	{
+		double density = 0;
+		density += m_mu * 0.5 * (s.m_trace - 3.);
+		density += m_lambda * 0.5 * (s.m_J - 1. - 0.75 * m_mu / m_lambda) * (s.m_J - 1. - 0.75 * m_mu / m_lambda);
+		density -= m_mu * 0.5 * log(s.m_trace + 1);
+		return density;
+	}
+
+	virtual void addScaledElasticForce(btScalar scale, TVStack& force)
+	{
+		int numNodes = getNumNodes();
+		btAssert(numNodes <= force.size());
+		btVector3 grad_N_hat_1st_col = btVector3(-1, -1, -1);
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			btSoftBody* psb = m_softBodies[i];
+			if (!psb->isActive())
+			{
+				continue;
+			}
+			btScalar max_p = psb->m_cfg.m_maxStress;
+			for (int j = 0; j < psb->m_tetras.size(); ++j)
+			{
+				btSoftBody::Tetra& tetra = psb->m_tetras[j];
+				btMatrix3x3 P;
+				firstPiola(psb->m_tetraScratches[j], P);
+#ifdef USE_SVD
+				if (max_p > 0)
+				{
+					// since we want to clamp the principal stress to max_p, we only need to
+					// calculate SVD when sigma_0^2 + sigma_1^2 + sigma_2^2 > max_p * max_p
+					btScalar trPTP = (P[0].length2() + P[1].length2() + P[2].length2());
+					if (trPTP > max_p * max_p)
+					{
+						btMatrix3x3 U, V;
+						btVector3 sigma;
+						singularValueDecomposition(P, U, sigma, V);
+						sigma[0] = btMin(sigma[0], max_p);
+						sigma[1] = btMin(sigma[1], max_p);
+						sigma[2] = btMin(sigma[2], max_p);
+						sigma[0] = btMax(sigma[0], -max_p);
+						sigma[1] = btMax(sigma[1], -max_p);
+						sigma[2] = btMax(sigma[2], -max_p);
+						btMatrix3x3 Sigma;
+						Sigma.setIdentity();
+						Sigma[0][0] = sigma[0];
+						Sigma[1][1] = sigma[1];
+						Sigma[2][2] = sigma[2];
+						P = U * Sigma * V.transpose();
+					}
+				}
+#endif
+				//                btVector3 force_on_node0 = P * (tetra.m_Dm_inverse.transpose()*grad_N_hat_1st_col);
+				btMatrix3x3 force_on_node123 = P * tetra.m_Dm_inverse.transpose();
+				btVector3 force_on_node0 = force_on_node123 * grad_N_hat_1st_col;
+
+				btSoftBody::Node* node0 = tetra.m_n[0];
+				btSoftBody::Node* node1 = tetra.m_n[1];
+				btSoftBody::Node* node2 = tetra.m_n[2];
+				btSoftBody::Node* node3 = tetra.m_n[3];
+				size_t id0 = node0->index;
+				size_t id1 = node1->index;
+				size_t id2 = node2->index;
+				size_t id3 = node3->index;
+
+				// elastic force
+				btScalar scale1 = scale * tetra.m_element_measure;
+				force[id0] -= scale1 * force_on_node0;
+				force[id1] -= scale1 * force_on_node123.getColumn(0);
+				force[id2] -= scale1 * force_on_node123.getColumn(1);
+				force[id3] -= scale1 * force_on_node123.getColumn(2);
+			}
+		}
+	}
+
+	// The damping matrix is calculated using the time n state as described in https://www.math.ucla.edu/~jteran/papers/GSSJT15.pdf to allow line search
+	virtual void addScaledDampingForceDifferential(btScalar scale, const TVStack& dv, TVStack& df)
+	{
+		if (m_mu_damp == 0 && m_lambda_damp == 0)
+			return;
+		int numNodes = getNumNodes();
+		btAssert(numNodes <= df.size());
+		btVector3 grad_N_hat_1st_col = btVector3(-1, -1, -1);
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			btSoftBody* psb = m_softBodies[i];
+			if (!psb->isActive())
+			{
+				continue;
+			}
+			for (int j = 0; j < psb->m_tetras.size(); ++j)
+			{
+				btSoftBody::Tetra& tetra = psb->m_tetras[j];
+				btSoftBody::Node* node0 = tetra.m_n[0];
+				btSoftBody::Node* node1 = tetra.m_n[1];
+				btSoftBody::Node* node2 = tetra.m_n[2];
+				btSoftBody::Node* node3 = tetra.m_n[3];
+				size_t id0 = node0->index;
+				size_t id1 = node1->index;
+				size_t id2 = node2->index;
+				size_t id3 = node3->index;
+				btMatrix3x3 dF = Ds(id0, id1, id2, id3, dv) * tetra.m_Dm_inverse;
+				btMatrix3x3 I;
+				I.setIdentity();
+				btMatrix3x3 dP = (dF + dF.transpose()) * m_mu_damp + I * (dF[0][0] + dF[1][1] + dF[2][2]) * m_lambda_damp;
+				//                firstPiolaDampingDifferential(psb->m_tetraScratchesTn[j], dF, dP);
+				//                btVector3 df_on_node0 = dP * (tetra.m_Dm_inverse.transpose()*grad_N_hat_1st_col);
+				btMatrix3x3 df_on_node123 = dP * tetra.m_Dm_inverse.transpose();
+				btVector3 df_on_node0 = df_on_node123 * grad_N_hat_1st_col;
+
+				// damping force differential
+				btScalar scale1 = scale * tetra.m_element_measure;
+				df[id0] -= scale1 * df_on_node0;
+				df[id1] -= scale1 * df_on_node123.getColumn(0);
+				df[id2] -= scale1 * df_on_node123.getColumn(1);
+				df[id3] -= scale1 * df_on_node123.getColumn(2);
+			}
+		}
+	}
+
+	virtual void buildDampingForceDifferentialDiagonal(btScalar scale, TVStack& diagA) {}
+
+	virtual void addScaledElasticForceDifferential(btScalar scale, const TVStack& dx, TVStack& df)
+	{
+		int numNodes = getNumNodes();
+		btAssert(numNodes <= df.size());
+		btVector3 grad_N_hat_1st_col = btVector3(-1, -1, -1);
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			btSoftBody* psb = m_softBodies[i];
+			if (!psb->isActive())
+			{
+				continue;
+			}
+			for (int j = 0; j < psb->m_tetras.size(); ++j)
+			{
+				btSoftBody::Tetra& tetra = psb->m_tetras[j];
+				btSoftBody::Node* node0 = tetra.m_n[0];
+				btSoftBody::Node* node1 = tetra.m_n[1];
+				btSoftBody::Node* node2 = tetra.m_n[2];
+				btSoftBody::Node* node3 = tetra.m_n[3];
+				size_t id0 = node0->index;
+				size_t id1 = node1->index;
+				size_t id2 = node2->index;
+				size_t id3 = node3->index;
+				btMatrix3x3 dF = Ds(id0, id1, id2, id3, dx) * tetra.m_Dm_inverse;
+				btMatrix3x3 dP;
+				firstPiolaDifferential(psb->m_tetraScratches[j], dF, dP);
+				//                btVector3 df_on_node0 = dP * (tetra.m_Dm_inverse.transpose()*grad_N_hat_1st_col);
+				btMatrix3x3 df_on_node123 = dP * tetra.m_Dm_inverse.transpose();
+				btVector3 df_on_node0 = df_on_node123 * grad_N_hat_1st_col;
+
+				// elastic force differential
+				btScalar scale1 = scale * tetra.m_element_measure;
+				df[id0] -= scale1 * df_on_node0;
+				df[id1] -= scale1 * df_on_node123.getColumn(0);
+				df[id2] -= scale1 * df_on_node123.getColumn(1);
+				df[id3] -= scale1 * df_on_node123.getColumn(2);
+			}
+		}
+	}
+
+	void firstPiola(const btSoftBody::TetraScratch& s, btMatrix3x3& P)
+	{
+		btScalar c1 = (m_mu * (1. - 1. / (s.m_trace + 1.)));
+		btScalar c2 = (m_lambda * (s.m_J - 1.) - 0.75 * m_mu);
+		P = s.m_F * c1 + s.m_cofF * c2;
+	}
+
+	// Let P be the first piola stress.
+	// This function calculates the dP = dP/dF * dF
+	void firstPiolaDifferential(const btSoftBody::TetraScratch& s, const btMatrix3x3& dF, btMatrix3x3& dP)
+	{
+		btScalar c1 = m_mu * (1. - 1. / (s.m_trace + 1.));
+		btScalar c2 = (2. * m_mu) * DotProduct(s.m_F, dF) * (1. / ((1. + s.m_trace) * (1. + s.m_trace)));
+		btScalar c3 = (m_lambda * DotProduct(s.m_cofF, dF));
+		dP = dF * c1 + s.m_F * c2;
+		addScaledCofactorMatrixDifferential(s.m_F, dF, m_lambda * (s.m_J - 1.) - 0.75 * m_mu, dP);
+		dP += s.m_cofF * c3;
+	}
+
+	// Let Q be the damping stress.
+	// This function calculates the dP = dQ/dF * dF
+	void firstPiolaDampingDifferential(const btSoftBody::TetraScratch& s, const btMatrix3x3& dF, btMatrix3x3& dP)
+	{
+		btScalar c1 = (m_mu_damp * (1. - 1. / (s.m_trace + 1.)));
+		btScalar c2 = ((2. * m_mu_damp) * DotProduct(s.m_F, dF) * (1. / ((1. + s.m_trace) * (1. + s.m_trace))));
+		btScalar c3 = (m_lambda_damp * DotProduct(s.m_cofF, dF));
+		dP = dF * c1 + s.m_F * c2;
+		addScaledCofactorMatrixDifferential(s.m_F, dF, m_lambda_damp * (s.m_J - 1.) - 0.75 * m_mu_damp, dP);
+		dP += s.m_cofF * c3;
+	}
+
+	btScalar DotProduct(const btMatrix3x3& A, const btMatrix3x3& B)
+	{
+		btScalar ans = 0;
+		for (int i = 0; i < 3; ++i)
+		{
+			ans += A[i].dot(B[i]);
+		}
+		return ans;
+	}
+
+	// Let C(A) be the cofactor of the matrix A
+	// Let H = the derivative of C(A) with respect to A evaluated at F = A
+	// This function calculates H*dF
+	void addScaledCofactorMatrixDifferential(const btMatrix3x3& F, const btMatrix3x3& dF, btScalar scale, btMatrix3x3& M)
+	{
+		M[0][0] += scale * (dF[1][1] * F[2][2] + F[1][1] * dF[2][2] - dF[2][1] * F[1][2] - F[2][1] * dF[1][2]);
+		M[1][0] += scale * (dF[2][1] * F[0][2] + F[2][1] * dF[0][2] - dF[0][1] * F[2][2] - F[0][1] * dF[2][2]);
+		M[2][0] += scale * (dF[0][1] * F[1][2] + F[0][1] * dF[1][2] - dF[1][1] * F[0][2] - F[1][1] * dF[0][2]);
+		M[0][1] += scale * (dF[2][0] * F[1][2] + F[2][0] * dF[1][2] - dF[1][0] * F[2][2] - F[1][0] * dF[2][2]);
+		M[1][1] += scale * (dF[0][0] * F[2][2] + F[0][0] * dF[2][2] - dF[2][0] * F[0][2] - F[2][0] * dF[0][2]);
+		M[2][1] += scale * (dF[1][0] * F[0][2] + F[1][0] * dF[0][2] - dF[0][0] * F[1][2] - F[0][0] * dF[1][2]);
+		M[0][2] += scale * (dF[1][0] * F[2][1] + F[1][0] * dF[2][1] - dF[2][0] * F[1][1] - F[2][0] * dF[1][1]);
+		M[1][2] += scale * (dF[2][0] * F[0][1] + F[2][0] * dF[0][1] - dF[0][0] * F[2][1] - F[0][0] * dF[2][1]);
+		M[2][2] += scale * (dF[0][0] * F[1][1] + F[0][0] * dF[1][1] - dF[1][0] * F[0][1] - F[1][0] * dF[0][1]);
+	}
+
+	virtual btDeformableLagrangianForceType getForceType()
+	{
+		return BT_NEOHOOKEAN_FORCE;
+	}
+};
+#endif /* BT_NEOHOOKEAN_H */
diff --git a/engine/inc/bullet/BulletSoftBody/btKrylovSolver.h b/engine/inc/bullet/BulletSoftBody/btKrylovSolver.h
new file mode 100644
index 00000000..59126b47
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btKrylovSolver.h
@@ -0,0 +1,107 @@
+/*
+ Written by Xuchen Han <xuchenhan2015@u.northwestern.edu>
+ 
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef BT_KRYLOV_SOLVER_H
+#define BT_KRYLOV_SOLVER_H
+#include <iostream>
+#include <cmath>
+#include <limits>
+#include <LinearMath/btAlignedObjectArray.h>
+#include <LinearMath/btVector3.h>
+#include <LinearMath/btScalar.h>
+#include "LinearMath/btQuickprof.h"
+
+template <class MatrixX>
+class btKrylovSolver
+{
+	typedef btAlignedObjectArray<btVector3> TVStack;
+
+public:
+	int m_maxIterations;
+	btScalar m_tolerance;
+	btKrylovSolver(int maxIterations, btScalar tolerance)
+		: m_maxIterations(maxIterations), m_tolerance(tolerance)
+	{
+	}
+
+	virtual ~btKrylovSolver() {}
+
+	virtual int solve(MatrixX& A, TVStack& x, const TVStack& b, bool verbose = false) = 0;
+
+	virtual void reinitialize(const TVStack& b) = 0;
+
+	virtual SIMD_FORCE_INLINE TVStack sub(const TVStack& a, const TVStack& b)
+	{
+		// c = a-b
+		btAssert(a.size() == b.size());
+		TVStack c;
+		c.resize(a.size());
+		for (int i = 0; i < a.size(); ++i)
+		{
+			c[i] = a[i] - b[i];
+		}
+		return c;
+	}
+
+	virtual SIMD_FORCE_INLINE btScalar squaredNorm(const TVStack& a)
+	{
+		return dot(a, a);
+	}
+
+	virtual SIMD_FORCE_INLINE btScalar norm(const TVStack& a)
+	{
+		btScalar ret = 0;
+		for (int i = 0; i < a.size(); ++i)
+		{
+			for (int d = 0; d < 3; ++d)
+			{
+				ret = btMax(ret, btFabs(a[i][d]));
+			}
+		}
+		return ret;
+	}
+
+	virtual SIMD_FORCE_INLINE btScalar dot(const TVStack& a, const TVStack& b)
+	{
+		btScalar ans(0);
+		for (int i = 0; i < a.size(); ++i)
+			ans += a[i].dot(b[i]);
+		return ans;
+	}
+
+	virtual SIMD_FORCE_INLINE void multAndAddTo(btScalar s, const TVStack& a, TVStack& result)
+	{
+		//        result += s*a
+		btAssert(a.size() == result.size());
+		for (int i = 0; i < a.size(); ++i)
+			result[i] += s * a[i];
+	}
+
+	virtual SIMD_FORCE_INLINE TVStack multAndAdd(btScalar s, const TVStack& a, const TVStack& b)
+	{
+		// result = a*s + b
+		TVStack result;
+		result.resize(a.size());
+		for (int i = 0; i < a.size(); ++i)
+			result[i] = s * a[i] + b[i];
+		return result;
+	}
+
+	virtual SIMD_FORCE_INLINE void setTolerance(btScalar tolerance)
+	{
+		m_tolerance = tolerance;
+	}
+};
+#endif /* BT_KRYLOV_SOLVER_H */
diff --git a/engine/inc/bullet/BulletSoftBody/btPreconditioner.h b/engine/inc/bullet/BulletSoftBody/btPreconditioner.h
new file mode 100644
index 00000000..21c1106a
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btPreconditioner.h
@@ -0,0 +1,285 @@
+/*
+ Written by Xuchen Han <xuchenhan2015@u.northwestern.edu>
+ 
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef BT_PRECONDITIONER_H
+#define BT_PRECONDITIONER_H
+
+class Preconditioner
+{
+public:
+	typedef btAlignedObjectArray<btVector3> TVStack;
+	virtual void operator()(const TVStack& x, TVStack& b) = 0;
+	virtual void reinitialize(bool nodeUpdated) = 0;
+	virtual ~Preconditioner() {}
+};
+
+class DefaultPreconditioner : public Preconditioner
+{
+public:
+	virtual void operator()(const TVStack& x, TVStack& b)
+	{
+		btAssert(b.size() == x.size());
+		for (int i = 0; i < b.size(); ++i)
+			b[i] = x[i];
+	}
+	virtual void reinitialize(bool nodeUpdated)
+	{
+	}
+
+	virtual ~DefaultPreconditioner() {}
+};
+
+class MassPreconditioner : public Preconditioner
+{
+	btAlignedObjectArray<btScalar> m_inv_mass;
+	const btAlignedObjectArray<btSoftBody*>& m_softBodies;
+
+public:
+	MassPreconditioner(const btAlignedObjectArray<btSoftBody*>& softBodies)
+		: m_softBodies(softBodies)
+	{
+	}
+
+	virtual void reinitialize(bool nodeUpdated)
+	{
+		if (nodeUpdated)
+		{
+			m_inv_mass.clear();
+			for (int i = 0; i < m_softBodies.size(); ++i)
+			{
+				btSoftBody* psb = m_softBodies[i];
+				for (int j = 0; j < psb->m_nodes.size(); ++j)
+					m_inv_mass.push_back(psb->m_nodes[j].m_im);
+			}
+		}
+	}
+
+	virtual void operator()(const TVStack& x, TVStack& b)
+	{
+		btAssert(b.size() == x.size());
+		btAssert(m_inv_mass.size() <= x.size());
+		for (int i = 0; i < m_inv_mass.size(); ++i)
+		{
+			b[i] = x[i] * m_inv_mass[i];
+		}
+		for (int i = m_inv_mass.size(); i < b.size(); ++i)
+		{
+			b[i] = x[i];
+		}
+	}
+};
+
+class KKTPreconditioner : public Preconditioner
+{
+	const btAlignedObjectArray<btSoftBody*>& m_softBodies;
+	const btDeformableContactProjection& m_projections;
+	const btAlignedObjectArray<btDeformableLagrangianForce*>& m_lf;
+	TVStack m_inv_A, m_inv_S;
+	const btScalar& m_dt;
+	const bool& m_implicit;
+
+public:
+	KKTPreconditioner(const btAlignedObjectArray<btSoftBody*>& softBodies, const btDeformableContactProjection& projections, const btAlignedObjectArray<btDeformableLagrangianForce*>& lf, const btScalar& dt, const bool& implicit)
+		: m_softBodies(softBodies), m_projections(projections), m_lf(lf), m_dt(dt), m_implicit(implicit)
+	{
+	}
+
+	virtual void reinitialize(bool nodeUpdated)
+	{
+		if (nodeUpdated)
+		{
+			int num_nodes = 0;
+			for (int i = 0; i < m_softBodies.size(); ++i)
+			{
+				btSoftBody* psb = m_softBodies[i];
+				num_nodes += psb->m_nodes.size();
+			}
+			m_inv_A.resize(num_nodes);
+		}
+		buildDiagonalA(m_inv_A);
+		for (int i = 0; i < m_inv_A.size(); ++i)
+		{
+			//            printf("A[%d] = %f, %f, %f \n", i, m_inv_A[i][0], m_inv_A[i][1], m_inv_A[i][2]);
+			for (int d = 0; d < 3; ++d)
+			{
+				m_inv_A[i][d] = (m_inv_A[i][d] == 0) ? 0.0 : 1.0 / m_inv_A[i][d];
+			}
+		}
+		m_inv_S.resize(m_projections.m_lagrangeMultipliers.size());
+		//        printf("S.size() = %d \n", m_inv_S.size());
+		buildDiagonalS(m_inv_A, m_inv_S);
+		for (int i = 0; i < m_inv_S.size(); ++i)
+		{
+			//            printf("S[%d] = %f, %f, %f \n", i, m_inv_S[i][0], m_inv_S[i][1], m_inv_S[i][2]);
+			for (int d = 0; d < 3; ++d)
+			{
+				m_inv_S[i][d] = (m_inv_S[i][d] == 0) ? 0.0 : 1.0 / m_inv_S[i][d];
+			}
+		}
+	}
+
+	void buildDiagonalA(TVStack& diagA) const
+	{
+		size_t counter = 0;
+		for (int i = 0; i < m_softBodies.size(); ++i)
+		{
+			btSoftBody* psb = m_softBodies[i];
+			for (int j = 0; j < psb->m_nodes.size(); ++j)
+			{
+				const btSoftBody::Node& node = psb->m_nodes[j];
+				diagA[counter] = (node.m_im == 0) ? btVector3(0, 0, 0) : btVector3(1.0 / node.m_im, 1.0 / node.m_im, 1.0 / node.m_im);
+				++counter;
+			}
+		}
+		if (m_implicit)
+		{
+			printf("implicit not implemented\n");
+			btAssert(false);
+		}
+		for (int i = 0; i < m_lf.size(); ++i)
+		{
+			// add damping matrix
+			m_lf[i]->buildDampingForceDifferentialDiagonal(-m_dt, diagA);
+		}
+	}
+
+	void buildDiagonalS(const TVStack& inv_A, TVStack& diagS)
+	{
+		for (int c = 0; c < m_projections.m_lagrangeMultipliers.size(); ++c)
+		{
+			// S[k,k] = e_k^T * C A_d^-1 C^T * e_k
+			const LagrangeMultiplier& lm = m_projections.m_lagrangeMultipliers[c];
+			btVector3& t = diagS[c];
+			t.setZero();
+			for (int j = 0; j < lm.m_num_constraints; ++j)
+			{
+				for (int i = 0; i < lm.m_num_nodes; ++i)
+				{
+					for (int d = 0; d < 3; ++d)
+					{
+						t[j] += inv_A[lm.m_indices[i]][d] * lm.m_dirs[j][d] * lm.m_dirs[j][d] * lm.m_weights[i] * lm.m_weights[i];
+					}
+				}
+			}
+		}
+	}
+//#define USE_FULL_PRECONDITIONER
+#ifndef USE_FULL_PRECONDITIONER
+	virtual void operator()(const TVStack& x, TVStack& b)
+	{
+		btAssert(b.size() == x.size());
+		for (int i = 0; i < m_inv_A.size(); ++i)
+		{
+			b[i] = x[i] * m_inv_A[i];
+		}
+		int offset = m_inv_A.size();
+		for (int i = 0; i < m_inv_S.size(); ++i)
+		{
+			b[i + offset] = x[i + offset] * m_inv_S[i];
+		}
+	}
+#else
+	virtual void operator()(const TVStack& x, TVStack& b)
+	{
+		btAssert(b.size() == x.size());
+		int offset = m_inv_A.size();
+
+		for (int i = 0; i < m_inv_A.size(); ++i)
+		{
+			b[i] = x[i] * m_inv_A[i];
+		}
+
+		for (int i = 0; i < m_inv_S.size(); ++i)
+		{
+			b[i + offset].setZero();
+		}
+
+		for (int c = 0; c < m_projections.m_lagrangeMultipliers.size(); ++c)
+		{
+			const LagrangeMultiplier& lm = m_projections.m_lagrangeMultipliers[c];
+			// C * x
+			for (int d = 0; d < lm.m_num_constraints; ++d)
+			{
+				for (int i = 0; i < lm.m_num_nodes; ++i)
+				{
+					b[offset + c][d] += lm.m_weights[i] * b[lm.m_indices[i]].dot(lm.m_dirs[d]);
+				}
+			}
+		}
+
+		for (int i = 0; i < m_inv_S.size(); ++i)
+		{
+			b[i + offset] = b[i + offset] * m_inv_S[i];
+		}
+
+		for (int i = 0; i < m_inv_A.size(); ++i)
+		{
+			b[i].setZero();
+		}
+
+		for (int c = 0; c < m_projections.m_lagrangeMultipliers.size(); ++c)
+		{
+			// C^T * lambda
+			const LagrangeMultiplier& lm = m_projections.m_lagrangeMultipliers[c];
+			for (int i = 0; i < lm.m_num_nodes; ++i)
+			{
+				for (int j = 0; j < lm.m_num_constraints; ++j)
+				{
+					b[lm.m_indices[i]] += b[offset + c][j] * lm.m_weights[i] * lm.m_dirs[j];
+				}
+			}
+		}
+
+		for (int i = 0; i < m_inv_A.size(); ++i)
+		{
+			b[i] = (x[i] - b[i]) * m_inv_A[i];
+		}
+
+		TVStack t;
+		t.resize(b.size());
+		for (int i = 0; i < m_inv_S.size(); ++i)
+		{
+			t[i + offset] = x[i + offset] * m_inv_S[i];
+		}
+		for (int i = 0; i < m_inv_A.size(); ++i)
+		{
+			t[i].setZero();
+		}
+		for (int c = 0; c < m_projections.m_lagrangeMultipliers.size(); ++c)
+		{
+			// C^T * lambda
+			const LagrangeMultiplier& lm = m_projections.m_lagrangeMultipliers[c];
+			for (int i = 0; i < lm.m_num_nodes; ++i)
+			{
+				for (int j = 0; j < lm.m_num_constraints; ++j)
+				{
+					t[lm.m_indices[i]] += t[offset + c][j] * lm.m_weights[i] * lm.m_dirs[j];
+				}
+			}
+		}
+		for (int i = 0; i < m_inv_A.size(); ++i)
+		{
+			b[i] += t[i] * m_inv_A[i];
+		}
+
+		for (int i = 0; i < m_inv_S.size(); ++i)
+		{
+			b[i + offset] -= x[i + offset] * m_inv_S[i];
+		}
+	}
+#endif
+};
+
+#endif /* BT_PRECONDITIONER_H */
diff --git a/engine/inc/bullet/BulletSoftBody/btSoftBody.h b/engine/inc/bullet/BulletSoftBody/btSoftBody.h
new file mode 100644
index 00000000..f578487b
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btSoftBody.h
@@ -0,0 +1,1394 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+///btSoftBody implementation by Nathanael Presson
+
+#ifndef _BT_SOFT_BODY_H
+#define _BT_SOFT_BODY_H
+
+#include "LinearMath/btAlignedObjectArray.h"
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btIDebugDraw.h"
+#include "LinearMath/btVector3.h"
+#include "BulletDynamics/Dynamics/btRigidBody.h"
+
+#include "BulletCollision/CollisionShapes/btConcaveShape.h"
+#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
+#include "btSparseSDF.h"
+#include "BulletCollision/BroadphaseCollision/btDbvt.h"
+#include "BulletDynamics/Featherstone/btMultiBodyLinkCollider.h"
+#include "BulletDynamics/Featherstone/btMultiBodyConstraint.h"
+//#ifdef BT_USE_DOUBLE_PRECISION
+//#define btRigidBodyData	btRigidBodyDoubleData
+//#define btRigidBodyDataName	"btRigidBodyDoubleData"
+//#else
+#define btSoftBodyData btSoftBodyFloatData
+#define btSoftBodyDataName "btSoftBodyFloatData"
+static const btScalar OVERLAP_REDUCTION_FACTOR = 0.1;
+static unsigned long seed = 243703;
+//#endif //BT_USE_DOUBLE_PRECISION
+
+class btBroadphaseInterface;
+class btDispatcher;
+class btSoftBodySolver;
+
+/* btSoftBodyWorldInfo	*/
+struct btSoftBodyWorldInfo
+{
+	btScalar air_density;
+	btScalar water_density;
+	btScalar water_offset;
+	btScalar m_maxDisplacement;
+	btVector3 water_normal;
+	btBroadphaseInterface* m_broadphase;
+	btDispatcher* m_dispatcher;
+	btVector3 m_gravity;
+	btSparseSdf<3> m_sparsesdf;
+
+	btSoftBodyWorldInfo()
+		: air_density((btScalar)1.2),
+		  water_density(0),
+		  water_offset(0),
+		  m_maxDisplacement(1000.f),  //avoid soft body from 'exploding' so use some upper threshold of maximum motion that a node can travel per frame
+		  water_normal(0, 0, 0),
+		  m_broadphase(0),
+		  m_dispatcher(0),
+		  m_gravity(0, -10, 0)
+	{
+	}
+};
+
+///The btSoftBody is an class to simulate cloth and volumetric soft bodies.
+///There is two-way interaction between btSoftBody and btRigidBody/btCollisionObject.
+class btSoftBody : public btCollisionObject
+{
+public:
+	btAlignedObjectArray<const class btCollisionObject*> m_collisionDisabledObjects;
+
+	// The solver object that handles this soft body
+	btSoftBodySolver* m_softBodySolver;
+
+	//
+	// Enumerations
+	//
+
+	///eAeroModel
+	struct eAeroModel
+	{
+		enum _
+		{
+			V_Point,             ///Vertex normals are oriented toward velocity
+			V_TwoSided,          ///Vertex normals are flipped to match velocity
+			V_TwoSidedLiftDrag,  ///Vertex normals are flipped to match velocity and lift and drag forces are applied
+			V_OneSided,          ///Vertex normals are taken as it is
+			F_TwoSided,          ///Face normals are flipped to match velocity
+			F_TwoSidedLiftDrag,  ///Face normals are flipped to match velocity and lift and drag forces are applied
+			F_OneSided,          ///Face normals are taken as it is
+			END
+		};
+	};
+
+	///eVSolver : velocities solvers
+	struct eVSolver
+	{
+		enum _
+		{
+			Linear,  ///Linear solver
+			END
+		};
+	};
+
+	///ePSolver : positions solvers
+	struct ePSolver
+	{
+		enum _
+		{
+			Linear,     ///Linear solver
+			Anchors,    ///Anchor solver
+			RContacts,  ///Rigid contacts solver
+			SContacts,  ///Soft contacts solver
+			END
+		};
+	};
+
+	///eSolverPresets
+	struct eSolverPresets
+	{
+		enum _
+		{
+			Positions,
+			Velocities,
+			Default = Positions,
+			END
+		};
+	};
+
+	///eFeature
+	struct eFeature
+	{
+		enum _
+		{
+			None,
+			Node,
+			Link,
+			Face,
+			Tetra,
+			END
+		};
+	};
+
+	typedef btAlignedObjectArray<eVSolver::_> tVSolverArray;
+	typedef btAlignedObjectArray<ePSolver::_> tPSolverArray;
+
+	//
+	// Flags
+	//
+
+	///fCollision
+	struct fCollision
+	{
+		enum _
+		{
+			RVSmask = 0x000f,  ///Rigid versus soft mask
+			SDF_RS = 0x0001,   ///SDF based rigid vs soft
+			CL_RS = 0x0002,    ///Cluster vs convex rigid vs soft
+			SDF_RD = 0x0004,   ///rigid vs deformable
+
+			SVSmask = 0x00f0,  ///Rigid versus soft mask
+			VF_SS = 0x0010,    ///Vertex vs face soft vs soft handling
+			CL_SS = 0x0020,    ///Cluster vs cluster soft vs soft handling
+			CL_SELF = 0x0040,  ///Cluster soft body self collision
+			VF_DD = 0x0080,    ///Vertex vs face soft vs soft handling
+
+			RVDFmask = 0x0f00,  /// Rigid versus deformable face mask
+			SDF_RDF = 0x0100,   /// GJK based Rigid vs. deformable face
+			SDF_MDF = 0x0200,   /// GJK based Multibody vs. deformable face
+			SDF_RDN = 0x0400,   /// SDF based Rigid vs. deformable node
+			/* presets	*/
+			Default = SDF_RS,
+			END
+		};
+	};
+
+	///fMaterial
+	struct fMaterial
+	{
+		enum _
+		{
+			DebugDraw = 0x0001,  /// Enable debug draw
+			/* presets	*/
+			Default = DebugDraw,
+			END
+		};
+	};
+
+	//
+	// API Types
+	//
+
+	/* sRayCast		*/
+	struct sRayCast
+	{
+		btSoftBody* body;     /// soft body
+		eFeature::_ feature;  /// feature type
+		int index;            /// feature index
+		btScalar fraction;    /// time of impact fraction (rayorg+(rayto-rayfrom)*fraction)
+	};
+
+	/* ImplicitFn	*/
+	struct ImplicitFn
+	{
+		virtual ~ImplicitFn() {}
+		virtual btScalar Eval(const btVector3& x) = 0;
+	};
+
+	//
+	// Internal types
+	//
+
+	typedef btAlignedObjectArray<btScalar> tScalarArray;
+	typedef btAlignedObjectArray<btVector3> tVector3Array;
+
+	/* sCti is Softbody contact info	*/
+	struct sCti
+	{
+		const btCollisionObject* m_colObj; /* Rigid body			*/
+		btVector3 m_normal;                /* Outward normal		*/
+		btScalar m_offset;                 /* Offset from origin	*/
+		btVector3 m_bary;                  /* Barycentric weights for faces */
+	};
+
+	/* sMedium		*/
+	struct sMedium
+	{
+		btVector3 m_velocity; /* Velocity				*/
+		btScalar m_pressure;  /* Pressure				*/
+		btScalar m_density;   /* Density				*/
+	};
+
+	/* Base type	*/
+	struct Element
+	{
+		void* m_tag;  // User data
+		Element() : m_tag(0) {}
+	};
+	/* Material		*/
+	struct Material : Element
+	{
+		btScalar m_kLST;  // Linear stiffness coefficient [0,1]
+		btScalar m_kAST;  // Area/Angular stiffness coefficient [0,1]
+		btScalar m_kVST;  // Volume stiffness coefficient [0,1]
+		int m_flags;      // Flags
+	};
+
+	/* Feature		*/
+	struct Feature : Element
+	{
+		Material* m_material;  // Material
+	};
+	/* Node			*/
+	struct RenderNode
+	{
+		btVector3 m_x;
+		btVector3 m_uv1;
+		btVector3 m_normal;
+	};
+	struct Node : Feature
+	{
+		btVector3 m_x;       // Position
+		btVector3 m_q;       // Previous step position/Test position
+		btVector3 m_v;       // Velocity
+		btVector3 m_vn;      // Previous step velocity
+		btVector3 m_f;       // Force accumulator
+		btVector3 m_n;       // Normal
+		btScalar m_im;       // 1/mass
+		btScalar m_area;     // Area
+		btDbvtNode* m_leaf;  // Leaf data
+		int m_constrained;   // depth of penetration
+		int m_battach : 1;   // Attached
+		int index;
+		btVector3 m_splitv;               // velocity associated with split impulse
+		btMatrix3x3 m_effectiveMass;      // effective mass in contact
+		btMatrix3x3 m_effectiveMass_inv;  // inverse of effective mass
+	};
+	/* Link			*/
+	ATTRIBUTE_ALIGNED16(struct)
+	Link : Feature
+	{
+		btVector3 m_c3;      // gradient
+		Node* m_n[2];        // Node pointers
+		btScalar m_rl;       // Rest length
+		int m_bbending : 1;  // Bending link
+		btScalar m_c0;       // (ima+imb)*kLST
+		btScalar m_c1;       // rl^2
+		btScalar m_c2;       // |gradient|^2/c0
+
+		BT_DECLARE_ALIGNED_ALLOCATOR();
+	};
+	struct RenderFace
+	{
+		RenderNode* m_n[3];          // Node pointers
+	};
+
+	/* Face			*/
+	struct Face : Feature
+	{
+		Node* m_n[3];          // Node pointers
+		btVector3 m_normal;    // Normal
+		btScalar m_ra;         // Rest area
+		btDbvtNode* m_leaf;    // Leaf data
+		btVector4 m_pcontact;  // barycentric weights of the persistent contact
+		btVector3 m_n0, m_n1, m_vn;
+		int m_index;
+	};
+	/* Tetra		*/
+	struct Tetra : Feature
+	{
+		Node* m_n[4];              // Node pointers
+		btScalar m_rv;             // Rest volume
+		btDbvtNode* m_leaf;        // Leaf data
+		btVector3 m_c0[4];         // gradients
+		btScalar m_c1;             // (4*kVST)/(im0+im1+im2+im3)
+		btScalar m_c2;             // m_c1/sum(|g0..3|^2)
+		btMatrix3x3 m_Dm_inverse;  // rest Dm^-1
+		btMatrix3x3 m_F;
+		btScalar m_element_measure;
+		btVector4 m_P_inv[3];  // first three columns of P_inv matrix
+	};
+
+	/*  TetraScratch  */
+	struct TetraScratch
+	{
+		btMatrix3x3 m_F;           // deformation gradient F
+		btScalar m_trace;          // trace of F^T * F
+		btScalar m_J;              // det(F)
+		btMatrix3x3 m_cofF;        // cofactor of F
+		btMatrix3x3 m_corotation;  // corotatio of the tetra
+	};
+
+	/* RContact		*/
+	struct RContact
+	{
+		sCti m_cti;        // Contact infos
+		Node* m_node;      // Owner node
+		btMatrix3x3 m_c0;  // Impulse matrix
+		btVector3 m_c1;    // Relative anchor
+		btScalar m_c2;     // ima*dt
+		btScalar m_c3;     // Friction
+		btScalar m_c4;     // Hardness
+
+		// jacobians and unit impulse responses for multibody
+		btMultiBodyJacobianData jacobianData_normal;
+		btMultiBodyJacobianData jacobianData_t1;
+		btMultiBodyJacobianData jacobianData_t2;
+		btVector3 t1;
+		btVector3 t2;
+	};
+
+	class DeformableRigidContact
+	{
+	public:
+		sCti m_cti;        // Contact infos
+		btMatrix3x3 m_c0;  // Impulse matrix
+		btVector3 m_c1;    // Relative anchor
+		btScalar m_c2;     // inverse mass of node/face
+		btScalar m_c3;     // Friction
+		btScalar m_c4;     // Hardness
+		btMatrix3x3 m_c5;  // inverse effective mass
+
+		// jacobians and unit impulse responses for multibody
+		btMultiBodyJacobianData jacobianData_normal;
+		btMultiBodyJacobianData jacobianData_t1;
+		btMultiBodyJacobianData jacobianData_t2;
+		btVector3 t1;
+		btVector3 t2;
+	};
+
+	class DeformableNodeRigidContact : public DeformableRigidContact
+	{
+	public:
+		Node* m_node;  // Owner node
+	};
+
+	class DeformableNodeRigidAnchor : public DeformableNodeRigidContact
+	{
+	public:
+		btVector3 m_local;  // Anchor position in body space
+	};
+
+	class DeformableFaceRigidContact : public DeformableRigidContact
+	{
+	public:
+		Face* m_face;              // Owner face
+		btVector3 m_contactPoint;  // Contact point
+		btVector3 m_bary;          // Barycentric weights
+		btVector3 m_weights;       // v_contactPoint * m_weights[i] = m_face->m_node[i]->m_v;
+	};
+
+	struct DeformableFaceNodeContact
+	{
+		Node* m_node;         // Node
+		Face* m_face;         // Face
+		btVector3 m_bary;     // Barycentric weights
+		btVector3 m_weights;  // v_contactPoint * m_weights[i] = m_face->m_node[i]->m_v;
+		btVector3 m_normal;   // Normal
+		btScalar m_margin;    // Margin
+		btScalar m_friction;  // Friction
+		btScalar m_imf;       // inverse mass of the face at contact point
+		btScalar m_c0;        // scale of the impulse matrix;
+	};
+
+	/* SContact		*/
+	struct SContact
+	{
+		Node* m_node;         // Node
+		Face* m_face;         // Face
+		btVector3 m_weights;  // Weigths
+		btVector3 m_normal;   // Normal
+		btScalar m_margin;    // Margin
+		btScalar m_friction;  // Friction
+		btScalar m_cfm[2];    // Constraint force mixing
+	};
+	/* Anchor		*/
+	struct Anchor
+	{
+		Node* m_node;         // Node pointer
+		btVector3 m_local;    // Anchor position in body space
+		btRigidBody* m_body;  // Body
+		btScalar m_influence;
+		btMatrix3x3 m_c0;  // Impulse matrix
+		btVector3 m_c1;    // Relative anchor
+		btScalar m_c2;     // ima*dt
+	};
+	/* Note			*/
+	struct Note : Element
+	{
+		const char* m_text;    // Text
+		btVector3 m_offset;    // Offset
+		int m_rank;            // Rank
+		Node* m_nodes[4];      // Nodes
+		btScalar m_coords[4];  // Coordinates
+	};
+	/* Pose			*/
+	struct Pose
+	{
+		bool m_bvolume;       // Is valid
+		bool m_bframe;        // Is frame
+		btScalar m_volume;    // Rest volume
+		tVector3Array m_pos;  // Reference positions
+		tScalarArray m_wgh;   // Weights
+		btVector3 m_com;      // COM
+		btMatrix3x3 m_rot;    // Rotation
+		btMatrix3x3 m_scl;    // Scale
+		btMatrix3x3 m_aqq;    // Base scaling
+	};
+	/* Cluster		*/
+	struct Cluster
+	{
+		tScalarArray m_masses;
+		btAlignedObjectArray<Node*> m_nodes;
+		tVector3Array m_framerefs;
+		btTransform m_framexform;
+		btScalar m_idmass;
+		btScalar m_imass;
+		btMatrix3x3 m_locii;
+		btMatrix3x3 m_invwi;
+		btVector3 m_com;
+		btVector3 m_vimpulses[2];
+		btVector3 m_dimpulses[2];
+		int m_nvimpulses;
+		int m_ndimpulses;
+		btVector3 m_lv;
+		btVector3 m_av;
+		btDbvtNode* m_leaf;
+		btScalar m_ndamping; /* Node damping		*/
+		btScalar m_ldamping; /* Linear damping	*/
+		btScalar m_adamping; /* Angular damping	*/
+		btScalar m_matching;
+		btScalar m_maxSelfCollisionImpulse;
+		btScalar m_selfCollisionImpulseFactor;
+		bool m_containsAnchor;
+		bool m_collide;
+		int m_clusterIndex;
+		Cluster() : m_leaf(0), m_ndamping(0), m_ldamping(0), m_adamping(0), m_matching(0), m_maxSelfCollisionImpulse(100.f), m_selfCollisionImpulseFactor(0.01f), m_containsAnchor(false)
+		{
+		}
+	};
+	/* Impulse		*/
+	struct Impulse
+	{
+		btVector3 m_velocity;
+		btVector3 m_drift;
+		int m_asVelocity : 1;
+		int m_asDrift : 1;
+		Impulse() : m_velocity(0, 0, 0), m_drift(0, 0, 0), m_asVelocity(0), m_asDrift(0) {}
+		Impulse operator-() const
+		{
+			Impulse i = *this;
+			i.m_velocity = -i.m_velocity;
+			i.m_drift = -i.m_drift;
+			return (i);
+		}
+		Impulse operator*(btScalar x) const
+		{
+			Impulse i = *this;
+			i.m_velocity *= x;
+			i.m_drift *= x;
+			return (i);
+		}
+	};
+	/* Body			*/
+	struct Body
+	{
+		Cluster* m_soft;
+		btRigidBody* m_rigid;
+		const btCollisionObject* m_collisionObject;
+
+		Body() : m_soft(0), m_rigid(0), m_collisionObject(0) {}
+		Body(Cluster* p) : m_soft(p), m_rigid(0), m_collisionObject(0) {}
+		Body(const btCollisionObject* colObj) : m_soft(0), m_collisionObject(colObj)
+		{
+			m_rigid = (btRigidBody*)btRigidBody::upcast(m_collisionObject);
+		}
+
+		void activate() const
+		{
+			if (m_rigid)
+				m_rigid->activate();
+			if (m_collisionObject)
+				m_collisionObject->activate();
+		}
+		const btMatrix3x3& invWorldInertia() const
+		{
+			static const btMatrix3x3 iwi(0, 0, 0, 0, 0, 0, 0, 0, 0);
+			if (m_rigid) return (m_rigid->getInvInertiaTensorWorld());
+			if (m_soft) return (m_soft->m_invwi);
+			return (iwi);
+		}
+		btScalar invMass() const
+		{
+			if (m_rigid) return (m_rigid->getInvMass());
+			if (m_soft) return (m_soft->m_imass);
+			return (0);
+		}
+		const btTransform& xform() const
+		{
+			static const btTransform identity = btTransform::getIdentity();
+			if (m_collisionObject) return (m_collisionObject->getWorldTransform());
+			if (m_soft) return (m_soft->m_framexform);
+			return (identity);
+		}
+		btVector3 linearVelocity() const
+		{
+			if (m_rigid) return (m_rigid->getLinearVelocity());
+			if (m_soft) return (m_soft->m_lv);
+			return (btVector3(0, 0, 0));
+		}
+		btVector3 angularVelocity(const btVector3& rpos) const
+		{
+			if (m_rigid) return (btCross(m_rigid->getAngularVelocity(), rpos));
+			if (m_soft) return (btCross(m_soft->m_av, rpos));
+			return (btVector3(0, 0, 0));
+		}
+		btVector3 angularVelocity() const
+		{
+			if (m_rigid) return (m_rigid->getAngularVelocity());
+			if (m_soft) return (m_soft->m_av);
+			return (btVector3(0, 0, 0));
+		}
+		btVector3 velocity(const btVector3& rpos) const
+		{
+			return (linearVelocity() + angularVelocity(rpos));
+		}
+		void applyVImpulse(const btVector3& impulse, const btVector3& rpos) const
+		{
+			if (m_rigid) m_rigid->applyImpulse(impulse, rpos);
+			if (m_soft) btSoftBody::clusterVImpulse(m_soft, rpos, impulse);
+		}
+		void applyDImpulse(const btVector3& impulse, const btVector3& rpos) const
+		{
+			if (m_rigid) m_rigid->applyImpulse(impulse, rpos);
+			if (m_soft) btSoftBody::clusterDImpulse(m_soft, rpos, impulse);
+		}
+		void applyImpulse(const Impulse& impulse, const btVector3& rpos) const
+		{
+			if (impulse.m_asVelocity)
+			{
+				//				printf("impulse.m_velocity = %f,%f,%f\n",impulse.m_velocity.getX(),impulse.m_velocity.getY(),impulse.m_velocity.getZ());
+				applyVImpulse(impulse.m_velocity, rpos);
+			}
+			if (impulse.m_asDrift)
+			{
+				//				printf("impulse.m_drift = %f,%f,%f\n",impulse.m_drift.getX(),impulse.m_drift.getY(),impulse.m_drift.getZ());
+				applyDImpulse(impulse.m_drift, rpos);
+			}
+		}
+		void applyVAImpulse(const btVector3& impulse) const
+		{
+			if (m_rigid) m_rigid->applyTorqueImpulse(impulse);
+			if (m_soft) btSoftBody::clusterVAImpulse(m_soft, impulse);
+		}
+		void applyDAImpulse(const btVector3& impulse) const
+		{
+			if (m_rigid) m_rigid->applyTorqueImpulse(impulse);
+			if (m_soft) btSoftBody::clusterDAImpulse(m_soft, impulse);
+		}
+		void applyAImpulse(const Impulse& impulse) const
+		{
+			if (impulse.m_asVelocity) applyVAImpulse(impulse.m_velocity);
+			if (impulse.m_asDrift) applyDAImpulse(impulse.m_drift);
+		}
+		void applyDCImpulse(const btVector3& impulse) const
+		{
+			if (m_rigid) m_rigid->applyCentralImpulse(impulse);
+			if (m_soft) btSoftBody::clusterDCImpulse(m_soft, impulse);
+		}
+	};
+	/* Joint		*/
+	struct Joint
+	{
+		struct eType
+		{
+			enum _
+			{
+				Linear = 0,
+				Angular,
+				Contact
+			};
+		};
+		struct Specs
+		{
+			Specs() : erp(1), cfm(1), split(1) {}
+			btScalar erp;
+			btScalar cfm;
+			btScalar split;
+		};
+		Body m_bodies[2];
+		btVector3 m_refs[2];
+		btScalar m_cfm;
+		btScalar m_erp;
+		btScalar m_split;
+		btVector3 m_drift;
+		btVector3 m_sdrift;
+		btMatrix3x3 m_massmatrix;
+		bool m_delete;
+		virtual ~Joint() {}
+		Joint() : m_delete(false) {}
+		virtual void Prepare(btScalar dt, int iterations);
+		virtual void Solve(btScalar dt, btScalar sor) = 0;
+		virtual void Terminate(btScalar dt) = 0;
+		virtual eType::_ Type() const = 0;
+	};
+	/* LJoint		*/
+	struct LJoint : Joint
+	{
+		struct Specs : Joint::Specs
+		{
+			btVector3 position;
+		};
+		btVector3 m_rpos[2];
+		void Prepare(btScalar dt, int iterations);
+		void Solve(btScalar dt, btScalar sor);
+		void Terminate(btScalar dt);
+		eType::_ Type() const { return (eType::Linear); }
+	};
+	/* AJoint		*/
+	struct AJoint : Joint
+	{
+		struct IControl
+		{
+			virtual ~IControl() {}
+			virtual void Prepare(AJoint*) {}
+			virtual btScalar Speed(AJoint*, btScalar current) { return (current); }
+			static IControl* Default()
+			{
+				static IControl def;
+				return (&def);
+			}
+		};
+		struct Specs : Joint::Specs
+		{
+			Specs() : icontrol(IControl::Default()) {}
+			btVector3 axis;
+			IControl* icontrol;
+		};
+		btVector3 m_axis[2];
+		IControl* m_icontrol;
+		void Prepare(btScalar dt, int iterations);
+		void Solve(btScalar dt, btScalar sor);
+		void Terminate(btScalar dt);
+		eType::_ Type() const { return (eType::Angular); }
+	};
+	/* CJoint		*/
+	struct CJoint : Joint
+	{
+		int m_life;
+		int m_maxlife;
+		btVector3 m_rpos[2];
+		btVector3 m_normal;
+		btScalar m_friction;
+		void Prepare(btScalar dt, int iterations);
+		void Solve(btScalar dt, btScalar sor);
+		void Terminate(btScalar dt);
+		eType::_ Type() const { return (eType::Contact); }
+	};
+	/* Config		*/
+	struct Config
+	{
+		eAeroModel::_ aeromodel;    // Aerodynamic model (default: V_Point)
+		btScalar kVCF;              // Velocities correction factor (Baumgarte)
+		btScalar kDP;               // Damping coefficient [0,1]
+		btScalar kDG;               // Drag coefficient [0,+inf]
+		btScalar kLF;               // Lift coefficient [0,+inf]
+		btScalar kPR;               // Pressure coefficient [-inf,+inf]
+		btScalar kVC;               // Volume conversation coefficient [0,+inf]
+		btScalar kDF;               // Dynamic friction coefficient [0,1]
+		btScalar kMT;               // Pose matching coefficient [0,1]
+		btScalar kCHR;              // Rigid contacts hardness [0,1]
+		btScalar kKHR;              // Kinetic contacts hardness [0,1]
+		btScalar kSHR;              // Soft contacts hardness [0,1]
+		btScalar kAHR;              // Anchors hardness [0,1]
+		btScalar kSRHR_CL;          // Soft vs rigid hardness [0,1] (cluster only)
+		btScalar kSKHR_CL;          // Soft vs kinetic hardness [0,1] (cluster only)
+		btScalar kSSHR_CL;          // Soft vs soft hardness [0,1] (cluster only)
+		btScalar kSR_SPLT_CL;       // Soft vs rigid impulse split [0,1] (cluster only)
+		btScalar kSK_SPLT_CL;       // Soft vs rigid impulse split [0,1] (cluster only)
+		btScalar kSS_SPLT_CL;       // Soft vs rigid impulse split [0,1] (cluster only)
+		btScalar maxvolume;         // Maximum volume ratio for pose
+		btScalar timescale;         // Time scale
+		int viterations;            // Velocities solver iterations
+		int piterations;            // Positions solver iterations
+		int diterations;            // Drift solver iterations
+		int citerations;            // Cluster solver iterations
+		int collisions;             // Collisions flags
+		tVSolverArray m_vsequence;  // Velocity solvers sequence
+		tPSolverArray m_psequence;  // Position solvers sequence
+		tPSolverArray m_dsequence;  // Drift solvers sequence
+		btScalar drag;              // deformable air drag
+		btScalar m_maxStress;       // Maximum principle first Piola stress
+	};
+	/* SolverState	*/
+	struct SolverState
+	{
+		//if you add new variables, always initialize them!
+		SolverState()
+			: sdt(0),
+			  isdt(0),
+			  velmrg(0),
+			  radmrg(0),
+			  updmrg(0)
+		{
+		}
+		btScalar sdt;     // dt*timescale
+		btScalar isdt;    // 1/sdt
+		btScalar velmrg;  // velocity margin
+		btScalar radmrg;  // radial margin
+		btScalar updmrg;  // Update margin
+	};
+	/// RayFromToCaster takes a ray from, ray to (instead of direction!)
+	struct RayFromToCaster : btDbvt::ICollide
+	{
+		btVector3 m_rayFrom;
+		btVector3 m_rayTo;
+		btVector3 m_rayNormalizedDirection;
+		btScalar m_mint;
+		Face* m_face;
+		int m_tests;
+		RayFromToCaster(const btVector3& rayFrom, const btVector3& rayTo, btScalar mxt);
+		void Process(const btDbvtNode* leaf);
+
+		static /*inline*/ btScalar rayFromToTriangle(const btVector3& rayFrom,
+													 const btVector3& rayTo,
+													 const btVector3& rayNormalizedDirection,
+													 const btVector3& a,
+													 const btVector3& b,
+													 const btVector3& c,
+													 btScalar maxt = SIMD_INFINITY);
+	};
+
+	//
+	// Typedefs
+	//
+
+	typedef void (*psolver_t)(btSoftBody*, btScalar, btScalar);
+	typedef void (*vsolver_t)(btSoftBody*, btScalar);
+	typedef btAlignedObjectArray<Cluster*> tClusterArray;
+	typedef btAlignedObjectArray<Note> tNoteArray;
+	typedef btAlignedObjectArray<Node> tNodeArray;
+	typedef btAlignedObjectArray< RenderNode> tRenderNodeArray;
+	typedef btAlignedObjectArray<btDbvtNode*> tLeafArray;
+	typedef btAlignedObjectArray<Link> tLinkArray;
+	typedef btAlignedObjectArray<Face> tFaceArray;
+	typedef btAlignedObjectArray<RenderFace> tRenderFaceArray;
+	typedef btAlignedObjectArray<Tetra> tTetraArray;
+	typedef btAlignedObjectArray<Anchor> tAnchorArray;
+	typedef btAlignedObjectArray<RContact> tRContactArray;
+	typedef btAlignedObjectArray<SContact> tSContactArray;
+	typedef btAlignedObjectArray<Material*> tMaterialArray;
+	typedef btAlignedObjectArray<Joint*> tJointArray;
+	typedef btAlignedObjectArray<btSoftBody*> tSoftBodyArray;
+
+	//
+	// Fields
+	//
+
+	Config m_cfg;                      // Configuration
+	SolverState m_sst;                 // Solver state
+	Pose m_pose;                       // Pose
+	void* m_tag;                       // User data
+	btSoftBodyWorldInfo* m_worldInfo;  // World info
+	tNoteArray m_notes;                // Notes
+	tNodeArray m_nodes;                // Nodes
+	tRenderNodeArray m_renderNodes;    // Render Nodes
+	tLinkArray m_links;                // Links
+	tFaceArray m_faces;                // Faces
+	tRenderFaceArray m_renderFaces;          // Faces
+	tTetraArray m_tetras;              // Tetras
+	btAlignedObjectArray<TetraScratch> m_tetraScratches;
+	btAlignedObjectArray<TetraScratch> m_tetraScratchesTn;
+	tAnchorArray m_anchors;  // Anchors
+	btAlignedObjectArray<DeformableNodeRigidAnchor> m_deformableAnchors;
+	tRContactArray m_rcontacts;  // Rigid contacts
+	btAlignedObjectArray<DeformableNodeRigidContact> m_nodeRigidContacts;
+	btAlignedObjectArray<DeformableFaceNodeContact> m_faceNodeContacts;
+	btAlignedObjectArray<DeformableFaceRigidContact> m_faceRigidContacts;
+	tSContactArray m_scontacts;     // Soft contacts
+	tJointArray m_joints;           // Joints
+	tMaterialArray m_materials;     // Materials
+	btScalar m_timeacc;             // Time accumulator
+	btVector3 m_bounds[2];          // Spatial bounds
+	bool m_bUpdateRtCst;            // Update runtime constants
+	btDbvt m_ndbvt;                 // Nodes tree
+	btDbvt m_fdbvt;                 // Faces tree
+	btDbvntNode* m_fdbvnt;          // Faces tree with normals
+	btDbvt m_cdbvt;                 // Clusters tree
+	tClusterArray m_clusters;       // Clusters
+	btScalar m_dampingCoefficient;  // Damping Coefficient
+	btScalar m_sleepingThreshold;
+	btScalar m_maxSpeedSquared;
+	btAlignedObjectArray<btVector3> m_quads;  // quadrature points for collision detection
+	btScalar m_repulsionStiffness;
+	btScalar m_gravityFactor;
+	bool m_cacheBarycenter;
+	btAlignedObjectArray<btVector3> m_X;  // initial positions
+
+	btAlignedObjectArray<btVector4> m_renderNodesInterpolationWeights;
+	btAlignedObjectArray<btAlignedObjectArray<const btSoftBody::Node*> > m_renderNodesParents;
+	btAlignedObjectArray<btScalar> m_z;  // vertical distance used in extrapolation
+	bool m_useSelfCollision;
+	bool m_softSoftCollision;
+
+	btAlignedObjectArray<bool> m_clusterConnectivity;  //cluster connectivity, for self-collision
+
+	btVector3 m_windVelocity;
+
+	btScalar m_restLengthScale;
+
+	//
+	// Api
+	//
+
+	/* ctor																	*/
+	btSoftBody(btSoftBodyWorldInfo* worldInfo, int node_count, const btVector3* x, const btScalar* m);
+
+	/* ctor																	*/
+	btSoftBody(btSoftBodyWorldInfo* worldInfo);
+
+	void initDefaults();
+
+	/* dtor																	*/
+	virtual ~btSoftBody();
+	/* Check for existing link												*/
+
+	btAlignedObjectArray<int> m_userIndexMapping;
+
+	btSoftBodyWorldInfo* getWorldInfo()
+	{
+		return m_worldInfo;
+	}
+
+	void setDampingCoefficient(btScalar damping_coeff)
+	{
+		m_dampingCoefficient = damping_coeff;
+	}
+
+	///@todo: avoid internal softbody shape hack and move collision code to collision library
+	virtual void setCollisionShape(btCollisionShape* collisionShape)
+	{
+	}
+
+	bool checkLink(int node0,
+				   int node1) const;
+	bool checkLink(const Node* node0,
+				   const Node* node1) const;
+	/* Check for existring face												*/
+	bool checkFace(int node0,
+				   int node1,
+				   int node2) const;
+	/* Append material														*/
+	Material* appendMaterial();
+	/* Append note															*/
+	void appendNote(const char* text,
+					const btVector3& o,
+					const btVector4& c = btVector4(1, 0, 0, 0),
+					Node* n0 = 0,
+					Node* n1 = 0,
+					Node* n2 = 0,
+					Node* n3 = 0);
+	void appendNote(const char* text,
+					const btVector3& o,
+					Node* feature);
+	void appendNote(const char* text,
+					const btVector3& o,
+					Link* feature);
+	void appendNote(const char* text,
+					const btVector3& o,
+					Face* feature);
+	/* Append node															*/
+	void appendNode(const btVector3& x, btScalar m);
+	/* Append link															*/
+	void appendLink(int model = -1, Material* mat = 0);
+	void appendLink(int node0,
+					int node1,
+					Material* mat = 0,
+					bool bcheckexist = false);
+	void appendLink(Node* node0,
+					Node* node1,
+					Material* mat = 0,
+					bool bcheckexist = false);
+	/* Append face															*/
+	void appendFace(int model = -1, Material* mat = 0);
+	void appendFace(int node0,
+					int node1,
+					int node2,
+					Material* mat = 0);
+	void appendTetra(int model, Material* mat);
+	//
+	void appendTetra(int node0,
+					 int node1,
+					 int node2,
+					 int node3,
+					 Material* mat = 0);
+
+	/* Append anchor														*/
+	void appendDeformableAnchor(int node, btRigidBody* body);
+	void appendDeformableAnchor(int node, btMultiBodyLinkCollider* link);
+	void appendAnchor(int node,
+					  btRigidBody* body, bool disableCollisionBetweenLinkedBodies = false, btScalar influence = 1);
+	void appendAnchor(int node, btRigidBody* body, const btVector3& localPivot, bool disableCollisionBetweenLinkedBodies = false, btScalar influence = 1);
+	void removeAnchor(int node);
+	/* Append linear joint													*/
+	void appendLinearJoint(const LJoint::Specs& specs, Cluster* body0, Body body1);
+	void appendLinearJoint(const LJoint::Specs& specs, Body body = Body());
+	void appendLinearJoint(const LJoint::Specs& specs, btSoftBody* body);
+	/* Append linear joint													*/
+	void appendAngularJoint(const AJoint::Specs& specs, Cluster* body0, Body body1);
+	void appendAngularJoint(const AJoint::Specs& specs, Body body = Body());
+	void appendAngularJoint(const AJoint::Specs& specs, btSoftBody* body);
+	/* Add force (or gravity) to the entire body							*/
+	void addForce(const btVector3& force);
+	/* Add force (or gravity) to a node of the body							*/
+	void addForce(const btVector3& force,
+				  int node);
+	/* Add aero force to a node of the body */
+	void addAeroForceToNode(const btVector3& windVelocity, int nodeIndex);
+
+	/* Add aero force to a face of the body */
+	void addAeroForceToFace(const btVector3& windVelocity, int faceIndex);
+
+	/* Add velocity to the entire body										*/
+	void addVelocity(const btVector3& velocity);
+
+	/* Set velocity for the entire body										*/
+	void setVelocity(const btVector3& velocity);
+
+	/* Add velocity to a node of the body									*/
+	void addVelocity(const btVector3& velocity,
+					 int node);
+	/* Set mass																*/
+	void setMass(int node,
+				 btScalar mass);
+	/* Get mass																*/
+	btScalar getMass(int node) const;
+	/* Get total mass														*/
+	btScalar getTotalMass() const;
+	/* Set total mass (weighted by previous masses)							*/
+	void setTotalMass(btScalar mass,
+					  bool fromfaces = false);
+	/* Set total density													*/
+	void setTotalDensity(btScalar density);
+	/* Set volume mass (using tetrahedrons)									*/
+	void setVolumeMass(btScalar mass);
+	/* Set volume density (using tetrahedrons)								*/
+	void setVolumeDensity(btScalar density);
+	/* Get the linear velocity of the center of mass                        */
+	btVector3 getLinearVelocity();
+	/* Set the linear velocity of the center of mass                        */
+	void setLinearVelocity(const btVector3& linVel);
+	/* Set the angular velocity of the center of mass                       */
+	void setAngularVelocity(const btVector3& angVel);
+	/* Get best fit rigid transform                                         */
+	btTransform getRigidTransform();
+	/* Transform to given pose                                              */
+	void transformTo(const btTransform& trs);
+	/* Transform															*/
+	void transform(const btTransform& trs);
+	/* Translate															*/
+	void translate(const btVector3& trs);
+	/* Rotate															*/
+	void rotate(const btQuaternion& rot);
+	/* Scale																*/
+	void scale(const btVector3& scl);
+	/* Get link resting lengths scale										*/
+	btScalar getRestLengthScale();
+	/* Scale resting length of all springs									*/
+	void setRestLengthScale(btScalar restLength);
+	/* Set current state as pose											*/
+	void setPose(bool bvolume,
+				 bool bframe);
+	/* Set current link lengths as resting lengths							*/
+	void resetLinkRestLengths();
+	/* Return the volume													*/
+	btScalar getVolume() const;
+	/* Cluster count														*/
+	btVector3 getCenterOfMass() const
+	{
+		btVector3 com(0, 0, 0);
+		for (int i = 0; i < m_nodes.size(); i++)
+		{
+			com += (m_nodes[i].m_x * this->getMass(i));
+		}
+		com /= this->getTotalMass();
+		return com;
+	}
+	int clusterCount() const;
+	/* Cluster center of mass												*/
+	static btVector3 clusterCom(const Cluster* cluster);
+	btVector3 clusterCom(int cluster) const;
+	/* Cluster velocity at rpos												*/
+	static btVector3 clusterVelocity(const Cluster* cluster, const btVector3& rpos);
+	/* Cluster impulse														*/
+	static void clusterVImpulse(Cluster* cluster, const btVector3& rpos, const btVector3& impulse);
+	static void clusterDImpulse(Cluster* cluster, const btVector3& rpos, const btVector3& impulse);
+	static void clusterImpulse(Cluster* cluster, const btVector3& rpos, const Impulse& impulse);
+	static void clusterVAImpulse(Cluster* cluster, const btVector3& impulse);
+	static void clusterDAImpulse(Cluster* cluster, const btVector3& impulse);
+	static void clusterAImpulse(Cluster* cluster, const Impulse& impulse);
+	static void clusterDCImpulse(Cluster* cluster, const btVector3& impulse);
+	/* Generate bending constraints based on distance in the adjency graph	*/
+	int generateBendingConstraints(int distance,
+								   Material* mat = 0);
+	/* Randomize constraints to reduce solver bias							*/
+	void randomizeConstraints();
+	/* Release clusters														*/
+	void releaseCluster(int index);
+	void releaseClusters();
+	/* Generate clusters (K-mean)											*/
+	///generateClusters with k=0 will create a convex cluster for each tetrahedron or triangle
+	///otherwise an approximation will be used (better performance)
+	int generateClusters(int k, int maxiterations = 8192);
+	/* Refine																*/
+	void refine(ImplicitFn* ifn, btScalar accurary, bool cut);
+	/* CutLink																*/
+	bool cutLink(int node0, int node1, btScalar position);
+	bool cutLink(const Node* node0, const Node* node1, btScalar position);
+
+	///Ray casting using rayFrom and rayTo in worldspace, (not direction!)
+	bool rayTest(const btVector3& rayFrom,
+				 const btVector3& rayTo,
+				 sRayCast& results);
+	bool rayFaceTest(const btVector3& rayFrom,
+					 const btVector3& rayTo,
+					 sRayCast& results);
+	int rayFaceTest(const btVector3& rayFrom, const btVector3& rayTo,
+					btScalar& mint, int& index) const;
+	/* Solver presets														*/
+	void setSolver(eSolverPresets::_ preset);
+	/* predictMotion														*/
+	void predictMotion(btScalar dt);
+	/* solveConstraints														*/
+	void solveConstraints();
+	/* staticSolve															*/
+	void staticSolve(int iterations);
+	/* solveCommonConstraints												*/
+	static void solveCommonConstraints(btSoftBody** bodies, int count, int iterations);
+	/* solveClusters														*/
+	static void solveClusters(const btAlignedObjectArray<btSoftBody*>& bodies);
+	/* integrateMotion														*/
+	void integrateMotion();
+	/* defaultCollisionHandlers												*/
+	void defaultCollisionHandler(const btCollisionObjectWrapper* pcoWrap);
+	void defaultCollisionHandler(btSoftBody* psb);
+	void setSelfCollision(bool useSelfCollision);
+	bool useSelfCollision();
+	void updateDeactivation(btScalar timeStep);
+	void setZeroVelocity();
+	bool wantsSleeping();
+
+	//
+	// Functionality to deal with new accelerated solvers.
+	//
+
+	/**
+	 * Set a wind velocity for interaction with the air.
+	 */
+	void setWindVelocity(const btVector3& velocity);
+
+	/**
+	 * Return the wind velocity for interaction with the air.
+	 */
+	const btVector3& getWindVelocity();
+
+	//
+	// Set the solver that handles this soft body
+	// Should not be allowed to get out of sync with reality
+	// Currently called internally on addition to the world
+	void setSoftBodySolver(btSoftBodySolver* softBodySolver)
+	{
+		m_softBodySolver = softBodySolver;
+	}
+
+	//
+	// Return the solver that handles this soft body
+	//
+	btSoftBodySolver* getSoftBodySolver()
+	{
+		return m_softBodySolver;
+	}
+
+	//
+	// Return the solver that handles this soft body
+	//
+	btSoftBodySolver* getSoftBodySolver() const
+	{
+		return m_softBodySolver;
+	}
+
+	//
+	// Cast
+	//
+
+	static const btSoftBody* upcast(const btCollisionObject* colObj)
+	{
+		if (colObj->getInternalType() == CO_SOFT_BODY)
+			return (const btSoftBody*)colObj;
+		return 0;
+	}
+	static btSoftBody* upcast(btCollisionObject* colObj)
+	{
+		if (colObj->getInternalType() == CO_SOFT_BODY)
+			return (btSoftBody*)colObj;
+		return 0;
+	}
+
+	//
+	// ::btCollisionObject
+	//
+
+	virtual void getAabb(btVector3& aabbMin, btVector3& aabbMax) const
+	{
+		aabbMin = m_bounds[0];
+		aabbMax = m_bounds[1];
+	}
+	//
+	// Private
+	//
+	void pointersToIndices();
+	void indicesToPointers(const int* map = 0);
+
+	int rayTest(const btVector3& rayFrom, const btVector3& rayTo,
+				btScalar& mint, eFeature::_& feature, int& index, bool bcountonly) const;
+	void initializeFaceTree();
+	void rebuildNodeTree();
+	btVector3 evaluateCom() const;
+	bool checkDeformableContact(const btCollisionObjectWrapper* colObjWrap, const btVector3& x, btScalar margin, btSoftBody::sCti& cti, bool predict = false) const;
+	bool checkDeformableFaceContact(const btCollisionObjectWrapper* colObjWrap, Face& f, btVector3& contact_point, btVector3& bary, btScalar margin, btSoftBody::sCti& cti, bool predict = false) const;
+	bool checkContact(const btCollisionObjectWrapper* colObjWrap, const btVector3& x, btScalar margin, btSoftBody::sCti& cti) const;
+	void updateNormals();
+	void updateBounds();
+	void updatePose();
+	void updateConstants();
+	void updateLinkConstants();
+	void updateArea(bool averageArea = true);
+	void initializeClusters();
+	void updateClusters();
+	void cleanupClusters();
+	void prepareClusters(int iterations);
+	void solveClusters(btScalar sor);
+	void applyClusters(bool drift);
+	void dampClusters();
+	void setSpringStiffness(btScalar k);
+	void setGravityFactor(btScalar gravFactor);
+	void setCacheBarycenter(bool cacheBarycenter);
+	void initializeDmInverse();
+	void updateDeformation();
+	void advanceDeformation();
+	void applyForces();
+	void setMaxStress(btScalar maxStress);
+	void interpolateRenderMesh();
+	void setCollisionQuadrature(int N);
+	static void PSolve_Anchors(btSoftBody* psb, btScalar kst, btScalar ti);
+	static void PSolve_RContacts(btSoftBody* psb, btScalar kst, btScalar ti);
+	static void PSolve_SContacts(btSoftBody* psb, btScalar, btScalar ti);
+	static void PSolve_Links(btSoftBody* psb, btScalar kst, btScalar ti);
+	static void VSolve_Links(btSoftBody* psb, btScalar kst);
+	static psolver_t getSolver(ePSolver::_ solver);
+	static vsolver_t getSolver(eVSolver::_ solver);
+	void geometricCollisionHandler(btSoftBody* psb);
+#define SAFE_EPSILON SIMD_EPSILON * 100.0
+	void updateNode(btDbvtNode* node, bool use_velocity, bool margin)
+	{
+		if (node->isleaf())
+		{
+			btSoftBody::Node* n = (btSoftBody::Node*)(node->data);
+			ATTRIBUTE_ALIGNED16(btDbvtVolume)
+			vol;
+			btScalar pad = margin ? m_sst.radmrg : SAFE_EPSILON;  // use user defined margin or margin for floating point precision
+			if (use_velocity)
+			{
+				btVector3 points[2] = {n->m_x, n->m_x + m_sst.sdt * n->m_v};
+				vol = btDbvtVolume::FromPoints(points, 2);
+				vol.Expand(btVector3(pad, pad, pad));
+			}
+			else
+			{
+				vol = btDbvtVolume::FromCR(n->m_x, pad);
+			}
+			node->volume = vol;
+			return;
+		}
+		else
+		{
+			updateNode(node->childs[0], use_velocity, margin);
+			updateNode(node->childs[1], use_velocity, margin);
+			ATTRIBUTE_ALIGNED16(btDbvtVolume)
+			vol;
+			Merge(node->childs[0]->volume, node->childs[1]->volume, vol);
+			node->volume = vol;
+		}
+	}
+
+	void updateNodeTree(bool use_velocity, bool margin)
+	{
+		if (m_ndbvt.m_root)
+			updateNode(m_ndbvt.m_root, use_velocity, margin);
+	}
+
+	template <class DBVTNODE>  // btDbvtNode or btDbvntNode
+	void updateFace(DBVTNODE* node, bool use_velocity, bool margin)
+	{
+		if (node->isleaf())
+		{
+			btSoftBody::Face* f = (btSoftBody::Face*)(node->data);
+			btScalar pad = margin ? m_sst.radmrg : SAFE_EPSILON;  // use user defined margin or margin for floating point precision
+			ATTRIBUTE_ALIGNED16(btDbvtVolume)
+			vol;
+			if (use_velocity)
+			{
+				btVector3 points[6] = {f->m_n[0]->m_x, f->m_n[0]->m_x + m_sst.sdt * f->m_n[0]->m_v,
+									   f->m_n[1]->m_x, f->m_n[1]->m_x + m_sst.sdt * f->m_n[1]->m_v,
+									   f->m_n[2]->m_x, f->m_n[2]->m_x + m_sst.sdt * f->m_n[2]->m_v};
+				vol = btDbvtVolume::FromPoints(points, 6);
+			}
+			else
+			{
+				btVector3 points[3] = {f->m_n[0]->m_x,
+									   f->m_n[1]->m_x,
+									   f->m_n[2]->m_x};
+				vol = btDbvtVolume::FromPoints(points, 3);
+			}
+			vol.Expand(btVector3(pad, pad, pad));
+			node->volume = vol;
+			return;
+		}
+		else
+		{
+			updateFace(node->childs[0], use_velocity, margin);
+			updateFace(node->childs[1], use_velocity, margin);
+			ATTRIBUTE_ALIGNED16(btDbvtVolume)
+			vol;
+			Merge(node->childs[0]->volume, node->childs[1]->volume, vol);
+			node->volume = vol;
+		}
+	}
+	void updateFaceTree(bool use_velocity, bool margin)
+	{
+		if (m_fdbvt.m_root)
+			updateFace(m_fdbvt.m_root, use_velocity, margin);
+		if (m_fdbvnt)
+			updateFace(m_fdbvnt, use_velocity, margin);
+	}
+
+	template <typename T>
+	static inline T BaryEval(const T& a,
+							 const T& b,
+							 const T& c,
+							 const btVector3& coord)
+	{
+		return (a * coord.x() + b * coord.y() + c * coord.z());
+	}
+
+	void applyRepulsionForce(btScalar timeStep, bool applySpringForce)
+	{
+		btAlignedObjectArray<int> indices;
+		{
+			// randomize the order of repulsive force
+			indices.resize(m_faceNodeContacts.size());
+			for (int i = 0; i < m_faceNodeContacts.size(); ++i)
+				indices[i] = i;
+#define NEXTRAND (seed = (1664525L * seed + 1013904223L) & 0xffffffff)
+			int i, ni;
+
+			for (i = 0, ni = indices.size(); i < ni; ++i)
+			{
+				btSwap(indices[i], indices[NEXTRAND % ni]);
+			}
+		}
+		for (int k = 0; k < m_faceNodeContacts.size(); ++k)
+		{
+			int i = indices[k];
+			btSoftBody::DeformableFaceNodeContact& c = m_faceNodeContacts[i];
+			btSoftBody::Node* node = c.m_node;
+			btSoftBody::Face* face = c.m_face;
+			const btVector3& w = c.m_bary;
+			const btVector3& n = c.m_normal;
+			btVector3 l = node->m_x - BaryEval(face->m_n[0]->m_x, face->m_n[1]->m_x, face->m_n[2]->m_x, w);
+			btScalar d = c.m_margin - n.dot(l);
+			d = btMax(btScalar(0), d);
+
+			const btVector3& va = node->m_v;
+			btVector3 vb = BaryEval(face->m_n[0]->m_v, face->m_n[1]->m_v, face->m_n[2]->m_v, w);
+			btVector3 vr = va - vb;
+			const btScalar vn = btDot(vr, n);  // dn < 0 <==> opposing
+			if (vn > OVERLAP_REDUCTION_FACTOR * d / timeStep)
+				continue;
+			btVector3 vt = vr - vn * n;
+			btScalar I = 0;
+			btScalar mass = node->m_im == 0 ? 0 : btScalar(1) / node->m_im;
+			if (applySpringForce)
+				I = -btMin(m_repulsionStiffness * timeStep * d, mass * (OVERLAP_REDUCTION_FACTOR * d / timeStep - vn));
+			if (vn < 0)
+				I += 0.5 * mass * vn;
+			int face_penetration = 0, node_penetration = node->m_constrained;
+			for (int i = 0; i < 3; ++i)
+				face_penetration |= face->m_n[i]->m_constrained;
+			btScalar I_tilde = 2.0 * I / (1.0 + w.length2());
+
+			//             double the impulse if node or face is constrained.
+			if (face_penetration > 0 || node_penetration > 0)
+			{
+				I_tilde *= 2.0;
+			}
+			if (face_penetration <= 0)
+			{
+				for (int j = 0; j < 3; ++j)
+					face->m_n[j]->m_v += w[j] * n * I_tilde * node->m_im;
+			}
+			if (node_penetration <= 0)
+			{
+				node->m_v -= I_tilde * node->m_im * n;
+			}
+
+			// apply frictional impulse
+			btScalar vt_norm = vt.safeNorm();
+			if (vt_norm > SIMD_EPSILON)
+			{
+				btScalar delta_vn = -2 * I * node->m_im;
+				btScalar mu = c.m_friction;
+				btScalar vt_new = btMax(btScalar(1) - mu * delta_vn / (vt_norm + SIMD_EPSILON), btScalar(0)) * vt_norm;
+				I = 0.5 * mass * (vt_norm - vt_new);
+				vt.safeNormalize();
+				I_tilde = 2.0 * I / (1.0 + w.length2());
+				//                 double the impulse if node or face is constrained.
+				if (face_penetration > 0 || node_penetration > 0)
+					I_tilde *= 2.0;
+				if (face_penetration <= 0)
+				{
+					for (int j = 0; j < 3; ++j)
+						face->m_n[j]->m_v += w[j] * vt * I_tilde * (face->m_n[j])->m_im;
+				}
+				if (node_penetration <= 0)
+				{
+					node->m_v -= I_tilde * node->m_im * vt;
+				}
+			}
+		}
+	}
+	virtual int calculateSerializeBufferSize() const;
+
+	///fills the dataBuffer and returns the struct name (and 0 on failure)
+	virtual const char* serialize(void* dataBuffer, class btSerializer* serializer) const;
+};
+
+#endif  //_BT_SOFT_BODY_H
diff --git a/engine/inc/bullet/BulletSoftBody/btSoftBodyConcaveCollisionAlgorithm.h b/engine/inc/bullet/BulletSoftBody/btSoftBodyConcaveCollisionAlgorithm.h
new file mode 100644
index 00000000..3adedbd8
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btSoftBodyConcaveCollisionAlgorithm.h
@@ -0,0 +1,147 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SOFT_BODY_CONCAVE_COLLISION_ALGORITHM_H
+#define BT_SOFT_BODY_CONCAVE_COLLISION_ALGORITHM_H
+
+#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+#include "BulletCollision/BroadphaseCollision/btDispatcher.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h"
+#include "BulletCollision/CollisionShapes/btTriangleCallback.h"
+#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
+class btDispatcher;
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
+class btSoftBody;
+class btCollisionShape;
+
+#include "LinearMath/btHashMap.h"
+
+#include "BulletCollision/BroadphaseCollision/btQuantizedBvh.h"  //for definition of MAX_NUM_PARTS_IN_BITS
+
+struct btTriIndex
+{
+	int m_PartIdTriangleIndex;
+	class btCollisionShape* m_childShape;
+
+	btTriIndex(int partId, int triangleIndex, btCollisionShape* shape)
+	{
+		m_PartIdTriangleIndex = (partId << (31 - MAX_NUM_PARTS_IN_BITS)) | triangleIndex;
+		m_childShape = shape;
+	}
+
+	int getTriangleIndex() const
+	{
+		// Get only the lower bits where the triangle index is stored
+		unsigned int x = 0;
+		unsigned int y = (~(x & 0)) << (31 - MAX_NUM_PARTS_IN_BITS);
+		return (m_PartIdTriangleIndex & ~(y));
+	}
+	int getPartId() const
+	{
+		// Get only the highest bits where the part index is stored
+		return (m_PartIdTriangleIndex >> (31 - MAX_NUM_PARTS_IN_BITS));
+	}
+	int getUid() const
+	{
+		return m_PartIdTriangleIndex;
+	}
+};
+
+///For each triangle in the concave mesh that overlaps with the AABB of a soft body (m_softBody), processTriangle is called.
+class btSoftBodyTriangleCallback : public btTriangleCallback
+{
+	btSoftBody* m_softBody;
+	const btCollisionObject* m_triBody;
+
+	btVector3 m_aabbMin;
+	btVector3 m_aabbMax;
+
+	btManifoldResult* m_resultOut;
+
+	btDispatcher* m_dispatcher;
+	const btDispatcherInfo* m_dispatchInfoPtr;
+	btScalar m_collisionMarginTriangle;
+
+	btHashMap<btHashKey<btTriIndex>, btTriIndex> m_shapeCache;
+
+public:
+	int m_triangleCount;
+
+	//	btPersistentManifold*	m_manifoldPtr;
+
+	btSoftBodyTriangleCallback(btDispatcher* dispatcher, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, bool isSwapped);
+
+	void setTimeStepAndCounters(btScalar collisionMarginTriangle, const btCollisionObjectWrapper* triObjWrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	virtual ~btSoftBodyTriangleCallback();
+
+	virtual void processTriangle(btVector3* triangle, int partId, int triangleIndex);
+
+	void clearCache();
+
+	SIMD_FORCE_INLINE const btVector3& getAabbMin() const
+	{
+		return m_aabbMin;
+	}
+	SIMD_FORCE_INLINE const btVector3& getAabbMax() const
+	{
+		return m_aabbMax;
+	}
+};
+
+/// btSoftBodyConcaveCollisionAlgorithm  supports collision between soft body shapes and (concave) trianges meshes.
+class btSoftBodyConcaveCollisionAlgorithm : public btCollisionAlgorithm
+{
+	bool m_isSwapped;
+
+	btSoftBodyTriangleCallback m_btSoftBodyTriangleCallback;
+
+public:
+	btSoftBodyConcaveCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, bool isSwapped);
+
+	virtual ~btSoftBodyConcaveCollisionAlgorithm();
+
+	virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	btScalar calculateTimeOfImpact(btCollisionObject* body0, btCollisionObject* body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	virtual void getAllContactManifolds(btManifoldArray& manifoldArray)
+	{
+		//we don't add any manifolds
+	}
+
+	void clearCache();
+
+	struct CreateFunc : public btCollisionAlgorithmCreateFunc
+	{
+		virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap)
+		{
+			void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btSoftBodyConcaveCollisionAlgorithm));
+			return new (mem) btSoftBodyConcaveCollisionAlgorithm(ci, body0Wrap, body1Wrap, false);
+		}
+	};
+
+	struct SwappedCreateFunc : public btCollisionAlgorithmCreateFunc
+	{
+		virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap)
+		{
+			void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btSoftBodyConcaveCollisionAlgorithm));
+			return new (mem) btSoftBodyConcaveCollisionAlgorithm(ci, body0Wrap, body1Wrap, true);
+		}
+	};
+};
+
+#endif  //BT_SOFT_BODY_CONCAVE_COLLISION_ALGORITHM_H
diff --git a/engine/inc/bullet/BulletSoftBody/btSoftBodyData.h b/engine/inc/bullet/BulletSoftBody/btSoftBodyData.h
new file mode 100644
index 00000000..cec6f401
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btSoftBodyData.h
@@ -0,0 +1,212 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SOFTBODY_FLOAT_DATA
+#define BT_SOFTBODY_FLOAT_DATA
+
+#include "BulletCollision/CollisionDispatch/btCollisionObject.h"
+#include "BulletDynamics/Dynamics/btRigidBody.h"
+
+struct SoftBodyMaterialData
+{
+	float m_linearStiffness;
+	float m_angularStiffness;
+	float m_volumeStiffness;
+	int m_flags;
+};
+
+struct SoftBodyNodeData
+{
+	SoftBodyMaterialData *m_material;
+	btVector3FloatData m_position;
+	btVector3FloatData m_previousPosition;
+	btVector3FloatData m_velocity;
+	btVector3FloatData m_accumulatedForce;
+	btVector3FloatData m_normal;
+	float m_inverseMass;
+	float m_area;
+	int m_attach;
+	int m_pad;
+};
+
+struct SoftBodyLinkData
+{
+	SoftBodyMaterialData *m_material;
+	int m_nodeIndices[2];  // Node pointers
+	float m_restLength;    // Rest length
+	int m_bbending;        // Bending link
+};
+
+struct SoftBodyFaceData
+{
+	btVector3FloatData m_normal;  // Normal
+	SoftBodyMaterialData *m_material;
+	int m_nodeIndices[3];  // Node pointers
+	float m_restArea;      // Rest area
+};
+
+struct SoftBodyTetraData
+{
+	btVector3FloatData m_c0[4];  // gradients
+	SoftBodyMaterialData *m_material;
+	int m_nodeIndices[4];  // Node pointers
+	float m_restVolume;    // Rest volume
+	float m_c1;            // (4*kVST)/(im0+im1+im2+im3)
+	float m_c2;            // m_c1/sum(|g0..3|^2)
+	int m_pad;
+};
+
+struct SoftRigidAnchorData
+{
+	btMatrix3x3FloatData m_c0;        // Impulse matrix
+	btVector3FloatData m_c1;          // Relative anchor
+	btVector3FloatData m_localFrame;  // Anchor position in body space
+	btRigidBodyData *m_rigidBody;
+	int m_nodeIndex;  // Node pointer
+	float m_c2;       // ima*dt
+};
+
+struct SoftBodyConfigData
+{
+	int m_aeroModel;                         // Aerodynamic model (default: V_Point)
+	float m_baumgarte;                       // Velocities correction factor (Baumgarte)
+	float m_damping;                         // Damping coefficient [0,1]
+	float m_drag;                            // Drag coefficient [0,+inf]
+	float m_lift;                            // Lift coefficient [0,+inf]
+	float m_pressure;                        // Pressure coefficient [-inf,+inf]
+	float m_volume;                          // Volume conversation coefficient [0,+inf]
+	float m_dynamicFriction;                 // Dynamic friction coefficient [0,1]
+	float m_poseMatch;                       // Pose matching coefficient [0,1]
+	float m_rigidContactHardness;            // Rigid contacts hardness [0,1]
+	float m_kineticContactHardness;          // Kinetic contacts hardness [0,1]
+	float m_softContactHardness;             // Soft contacts hardness [0,1]
+	float m_anchorHardness;                  // Anchors hardness [0,1]
+	float m_softRigidClusterHardness;        // Soft vs rigid hardness [0,1] (cluster only)
+	float m_softKineticClusterHardness;      // Soft vs kinetic hardness [0,1] (cluster only)
+	float m_softSoftClusterHardness;         // Soft vs soft hardness [0,1] (cluster only)
+	float m_softRigidClusterImpulseSplit;    // Soft vs rigid impulse split [0,1] (cluster only)
+	float m_softKineticClusterImpulseSplit;  // Soft vs rigid impulse split [0,1] (cluster only)
+	float m_softSoftClusterImpulseSplit;     // Soft vs rigid impulse split [0,1] (cluster only)
+	float m_maxVolume;                       // Maximum volume ratio for pose
+	float m_timeScale;                       // Time scale
+	int m_velocityIterations;                // Velocities solver iterations
+	int m_positionIterations;                // Positions solver iterations
+	int m_driftIterations;                   // Drift solver iterations
+	int m_clusterIterations;                 // Cluster solver iterations
+	int m_collisionFlags;                    // Collisions flags
+};
+
+struct SoftBodyPoseData
+{
+	btMatrix3x3FloatData m_rot;    // Rotation
+	btMatrix3x3FloatData m_scale;  // Scale
+	btMatrix3x3FloatData m_aqq;    // Base scaling
+	btVector3FloatData m_com;      // COM
+
+	btVector3FloatData *m_positions;  // Reference positions
+	float *m_weights;                 // Weights
+	int m_numPositions;
+	int m_numWeigts;
+
+	int m_bvolume;       // Is valid
+	int m_bframe;        // Is frame
+	float m_restVolume;  // Rest volume
+	int m_pad;
+};
+
+struct SoftBodyClusterData
+{
+	btTransformFloatData m_framexform;
+	btMatrix3x3FloatData m_locii;
+	btMatrix3x3FloatData m_invwi;
+	btVector3FloatData m_com;
+	btVector3FloatData m_vimpulses[2];
+	btVector3FloatData m_dimpulses[2];
+	btVector3FloatData m_lv;
+	btVector3FloatData m_av;
+
+	btVector3FloatData *m_framerefs;
+	int *m_nodeIndices;
+	float *m_masses;
+
+	int m_numFrameRefs;
+	int m_numNodes;
+	int m_numMasses;
+
+	float m_idmass;
+	float m_imass;
+	int m_nvimpulses;
+	int m_ndimpulses;
+	float m_ndamping;
+	float m_ldamping;
+	float m_adamping;
+	float m_matching;
+	float m_maxSelfCollisionImpulse;
+	float m_selfCollisionImpulseFactor;
+	int m_containsAnchor;
+	int m_collide;
+	int m_clusterIndex;
+};
+
+enum btSoftJointBodyType
+{
+	BT_JOINT_SOFT_BODY_CLUSTER = 1,
+	BT_JOINT_RIGID_BODY,
+	BT_JOINT_COLLISION_OBJECT
+};
+
+struct btSoftBodyJointData
+{
+	void *m_bodyA;
+	void *m_bodyB;
+	btVector3FloatData m_refs[2];
+	float m_cfm;
+	float m_erp;
+	float m_split;
+	int m_delete;
+	btVector3FloatData m_relPosition[2];  //linear
+	int m_bodyAtype;
+	int m_bodyBtype;
+	int m_jointType;
+	int m_pad;
+};
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct btSoftBodyFloatData
+{
+	btCollisionObjectFloatData m_collisionObjectData;
+
+	SoftBodyPoseData *m_pose;
+	SoftBodyMaterialData **m_materials;
+	SoftBodyNodeData *m_nodes;
+	SoftBodyLinkData *m_links;
+	SoftBodyFaceData *m_faces;
+	SoftBodyTetraData *m_tetrahedra;
+	SoftRigidAnchorData *m_anchors;
+	SoftBodyClusterData *m_clusters;
+	btSoftBodyJointData *m_joints;
+
+	int m_numMaterials;
+	int m_numNodes;
+	int m_numLinks;
+	int m_numFaces;
+	int m_numTetrahedra;
+	int m_numAnchors;
+	int m_numClusters;
+	int m_numJoints;
+	SoftBodyConfigData m_config;
+};
+
+#endif  //BT_SOFTBODY_FLOAT_DATA
diff --git a/engine/inc/bullet/BulletSoftBody/btSoftBodyHelpers.h b/engine/inc/bullet/BulletSoftBody/btSoftBodyHelpers.h
new file mode 100644
index 00000000..237d2976
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btSoftBodyHelpers.h
@@ -0,0 +1,167 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2008 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SOFT_BODY_HELPERS_H
+#define BT_SOFT_BODY_HELPERS_H
+
+#include "btSoftBody.h"
+#include <fstream>
+#include <string>
+//
+// Helpers
+//
+
+/* fDrawFlags															*/
+struct fDrawFlags
+{
+	enum _
+	{
+		Nodes = 0x0001,
+		Links = 0x0002,
+		Faces = 0x0004,
+		Tetras = 0x0008,
+		Normals = 0x0010,
+		Contacts = 0x0020,
+		Anchors = 0x0040,
+		Notes = 0x0080,
+		Clusters = 0x0100,
+		NodeTree = 0x0200,
+		FaceTree = 0x0400,
+		ClusterTree = 0x0800,
+		Joints = 0x1000,
+		/* presets	*/
+		Std = Links + Faces + Tetras + Anchors + Notes + Joints,
+		StdTetra = Std - Faces + Tetras
+	};
+};
+
+struct btSoftBodyHelpers
+{
+	/* Draw body															*/
+	static void Draw(btSoftBody* psb,
+					 btIDebugDraw* idraw,
+					 int drawflags = fDrawFlags::Std);
+	/* Draw body infos														*/
+	static void DrawInfos(btSoftBody* psb,
+						  btIDebugDraw* idraw,
+						  bool masses,
+						  bool areas,
+						  bool stress);
+	/* Draw node tree														*/
+	static void DrawNodeTree(btSoftBody* psb,
+							 btIDebugDraw* idraw,
+							 int mindepth = 0,
+							 int maxdepth = -1);
+	/* Draw face tree														*/
+	static void DrawFaceTree(btSoftBody* psb,
+							 btIDebugDraw* idraw,
+							 int mindepth = 0,
+							 int maxdepth = -1);
+	/* Draw cluster tree													*/
+	static void DrawClusterTree(btSoftBody* psb,
+								btIDebugDraw* idraw,
+								int mindepth = 0,
+								int maxdepth = -1);
+	/* Draw rigid frame														*/
+	static void DrawFrame(btSoftBody* psb,
+						  btIDebugDraw* idraw);
+	/* Create a rope														*/
+	static btSoftBody* CreateRope(btSoftBodyWorldInfo& worldInfo,
+								  const btVector3& from,
+								  const btVector3& to,
+								  int res,
+								  int fixeds);
+	/* Create a patch														*/
+	static btSoftBody* CreatePatch(btSoftBodyWorldInfo& worldInfo,
+								   const btVector3& corner00,
+								   const btVector3& corner10,
+								   const btVector3& corner01,
+								   const btVector3& corner11,
+								   int resx,
+								   int resy,
+								   int fixeds,
+								   bool gendiags,
+								   btScalar perturbation = 0.);
+	/* Create a patch with UV Texture Coordinates	*/
+	static btSoftBody* CreatePatchUV(btSoftBodyWorldInfo& worldInfo,
+									 const btVector3& corner00,
+									 const btVector3& corner10,
+									 const btVector3& corner01,
+									 const btVector3& corner11,
+									 int resx,
+									 int resy,
+									 int fixeds,
+									 bool gendiags,
+									 float* tex_coords = 0);
+	static float CalculateUV(int resx, int resy, int ix, int iy, int id);
+	/* Create an ellipsoid													*/
+	static btSoftBody* CreateEllipsoid(btSoftBodyWorldInfo& worldInfo,
+									   const btVector3& center,
+									   const btVector3& radius,
+									   int res);
+	/* Create from trimesh													*/
+	static btSoftBody* CreateFromTriMesh(btSoftBodyWorldInfo& worldInfo,
+										 const btScalar* vertices,
+										 const int* triangles,
+										 int ntriangles,
+										 bool randomizeConstraints = true);
+	/* Create from convex-hull												*/
+	static btSoftBody* CreateFromConvexHull(btSoftBodyWorldInfo& worldInfo,
+											const btVector3* vertices,
+											int nvertices,
+											bool randomizeConstraints = true);
+
+	/* Export TetGen compatible .smesh file									*/
+	//	static void				ExportAsSMeshFile(	btSoftBody* psb,
+	//												const char* filename);
+	/* Create from TetGen .ele, .face, .node files							*/
+	//	static btSoftBody*		CreateFromTetGenFile(	btSoftBodyWorldInfo& worldInfo,
+	//													const char* ele,
+	//													const char* face,
+	//													const char* node,
+	//													bool bfacelinks,
+	//													bool btetralinks,
+	//													bool bfacesfromtetras);
+	/* Create from TetGen .ele, .face, .node data							*/
+	static btSoftBody* CreateFromTetGenData(btSoftBodyWorldInfo& worldInfo,
+											const char* ele,
+											const char* face,
+											const char* node,
+											bool bfacelinks,
+											bool btetralinks,
+											bool bfacesfromtetras);
+	static btSoftBody* CreateFromVtkFile(btSoftBodyWorldInfo& worldInfo, const char* vtk_file);
+
+	static void writeObj(const char* file, const btSoftBody* psb);
+
+	static void getBarycentricWeights(const btVector3& a, const btVector3& b, const btVector3& c, const btVector3& d, const btVector3& p, btVector4& bary);
+
+	static void getBarycentricWeights(const btVector3& a, const btVector3& b, const btVector3& c, const btVector3& p, btVector4& bary);
+
+	static void interpolateBarycentricWeights(btSoftBody* psb);
+
+	static void extrapolateBarycentricWeights(btSoftBody* psb);
+
+	static void generateBoundaryFaces(btSoftBody* psb);
+
+	static void duplicateFaces(const char* filename, const btSoftBody* psb);
+	/// Sort the list of links to move link calculations that are dependent upon earlier
+	/// ones as far as possible away from the calculation of those values
+	/// This tends to make adjacent loop iterations not dependent upon one another,
+	/// so out-of-order processors can execute instructions from multiple iterations at once
+	static void ReoptimizeLinkOrder(btSoftBody* psb);
+};
+
+#endif  //BT_SOFT_BODY_HELPERS_H
diff --git a/engine/inc/bullet/BulletSoftBody/btSoftBodyInternals.h b/engine/inc/bullet/BulletSoftBody/btSoftBodyInternals.h
new file mode 100644
index 00000000..c17bbb5c
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btSoftBodyInternals.h
@@ -0,0 +1,2108 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+///btSoftBody implementation by Nathanael Presson
+
+#ifndef _BT_SOFT_BODY_INTERNALS_H
+#define _BT_SOFT_BODY_INTERNALS_H
+
+#include "btSoftBody.h"
+#include "LinearMath/btQuickprof.h"
+#include "LinearMath/btPolarDecomposition.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h"
+#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h"
+#include "BulletCollision/CollisionShapes/btConvexInternalShape.h"
+#include "BulletCollision/NarrowPhaseCollision/btGjkEpa2.h"
+#include "BulletDynamics/Featherstone/btMultiBodyLinkCollider.h"
+#include "BulletDynamics/Featherstone/btMultiBodyConstraint.h"
+#include <string.h>  //for memset
+#include <cmath>
+#include "poly34.h"
+
+// Given a multibody link, a contact point and a contact direction, fill in the jacobian data needed to calculate the velocity change given an impulse in the contact direction
+static SIMD_FORCE_INLINE void findJacobian(const btMultiBodyLinkCollider* multibodyLinkCol,
+										   btMultiBodyJacobianData& jacobianData,
+										   const btVector3& contact_point,
+										   const btVector3& dir)
+{
+	const int ndof = multibodyLinkCol->m_multiBody->getNumDofs() + 6;
+	jacobianData.m_jacobians.resize(ndof);
+	jacobianData.m_deltaVelocitiesUnitImpulse.resize(ndof);
+	btScalar* jac = &jacobianData.m_jacobians[0];
+
+	multibodyLinkCol->m_multiBody->fillContactJacobianMultiDof(multibodyLinkCol->m_link, contact_point, dir, jac, jacobianData.scratch_r, jacobianData.scratch_v, jacobianData.scratch_m);
+	multibodyLinkCol->m_multiBody->calcAccelerationDeltasMultiDof(&jacobianData.m_jacobians[0], &jacobianData.m_deltaVelocitiesUnitImpulse[0], jacobianData.scratch_r, jacobianData.scratch_v);
+}
+static SIMD_FORCE_INLINE btVector3 generateUnitOrthogonalVector(const btVector3& u)
+{
+	btScalar ux = u.getX();
+	btScalar uy = u.getY();
+	btScalar uz = u.getZ();
+	btScalar ax = std::abs(ux);
+	btScalar ay = std::abs(uy);
+	btScalar az = std::abs(uz);
+	btVector3 v;
+	if (ax <= ay && ax <= az)
+		v = btVector3(0, -uz, uy);
+	else if (ay <= ax && ay <= az)
+		v = btVector3(-uz, 0, ux);
+	else
+		v = btVector3(-uy, ux, 0);
+	v.normalize();
+	return v;
+}
+
+static SIMD_FORCE_INLINE bool proximityTest(const btVector3& x1, const btVector3& x2, const btVector3& x3, const btVector3& x4, const btVector3& normal, const btScalar& mrg, btVector3& bary)
+{
+	btVector3 x43 = x4 - x3;
+	if (std::abs(x43.dot(normal)) > mrg)
+		return false;
+	btVector3 x13 = x1 - x3;
+	btVector3 x23 = x2 - x3;
+	btScalar a11 = x13.length2();
+	btScalar a22 = x23.length2();
+	btScalar a12 = x13.dot(x23);
+	btScalar b1 = x13.dot(x43);
+	btScalar b2 = x23.dot(x43);
+	btScalar det = a11 * a22 - a12 * a12;
+	if (det < SIMD_EPSILON)
+		return false;
+	btScalar w1 = (b1 * a22 - b2 * a12) / det;
+	btScalar w2 = (b2 * a11 - b1 * a12) / det;
+	btScalar w3 = 1 - w1 - w2;
+	btScalar delta = mrg / std::sqrt(0.5 * std::abs(x13.cross(x23).safeNorm()));
+	bary = btVector3(w1, w2, w3);
+	for (int i = 0; i < 3; ++i)
+	{
+		if (bary[i] < -delta || bary[i] > 1 + delta)
+			return false;
+	}
+	return true;
+}
+static const int KDOP_COUNT = 13;
+static btVector3 dop[KDOP_COUNT] = {btVector3(1, 0, 0),
+									btVector3(0, 1, 0),
+									btVector3(0, 0, 1),
+									btVector3(1, 1, 0),
+									btVector3(1, 0, 1),
+									btVector3(0, 1, 1),
+									btVector3(1, -1, 0),
+									btVector3(1, 0, -1),
+									btVector3(0, 1, -1),
+									btVector3(1, 1, 1),
+									btVector3(1, -1, 1),
+									btVector3(1, 1, -1),
+									btVector3(1, -1, -1)};
+
+static inline int getSign(const btVector3& n, const btVector3& x)
+{
+	btScalar d = n.dot(x);
+	if (d > SIMD_EPSILON)
+		return 1;
+	if (d < -SIMD_EPSILON)
+		return -1;
+	return 0;
+}
+
+static SIMD_FORCE_INLINE bool hasSeparatingPlane(const btSoftBody::Face* face, const btSoftBody::Node* node, const btScalar& dt)
+{
+	btVector3 hex[6] = {face->m_n[0]->m_x - node->m_x,
+						face->m_n[1]->m_x - node->m_x,
+						face->m_n[2]->m_x - node->m_x,
+						face->m_n[0]->m_x + dt * face->m_n[0]->m_v - node->m_x,
+						face->m_n[1]->m_x + dt * face->m_n[1]->m_v - node->m_x,
+						face->m_n[2]->m_x + dt * face->m_n[2]->m_v - node->m_x};
+	btVector3 segment = dt * node->m_v;
+	for (int i = 0; i < KDOP_COUNT; ++i)
+	{
+		int s = getSign(dop[i], segment);
+		int j = 0;
+		for (; j < 6; ++j)
+		{
+			if (getSign(dop[i], hex[j]) == s)
+				break;
+		}
+		if (j == 6)
+			return true;
+	}
+	return false;
+}
+
+static SIMD_FORCE_INLINE bool nearZero(const btScalar& a)
+{
+	return (a > -SAFE_EPSILON && a < SAFE_EPSILON);
+}
+static SIMD_FORCE_INLINE bool sameSign(const btScalar& a, const btScalar& b)
+{
+	return (nearZero(a) || nearZero(b) || (a > SAFE_EPSILON && b > SAFE_EPSILON) || (a < -SAFE_EPSILON && b < -SAFE_EPSILON));
+}
+static SIMD_FORCE_INLINE bool diffSign(const btScalar& a, const btScalar& b)
+{
+	return !sameSign(a, b);
+}
+inline btScalar evaluateBezier2(const btScalar& p0, const btScalar& p1, const btScalar& p2, const btScalar& t, const btScalar& s)
+{
+	btScalar s2 = s * s;
+	btScalar t2 = t * t;
+
+	return p0 * s2 + p1 * btScalar(2.0) * s * t + p2 * t2;
+}
+inline btScalar evaluateBezier(const btScalar& p0, const btScalar& p1, const btScalar& p2, const btScalar& p3, const btScalar& t, const btScalar& s)
+{
+	btScalar s2 = s * s;
+	btScalar s3 = s2 * s;
+	btScalar t2 = t * t;
+	btScalar t3 = t2 * t;
+
+	return p0 * s3 + p1 * btScalar(3.0) * s2 * t + p2 * btScalar(3.0) * s * t2 + p3 * t3;
+}
+static SIMD_FORCE_INLINE bool getSigns(bool type_c, const btScalar& k0, const btScalar& k1, const btScalar& k2, const btScalar& k3, const btScalar& t0, const btScalar& t1, btScalar& lt0, btScalar& lt1)
+{
+	if (sameSign(t0, t1))
+	{
+		lt0 = t0;
+		lt1 = t0;
+		return true;
+	}
+
+	if (type_c || diffSign(k0, k3))
+	{
+		btScalar ft = evaluateBezier(k0, k1, k2, k3, t0, -t1);
+		if (t0 < -0)
+			ft = -ft;
+
+		if (sameSign(ft, k0))
+		{
+			lt0 = t1;
+			lt1 = t1;
+		}
+		else
+		{
+			lt0 = t0;
+			lt1 = t0;
+		}
+		return true;
+	}
+
+	if (!type_c)
+	{
+		btScalar ft = evaluateBezier(k0, k1, k2, k3, t0, -t1);
+		if (t0 < -0)
+			ft = -ft;
+
+		if (diffSign(ft, k0))
+		{
+			lt0 = t0;
+			lt1 = t1;
+			return true;
+		}
+
+		btScalar fk = evaluateBezier2(k1 - k0, k2 - k1, k3 - k2, t0, -t1);
+
+		if (sameSign(fk, k1 - k0))
+			lt0 = lt1 = t1;
+		else
+			lt0 = lt1 = t0;
+
+		return true;
+	}
+	return false;
+}
+
+static SIMD_FORCE_INLINE void getBernsteinCoeff(const btSoftBody::Face* face, const btSoftBody::Node* node, const btScalar& dt, btScalar& k0, btScalar& k1, btScalar& k2, btScalar& k3)
+{
+	const btVector3& n0 = face->m_n0;
+	const btVector3& n1 = face->m_n1;
+	btVector3 n_hat = n0 + n1 - face->m_vn;
+	btVector3 p0ma0 = node->m_x - face->m_n[0]->m_x;
+	btVector3 p1ma1 = node->m_q - face->m_n[0]->m_q;
+	k0 = (p0ma0).dot(n0) * 3.0;
+	k1 = (p0ma0).dot(n_hat) + (p1ma1).dot(n0);
+	k2 = (p1ma1).dot(n_hat) + (p0ma0).dot(n1);
+	k3 = (p1ma1).dot(n1) * 3.0;
+}
+
+static SIMD_FORCE_INLINE void polyDecomposition(const btScalar& k0, const btScalar& k1, const btScalar& k2, const btScalar& k3, const btScalar& j0, const btScalar& j1, const btScalar& j2, btScalar& u0, btScalar& u1, btScalar& v0, btScalar& v1)
+{
+	btScalar denom = 4.0 * (j1 - j2) * (j1 - j0) + (j2 - j0) * (j2 - j0);
+	u0 = (2.0 * (j1 - j2) * (3.0 * k1 - 2.0 * k0 - k3) - (j0 - j2) * (3.0 * k2 - 2.0 * k3 - k0)) / denom;
+	u1 = (2.0 * (j1 - j0) * (3.0 * k2 - 2.0 * k3 - k0) - (j2 - j0) * (3.0 * k1 - 2.0 * k0 - k3)) / denom;
+	v0 = k0 - u0 * j0;
+	v1 = k3 - u1 * j2;
+}
+
+static SIMD_FORCE_INLINE bool rootFindingLemma(const btScalar& k0, const btScalar& k1, const btScalar& k2, const btScalar& k3)
+{
+	btScalar u0, u1, v0, v1;
+	btScalar j0 = 3.0 * (k1 - k0);
+	btScalar j1 = 3.0 * (k2 - k1);
+	btScalar j2 = 3.0 * (k3 - k2);
+	polyDecomposition(k0, k1, k2, k3, j0, j1, j2, u0, u1, v0, v1);
+	if (sameSign(v0, v1))
+	{
+		btScalar Ypa = j0 * (1.0 - v0) * (1.0 - v0) + 2.0 * j1 * v0 * (1.0 - v0) + j2 * v0 * v0;  // Y'(v0)
+		if (sameSign(Ypa, j0))
+		{
+			return (diffSign(k0, v1));
+		}
+	}
+	return diffSign(k0, v0);
+}
+
+static SIMD_FORCE_INLINE void getJs(const btScalar& k0, const btScalar& k1, const btScalar& k2, const btScalar& k3, const btSoftBody::Node* a, const btSoftBody::Node* b, const btSoftBody::Node* c, const btSoftBody::Node* p, const btScalar& dt, btScalar& j0, btScalar& j1, btScalar& j2)
+{
+	const btVector3& a0 = a->m_x;
+	const btVector3& b0 = b->m_x;
+	const btVector3& c0 = c->m_x;
+	const btVector3& va = a->m_v;
+	const btVector3& vb = b->m_v;
+	const btVector3& vc = c->m_v;
+	const btVector3 a1 = a0 + dt * va;
+	const btVector3 b1 = b0 + dt * vb;
+	const btVector3 c1 = c0 + dt * vc;
+	btVector3 n0 = (b0 - a0).cross(c0 - a0);
+	btVector3 n1 = (b1 - a1).cross(c1 - a1);
+	btVector3 n_hat = n0 + n1 - dt * dt * (vb - va).cross(vc - va);
+	const btVector3& p0 = p->m_x;
+	const btVector3& vp = p->m_v;
+	btVector3 p1 = p0 + dt * vp;
+	btVector3 m0 = (b0 - p0).cross(c0 - p0);
+	btVector3 m1 = (b1 - p1).cross(c1 - p1);
+	btVector3 m_hat = m0 + m1 - dt * dt * (vb - vp).cross(vc - vp);
+	btScalar l0 = m0.dot(n0);
+	btScalar l1 = 0.25 * (m0.dot(n_hat) + m_hat.dot(n0));
+	btScalar l2 = btScalar(1) / btScalar(6) * (m0.dot(n1) + m_hat.dot(n_hat) + m1.dot(n0));
+	btScalar l3 = 0.25 * (m_hat.dot(n1) + m1.dot(n_hat));
+	btScalar l4 = m1.dot(n1);
+
+	btScalar k1p = 0.25 * k0 + 0.75 * k1;
+	btScalar k2p = 0.5 * k1 + 0.5 * k2;
+	btScalar k3p = 0.75 * k2 + 0.25 * k3;
+
+	btScalar s0 = (l1 * k0 - l0 * k1p) * 4.0;
+	btScalar s1 = (l2 * k0 - l0 * k2p) * 2.0;
+	btScalar s2 = (l3 * k0 - l0 * k3p) * btScalar(4) / btScalar(3);
+	btScalar s3 = l4 * k0 - l0 * k3;
+
+	j0 = (s1 * k0 - s0 * k1) * 3.0;
+	j1 = (s2 * k0 - s0 * k2) * 1.5;
+	j2 = (s3 * k0 - s0 * k3);
+}
+
+static SIMD_FORCE_INLINE bool signDetermination1Internal(const btScalar& k0, const btScalar& k1, const btScalar& k2, const btScalar& k3, const btScalar& u0, const btScalar& u1, const btScalar& v0, const btScalar& v1)
+{
+	btScalar Yu0 = k0 * (1.0 - u0) * (1.0 - u0) * (1.0 - u0) + 3.0 * k1 * u0 * (1.0 - u0) * (1.0 - u0) + 3.0 * k2 * u0 * u0 * (1.0 - u0) + k3 * u0 * u0 * u0;  // Y(u0)
+	btScalar Yv0 = k0 * (1.0 - v0) * (1.0 - v0) * (1.0 - v0) + 3.0 * k1 * v0 * (1.0 - v0) * (1.0 - v0) + 3.0 * k2 * v0 * v0 * (1.0 - v0) + k3 * v0 * v0 * v0;  // Y(v0)
+
+	btScalar sign_Ytp = (u0 > u1) ? Yu0 : -Yu0;
+	btScalar L = sameSign(sign_Ytp, k0) ? u1 : u0;
+	sign_Ytp = (v0 > v1) ? Yv0 : -Yv0;
+	btScalar K = (sameSign(sign_Ytp, k0)) ? v1 : v0;
+	return diffSign(L, K);
+}
+
+static SIMD_FORCE_INLINE bool signDetermination2Internal(const btScalar& k0, const btScalar& k1, const btScalar& k2, const btScalar& k3, const btScalar& j0, const btScalar& j1, const btScalar& j2, const btScalar& u0, const btScalar& u1, const btScalar& v0, const btScalar& v1)
+{
+	btScalar Yu0 = k0 * (1.0 - u0) * (1.0 - u0) * (1.0 - u0) + 3.0 * k1 * u0 * (1.0 - u0) * (1.0 - u0) + 3.0 * k2 * u0 * u0 * (1.0 - u0) + k3 * u0 * u0 * u0;  // Y(u0)
+	btScalar sign_Ytp = (u0 > u1) ? Yu0 : -Yu0, L1, L2;
+	if (diffSign(sign_Ytp, k0))
+	{
+		L1 = u0;
+		L2 = u1;
+	}
+	else
+	{
+		btScalar Yp_u0 = j0 * (1.0 - u0) * (1.0 - u0) + 2.0 * j1 * (1.0 - u0) * u0 + j2 * u0 * u0;
+		if (sameSign(Yp_u0, j0))
+		{
+			L1 = u1;
+			L2 = u1;
+		}
+		else
+		{
+			L1 = u0;
+			L2 = u0;
+		}
+	}
+	btScalar Yv0 = k0 * (1.0 - v0) * (1.0 - v0) * (1.0 - v0) + 3.0 * k1 * v0 * (1.0 - v0) * (1.0 - v0) + 3.0 * k2 * v0 * v0 * (1.0 - v0) + k3 * v0 * v0 * v0;  // Y(uv0)
+	sign_Ytp = (v0 > v1) ? Yv0 : -Yv0;
+	btScalar K1, K2;
+	if (diffSign(sign_Ytp, k0))
+	{
+		K1 = v0;
+		K2 = v1;
+	}
+	else
+	{
+		btScalar Yp_v0 = j0 * (1.0 - v0) * (1.0 - v0) + 2.0 * j1 * (1.0 - v0) * v0 + j2 * v0 * v0;
+		if (sameSign(Yp_v0, j0))
+		{
+			K1 = v1;
+			K2 = v1;
+		}
+		else
+		{
+			K1 = v0;
+			K2 = v0;
+		}
+	}
+	return (diffSign(K1, L1) || diffSign(L2, K2));
+}
+
+static SIMD_FORCE_INLINE bool signDetermination1(const btScalar& k0, const btScalar& k1, const btScalar& k2, const btScalar& k3, const btSoftBody::Face* face, const btSoftBody::Node* node, const btScalar& dt)
+{
+	btScalar j0, j1, j2, u0, u1, v0, v1;
+	// p1
+	getJs(k0, k1, k2, k3, face->m_n[0], face->m_n[1], face->m_n[2], node, dt, j0, j1, j2);
+	if (nearZero(j0 + j2 - j1 * 2.0))
+	{
+		btScalar lt0, lt1;
+		getSigns(true, k0, k1, k2, k3, j0, j2, lt0, lt1);
+		if (lt0 < -SAFE_EPSILON)
+			return false;
+	}
+	else
+	{
+		polyDecomposition(k0, k1, k2, k3, j0, j1, j2, u0, u1, v0, v1);
+		if (!signDetermination1Internal(k0, k1, k2, k3, u0, u1, v0, v1))
+			return false;
+	}
+	// p2
+	getJs(k0, k1, k2, k3, face->m_n[1], face->m_n[2], face->m_n[0], node, dt, j0, j1, j2);
+	if (nearZero(j0 + j2 - j1 * 2.0))
+	{
+		btScalar lt0, lt1;
+		getSigns(true, k0, k1, k2, k3, j0, j2, lt0, lt1);
+		if (lt0 < -SAFE_EPSILON)
+			return false;
+	}
+	else
+	{
+		polyDecomposition(k0, k1, k2, k3, j0, j1, j2, u0, u1, v0, v1);
+		if (!signDetermination1Internal(k0, k1, k2, k3, u0, u1, v0, v1))
+			return false;
+	}
+	// p3
+	getJs(k0, k1, k2, k3, face->m_n[2], face->m_n[0], face->m_n[1], node, dt, j0, j1, j2);
+	if (nearZero(j0 + j2 - j1 * 2.0))
+	{
+		btScalar lt0, lt1;
+		getSigns(true, k0, k1, k2, k3, j0, j2, lt0, lt1);
+		if (lt0 < -SAFE_EPSILON)
+			return false;
+	}
+	else
+	{
+		polyDecomposition(k0, k1, k2, k3, j0, j1, j2, u0, u1, v0, v1);
+		if (!signDetermination1Internal(k0, k1, k2, k3, u0, u1, v0, v1))
+			return false;
+	}
+	return true;
+}
+
+static SIMD_FORCE_INLINE bool signDetermination2(const btScalar& k0, const btScalar& k1, const btScalar& k2, const btScalar& k3, const btSoftBody::Face* face, const btSoftBody::Node* node, const btScalar& dt)
+{
+	btScalar j0, j1, j2, u0, u1, v0, v1;
+	// p1
+	getJs(k0, k1, k2, k3, face->m_n[0], face->m_n[1], face->m_n[2], node, dt, j0, j1, j2);
+	if (nearZero(j0 + j2 - j1 * 2.0))
+	{
+		btScalar lt0, lt1;
+		bool bt0 = true, bt1 = true;
+		getSigns(false, k0, k1, k2, k3, j0, j2, lt0, lt1);
+		if (lt0 < -SAFE_EPSILON)
+			bt0 = false;
+		if (lt1 < -SAFE_EPSILON)
+			bt1 = false;
+		if (!bt0 && !bt1)
+			return false;
+	}
+	else
+	{
+		polyDecomposition(k0, k1, k2, k3, j0, j1, j2, u0, u1, v0, v1);
+		if (!signDetermination2Internal(k0, k1, k2, k3, j0, j1, j2, u0, u1, v0, v1))
+			return false;
+	}
+	// p2
+	getJs(k0, k1, k2, k3, face->m_n[1], face->m_n[2], face->m_n[0], node, dt, j0, j1, j2);
+	if (nearZero(j0 + j2 - j1 * 2.0))
+	{
+		btScalar lt0, lt1;
+		bool bt0 = true, bt1 = true;
+		getSigns(false, k0, k1, k2, k3, j0, j2, lt0, lt1);
+		if (lt0 < -SAFE_EPSILON)
+			bt0 = false;
+		if (lt1 < -SAFE_EPSILON)
+			bt1 = false;
+		if (!bt0 && !bt1)
+			return false;
+	}
+	else
+	{
+		polyDecomposition(k0, k1, k2, k3, j0, j1, j2, u0, u1, v0, v1);
+		if (!signDetermination2Internal(k0, k1, k2, k3, j0, j1, j2, u0, u1, v0, v1))
+			return false;
+	}
+	// p3
+	getJs(k0, k1, k2, k3, face->m_n[2], face->m_n[0], face->m_n[1], node, dt, j0, j1, j2);
+	if (nearZero(j0 + j2 - j1 * 2.0))
+	{
+		btScalar lt0, lt1;
+		bool bt0 = true, bt1 = true;
+		getSigns(false, k0, k1, k2, k3, j0, j2, lt0, lt1);
+		if (lt0 < -SAFE_EPSILON)
+			bt0 = false;
+		if (lt1 < -SAFE_EPSILON)
+			bt1 = false;
+		if (!bt0 && !bt1)
+			return false;
+	}
+	else
+	{
+		polyDecomposition(k0, k1, k2, k3, j0, j1, j2, u0, u1, v0, v1);
+		if (!signDetermination2Internal(k0, k1, k2, k3, j0, j1, j2, u0, u1, v0, v1))
+			return false;
+	}
+	return true;
+}
+
+static SIMD_FORCE_INLINE bool coplanarAndInsideTest(const btScalar& k0, const btScalar& k1, const btScalar& k2, const btScalar& k3, const btSoftBody::Face* face, const btSoftBody::Node* node, const btScalar& dt)
+{
+	// Coplanar test
+	if (diffSign(k1 - k0, k3 - k2))
+	{
+		// Case b:
+		if (sameSign(k0, k3) && !rootFindingLemma(k0, k1, k2, k3))
+			return false;
+		// inside test
+		return signDetermination2(k0, k1, k2, k3, face, node, dt);
+	}
+	else
+	{
+		// Case c:
+		if (sameSign(k0, k3))
+			return false;
+		// inside test
+		return signDetermination1(k0, k1, k2, k3, face, node, dt);
+	}
+	return false;
+}
+static SIMD_FORCE_INLINE bool conservativeCulling(const btScalar& k0, const btScalar& k1, const btScalar& k2, const btScalar& k3, const btScalar& mrg)
+{
+	if (k0 > mrg && k1 > mrg && k2 > mrg && k3 > mrg)
+		return true;
+	if (k0 < -mrg && k1 < -mrg && k2 < -mrg && k3 < -mrg)
+		return true;
+	return false;
+}
+
+static SIMD_FORCE_INLINE bool bernsteinVFTest(const btScalar& k0, const btScalar& k1, const btScalar& k2, const btScalar& k3, const btScalar& mrg, const btSoftBody::Face* face, const btSoftBody::Node* node, const btScalar& dt)
+{
+	if (conservativeCulling(k0, k1, k2, k3, mrg))
+		return false;
+	return coplanarAndInsideTest(k0, k1, k2, k3, face, node, dt);
+}
+
+static SIMD_FORCE_INLINE void deCasteljau(const btScalar& k0, const btScalar& k1, const btScalar& k2, const btScalar& k3, const btScalar& t0, btScalar& k10, btScalar& k20, btScalar& k30, btScalar& k21, btScalar& k12)
+{
+	k10 = k0 * (1.0 - t0) + k1 * t0;
+	btScalar k11 = k1 * (1.0 - t0) + k2 * t0;
+	k12 = k2 * (1.0 - t0) + k3 * t0;
+	k20 = k10 * (1.0 - t0) + k11 * t0;
+	k21 = k11 * (1.0 - t0) + k12 * t0;
+	k30 = k20 * (1.0 - t0) + k21 * t0;
+}
+static SIMD_FORCE_INLINE bool bernsteinVFTest(const btSoftBody::Face* face, const btSoftBody::Node* node, const btScalar& dt, const btScalar& mrg)
+{
+	btScalar k0, k1, k2, k3;
+	getBernsteinCoeff(face, node, dt, k0, k1, k2, k3);
+	if (conservativeCulling(k0, k1, k2, k3, mrg))
+		return false;
+	return true;
+	if (diffSign(k2 - 2.0 * k1 + k0, k3 - 2.0 * k2 + k1))
+	{
+		btScalar k10, k20, k30, k21, k12;
+		btScalar t0 = (k2 - 2.0 * k1 + k0) / (k0 - 3.0 * k1 + 3.0 * k2 - k3);
+		deCasteljau(k0, k1, k2, k3, t0, k10, k20, k30, k21, k12);
+		return bernsteinVFTest(k0, k10, k20, k30, mrg, face, node, dt) || bernsteinVFTest(k30, k21, k12, k3, mrg, face, node, dt);
+	}
+	return coplanarAndInsideTest(k0, k1, k2, k3, face, node, dt);
+}
+
+static SIMD_FORCE_INLINE bool continuousCollisionDetection(const btSoftBody::Face* face, const btSoftBody::Node* node, const btScalar& dt, const btScalar& mrg, btVector3& bary)
+{
+	if (hasSeparatingPlane(face, node, dt))
+		return false;
+	btVector3 x21 = face->m_n[1]->m_x - face->m_n[0]->m_x;
+	btVector3 x31 = face->m_n[2]->m_x - face->m_n[0]->m_x;
+	btVector3 x41 = node->m_x - face->m_n[0]->m_x;
+	btVector3 v21 = face->m_n[1]->m_v - face->m_n[0]->m_v;
+	btVector3 v31 = face->m_n[2]->m_v - face->m_n[0]->m_v;
+	btVector3 v41 = node->m_v - face->m_n[0]->m_v;
+	btVector3 a = x21.cross(x31);
+	btVector3 b = x21.cross(v31) + v21.cross(x31);
+	btVector3 c = v21.cross(v31);
+	btVector3 d = x41;
+	btVector3 e = v41;
+	btScalar a0 = a.dot(d);
+	btScalar a1 = a.dot(e) + b.dot(d);
+	btScalar a2 = c.dot(d) + b.dot(e);
+	btScalar a3 = c.dot(e);
+	btScalar eps = SAFE_EPSILON;
+	int num_roots = 0;
+	btScalar roots[3];
+	if (std::abs(a3) < eps)
+	{
+		// cubic term is zero
+		if (std::abs(a2) < eps)
+		{
+			if (std::abs(a1) < eps)
+			{
+				if (std::abs(a0) < eps)
+				{
+					num_roots = 2;
+					roots[0] = 0;
+					roots[1] = dt;
+				}
+			}
+			else
+			{
+				num_roots = 1;
+				roots[0] = -a0 / a1;
+			}
+		}
+		else
+		{
+			num_roots = SolveP2(roots, a1 / a2, a0 / a2);
+		}
+	}
+	else
+	{
+		num_roots = SolveP3(roots, a2 / a3, a1 / a3, a0 / a3);
+	}
+	//    std::sort(roots, roots+num_roots);
+	if (num_roots > 1)
+	{
+		if (roots[0] > roots[1])
+			btSwap(roots[0], roots[1]);
+	}
+	if (num_roots > 2)
+	{
+		if (roots[0] > roots[2])
+			btSwap(roots[0], roots[2]);
+		if (roots[1] > roots[2])
+			btSwap(roots[1], roots[2]);
+	}
+	for (int r = 0; r < num_roots; ++r)
+	{
+		double root = roots[r];
+		if (root <= 0)
+			continue;
+		if (root > dt + SIMD_EPSILON)
+			return false;
+		btVector3 x1 = face->m_n[0]->m_x + root * face->m_n[0]->m_v;
+		btVector3 x2 = face->m_n[1]->m_x + root * face->m_n[1]->m_v;
+		btVector3 x3 = face->m_n[2]->m_x + root * face->m_n[2]->m_v;
+		btVector3 x4 = node->m_x + root * node->m_v;
+		btVector3 normal = (x2 - x1).cross(x3 - x1);
+		normal.safeNormalize();
+		if (proximityTest(x1, x2, x3, x4, normal, mrg, bary))
+			return true;
+	}
+	return false;
+}
+static SIMD_FORCE_INLINE bool bernsteinCCD(const btSoftBody::Face* face, const btSoftBody::Node* node, const btScalar& dt, const btScalar& mrg, btVector3& bary)
+{
+	if (!bernsteinVFTest(face, node, dt, mrg))
+		return false;
+	if (!continuousCollisionDetection(face, node, dt, 1e-6, bary))
+		return false;
+	return true;
+}
+
+//
+// btSymMatrix
+//
+template <typename T>
+struct btSymMatrix
+{
+	btSymMatrix() : dim(0) {}
+	btSymMatrix(int n, const T& init = T()) { resize(n, init); }
+	void resize(int n, const T& init = T())
+	{
+		dim = n;
+		store.resize((n * (n + 1)) / 2, init);
+	}
+	int index(int c, int r) const
+	{
+		if (c > r) btSwap(c, r);
+		btAssert(r < dim);
+		return ((r * (r + 1)) / 2 + c);
+	}
+	T& operator()(int c, int r) { return (store[index(c, r)]); }
+	const T& operator()(int c, int r) const { return (store[index(c, r)]); }
+	btAlignedObjectArray<T> store;
+	int dim;
+};
+
+//
+// btSoftBodyCollisionShape
+//
+class btSoftBodyCollisionShape : public btConcaveShape
+{
+public:
+	btSoftBody* m_body;
+
+	btSoftBodyCollisionShape(btSoftBody* backptr)
+	{
+		m_shapeType = SOFTBODY_SHAPE_PROXYTYPE;
+		m_body = backptr;
+	}
+
+	virtual ~btSoftBodyCollisionShape()
+	{
+	}
+
+	void processAllTriangles(btTriangleCallback* /*callback*/, const btVector3& /*aabbMin*/, const btVector3& /*aabbMax*/) const
+	{
+		//not yet
+		btAssert(0);
+	}
+
+	///getAabb returns the axis aligned bounding box in the coordinate frame of the given transform t.
+	virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const
+	{
+		/* t is usually identity, except when colliding against btCompoundShape. See Issue 512 */
+		const btVector3 mins = m_body->m_bounds[0];
+		const btVector3 maxs = m_body->m_bounds[1];
+		const btVector3 crns[] = {t * btVector3(mins.x(), mins.y(), mins.z()),
+								  t * btVector3(maxs.x(), mins.y(), mins.z()),
+								  t * btVector3(maxs.x(), maxs.y(), mins.z()),
+								  t * btVector3(mins.x(), maxs.y(), mins.z()),
+								  t * btVector3(mins.x(), mins.y(), maxs.z()),
+								  t * btVector3(maxs.x(), mins.y(), maxs.z()),
+								  t * btVector3(maxs.x(), maxs.y(), maxs.z()),
+								  t * btVector3(mins.x(), maxs.y(), maxs.z())};
+		aabbMin = aabbMax = crns[0];
+		for (int i = 1; i < 8; ++i)
+		{
+			aabbMin.setMin(crns[i]);
+			aabbMax.setMax(crns[i]);
+		}
+	}
+
+	virtual void setLocalScaling(const btVector3& /*scaling*/)
+	{
+		///na
+	}
+	virtual const btVector3& getLocalScaling() const
+	{
+		static const btVector3 dummy(1, 1, 1);
+		return dummy;
+	}
+	virtual void calculateLocalInertia(btScalar /*mass*/, btVector3& /*inertia*/) const
+	{
+		///not yet
+		btAssert(0);
+	}
+	virtual const char* getName() const
+	{
+		return "SoftBody";
+	}
+};
+
+//
+// btSoftClusterCollisionShape
+//
+class btSoftClusterCollisionShape : public btConvexInternalShape
+{
+public:
+	const btSoftBody::Cluster* m_cluster;
+
+	btSoftClusterCollisionShape(const btSoftBody::Cluster* cluster) : m_cluster(cluster) { setMargin(0); }
+
+	virtual btVector3 localGetSupportingVertex(const btVector3& vec) const
+	{
+		btSoftBody::Node* const* n = &m_cluster->m_nodes[0];
+		btScalar d = btDot(vec, n[0]->m_x);
+		int j = 0;
+		for (int i = 1, ni = m_cluster->m_nodes.size(); i < ni; ++i)
+		{
+			const btScalar k = btDot(vec, n[i]->m_x);
+			if (k > d)
+			{
+				d = k;
+				j = i;
+			}
+		}
+		return (n[j]->m_x);
+	}
+	virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const
+	{
+		return (localGetSupportingVertex(vec));
+	}
+	//notice that the vectors should be unit length
+	virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const
+	{
+	}
+
+	virtual void calculateLocalInertia(btScalar mass, btVector3& inertia) const
+	{
+	}
+
+	virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const
+	{
+	}
+
+	virtual int getShapeType() const { return SOFTBODY_SHAPE_PROXYTYPE; }
+
+	//debugging
+	virtual const char* getName() const { return "SOFTCLUSTER"; }
+
+	virtual void setMargin(btScalar margin)
+	{
+		btConvexInternalShape::setMargin(margin);
+	}
+	virtual btScalar getMargin() const
+	{
+		return btConvexInternalShape::getMargin();
+	}
+};
+
+//
+// Inline's
+//
+
+//
+template <typename T>
+static inline void ZeroInitialize(T& value)
+{
+	memset(&value, 0, sizeof(T));
+}
+//
+template <typename T>
+static inline bool CompLess(const T& a, const T& b)
+{
+	return (a < b);
+}
+//
+template <typename T>
+static inline bool CompGreater(const T& a, const T& b)
+{
+	return (a > b);
+}
+//
+template <typename T>
+static inline T Lerp(const T& a, const T& b, btScalar t)
+{
+	return (a + (b - a) * t);
+}
+//
+template <typename T>
+static inline T InvLerp(const T& a, const T& b, btScalar t)
+{
+	return ((b + a * t - b * t) / (a * b));
+}
+//
+static inline btMatrix3x3 Lerp(const btMatrix3x3& a,
+							   const btMatrix3x3& b,
+							   btScalar t)
+{
+	btMatrix3x3 r;
+	r[0] = Lerp(a[0], b[0], t);
+	r[1] = Lerp(a[1], b[1], t);
+	r[2] = Lerp(a[2], b[2], t);
+	return (r);
+}
+//
+static inline btVector3 Clamp(const btVector3& v, btScalar maxlength)
+{
+	const btScalar sql = v.length2();
+	if (sql > (maxlength * maxlength))
+		return ((v * maxlength) / btSqrt(sql));
+	else
+		return (v);
+}
+//
+template <typename T>
+static inline T Clamp(const T& x, const T& l, const T& h)
+{
+	return (x < l ? l : x > h ? h : x);
+}
+//
+template <typename T>
+static inline T Sq(const T& x)
+{
+	return (x * x);
+}
+//
+template <typename T>
+static inline T Cube(const T& x)
+{
+	return (x * x * x);
+}
+//
+template <typename T>
+static inline T Sign(const T& x)
+{
+	return ((T)(x < 0 ? -1 : +1));
+}
+//
+template <typename T>
+static inline bool SameSign(const T& x, const T& y)
+{
+	return ((x * y) > 0);
+}
+//
+static inline btScalar ClusterMetric(const btVector3& x, const btVector3& y)
+{
+	const btVector3 d = x - y;
+	return (btFabs(d[0]) + btFabs(d[1]) + btFabs(d[2]));
+}
+//
+static inline btMatrix3x3 ScaleAlongAxis(const btVector3& a, btScalar s)
+{
+	const btScalar xx = a.x() * a.x();
+	const btScalar yy = a.y() * a.y();
+	const btScalar zz = a.z() * a.z();
+	const btScalar xy = a.x() * a.y();
+	const btScalar yz = a.y() * a.z();
+	const btScalar zx = a.z() * a.x();
+	btMatrix3x3 m;
+	m[0] = btVector3(1 - xx + xx * s, xy * s - xy, zx * s - zx);
+	m[1] = btVector3(xy * s - xy, 1 - yy + yy * s, yz * s - yz);
+	m[2] = btVector3(zx * s - zx, yz * s - yz, 1 - zz + zz * s);
+	return (m);
+}
+//
+static inline btMatrix3x3 Cross(const btVector3& v)
+{
+	btMatrix3x3 m;
+	m[0] = btVector3(0, -v.z(), +v.y());
+	m[1] = btVector3(+v.z(), 0, -v.x());
+	m[2] = btVector3(-v.y(), +v.x(), 0);
+	return (m);
+}
+//
+static inline btMatrix3x3 Diagonal(btScalar x)
+{
+	btMatrix3x3 m;
+	m[0] = btVector3(x, 0, 0);
+	m[1] = btVector3(0, x, 0);
+	m[2] = btVector3(0, 0, x);
+	return (m);
+}
+
+static inline btMatrix3x3 Diagonal(const btVector3& v)
+{
+	btMatrix3x3 m;
+	m[0] = btVector3(v.getX(), 0, 0);
+	m[1] = btVector3(0, v.getY(), 0);
+	m[2] = btVector3(0, 0, v.getZ());
+	return (m);
+}
+
+static inline btScalar Dot(const btScalar* a, const btScalar* b, int ndof)
+{
+	btScalar result = 0;
+	for (int i = 0; i < ndof; ++i)
+		result += a[i] * b[i];
+	return result;
+}
+
+static inline btMatrix3x3 OuterProduct(const btScalar* v1, const btScalar* v2, const btScalar* v3,
+									   const btScalar* u1, const btScalar* u2, const btScalar* u3, int ndof)
+{
+	btMatrix3x3 m;
+	btScalar a11 = Dot(v1, u1, ndof);
+	btScalar a12 = Dot(v1, u2, ndof);
+	btScalar a13 = Dot(v1, u3, ndof);
+
+	btScalar a21 = Dot(v2, u1, ndof);
+	btScalar a22 = Dot(v2, u2, ndof);
+	btScalar a23 = Dot(v2, u3, ndof);
+
+	btScalar a31 = Dot(v3, u1, ndof);
+	btScalar a32 = Dot(v3, u2, ndof);
+	btScalar a33 = Dot(v3, u3, ndof);
+	m[0] = btVector3(a11, a12, a13);
+	m[1] = btVector3(a21, a22, a23);
+	m[2] = btVector3(a31, a32, a33);
+	return (m);
+}
+
+static inline btMatrix3x3 OuterProduct(const btVector3& v1, const btVector3& v2)
+{
+	btMatrix3x3 m;
+	btScalar a11 = v1[0] * v2[0];
+	btScalar a12 = v1[0] * v2[1];
+	btScalar a13 = v1[0] * v2[2];
+
+	btScalar a21 = v1[1] * v2[0];
+	btScalar a22 = v1[1] * v2[1];
+	btScalar a23 = v1[1] * v2[2];
+
+	btScalar a31 = v1[2] * v2[0];
+	btScalar a32 = v1[2] * v2[1];
+	btScalar a33 = v1[2] * v2[2];
+	m[0] = btVector3(a11, a12, a13);
+	m[1] = btVector3(a21, a22, a23);
+	m[2] = btVector3(a31, a32, a33);
+	return (m);
+}
+
+//
+static inline btMatrix3x3 Add(const btMatrix3x3& a,
+							  const btMatrix3x3& b)
+{
+	btMatrix3x3 r;
+	for (int i = 0; i < 3; ++i) r[i] = a[i] + b[i];
+	return (r);
+}
+//
+static inline btMatrix3x3 Sub(const btMatrix3x3& a,
+							  const btMatrix3x3& b)
+{
+	btMatrix3x3 r;
+	for (int i = 0; i < 3; ++i) r[i] = a[i] - b[i];
+	return (r);
+}
+//
+static inline btMatrix3x3 Mul(const btMatrix3x3& a,
+							  btScalar b)
+{
+	btMatrix3x3 r;
+	for (int i = 0; i < 3; ++i) r[i] = a[i] * b;
+	return (r);
+}
+//
+static inline void Orthogonalize(btMatrix3x3& m)
+{
+	m[2] = btCross(m[0], m[1]).normalized();
+	m[1] = btCross(m[2], m[0]).normalized();
+	m[0] = btCross(m[1], m[2]).normalized();
+}
+//
+static inline btMatrix3x3 MassMatrix(btScalar im, const btMatrix3x3& iwi, const btVector3& r)
+{
+	const btMatrix3x3 cr = Cross(r);
+	return (Sub(Diagonal(im), cr * iwi * cr));
+}
+
+//
+static inline btMatrix3x3 ImpulseMatrix(btScalar dt,
+										btScalar ima,
+										btScalar imb,
+										const btMatrix3x3& iwi,
+										const btVector3& r)
+{
+	return (Diagonal(1 / dt) * Add(Diagonal(ima), MassMatrix(imb, iwi, r)).inverse());
+}
+
+//
+static inline btMatrix3x3 ImpulseMatrix(btScalar dt,
+										const btMatrix3x3& effective_mass_inv,
+										btScalar imb,
+										const btMatrix3x3& iwi,
+										const btVector3& r)
+{
+	return (Diagonal(1 / dt) * Add(effective_mass_inv, MassMatrix(imb, iwi, r)).inverse());
+	//    btMatrix3x3 iimb = MassMatrix(imb, iwi, r);
+	//    if (iimb.determinant() == 0)
+	//        return effective_mass_inv.inverse();
+	//    return effective_mass_inv.inverse() *  Add(effective_mass_inv.inverse(), iimb.inverse()).inverse() * iimb.inverse();
+}
+
+//
+static inline btMatrix3x3 ImpulseMatrix(btScalar ima, const btMatrix3x3& iia, const btVector3& ra,
+										btScalar imb, const btMatrix3x3& iib, const btVector3& rb)
+{
+	return (Add(MassMatrix(ima, iia, ra), MassMatrix(imb, iib, rb)).inverse());
+}
+
+//
+static inline btMatrix3x3 AngularImpulseMatrix(const btMatrix3x3& iia,
+											   const btMatrix3x3& iib)
+{
+	return (Add(iia, iib).inverse());
+}
+
+//
+static inline btVector3 ProjectOnAxis(const btVector3& v,
+									  const btVector3& a)
+{
+	return (a * btDot(v, a));
+}
+//
+static inline btVector3 ProjectOnPlane(const btVector3& v,
+									   const btVector3& a)
+{
+	return (v - ProjectOnAxis(v, a));
+}
+
+//
+static inline void ProjectOrigin(const btVector3& a,
+								 const btVector3& b,
+								 btVector3& prj,
+								 btScalar& sqd)
+{
+	const btVector3 d = b - a;
+	const btScalar m2 = d.length2();
+	if (m2 > SIMD_EPSILON)
+	{
+		const btScalar t = Clamp<btScalar>(-btDot(a, d) / m2, 0, 1);
+		const btVector3 p = a + d * t;
+		const btScalar l2 = p.length2();
+		if (l2 < sqd)
+		{
+			prj = p;
+			sqd = l2;
+		}
+	}
+}
+//
+static inline void ProjectOrigin(const btVector3& a,
+								 const btVector3& b,
+								 const btVector3& c,
+								 btVector3& prj,
+								 btScalar& sqd)
+{
+	const btVector3& q = btCross(b - a, c - a);
+	const btScalar m2 = q.length2();
+	if (m2 > SIMD_EPSILON)
+	{
+		const btVector3 n = q / btSqrt(m2);
+		const btScalar k = btDot(a, n);
+		const btScalar k2 = k * k;
+		if (k2 < sqd)
+		{
+			const btVector3 p = n * k;
+			if ((btDot(btCross(a - p, b - p), q) > 0) &&
+				(btDot(btCross(b - p, c - p), q) > 0) &&
+				(btDot(btCross(c - p, a - p), q) > 0))
+			{
+				prj = p;
+				sqd = k2;
+			}
+			else
+			{
+				ProjectOrigin(a, b, prj, sqd);
+				ProjectOrigin(b, c, prj, sqd);
+				ProjectOrigin(c, a, prj, sqd);
+			}
+		}
+	}
+}
+
+//
+static inline bool rayIntersectsTriangle(const btVector3& origin, const btVector3& dir, const btVector3& v0, const btVector3& v1, const btVector3& v2, btScalar& t)
+{
+	btScalar a, f, u, v;
+
+	btVector3 e1 = v1 - v0;
+	btVector3 e2 = v2 - v0;
+	btVector3 h = dir.cross(e2);
+	a = e1.dot(h);
+
+	if (a > -0.00001 && a < 0.00001)
+		return (false);
+
+	f = btScalar(1) / a;
+	btVector3 s = origin - v0;
+	u = f * s.dot(h);
+
+	if (u < 0.0 || u > 1.0)
+		return (false);
+
+	btVector3 q = s.cross(e1);
+	v = f * dir.dot(q);
+	if (v < 0.0 || u + v > 1.0)
+		return (false);
+	// at this stage we can compute t to find out where
+	// the intersection point is on the line
+	t = f * e2.dot(q);
+	if (t > 0)  // ray intersection
+		return (true);
+	else  // this means that there is a line intersection
+		// but not a ray intersection
+		return (false);
+}
+
+static inline bool lineIntersectsTriangle(const btVector3& rayStart, const btVector3& rayEnd, const btVector3& p1, const btVector3& p2, const btVector3& p3, btVector3& sect, btVector3& normal)
+{
+	btVector3 dir = rayEnd - rayStart;
+	btScalar dir_norm = dir.norm();
+	if (dir_norm < SIMD_EPSILON)
+		return false;
+	dir.normalize();
+	btScalar t;
+	bool ret = rayIntersectsTriangle(rayStart, dir, p1, p2, p3, t);
+
+	if (ret)
+	{
+		if (t <= dir_norm)
+		{
+			sect = rayStart + dir * t;
+		}
+		else
+		{
+			ret = false;
+		}
+	}
+
+	if (ret)
+	{
+		btVector3 n = (p3 - p1).cross(p2 - p1);
+		n.safeNormalize();
+		if (n.dot(dir) < 0)
+			normal = n;
+		else
+			normal = -n;
+	}
+	return ret;
+}
+
+//
+template <typename T>
+static inline T BaryEval(const T& a,
+						 const T& b,
+						 const T& c,
+						 const btVector3& coord)
+{
+	return (a * coord.x() + b * coord.y() + c * coord.z());
+}
+//
+static inline btVector3 BaryCoord(const btVector3& a,
+								  const btVector3& b,
+								  const btVector3& c,
+								  const btVector3& p)
+{
+	const btScalar w[] = {btCross(a - p, b - p).length(),
+						  btCross(b - p, c - p).length(),
+						  btCross(c - p, a - p).length()};
+	const btScalar isum = 1 / (w[0] + w[1] + w[2]);
+	return (btVector3(w[1] * isum, w[2] * isum, w[0] * isum));
+}
+
+//
+inline static btScalar ImplicitSolve(btSoftBody::ImplicitFn* fn,
+									 const btVector3& a,
+									 const btVector3& b,
+									 const btScalar accuracy,
+									 const int maxiterations = 256)
+{
+	btScalar span[2] = {0, 1};
+	btScalar values[2] = {fn->Eval(a), fn->Eval(b)};
+	if (values[0] > values[1])
+	{
+		btSwap(span[0], span[1]);
+		btSwap(values[0], values[1]);
+	}
+	if (values[0] > -accuracy) return (-1);
+	if (values[1] < +accuracy) return (-1);
+	for (int i = 0; i < maxiterations; ++i)
+	{
+		const btScalar t = Lerp(span[0], span[1], values[0] / (values[0] - values[1]));
+		const btScalar v = fn->Eval(Lerp(a, b, t));
+		if ((t <= 0) || (t >= 1)) break;
+		if (btFabs(v) < accuracy) return (t);
+		if (v < 0)
+		{
+			span[0] = t;
+			values[0] = v;
+		}
+		else
+		{
+			span[1] = t;
+			values[1] = v;
+		}
+	}
+	return (-1);
+}
+
+inline static void EvaluateMedium(const btSoftBodyWorldInfo* wfi,
+								  const btVector3& x,
+								  btSoftBody::sMedium& medium)
+{
+	medium.m_velocity = btVector3(0, 0, 0);
+	medium.m_pressure = 0;
+	medium.m_density = wfi->air_density;
+	if (wfi->water_density > 0)
+	{
+		const btScalar depth = -(btDot(x, wfi->water_normal) + wfi->water_offset);
+		if (depth > 0)
+		{
+			medium.m_density = wfi->water_density;
+			medium.m_pressure = depth * wfi->water_density * wfi->m_gravity.length();
+		}
+	}
+}
+
+//
+static inline btVector3 NormalizeAny(const btVector3& v)
+{
+	const btScalar l = v.length();
+	if (l > SIMD_EPSILON)
+		return (v / l);
+	else
+		return (btVector3(0, 0, 0));
+}
+
+//
+static inline btDbvtVolume VolumeOf(const btSoftBody::Face& f,
+									btScalar margin)
+{
+	const btVector3* pts[] = {&f.m_n[0]->m_x,
+							  &f.m_n[1]->m_x,
+							  &f.m_n[2]->m_x};
+	btDbvtVolume vol = btDbvtVolume::FromPoints(pts, 3);
+	vol.Expand(btVector3(margin, margin, margin));
+	return (vol);
+}
+
+//
+static inline btVector3 CenterOf(const btSoftBody::Face& f)
+{
+	return ((f.m_n[0]->m_x + f.m_n[1]->m_x + f.m_n[2]->m_x) / 3);
+}
+
+//
+static inline btScalar AreaOf(const btVector3& x0,
+							  const btVector3& x1,
+							  const btVector3& x2)
+{
+	const btVector3 a = x1 - x0;
+	const btVector3 b = x2 - x0;
+	const btVector3 cr = btCross(a, b);
+	const btScalar area = cr.length();
+	return (area);
+}
+
+//
+static inline btScalar VolumeOf(const btVector3& x0,
+								const btVector3& x1,
+								const btVector3& x2,
+								const btVector3& x3)
+{
+	const btVector3 a = x1 - x0;
+	const btVector3 b = x2 - x0;
+	const btVector3 c = x3 - x0;
+	return (btDot(a, btCross(b, c)));
+}
+
+//
+
+//
+static inline void ApplyClampedForce(btSoftBody::Node& n,
+									 const btVector3& f,
+									 btScalar dt)
+{
+	const btScalar dtim = dt * n.m_im;
+	if ((f * dtim).length2() > n.m_v.length2())
+	{ /* Clamp	*/
+		n.m_f -= ProjectOnAxis(n.m_v, f.normalized()) / dtim;
+	}
+	else
+	{ /* Apply	*/
+		n.m_f += f;
+	}
+}
+
+//
+static inline int MatchEdge(const btSoftBody::Node* a,
+							const btSoftBody::Node* b,
+							const btSoftBody::Node* ma,
+							const btSoftBody::Node* mb)
+{
+	if ((a == ma) && (b == mb)) return (0);
+	if ((a == mb) && (b == ma)) return (1);
+	return (-1);
+}
+
+//
+// btEigen : Extract eigen system,
+// straitforward implementation of http://math.fullerton.edu/mathews/n2003/JacobiMethodMod.html
+// outputs are NOT sorted.
+//
+struct btEigen
+{
+	static int system(btMatrix3x3& a, btMatrix3x3* vectors, btVector3* values = 0)
+	{
+		static const int maxiterations = 16;
+		static const btScalar accuracy = (btScalar)0.0001;
+		btMatrix3x3& v = *vectors;
+		int iterations = 0;
+		vectors->setIdentity();
+		do
+		{
+			int p = 0, q = 1;
+			if (btFabs(a[p][q]) < btFabs(a[0][2]))
+			{
+				p = 0;
+				q = 2;
+			}
+			if (btFabs(a[p][q]) < btFabs(a[1][2]))
+			{
+				p = 1;
+				q = 2;
+			}
+			if (btFabs(a[p][q]) > accuracy)
+			{
+				const btScalar w = (a[q][q] - a[p][p]) / (2 * a[p][q]);
+				const btScalar z = btFabs(w);
+				const btScalar t = w / (z * (btSqrt(1 + w * w) + z));
+				if (t == t) /* [WARNING] let hope that one does not get thrown aways by some compilers... */
+				{
+					const btScalar c = 1 / btSqrt(t * t + 1);
+					const btScalar s = c * t;
+					mulPQ(a, c, s, p, q);
+					mulTPQ(a, c, s, p, q);
+					mulPQ(v, c, s, p, q);
+				}
+				else
+					break;
+			}
+			else
+				break;
+		} while ((++iterations) < maxiterations);
+		if (values)
+		{
+			*values = btVector3(a[0][0], a[1][1], a[2][2]);
+		}
+		return (iterations);
+	}
+
+private:
+	static inline void mulTPQ(btMatrix3x3& a, btScalar c, btScalar s, int p, int q)
+	{
+		const btScalar m[2][3] = {{a[p][0], a[p][1], a[p][2]},
+								  {a[q][0], a[q][1], a[q][2]}};
+		int i;
+
+		for (i = 0; i < 3; ++i) a[p][i] = c * m[0][i] - s * m[1][i];
+		for (i = 0; i < 3; ++i) a[q][i] = c * m[1][i] + s * m[0][i];
+	}
+	static inline void mulPQ(btMatrix3x3& a, btScalar c, btScalar s, int p, int q)
+	{
+		const btScalar m[2][3] = {{a[0][p], a[1][p], a[2][p]},
+								  {a[0][q], a[1][q], a[2][q]}};
+		int i;
+
+		for (i = 0; i < 3; ++i) a[i][p] = c * m[0][i] - s * m[1][i];
+		for (i = 0; i < 3; ++i) a[i][q] = c * m[1][i] + s * m[0][i];
+	}
+};
+
+//
+// Polar decomposition,
+// "Computing the Polar Decomposition with Applications", Nicholas J. Higham, 1986.
+//
+static inline int PolarDecompose(const btMatrix3x3& m, btMatrix3x3& q, btMatrix3x3& s)
+{
+	static const btPolarDecomposition polar;
+	return polar.decompose(m, q, s);
+}
+
+//
+// btSoftColliders
+//
+struct btSoftColliders
+{
+	//
+	// ClusterBase
+	//
+	struct ClusterBase : btDbvt::ICollide
+	{
+		btScalar erp;
+		btScalar idt;
+		btScalar m_margin;
+		btScalar friction;
+		btScalar threshold;
+		ClusterBase()
+		{
+			erp = (btScalar)1;
+			idt = 0;
+			m_margin = 0;
+			friction = 0;
+			threshold = (btScalar)0;
+		}
+		bool SolveContact(const btGjkEpaSolver2::sResults& res,
+						  btSoftBody::Body ba, const btSoftBody::Body bb,
+						  btSoftBody::CJoint& joint)
+		{
+			if (res.distance < m_margin)
+			{
+				btVector3 norm = res.normal;
+				norm.normalize();  //is it necessary?
+
+				const btVector3 ra = res.witnesses[0] - ba.xform().getOrigin();
+				const btVector3 rb = res.witnesses[1] - bb.xform().getOrigin();
+				const btVector3 va = ba.velocity(ra);
+				const btVector3 vb = bb.velocity(rb);
+				const btVector3 vrel = va - vb;
+				const btScalar rvac = btDot(vrel, norm);
+				btScalar depth = res.distance - m_margin;
+
+				//				printf("depth=%f\n",depth);
+				const btVector3 iv = norm * rvac;
+				const btVector3 fv = vrel - iv;
+				joint.m_bodies[0] = ba;
+				joint.m_bodies[1] = bb;
+				joint.m_refs[0] = ra * ba.xform().getBasis();
+				joint.m_refs[1] = rb * bb.xform().getBasis();
+				joint.m_rpos[0] = ra;
+				joint.m_rpos[1] = rb;
+				joint.m_cfm = 1;
+				joint.m_erp = 1;
+				joint.m_life = 0;
+				joint.m_maxlife = 0;
+				joint.m_split = 1;
+
+				joint.m_drift = depth * norm;
+
+				joint.m_normal = norm;
+				//				printf("normal=%f,%f,%f\n",res.normal.getX(),res.normal.getY(),res.normal.getZ());
+				joint.m_delete = false;
+				joint.m_friction = fv.length2() < (rvac * friction * rvac * friction) ? 1 : friction;
+				joint.m_massmatrix = ImpulseMatrix(ba.invMass(), ba.invWorldInertia(), joint.m_rpos[0],
+												   bb.invMass(), bb.invWorldInertia(), joint.m_rpos[1]);
+
+				return (true);
+			}
+			return (false);
+		}
+	};
+	//
+	// CollideCL_RS
+	//
+	struct CollideCL_RS : ClusterBase
+	{
+		btSoftBody* psb;
+		const btCollisionObjectWrapper* m_colObjWrap;
+
+		void Process(const btDbvtNode* leaf)
+		{
+			btSoftBody::Cluster* cluster = (btSoftBody::Cluster*)leaf->data;
+			btSoftClusterCollisionShape cshape(cluster);
+
+			const btConvexShape* rshape = (const btConvexShape*)m_colObjWrap->getCollisionShape();
+
+			///don't collide an anchored cluster with a static/kinematic object
+			if (m_colObjWrap->getCollisionObject()->isStaticOrKinematicObject() && cluster->m_containsAnchor)
+				return;
+
+			btGjkEpaSolver2::sResults res;
+			if (btGjkEpaSolver2::SignedDistance(&cshape, btTransform::getIdentity(),
+												rshape, m_colObjWrap->getWorldTransform(),
+												btVector3(1, 0, 0), res))
+			{
+				btSoftBody::CJoint joint;
+				if (SolveContact(res, cluster, m_colObjWrap->getCollisionObject(), joint))  //prb,joint))
+				{
+					btSoftBody::CJoint* pj = new (btAlignedAlloc(sizeof(btSoftBody::CJoint), 16)) btSoftBody::CJoint();
+					*pj = joint;
+					psb->m_joints.push_back(pj);
+					if (m_colObjWrap->getCollisionObject()->isStaticOrKinematicObject())
+					{
+						pj->m_erp *= psb->m_cfg.kSKHR_CL;
+						pj->m_split *= psb->m_cfg.kSK_SPLT_CL;
+					}
+					else
+					{
+						pj->m_erp *= psb->m_cfg.kSRHR_CL;
+						pj->m_split *= psb->m_cfg.kSR_SPLT_CL;
+					}
+				}
+			}
+		}
+		void ProcessColObj(btSoftBody* ps, const btCollisionObjectWrapper* colObWrap)
+		{
+			psb = ps;
+			m_colObjWrap = colObWrap;
+			idt = ps->m_sst.isdt;
+			m_margin = m_colObjWrap->getCollisionShape()->getMargin() + psb->getCollisionShape()->getMargin();
+			///Bullet rigid body uses multiply instead of minimum to determine combined friction. Some customization would be useful.
+			friction = btMin(psb->m_cfg.kDF, m_colObjWrap->getCollisionObject()->getFriction());
+			btVector3 mins;
+			btVector3 maxs;
+
+			ATTRIBUTE_ALIGNED16(btDbvtVolume)
+			volume;
+			colObWrap->getCollisionShape()->getAabb(colObWrap->getWorldTransform(), mins, maxs);
+			volume = btDbvtVolume::FromMM(mins, maxs);
+			volume.Expand(btVector3(1, 1, 1) * m_margin);
+			ps->m_cdbvt.collideTV(ps->m_cdbvt.m_root, volume, *this);
+		}
+	};
+	//
+	// CollideCL_SS
+	//
+	struct CollideCL_SS : ClusterBase
+	{
+		btSoftBody* bodies[2];
+		void Process(const btDbvtNode* la, const btDbvtNode* lb)
+		{
+			btSoftBody::Cluster* cla = (btSoftBody::Cluster*)la->data;
+			btSoftBody::Cluster* clb = (btSoftBody::Cluster*)lb->data;
+
+			bool connected = false;
+			if ((bodies[0] == bodies[1]) && (bodies[0]->m_clusterConnectivity.size()))
+			{
+				connected = bodies[0]->m_clusterConnectivity[cla->m_clusterIndex + bodies[0]->m_clusters.size() * clb->m_clusterIndex];
+			}
+
+			if (!connected)
+			{
+				btSoftClusterCollisionShape csa(cla);
+				btSoftClusterCollisionShape csb(clb);
+				btGjkEpaSolver2::sResults res;
+				if (btGjkEpaSolver2::SignedDistance(&csa, btTransform::getIdentity(),
+													&csb, btTransform::getIdentity(),
+													cla->m_com - clb->m_com, res))
+				{
+					btSoftBody::CJoint joint;
+					if (SolveContact(res, cla, clb, joint))
+					{
+						btSoftBody::CJoint* pj = new (btAlignedAlloc(sizeof(btSoftBody::CJoint), 16)) btSoftBody::CJoint();
+						*pj = joint;
+						bodies[0]->m_joints.push_back(pj);
+						pj->m_erp *= btMax(bodies[0]->m_cfg.kSSHR_CL, bodies[1]->m_cfg.kSSHR_CL);
+						pj->m_split *= (bodies[0]->m_cfg.kSS_SPLT_CL + bodies[1]->m_cfg.kSS_SPLT_CL) / 2;
+					}
+				}
+			}
+			else
+			{
+				static int count = 0;
+				count++;
+				//printf("count=%d\n",count);
+			}
+		}
+		void ProcessSoftSoft(btSoftBody* psa, btSoftBody* psb)
+		{
+			idt = psa->m_sst.isdt;
+			//m_margin		=	(psa->getCollisionShape()->getMargin()+psb->getCollisionShape()->getMargin())/2;
+			m_margin = (psa->getCollisionShape()->getMargin() + psb->getCollisionShape()->getMargin());
+			friction = btMin(psa->m_cfg.kDF, psb->m_cfg.kDF);
+			bodies[0] = psa;
+			bodies[1] = psb;
+			psa->m_cdbvt.collideTT(psa->m_cdbvt.m_root, psb->m_cdbvt.m_root, *this);
+		}
+	};
+	//
+	// CollideSDF_RS
+	//
+	struct CollideSDF_RS : btDbvt::ICollide
+	{
+		void Process(const btDbvtNode* leaf)
+		{
+			btSoftBody::Node* node = (btSoftBody::Node*)leaf->data;
+			DoNode(*node);
+		}
+		void DoNode(btSoftBody::Node& n) const
+		{
+			const btScalar m = n.m_im > 0 ? dynmargin : stamargin;
+			btSoftBody::RContact c;
+
+			if ((!n.m_battach) &&
+				psb->checkContact(m_colObj1Wrap, n.m_x, m, c.m_cti))
+			{
+				const btScalar ima = n.m_im;
+				const btScalar imb = m_rigidBody ? m_rigidBody->getInvMass() : 0.f;
+				const btScalar ms = ima + imb;
+				if (ms > 0)
+				{
+					const btTransform& wtr = m_rigidBody ? m_rigidBody->getWorldTransform() : m_colObj1Wrap->getCollisionObject()->getWorldTransform();
+					static const btMatrix3x3 iwiStatic(0, 0, 0, 0, 0, 0, 0, 0, 0);
+					const btMatrix3x3& iwi = m_rigidBody ? m_rigidBody->getInvInertiaTensorWorld() : iwiStatic;
+					const btVector3 ra = n.m_x - wtr.getOrigin();
+					const btVector3 va = m_rigidBody ? m_rigidBody->getVelocityInLocalPoint(ra) * psb->m_sst.sdt : btVector3(0, 0, 0);
+					const btVector3 vb = n.m_x - n.m_q;
+					const btVector3 vr = vb - va;
+					const btScalar dn = btDot(vr, c.m_cti.m_normal);
+					const btVector3 fv = vr - c.m_cti.m_normal * dn;
+					const btScalar fc = psb->m_cfg.kDF * m_colObj1Wrap->getCollisionObject()->getFriction();
+					c.m_node = &n;
+					c.m_c0 = ImpulseMatrix(psb->m_sst.sdt, ima, imb, iwi, ra);
+					c.m_c1 = ra;
+					c.m_c2 = ima * psb->m_sst.sdt;
+					c.m_c3 = fv.length2() < (dn * fc * dn * fc) ? 0 : 1 - fc;
+					c.m_c4 = m_colObj1Wrap->getCollisionObject()->isStaticOrKinematicObject() ? psb->m_cfg.kKHR : psb->m_cfg.kCHR;
+					psb->m_rcontacts.push_back(c);
+					if (m_rigidBody)
+						m_rigidBody->activate();
+				}
+			}
+		}
+		btSoftBody* psb;
+		const btCollisionObjectWrapper* m_colObj1Wrap;
+		btRigidBody* m_rigidBody;
+		btScalar dynmargin;
+		btScalar stamargin;
+	};
+
+	//
+	// CollideSDF_RD
+	//
+	struct CollideSDF_RD : btDbvt::ICollide
+	{
+		void Process(const btDbvtNode* leaf)
+		{
+			btSoftBody::Node* node = (btSoftBody::Node*)leaf->data;
+			DoNode(*node);
+		}
+		void DoNode(btSoftBody::Node& n) const
+		{
+			const btScalar m = n.m_im > 0 ? dynmargin : stamargin;
+			btSoftBody::DeformableNodeRigidContact c;
+
+			if (!n.m_battach)
+			{
+				// check for collision at x_{n+1}^*
+				if (psb->checkDeformableContact(m_colObj1Wrap, n.m_q, m, c.m_cti, /*predict = */ true))
+				{
+					const btScalar ima = n.m_im;
+					// todo: collision between multibody and fixed deformable node will be missed.
+					const btScalar imb = m_rigidBody ? m_rigidBody->getInvMass() : 0.f;
+					const btScalar ms = ima + imb;
+					if (ms > 0)
+					{
+						// resolve contact at x_n
+						psb->checkDeformableContact(m_colObj1Wrap, n.m_x, m, c.m_cti, /*predict = */ false);
+						btSoftBody::sCti& cti = c.m_cti;
+						c.m_node = &n;
+						const btScalar fc = psb->m_cfg.kDF * m_colObj1Wrap->getCollisionObject()->getFriction();
+						c.m_c2 = ima;
+						c.m_c3 = fc;
+						c.m_c4 = m_colObj1Wrap->getCollisionObject()->isStaticOrKinematicObject() ? psb->m_cfg.kKHR : psb->m_cfg.kCHR;
+						c.m_c5 = n.m_effectiveMass_inv;
+
+						if (cti.m_colObj->getInternalType() == btCollisionObject::CO_RIGID_BODY)
+						{
+							const btTransform& wtr = m_rigidBody ? m_rigidBody->getWorldTransform() : m_colObj1Wrap->getCollisionObject()->getWorldTransform();
+							static const btMatrix3x3 iwiStatic(0, 0, 0, 0, 0, 0, 0, 0, 0);
+							const btMatrix3x3& iwi = m_rigidBody ? m_rigidBody->getInvInertiaTensorWorld() : iwiStatic;
+							const btVector3 ra = n.m_x - wtr.getOrigin();
+
+							c.m_c0 = ImpulseMatrix(1, n.m_effectiveMass_inv, imb, iwi, ra);
+							//                            c.m_c0 = ImpulseMatrix(1, ima, imb, iwi, ra);
+							c.m_c1 = ra;
+						}
+						else if (cti.m_colObj->getInternalType() == btCollisionObject::CO_FEATHERSTONE_LINK)
+						{
+							btMultiBodyLinkCollider* multibodyLinkCol = (btMultiBodyLinkCollider*)btMultiBodyLinkCollider::upcast(cti.m_colObj);
+							if (multibodyLinkCol)
+							{
+								btVector3 normal = cti.m_normal;
+								btVector3 t1 = generateUnitOrthogonalVector(normal);
+								btVector3 t2 = btCross(normal, t1);
+								btMultiBodyJacobianData jacobianData_normal, jacobianData_t1, jacobianData_t2;
+								findJacobian(multibodyLinkCol, jacobianData_normal, c.m_node->m_x, normal);
+								findJacobian(multibodyLinkCol, jacobianData_t1, c.m_node->m_x, t1);
+								findJacobian(multibodyLinkCol, jacobianData_t2, c.m_node->m_x, t2);
+
+								btScalar* J_n = &jacobianData_normal.m_jacobians[0];
+								btScalar* J_t1 = &jacobianData_t1.m_jacobians[0];
+								btScalar* J_t2 = &jacobianData_t2.m_jacobians[0];
+
+								btScalar* u_n = &jacobianData_normal.m_deltaVelocitiesUnitImpulse[0];
+								btScalar* u_t1 = &jacobianData_t1.m_deltaVelocitiesUnitImpulse[0];
+								btScalar* u_t2 = &jacobianData_t2.m_deltaVelocitiesUnitImpulse[0];
+
+								btMatrix3x3 rot(normal.getX(), normal.getY(), normal.getZ(),
+												t1.getX(), t1.getY(), t1.getZ(),
+												t2.getX(), t2.getY(), t2.getZ());  // world frame to local frame
+								const int ndof = multibodyLinkCol->m_multiBody->getNumDofs() + 6;
+								btMatrix3x3 local_impulse_matrix = (n.m_effectiveMass_inv + OuterProduct(J_n, J_t1, J_t2, u_n, u_t1, u_t2, ndof)).inverse();
+								c.m_c0 = rot.transpose() * local_impulse_matrix * rot;
+								c.jacobianData_normal = jacobianData_normal;
+								c.jacobianData_t1 = jacobianData_t1;
+								c.jacobianData_t2 = jacobianData_t2;
+								c.t1 = t1;
+								c.t2 = t2;
+							}
+						}
+						psb->m_nodeRigidContacts.push_back(c);
+					}
+				}
+			}
+		}
+		btSoftBody* psb;
+		const btCollisionObjectWrapper* m_colObj1Wrap;
+		btRigidBody* m_rigidBody;
+		btScalar dynmargin;
+		btScalar stamargin;
+	};
+
+	//
+	// CollideSDF_RDF
+	//
+	struct CollideSDF_RDF : btDbvt::ICollide
+	{
+		void Process(const btDbvtNode* leaf)
+		{
+			btSoftBody::Face* face = (btSoftBody::Face*)leaf->data;
+			DoNode(*face);
+		}
+		void DoNode(btSoftBody::Face& f) const
+		{
+			btSoftBody::Node* n0 = f.m_n[0];
+			btSoftBody::Node* n1 = f.m_n[1];
+			btSoftBody::Node* n2 = f.m_n[2];
+			const btScalar m = (n0->m_im > 0 && n1->m_im > 0 && n2->m_im > 0) ? dynmargin : stamargin;
+			btSoftBody::DeformableFaceRigidContact c;
+			btVector3 contact_point;
+			btVector3 bary;
+			if (psb->checkDeformableFaceContact(m_colObj1Wrap, f, contact_point, bary, m, c.m_cti, true))
+			{
+				btScalar ima = n0->m_im + n1->m_im + n2->m_im;
+				const btScalar imb = m_rigidBody ? m_rigidBody->getInvMass() : 0.f;
+				// todo: collision between multibody and fixed deformable face will be missed.
+				const btScalar ms = ima + imb;
+				if (ms > 0)
+				{
+					// resolve contact at x_n
+					//                    psb->checkDeformableFaceContact(m_colObj1Wrap, f, contact_point, bary, m, c.m_cti, /*predict = */ false);
+					btSoftBody::sCti& cti = c.m_cti;
+					c.m_contactPoint = contact_point;
+					c.m_bary = bary;
+					// todo xuchenhan@: this is assuming mass of all vertices are the same. Need to modify if mass are different for distinct vertices
+					c.m_weights = btScalar(2) / (btScalar(1) + bary.length2()) * bary;
+					c.m_face = &f;
+					// friction is handled by the nodes to prevent sticking
+					//                    const btScalar fc = 0;
+					const btScalar fc = psb->m_cfg.kDF * m_colObj1Wrap->getCollisionObject()->getFriction();
+
+					// the effective inverse mass of the face as in https://graphics.stanford.edu/papers/cloth-sig02/cloth.pdf
+					ima = bary.getX() * c.m_weights.getX() * n0->m_im + bary.getY() * c.m_weights.getY() * n1->m_im + bary.getZ() * c.m_weights.getZ() * n2->m_im;
+					c.m_c2 = ima;
+					c.m_c3 = fc;
+					c.m_c4 = m_colObj1Wrap->getCollisionObject()->isStaticOrKinematicObject() ? psb->m_cfg.kKHR : psb->m_cfg.kCHR;
+					c.m_c5 = Diagonal(ima);
+					if (cti.m_colObj->getInternalType() == btCollisionObject::CO_RIGID_BODY)
+					{
+						const btTransform& wtr = m_rigidBody ? m_rigidBody->getWorldTransform() : m_colObj1Wrap->getCollisionObject()->getWorldTransform();
+						static const btMatrix3x3 iwiStatic(0, 0, 0, 0, 0, 0, 0, 0, 0);
+						const btMatrix3x3& iwi = m_rigidBody ? m_rigidBody->getInvInertiaTensorWorld() : iwiStatic;
+						const btVector3 ra = contact_point - wtr.getOrigin();
+
+						// we do not scale the impulse matrix by dt
+						c.m_c0 = ImpulseMatrix(1, ima, imb, iwi, ra);
+						c.m_c1 = ra;
+					}
+					else if (cti.m_colObj->getInternalType() == btCollisionObject::CO_FEATHERSTONE_LINK)
+					{
+						btMultiBodyLinkCollider* multibodyLinkCol = (btMultiBodyLinkCollider*)btMultiBodyLinkCollider::upcast(cti.m_colObj);
+						if (multibodyLinkCol)
+						{
+							btVector3 normal = cti.m_normal;
+							btVector3 t1 = generateUnitOrthogonalVector(normal);
+							btVector3 t2 = btCross(normal, t1);
+							btMultiBodyJacobianData jacobianData_normal, jacobianData_t1, jacobianData_t2;
+							findJacobian(multibodyLinkCol, jacobianData_normal, contact_point, normal);
+							findJacobian(multibodyLinkCol, jacobianData_t1, contact_point, t1);
+							findJacobian(multibodyLinkCol, jacobianData_t2, contact_point, t2);
+
+							btScalar* J_n = &jacobianData_normal.m_jacobians[0];
+							btScalar* J_t1 = &jacobianData_t1.m_jacobians[0];
+							btScalar* J_t2 = &jacobianData_t2.m_jacobians[0];
+
+							btScalar* u_n = &jacobianData_normal.m_deltaVelocitiesUnitImpulse[0];
+							btScalar* u_t1 = &jacobianData_t1.m_deltaVelocitiesUnitImpulse[0];
+							btScalar* u_t2 = &jacobianData_t2.m_deltaVelocitiesUnitImpulse[0];
+
+							btMatrix3x3 rot(normal.getX(), normal.getY(), normal.getZ(),
+											t1.getX(), t1.getY(), t1.getZ(),
+											t2.getX(), t2.getY(), t2.getZ());  // world frame to local frame
+							const int ndof = multibodyLinkCol->m_multiBody->getNumDofs() + 6;
+							btMatrix3x3 local_impulse_matrix = (Diagonal(ima) + OuterProduct(J_n, J_t1, J_t2, u_n, u_t1, u_t2, ndof)).inverse();
+							c.m_c0 = rot.transpose() * local_impulse_matrix * rot;
+							c.jacobianData_normal = jacobianData_normal;
+							c.jacobianData_t1 = jacobianData_t1;
+							c.jacobianData_t2 = jacobianData_t2;
+							c.t1 = t1;
+							c.t2 = t2;
+						}
+					}
+					psb->m_faceRigidContacts.push_back(c);
+				}
+			}
+			// Set caching barycenters to be false after collision detection.
+			// Only turn on when contact is static.
+			f.m_pcontact[3] = 0;
+		}
+		btSoftBody* psb;
+		const btCollisionObjectWrapper* m_colObj1Wrap;
+		btRigidBody* m_rigidBody;
+		btScalar dynmargin;
+		btScalar stamargin;
+	};
+
+	//
+	// CollideVF_SS
+	//
+	struct CollideVF_SS : btDbvt::ICollide
+	{
+		void Process(const btDbvtNode* lnode,
+					 const btDbvtNode* lface)
+		{
+			btSoftBody::Node* node = (btSoftBody::Node*)lnode->data;
+			btSoftBody::Face* face = (btSoftBody::Face*)lface->data;
+			for (int i = 0; i < 3; ++i)
+			{
+				if (face->m_n[i] == node)
+					continue;
+			}
+
+			btVector3 o = node->m_x;
+			btVector3 p;
+			btScalar d = SIMD_INFINITY;
+			ProjectOrigin(face->m_n[0]->m_x - o,
+						  face->m_n[1]->m_x - o,
+						  face->m_n[2]->m_x - o,
+						  p, d);
+			const btScalar m = mrg + (o - node->m_q).length() * 2;
+			if (d < (m * m))
+			{
+				const btSoftBody::Node* n[] = {face->m_n[0], face->m_n[1], face->m_n[2]};
+				const btVector3 w = BaryCoord(n[0]->m_x, n[1]->m_x, n[2]->m_x, p + o);
+				const btScalar ma = node->m_im;
+				btScalar mb = BaryEval(n[0]->m_im, n[1]->m_im, n[2]->m_im, w);
+				if ((n[0]->m_im <= 0) ||
+					(n[1]->m_im <= 0) ||
+					(n[2]->m_im <= 0))
+				{
+					mb = 0;
+				}
+				const btScalar ms = ma + mb;
+				if (ms > 0)
+				{
+					btSoftBody::SContact c;
+					c.m_normal = p / -btSqrt(d);
+					c.m_margin = m;
+					c.m_node = node;
+					c.m_face = face;
+					c.m_weights = w;
+					c.m_friction = btMax(psb[0]->m_cfg.kDF, psb[1]->m_cfg.kDF);
+					c.m_cfm[0] = ma / ms * psb[0]->m_cfg.kSHR;
+					c.m_cfm[1] = mb / ms * psb[1]->m_cfg.kSHR;
+					psb[0]->m_scontacts.push_back(c);
+				}
+			}
+		}
+		btSoftBody* psb[2];
+		btScalar mrg;
+	};
+
+	//
+	// CollideVF_DD
+	//
+	struct CollideVF_DD : btDbvt::ICollide
+	{
+		void Process(const btDbvtNode* lnode,
+					 const btDbvtNode* lface)
+		{
+			btSoftBody::Node* node = (btSoftBody::Node*)lnode->data;
+			btSoftBody::Face* face = (btSoftBody::Face*)lface->data;
+			btVector3 bary;
+			if (proximityTest(face->m_n[0]->m_x, face->m_n[1]->m_x, face->m_n[2]->m_x, node->m_x, face->m_normal, mrg, bary))
+			{
+				const btSoftBody::Node* n[] = {face->m_n[0], face->m_n[1], face->m_n[2]};
+				const btVector3 w = bary;
+				const btScalar ma = node->m_im;
+				btScalar mb = BaryEval(n[0]->m_im, n[1]->m_im, n[2]->m_im, w);
+				if ((n[0]->m_im <= 0) ||
+					(n[1]->m_im <= 0) ||
+					(n[2]->m_im <= 0))
+				{
+					mb = 0;
+				}
+				const btScalar ms = ma + mb;
+				if (ms > 0)
+				{
+					btSoftBody::DeformableFaceNodeContact c;
+					c.m_normal = face->m_normal;
+					if (!useFaceNormal && c.m_normal.dot(node->m_x - face->m_n[2]->m_x) < 0)
+						c.m_normal = -face->m_normal;
+					c.m_margin = mrg;
+					c.m_node = node;
+					c.m_face = face;
+					c.m_bary = w;
+					c.m_friction = psb[0]->m_cfg.kDF * psb[1]->m_cfg.kDF;
+					psb[0]->m_faceNodeContacts.push_back(c);
+				}
+			}
+		}
+		btSoftBody* psb[2];
+		btScalar mrg;
+		bool useFaceNormal;
+	};
+
+	//
+	// CollideFF_DD
+	//
+	struct CollideFF_DD : btDbvt::ICollide
+	{
+		void Process(const btDbvntNode* lface1,
+					 const btDbvntNode* lface2)
+		{
+			btSoftBody::Face* f1 = (btSoftBody::Face*)lface1->data;
+			btSoftBody::Face* f2 = (btSoftBody::Face*)lface2->data;
+			if (f1 != f2)
+			{
+				Repel(f1, f2);
+				Repel(f2, f1);
+			}
+		}
+		void Repel(btSoftBody::Face* f1, btSoftBody::Face* f2)
+		{
+			//#define REPEL_NEIGHBOR 1
+#ifndef REPEL_NEIGHBOR
+			for (int node_id = 0; node_id < 3; ++node_id)
+			{
+				btSoftBody::Node* node = f1->m_n[node_id];
+				for (int i = 0; i < 3; ++i)
+				{
+					if (f2->m_n[i] == node)
+						return;
+				}
+			}
+#endif
+			bool skip = false;
+			for (int node_id = 0; node_id < 3; ++node_id)
+			{
+				btSoftBody::Node* node = f1->m_n[node_id];
+#ifdef REPEL_NEIGHBOR
+				for (int i = 0; i < 3; ++i)
+				{
+					if (f2->m_n[i] == node)
+					{
+						skip = true;
+						break;
+					}
+				}
+				if (skip)
+				{
+					skip = false;
+					continue;
+				}
+#endif
+				btSoftBody::Face* face = f2;
+				btVector3 bary;
+				if (!proximityTest(face->m_n[0]->m_x, face->m_n[1]->m_x, face->m_n[2]->m_x, node->m_x, face->m_normal, mrg, bary))
+					continue;
+				btSoftBody::DeformableFaceNodeContact c;
+				c.m_normal = face->m_normal;
+				if (!useFaceNormal && c.m_normal.dot(node->m_x - face->m_n[2]->m_x) < 0)
+					c.m_normal = -face->m_normal;
+				c.m_margin = mrg;
+				c.m_node = node;
+				c.m_face = face;
+				c.m_bary = bary;
+				c.m_friction = psb[0]->m_cfg.kDF * psb[1]->m_cfg.kDF;
+				psb[0]->m_faceNodeContacts.push_back(c);
+			}
+		}
+		btSoftBody* psb[2];
+		btScalar mrg;
+		bool useFaceNormal;
+	};
+
+	struct CollideCCD : btDbvt::ICollide
+	{
+		void Process(const btDbvtNode* lnode,
+					 const btDbvtNode* lface)
+		{
+			btSoftBody::Node* node = (btSoftBody::Node*)lnode->data;
+			btSoftBody::Face* face = (btSoftBody::Face*)lface->data;
+			btVector3 bary;
+			if (bernsteinCCD(face, node, dt, SAFE_EPSILON, bary))
+			{
+				btSoftBody::DeformableFaceNodeContact c;
+				c.m_normal = face->m_normal;
+				if (!useFaceNormal && c.m_normal.dot(node->m_x - face->m_n[2]->m_x) < 0)
+					c.m_normal = -face->m_normal;
+				c.m_node = node;
+				c.m_face = face;
+				c.m_bary = bary;
+				c.m_friction = psb[0]->m_cfg.kDF * psb[1]->m_cfg.kDF;
+				psb[0]->m_faceNodeContacts.push_back(c);
+			}
+		}
+		void Process(const btDbvntNode* lface1,
+					 const btDbvntNode* lface2)
+		{
+			btSoftBody::Face* f1 = (btSoftBody::Face*)lface1->data;
+			btSoftBody::Face* f2 = (btSoftBody::Face*)lface2->data;
+			if (f1 != f2)
+			{
+				Repel(f1, f2);
+				Repel(f2, f1);
+			}
+		}
+		void Repel(btSoftBody::Face* f1, btSoftBody::Face* f2)
+		{
+			//#define REPEL_NEIGHBOR 1
+#ifndef REPEL_NEIGHBOR
+			for (int node_id = 0; node_id < 3; ++node_id)
+			{
+				btSoftBody::Node* node = f1->m_n[node_id];
+				for (int i = 0; i < 3; ++i)
+				{
+					if (f2->m_n[i] == node)
+						return;
+				}
+			}
+#endif
+			bool skip = false;
+			for (int node_id = 0; node_id < 3; ++node_id)
+			{
+				btSoftBody::Node* node = f1->m_n[node_id];
+#ifdef REPEL_NEIGHBOR
+				for (int i = 0; i < 3; ++i)
+				{
+					if (f2->m_n[i] == node)
+					{
+						skip = true;
+						break;
+					}
+				}
+				if (skip)
+				{
+					skip = false;
+					continue;
+				}
+#endif
+				btSoftBody::Face* face = f2;
+				btVector3 bary;
+				if (bernsteinCCD(face, node, dt, SAFE_EPSILON, bary))
+				{
+					btSoftBody::DeformableFaceNodeContact c;
+					c.m_normal = face->m_normal;
+					if (!useFaceNormal && c.m_normal.dot(node->m_x - face->m_n[2]->m_x) < 0)
+						c.m_normal = -face->m_normal;
+					c.m_node = node;
+					c.m_face = face;
+					c.m_bary = bary;
+					c.m_friction = psb[0]->m_cfg.kDF * psb[1]->m_cfg.kDF;
+					psb[0]->m_faceNodeContacts.push_back(c);
+				}
+			}
+		}
+		btSoftBody* psb[2];
+		btScalar dt, mrg;
+		bool useFaceNormal;
+	};
+};
+#endif  //_BT_SOFT_BODY_INTERNALS_H
diff --git a/engine/inc/bullet/BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.h b/engine/inc/bullet/BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.h
new file mode 100644
index 00000000..0396a52d
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.h
@@ -0,0 +1,43 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SOFTBODY_RIGIDBODY_COLLISION_CONFIGURATION
+#define BT_SOFTBODY_RIGIDBODY_COLLISION_CONFIGURATION
+
+#include "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h"
+
+class btVoronoiSimplexSolver;
+class btGjkEpaPenetrationDepthSolver;
+
+///btSoftBodyRigidBodyCollisionConfiguration add softbody interaction on top of btDefaultCollisionConfiguration
+class btSoftBodyRigidBodyCollisionConfiguration : public btDefaultCollisionConfiguration
+{
+	//default CreationFunctions, filling the m_doubleDispatch table
+	btCollisionAlgorithmCreateFunc* m_softSoftCreateFunc;
+	btCollisionAlgorithmCreateFunc* m_softRigidConvexCreateFunc;
+	btCollisionAlgorithmCreateFunc* m_swappedSoftRigidConvexCreateFunc;
+	btCollisionAlgorithmCreateFunc* m_softRigidConcaveCreateFunc;
+	btCollisionAlgorithmCreateFunc* m_swappedSoftRigidConcaveCreateFunc;
+
+public:
+	btSoftBodyRigidBodyCollisionConfiguration(const btDefaultCollisionConstructionInfo& constructionInfo = btDefaultCollisionConstructionInfo());
+
+	virtual ~btSoftBodyRigidBodyCollisionConfiguration();
+
+	///creation of soft-soft and soft-rigid, and otherwise fallback to base class implementation
+	virtual btCollisionAlgorithmCreateFunc* getCollisionAlgorithmCreateFunc(int proxyType0, int proxyType1);
+};
+
+#endif  //BT_SOFTBODY_RIGIDBODY_COLLISION_CONFIGURATION
diff --git a/engine/inc/bullet/BulletSoftBody/btSoftBodySolverVertexBuffer.h b/engine/inc/bullet/BulletSoftBody/btSoftBodySolverVertexBuffer.h
new file mode 100644
index 00000000..bc538db4
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btSoftBodySolverVertexBuffer.h
@@ -0,0 +1,160 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SOFT_BODY_SOLVER_VERTEX_BUFFER_H
+#define BT_SOFT_BODY_SOLVER_VERTEX_BUFFER_H
+
+class btVertexBufferDescriptor
+{
+public:
+	enum BufferTypes
+	{
+		CPU_BUFFER,
+		DX11_BUFFER,
+		OPENGL_BUFFER
+	};
+
+protected:
+	bool m_hasVertexPositions;
+	bool m_hasNormals;
+
+	int m_vertexOffset;
+	int m_vertexStride;
+
+	int m_normalOffset;
+	int m_normalStride;
+
+public:
+	btVertexBufferDescriptor()
+	{
+		m_hasVertexPositions = false;
+		m_hasNormals = false;
+		m_vertexOffset = 0;
+		m_vertexStride = 0;
+		m_normalOffset = 0;
+		m_normalStride = 0;
+	}
+
+	virtual ~btVertexBufferDescriptor()
+	{
+	}
+
+	virtual bool hasVertexPositions() const
+	{
+		return m_hasVertexPositions;
+	}
+
+	virtual bool hasNormals() const
+	{
+		return m_hasNormals;
+	}
+
+	/**
+	 * Return the type of the vertex buffer descriptor.
+	 */
+	virtual BufferTypes getBufferType() const = 0;
+
+	/**
+	 * Return the vertex offset in floats from the base pointer.
+	 */
+	virtual int getVertexOffset() const
+	{
+		return m_vertexOffset;
+	}
+
+	/**
+	 * Return the vertex stride in number of floats between vertices.
+	 */
+	virtual int getVertexStride() const
+	{
+		return m_vertexStride;
+	}
+
+	/**
+	 * Return the vertex offset in floats from the base pointer.
+	 */
+	virtual int getNormalOffset() const
+	{
+		return m_normalOffset;
+	}
+
+	/**
+	 * Return the vertex stride in number of floats between vertices.
+	 */
+	virtual int getNormalStride() const
+	{
+		return m_normalStride;
+	}
+};
+
+class btCPUVertexBufferDescriptor : public btVertexBufferDescriptor
+{
+protected:
+	float *m_basePointer;
+
+public:
+	/**
+	 * vertexBasePointer is pointer to beginning of the buffer.
+	 * vertexOffset is the offset in floats to the first vertex.
+	 * vertexStride is the stride in floats between vertices.
+	 */
+	btCPUVertexBufferDescriptor(float *basePointer, int vertexOffset, int vertexStride)
+	{
+		m_basePointer = basePointer;
+		m_vertexOffset = vertexOffset;
+		m_vertexStride = vertexStride;
+		m_hasVertexPositions = true;
+	}
+
+	/**
+	 * vertexBasePointer is pointer to beginning of the buffer.
+	 * vertexOffset is the offset in floats to the first vertex.
+	 * vertexStride is the stride in floats between vertices.
+	 */
+	btCPUVertexBufferDescriptor(float *basePointer, int vertexOffset, int vertexStride, int normalOffset, int normalStride)
+	{
+		m_basePointer = basePointer;
+
+		m_vertexOffset = vertexOffset;
+		m_vertexStride = vertexStride;
+		m_hasVertexPositions = true;
+
+		m_normalOffset = normalOffset;
+		m_normalStride = normalStride;
+		m_hasNormals = true;
+	}
+
+	virtual ~btCPUVertexBufferDescriptor()
+	{
+	}
+
+	/**
+	 * Return the type of the vertex buffer descriptor.
+	 */
+	virtual BufferTypes getBufferType() const
+	{
+		return CPU_BUFFER;
+	}
+
+	/**
+	 * Return the base pointer in memory to the first vertex.
+	 */
+	virtual float *getBasePointer() const
+	{
+		return m_basePointer;
+	}
+};
+
+#endif  // #ifndef BT_SOFT_BODY_SOLVER_VERTEX_BUFFER_H
diff --git a/engine/inc/bullet/BulletSoftBody/btSoftBodySolvers.h b/engine/inc/bullet/BulletSoftBody/btSoftBodySolvers.h
new file mode 100644
index 00000000..dbb2624e
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btSoftBodySolvers.h
@@ -0,0 +1,147 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SOFT_BODY_SOLVERS_H
+#define BT_SOFT_BODY_SOLVERS_H
+
+#include "BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h"
+
+class btSoftBodyTriangleData;
+class btSoftBodyLinkData;
+class btSoftBodyVertexData;
+class btVertexBufferDescriptor;
+class btCollisionObject;
+class btSoftBody;
+
+class btSoftBodySolver
+{
+public:
+	enum SolverTypes
+	{
+		DEFAULT_SOLVER,
+		CPU_SOLVER,
+		CL_SOLVER,
+		CL_SIMD_SOLVER,
+		DX_SOLVER,
+		DX_SIMD_SOLVER,
+		DEFORMABLE_SOLVER
+	};
+
+protected:
+	int m_numberOfPositionIterations;
+	int m_numberOfVelocityIterations;
+	// Simulation timescale
+	float m_timeScale;
+
+public:
+	btSoftBodySolver() : m_numberOfPositionIterations(10),
+						 m_timeScale(1)
+	{
+		m_numberOfVelocityIterations = 0;
+		m_numberOfPositionIterations = 5;
+	}
+
+	virtual ~btSoftBodySolver()
+	{
+	}
+
+	/**
+	 * Return the type of the solver.
+	 */
+	virtual SolverTypes getSolverType() const = 0;
+
+	/** Ensure that this solver is initialized. */
+	virtual bool checkInitialized() = 0;
+
+	/** Optimize soft bodies in this solver. */
+	virtual void optimize(btAlignedObjectArray<btSoftBody *> &softBodies, bool forceUpdate = false) = 0;
+
+	/** Copy necessary data back to the original soft body source objects. */
+	virtual void copyBackToSoftBodies(bool bMove = true) = 0;
+
+	/** Predict motion of soft bodies into next timestep */
+	virtual void predictMotion(btScalar solverdt) = 0;
+
+	/** Solve constraints for a set of soft bodies */
+	virtual void solveConstraints(btScalar solverdt) = 0;
+
+	/** Perform necessary per-step updates of soft bodies such as recomputing normals and bounding boxes */
+	virtual void updateSoftBodies() = 0;
+
+	/** Process a collision between one of the world's soft bodies and another collision object */
+	virtual void processCollision(btSoftBody *, const struct btCollisionObjectWrapper *) = 0;
+
+	/** Process a collision between two soft bodies */
+	virtual void processCollision(btSoftBody *, btSoftBody *) = 0;
+
+	/** Set the number of velocity constraint solver iterations this solver uses. */
+	virtual void setNumberOfPositionIterations(int iterations)
+	{
+		m_numberOfPositionIterations = iterations;
+	}
+
+	/** Get the number of velocity constraint solver iterations this solver uses. */
+	virtual int getNumberOfPositionIterations()
+	{
+		return m_numberOfPositionIterations;
+	}
+
+	/** Set the number of velocity constraint solver iterations this solver uses. */
+	virtual void setNumberOfVelocityIterations(int iterations)
+	{
+		m_numberOfVelocityIterations = iterations;
+	}
+
+	/** Get the number of velocity constraint solver iterations this solver uses. */
+	virtual int getNumberOfVelocityIterations()
+	{
+		return m_numberOfVelocityIterations;
+	}
+
+	/** Return the timescale that the simulation is using */
+	float getTimeScale()
+	{
+		return m_timeScale;
+	}
+
+#if 0
+	/**
+	 * Add a collision object to be used by the indicated softbody.
+	 */
+	virtual void addCollisionObjectForSoftBody( int clothIdentifier, btCollisionObject *collisionObject ) = 0;
+#endif
+};
+
+/** 
+ * Class to manage movement of data from a solver to a given target.
+ * This version is abstract. Subclasses will have custom pairings for different combinations.
+ */
+class btSoftBodySolverOutput
+{
+protected:
+public:
+	btSoftBodySolverOutput()
+	{
+	}
+
+	virtual ~btSoftBodySolverOutput()
+	{
+	}
+
+	/** Output current computed vertex data to the vertex buffers for all cloths in the solver. */
+	virtual void copySoftBodyToVertexBuffer(const btSoftBody *const softBody, btVertexBufferDescriptor *vertexBuffer) = 0;
+};
+
+#endif  // #ifndef BT_SOFT_BODY_SOLVERS_H
diff --git a/engine/inc/bullet/BulletSoftBody/btSoftMultiBodyDynamicsWorld.h b/engine/inc/bullet/BulletSoftBody/btSoftMultiBodyDynamicsWorld.h
new file mode 100644
index 00000000..f295945a
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btSoftMultiBodyDynamicsWorld.h
@@ -0,0 +1,105 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SOFT_MULTIBODY_DYNAMICS_WORLD_H
+#define BT_SOFT_MULTIBODY_DYNAMICS_WORLD_H
+
+#include "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h"
+#include "BulletDynamics/Featherstone/btMultiBodyDynamicsWorld.h"
+#include "BulletSoftBody/btSoftBody.h"
+
+#ifndef BT_SOFT_RIGID_DYNAMICS_WORLD_H
+typedef btAlignedObjectArray<btSoftBody*> btSoftBodyArray;
+#endif
+
+class btSoftBodySolver;
+
+class btSoftMultiBodyDynamicsWorld : public btMultiBodyDynamicsWorld
+{
+	btSoftBodyArray m_softBodies;
+	int m_drawFlags;
+	bool m_drawNodeTree;
+	bool m_drawFaceTree;
+	bool m_drawClusterTree;
+	btSoftBodyWorldInfo m_sbi;
+	///Solver classes that encapsulate multiple soft bodies for solving
+	btSoftBodySolver* m_softBodySolver;
+	bool m_ownsSolver;
+
+protected:
+	virtual void predictUnconstraintMotion(btScalar timeStep);
+
+	virtual void internalSingleStepSimulation(btScalar timeStep);
+
+	void solveSoftBodiesConstraints(btScalar timeStep);
+
+	void serializeSoftBodies(btSerializer* serializer);
+
+public:
+	btSoftMultiBodyDynamicsWorld(btDispatcher* dispatcher, btBroadphaseInterface* pairCache, btMultiBodyConstraintSolver* constraintSolver, btCollisionConfiguration* collisionConfiguration, btSoftBodySolver* softBodySolver = 0);
+
+	virtual ~btSoftMultiBodyDynamicsWorld();
+
+	virtual void debugDrawWorld();
+
+	void addSoftBody(btSoftBody* body, int collisionFilterGroup = btBroadphaseProxy::DefaultFilter, int collisionFilterMask = btBroadphaseProxy::AllFilter);
+
+	void removeSoftBody(btSoftBody* body);
+
+	///removeCollisionObject will first check if it is a rigid body, if so call removeRigidBody otherwise call btDiscreteDynamicsWorld::removeCollisionObject
+	virtual void removeCollisionObject(btCollisionObject* collisionObject);
+
+	int getDrawFlags() const { return (m_drawFlags); }
+	void setDrawFlags(int f) { m_drawFlags = f; }
+
+	btSoftBodyWorldInfo& getWorldInfo()
+	{
+		return m_sbi;
+	}
+	const btSoftBodyWorldInfo& getWorldInfo() const
+	{
+		return m_sbi;
+	}
+
+	virtual btDynamicsWorldType getWorldType() const
+	{
+		return BT_SOFT_MULTIBODY_DYNAMICS_WORLD;
+	}
+
+	btSoftBodyArray& getSoftBodyArray()
+	{
+		return m_softBodies;
+	}
+
+	const btSoftBodyArray& getSoftBodyArray() const
+	{
+		return m_softBodies;
+	}
+
+	virtual void rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback) const;
+
+	/// rayTestSingle performs a raycast call and calls the resultCallback. It is used internally by rayTest.
+	/// In a future implementation, we consider moving the ray test as a virtual method in btCollisionShape.
+	/// This allows more customization.
+	static void rayTestSingle(const btTransform& rayFromTrans, const btTransform& rayToTrans,
+							  btCollisionObject* collisionObject,
+							  const btCollisionShape* collisionShape,
+							  const btTransform& colObjWorldTransform,
+							  RayResultCallback& resultCallback);
+
+	virtual void serialize(btSerializer* serializer);
+};
+
+#endif  //BT_SOFT_MULTIBODY_DYNAMICS_WORLD_H
diff --git a/engine/inc/bullet/BulletSoftBody/btSoftRigidCollisionAlgorithm.h b/engine/inc/bullet/BulletSoftBody/btSoftRigidCollisionAlgorithm.h
new file mode 100644
index 00000000..9773af19
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btSoftRigidCollisionAlgorithm.h
@@ -0,0 +1,71 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SOFT_RIGID_COLLISION_ALGORITHM_H
+#define BT_SOFT_RIGID_COLLISION_ALGORITHM_H
+
+#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
+class btPersistentManifold;
+#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h"
+
+#include "LinearMath/btVector3.h"
+class btSoftBody;
+
+/// btSoftRigidCollisionAlgorithm  provides collision detection between btSoftBody and btRigidBody
+class btSoftRigidCollisionAlgorithm : public btCollisionAlgorithm
+{
+	//	bool	m_ownManifold;
+	//	btPersistentManifold*	m_manifoldPtr;
+
+	//btSoftBody*				m_softBody;
+	//btCollisionObject*		m_rigidCollisionObject;
+
+	///for rigid versus soft (instead of soft versus rigid), we use this swapped boolean
+	bool m_isSwapped;
+
+public:
+	btSoftRigidCollisionAlgorithm(btPersistentManifold* mf, const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* col0, const btCollisionObjectWrapper* col1Wrap, bool isSwapped);
+
+	virtual ~btSoftRigidCollisionAlgorithm();
+
+	virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	virtual btScalar calculateTimeOfImpact(btCollisionObject* body0, btCollisionObject* body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	virtual void getAllContactManifolds(btManifoldArray& manifoldArray)
+	{
+		//we don't add any manifolds
+	}
+
+	struct CreateFunc : public btCollisionAlgorithmCreateFunc
+	{
+		virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap)
+		{
+			void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btSoftRigidCollisionAlgorithm));
+			if (!m_swapped)
+			{
+				return new (mem) btSoftRigidCollisionAlgorithm(0, ci, body0Wrap, body1Wrap, false);
+			}
+			else
+			{
+				return new (mem) btSoftRigidCollisionAlgorithm(0, ci, body0Wrap, body1Wrap, true);
+			}
+		}
+	};
+};
+
+#endif  //BT_SOFT_RIGID_COLLISION_ALGORITHM_H
diff --git a/engine/inc/bullet/BulletSoftBody/btSoftRigidDynamicsWorld.h b/engine/inc/bullet/BulletSoftBody/btSoftRigidDynamicsWorld.h
new file mode 100644
index 00000000..be49c444
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btSoftRigidDynamicsWorld.h
@@ -0,0 +1,102 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SOFT_RIGID_DYNAMICS_WORLD_H
+#define BT_SOFT_RIGID_DYNAMICS_WORLD_H
+
+#include "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h"
+#include "btSoftBody.h"
+
+typedef btAlignedObjectArray<btSoftBody*> btSoftBodyArray;
+
+class btSoftBodySolver;
+
+class btSoftRigidDynamicsWorld : public btDiscreteDynamicsWorld
+{
+	btSoftBodyArray m_softBodies;
+	int m_drawFlags;
+	bool m_drawNodeTree;
+	bool m_drawFaceTree;
+	bool m_drawClusterTree;
+	btSoftBodyWorldInfo m_sbi;
+	///Solver classes that encapsulate multiple soft bodies for solving
+	btSoftBodySolver* m_softBodySolver;
+	bool m_ownsSolver;
+
+protected:
+	virtual void predictUnconstraintMotion(btScalar timeStep);
+
+	virtual void internalSingleStepSimulation(btScalar timeStep);
+
+	void solveSoftBodiesConstraints(btScalar timeStep);
+
+	void serializeSoftBodies(btSerializer* serializer);
+
+public:
+	btSoftRigidDynamicsWorld(btDispatcher* dispatcher, btBroadphaseInterface* pairCache, btConstraintSolver* constraintSolver, btCollisionConfiguration* collisionConfiguration, btSoftBodySolver* softBodySolver = 0);
+
+	virtual ~btSoftRigidDynamicsWorld();
+
+	virtual void debugDrawWorld();
+
+	void addSoftBody(btSoftBody* body, int collisionFilterGroup = btBroadphaseProxy::DefaultFilter, int collisionFilterMask = btBroadphaseProxy::AllFilter);
+
+	void removeSoftBody(btSoftBody* body);
+
+	///removeCollisionObject will first check if it is a rigid body, if so call removeRigidBody otherwise call btDiscreteDynamicsWorld::removeCollisionObject
+	virtual void removeCollisionObject(btCollisionObject* collisionObject);
+
+	int getDrawFlags() const { return (m_drawFlags); }
+	void setDrawFlags(int f) { m_drawFlags = f; }
+
+	btSoftBodyWorldInfo& getWorldInfo()
+	{
+		return m_sbi;
+	}
+	const btSoftBodyWorldInfo& getWorldInfo() const
+	{
+		return m_sbi;
+	}
+
+	virtual btDynamicsWorldType getWorldType() const
+	{
+		return BT_SOFT_RIGID_DYNAMICS_WORLD;
+	}
+
+	btSoftBodyArray& getSoftBodyArray()
+	{
+		return m_softBodies;
+	}
+
+	const btSoftBodyArray& getSoftBodyArray() const
+	{
+		return m_softBodies;
+	}
+
+	virtual void rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback) const;
+
+	/// rayTestSingle performs a raycast call and calls the resultCallback. It is used internally by rayTest.
+	/// In a future implementation, we consider moving the ray test as a virtual method in btCollisionShape.
+	/// This allows more customization.
+	static void rayTestSingle(const btTransform& rayFromTrans, const btTransform& rayToTrans,
+							  btCollisionObject* collisionObject,
+							  const btCollisionShape* collisionShape,
+							  const btTransform& colObjWorldTransform,
+							  RayResultCallback& resultCallback);
+
+	virtual void serialize(btSerializer* serializer);
+};
+
+#endif  //BT_SOFT_RIGID_DYNAMICS_WORLD_H
diff --git a/engine/inc/bullet/BulletSoftBody/btSoftSoftCollisionAlgorithm.h b/engine/inc/bullet/BulletSoftBody/btSoftSoftCollisionAlgorithm.h
new file mode 100644
index 00000000..6f871f5b
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btSoftSoftCollisionAlgorithm.h
@@ -0,0 +1,65 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SOFT_SOFT_COLLISION_ALGORITHM_H
+#define BT_SOFT_SOFT_COLLISION_ALGORITHM_H
+
+#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+#include "BulletCollision/BroadphaseCollision/btDispatcher.h"
+#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
+
+class btPersistentManifold;
+class btSoftBody;
+
+///collision detection between two btSoftBody shapes
+class btSoftSoftCollisionAlgorithm : public btCollisionAlgorithm
+{
+	bool m_ownManifold;
+	btPersistentManifold* m_manifoldPtr;
+
+	//	btSoftBody*	m_softBody0;
+	//	btSoftBody*	m_softBody1;
+
+public:
+	btSoftSoftCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci)
+		: btCollisionAlgorithm(ci) {}
+
+	virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	virtual btScalar calculateTimeOfImpact(btCollisionObject* body0, btCollisionObject* body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	virtual void getAllContactManifolds(btManifoldArray& manifoldArray)
+	{
+		if (m_manifoldPtr && m_ownManifold)
+			manifoldArray.push_back(m_manifoldPtr);
+	}
+
+	btSoftSoftCollisionAlgorithm(btPersistentManifold* mf, const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap);
+
+	virtual ~btSoftSoftCollisionAlgorithm();
+
+	struct CreateFunc : public btCollisionAlgorithmCreateFunc
+	{
+		virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap)
+		{
+			int bbsize = sizeof(btSoftSoftCollisionAlgorithm);
+			void* ptr = ci.m_dispatcher1->allocateCollisionAlgorithm(bbsize);
+			return new (ptr) btSoftSoftCollisionAlgorithm(0, ci, body0Wrap, body1Wrap);
+		}
+	};
+};
+
+#endif  //BT_SOFT_SOFT_COLLISION_ALGORITHM_H
diff --git a/engine/inc/bullet/BulletSoftBody/btSparseSDF.h b/engine/inc/bullet/BulletSoftBody/btSparseSDF.h
new file mode 100644
index 00000000..d611726b
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/btSparseSDF.h
@@ -0,0 +1,372 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+///btSparseSdf implementation by Nathanael Presson
+
+#ifndef BT_SPARSE_SDF_H
+#define BT_SPARSE_SDF_H
+
+#include "BulletCollision/CollisionDispatch/btCollisionObject.h"
+#include "BulletCollision/NarrowPhaseCollision/btGjkEpa2.h"
+
+// Fast Hash
+
+#if !defined(get16bits)
+#define get16bits(d) ((((unsigned int)(((const unsigned char*)(d))[1])) << 8) + (unsigned int)(((const unsigned char*)(d))[0]))
+#endif
+//
+// super hash function by Paul Hsieh
+//
+inline unsigned int HsiehHash(const char* data, int len)
+{
+	unsigned int hash = len, tmp;
+	len >>= 2;
+
+	/* Main loop */
+	for (; len > 0; len--)
+	{
+		hash += get16bits(data);
+		tmp = (get16bits(data + 2) << 11) ^ hash;
+		hash = (hash << 16) ^ tmp;
+		data += 2 * sizeof(unsigned short);
+		hash += hash >> 11;
+	}
+
+	/* Force "avalanching" of final 127 bits */
+	hash ^= hash << 3;
+	hash += hash >> 5;
+	hash ^= hash << 4;
+	hash += hash >> 17;
+	hash ^= hash << 25;
+	hash += hash >> 6;
+
+	return hash;
+}
+
+template <const int CELLSIZE>
+struct btSparseSdf
+{
+	//
+	// Inner types
+	//
+	struct IntFrac
+	{
+		int b;
+		int i;
+		btScalar f;
+	};
+	struct Cell
+	{
+		btScalar d[CELLSIZE + 1][CELLSIZE + 1][CELLSIZE + 1];
+		int c[3];
+		int puid;
+		unsigned hash;
+		const btCollisionShape* pclient;
+		Cell* next;
+	};
+	//
+	// Fields
+	//
+
+	btAlignedObjectArray<Cell*> cells;
+	btScalar voxelsz;
+	btScalar m_defaultVoxelsz;
+	int puid;
+	int ncells;
+	int m_clampCells;
+	int nprobes;
+	int nqueries;
+
+	~btSparseSdf()
+	{
+		Reset();
+	}
+	//
+	// Methods
+	//
+
+	//
+	void Initialize(int hashsize = 2383, int clampCells = 256 * 1024)
+	{
+		//avoid a crash due to running out of memory, so clamp the maximum number of cells allocated
+		//if this limit is reached, the SDF is reset (at the cost of some performance during the reset)
+		m_clampCells = clampCells;
+		cells.resize(hashsize, 0);
+		m_defaultVoxelsz = 0.25;
+		Reset();
+	}
+	//
+
+	void setDefaultVoxelsz(btScalar sz)
+	{
+		m_defaultVoxelsz = sz;
+	}
+
+	void Reset()
+	{
+		for (int i = 0, ni = cells.size(); i < ni; ++i)
+		{
+			Cell* pc = cells[i];
+			cells[i] = 0;
+			while (pc)
+			{
+				Cell* pn = pc->next;
+				delete pc;
+				pc = pn;
+			}
+		}
+		voxelsz = m_defaultVoxelsz;
+		puid = 0;
+		ncells = 0;
+		nprobes = 1;
+		nqueries = 1;
+	}
+	//
+	void GarbageCollect(int lifetime = 256)
+	{
+		const int life = puid - lifetime;
+		for (int i = 0; i < cells.size(); ++i)
+		{
+			Cell*& root = cells[i];
+			Cell* pp = 0;
+			Cell* pc = root;
+			while (pc)
+			{
+				Cell* pn = pc->next;
+				if (pc->puid < life)
+				{
+					if (pp)
+						pp->next = pn;
+					else
+						root = pn;
+					delete pc;
+					pc = pp;
+					--ncells;
+				}
+				pp = pc;
+				pc = pn;
+			}
+		}
+		//printf("GC[%d]: %d cells, PpQ: %f\r\n",puid,ncells,nprobes/(btScalar)nqueries);
+		nqueries = 1;
+		nprobes = 1;
+		++puid;  ///@todo: Reset puid's when int range limit is reached	*/
+		/* else setup a priority list...						*/
+	}
+	//
+	int RemoveReferences(btCollisionShape* pcs)
+	{
+		int refcount = 0;
+		for (int i = 0; i < cells.size(); ++i)
+		{
+			Cell*& root = cells[i];
+			Cell* pp = 0;
+			Cell* pc = root;
+			while (pc)
+			{
+				Cell* pn = pc->next;
+				if (pc->pclient == pcs)
+				{
+					if (pp)
+						pp->next = pn;
+					else
+						root = pn;
+					delete pc;
+					pc = pp;
+					++refcount;
+				}
+				pp = pc;
+				pc = pn;
+			}
+		}
+		return (refcount);
+	}
+	//
+	btScalar Evaluate(const btVector3& x,
+					  const btCollisionShape* shape,
+					  btVector3& normal,
+					  btScalar margin)
+	{
+		/* Lookup cell			*/
+		const btVector3 scx = x / voxelsz;
+		const IntFrac ix = Decompose(scx.x());
+		const IntFrac iy = Decompose(scx.y());
+		const IntFrac iz = Decompose(scx.z());
+		const unsigned h = Hash(ix.b, iy.b, iz.b, shape);
+		Cell*& root = cells[static_cast<int>(h % cells.size())];
+		Cell* c = root;
+		++nqueries;
+		while (c)
+		{
+			++nprobes;
+			if ((c->hash == h) &&
+				(c->c[0] == ix.b) &&
+				(c->c[1] == iy.b) &&
+				(c->c[2] == iz.b) &&
+				(c->pclient == shape))
+			{
+				break;
+			}
+			else
+			{
+				// printf("c->hash/c[0][1][2]=%d,%d,%d,%d\n", c->hash, c->c[0], c->c[1],c->c[2]);
+				//printf("h,ixb,iyb,izb=%d,%d,%d,%d\n", h,ix.b, iy.b, iz.b);
+
+				c = c->next;
+			}
+		}
+		if (!c)
+		{
+			++nprobes;
+			++ncells;
+			//int sz = sizeof(Cell);
+			if (ncells > m_clampCells)
+			{
+				static int numResets = 0;
+				numResets++;
+				//				printf("numResets=%d\n",numResets);
+				Reset();
+			}
+
+			c = new Cell();
+			c->next = root;
+			root = c;
+			c->pclient = shape;
+			c->hash = h;
+			c->c[0] = ix.b;
+			c->c[1] = iy.b;
+			c->c[2] = iz.b;
+			BuildCell(*c);
+		}
+		c->puid = puid;
+		/* Extract infos		*/
+		const int o[] = {ix.i, iy.i, iz.i};
+		const btScalar d[] = {c->d[o[0] + 0][o[1] + 0][o[2] + 0],
+							  c->d[o[0] + 1][o[1] + 0][o[2] + 0],
+							  c->d[o[0] + 1][o[1] + 1][o[2] + 0],
+							  c->d[o[0] + 0][o[1] + 1][o[2] + 0],
+							  c->d[o[0] + 0][o[1] + 0][o[2] + 1],
+							  c->d[o[0] + 1][o[1] + 0][o[2] + 1],
+							  c->d[o[0] + 1][o[1] + 1][o[2] + 1],
+							  c->d[o[0] + 0][o[1] + 1][o[2] + 1]};
+		/* Normal	*/
+#if 1
+		const btScalar gx[] = {d[1] - d[0], d[2] - d[3],
+							   d[5] - d[4], d[6] - d[7]};
+		const btScalar gy[] = {d[3] - d[0], d[2] - d[1],
+							   d[7] - d[4], d[6] - d[5]};
+		const btScalar gz[] = {d[4] - d[0], d[5] - d[1],
+							   d[7] - d[3], d[6] - d[2]};
+		normal.setX(Lerp(Lerp(gx[0], gx[1], iy.f),
+						 Lerp(gx[2], gx[3], iy.f), iz.f));
+		normal.setY(Lerp(Lerp(gy[0], gy[1], ix.f),
+						 Lerp(gy[2], gy[3], ix.f), iz.f));
+		normal.setZ(Lerp(Lerp(gz[0], gz[1], ix.f),
+						 Lerp(gz[2], gz[3], ix.f), iy.f));
+		normal.safeNormalize();
+#else
+		normal = btVector3(d[1] - d[0], d[3] - d[0], d[4] - d[0]).normalized();
+#endif
+		/* Distance	*/
+		const btScalar d0 = Lerp(Lerp(d[0], d[1], ix.f),
+								 Lerp(d[3], d[2], ix.f), iy.f);
+		const btScalar d1 = Lerp(Lerp(d[4], d[5], ix.f),
+								 Lerp(d[7], d[6], ix.f), iy.f);
+		return (Lerp(d0, d1, iz.f) - margin);
+	}
+	//
+	void BuildCell(Cell& c)
+	{
+		const btVector3 org = btVector3((btScalar)c.c[0],
+										(btScalar)c.c[1],
+										(btScalar)c.c[2]) *
+							  CELLSIZE * voxelsz;
+		for (int k = 0; k <= CELLSIZE; ++k)
+		{
+			const btScalar z = voxelsz * k + org.z();
+			for (int j = 0; j <= CELLSIZE; ++j)
+			{
+				const btScalar y = voxelsz * j + org.y();
+				for (int i = 0; i <= CELLSIZE; ++i)
+				{
+					const btScalar x = voxelsz * i + org.x();
+					c.d[i][j][k] = DistanceToShape(btVector3(x, y, z),
+												   c.pclient);
+				}
+			}
+		}
+	}
+	//
+	static inline btScalar DistanceToShape(const btVector3& x,
+										   const btCollisionShape* shape)
+	{
+		btTransform unit;
+		unit.setIdentity();
+		if (shape->isConvex())
+		{
+			btGjkEpaSolver2::sResults res;
+			const btConvexShape* csh = static_cast<const btConvexShape*>(shape);
+			return (btGjkEpaSolver2::SignedDistance(x, 0, csh, unit, res));
+		}
+		return (0);
+	}
+	//
+	static inline IntFrac Decompose(btScalar x)
+	{
+		/* That one need a lot of improvements...	*/
+		/* Remove test, faster floor...				*/
+		IntFrac r;
+		x /= CELLSIZE;
+		const int o = x < 0 ? (int)(-x + 1) : 0;
+		x += o;
+		r.b = (int)x;
+		const btScalar k = (x - r.b) * CELLSIZE;
+		r.i = (int)k;
+		r.f = k - r.i;
+		r.b -= o;
+		return (r);
+	}
+	//
+	static inline btScalar Lerp(btScalar a, btScalar b, btScalar t)
+	{
+		return (a + (b - a) * t);
+	}
+
+	//
+	static inline unsigned int Hash(int x, int y, int z, const btCollisionShape* shape)
+	{
+		struct btS
+		{
+			int x, y, z, w;
+			void* p;
+		};
+
+		btS myset;
+		//memset may be needed in case of additional (uninitialized) padding!
+		//memset(&myset, 0, sizeof(btS));
+
+		myset.x = x;
+		myset.y = y;
+		myset.z = z;
+		myset.w = 0;
+		myset.p = (void*)shape;
+		const char* ptr = (const char*)&myset;
+
+		unsigned int result = HsiehHash(ptr, sizeof(btS));
+
+		return result;
+	}
+};
+
+#endif  //BT_SPARSE_SDF_H
diff --git a/engine/inc/bullet/BulletSoftBody/poly34.h b/engine/inc/bullet/BulletSoftBody/poly34.h
new file mode 100644
index 00000000..35a52c5f
--- /dev/null
+++ b/engine/inc/bullet/BulletSoftBody/poly34.h
@@ -0,0 +1,38 @@
+// poly34.h : solution of cubic and quartic equation
+// (c) Khashin S.I. http://math.ivanovo.ac.ru/dalgebra/Khashin/index.html
+// khash2 (at) gmail.com
+
+#ifndef POLY_34
+#define POLY_34
+#include "LinearMath/btScalar.h"
+// x - array of size 2
+// return 2: 2 real roots x[0], x[1]
+// return 0: pair of complex roots: x[0]i*x[1]
+int SolveP2(btScalar* x, btScalar a, btScalar b);  // solve equation x^2 + a*x + b = 0
+
+// x - array of size 3
+// return 3: 3 real roots x[0], x[1], x[2]
+// return 1: 1 real root x[0] and pair of complex roots: x[1]i*x[2]
+int SolveP3(btScalar* x, btScalar a, btScalar b, btScalar c);  // solve cubic equation x^3 + a*x^2 + b*x + c = 0
+
+// x - array of size 4
+// return 4: 4 real roots x[0], x[1], x[2], x[3], possible multiple roots
+// return 2: 2 real roots x[0], x[1] and complex x[2]i*x[3],
+// return 0: two pair of complex roots: x[0]i*x[1],  x[2]i*x[3],
+int SolveP4(btScalar* x, btScalar a, btScalar b, btScalar c, btScalar d);  // solve equation x^4 + a*x^3 + b*x^2 + c*x + d = 0 by Dekart-Euler method
+
+// x - array of size 5
+// return 5: 5 real roots x[0], x[1], x[2], x[3], x[4], possible multiple roots
+// return 3: 3 real roots x[0], x[1], x[2] and complex x[3]i*x[4],
+// return 1: 1 real root x[0] and two pair of complex roots: x[1]i*x[2],  x[3]i*x[4],
+int SolveP5(btScalar* x, btScalar a, btScalar b, btScalar c, btScalar d, btScalar e);  // solve equation x^5 + a*x^4 + b*x^3 + c*x^2 + d*x + e = 0
+
+//-----------------------------------------------------------------------------
+// And some additional functions for internal use.
+// Your may remove this definitions from here
+int SolveP4Bi(btScalar* x, btScalar b, btScalar d);                              // solve equation x^4 + b*x^2 + d = 0
+int SolveP4De(btScalar* x, btScalar b, btScalar c, btScalar d);                  // solve equation x^4 + b*x^2 + c*x + d = 0
+void CSqrt(btScalar x, btScalar y, btScalar& a, btScalar& b);                    // returns as a+i*s,  sqrt(x+i*y)
+btScalar N4Step(btScalar x, btScalar a, btScalar b, btScalar c, btScalar d);     // one Newton step for x^4 + a*x^3 + b*x^2 + c*x + d
+btScalar SolveP5_1(btScalar a, btScalar b, btScalar c, btScalar d, btScalar e);  // return real root of x^5 + a*x^4 + b*x^3 + c*x^2 + d*x + e = 0
+#endif
diff --git a/engine/inc/bullet/BulletWorldImporter/btBulletWorldImporter.h b/engine/inc/bullet/BulletWorldImporter/btBulletWorldImporter.h
new file mode 100644
index 00000000..0a856bc3
--- /dev/null
+++ b/engine/inc/bullet/BulletWorldImporter/btBulletWorldImporter.h
@@ -0,0 +1,52 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2012 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BULLET_WORLD_IMPORTER_H
+#define BULLET_WORLD_IMPORTER_H
+
+#include "btWorldImporter.h"
+
+class btBulletFile;
+
+namespace bParse
+{
+class btBulletFile;
+
+};
+
+///The btBulletWorldImporter is a starting point to import .bullet files.
+///note that not all data is converted yet. You are expected to override or modify this class.
+///See Bullet/Demos/SerializeDemo for a derived class that extract btSoftBody objects too.
+class btBulletWorldImporter : public btWorldImporter
+{
+public:
+	btBulletWorldImporter(btDynamicsWorld* world = 0);
+
+	virtual ~btBulletWorldImporter();
+
+	///if you pass a valid preSwapFilenameOut, it will save a new file with a different endianness
+	///this pre-swapped file can be loaded without swapping on a target platform of different endianness
+	bool loadFile(const char* fileName, const char* preSwapFilenameOut = 0);
+
+	///the memoryBuffer might be modified (for example if endian swaps are necessary)
+	bool loadFileFromMemory(char* memoryBuffer, int len);
+
+	bool loadFileFromMemory(bParse::btBulletFile* file);
+
+	//call make sure bulletFile2 has been parsed, either using btBulletFile::parse or btBulletWorldImporter::loadFileFromMemory
+	virtual bool convertAllObjects(bParse::btBulletFile* file);
+};
+
+#endif  //BULLET_WORLD_IMPORTER_H
diff --git a/engine/inc/bullet/BulletWorldImporter/btMultiBodyWorldImporter.h b/engine/inc/bullet/BulletWorldImporter/btMultiBodyWorldImporter.h
new file mode 100644
index 00000000..46dd3ce2
--- /dev/null
+++ b/engine/inc/bullet/BulletWorldImporter/btMultiBodyWorldImporter.h
@@ -0,0 +1,19 @@
+#ifndef BT_MULTIBODY_WORLD_IMPORTER_H
+#define BT_MULTIBODY_WORLD_IMPORTER_H
+
+#include "btBulletWorldImporter.h"
+
+class btMultiBodyWorldImporter : public btBulletWorldImporter
+{
+	struct btMultiBodyWorldImporterInternalData* m_data;
+
+public:
+	btMultiBodyWorldImporter(class btMultiBodyDynamicsWorld* world);
+	virtual ~btMultiBodyWorldImporter();
+
+	virtual bool convertAllObjects(bParse::btBulletFile* bulletFile2);
+
+	virtual void deleteAllData();
+};
+
+#endif  //BT_MULTIBODY_WORLD_IMPORTER_H
diff --git a/engine/inc/bullet/BulletWorldImporter/btWorldImporter.h b/engine/inc/bullet/BulletWorldImporter/btWorldImporter.h
new file mode 100644
index 00000000..ba087fba
--- /dev/null
+++ b/engine/inc/bullet/BulletWorldImporter/btWorldImporter.h
@@ -0,0 +1,227 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2012 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_WORLD_IMPORTER_H
+#define BT_WORLD_IMPORTER_H
+
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btAlignedObjectArray.h"
+#include "LinearMath/btHashMap.h"
+
+class btCollisionShape;
+class btCollisionObject;
+class btRigidBody;
+class btTypedConstraint;
+class btDynamicsWorld;
+struct ConstraintInput;
+class btRigidBodyColladaInfo;
+struct btCollisionShapeData;
+class btTriangleIndexVertexArray;
+class btStridingMeshInterface;
+struct btStridingMeshInterfaceData;
+class btGImpactMeshShape;
+class btOptimizedBvh;
+struct btTriangleInfoMap;
+class btBvhTriangleMeshShape;
+class btPoint2PointConstraint;
+class btHingeConstraint;
+class btConeTwistConstraint;
+class btGeneric6DofConstraint;
+class btGeneric6DofSpringConstraint;
+class btGeneric6DofSpring2Constraint;
+class btSliderConstraint;
+class btGearConstraint;
+struct btContactSolverInfo;
+struct btTypedConstraintData;
+struct btTypedConstraintFloatData;
+struct btTypedConstraintDoubleData;
+
+struct btRigidBodyDoubleData;
+struct btRigidBodyFloatData;
+
+#ifdef BT_USE_DOUBLE_PRECISION
+#define btRigidBodyData btRigidBodyDoubleData
+#else
+#define btRigidBodyData btRigidBodyFloatData
+#endif  //BT_USE_DOUBLE_PRECISION
+
+enum btWorldImporterFlags
+{
+	eRESTORE_EXISTING_OBJECTS = 1,  //don't create new objects
+};
+
+class btWorldImporter
+{
+protected:
+	btDynamicsWorld* m_dynamicsWorld;
+
+	int m_verboseMode;
+	int m_importerFlags;
+
+	btAlignedObjectArray<btCollisionShape*> m_allocatedCollisionShapes;
+	btAlignedObjectArray<btCollisionObject*> m_allocatedRigidBodies;
+	btAlignedObjectArray<btTypedConstraint*> m_allocatedConstraints;
+	btAlignedObjectArray<btOptimizedBvh*> m_allocatedBvhs;
+	btAlignedObjectArray<btTriangleInfoMap*> m_allocatedTriangleInfoMaps;
+	btAlignedObjectArray<btTriangleIndexVertexArray*> m_allocatedTriangleIndexArrays;
+	btAlignedObjectArray<btStridingMeshInterfaceData*> m_allocatedbtStridingMeshInterfaceDatas;
+
+	btAlignedObjectArray<char*> m_allocatedNames;
+
+	btAlignedObjectArray<int*> m_indexArrays;
+	btAlignedObjectArray<short int*> m_shortIndexArrays;
+	btAlignedObjectArray<unsigned char*> m_charIndexArrays;
+
+	btAlignedObjectArray<btVector3FloatData*> m_floatVertexArrays;
+	btAlignedObjectArray<btVector3DoubleData*> m_doubleVertexArrays;
+
+	btHashMap<btHashPtr, btOptimizedBvh*> m_bvhMap;
+	btHashMap<btHashPtr, btTriangleInfoMap*> m_timMap;
+
+	btHashMap<btHashString, btCollisionShape*> m_nameShapeMap;
+	btHashMap<btHashString, btRigidBody*> m_nameBodyMap;
+	btHashMap<btHashString, btTypedConstraint*> m_nameConstraintMap;
+	btHashMap<btHashPtr, const char*> m_objectNameMap;
+
+	btHashMap<btHashPtr, btCollisionShape*> m_shapeMap;
+	btHashMap<btHashPtr, btCollisionObject*> m_bodyMap;
+
+	//methods
+
+	static btRigidBody& getFixedBody();
+
+	char* duplicateName(const char* name);
+
+	btCollisionShape* convertCollisionShape(btCollisionShapeData* shapeData);
+
+	void convertConstraintBackwardsCompatible281(btTypedConstraintData* constraintData, btRigidBody* rbA, btRigidBody* rbB, int fileVersion);
+	void convertConstraintFloat(btTypedConstraintFloatData* constraintData, btRigidBody* rbA, btRigidBody* rbB, int fileVersion);
+	void convertConstraintDouble(btTypedConstraintDoubleData* constraintData, btRigidBody* rbA, btRigidBody* rbB, int fileVersion);
+	void convertRigidBodyFloat(btRigidBodyFloatData* colObjData);
+	void convertRigidBodyDouble(btRigidBodyDoubleData* colObjData);
+
+public:
+	btWorldImporter(btDynamicsWorld* world);
+
+	virtual ~btWorldImporter();
+
+	///delete all memory collision shapes, rigid bodies, constraints etc. allocated during the load.
+	///make sure you don't use the dynamics world containing objects after you call this method
+	virtual void deleteAllData();
+
+	void setVerboseMode(int verboseMode)
+	{
+		m_verboseMode = verboseMode;
+	}
+
+	int getVerboseMode() const
+	{
+		return m_verboseMode;
+	}
+
+	void setImporterFlags(int importerFlags)
+	{
+		m_importerFlags = importerFlags;
+	}
+
+	int getImporterFlags() const
+	{
+		return m_importerFlags;
+	}
+
+	// query for data
+	int getNumCollisionShapes() const;
+	btCollisionShape* getCollisionShapeByIndex(int index);
+	int getNumRigidBodies() const;
+	btCollisionObject* getRigidBodyByIndex(int index) const;
+	int getNumConstraints() const;
+	btTypedConstraint* getConstraintByIndex(int index) const;
+	int getNumBvhs() const;
+	btOptimizedBvh* getBvhByIndex(int index) const;
+	int getNumTriangleInfoMaps() const;
+	btTriangleInfoMap* getTriangleInfoMapByIndex(int index) const;
+
+	// queris involving named objects
+	btCollisionShape* getCollisionShapeByName(const char* name);
+	btRigidBody* getRigidBodyByName(const char* name);
+	btTypedConstraint* getConstraintByName(const char* name);
+	const char* getNameForPointer(const void* ptr) const;
+
+	///those virtuals are called by load and can be overridden by the user
+
+	virtual void setDynamicsWorldInfo(const btVector3& gravity, const btContactSolverInfo& solverInfo);
+
+	//bodies
+	virtual btRigidBody* createRigidBody(bool isDynamic, btScalar mass, const btTransform& startTransform, btCollisionShape* shape, const char* bodyName);
+	virtual btCollisionObject* createCollisionObject(const btTransform& startTransform, btCollisionShape* shape, const char* bodyName);
+
+	///shapes
+
+	virtual btCollisionShape* createPlaneShape(const btVector3& planeNormal, btScalar planeConstant);
+	virtual btCollisionShape* createBoxShape(const btVector3& halfExtents);
+	virtual btCollisionShape* createSphereShape(btScalar radius);
+	virtual btCollisionShape* createCapsuleShapeX(btScalar radius, btScalar height);
+	virtual btCollisionShape* createCapsuleShapeY(btScalar radius, btScalar height);
+	virtual btCollisionShape* createCapsuleShapeZ(btScalar radius, btScalar height);
+
+	virtual btCollisionShape* createCylinderShapeX(btScalar radius, btScalar height);
+	virtual btCollisionShape* createCylinderShapeY(btScalar radius, btScalar height);
+	virtual btCollisionShape* createCylinderShapeZ(btScalar radius, btScalar height);
+	virtual btCollisionShape* createConeShapeX(btScalar radius, btScalar height);
+	virtual btCollisionShape* createConeShapeY(btScalar radius, btScalar height);
+	virtual btCollisionShape* createConeShapeZ(btScalar radius, btScalar height);
+	virtual class btTriangleIndexVertexArray* createTriangleMeshContainer();
+	virtual btBvhTriangleMeshShape* createBvhTriangleMeshShape(btStridingMeshInterface* trimesh, btOptimizedBvh* bvh);
+	virtual btCollisionShape* createConvexTriangleMeshShape(btStridingMeshInterface* trimesh);
+	virtual btGImpactMeshShape* createGimpactShape(btStridingMeshInterface* trimesh);
+	virtual btStridingMeshInterfaceData* createStridingMeshInterfaceData(btStridingMeshInterfaceData* interfaceData);
+
+	virtual class btConvexHullShape* createConvexHullShape();
+	virtual class btCompoundShape* createCompoundShape();
+	virtual class btScaledBvhTriangleMeshShape* createScaledTrangleMeshShape(btBvhTriangleMeshShape* meshShape, const btVector3& localScalingbtBvhTriangleMeshShape);
+
+	virtual class btMultiSphereShape* createMultiSphereShape(const btVector3* positions, const btScalar* radi, int numSpheres);
+
+	virtual btTriangleIndexVertexArray* createMeshInterface(btStridingMeshInterfaceData& meshData);
+
+	virtual class btHeightfieldTerrainShape* createHeightfieldShape(int heightStickWidth, int heightStickLength,
+		const void* heightfieldData, btScalar heightScale,
+		btScalar minHeight, btScalar maxHeight,
+		int upAxis, int heightDataType,
+		bool flipQuadEdges);
+
+	///acceleration and connectivity structures
+	virtual btOptimizedBvh* createOptimizedBvh();
+	virtual btTriangleInfoMap* createTriangleInfoMap();
+
+	///constraints
+	virtual btPoint2PointConstraint* createPoint2PointConstraint(btRigidBody& rbA, btRigidBody& rbB, const btVector3& pivotInA, const btVector3& pivotInB);
+	virtual btPoint2PointConstraint* createPoint2PointConstraint(btRigidBody& rbA, const btVector3& pivotInA);
+	virtual btHingeConstraint* createHingeConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& rbAFrame, const btTransform& rbBFrame, bool useReferenceFrameA = false);
+	virtual btHingeConstraint* createHingeConstraint(btRigidBody& rbA, const btTransform& rbAFrame, bool useReferenceFrameA = false);
+	virtual btConeTwistConstraint* createConeTwistConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& rbAFrame, const btTransform& rbBFrame);
+	virtual btConeTwistConstraint* createConeTwistConstraint(btRigidBody& rbA, const btTransform& rbAFrame);
+	virtual btGeneric6DofConstraint* createGeneric6DofConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB, bool useLinearReferenceFrameA);
+	virtual btGeneric6DofConstraint* createGeneric6DofConstraint(btRigidBody& rbB, const btTransform& frameInB, bool useLinearReferenceFrameB);
+	virtual btGeneric6DofSpringConstraint* createGeneric6DofSpringConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB, bool useLinearReferenceFrameA);
+	virtual btGeneric6DofSpring2Constraint* createGeneric6DofSpring2Constraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB, int rotateOrder);
+
+	virtual btSliderConstraint* createSliderConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB, bool useLinearReferenceFrameA);
+	virtual btSliderConstraint* createSliderConstraint(btRigidBody& rbB, const btTransform& frameInB, bool useLinearReferenceFrameA);
+	virtual btGearConstraint* createGearConstraint(btRigidBody& rbA, btRigidBody& rbB, const btVector3& axisInA, const btVector3& axisInB, btScalar ratio);
+};
+
+#endif  //BT_WORLD_IMPORTER_H
\ No newline at end of file
diff --git a/engine/inc/bullet/BulletXmlWorldImporter/btBulletXmlWorldImporter.h b/engine/inc/bullet/BulletXmlWorldImporter/btBulletXmlWorldImporter.h
new file mode 100644
index 00000000..aa88c088
--- /dev/null
+++ b/engine/inc/bullet/BulletXmlWorldImporter/btBulletXmlWorldImporter.h
@@ -0,0 +1,89 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2012 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_BULLET_XML_WORLD_IMPORTER_H
+#define BT_BULLET_XML_WORLD_IMPORTER_H
+
+#include "LinearMath/btScalar.h"
+
+class btDynamicsWorld;
+
+namespace tinyxml2
+{
+class XMLNode;
+};
+
+struct btConvexInternalShapeData;
+struct btCollisionShapeData;
+#ifdef BT_USE_DOUBLE_PRECISION
+struct btRigidBodyDoubleData;
+struct btTypedConstraintDoubleData;
+#define btRigidBodyData btRigidBodyDoubleData
+#define btTypedConstraintData2 btTypedConstraintDoubleData
+#else
+struct btRigidBodyFloatData;
+struct btTypedConstraintFloatData;
+#define btTypedConstraintData2 btTypedConstraintFloatData
+#define btRigidBodyData btRigidBodyFloatData
+#endif  //BT_USE_DOUBLE_PRECISION
+
+struct btCompoundShapeChildData;
+
+#include "LinearMath/btAlignedObjectArray.h"
+#include "btWorldImporter.h"
+
+class btBulletXmlWorldImporter : public btWorldImporter
+{
+protected:
+	btAlignedObjectArray<btCollisionShapeData*> m_collisionShapeData;
+	btAlignedObjectArray<btAlignedObjectArray<btCompoundShapeChildData>*> m_compoundShapeChildDataArrays;
+	btAlignedObjectArray<btRigidBodyData*> m_rigidBodyData;
+	btAlignedObjectArray<btTypedConstraintData2*> m_constraintData;
+	btHashMap<btHashPtr, void*> m_pointerLookup;
+	int m_fileVersion;
+	bool m_fileOk;
+
+	void auto_serialize_root_level_children(tinyxml2::XMLNode* pParent);
+	void auto_serialize(tinyxml2::XMLNode* pParent);
+
+	void deSerializeVector3FloatData(tinyxml2::XMLNode* pParent, btAlignedObjectArray<btVector3FloatData>& vectors);
+
+	void fixupCollisionDataPointers(btCollisionShapeData* shapeData);
+	void fixupConstraintData(btTypedConstraintData2* tcd);
+
+	//collision shapes data
+	void deSerializeCollisionShapeData(tinyxml2::XMLNode* pParent, btCollisionShapeData* colShapeData);
+	void deSerializeConvexInternalShapeData(tinyxml2::XMLNode* pParent);
+	void deSerializeStaticPlaneShapeData(tinyxml2::XMLNode* pParent);
+	void deSerializeCompoundShapeData(tinyxml2::XMLNode* pParent);
+	void deSerializeCompoundShapeChildData(tinyxml2::XMLNode* pParent);
+	void deSerializeConvexHullShapeData(tinyxml2::XMLNode* pParent);
+	void deSerializeDynamicsWorldData(tinyxml2::XMLNode* parent);
+
+	///bodies
+	void deSerializeRigidBodyFloatData(tinyxml2::XMLNode* pParent);
+
+	///constraints
+	void deSerializeGeneric6DofConstraintData(tinyxml2::XMLNode* pParent);
+
+public:
+	btBulletXmlWorldImporter(btDynamicsWorld* world);
+
+	virtual ~btBulletXmlWorldImporter();
+
+	bool loadFile(const char* fileName);
+};
+
+#endif  //BT_BULLET_XML_WORLD_IMPORTER_H
diff --git a/engine/inc/bullet/BulletXmlWorldImporter/string_split.h b/engine/inc/bullet/BulletXmlWorldImporter/string_split.h
new file mode 100644
index 00000000..16d629d6
--- /dev/null
+++ b/engine/inc/bullet/BulletXmlWorldImporter/string_split.h
@@ -0,0 +1,46 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2012 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+///The string split C code is by Lars Wirzenius
+///See http://stackoverflow.com/questions/2531605/how-to-split-a-string-with-a-delimiter-larger-than-one-single-char
+
+#ifndef STRING_SPLIT_H
+#define STRING_SPLIT_H
+
+#include <cstring>
+#include "LinearMath/btAlignedObjectArray.h"
+
+#include <string>
+
+namespace bullet_utils
+{
+void split(btAlignedObjectArray<std::string>& pieces, const std::string& vector_str, const std::string& separator);
+};
+
+///The string split C code is by Lars Wirzenius
+///See http://stackoverflow.com/questions/2531605/how-to-split-a-string-with-a-delimiter-larger-than-one-single-char
+
+/* Split a string into substrings. Return dynamic array of dynamically
+ allocated substrings, or NULL if there was an error. Caller is
+ expected to free the memory, for example with str_array_free. */
+char** str_split(const char* input, const char* sep);
+
+/* Free a dynamic array of dynamic strings. */
+void str_array_free(char** array);
+
+/* Return length of a NULL-delimited array of strings. */
+size_t str_array_len(char** array);
+
+#endif  //STRING_SPLIT_H
diff --git a/engine/inc/bullet/Collision/CollisionSdkC_Api.h b/engine/inc/bullet/Collision/CollisionSdkC_Api.h
new file mode 100644
index 00000000..afbe453f
--- /dev/null
+++ b/engine/inc/bullet/Collision/CollisionSdkC_Api.h
@@ -0,0 +1,104 @@
+#ifndef LW_COLLISION_C_API_H
+#define LW_COLLISION_C_API_H
+
+#define PL_DECLARE_HANDLE(name) \
+	typedef struct name##__     \
+	{                           \
+		int unused;             \
+	} * name
+
+#ifdef BT_USE_DOUBLE_PRECISION
+typedef double plReal;
+#else
+typedef float plReal;
+#endif
+
+typedef plReal plVector3[3];
+typedef plReal plQuaternion[4];
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	/**     Particular collision SDK (C-API) */
+	PL_DECLARE_HANDLE(plCollisionSdkHandle);
+
+	/**     Collision world, belonging to some collision SDK (C-API)*/
+	PL_DECLARE_HANDLE(plCollisionWorldHandle);
+
+	/** Collision object that can be part of a collision World (C-API)*/
+	PL_DECLARE_HANDLE(plCollisionObjectHandle);
+
+	/**     Collision Shape/Geometry, property of a collision object (C-API)*/
+	PL_DECLARE_HANDLE(plCollisionShapeHandle);
+
+	/* Collision SDK */
+
+	extern plCollisionSdkHandle plCreateBullet2CollisionSdk();
+
+#ifndef DISABLE_REAL_TIME_BULLET3_COLLISION_SDK
+	extern plCollisionSdkHandle plCreateRealTimeBullet3CollisionSdk();
+#endif  //DISABLE_REAL_TIME_BULLET3_COLLISION_SDK
+
+	//	extern plCollisionSdkHandle plCreateCustomCollisionSdk();
+
+	extern void plDeleteCollisionSdk(plCollisionSdkHandle collisionSdkHandle);
+
+	//extern int plGetSdkWorldCreationIntParameter();
+	//extern int plSetSdkWorldCreationIntParameter(int newValue);
+
+	/* Collision World */
+
+	extern plCollisionWorldHandle plCreateCollisionWorld(plCollisionSdkHandle collisionSdkHandle, int maxNumObjsCapacity, int maxNumShapesCapacity, int maxNumPairsCapacity);
+	extern void plDeleteCollisionWorld(plCollisionSdkHandle sdkHandle, plCollisionWorldHandle world);
+
+	extern void plAddCollisionObject(plCollisionSdkHandle sdkHandle, plCollisionWorldHandle world, plCollisionObjectHandle object);
+	extern void plRemoveCollisionObject(plCollisionSdkHandle sdkHandle, plCollisionWorldHandle world, plCollisionObjectHandle object);
+
+	/* Collision Object  */
+
+	extern plCollisionObjectHandle plCreateCollisionObject(plCollisionSdkHandle sdkHandle, plCollisionWorldHandle worldHandle, void* userPointer, int userIndex, plCollisionShapeHandle cshape, plVector3 startPosition, plQuaternion startOrientation);
+	extern void plDeleteCollisionObject(plCollisionSdkHandle sdkHandle, plCollisionWorldHandle worldHandle, plCollisionObjectHandle body);
+	extern void plSetCollisionObjectTransform(plCollisionSdkHandle sdkHandle, plCollisionWorldHandle worldHandle, plCollisionObjectHandle objHandle, plVector3 startPosition, plQuaternion startOrientation);
+
+	/* Collision Shape definition */
+
+	extern plCollisionShapeHandle plCreateSphereShape(plCollisionSdkHandle sdk, plCollisionWorldHandle worldHandle, plReal radius);
+	extern plCollisionShapeHandle plCreateCapsuleShape(plCollisionSdkHandle sdk, plCollisionWorldHandle worldHandle, plReal radius, plReal height, int capsuleAxis);
+	extern plCollisionShapeHandle plCreatePlaneShape(plCollisionSdkHandle sdk, plCollisionWorldHandle worldHandle,
+													 plReal planeNormalX,
+													 plReal planeNormalY,
+													 plReal planeNormalZ,
+													 plReal planeConstant);
+	extern plCollisionShapeHandle plCreateCompoundShape(plCollisionSdkHandle sdk, plCollisionWorldHandle worldHandle);
+	extern void plAddChildShape(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle, plCollisionShapeHandle compoundShape, plCollisionShapeHandle childShape, plVector3 childPos, plQuaternion childOrn);
+
+	extern void plDeleteShape(plCollisionSdkHandle collisionSdkHandle, plCollisionWorldHandle worldHandle, plCollisionShapeHandle shape);
+
+	/* Contact Results */
+
+	struct lwContactPoint
+	{
+		plVector3 m_ptOnAWorld;
+		plVector3 m_ptOnBWorld;
+		plVector3 m_normalOnB;
+		plReal m_distance;
+	};
+
+	/* Collision Filtering */
+	typedef void (*plNearCallback)(plCollisionSdkHandle sdkHandle, plCollisionWorldHandle worldHandle, void* userData,
+								   plCollisionObjectHandle objA, plCollisionObjectHandle objB);
+
+	/* Collision Queries */
+	extern int plCollide(plCollisionSdkHandle sdkHandle, plCollisionWorldHandle worldHandle, plCollisionObjectHandle colA, plCollisionObjectHandle colB,
+						 lwContactPoint* pointsOut, int pointCapacity);
+
+	extern void plWorldCollide(plCollisionSdkHandle sdkHandle, plCollisionWorldHandle world,
+							   plNearCallback filter, void* userData);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  //LW_COLLISION_C_API_H
diff --git a/engine/inc/bullet/Collision/CollisionTutorialBullet2.h b/engine/inc/bullet/Collision/CollisionTutorialBullet2.h
new file mode 100644
index 00000000..6ed76f24
--- /dev/null
+++ b/engine/inc/bullet/Collision/CollisionTutorialBullet2.h
@@ -0,0 +1,12 @@
+#ifndef COLLISION_TUTORIAL_H
+#define COLLISION_TUTORIAL_H
+
+enum EnumCollisionTutorialTypes
+{
+	TUT_SPHERE_PLANE_BULLET2 = 0,
+	TUT_SPHERE_PLANE_RTB3,
+};
+
+class CommonExampleInterface* CollisionTutorialBullet2CreateFunc(struct CommonExampleOptions& options);
+
+#endif  //COLLISION_TUTORIAL_H
diff --git a/engine/inc/bullet/Collision/Internal/Bullet2CollisionSdk.h b/engine/inc/bullet/Collision/Internal/Bullet2CollisionSdk.h
new file mode 100644
index 00000000..ce46b0ba
--- /dev/null
+++ b/engine/inc/bullet/Collision/Internal/Bullet2CollisionSdk.h
@@ -0,0 +1,55 @@
+#ifndef BULLET2_COLLISION_SDK_H
+#define BULLET2_COLLISION_SDK_H
+
+#include "CollisionSdkInterface.h"
+
+class Bullet2CollisionSdk : public CollisionSdkInterface
+{
+	struct Bullet2CollisionSdkInternalData* m_internalData;
+
+public:
+	Bullet2CollisionSdk();
+
+	virtual ~Bullet2CollisionSdk();
+
+	virtual plCollisionWorldHandle createCollisionWorld(int maxNumObjsCapacity, int maxNumShapesCapacity, int maxNumPairsCapacity);
+
+	virtual void deleteCollisionWorld(plCollisionWorldHandle worldHandle);
+
+	virtual plCollisionShapeHandle createSphereShape(plCollisionWorldHandle worldHandle, plReal radius);
+
+	virtual plCollisionShapeHandle createPlaneShape(plCollisionWorldHandle worldHandle,
+													plReal planeNormalX,
+													plReal planeNormalY,
+													plReal planeNormalZ,
+													plReal planeConstant);
+
+	virtual plCollisionShapeHandle createCapsuleShape(plCollisionWorldHandle worldHandle,
+													  plReal radius,
+													  plReal height,
+													  int capsuleAxis);
+
+	virtual plCollisionShapeHandle createCompoundShape(plCollisionWorldHandle worldHandle);
+	virtual void addChildShape(plCollisionWorldHandle worldHandle, plCollisionShapeHandle compoundShape, plCollisionShapeHandle childShape, plVector3 childPos, plQuaternion childOrn);
+
+	virtual void deleteShape(plCollisionWorldHandle worldHandle, plCollisionShapeHandle shape);
+
+	virtual void addCollisionObject(plCollisionWorldHandle world, plCollisionObjectHandle object);
+	virtual void removeCollisionObject(plCollisionWorldHandle world, plCollisionObjectHandle object);
+
+	virtual plCollisionObjectHandle createCollisionObject(plCollisionWorldHandle worldHandle, void* userPointer, int userIndex, plCollisionShapeHandle cshape,
+														  plVector3 startPosition, plQuaternion startOrientation);
+	virtual void deleteCollisionObject(plCollisionObjectHandle body);
+	virtual void setCollisionObjectTransform(plCollisionWorldHandle world, plCollisionObjectHandle body,
+											 plVector3 position, plQuaternion orientation);
+
+	virtual int collide(plCollisionWorldHandle world, plCollisionObjectHandle colA, plCollisionObjectHandle colB,
+						lwContactPoint* pointsOut, int pointCapacity);
+
+	virtual void collideWorld(plCollisionWorldHandle world,
+							  plNearCallback filter, void* userData);
+
+	static plCollisionSdkHandle createBullet2SdkHandle();
+};
+
+#endif  //BULLET2_COLLISION_SDK_H
diff --git a/engine/inc/bullet/Collision/Internal/CollisionSdkInterface.h b/engine/inc/bullet/Collision/Internal/CollisionSdkInterface.h
new file mode 100644
index 00000000..88c1d8af
--- /dev/null
+++ b/engine/inc/bullet/Collision/Internal/CollisionSdkInterface.h
@@ -0,0 +1,51 @@
+#ifndef COLLISION_SDK_INTERFACE_H
+#define COLLISION_SDK_INTERFACE_H
+
+#include "../CollisionSdkC_Api.h"
+
+class CollisionSdkInterface
+{
+public:
+	virtual ~CollisionSdkInterface()
+	{
+	}
+
+	virtual plCollisionWorldHandle createCollisionWorld(int maxNumObjsCapacity, int maxNumShapesCapacity, int maxNumPairsCapacity) = 0;
+
+	virtual void deleteCollisionWorld(plCollisionWorldHandle worldHandle) = 0;
+
+	virtual plCollisionShapeHandle createSphereShape(plCollisionWorldHandle worldHandle, plReal radius) = 0;
+
+	virtual plCollisionShapeHandle createPlaneShape(plCollisionWorldHandle worldHandle,
+													plReal planeNormalX,
+													plReal planeNormalY,
+													plReal planeNormalZ,
+													plReal planeConstant) = 0;
+
+	virtual plCollisionShapeHandle createCapsuleShape(plCollisionWorldHandle worldHandle,
+													  plReal radius,
+													  plReal height,
+													  int capsuleAxis) = 0;
+
+	virtual plCollisionShapeHandle createCompoundShape(plCollisionWorldHandle worldHandle) = 0;
+	virtual void addChildShape(plCollisionWorldHandle worldHandle, plCollisionShapeHandle compoundShape, plCollisionShapeHandle childShape, plVector3 childPos, plQuaternion childOrn) = 0;
+
+	virtual void deleteShape(plCollisionWorldHandle worldHandle, plCollisionShapeHandle shape) = 0;
+
+	virtual void addCollisionObject(plCollisionWorldHandle world, plCollisionObjectHandle object) = 0;
+	virtual void removeCollisionObject(plCollisionWorldHandle world, plCollisionObjectHandle object) = 0;
+
+	virtual plCollisionObjectHandle createCollisionObject(plCollisionWorldHandle worldHandle, void* userPointer, int userIndex, plCollisionShapeHandle cshape,
+														  plVector3 startPosition, plQuaternion startOrientation) = 0;
+	virtual void deleteCollisionObject(plCollisionObjectHandle body) = 0;
+	virtual void setCollisionObjectTransform(plCollisionWorldHandle world, plCollisionObjectHandle body,
+											 plVector3 position, plQuaternion orientation) = 0;
+
+	virtual int collide(plCollisionWorldHandle world, plCollisionObjectHandle colA, plCollisionObjectHandle colB,
+						lwContactPoint* pointsOut, int pointCapacity) = 0;
+
+	virtual void collideWorld(plCollisionWorldHandle world,
+							  plNearCallback filter, void* userData) = 0;
+};
+
+#endif  //COLLISION_SDK_INTERFACE_H
diff --git a/engine/inc/bullet/Collision/Internal/RealTimeBullet3CollisionSdk.h b/engine/inc/bullet/Collision/Internal/RealTimeBullet3CollisionSdk.h
new file mode 100644
index 00000000..76b4042e
--- /dev/null
+++ b/engine/inc/bullet/Collision/Internal/RealTimeBullet3CollisionSdk.h
@@ -0,0 +1,53 @@
+#ifndef REAL_TIME_COLLISION_SDK_H
+#define REAL_TIME_COLLISION_SDK_H
+
+#include "CollisionSdkInterface.h"
+
+class RealTimeBullet3CollisionSdk : public CollisionSdkInterface
+{
+	struct RealTimeBullet3CollisionSdkInternalData* m_internalData;
+
+public:
+	RealTimeBullet3CollisionSdk();
+
+	virtual ~RealTimeBullet3CollisionSdk();
+
+	virtual plCollisionWorldHandle createCollisionWorld(int maxNumObjsCapacity, int maxNumShapesCapacity, int maxNumPairsCapacity);
+
+	virtual void deleteCollisionWorld(plCollisionWorldHandle worldHandle);
+
+	virtual plCollisionShapeHandle createSphereShape(plCollisionWorldHandle worldHandle, plReal radius);
+	virtual plCollisionShapeHandle createPlaneShape(plCollisionWorldHandle worldHandle,
+													plReal planeNormalX,
+													plReal planeNormalY,
+													plReal planeNormalZ,
+													plReal planeConstant);
+	virtual plCollisionShapeHandle createCapsuleShape(plCollisionWorldHandle worldHandle,
+													  plReal radius,
+													  plReal height,
+													  int capsuleAxis);
+
+	virtual plCollisionShapeHandle createCompoundShape(plCollisionWorldHandle worldHandle);
+	virtual void addChildShape(plCollisionWorldHandle worldHandle, plCollisionShapeHandle compoundShape, plCollisionShapeHandle childShape, plVector3 childPos, plQuaternion childOrn);
+
+	virtual void deleteShape(plCollisionWorldHandle worldHandle, plCollisionShapeHandle shape);
+
+	virtual void addCollisionObject(plCollisionWorldHandle world, plCollisionObjectHandle object);
+	virtual void removeCollisionObject(plCollisionWorldHandle world, plCollisionObjectHandle object);
+
+	virtual plCollisionObjectHandle createCollisionObject(plCollisionWorldHandle worldHandle, void* userPointer, int userIndex, plCollisionShapeHandle cshape,
+														  plVector3 startPosition, plQuaternion startOrientation);
+	virtual void deleteCollisionObject(plCollisionObjectHandle body);
+	virtual void setCollisionObjectTransform(plCollisionWorldHandle world, plCollisionObjectHandle body,
+											 plVector3 position, plQuaternion orientation);
+
+	virtual int collide(plCollisionWorldHandle world, plCollisionObjectHandle colA, plCollisionObjectHandle colB,
+						lwContactPoint* pointsOut, int pointCapacity);
+
+	virtual void collideWorld(plCollisionWorldHandle world,
+							  plNearCallback filter, void* userData);
+
+	static plCollisionSdkHandle createRealTimeBullet3CollisionSdkHandle();
+};
+
+#endif  //REAL_TIME_COLLISION_SDK_H
diff --git a/engine/inc/bullet/CommonInterfaces/Common2dCanvasInterface.h b/engine/inc/bullet/CommonInterfaces/Common2dCanvasInterface.h
new file mode 100644
index 00000000..7d1e7f37
--- /dev/null
+++ b/engine/inc/bullet/CommonInterfaces/Common2dCanvasInterface.h
@@ -0,0 +1,15 @@
+#ifndef COMMON_2D_CANVAS_INTERFACE_H
+#define COMMON_2D_CANVAS_INTERFACE_H
+
+struct Common2dCanvasInterface
+{
+	virtual ~Common2dCanvasInterface() {}
+	virtual int createCanvas(const char* canvasName, int width, int height, int xPos, int yPos) = 0;
+	virtual void destroyCanvas(int canvasId) = 0;
+	virtual void setPixel(int canvasId, int x, int y, unsigned char red, unsigned char green, unsigned char blue, unsigned char alpha) = 0;
+	virtual void getPixel(int canvasId, int x, int y, unsigned char& red, unsigned char& green, unsigned char& blue, unsigned char& alpha) = 0;
+
+	virtual void refreshImageData(int canvasId) = 0;
+};
+
+#endif  //COMMON_2D_CANVAS_INTERFACE_H
diff --git a/engine/inc/bullet/CommonInterfaces/CommonCallbacks.h b/engine/inc/bullet/CommonInterfaces/CommonCallbacks.h
new file mode 100644
index 00000000..3047d143
--- /dev/null
+++ b/engine/inc/bullet/CommonInterfaces/CommonCallbacks.h
@@ -0,0 +1,48 @@
+#ifndef COMMON_CALLBACKS_H
+#define COMMON_CALLBACKS_H
+
+typedef void (*b3WheelCallback)(float deltax, float deltay);
+typedef void (*b3ResizeCallback)(float width, float height);
+typedef void (*b3MouseMoveCallback)(float x, float y);
+typedef void (*b3MouseButtonCallback)(int button, int state, float x, float y);
+typedef void (*b3KeyboardCallback)(int keycode, int state);
+typedef void (*b3RenderCallback)();
+
+enum
+{
+	B3G_ESCAPE = 27,
+	B3G_SPACE = 32,
+	B3G_F1 = 0xff00,
+	B3G_F2,
+	B3G_F3,
+	B3G_F4,
+	B3G_F5,
+	B3G_F6,
+	B3G_F7,
+	B3G_F8,
+	B3G_F9,
+	B3G_F10,
+	B3G_F11,
+	B3G_F12,
+	B3G_F13,
+	B3G_F14,
+	B3G_F15,
+	B3G_LEFT_ARROW,
+	B3G_RIGHT_ARROW,
+	B3G_UP_ARROW,
+	B3G_DOWN_ARROW,
+	B3G_PAGE_UP,
+	B3G_PAGE_DOWN,
+	B3G_END,
+	B3G_HOME,
+	B3G_INSERT,
+	B3G_DELETE,
+	B3G_BACKSPACE,
+	B3G_SHIFT,
+	B3G_CONTROL,
+	B3G_ALT,
+	B3G_RETURN,
+	
+};
+
+#endif
diff --git a/engine/inc/bullet/CommonInterfaces/CommonCameraInterface.h b/engine/inc/bullet/CommonInterfaces/CommonCameraInterface.h
new file mode 100644
index 00000000..e0cfaa28
--- /dev/null
+++ b/engine/inc/bullet/CommonInterfaces/CommonCameraInterface.h
@@ -0,0 +1,46 @@
+#ifndef COMMON_CAMERA_INTERFACE_H
+#define COMMON_CAMERA_INTERFACE_H
+
+struct CommonCameraInterface
+{
+	virtual ~CommonCameraInterface() {}
+	virtual void getCameraProjectionMatrix(float m[16]) const = 0;
+	virtual void getCameraViewMatrix(float m[16]) const = 0;
+
+	virtual void setVRCamera(const float viewMat[16], const float projectionMatrix[16]) = 0;
+	virtual void disableVRCamera() = 0;
+	virtual bool isVRCamera() const = 0;
+	virtual void setVRCameraOffsetTransform(const float offset[16]) = 0;
+
+	virtual void getCameraTargetPosition(float pos[3]) const = 0;
+	virtual void getCameraPosition(float pos[3]) const = 0;
+
+	virtual void getCameraTargetPosition(double pos[3]) const = 0;
+	virtual void getCameraPosition(double pos[3]) const = 0;
+
+	virtual void setCameraTargetPosition(float x, float y, float z) = 0;
+	virtual void setCameraDistance(float dist) = 0;
+	virtual float getCameraDistance() const = 0;
+
+	virtual void setCameraUpVector(float x, float y, float z) = 0;
+	virtual void getCameraUpVector(float up[3]) const = 0;
+	virtual void getCameraForwardVector(float fwd[3]) const = 0;
+
+	///the setCameraUpAxis will call the 'setCameraUpVector' and 'setCameraForwardVector'
+	virtual void setCameraUpAxis(int axis) = 0;
+	virtual int getCameraUpAxis() const = 0;
+
+	virtual void setCameraYaw(float yaw) = 0;
+	virtual float getCameraYaw() const = 0;
+
+	virtual void setCameraPitch(float pitch) = 0;
+	virtual float getCameraPitch() const = 0;
+
+	virtual void setAspectRatio(float ratio) = 0;
+	virtual float getAspectRatio() const = 0;
+
+	virtual float getCameraFrustumFar() const = 0;
+	virtual float getCameraFrustumNear() const = 0;
+};
+
+#endif  //COMMON_CAMERA_INTERFACE_H
diff --git a/engine/inc/bullet/CommonInterfaces/CommonDeformableBodyBase.h b/engine/inc/bullet/CommonInterfaces/CommonDeformableBodyBase.h
new file mode 100644
index 00000000..90dbf8f0
--- /dev/null
+++ b/engine/inc/bullet/CommonInterfaces/CommonDeformableBodyBase.h
@@ -0,0 +1,221 @@
+
+#ifndef COMMON_DEFORMABLE_BODY_SETUP_H
+#define COMMON_DEFORMABLE_BODY_SETUP_H
+#include "btBulletDynamicsCommon.h"
+#include "BulletDynamics/Featherstone/btMultiBodyDynamicsWorld.h"
+#include "BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h"
+#include "BulletDynamics/Featherstone/btMultiBodyPoint2Point.h"
+#include "BulletDynamics/Featherstone/btMultiBodyLinkCollider.h"
+#include "btBulletDynamicsCommon.h"
+#include "CommonExampleInterface.h"
+#include "CommonGUIHelperInterface.h"
+#include "CommonRenderInterface.h"
+#include "CommonGraphicsAppInterface.h"
+#include "CommonWindowInterface.h"
+#include "CommonCameraInterface.h"
+#include "CommonMultiBodyBase.h"
+#include "BulletSoftBody/btSoftBody.h"
+
+struct CommonDeformableBodyBase : public CommonMultiBodyBase
+{
+	btAlignedObjectArray<btDeformableLagrangianForce*> m_forces;
+	btSoftBody* m_pickedSoftBody;
+	btDeformableMousePickingForce* m_mouseForce;
+	btScalar m_pickingForceElasticStiffness, m_pickingForceDampingStiffness, m_maxPickingForce;
+	CommonDeformableBodyBase(GUIHelperInterface* helper)
+	: CommonMultiBodyBase(helper),
+	m_pickedSoftBody(0),
+	m_mouseForce(0),
+	m_pickingForceElasticStiffness(100),
+	m_pickingForceDampingStiffness(0.0),
+	m_maxPickingForce(0.3)
+	{
+	}
+
+	virtual btDeformableMultiBodyDynamicsWorld* getDeformableDynamicsWorld()
+	{
+		return (btDeformableMultiBodyDynamicsWorld*)m_dynamicsWorld;
+	}
+
+	virtual const btDeformableMultiBodyDynamicsWorld* getDeformableDynamicsWorld() const
+	{
+		return (btDeformableMultiBodyDynamicsWorld*)m_dynamicsWorld;
+	}
+	
+	struct ClosestRayResultCallbackWithInfo : public btCollisionWorld::ClosestRayResultCallback
+	{
+		ClosestRayResultCallbackWithInfo(const btVector3& rayFromWorld, const btVector3& rayToWorld)
+		: ClosestRayResultCallback(rayFromWorld, rayToWorld)
+		{
+		}
+		int m_faceId;
+		
+		virtual btScalar addSingleResult(btCollisionWorld::LocalRayResult& rayResult, bool normalInWorldSpace)
+		{
+			//caller already does the filter on the m_closestHitFraction
+			btAssert(rayResult.m_hitFraction <= m_closestHitFraction);
+			
+			m_closestHitFraction = rayResult.m_hitFraction;
+			m_collisionObject = rayResult.m_collisionObject;
+			if (rayResult.m_localShapeInfo)
+			{
+				m_faceId = rayResult.m_localShapeInfo->m_triangleIndex;
+			}
+			else
+			{
+				m_faceId = -1;
+			}
+			if (normalInWorldSpace)
+			{
+				m_hitNormalWorld = rayResult.m_hitNormalLocal;
+			}
+			else
+			{
+				///need to transform normal into worldspace
+				m_hitNormalWorld = m_collisionObject->getWorldTransform().getBasis() * rayResult.m_hitNormalLocal;
+			}
+			m_hitPointWorld.setInterpolate3(m_rayFromWorld, m_rayToWorld, rayResult.m_hitFraction);
+			return rayResult.m_hitFraction;
+		}
+	};
+	
+	virtual bool pickBody(const btVector3& rayFromWorld, const btVector3& rayToWorld)
+	{
+		if (getDeformableDynamicsWorld() == 0)
+			return false;
+		ClosestRayResultCallbackWithInfo rayCallback(rayFromWorld, rayToWorld);
+		getDeformableDynamicsWorld()->rayTest(rayFromWorld, rayToWorld, rayCallback);
+		if (rayCallback.hasHit())
+		{
+			btVector3 pickPos = rayCallback.m_hitPointWorld;
+			btRigidBody* body = (btRigidBody*)btRigidBody::upcast(rayCallback.m_collisionObject);
+			btSoftBody* psb = (btSoftBody*)btSoftBody::upcast(rayCallback.m_collisionObject);
+            m_oldPickingPos = rayToWorld;
+            m_hitPos = pickPos;
+            m_oldPickingDist = (pickPos - rayFromWorld).length();
+			if (body)
+			{
+				if (!(body->isStaticObject() || body->isKinematicObject()))
+				{
+					m_pickedBody = body;
+					m_pickedBody->setActivationState(DISABLE_DEACTIVATION);
+					btVector3 localPivot = body->getCenterOfMassTransform().inverse() * pickPos;
+					btPoint2PointConstraint* p2p = new btPoint2PointConstraint(*body, localPivot);
+					m_dynamicsWorld->addConstraint(p2p, true);
+					m_pickedConstraint = p2p;
+					btScalar mousePickClamping = 30.f;
+					p2p->m_setting.m_impulseClamp = mousePickClamping;
+					//very weak constraint for picking
+					p2p->m_setting.m_tau = 0.001f;
+				}
+			}
+			else if (psb)
+			{
+				int face_id = rayCallback.m_faceId;
+				if (face_id >= 0 && face_id < psb->m_faces.size())
+				{
+					m_pickedSoftBody = psb;
+					psb->setActivationState(DISABLE_DEACTIVATION);
+					const btSoftBody::Face& f = psb->m_faces[face_id];
+					btDeformableMousePickingForce* mouse_force = new btDeformableMousePickingForce(m_pickingForceElasticStiffness, m_pickingForceDampingStiffness, f, m_hitPos, m_maxPickingForce);
+					m_mouseForce = mouse_force;
+					getDeformableDynamicsWorld()->addForce(psb, mouse_force);
+				}
+			}
+			else
+			{
+				btMultiBodyLinkCollider* multiCol = (btMultiBodyLinkCollider*)btMultiBodyLinkCollider::upcast(rayCallback.m_collisionObject);
+				if (multiCol && multiCol->m_multiBody)
+				{
+					m_prevCanSleep = multiCol->m_multiBody->getCanSleep();
+					multiCol->m_multiBody->setCanSleep(false);
+
+					btVector3 pivotInA = multiCol->m_multiBody->worldPosToLocal(multiCol->m_link, pickPos);
+
+					btMultiBodyPoint2Point* p2p = new btMultiBodyPoint2Point(multiCol->m_multiBody, multiCol->m_link, 0, pivotInA, pickPos);
+					//if you add too much energy to the system, causing high angular velocities, simulation 'explodes'
+					//see also http://www.bulletphysics.org/Bullet/phpBB3/viewtopic.php?f=4&t=949
+					//so we try to avoid it by clamping the maximum impulse (force) that the mouse pick can apply
+					//it is not satisfying, hopefully we find a better solution (higher order integrator, using joint friction using a zero-velocity target motor with limited force etc?)
+					btScalar scaling = 1;
+					p2p->setMaxAppliedImpulse(2 * scaling);
+					btMultiBodyDynamicsWorld* world = (btMultiBodyDynamicsWorld*)m_dynamicsWorld;
+					world->addMultiBodyConstraint(p2p);
+					m_pickingMultiBodyPoint2Point = p2p;
+				}
+			}
+		}
+		return false;
+	}
+
+	virtual bool movePickedBody(const btVector3& rayFromWorld, const btVector3& rayToWorld)
+	{
+		if (m_pickedBody && m_pickedConstraint)
+		{
+			btPoint2PointConstraint* pickCon = static_cast<btPoint2PointConstraint*>(m_pickedConstraint);
+			if (pickCon)
+			{
+				//keep it at the same picking distance
+				btVector3 newPivotB;
+				btVector3 dir = rayToWorld - rayFromWorld;
+				dir.normalize();
+				dir *= m_oldPickingDist;
+				newPivotB = rayFromWorld + dir;
+				pickCon->setPivotB(newPivotB);
+				return true;
+			}
+		}
+		if (m_pickingMultiBodyPoint2Point)
+		{
+			//keep it at the same picking distance
+			btVector3 dir = rayToWorld - rayFromWorld;
+			dir.normalize();
+			dir *= m_oldPickingDist;
+			btVector3 newPivotB = rayFromWorld + dir;
+			m_pickingMultiBodyPoint2Point->setPivotInB(newPivotB);
+		}
+		if (m_pickedSoftBody && m_mouseForce)
+		{
+			btVector3 newPivot;
+			btVector3 dir = rayToWorld - rayFromWorld;
+			dir.normalize();
+			dir *= m_oldPickingDist;
+			newPivot = rayFromWorld + dir;
+			m_mouseForce->setMousePos(newPivot);
+		}
+		return false;
+	}
+
+	virtual void removePickingConstraint()
+	{
+		if (m_pickedConstraint)
+		{
+			m_dynamicsWorld->removeConstraint(m_pickedConstraint);
+
+			if (m_pickedBody)
+			{
+				m_pickedBody->forceActivationState(ACTIVE_TAG);
+				m_pickedBody->activate(true);
+			}
+			delete m_pickedConstraint;
+			m_pickedConstraint = 0;
+			m_pickedBody = 0;
+		}
+		if (m_pickingMultiBodyPoint2Point)
+		{
+			m_pickingMultiBodyPoint2Point->getMultiBodyA()->setCanSleep(m_prevCanSleep);
+			btMultiBodyDynamicsWorld* world = (btMultiBodyDynamicsWorld*)m_dynamicsWorld;
+			world->removeMultiBodyConstraint(m_pickingMultiBodyPoint2Point);
+			delete m_pickingMultiBodyPoint2Point;
+			m_pickingMultiBodyPoint2Point = 0;
+		}
+		if (m_pickedSoftBody)
+		{
+			getDeformableDynamicsWorld()->removeForce(m_pickedSoftBody, m_mouseForce);
+			delete m_mouseForce;
+			m_mouseForce = 0;
+			m_pickedSoftBody = 0;
+		}
+	}
+};
+#endif  //COMMON_MULTI_BODY_SETUP_H
diff --git a/engine/inc/bullet/CommonInterfaces/CommonExampleInterface.h b/engine/inc/bullet/CommonInterfaces/CommonExampleInterface.h
new file mode 100644
index 00000000..fc4e05ce
--- /dev/null
+++ b/engine/inc/bullet/CommonInterfaces/CommonExampleInterface.h
@@ -0,0 +1,96 @@
+
+
+#ifndef COMMON_EXAMPLE_INTERFACE_H
+#define COMMON_EXAMPLE_INTERFACE_H
+
+struct CommandProcessorCreationInterface
+{
+	virtual ~CommandProcessorCreationInterface() {}
+	virtual class CommandProcessorInterface* createCommandProcessor() = 0;
+	virtual void deleteCommandProcessor(CommandProcessorInterface*) = 0;
+};
+
+struct CommonExampleOptions
+{
+	struct GUIHelperInterface* m_guiHelper;
+
+	//Those are optional, some examples will use them others don't. Each example should work with them being 0.
+	int m_option;
+	const char* m_fileName;
+	class SharedMemoryInterface* m_sharedMem;
+	CommandProcessorCreationInterface* m_commandProcessorCreation;
+	bool m_skipGraphicsUpdate;
+
+	CommonExampleOptions(struct GUIHelperInterface* helper, int option = 0)
+		: m_guiHelper(helper),
+		  m_option(option),
+		  m_fileName(0),
+		  m_sharedMem(0),
+		  m_commandProcessorCreation(0),
+		  m_skipGraphicsUpdate(false)
+	{
+	}
+};
+
+class CommonExampleInterface
+{
+public:
+	typedef class CommonExampleInterface*(CreateFunc)(CommonExampleOptions& options);
+
+	virtual ~CommonExampleInterface()
+	{
+	}
+
+	virtual void initPhysics() = 0;
+	virtual void exitPhysics() = 0;
+	virtual void updateGraphics() {}
+	virtual void stepSimulation(float deltaTime) = 0;
+	virtual void renderScene() = 0;
+	virtual void physicsDebugDraw(int debugFlags) = 0;  //for now we reuse the flags in Bullet/src/LinearMath/btIDebugDraw.h
+	//reset camera is only called when switching demo. this way you can restart (initPhysics) and watch in a specific location easier
+	virtual void resetCamera(){};
+	virtual bool mouseMoveCallback(float x, float y) = 0;
+	virtual bool mouseButtonCallback(int button, int state, float x, float y) = 0;
+	virtual bool keyboardCallback(int key, int state) = 0;
+
+	virtual void vrControllerMoveCallback(int controllerId, float pos[4], float orientation[4], float analogAxis, float auxAnalogAxes[10]) {}
+	virtual void vrControllerButtonCallback(int controllerId, int button, int state, float pos[4], float orientation[4]) {}
+	virtual void vrHMDMoveCallback(int controllerId, float pos[4], float orientation[4]) {}
+	virtual void vrGenericTrackerMoveCallback(int controllerId, float pos[4], float orientation[4]) {}
+
+	virtual void processCommandLineArgs(int argc, char* argv[]){};
+};
+
+class ExampleEntries
+{
+public:
+	virtual ~ExampleEntries() {}
+
+	virtual void initExampleEntries() = 0;
+
+	virtual void initOpenCLExampleEntries() = 0;
+
+	virtual int getNumRegisteredExamples() = 0;
+
+	virtual CommonExampleInterface::CreateFunc* getExampleCreateFunc(int index) = 0;
+
+	virtual const char* getExampleName(int index) = 0;
+
+	virtual const char* getExampleDescription(int index) = 0;
+
+	virtual int getExampleOption(int index) = 0;
+};
+
+CommonExampleInterface* StandaloneExampleCreateFunc(CommonExampleOptions& options);
+
+#ifdef B3_USE_STANDALONE_EXAMPLE
+#define B3_STANDALONE_EXAMPLE(ExampleFunc)                                             \
+	CommonExampleInterface* StandaloneExampleCreateFunc(CommonExampleOptions& options) \
+	{                                                                                  \
+		return ExampleFunc(options);                                                   \
+	}
+#else  //B3_USE_STANDALONE_EXAMPLE
+#define B3_STANDALONE_EXAMPLE(ExampleFunc)
+#endif  //B3_USE_STANDALONE_EXAMPLE
+
+#endif  //COMMON_EXAMPLE_INTERFACE_H
diff --git a/engine/inc/bullet/CommonInterfaces/CommonFileIOInterface.h b/engine/inc/bullet/CommonInterfaces/CommonFileIOInterface.h
new file mode 100644
index 00000000..beb25edd
--- /dev/null
+++ b/engine/inc/bullet/CommonInterfaces/CommonFileIOInterface.h
@@ -0,0 +1,28 @@
+#ifndef COMMON_FILE_IO_INTERFACE_H
+#define COMMON_FILE_IO_INTERFACE_H
+
+struct CommonFileIOInterface
+{
+	int m_fileIOType;
+	const char* m_pathPrefix;
+
+	CommonFileIOInterface(int fileIOType, const char* pathPrefix)
+		:m_fileIOType(fileIOType),
+		m_pathPrefix(pathPrefix)
+	{
+	}
+
+	virtual ~CommonFileIOInterface()
+	{
+	}
+	virtual int fileOpen(const char* fileName, const char* mode)=0;
+	virtual int fileRead(int fileHandle, char* destBuffer, int numBytes)=0;
+	virtual int fileWrite(int fileHandle,const char* sourceBuffer, int numBytes)=0;
+	virtual void fileClose(int fileHandle)=0;
+	virtual bool findResourcePath(const char* fileName,  char* resourcePathOut, int resourcePathMaxNumBytes)=0;
+	virtual char* readLine(int fileHandle, char* destBuffer, int numBytes)=0;
+	virtual int getFileSize(int fileHandle)=0;
+	virtual void enableFileCaching(bool enable) = 0;
+};
+
+#endif //COMMON_FILE_IO_INTERFACE_H
\ No newline at end of file
diff --git a/engine/inc/bullet/CommonInterfaces/CommonGUIHelperInterface.h b/engine/inc/bullet/CommonInterfaces/CommonGUIHelperInterface.h
new file mode 100644
index 00000000..4ba413ef
--- /dev/null
+++ b/engine/inc/bullet/CommonInterfaces/CommonGUIHelperInterface.h
@@ -0,0 +1,227 @@
+#ifndef GUI_HELPER_INTERFACE_H
+#define GUI_HELPER_INTERFACE_H
+class btRigidBody;
+class btVector3;
+class btCollisionObject;
+class btDiscreteDynamicsWorld;
+class btCollisionShape;
+struct Common2dCanvasInterface;
+struct CommonParameterInterface;
+struct CommonRenderInterface;
+struct CommonGraphicsApp;
+
+struct GUISyncPosition
+{
+	int m_graphicsInstanceId;
+	float m_pos[4];
+	float m_orn[4];
+};
+
+typedef void (*VisualizerFlagCallback)(int flag, bool enable);
+
+///The Bullet 2 GraphicsPhysicsBridge let's the graphics engine create graphics representation and synchronize
+struct GUIHelperInterface
+{
+	virtual ~GUIHelperInterface() {}
+
+	virtual void createRigidBodyGraphicsObject(btRigidBody* body, const btVector3& color) = 0;
+
+	virtual void createCollisionObjectGraphicsObject(btCollisionObject* obj, const btVector3& color) = 0;
+
+	virtual void createCollisionShapeGraphicsObject(btCollisionShape* collisionShape) = 0;
+
+	virtual void syncPhysicsToGraphics(const btDiscreteDynamicsWorld* rbWorld) = 0;
+	virtual void syncPhysicsToGraphics2(const btDiscreteDynamicsWorld* rbWorld) {}
+	virtual void syncPhysicsToGraphics2(const GUISyncPosition* positions, int numPositions) {}
+	
+	virtual void render(const btDiscreteDynamicsWorld* rbWorld) = 0;
+
+	virtual void createPhysicsDebugDrawer(btDiscreteDynamicsWorld* rbWorld) = 0;
+
+	virtual int registerTexture(const unsigned char* texels, int width, int height) = 0;
+	virtual int registerGraphicsShape(const float* vertices, int numvertices, const int* indices, int numIndices, int primitiveType, int textureId) = 0;
+	virtual int registerGraphicsInstance(int shapeIndex, const float* position, const float* quaternion, const float* color, const float* scaling) = 0;
+	virtual void removeAllGraphicsInstances() = 0;
+	virtual void removeGraphicsInstance(int graphicsUid) {}
+	virtual void changeInstanceFlags(int instanceUid, int flags) {}
+	virtual void changeRGBAColor(int instanceUid, const double rgbaColor[4]) {}
+	virtual void changeScaling(int instanceUid, const double scaling[3]) {}
+	virtual void changeSpecularColor(int instanceUid, const double specularColor[3]) {}
+	virtual void changeTexture(int textureUniqueId, const unsigned char* rgbTexels, int width, int height) {}
+	virtual void updateShape(int shapeIndex, float* vertices, int numVertices) {}
+	virtual int getShapeIndexFromInstance(int instanceUid) { return -1; }
+	virtual void replaceTexture(int shapeIndex, int textureUid) {}
+	virtual void removeTexture(int textureUid) {}
+
+	virtual Common2dCanvasInterface* get2dCanvasInterface() = 0;
+
+	virtual CommonParameterInterface* getParameterInterface() = 0;
+
+	virtual CommonRenderInterface* getRenderInterface() = 0;
+
+	virtual const CommonRenderInterface* getRenderInterface() const
+	{
+		return 0;
+	}
+
+	virtual CommonGraphicsApp* getAppInterface() = 0;
+
+	virtual void setUpAxis(int axis) = 0;
+
+	virtual void resetCamera(float camDist, float yaw, float pitch, float camPosX, float camPosY, float camPosZ) = 0;
+
+	virtual bool getCameraInfo(int* width, int* height, float viewMatrix[16], float projectionMatrix[16], float camUp[3], float camForward[3], float hor[3], float vert[3], float* yaw, float* pitch, float* camDist, float camTarget[3]) const
+	{
+		return false;
+	}
+
+	virtual void setVisualizerFlag(int flag, int enable){};
+
+	virtual void copyCameraImageData(const float viewMatrix[16], const float projectionMatrix[16],
+									 unsigned char* pixelsRGBA, int rgbaBufferSizeInPixels,
+									 float* depthBuffer, int depthBufferSizeInPixels,
+									 int startPixelIndex, int destinationWidth, int destinationHeight, int* numPixelsCopied)
+	{
+		copyCameraImageData(viewMatrix, projectionMatrix, pixelsRGBA, rgbaBufferSizeInPixels,
+							depthBuffer, depthBufferSizeInPixels,
+							0, 0,
+							startPixelIndex, destinationWidth,
+							destinationHeight, numPixelsCopied);
+	}
+
+	virtual void copyCameraImageData(const float viewMatrix[16], const float projectionMatrix[16],
+									 unsigned char* pixelsRGBA, int rgbaBufferSizeInPixels,
+									 float* depthBuffer, int depthBufferSizeInPixels,
+									 int* segmentationMaskBuffer, int segmentationMaskBufferSizeInPixels,
+									 int startPixelIndex, int destinationWidth, int destinationHeight, int* numPixelsCopied) = 0;
+	virtual void debugDisplayCameraImageData(const float viewMatrix[16], const float projectionMatrix[16],
+											 unsigned char* pixelsRGBA, int rgbaBufferSizeInPixels,
+											 float* depthBuffer, int depthBufferSizeInPixels,
+											 int* segmentationMaskBuffer, int segmentationMaskBufferSizeInPixels,
+											 int startPixelIndex, int destinationWidth, int destinationHeight, int* numPixelsCopied) {}
+
+	virtual void setProjectiveTextureMatrices(const float viewMatrix[16], const float projectionMatrix[16]) {}
+	virtual void setProjectiveTexture(bool useProjectiveTexture) {}
+
+	virtual void autogenerateGraphicsObjects(btDiscreteDynamicsWorld* rbWorld) = 0;
+
+	virtual void drawText3D(const char* txt, float posX, float posY, float posZ, float size) {}
+	virtual void drawText3D(const char* txt, float position[3], float orientation[4], float color[4], float size, int optionFlag) {}
+
+	virtual int addUserDebugText3D(const char* txt, const double positionXYZ[3], const double orientation[4], const double textColorRGB[3], double size, double lifeTime, int trackingVisualShapeIndex, int optionFlags, int replaceItemUid) { return -1; }
+	virtual int addUserDebugLine(const double debugLineFromXYZ[3], const double debugLineToXYZ[3], const double debugLineColorRGB[3], double lineWidth, double lifeTime, int trackingVisualShapeIndex, int replaceItemUid) { return -1; };
+	virtual int addUserDebugParameter(const char* txt, double rangeMin, double rangeMax, double startValue) { return -1; };
+	virtual int readUserDebugParameter(int itemUniqueId, double* value) { return 0; }
+
+	virtual void removeUserDebugItem(int debugItemUniqueId){};
+	virtual void removeAllUserDebugItems(){};
+	virtual void removeAllUserParameters() {};
+	
+	virtual void setVisualizerFlagCallback(VisualizerFlagCallback callback) {}
+
+	//empty name stops dumping video
+	virtual void dumpFramesToVideo(const char* mp4FileName){};
+	virtual void drawDebugDrawerLines(){}
+	virtual void clearLines(){}
+};
+
+///the DummyGUIHelper does nothing, so we can test the examples without GUI/graphics (in 'console mode')
+struct DummyGUIHelper : public GUIHelperInterface
+{
+	DummyGUIHelper() 
+	{
+
+	}
+	virtual ~DummyGUIHelper() {}
+
+	virtual void createRigidBodyGraphicsObject(btRigidBody* body, const btVector3& color) {}
+
+	virtual void createCollisionObjectGraphicsObject(btCollisionObject* obj, const btVector3& color) {}
+
+	virtual void createCollisionShapeGraphicsObject(btCollisionShape* collisionShape) {}
+
+	virtual void syncPhysicsToGraphics(const btDiscreteDynamicsWorld* rbWorld) {}
+
+	virtual void render(const btDiscreteDynamicsWorld* rbWorld) {}
+
+	virtual void createPhysicsDebugDrawer(btDiscreteDynamicsWorld* rbWorld) {}
+
+	virtual int registerTexture(const unsigned char* texels, int width, int height) { return -1; }
+	virtual int registerGraphicsShape(const float* vertices, int numvertices, const int* indices, int numIndices, int primitiveType, int textureId) { return -1; }
+	virtual int registerGraphicsInstance(int shapeIndex, const float* position, const float* quaternion, const float* color, const float* scaling) { return -1; }
+	virtual void removeAllGraphicsInstances() {}
+	virtual void removeGraphicsInstance(int graphicsUid) {}
+	virtual void changeRGBAColor(int instanceUid, const double rgbaColor[4]) {}
+	virtual void changeScaling(int instanceUid, const double scaling[3]) {}
+
+	virtual Common2dCanvasInterface* get2dCanvasInterface()
+	{
+		return 0;
+	}
+
+	virtual CommonParameterInterface* getParameterInterface()
+	{
+		return 0;
+	}
+
+	virtual CommonRenderInterface* getRenderInterface()
+	{
+		return 0;
+	}
+
+	virtual CommonGraphicsApp* getAppInterface()
+	{
+		return 0;
+	}
+
+	virtual void setUpAxis(int axis)
+	{
+	}
+	virtual void resetCamera(float camDist, float yaw, float pitch, float camPosX, float camPosY, float camPosZ)
+	{
+	}
+
+	virtual void copyCameraImageData(const float viewMatrix[16], const float projectionMatrix[16],
+									 unsigned char* pixelsRGBA, int rgbaBufferSizeInPixels,
+									 float* depthBuffer, int depthBufferSizeInPixels,
+									 int* segmentationMaskBuffer, int segmentationMaskBufferSizeInPixels,
+									 int startPixelIndex, int width, int height, int* numPixelsCopied)
+
+	{
+		if (numPixelsCopied)
+			*numPixelsCopied = 0;
+	}
+
+	virtual void setProjectiveTextureMatrices(const float viewMatrix[16], const float projectionMatrix[16])
+	{
+	}
+
+	virtual void setProjectiveTexture(bool useProjectiveTexture)
+	{
+	}
+
+	virtual void autogenerateGraphicsObjects(btDiscreteDynamicsWorld* rbWorld)
+	{
+	}
+
+	virtual void drawText3D(const char* txt, float posX, float posZY, float posZ, float size)
+	{
+	}
+
+	virtual void drawText3D(const char* txt, float position[3], float orientation[4], float color[4], float size, int optionFlag)
+	{
+	}
+
+	virtual int addUserDebugLine(const double debugLineFromXYZ[3], const double debugLineToXYZ[3], const double debugLineColorRGB[3], double lineWidth, double lifeTime, int trackingVisualShapeIndex, int replaceItemUid)
+	{
+		return -1;
+	}
+	virtual void removeUserDebugItem(int debugItemUniqueId)
+	{
+	}
+	virtual void removeAllUserDebugItems()
+	{
+	}
+};
+
+#endif  //GUI_HELPER_INTERFACE_H
diff --git a/engine/inc/bullet/CommonInterfaces/CommonGraphicsAppInterface.h b/engine/inc/bullet/CommonInterfaces/CommonGraphicsAppInterface.h
new file mode 100644
index 00000000..a3d9d3ea
--- /dev/null
+++ b/engine/inc/bullet/CommonInterfaces/CommonGraphicsAppInterface.h
@@ -0,0 +1,287 @@
+#ifndef COMMON_GRAPHICS_APP_H
+#define COMMON_GRAPHICS_APP_H
+
+#include "Bullet3Common/b3Vector3.h"
+#include "CommonRenderInterface.h"
+#include "CommonWindowInterface.h"
+#include "CommonCameraInterface.h"
+
+struct DrawGridData
+{
+	int gridSize;
+	float upOffset;
+	int upAxis;
+	float gridColor[4];
+
+	DrawGridData(int upAx = 1)
+		: gridSize(10),
+		upOffset(0.001f),
+		upAxis(upAx)
+	{
+		gridColor[0] = 0.6f;
+		gridColor[1] = 0.6f;
+		gridColor[2] = 0.6f;
+		gridColor[3] = 1.f;
+	}
+};
+
+enum EnumSphereLevelOfDetail
+{
+	SPHERE_LOD_POINT_SPRITE = 0,
+	SPHERE_LOD_LOW,
+	SPHERE_LOD_MEDIUM,
+	SPHERE_LOD_HIGH,
+
+};
+struct CommonGraphicsApp
+{
+	enum drawText3DOption
+	{
+		eDrawText3D_OrtogonalFaceCamera = 1,
+		eDrawText3D_TrueType = 2,
+		eDrawText3D_TrackObject = 4,
+	};
+	class CommonWindowInterface* m_window;
+	struct CommonRenderInterface* m_renderer;
+	struct CommonParameterInterface* m_parameterInterface;
+	struct Common2dCanvasInterface* m_2dCanvasInterface;
+
+	bool m_leftMouseButton;
+	bool m_middleMouseButton;
+	bool m_rightMouseButton;
+	float m_wheelMultiplier;
+	float m_mouseMoveMultiplier;
+	float m_mouseXpos;
+	float m_mouseYpos;
+	bool m_mouseInitialized;
+	float m_backgroundColorRGB[3];
+
+	CommonGraphicsApp()
+		: m_window(0),
+		m_renderer(0),
+		m_parameterInterface(0),
+		m_2dCanvasInterface(0),
+		m_leftMouseButton(false),
+		m_middleMouseButton(false),
+		m_rightMouseButton(false),
+		m_wheelMultiplier(0.01f),
+		m_mouseMoveMultiplier(0.4f),
+		m_mouseXpos(0.f),
+		m_mouseYpos(0.f),
+		m_mouseInitialized(false)
+	{
+		m_backgroundColorRGB[0] = 0.7;
+		m_backgroundColorRGB[1] = 0.7;
+		m_backgroundColorRGB[2] = 0.8;
+	}
+	virtual ~CommonGraphicsApp()
+	{
+	}
+
+	virtual void dumpNextFrameToPng(const char* pngFilename) {}
+	virtual void dumpFramesToVideo(const char* mp4Filename) {}
+
+	virtual void getScreenPixels(unsigned char* rgbaBuffer, int bufferSizeInBytes, float* depthBuffer, int depthBufferSizeInBytes) {}
+	virtual void setViewport(int width, int height) {}
+
+	virtual void getBackgroundColor(float* red, float* green, float* blue) const
+	{
+		if (red)
+			*red = m_backgroundColorRGB[0];
+		if (green)
+			*green = m_backgroundColorRGB[1];
+		if (blue)
+			*blue = m_backgroundColorRGB[2];
+	}
+	virtual void setMp4Fps(int fps) {}
+	virtual void setBackgroundColor(float red, float green, float blue)
+	{
+		m_backgroundColorRGB[0] = red;
+		m_backgroundColorRGB[1] = green;
+		m_backgroundColorRGB[2] = blue;
+	}
+	virtual void setMouseWheelMultiplier(float mult)
+	{
+		m_wheelMultiplier = mult;
+	}
+	virtual float getMouseWheelMultiplier() const
+	{
+		return m_wheelMultiplier;
+	}
+
+	virtual void setMouseMoveMultiplier(float mult)
+	{
+		m_mouseMoveMultiplier = mult;
+	}
+
+	virtual float getMouseMoveMultiplier() const
+	{
+		return m_mouseMoveMultiplier;
+	}
+
+	virtual void drawGrid(DrawGridData data = DrawGridData()) = 0;
+	virtual void setUpAxis(int axis) = 0;
+	virtual int getUpAxis() const = 0;
+
+	virtual void swapBuffer() = 0;
+	virtual void drawText(const char* txt, int posX, int posY)
+	{
+		float size = 1;
+		float colorRGBA[4] = { 0, 0, 0, 1 };
+		drawText(txt, posX, posY, size, colorRGBA);
+	}
+
+	virtual void drawText(const char* txt, int posX, int posY, float size)
+	{
+		float colorRGBA[4] = { 0, 0, 0, 1 };
+		drawText(txt, posX, posY, size, colorRGBA);
+	}
+	virtual void drawText(const char* txt, int posX, int posY, float size, float colorRGBA[4]) = 0;
+	virtual void drawText3D(const char* txt, float posX, float posY, float posZ, float size) = 0;
+	virtual void drawText3D(const char* txt, float position[3], float orientation[4], float color[4], float size, int optionFlag) = 0;
+	virtual void drawTexturedRect(float x0, float y0, float x1, float y1, float color[4], float u0, float v0, float u1, float v1, int useRGBA) = 0;
+	virtual int registerCubeShape(float halfExtentsX, float halfExtentsY, float halfExtentsZ, int textureIndex = -1, float textureScaling = 1) = 0;
+	virtual int registerGraphicsUnitSphereShape(EnumSphereLevelOfDetail lod, int textureId = -1) = 0;
+
+	virtual void registerGrid(int xres, int yres, float color0[4], float color1[4]) = 0;
+
+	void defaultMouseButtonCallback(int button, int state, float x, float y)
+	{
+		if (button == 0)
+			m_leftMouseButton = (state == 1);
+		if (button == 1)
+			m_middleMouseButton = (state == 1);
+
+		if (button == 2)
+			m_rightMouseButton = (state == 1);
+
+		m_mouseXpos = x;
+		m_mouseYpos = y;
+		m_mouseInitialized = true;
+	}
+	void defaultMouseMoveCallback(float x, float y)
+	{
+		if (m_window && m_renderer)
+		{
+			CommonCameraInterface* camera = m_renderer->getActiveCamera();
+
+			bool isAltPressed = m_window->isModifierKeyPressed(B3G_ALT);
+			bool isControlPressed = m_window->isModifierKeyPressed(B3G_CONTROL);
+
+			if (isAltPressed || isControlPressed)
+			{
+				float xDelta = x - m_mouseXpos;
+				float yDelta = y - m_mouseYpos;
+				float cameraDistance = camera->getCameraDistance();
+				float pitch = camera->getCameraPitch();
+				float yaw = camera->getCameraYaw();
+
+				float targPos[3];
+				float camPos[3];
+
+				camera->getCameraTargetPosition(targPos);
+				camera->getCameraPosition(camPos);
+
+				b3Vector3 cameraPosition = b3MakeVector3(b3Scalar(camPos[0]),
+					b3Scalar(camPos[1]),
+					b3Scalar(camPos[2]));
+
+				b3Vector3 cameraTargetPosition = b3MakeVector3(b3Scalar(targPos[0]),
+					b3Scalar(targPos[1]),
+					b3Scalar(targPos[2]));
+				b3Vector3 cameraUp = b3MakeVector3(0, 0, 0);
+				cameraUp[camera->getCameraUpAxis()] = 1.f;
+
+				if (m_leftMouseButton)
+				{
+					//			if (b3Fabs(xDelta)>b3Fabs(yDelta))
+					//			{
+					pitch -= yDelta * m_mouseMoveMultiplier;
+					//			} else
+					//			{
+					yaw -= xDelta * m_mouseMoveMultiplier;
+					//			}
+				}
+
+				if (m_middleMouseButton)
+				{
+					cameraTargetPosition += cameraUp * yDelta *m_mouseMoveMultiplier* 0.01;
+
+					b3Vector3 fwd = cameraTargetPosition - cameraPosition;
+					b3Vector3 side = cameraUp.cross(fwd);
+					side.normalize();
+					cameraTargetPosition += side * xDelta *m_mouseMoveMultiplier* 0.01;
+				}
+				if (m_rightMouseButton)
+				{
+					cameraDistance -= xDelta * m_mouseMoveMultiplier*0.01f;
+					cameraDistance -= yDelta * m_mouseMoveMultiplier*0.01f;
+					if (cameraDistance < 1)
+						cameraDistance = 1;
+					if (cameraDistance > 1000)
+						cameraDistance = 1000;
+				}
+				camera->setCameraDistance(cameraDistance);
+				camera->setCameraPitch(pitch);
+				camera->setCameraYaw(yaw);
+				camera->setCameraTargetPosition(cameraTargetPosition[0], cameraTargetPosition[1], cameraTargetPosition[2]);
+			}
+
+		}  //m_window &&  m_renderer
+
+		m_mouseXpos = x;
+		m_mouseYpos = y;
+		m_mouseInitialized = true;
+	}
+	//	void defaultKeyboardCallback(int key, int state)
+	//	{
+	//	}
+	void defaultWheelCallback(float deltax, float deltay)
+	{
+		if (m_renderer)
+		{
+			b3Vector3 cameraTargetPosition, cameraPosition, cameraUp = b3MakeVector3(0, 0, 0);
+			cameraUp[getUpAxis()] = 1;
+			CommonCameraInterface* camera = m_renderer->getActiveCamera();
+
+			camera->getCameraPosition(cameraPosition);
+			camera->getCameraTargetPosition(cameraTargetPosition);
+
+			if (!m_leftMouseButton)
+			{
+				float cameraDistance = camera->getCameraDistance();
+				if (deltay < 0 || cameraDistance > 1)
+				{
+					cameraDistance -= deltay*m_wheelMultiplier;
+					if (cameraDistance < 1)
+						cameraDistance = 1;
+					camera->setCameraDistance(cameraDistance);
+				}
+				else
+				{
+					b3Vector3 fwd = cameraTargetPosition - cameraPosition;
+					fwd.normalize();
+					cameraTargetPosition += fwd * deltay * m_wheelMultiplier;  //todo: expose it in the GUI?
+				}
+			}
+			else
+			{
+				if (b3Fabs(deltax) > b3Fabs(deltay))
+				{
+					b3Vector3 fwd = cameraTargetPosition - cameraPosition;
+					b3Vector3 side = cameraUp.cross(fwd);
+					side.normalize();
+					cameraTargetPosition += side * deltax * m_wheelMultiplier;
+				}
+				else
+				{
+					cameraTargetPosition -= cameraUp * deltay * m_wheelMultiplier;
+				}
+			}
+
+			camera->setCameraTargetPosition(cameraTargetPosition[0], cameraTargetPosition[1], cameraTargetPosition[2]);
+		}
+	}
+};
+
+#endif  //COMMON_GRAPHICS_APP_H
diff --git a/engine/inc/bullet/CommonInterfaces/CommonMultiBodyBase.h b/engine/inc/bullet/CommonInterfaces/CommonMultiBodyBase.h
new file mode 100644
index 00000000..ad6c2a4c
--- /dev/null
+++ b/engine/inc/bullet/CommonInterfaces/CommonMultiBodyBase.h
@@ -0,0 +1,524 @@
+
+#ifndef COMMON_MULTI_BODY_SETUP_H
+#define COMMON_MULTI_BODY_SETUP_H
+
+#include "btBulletDynamicsCommon.h"
+
+#include "BulletDynamics/Featherstone/btMultiBodyDynamicsWorld.h"
+#include "BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h"
+#include "BulletDynamics/Featherstone/btMultiBodyPoint2Point.h"
+#include "BulletDynamics/Featherstone/btMultiBodyLinkCollider.h"
+
+#include "btBulletDynamicsCommon.h"
+#include "CommonExampleInterface.h"
+#include "CommonGUIHelperInterface.h"
+#include "CommonRenderInterface.h"
+#include "CommonGraphicsAppInterface.h"
+#include "CommonWindowInterface.h"
+#include "CommonCameraInterface.h"
+
+enum MyFilterModes
+{
+	FILTER_GROUPAMASKB_AND_GROUPBMASKA2 = 0,
+	FILTER_GROUPAMASKB_OR_GROUPBMASKA2
+};
+
+struct MyOverlapFilterCallback2 : public btOverlapFilterCallback
+{
+	int m_filterMode;
+
+	MyOverlapFilterCallback2()
+		: m_filterMode(FILTER_GROUPAMASKB_AND_GROUPBMASKA2)
+	{
+	}
+
+	virtual ~MyOverlapFilterCallback2()
+	{
+	}
+	// return true when pairs need collision
+	virtual bool needBroadphaseCollision(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1) const
+	{
+		if (m_filterMode == FILTER_GROUPAMASKB_AND_GROUPBMASKA2)
+		{
+			bool collides = (proxy0->m_collisionFilterGroup & proxy1->m_collisionFilterMask) != 0;
+			collides = collides && (proxy1->m_collisionFilterGroup & proxy0->m_collisionFilterMask);
+			return collides;
+		}
+
+		if (m_filterMode == FILTER_GROUPAMASKB_OR_GROUPBMASKA2)
+		{
+			bool collides = (proxy0->m_collisionFilterGroup & proxy1->m_collisionFilterMask) != 0;
+			collides = collides || (proxy1->m_collisionFilterGroup & proxy0->m_collisionFilterMask);
+			return collides;
+		}
+		return false;
+	}
+};
+
+struct CommonMultiBodyBase : public CommonExampleInterface
+{
+	//keep the collision shapes, for deletion/cleanup
+	btAlignedObjectArray<btCollisionShape*> m_collisionShapes;
+	MyOverlapFilterCallback2* m_filterCallback;
+	btOverlappingPairCache* m_pairCache;
+	btBroadphaseInterface* m_broadphase;
+	btCollisionDispatcher* m_dispatcher;
+	btMultiBodyConstraintSolver* m_solver;
+	btDefaultCollisionConfiguration* m_collisionConfiguration;
+	btMultiBodyDynamicsWorld* m_dynamicsWorld;
+
+	//data for picking objects
+	class btRigidBody* m_pickedBody;
+	class btTypedConstraint* m_pickedConstraint;
+	class btMultiBodyPoint2Point* m_pickingMultiBodyPoint2Point;
+
+	btVector3 m_oldPickingPos;
+	btVector3 m_hitPos;
+	btScalar m_oldPickingDist;
+	bool m_prevCanSleep;
+
+	struct GUIHelperInterface* m_guiHelper;
+
+	CommonMultiBodyBase(GUIHelperInterface* helper)
+		: m_filterCallback(0),
+		  m_pairCache(0),
+		  m_broadphase(0),
+		  m_dispatcher(0),
+		  m_solver(0),
+		  m_collisionConfiguration(0),
+		  m_dynamicsWorld(0),
+		  m_pickedBody(0),
+		  m_pickedConstraint(0),
+		  m_pickingMultiBodyPoint2Point(0),
+		  m_prevCanSleep(false),
+		  m_guiHelper(helper)
+	{
+	}
+
+	virtual void createEmptyDynamicsWorld()
+	{
+		///collision configuration contains default setup for memory, collision setup
+		m_collisionConfiguration = new btDefaultCollisionConfiguration();
+		//m_collisionConfiguration->setConvexConvexMultipointIterations();
+		m_filterCallback = new MyOverlapFilterCallback2();
+
+		///use the default collision dispatcher. For parallel processing you can use a diffent dispatcher (see Extras/BulletMultiThreaded)
+		m_dispatcher = new btCollisionDispatcher(m_collisionConfiguration);
+
+		m_pairCache = new btHashedOverlappingPairCache();
+
+		m_pairCache->setOverlapFilterCallback(m_filterCallback);
+
+		m_broadphase = new btDbvtBroadphase(m_pairCache);  //btSimpleBroadphase();
+
+		m_solver = new btMultiBodyConstraintSolver;
+
+		m_dynamicsWorld = new btMultiBodyDynamicsWorld(m_dispatcher, m_broadphase, m_solver, m_collisionConfiguration);
+
+		m_dynamicsWorld->setGravity(btVector3(0, -10, 0));
+	}
+
+	virtual void stepSimulation(float deltaTime)
+	{
+		if (m_dynamicsWorld)
+		{
+			m_dynamicsWorld->stepSimulation(deltaTime);
+		}
+	}
+
+	virtual void exitPhysics()
+	{
+		removePickingConstraint();
+		//cleanup in the reverse order of creation/initialization
+
+		//remove the rigidbodies from the dynamics world and delete them
+
+		if (m_dynamicsWorld)
+		{
+			int i;
+			for (i = m_dynamicsWorld->getNumConstraints() - 1; i >= 0; i--)
+			{
+				m_dynamicsWorld->removeConstraint(m_dynamicsWorld->getConstraint(i));
+			}
+
+			for (i = m_dynamicsWorld->getNumMultiBodyConstraints() - 1; i >= 0; i--)
+			{
+				btMultiBodyConstraint* mbc = m_dynamicsWorld->getMultiBodyConstraint(i);
+				m_dynamicsWorld->removeMultiBodyConstraint(mbc);
+				delete mbc;
+			}
+
+			for (i = m_dynamicsWorld->getNumMultibodies() - 1; i >= 0; i--)
+			{
+				btMultiBody* mb = m_dynamicsWorld->getMultiBody(i);
+				m_dynamicsWorld->removeMultiBody(mb);
+				delete mb;
+			}
+			for (i = m_dynamicsWorld->getNumCollisionObjects() - 1; i >= 0; i--)
+			{
+				btCollisionObject* obj = m_dynamicsWorld->getCollisionObjectArray()[i];
+				btRigidBody* body = btRigidBody::upcast(obj);
+				if (body && body->getMotionState())
+				{
+					delete body->getMotionState();
+				}
+				m_dynamicsWorld->removeCollisionObject(obj);
+				delete obj;
+			}
+		}
+		//delete collision shapes
+		for (int j = 0; j < m_collisionShapes.size(); j++)
+		{
+			btCollisionShape* shape = m_collisionShapes[j];
+			delete shape;
+		}
+		m_collisionShapes.clear();
+
+		delete m_dynamicsWorld;
+		m_dynamicsWorld = 0;
+
+		delete m_solver;
+		m_solver = 0;
+
+		delete m_broadphase;
+		m_broadphase = 0;
+
+		delete m_dispatcher;
+		m_dispatcher = 0;
+
+		delete m_pairCache;
+		m_pairCache = 0;
+
+		delete m_filterCallback;
+		m_filterCallback = 0;
+
+		delete m_collisionConfiguration;
+		m_collisionConfiguration = 0;
+	}
+
+	virtual void syncPhysicsToGraphics()
+	{
+		if (m_dynamicsWorld)
+		{
+			m_guiHelper->syncPhysicsToGraphics(m_dynamicsWorld);
+		}
+	}
+
+	virtual void renderScene()
+	{
+		if (m_dynamicsWorld)
+		{
+			m_guiHelper->syncPhysicsToGraphics(m_dynamicsWorld);
+
+			m_guiHelper->render(m_dynamicsWorld);
+		}
+	}
+
+	virtual void physicsDebugDraw(int debugDrawFlags)
+	{
+		if (m_dynamicsWorld)
+		{
+			if (m_dynamicsWorld->getDebugDrawer())
+			{
+				m_dynamicsWorld->getDebugDrawer()->setDebugMode(debugDrawFlags);
+			}
+			m_dynamicsWorld->debugDrawWorld();
+		}
+	}
+
+	virtual bool keyboardCallback(int key, int state)
+	{
+		if ((key == B3G_F3) && state && m_dynamicsWorld)
+		{
+			btDefaultSerializer* serializer = new btDefaultSerializer();
+			m_dynamicsWorld->serialize(serializer);
+
+			FILE* file = fopen("testFile.bullet", "wb");
+			fwrite(serializer->getBufferPointer(), serializer->getCurrentBufferSize(), 1, file);
+			fclose(file);
+			//b3Printf("btDefaultSerializer wrote testFile.bullet");
+			delete serializer;
+			return true;
+		}
+		return false;  //don't handle this key
+	}
+
+	btVector3 getRayTo(int x, int y)
+	{
+		CommonRenderInterface* renderer = m_guiHelper->getRenderInterface();
+
+		if (!renderer)
+		{
+			btAssert(0);
+			return btVector3(0, 0, 0);
+		}
+
+		float top = 1.f;
+		float bottom = -1.f;
+		float nearPlane = 1.f;
+		float tanFov = (top - bottom) * 0.5f / nearPlane;
+		float fov = btScalar(2.0) * btAtan(tanFov);
+
+		btVector3 camPos, camTarget;
+		renderer->getActiveCamera()->getCameraPosition(camPos);
+		renderer->getActiveCamera()->getCameraTargetPosition(camTarget);
+
+		btVector3 rayFrom = camPos;
+		btVector3 rayForward = (camTarget - camPos);
+		rayForward.normalize();
+		float farPlane = 10000.f;
+		rayForward *= farPlane;
+
+		btVector3 rightOffset;
+		btVector3 cameraUp = btVector3(0, 0, 0);
+		cameraUp[m_guiHelper->getAppInterface()->getUpAxis()] = 1;
+
+		btVector3 vertical = cameraUp;
+
+		btVector3 hor;
+		hor = rayForward.cross(vertical);
+		hor.normalize();
+		vertical = hor.cross(rayForward);
+		vertical.normalize();
+
+		float tanfov = tanf(0.5f * fov);
+
+		hor *= 2.f * farPlane * tanfov;
+		vertical *= 2.f * farPlane * tanfov;
+
+		btScalar aspect;
+		float width = float(renderer->getScreenWidth());
+		float height = float(renderer->getScreenHeight());
+
+		aspect = width / height;
+
+		hor *= aspect;
+
+		btVector3 rayToCenter = rayFrom + rayForward;
+		btVector3 dHor = hor * 1.f / width;
+		btVector3 dVert = vertical * 1.f / height;
+
+		btVector3 rayTo = rayToCenter - 0.5f * hor + 0.5f * vertical;
+		rayTo += btScalar(x) * dHor;
+		rayTo -= btScalar(y) * dVert;
+		return rayTo;
+	}
+
+	virtual bool mouseMoveCallback(float x, float y)
+	{
+		CommonRenderInterface* renderer = m_guiHelper->getRenderInterface();
+
+		if (!renderer)
+		{
+			btAssert(0);
+			return false;
+		}
+
+		btVector3 rayTo = getRayTo(int(x), int(y));
+		btVector3 rayFrom;
+		renderer->getActiveCamera()->getCameraPosition(rayFrom);
+		movePickedBody(rayFrom, rayTo);
+
+		return false;
+	}
+
+	virtual bool mouseButtonCallback(int button, int state, float x, float y)
+	{
+		CommonRenderInterface* renderer = m_guiHelper->getRenderInterface();
+
+		if (!renderer)
+		{
+			btAssert(0);
+			return false;
+		}
+
+		CommonWindowInterface* window = m_guiHelper->getAppInterface()->m_window;
+
+		if (state == 1)
+		{
+			if (button == 0 && (!window->isModifierKeyPressed(B3G_ALT) && !window->isModifierKeyPressed(B3G_CONTROL)))
+			{
+				btVector3 camPos;
+				renderer->getActiveCamera()->getCameraPosition(camPos);
+
+				btVector3 rayFrom = camPos;
+				btVector3 rayTo = getRayTo(int(x), int(y));
+
+				pickBody(rayFrom, rayTo);
+			}
+		}
+		else
+		{
+			if (button == 0)
+			{
+				removePickingConstraint();
+				//remove p2p
+			}
+		}
+
+		//printf("button=%d, state=%d\n",button,state);
+		return false;
+	}
+
+	virtual bool pickBody(const btVector3& rayFromWorld, const btVector3& rayToWorld)
+	{
+		if (m_dynamicsWorld == 0)
+			return false;
+
+		btCollisionWorld::ClosestRayResultCallback rayCallback(rayFromWorld, rayToWorld);
+
+		m_dynamicsWorld->rayTest(rayFromWorld, rayToWorld, rayCallback);
+		if (rayCallback.hasHit())
+		{
+			btVector3 pickPos = rayCallback.m_hitPointWorld;
+			btRigidBody* body = (btRigidBody*)btRigidBody::upcast(rayCallback.m_collisionObject);
+			if (body)
+			{
+				//other exclusions?
+				if (!(body->isStaticObject() || body->isKinematicObject()))
+				{
+					m_pickedBody = body;
+					m_pickedBody->setActivationState(DISABLE_DEACTIVATION);
+					//printf("pickPos=%f,%f,%f\n",pickPos.getX(),pickPos.getY(),pickPos.getZ());
+					btVector3 localPivot = body->getCenterOfMassTransform().inverse() * pickPos;
+					btPoint2PointConstraint* p2p = new btPoint2PointConstraint(*body, localPivot);
+					m_dynamicsWorld->addConstraint(p2p, true);
+					m_pickedConstraint = p2p;
+					btScalar mousePickClamping = 30.f;
+					p2p->m_setting.m_impulseClamp = mousePickClamping;
+					//very weak constraint for picking
+					p2p->m_setting.m_tau = 0.001f;
+				}
+			}
+			else
+			{
+				btMultiBodyLinkCollider* multiCol = (btMultiBodyLinkCollider*)btMultiBodyLinkCollider::upcast(rayCallback.m_collisionObject);
+				if (multiCol && multiCol->m_multiBody)
+				{
+					m_prevCanSleep = multiCol->m_multiBody->getCanSleep();
+					multiCol->m_multiBody->setCanSleep(false);
+
+					btVector3 pivotInA = multiCol->m_multiBody->worldPosToLocal(multiCol->m_link, pickPos);
+
+					btMultiBodyPoint2Point* p2p = new btMultiBodyPoint2Point(multiCol->m_multiBody, multiCol->m_link, 0, pivotInA, pickPos);
+					//if you add too much energy to the system, causing high angular velocities, simulation 'explodes'
+					//see also http://www.bulletphysics.org/Bullet/phpBB3/viewtopic.php?f=4&t=949
+					//so we try to avoid it by clamping the maximum impulse (force) that the mouse pick can apply
+					//it is not satisfying, hopefully we find a better solution (higher order integrator, using joint friction using a zero-velocity target motor with limited force etc?)
+					btScalar scaling = 1;
+					p2p->setMaxAppliedImpulse(2 * scaling);
+
+					btMultiBodyDynamicsWorld* world = (btMultiBodyDynamicsWorld*)m_dynamicsWorld;
+					world->addMultiBodyConstraint(p2p);
+					m_pickingMultiBodyPoint2Point = p2p;
+				}
+			}
+
+			//					pickObject(pickPos, rayCallback.m_collisionObject);
+			m_oldPickingPos = rayToWorld;
+			m_hitPos = pickPos;
+			m_oldPickingDist = (pickPos - rayFromWorld).length();
+			//					printf("hit !\n");
+			//add p2p
+		}
+		return false;
+	}
+	virtual bool movePickedBody(const btVector3& rayFromWorld, const btVector3& rayToWorld)
+	{
+		if (m_pickedBody && m_pickedConstraint)
+		{
+			btPoint2PointConstraint* pickCon = static_cast<btPoint2PointConstraint*>(m_pickedConstraint);
+			if (pickCon)
+			{
+				//keep it at the same picking distance
+
+				btVector3 dir = rayToWorld - rayFromWorld;
+				dir.normalize();
+				dir *= m_oldPickingDist;
+
+				btVector3 newPivotB = rayFromWorld + dir;
+				pickCon->setPivotB(newPivotB);
+			}
+		}
+
+		if (m_pickingMultiBodyPoint2Point)
+		{
+			//keep it at the same picking distance
+
+			btVector3 dir = rayToWorld - rayFromWorld;
+			dir.normalize();
+			dir *= m_oldPickingDist;
+
+			btVector3 newPivotB = rayFromWorld + dir;
+
+			m_pickingMultiBodyPoint2Point->setPivotInB(newPivotB);
+		}
+
+		return false;
+	}
+    
+	virtual void removePickingConstraint()
+	{
+		if (m_pickedConstraint)
+		{
+			m_dynamicsWorld->removeConstraint(m_pickedConstraint);
+
+			if (m_pickedBody)
+			{
+				m_pickedBody->forceActivationState(ACTIVE_TAG);
+				m_pickedBody->activate(true);
+			}
+			delete m_pickedConstraint;
+			m_pickedConstraint = 0;
+			m_pickedBody = 0;
+		}
+		if (m_pickingMultiBodyPoint2Point)
+		{
+			m_pickingMultiBodyPoint2Point->getMultiBodyA()->setCanSleep(m_prevCanSleep);
+			btMultiBodyDynamicsWorld* world = (btMultiBodyDynamicsWorld*)m_dynamicsWorld;
+			world->removeMultiBodyConstraint(m_pickingMultiBodyPoint2Point);
+			delete m_pickingMultiBodyPoint2Point;
+			m_pickingMultiBodyPoint2Point = 0;
+		}
+	}
+
+	btBoxShape* createBoxShape(const btVector3& halfExtents)
+	{
+		btBoxShape* box = new btBoxShape(halfExtents);
+		return box;
+	}
+
+	btRigidBody* createRigidBody(float mass, const btTransform& startTransform, btCollisionShape* shape, const btVector4& color = btVector4(1, 0, 0, 1))
+	{
+		btAssert((!shape || shape->getShapeType() != INVALID_SHAPE_PROXYTYPE));
+
+		//rigidbody is dynamic if and only if mass is non zero, otherwise static
+		bool isDynamic = (mass != 0.f);
+
+		btVector3 localInertia(0, 0, 0);
+		if (isDynamic)
+			shape->calculateLocalInertia(mass, localInertia);
+
+			//using motionstate is recommended, it provides interpolation capabilities, and only synchronizes 'active' objects
+
+#define USE_MOTIONSTATE 1
+#ifdef USE_MOTIONSTATE
+		btDefaultMotionState* myMotionState = new btDefaultMotionState(startTransform);
+
+		btRigidBody::btRigidBodyConstructionInfo cInfo(mass, myMotionState, shape, localInertia);
+
+		btRigidBody* body = new btRigidBody(cInfo);
+		//body->setContactProcessingThreshold(m_defaultContactProcessingThreshold);
+
+#else
+		btRigidBody* body = new btRigidBody(mass, 0, shape, localInertia);
+		body->setWorldTransform(startTransform);
+#endif  //
+
+		body->setUserIndex(-1);
+		m_dynamicsWorld->addRigidBody(body);
+		return body;
+	}
+};
+
+#endif  //COMMON_MULTI_BODY_SETUP_H
diff --git a/engine/inc/bullet/CommonInterfaces/CommonParameterInterface.h b/engine/inc/bullet/CommonInterfaces/CommonParameterInterface.h
new file mode 100644
index 00000000..93edee89
--- /dev/null
+++ b/engine/inc/bullet/CommonInterfaces/CommonParameterInterface.h
@@ -0,0 +1,91 @@
+
+#ifndef PARAM_INTERFACE_H
+#define PARAM_INTERFACE_H
+
+#pragma once
+
+typedef void (*SliderParamChangedCallback)(float newVal, void* userPointer);
+#include "LinearMath/btScalar.h"
+
+struct SliderParams
+{
+	const char* m_name;
+	float m_minVal;
+	float m_maxVal;
+	SliderParamChangedCallback m_callback;
+	btScalar* m_paramValuePointer;
+	void* m_userPointer;
+	bool m_clampToNotches;
+	bool m_clampToIntegers;
+	bool m_showValues;
+
+	SliderParams(const char* name, btScalar* targetValuePointer)
+		: m_name(name),
+		  m_minVal(-100),
+		  m_maxVal(100),
+		  m_callback(0),
+		  m_paramValuePointer(targetValuePointer),
+		  m_userPointer(0),
+		  m_clampToNotches(false),
+		  m_clampToIntegers(false),
+		  m_showValues(true)
+	{
+	}
+};
+
+typedef void (*ButtonParamChangedCallback)(int buttonId, bool buttonState, void* userPointer);
+typedef void (*ComboBoxCallback)(int combobox, const char* item, void* userPointer);
+
+struct ButtonParams
+{
+	const char* m_name;
+	int m_buttonId;
+	void* m_userPointer;
+	bool m_isTrigger;
+	bool m_initialState;
+
+	ButtonParamChangedCallback m_callback;
+	ButtonParams(const char* name, int buttonId, bool isTrigger)
+		: m_name(name),
+		  m_buttonId(buttonId),
+		  m_userPointer(0),
+		  m_isTrigger(isTrigger),
+		  m_initialState(false),
+		  m_callback(0)
+	{
+	}
+};
+
+struct ComboBoxParams
+{
+	int m_comboboxId;
+	int m_numItems;
+	const char** m_items;
+	int m_startItem;
+	ComboBoxCallback m_callback;
+	void* m_userPointer;
+
+	ComboBoxParams()
+		: m_comboboxId(-1),
+		  m_numItems(0),
+		  m_items(0),
+		  m_startItem(0),
+		  m_callback(0),
+		  m_userPointer(0)
+	{
+	}
+};
+
+struct CommonParameterInterface
+{
+	virtual ~CommonParameterInterface() {}
+	virtual void registerSliderFloatParameter(SliderParams& params) = 0;
+	virtual void registerButtonParameter(ButtonParams& params) = 0;
+	virtual void registerComboBox(ComboBoxParams& params) = 0;
+
+	virtual void syncParameters() = 0;
+	virtual void removeAllParameters() = 0;
+	virtual void setSliderValue(int sliderIndex, double sliderValue) = 0;
+};
+
+#endif  //PARAM_INTERFACE_H
diff --git a/engine/inc/bullet/CommonInterfaces/CommonRenderInterface.h b/engine/inc/bullet/CommonInterfaces/CommonRenderInterface.h
new file mode 100644
index 00000000..25bf8285
--- /dev/null
+++ b/engine/inc/bullet/CommonInterfaces/CommonRenderInterface.h
@@ -0,0 +1,167 @@
+#ifndef COMMON_RENDER_INTERFACE_H
+#define COMMON_RENDER_INTERFACE_H
+
+struct CommonCameraInterface;
+
+enum
+{
+	B3_GL_TRIANGLES = 1,
+	B3_GL_POINTS
+};
+
+enum
+{
+	B3_INSTANCE_TRANSPARANCY = 1,
+	B3_INSTANCE_TEXTURE = 2,
+	B3_INSTANCE_DOUBLE_SIDED = 4,
+};
+
+enum
+{
+	B3_DEFAULT_RENDERMODE = 1,
+	//B3_WIREFRAME_RENDERMODE,
+	B3_CREATE_SHADOWMAP_RENDERMODE,
+	B3_USE_SHADOWMAP_RENDERMODE,
+	B3_USE_SHADOWMAP_RENDERMODE_REFLECTION,
+	B3_USE_SHADOWMAP_RENDERMODE_REFLECTION_PLANE,
+	B3_USE_PROJECTIVE_TEXTURE_RENDERMODE,
+	B3_SEGMENTATION_MASK_RENDERMODE,
+};
+
+struct GfxVertexFormat0
+{
+	float x, y, z, w;
+	float unused0, unused1, unused2, unused3;
+	float u, v;
+};
+
+struct GfxVertexFormat1
+{
+	float x, y, z, w;
+	float nx, ny, nz;
+	float u, v;
+};
+
+struct CommonRenderInterface
+{
+	virtual ~CommonRenderInterface() {}
+	virtual void init() = 0;
+	virtual void updateCamera(int upAxis) = 0;
+	virtual void removeAllInstances() = 0;
+	virtual void removeGraphicsInstance(int instanceUid) = 0;
+
+	virtual const CommonCameraInterface* getActiveCamera() const = 0;
+	virtual CommonCameraInterface* getActiveCamera() = 0;
+	virtual void setActiveCamera(CommonCameraInterface* cam) = 0;
+
+	virtual void setLightPosition(const float lightPos[3]) = 0;
+	virtual void setLightPosition(const double lightPos[3]) = 0;
+	virtual void setShadowMapResolution(int shadowMapResolution) = 0;
+	virtual void setShadowMapIntensity(double shadowMapIntensity) = 0;
+	
+	virtual void setShadowMapWorldSize(float worldSize) = 0;
+	
+	virtual void setProjectiveTextureMatrices(const float viewMatrix[16], const float projectionMatrix[16]){};
+	virtual void setProjectiveTexture(bool useProjectiveTexture){};
+
+	virtual void renderScene() = 0;
+	virtual void renderSceneInternal(int renderMode = B3_DEFAULT_RENDERMODE){};
+	virtual int getScreenWidth() = 0;
+	virtual int getScreenHeight() = 0;
+
+	virtual void resize(int width, int height) = 0;
+
+	virtual int registerGraphicsInstance(int shapeIndex, const float* position, const float* quaternion, const float* color, const float* scaling) = 0;
+	virtual int registerGraphicsInstance(int shapeIndex, const double* position, const double* quaternion, const double* color, const double* scaling) = 0;
+	virtual void drawLines(const float* positions, const float color[4], int numPoints, int pointStrideInBytes, const unsigned int* indices, int numIndices, float pointDrawSize) = 0;
+	virtual void drawLine(const float from[4], const float to[4], const float color[4], float lineWidth) = 0;
+	virtual void drawLine(const double from[4], const double to[4], const double color[4], double lineWidth) = 0;
+	virtual void drawPoint(const float* position, const float color[4], float pointDrawSize) = 0;
+	virtual void drawPoint(const double* position, const double color[4], double pointDrawSize) = 0;
+	virtual void drawTexturedTriangleMesh(float worldPosition[3], float worldOrientation[4], const float* vertices, int numvertices, const unsigned int* indices, int numIndices, float color[4], int textureIndex = -1, int vertexLayout = 0) = 0;
+
+	virtual int registerShape(const float* vertices, int numvertices, const int* indices, int numIndices, int primitiveType = B3_GL_TRIANGLES, int textureIndex = -1) = 0;
+	virtual void updateShape(int shapeIndex, const float* vertices, int numVertices) = 0;
+
+	virtual int registerTexture(const unsigned char* texels, int width, int height, bool flipPixelsY = true) = 0;
+	virtual void updateTexture(int textureIndex, const unsigned char* texels, bool flipPixelsY = true) = 0;
+	virtual void activateTexture(int textureIndex) = 0;
+	virtual void replaceTexture(int shapeIndex, int textureIndex){};
+	virtual void removeTexture(int textureIndex) = 0;
+
+	virtual void setPlaneReflectionShapeIndex(int index) {}
+
+	virtual int getShapeIndexFromInstance(int srcIndex) { return -1; }
+
+	virtual bool readSingleInstanceTransformToCPU(float* position, float* orientation, int srcIndex) = 0;
+
+	virtual void writeSingleInstanceTransformToCPU(const float* position, const float* orientation, int srcIndex) = 0;
+	virtual void writeSingleInstanceTransformToCPU(const double* position, const double* orientation, int srcIndex) = 0;
+	virtual void writeSingleInstanceColorToCPU(const float* color, int srcIndex) = 0;
+	virtual void writeSingleInstanceColorToCPU(const double* color, int srcIndex) = 0;
+	virtual void writeSingleInstanceScaleToCPU(const float* scale, int srcIndex) = 0;
+	virtual void writeSingleInstanceScaleToCPU(const double* scale, int srcIndex) = 0;
+	virtual void writeSingleInstanceSpecularColorToCPU(const double* specular, int srcIndex) = 0;
+	virtual void writeSingleInstanceSpecularColorToCPU(const float* specular, int srcIndex) = 0;
+	virtual void writeSingleInstanceFlagsToCPU(int flags, int srcIndex) = 0;
+	
+	virtual int getTotalNumInstances() const = 0;
+
+	virtual void writeTransforms() = 0;
+
+	virtual void clearZBuffer() = 0;
+
+	//This is internal access to OpenGL3+ features, mainly used for OpenCL-OpenGL interop
+	//Only the GLInstancingRenderer supports it, just return 0 otherwise.
+	virtual struct GLInstanceRendererInternalData* getInternalData() = 0;
+};
+
+template <typename T>
+inline int projectWorldCoordToScreen(T objx, T objy, T objz,
+									 const T modelMatrix[16],
+									 const T projMatrix[16],
+									 const int viewport[4],
+									 T* winx, T* winy, T* winz)
+{
+	int i;
+	T in2[4];
+	T tmp[4];
+
+	in2[0] = objx;
+	in2[1] = objy;
+	in2[2] = objz;
+	in2[3] = T(1.0);
+
+	for (i = 0; i < 4; i++)
+	{
+		tmp[i] = in2[0] * modelMatrix[0 * 4 + i] + in2[1] * modelMatrix[1 * 4 + i] +
+				 in2[2] * modelMatrix[2 * 4 + i] + in2[3] * modelMatrix[3 * 4 + i];
+	}
+
+	T out[4];
+	for (i = 0; i < 4; i++)
+	{
+		out[i] = tmp[0] * projMatrix[0 * 4 + i] + tmp[1] * projMatrix[1 * 4 + i] + tmp[2] * projMatrix[2 * 4 + i] + tmp[3] * projMatrix[3 * 4 + i];
+	}
+
+	if (out[3] == T(0.0))
+		return 0;
+	out[0] /= out[3];
+	out[1] /= out[3];
+	out[2] /= out[3];
+	/* Map x, y and z to range 0-1 */
+	out[0] = out[0] * T(0.5) + T(0.5);
+	out[1] = out[1] * T(0.5) + T(0.5);
+	out[2] = out[2] * T(0.5) + T(0.5);
+
+	/* Map x,y to viewport */
+	out[0] = out[0] * viewport[2] + viewport[0];
+	out[1] = out[1] * viewport[3] + viewport[1];
+
+	*winx = out[0];
+	*winy = out[1];
+	*winz = out[2];
+	return 1;
+}
+
+#endif  //COMMON_RENDER_INTERFACE_H
diff --git a/engine/inc/bullet/CommonInterfaces/CommonRigidBodyBase.h b/engine/inc/bullet/CommonInterfaces/CommonRigidBodyBase.h
new file mode 100644
index 00000000..98352bcd
--- /dev/null
+++ b/engine/inc/bullet/CommonInterfaces/CommonRigidBodyBase.h
@@ -0,0 +1,454 @@
+
+#ifndef COMMON_RIGID_BODY_BASE_H
+#define COMMON_RIGID_BODY_BASE_H
+
+#include "btBulletDynamicsCommon.h"
+#include "CommonExampleInterface.h"
+#include "CommonGUIHelperInterface.h"
+#include "CommonRenderInterface.h"
+#include "CommonCameraInterface.h"
+#include "CommonGraphicsAppInterface.h"
+#include "CommonWindowInterface.h"
+#include "BulletCollision/NarrowPhaseCollision/btRaycastCallback.h"
+
+struct CommonRigidBodyBase : public CommonExampleInterface
+{
+	//keep the collision shapes, for deletion/cleanup
+	btAlignedObjectArray<btCollisionShape*> m_collisionShapes;
+	btBroadphaseInterface* m_broadphase;
+	btCollisionDispatcher* m_dispatcher;
+	btConstraintSolver* m_solver;
+	btDefaultCollisionConfiguration* m_collisionConfiguration;
+	btDiscreteDynamicsWorld* m_dynamicsWorld;
+
+	//data for picking objects
+	class btRigidBody* m_pickedBody;
+	class btTypedConstraint* m_pickedConstraint;
+	int m_savedState;
+	btVector3 m_oldPickingPos;
+	btVector3 m_hitPos;
+	btScalar m_oldPickingDist;
+	struct GUIHelperInterface* m_guiHelper;
+
+	CommonRigidBodyBase(struct GUIHelperInterface* helper)
+		: m_broadphase(0),
+		  m_dispatcher(0),
+		  m_solver(0),
+		  m_collisionConfiguration(0),
+		  m_dynamicsWorld(0),
+		  m_pickedBody(0),
+		  m_pickedConstraint(0),
+		  m_guiHelper(helper)
+	{
+	}
+	virtual ~CommonRigidBodyBase()
+	{
+	}
+
+	btDiscreteDynamicsWorld* getDynamicsWorld()
+	{
+		return m_dynamicsWorld;
+	}
+
+	virtual void createEmptyDynamicsWorld()
+	{
+		///collision configuration contains default setup for memory, collision setup
+		m_collisionConfiguration = new btDefaultCollisionConfiguration();
+		//m_collisionConfiguration->setConvexConvexMultipointIterations();
+
+		///use the default collision dispatcher. For parallel processing you can use a diffent dispatcher (see Extras/BulletMultiThreaded)
+		m_dispatcher = new btCollisionDispatcher(m_collisionConfiguration);
+
+		m_broadphase = new btDbvtBroadphase();
+
+		///the default constraint solver. For parallel processing you can use a different solver (see Extras/BulletMultiThreaded)
+		btSequentialImpulseConstraintSolver* sol = new btSequentialImpulseConstraintSolver;
+		m_solver = sol;
+
+		m_dynamicsWorld = new btDiscreteDynamicsWorld(m_dispatcher, m_broadphase, m_solver, m_collisionConfiguration);
+
+		m_dynamicsWorld->setGravity(btVector3(0, -10, 0));
+	}
+
+	virtual void stepSimulation(float deltaTime)
+	{
+		if (m_dynamicsWorld)
+		{
+			m_dynamicsWorld->stepSimulation(deltaTime);
+		}
+	}
+
+	virtual void physicsDebugDraw(int debugFlags)
+	{
+		if (m_dynamicsWorld && m_dynamicsWorld->getDebugDrawer())
+		{
+			m_dynamicsWorld->getDebugDrawer()->setDebugMode(debugFlags);
+			m_dynamicsWorld->debugDrawWorld();
+		}
+	}
+
+	virtual void exitPhysics()
+	{
+		removePickingConstraint();
+		//cleanup in the reverse order of creation/initialization
+
+		//remove the rigidbodies from the dynamics world and delete them
+
+		if (m_dynamicsWorld)
+		{
+			int i;
+			for (i = m_dynamicsWorld->getNumConstraints() - 1; i >= 0; i--)
+			{
+				m_dynamicsWorld->removeConstraint(m_dynamicsWorld->getConstraint(i));
+			}
+			for (i = m_dynamicsWorld->getNumCollisionObjects() - 1; i >= 0; i--)
+			{
+				btCollisionObject* obj = m_dynamicsWorld->getCollisionObjectArray()[i];
+				btRigidBody* body = btRigidBody::upcast(obj);
+				if (body && body->getMotionState())
+				{
+					delete body->getMotionState();
+				}
+				m_dynamicsWorld->removeCollisionObject(obj);
+				delete obj;
+			}
+		}
+		//delete collision shapes
+		for (int j = 0; j < m_collisionShapes.size(); j++)
+		{
+			btCollisionShape* shape = m_collisionShapes[j];
+			delete shape;
+		}
+		m_collisionShapes.clear();
+
+		delete m_dynamicsWorld;
+		m_dynamicsWorld = 0;
+
+		delete m_solver;
+		m_solver = 0;
+
+		delete m_broadphase;
+		m_broadphase = 0;
+
+		delete m_dispatcher;
+		m_dispatcher = 0;
+
+		delete m_collisionConfiguration;
+		m_collisionConfiguration = 0;
+	}
+
+	virtual void debugDraw(int debugDrawFlags)
+	{
+		if (m_dynamicsWorld)
+		{
+			if (m_dynamicsWorld->getDebugDrawer())
+			{
+				m_dynamicsWorld->getDebugDrawer()->setDebugMode(debugDrawFlags);
+			}
+			m_dynamicsWorld->debugDrawWorld();
+		}
+	}
+
+	virtual bool keyboardCallback(int key, int state)
+	{
+		if ((key == B3G_F3) && state && m_dynamicsWorld)
+		{
+			btDefaultSerializer* serializer = new btDefaultSerializer();
+			m_dynamicsWorld->serialize(serializer);
+
+			FILE* file = fopen("testFile.bullet", "wb");
+			fwrite(serializer->getBufferPointer(), serializer->getCurrentBufferSize(), 1, file);
+			fclose(file);
+			//b3Printf("btDefaultSerializer wrote testFile.bullet");
+			delete serializer;
+			return true;
+		}
+		return false;  //don't handle this key
+	}
+
+	btVector3 getRayTo(int x, int y)
+	{
+		CommonRenderInterface* renderer = m_guiHelper->getRenderInterface();
+
+		if (!renderer)
+		{
+			btAssert(0);
+			return btVector3(0, 0, 0);
+		}
+
+		float top = 1.f;
+		float bottom = -1.f;
+		float nearPlane = 1.f;
+		float tanFov = (top - bottom) * 0.5f / nearPlane;
+		float fov = btScalar(2.0) * btAtan(tanFov);
+
+		btVector3 camPos, camTarget;
+
+		renderer->getActiveCamera()->getCameraPosition(camPos);
+		renderer->getActiveCamera()->getCameraTargetPosition(camTarget);
+
+		btVector3 rayFrom = camPos;
+		btVector3 rayForward = (camTarget - camPos);
+		rayForward.normalize();
+		float farPlane = 10000.f;
+		rayForward *= farPlane;
+
+		btVector3 rightOffset;
+		btVector3 cameraUp = btVector3(0, 0, 0);
+		cameraUp[m_guiHelper->getAppInterface()->getUpAxis()] = 1;
+
+		btVector3 vertical = cameraUp;
+
+		btVector3 hor;
+		hor = rayForward.cross(vertical);
+		hor.safeNormalize();
+		vertical = hor.cross(rayForward);
+		vertical.safeNormalize();
+
+		float tanfov = tanf(0.5f * fov);
+
+		hor *= 2.f * farPlane * tanfov;
+		vertical *= 2.f * farPlane * tanfov;
+
+		btScalar aspect;
+		float width = float(renderer->getScreenWidth());
+		float height = float(renderer->getScreenHeight());
+
+		aspect = width / height;
+
+		hor *= aspect;
+
+		btVector3 rayToCenter = rayFrom + rayForward;
+		btVector3 dHor = hor * 1.f / width;
+		btVector3 dVert = vertical * 1.f / height;
+
+		btVector3 rayTo = rayToCenter - 0.5f * hor + 0.5f * vertical;
+		rayTo += btScalar(x) * dHor;
+		rayTo -= btScalar(y) * dVert;
+		return rayTo;
+	}
+
+	virtual bool mouseMoveCallback(float x, float y)
+	{
+		CommonRenderInterface* renderer = m_guiHelper->getRenderInterface();
+
+		if (!renderer)
+		{
+			btAssert(0);
+			return false;
+		}
+
+		btVector3 rayTo = getRayTo(int(x), int(y));
+		btVector3 rayFrom;
+		renderer->getActiveCamera()->getCameraPosition(rayFrom);
+		movePickedBody(rayFrom, rayTo);
+
+		return false;
+	}
+
+	virtual bool mouseButtonCallback(int button, int state, float x, float y)
+	{
+		CommonRenderInterface* renderer = m_guiHelper->getRenderInterface();
+
+		if (!renderer)
+		{
+			btAssert(0);
+			return false;
+		}
+
+		CommonWindowInterface* window = m_guiHelper->getAppInterface()->m_window;
+
+#if 0
+		if (window->isModifierKeyPressed(B3G_ALT))
+		{
+			printf("ALT pressed\n");
+		} else
+		{
+			printf("NO ALT pressed\n");
+		}
+		
+		if (window->isModifierKeyPressed(B3G_SHIFT))
+		{
+			printf("SHIFT pressed\n");
+		} else
+		{
+			printf("NO SHIFT pressed\n");
+		}
+		
+		if (window->isModifierKeyPressed(B3G_CONTROL))
+		{
+			printf("CONTROL pressed\n");
+		} else
+		{
+			printf("NO CONTROL pressed\n");
+		}
+#endif
+
+		if (state == 1)
+		{
+			if (button == 0 && (!window->isModifierKeyPressed(B3G_ALT) && !window->isModifierKeyPressed(B3G_CONTROL)))
+			{
+				btVector3 camPos;
+				renderer->getActiveCamera()->getCameraPosition(camPos);
+
+				btVector3 rayFrom = camPos;
+				btVector3 rayTo = getRayTo(int(x), int(y));
+
+				pickBody(rayFrom, rayTo);
+			}
+		}
+		else
+		{
+			if (button == 0)
+			{
+				removePickingConstraint();
+				//remove p2p
+			}
+		}
+
+		//printf("button=%d, state=%d\n",button,state);
+		return false;
+	}
+
+	virtual bool pickBody(const btVector3& rayFromWorld, const btVector3& rayToWorld)
+	{
+		if (m_dynamicsWorld == 0)
+			return false;
+
+		btCollisionWorld::ClosestRayResultCallback rayCallback(rayFromWorld, rayToWorld);
+
+		rayCallback.m_flags |= btTriangleRaycastCallback::kF_UseGjkConvexCastRaytest;
+		m_dynamicsWorld->rayTest(rayFromWorld, rayToWorld, rayCallback);
+		if (rayCallback.hasHit())
+		{
+			btVector3 pickPos = rayCallback.m_hitPointWorld;
+			btRigidBody* body = (btRigidBody*)btRigidBody::upcast(rayCallback.m_collisionObject);
+			if (body)
+			{
+				//other exclusions?
+				if (!(body->isStaticObject() || body->isKinematicObject()))
+				{
+					m_pickedBody = body;
+					m_savedState = m_pickedBody->getActivationState();
+					m_pickedBody->setActivationState(DISABLE_DEACTIVATION);
+					//printf("pickPos=%f,%f,%f\n",pickPos.getX(),pickPos.getY(),pickPos.getZ());
+					btVector3 localPivot = body->getCenterOfMassTransform().inverse() * pickPos;
+					btPoint2PointConstraint* p2p = new btPoint2PointConstraint(*body, localPivot);
+					m_dynamicsWorld->addConstraint(p2p, true);
+					m_pickedConstraint = p2p;
+					btScalar mousePickClamping = 30.f;
+					p2p->m_setting.m_impulseClamp = mousePickClamping;
+					//very weak constraint for picking
+					p2p->m_setting.m_tau = 0.001f;
+				}
+			}
+
+			//					pickObject(pickPos, rayCallback.m_collisionObject);
+			m_oldPickingPos = rayToWorld;
+			m_hitPos = pickPos;
+			m_oldPickingDist = (pickPos - rayFromWorld).length();
+			//					printf("hit !\n");
+			//add p2p
+		}
+		return false;
+	}
+	virtual bool movePickedBody(const btVector3& rayFromWorld, const btVector3& rayToWorld)
+	{
+		if (m_pickedBody && m_pickedConstraint)
+		{
+			btPoint2PointConstraint* pickCon = static_cast<btPoint2PointConstraint*>(m_pickedConstraint);
+			if (pickCon)
+			{
+				//keep it at the same picking distance
+
+				btVector3 newPivotB;
+
+				btVector3 dir = rayToWorld - rayFromWorld;
+				dir.normalize();
+				dir *= m_oldPickingDist;
+
+				newPivotB = rayFromWorld + dir;
+				pickCon->setPivotB(newPivotB);
+				return true;
+			}
+		}
+		return false;
+	}
+	virtual void removePickingConstraint()
+	{
+		if (m_pickedConstraint)
+		{
+			m_pickedBody->forceActivationState(m_savedState);
+			m_pickedBody->activate();
+			m_dynamicsWorld->removeConstraint(m_pickedConstraint);
+			delete m_pickedConstraint;
+			m_pickedConstraint = 0;
+			m_pickedBody = 0;
+		}
+	}
+
+	btBoxShape* createBoxShape(const btVector3& halfExtents)
+	{
+		btBoxShape* box = new btBoxShape(halfExtents);
+		return box;
+	}
+
+	void deleteRigidBody(btRigidBody* body)
+	{
+		int graphicsUid = body->getUserIndex();
+		m_guiHelper->removeGraphicsInstance(graphicsUid);
+
+		m_dynamicsWorld->removeRigidBody(body);
+		btMotionState* ms = body->getMotionState();
+		delete body;
+		delete ms;
+	}
+
+	btRigidBody* createRigidBody(float mass, const btTransform& startTransform, btCollisionShape* shape, const btVector4& color = btVector4(1, 0, 0, 1))
+	{
+		btAssert((!shape || shape->getShapeType() != INVALID_SHAPE_PROXYTYPE));
+
+		//rigidbody is dynamic if and only if mass is non zero, otherwise static
+		bool isDynamic = (mass != 0.f);
+
+		btVector3 localInertia(0, 0, 0);
+		if (isDynamic)
+			shape->calculateLocalInertia(mass, localInertia);
+
+			//using motionstate is recommended, it provides interpolation capabilities, and only synchronizes 'active' objects
+
+#define USE_MOTIONSTATE 1
+#ifdef USE_MOTIONSTATE
+		btDefaultMotionState* myMotionState = new btDefaultMotionState(startTransform);
+
+		btRigidBody::btRigidBodyConstructionInfo cInfo(mass, myMotionState, shape, localInertia);
+
+		btRigidBody* body = new btRigidBody(cInfo);
+		//body->setContactProcessingThreshold(m_defaultContactProcessingThreshold);
+
+#else
+		btRigidBody* body = new btRigidBody(mass, 0, shape, localInertia);
+		body->setWorldTransform(startTransform);
+#endif  //
+
+		body->setUserIndex(-1);
+		m_dynamicsWorld->addRigidBody(body);
+		return body;
+	}
+
+	virtual void renderScene()
+	{
+		if (m_dynamicsWorld)
+		{
+			{
+				m_guiHelper->syncPhysicsToGraphics(m_dynamicsWorld);
+			}
+
+			{
+				m_guiHelper->render(m_dynamicsWorld);
+			}
+		}
+	}
+};
+
+#endif  //COMMON_RIGID_BODY_SETUP_H
diff --git a/engine/inc/bullet/CommonInterfaces/CommonWindowInterface.h b/engine/inc/bullet/CommonInterfaces/CommonWindowInterface.h
new file mode 100644
index 00000000..ce212f64
--- /dev/null
+++ b/engine/inc/bullet/CommonInterfaces/CommonWindowInterface.h
@@ -0,0 +1,88 @@
+#ifndef B3G_WINDOW_INTERFACE_H
+#define B3G_WINDOW_INTERFACE_H
+
+#include "CommonCallbacks.h"
+
+struct b3gWindowConstructionInfo
+{
+	int m_width;
+	int m_height;
+	bool m_fullscreen;
+	int m_colorBitsPerPixel;
+	void* m_windowHandle;
+	const char* m_title;
+	int m_openglVersion;
+	int m_renderDevice;
+
+	b3gWindowConstructionInfo(int width = 1024, int height = 768)
+		: m_width(width),
+		  m_height(height),
+		  m_fullscreen(false),
+		  m_colorBitsPerPixel(32),
+		  m_windowHandle(0),
+		  m_title("title"),
+		  m_openglVersion(3),
+		  m_renderDevice(-1)
+	{
+	}
+};
+
+class CommonWindowInterface
+{
+public:
+	virtual ~CommonWindowInterface()
+	{
+	}
+
+	virtual void createDefaultWindow(int width, int height, const char* title)
+	{
+		b3gWindowConstructionInfo ci(width, height);
+		ci.m_title = title;
+		createWindow(ci);
+	}
+
+	virtual void createWindow(const b3gWindowConstructionInfo& ci) = 0;
+
+	virtual void closeWindow() = 0;
+
+	virtual void runMainLoop() = 0;
+	virtual float getTimeInSeconds() = 0;
+
+	virtual bool requestedExit() const = 0;
+	virtual void setRequestExit() = 0;
+
+	virtual void startRendering() = 0;
+
+	virtual void endRendering() = 0;
+
+	virtual bool isModifierKeyPressed(int key) = 0;
+
+	virtual void setMouseMoveCallback(b3MouseMoveCallback mouseCallback) = 0;
+	virtual b3MouseMoveCallback getMouseMoveCallback() = 0;
+
+	virtual void setMouseButtonCallback(b3MouseButtonCallback mouseCallback) = 0;
+	virtual b3MouseButtonCallback getMouseButtonCallback() = 0;
+
+	virtual void setResizeCallback(b3ResizeCallback resizeCallback) = 0;
+	virtual b3ResizeCallback getResizeCallback() = 0;
+
+	virtual void setWheelCallback(b3WheelCallback wheelCallback) = 0;
+	virtual b3WheelCallback getWheelCallback() = 0;
+
+	virtual void setKeyboardCallback(b3KeyboardCallback keyboardCallback) = 0;
+	virtual b3KeyboardCallback getKeyboardCallback() = 0;
+
+	virtual void setRenderCallback(b3RenderCallback renderCallback) = 0;
+
+	virtual void setWindowTitle(const char* title) = 0;
+
+	virtual float getRetinaScale() const = 0;
+	virtual void setAllowRetina(bool allow) = 0;
+
+	virtual int getWidth() const = 0;
+	virtual int getHeight() const = 0;
+
+	virtual int fileOpenDialog(char* fileName, int maxFileNameLength) = 0;
+};
+
+#endif  //B3G_WINDOW_INTERFACE_H
diff --git a/engine/inc/bullet/Constraints/ConstraintDemo.h b/engine/inc/bullet/Constraints/ConstraintDemo.h
new file mode 100644
index 00000000..de0061ba
--- /dev/null
+++ b/engine/inc/bullet/Constraints/ConstraintDemo.h
@@ -0,0 +1,20 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef ALL_CONSTRAINT_DEMO_H
+#define ALL_CONSTRAINT_DEMO_H
+
+class CommonExampleInterface* AllConstraintCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //ALL_CONSTRAINT_DEMO_H
diff --git a/engine/inc/bullet/Constraints/ConstraintPhysicsSetup.h b/engine/inc/bullet/Constraints/ConstraintPhysicsSetup.h
new file mode 100644
index 00000000..0c032ea9
--- /dev/null
+++ b/engine/inc/bullet/Constraints/ConstraintPhysicsSetup.h
@@ -0,0 +1,6 @@
+#ifndef CONSTAINT_PHYSICS_SETUP_H
+#define CONSTAINT_PHYSICS_SETUP_H
+
+class CommonExampleInterface* ConstraintCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //CONSTAINT_PHYSICS_SETUP_H
diff --git a/engine/inc/bullet/Constraints/Dof6Spring2Setup.h b/engine/inc/bullet/Constraints/Dof6Spring2Setup.h
new file mode 100644
index 00000000..66bda387
--- /dev/null
+++ b/engine/inc/bullet/Constraints/Dof6Spring2Setup.h
@@ -0,0 +1,6 @@
+#ifndef GENERIC_6DOF_SPRING2_CONSTRAINT_DEMO_H
+#define GENERIC_6DOF_SPRING2_CONSTRAINT_DEMO_H
+
+class CommonExampleInterface* Dof6Spring2CreateFunc(struct CommonExampleOptions& options);
+
+#endif  //GENERIC_6DOF_SPRING2_CONSTRAINT_DEMO_H
diff --git a/engine/inc/bullet/Constraints/TestHingeTorque.h b/engine/inc/bullet/Constraints/TestHingeTorque.h
new file mode 100644
index 00000000..7d264840
--- /dev/null
+++ b/engine/inc/bullet/Constraints/TestHingeTorque.h
@@ -0,0 +1,6 @@
+#ifndef TEST_HINGE_TORQUE_H
+#define TEST_HINGE_TORQUE_H
+
+class CommonExampleInterface* TestHingeTorqueCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //TEST_HINGE_TORQUE_H
diff --git a/engine/inc/bullet/ConvexDecomposition/ConvexBuilder.h b/engine/inc/bullet/ConvexDecomposition/ConvexBuilder.h
new file mode 100644
index 00000000..238dfda0
--- /dev/null
+++ b/engine/inc/bullet/ConvexDecomposition/ConvexBuilder.h
@@ -0,0 +1,103 @@
+#ifndef CONVEX_BUILDER_H
+#define CONVEX_BUILDER_H
+
+/*----------------------------------------------------------------------
+Copyright (c) 2004 Open Dynamics Framework Group
+www.physicstools.org
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided
+that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list of conditions
+and the following disclaimer.
+
+Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+
+Neither the name of the Open Dynamics Framework Group nor the names of its contributors may
+be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE INTEL OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+-----------------------------------------------------------------------*/
+
+// http://codesuppository.blogspot.com
+//
+// mailto: jratcliff@infiniplex.net
+//
+// http://www.amillionpixels.us
+//
+
+#include "ConvexDecomposition.h"
+#include "vlookup.h"
+#include "LinearMath/btAlignedObjectArray.h"
+
+class CHull
+{
+public:
+	CHull(const ConvexDecomposition::ConvexResult &result);
+
+	~CHull(void);
+
+	bool overlap(const CHull &h) const;
+
+	float mMin[3];
+	float mMax[3];
+	float mVolume;
+	float mDiagonal;  // long edge..
+	ConvexDecomposition::ConvexResult *mResult;
+};
+
+// Usage: std::sort( list.begin(), list.end(), StringSortRef() );
+class CHullSort
+{
+public:
+	inline bool operator()(const CHull *a, const CHull *b) const
+	{
+		return a->mVolume < b->mVolume;
+	}
+};
+
+typedef btAlignedObjectArray<CHull *> CHullVector;
+
+class ConvexBuilder : public ConvexDecomposition::ConvexDecompInterface
+{
+public:
+	ConvexBuilder(ConvexDecomposition::ConvexDecompInterface *callback);
+
+	virtual ~ConvexBuilder(void);
+
+	bool isDuplicate(unsigned int i1, unsigned int i2, unsigned int i3,
+					 unsigned int ci1, unsigned int ci2, unsigned int ci3);
+
+	void getMesh(const ConvexDecomposition::ConvexResult &cr, VertexLookup vc, UintVector &indices);
+
+	CHull *canMerge(CHull *a, CHull *b);
+
+	bool combineHulls(void);
+
+	unsigned int process(const ConvexDecomposition::DecompDesc &desc);
+
+	virtual void ConvexDebugTri(const float *p1, const float *p2, const float *p3, unsigned int color);
+
+	virtual void ConvexDebugOBB(const float *sides, const float *matrix, unsigned int color);
+	virtual void ConvexDebugPoint(const float *p, float dist, unsigned int color);
+
+	virtual void ConvexDebugBound(const float *bmin, const float *bmax, unsigned int color);
+
+	virtual void ConvexDecompResult(ConvexDecomposition::ConvexResult &result);
+
+	void sortChulls(CHullVector &hulls);
+
+	CHullVector mChulls;
+	ConvexDecompInterface *mCallback;
+};
+
+#endif  //CONVEX_BUILDER_H
diff --git a/engine/inc/bullet/ConvexDecomposition/ConvexDecomposition.h b/engine/inc/bullet/ConvexDecomposition/ConvexDecomposition.h
new file mode 100644
index 00000000..ad5c1f96
--- /dev/null
+++ b/engine/inc/bullet/ConvexDecomposition/ConvexDecomposition.h
@@ -0,0 +1,202 @@
+#ifndef CONVEX_DECOMPOSITION_H
+
+#define CONVEX_DECOMPOSITION_H
+
+/*----------------------------------------------------------------------
+Copyright (c) 2004 Open Dynamics Framework Group
+www.physicstools.org
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided
+that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list of conditions
+and the following disclaimer.
+
+Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+
+Neither the name of the Open Dynamics Framework Group nor the names of its contributors may
+be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE INTEL OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+-----------------------------------------------------------------------*/
+
+// http://codesuppository.blogspot.com
+//
+// mailto: jratcliff@infiniplex.net
+//
+// http://www.amillionpixels.us
+//
+
+#ifdef _WIN32
+#include <memory.h>  //memcpy
+#endif
+#include <string.h>
+#include <stdio.h>
+#include "LinearMath/btAlignedObjectArray.h"
+
+extern unsigned int MAXDEPTH;
+extern float CONCAVE_PERCENT;
+extern float MERGE_PERCENT;
+
+typedef btAlignedObjectArray<unsigned int> UintVector;
+
+namespace ConvexDecomposition
+{
+class ConvexResult
+{
+public:
+	ConvexResult(void)
+	{
+		mHullVcount = 0;
+		mHullVertices = 0;
+		mHullTcount = 0;
+		mHullIndices = 0;
+	}
+
+	ConvexResult(unsigned int hvcount, const float *hvertices, unsigned int htcount, const unsigned int *hindices)
+	{
+		mHullVcount = hvcount;
+		if (mHullVcount)
+		{
+			mHullVertices = new float[mHullVcount * sizeof(float) * 3];
+			memcpy(mHullVertices, hvertices, sizeof(float) * 3 * mHullVcount);
+		}
+		else
+		{
+			mHullVertices = 0;
+		}
+
+		mHullTcount = htcount;
+
+		if (mHullTcount)
+		{
+			mHullIndices = new unsigned int[sizeof(unsigned int) * mHullTcount * 3];
+			memcpy(mHullIndices, hindices, sizeof(unsigned int) * mHullTcount * 3);
+		}
+		else
+		{
+			mHullIndices = 0;
+		}
+	}
+
+	ConvexResult(const ConvexResult &r)
+	{
+		mHullVcount = r.mHullVcount;
+		if (mHullVcount)
+		{
+			mHullVertices = new float[mHullVcount * sizeof(float) * 3];
+			memcpy(mHullVertices, r.mHullVertices, sizeof(float) * 3 * mHullVcount);
+		}
+		else
+		{
+			mHullVertices = 0;
+		}
+		mHullTcount = r.mHullTcount;
+		if (mHullTcount)
+		{
+			mHullIndices = new unsigned int[sizeof(unsigned int) * mHullTcount * 3];
+			memcpy(mHullIndices, r.mHullIndices, sizeof(unsigned int) * mHullTcount * 3);
+		}
+		else
+		{
+			mHullIndices = 0;
+		}
+	}
+
+	~ConvexResult(void)
+	{
+		delete[] mHullVertices;
+		delete[] mHullIndices;
+	}
+
+	// the convex hull.
+	unsigned int mHullVcount;
+	float *mHullVertices;
+	unsigned int mHullTcount;
+	unsigned int *mHullIndices;
+
+	float mHullVolume;  // the volume of the convex hull.
+
+	float mOBBSides[3];        // the width, height and breadth of the best fit OBB
+	float mOBBCenter[3];       // the center of the OBB
+	float mOBBOrientation[4];  // the quaternion rotation of the OBB.
+	float mOBBTransform[16];   // the 4x4 transform of the OBB.
+	float mOBBVolume;          // the volume of the OBB
+
+	float mSphereRadius;  // radius and center of best fit sphere
+	float mSphereCenter[3];
+	float mSphereVolume;  // volume of the best fit sphere
+};
+
+class ConvexDecompInterface
+{
+public:
+	virtual ~ConvexDecompInterface(){};
+	virtual void ConvexDebugTri(const float *p1, const float *p2, const float *p3, unsigned int color){};
+	virtual void ConvexDebugPoint(const float *p, float dist, unsigned int color){};
+	virtual void ConvexDebugBound(const float *bmin, const float *bmax, unsigned int color){};
+	virtual void ConvexDebugOBB(const float *sides, const float *matrix, unsigned int color){};
+
+	virtual void ConvexDecompResult(ConvexResult &result) = 0;
+};
+
+// just to avoid passing a zillion parameters to the method the
+// options are packed into this descriptor.
+class DecompDesc
+{
+public:
+	DecompDesc(void)
+	{
+		mVcount = 0;
+		mVertices = 0;
+		mTcount = 0;
+		mIndices = 0;
+		mDepth = 5;
+		mCpercent = 5;
+		mPpercent = 5;
+		mMaxVertices = 32;
+		mSkinWidth = 0;
+		mCallback = 0;
+	}
+
+	// describes the input triangle.
+	unsigned int mVcount;    // the number of vertices in the source mesh.
+	const float *mVertices;  // start of the vertex position array.  Assumes a stride of 3 floats.
+	unsigned int mTcount;    // the number of triangles in the source mesh.
+	unsigned int *mIndices;  // the indexed triangle list array (zero index based)
+
+	// options
+	unsigned int mDepth;  // depth to split, a maximum of 10, generally not over 7.
+	float mCpercent;      // the concavity threshold percentage.  0=20 is reasonable.
+	float mPpercent;      // the percentage volume conservation threshold to collapse hulls. 0-30 is reasonable.
+
+	// hull output limits.
+	unsigned int mMaxVertices;  // maximum number of vertices in the output hull. Recommended 32 or less.
+	float mSkinWidth;           // a skin width to apply to the output hulls.
+
+	ConvexDecompInterface *mCallback;  // the interface to receive back the results.
+};
+
+// perform approximate convex decomposition on a mesh.
+unsigned int performConvexDecomposition(const DecompDesc &desc);  // returns the number of hulls produced.
+
+void calcConvexDecomposition(unsigned int vcount,
+							 const float *vertices,
+							 unsigned int tcount,
+							 const unsigned int *indices,
+							 ConvexDecompInterface *callback,
+							 float masterVolume,
+							 unsigned int depth);
+
+}  // namespace ConvexDecomposition
+
+#endif
diff --git a/engine/inc/bullet/ConvexDecomposition/bestfit.h b/engine/inc/bullet/ConvexDecomposition/bestfit.h
new file mode 100644
index 00000000..433f0966
--- /dev/null
+++ b/engine/inc/bullet/ConvexDecomposition/bestfit.h
@@ -0,0 +1,63 @@
+#ifndef BEST_FIT_H
+
+#define BEST_FIT_H
+
+/*----------------------------------------------------------------------
+		Copyright (c) 2004 Open Dynamics Framework Group
+					www.physicstools.org
+		All rights reserved.
+
+		Redistribution and use in source and binary forms, with or without modification, are permitted provided
+		that the following conditions are met:
+
+		Redistributions of source code must retain the above copyright notice, this list of conditions
+		and the following disclaimer.
+
+		Redistributions in binary form must reproduce the above copyright notice,
+		this list of conditions and the following disclaimer in the documentation
+		and/or other materials provided with the distribution.
+
+		Neither the name of the Open Dynamics Framework Group nor the names of its contributors may
+		be used to endorse or promote products derived from this software without specific prior written permission.
+
+		THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+		INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+		DISCLAIMED. IN NO EVENT SHALL THE INTEL OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+		EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+		LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+		IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+		THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+-----------------------------------------------------------------------*/
+
+// http://codesuppository.blogspot.com
+//
+// mailto: jratcliff@infiniplex.net
+//
+// http://www.amillionpixels.us
+//
+
+// This routine was released in 'snippet' form
+// by John W. Ratcliff mailto:jratcliff@infiniplex.net
+// on March 22, 2006.
+//
+// This routine computes the 'best fit' plane equation to
+// a set of input data points with an optional per vertex
+// weighting component.
+//
+// The implementation for this was lifted directly from
+// David Eberly's Magic Software implementation.
+
+// computes the best fit plane to a collection of data points.
+// returns the plane equation as A,B,C,D format. (Ax+By+Cz+D)
+
+bool getBestFitPlane(unsigned int vcount,   // number of input data points
+					 const float *points,   // starting address of points array.
+					 unsigned int vstride,  // stride between input points.
+					 const float *weights,  // *optional point weighting values.
+					 unsigned int wstride,  // weight stride for each vertex.
+					 float *plane);
+
+float getBoundingRegion(unsigned int vcount, const float *points, unsigned int pstride, float *bmin, float *bmax);  // returns the diagonal distance
+bool overlapAABB(const float *bmin1, const float *bmax1, const float *bmin2, const float *bmax2);                   // return true if the two AABB's overlap.
+
+#endif
diff --git a/engine/inc/bullet/ConvexDecomposition/bestfitobb.h b/engine/inc/bullet/ConvexDecomposition/bestfitobb.h
new file mode 100644
index 00000000..4536c1cd
--- /dev/null
+++ b/engine/inc/bullet/ConvexDecomposition/bestfitobb.h
@@ -0,0 +1,41 @@
+#ifndef BEST_FIT_OBB_H
+
+#define BEST_FIT_OBB_H
+
+/*----------------------------------------------------------------------
+		Copyright (c) 2004 Open Dynamics Framework Group
+					www.physicstools.org
+		All rights reserved.
+
+		Redistribution and use in source and binary forms, with or without modification, are permitted provided
+		that the following conditions are met:
+
+		Redistributions of source code must retain the above copyright notice, this list of conditions
+		and the following disclaimer.
+
+		Redistributions in binary form must reproduce the above copyright notice,
+		this list of conditions and the following disclaimer in the documentation
+		and/or other materials provided with the distribution.
+
+		Neither the name of the Open Dynamics Framework Group nor the names of its contributors may
+		be used to endorse or promote products derived from this software without specific prior written permission.
+
+		THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+		INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+		DISCLAIMED. IN NO EVENT SHALL THE INTEL OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+		EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+		LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+		IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+		THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+-----------------------------------------------------------------------*/
+
+// http://codesuppository.blogspot.com
+//
+// mailto: jratcliff@infiniplex.net
+//
+// http://www.amillionpixels.us
+//
+
+void computeBestFitOBB(unsigned int vcount, const float *points, unsigned int pstride, float *sides, float *matrix);
+
+#endif
diff --git a/engine/inc/bullet/ConvexDecomposition/cd_hull.h b/engine/inc/bullet/ConvexDecomposition/cd_hull.h
new file mode 100644
index 00000000..212815f8
--- /dev/null
+++ b/engine/inc/bullet/ConvexDecomposition/cd_hull.h
@@ -0,0 +1,148 @@
+#ifndef CD_HULL_H
+
+#define CD_HULL_H
+
+/*----------------------------------------------------------------------
+		Copyright (c) 2004 Open Dynamics Framework Group
+					www.physicstools.org
+		All rights reserved.
+
+		Redistribution and use in source and binary forms, with or without modification, are permitted provided
+		that the following conditions are met:
+
+		Redistributions of source code must retain the above copyright notice, this list of conditions
+		and the following disclaimer.
+
+		Redistributions in binary form must reproduce the above copyright notice,
+		this list of conditions and the following disclaimer in the documentation
+		and/or other materials provided with the distribution.
+
+		Neither the name of the Open Dynamics Framework Group nor the names of its contributors may
+		be used to endorse or promote products derived from this software without specific prior written permission.
+
+		THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+		INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+		DISCLAIMED. IN NO EVENT SHALL THE INTEL OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+		EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+		LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+		IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+		THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+-----------------------------------------------------------------------*/
+
+namespace ConvexDecomposition
+{
+class HullResult
+{
+public:
+	HullResult(void)
+	{
+		mPolygons = true;
+		mNumOutputVertices = 0;
+		mOutputVertices = 0;
+		mNumFaces = 0;
+		mNumIndices = 0;
+		mIndices = 0;
+	}
+	bool mPolygons;                   // true if indices represents polygons, false indices are triangles
+	unsigned int mNumOutputVertices;  // number of vertices in the output hull
+	float *mOutputVertices;           // array of vertices, 3 floats each x,y,z
+	unsigned int mNumFaces;           // the number of faces produced
+	unsigned int mNumIndices;         // the total number of indices
+	unsigned int *mIndices;           // pointer to indices.
+
+	// If triangles, then indices are array indexes into the vertex list.
+	// If polygons, indices are in the form (number of points in face) (p1, p2, p3, ..) etc..
+};
+
+enum HullFlag
+{
+	QF_TRIANGLES = (1 << 0),      // report results as triangles, not polygons.
+	QF_REVERSE_ORDER = (1 << 1),  // reverse order of the triangle indices.
+	QF_SKIN_WIDTH = (1 << 2),     // extrude hull based on this skin width
+	QF_DEFAULT = 0
+};
+
+class HullDesc
+{
+public:
+	HullDesc(void)
+	{
+		mFlags = QF_DEFAULT;
+		mVcount = 0;
+		mVertices = 0;
+		mVertexStride = sizeof(float) * 3;
+		mNormalEpsilon = 0.001f;
+		mMaxVertices = 4096;  // maximum number of points to be considered for a convex hull.
+		mMaxFaces = 4096;
+		mSkinWidth = 0.01f;  // default is one centimeter
+	};
+
+	HullDesc(HullFlag flag,
+			 unsigned int vcount,
+			 const float *vertices,
+			 unsigned int stride)
+	{
+		mFlags = flag;
+		mVcount = vcount;
+		mVertices = vertices;
+		mVertexStride = stride;
+		mNormalEpsilon = 0.001f;
+		mMaxVertices = 4096;
+		mSkinWidth = 0.01f;  // default is one centimeter
+	}
+
+	bool HasHullFlag(HullFlag flag) const
+	{
+		if (mFlags & flag) return true;
+		return false;
+	}
+
+	void SetHullFlag(HullFlag flag)
+	{
+		mFlags |= flag;
+	}
+
+	void ClearHullFlag(HullFlag flag)
+	{
+		mFlags &= ~flag;
+	}
+
+	unsigned int mFlags;         // flags to use when generating the convex hull.
+	unsigned int mVcount;        // number of vertices in the input point cloud
+	const float *mVertices;      // the array of vertices.
+	unsigned int mVertexStride;  // the stride of each vertex, in bytes.
+	float mNormalEpsilon;        // the epsilon for removing duplicates.  This is a normalized value, if normalized bit is on.
+	float mSkinWidth;
+	unsigned int mMaxVertices;  // maximum number of vertices to be considered for the hull!
+	unsigned int mMaxFaces;
+};
+
+enum HullError
+{
+	QE_OK,   // success!
+	QE_FAIL  // failed.
+};
+
+class HullLibrary
+{
+public:
+	HullError CreateConvexHull(const HullDesc &desc,  // describes the input request
+							   HullResult &result);   // contains the resulst
+
+	HullError ReleaseResult(HullResult &result);  // release memory allocated for this result, we are done with it.
+
+private:
+	void BringOutYourDead(const float *verts, unsigned int vcount, float *overts, unsigned int &ocount, unsigned int *indices, unsigned indexcount);
+
+	bool CleanupVertices(unsigned int svcount,
+						 const float *svertices,
+						 unsigned int stride,
+						 unsigned int &vcount,  // output number of vertices
+						 float *vertices,       // location to store the results.
+						 float normalepsilon,
+						 float *scale);
+};
+
+}  // namespace ConvexDecomposition
+
+#endif
diff --git a/engine/inc/bullet/ConvexDecomposition/cd_vector.h b/engine/inc/bullet/ConvexDecomposition/cd_vector.h
new file mode 100644
index 00000000..6d46b2f3
--- /dev/null
+++ b/engine/inc/bullet/ConvexDecomposition/cd_vector.h
@@ -0,0 +1,1192 @@
+#ifndef CD_VECTOR_H
+
+#define CD_VECTOR_H
+
+/*----------------------------------------------------------------------
+		Copyright (c) 2004 Open Dynamics Framework Group
+					www.physicstools.org
+		All rights reserved.
+
+		Redistribution and use in source and binary forms, with or without modification, are permitted provided
+		that the following conditions are met:
+
+		Redistributions of source code must retain the above copyright notice, this list of conditions
+		and the following disclaimer.
+
+		Redistributions in binary form must reproduce the above copyright notice,
+		this list of conditions and the following disclaimer in the documentation
+		and/or other materials provided with the distribution.
+
+		Neither the name of the Open Dynamics Framework Group nor the names of its contributors may
+		be used to endorse or promote products derived from this software without specific prior written permission.
+
+		THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+		INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+		DISCLAIMED. IN NO EVENT SHALL THE INTEL OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+		EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+		LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+		IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+		THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+-----------------------------------------------------------------------*/
+
+// http://codesuppository.blogspot.com
+//
+// mailto: jratcliff@infiniplex.net
+//
+// http://www.amillionpixels.us
+//
+
+#pragma warning(disable : 4786)
+
+#include <math.h>
+#include <float.h>
+#include <vector>
+
+namespace ConvexDecomposition
+{
+const float DEG_TO_RAD = ((2.0f * 3.14152654f) / 360.0f);
+const float RAD_TO_DEG = (360.0f / (2.0f * 3.141592654f));
+
+class Vector3d
+{
+public:
+	Vector3d(void){};  // null constructor, does not inialize point.
+
+	Vector3d(const Vector3d &a)  // constructor copies existing vector.
+	{
+		x = a.x;
+		y = a.y;
+		z = a.z;
+	};
+
+	Vector3d(float a, float b, float c)  // construct with initial point.
+	{
+		x = a;
+		y = b;
+		z = c;
+	};
+
+	Vector3d(const float *t)
+	{
+		x = t[0];
+		y = t[1];
+		z = t[2];
+	};
+
+	Vector3d(const int *t)
+	{
+		x = t[0];
+		y = t[1];
+		z = t[2];
+	};
+
+	bool operator==(const Vector3d &a) const
+	{
+		return (a.x == x && a.y == y && a.z == z);
+	};
+
+	bool operator!=(const Vector3d &a) const
+	{
+		return (a.x != x || a.y != y || a.z != z);
+	};
+
+	// Operators
+	Vector3d &operator=(const Vector3d &A)  // ASSIGNMENT (=)
+	{
+		x = A.x;
+		y = A.y;
+		z = A.z;
+		return (*this);
+	};
+
+	Vector3d operator+(const Vector3d &A) const  // ADDITION (+)
+	{
+		Vector3d Sum(x + A.x, y + A.y, z + A.z);
+		return (Sum);
+	};
+
+	Vector3d operator-(const Vector3d &A) const  // SUBTRACTION (-)
+	{
+		Vector3d Diff(x - A.x, y - A.y, z - A.z);
+		return (Diff);
+	};
+
+	Vector3d operator*(const float s) const  // MULTIPLY BY SCALAR (*)
+	{
+		Vector3d Scaled(x * s, y * s, z * s);
+		return (Scaled);
+	};
+
+	Vector3d operator+(const float s) const  // ADD CONSTANT TO ALL 3 COMPONENTS (*)
+	{
+		Vector3d Scaled(x + s, y + s, z + s);
+		return (Scaled);
+	};
+
+	Vector3d operator/(const float s) const  // DIVIDE BY SCALAR (/)
+	{
+		float r = 1.0f / s;
+		Vector3d Scaled(x * r, y * r, z * r);
+		return (Scaled);
+	};
+
+	void operator/=(float A)  // ACCUMULATED VECTOR ADDITION (/=)
+	{
+		x /= A;
+		y /= A;
+		z /= A;
+	};
+
+	void operator+=(const Vector3d A)  // ACCUMULATED VECTOR ADDITION (+=)
+	{
+		x += A.x;
+		y += A.y;
+		z += A.z;
+	};
+	void operator-=(const Vector3d A)  // ACCUMULATED VECTOR SUBTRACTION (+=)
+	{
+		x -= A.x;
+		y -= A.y;
+		z -= A.z;
+	};
+	void operator*=(const float s)  // ACCUMULATED SCALAR MULTIPLICATION (*=) (bpc 4/24/2000)
+	{
+		x *= s;
+		y *= s;
+		z *= s;
+	}
+
+	void operator+=(const float A)  // ACCUMULATED VECTOR ADDITION (+=)
+	{
+		x += A;
+		y += A;
+		z += A;
+	};
+
+	Vector3d operator-(void) const  // NEGATION (-)
+	{
+		Vector3d Negated(-x, -y, -z);
+		return (Negated);
+	};
+
+	float operator[](const int i) const  // ALLOWS VECTOR ACCESS AS AN ARRAY.
+	{
+		return ((i == 0) ? x : ((i == 1) ? y : z));
+	};
+	float &operator[](const int i)
+	{
+		return ((i == 0) ? x : ((i == 1) ? y : z));
+	};
+	//
+
+	// accessor methods.
+	float GetX(void) const { return x; };
+	float GetY(void) const { return y; };
+	float GetZ(void) const { return z; };
+
+	float X(void) const { return x; };
+	float Y(void) const { return y; };
+	float Z(void) const { return z; };
+
+	void SetX(float t) { x = t; };
+	void SetY(float t) { y = t; };
+	void SetZ(float t) { z = t; };
+
+	bool IsSame(const Vector3d &v, float epsilon) const
+	{
+		float dx = fabsf(x - v.x);
+		if (dx > epsilon) return false;
+		float dy = fabsf(y - v.y);
+		if (dy > epsilon) return false;
+		float dz = fabsf(z - v.z);
+		if (dz > epsilon) return false;
+		return true;
+	}
+
+	float ComputeNormal(const Vector3d &A,
+						const Vector3d &B,
+						const Vector3d &C)
+	{
+		float vx, vy, vz, wx, wy, wz, vw_x, vw_y, vw_z, mag;
+
+		vx = (B.x - C.x);
+		vy = (B.y - C.y);
+		vz = (B.z - C.z);
+
+		wx = (A.x - B.x);
+		wy = (A.y - B.y);
+		wz = (A.z - B.z);
+
+		vw_x = vy * wz - vz * wy;
+		vw_y = vz * wx - vx * wz;
+		vw_z = vx * wy - vy * wx;
+
+		mag = sqrtf((vw_x * vw_x) + (vw_y * vw_y) + (vw_z * vw_z));
+
+		if (mag < 0.000001f)
+		{
+			mag = 0;
+		}
+		else
+		{
+			mag = 1.0f / mag;
+		}
+
+		x = vw_x * mag;
+		y = vw_y * mag;
+		z = vw_z * mag;
+
+		return mag;
+	}
+
+	void ScaleSumScale(float c0, float c1, const Vector3d &pos)
+	{
+		x = (x * c0) + (pos.x * c1);
+		y = (y * c0) + (pos.y * c1);
+		z = (z * c0) + (pos.z * c1);
+	}
+
+	void SwapYZ(void)
+	{
+		float t = y;
+		y = z;
+		z = t;
+	};
+
+	void Get(float *v) const
+	{
+		v[0] = x;
+		v[1] = y;
+		v[2] = z;
+	};
+
+	void Set(const int *p)
+	{
+		x = (float)p[0];
+		y = (float)p[1];
+		z = (float)p[2];
+	}
+
+	void Set(const float *p)
+	{
+		x = (float)p[0];
+		y = (float)p[1];
+		z = (float)p[2];
+	}
+
+	void Set(float a, float b, float c)
+	{
+		x = a;
+		y = b;
+		z = c;
+	};
+
+	void Zero(void)
+	{
+		x = y = z = 0;
+	};
+
+	const float *Ptr() const { return &x; }
+	float *Ptr() { return &x; }
+
+	// return -(*this).
+	Vector3d negative(void) const
+	{
+		Vector3d result;
+		result.x = -x;
+		result.y = -y;
+		result.z = -z;
+		return result;
+	}
+
+	float Magnitude(void) const
+	{
+		return float(sqrt(x * x + y * y + z * z));
+	};
+
+	float FastMagnitude(void) const
+	{
+		return float(sqrtf(x * x + y * y + z * z));
+	};
+
+	float FasterMagnitude(void) const
+	{
+		return float(sqrtf(x * x + y * y + z * z));
+	};
+
+	void Lerp(const Vector3d &from, const Vector3d &to, float slerp)
+	{
+		x = ((to.x - from.x) * slerp) + from.x;
+		y = ((to.y - from.y) * slerp) + from.y;
+		z = ((to.z - from.z) * slerp) + from.z;
+	};
+
+	// Highly specialized interpolate routine.  Will compute the interpolated position
+	// shifted forward or backwards along the ray defined between (from) and (to).
+	// Reason for existance is so that when a bullet collides with a wall, for
+	// example, you can generate a graphic effect slightly *before* it hit the
+	// wall so that the effect doesn't sort into the wall itself.
+	void Interpolate(const Vector3d &from, const Vector3d &to, float offset)
+	{
+		x = to.x - from.x;
+		y = to.y - from.y;
+		z = to.z - from.z;
+		float d = sqrtf(x * x + y * y + z * z);
+		float recip = 1.0f / d;
+		x *= recip;
+		y *= recip;
+		z *= recip;   // normalize vector
+		d += offset;  // shift along ray
+		x = x * d + from.x;
+		y = y * d + from.y;
+		z = z * d + from.z;
+	};
+
+	bool BinaryEqual(const Vector3d &p) const
+	{
+		const int *source = (const int *)&x;
+		const int *dest = (const int *)&p.x;
+
+		if (source[0] == dest[0] &&
+			source[1] == dest[1] &&
+			source[2] == dest[2]) return true;
+
+		return false;
+	};
+
+	/*bool BinaryEqual(const Vector3d<int> &p) const
+	{
+		if ( x == p.x && y == p.y && z == p.z ) return true;
+		return false;
+	}
+	*/
+
+	/** Computes the reflection vector between two vectors.*/
+	void Reflection(const Vector3d &a, const Vector3d &b)  // compute reflection vector.
+	{
+		Vector3d c;
+		Vector3d d;
+
+		float dot = a.Dot(b) * 2.0f;
+
+		c = b * dot;
+
+		d = c - a;
+
+		x = -d.x;
+		y = -d.y;
+		z = -d.z;
+	};
+
+	void AngleAxis(float angle, const Vector3d &axis)
+	{
+		x = axis.x * angle;
+		y = axis.y * angle;
+		z = axis.z * angle;
+	};
+
+	float Length(void) const  // length of vector.
+	{
+		return float(sqrt(x * x + y * y + z * z));
+	};
+
+	float ComputePlane(const Vector3d &A,
+					   const Vector3d &B,
+					   const Vector3d &C)
+	{
+		float vx, vy, vz, wx, wy, wz, vw_x, vw_y, vw_z, mag;
+
+		vx = (B.x - C.x);
+		vy = (B.y - C.y);
+		vz = (B.z - C.z);
+
+		wx = (A.x - B.x);
+		wy = (A.y - B.y);
+		wz = (A.z - B.z);
+
+		vw_x = vy * wz - vz * wy;
+		vw_y = vz * wx - vx * wz;
+		vw_z = vx * wy - vy * wx;
+
+		mag = sqrtf((vw_x * vw_x) + (vw_y * vw_y) + (vw_z * vw_z));
+
+		if (mag < 0.000001f)
+		{
+			mag = 0;
+		}
+		else
+		{
+			mag = 1.0f / mag;
+		}
+
+		x = vw_x * mag;
+		y = vw_y * mag;
+		z = vw_z * mag;
+
+		float D = 0.0f - ((x * A.x) + (y * A.y) + (z * A.z));
+
+		return D;
+	}
+
+	float FastLength(void) const  // length of vector.
+	{
+		return float(sqrtf(x * x + y * y + z * z));
+	};
+
+	float FasterLength(void) const  // length of vector.
+	{
+		return float(sqrtf(x * x + y * y + z * z));
+	};
+
+	float Length2(void) const  // squared distance, prior to square root.
+	{
+		float l2 = x * x + y * y + z * z;
+		return l2;
+	};
+
+	float Distance(const Vector3d &a) const  // distance between two points.
+	{
+		Vector3d d(a.x - x, a.y - y, a.z - z);
+		return d.Length();
+	}
+
+	float FastDistance(const Vector3d &a) const  // distance between two points.
+	{
+		Vector3d d(a.x - x, a.y - y, a.z - z);
+		return d.FastLength();
+	}
+
+	float FasterDistance(const Vector3d &a) const  // distance between two points.
+	{
+		Vector3d d(a.x - x, a.y - y, a.z - z);
+		return d.FasterLength();
+	}
+
+	float DistanceXY(const Vector3d &a) const
+	{
+		float dx = a.x - x;
+		float dy = a.y - y;
+		float dist = dx * dx + dy * dy;
+		return dist;
+	}
+
+	float Distance2(const Vector3d &a) const  // squared distance.
+	{
+		float dx = a.x - x;
+		float dy = a.y - y;
+		float dz = a.z - z;
+		return dx * dx + dy * dy + dz * dz;
+	};
+
+	float Partial(const Vector3d &p) const
+	{
+		return (x * p.y) - (p.x * y);
+	}
+
+	float Area(const Vector3d &p1, const Vector3d &p2) const
+	{
+		float A = Partial(p1);
+		A += p1.Partial(p2);
+		A += p2.Partial(*this);
+		return A * 0.5f;
+	}
+
+	inline float Normalize(void)  // normalize to a unit vector, returns distance.
+	{
+		float d = sqrtf(static_cast<float>(x * x + y * y + z * z));
+		if (d > 0)
+		{
+			float r = 1.0f / d;
+			x *= r;
+			y *= r;
+			z *= r;
+		}
+		else
+		{
+			x = y = z = 1;
+		}
+		return d;
+	};
+
+	inline float FastNormalize(void)  // normalize to a unit vector, returns distance.
+	{
+		float d = sqrt(static_cast<float>(x * x + y * y + z * z));
+		if (d > 0)
+		{
+			float r = 1.0f / d;
+			x *= r;
+			y *= r;
+			z *= r;
+		}
+		else
+		{
+			x = y = z = 1;
+		}
+		return d;
+	};
+
+	inline float FasterNormalize(void)  // normalize to a unit vector, returns distance.
+	{
+		float d = sqrtf(static_cast<float>(x * x + y * y + z * z));
+		if (d > 0)
+		{
+			float r = 1.0f / d;
+			x *= r;
+			y *= r;
+			z *= r;
+		}
+		else
+		{
+			x = y = z = 1;
+		}
+		return d;
+	};
+
+	float Dot(const Vector3d &a) const  // computes dot product.
+	{
+		return (x * a.x + y * a.y + z * a.z);
+	};
+
+	Vector3d Cross(const Vector3d &other) const
+	{
+		Vector3d result(y * other.z - z * other.y, z * other.x - x * other.z, x * other.y - y * other.x);
+
+		return result;
+	}
+
+	void Cross(const Vector3d &a, const Vector3d &b)  // cross two vectors result in this one.
+	{
+		x = a.y * b.z - a.z * b.y;
+		y = a.z * b.x - a.x * b.z;
+		z = a.x * b.y - a.y * b.x;
+	};
+
+	/******************************************/
+	// Check if next edge (b to c) turns inward
+	//
+	//    Edge from a to b is already in face
+	//    Edge from b to c is being considered for addition to face
+	/******************************************/
+	bool Concave(const Vector3d &a, const Vector3d &b)
+	{
+		float vx, vy, vz, wx, wy, wz, vw_x, vw_y, vw_z, mag, nx, ny, nz, mag_a, mag_b;
+
+		wx = b.x - a.x;
+		wy = b.y - a.y;
+		wz = b.z - a.z;
+
+		mag_a = (float)sqrtf((wx * wx) + (wy * wy) + (wz * wz));
+
+		vx = x - b.x;
+		vy = y - b.y;
+		vz = z - b.z;
+
+		mag_b = (float)sqrtf((vx * vx) + (vy * vy) + (vz * vz));
+
+		vw_x = (vy * wz) - (vz * wy);
+		vw_y = (vz * wx) - (vx * wz);
+		vw_z = (vx * wy) - (vy * wx);
+
+		mag = (float)sqrtf((vw_x * vw_x) + (vw_y * vw_y) + (vw_z * vw_z));
+
+		// Check magnitude of cross product, which is a sine function
+		// i.e., mag (a x b) = mag (a) * mag (b) * sin (theta);
+		// If sin (theta) small, then angle between edges is very close to
+		// 180, which we may want to call a concavity.	Setting the
+		// CONCAVITY_TOLERANCE value greater than about 0.01 MAY cause
+		// face consolidation to get stuck on particular face.	Most meshes
+		// convert properly with a value of 0.0
+
+		if (mag / (mag_a * mag_b) <= 0.0f) return true;
+
+		mag = 1.0f / mag;
+
+		nx = vw_x * mag;
+		ny = vw_y * mag;
+		nz = vw_z * mag;
+
+		// Dot product of tri normal with cross product result will
+		// yield positive number if edges are convex (+1.0 if two tris
+		// are coplanar), negative number if edges are concave (-1.0 if
+		// two tris are coplanar.)
+
+		mag = (x * nx) + (y * ny) + (z * nz);
+
+		if (mag > 0.0f) return false;
+
+		return (true);
+	};
+
+	bool PointTestXY(const Vector3d &i, const Vector3d &j) const
+	{
+		if ((((i.y <= y) && (y < j.y)) ||
+			 ((j.y <= y) && (y < i.y))) &&
+			(x < (j.x - i.x) * (y - i.y) / (j.y - i.y) + i.x)) return true;
+		return false;
+	}
+
+	// test to see if this point is inside the triangle specified by
+	// these three points on the X/Y plane.
+	bool PointInTriXY(const Vector3d &p1,
+					  const Vector3d &p2,
+					  const Vector3d &p3) const
+	{
+		float ax = p3.x - p2.x;
+		float ay = p3.y - p2.y;
+		float bx = p1.x - p3.x;
+		float by = p1.y - p3.y;
+		float cx = p2.x - p1.x;
+		float cy = p2.y - p1.y;
+		float apx = x - p1.x;
+		float apy = y - p1.y;
+		float bpx = x - p2.x;
+		float bpy = y - p2.y;
+		float cpx = x - p3.x;
+		float cpy = y - p3.y;
+
+		float aCROSSbp = ax * bpy - ay * bpx;
+		float cCROSSap = cx * apy - cy * apx;
+		float bCROSScp = bx * cpy - by * cpx;
+
+		return ((aCROSSbp >= 0.0f) && (bCROSScp >= 0.0f) && (cCROSSap >= 0.0f));
+	};
+
+	// test to see if this point is inside the triangle specified by
+	// these three points on the X/Y plane.
+	bool PointInTriYZ(const Vector3d &p1,
+					  const Vector3d &p2,
+					  const Vector3d &p3) const
+	{
+		float ay = p3.y - p2.y;
+		float az = p3.z - p2.z;
+		float by = p1.y - p3.y;
+		float bz = p1.z - p3.z;
+		float cy = p2.y - p1.y;
+		float cz = p2.z - p1.z;
+		float apy = y - p1.y;
+		float apz = z - p1.z;
+		float bpy = y - p2.y;
+		float bpz = z - p2.z;
+		float cpy = y - p3.y;
+		float cpz = z - p3.z;
+
+		float aCROSSbp = ay * bpz - az * bpy;
+		float cCROSSap = cy * apz - cz * apy;
+		float bCROSScp = by * cpz - bz * cpy;
+
+		return ((aCROSSbp >= 0.0f) && (bCROSScp >= 0.0f) && (cCROSSap >= 0.0f));
+	};
+
+	// test to see if this point is inside the triangle specified by
+	// these three points on the X/Y plane.
+	bool PointInTriXZ(const Vector3d &p1,
+					  const Vector3d &p2,
+					  const Vector3d &p3) const
+	{
+		float az = p3.z - p2.z;
+		float ax = p3.x - p2.x;
+		float bz = p1.z - p3.z;
+		float bx = p1.x - p3.x;
+		float cz = p2.z - p1.z;
+		float cx = p2.x - p1.x;
+		float apz = z - p1.z;
+		float apx = x - p1.x;
+		float bpz = z - p2.z;
+		float bpx = x - p2.x;
+		float cpz = z - p3.z;
+		float cpx = x - p3.x;
+
+		float aCROSSbp = az * bpx - ax * bpz;
+		float cCROSSap = cz * apx - cx * apz;
+		float bCROSScp = bz * cpx - bx * cpz;
+
+		return ((aCROSSbp >= 0.0f) && (bCROSScp >= 0.0f) && (cCROSSap >= 0.0f));
+	};
+
+	// Given a point and a line (defined by two points), compute the closest point
+	// in the line.  (The line is treated as infinitely long.)
+	void NearestPointInLine(const Vector3d &point,
+							const Vector3d &line0,
+							const Vector3d &line1)
+	{
+		Vector3d &nearestPoint = *this;
+		Vector3d lineDelta = line1 - line0;
+
+		// Handle degenerate lines
+		if (lineDelta == Vector3d(0, 0, 0))
+		{
+			nearestPoint = line0;
+		}
+		else
+		{
+			float delta = (point - line0).Dot(lineDelta) / (lineDelta).Dot(lineDelta);
+			nearestPoint = line0 + lineDelta * delta;
+		}
+	}
+
+	// Given a point and a line segment (defined by two points), compute the closest point
+	// in the line.  Cap the point at the endpoints of the line segment.
+	void NearestPointInLineSegment(const Vector3d &point,
+								   const Vector3d &line0,
+								   const Vector3d &line1)
+	{
+		Vector3d &nearestPoint = *this;
+		Vector3d lineDelta = line1 - line0;
+
+		// Handle degenerate lines
+		if (lineDelta == Vector3d(0, 0, 0))
+		{
+			nearestPoint = line0;
+		}
+		else
+		{
+			float delta = (point - line0).Dot(lineDelta) / (lineDelta).Dot(lineDelta);
+
+			// Clamp the point to conform to the segment's endpoints
+			if (delta < 0)
+				delta = 0;
+			else if (delta > 1)
+				delta = 1;
+
+			nearestPoint = line0 + lineDelta * delta;
+		}
+	}
+
+	// Given a point and a plane (defined by three points), compute the closest point
+	// in the plane.  (The plane is unbounded.)
+	void NearestPointInPlane(const Vector3d &point,
+							 const Vector3d &triangle0,
+							 const Vector3d &triangle1,
+							 const Vector3d &triangle2)
+	{
+		Vector3d &nearestPoint = *this;
+		Vector3d lineDelta0 = triangle1 - triangle0;
+		Vector3d lineDelta1 = triangle2 - triangle0;
+		Vector3d pointDelta = point - triangle0;
+		Vector3d normal;
+
+		// Get the normal of the polygon (doesn't have to be a unit vector)
+		normal.Cross(lineDelta0, lineDelta1);
+
+		float delta = normal.Dot(pointDelta) / normal.Dot(normal);
+		nearestPoint = point - normal * delta;
+	}
+
+	// Given a point and a plane (defined by a coplanar point and a normal), compute the closest point
+	// in the plane.  (The plane is unbounded.)
+	void NearestPointInPlane(const Vector3d &point,
+							 const Vector3d &planePoint,
+							 const Vector3d &planeNormal)
+	{
+		Vector3d &nearestPoint = *this;
+		Vector3d pointDelta = point - planePoint;
+
+		float delta = planeNormal.Dot(pointDelta) / planeNormal.Dot(planeNormal);
+		nearestPoint = point - planeNormal * delta;
+	}
+
+	// Given a point and a triangle (defined by three points), compute the closest point
+	// in the triangle.  Clamp the point so it's confined to the area of the triangle.
+	void NearestPointInTriangle(const Vector3d &point,
+								const Vector3d &triangle0,
+								const Vector3d &triangle1,
+								const Vector3d &triangle2)
+	{
+		static const Vector3d zeroVector(0, 0, 0);
+
+		Vector3d &nearestPoint = *this;
+
+		Vector3d lineDelta0 = triangle1 - triangle0;
+		Vector3d lineDelta1 = triangle2 - triangle0;
+
+		// Handle degenerate triangles
+		if ((lineDelta0 == zeroVector) || (lineDelta1 == zeroVector))
+		{
+			nearestPoint.NearestPointInLineSegment(point, triangle1, triangle2);
+		}
+		else if (lineDelta0 == lineDelta1)
+		{
+			nearestPoint.NearestPointInLineSegment(point, triangle0, triangle1);
+		}
+
+		else
+		{
+			Vector3d axis[3];
+			axis[0].NearestPointInLine(triangle0, triangle1, triangle2);
+			axis[1].NearestPointInLine(triangle1, triangle0, triangle2);
+			axis[2].NearestPointInLine(triangle2, triangle0, triangle1);
+
+			float axisDot[3];
+			axisDot[0] = (triangle0 - axis[0]).Dot(point - axis[0]);
+			axisDot[1] = (triangle1 - axis[1]).Dot(point - axis[1]);
+			axisDot[2] = (triangle2 - axis[2]).Dot(point - axis[2]);
+
+			bool bForce = true;
+			float bestMagnitude2 = 0;
+			float closeMagnitude2;
+			Vector3d closePoint;
+
+			if (axisDot[0] < 0)
+			{
+				closePoint.NearestPointInLineSegment(point, triangle1, triangle2);
+				closeMagnitude2 = point.Distance2(closePoint);
+				if (bForce || (bestMagnitude2 > closeMagnitude2))
+				{
+					bForce = false;
+					bestMagnitude2 = closeMagnitude2;
+					nearestPoint = closePoint;
+				}
+			}
+			if (axisDot[1] < 0)
+			{
+				closePoint.NearestPointInLineSegment(point, triangle0, triangle2);
+				closeMagnitude2 = point.Distance2(closePoint);
+				if (bForce || (bestMagnitude2 > closeMagnitude2))
+				{
+					bForce = false;
+					bestMagnitude2 = closeMagnitude2;
+					nearestPoint = closePoint;
+				}
+			}
+			if (axisDot[2] < 0)
+			{
+				closePoint.NearestPointInLineSegment(point, triangle0, triangle1);
+				closeMagnitude2 = point.Distance2(closePoint);
+				if (bForce || (bestMagnitude2 > closeMagnitude2))
+				{
+					bForce = false;
+					bestMagnitude2 = closeMagnitude2;
+					nearestPoint = closePoint;
+				}
+			}
+
+			// If bForce is true at this point, it means the nearest point lies
+			// inside the triangle; use the nearest-point-on-a-plane equation
+			if (bForce)
+			{
+				Vector3d normal;
+
+				// Get the normal of the polygon (doesn't have to be a unit vector)
+				normal.Cross(lineDelta0, lineDelta1);
+
+				Vector3d pointDelta = point - triangle0;
+				float delta = normal.Dot(pointDelta) / normal.Dot(normal);
+
+				nearestPoint = point - normal * delta;
+			}
+		}
+	}
+
+	//private:
+
+	float x;
+	float y;
+	float z;
+};
+
+class Vector2d
+{
+public:
+	Vector2d(void){};  // null constructor, does not inialize point.
+
+	Vector2d(const Vector2d &a)  // constructor copies existing vector.
+	{
+		x = a.x;
+		y = a.y;
+	};
+
+	Vector2d(const float *t)
+	{
+		x = t[0];
+		y = t[1];
+	};
+
+	Vector2d(float a, float b)  // construct with initial point.
+	{
+		x = a;
+		y = b;
+	};
+
+	const float *Ptr() const { return &x; }
+	float *Ptr() { return &x; }
+
+	Vector2d &operator+=(const Vector2d &a)  // += operator.
+	{
+		x += a.x;
+		y += a.y;
+		return *this;
+	};
+
+	Vector2d &operator-=(const Vector2d &a)
+	{
+		x -= a.x;
+		y -= a.y;
+		return *this;
+	};
+
+	Vector2d &operator*=(const Vector2d &a)
+	{
+		x *= a.x;
+		y *= a.y;
+		return *this;
+	};
+
+	Vector2d &operator/=(const Vector2d &a)
+	{
+		x /= a.x;
+		y /= a.y;
+		return *this;
+	};
+
+	bool operator==(const Vector2d &a) const
+	{
+		if (a.x == x && a.y == y) return true;
+		return false;
+	};
+
+	bool operator!=(const Vector2d &a) const
+	{
+		if (a.x != x || a.y != y) return true;
+		return false;
+	};
+
+	Vector2d operator+(Vector2d a) const
+	{
+		a.x += x;
+		a.y += y;
+		return a;
+	};
+
+	Vector2d operator-(Vector2d a) const
+	{
+		a.x = x - a.x;
+		a.y = y - a.y;
+		return a;
+	};
+
+	Vector2d operator-(void) const
+	{
+		return negative();
+	};
+
+	Vector2d operator*(Vector2d a) const
+	{
+		a.x *= x;
+		a.y *= y;
+		return a;
+	};
+
+	Vector2d operator*(float c) const
+	{
+		Vector2d a;
+
+		a.x = x * c;
+		a.y = y * c;
+
+		return a;
+	};
+
+	Vector2d operator/(Vector2d a) const
+	{
+		a.x = x / a.x;
+		a.y = y / a.y;
+		return a;
+	};
+
+	float Dot(const Vector2d &a) const  // computes dot product.
+	{
+		return (x * a.x + y * a.y);
+	};
+
+	float GetX(void) const { return x; };
+	float GetY(void) const { return y; };
+
+	void SetX(float t) { x = t; };
+	void SetY(float t) { y = t; };
+
+	void Set(float a, float b)
+	{
+		x = a;
+		y = b;
+	};
+
+	void Zero(void)
+	{
+		x = y = 0;
+	};
+
+	Vector2d negative(void) const
+	{
+		Vector2d result;
+		result.x = -x;
+		result.y = -y;
+		return result;
+	}
+
+	float magnitude(void) const
+	{
+		return (float)sqrtf(x * x + y * y);
+	}
+
+	float fastmagnitude(void) const
+	{
+		return (float)sqrtf(x * x + y * y);
+	}
+
+	float fastermagnitude(void) const
+	{
+		return (float)sqrtf(x * x + y * y);
+	}
+
+	void Reflection(Vector2d &a, Vector2d &b);  // compute reflection vector.
+
+	float Length(void) const  // length of vector.
+	{
+		return float(sqrtf(x * x + y * y));
+	};
+
+	float FastLength(void) const  // length of vector.
+	{
+		return float(sqrtf(x * x + y * y));
+	};
+
+	float FasterLength(void) const  // length of vector.
+	{
+		return float(sqrtf(x * x + y * y));
+	};
+
+	float Length2(void)  // squared distance, prior to square root.
+	{
+		return x * x + y * y;
+	}
+
+	float Distance(const Vector2d &a) const  // distance between two points.
+	{
+		float dx = a.x - x;
+		float dy = a.y - y;
+		float d = dx * dx + dy * dy;
+		return sqrtf(d);
+	};
+
+	float FastDistance(const Vector2d &a) const  // distance between two points.
+	{
+		float dx = a.x - x;
+		float dy = a.y - y;
+		float d = dx * dx + dy * dy;
+		return sqrtf(d);
+	};
+
+	float FasterDistance(const Vector2d &a) const  // distance between two points.
+	{
+		float dx = a.x - x;
+		float dy = a.y - y;
+		float d = dx * dx + dy * dy;
+		return sqrtf(d);
+	};
+
+	float Distance2(Vector2d &a)  // squared distance.
+	{
+		float dx = a.x - x;
+		float dy = a.y - y;
+		return dx * dx + dy * dy;
+	};
+
+	void Lerp(const Vector2d &from, const Vector2d &to, float slerp)
+	{
+		x = ((to.x - from.x) * slerp) + from.x;
+		y = ((to.y - from.y) * slerp) + from.y;
+	};
+
+	void Cross(const Vector2d &a, const Vector2d &b)  // cross two vectors result in this one.
+	{
+		x = a.y * b.x - a.x * b.y;
+		y = a.x * b.x - a.x * b.x;
+	};
+
+	float Normalize(void)  // normalize to a unit vector, returns distance.
+	{
+		float l = Length();
+		if (l != 0)
+		{
+			l = float(1) / l;
+			x *= l;
+			y *= l;
+		}
+		else
+		{
+			x = y = 0;
+		}
+		return l;
+	};
+
+	float FastNormalize(void)  // normalize to a unit vector, returns distance.
+	{
+		float l = FastLength();
+		if (l != 0)
+		{
+			l = float(1) / l;
+			x *= l;
+			y *= l;
+		}
+		else
+		{
+			x = y = 0;
+		}
+		return l;
+	};
+
+	float FasterNormalize(void)  // normalize to a unit vector, returns distance.
+	{
+		float l = FasterLength();
+		if (l != 0)
+		{
+			l = float(1) / l;
+			x *= l;
+			y *= l;
+		}
+		else
+		{
+			x = y = 0;
+		}
+		return l;
+	};
+
+	float x;
+	float y;
+};
+
+class Line
+{
+public:
+	Line(const Vector3d &from, const Vector3d &to)
+	{
+		mP1 = from;
+		mP2 = to;
+	};
+	// JWR  Test for the intersection of two lines.
+
+	bool Intersect(const Line &src, Vector3d &sect);
+
+private:
+	Vector3d mP1;
+	Vector3d mP2;
+};
+
+typedef std::vector<Vector3d> Vector3dVector;
+typedef std::vector<Vector2d> Vector2dVector;
+
+inline Vector3d operator*(float s, const Vector3d &v)
+{
+	Vector3d Scaled(v.x * s, v.y * s, v.z * s);
+	return (Scaled);
+}
+
+inline Vector2d operator*(float s, const Vector2d &v)
+{
+	Vector2d Scaled(v.x * s, v.y * s);
+	return (Scaled);
+}
+
+}  // namespace ConvexDecomposition
+
+#endif
diff --git a/engine/inc/bullet/ConvexDecomposition/cd_wavefront.h b/engine/inc/bullet/ConvexDecomposition/cd_wavefront.h
new file mode 100644
index 00000000..e50a5853
--- /dev/null
+++ b/engine/inc/bullet/ConvexDecomposition/cd_wavefront.h
@@ -0,0 +1,57 @@
+#ifndef CD_WAVEFRONT_OBJ_H
+
+#define CD_WAVEFRONT_OBJ_H
+
+/*----------------------------------------------------------------------
+		Copyright (c) 2004 Open Dynamics Framework Group
+					www.physicstools.org
+		All rights reserved.
+
+		Redistribution and use in source and binary forms, with or without modification, are permitted provided
+		that the following conditions are met:
+
+		Redistributions of source code must retain the above copyright notice, this list of conditions
+		and the following disclaimer.
+
+		Redistributions in binary form must reproduce the above copyright notice,
+		this list of conditions and the following disclaimer in the documentation
+		and/or other materials provided with the distribution.
+
+		Neither the name of the Open Dynamics Framework Group nor the names of its contributors may
+		be used to endorse or promote products derived from this software without specific prior written permission.
+
+		THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+		INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+		DISCLAIMED. IN NO EVENT SHALL THE INTEL OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+		EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+		LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+		IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+		THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+-----------------------------------------------------------------------*/
+
+// http://codesuppository.blogspot.com
+//
+// mailto: jratcliff@infiniplex.net
+//
+// http://www.amillionpixels.us
+//
+
+namespace ConvexDecomposition
+{
+class WavefrontObj
+{
+public:
+	WavefrontObj(void);
+	~WavefrontObj(void);
+
+	unsigned int loadObj(const char *fname);  // load a wavefront obj returns number of triangles that were loaded.  Data is persists until the class is destructed.
+
+	int mVertexCount;
+	int mTriCount;
+	int *mIndices;
+	float *mVertices;
+};
+
+}  // namespace ConvexDecomposition
+
+#endif
diff --git a/engine/inc/bullet/ConvexDecomposition/concavity.h b/engine/inc/bullet/ConvexDecomposition/concavity.h
new file mode 100644
index 00000000..be5e7580
--- /dev/null
+++ b/engine/inc/bullet/ConvexDecomposition/concavity.h
@@ -0,0 +1,55 @@
+#ifndef COMPUTE_CONCAVITY_H
+
+#define COMPUTE_CONCAVITY_H
+
+/*----------------------------------------------------------------------
+		Copyright (c) 2004 Open Dynamics Framework Group
+					www.physicstools.org
+		All rights reserved.
+
+		Redistribution and use in source and binary forms, with or without modification, are permitted provided
+		that the following conditions are met:
+
+		Redistributions of source code must retain the above copyright notice, this list of conditions
+		and the following disclaimer.
+
+		Redistributions in binary form must reproduce the above copyright notice,
+		this list of conditions and the following disclaimer in the documentation
+		and/or other materials provided with the distribution.
+
+		Neither the name of the Open Dynamics Framework Group nor the names of its contributors may
+		be used to endorse or promote products derived from this software without specific prior written permission.
+
+		THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+		INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+		DISCLAIMED. IN NO EVENT SHALL THE INTEL OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+		EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+		LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+		IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+		THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+-----------------------------------------------------------------------*/
+
+// http://codesuppository.blogspot.com
+//
+// mailto: jratcliff@infiniplex.net
+//
+// http://www.amillionpixels.us
+//
+
+namespace ConvexDecomposition
+{
+class ConvexDecompInterface;
+
+// compute's how 'concave' this object is and returns the total volume of the
+// convex hull as well as the volume of the 'concavity' which was found.
+float computeConcavity(unsigned int vcount,
+					   const float *vertices,
+					   unsigned int tcount,
+					   const unsigned int *indices,
+					   ConvexDecompInterface *callback,
+					   float *plane,
+					   float &volume);
+
+}  // namespace ConvexDecomposition
+
+#endif
diff --git a/engine/inc/bullet/ConvexDecomposition/fitsphere.h b/engine/inc/bullet/ConvexDecomposition/fitsphere.h
new file mode 100644
index 00000000..41d20dbd
--- /dev/null
+++ b/engine/inc/bullet/ConvexDecomposition/fitsphere.h
@@ -0,0 +1,41 @@
+#ifndef FIT_SPHERE_H
+
+#define FIT_SPHERE_H
+
+/*----------------------------------------------------------------------
+		Copyright (c) 2004 Open Dynamics Framework Group
+					www.physicstools.org
+		All rights reserved.
+
+		Redistribution and use in source and binary forms, with or without modification, are permitted provided
+		that the following conditions are met:
+
+		Redistributions of source code must retain the above copyright notice, this list of conditions
+		and the following disclaimer.
+
+		Redistributions in binary form must reproduce the above copyright notice,
+		this list of conditions and the following disclaimer in the documentation
+		and/or other materials provided with the distribution.
+
+		Neither the name of the Open Dynamics Framework Group nor the names of its contributors may
+		be used to endorse or promote products derived from this software without specific prior written permission.
+
+		THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+		INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+		DISCLAIMED. IN NO EVENT SHALL THE INTEL OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+		EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+		LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+		IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+		THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+-----------------------------------------------------------------------*/
+
+// http://codesuppository.blogspot.com
+//
+// mailto: jratcliff@infiniplex.net
+//
+// http://www.amillionpixels.us
+//
+
+float computeBoundingSphere(unsigned int vcount, const float *points, float *center);
+
+#endif
diff --git a/engine/inc/bullet/ConvexDecomposition/float_math.h b/engine/inc/bullet/ConvexDecomposition/float_math.h
new file mode 100644
index 00000000..b2328001
--- /dev/null
+++ b/engine/inc/bullet/ConvexDecomposition/float_math.h
@@ -0,0 +1,71 @@
+#ifndef FLOAT_MATH_H
+
+#define FLOAT_MATH_H
+
+#ifdef _WIN32
+#pragma warning(disable : 4324)  // disable padding warning
+#pragma warning(disable : 4244)  // disable padding warning
+#pragma warning(disable : 4267)  //  possible loss of data
+#pragma warning(disable : 4530)  // Disable the exception disable but used in MSCV Stl warning.
+#pragma warning(disable : 4996)  //Turn off warnings about deprecated C routines
+#pragma warning(disable : 4786)  // Disable the "debug name too long" warning
+#endif
+
+/*----------------------------------------------------------------------
+		Copyright (c) 2004 Open Dynamics Framework Group
+					www.physicstools.org
+		All rights reserved.
+
+		Redistribution and use in source and binary forms, with or without modification, are permitted provided
+		that the following conditions are met:
+
+		Redistributions of source code must retain the above copyright notice, this list of conditions
+		and the following disclaimer.
+
+		Redistributions in binary form must reproduce the above copyright notice,
+		this list of conditions and the following disclaimer in the documentation
+		and/or other materials provided with the distribution.
+
+		Neither the name of the Open Dynamics Framework Group nor the names of its contributors may
+		be used to endorse or promote products derived from this software without specific prior written permission.
+
+		THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+		INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+		DISCLAIMED. IN NO EVENT SHALL THE INTEL OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+		EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+		LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+		IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+		THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+-----------------------------------------------------------------------*/
+
+// http://codesuppository.blogspot.com
+//
+// mailto: jratcliff@infiniplex.net
+//
+// http://www.amillionpixels.us
+//
+
+// a set of routines that last you do common 3d math
+// operations without any vector, matrix, or quaternion
+// classes or templates.
+//
+// a vector (or point) is a 'float *' to 3 floating point numbers.
+// a matrix is a 'float *' to an array of 16 floating point numbers representing a 4x4 transformation matrix compatible with D3D or OGL
+// a quaternion is a 'float *' to 4 floats representing a quaternion x,y,z,w
+
+const float FM_PI = 3.141592654f;
+const float FM_DEG_TO_RAD = ((2.0f * FM_PI) / 360.0f);
+const float FM_RAD_TO_DEG = (360.0f / (2.0f * FM_PI));
+
+void fm_identity(float *matrix);                                     // set 4x4 matrix to identity.
+void fm_inverseRT(const float *matrix, const float *pos, float *t);  // inverse rotate translate the point.
+void fm_eulerMatrix(float ax, float ay, float az, float *matrix);    // convert euler (in radians) to a dest 4x4 matrix (translation set to zero)
+void fm_getAABB(unsigned int vcount, const float *points, unsigned int pstride, float *bmin, float *bmax);
+void fm_eulerToQuat(float roll, float pitch, float yaw, float *quat);  // convert euler angles to quaternion.
+void fm_quatToMatrix(const float *quat, float *matrix);                // convert quaterinion rotation to matrix, translation set to zero.
+void fm_quatRotate(const float *quat, const float *v, float *r);       // rotate a vector directly by a quaternion.
+void fm_getTranslation(const float *matrix, float *t);
+void fm_matrixToQuat(const float *matrix, float *quat);  // convert the 3x3 portion of a 4x4 matrix into a quaterion as x,y,z,w
+float fm_sphereVolume(float radius);                     // return's the volume of a sphere of this radius (4/3 PI * R cubed )
+
+#endif
diff --git a/engine/inc/bullet/ConvexDecomposition/meshvolume.h b/engine/inc/bullet/ConvexDecomposition/meshvolume.h
new file mode 100644
index 00000000..73477e0c
--- /dev/null
+++ b/engine/inc/bullet/ConvexDecomposition/meshvolume.h
@@ -0,0 +1,42 @@
+#ifndef MESH_VOLUME_H
+
+#define MESH_VOLUME_H
+
+/*----------------------------------------------------------------------
+		Copyright (c) 2004 Open Dynamics Framework Group
+					www.physicstools.org
+		All rights reserved.
+
+		Redistribution and use in source and binary forms, with or without modification, are permitted provided
+		that the following conditions are met:
+
+		Redistributions of source code must retain the above copyright notice, this list of conditions
+		and the following disclaimer.
+
+		Redistributions in binary form must reproduce the above copyright notice,
+		this list of conditions and the following disclaimer in the documentation
+		and/or other materials provided with the distribution.
+
+		Neither the name of the Open Dynamics Framework Group nor the names of its contributors may
+		be used to endorse or promote products derived from this software without specific prior written permission.
+
+		THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+		INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+		DISCLAIMED. IN NO EVENT SHALL THE INTEL OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+		EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+		LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+		IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+		THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+-----------------------------------------------------------------------*/
+
+// http://codesuppository.blogspot.com
+//
+// mailto: jratcliff@infiniplex.net
+//
+// http://www.amillionpixels.us
+//
+
+float computeMeshVolume(const float *vertices, unsigned int tcount, const unsigned int *indices);
+float computeMeshVolume2(const float *vertices, unsigned int tcount, const unsigned int *indices);
+
+#endif
diff --git a/engine/inc/bullet/ConvexDecomposition/planetri.h b/engine/inc/bullet/ConvexDecomposition/planetri.h
new file mode 100644
index 00000000..1ae2ab21
--- /dev/null
+++ b/engine/inc/bullet/ConvexDecomposition/planetri.h
@@ -0,0 +1,55 @@
+#ifndef PLANE_TRI_H
+
+#define PLANE_TRI_H
+
+/*----------------------------------------------------------------------
+		Copyright (c) 2004 Open Dynamics Framework Group
+					www.physicstools.org
+		All rights reserved.
+
+		Redistribution and use in source and binary forms, with or without modification, are permitted provided
+		that the following conditions are met:
+
+		Redistributions of source code must retain the above copyright notice, this list of conditions
+		and the following disclaimer.
+
+		Redistributions in binary form must reproduce the above copyright notice,
+		this list of conditions and the following disclaimer in the documentation
+		and/or other materials provided with the distribution.
+
+		Neither the name of the Open Dynamics Framework Group nor the names of its contributors may
+		be used to endorse or promote products derived from this software without specific prior written permission.
+
+		THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+		INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+		DISCLAIMED. IN NO EVENT SHALL THE INTEL OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+		EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+		LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+		IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+		THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+-----------------------------------------------------------------------*/
+
+// http://codesuppository.blogspot.com
+//
+// mailto: jratcliff@infiniplex.net
+//
+// http://www.amillionpixels.us
+//
+
+enum PlaneTriResult
+{
+	PTR_FRONT,
+	PTR_BACK,
+	PTR_SPLIT
+};
+
+PlaneTriResult planeTriIntersection(const float *plane,     // the plane equation in Ax+By+Cz+D format
+									const float *triangle,  // the source position triangle.
+									unsigned int tstride,   // stride in bytes between vertices of the triangle.
+									float epsilon,          // the co-planer epsilon value.
+									float *front,           // the triangle in front of the
+									unsigned int &fcount,   // number of vertices in the 'front' triangle.
+									float *back,            // the triangle in back of the plane
+									unsigned int &bcount);  // the number of vertices in the 'back' triangle.
+
+#endif
diff --git a/engine/inc/bullet/ConvexDecomposition/raytri.h b/engine/inc/bullet/ConvexDecomposition/raytri.h
new file mode 100644
index 00000000..19932f8c
--- /dev/null
+++ b/engine/inc/bullet/ConvexDecomposition/raytri.h
@@ -0,0 +1,43 @@
+#ifndef RAY_TRI_H
+
+#define RAY_TRI_H
+
+/*----------------------------------------------------------------------
+		Copyright (c) 2004 Open Dynamics Framework Group
+					www.physicstools.org
+		All rights reserved.
+
+		Redistribution and use in source and binary forms, with or without modification, are permitted provided
+		that the following conditions are met:
+
+		Redistributions of source code must retain the above copyright notice, this list of conditions
+		and the following disclaimer.
+
+		Redistributions in binary form must reproduce the above copyright notice,
+		this list of conditions and the following disclaimer in the documentation
+		and/or other materials provided with the distribution.
+
+		Neither the name of the Open Dynamics Framework Group nor the names of its contributors may
+		be used to endorse or promote products derived from this software without specific prior written permission.
+
+		THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+		INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+		DISCLAIMED. IN NO EVENT SHALL THE INTEL OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+		EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+		LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+		IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+		THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+-----------------------------------------------------------------------*/
+
+// http://codesuppository.blogspot.com
+//
+// mailto: jratcliff@infiniplex.net
+//
+// http://www.amillionpixels.us
+//
+
+// returns true if the ray intersects the triangle.
+bool lineIntersectsTriangle(const float *rayStart, const float *rayEnd, const float *p1, const float *p2, const float *p3, float *sect);
+bool rayIntersectsTriangle(const float *p, const float *d, const float *v0, const float *v1, const float *v2, float &t);
+
+#endif
diff --git a/engine/inc/bullet/ConvexDecomposition/splitplane.h b/engine/inc/bullet/ConvexDecomposition/splitplane.h
new file mode 100644
index 00000000..12bc06a3
--- /dev/null
+++ b/engine/inc/bullet/ConvexDecomposition/splitplane.h
@@ -0,0 +1,55 @@
+#ifndef SPLIT_PLANE_H
+
+#define SPLIT_PLANE_H
+
+//** Computes an 'optimal' split plane for the supplied mesh.
+//** needs much improvement since it currently just splits along
+//** the longest side of the AABB.
+/*----------------------------------------------------------------------
+		Copyright (c) 2004 Open Dynamics Framework Group
+					www.physicstools.org
+		All rights reserved.
+
+		Redistribution and use in source and binary forms, with or without modification, are permitted provided
+		that the following conditions are met:
+
+		Redistributions of source code must retain the above copyright notice, this list of conditions
+		and the following disclaimer.
+
+		Redistributions in binary form must reproduce the above copyright notice,
+		this list of conditions and the following disclaimer in the documentation
+		and/or other materials provided with the distribution.
+
+		Neither the name of the Open Dynamics Framework Group nor the names of its contributors may
+		be used to endorse or promote products derived from this software without specific prior written permission.
+
+		THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+		INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+		DISCLAIMED. IN NO EVENT SHALL THE INTEL OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+		EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+		LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+		IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+		THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+-----------------------------------------------------------------------*/
+
+// http://codesuppository.blogspot.com
+//
+// mailto: jratcliff@infiniplex.net
+//
+// http://www.amillionpixels.us
+//
+
+namespace ConvexDecomposition
+{
+class ConvexDecompInterface;
+
+bool computeSplitPlane(unsigned int vcount,
+					   const float *vertices,
+					   unsigned int tcount,
+					   const unsigned int *indices,
+					   ConvexDecompInterface *callback,
+					   float *plane);
+
+}  // namespace ConvexDecomposition
+
+#endif
diff --git a/engine/inc/bullet/ConvexDecomposition/vlookup.h b/engine/inc/bullet/ConvexDecomposition/vlookup.h
new file mode 100644
index 00000000..8120def4
--- /dev/null
+++ b/engine/inc/bullet/ConvexDecomposition/vlookup.h
@@ -0,0 +1,115 @@
+#ifndef VLOOKUP_H
+
+#define VLOOKUP_H
+
+/*----------------------------------------------------------------------
+		Copyright (c) 2004 Open Dynamics Framework Group
+					www.physicstools.org
+		All rights reserved.
+
+		Redistribution and use in source and binary forms, with or without modification, are permitted provided
+		that the following conditions are met:
+
+		Redistributions of source code must retain the above copyright notice, this list of conditions
+		and the following disclaimer.
+
+		Redistributions in binary form must reproduce the above copyright notice,
+		this list of conditions and the following disclaimer in the documentation
+		and/or other materials provided with the distribution.
+
+		Neither the name of the Open Dynamics Framework Group nor the names of its contributors may
+		be used to endorse or promote products derived from this software without specific prior written permission.
+
+		THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+		INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+		DISCLAIMED. IN NO EVENT SHALL THE INTEL OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+		EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+		LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+		IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+		THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+-----------------------------------------------------------------------*/
+
+// http://codesuppository.blogspot.com
+//
+// mailto: jratcliff@infiniplex.net
+//
+// http://www.amillionpixels.us
+//
+
+// CodeSnippet provided by John W. Ratcliff
+// on March 23, 2006.
+//
+// mailto: jratcliff@infiniplex.net
+//
+// Personal website: http://jratcliffscarab.blogspot.com
+// Coding Website:   http://codesuppository.blogspot.com
+// FundRaising Blog: http://amillionpixels.blogspot.com
+// Fundraising site: http://www.amillionpixels.us
+// New Temple Site:  http://newtemple.blogspot.com
+//
+// This snippet shows how to 'hide' the complexity of
+// the STL by wrapping some useful piece of functionality
+// around a handful of discrete API calls.
+//
+// This API allows you to create an indexed triangle list
+// from a collection of raw input triangles.  Internally
+// it uses an STL set to build the lookup table very rapidly.
+//
+// Here is how you would use it to build an indexed triangle
+// list from a raw list of triangles.
+//
+// (1) create a 'VertexLookup' interface by calling
+//
+//     VertexLook vl = Vl_createVertexLookup();
+//
+// (2) For each vertice in each triangle call:
+//
+//     unsigned int i1 = Vl_getIndex(vl,p1);
+//     unsigned int i2 = Vl_getIndex(vl,p2);
+//     unsigned int i3 = Vl_getIndex(vl,p3);
+//
+//     save the 3 indices into your triangle list array.
+//
+// (3) Get the vertex array by calling:
+//
+//     const float *vertices = Vl_getVertices(vl);
+//
+// (4) Get the number of vertices so you can copy them into
+//     your own buffer.
+//     unsigned int vcount = Vl_getVcount(vl);
+//
+// (5) Release the VertexLookup interface when you are done with it.
+//     Vl_releaseVertexLookup(vl);
+//
+// Teaches the following lessons:
+//
+//    How to wrap the complexity of STL and C++ classes around a
+//    simple API interface.
+//
+//    How to use an STL set and custom comparator operator for
+//    a complex data type.
+//
+//    How to create a template class.
+//
+//    How to achieve significant performance improvements by
+//    taking advantage of built in STL containers in just
+//    a few lines of code.
+//
+//    You could easily modify this code to support other vertex
+//    formats with any number of interpolants.
+//
+//    Hide C++ classes from the rest of your application by
+//    keeping them in the CPP and wrapping them in a namespace
+// Uses an STL set to create an index table for a bunch of vertex positions
+// used typically to re-index a collection of raw triangle data.
+
+typedef void *VertexLookup;
+
+VertexLookup Vl_createVertexLookup(void);
+void Vl_releaseVertexLookup(VertexLookup vlook);
+
+unsigned int Vl_getIndex(VertexLookup vlook, const float *pos);  // get index.
+const float *Vl_getVertices(VertexLookup vlook);
+unsigned int Vl_getVcount(VertexLookup vlook);
+
+#endif
diff --git a/engine/inc/bullet/DeformableDemo/ClothFriction.h b/engine/inc/bullet/DeformableDemo/ClothFriction.h
new file mode 100644
index 00000000..228ec659
--- /dev/null
+++ b/engine/inc/bullet/DeformableDemo/ClothFriction.h
@@ -0,0 +1,19 @@
+/*
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef CLOTH_FRICTION_H
+#define CLOTH_FRICTION_H
+
+class CommonExampleInterface* ClothFrictionCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //CLOTH_FRICTION_H
diff --git a/engine/inc/bullet/DeformableDemo/Collide.h b/engine/inc/bullet/DeformableDemo/Collide.h
new file mode 100644
index 00000000..97a432e5
--- /dev/null
+++ b/engine/inc/bullet/DeformableDemo/Collide.h
@@ -0,0 +1,19 @@
+/*
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef _COLLIDE_H
+#define _COLLIDE_H
+
+class CommonExampleInterface* CollideCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //_COLLIDE_H
diff --git a/engine/inc/bullet/DeformableDemo/DeformableClothAnchor.h b/engine/inc/bullet/DeformableDemo/DeformableClothAnchor.h
new file mode 100644
index 00000000..4e838864
--- /dev/null
+++ b/engine/inc/bullet/DeformableDemo/DeformableClothAnchor.h
@@ -0,0 +1,19 @@
+/*
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef DEFORMABLE_CLOTH_ANCHOR_H
+#define DEFORMABLE_CLOTH_ANCHOR_H
+
+class CommonExampleInterface* DeformableClothAnchorCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //DEFORMABLE_CLOTH_ANCHOR_H
diff --git a/engine/inc/bullet/DeformableDemo/DeformableContact.h b/engine/inc/bullet/DeformableDemo/DeformableContact.h
new file mode 100644
index 00000000..1e1fe567
--- /dev/null
+++ b/engine/inc/bullet/DeformableDemo/DeformableContact.h
@@ -0,0 +1,19 @@
+/*
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef DEFORMABLE_CONTACT_H
+#define DEFORMABLE_CONTACT_H
+
+class CommonExampleInterface* DeformableContactCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //_DEFORMABLE_CONTACT_H
diff --git a/engine/inc/bullet/DeformableDemo/DeformableMultibody.h b/engine/inc/bullet/DeformableDemo/DeformableMultibody.h
new file mode 100644
index 00000000..acd9d421
--- /dev/null
+++ b/engine/inc/bullet/DeformableDemo/DeformableMultibody.h
@@ -0,0 +1,19 @@
+/*
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef _DEFORMABLE_MULTIBODY_H
+#define _DEFORMABLE_MULTIBODY_H
+
+class CommonExampleInterface* DeformableMultibodyCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //_DEFORMABLE_MULTIBODY_H
diff --git a/engine/inc/bullet/DeformableDemo/DeformableRigid.h b/engine/inc/bullet/DeformableDemo/DeformableRigid.h
new file mode 100644
index 00000000..0d0e0dc5
--- /dev/null
+++ b/engine/inc/bullet/DeformableDemo/DeformableRigid.h
@@ -0,0 +1,19 @@
+/*
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef _DEFORMABLE_RIGID_H
+#define _DEFORMABLE_RIGID_H
+
+class CommonExampleInterface* DeformableRigidCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //_DEFORMABLE_RIGID_H
diff --git a/engine/inc/bullet/DeformableDemo/DeformableSelfCollision.h b/engine/inc/bullet/DeformableDemo/DeformableSelfCollision.h
new file mode 100644
index 00000000..36359c0d
--- /dev/null
+++ b/engine/inc/bullet/DeformableDemo/DeformableSelfCollision.h
@@ -0,0 +1,19 @@
+/*
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef DEFORMABLE_SELF_COLLISION_H
+#define DEFORMABLE_SELF_COLLISION_H
+
+class CommonExampleInterface* DeformableSelfCollisionCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //_DEFORMABLE_SELF_COLLISION_H
diff --git a/engine/inc/bullet/DeformableDemo/GraspDeformable.h b/engine/inc/bullet/DeformableDemo/GraspDeformable.h
new file mode 100644
index 00000000..1ce2230d
--- /dev/null
+++ b/engine/inc/bullet/DeformableDemo/GraspDeformable.h
@@ -0,0 +1,19 @@
+/*
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef _GRASP_DEFORMABLE_H
+#define _GRASP_DEFORMABLE_H
+
+class CommonExampleInterface* GraspDeformableCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //_GRASP_DEFORMABLE_H
diff --git a/engine/inc/bullet/DeformableDemo/LargeDeformation.h b/engine/inc/bullet/DeformableDemo/LargeDeformation.h
new file mode 100644
index 00000000..bb68082f
--- /dev/null
+++ b/engine/inc/bullet/DeformableDemo/LargeDeformation.h
@@ -0,0 +1,19 @@
+/*
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef _LARGE_DEFORMATION_H
+#define _LARGE_DEFORMATION_H
+
+class CommonExampleInterface* LargeDeformationCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //_LARGE_DEFORMATION_H
diff --git a/engine/inc/bullet/DeformableDemo/MultibodyClothAnchor.h b/engine/inc/bullet/DeformableDemo/MultibodyClothAnchor.h
new file mode 100644
index 00000000..818e043c
--- /dev/null
+++ b/engine/inc/bullet/DeformableDemo/MultibodyClothAnchor.h
@@ -0,0 +1,19 @@
+/*
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef MULTIBODY_CLOTH_ANCHOR_H
+#define MULTIBODY_CLOTH_ANCHOR_H
+
+class CommonExampleInterface* MultibodyClothAnchorCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //MULTIBODY_CLOTH_ANCHOR_H
diff --git a/engine/inc/bullet/DeformableDemo/Pinch.h b/engine/inc/bullet/DeformableDemo/Pinch.h
new file mode 100644
index 00000000..1616ec39
--- /dev/null
+++ b/engine/inc/bullet/DeformableDemo/Pinch.h
@@ -0,0 +1,19 @@
+/*
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef _PINCH_H
+#define _PINCH_H
+
+class CommonExampleInterface* PinchCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //_PINCH_H
diff --git a/engine/inc/bullet/DeformableDemo/PinchFriction.h b/engine/inc/bullet/DeformableDemo/PinchFriction.h
new file mode 100644
index 00000000..b397ba34
--- /dev/null
+++ b/engine/inc/bullet/DeformableDemo/PinchFriction.h
@@ -0,0 +1,19 @@
+/*
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef _PINCH_FRICTION_H
+#define _PINCH_FRICTION_H
+
+class CommonExampleInterface* PinchFrictionCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //_PINCH_FRICTION_H
diff --git a/engine/inc/bullet/DeformableDemo/SplitImpulse.h b/engine/inc/bullet/DeformableDemo/SplitImpulse.h
new file mode 100644
index 00000000..441f9106
--- /dev/null
+++ b/engine/inc/bullet/DeformableDemo/SplitImpulse.h
@@ -0,0 +1,19 @@
+/*
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef _SPLIT_IMPULSE_H
+#define _SPLIT_IMPULSE_H
+
+class CommonExampleInterface* SplitImpulseCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //_SPLIT_IMPULSE_H
diff --git a/engine/inc/bullet/DeformableDemo/VolumetricDeformable.h b/engine/inc/bullet/DeformableDemo/VolumetricDeformable.h
new file mode 100644
index 00000000..fe5d326a
--- /dev/null
+++ b/engine/inc/bullet/DeformableDemo/VolumetricDeformable.h
@@ -0,0 +1,19 @@
+/*
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef _VOLUMETRIC_DEFORMABLE_H
+#define _VOLUMETRIC_DEFORMABLE_H
+
+class CommonExampleInterface* VolumetricDeformableCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //_VOLUMETRIC_DEFORMABLE__H
diff --git a/engine/inc/bullet/DynamicControlDemo/MotorDemo.h b/engine/inc/bullet/DynamicControlDemo/MotorDemo.h
new file mode 100644
index 00000000..1389224c
--- /dev/null
+++ b/engine/inc/bullet/DynamicControlDemo/MotorDemo.h
@@ -0,0 +1,21 @@
+/*
+Bullet Continuous Collision Detection and Physics Library Copyright (c) 2007 Erwin Coumans
+Motor Demo
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef MOTORDEMO_H
+#define MOTORDEMO_H
+
+class CommonExampleInterface* MotorControlCreateFunc(struct CommonExampleOptions& options);
+
+#endif
diff --git a/engine/inc/bullet/Evolution/NN3DWalkers.h b/engine/inc/bullet/Evolution/NN3DWalkers.h
new file mode 100644
index 00000000..26a7bf81
--- /dev/null
+++ b/engine/inc/bullet/Evolution/NN3DWalkers.h
@@ -0,0 +1,21 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2015 Google Inc. http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef ET_NN_3D_WALKERS_EXAMPLE_H
+#define ET_NN_3D_WALKERS_EXAMPLE_H
+
+class CommonExampleInterface* ET_NN3DWalkersCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //ET_NN_3D_WALKERS_EXAMPLE_H
diff --git a/engine/inc/bullet/Evolution/NN3DWalkersTimeWarpBase.h b/engine/inc/bullet/Evolution/NN3DWalkersTimeWarpBase.h
new file mode 100644
index 00000000..deef1147
--- /dev/null
+++ b/engine/inc/bullet/Evolution/NN3DWalkersTimeWarpBase.h
@@ -0,0 +1,950 @@
+/*
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2015 Google Inc. http://bulletphysics.org
+
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef NN3D_WALKERS_TIME_WARP_BASE_H
+#define NN3D_WALKERS_TIME_WARP_BASE_H
+
+#include "btBulletDynamicsCommon.h"
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btAlignedObjectArray.h"
+#include "LinearMath/btQuickprof.h"  // Use your own timer, this timer is only used as we lack another timer
+
+#include "../CommonInterfaces/CommonRigidBodyBase.h"
+#include "../CommonInterfaces/CommonParameterInterface.h"
+
+//Solvers
+#include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h"
+#include "BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.h"
+#include "BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h"
+#include "BulletDynamics/Featherstone/btMultiBodyDynamicsWorld.h"
+#include "BulletDynamics/MLCPSolvers/btDantzigSolver.h"
+#include "BulletDynamics/MLCPSolvers/btSolveProjectedGaussSeidel.h"
+#include "BulletDynamics/MLCPSolvers/btLemkeSolver.h"
+#include "BulletDynamics/MLCPSolvers/btMLCPSolver.h"
+
+#include "../Utils/b3ERPCFMHelper.hpp"  // ERP/CFM setting utils
+
+static btScalar gSimulationSpeed = 1;  // default simulation speed at startup
+
+// the current simulation speeds to choose from (the slider will snap to those using a custom form of snapping)
+namespace SimulationSpeeds
+{
+static double /*0*/ PAUSE = 0;
+static double /*1*/ QUARTER_SPEED = 0.25;
+static double /*2*/ HALF_SPEED = 0.5;
+static double /*3*/ NORMAL_SPEED = 1;
+static double /*4*/ DOUBLE_SPEED = 2;
+static double /*5*/ QUADRUPLE_SPEED = 4;
+static double /*6*/ DECUPLE_SPEED = 10;
+static double /*7*/ CENTUPLE_SPEED = 100;
+static double /*8*/ QUINCENTUPLE_SPEED = 500;
+static double /*9*/ MILLITUPLE_SPEED = 1000;
+static double /*0*/ MAX_SPEED = MILLITUPLE_SPEED;
+static double /**/ NUM_SPEEDS = 10;
+};  // namespace SimulationSpeeds
+
+// add speeds from the namespace here
+static double speeds[] = {
+	SimulationSpeeds::PAUSE,
+	SimulationSpeeds::QUARTER_SPEED, SimulationSpeeds::HALF_SPEED,
+	SimulationSpeeds::NORMAL_SPEED, SimulationSpeeds::DOUBLE_SPEED,
+	SimulationSpeeds::QUADRUPLE_SPEED, SimulationSpeeds::DECUPLE_SPEED,
+	SimulationSpeeds::CENTUPLE_SPEED, SimulationSpeeds::QUINCENTUPLE_SPEED,
+	SimulationSpeeds::MILLITUPLE_SPEED};
+
+static btScalar gSolverIterations = 10;  // default number of solver iterations for the iterative solvers
+
+static bool gIsHeadless = false;  // demo runs with graphics by default
+
+static bool gChangeErpCfm = false;  // flag to make recalculation of ERP/CFM
+
+static int gMinSpeed = SimulationSpeeds::PAUSE;  // the minimum simulation speed
+
+static int gMaxSpeed = SimulationSpeeds::MAX_SPEED;  // the maximum simulation speed
+
+static bool gMaximumSpeed = false;  // the demo does not try to achieve maximum stepping speed by default
+
+static bool gInterpolate = false;  // the demo does not use any bullet interpolated physics substeps
+
+static bool useSplitImpulse = true;  // split impulse fixes issues with restitution in Baumgarte stabilization
+// http://bulletphysics.org/Bullet/phpBB3/viewtopic.php?f=9&t=7117&p=24631&hilit=Baumgarte#p24631
+// disabling continuous collision detection can also fix issues with restitution, though CCD is disabled by default an only kicks in at higher speeds
+// set CCD speed threshold and testing sphere radius per rigidbody (rb->setCCDSpeedThreshold())
+
+// all supported solvers by bullet
+enum SolverEnumType
+{
+	SEQUENTIALIMPULSESOLVER = 0,
+	GAUSSSEIDELSOLVER = 1,
+	NNCGSOLVER = 2,
+	DANZIGSOLVER = 3,
+	LEMKESOLVER = 4,
+	
+	NUM_SOLVERS = 6
+};
+
+// solvers can be changed by drop down menu
+namespace SolverType
+{
+static char SEQUENTIALIMPULSESOLVER[] = "Sequential Impulse Solver";
+static char GAUSSSEIDELSOLVER[] = "Gauss-Seidel Solver";
+static char NNCGSOLVER[] = "NNCG Solver";
+static char DANZIGSOLVER[] = "Danzig Solver";
+static char LEMKESOLVER[] = "Lemke Solver";
+
+};  // namespace SolverType
+
+static const char* solverTypes[NUM_SOLVERS];
+
+static SolverEnumType SOLVER_TYPE = SEQUENTIALIMPULSESOLVER;  // You can switch the solver here
+
+//TODO:s===
+//TODO: Give specific explanations about solver values
+
+/**
+ * Step size of the bullet physics simulator (solverAccuracy). Accuracy versus speed.
+ */
+// Choose an appropriate number of steps per second for your needs
+static btScalar gPhysicsStepsPerSecond = 60.0f;  // Default number of steps
+//static btScalar gPhysicsStepsPerSecond = 120.0f; // Double steps for more accuracy
+//static btScalar gPhysicsStepsPerSecond = 240.0f; // For high accuracy
+//static btScalar gPhysicsStepsPerSecond = 1000.0f; // Very high accuracy
+
+// appropriate inverses for seconds and milliseconds
+static double fixedPhysicsStepSizeSec = 1.0f / gPhysicsStepsPerSecond;       // steps size in seconds
+static double fixedPhysicsStepSizeMilli = 1000.0f / gPhysicsStepsPerSecond;  // step size in milliseconds
+
+static btScalar gApplicationFrequency = 60.0f;                  // number of internal application ticks per second
+static int gApplicationTick = 1000.0f / gApplicationFrequency;  //ms
+
+static btScalar gFramesPerSecond = 30.0f;  // number of frames per second
+
+static btScalar gERPSpringK = 10;
+static btScalar gERPDamperC = 1;
+
+static btScalar gCFMSpringK = 10;
+static btScalar gCFMDamperC = 1;
+static btScalar gCFMSingularityAvoidance = 0;
+
+//GUI related parameter changing helpers
+
+inline void twxChangePhysicsStepsPerSecond(float physicsStepsPerSecond, void*)
+{  // function to change simulation physics steps per second
+	gPhysicsStepsPerSecond = physicsStepsPerSecond;
+}
+
+inline void twxChangeFPS(float framesPerSecond, void*)
+{
+	gFramesPerSecond = framesPerSecond;
+}
+
+inline void twxChangeERPCFM(float notUsed, void*)
+{  // function to change ERP/CFM appropriately
+	gChangeErpCfm = true;
+}
+
+inline void changeSolver(int comboboxId, const char* item, void* userPointer)
+{  // function to change the solver
+	for (int i = 0; i < NUM_SOLVERS; i++)
+	{
+		if (strcmp(solverTypes[i], item) == 0)
+		{  // if the strings are equal
+			SOLVER_TYPE = ((SolverEnumType)i);
+			b3Printf("=%s=\n Reset the simulation by double clicking it in the menu list.", item);
+			return;
+		}
+	}
+	b3Printf("No Change");
+}
+
+inline void twxChangeSolverIterations(float notUsed, void* userPtr)
+{  // change the solver iterations
+}
+
+inline void clampToCustomSpeedNotches(float speed, void*)
+{  // function to clamp to custom speed notches
+	double minSpeed = 0;
+	double minSpeedDist = SimulationSpeeds::MAX_SPEED;
+	for (int i = 0; i < SimulationSpeeds::NUM_SPEEDS; i++)
+	{
+		double speedDist = (speeds[i] - speed >= 0) ? speeds[i] - speed : speed - speeds[i];  // float absolute
+
+		if (minSpeedDist > speedDist)
+		{
+			minSpeedDist = speedDist;
+			minSpeed = speeds[i];
+		}
+	}
+	gSimulationSpeed = minSpeed;
+}
+
+inline void switchInterpolated(int buttonId, bool buttonState, void* userPointer)
+{  // toggle if interpolation steps are taken
+	gInterpolate = !gInterpolate;
+	//	b3Printf("Interpolate substeps %s", gInterpolate?"on":"off");
+}
+
+inline void switchHeadless(int buttonId, bool buttonState, void* userPointer)
+{  // toggle if the demo should run headless
+	gIsHeadless = !gIsHeadless;
+	//	b3Printf("Run headless %s", gIsHeadless?"on":"off");
+}
+
+inline void switchMaximumSpeed(int buttonId, bool buttonState, void* userPointer)
+{   // toggle it the demo should run as fast as possible
+	//	b3Printf("Run maximum speed %s", gMaximumSpeed?"on":"off");
+}
+
+inline void setApplicationTick(float frequency, void*)
+{  // set internal application tick
+	gApplicationTick = 1000.0f / frequency;
+}
+
+/**
+ * @link: Gaffer on Games - Fix your timestep: http://gafferongames.com/game-physics/fix-your-timestep/
+ */
+struct NN3DWalkersTimeWarpBase : public CommonRigidBodyBase
+{
+	NN3DWalkersTimeWarpBase(struct GUIHelperInterface* helper) : CommonRigidBodyBase(helper),
+																 mPhysicsStepsPerSecondUpdated(false),
+																 mFramesPerSecondUpdated(false),
+																 mSolverIterationsUpdated(false)
+	{
+		// main frame timer initialization
+		mApplicationStart = mLoopTimer.getTimeMilliseconds(); /**!< Initialize when the application started running */
+		mInputClock = mApplicationStart;                      /**!< Initialize the last time the input was updated */
+		mPreviousModelIteration = mApplicationStart;
+		mThisModelIteration = mApplicationStart;
+		mApplicationRuntime = mThisModelIteration - mApplicationStart; /**!< Initialize the application runtime */
+
+		// sub frame time initializations
+		mGraphicsStart = mApplicationStart; /** !< Initialize the last graphics start */
+		mModelStart = mApplicationStart;    /** !< Initialize the last model start */
+		mInputStart = mApplicationStart;    /** !< Initialize the last input start */
+
+		mPhysicsStepStart = mApplicationStart; /**!< Initialize the physics step start */
+		mPhysicsStepEnd = mApplicationStart;   /**!< Initialize the physics step end */
+
+		//durations
+		mLastGraphicsTick = 0;
+		mLastModelTick = 0;
+		mLastInputTick = 0;
+		mPhysicsTick = 0;
+
+		mInputDt = 0;
+		mModelAccumulator = 0;
+		mFrameTime = 0;
+
+		fpsTimeStamp = mLoopTimer.getTimeMilliseconds();  // to time the fps
+		fpsStep = 1000.0f / gFramesPerSecond;
+
+		// performance measurements for this demo
+		performanceTimestamp = 0;
+		performedTime = 0;                                    // time the physics steps consumed
+		speedUpPrintTimeStamp = mLoopTimer.getTimeSeconds();  // timer to print the speed up periodically
+		mLoopTimer.reset();
+	}
+
+	~NN3DWalkersTimeWarpBase()
+	{
+	}
+
+	void initPhysics()
+	{  // initialize the demo
+
+		setupBasicParamInterface();  // setup adjustable sliders and buttons for parameters
+
+		m_guiHelper->setUpAxis(1);  // Set Y axis as Up axis
+
+		createEmptyDynamicsWorld();  // create an empty dynamic world
+
+		m_guiHelper->autogenerateGraphicsObjects(m_dynamicsWorld);
+	}
+
+	void setupBasicParamInterface()
+	{  // setup the adjustable sliders and button for parameters
+
+		{  // create a slider to adjust the simulation speed
+			// Force increase the simulation speed to run the simulation with the same accuracy but a higher speed
+			SliderParams slider("Simulation speed",
+								&gSimulationSpeed);
+			slider.m_minVal = gMinSpeed;
+			slider.m_maxVal = gMaxSpeed;
+			slider.m_callback = clampToCustomSpeedNotches;
+			slider.m_clampToNotches = false;
+			if (m_guiHelper->getParameterInterface())
+				m_guiHelper->getParameterInterface()->registerSliderFloatParameter(
+					slider);
+		}
+
+		{  // create a button to switch to headless simulation
+			// This turns off the graphics update and therefore results in more time for the model update
+			ButtonParams button("Run headless", 0, true);
+			button.m_callback = switchHeadless;
+			if (m_guiHelper->getParameterInterface())
+				m_guiHelper->getParameterInterface()->registerButtonParameter(
+					button);
+		}
+
+		{  // create a button to switch to maximum speed simulation (fully deterministic)
+			// Interesting to test the maximal achievable speed on this hardware
+			ButtonParams button("Run maximum speed", 0, true);
+			button.m_callback = switchMaximumSpeed;
+			if (m_guiHelper->getParameterInterface())
+				m_guiHelper->getParameterInterface()->registerButtonParameter(
+					button);
+		}
+
+		{  // create a button to switch bullet to perform interpolated substeps to speed up simulation
+			// generally, interpolated steps are a good speed-up and should only be avoided if higher accuracy is needed (research purposes etc.)
+			ButtonParams button("Perform interpolated substeps", 0, true);
+			button.m_callback = switchInterpolated;
+			if (m_guiHelper->getParameterInterface())
+				m_guiHelper->getParameterInterface()->registerButtonParameter(
+					button);
+		}
+	}
+
+	void setupAdvancedParamInterface()
+	{
+		solverTypes[0] = SolverType::SEQUENTIALIMPULSESOLVER;
+		solverTypes[1] = SolverType::GAUSSSEIDELSOLVER;
+		solverTypes[2] = SolverType::NNCGSOLVER;
+		solverTypes[3] = SolverType::DANZIGSOLVER;
+		solverTypes[4] = SolverType::LEMKESOLVER;
+		
+
+		{
+			ComboBoxParams comboParams;
+			comboParams.m_comboboxId = 0;
+			comboParams.m_numItems = NUM_SOLVERS;
+			comboParams.m_startItem = SOLVER_TYPE;
+			comboParams.m_callback = changeSolver;
+
+			comboParams.m_items = solverTypes;
+			m_guiHelper->getParameterInterface()->registerComboBox(comboParams);
+		}
+
+		{  // create a slider to adjust the number of internal application ticks
+			// The set application tick should contain enough time to perform a full cycle of model update (physics and input)
+			// and view update (graphics) with average application load. The graphics and input update determine the remaining time
+			// for the physics update
+			SliderParams slider("Application Ticks",
+								&gApplicationFrequency);
+			slider.m_minVal = gMinSpeed;
+			slider.m_maxVal = gMaxSpeed;
+			slider.m_callback = setApplicationTick;
+			slider.m_clampToNotches = false;
+			if (m_guiHelper->getParameterInterface())
+				m_guiHelper->getParameterInterface()->registerSliderFloatParameter(
+					slider);
+		}
+
+		{  // create a slider to adjust the number of physics steps per second
+			// The default number of steps is at 60, which is appropriate for most general simulations
+			// For simulations with higher complexity or if you experience undesired behavior, try increasing the number of steps per second
+			// Alternatively, try increasing the number of solver iterations if you experience jittering constraints due to non-converging solutions
+			SliderParams slider("Physics steps per second", &gPhysicsStepsPerSecond);
+			slider.m_minVal = 0;
+			slider.m_maxVal = 1000;
+			slider.m_callback = twxChangePhysicsStepsPerSecond;
+			slider.m_clampToNotches = false;
+			if (m_guiHelper->getParameterInterface())
+				m_guiHelper->getParameterInterface()->registerSliderFloatParameter(
+					slider);
+		}
+
+		{  // create a slider to adjust the number of frames per second
+			SliderParams slider("Frames per second", &gFramesPerSecond);
+			slider.m_minVal = 0;
+			slider.m_maxVal = 200;
+			slider.m_callback = twxChangeFPS;
+			slider.m_clampToNotches = false;
+			if (m_guiHelper->getParameterInterface())
+				m_guiHelper->getParameterInterface()->registerSliderFloatParameter(
+					slider);
+		}
+
+		{  // create a slider to adjust the number of solver iterations to converge to a solution
+			// more complex simulations might need a higher number of iterations to converge, it also
+			// depends on the type of solver.
+			SliderParams slider(
+				"Solver interations",
+				&gSolverIterations);
+			slider.m_minVal = 0;
+			slider.m_maxVal = 1000;
+			slider.m_callback = twxChangePhysicsStepsPerSecond;
+			slider.m_clampToIntegers = true;
+			m_guiHelper->getParameterInterface()->registerSliderFloatParameter(
+				slider);
+		}
+
+		// ERP/CFM sliders
+		// Advanced users: Check descriptions of ERP/CFM in BulletUtils.cpp
+
+		{  // create a slider to adjust ERP Spring k constant
+			SliderParams slider("Global ERP Spring k (F=k*x)", &gERPSpringK);
+			slider.m_minVal = 0;
+			slider.m_maxVal = 10;
+			slider.m_callback = twxChangeERPCFM;
+			slider.m_clampToNotches = false;
+			if (m_guiHelper->getParameterInterface())
+				m_guiHelper->getParameterInterface()->registerSliderFloatParameter(
+					slider);
+		}
+
+		{  // create a slider to adjust ERP damper c constant
+			SliderParams slider("Global ERP damper c (F=c*xdot)", &gERPDamperC);
+			slider.m_minVal = 0;
+			slider.m_maxVal = 10;
+			slider.m_callback = twxChangeERPCFM;
+			slider.m_clampToNotches = false;
+			if (m_guiHelper->getParameterInterface())
+				m_guiHelper->getParameterInterface()->registerSliderFloatParameter(
+					slider);
+		}
+
+		{  // create a slider to adjust CFM Spring k constant
+			SliderParams slider("Global CFM Spring k (F=k*x)", &gCFMSpringK);
+			slider.m_minVal = 0;
+			slider.m_maxVal = 10;
+			slider.m_callback = twxChangeERPCFM;
+			slider.m_clampToNotches = false;
+			if (m_guiHelper->getParameterInterface())
+				m_guiHelper->getParameterInterface()->registerSliderFloatParameter(
+					slider);
+		}
+
+		{  // create a slider to adjust CFM damper c constant
+			SliderParams slider("Global CFM damper c (F=c*xdot)", &gCFMDamperC);
+			slider.m_minVal = 0;
+			slider.m_maxVal = 10;
+			slider.m_callback = twxChangeERPCFM;
+			slider.m_clampToNotches = false;
+			if (m_guiHelper->getParameterInterface())
+				m_guiHelper->getParameterInterface()->registerSliderFloatParameter(
+					slider);
+		}
+
+		{  // create a slider to adjust CFM damper c constant
+			SliderParams slider("Global CFM singularity avoidance", &gCFMSingularityAvoidance);
+			slider.m_minVal = 0;
+			slider.m_maxVal = 10;
+			slider.m_callback = twxChangeERPCFM;
+			slider.m_clampToNotches = false;
+			if (m_guiHelper->getParameterInterface())
+				m_guiHelper->getParameterInterface()->registerSliderFloatParameter(
+					slider);
+		}
+	}
+
+	void createEmptyDynamicsWorld()
+	{  // create an empty dynamics worlds according to the chosen settings via statics (top section of code)
+
+		///collision configuration contains default setup for memory, collision setup
+		m_collisionConfiguration = new btDefaultCollisionConfiguration();
+		//m_collisionConfiguration->setConvexConvexMultipointIterations();
+
+		///use the default collision dispatcher. For parallel processing you can use a diffent dispatcher (see Extras/BulletMultiThreaded)
+		m_dispatcher = new btCollisionDispatcher(m_collisionConfiguration);
+
+		// default broadphase
+		m_broadphase = new btDbvtBroadphase();
+
+		// different solvers require different settings
+		switch (SOLVER_TYPE)
+		{
+			case SEQUENTIALIMPULSESOLVER:
+			{
+				//			b3Printf("=%s=",SolverType::SEQUENTIALIMPULSESOLVER);
+				m_solver = new btSequentialImpulseConstraintSolver();
+				break;
+			}
+			case NNCGSOLVER:
+			{
+				//			b3Printf("=%s=",SolverType::NNCGSOLVER);
+				m_solver = new btNNCGConstraintSolver();
+				break;
+			}
+			case DANZIGSOLVER:
+			{
+				//			b3Printf("=%s=",SolverType::DANZIGSOLVER);
+				btDantzigSolver* mlcp = new btDantzigSolver();
+				m_solver = new btMLCPSolver(mlcp);
+				break;
+			}
+			case GAUSSSEIDELSOLVER:
+			{
+				//			b3Printf("=%s=",SolverType::GAUSSSEIDELSOLVER);
+				btSolveProjectedGaussSeidel* mlcp = new btSolveProjectedGaussSeidel();
+				m_solver = new btMLCPSolver(mlcp);
+				break;
+			}
+			case LEMKESOLVER:
+			{
+				//			b3Printf("=%s=",SolverType::LEMKESOLVER);
+				btLemkeSolver* mlcp = new btLemkeSolver();
+				m_solver = new btMLCPSolver(mlcp);
+				break;
+			}
+			
+			default:
+				break;
+		}
+
+		if (1)
+		{
+			//TODO: Set parameters for other solvers
+
+			m_dynamicsWorld = new btDiscreteDynamicsWorld(m_dispatcher,
+														  m_broadphase, m_solver, m_collisionConfiguration);
+
+			if (SOLVER_TYPE == DANZIGSOLVER || SOLVER_TYPE == GAUSSSEIDELSOLVER)
+			{
+				m_dynamicsWorld->getSolverInfo().m_minimumSolverBatchSize = 1;  //for mlcp solver it is better to have a small A matrix
+			}
+			else
+			{
+				m_dynamicsWorld->getSolverInfo().m_minimumSolverBatchSize = 128;  //for direct solver, it is better to solve multiple objects together, small batches have high overhead
+			}
+
+			m_dynamicsWorld->getDispatchInfo().m_useContinuous = true;  // set continuous collision
+		}
+		else
+		{
+			//use btMultiBodyDynamicsWorld for Featherstone btMultiBody support
+			m_dynamicsWorld = new btMultiBodyDynamicsWorld(m_dispatcher,
+														   m_broadphase, (btMultiBodyConstraintSolver*)m_solver,
+														   m_collisionConfiguration);
+		}
+
+		changeERPCFM();  // set appropriate ERP/CFM values according to the string and damper properties of the constraint
+
+		if (useSplitImpulse)
+		{                                                         // If you experience strong repulsion forces in your constraints, it might help to enable the split impulse feature
+			m_dynamicsWorld->getSolverInfo().m_splitImpulse = 1;  //enable split impulse feature
+																  //		m_dynamicsWorld->getSolverInfo().m_splitImpulsePenetrationThreshold =
+																  //			-0.02;
+																  //		m_dynamicsWorld->getSolverInfo().m_erp2 = BulletUtils::getERP(
+																  //			fixedPhysicsStepSizeSec, 10, 1);
+																  //		m_dynamicsWorld->getSolverInfo().m_splitImpulseTurnErp =
+																  //			BulletUtils::getERP(fixedPhysicsStepSizeSec, 10, 1);
+																  //			b3Printf("Using split impulse feature with ERP/TurnERP: (%f,%f)",
+																  //				m_dynamicsWorld->getSolverInfo().m_erp2,
+																  //				m_dynamicsWorld->getSolverInfo().m_splitImpulseTurnErp);
+		}
+
+		m_dynamicsWorld->getSolverInfo().m_numIterations = gSolverIterations;  // set the number of solver iterations for iteration based solvers
+
+		m_dynamicsWorld->setGravity(btVector3(0, -9.81f, 0));  // set gravity to -9.81
+	}
+
+	btScalar calculatePerformedSpeedup()
+	{  // calculate performed speedup
+		// we calculate the performed speed up
+		btScalar speedUp = ((double)performedTime * 1000.0) / ((double)(mLoopTimer.getTimeMilliseconds() - performanceTimestamp));
+		//		b3Printf("Avg Effective speedup: %f",speedUp);
+		performedTime = 0;
+		performanceTimestamp = mLoopTimer.getTimeMilliseconds();
+		return speedUp;
+	}
+
+	void timeWarpSimulation(float deltaTime)  // Override this
+	{
+	}
+
+	void stepSimulation(float deltaTime)
+	{  // customly step the simulation
+		do
+		{
+			//			// settings
+			if (mPhysicsStepsPerSecondUpdated)
+			{
+				changePhysicsStepsPerSecond(gPhysicsStepsPerSecond);
+				mPhysicsStepsPerSecondUpdated = false;
+			}
+
+			if (mFramesPerSecondUpdated)
+			{
+				changeFPS(gFramesPerSecond);
+				mFramesPerSecondUpdated = false;
+			}
+
+			if (gChangeErpCfm)
+			{
+				changeERPCFM();
+				gChangeErpCfm = false;
+			}
+
+			if (mSolverIterationsUpdated)
+			{
+				changeSolverIterations(gSolverIterations);
+				mSolverIterationsUpdated = false;
+			}
+
+			// structure according to the canonical game loop
+			// http://www.bulletphysics.org/mediawiki-1.5.8/index.php/Canonical_Game_Loop
+
+			//##############
+			// breaking conditions - if the loop should stop, then check it here
+
+			//#############
+			// model update - here you perform updates of your model, be it the physics model, the game or simulation state or anything not related to graphics and input
+
+			timeWarpSimulation(deltaTime);
+			if (mLoopTimer.getTimeSeconds() - speedUpPrintTimeStamp > 1)
+			{
+				// on reset, we calculate the performed speed up
+				//double speedUp = ((double)performedTime*1000.0)/((double)(mLoopTimer.getTimeMilliseconds()-performanceTimestamp));
+				//				b3Printf("Avg Effective speedup: %f",speedUp);
+				performedTime = 0;
+				performanceTimestamp = mLoopTimer.getTimeMilliseconds();
+				speedUpPrintTimeStamp = mLoopTimer.getTimeSeconds();
+			}
+
+			// update timers
+			mThisModelIteration = mLoopTimer.getTimeMilliseconds();
+			mFrameTime = mThisModelIteration - mPreviousModelIteration; /**!< Calculate the frame time (in Milliseconds) */
+			mPreviousModelIteration = mThisModelIteration;
+
+			//	b3Printf("Current Frame time: % u", mFrameTime);
+
+			mApplicationRuntime = mThisModelIteration - mApplicationStart; /**!< Update main frame timer (in Milliseconds) */
+
+			mModelStart = mLoopTimer.getTimeMilliseconds();   /**!< Begin with the model update (in Milliseconds)*/
+			mLastGraphicsTick = mModelStart - mGraphicsStart; /**!< Update graphics timer (in Milliseconds) */
+
+			if (gMaximumSpeed /** If maximum speed is enabled*/)
+			{
+				performMaxStep();
+			}
+			else
+			{ /**!< This mode tries to progress as much time as it is expected from the game loop*/
+				performSpeedStep();
+			}
+
+			mInputStart = mLoopTimer.getTimeMilliseconds(); /**!< Start the input update */
+			mLastModelTick = mInputStart - mModelStart;     /**!< Calculate the time the model update took */
+
+			//#############
+			// Input update - Game Clock part of the loop
+			/** This runs once every gApplicationTick milliseconds on average */
+			mInputDt = mThisModelIteration - mInputClock;
+			if (mInputDt >= gApplicationTick)
+			{
+				mInputClock = mThisModelIteration;
+				//	         mInputHandler.injectInput(); /**!< Inject input into handlers */
+				//	         mInputHandler.update(mInputClock); /**!< update elements that work on the current input state */
+			}
+
+			mGraphicsStart = mLoopTimer.getTimeMilliseconds(); /**!< Start the graphics update */
+			mLastInputTick = mGraphicsStart - mInputStart;     /**!< Calculate the time the input injection took */
+
+			//#############
+			// Graphics update - Here you perform the representation of your model, meaning graphics rendering according to what your game or simulation model describes
+			// In the example browser, there is a separate method called renderScene() for this
+
+			// Uncomment this for some detailed output about the application ticks
+			//	b3Printf(
+			//		"Physics time: %u milliseconds / Graphics time: %u milliseconds / Input time: %u milliseconds / Total time passed: %u milliseconds",
+			//		mLastModelTick, mLastGraphicsTick, mLastInputTick, mApplicationRuntime);
+
+		} while (mLoopTimer.getTimeMilliseconds() - fpsTimeStamp < fpsStep);  // escape the loop if it is time to render
+		// Unfortunately, the input is not included in the loop, therefore the input update frequency is equal to the fps
+
+		fpsTimeStamp = mLoopTimer.getTimeMilliseconds();
+	}
+
+	virtual bool keyboardCallback(int key, int state)
+	{
+		switch (key)
+		{
+			case '1':
+			{
+				gSimulationSpeed = SimulationSpeeds::QUARTER_SPEED;
+				gMaximumSpeed = false;
+				return true;
+			}
+			case '2':
+			{
+				gSimulationSpeed = SimulationSpeeds::HALF_SPEED;
+				gMaximumSpeed = false;
+				return true;
+			}
+			case '3':
+			{
+				gSimulationSpeed = SimulationSpeeds::NORMAL_SPEED;
+				gMaximumSpeed = false;
+				return true;
+			}
+			case '4':
+			{
+				gSimulationSpeed = SimulationSpeeds::DOUBLE_SPEED;
+				gMaximumSpeed = false;
+				return true;
+			}
+			case '5':
+			{
+				gSimulationSpeed = SimulationSpeeds::QUADRUPLE_SPEED;
+				gMaximumSpeed = false;
+				return true;
+			}
+			case '6':
+			{
+				gSimulationSpeed = SimulationSpeeds::DECUPLE_SPEED;
+				gMaximumSpeed = false;
+				return true;
+			}
+			case '7':
+			{
+				gSimulationSpeed = SimulationSpeeds::CENTUPLE_SPEED;
+				gMaximumSpeed = false;
+				return true;
+			}
+			case '8':
+			{
+				gSimulationSpeed = SimulationSpeeds::QUINCENTUPLE_SPEED;
+				gMaximumSpeed = false;
+				return true;
+			}
+			case '9':
+			{
+				gSimulationSpeed = SimulationSpeeds::MILLITUPLE_SPEED;
+				gMaximumSpeed = false;
+				return true;
+			}
+			case '0':
+			{
+				gSimulationSpeed = SimulationSpeeds::MAX_SPEED;
+				gMaximumSpeed = true;
+				return true;
+			}
+		}
+		return CommonRigidBodyBase::keyboardCallback(key, state);
+	}
+
+	void changePhysicsStepsPerSecond(float physicsStepsPerSecond)
+	{  // change the simulation accuracy
+		if (m_dynamicsWorld && physicsStepsPerSecond)
+		{
+			fixedPhysicsStepSizeSec = 1.0f / physicsStepsPerSecond;
+			fixedPhysicsStepSizeMilli = 1000.0f / physicsStepsPerSecond;
+
+			changeERPCFM();
+		}
+	}
+
+	void changeERPCFM()
+	{  // Change ERP/CFM appropriately to the timestep and the ERP/CFM parameters above
+		if (m_dynamicsWorld)
+		{
+			m_dynamicsWorld->getSolverInfo().m_erp = b3ERPCFMHelper::getERP(  // set the error reduction parameter
+				fixedPhysicsStepSizeSec,                                      // step size per second
+				gERPSpringK,                                                  // k of a spring in the equation F = k * x (x:position)
+				gERPDamperC);                                                 // k of a damper in the equation F = k * v (v:velocity)
+
+			m_dynamicsWorld->getSolverInfo().m_globalCfm = b3ERPCFMHelper::getCFM(  // set the constraint force mixing according to the time step
+				gCFMSingularityAvoidance,                                           // singularity avoidance (if you experience unsolvable constraints, increase this value
+				fixedPhysicsStepSizeSec,                                            // steps size per second
+				gCFMSpringK,                                                        // k of a spring in the equation F = k * x (x:position)
+				gCFMDamperC);                                                       // k of a damper in the equation F = k * v (v:velocity)
+
+			//			b3Printf("Bullet DynamicsWorld ERP: %f",
+			//				m_dynamicsWorld->getSolverInfo().m_erp);
+
+			//			b3Printf("Bullet DynamicsWorld CFM: %f",
+			//				m_dynamicsWorld->getSolverInfo().m_globalCfm);
+		}
+	}
+
+	void changeSolverIterations(int iterations)
+	{  // change the number of iterations
+		m_dynamicsWorld->getSolverInfo().m_numIterations = iterations;
+	}
+
+	void changeFPS(float framesPerSecond)
+	{  // change the frames per second
+		fpsStep = 1000.0f / gFramesPerSecond;
+	}
+
+	void performTrueSteps(btScalar timeStep)
+	{                                                                     // physics stepping without interpolated substeps
+		int subSteps = floor((timeStep / fixedPhysicsStepSizeSec) + 0.5); /**!< Calculate the number of full normal time steps we can take */
+
+		for (int i = 0; i < subSteps; i++)
+		{ /**!< Perform the number of substeps to reach the timestep*/
+			if (timeStep && m_dynamicsWorld)
+			{
+				// since we want to perform all proper steps, we perform no interpolated substeps
+				int subSteps = 1;
+
+				m_dynamicsWorld->stepSimulation(btScalar(timeStep),
+												btScalar(subSteps), btScalar(fixedPhysicsStepSizeSec));
+			}
+		}
+	}
+
+	void performInterpolatedSteps(btScalar timeStep)
+	{                                                                         // physics stepping with interpolated substeps
+		int subSteps = 1 + floor((timeStep / fixedPhysicsStepSizeSec) + 0.5); /**!< Calculate the number of full normal time steps we can take, plus 1 for safety of not losing time */
+		if (timeStep && m_dynamicsWorld)
+		{
+			m_dynamicsWorld->stepSimulation(btScalar(timeStep), btScalar(subSteps),
+											btScalar(fixedPhysicsStepSizeSec)); /**!< Perform the number of substeps to reach the timestep*/
+		}
+	}
+
+	void performMaxStep()
+	{  // perform as many steps as possible
+		if (gApplicationTick >= mLastGraphicsTick + mLastInputTick)
+		{                                   // if the remaining time for graphics is going to be positive
+			mPhysicsTick = gApplicationTick /**!< calculate the remaining time for physics (in Milliseconds) */
+						   - mLastGraphicsTick - mLastInputTick;
+		}
+		else
+		{
+			mPhysicsTick = 0;  // no time for physics left / The internal application step is too high
+		}
+
+		//	b3Printf("Application tick: %u",gApplicationTick);
+		//	b3Printf("Graphics tick: %u",mLastGraphicsTick);
+		//	b3Printf("Input tick: %u",mLastInputTick);
+		//	b3Printf("Physics tick: %u",mPhysicsTick);
+
+		if (mPhysicsTick > 0)
+		{  // with positive physics tick we perform as many update steps until the time for it is used up
+
+			mPhysicsStepStart = mLoopTimer.getTimeMilliseconds(); /**!< The physics updates start (in Milliseconds)*/
+			mPhysicsStepEnd = mPhysicsStepStart;
+
+			while (mPhysicsTick > mPhysicsStepEnd - mPhysicsStepStart)
+			{ /**!< Update the physics until we run out of time (in Milliseconds) */
+				//			b3Printf("Physics passed: %u", mPhysicsStepEnd - mPhysicsStepStart);
+				double timeStep = fixedPhysicsStepSizeSec; /**!< update the world (in Seconds) */
+
+				if (gInterpolate)
+				{
+					performInterpolatedSteps(timeStep);
+				}
+				else
+				{
+					performTrueSteps(timeStep);
+				}
+				performedTime += timeStep;
+				mPhysicsStepEnd = mLoopTimer.getTimeMilliseconds(); /**!< Update the last physics step end to stop updating in time (in Milliseconds) */
+			}
+		}
+	}
+
+	void performSpeedStep()
+	{  // force-perform the number of steps needed to achieve a certain speed (safe to too high speeds, meaning the application will lose time, not the physics)
+		if (mFrameTime > gApplicationTick)
+		{                                   /** cap frametime to make the application lose time, not the physics (in Milliseconds) */
+			mFrameTime = gApplicationTick;  // This prevents the physics time accumulator to sum up too much time
+		}                                   // The simulation therefore gets slower, but still performs all requested physics steps
+
+		mModelAccumulator += mFrameTime; /**!< Accumulate the time the physics simulation has to perform in order to stay in real-time (in Milliseconds) */
+		//	b3Printf("Model time accumulator: %u", mModelAccumulator);
+
+		int steps = floor(mModelAccumulator / fixedPhysicsStepSizeMilli); /**!< Calculate the number of time steps we can take */
+		//	b3Printf("Next steps: %i", steps);
+
+		if (steps > 0)
+		{ /**!< Update if we can take at least one step */
+
+			double timeStep = gSimulationSpeed * steps * fixedPhysicsStepSizeSec; /**!< update the universe (in Seconds) */
+
+			if (gInterpolate)
+			{
+				performInterpolatedSteps(timeStep);  // perform interpolated steps
+			}
+			else
+			{
+				performTrueSteps(timeStep);  // perform full steps
+			}
+			performedTime += timeStep;                              // sum up the performed time for measuring the speed up
+			mModelAccumulator -= steps * fixedPhysicsStepSizeMilli; /**!< Remove the time performed by the physics simulation from the accumulator, the remaining time carries over to the next cycle  (in Milliseconds) */
+		}
+	}
+
+	void renderScene()
+	{  // render the scene
+		if (!gIsHeadless)
+		{  // while the simulation is not running headlessly, render to screen
+			CommonRigidBodyBase::renderScene();
+
+			if (m_dynamicsWorld->getDebugDrawer())
+			{
+				debugDraw(m_dynamicsWorld->getDebugDrawer()->getDebugMode());
+			}
+		}
+		mIsHeadless = gIsHeadless;
+	}
+	void resetCamera()
+	{  // reset the camera to its original position
+		float dist = 41;
+		float pitch = 52;
+		float yaw = 35;
+		float targetPos[3] = {0, 0.46, 0};
+		m_guiHelper->resetCamera(dist, pitch, yaw, targetPos[0], targetPos[1],
+								 targetPos[2]);
+	}
+
+	// loop timing components ###################
+	//# loop timestamps
+	btClock mLoopTimer;                        /**!< The loop timer to time the loop correctly */
+	unsigned long int mApplicationStart;       /**!< The time the application was started (absolute, in Milliseconds) */
+	unsigned long int mPreviousModelIteration; /**!< The previous model iteration timestamp (absolute, in Milliseconds) */
+	unsigned long int mThisModelIteration;     /**!< This model iteration timestamp (absolute, in Milliseconds) */
+
+	//# loop durations
+	long int mModelAccumulator;            /**!< The time to forward the model in this loop iteration (relative, in Milliseconds) */
+	unsigned long int mFrameTime;          /**!< The time to render a frame (relative, in Milliseconds) */
+	unsigned long int mApplicationRuntime; /**!< The total application runtime (relative, in Milliseconds) */
+
+	long int mInputDt; /**!< The time difference of input that has to be fed in */
+	unsigned long int mInputClock;
+
+	long int mLastGraphicsTick; /*!< The time it took the graphics rendering last time (relative, in Milliseconds) */
+	unsigned long int mGraphicsStart;
+
+	long int mLastInputTick; /**!< The time it took the input to process last time (relative, in Milliseconds) */
+	unsigned long int mInputStart;
+
+	long int mLastModelTick;       /**!<  The time it took the model to update last time
+	 This includes the bullet physics update */
+	unsigned long int mModelStart; /**!< The timestamp the model started updating last (absolute, in Milliseconds)*/
+
+	long int mPhysicsTick;               /**!< The time remaining in the loop to update the physics (relative, in Milliseconds)*/
+	unsigned long int mPhysicsStepStart; /**!< The physics start timestamp (absolute, in Milliseconds) */
+	unsigned long int mPhysicsStepEnd;   /**!< The last physics step end (absolute, in Milliseconds) */
+
+	// to measure the performance of the demo
+	double performedTime;
+	unsigned long int performanceTimestamp;
+
+	unsigned long int speedUpPrintTimeStamp;
+
+	unsigned long int fpsTimeStamp; /**!< FPS timing variables */
+	double fpsStep;
+
+	//store old values
+	bool mPhysicsStepsPerSecondUpdated;
+	bool mFramesPerSecondUpdated;
+	bool mSolverIterationsUpdated;
+	bool mIsHeadless;
+};
+
+#endif  //NN3D_WALKERS_TIME_WARP_BASE_H
diff --git a/engine/inc/bullet/ExampleBrowser/CollisionShape2TriangleMesh.h b/engine/inc/bullet/ExampleBrowser/CollisionShape2TriangleMesh.h
new file mode 100644
index 00000000..b4aafbb0
--- /dev/null
+++ b/engine/inc/bullet/ExampleBrowser/CollisionShape2TriangleMesh.h
@@ -0,0 +1,10 @@
+#ifndef COLLISION_SHAPE_2_GRAPHICS_H
+#define COLLISION_SHAPE_2_GRAPHICS_H
+
+#include "LinearMath/btAlignedObjectArray.h"
+#include "LinearMath/btTransform.h"
+class btCollisionShape;
+
+void CollisionShape2TriangleMesh(btCollisionShape* collisionShape, const btTransform& parentTransform, btAlignedObjectArray<btVector3>& vertexPositions, btAlignedObjectArray<btVector3>& vertexNormals, btAlignedObjectArray<int>& indicesOut);
+
+#endif  //COLLISION_SHAPE_2_GRAPHICS_H
diff --git a/engine/inc/bullet/ExampleBrowser/EmptyBrowser.h b/engine/inc/bullet/ExampleBrowser/EmptyBrowser.h
new file mode 100644
index 00000000..b3dd3a80
--- /dev/null
+++ b/engine/inc/bullet/ExampleBrowser/EmptyBrowser.h
@@ -0,0 +1,45 @@
+#ifndef EMPTY_BROWSER
+#define EMPTY_BROWSER
+
+#include "ExampleBrowserInterface.h"
+#include "EmptyExample.h"
+
+class EmptyBrowser : public ExampleBrowserInterface
+{
+public:
+	EmptyExample m_emptyExample;
+
+	virtual CommonExampleInterface* getCurrentExample()
+	{
+		return &m_emptyExample;
+	}
+
+	EmptyBrowser(class ExampleEntries* examples)
+	{
+	}
+
+	virtual bool init(int /*argc*/, char* argv[])
+	{
+		return true;
+	}
+
+	virtual void update(float deltaTime)
+	{
+		m_emptyExample.stepSimulation(deltaTime);
+	}
+
+	virtual void updateGraphics()
+	{
+	}
+
+	virtual bool requestedExit()
+	{
+		return false;
+	}
+
+	virtual void setSharedMemoryInterface(class SharedMemoryInterface* sharedMem)
+	{
+	}
+};
+
+#endif  //EMPTY_BROWSER
diff --git a/engine/inc/bullet/ExampleBrowser/EmptyExample.h b/engine/inc/bullet/ExampleBrowser/EmptyExample.h
new file mode 100644
index 00000000..95ba27ff
--- /dev/null
+++ b/engine/inc/bullet/ExampleBrowser/EmptyExample.h
@@ -0,0 +1,27 @@
+#ifndef EMPTY_EXAMPLE_H
+#define EMPTY_EXAMPLE_H
+
+#include "../CommonInterfaces/CommonExampleInterface.h"
+
+class EmptyExample : public CommonExampleInterface
+{
+public:
+	EmptyExample() {}
+	virtual ~EmptyExample() {}
+
+	static CommonExampleInterface* CreateFunc(struct CommonExampleOptions& /* unusedOptions*/)
+	{
+		return new EmptyExample;
+	}
+
+	virtual void initPhysics() {}
+	virtual void exitPhysics() {}
+	virtual void stepSimulation(float deltaTime) {}
+	virtual void renderScene() {}
+	virtual void physicsDebugDraw(int debugFlags) {}
+	virtual bool mouseMoveCallback(float x, float y) { return false; }
+	virtual bool mouseButtonCallback(int button, int state, float x, float y) { return false; }
+	virtual bool keyboardCallback(int key, int state) { return false; }
+};
+
+#endif  //EMPTY_EXAMPLE_H
diff --git a/engine/inc/bullet/ExampleBrowser/ExampleBrowserInterface.h b/engine/inc/bullet/ExampleBrowser/ExampleBrowserInterface.h
new file mode 100644
index 00000000..f4867987
--- /dev/null
+++ b/engine/inc/bullet/ExampleBrowser/ExampleBrowserInterface.h
@@ -0,0 +1,24 @@
+#ifndef EXAMPLE_BROWSER_GUI_H
+#define EXAMPLE_BROWSER_GUI_H
+
+#include "../CommonInterfaces/CommonExampleInterface.h"
+
+class ExampleBrowserInterface
+{
+public:
+	virtual ~ExampleBrowserInterface() {}
+
+	virtual CommonExampleInterface* getCurrentExample() = 0;
+
+	virtual bool init(int argc, char* argv[]) = 0;
+
+	virtual void update(float deltaTime) = 0;
+
+	virtual void updateGraphics() = 0;
+
+	virtual bool requestedExit() = 0;
+
+	virtual void setSharedMemoryInterface(class SharedMemoryInterface* sharedMem) = 0;
+};
+
+#endif  //EXAMPLE_BROWSER_GUI_H
\ No newline at end of file
diff --git a/engine/inc/bullet/ExampleBrowser/ExampleEntries.h b/engine/inc/bullet/ExampleBrowser/ExampleEntries.h
new file mode 100644
index 00000000..d4b4119c
--- /dev/null
+++ b/engine/inc/bullet/ExampleBrowser/ExampleEntries.h
@@ -0,0 +1,32 @@
+
+#ifndef EXAMPLE_ENTRIES_H
+#define EXAMPLE_ENTRIES_H
+
+#include "../CommonInterfaces/CommonExampleInterface.h"
+
+class ExampleEntriesAll : public ExampleEntries
+{
+	struct ExampleEntriesInternalData* m_data;
+
+public:
+	ExampleEntriesAll();
+	virtual ~ExampleEntriesAll();
+
+	static void registerExampleEntry(int menuLevel, const char* name, const char* description, CommonExampleInterface::CreateFunc* createFunc, int option = 0);
+
+	virtual void initExampleEntries();
+
+	virtual void initOpenCLExampleEntries();
+
+	virtual int getNumRegisteredExamples();
+
+	virtual CommonExampleInterface::CreateFunc* getExampleCreateFunc(int index);
+
+	virtual const char* getExampleName(int index);
+
+	virtual const char* getExampleDescription(int index);
+
+	virtual int getExampleOption(int index);
+};
+
+#endif  //EXAMPLE_ENTRIES_H
diff --git a/engine/inc/bullet/ExampleBrowser/GL_ShapeDrawer.h b/engine/inc/bullet/ExampleBrowser/GL_ShapeDrawer.h
new file mode 100644
index 00000000..9eb13bfd
--- /dev/null
+++ b/engine/inc/bullet/ExampleBrowser/GL_ShapeDrawer.h
@@ -0,0 +1,81 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef GL_SHAPE_DRAWER_H
+#define GL_SHAPE_DRAWER_H
+
+class btCollisionShape;
+class btShapeHull;
+class btDiscreteDynamicsWorld;
+
+#include "LinearMath/btAlignedObjectArray.h"
+#include "LinearMath/btVector3.h"
+
+#include "BulletCollision/CollisionShapes/btShapeHull.h"
+
+/// OpenGL shape drawing
+class GL_ShapeDrawer
+{
+protected:
+	struct ShapeCache
+	{
+		struct Edge
+		{
+			btVector3 n[2];
+			int v[2];
+		};
+		ShapeCache(btConvexShape* s) : m_shapehull(s) {}
+		btShapeHull m_shapehull;
+		btAlignedObjectArray<Edge> m_edges;
+	};
+	//clean-up memory of dynamically created shape hulls
+	btAlignedObjectArray<ShapeCache*> m_shapecaches;
+	unsigned int m_texturehandle;
+	bool m_textureenabled;
+	bool m_textureinitialized;
+
+	ShapeCache* cache(btConvexShape*);
+
+	virtual void drawSceneInternal(const btDiscreteDynamicsWorld* world, int pass, int cameraUpAxis);
+
+public:
+	GL_ShapeDrawer();
+
+	virtual ~GL_ShapeDrawer();
+
+	virtual void drawScene(const btDiscreteDynamicsWorld* world, bool useShadows, int cameraUpAxis);
+
+	///drawOpenGL might allocate temporary memoty, stores pointer in shape userpointer
+	virtual void drawOpenGL(btScalar* m, const btCollisionShape* shape, const btVector3& color, int debugMode, const btVector3& worldBoundsMin, const btVector3& worldBoundsMax);
+	virtual void drawShadow(btScalar* m, const btVector3& extrusion, const btCollisionShape* shape, const btVector3& worldBoundsMin, const btVector3& worldBoundsMax);
+
+	bool enableTexture(bool enable)
+	{
+		bool p = m_textureenabled;
+		m_textureenabled = enable;
+		return (p);
+	}
+	bool hasTextureEnabled() const
+	{
+		return m_textureenabled;
+	}
+
+	void drawSphere(btScalar r, int lats, int longs);
+	static void drawCoordSystem();
+};
+
+void OGL_displaylist_register_shape(btCollisionShape* shape);
+void OGL_displaylist_clean();
+
+#endif  //GL_SHAPE_DRAWER_H
diff --git a/engine/inc/bullet/ExampleBrowser/GwenGUISupport/GraphingTexture.h b/engine/inc/bullet/ExampleBrowser/GwenGUISupport/GraphingTexture.h
new file mode 100644
index 00000000..27d52e71
--- /dev/null
+++ b/engine/inc/bullet/ExampleBrowser/GwenGUISupport/GraphingTexture.h
@@ -0,0 +1,45 @@
+#ifndef GRAPHING_TEXTURE_H
+#define GRAPHING_TEXTURE_H
+#include "LinearMath/btAlignedObjectArray.h"
+
+struct GraphingTexture
+{
+	int m_textureId;
+	//assume rgba (8 bit per component, total of 32bit per pixel, for m_width*m_height pixels)
+	btAlignedObjectArray<unsigned char> m_imageData;
+	int m_width;
+	int m_height;
+
+	GraphingTexture();
+	virtual ~GraphingTexture();
+
+	bool create(int texWidth, int texHeight);
+	void destroy();
+
+	void setPixel(int x, int y, unsigned char red, unsigned char green, unsigned char blue, unsigned char alpha)
+	{
+		if (y >= 0 && y < m_height && x >= 0 && x < m_width)
+		{
+			m_imageData[x * 4 + y * 4 * m_width + 0] = red;
+			m_imageData[x * 4 + y * 4 * m_width + 1] = green;
+			m_imageData[x * 4 + y * 4 * m_width + 2] = blue;
+			m_imageData[x * 4 + y * 4 * m_width + 3] = alpha;
+		}
+	}
+
+	void getPixel(int x, int y, unsigned char& red, unsigned char& green, unsigned char& blue, unsigned char& alpha)
+	{
+		red = m_imageData[x * 4 + y * 4 * m_width + 0];
+		green = m_imageData[x * 4 + y * 4 * m_width + 1];
+		blue = m_imageData[x * 4 + y * 4 * m_width + 2];
+		alpha = m_imageData[x * 4 + y * 4 * m_width + 3];
+	}
+	void uploadImageData();
+
+	int getTextureId()
+	{
+		return m_textureId;
+	}
+};
+
+#endif  //GRAPHING_TEXTURE_H
diff --git a/engine/inc/bullet/ExampleBrowser/GwenGUISupport/GwenParameterInterface.h b/engine/inc/bullet/ExampleBrowser/GwenGUISupport/GwenParameterInterface.h
new file mode 100644
index 00000000..819090b4
--- /dev/null
+++ b/engine/inc/bullet/ExampleBrowser/GwenGUISupport/GwenParameterInterface.h
@@ -0,0 +1,23 @@
+#ifndef GWEN_PARAMETER_INTERFACE_H
+#define GWEN_PARAMETER_INTERFACE_H
+
+#include "../CommonInterfaces/CommonParameterInterface.h"
+
+struct GwenParameterInterface : public CommonParameterInterface
+{
+	struct GwenInternalData* m_gwenInternalData;
+
+	struct GwenParameters* m_paramInternalData;
+
+	GwenParameterInterface(struct GwenInternalData* gwenInternalData);
+	virtual ~GwenParameterInterface();
+	virtual void registerSliderFloatParameter(SliderParams& params);
+	virtual void registerButtonParameter(ButtonParams& params);
+	virtual void registerComboBox(ComboBoxParams& params);
+
+	virtual void setSliderValue(int sliderIndex, double sliderValue);
+	virtual void syncParameters();
+	virtual void removeAllParameters();
+};
+
+#endif  //GWEN_PARAMETER_INTERFACE_H
diff --git a/engine/inc/bullet/ExampleBrowser/GwenGUISupport/GwenProfileWindow.h b/engine/inc/bullet/ExampleBrowser/GwenGUISupport/GwenProfileWindow.h
new file mode 100644
index 00000000..fbe69e81
--- /dev/null
+++ b/engine/inc/bullet/ExampleBrowser/GwenGUISupport/GwenProfileWindow.h
@@ -0,0 +1,11 @@
+#ifndef GWEN_PROFILE_WINDOW_H
+#define GWEN_PROFILE_WINDOW_H
+
+class MyProfileWindow* setupProfileWindow(struct GwenInternalData* data);
+void processProfileData(MyProfileWindow* window, bool idle);
+void profileWindowSetVisible(MyProfileWindow* window, bool visible);
+bool isProfileWindowVisible(MyProfileWindow* window);
+
+void destroyProfileWindow(MyProfileWindow* window);
+
+#endif  //GWEN_PROFILE_WINDOW_H
diff --git a/engine/inc/bullet/ExampleBrowser/GwenGUISupport/GwenTextureWindow.h b/engine/inc/bullet/ExampleBrowser/GwenGUISupport/GwenTextureWindow.h
new file mode 100644
index 00000000..85866b1d
--- /dev/null
+++ b/engine/inc/bullet/ExampleBrowser/GwenGUISupport/GwenTextureWindow.h
@@ -0,0 +1,31 @@
+
+
+#ifndef GWEN_TEXTURE_WINDOW_H
+#define GWEN_TEXTURE_WINDOW_H
+
+struct MyGraphInput
+{
+	struct GwenInternalData* m_data;
+	int m_xPos;
+	int m_yPos;
+	int m_width;
+	int m_height;
+	int m_borderWidth;
+	const char* m_name;
+	const char* m_texName;
+	MyGraphInput(struct GwenInternalData* data)
+		: m_data(data),
+		  m_xPos(0),
+		  m_yPos(0),
+		  m_width(400),
+		  m_height(400),
+		  m_borderWidth(0),
+		  m_name("GraphWindow"),
+		  m_texName(0)
+	{
+	}
+};
+class MyGraphWindow* setupTextureWindow(const MyGraphInput& input);
+void destroyTextureWindow(MyGraphWindow* window);
+
+#endif  //GWEN_TEXTURE_WINDOW_H
diff --git a/engine/inc/bullet/ExampleBrowser/GwenGUISupport/gwenInternalData.h b/engine/inc/bullet/ExampleBrowser/GwenGUISupport/gwenInternalData.h
new file mode 100644
index 00000000..6ce62fc1
--- /dev/null
+++ b/engine/inc/bullet/ExampleBrowser/GwenGUISupport/gwenInternalData.h
@@ -0,0 +1,61 @@
+#ifndef GWEN_INTERNAL_DATA_H
+#define GWEN_INTERNAL_DATA_H
+
+#include "../OpenGLWindow/GwenOpenGL3CoreRenderer.h"
+#include "../OpenGLWindow/GLPrimitiveRenderer.h"
+#include "Gwen/Platform.h"
+#include "Gwen/Controls/TreeControl.h"
+#include "Gwen/Controls/RadioButtonController.h"
+#include "Gwen/Controls/VerticalSlider.h"
+#include "Gwen/Controls/HorizontalSlider.h"
+#include "Gwen/Controls/GroupBox.h"
+#include "Gwen/Controls/CheckBox.h"
+#include "Gwen/Controls/StatusBar.h"
+#include "Gwen/Controls/Button.h"
+#include "Gwen/Controls/ComboBox.h"
+#include "Gwen/Controls/MenuStrip.h"
+#include "Gwen/Controls/Slider.h"
+#include "Gwen/Controls/Property/Text.h"
+#include "Gwen/Controls/SplitterBar.h"
+#include "Bullet3Common/b3AlignedObjectArray.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Align.h"
+#include "Gwen/Utility.h"
+#include "Gwen/Controls/WindowControl.h"
+#include "Gwen/Controls/TabControl.h"
+#include "Gwen/Controls/ListBox.h"
+#include "Gwen/Skins/Simple.h"
+//#include "Gwen/Skins/TexturedBase.h"
+#include "gwenUserInterface.h"
+
+struct GwenInternalData
+{
+	//struct sth_stash;
+	//class GwenOpenGL3CoreRenderer*	pRenderer;
+	Gwen::Renderer::Base* pRenderer;
+	Gwen::Skin::Simple skin;
+	Gwen::Controls::Canvas* pCanvas;
+	//GLPrimitiveRenderer* m_primRenderer;
+	Gwen::Controls::TabButton* m_demoPage;
+	Gwen::Controls::TabButton* m_explorerPage;
+	Gwen::Controls::TreeControl* m_explorerTreeCtrl;
+	Gwen::Controls::MenuItem* m_viewMenu;
+	class MyMenuItems* m_menuItems;
+	Gwen::Controls::ListBox* m_TextOutput;
+	Gwen::Controls::Label* m_exampleInfoGroupBox;
+	Gwen::Controls::ListBox* m_exampleInfoTextOutput;
+	struct MyTestMenuBar* m_menubar;
+	Gwen::Controls::StatusBar* m_bar;
+	Gwen::Controls::ScrollControl* m_windowRight;
+	Gwen::Controls::TabControl* m_tab;
+
+	int m_curYposition;
+
+	Gwen::Controls::Label* m_rightStatusBar;
+	Gwen::Controls::Label* m_leftStatusBar;
+	b3AlignedObjectArray<class Gwen::Event::Handler*> m_handlers;
+	b3ToggleButtonCallback m_toggleButtonCallback;
+	b3ComboBoxCallback m_comboBoxCallback;
+};
+
+#endif  //GWEN_INTERNAL_DATA_H
diff --git a/engine/inc/bullet/ExampleBrowser/GwenGUISupport/gwenUserInterface.h b/engine/inc/bullet/ExampleBrowser/GwenGUISupport/gwenUserInterface.h
new file mode 100644
index 00000000..5f246180
--- /dev/null
+++ b/engine/inc/bullet/ExampleBrowser/GwenGUISupport/gwenUserInterface.h
@@ -0,0 +1,63 @@
+#ifndef _GWEN_USER_INTERFACE_H
+#define _GWEN_USER_INTERFACE_H
+
+struct GwenInternalData;
+
+typedef void (*b3ComboBoxCallback)(int combobox, const char* item);
+typedef void (*b3ToggleButtonCallback)(int button, int state);
+typedef void (*b3FileOpenCallback)();
+typedef void (*b3QuitCallback)();
+
+namespace Gwen
+{
+namespace Renderer
+{
+class Base;
+};
+};  // namespace Gwen
+class GwenUserInterface
+{
+	GwenInternalData* m_data;
+
+public:
+	GwenUserInterface();
+
+	virtual ~GwenUserInterface();
+
+	void init(int width, int height, Gwen::Renderer::Base* gwenRenderer, float retinaScale);
+	void exit();
+	void setFocus();
+	void forceUpdateScrollBars();
+
+	void draw(int width, int height);
+
+	void resize(int width, int height);
+
+	bool mouseMoveCallback(float x, float y);
+	bool mouseButtonCallback(int button, int state, float x, float y);
+	bool keyboardCallback(int key, int state);
+
+	void setToggleButtonCallback(b3ToggleButtonCallback callback);
+	b3ToggleButtonCallback getToggleButtonCallback();
+
+	void registerToggleButton2(int buttonId, const char* name);
+
+	void setComboBoxCallback(b3ComboBoxCallback callback);
+	b3ComboBoxCallback getComboBoxCallback();
+	void registerComboBox2(int buttonId, int numItems, const char** items, int startItem = 0);
+
+	void setStatusBarMessage(const char* message, bool isLeft = true);
+
+	void textOutput(const char* msg);
+	void setExampleDescription(const char* msg);
+
+	void registerFileOpenCallback(b3FileOpenCallback callback);
+	void registerQuitCallback(b3QuitCallback callback);
+
+	GwenInternalData* getInternalData()
+	{
+		return m_data;
+	}
+};
+
+#endif  //_GWEN_USER_INTERFACE_H
diff --git a/engine/inc/bullet/ExampleBrowser/InProcessExampleBrowser.h b/engine/inc/bullet/ExampleBrowser/InProcessExampleBrowser.h
new file mode 100644
index 00000000..f231091e
--- /dev/null
+++ b/engine/inc/bullet/ExampleBrowser/InProcessExampleBrowser.h
@@ -0,0 +1,30 @@
+#ifndef IN_PROCESS_EXAMPLE_BROWSER_H
+#define IN_PROCESS_EXAMPLE_BROWSER_H
+
+struct btInProcessExampleBrowserInternalData;
+
+btInProcessExampleBrowserInternalData* btCreateInProcessExampleBrowser(int argc, char** argv2, bool useInProcessMemory);
+
+bool btIsExampleBrowserTerminated(btInProcessExampleBrowserInternalData* data);
+
+void btShutDownExampleBrowser(btInProcessExampleBrowserInternalData* data);
+
+class SharedMemoryInterface* btGetSharedMemoryInterface(btInProcessExampleBrowserInternalData* data);
+
+///////////////////////
+
+struct btInProcessExampleBrowserMainThreadInternalData;
+
+btInProcessExampleBrowserMainThreadInternalData* btCreateInProcessExampleBrowserMainThread(int argc, char** argv, bool useInProcessMemory);
+
+bool btIsExampleBrowserMainThreadTerminated(btInProcessExampleBrowserMainThreadInternalData* data);
+
+void btUpdateInProcessExampleBrowserMainThread(btInProcessExampleBrowserMainThreadInternalData* data);
+
+void btShutDownExampleBrowserMainThread(btInProcessExampleBrowserMainThreadInternalData* data);
+
+class SharedMemoryInterface* btGetSharedMemoryInterfaceMainThread(btInProcessExampleBrowserMainThreadInternalData* data);
+
+//////////////////////
+
+#endif  //IN_PROCESS_EXAMPLE_BROWSER_H
diff --git a/engine/inc/bullet/ExampleBrowser/OpenGLExampleBrowser.h b/engine/inc/bullet/ExampleBrowser/OpenGLExampleBrowser.h
new file mode 100644
index 00000000..df26f9e4
--- /dev/null
+++ b/engine/inc/bullet/ExampleBrowser/OpenGLExampleBrowser.h
@@ -0,0 +1,29 @@
+#ifndef OPENGL_BROWSER_GUI_H
+#define OPENGL_BROWSER_GUI_H
+
+#include "ExampleBrowserInterface.h"
+
+class OpenGLExampleBrowser : public ExampleBrowserInterface
+{
+	struct OpenGLExampleBrowserInternalData* m_internalData;
+
+public:
+	OpenGLExampleBrowser(class ExampleEntries* examples);
+	virtual ~OpenGLExampleBrowser();
+
+	virtual CommonExampleInterface* getCurrentExample();
+
+	virtual bool init(int argc, char* argv[]);
+
+	virtual void update(float deltaTime);
+
+	virtual void updateGraphics();
+
+	virtual bool requestedExit();
+
+	virtual void setSharedMemoryInterface(class SharedMemoryInterface* sharedMem);
+
+	static void registerFileImporter(const char* extension, CommonExampleInterface::CreateFunc* createFunc);
+};
+
+#endif  //OPENGL_BROWSER_GUI_H
diff --git a/engine/inc/bullet/ExampleBrowser/OpenGLGuiHelper.h b/engine/inc/bullet/ExampleBrowser/OpenGLGuiHelper.h
new file mode 100644
index 00000000..abeaa9af
--- /dev/null
+++ b/engine/inc/bullet/ExampleBrowser/OpenGLGuiHelper.h
@@ -0,0 +1,113 @@
+#ifndef OPENGL_GUI_HELPER_H
+#define OPENGL_GUI_HELPER_H
+#include "../CommonInterfaces/CommonGUIHelperInterface.h"
+
+class btCollisionShape;
+class btTransform;
+#include "LinearMath/btAlignedObjectArray.h"
+#include "../OpenGLWindow/GLInstanceGraphicsShape.h"
+
+struct OpenGLGuiHelper : public GUIHelperInterface
+{
+	struct OpenGLGuiHelperInternalData* m_data;
+
+	OpenGLGuiHelper(struct CommonGraphicsApp* glApp, bool useOpenGL2);
+
+	virtual ~OpenGLGuiHelper();
+
+	virtual struct CommonRenderInterface* getRenderInterface();
+	virtual const struct CommonRenderInterface* getRenderInterface() const;
+
+	virtual void createRigidBodyGraphicsObject(btRigidBody* body, const btVector3& color);
+
+	virtual void createCollisionObjectGraphicsObject(btCollisionObject* body, const btVector3& color);
+
+	virtual int registerTexture(const unsigned char* texels, int width, int height);
+	virtual int registerGraphicsShape(const float* vertices, int numvertices, const int* indices, int numIndices, int primitiveType, int textureId);
+	virtual int registerGraphicsInstance(int shapeIndex, const float* position, const float* quaternion, const float* color, const float* scaling);
+	virtual void removeAllGraphicsInstances();
+	virtual void removeGraphicsInstance(int graphicsUid);
+	virtual void changeInstanceFlags(int instanceUid, int flags);
+	virtual void changeRGBAColor(int instanceUid, const double rgbaColor[4]);
+	virtual void changeScaling(int instanceUid, const double scaling[3]);
+	virtual void changeSpecularColor(int instanceUid, const double specularColor[3]);
+	virtual void changeTexture(int textureUniqueId, const unsigned char* rgbTexels, int width, int height);
+	virtual void removeTexture(int textureUid);
+	virtual int getShapeIndexFromInstance(int instanceUid);
+	virtual void replaceTexture(int shapeIndex, int textureUid);
+	virtual void updateShape(int shapeIndex, float* vertices, int numVertices);
+
+	virtual void createCollisionShapeGraphicsObject(btCollisionShape* collisionShape);
+
+	virtual void syncPhysicsToGraphics(const btDiscreteDynamicsWorld* rbWorld);
+
+	virtual void render(const btDiscreteDynamicsWorld* rbWorld);
+
+	virtual void createPhysicsDebugDrawer(btDiscreteDynamicsWorld* rbWorld);
+
+	virtual struct Common2dCanvasInterface* get2dCanvasInterface();
+
+	virtual CommonParameterInterface* getParameterInterface();
+
+	virtual struct CommonGraphicsApp* getAppInterface();
+
+	virtual void setUpAxis(int axis);
+
+	virtual void resetCamera(float camDist, float yaw, float pitch, float camPosX, float camPosY, float camPosZ);
+	virtual bool getCameraInfo(int* width, int* height, float viewMatrix[16], float projectionMatrix[16], float camUp[3], float camForward[3], float hor[3], float vert[3], float* yaw, float* pitch, float* camDist, float cameraTarget[3]) const;
+
+	virtual void copyCameraImageData(const float viewMatrix[16], const float projectionMatrix[16],
+									 unsigned char* pixelsRGBA, int rgbaBufferSizeInPixels,
+									 float* depthBuffer, int depthBufferSizeInPixels,
+									 int* segmentationMaskBuffer, int segmentationMaskBufferSizeInPixels,
+									 int startPixelIndex, int destinationWidth,
+									 int destinationHeight, int* numPixelsCopied);
+
+	virtual void setProjectiveTextureMatrices(const float viewMatrix[16], const float projectionMatrix[16]);
+	virtual void setProjectiveTexture(bool useProjectiveTexture);
+
+	virtual void autogenerateGraphicsObjects(btDiscreteDynamicsWorld* rbWorld);
+
+	virtual void drawText3D(const char* txt, float position[3], float orientation[4], float color[4], float size, int optionFlag);
+
+	virtual void drawText3D(const char* txt, float posX, float posY, float posZ, float size);
+
+	virtual int addUserDebugText3D(const char* txt, const double positionXYZ[3], const double textColorRGB[3], double size, double lifeTime)
+	{
+		return -1;
+	}
+
+	virtual int addUserDebugLine(const double debugLineFromXYZ[3], const double debugLineToXYZ[3], const double debugLineColorRGB[3], double lineWidth, double lifeTime, int trackingVisualShapeIndex, int replaceItemUid)
+	{
+		return -1;
+	}
+	virtual int addUserDebugParameter(const char* txt, double rangeMin, double rangeMax, double startValue)
+	{
+		return -1;
+	}
+
+	virtual void removeUserDebugItem(int debugItemUniqueId)
+	{
+	}
+	virtual void removeAllUserDebugItems()
+	{
+	}
+
+	void renderInternalGl2(int pass, const btDiscreteDynamicsWorld* dynamicsWorld);
+
+	void setVRMode(bool vrMode);
+
+	void setVisualizerFlag(int flag, int enable);
+
+	virtual void setVisualizerFlagCallback(VisualizerFlagCallback callback);
+
+	virtual void dumpFramesToVideo(const char* mp4FileName);
+
+	int createCheckeredTexture(int r, int g, int b);
+
+	void computeSoftBodyVertices(btCollisionShape* collisionShape,
+								 btAlignedObjectArray<GLInstanceVertex>& gfxVertices,
+								 btAlignedObjectArray<int>& indices);
+};
+
+#endif  //OPENGL_GUI_HELPER_H
diff --git a/engine/inc/bullet/Experiments/ImplicitCloth/ImplicitClothExample.h b/engine/inc/bullet/Experiments/ImplicitCloth/ImplicitClothExample.h
new file mode 100644
index 00000000..07849e19
--- /dev/null
+++ b/engine/inc/bullet/Experiments/ImplicitCloth/ImplicitClothExample.h
@@ -0,0 +1,6 @@
+#ifndef IMPLICIT_CLOTH_EXAMPLE_H
+#define IMPLICIT_CLOTH_EXAMPLE_H
+
+class CommonExampleInterface* ImplicitClothCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //IMPLICIT_CLOTH_EXAMPLE_H
diff --git a/engine/inc/bullet/Experiments/ImplicitCloth/stan/Cloth.h b/engine/inc/bullet/Experiments/ImplicitCloth/stan/Cloth.h
new file mode 100644
index 00000000..79c334e2
--- /dev/null
+++ b/engine/inc/bullet/Experiments/ImplicitCloth/stan/Cloth.h
@@ -0,0 +1,18 @@
+#ifndef STAN_CLOTH_H
+#define STAN_CLOTH_H
+
+#include "SpringNetwork.h"
+
+class Cloth : public SpringNetwork
+{
+public:
+	int w, h;
+
+	float3 color;  // for debug rendering
+	Cloth(const char* _name, int _n);
+	~Cloth();
+};
+
+Cloth* ClothCreate(int w, int h, float size);
+
+#endif  //STAN_CLOTH_H
diff --git a/engine/inc/bullet/Experiments/ImplicitCloth/stan/SpringNetwork.h b/engine/inc/bullet/Experiments/ImplicitCloth/stan/SpringNetwork.h
new file mode 100644
index 00000000..a59c3d07
--- /dev/null
+++ b/engine/inc/bullet/Experiments/ImplicitCloth/stan/SpringNetwork.h
@@ -0,0 +1,61 @@
+#ifndef STAN_SPRING_NETWORK_H
+#define STAN_SPRING_NETWORK_H
+
+#include "vec3n.h"
+
+#define SPRING_STRUCT (0)
+#define SPRING_SHEAR (1)
+#define SPRING_BEND (2)
+
+class SpringNetwork
+{
+public:
+	class Spring
+	{
+	public:
+		int type;  // index into coefficients spring_k[]
+		float restlen;
+		int a, b;      // spring endpoints vector indices
+		int iab, iba;  // indices into off-diagonal blocks of sparse matrix
+		Spring() {}
+		Spring(int _type, int _a, int _b, float _restlen) : type(_type), a(_a), b(_b), restlen(_restlen) { iab = iba = -1; }
+	};
+	Array<Spring> springs;
+	float3N X;        // positions of all points
+	float3N V;        // velocities
+	float3N F;        // force on each point
+	float3N dV;       // change in velocity
+	float3Nx3N A;     // big matrix we solve system with
+	float3Nx3N dFdX;  // big matrix of derivative of force wrt position
+	float3Nx3N dFdV;  // big matrix of derivative of force wrt velocity
+	float3Nx3N S;     // used for our constraints - contains only some diagonal blocks as needed S[i,i]
+	int awake;
+	float3 bmin, bmax;
+	union {
+		struct
+		{
+			float spring_struct;
+			float spring_shear;
+			float spring_bend;
+		};
+		float spring_k[3];
+	};
+	float spring_damp;
+	float spring_air;
+	float cloth_step;  // delta time for cloth
+	float3 cloth_gravity;
+	float cloth_sleepthreshold;
+	int cloth_sleepcount;
+
+	SpringNetwork(int _n);
+	Spring &AddBlocks(Spring &s);
+	Spring &CreateSpring(int type, int a, int b, float restlen) { return AddBlocks(springs.Add(Spring(type, a, b, restlen))); }
+	Spring &CreateSpring(int type, int a, int b) { return CreateSpring(type, a, b, magnitude(X[b] - X[a])); }
+	void UpdateLimits() { BoxLimits(X.element, X.count, bmin, bmax); }
+	void Wake() { awake = cloth_sleepcount; }
+	void Simulate(float dt);
+	void PreSolveSpring(const Spring &s);
+	void CalcForces();
+};
+
+#endif  //STAN_SPRING_NETWORK_H
diff --git a/engine/inc/bullet/Experiments/ImplicitCloth/stan/array.h b/engine/inc/bullet/Experiments/ImplicitCloth/stan/array.h
new file mode 100644
index 00000000..e422c509
--- /dev/null
+++ b/engine/inc/bullet/Experiments/ImplicitCloth/stan/array.h
@@ -0,0 +1,307 @@
+//
+//  Typical template dynamic array container class.
+//  By S Melax 1998
+//
+// anyone is free to use, inspect, learn from, or ignore
+// the code here as they see fit.
+//
+// A very simple template array class.
+// Its easiest to understand this array
+// class by seeing how it is used in code.
+//
+// For example:
+//     for(i=0;i<myarray.count;i++)
+//         myarray[i] = somefunction(i);
+//
+// When the array runs out of room, it
+// reallocates memory and doubles the size of its
+// storage buffer.  The reason for *doubleing* the amount of
+// memory is so the order of any algorithm using this class
+// is the same as it would be had you used a regular C array.
+// The penalty for reallocating and copying
+// For example consider adding n elements to a list.
+// Lets sum the number of times elements are "copied".
+// The worst case occurs when n=2^k+1 where k is integer.
+// In this case we do a big reallocation when we add the last element.
+// n elements are copied once, n/2 elements are copied twice,
+// n/4 elements are copied 3 times, and so on ...
+//    total == n* (1+1/2 + 1/4 + 1/8 + ...) == n * 2
+// So we do n*2 copies.  Therefore adding n
+// elements to an Array is still O(n).
+// The memory usage is also of the same order as if a C array was used.
+// An Array uses less than double the minimum needed space.  Again, we
+// see that we are within a small constant multiple.
+//
+// Why no "realloc" to avoid the copy when reallocating memory?
+// You have a choice to either use malloc/free and friends
+// or to use new/delete.  Its bad mojo to mix these.  new/delete was
+// chosen to be C++ish and have the array elements constructors/destructors
+// invoked as expected.
+//
+//
+
+#ifndef SM_ARRAY_H
+#define SM_ARRAY_H
+
+#include <assert.h>
+#include <stdio.h>
+
+template <class Type>
+class Array
+{
+public:
+	Array(int s = 0);
+	Array(Array<Type> &array);
+	~Array();
+	void allocate(int s);
+	void SetSize(int s);
+	void Pack();
+	Type &Add(Type);
+	void AddUnique(Type);
+	int Contains(Type);
+	void Insert(Type, int);
+	int IndexOf(Type);
+	void Remove(Type);
+	void DelIndex(int i);
+	Type &DelIndexWithLast(int i);
+	Type *element;
+	int count;
+	int array_size;
+	const Type &operator[](int i) const
+	{
+		assert(i >= 0 && i < count);
+		return element[i];
+	}
+	Type &operator[](int i)
+	{
+		assert(i >= 0 && i < count);
+		return element[i];
+	}
+	Type &Pop()
+	{
+		assert(count);
+		count--;
+		return element[count];
+	}
+	Array<Type> &copy(const Array<Type> &array);
+	Array<Type> &operator=(Array<Type> &array);
+};
+
+template <class Type>
+Array<Type>::Array(int s)
+{
+	if (s == -1) return;
+	count = 0;
+	array_size = 0;
+	element = NULL;
+	if (s)
+	{
+		allocate(s);
+	}
+}
+
+template <class Type>
+Array<Type>::Array(Array<Type> &array)
+{
+	count = 0;
+	array_size = 0;
+	element = NULL;
+	*this = array;
+}
+
+template <class Type>
+Array<Type> &Array<Type>::copy(const Array<Type> &array)
+{
+	assert(array.array_size >= 0);
+	count = 0;
+	for (int i = 0; i < array.count; i++)
+	{
+		Add(array[i]);
+	}
+	return *this;
+}
+template <class Type>
+Array<Type> &Array<Type>::operator=(Array<Type> &array)
+{
+	if (array.array_size < 0)  //  negative number means steal the data buffer instead of copying
+	{
+		delete[] element;
+		element = array.element;
+		array_size = -array.array_size;
+		count = array.count;
+		array.count = array.array_size = 0;
+		array.element = NULL;
+		return *this;
+	}
+	count = 0;
+	for (int i = 0; i < array.count; i++)
+	{
+		Add(array[i]);
+	}
+	return *this;
+}
+
+template <class Type>
+Array<Type>::~Array()
+{
+	if (element != NULL && array_size != 0)
+	{
+		delete[] element;
+	}
+	count = 0;
+	array_size = 0;
+	element = NULL;
+}
+
+template <class Type>
+void Array<Type>::allocate(int s)
+{
+	assert(s > 0);
+	assert(s >= count);
+	if (s == array_size) return;
+	Type *old = element;
+	array_size = s;
+	element = new Type[array_size];
+	assert(element);
+	for (int i = 0; i < count; i++)
+	{
+		element[i] = old[i];
+	}
+	if (old) delete[] old;
+}
+
+template <class Type>
+void Array<Type>::SetSize(int s)
+{
+	if (s == 0)
+	{
+		if (element)
+		{
+			delete[] element;
+			element = NULL;
+		}
+		array_size = s;
+	}
+	else
+	{
+		allocate(s);
+	}
+	count = s;
+}
+
+template <class Type>
+void Array<Type>::Pack()
+{
+	allocate(count);
+}
+
+template <class Type>
+Type &Array<Type>::Add(Type t)
+{
+	assert(count <= array_size);
+	if (count == array_size)
+	{
+		allocate((array_size) ? array_size * 2 : 16);
+	}
+	//int i;
+	//for(i=0;i<count;i++) {
+	// dissallow duplicates
+	//	assert(element[i] != t);
+	//}
+	element[count++] = t;
+	return element[count - 1];
+}
+
+template <class Type>
+int Array<Type>::Contains(Type t)
+{
+	int i;
+	int found = 0;
+	for (i = 0; i < count; i++)
+	{
+		if (element[i] == t) found++;
+	}
+	return found;
+}
+
+template <class Type>
+void Array<Type>::AddUnique(Type t)
+{
+	if (!Contains(t)) Add(t);
+}
+
+template <class Type>
+void Array<Type>::DelIndex(int i)
+{
+	assert(i < count);
+	count--;
+	while (i < count)
+	{
+		element[i] = element[i + 1];
+		i++;
+	}
+}
+
+template <class Type>
+Type &Array<Type>::DelIndexWithLast(int i)
+{
+	assert(i < count);
+	count--;
+	if (i < count)
+	{
+		Type r = element[i];
+		element[i] = element[count];
+		element[count] = r;
+	}
+	return element[count];
+}
+
+template <class Type>
+void Array<Type>::Remove(Type t)
+{
+	int i;
+	for (i = 0; i < count; i++)
+	{
+		if (element[i] == t)
+		{
+			break;
+		}
+	}
+	assert(i < count);  // assert object t is in the array.
+	DelIndex(i);
+	for (i = 0; i < count; i++)
+	{
+		assert(element[i] != t);
+	}
+}
+
+template <class Type>
+void Array<Type>::Insert(Type t, int k)
+{
+	int i = count;
+	Add(t);  // to allocate space
+	while (i > k)
+	{
+		element[i] = element[i - 1];
+		i--;
+	}
+	assert(i == k);
+	element[k] = t;
+}
+
+template <class Type>
+int Array<Type>::IndexOf(Type t)
+{
+	int i;
+	for (i = 0; i < count; i++)
+	{
+		if (element[i] == t)
+		{
+			return i;
+		}
+	}
+	assert(0);
+	return -1;
+}
+
+#endif
diff --git a/engine/inc/bullet/Experiments/ImplicitCloth/stan/vec3n.h b/engine/inc/bullet/Experiments/ImplicitCloth/stan/vec3n.h
new file mode 100644
index 00000000..c4db53d6
--- /dev/null
+++ b/engine/inc/bullet/Experiments/ImplicitCloth/stan/vec3n.h
@@ -0,0 +1,435 @@
+//
+// Big Vector and Sparse Matrix Classes
+//
+//   (c) S Melax 2006
+//
+// The focus is on 3D applications, so
+// the big vector is an array of float3s
+// and the matrix class uses 3x3 blocks.
+//
+// This file includes both:
+//  - basic non-optimized version
+//  - an expression optimized version
+//
+// Optimized Expressions
+//
+// We want to write sweet looking code such as V=As+Bt with big vectors.
+// However, we dont want the extra overheads with allocating memory for temps and excessing copying.
+// Instead of a full Template Metaprogramming approach, we explicitly write
+// classes to specifically handle all the expressions we are likely to use.
+// Most applicable lines of code will be of the same handful of basic forms,
+// but with different parameters for the operands.
+// In the future, if we ever need a longer expression with more operands,
+// then we will just add whatever additional building blocks that are necessary - not a big deal.
+// This approach is much simpler to develop, debug and optimize (restrict keyword, simd etc)
+// than template metaprogramming is.  We do not rely on the implementation
+// of a particular compiler to be able to expand extensive nested inline codes.
+// Additionally, we reliably get our optimizations even within a debug build.
+// Therefore we believe that our Optimized Expressions
+// are a good compromise that give us the best of both worlds.
+// The code within those important algorithms, which use this library,
+// can now remain clean and readable yet still execute quickly.
+//
+
+#ifndef SM_VEC3N_H
+#define SM_VEC3N_H
+
+#include "vecmath.h"
+#include "array.h"
+
+//#include <malloc.h>
+//template <class T> void * vec4<T>::operator new[](size_t n){ return _mm_malloc(n,64); }
+//template <class T> void vec4<T>::operator delete[](void *a) { _mm_free(a); }
+
+struct HalfConstraint
+{
+	float3 n;
+	int vi;
+	float s, t;
+	HalfConstraint(const float3 &_n, int _vi, float _t) : n(_n), vi(_vi), s(0), t(_t) {}
+	HalfConstraint() : vi(-1) {}
+};
+
+class float3Nx3N
+{
+public:
+	class Block
+	{
+	public:
+		float3x3 m;
+		int r, c;
+		float unused[16];
+
+		Block() {}
+		Block(short _r, short _c) : r(_r), c(_c) { m.x = m.y = m.z = float3(0, 0, 0); }
+	};
+	Array<Block> blocks;  // the first n blocks use as the diagonal.
+	int n;
+	void Zero();
+	void InitDiagonal(float d);
+	void Identity() { InitDiagonal(1.0f); }
+	float3Nx3N() : n(0) {}
+	float3Nx3N(int _n) : n(_n)
+	{
+		for (int i = 0; i < n; i++) blocks.Add(Block((short)i, (short)i));
+	}
+	template <class E>
+	float3Nx3N &operator=(const E &expression)
+	{
+		expression.evalequals(*this);
+		return *this;
+	}
+	template <class E>
+	float3Nx3N &operator+=(const E &expression)
+	{
+		expression.evalpluseq(*this);
+		return *this;
+	}
+	template <class E>
+	float3Nx3N &operator-=(const E &expression)
+	{
+		expression.evalmnuseq(*this);
+		return *this;
+	}
+};
+
+class float3N : public Array<float3>
+{
+public:
+	float3N(int _count = 0)
+	{
+		SetSize(_count);
+	}
+	void Zero();
+	void Init(const float3 &v);  // sets each subvector to v
+	template <class E>
+	float3N &operator=(const E &expression)
+	{
+		expression.evalequals(*this);
+		return *this;
+	}
+	template <class E>
+	float3N &operator+=(const E &expression)
+	{
+		expression.evalpluseq(*this);
+		return *this;
+	}
+	template <class E>
+	float3N &operator-=(const E &expression)
+	{
+		expression.evalmnuseq(*this);
+		return *this;
+	}
+	float3N &operator=(const float3N &V)
+	{
+		this->copy(V);
+		return *this;
+	}
+};
+
+int ConjGradient(float3N &X, float3Nx3N &A, float3N &B);
+int ConjGradientFiltered(float3N &X, const float3Nx3N &A, const float3N &B, const float3Nx3N &S, Array<HalfConstraint> &H);
+int ConjGradientFiltered(float3N &X, const float3Nx3N &A, const float3N &B, const float3Nx3N &S);
+
+inline float3N &Mul(float3N &r, const float3Nx3N &m, const float3N &v)
+{
+	int i;
+	for (i = 0; i < r.count; i++) r[i] = float3(0, 0, 0);
+	for (i = 0; i < m.blocks.count; i++)
+	{
+		r[m.blocks[i].r] += m.blocks[i].m * v[m.blocks[i].c];
+	}
+	return r;
+}
+
+inline float dot(const float3N &a, const float3N &b)
+{
+	float d = 0;
+	for (int i = 0; i < a.count; i++)
+	{
+		d += dot(a[i], b[i]);
+	}
+	return d;
+}
+
+inline void float3Nx3N::Zero()
+{
+	for (int i = 0; i < blocks.count; i++)
+	{
+		blocks[i].m = float3x3(0, 0, 0, 0, 0, 0, 0, 0, 0);
+	}
+}
+
+inline void float3Nx3N::InitDiagonal(float d)
+{
+	for (int i = 0; i < blocks.count; i++)
+	{
+		blocks[i].m = (blocks[i].c == blocks[i].r) ? float3x3(d, 0, 0, 0, d, 0, 0, 0, d) : float3x3(0, 0, 0, 0, 0, 0, 0, 0, 0);
+	}
+}
+
+inline void float3N::Zero()
+{
+	for (int i = 0; i < count; i++)
+	{
+		element[i] = float3(0, 0, 0);
+	}
+}
+
+inline void float3N::Init(const float3 &v)
+{
+	for (int i = 0; i < count; i++)
+	{
+		element[i] = v;
+	}
+}
+
+#ifdef WE_LIKE_SLOW_CODE
+
+// Unoptimized Slow Basic Version of big vector operators.
+// Uses typical implmentation for operators +/-*=
+// These operators cause lots of unnecessary construction, memory allocation, and copying.
+
+inline float3N operator+(const float3N &a, const float3N &b)
+{
+	float3N r(a.count);
+	for (int i = 0; i < a.count; i++) r[i] = a[i] + b[i];
+	return r;
+}
+
+inline float3N operator*(const float3N &a, const float &s)
+{
+	float3N r(a.count);
+	for (int i = 0; i < a.count; i++) r[i] = a[i] * s;
+	return r;
+}
+inline float3N operator/(const float3N &a, const float &s)
+{
+	float3N r(a.count);
+	return Mul(r, a, 1.0f / s);
+}
+inline float3N operator-(const float3N &a, const float3N &b)
+{
+	float3N r(a.count);
+	for (int i = 0; i < a.count; i++) r[i] = a[i] - b[i];
+	return r;
+}
+inline float3N operator-(const float3N &a)
+{
+	float3N r(a.count);
+	for (int i = 0; i < a.count; i++) r[i] = -a[i];
+	return r;
+}
+
+inline float3N operator*(const float3Nx3N &m, const float3N &v)
+{
+	float3N r(v.count);
+	return Mul(r, m, v);
+}
+inline float3N &operator-=(float3N &A, const float3N &B)
+{
+	assert(A.count == B.count);
+	for (int i = 0; i < A.count; i++) A[i] -= B[i];
+	return A;
+}
+inline float3N &operator+=(float3N &A, const float3N &B)
+{
+	assert(A.count == B.count);
+	for (int i = 0; i < A.count; i++) A[i] += B[i];
+	return A;
+}
+
+#else
+
+// Optimized Expressions
+
+class exVneg
+{
+public:
+	const float3N &v;
+	exVneg(const float3N &_v) : v(_v) {}
+	void evalequals(float3N &r) const
+	{
+		for (int i = 0; i < v.count; i++) r[i] = -v[i];
+	}
+	void evalpluseq(float3N &r) const
+	{
+		for (int i = 0; i < v.count; i++) r[i] += -v[i];
+	}
+	void evalmnuseq(float3N &r) const
+	{
+		for (int i = 0; i < v.count; i++) r[i] -= -v[i];
+	}
+};
+
+class exVaddV
+{
+public:
+	const float3N &a;
+	const float3N &b;
+	exVaddV(const float3N &_a, const float3N &_b) : a(_a), b(_b) {}
+	void evalequals(float3N &r) const
+	{
+		for (int i = 0; i < a.count; i++) r[i] = a[i] + b[i];
+	}
+	void evalpluseq(float3N &r) const
+	{
+		for (int i = 0; i < a.count; i++) r[i] += a[i] + b[i];
+	}
+	void evalmnuseq(float3N &r) const
+	{
+		for (int i = 0; i < a.count; i++) r[i] -= a[i] + b[i];
+	}
+};
+
+class exVsubV
+{
+public:
+	const float3N &a;
+	const float3N &b;
+	exVsubV(const float3N &_a, const float3N &_b) : a(_a), b(_b) {}
+	void evalequals(float3N &r) const
+	{
+		for (int i = 0; i < a.count; i++) r[i] = a[i] - b[i];
+	}
+	void evalpluseq(float3N &r) const
+	{
+		for (int i = 0; i < a.count; i++) r[i] += a[i] - b[i];
+	}
+	void evalmnuseq(float3N &r) const
+	{
+		for (int i = 0; i < a.count; i++) r[i] -= a[i] - b[i];
+	}
+};
+
+class exVs
+{
+public:
+	const float3N &v;
+	const float s;
+	exVs(const float3N &_v, const float &_s) : v(_v), s(_s) {}
+	void evalequals(float3N &r) const
+	{
+		for (int i = 0; i < v.count; i++) r[i] = v[i] * s;
+	}
+	void evalpluseq(float3N &r) const
+	{
+		for (int i = 0; i < v.count; i++) r[i] += v[i] * s;
+	}
+	void evalmnuseq(float3N &r) const
+	{
+		for (int i = 0; i < v.count; i++) r[i] -= v[i] * s;
+	}
+};
+class exAsaddB
+{
+public:
+	const float3N &a;
+	const float3N &b;
+	const float s;
+	exAsaddB(const float3N &_a, const float &_s, const float3N &_b) : a(_a), s(_s), b(_b) {}
+	void evalequals(float3N &r) const
+	{
+		for (int i = 0; i < a.count; i++) r[i] = a[i] * s + b[i];
+	}
+	void evalpluseq(float3N &r) const
+	{
+		for (int i = 0; i < a.count; i++) r[i] += a[i] * s + b[i];
+	}
+	void evalmnuseq(float3N &r) const
+	{
+		for (int i = 0; i < a.count; i++) r[i] -= a[i] * s + b[i];
+	}
+};
+class exAsaddBt
+{
+public:
+	const float3N &a;
+	const float3N &b;
+	const float s;
+	const float t;
+	exAsaddBt(const float3N &_a, const float &_s, const float3N &_b, const float &_t) : a(_a), s(_s), b(_b), t(_t) {}
+	void evalequals(float3N &r) const
+	{
+		for (int i = 0; i < a.count; i++) r[i] = a[i] * s + b[i] * t;
+	}
+	void evalpluseq(float3N &r) const
+	{
+		for (int i = 0; i < a.count; i++) r[i] += a[i] * s + b[i] * t;
+	}
+	void evalmnuseq(float3N &r) const
+	{
+		for (int i = 0; i < a.count; i++) r[i] -= a[i] * s + b[i] * t;
+	}
+};
+
+class exMv
+{
+public:
+	const float3Nx3N &m;
+	const float3N &v;
+	exMv(const float3Nx3N &_m, const float3N &_v) : m(_m), v(_v) {}
+	void evalequals(float3N &r) const { Mul(r, m, v); }
+};
+
+class exMs
+{
+public:
+	const float3Nx3N &m;
+	const float s;
+	exMs(const float3Nx3N &_m, const float &_s) : m(_m), s(_s) {}
+	void evalequals(float3Nx3N &r) const
+	{
+		for (int i = 0; i < r.blocks.count; i++) r.blocks[i].m = m.blocks[i].m * s;
+	}
+	void evalpluseq(float3Nx3N &r) const
+	{
+		for (int i = 0; i < r.blocks.count; i++) r.blocks[i].m += m.blocks[i].m * s;
+	}
+	void evalmnuseq(float3Nx3N &r) const
+	{
+		for (int i = 0; i < r.blocks.count; i++) r.blocks[i].m -= m.blocks[i].m * s;
+	}
+};
+
+class exMAsMBt
+{
+public:
+	const float3Nx3N &a;
+	const float s;
+	const float3Nx3N &b;
+	const float t;
+	exMAsMBt(const float3Nx3N &_a, const float &_s, const float3Nx3N &_b, const float &_t) : a(_a), s(_s), b(_b), t(_t) {}
+	void evalequals(float3Nx3N &r) const
+	{
+		for (int i = 0; i < r.blocks.count; i++) r.blocks[i].m = a.blocks[i].m * s + b.blocks[i].m * t;
+	}
+	void evalpluseq(float3Nx3N &r) const
+	{
+		for (int i = 0; i < r.blocks.count; i++) r.blocks[i].m += a.blocks[i].m * s + b.blocks[i].m * t;
+	}
+	void evalmnuseq(float3Nx3N &r) const
+	{
+		for (int i = 0; i < r.blocks.count; i++) r.blocks[i].m -= a.blocks[i].m * s + b.blocks[i].m * t;
+	}
+};
+
+inline exVaddV operator+(const float3N &a, const float3N &b) { return exVaddV(a, b); }
+inline exVsubV operator+(const exVneg &E, const float3N &b) { return exVsubV(b, E.v); }
+inline exVsubV operator-(const float3N &a, const float3N &b) { return exVsubV(a, b); }
+inline exVs operator*(const float3N &V, const float &s) { return exVs(V, s); }
+inline exVs operator*(const exVs &E, const float &s) { return exVs(E.v, E.s * s); }
+inline exAsaddB operator+(const exVs &E, const float3N &b) { return exAsaddB(E.v, E.s, b); }
+inline exAsaddB operator+(const float3N &b, const exVs &E) { return exAsaddB(E.v, E.s, b); }
+inline exAsaddB operator-(const float3N &b, const exVs &E) { return exAsaddB(E.v, -E.s, b); }
+inline exAsaddBt operator+(const exVs &Ea, const exVs &Eb) { return exAsaddBt(Ea.v, Ea.s, Eb.v, Eb.s); }
+inline exAsaddBt operator-(const exVs &Ea, const exVs &Eb) { return exAsaddBt(Ea.v, Ea.s, Eb.v, -Eb.s); }
+inline exMv operator*(const float3Nx3N &m, const float3N &v) { return exMv(m, v); }
+inline exMs operator*(const exMs &E, const float &s) { return exMs(E.m, E.s * s); }
+inline exMs operator*(const float3Nx3N &m, const float &s) { return exMs(m, s); }
+inline exMAsMBt operator+(const exMs &Ea, const exMs &Eb) { return exMAsMBt(Ea.m, Ea.s, Eb.m, Eb.s); }
+inline exMAsMBt operator-(const exMs &Ea, const exMs &Eb) { return exMAsMBt(Ea.m, Ea.s, Eb.m, -Eb.s); }
+
+#endif
+
+#endif
diff --git a/engine/inc/bullet/Experiments/ImplicitCloth/stan/vecmath.h b/engine/inc/bullet/Experiments/ImplicitCloth/stan/vecmath.h
new file mode 100644
index 00000000..c219eb13
--- /dev/null
+++ b/engine/inc/bullet/Experiments/ImplicitCloth/stan/vecmath.h
@@ -0,0 +1,723 @@
+//
+//
+//  Typical 3d vector math code.
+//  By S Melax 1998-2008
+//
+//
+
+#ifndef SM_VEC_MATH_H
+#define SM_VEC_MATH_H
+
+#include <stdio.h>
+#include <math.h>
+#include <assert.h>
+#include <xmmintrin.h>
+
+#define M_PIf (3.1415926535897932384626433832795f)
+
+inline float DegToRad(float angle_degrees) { return angle_degrees * M_PIf / 180.0f; }  // returns Radians.
+inline float RadToDeg(float angle_radians) { return angle_radians * 180.0f / M_PIf; }  // returns Degrees.
+
+#define OFFSET(Class, Member) (((char *)(&(((Class *)NULL)->Member))) - ((char *)NULL))
+
+int argmin(const float a[], int n);
+int argmax(const float a[], int n);
+float squared(float a);
+float clamp(float a, const float minval = 0.0f, const float maxval = 1.0f);
+int clamp(int a, const int minval, const int maxval);
+float Round(float a, float precision);
+float Interpolate(const float &f0, const float &f1, float alpha);
+
+template <class T>
+void Swap(T &a, T &b)
+{
+	T tmp = a;
+	a = b;
+	b = tmp;
+}
+
+template <class T>
+T Max(const T &a, const T &b)
+{
+	return (a > b) ? a : b;
+}
+
+template <class T>
+T Min(const T &a, const T &b)
+{
+	return (a < b) ? a : b;
+}
+
+//for template normalize functions:
+inline float squareroot(float a) { return sqrtf(a); }
+inline double squareroot(double a) { return sqrt(a); }
+
+//----------------------------------
+
+//-------- 2D --------
+
+template <class T>
+class vec2
+{
+public:
+	T x, y;
+	inline vec2()
+	{
+		x = 0;
+		y = 0;
+	}
+	inline vec2(const T &_x, const T &_y)
+	{
+		x = _x;
+		y = _y;
+	}
+	inline T &operator[](int i) { return ((T *)this)[i]; }
+	inline const T &operator[](int i) const { return ((T *)this)[i]; }
+};
+
+typedef vec2<int> int2;
+typedef vec2<float> float2;
+
+template <class T>
+inline int operator==(const vec2<T> &a, const vec2<T> &b)
+{
+	return (a.x == b.x && a.y == b.y);
+}
+template <class T>
+inline vec2<T> operator-(const vec2<T> &a, const vec2<T> &b)
+{
+	return vec2<T>(a.x - b.x, a.y - b.y);
+}
+template <class T>
+inline vec2<T> operator+(const vec2<T> &a, const vec2<T> &b)
+{
+	return float2(a.x + b.x, a.y + b.y);
+}
+
+//--------- 3D ---------
+
+template <class T>
+class vec3
+{
+public:
+	T x, y, z;
+	inline vec3()
+	{
+		x = 0;
+		y = 0;
+		z = 0;
+	};
+	inline vec3(const T &_x, const T &_y, const T &_z)
+	{
+		x = _x;
+		y = _y;
+		z = _z;
+	};
+	inline T &operator[](int i) { return ((T *)this)[i]; }
+	inline const T &operator[](int i) const { return ((T *)this)[i]; }
+};
+
+typedef vec3<int> int3;
+typedef vec3<short> short3;
+typedef vec3<float> float3;
+
+// due to ambiguity there is no overloaded operators for v3*v3 use dot,cross,outerprod,cmul
+template <class T>
+inline int operator==(const vec3<T> &a, const vec3<T> &b)
+{
+	return (a.x == b.x && a.y == b.y && a.z == b.z);
+}
+template <class T>
+inline int operator!=(const vec3<T> &a, const vec3<T> &b)
+{
+	return !(a == b);
+}
+template <class T>
+inline vec3<T> operator+(const vec3<T> &a, const vec3<T> &b)
+{
+	return vec3<T>(a.x + b.x, a.y + b.y, a.z + b.z);
+}
+template <class T>
+inline vec3<T> operator-(const vec3<T> &a, const vec3<T> &b)
+{
+	return vec3<T>(a.x - b.x, a.y - b.y, a.z - b.z);
+}
+template <class T>
+inline vec3<T> operator-(const vec3<T> &v)
+{
+	return vec3<T>(-v.x, -v.y, -v.z);
+}
+template <class T>
+inline vec3<T> operator*(const vec3<T> &v, const T &s)
+{
+	return vec3<T>(v.x * s, v.y * s, v.z * s);
+}
+template <class T>
+inline vec3<T> operator*(T s, const vec3<T> &v)
+{
+	return v * s;
+}
+template <class T>
+inline vec3<T> operator/(const vec3<T> &v, T s)
+{
+	return vec3<T>(v.x / s, v.y / s, v.z / s);
+}
+template <class T>
+inline T dot(const vec3<T> &a, const vec3<T> &b)
+{
+	return a.x * b.x + a.y * b.y + a.z * b.z;
+}
+template <class T>
+inline vec3<T> cmul(const vec3<T> &a, const vec3<T> &b)
+{
+	return vec3<T>(a.x * b.x, a.y * b.y, a.z * b.z);
+}
+template <class T>
+inline vec3<T> cross(const vec3<T> &a, const vec3<T> &b)
+{
+	return vec3<T>(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x);
+}
+template <class T>
+inline T magnitude(const vec3<T> &v)
+{
+	return squareroot(dot(v, v));
+}
+template <class T>
+inline vec3<T> normalize(const vec3<T> &v)
+{
+	return v / magnitude(v);
+}
+template <class T>
+inline vec3<T> &operator+=(vec3<T> &a, const vec3<T> &b)
+{
+	a.x += b.x;
+	a.y += b.y;
+	a.z += b.z;
+	return a;
+}
+template <class T>
+inline vec3<T> &operator-=(vec3<T> &a, const vec3<T> &b)
+{
+	a.x -= b.x;
+	a.y -= b.y;
+	a.z -= b.z;
+	return a;
+}
+template <class T>
+inline vec3<T> &operator*=(vec3<T> &v, T s)
+{
+	v.x *= s;
+	v.y *= s;
+	v.z *= s;
+	return v;
+}
+template <class T>
+inline vec3<T> &operator/=(vec3<T> &v, T s)
+{
+	v.x /= s;
+	v.y /= s;
+	v.z /= s;
+	return v;
+}
+
+float3 safenormalize(const float3 &v);
+float3 vabs(const float3 &v);
+float3 Interpolate(const float3 &v0, const float3 &v1, float alpha);
+float3 Round(const float3 &a, float precision);
+template <class T>
+inline vec3<T> VectorMin(const vec3<T> &a, const vec3<T> &b)
+{
+	return vec3<T>(Min(a.x, b.x), Min(a.y, b.y), Min(a.z, b.z));
+}
+template <class T>
+inline vec3<T> VectorMax(const vec3<T> &a, const vec3<T> &b)
+{
+	return vec3<T>(Max(a.x, b.x), Max(a.y, b.y), Max(a.z, b.z));
+}
+int overlap(const float3 &bmina, const float3 &bmaxa, const float3 &bminb, const float3 &bmaxb);
+
+template <class T>
+class mat3x3
+{
+public:
+	vec3<T> x, y, z;  // the 3 rows of the Matrix
+	inline mat3x3() {}
+	inline mat3x3(const T &xx, const T &xy, const T &xz, const T &yx, const T &yy, const T &yz, const T &zx, const T &zy, const T &zz) : x(xx, xy, xz), y(yx, yy, yz), z(zx, zy, zz) {}
+	inline mat3x3(const vec3<T> &_x, const vec3<T> &_y, const vec3<T> &_z) : x(_x), y(_y), z(_z) {}
+	inline vec3<T> &operator[](int i) { return (&x)[i]; }
+	inline const vec3<T> &operator[](int i) const { return (&x)[i]; }
+	inline T &operator()(int r, int c) { return ((&x)[r])[c]; }
+	inline const T &operator()(int r, int c) const { return ((&x)[r])[c]; }
+};
+typedef mat3x3<float> float3x3;
+
+float3x3 Transpose(const float3x3 &m);
+template <class T>
+vec3<T> operator*(const vec3<T> &v, const mat3x3<T> &m)
+{
+	return vec3<T>((m.x.x * v.x + m.y.x * v.y + m.z.x * v.z),
+				   (m.x.y * v.x + m.y.y * v.y + m.z.y * v.z),
+				   (m.x.z * v.x + m.y.z * v.y + m.z.z * v.z));
+}
+
+float3 operator*(const float3x3 &m, const float3 &v);
+float3x3 operator*(const float3x3 &m, const float &s);
+float3x3 operator*(const float3x3 &ma, const float3x3 &mb);
+float3x3 operator/(const float3x3 &a, const float &s);
+float3x3 operator+(const float3x3 &a, const float3x3 &b);
+float3x3 operator-(const float3x3 &a, const float3x3 &b);
+float3x3 &operator+=(float3x3 &a, const float3x3 &b);
+float3x3 &operator-=(float3x3 &a, const float3x3 &b);
+float3x3 &operator*=(float3x3 &a, const float &s);
+float Determinant(const float3x3 &m);
+float3x3 Inverse(const float3x3 &a);  // its just 3x3 so we simply do that cofactor method
+float3x3 outerprod(const float3 &a, const float3 &b);
+
+//-------- 4D Math --------
+
+template <class T>
+class vec4
+{
+public:
+	T x, y, z, w;
+	inline vec4()
+	{
+		x = 0;
+		y = 0;
+		z = 0;
+		w = 0;
+	};
+	inline vec4(const T &_x, const T &_y, const T &_z, const T &_w)
+	{
+		x = _x;
+		y = _y;
+		z = _z;
+		w = _w;
+	}
+	inline vec4(const vec3<T> &v, const T &_w)
+	{
+		x = v.x;
+		y = v.y;
+		z = v.z;
+		w = _w;
+	}
+	//operator float *() { return &x;};
+	T &operator[](int i) { return ((T *)this)[i]; }
+	const T &operator[](int i) const { return ((T *)this)[i]; }
+	inline const vec3<T> &xyz() const { return *((vec3<T> *)this); }
+	inline vec3<T> &xyz() { return *((vec3<T> *)this); }
+};
+
+typedef vec4<float> float4;
+typedef vec4<int> int4;
+typedef vec4<unsigned char> byte4;
+
+template <class T>
+inline int operator==(const vec4<T> &a, const vec4<T> &b)
+{
+	return (a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w);
+}
+template <class T>
+inline int operator!=(const vec4<T> &a, const vec4<T> &b)
+{
+	return !(a == b);
+}
+template <class T>
+inline vec4<T> operator+(const vec4<T> &a, const vec4<T> &b)
+{
+	return vec4<T>(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w);
+}
+template <class T>
+inline vec4<T> operator-(const vec4<T> &a, const vec4<T> &b)
+{
+	return vec4<T>(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w);
+}
+template <class T>
+inline vec4<T> operator-(const vec4<T> &v)
+{
+	return vec4<T>(-v.x, -v.y, -v.z, -v.w);
+}
+template <class T>
+inline vec4<T> operator*(const vec4<T> &v, const T &s)
+{
+	return vec4<T>(v.x * s, v.y * s, v.z * s, v.w * s);
+}
+template <class T>
+inline vec4<T> operator*(T s, const vec4<T> &v)
+{
+	return v * s;
+}
+template <class T>
+inline vec4<T> operator/(const vec4<T> &v, T s)
+{
+	return vec4<T>(v.x / s, v.y / s, v.z / s, v.w / s);
+}
+template <class T>
+inline T dot(const vec4<T> &a, const vec4<T> &b)
+{
+	return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
+}
+template <class T>
+inline vec4<T> cmul(const vec4<T> &a, const vec4<T> &b)
+{
+	return vec4<T>(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w);
+}
+template <class T>
+inline vec4<T> &operator+=(vec4<T> &a, const vec4<T> &b)
+{
+	a.x += b.x;
+	a.y += b.y;
+	a.z += b.z;
+	a.w += b.w;
+	return a;
+}
+template <class T>
+inline vec4<T> &operator-=(vec4<T> &a, const vec4<T> &b)
+{
+	a.x -= b.x;
+	a.y -= b.y;
+	a.z -= b.z;
+	a.w -= b.w;
+	return a;
+}
+template <class T>
+inline vec4<T> &operator*=(vec4<T> &v, T s)
+{
+	v.x *= s;
+	v.y *= s;
+	v.z *= s;
+	v.w *= s;
+	return v;
+}
+template <class T>
+inline vec4<T> &operator/=(vec4<T> &v, T s)
+{
+	v.x /= s;
+	v.y /= s;
+	v.z /= s;
+	v.w /= s;
+	return v;
+}
+template <class T>
+inline T magnitude(const vec4<T> &v)
+{
+	return squareroot(dot(v, v));
+}
+template <class T>
+inline vec4<T> normalize(const vec4<T> &v)
+{
+	return v / magnitude(v);
+}
+
+struct D3DXMATRIX;
+
+template <class T>
+class mat4x4
+{
+public:
+	vec4<T> x, y, z, w;  // the 4 rows
+	inline mat4x4() {}
+	inline mat4x4(const vec4<T> &_x, const vec4<T> &_y, const vec4<T> &_z, const vec4<T> &_w) : x(_x), y(_y), z(_z), w(_w) {}
+	inline mat4x4(const T &m00, const T &m01, const T &m02, const T &m03,
+				  const T &m10, const T &m11, const T &m12, const T &m13,
+				  const T &m20, const T &m21, const T &m22, const T &m23,
+				  const T &m30, const T &m31, const T &m32, const T &m33)
+		: x(m00, m01, m02, m03), y(m10, m11, m12, m13), z(m20, m21, m22, m23), w(m30, m31, m32, m33) {}
+	inline vec4<T> &operator[](int i)
+	{
+		assert(i >= 0 && i < 4);
+		return (&x)[i];
+	}
+	inline const vec4<T> &operator[](int i) const
+	{
+		assert(i >= 0 && i < 4);
+		return (&x)[i];
+	}
+	inline T &operator()(int r, int c)
+	{
+		assert(r >= 0 && r < 4 && c >= 0 && c < 4);
+		return ((&x)[r])[c];
+	}
+	inline const T &operator()(int r, int c) const
+	{
+		assert(r >= 0 && r < 4 && c >= 0 && c < 4);
+		return ((&x)[r])[c];
+	}
+	inline operator T *() { return &x.x; }
+	inline operator const T *() const { return &x.x; }
+	operator struct D3DXMATRIX *() { return (struct D3DXMATRIX *)this; }
+	operator const struct D3DXMATRIX *() const { return (struct D3DXMATRIX *)this; }
+};
+
+typedef mat4x4<float> float4x4;
+
+float4x4 operator*(const float4x4 &a, const float4x4 &b);
+float4 operator*(const float4 &v, const float4x4 &m);
+float4x4 Inverse(const float4x4 &m);
+float4x4 MatrixRigidInverse(const float4x4 &m);
+float4x4 MatrixTranspose(const float4x4 &m);
+float4x4 MatrixPerspectiveFov(float fovy, float Aspect, float zn, float zf);
+float4x4 MatrixTranslation(const float3 &t);
+float4x4 MatrixRotationZ(const float angle_radians);
+float4x4 MatrixLookAt(const float3 &eye, const float3 &at, const float3 &up);
+int operator==(const float4x4 &a, const float4x4 &b);
+
+//-------- Quaternion ------------
+
+template <class T>
+class quaternion : public vec4<T>
+{
+public:
+	inline quaternion()
+	{
+		this->x = this->y = this->z = 0.0f;
+		this->w = 1.0f;
+	}
+	inline quaternion(const T &_x, const T &_y, const T &_z, const T &_w)
+	{
+		this->x = _x;
+		this->y = _y;
+		this->z = _z;
+		this->w = _w;
+	}
+	inline explicit quaternion(const vec4<T> &v) : vec4<T>(v) {}
+	T angle() const { return acosf(this->w) * 2.0f; }
+	vec3<T> axis() const
+	{
+		vec3<T> a(this->x, this->y, this->z);
+		if (fabsf(angle()) < 0.0000001f) return vec3<T>(1, 0, 0);
+		return a * (1 / sinf(angle() / 2.0f));
+	}
+	inline vec3<T> xdir() const { return vec3<T>(1 - 2 * (this->y * this->y + this->z * this->z), 2 * (this->x * this->y + this->w * this->z),
+												 2 * (this->x * this->z - this->w * this->y)); }
+	inline vec3<T> ydir() const { return vec3<T>(2 * (this->x * this->y - this->w * this->z), 1 - 2 * (this->x * this->x + this->z * this->z), 2 * (this->y * this->z + this->w * this->x)); }
+	inline vec3<T> zdir() const { return vec3<T>(2 * (this->x * this->z + this->w * this->y),
+												 2 * (this->y * this->z - this->w * this->x), 1 - 2 * (this->x * this->x + this->y * this->y)); }
+	inline mat3x3<T> getmatrix() const { return mat3x3<T>(xdir(), ydir(), zdir()); }
+	//operator float3x3() { return getmatrix(); }
+	void Normalize();
+};
+
+template <class T>
+inline quaternion<T> quatfrommat(const mat3x3<T> &m)
+{
+	T magw = m[0][0] + m[1][1] + m[2][2];
+	T magxy;
+	T magzw;
+	vec3<T> pre;
+	vec3<T> prexy;
+	vec3<T> prezw;
+	quaternion<T> postxy;
+	quaternion<T> postzw;
+	quaternion<T> post;
+	int wvsz = (magw > m[2][2]);
+	magzw = (wvsz) ? magw : m[2][2];
+	prezw = (wvsz) ? vec3<T>(1.0f, 1.0f, 1.0f) : vec3<T>(-1.0f, -1.0f, 1.0f);
+	postzw = (wvsz) ? quaternion<T>(0.0f, 0.0f, 0.0f, 1.0f) : quaternion<T>(0.0f, 0.0f, 1.0f, 0.0f);
+	int xvsy = (m[0][0] > m[1][1]);
+	magxy = (xvsy) ? m[0][0] : m[1][1];
+	prexy = (xvsy) ? vec3<T>(1.0f, -1.0f, -1.0f) : vec3<T>(-1.0f, 1.0f, -1.0f);
+	postxy = (xvsy) ? quaternion<T>(1.0f, 0.0f, 0.0f, 0.0f) : quaternion<T>(0.0f, 1.0f, 0.0f, 0.0f);
+	int zwvsxy = (magzw > magxy);
+	pre = (zwvsxy) ? prezw : prexy;
+	post = (zwvsxy) ? postzw : postxy;
+
+	T t = pre.x * m[0][0] + pre.y * m[1][1] + pre.z * m[2][2] + 1.0f;
+	T s = 1 / sqrt(t) * 0.5f;
+	quaternion<T> qp;
+	qp.x = (pre.y * m[1][2] - pre.z * m[2][1]) * s;
+	qp.y = (pre.z * m[2][0] - pre.x * m[0][2]) * s;
+	qp.z = (pre.x * m[0][1] - pre.y * m[1][0]) * s;
+	qp.w = t * s;
+	return qp * post;
+}
+
+typedef quaternion<float> Quaternion;
+
+inline Quaternion QuatFromAxisAngle(const float3 &_v, float angle_radians)
+{
+	float3 v = normalize(_v) * sinf(angle_radians / 2.0f);
+	return Quaternion(v.x, v.y, v.z, cosf(angle_radians / 2.0f));
+}
+
+template <class T>
+inline quaternion<T> Conjugate(const quaternion<T> &q)
+{
+	return quaternion<T>(-q.x, -q.y, -q.z, q.w);
+}
+template <class T>
+inline quaternion<T> Inverse(const quaternion<T> &q)
+{
+	return Conjugate(q);
+}
+template <class T>
+inline quaternion<T> normalize(const quaternion<T> &a)
+{
+	return quaternion<T>(normalize((vec4<T> &)a));
+}
+template <class T>
+inline quaternion<T> &operator*=(quaternion<T> &a, T s)
+{
+	return (quaternion<T> &)((vec4<T> &)a *= s);
+}
+template <class T>
+inline quaternion<T> operator*(const quaternion<T> &a, float s)
+{
+	return quaternion<T>((vec4<T> &)a * s);
+}
+template <class T>
+inline quaternion<T> operator+(const quaternion<T> &a, const quaternion<T> &b)
+{
+	return quaternion<T>((vec4<T> &)a + (vec4<T> &)b);
+}
+template <class T>
+inline quaternion<T> operator-(const quaternion<T> &a, const quaternion<T> &b)
+{
+	return quaternion<T>((vec4<T> &)a - (vec4<T> &)b);
+}
+template <class T>
+inline quaternion<T> operator-(const quaternion<T> &b)
+{
+	return quaternion<T>(-(vec4<T> &)b);
+}
+template <class T>
+inline quaternion<T> operator*(const quaternion<T> &a, const quaternion<T> &b)
+{
+	return quaternion<T>(
+		a.w * b.x + a.x * b.w + a.y * b.z - a.z * b.y,   //x
+		a.w * b.y - a.x * b.z + a.y * b.w + a.z * b.x,   //y
+		a.w * b.z + a.x * b.y - a.y * b.x + a.z * b.w,   //z
+		a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z);  //w
+}
+
+float3 rotate(const Quaternion &q, const float3 &v);
+//float3		operator*( const Quaternion& q, const float3& v );
+//float3		operator*( const float3& v, const Quaternion& q );
+
+Quaternion slerp(const Quaternion &a, const Quaternion &b, float t);
+Quaternion Interpolate(const Quaternion &q0, const Quaternion &q1, float t);
+Quaternion RotationArc(float3 v0, float3 v1);  // returns quat q where q*v0*q^-1=v1
+float4x4 MatrixFromQuatVec(const Quaternion &q, const float3 &v);
+
+inline Quaternion QuatFromMat(const float3 &t, const float3 &b, const float3 &n)
+{
+	return normalize(quatfrommat<float>(float3x3(t, b, n)));
+}
+
+//---------------- Pose ------------------
+
+class Pose
+{
+public:
+	float3 position;
+	Quaternion orientation;
+	Pose() {}
+	Pose(const float3 &p, const Quaternion &q) : position(p), orientation(q) {}
+	Pose &pose() { return *this; }
+	const Pose &pose() const { return *this; }
+};
+
+inline float3 operator*(const Pose &a, const float3 &v)
+{
+	return a.position + rotate(a.orientation, v);
+}
+
+inline Pose operator*(const Pose &a, const Pose &b)
+{
+	return Pose(a.position + rotate(a.orientation, b.position), a.orientation * b.orientation);
+}
+
+inline Pose Inverse(const Pose &a)
+{
+	Quaternion q = Inverse(a.orientation);
+	return Pose(rotate(q, -a.position), q);
+}
+
+inline Pose slerp(const Pose &p0, const Pose &p1, float t)
+{
+	return Pose(p0.position * (1.0f - t) + p1.position * t, slerp(p0.orientation, p1.orientation, t));
+}
+
+inline float4x4 MatrixFromPose(const Pose &pose)
+{
+	return MatrixFromQuatVec(pose.orientation, pose.position);
+}
+
+//------ Euler Angle -----
+
+Quaternion YawPitchRoll(float yaw, float pitch, float roll);
+float Yaw(const Quaternion &q);
+float Pitch(const Quaternion &q);
+float Roll(const Quaternion &q);
+float Yaw(const float3 &v);
+float Pitch(const float3 &v);
+
+//------- Plane ----------
+class Plane : public float4
+{
+public:
+	float3 &normal() { return xyz(); }
+	const float3 &normal() const { return xyz(); }
+	float &dist() { return w; }              // distance below origin - the D from plane equasion Ax+By+Cz+D=0
+	const float &dist() const { return w; }  // distance below origin - the D from plane equasion Ax+By+Cz+D=0
+	Plane(const float3 &n, float d) : float4(n, d) {}
+	Plane() { dist() = 0; }
+	explicit Plane(const float4 &v) : float4(v) {}
+};
+
+Plane Transform(const Plane &p, const float3 &translation, const Quaternion &rotation);
+
+inline Plane PlaneFlip(const Plane &p) { return Plane(-p.normal(), -p.dist()); }
+inline int operator==(const Plane &a, const Plane &b) { return (a.normal() == b.normal() && a.dist() == b.dist()); }
+inline int coplanar(const Plane &a, const Plane &b) { return (a == b || a == PlaneFlip(b)); }
+
+float3 PlaneLineIntersection(const Plane &plane, const float3 &p0, const float3 &p1);
+float3 PlaneProject(const Plane &plane, const float3 &point);
+float3 PlanesIntersection(const Plane &p0, const Plane &p1, const Plane &p2);
+float3 PlanesIntersection(const Plane *planes, int planes_count, const float3 &seed = float3(0, 0, 0));
+
+int Clip(const Plane &p, const float3 *verts_in, int count, float *verts_out);                                                            // verts_out must be preallocated with sufficient size >= count+1 or more if concave
+int ClipPolyPoly(const float3 &normal, const float3 *clipper, int clipper_count, const float3 *verts_in, int in_count, float3 *scratch);  //scratch must be preallocated
+
+//--------- Utility Functions ------
+
+float3 PlaneLineIntersection(const float3 &normal, const float dist, const float3 &p0, const float3 &p1);
+float3 LineProject(const float3 &p0, const float3 &p1, const float3 &a);  // projects a onto infinite line p0p1
+float LineProjectTime(const float3 &p0, const float3 &p1, const float3 &a);
+int BoxInside(const float3 &p, const float3 &bmin, const float3 &bmax);
+int BoxIntersect(const float3 &v0, const float3 &v1, const float3 &bmin, const float3 &bmax, float3 *impact);
+float DistanceBetweenLines(const float3 &ustart, const float3 &udir, const float3 &vstart, const float3 &vdir, float3 *upoint = NULL, float3 *vpoint = NULL);
+float3 TriNormal(const float3 &v0, const float3 &v1, const float3 &v2);
+float3 NormalOf(const float3 *vert, const int n);
+Quaternion VirtualTrackBall(const float3 &cop, const float3 &cor, const float3 &dir0, const float3 &dir1);
+int Clip(const float3 &plane_normal, float plane_dist, const float3 *verts_in, int count, float *verts_out);                              // verts_out must be preallocated with sufficient size >= count+1 or more if concave
+int ClipPolyPoly(const float3 &normal, const float3 *clipper, int clipper_count, const float3 *verts_in, int in_count, float3 *scratch);  //scratch must be preallocated
+float3 Diagonal(const float3x3 &M);
+Quaternion Diagonalizer(const float3x3 &A);
+float3 Orth(const float3 &v);
+int SolveQuadratic(float a, float b, float c, float *ta, float *tb);  // if true returns roots ta,tb where ta<=tb
+int HitCheckPoly(const float3 *vert, const int n, const float3 &v0, const float3 &v1, float3 *impact = NULL, float3 *normal = NULL);
+int HitCheckRaySphere(const float3 &sphereposition, float radius, const float3 &_v0, const float3 &_v1, float3 *impact, float3 *normal);
+int HitCheckRayCylinder(const float3 &p0, const float3 &p1, float radius, const float3 &_v0, const float3 &_v1, float3 *impact, float3 *normal);
+int HitCheckSweptSphereTri(const float3 &p0, const float3 &p1, const float3 &p2, float radius, const float3 &v0, const float3 &_v1, float3 *impact, float3 *normal);
+void BoxLimits(const float3 *verts, int verts_count, float3 &bmin_out, float3 &bmax_out);
+void BoxLimits(const float4 *verts, int verts_count, float3 &bmin_out, float3 &bmax_out);
+
+template <class T>
+inline int maxdir(const T *p, int count, const T &dir)
+{
+	assert(count);
+	int m = 0;
+	for (int i = 1; i < count; i++)
+	{
+		if (dot(p[i], dir) > dot(p[m], dir)) m = i;
+	}
+	return m;
+}
+
+float3 CenterOfMass(const float3 *vertices, const int3 *tris, const int count);
+float3x3 Inertia(const float3 *vertices, const int3 *tris, const int count, const float3 &com = float3(0, 0, 0));
+float Volume(const float3 *vertices, const int3 *tris, const int count);
+int calchull(float3 *verts, int verts_count, int3 *&tris_out, int &tris_count, int vlimit);  // computes convex hull see hull.cpp
+
+#endif  // VEC_MATH_H
diff --git a/engine/inc/bullet/ExtendedTutorials/Bridge.h b/engine/inc/bullet/ExtendedTutorials/Bridge.h
new file mode 100644
index 00000000..5848e2fe
--- /dev/null
+++ b/engine/inc/bullet/ExtendedTutorials/Bridge.h
@@ -0,0 +1,21 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2015 Google Inc. http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef ET_BRIDGE_EXAMPLE_H
+#define ET_BRIDGE_EXAMPLE_H
+
+class CommonExampleInterface* ET_BridgeCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //ET_BRIDGE_EXAMPLE_H
diff --git a/engine/inc/bullet/ExtendedTutorials/Chain.h b/engine/inc/bullet/ExtendedTutorials/Chain.h
new file mode 100644
index 00000000..5def1db9
--- /dev/null
+++ b/engine/inc/bullet/ExtendedTutorials/Chain.h
@@ -0,0 +1,21 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2015 Google Inc. http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef ET_CHAIN_EXAMPLE_H
+#define ET_CHAIN_EXAMPLE_H
+
+class CommonExampleInterface* ET_ChainCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //ET_CHAIN_EXAMPLE_H
diff --git a/engine/inc/bullet/ExtendedTutorials/CompoundBoxes.h b/engine/inc/bullet/ExtendedTutorials/CompoundBoxes.h
new file mode 100644
index 00000000..02a7eb08
--- /dev/null
+++ b/engine/inc/bullet/ExtendedTutorials/CompoundBoxes.h
@@ -0,0 +1,21 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2015 Google Inc. http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef ET_COMPOUND_BOXES_EXAMPLE_H
+#define ET_COMPOUND_BOXES_EXAMPLE_H
+
+class CommonExampleInterface* ET_CompoundBoxesCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //ET_COMPOUND_BOXES_EXAMPLE_H
diff --git a/engine/inc/bullet/ExtendedTutorials/InclinedPlane.h b/engine/inc/bullet/ExtendedTutorials/InclinedPlane.h
new file mode 100644
index 00000000..0a7c2d37
--- /dev/null
+++ b/engine/inc/bullet/ExtendedTutorials/InclinedPlane.h
@@ -0,0 +1,21 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2015 Google Inc. http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef ET_INCLINED_PLANE_EXAMPLE_H
+#define ET_INCLINED_PLANE_EXAMPLE_H
+
+class CommonExampleInterface* ET_InclinedPlaneCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //ET_INCLINED_PLANE_EXAMPLE_H
diff --git a/engine/inc/bullet/ExtendedTutorials/MultiPendulum.h b/engine/inc/bullet/ExtendedTutorials/MultiPendulum.h
new file mode 100644
index 00000000..d65a295f
--- /dev/null
+++ b/engine/inc/bullet/ExtendedTutorials/MultiPendulum.h
@@ -0,0 +1,21 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2015 Google Inc. http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef ET_MULTI_PENDULUM_EXAMPLE_H
+#define ET_MULTI_PENDULUM_EXAMPLE_H
+
+class CommonExampleInterface* ET_MultiPendulumCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //ET_MULTI_PENDULUM_EXAMPLE_H
diff --git a/engine/inc/bullet/ExtendedTutorials/MultipleBoxes.h b/engine/inc/bullet/ExtendedTutorials/MultipleBoxes.h
new file mode 100644
index 00000000..5f34c585
--- /dev/null
+++ b/engine/inc/bullet/ExtendedTutorials/MultipleBoxes.h
@@ -0,0 +1,21 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2015 Google Inc. http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef ET_MULTIPLE_BOXES_EXAMPLE_H
+#define ET_MULTIPLE_BOXES_EXAMPLE_H
+
+class CommonExampleInterface* ET_MultipleBoxesCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //ET_MULTIPLE_BOXES_EXAMPLE_H
diff --git a/engine/inc/bullet/ExtendedTutorials/NewtonsCradle.h b/engine/inc/bullet/ExtendedTutorials/NewtonsCradle.h
new file mode 100644
index 00000000..439003d3
--- /dev/null
+++ b/engine/inc/bullet/ExtendedTutorials/NewtonsCradle.h
@@ -0,0 +1,21 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2015 Google Inc. http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef ET_NEWTONS_CRADLE_EXAMPLE_H
+#define ET_NEWTONS_CRADLE_EXAMPLE_H
+
+class CommonExampleInterface* ET_NewtonsCradleCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //ET_NEWTONS_CRADLE_EXAMPLE_H
diff --git a/engine/inc/bullet/ExtendedTutorials/NewtonsRopeCradle.h b/engine/inc/bullet/ExtendedTutorials/NewtonsRopeCradle.h
new file mode 100644
index 00000000..e7ddcf2d
--- /dev/null
+++ b/engine/inc/bullet/ExtendedTutorials/NewtonsRopeCradle.h
@@ -0,0 +1,21 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2015 Google Inc. http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef ET_NEWTONS_ROPE_CRADLE_EXAMPLE_H
+#define ET_NEWTONS_ROPE_CRADLE_EXAMPLE_H
+
+class CommonExampleInterface* ET_NewtonsRopeCradleCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //ET_NEWTONS_ROPE_CRADLE_EXAMPLE_H
diff --git a/engine/inc/bullet/ExtendedTutorials/RigidBodyFromObj.h b/engine/inc/bullet/ExtendedTutorials/RigidBodyFromObj.h
new file mode 100644
index 00000000..cd133a33
--- /dev/null
+++ b/engine/inc/bullet/ExtendedTutorials/RigidBodyFromObj.h
@@ -0,0 +1,27 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2015 Google Inc. http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef ET_RIGIDBODYFROMOBJ_EXAMPLE_H
+#define ET_RIGIDBODYFROMOBJ_EXAMPLE_H
+
+enum ObjToRigidBodyOptionsEnum
+{
+	ObjUseConvexHullForRendering = 1,
+	OptimizeConvexObj = 2,
+	ComputePolyhedralFeatures = 4,
+};
+class CommonExampleInterface* ET_RigidBodyFromObjCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //ET_RIGIDBODYFROMOBJ_EXAMPLE_H
diff --git a/engine/inc/bullet/ExtendedTutorials/SimpleBox.h b/engine/inc/bullet/ExtendedTutorials/SimpleBox.h
new file mode 100644
index 00000000..03c2e637
--- /dev/null
+++ b/engine/inc/bullet/ExtendedTutorials/SimpleBox.h
@@ -0,0 +1,21 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2015 Google Inc. http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef ET_SIMPLE_BOX_EXAMPLE_H
+#define ET_SIMPLE_BOX_EXAMPLE_H
+
+class CommonExampleInterface* ET_SimpleBoxCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //ET_SIMPLE_BOX_EXAMPLE_H
diff --git a/engine/inc/bullet/ExtendedTutorials/SimpleCloth.h b/engine/inc/bullet/ExtendedTutorials/SimpleCloth.h
new file mode 100644
index 00000000..d8269b01
--- /dev/null
+++ b/engine/inc/bullet/ExtendedTutorials/SimpleCloth.h
@@ -0,0 +1,21 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2015 Google Inc. http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef ET_SIMPLE_CLOTH_EXAMPLE_H
+#define ET_SIMPLE_CLOTH_EXAMPLE_H
+
+class CommonExampleInterface* ET_SimpleClothCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //ET_SIMPLE_CLOTH_EXAMPLE_H
diff --git a/engine/inc/bullet/ExtendedTutorials/SimpleJoint.h b/engine/inc/bullet/ExtendedTutorials/SimpleJoint.h
new file mode 100644
index 00000000..7097c8d5
--- /dev/null
+++ b/engine/inc/bullet/ExtendedTutorials/SimpleJoint.h
@@ -0,0 +1,21 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2015 Google Inc. http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef ET_SIMPLE_JOINT_EXAMPLE_H
+#define ET_SIMPLE_JOINT_EXAMPLE_H
+
+class CommonExampleInterface* ET_SimpleJointCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //ET_SIMPLE_JOINT_EXAMPLE_H
diff --git a/engine/inc/bullet/ForkLift/ForkLiftDemo.h b/engine/inc/bullet/ForkLift/ForkLiftDemo.h
new file mode 100644
index 00000000..497c2d4c
--- /dev/null
+++ b/engine/inc/bullet/ForkLift/ForkLiftDemo.h
@@ -0,0 +1,20 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef FORKLIFT_DEMO_H
+#define FORKLIFT_DEMO_H
+
+class CommonExampleInterface* ForkLiftCreateFunc(struct CommonExampleOptions& options);
+
+#endif  // FORKLIFT_DEMO_H
diff --git a/engine/inc/bullet/FractureDemo/FractureDemo.h b/engine/inc/bullet/FractureDemo/FractureDemo.h
new file mode 100644
index 00000000..3108d250
--- /dev/null
+++ b/engine/inc/bullet/FractureDemo/FractureDemo.h
@@ -0,0 +1,20 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef FRACTURE_DEMO_H
+#define FRACTURE_DEMO_H
+
+class CommonExampleInterface* FractureDemoCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //FRACTURE_DEMO_H
diff --git a/engine/inc/bullet/FractureDemo/btFractureBody.h b/engine/inc/bullet/FractureDemo/btFractureBody.h
new file mode 100644
index 00000000..746babde
--- /dev/null
+++ b/engine/inc/bullet/FractureDemo/btFractureBody.h
@@ -0,0 +1,65 @@
+
+#ifndef BT_FRACTURE_BODY
+#define BT_FRACTURE_BODY
+
+class btCollisionShape;
+class btDynamicsWorld;
+class btCollisionWorld;
+class btCompoundShape;
+class btManifoldPoint;
+
+#include "LinearMath/btAlignedObjectArray.h"
+#include "BulletDynamics/Dynamics/btRigidBody.h"
+
+#define CUSTOM_FRACTURE_TYPE (btRigidBody::CO_USER_TYPE + 1)
+
+struct btConnection
+{
+	btCollisionShape* m_childShape0;
+	btCollisionShape* m_childShape1;
+	int m_childIndex0;
+	int m_childIndex1;
+	btScalar m_strength;
+};
+
+class btFractureBody : public btRigidBody
+{
+	//connections
+public:
+	btDynamicsWorld* m_world;
+	btAlignedObjectArray<btScalar> m_masses;
+	btAlignedObjectArray<btConnection> m_connections;
+
+	btFractureBody(const btRigidBodyConstructionInfo& constructionInfo, btDynamicsWorld* world)
+		: btRigidBody(constructionInfo),
+		  m_world(world)
+	{
+		m_masses.push_back(constructionInfo.m_mass);
+		m_internalType = CUSTOM_FRACTURE_TYPE + CO_RIGID_BODY;
+	}
+
+	///btRigidBody constructor for backwards compatibility.
+	///To specify friction (etc) during rigid body construction, please use the other constructor (using btRigidBodyConstructionInfo)
+	btFractureBody(btScalar mass, btMotionState* motionState, btCollisionShape* collisionShape, const btVector3& localInertia, btScalar* masses, int numMasses, btDynamicsWorld* world)
+		: btRigidBody(mass, motionState, collisionShape, localInertia),
+		  m_world(world)
+	{
+		for (int i = 0; i < numMasses; i++)
+			m_masses.push_back(masses[i]);
+
+		m_internalType = CUSTOM_FRACTURE_TYPE + CO_RIGID_BODY;
+	}
+
+	void recomputeConnectivity(btCollisionWorld* world);
+
+	static btCompoundShape* shiftTransform(btCompoundShape* boxCompound, btScalar* masses, btTransform& shift, btVector3& principalInertia);
+
+	static btCompoundShape* shiftTransformDistributeMass(btCompoundShape* boxCompound, btScalar mass, btTransform& shift);
+
+	static bool collisionCallback(btManifoldPoint& cp, const btCollisionObject* colObj0, int partId0, int index0, const btCollisionObject* colObj1, int partId1, int index1);
+};
+
+void fractureCallback(btDynamicsWorld* world, btScalar timeStep);
+void glueCallback(btDynamicsWorld* world, btScalar timeStep);
+
+#endif  //BT_FRACTURE_BODY
diff --git a/engine/inc/bullet/FractureDemo/btFractureDynamicsWorld.h b/engine/inc/bullet/FractureDemo/btFractureDynamicsWorld.h
new file mode 100644
index 00000000..857f8ca0
--- /dev/null
+++ b/engine/inc/bullet/FractureDemo/btFractureDynamicsWorld.h
@@ -0,0 +1,47 @@
+#ifndef _BT_FRACTURE_DYNAMICS_WORLD_H
+#define _BT_FRACTURE_DYNAMICS_WORLD_H
+
+#include "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h"
+#include "LinearMath/btAlignedObjectArray.h"
+
+class btFractureBody;
+class btCompoundShape;
+class btTransform;
+
+///The btFractureDynamicsWorld class enabled basic glue and fracture of objects.
+///If/once this implementation is stablized/tested we might merge it into btDiscreteDynamicsWorld and remove the class.
+class btFractureDynamicsWorld : public btDiscreteDynamicsWorld
+{
+	btAlignedObjectArray<btFractureBody*> m_fractureBodies;
+
+	bool m_fracturingMode;
+
+	btFractureBody* addNewBody(const btTransform& oldTransform, btScalar* masses, btCompoundShape* oldCompound);
+
+	void breakDisconnectedParts(btFractureBody* fracObj);
+
+public:
+	btFractureDynamicsWorld(btDispatcher* dispatcher, btBroadphaseInterface* pairCache, btConstraintSolver* constraintSolver, btCollisionConfiguration* collisionConfiguration);
+
+	virtual void addRigidBody(btRigidBody* body);
+
+	virtual void removeRigidBody(btRigidBody* body);
+
+	void solveConstraints(btContactSolverInfo& solverInfo);
+
+	///either fracture or glue (!fracture)
+	void setFractureMode(bool fracture)
+	{
+		m_fracturingMode = fracture;
+	}
+
+	bool getFractureMode() const { return m_fracturingMode; }
+
+	///normally those callbacks are called internally by the 'solveConstraints'
+	void glueCallback();
+
+	///normally those callbacks are called internally by the 'solveConstraints'
+	void fractureCallback();
+};
+
+#endif  //_BT_FRACTURE_DYNAMICS_WORLD_H
diff --git a/engine/inc/bullet/GIMPACTUtils/btGImpactConvexDecompositionShape.h b/engine/inc/bullet/GIMPACTUtils/btGImpactConvexDecompositionShape.h
new file mode 100644
index 00000000..47a32706
--- /dev/null
+++ b/engine/inc/bullet/GIMPACTUtils/btGImpactConvexDecompositionShape.h
@@ -0,0 +1,79 @@
+/*! \file btGImpactConvexDecompositionShape.h
+\author Francisco León Nájera
+*/
+/*
+This source file is part of GIMPACT Library.
+
+For the latest info, see http://gimpact.sourceforge.net/
+
+Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371.
+email: projectileman@yahoo.com
+
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef GIMPACT_CONVEX_DECOMPOSITION_SHAPE_H
+#define GIMPACT_CONVEX_DECOMPOSITION_SHAPE_H
+
+#include "BulletCollision/Gimpact/btGImpactShape.h"  // box tree class
+
+//! This class creates a decomposition from a trimesh.
+/*!
+
+*/
+class btGImpactConvexDecompositionShape : public btGImpactCompoundShape
+{
+protected:
+	btAlignedObjectArray<btGImpactMeshShapePart::TrimeshPrimitiveManager> m_trimeshInterfaces;
+
+	class GIM_ConvexDecomposition* m_decomposition;
+
+	void buildConvexDecomposition(bool transformSubShapes);
+
+public:
+	btGImpactConvexDecompositionShape(
+		btStridingMeshInterface* meshInterface,
+		const btVector3& mesh_scale,
+		btScalar margin = btScalar(0.01), bool children_has_transform = true)
+		: btGImpactCompoundShape(children_has_transform)
+	{
+		m_collisionMargin = margin;
+
+		btGImpactMeshShapePart::TrimeshPrimitiveManager triInterface;
+		triInterface.m_meshInterface = meshInterface;
+		triInterface.m_scale = mesh_scale;
+		triInterface.m_margin = btScalar(1.0);
+
+		//add parts
+		int part_count = meshInterface->getNumSubParts();
+		for (int i = 0; i < part_count; i++)
+		{
+			triInterface.m_part = i;
+			m_trimeshInterfaces.push_back(triInterface);
+		}
+
+		m_decomposition = 0;
+
+		buildConvexDecomposition(children_has_transform);
+	}
+
+	virtual ~btGImpactConvexDecompositionShape();
+
+	SIMD_FORCE_INLINE btGImpactMeshShapePart::TrimeshPrimitiveManager* getTrimeshInterface(int part)
+	{
+		return &m_trimeshInterfaces[part];
+	}
+
+	virtual void processAllTriangles(btTriangleCallback* callback, const btVector3& aabbMin, const btVector3& aabbMax) const;
+};
+
+#endif  //GIMPACT_MESH_SHAPE_H
diff --git a/engine/inc/bullet/GyroscopicDemo/GyroscopicSetup.h b/engine/inc/bullet/GyroscopicDemo/GyroscopicSetup.h
new file mode 100644
index 00000000..a5378143
--- /dev/null
+++ b/engine/inc/bullet/GyroscopicDemo/GyroscopicSetup.h
@@ -0,0 +1,7 @@
+
+#ifndef GYROSCOPIC_SETUP_H
+#define GYROSCOPIC_SETUP_H
+
+class CommonExampleInterface* GyroscopicCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //GYROSCOPIC_SETUP_H
diff --git a/engine/inc/bullet/HACD/hacdCircularList.h b/engine/inc/bullet/HACD/hacdCircularList.h
new file mode 100644
index 00000000..d09237ae
--- /dev/null
+++ b/engine/inc/bullet/HACD/hacdCircularList.h
@@ -0,0 +1,86 @@
+/* Copyright (c) 2011 Khaled Mamou (kmamou at gmail dot com)
+ All rights reserved.
+ 
+ 
+ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+ 
+ 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+ 
+ 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+ 
+ 3. The names of the contributors may not be used to endorse or promote products derived from this software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#pragma once
+#ifndef HACD_CIRCULAR_LIST_H
+#define HACD_CIRCULAR_LIST_H
+#include <stdlib.h>
+#include "hacdVersion.h"
+namespace HACD
+{
+//!	CircularListElement class.
+template <typename T>
+class CircularListElement
+{
+public:
+	T& GetData() { return m_data; }
+	const T& GetData() const { return m_data; }
+	CircularListElement<T>*& GetNext() { return m_next; }
+	CircularListElement<T>*& GetPrev() { return m_prev; }
+	const CircularListElement<T>*& GetNext() const { return m_next; }
+	const CircularListElement<T>*& GetPrev() const { return m_prev; }
+	//!	Constructor
+	CircularListElement(const T& data) { m_data = data; }
+	CircularListElement(void) {}
+	//! Destructor
+	~CircularListElement(void) {}
+
+private:
+	T m_data;
+	CircularListElement<T>* m_next;
+	CircularListElement<T>* m_prev;
+
+	CircularListElement(const CircularListElement& rhs);
+};
+
+//!	CircularList class.
+template <typename T>
+class CircularList
+{
+public:
+	CircularListElement<T>*& GetHead() { return m_head; }
+	const CircularListElement<T>* GetHead() const { return m_head; }
+	bool IsEmpty() const { return (m_size == 0); }
+	size_t GetSize() const { return m_size; }
+	const T& GetData() const { return m_head->GetData(); }
+	T& GetData() { return m_head->GetData(); }
+	bool Delete();
+	bool Delete(CircularListElement<T>* element);
+	CircularListElement<T>* Add(const T* data = 0);
+	CircularListElement<T>* Add(const T& data);
+	bool Next();
+	bool Prev();
+	void Clear()
+	{
+		while (Delete())
+			;
+	};
+	const CircularList& operator=(const CircularList& rhs);
+	//!	Constructor
+	CircularList()
+	{
+		m_head = 0;
+		m_size = 0;
+	}
+	CircularList(const CircularList& rhs);
+	//! Destructor
+	virtual ~CircularList(void) { Clear(); };
+
+private:
+	CircularListElement<T>* m_head;  //!< a pointer to the head of the circular list
+	size_t m_size;                   //!< number of element in the circular list
+};
+}  // namespace HACD
+#include "hacdCircularList.inl"
+#endif
diff --git a/engine/inc/bullet/HACD/hacdCircularList.inl b/engine/inc/bullet/HACD/hacdCircularList.inl
new file mode 100644
index 00000000..471f9ed4
--- /dev/null
+++ b/engine/inc/bullet/HACD/hacdCircularList.inl
@@ -0,0 +1,163 @@
+#pragma once
+#ifndef HACD_CIRCULAR_LIST_INL
+#define HACD_CIRCULAR_LIST_INL
+#include<stdlib.h>
+#include "hacdVersion.h"
+namespace HACD
+{
+	template < typename T > 
+	inline bool CircularList<T>::Delete(CircularListElement<T> * element)
+	{
+        if (!element)
+        {
+            return false;
+        }
+		if (m_size > 1)
+		{
+			CircularListElement<T> * next = element->GetNext();
+			CircularListElement<T> * prev = element->GetPrev();
+			delete element;
+			m_size--;
+            if (element == m_head)
+            {
+                m_head = next;
+            }
+			next->GetPrev() = prev;
+			prev->GetNext() = next;
+			return true;
+		}
+		else if (m_size == 1)
+		{
+			delete m_head;
+			m_size--;
+			m_head = 0;
+			return true;
+		}
+		else
+		{
+			return false;
+		}
+	}
+    
+	template < typename T > 
+	inline bool CircularList<T>::Delete()
+	{
+		if (m_size > 1)
+		{
+			CircularListElement<T> * next = m_head->GetNext();
+			CircularListElement<T> * prev = m_head->GetPrev();
+			delete m_head;
+			m_size--;
+			m_head = next;
+			next->GetPrev() = prev;
+			prev->GetNext() = next;
+			return true;
+		}
+		else if (m_size == 1)
+		{
+			delete m_head;
+			m_size--;
+			m_head = 0;
+			return true;
+		}
+		else
+		{
+			return false;
+		}
+	}
+	template < typename T > 
+	inline CircularListElement<T> * CircularList<T>::Add(const T * data)
+	{
+		if (m_size == 0)
+		{
+			if (data)
+			{
+				m_head = new CircularListElement<T>(*data);
+			}
+			else
+			{
+				m_head = new CircularListElement<T>();
+			}
+			m_head->GetNext() = m_head->GetPrev() = m_head;
+		}
+		else
+		{
+			CircularListElement<T> * next = m_head->GetNext();
+			CircularListElement<T> * element = m_head;
+			if (data)
+			{
+				m_head = new CircularListElement<T>(*data);
+			}
+			else
+			{
+				m_head = new CircularListElement<T>;
+			}
+			m_head->GetNext() = next;
+			m_head->GetPrev() = element;
+			element->GetNext() = m_head;
+			next->GetPrev() = m_head;
+		}
+		m_size++;
+		return m_head;
+	}
+	template < typename T > 
+	inline CircularListElement<T> * CircularList<T>::Add(const T & data)
+	{
+		const T * pData = &data;
+		return Add(pData);
+	}
+	template < typename T > 
+	inline bool CircularList<T>::Next()
+	{
+		if (m_size == 0)
+		{
+			return false;
+		}
+		m_head = m_head->GetNext();
+		return true;
+	}
+	template < typename T > 
+	inline bool CircularList<T>::Prev()
+	{
+		if (m_size == 0)
+		{
+			return false;
+		}
+		m_head = m_head->GetPrev();
+		return true;
+	}
+	template < typename T > 
+	inline CircularList<T>::CircularList(const CircularList& rhs)
+	{
+		if (rhs.m_size > 0)
+		{
+			CircularListElement<T> * current = rhs.m_head;
+			do
+			{
+				current = current->GetNext();
+				Add(current->GetData());
+			}
+			while ( current != rhs.m_head );
+		}
+	}
+    template < typename T > 
+	inline const CircularList<T>& CircularList<T>::operator=(const CircularList& rhs)
+	{
+        if (&rhs != this)
+        {
+            Clear();
+            if (rhs.m_size > 0)
+            {
+                CircularListElement<T> * current = rhs.m_head;
+                do
+                {
+                    current = current->GetNext();
+                    Add(current->GetData());
+                }
+                while ( current != rhs.m_head );
+            }
+        }
+        return (*this);
+	}
+}
+#endif
diff --git a/engine/inc/bullet/HACD/hacdGraph.h b/engine/inc/bullet/HACD/hacdGraph.h
new file mode 100644
index 00000000..7df9dd51
--- /dev/null
+++ b/engine/inc/bullet/HACD/hacdGraph.h
@@ -0,0 +1,119 @@
+/* Copyright (c) 2011 Khaled Mamou (kmamou at gmail dot com)
+ All rights reserved.
+ 
+ 
+ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+ 
+ 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+ 
+ 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+ 
+ 3. The names of the contributors may not be used to endorse or promote products derived from this software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#pragma once
+#ifndef HACD_GRAPH_H
+#define HACD_GRAPH_H
+#include "hacdVersion.h"
+#include "hacdVector.h"
+#include "hacdICHull.h"
+#include <map>
+#include <vector>
+#include <set>
+
+namespace HACD
+{
+class GraphVertex;
+class GraphEdge;
+class Graph;
+class HACD;
+
+class GraphVertex
+{
+public:
+	bool AddEdge(long name)
+	{
+		m_edges.insert(name);
+		return true;
+	}
+	bool DeleteEdge(long name);
+	GraphVertex();
+	~GraphVertex() { delete m_convexHull; };
+
+private:
+	long m_name;
+	long m_cc;
+	std::set<long> m_edges;
+	bool m_deleted;
+	std::vector<long> m_ancestors;
+	std::map<long, DPoint> m_distPoints;
+
+	Real m_error;
+	double m_surf;
+	double m_volume;
+	double m_perimeter;
+	double m_concavity;
+	ICHull* m_convexHull;
+	std::set<unsigned long long> m_boudaryEdges;
+
+	friend class GraphEdge;
+	friend class Graph;
+	friend class HACD;
+};
+
+class GraphEdge
+{
+public:
+	GraphEdge();
+	~GraphEdge() { delete m_convexHull; };
+
+private:
+	long m_name;
+	long m_v1;
+	long m_v2;
+	std::map<long, DPoint> m_distPoints;
+	Real m_error;
+	double m_surf;
+	double m_volume;
+	double m_perimeter;
+	double m_concavity;
+	ICHull* m_convexHull;
+	std::set<unsigned long long> m_boudaryEdges;
+	bool m_deleted;
+
+	friend class GraphVertex;
+	friend class Graph;
+	friend class HACD;
+};
+
+class Graph
+{
+public:
+	size_t GetNEdges() const { return m_nE; }
+	size_t GetNVertices() const { return m_nV; }
+	bool EdgeCollapse(long v1, long v2);
+	long AddVertex();
+	long AddEdge(long v1, long v2);
+	bool DeleteEdge(long name);
+	bool DeleteVertex(long name);
+	long GetEdgeID(long v1, long v2) const;
+	void Clear();
+	void Print() const;
+	long ExtractCCs();
+
+	Graph();
+	virtual ~Graph();
+	void Allocate(size_t nV, size_t nE);
+
+private:
+	size_t m_nCCs;
+	size_t m_nV;
+	size_t m_nE;
+	std::vector<GraphEdge> m_edges;
+	std::vector<GraphVertex> m_vertices;
+
+	friend class HACD;
+};
+}  // namespace HACD
+#endif
diff --git a/engine/inc/bullet/HACD/hacdHACD.h b/engine/inc/bullet/HACD/hacdHACD.h
new file mode 100644
index 00000000..efb0fe85
--- /dev/null
+++ b/engine/inc/bullet/HACD/hacdHACD.h
@@ -0,0 +1,285 @@
+/* Copyright (c) 2011 Khaled Mamou (kmamou at gmail dot com)
+ All rights reserved.
+ 
+ 
+ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+ 
+ 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+ 
+ 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+ 
+ 3. The names of the contributors may not be used to endorse or promote products derived from this software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#pragma once
+#ifndef HACD_HACD_H
+#define HACD_HACD_H
+#include "hacdVersion.h"
+#include "hacdVector.h"
+#include "hacdGraph.h"
+#include "hacdICHull.h"
+#include <set>
+#include <vector>
+#include <queue>
+#include <functional>
+
+namespace HACD
+{
+const double sc_pi = 3.14159265;
+class HACD;
+
+// just to be able to set the capcity of the container
+
+template <class _Ty, class _Container = std::vector<_Ty>, class _Pr = std::less<typename _Container::value_type> >
+class reservable_priority_queue : public std::priority_queue<_Ty, _Container, _Pr>
+{
+	typedef typename std::priority_queue<_Ty, _Container, _Pr>::size_type size_type;
+
+public:
+	reservable_priority_queue(size_type capacity = 0) { reserve(capacity); };
+	void reserve(size_type capacity) { this->c.reserve(capacity); }
+	size_type capacity() const { return this->c.capacity(); }
+};
+
+//! priority queque element
+class GraphEdgePriorityQueue
+{
+public:
+	//! Constructor
+	//! @param name edge's id
+	//! @param priority edge's priority
+	GraphEdgePriorityQueue(long name, Real priority)
+	{
+		m_name = name;
+		m_priority = priority;
+	}
+	//! Destructor
+	~GraphEdgePriorityQueue(void) {}
+
+private:
+	long m_name;      //!< edge name
+	Real m_priority;  //!< priority
+					  //! Operator < for GraphEdgePQ
+	friend bool operator<(const GraphEdgePriorityQueue &lhs, const GraphEdgePriorityQueue &rhs);
+	//! Operator > for GraphEdgePQ
+	friend bool operator>(const GraphEdgePriorityQueue &lhs, const GraphEdgePriorityQueue &rhs);
+	friend class HACD;
+};
+inline bool operator<(const GraphEdgePriorityQueue &lhs, const GraphEdgePriorityQueue &rhs)
+{
+	return lhs.m_priority < rhs.m_priority;
+}
+inline bool operator>(const GraphEdgePriorityQueue &lhs, const GraphEdgePriorityQueue &rhs)
+{
+	return lhs.m_priority > rhs.m_priority;
+}
+typedef bool (*CallBackFunction)(const char *, double, double, size_t);
+
+//! Provides an implementation of the Hierarchical Approximate Convex Decomposition (HACD) technique described in "A Simple and Efficient Approach for 3D Mesh Approximate Convex Decomposition" Game Programming Gems 8 - Chapter 2.8, p.202. A short version of the chapter was published in ICIP09 and is available at ftp://ftp.elet.polimi.it/users/Stefano.Tubaro/ICIP_USB_Proceedings_v2/pdfs/0003501.pdf
+class HACD
+{
+public:
+	//! Gives the triangles partitionas an array of size m_nTriangles where the i-th element specifies the cluster to which belong the i-th triangle
+	//! @return triangles partition
+	const long *GetPartition() const { return m_partition; }
+	//! Sets the scale factor
+	//! @param scale scale factor
+	void SetScaleFactor(double scale) { m_scale = scale; }
+	//! Gives the scale factor
+	//! @return scale factor
+	double GetScaleFactor() const { return m_scale; }
+	//! Sets the call-back function
+	//! @param callBack pointer to the call-back function
+	void SetCallBack(CallBackFunction callBack) { m_callBack = callBack; }
+	//! Gives the call-back function
+	//! @return pointer to the call-back function
+	CallBackFunction GetCallBack() const { return m_callBack; }
+
+	//! Specifies whether faces points should be added when computing the concavity
+	//! @param addFacesPoints true = faces points should be added
+	void SetAddFacesPoints(bool addFacesPoints) { m_addFacesPoints = addFacesPoints; }
+	//! Specifies wheter faces points should be added when computing the concavity
+	//! @return true = faces points should be added
+	bool GetAddFacesPoints() const { return m_addFacesPoints; }
+	//! Specifies whether extra points should be added when computing the concavity
+	//! @param addExteraDistPoints true = extra points should be added
+	void SetAddExtraDistPoints(bool addExtraDistPoints) { m_addExtraDistPoints = addExtraDistPoints; }
+	//! Specifies wheter extra points should be added when computing the concavity
+	//! @return true = extra points should be added
+	bool GetAddExtraDistPoints() const { return m_addExtraDistPoints; }
+	//! Specifies whether extra points should be added when computing the concavity
+	//! @param addExteraDistPoints true = extra points should be added
+	void SetAddNeighboursDistPoints(bool addNeighboursDistPoints) { m_addNeighboursDistPoints = addNeighboursDistPoints; }
+	//! Specifies wheter extra points should be added when computing the concavity
+	//! @return true = extra points should be added
+	bool GetAddNeighboursDistPoints() const { return m_addNeighboursDistPoints; }
+	//! Sets the points of the input mesh (Remark: the input points will be scaled and shifted. Use DenormalizeData() to invert those operations)
+	//! @param points pointer to the input points
+	void SetPoints(Vec3<Real> *points) { m_points = points; }
+	//! Gives the points of the input mesh (Remark: the input points will be scaled and shifted. Use DenormalizeData() to invert those operations)
+	//! @return pointer to the input points
+	const Vec3<Real> *GetPoints() const { return m_points; }
+	//! Sets the triangles of the input mesh.
+	//! @param triangles points pointer to the input points
+	void SetTriangles(Vec3<long> *triangles) { m_triangles = triangles; }
+	//! Gives the triangles in the input mesh
+	//! @return pointer to the input triangles
+	const Vec3<long> *GetTriangles() const { return m_triangles; }
+	//! Sets the number of points in the input mesh.
+	//! @param nPoints number of points the input mesh
+	void SetNPoints(size_t nPoints) { m_nPoints = nPoints; }
+	//! Gives the number of points in the input mesh.
+	//! @return number of points the input mesh
+	size_t GetNPoints() const { return m_nPoints; }
+	//! Sets the number of triangles in the input mesh.
+	//! @param nTriangles number of triangles in the input mesh
+	void SetNTriangles(size_t nTriangles) { m_nTriangles = nTriangles; }
+	//! Gives the number of triangles in the input mesh.
+	//! @return number of triangles the input mesh
+	size_t GetNTriangles() const { return m_nTriangles; }
+	//! Sets the minimum number of clusters to be generated.
+	//! @param nClusters minimum number of clusters
+	void SetNClusters(size_t nClusters) { m_nMinClusters = nClusters; }
+	//! Gives the number of generated clusters.
+	//! @return number of generated clusters
+	size_t GetNClusters() const { return m_nClusters; }
+	//! Sets the maximum allowed concavity.
+	//! @param concavity maximum concavity
+	void SetConcavity(double concavity) { m_concavity = concavity; }
+	//! Gives the maximum allowed concavity.
+	//! @return maximum concavity
+	double GetConcavity() const { return m_concavity; }
+	//! Sets the maximum allowed distance to get CCs connected.
+	//! @param concavity maximum distance to get CCs connected
+	void SetConnectDist(double ccConnectDist) { m_ccConnectDist = ccConnectDist; }
+	//! Gives the maximum allowed distance to get CCs connected.
+	//! @return maximum distance to get CCs connected
+	double GetConnectDist() const { return m_ccConnectDist; }
+	//! Sets the volume weight.
+	//! @param beta volume weight
+	void SetVolumeWeight(double beta) { m_beta = beta; }
+	//! Gives the volume weight.
+	//! @return volume weight
+	double GetVolumeWeight() const { return m_beta; }
+	//! Sets the compacity weight (i.e. parameter alpha in ftp://ftp.elet.polimi.it/users/Stefano.Tubaro/ICIP_USB_Proceedings_v2/pdfs/0003501.pdf).
+	//! @param alpha compacity weight
+	void SetCompacityWeight(double alpha) { m_alpha = alpha; }
+	//! Gives the compacity weight (i.e. parameter alpha in ftp://ftp.elet.polimi.it/users/Stefano.Tubaro/ICIP_USB_Proceedings_v2/pdfs/0003501.pdf).
+	//! @return compacity weight
+	double GetCompacityWeight() const { return m_alpha; }
+	//! Sets the maximum number of vertices for each generated convex-hull.
+	//! @param nVerticesPerCH maximum # vertices per CH
+	void SetNVerticesPerCH(size_t nVerticesPerCH) { m_nVerticesPerCH = nVerticesPerCH; }
+	//! Gives the maximum number of vertices for each generated convex-hull.
+	//! @return maximum # vertices per CH
+	size_t GetNVerticesPerCH() const { return m_nVerticesPerCH; }
+	//! Gives the number of vertices for the cluster number numCH.
+	//! @return number of vertices
+	size_t GetNPointsCH(size_t numCH) const;
+	//! Gives the number of triangles for the cluster number numCH.
+	//! @param numCH cluster's number
+	//! @return number of triangles
+	size_t GetNTrianglesCH(size_t numCH) const;
+	//! Gives the vertices and the triangles of the cluster number numCH.
+	//! @param numCH cluster's number
+	//! @param points pointer to the vector of points to be filled
+	//! @param triangles pointer to the vector of triangles to be filled
+	//! @return true if sucess
+	bool GetCH(size_t numCH, Vec3<Real> *const points, Vec3<long> *const triangles);
+	//! Computes the HACD decomposition.
+	//! @param fullCH specifies whether to generate convex-hulls with a full or limited (i.e. < m_nVerticesPerCH) number of vertices
+	//! @param exportDistPoints specifies wheter distance points should ne exported or not (used only for debugging).
+	//! @return true if sucess
+	bool Compute(bool fullCH = false, bool exportDistPoints = false);
+	//! Saves the generated convex-hulls in a VRML 2.0 file.
+	//! @param fileName the output file name
+	//! @param uniColor specifies whether the different convex-hulls should have the same color or not
+	//! @param numCluster specifies the cluster to be saved, if numCluster < 0 export all clusters
+	//! @return true if sucess
+	bool Save(const char *fileName, bool uniColor, long numCluster = -1) const;
+	//! Shifts and scales to the data to have all the coordinates between 0.0 and 1000.0.
+	void NormalizeData();
+	//! Inverse the operations applied by NormalizeData().
+	void DenormalizeData();
+	//! Constructor.
+	HACD(void);
+	//! Destructor.
+	~HACD(void);
+
+private:
+	//! Gives the edge index.
+	//! @param a first vertex id
+	//! @param b second vertex id
+	//! @return edge's index
+	static unsigned long long GetEdgeIndex(unsigned long long a, unsigned long long b)
+	{
+		if (a > b)
+			return (a << 32) + b;
+		else
+			return (b << 32) + a;
+	}
+	//! Computes the concavity of a cluster.
+	//! @param ch the cluster's convex-hull
+	//! @param distPoints the cluster's points
+	//! @return cluster's concavity
+	double Concavity(ICHull &ch, std::map<long, DPoint> &distPoints);
+	//! Computes the perimeter of a cluster.
+	//! @param triIndices the cluster's triangles
+	//! @param distPoints the cluster's points
+	//! @return cluster's perimeter
+	double ComputePerimeter(const std::vector<long> &triIndices) const;
+	//! Creates the Graph by associating to each mesh triangle a vertex in the graph and to each couple of adjacent triangles an edge in the graph.
+	void CreateGraph();
+	//! Initializes the graph costs and computes the vertices normals
+	void InitializeDualGraph();
+	//! Computes the cost of an edge
+	//! @param e edge's id
+	void ComputeEdgeCost(size_t e);
+	//! Initializes the priority queue
+	//! @param fast specifies whether fast mode is used
+	//! @return true if success
+	bool InitializePriorityQueue();
+	//! Cleans the intersection between convex-hulls
+	void CleanClusters();
+	//! Computes convex-hulls from partition information
+	//! @param fullCH specifies whether to generate convex-hulls with a full or limited (i.e. < m_nVerticesPerCH) number of vertices
+	void ComputeConvexHulls(bool fullCH);
+	//! Simplifies the graph
+	//! @param fast specifies whether fast mode is used
+	void Simplify();
+
+private:
+	double m_scale;                 //>! scale factor used for NormalizeData() and DenormalizeData()
+	Vec3<long> *m_triangles;        //>! pointer the triangles array
+	Vec3<Real> *m_points;           //>! pointer the points array
+	Vec3<Real> *m_facePoints;       //>! pointer to the faces points array
+	Vec3<Real> *m_faceNormals;      //>! pointer to the faces normals array
+	Vec3<Real> *m_normals;          //>! pointer the normals array
+	size_t m_nTriangles;            //>! number of triangles in the original mesh
+	size_t m_nPoints;               //>! number of vertices in the original mesh
+	size_t m_nClusters;             //>! number of clusters
+	size_t m_nMinClusters;          //>! minimum number of clusters
+	double m_ccConnectDist;         //>! maximum allowed distance to connect CCs
+	double m_concavity;             //>! maximum concavity
+	double m_alpha;                 //>! compacity weigth
+	double m_beta;                  //>! volume weigth
+	double m_diag;                  //>! length of the BB diagonal
+	Vec3<Real> m_barycenter;        //>! barycenter of the mesh
+	std::vector<long> m_cVertices;  //>! array of vertices each belonging to a different cluster
+	ICHull *m_convexHulls;          //>! convex-hulls associated with the final HACD clusters
+	Graph m_graph;                  //>! simplification graph
+	size_t m_nVerticesPerCH;        //>! maximum number of vertices per convex-hull
+	reservable_priority_queue<GraphEdgePriorityQueue,
+							  std::vector<GraphEdgePriorityQueue>,
+							  std::greater<std::vector<GraphEdgePriorityQueue>::value_type> >
+		m_pqueue;  //!> priority queue
+	HACD(const HACD &rhs);
+	CallBackFunction m_callBack;     //>! call-back function
+	long *m_partition;               //>! array of size m_nTriangles where the i-th element specifies the cluster to which belong the i-th triangle
+	bool m_addFacesPoints;           //>! specifies whether to add faces points or not
+	bool m_addExtraDistPoints;       //>! specifies whether to add extra points for concave shapes or not
+	bool m_addNeighboursDistPoints;  //>! specifies whether to add extra points from adjacent clusters or not
+};
+}  // namespace HACD
+#endif
diff --git a/engine/inc/bullet/HACD/hacdICHull.h b/engine/inc/bullet/HACD/hacdICHull.h
new file mode 100644
index 00000000..c7d83956
--- /dev/null
+++ b/engine/inc/bullet/HACD/hacdICHull.h
@@ -0,0 +1,120 @@
+/* Copyright (c) 2011 Khaled Mamou (kmamou at gmail dot com)
+ All rights reserved.
+ 
+ 
+ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+ 
+ 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+ 
+ 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+ 
+ 3. The names of the contributors may not be used to endorse or promote products derived from this software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#pragma once
+#ifndef HACD_ICHULL_H
+#define HACD_ICHULL_H
+#include "hacdVersion.h"
+#include "hacdManifoldMesh.h"
+#include "hacdVector.h"
+#include <vector>
+#include <map>
+namespace HACD
+{
+class DPoint;
+class HACD;
+//!	Incremental Convex Hull algorithm (cf. http://maven.smith.edu/~orourke/books/ftp.html ).
+enum ICHullError
+{
+	ICHullErrorOK = 0,
+	ICHullErrorCoplanarPoints,
+	ICHullErrorNoVolume,
+	ICHullErrorInconsistent,
+	ICHullErrorNotEnoughPoints
+};
+class ICHull
+{
+public:
+	//!
+	bool IsFlat() { return m_isFlat; }
+	//!
+	std::map<long, DPoint> *GetDistPoints() const { return m_distPoints; }
+	//!
+	void SetDistPoints(std::map<long, DPoint> *distPoints) { m_distPoints = distPoints; }
+	//! Returns the computed mesh
+	TMMesh &GetMesh() { return m_mesh; }
+	//!	Add one point to the convex-hull
+	bool AddPoint(const Vec3<Real> &point) { return AddPoints(&point, 1); }
+	//!	Add one point to the convex-hull
+	bool AddPoint(const Vec3<Real> &point, long id);
+	//!	Add points to the convex-hull
+	bool AddPoints(const Vec3<Real> *points, size_t nPoints);
+	bool AddPoints(std::vector<Vec3<Real> > points);
+	//!
+	ICHullError Process();
+	//!
+	ICHullError Process(unsigned long nPointsCH);
+	//!
+	double ComputeVolume();
+	//!
+	bool IsInside(const Vec3<Real> &pt0);
+	//!
+	double ComputeDistance(long name, const Vec3<Real> &pt, const Vec3<Real> &normal, bool &insideHull, bool updateIncidentPoints);
+	//!
+	const ICHull &operator=(ICHull &rhs);
+
+	//!	Constructor
+	ICHull(void);
+	//! Destructor
+	virtual ~ICHull(void){};
+
+private:
+	//!	DoubleTriangle builds the initial double triangle.  It first finds 3 noncollinear points and makes two faces out of them, in opposite order. It then finds a fourth point that is not coplanar with that face.  The vertices are stored in the face structure in counterclockwise order so that the volume between the face and the point is negative. Lastly, the 3 newfaces to the fourth point are constructed and the data structures are cleaned up.
+	ICHullError DoubleTriangle();
+	//!	MakeFace creates a new face structure from three vertices (in ccw order).  It returns a pointer to the face.
+	CircularListElement<TMMTriangle> *MakeFace(CircularListElement<TMMVertex> *v0,
+											   CircularListElement<TMMVertex> *v1,
+											   CircularListElement<TMMVertex> *v2,
+											   CircularListElement<TMMTriangle> *fold);
+	//!
+	CircularListElement<TMMTriangle> *MakeConeFace(CircularListElement<TMMEdge> *e, CircularListElement<TMMVertex> *v);
+	//!
+	bool ProcessPoint();
+	//!
+	bool ComputePointVolume(double &totalVolume, bool markVisibleFaces);
+	//!
+	bool FindMaxVolumePoint();
+	//!
+	bool CleanEdges();
+	//!
+	bool CleanVertices(unsigned long &addedPoints);
+	//!
+	bool CleanTriangles();
+	//!
+	bool CleanUp(unsigned long &addedPoints);
+	//!
+	bool MakeCCW(CircularListElement<TMMTriangle> *f,
+				 CircularListElement<TMMEdge> *e,
+				 CircularListElement<TMMVertex> *v);
+	void Clear();
+
+private:
+	static const long sc_dummyIndex;
+	static const double sc_distMin;
+	TMMesh m_mesh;
+	std::vector<CircularListElement<TMMEdge> *> m_edgesToDelete;
+	std::vector<CircularListElement<TMMEdge> *> m_edgesToUpdate;
+	std::vector<CircularListElement<TMMTriangle> *> m_trianglesToDelete;
+	std::map<long, DPoint> *m_distPoints;
+	CircularListElement<TMMVertex> *m_dummyVertex;
+	Vec3<Real> m_normal;
+	bool m_isFlat;
+
+	ICHull(const ICHull &rhs);
+
+	friend class HACD;
+};
+
+}  // namespace HACD
+#endif
diff --git a/engine/inc/bullet/HACD/hacdManifoldMesh.h b/engine/inc/bullet/HACD/hacdManifoldMesh.h
new file mode 100644
index 00000000..1d229187
--- /dev/null
+++ b/engine/inc/bullet/HACD/hacdManifoldMesh.h
@@ -0,0 +1,251 @@
+/* Copyright (c) 2011 Khaled Mamou (kmamou at gmail dot com)
+All rights reserved.
+
+
+ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+ 3. The names of the contributors may not be used to endorse or promote products derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/* Copyright (c) 2011 Khaled Mamou (kmamou at gmail dot com)
+ All rights reserved.
+ 
+ 
+ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+ 
+ 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+ 
+ 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+ 
+ 3. The names of the contributors may not be used to endorse or promote products derived from this software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#pragma once
+#ifndef HACD_MANIFOLD_MESH_H
+#define HACD_MANIFOLD_MESH_H
+#include <iostream>
+#include <fstream>
+#include "hacdVersion.h"
+#include "hacdCircularList.h"
+#include "hacdVector.h"
+#include <set>
+namespace HACD
+{
+class TMMTriangle;
+class TMMEdge;
+class TMMesh;
+class ICHull;
+class HACD;
+
+class DPoint
+{
+public:
+	DPoint(Real dist = 0, bool computed = false, bool distOnly = false)
+		: m_dist(dist),
+		  m_computed(computed),
+		  m_distOnly(distOnly){};
+	~DPoint(){};
+
+private:
+	Real m_dist;
+	bool m_computed;
+	bool m_distOnly;
+	friend class TMMTriangle;
+	friend class TMMesh;
+	friend class GraphVertex;
+	friend class GraphEdge;
+	friend class Graph;
+	friend class ICHull;
+	friend class HACD;
+};
+
+//!	Vertex data structure used in a triangular manifold mesh (TMM).
+class TMMVertex
+{
+public:
+	TMMVertex(void);
+	~TMMVertex(void);
+
+private:
+	Vec3<Real> m_pos;
+	long m_name;
+	size_t m_id;
+	CircularListElement<TMMEdge> *m_duplicate;  // pointer to incident cone edge (or NULL)
+	bool m_onHull;
+	bool m_tag;
+	TMMVertex(const TMMVertex &rhs);
+
+	friend class HACD;
+	friend class ICHull;
+	friend class TMMesh;
+	friend class TMMTriangle;
+	friend class TMMEdge;
+};
+
+//!	Edge data structure used in a triangular manifold mesh (TMM).
+class TMMEdge
+{
+public:
+	TMMEdge(void);
+	~TMMEdge(void);
+
+private:
+	size_t m_id;
+	CircularListElement<TMMTriangle> *m_triangles[2];
+	CircularListElement<TMMVertex> *m_vertices[2];
+	CircularListElement<TMMTriangle> *m_newFace;
+
+	TMMEdge(const TMMEdge &rhs);
+
+	friend class HACD;
+	friend class ICHull;
+	friend class TMMTriangle;
+	friend class TMMVertex;
+	friend class TMMesh;
+};
+
+//!	Triangle data structure used in a triangular manifold mesh (TMM).
+class TMMTriangle
+{
+public:
+	TMMTriangle(void);
+	~TMMTriangle(void);
+
+private:
+	size_t m_id;
+	CircularListElement<TMMEdge> *m_edges[3];
+	CircularListElement<TMMVertex> *m_vertices[3];
+	std::set<long> m_incidentPoints;
+	bool m_visible;
+
+	TMMTriangle(const TMMTriangle &rhs);
+
+	friend class HACD;
+	friend class ICHull;
+	friend class TMMesh;
+	friend class TMMVertex;
+	friend class TMMEdge;
+};
+
+class Material
+{
+public:
+	Material(void);
+	~Material(void) {}
+	//    private:
+	Vec3<double> m_diffuseColor;
+	double m_ambientIntensity;
+	Vec3<double> m_specularColor;
+	Vec3<double> m_emissiveColor;
+	double m_shininess;
+	double m_transparency;
+
+	friend class TMMesh;
+	friend class HACD;
+};
+
+//!	triangular manifold mesh data structure.
+class TMMesh
+{
+public:
+	//! Returns the number of vertices>
+	inline size_t GetNVertices() const { return m_vertices.GetSize(); }
+	//! Returns the number of edges
+	inline size_t GetNEdges() const { return m_edges.GetSize(); }
+	//! Returns the number of triangles
+	inline size_t GetNTriangles() const { return m_triangles.GetSize(); }
+	//! Returns the vertices circular list
+	inline const CircularList<TMMVertex> &GetVertices() const { return m_vertices; }
+	//! Returns the edges circular list
+	inline const CircularList<TMMEdge> &GetEdges() const { return m_edges; }
+	//! Returns the triangles circular list
+	inline const CircularList<TMMTriangle> &GetTriangles() const { return m_triangles; }
+	//! Returns the vertices circular list
+	inline CircularList<TMMVertex> &GetVertices() { return m_vertices; }
+	//! Returns the edges circular list
+	inline CircularList<TMMEdge> &GetEdges() { return m_edges; }
+	//! Returns the triangles circular list
+	inline CircularList<TMMTriangle> &GetTriangles() { return m_triangles; }
+	//! Add vertex to the mesh
+	CircularListElement<TMMVertex> *AddVertex() { return m_vertices.Add(); }
+	//! Add vertex to the mesh
+	CircularListElement<TMMEdge> *AddEdge() { return m_edges.Add(); }
+	//! Add vertex to the mesh
+	CircularListElement<TMMTriangle> *AddTriangle() { return m_triangles.Add(); }
+	//! Print mesh information
+	void Print();
+	//!
+	void GetIFS(Vec3<Real> *const points, Vec3<long> *const triangles);
+	//! Save mesh
+	bool Save(const char *fileName);
+	//! Save mesh to VRML 2.0 format
+	bool SaveVRML2(std::ofstream &fout);
+	//! Save mesh to VRML 2.0 format
+	bool SaveVRML2(std::ofstream &fout, const Material &material);
+	//!
+	void Clear();
+	//!
+	void Copy(TMMesh &mesh);
+	//!
+	bool CheckConsistancy();
+	//!
+	bool Normalize();
+	//!
+	bool Denormalize();
+	//!	Constructor
+	TMMesh(void);
+	//! Destructor
+	virtual ~TMMesh(void);
+
+private:
+	CircularList<TMMVertex> m_vertices;
+	CircularList<TMMEdge> m_edges;
+	CircularList<TMMTriangle> m_triangles;
+	Real m_diag;              //>! length of the BB diagonal
+	Vec3<Real> m_barycenter;  //>! barycenter of the mesh
+
+	// not defined
+	TMMesh(const TMMesh &rhs);
+	friend class ICHull;
+	friend class HACD;
+};
+//! IntersectRayTriangle(): intersect a ray with a 3D triangle
+//!    Input:  a ray R, and a triangle T
+//!    Output: *I = intersection point (when it exists)
+//!             0 = disjoint (no intersect)
+//!             1 = intersect in unique point I1
+long IntersectRayTriangle(const Vec3<double> &P0, const Vec3<double> &dir,
+						  const Vec3<double> &V0, const Vec3<double> &V1,
+						  const Vec3<double> &V2, double &t);
+
+// intersect_RayTriangle(): intersect a ray with a 3D triangle
+//    Input:  a ray R, and a triangle T
+//    Output: *I = intersection point (when it exists)
+//    Return: -1 = triangle is degenerate (a segment or point)
+//             0 = disjoint (no intersect)
+//             1 = intersect in unique point I1
+//             2 = are in the same plane
+long IntersectRayTriangle2(const Vec3<double> &P0, const Vec3<double> &dir,
+						   const Vec3<double> &V0, const Vec3<double> &V1,
+						   const Vec3<double> &V2, double &r);
+
+/*
+     Calculate the line segment PaPb that is the shortest route between
+     two lines P1P2 and P3P4. Calculate also the values of mua and mub where
+     Pa = P1 + mua (P2 - P1)
+     Pb = P3 + mub (P4 - P3)
+     Return FALSE if no solution exists.
+     */
+bool IntersectLineLine(const Vec3<double> &p1, const Vec3<double> &p2,
+					   const Vec3<double> &p3, const Vec3<double> &p4,
+					   Vec3<double> &pa, Vec3<double> &pb,
+					   double &mua, double &mub);
+}  // namespace HACD
+#endif
diff --git a/engine/inc/bullet/HACD/hacdVector.h b/engine/inc/bullet/HACD/hacdVector.h
new file mode 100644
index 00000000..778e04a3
--- /dev/null
+++ b/engine/inc/bullet/HACD/hacdVector.h
@@ -0,0 +1,68 @@
+/* Copyright (c) 2011 Khaled Mamou (kmamou at gmail dot com)
+ All rights reserved.
+ 
+ 
+ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+ 
+ 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+ 
+ 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+ 
+ 3. The names of the contributors may not be used to endorse or promote products derived from this software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#pragma once
+#ifndef HACD_VECTOR_H
+#define HACD_VECTOR_H
+#include <math.h>
+#include <iostream>
+#include "hacdVersion.h"
+
+namespace HACD
+{
+typedef double Real;
+//!	Vector dim 3.
+template <typename T>
+class Vec3
+{
+public:
+	T& X();
+	T& Y();
+	T& Z();
+	const T& X() const;
+	const T& Y() const;
+	const T& Z() const;
+	void Normalize();
+	T GetNorm() const;
+	void operator=(const Vec3& rhs);
+	void operator+=(const Vec3& rhs);
+	void operator-=(const Vec3& rhs);
+	void operator-=(T a);
+	void operator+=(T a);
+	void operator/=(T a);
+	void operator*=(T a);
+	Vec3 operator^(const Vec3& rhs) const;
+	T operator*(const Vec3& rhs) const;
+	Vec3 operator+(const Vec3& rhs) const;
+	Vec3 operator-(const Vec3& rhs) const;
+	Vec3 operator-() const;
+	Vec3 operator*(T rhs) const;
+	Vec3 operator/(T rhs) const;
+	Vec3();
+	Vec3(T a);
+	Vec3(T x, T y, T z);
+	Vec3(const Vec3& rhs);
+	/*virtual*/ ~Vec3(void);
+
+private:
+	T m_data[3];
+};
+template <typename T>
+bool Colinear(const Vec3<T>& a, const Vec3<T>& b, const Vec3<T>& c);
+template <typename T>
+const T Volume(const Vec3<T>& a, const Vec3<T>& b, const Vec3<T>& c, const Vec3<T>& d);
+
+}  // namespace HACD
+#include "hacdVector.inl"  // template implementation
+#endif
diff --git a/engine/inc/bullet/HACD/hacdVector.inl b/engine/inc/bullet/HACD/hacdVector.inl
new file mode 100644
index 00000000..b1f0c1b2
--- /dev/null
+++ b/engine/inc/bullet/HACD/hacdVector.inl
@@ -0,0 +1,178 @@
+#pragma once
+#ifndef HACD_VECTOR_INL
+#define HACD_VECTOR_INL
+namespace HACD
+{
+	template <typename T> 
+	inline Vec3<T> operator*(T lhs, const Vec3<T> & rhs)
+	{
+		return Vec3<T>(lhs * rhs.X(), lhs * rhs.Y(), lhs * rhs.Z());
+	}
+	template <typename T> 
+	inline T & Vec3<T>::X() 
+	{
+		return m_data[0];
+	}
+	template <typename T>	
+	inline  T &	Vec3<T>::Y() 
+	{
+		return m_data[1];
+	}
+	template <typename T>	
+	inline  T &	Vec3<T>::Z() 
+	{
+		return m_data[2];
+	}
+	template <typename T>	
+	inline  const T & Vec3<T>::X() const 
+	{
+		return m_data[0];
+	}
+	template <typename T>	
+	inline  const T & Vec3<T>::Y() const 
+	{
+		return m_data[1];
+	}
+	template <typename T>	
+	inline  const T & Vec3<T>::Z() const 
+	{
+		return m_data[2];
+	}
+	template <typename T>	
+	inline  void Vec3<T>::Normalize()
+	{
+		T n = sqrt(m_data[0]*m_data[0]+m_data[1]*m_data[1]+m_data[2]*m_data[2]);
+		if (n != 0.0) (*this) /= n;
+	}
+	template <typename T>	
+	inline  T Vec3<T>::GetNorm() const 
+	{ 
+		return sqrt(m_data[0]*m_data[0]+m_data[1]*m_data[1]+m_data[2]*m_data[2]);
+	}
+	template <typename T>	
+	inline  void Vec3<T>::operator= (const Vec3 & rhs)
+	{ 
+		this->m_data[0] = rhs.m_data[0]; 
+		this->m_data[1] = rhs.m_data[1]; 
+		this->m_data[2] = rhs.m_data[2]; 
+	}
+	template <typename T>	
+	inline  void Vec3<T>::operator+=(const Vec3 & rhs)
+	{ 
+		this->m_data[0] += rhs.m_data[0]; 
+		this->m_data[1] += rhs.m_data[1]; 
+		this->m_data[2] += rhs.m_data[2]; 
+	}     
+	template <typename T>  
+	inline void Vec3<T>::operator-=(const Vec3 & rhs)
+	{ 
+		this->m_data[0] -= rhs.m_data[0]; 
+		this->m_data[1] -= rhs.m_data[1]; 
+		this->m_data[2] -= rhs.m_data[2]; 
+	}
+	template <typename T>  
+	inline void Vec3<T>::operator-=(T a)
+	{ 
+		this->m_data[0] -= a; 
+		this->m_data[1] -= a; 
+		this->m_data[2] -= a; 
+	}
+	template <typename T>  
+	inline void Vec3<T>::operator+=(T a)
+	{ 
+		this->m_data[0] += a; 
+		this->m_data[1] += a; 
+		this->m_data[2] += a; 
+	}
+	template <typename T>  
+	inline void Vec3<T>::operator/=(T a)
+	{ 
+		this->m_data[0] /= a; 
+		this->m_data[1] /= a; 
+		this->m_data[2] /= a; 
+	}
+	template <typename T>  
+	inline void Vec3<T>::operator*=(T a)
+	{ 
+		this->m_data[0] *= a; 
+		this->m_data[1] *= a; 
+		this->m_data[2] *= a; 
+	}  
+	template <typename T>	
+	inline Vec3<T> Vec3<T>::operator^ (const Vec3<T> & rhs) const
+	{
+		return Vec3<T>(m_data[1] * rhs.m_data[2] - m_data[2] * rhs.m_data[1],
+					   m_data[2] * rhs.m_data[0] - m_data[0] * rhs.m_data[2],
+					   m_data[0] * rhs.m_data[1] - m_data[1] * rhs.m_data[0]);
+	}
+	template <typename T>
+	inline T Vec3<T>::operator*(const Vec3<T> & rhs) const
+	{
+		return (m_data[0] * rhs.m_data[0] + m_data[1] * rhs.m_data[1] + m_data[2] * rhs.m_data[2]);
+	}        
+	template <typename T>
+	inline Vec3<T> Vec3<T>::operator+(const Vec3<T> & rhs) const
+	{
+		return Vec3<T>(m_data[0] + rhs.m_data[0],m_data[1] + rhs.m_data[1],m_data[2] + rhs.m_data[2]);
+	}
+	template <typename T> 
+	inline  Vec3<T> Vec3<T>::operator-(const Vec3<T> & rhs) const
+	{
+		return Vec3<T>(m_data[0] - rhs.m_data[0],m_data[1] - rhs.m_data[1],m_data[2] - rhs.m_data[2]) ;
+	}     
+	template <typename T> 
+	inline  Vec3<T> Vec3<T>::operator-() const
+	{
+		return Vec3<T>(-m_data[0],-m_data[1],-m_data[2]) ;
+	}     
+
+	template <typename T> 
+	inline Vec3<T> Vec3<T>::operator*(T rhs) const
+	{
+		return Vec3<T>(rhs * this->m_data[0], rhs * this->m_data[1], rhs * this->m_data[2]);
+	}
+	template <typename T>
+	inline Vec3<T> Vec3<T>::operator/ (T rhs) const
+	{
+		return Vec3<T>(m_data[0] / rhs, m_data[1] / rhs, m_data[2] / rhs);
+	}
+	template <typename T>
+	inline Vec3<T>::Vec3(T a) 
+	{ 
+		m_data[0] = m_data[1] = m_data[2] = a; 
+	}
+	template <typename T>
+	inline Vec3<T>::Vec3(T x, T y, T z)
+	{
+		m_data[0] = x;
+		m_data[1] = y;
+		m_data[2] = z;
+	}
+	template <typename T>
+	inline Vec3<T>::Vec3(const Vec3 & rhs)
+	{		
+		m_data[0] = rhs.m_data[0];
+		m_data[1] = rhs.m_data[1];
+		m_data[2] = rhs.m_data[2];
+	}
+	template <typename T>
+	inline Vec3<T>::~Vec3(void){};
+
+	template <typename T>
+	inline Vec3<T>::Vec3() {}
+    
+    template<typename T>
+    inline bool Colinear(const Vec3<T> & a, const Vec3<T> & b, const Vec3<T> & c)
+    {
+        return  ((c.Z() - a.Z()) * (b.Y() - a.Y()) - (b.Z() - a.Z()) * (c.Y() - a.Y()) == 0.0 /*EPS*/) &&
+                ((b.Z() - a.Z()) * (c.X() - a.X()) - (b.X() - a.X()) * (c.Z() - a.Z()) == 0.0 /*EPS*/) &&
+                ((b.X() - a.X()) * (c.Y() - a.Y()) - (b.Y() - a.Y()) * (c.X() - a.X()) == 0.0 /*EPS*/);
+    }
+    
+    template<typename T>
+    inline const T Volume(const Vec3<T> & a, const Vec3<T> & b, const Vec3<T> & c, const Vec3<T> & d)
+    {
+        return (a-d) * ((b-d) ^ (c-d));
+    }
+}
+#endif //HACD_VECTOR_INL
diff --git a/engine/inc/bullet/HACD/hacdVersion.h b/engine/inc/bullet/HACD/hacdVersion.h
new file mode 100644
index 00000000..c9f7f28d
--- /dev/null
+++ b/engine/inc/bullet/HACD/hacdVersion.h
@@ -0,0 +1,20 @@
+/* Copyright (c) 2011 Khaled Mamou (kmamou at gmail dot com)
+ All rights reserved.
+ 
+ 
+ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+ 
+ 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+ 
+ 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+ 
+ 3. The names of the contributors may not be used to endorse or promote products derived from this software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#pragma once
+#ifndef HACD_VERSION_H
+#define HACD_VERSION_H
+#define HACD_VERSION_MAJOR 0
+#define HACD_VERSION_MINOR 0
+#endif
\ No newline at end of file
diff --git a/engine/inc/bullet/Heightfield/HeightfieldExample.h b/engine/inc/bullet/Heightfield/HeightfieldExample.h
new file mode 100644
index 00000000..258e7f70
--- /dev/null
+++ b/engine/inc/bullet/Heightfield/HeightfieldExample.h
@@ -0,0 +1,21 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2015 Google Inc. http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef HEIGHTFIELD_EXAMPLE_H
+#define HEIGHTFIELD_EXAMPLE_H
+
+class CommonExampleInterface* HeightfieldExampleCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //HEIGHTFIELD_EXAMPLE_H
\ No newline at end of file
diff --git a/engine/inc/bullet/Importers/ImportBsp/BspConverter.h b/engine/inc/bullet/Importers/ImportBsp/BspConverter.h
new file mode 100644
index 00000000..20faae66
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportBsp/BspConverter.h
@@ -0,0 +1,36 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BSP_CONVERTER_H
+#define BSP_CONVERTER_H
+
+class BspLoader;
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btAlignedObjectArray.h"
+
+///BspConverter turns a loaded bsp level into convex parts (vertices)
+class BspConverter
+{
+public:
+	void convertBsp(BspLoader& bspLoader, float scaling);
+	virtual ~BspConverter()
+	{
+	}
+
+	///this callback is called for each brush that succesfully converted into vertices
+	virtual void addConvexVerticesCollider(btAlignedObjectArray<btVector3>& vertices, bool isEntity, const btVector3& entityTargetLocation) = 0;
+};
+
+#endif  //BSP_CONVERTER_H
diff --git a/engine/inc/bullet/Importers/ImportBsp/BspLoader.h b/engine/inc/bullet/Importers/ImportBsp/BspLoader.h
new file mode 100644
index 00000000..b7089cc1
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportBsp/BspLoader.h
@@ -0,0 +1,288 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+
+This file is part of Quake III Arena source code.
+
+Quake III Arena source code is free software; you can redistribute it
+and/or modify it under the terms of the GNU bteral Public License as
+published by the Free Software Foundation; either version 2 of the License,
+or (at your option) any later version.
+
+Quake III Arena source code is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU bteral Public License for more details.
+
+You should have received a copy of the GNU bteral Public License
+along with Foobar; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+===========================================================================
+*/
+
+#ifndef BSP_LOADER_H
+#define BSP_LOADER_H
+
+#include "LinearMath/btAlignedObjectArray.h"
+
+#define BSPMAXTOKEN 1024
+#define BSPMAX_KEY 32
+#define BSPMAX_VALUE 1024
+#define BSPCONTENTS_SOLID 1
+#define BSPCONTENTS_AREAPORTAL 0x8000
+#define BSPLUMP_ENTITIES 0
+#define BSPLUMP_SHADERS 1
+#define BSPLUMP_PLANES 2
+#define BSPLUMP_NODES 3
+#define BSPLUMP_LEAFS 4
+#define BSPLUMP_LEAFSURFACES 5
+#define BSPLUMP_LEAFBRUSHES 6
+#define LUMP_MODELS 7
+#define LUMP_BRUSHES 8
+#define LUMP_BRUSHSIDES 9
+#define LUMP_DRAWVERTS 10
+#define LUMP_DRAWINDEXES 11
+#define LUMP_SURFACES 13
+#define LUMP_LIGHTMAPS 14
+#define LUMP_LIGHTGRID 15
+#define LUMP_VISIBILITY 16
+#define HEADER_LUMPS 17
+#define MAX_QPATH 64
+
+typedef struct
+{
+	int fileofs, filelen;
+} BSPLump;
+
+typedef float BSPVector3[3];
+
+typedef struct
+{
+	int ident;
+	int version;
+
+	BSPLump lumps[HEADER_LUMPS];
+} BSPHeader;
+
+typedef struct
+{
+	float mins[3], maxs[3];
+	int firstSurface, numSurfaces;
+	int firstBrush, numBrushes;
+} BSPModel;
+
+typedef struct
+{
+	char shader[MAX_QPATH];
+	int surfaceFlags;
+	int contentFlags;
+} BSPShader;
+
+typedef struct
+{
+	float normal[3];
+	float dist;
+} BSPPlane;
+
+typedef struct
+{
+	int planeNum;
+	int children[2];
+	int mins[3];
+	int maxs[3];
+} BSPNode;
+
+typedef struct
+{
+	int cluster;
+	int area;
+
+	int mins[3];
+	int maxs[3];
+
+	int firstLeafSurface;
+	int numLeafSurfaces;
+
+	int firstLeafBrush;
+	int numLeafBrushes;
+} BSPLeaf;
+
+typedef struct
+{
+	int planeNum;
+	int shaderNum;
+} BSPBrushSide;
+
+typedef struct
+{
+	int firstSide;
+	int numSides;
+	int shaderNum;
+} BSPBrush;
+
+typedef struct BSPPair
+{
+	struct BSPPair *next;
+	char *key;
+	char *value;
+} BSPKeyValuePair;
+
+typedef struct
+{
+	BSPVector3 origin;
+	struct bspbrush_s *brushes;
+	struct parseMesh_s *patches;
+	int firstDrawSurf;
+	BSPKeyValuePair *epairs;
+} BSPEntity;
+
+typedef enum
+{
+	MST_BAD,
+	MST_PLANAR,
+	MST_PATCH,
+	MST_TRIANGLE_SOUP,
+	MST_FLARE
+} BSPMapSurface;
+
+typedef struct
+{
+	int shaderNum;
+	int fogNum;
+	int surfaceType;
+
+	int firstVert;
+	int numVerts;
+
+	int firstIndex;
+	int numIndexes;
+
+	int lightmapNum;
+	int lightmapX, lightmapY;
+	int lightmapWidth, lightmapHeight;
+
+	BSPVector3 lightmapOrigin;
+	BSPVector3 lightmapVecs[3];
+
+	int patchWidth;
+	int patchHeight;
+} BSPSurface;
+
+///GPL code from IdSofware to parse a Quake 3 BSP file
+///check that your platform define __BIG_ENDIAN__ correctly (in BspLoader.cpp)
+class BspLoader
+{
+	int m_Endianness;
+
+public:
+	BspLoader();
+
+	bool loadBSPFile(void *memoryBuffer);
+
+	const char *getValueForKey(const BSPEntity *ent, const char *key) const;
+
+	bool getVectorForKey(const BSPEntity *ent, const char *key, BSPVector3 vec);
+
+	float getFloatForKey(const BSPEntity *ent, const char *key);
+
+	void parseEntities(void);
+
+	bool findVectorByName(float *outvec, const char *name);
+
+	const BSPEntity *getEntityByValue(const char *name, const char *value);
+
+protected:
+	void parseFromMemory(char *buffer, int size);
+
+	bool isEndOfScript(bool crossline);
+
+	bool getToken(bool crossline);
+
+	char *copystring(const char *s);
+
+	void stripTrailing(char *e);
+
+	BSPKeyValuePair *parseEpair(void);
+
+	bool parseEntity(void);
+
+	short isLittleShort(short l);
+	int isLittleLong(int l);
+	float isLittleFloat(float l);
+
+	int isBigLong(int l);
+	short isBigShort(short l);
+	float isBigFloat(float l);
+
+	void swapBlock(int *block, int sizeOfBlock);
+
+	int copyLump(BSPHeader *header, int lump, void *dest, int size);
+
+	void swapBSPFile(void);
+
+public:  //easier for conversion
+	int m_num_entities;
+	btAlignedObjectArray<BSPEntity> m_entities;
+
+	int m_nummodels;
+	btAlignedObjectArray<BSPModel> m_dmodels;
+
+	int m_numShaders;
+	btAlignedObjectArray<BSPShader> m_dshaders;
+
+	int m_entdatasize;
+	btAlignedObjectArray<char> m_dentdata;
+
+	int m_numleafs;
+	btAlignedObjectArray<BSPLeaf> m_dleafs;
+
+	int m_numplanes;
+	btAlignedObjectArray<BSPPlane> m_dplanes;
+
+	int m_numnodes;
+	btAlignedObjectArray<BSPNode> m_dnodes;
+
+	int m_numleafsurfaces;
+	btAlignedObjectArray<int> m_dleafsurfaces;
+
+	int m_numleafbrushes;
+	btAlignedObjectArray<int> m_dleafbrushes;
+
+	int m_numbrushes;
+	btAlignedObjectArray<BSPBrush> m_dbrushes;
+
+	int m_numbrushsides;
+	btAlignedObjectArray<BSPBrushSide> m_dbrushsides;
+
+	int m_numLightBytes;
+	btAlignedObjectArray<unsigned char> m_lightBytes;
+
+	int m_numGridPoints;
+	btAlignedObjectArray<unsigned char> m_gridData;
+
+	int m_numVisBytes;
+	btAlignedObjectArray<unsigned char> m_visBytes;
+
+	int m_numDrawIndexes;
+	btAlignedObjectArray<int> m_drawIndexes;
+
+	int m_numDrawSurfaces;
+	btAlignedObjectArray<BSPSurface> m_drawSurfaces;
+
+	enum
+	{
+		BSP_LITTLE_ENDIAN = 0,
+		BSP_BIG_ENDIAN = 1
+	};
+
+	//returns machines big endian / little endian
+	//
+	int getMachineEndianness();
+
+	inline int machineEndianness()
+	{
+		return m_Endianness;
+	}
+};
+
+#endif  //BSP_LOADER_H
diff --git a/engine/inc/bullet/Importers/ImportBsp/ImportBspExample.h b/engine/inc/bullet/Importers/ImportBsp/ImportBspExample.h
new file mode 100644
index 00000000..71f6ca92
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportBsp/ImportBspExample.h
@@ -0,0 +1,20 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef BSP_DEMO_H
+#define BSP_DEMO_H
+
+class CommonExampleInterface* ImportBspCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //BSP_DEMO_H
diff --git a/engine/inc/bullet/Importers/ImportBullet/SerializeSetup.h b/engine/inc/bullet/Importers/ImportBullet/SerializeSetup.h
new file mode 100644
index 00000000..eae85c61
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportBullet/SerializeSetup.h
@@ -0,0 +1,6 @@
+#ifndef SERIALIZE_SETUP_H
+#define SERIALIZE_SETUP_H
+
+class CommonExampleInterface* SerializeBulletCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //SERIALIZE_SETUP_H
diff --git a/engine/inc/bullet/Importers/ImportColladaDemo/ColladaGraphicsInstance.h b/engine/inc/bullet/Importers/ImportColladaDemo/ColladaGraphicsInstance.h
new file mode 100644
index 00000000..ef750d16
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportColladaDemo/ColladaGraphicsInstance.h
@@ -0,0 +1,35 @@
+/*
+Bullet Collision Detection and Physics Library http://bulletphysics.org
+This file is Copyright (c) 2014 Google Inc. 
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+
+//original author: Erwin Coumans
+*/
+
+#ifndef COLLADA_GRAPHICS_INSTANCE_H
+#define COLLADA_GRAPHICS_INSTANCE_H
+
+#include "btMatrix4x4.h"
+
+struct ColladaGraphicsInstance
+{
+	ColladaGraphicsInstance()
+		: m_shapeIndex(-1)
+	{
+		m_worldTransform.setIdentity();
+	}
+	btMatrix4x4 m_worldTransform;
+	int m_shapeIndex;  //could be index into array of GLInstanceGraphicsShape
+	float m_color[4];
+};
+
+#endif  //COLLADA_GRAPHICS_INSTANCE_H
diff --git a/engine/inc/bullet/Importers/ImportColladaDemo/ImportColladaSetup.h b/engine/inc/bullet/Importers/ImportColladaDemo/ImportColladaSetup.h
new file mode 100644
index 00000000..7f37a172
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportColladaDemo/ImportColladaSetup.h
@@ -0,0 +1,23 @@
+/*
+Bullet Collision Detection and Physics Library http://bulletphysics.org
+This file is Copyright (c) 2014 Google Inc. 
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+
+//original author: Erwin Coumans
+*/
+
+#ifndef IMPORT_COLLADA_SETUP_H
+#define IMPORT_COLLADA_SETUP_H
+
+class CommonExampleInterface* ImportColladaCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //IMPORT_COLLADA_SETUP_H
diff --git a/engine/inc/bullet/Importers/ImportColladaDemo/LoadMeshFromCollada.h b/engine/inc/bullet/Importers/ImportColladaDemo/LoadMeshFromCollada.h
new file mode 100644
index 00000000..16911ae6
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportColladaDemo/LoadMeshFromCollada.h
@@ -0,0 +1,43 @@
+/*
+Bullet Collision Detection and Physics Library http://bulletphysics.org
+This file is Copyright (c) 2014 Google Inc. 
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+
+//original author: Erwin Coumans
+*/
+
+#ifndef LOAD_MESH_FROM_COLLADA_H
+#define LOAD_MESH_FROM_COLLADA_H
+
+#include "LinearMath/btAlignedObjectArray.h"
+#include "LinearMath/btTransform.h"
+#include "../../OpenGLWindow/GLInstanceGraphicsShape.h"
+#include "ColladaGraphicsInstance.h"
+
+void LoadMeshFromCollada(const char* relativeFileName,
+						 btAlignedObjectArray<GLInstanceGraphicsShape>& visualShapes,
+						 btAlignedObjectArray<ColladaGraphicsInstance>& visualShapeInstances,
+						 btTransform& upAxisTrans,
+						 float& unitMeterScaling,
+						 int clientUpAxis,
+						 struct CommonFileIOInterface* fileIO);
+
+//#define COMPARE_WITH_ASSIMP
+#ifdef COMPARE_WITH_ASSIMP
+void LoadMeshFromColladaAssimp(const char* relativeFileName,
+							   btAlignedObjectArray<GLInstanceGraphicsShape>& visualShapes,
+							   btAlignedObjectArray<ColladaGraphicsInstance>& visualShapeInstances,
+							   btTransform& upAxisTrans,
+							   float& unitMeterScaling);
+#endif  //COMPARE_WITH_ASSIMP
+
+#endif  //LOAD_MESH_FROM_COLLADA_H
diff --git a/engine/inc/bullet/Importers/ImportColladaDemo/btMatrix4x4.h b/engine/inc/bullet/Importers/ImportColladaDemo/btMatrix4x4.h
new file mode 100644
index 00000000..54e449a2
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportColladaDemo/btMatrix4x4.h
@@ -0,0 +1,152 @@
+/*
+Bullet Collision Detection and Physics Library http://bulletphysics.org
+This file is Copyright (c) 2014 Google Inc. 
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+
+//original author: Erwin Coumans
+*/
+
+#ifndef MATRIX4x4_H
+#define MATRIX4x4_H
+
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btQuaternion.h"
+
+///This 4x4 matrix class is extremely limited, just created for the purpose of accumulating transform matrices in COLLADA .dae files
+ATTRIBUTE_ALIGNED16(class)
+btMatrix4x4
+{
+	btVector4 m_el[4];
+
+public:
+	btMatrix4x4()
+	{
+	}
+	btMatrix4x4(const btScalar& xx, const btScalar& xy, const btScalar& xz, const btScalar& xw,
+				const btScalar& yx, const btScalar& yy, const btScalar& yz, const btScalar& yw,
+				const btScalar& zx, const btScalar& zy, const btScalar& zz, const btScalar& zw,
+				const btScalar& wx, const btScalar& wy, const btScalar& wz, const btScalar& ww)
+	{
+		setValue(xx, xy, xz, xw,
+				 yx, yy, yz, yw,
+				 zx, zy, zz, zw,
+				 wx, wy, wz, ww);
+	}
+
+	~btMatrix4x4()
+	{
+	}
+
+	inline void setValue(const btScalar& xx, const btScalar& xy, const btScalar& xz, const btScalar& xw,
+						 const btScalar& yx, const btScalar& yy, const btScalar& yz, const btScalar& yw,
+						 const btScalar& zx, const btScalar& zy, const btScalar& zz, const btScalar& zw,
+						 const btScalar& wx, const btScalar& wy, const btScalar& wz, const btScalar& ww)
+	{
+		m_el[0].setValue(xx, xy, xz, xw);
+		m_el[1].setValue(yx, yy, yz, yw);
+		m_el[2].setValue(zx, zy, zz, zw);
+		m_el[3].setValue(wx, wy, wz, ww);
+	}
+
+	inline void setIdentity()
+	{
+		m_el[0].setValue(1, 0, 0, 0);
+		m_el[1].setValue(0, 1, 0, 0);
+		m_el[2].setValue(0, 0, 1, 0);
+		m_el[3].setValue(0, 0, 0, 1);
+	}
+	inline void setPureRotation(const btQuaternion& orn)
+	{
+		setIdentity();
+
+		btMatrix3x3 m3(orn);
+		for (int i = 0; i < 3; i++)
+		{
+			for (int j = 0; j < 3; j++)
+			{
+				m_el[i][j] = m3[i][j];
+			}
+		}
+	}
+
+	inline void setPureScaling(const btVector3& scale)
+	{
+		m_el[0].setValue(scale[0], 0, 0, 0);
+		m_el[1].setValue(0, scale[1], 0, 0);
+		m_el[2].setValue(0, 0, scale[2], 0);
+		m_el[3].setValue(0, 0, 0, 1);
+	}
+
+	inline void setPureTranslation(const btVector3& pos)
+	{
+		m_el[0].setValue(1, 0, 0, pos[0]);
+		m_el[1].setValue(0, 1, 0, pos[1]);
+		m_el[2].setValue(0, 0, 1, pos[2]);
+		m_el[3].setValue(0, 0, 0, 1);
+	}
+	SIMD_FORCE_INLINE const btVector4& operator[](int i) const
+	{
+		btFullAssert(0 <= i && i < 3);
+		return m_el[i];
+	}
+
+	SIMD_FORCE_INLINE btScalar tdotx(const btVector4& v) const
+	{
+		return m_el[0].x() * v.x() + m_el[1].x() * v.y() + m_el[2].x() * v.z() + m_el[3].x() * v.w();
+	}
+	SIMD_FORCE_INLINE btScalar tdoty(const btVector4& v) const
+	{
+		return m_el[0].y() * v.x() + m_el[1].y() * v.y() + m_el[2].y() * v.z() + m_el[3].y() * v.w();
+	}
+	SIMD_FORCE_INLINE btScalar tdotz(const btVector4& v) const
+	{
+		return m_el[0].z() * v.x() + m_el[1].z() * v.y() + m_el[2].z() * v.z() + m_el[3].z() * v.w();
+	}
+	SIMD_FORCE_INLINE btScalar tdotw(const btVector4& v) const
+	{
+		return m_el[0].w() * v.x() + m_el[1].w() * v.y() + m_el[2].w() * v.z() + m_el[3].w() * v.w();
+	}
+
+	SIMD_FORCE_INLINE btMatrix4x4&
+	operator*=(const btMatrix4x4& m)
+	{
+		setValue(
+			m.tdotx(m_el[0]), m.tdoty(m_el[0]), m.tdotz(m_el[0]), m.tdotw(m_el[0]),
+			m.tdotx(m_el[1]), m.tdoty(m_el[1]), m.tdotz(m_el[1]), m.tdotw(m_el[1]),
+			m.tdotx(m_el[2]), m.tdoty(m_el[2]), m.tdotz(m_el[2]), m.tdotw(m_el[2]),
+			m.tdotx(m_el[3]), m.tdoty(m_el[3]), m.tdotz(m_el[3]), m.tdotw(m_el[3]));
+		return *this;
+	}
+};
+
+inline btScalar btDot4(const btVector4& v0, const btVector4& v1)
+{
+	return v0.x() * v1.x() + v0.y() * v1.y() + v0.z() * v1.z() + v0.w() * v1.w();
+}
+SIMD_FORCE_INLINE btVector3
+operator*(const btMatrix4x4& m, const btVector3& v1)
+{
+	btVector4 v(v1[0], v1[1], v1[2], 1);
+	return btVector3(btDot4(m[0], v), btDot4(m[1], v), btDot4(m[2], v));
+}
+
+SIMD_FORCE_INLINE btMatrix4x4
+operator*(const btMatrix4x4& m1, btMatrix4x4& m2)
+{
+	return btMatrix4x4(
+		m2.tdotx(m1[0]), m2.tdoty(m1[0]), m2.tdotz(m1[0]), m2.tdotw(m1[0]),
+		m2.tdotx(m1[1]), m2.tdoty(m1[1]), m2.tdotz(m1[1]), m2.tdotw(m1[1]),
+		m2.tdotx(m1[2]), m2.tdoty(m1[2]), m2.tdotz(m1[2]), m2.tdotw(m1[2]),
+		m2.tdotx(m1[3]), m2.tdoty(m1[3]), m2.tdotz(m1[3]), m2.tdotw(m1[3]));
+}
+
+#endif  //MATRIX4x4_H
diff --git a/engine/inc/bullet/Importers/ImportMJCFDemo/BulletMJCFImporter.h b/engine/inc/bullet/Importers/ImportMJCFDemo/BulletMJCFImporter.h
new file mode 100644
index 00000000..d4de6b28
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportMJCFDemo/BulletMJCFImporter.h
@@ -0,0 +1,93 @@
+#ifndef BULLET_MJCF_IMPORTER_H
+#define BULLET_MJCF_IMPORTER_H
+
+#include "../ImportURDFDemo/URDFImporterInterface.h"
+#include "../ImportURDFDemo/UrdfRenderingInterface.h"
+
+struct MJCFErrorLogger
+{
+	virtual ~MJCFErrorLogger() {}
+	virtual void reportError(const char* error) = 0;
+	virtual void reportWarning(const char* warning) = 0;
+	virtual void printMessage(const char* msg) = 0;
+};
+
+struct MJCFURDFTexture
+{
+	int m_width;
+	int m_height;
+	unsigned char* textureData1;
+	bool m_isCached;
+};
+
+class BulletMJCFImporter : public URDFImporterInterface
+{
+	struct BulletMJCFImporterInternalData* m_data;
+
+	void convertURDFToVisualShapeInternal(const struct UrdfVisual* visual, const char* urdfPathPrefix, const btTransform& visualTransform, btAlignedObjectArray<struct GLInstanceVertex>& verticesOut, btAlignedObjectArray<int>& indicesOut, btAlignedObjectArray<MJCFURDFTexture>& texturesOut) const;
+
+public:
+	BulletMJCFImporter(struct GUIHelperInterface* helper, UrdfRenderingInterface* customConverter,  struct CommonFileIOInterface* fileIO, int flags);
+	virtual ~BulletMJCFImporter();
+
+	virtual bool parseMJCFString(const char* xmlString, MJCFErrorLogger* logger);
+
+	virtual bool loadMJCF(const char* fileName, MJCFErrorLogger* logger, bool forceFixedBase = false);
+
+	virtual bool loadURDF(const char* fileName, bool forceFixedBase = false)
+	{
+		return false;
+	}
+
+	virtual bool loadSDF(const char* fileName, bool forceFixedBase = false) { return false; }
+
+	virtual const char* getPathPrefix();
+
+	///return >=0 for the root link index, -1 if there is no root link
+	virtual int getRootLinkIndex() const;
+
+	///pure virtual interfaces, precondition is a valid linkIndex (you can assert/terminate if the linkIndex is out of range)
+	virtual std::string getLinkName(int linkIndex) const;
+
+	virtual std::string getBodyName() const;
+
+	/// optional method to provide the link color. return true if the color is available and copied into colorRGBA, return false otherwise
+	virtual bool getLinkColor(int linkIndex, btVector4& colorRGBA) const;
+	bool getLinkColor2(int linkIndex, struct UrdfMaterialColor& matCol) const;
+
+	//optional method to get collision group (type) and mask (affinity)
+	virtual int getCollisionGroupAndMask(int linkIndex, int& colGroup, int& colMask) const;
+
+	///this API will likely change, don't override it!
+	virtual bool getLinkContactInfo(int linkIndex, URDFLinkContactInfo& contactInfo) const;
+
+	virtual std::string getJointName(int linkIndex) const;
+
+	//fill mass and inertial data. If inertial data is missing, please initialize mass, inertia to sensitive values, and inertialFrame to identity.
+	virtual void getMassAndInertia(int urdfLinkIndex, btScalar& mass, btVector3& localInertiaDiagonal, btTransform& inertialFrame) const;
+
+	///fill an array of child link indices for this link, btAlignedObjectArray behaves like a std::vector so just use push_back and resize(0) if needed
+	virtual void getLinkChildIndices(int urdfLinkIndex, btAlignedObjectArray<int>& childLinkIndices) const;
+
+	virtual bool getJointInfo(int urdfLinkIndex, btTransform& parent2joint, btTransform& linkTransformInWorld, btVector3& jointAxisInJointSpace, int& jointType, btScalar& jointLowerLimit, btScalar& jointUpperLimit, btScalar& jointDamping, btScalar& jointFriction) const;
+	virtual bool getJointInfo2(int urdfLinkIndex, btTransform& parent2joint, btTransform& linkTransformInWorld, btVector3& jointAxisInJointSpace, int& jointType, btScalar& jointLowerLimit, btScalar& jointUpperLimit, btScalar& jointDamping, btScalar& jointFriction, btScalar& jointMaxForce, btScalar& jointMaxVelocity) const;
+
+	virtual bool getRootTransformInWorld(btTransform& rootTransformInWorld) const;
+
+	virtual int convertLinkVisualShapes(int linkIndex, const char* pathPrefix, const btTransform& inertialFrame) const;
+
+	virtual void convertLinkVisualShapes2(int linkIndex, int urdfIndex, const char* pathPrefix, const btTransform& inertialFrame, class btCollisionObject* colObj, int objectIndex) const;
+	virtual void setBodyUniqueId(int bodyId);
+	virtual int getBodyUniqueId() const;
+
+	virtual class btCompoundShape* convertLinkCollisionShapes(int linkIndex, const char* pathPrefix, const btTransform& localInertiaFrame) const;
+	virtual int getNumAllocatedCollisionShapes() const;
+	virtual class btCollisionShape* getAllocatedCollisionShape(int index);
+	virtual int getNumModels() const;
+	virtual void activateModel(int modelIndex);
+
+	virtual int getNumAllocatedMeshInterfaces() const;
+	virtual btStridingMeshInterface* getAllocatedMeshInterface(int index);
+};
+
+#endif  //BULLET_MJCF_IMPORTER_H
diff --git a/engine/inc/bullet/Importers/ImportMJCFDemo/ImportMJCFSetup.h b/engine/inc/bullet/Importers/ImportMJCFDemo/ImportMJCFSetup.h
new file mode 100644
index 00000000..fdfa16ca
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportMJCFDemo/ImportMJCFSetup.h
@@ -0,0 +1,6 @@
+#ifndef IMPORT_MJCF_SETUP_H
+#define IMPORT_MJCF_SETUP_H
+
+class CommonExampleInterface* ImportMJCFCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //IMPORT_MJCF_SETUP_H
diff --git a/engine/inc/bullet/Importers/ImportMeshUtility/b3ImportMeshUtility.h b/engine/inc/bullet/Importers/ImportMeshUtility/b3ImportMeshUtility.h
new file mode 100644
index 00000000..1cff27b1
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportMeshUtility/b3ImportMeshUtility.h
@@ -0,0 +1,42 @@
+#ifndef B3_IMPORT_MESH_UTILITY_H
+#define B3_IMPORT_MESH_UTILITY_H
+
+#include <string>
+
+enum b3ImportMeshDataFlags
+{
+	B3_IMPORT_MESH_HAS_RGBA_COLOR=1,
+	B3_IMPORT_MESH_HAS_SPECULAR_COLOR=2,
+};
+
+struct b3ImportMeshData
+{
+	struct GLInstanceGraphicsShape* m_gfxShape;
+
+	unsigned char* m_textureImage1;  //in 3 component 8-bit RGB data
+	bool m_isCached;
+	int m_textureWidth;
+	int m_textureHeight;
+	double m_rgbaColor[4];
+	double m_specularColor[4];
+	int m_flags;
+
+	b3ImportMeshData()
+		:m_gfxShape(0),
+		m_textureImage1(0),
+		m_isCached(false),
+		m_textureWidth(0),
+		m_textureHeight(0),
+		m_flags(0)
+	{
+	}
+
+};
+
+class b3ImportMeshUtility
+{
+public:
+	static bool loadAndRegisterMeshFromFileInternal(const std::string& fileName, b3ImportMeshData& meshData, struct CommonFileIOInterface* fileIO);
+};
+
+#endif  //B3_IMPORT_MESH_UTILITY_H
diff --git a/engine/inc/bullet/Importers/ImportObjDemo/ImportObjExample.h b/engine/inc/bullet/Importers/ImportObjDemo/ImportObjExample.h
new file mode 100644
index 00000000..b14f2fe0
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportObjDemo/ImportObjExample.h
@@ -0,0 +1,6 @@
+#ifndef IMPORT_OBJ_EXAMPLE_H
+#define IMPORT_OBJ_EXAMPLE_H
+
+class CommonExampleInterface* ImportObjCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //IMPORT_OBJ_EXAMPLE_H
diff --git a/engine/inc/bullet/Importers/ImportObjDemo/LoadMeshFromObj.h b/engine/inc/bullet/Importers/ImportObjDemo/LoadMeshFromObj.h
new file mode 100644
index 00000000..54bc6631
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportObjDemo/LoadMeshFromObj.h
@@ -0,0 +1,20 @@
+#ifndef LOAD_MESH_FROM_OBJ_H
+#define LOAD_MESH_FROM_OBJ_H
+
+struct GLInstanceGraphicsShape;
+
+#include "../../ThirdPartyLibs/Wavefront/tiny_obj_loader.h"
+
+int b3IsFileCachingEnabled();
+void b3EnableFileCaching(int enable);
+
+std::string LoadFromCachedOrFromObj(
+	tinyobj::attrib_t& attribute,
+	std::vector<tinyobj::shape_t>& shapes,  // [output]
+	const char* filename,
+	const char* mtl_basepath,
+	struct CommonFileIOInterface* fileIO);
+
+GLInstanceGraphicsShape* LoadMeshFromObj(const char* relativeFileName, const char* materialPrefixPath,struct CommonFileIOInterface* fileIO);
+
+#endif  //LOAD_MESH_FROM_OBJ_H
diff --git a/engine/inc/bullet/Importers/ImportObjDemo/Wavefront2GLInstanceGraphicsShape.h b/engine/inc/bullet/Importers/ImportObjDemo/Wavefront2GLInstanceGraphicsShape.h
new file mode 100644
index 00000000..4054b4da
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportObjDemo/Wavefront2GLInstanceGraphicsShape.h
@@ -0,0 +1,9 @@
+#ifndef WAVEFRONT2GRAPHICS_H
+#define WAVEFRONT2GRAPHICS_H
+
+#include "../../ThirdPartyLibs/Wavefront/tiny_obj_loader.h"
+#include <vector>
+
+struct GLInstanceGraphicsShape* btgCreateGraphicsShapeFromWavefrontObj(const tinyobj::attrib_t& attribute, std::vector<tinyobj::shape_t>& shapes, bool flatShading = false);
+
+#endif  //WAVEFRONT2GRAPHICS_H
diff --git a/engine/inc/bullet/Importers/ImportSDFDemo/ImportSDFSetup.h b/engine/inc/bullet/Importers/ImportSDFDemo/ImportSDFSetup.h
new file mode 100644
index 00000000..2aeb0228
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportSDFDemo/ImportSDFSetup.h
@@ -0,0 +1,6 @@
+#ifndef IMPORT_SDF_SETUP_H
+#define IMPORT_SDF_SETUP_H
+
+class CommonExampleInterface* ImportSDFCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //IMPORT_SDF_SETUP_H
diff --git a/engine/inc/bullet/Importers/ImportSTLDemo/ImportSTLSetup.h b/engine/inc/bullet/Importers/ImportSTLDemo/ImportSTLSetup.h
new file mode 100644
index 00000000..5493f3f5
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportSTLDemo/ImportSTLSetup.h
@@ -0,0 +1,6 @@
+#ifndef IMPORT_STL_SETUP_H
+#define IMPORT_STL_SETUP_H
+
+class CommonExampleInterface* ImportSTLCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //IMPORT_OBJ_SETUP_H
diff --git a/engine/inc/bullet/Importers/ImportSTLDemo/LoadMeshFromSTL.h b/engine/inc/bullet/Importers/ImportSTLDemo/LoadMeshFromSTL.h
new file mode 100644
index 00000000..6e8dbed9
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportSTLDemo/LoadMeshFromSTL.h
@@ -0,0 +1,107 @@
+#ifndef LOAD_MESH_FROM_STL_H
+#define LOAD_MESH_FROM_STL_H
+
+#include "../../OpenGLWindow/GLInstanceGraphicsShape.h"
+#include <stdio.h>  //fopen
+#include "Bullet3Common/b3AlignedObjectArray.h"
+#include "../../CommonInterfaces/CommonFileIOInterface.h"
+#include <string.h> //memcpy
+struct MySTLTriangle
+{
+	float normal[3];
+	float vertex0[3];
+	float vertex1[3];
+	float vertex2[3];
+};
+
+static GLInstanceGraphicsShape* LoadMeshFromSTL(const char* relativeFileName, struct CommonFileIOInterface* fileIO)
+{
+	GLInstanceGraphicsShape* shape = 0;
+
+	int fileHandle = fileIO->fileOpen(relativeFileName, "rb");
+	if (fileHandle>=0)
+	{
+		int size = 0;
+		size = fileIO->getFileSize(fileHandle);
+		{
+			if (size>=0)
+			{
+				//b3Warning("Open STL file of %d bytes\n",size);
+				char* memoryBuffer = new char[size + 1];
+				int actualBytesRead = fileIO->fileRead(fileHandle, memoryBuffer, size);
+				if (actualBytesRead != size)
+				{
+					b3Warning("Error reading from file %s", relativeFileName);
+				}
+				else
+				{
+					int numTriangles = *(int*)&memoryBuffer[80];
+
+					if (numTriangles)
+					{
+						{
+							//perform a sanity check instead of crashing on invalid triangles/STL files
+							int expectedBinaryFileSize = numTriangles * 50 + 84;
+							if (expectedBinaryFileSize != size)
+							{
+								delete[] memoryBuffer;
+								fileIO->fileClose(fileHandle);
+								return 0;
+							}
+						}
+						shape = new GLInstanceGraphicsShape;
+						//						b3AlignedObjectArray<GLInstanceVertex>*	m_vertices;
+						//						int				m_numvertices;
+						//						b3AlignedObjectArray<int>* 		m_indices;
+						//						int				m_numIndices;
+						//						float			m_scaling[4];
+						shape->m_scaling[0] = 1;
+						shape->m_scaling[1] = 1;
+						shape->m_scaling[2] = 1;
+						shape->m_scaling[3] = 1;
+						int index = 0;
+						shape->m_indices = new b3AlignedObjectArray<int>();
+						shape->m_vertices = new b3AlignedObjectArray<GLInstanceVertex>();
+						for (int i = 0; i < numTriangles; i++)
+						{
+							char* curPtr = &memoryBuffer[84 + i * 50];
+							MySTLTriangle tmp;
+							memcpy(&tmp, curPtr, sizeof(MySTLTriangle));
+
+							GLInstanceVertex v0, v1, v2;
+							v0.uv[0] = v1.uv[0] = v2.uv[0] = 0.5;
+							v0.uv[1] = v1.uv[1] = v2.uv[1] = 0.5;
+							for (int v = 0; v < 3; v++)
+							{
+								v0.xyzw[v] = tmp.vertex0[v];
+								v1.xyzw[v] = tmp.vertex1[v];
+								v2.xyzw[v] = tmp.vertex2[v];
+								v0.normal[v] = v1.normal[v] = v2.normal[v] = tmp.normal[v];
+							}
+							v0.xyzw[3] = v1.xyzw[3] = v2.xyzw[3] = 0.f;
+
+							shape->m_vertices->push_back(v0);
+							shape->m_vertices->push_back(v1);
+							shape->m_vertices->push_back(v2);
+
+							shape->m_indices->push_back(index++);
+							shape->m_indices->push_back(index++);
+							shape->m_indices->push_back(index++);
+						}
+					}
+				}
+
+				delete[] memoryBuffer;
+			}
+		}
+		fileIO->fileClose(fileHandle);
+	}
+	if (shape)
+	{
+		shape->m_numIndices = shape->m_indices->size();
+		shape->m_numvertices = shape->m_vertices->size();
+	}
+	return shape;
+}
+
+#endif  //LOAD_MESH_FROM_STL_H
diff --git a/engine/inc/bullet/Importers/ImportURDFDemo/BulletUrdfImporter.h b/engine/inc/bullet/Importers/ImportURDFDemo/BulletUrdfImporter.h
new file mode 100644
index 00000000..eb890c01
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportURDFDemo/BulletUrdfImporter.h
@@ -0,0 +1,97 @@
+#ifndef BULLET_URDF_IMPORTER_H
+#define BULLET_URDF_IMPORTER_H
+
+#include "URDFImporterInterface.h"
+#include "UrdfRenderingInterface.h"
+#include "UrdfParser.h"
+
+struct BulletURDFTexture
+{
+	int m_width;
+	int m_height;
+	unsigned char* textureData1;
+	bool m_isCached;
+};
+
+///BulletURDFImporter can deal with URDF and (soon) SDF files
+class BulletURDFImporter : public URDFImporterInterface
+{
+	struct BulletURDFInternalData* m_data;
+
+public:
+	BulletURDFImporter(struct GUIHelperInterface* helper, UrdfRenderingInterface* customConverter, struct CommonFileIOInterface* fileIO=0,double globalScaling=1, int flags=0);
+
+	virtual ~BulletURDFImporter();
+
+	virtual bool loadURDF(const char* fileName, bool forceFixedBase = false);
+
+	//warning: some quick test to load SDF: we 'activate' a model, so we can re-use URDF code path
+	virtual bool loadSDF(const char* fileName, bool forceFixedBase = false);
+	virtual int getNumModels() const;
+	virtual void activateModel(int modelIndex);
+	virtual void setBodyUniqueId(int bodyId);
+	virtual int getBodyUniqueId() const;
+	const char* getPathPrefix();
+
+	void printTree();  //for debugging
+
+	virtual int getRootLinkIndex() const;
+
+	virtual void getLinkChildIndices(int linkIndex, btAlignedObjectArray<int>& childLinkIndices) const;
+
+	virtual std::string getBodyName() const;
+
+	virtual std::string getLinkName(int linkIndex) const;
+
+	virtual bool getLinkColor(int linkIndex, btVector4& colorRGBA) const;
+
+	virtual bool getLinkColor2(int linkIndex, UrdfMaterialColor& matCol) const;
+
+	virtual void setLinkColor2(int linkIndex, struct UrdfMaterialColor& matCol) const;
+
+	virtual bool getLinkContactInfo(int urdflinkIndex, URDFLinkContactInfo& contactInfo) const;
+
+	virtual bool getLinkAudioSource(int linkIndex, SDFAudioSource& audioSource) const;
+
+	virtual std::string getJointName(int linkIndex) const;
+
+	virtual void getMassAndInertia(int linkIndex, btScalar& mass, btVector3& localInertiaDiagonal, btTransform& inertialFrame) const;
+	virtual void getMassAndInertia2(int urdfLinkIndex, btScalar& mass, btVector3& localInertiaDiagonal, btTransform& inertialFrame, int flags) const;
+
+	virtual bool getJointInfo(int urdfLinkIndex, btTransform& parent2joint, btTransform& linkTransformInWorld, btVector3& jointAxisInJointSpace, int& jointType, btScalar& jointLowerLimit, btScalar& jointUpperLimit, btScalar& jointDamping, btScalar& jointFriction) const;
+	virtual bool getJointInfo2(int urdfLinkIndex, btTransform& parent2joint, btTransform& linkTransformInWorld, btVector3& jointAxisInJointSpace, int& jointType, btScalar& jointLowerLimit, btScalar& jointUpperLimit, btScalar& jointDamping, btScalar& jointFriction, btScalar& jointMaxForce, btScalar& jointMaxVelocity) const;
+
+	virtual bool getRootTransformInWorld(btTransform& rootTransformInWorld) const;
+	virtual void setRootTransformInWorld(const btTransform& rootTransformInWorld);
+
+	virtual int convertLinkVisualShapes(int linkIndex, const char* pathPrefix, const btTransform& inertialFrame) const;
+
+	virtual void convertLinkVisualShapes2(int linkIndex, int urdfIndex, const char* pathPrefix, const btTransform& inertialFrame, class btCollisionObject* colObj, int bodyUniqueId) const;
+
+	class btCollisionShape* convertURDFToCollisionShape(const struct UrdfCollision* collision, const char* urdfPathPrefix) const;
+
+	virtual int getUrdfFromCollisionShape(const btCollisionShape* collisionShape, UrdfCollision& collision) const;
+
+	///todo(erwincoumans) refactor this convertLinkCollisionShapes/memory allocation
+
+	virtual const struct UrdfModel* getUrdfModel() const;
+
+	virtual class btCompoundShape* convertLinkCollisionShapes(int linkIndex, const char* pathPrefix, const btTransform& localInertiaFrame) const;
+
+	virtual int getCollisionGroupAndMask(int linkIndex, int& colGroup, int& colMask) const;
+
+	virtual int getNumAllocatedCollisionShapes() const;
+	virtual class btCollisionShape* getAllocatedCollisionShape(int index);
+
+	virtual int getNumAllocatedMeshInterfaces() const;
+	virtual class btStridingMeshInterface* getAllocatedMeshInterface(int index);
+
+	virtual int getNumAllocatedTextures() const;
+	virtual int getAllocatedTexture(int index) const;
+
+	virtual void setEnableTinyRenderer(bool enable);
+	void convertURDFToVisualShapeInternal(const struct UrdfVisual* visual, const char* urdfPathPrefix, const class btTransform& visualTransform, btAlignedObjectArray<struct GLInstanceVertex>& verticesOut, btAlignedObjectArray<int>& indicesOut, btAlignedObjectArray<struct BulletURDFTexture>& texturesOut, struct b3ImportMeshData& meshData) const;
+	const struct UrdfDeformable& getDeformableModel() const;
+};
+
+#endif  //BULLET_URDF_IMPORTER_H
diff --git a/engine/inc/bullet/Importers/ImportURDFDemo/ConvertRigidBodies2MultiBody.h b/engine/inc/bullet/Importers/ImportURDFDemo/ConvertRigidBodies2MultiBody.h
new file mode 100644
index 00000000..4dbc51aa
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportURDFDemo/ConvertRigidBodies2MultiBody.h
@@ -0,0 +1,13 @@
+#ifndef CONVERT_RIGIDBODIES_2_MULTIBODY_H
+#define CONVERT_RIGIDBODIES_2_MULTIBODY_H
+
+struct ConvertRigidBodies2MultiBody
+{
+	btAlignedObjectArray<btRigidBody*> m_bodies;
+	btAlignedObjectArray<btTypedConstraint*> m_constraints;
+
+	virtual void addRigidBody(btRigidBody* body);
+	virtual void addConstraint(btTypedConstraint* constraint, bool disableCollisionsBetweenLinkedBodies = false);
+	virtual btMultiBody* convertToMultiBody();
+};
+#endif  //CONVERT_RIGIDBODIES_2_MULTIBODY_H
diff --git a/engine/inc/bullet/Importers/ImportURDFDemo/ImportURDFSetup.h b/engine/inc/bullet/Importers/ImportURDFDemo/ImportURDFSetup.h
new file mode 100644
index 00000000..f0c6498e
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportURDFDemo/ImportURDFSetup.h
@@ -0,0 +1,6 @@
+#ifndef IMPORT_URDF_SETUP_H
+#define IMPORT_URDF_SETUP_H
+
+class CommonExampleInterface* ImportURDFCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //IMPORT_URDF_SETUP_H
diff --git a/engine/inc/bullet/Importers/ImportURDFDemo/MultiBodyCreationInterface.h b/engine/inc/bullet/Importers/ImportURDFDemo/MultiBodyCreationInterface.h
new file mode 100644
index 00000000..1acc47dd
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportURDFDemo/MultiBodyCreationInterface.h
@@ -0,0 +1,42 @@
+#ifndef MULTIBODY_CREATION_INTERFACE_H
+#define MULTIBODY_CREATION_INTERFACE_H
+
+#include "LinearMath/btTransform.h"
+
+class MultiBodyCreationInterface
+{
+public:
+	virtual ~MultiBodyCreationInterface() {}
+
+	virtual void createRigidBodyGraphicsInstance(int linkIndex, class btRigidBody* body, const btVector3& colorRgba, int graphicsIndex) = 0;
+	virtual void createRigidBodyGraphicsInstance2(int linkIndex, class btRigidBody* body, const btVector3& colorRgba, const btVector3& specularColor, int graphicsIndex)
+	{
+		createRigidBodyGraphicsInstance(linkIndex, body, colorRgba, graphicsIndex);
+	}
+
+	///optionally create some graphical representation from a collision object, usually for visual debugging purposes.
+	virtual void createCollisionObjectGraphicsInstance(int linkIndex, class btCollisionObject* col, const btVector3& colorRgba) = 0;
+	virtual void createCollisionObjectGraphicsInstance2(int linkIndex, class btCollisionObject* col, const btVector4& colorRgba, const btVector3& specularColor)
+	{
+		createCollisionObjectGraphicsInstance(linkIndex, col, colorRgba);
+	}
+
+	virtual class btMultiBody* allocateMultiBody(int urdfLinkIndex, int totalNumJoints, btScalar mass, const btVector3& localInertiaDiagonal, bool isFixedBase, bool canSleep) = 0;
+
+	virtual class btRigidBody* allocateRigidBody(int urdfLinkIndex, btScalar mass, const btVector3& localInertiaDiagonal, const btTransform& initialWorldTrans, class btCollisionShape* colShape) = 0;
+
+	virtual class btGeneric6DofSpring2Constraint* allocateGeneric6DofSpring2Constraint(int urdfLinkIndex, btRigidBody& rbA /*parent*/, btRigidBody& rbB, const btTransform& offsetInA, const btTransform& offsetInB, int rotateOrder = 0) = 0;
+
+	virtual class btGeneric6DofSpring2Constraint* createPrismaticJoint(int urdfLinkIndex, btRigidBody& rbA /*parent*/, btRigidBody& rbB, const btTransform& offsetInA, const btTransform& offsetInB,
+																	   const btVector3& jointAxisInJointSpace, btScalar jointLowerLimit, btScalar jointUpperLimit) = 0;
+	virtual class btGeneric6DofSpring2Constraint* createRevoluteJoint(int urdfLinkIndex, btRigidBody& rbA /*parent*/, btRigidBody& rbB, const btTransform& offsetInA, const btTransform& offsetInB,
+																	  const btVector3& jointAxisInJointSpace, btScalar jointLowerLimit, btScalar jointUpperLimit) = 0;
+
+	virtual class btGeneric6DofSpring2Constraint* createFixedJoint(int urdfLinkIndex, btRigidBody& rbA /*parent*/, btRigidBody& rbB, const btTransform& offsetInA, const btTransform& offsetInB) = 0;
+
+	virtual class btMultiBodyLinkCollider* allocateMultiBodyLinkCollider(int urdfLinkIndex, int mbLinkIndex, btMultiBody* body) = 0;
+
+	virtual void addLinkMapping(int urdfLinkIndex, int mbLinkIndex) = 0;
+};
+
+#endif  //MULTIBODY_CREATION_INTERFACE_H
\ No newline at end of file
diff --git a/engine/inc/bullet/Importers/ImportURDFDemo/MyMultiBodyCreator.h b/engine/inc/bullet/Importers/ImportURDFDemo/MyMultiBodyCreator.h
new file mode 100644
index 00000000..c2885236
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportURDFDemo/MyMultiBodyCreator.h
@@ -0,0 +1,80 @@
+
+#ifndef MY_MULTIBODY_CREATOR
+#define MY_MULTIBODY_CREATOR
+
+#include "MultiBodyCreationInterface.h"
+#include "LinearMath/btAlignedObjectArray.h"
+#include "LinearMath/btHashMap.h"
+
+struct GUIHelperInterface;
+class btMultiBody;
+
+struct GenericConstraintUserInfo
+{
+	int m_urdfIndex;
+	int m_urdfJointType;
+	btVector3 m_jointAxisInJointSpace;
+	int m_jointAxisIndex;
+	btScalar m_lowerJointLimit;
+	btScalar m_upperJointLimit;
+};
+
+class MyMultiBodyCreator : public MultiBodyCreationInterface
+{
+protected:
+	btMultiBody* m_bulletMultiBody;
+	btRigidBody* m_rigidBody;
+
+	struct GUIHelperInterface* m_guiHelper;
+
+	btAlignedObjectArray<btGeneric6DofSpring2Constraint*> m_6DofConstraints;
+
+public:
+	btAlignedObjectArray<int> m_mb2urdfLink;
+
+	MyMultiBodyCreator(GUIHelperInterface* guiHelper);
+
+	virtual ~MyMultiBodyCreator() {}
+
+	virtual void createRigidBodyGraphicsInstance(int linkIndex, class btRigidBody* body, const btVector3& colorRgba, int graphicsIndex);
+	virtual void createRigidBodyGraphicsInstance2(int linkIndex, class btRigidBody* body, const btVector3& colorRgba, const btVector3& specularColor, int graphicsIndex);
+
+	///optionally create some graphical representation from a collision object, usually for visual debugging purposes.
+	virtual void createCollisionObjectGraphicsInstance(int linkIndex, class btCollisionObject* col, const btVector3& colorRgba);
+	virtual void createCollisionObjectGraphicsInstance2(int linkIndex, class btCollisionObject* col, const btVector4& colorRgba, const btVector3& specularColor);
+
+	virtual class btMultiBody* allocateMultiBody(int urdfLinkIndex, int totalNumJoints, btScalar mass, const btVector3& localInertiaDiagonal, bool isFixedBase, bool canSleep);
+
+	virtual class btRigidBody* allocateRigidBody(int urdfLinkIndex, btScalar mass, const btVector3& localInertiaDiagonal, const btTransform& initialWorldTrans, class btCollisionShape* colShape);
+
+	virtual class btGeneric6DofSpring2Constraint* allocateGeneric6DofSpring2Constraint(int urdfLinkIndex, btRigidBody& rbA /*parent*/, btRigidBody& rbB, const btTransform& offsetInA, const btTransform& offsetInB, int rotateOrder = 0);
+
+	virtual class btGeneric6DofSpring2Constraint* createPrismaticJoint(int urdfLinkIndex, btRigidBody& rbA /*parent*/, btRigidBody& rbB, const btTransform& offsetInA, const btTransform& offsetInB,
+																	   const btVector3& jointAxisInJointSpace, btScalar jointLowerLimit, btScalar jointUpperLimit);
+	virtual class btGeneric6DofSpring2Constraint* createRevoluteJoint(int urdfLinkIndex, btRigidBody& rbA /*parent*/, btRigidBody& rbB, const btTransform& offsetInA, const btTransform& offsetInB,
+																	  const btVector3& jointAxisInJointSpace, btScalar jointLowerLimit, btScalar jointUpperLimit);
+
+	virtual class btGeneric6DofSpring2Constraint* createFixedJoint(int urdfLinkIndex, btRigidBody& rbA /*parent*/, btRigidBody& rbB, const btTransform& offsetInA, const btTransform& offsetInB);
+
+	virtual class btMultiBodyLinkCollider* allocateMultiBodyLinkCollider(int urdfLinkIndex, int mbLinkIndex, btMultiBody* body);
+
+	virtual void addLinkMapping(int urdfLinkIndex, int mbLinkIndex);
+
+	btMultiBody* getBulletMultiBody();
+	btRigidBody* getRigidBody()
+	{
+		return m_rigidBody;
+	}
+
+	int getNum6DofConstraints() const
+	{
+		return m_6DofConstraints.size();
+	}
+
+	btGeneric6DofSpring2Constraint* get6DofConstraint(int index)
+	{
+		return m_6DofConstraints[index];
+	}
+};
+
+#endif  //MY_MULTIBODY_CREATOR
diff --git a/engine/inc/bullet/Importers/ImportURDFDemo/SDFAudioTypes.h b/engine/inc/bullet/Importers/ImportURDFDemo/SDFAudioTypes.h
new file mode 100644
index 00000000..d3928f3b
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportURDFDemo/SDFAudioTypes.h
@@ -0,0 +1,44 @@
+#ifndef SDF_AUDIO_TYPES_H
+#define SDF_AUDIO_TYPES_H
+
+#include <string>
+
+///See audio_source element in http://sdformat.org/spec?ver=1.6&elem=link
+struct SDFAudioSource
+{
+	enum
+	{
+		SDFAudioSourceValid = 1,
+		SDFAudioSourceLooping = 2,
+	};
+
+	int m_flags;  //repeat mode (0 = no repeat, 1 = loop forever)
+
+	std::string m_uri;  //media filename of the sound, .wav file
+	double m_pitch;     //1 = regular rate, -1 play in reverse
+	double m_gain;      //normalized volume in range [0..1] where 0 is silent, 1 is most loud
+
+	double m_attackRate;
+	double m_decayRate;
+	double m_sustainLevel;
+	double m_releaseRate;
+
+	double m_collisionForceThreshold;  //force that will trigger the audio, in Newton. If < 0, audio source is invalid
+
+	int m_userIndex;
+
+	SDFAudioSource()
+		: m_flags(0),
+		  m_pitch(1),
+		  m_gain(1),
+		  m_attackRate(0.0001),
+		  m_decayRate(0.00001),
+		  m_sustainLevel(0.5),
+		  m_releaseRate(0.0005),
+		  m_collisionForceThreshold(0.5),
+		  m_userIndex(-1)
+	{
+	}
+};
+
+#endif  //SDF_AUDIO_TYPES_H
diff --git a/engine/inc/bullet/Importers/ImportURDFDemo/URDF2Bullet.h b/engine/inc/bullet/Importers/ImportURDFDemo/URDF2Bullet.h
new file mode 100644
index 00000000..233091c1
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportURDFDemo/URDF2Bullet.h
@@ -0,0 +1,33 @@
+#ifndef _URDF2BULLET_H
+#define _URDF2BULLET_H
+#include "LinearMath/btAlignedObjectArray.h"
+#include "LinearMath/btTransform.h"
+#include <string>
+#include "URDFJointTypes.h"  //for UrdfMaterialColor cache
+
+class btVector3;
+class btTransform;
+class btMultiBodyDynamicsWorld;
+class btTransform;
+
+class URDFImporterInterface;
+class MultiBodyCreationInterface;
+
+
+
+struct UrdfVisualShapeCache
+{
+	btAlignedObjectArray<UrdfMaterialColor> m_cachedUrdfLinkColors;
+	btAlignedObjectArray<int> m_cachedUrdfLinkVisualShapeIndices;
+};
+
+void ConvertURDF2Bullet(const URDFImporterInterface& u2b,
+						MultiBodyCreationInterface& creationCallback,
+						const btTransform& rootTransformInWorldSpace,
+						btMultiBodyDynamicsWorld* world,
+						bool createMultiBody,
+						const char* pathPrefix,
+						int flags = 0,
+						UrdfVisualShapeCache* cachedLinkGraphicsShapes = 0);
+
+#endif  //_URDF2BULLET_H
diff --git a/engine/inc/bullet/Importers/ImportURDFDemo/URDFImporterInterface.h b/engine/inc/bullet/Importers/ImportURDFDemo/URDFImporterInterface.h
new file mode 100644
index 00000000..0bf494b0
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportURDFDemo/URDFImporterInterface.h
@@ -0,0 +1,103 @@
+#ifndef URDF_IMPORTER_INTERFACE_H
+#define URDF_IMPORTER_INTERFACE_H
+
+#include <string>
+#include "LinearMath/btAlignedObjectArray.h"
+#include "LinearMath/btTransform.h"
+#include "URDFJointTypes.h"
+#include "SDFAudioTypes.h"
+
+class URDFImporterInterface
+{
+public:
+	virtual ~URDFImporterInterface() {}
+
+	virtual bool loadURDF(const char* fileName, bool forceFixedBase = false) = 0;
+
+	virtual bool loadSDF(const char* fileName, bool forceFixedBase = false) { return false; }
+
+	virtual const char* getPathPrefix() = 0;
+
+	///return >=0 for the root link index, -1 if there is no root link
+	virtual int getRootLinkIndex() const = 0;
+
+	///pure virtual interfaces, precondition is a valid linkIndex (you can assert/terminate if the linkIndex is out of range)
+	virtual std::string getLinkName(int linkIndex) const = 0;
+
+	//various derived class in internal source code break with new pure virtual methods, so provide some default implementation
+	virtual std::string getBodyName() const
+	{
+		return "";
+	}
+
+	/// optional method to provide the link color. return true if the color is available and copied into colorRGBA, return false otherwise
+	virtual bool getLinkColor(int linkIndex, btVector4& colorRGBA) const { return false; }
+
+	virtual bool getLinkColor2(int linkIndex, struct UrdfMaterialColor& matCol) const { return false; }
+	virtual void setLinkColor2(int linkIndex, struct UrdfMaterialColor& matCol) const {}
+
+	virtual int getCollisionGroupAndMask(int linkIndex, int& colGroup, int& colMask) const { return 0; }
+	///this API will likely change, don't override it!
+	virtual bool getLinkContactInfo(int linkIndex, URDFLinkContactInfo& contactInfo) const { return false; }
+
+	virtual bool getLinkAudioSource(int linkIndex, SDFAudioSource& audioSource) const { return false; }
+
+	virtual std::string getJointName(int linkIndex) const = 0;
+
+	//fill mass and inertial data. If inertial data is missing, please initialize mass, inertia to sensitive values, and inertialFrame to identity.
+	virtual void getMassAndInertia(int urdfLinkIndex, btScalar& mass, btVector3& localInertiaDiagonal, btTransform& inertialFrame) const = 0;
+	virtual void getMassAndInertia2(int urdfLinkIndex, btScalar& mass, btVector3& localInertiaDiagonal, btTransform& inertialFrame, int flags) const
+	{
+		getMassAndInertia(urdfLinkIndex, mass, localInertiaDiagonal, inertialFrame);
+	}
+
+	///fill an array of child link indices for this link, btAlignedObjectArray behaves like a std::vector so just use push_back and resize(0) if needed
+	virtual void getLinkChildIndices(int urdfLinkIndex, btAlignedObjectArray<int>& childLinkIndices) const = 0;
+
+	virtual bool getJointInfo(int urdfLinkIndex, btTransform& parent2joint, btTransform& linkTransformInWorld, btVector3& jointAxisInJointSpace, int& jointType, btScalar& jointLowerLimit, btScalar& jointUpperLimit, btScalar& jointDamping, btScalar& jointFriction) const = 0;
+
+	virtual bool getJointInfo2(int urdfLinkIndex, btTransform& parent2joint, btTransform& linkTransformInWorld, btVector3& jointAxisInJointSpace, int& jointType, btScalar& jointLowerLimit, btScalar& jointUpperLimit, btScalar& jointDamping, btScalar& jointFriction, btScalar& jointMaxForce, btScalar& jointMaxVelocity) const
+	{
+		//backwards compatibility for custom file importers
+		jointMaxForce = 0;
+		jointMaxVelocity = 0;
+		return getJointInfo(urdfLinkIndex, parent2joint, linkTransformInWorld, jointAxisInJointSpace, jointType, jointLowerLimit, jointUpperLimit, jointDamping, jointFriction);
+	};
+
+	virtual bool getRootTransformInWorld(btTransform& rootTransformInWorld) const = 0;
+	virtual void setRootTransformInWorld(const btTransform& rootTransformInWorld) {}
+
+	///quick hack: need to rethink the API/dependencies of this
+	virtual int convertLinkVisualShapes(int linkIndex, const char* pathPrefix, const btTransform& inertialFrame) const { return -1; }
+
+	virtual void convertLinkVisualShapes2(int linkIndex, int urdfIndex, const char* pathPrefix, const btTransform& inertialFrame, class btCollisionObject* colObj, int objectIndex) const {}
+	virtual void setBodyUniqueId(int bodyId) {}
+	virtual int getBodyUniqueId() const { return 0; }
+
+	//default implementation for backward compatibility
+	virtual class btCompoundShape* convertLinkCollisionShapes(int linkIndex, const char* pathPrefix, const btTransform& localInertiaFrame) const = 0;
+	virtual int getUrdfFromCollisionShape(const class btCollisionShape* collisionShape, struct UrdfCollision& collision) const
+	{
+		return 0;
+	}
+
+	virtual const struct UrdfLink* getUrdfLink(int urdfLinkIndex) const
+	{
+		return 0;
+	}
+
+	virtual const struct UrdfModel* getUrdfModel() const { return 0; };
+
+	virtual int getNumAllocatedCollisionShapes() const { return 0; }
+	virtual class btCollisionShape* getAllocatedCollisionShape(int /*index*/) { return 0; }
+	virtual int getNumModels() const { return 0; }
+	virtual void activateModel(int /*modelIndex*/) {}
+	virtual int getNumAllocatedMeshInterfaces() const { return 0; }
+
+	virtual int getNumAllocatedTextures() const { return 0; }
+	virtual int getAllocatedTexture(int index) const { return 0; }
+
+	virtual class btStridingMeshInterface* getAllocatedMeshInterface(int index) { return 0; }
+};
+
+#endif  //URDF_IMPORTER_INTERFACE_H
diff --git a/engine/inc/bullet/Importers/ImportURDFDemo/URDFJointTypes.h b/engine/inc/bullet/Importers/ImportURDFDemo/URDFJointTypes.h
new file mode 100644
index 00000000..fff0fee2
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportURDFDemo/URDFJointTypes.h
@@ -0,0 +1,111 @@
+#ifndef URDF_JOINT_TYPES_H
+#define URDF_JOINT_TYPES_H
+
+#include "LinearMath/btScalar.h"
+#include "LinearMath/btVector3.h"
+
+enum UrdfJointTypes
+{
+	URDFRevoluteJoint = 1,
+	URDFPrismaticJoint,
+	URDFContinuousJoint,
+	URDFFloatingJoint,
+	URDFPlanarJoint,
+	URDFFixedJoint,
+	URDFSphericalJoint,
+
+};
+
+enum URDF_LinkContactFlags
+{
+	URDF_CONTACT_HAS_LATERAL_FRICTION = 1,
+	URDF_CONTACT_HAS_INERTIA_SCALING = 2,
+	URDF_CONTACT_HAS_CONTACT_CFM = 4,
+	URDF_CONTACT_HAS_CONTACT_ERP = 8,
+	URDF_CONTACT_HAS_STIFFNESS_DAMPING = 16,
+	URDF_CONTACT_HAS_ROLLING_FRICTION = 32,
+	URDF_CONTACT_HAS_SPINNING_FRICTION = 64,
+	URDF_CONTACT_HAS_RESTITUTION = 128,
+	URDF_CONTACT_HAS_FRICTION_ANCHOR = 256,
+
+};
+
+struct URDFLinkContactInfo
+{
+	btScalar m_lateralFriction;
+	btScalar m_rollingFriction;
+	btScalar m_spinningFriction;
+	btScalar m_restitution;
+	btScalar m_inertiaScaling;
+	btScalar m_contactCfm;
+	btScalar m_contactErp;
+	btScalar m_contactStiffness;
+	btScalar m_contactDamping;
+
+	int m_flags;
+
+	URDFLinkContactInfo()
+		: m_lateralFriction(0.5),
+		  m_rollingFriction(0),
+		  m_spinningFriction(0),
+		  m_restitution(0),
+		  m_inertiaScaling(1),
+		  m_contactCfm(0),
+		  m_contactErp(0),
+		  m_contactStiffness(1e4),
+		  m_contactDamping(1)
+	{
+		m_flags = URDF_CONTACT_HAS_LATERAL_FRICTION;
+	}
+};
+
+enum UrdfCollisionFlags
+{
+	URDF_FORCE_CONCAVE_TRIMESH = 1,
+	URDF_HAS_COLLISION_GROUP = 2,
+	URDF_HAS_COLLISION_MASK = 4,
+};
+
+struct UrdfMaterialColor
+{
+	btVector4 m_rgbaColor;
+	btVector3 m_specularColor;
+	UrdfMaterialColor()
+		: m_rgbaColor(0.8, 0.8, 0.8, 1),
+		  m_specularColor(0.4, 0.4, 0.4)
+	{
+	}
+};
+
+//manually sync with eURDF_Flags in SharedMemoryPublic.h!
+enum ConvertURDFFlags
+{
+	CUF_USE_SDF = 1,
+	// Use inertia values in URDF instead of recomputing them from collision shape.
+	CUF_USE_URDF_INERTIA = 2,
+	CUF_USE_MJCF = 4,
+	CUF_USE_SELF_COLLISION = 8,
+	CUF_USE_SELF_COLLISION_EXCLUDE_PARENT = 16,
+	CUF_USE_SELF_COLLISION_EXCLUDE_ALL_PARENTS = 32,
+	CUF_RESERVED = 64,
+	CUF_USE_IMPLICIT_CYLINDER = 128,
+	CUF_GLOBAL_VELOCITIES_MB = 256,
+	CUF_MJCF_COLORS_FROM_FILE = 512,
+	CUF_ENABLE_CACHED_GRAPHICS_SHAPES = 1024,
+	CUF_ENABLE_SLEEPING = 2048,
+	CUF_INITIALIZE_SAT_FEATURES = 4096,
+	CUF_USE_SELF_COLLISION_INCLUDE_PARENT = 8192,
+	CUF_PARSE_SENSORS = 16384,
+	CUF_USE_MATERIAL_COLORS_FROM_MTL = 32768,
+	CUF_USE_MATERIAL_TRANSPARANCY_FROM_MTL = 65536,
+	CUF_MAINTAIN_LINK_ORDER = 131072,
+	CUF_ENABLE_WAKEUP = 1 << 18, 
+	CUF_MERGE_FIXED_LINKS = 1 << 19,
+	CUF_IGNORE_VISUAL_SHAPES = 1 << 20,
+	CUF_IGNORE_COLLISION_SHAPES = 1 << 21,
+	CUF_PRINT_URDF_INFO = 1 << 22,
+	CUF_GOOGLEY_UNDEFINED_COLORS = 1 << 23,
+
+};
+
+#endif  //URDF_JOINT_TYPES_H
diff --git a/engine/inc/bullet/Importers/ImportURDFDemo/UrdfFindMeshFile.h b/engine/inc/bullet/Importers/ImportURDFDemo/UrdfFindMeshFile.h
new file mode 100644
index 00000000..1c92d064
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportURDFDemo/UrdfFindMeshFile.h
@@ -0,0 +1,112 @@
+
+#ifndef URDF_FIND_MESH_FILE_H
+#define URDF_FIND_MESH_FILE_H
+
+#include "../../CommonInterfaces/CommonFileIOInterface.h"
+#include "Bullet3Common/b3Logging.h"
+
+#include <string>
+#include <list>
+
+#include "UrdfParser.h"
+
+static bool UrdfFindMeshFile(
+	CommonFileIOInterface* fileIO,
+	const std::string& urdf_path, std::string fn,
+	const std::string& error_message_prefix,
+	std::string* out_found_filename, int* out_type)
+{
+	if (fn.size() <= 4)
+	{
+		b3Warning("%s: invalid mesh filename '%s'\n", error_message_prefix.c_str(), fn.c_str());
+		return false;
+	}
+
+	std::string ext;
+	std::string ext_ = fn.substr(fn.size() - 4);
+	for (std::string::iterator i = ext_.begin(); i != ext_.end(); ++i)
+	{
+		ext += char(tolower(*i));
+	}
+
+	if (ext == ".dae")
+	{
+		*out_type = UrdfGeometry::FILE_COLLADA;
+	}
+	else if (ext == ".stl")
+	{
+		*out_type = UrdfGeometry::FILE_STL;
+	}
+	else if (ext == ".obj")
+	{
+		*out_type = UrdfGeometry::FILE_OBJ;
+	}
+	else if (ext == ".cdf")
+	{
+		*out_type = UrdfGeometry::FILE_CDF;
+	}
+	else if (ext == ".vtk")
+	{
+		*out_type = UrdfGeometry::FILE_VTK;
+	}
+	else
+	{
+		b3Warning("%s: invalid mesh filename extension '%s'\n", error_message_prefix.c_str(), ext.c_str());
+		return false;
+	}
+
+	std::string drop_it_file = "file://";
+	std::string drop_it_pack = "package://";
+	std::string drop_it_model = "model://";
+	if (fn.substr(0, drop_it_file.length()) == drop_it_file)
+		fn = fn.substr(drop_it_file.length());
+	if (fn.substr(0, drop_it_pack.length()) == drop_it_pack)
+		fn = fn.substr(drop_it_pack.length());
+	else if (fn.substr(0, drop_it_model.length()) == drop_it_model)
+		fn = fn.substr(drop_it_model.length());
+
+	std::list<std::string> shorter;
+	shorter.push_back("../../");
+	shorter.push_back("../");
+	shorter.push_back("./");
+	int cnt = urdf_path.size();
+	for (int i = 0; i < cnt; ++i)
+	{
+		if (urdf_path[i] == '/' || urdf_path[i] == '\\')
+		{
+			shorter.push_back(urdf_path.substr(0, i) + "/");
+		}
+	}
+	shorter.push_back("");  // no prefix
+	shorter.reverse();
+
+	std::string existing_file;
+
+	for (std::list<std::string>::iterator x = shorter.begin(); x != shorter.end(); ++x)
+	{
+		std::string attempt = *x + fn;
+		int f = fileIO->fileOpen(attempt.c_str(), "rb");
+		if (f<0)
+		{
+			//b3Printf("%s: tried '%s'", error_message_prefix.c_str(), attempt.c_str());
+			continue;
+		}
+		fileIO->fileClose(f);
+		existing_file = attempt;
+		//b3Printf("%s: found '%s'", error_message_prefix.c_str(), attempt.c_str());
+		break;
+	}
+
+	if (existing_file.empty())
+	{
+		b3Warning("%s: cannot find '%s' in any directory in urdf path\n", error_message_prefix.c_str(), fn.c_str());
+		return false;
+	}
+	else
+	{
+		*out_found_filename = existing_file;
+		return true;
+	}
+}
+
+#endif //URDF_FIND_MESH_FILE_H
diff --git a/engine/inc/bullet/Importers/ImportURDFDemo/UrdfParser.h b/engine/inc/bullet/Importers/ImportURDFDemo/UrdfParser.h
new file mode 100644
index 00000000..efe51b70
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportURDFDemo/UrdfParser.h
@@ -0,0 +1,426 @@
+#ifndef URDF_PARSER_H
+#define URDF_PARSER_H
+
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btAlignedObjectArray.h"
+#include "LinearMath/btHashMap.h"
+#include "URDFJointTypes.h"
+#include "SDFAudioTypes.h"
+#include <string>
+
+#define btArray btAlignedObjectArray
+
+struct ErrorLogger
+{
+	virtual ~ErrorLogger() {}
+	virtual void reportError(const char* error) = 0;
+	virtual void reportWarning(const char* warning) = 0;
+	virtual void printMessage(const char* msg) = 0;
+};
+
+struct UrdfMaterial
+{
+	std::string m_name;
+	std::string m_textureFilename;
+	UrdfMaterialColor m_matColor;
+
+	UrdfMaterial()
+	{
+	}
+};
+
+struct UrdfInertia
+{
+	btTransform m_linkLocalFrame;
+	bool m_hasLinkLocalFrame;
+
+	double m_mass;
+	double m_ixx, m_ixy, m_ixz, m_iyy, m_iyz, m_izz;
+
+	UrdfInertia()
+	{
+		m_hasLinkLocalFrame = false;
+		m_linkLocalFrame.setIdentity();
+		m_mass = 0.f;
+		m_ixx = m_ixy = m_ixz = m_iyy = m_iyz = m_izz = 0.f;
+	}
+};
+
+enum UrdfGeomTypes
+{
+	URDF_GEOM_SPHERE = 2,
+	URDF_GEOM_BOX,
+	URDF_GEOM_CYLINDER,
+	URDF_GEOM_MESH,
+	URDF_GEOM_PLANE,
+	URDF_GEOM_CAPSULE,  //non-standard URDF
+	URDF_GEOM_CDF,      //signed-distance-field, non-standard URDF
+	URDF_GEOM_HEIGHTFIELD,   //heightfield, non-standard URDF
+	URDF_GEOM_UNKNOWN,
+};
+
+struct UrdfGeometry
+{
+	UrdfGeomTypes m_type;
+
+	double m_sphereRadius;
+
+	btVector3 m_boxSize;
+
+	double m_capsuleRadius;
+	double m_capsuleHeight;
+	int m_hasFromTo;
+	btVector3 m_capsuleFrom;
+	btVector3 m_capsuleTo;
+
+	btVector3 m_planeNormal;
+
+	enum
+	{
+		FILE_STL = 1,
+		FILE_COLLADA = 2,
+		FILE_OBJ = 3,
+		FILE_CDF = 4,
+		MEMORY_VERTICES = 5,
+	        FILE_VTK = 6,
+
+	};
+	int m_meshFileType;
+	std::string m_meshFileName;
+	btVector3 m_meshScale;
+
+	btArray<btVector3> m_vertices;
+	btArray<btVector3> m_uvs;
+	btArray<btVector3> m_normals;
+	btArray<int> m_indices;
+
+
+	UrdfMaterial m_localMaterial;
+	bool m_hasLocalMaterial;
+
+	UrdfGeometry()
+		: m_type(URDF_GEOM_UNKNOWN),
+		  m_sphereRadius(1),
+		  m_boxSize(1, 1, 1),
+		  m_capsuleRadius(1),
+		  m_capsuleHeight(1),
+		  m_hasFromTo(0),
+		  m_capsuleFrom(0, 1, 0),
+		  m_capsuleTo(1, 0, 0),
+		  m_planeNormal(0, 0, 1),
+		  m_meshFileType(0),
+		  m_meshScale(1, 1, 1),
+		  m_hasLocalMaterial(false)
+	{
+	}
+};
+
+
+struct UrdfShape
+{
+	std::string m_sourceFileLocation;
+	btTransform m_linkLocalFrame;
+	UrdfGeometry m_geometry;
+	std::string m_name;
+};
+
+struct UrdfVisual : UrdfShape
+{
+	std::string m_materialName;
+	// Maps user data keys to user data values.
+	btHashMap<btHashString, std::string> m_userData;
+};
+
+struct UrdfCollision : UrdfShape
+{
+	int m_flags;
+	int m_collisionGroup;
+	int m_collisionMask;
+	UrdfCollision()
+		: m_flags(0)
+	{
+	}
+};
+
+struct UrdfJoint;
+
+struct UrdfLink
+{
+	std::string m_name;
+	UrdfInertia m_inertia;
+	btTransform m_linkTransformInWorld;
+	btArray<UrdfVisual> m_visualArray;
+	btArray<UrdfCollision> m_collisionArray;
+	UrdfLink* m_parentLink;
+	UrdfJoint* m_parentJoint;
+
+	btArray<UrdfJoint*> m_childJoints;
+	btArray<UrdfLink*> m_childLinks;
+
+	int m_linkIndex;
+
+	URDFLinkContactInfo m_contactInfo;
+
+	SDFAudioSource m_audioSource;
+	// Maps user data keys to user data values.
+	btHashMap<btHashString, std::string> m_userData;
+
+	UrdfLink()
+		: m_parentLink(0),
+		  m_parentJoint(0),
+		  m_linkIndex(-2)
+	{
+	}
+};
+struct UrdfJoint
+{
+	std::string m_name;
+	UrdfJointTypes m_type;
+	btTransform m_parentLinkToJointTransform;
+	std::string m_parentLinkName;
+	std::string m_childLinkName;
+	btVector3 m_localJointAxis;
+
+	double m_lowerLimit;
+	double m_upperLimit;
+
+	double m_effortLimit;
+	double m_velocityLimit;
+
+	double m_jointDamping;
+	double m_jointFriction;
+	UrdfJoint()
+		: m_lowerLimit(0),
+		  m_upperLimit(-1),
+		  m_effortLimit(0),
+		  m_velocityLimit(0),
+		  m_jointDamping(0),
+		  m_jointFriction(0)
+	{
+	}
+};
+
+struct SpringCoeffcients
+{
+	double elastic_stiffness;
+	double damping_stiffness;
+	double bending_stiffness;
+	int damp_all_directions;
+	int bending_stride;
+	SpringCoeffcients() : elastic_stiffness(0.),
+						  damping_stiffness(0.),
+						  bending_stiffness(0.),
+						  damp_all_directions(0),
+						  bending_stride(2) {}
+};
+
+struct LameCoefficients
+{
+	double mu;
+	double lambda;
+	double damping;
+	LameCoefficients() : mu(0.), lambda(0.), damping(0.) {}
+};
+
+struct UrdfDeformable
+{
+	std::string m_name;
+	double m_mass;
+	double m_collisionMargin;
+	double m_friction;
+	double m_repulsionStiffness;
+	double m_gravFactor;
+	bool m_cache_barycenter;
+
+	SpringCoeffcients m_springCoefficients;
+	LameCoefficients m_corotatedCoefficients;
+	LameCoefficients m_neohookeanCoefficients;
+
+	std::string m_visualFileName;
+	std::string m_simFileName;
+	btHashMap<btHashString, std::string> m_userData;
+
+	UrdfDeformable() : m_mass(1.), m_collisionMargin(0.02), m_friction(1.), m_repulsionStiffness(0.5), m_gravFactor(1.), m_cache_barycenter(false), m_visualFileName(""), m_simFileName("")
+	{
+	}
+};
+
+struct UrdfModel
+{
+	std::string m_name;
+	std::string m_sourceFile;
+	btTransform m_rootTransformInWorld;
+	btHashMap<btHashString, UrdfMaterial*> m_materials;
+	btHashMap<btHashString, UrdfLink*> m_links;
+	btHashMap<btHashString, UrdfJoint*> m_joints;
+	UrdfDeformable m_deformable;
+	// Maps user data keys to user data values.
+	btHashMap<btHashString, std::string> m_userData;
+
+	btArray<UrdfLink*> m_rootLinks;
+	bool m_overrideFixedBase;
+
+	UrdfModel()
+		: m_overrideFixedBase(false)
+	{
+		m_rootTransformInWorld.setIdentity();
+	}
+
+	~UrdfModel()
+	{
+		for (int i = 0; i < m_materials.size(); i++)
+		{
+			UrdfMaterial** ptr = m_materials.getAtIndex(i);
+			if (ptr)
+			{
+				UrdfMaterial* t = *ptr;
+				delete t;
+			}
+		}
+		for (int i = 0; i < m_links.size(); i++)
+		{
+			UrdfLink** ptr = m_links.getAtIndex(i);
+			if (ptr)
+			{
+				UrdfLink* t = *ptr;
+				delete t;
+			}
+		}
+		for (int i = 0; i < m_joints.size(); i++)
+		{
+			UrdfJoint** ptr = m_joints.getAtIndex(i);
+			if (ptr)
+			{
+				UrdfJoint* t = *ptr;
+				delete t;
+			}
+		}
+	}
+};
+
+namespace tinyxml2
+{
+class XMLElement;
+};
+
+class UrdfParser
+{
+protected:
+	UrdfModel m_urdf2Model;
+	btAlignedObjectArray<UrdfModel*> m_sdfModels;
+	btAlignedObjectArray<UrdfModel*> m_tmpModels;
+
+	bool m_parseSDF;
+	int m_activeSdfModel;
+
+	btScalar m_urdfScaling;
+
+	struct CommonFileIOInterface* m_fileIO;
+
+	bool parseTransform(btTransform& tr, tinyxml2::XMLElement* xml, ErrorLogger* logger, bool parseSDF = false);
+	bool parseInertia(UrdfInertia& inertia, tinyxml2::XMLElement* config, ErrorLogger* logger);
+	bool parseGeometry(UrdfGeometry& geom, tinyxml2::XMLElement* g, ErrorLogger* logger);
+	bool parseVisual(UrdfModel& model, UrdfVisual& visual, tinyxml2::XMLElement* config, ErrorLogger* logger);
+	bool parseCollision(UrdfCollision& collision, tinyxml2::XMLElement* config, ErrorLogger* logger);
+	bool initTreeAndRoot(UrdfModel& model, ErrorLogger* logger);
+	bool parseMaterial(UrdfMaterial& material, tinyxml2::XMLElement* config, ErrorLogger* logger);
+	bool parseJointLimits(UrdfJoint& joint, tinyxml2::XMLElement* config, ErrorLogger* logger);
+	bool parseJointDynamics(UrdfJoint& joint, tinyxml2::XMLElement* config, ErrorLogger* logger);
+	bool parseJoint(UrdfJoint& joint, tinyxml2::XMLElement* config, ErrorLogger* logger);
+	bool parseLink(UrdfModel& model, UrdfLink& link, tinyxml2::XMLElement* config, ErrorLogger* logger);
+	bool parseSensor(UrdfModel& model, UrdfLink& link, UrdfJoint& joint, tinyxml2::XMLElement* config, ErrorLogger* logger);
+  bool parseLameCoefficients(LameCoefficients& lameCoefficients, tinyxml2::XMLElement* config, ErrorLogger* logger);
+	bool parseDeformable(UrdfModel& model, tinyxml2::XMLElement* config, ErrorLogger* logger);
+
+
+public:
+	UrdfParser(struct CommonFileIOInterface* fileIO);
+	virtual ~UrdfParser();
+
+	void setParseSDF(bool useSDF)
+	{
+		m_parseSDF = useSDF;
+	}
+	bool getParseSDF() const
+	{
+		return m_parseSDF;
+	}
+	void setGlobalScaling(btScalar scaling)
+	{
+		m_urdfScaling = scaling;
+	}
+
+	bool loadUrdf(const char* urdfText, ErrorLogger* logger, bool forceFixedBase, bool parseSensors);
+
+	bool loadUrdf(const char* urdfText, ErrorLogger* logger, bool forceFixedBase)
+	{
+		return loadUrdf(urdfText, logger, forceFixedBase, false);
+	}
+
+	bool loadSDF(const char* sdfText, ErrorLogger* logger);
+
+	int getNumModels() const
+	{
+		//user should have loaded an SDF when calling this method
+		if (m_parseSDF)
+		{
+			return m_sdfModels.size();
+		}
+		return 1;
+	}
+
+	void activateModel(int modelIndex);
+
+	UrdfModel& getModelByIndex(int index)
+	{
+		//user should have loaded an SDF when calling this method
+		btAssert(m_parseSDF);
+
+		return *m_sdfModels[index];
+	}
+
+	const UrdfModel& getModelByIndex(int index) const
+	{
+		//user should have loaded an SDF when calling this method
+		btAssert(m_parseSDF);
+
+		return *m_sdfModels[index];
+	}
+
+	const UrdfModel& getModel() const
+	{
+		if (m_parseSDF)
+		{
+			return *m_sdfModels[m_activeSdfModel];
+		}
+
+		return m_urdf2Model;
+	}
+
+	UrdfModel& getModel()
+	{
+		if (m_parseSDF)
+		{
+			return *m_sdfModels[m_activeSdfModel];
+		}
+		return m_urdf2Model;
+	}
+
+	const UrdfDeformable& getDeformable() const
+	{
+		return m_urdf2Model.m_deformable;
+	}
+
+	bool mergeFixedLinks(UrdfModel& model, UrdfLink* link, ErrorLogger* logger, bool forceFixedBase, int level);
+	bool printTree(UrdfLink* link, ErrorLogger* logger, int level);
+	bool recreateModel(UrdfModel& model, UrdfLink* link, ErrorLogger* logger);
+
+	std::string sourceFileLocation(tinyxml2::XMLElement* e);
+
+	void setSourceFile(const std::string& sourceFile)
+	{
+		m_urdf2Model.m_sourceFile = sourceFile;
+	}
+};
+
+#endif
diff --git a/engine/inc/bullet/Importers/ImportURDFDemo/UrdfRenderingInterface.h b/engine/inc/bullet/Importers/ImportURDFDemo/UrdfRenderingInterface.h
new file mode 100644
index 00000000..460d0cf9
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportURDFDemo/UrdfRenderingInterface.h
@@ -0,0 +1,115 @@
+#ifndef URDF_RENDERING_INTERFACE_H
+#define URDF_RENDERING_INTERFACE_H
+
+///UrdfLink and UrdfModel are the main URDF structures to define a robot
+struct UrdfLink;
+struct UrdfModel;
+///btTransform is a position and 3x3 matrix, as defined in Bullet/src/LinearMath/btTransform
+class btTransform;
+class btVector3;
+
+///UrdfRenderingInterface is a simple rendering interface, mainly for URDF-based robots.
+///There is an implementation in
+///bullet3\examples\SharedMemory\plugins\tinyRendererPlugin\TinyRendererVisualShapeConverter.cpp
+struct UrdfRenderingInterface
+{
+	virtual ~UrdfRenderingInterface() {}
+	///given a URDF link, convert all visual shapes into internal renderer (loading graphics meshes, textures etc)
+	///use the visualShapeUniqueId as a unique identifier to synchronize the world transform and to remove the visual shape.
+	virtual int convertVisualShapes(int linkIndex, const char* pathPrefix, const btTransform& localInertiaFrame, const UrdfLink* linkPtr, const UrdfModel* model, int visualShapeUniqueId, int bodyUniqueId, struct CommonFileIOInterface* fileIO) = 0;
+
+	virtual int registerShapeAndInstance(const struct b3VisualShapeData& visualShape, const float* vertices, int numvertices, const int* indices, int numIndices, int primitiveType, int textureId, int orgGraphicsUniqueId, int bodyUniqueId, int linkIndex)=0;
+
+	virtual void updateShape(int shapeUniqueId, const btVector3* vertices, int numVertices, const btVector3* normals, int numNormals) = 0;
+
+	///remove a visual shapes, based on the shape unique id (shapeUid)
+	virtual void removeVisualShape(int collisionObjectUid) = 0;
+
+	///update the world transform + scaling of the visual shape, using the shapeUid
+	virtual void syncTransform(int collisionObjectUid, const class btTransform& worldTransform, const class btVector3& localScaling) = 0;
+
+	///return the number of visual shapes, for a particular body unique id
+	virtual int getNumVisualShapes(int bodyUniqueId) = 0;
+
+	///return the visual shape information, for a particular body unique id and 'shape index'
+	virtual int getVisualShapesData(int bodyUniqueId, int shapeIndex, struct b3VisualShapeData* shapeData) = 0;
+
+	///change the RGBA color for some visual shape.
+	virtual void changeRGBAColor(int bodyUniqueId, int linkIndex, int shapeIndex, const double rgbaColor[4]) = 0;
+
+	//change the instance flags, double-sided rendering
+	virtual void changeInstanceFlags(int bodyUniqueId, int linkIndex, int shapeIndex, int flags) = 0;
+
+	///select a given texture for some visual shape.
+	virtual void changeShapeTexture(int objectUniqueId, int linkIndex, int shapeIndex, int textureUniqueId) = 0;
+
+	///pick the up-axis, either Y (1) or Z (2)
+	virtual void setUpAxis(int axis) = 0;
+
+	///compute the view matrix based on those parameters
+	virtual void resetCamera(float camDist, float yaw, float pitch, float camPosX, float camPosY, float camPosZ) = 0;
+
+	///clear the render buffer with a particular color.
+	virtual void clearBuffers(struct TGAColor& clearColor) = 0;
+
+	///remove all visual shapes.
+	virtual void resetAll() = 0;
+
+	///return the frame buffer width and height for the renderer
+	virtual void getWidthAndHeight(int& width, int& height) = 0;
+
+	///set the frame buffer width and height for the renderer
+	virtual void setWidthAndHeight(int width, int height) = 0;
+
+	///set the light direction, in world coordinates
+	virtual void setLightDirection(float x, float y, float z) = 0;
+
+	///set the ambient light color, in world coordinates
+	virtual void setLightColor(float x, float y, float z) = 0;
+
+	///set the light distance
+	virtual void setLightDistance(float dist) = 0;
+
+	///set the light ambient coefficient
+	virtual void setLightAmbientCoeff(float ambientCoeff) = 0;
+
+	///set the light diffuse coefficient
+	virtual void setLightDiffuseCoeff(float diffuseCoeff) = 0;
+
+	///set the light specular coefficient
+	virtual void setLightSpecularCoeff(float specularCoeff) = 0;
+
+	///enable or disable rendering of shadows
+	virtual void setShadow(bool hasShadow) = 0;
+
+	///some undocumented flags for experimentation (todo: document)
+	virtual void setFlags(int flags) = 0;
+
+	///provide the image pixels as a part of a stream.
+	virtual void copyCameraImageData(unsigned char* pixelsRGBA, int rgbaBufferSizeInPixels, float* depthBuffer, int depthBufferSizeInPixels, int* segmentationMaskBuffer, int segmentationMaskSizeInPixels, int startPixelIndex, int* widthPtr, int* heightPtr, int* numPixelsCopied) = 0;
+
+	///render an image, using some arbitraty view and projection matrix
+	virtual void render() = 0;
+
+	///render an image using the provided view and projection matrix
+	virtual void render(const float viewMat[16], const float projMat[16]) = 0;
+
+	///load a texture from file, in png or other popular/supported format
+	//virtual int loadTextureFile(const char* filename) = 0;
+	virtual int loadTextureFile(const char* filename, struct CommonFileIOInterface* fileIO)=0;
+	
+	///register a texture using an in-memory pixel buffer of a given width and height
+	virtual int registerTexture(unsigned char* texels, int width, int height) = 0;
+
+	virtual void setProjectiveTextureMatrices(const float viewMatrix[16], const float projectionMatrix[16]) {}
+	virtual void setProjectiveTexture(bool useProjectiveTexture) {}
+
+
+	virtual bool getCameraInfo(int* width, int* height, float viewMatrix[16], float projectionMatrix[16], float camUp[3], float camForward[3], float hor[3], float vert[3], float* yaw, float* pitch, float* camDist, float cameraTarget[3]) const
+	{
+		return false;
+	}
+
+};
+
+#endif  //LINK_VISUAL_SHAPES_CONVERTER_H
diff --git a/engine/inc/bullet/Importers/ImportURDFDemo/urdfLexicalCast.h b/engine/inc/bullet/Importers/ImportURDFDemo/urdfLexicalCast.h
new file mode 100644
index 00000000..66481365
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportURDFDemo/urdfLexicalCast.h
@@ -0,0 +1,13 @@
+#ifndef BOOST_REPLACEMENT_LEXICAL_CAST_H
+#define BOOST_REPLACEMENT_LEXICAL_CAST_H
+
+#include <stdlib.h>
+
+template <typename T>
+T urdfLexicalCast(const char* txt)
+{
+	double result = atof(txt);
+	return result;
+};
+
+#endif
diff --git a/engine/inc/bullet/Importers/ImportURDFDemo/urdfStringSplit.h b/engine/inc/bullet/Importers/ImportURDFDemo/urdfStringSplit.h
new file mode 100644
index 00000000..783020da
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportURDFDemo/urdfStringSplit.h
@@ -0,0 +1,39 @@
+
+#ifndef STRING_SPLIT_H
+#define STRING_SPLIT_H
+
+#ifdef __cplusplus
+
+#include <cstring>
+#include <string>
+#include "LinearMath/btAlignedObjectArray.h"
+
+void urdfStringSplit(btAlignedObjectArray<std::string>& pieces, const std::string& vector_str, const btAlignedObjectArray<std::string>& separators);
+
+void urdfIsAnyOf(const char* seps, btAlignedObjectArray<std::string>& strArray);
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	///The string split C code is by Lars Wirzenius
+	///See http://stackoverflow.com/questions/2531605/how-to-split-a-string-with-a-delimiter-larger-than-one-single-char
+
+	/* Split a string into substrings. Return dynamic array of dynamically
+ allocated substrings, or NULL if there was an error. Caller is
+ expected to free the memory, for example with str_array_free. */
+	char** urdfStrSplit(const char* input, const char* sep);
+
+	/* Free a dynamic array of dynamic strings. */
+	void urdfStrArrayFree(char** array);
+
+	/* Return length of a NULL-delimited array of strings. */
+	size_t urdfStrArrayLen(char** array);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  //STRING_SPLIT_H
diff --git a/engine/inc/bullet/Importers/ImportURDFDemo/urdf_samples.h b/engine/inc/bullet/Importers/ImportURDFDemo/urdf_samples.h
new file mode 100644
index 00000000..8d668263
--- /dev/null
+++ b/engine/inc/bullet/Importers/ImportURDFDemo/urdf_samples.h
@@ -0,0 +1,823 @@
+#ifndef URDF_SAMPLES_H
+#define URDF_SAMPLES_H
+
+#define MSTRINGIFY(A) #A
+
+const char* urdf_char2 = MSTRINGIFY(
+	<robot name = "test_robot">
+	<link name = "link1" />
+	<link name = "link2" />
+	<link name = "link3" />
+	<link name = "link4" />
+
+	<joint name = "joint1" type = "continuous">
+	<parent link = "link1" />
+	<child link = "link2" />
+	</ joint>
+
+	<joint name = "joint2" type = "continuous">
+	<parent link = "link1" />
+	<child link = "link3" />
+	</ joint>
+
+	<joint name = "joint3" type = "continuous">
+	<parent link = "link3" />
+	<child link = "link4" />
+	</ joint>
+	</ robot>);
+
+const char* urdf_char1 = MSTRINGIFY(
+                                   <?xml version="1.0"?>
+                                   <robot name="myfirst">
+                                   <link name="base_link">
+                                   <visual>
+                                   <geometry>
+                                   <cylinder length="0.6" radius="0.2"/>
+                                   </geometry>
+                                   </visual>
+                                   </link>
+                                   </robot>
+                                   );
+
+const char* urdf_char3 = MSTRINGIFY(<?xml version="1.0"?>
+                                   <robot name="multipleshapes">
+                                   <link name="base_link">
+                                   <visual>
+                                   <geometry>
+                                   <cylinder length="0.6" radius="0.2"/>
+                                   </geometry>
+                                   </visual>
+                                   </link>
+                                   
+                                   <link name="right_leg">
+                                   <visual>
+                                   <geometry>
+                                   <box size="0.6 .2 .1"/>
+                                   </geometry>
+                                   </visual>
+                                   </link>
+                                   
+                                   <joint name="base_to_right_leg" type="fixed">
+                                   <parent link="base_link"/>
+                                   <child link="right_leg"/>
+                                   </joint>
+                                   
+                                   </robot>);
+
+const char* urdf_char4 = MSTRINGIFY(
+
+								   <?xml version="1.0"?>
+								   <robot name="materials">
+								   <link name="base_link">
+								   <visual>
+								   <geometry>
+								   <cylinder length="0.6" radius="0.2"/>
+								   </geometry>
+								   <material name="blue">
+								   <color rgba="0 0 .8 1"/>
+								   </material>
+								   </visual>
+								   </link>
+								   
+								   <link name="right_leg">
+								   <visual>
+								   <geometry>
+								   <box size="0.6 .2 .1"/>
+								   </geometry>
+								   <origin rpy="0 1.57075 0" xyz="0 0 -0.3"/>
+								   <material name="white">
+								   <color rgba="1 1 1 1"/>
+								   </material>
+								   </visual>
+								   </link>
+								   
+								   <joint name="base_to_right_leg" type="fixed">
+								   <parent link="base_link"/>
+								   <child link="right_leg"/>
+								   <origin xyz="0.22 0 .25"/>
+								   </joint>
+								   
+								   <link name="left_leg">
+								   <visual>
+								   <geometry>
+								   <box size="0.6 .2 .1"/>
+								   </geometry>
+								   <origin rpy="0 1.57075 0" xyz="0 0 -0.3"/>
+								   <material name="white"/>
+								   </visual>
+								   </link>
+								   
+								   <joint name="base_to_left_leg" type="fixed">
+								   <parent link="base_link"/>
+								   <child link="left_leg"/>
+								   <origin xyz="-0.22 0 .25"/>
+								   </joint>
+								   
+								   <link name="head">
+								   <visual>
+								   <geometry>
+								   <sphere radius="0.2"/>
+								   </geometry>
+								   <material name="white"/>
+								   </visual>
+								   </link>
+								   
+								   <joint name="head_swivel" type="fixed">
+								   <parent link="base_link"/>
+								   <child link="head"/>
+								   <origin xyz="0 0 0.3"/>
+								   </joint>
+
+								   <link name="box">
+								   <visual>
+								   <geometry>
+								   <box size=".08 .08 .08"/>
+								   </geometry>
+								   <material name="blue"/>
+								   </visual>
+								   </link>
+								   
+								   <joint name="tobox" type="fixed">
+								   <parent link="head"/>
+								   <child link="box"/>
+								   <origin xyz="0 0.1414 0.1414"/>
+								   </joint>
+								   
+								   </robot>
+
+
+);
+
+const char* urdf_char_r2d2 = MSTRINGIFY(
+
+								   <?xml version="1.0"?>
+								   <robot name="visual">
+								   <link name="base_link">
+								   <visual>
+								   <geometry>
+								   <cylinder length="0.6" radius="0.2"/>
+								   </geometry>
+								   <material name="blue">
+								   <color rgba="0 0 .8 1"/>
+								   </material>
+								   </visual>
+								   </link>
+								   
+								   <link name="right_leg">
+								   <visual>
+								   <geometry>
+								   <box size="0.6 .2 .1"/>
+								   </geometry>
+								   <origin rpy="0 1.57075 0" xyz="0 0 -0.3"/>
+								   <material name="white">
+								   <color rgba="1 1 1 1"/>
+								   </material>
+								   </visual>
+								   </link>
+								   
+								   <joint name="base_to_right_leg" type="fixed">
+								   <parent link="base_link"/>
+								   <child link="right_leg"/>
+								   <origin xyz="0.22 0 .25"/>
+								   </joint>
+								   
+								   <link name="right_base">
+								   <visual>
+								   <geometry>
+								   <box size=".1 0.4 .1"/>
+								   </geometry>
+								   <material name="white"/>
+								   </visual>
+								   </link>
+								   
+								   <joint name="right_base_joint" type="fixed">
+								   <parent link="right_leg"/>
+								   <child link="right_base"/>
+								   <origin xyz="0 0 -0.6"/>
+								   </joint>
+								   
+								   <link name="right_front_wheel">
+								   <visual>
+								   <geometry>
+								   <cylinder length=".1" radius="0.035"/>
+								   </geometry>
+								   <material name="black">
+								   <color rgba="0 0 0 1"/>
+								   </material>
+								   </visual>
+								   </link>
+								   
+								   <joint name="right_front_wheel_joint" type="fixed">
+								   <parent link="right_base"/>
+								   <child link="right_front_wheel"/>
+								   <origin rpy="0 1.57075 0" xyz="0 0.133333333333 -0.085"/>
+								   </joint>
+								   
+								   <link name="right_back_wheel">
+								   <visual>
+								   <geometry>
+								   <cylinder length=".1" radius="0.035"/>
+								   </geometry>
+								   <material name="black"/>
+								   </visual>
+								   </link>
+								   
+								   <joint name="right_back_wheel_joint" type="fixed">
+								   <parent link="right_base"/>
+								   <child link="right_back_wheel"/>
+								   <origin rpy="0 1.57075 0" xyz="0 -0.133333333333 -0.085"/>
+								   </joint>
+								   
+								   <link name="left_leg">
+								   <visual>
+								   <geometry>
+								   <box size="0.6 .2 .1"/>
+								   </geometry>
+								   <origin rpy="0 1.57075 0" xyz="0 0 -0.3"/>
+								   <material name="white"/>
+								   </visual>
+								   </link>
+								   
+								   <joint name="base_to_left_leg" type="fixed">
+								   <parent link="base_link"/>
+								   <child link="left_leg"/>
+								   <origin xyz="-0.22 0 .25"/>
+								   </joint>
+								   
+								   <link name="left_base">
+								   <visual>
+								   <geometry>
+								   <box size=".1 0.4 .1"/>
+								   </geometry>
+								   <material name="white"/>
+								   </visual>
+								   </link>
+								   
+								   <joint name="left_base_joint" type="fixed">
+								   <parent link="left_leg"/>
+								   <child link="left_base"/>
+								   <origin xyz="0 0 -0.6"/>
+								   </joint>
+								   
+								   <link name="left_front_wheel">
+								   <visual>
+								   <geometry>
+								   <cylinder length=".1" radius="0.035"/>
+								   </geometry>
+								   <material name="black"/>
+								   </visual>
+								   </link>
+								   
+								   <joint name="left_front_wheel_joint" type="fixed">
+								   <parent link="left_base"/>
+								   <child link="left_front_wheel"/>
+								   <origin rpy="0 1.57075 0" xyz="0 0.133333333333 -0.085"/>
+								   </joint>
+								   
+								   <link name="left_back_wheel">
+								   <visual>
+								   <geometry>
+								   <cylinder length=".1" radius="0.035"/>
+								   </geometry>
+								   <material name="black"/>
+								   </visual>
+								   </link>
+								   
+								   <joint name="left_back_wheel_joint" type="fixed">
+								   <parent link="left_base"/>
+								   <child link="left_back_wheel"/>
+								   <origin rpy="0 1.57075 0" xyz="0 -0.133333333333 -0.085"/>
+								   </joint>
+								   
+								   <joint name="gripper_extension" type="fixed">
+								   <parent link="base_link"/>
+								   <child link="gripper_pole"/>
+								   <origin rpy="0 0 1.57075" xyz="0 0.19 .2"/>
+								   </joint>
+								   
+								   <link name="gripper_pole">
+								   <visual>
+								   <geometry>
+								   <cylinder length="0.2" radius=".01"/>
+								   </geometry>
+								   <origin rpy="0 1.57075 0 " xyz="0.1 0 0"/>
+								   <material name="Gray">
+								   <color rgba=".7 .7 .7 1"/>
+								   </material>
+								   </visual>
+								   </link>
+								   
+								   <joint name="left_gripper_joint" type="fixed">
+								   <origin rpy="0 0 0" xyz="0.2 0.01 0"/>
+								   <parent link="gripper_pole"/>
+								   <child link="left_gripper"/>
+								   </joint>
+								   
+								   <link name="left_gripper">
+								   <visual>
+								   <origin rpy="0.0 0 0" xyz="0 0 0"/>
+								   <geometry>
+								   <mesh filename="package://pr2_description/meshes/gripper_v0/l_finger.dae"/>
+								   </geometry>
+								   </visual>
+								   </link>
+								   
+								   <joint name="left_tip_joint" type="fixed">
+								   <parent link="left_gripper"/>
+								   <child link="left_tip"/>
+								   </joint>
+								   
+								   <link name="left_tip">
+								   <visual>
+								   <origin rpy="0.0 0 0" xyz="0.09137 0.00495 0"/>
+								   <geometry>
+								   <mesh filename="package://pr2_description/meshes/gripper_v0/l_finger_tip.dae"/>
+								   </geometry>
+								   </visual>
+								   </link>
+								   
+								   <joint name="right_gripper_joint" type="fixed">
+								   <origin rpy="0 0 0" xyz="0.2 -0.01 0"/>
+								   <parent link="gripper_pole"/>
+								   <child link="right_gripper"/>
+								   </joint>
+								   
+								   <link name="right_gripper">
+								   <visual>
+								   <origin rpy="-3.1415 0 0" xyz="0 0 0"/>
+								   <geometry>
+								   <mesh filename="package://pr2_description/meshes/gripper_v0/l_finger.dae"/>
+								   </geometry>
+								   </visual>
+								   </link>
+								   
+								   <joint name="right_tip_joint" type="fixed">
+								   <parent link="right_gripper"/>
+								   <child link="right_tip"/>
+								   </joint>
+								   
+								   <link name="right_tip">
+								   <visual>
+								   <origin rpy="-3.1415 0 0" xyz="0.09137 0.00495 0"/>
+								   <geometry>
+								   <mesh filename="package://pr2_description/meshes/gripper_v0/l_finger_tip.dae"/>
+								   </geometry>
+								   </visual>
+								   </link>
+								   
+								   <link name="head">
+								   <visual>
+								   <geometry>
+								   <sphere radius="0.2"/>
+								   </geometry>
+								   <material name="white"/>
+								   </visual>
+								   </link>
+								   
+								   <joint name="head_swivel" type="fixed">
+								   <parent link="base_link"/>
+								   <child link="head"/>
+								   <origin xyz="0 0 0.3"/>
+								   </joint>
+								   
+								   <link name="box">
+								   <visual>
+								   <geometry>
+								   <box size=".08 .08 .08"/>
+								   </geometry>
+								   <material name="blue"/>
+								   </visual>
+								   </link>
+								   
+								   <joint name="tobox" type="fixed">
+								   <parent link="head"/>
+								   <child link="box"/>
+								   <origin xyz="0 0.1414 0.1414"/>
+								   </joint>
+								   
+								   </robot>
+);
+
+const char* urdf_char = MSTRINGIFY(
+
+								<?xml version="1.0"?>
+<robot name="physics">
+  <link name="base_link">
+    <visual>
+      <geometry>
+        <cylinder length="0.6" radius="0.2"/>
+      </geometry>
+      <material name="blue">
+        <color rgba="0 0 .8 1"/>
+      </material>
+    </visual>
+    <collision>
+      <geometry>
+        <cylinder length="0.6" radius="0.2"/>
+      </geometry>
+    </collision>
+    <inertial>
+      <mass value="10"/>
+      <inertia ixx="1.0" ixy="0.0" ixz="0.0" iyy="1.0" iyz="0.0" izz="1.0"/>
+    </inertial>
+  </link>
+
+  <link name="right_leg">
+    <visual>
+      <geometry>
+        <box size="0.6 .2 .1"/>
+      </geometry>
+      <origin rpy="0 1.57075 0" xyz="0 0 -0.3"/>
+      <material name="white">
+        <color rgba="1 1 1 1"/>
+      </material>
+    </visual>
+    <collision>
+      <geometry>
+        <box size="0.6 .2 .1"/>
+      </geometry>
+      <origin rpy="0 1.57075 0" xyz="0 0 -0.3"/>
+    </collision>
+    <inertial>
+      <mass value="10"/>
+      <origin rpy="0 1.57075 0" xyz="0 0 -0.3"/>
+      <inertia ixx="1.0" ixy="0.0" ixz="0.0" iyy="1.0" iyz="0.0" izz="1.0"/>
+    </inertial>
+  </link>
+
+  <joint name="base_to_right_leg" type="fixed">
+    <parent link="base_link"/>
+    <child link="right_leg"/>
+    <origin xyz="0.22 0 .25"/>
+  </joint>
+
+  <link name="right_base">
+    <visual>
+      <geometry>
+        <box size=".1 0.4 .1"/>
+      </geometry>
+      <material name="white"/>
+    </visual>
+    <collision>
+      <geometry>
+        <box size=".1 0.4 .1"/>
+      </geometry>
+    </collision>
+    <inertial>
+      <mass value="10"/>
+      <inertia ixx="1.0" ixy="0.0" ixz="0.0" iyy="1.0" iyz="0.0" izz="1.0"/>
+    </inertial>
+  </link>
+
+  <joint name="right_base_joint" type="fixed">
+    <parent link="right_leg"/>
+    <child link="right_base"/>
+    <origin xyz="0 0 -0.6"/>
+  </joint>
+
+  <link name="right_front_wheel">
+    <visual>
+      <geometry>
+        <cylinder length=".1" radius="0.035"/>
+      </geometry>
+      <material name="black">
+        <color rgba="0 0 0 1"/>
+      </material>
+    </visual>
+    <collision>
+      <geometry>
+        <cylinder length=".1" radius="0.035"/>
+      </geometry>
+    </collision>
+    <inertial>
+      <mass value="1"/>
+      <inertia ixx="1.0" ixy="0.0" ixz="0.0" iyy="1.0" iyz="0.0" izz="1.0"/>
+    </inertial>
+  </link>
+
+  <joint name="right_front_wheel_joint" type="continuous">
+    <axis xyz="0 0 1"/>
+    <parent link="right_base"/>
+    <child link="right_front_wheel"/>
+    <origin rpy="0 1.57075 0" xyz="0 0.133333333333 -0.085"/>
+    <limit effort="100" velocity="100"/>
+    <joint_properties damping="0.0" friction="0.0"/>
+  </joint>
+
+  <link name="right_back_wheel">
+    <visual>
+      <geometry>
+        <cylinder length=".1" radius="0.035"/>
+      </geometry>
+      <material name="black"/>
+    </visual>
+    <collision>
+      <geometry>
+        <cylinder length=".1" radius="0.035"/>
+      </geometry>
+    </collision>
+    <inertial>
+      <mass value="1"/>
+      <inertia ixx="1.0" ixy="0.0" ixz="0.0" iyy="1.0" iyz="0.0" izz="1.0"/>
+    </inertial>
+  </link>
+
+  <joint name="right_back_wheel_joint" type="continuous">
+    <axis xyz="0 0 1"/>
+    <parent link="right_base"/>
+    <child link="right_back_wheel"/>
+    <origin rpy="0 1.57075 0" xyz="0 -0.133333333333 -0.085"/>
+    <limit effort="100" velocity="100"/>
+    <joint_properties damping="0.0" friction="0.0"/>
+  </joint>
+
+  <link name="left_leg">
+    <visual>
+      <geometry>
+        <box size="0.6 .2 .1"/>
+      </geometry>
+      <origin rpy="0 1.57075 0" xyz="0 0 -0.3"/>
+      <material name="white"/>
+    </visual>
+    <collision>
+      <geometry>
+        <box size="0.6 .2 .1"/>
+      </geometry>
+      <origin rpy="0 1.57075 0" xyz="0 0 -0.3"/>
+    </collision>
+    <inertial>
+      <mass value="10"/>
+      <inertia ixx="1.0" ixy="0.0" ixz="0.0" iyy="1.0" iyz="0.0" izz="1.0"/>
+       <origin rpy="0 1.57075 0" xyz="0 0 -0.3"/>
+    </inertial>
+  </link>
+
+  <joint name="base_to_left_leg" type="fixed">
+    <parent link="base_link"/>
+    <child link="left_leg"/>
+    <origin xyz="-0.22 0 .25"/>
+  </joint>
+
+  <link name="left_base">
+    <visual>
+      <geometry>
+        <box size=".1 0.4 .1"/>
+      </geometry>
+      <material name="white"/>
+    </visual>
+    <collision>
+      <geometry>
+        <box size=".1 0.4 .1"/>
+      </geometry>
+    </collision>
+    <inertial>
+      <mass value="10"/>
+      <inertia ixx="1.0" ixy="0.0" ixz="0.0" iyy="1.0" iyz="0.0" izz="1.0"/>
+    </inertial>
+  </link>
+
+  <joint name="left_base_joint" type="fixed">
+    <parent link="left_leg"/>
+    <child link="left_base"/>
+    <origin xyz="0 0 -0.6"/>
+  </joint>
+
+  <link name="left_front_wheel">
+    <visual>
+      <geometry>
+        <cylinder length=".1" radius="0.035"/>
+      </geometry>
+      <material name="black"/>
+    </visual>
+    <collision>
+      <geometry>
+        <cylinder length=".1" radius="0.035"/>
+      </geometry>
+    </collision>
+    <inertial>
+      <mass value="1"/>
+      <inertia ixx="1.0" ixy="0.0" ixz="0.0" iyy="1.0" iyz="0.0" izz="1.0"/>
+    </inertial>
+  </link>
+
+  <joint name="left_front_wheel_joint" type="continuous">
+    <axis xyz="0 0 1"/>
+    <parent link="left_base"/>
+    <child link="left_front_wheel"/>
+    <origin rpy="0 1.57075 0" xyz="0 0.133333333333 -0.085"/>
+    <limit effort="100" velocity="100"/>
+    <joint_properties damping="0.0" friction="0.0"/>
+  </joint>
+
+  <link name="left_back_wheel">
+    <visual>
+      <geometry>
+        <cylinder length=".1" radius="0.035"/>
+      </geometry>
+      <material name="black"/>
+    </visual>
+    <collision>
+      <geometry>
+        <cylinder length=".1" radius="0.035"/>
+      </geometry>
+    </collision>
+    <inertial>
+      <mass value="1"/>
+      <inertia ixx="1.0" ixy="0.0" ixz="0.0" iyy="1.0" iyz="0.0" izz="1.0"/>
+    </inertial>
+  </link>
+
+  <joint name="left_back_wheel_joint" type="continuous">
+    <axis xyz="0 0 1"/>
+    <parent link="left_base"/>
+    <child link="left_back_wheel"/>
+    <origin rpy="0 1.57075 0" xyz="0 -0.133333333333 -0.085"/>
+    <limit effort="100" velocity="100"/>
+    <joint_properties damping="0.0" friction="0.0"/>
+  </joint>
+  <joint name="gripper_extension" type="prismatic">
+    <parent link="base_link"/>
+    <child link="gripper_pole"/>
+    <limit effort="1000.0" lower="-0.38" upper="0" velocity="0.5"/>
+    <origin rpy="0 0 1.57075" xyz="0 0.19 .2"/>
+  </joint>
+
+  <link name="gripper_pole">
+    <visual>
+      <geometry>
+        <cylinder length="0.2" radius=".01"/>
+      </geometry>
+      <origin rpy="0 1.57075 0 " xyz="0.1 0 0"/>
+      <material name="Gray">
+        <color rgba=".7 .7 .7 1"/>
+      </material>
+    </visual>
+    <collision>
+      <geometry>
+        <cylinder length="0.2" radius=".01"/>
+      </geometry>
+      <origin rpy="0 1.57075 0 " xyz="0.1 0 0"/>
+    </collision>
+    <inertial>
+      <mass value="0.05"/>
+      <inertia ixx="1.0" ixy="0.0" ixz="0.0" iyy="1.0" iyz="0.0" izz="1.0"/>
+    </inertial>
+  </link>
+
+  <joint name="left_gripper_joint" type="revolute">
+    <axis xyz="0 0 1"/>
+    <limit effort="1000.0" lower="0.0" upper="0.548" velocity="0.5"/>
+    <origin rpy="0 0 0" xyz="0.2 0.01 0"/>
+    <parent link="gripper_pole"/>
+    <child link="left_gripper"/>
+  </joint>
+
+  <link name="left_gripper">
+    <visual>
+      <origin rpy="0.0 0 0" xyz="0 0 0"/>
+      <geometry>
+        <mesh filename="l_finger.stl"/>
+      </geometry>
+    </visual>
+    <collision>
+      <geometry>
+        <mesh filename="l_finger.stl"/>
+      </geometry>
+      <origin rpy="0.0 0 0" xyz="0 0 0"/>
+    </collision>
+    <inertial>
+      <mass value="0.05"/>
+      <inertia ixx="1.0" ixy="0.0" ixz="0.0" iyy="1.0" iyz="0.0" izz="1.0"/>
+    </inertial>
+  </link>
+
+  <joint name="left_tip_joint" type="fixed">
+    <parent link="left_gripper"/>
+    <child link="left_tip"/>
+  </joint>
+
+  <link name="left_tip">
+    <visual>
+      <origin rpy="0.0 0 0" xyz="0.09137 0.00495 0"/>
+      <geometry>
+        <mesh filename="l_finger_tip.stl"/>
+      </geometry>
+    </visual>
+    <collision>
+      <geometry>
+        <mesh filename="l_finger_tip.stl"/>
+      </geometry>
+      <origin rpy="0.0 0 0" xyz="0.09137 0.00495 0"/>
+    </collision>
+    <inertial>
+      <mass value="0.05"/>
+      <inertia ixx="1.0" ixy="0.0" ixz="0.0" iyy="1.0" iyz="0.0" izz="1.0"/>
+    </inertial>
+  </link>
+
+  <joint name="right_gripper_joint" type="revolute">
+    <axis xyz="0 0 -1"/>
+    <limit effort="1000.0" lower="0.0" upper="0.548" velocity="0.5"/>
+    <origin rpy="0 0 0" xyz="0.2 -0.01 0"/>
+    <parent link="gripper_pole"/>
+    <child link="right_gripper"/>
+  </joint>
+
+  <link name="right_gripper">
+    <visual>
+      <origin rpy="-3.1415 0 0" xyz="0 0 0"/>
+      <geometry>
+        <mesh filename="l_finger.stl"/>
+      </geometry>
+    </visual>
+    <collision>
+      <geometry>
+        <mesh filename="l_finger.stl"/>
+      </geometry>
+      <origin rpy="-3.1415 0 0" xyz="0 0 0"/>
+    </collision>
+    <inertial>
+      <mass value="0.05"/>
+      <inertia ixx="1.0" ixy="0.0" ixz="0.0" iyy="1.0" iyz="0.0" izz="1.0"/>
+    </inertial>
+  </link>
+
+  <joint name="right_tip_joint" type="fixed">
+    <parent link="right_gripper"/>
+    <child link="right_tip"/>
+  </joint>
+
+  <link name="right_tip">
+    <visual>
+      <origin rpy="-3.1415 0 0" xyz="0.09137 0.00495 0"/>
+      <geometry>
+        <mesh filename="l_finger_tip.stl"/>
+      </geometry>
+    </visual>
+    <collision>
+      <geometry>
+        <mesh filename="l_finger_tip.stl"/>
+      </geometry>
+      <origin rpy="-3.1415 0 0" xyz="0.09137 0.00495 0"/>
+    </collision>
+    <inertial>
+      <mass value="0.05"/>
+      <inertia ixx="1.0" ixy="0.0" ixz="0.0" iyy="1.0" iyz="0.0" izz="1.0"/>
+    </inertial>
+  </link>
+
+  <link name="head">
+    <visual>
+      <geometry>
+        <sphere radius="0.2"/>
+      </geometry>
+      <material name="white"/>
+    </visual>
+    <collision>
+      <geometry>
+        <sphere radius="0.2"/>
+      </geometry>
+    </collision>
+    <inertial>
+      <mass value="10"/>
+      <inertia ixx="1.0" ixy="0.0" ixz="0.0" iyy="1.0" iyz="0.0" izz="1.0"/>
+    </inertial>
+  </link>
+
+  <joint name="head_swivel" type="continuous">
+    <parent link="base_link"/>
+    <child link="head"/>
+    <axis xyz="0 0 1"/>
+    <origin xyz="0 0 0.3"/>
+  </joint>
+
+  <link name="box">
+    <visual>
+      <geometry>
+        <box size=".08 .08 .08"/>
+      </geometry>
+      <material name="blue"/>
+    </visual>
+    <collision>
+      <geometry>
+        <box size=".08 .08 .08"/>
+      </geometry>
+    </collision>
+    <inertial>
+      <mass value="1"/>
+      <inertia ixx="1.0" ixy="0.0" ixz="0.0" iyy="1.0" iyz="0.0" izz="1.0"/>
+    </inertial>
+  </link>
+
+  <joint name="tobox" type="fixed">
+    <parent link="head"/>
+    <child link="box"/>
+    <origin xyz="0 0.1414 0.1414"/>
+  </joint>
+
+</robot>
+
+
+);
+
+#endif  //URDF_SAMPLES_H
diff --git a/engine/inc/bullet/InverseDynamics/BulletInverseDynamicsUtilsCommon.h b/engine/inc/bullet/InverseDynamics/BulletInverseDynamicsUtilsCommon.h
new file mode 100644
index 00000000..87a0897f
--- /dev/null
+++ b/engine/inc/bullet/InverseDynamics/BulletInverseDynamicsUtilsCommon.h
@@ -0,0 +1,15 @@
+#ifndef BULLET_INVERSE_DYNAMICS_UTILS_COMMON_H
+#define BULLET_INVERSE_DYNAMICS_UTILS_COMMON_H
+#include "CoilCreator.hpp"
+#include "MultiBodyTreeCreator.hpp"
+#include "btMultiBodyFromURDF.hpp"
+#include "DillCreator.hpp"
+#include "MultiBodyTreeDebugGraph.hpp"
+#include "btMultiBodyTreeCreator.hpp"
+#include "IDRandomUtil.hpp"
+#include "SimpleTreeCreator.hpp"
+#include "invdyn_bullet_comparison.hpp"
+#include "MultiBodyNameMap.hpp"
+#include "User2InternalIndex.hpp"
+
+#endif  //BULLET_INVERSE_DYNAMICS_UTILS_COMMON_H
diff --git a/engine/inc/bullet/InverseDynamics/InverseDynamicsExample.h b/engine/inc/bullet/InverseDynamics/InverseDynamicsExample.h
new file mode 100644
index 00000000..ce21e54f
--- /dev/null
+++ b/engine/inc/bullet/InverseDynamics/InverseDynamicsExample.h
@@ -0,0 +1,27 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2015 Google Inc. http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef INVERSE_DYNAMICS_EXAMPLE_H
+#define INVERSE_DYNAMICS_EXAMPLE_H
+
+enum btInverseDynamicsExampleOptions
+{
+	BT_ID_LOAD_URDF = 0,
+	BT_ID_PROGRAMMATICALLY = 1
+};
+
+class CommonExampleInterface* InverseDynamicsExampleCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //INVERSE_DYNAMICS_EXAMPLE_H
diff --git a/engine/inc/bullet/InverseKinematics/InverseKinematicsExample.h b/engine/inc/bullet/InverseKinematics/InverseKinematicsExample.h
new file mode 100644
index 00000000..bdfbd813
--- /dev/null
+++ b/engine/inc/bullet/InverseKinematics/InverseKinematicsExample.h
@@ -0,0 +1,15 @@
+#ifndef INVERSE_KINEMATICSEXAMPLE_H
+#define INVERSE_KINEMATICSEXAMPLE_H
+
+enum Method
+{
+	IK_JACOB_TRANS = 0,
+	IK_PURE_PSEUDO,
+	IK_DLS,
+	IK_SDLS,
+	IK_DLS_SVD
+};
+
+class CommonExampleInterface* InverseKinematicsExampleCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //INVERSE_KINEMATICSEXAMPLE_H
diff --git a/engine/inc/bullet/LinearMath/TaskScheduler/btThreadSupportInterface.h b/engine/inc/bullet/LinearMath/TaskScheduler/btThreadSupportInterface.h
new file mode 100644
index 00000000..1fe49335
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/TaskScheduler/btThreadSupportInterface.h
@@ -0,0 +1,64 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2018 Erwin Coumans  http://bulletphysics.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_THREAD_SUPPORT_INTERFACE_H
+#define BT_THREAD_SUPPORT_INTERFACE_H
+
+class btCriticalSection
+{
+public:
+	btCriticalSection() {}
+	virtual ~btCriticalSection() {}
+
+	virtual void lock() = 0;
+	virtual void unlock() = 0;
+};
+
+class btThreadSupportInterface
+{
+public:
+	virtual ~btThreadSupportInterface() {}
+
+	virtual int getNumWorkerThreads() const = 0;            // number of worker threads (total number of logical processors - 1)
+	virtual int getCacheFriendlyNumThreads() const = 0;     // the number of logical processors sharing a single L3 cache
+	virtual int getLogicalToPhysicalCoreRatio() const = 0;  // the number of logical processors per physical processor (usually 1 or 2)
+	virtual void runTask(int threadIndex, void* userData) = 0;
+	virtual void waitForAllTasks() = 0;
+
+	virtual btCriticalSection* createCriticalSection() = 0;
+	virtual void deleteCriticalSection(btCriticalSection* criticalSection) = 0;
+
+	typedef void (*ThreadFunc)(void* userPtr);
+
+	struct ConstructionInfo
+	{
+		ConstructionInfo(const char* uniqueName,
+						 ThreadFunc userThreadFunc,
+						 int threadStackSize = 65535)
+			: m_uniqueName(uniqueName),
+			  m_userThreadFunc(userThreadFunc),
+			  m_threadStackSize(threadStackSize)
+		{
+		}
+
+		const char* m_uniqueName;
+		ThreadFunc m_userThreadFunc;
+		int m_threadStackSize;
+	};
+
+	static btThreadSupportInterface* create(const ConstructionInfo& info);
+};
+
+#endif  //BT_THREAD_SUPPORT_INTERFACE_H
diff --git a/engine/inc/bullet/LinearMath/btAabbUtil2.h b/engine/inc/bullet/LinearMath/btAabbUtil2.h
new file mode 100644
index 00000000..eea49dd3
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btAabbUtil2.h
@@ -0,0 +1,217 @@
+/*
+Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_AABB_UTIL2
+#define BT_AABB_UTIL2
+
+#include "btTransform.h"
+#include "btVector3.h"
+#include "btMinMax.h"
+
+SIMD_FORCE_INLINE void AabbExpand(btVector3& aabbMin,
+								  btVector3& aabbMax,
+								  const btVector3& expansionMin,
+								  const btVector3& expansionMax)
+{
+	aabbMin = aabbMin + expansionMin;
+	aabbMax = aabbMax + expansionMax;
+}
+
+/// conservative test for overlap between two aabbs
+SIMD_FORCE_INLINE bool TestPointAgainstAabb2(const btVector3& aabbMin1, const btVector3& aabbMax1,
+											 const btVector3& point)
+{
+	bool overlap = true;
+	overlap = (aabbMin1.getX() > point.getX() || aabbMax1.getX() < point.getX()) ? false : overlap;
+	overlap = (aabbMin1.getZ() > point.getZ() || aabbMax1.getZ() < point.getZ()) ? false : overlap;
+	overlap = (aabbMin1.getY() > point.getY() || aabbMax1.getY() < point.getY()) ? false : overlap;
+	return overlap;
+}
+
+/// conservative test for overlap between two aabbs
+SIMD_FORCE_INLINE bool TestAabbAgainstAabb2(const btVector3& aabbMin1, const btVector3& aabbMax1,
+											const btVector3& aabbMin2, const btVector3& aabbMax2)
+{
+	bool overlap = true;
+	overlap = (aabbMin1.getX() > aabbMax2.getX() || aabbMax1.getX() < aabbMin2.getX()) ? false : overlap;
+	overlap = (aabbMin1.getZ() > aabbMax2.getZ() || aabbMax1.getZ() < aabbMin2.getZ()) ? false : overlap;
+	overlap = (aabbMin1.getY() > aabbMax2.getY() || aabbMax1.getY() < aabbMin2.getY()) ? false : overlap;
+	return overlap;
+}
+
+/// conservative test for overlap between triangle and aabb
+SIMD_FORCE_INLINE bool TestTriangleAgainstAabb2(const btVector3* vertices,
+												const btVector3& aabbMin, const btVector3& aabbMax)
+{
+	const btVector3& p1 = vertices[0];
+	const btVector3& p2 = vertices[1];
+	const btVector3& p3 = vertices[2];
+
+	if (btMin(btMin(p1[0], p2[0]), p3[0]) > aabbMax[0]) return false;
+	if (btMax(btMax(p1[0], p2[0]), p3[0]) < aabbMin[0]) return false;
+
+	if (btMin(btMin(p1[2], p2[2]), p3[2]) > aabbMax[2]) return false;
+	if (btMax(btMax(p1[2], p2[2]), p3[2]) < aabbMin[2]) return false;
+
+	if (btMin(btMin(p1[1], p2[1]), p3[1]) > aabbMax[1]) return false;
+	if (btMax(btMax(p1[1], p2[1]), p3[1]) < aabbMin[1]) return false;
+	return true;
+}
+
+SIMD_FORCE_INLINE int btOutcode(const btVector3& p, const btVector3& halfExtent)
+{
+	return (p.getX() < -halfExtent.getX() ? 0x01 : 0x0) |
+		   (p.getX() > halfExtent.getX() ? 0x08 : 0x0) |
+		   (p.getY() < -halfExtent.getY() ? 0x02 : 0x0) |
+		   (p.getY() > halfExtent.getY() ? 0x10 : 0x0) |
+		   (p.getZ() < -halfExtent.getZ() ? 0x4 : 0x0) |
+		   (p.getZ() > halfExtent.getZ() ? 0x20 : 0x0);
+}
+
+SIMD_FORCE_INLINE bool btRayAabb2(const btVector3& rayFrom,
+								  const btVector3& rayInvDirection,
+								  const unsigned int raySign[3],
+								  const btVector3 bounds[2],
+								  btScalar& tmin,
+								  btScalar lambda_min,
+								  btScalar lambda_max)
+{
+	btScalar tmax, tymin, tymax, tzmin, tzmax;
+	tmin = (bounds[raySign[0]].getX() - rayFrom.getX()) * rayInvDirection.getX();
+	tmax = (bounds[1 - raySign[0]].getX() - rayFrom.getX()) * rayInvDirection.getX();
+	tymin = (bounds[raySign[1]].getY() - rayFrom.getY()) * rayInvDirection.getY();
+	tymax = (bounds[1 - raySign[1]].getY() - rayFrom.getY()) * rayInvDirection.getY();
+
+	if ((tmin > tymax) || (tymin > tmax))
+		return false;
+
+	if (tymin > tmin)
+		tmin = tymin;
+
+	if (tymax < tmax)
+		tmax = tymax;
+
+	tzmin = (bounds[raySign[2]].getZ() - rayFrom.getZ()) * rayInvDirection.getZ();
+	tzmax = (bounds[1 - raySign[2]].getZ() - rayFrom.getZ()) * rayInvDirection.getZ();
+
+	if ((tmin > tzmax) || (tzmin > tmax))
+		return false;
+	if (tzmin > tmin)
+		tmin = tzmin;
+	if (tzmax < tmax)
+		tmax = tzmax;
+	return ((tmin < lambda_max) && (tmax > lambda_min));
+}
+
+SIMD_FORCE_INLINE bool btRayAabb(const btVector3& rayFrom,
+								 const btVector3& rayTo,
+								 const btVector3& aabbMin,
+								 const btVector3& aabbMax,
+								 btScalar& param, btVector3& normal)
+{
+	btVector3 aabbHalfExtent = (aabbMax - aabbMin) * btScalar(0.5);
+	btVector3 aabbCenter = (aabbMax + aabbMin) * btScalar(0.5);
+	btVector3 source = rayFrom - aabbCenter;
+	btVector3 target = rayTo - aabbCenter;
+	int sourceOutcode = btOutcode(source, aabbHalfExtent);
+	int targetOutcode = btOutcode(target, aabbHalfExtent);
+	if ((sourceOutcode & targetOutcode) == 0x0)
+	{
+		btScalar lambda_enter = btScalar(0.0);
+		btScalar lambda_exit = param;
+		btVector3 r = target - source;
+		int i;
+		btScalar normSign = 1;
+		btVector3 hitNormal(0, 0, 0);
+		int bit = 1;
+
+		for (int j = 0; j < 2; j++)
+		{
+			for (i = 0; i != 3; ++i)
+			{
+				if (sourceOutcode & bit)
+				{
+					btScalar lambda = (-source[i] - aabbHalfExtent[i] * normSign) / r[i];
+					if (lambda_enter <= lambda)
+					{
+						lambda_enter = lambda;
+						hitNormal.setValue(0, 0, 0);
+						hitNormal[i] = normSign;
+					}
+				}
+				else if (targetOutcode & bit)
+				{
+					btScalar lambda = (-source[i] - aabbHalfExtent[i] * normSign) / r[i];
+					btSetMin(lambda_exit, lambda);
+				}
+				bit <<= 1;
+			}
+			normSign = btScalar(-1.);
+		}
+		if (lambda_enter <= lambda_exit)
+		{
+			param = lambda_enter;
+			normal = hitNormal;
+			return true;
+		}
+	}
+	return false;
+}
+
+SIMD_FORCE_INLINE void btTransformAabb(const btVector3& halfExtents, btScalar margin, const btTransform& t, btVector3& aabbMinOut, btVector3& aabbMaxOut)
+{
+	btVector3 halfExtentsWithMargin = halfExtents + btVector3(margin, margin, margin);
+	btMatrix3x3 abs_b = t.getBasis().absolute();
+	btVector3 center = t.getOrigin();
+	btVector3 extent = halfExtentsWithMargin.dot3(abs_b[0], abs_b[1], abs_b[2]);
+	aabbMinOut = center - extent;
+	aabbMaxOut = center + extent;
+}
+
+SIMD_FORCE_INLINE void btTransformAabb(const btVector3& localAabbMin, const btVector3& localAabbMax, btScalar margin, const btTransform& trans, btVector3& aabbMinOut, btVector3& aabbMaxOut)
+{
+	btAssert(localAabbMin.getX() <= localAabbMax.getX());
+	btAssert(localAabbMin.getY() <= localAabbMax.getY());
+	btAssert(localAabbMin.getZ() <= localAabbMax.getZ());
+	btVector3 localHalfExtents = btScalar(0.5) * (localAabbMax - localAabbMin);
+	localHalfExtents += btVector3(margin, margin, margin);
+
+	btVector3 localCenter = btScalar(0.5) * (localAabbMax + localAabbMin);
+	btMatrix3x3 abs_b = trans.getBasis().absolute();
+	btVector3 center = trans(localCenter);
+	btVector3 extent = localHalfExtents.dot3(abs_b[0], abs_b[1], abs_b[2]);
+	aabbMinOut = center - extent;
+	aabbMaxOut = center + extent;
+}
+
+#define USE_BANCHLESS 1
+#ifdef USE_BANCHLESS
+//This block replaces the block below and uses no branches, and replaces the 8 bit return with a 32 bit return for improved performance (~3x on XBox 360)
+SIMD_FORCE_INLINE unsigned testQuantizedAabbAgainstQuantizedAabb(const unsigned short int* aabbMin1, const unsigned short int* aabbMax1, const unsigned short int* aabbMin2, const unsigned short int* aabbMax2)
+{
+	return static_cast<unsigned int>(btSelect((unsigned)((aabbMin1[0] <= aabbMax2[0]) & (aabbMax1[0] >= aabbMin2[0]) & (aabbMin1[2] <= aabbMax2[2]) & (aabbMax1[2] >= aabbMin2[2]) & (aabbMin1[1] <= aabbMax2[1]) & (aabbMax1[1] >= aabbMin2[1])),
+											  1, 0));
+}
+#else
+SIMD_FORCE_INLINE bool testQuantizedAabbAgainstQuantizedAabb(const unsigned short int* aabbMin1, const unsigned short int* aabbMax1, const unsigned short int* aabbMin2, const unsigned short int* aabbMax2)
+{
+	bool overlap = true;
+	overlap = (aabbMin1[0] > aabbMax2[0] || aabbMax1[0] < aabbMin2[0]) ? false : overlap;
+	overlap = (aabbMin1[2] > aabbMax2[2] || aabbMax1[2] < aabbMin2[2]) ? false : overlap;
+	overlap = (aabbMin1[1] > aabbMax2[1] || aabbMax1[1] < aabbMin2[1]) ? false : overlap;
+	return overlap;
+}
+#endif  //USE_BANCHLESS
+
+#endif  //BT_AABB_UTIL2
diff --git a/engine/inc/bullet/LinearMath/btAlignedAllocator.h b/engine/inc/bullet/LinearMath/btAlignedAllocator.h
new file mode 100644
index 00000000..971f62bf
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btAlignedAllocator.h
@@ -0,0 +1,115 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_ALIGNED_ALLOCATOR
+#define BT_ALIGNED_ALLOCATOR
+
+///we probably replace this with our own aligned memory allocator
+///so we replace _aligned_malloc and _aligned_free with our own
+///that is better portable and more predictable
+
+#include "btScalar.h"
+
+///BT_DEBUG_MEMORY_ALLOCATIONS preprocessor can be set in build system
+///for regression tests to detect memory leaks
+///#define BT_DEBUG_MEMORY_ALLOCATIONS 1
+#ifdef BT_DEBUG_MEMORY_ALLOCATIONS
+
+int btDumpMemoryLeaks();
+
+#define btAlignedAlloc(a, b) \
+	btAlignedAllocInternal(a, b, __LINE__, __FILE__)
+
+#define btAlignedFree(ptr) \
+	btAlignedFreeInternal(ptr, __LINE__, __FILE__)
+
+void* btAlignedAllocInternal(size_t size, int alignment, int line, const char* filename);
+
+void btAlignedFreeInternal(void* ptr, int line, const char* filename);
+
+#else
+void* btAlignedAllocInternal(size_t size, int alignment);
+void btAlignedFreeInternal(void* ptr);
+
+#define btAlignedAlloc(size, alignment) btAlignedAllocInternal(size, alignment)
+#define btAlignedFree(ptr) btAlignedFreeInternal(ptr)
+
+#endif
+typedef int size_type;
+
+typedef void*(btAlignedAllocFunc)(size_t size, int alignment);
+typedef void(btAlignedFreeFunc)(void* memblock);
+typedef void*(btAllocFunc)(size_t size);
+typedef void(btFreeFunc)(void* memblock);
+
+///The developer can let all Bullet memory allocations go through a custom memory allocator, using btAlignedAllocSetCustom
+void btAlignedAllocSetCustom(btAllocFunc* allocFunc, btFreeFunc* freeFunc);
+///If the developer has already an custom aligned allocator, then btAlignedAllocSetCustomAligned can be used. The default aligned allocator pre-allocates extra memory using the non-aligned allocator, and instruments it.
+void btAlignedAllocSetCustomAligned(btAlignedAllocFunc* allocFunc, btAlignedFreeFunc* freeFunc);
+
+///The btAlignedAllocator is a portable class for aligned memory allocations.
+///Default implementations for unaligned and aligned allocations can be overridden by a custom allocator using btAlignedAllocSetCustom and btAlignedAllocSetCustomAligned.
+template <typename T, unsigned Alignment>
+class btAlignedAllocator
+{
+	typedef btAlignedAllocator<T, Alignment> self_type;
+
+public:
+	//just going down a list:
+	btAlignedAllocator() {}
+	/*
+	btAlignedAllocator( const self_type & ) {}
+	*/
+
+	template <typename Other>
+	btAlignedAllocator(const btAlignedAllocator<Other, Alignment>&)
+	{
+	}
+
+	typedef const T* const_pointer;
+	typedef const T& const_reference;
+	typedef T* pointer;
+	typedef T& reference;
+	typedef T value_type;
+
+	pointer address(reference ref) const { return &ref; }
+	const_pointer address(const_reference ref) const { return &ref; }
+	pointer allocate(size_type n, const_pointer* hint = 0)
+	{
+		(void)hint;
+		return reinterpret_cast<pointer>(btAlignedAlloc(sizeof(value_type) * n, Alignment));
+	}
+	void construct(pointer ptr, const value_type& value) { new (ptr) value_type(value); }
+	void deallocate(pointer ptr)
+	{
+		btAlignedFree(reinterpret_cast<void*>(ptr));
+	}
+	void destroy(pointer ptr) { ptr->~value_type(); }
+
+	template <typename O>
+	struct rebind
+	{
+		typedef btAlignedAllocator<O, Alignment> other;
+	};
+	template <typename O>
+	self_type& operator=(const btAlignedAllocator<O, Alignment>&)
+	{
+		return *this;
+	}
+
+	friend bool operator==(const self_type&, const self_type&) { return true; }
+};
+
+#endif  //BT_ALIGNED_ALLOCATOR
diff --git a/engine/inc/bullet/LinearMath/btAlignedObjectArray.h b/engine/inc/bullet/LinearMath/btAlignedObjectArray.h
new file mode 100644
index 00000000..b3d5d64b
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btAlignedObjectArray.h
@@ -0,0 +1,504 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_OBJECT_ARRAY__
+#define BT_OBJECT_ARRAY__
+
+#include "btScalar.h"  // has definitions like SIMD_FORCE_INLINE
+#include "btAlignedAllocator.h"
+
+///If the platform doesn't support placement new, you can disable BT_USE_PLACEMENT_NEW
+///then the btAlignedObjectArray doesn't support objects with virtual methods, and non-trivial constructors/destructors
+///You can enable BT_USE_MEMCPY, then swapping elements in the array will use memcpy instead of operator=
+///see discussion here: http://continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=1231 and
+///http://www.continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=1240
+
+#define BT_USE_PLACEMENT_NEW 1
+//#define BT_USE_MEMCPY 1 //disable, because it is cumbersome to find out for each platform where memcpy is defined. It can be in <memory.h> or <string.h> or otherwise...
+#define BT_ALLOW_ARRAY_COPY_OPERATOR  // enabling this can accidently perform deep copies of data if you are not careful
+
+#ifdef BT_USE_MEMCPY
+#include <memory.h>
+#include <string.h>
+#endif  //BT_USE_MEMCPY
+
+#ifdef BT_USE_PLACEMENT_NEW
+#include <new>  //for placement new
+#endif          //BT_USE_PLACEMENT_NEW
+
+///The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods
+///It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data
+template <typename T>
+//template <class T>
+class btAlignedObjectArray
+{
+	btAlignedAllocator<T, 16> m_allocator;
+
+	int m_size;
+	int m_capacity;
+	T* m_data;
+	//PCK: added this line
+	bool m_ownsMemory;
+
+#ifdef BT_ALLOW_ARRAY_COPY_OPERATOR
+public:
+	SIMD_FORCE_INLINE btAlignedObjectArray<T>& operator=(const btAlignedObjectArray<T>& other)
+	{
+		copyFromArray(other);
+		return *this;
+	}
+#else   //BT_ALLOW_ARRAY_COPY_OPERATOR
+private:
+	SIMD_FORCE_INLINE btAlignedObjectArray<T>& operator=(const btAlignedObjectArray<T>& other);
+#endif  //BT_ALLOW_ARRAY_COPY_OPERATOR
+
+protected:
+	SIMD_FORCE_INLINE int allocSize(int size)
+	{
+		return (size ? size * 2 : 1);
+	}
+	SIMD_FORCE_INLINE void copy(int start, int end, T* dest) const
+	{
+		int i;
+		for (i = start; i < end; ++i)
+#ifdef BT_USE_PLACEMENT_NEW
+			new (&dest[i]) T(m_data[i]);
+#else
+			dest[i] = m_data[i];
+#endif  //BT_USE_PLACEMENT_NEW
+	}
+
+	SIMD_FORCE_INLINE void init()
+	{
+		//PCK: added this line
+		m_ownsMemory = true;
+		m_data = 0;
+		m_size = 0;
+		m_capacity = 0;
+	}
+	SIMD_FORCE_INLINE void destroy(int first, int last)
+	{
+		int i;
+		for (i = first; i < last; i++)
+		{
+			m_data[i].~T();
+		}
+	}
+
+	SIMD_FORCE_INLINE void* allocate(int size)
+	{
+		if (size)
+			return m_allocator.allocate(size);
+		return 0;
+	}
+
+	SIMD_FORCE_INLINE void deallocate()
+	{
+		if (m_data)
+		{
+			//PCK: enclosed the deallocation in this block
+			if (m_ownsMemory)
+			{
+				m_allocator.deallocate(m_data);
+			}
+			m_data = 0;
+		}
+	}
+
+public:
+	btAlignedObjectArray()
+	{
+		init();
+	}
+
+	~btAlignedObjectArray()
+	{
+		clear();
+	}
+
+	///Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead.
+	btAlignedObjectArray(const btAlignedObjectArray& otherArray)
+	{
+		init();
+
+		int otherSize = otherArray.size();
+		resize(otherSize);
+		otherArray.copy(0, otherSize, m_data);
+	}
+
+	/// return the number of elements in the array
+	SIMD_FORCE_INLINE int size() const
+	{
+		return m_size;
+	}
+
+	SIMD_FORCE_INLINE const T& at(int n) const
+	{
+		btAssert(n >= 0);
+		btAssert(n < size());
+		return m_data[n];
+	}
+
+	SIMD_FORCE_INLINE T& at(int n)
+	{
+		btAssert(n >= 0);
+		btAssert(n < size());
+		return m_data[n];
+	}
+
+	SIMD_FORCE_INLINE const T& operator[](int n) const
+	{
+		btAssert(n >= 0);
+		btAssert(n < size());
+		return m_data[n];
+	}
+
+	SIMD_FORCE_INLINE T& operator[](int n)
+	{
+		btAssert(n >= 0);
+		btAssert(n < size());
+		return m_data[n];
+	}
+
+	///clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations.
+	SIMD_FORCE_INLINE void clear()
+	{
+		destroy(0, size());
+
+		deallocate();
+
+		init();
+	}
+
+	SIMD_FORCE_INLINE void pop_back()
+	{
+		btAssert(m_size > 0);
+		m_size--;
+		m_data[m_size].~T();
+	}
+
+	///resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument.
+	///when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations.
+	SIMD_FORCE_INLINE void resizeNoInitialize(int newsize)
+	{
+		if (newsize > size())
+		{
+			reserve(newsize);
+		}
+		m_size = newsize;
+	}
+
+	SIMD_FORCE_INLINE void resize(int newsize, const T& fillData = T())
+	{
+		const int curSize = size();
+
+		if (newsize < curSize)
+		{
+			for (int i = newsize; i < curSize; i++)
+			{
+				m_data[i].~T();
+			}
+		}
+		else
+		{
+			if (newsize > curSize)
+			{
+				reserve(newsize);
+			}
+#ifdef BT_USE_PLACEMENT_NEW
+			for (int i = curSize; i < newsize; i++)
+			{
+				new (&m_data[i]) T(fillData);
+			}
+#endif  //BT_USE_PLACEMENT_NEW
+		}
+
+		m_size = newsize;
+	}
+	SIMD_FORCE_INLINE T& expandNonInitializing()
+	{
+		const int sz = size();
+		if (sz == capacity())
+		{
+			reserve(allocSize(size()));
+		}
+		m_size++;
+
+		return m_data[sz];
+	}
+
+	SIMD_FORCE_INLINE T& expand(const T& fillValue = T())
+	{
+		const int sz = size();
+		if (sz == capacity())
+		{
+			reserve(allocSize(size()));
+		}
+		m_size++;
+#ifdef BT_USE_PLACEMENT_NEW
+		new (&m_data[sz]) T(fillValue);  //use the in-place new (not really allocating heap memory)
+#endif
+
+		return m_data[sz];
+	}
+
+	SIMD_FORCE_INLINE void push_back(const T& _Val)
+	{
+		const int sz = size();
+		if (sz == capacity())
+		{
+			reserve(allocSize(size()));
+		}
+
+#ifdef BT_USE_PLACEMENT_NEW
+		new (&m_data[m_size]) T(_Val);
+#else
+		m_data[size()] = _Val;
+#endif  //BT_USE_PLACEMENT_NEW
+
+		m_size++;
+	}
+
+	/// return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve()
+	SIMD_FORCE_INLINE int capacity() const
+	{
+		return m_capacity;
+	}
+
+	SIMD_FORCE_INLINE void reserve(int _Count)
+	{  // determine new minimum length of allocated storage
+		if (capacity() < _Count)
+		{  // not enough room, reallocate
+			T* s = (T*)allocate(_Count);
+
+			copy(0, size(), s);
+
+			destroy(0, size());
+
+			deallocate();
+
+			//PCK: added this line
+			m_ownsMemory = true;
+
+			m_data = s;
+
+			m_capacity = _Count;
+		}
+	}
+
+	class less
+	{
+	public:
+		bool operator()(const T& a, const T& b) const
+		{
+			return (a < b);
+		}
+	};
+
+	template <typename L>
+	void quickSortInternal(const L& CompareFunc, int lo, int hi)
+	{
+		//  lo is the lower index, hi is the upper index
+		//  of the region of array a that is to be sorted
+		int i = lo, j = hi;
+		T x = m_data[(lo + hi) / 2];
+
+		//  partition
+		do
+		{
+			while (CompareFunc(m_data[i], x))
+				i++;
+			while (CompareFunc(x, m_data[j]))
+				j--;
+			if (i <= j)
+			{
+				swap(i, j);
+				i++;
+				j--;
+			}
+		} while (i <= j);
+
+		//  recursion
+		if (lo < j)
+			quickSortInternal(CompareFunc, lo, j);
+		if (i < hi)
+			quickSortInternal(CompareFunc, i, hi);
+	}
+
+	template <typename L>
+	void quickSort(const L& CompareFunc)
+	{
+		//don't sort 0 or 1 elements
+		if (size() > 1)
+		{
+			quickSortInternal(CompareFunc, 0, size() - 1);
+		}
+	}
+
+	///heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/
+	template <typename L>
+	void downHeap(T* pArr, int k, int n, const L& CompareFunc)
+	{
+		/*  PRE: a[k+1..N] is a heap */
+		/* POST:  a[k..N]  is a heap */
+
+		T temp = pArr[k - 1];
+		/* k has child(s) */
+		while (k <= n / 2)
+		{
+			int child = 2 * k;
+
+			if ((child < n) && CompareFunc(pArr[child - 1], pArr[child]))
+			{
+				child++;
+			}
+			/* pick larger child */
+			if (CompareFunc(temp, pArr[child - 1]))
+			{
+				/* move child up */
+				pArr[k - 1] = pArr[child - 1];
+				k = child;
+			}
+			else
+			{
+				break;
+			}
+		}
+		pArr[k - 1] = temp;
+	} /*downHeap*/
+
+	void swap(int index0, int index1)
+	{
+#ifdef BT_USE_MEMCPY
+		char temp[sizeof(T)];
+		memcpy(temp, &m_data[index0], sizeof(T));
+		memcpy(&m_data[index0], &m_data[index1], sizeof(T));
+		memcpy(&m_data[index1], temp, sizeof(T));
+#else
+		T temp = m_data[index0];
+		m_data[index0] = m_data[index1];
+		m_data[index1] = temp;
+#endif  //BT_USE_PLACEMENT_NEW
+	}
+
+	template <typename L>
+	void heapSort(const L& CompareFunc)
+	{
+		/* sort a[0..N-1],  N.B. 0 to N-1 */
+		int k;
+		int n = m_size;
+		for (k = n / 2; k > 0; k--)
+		{
+			downHeap(m_data, k, n, CompareFunc);
+		}
+
+		/* a[1..N] is now a heap */
+		while (n >= 1)
+		{
+			swap(0, n - 1); /* largest of a[0..n-1] */
+
+			n = n - 1;
+			/* restore a[1..i-1] heap */
+			downHeap(m_data, 1, n, CompareFunc);
+		}
+	}
+
+	///non-recursive binary search, assumes sorted array
+	int findBinarySearch(const T& key) const
+	{
+		int first = 0;
+		int last = size() - 1;
+
+		//assume sorted array
+		while (first <= last)
+		{
+			int mid = (first + last) / 2;  // compute mid point.
+			if (key > m_data[mid])
+				first = mid + 1;  // repeat search in top half.
+			else if (key < m_data[mid])
+				last = mid - 1;  // repeat search in bottom half.
+			else
+				return mid;  // found it. return position /////
+		}
+		return size();  // failed to find key
+	}
+
+	int findLinearSearch(const T& key) const
+	{
+		int index = size();
+		int i;
+
+		for (i = 0; i < size(); i++)
+		{
+			if (m_data[i] == key)
+			{
+				index = i;
+				break;
+			}
+		}
+		return index;
+	}
+
+	// If the key is not in the array, return -1 instead of 0,
+	// since 0 also means the first element in the array.
+	int findLinearSearch2(const T& key) const
+	{
+		int index = -1;
+		int i;
+
+		for (i = 0; i < size(); i++)
+		{
+			if (m_data[i] == key)
+			{
+				index = i;
+				break;
+			}
+		}
+		return index;
+	}
+
+	void removeAtIndex(int index)
+	{
+		if (index < size())
+		{
+			swap(index, size() - 1);
+			pop_back();
+		}
+	}
+	void remove(const T& key)
+	{
+		int findIndex = findLinearSearch(key);
+		removeAtIndex(findIndex);
+	}
+
+	//PCK: whole function
+	void initializeFromBuffer(void* buffer, int size, int capacity)
+	{
+		clear();
+		m_ownsMemory = false;
+		m_data = (T*)buffer;
+		m_size = size;
+		m_capacity = capacity;
+	}
+
+	void copyFromArray(const btAlignedObjectArray& otherArray)
+	{
+		int otherSize = otherArray.size();
+		resize(otherSize);
+		otherArray.copy(0, otherSize, m_data);
+	}
+};
+
+#endif  //BT_OBJECT_ARRAY__
diff --git a/engine/inc/bullet/LinearMath/btConvexHull.h b/engine/inc/bullet/LinearMath/btConvexHull.h
new file mode 100644
index 00000000..f890d75e
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btConvexHull.h
@@ -0,0 +1,233 @@
+
+/*
+Stan Melax Convex Hull Computation
+Copyright (c) 2008 Stan Melax http://www.melax.com/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+///includes modifications/improvements by John Ratcliff, see BringOutYourDead below.
+
+#ifndef BT_CD_HULL_H
+#define BT_CD_HULL_H
+
+#include "btVector3.h"
+#include "btAlignedObjectArray.h"
+
+typedef btAlignedObjectArray<unsigned int> TUIntArray;
+
+class HullResult
+{
+public:
+	HullResult(void)
+	{
+		mPolygons = true;
+		mNumOutputVertices = 0;
+		mNumFaces = 0;
+		mNumIndices = 0;
+	}
+	bool mPolygons;                                    // true if indices represents polygons, false indices are triangles
+	unsigned int mNumOutputVertices;                   // number of vertices in the output hull
+	btAlignedObjectArray<btVector3> m_OutputVertices;  // array of vertices
+	unsigned int mNumFaces;                            // the number of faces produced
+	unsigned int mNumIndices;                          // the total number of indices
+	btAlignedObjectArray<unsigned int> m_Indices;      // pointer to indices.
+
+	// If triangles, then indices are array indexes into the vertex list.
+	// If polygons, indices are in the form (number of points in face) (p1, p2, p3, ..) etc..
+};
+
+enum HullFlag
+{
+	QF_TRIANGLES = (1 << 0),      // report results as triangles, not polygons.
+	QF_REVERSE_ORDER = (1 << 1),  // reverse order of the triangle indices.
+	QF_DEFAULT = QF_TRIANGLES
+};
+
+class HullDesc
+{
+public:
+	HullDesc(void)
+	{
+		mFlags = QF_DEFAULT;
+		mVcount = 0;
+		mVertices = 0;
+		mVertexStride = sizeof(btVector3);
+		mNormalEpsilon = 0.001f;
+		mMaxVertices = 4096;  // maximum number of points to be considered for a convex hull.
+		mMaxFaces = 4096;
+	};
+
+	HullDesc(HullFlag flag,
+			 unsigned int vcount,
+			 const btVector3* vertices,
+			 unsigned int stride = sizeof(btVector3))
+	{
+		mFlags = flag;
+		mVcount = vcount;
+		mVertices = vertices;
+		mVertexStride = stride;
+		mNormalEpsilon = btScalar(0.001);
+		mMaxVertices = 4096;
+	}
+
+	bool HasHullFlag(HullFlag flag) const
+	{
+		if (mFlags & flag) return true;
+		return false;
+	}
+
+	void SetHullFlag(HullFlag flag)
+	{
+		mFlags |= flag;
+	}
+
+	void ClearHullFlag(HullFlag flag)
+	{
+		mFlags &= ~flag;
+	}
+
+	unsigned int mFlags;         // flags to use when generating the convex hull.
+	unsigned int mVcount;        // number of vertices in the input point cloud
+	const btVector3* mVertices;  // the array of vertices.
+	unsigned int mVertexStride;  // the stride of each vertex, in bytes.
+	btScalar mNormalEpsilon;     // the epsilon for removing duplicates.  This is a normalized value, if normalized bit is on.
+	unsigned int mMaxVertices;   // maximum number of vertices to be considered for the hull!
+	unsigned int mMaxFaces;
+};
+
+enum HullError
+{
+	QE_OK,   // success!
+	QE_FAIL  // failed.
+};
+
+class btPlane
+{
+public:
+	btVector3 normal;
+	btScalar dist;  // distance below origin - the D from plane equasion Ax+By+Cz+D=0
+	btPlane(const btVector3& n, btScalar d) : normal(n), dist(d) {}
+	btPlane() : normal(), dist(0) {}
+};
+
+class ConvexH
+{
+public:
+	class HalfEdge
+	{
+	public:
+		short ea;         // the other half of the edge (index into edges list)
+		unsigned char v;  // the vertex at the start of this edge (index into vertices list)
+		unsigned char p;  // the facet on which this edge lies (index into facets list)
+		HalfEdge() {}
+		HalfEdge(short _ea, unsigned char _v, unsigned char _p) : ea(_ea), v(_v), p(_p) {}
+	};
+	ConvexH()
+	{
+	}
+	~ConvexH()
+	{
+	}
+	btAlignedObjectArray<btVector3> vertices;
+	btAlignedObjectArray<HalfEdge> edges;
+	btAlignedObjectArray<btPlane> facets;
+	ConvexH(int vertices_size, int edges_size, int facets_size);
+};
+
+class int4
+{
+public:
+	int x, y, z, w;
+	int4(){};
+	int4(int _x, int _y, int _z, int _w)
+	{
+		x = _x;
+		y = _y;
+		z = _z;
+		w = _w;
+	}
+	const int& operator[](int i) const { return (&x)[i]; }
+	int& operator[](int i) { return (&x)[i]; }
+};
+
+class PHullResult
+{
+public:
+	PHullResult(void)
+	{
+		mVcount = 0;
+		mIndexCount = 0;
+		mFaceCount = 0;
+		mVertices = 0;
+	}
+
+	unsigned int mVcount;
+	unsigned int mIndexCount;
+	unsigned int mFaceCount;
+	btVector3* mVertices;
+	TUIntArray m_Indices;
+};
+
+///The HullLibrary class can create a convex hull from a collection of vertices, using the ComputeHull method.
+///The btShapeHull class uses this HullLibrary to create a approximate convex mesh given a general (non-polyhedral) convex shape.
+class HullLibrary
+{
+	btAlignedObjectArray<class btHullTriangle*> m_tris;
+
+public:
+	btAlignedObjectArray<int> m_vertexIndexMapping;
+
+	HullError CreateConvexHull(const HullDesc& desc,  // describes the input request
+							   HullResult& result);   // contains the resulst
+	HullError ReleaseResult(HullResult& result);      // release memory allocated for this result, we are done with it.
+
+private:
+	bool ComputeHull(unsigned int vcount, const btVector3* vertices, PHullResult& result, unsigned int vlimit);
+
+	class btHullTriangle* allocateTriangle(int a, int b, int c);
+	void deAllocateTriangle(btHullTriangle*);
+	void b2bfix(btHullTriangle* s, btHullTriangle* t);
+
+	void removeb2b(btHullTriangle* s, btHullTriangle* t);
+
+	void checkit(btHullTriangle* t);
+
+	btHullTriangle* extrudable(btScalar epsilon);
+
+	int calchull(btVector3* verts, int verts_count, TUIntArray& tris_out, int& tris_count, int vlimit);
+
+	int calchullgen(btVector3* verts, int verts_count, int vlimit);
+
+	int4 FindSimplex(btVector3* verts, int verts_count, btAlignedObjectArray<int>& allow);
+
+	class ConvexH* ConvexHCrop(ConvexH& convex, const btPlane& slice);
+
+	void extrude(class btHullTriangle* t0, int v);
+
+	ConvexH* test_cube();
+
+	//BringOutYourDead (John Ratcliff): When you create a convex hull you hand it a large input set of vertices forming a 'point cloud'.
+	//After the hull is generated it give you back a set of polygon faces which index the *original* point cloud.
+	//The thing is, often times, there are many 'dead vertices' in the point cloud that are on longer referenced by the hull.
+	//The routine 'BringOutYourDead' find only the referenced vertices, copies them to an new buffer, and re-indexes the hull so that it is a minimal representation.
+	void BringOutYourDead(const btVector3* verts, unsigned int vcount, btVector3* overts, unsigned int& ocount, unsigned int* indices, unsigned indexcount);
+
+	bool CleanupVertices(unsigned int svcount,
+						 const btVector3* svertices,
+						 unsigned int stride,
+						 unsigned int& vcount,  // output number of vertices
+						 btVector3* vertices,   // location to store the results.
+						 btScalar normalepsilon,
+						 btVector3& scale);
+};
+
+#endif  //BT_CD_HULL_H
diff --git a/engine/inc/bullet/LinearMath/btConvexHullComputer.h b/engine/inc/bullet/LinearMath/btConvexHullComputer.h
new file mode 100644
index 00000000..18b26eea
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btConvexHullComputer.h
@@ -0,0 +1,102 @@
+/*
+Copyright (c) 2011 Ole Kniemeyer, MAXON, www.maxon.net
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_CONVEX_HULL_COMPUTER_H
+#define BT_CONVEX_HULL_COMPUTER_H
+
+#include "btVector3.h"
+#include "btAlignedObjectArray.h"
+
+/// Convex hull implementation based on Preparata and Hong
+/// See http://code.google.com/p/bullet/issues/detail?id=275
+/// Ole Kniemeyer, MAXON Computer GmbH
+class btConvexHullComputer
+{
+private:
+	btScalar compute(const void* coords, bool doubleCoords, int stride, int count, btScalar shrink, btScalar shrinkClamp);
+
+public:
+	class Edge
+	{
+	private:
+		int next;
+		int reverse;
+		int targetVertex;
+
+		friend class btConvexHullComputer;
+
+	public:
+		int getSourceVertex() const
+		{
+			return (this + reverse)->targetVertex;
+		}
+
+		int getTargetVertex() const
+		{
+			return targetVertex;
+		}
+
+		const Edge* getNextEdgeOfVertex() const  // clockwise list of all edges of a vertex
+		{
+			return this + next;
+		}
+
+		const Edge* getNextEdgeOfFace() const  // counter-clockwise list of all edges of a face
+		{
+			return (this + reverse)->getNextEdgeOfVertex();
+		}
+
+		const Edge* getReverseEdge() const
+		{
+			return this + reverse;
+		}
+	};
+
+	// Vertices of the output hull
+	btAlignedObjectArray<btVector3> vertices;
+
+	// The original vertex index in the input coords array
+	btAlignedObjectArray<int> original_vertex_index;
+
+	// Edges of the output hull
+	btAlignedObjectArray<Edge> edges;
+
+	// Faces of the convex hull. Each entry is an index into the "edges" array pointing to an edge of the face. Faces are planar n-gons
+	btAlignedObjectArray<int> faces;
+
+	/*
+		Compute convex hull of "count" vertices stored in "coords". "stride" is the difference in bytes
+		between the addresses of consecutive vertices. If "shrink" is positive, the convex hull is shrunken
+		by that amount (each face is moved by "shrink" length units towards the center along its normal).
+		If "shrinkClamp" is positive, "shrink" is clamped to not exceed "shrinkClamp * innerRadius", where "innerRadius"
+		is the minimum distance of a face to the center of the convex hull.
+
+		The returned value is the amount by which the hull has been shrunken. If it is negative, the amount was so large
+		that the resulting convex hull is empty.
+
+		The output convex hull can be found in the member variables "vertices", "edges", "faces".
+		*/
+	btScalar compute(const float* coords, int stride, int count, btScalar shrink, btScalar shrinkClamp)
+	{
+		return compute(coords, false, stride, count, shrink, shrinkClamp);
+	}
+
+	// same as above, but double precision
+	btScalar compute(const double* coords, int stride, int count, btScalar shrink, btScalar shrinkClamp)
+	{
+		return compute(coords, true, stride, count, shrink, shrinkClamp);
+	}
+};
+
+#endif  //BT_CONVEX_HULL_COMPUTER_H
diff --git a/engine/inc/bullet/LinearMath/btCpuFeatureUtility.h b/engine/inc/bullet/LinearMath/btCpuFeatureUtility.h
new file mode 100644
index 00000000..5e4b9a31
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btCpuFeatureUtility.h
@@ -0,0 +1,88 @@
+
+#ifndef BT_CPU_UTILITY_H
+#define BT_CPU_UTILITY_H
+
+#include "LinearMath/btScalar.h"
+
+#include <string.h>  //memset
+#ifdef USE_SIMD
+#include <emmintrin.h>
+#ifdef BT_ALLOW_SSE4
+#include <intrin.h>
+#endif  //BT_ALLOW_SSE4
+#endif  //USE_SIMD
+
+#if defined BT_USE_NEON
+#define ARM_NEON_GCC_COMPATIBILITY 1
+#include <arm_neon.h>
+#include <sys/types.h>
+#include <sys/sysctl.h>  //for sysctlbyname
+#endif                   //BT_USE_NEON
+
+///Rudimentary btCpuFeatureUtility for CPU features: only report the features that Bullet actually uses (SSE4/FMA3, NEON_HPFP)
+///We assume SSE2 in case BT_USE_SSE2 is defined in LinearMath/btScalar.h
+class btCpuFeatureUtility
+{
+public:
+	enum btCpuFeature
+	{
+		CPU_FEATURE_FMA3 = 1,
+		CPU_FEATURE_SSE4_1 = 2,
+		CPU_FEATURE_NEON_HPFP = 4
+	};
+
+	static int getCpuFeatures()
+	{
+		static int capabilities = 0;
+		static bool testedCapabilities = false;
+		if (0 != testedCapabilities)
+		{
+			return capabilities;
+		}
+
+#ifdef BT_USE_NEON
+		{
+			uint32_t hasFeature = 0;
+			size_t featureSize = sizeof(hasFeature);
+			int err = sysctlbyname("hw.optional.neon_hpfp", &hasFeature, &featureSize, NULL, 0);
+			if (0 == err && hasFeature)
+				capabilities |= CPU_FEATURE_NEON_HPFP;
+		}
+#endif  //BT_USE_NEON
+
+#ifdef BT_ALLOW_SSE4
+		{
+			int cpuInfo[4];
+			memset(cpuInfo, 0, sizeof(cpuInfo));
+			unsigned long long sseExt = 0;
+			__cpuid(cpuInfo, 1);
+
+			bool osUsesXSAVE_XRSTORE = cpuInfo[2] & (1 << 27) || false;
+			bool cpuAVXSuport = cpuInfo[2] & (1 << 28) || false;
+
+			if (osUsesXSAVE_XRSTORE && cpuAVXSuport)
+			{
+				sseExt = _xgetbv(0);
+			}
+			const int OSXSAVEFlag = (1UL << 27);
+			const int AVXFlag = ((1UL << 28) | OSXSAVEFlag);
+			const int FMAFlag = ((1UL << 12) | AVXFlag | OSXSAVEFlag);
+			if ((cpuInfo[2] & FMAFlag) == FMAFlag && (sseExt & 6) == 6)
+			{
+				capabilities |= btCpuFeatureUtility::CPU_FEATURE_FMA3;
+			}
+
+			const int SSE41Flag = (1 << 19);
+			if (cpuInfo[2] & SSE41Flag)
+			{
+				capabilities |= btCpuFeatureUtility::CPU_FEATURE_SSE4_1;
+			}
+		}
+#endif  //BT_ALLOW_SSE4
+
+		testedCapabilities = true;
+		return capabilities;
+	}
+};
+
+#endif  //BT_CPU_UTILITY_H
diff --git a/engine/inc/bullet/LinearMath/btDefaultMotionState.h b/engine/inc/bullet/LinearMath/btDefaultMotionState.h
new file mode 100644
index 00000000..14c40d36
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btDefaultMotionState.h
@@ -0,0 +1,40 @@
+#ifndef BT_DEFAULT_MOTION_STATE_H
+#define BT_DEFAULT_MOTION_STATE_H
+
+#include "btMotionState.h"
+
+///The btDefaultMotionState provides a common implementation to synchronize world transforms with offsets.
+ATTRIBUTE_ALIGNED16(struct)
+btDefaultMotionState : public btMotionState
+{
+	btTransform m_graphicsWorldTrans;
+	btTransform m_centerOfMassOffset;
+	btTransform m_startWorldTrans;
+	void* m_userPointer;
+
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+	btDefaultMotionState(const btTransform& startTrans = btTransform::getIdentity(), const btTransform& centerOfMassOffset = btTransform::getIdentity())
+		: m_graphicsWorldTrans(startTrans),
+		  m_centerOfMassOffset(centerOfMassOffset),
+		  m_startWorldTrans(startTrans),
+		  m_userPointer(0)
+
+	{
+	}
+
+	///synchronizes world transform from user to physics
+	virtual void getWorldTransform(btTransform & centerOfMassWorldTrans) const
+	{
+		centerOfMassWorldTrans = m_graphicsWorldTrans * m_centerOfMassOffset.inverse();
+	}
+
+	///synchronizes world transform from physics to user
+	///Bullet only calls the update of worldtransform for active objects
+	virtual void setWorldTransform(const btTransform& centerOfMassWorldTrans)
+	{
+		m_graphicsWorldTrans = centerOfMassWorldTrans * m_centerOfMassOffset;
+	}
+};
+
+#endif  //BT_DEFAULT_MOTION_STATE_H
diff --git a/engine/inc/bullet/LinearMath/btGeometryUtil.h b/engine/inc/bullet/LinearMath/btGeometryUtil.h
new file mode 100644
index 00000000..0ce5b76d
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btGeometryUtil.h
@@ -0,0 +1,36 @@
+/*
+Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_GEOMETRY_UTIL_H
+#define BT_GEOMETRY_UTIL_H
+
+#include "btVector3.h"
+#include "btAlignedObjectArray.h"
+
+///The btGeometryUtil helper class provides a few methods to convert between plane equations and vertices.
+class btGeometryUtil
+{
+public:
+	static void getPlaneEquationsFromVertices(btAlignedObjectArray<btVector3>& vertices, btAlignedObjectArray<btVector3>& planeEquationsOut);
+
+	static void getVerticesFromPlaneEquations(const btAlignedObjectArray<btVector3>& planeEquations, btAlignedObjectArray<btVector3>& verticesOut);
+
+	static bool isInside(const btAlignedObjectArray<btVector3>& vertices, const btVector3& planeNormal, btScalar margin);
+
+	static bool isPointInsidePlanes(const btAlignedObjectArray<btVector3>& planeEquations, const btVector3& point, btScalar margin);
+
+	static bool areVerticesBehindPlane(const btVector3& planeNormal, const btAlignedObjectArray<btVector3>& vertices, btScalar margin);
+};
+
+#endif  //BT_GEOMETRY_UTIL_H
diff --git a/engine/inc/bullet/LinearMath/btGrahamScan2dConvexHull.h b/engine/inc/bullet/LinearMath/btGrahamScan2dConvexHull.h
new file mode 100644
index 00000000..0fcb2859
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btGrahamScan2dConvexHull.h
@@ -0,0 +1,129 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2011 Advanced Micro Devices, Inc.  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef GRAHAM_SCAN_2D_CONVEX_HULL_H
+#define GRAHAM_SCAN_2D_CONVEX_HULL_H
+
+#include "btVector3.h"
+#include "btAlignedObjectArray.h"
+
+struct GrahamVector3 : public btVector3
+{
+	GrahamVector3(const btVector3& org, int orgIndex)
+		: btVector3(org),
+		  m_orgIndex(orgIndex)
+	{
+	}
+	btScalar m_angle;
+	int m_orgIndex;
+};
+
+struct btAngleCompareFunc
+{
+	btVector3 m_anchor;
+	btAngleCompareFunc(const btVector3& anchor)
+		: m_anchor(anchor)
+	{
+	}
+	bool operator()(const GrahamVector3& a, const GrahamVector3& b) const
+	{
+		if (a.m_angle != b.m_angle)
+			return a.m_angle < b.m_angle;
+		else
+		{
+			btScalar al = (a - m_anchor).length2();
+			btScalar bl = (b - m_anchor).length2();
+			if (al != bl)
+				return al < bl;
+			else
+			{
+				return a.m_orgIndex < b.m_orgIndex;
+			}
+		}
+	}
+};
+
+inline void GrahamScanConvexHull2D(btAlignedObjectArray<GrahamVector3>& originalPoints, btAlignedObjectArray<GrahamVector3>& hull, const btVector3& normalAxis)
+{
+	btVector3 axis0, axis1;
+	btPlaneSpace1(normalAxis, axis0, axis1);
+
+	if (originalPoints.size() <= 1)
+	{
+		for (int i = 0; i < originalPoints.size(); i++)
+			hull.push_back(originalPoints[0]);
+		return;
+	}
+	//step1 : find anchor point with smallest projection on axis0 and move it to first location
+	for (int i = 0; i < originalPoints.size(); i++)
+	{
+		//		const btVector3& left = originalPoints[i];
+		//		const btVector3& right = originalPoints[0];
+		btScalar projL = originalPoints[i].dot(axis0);
+		btScalar projR = originalPoints[0].dot(axis0);
+		if (projL < projR)
+		{
+			originalPoints.swap(0, i);
+		}
+	}
+
+	//also precompute angles
+	originalPoints[0].m_angle = -1e30f;
+	for (int i = 1; i < originalPoints.size(); i++)
+	{
+		btVector3 ar = originalPoints[i] - originalPoints[0];
+		btScalar ar1 = axis1.dot(ar);
+		btScalar ar0 = axis0.dot(ar);
+		if (ar1 * ar1 + ar0 * ar0 < FLT_EPSILON)
+		{
+			originalPoints[i].m_angle = 0.0f;
+		}
+		else
+		{
+			originalPoints[i].m_angle = btAtan2Fast(ar1, ar0);
+		}
+	}
+
+	//step 2: sort all points, based on 'angle' with this anchor
+	btAngleCompareFunc comp(originalPoints[0]);
+	originalPoints.quickSortInternal(comp, 1, originalPoints.size() - 1);
+
+	int i;
+	for (i = 0; i < 2; i++)
+		hull.push_back(originalPoints[i]);
+
+	//step 3: keep all 'convex' points and discard concave points (using back tracking)
+	for (; i != originalPoints.size(); i++)
+	{
+		bool isConvex = false;
+		while (!isConvex && hull.size() > 1)
+		{
+			btVector3& a = hull[hull.size() - 2];
+			btVector3& b = hull[hull.size() - 1];
+			isConvex = btCross(a - b, a - originalPoints[i]).dot(normalAxis) > 0;
+			if (!isConvex)
+				hull.pop_back();
+			else
+				hull.push_back(originalPoints[i]);
+		}
+
+		if (hull.size() == 1)
+		{
+			hull.push_back(originalPoints[i]);
+		}
+	}
+}
+
+#endif  //GRAHAM_SCAN_2D_CONVEX_HULL_H
diff --git a/engine/inc/bullet/LinearMath/btHashMap.h b/engine/inc/bullet/LinearMath/btHashMap.h
new file mode 100644
index 00000000..1fca0fb7
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btHashMap.h
@@ -0,0 +1,470 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_HASH_MAP_H
+#define BT_HASH_MAP_H
+
+#include <string>
+#include "btAlignedObjectArray.h"
+
+///very basic hashable string implementation, compatible with btHashMap
+struct btHashString
+{
+	std::string m_string1;
+	unsigned int m_hash;
+
+	SIMD_FORCE_INLINE unsigned int getHash() const
+	{
+		return m_hash;
+	}
+
+	btHashString()
+	{
+		m_string1 = "";
+		m_hash = 0;
+	}
+	btHashString(const char* name)
+		: m_string1(name)
+	{
+		/* magic numbers from http://www.isthe.com/chongo/tech/comp/fnv/ */
+		static const unsigned int InitialFNV = 2166136261u;
+		static const unsigned int FNVMultiple = 16777619u;
+
+		/* Fowler / Noll / Vo (FNV) Hash */
+		unsigned int hash = InitialFNV;
+
+		for (int i = 0; m_string1.c_str()[i]; i++)
+		{
+			hash = hash ^ (m_string1.c_str()[i]); /* xor  the low 8 bits */
+			hash = hash * FNVMultiple;            /* multiply by the magic number */
+		}
+		m_hash = hash;
+	}
+
+	bool equals(const btHashString& other) const
+	{
+		return (m_string1 == other.m_string1);
+	}
+};
+
+const int BT_HASH_NULL = 0xffffffff;
+
+class btHashInt
+{
+	int m_uid;
+
+public:
+	btHashInt()
+	{
+	}
+
+	btHashInt(int uid) : m_uid(uid)
+	{
+	}
+
+	int getUid1() const
+	{
+		return m_uid;
+	}
+
+	void setUid1(int uid)
+	{
+		m_uid = uid;
+	}
+
+	bool equals(const btHashInt& other) const
+	{
+		return getUid1() == other.getUid1();
+	}
+	//to our success
+	SIMD_FORCE_INLINE unsigned int getHash() const
+	{
+		unsigned int key = m_uid;
+		// Thomas Wang's hash
+		key += ~(key << 15);
+		key ^= (key >> 10);
+		key += (key << 3);
+		key ^= (key >> 6);
+		key += ~(key << 11);
+		key ^= (key >> 16);
+
+		return key;
+	}
+};
+
+class btHashPtr
+{
+	union {
+		const void* m_pointer;
+		unsigned int m_hashValues[2];
+	};
+
+public:
+	btHashPtr(const void* ptr)
+		: m_pointer(ptr)
+	{
+	}
+
+	const void* getPointer() const
+	{
+		return m_pointer;
+	}
+
+	bool equals(const btHashPtr& other) const
+	{
+		return getPointer() == other.getPointer();
+	}
+
+	//to our success
+	SIMD_FORCE_INLINE unsigned int getHash() const
+	{
+		const bool VOID_IS_8 = ((sizeof(void*) == 8));
+
+		unsigned int key = VOID_IS_8 ? m_hashValues[0] + m_hashValues[1] : m_hashValues[0];
+		// Thomas Wang's hash
+		key += ~(key << 15);
+		key ^= (key >> 10);
+		key += (key << 3);
+		key ^= (key >> 6);
+		key += ~(key << 11);
+		key ^= (key >> 16);
+		return key;
+	}
+};
+
+template <class Value>
+class btHashKeyPtr
+{
+	int m_uid;
+
+public:
+	btHashKeyPtr(int uid) : m_uid(uid)
+	{
+	}
+
+	int getUid1() const
+	{
+		return m_uid;
+	}
+
+	bool equals(const btHashKeyPtr<Value>& other) const
+	{
+		return getUid1() == other.getUid1();
+	}
+
+	//to our success
+	SIMD_FORCE_INLINE unsigned int getHash() const
+	{
+		unsigned int key = m_uid;
+		// Thomas Wang's hash
+		key += ~(key << 15);
+		key ^= (key >> 10);
+		key += (key << 3);
+		key ^= (key >> 6);
+		key += ~(key << 11);
+		key ^= (key >> 16);
+		return key;
+	}
+};
+
+template <class Value>
+class btHashKey
+{
+	int m_uid;
+
+public:
+	btHashKey(int uid) : m_uid(uid)
+	{
+	}
+
+	int getUid1() const
+	{
+		return m_uid;
+	}
+
+	bool equals(const btHashKey<Value>& other) const
+	{
+		return getUid1() == other.getUid1();
+	}
+	//to our success
+	SIMD_FORCE_INLINE unsigned int getHash() const
+	{
+		unsigned int key = m_uid;
+		// Thomas Wang's hash
+		key += ~(key << 15);
+		key ^= (key >> 10);
+		key += (key << 3);
+		key ^= (key >> 6);
+		key += ~(key << 11);
+		key ^= (key >> 16);
+		return key;
+	}
+};
+
+///The btHashMap template class implements a generic and lightweight hashmap.
+///A basic sample of how to use btHashMap is located in Demos\BasicDemo\main.cpp
+template <class Key, class Value>
+class btHashMap
+{
+protected:
+	btAlignedObjectArray<int> m_hashTable;
+	btAlignedObjectArray<int> m_next;
+
+	btAlignedObjectArray<Value> m_valueArray;
+	btAlignedObjectArray<Key> m_keyArray;
+
+	void growTables(const Key& /*key*/)
+	{
+		int newCapacity = m_valueArray.capacity();
+
+		if (m_hashTable.size() < newCapacity)
+		{
+			//grow hashtable and next table
+			int curHashtableSize = m_hashTable.size();
+
+			m_hashTable.resize(newCapacity);
+			m_next.resize(newCapacity);
+
+			int i;
+
+			for (i = 0; i < newCapacity; ++i)
+			{
+				m_hashTable[i] = BT_HASH_NULL;
+			}
+			for (i = 0; i < newCapacity; ++i)
+			{
+				m_next[i] = BT_HASH_NULL;
+			}
+
+			for (i = 0; i < curHashtableSize; i++)
+			{
+				//const Value& value = m_valueArray[i];
+				//const Key& key = m_keyArray[i];
+
+				int hashValue = m_keyArray[i].getHash() & (m_valueArray.capacity() - 1);  // New hash value with new mask
+				m_next[i] = m_hashTable[hashValue];
+				m_hashTable[hashValue] = i;
+			}
+		}
+	}
+
+public:
+	void insert(const Key& key, const Value& value)
+	{
+		int hash = key.getHash() & (m_valueArray.capacity() - 1);
+
+		//replace value if the key is already there
+		int index = findIndex(key);
+		if (index != BT_HASH_NULL)
+		{
+			m_valueArray[index] = value;
+			return;
+		}
+
+		int count = m_valueArray.size();
+		int oldCapacity = m_valueArray.capacity();
+		m_valueArray.push_back(value);
+		m_keyArray.push_back(key);
+
+		int newCapacity = m_valueArray.capacity();
+		if (oldCapacity < newCapacity)
+		{
+			growTables(key);
+			//hash with new capacity
+			hash = key.getHash() & (m_valueArray.capacity() - 1);
+		}
+		m_next[count] = m_hashTable[hash];
+		m_hashTable[hash] = count;
+	}
+
+	void remove(const Key& key)
+	{
+		int hash = key.getHash() & (m_valueArray.capacity() - 1);
+
+		int pairIndex = findIndex(key);
+
+		if (pairIndex == BT_HASH_NULL)
+		{
+			return;
+		}
+
+		// Remove the pair from the hash table.
+		int index = m_hashTable[hash];
+		btAssert(index != BT_HASH_NULL);
+
+		int previous = BT_HASH_NULL;
+		while (index != pairIndex)
+		{
+			previous = index;
+			index = m_next[index];
+		}
+
+		if (previous != BT_HASH_NULL)
+		{
+			btAssert(m_next[previous] == pairIndex);
+			m_next[previous] = m_next[pairIndex];
+		}
+		else
+		{
+			m_hashTable[hash] = m_next[pairIndex];
+		}
+
+		// We now move the last pair into spot of the
+		// pair being removed. We need to fix the hash
+		// table indices to support the move.
+
+		int lastPairIndex = m_valueArray.size() - 1;
+
+		// If the removed pair is the last pair, we are done.
+		if (lastPairIndex == pairIndex)
+		{
+			m_valueArray.pop_back();
+			m_keyArray.pop_back();
+			return;
+		}
+
+		// Remove the last pair from the hash table.
+		int lastHash = m_keyArray[lastPairIndex].getHash() & (m_valueArray.capacity() - 1);
+
+		index = m_hashTable[lastHash];
+		btAssert(index != BT_HASH_NULL);
+
+		previous = BT_HASH_NULL;
+		while (index != lastPairIndex)
+		{
+			previous = index;
+			index = m_next[index];
+		}
+
+		if (previous != BT_HASH_NULL)
+		{
+			btAssert(m_next[previous] == lastPairIndex);
+			m_next[previous] = m_next[lastPairIndex];
+		}
+		else
+		{
+			m_hashTable[lastHash] = m_next[lastPairIndex];
+		}
+
+		// Copy the last pair into the remove pair's spot.
+		m_valueArray[pairIndex] = m_valueArray[lastPairIndex];
+		m_keyArray[pairIndex] = m_keyArray[lastPairIndex];
+
+		// Insert the last pair into the hash table
+		m_next[pairIndex] = m_hashTable[lastHash];
+		m_hashTable[lastHash] = pairIndex;
+
+		m_valueArray.pop_back();
+		m_keyArray.pop_back();
+	}
+
+	int size() const
+	{
+		return m_valueArray.size();
+	}
+
+	const Value* getAtIndex(int index) const
+	{
+		btAssert(index < m_valueArray.size());
+		btAssert(index >= 0);
+		if (index >= 0 && index < m_valueArray.size())
+		{
+			return &m_valueArray[index];
+		}
+		return 0;
+	}
+
+	Value* getAtIndex(int index)
+	{
+		btAssert(index < m_valueArray.size());
+		btAssert(index >= 0);
+		if (index >= 0 && index < m_valueArray.size())
+		{
+			return &m_valueArray[index];
+		}
+		return 0;
+	}
+
+	Key getKeyAtIndex(int index)
+	{
+		btAssert(index < m_keyArray.size());
+		btAssert(index >= 0);
+		return m_keyArray[index];
+	}
+
+	const Key getKeyAtIndex(int index) const
+	{
+		btAssert(index < m_keyArray.size());
+		btAssert(index >= 0);
+		return m_keyArray[index];
+	}
+
+	Value* operator[](const Key& key)
+	{
+		return find(key);
+	}
+
+	const Value* operator[](const Key& key) const
+	{
+		return find(key);
+	}
+
+	const Value* find(const Key& key) const
+	{
+		int index = findIndex(key);
+		if (index == BT_HASH_NULL)
+		{
+			return NULL;
+		}
+		return &m_valueArray[index];
+	}
+
+	Value* find(const Key& key)
+	{
+		int index = findIndex(key);
+		if (index == BT_HASH_NULL)
+		{
+			return NULL;
+		}
+		return &m_valueArray[index];
+	}
+
+	int findIndex(const Key& key) const
+	{
+		unsigned int hash = key.getHash() & (m_valueArray.capacity() - 1);
+
+		if (hash >= (unsigned int)m_hashTable.size())
+		{
+			return BT_HASH_NULL;
+		}
+
+		int index = m_hashTable[hash];
+		while ((index != BT_HASH_NULL) && key.equals(m_keyArray[index]) == false)
+		{
+			index = m_next[index];
+		}
+		return index;
+	}
+
+	void clear()
+	{
+		m_hashTable.clear();
+		m_next.clear();
+		m_valueArray.clear();
+		m_keyArray.clear();
+	}
+};
+
+#endif  //BT_HASH_MAP_H
diff --git a/engine/inc/bullet/LinearMath/btIDebugDraw.h b/engine/inc/bullet/LinearMath/btIDebugDraw.h
new file mode 100644
index 00000000..82ec19a6
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btIDebugDraw.h
@@ -0,0 +1,473 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_IDEBUG_DRAW__H
+#define BT_IDEBUG_DRAW__H
+
+#include "btVector3.h"
+#include "btTransform.h"
+
+///The btIDebugDraw interface class allows hooking up a debug renderer to visually debug simulations.
+///Typical use case: create a debug drawer object, and assign it to a btCollisionWorld or btDynamicsWorld using setDebugDrawer and call debugDrawWorld.
+///A class that implements the btIDebugDraw interface has to implement the drawLine method at a minimum.
+///For color arguments the X,Y,Z components refer to Red, Green and Blue each in the range [0..1]
+class btIDebugDraw
+{
+public:
+	ATTRIBUTE_ALIGNED16(struct)
+	DefaultColors
+	{
+		btVector3 m_activeObject;
+		btVector3 m_deactivatedObject;
+		btVector3 m_wantsDeactivationObject;
+		btVector3 m_disabledDeactivationObject;
+		btVector3 m_disabledSimulationObject;
+		btVector3 m_aabb;
+		btVector3 m_contactPoint;
+
+		DefaultColors()
+			: m_activeObject(1, 1, 1),
+			  m_deactivatedObject(0, 1, 0),
+			  m_wantsDeactivationObject(0, 1, 1),
+			  m_disabledDeactivationObject(1, 0, 0),
+			  m_disabledSimulationObject(1, 1, 0),
+			  m_aabb(1, 0, 0),
+			  m_contactPoint(1, 1, 0)
+		{
+		}
+	};
+
+	enum DebugDrawModes
+	{
+		DBG_NoDebug = 0,
+		DBG_DrawWireframe = 1,
+		DBG_DrawAabb = 2,
+		DBG_DrawFeaturesText = 4,
+		DBG_DrawContactPoints = 8,
+		DBG_NoDeactivation = 16,
+		DBG_NoHelpText = 32,
+		DBG_DrawText = 64,
+		DBG_ProfileTimings = 128,
+		DBG_EnableSatComparison = 256,
+		DBG_DisableBulletLCP = 512,
+		DBG_EnableCCD = 1024,
+		DBG_DrawConstraints = (1 << 11),
+		DBG_DrawConstraintLimits = (1 << 12),
+		DBG_FastWireframe = (1 << 13),
+		DBG_DrawNormals = (1 << 14),
+		DBG_DrawFrames = (1 << 15),
+		DBG_MAX_DEBUG_DRAW_MODE
+	};
+
+	virtual ~btIDebugDraw(){};
+
+	virtual DefaultColors getDefaultColors() const
+	{
+		DefaultColors colors;
+		return colors;
+	}
+	///the default implementation for setDefaultColors has no effect. A derived class can implement it and store the colors.
+	virtual void setDefaultColors(const DefaultColors& /*colors*/) {}
+
+	virtual void drawLine(const btVector3& from, const btVector3& to, const btVector3& color) = 0;
+
+	virtual void drawLine(const btVector3& from, const btVector3& to, const btVector3& fromColor, const btVector3& toColor)
+	{
+		(void)toColor;
+		drawLine(from, to, fromColor);
+	}
+
+	virtual void drawSphere(btScalar radius, const btTransform& transform, const btVector3& color)
+	{
+		btVector3 center = transform.getOrigin();
+		btVector3 up = transform.getBasis().getColumn(1);
+		btVector3 axis = transform.getBasis().getColumn(0);
+		btScalar minTh = -SIMD_HALF_PI;
+		btScalar maxTh = SIMD_HALF_PI;
+		btScalar minPs = -SIMD_HALF_PI;
+		btScalar maxPs = SIMD_HALF_PI;
+		btScalar stepDegrees = 30.f;
+		drawSpherePatch(center, up, axis, radius, minTh, maxTh, minPs, maxPs, color, stepDegrees, false);
+		drawSpherePatch(center, up, -axis, radius, minTh, maxTh, minPs, maxPs, color, stepDegrees, false);
+	}
+
+	virtual void drawSphere(const btVector3& p, btScalar radius, const btVector3& color)
+	{
+		btTransform tr;
+		tr.setIdentity();
+		tr.setOrigin(p);
+		drawSphere(radius, tr, color);
+	}
+
+	virtual void drawTriangle(const btVector3& v0, const btVector3& v1, const btVector3& v2, const btVector3& /*n0*/, const btVector3& /*n1*/, const btVector3& /*n2*/, const btVector3& color, btScalar alpha)
+	{
+		drawTriangle(v0, v1, v2, color, alpha);
+	}
+	virtual void drawTriangle(const btVector3& v0, const btVector3& v1, const btVector3& v2, const btVector3& color, btScalar /*alpha*/)
+	{
+		drawLine(v0, v1, color);
+		drawLine(v1, v2, color);
+		drawLine(v2, v0, color);
+	}
+
+	virtual void drawContactPoint(const btVector3& PointOnB, const btVector3& normalOnB, btScalar distance, int lifeTime, const btVector3& color) = 0;
+
+	virtual void reportErrorWarning(const char* warningString) = 0;
+
+	virtual void draw3dText(const btVector3& location, const char* textString) = 0;
+
+	virtual void setDebugMode(int debugMode) = 0;
+
+	virtual int getDebugMode() const = 0;
+
+	virtual void drawAabb(const btVector3& from, const btVector3& to, const btVector3& color)
+	{
+		btVector3 halfExtents = (to - from) * 0.5f;
+		btVector3 center = (to + from) * 0.5f;
+		int i, j;
+
+		btVector3 edgecoord(1.f, 1.f, 1.f), pa, pb;
+		for (i = 0; i < 4; i++)
+		{
+			for (j = 0; j < 3; j++)
+			{
+				pa = btVector3(edgecoord[0] * halfExtents[0], edgecoord[1] * halfExtents[1],
+							   edgecoord[2] * halfExtents[2]);
+				pa += center;
+
+				int othercoord = j % 3;
+				edgecoord[othercoord] *= -1.f;
+				pb = btVector3(edgecoord[0] * halfExtents[0], edgecoord[1] * halfExtents[1],
+							   edgecoord[2] * halfExtents[2]);
+				pb += center;
+
+				drawLine(pa, pb, color);
+			}
+			edgecoord = btVector3(-1.f, -1.f, -1.f);
+			if (i < 3)
+				edgecoord[i] *= -1.f;
+		}
+	}
+	virtual void drawTransform(const btTransform& transform, btScalar orthoLen)
+	{
+		btVector3 start = transform.getOrigin();
+		drawLine(start, start + transform.getBasis() * btVector3(orthoLen, 0, 0), btVector3(btScalar(1.), btScalar(0.3), btScalar(0.3)));
+		drawLine(start, start + transform.getBasis() * btVector3(0, orthoLen, 0), btVector3(btScalar(0.3), btScalar(1.), btScalar(0.3)));
+		drawLine(start, start + transform.getBasis() * btVector3(0, 0, orthoLen), btVector3(btScalar(0.3), btScalar(0.3), btScalar(1.)));
+	}
+
+	virtual void drawArc(const btVector3& center, const btVector3& normal, const btVector3& axis, btScalar radiusA, btScalar radiusB, btScalar minAngle, btScalar maxAngle,
+						 const btVector3& color, bool drawSect, btScalar stepDegrees = btScalar(10.f))
+	{
+		const btVector3& vx = axis;
+		btVector3 vy = normal.cross(axis);
+		btScalar step = stepDegrees * SIMD_RADS_PER_DEG;
+		int nSteps = (int)btFabs((maxAngle - minAngle) / step);
+		if (!nSteps) nSteps = 1;
+		btVector3 prev = center + radiusA * vx * btCos(minAngle) + radiusB * vy * btSin(minAngle);
+		if (drawSect)
+		{
+			drawLine(center, prev, color);
+		}
+		for (int i = 1; i <= nSteps; i++)
+		{
+			btScalar angle = minAngle + (maxAngle - minAngle) * btScalar(i) / btScalar(nSteps);
+			btVector3 next = center + radiusA * vx * btCos(angle) + radiusB * vy * btSin(angle);
+			drawLine(prev, next, color);
+			prev = next;
+		}
+		if (drawSect)
+		{
+			drawLine(center, prev, color);
+		}
+	}
+	virtual void drawSpherePatch(const btVector3& center, const btVector3& up, const btVector3& axis, btScalar radius,
+								 btScalar minTh, btScalar maxTh, btScalar minPs, btScalar maxPs, const btVector3& color, btScalar stepDegrees = btScalar(10.f), bool drawCenter = true)
+	{
+		btVector3 vA[74];
+		btVector3 vB[74];
+		btVector3 *pvA = vA, *pvB = vB, *pT;
+		btVector3 npole = center + up * radius;
+		btVector3 spole = center - up * radius;
+		btVector3 arcStart;
+		btScalar step = stepDegrees * SIMD_RADS_PER_DEG;
+		const btVector3& kv = up;
+		const btVector3& iv = axis;
+		btVector3 jv = kv.cross(iv);
+		bool drawN = false;
+		bool drawS = false;
+		if (minTh <= -SIMD_HALF_PI)
+		{
+			minTh = -SIMD_HALF_PI + step;
+			drawN = true;
+		}
+		if (maxTh >= SIMD_HALF_PI)
+		{
+			maxTh = SIMD_HALF_PI - step;
+			drawS = true;
+		}
+		if (minTh > maxTh)
+		{
+			minTh = -SIMD_HALF_PI + step;
+			maxTh = SIMD_HALF_PI - step;
+			drawN = drawS = true;
+		}
+		int n_hor = (int)((maxTh - minTh) / step) + 1;
+		if (n_hor < 2) n_hor = 2;
+		btScalar step_h = (maxTh - minTh) / btScalar(n_hor - 1);
+		bool isClosed = false;
+		if (minPs > maxPs)
+		{
+			minPs = -SIMD_PI + step;
+			maxPs = SIMD_PI;
+			isClosed = true;
+		}
+		else if ((maxPs - minPs) >= SIMD_PI * btScalar(2.f))
+		{
+			isClosed = true;
+		}
+		else
+		{
+			isClosed = false;
+		}
+		int n_vert = (int)((maxPs - minPs) / step) + 1;
+		if (n_vert < 2) n_vert = 2;
+		btScalar step_v = (maxPs - minPs) / btScalar(n_vert - 1);
+		for (int i = 0; i < n_hor; i++)
+		{
+			btScalar th = minTh + btScalar(i) * step_h;
+			btScalar sth = radius * btSin(th);
+			btScalar cth = radius * btCos(th);
+			for (int j = 0; j < n_vert; j++)
+			{
+				btScalar psi = minPs + btScalar(j) * step_v;
+				btScalar sps = btSin(psi);
+				btScalar cps = btCos(psi);
+				pvB[j] = center + cth * cps * iv + cth * sps * jv + sth * kv;
+				if (i)
+				{
+					drawLine(pvA[j], pvB[j], color);
+				}
+				else if (drawS)
+				{
+					drawLine(spole, pvB[j], color);
+				}
+				if (j)
+				{
+					drawLine(pvB[j - 1], pvB[j], color);
+				}
+				else
+				{
+					arcStart = pvB[j];
+				}
+				if ((i == (n_hor - 1)) && drawN)
+				{
+					drawLine(npole, pvB[j], color);
+				}
+
+				if (drawCenter)
+				{
+					if (isClosed)
+					{
+						if (j == (n_vert - 1))
+						{
+							drawLine(arcStart, pvB[j], color);
+						}
+					}
+					else
+					{
+						if (((!i) || (i == (n_hor - 1))) && ((!j) || (j == (n_vert - 1))))
+						{
+							drawLine(center, pvB[j], color);
+						}
+					}
+				}
+			}
+			pT = pvA;
+			pvA = pvB;
+			pvB = pT;
+		}
+	}
+
+	virtual void drawBox(const btVector3& bbMin, const btVector3& bbMax, const btVector3& color)
+	{
+		drawLine(btVector3(bbMin[0], bbMin[1], bbMin[2]), btVector3(bbMax[0], bbMin[1], bbMin[2]), color);
+		drawLine(btVector3(bbMax[0], bbMin[1], bbMin[2]), btVector3(bbMax[0], bbMax[1], bbMin[2]), color);
+		drawLine(btVector3(bbMax[0], bbMax[1], bbMin[2]), btVector3(bbMin[0], bbMax[1], bbMin[2]), color);
+		drawLine(btVector3(bbMin[0], bbMax[1], bbMin[2]), btVector3(bbMin[0], bbMin[1], bbMin[2]), color);
+		drawLine(btVector3(bbMin[0], bbMin[1], bbMin[2]), btVector3(bbMin[0], bbMin[1], bbMax[2]), color);
+		drawLine(btVector3(bbMax[0], bbMin[1], bbMin[2]), btVector3(bbMax[0], bbMin[1], bbMax[2]), color);
+		drawLine(btVector3(bbMax[0], bbMax[1], bbMin[2]), btVector3(bbMax[0], bbMax[1], bbMax[2]), color);
+		drawLine(btVector3(bbMin[0], bbMax[1], bbMin[2]), btVector3(bbMin[0], bbMax[1], bbMax[2]), color);
+		drawLine(btVector3(bbMin[0], bbMin[1], bbMax[2]), btVector3(bbMax[0], bbMin[1], bbMax[2]), color);
+		drawLine(btVector3(bbMax[0], bbMin[1], bbMax[2]), btVector3(bbMax[0], bbMax[1], bbMax[2]), color);
+		drawLine(btVector3(bbMax[0], bbMax[1], bbMax[2]), btVector3(bbMin[0], bbMax[1], bbMax[2]), color);
+		drawLine(btVector3(bbMin[0], bbMax[1], bbMax[2]), btVector3(bbMin[0], bbMin[1], bbMax[2]), color);
+	}
+	virtual void drawBox(const btVector3& bbMin, const btVector3& bbMax, const btTransform& trans, const btVector3& color)
+	{
+		drawLine(trans * btVector3(bbMin[0], bbMin[1], bbMin[2]), trans * btVector3(bbMax[0], bbMin[1], bbMin[2]), color);
+		drawLine(trans * btVector3(bbMax[0], bbMin[1], bbMin[2]), trans * btVector3(bbMax[0], bbMax[1], bbMin[2]), color);
+		drawLine(trans * btVector3(bbMax[0], bbMax[1], bbMin[2]), trans * btVector3(bbMin[0], bbMax[1], bbMin[2]), color);
+		drawLine(trans * btVector3(bbMin[0], bbMax[1], bbMin[2]), trans * btVector3(bbMin[0], bbMin[1], bbMin[2]), color);
+		drawLine(trans * btVector3(bbMin[0], bbMin[1], bbMin[2]), trans * btVector3(bbMin[0], bbMin[1], bbMax[2]), color);
+		drawLine(trans * btVector3(bbMax[0], bbMin[1], bbMin[2]), trans * btVector3(bbMax[0], bbMin[1], bbMax[2]), color);
+		drawLine(trans * btVector3(bbMax[0], bbMax[1], bbMin[2]), trans * btVector3(bbMax[0], bbMax[1], bbMax[2]), color);
+		drawLine(trans * btVector3(bbMin[0], bbMax[1], bbMin[2]), trans * btVector3(bbMin[0], bbMax[1], bbMax[2]), color);
+		drawLine(trans * btVector3(bbMin[0], bbMin[1], bbMax[2]), trans * btVector3(bbMax[0], bbMin[1], bbMax[2]), color);
+		drawLine(trans * btVector3(bbMax[0], bbMin[1], bbMax[2]), trans * btVector3(bbMax[0], bbMax[1], bbMax[2]), color);
+		drawLine(trans * btVector3(bbMax[0], bbMax[1], bbMax[2]), trans * btVector3(bbMin[0], bbMax[1], bbMax[2]), color);
+		drawLine(trans * btVector3(bbMin[0], bbMax[1], bbMax[2]), trans * btVector3(bbMin[0], bbMin[1], bbMax[2]), color);
+	}
+
+	virtual void drawCapsule(btScalar radius, btScalar halfHeight, int upAxis, const btTransform& transform, const btVector3& color)
+	{
+		int stepDegrees = 30;
+
+		btVector3 capStart(0.f, 0.f, 0.f);
+		capStart[upAxis] = -halfHeight;
+
+		btVector3 capEnd(0.f, 0.f, 0.f);
+		capEnd[upAxis] = halfHeight;
+
+		// Draw the ends
+		{
+			btTransform childTransform = transform;
+			childTransform.getOrigin() = transform * capStart;
+			{
+				btVector3 center = childTransform.getOrigin();
+				btVector3 up = childTransform.getBasis().getColumn((upAxis + 1) % 3);
+				btVector3 axis = -childTransform.getBasis().getColumn(upAxis);
+				btScalar minTh = -SIMD_HALF_PI;
+				btScalar maxTh = SIMD_HALF_PI;
+				btScalar minPs = -SIMD_HALF_PI;
+				btScalar maxPs = SIMD_HALF_PI;
+
+				drawSpherePatch(center, up, axis, radius, minTh, maxTh, minPs, maxPs, color, btScalar(stepDegrees), false);
+			}
+		}
+
+		{
+			btTransform childTransform = transform;
+			childTransform.getOrigin() = transform * capEnd;
+			{
+				btVector3 center = childTransform.getOrigin();
+				btVector3 up = childTransform.getBasis().getColumn((upAxis + 1) % 3);
+				btVector3 axis = childTransform.getBasis().getColumn(upAxis);
+				btScalar minTh = -SIMD_HALF_PI;
+				btScalar maxTh = SIMD_HALF_PI;
+				btScalar minPs = -SIMD_HALF_PI;
+				btScalar maxPs = SIMD_HALF_PI;
+				drawSpherePatch(center, up, axis, radius, minTh, maxTh, minPs, maxPs, color, btScalar(stepDegrees), false);
+			}
+		}
+
+		// Draw some additional lines
+		btVector3 start = transform.getOrigin();
+
+		for (int i = 0; i < 360; i += stepDegrees)
+		{
+			capEnd[(upAxis + 1) % 3] = capStart[(upAxis + 1) % 3] = btSin(btScalar(i) * SIMD_RADS_PER_DEG) * radius;
+			capEnd[(upAxis + 2) % 3] = capStart[(upAxis + 2) % 3] = btCos(btScalar(i) * SIMD_RADS_PER_DEG) * radius;
+			drawLine(start + transform.getBasis() * capStart, start + transform.getBasis() * capEnd, color);
+		}
+	}
+
+	virtual void drawCylinder(btScalar radius, btScalar halfHeight, int upAxis, const btTransform& transform, const btVector3& color)
+	{
+		btVector3 start = transform.getOrigin();
+		btVector3 offsetHeight(0, 0, 0);
+		offsetHeight[upAxis] = halfHeight;
+		int stepDegrees = 30;
+		btVector3 capStart(0.f, 0.f, 0.f);
+		capStart[upAxis] = -halfHeight;
+		btVector3 capEnd(0.f, 0.f, 0.f);
+		capEnd[upAxis] = halfHeight;
+
+		for (int i = 0; i < 360; i += stepDegrees)
+		{
+			capEnd[(upAxis + 1) % 3] = capStart[(upAxis + 1) % 3] = btSin(btScalar(i) * SIMD_RADS_PER_DEG) * radius;
+			capEnd[(upAxis + 2) % 3] = capStart[(upAxis + 2) % 3] = btCos(btScalar(i) * SIMD_RADS_PER_DEG) * radius;
+			drawLine(start + transform.getBasis() * capStart, start + transform.getBasis() * capEnd, color);
+		}
+		// Drawing top and bottom caps of the cylinder
+		btVector3 yaxis(0, 0, 0);
+		yaxis[upAxis] = btScalar(1.0);
+		btVector3 xaxis(0, 0, 0);
+		xaxis[(upAxis + 1) % 3] = btScalar(1.0);
+		drawArc(start - transform.getBasis() * (offsetHeight), transform.getBasis() * yaxis, transform.getBasis() * xaxis, radius, radius, 0, SIMD_2_PI, color, false, btScalar(10.0));
+		drawArc(start + transform.getBasis() * (offsetHeight), transform.getBasis() * yaxis, transform.getBasis() * xaxis, radius, radius, 0, SIMD_2_PI, color, false, btScalar(10.0));
+	}
+
+	virtual void drawCone(btScalar radius, btScalar height, int upAxis, const btTransform& transform, const btVector3& color)
+	{
+		int stepDegrees = 30;
+		btVector3 start = transform.getOrigin();
+
+		btVector3 offsetHeight(0, 0, 0);
+		btScalar halfHeight = height * btScalar(0.5);
+		offsetHeight[upAxis] = halfHeight;
+		btVector3 offsetRadius(0, 0, 0);
+		offsetRadius[(upAxis + 1) % 3] = radius;
+		btVector3 offset2Radius(0, 0, 0);
+		offset2Radius[(upAxis + 2) % 3] = radius;
+
+		btVector3 capEnd(0.f, 0.f, 0.f);
+		capEnd[upAxis] = -halfHeight;
+
+		for (int i = 0; i < 360; i += stepDegrees)
+		{
+			capEnd[(upAxis + 1) % 3] = btSin(btScalar(i) * SIMD_RADS_PER_DEG) * radius;
+			capEnd[(upAxis + 2) % 3] = btCos(btScalar(i) * SIMD_RADS_PER_DEG) * radius;
+			drawLine(start + transform.getBasis() * (offsetHeight), start + transform.getBasis() * capEnd, color);
+		}
+
+		drawLine(start + transform.getBasis() * (offsetHeight), start + transform.getBasis() * (-offsetHeight + offsetRadius), color);
+		drawLine(start + transform.getBasis() * (offsetHeight), start + transform.getBasis() * (-offsetHeight - offsetRadius), color);
+		drawLine(start + transform.getBasis() * (offsetHeight), start + transform.getBasis() * (-offsetHeight + offset2Radius), color);
+		drawLine(start + transform.getBasis() * (offsetHeight), start + transform.getBasis() * (-offsetHeight - offset2Radius), color);
+
+		// Drawing the base of the cone
+		btVector3 yaxis(0, 0, 0);
+		yaxis[upAxis] = btScalar(1.0);
+		btVector3 xaxis(0, 0, 0);
+		xaxis[(upAxis + 1) % 3] = btScalar(1.0);
+		drawArc(start - transform.getBasis() * (offsetHeight), transform.getBasis() * yaxis, transform.getBasis() * xaxis, radius, radius, 0, SIMD_2_PI, color, false, 10.0);
+	}
+
+	virtual void drawPlane(const btVector3& planeNormal, btScalar planeConst, const btTransform& transform, const btVector3& color)
+	{
+		btVector3 planeOrigin = planeNormal * planeConst;
+		btVector3 vec0, vec1;
+		btPlaneSpace1(planeNormal, vec0, vec1);
+		btScalar vecLen = 100.f;
+		btVector3 pt0 = planeOrigin + vec0 * vecLen;
+		btVector3 pt1 = planeOrigin - vec0 * vecLen;
+		btVector3 pt2 = planeOrigin + vec1 * vecLen;
+		btVector3 pt3 = planeOrigin - vec1 * vecLen;
+		drawLine(transform * pt0, transform * pt1, color);
+		drawLine(transform * pt2, transform * pt3, color);
+	}
+
+	virtual void clearLines()
+	{
+	}
+
+	virtual void flushLines()
+	{
+	}
+};
+
+#endif  //BT_IDEBUG_DRAW__H
diff --git a/engine/inc/bullet/LinearMath/btImplicitQRSVD.h b/engine/inc/bullet/LinearMath/btImplicitQRSVD.h
new file mode 100644
index 00000000..aaedc964
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btImplicitQRSVD.h
@@ -0,0 +1,916 @@
+/**
+ Bullet Continuous Collision Detection and Physics Library
+ Copyright (c) 2019 Google Inc. http://bulletphysics.org
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it freely,
+ subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ 
+ Copyright (c) 2016 Theodore Gast, Chuyuan Fu, Chenfanfu Jiang, Joseph Teran
+ 
+ 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.
+ 
+ If the code is used in an article, the following paper shall be cited:
+ @techreport{qrsvd:2016,
+ title={Implicit-shifted Symmetric QR Singular Value Decomposition of 3x3 Matrices},
+ author={Gast, Theodore and Fu, Chuyuan and Jiang, Chenfanfu and Teran, Joseph},
+ year={2016},
+ institution={University of California Los Angeles}
+ }
+ 
+ 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.
+**/
+
+#ifndef btImplicitQRSVD_h
+#define btImplicitQRSVD_h
+#include <limits>
+#include "btMatrix3x3.h"
+class btMatrix2x2
+{
+public:
+    btScalar m_00, m_01, m_10, m_11;
+    btMatrix2x2(): m_00(0), m_10(0), m_01(0), m_11(0)
+    {
+    }
+    btMatrix2x2(const btMatrix2x2& other): m_00(other.m_00),m_01(other.m_01),m_10(other.m_10),m_11(other.m_11)
+    {}
+    btScalar& operator()(int i, int j)
+    {
+        if (i == 0 && j == 0)
+            return m_00;
+        if (i == 1 && j == 0)
+            return m_10;
+        if (i == 0 && j == 1)
+            return m_01;
+        if (i == 1 && j == 1)
+            return m_11;
+        btAssert(false);
+        return m_00;
+    }
+    const btScalar& operator()(int i, int j) const
+    {
+        if (i == 0 && j == 0)
+            return m_00;
+        if (i == 1 && j == 0)
+            return m_10;
+        if (i == 0 && j == 1)
+            return m_01;
+        if (i == 1 && j == 1)
+            return m_11;
+        btAssert(false);
+        return m_00;
+    }
+    void setIdentity()
+    {
+        m_00 = 1;
+        m_11 = 1;
+        m_01 = 0;
+        m_10 = 0;
+    }
+};
+
+static inline btScalar copySign(btScalar x, btScalar y) {
+    if ((x < 0 && y > 0) || (x > 0 && y < 0))
+        return -x;
+    return x;
+}
+
+/**
+ Class for givens rotation.
+ Row rotation G*A corresponds to something like
+ c -s  0
+ ( s  c  0 ) A
+ 0  0  1
+ Column rotation A G' corresponds to something like
+ c -s  0
+ A ( s  c  0 )
+ 0  0  1
+ 
+ c and s are always computed so that
+ ( c -s ) ( a )  =  ( * )
+ s  c     b       ( 0 )
+ 
+ Assume rowi<rowk.
+ */
+
+class GivensRotation {
+public:
+    int rowi;
+    int rowk;
+    btScalar c;
+    btScalar s;
+    
+    inline GivensRotation(int rowi_in, int rowk_in)
+    : rowi(rowi_in)
+    , rowk(rowk_in)
+    , c(1)
+    , s(0)
+    {
+    }
+    
+    inline GivensRotation(btScalar a, btScalar b, int rowi_in, int rowk_in)
+    : rowi(rowi_in)
+    , rowk(rowk_in)
+    {
+        compute(a, b);
+    }
+    
+    ~GivensRotation() {}
+    
+    inline void transposeInPlace()
+    {
+        s = -s;
+    }
+    
+    /**
+     Compute c and s from a and b so that
+     ( c -s ) ( a )  =  ( * )
+     s  c     b       ( 0 )
+     */
+    inline void compute(const btScalar a, const btScalar b)
+    {
+        btScalar d = a * a + b * b;
+        c = 1;
+        s = 0;
+        if (d > SIMD_EPSILON) {
+            btScalar sqrtd = btSqrt(d);
+            if (sqrtd>SIMD_EPSILON)
+            {
+              btScalar t = btScalar(1.0)/sqrtd;
+              c = a * t;
+              s = -b * t;
+            }
+        }
+    }
+    
+    /**
+     This function computes c and s so that
+     ( c -s ) ( a )  =  ( 0 )
+     s  c     b       ( * )
+     */
+    inline void computeUnconventional(const btScalar a, const btScalar b)
+    {
+        btScalar d = a * a + b * b;
+        c = 0;
+        s = 1;
+        if (d > SIMD_EPSILON) {
+            btScalar t = btScalar(1.0)/btSqrt(d);
+            s = a * t;
+            c = b * t;
+        }
+    }
+    /**
+     Fill the R with the entries of this rotation
+     */
+    inline void fill(const btMatrix3x3& R) const
+    {
+        btMatrix3x3& A = const_cast<btMatrix3x3&>(R);
+        A.setIdentity();
+        A[rowi][rowi] = c;
+        A[rowk][rowi] = -s;
+        A[rowi][rowk] = s;
+        A[rowk][rowk] = c;
+    }
+    
+    inline void fill(const btMatrix2x2& R) const
+    {
+        btMatrix2x2& A = const_cast<btMatrix2x2&>(R);
+        A(rowi,rowi) = c;
+        A(rowk,rowi) = -s;
+        A(rowi,rowk) = s;
+        A(rowk,rowk) = c;
+    }
+    
+    /**
+     This function does something like
+     c -s  0
+     ( s  c  0 ) A -> A
+     0  0  1
+     It only affects row i and row k of A.
+     */
+    inline void rowRotation(btMatrix3x3& A) const
+    {
+        for (int j = 0; j < 3; j++) {
+            btScalar tau1 = A[rowi][j];
+            btScalar tau2 = A[rowk][j];
+            A[rowi][j] = c * tau1 - s * tau2;
+            A[rowk][j] = s * tau1 + c * tau2;
+        }
+    }
+    inline void rowRotation(btMatrix2x2& A) const
+    {
+        for (int j = 0; j < 2; j++) {
+            btScalar tau1 = A(rowi,j);
+            btScalar tau2 = A(rowk,j);
+            A(rowi,j) = c * tau1 - s * tau2;
+            A(rowk,j) = s * tau1 + c * tau2;
+        }
+    }
+    
+    /**
+     This function does something like
+     c  s  0
+     A ( -s  c  0 )  -> A
+     0  0  1
+     It only affects column i and column k of A.
+     */
+    inline void columnRotation(btMatrix3x3& A) const
+    {
+        for (int j = 0; j < 3; j++) {
+            btScalar tau1 = A[j][rowi];
+            btScalar tau2 = A[j][rowk];
+            A[j][rowi] = c * tau1 - s * tau2;
+            A[j][rowk] = s * tau1 + c * tau2;
+        }
+    }
+    inline void columnRotation(btMatrix2x2& A) const
+    {
+        for (int j = 0; j < 2; j++) {
+            btScalar tau1 = A(j,rowi);
+            btScalar tau2 = A(j,rowk);
+            A(j,rowi) = c * tau1 - s * tau2;
+            A(j,rowk) = s * tau1 + c * tau2;
+        }
+    }
+    
+    /**
+     Multiply givens must be for same row and column
+     **/
+    inline void operator*=(const GivensRotation& A)
+    {
+        btScalar new_c = c * A.c - s * A.s;
+        btScalar new_s = s * A.c + c * A.s;
+        c = new_c;
+        s = new_s;
+    }
+    
+    /**
+     Multiply givens must be for same row and column
+     **/
+    inline GivensRotation operator*(const GivensRotation& A) const
+    {
+        GivensRotation r(*this);
+        r *= A;
+        return r;
+    }
+};
+
+/**
+ \brief zero chasing the 3X3 matrix to bidiagonal form
+ original form of H:   x x 0
+ x x x
+ 0 0 x
+ after zero chase:
+ x x 0
+ 0 x x
+ 0 0 x
+ */
+inline void zeroChase(btMatrix3x3& H, btMatrix3x3& U, btMatrix3x3& V)
+{
+    
+    /**
+     Reduce H to of form
+     x x +
+     0 x x
+     0 0 x
+     */
+    GivensRotation r1(H[0][0], H[1][0], 0, 1);
+    /**
+     Reduce H to of form
+     x x 0
+     0 x x
+     0 + x
+     Can calculate r2 without multiplying by r1 since both entries are in first two
+     rows thus no need to divide by sqrt(a^2+b^2)
+     */
+    GivensRotation r2(1, 2);
+    if (H[1][0] != 0)
+        r2.compute(H[0][0] * H[0][1] + H[1][0] * H[1][1], H[0][0] * H[0][2] + H[1][0] * H[1][2]);
+    else
+        r2.compute(H[0][1], H[0][2]);
+    
+    r1.rowRotation(H);
+    
+    /* GivensRotation<T> r2(H(0, 1), H(0, 2), 1, 2); */
+    r2.columnRotation(H);
+    r2.columnRotation(V);
+    
+    /**
+     Reduce H to of form
+     x x 0
+     0 x x
+     0 0 x
+     */
+    GivensRotation r3(H[1][1], H[2][1], 1, 2);
+    r3.rowRotation(H);
+    
+    // Save this till end for better cache coherency
+    // r1.rowRotation(u_transpose);
+    // r3.rowRotation(u_transpose);
+    r1.columnRotation(U);
+    r3.columnRotation(U);
+}
+
+/**
+ \brief make a 3X3 matrix to upper bidiagonal form
+ original form of H:   x x x
+ x x x
+ x x x
+ after zero chase:
+ x x 0
+ 0 x x
+ 0 0 x
+ */
+inline void makeUpperBidiag(btMatrix3x3& H, btMatrix3x3& U, btMatrix3x3& V)
+{
+    U.setIdentity();
+    V.setIdentity();
+    
+    /**
+     Reduce H to of form
+     x x x
+     x x x
+     0 x x
+     */
+    
+    GivensRotation r(H[1][0], H[2][0], 1, 2);
+    r.rowRotation(H);
+    // r.rowRotation(u_transpose);
+    r.columnRotation(U);
+    // zeroChase(H, u_transpose, V);
+    zeroChase(H, U, V);
+}
+
+/**
+ \brief make a 3X3 matrix to lambda shape
+ original form of H:   x x x
+ *                     x x x
+ *                     x x x
+ after :
+ *                     x 0 0
+ *                     x x 0
+ *                     x 0 x
+ */
+inline void makeLambdaShape(btMatrix3x3& H, btMatrix3x3& U, btMatrix3x3& V)
+{
+    U.setIdentity();
+    V.setIdentity();
+    
+    /**
+     Reduce H to of form
+     *                    x x 0
+     *                    x x x
+     *                    x x x
+     */
+    
+    GivensRotation r1(H[0][1], H[0][2], 1, 2);
+    r1.columnRotation(H);
+    r1.columnRotation(V);
+    
+    /**
+     Reduce H to of form
+     *                    x x 0
+     *                    x x 0
+     *                    x x x
+     */
+    
+    r1.computeUnconventional(H[1][2], H[2][2]);
+    r1.rowRotation(H);
+    r1.columnRotation(U);
+    
+    /**
+     Reduce H to of form
+     *                    x x 0
+     *                    x x 0
+     *                    x 0 x
+     */
+    
+    GivensRotation r2(H[2][0], H[2][1], 0, 1);
+    r2.columnRotation(H);
+    r2.columnRotation(V);
+    
+    /**
+     Reduce H to of form
+     *                    x 0 0
+     *                    x x 0
+     *                    x 0 x
+     */
+    r2.computeUnconventional(H[0][1], H[1][1]);
+    r2.rowRotation(H);
+    r2.columnRotation(U);
+}
+
+/**
+ \brief 2x2 polar decomposition.
+ \param[in] A matrix.
+ \param[out] R Robustly a rotation matrix.
+ \param[out] S_Sym Symmetric. Whole matrix is stored
+ 
+ Polar guarantees negative sign is on the small magnitude singular value.
+ S is guaranteed to be the closest one to identity.
+ R is guaranteed to be the closest rotation to A.
+ */
+inline void polarDecomposition(const btMatrix2x2& A,
+                   GivensRotation& R,
+                   const btMatrix2x2& S_Sym)
+{
+    btScalar a = (A(0, 0) + A(1, 1)),  b = (A(1, 0) - A(0, 1));
+    btScalar denominator = btSqrt(a*a+b*b);
+    R.c = (btScalar)1;
+    R.s = (btScalar)0;
+    if (denominator > SIMD_EPSILON) { 
+        /*
+         No need to use a tolerance here because x(0) and x(1) always have
+         smaller magnitude then denominator, therefore overflow never happens.
+         In Bullet, we use a tolerance anyway.
+         */
+        R.c = a / denominator;
+        R.s = -b / denominator;
+    }
+    btMatrix2x2& S = const_cast<btMatrix2x2&>(S_Sym);
+    S = A;
+    R.rowRotation(S);
+}
+
+inline void polarDecomposition(const btMatrix2x2& A,
+                   const btMatrix2x2& R,
+                   const btMatrix2x2& S_Sym)
+{
+    GivensRotation r(0, 1);
+    polarDecomposition(A, r, S_Sym);
+    r.fill(R);
+}
+
+/**
+ \brief 2x2 SVD (singular value decomposition) A=USV'
+ \param[in] A Input matrix.
+ \param[out] U Robustly a rotation matrix in Givens form
+ \param[out] Sigma matrix of singular values sorted with decreasing magnitude. The second one can be negative.
+ \param[out] V Robustly a rotation matrix in Givens form
+ */
+inline void singularValueDecomposition(
+                           const btMatrix2x2& A,
+                           GivensRotation& U,
+                           const btMatrix2x2& Sigma,
+                           GivensRotation& V,
+                           const btScalar tol = 64 * std::numeric_limits<btScalar>::epsilon())
+{
+    btMatrix2x2& sigma = const_cast<btMatrix2x2&>(Sigma);
+    sigma.setIdentity();
+    btMatrix2x2 S_Sym;
+    polarDecomposition(A, U, S_Sym);
+    btScalar cosine, sine;
+    btScalar x = S_Sym(0, 0);
+    btScalar y = S_Sym(0, 1);
+    btScalar z = S_Sym(1, 1);
+    if (y == 0) {
+        // S is already diagonal
+        cosine = 1;
+        sine = 0;
+        sigma(0,0) = x;
+        sigma(1,1) = z;
+    }
+    else {
+        btScalar tau = 0.5 * (x - z);
+        btScalar val = tau * tau + y * y;
+        if (val > SIMD_EPSILON)
+        {
+        btScalar w = btSqrt(val);
+        // w > y > 0
+        btScalar t;
+        if (tau > 0) {
+            // tau + w > w > y > 0 ==> division is safe
+            t = y / (tau + w);
+        }
+        else {
+            // tau - w < -w < -y < 0 ==> division is safe
+            t = y / (tau - w);
+        }
+        cosine = btScalar(1) / btSqrt(t * t + btScalar(1));
+        sine = -t * cosine;
+        /*
+         V = [cosine -sine; sine cosine]
+         Sigma = V'SV. Only compute the diagonals for efficiency.
+         Also utilize symmetry of S and don't form V yet.
+         */
+        btScalar c2 = cosine * cosine;
+        btScalar csy = 2 * cosine * sine * y;
+        btScalar s2 = sine * sine;
+        sigma(0,0) = c2 * x - csy + s2 * z;
+        sigma(1,1) = s2 * x + csy + c2 * z;
+      } else
+      	{
+      		cosine = 1;
+        sine = 0;
+        sigma(0,0) = x;
+        sigma(1,1) = z;
+      	}
+    }
+    
+    // Sorting
+    // Polar already guarantees negative sign is on the small magnitude singular value.
+    if (sigma(0,0) < sigma(1,1)) {
+        std::swap(sigma(0,0), sigma(1,1));
+        V.c = -sine;
+        V.s = cosine;
+    }
+    else {
+        V.c = cosine;
+        V.s = sine;
+    }
+    U *= V;
+}
+
+/**
+ \brief 2x2 SVD (singular value decomposition) A=USV'
+ \param[in] A Input matrix.
+ \param[out] U Robustly a rotation matrix.
+ \param[out] Sigma Vector of singular values sorted with decreasing magnitude. The second one can be negative.
+ \param[out] V Robustly a rotation matrix.
+ */
+inline void singularValueDecomposition(
+                           const btMatrix2x2& A,
+                           const btMatrix2x2& U,
+                           const btMatrix2x2& Sigma,
+                           const btMatrix2x2& V,
+                           const btScalar tol = 64 * std::numeric_limits<btScalar>::epsilon())
+{
+    GivensRotation gv(0, 1);
+    GivensRotation gu(0, 1);
+    singularValueDecomposition(A, gu, Sigma, gv);
+    
+    gu.fill(U);
+    gv.fill(V);
+}
+
+/**
+ \brief compute wilkinsonShift of the block
+ a1     b1
+ b1     a2
+ based on the wilkinsonShift formula
+ mu = c + d - sign (d) \ sqrt (d*d + b*b), where d = (a-c)/2
+ 
+ */
+inline btScalar wilkinsonShift(const btScalar a1, const btScalar b1, const btScalar a2)
+{
+	btScalar d = (btScalar)0.5 * (a1 - a2);
+	btScalar bs = b1 * b1;
+	btScalar val = d * d + bs;
+	if (val>SIMD_EPSILON)
+	{
+		btScalar denom = btFabs(d) + btSqrt(val);
+
+		btScalar mu = a2 - copySign(bs / (denom), d);
+		// T mu = a2 - bs / ( d + sign_d*sqrt (d*d + bs));
+		return mu;
+	}
+	return a2;
+}
+
+/**
+ \brief Helper function of 3X3 SVD for processing 2X2 SVD
+ */
+template <int t>
+inline void process(btMatrix3x3& B, btMatrix3x3& U, btVector3& sigma, btMatrix3x3& V)
+{
+    int other = (t == 1) ? 0 : 2;
+    GivensRotation u(0, 1);
+    GivensRotation v(0, 1);
+    sigma[other] = B[other][other];
+    
+    btMatrix2x2 B_sub, sigma_sub;
+    if (t == 0)
+    {
+        B_sub.m_00 = B[0][0];
+        B_sub.m_10 = B[1][0];
+        B_sub.m_01 = B[0][1];
+        B_sub.m_11 = B[1][1];
+        sigma_sub.m_00 = sigma[0];
+        sigma_sub.m_11 = sigma[1];
+//        singularValueDecomposition(B.template block<2, 2>(t, t), u, sigma.template block<2, 1>(t, 0), v);
+        singularValueDecomposition(B_sub, u, sigma_sub, v);
+        B[0][0] = B_sub.m_00;
+        B[1][0] = B_sub.m_10;
+        B[0][1] = B_sub.m_01;
+        B[1][1] = B_sub.m_11;
+        sigma[0] = sigma_sub.m_00;
+        sigma[1] = sigma_sub.m_11;
+    }
+    else
+    {
+        B_sub.m_00 = B[1][1];
+        B_sub.m_10 = B[2][1];
+        B_sub.m_01 = B[1][2];
+        B_sub.m_11 = B[2][2];
+        sigma_sub.m_00 = sigma[1];
+        sigma_sub.m_11 = sigma[2];
+        //        singularValueDecomposition(B.template block<2, 2>(t, t), u, sigma.template block<2, 1>(t, 0), v);
+        singularValueDecomposition(B_sub, u, sigma_sub, v);
+        B[1][1] = B_sub.m_00;
+        B[2][1] = B_sub.m_10;
+        B[1][2] = B_sub.m_01;
+        B[2][2] = B_sub.m_11;
+        sigma[1] = sigma_sub.m_00;
+        sigma[2] = sigma_sub.m_11;
+    }
+    u.rowi += t;
+    u.rowk += t;
+    v.rowi += t;
+    v.rowk += t;
+    u.columnRotation(U);
+    v.columnRotation(V);
+}
+
+/**
+ \brief Helper function of 3X3 SVD for flipping signs due to flipping signs of sigma
+ */
+inline void flipSign(int i, btMatrix3x3& U, btVector3& sigma)
+{
+    sigma[i] = -sigma[i];
+    U[0][i] = -U[0][i];
+    U[1][i] = -U[1][i];
+    U[2][i] = -U[2][i];
+}
+
+inline void flipSign(int i, btMatrix3x3& U)
+{
+    U[0][i] = -U[0][i];
+    U[1][i] = -U[1][i];
+    U[2][i] = -U[2][i];
+}
+
+inline void swapCol(btMatrix3x3& A, int i, int j)
+{
+    for (int d = 0; d < 3; ++d)
+        std::swap(A[d][i], A[d][j]);
+}
+/**
+ \brief Helper function of 3X3 SVD for sorting singular values
+ */
+inline void sort(btMatrix3x3& U, btVector3& sigma, btMatrix3x3& V, int t)
+{
+    if (t == 0)
+    {
+        // Case: sigma(0) > |sigma(1)| >= |sigma(2)|
+        if (btFabs(sigma[1]) >= btFabs(sigma[2])) {
+            if (sigma[1] < 0) {
+                flipSign(1, U, sigma);
+                flipSign(2, U, sigma);
+            }
+            return;
+        }
+        
+        //fix sign of sigma for both cases
+        if (sigma[2] < 0) {
+            flipSign(1, U, sigma);
+            flipSign(2, U, sigma);
+        }
+        
+        //swap sigma(1) and sigma(2) for both cases
+        std::swap(sigma[1], sigma[2]);
+        // swap the col 1 and col 2 for U,V
+        swapCol(U,1,2);
+        swapCol(V,1,2);
+        
+        // Case: |sigma(2)| >= sigma(0) > |simga(1)|
+        if (sigma[1] > sigma[0]) {
+            std::swap(sigma[0], sigma[1]);
+            swapCol(U,0,1);
+            swapCol(V,0,1);
+        }
+        
+        // Case: sigma(0) >= |sigma(2)| > |simga(1)|
+        else {
+            flipSign(2, U);
+            flipSign(2, V);
+        }
+    }
+    else if (t == 1)
+    {
+        // Case: |sigma(0)| >= sigma(1) > |sigma(2)|
+        if (btFabs(sigma[0]) >= sigma[1]) {
+            if (sigma[0] < 0) {
+                flipSign(0, U, sigma);
+                flipSign(2, U, sigma);
+            }
+            return;
+        }
+        
+        //swap sigma(0) and sigma(1) for both cases
+        std::swap(sigma[0], sigma[1]);
+        swapCol(U, 0, 1);
+        swapCol(V, 0, 1);
+        
+        // Case: sigma(1) > |sigma(2)| >= |sigma(0)|
+        if (btFabs(sigma[1]) < btFabs(sigma[2])) {
+            std::swap(sigma[1], sigma[2]);
+            swapCol(U, 1, 2);
+            swapCol(V, 1, 2);
+        }
+        
+        // Case: sigma(1) >= |sigma(0)| > |sigma(2)|
+        else {
+            flipSign(1, U);
+            flipSign(1, V);
+        }
+        
+        // fix sign for both cases
+        if (sigma[1] < 0) {
+            flipSign(1, U, sigma);
+            flipSign(2, U, sigma);
+        }
+    }
+}
+
+/**
+ \brief 3X3 SVD (singular value decomposition) A=USV'
+ \param[in] A Input matrix.
+ \param[out] U is a rotation matrix.
+ \param[out] sigma Diagonal matrix, sorted with decreasing magnitude. The third one can be negative.
+ \param[out] V is a rotation matrix.
+ */
+inline int singularValueDecomposition(const btMatrix3x3& A,
+                                     btMatrix3x3& U,
+                                     btVector3& sigma,
+                                     btMatrix3x3& V,
+                                     btScalar tol = 128*std::numeric_limits<btScalar>::epsilon())
+{
+//    using std::fabs;
+    btMatrix3x3 B = A;
+    U.setIdentity();
+    V.setIdentity();
+    
+    makeUpperBidiag(B, U, V);
+    
+    int count = 0;
+    btScalar mu = (btScalar)0;
+    GivensRotation r(0, 1);
+    
+    btScalar alpha_1 = B[0][0];
+    btScalar beta_1 = B[0][1];
+    btScalar alpha_2 = B[1][1];
+    btScalar alpha_3 = B[2][2];
+    btScalar beta_2 = B[1][2];
+    btScalar gamma_1 = alpha_1 * beta_1;
+    btScalar gamma_2 = alpha_2 * beta_2;
+    btScalar val = alpha_1 * alpha_1 + alpha_2 * alpha_2 + alpha_3 * alpha_3 + beta_1 * beta_1 + beta_2 * beta_2;
+    if (val > SIMD_EPSILON)
+    {
+	    tol *= btMax((btScalar)0.5 * btSqrt(val), (btScalar)1);
+		}    
+    /**
+     Do implicit shift QR until A^T A is block diagonal
+     */
+    int max_count = 100;
+    
+    while (btFabs(beta_2) > tol && btFabs(beta_1) > tol
+           && btFabs(alpha_1) > tol && btFabs(alpha_2) > tol
+           && btFabs(alpha_3) > tol
+           && count < max_count) {
+        mu = wilkinsonShift(alpha_2 * alpha_2 + beta_1 * beta_1, gamma_2, alpha_3 * alpha_3 + beta_2 * beta_2);
+        
+        r.compute(alpha_1 * alpha_1 - mu, gamma_1);
+        r.columnRotation(B);
+        
+        r.columnRotation(V);
+        zeroChase(B, U, V);
+        
+        alpha_1 = B[0][0];
+        beta_1 = B[0][1];
+        alpha_2 = B[1][1];
+        alpha_3 = B[2][2];
+        beta_2 = B[1][2];
+        gamma_1 = alpha_1 * beta_1;
+        gamma_2 = alpha_2 * beta_2;
+        count++;
+    }
+    /**
+     Handle the cases of one of the alphas and betas being 0
+     Sorted by ease of handling and then frequency
+     of occurrence
+     
+     If B is of form
+     x x 0
+     0 x 0
+     0 0 x
+     */
+    if (btFabs(beta_2) <= tol) {
+        process<0>(B, U, sigma, V);
+        sort(U, sigma, V,0);
+    }
+    /**
+     If B is of form
+     x 0 0
+     0 x x
+     0 0 x
+     */
+    else if (btFabs(beta_1) <= tol) {
+        process<1>(B, U, sigma, V);
+        sort(U, sigma, V,1);
+    }
+    /**
+     If B is of form
+     x x 0
+     0 0 x
+     0 0 x
+     */
+    else if (btFabs(alpha_2) <= tol) {
+        /**
+         Reduce B to
+         x x 0
+         0 0 0
+         0 0 x
+         */
+        GivensRotation r1(1, 2);
+        r1.computeUnconventional(B[1][2], B[2][2]);
+        r1.rowRotation(B);
+        r1.columnRotation(U);
+        
+        process<0>(B, U, sigma, V);
+        sort(U, sigma, V, 0);
+    }
+    /**
+     If B is of form
+     x x 0
+     0 x x
+     0 0 0
+     */
+    else if (btFabs(alpha_3) <= tol) {
+        /**
+         Reduce B to
+         x x +
+         0 x 0
+         0 0 0
+         */
+        GivensRotation r1(1, 2);
+        r1.compute(B[1][1], B[1][2]);
+        r1.columnRotation(B);
+        r1.columnRotation(V);
+        /**
+         Reduce B to
+         x x 0
+         + x 0
+         0 0 0
+         */
+        GivensRotation r2(0, 2);
+        r2.compute(B[0][0], B[0][2]);
+        r2.columnRotation(B);
+        r2.columnRotation(V);
+        
+        process<0>(B, U, sigma, V);
+        sort(U, sigma, V, 0);
+    }
+    /**
+     If B is of form
+     0 x 0
+     0 x x
+     0 0 x
+     */
+    else if (btFabs(alpha_1) <= tol) {
+        /**
+         Reduce B to
+         0 0 +
+         0 x x
+         0 0 x
+         */
+        GivensRotation r1(0, 1);
+        r1.computeUnconventional(B[0][1], B[1][1]);
+        r1.rowRotation(B);
+        r1.columnRotation(U);
+        
+        /**
+         Reduce B to
+         0 0 0
+         0 x x
+         0 + x
+         */
+        GivensRotation r2(0, 2);
+        r2.computeUnconventional(B[0][2], B[2][2]);
+        r2.rowRotation(B);
+        r2.columnRotation(U);
+        
+        process<1>(B, U, sigma, V);
+        sort(U, sigma, V, 1);
+    }
+    
+    return count;
+}
+#endif /* btImplicitQRSVD_h */
diff --git a/engine/inc/bullet/LinearMath/btList.h b/engine/inc/bullet/LinearMath/btList.h
new file mode 100644
index 00000000..b255938c
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btList.h
@@ -0,0 +1,73 @@
+/*
+Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_GEN_LIST_H
+#define BT_GEN_LIST_H
+
+class btGEN_Link
+{
+public:
+	btGEN_Link() : m_next(0), m_prev(0) {}
+	btGEN_Link(btGEN_Link *next, btGEN_Link *prev) : m_next(next), m_prev(prev) {}
+
+	btGEN_Link *getNext() const { return m_next; }
+	btGEN_Link *getPrev() const { return m_prev; }
+
+	bool isHead() const { return m_prev == 0; }
+	bool isTail() const { return m_next == 0; }
+
+	void insertBefore(btGEN_Link *link)
+	{
+		m_next = link;
+		m_prev = link->m_prev;
+		m_next->m_prev = this;
+		m_prev->m_next = this;
+	}
+
+	void insertAfter(btGEN_Link *link)
+	{
+		m_next = link->m_next;
+		m_prev = link;
+		m_next->m_prev = this;
+		m_prev->m_next = this;
+	}
+
+	void remove()
+	{
+		m_next->m_prev = m_prev;
+		m_prev->m_next = m_next;
+	}
+
+private:
+	btGEN_Link *m_next;
+	btGEN_Link *m_prev;
+};
+
+class btGEN_List
+{
+public:
+	btGEN_List() : m_head(&m_tail, 0), m_tail(0, &m_head) {}
+
+	btGEN_Link *getHead() const { return m_head.getNext(); }
+	btGEN_Link *getTail() const { return m_tail.getPrev(); }
+
+	void addHead(btGEN_Link *link) { link->insertAfter(&m_head); }
+	void addTail(btGEN_Link *link) { link->insertBefore(&m_tail); }
+
+private:
+	btGEN_Link m_head;
+	btGEN_Link m_tail;
+};
+
+#endif  //BT_GEN_LIST_H
diff --git a/engine/inc/bullet/LinearMath/btMatrix3x3.h b/engine/inc/bullet/LinearMath/btMatrix3x3.h
new file mode 100644
index 00000000..9c90fee1
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btMatrix3x3.h
@@ -0,0 +1,1431 @@
+/*
+Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_MATRIX3x3_H
+#define BT_MATRIX3x3_H
+
+#include "btVector3.h"
+#include "btQuaternion.h"
+#include <stdio.h>
+
+#ifdef BT_USE_SSE
+//const __m128 ATTRIBUTE_ALIGNED16(v2220) = {2.0f, 2.0f, 2.0f, 0.0f};
+//const __m128 ATTRIBUTE_ALIGNED16(vMPPP) = {-0.0f, +0.0f, +0.0f, +0.0f};
+#define vMPPP (_mm_set_ps(+0.0f, +0.0f, +0.0f, -0.0f))
+#endif
+
+#if defined(BT_USE_SSE)
+#define v0000 (_mm_set_ps(0.0f, 0.0f, 0.0f, 0.0f))
+#define v1000 (_mm_set_ps(0.0f, 0.0f, 0.0f, 1.0f))
+#define v0100 (_mm_set_ps(0.0f, 0.0f, 1.0f, 0.0f))
+#define v0010 (_mm_set_ps(0.0f, 1.0f, 0.0f, 0.0f))
+#elif defined(BT_USE_NEON)
+const btSimdFloat4 ATTRIBUTE_ALIGNED16(v0000) = {0.0f, 0.0f, 0.0f, 0.0f};
+const btSimdFloat4 ATTRIBUTE_ALIGNED16(v1000) = {1.0f, 0.0f, 0.0f, 0.0f};
+const btSimdFloat4 ATTRIBUTE_ALIGNED16(v0100) = {0.0f, 1.0f, 0.0f, 0.0f};
+const btSimdFloat4 ATTRIBUTE_ALIGNED16(v0010) = {0.0f, 0.0f, 1.0f, 0.0f};
+#endif
+
+#ifdef BT_USE_DOUBLE_PRECISION
+#define btMatrix3x3Data btMatrix3x3DoubleData
+#else
+#define btMatrix3x3Data btMatrix3x3FloatData
+#endif  //BT_USE_DOUBLE_PRECISION
+
+/**@brief The btMatrix3x3 class implements a 3x3 rotation matrix, to perform linear algebra in combination with btQuaternion, btTransform and btVector3.
+* Make sure to only include a pure orthogonal matrix without scaling. */
+ATTRIBUTE_ALIGNED16(class)
+btMatrix3x3
+{
+	///Data storage for the matrix, each vector is a row of the matrix
+	btVector3 m_el[3];
+
+public:
+	/** @brief No initializaion constructor */
+	btMatrix3x3() {}
+
+	//		explicit btMatrix3x3(const btScalar *m) { setFromOpenGLSubMatrix(m); }
+
+	/**@brief Constructor from Quaternion */
+	explicit btMatrix3x3(const btQuaternion& q) { setRotation(q); }
+	/*
+	template <typename btScalar>
+	Matrix3x3(const btScalar& yaw, const btScalar& pitch, const btScalar& roll)
+	{ 
+	setEulerYPR(yaw, pitch, roll);
+	}
+	*/
+	/** @brief Constructor with row major formatting */
+	btMatrix3x3(const btScalar& xx, const btScalar& xy, const btScalar& xz,
+				const btScalar& yx, const btScalar& yy, const btScalar& yz,
+				const btScalar& zx, const btScalar& zy, const btScalar& zz)
+	{
+		setValue(xx, xy, xz,
+				 yx, yy, yz,
+				 zx, zy, zz);
+	}
+
+#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON)
+	SIMD_FORCE_INLINE btMatrix3x3(const btSimdFloat4 v0, const btSimdFloat4 v1, const btSimdFloat4 v2)
+	{
+		m_el[0].mVec128 = v0;
+		m_el[1].mVec128 = v1;
+		m_el[2].mVec128 = v2;
+	}
+
+	SIMD_FORCE_INLINE btMatrix3x3(const btVector3& v0, const btVector3& v1, const btVector3& v2)
+	{
+		m_el[0] = v0;
+		m_el[1] = v1;
+		m_el[2] = v2;
+	}
+
+	// Copy constructor
+	SIMD_FORCE_INLINE btMatrix3x3(const btMatrix3x3& rhs)
+	{
+		m_el[0].mVec128 = rhs.m_el[0].mVec128;
+		m_el[1].mVec128 = rhs.m_el[1].mVec128;
+		m_el[2].mVec128 = rhs.m_el[2].mVec128;
+	}
+
+	// Assignment Operator
+	SIMD_FORCE_INLINE btMatrix3x3& operator=(const btMatrix3x3& m)
+	{
+		m_el[0].mVec128 = m.m_el[0].mVec128;
+		m_el[1].mVec128 = m.m_el[1].mVec128;
+		m_el[2].mVec128 = m.m_el[2].mVec128;
+
+		return *this;
+	}
+
+#else
+
+	/** @brief Copy constructor */
+	SIMD_FORCE_INLINE btMatrix3x3(const btMatrix3x3& other)
+	{
+		m_el[0] = other.m_el[0];
+		m_el[1] = other.m_el[1];
+		m_el[2] = other.m_el[2];
+	}
+
+	/** @brief Assignment Operator */
+	SIMD_FORCE_INLINE btMatrix3x3& operator=(const btMatrix3x3& other)
+	{
+		m_el[0] = other.m_el[0];
+		m_el[1] = other.m_el[1];
+		m_el[2] = other.m_el[2];
+		return *this;
+	}
+    
+    SIMD_FORCE_INLINE btMatrix3x3(const btVector3& v0, const btVector3& v1, const btVector3& v2)
+    {
+        m_el[0] = v0;
+        m_el[1] = v1;
+        m_el[2] = v2;
+    }
+
+#endif
+
+	/** @brief Get a column of the matrix as a vector 
+	*  @param i Column number 0 indexed */
+	SIMD_FORCE_INLINE btVector3 getColumn(int i) const
+	{
+		return btVector3(m_el[0][i], m_el[1][i], m_el[2][i]);
+	}
+
+	/** @brief Get a row of the matrix as a vector 
+	*  @param i Row number 0 indexed */
+	SIMD_FORCE_INLINE const btVector3& getRow(int i) const
+	{
+		btFullAssert(0 <= i && i < 3);
+		return m_el[i];
+	}
+
+	/** @brief Get a mutable reference to a row of the matrix as a vector 
+	*  @param i Row number 0 indexed */
+	SIMD_FORCE_INLINE btVector3& operator[](int i)
+	{
+		btFullAssert(0 <= i && i < 3);
+		return m_el[i];
+	}
+
+	/** @brief Get a const reference to a row of the matrix as a vector 
+	*  @param i Row number 0 indexed */
+	SIMD_FORCE_INLINE const btVector3& operator[](int i) const
+	{
+		btFullAssert(0 <= i && i < 3);
+		return m_el[i];
+	}
+
+	/** @brief Multiply by the target matrix on the right
+	*  @param m Rotation matrix to be applied 
+	* Equivilant to this = this * m */
+	btMatrix3x3& operator*=(const btMatrix3x3& m);
+
+	/** @brief Adds by the target matrix on the right
+	*  @param m matrix to be applied 
+	* Equivilant to this = this + m */
+	btMatrix3x3& operator+=(const btMatrix3x3& m);
+
+	/** @brief Substractss by the target matrix on the right
+	*  @param m matrix to be applied 
+	* Equivilant to this = this - m */
+	btMatrix3x3& operator-=(const btMatrix3x3& m);
+
+	/** @brief Set from the rotational part of a 4x4 OpenGL matrix
+	*  @param m A pointer to the beginning of the array of scalars*/
+	void setFromOpenGLSubMatrix(const btScalar* m)
+	{
+		m_el[0].setValue(m[0], m[4], m[8]);
+		m_el[1].setValue(m[1], m[5], m[9]);
+		m_el[2].setValue(m[2], m[6], m[10]);
+	}
+	/** @brief Set the values of the matrix explicitly (row major)
+	*  @param xx Top left
+	*  @param xy Top Middle
+	*  @param xz Top Right
+	*  @param yx Middle Left
+	*  @param yy Middle Middle
+	*  @param yz Middle Right
+	*  @param zx Bottom Left
+	*  @param zy Bottom Middle
+	*  @param zz Bottom Right*/
+	void setValue(const btScalar& xx, const btScalar& xy, const btScalar& xz,
+				  const btScalar& yx, const btScalar& yy, const btScalar& yz,
+				  const btScalar& zx, const btScalar& zy, const btScalar& zz)
+	{
+		m_el[0].setValue(xx, xy, xz);
+		m_el[1].setValue(yx, yy, yz);
+		m_el[2].setValue(zx, zy, zz);
+	}
+
+	/** @brief Set the matrix from a quaternion
+	*  @param q The Quaternion to match */
+	void setRotation(const btQuaternion& q)
+	{
+		btScalar d = q.length2();
+		btFullAssert(d != btScalar(0.0));
+		btScalar s = btScalar(2.0) / d;
+
+#if defined BT_USE_SIMD_VECTOR3 && defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+		__m128 vs, Q = q.get128();
+		__m128i Qi = btCastfTo128i(Q);
+		__m128 Y, Z;
+		__m128 V1, V2, V3;
+		__m128 V11, V21, V31;
+		__m128 NQ = _mm_xor_ps(Q, btvMzeroMask);
+		__m128i NQi = btCastfTo128i(NQ);
+
+		V1 = btCastiTo128f(_mm_shuffle_epi32(Qi, BT_SHUFFLE(1, 0, 2, 3)));  // Y X Z W
+		V2 = _mm_shuffle_ps(NQ, Q, BT_SHUFFLE(0, 0, 1, 3));                 // -X -X  Y  W
+		V3 = btCastiTo128f(_mm_shuffle_epi32(Qi, BT_SHUFFLE(2, 1, 0, 3)));  // Z Y X W
+		V1 = _mm_xor_ps(V1, vMPPP);                                         //	change the sign of the first element
+
+		V11 = btCastiTo128f(_mm_shuffle_epi32(Qi, BT_SHUFFLE(1, 1, 0, 3)));  // Y Y X W
+		V21 = _mm_unpackhi_ps(Q, Q);                                         //  Z  Z  W  W
+		V31 = _mm_shuffle_ps(Q, NQ, BT_SHUFFLE(0, 2, 0, 3));                 //  X  Z -X -W
+
+		V2 = V2 * V1;   //
+		V1 = V1 * V11;  //
+		V3 = V3 * V31;  //
+
+		V11 = _mm_shuffle_ps(NQ, Q, BT_SHUFFLE(2, 3, 1, 3));                //	-Z -W  Y  W
+		V11 = V11 * V21;                                                    //
+		V21 = _mm_xor_ps(V21, vMPPP);                                       //	change the sign of the first element
+		V31 = _mm_shuffle_ps(Q, NQ, BT_SHUFFLE(3, 3, 1, 3));                //	 W  W -Y -W
+		V31 = _mm_xor_ps(V31, vMPPP);                                       //	change the sign of the first element
+		Y = btCastiTo128f(_mm_shuffle_epi32(NQi, BT_SHUFFLE(3, 2, 0, 3)));  // -W -Z -X -W
+		Z = btCastiTo128f(_mm_shuffle_epi32(Qi, BT_SHUFFLE(1, 0, 1, 3)));   //  Y  X  Y  W
+
+		vs = _mm_load_ss(&s);
+		V21 = V21 * Y;
+		V31 = V31 * Z;
+
+		V1 = V1 + V11;
+		V2 = V2 + V21;
+		V3 = V3 + V31;
+
+		vs = bt_splat3_ps(vs, 0);
+		//	s ready
+		V1 = V1 * vs;
+		V2 = V2 * vs;
+		V3 = V3 * vs;
+
+		V1 = V1 + v1000;
+		V2 = V2 + v0100;
+		V3 = V3 + v0010;
+
+		m_el[0] = V1;
+		m_el[1] = V2;
+		m_el[2] = V3;
+#else
+		btScalar xs = q.x() * s, ys = q.y() * s, zs = q.z() * s;
+		btScalar wx = q.w() * xs, wy = q.w() * ys, wz = q.w() * zs;
+		btScalar xx = q.x() * xs, xy = q.x() * ys, xz = q.x() * zs;
+		btScalar yy = q.y() * ys, yz = q.y() * zs, zz = q.z() * zs;
+		setValue(
+			btScalar(1.0) - (yy + zz), xy - wz, xz + wy,
+			xy + wz, btScalar(1.0) - (xx + zz), yz - wx,
+			xz - wy, yz + wx, btScalar(1.0) - (xx + yy));
+#endif
+	}
+
+	/** @brief Set the matrix from euler angles using YPR around YXZ respectively
+	*  @param yaw Yaw about Y axis
+	*  @param pitch Pitch about X axis
+	*  @param roll Roll about Z axis 
+	*/
+	void setEulerYPR(const btScalar& yaw, const btScalar& pitch, const btScalar& roll)
+	{
+		setEulerZYX(roll, pitch, yaw);
+	}
+
+	/** @brief Set the matrix from euler angles YPR around ZYX axes
+	* @param eulerX Roll about X axis
+	* @param eulerY Pitch around Y axis
+	* @param eulerZ Yaw about Z axis
+	* 
+	* These angles are used to produce a rotation matrix. The euler
+	* angles are applied in ZYX order. I.e a vector is first rotated 
+	* about X then Y and then Z
+	**/
+	void setEulerZYX(btScalar eulerX, btScalar eulerY, btScalar eulerZ)
+	{
+		///@todo proposed to reverse this since it's labeled zyx but takes arguments xyz and it will match all other parts of the code
+		btScalar ci(btCos(eulerX));
+		btScalar cj(btCos(eulerY));
+		btScalar ch(btCos(eulerZ));
+		btScalar si(btSin(eulerX));
+		btScalar sj(btSin(eulerY));
+		btScalar sh(btSin(eulerZ));
+		btScalar cc = ci * ch;
+		btScalar cs = ci * sh;
+		btScalar sc = si * ch;
+		btScalar ss = si * sh;
+
+		setValue(cj * ch, sj * sc - cs, sj * cc + ss,
+				 cj * sh, sj * ss + cc, sj * cs - sc,
+				 -sj, cj * si, cj * ci);
+	}
+
+	/**@brief Set the matrix to the identity */
+	void setIdentity()
+	{
+#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON)
+		m_el[0] = v1000;
+		m_el[1] = v0100;
+		m_el[2] = v0010;
+#else
+		setValue(btScalar(1.0), btScalar(0.0), btScalar(0.0),
+				 btScalar(0.0), btScalar(1.0), btScalar(0.0),
+				 btScalar(0.0), btScalar(0.0), btScalar(1.0));
+#endif
+	}
+    
+    /**@brief Set the matrix to the identity */
+    void setZero()
+    {
+#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON)
+        m_el[0] = v0000;
+        m_el[1] = v0000;
+        m_el[2] = v0000;
+#else
+        setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0),
+                 btScalar(0.0), btScalar(0.0), btScalar(0.0),
+                 btScalar(0.0), btScalar(0.0), btScalar(0.0));
+#endif
+    }
+
+	static const btMatrix3x3& getIdentity()
+	{
+#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON)
+		static const btMatrix3x3
+			identityMatrix(v1000, v0100, v0010);
+#else
+		static const btMatrix3x3
+			identityMatrix(
+				btScalar(1.0), btScalar(0.0), btScalar(0.0),
+				btScalar(0.0), btScalar(1.0), btScalar(0.0),
+				btScalar(0.0), btScalar(0.0), btScalar(1.0));
+#endif
+		return identityMatrix;
+	}
+
+	/**@brief Fill the rotational part of an OpenGL matrix and clear the shear/perspective
+	* @param m The array to be filled */
+	void getOpenGLSubMatrix(btScalar * m) const
+	{
+#if defined BT_USE_SIMD_VECTOR3 && defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+		__m128 v0 = m_el[0].mVec128;
+		__m128 v1 = m_el[1].mVec128;
+		__m128 v2 = m_el[2].mVec128;  //  x2 y2 z2 w2
+		__m128* vm = (__m128*)m;
+		__m128 vT;
+
+		v2 = _mm_and_ps(v2, btvFFF0fMask);  //  x2 y2 z2 0
+
+		vT = _mm_unpackhi_ps(v0, v1);  //	z0 z1 * *
+		v0 = _mm_unpacklo_ps(v0, v1);  //	x0 x1 y0 y1
+
+		v1 = _mm_shuffle_ps(v0, v2, BT_SHUFFLE(2, 3, 1, 3));                    // y0 y1 y2 0
+		v0 = _mm_shuffle_ps(v0, v2, BT_SHUFFLE(0, 1, 0, 3));                    // x0 x1 x2 0
+		v2 = btCastdTo128f(_mm_move_sd(btCastfTo128d(v2), btCastfTo128d(vT)));  // z0 z1 z2 0
+
+		vm[0] = v0;
+		vm[1] = v1;
+		vm[2] = v2;
+#elif defined(BT_USE_NEON)
+		// note: zeros the w channel. We can preserve it at the cost of two more vtrn instructions.
+		static const uint32x2_t zMask = (const uint32x2_t){static_cast<uint32_t>(-1), 0};
+		float32x4_t* vm = (float32x4_t*)m;
+		float32x4x2_t top = vtrnq_f32(m_el[0].mVec128, m_el[1].mVec128);               // {x0 x1 z0 z1}, {y0 y1 w0 w1}
+		float32x2x2_t bl = vtrn_f32(vget_low_f32(m_el[2].mVec128), vdup_n_f32(0.0f));  // {x2  0 }, {y2 0}
+		float32x4_t v0 = vcombine_f32(vget_low_f32(top.val[0]), bl.val[0]);
+		float32x4_t v1 = vcombine_f32(vget_low_f32(top.val[1]), bl.val[1]);
+		float32x2_t q = (float32x2_t)vand_u32((uint32x2_t)vget_high_f32(m_el[2].mVec128), zMask);
+		float32x4_t v2 = vcombine_f32(vget_high_f32(top.val[0]), q);  // z0 z1 z2  0
+
+		vm[0] = v0;
+		vm[1] = v1;
+		vm[2] = v2;
+#else
+		m[0] = btScalar(m_el[0].x());
+		m[1] = btScalar(m_el[1].x());
+		m[2] = btScalar(m_el[2].x());
+		m[3] = btScalar(0.0);
+		m[4] = btScalar(m_el[0].y());
+		m[5] = btScalar(m_el[1].y());
+		m[6] = btScalar(m_el[2].y());
+		m[7] = btScalar(0.0);
+		m[8] = btScalar(m_el[0].z());
+		m[9] = btScalar(m_el[1].z());
+		m[10] = btScalar(m_el[2].z());
+		m[11] = btScalar(0.0);
+#endif
+	}
+
+	/**@brief Get the matrix represented as a quaternion 
+	* @param q The quaternion which will be set */
+	void getRotation(btQuaternion & q) const
+	{
+#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON)
+		btScalar trace = m_el[0].x() + m_el[1].y() + m_el[2].z();
+		btScalar s, x;
+
+		union {
+			btSimdFloat4 vec;
+			btScalar f[4];
+		} temp;
+
+		if (trace > btScalar(0.0))
+		{
+			x = trace + btScalar(1.0);
+
+			temp.f[0] = m_el[2].y() - m_el[1].z();
+			temp.f[1] = m_el[0].z() - m_el[2].x();
+			temp.f[2] = m_el[1].x() - m_el[0].y();
+			temp.f[3] = x;
+			//temp.f[3]= s * btScalar(0.5);
+		}
+		else
+		{
+			int i, j, k;
+			if (m_el[0].x() < m_el[1].y())
+			{
+				if (m_el[1].y() < m_el[2].z())
+				{
+					i = 2;
+					j = 0;
+					k = 1;
+				}
+				else
+				{
+					i = 1;
+					j = 2;
+					k = 0;
+				}
+			}
+			else
+			{
+				if (m_el[0].x() < m_el[2].z())
+				{
+					i = 2;
+					j = 0;
+					k = 1;
+				}
+				else
+				{
+					i = 0;
+					j = 1;
+					k = 2;
+				}
+			}
+
+			x = m_el[i][i] - m_el[j][j] - m_el[k][k] + btScalar(1.0);
+
+			temp.f[3] = (m_el[k][j] - m_el[j][k]);
+			temp.f[j] = (m_el[j][i] + m_el[i][j]);
+			temp.f[k] = (m_el[k][i] + m_el[i][k]);
+			temp.f[i] = x;
+			//temp.f[i] = s * btScalar(0.5);
+		}
+
+		s = btSqrt(x);
+		q.set128(temp.vec);
+		s = btScalar(0.5) / s;
+
+		q *= s;
+#else
+		btScalar trace = m_el[0].x() + m_el[1].y() + m_el[2].z();
+
+		btScalar temp[4];
+
+		if (trace > btScalar(0.0))
+		{
+			btScalar s = btSqrt(trace + btScalar(1.0));
+			temp[3] = (s * btScalar(0.5));
+			s = btScalar(0.5) / s;
+
+			temp[0] = ((m_el[2].y() - m_el[1].z()) * s);
+			temp[1] = ((m_el[0].z() - m_el[2].x()) * s);
+			temp[2] = ((m_el[1].x() - m_el[0].y()) * s);
+		}
+		else
+		{
+			int i = m_el[0].x() < m_el[1].y() ? (m_el[1].y() < m_el[2].z() ? 2 : 1) : (m_el[0].x() < m_el[2].z() ? 2 : 0);
+			int j = (i + 1) % 3;
+			int k = (i + 2) % 3;
+
+			btScalar s = btSqrt(m_el[i][i] - m_el[j][j] - m_el[k][k] + btScalar(1.0));
+			temp[i] = s * btScalar(0.5);
+			s = btScalar(0.5) / s;
+
+			temp[3] = (m_el[k][j] - m_el[j][k]) * s;
+			temp[j] = (m_el[j][i] + m_el[i][j]) * s;
+			temp[k] = (m_el[k][i] + m_el[i][k]) * s;
+		}
+		q.setValue(temp[0], temp[1], temp[2], temp[3]);
+#endif
+	}
+
+	/**@brief Get the matrix represented as euler angles around YXZ, roundtrip with setEulerYPR
+	* @param yaw Yaw around Y axis
+	* @param pitch Pitch around X axis
+	* @param roll around Z axis */
+	void getEulerYPR(btScalar & yaw, btScalar & pitch, btScalar & roll) const
+	{
+		// first use the normal calculus
+		yaw = btScalar(btAtan2(m_el[1].x(), m_el[0].x()));
+		pitch = btScalar(btAsin(-m_el[2].x()));
+		roll = btScalar(btAtan2(m_el[2].y(), m_el[2].z()));
+
+		// on pitch = +/-HalfPI
+		if (btFabs(pitch) == SIMD_HALF_PI)
+		{
+			if (yaw > 0)
+				yaw -= SIMD_PI;
+			else
+				yaw += SIMD_PI;
+
+			if (roll > 0)
+				roll -= SIMD_PI;
+			else
+				roll += SIMD_PI;
+		}
+	};
+
+	/**@brief Get the matrix represented as euler angles around ZYX
+	* @param yaw Yaw around Z axis
+	* @param pitch Pitch around Y axis
+	* @param roll around X axis 
+	* @param solution_number Which solution of two possible solutions ( 1 or 2) are possible values*/
+	void getEulerZYX(btScalar & yaw, btScalar & pitch, btScalar & roll, unsigned int solution_number = 1) const
+	{
+		struct Euler
+		{
+			btScalar yaw;
+			btScalar pitch;
+			btScalar roll;
+		};
+
+		Euler euler_out;
+		Euler euler_out2;  //second solution
+		//get the pointer to the raw data
+
+		// Check that pitch is not at a singularity
+		if (btFabs(m_el[2].x()) >= 1)
+		{
+			euler_out.yaw = 0;
+			euler_out2.yaw = 0;
+
+			// From difference of angles formula
+			btScalar delta = btAtan2(m_el[0].x(), m_el[0].z());
+			if (m_el[2].x() > 0)  //gimbal locked up
+			{
+				euler_out.pitch = SIMD_PI / btScalar(2.0);
+				euler_out2.pitch = SIMD_PI / btScalar(2.0);
+				euler_out.roll = euler_out.pitch + delta;
+				euler_out2.roll = euler_out.pitch + delta;
+			}
+			else  // gimbal locked down
+			{
+				euler_out.pitch = -SIMD_PI / btScalar(2.0);
+				euler_out2.pitch = -SIMD_PI / btScalar(2.0);
+				euler_out.roll = -euler_out.pitch + delta;
+				euler_out2.roll = -euler_out.pitch + delta;
+			}
+		}
+		else
+		{
+			euler_out.pitch = -btAsin(m_el[2].x());
+			euler_out2.pitch = SIMD_PI - euler_out.pitch;
+
+			euler_out.roll = btAtan2(m_el[2].y() / btCos(euler_out.pitch),
+									 m_el[2].z() / btCos(euler_out.pitch));
+			euler_out2.roll = btAtan2(m_el[2].y() / btCos(euler_out2.pitch),
+									  m_el[2].z() / btCos(euler_out2.pitch));
+
+			euler_out.yaw = btAtan2(m_el[1].x() / btCos(euler_out.pitch),
+									m_el[0].x() / btCos(euler_out.pitch));
+			euler_out2.yaw = btAtan2(m_el[1].x() / btCos(euler_out2.pitch),
+									 m_el[0].x() / btCos(euler_out2.pitch));
+		}
+
+		if (solution_number == 1)
+		{
+			yaw = euler_out.yaw;
+			pitch = euler_out.pitch;
+			roll = euler_out.roll;
+		}
+		else
+		{
+			yaw = euler_out2.yaw;
+			pitch = euler_out2.pitch;
+			roll = euler_out2.roll;
+		}
+	}
+
+	/**@brief Create a scaled copy of the matrix 
+	* @param s Scaling vector The elements of the vector will scale each column */
+
+	btMatrix3x3 scaled(const btVector3& s) const
+	{
+#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON)
+		return btMatrix3x3(m_el[0] * s, m_el[1] * s, m_el[2] * s);
+#else
+		return btMatrix3x3(
+			m_el[0].x() * s.x(), m_el[0].y() * s.y(), m_el[0].z() * s.z(),
+			m_el[1].x() * s.x(), m_el[1].y() * s.y(), m_el[1].z() * s.z(),
+			m_el[2].x() * s.x(), m_el[2].y() * s.y(), m_el[2].z() * s.z());
+#endif
+	}
+
+	/**@brief Return the determinant of the matrix */
+	btScalar determinant() const;
+	/**@brief Return the adjoint of the matrix */
+	btMatrix3x3 adjoint() const;
+	/**@brief Return the matrix with all values non negative */
+	btMatrix3x3 absolute() const;
+	/**@brief Return the transpose of the matrix */
+	btMatrix3x3 transpose() const;
+	/**@brief Return the inverse of the matrix */
+	btMatrix3x3 inverse() const;
+
+	/// Solve A * x = b, where b is a column vector. This is more efficient
+	/// than computing the inverse in one-shot cases.
+	///Solve33 is from Box2d, thanks to Erin Catto,
+	btVector3 solve33(const btVector3& b) const
+	{
+		btVector3 col1 = getColumn(0);
+		btVector3 col2 = getColumn(1);
+		btVector3 col3 = getColumn(2);
+
+		btScalar det = btDot(col1, btCross(col2, col3));
+		if (btFabs(det) > SIMD_EPSILON)
+		{
+			det = 1.0f / det;
+		}
+		btVector3 x;
+		x[0] = det * btDot(b, btCross(col2, col3));
+		x[1] = det * btDot(col1, btCross(b, col3));
+		x[2] = det * btDot(col1, btCross(col2, b));
+		return x;
+	}
+
+	btMatrix3x3 transposeTimes(const btMatrix3x3& m) const;
+	btMatrix3x3 timesTranspose(const btMatrix3x3& m) const;
+
+	SIMD_FORCE_INLINE btScalar tdotx(const btVector3& v) const
+	{
+		return m_el[0].x() * v.x() + m_el[1].x() * v.y() + m_el[2].x() * v.z();
+	}
+	SIMD_FORCE_INLINE btScalar tdoty(const btVector3& v) const
+	{
+		return m_el[0].y() * v.x() + m_el[1].y() * v.y() + m_el[2].y() * v.z();
+	}
+	SIMD_FORCE_INLINE btScalar tdotz(const btVector3& v) const
+	{
+		return m_el[0].z() * v.x() + m_el[1].z() * v.y() + m_el[2].z() * v.z();
+	}
+
+	///extractRotation is from "A robust method to extract the rotational part of deformations"
+	///See http://dl.acm.org/citation.cfm?doid=2994258.2994269
+	///decomposes a matrix A in a orthogonal matrix R and a
+	///symmetric matrix S:
+	///A = R*S.
+	///note that R can include both rotation and scaling.
+	SIMD_FORCE_INLINE void extractRotation(btQuaternion & q, btScalar tolerance = 1.0e-9, int maxIter = 100)
+	{
+		int iter = 0;
+		btScalar w;
+		const btMatrix3x3& A = *this;
+		for (iter = 0; iter < maxIter; iter++)
+		{
+			btMatrix3x3 R(q);
+			btVector3 omega = (R.getColumn(0).cross(A.getColumn(0)) + R.getColumn(1).cross(A.getColumn(1)) + R.getColumn(2).cross(A.getColumn(2))) * (btScalar(1.0) / btFabs(R.getColumn(0).dot(A.getColumn(0)) + R.getColumn(1).dot(A.getColumn(1)) + R.getColumn(2).dot(A.getColumn(2))) +
+																																					  tolerance);
+			w = omega.norm();
+			if (w < tolerance)
+				break;
+			q = btQuaternion(btVector3((btScalar(1.0) / w) * omega), w) *
+				q;
+			q.normalize();
+		}
+	}
+
+	/**@brief diagonalizes this matrix by the Jacobi method.
+	* @param rot stores the rotation from the coordinate system in which the matrix is diagonal to the original
+	* coordinate system, i.e., old_this = rot * new_this * rot^T.
+	* @param threshold See iteration
+	* @param iteration The iteration stops when all off-diagonal elements are less than the threshold multiplied
+	* by the sum of the absolute values of the diagonal, or when maxSteps have been executed.
+	*
+	* Note that this matrix is assumed to be symmetric.
+	*/
+	void diagonalize(btMatrix3x3 & rot, btScalar threshold, int maxSteps)
+	{
+		rot.setIdentity();
+		for (int step = maxSteps; step > 0; step--)
+		{
+			// find off-diagonal element [p][q] with largest magnitude
+			int p = 0;
+			int q = 1;
+			int r = 2;
+			btScalar max = btFabs(m_el[0][1]);
+			btScalar v = btFabs(m_el[0][2]);
+			if (v > max)
+			{
+				q = 2;
+				r = 1;
+				max = v;
+			}
+			v = btFabs(m_el[1][2]);
+			if (v > max)
+			{
+				p = 1;
+				q = 2;
+				r = 0;
+				max = v;
+			}
+
+			btScalar t = threshold * (btFabs(m_el[0][0]) + btFabs(m_el[1][1]) + btFabs(m_el[2][2]));
+			if (max <= t)
+			{
+				if (max <= SIMD_EPSILON * t)
+				{
+					return;
+				}
+				step = 1;
+			}
+
+			// compute Jacobi rotation J which leads to a zero for element [p][q]
+			btScalar mpq = m_el[p][q];
+			btScalar theta = (m_el[q][q] - m_el[p][p]) / (2 * mpq);
+			btScalar theta2 = theta * theta;
+			btScalar cos;
+			btScalar sin;
+			if (theta2 * theta2 < btScalar(10 / SIMD_EPSILON))
+			{
+				t = (theta >= 0) ? 1 / (theta + btSqrt(1 + theta2))
+								 : 1 / (theta - btSqrt(1 + theta2));
+				cos = 1 / btSqrt(1 + t * t);
+				sin = cos * t;
+			}
+			else
+			{
+				// approximation for large theta-value, i.e., a nearly diagonal matrix
+				t = 1 / (theta * (2 + btScalar(0.5) / theta2));
+				cos = 1 - btScalar(0.5) * t * t;
+				sin = cos * t;
+			}
+
+			// apply rotation to matrix (this = J^T * this * J)
+			m_el[p][q] = m_el[q][p] = 0;
+			m_el[p][p] -= t * mpq;
+			m_el[q][q] += t * mpq;
+			btScalar mrp = m_el[r][p];
+			btScalar mrq = m_el[r][q];
+			m_el[r][p] = m_el[p][r] = cos * mrp - sin * mrq;
+			m_el[r][q] = m_el[q][r] = cos * mrq + sin * mrp;
+
+			// apply rotation to rot (rot = rot * J)
+			for (int i = 0; i < 3; i++)
+			{
+				btVector3& row = rot[i];
+				mrp = row[p];
+				mrq = row[q];
+				row[p] = cos * mrp - sin * mrq;
+				row[q] = cos * mrq + sin * mrp;
+			}
+		}
+	}
+
+	/**@brief Calculate the matrix cofactor 
+	* @param r1 The first row to use for calculating the cofactor
+	* @param c1 The first column to use for calculating the cofactor
+	* @param r1 The second row to use for calculating the cofactor
+	* @param c1 The second column to use for calculating the cofactor
+	* See http://en.wikipedia.org/wiki/Cofactor_(linear_algebra) for more details
+	*/
+	btScalar cofac(int r1, int c1, int r2, int c2) const
+	{
+		return m_el[r1][c1] * m_el[r2][c2] - m_el[r1][c2] * m_el[r2][c1];
+	}
+
+	void serialize(struct btMatrix3x3Data & dataOut) const;
+
+	void serializeFloat(struct btMatrix3x3FloatData & dataOut) const;
+
+	void deSerialize(const struct btMatrix3x3Data& dataIn);
+
+	void deSerializeFloat(const struct btMatrix3x3FloatData& dataIn);
+
+	void deSerializeDouble(const struct btMatrix3x3DoubleData& dataIn);
+};
+
+SIMD_FORCE_INLINE btMatrix3x3&
+btMatrix3x3::operator*=(const btMatrix3x3& m)
+{
+#if defined BT_USE_SIMD_VECTOR3 && defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+	__m128 rv00, rv01, rv02;
+	__m128 rv10, rv11, rv12;
+	__m128 rv20, rv21, rv22;
+	__m128 mv0, mv1, mv2;
+
+	rv02 = m_el[0].mVec128;
+	rv12 = m_el[1].mVec128;
+	rv22 = m_el[2].mVec128;
+
+	mv0 = _mm_and_ps(m[0].mVec128, btvFFF0fMask);
+	mv1 = _mm_and_ps(m[1].mVec128, btvFFF0fMask);
+	mv2 = _mm_and_ps(m[2].mVec128, btvFFF0fMask);
+
+	// rv0
+	rv00 = bt_splat_ps(rv02, 0);
+	rv01 = bt_splat_ps(rv02, 1);
+	rv02 = bt_splat_ps(rv02, 2);
+
+	rv00 = _mm_mul_ps(rv00, mv0);
+	rv01 = _mm_mul_ps(rv01, mv1);
+	rv02 = _mm_mul_ps(rv02, mv2);
+
+	// rv1
+	rv10 = bt_splat_ps(rv12, 0);
+	rv11 = bt_splat_ps(rv12, 1);
+	rv12 = bt_splat_ps(rv12, 2);
+
+	rv10 = _mm_mul_ps(rv10, mv0);
+	rv11 = _mm_mul_ps(rv11, mv1);
+	rv12 = _mm_mul_ps(rv12, mv2);
+
+	// rv2
+	rv20 = bt_splat_ps(rv22, 0);
+	rv21 = bt_splat_ps(rv22, 1);
+	rv22 = bt_splat_ps(rv22, 2);
+
+	rv20 = _mm_mul_ps(rv20, mv0);
+	rv21 = _mm_mul_ps(rv21, mv1);
+	rv22 = _mm_mul_ps(rv22, mv2);
+
+	rv00 = _mm_add_ps(rv00, rv01);
+	rv10 = _mm_add_ps(rv10, rv11);
+	rv20 = _mm_add_ps(rv20, rv21);
+
+	m_el[0].mVec128 = _mm_add_ps(rv00, rv02);
+	m_el[1].mVec128 = _mm_add_ps(rv10, rv12);
+	m_el[2].mVec128 = _mm_add_ps(rv20, rv22);
+
+#elif defined(BT_USE_NEON)
+
+	float32x4_t rv0, rv1, rv2;
+	float32x4_t v0, v1, v2;
+	float32x4_t mv0, mv1, mv2;
+
+	v0 = m_el[0].mVec128;
+	v1 = m_el[1].mVec128;
+	v2 = m_el[2].mVec128;
+
+	mv0 = (float32x4_t)vandq_s32((int32x4_t)m[0].mVec128, btvFFF0Mask);
+	mv1 = (float32x4_t)vandq_s32((int32x4_t)m[1].mVec128, btvFFF0Mask);
+	mv2 = (float32x4_t)vandq_s32((int32x4_t)m[2].mVec128, btvFFF0Mask);
+
+	rv0 = vmulq_lane_f32(mv0, vget_low_f32(v0), 0);
+	rv1 = vmulq_lane_f32(mv0, vget_low_f32(v1), 0);
+	rv2 = vmulq_lane_f32(mv0, vget_low_f32(v2), 0);
+
+	rv0 = vmlaq_lane_f32(rv0, mv1, vget_low_f32(v0), 1);
+	rv1 = vmlaq_lane_f32(rv1, mv1, vget_low_f32(v1), 1);
+	rv2 = vmlaq_lane_f32(rv2, mv1, vget_low_f32(v2), 1);
+
+	rv0 = vmlaq_lane_f32(rv0, mv2, vget_high_f32(v0), 0);
+	rv1 = vmlaq_lane_f32(rv1, mv2, vget_high_f32(v1), 0);
+	rv2 = vmlaq_lane_f32(rv2, mv2, vget_high_f32(v2), 0);
+
+	m_el[0].mVec128 = rv0;
+	m_el[1].mVec128 = rv1;
+	m_el[2].mVec128 = rv2;
+#else
+	setValue(
+		m.tdotx(m_el[0]), m.tdoty(m_el[0]), m.tdotz(m_el[0]),
+		m.tdotx(m_el[1]), m.tdoty(m_el[1]), m.tdotz(m_el[1]),
+		m.tdotx(m_el[2]), m.tdoty(m_el[2]), m.tdotz(m_el[2]));
+#endif
+	return *this;
+}
+
+SIMD_FORCE_INLINE btMatrix3x3&
+btMatrix3x3::operator+=(const btMatrix3x3& m)
+{
+#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON)
+	m_el[0].mVec128 = m_el[0].mVec128 + m.m_el[0].mVec128;
+	m_el[1].mVec128 = m_el[1].mVec128 + m.m_el[1].mVec128;
+	m_el[2].mVec128 = m_el[2].mVec128 + m.m_el[2].mVec128;
+#else
+	setValue(
+		m_el[0][0] + m.m_el[0][0],
+		m_el[0][1] + m.m_el[0][1],
+		m_el[0][2] + m.m_el[0][2],
+		m_el[1][0] + m.m_el[1][0],
+		m_el[1][1] + m.m_el[1][1],
+		m_el[1][2] + m.m_el[1][2],
+		m_el[2][0] + m.m_el[2][0],
+		m_el[2][1] + m.m_el[2][1],
+		m_el[2][2] + m.m_el[2][2]);
+#endif
+	return *this;
+}
+
+SIMD_FORCE_INLINE btMatrix3x3
+operator*(const btMatrix3x3& m, const btScalar& k)
+{
+#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE))
+	__m128 vk = bt_splat_ps(_mm_load_ss((float*)&k), 0x80);
+	return btMatrix3x3(
+		_mm_mul_ps(m[0].mVec128, vk),
+		_mm_mul_ps(m[1].mVec128, vk),
+		_mm_mul_ps(m[2].mVec128, vk));
+#elif defined(BT_USE_NEON)
+	return btMatrix3x3(
+		vmulq_n_f32(m[0].mVec128, k),
+		vmulq_n_f32(m[1].mVec128, k),
+		vmulq_n_f32(m[2].mVec128, k));
+#else
+	return btMatrix3x3(
+		m[0].x() * k, m[0].y() * k, m[0].z() * k,
+		m[1].x() * k, m[1].y() * k, m[1].z() * k,
+		m[2].x() * k, m[2].y() * k, m[2].z() * k);
+#endif
+}
+
+SIMD_FORCE_INLINE btMatrix3x3
+operator+(const btMatrix3x3& m1, const btMatrix3x3& m2)
+{
+#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON)
+	return btMatrix3x3(
+		m1[0].mVec128 + m2[0].mVec128,
+		m1[1].mVec128 + m2[1].mVec128,
+		m1[2].mVec128 + m2[2].mVec128);
+#else
+	return btMatrix3x3(
+		m1[0][0] + m2[0][0],
+		m1[0][1] + m2[0][1],
+		m1[0][2] + m2[0][2],
+
+		m1[1][0] + m2[1][0],
+		m1[1][1] + m2[1][1],
+		m1[1][2] + m2[1][2],
+
+		m1[2][0] + m2[2][0],
+		m1[2][1] + m2[2][1],
+		m1[2][2] + m2[2][2]);
+#endif
+}
+
+SIMD_FORCE_INLINE btMatrix3x3
+operator-(const btMatrix3x3& m1, const btMatrix3x3& m2)
+{
+#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON)
+	return btMatrix3x3(
+		m1[0].mVec128 - m2[0].mVec128,
+		m1[1].mVec128 - m2[1].mVec128,
+		m1[2].mVec128 - m2[2].mVec128);
+#else
+	return btMatrix3x3(
+		m1[0][0] - m2[0][0],
+		m1[0][1] - m2[0][1],
+		m1[0][2] - m2[0][2],
+
+		m1[1][0] - m2[1][0],
+		m1[1][1] - m2[1][1],
+		m1[1][2] - m2[1][2],
+
+		m1[2][0] - m2[2][0],
+		m1[2][1] - m2[2][1],
+		m1[2][2] - m2[2][2]);
+#endif
+}
+
+SIMD_FORCE_INLINE btMatrix3x3&
+btMatrix3x3::operator-=(const btMatrix3x3& m)
+{
+#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON)
+	m_el[0].mVec128 = m_el[0].mVec128 - m.m_el[0].mVec128;
+	m_el[1].mVec128 = m_el[1].mVec128 - m.m_el[1].mVec128;
+	m_el[2].mVec128 = m_el[2].mVec128 - m.m_el[2].mVec128;
+#else
+	setValue(
+		m_el[0][0] - m.m_el[0][0],
+		m_el[0][1] - m.m_el[0][1],
+		m_el[0][2] - m.m_el[0][2],
+		m_el[1][0] - m.m_el[1][0],
+		m_el[1][1] - m.m_el[1][1],
+		m_el[1][2] - m.m_el[1][2],
+		m_el[2][0] - m.m_el[2][0],
+		m_el[2][1] - m.m_el[2][1],
+		m_el[2][2] - m.m_el[2][2]);
+#endif
+	return *this;
+}
+
+SIMD_FORCE_INLINE btScalar
+btMatrix3x3::determinant() const
+{
+	return btTriple((*this)[0], (*this)[1], (*this)[2]);
+}
+
+SIMD_FORCE_INLINE btMatrix3x3
+btMatrix3x3::absolute() const
+{
+#if defined BT_USE_SIMD_VECTOR3 && (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE))
+	return btMatrix3x3(
+		_mm_and_ps(m_el[0].mVec128, btvAbsfMask),
+		_mm_and_ps(m_el[1].mVec128, btvAbsfMask),
+		_mm_and_ps(m_el[2].mVec128, btvAbsfMask));
+#elif defined(BT_USE_NEON)
+	return btMatrix3x3(
+		(float32x4_t)vandq_s32((int32x4_t)m_el[0].mVec128, btv3AbsMask),
+		(float32x4_t)vandq_s32((int32x4_t)m_el[1].mVec128, btv3AbsMask),
+		(float32x4_t)vandq_s32((int32x4_t)m_el[2].mVec128, btv3AbsMask));
+#else
+	return btMatrix3x3(
+		btFabs(m_el[0].x()), btFabs(m_el[0].y()), btFabs(m_el[0].z()),
+		btFabs(m_el[1].x()), btFabs(m_el[1].y()), btFabs(m_el[1].z()),
+		btFabs(m_el[2].x()), btFabs(m_el[2].y()), btFabs(m_el[2].z()));
+#endif
+}
+
+SIMD_FORCE_INLINE btMatrix3x3
+btMatrix3x3::transpose() const
+{
+#if defined BT_USE_SIMD_VECTOR3 && (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE))
+	__m128 v0 = m_el[0].mVec128;
+	__m128 v1 = m_el[1].mVec128;
+	__m128 v2 = m_el[2].mVec128;  //  x2 y2 z2 w2
+	__m128 vT;
+
+	v2 = _mm_and_ps(v2, btvFFF0fMask);  //  x2 y2 z2 0
+
+	vT = _mm_unpackhi_ps(v0, v1);  //	z0 z1 * *
+	v0 = _mm_unpacklo_ps(v0, v1);  //	x0 x1 y0 y1
+
+	v1 = _mm_shuffle_ps(v0, v2, BT_SHUFFLE(2, 3, 1, 3));                    // y0 y1 y2 0
+	v0 = _mm_shuffle_ps(v0, v2, BT_SHUFFLE(0, 1, 0, 3));                    // x0 x1 x2 0
+	v2 = btCastdTo128f(_mm_move_sd(btCastfTo128d(v2), btCastfTo128d(vT)));  // z0 z1 z2 0
+
+	return btMatrix3x3(v0, v1, v2);
+#elif defined(BT_USE_NEON)
+	// note: zeros the w channel. We can preserve it at the cost of two more vtrn instructions.
+	static const uint32x2_t zMask = (const uint32x2_t){static_cast<uint32_t>(-1), 0};
+	float32x4x2_t top = vtrnq_f32(m_el[0].mVec128, m_el[1].mVec128);               // {x0 x1 z0 z1}, {y0 y1 w0 w1}
+	float32x2x2_t bl = vtrn_f32(vget_low_f32(m_el[2].mVec128), vdup_n_f32(0.0f));  // {x2  0 }, {y2 0}
+	float32x4_t v0 = vcombine_f32(vget_low_f32(top.val[0]), bl.val[0]);
+	float32x4_t v1 = vcombine_f32(vget_low_f32(top.val[1]), bl.val[1]);
+	float32x2_t q = (float32x2_t)vand_u32((uint32x2_t)vget_high_f32(m_el[2].mVec128), zMask);
+	float32x4_t v2 = vcombine_f32(vget_high_f32(top.val[0]), q);  // z0 z1 z2  0
+	return btMatrix3x3(v0, v1, v2);
+#else
+	return btMatrix3x3(m_el[0].x(), m_el[1].x(), m_el[2].x(),
+					   m_el[0].y(), m_el[1].y(), m_el[2].y(),
+					   m_el[0].z(), m_el[1].z(), m_el[2].z());
+#endif
+}
+
+SIMD_FORCE_INLINE btMatrix3x3
+btMatrix3x3::adjoint() const
+{
+	return btMatrix3x3(cofac(1, 1, 2, 2), cofac(0, 2, 2, 1), cofac(0, 1, 1, 2),
+					   cofac(1, 2, 2, 0), cofac(0, 0, 2, 2), cofac(0, 2, 1, 0),
+					   cofac(1, 0, 2, 1), cofac(0, 1, 2, 0), cofac(0, 0, 1, 1));
+}
+
+SIMD_FORCE_INLINE btMatrix3x3
+btMatrix3x3::inverse() const
+{
+	btVector3 co(cofac(1, 1, 2, 2), cofac(1, 2, 2, 0), cofac(1, 0, 2, 1));
+	btScalar det = (*this)[0].dot(co);
+	//btFullAssert(det != btScalar(0.0));
+	btAssert(det != btScalar(0.0));
+	btScalar s = btScalar(1.0) / det;
+	return btMatrix3x3(co.x() * s, cofac(0, 2, 2, 1) * s, cofac(0, 1, 1, 2) * s,
+					   co.y() * s, cofac(0, 0, 2, 2) * s, cofac(0, 2, 1, 0) * s,
+					   co.z() * s, cofac(0, 1, 2, 0) * s, cofac(0, 0, 1, 1) * s);
+}
+
+SIMD_FORCE_INLINE btMatrix3x3
+btMatrix3x3::transposeTimes(const btMatrix3x3& m) const
+{
+#if defined BT_USE_SIMD_VECTOR3 && (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE))
+	// zeros w
+	//    static const __m128i xyzMask = (const __m128i){ -1ULL, 0xffffffffULL };
+	__m128 row = m_el[0].mVec128;
+	__m128 m0 = _mm_and_ps(m.getRow(0).mVec128, btvFFF0fMask);
+	__m128 m1 = _mm_and_ps(m.getRow(1).mVec128, btvFFF0fMask);
+	__m128 m2 = _mm_and_ps(m.getRow(2).mVec128, btvFFF0fMask);
+	__m128 r0 = _mm_mul_ps(m0, _mm_shuffle_ps(row, row, 0));
+	__m128 r1 = _mm_mul_ps(m0, _mm_shuffle_ps(row, row, 0x55));
+	__m128 r2 = _mm_mul_ps(m0, _mm_shuffle_ps(row, row, 0xaa));
+	row = m_el[1].mVec128;
+	r0 = _mm_add_ps(r0, _mm_mul_ps(m1, _mm_shuffle_ps(row, row, 0)));
+	r1 = _mm_add_ps(r1, _mm_mul_ps(m1, _mm_shuffle_ps(row, row, 0x55)));
+	r2 = _mm_add_ps(r2, _mm_mul_ps(m1, _mm_shuffle_ps(row, row, 0xaa)));
+	row = m_el[2].mVec128;
+	r0 = _mm_add_ps(r0, _mm_mul_ps(m2, _mm_shuffle_ps(row, row, 0)));
+	r1 = _mm_add_ps(r1, _mm_mul_ps(m2, _mm_shuffle_ps(row, row, 0x55)));
+	r2 = _mm_add_ps(r2, _mm_mul_ps(m2, _mm_shuffle_ps(row, row, 0xaa)));
+	return btMatrix3x3(r0, r1, r2);
+
+#elif defined BT_USE_NEON
+	// zeros w
+	static const uint32x4_t xyzMask = (const uint32x4_t){static_cast<uint32_t>(-1), static_cast<uint32_t>(-1), static_cast<uint32_t>(-1), 0};
+	float32x4_t m0 = (float32x4_t)vandq_u32((uint32x4_t)m.getRow(0).mVec128, xyzMask);
+	float32x4_t m1 = (float32x4_t)vandq_u32((uint32x4_t)m.getRow(1).mVec128, xyzMask);
+	float32x4_t m2 = (float32x4_t)vandq_u32((uint32x4_t)m.getRow(2).mVec128, xyzMask);
+	float32x4_t row = m_el[0].mVec128;
+	float32x4_t r0 = vmulq_lane_f32(m0, vget_low_f32(row), 0);
+	float32x4_t r1 = vmulq_lane_f32(m0, vget_low_f32(row), 1);
+	float32x4_t r2 = vmulq_lane_f32(m0, vget_high_f32(row), 0);
+	row = m_el[1].mVec128;
+	r0 = vmlaq_lane_f32(r0, m1, vget_low_f32(row), 0);
+	r1 = vmlaq_lane_f32(r1, m1, vget_low_f32(row), 1);
+	r2 = vmlaq_lane_f32(r2, m1, vget_high_f32(row), 0);
+	row = m_el[2].mVec128;
+	r0 = vmlaq_lane_f32(r0, m2, vget_low_f32(row), 0);
+	r1 = vmlaq_lane_f32(r1, m2, vget_low_f32(row), 1);
+	r2 = vmlaq_lane_f32(r2, m2, vget_high_f32(row), 0);
+	return btMatrix3x3(r0, r1, r2);
+#else
+	return btMatrix3x3(
+		m_el[0].x() * m[0].x() + m_el[1].x() * m[1].x() + m_el[2].x() * m[2].x(),
+		m_el[0].x() * m[0].y() + m_el[1].x() * m[1].y() + m_el[2].x() * m[2].y(),
+		m_el[0].x() * m[0].z() + m_el[1].x() * m[1].z() + m_el[2].x() * m[2].z(),
+		m_el[0].y() * m[0].x() + m_el[1].y() * m[1].x() + m_el[2].y() * m[2].x(),
+		m_el[0].y() * m[0].y() + m_el[1].y() * m[1].y() + m_el[2].y() * m[2].y(),
+		m_el[0].y() * m[0].z() + m_el[1].y() * m[1].z() + m_el[2].y() * m[2].z(),
+		m_el[0].z() * m[0].x() + m_el[1].z() * m[1].x() + m_el[2].z() * m[2].x(),
+		m_el[0].z() * m[0].y() + m_el[1].z() * m[1].y() + m_el[2].z() * m[2].y(),
+		m_el[0].z() * m[0].z() + m_el[1].z() * m[1].z() + m_el[2].z() * m[2].z());
+#endif
+}
+
+SIMD_FORCE_INLINE btMatrix3x3
+btMatrix3x3::timesTranspose(const btMatrix3x3& m) const
+{
+#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE))
+	__m128 a0 = m_el[0].mVec128;
+	__m128 a1 = m_el[1].mVec128;
+	__m128 a2 = m_el[2].mVec128;
+
+	btMatrix3x3 mT = m.transpose();  // we rely on transpose() zeroing w channel so that we don't have to do it here
+	__m128 mx = mT[0].mVec128;
+	__m128 my = mT[1].mVec128;
+	__m128 mz = mT[2].mVec128;
+
+	__m128 r0 = _mm_mul_ps(mx, _mm_shuffle_ps(a0, a0, 0x00));
+	__m128 r1 = _mm_mul_ps(mx, _mm_shuffle_ps(a1, a1, 0x00));
+	__m128 r2 = _mm_mul_ps(mx, _mm_shuffle_ps(a2, a2, 0x00));
+	r0 = _mm_add_ps(r0, _mm_mul_ps(my, _mm_shuffle_ps(a0, a0, 0x55)));
+	r1 = _mm_add_ps(r1, _mm_mul_ps(my, _mm_shuffle_ps(a1, a1, 0x55)));
+	r2 = _mm_add_ps(r2, _mm_mul_ps(my, _mm_shuffle_ps(a2, a2, 0x55)));
+	r0 = _mm_add_ps(r0, _mm_mul_ps(mz, _mm_shuffle_ps(a0, a0, 0xaa)));
+	r1 = _mm_add_ps(r1, _mm_mul_ps(mz, _mm_shuffle_ps(a1, a1, 0xaa)));
+	r2 = _mm_add_ps(r2, _mm_mul_ps(mz, _mm_shuffle_ps(a2, a2, 0xaa)));
+	return btMatrix3x3(r0, r1, r2);
+
+#elif defined BT_USE_NEON
+	float32x4_t a0 = m_el[0].mVec128;
+	float32x4_t a1 = m_el[1].mVec128;
+	float32x4_t a2 = m_el[2].mVec128;
+
+	btMatrix3x3 mT = m.transpose();  // we rely on transpose() zeroing w channel so that we don't have to do it here
+	float32x4_t mx = mT[0].mVec128;
+	float32x4_t my = mT[1].mVec128;
+	float32x4_t mz = mT[2].mVec128;
+
+	float32x4_t r0 = vmulq_lane_f32(mx, vget_low_f32(a0), 0);
+	float32x4_t r1 = vmulq_lane_f32(mx, vget_low_f32(a1), 0);
+	float32x4_t r2 = vmulq_lane_f32(mx, vget_low_f32(a2), 0);
+	r0 = vmlaq_lane_f32(r0, my, vget_low_f32(a0), 1);
+	r1 = vmlaq_lane_f32(r1, my, vget_low_f32(a1), 1);
+	r2 = vmlaq_lane_f32(r2, my, vget_low_f32(a2), 1);
+	r0 = vmlaq_lane_f32(r0, mz, vget_high_f32(a0), 0);
+	r1 = vmlaq_lane_f32(r1, mz, vget_high_f32(a1), 0);
+	r2 = vmlaq_lane_f32(r2, mz, vget_high_f32(a2), 0);
+	return btMatrix3x3(r0, r1, r2);
+
+#else
+	return btMatrix3x3(
+		m_el[0].dot(m[0]), m_el[0].dot(m[1]), m_el[0].dot(m[2]),
+		m_el[1].dot(m[0]), m_el[1].dot(m[1]), m_el[1].dot(m[2]),
+		m_el[2].dot(m[0]), m_el[2].dot(m[1]), m_el[2].dot(m[2]));
+#endif
+}
+
+SIMD_FORCE_INLINE btVector3
+operator*(const btMatrix3x3& m, const btVector3& v)
+{
+#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON)
+	return v.dot3(m[0], m[1], m[2]);
+#else
+	return btVector3(m[0].dot(v), m[1].dot(v), m[2].dot(v));
+#endif
+}
+
+SIMD_FORCE_INLINE btVector3
+operator*(const btVector3& v, const btMatrix3x3& m)
+{
+#if defined BT_USE_SIMD_VECTOR3 && (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE))
+
+	const __m128 vv = v.mVec128;
+
+	__m128 c0 = bt_splat_ps(vv, 0);
+	__m128 c1 = bt_splat_ps(vv, 1);
+	__m128 c2 = bt_splat_ps(vv, 2);
+
+	c0 = _mm_mul_ps(c0, _mm_and_ps(m[0].mVec128, btvFFF0fMask));
+	c1 = _mm_mul_ps(c1, _mm_and_ps(m[1].mVec128, btvFFF0fMask));
+	c0 = _mm_add_ps(c0, c1);
+	c2 = _mm_mul_ps(c2, _mm_and_ps(m[2].mVec128, btvFFF0fMask));
+
+	return btVector3(_mm_add_ps(c0, c2));
+#elif defined(BT_USE_NEON)
+	const float32x4_t vv = v.mVec128;
+	const float32x2_t vlo = vget_low_f32(vv);
+	const float32x2_t vhi = vget_high_f32(vv);
+
+	float32x4_t c0, c1, c2;
+
+	c0 = (float32x4_t)vandq_s32((int32x4_t)m[0].mVec128, btvFFF0Mask);
+	c1 = (float32x4_t)vandq_s32((int32x4_t)m[1].mVec128, btvFFF0Mask);
+	c2 = (float32x4_t)vandq_s32((int32x4_t)m[2].mVec128, btvFFF0Mask);
+
+	c0 = vmulq_lane_f32(c0, vlo, 0);
+	c1 = vmulq_lane_f32(c1, vlo, 1);
+	c2 = vmulq_lane_f32(c2, vhi, 0);
+	c0 = vaddq_f32(c0, c1);
+	c0 = vaddq_f32(c0, c2);
+
+	return btVector3(c0);
+#else
+	return btVector3(m.tdotx(v), m.tdoty(v), m.tdotz(v));
+#endif
+}
+
+SIMD_FORCE_INLINE btMatrix3x3
+operator*(const btMatrix3x3& m1, const btMatrix3x3& m2)
+{
+#if defined BT_USE_SIMD_VECTOR3 && (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE))
+
+	__m128 m10 = m1[0].mVec128;
+	__m128 m11 = m1[1].mVec128;
+	__m128 m12 = m1[2].mVec128;
+
+	__m128 m2v = _mm_and_ps(m2[0].mVec128, btvFFF0fMask);
+
+	__m128 c0 = bt_splat_ps(m10, 0);
+	__m128 c1 = bt_splat_ps(m11, 0);
+	__m128 c2 = bt_splat_ps(m12, 0);
+
+	c0 = _mm_mul_ps(c0, m2v);
+	c1 = _mm_mul_ps(c1, m2v);
+	c2 = _mm_mul_ps(c2, m2v);
+
+	m2v = _mm_and_ps(m2[1].mVec128, btvFFF0fMask);
+
+	__m128 c0_1 = bt_splat_ps(m10, 1);
+	__m128 c1_1 = bt_splat_ps(m11, 1);
+	__m128 c2_1 = bt_splat_ps(m12, 1);
+
+	c0_1 = _mm_mul_ps(c0_1, m2v);
+	c1_1 = _mm_mul_ps(c1_1, m2v);
+	c2_1 = _mm_mul_ps(c2_1, m2v);
+
+	m2v = _mm_and_ps(m2[2].mVec128, btvFFF0fMask);
+
+	c0 = _mm_add_ps(c0, c0_1);
+	c1 = _mm_add_ps(c1, c1_1);
+	c2 = _mm_add_ps(c2, c2_1);
+
+	m10 = bt_splat_ps(m10, 2);
+	m11 = bt_splat_ps(m11, 2);
+	m12 = bt_splat_ps(m12, 2);
+
+	m10 = _mm_mul_ps(m10, m2v);
+	m11 = _mm_mul_ps(m11, m2v);
+	m12 = _mm_mul_ps(m12, m2v);
+
+	c0 = _mm_add_ps(c0, m10);
+	c1 = _mm_add_ps(c1, m11);
+	c2 = _mm_add_ps(c2, m12);
+
+	return btMatrix3x3(c0, c1, c2);
+
+#elif defined(BT_USE_NEON)
+
+	float32x4_t rv0, rv1, rv2;
+	float32x4_t v0, v1, v2;
+	float32x4_t mv0, mv1, mv2;
+
+	v0 = m1[0].mVec128;
+	v1 = m1[1].mVec128;
+	v2 = m1[2].mVec128;
+
+	mv0 = (float32x4_t)vandq_s32((int32x4_t)m2[0].mVec128, btvFFF0Mask);
+	mv1 = (float32x4_t)vandq_s32((int32x4_t)m2[1].mVec128, btvFFF0Mask);
+	mv2 = (float32x4_t)vandq_s32((int32x4_t)m2[2].mVec128, btvFFF0Mask);
+
+	rv0 = vmulq_lane_f32(mv0, vget_low_f32(v0), 0);
+	rv1 = vmulq_lane_f32(mv0, vget_low_f32(v1), 0);
+	rv2 = vmulq_lane_f32(mv0, vget_low_f32(v2), 0);
+
+	rv0 = vmlaq_lane_f32(rv0, mv1, vget_low_f32(v0), 1);
+	rv1 = vmlaq_lane_f32(rv1, mv1, vget_low_f32(v1), 1);
+	rv2 = vmlaq_lane_f32(rv2, mv1, vget_low_f32(v2), 1);
+
+	rv0 = vmlaq_lane_f32(rv0, mv2, vget_high_f32(v0), 0);
+	rv1 = vmlaq_lane_f32(rv1, mv2, vget_high_f32(v1), 0);
+	rv2 = vmlaq_lane_f32(rv2, mv2, vget_high_f32(v2), 0);
+
+	return btMatrix3x3(rv0, rv1, rv2);
+
+#else
+	return btMatrix3x3(
+		m2.tdotx(m1[0]), m2.tdoty(m1[0]), m2.tdotz(m1[0]),
+		m2.tdotx(m1[1]), m2.tdoty(m1[1]), m2.tdotz(m1[1]),
+		m2.tdotx(m1[2]), m2.tdoty(m1[2]), m2.tdotz(m1[2]));
+#endif
+}
+
+/*
+SIMD_FORCE_INLINE btMatrix3x3 btMultTransposeLeft(const btMatrix3x3& m1, const btMatrix3x3& m2) {
+return btMatrix3x3(
+m1[0][0] * m2[0][0] + m1[1][0] * m2[1][0] + m1[2][0] * m2[2][0],
+m1[0][0] * m2[0][1] + m1[1][0] * m2[1][1] + m1[2][0] * m2[2][1],
+m1[0][0] * m2[0][2] + m1[1][0] * m2[1][2] + m1[2][0] * m2[2][2],
+m1[0][1] * m2[0][0] + m1[1][1] * m2[1][0] + m1[2][1] * m2[2][0],
+m1[0][1] * m2[0][1] + m1[1][1] * m2[1][1] + m1[2][1] * m2[2][1],
+m1[0][1] * m2[0][2] + m1[1][1] * m2[1][2] + m1[2][1] * m2[2][2],
+m1[0][2] * m2[0][0] + m1[1][2] * m2[1][0] + m1[2][2] * m2[2][0],
+m1[0][2] * m2[0][1] + m1[1][2] * m2[1][1] + m1[2][2] * m2[2][1],
+m1[0][2] * m2[0][2] + m1[1][2] * m2[1][2] + m1[2][2] * m2[2][2]);
+}
+*/
+
+/**@brief Equality operator between two matrices
+* It will test all elements are equal.  */
+SIMD_FORCE_INLINE bool operator==(const btMatrix3x3& m1, const btMatrix3x3& m2)
+{
+#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE))
+
+	__m128 c0, c1, c2;
+
+	c0 = _mm_cmpeq_ps(m1[0].mVec128, m2[0].mVec128);
+	c1 = _mm_cmpeq_ps(m1[1].mVec128, m2[1].mVec128);
+	c2 = _mm_cmpeq_ps(m1[2].mVec128, m2[2].mVec128);
+
+	c0 = _mm_and_ps(c0, c1);
+	c0 = _mm_and_ps(c0, c2);
+
+	int m = _mm_movemask_ps((__m128)c0);
+	return (0x7 == (m & 0x7));
+
+#else
+	return (m1[0][0] == m2[0][0] && m1[1][0] == m2[1][0] && m1[2][0] == m2[2][0] &&
+			m1[0][1] == m2[0][1] && m1[1][1] == m2[1][1] && m1[2][1] == m2[2][1] &&
+			m1[0][2] == m2[0][2] && m1[1][2] == m2[1][2] && m1[2][2] == m2[2][2]);
+#endif
+}
+
+///for serialization
+struct btMatrix3x3FloatData
+{
+	btVector3FloatData m_el[3];
+};
+
+///for serialization
+struct btMatrix3x3DoubleData
+{
+	btVector3DoubleData m_el[3];
+};
+
+SIMD_FORCE_INLINE void btMatrix3x3::serialize(struct btMatrix3x3Data& dataOut) const
+{
+	for (int i = 0; i < 3; i++)
+		m_el[i].serialize(dataOut.m_el[i]);
+}
+
+SIMD_FORCE_INLINE void btMatrix3x3::serializeFloat(struct btMatrix3x3FloatData& dataOut) const
+{
+	for (int i = 0; i < 3; i++)
+		m_el[i].serializeFloat(dataOut.m_el[i]);
+}
+
+SIMD_FORCE_INLINE void btMatrix3x3::deSerialize(const struct btMatrix3x3Data& dataIn)
+{
+	for (int i = 0; i < 3; i++)
+		m_el[i].deSerialize(dataIn.m_el[i]);
+}
+
+SIMD_FORCE_INLINE void btMatrix3x3::deSerializeFloat(const struct btMatrix3x3FloatData& dataIn)
+{
+	for (int i = 0; i < 3; i++)
+		m_el[i].deSerializeFloat(dataIn.m_el[i]);
+}
+
+SIMD_FORCE_INLINE void btMatrix3x3::deSerializeDouble(const struct btMatrix3x3DoubleData& dataIn)
+{
+	for (int i = 0; i < 3; i++)
+		m_el[i].deSerializeDouble(dataIn.m_el[i]);
+}
+
+#endif  //BT_MATRIX3x3_H
diff --git a/engine/inc/bullet/LinearMath/btMatrixX.h b/engine/inc/bullet/LinearMath/btMatrixX.h
new file mode 100644
index 00000000..bb0f0dd2
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btMatrixX.h
@@ -0,0 +1,532 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+///original version written by Erwin Coumans, October 2013
+
+#ifndef BT_MATRIX_X_H
+#define BT_MATRIX_X_H
+
+#include "LinearMath/btQuickprof.h"
+#include "LinearMath/btAlignedObjectArray.h"
+#include <stdio.h>
+
+//#define BT_DEBUG_OSTREAM
+#ifdef BT_DEBUG_OSTREAM
+#include <iostream>
+#include <iomanip>  // std::setw
+#endif              //BT_DEBUG_OSTREAM
+
+class btIntSortPredicate
+{
+public:
+	bool operator()(const int& a, const int& b) const
+	{
+		return a < b;
+	}
+};
+
+template <typename T>
+struct btVectorX
+{
+	btAlignedObjectArray<T> m_storage;
+
+	btVectorX()
+	{
+	}
+	btVectorX(int numRows)
+	{
+		m_storage.resize(numRows);
+	}
+
+	void resize(int rows)
+	{
+		m_storage.resize(rows);
+	}
+	int cols() const
+	{
+		return 1;
+	}
+	int rows() const
+	{
+		return m_storage.size();
+	}
+	int size() const
+	{
+		return rows();
+	}
+
+	T nrm2() const
+	{
+		T norm = T(0);
+
+		int nn = rows();
+
+		{
+			if (nn == 1)
+			{
+				norm = btFabs((*this)[0]);
+			}
+			else
+			{
+				T scale = 0.0;
+				T ssq = 1.0;
+
+				/* The following loop is equivalent to this call to the LAPACK
+				 auxiliary routine:   CALL SLASSQ( N, X, INCX, SCALE, SSQ ) */
+
+				for (int ix = 0; ix < nn; ix++)
+				{
+					if ((*this)[ix] != 0.0)
+					{
+						T absxi = btFabs((*this)[ix]);
+						if (scale < absxi)
+						{
+							T temp;
+							temp = scale / absxi;
+							ssq = ssq * (temp * temp) + BT_ONE;
+							scale = absxi;
+						}
+						else
+						{
+							T temp;
+							temp = absxi / scale;
+							ssq += temp * temp;
+						}
+					}
+				}
+				norm = scale * sqrt(ssq);
+			}
+		}
+		return norm;
+	}
+	void setZero()
+	{
+		if (m_storage.size())
+		{
+			//	for (int i=0;i<m_storage.size();i++)
+			//		m_storage[i]=0;
+			//memset(&m_storage[0],0,sizeof(T)*m_storage.size());
+			btSetZero(&m_storage[0], m_storage.size());
+		}
+	}
+	const T& operator[](int index) const
+	{
+		return m_storage[index];
+	}
+
+	T& operator[](int index)
+	{
+		return m_storage[index];
+	}
+
+	T* getBufferPointerWritable()
+	{
+		return m_storage.size() ? &m_storage[0] : 0;
+	}
+
+	const T* getBufferPointer() const
+	{
+		return m_storage.size() ? &m_storage[0] : 0;
+	}
+};
+/*
+ template <typename T>
+ void setElem(btMatrixX<T>& mat, int row, int col, T val)
+ {
+ mat.setElem(row,col,val);
+ }
+ */
+
+template <typename T>
+struct btMatrixX
+{
+	int m_rows;
+	int m_cols;
+	int m_operations;
+	int m_resizeOperations;
+	int m_setElemOperations;
+
+	btAlignedObjectArray<T> m_storage;
+	mutable btAlignedObjectArray<btAlignedObjectArray<int> > m_rowNonZeroElements1;
+
+	T* getBufferPointerWritable()
+	{
+		return m_storage.size() ? &m_storage[0] : 0;
+	}
+
+	const T* getBufferPointer() const
+	{
+		return m_storage.size() ? &m_storage[0] : 0;
+	}
+	btMatrixX()
+		: m_rows(0),
+		  m_cols(0),
+		  m_operations(0),
+		  m_resizeOperations(0),
+		  m_setElemOperations(0)
+	{
+	}
+	btMatrixX(int rows, int cols)
+		: m_rows(rows),
+		  m_cols(cols),
+		  m_operations(0),
+		  m_resizeOperations(0),
+		  m_setElemOperations(0)
+	{
+		resize(rows, cols);
+	}
+	void resize(int rows, int cols)
+	{
+		m_resizeOperations++;
+		m_rows = rows;
+		m_cols = cols;
+		{
+			BT_PROFILE("m_storage.resize");
+			m_storage.resize(rows * cols);
+		}
+	}
+	int cols() const
+	{
+		return m_cols;
+	}
+	int rows() const
+	{
+		return m_rows;
+	}
+	///we don't want this read/write operator(), because we cannot keep track of non-zero elements, use setElem instead
+	/*T& operator() (int row,int col)
+	{
+		return m_storage[col*m_rows+row];
+	}
+	*/
+
+	void addElem(int row, int col, T val)
+	{
+		if (val)
+		{
+			if (m_storage[col + row * m_cols] == 0.f)
+			{
+				setElem(row, col, val);
+			}
+			else
+			{
+				m_storage[row * m_cols + col] += val;
+			}
+		}
+	}
+
+	void setElem(int row, int col, T val)
+	{
+		m_setElemOperations++;
+		m_storage[row * m_cols + col] = val;
+	}
+
+	void mulElem(int row, int col, T val)
+	{
+		m_setElemOperations++;
+		//mul doesn't change sparsity info
+
+		m_storage[row * m_cols + col] *= val;
+	}
+
+	void copyLowerToUpperTriangle()
+	{
+		int count = 0;
+		for (int row = 0; row < rows(); row++)
+		{
+			for (int col = 0; col < row; col++)
+			{
+				setElem(col, row, (*this)(row, col));
+				count++;
+			}
+		}
+		//printf("copyLowerToUpperTriangle copied %d elements out of %dx%d=%d\n", count,rows(),cols(),cols()*rows());
+	}
+
+	const T& operator()(int row, int col) const
+	{
+		return m_storage[col + row * m_cols];
+	}
+
+	void setZero()
+	{
+		{
+			BT_PROFILE("storage=0");
+			if (m_storage.size())
+			{
+				btSetZero(&m_storage[0], m_storage.size());
+			}
+			//memset(&m_storage[0],0,sizeof(T)*m_storage.size());
+			//for (int i=0;i<m_storage.size();i++)
+			//			m_storage[i]=0;
+		}
+	}
+
+	void setIdentity()
+	{
+		btAssert(rows() == cols());
+
+		setZero();
+		for (int row = 0; row < rows(); row++)
+		{
+			setElem(row, row, 1);
+		}
+	}
+
+	void printMatrix(const char* msg) const
+	{
+		printf("%s ---------------------\n", msg);
+		for (int i = 0; i < rows(); i++)
+		{
+			printf("\n");
+			for (int j = 0; j < cols(); j++)
+			{
+				printf("%2.1f\t", (*this)(i, j));
+			}
+		}
+		printf("\n---------------------\n");
+	}
+
+	void rowComputeNonZeroElements() const
+	{
+		m_rowNonZeroElements1.resize(rows());
+		for (int i = 0; i < rows(); i++)
+		{
+			m_rowNonZeroElements1[i].resize(0);
+			for (int j = 0; j < cols(); j++)
+			{
+				if ((*this)(i, j) != 0.f)
+				{
+					m_rowNonZeroElements1[i].push_back(j);
+				}
+			}
+		}
+	}
+	btMatrixX transpose() const
+	{
+		//transpose is optimized for sparse matrices
+		btMatrixX tr(m_cols, m_rows);
+		tr.setZero();
+		for (int i = 0; i < m_cols; i++)
+			for (int j = 0; j < m_rows; j++)
+			{
+				T v = (*this)(j, i);
+				if (v)
+				{
+					tr.setElem(i, j, v);
+				}
+			}
+		return tr;
+	}
+
+	btMatrixX operator*(const btMatrixX& other)
+	{
+		//btMatrixX*btMatrixX implementation, brute force
+		btAssert(cols() == other.rows());
+
+		btMatrixX res(rows(), other.cols());
+		res.setZero();
+		//		BT_PROFILE("btMatrixX mul");
+		for (int i = 0; i < rows(); ++i)
+		{
+			{
+				for (int j = 0; j < other.cols(); ++j)
+				{
+					T dotProd = 0;
+					{
+						{
+							int c = cols();
+
+							for (int k = 0; k < c; k++)
+							{
+								T w = (*this)(i, k);
+								if (other(k, j) != 0.f)
+								{
+									dotProd += w * other(k, j);
+								}
+							}
+						}
+					}
+					if (dotProd)
+						res.setElem(i, j, dotProd);
+				}
+			}
+		}
+		return res;
+	}
+
+	// this assumes the 4th and 8th rows of B and C are zero.
+	void multiplyAdd2_p8r(const btScalar* B, const btScalar* C, int numRows, int numRowsOther, int row, int col)
+	{
+		const btScalar* bb = B;
+		for (int i = 0; i < numRows; i++)
+		{
+			const btScalar* cc = C;
+			for (int j = 0; j < numRowsOther; j++)
+			{
+				btScalar sum;
+				sum = bb[0] * cc[0];
+				sum += bb[1] * cc[1];
+				sum += bb[2] * cc[2];
+				sum += bb[4] * cc[4];
+				sum += bb[5] * cc[5];
+				sum += bb[6] * cc[6];
+				addElem(row + i, col + j, sum);
+				cc += 8;
+			}
+			bb += 8;
+		}
+	}
+
+	void multiply2_p8r(const btScalar* B, const btScalar* C, int numRows, int numRowsOther, int row, int col)
+	{
+		btAssert(numRows > 0 && numRowsOther > 0 && B && C);
+		const btScalar* bb = B;
+		for (int i = 0; i < numRows; i++)
+		{
+			const btScalar* cc = C;
+			for (int j = 0; j < numRowsOther; j++)
+			{
+				btScalar sum;
+				sum = bb[0] * cc[0];
+				sum += bb[1] * cc[1];
+				sum += bb[2] * cc[2];
+				sum += bb[4] * cc[4];
+				sum += bb[5] * cc[5];
+				sum += bb[6] * cc[6];
+				setElem(row + i, col + j, sum);
+				cc += 8;
+			}
+			bb += 8;
+		}
+	}
+
+	void setSubMatrix(int rowstart, int colstart, int rowend, int colend, const T value)
+	{
+		int numRows = rowend + 1 - rowstart;
+		int numCols = colend + 1 - colstart;
+
+		for (int row = 0; row < numRows; row++)
+		{
+			for (int col = 0; col < numCols; col++)
+			{
+				setElem(rowstart + row, colstart + col, value);
+			}
+		}
+	}
+
+	void setSubMatrix(int rowstart, int colstart, int rowend, int colend, const btMatrixX& block)
+	{
+		btAssert(rowend + 1 - rowstart == block.rows());
+		btAssert(colend + 1 - colstart == block.cols());
+		for (int row = 0; row < block.rows(); row++)
+		{
+			for (int col = 0; col < block.cols(); col++)
+			{
+				setElem(rowstart + row, colstart + col, block(row, col));
+			}
+		}
+	}
+	void setSubMatrix(int rowstart, int colstart, int rowend, int colend, const btVectorX<T>& block)
+	{
+		btAssert(rowend + 1 - rowstart == block.rows());
+		btAssert(colend + 1 - colstart == block.cols());
+		for (int row = 0; row < block.rows(); row++)
+		{
+			for (int col = 0; col < block.cols(); col++)
+			{
+				setElem(rowstart + row, colstart + col, block[row]);
+			}
+		}
+	}
+
+	btMatrixX negative()
+	{
+		btMatrixX neg(rows(), cols());
+		for (int i = 0; i < rows(); i++)
+			for (int j = 0; j < cols(); j++)
+			{
+				T v = (*this)(i, j);
+				neg.setElem(i, j, -v);
+			}
+		return neg;
+	}
+};
+
+typedef btMatrixX<float> btMatrixXf;
+typedef btVectorX<float> btVectorXf;
+
+typedef btMatrixX<double> btMatrixXd;
+typedef btVectorX<double> btVectorXd;
+
+#ifdef BT_DEBUG_OSTREAM
+template <typename T>
+std::ostream& operator<<(std::ostream& os, const btMatrixX<T>& mat)
+{
+	os << " [";
+	//printf("%s ---------------------\n",msg);
+	for (int i = 0; i < mat.rows(); i++)
+	{
+		for (int j = 0; j < mat.cols(); j++)
+		{
+			os << std::setw(12) << mat(i, j);
+		}
+		if (i != mat.rows() - 1)
+			os << std::endl
+			   << "  ";
+	}
+	os << " ]";
+	//printf("\n---------------------\n");
+
+	return os;
+}
+template <typename T>
+std::ostream& operator<<(std::ostream& os, const btVectorX<T>& mat)
+{
+	os << " [";
+	//printf("%s ---------------------\n",msg);
+	for (int i = 0; i < mat.rows(); i++)
+	{
+		os << std::setw(12) << mat[i];
+		if (i != mat.rows() - 1)
+			os << std::endl
+			   << "  ";
+	}
+	os << " ]";
+	//printf("\n---------------------\n");
+
+	return os;
+}
+
+#endif  //BT_DEBUG_OSTREAM
+
+inline void setElem(btMatrixXd& mat, int row, int col, double val)
+{
+	mat.setElem(row, col, val);
+}
+
+inline void setElem(btMatrixXf& mat, int row, int col, float val)
+{
+	mat.setElem(row, col, val);
+}
+
+#ifdef BT_USE_DOUBLE_PRECISION
+#define btVectorXu btVectorXd
+#define btMatrixXu btMatrixXd
+#else
+#define btVectorXu btVectorXf
+#define btMatrixXu btMatrixXf
+#endif  //BT_USE_DOUBLE_PRECISION
+
+#endif  //BT_MATRIX_H_H
diff --git a/engine/inc/bullet/LinearMath/btMinMax.h b/engine/inc/bullet/LinearMath/btMinMax.h
new file mode 100644
index 00000000..92fea027
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btMinMax.h
@@ -0,0 +1,69 @@
+/*
+Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_GEN_MINMAX_H
+#define BT_GEN_MINMAX_H
+
+#include "btScalar.h"
+
+template <class T>
+SIMD_FORCE_INLINE const T& btMin(const T& a, const T& b)
+{
+	return a < b ? a : b;
+}
+
+template <class T>
+SIMD_FORCE_INLINE const T& btMax(const T& a, const T& b)
+{
+	return a > b ? a : b;
+}
+
+template <class T>
+SIMD_FORCE_INLINE const T& btClamped(const T& a, const T& lb, const T& ub)
+{
+	return a < lb ? lb : (ub < a ? ub : a);
+}
+
+template <class T>
+SIMD_FORCE_INLINE void btSetMin(T& a, const T& b)
+{
+	if (b < a)
+	{
+		a = b;
+	}
+}
+
+template <class T>
+SIMD_FORCE_INLINE void btSetMax(T& a, const T& b)
+{
+	if (a < b)
+	{
+		a = b;
+	}
+}
+
+template <class T>
+SIMD_FORCE_INLINE void btClamp(T& a, const T& lb, const T& ub)
+{
+	if (a < lb)
+	{
+		a = lb;
+	}
+	else if (ub < a)
+	{
+		a = ub;
+	}
+}
+
+#endif  //BT_GEN_MINMAX_H
diff --git a/engine/inc/bullet/LinearMath/btModifiedGramSchmidt.h b/engine/inc/bullet/LinearMath/btModifiedGramSchmidt.h
new file mode 100644
index 00000000..33bab8d6
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btModifiedGramSchmidt.h
@@ -0,0 +1,83 @@
+//
+//  btModifiedGramSchmidt.h
+//  LinearMath
+//
+//  Created by Xuchen Han on 4/4/20.
+//
+
+#ifndef btModifiedGramSchmidt_h
+#define btModifiedGramSchmidt_h
+
+#include "btReducedVector.h"
+#include "btAlignedObjectArray.h"
+#include <iostream>
+#include <cmath>
+template<class TV>
+class btModifiedGramSchmidt
+{
+public:
+    btAlignedObjectArray<TV> m_in;
+    btAlignedObjectArray<TV> m_out;
+    
+    btModifiedGramSchmidt(const btAlignedObjectArray<TV>& vecs): m_in(vecs)
+    {
+        m_out.resize(0);
+    }
+    
+    void solve()
+    {
+        m_out.resize(m_in.size());
+        for (int i = 0; i < m_in.size(); ++i)
+        {
+//            printf("========= starting %d ==========\n", i);
+            TV v(m_in[i]);
+//            v.print();
+            for (int j = 0; j < i; ++j)
+            {
+                v = v - v.proj(m_out[j]);
+//                v.print();
+            }
+            v.normalize();
+            m_out[i] = v;
+//            v.print();
+        }
+    }
+    
+    void test()
+    {
+        std::cout << SIMD_EPSILON << std::endl;
+        printf("=======inputs=========\n");
+        for (int i = 0; i < m_out.size(); ++i)
+        {
+            m_in[i].print();
+        }
+        printf("=======output=========\n");
+        for (int i = 0; i < m_out.size(); ++i)
+        {
+            m_out[i].print();
+        }
+        btScalar eps = SIMD_EPSILON;
+        for (int i = 0; i < m_out.size(); ++i)
+        {
+            for (int j = 0; j < m_out.size(); ++j)
+            {
+                if (i == j)
+                {
+                    if (std::abs(1.0-m_out[i].dot(m_out[j])) > eps)// && std::abs(m_out[i].dot(m_out[j])) > eps)
+                    {
+                        printf("vec[%d] is not unit, norm squared = %f\n", i,m_out[i].dot(m_out[j]));
+                    }
+                }
+                else
+                {
+                    if (std::abs(m_out[i].dot(m_out[j])) > eps)
+                    {
+                        printf("vec[%d] and vec[%d] is not orthogonal, dot product = %f\n", i, j, m_out[i].dot(m_out[j]));
+                    }
+                }
+            }
+        }
+    }
+};
+template class btModifiedGramSchmidt<btReducedVector>;
+#endif /* btModifiedGramSchmidt_h */
diff --git a/engine/inc/bullet/LinearMath/btMotionState.h b/engine/inc/bullet/LinearMath/btMotionState.h
new file mode 100644
index 00000000..ae6a5161
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btMotionState.h
@@ -0,0 +1,36 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_MOTIONSTATE_H
+#define BT_MOTIONSTATE_H
+
+#include "btTransform.h"
+
+///The btMotionState interface class allows the dynamics world to synchronize and interpolate the updated world transforms with graphics
+///For optimizations, potentially only moving objects get synchronized (using setWorldPosition/setWorldOrientation)
+class btMotionState
+{
+public:
+	virtual ~btMotionState()
+	{
+	}
+
+	virtual void getWorldTransform(btTransform& worldTrans) const = 0;
+
+	//Bullet only calls the update of worldtransform for active objects
+	virtual void setWorldTransform(const btTransform& worldTrans) = 0;
+};
+
+#endif  //BT_MOTIONSTATE_H
diff --git a/engine/inc/bullet/LinearMath/btPolarDecomposition.h b/engine/inc/bullet/LinearMath/btPolarDecomposition.h
new file mode 100644
index 00000000..bf29140a
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btPolarDecomposition.h
@@ -0,0 +1,69 @@
+#ifndef POLARDECOMPOSITION_H
+#define POLARDECOMPOSITION_H
+
+#include "btMatrix3x3.h"
+
+/**
+ * This class is used to compute the polar decomposition of a matrix. In
+ * general, the polar decomposition factorizes a matrix, A, into two parts: a
+ * unitary matrix (U) and a positive, semi-definite Hermitian matrix (H).
+ * However, in this particular implementation the original matrix, A, is
+ * required to be a square 3x3 matrix with real elements. This means that U will
+ * be an orthogonal matrix and H with be a positive-definite, symmetric matrix.
+ */
+class btPolarDecomposition
+{
+public:
+	/**
+     * Creates an instance with optional parameters.
+     *
+     * @param tolerance     - the tolerance used to determine convergence of the
+     *                        algorithm
+     * @param maxIterations - the maximum number of iterations used to achieve
+     *                        convergence
+     */
+	btPolarDecomposition(btScalar tolerance = btScalar(0.0001),
+						 unsigned int maxIterations = 16);
+
+	/**
+     * Decomposes a matrix into orthogonal and symmetric, positive-definite
+     * parts. If the number of iterations returned by this function is equal to
+     * the maximum number of iterations, the algorithm has failed to converge.
+     *
+     * @param a - the original matrix
+     * @param u - the resulting orthogonal matrix
+     * @param h - the resulting symmetric matrix
+     *
+     * @return the number of iterations performed by the algorithm.
+     */
+	unsigned int decompose(const btMatrix3x3& a, btMatrix3x3& u, btMatrix3x3& h) const;
+
+	/**
+     * Returns the maximum number of iterations that this algorithm will perform
+     * to achieve convergence.
+     *
+     * @return maximum number of iterations
+     */
+	unsigned int maxIterations() const;
+
+private:
+	btScalar m_tolerance;
+	unsigned int m_maxIterations;
+};
+
+/**
+ * This functions decomposes the matrix 'a' into two parts: an orthogonal matrix
+ * 'u' and a symmetric, positive-definite matrix 'h'. If the number of
+ * iterations returned by this function is equal to
+ * btPolarDecomposition::DEFAULT_MAX_ITERATIONS, the algorithm has failed to
+ * converge.
+ *
+ * @param a - the original matrix
+ * @param u - the resulting orthogonal matrix
+ * @param h - the resulting symmetric matrix
+ *
+ * @return the number of iterations performed by the algorithm.
+ */
+unsigned int polarDecompose(const btMatrix3x3& a, btMatrix3x3& u, btMatrix3x3& h);
+
+#endif  // POLARDECOMPOSITION_H
diff --git a/engine/inc/bullet/LinearMath/btPoolAllocator.h b/engine/inc/bullet/LinearMath/btPoolAllocator.h
new file mode 100644
index 00000000..4e7b4966
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btPoolAllocator.h
@@ -0,0 +1,130 @@
+/*
+Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef _BT_POOL_ALLOCATOR_H
+#define _BT_POOL_ALLOCATOR_H
+
+#include "btScalar.h"
+#include "btAlignedAllocator.h"
+#include "btThreads.h"
+
+///The btPoolAllocator class allows to efficiently allocate a large pool of objects, instead of dynamically allocating them separately.
+class btPoolAllocator
+{
+	int m_elemSize;
+	int m_maxElements;
+	int m_freeCount;
+	void* m_firstFree;
+	unsigned char* m_pool;
+	btSpinMutex m_mutex;  // only used if BT_THREADSAFE
+
+public:
+	btPoolAllocator(int elemSize, int maxElements)
+		: m_elemSize(elemSize),
+		  m_maxElements(maxElements)
+	{
+		m_pool = (unsigned char*)btAlignedAlloc(static_cast<unsigned int>(m_elemSize * m_maxElements), 16);
+
+		unsigned char* p = m_pool;
+		m_firstFree = p;
+		m_freeCount = m_maxElements;
+		int count = m_maxElements;
+		while (--count)
+		{
+			*(void**)p = (p + m_elemSize);
+			p += m_elemSize;
+		}
+		*(void**)p = 0;
+	}
+
+	~btPoolAllocator()
+	{
+		btAlignedFree(m_pool);
+	}
+
+	int getFreeCount() const
+	{
+		return m_freeCount;
+	}
+
+	int getUsedCount() const
+	{
+		return m_maxElements - m_freeCount;
+	}
+
+	int getMaxCount() const
+	{
+		return m_maxElements;
+	}
+
+	void* allocate(int size)
+	{
+		// release mode fix
+		(void)size;
+		btMutexLock(&m_mutex);
+		btAssert(!size || size <= m_elemSize);
+		//btAssert(m_freeCount>0);  // should return null if all full
+		void* result = m_firstFree;
+		if (NULL != m_firstFree)
+		{
+			m_firstFree = *(void**)m_firstFree;
+			--m_freeCount;
+		}
+		btMutexUnlock(&m_mutex);
+		return result;
+	}
+
+	bool validPtr(void* ptr)
+	{
+		if (ptr)
+		{
+			if (((unsigned char*)ptr >= m_pool && (unsigned char*)ptr < m_pool + m_maxElements * m_elemSize))
+			{
+				return true;
+			}
+		}
+		return false;
+	}
+
+	void freeMemory(void* ptr)
+	{
+		if (ptr)
+		{
+			btAssert((unsigned char*)ptr >= m_pool && (unsigned char*)ptr < m_pool + m_maxElements * m_elemSize);
+
+			btMutexLock(&m_mutex);
+			*(void**)ptr = m_firstFree;
+			m_firstFree = ptr;
+			++m_freeCount;
+			btMutexUnlock(&m_mutex);
+		}
+	}
+
+	int getElementSize() const
+	{
+		return m_elemSize;
+	}
+
+	unsigned char* getPoolAddress()
+	{
+		return m_pool;
+	}
+
+	const unsigned char* getPoolAddress() const
+	{
+		return m_pool;
+	}
+};
+
+#endif  //_BT_POOL_ALLOCATOR_H
diff --git a/engine/inc/bullet/LinearMath/btQuadWord.h b/engine/inc/bullet/LinearMath/btQuadWord.h
new file mode 100644
index 00000000..ab2d3175
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btQuadWord.h
@@ -0,0 +1,238 @@
+/*
+Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SIMD_QUADWORD_H
+#define BT_SIMD_QUADWORD_H
+
+#include "btScalar.h"
+#include "btMinMax.h"
+
+#if defined(__CELLOS_LV2) && defined(__SPU__)
+#include <altivec.h>
+#endif
+
+/**@brief The btQuadWord class is base class for btVector3 and btQuaternion. 
+ * Some issues under PS3 Linux with IBM 2.1 SDK, gcc compiler prevent from using aligned quadword.
+ */
+#ifndef USE_LIBSPE2
+ATTRIBUTE_ALIGNED16(class)
+btQuadWord
+#else
+class btQuadWord
+#endif
+{
+protected:
+#if defined(__SPU__) && defined(__CELLOS_LV2__)
+	union {
+		vec_float4 mVec128;
+		btScalar m_floats[4];
+	};
+
+public:
+	vec_float4 get128() const
+	{
+		return mVec128;
+	}
+
+protected:
+#else  //__CELLOS_LV2__ __SPU__
+
+#if defined(BT_USE_SSE) || defined(BT_USE_NEON)
+	union {
+		btSimdFloat4 mVec128;
+		btScalar m_floats[4];
+	};
+
+public:
+	SIMD_FORCE_INLINE btSimdFloat4 get128() const
+	{
+		return mVec128;
+	}
+	SIMD_FORCE_INLINE void set128(btSimdFloat4 v128)
+	{
+		mVec128 = v128;
+	}
+#else
+	btScalar m_floats[4];
+#endif  // BT_USE_SSE
+
+#endif  //__CELLOS_LV2__ __SPU__
+
+public:
+#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON)
+
+	// Set Vector
+	SIMD_FORCE_INLINE btQuadWord(const btSimdFloat4 vec)
+	{
+		mVec128 = vec;
+	}
+
+	// Copy constructor
+	SIMD_FORCE_INLINE btQuadWord(const btQuadWord& rhs)
+	{
+		mVec128 = rhs.mVec128;
+	}
+
+	// Assignment Operator
+	SIMD_FORCE_INLINE btQuadWord&
+	operator=(const btQuadWord& v)
+	{
+		mVec128 = v.mVec128;
+
+		return *this;
+	}
+
+#endif
+
+	/**@brief Return the x value */
+	SIMD_FORCE_INLINE const btScalar& getX() const { return m_floats[0]; }
+	/**@brief Return the y value */
+	SIMD_FORCE_INLINE const btScalar& getY() const { return m_floats[1]; }
+	/**@brief Return the z value */
+	SIMD_FORCE_INLINE const btScalar& getZ() const { return m_floats[2]; }
+	/**@brief Set the x value */
+	SIMD_FORCE_INLINE void setX(btScalar _x) { m_floats[0] = _x; };
+	/**@brief Set the y value */
+	SIMD_FORCE_INLINE void setY(btScalar _y) { m_floats[1] = _y; };
+	/**@brief Set the z value */
+	SIMD_FORCE_INLINE void setZ(btScalar _z) { m_floats[2] = _z; };
+	/**@brief Set the w value */
+	SIMD_FORCE_INLINE void setW(btScalar _w) { m_floats[3] = _w; };
+	/**@brief Return the x value */
+	SIMD_FORCE_INLINE const btScalar& x() const { return m_floats[0]; }
+	/**@brief Return the y value */
+	SIMD_FORCE_INLINE const btScalar& y() const { return m_floats[1]; }
+	/**@brief Return the z value */
+	SIMD_FORCE_INLINE const btScalar& z() const { return m_floats[2]; }
+	/**@brief Return the w value */
+	SIMD_FORCE_INLINE const btScalar& w() const { return m_floats[3]; }
+
+	//SIMD_FORCE_INLINE btScalar&       operator[](int i)       { return (&m_floats[0])[i];	}
+	//SIMD_FORCE_INLINE const btScalar& operator[](int i) const { return (&m_floats[0])[i]; }
+	///operator btScalar*() replaces operator[], using implicit conversion. We added operator != and operator == to avoid pointer comparisons.
+	SIMD_FORCE_INLINE operator btScalar*() { return &m_floats[0]; }
+	SIMD_FORCE_INLINE operator const btScalar*() const { return &m_floats[0]; }
+
+	SIMD_FORCE_INLINE bool operator==(const btQuadWord& other) const
+	{
+#ifdef BT_USE_SSE
+		return (0xf == _mm_movemask_ps((__m128)_mm_cmpeq_ps(mVec128, other.mVec128)));
+#else
+		return ((m_floats[3] == other.m_floats[3]) &&
+				(m_floats[2] == other.m_floats[2]) &&
+				(m_floats[1] == other.m_floats[1]) &&
+				(m_floats[0] == other.m_floats[0]));
+#endif
+	}
+
+	SIMD_FORCE_INLINE bool operator!=(const btQuadWord& other) const
+	{
+		return !(*this == other);
+	}
+
+	/**@brief Set x,y,z and zero w 
+   * @param x Value of x
+   * @param y Value of y
+   * @param z Value of z
+   */
+	SIMD_FORCE_INLINE void setValue(const btScalar& _x, const btScalar& _y, const btScalar& _z)
+	{
+		m_floats[0] = _x;
+		m_floats[1] = _y;
+		m_floats[2] = _z;
+		m_floats[3] = 0.f;
+	}
+
+	/*		void getValue(btScalar *m) const 
+		{
+			m[0] = m_floats[0];
+			m[1] = m_floats[1];
+			m[2] = m_floats[2];
+		}
+*/
+	/**@brief Set the values 
+   * @param x Value of x
+   * @param y Value of y
+   * @param z Value of z
+   * @param w Value of w
+   */
+	SIMD_FORCE_INLINE void setValue(const btScalar& _x, const btScalar& _y, const btScalar& _z, const btScalar& _w)
+	{
+		m_floats[0] = _x;
+		m_floats[1] = _y;
+		m_floats[2] = _z;
+		m_floats[3] = _w;
+	}
+	/**@brief No initialization constructor */
+	SIMD_FORCE_INLINE btQuadWord()
+	//	:m_floats[0](btScalar(0.)),m_floats[1](btScalar(0.)),m_floats[2](btScalar(0.)),m_floats[3](btScalar(0.))
+	{
+	}
+
+	/**@brief Three argument constructor (zeros w)
+   * @param x Value of x
+   * @param y Value of y
+   * @param z Value of z
+   */
+	SIMD_FORCE_INLINE btQuadWord(const btScalar& _x, const btScalar& _y, const btScalar& _z)
+	{
+		m_floats[0] = _x, m_floats[1] = _y, m_floats[2] = _z, m_floats[3] = 0.0f;
+	}
+
+	/**@brief Initializing constructor
+   * @param x Value of x
+   * @param y Value of y
+   * @param z Value of z
+   * @param w Value of w
+   */
+	SIMD_FORCE_INLINE btQuadWord(const btScalar& _x, const btScalar& _y, const btScalar& _z, const btScalar& _w)
+	{
+		m_floats[0] = _x, m_floats[1] = _y, m_floats[2] = _z, m_floats[3] = _w;
+	}
+
+	/**@brief Set each element to the max of the current values and the values of another btQuadWord
+   * @param other The other btQuadWord to compare with 
+   */
+	SIMD_FORCE_INLINE void setMax(const btQuadWord& other)
+	{
+#ifdef BT_USE_SSE
+		mVec128 = _mm_max_ps(mVec128, other.mVec128);
+#elif defined(BT_USE_NEON)
+		mVec128 = vmaxq_f32(mVec128, other.mVec128);
+#else
+		btSetMax(m_floats[0], other.m_floats[0]);
+		btSetMax(m_floats[1], other.m_floats[1]);
+		btSetMax(m_floats[2], other.m_floats[2]);
+		btSetMax(m_floats[3], other.m_floats[3]);
+#endif
+	}
+	/**@brief Set each element to the min of the current values and the values of another btQuadWord
+   * @param other The other btQuadWord to compare with 
+   */
+	SIMD_FORCE_INLINE void setMin(const btQuadWord& other)
+	{
+#ifdef BT_USE_SSE
+		mVec128 = _mm_min_ps(mVec128, other.mVec128);
+#elif defined(BT_USE_NEON)
+		mVec128 = vminq_f32(mVec128, other.mVec128);
+#else
+		btSetMin(m_floats[0], other.m_floats[0]);
+		btSetMin(m_floats[1], other.m_floats[1]);
+		btSetMin(m_floats[2], other.m_floats[2]);
+		btSetMin(m_floats[3], other.m_floats[3]);
+#endif
+	}
+};
+
+#endif  //BT_SIMD_QUADWORD_H
diff --git a/engine/inc/bullet/LinearMath/btQuaternion.h b/engine/inc/bullet/LinearMath/btQuaternion.h
new file mode 100644
index 00000000..53e8169b
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btQuaternion.h
@@ -0,0 +1,1021 @@
+/*
+Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SIMD__QUATERNION_H_
+#define BT_SIMD__QUATERNION_H_
+
+#include "btVector3.h"
+#include "btQuadWord.h"
+
+#ifdef BT_USE_DOUBLE_PRECISION
+#define btQuaternionData btQuaternionDoubleData
+#define btQuaternionDataName "btQuaternionDoubleData"
+#else
+#define btQuaternionData btQuaternionFloatData
+#define btQuaternionDataName "btQuaternionFloatData"
+#endif  //BT_USE_DOUBLE_PRECISION
+
+#ifdef BT_USE_SSE
+
+//const __m128 ATTRIBUTE_ALIGNED16(vOnes) = {1.0f, 1.0f, 1.0f, 1.0f};
+#define vOnes (_mm_set_ps(1.0f, 1.0f, 1.0f, 1.0f))
+
+#endif
+
+#if defined(BT_USE_SSE)
+
+#define vQInv (_mm_set_ps(+0.0f, -0.0f, -0.0f, -0.0f))
+#define vPPPM (_mm_set_ps(-0.0f, +0.0f, +0.0f, +0.0f))
+
+#elif defined(BT_USE_NEON)
+
+const btSimdFloat4 ATTRIBUTE_ALIGNED16(vQInv) = {-0.0f, -0.0f, -0.0f, +0.0f};
+const btSimdFloat4 ATTRIBUTE_ALIGNED16(vPPPM) = {+0.0f, +0.0f, +0.0f, -0.0f};
+
+#endif
+
+/**@brief The btQuaternion implements quaternion to perform linear algebra rotations in combination with btMatrix3x3, btVector3 and btTransform. */
+class btQuaternion : public btQuadWord
+{
+public:
+	/**@brief No initialization constructor */
+	btQuaternion() {}
+
+#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON)
+	// Set Vector
+	SIMD_FORCE_INLINE btQuaternion(const btSimdFloat4 vec)
+	{
+		mVec128 = vec;
+	}
+
+	// Copy constructor
+	SIMD_FORCE_INLINE btQuaternion(const btQuaternion& rhs)
+	{
+		mVec128 = rhs.mVec128;
+	}
+
+	// Assignment Operator
+	SIMD_FORCE_INLINE btQuaternion&
+	operator=(const btQuaternion& v)
+	{
+		mVec128 = v.mVec128;
+
+		return *this;
+	}
+
+#endif
+
+	//		template <typename btScalar>
+	//		explicit Quaternion(const btScalar *v) : Tuple4<btScalar>(v) {}
+	/**@brief Constructor from scalars */
+	btQuaternion(const btScalar& _x, const btScalar& _y, const btScalar& _z, const btScalar& _w)
+		: btQuadWord(_x, _y, _z, _w)
+	{
+	}
+	/**@brief Axis angle Constructor
+   * @param axis The axis which the rotation is around
+   * @param angle The magnitude of the rotation around the angle (Radians) */
+	btQuaternion(const btVector3& _axis, const btScalar& _angle)
+	{
+		setRotation(_axis, _angle);
+	}
+	/**@brief Constructor from Euler angles
+   * @param yaw Angle around Y unless BT_EULER_DEFAULT_ZYX defined then Z
+   * @param pitch Angle around X unless BT_EULER_DEFAULT_ZYX defined then Y
+   * @param roll Angle around Z unless BT_EULER_DEFAULT_ZYX defined then X */
+	btQuaternion(const btScalar& yaw, const btScalar& pitch, const btScalar& roll)
+	{
+#ifndef BT_EULER_DEFAULT_ZYX
+		setEuler(yaw, pitch, roll);
+#else
+		setEulerZYX(yaw, pitch, roll);
+#endif
+	}
+	/**@brief Set the rotation using axis angle notation 
+   * @param axis The axis around which to rotate
+   * @param angle The magnitude of the rotation in Radians */
+	void setRotation(const btVector3& axis, const btScalar& _angle)
+	{
+		btScalar d = axis.length();
+		btAssert(d != btScalar(0.0));
+		btScalar s = btSin(_angle * btScalar(0.5)) / d;
+		setValue(axis.x() * s, axis.y() * s, axis.z() * s,
+				 btCos(_angle * btScalar(0.5)));
+	}
+	/**@brief Set the quaternion using Euler angles
+   * @param yaw Angle around Y
+   * @param pitch Angle around X
+   * @param roll Angle around Z */
+	void setEuler(const btScalar& yaw, const btScalar& pitch, const btScalar& roll)
+	{
+		btScalar halfYaw = btScalar(yaw) * btScalar(0.5);
+		btScalar halfPitch = btScalar(pitch) * btScalar(0.5);
+		btScalar halfRoll = btScalar(roll) * btScalar(0.5);
+		btScalar cosYaw = btCos(halfYaw);
+		btScalar sinYaw = btSin(halfYaw);
+		btScalar cosPitch = btCos(halfPitch);
+		btScalar sinPitch = btSin(halfPitch);
+		btScalar cosRoll = btCos(halfRoll);
+		btScalar sinRoll = btSin(halfRoll);
+		setValue(cosRoll * sinPitch * cosYaw + sinRoll * cosPitch * sinYaw,
+				 cosRoll * cosPitch * sinYaw - sinRoll * sinPitch * cosYaw,
+				 sinRoll * cosPitch * cosYaw - cosRoll * sinPitch * sinYaw,
+				 cosRoll * cosPitch * cosYaw + sinRoll * sinPitch * sinYaw);
+	}
+	/**@brief Set the quaternion using euler angles 
+   * @param yaw Angle around Z
+   * @param pitch Angle around Y
+   * @param roll Angle around X */
+	void setEulerZYX(const btScalar& yawZ, const btScalar& pitchY, const btScalar& rollX)
+	{
+		btScalar halfYaw = btScalar(yawZ) * btScalar(0.5);
+		btScalar halfPitch = btScalar(pitchY) * btScalar(0.5);
+		btScalar halfRoll = btScalar(rollX) * btScalar(0.5);
+		btScalar cosYaw = btCos(halfYaw);
+		btScalar sinYaw = btSin(halfYaw);
+		btScalar cosPitch = btCos(halfPitch);
+		btScalar sinPitch = btSin(halfPitch);
+		btScalar cosRoll = btCos(halfRoll);
+		btScalar sinRoll = btSin(halfRoll);
+		setValue(sinRoll * cosPitch * cosYaw - cosRoll * sinPitch * sinYaw,   //x
+				 cosRoll * sinPitch * cosYaw + sinRoll * cosPitch * sinYaw,   //y
+				 cosRoll * cosPitch * sinYaw - sinRoll * sinPitch * cosYaw,   //z
+				 cosRoll * cosPitch * cosYaw + sinRoll * sinPitch * sinYaw);  //formerly yzx
+	}
+
+	/**@brief Get the euler angles from this quaternion
+	   * @param yaw Angle around Z
+	   * @param pitch Angle around Y
+	   * @param roll Angle around X */
+	void getEulerZYX(btScalar& yawZ, btScalar& pitchY, btScalar& rollX) const
+	{
+		btScalar squ;
+		btScalar sqx;
+		btScalar sqy;
+		btScalar sqz;
+		btScalar sarg;
+		sqx = m_floats[0] * m_floats[0];
+		sqy = m_floats[1] * m_floats[1];
+		sqz = m_floats[2] * m_floats[2];
+		squ = m_floats[3] * m_floats[3];
+		sarg = btScalar(-2.) * (m_floats[0] * m_floats[2] - m_floats[3] * m_floats[1]);
+
+		// If the pitch angle is PI/2 or -PI/2, we can only compute
+		// the sum roll + yaw.  However, any combination that gives
+		// the right sum will produce the correct orientation, so we
+		// set rollX = 0 and compute yawZ.
+		if (sarg <= -btScalar(0.99999))
+		{
+			pitchY = btScalar(-0.5) * SIMD_PI;
+			rollX = 0;
+			yawZ = btScalar(2) * btAtan2(m_floats[0], -m_floats[1]);
+		}
+		else if (sarg >= btScalar(0.99999))
+		{
+			pitchY = btScalar(0.5) * SIMD_PI;
+			rollX = 0;
+			yawZ = btScalar(2) * btAtan2(-m_floats[0], m_floats[1]);
+		}
+		else
+		{
+			pitchY = btAsin(sarg);
+			rollX = btAtan2(2 * (m_floats[1] * m_floats[2] + m_floats[3] * m_floats[0]), squ - sqx - sqy + sqz);
+			yawZ = btAtan2(2 * (m_floats[0] * m_floats[1] + m_floats[3] * m_floats[2]), squ + sqx - sqy - sqz);
+		}
+	}
+
+	/**@brief Add two quaternions
+   * @param q The quaternion to add to this one */
+	SIMD_FORCE_INLINE btQuaternion& operator+=(const btQuaternion& q)
+	{
+#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+		mVec128 = _mm_add_ps(mVec128, q.mVec128);
+#elif defined(BT_USE_NEON)
+		mVec128 = vaddq_f32(mVec128, q.mVec128);
+#else
+		m_floats[0] += q.x();
+		m_floats[1] += q.y();
+		m_floats[2] += q.z();
+		m_floats[3] += q.m_floats[3];
+#endif
+		return *this;
+	}
+
+	/**@brief Subtract out a quaternion
+   * @param q The quaternion to subtract from this one */
+	btQuaternion& operator-=(const btQuaternion& q)
+	{
+#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+		mVec128 = _mm_sub_ps(mVec128, q.mVec128);
+#elif defined(BT_USE_NEON)
+		mVec128 = vsubq_f32(mVec128, q.mVec128);
+#else
+		m_floats[0] -= q.x();
+		m_floats[1] -= q.y();
+		m_floats[2] -= q.z();
+		m_floats[3] -= q.m_floats[3];
+#endif
+		return *this;
+	}
+
+	/**@brief Scale this quaternion
+   * @param s The scalar to scale by */
+	btQuaternion& operator*=(const btScalar& s)
+	{
+#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+		__m128 vs = _mm_load_ss(&s);  //	(S 0 0 0)
+		vs = bt_pshufd_ps(vs, 0);     //	(S S S S)
+		mVec128 = _mm_mul_ps(mVec128, vs);
+#elif defined(BT_USE_NEON)
+		mVec128 = vmulq_n_f32(mVec128, s);
+#else
+		m_floats[0] *= s;
+		m_floats[1] *= s;
+		m_floats[2] *= s;
+		m_floats[3] *= s;
+#endif
+		return *this;
+	}
+
+	/**@brief Multiply this quaternion by q on the right
+   * @param q The other quaternion 
+   * Equivilant to this = this * q */
+	btQuaternion& operator*=(const btQuaternion& q)
+	{
+#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+		__m128 vQ2 = q.get128();
+
+		__m128 A1 = bt_pshufd_ps(mVec128, BT_SHUFFLE(0, 1, 2, 0));
+		__m128 B1 = bt_pshufd_ps(vQ2, BT_SHUFFLE(3, 3, 3, 0));
+
+		A1 = A1 * B1;
+
+		__m128 A2 = bt_pshufd_ps(mVec128, BT_SHUFFLE(1, 2, 0, 1));
+		__m128 B2 = bt_pshufd_ps(vQ2, BT_SHUFFLE(2, 0, 1, 1));
+
+		A2 = A2 * B2;
+
+		B1 = bt_pshufd_ps(mVec128, BT_SHUFFLE(2, 0, 1, 2));
+		B2 = bt_pshufd_ps(vQ2, BT_SHUFFLE(1, 2, 0, 2));
+
+		B1 = B1 * B2;  //	A3 *= B3
+
+		mVec128 = bt_splat_ps(mVec128, 3);  //	A0
+		mVec128 = mVec128 * vQ2;            //	A0 * B0
+
+		A1 = A1 + A2;                //	AB12
+		mVec128 = mVec128 - B1;      //	AB03 = AB0 - AB3
+		A1 = _mm_xor_ps(A1, vPPPM);  //	change sign of the last element
+		mVec128 = mVec128 + A1;      //	AB03 + AB12
+
+#elif defined(BT_USE_NEON)
+
+		float32x4_t vQ1 = mVec128;
+		float32x4_t vQ2 = q.get128();
+		float32x4_t A0, A1, B1, A2, B2, A3, B3;
+		float32x2_t vQ1zx, vQ2wx, vQ1yz, vQ2zx, vQ2yz, vQ2xz;
+
+		{
+			float32x2x2_t tmp;
+			tmp = vtrn_f32(vget_high_f32(vQ1), vget_low_f32(vQ1));  // {z x}, {w y}
+			vQ1zx = tmp.val[0];
+
+			tmp = vtrn_f32(vget_high_f32(vQ2), vget_low_f32(vQ2));  // {z x}, {w y}
+			vQ2zx = tmp.val[0];
+		}
+		vQ2wx = vext_f32(vget_high_f32(vQ2), vget_low_f32(vQ2), 1);
+
+		vQ1yz = vext_f32(vget_low_f32(vQ1), vget_high_f32(vQ1), 1);
+
+		vQ2yz = vext_f32(vget_low_f32(vQ2), vget_high_f32(vQ2), 1);
+		vQ2xz = vext_f32(vQ2zx, vQ2zx, 1);
+
+		A1 = vcombine_f32(vget_low_f32(vQ1), vQ1zx);                     // X Y  z x
+		B1 = vcombine_f32(vdup_lane_f32(vget_high_f32(vQ2), 1), vQ2wx);  // W W  W X
+
+		A2 = vcombine_f32(vQ1yz, vget_low_f32(vQ1));
+		B2 = vcombine_f32(vQ2zx, vdup_lane_f32(vget_low_f32(vQ2), 1));
+
+		A3 = vcombine_f32(vQ1zx, vQ1yz);  // Z X Y Z
+		B3 = vcombine_f32(vQ2yz, vQ2xz);  // Y Z x z
+
+		A1 = vmulq_f32(A1, B1);
+		A2 = vmulq_f32(A2, B2);
+		A3 = vmulq_f32(A3, B3);                           //	A3 *= B3
+		A0 = vmulq_lane_f32(vQ2, vget_high_f32(vQ1), 1);  //	A0 * B0
+
+		A1 = vaddq_f32(A1, A2);  //	AB12 = AB1 + AB2
+		A0 = vsubq_f32(A0, A3);  //	AB03 = AB0 - AB3
+
+		//	change the sign of the last element
+		A1 = (btSimdFloat4)veorq_s32((int32x4_t)A1, (int32x4_t)vPPPM);
+		A0 = vaddq_f32(A0, A1);  //	AB03 + AB12
+
+		mVec128 = A0;
+#else
+		setValue(
+			m_floats[3] * q.x() + m_floats[0] * q.m_floats[3] + m_floats[1] * q.z() - m_floats[2] * q.y(),
+			m_floats[3] * q.y() + m_floats[1] * q.m_floats[3] + m_floats[2] * q.x() - m_floats[0] * q.z(),
+			m_floats[3] * q.z() + m_floats[2] * q.m_floats[3] + m_floats[0] * q.y() - m_floats[1] * q.x(),
+			m_floats[3] * q.m_floats[3] - m_floats[0] * q.x() - m_floats[1] * q.y() - m_floats[2] * q.z());
+#endif
+		return *this;
+	}
+	/**@brief Return the dot product between this quaternion and another
+   * @param q The other quaternion */
+	btScalar dot(const btQuaternion& q) const
+	{
+#if defined BT_USE_SIMD_VECTOR3 && defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+		__m128 vd;
+
+		vd = _mm_mul_ps(mVec128, q.mVec128);
+
+		__m128 t = _mm_movehl_ps(vd, vd);
+		vd = _mm_add_ps(vd, t);
+		t = _mm_shuffle_ps(vd, vd, 0x55);
+		vd = _mm_add_ss(vd, t);
+
+		return _mm_cvtss_f32(vd);
+#elif defined(BT_USE_NEON)
+		float32x4_t vd = vmulq_f32(mVec128, q.mVec128);
+		float32x2_t x = vpadd_f32(vget_low_f32(vd), vget_high_f32(vd));
+		x = vpadd_f32(x, x);
+		return vget_lane_f32(x, 0);
+#else
+		return m_floats[0] * q.x() +
+			   m_floats[1] * q.y() +
+			   m_floats[2] * q.z() +
+			   m_floats[3] * q.m_floats[3];
+#endif
+	}
+
+	/**@brief Return the length squared of the quaternion */
+	btScalar length2() const
+	{
+		return dot(*this);
+	}
+
+	/**@brief Return the length of the quaternion */
+	btScalar length() const
+	{
+		return btSqrt(length2());
+	}
+	btQuaternion& safeNormalize()
+	{
+		btScalar l2 = length2();
+		if (l2 > SIMD_EPSILON)
+		{
+			normalize();
+		}
+		return *this;
+	}
+	/**@brief Normalize the quaternion 
+   * Such that x^2 + y^2 + z^2 +w^2 = 1 */
+	btQuaternion& normalize()
+	{
+#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+		__m128 vd;
+
+		vd = _mm_mul_ps(mVec128, mVec128);
+
+		__m128 t = _mm_movehl_ps(vd, vd);
+		vd = _mm_add_ps(vd, t);
+		t = _mm_shuffle_ps(vd, vd, 0x55);
+		vd = _mm_add_ss(vd, t);
+
+		vd = _mm_sqrt_ss(vd);
+		vd = _mm_div_ss(vOnes, vd);
+		vd = bt_pshufd_ps(vd, 0);  // splat
+		mVec128 = _mm_mul_ps(mVec128, vd);
+
+		return *this;
+#else
+		return *this /= length();
+#endif
+	}
+
+	/**@brief Return a scaled version of this quaternion
+   * @param s The scale factor */
+	SIMD_FORCE_INLINE btQuaternion
+	operator*(const btScalar& s) const
+	{
+#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+		__m128 vs = _mm_load_ss(&s);  //	(S 0 0 0)
+		vs = bt_pshufd_ps(vs, 0x00);  //	(S S S S)
+
+		return btQuaternion(_mm_mul_ps(mVec128, vs));
+#elif defined(BT_USE_NEON)
+		return btQuaternion(vmulq_n_f32(mVec128, s));
+#else
+		return btQuaternion(x() * s, y() * s, z() * s, m_floats[3] * s);
+#endif
+	}
+
+	/**@brief Return an inversely scaled versionof this quaternion
+   * @param s The inverse scale factor */
+	btQuaternion operator/(const btScalar& s) const
+	{
+		btAssert(s != btScalar(0.0));
+		return *this * (btScalar(1.0) / s);
+	}
+
+	/**@brief Inversely scale this quaternion
+   * @param s The scale factor */
+	btQuaternion& operator/=(const btScalar& s)
+	{
+		btAssert(s != btScalar(0.0));
+		return *this *= btScalar(1.0) / s;
+	}
+
+	/**@brief Return a normalized version of this quaternion */
+	btQuaternion normalized() const
+	{
+		return *this / length();
+	}
+	/**@brief Return the ***half*** angle between this quaternion and the other
+   * @param q The other quaternion */
+	btScalar angle(const btQuaternion& q) const
+	{
+		btScalar s = btSqrt(length2() * q.length2());
+		btAssert(s != btScalar(0.0));
+		return btAcos(dot(q) / s);
+	}
+
+	/**@brief Return the angle between this quaternion and the other along the shortest path
+	* @param q The other quaternion */
+	btScalar angleShortestPath(const btQuaternion& q) const
+	{
+		btScalar s = btSqrt(length2() * q.length2());
+		btAssert(s != btScalar(0.0));
+		if (dot(q) < 0)  // Take care of long angle case see http://en.wikipedia.org/wiki/Slerp
+			return btAcos(dot(-q) / s) * btScalar(2.0);
+		else
+			return btAcos(dot(q) / s) * btScalar(2.0);
+	}
+
+	/**@brief Return the angle [0, 2Pi] of rotation represented by this quaternion */
+	btScalar getAngle() const
+	{
+		btScalar s = btScalar(2.) * btAcos(m_floats[3]);
+		return s;
+	}
+
+	/**@brief Return the angle [0, Pi] of rotation represented by this quaternion along the shortest path */
+	btScalar getAngleShortestPath() const
+	{
+		btScalar s;
+		if (m_floats[3] >= 0)
+			s = btScalar(2.) * btAcos(m_floats[3]);
+		else
+			s = btScalar(2.) * btAcos(-m_floats[3]);
+		return s;
+	}
+
+	/**@brief Return the axis of the rotation represented by this quaternion */
+	btVector3 getAxis() const
+	{
+		btScalar s_squared = 1.f - m_floats[3] * m_floats[3];
+
+		if (s_squared < btScalar(10.) * SIMD_EPSILON)  //Check for divide by zero
+			return btVector3(1.0, 0.0, 0.0);           // Arbitrary
+		btScalar s = 1.f / btSqrt(s_squared);
+		return btVector3(m_floats[0] * s, m_floats[1] * s, m_floats[2] * s);
+	}
+
+	/**@brief Return the inverse of this quaternion */
+	btQuaternion inverse() const
+	{
+#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+		return btQuaternion(_mm_xor_ps(mVec128, vQInv));
+#elif defined(BT_USE_NEON)
+		return btQuaternion((btSimdFloat4)veorq_s32((int32x4_t)mVec128, (int32x4_t)vQInv));
+#else
+		return btQuaternion(-m_floats[0], -m_floats[1], -m_floats[2], m_floats[3]);
+#endif
+	}
+
+	/**@brief Return the sum of this quaternion and the other 
+   * @param q2 The other quaternion */
+	SIMD_FORCE_INLINE btQuaternion
+	operator+(const btQuaternion& q2) const
+	{
+#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+		return btQuaternion(_mm_add_ps(mVec128, q2.mVec128));
+#elif defined(BT_USE_NEON)
+		return btQuaternion(vaddq_f32(mVec128, q2.mVec128));
+#else
+		const btQuaternion& q1 = *this;
+		return btQuaternion(q1.x() + q2.x(), q1.y() + q2.y(), q1.z() + q2.z(), q1.m_floats[3] + q2.m_floats[3]);
+#endif
+	}
+
+	/**@brief Return the difference between this quaternion and the other 
+   * @param q2 The other quaternion */
+	SIMD_FORCE_INLINE btQuaternion
+	operator-(const btQuaternion& q2) const
+	{
+#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+		return btQuaternion(_mm_sub_ps(mVec128, q2.mVec128));
+#elif defined(BT_USE_NEON)
+		return btQuaternion(vsubq_f32(mVec128, q2.mVec128));
+#else
+		const btQuaternion& q1 = *this;
+		return btQuaternion(q1.x() - q2.x(), q1.y() - q2.y(), q1.z() - q2.z(), q1.m_floats[3] - q2.m_floats[3]);
+#endif
+	}
+
+	/**@brief Return the negative of this quaternion 
+   * This simply negates each element */
+	SIMD_FORCE_INLINE btQuaternion operator-() const
+	{
+#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+		return btQuaternion(_mm_xor_ps(mVec128, btvMzeroMask));
+#elif defined(BT_USE_NEON)
+		return btQuaternion((btSimdFloat4)veorq_s32((int32x4_t)mVec128, (int32x4_t)btvMzeroMask));
+#else
+		const btQuaternion& q2 = *this;
+		return btQuaternion(-q2.x(), -q2.y(), -q2.z(), -q2.m_floats[3]);
+#endif
+	}
+	/**@todo document this and it's use */
+	SIMD_FORCE_INLINE btQuaternion farthest(const btQuaternion& qd) const
+	{
+		btQuaternion diff, sum;
+		diff = *this - qd;
+		sum = *this + qd;
+		if (diff.dot(diff) > sum.dot(sum))
+			return qd;
+		return (-qd);
+	}
+
+	/**@todo document this and it's use */
+	SIMD_FORCE_INLINE btQuaternion nearest(const btQuaternion& qd) const
+	{
+		btQuaternion diff, sum;
+		diff = *this - qd;
+		sum = *this + qd;
+		if (diff.dot(diff) < sum.dot(sum))
+			return qd;
+		return (-qd);
+	}
+
+	/**@brief Return the quaternion which is the result of Spherical Linear Interpolation between this and the other quaternion
+   * @param q The other quaternion to interpolate with 
+   * @param t The ratio between this and q to interpolate.  If t = 0 the result is this, if t=1 the result is q.
+   * Slerp interpolates assuming constant velocity.  */
+	btQuaternion slerp(const btQuaternion& q, const btScalar& t) const
+	{
+		const btScalar magnitude = btSqrt(length2() * q.length2());
+		btAssert(magnitude > btScalar(0));
+
+		const btScalar product = dot(q) / magnitude;
+		const btScalar absproduct = btFabs(product);
+
+		if (absproduct < btScalar(1.0 - SIMD_EPSILON))
+		{
+			// Take care of long angle case see http://en.wikipedia.org/wiki/Slerp
+			const btScalar theta = btAcos(absproduct);
+			const btScalar d = btSin(theta);
+			btAssert(d > btScalar(0));
+
+			const btScalar sign = (product < 0) ? btScalar(-1) : btScalar(1);
+			const btScalar s0 = btSin((btScalar(1.0) - t) * theta) / d;
+			const btScalar s1 = btSin(sign * t * theta) / d;
+
+			return btQuaternion(
+				(m_floats[0] * s0 + q.x() * s1),
+				(m_floats[1] * s0 + q.y() * s1),
+				(m_floats[2] * s0 + q.z() * s1),
+				(m_floats[3] * s0 + q.w() * s1));
+		}
+		else
+		{
+			return *this;
+		}
+	}
+
+	static const btQuaternion& getIdentity()
+	{
+		static const btQuaternion identityQuat(btScalar(0.), btScalar(0.), btScalar(0.), btScalar(1.));
+		return identityQuat;
+	}
+
+	SIMD_FORCE_INLINE const btScalar& getW() const { return m_floats[3]; }
+
+	SIMD_FORCE_INLINE void serialize(struct btQuaternionData& dataOut) const;
+
+	SIMD_FORCE_INLINE void deSerialize(const struct btQuaternionFloatData& dataIn);
+
+	SIMD_FORCE_INLINE void deSerialize(const struct btQuaternionDoubleData& dataIn);
+
+	SIMD_FORCE_INLINE void serializeFloat(struct btQuaternionFloatData& dataOut) const;
+
+	SIMD_FORCE_INLINE void deSerializeFloat(const struct btQuaternionFloatData& dataIn);
+
+	SIMD_FORCE_INLINE void serializeDouble(struct btQuaternionDoubleData& dataOut) const;
+
+	SIMD_FORCE_INLINE void deSerializeDouble(const struct btQuaternionDoubleData& dataIn);
+};
+
+/**@brief Return the product of two quaternions */
+SIMD_FORCE_INLINE btQuaternion
+operator*(const btQuaternion& q1, const btQuaternion& q2)
+{
+#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+	__m128 vQ1 = q1.get128();
+	__m128 vQ2 = q2.get128();
+	__m128 A0, A1, B1, A2, B2;
+
+	A1 = bt_pshufd_ps(vQ1, BT_SHUFFLE(0, 1, 2, 0));  // X Y  z x     //      vtrn
+	B1 = bt_pshufd_ps(vQ2, BT_SHUFFLE(3, 3, 3, 0));  // W W  W X     // vdup vext
+
+	A1 = A1 * B1;
+
+	A2 = bt_pshufd_ps(vQ1, BT_SHUFFLE(1, 2, 0, 1));  // Y Z  X Y     // vext
+	B2 = bt_pshufd_ps(vQ2, BT_SHUFFLE(2, 0, 1, 1));  // z x  Y Y     // vtrn vdup
+
+	A2 = A2 * B2;
+
+	B1 = bt_pshufd_ps(vQ1, BT_SHUFFLE(2, 0, 1, 2));  // z x Y Z      // vtrn vext
+	B2 = bt_pshufd_ps(vQ2, BT_SHUFFLE(1, 2, 0, 2));  // Y Z x z      // vext vtrn
+
+	B1 = B1 * B2;  //	A3 *= B3
+
+	A0 = bt_splat_ps(vQ1, 3);  //	A0
+	A0 = A0 * vQ2;             //	A0 * B0
+
+	A1 = A1 + A2;  //	AB12
+	A0 = A0 - B1;  //	AB03 = AB0 - AB3
+
+	A1 = _mm_xor_ps(A1, vPPPM);  //	change sign of the last element
+	A0 = A0 + A1;                //	AB03 + AB12
+
+	return btQuaternion(A0);
+
+#elif defined(BT_USE_NEON)
+
+	float32x4_t vQ1 = q1.get128();
+	float32x4_t vQ2 = q2.get128();
+	float32x4_t A0, A1, B1, A2, B2, A3, B3;
+	float32x2_t vQ1zx, vQ2wx, vQ1yz, vQ2zx, vQ2yz, vQ2xz;
+
+	{
+		float32x2x2_t tmp;
+		tmp = vtrn_f32(vget_high_f32(vQ1), vget_low_f32(vQ1));  // {z x}, {w y}
+		vQ1zx = tmp.val[0];
+
+		tmp = vtrn_f32(vget_high_f32(vQ2), vget_low_f32(vQ2));  // {z x}, {w y}
+		vQ2zx = tmp.val[0];
+	}
+	vQ2wx = vext_f32(vget_high_f32(vQ2), vget_low_f32(vQ2), 1);
+
+	vQ1yz = vext_f32(vget_low_f32(vQ1), vget_high_f32(vQ1), 1);
+
+	vQ2yz = vext_f32(vget_low_f32(vQ2), vget_high_f32(vQ2), 1);
+	vQ2xz = vext_f32(vQ2zx, vQ2zx, 1);
+
+	A1 = vcombine_f32(vget_low_f32(vQ1), vQ1zx);                     // X Y  z x
+	B1 = vcombine_f32(vdup_lane_f32(vget_high_f32(vQ2), 1), vQ2wx);  // W W  W X
+
+	A2 = vcombine_f32(vQ1yz, vget_low_f32(vQ1));
+	B2 = vcombine_f32(vQ2zx, vdup_lane_f32(vget_low_f32(vQ2), 1));
+
+	A3 = vcombine_f32(vQ1zx, vQ1yz);  // Z X Y Z
+	B3 = vcombine_f32(vQ2yz, vQ2xz);  // Y Z x z
+
+	A1 = vmulq_f32(A1, B1);
+	A2 = vmulq_f32(A2, B2);
+	A3 = vmulq_f32(A3, B3);                           //	A3 *= B3
+	A0 = vmulq_lane_f32(vQ2, vget_high_f32(vQ1), 1);  //	A0 * B0
+
+	A1 = vaddq_f32(A1, A2);  //	AB12 = AB1 + AB2
+	A0 = vsubq_f32(A0, A3);  //	AB03 = AB0 - AB3
+
+	//	change the sign of the last element
+	A1 = (btSimdFloat4)veorq_s32((int32x4_t)A1, (int32x4_t)vPPPM);
+	A0 = vaddq_f32(A0, A1);  //	AB03 + AB12
+
+	return btQuaternion(A0);
+
+#else
+	return btQuaternion(
+		q1.w() * q2.x() + q1.x() * q2.w() + q1.y() * q2.z() - q1.z() * q2.y(),
+		q1.w() * q2.y() + q1.y() * q2.w() + q1.z() * q2.x() - q1.x() * q2.z(),
+		q1.w() * q2.z() + q1.z() * q2.w() + q1.x() * q2.y() - q1.y() * q2.x(),
+		q1.w() * q2.w() - q1.x() * q2.x() - q1.y() * q2.y() - q1.z() * q2.z());
+#endif
+}
+
+SIMD_FORCE_INLINE btQuaternion
+operator*(const btQuaternion& q, const btVector3& w)
+{
+#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+	__m128 vQ1 = q.get128();
+	__m128 vQ2 = w.get128();
+	__m128 A1, B1, A2, B2, A3, B3;
+
+	A1 = bt_pshufd_ps(vQ1, BT_SHUFFLE(3, 3, 3, 0));
+	B1 = bt_pshufd_ps(vQ2, BT_SHUFFLE(0, 1, 2, 0));
+
+	A1 = A1 * B1;
+
+	A2 = bt_pshufd_ps(vQ1, BT_SHUFFLE(1, 2, 0, 1));
+	B2 = bt_pshufd_ps(vQ2, BT_SHUFFLE(2, 0, 1, 1));
+
+	A2 = A2 * B2;
+
+	A3 = bt_pshufd_ps(vQ1, BT_SHUFFLE(2, 0, 1, 2));
+	B3 = bt_pshufd_ps(vQ2, BT_SHUFFLE(1, 2, 0, 2));
+
+	A3 = A3 * B3;  //	A3 *= B3
+
+	A1 = A1 + A2;                //	AB12
+	A1 = _mm_xor_ps(A1, vPPPM);  //	change sign of the last element
+	A1 = A1 - A3;                //	AB123 = AB12 - AB3
+
+	return btQuaternion(A1);
+
+#elif defined(BT_USE_NEON)
+
+	float32x4_t vQ1 = q.get128();
+	float32x4_t vQ2 = w.get128();
+	float32x4_t A1, B1, A2, B2, A3, B3;
+	float32x2_t vQ1wx, vQ2zx, vQ1yz, vQ2yz, vQ1zx, vQ2xz;
+
+	vQ1wx = vext_f32(vget_high_f32(vQ1), vget_low_f32(vQ1), 1);
+	{
+		float32x2x2_t tmp;
+
+		tmp = vtrn_f32(vget_high_f32(vQ2), vget_low_f32(vQ2));  // {z x}, {w y}
+		vQ2zx = tmp.val[0];
+
+		tmp = vtrn_f32(vget_high_f32(vQ1), vget_low_f32(vQ1));  // {z x}, {w y}
+		vQ1zx = tmp.val[0];
+	}
+
+	vQ1yz = vext_f32(vget_low_f32(vQ1), vget_high_f32(vQ1), 1);
+
+	vQ2yz = vext_f32(vget_low_f32(vQ2), vget_high_f32(vQ2), 1);
+	vQ2xz = vext_f32(vQ2zx, vQ2zx, 1);
+
+	A1 = vcombine_f32(vdup_lane_f32(vget_high_f32(vQ1), 1), vQ1wx);  // W W  W X
+	B1 = vcombine_f32(vget_low_f32(vQ2), vQ2zx);                     // X Y  z x
+
+	A2 = vcombine_f32(vQ1yz, vget_low_f32(vQ1));
+	B2 = vcombine_f32(vQ2zx, vdup_lane_f32(vget_low_f32(vQ2), 1));
+
+	A3 = vcombine_f32(vQ1zx, vQ1yz);  // Z X Y Z
+	B3 = vcombine_f32(vQ2yz, vQ2xz);  // Y Z x z
+
+	A1 = vmulq_f32(A1, B1);
+	A2 = vmulq_f32(A2, B2);
+	A3 = vmulq_f32(A3, B3);  //	A3 *= B3
+
+	A1 = vaddq_f32(A1, A2);  //	AB12 = AB1 + AB2
+
+	//	change the sign of the last element
+	A1 = (btSimdFloat4)veorq_s32((int32x4_t)A1, (int32x4_t)vPPPM);
+
+	A1 = vsubq_f32(A1, A3);  //	AB123 = AB12 - AB3
+
+	return btQuaternion(A1);
+
+#else
+	return btQuaternion(
+		q.w() * w.x() + q.y() * w.z() - q.z() * w.y(),
+		q.w() * w.y() + q.z() * w.x() - q.x() * w.z(),
+		q.w() * w.z() + q.x() * w.y() - q.y() * w.x(),
+		-q.x() * w.x() - q.y() * w.y() - q.z() * w.z());
+#endif
+}
+
+SIMD_FORCE_INLINE btQuaternion
+operator*(const btVector3& w, const btQuaternion& q)
+{
+#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+	__m128 vQ1 = w.get128();
+	__m128 vQ2 = q.get128();
+	__m128 A1, B1, A2, B2, A3, B3;
+
+	A1 = bt_pshufd_ps(vQ1, BT_SHUFFLE(0, 1, 2, 0));  // X Y  z x
+	B1 = bt_pshufd_ps(vQ2, BT_SHUFFLE(3, 3, 3, 0));  // W W  W X
+
+	A1 = A1 * B1;
+
+	A2 = bt_pshufd_ps(vQ1, BT_SHUFFLE(1, 2, 0, 1));
+	B2 = bt_pshufd_ps(vQ2, BT_SHUFFLE(2, 0, 1, 1));
+
+	A2 = A2 * B2;
+
+	A3 = bt_pshufd_ps(vQ1, BT_SHUFFLE(2, 0, 1, 2));
+	B3 = bt_pshufd_ps(vQ2, BT_SHUFFLE(1, 2, 0, 2));
+
+	A3 = A3 * B3;  //	A3 *= B3
+
+	A1 = A1 + A2;                //	AB12
+	A1 = _mm_xor_ps(A1, vPPPM);  //	change sign of the last element
+	A1 = A1 - A3;                //	AB123 = AB12 - AB3
+
+	return btQuaternion(A1);
+
+#elif defined(BT_USE_NEON)
+
+	float32x4_t vQ1 = w.get128();
+	float32x4_t vQ2 = q.get128();
+	float32x4_t A1, B1, A2, B2, A3, B3;
+	float32x2_t vQ1zx, vQ2wx, vQ1yz, vQ2zx, vQ2yz, vQ2xz;
+
+	{
+		float32x2x2_t tmp;
+
+		tmp = vtrn_f32(vget_high_f32(vQ1), vget_low_f32(vQ1));  // {z x}, {w y}
+		vQ1zx = tmp.val[0];
+
+		tmp = vtrn_f32(vget_high_f32(vQ2), vget_low_f32(vQ2));  // {z x}, {w y}
+		vQ2zx = tmp.val[0];
+	}
+	vQ2wx = vext_f32(vget_high_f32(vQ2), vget_low_f32(vQ2), 1);
+
+	vQ1yz = vext_f32(vget_low_f32(vQ1), vget_high_f32(vQ1), 1);
+
+	vQ2yz = vext_f32(vget_low_f32(vQ2), vget_high_f32(vQ2), 1);
+	vQ2xz = vext_f32(vQ2zx, vQ2zx, 1);
+
+	A1 = vcombine_f32(vget_low_f32(vQ1), vQ1zx);                     // X Y  z x
+	B1 = vcombine_f32(vdup_lane_f32(vget_high_f32(vQ2), 1), vQ2wx);  // W W  W X
+
+	A2 = vcombine_f32(vQ1yz, vget_low_f32(vQ1));
+	B2 = vcombine_f32(vQ2zx, vdup_lane_f32(vget_low_f32(vQ2), 1));
+
+	A3 = vcombine_f32(vQ1zx, vQ1yz);  // Z X Y Z
+	B3 = vcombine_f32(vQ2yz, vQ2xz);  // Y Z x z
+
+	A1 = vmulq_f32(A1, B1);
+	A2 = vmulq_f32(A2, B2);
+	A3 = vmulq_f32(A3, B3);  //	A3 *= B3
+
+	A1 = vaddq_f32(A1, A2);  //	AB12 = AB1 + AB2
+
+	//	change the sign of the last element
+	A1 = (btSimdFloat4)veorq_s32((int32x4_t)A1, (int32x4_t)vPPPM);
+
+	A1 = vsubq_f32(A1, A3);  //	AB123 = AB12 - AB3
+
+	return btQuaternion(A1);
+
+#else
+	return btQuaternion(
+		+w.x() * q.w() + w.y() * q.z() - w.z() * q.y(),
+		+w.y() * q.w() + w.z() * q.x() - w.x() * q.z(),
+		+w.z() * q.w() + w.x() * q.y() - w.y() * q.x(),
+		-w.x() * q.x() - w.y() * q.y() - w.z() * q.z());
+#endif
+}
+
+/**@brief Calculate the dot product between two quaternions */
+SIMD_FORCE_INLINE btScalar
+dot(const btQuaternion& q1, const btQuaternion& q2)
+{
+	return q1.dot(q2);
+}
+
+/**@brief Return the length of a quaternion */
+SIMD_FORCE_INLINE btScalar
+length(const btQuaternion& q)
+{
+	return q.length();
+}
+
+/**@brief Return the angle between two quaternions*/
+SIMD_FORCE_INLINE btScalar
+btAngle(const btQuaternion& q1, const btQuaternion& q2)
+{
+	return q1.angle(q2);
+}
+
+/**@brief Return the inverse of a quaternion*/
+SIMD_FORCE_INLINE btQuaternion
+inverse(const btQuaternion& q)
+{
+	return q.inverse();
+}
+
+/**@brief Return the result of spherical linear interpolation betwen two quaternions 
+ * @param q1 The first quaternion
+ * @param q2 The second quaternion 
+ * @param t The ration between q1 and q2.  t = 0 return q1, t=1 returns q2 
+ * Slerp assumes constant velocity between positions. */
+SIMD_FORCE_INLINE btQuaternion
+slerp(const btQuaternion& q1, const btQuaternion& q2, const btScalar& t)
+{
+	return q1.slerp(q2, t);
+}
+
+SIMD_FORCE_INLINE btVector3
+quatRotate(const btQuaternion& rotation, const btVector3& v)
+{
+	btQuaternion q = rotation * v;
+	q *= rotation.inverse();
+#if defined BT_USE_SIMD_VECTOR3 && defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+	return btVector3(_mm_and_ps(q.get128(), btvFFF0fMask));
+#elif defined(BT_USE_NEON)
+	return btVector3((float32x4_t)vandq_s32((int32x4_t)q.get128(), btvFFF0Mask));
+#else
+	return btVector3(q.getX(), q.getY(), q.getZ());
+#endif
+}
+
+SIMD_FORCE_INLINE btQuaternion
+shortestArcQuat(const btVector3& v0, const btVector3& v1)  // Game Programming Gems 2.10. make sure v0,v1 are normalized
+{
+	btVector3 c = v0.cross(v1);
+	btScalar d = v0.dot(v1);
+
+	if (d < -1.0 + SIMD_EPSILON)
+	{
+		btVector3 n, unused;
+		btPlaneSpace1(v0, n, unused);
+		return btQuaternion(n.x(), n.y(), n.z(), 0.0f);  // just pick any vector that is orthogonal to v0
+	}
+
+	btScalar s = btSqrt((1.0f + d) * 2.0f);
+	btScalar rs = 1.0f / s;
+
+	return btQuaternion(c.getX() * rs, c.getY() * rs, c.getZ() * rs, s * 0.5f);
+}
+
+SIMD_FORCE_INLINE btQuaternion
+shortestArcQuatNormalize2(btVector3& v0, btVector3& v1)
+{
+	v0.normalize();
+	v1.normalize();
+	return shortestArcQuat(v0, v1);
+}
+
+struct btQuaternionFloatData
+{
+	float m_floats[4];
+};
+
+struct btQuaternionDoubleData
+{
+	double m_floats[4];
+};
+
+SIMD_FORCE_INLINE void btQuaternion::serializeFloat(struct btQuaternionFloatData& dataOut) const
+{
+	///could also do a memcpy, check if it is worth it
+	for (int i = 0; i < 4; i++)
+		dataOut.m_floats[i] = float(m_floats[i]);
+}
+
+SIMD_FORCE_INLINE void btQuaternion::deSerializeFloat(const struct btQuaternionFloatData& dataIn)
+{
+	for (int i = 0; i < 4; i++)
+		m_floats[i] = btScalar(dataIn.m_floats[i]);
+}
+
+SIMD_FORCE_INLINE void btQuaternion::serializeDouble(struct btQuaternionDoubleData& dataOut) const
+{
+	///could also do a memcpy, check if it is worth it
+	for (int i = 0; i < 4; i++)
+		dataOut.m_floats[i] = double(m_floats[i]);
+}
+
+SIMD_FORCE_INLINE void btQuaternion::deSerializeDouble(const struct btQuaternionDoubleData& dataIn)
+{
+	for (int i = 0; i < 4; i++)
+		m_floats[i] = btScalar(dataIn.m_floats[i]);
+}
+
+SIMD_FORCE_INLINE void btQuaternion::serialize(struct btQuaternionData& dataOut) const
+{
+	///could also do a memcpy, check if it is worth it
+	for (int i = 0; i < 4; i++)
+		dataOut.m_floats[i] = m_floats[i];
+}
+
+SIMD_FORCE_INLINE void btQuaternion::deSerialize(const struct btQuaternionFloatData& dataIn)
+{
+	for (int i = 0; i < 4; i++)
+		m_floats[i] = (btScalar)dataIn.m_floats[i];
+}
+
+SIMD_FORCE_INLINE void btQuaternion::deSerialize(const struct btQuaternionDoubleData& dataIn)
+{
+	for (int i = 0; i < 4; i++)
+		m_floats[i] = (btScalar)dataIn.m_floats[i];
+}
+
+#endif  //BT_SIMD__QUATERNION_H_
diff --git a/engine/inc/bullet/LinearMath/btQuickprof.h b/engine/inc/bullet/LinearMath/btQuickprof.h
new file mode 100644
index 00000000..990d401d
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btQuickprof.h
@@ -0,0 +1,200 @@
+
+/***************************************************************************************************
+**
+** Real-Time Hierarchical Profiling for Game Programming Gems 3
+**
+** by Greg Hjelstrom & Byon Garrabrant
+**
+***************************************************************************************************/
+
+// Credits: The Clock class was inspired by the Timer classes in
+// Ogre (www.ogre3d.org).
+
+#ifndef BT_QUICK_PROF_H
+#define BT_QUICK_PROF_H
+
+#include "btScalar.h"
+#define USE_BT_CLOCK 1
+
+#ifdef USE_BT_CLOCK
+
+///The btClock is a portable basic clock that measures accurate time in seconds, use for profiling.
+class btClock
+{
+public:
+	btClock();
+
+	btClock(const btClock& other);
+	btClock& operator=(const btClock& other);
+
+	~btClock();
+
+	/// Resets the initial reference time.
+	void reset();
+
+	/// Returns the time in ms since the last call to reset or since
+	/// the btClock was created.
+	unsigned long long int getTimeMilliseconds();
+
+	/// Returns the time in us since the last call to reset or since
+	/// the Clock was created.
+	unsigned long long int getTimeMicroseconds();
+
+	unsigned long long int getTimeNanoseconds();
+
+	/// Returns the time in s since the last call to reset or since
+	/// the Clock was created.
+	btScalar getTimeSeconds();
+
+private:
+	struct btClockData* m_data;
+};
+
+#endif  //USE_BT_CLOCK
+
+typedef void(btEnterProfileZoneFunc)(const char* msg);
+typedef void(btLeaveProfileZoneFunc)();
+
+btEnterProfileZoneFunc* btGetCurrentEnterProfileZoneFunc();
+btLeaveProfileZoneFunc* btGetCurrentLeaveProfileZoneFunc();
+
+void btSetCustomEnterProfileZoneFunc(btEnterProfileZoneFunc* enterFunc);
+void btSetCustomLeaveProfileZoneFunc(btLeaveProfileZoneFunc* leaveFunc);
+
+#ifndef BT_ENABLE_PROFILE
+#define BT_NO_PROFILE 1
+#endif  //BT_NO_PROFILE
+
+const unsigned int BT_QUICKPROF_MAX_THREAD_COUNT = 64;
+
+//btQuickprofGetCurrentThreadIndex will return -1 if thread index cannot be determined,
+//otherwise returns thread index in range [0..maxThreads]
+unsigned int btQuickprofGetCurrentThreadIndex2();
+
+#ifndef BT_NO_PROFILE
+
+
+#include <stdio.h>  //@todo remove this, backwards compatibility
+
+#include "btAlignedAllocator.h"
+#include <new>
+
+///A node in the Profile Hierarchy Tree
+class CProfileNode
+{
+public:
+	CProfileNode(const char* name, CProfileNode* parent);
+	~CProfileNode(void);
+
+	CProfileNode* Get_Sub_Node(const char* name);
+
+	CProfileNode* Get_Parent(void) { return Parent; }
+	CProfileNode* Get_Sibling(void) { return Sibling; }
+	CProfileNode* Get_Child(void) { return Child; }
+
+	void CleanupMemory();
+	void Reset(void);
+	void Call(void);
+	bool Return(void);
+
+	const char* Get_Name(void) { return Name; }
+	int Get_Total_Calls(void) { return TotalCalls; }
+	float Get_Total_Time(void) { return TotalTime; }
+	void* GetUserPointer() const { return m_userPtr; }
+	void SetUserPointer(void* ptr) { m_userPtr = ptr; }
+
+protected:
+	const char* Name;
+	int TotalCalls;
+	float TotalTime;
+	unsigned long int StartTime;
+	int RecursionCounter;
+
+	CProfileNode* Parent;
+	CProfileNode* Child;
+	CProfileNode* Sibling;
+	void* m_userPtr;
+};
+
+///An iterator to navigate through the tree
+class CProfileIterator
+{
+public:
+	// Access all the children of the current parent
+	void First(void);
+	void Next(void);
+	bool Is_Done(void);
+	bool Is_Root(void) { return (CurrentParent->Get_Parent() == 0); }
+
+	void Enter_Child(int index);     // Make the given child the new parent
+	void Enter_Largest_Child(void);  // Make the largest child the new parent
+	void Enter_Parent(void);         // Make the current parent's parent the new parent
+
+	// Access the current child
+	const char* Get_Current_Name(void) { return CurrentChild->Get_Name(); }
+	int Get_Current_Total_Calls(void) { return CurrentChild->Get_Total_Calls(); }
+	float Get_Current_Total_Time(void) { return CurrentChild->Get_Total_Time(); }
+
+	void* Get_Current_UserPointer(void) { return CurrentChild->GetUserPointer(); }
+	void Set_Current_UserPointer(void* ptr) { CurrentChild->SetUserPointer(ptr); }
+	// Access the current parent
+	const char* Get_Current_Parent_Name(void) { return CurrentParent->Get_Name(); }
+	int Get_Current_Parent_Total_Calls(void) { return CurrentParent->Get_Total_Calls(); }
+	float Get_Current_Parent_Total_Time(void) { return CurrentParent->Get_Total_Time(); }
+
+protected:
+	CProfileNode* CurrentParent;
+	CProfileNode* CurrentChild;
+
+	CProfileIterator(CProfileNode* start);
+	friend class CProfileManager;
+};
+
+///The Manager for the Profile system
+class CProfileManager
+{
+public:
+	static void Start_Profile(const char* name);
+	static void Stop_Profile(void);
+
+	static void CleanupMemory(void);
+	//	{
+	//		Root.CleanupMemory();
+	//	}
+
+	static void Reset(void);
+	static void Increment_Frame_Counter(void);
+	static int Get_Frame_Count_Since_Reset(void) { return FrameCounter; }
+	static float Get_Time_Since_Reset(void);
+
+	static CProfileIterator* Get_Iterator(void);
+	//	{
+	//
+	//		return new CProfileIterator( &Root );
+	//	}
+	static void Release_Iterator(CProfileIterator* iterator) { delete (iterator); }
+
+	static void dumpRecursive(CProfileIterator* profileIterator, int spacing);
+
+	static void dumpAll();
+
+private:
+	static int FrameCounter;
+	static unsigned long int ResetTime;
+};
+
+#endif  //#ifndef BT_NO_PROFILE
+
+///ProfileSampleClass is a simple way to profile a function's scope
+///Use the BT_PROFILE macro at the start of scope to time
+class CProfileSample
+{
+public:
+	CProfileSample(const char* name);
+
+	~CProfileSample(void);
+};
+
+#define BT_PROFILE(name) CProfileSample __profile(name)
+
+#endif  //BT_QUICK_PROF_H
diff --git a/engine/inc/bullet/LinearMath/btRandom.h b/engine/inc/bullet/LinearMath/btRandom.h
new file mode 100644
index 00000000..e659af86
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btRandom.h
@@ -0,0 +1,39 @@
+/*
+Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_GEN_RANDOM_H
+#define BT_GEN_RANDOM_H
+
+#ifdef MT19937
+
+#include <limits.h>
+#include <mt19937.h>
+
+#define GEN_RAND_MAX UINT_MAX
+
+SIMD_FORCE_INLINE void GEN_srand(unsigned int seed) { init_genrand(seed); }
+SIMD_FORCE_INLINE unsigned int GEN_rand() { return genrand_int32(); }
+
+#else
+
+#include <stdlib.h>
+
+#define GEN_RAND_MAX RAND_MAX
+
+SIMD_FORCE_INLINE void GEN_srand(unsigned int seed) { srand(seed); }
+SIMD_FORCE_INLINE unsigned int GEN_rand() { return rand(); }
+
+#endif
+
+#endif  //BT_GEN_RANDOM_H
diff --git a/engine/inc/bullet/LinearMath/btReducedVector.h b/engine/inc/bullet/LinearMath/btReducedVector.h
new file mode 100644
index 00000000..313a4271
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btReducedVector.h
@@ -0,0 +1,320 @@
+//
+//  btReducedVectors.h
+//  BulletLinearMath
+//
+//  Created by Xuchen Han on 4/4/20.
+//
+#ifndef btReducedVectors_h
+#define btReducedVectors_h
+#include "btVector3.h"
+#include "btMatrix3x3.h"
+#include "btAlignedObjectArray.h"
+#include <stdio.h>
+#include <vector>
+#include <algorithm>
+struct TwoInts
+{
+    int a,b;
+};
+inline bool operator<(const TwoInts& A, const TwoInts& B)
+{
+    return A.b < B.b;
+}
+
+
+// A helper vector type used for CG projections
+class btReducedVector
+{
+public:
+    btAlignedObjectArray<int> m_indices;
+    btAlignedObjectArray<btVector3> m_vecs;
+    int m_sz; // all m_indices value < m_sz
+public:
+	btReducedVector():m_sz(0)
+	{
+		m_indices.resize(0);
+		m_vecs.resize(0);
+        m_indices.clear();
+        m_vecs.clear();
+	}
+	
+    btReducedVector(int sz): m_sz(sz)
+    {
+        m_indices.resize(0);
+        m_vecs.resize(0);
+        m_indices.clear();
+        m_vecs.clear();
+    }
+    
+    btReducedVector(int sz, const btAlignedObjectArray<int>& indices, const btAlignedObjectArray<btVector3>& vecs): m_sz(sz), m_indices(indices), m_vecs(vecs)
+    {
+    }
+    
+    void simplify()
+    {
+        btAlignedObjectArray<int> old_indices(m_indices);
+        btAlignedObjectArray<btVector3> old_vecs(m_vecs);
+        m_indices.resize(0);
+        m_vecs.resize(0);
+        m_indices.clear();
+        m_vecs.clear();
+        for (int i = 0; i < old_indices.size(); ++i)
+        {
+            if (old_vecs[i].length2() > SIMD_EPSILON)
+            {
+                m_indices.push_back(old_indices[i]);
+                m_vecs.push_back(old_vecs[i]);
+            }
+        }
+    }
+    
+    btReducedVector operator+(const btReducedVector& other)
+    {
+		btReducedVector ret(m_sz);
+		int i=0, j=0;
+		while (i < m_indices.size() && j < other.m_indices.size())
+		{
+			if (m_indices[i] < other.m_indices[j])
+			{
+				ret.m_indices.push_back(m_indices[i]);
+				ret.m_vecs.push_back(m_vecs[i]);
+				++i;
+			}
+			else if (m_indices[i] > other.m_indices[j])
+			{
+				ret.m_indices.push_back(other.m_indices[j]);
+				ret.m_vecs.push_back(other.m_vecs[j]);
+				++j;
+			}
+			else
+			{
+				ret.m_indices.push_back(other.m_indices[j]);
+				ret.m_vecs.push_back(m_vecs[i] + other.m_vecs[j]);
+				++i; ++j;
+			}
+		}
+		while (i < m_indices.size())
+		{
+			ret.m_indices.push_back(m_indices[i]);
+			ret.m_vecs.push_back(m_vecs[i]);
+			++i;
+		}
+		while (j < other.m_indices.size())
+		{
+			ret.m_indices.push_back(other.m_indices[j]);
+			ret.m_vecs.push_back(other.m_vecs[j]);
+			++j;
+		}
+        ret.simplify();
+        return ret;
+    }
+
+    btReducedVector operator-()
+    {
+        btReducedVector ret(m_sz);
+        for (int i = 0; i < m_indices.size(); ++i)
+        {
+            ret.m_indices.push_back(m_indices[i]);
+            ret.m_vecs.push_back(-m_vecs[i]);
+        }
+        ret.simplify();
+        return ret;
+    }
+    
+    btReducedVector operator-(const btReducedVector& other)
+    {
+		btReducedVector ret(m_sz);
+		int i=0, j=0;
+		while (i < m_indices.size() && j < other.m_indices.size())
+		{
+			if (m_indices[i] < other.m_indices[j])
+			{
+				ret.m_indices.push_back(m_indices[i]);
+				ret.m_vecs.push_back(m_vecs[i]);
+				++i;
+			}
+			else if (m_indices[i] > other.m_indices[j])
+			{
+				ret.m_indices.push_back(other.m_indices[j]);
+				ret.m_vecs.push_back(-other.m_vecs[j]);
+				++j;
+			}
+			else
+			{
+				ret.m_indices.push_back(other.m_indices[j]);
+				ret.m_vecs.push_back(m_vecs[i] - other.m_vecs[j]);
+				++i; ++j;
+			}
+		}
+		while (i < m_indices.size())
+		{
+			ret.m_indices.push_back(m_indices[i]);
+			ret.m_vecs.push_back(m_vecs[i]);
+			++i;
+		}
+		while (j < other.m_indices.size())
+		{
+			ret.m_indices.push_back(other.m_indices[j]);
+			ret.m_vecs.push_back(-other.m_vecs[j]);
+			++j;
+		}
+        ret.simplify();
+		return ret;
+    }
+    
+    bool operator==(const btReducedVector& other) const
+    {
+        if (m_sz != other.m_sz)
+            return false;
+        if (m_indices.size() != other.m_indices.size())
+            return false;
+        for (int i = 0; i < m_indices.size(); ++i)
+        {
+            if (m_indices[i] != other.m_indices[i] || m_vecs[i] != other.m_vecs[i])
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+    
+    bool operator!=(const btReducedVector& other) const
+    {
+        return !(*this == other);
+    }
+	
+	btReducedVector& operator=(const btReducedVector& other)
+	{
+		if (this == &other)
+		{
+			return *this;
+		}
+        m_sz = other.m_sz;
+		m_indices.copyFromArray(other.m_indices);
+		m_vecs.copyFromArray(other.m_vecs);
+		return *this;
+	}
+    
+    btScalar dot(const btReducedVector& other) const
+    {
+        btScalar ret = 0;
+        int j = 0;
+        for (int i = 0; i < m_indices.size(); ++i)
+        {
+            while (j < other.m_indices.size() && other.m_indices[j] < m_indices[i])
+            {
+                ++j;
+            }
+            if (j < other.m_indices.size() && other.m_indices[j] == m_indices[i])
+            {
+                ret += m_vecs[i].dot(other.m_vecs[j]);
+//                ++j;
+            }
+        }
+        return ret;
+    }
+    
+    btScalar dot(const btAlignedObjectArray<btVector3>& other) const
+    {
+        btScalar ret = 0;
+        for (int i = 0; i < m_indices.size(); ++i)
+        {
+            ret += m_vecs[i].dot(other[m_indices[i]]);
+        }
+        return ret;
+    }
+    
+    btScalar length2() const
+    {
+        return this->dot(*this);
+    }
+	
+	void normalize();
+    
+    // returns the projection of this onto other
+    btReducedVector proj(const btReducedVector& other) const;
+    
+    bool testAdd() const;
+    
+    bool testMinus() const;
+    
+    bool testDot() const;
+    
+    bool testMultiply() const;
+    
+    void test() const;
+    
+    void print() const
+    {
+        for (int i = 0; i < m_indices.size(); ++i)
+        {
+            printf("%d: (%f, %f, %f)/", m_indices[i], m_vecs[i][0],m_vecs[i][1],m_vecs[i][2]);
+        }
+        printf("\n");
+    }
+    
+    
+    void sort()
+    {
+        std::vector<TwoInts> tuples;
+        for (int i = 0; i < m_indices.size(); ++i)
+        {
+            TwoInts ti;
+            ti.a = i;
+            ti.b = m_indices[i];
+            tuples.push_back(ti);
+        }
+        std::sort(tuples.begin(), tuples.end());
+        btAlignedObjectArray<int> new_indices;
+        btAlignedObjectArray<btVector3> new_vecs;
+        for (size_t i = 0; i < tuples.size(); ++i)
+        {
+            new_indices.push_back(tuples[i].b);
+            new_vecs.push_back(m_vecs[tuples[i].a]);
+        }
+        m_indices = new_indices;
+        m_vecs = new_vecs;
+    }
+};
+
+SIMD_FORCE_INLINE btReducedVector operator*(const btReducedVector& v, btScalar s)
+{
+    btReducedVector ret(v.m_sz);
+    for (int i = 0; i < v.m_indices.size(); ++i)
+    {
+        ret.m_indices.push_back(v.m_indices[i]);
+        ret.m_vecs.push_back(s*v.m_vecs[i]);
+    }
+    ret.simplify();
+    return ret;
+}
+
+SIMD_FORCE_INLINE btReducedVector operator*(btScalar s, const btReducedVector& v)
+{
+    return v*s;
+}
+
+SIMD_FORCE_INLINE btReducedVector operator/(const btReducedVector& v, btScalar s)
+{
+	return v * (1.0/s);
+}
+
+SIMD_FORCE_INLINE btReducedVector& operator/=(btReducedVector& v, btScalar s)
+{
+	v = v/s;
+	return v;
+}
+
+SIMD_FORCE_INLINE btReducedVector& operator+=(btReducedVector& v1, const btReducedVector& v2)
+{
+	v1 = v1+v2;
+	return v1;
+}
+
+SIMD_FORCE_INLINE btReducedVector& operator-=(btReducedVector& v1, const btReducedVector& v2)
+{
+	v1 = v1-v2;
+	return v1;
+}
+
+#endif /* btReducedVectors_h */
diff --git a/engine/inc/bullet/LinearMath/btScalar.h b/engine/inc/bullet/LinearMath/btScalar.h
new file mode 100644
index 00000000..36b90cc9
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btScalar.h
@@ -0,0 +1,832 @@
+/*
+Copyright (c) 2003-2009 Erwin Coumans  http://bullet.googlecode.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SCALAR_H
+#define BT_SCALAR_H
+
+#ifdef BT_MANAGED_CODE
+//Aligned data types not supported in managed code
+#pragma unmanaged
+#endif
+
+#include <math.h>
+#include <stdlib.h>  //size_t for MSVC 6.0
+#include <float.h>
+
+/* SVN $Revision$ on $Date$ from http://bullet.googlecode.com*/
+#define BT_BULLET_VERSION 307
+
+inline int btGetVersion()
+{
+	return BT_BULLET_VERSION;
+}
+
+inline int btIsDoublePrecision()
+{
+  #ifdef BT_USE_DOUBLE_PRECISION
+  return true;
+  #else
+  return false;
+  #endif
+}
+
+
+// The following macro "BT_NOT_EMPTY_FILE" can be put into a file
+// in order suppress the MS Visual C++ Linker warning 4221
+//
+// warning LNK4221: no public symbols found; archive member will be inaccessible
+//
+// This warning occurs on PC and XBOX when a file compiles out completely
+// has no externally visible symbols which may be dependant on configuration
+// #defines and options.
+//
+// see more https://stackoverflow.com/questions/1822887/what-is-the-best-way-to-eliminate-ms-visual-c-linker-warning-warning-lnk422
+
+#if defined(_MSC_VER)
+#define BT_NOT_EMPTY_FILE_CAT_II(p, res) res
+#define BT_NOT_EMPTY_FILE_CAT_I(a, b) BT_NOT_EMPTY_FILE_CAT_II(~, a##b)
+#define BT_NOT_EMPTY_FILE_CAT(a, b) BT_NOT_EMPTY_FILE_CAT_I(a, b)
+#define BT_NOT_EMPTY_FILE                                      \
+	namespace                                                  \
+	{                                                          \
+	char BT_NOT_EMPTY_FILE_CAT(NoEmptyFileDummy, __COUNTER__); \
+	}
+#else
+#define BT_NOT_EMPTY_FILE
+#endif
+
+// clang and most formatting tools don't support indentation of preprocessor guards, so turn it off
+// clang-format off
+#if defined(DEBUG) || defined (_DEBUG)
+	#define BT_DEBUG
+#endif
+
+#ifdef _WIN32
+	#if  defined(__GNUC__)	// it should handle both MINGW and CYGWIN
+        	#define SIMD_FORCE_INLINE        __inline__ __attribute__((always_inline))
+        	#define ATTRIBUTE_ALIGNED16(a)   a __attribute__((aligned(16)))
+        	#define ATTRIBUTE_ALIGNED64(a)   a __attribute__((aligned(64)))
+        	#define ATTRIBUTE_ALIGNED128(a)  a __attribute__((aligned(128)))
+    	#elif ( defined(_MSC_VER) && _MSC_VER < 1300 )
+		#define SIMD_FORCE_INLINE inline
+		#define ATTRIBUTE_ALIGNED16(a) a
+		#define ATTRIBUTE_ALIGNED64(a) a
+		#define ATTRIBUTE_ALIGNED128(a) a
+	#elif defined(_M_ARM)
+		#define SIMD_FORCE_INLINE __forceinline
+		#define ATTRIBUTE_ALIGNED16(a) __declspec() a
+		#define ATTRIBUTE_ALIGNED64(a) __declspec() a
+		#define ATTRIBUTE_ALIGNED128(a) __declspec () a
+	#else//__MINGW32__
+		//#define BT_HAS_ALIGNED_ALLOCATOR
+		#pragma warning(disable : 4324) // disable padding warning
+//			#pragma warning(disable:4530) // Disable the exception disable but used in MSCV Stl warning.
+		#pragma warning(disable:4996) //Turn off warnings about deprecated C routines
+//			#pragma warning(disable:4786) // Disable the "debug name too long" warning
+
+		#define SIMD_FORCE_INLINE __forceinline
+		#define ATTRIBUTE_ALIGNED16(a) __declspec(align(16)) a
+		#define ATTRIBUTE_ALIGNED64(a) __declspec(align(64)) a
+		#define ATTRIBUTE_ALIGNED128(a) __declspec (align(128)) a
+		#ifdef _XBOX
+			#define BT_USE_VMX128
+
+			#include <ppcintrinsics.h>
+ 			#define BT_HAVE_NATIVE_FSEL
+ 			#define btFsel(a,b,c) __fsel((a),(b),(c))
+		#else
+
+#if defined (_M_ARM)
+            //Do not turn SSE on for ARM (may want to turn on BT_USE_NEON however)
+#elif (defined (_WIN32) && (_MSC_VER) && _MSC_VER >= 1400) && (!defined (BT_USE_DOUBLE_PRECISION))
+
+#ifdef __clang__
+#define __BT_DISABLE_SSE__
+#endif
+#ifndef __BT_DISABLE_SSE__
+			#if _MSC_VER>1400
+				#define BT_USE_SIMD_VECTOR3
+			#endif
+			#define BT_USE_SSE
+#endif//__BT_DISABLE_SSE__
+			#ifdef BT_USE_SSE
+
+#if (_MSC_FULL_VER >= 170050727)//Visual Studio 2012 can compile SSE4/FMA3 (but SSE4/FMA3 is not enabled by default)
+			#define BT_ALLOW_SSE4
+#endif //(_MSC_FULL_VER >= 160040219)
+
+			//BT_USE_SSE_IN_API is disabled under Windows by default, because 
+			//it makes it harder to integrate Bullet into your application under Windows 
+			//(structured embedding Bullet structs/classes need to be 16-byte aligned)
+			//with relatively little performance gain
+			//If you are not embedded Bullet data in your classes, or make sure that you align those classes on 16-byte boundaries
+			//you can manually enable this line or set it in the build system for a bit of performance gain (a few percent, dependent on usage)
+			//#define BT_USE_SSE_IN_API
+			#endif //BT_USE_SSE
+			#include <emmintrin.h>
+#endif
+
+		#endif//_XBOX
+
+	#endif //__MINGW32__
+
+	#ifdef BT_DEBUG
+		#ifdef _MSC_VER
+			#include <stdio.h>
+			#define btAssert(x) { if(!(x)){printf("Assert " __FILE__ ":%u (%s)\n", __LINE__, #x);__debugbreak();	}}
+		#else//_MSC_VER
+			#include <assert.h>
+			#define btAssert assert
+		#endif//_MSC_VER
+	#else
+		#define btAssert(x)
+	#endif
+		//btFullAssert is optional, slows down a lot
+		#define btFullAssert(x)
+
+		#define btLikely(_c)  _c
+		#define btUnlikely(_c) _c
+
+#else//_WIN32
+	
+	#if defined	(__CELLOS_LV2__)
+		#define SIMD_FORCE_INLINE inline __attribute__((always_inline))
+		#define ATTRIBUTE_ALIGNED16(a) a __attribute__ ((aligned (16)))
+		#define ATTRIBUTE_ALIGNED64(a) a __attribute__ ((aligned (64)))
+		#define ATTRIBUTE_ALIGNED128(a) a __attribute__ ((aligned (128)))
+		#ifndef assert
+		#include <assert.h>
+		#endif
+		#ifdef BT_DEBUG
+			#ifdef __SPU__
+				#include <spu_printf.h>
+				#define printf spu_printf
+				#define btAssert(x) {if(!(x)){printf("Assert " __FILE__ ":%u ("#x")\n", __LINE__);spu_hcmpeq(0,0);}}
+			#else
+				#define btAssert assert
+			#endif
+	
+		#else//BT_DEBUG
+				#define btAssert(x)
+		#endif//BT_DEBUG
+		//btFullAssert is optional, slows down a lot
+		#define btFullAssert(x)
+
+		#define btLikely(_c)  _c
+		#define btUnlikely(_c) _c
+
+	#else//defined	(__CELLOS_LV2__)
+
+		#ifdef USE_LIBSPE2
+
+			#define SIMD_FORCE_INLINE __inline
+			#define ATTRIBUTE_ALIGNED16(a) a __attribute__ ((aligned (16)))
+			#define ATTRIBUTE_ALIGNED64(a) a __attribute__ ((aligned (64)))
+			#define ATTRIBUTE_ALIGNED128(a) a __attribute__ ((aligned (128)))
+			#ifndef assert
+			#include <assert.h>
+			#endif
+	#ifdef BT_DEBUG
+			#define btAssert assert
+	#else
+			#define btAssert(x)
+	#endif
+			//btFullAssert is optional, slows down a lot
+			#define btFullAssert(x)
+
+
+			#define btLikely(_c)   __builtin_expect((_c), 1)
+			#define btUnlikely(_c) __builtin_expect((_c), 0)
+		
+
+		#else//USE_LIBSPE2
+	//non-windows systems
+
+			#if (defined (__APPLE__) && (!defined (BT_USE_DOUBLE_PRECISION)))
+				#if defined (__i386__) || defined (__x86_64__)
+					#define BT_USE_SIMD_VECTOR3
+					#define BT_USE_SSE
+					//BT_USE_SSE_IN_API is enabled on Mac OSX by default, because memory is automatically aligned on 16-byte boundaries
+					//if apps run into issues, we will disable the next line
+					#define BT_USE_SSE_IN_API
+					#ifdef BT_USE_SSE
+						// include appropriate SSE level
+						#if defined (__SSE4_1__)
+							#include <smmintrin.h>
+						#elif defined (__SSSE3__)
+							#include <tmmintrin.h>
+						#elif defined (__SSE3__)
+							#include <pmmintrin.h>
+						#else
+							#include <emmintrin.h>
+						#endif
+					#endif //BT_USE_SSE
+				#elif defined( __ARM_NEON__ )
+					#ifdef __clang__
+						#define BT_USE_NEON 1
+						#define BT_USE_SIMD_VECTOR3
+		
+						#if defined BT_USE_NEON && defined (__clang__)
+							#include <arm_neon.h>
+						#endif//BT_USE_NEON
+				   #endif //__clang__
+				#endif//__arm__
+
+				#define SIMD_FORCE_INLINE inline __attribute__ ((always_inline))
+			///@todo: check out alignment methods for other platforms/compilers
+				#define ATTRIBUTE_ALIGNED16(a) a __attribute__ ((aligned (16)))
+				#define ATTRIBUTE_ALIGNED64(a) a __attribute__ ((aligned (64)))
+				#define ATTRIBUTE_ALIGNED128(a) a __attribute__ ((aligned (128)))
+				#ifndef assert
+				#include <assert.h>
+				#endif
+
+				#if defined(DEBUG) || defined (_DEBUG)
+				 #if defined (__i386__) || defined (__x86_64__)
+				#include <stdio.h>
+				 #define btAssert(x)\
+				{\
+				if(!(x))\
+				{\
+					printf("Assert %s in line %d, file %s\n",#x, __LINE__, __FILE__);\
+					asm volatile ("int3");\
+				}\
+				}
+				#else//defined (__i386__) || defined (__x86_64__)
+					#define btAssert assert
+				#endif//defined (__i386__) || defined (__x86_64__)
+				#else//defined(DEBUG) || defined (_DEBUG)
+					#define btAssert(x)
+				#endif//defined(DEBUG) || defined (_DEBUG)
+
+				//btFullAssert is optional, slows down a lot
+				#define btFullAssert(x)
+				#define btLikely(_c)  _c
+				#define btUnlikely(_c) _c
+
+			#else//__APPLE__
+
+				#define SIMD_FORCE_INLINE inline
+				///@todo: check out alignment methods for other platforms/compilers
+				///#define ATTRIBUTE_ALIGNED16(a) a __attribute__ ((aligned (16)))
+				///#define ATTRIBUTE_ALIGNED64(a) a __attribute__ ((aligned (64)))
+				///#define ATTRIBUTE_ALIGNED128(a) a __attribute__ ((aligned (128)))
+				#define ATTRIBUTE_ALIGNED16(a) a
+				#define ATTRIBUTE_ALIGNED64(a) a
+				#define ATTRIBUTE_ALIGNED128(a) a
+				#ifndef assert
+				#include <assert.h>
+				#endif
+
+				#if defined(DEBUG) || defined (_DEBUG)
+					#define btAssert assert
+				#else
+					#define btAssert(x)
+				#endif
+
+				//btFullAssert is optional, slows down a lot
+				#define btFullAssert(x)
+				#define btLikely(_c)  _c
+				#define btUnlikely(_c) _c
+			#endif //__APPLE__ 
+		#endif // LIBSPE2
+	#endif	//__CELLOS_LV2__
+#endif//_WIN32
+
+
+///The btScalar type abstracts floating point numbers, to easily switch between double and single floating point precision.
+#if defined(BT_USE_DOUBLE_PRECISION)
+	typedef double btScalar;
+	//this number could be bigger in double precision
+	#define BT_LARGE_FLOAT 1e30
+#else
+	typedef float btScalar;
+	//keep BT_LARGE_FLOAT*BT_LARGE_FLOAT < FLT_MAX
+	#define BT_LARGE_FLOAT 1e18f
+#endif
+
+#ifdef BT_USE_SSE
+	typedef __m128 btSimdFloat4;
+#endif  //BT_USE_SSE
+
+#if defined(BT_USE_SSE)
+	//#if defined BT_USE_SSE_IN_API && defined (BT_USE_SSE)
+	#ifdef _WIN32
+
+		#ifndef BT_NAN
+			static int btNanMask = 0x7F800001;
+			#define BT_NAN (*(float *)&btNanMask)
+		#endif
+
+		#ifndef BT_INFINITY
+			static int btInfinityMask = 0x7F800000;
+			#define BT_INFINITY (*(float *)&btInfinityMask)
+			inline int btGetInfinityMask()  //suppress stupid compiler warning
+			{
+				return btInfinityMask;
+			}
+		#endif
+
+
+
+	//use this, in case there are clashes (such as xnamath.h)
+	#ifndef BT_NO_SIMD_OPERATOR_OVERLOADS
+	inline __m128 operator+(const __m128 A, const __m128 B)
+	{
+		return _mm_add_ps(A, B);
+	}
+
+	inline __m128 operator-(const __m128 A, const __m128 B)
+	{
+		return _mm_sub_ps(A, B);
+	}
+
+	inline __m128 operator*(const __m128 A, const __m128 B)
+	{
+		return _mm_mul_ps(A, B);
+	}
+	#endif  //BT_NO_SIMD_OPERATOR_OVERLOADS
+
+	#define btCastfTo128i(a) (_mm_castps_si128(a))
+	#define btCastfTo128d(a) (_mm_castps_pd(a))
+	#define btCastiTo128f(a) (_mm_castsi128_ps(a))
+	#define btCastdTo128f(a) (_mm_castpd_ps(a))
+	#define btCastdTo128i(a) (_mm_castpd_si128(a))
+	#define btAssign128(r0, r1, r2, r3) _mm_setr_ps(r0, r1, r2, r3)
+
+	#else  //_WIN32
+
+		#define btCastfTo128i(a) ((__m128i)(a))
+		#define btCastfTo128d(a) ((__m128d)(a))
+		#define btCastiTo128f(a) ((__m128)(a))
+		#define btCastdTo128f(a) ((__m128)(a))
+		#define btCastdTo128i(a) ((__m128i)(a))
+		#define btAssign128(r0, r1, r2, r3) \
+			(__m128) { r0, r1, r2, r3 }
+		#define BT_INFINITY INFINITY
+		#define BT_NAN NAN
+	#endif  //_WIN32
+#else//BT_USE_SSE
+
+	#ifdef BT_USE_NEON
+	#include <arm_neon.h>
+
+	typedef float32x4_t btSimdFloat4;
+	#define BT_INFINITY INFINITY
+	#define BT_NAN NAN
+	#define btAssign128(r0, r1, r2, r3) \
+		(float32x4_t) { r0, r1, r2, r3 }
+	#else  //BT_USE_NEON
+
+	#ifndef BT_INFINITY
+	struct btInfMaskConverter
+	{
+		union {
+			float mask;
+			int intmask;
+		};
+		btInfMaskConverter(int _mask = 0x7F800000)
+			: intmask(_mask)
+		{
+		}
+	};
+	static btInfMaskConverter btInfinityMask = 0x7F800000;
+	#define BT_INFINITY (btInfinityMask.mask)
+	inline int btGetInfinityMask()  //suppress stupid compiler warning
+	{
+		return btInfinityMask.intmask;
+	}
+	#endif
+	#endif  //BT_USE_NEON
+
+#endif  //BT_USE_SSE
+
+#ifdef BT_USE_NEON
+	#include <arm_neon.h>
+
+	typedef float32x4_t btSimdFloat4;
+	#define BT_INFINITY INFINITY
+	#define BT_NAN NAN
+	#define btAssign128(r0, r1, r2, r3) \
+		(float32x4_t) { r0, r1, r2, r3 }
+#endif//BT_USE_NEON
+
+#define BT_DECLARE_ALIGNED_ALLOCATOR()                                                                     \
+	SIMD_FORCE_INLINE void *operator new(size_t sizeInBytes) { return btAlignedAlloc(sizeInBytes, 16); }   \
+	SIMD_FORCE_INLINE void operator delete(void *ptr) { btAlignedFree(ptr); }                              \
+	SIMD_FORCE_INLINE void *operator new(size_t, void *ptr) { return ptr; }                                \
+	SIMD_FORCE_INLINE void operator delete(void *, void *) {}                                              \
+	SIMD_FORCE_INLINE void *operator new[](size_t sizeInBytes) { return btAlignedAlloc(sizeInBytes, 16); } \
+	SIMD_FORCE_INLINE void operator delete[](void *ptr) { btAlignedFree(ptr); }                            \
+	SIMD_FORCE_INLINE void *operator new[](size_t, void *ptr) { return ptr; }                              \
+	SIMD_FORCE_INLINE void operator delete[](void *, void *) {}
+
+#if defined(BT_USE_DOUBLE_PRECISION) || defined(BT_FORCE_DOUBLE_FUNCTIONS)
+
+	SIMD_FORCE_INLINE btScalar btSqrt(btScalar x)
+	{
+		return sqrt(x);
+	}
+	SIMD_FORCE_INLINE btScalar btFabs(btScalar x) { return fabs(x); }
+	SIMD_FORCE_INLINE btScalar btCos(btScalar x) { return cos(x); }
+	SIMD_FORCE_INLINE btScalar btSin(btScalar x) { return sin(x); }
+	SIMD_FORCE_INLINE btScalar btTan(btScalar x) { return tan(x); }
+	SIMD_FORCE_INLINE btScalar btAcos(btScalar x)
+	{
+		if (x < btScalar(-1)) x = btScalar(-1);
+		if (x > btScalar(1)) x = btScalar(1);
+		return acos(x);
+	}
+	SIMD_FORCE_INLINE btScalar btAsin(btScalar x)
+	{
+		if (x < btScalar(-1)) x = btScalar(-1);
+		if (x > btScalar(1)) x = btScalar(1);
+		return asin(x);
+	}
+	SIMD_FORCE_INLINE btScalar btAtan(btScalar x) { return atan(x); }
+	SIMD_FORCE_INLINE btScalar btAtan2(btScalar x, btScalar y) { return atan2(x, y); }
+	SIMD_FORCE_INLINE btScalar btExp(btScalar x) { return exp(x); }
+	SIMD_FORCE_INLINE btScalar btLog(btScalar x) { return log(x); }
+	SIMD_FORCE_INLINE btScalar btPow(btScalar x, btScalar y) { return pow(x, y); }
+	SIMD_FORCE_INLINE btScalar btFmod(btScalar x, btScalar y) { return fmod(x, y); }
+
+#else//BT_USE_DOUBLE_PRECISION
+
+	SIMD_FORCE_INLINE btScalar btSqrt(btScalar y)
+	{
+	#ifdef USE_APPROXIMATION
+	#ifdef __LP64__
+		float xhalf = 0.5f * y;
+		int i = *(int *)&y;
+		i = 0x5f375a86 - (i >> 1);
+		y = *(float *)&i;
+		y = y * (1.5f - xhalf * y * y);
+		y = y * (1.5f - xhalf * y * y);
+		y = y * (1.5f - xhalf * y * y);
+		y = 1 / y;
+		return y;
+	#else
+		double x, z, tempf;
+		unsigned long *tfptr = ((unsigned long *)&tempf) + 1;
+		tempf = y;
+		*tfptr = (0xbfcdd90a - *tfptr) >> 1; /* estimate of 1/sqrt(y) */
+		x = tempf;
+		z = y * btScalar(0.5);
+		x = (btScalar(1.5) * x) - (x * x) * (x * z); /* iteration formula     */
+		x = (btScalar(1.5) * x) - (x * x) * (x * z);
+		x = (btScalar(1.5) * x) - (x * x) * (x * z);
+		x = (btScalar(1.5) * x) - (x * x) * (x * z);
+		x = (btScalar(1.5) * x) - (x * x) * (x * z);
+		return x * y;
+	#endif
+	#else
+		return sqrtf(y);
+	#endif
+	}
+	SIMD_FORCE_INLINE btScalar btFabs(btScalar x) { return fabsf(x); }
+	SIMD_FORCE_INLINE btScalar btCos(btScalar x) { return cosf(x); }
+	SIMD_FORCE_INLINE btScalar btSin(btScalar x) { return sinf(x); }
+	SIMD_FORCE_INLINE btScalar btTan(btScalar x) { return tanf(x); }
+	SIMD_FORCE_INLINE btScalar btAcos(btScalar x)
+	{
+		if (x < btScalar(-1))
+			x = btScalar(-1);
+		if (x > btScalar(1))
+			x = btScalar(1);
+		return acosf(x);
+	}
+	SIMD_FORCE_INLINE btScalar btAsin(btScalar x)
+	{
+		if (x < btScalar(-1))
+			x = btScalar(-1);
+		if (x > btScalar(1))
+			x = btScalar(1);
+		return asinf(x);
+	}
+	SIMD_FORCE_INLINE btScalar btAtan(btScalar x) { return atanf(x); }
+	SIMD_FORCE_INLINE btScalar btAtan2(btScalar x, btScalar y) { return atan2f(x, y); }
+	SIMD_FORCE_INLINE btScalar btExp(btScalar x) { return expf(x); }
+	SIMD_FORCE_INLINE btScalar btLog(btScalar x) { return logf(x); }
+	SIMD_FORCE_INLINE btScalar btPow(btScalar x, btScalar y) { return powf(x, y); }
+	SIMD_FORCE_INLINE btScalar btFmod(btScalar x, btScalar y) { return fmodf(x, y); }
+
+#endif//BT_USE_DOUBLE_PRECISION
+
+#define SIMD_PI btScalar(3.1415926535897932384626433832795029)
+#define SIMD_2_PI (btScalar(2.0) * SIMD_PI)
+#define SIMD_HALF_PI (SIMD_PI * btScalar(0.5))
+#define SIMD_RADS_PER_DEG (SIMD_2_PI / btScalar(360.0))
+#define SIMD_DEGS_PER_RAD (btScalar(360.0) / SIMD_2_PI)
+#define SIMDSQRT12 btScalar(0.7071067811865475244008443621048490)
+#define btRecipSqrt(x) ((btScalar)(btScalar(1.0) / btSqrt(btScalar(x)))) /* reciprocal square root */
+#define btRecip(x) (btScalar(1.0) / btScalar(x))
+
+#ifdef BT_USE_DOUBLE_PRECISION
+	#define SIMD_EPSILON DBL_EPSILON
+	#define SIMD_INFINITY DBL_MAX
+	#define BT_ONE 1.0
+	#define BT_ZERO 0.0
+	#define BT_TWO 2.0
+	#define BT_HALF 0.5
+#else
+	#define SIMD_EPSILON FLT_EPSILON
+	#define SIMD_INFINITY FLT_MAX
+	#define BT_ONE 1.0f
+	#define BT_ZERO 0.0f
+	#define BT_TWO 2.0f
+	#define BT_HALF 0.5f
+#endif
+
+// clang-format on
+
+SIMD_FORCE_INLINE btScalar btAtan2Fast(btScalar y, btScalar x)
+{
+	btScalar coeff_1 = SIMD_PI / 4.0f;
+	btScalar coeff_2 = 3.0f * coeff_1;
+	btScalar abs_y = btFabs(y);
+	btScalar angle;
+	if (x >= 0.0f)
+	{
+		btScalar r = (x - abs_y) / (x + abs_y);
+		angle = coeff_1 - coeff_1 * r;
+	}
+	else
+	{
+		btScalar r = (x + abs_y) / (abs_y - x);
+		angle = coeff_2 - coeff_1 * r;
+	}
+	return (y < 0.0f) ? -angle : angle;
+}
+
+SIMD_FORCE_INLINE bool btFuzzyZero(btScalar x) { return btFabs(x) < SIMD_EPSILON; }
+
+SIMD_FORCE_INLINE bool btEqual(btScalar a, btScalar eps)
+{
+	return (((a) <= eps) && !((a) < -eps));
+}
+SIMD_FORCE_INLINE bool btGreaterEqual(btScalar a, btScalar eps)
+{
+	return (!((a) <= eps));
+}
+
+SIMD_FORCE_INLINE int btIsNegative(btScalar x)
+{
+	return x < btScalar(0.0) ? 1 : 0;
+}
+
+SIMD_FORCE_INLINE btScalar btRadians(btScalar x) { return x * SIMD_RADS_PER_DEG; }
+SIMD_FORCE_INLINE btScalar btDegrees(btScalar x) { return x * SIMD_DEGS_PER_RAD; }
+
+#define BT_DECLARE_HANDLE(name) \
+	typedef struct name##__     \
+	{                           \
+		int unused;             \
+	} * name
+
+#ifndef btFsel
+SIMD_FORCE_INLINE btScalar btFsel(btScalar a, btScalar b, btScalar c)
+{
+	return a >= 0 ? b : c;
+}
+#endif
+#define btFsels(a, b, c) (btScalar) btFsel(a, b, c)
+
+SIMD_FORCE_INLINE bool btMachineIsLittleEndian()
+{
+	long int i = 1;
+	const char *p = (const char *)&i;
+	if (p[0] == 1)  // Lowest address contains the least significant byte
+		return true;
+	else
+		return false;
+}
+
+///btSelect avoids branches, which makes performance much better for consoles like Playstation 3 and XBox 360
+///Thanks Phil Knight. See also http://www.cellperformance.com/articles/2006/04/more_techniques_for_eliminatin_1.html
+SIMD_FORCE_INLINE unsigned btSelect(unsigned condition, unsigned valueIfConditionNonZero, unsigned valueIfConditionZero)
+{
+	// Set testNz to 0xFFFFFFFF if condition is nonzero, 0x00000000 if condition is zero
+	// Rely on positive value or'ed with its negative having sign bit on
+	// and zero value or'ed with its negative (which is still zero) having sign bit off
+	// Use arithmetic shift right, shifting the sign bit through all 32 bits
+	unsigned testNz = (unsigned)(((int)condition | -(int)condition) >> 31);
+	unsigned testEqz = ~testNz;
+	return ((valueIfConditionNonZero & testNz) | (valueIfConditionZero & testEqz));
+}
+SIMD_FORCE_INLINE int btSelect(unsigned condition, int valueIfConditionNonZero, int valueIfConditionZero)
+{
+	unsigned testNz = (unsigned)(((int)condition | -(int)condition) >> 31);
+	unsigned testEqz = ~testNz;
+	return static_cast<int>((valueIfConditionNonZero & testNz) | (valueIfConditionZero & testEqz));
+}
+SIMD_FORCE_INLINE float btSelect(unsigned condition, float valueIfConditionNonZero, float valueIfConditionZero)
+{
+#ifdef BT_HAVE_NATIVE_FSEL
+	return (float)btFsel((btScalar)condition - btScalar(1.0f), valueIfConditionNonZero, valueIfConditionZero);
+#else
+	return (condition != 0) ? valueIfConditionNonZero : valueIfConditionZero;
+#endif
+}
+
+template <typename T>
+SIMD_FORCE_INLINE void btSwap(T &a, T &b)
+{
+	T tmp = a;
+	a = b;
+	b = tmp;
+}
+
+//PCK: endian swapping functions
+SIMD_FORCE_INLINE unsigned btSwapEndian(unsigned val)
+{
+	return (((val & 0xff000000) >> 24) | ((val & 0x00ff0000) >> 8) | ((val & 0x0000ff00) << 8) | ((val & 0x000000ff) << 24));
+}
+
+SIMD_FORCE_INLINE unsigned short btSwapEndian(unsigned short val)
+{
+	return static_cast<unsigned short>(((val & 0xff00) >> 8) | ((val & 0x00ff) << 8));
+}
+
+SIMD_FORCE_INLINE unsigned btSwapEndian(int val)
+{
+	return btSwapEndian((unsigned)val);
+}
+
+SIMD_FORCE_INLINE unsigned short btSwapEndian(short val)
+{
+	return btSwapEndian((unsigned short)val);
+}
+
+///btSwapFloat uses using char pointers to swap the endianness
+////btSwapFloat/btSwapDouble will NOT return a float, because the machine might 'correct' invalid floating point values
+///Not all values of sign/exponent/mantissa are valid floating point numbers according to IEEE 754.
+///When a floating point unit is faced with an invalid value, it may actually change the value, or worse, throw an exception.
+///In most systems, running user mode code, you wouldn't get an exception, but instead the hardware/os/runtime will 'fix' the number for you.
+///so instead of returning a float/double, we return integer/long long integer
+SIMD_FORCE_INLINE unsigned int btSwapEndianFloat(float d)
+{
+	unsigned int a = 0;
+	unsigned char *dst = (unsigned char *)&a;
+	unsigned char *src = (unsigned char *)&d;
+
+	dst[0] = src[3];
+	dst[1] = src[2];
+	dst[2] = src[1];
+	dst[3] = src[0];
+	return a;
+}
+
+// unswap using char pointers
+SIMD_FORCE_INLINE float btUnswapEndianFloat(unsigned int a)
+{
+	float d = 0.0f;
+	unsigned char *src = (unsigned char *)&a;
+	unsigned char *dst = (unsigned char *)&d;
+
+	dst[0] = src[3];
+	dst[1] = src[2];
+	dst[2] = src[1];
+	dst[3] = src[0];
+
+	return d;
+}
+
+// swap using char pointers
+SIMD_FORCE_INLINE void btSwapEndianDouble(double d, unsigned char *dst)
+{
+	unsigned char *src = (unsigned char *)&d;
+
+	dst[0] = src[7];
+	dst[1] = src[6];
+	dst[2] = src[5];
+	dst[3] = src[4];
+	dst[4] = src[3];
+	dst[5] = src[2];
+	dst[6] = src[1];
+	dst[7] = src[0];
+}
+
+// unswap using char pointers
+SIMD_FORCE_INLINE double btUnswapEndianDouble(const unsigned char *src)
+{
+	double d = 0.0;
+	unsigned char *dst = (unsigned char *)&d;
+
+	dst[0] = src[7];
+	dst[1] = src[6];
+	dst[2] = src[5];
+	dst[3] = src[4];
+	dst[4] = src[3];
+	dst[5] = src[2];
+	dst[6] = src[1];
+	dst[7] = src[0];
+
+	return d;
+}
+
+template <typename T>
+SIMD_FORCE_INLINE void btSetZero(T *a, int n)
+{
+	T *acurr = a;
+	size_t ncurr = n;
+	while (ncurr > 0)
+	{
+		*(acurr++) = 0;
+		--ncurr;
+	}
+}
+
+SIMD_FORCE_INLINE btScalar btLargeDot(const btScalar *a, const btScalar *b, int n)
+{
+	btScalar p0, q0, m0, p1, q1, m1, sum;
+	sum = 0;
+	n -= 2;
+	while (n >= 0)
+	{
+		p0 = a[0];
+		q0 = b[0];
+		m0 = p0 * q0;
+		p1 = a[1];
+		q1 = b[1];
+		m1 = p1 * q1;
+		sum += m0;
+		sum += m1;
+		a += 2;
+		b += 2;
+		n -= 2;
+	}
+	n += 2;
+	while (n > 0)
+	{
+		sum += (*a) * (*b);
+		a++;
+		b++;
+		n--;
+	}
+	return sum;
+}
+
+// returns normalized value in range [-SIMD_PI, SIMD_PI]
+SIMD_FORCE_INLINE btScalar btNormalizeAngle(btScalar angleInRadians)
+{
+	angleInRadians = btFmod(angleInRadians, SIMD_2_PI);
+	if (angleInRadians < -SIMD_PI)
+	{
+		return angleInRadians + SIMD_2_PI;
+	}
+	else if (angleInRadians > SIMD_PI)
+	{
+		return angleInRadians - SIMD_2_PI;
+	}
+	else
+	{
+		return angleInRadians;
+	}
+}
+
+///rudimentary class to provide type info
+struct btTypedObject
+{
+	btTypedObject(int objectType)
+		: m_objectType(objectType)
+	{
+	}
+	int m_objectType;
+	inline int getObjectType() const
+	{
+		return m_objectType;
+	}
+};
+
+///align a pointer to the provided alignment, upwards
+template <typename T>
+T *btAlignPointer(T *unalignedPtr, size_t alignment)
+{
+	struct btConvertPointerSizeT
+	{
+		union {
+			T *ptr;
+			size_t integer;
+		};
+	};
+	btConvertPointerSizeT converter;
+
+	const size_t bit_mask = ~(alignment - 1);
+	converter.ptr = unalignedPtr;
+	converter.integer += alignment - 1;
+	converter.integer &= bit_mask;
+	return converter.ptr;
+}
+
+#endif  //BT_SCALAR_H
diff --git a/engine/inc/bullet/LinearMath/btSerializer.h b/engine/inc/bullet/LinearMath/btSerializer.h
new file mode 100644
index 00000000..9abcf031
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btSerializer.h
@@ -0,0 +1,869 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_SERIALIZER_H
+#define BT_SERIALIZER_H
+
+#include "btScalar.h"  // has definitions like SIMD_FORCE_INLINE
+#include "btHashMap.h"
+
+#if !defined(__CELLOS_LV2__) && !defined(__MWERKS__)
+#include <memory.h>
+#endif
+#include <string.h>
+
+extern char sBulletDNAstr[];
+extern int sBulletDNAlen;
+extern char sBulletDNAstr64[];
+extern int sBulletDNAlen64;
+
+SIMD_FORCE_INLINE int btStrLen(const char* str)
+{
+	if (!str)
+		return (0);
+	int len = 0;
+
+	while (*str != 0)
+	{
+		str++;
+		len++;
+	}
+
+	return len;
+}
+
+class btChunk
+{
+public:
+	int m_chunkCode;
+	int m_length;
+	void* m_oldPtr;
+	int m_dna_nr;
+	int m_number;
+};
+
+enum btSerializationFlags
+{
+	BT_SERIALIZE_NO_BVH = 1,
+	BT_SERIALIZE_NO_TRIANGLEINFOMAP = 2,
+	BT_SERIALIZE_NO_DUPLICATE_ASSERT = 4,
+	BT_SERIALIZE_CONTACT_MANIFOLDS = 8,
+};
+
+class btSerializer
+{
+public:
+	virtual ~btSerializer() {}
+
+	virtual const unsigned char* getBufferPointer() const = 0;
+
+	virtual int getCurrentBufferSize() const = 0;
+
+	virtual btChunk* allocate(size_t size, int numElements) = 0;
+
+	virtual void finalizeChunk(btChunk* chunk, const char* structType, int chunkCode, void* oldPtr) = 0;
+
+	virtual void* findPointer(void* oldPtr) = 0;
+
+	virtual void* getUniquePointer(void* oldPtr) = 0;
+
+	virtual void startSerialization() = 0;
+
+	virtual void finishSerialization() = 0;
+
+	virtual const char* findNameForPointer(const void* ptr) const = 0;
+
+	virtual void registerNameForPointer(const void* ptr, const char* name) = 0;
+
+	virtual void serializeName(const char* ptr) = 0;
+
+	virtual int getSerializationFlags() const = 0;
+
+	virtual void setSerializationFlags(int flags) = 0;
+
+	virtual int getNumChunks() const = 0;
+
+	virtual const btChunk* getChunk(int chunkIndex) const = 0;
+};
+
+#define BT_HEADER_LENGTH 12
+#if defined(__sgi) || defined(__sparc) || defined(__sparc__) || defined(__PPC__) || defined(__ppc__) || defined(__BIG_ENDIAN__)
+#define BT_MAKE_ID(a, b, c, d) ((int)(a) << 24 | (int)(b) << 16 | (c) << 8 | (d))
+#else
+#define BT_MAKE_ID(a, b, c, d) ((int)(d) << 24 | (int)(c) << 16 | (b) << 8 | (a))
+#endif
+
+#define BT_MULTIBODY_CODE BT_MAKE_ID('M', 'B', 'D', 'Y')
+#define BT_MB_LINKCOLLIDER_CODE BT_MAKE_ID('M', 'B', 'L', 'C')
+#define BT_SOFTBODY_CODE BT_MAKE_ID('S', 'B', 'D', 'Y')
+#define BT_COLLISIONOBJECT_CODE BT_MAKE_ID('C', 'O', 'B', 'J')
+#define BT_RIGIDBODY_CODE BT_MAKE_ID('R', 'B', 'D', 'Y')
+#define BT_CONSTRAINT_CODE BT_MAKE_ID('C', 'O', 'N', 'S')
+#define BT_BOXSHAPE_CODE BT_MAKE_ID('B', 'O', 'X', 'S')
+#define BT_QUANTIZED_BVH_CODE BT_MAKE_ID('Q', 'B', 'V', 'H')
+#define BT_TRIANLGE_INFO_MAP BT_MAKE_ID('T', 'M', 'A', 'P')
+#define BT_SHAPE_CODE BT_MAKE_ID('S', 'H', 'A', 'P')
+#define BT_ARRAY_CODE BT_MAKE_ID('A', 'R', 'A', 'Y')
+#define BT_SBMATERIAL_CODE BT_MAKE_ID('S', 'B', 'M', 'T')
+#define BT_SBNODE_CODE BT_MAKE_ID('S', 'B', 'N', 'D')
+#define BT_DYNAMICSWORLD_CODE BT_MAKE_ID('D', 'W', 'L', 'D')
+#define BT_CONTACTMANIFOLD_CODE BT_MAKE_ID('C', 'O', 'N', 'T')
+#define BT_DNA_CODE BT_MAKE_ID('D', 'N', 'A', '1')
+
+struct btPointerUid
+{
+	union {
+		void* m_ptr;
+		int m_uniqueIds[2];
+	};
+};
+
+struct btBulletSerializedArrays
+{
+	btBulletSerializedArrays()
+	{
+	}
+	btAlignedObjectArray<struct btQuantizedBvhDoubleData*> m_bvhsDouble;
+	btAlignedObjectArray<struct btQuantizedBvhFloatData*> m_bvhsFloat;
+	btAlignedObjectArray<struct btCollisionShapeData*> m_colShapeData;
+	btAlignedObjectArray<struct btDynamicsWorldDoubleData*> m_dynamicWorldInfoDataDouble;
+	btAlignedObjectArray<struct btDynamicsWorldFloatData*> m_dynamicWorldInfoDataFloat;
+	btAlignedObjectArray<struct btRigidBodyDoubleData*> m_rigidBodyDataDouble;
+	btAlignedObjectArray<struct btRigidBodyFloatData*> m_rigidBodyDataFloat;
+	btAlignedObjectArray<struct btCollisionObjectDoubleData*> m_collisionObjectDataDouble;
+	btAlignedObjectArray<struct btCollisionObjectFloatData*> m_collisionObjectDataFloat;
+	btAlignedObjectArray<struct btTypedConstraintFloatData*> m_constraintDataFloat;
+	btAlignedObjectArray<struct btTypedConstraintDoubleData*> m_constraintDataDouble;
+	btAlignedObjectArray<struct btTypedConstraintData*> m_constraintData;  //for backwards compatibility
+	btAlignedObjectArray<struct btSoftBodyFloatData*> m_softBodyFloatData;
+	btAlignedObjectArray<struct btSoftBodyDoubleData*> m_softBodyDoubleData;
+};
+
+///The btDefaultSerializer is the main Bullet serialization class.
+///The constructor takes an optional argument for backwards compatibility, it is recommended to leave this empty/zero.
+class btDefaultSerializer : public btSerializer
+{
+protected:
+	btAlignedObjectArray<char*> mTypes;
+	btAlignedObjectArray<short*> mStructs;
+	btAlignedObjectArray<short> mTlens;
+	btHashMap<btHashInt, int> mStructReverse;
+	btHashMap<btHashString, int> mTypeLookup;
+
+	btHashMap<btHashPtr, void*> m_chunkP;
+
+	btHashMap<btHashPtr, const char*> m_nameMap;
+
+	btHashMap<btHashPtr, btPointerUid> m_uniquePointers;
+	int m_uniqueIdGenerator;
+
+	int m_totalSize;
+	unsigned char* m_buffer;
+	bool m_ownsBuffer;
+	int m_currentSize;
+	void* m_dna;
+	int m_dnaLength;
+
+	int m_serializationFlags;
+
+	btAlignedObjectArray<btChunk*> m_chunkPtrs;
+
+protected:
+	virtual void* findPointer(void* oldPtr)
+	{
+		void** ptr = m_chunkP.find(oldPtr);
+		if (ptr && *ptr)
+			return *ptr;
+		return 0;
+	}
+
+	virtual void writeDNA()
+	{
+		btChunk* dnaChunk = allocate(m_dnaLength, 1);
+		memcpy(dnaChunk->m_oldPtr, m_dna, m_dnaLength);
+		finalizeChunk(dnaChunk, "DNA1", BT_DNA_CODE, m_dna);
+	}
+
+	int getReverseType(const char* type) const
+	{
+		btHashString key(type);
+		const int* valuePtr = mTypeLookup.find(key);
+		if (valuePtr)
+			return *valuePtr;
+
+		return -1;
+	}
+
+	void initDNA(const char* bdnaOrg, int dnalen)
+	{
+		///was already initialized
+		if (m_dna)
+			return;
+
+		int littleEndian = 1;
+		littleEndian = ((char*)&littleEndian)[0];
+
+		m_dna = btAlignedAlloc(dnalen, 16);
+		memcpy(m_dna, bdnaOrg, dnalen);
+		m_dnaLength = dnalen;
+
+		int* intPtr = 0;
+		short* shtPtr = 0;
+		char* cp = 0;
+		int dataLen = 0;
+		intPtr = (int*)m_dna;
+
+		/*
+				SDNA (4 bytes) (magic number)
+				NAME (4 bytes)
+				<nr> (4 bytes) amount of names (int)
+				<string>
+				<string>
+			*/
+
+		if (strncmp((const char*)m_dna, "SDNA", 4) == 0)
+		{
+			// skip ++ NAME
+			intPtr++;
+			intPtr++;
+		}
+
+		// Parse names
+		if (!littleEndian)
+			*intPtr = btSwapEndian(*intPtr);
+
+		dataLen = *intPtr;
+
+		intPtr++;
+
+		cp = (char*)intPtr;
+		int i;
+		for (i = 0; i < dataLen; i++)
+		{
+			while (*cp) cp++;
+			cp++;
+		}
+		cp = btAlignPointer(cp, 4);
+
+		/*
+				TYPE (4 bytes)
+				<nr> amount of types (int)
+				<string>
+				<string>
+			*/
+
+		intPtr = (int*)cp;
+		btAssert(strncmp(cp, "TYPE", 4) == 0);
+		intPtr++;
+
+		if (!littleEndian)
+			*intPtr = btSwapEndian(*intPtr);
+
+		dataLen = *intPtr;
+		intPtr++;
+
+		cp = (char*)intPtr;
+		for (i = 0; i < dataLen; i++)
+		{
+			mTypes.push_back(cp);
+			while (*cp) cp++;
+			cp++;
+		}
+
+		cp = btAlignPointer(cp, 4);
+
+		/*
+				TLEN (4 bytes)
+				<len> (short) the lengths of types
+				<len>
+			*/
+
+		// Parse type lens
+		intPtr = (int*)cp;
+		btAssert(strncmp(cp, "TLEN", 4) == 0);
+		intPtr++;
+
+		dataLen = (int)mTypes.size();
+
+		shtPtr = (short*)intPtr;
+		for (i = 0; i < dataLen; i++, shtPtr++)
+		{
+			if (!littleEndian)
+				shtPtr[0] = btSwapEndian(shtPtr[0]);
+			mTlens.push_back(shtPtr[0]);
+		}
+
+		if (dataLen & 1) shtPtr++;
+
+		/*
+				STRC (4 bytes)
+				<nr> amount of structs (int)
+				<typenr>
+				<nr_of_elems>
+				<typenr>
+				<namenr>
+				<typenr>
+				<namenr>
+			*/
+
+		intPtr = (int*)shtPtr;
+		cp = (char*)intPtr;
+		btAssert(strncmp(cp, "STRC", 4) == 0);
+		intPtr++;
+
+		if (!littleEndian)
+			*intPtr = btSwapEndian(*intPtr);
+		dataLen = *intPtr;
+		intPtr++;
+
+		shtPtr = (short*)intPtr;
+		for (i = 0; i < dataLen; i++)
+		{
+			mStructs.push_back(shtPtr);
+
+			if (!littleEndian)
+			{
+				shtPtr[0] = btSwapEndian(shtPtr[0]);
+				shtPtr[1] = btSwapEndian(shtPtr[1]);
+
+				int len = shtPtr[1];
+				shtPtr += 2;
+
+				for (int a = 0; a < len; a++, shtPtr += 2)
+				{
+					shtPtr[0] = btSwapEndian(shtPtr[0]);
+					shtPtr[1] = btSwapEndian(shtPtr[1]);
+				}
+			}
+			else
+			{
+				shtPtr += (2 * shtPtr[1]) + 2;
+			}
+		}
+
+		// build reverse lookups
+		for (i = 0; i < (int)mStructs.size(); i++)
+		{
+			short* strc = mStructs.at(i);
+			mStructReverse.insert(strc[0], i);
+			mTypeLookup.insert(btHashString(mTypes[strc[0]]), i);
+		}
+	}
+
+public:
+	btHashMap<btHashPtr, void*> m_skipPointers;
+
+	btDefaultSerializer(int totalSize = 0, unsigned char* buffer = 0)
+		: m_uniqueIdGenerator(0),
+		  m_totalSize(totalSize),
+		  m_currentSize(0),
+		  m_dna(0),
+		  m_dnaLength(0),
+		  m_serializationFlags(0)
+	{
+		if (buffer == 0)
+		{
+			m_buffer = m_totalSize ? (unsigned char*)btAlignedAlloc(totalSize, 16) : 0;
+			m_ownsBuffer = true;
+		}
+		else
+		{
+			m_buffer = buffer;
+			m_ownsBuffer = false;
+		}
+
+		const bool VOID_IS_8 = ((sizeof(void*) == 8));
+
+#ifdef BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+		if (VOID_IS_8)
+		{
+#if _WIN64
+			initDNA((const char*)sBulletDNAstr64, sBulletDNAlen64);
+#else
+			btAssert(0);
+#endif
+		}
+		else
+		{
+#ifndef _WIN64
+			initDNA((const char*)sBulletDNAstr, sBulletDNAlen);
+#else
+			btAssert(0);
+#endif
+		}
+
+#else   //BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+		if (VOID_IS_8)
+		{
+			initDNA((const char*)sBulletDNAstr64, sBulletDNAlen64);
+		}
+		else
+		{
+			initDNA((const char*)sBulletDNAstr, sBulletDNAlen);
+		}
+#endif  //BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+	}
+
+	virtual ~btDefaultSerializer()
+	{
+		if (m_buffer && m_ownsBuffer)
+			btAlignedFree(m_buffer);
+		if (m_dna)
+			btAlignedFree(m_dna);
+	}
+
+	static int getMemoryDnaSizeInBytes()
+	{
+		const bool VOID_IS_8 = ((sizeof(void*) == 8));
+
+		if (VOID_IS_8)
+		{
+			return sBulletDNAlen64;
+		}
+		return sBulletDNAlen;
+	}
+	static const char* getMemoryDna()
+	{
+		const bool VOID_IS_8 = ((sizeof(void*) == 8));
+		if (VOID_IS_8)
+		{
+			return (const char*)sBulletDNAstr64;
+		}
+		return (const char*)sBulletDNAstr;
+	}
+
+	void insertHeader()
+	{
+		writeHeader(m_buffer);
+		m_currentSize += BT_HEADER_LENGTH;
+	}
+
+	void writeHeader(unsigned char* buffer) const
+	{
+#ifdef BT_USE_DOUBLE_PRECISION
+		memcpy(buffer, "BULLETd", 7);
+#else
+		memcpy(buffer, "BULLETf", 7);
+#endif  //BT_USE_DOUBLE_PRECISION
+
+		int littleEndian = 1;
+		littleEndian = ((char*)&littleEndian)[0];
+
+		if (sizeof(void*) == 8)
+		{
+			buffer[7] = '-';
+		}
+		else
+		{
+			buffer[7] = '_';
+		}
+
+		if (littleEndian)
+		{
+			buffer[8] = 'v';
+		}
+		else
+		{
+			buffer[8] = 'V';
+		}
+
+		buffer[9] = '3';
+		buffer[10] = '0';
+		buffer[11] = '7';
+	}
+
+	virtual void startSerialization()
+	{
+		m_uniqueIdGenerator = 1;
+		if (m_totalSize)
+		{
+			unsigned char* buffer = internalAlloc(BT_HEADER_LENGTH);
+			writeHeader(buffer);
+		}
+	}
+
+	virtual void finishSerialization()
+	{
+		writeDNA();
+
+		//if we didn't pre-allocate a buffer, we need to create a contiguous buffer now
+		int mysize = 0;
+		if (!m_totalSize)
+		{
+			if (m_buffer)
+				btAlignedFree(m_buffer);
+
+			m_currentSize += BT_HEADER_LENGTH;
+			m_buffer = (unsigned char*)btAlignedAlloc(m_currentSize, 16);
+
+			unsigned char* currentPtr = m_buffer;
+			writeHeader(m_buffer);
+			currentPtr += BT_HEADER_LENGTH;
+			mysize += BT_HEADER_LENGTH;
+			for (int i = 0; i < m_chunkPtrs.size(); i++)
+			{
+				int curLength = sizeof(btChunk) + m_chunkPtrs[i]->m_length;
+				memcpy(currentPtr, m_chunkPtrs[i], curLength);
+				btAlignedFree(m_chunkPtrs[i]);
+				currentPtr += curLength;
+				mysize += curLength;
+			}
+		}
+
+		mTypes.clear();
+		mStructs.clear();
+		mTlens.clear();
+		mStructReverse.clear();
+		mTypeLookup.clear();
+		m_skipPointers.clear();
+		m_chunkP.clear();
+		m_nameMap.clear();
+		m_uniquePointers.clear();
+		m_chunkPtrs.clear();
+	}
+
+	virtual void* getUniquePointer(void* oldPtr)
+	{
+		btAssert(m_uniqueIdGenerator >= 0);
+		if (!oldPtr)
+			return 0;
+
+		btPointerUid* uptr = (btPointerUid*)m_uniquePointers.find(oldPtr);
+		if (uptr)
+		{
+			return uptr->m_ptr;
+		}
+
+		void** ptr2 = m_skipPointers[oldPtr];
+		if (ptr2)
+		{
+			return 0;
+		}
+
+		m_uniqueIdGenerator++;
+
+		btPointerUid uid;
+		uid.m_uniqueIds[0] = m_uniqueIdGenerator;
+		uid.m_uniqueIds[1] = m_uniqueIdGenerator;
+		m_uniquePointers.insert(oldPtr, uid);
+		return uid.m_ptr;
+	}
+
+	virtual const unsigned char* getBufferPointer() const
+	{
+		return m_buffer;
+	}
+
+	virtual int getCurrentBufferSize() const
+	{
+		return m_currentSize;
+	}
+
+	virtual void finalizeChunk(btChunk* chunk, const char* structType, int chunkCode, void* oldPtr)
+	{
+		if (!(m_serializationFlags & BT_SERIALIZE_NO_DUPLICATE_ASSERT))
+		{
+			btAssert(!findPointer(oldPtr));
+		}
+
+		chunk->m_dna_nr = getReverseType(structType);
+
+		chunk->m_chunkCode = chunkCode;
+
+		void* uniquePtr = getUniquePointer(oldPtr);
+
+		m_chunkP.insert(oldPtr, uniquePtr);  //chunk->m_oldPtr);
+		chunk->m_oldPtr = uniquePtr;         //oldPtr;
+	}
+
+	virtual unsigned char* internalAlloc(size_t size)
+	{
+		unsigned char* ptr = 0;
+
+		if (m_totalSize)
+		{
+			ptr = m_buffer + m_currentSize;
+			m_currentSize += int(size);
+			btAssert(m_currentSize < m_totalSize);
+		}
+		else
+		{
+			ptr = (unsigned char*)btAlignedAlloc(size, 16);
+			m_currentSize += int(size);
+		}
+		return ptr;
+	}
+
+	virtual btChunk* allocate(size_t size, int numElements)
+	{
+		unsigned char* ptr = internalAlloc(int(size) * numElements + sizeof(btChunk));
+
+		unsigned char* data = ptr + sizeof(btChunk);
+
+		btChunk* chunk = (btChunk*)ptr;
+		chunk->m_chunkCode = 0;
+		chunk->m_oldPtr = data;
+		chunk->m_length = int(size) * numElements;
+		chunk->m_number = numElements;
+
+		m_chunkPtrs.push_back(chunk);
+
+		return chunk;
+	}
+
+	virtual const char* findNameForPointer(const void* ptr) const
+	{
+		const char* const* namePtr = m_nameMap.find(ptr);
+		if (namePtr && *namePtr)
+			return *namePtr;
+		return 0;
+	}
+
+	virtual void registerNameForPointer(const void* ptr, const char* name)
+	{
+		m_nameMap.insert(ptr, name);
+	}
+
+	virtual void serializeName(const char* name)
+	{
+		if (name)
+		{
+			//don't serialize name twice
+			if (findPointer((void*)name))
+				return;
+
+			int len = btStrLen(name);
+			if (len)
+			{
+				int newLen = len + 1;
+				int padding = ((newLen + 3) & ~3) - newLen;
+				newLen += padding;
+
+				//serialize name string now
+				btChunk* chunk = allocate(sizeof(char), newLen);
+				char* destinationName = (char*)chunk->m_oldPtr;
+				for (int i = 0; i < len; i++)
+				{
+					destinationName[i] = name[i];
+				}
+				destinationName[len] = 0;
+				finalizeChunk(chunk, "char", BT_ARRAY_CODE, (void*)name);
+			}
+		}
+	}
+
+	virtual int getSerializationFlags() const
+	{
+		return m_serializationFlags;
+	}
+
+	virtual void setSerializationFlags(int flags)
+	{
+		m_serializationFlags = flags;
+	}
+	int getNumChunks() const
+	{
+		return m_chunkPtrs.size();
+	}
+
+	const btChunk* getChunk(int chunkIndex) const
+	{
+		return m_chunkPtrs[chunkIndex];
+	}
+};
+
+///In general it is best to use btDefaultSerializer,
+///in particular when writing the data to disk or sending it over the network.
+///The btInMemorySerializer is experimental and only suitable in a few cases.
+///The btInMemorySerializer takes a shortcut and can be useful to create a deep-copy
+///of objects. There will be a demo on how to use the btInMemorySerializer.
+#ifdef ENABLE_INMEMORY_SERIALIZER
+
+struct btInMemorySerializer : public btDefaultSerializer
+{
+	btHashMap<btHashPtr, btChunk*> m_uid2ChunkPtr;
+	btHashMap<btHashPtr, void*> m_orgPtr2UniqueDataPtr;
+	btHashMap<btHashString, const void*> m_names2Ptr;
+
+	btBulletSerializedArrays m_arrays;
+
+	btInMemorySerializer(int totalSize = 0, unsigned char* buffer = 0)
+		: btDefaultSerializer(totalSize, buffer)
+	{
+	}
+
+	virtual void startSerialization()
+	{
+		m_uid2ChunkPtr.clear();
+		//todo: m_arrays.clear();
+		btDefaultSerializer::startSerialization();
+	}
+
+	btChunk* findChunkFromUniquePointer(void* uniquePointer)
+	{
+		btChunk** chkPtr = m_uid2ChunkPtr[uniquePointer];
+		if (chkPtr)
+		{
+			return *chkPtr;
+		}
+		return 0;
+	}
+
+	virtual void registerNameForPointer(const void* ptr, const char* name)
+	{
+		btDefaultSerializer::registerNameForPointer(ptr, name);
+		m_names2Ptr.insert(name, ptr);
+	}
+
+	virtual void finishSerialization()
+	{
+	}
+
+	virtual void* getUniquePointer(void* oldPtr)
+	{
+		if (oldPtr == 0)
+			return 0;
+
+		// void* uniquePtr = getUniquePointer(oldPtr);
+		btChunk* chunk = findChunkFromUniquePointer(oldPtr);
+		if (chunk)
+		{
+			return chunk->m_oldPtr;
+		}
+		else
+		{
+			const char* n = (const char*)oldPtr;
+			const void** ptr = m_names2Ptr[n];
+			if (ptr)
+			{
+				return oldPtr;
+			}
+			else
+			{
+				void** ptr2 = m_skipPointers[oldPtr];
+				if (ptr2)
+				{
+					return 0;
+				}
+				else
+				{
+					//If this assert hit, serialization happened in the wrong order
+					// 'getUniquePointer'
+					btAssert(0);
+				}
+			}
+			return 0;
+		}
+		return oldPtr;
+	}
+
+	virtual void finalizeChunk(btChunk* chunk, const char* structType, int chunkCode, void* oldPtr)
+	{
+		if (!(m_serializationFlags & BT_SERIALIZE_NO_DUPLICATE_ASSERT))
+		{
+			btAssert(!findPointer(oldPtr));
+		}
+
+		chunk->m_dna_nr = getReverseType(structType);
+		chunk->m_chunkCode = chunkCode;
+		//void* uniquePtr = getUniquePointer(oldPtr);
+		m_chunkP.insert(oldPtr, oldPtr);  //chunk->m_oldPtr);
+		// chunk->m_oldPtr = uniquePtr;//oldPtr;
+
+		void* uid = findPointer(oldPtr);
+		m_uid2ChunkPtr.insert(uid, chunk);
+
+		switch (chunk->m_chunkCode)
+		{
+			case BT_SOFTBODY_CODE:
+			{
+#ifdef BT_USE_DOUBLE_PRECISION
+				m_arrays.m_softBodyDoubleData.push_back((btSoftBodyDoubleData*)chunk->m_oldPtr);
+#else
+				m_arrays.m_softBodyFloatData.push_back((btSoftBodyFloatData*)chunk->m_oldPtr);
+#endif
+				break;
+			}
+			case BT_COLLISIONOBJECT_CODE:
+			{
+#ifdef BT_USE_DOUBLE_PRECISION
+				m_arrays.m_collisionObjectDataDouble.push_back((btCollisionObjectDoubleData*)chunk->m_oldPtr);
+#else   //BT_USE_DOUBLE_PRECISION
+				m_arrays.m_collisionObjectDataFloat.push_back((btCollisionObjectFloatData*)chunk->m_oldPtr);
+#endif  //BT_USE_DOUBLE_PRECISION
+				break;
+			}
+			case BT_RIGIDBODY_CODE:
+			{
+#ifdef BT_USE_DOUBLE_PRECISION
+				m_arrays.m_rigidBodyDataDouble.push_back((btRigidBodyDoubleData*)chunk->m_oldPtr);
+#else
+				m_arrays.m_rigidBodyDataFloat.push_back((btRigidBodyFloatData*)chunk->m_oldPtr);
+#endif  //BT_USE_DOUBLE_PRECISION
+				break;
+			};
+			case BT_CONSTRAINT_CODE:
+			{
+#ifdef BT_USE_DOUBLE_PRECISION
+				m_arrays.m_constraintDataDouble.push_back((btTypedConstraintDoubleData*)chunk->m_oldPtr);
+#else
+				m_arrays.m_constraintDataFloat.push_back((btTypedConstraintFloatData*)chunk->m_oldPtr);
+#endif
+				break;
+			}
+			case BT_QUANTIZED_BVH_CODE:
+			{
+#ifdef BT_USE_DOUBLE_PRECISION
+				m_arrays.m_bvhsDouble.push_back((btQuantizedBvhDoubleData*)chunk->m_oldPtr);
+#else
+				m_arrays.m_bvhsFloat.push_back((btQuantizedBvhFloatData*)chunk->m_oldPtr);
+#endif
+				break;
+			}
+
+			case BT_SHAPE_CODE:
+			{
+				btCollisionShapeData* shapeData = (btCollisionShapeData*)chunk->m_oldPtr;
+				m_arrays.m_colShapeData.push_back(shapeData);
+				break;
+			}
+			case BT_TRIANLGE_INFO_MAP:
+			case BT_ARRAY_CODE:
+			case BT_SBMATERIAL_CODE:
+			case BT_SBNODE_CODE:
+			case BT_DYNAMICSWORLD_CODE:
+			case BT_DNA_CODE:
+			{
+				break;
+			}
+			default:
+			{
+			}
+		};
+	}
+
+	int getNumChunks() const
+	{
+		return m_uid2ChunkPtr.size();
+	}
+
+	const btChunk* getChunk(int chunkIndex) const
+	{
+		return *m_uid2ChunkPtr.getAtIndex(chunkIndex);
+	}
+};
+#endif  //ENABLE_INMEMORY_SERIALIZER
+
+#endif  //BT_SERIALIZER_H
diff --git a/engine/inc/bullet/LinearMath/btSpatialAlgebra.h b/engine/inc/bullet/LinearMath/btSpatialAlgebra.h
new file mode 100644
index 00000000..6ad67a10
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btSpatialAlgebra.h
@@ -0,0 +1,389 @@
+/*
+Copyright (c) 2003-2015 Erwin Coumans, Jakub Stepien
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+///These spatial algebra classes are used for btMultiBody,
+///see BulletDynamics/Featherstone
+
+#ifndef BT_SPATIAL_ALGEBRA_H
+#define BT_SPATIAL_ALGEBRA_H
+
+#include "btMatrix3x3.h"
+
+struct btSpatialForceVector
+{
+	btVector3 m_topVec, m_bottomVec;
+	//
+	btSpatialForceVector() { setZero(); }
+	btSpatialForceVector(const btVector3 &angular, const btVector3 &linear) : m_topVec(linear), m_bottomVec(angular) {}
+	btSpatialForceVector(const btScalar &ax, const btScalar &ay, const btScalar &az, const btScalar &lx, const btScalar &ly, const btScalar &lz)
+	{
+		setValue(ax, ay, az, lx, ly, lz);
+	}
+	//
+	void setVector(const btVector3 &angular, const btVector3 &linear)
+	{
+		m_topVec = linear;
+		m_bottomVec = angular;
+	}
+	void setValue(const btScalar &ax, const btScalar &ay, const btScalar &az, const btScalar &lx, const btScalar &ly, const btScalar &lz)
+	{
+		m_bottomVec.setValue(ax, ay, az);
+		m_topVec.setValue(lx, ly, lz);
+	}
+	//
+	void addVector(const btVector3 &angular, const btVector3 &linear)
+	{
+		m_topVec += linear;
+		m_bottomVec += angular;
+	}
+	void addValue(const btScalar &ax, const btScalar &ay, const btScalar &az, const btScalar &lx, const btScalar &ly, const btScalar &lz)
+	{
+		m_bottomVec[0] += ax;
+		m_bottomVec[1] += ay;
+		m_bottomVec[2] += az;
+		m_topVec[0] += lx;
+		m_topVec[1] += ly;
+		m_topVec[2] += lz;
+	}
+	//
+	const btVector3 &getLinear() const { return m_topVec; }
+	const btVector3 &getAngular() const { return m_bottomVec; }
+	//
+	void setLinear(const btVector3 &linear) { m_topVec = linear; }
+	void setAngular(const btVector3 &angular) { m_bottomVec = angular; }
+	//
+	void addAngular(const btVector3 &angular) { m_bottomVec += angular; }
+	void addLinear(const btVector3 &linear) { m_topVec += linear; }
+	//
+	void setZero()
+	{
+		m_topVec.setZero();
+		m_bottomVec.setZero();
+	}
+	//
+	btSpatialForceVector &operator+=(const btSpatialForceVector &vec)
+	{
+		m_topVec += vec.m_topVec;
+		m_bottomVec += vec.m_bottomVec;
+		return *this;
+	}
+	btSpatialForceVector &operator-=(const btSpatialForceVector &vec)
+	{
+		m_topVec -= vec.m_topVec;
+		m_bottomVec -= vec.m_bottomVec;
+		return *this;
+	}
+	btSpatialForceVector operator-(const btSpatialForceVector &vec) const { return btSpatialForceVector(m_bottomVec - vec.m_bottomVec, m_topVec - vec.m_topVec); }
+	btSpatialForceVector operator+(const btSpatialForceVector &vec) const { return btSpatialForceVector(m_bottomVec + vec.m_bottomVec, m_topVec + vec.m_topVec); }
+	btSpatialForceVector operator-() const { return btSpatialForceVector(-m_bottomVec, -m_topVec); }
+	btSpatialForceVector operator*(const btScalar &s) const { return btSpatialForceVector(s * m_bottomVec, s * m_topVec); }
+	//btSpatialForceVector & operator = (const btSpatialForceVector &vec) { m_topVec = vec.m_topVec; m_bottomVec = vec.m_bottomVec; return *this; }
+};
+
+struct btSpatialMotionVector
+{
+	btVector3 m_topVec, m_bottomVec;
+	//
+	btSpatialMotionVector() { setZero(); }
+	btSpatialMotionVector(const btVector3 &angular, const btVector3 &linear) : m_topVec(angular), m_bottomVec(linear) {}
+	//
+	void setVector(const btVector3 &angular, const btVector3 &linear)
+	{
+		m_topVec = angular;
+		m_bottomVec = linear;
+	}
+	void setValue(const btScalar &ax, const btScalar &ay, const btScalar &az, const btScalar &lx, const btScalar &ly, const btScalar &lz)
+	{
+		m_topVec.setValue(ax, ay, az);
+		m_bottomVec.setValue(lx, ly, lz);
+	}
+	//
+	void addVector(const btVector3 &angular, const btVector3 &linear)
+	{
+		m_topVec += linear;
+		m_bottomVec += angular;
+	}
+	void addValue(const btScalar &ax, const btScalar &ay, const btScalar &az, const btScalar &lx, const btScalar &ly, const btScalar &lz)
+	{
+		m_topVec[0] += ax;
+		m_topVec[1] += ay;
+		m_topVec[2] += az;
+		m_bottomVec[0] += lx;
+		m_bottomVec[1] += ly;
+		m_bottomVec[2] += lz;
+	}
+	//
+	const btVector3 &getAngular() const { return m_topVec; }
+	const btVector3 &getLinear() const { return m_bottomVec; }
+	//
+	void setAngular(const btVector3 &angular) { m_topVec = angular; }
+	void setLinear(const btVector3 &linear) { m_bottomVec = linear; }
+	//
+	void addAngular(const btVector3 &angular) { m_topVec += angular; }
+	void addLinear(const btVector3 &linear) { m_bottomVec += linear; }
+	//
+	void setZero()
+	{
+		m_topVec.setZero();
+		m_bottomVec.setZero();
+	}
+	//
+	btScalar dot(const btSpatialForceVector &b) const
+	{
+		return m_bottomVec.dot(b.m_topVec) + m_topVec.dot(b.m_bottomVec);
+	}
+	//
+	template <typename SpatialVectorType>
+	void cross(const SpatialVectorType &b, SpatialVectorType &out) const
+	{
+		out.m_topVec = m_topVec.cross(b.m_topVec);
+		out.m_bottomVec = m_bottomVec.cross(b.m_topVec) + m_topVec.cross(b.m_bottomVec);
+	}
+	template <typename SpatialVectorType>
+	SpatialVectorType cross(const SpatialVectorType &b) const
+	{
+		SpatialVectorType out;
+		out.m_topVec = m_topVec.cross(b.m_topVec);
+		out.m_bottomVec = m_bottomVec.cross(b.m_topVec) + m_topVec.cross(b.m_bottomVec);
+		return out;
+	}
+	//
+	btSpatialMotionVector &operator+=(const btSpatialMotionVector &vec)
+	{
+		m_topVec += vec.m_topVec;
+		m_bottomVec += vec.m_bottomVec;
+		return *this;
+	}
+	btSpatialMotionVector &operator-=(const btSpatialMotionVector &vec)
+	{
+		m_topVec -= vec.m_topVec;
+		m_bottomVec -= vec.m_bottomVec;
+		return *this;
+	}
+	btSpatialMotionVector &operator*=(const btScalar &s)
+	{
+		m_topVec *= s;
+		m_bottomVec *= s;
+		return *this;
+	}
+	btSpatialMotionVector operator-(const btSpatialMotionVector &vec) const { return btSpatialMotionVector(m_topVec - vec.m_topVec, m_bottomVec - vec.m_bottomVec); }
+	btSpatialMotionVector operator+(const btSpatialMotionVector &vec) const { return btSpatialMotionVector(m_topVec + vec.m_topVec, m_bottomVec + vec.m_bottomVec); }
+	btSpatialMotionVector operator-() const { return btSpatialMotionVector(-m_topVec, -m_bottomVec); }
+	btSpatialMotionVector operator*(const btScalar &s) const { return btSpatialMotionVector(s * m_topVec, s * m_bottomVec); }
+};
+
+struct btSymmetricSpatialDyad
+{
+	btMatrix3x3 m_topLeftMat, m_topRightMat, m_bottomLeftMat;
+	//
+	btSymmetricSpatialDyad() { setIdentity(); }
+	btSymmetricSpatialDyad(const btMatrix3x3 &topLeftMat, const btMatrix3x3 &topRightMat, const btMatrix3x3 &bottomLeftMat) { setMatrix(topLeftMat, topRightMat, bottomLeftMat); }
+	//
+	void setMatrix(const btMatrix3x3 &topLeftMat, const btMatrix3x3 &topRightMat, const btMatrix3x3 &bottomLeftMat)
+	{
+		m_topLeftMat = topLeftMat;
+		m_topRightMat = topRightMat;
+		m_bottomLeftMat = bottomLeftMat;
+	}
+	//
+	void addMatrix(const btMatrix3x3 &topLeftMat, const btMatrix3x3 &topRightMat, const btMatrix3x3 &bottomLeftMat)
+	{
+		m_topLeftMat += topLeftMat;
+		m_topRightMat += topRightMat;
+		m_bottomLeftMat += bottomLeftMat;
+	}
+	//
+	void setIdentity()
+	{
+		m_topLeftMat.setIdentity();
+		m_topRightMat.setIdentity();
+		m_bottomLeftMat.setIdentity();
+	}
+	//
+	btSymmetricSpatialDyad &operator-=(const btSymmetricSpatialDyad &mat)
+	{
+		m_topLeftMat -= mat.m_topLeftMat;
+		m_topRightMat -= mat.m_topRightMat;
+		m_bottomLeftMat -= mat.m_bottomLeftMat;
+		return *this;
+	}
+	//
+	btSpatialForceVector operator*(const btSpatialMotionVector &vec)
+	{
+		return btSpatialForceVector(m_bottomLeftMat * vec.m_topVec + m_topLeftMat.transpose() * vec.m_bottomVec, m_topLeftMat * vec.m_topVec + m_topRightMat * vec.m_bottomVec);
+	}
+};
+
+struct btSpatialTransformationMatrix
+{
+	btMatrix3x3 m_rotMat;  //btMatrix3x3 m_trnCrossMat;
+	btVector3 m_trnVec;
+	//
+	enum eOutputOperation
+	{
+		None = 0,
+		Add = 1,
+		Subtract = 2
+	};
+	//
+	template <typename SpatialVectorType>
+	void transform(const SpatialVectorType &inVec,
+				   SpatialVectorType &outVec,
+				   eOutputOperation outOp = None)
+	{
+		if (outOp == None)
+		{
+			outVec.m_topVec = m_rotMat * inVec.m_topVec;
+			outVec.m_bottomVec = -m_trnVec.cross(outVec.m_topVec) + m_rotMat * inVec.m_bottomVec;
+		}
+		else if (outOp == Add)
+		{
+			outVec.m_topVec += m_rotMat * inVec.m_topVec;
+			outVec.m_bottomVec += -m_trnVec.cross(outVec.m_topVec) + m_rotMat * inVec.m_bottomVec;
+		}
+		else if (outOp == Subtract)
+		{
+			outVec.m_topVec -= m_rotMat * inVec.m_topVec;
+			outVec.m_bottomVec -= -m_trnVec.cross(outVec.m_topVec) + m_rotMat * inVec.m_bottomVec;
+		}
+	}
+
+	template <typename SpatialVectorType>
+	void transformRotationOnly(const SpatialVectorType &inVec,
+							   SpatialVectorType &outVec,
+							   eOutputOperation outOp = None)
+	{
+		if (outOp == None)
+		{
+			outVec.m_topVec = m_rotMat * inVec.m_topVec;
+			outVec.m_bottomVec = m_rotMat * inVec.m_bottomVec;
+		}
+		else if (outOp == Add)
+		{
+			outVec.m_topVec += m_rotMat * inVec.m_topVec;
+			outVec.m_bottomVec += m_rotMat * inVec.m_bottomVec;
+		}
+		else if (outOp == Subtract)
+		{
+			outVec.m_topVec -= m_rotMat * inVec.m_topVec;
+			outVec.m_bottomVec -= m_rotMat * inVec.m_bottomVec;
+		}
+	}
+
+	template <typename SpatialVectorType>
+	void transformInverse(const SpatialVectorType &inVec,
+						  SpatialVectorType &outVec,
+						  eOutputOperation outOp = None)
+	{
+		if (outOp == None)
+		{
+			outVec.m_topVec = m_rotMat.transpose() * inVec.m_topVec;
+			outVec.m_bottomVec = m_rotMat.transpose() * (inVec.m_bottomVec + m_trnVec.cross(inVec.m_topVec));
+		}
+		else if (outOp == Add)
+		{
+			outVec.m_topVec += m_rotMat.transpose() * inVec.m_topVec;
+			outVec.m_bottomVec += m_rotMat.transpose() * (inVec.m_bottomVec + m_trnVec.cross(inVec.m_topVec));
+		}
+		else if (outOp == Subtract)
+		{
+			outVec.m_topVec -= m_rotMat.transpose() * inVec.m_topVec;
+			outVec.m_bottomVec -= m_rotMat.transpose() * (inVec.m_bottomVec + m_trnVec.cross(inVec.m_topVec));
+		}
+	}
+
+	template <typename SpatialVectorType>
+	void transformInverseRotationOnly(const SpatialVectorType &inVec,
+									  SpatialVectorType &outVec,
+									  eOutputOperation outOp = None)
+	{
+		if (outOp == None)
+		{
+			outVec.m_topVec = m_rotMat.transpose() * inVec.m_topVec;
+			outVec.m_bottomVec = m_rotMat.transpose() * inVec.m_bottomVec;
+		}
+		else if (outOp == Add)
+		{
+			outVec.m_topVec += m_rotMat.transpose() * inVec.m_topVec;
+			outVec.m_bottomVec += m_rotMat.transpose() * inVec.m_bottomVec;
+		}
+		else if (outOp == Subtract)
+		{
+			outVec.m_topVec -= m_rotMat.transpose() * inVec.m_topVec;
+			outVec.m_bottomVec -= m_rotMat.transpose() * inVec.m_bottomVec;
+		}
+	}
+
+	void transformInverse(const btSymmetricSpatialDyad &inMat,
+						  btSymmetricSpatialDyad &outMat,
+						  eOutputOperation outOp = None)
+	{
+		const btMatrix3x3 r_cross(0, -m_trnVec[2], m_trnVec[1],
+								  m_trnVec[2], 0, -m_trnVec[0],
+								  -m_trnVec[1], m_trnVec[0], 0);
+
+		if (outOp == None)
+		{
+			outMat.m_topLeftMat = m_rotMat.transpose() * (inMat.m_topLeftMat - inMat.m_topRightMat * r_cross) * m_rotMat;
+			outMat.m_topRightMat = m_rotMat.transpose() * inMat.m_topRightMat * m_rotMat;
+			outMat.m_bottomLeftMat = m_rotMat.transpose() * (r_cross * (inMat.m_topLeftMat - inMat.m_topRightMat * r_cross) + inMat.m_bottomLeftMat - inMat.m_topLeftMat.transpose() * r_cross) * m_rotMat;
+		}
+		else if (outOp == Add)
+		{
+			outMat.m_topLeftMat += m_rotMat.transpose() * (inMat.m_topLeftMat - inMat.m_topRightMat * r_cross) * m_rotMat;
+			outMat.m_topRightMat += m_rotMat.transpose() * inMat.m_topRightMat * m_rotMat;
+			outMat.m_bottomLeftMat += m_rotMat.transpose() * (r_cross * (inMat.m_topLeftMat - inMat.m_topRightMat * r_cross) + inMat.m_bottomLeftMat - inMat.m_topLeftMat.transpose() * r_cross) * m_rotMat;
+		}
+		else if (outOp == Subtract)
+		{
+			outMat.m_topLeftMat -= m_rotMat.transpose() * (inMat.m_topLeftMat - inMat.m_topRightMat * r_cross) * m_rotMat;
+			outMat.m_topRightMat -= m_rotMat.transpose() * inMat.m_topRightMat * m_rotMat;
+			outMat.m_bottomLeftMat -= m_rotMat.transpose() * (r_cross * (inMat.m_topLeftMat - inMat.m_topRightMat * r_cross) + inMat.m_bottomLeftMat - inMat.m_topLeftMat.transpose() * r_cross) * m_rotMat;
+		}
+	}
+
+	template <typename SpatialVectorType>
+	SpatialVectorType operator*(const SpatialVectorType &vec)
+	{
+		SpatialVectorType out;
+		transform(vec, out);
+		return out;
+	}
+};
+
+template <typename SpatialVectorType>
+void symmetricSpatialOuterProduct(const SpatialVectorType &a, const SpatialVectorType &b, btSymmetricSpatialDyad &out)
+{
+	//output op maybe?
+
+	out.m_topLeftMat = outerProduct(a.m_topVec, b.m_bottomVec);
+	out.m_topRightMat = outerProduct(a.m_topVec, b.m_topVec);
+	out.m_topLeftMat = outerProduct(a.m_bottomVec, b.m_bottomVec);
+	//maybe simple a*spatTranspose(a) would be nicer?
+}
+
+template <typename SpatialVectorType>
+btSymmetricSpatialDyad symmetricSpatialOuterProduct(const SpatialVectorType &a, const SpatialVectorType &b)
+{
+	btSymmetricSpatialDyad out;
+
+	out.m_topLeftMat = outerProduct(a.m_topVec, b.m_bottomVec);
+	out.m_topRightMat = outerProduct(a.m_topVec, b.m_topVec);
+	out.m_bottomLeftMat = outerProduct(a.m_bottomVec, b.m_bottomVec);
+
+	return out;
+	//maybe simple a*spatTranspose(a) would be nicer?
+}
+
+#endif  //BT_SPATIAL_ALGEBRA_H
diff --git a/engine/inc/bullet/LinearMath/btStackAlloc.h b/engine/inc/bullet/LinearMath/btStackAlloc.h
new file mode 100644
index 00000000..3fc20849
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btStackAlloc.h
@@ -0,0 +1,118 @@
+/*
+Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+/*
+StackAlloc extracted from GJK-EPA collision solver by Nathanael Presson
+Nov.2006
+*/
+
+#ifndef BT_STACK_ALLOC
+#define BT_STACK_ALLOC
+
+#include "btScalar.h"  //for btAssert
+#include "btAlignedAllocator.h"
+
+///The btBlock class is an internal structure for the btStackAlloc memory allocator.
+struct btBlock
+{
+	btBlock* previous;
+	unsigned char* address;
+};
+
+///The StackAlloc class provides some fast stack-based memory allocator (LIFO last-in first-out)
+class btStackAlloc
+{
+public:
+	btStackAlloc(unsigned int size)
+	{
+		ctor();
+		create(size);
+	}
+	~btStackAlloc() { destroy(); }
+
+	inline void create(unsigned int size)
+	{
+		destroy();
+		data = (unsigned char*)btAlignedAlloc(size, 16);
+		totalsize = size;
+	}
+	inline void destroy()
+	{
+		btAssert(usedsize == 0);
+		//Raise(L"StackAlloc is still in use");
+
+		if (usedsize == 0)
+		{
+			if (!ischild && data)
+				btAlignedFree(data);
+
+			data = 0;
+			usedsize = 0;
+		}
+	}
+
+	int getAvailableMemory() const
+	{
+		return static_cast<int>(totalsize - usedsize);
+	}
+
+	unsigned char* allocate(unsigned int size)
+	{
+		const unsigned int nus(usedsize + size);
+		if (nus < totalsize)
+		{
+			usedsize = nus;
+			return (data + (usedsize - size));
+		}
+		btAssert(0);
+		//&& (L"Not enough memory"));
+
+		return (0);
+	}
+	SIMD_FORCE_INLINE btBlock* beginBlock()
+	{
+		btBlock* pb = (btBlock*)allocate(sizeof(btBlock));
+		pb->previous = current;
+		pb->address = data + usedsize;
+		current = pb;
+		return (pb);
+	}
+	SIMD_FORCE_INLINE void endBlock(btBlock* block)
+	{
+		btAssert(block == current);
+		//Raise(L"Unmatched blocks");
+		if (block == current)
+		{
+			current = block->previous;
+			usedsize = (unsigned int)((block->address - data) - sizeof(btBlock));
+		}
+	}
+
+private:
+	void ctor()
+	{
+		data = 0;
+		totalsize = 0;
+		usedsize = 0;
+		current = 0;
+		ischild = false;
+	}
+	unsigned char* data;
+	unsigned int totalsize;
+	unsigned int usedsize;
+	btBlock* current;
+	bool ischild;
+};
+
+#endif  //BT_STACK_ALLOC
diff --git a/engine/inc/bullet/LinearMath/btThreads.h b/engine/inc/bullet/LinearMath/btThreads.h
new file mode 100644
index 00000000..b2227e17
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btThreads.h
@@ -0,0 +1,177 @@
+/*
+Copyright (c) 2003-2014 Erwin Coumans  http://bullet.googlecode.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_THREADS_H
+#define BT_THREADS_H
+
+#include "btScalar.h"  // has definitions like SIMD_FORCE_INLINE
+
+#if defined(_MSC_VER) && _MSC_VER >= 1600
+// give us a compile error if any signatures of overriden methods is changed
+#define BT_OVERRIDE override
+#endif
+
+#ifndef BT_OVERRIDE
+#define BT_OVERRIDE
+#endif
+
+// Don't set this to larger than 64, without modifying btThreadSupportPosix
+// and btThreadSupportWin32. They use UINT64 bit-masks.
+const unsigned int BT_MAX_THREAD_COUNT = 64;  // only if BT_THREADSAFE is 1
+
+// for internal use only
+bool btIsMainThread();
+bool btThreadsAreRunning();
+unsigned int btGetCurrentThreadIndex();
+void btResetThreadIndexCounter();  // notify that all worker threads have been destroyed
+
+///
+/// btSpinMutex -- lightweight spin-mutex implemented with atomic ops, never puts
+///               a thread to sleep because it is designed to be used with a task scheduler
+///               which has one thread per core and the threads don't sleep until they
+///               run out of tasks. Not good for general purpose use.
+///
+class btSpinMutex
+{
+	int mLock;
+
+public:
+	btSpinMutex()
+	{
+		mLock = 0;
+	}
+	void lock();
+	void unlock();
+	bool tryLock();
+};
+
+//
+// NOTE: btMutex* is for internal Bullet use only
+//
+// If BT_THREADSAFE is undefined or 0, should optimize away to nothing.
+// This is good because for the single-threaded build of Bullet, any calls
+// to these functions will be optimized out.
+//
+// However, for users of the multi-threaded build of Bullet this is kind
+// of bad because if you call any of these functions from external code
+// (where BT_THREADSAFE is undefined) you will get unexpected race conditions.
+//
+SIMD_FORCE_INLINE void btMutexLock(btSpinMutex* mutex)
+{
+#if BT_THREADSAFE
+	mutex->lock();
+#else
+	(void)mutex;
+#endif  // #if BT_THREADSAFE
+}
+
+SIMD_FORCE_INLINE void btMutexUnlock(btSpinMutex* mutex)
+{
+#if BT_THREADSAFE
+	mutex->unlock();
+#else
+	(void)mutex;
+#endif  // #if BT_THREADSAFE
+}
+
+SIMD_FORCE_INLINE bool btMutexTryLock(btSpinMutex* mutex)
+{
+#if BT_THREADSAFE
+	return mutex->tryLock();
+#else
+	(void)mutex;
+	return true;
+#endif  // #if BT_THREADSAFE
+}
+
+//
+// btIParallelForBody -- subclass this to express work that can be done in parallel
+//
+class btIParallelForBody
+{
+public:
+	virtual ~btIParallelForBody() {}
+	virtual void forLoop(int iBegin, int iEnd) const = 0;
+};
+
+//
+// btIParallelSumBody -- subclass this to express work that can be done in parallel
+//                       and produces a sum over all loop elements
+//
+class btIParallelSumBody
+{
+public:
+	virtual ~btIParallelSumBody() {}
+	virtual btScalar sumLoop(int iBegin, int iEnd) const = 0;
+};
+
+//
+// btITaskScheduler -- subclass this to implement a task scheduler that can dispatch work to
+//                     worker threads
+//
+class btITaskScheduler
+{
+public:
+	btITaskScheduler(const char* name);
+	virtual ~btITaskScheduler() {}
+	const char* getName() const { return m_name; }
+
+	virtual int getMaxNumThreads() const = 0;
+	virtual int getNumThreads() const = 0;
+	virtual void setNumThreads(int numThreads) = 0;
+	virtual void parallelFor(int iBegin, int iEnd, int grainSize, const btIParallelForBody& body) = 0;
+	virtual btScalar parallelSum(int iBegin, int iEnd, int grainSize, const btIParallelSumBody& body) = 0;
+	virtual void sleepWorkerThreadsHint() {}  // hint the task scheduler that we may not be using these threads for a little while
+
+	// internal use only
+	virtual void activate();
+	virtual void deactivate();
+
+protected:
+	const char* m_name;
+	unsigned int m_savedThreadCounter;
+	bool m_isActive;
+};
+
+// set the task scheduler to use for all calls to btParallelFor()
+// NOTE: you must set this prior to using any of the multi-threaded "Mt" classes
+void btSetTaskScheduler(btITaskScheduler* ts);
+
+// get the current task scheduler
+btITaskScheduler* btGetTaskScheduler();
+
+// get non-threaded task scheduler (always available)
+btITaskScheduler* btGetSequentialTaskScheduler();
+
+// create a default task scheduler (Win32 or pthreads based)
+btITaskScheduler* btCreateDefaultTaskScheduler();
+
+// get OpenMP task scheduler (if available, otherwise returns null)
+btITaskScheduler* btGetOpenMPTaskScheduler();
+
+// get Intel TBB task scheduler (if available, otherwise returns null)
+btITaskScheduler* btGetTBBTaskScheduler();
+
+// get PPL task scheduler (if available, otherwise returns null)
+btITaskScheduler* btGetPPLTaskScheduler();
+
+// btParallelFor -- call this to dispatch work like a for-loop
+//                 (iterations may be done out of order, so no dependencies are allowed)
+void btParallelFor(int iBegin, int iEnd, int grainSize, const btIParallelForBody& body);
+
+// btParallelSum -- call this to dispatch work like a for-loop, returns the sum of all iterations
+//                 (iterations may be done out of order, so no dependencies are allowed)
+btScalar btParallelSum(int iBegin, int iEnd, int grainSize, const btIParallelSumBody& body);
+
+#endif
diff --git a/engine/inc/bullet/LinearMath/btTransform.h b/engine/inc/bullet/LinearMath/btTransform.h
new file mode 100644
index 00000000..6f2f9981
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btTransform.h
@@ -0,0 +1,286 @@
+/*
+Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_TRANSFORM_H
+#define BT_TRANSFORM_H
+
+#include "btMatrix3x3.h"
+
+#ifdef BT_USE_DOUBLE_PRECISION
+#define btTransformData btTransformDoubleData
+#else
+#define btTransformData btTransformFloatData
+#endif
+
+/**@brief The btTransform class supports rigid transforms with only translation and rotation and no scaling/shear.
+ *It can be used in combination with btVector3, btQuaternion and btMatrix3x3 linear algebra classes. */
+ATTRIBUTE_ALIGNED16(class)
+btTransform
+{
+	///Storage for the rotation
+	btMatrix3x3 m_basis;
+	///Storage for the translation
+	btVector3 m_origin;
+
+public:
+	/**@brief No initialization constructor */
+	btTransform() {}
+	/**@brief Constructor from btQuaternion (optional btVector3 )
+   * @param q Rotation from quaternion 
+   * @param c Translation from Vector (default 0,0,0) */
+	explicit SIMD_FORCE_INLINE btTransform(const btQuaternion& q,
+										   const btVector3& c = btVector3(btScalar(0), btScalar(0), btScalar(0)))
+		: m_basis(q),
+		  m_origin(c)
+	{
+	}
+
+	/**@brief Constructor from btMatrix3x3 (optional btVector3)
+   * @param b Rotation from Matrix 
+   * @param c Translation from Vector default (0,0,0)*/
+	explicit SIMD_FORCE_INLINE btTransform(const btMatrix3x3& b,
+										   const btVector3& c = btVector3(btScalar(0), btScalar(0), btScalar(0)))
+		: m_basis(b),
+		  m_origin(c)
+	{
+	}
+	/**@brief Copy constructor */
+	SIMD_FORCE_INLINE btTransform(const btTransform& other)
+		: m_basis(other.m_basis),
+		  m_origin(other.m_origin)
+	{
+	}
+	/**@brief Assignment Operator */
+	SIMD_FORCE_INLINE btTransform& operator=(const btTransform& other)
+	{
+		m_basis = other.m_basis;
+		m_origin = other.m_origin;
+		return *this;
+	}
+
+	/**@brief Set the current transform as the value of the product of two transforms
+   * @param t1 Transform 1
+   * @param t2 Transform 2
+   * This = Transform1 * Transform2 */
+	SIMD_FORCE_INLINE void mult(const btTransform& t1, const btTransform& t2)
+	{
+		m_basis = t1.m_basis * t2.m_basis;
+		m_origin = t1(t2.m_origin);
+	}
+
+	/*		void multInverseLeft(const btTransform& t1, const btTransform& t2) {
+			btVector3 v = t2.m_origin - t1.m_origin;
+			m_basis = btMultTransposeLeft(t1.m_basis, t2.m_basis);
+			m_origin = v * t1.m_basis;
+		}
+		*/
+
+	/**@brief Return the transform of the vector */
+	SIMD_FORCE_INLINE btVector3 operator()(const btVector3& x) const
+	{
+		return x.dot3(m_basis[0], m_basis[1], m_basis[2]) + m_origin;
+	}
+
+	/**@brief Return the transform of the vector */
+	SIMD_FORCE_INLINE btVector3 operator*(const btVector3& x) const
+	{
+		return (*this)(x);
+	}
+
+	/**@brief Return the transform of the btQuaternion */
+	SIMD_FORCE_INLINE btQuaternion operator*(const btQuaternion& q) const
+	{
+		return getRotation() * q;
+	}
+
+	/**@brief Return the basis matrix for the rotation */
+	SIMD_FORCE_INLINE btMatrix3x3& getBasis() { return m_basis; }
+	/**@brief Return the basis matrix for the rotation */
+	SIMD_FORCE_INLINE const btMatrix3x3& getBasis() const { return m_basis; }
+
+	/**@brief Return the origin vector translation */
+	SIMD_FORCE_INLINE btVector3& getOrigin() { return m_origin; }
+	/**@brief Return the origin vector translation */
+	SIMD_FORCE_INLINE const btVector3& getOrigin() const { return m_origin; }
+
+	/**@brief Return a quaternion representing the rotation */
+	btQuaternion getRotation() const
+	{
+		btQuaternion q;
+		m_basis.getRotation(q);
+		return q;
+	}
+
+	/**@brief Set from an array 
+   * @param m A pointer to a 16 element array (12 rotation(row major padded on the right by 1), and 3 translation */
+	void setFromOpenGLMatrix(const btScalar* m)
+	{
+		m_basis.setFromOpenGLSubMatrix(m);
+		m_origin.setValue(m[12], m[13], m[14]);
+	}
+
+	/**@brief Fill an array representation
+   * @param m A pointer to a 16 element array (12 rotation(row major padded on the right by 1), and 3 translation */
+	void getOpenGLMatrix(btScalar * m) const
+	{
+		m_basis.getOpenGLSubMatrix(m);
+		m[12] = m_origin.x();
+		m[13] = m_origin.y();
+		m[14] = m_origin.z();
+		m[15] = btScalar(1.0);
+	}
+
+	/**@brief Set the translational element
+   * @param origin The vector to set the translation to */
+	SIMD_FORCE_INLINE void setOrigin(const btVector3& origin)
+	{
+		m_origin = origin;
+	}
+
+	SIMD_FORCE_INLINE btVector3 invXform(const btVector3& inVec) const;
+
+	/**@brief Set the rotational element by btMatrix3x3 */
+	SIMD_FORCE_INLINE void setBasis(const btMatrix3x3& basis)
+	{
+		m_basis = basis;
+	}
+
+	/**@brief Set the rotational element by btQuaternion */
+	SIMD_FORCE_INLINE void setRotation(const btQuaternion& q)
+	{
+		m_basis.setRotation(q);
+	}
+
+	/**@brief Set this transformation to the identity */
+	void setIdentity()
+	{
+		m_basis.setIdentity();
+		m_origin.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0));
+	}
+
+	/**@brief Multiply this Transform by another(this = this * another) 
+   * @param t The other transform */
+	btTransform& operator*=(const btTransform& t)
+	{
+		m_origin += m_basis * t.m_origin;
+		m_basis *= t.m_basis;
+		return *this;
+	}
+
+	/**@brief Return the inverse of this transform */
+	btTransform inverse() const
+	{
+		btMatrix3x3 inv = m_basis.transpose();
+		return btTransform(inv, inv * -m_origin);
+	}
+
+	/**@brief Return the inverse of this transform times the other transform
+   * @param t The other transform 
+   * return this.inverse() * the other */
+	btTransform inverseTimes(const btTransform& t) const;
+
+	/**@brief Return the product of this transform and the other */
+	btTransform operator*(const btTransform& t) const;
+
+	/**@brief Return an identity transform */
+	static const btTransform& getIdentity()
+	{
+		static const btTransform identityTransform(btMatrix3x3::getIdentity());
+		return identityTransform;
+	}
+
+	void serialize(struct btTransformData & dataOut) const;
+
+	void serializeFloat(struct btTransformFloatData & dataOut) const;
+
+	void deSerialize(const struct btTransformData& dataIn);
+
+	void deSerializeDouble(const struct btTransformDoubleData& dataIn);
+
+	void deSerializeFloat(const struct btTransformFloatData& dataIn);
+};
+
+SIMD_FORCE_INLINE btVector3
+btTransform::invXform(const btVector3& inVec) const
+{
+	btVector3 v = inVec - m_origin;
+	return (m_basis.transpose() * v);
+}
+
+SIMD_FORCE_INLINE btTransform
+btTransform::inverseTimes(const btTransform& t) const
+{
+	btVector3 v = t.getOrigin() - m_origin;
+	return btTransform(m_basis.transposeTimes(t.m_basis),
+					   v * m_basis);
+}
+
+SIMD_FORCE_INLINE btTransform
+	btTransform::operator*(const btTransform& t) const
+{
+	return btTransform(m_basis * t.m_basis,
+					   (*this)(t.m_origin));
+}
+
+/**@brief Test if two transforms have all elements equal */
+SIMD_FORCE_INLINE bool operator==(const btTransform& t1, const btTransform& t2)
+{
+	return (t1.getBasis() == t2.getBasis() &&
+			t1.getOrigin() == t2.getOrigin());
+}
+
+///for serialization
+struct btTransformFloatData
+{
+	btMatrix3x3FloatData m_basis;
+	btVector3FloatData m_origin;
+};
+
+struct btTransformDoubleData
+{
+	btMatrix3x3DoubleData m_basis;
+	btVector3DoubleData m_origin;
+};
+
+SIMD_FORCE_INLINE void btTransform::serialize(btTransformData& dataOut) const
+{
+	m_basis.serialize(dataOut.m_basis);
+	m_origin.serialize(dataOut.m_origin);
+}
+
+SIMD_FORCE_INLINE void btTransform::serializeFloat(btTransformFloatData& dataOut) const
+{
+	m_basis.serializeFloat(dataOut.m_basis);
+	m_origin.serializeFloat(dataOut.m_origin);
+}
+
+SIMD_FORCE_INLINE void btTransform::deSerialize(const btTransformData& dataIn)
+{
+	m_basis.deSerialize(dataIn.m_basis);
+	m_origin.deSerialize(dataIn.m_origin);
+}
+
+SIMD_FORCE_INLINE void btTransform::deSerializeFloat(const btTransformFloatData& dataIn)
+{
+	m_basis.deSerializeFloat(dataIn.m_basis);
+	m_origin.deSerializeFloat(dataIn.m_origin);
+}
+
+SIMD_FORCE_INLINE void btTransform::deSerializeDouble(const btTransformDoubleData& dataIn)
+{
+	m_basis.deSerializeDouble(dataIn.m_basis);
+	m_origin.deSerializeDouble(dataIn.m_origin);
+}
+
+#endif  //BT_TRANSFORM_H
diff --git a/engine/inc/bullet/LinearMath/btTransformUtil.h b/engine/inc/bullet/LinearMath/btTransformUtil.h
new file mode 100644
index 00000000..b874dd68
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btTransformUtil.h
@@ -0,0 +1,223 @@
+/*
+Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_TRANSFORM_UTIL_H
+#define BT_TRANSFORM_UTIL_H
+
+#include "btTransform.h"
+#define ANGULAR_MOTION_THRESHOLD btScalar(0.5) * SIMD_HALF_PI
+
+SIMD_FORCE_INLINE btVector3 btAabbSupport(const btVector3& halfExtents, const btVector3& supportDir)
+{
+	return btVector3(supportDir.x() < btScalar(0.0) ? -halfExtents.x() : halfExtents.x(),
+					 supportDir.y() < btScalar(0.0) ? -halfExtents.y() : halfExtents.y(),
+					 supportDir.z() < btScalar(0.0) ? -halfExtents.z() : halfExtents.z());
+}
+
+/// Utils related to temporal transforms
+class btTransformUtil
+{
+public:
+	static void integrateTransform(const btTransform& curTrans, const btVector3& linvel, const btVector3& angvel, btScalar timeStep, btTransform& predictedTransform)
+	{
+		predictedTransform.setOrigin(curTrans.getOrigin() + linvel * timeStep);
+		//	#define QUATERNION_DERIVATIVE
+#ifdef QUATERNION_DERIVATIVE
+		btQuaternion predictedOrn = curTrans.getRotation();
+		predictedOrn += (angvel * predictedOrn) * (timeStep * btScalar(0.5));
+		predictedOrn.safeNormalize();
+#else
+		//Exponential map
+		//google for "Practical Parameterization of Rotations Using the Exponential Map", F. Sebastian Grassia
+
+		btVector3 axis;
+		btScalar fAngle2 = angvel.length2();
+		btScalar fAngle = 0;
+		if (fAngle2 > SIMD_EPSILON)
+		{
+			fAngle = btSqrt(fAngle2);
+		}
+
+		//limit the angular motion
+		if (fAngle * timeStep > ANGULAR_MOTION_THRESHOLD)
+		{
+			fAngle = ANGULAR_MOTION_THRESHOLD / timeStep;
+		}
+
+		if (fAngle < btScalar(0.001))
+		{
+			// use Taylor's expansions of sync function
+			axis = angvel * (btScalar(0.5) * timeStep - (timeStep * timeStep * timeStep) * (btScalar(0.020833333333)) * fAngle * fAngle);
+		}
+		else
+		{
+			// sync(fAngle) = sin(c*fAngle)/t
+			axis = angvel * (btSin(btScalar(0.5) * fAngle * timeStep) / fAngle);
+		}
+		btQuaternion dorn(axis.x(), axis.y(), axis.z(), btCos(fAngle * timeStep * btScalar(0.5)));
+		btQuaternion orn0 = curTrans.getRotation();
+
+		btQuaternion predictedOrn = dorn * orn0;
+		predictedOrn.safeNormalize();
+#endif
+		if (predictedOrn.length2() > SIMD_EPSILON)
+		{
+			predictedTransform.setRotation(predictedOrn);
+		}
+		else
+		{
+			predictedTransform.setBasis(curTrans.getBasis());
+		}
+	}
+
+	static void calculateVelocityQuaternion(const btVector3& pos0, const btVector3& pos1, const btQuaternion& orn0, const btQuaternion& orn1, btScalar timeStep, btVector3& linVel, btVector3& angVel)
+	{
+		linVel = (pos1 - pos0) / timeStep;
+		btVector3 axis;
+		btScalar angle;
+		if (orn0 != orn1)
+		{
+			calculateDiffAxisAngleQuaternion(orn0, orn1, axis, angle);
+			angVel = axis * angle / timeStep;
+		}
+		else
+		{
+			angVel.setValue(0, 0, 0);
+		}
+	}
+
+	static void calculateDiffAxisAngleQuaternion(const btQuaternion& orn0, const btQuaternion& orn1a, btVector3& axis, btScalar& angle)
+	{
+		btQuaternion orn1 = orn0.nearest(orn1a);
+		btQuaternion dorn = orn1 * orn0.inverse();
+		angle = dorn.getAngle();
+		axis = btVector3(dorn.x(), dorn.y(), dorn.z());
+		axis[3] = btScalar(0.);
+		//check for axis length
+		btScalar len = axis.length2();
+		if (len < SIMD_EPSILON * SIMD_EPSILON)
+			axis = btVector3(btScalar(1.), btScalar(0.), btScalar(0.));
+		else
+			axis /= btSqrt(len);
+	}
+
+	static void calculateVelocity(const btTransform& transform0, const btTransform& transform1, btScalar timeStep, btVector3& linVel, btVector3& angVel)
+	{
+		linVel = (transform1.getOrigin() - transform0.getOrigin()) / timeStep;
+		btVector3 axis;
+		btScalar angle;
+		calculateDiffAxisAngle(transform0, transform1, axis, angle);
+		angVel = axis * angle / timeStep;
+	}
+
+	static void calculateDiffAxisAngle(const btTransform& transform0, const btTransform& transform1, btVector3& axis, btScalar& angle)
+	{
+		btMatrix3x3 dmat = transform1.getBasis() * transform0.getBasis().inverse();
+		btQuaternion dorn;
+		dmat.getRotation(dorn);
+
+		///floating point inaccuracy can lead to w component > 1..., which breaks
+		dorn.normalize();
+
+		angle = dorn.getAngle();
+		axis = btVector3(dorn.x(), dorn.y(), dorn.z());
+		axis[3] = btScalar(0.);
+		//check for axis length
+		btScalar len = axis.length2();
+		if (len < SIMD_EPSILON * SIMD_EPSILON)
+			axis = btVector3(btScalar(1.), btScalar(0.), btScalar(0.));
+		else
+			axis /= btSqrt(len);
+	}
+};
+
+///The btConvexSeparatingDistanceUtil can help speed up convex collision detection
+///by conservatively updating a cached separating distance/vector instead of re-calculating the closest distance
+class btConvexSeparatingDistanceUtil
+{
+	btQuaternion m_ornA;
+	btQuaternion m_ornB;
+	btVector3 m_posA;
+	btVector3 m_posB;
+
+	btVector3 m_separatingNormal;
+
+	btScalar m_boundingRadiusA;
+	btScalar m_boundingRadiusB;
+	btScalar m_separatingDistance;
+
+public:
+	btConvexSeparatingDistanceUtil(btScalar boundingRadiusA, btScalar boundingRadiusB)
+		: m_boundingRadiusA(boundingRadiusA),
+		  m_boundingRadiusB(boundingRadiusB),
+		  m_separatingDistance(0.f)
+	{
+	}
+
+	btScalar getConservativeSeparatingDistance()
+	{
+		return m_separatingDistance;
+	}
+
+	void updateSeparatingDistance(const btTransform& transA, const btTransform& transB)
+	{
+		const btVector3& toPosA = transA.getOrigin();
+		const btVector3& toPosB = transB.getOrigin();
+		btQuaternion toOrnA = transA.getRotation();
+		btQuaternion toOrnB = transB.getRotation();
+
+		if (m_separatingDistance > 0.f)
+		{
+			btVector3 linVelA, angVelA, linVelB, angVelB;
+			btTransformUtil::calculateVelocityQuaternion(m_posA, toPosA, m_ornA, toOrnA, btScalar(1.), linVelA, angVelA);
+			btTransformUtil::calculateVelocityQuaternion(m_posB, toPosB, m_ornB, toOrnB, btScalar(1.), linVelB, angVelB);
+			btScalar maxAngularProjectedVelocity = angVelA.length() * m_boundingRadiusA + angVelB.length() * m_boundingRadiusB;
+			btVector3 relLinVel = (linVelB - linVelA);
+			btScalar relLinVelocLength = relLinVel.dot(m_separatingNormal);
+			if (relLinVelocLength < 0.f)
+			{
+				relLinVelocLength = 0.f;
+			}
+
+			btScalar projectedMotion = maxAngularProjectedVelocity + relLinVelocLength;
+			m_separatingDistance -= projectedMotion;
+		}
+
+		m_posA = toPosA;
+		m_posB = toPosB;
+		m_ornA = toOrnA;
+		m_ornB = toOrnB;
+	}
+
+	void initSeparatingDistance(const btVector3& separatingVector, btScalar separatingDistance, const btTransform& transA, const btTransform& transB)
+	{
+		m_separatingDistance = separatingDistance;
+
+		if (m_separatingDistance > 0.f)
+		{
+			m_separatingNormal = separatingVector;
+
+			const btVector3& toPosA = transA.getOrigin();
+			const btVector3& toPosB = transB.getOrigin();
+			btQuaternion toOrnA = transA.getRotation();
+			btQuaternion toOrnB = transB.getRotation();
+			m_posA = toPosA;
+			m_posB = toPosB;
+			m_ornA = toOrnA;
+			m_ornB = toOrnB;
+		}
+	}
+};
+
+#endif  //BT_TRANSFORM_UTIL_H
diff --git a/engine/inc/bullet/LinearMath/btVector3.h b/engine/inc/bullet/LinearMath/btVector3.h
new file mode 100644
index 00000000..d65ed980
--- /dev/null
+++ b/engine/inc/bullet/LinearMath/btVector3.h
@@ -0,0 +1,1336 @@
+/*
+Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_VECTOR3_H
+#define BT_VECTOR3_H
+
+//#include <stdint.h>
+#include "btScalar.h"
+#include "btMinMax.h"
+#include "btAlignedAllocator.h"
+
+#ifdef BT_USE_DOUBLE_PRECISION
+#define btVector3Data btVector3DoubleData
+#define btVector3DataName "btVector3DoubleData"
+#else
+#define btVector3Data btVector3FloatData
+#define btVector3DataName "btVector3FloatData"
+#endif  //BT_USE_DOUBLE_PRECISION
+
+#if defined BT_USE_SSE
+
+//typedef  uint32_t __m128i __attribute__ ((vector_size(16)));
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4556)  // value of intrinsic immediate argument '4294967239' is out of range '0 - 255'
+#endif
+
+#define BT_SHUFFLE(x, y, z, w) (((w) << 6 | (z) << 4 | (y) << 2 | (x)) & 0xff)
+//#define bt_pshufd_ps( _a, _mask ) (__m128) _mm_shuffle_epi32((__m128i)(_a), (_mask) )
+#define bt_pshufd_ps(_a, _mask) _mm_shuffle_ps((_a), (_a), (_mask))
+#define bt_splat3_ps(_a, _i) bt_pshufd_ps((_a), BT_SHUFFLE(_i, _i, _i, 3))
+#define bt_splat_ps(_a, _i) bt_pshufd_ps((_a), BT_SHUFFLE(_i, _i, _i, _i))
+
+#define btv3AbsiMask (_mm_set_epi32(0x00000000, 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF))
+#define btvAbsMask (_mm_set_epi32(0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF))
+#define btvFFF0Mask (_mm_set_epi32(0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF))
+#define btv3AbsfMask btCastiTo128f(btv3AbsiMask)
+#define btvFFF0fMask btCastiTo128f(btvFFF0Mask)
+#define btvxyzMaskf btvFFF0fMask
+#define btvAbsfMask btCastiTo128f(btvAbsMask)
+
+//there is an issue with XCode 3.2 (LCx errors)
+#define btvMzeroMask (_mm_set_ps(-0.0f, -0.0f, -0.0f, -0.0f))
+#define v1110 (_mm_set_ps(0.0f, 1.0f, 1.0f, 1.0f))
+#define vHalf (_mm_set_ps(0.5f, 0.5f, 0.5f, 0.5f))
+#define v1_5 (_mm_set_ps(1.5f, 1.5f, 1.5f, 1.5f))
+
+//const __m128 ATTRIBUTE_ALIGNED16(btvMzeroMask) = {-0.0f, -0.0f, -0.0f, -0.0f};
+//const __m128 ATTRIBUTE_ALIGNED16(v1110) = {1.0f, 1.0f, 1.0f, 0.0f};
+//const __m128 ATTRIBUTE_ALIGNED16(vHalf) = {0.5f, 0.5f, 0.5f, 0.5f};
+//const __m128 ATTRIBUTE_ALIGNED16(v1_5)  = {1.5f, 1.5f, 1.5f, 1.5f};
+
+#endif
+
+#ifdef BT_USE_NEON
+
+const float32x4_t ATTRIBUTE_ALIGNED16(btvMzeroMask) = (float32x4_t){-0.0f, -0.0f, -0.0f, -0.0f};
+const int32x4_t ATTRIBUTE_ALIGNED16(btvFFF0Mask) = (int32x4_t){static_cast<int32_t>(0xFFFFFFFF),
+															   static_cast<int32_t>(0xFFFFFFFF), static_cast<int32_t>(0xFFFFFFFF), 0x0};
+const int32x4_t ATTRIBUTE_ALIGNED16(btvAbsMask) = (int32x4_t){0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF};
+const int32x4_t ATTRIBUTE_ALIGNED16(btv3AbsMask) = (int32x4_t){0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF, 0x0};
+
+#endif
+
+/**@brief btVector3 can be used to represent 3D points and vectors.
+ * It has an un-used w component to suit 16-byte alignment when btVector3 is stored in containers. This extra component can be used by derived classes (Quaternion?) or by user
+ * Ideally, this class should be replaced by a platform optimized SIMD version that keeps the data in registers
+ */
+ATTRIBUTE_ALIGNED16(class)
+btVector3
+{
+public:
+	BT_DECLARE_ALIGNED_ALLOCATOR();
+
+#if defined(__SPU__) && defined(__CELLOS_LV2__)
+	btScalar m_floats[4];
+
+public:
+	SIMD_FORCE_INLINE const vec_float4& get128() const
+	{
+		return *((const vec_float4*)&m_floats[0]);
+	}
+
+public:
+#else                                            //__CELLOS_LV2__ __SPU__
+#if defined(BT_USE_SSE) || defined(BT_USE_NEON)  // _WIN32 || ARM
+	union {
+		btSimdFloat4 mVec128;
+		btScalar m_floats[4];
+	};
+	SIMD_FORCE_INLINE btSimdFloat4 get128() const
+	{
+		return mVec128;
+	}
+	SIMD_FORCE_INLINE void set128(btSimdFloat4 v128)
+	{
+		mVec128 = v128;
+	}
+#else
+	btScalar m_floats[4];
+#endif
+#endif  //__CELLOS_LV2__ __SPU__
+
+public:
+	/**@brief No initialization constructor */
+	SIMD_FORCE_INLINE btVector3()
+	{
+	}
+
+	/**@brief Constructor from scalars 
+   * @param x X value
+   * @param y Y value 
+   * @param z Z value 
+   */
+	SIMD_FORCE_INLINE btVector3(const btScalar& _x, const btScalar& _y, const btScalar& _z)
+	{
+		m_floats[0] = _x;
+		m_floats[1] = _y;
+		m_floats[2] = _z;
+		m_floats[3] = btScalar(0.f);
+	}
+
+#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON)
+	// Set Vector
+	SIMD_FORCE_INLINE btVector3(btSimdFloat4 v)
+	{
+		mVec128 = v;
+	}
+
+	// Copy constructor
+	SIMD_FORCE_INLINE btVector3(const btVector3& rhs)
+	{
+		mVec128 = rhs.mVec128;
+	}
+
+	// Assignment Operator
+	SIMD_FORCE_INLINE btVector3&
+	operator=(const btVector3& v)
+	{
+		mVec128 = v.mVec128;
+
+		return *this;
+	}
+#endif  // #if defined (BT_USE_SSE_IN_API) || defined (BT_USE_NEON)
+
+	/**@brief Add a vector to this one 
+ * @param The vector to add to this one */
+	SIMD_FORCE_INLINE btVector3& operator+=(const btVector3& v)
+	{
+#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+		mVec128 = _mm_add_ps(mVec128, v.mVec128);
+#elif defined(BT_USE_NEON)
+		mVec128 = vaddq_f32(mVec128, v.mVec128);
+#else
+		m_floats[0] += v.m_floats[0];
+		m_floats[1] += v.m_floats[1];
+		m_floats[2] += v.m_floats[2];
+#endif
+		return *this;
+	}
+
+	/**@brief Subtract a vector from this one
+   * @param The vector to subtract */
+	SIMD_FORCE_INLINE btVector3& operator-=(const btVector3& v)
+	{
+#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+		mVec128 = _mm_sub_ps(mVec128, v.mVec128);
+#elif defined(BT_USE_NEON)
+		mVec128 = vsubq_f32(mVec128, v.mVec128);
+#else
+		m_floats[0] -= v.m_floats[0];
+		m_floats[1] -= v.m_floats[1];
+		m_floats[2] -= v.m_floats[2];
+#endif
+		return *this;
+	}
+
+	/**@brief Scale the vector
+   * @param s Scale factor */
+	SIMD_FORCE_INLINE btVector3& operator*=(const btScalar& s)
+	{
+#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+		__m128 vs = _mm_load_ss(&s);  //	(S 0 0 0)
+		vs = bt_pshufd_ps(vs, 0x80);  //	(S S S 0.0)
+		mVec128 = _mm_mul_ps(mVec128, vs);
+#elif defined(BT_USE_NEON)
+		mVec128 = vmulq_n_f32(mVec128, s);
+#else
+		m_floats[0] *= s;
+		m_floats[1] *= s;
+		m_floats[2] *= s;
+#endif
+		return *this;
+	}
+
+	/**@brief Inversely scale the vector 
+   * @param s Scale factor to divide by */
+	SIMD_FORCE_INLINE btVector3& operator/=(const btScalar& s)
+	{
+		btFullAssert(s != btScalar(0.0));
+
+#if 0  //defined(BT_USE_SSE_IN_API)
+// this code is not faster !
+		__m128 vs = _mm_load_ss(&s);
+		vs = _mm_div_ss(v1110, vs);
+		vs = bt_pshufd_ps(vs, 0x00);	//	(S S S S)
+
+		mVec128 = _mm_mul_ps(mVec128, vs);
+		
+		return *this;
+#else
+		return *this *= btScalar(1.0) / s;
+#endif
+	}
+
+	/**@brief Return the dot product
+   * @param v The other vector in the dot product */
+	SIMD_FORCE_INLINE btScalar dot(const btVector3& v) const
+	{
+#if defined BT_USE_SIMD_VECTOR3 && defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+		__m128 vd = _mm_mul_ps(mVec128, v.mVec128);
+		__m128 z = _mm_movehl_ps(vd, vd);
+		__m128 y = _mm_shuffle_ps(vd, vd, 0x55);
+		vd = _mm_add_ss(vd, y);
+		vd = _mm_add_ss(vd, z);
+		return _mm_cvtss_f32(vd);
+#elif defined(BT_USE_NEON)
+		float32x4_t vd = vmulq_f32(mVec128, v.mVec128);
+		float32x2_t x = vpadd_f32(vget_low_f32(vd), vget_low_f32(vd));
+		x = vadd_f32(x, vget_high_f32(vd));
+		return vget_lane_f32(x, 0);
+#else
+		return m_floats[0] * v.m_floats[0] +
+			   m_floats[1] * v.m_floats[1] +
+			   m_floats[2] * v.m_floats[2];
+#endif
+	}
+
+	/**@brief Return the length of the vector squared */
+	SIMD_FORCE_INLINE btScalar length2() const
+	{
+		return dot(*this);
+	}
+
+	/**@brief Return the length of the vector */
+	SIMD_FORCE_INLINE btScalar length() const
+	{
+		return btSqrt(length2());
+	}
+
+	/**@brief Return the norm (length) of the vector */
+	SIMD_FORCE_INLINE btScalar norm() const
+	{
+		return length();
+	}
+
+	/**@brief Return the norm (length) of the vector */
+	SIMD_FORCE_INLINE btScalar safeNorm() const
+	{
+		btScalar d = length2();
+		//workaround for some clang/gcc issue of sqrtf(tiny number) = -INF
+		if (d > SIMD_EPSILON)
+			return btSqrt(d);
+		return btScalar(0);
+	}
+
+	/**@brief Return the distance squared between the ends of this and another vector
+   * This is symantically treating the vector like a point */
+	SIMD_FORCE_INLINE btScalar distance2(const btVector3& v) const;
+
+	/**@brief Return the distance between the ends of this and another vector
+   * This is symantically treating the vector like a point */
+	SIMD_FORCE_INLINE btScalar distance(const btVector3& v) const;
+
+	SIMD_FORCE_INLINE btVector3& safeNormalize()
+	{
+		btScalar l2 = length2();
+		//triNormal.normalize();
+		if (l2 >= SIMD_EPSILON * SIMD_EPSILON)
+		{
+			(*this) /= btSqrt(l2);
+		}
+		else
+		{
+			setValue(1, 0, 0);
+		}
+		return *this;
+	}
+
+	/**@brief Normalize this vector 
+   * x^2 + y^2 + z^2 = 1 */
+	SIMD_FORCE_INLINE btVector3& normalize()
+	{
+		btAssert(!fuzzyZero());
+
+#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+		// dot product first
+		__m128 vd = _mm_mul_ps(mVec128, mVec128);
+		__m128 z = _mm_movehl_ps(vd, vd);
+		__m128 y = _mm_shuffle_ps(vd, vd, 0x55);
+		vd = _mm_add_ss(vd, y);
+		vd = _mm_add_ss(vd, z);
+
+#if 0
+        vd = _mm_sqrt_ss(vd);
+		vd = _mm_div_ss(v1110, vd);
+		vd = bt_splat_ps(vd, 0x80);
+		mVec128 = _mm_mul_ps(mVec128, vd);
+#else
+
+		// NR step 1/sqrt(x) - vd is x, y is output
+		y = _mm_rsqrt_ss(vd);  // estimate
+
+		//  one step NR
+		z = v1_5;
+		vd = _mm_mul_ss(vd, vHalf);  // vd * 0.5
+		//x2 = vd;
+		vd = _mm_mul_ss(vd, y);  // vd * 0.5 * y0
+		vd = _mm_mul_ss(vd, y);  // vd * 0.5 * y0 * y0
+		z = _mm_sub_ss(z, vd);   // 1.5 - vd * 0.5 * y0 * y0
+
+		y = _mm_mul_ss(y, z);  // y0 * (1.5 - vd * 0.5 * y0 * y0)
+
+		y = bt_splat_ps(y, 0x80);
+		mVec128 = _mm_mul_ps(mVec128, y);
+
+#endif
+
+		return *this;
+#else
+		return *this /= length();
+#endif
+	}
+
+	/**@brief Return a normalized version of this vector */
+	SIMD_FORCE_INLINE btVector3 normalized() const;
+
+	/**@brief Return a rotated version of this vector
+   * @param wAxis The axis to rotate about 
+   * @param angle The angle to rotate by */
+	SIMD_FORCE_INLINE btVector3 rotate(const btVector3& wAxis, const btScalar angle) const;
+
+	/**@brief Return the angle between this and another vector
+   * @param v The other vector */
+	SIMD_FORCE_INLINE btScalar angle(const btVector3& v) const
+	{
+		btScalar s = btSqrt(length2() * v.length2());
+		btFullAssert(s != btScalar(0.0));
+		return btAcos(dot(v) / s);
+	}
+
+	/**@brief Return a vector with the absolute values of each element */
+	SIMD_FORCE_INLINE btVector3 absolute() const
+	{
+#if defined BT_USE_SIMD_VECTOR3 && defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+		return btVector3(_mm_and_ps(mVec128, btv3AbsfMask));
+#elif defined(BT_USE_NEON)
+		return btVector3(vabsq_f32(mVec128));
+#else
+		return btVector3(
+			btFabs(m_floats[0]),
+			btFabs(m_floats[1]),
+			btFabs(m_floats[2]));
+#endif
+	}
+
+	/**@brief Return the cross product between this and another vector 
+   * @param v The other vector */
+	SIMD_FORCE_INLINE btVector3 cross(const btVector3& v) const
+	{
+#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+		__m128 T, V;
+
+		T = bt_pshufd_ps(mVec128, BT_SHUFFLE(1, 2, 0, 3));    //	(Y Z X 0)
+		V = bt_pshufd_ps(v.mVec128, BT_SHUFFLE(1, 2, 0, 3));  //	(Y Z X 0)
+
+		V = _mm_mul_ps(V, mVec128);
+		T = _mm_mul_ps(T, v.mVec128);
+		V = _mm_sub_ps(V, T);
+
+		V = bt_pshufd_ps(V, BT_SHUFFLE(1, 2, 0, 3));
+		return btVector3(V);
+#elif defined(BT_USE_NEON)
+		float32x4_t T, V;
+		// form (Y, Z, X, _) of mVec128 and v.mVec128
+		float32x2_t Tlow = vget_low_f32(mVec128);
+		float32x2_t Vlow = vget_low_f32(v.mVec128);
+		T = vcombine_f32(vext_f32(Tlow, vget_high_f32(mVec128), 1), Tlow);
+		V = vcombine_f32(vext_f32(Vlow, vget_high_f32(v.mVec128), 1), Vlow);
+
+		V = vmulq_f32(V, mVec128);
+		T = vmulq_f32(T, v.mVec128);
+		V = vsubq_f32(V, T);
+		Vlow = vget_low_f32(V);
+		// form (Y, Z, X, _);
+		V = vcombine_f32(vext_f32(Vlow, vget_high_f32(V), 1), Vlow);
+		V = (float32x4_t)vandq_s32((int32x4_t)V, btvFFF0Mask);
+
+		return btVector3(V);
+#else
+		return btVector3(
+			m_floats[1] * v.m_floats[2] - m_floats[2] * v.m_floats[1],
+			m_floats[2] * v.m_floats[0] - m_floats[0] * v.m_floats[2],
+			m_floats[0] * v.m_floats[1] - m_floats[1] * v.m_floats[0]);
+#endif
+	}
+
+	SIMD_FORCE_INLINE btScalar triple(const btVector3& v1, const btVector3& v2) const
+	{
+#if defined BT_USE_SIMD_VECTOR3 && defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+		// cross:
+		__m128 T = _mm_shuffle_ps(v1.mVec128, v1.mVec128, BT_SHUFFLE(1, 2, 0, 3));  //	(Y Z X 0)
+		__m128 V = _mm_shuffle_ps(v2.mVec128, v2.mVec128, BT_SHUFFLE(1, 2, 0, 3));  //	(Y Z X 0)
+
+		V = _mm_mul_ps(V, v1.mVec128);
+		T = _mm_mul_ps(T, v2.mVec128);
+		V = _mm_sub_ps(V, T);
+
+		V = _mm_shuffle_ps(V, V, BT_SHUFFLE(1, 2, 0, 3));
+
+		// dot:
+		V = _mm_mul_ps(V, mVec128);
+		__m128 z = _mm_movehl_ps(V, V);
+		__m128 y = _mm_shuffle_ps(V, V, 0x55);
+		V = _mm_add_ss(V, y);
+		V = _mm_add_ss(V, z);
+		return _mm_cvtss_f32(V);
+
+#elif defined(BT_USE_NEON)
+		// cross:
+		float32x4_t T, V;
+		// form (Y, Z, X, _) of mVec128 and v.mVec128
+		float32x2_t Tlow = vget_low_f32(v1.mVec128);
+		float32x2_t Vlow = vget_low_f32(v2.mVec128);
+		T = vcombine_f32(vext_f32(Tlow, vget_high_f32(v1.mVec128), 1), Tlow);
+		V = vcombine_f32(vext_f32(Vlow, vget_high_f32(v2.mVec128), 1), Vlow);
+
+		V = vmulq_f32(V, v1.mVec128);
+		T = vmulq_f32(T, v2.mVec128);
+		V = vsubq_f32(V, T);
+		Vlow = vget_low_f32(V);
+		// form (Y, Z, X, _);
+		V = vcombine_f32(vext_f32(Vlow, vget_high_f32(V), 1), Vlow);
+
+		// dot:
+		V = vmulq_f32(mVec128, V);
+		float32x2_t x = vpadd_f32(vget_low_f32(V), vget_low_f32(V));
+		x = vadd_f32(x, vget_high_f32(V));
+		return vget_lane_f32(x, 0);
+#else
+		return m_floats[0] * (v1.m_floats[1] * v2.m_floats[2] - v1.m_floats[2] * v2.m_floats[1]) +
+			   m_floats[1] * (v1.m_floats[2] * v2.m_floats[0] - v1.m_floats[0] * v2.m_floats[2]) +
+			   m_floats[2] * (v1.m_floats[0] * v2.m_floats[1] - v1.m_floats[1] * v2.m_floats[0]);
+#endif
+	}
+
+	/**@brief Return the axis with the smallest value 
+   * Note return values are 0,1,2 for x, y, or z */
+	SIMD_FORCE_INLINE int minAxis() const
+	{
+		return m_floats[0] < m_floats[1] ? (m_floats[0] < m_floats[2] ? 0 : 2) : (m_floats[1] < m_floats[2] ? 1 : 2);
+	}
+
+	/**@brief Return the axis with the largest value 
+   * Note return values are 0,1,2 for x, y, or z */
+	SIMD_FORCE_INLINE int maxAxis() const
+	{
+		return m_floats[0] < m_floats[1] ? (m_floats[1] < m_floats[2] ? 2 : 1) : (m_floats[0] < m_floats[2] ? 2 : 0);
+	}
+
+	SIMD_FORCE_INLINE int furthestAxis() const
+	{
+		return absolute().minAxis();
+	}
+
+	SIMD_FORCE_INLINE int closestAxis() const
+	{
+		return absolute().maxAxis();
+	}
+
+	SIMD_FORCE_INLINE void setInterpolate3(const btVector3& v0, const btVector3& v1, btScalar rt)
+	{
+#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+		__m128 vrt = _mm_load_ss(&rt);  //	(rt 0 0 0)
+		btScalar s = btScalar(1.0) - rt;
+		__m128 vs = _mm_load_ss(&s);  //	(S 0 0 0)
+		vs = bt_pshufd_ps(vs, 0x80);  //	(S S S 0.0)
+		__m128 r0 = _mm_mul_ps(v0.mVec128, vs);
+		vrt = bt_pshufd_ps(vrt, 0x80);  //	(rt rt rt 0.0)
+		__m128 r1 = _mm_mul_ps(v1.mVec128, vrt);
+		__m128 tmp3 = _mm_add_ps(r0, r1);
+		mVec128 = tmp3;
+#elif defined(BT_USE_NEON)
+		float32x4_t vl = vsubq_f32(v1.mVec128, v0.mVec128);
+		vl = vmulq_n_f32(vl, rt);
+		mVec128 = vaddq_f32(vl, v0.mVec128);
+#else
+		btScalar s = btScalar(1.0) - rt;
+		m_floats[0] = s * v0.m_floats[0] + rt * v1.m_floats[0];
+		m_floats[1] = s * v0.m_floats[1] + rt * v1.m_floats[1];
+		m_floats[2] = s * v0.m_floats[2] + rt * v1.m_floats[2];
+		//don't do the unused w component
+		//		m_co[3] = s * v0[3] + rt * v1[3];
+#endif
+	}
+
+	/**@brief Return the linear interpolation between this and another vector 
+   * @param v The other vector 
+   * @param t The ration of this to v (t = 0 => return this, t=1 => return other) */
+	SIMD_FORCE_INLINE btVector3 lerp(const btVector3& v, const btScalar& t) const
+	{
+#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+		__m128 vt = _mm_load_ss(&t);  //	(t 0 0 0)
+		vt = bt_pshufd_ps(vt, 0x80);  //	(rt rt rt 0.0)
+		__m128 vl = _mm_sub_ps(v.mVec128, mVec128);
+		vl = _mm_mul_ps(vl, vt);
+		vl = _mm_add_ps(vl, mVec128);
+
+		return btVector3(vl);
+#elif defined(BT_USE_NEON)
+		float32x4_t vl = vsubq_f32(v.mVec128, mVec128);
+		vl = vmulq_n_f32(vl, t);
+		vl = vaddq_f32(vl, mVec128);
+
+		return btVector3(vl);
+#else
+		return btVector3(m_floats[0] + (v.m_floats[0] - m_floats[0]) * t,
+						 m_floats[1] + (v.m_floats[1] - m_floats[1]) * t,
+						 m_floats[2] + (v.m_floats[2] - m_floats[2]) * t);
+#endif
+	}
+
+	/**@brief Elementwise multiply this vector by the other 
+   * @param v The other vector */
+	SIMD_FORCE_INLINE btVector3& operator*=(const btVector3& v)
+	{
+#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+		mVec128 = _mm_mul_ps(mVec128, v.mVec128);
+#elif defined(BT_USE_NEON)
+		mVec128 = vmulq_f32(mVec128, v.mVec128);
+#else
+		m_floats[0] *= v.m_floats[0];
+		m_floats[1] *= v.m_floats[1];
+		m_floats[2] *= v.m_floats[2];
+#endif
+		return *this;
+	}
+
+	/**@brief Return the x value */
+	SIMD_FORCE_INLINE const btScalar& getX() const { return m_floats[0]; }
+	/**@brief Return the y value */
+	SIMD_FORCE_INLINE const btScalar& getY() const { return m_floats[1]; }
+	/**@brief Return the z value */
+	SIMD_FORCE_INLINE const btScalar& getZ() const { return m_floats[2]; }
+	/**@brief Set the x value */
+	SIMD_FORCE_INLINE void setX(btScalar _x) { m_floats[0] = _x; };
+	/**@brief Set the y value */
+	SIMD_FORCE_INLINE void setY(btScalar _y) { m_floats[1] = _y; };
+	/**@brief Set the z value */
+	SIMD_FORCE_INLINE void setZ(btScalar _z) { m_floats[2] = _z; };
+	/**@brief Set the w value */
+	SIMD_FORCE_INLINE void setW(btScalar _w) { m_floats[3] = _w; };
+	/**@brief Return the x value */
+	SIMD_FORCE_INLINE const btScalar& x() const { return m_floats[0]; }
+	/**@brief Return the y value */
+	SIMD_FORCE_INLINE const btScalar& y() const { return m_floats[1]; }
+	/**@brief Return the z value */
+	SIMD_FORCE_INLINE const btScalar& z() const { return m_floats[2]; }
+	/**@brief Return the w value */
+	SIMD_FORCE_INLINE const btScalar& w() const { return m_floats[3]; }
+
+	//SIMD_FORCE_INLINE btScalar&       operator[](int i)       { return (&m_floats[0])[i];	}
+	//SIMD_FORCE_INLINE const btScalar& operator[](int i) const { return (&m_floats[0])[i]; }
+	///operator btScalar*() replaces operator[], using implicit conversion. We added operator != and operator == to avoid pointer comparisons.
+	SIMD_FORCE_INLINE operator btScalar*() { return &m_floats[0]; }
+	SIMD_FORCE_INLINE operator const btScalar*() const { return &m_floats[0]; }
+
+	SIMD_FORCE_INLINE bool operator==(const btVector3& other) const
+	{
+#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+		return (0xf == _mm_movemask_ps((__m128)_mm_cmpeq_ps(mVec128, other.mVec128)));
+#else
+		return ((m_floats[3] == other.m_floats[3]) &&
+				(m_floats[2] == other.m_floats[2]) &&
+				(m_floats[1] == other.m_floats[1]) &&
+				(m_floats[0] == other.m_floats[0]));
+#endif
+	}
+
+	SIMD_FORCE_INLINE bool operator!=(const btVector3& other) const
+	{
+		return !(*this == other);
+	}
+
+	/**@brief Set each element to the max of the current values and the values of another btVector3
+   * @param other The other btVector3 to compare with 
+   */
+	SIMD_FORCE_INLINE void setMax(const btVector3& other)
+	{
+#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+		mVec128 = _mm_max_ps(mVec128, other.mVec128);
+#elif defined(BT_USE_NEON)
+		mVec128 = vmaxq_f32(mVec128, other.mVec128);
+#else
+		btSetMax(m_floats[0], other.m_floats[0]);
+		btSetMax(m_floats[1], other.m_floats[1]);
+		btSetMax(m_floats[2], other.m_floats[2]);
+		btSetMax(m_floats[3], other.w());
+#endif
+	}
+
+	/**@brief Set each element to the min of the current values and the values of another btVector3
+   * @param other The other btVector3 to compare with 
+   */
+	SIMD_FORCE_INLINE void setMin(const btVector3& other)
+	{
+#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+		mVec128 = _mm_min_ps(mVec128, other.mVec128);
+#elif defined(BT_USE_NEON)
+		mVec128 = vminq_f32(mVec128, other.mVec128);
+#else
+		btSetMin(m_floats[0], other.m_floats[0]);
+		btSetMin(m_floats[1], other.m_floats[1]);
+		btSetMin(m_floats[2], other.m_floats[2]);
+		btSetMin(m_floats[3], other.w());
+#endif
+	}
+
+	SIMD_FORCE_INLINE void setValue(const btScalar& _x, const btScalar& _y, const btScalar& _z)
+	{
+		m_floats[0] = _x;
+		m_floats[1] = _y;
+		m_floats[2] = _z;
+		m_floats[3] = btScalar(0.f);
+	}
+
+	void getSkewSymmetricMatrix(btVector3 * v0, btVector3 * v1, btVector3 * v2) const
+	{
+#if defined BT_USE_SIMD_VECTOR3 && defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+
+		__m128 V = _mm_and_ps(mVec128, btvFFF0fMask);
+		__m128 V0 = _mm_xor_ps(btvMzeroMask, V);
+		__m128 V2 = _mm_movelh_ps(V0, V);
+
+		__m128 V1 = _mm_shuffle_ps(V, V0, 0xCE);
+
+		V0 = _mm_shuffle_ps(V0, V, 0xDB);
+		V2 = _mm_shuffle_ps(V2, V, 0xF9);
+
+		v0->mVec128 = V0;
+		v1->mVec128 = V1;
+		v2->mVec128 = V2;
+#else
+		v0->setValue(0., -z(), y());
+		v1->setValue(z(), 0., -x());
+		v2->setValue(-y(), x(), 0.);
+#endif
+	}
+
+	void setZero()
+	{
+#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+		mVec128 = (__m128)_mm_xor_ps(mVec128, mVec128);
+#elif defined(BT_USE_NEON)
+		int32x4_t vi = vdupq_n_s32(0);
+		mVec128 = vreinterpretq_f32_s32(vi);
+#else
+		setValue(btScalar(0.), btScalar(0.), btScalar(0.));
+#endif
+	}
+
+	SIMD_FORCE_INLINE bool isZero() const
+	{
+		return m_floats[0] == btScalar(0) && m_floats[1] == btScalar(0) && m_floats[2] == btScalar(0);
+	}
+
+	SIMD_FORCE_INLINE bool fuzzyZero() const
+	{
+		return length2() < SIMD_EPSILON * SIMD_EPSILON;
+	}
+
+	SIMD_FORCE_INLINE void serialize(struct btVector3Data & dataOut) const;
+
+	SIMD_FORCE_INLINE void deSerialize(const struct btVector3DoubleData& dataIn);
+
+	SIMD_FORCE_INLINE void deSerialize(const struct btVector3FloatData& dataIn);
+
+	SIMD_FORCE_INLINE void serializeFloat(struct btVector3FloatData & dataOut) const;
+
+	SIMD_FORCE_INLINE void deSerializeFloat(const struct btVector3FloatData& dataIn);
+
+	SIMD_FORCE_INLINE void serializeDouble(struct btVector3DoubleData & dataOut) const;
+
+	SIMD_FORCE_INLINE void deSerializeDouble(const struct btVector3DoubleData& dataIn);
+
+	/**@brief returns index of maximum dot product between this and vectors in array[]
+         * @param array The other vectors 
+         * @param array_count The number of other vectors 
+         * @param dotOut The maximum dot product */
+	SIMD_FORCE_INLINE long maxDot(const btVector3* array, long array_count, btScalar& dotOut) const;
+
+	/**@brief returns index of minimum dot product between this and vectors in array[]
+         * @param array The other vectors 
+         * @param array_count The number of other vectors 
+         * @param dotOut The minimum dot product */
+	SIMD_FORCE_INLINE long minDot(const btVector3* array, long array_count, btScalar& dotOut) const;
+
+	/* create a vector as  btVector3( this->dot( btVector3 v0 ), this->dot( btVector3 v1), this->dot( btVector3 v2 ))  */
+	SIMD_FORCE_INLINE btVector3 dot3(const btVector3& v0, const btVector3& v1, const btVector3& v2) const
+	{
+#if defined BT_USE_SIMD_VECTOR3 && defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+
+		__m128 a0 = _mm_mul_ps(v0.mVec128, this->mVec128);
+		__m128 a1 = _mm_mul_ps(v1.mVec128, this->mVec128);
+		__m128 a2 = _mm_mul_ps(v2.mVec128, this->mVec128);
+		__m128 b0 = _mm_unpacklo_ps(a0, a1);
+		__m128 b1 = _mm_unpackhi_ps(a0, a1);
+		__m128 b2 = _mm_unpacklo_ps(a2, _mm_setzero_ps());
+		__m128 r = _mm_movelh_ps(b0, b2);
+		r = _mm_add_ps(r, _mm_movehl_ps(b2, b0));
+		a2 = _mm_and_ps(a2, btvxyzMaskf);
+		r = _mm_add_ps(r, btCastdTo128f(_mm_move_sd(btCastfTo128d(a2), btCastfTo128d(b1))));
+		return btVector3(r);
+
+#elif defined(BT_USE_NEON)
+		static const uint32x4_t xyzMask = (const uint32x4_t){static_cast<uint32_t>(-1), static_cast<uint32_t>(-1), static_cast<uint32_t>(-1), 0};
+		float32x4_t a0 = vmulq_f32(v0.mVec128, this->mVec128);
+		float32x4_t a1 = vmulq_f32(v1.mVec128, this->mVec128);
+		float32x4_t a2 = vmulq_f32(v2.mVec128, this->mVec128);
+		float32x2x2_t zLo = vtrn_f32(vget_high_f32(a0), vget_high_f32(a1));
+		a2 = (float32x4_t)vandq_u32((uint32x4_t)a2, xyzMask);
+		float32x2_t b0 = vadd_f32(vpadd_f32(vget_low_f32(a0), vget_low_f32(a1)), zLo.val[0]);
+		float32x2_t b1 = vpadd_f32(vpadd_f32(vget_low_f32(a2), vget_high_f32(a2)), vdup_n_f32(0.0f));
+		return btVector3(vcombine_f32(b0, b1));
+#else
+		return btVector3(dot(v0), dot(v1), dot(v2));
+#endif
+	}
+};
+
+/**@brief Return the sum of two vectors (Point symantics)*/
+SIMD_FORCE_INLINE btVector3
+operator+(const btVector3& v1, const btVector3& v2)
+{
+#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+	return btVector3(_mm_add_ps(v1.mVec128, v2.mVec128));
+#elif defined(BT_USE_NEON)
+	return btVector3(vaddq_f32(v1.mVec128, v2.mVec128));
+#else
+	return btVector3(
+		v1.m_floats[0] + v2.m_floats[0],
+		v1.m_floats[1] + v2.m_floats[1],
+		v1.m_floats[2] + v2.m_floats[2]);
+#endif
+}
+
+/**@brief Return the elementwise product of two vectors */
+SIMD_FORCE_INLINE btVector3
+operator*(const btVector3& v1, const btVector3& v2)
+{
+#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+	return btVector3(_mm_mul_ps(v1.mVec128, v2.mVec128));
+#elif defined(BT_USE_NEON)
+	return btVector3(vmulq_f32(v1.mVec128, v2.mVec128));
+#else
+	return btVector3(
+		v1.m_floats[0] * v2.m_floats[0],
+		v1.m_floats[1] * v2.m_floats[1],
+		v1.m_floats[2] * v2.m_floats[2]);
+#endif
+}
+
+/**@brief Return the difference between two vectors */
+SIMD_FORCE_INLINE btVector3
+operator-(const btVector3& v1, const btVector3& v2)
+{
+#if defined BT_USE_SIMD_VECTOR3 && (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE))
+
+	//	without _mm_and_ps this code causes slowdown in Concave moving
+	__m128 r = _mm_sub_ps(v1.mVec128, v2.mVec128);
+	return btVector3(_mm_and_ps(r, btvFFF0fMask));
+#elif defined(BT_USE_NEON)
+	float32x4_t r = vsubq_f32(v1.mVec128, v2.mVec128);
+	return btVector3((float32x4_t)vandq_s32((int32x4_t)r, btvFFF0Mask));
+#else
+	return btVector3(
+		v1.m_floats[0] - v2.m_floats[0],
+		v1.m_floats[1] - v2.m_floats[1],
+		v1.m_floats[2] - v2.m_floats[2]);
+#endif
+}
+
+/**@brief Return the negative of the vector */
+SIMD_FORCE_INLINE btVector3
+operator-(const btVector3& v)
+{
+#if defined BT_USE_SIMD_VECTOR3 && (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE))
+	__m128 r = _mm_xor_ps(v.mVec128, btvMzeroMask);
+	return btVector3(_mm_and_ps(r, btvFFF0fMask));
+#elif defined(BT_USE_NEON)
+	return btVector3((btSimdFloat4)veorq_s32((int32x4_t)v.mVec128, (int32x4_t)btvMzeroMask));
+#else
+	return btVector3(-v.m_floats[0], -v.m_floats[1], -v.m_floats[2]);
+#endif
+}
+
+/**@brief Return the vector scaled by s */
+SIMD_FORCE_INLINE btVector3
+operator*(const btVector3& v, const btScalar& s)
+{
+#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+	__m128 vs = _mm_load_ss(&s);  //	(S 0 0 0)
+	vs = bt_pshufd_ps(vs, 0x80);  //	(S S S 0.0)
+	return btVector3(_mm_mul_ps(v.mVec128, vs));
+#elif defined(BT_USE_NEON)
+	float32x4_t r = vmulq_n_f32(v.mVec128, s);
+	return btVector3((float32x4_t)vandq_s32((int32x4_t)r, btvFFF0Mask));
+#else
+	return btVector3(v.m_floats[0] * s, v.m_floats[1] * s, v.m_floats[2] * s);
+#endif
+}
+
+/**@brief Return the vector scaled by s */
+SIMD_FORCE_INLINE btVector3
+operator*(const btScalar& s, const btVector3& v)
+{
+	return v * s;
+}
+
+/**@brief Return the vector inversely scaled by s */
+SIMD_FORCE_INLINE btVector3
+operator/(const btVector3& v, const btScalar& s)
+{
+	btFullAssert(s != btScalar(0.0));
+#if 0  //defined(BT_USE_SSE_IN_API)
+// this code is not faster !
+	__m128 vs = _mm_load_ss(&s);
+    vs = _mm_div_ss(v1110, vs);
+	vs = bt_pshufd_ps(vs, 0x00);	//	(S S S S)
+
+	return btVector3(_mm_mul_ps(v.mVec128, vs));
+#else
+	return v * (btScalar(1.0) / s);
+#endif
+}
+
+/**@brief Return the vector inversely scaled by s */
+SIMD_FORCE_INLINE btVector3
+operator/(const btVector3& v1, const btVector3& v2)
+{
+#if defined BT_USE_SIMD_VECTOR3 && (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE))
+	__m128 vec = _mm_div_ps(v1.mVec128, v2.mVec128);
+	vec = _mm_and_ps(vec, btvFFF0fMask);
+	return btVector3(vec);
+#elif defined(BT_USE_NEON)
+	float32x4_t x, y, v, m;
+
+	x = v1.mVec128;
+	y = v2.mVec128;
+
+	v = vrecpeq_f32(y);     // v ~ 1/y
+	m = vrecpsq_f32(y, v);  // m = (2-v*y)
+	v = vmulq_f32(v, m);    // vv = v*m ~~ 1/y
+	m = vrecpsq_f32(y, v);  // mm = (2-vv*y)
+	v = vmulq_f32(v, x);    // x*vv
+	v = vmulq_f32(v, m);    // (x*vv)*(2-vv*y) = x*(vv(2-vv*y)) ~~~ x/y
+
+	return btVector3(v);
+#else
+	return btVector3(
+		v1.m_floats[0] / v2.m_floats[0],
+		v1.m_floats[1] / v2.m_floats[1],
+		v1.m_floats[2] / v2.m_floats[2]);
+#endif
+}
+
+/**@brief Return the dot product between two vectors */
+SIMD_FORCE_INLINE btScalar
+btDot(const btVector3& v1, const btVector3& v2)
+{
+	return v1.dot(v2);
+}
+
+/**@brief Return the distance squared between two vectors */
+SIMD_FORCE_INLINE btScalar
+btDistance2(const btVector3& v1, const btVector3& v2)
+{
+	return v1.distance2(v2);
+}
+
+/**@brief Return the distance between two vectors */
+SIMD_FORCE_INLINE btScalar
+btDistance(const btVector3& v1, const btVector3& v2)
+{
+	return v1.distance(v2);
+}
+
+/**@brief Return the angle between two vectors */
+SIMD_FORCE_INLINE btScalar
+btAngle(const btVector3& v1, const btVector3& v2)
+{
+	return v1.angle(v2);
+}
+
+/**@brief Return the cross product of two vectors */
+SIMD_FORCE_INLINE btVector3
+btCross(const btVector3& v1, const btVector3& v2)
+{
+	return v1.cross(v2);
+}
+
+SIMD_FORCE_INLINE btScalar
+btTriple(const btVector3& v1, const btVector3& v2, const btVector3& v3)
+{
+	return v1.triple(v2, v3);
+}
+
+/**@brief Return the linear interpolation between two vectors
+ * @param v1 One vector 
+ * @param v2 The other vector 
+ * @param t The ration of this to v (t = 0 => return v1, t=1 => return v2) */
+SIMD_FORCE_INLINE btVector3
+lerp(const btVector3& v1, const btVector3& v2, const btScalar& t)
+{
+	return v1.lerp(v2, t);
+}
+
+SIMD_FORCE_INLINE btScalar btVector3::distance2(const btVector3& v) const
+{
+	return (v - *this).length2();
+}
+
+SIMD_FORCE_INLINE btScalar btVector3::distance(const btVector3& v) const
+{
+	return (v - *this).length();
+}
+
+SIMD_FORCE_INLINE btVector3 btVector3::normalized() const
+{
+	btVector3 nrm = *this;
+
+	return nrm.normalize();
+}
+
+SIMD_FORCE_INLINE btVector3 btVector3::rotate(const btVector3& wAxis, const btScalar _angle) const
+{
+	// wAxis must be a unit lenght vector
+
+#if defined BT_USE_SIMD_VECTOR3 && defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+
+	__m128 O = _mm_mul_ps(wAxis.mVec128, mVec128);
+	btScalar ssin = btSin(_angle);
+	__m128 C = wAxis.cross(mVec128).mVec128;
+	O = _mm_and_ps(O, btvFFF0fMask);
+	btScalar scos = btCos(_angle);
+
+	__m128 vsin = _mm_load_ss(&ssin);  //	(S 0 0 0)
+	__m128 vcos = _mm_load_ss(&scos);  //	(S 0 0 0)
+
+	__m128 Y = bt_pshufd_ps(O, 0xC9);  //	(Y Z X 0)
+	__m128 Z = bt_pshufd_ps(O, 0xD2);  //	(Z X Y 0)
+	O = _mm_add_ps(O, Y);
+	vsin = bt_pshufd_ps(vsin, 0x80);  //	(S S S 0)
+	O = _mm_add_ps(O, Z);
+	vcos = bt_pshufd_ps(vcos, 0x80);  //	(S S S 0)
+
+	vsin = vsin * C;
+	O = O * wAxis.mVec128;
+	__m128 X = mVec128 - O;
+
+	O = O + vsin;
+	vcos = vcos * X;
+	O = O + vcos;
+
+	return btVector3(O);
+#else
+	btVector3 o = wAxis * wAxis.dot(*this);
+	btVector3 _x = *this - o;
+	btVector3 _y;
+
+	_y = wAxis.cross(*this);
+
+	return (o + _x * btCos(_angle) + _y * btSin(_angle));
+#endif
+}
+
+SIMD_FORCE_INLINE long btVector3::maxDot(const btVector3* array, long array_count, btScalar& dotOut) const
+{
+#if (defined BT_USE_SSE && defined BT_USE_SIMD_VECTOR3 && defined BT_USE_SSE_IN_API) || defined(BT_USE_NEON)
+#if defined _WIN32 || defined(BT_USE_SSE)
+	const long scalar_cutoff = 10;
+	long _maxdot_large(const float* array, const float* vec, unsigned long array_count, float* dotOut);
+#elif defined BT_USE_NEON
+	const long scalar_cutoff = 4;
+	extern long (*_maxdot_large)(const float* array, const float* vec, unsigned long array_count, float* dotOut);
+#endif
+	if (array_count < scalar_cutoff)
+#endif
+	{
+		btScalar maxDot1 = -SIMD_INFINITY;
+		int i = 0;
+		int ptIndex = -1;
+		for (i = 0; i < array_count; i++)
+		{
+			btScalar dot = array[i].dot(*this);
+
+			if (dot > maxDot1)
+			{
+				maxDot1 = dot;
+				ptIndex = i;
+			}
+		}
+
+		dotOut = maxDot1;
+		return ptIndex;
+	}
+#if (defined BT_USE_SSE && defined BT_USE_SIMD_VECTOR3 && defined BT_USE_SSE_IN_API) || defined(BT_USE_NEON)
+	return _maxdot_large((float*)array, (float*)&m_floats[0], array_count, &dotOut);
+#endif
+}
+
+SIMD_FORCE_INLINE long btVector3::minDot(const btVector3* array, long array_count, btScalar& dotOut) const
+{
+#if (defined BT_USE_SSE && defined BT_USE_SIMD_VECTOR3 && defined BT_USE_SSE_IN_API) || defined(BT_USE_NEON)
+#if defined BT_USE_SSE
+	const long scalar_cutoff = 10;
+	long _mindot_large(const float* array, const float* vec, unsigned long array_count, float* dotOut);
+#elif defined BT_USE_NEON
+	const long scalar_cutoff = 4;
+	extern long (*_mindot_large)(const float* array, const float* vec, unsigned long array_count, float* dotOut);
+#else
+#error unhandled arch!
+#endif
+
+	if (array_count < scalar_cutoff)
+#endif
+	{
+		btScalar minDot = SIMD_INFINITY;
+		int i = 0;
+		int ptIndex = -1;
+
+		for (i = 0; i < array_count; i++)
+		{
+			btScalar dot = array[i].dot(*this);
+
+			if (dot < minDot)
+			{
+				minDot = dot;
+				ptIndex = i;
+			}
+		}
+
+		dotOut = minDot;
+
+		return ptIndex;
+	}
+#if (defined BT_USE_SSE && defined BT_USE_SIMD_VECTOR3 && defined BT_USE_SSE_IN_API) || defined(BT_USE_NEON)
+	return _mindot_large((float*)array, (float*)&m_floats[0], array_count, &dotOut);
+#endif  //BT_USE_SIMD_VECTOR3
+}
+
+class btVector4 : public btVector3
+{
+public:
+	SIMD_FORCE_INLINE btVector4() {}
+
+	SIMD_FORCE_INLINE btVector4(const btScalar& _x, const btScalar& _y, const btScalar& _z, const btScalar& _w)
+		: btVector3(_x, _y, _z)
+	{
+		m_floats[3] = _w;
+	}
+
+#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON)
+	SIMD_FORCE_INLINE btVector4(const btSimdFloat4 vec)
+	{
+		mVec128 = vec;
+	}
+
+	SIMD_FORCE_INLINE btVector4(const btVector3& rhs)
+	{
+		mVec128 = rhs.mVec128;
+	}
+
+	SIMD_FORCE_INLINE btVector4&
+	operator=(const btVector4& v)
+	{
+		mVec128 = v.mVec128;
+		return *this;
+	}
+#endif  // #if defined (BT_USE_SSE_IN_API) || defined (BT_USE_NEON)
+
+	SIMD_FORCE_INLINE btVector4 absolute4() const
+	{
+#if defined BT_USE_SIMD_VECTOR3 && defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)
+		return btVector4(_mm_and_ps(mVec128, btvAbsfMask));
+#elif defined(BT_USE_NEON)
+		return btVector4(vabsq_f32(mVec128));
+#else
+		return btVector4(
+			btFabs(m_floats[0]),
+			btFabs(m_floats[1]),
+			btFabs(m_floats[2]),
+			btFabs(m_floats[3]));
+#endif
+	}
+
+	btScalar getW() const { return m_floats[3]; }
+
+	SIMD_FORCE_INLINE int maxAxis4() const
+	{
+		int maxIndex = -1;
+		btScalar maxVal = btScalar(-BT_LARGE_FLOAT);
+		if (m_floats[0] > maxVal)
+		{
+			maxIndex = 0;
+			maxVal = m_floats[0];
+		}
+		if (m_floats[1] > maxVal)
+		{
+			maxIndex = 1;
+			maxVal = m_floats[1];
+		}
+		if (m_floats[2] > maxVal)
+		{
+			maxIndex = 2;
+			maxVal = m_floats[2];
+		}
+		if (m_floats[3] > maxVal)
+		{
+			maxIndex = 3;
+		}
+
+		return maxIndex;
+	}
+
+	SIMD_FORCE_INLINE int minAxis4() const
+	{
+		int minIndex = -1;
+		btScalar minVal = btScalar(BT_LARGE_FLOAT);
+		if (m_floats[0] < minVal)
+		{
+			minIndex = 0;
+			minVal = m_floats[0];
+		}
+		if (m_floats[1] < minVal)
+		{
+			minIndex = 1;
+			minVal = m_floats[1];
+		}
+		if (m_floats[2] < minVal)
+		{
+			minIndex = 2;
+			minVal = m_floats[2];
+		}
+		if (m_floats[3] < minVal)
+		{
+			minIndex = 3;
+		}
+
+		return minIndex;
+	}
+
+	SIMD_FORCE_INLINE int closestAxis4() const
+	{
+		return absolute4().maxAxis4();
+	}
+
+	/**@brief Set x,y,z and zero w 
+   * @param x Value of x
+   * @param y Value of y
+   * @param z Value of z
+   */
+
+	/*		void getValue(btScalar *m) const 
+		{
+			m[0] = m_floats[0];
+			m[1] = m_floats[1];
+			m[2] =m_floats[2];
+		}
+*/
+	/**@brief Set the values 
+   * @param x Value of x
+   * @param y Value of y
+   * @param z Value of z
+   * @param w Value of w
+   */
+	SIMD_FORCE_INLINE void setValue(const btScalar& _x, const btScalar& _y, const btScalar& _z, const btScalar& _w)
+	{
+		m_floats[0] = _x;
+		m_floats[1] = _y;
+		m_floats[2] = _z;
+		m_floats[3] = _w;
+	}
+};
+
+///btSwapVector3Endian swaps vector endianness, useful for network and cross-platform serialization
+SIMD_FORCE_INLINE void btSwapScalarEndian(const btScalar& sourceVal, btScalar& destVal)
+{
+#ifdef BT_USE_DOUBLE_PRECISION
+	unsigned char* dest = (unsigned char*)&destVal;
+	const unsigned char* src = (const unsigned char*)&sourceVal;
+	dest[0] = src[7];
+	dest[1] = src[6];
+	dest[2] = src[5];
+	dest[3] = src[4];
+	dest[4] = src[3];
+	dest[5] = src[2];
+	dest[6] = src[1];
+	dest[7] = src[0];
+#else
+	unsigned char* dest = (unsigned char*)&destVal;
+	const unsigned char* src = (const unsigned char*)&sourceVal;
+	dest[0] = src[3];
+	dest[1] = src[2];
+	dest[2] = src[1];
+	dest[3] = src[0];
+#endif  //BT_USE_DOUBLE_PRECISION
+}
+///btSwapVector3Endian swaps vector endianness, useful for network and cross-platform serialization
+SIMD_FORCE_INLINE void btSwapVector3Endian(const btVector3& sourceVec, btVector3& destVec)
+{
+	for (int i = 0; i < 4; i++)
+	{
+		btSwapScalarEndian(sourceVec[i], destVec[i]);
+	}
+}
+
+///btUnSwapVector3Endian swaps vector endianness, useful for network and cross-platform serialization
+SIMD_FORCE_INLINE void btUnSwapVector3Endian(btVector3& vector)
+{
+	btVector3 swappedVec;
+	for (int i = 0; i < 4; i++)
+	{
+		btSwapScalarEndian(vector[i], swappedVec[i]);
+	}
+	vector = swappedVec;
+}
+
+template <class T>
+SIMD_FORCE_INLINE void btPlaneSpace1(const T& n, T& p, T& q)
+{
+	if (btFabs(n[2]) > SIMDSQRT12)
+	{
+		// choose p in y-z plane
+		btScalar a = n[1] * n[1] + n[2] * n[2];
+		btScalar k = btRecipSqrt(a);
+		p[0] = 0;
+		p[1] = -n[2] * k;
+		p[2] = n[1] * k;
+		// set q = n x p
+		q[0] = a * k;
+		q[1] = -n[0] * p[2];
+		q[2] = n[0] * p[1];
+	}
+	else
+	{
+		// choose p in x-y plane
+		btScalar a = n[0] * n[0] + n[1] * n[1];
+		btScalar k = btRecipSqrt(a);
+		p[0] = -n[1] * k;
+		p[1] = n[0] * k;
+		p[2] = 0;
+		// set q = n x p
+		q[0] = -n[2] * p[1];
+		q[1] = n[2] * p[0];
+		q[2] = a * k;
+	}
+}
+
+struct btVector3FloatData
+{
+	float m_floats[4];
+};
+
+struct btVector3DoubleData
+{
+	double m_floats[4];
+};
+
+SIMD_FORCE_INLINE void btVector3::serializeFloat(struct btVector3FloatData& dataOut) const
+{
+	///could also do a memcpy, check if it is worth it
+	for (int i = 0; i < 4; i++)
+		dataOut.m_floats[i] = float(m_floats[i]);
+}
+
+SIMD_FORCE_INLINE void btVector3::deSerializeFloat(const struct btVector3FloatData& dataIn)
+{
+	for (int i = 0; i < 4; i++)
+		m_floats[i] = btScalar(dataIn.m_floats[i]);
+}
+
+SIMD_FORCE_INLINE void btVector3::serializeDouble(struct btVector3DoubleData& dataOut) const
+{
+	///could also do a memcpy, check if it is worth it
+	for (int i = 0; i < 4; i++)
+		dataOut.m_floats[i] = double(m_floats[i]);
+}
+
+SIMD_FORCE_INLINE void btVector3::deSerializeDouble(const struct btVector3DoubleData& dataIn)
+{
+	for (int i = 0; i < 4; i++)
+		m_floats[i] = btScalar(dataIn.m_floats[i]);
+}
+
+SIMD_FORCE_INLINE void btVector3::serialize(struct btVector3Data& dataOut) const
+{
+	///could also do a memcpy, check if it is worth it
+	for (int i = 0; i < 4; i++)
+		dataOut.m_floats[i] = m_floats[i];
+}
+
+SIMD_FORCE_INLINE void btVector3::deSerialize(const struct btVector3FloatData& dataIn)
+{
+	for (int i = 0; i < 4; i++)
+		m_floats[i] = (btScalar)dataIn.m_floats[i];
+}
+
+SIMD_FORCE_INLINE void btVector3::deSerialize(const struct btVector3DoubleData& dataIn)
+{
+	for (int i = 0; i < 4; i++)
+		m_floats[i] = (btScalar)dataIn.m_floats[i];
+}
+
+#endif  //BT_VECTOR3_H
diff --git a/engine/inc/bullet/LuaDemo/LuaPhysicsSetup.h b/engine/inc/bullet/LuaDemo/LuaPhysicsSetup.h
new file mode 100644
index 00000000..76d91238
--- /dev/null
+++ b/engine/inc/bullet/LuaDemo/LuaPhysicsSetup.h
@@ -0,0 +1,6 @@
+#ifndef _LUA_PHYSICS_SETUP_H
+#define _LUA_PHYSICS_SETUP_H
+
+class CommonExampleInterface* LuaDemoCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //_LUA_PHYSICS_SETUP_H
diff --git a/engine/inc/bullet/MultiBody/InvertedPendulumPDControl.h b/engine/inc/bullet/MultiBody/InvertedPendulumPDControl.h
new file mode 100644
index 00000000..b108f292
--- /dev/null
+++ b/engine/inc/bullet/MultiBody/InvertedPendulumPDControl.h
@@ -0,0 +1,6 @@
+#ifndef INVERTED_PENDULUM_PD_CONTROL_H
+#define INVERTED_PENDULUM_PD_CONTROL_H
+
+class CommonExampleInterface* InvertedPendulumPDControlCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //INVERTED_PENDULUM_PD_CONTROL_H
diff --git a/engine/inc/bullet/MultiBody/KinematicMultiBodyExample.h b/engine/inc/bullet/MultiBody/KinematicMultiBodyExample.h
new file mode 100644
index 00000000..1d6f44bb
--- /dev/null
+++ b/engine/inc/bullet/MultiBody/KinematicMultiBodyExample.h
@@ -0,0 +1,21 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2015 Google Inc. http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef KINEMATIC_MULTI_BODY_EXAMPLE_H
+#define KINEMATIC_MULTI_BODY_EXAMPLE_H
+
+class CommonExampleInterface* KinematicMultiBodyExampleCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //KINEMATIC_MULTI_BODY_EXAMPLE_H
diff --git a/engine/inc/bullet/MultiBody/MultiBodyConstraintFeedback.h b/engine/inc/bullet/MultiBody/MultiBodyConstraintFeedback.h
new file mode 100644
index 00000000..333d7efb
--- /dev/null
+++ b/engine/inc/bullet/MultiBody/MultiBodyConstraintFeedback.h
@@ -0,0 +1,6 @@
+#ifndef MULTIBODY_CONSTRAINT_FEEDBACK_H
+#define MULTIBODY_CONSTRAINT_FEEDBACK_H
+
+class CommonExampleInterface* MultiBodyConstraintFeedbackCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //MULTIBODY_CONSTRAINT_FEEDBACK_H
diff --git a/engine/inc/bullet/MultiBody/MultiBodySoftContact.h b/engine/inc/bullet/MultiBody/MultiBodySoftContact.h
new file mode 100644
index 00000000..aebfda74
--- /dev/null
+++ b/engine/inc/bullet/MultiBody/MultiBodySoftContact.h
@@ -0,0 +1,6 @@
+#ifndef MULTI_BODY_SOFT_CONTACT_H
+#define MULTI_BODY_SOFT_CONTACT_H
+
+class CommonExampleInterface* MultiBodySoftContactCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //MULTI_BODY_SOFT_CONTACT_H
diff --git a/engine/inc/bullet/MultiBody/MultiDofDemo.h b/engine/inc/bullet/MultiBody/MultiDofDemo.h
new file mode 100644
index 00000000..bf640e17
--- /dev/null
+++ b/engine/inc/bullet/MultiBody/MultiDofDemo.h
@@ -0,0 +1,7 @@
+
+#ifndef MULTI_DOF_DEMO_H
+#define MULTI_DOF_DEMO_H
+
+class CommonExampleInterface* MultiDofCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //MULTI_DOF_DEMO_H
diff --git a/engine/inc/bullet/MultiBody/Pendulum.h b/engine/inc/bullet/MultiBody/Pendulum.h
new file mode 100644
index 00000000..28a5150c
--- /dev/null
+++ b/engine/inc/bullet/MultiBody/Pendulum.h
@@ -0,0 +1,6 @@
+#ifndef TEST_PENDULUM_H
+#define TEST_PENDULUM_H
+
+class CommonExampleInterface* TestPendulumCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //TEST_PENDULUM_H
diff --git a/engine/inc/bullet/MultiBody/SerialChains.h b/engine/inc/bullet/MultiBody/SerialChains.h
new file mode 100644
index 00000000..aa7d75ec
--- /dev/null
+++ b/engine/inc/bullet/MultiBody/SerialChains.h
@@ -0,0 +1,7 @@
+
+#ifndef MULTI_BODY_CONSTRAINT_SOLVERS_DEMO_H
+#define MULTI_BODY_CONSTRAINT_SOLVERS_DEMO_H
+
+class CommonExampleInterface* SerialChainsCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //MULTI_BODY_CONSTRAINT_SOLVERS_DEMO_H
diff --git a/engine/inc/bullet/MultiBody/TestJointTorqueSetup.h b/engine/inc/bullet/MultiBody/TestJointTorqueSetup.h
new file mode 100644
index 00000000..60a2d67a
--- /dev/null
+++ b/engine/inc/bullet/MultiBody/TestJointTorqueSetup.h
@@ -0,0 +1,6 @@
+#ifndef TEST_JOINT_TORQUE_SETUP_H
+#define TEST_JOINT_TORQUE_SETUP_H
+
+class CommonExampleInterface* TestJointTorqueCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //TEST_JOINT_TORQUE_SETUP_H
diff --git a/engine/inc/bullet/MultiBody/pendulum_gold.h b/engine/inc/bullet/MultiBody/pendulum_gold.h
new file mode 100644
index 00000000..8530a80d
--- /dev/null
+++ b/engine/inc/bullet/MultiBody/pendulum_gold.h
@@ -0,0 +1,2057 @@
+#ifndef PENDULUM_GOLD_H
+#define PENDULUM_GOLD_H
+
+#include "LinearMath/btScalar.h"
+
+/*
+sPendulumGold data was created using the Python script,
+thanks to Andreas Bihlmaier for the script.
+
+#!/usr/bin/env python
+
+from __future__ import print_function
+
+import numpy as np
+from scipy import integrate
+import pylab as pl
+import math
+import argparse
+
+theta_pos = 0
+dtheta_pos = 1
+
+def pendulum_system(Y, t):
+  m = 10  # [kg]
+  g = 9.81  # [m/s^2]
+  l = 0.5  # [m]
+  tau = 20  # [Nm]
+  I = m * pow(l, 2)  # inertia
+  return [Y[dtheta_pos], (tau - m*g*l*math.sin(Y[theta_pos])) / I]
+
+def main():
+  parser = argparse.ArgumentParser()
+  parser.add_argument('--plot', action='store_true', default=False, help='Plot results')
+  args = parser.parse_args()
+
+  t = np.arange(0, 2, 0.001) # [s]
+  theta0 = 0
+  dtheta0 = 0
+  theta = integrate.odeint(pendulum_system, [theta0, dtheta0], t)  # [rad]
+  print("timestamp;theta;")
+  for i in range(theta.shape[0]):
+    print("%f;%f;" % (t[i], theta[i,theta_pos]))
+
+  if args.plot:
+    pl.plot(t, theta[:,theta_pos], '+')
+    pl.show()
+
+
+if __name__ == '__main__':
+  main()
+*/
+
+//sPendulumGold stores scalar values of a simulated pendulum in tuples 'timestamp' and 'theta joint angle'
+static btScalar sPendulumGold[] =
+	{
+		0.000000, 0.000000,
+		0.001000, 0.000004,
+		0.002000, 0.000016,
+		0.003000, 0.000036,
+		0.004000, 0.000064,
+		0.005000, 0.000100,
+		0.006000, 0.000144,
+		0.007000, 0.000196,
+		0.008000, 0.000256,
+		0.009000, 0.000324,
+		0.010000, 0.000400,
+		0.011000, 0.000484,
+		0.012000, 0.000576,
+		0.013000, 0.000676,
+		0.014000, 0.000784,
+		0.015000, 0.000900,
+		0.016000, 0.001024,
+		0.017000, 0.001155,
+		0.018000, 0.001295,
+		0.019000, 0.001443,
+		0.020000, 0.001599,
+		0.021000, 0.001763,
+		0.022000, 0.001934,
+		0.023000, 0.002114,
+		0.024000, 0.002302,
+		0.025000, 0.002497,
+		0.026000, 0.002701,
+		0.027000, 0.002913,
+		0.028000, 0.003132,
+		0.029000, 0.003359,
+		0.030000, 0.003595,
+		0.031000, 0.003838,
+		0.032000, 0.004089,
+		0.033000, 0.004348,
+		0.034000, 0.004615,
+		0.035000, 0.004890,
+		0.036000, 0.005173,
+		0.037000, 0.005464,
+		0.038000, 0.005762,
+		0.039000, 0.006069,
+		0.040000, 0.006383,
+		0.041000, 0.006706,
+		0.042000, 0.007036,
+		0.043000, 0.007374,
+		0.044000, 0.007720,
+		0.045000, 0.008073,
+		0.046000, 0.008435,
+		0.047000, 0.008804,
+		0.048000, 0.009181,
+		0.049000, 0.009566,
+		0.050000, 0.009959,
+		0.051000, 0.010360,
+		0.052000, 0.010768,
+		0.053000, 0.011184,
+		0.054000, 0.011608,
+		0.055000, 0.012040,
+		0.056000, 0.012480,
+		0.057000, 0.012927,
+		0.058000, 0.013382,
+		0.059000, 0.013845,
+		0.060000, 0.014315,
+		0.061000, 0.014794,
+		0.062000, 0.015280,
+		0.063000, 0.015773,
+		0.064000, 0.016275,
+		0.065000, 0.016784,
+		0.066000, 0.017300,
+		0.067000, 0.017825,
+		0.068000, 0.018357,
+		0.069000, 0.018896,
+		0.070000, 0.019443,
+		0.071000, 0.019998,
+		0.072000, 0.020561,
+		0.073000, 0.021131,
+		0.074000, 0.021709,
+		0.075000, 0.022294,
+		0.076000, 0.022887,
+		0.077000, 0.023487,
+		0.078000, 0.024095,
+		0.079000, 0.024710,
+		0.080000, 0.025333,
+		0.081000, 0.025964,
+		0.082000, 0.026602,
+		0.083000, 0.027247,
+		0.084000, 0.027900,
+		0.085000, 0.028560,
+		0.086000, 0.029228,
+		0.087000, 0.029903,
+		0.088000, 0.030586,
+		0.089000, 0.031276,
+		0.090000, 0.031973,
+		0.091000, 0.032678,
+		0.092000, 0.033390,
+		0.093000, 0.034110,
+		0.094000, 0.034836,
+		0.095000, 0.035570,
+		0.096000, 0.036312,
+		0.097000, 0.037061,
+		0.098000, 0.037817,
+		0.099000, 0.038580,
+		0.100000, 0.039350,
+		0.101000, 0.040128,
+		0.102000, 0.040913,
+		0.103000, 0.041705,
+		0.104000, 0.042504,
+		0.105000, 0.043311,
+		0.106000, 0.044124,
+		0.107000, 0.044945,
+		0.108000, 0.045773,
+		0.109000, 0.046608,
+		0.110000, 0.047450,
+		0.111000, 0.048299,
+		0.112000, 0.049155,
+		0.113000, 0.050019,
+		0.114000, 0.050889,
+		0.115000, 0.051766,
+		0.116000, 0.052650,
+		0.117000, 0.053542,
+		0.118000, 0.054440,
+		0.119000, 0.055345,
+		0.120000, 0.056257,
+		0.121000, 0.057176,
+		0.122000, 0.058101,
+		0.123000, 0.059034,
+		0.124000, 0.059973,
+		0.125000, 0.060920,
+		0.126000, 0.061873,
+		0.127000, 0.062833,
+		0.128000, 0.063799,
+		0.129000, 0.064773,
+		0.130000, 0.065753,
+		0.131000, 0.066740,
+		0.132000, 0.067733,
+		0.133000, 0.068734,
+		0.134000, 0.069740,
+		0.135000, 0.070754,
+		0.136000, 0.071774,
+		0.137000, 0.072801,
+		0.138000, 0.073834,
+		0.139000, 0.074874,
+		0.140000, 0.075920,
+		0.141000, 0.076973,
+		0.142000, 0.078032,
+		0.143000, 0.079098,
+		0.144000, 0.080170,
+		0.145000, 0.081249,
+		0.146000, 0.082334,
+		0.147000, 0.083426,
+		0.148000, 0.084524,
+		0.149000, 0.085628,
+		0.150000, 0.086738,
+		0.151000, 0.087855,
+		0.152000, 0.088978,
+		0.153000, 0.090108,
+		0.154000, 0.091243,
+		0.155000, 0.092385,
+		0.156000, 0.093533,
+		0.157000, 0.094687,
+		0.158000, 0.095848,
+		0.159000, 0.097014,
+		0.160000, 0.098187,
+		0.161000, 0.099365,
+		0.162000, 0.100550,
+		0.163000, 0.101741,
+		0.164000, 0.102937,
+		0.165000, 0.104140,
+		0.166000, 0.105349,
+		0.167000, 0.106563,
+		0.168000, 0.107784,
+		0.169000, 0.109010,
+		0.170000, 0.110242,
+		0.171000, 0.111480,
+		0.172000, 0.112724,
+		0.173000, 0.113974,
+		0.174000, 0.115230,
+		0.175000, 0.116491,
+		0.176000, 0.117758,
+		0.177000, 0.119030,
+		0.178000, 0.120309,
+		0.179000, 0.121593,
+		0.180000, 0.122882,
+		0.181000, 0.124177,
+		0.182000, 0.125478,
+		0.183000, 0.126784,
+		0.184000, 0.128096,
+		0.185000, 0.129413,
+		0.186000, 0.130736,
+		0.187000, 0.132064,
+		0.188000, 0.133398,
+		0.189000, 0.134737,
+		0.190000, 0.136081,
+		0.191000, 0.137431,
+		0.192000, 0.138786,
+		0.193000, 0.140146,
+		0.194000, 0.141512,
+		0.195000, 0.142883,
+		0.196000, 0.144259,
+		0.197000, 0.145640,
+		0.198000, 0.147026,
+		0.199000, 0.148418,
+		0.200000, 0.149814,
+		0.201000, 0.151216,
+		0.202000, 0.152623,
+		0.203000, 0.154034,
+		0.204000, 0.155451,
+		0.205000, 0.156873,
+		0.206000, 0.158299,
+		0.207000, 0.159731,
+		0.208000, 0.161167,
+		0.209000, 0.162608,
+		0.210000, 0.164054,
+		0.211000, 0.165505,
+		0.212000, 0.166961,
+		0.213000, 0.168421,
+		0.214000, 0.169886,
+		0.215000, 0.171356,
+		0.216000, 0.172830,
+		0.217000, 0.174309,
+		0.218000, 0.175793,
+		0.219000, 0.177281,
+		0.220000, 0.178774,
+		0.221000, 0.180271,
+		0.222000, 0.181773,
+		0.223000, 0.183279,
+		0.224000, 0.184790,
+		0.225000, 0.186305,
+		0.226000, 0.187824,
+		0.227000, 0.189348,
+		0.228000, 0.190876,
+		0.229000, 0.192408,
+		0.230000, 0.193945,
+		0.231000, 0.195485,
+		0.232000, 0.197030,
+		0.233000, 0.198579,
+		0.234000, 0.200133,
+		0.235000, 0.201690,
+		0.236000, 0.203251,
+		0.237000, 0.204817,
+		0.238000, 0.206386,
+		0.239000, 0.207960,
+		0.240000, 0.209537,
+		0.241000, 0.211118,
+		0.242000, 0.212703,
+		0.243000, 0.214293,
+		0.244000, 0.215885,
+		0.245000, 0.217482,
+		0.246000, 0.219082,
+		0.247000, 0.220687,
+		0.248000, 0.222295,
+		0.249000, 0.223906,
+		0.250000, 0.225521,
+		0.251000, 0.227140,
+		0.252000, 0.228762,
+		0.253000, 0.230388,
+		0.254000, 0.232018,
+		0.255000, 0.233651,
+		0.256000, 0.235287,
+		0.257000, 0.236927,
+		0.258000, 0.238570,
+		0.259000, 0.240217,
+		0.260000, 0.241867,
+		0.261000, 0.243520,
+		0.262000, 0.245176,
+		0.263000, 0.246836,
+		0.264000, 0.248499,
+		0.265000, 0.250165,
+		0.266000, 0.251834,
+		0.267000, 0.253507,
+		0.268000, 0.255182,
+		0.269000, 0.256861,
+		0.270000, 0.258542,
+		0.271000, 0.260227,
+		0.272000, 0.261914,
+		0.273000, 0.263604,
+		0.274000, 0.265298,
+		0.275000, 0.266994,
+		0.276000, 0.268693,
+		0.277000, 0.270394,
+		0.278000, 0.272099,
+		0.279000, 0.273806,
+		0.280000, 0.275516,
+		0.281000, 0.277229,
+		0.282000, 0.278944,
+		0.283000, 0.280662,
+		0.284000, 0.282382,
+		0.285000, 0.284105,
+		0.286000, 0.285830,
+		0.287000, 0.287558,
+		0.288000, 0.289288,
+		0.289000, 0.291021,
+		0.290000, 0.292756,
+		0.291000, 0.294493,
+		0.292000, 0.296233,
+		0.293000, 0.297975,
+		0.294000, 0.299719,
+		0.295000, 0.301466,
+		0.296000, 0.303214,
+		0.297000, 0.304965,
+		0.298000, 0.306718,
+		0.299000, 0.308473,
+		0.300000, 0.310230,
+		0.301000, 0.311989,
+		0.302000, 0.313750,
+		0.303000, 0.315513,
+		0.304000, 0.317278,
+		0.305000, 0.319044,
+		0.306000, 0.320813,
+		0.307000, 0.322583,
+		0.308000, 0.324355,
+		0.309000, 0.326129,
+		0.310000, 0.327905,
+		0.311000, 0.329682,
+		0.312000, 0.331461,
+		0.313000, 0.333241,
+		0.314000, 0.335024,
+		0.315000, 0.336807,
+		0.316000, 0.338592,
+		0.317000, 0.340379,
+		0.318000, 0.342167,
+		0.319000, 0.343957,
+		0.320000, 0.345748,
+		0.321000, 0.347540,
+		0.322000, 0.349334,
+		0.323000, 0.351128,
+		0.324000, 0.352925,
+		0.325000, 0.354722,
+		0.326000, 0.356520,
+		0.327000, 0.358320,
+		0.328000, 0.360121,
+		0.329000, 0.361923,
+		0.330000, 0.363726,
+		0.331000, 0.365530,
+		0.332000, 0.367335,
+		0.333000, 0.369141,
+		0.334000, 0.370947,
+		0.335000, 0.372755,
+		0.336000, 0.374564,
+		0.337000, 0.376373,
+		0.338000, 0.378183,
+		0.339000, 0.379994,
+		0.340000, 0.381806,
+		0.341000, 0.383618,
+		0.342000, 0.385431,
+		0.343000, 0.387245,
+		0.344000, 0.389059,
+		0.345000, 0.390874,
+		0.346000, 0.392689,
+		0.347000, 0.394505,
+		0.348000, 0.396321,
+		0.349000, 0.398138,
+		0.350000, 0.399955,
+		0.351000, 0.401772,
+		0.352000, 0.403590,
+		0.353000, 0.405408,
+		0.354000, 0.407226,
+		0.355000, 0.409045,
+		0.356000, 0.410864,
+		0.357000, 0.412682,
+		0.358000, 0.414501,
+		0.359000, 0.416321,
+		0.360000, 0.418140,
+		0.361000, 0.419959,
+		0.362000, 0.421778,
+		0.363000, 0.423597,
+		0.364000, 0.425417,
+		0.365000, 0.427236,
+		0.366000, 0.429055,
+		0.367000, 0.430873,
+		0.368000, 0.432692,
+		0.369000, 0.434510,
+		0.370000, 0.436328,
+		0.371000, 0.438146,
+		0.372000, 0.439963,
+		0.373000, 0.441781,
+		0.374000, 0.443597,
+		0.375000, 0.445413,
+		0.376000, 0.447229,
+		0.377000, 0.449045,
+		0.378000, 0.450859,
+		0.379000, 0.452674,
+		0.380000, 0.454487,
+		0.381000, 0.456301,
+		0.382000, 0.458113,
+		0.383000, 0.459925,
+		0.384000, 0.461736,
+		0.385000, 0.463546,
+		0.386000, 0.465356,
+		0.387000, 0.467164,
+		0.388000, 0.468972,
+		0.389000, 0.470779,
+		0.390000, 0.472585,
+		0.391000, 0.474391,
+		0.392000, 0.476195,
+		0.393000, 0.477998,
+		0.394000, 0.479800,
+		0.395000, 0.481601,
+		0.396000, 0.483402,
+		0.397000, 0.485200,
+		0.398000, 0.486998,
+		0.399000, 0.488795,
+		0.400000, 0.490590,
+		0.401000, 0.492384,
+		0.402000, 0.494177,
+		0.403000, 0.495969,
+		0.404000, 0.497759,
+		0.405000, 0.499548,
+		0.406000, 0.501336,
+		0.407000, 0.503122,
+		0.408000, 0.504906,
+		0.409000, 0.506689,
+		0.410000, 0.508471,
+		0.411000, 0.510251,
+		0.412000, 0.512029,
+		0.413000, 0.513806,
+		0.414000, 0.515581,
+		0.415000, 0.517355,
+		0.416000, 0.519127,
+		0.417000, 0.520897,
+		0.418000, 0.522665,
+		0.419000, 0.524432,
+		0.420000, 0.526196,
+		0.421000, 0.527959,
+		0.422000, 0.529720,
+		0.423000, 0.531479,
+		0.424000, 0.533236,
+		0.425000, 0.534991,
+		0.426000, 0.536745,
+		0.427000, 0.538496,
+		0.428000, 0.540245,
+		0.429000, 0.541992,
+		0.430000, 0.543736,
+		0.431000, 0.545479,
+		0.432000, 0.547220,
+		0.433000, 0.548958,
+		0.434000, 0.550694,
+		0.435000, 0.552428,
+		0.436000, 0.554159,
+		0.437000, 0.555888,
+		0.438000, 0.557615,
+		0.439000, 0.559340,
+		0.440000, 0.561062,
+		0.441000, 0.562781,
+		0.442000, 0.564498,
+		0.443000, 0.566213,
+		0.444000, 0.567925,
+		0.445000, 0.569634,
+		0.446000, 0.571341,
+		0.447000, 0.573046,
+		0.448000, 0.574747,
+		0.449000, 0.576446,
+		0.450000, 0.578143,
+		0.451000, 0.579836,
+		0.452000, 0.581527,
+		0.453000, 0.583215,
+		0.454000, 0.584901,
+		0.455000, 0.586583,
+		0.456000, 0.588263,
+		0.457000, 0.589939,
+		0.458000, 0.591613,
+		0.459000, 0.593284,
+		0.460000, 0.594952,
+		0.461000, 0.596617,
+		0.462000, 0.598279,
+		0.463000, 0.599937,
+		0.464000, 0.601593,
+		0.465000, 0.603246,
+		0.466000, 0.604895,
+		0.467000, 0.606542,
+		0.468000, 0.608185,
+		0.469000, 0.609825,
+		0.470000, 0.611461,
+		0.471000, 0.613095,
+		0.472000, 0.614725,
+		0.473000, 0.616352,
+		0.474000, 0.617975,
+		0.475000, 0.619595,
+		0.476000, 0.621212,
+		0.477000, 0.622825,
+		0.478000, 0.624435,
+		0.479000, 0.626042,
+		0.480000, 0.627645,
+		0.481000, 0.629244,
+		0.482000, 0.630840,
+		0.483000, 0.632432,
+		0.484000, 0.634021,
+		0.485000, 0.635606,
+		0.486000, 0.637187,
+		0.487000, 0.638765,
+		0.488000, 0.640339,
+		0.489000, 0.641909,
+		0.490000, 0.643476,
+		0.491000, 0.645039,
+		0.492000, 0.646598,
+		0.493000, 0.648153,
+		0.494000, 0.649704,
+		0.495000, 0.651252,
+		0.496000, 0.652795,
+		0.497000, 0.654335,
+		0.498000, 0.655870,
+		0.499000, 0.657402,
+		0.500000, 0.658930,
+		0.501000, 0.660454,
+		0.502000, 0.661973,
+		0.503000, 0.663489,
+		0.504000, 0.665001,
+		0.505000, 0.666508,
+		0.506000, 0.668011,
+		0.507000, 0.669511,
+		0.508000, 0.671006,
+		0.509000, 0.672496,
+		0.510000, 0.673983,
+		0.511000, 0.675465,
+		0.512000, 0.676943,
+		0.513000, 0.678417,
+		0.514000, 0.679886,
+		0.515000, 0.681352,
+		0.516000, 0.682812,
+		0.517000, 0.684269,
+		0.518000, 0.685721,
+		0.519000, 0.687168,
+		0.520000, 0.688611,
+		0.521000, 0.690050,
+		0.522000, 0.691484,
+		0.523000, 0.692914,
+		0.524000, 0.694339,
+		0.525000, 0.695759,
+		0.526000, 0.697175,
+		0.527000, 0.698587,
+		0.528000, 0.699994,
+		0.529000, 0.701396,
+		0.530000, 0.702793,
+		0.531000, 0.704186,
+		0.532000, 0.705574,
+		0.533000, 0.706957,
+		0.534000, 0.708336,
+		0.535000, 0.709710,
+		0.536000, 0.711079,
+		0.537000, 0.712443,
+		0.538000, 0.713803,
+		0.539000, 0.715157,
+		0.540000, 0.716507,
+		0.541000, 0.717852,
+		0.542000, 0.719192,
+		0.543000, 0.720527,
+		0.544000, 0.721857,
+		0.545000, 0.723182,
+		0.546000, 0.724502,
+		0.547000, 0.725817,
+		0.548000, 0.727127,
+		0.549000, 0.728432,
+		0.550000, 0.729732,
+		0.551000, 0.731027,
+		0.552000, 0.732317,
+		0.553000, 0.733602,
+		0.554000, 0.734881,
+		0.555000, 0.736155,
+		0.556000, 0.737425,
+		0.557000, 0.738689,
+		0.558000, 0.739948,
+		0.559000, 0.741201,
+		0.560000, 0.742449,
+		0.561000, 0.743693,
+		0.562000, 0.744930,
+		0.563000, 0.746163,
+		0.564000, 0.747390,
+		0.565000, 0.748612,
+		0.566000, 0.749828,
+		0.567000, 0.751039,
+		0.568000, 0.752245,
+		0.569000, 0.753446,
+		0.570000, 0.754640,
+		0.571000, 0.755830,
+		0.572000, 0.757014,
+		0.573000, 0.758192,
+		0.574000, 0.759365,
+		0.575000, 0.760533,
+		0.576000, 0.761695,
+		0.577000, 0.762851,
+		0.578000, 0.764002,
+		0.579000, 0.765148,
+		0.580000, 0.766287,
+		0.581000, 0.767422,
+		0.582000, 0.768550,
+		0.583000, 0.769673,
+		0.584000, 0.770790,
+		0.585000, 0.771902,
+		0.586000, 0.773008,
+		0.587000, 0.774108,
+		0.588000, 0.775202,
+		0.589000, 0.776291,
+		0.590000, 0.777374,
+		0.591000, 0.778451,
+		0.592000, 0.779522,
+		0.593000, 0.780588,
+		0.594000, 0.781648,
+		0.595000, 0.782702,
+		0.596000, 0.783750,
+		0.597000, 0.784792,
+		0.598000, 0.785829,
+		0.599000, 0.786860,
+		0.600000, 0.787884,
+		0.601000, 0.788903,
+		0.602000, 0.789916,
+		0.603000, 0.790923,
+		0.604000, 0.791924,
+		0.605000, 0.792919,
+		0.606000, 0.793908,
+		0.607000, 0.794891,
+		0.608000, 0.795868,
+		0.609000, 0.796839,
+		0.610000, 0.797804,
+		0.611000, 0.798763,
+		0.612000, 0.799716,
+		0.613000, 0.800663,
+		0.614000, 0.801603,
+		0.615000, 0.802538,
+		0.616000, 0.803466,
+		0.617000, 0.804389,
+		0.618000, 0.805305,
+		0.619000, 0.806215,
+		0.620000, 0.807119,
+		0.621000, 0.808017,
+		0.622000, 0.808909,
+		0.623000, 0.809794,
+		0.624000, 0.810673,
+		0.625000, 0.811546,
+		0.626000, 0.812413,
+		0.627000, 0.813274,
+		0.628000, 0.814128,
+		0.629000, 0.814976,
+		0.630000, 0.815817,
+		0.631000, 0.816653,
+		0.632000, 0.817482,
+		0.633000, 0.818305,
+		0.634000, 0.819121,
+		0.635000, 0.819931,
+		0.636000, 0.820735,
+		0.637000, 0.821533,
+		0.638000, 0.822324,
+		0.639000, 0.823109,
+		0.640000, 0.823887,
+		0.641000, 0.824659,
+		0.642000, 0.825424,
+		0.643000, 0.826183,
+		0.644000, 0.826936,
+		0.645000, 0.827682,
+		0.646000, 0.828422,
+		0.647000, 0.829156,
+		0.648000, 0.829882,
+		0.649000, 0.830603,
+		0.650000, 0.831317,
+		0.651000, 0.832024,
+		0.652000, 0.832725,
+		0.653000, 0.833419,
+		0.654000, 0.834107,
+		0.655000, 0.834789,
+		0.656000, 0.835463,
+		0.657000, 0.836132,
+		0.658000, 0.836793,
+		0.659000, 0.837448,
+		0.660000, 0.838097,
+		0.661000, 0.838739,
+		0.662000, 0.839374,
+		0.663000, 0.840003,
+		0.664000, 0.840625,
+		0.665000, 0.841241,
+		0.666000, 0.841850,
+		0.667000, 0.842452,
+		0.668000, 0.843048,
+		0.669000, 0.843637,
+		0.670000, 0.844219,
+		0.671000, 0.844795,
+		0.672000, 0.845364,
+		0.673000, 0.845926,
+		0.674000, 0.846481,
+		0.675000, 0.847030,
+		0.676000, 0.847573,
+		0.677000, 0.848108,
+		0.678000, 0.848637,
+		0.679000, 0.849159,
+		0.680000, 0.849674,
+		0.681000, 0.850183,
+		0.682000, 0.850685,
+		0.683000, 0.851180,
+		0.684000, 0.851668,
+		0.685000, 0.852150,
+		0.686000, 0.852625,
+		0.687000, 0.853093,
+		0.688000, 0.853554,
+		0.689000, 0.854009,
+		0.690000, 0.854456,
+		0.691000, 0.854897,
+		0.692000, 0.855331,
+		0.693000, 0.855759,
+		0.694000, 0.856179,
+		0.695000, 0.856593,
+		0.696000, 0.857000,
+		0.697000, 0.857400,
+		0.698000, 0.857793,
+		0.699000, 0.858179,
+		0.700000, 0.858559,
+		0.701000, 0.858931,
+		0.702000, 0.859297,
+		0.703000, 0.859656,
+		0.704000, 0.860008,
+		0.705000, 0.860353,
+		0.706000, 0.860691,
+		0.707000, 0.861023,
+		0.708000, 0.861347,
+		0.709000, 0.861665,
+		0.710000, 0.861976,
+		0.711000, 0.862280,
+		0.712000, 0.862577,
+		0.713000, 0.862867,
+		0.714000, 0.863150,
+		0.715000, 0.863426,
+		0.716000, 0.863696,
+		0.717000, 0.863958,
+		0.718000, 0.864214,
+		0.719000, 0.864462,
+		0.720000, 0.864704,
+		0.721000, 0.864939,
+		0.722000, 0.865166,
+		0.723000, 0.865387,
+		0.724000, 0.865601,
+		0.725000, 0.865808,
+		0.726000, 0.866008,
+		0.727000, 0.866201,
+		0.728000, 0.866388,
+		0.729000, 0.866567,
+		0.730000, 0.866739,
+		0.731000, 0.866904,
+		0.732000, 0.867063,
+		0.733000, 0.867214,
+		0.734000, 0.867358,
+		0.735000, 0.867496,
+		0.736000, 0.867626,
+		0.737000, 0.867750,
+		0.738000, 0.867867,
+		0.739000, 0.867976,
+		0.740000, 0.868079,
+		0.741000, 0.868174,
+		0.742000, 0.868263,
+		0.743000, 0.868345,
+		0.744000, 0.868420,
+		0.745000, 0.868487,
+		0.746000, 0.868548,
+		0.747000, 0.868602,
+		0.748000, 0.868649,
+		0.749000, 0.868689,
+		0.750000, 0.868721,
+		0.751000, 0.868747,
+		0.752000, 0.868766,
+		0.753000, 0.868778,
+		0.754000, 0.868783,
+		0.755000, 0.868781,
+		0.756000, 0.868772,
+		0.757000, 0.868756,
+		0.758000, 0.868733,
+		0.759000, 0.868703,
+		0.760000, 0.868666,
+		0.761000, 0.868622,
+		0.762000, 0.868571,
+		0.763000, 0.868513,
+		0.764000, 0.868449,
+		0.765000, 0.868377,
+		0.766000, 0.868298,
+		0.767000, 0.868212,
+		0.768000, 0.868119,
+		0.769000, 0.868020,
+		0.770000, 0.867913,
+		0.771000, 0.867799,
+		0.772000, 0.867679,
+		0.773000, 0.867551,
+		0.774000, 0.867416,
+		0.775000, 0.867275,
+		0.776000, 0.867126,
+		0.777000, 0.866971,
+		0.778000, 0.866809,
+		0.779000, 0.866639,
+		0.780000, 0.866463,
+		0.781000, 0.866280,
+		0.782000, 0.866089,
+		0.783000, 0.865892,
+		0.784000, 0.865688,
+		0.785000, 0.865477,
+		0.786000, 0.865259,
+		0.787000, 0.865034,
+		0.788000, 0.864802,
+		0.789000, 0.864564,
+		0.790000, 0.864318,
+		0.791000, 0.864065,
+		0.792000, 0.863806,
+		0.793000, 0.863539,
+		0.794000, 0.863266,
+		0.795000, 0.862985,
+		0.796000, 0.862698,
+		0.797000, 0.862404,
+		0.798000, 0.862103,
+		0.799000, 0.861795,
+		0.800000, 0.861480,
+		0.801000, 0.861159,
+		0.802000, 0.860830,
+		0.803000, 0.860495,
+		0.804000, 0.860152,
+		0.805000, 0.859803,
+		0.806000, 0.859447,
+		0.807000, 0.859084,
+		0.808000, 0.858714,
+		0.809000, 0.858338,
+		0.810000, 0.857954,
+		0.811000, 0.857564,
+		0.812000, 0.857167,
+		0.813000, 0.856763,
+		0.814000, 0.856352,
+		0.815000, 0.855934,
+		0.816000, 0.855510,
+		0.817000, 0.855079,
+		0.818000, 0.854641,
+		0.819000, 0.854196,
+		0.820000, 0.853744,
+		0.821000, 0.853286,
+		0.822000, 0.852820,
+		0.823000, 0.852348,
+		0.824000, 0.851869,
+		0.825000, 0.851384,
+		0.826000, 0.850892,
+		0.827000, 0.850393,
+		0.828000, 0.849887,
+		0.829000, 0.849374,
+		0.830000, 0.848855,
+		0.831000, 0.848329,
+		0.832000, 0.847796,
+		0.833000, 0.847257,
+		0.834000, 0.846711,
+		0.835000, 0.846158,
+		0.836000, 0.845598,
+		0.837000, 0.845032,
+		0.838000, 0.844459,
+		0.839000, 0.843880,
+		0.840000, 0.843293,
+		0.841000, 0.842700,
+		0.842000, 0.842101,
+		0.843000, 0.841495,
+		0.844000, 0.840882,
+		0.845000, 0.840263,
+		0.846000, 0.839637,
+		0.847000, 0.839004,
+		0.848000, 0.838365,
+		0.849000, 0.837719,
+		0.850000, 0.837067,
+		0.851000, 0.836408,
+		0.852000, 0.835742,
+		0.853000, 0.835070,
+		0.854000, 0.834391,
+		0.855000, 0.833706,
+		0.856000, 0.833015,
+		0.857000, 0.832316,
+		0.858000, 0.831612,
+		0.859000, 0.830900,
+		0.860000, 0.830183,
+		0.861000, 0.829459,
+		0.862000, 0.828728,
+		0.863000, 0.827991,
+		0.864000, 0.827247,
+		0.865000, 0.826497,
+		0.866000, 0.825741,
+		0.867000, 0.824978,
+		0.868000, 0.824209,
+		0.869000, 0.823433,
+		0.870000, 0.822651,
+		0.871000, 0.821863,
+		0.872000, 0.821068,
+		0.873000, 0.820267,
+		0.874000, 0.819459,
+		0.875000, 0.818645,
+		0.876000, 0.817825,
+		0.877000, 0.816998,
+		0.878000, 0.816166,
+		0.879000, 0.815327,
+		0.880000, 0.814481,
+		0.881000, 0.813630,
+		0.882000, 0.812772,
+		0.883000, 0.811907,
+		0.884000, 0.811037,
+		0.885000, 0.810160,
+		0.886000, 0.809278,
+		0.887000, 0.808389,
+		0.888000, 0.807493,
+		0.889000, 0.806592,
+		0.890000, 0.805684,
+		0.891000, 0.804771,
+		0.892000, 0.803851,
+		0.893000, 0.802925,
+		0.894000, 0.801993,
+		0.895000, 0.801055,
+		0.896000, 0.800110,
+		0.897000, 0.799160,
+		0.898000, 0.798203,
+		0.899000, 0.797241,
+		0.900000, 0.796272,
+		0.901000, 0.795298,
+		0.902000, 0.794317,
+		0.903000, 0.793331,
+		0.904000, 0.792338,
+		0.905000, 0.791340,
+		0.906000, 0.790335,
+		0.907000, 0.789325,
+		0.908000, 0.788309,
+		0.909000, 0.787286,
+		0.910000, 0.786258,
+		0.911000, 0.785224,
+		0.912000, 0.784184,
+		0.913000, 0.783139,
+		0.914000, 0.782087,
+		0.915000, 0.781030,
+		0.916000, 0.779966,
+		0.917000, 0.778897,
+		0.918000, 0.777823,
+		0.919000, 0.776742,
+		0.920000, 0.775656,
+		0.921000, 0.774564,
+		0.922000, 0.773466,
+		0.923000, 0.772362,
+		0.924000, 0.771253,
+		0.925000, 0.770138,
+		0.926000, 0.769018,
+		0.927000, 0.767891,
+		0.928000, 0.766760,
+		0.929000, 0.765622,
+		0.930000, 0.764479,
+		0.931000, 0.763331,
+		0.932000, 0.762177,
+		0.933000, 0.761017,
+		0.934000, 0.759852,
+		0.935000, 0.758681,
+		0.936000, 0.757505,
+		0.937000, 0.756323,
+		0.938000, 0.755136,
+		0.939000, 0.753943,
+		0.940000, 0.752745,
+		0.941000, 0.751542,
+		0.942000, 0.750333,
+		0.943000, 0.749118,
+		0.944000, 0.747899,
+		0.945000, 0.746674,
+		0.946000, 0.745444,
+		0.947000, 0.744208,
+		0.948000, 0.742967,
+		0.949000, 0.741721,
+		0.950000, 0.740470,
+		0.951000, 0.739213,
+		0.952000, 0.737951,
+		0.953000, 0.736684,
+		0.954000, 0.735412,
+		0.955000, 0.734134,
+		0.956000, 0.732852,
+		0.957000, 0.731564,
+		0.958000, 0.730271,
+		0.959000, 0.728973,
+		0.960000, 0.727670,
+		0.961000, 0.726362,
+		0.962000, 0.725049,
+		0.963000, 0.723731,
+		0.964000, 0.722408,
+		0.965000, 0.721080,
+		0.966000, 0.719747,
+		0.967000, 0.718410,
+		0.968000, 0.717067,
+		0.969000, 0.715719,
+		0.970000, 0.714366,
+		0.971000, 0.713009,
+		0.972000, 0.711647,
+		0.973000, 0.710280,
+		0.974000, 0.708908,
+		0.975000, 0.707531,
+		0.976000, 0.706150,
+		0.977000, 0.704764,
+		0.978000, 0.703373,
+		0.979000, 0.701977,
+		0.980000, 0.700577,
+		0.981000, 0.699172,
+		0.982000, 0.697763,
+		0.983000, 0.696349,
+		0.984000, 0.694930,
+		0.985000, 0.693507,
+		0.986000, 0.692079,
+		0.987000, 0.690647,
+		0.988000, 0.689210,
+		0.989000, 0.687769,
+		0.990000, 0.686323,
+		0.991000, 0.684873,
+		0.992000, 0.683419,
+		0.993000, 0.681960,
+		0.994000, 0.680496,
+		0.995000, 0.679029,
+		0.996000, 0.677557,
+		0.997000, 0.676080,
+		0.998000, 0.674600,
+		0.999000, 0.673115,
+		1.000000, 0.671626,
+		1.001000, 0.670133,
+		1.002000, 0.668635,
+		1.003000, 0.667134,
+		1.004000, 0.665628,
+		1.005000, 0.664118,
+		1.006000, 0.662604,
+		1.007000, 0.661086,
+		1.008000, 0.659564,
+		1.009000, 0.658038,
+		1.010000, 0.656508,
+		1.011000, 0.654974,
+		1.012000, 0.653436,
+		1.013000, 0.651894,
+		1.014000, 0.650348,
+		1.015000, 0.648798,
+		1.016000, 0.647245,
+		1.017000, 0.645687,
+		1.018000, 0.644126,
+		1.019000, 0.642561,
+		1.020000, 0.640992,
+		1.021000, 0.639420,
+		1.022000, 0.637844,
+		1.023000, 0.636264,
+		1.024000, 0.634680,
+		1.025000, 0.633093,
+		1.026000, 0.631502,
+		1.027000, 0.629908,
+		1.028000, 0.628310,
+		1.029000, 0.626709,
+		1.030000, 0.625104,
+		1.031000, 0.623495,
+		1.032000, 0.621883,
+		1.033000, 0.620268,
+		1.034000, 0.618649,
+		1.035000, 0.617027,
+		1.036000, 0.615402,
+		1.037000, 0.613773,
+		1.038000, 0.612141,
+		1.039000, 0.610506,
+		1.040000, 0.608867,
+		1.041000, 0.607225,
+		1.042000, 0.605580,
+		1.043000, 0.603932,
+		1.044000, 0.602281,
+		1.045000, 0.600626,
+		1.046000, 0.598969,
+		1.047000, 0.597308,
+		1.048000, 0.595645,
+		1.049000, 0.593978,
+		1.050000, 0.592308,
+		1.051000, 0.590636,
+		1.052000, 0.588960,
+		1.053000, 0.587282,
+		1.054000, 0.585601,
+		1.055000, 0.583916,
+		1.056000, 0.582230,
+		1.057000, 0.580540,
+		1.058000, 0.578847,
+		1.059000, 0.577152,
+		1.060000, 0.575454,
+		1.061000, 0.573754,
+		1.062000, 0.572050,
+		1.063000, 0.570345,
+		1.064000, 0.568636,
+		1.065000, 0.566925,
+		1.066000, 0.565212,
+		1.067000, 0.563495,
+		1.068000, 0.561777,
+		1.069000, 0.560056,
+		1.070000, 0.558332,
+		1.071000, 0.556607,
+		1.072000, 0.554878,
+		1.073000, 0.553148,
+		1.074000, 0.551415,
+		1.075000, 0.549680,
+		1.076000, 0.547943,
+		1.077000, 0.546203,
+		1.078000, 0.544461,
+		1.079000, 0.542717,
+		1.080000, 0.540971,
+		1.081000, 0.539223,
+		1.082000, 0.537473,
+		1.083000, 0.535721,
+		1.084000, 0.533966,
+		1.085000, 0.532210,
+		1.086000, 0.530452,
+		1.087000, 0.528692,
+		1.088000, 0.526930,
+		1.089000, 0.525166,
+		1.090000, 0.523400,
+		1.091000, 0.521632,
+		1.092000, 0.519863,
+		1.093000, 0.518092,
+		1.094000, 0.516319,
+		1.095000, 0.514545,
+		1.096000, 0.512768,
+		1.097000, 0.510991,
+		1.098000, 0.509211,
+		1.099000, 0.507430,
+		1.100000, 0.505648,
+		1.101000, 0.503864,
+		1.102000, 0.502078,
+		1.103000, 0.500292,
+		1.104000, 0.498503,
+		1.105000, 0.496714,
+		1.106000, 0.494923,
+		1.107000, 0.493130,
+		1.108000, 0.491337,
+		1.109000, 0.489542,
+		1.110000, 0.487746,
+		1.111000, 0.485948,
+		1.112000, 0.484150,
+		1.113000, 0.482350,
+		1.114000, 0.480549,
+		1.115000, 0.478748,
+		1.116000, 0.476945,
+		1.117000, 0.475141,
+		1.118000, 0.473336,
+		1.119000, 0.471530,
+		1.120000, 0.469724,
+		1.121000, 0.467916,
+		1.122000, 0.466108,
+		1.123000, 0.464299,
+		1.124000, 0.462489,
+		1.125000, 0.460678,
+		1.126000, 0.458866,
+		1.127000, 0.457054,
+		1.128000, 0.455242,
+		1.129000, 0.453428,
+		1.130000, 0.451614,
+		1.131000, 0.449799,
+		1.132000, 0.447984,
+		1.133000, 0.446169,
+		1.134000, 0.444353,
+		1.135000, 0.442536,
+		1.136000, 0.440719,
+		1.137000, 0.438902,
+		1.138000, 0.437084,
+		1.139000, 0.435266,
+		1.140000, 0.433448,
+		1.141000, 0.431630,
+		1.142000, 0.429811,
+		1.143000, 0.427992,
+		1.144000, 0.426173,
+		1.145000, 0.424354,
+		1.146000, 0.422535,
+		1.147000, 0.420716,
+		1.148000, 0.418896,
+		1.149000, 0.417077,
+		1.150000, 0.415258,
+		1.151000, 0.413439,
+		1.152000, 0.411620,
+		1.153000, 0.409801,
+		1.154000, 0.407983,
+		1.155000, 0.406164,
+		1.156000, 0.404346,
+		1.157000, 0.402528,
+		1.158000, 0.400710,
+		1.159000, 0.398893,
+		1.160000, 0.397076,
+		1.161000, 0.395260,
+		1.162000, 0.393444,
+		1.163000, 0.391629,
+		1.164000, 0.389814,
+		1.165000, 0.387999,
+		1.166000, 0.386185,
+		1.167000, 0.384372,
+		1.168000, 0.382559,
+		1.169000, 0.380747,
+		1.170000, 0.378936,
+		1.171000, 0.377126,
+		1.172000, 0.375316,
+		1.173000, 0.373507,
+		1.174000, 0.371699,
+		1.175000, 0.369892,
+		1.176000, 0.368085,
+		1.177000, 0.366280,
+		1.178000, 0.364476,
+		1.179000, 0.362672,
+		1.180000, 0.360870,
+		1.181000, 0.359069,
+		1.182000, 0.357269,
+		1.183000, 0.355470,
+		1.184000, 0.353672,
+		1.185000, 0.351875,
+		1.186000, 0.350080,
+		1.187000, 0.348286,
+		1.188000, 0.346493,
+		1.189000, 0.344701,
+		1.190000, 0.342911,
+		1.191000, 0.341123,
+		1.192000, 0.339335,
+		1.193000, 0.337549,
+		1.194000, 0.335765,
+		1.195000, 0.333982,
+		1.196000, 0.332201,
+		1.197000, 0.330422,
+		1.198000, 0.328644,
+		1.199000, 0.326867,
+		1.200000, 0.325093,
+		1.201000, 0.323320,
+		1.202000, 0.321549,
+		1.203000, 0.319779,
+		1.204000, 0.318012,
+		1.205000, 0.316246,
+		1.206000, 0.314483,
+		1.207000, 0.312721,
+		1.208000, 0.310961,
+		1.209000, 0.309203,
+		1.210000, 0.307448,
+		1.211000, 0.305694,
+		1.212000, 0.303942,
+		1.213000, 0.302193,
+		1.214000, 0.300445,
+		1.215000, 0.298700,
+		1.216000, 0.296957,
+		1.217000, 0.295217,
+		1.218000, 0.293478,
+		1.219000, 0.291742,
+		1.220000, 0.290009,
+		1.221000, 0.288277,
+		1.222000, 0.286548,
+		1.223000, 0.284822,
+		1.224000, 0.283098,
+		1.225000, 0.281377,
+		1.226000, 0.279658,
+		1.227000, 0.277942,
+		1.228000, 0.276228,
+		1.229000, 0.274517,
+		1.230000, 0.272809,
+		1.231000, 0.271103,
+		1.232000, 0.269400,
+		1.233000, 0.267700,
+		1.234000, 0.266003,
+		1.235000, 0.264308,
+		1.236000, 0.262617,
+		1.237000, 0.260928,
+		1.238000, 0.259242,
+		1.239000, 0.257560,
+		1.240000, 0.255880,
+		1.241000, 0.254203,
+		1.242000, 0.252530,
+		1.243000, 0.250859,
+		1.244000, 0.249192,
+		1.245000, 0.247527,
+		1.246000, 0.245866,
+		1.247000, 0.244208,
+		1.248000, 0.242554,
+		1.249000, 0.240903,
+		1.250000, 0.239255,
+		1.251000, 0.237610,
+		1.252000, 0.235969,
+		1.253000, 0.234331,
+		1.254000, 0.232696,
+		1.255000, 0.231066,
+		1.256000, 0.229438,
+		1.257000, 0.227814,
+		1.258000, 0.226194,
+		1.259000, 0.224577,
+		1.260000, 0.222964,
+		1.261000, 0.221355,
+		1.262000, 0.219749,
+		1.263000, 0.218147,
+		1.264000, 0.216549,
+		1.265000, 0.214954,
+		1.266000, 0.213364,
+		1.267000, 0.211777,
+		1.268000, 0.210194,
+		1.269000, 0.208615,
+		1.270000, 0.207040,
+		1.271000, 0.205469,
+		1.272000, 0.203902,
+		1.273000, 0.202339,
+		1.274000, 0.200780,
+		1.275000, 0.199225,
+		1.276000, 0.197674,
+		1.277000, 0.196127,
+		1.278000, 0.194585,
+		1.279000, 0.193047,
+		1.280000, 0.191512,
+		1.281000, 0.189983,
+		1.282000, 0.188457,
+		1.283000, 0.186936,
+		1.284000, 0.185419,
+		1.285000, 0.183907,
+		1.286000, 0.182399,
+		1.287000, 0.180895,
+		1.288000, 0.179396,
+		1.289000, 0.177901,
+		1.290000, 0.176411,
+		1.291000, 0.174926,
+		1.292000, 0.173445,
+		1.293000, 0.171969,
+		1.294000, 0.170497,
+		1.295000, 0.169030,
+		1.296000, 0.167568,
+		1.297000, 0.166110,
+		1.298000, 0.164657,
+		1.299000, 0.163209,
+		1.300000, 0.161766,
+		1.301000, 0.160328,
+		1.302000, 0.158894,
+		1.303000, 0.157465,
+		1.304000, 0.156042,
+		1.305000, 0.154623,
+		1.306000, 0.153209,
+		1.307000, 0.151800,
+		1.308000, 0.150397,
+		1.309000, 0.148998,
+		1.310000, 0.147604,
+		1.311000, 0.146216,
+		1.312000, 0.144833,
+		1.313000, 0.143454,
+		1.314000, 0.142081,
+		1.315000, 0.140714,
+		1.316000, 0.139351,
+		1.317000, 0.137994,
+		1.318000, 0.136642,
+		1.319000, 0.135295,
+		1.320000, 0.133954,
+		1.321000, 0.132618,
+		1.322000, 0.131288,
+		1.323000, 0.129963,
+		1.324000, 0.128643,
+		1.325000, 0.127329,
+		1.326000, 0.126021,
+		1.327000, 0.124718,
+		1.328000, 0.123420,
+		1.329000, 0.122128,
+		1.330000, 0.120842,
+		1.331000, 0.119561,
+		1.332000, 0.118286,
+		1.333000, 0.117017,
+		1.334000, 0.115753,
+		1.335000, 0.114495,
+		1.336000, 0.113243,
+		1.337000, 0.111997,
+		1.338000, 0.110757,
+		1.339000, 0.109522,
+		1.340000, 0.108293,
+		1.341000, 0.107070,
+		1.342000, 0.105853,
+		1.343000, 0.104642,
+		1.344000, 0.103437,
+		1.345000, 0.102237,
+		1.346000, 0.101044,
+		1.347000, 0.099857,
+		1.348000, 0.098676,
+		1.349000, 0.097501,
+		1.350000, 0.096332,
+		1.351000, 0.095169,
+		1.352000, 0.094012,
+		1.353000, 0.092862,
+		1.354000, 0.091717,
+		1.355000, 0.090579,
+		1.356000, 0.089447,
+		1.357000, 0.088322,
+		1.358000, 0.087202,
+		1.359000, 0.086089,
+		1.360000, 0.084982,
+		1.361000, 0.083882,
+		1.362000, 0.082787,
+		1.363000, 0.081700,
+		1.364000, 0.080618,
+		1.365000, 0.079543,
+		1.366000, 0.078475,
+		1.367000, 0.077413,
+		1.368000, 0.076357,
+		1.369000, 0.075308,
+		1.370000, 0.074266,
+		1.371000, 0.073230,
+		1.372000, 0.072200,
+		1.373000, 0.071177,
+		1.374000, 0.070161,
+		1.375000, 0.069151,
+		1.376000, 0.068148,
+		1.377000, 0.067152,
+		1.378000, 0.066163,
+		1.379000, 0.065180,
+		1.380000, 0.064203,
+		1.381000, 0.063234,
+		1.382000, 0.062271,
+		1.383000, 0.061315,
+		1.384000, 0.060366,
+		1.385000, 0.059424,
+		1.386000, 0.058488,
+		1.387000, 0.057560,
+		1.388000, 0.056638,
+		1.389000, 0.055723,
+		1.390000, 0.054815,
+		1.391000, 0.053914,
+		1.392000, 0.053020,
+		1.393000, 0.052133,
+		1.394000, 0.051253,
+		1.395000, 0.050380,
+		1.396000, 0.049514,
+		1.397000, 0.048654,
+		1.398000, 0.047802,
+		1.399000, 0.046957,
+		1.400000, 0.046119,
+		1.401000, 0.045289,
+		1.402000, 0.044465,
+		1.403000, 0.043648,
+		1.404000, 0.042839,
+		1.405000, 0.042037,
+		1.406000, 0.041242,
+		1.407000, 0.040454,
+		1.408000, 0.039673,
+		1.409000, 0.038899,
+		1.410000, 0.038133,
+		1.411000, 0.037374,
+		1.412000, 0.036622,
+		1.413000, 0.035878,
+		1.414000, 0.035141,
+		1.415000, 0.034411,
+		1.416000, 0.033688,
+		1.417000, 0.032973,
+		1.418000, 0.032265,
+		1.419000, 0.031565,
+		1.420000, 0.030872,
+		1.421000, 0.030186,
+		1.422000, 0.029508,
+		1.423000, 0.028837,
+		1.424000, 0.028174,
+		1.425000, 0.027518,
+		1.426000, 0.026869,
+		1.427000, 0.026228,
+		1.428000, 0.025595,
+		1.429000, 0.024968,
+		1.430000, 0.024350,
+		1.431000, 0.023739,
+		1.432000, 0.023135,
+		1.433000, 0.022539,
+		1.434000, 0.021951,
+		1.435000, 0.021370,
+		1.436000, 0.020797,
+		1.437000, 0.020231,
+		1.438000, 0.019673,
+		1.439000, 0.019123,
+		1.440000, 0.018580,
+		1.441000, 0.018045,
+		1.442000, 0.017517,
+		1.443000, 0.016998,
+		1.444000, 0.016485,
+		1.445000, 0.015981,
+		1.446000, 0.015484,
+		1.447000, 0.014995,
+		1.448000, 0.014513,
+		1.449000, 0.014040,
+		1.450000, 0.013574,
+		1.451000, 0.013115,
+		1.452000, 0.012665,
+		1.453000, 0.012222,
+		1.454000, 0.011787,
+		1.455000, 0.011360,
+		1.456000, 0.010940,
+		1.457000, 0.010529,
+		1.458000, 0.010125,
+		1.459000, 0.009729,
+		1.460000, 0.009341,
+		1.461000, 0.008960,
+		1.462000, 0.008587,
+		1.463000, 0.008223,
+		1.464000, 0.007866,
+		1.465000, 0.007517,
+		1.466000, 0.007175,
+		1.467000, 0.006842,
+		1.468000, 0.006516,
+		1.469000, 0.006199,
+		1.470000, 0.005889,
+		1.471000, 0.005587,
+		1.472000, 0.005293,
+		1.473000, 0.005007,
+		1.474000, 0.004729,
+		1.475000, 0.004458,
+		1.476000, 0.004196,
+		1.477000, 0.003942,
+		1.478000, 0.003695,
+		1.479000, 0.003456,
+		1.480000, 0.003226,
+		1.481000, 0.003003,
+		1.482000, 0.002788,
+		1.483000, 0.002581,
+		1.484000, 0.002382,
+		1.485000, 0.002191,
+		1.486000, 0.002008,
+		1.487000, 0.001833,
+		1.488000, 0.001666,
+		1.489000, 0.001507,
+		1.490000, 0.001356,
+		1.491000, 0.001213,
+		1.492000, 0.001077,
+		1.493000, 0.000950,
+		1.494000, 0.000831,
+		1.495000, 0.000720,
+		1.496000, 0.000617,
+		1.497000, 0.000521,
+		1.498000, 0.000434,
+		1.499000, 0.000355,
+		1.500000, 0.000283,
+		1.501000, 0.000220,
+		1.502000, 0.000165,
+		1.503000, 0.000117,
+		1.504000, 0.000078,
+		1.505000, 0.000047,
+		1.506000, 0.000023,
+		1.507000, 0.000008,
+		1.508000, 0.000001,
+		1.509000, 0.000001,
+		1.510000, 0.000010,
+		1.511000, 0.000027,
+		1.512000, 0.000051,
+		1.513000, 0.000084,
+		1.514000, 0.000125,
+		1.515000, 0.000173,
+		1.516000, 0.000230,
+		1.517000, 0.000295,
+		1.518000, 0.000367,
+		1.519000, 0.000448,
+		1.520000, 0.000537,
+		1.521000, 0.000633,
+		1.522000, 0.000738,
+		1.523000, 0.000851,
+		1.524000, 0.000971,
+		1.525000, 0.001100,
+		1.526000, 0.001236,
+		1.527000, 0.001381,
+		1.528000, 0.001533,
+		1.529000, 0.001694,
+		1.530000, 0.001862,
+		1.531000, 0.002039,
+		1.532000, 0.002223,
+		1.533000, 0.002415,
+		1.534000, 0.002615,
+		1.535000, 0.002824,
+		1.536000, 0.003040,
+		1.537000, 0.003264,
+		1.538000, 0.003496,
+		1.539000, 0.003736,
+		1.540000, 0.003984,
+		1.541000, 0.004240,
+		1.542000, 0.004503,
+		1.543000, 0.004775,
+		1.544000, 0.005054,
+		1.545000, 0.005342,
+		1.546000, 0.005637,
+		1.547000, 0.005941,
+		1.548000, 0.006252,
+		1.549000, 0.006571,
+		1.550000, 0.006897,
+		1.551000, 0.007232,
+		1.552000, 0.007575,
+		1.553000, 0.007925,
+		1.554000, 0.008283,
+		1.555000, 0.008650,
+		1.556000, 0.009024,
+		1.557000, 0.009405,
+		1.558000, 0.009795,
+		1.559000, 0.010192,
+		1.560000, 0.010598,
+		1.561000, 0.011010,
+		1.562000, 0.011431,
+		1.563000, 0.011860,
+		1.564000, 0.012296,
+		1.565000, 0.012740,
+		1.566000, 0.013192,
+		1.567000, 0.013652,
+		1.568000, 0.014119,
+		1.569000, 0.014594,
+		1.570000, 0.015077,
+		1.571000, 0.015567,
+		1.572000, 0.016065,
+		1.573000, 0.016571,
+		1.574000, 0.017085,
+		1.575000, 0.017606,
+		1.576000, 0.018134,
+		1.577000, 0.018671,
+		1.578000, 0.019215,
+		1.579000, 0.019767,
+		1.580000, 0.020326,
+		1.581000, 0.020893,
+		1.582000, 0.021467,
+		1.583000, 0.022050,
+		1.584000, 0.022639,
+		1.585000, 0.023236,
+		1.586000, 0.023841,
+		1.587000, 0.024454,
+		1.588000, 0.025073,
+		1.589000, 0.025701,
+		1.590000, 0.026335,
+		1.591000, 0.026978,
+		1.592000, 0.027628,
+		1.593000, 0.028285,
+		1.594000, 0.028949,
+		1.595000, 0.029622,
+		1.596000, 0.030301,
+		1.597000, 0.030988,
+		1.598000, 0.031682,
+		1.599000, 0.032384,
+		1.600000, 0.033093,
+		1.601000, 0.033810,
+		1.602000, 0.034533,
+		1.603000, 0.035264,
+		1.604000, 0.036003,
+		1.605000, 0.036748,
+		1.606000, 0.037501,
+		1.607000, 0.038262,
+		1.608000, 0.039029,
+		1.609000, 0.039804,
+		1.610000, 0.040586,
+		1.611000, 0.041375,
+		1.612000, 0.042171,
+		1.613000, 0.042975,
+		1.614000, 0.043785,
+		1.615000, 0.044603,
+		1.616000, 0.045428,
+		1.617000, 0.046260,
+		1.618000, 0.047099,
+		1.619000, 0.047945,
+		1.620000, 0.048799,
+		1.621000, 0.049659,
+		1.622000, 0.050526,
+		1.623000, 0.051400,
+		1.624000, 0.052282,
+		1.625000, 0.053170,
+		1.626000, 0.054065,
+		1.627000, 0.054968,
+		1.628000, 0.055877,
+		1.629000, 0.056793,
+		1.630000, 0.057716,
+		1.631000, 0.058645,
+		1.632000, 0.059582,
+		1.633000, 0.060525,
+		1.634000, 0.061476,
+		1.635000, 0.062433,
+		1.636000, 0.063397,
+		1.637000, 0.064367,
+		1.638000, 0.065345,
+		1.639000, 0.066329,
+		1.640000, 0.067319,
+		1.641000, 0.068317,
+		1.642000, 0.069321,
+		1.643000, 0.070332,
+		1.644000, 0.071349,
+		1.645000, 0.072373,
+		1.646000, 0.073403,
+		1.647000, 0.074441,
+		1.648000, 0.075484,
+		1.649000, 0.076534,
+		1.650000, 0.077591,
+		1.651000, 0.078654,
+		1.652000, 0.079724,
+		1.653000, 0.080800,
+		1.654000, 0.081882,
+		1.655000, 0.082971,
+		1.656000, 0.084066,
+		1.657000, 0.085168,
+		1.658000, 0.086276,
+		1.659000, 0.087390,
+		1.660000, 0.088511,
+		1.661000, 0.089637,
+		1.662000, 0.090770,
+		1.663000, 0.091910,
+		1.664000, 0.093055,
+		1.665000, 0.094207,
+		1.666000, 0.095364,
+		1.667000, 0.096528,
+		1.668000, 0.097698,
+		1.669000, 0.098874,
+		1.670000, 0.100056,
+		1.671000, 0.101245,
+		1.672000, 0.102439,
+		1.673000, 0.103639,
+		1.674000, 0.104845,
+		1.675000, 0.106057,
+		1.676000, 0.107275,
+		1.677000, 0.108499,
+		1.678000, 0.109729,
+		1.679000, 0.110965,
+		1.680000, 0.112206,
+		1.681000, 0.113454,
+		1.682000, 0.114707,
+		1.683000, 0.115966,
+		1.684000, 0.117230,
+		1.685000, 0.118500,
+		1.686000, 0.119776,
+		1.687000, 0.121058,
+		1.688000, 0.122345,
+		1.689000, 0.123638,
+		1.690000, 0.124936,
+		1.691000, 0.126240,
+		1.692000, 0.127550,
+		1.693000, 0.128865,
+		1.694000, 0.130185,
+		1.695000, 0.131511,
+		1.696000, 0.132843,
+		1.697000, 0.134179,
+		1.698000, 0.135522,
+		1.699000, 0.136869,
+		1.700000, 0.138222,
+		1.701000, 0.139580,
+		1.702000, 0.140943,
+		1.703000, 0.142312,
+		1.704000, 0.143686,
+		1.705000, 0.145065,
+		1.706000, 0.146449,
+		1.707000, 0.147839,
+		1.708000, 0.149233,
+		1.709000, 0.150632,
+		1.710000, 0.152037,
+		1.711000, 0.153447,
+		1.712000, 0.154861,
+		1.713000, 0.156281,
+		1.714000, 0.157705,
+		1.715000, 0.159135,
+		1.716000, 0.160569,
+		1.717000, 0.162008,
+		1.718000, 0.163452,
+		1.719000, 0.164901,
+		1.720000, 0.166355,
+		1.721000, 0.167813,
+		1.722000, 0.169276,
+		1.723000, 0.170744,
+		1.724000, 0.172217,
+		1.725000, 0.173694,
+		1.726000, 0.175176,
+		1.727000, 0.176662,
+		1.728000, 0.178153,
+		1.729000, 0.179648,
+		1.730000, 0.181148,
+		1.731000, 0.182652,
+		1.732000, 0.184161,
+		1.733000, 0.185674,
+		1.734000, 0.187192,
+		1.735000, 0.188714,
+		1.736000, 0.190240,
+		1.737000, 0.191770,
+		1.738000, 0.193305,
+		1.739000, 0.194844,
+		1.740000, 0.196387,
+		1.741000, 0.197935,
+		1.742000, 0.199486,
+		1.743000, 0.201042,
+		1.744000, 0.202601,
+		1.745000, 0.204165,
+		1.746000, 0.205733,
+		1.747000, 0.207305,
+		1.748000, 0.208881,
+		1.749000, 0.210460,
+		1.750000, 0.212044,
+		1.751000, 0.213631,
+		1.752000, 0.215222,
+		1.753000, 0.216818,
+		1.754000, 0.218416,
+		1.755000, 0.220019,
+		1.756000, 0.221625,
+		1.757000, 0.223235,
+		1.758000, 0.224849,
+		1.759000, 0.226466,
+		1.760000, 0.228087,
+		1.761000, 0.229712,
+		1.762000, 0.231340,
+		1.763000, 0.232971,
+		1.764000, 0.234606,
+		1.765000, 0.236245,
+		1.766000, 0.237886,
+		1.767000, 0.239532,
+		1.768000, 0.241180,
+		1.769000, 0.242832,
+		1.770000, 0.244487,
+		1.771000, 0.246146,
+		1.772000, 0.247807,
+		1.773000, 0.249472,
+		1.774000, 0.251140,
+		1.775000, 0.252811,
+		1.776000, 0.254485,
+		1.777000, 0.256162,
+		1.778000, 0.257843,
+		1.779000, 0.259526,
+		1.780000, 0.261212,
+		1.781000, 0.262901,
+		1.782000, 0.264593,
+		1.783000, 0.266288,
+		1.784000, 0.267986,
+		1.785000, 0.269686,
+		1.786000, 0.271390,
+		1.787000, 0.273096,
+		1.788000, 0.274805,
+		1.789000, 0.276516,
+		1.790000, 0.278230,
+		1.791000, 0.279947,
+		1.792000, 0.281666,
+		1.793000, 0.283388,
+		1.794000, 0.285112,
+		1.795000, 0.286839,
+		1.796000, 0.288568,
+		1.797000, 0.290300,
+		1.798000, 0.292034,
+		1.799000, 0.293771,
+		1.800000, 0.295509,
+		1.801000, 0.297250,
+		1.802000, 0.298994,
+		1.803000, 0.300739,
+		1.804000, 0.302487,
+		1.805000, 0.304237,
+		1.806000, 0.305989,
+		1.807000, 0.307743,
+		1.808000, 0.309499,
+		1.809000, 0.311257,
+		1.810000, 0.313017,
+		1.811000, 0.314779,
+		1.812000, 0.316543,
+		1.813000, 0.318309,
+		1.814000, 0.320077,
+		1.815000, 0.321847,
+		1.816000, 0.323618,
+		1.817000, 0.325391,
+		1.818000, 0.327166,
+		1.819000, 0.328943,
+		1.820000, 0.330721,
+		1.821000, 0.332501,
+		1.822000, 0.334282,
+		1.823000, 0.336065,
+		1.824000, 0.337850,
+		1.825000, 0.339636,
+		1.826000, 0.341423,
+		1.827000, 0.343212,
+		1.828000, 0.345003,
+		1.829000, 0.346794,
+		1.830000, 0.348587,
+		1.831000, 0.350382,
+		1.832000, 0.352177,
+		1.833000, 0.353974,
+		1.834000, 0.355772,
+		1.835000, 0.357572,
+		1.836000, 0.359372,
+		1.837000, 0.361173,
+		1.838000, 0.362976,
+		1.839000, 0.364779,
+		1.840000, 0.366584,
+		1.841000, 0.368389,
+		1.842000, 0.370196,
+		1.843000, 0.372003,
+		1.844000, 0.373811,
+		1.845000, 0.375620,
+		1.846000, 0.377430,
+		1.847000, 0.379241,
+		1.848000, 0.381052,
+		1.849000, 0.382864,
+		1.850000, 0.384677,
+		1.851000, 0.386490,
+		1.852000, 0.388304,
+		1.853000, 0.390119,
+		1.854000, 0.391934,
+		1.855000, 0.393750,
+		1.856000, 0.395566,
+		1.857000, 0.397382,
+		1.858000, 0.399199,
+		1.859000, 0.401016,
+		1.860000, 0.402834,
+		1.861000, 0.404652,
+		1.862000, 0.406470,
+		1.863000, 0.408289,
+		1.864000, 0.410107,
+		1.865000, 0.411926,
+		1.866000, 0.413745,
+		1.867000, 0.415564,
+		1.868000, 0.417383,
+		1.869000, 0.419202,
+		1.870000, 0.421022,
+		1.871000, 0.422841,
+		1.872000, 0.424660,
+		1.873000, 0.426479,
+		1.874000, 0.428298,
+		1.875000, 0.430117,
+		1.876000, 0.431936,
+		1.877000, 0.433754,
+		1.878000, 0.435572,
+		1.879000, 0.437390,
+		1.880000, 0.439208,
+		1.881000, 0.441025,
+		1.882000, 0.442842,
+		1.883000, 0.444658,
+		1.884000, 0.446474,
+		1.885000, 0.448290,
+		1.886000, 0.450105,
+		1.887000, 0.451919,
+		1.888000, 0.453733,
+		1.889000, 0.455547,
+		1.890000, 0.457359,
+		1.891000, 0.459171,
+		1.892000, 0.460983,
+		1.893000, 0.462793,
+		1.894000, 0.464603,
+		1.895000, 0.466412,
+		1.896000, 0.468221,
+		1.897000, 0.470028,
+		1.898000, 0.471834,
+		1.899000, 0.473640,
+		1.900000, 0.475445,
+		1.901000, 0.477248,
+		1.902000, 0.479051,
+		1.903000, 0.480853,
+		1.904000, 0.482653,
+		1.905000, 0.484453,
+		1.906000, 0.486251,
+		1.907000, 0.488048,
+		1.908000, 0.489844,
+		1.909000, 0.491639,
+		1.910000, 0.493432,
+		1.911000, 0.495224,
+		1.912000, 0.497015,
+		1.913000, 0.498804,
+		1.914000, 0.500592,
+		1.915000, 0.502379,
+		1.916000, 0.504164,
+		1.917000, 0.505948,
+		1.918000, 0.507730,
+		1.919000, 0.509511,
+		1.920000, 0.511290,
+		1.921000, 0.513067,
+		1.922000, 0.514843,
+		1.923000, 0.516618,
+		1.924000, 0.518390,
+		1.925000, 0.520161,
+		1.926000, 0.521930,
+		1.927000, 0.523697,
+		1.928000, 0.525463,
+		1.929000, 0.527226,
+		1.930000, 0.528988,
+		1.931000, 0.530748,
+		1.932000, 0.532506,
+		1.933000, 0.534262,
+		1.934000, 0.536016,
+		1.935000, 0.537768,
+		1.936000, 0.539518,
+		1.937000, 0.541265,
+		1.938000, 0.543011,
+		1.939000, 0.544755,
+		1.940000, 0.546496,
+		1.941000, 0.548235,
+		1.942000, 0.549972,
+		1.943000, 0.551707,
+		1.944000, 0.553439,
+		1.945000, 0.555169,
+		1.946000, 0.556897,
+		1.947000, 0.558623,
+		1.948000, 0.560346,
+		1.949000, 0.562066,
+		1.950000, 0.563784,
+		1.951000, 0.565500,
+		1.952000, 0.567213,
+		1.953000, 0.568924,
+		1.954000, 0.570632,
+		1.955000, 0.572337,
+		1.956000, 0.574040,
+		1.957000, 0.575740,
+		1.958000, 0.577438,
+		1.959000, 0.579132,
+		1.960000, 0.580824,
+		1.961000, 0.582514,
+		1.962000, 0.584200,
+		1.963000, 0.585884,
+		1.964000, 0.587565,
+		1.965000, 0.589242,
+		1.966000, 0.590917,
+		1.967000, 0.592589,
+		1.968000, 0.594259,
+		1.969000, 0.595925,
+		1.970000, 0.597588,
+		1.971000, 0.599248,
+		1.972000, 0.600905,
+		1.973000, 0.602559,
+		1.974000, 0.604210,
+		1.975000, 0.605857,
+		1.976000, 0.607502,
+		1.977000, 0.609143,
+		1.978000, 0.610781,
+		1.979000, 0.612416,
+		1.980000, 0.614047,
+		1.981000, 0.615676,
+		1.982000, 0.617301,
+		1.983000, 0.618922,
+		1.984000, 0.620540,
+		1.985000, 0.622155,
+		1.986000, 0.623766,
+		1.987000, 0.625374,
+		1.988000, 0.626979,
+		1.989000, 0.628579,
+		1.990000, 0.630177,
+		1.991000, 0.631770,
+		1.992000, 0.633361,
+		1.993000, 0.634947,
+		1.994000, 0.636530,
+		1.995000, 0.638109,
+		1.996000, 0.639685,
+		1.997000, 0.641257,
+		1.998000, 0.642825,
+		1.999000, 0.644389};
+
+#endif  //PENDULUM_GOLD_H
diff --git a/engine/inc/bullet/MultiBodyBaseline/MultiBodyBaseline.h b/engine/inc/bullet/MultiBodyBaseline/MultiBodyBaseline.h
new file mode 100644
index 00000000..35734c63
--- /dev/null
+++ b/engine/inc/bullet/MultiBodyBaseline/MultiBodyBaseline.h
@@ -0,0 +1,20 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef _MULTIBODY_BASELINE_H
+#define _MULTIBODY_BASELINE_H
+
+class CommonExampleInterface*  MultiBodyBaselineCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //_MULTIBODY_BASELINE_H
diff --git a/engine/inc/bullet/MultiThreadedDemo/CommonRigidBodyMTBase.h b/engine/inc/bullet/MultiThreadedDemo/CommonRigidBodyMTBase.h
new file mode 100644
index 00000000..ff96070c
--- /dev/null
+++ b/engine/inc/bullet/MultiThreadedDemo/CommonRigidBodyMTBase.h
@@ -0,0 +1,444 @@
+
+#ifndef COMMON_RIGID_BODY_MT_BASE_H
+#define COMMON_RIGID_BODY_MT_BASE_H
+
+#include "btBulletDynamicsCommon.h"
+#include "../CommonInterfaces/CommonExampleInterface.h"
+#include "../CommonInterfaces/CommonGUIHelperInterface.h"
+#include "../CommonInterfaces/CommonRenderInterface.h"
+#include "../CommonInterfaces/CommonCameraInterface.h"
+#include "../CommonInterfaces/CommonGraphicsAppInterface.h"
+#include "../CommonInterfaces/CommonWindowInterface.h"
+
+enum SolverType
+{
+	SOLVER_TYPE_SEQUENTIAL_IMPULSE,
+	SOLVER_TYPE_SEQUENTIAL_IMPULSE_MT,
+	SOLVER_TYPE_NNCG,
+	SOLVER_TYPE_MLCP_PGS,
+	SOLVER_TYPE_MLCP_DANTZIG,
+	SOLVER_TYPE_MLCP_LEMKE,
+
+	SOLVER_TYPE_COUNT
+};
+
+inline const char* getSolverTypeName(SolverType t)
+{
+	switch (t)
+	{
+		case SOLVER_TYPE_SEQUENTIAL_IMPULSE:
+			return "SequentialImpulse";
+		case SOLVER_TYPE_SEQUENTIAL_IMPULSE_MT:
+			return "SequentialImpulseMt";
+		case SOLVER_TYPE_NNCG:
+			return "NNCG";
+		case SOLVER_TYPE_MLCP_PGS:
+			return "MLCP ProjectedGaussSeidel";
+		case SOLVER_TYPE_MLCP_DANTZIG:
+			return "MLCP Dantzig";
+		case SOLVER_TYPE_MLCP_LEMKE:
+			return "MLCP Lemke";
+		default:
+		{
+		}
+	}
+	btAssert(!"unhandled solver type in switch");
+	return "???";
+}
+
+struct CommonRigidBodyMTBase : public CommonExampleInterface
+{
+	//keep the collision shapes, for deletion/cleanup
+	btAlignedObjectArray<btCollisionShape*> m_collisionShapes;
+	btBroadphaseInterface* m_broadphase;
+	btCollisionDispatcher* m_dispatcher;
+	btConstraintSolver* m_solver;
+	btDefaultCollisionConfiguration* m_collisionConfiguration;
+	btDiscreteDynamicsWorld* m_dynamicsWorld;
+	SolverType m_solverType;
+	bool m_multithreadedWorld;
+	bool m_multithreadCapable;
+
+	//data for picking objects
+	class btRigidBody* m_pickedBody;
+	class btTypedConstraint* m_pickedConstraint;
+	int m_savedState;
+	btVector3 m_oldPickingPos;
+	btVector3 m_hitPos;
+	btScalar m_oldPickingDist;
+	struct GUIHelperInterface* m_guiHelper;
+
+	CommonRigidBodyMTBase(struct GUIHelperInterface* helper);
+	virtual ~CommonRigidBodyMTBase();
+
+	btDiscreteDynamicsWorld* getDynamicsWorld()
+	{
+		return m_dynamicsWorld;
+	}
+
+	virtual void createDefaultParameters();
+	virtual void createEmptyDynamicsWorld();
+
+	virtual void stepSimulation(float deltaTime)
+	{
+		if (m_dynamicsWorld)
+		{
+			m_dynamicsWorld->stepSimulation(deltaTime);
+		}
+	}
+
+	virtual void drawScreenText();
+	virtual void renderScene();
+	virtual void physicsDebugDraw(int debugFlags);
+
+	virtual void exitPhysics()
+	{
+		removePickingConstraint();
+		//cleanup in the reverse order of creation/initialization
+
+		//remove the rigidbodies from the dynamics world and delete them
+
+		if (m_dynamicsWorld)
+		{
+			int i;
+			for (i = m_dynamicsWorld->getNumConstraints() - 1; i >= 0; i--)
+			{
+				m_dynamicsWorld->removeConstraint(m_dynamicsWorld->getConstraint(i));
+			}
+			for (i = m_dynamicsWorld->getNumCollisionObjects() - 1; i >= 0; i--)
+			{
+				btCollisionObject* obj = m_dynamicsWorld->getCollisionObjectArray()[i];
+				btRigidBody* body = btRigidBody::upcast(obj);
+				if (body && body->getMotionState())
+				{
+					delete body->getMotionState();
+				}
+				m_dynamicsWorld->removeCollisionObject(obj);
+				delete obj;
+			}
+		}
+		//delete collision shapes
+		for (int j = 0; j < m_collisionShapes.size(); j++)
+		{
+			btCollisionShape* shape = m_collisionShapes[j];
+			delete shape;
+		}
+		m_collisionShapes.clear();
+
+		delete m_dynamicsWorld;
+		m_dynamicsWorld = 0;
+
+		delete m_solver;
+		m_solver = 0;
+
+		delete m_broadphase;
+		m_broadphase = 0;
+
+		delete m_dispatcher;
+		m_dispatcher = 0;
+
+		delete m_collisionConfiguration;
+		m_collisionConfiguration = 0;
+	}
+
+	virtual void debugDraw(int debugDrawFlags)
+	{
+		if (m_dynamicsWorld)
+		{
+			if (m_dynamicsWorld->getDebugDrawer())
+			{
+				m_dynamicsWorld->getDebugDrawer()->setDebugMode(debugDrawFlags);
+			}
+			m_dynamicsWorld->debugDrawWorld();
+		}
+	}
+
+	virtual bool keyboardCallback(int key, int state)
+	{
+		if ((key == B3G_F3) && state && m_dynamicsWorld)
+		{
+			btDefaultSerializer* serializer = new btDefaultSerializer();
+			m_dynamicsWorld->serialize(serializer);
+
+			FILE* file = fopen("testFile.bullet", "wb");
+			fwrite(serializer->getBufferPointer(), serializer->getCurrentBufferSize(), 1, file);
+			fclose(file);
+			//b3Printf("btDefaultSerializer wrote testFile.bullet");
+			delete serializer;
+			return true;
+		}
+		return false;  //don't handle this key
+	}
+
+	btVector3 getRayTo(int x, int y)
+	{
+		CommonRenderInterface* renderer = m_guiHelper->getRenderInterface();
+
+		if (!renderer)
+		{
+			btAssert(0);
+			return btVector3(0, 0, 0);
+		}
+
+		float top = 1.f;
+		float bottom = -1.f;
+		float nearPlane = 1.f;
+		float tanFov = (top - bottom) * 0.5f / nearPlane;
+		float fov = btScalar(2.0) * btAtan(tanFov);
+
+		btVector3 camPos, camTarget;
+
+		renderer->getActiveCamera()->getCameraPosition(camPos);
+		renderer->getActiveCamera()->getCameraTargetPosition(camTarget);
+
+		btVector3 rayFrom = camPos;
+		btVector3 rayForward = (camTarget - camPos);
+		rayForward.normalize();
+		float farPlane = 10000.f;
+		rayForward *= farPlane;
+
+		btVector3 rightOffset;
+		btVector3 cameraUp = btVector3(0, 0, 0);
+		cameraUp[m_guiHelper->getAppInterface()->getUpAxis()] = 1;
+
+		btVector3 vertical = cameraUp;
+
+		btVector3 hor;
+		hor = rayForward.cross(vertical);
+		hor.safeNormalize();
+		vertical = hor.cross(rayForward);
+		vertical.safeNormalize();
+
+		float tanfov = tanf(0.5f * fov);
+
+		hor *= 2.f * farPlane * tanfov;
+		vertical *= 2.f * farPlane * tanfov;
+
+		btScalar aspect;
+		float width = float(renderer->getScreenWidth());
+		float height = float(renderer->getScreenHeight());
+
+		aspect = width / height;
+
+		hor *= aspect;
+
+		btVector3 rayToCenter = rayFrom + rayForward;
+		btVector3 dHor = hor * 1.f / width;
+		btVector3 dVert = vertical * 1.f / height;
+
+		btVector3 rayTo = rayToCenter - 0.5f * hor + 0.5f * vertical;
+		rayTo += btScalar(x) * dHor;
+		rayTo -= btScalar(y) * dVert;
+		return rayTo;
+	}
+
+	virtual bool mouseMoveCallback(float x, float y)
+	{
+		CommonRenderInterface* renderer = m_guiHelper->getRenderInterface();
+
+		if (!renderer)
+		{
+			btAssert(0);
+			return false;
+		}
+
+		btVector3 rayTo = getRayTo(int(x), int(y));
+		btVector3 rayFrom;
+		renderer->getActiveCamera()->getCameraPosition(rayFrom);
+		movePickedBody(rayFrom, rayTo);
+
+		return false;
+	}
+
+	virtual bool mouseButtonCallback(int button, int state, float x, float y)
+	{
+		CommonRenderInterface* renderer = m_guiHelper->getRenderInterface();
+
+		if (!renderer)
+		{
+			btAssert(0);
+			return false;
+		}
+
+		CommonWindowInterface* window = m_guiHelper->getAppInterface()->m_window;
+
+#if 0
+		if (window->isModifierKeyPressed(B3G_ALT))
+		{
+			printf("ALT pressed\n");
+		} else
+		{
+			printf("NO ALT pressed\n");
+		}
+		
+		if (window->isModifierKeyPressed(B3G_SHIFT))
+		{
+			printf("SHIFT pressed\n");
+		} else
+		{
+			printf("NO SHIFT pressed\n");
+		}
+		
+		if (window->isModifierKeyPressed(B3G_CONTROL))
+		{
+			printf("CONTROL pressed\n");
+		} else
+		{
+			printf("NO CONTROL pressed\n");
+		}
+#endif
+
+		if (state == 1)
+		{
+			if (button == 0 && (!window->isModifierKeyPressed(B3G_ALT) && !window->isModifierKeyPressed(B3G_CONTROL)))
+			{
+				btVector3 camPos;
+				renderer->getActiveCamera()->getCameraPosition(camPos);
+
+				btVector3 rayFrom = camPos;
+				btVector3 rayTo = getRayTo(int(x), int(y));
+
+				pickBody(rayFrom, rayTo);
+			}
+		}
+		else
+		{
+			if (button == 0)
+			{
+				removePickingConstraint();
+				//remove p2p
+			}
+		}
+
+		//printf("button=%d, state=%d\n",button,state);
+		return false;
+	}
+
+	virtual bool pickBody(const btVector3& rayFromWorld, const btVector3& rayToWorld)
+	{
+		if (m_dynamicsWorld == 0)
+			return false;
+
+		btCollisionWorld::ClosestRayResultCallback rayCallback(rayFromWorld, rayToWorld);
+
+		m_dynamicsWorld->rayTest(rayFromWorld, rayToWorld, rayCallback);
+		if (rayCallback.hasHit())
+		{
+			btVector3 pickPos = rayCallback.m_hitPointWorld;
+			btRigidBody* body = (btRigidBody*)btRigidBody::upcast(rayCallback.m_collisionObject);
+			if (body)
+			{
+				//other exclusions?
+				if (!(body->isStaticObject() || body->isKinematicObject()))
+				{
+					m_pickedBody = body;
+					m_savedState = m_pickedBody->getActivationState();
+					m_pickedBody->setActivationState(DISABLE_DEACTIVATION);
+					//printf("pickPos=%f,%f,%f\n",pickPos.getX(),pickPos.getY(),pickPos.getZ());
+					btVector3 localPivot = body->getCenterOfMassTransform().inverse() * pickPos;
+					btPoint2PointConstraint* p2p = new btPoint2PointConstraint(*body, localPivot);
+					m_dynamicsWorld->addConstraint(p2p, true);
+					m_pickedConstraint = p2p;
+					btScalar mousePickClamping = 30.f;
+					p2p->m_setting.m_impulseClamp = mousePickClamping;
+					//very weak constraint for picking
+					p2p->m_setting.m_tau = 0.001f;
+				}
+			}
+
+			//					pickObject(pickPos, rayCallback.m_collisionObject);
+			m_oldPickingPos = rayToWorld;
+			m_hitPos = pickPos;
+			m_oldPickingDist = (pickPos - rayFromWorld).length();
+			//					printf("hit !\n");
+			//add p2p
+		}
+		return false;
+	}
+	virtual bool movePickedBody(const btVector3& rayFromWorld, const btVector3& rayToWorld)
+	{
+		if (m_pickedBody && m_pickedConstraint)
+		{
+			btPoint2PointConstraint* pickCon = static_cast<btPoint2PointConstraint*>(m_pickedConstraint);
+			if (pickCon)
+			{
+				//keep it at the same picking distance
+
+				btVector3 newPivotB;
+
+				btVector3 dir = rayToWorld - rayFromWorld;
+				dir.normalize();
+				dir *= m_oldPickingDist;
+
+				newPivotB = rayFromWorld + dir;
+				pickCon->setPivotB(newPivotB);
+				return true;
+			}
+		}
+		return false;
+	}
+	virtual void removePickingConstraint()
+	{
+		if (m_pickedConstraint)
+		{
+			m_pickedBody->forceActivationState(m_savedState);
+			m_pickedBody->activate();
+			m_dynamicsWorld->removeConstraint(m_pickedConstraint);
+			delete m_pickedConstraint;
+			m_pickedConstraint = 0;
+			m_pickedBody = 0;
+		}
+	}
+
+	btBoxShape* createBoxShape(const btVector3& halfExtents)
+	{
+		btBoxShape* box = new btBoxShape(halfExtents);
+		return box;
+	}
+
+	btRigidBody* createRigidBody(float mass, const btTransform& startTransform, btCollisionShape* shape, const btVector4& color = btVector4(1, 0, 0, 1))
+	{
+		btAssert((!shape || shape->getShapeType() != INVALID_SHAPE_PROXYTYPE));
+
+		//rigidbody is dynamic if and only if mass is non zero, otherwise static
+		bool isDynamic = (mass != 0.f);
+
+		btVector3 localInertia(0, 0, 0);
+		if (isDynamic)
+			shape->calculateLocalInertia(mass, localInertia);
+
+			//using motionstate is recommended, it provides interpolation capabilities, and only synchronizes 'active' objects
+
+#define USE_MOTIONSTATE 1
+#ifdef USE_MOTIONSTATE
+		btDefaultMotionState* myMotionState = new btDefaultMotionState(startTransform);
+
+		btRigidBody::btRigidBodyConstructionInfo cInfo(mass, myMotionState, shape, localInertia);
+
+		btRigidBody* body = new btRigidBody(cInfo);
+		//body->setContactProcessingThreshold(m_defaultContactProcessingThreshold);
+
+#else
+		btRigidBody* body = new btRigidBody(mass, 0, shape, localInertia);
+		body->setWorldTransform(startTransform);
+#endif  //
+
+		body->setUserIndex(-1);
+		m_dynamicsWorld->addRigidBody(body);
+		return body;
+	}
+
+	btRigidBody* createKinematicBody(const btTransform& startTransform, btCollisionShape* shape)
+	{
+		btAssert((!shape || shape->getShapeType() != INVALID_SHAPE_PROXYTYPE));
+
+		btRigidBody* body = new btRigidBody(0.0f, NULL, shape);
+		body->setWorldTransform(startTransform);
+		body->setCollisionFlags(body->getCollisionFlags() | btCollisionObject::CF_KINEMATIC_OBJECT);
+		body->setUserIndex(-1);
+		m_dynamicsWorld->addRigidBody(body);
+		return body;
+	}
+};
+
+#endif  //#define COMMON_RIGID_BODY_MT_BASE_H
diff --git a/engine/inc/bullet/MultiThreadedDemo/MultiThreadedDemo.h b/engine/inc/bullet/MultiThreadedDemo/MultiThreadedDemo.h
new file mode 100644
index 00000000..a4ae274f
--- /dev/null
+++ b/engine/inc/bullet/MultiThreadedDemo/MultiThreadedDemo.h
@@ -0,0 +1,20 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef MULTITHREADED_DEMO_H
+#define MULTITHREADED_DEMO_H
+
+class CommonExampleInterface* MultiThreadedDemoCreateFunc(struct CommonExampleOptions& options);
+
+#endif  // MULTITHREADED_DEMO_H
diff --git a/engine/inc/bullet/MultiThreading/MultiThreadingExample.h b/engine/inc/bullet/MultiThreading/MultiThreadingExample.h
new file mode 100644
index 00000000..6bc142c3
--- /dev/null
+++ b/engine/inc/bullet/MultiThreading/MultiThreadingExample.h
@@ -0,0 +1,11 @@
+#ifndef MULTI_THREADING_EXAMPLE_H
+#define MULTI_THREADING_EXAMPLE_H
+
+enum EnumMultiThreadingExampleTypes
+{
+	SINGLE_SIM_THREAD = 0,
+};
+
+class CommonExampleInterface* MultiThreadingExampleCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //MULTI_THREADING_EXAMPLE_H
diff --git a/engine/inc/bullet/MultiThreading/b3PosixThreadSupport.h b/engine/inc/bullet/MultiThreading/b3PosixThreadSupport.h
new file mode 100644
index 00000000..f20a7f85
--- /dev/null
+++ b/engine/inc/bullet/MultiThreading/b3PosixThreadSupport.h
@@ -0,0 +1,142 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2007 Erwin Coumans  http://bulletphysics.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_POSIX_THREAD_SUPPORT_H
+#define B3_POSIX_THREAD_SUPPORT_H
+
+#include "Bullet3Common/b3Scalar.h"
+
+#ifndef _XOPEN_SOURCE
+#define _XOPEN_SOURCE 600  //for definition of pthread_barrier_t, see http://pages.cs.wisc.edu/~travitch/pthreads_primer.html
+#endif                     //_XOPEN_SOURCE
+#include <pthread.h>
+#include <semaphore.h>
+
+#include "Bullet3Common/b3AlignedObjectArray.h"
+
+#include "b3ThreadSupportInterface.h"
+
+typedef void (*b3PosixThreadFunc)(void* userPtr, void* lsMemory);
+typedef void* (*b3PosixlsMemorySetupFunc)();
+typedef void (*b3PosixlsMemoryReleaseFunc)(void* ptr);
+
+// b3PosixThreadSupport helps to initialize/shutdown libspe2, start/stop SPU tasks and communication
+class b3PosixThreadSupport : public b3ThreadSupportInterface
+{
+public:
+	typedef enum sStatus
+	{
+		STATUS_BUSY,
+		STATUS_READY,
+		STATUS_FINISHED
+	} Status;
+
+	// placeholder, until libspe2 support is there
+	struct b3ThreadStatus
+	{
+		int m_taskId;
+		int m_commandId;
+		int m_status;
+
+		b3PosixThreadFunc m_userThreadFunc;
+		void* m_userPtr;  //for taskDesc etc
+		b3PosixlsMemoryReleaseFunc m_lsMemoryReleaseFunc;
+
+		void* m_lsMemory;  //initialized using PosixLocalStoreMemorySetupFunc
+
+		pthread_t thread;
+		//each tread will wait until this signal to start its work
+		sem_t* startSemaphore;
+
+		// this is a copy of m_mainSemaphore,
+		//each tread will signal once it is finished with its work
+		sem_t* m_mainSemaphore;
+		unsigned long threadUsed;
+	};
+
+private:
+	b3AlignedObjectArray<b3ThreadStatus> m_activeThreadStatus;
+
+	// m_mainSemaphoresemaphore will signal, if and how many threads are finished with their work
+	sem_t* m_mainSemaphore;
+
+public:
+	///Setup and initialize SPU/CELL/Libspe2
+
+	struct ThreadConstructionInfo
+	{
+		ThreadConstructionInfo(const char* uniqueName,
+							   b3PosixThreadFunc userThreadFunc,
+							   b3PosixlsMemorySetupFunc lsMemoryFunc,
+							   b3PosixlsMemoryReleaseFunc lsMemoryReleaseFunc,
+							   int numThreads = 1,
+							   int threadStackSize = 65535)
+			: m_uniqueName(uniqueName),
+			  m_userThreadFunc(userThreadFunc),
+			  m_lsMemoryFunc(lsMemoryFunc),
+			  m_lsMemoryReleaseFunc(lsMemoryReleaseFunc),
+			  m_numThreads(numThreads),
+			  m_threadStackSize(threadStackSize)
+		{
+		}
+
+		const char* m_uniqueName;
+		b3PosixThreadFunc m_userThreadFunc;
+		b3PosixlsMemorySetupFunc m_lsMemoryFunc;
+		b3PosixlsMemoryReleaseFunc m_lsMemoryReleaseFunc;
+
+		int m_numThreads;
+		int m_threadStackSize;
+	};
+
+	b3PosixThreadSupport(ThreadConstructionInfo& threadConstructionInfo);
+
+	///cleanup/shutdown Libspe2
+	virtual ~b3PosixThreadSupport();
+
+	void startThreads(ThreadConstructionInfo& threadInfo);
+
+	virtual void runTask(int uiCommand, void* uiArgument0, int uiArgument1);
+
+	virtual void waitForResponse(int* puiArgument0, int* puiArgument1);
+
+	///tell the task scheduler we are done with the SPU tasks
+	virtual void stopThreads();
+
+	virtual void setNumTasks(int numTasks) {}
+
+	virtual int getNumTasks() const
+	{
+		return m_activeThreadStatus.size();
+	}
+
+	///non-blocking test if a task is completed. First implement all versions, and then enable this API
+	virtual bool isTaskCompleted(int* puiArgument0, int* puiArgument1, int timeOutInMilliseconds);
+
+	virtual b3Barrier* createBarrier();
+
+	virtual b3CriticalSection* createCriticalSection();
+
+	virtual void deleteBarrier(b3Barrier* barrier);
+
+	virtual void deleteCriticalSection(b3CriticalSection* criticalSection);
+
+	virtual void* getThreadLocalMemory(int taskId)
+	{
+		return m_activeThreadStatus[taskId].m_lsMemory;
+	}
+};
+
+#endif  // B3_POSIX_THREAD_SUPPORT_H
diff --git a/engine/inc/bullet/MultiThreading/b3ThreadSupportInterface.h b/engine/inc/bullet/MultiThreading/b3ThreadSupportInterface.h
new file mode 100644
index 00000000..5f61951c
--- /dev/null
+++ b/engine/inc/bullet/MultiThreading/b3ThreadSupportInterface.h
@@ -0,0 +1,84 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2007 Erwin Coumans  http://bulletphysics.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_THREAD_SUPPORT_INTERFACE_H
+#define B3_THREAD_SUPPORT_INTERFACE_H
+
+enum
+{
+	B3_THREAD_SCHEDULE_TASK = 1,
+};
+
+#include "Bullet3Common/b3Scalar.h"  //for B3_ATTRIBUTE_ALIGNED16
+//#include "PlatformDefinitions.h"
+//#include "PpuAddressSpace.h"
+
+class b3Barrier
+{
+public:
+	b3Barrier() {}
+	virtual ~b3Barrier() {}
+
+	virtual void sync() = 0;
+	virtual void setMaxCount(int n) = 0;
+	virtual int getMaxCount() = 0;
+};
+
+class b3CriticalSection
+{
+public:
+	b3CriticalSection() {}
+	virtual ~b3CriticalSection() {}
+
+	B3_ATTRIBUTE_ALIGNED16(unsigned int mCommonBuff[32]);
+
+	virtual unsigned int getSharedParam(int i) = 0;
+	virtual void setSharedParam(int i, unsigned int p) = 0;
+
+	virtual void lock() = 0;
+	virtual void unlock() = 0;
+};
+
+class b3ThreadSupportInterface
+{
+public:
+	virtual ~b3ThreadSupportInterface();
+
+	virtual void runTask(int uiCommand, void* uiArgument0, int uiArgument1) = 0;
+
+	virtual void waitForResponse(int* puiArgument0, int* puiArgument1) = 0;
+
+	///non-blocking test if a task is completed. First implement all versions, and then enable this API
+	virtual bool isTaskCompleted(int* puiArgument0, int* puiArgument1, int timeOutInMilliseconds) = 0;
+
+	virtual void stopThreads() = 0;
+
+	///tell the task scheduler to use no more than numTasks tasks
+	virtual void setNumTasks(int numTasks) = 0;
+
+	virtual int getNumTasks() const = 0;
+
+	virtual b3Barrier* createBarrier() = 0;
+
+	virtual b3CriticalSection* createCriticalSection() = 0;
+
+	virtual void deleteBarrier(b3Barrier* barrier) = 0;
+
+	virtual void deleteCriticalSection(b3CriticalSection* criticalSection) = 0;
+
+	virtual void* getThreadLocalMemory(int taskId) { return 0; }
+};
+
+#endif  //B3_THREAD_SUPPORT_INTERFACE_H
diff --git a/engine/inc/bullet/MultiThreading/b3Win32ThreadSupport.h b/engine/inc/bullet/MultiThreading/b3Win32ThreadSupport.h
new file mode 100644
index 00000000..3b452629
--- /dev/null
+++ b/engine/inc/bullet/MultiThreading/b3Win32ThreadSupport.h
@@ -0,0 +1,135 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2007 Erwin Coumans  http://bulletphysics.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "Bullet3Common/b3Scalar.h"
+
+#ifndef BT_WIN32_THREAD_SUPPORT_H
+#define BT_WIN32_THREAD_SUPPORT_H
+
+#include "Bullet3Common/b3AlignedObjectArray.h"
+
+#include "b3ThreadSupportInterface.h"
+
+typedef void (*b3Win32ThreadFunc)(void* userPtr, void* lsMemory);
+typedef void* (*b3Win32lsMemorySetupFunc)();
+typedef void (*b3Win32lsMemoryReleaseFunc)(void*);
+
+///b3Win32ThreadSupport helps to initialize/shutdown libspe2, start/stop SPU tasks and communication
+class b3Win32ThreadSupport : public b3ThreadSupportInterface
+{
+public:
+	///placeholder, until libspe2 support is there
+	struct b3ThreadStatus
+	{
+		int m_taskId;
+		int m_commandId;
+		int m_status;
+
+		b3Win32ThreadFunc m_userThreadFunc;
+		void* m_userPtr;   //for taskDesc etc
+		void* m_lsMemory;  //initialized using Win32LocalStoreMemorySetupFunc
+
+		b3Win32lsMemoryReleaseFunc m_lsMemoryReleaseFunc;
+
+		void* m_threadHandle;  //this one is calling 'Win32ThreadFunc'
+
+		void* m_eventStartHandle;
+		char m_eventStartHandleName[32];
+
+		void* m_eventCompletetHandle;
+		char m_eventCompletetHandleName[32];
+	};
+
+private:
+	b3AlignedObjectArray<b3ThreadStatus> m_activeThreadStatus;
+	b3AlignedObjectArray<void*> m_completeHandles;
+
+	int m_maxNumTasks;
+
+public:
+	///Setup and initialize SPU/CELL/Libspe2
+
+	struct Win32ThreadConstructionInfo
+	{
+		Win32ThreadConstructionInfo(const char* uniqueName,
+									b3Win32ThreadFunc userThreadFunc,
+									b3Win32lsMemorySetupFunc lsMemoryFunc,
+									b3Win32lsMemoryReleaseFunc lsMemoryReleaseFunc,
+									int numThreads = 1,
+									int threadStackSize = 65535)
+			: m_uniqueName(uniqueName),
+			  m_userThreadFunc(userThreadFunc),
+			  m_lsMemoryFunc(lsMemoryFunc),
+			  m_lsMemoryReleaseFunc(lsMemoryReleaseFunc),
+			  m_numThreads(numThreads),
+			  m_threadStackSize(threadStackSize),
+			  m_priority(0)
+		{
+		}
+
+		const char* m_uniqueName;
+		b3Win32ThreadFunc m_userThreadFunc;
+		b3Win32lsMemorySetupFunc m_lsMemoryFunc;
+		b3Win32lsMemoryReleaseFunc m_lsMemoryReleaseFunc;
+		int m_numThreads;
+		int m_threadStackSize;
+		int m_priority;
+	};
+
+	b3Win32ThreadSupport(const Win32ThreadConstructionInfo& threadConstructionInfo);
+
+	///cleanup/shutdown Libspe2
+	virtual ~b3Win32ThreadSupport();
+
+	void startThreads(const Win32ThreadConstructionInfo& threadInfo);
+
+	///send messages to SPUs
+	virtual void runTask(int uiCommand, void* uiArgument0, int uiArgument1);
+
+	///check for messages from SPUs
+	virtual void waitForResponse(int* puiArgument0, int* puiArgument1);
+
+	virtual bool isTaskCompleted(int* puiArgument0, int* puiArgument1, int timeOutInMilliseconds);
+
+	///start the spus (can be called at the beginning of each frame, to make sure that the right SPU program is loaded)
+	virtual void startThreads();
+
+	///tell the task scheduler we are done with the SPU tasks
+	virtual void stopThreads();
+
+	virtual void setNumTasks(int numTasks)
+	{
+		m_maxNumTasks = numTasks;
+	}
+
+	virtual int getNumTasks() const
+	{
+		return m_maxNumTasks;
+	}
+
+	virtual void* getThreadLocalMemory(int taskId)
+	{
+		return m_activeThreadStatus[taskId].m_lsMemory;
+	}
+	virtual b3Barrier* createBarrier();
+
+	virtual b3CriticalSection* createCriticalSection();
+
+	virtual void deleteBarrier(b3Barrier* barrier);
+
+	virtual void deleteCriticalSection(b3CriticalSection* criticalSection);
+};
+
+#endif  //BT_WIN32_THREAD_SUPPORT_H
diff --git a/engine/inc/bullet/OpenCL/CommonOpenCL/CommonOpenCLBase.h b/engine/inc/bullet/OpenCL/CommonOpenCL/CommonOpenCLBase.h
new file mode 100644
index 00000000..e327b0e1
--- /dev/null
+++ b/engine/inc/bullet/OpenCL/CommonOpenCL/CommonOpenCLBase.h
@@ -0,0 +1,145 @@
+#ifndef COMMON_MULTI_BODY_SETUP_H
+#define COMMON_MULTI_BODY_SETUP_H
+
+#include "../CommonInterfaces/CommonExampleInterface.h"
+#include "../CommonInterfaces/CommonGUIHelperInterface.h"
+#include "../CommonInterfaces/CommonRenderInterface.h"
+#include "../CommonInterfaces/CommonGraphicsAppInterface.h"
+#include "../CommonInterfaces/CommonWindowInterface.h"
+#include "../CommonInterfaces/CommonCameraInterface.h"
+
+#include "GpuDemoInternalData.h"
+#include "Bullet3Common/b3Scalar.h"
+#include "Bullet3OpenCL/Initialize/b3OpenCLUtils.h"
+
+struct CommonOpenCLBase : public CommonExampleInterface
+{
+	struct GUIHelperInterface* m_guiHelper;
+	struct GpuDemoInternalData* m_clData;
+
+	CommonOpenCLBase(GUIHelperInterface* helper)
+		: m_guiHelper(helper),
+		  m_clData(0)
+	{
+		m_clData = new GpuDemoInternalData();
+	}
+
+	virtual ~CommonOpenCLBase()
+	{
+		delete m_clData;
+		m_clData = 0;
+	}
+
+	virtual void stepSimulation(float deltaTime)
+	{
+	}
+
+	virtual void initCL(int preferredDeviceIndex, int preferredPlatformIndex)
+	{
+		//	void* glCtx=0;
+		//	void* glDC = 0;
+
+		int ciErrNum = 0;
+
+		cl_device_type deviceType = CL_DEVICE_TYPE_GPU;
+		//if (gAllowCpuOpenCL)
+		//	deviceType = CL_DEVICE_TYPE_ALL;
+
+		//	if (useInterop)
+		//	{
+		//		m_data->m_clContext = b3OpenCLUtils::createContextFromType(deviceType, &ciErrNum, glCtx, glDC);
+		//	} else
+		{
+			m_clData->m_clContext = b3OpenCLUtils::createContextFromType(deviceType, &ciErrNum, 0, 0, preferredDeviceIndex, preferredPlatformIndex, &m_clData->m_platformId);
+		}
+
+		oclCHECKERROR(ciErrNum, CL_SUCCESS);
+
+		int numDev = b3OpenCLUtils::getNumDevices(m_clData->m_clContext);
+
+		if (numDev > 0)
+		{
+			m_clData->m_clDevice = b3OpenCLUtils::getDevice(m_clData->m_clContext, 0);
+			m_clData->m_clQueue = clCreateCommandQueue(m_clData->m_clContext, m_clData->m_clDevice, 0, &ciErrNum);
+			oclCHECKERROR(ciErrNum, CL_SUCCESS);
+
+			b3OpenCLDeviceInfo info;
+			b3OpenCLUtils::getDeviceInfo(m_clData->m_clDevice, &info);
+			m_clData->m_clDeviceName = info.m_deviceName;
+			m_clData->m_clInitialized = true;
+		}
+	}
+
+	virtual void exitCL()
+	{
+		if (m_clData && m_clData->m_clInitialized)
+		{
+			clReleaseCommandQueue(m_clData->m_clQueue);
+			clReleaseContext(m_clData->m_clContext);
+			m_clData->m_clInitialized = false;
+		}
+	}
+
+	virtual void renderScene()
+	{
+		if (m_guiHelper->getRenderInterface())
+		{
+			m_guiHelper->getRenderInterface()->renderScene();
+		}
+	}
+
+	virtual void physicsDebugDraw(int debugDrawFlags)
+	{
+	}
+
+	virtual bool keyboardCallback(int key, int state)
+	{
+		return false;  //don't handle this key
+	}
+
+	virtual bool mouseMoveCallback(float x, float y)
+	{
+		return false;
+	}
+
+	virtual bool mouseButtonCallback(int button, int state, float x, float y)
+	{
+		CommonRenderInterface* renderer = m_guiHelper->getRenderInterface();
+
+		if (!renderer)
+		{
+			b3Assert(0);
+			return false;
+		}
+
+		CommonWindowInterface* window = m_guiHelper->getAppInterface()->m_window;
+
+		if (state == 1)
+		{
+			if (button == 0 && (!window->isModifierKeyPressed(B3G_ALT) && !window->isModifierKeyPressed(B3G_CONTROL)))
+			{
+				/*btVector3 camPos;
+				renderer->getActiveCamera()->getCameraPosition(camPos);
+
+				btVector3 rayFrom = camPos;
+				btVector3 rayTo = getRayTo(int(x),int(y));
+
+				pickBody(rayFrom, rayTo);
+				*/
+			}
+		}
+		else
+		{
+			if (button == 0)
+			{
+				//				removePickingConstraint();
+				//remove p2p
+			}
+		}
+
+		//printf("button=%d, state=%d\n",button,state);
+		return false;
+	}
+};
+
+#endif  //COMMON_MULTI_BODY_SETUP_H
diff --git a/engine/inc/bullet/OpenCL/CommonOpenCL/GpuDemoInternalData.h b/engine/inc/bullet/OpenCL/CommonOpenCL/GpuDemoInternalData.h
new file mode 100644
index 00000000..1781e0e9
--- /dev/null
+++ b/engine/inc/bullet/OpenCL/CommonOpenCL/GpuDemoInternalData.h
@@ -0,0 +1,26 @@
+#ifndef GPU_DEMO_INTERNAL_DATA_H
+#define GPU_DEMO_INTERNAL_DATA_H
+
+#include "Bullet3OpenCL/Initialize/b3OpenCLInclude.h"
+
+struct GpuDemoInternalData
+{
+	cl_platform_id m_platformId;
+	cl_context m_clContext;
+	cl_device_id m_clDevice;
+	cl_command_queue m_clQueue;
+	bool m_clInitialized;
+	char* m_clDeviceName;
+
+	GpuDemoInternalData()
+		: m_platformId(0),
+		  m_clContext(0),
+		  m_clDevice(0),
+		  m_clQueue(0),
+		  m_clInitialized(false),
+		  m_clDeviceName(0)
+	{
+	}
+};
+
+#endif
diff --git a/engine/inc/bullet/OpenCL/broadphase/PairBench.h b/engine/inc/bullet/OpenCL/broadphase/PairBench.h
new file mode 100644
index 00000000..2a3040ee
--- /dev/null
+++ b/engine/inc/bullet/OpenCL/broadphase/PairBench.h
@@ -0,0 +1,6 @@
+#ifndef PAIR_BENCH_H
+#define PAIR_BENCH_H
+
+class CommonExampleInterface* PairBenchOpenCLCreateFunc(struct CommonExampleOptions& options);
+
+#endif
diff --git a/engine/inc/bullet/OpenCL/broadphase/pairsKernel.h b/engine/inc/bullet/OpenCL/broadphase/pairsKernel.h
new file mode 100644
index 00000000..803dcd46
--- /dev/null
+++ b/engine/inc/bullet/OpenCL/broadphase/pairsKernel.h
@@ -0,0 +1,76 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* pairsKernelsCL =
+	"__kernel void moveObjectsKernel(__global float4* posOrnColors, int numObjects)\n"
+	"{\n"
+	"	int iGID = get_global_id(0);\n"
+	"	if (iGID>=numObjects)\n"
+	"		return;\n"
+	"	__global float4* positions = &posOrnColors[0];\n"
+	"	if (iGID<0.5*numObjects)\n"
+	"	{\n"
+	"		positions[iGID].y +=0.01f;\n"
+	"	}\n"
+	"	__global float4* colors = &posOrnColors[numObjects*2];\n"
+	"	colors[iGID] = (float4)(0,0,1,1);\n"
+	"}\n"
+	"__kernel void colorPairsKernel2(__global float4* posOrnColors, int numObjects, __global const int4* pairs, int indexOffset, int numPairs)\n"
+	"{\n"
+	"	int iPairId = get_global_id(0);\n"
+	"	if (iPairId>=numPairs)\n"
+	"		return;\n"
+	"	__global float4* colors = &posOrnColors[numObjects*2];\n"
+	"	int iObjectA = pairs[iPairId].x-indexOffset;\n"
+	"	int iObjectB = pairs[iPairId].y-indexOffset;\n"
+	"	colors[iObjectA] = (float4)(1,0,0,1);\n"
+	"	colors[iObjectB] = (float4)(1,0,0,1);\n"
+	"}\n"
+	"__kernel void \n"
+	"  sineWaveKernel( __global float4* posOrnColors, __global float* pBodyTimes,float timeStepPos, float mAmplitude,const int numNodes)\n"
+	"{\n"
+	"	int nodeID = get_global_id(0);\n"
+	"	if( nodeID < numNodes )\n"
+	"	{\n"
+	"		pBodyTimes[nodeID] += timeStepPos;\n"
+	"		float4 position = posOrnColors[nodeID];\n"
+	"		position.x = native_cos(pBodyTimes[nodeID]*2.17f)*mAmplitude + native_sin(pBodyTimes[nodeID])*mAmplitude*0.5f;\n"
+	"		position.y = native_cos(pBodyTimes[nodeID]*1.38f)*mAmplitude + native_sin(pBodyTimes[nodeID]*mAmplitude);\n"
+	"		position.z = native_cos(pBodyTimes[nodeID]*2.17f)*mAmplitude + native_sin(pBodyTimes[nodeID]*0.777f)*mAmplitude;\n"
+	"		\n"
+	"		posOrnColors[nodeID] = position;\n"
+	"		__global float4* colors = &posOrnColors[numNodes*2];\n"
+	"		colors[nodeID] = (float4)(0,0,1,1);\n"
+	"	}\n"
+	"}\n"
+	"typedef struct \n"
+	"{\n"
+	"	float			fx;\n"
+	"	float			fy;\n"
+	"	float			fz;\n"
+	"	int	uw;\n"
+	"} b3AABBCL;\n"
+	"__kernel void updateAabbSimple( __global float4* posOrnColors, const int numNodes, __global b3AABBCL* pAABB)\n"
+	"{\n"
+	"	int nodeId = get_global_id(0);\n"
+	"	if( nodeId < numNodes )\n"
+	"	{\n"
+	"	\n"
+	"		b3AABBCL orgAabbMin = pAABB[nodeId*2];\n"
+	"		b3AABBCL orgAabbMax = pAABB[nodeId*2+1];\n"
+	"		int orgNodeId = orgAabbMin.uw;\n"
+	"		int orgBroadphaseIndex = orgAabbMax.uw;\n"
+	"		\n"
+	"		float4 position = posOrnColors[nodeId];\n"
+	"		float4 argAabbMinVec = (float4)(orgAabbMin.fx,orgAabbMin.fy,orgAabbMin.fz,0.f);\n"
+	"		float4 argAabbMaxVec = (float4)(orgAabbMax.fx,orgAabbMax.fy,orgAabbMax.fz,0.f);\n"
+	"		float4 halfExtents = 0.5f*(argAabbMaxVec-argAabbMinVec);\n"
+	"		\n"
+	"		pAABB[nodeId*2].fx = position.x-halfExtents.x;\n"
+	"		pAABB[nodeId*2].fy = position.y-halfExtents.y;\n"
+	"		pAABB[nodeId*2].fz = position.z-halfExtents.z;\n"
+	"		pAABB[nodeId*2].uw = orgNodeId;\n"
+	"		pAABB[nodeId*2+1].fx = position.x+halfExtents.x;\n"
+	"		pAABB[nodeId*2+1].fy = position.y+halfExtents.y;\n"
+	"		pAABB[nodeId*2+1].fz = position.z+halfExtents.z;\n"
+	"		pAABB[nodeId*2+1].uw = orgBroadphaseIndex;		\n"
+	"	}\n"
+	"}\n";
diff --git a/engine/inc/bullet/OpenCL/rigidbody/ConcaveScene.h b/engine/inc/bullet/OpenCL/rigidbody/ConcaveScene.h
new file mode 100644
index 00000000..9086858d
--- /dev/null
+++ b/engine/inc/bullet/OpenCL/rigidbody/ConcaveScene.h
@@ -0,0 +1,90 @@
+#ifndef CONCAVE_SCENE_H
+#define CONCAVE_SCENE_H
+
+#include "GpuRigidBodyDemo.h"
+#include "Bullet3Common/b3Vector3.h"
+
+class ConcaveScene : public GpuRigidBodyDemo
+{
+public:
+	ConcaveScene() {}
+	virtual ~ConcaveScene() {}
+	virtual const char* getName()
+	{
+		return "BoxTrimesh";
+	}
+
+	static GpuDemo* MyCreateFunc()
+	{
+		GpuDemo* demo = new ConcaveScene;
+		return demo;
+	}
+
+	virtual void setupScene(const ConstructionInfo& ci);
+
+	virtual void createDynamicObjects(const ConstructionInfo& ci);
+
+	virtual void createConcaveMesh(const ConstructionInfo& ci, const char* fileName, const b3Vector3& shift, const b3Vector3& scaling);
+};
+
+class ConcaveSphereScene : public ConcaveScene
+{
+public:
+	ConcaveSphereScene() {}
+	virtual ~ConcaveSphereScene() {}
+	virtual const char* getName()
+	{
+		return "SphereTrimesh";
+	}
+
+	static GpuDemo* MyCreateFunc()
+	{
+		GpuDemo* demo = new ConcaveSphereScene;
+		return demo;
+	}
+
+	virtual void setupScene(const ConstructionInfo& ci);
+
+	virtual void createDynamicObjects(const ConstructionInfo& ci);
+};
+
+class ConcaveCompoundScene : public ConcaveScene
+{
+public:
+	ConcaveCompoundScene() {}
+	virtual ~ConcaveCompoundScene() {}
+	virtual const char* getName()
+	{
+		return "CompoundConcave";
+	}
+
+	static GpuDemo* MyCreateFunc()
+	{
+		GpuDemo* demo = new ConcaveCompoundScene;
+		return demo;
+	}
+
+	virtual void setupScene(const ConstructionInfo& ci);
+
+	virtual void createDynamicObjects(const ConstructionInfo& ci);
+};
+
+class ConcaveCompound2Scene : public ConcaveCompoundScene
+{
+public:
+	ConcaveCompound2Scene() {}
+	virtual ~ConcaveCompound2Scene() {}
+	virtual const char* getName()
+	{
+		return "GRBConcave2Compound";
+	}
+
+	static GpuDemo* MyCreateFunc()
+	{
+		GpuDemo* demo = new ConcaveCompound2Scene;
+		return demo;
+	}
+	virtual void createDynamicObjects(const ConstructionInfo& ci);
+};
+
+#endif  //CONCAVE_SCENE_H
diff --git a/engine/inc/bullet/OpenCL/rigidbody/GpuCompoundScene.h b/engine/inc/bullet/OpenCL/rigidbody/GpuCompoundScene.h
new file mode 100644
index 00000000..6e8d1508
--- /dev/null
+++ b/engine/inc/bullet/OpenCL/rigidbody/GpuCompoundScene.h
@@ -0,0 +1,45 @@
+#ifndef GPU_COMPOUND_SCENE_H
+#define GPU_COMPOUND_SCENE_H
+
+#include "GpuRigidBodyDemo.h"
+
+class GpuCompoundScene : public GpuRigidBodyDemo
+{
+public:
+	GpuCompoundScene() {}
+	virtual ~GpuCompoundScene() {}
+	virtual const char* getName()
+	{
+		return "CompoundOnSphere";
+	}
+
+	static GpuDemo* MyCreateFunc()
+	{
+		GpuDemo* demo = new GpuCompoundScene;
+		return demo;
+	}
+
+	virtual void setupScene(const ConstructionInfo& ci);
+
+	virtual void createStaticEnvironment(const ConstructionInfo& ci);
+};
+
+class GpuCompoundPlaneScene : public GpuCompoundScene
+{
+public:
+	GpuCompoundPlaneScene() {}
+	virtual ~GpuCompoundPlaneScene() {}
+	virtual const char* getName()
+	{
+		return "CompoundOnPlane";
+	}
+
+	static GpuDemo* MyCreateFunc()
+	{
+		GpuDemo* demo = new GpuCompoundPlaneScene;
+		return demo;
+	}
+
+	virtual void createStaticEnvironment(const ConstructionInfo& ci);
+};
+#endif  //GPU_COMPOUND_SCENE_H
diff --git a/engine/inc/bullet/OpenCL/rigidbody/GpuConvexScene.h b/engine/inc/bullet/OpenCL/rigidbody/GpuConvexScene.h
new file mode 100644
index 00000000..6aea434b
--- /dev/null
+++ b/engine/inc/bullet/OpenCL/rigidbody/GpuConvexScene.h
@@ -0,0 +1,6 @@
+#ifndef GPU_CONVEX_SCENE_H
+#define GPU_CONVEX_SCENE_H
+
+class CommonExampleInterface* OpenCLBoxBoxCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //GPU_CONVEX_SCENE_H
diff --git a/engine/inc/bullet/OpenCL/rigidbody/GpuRigidBodyDemo.h b/engine/inc/bullet/OpenCL/rigidbody/GpuRigidBodyDemo.h
new file mode 100644
index 00000000..3eabc38d
--- /dev/null
+++ b/engine/inc/bullet/OpenCL/rigidbody/GpuRigidBodyDemo.h
@@ -0,0 +1,43 @@
+#ifndef GPU_RIGID_BODY_DEMO_H
+#define GPU_RIGID_BODY_DEMO_H
+
+#include "Bullet3Common/b3Vector3.h"
+#include "../CommonOpenCL/CommonOpenCLBase.h"
+
+class GpuRigidBodyDemo : public CommonOpenCLBase
+{
+protected:
+	class GLInstancingRenderer* m_instancingRenderer;
+	class GLPrimitiveRenderer* m_primRenderer;
+	class CommonWindowInterface* m_window;
+
+	struct GpuRigidBodyDemoInternalData* m_data;
+
+public:
+	GpuRigidBodyDemo(GUIHelperInterface* helper);
+	virtual ~GpuRigidBodyDemo();
+
+	virtual void initPhysics();
+
+	virtual void setupScene();
+
+	virtual void destroyScene(){};
+
+	virtual void exitPhysics();
+
+	virtual void renderScene();
+
+	void resetCamera();
+
+	virtual void stepSimulation(float deltaTime);
+
+	//for picking
+	b3Vector3 getRayTo(int x, int y);
+	virtual bool mouseMoveCallback(float x, float y);
+	virtual bool mouseButtonCallback(int button, int state, float x, float y);
+	virtual bool keyboardCallback(int key, int state);
+
+	unsigned char* loadImage(const char* fileName, int& width, int& height, int& n);
+};
+
+#endif  //GPU_RIGID_BODY_DEMO_H
diff --git a/engine/inc/bullet/OpenCL/rigidbody/GpuRigidBodyDemoInternalData.h b/engine/inc/bullet/OpenCL/rigidbody/GpuRigidBodyDemoInternalData.h
new file mode 100644
index 00000000..9e56fc59
--- /dev/null
+++ b/engine/inc/bullet/OpenCL/rigidbody/GpuRigidBodyDemoInternalData.h
@@ -0,0 +1,56 @@
+#ifndef GPU_RIGIDBODY_INTERNAL_DATA_H
+#define GPU_RIGIDBODY_INTERNAL_DATA_H
+
+#include "Bullet3OpenCL/Initialize/b3OpenCLUtils.h"
+#include "Bullet3OpenCL/ParallelPrimitives/b3OpenCLArray.h"
+#include "Bullet3Common/b3Vector3.h"
+#include "Bullet3Collision/NarrowPhaseCollision/b3Config.h"
+
+struct GpuRigidBodyDemoInternalData
+{
+	cl_kernel m_copyTransformsToVBOKernel;
+
+	b3OpenCLArray<b3Vector4>* m_instancePosOrnColor;
+
+	class b3GpuRigidBodyPipeline* m_rigidBodyPipeline;
+
+	class b3GpuNarrowPhase* m_np;
+	class b3GpuBroadphaseInterface* m_bp;
+	struct b3DynamicBvhBroadphase* m_broadphaseDbvt;
+
+	b3Vector3 m_pickPivotInA;
+	b3Vector3 m_pickPivotInB;
+	float m_pickDistance;
+	int m_pickBody;
+	int m_pickConstraint;
+
+	int m_altPressed;
+	int m_controlPressed;
+
+	int m_pickFixedBody;
+	int m_pickGraphicsShapeIndex;
+	int m_pickGraphicsShapeInstance;
+	b3Config m_config;
+	GUIHelperInterface* m_guiHelper;
+
+	GpuRigidBodyDemoInternalData()
+		: m_instancePosOrnColor(0),
+		  m_copyTransformsToVBOKernel(0),
+		  m_rigidBodyPipeline(0),
+		  m_np(0),
+		  m_bp(0),
+		  m_broadphaseDbvt(0),
+		  m_pickConstraint(-1),
+		  m_pickFixedBody(-1),
+		  m_pickGraphicsShapeIndex(-1),
+		  m_pickGraphicsShapeInstance(-1),
+		  m_pickBody(-1),
+		  m_altPressed(0),
+		  m_controlPressed(0),
+		  m_guiHelper(0)
+
+	{
+	}
+};
+
+#endif  //GPU_RIGIDBODY_INTERNAL_DATA_H
diff --git a/engine/inc/bullet/OpenCL/rigidbody/GpuSphereScene.h b/engine/inc/bullet/OpenCL/rigidbody/GpuSphereScene.h
new file mode 100644
index 00000000..bc2e0014
--- /dev/null
+++ b/engine/inc/bullet/OpenCL/rigidbody/GpuSphereScene.h
@@ -0,0 +1,25 @@
+#ifndef GPU_SPHERE_SCENE_H
+#define GPU_SPHERE_SCENE_H
+
+#include "GpuRigidBodyDemo.h"
+
+class GpuSphereScene : public GpuRigidBodyDemo
+{
+public:
+	GpuSphereScene() {}
+	virtual ~GpuSphereScene() {}
+	virtual const char* getName()
+	{
+		return "BoxOnSphere";
+	}
+
+	static GpuDemo* MyCreateFunc()
+	{
+		GpuDemo* demo = new GpuSphereScene;
+		return demo;
+	}
+
+	virtual void setupScene(const ConstructionInfo& ci);
+};
+
+#endif  //GPU_SPHERE_SCENE_H
diff --git a/engine/inc/bullet/OpenGLWindow/EGLOpenGLWindow.h b/engine/inc/bullet/OpenGLWindow/EGLOpenGLWindow.h
new file mode 100644
index 00000000..54b86fc2
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/EGLOpenGLWindow.h
@@ -0,0 +1,71 @@
+#ifndef EGL_OPENGL_WINDOW_H
+#define EGL_OPENGL_WINDOW_H
+
+#ifdef BT_USE_EGL
+
+#include "../CommonInterfaces/CommonWindowInterface.h"
+
+class EGLOpenGLWindow : public CommonWindowInterface
+{
+	struct EGLInternalData2* m_data;
+	bool m_OpenGLInitialized;
+	bool m_requestedExit;
+
+public:
+	EGLOpenGLWindow();
+	virtual ~EGLOpenGLWindow();
+
+	virtual void createDefaultWindow(int width, int height, const char* title)
+	{
+		b3gWindowConstructionInfo ci(width, height);
+		ci.m_title = title;
+		createWindow(ci);
+	}
+
+	virtual void createWindow(const b3gWindowConstructionInfo& ci);
+
+	virtual void closeWindow();
+
+	virtual void runMainLoop();
+	virtual float getTimeInSeconds();
+
+	virtual bool requestedExit() const;
+	virtual void setRequestExit();
+
+	virtual void startRendering();
+
+	virtual void endRendering();
+
+	virtual bool isModifierKeyPressed(int key);
+
+	virtual void setMouseMoveCallback(b3MouseMoveCallback mouseCallback);
+	virtual b3MouseMoveCallback getMouseMoveCallback();
+
+	virtual void setMouseButtonCallback(b3MouseButtonCallback mouseCallback);
+	virtual b3MouseButtonCallback getMouseButtonCallback();
+
+	virtual void setResizeCallback(b3ResizeCallback resizeCallback);
+	virtual b3ResizeCallback getResizeCallback();
+
+	virtual void setWheelCallback(b3WheelCallback wheelCallback);
+	virtual b3WheelCallback getWheelCallback();
+
+	virtual void setKeyboardCallback(b3KeyboardCallback keyboardCallback);
+	virtual b3KeyboardCallback getKeyboardCallback();
+
+	virtual void setRenderCallback(b3RenderCallback renderCallback);
+
+	virtual void setWindowTitle(const char* title);
+
+	virtual float getRetinaScale() const;
+	virtual void setAllowRetina(bool allow);
+
+	virtual int getWidth() const;
+	virtual int getHeight() const;
+
+	virtual int fileOpenDialog(char* fileName, int maxFileNameLength);
+};
+
+#endif  //BT_USE_EGL
+
+#endif  //EGL_OPENGL_WINDOW_H
diff --git a/engine/inc/bullet/OpenGLWindow/GLFWOpenGLWindow.h b/engine/inc/bullet/OpenGLWindow/GLFWOpenGLWindow.h
new file mode 100644
index 00000000..69ab5461
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/GLFWOpenGLWindow.h
@@ -0,0 +1,72 @@
+
+#ifndef GLFW_OPENGL_WINDOW_H
+#define GLFW_OPENGL_WINDOW_H
+
+#ifdef B3_USE_GLFW
+
+#include "../CommonInterfaces/CommonWindowInterface.h"
+
+#define b3gDefaultOpenGLWindow GLFWOpenGLWindow
+
+class GLFWOpenGLWindow : public CommonWindowInterface
+{
+	struct GLFWOpenGLWindowInternalData* m_data;
+
+protected:
+public:
+	GLFWOpenGLWindow();
+
+	virtual ~GLFWOpenGLWindow();
+
+	virtual void createDefaultWindow(int width, int height, const char* title);
+
+	virtual void createWindow(const b3gWindowConstructionInfo& ci);
+
+	virtual void closeWindow();
+
+	virtual void runMainLoop();
+	virtual float getTimeInSeconds();
+
+	virtual bool requestedExit() const;
+	virtual void setRequestExit();
+
+	virtual void startRendering();
+
+	virtual void endRendering();
+
+	virtual bool isModifierKeyPressed(int key);
+
+	virtual void setMouseMoveCallback(b3MouseMoveCallback mouseCallback);
+	virtual b3MouseMoveCallback getMouseMoveCallback();
+
+	virtual void setMouseButtonCallback(b3MouseButtonCallback mouseCallback);
+	virtual b3MouseButtonCallback getMouseButtonCallback();
+
+	virtual void setResizeCallback(b3ResizeCallback resizeCallback);
+	virtual b3ResizeCallback getResizeCallback();
+
+	virtual void setWheelCallback(b3WheelCallback wheelCallback);
+	virtual b3WheelCallback getWheelCallback();
+
+	virtual void setKeyboardCallback(b3KeyboardCallback keyboardCallback);
+	virtual b3KeyboardCallback getKeyboardCallback();
+
+	virtual void setRenderCallback(b3RenderCallback renderCallback);
+
+	virtual void setWindowTitle(const char* title);
+
+	virtual float getRetinaScale() const;
+	virtual void setAllowRetina(bool allow);
+
+	virtual int getWidth() const;
+	virtual int getHeight() const;
+
+	virtual int fileOpenDialog(char* fileName, int maxFileNameLength);
+
+	void keyboardCallbackInternal(int key, int state);
+	void mouseButtonCallbackInternal(int button, int state);
+	void mouseCursorCallbackInternal(double xPos, double yPos);
+	void resizeInternal(int width, int height);
+};
+#endif  //B3_USE_GLFW
+#endif  //GLFW_OPENGL_WINDOW_H
diff --git a/engine/inc/bullet/OpenGLWindow/GLInstanceGraphicsShape.h b/engine/inc/bullet/OpenGLWindow/GLInstanceGraphicsShape.h
new file mode 100644
index 00000000..ce1781e5
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/GLInstanceGraphicsShape.h
@@ -0,0 +1,33 @@
+#ifndef GL_INSTANCE_GRAPHICS_SHAPE_H
+#define GL_INSTANCE_GRAPHICS_SHAPE_H
+
+#include "Bullet3Common/b3AlignedObjectArray.h"
+
+struct GLInstanceVertex
+{
+	float xyzw[4];
+	float normal[3];
+	float uv[2];
+};
+struct GLInstanceGraphicsShape
+{
+	b3AlignedObjectArray<GLInstanceVertex>* m_vertices;
+	int m_numvertices;
+	b3AlignedObjectArray<int>* m_indices;
+	int m_numIndices;
+	float m_scaling[4];
+
+	GLInstanceGraphicsShape()
+		: m_vertices(0),
+		  m_indices(0)
+	{
+	}
+
+	virtual ~GLInstanceGraphicsShape()
+	{
+		delete m_vertices;
+		delete m_indices;
+	}
+};
+
+#endif  //GL_INSTANCE_GRAPHICS_SHAPE_H
diff --git a/engine/inc/bullet/OpenGLWindow/GLInstanceRendererInternalData.h b/engine/inc/bullet/OpenGLWindow/GLInstanceRendererInternalData.h
new file mode 100644
index 00000000..41a22a36
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/GLInstanceRendererInternalData.h
@@ -0,0 +1,21 @@
+#ifndef GL_INSTANCE_RENDERER_INTERNAL_DATA_H
+#define GL_INSTANCE_RENDERER_INTERNAL_DATA_H
+
+#include "OpenGLInclude.h"
+#include "Bullet3Common/b3AlignedObjectArray.h"
+
+struct GLInstanceRendererInternalData
+{
+	b3AlignedObjectArray<GLfloat> m_instance_positions_ptr;
+	b3AlignedObjectArray<GLfloat> m_instance_quaternion_ptr;
+	b3AlignedObjectArray<GLfloat> m_instance_colors_ptr;
+	b3AlignedObjectArray<GLfloat> m_instance_scale_ptr;
+
+	int m_vboSize;
+	GLuint m_vbo;
+	int m_totalNumInstances;
+	int m_maxNumObjectCapacity;
+	int m_maxShapeCapacityInBytes;
+};
+
+#endif  //GL_INSTANCE_RENDERER_INTERNAL_DATA_H
diff --git a/engine/inc/bullet/OpenGLWindow/GLInstancingRenderer.h b/engine/inc/bullet/OpenGLWindow/GLInstancingRenderer.h
new file mode 100644
index 00000000..71575821
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/GLInstancingRenderer.h
@@ -0,0 +1,156 @@
+/*
+Copyright (c) 2012 Advanced Micro Devices, Inc.  
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+//Originally written by Erwin Coumans
+
+#ifndef GL_INSTANCING_RENDERER_H
+#define GL_INSTANCING_RENDERER_H
+
+#include "Bullet3Common/b3AlignedObjectArray.h"
+#include "../CommonInterfaces/CommonRenderInterface.h"
+#include "SimpleCamera.h"
+
+class GLInstancingRenderer : public CommonRenderInterface
+{
+	b3AlignedObjectArray<struct b3GraphicsInstance*> m_graphicsInstances;
+
+	struct InternalDataRenderer* m_data;
+
+	bool m_textureenabled;
+	bool m_textureinitialized;
+
+	int m_screenWidth;
+	int m_screenHeight;
+
+	int m_upAxis;
+
+	int m_planeReflectionShapeIndex;
+
+	int registerGraphicsInstanceInternal(int shapeIndex, const float* position, const float* quaternion, const float* color, const float* scaling);
+	void rebuildGraphicsInstances();
+
+public:
+	GLInstancingRenderer(int m_maxObjectCapacity, int maxShapeCapacityInBytes = 56 * 1024 * 1024);
+	virtual ~GLInstancingRenderer();
+
+	virtual void init();
+
+	virtual void renderScene();
+	virtual void renderSceneInternal(int orgRenderMode = B3_DEFAULT_RENDERMODE);
+
+	void InitShaders();
+	void CleanupShaders();
+	virtual void removeAllInstances();
+	virtual void removeGraphicsInstance(int instanceUid);
+
+	virtual void updateShape(int shapeIndex, const float* vertices, int numVertices);
+
+	///vertices must be in the format x,y,z, nx,ny,nz, u,v
+	virtual int registerShape(const float* vertices, int numvertices, const int* indices, int numIndices, int primitiveType = B3_GL_TRIANGLES, int textureIndex = -1);
+
+	virtual int registerTexture(const unsigned char* texels, int width, int height, bool flipPixelsY = true);
+	virtual void updateTexture(int textureIndex, const unsigned char* texels, bool flipPixelsY = true);
+	virtual void activateTexture(int textureIndex);
+	virtual void replaceTexture(int shapeIndex, int textureId);
+	virtual int getShapeIndexFromInstance(int srcIndex);
+	virtual void removeTexture(int textureIndex);
+
+	///position x,y,z, quaternion x,y,z,w, color r,g,b,a, scaling x,y,z
+	virtual int registerGraphicsInstance(int shapeIndex, const float* position, const float* quaternion, const float* color, const float* scaling);
+	virtual int registerGraphicsInstance(int shapeIndex, const double* position, const double* quaternion, const double* color, const double* scaling);
+
+	void writeTransforms();
+
+	virtual bool readSingleInstanceTransformToCPU(float* position, float* orientation, int srcIndex);
+
+	virtual void writeSingleInstanceTransformToCPU(const float* position, const float* orientation, int srcIndex);
+	virtual void writeSingleInstanceTransformToCPU(const double* position, const double* orientation, int srcIndex)
+	{
+		float pos[4];
+		float orn[4];
+		pos[0] = (float)position[0];
+		pos[1] = (float)position[1];
+		pos[2] = (float)position[2];
+		pos[3] = (float)position[3];
+		orn[0] = (float)orientation[0];
+		orn[1] = (float)orientation[1];
+		orn[2] = (float)orientation[2];
+		orn[3] = (float)orientation[3];
+		writeSingleInstanceTransformToCPU(pos, orn, srcIndex);
+	}
+
+	virtual void readSingleInstanceTransformFromCPU(int srcIndex, float* position, float* orientation);
+
+	virtual void writeSingleInstanceTransformToGPU(float* position, float* orientation, int srcIndex);
+
+	virtual void writeSingleInstanceColorToCPU(const float* color, int srcIndex);
+	virtual void writeSingleInstanceColorToCPU(const double* color, int srcIndex);
+	virtual void writeSingleInstanceFlagsToCPU(int flags, int srcIndex2);
+
+	virtual void writeSingleInstanceSpecularColorToCPU(const double* specular, int srcIndex2);
+	virtual void writeSingleInstanceSpecularColorToCPU(const float* specular, int srcIndex2);
+
+	virtual void writeSingleInstanceScaleToCPU(const float* scale, int srcIndex);
+	virtual void writeSingleInstanceScaleToCPU(const double* scale, int srcIndex);
+
+	virtual struct GLInstanceRendererInternalData* getInternalData();
+
+	virtual void drawLine(const float from[4], const float to[4], const float color[4], float lineWidth = 1);
+	virtual void drawLine(const double from[4], const double to[4], const double color[4], double lineWidth = 1);
+	virtual void drawLines(const float* positions, const float color[4], int numPoints, int pointStrideInBytes, const unsigned int* indices, int numIndices, float pointDrawSize);
+	virtual void drawPoints(const float* positions, const float color[4], int numPoints, int pointStrideInBytes, float pointDrawSize);
+	virtual void drawPoint(const float* position, const float color[4], float pointSize = 1);
+	virtual void drawPoint(const double* position, const double color[4], double pointDrawSize = 1);
+	virtual void drawTexturedTriangleMesh(float worldPosition[3], float worldOrientation[4], const float* vertices, int numvertices, const unsigned int* indices, int numIndices, float color[4], int textureIndex = -1, int vertexLayout = 0);
+
+	virtual void updateCamera(int upAxis = 1);
+
+	virtual const CommonCameraInterface* getActiveCamera() const;
+	virtual CommonCameraInterface* getActiveCamera();
+	virtual void setActiveCamera(CommonCameraInterface* cam);
+
+	virtual void setLightPosition(const float lightPos[3]);
+	virtual void setLightPosition(const double lightPos[3]);
+	virtual void setShadowMapResolution(int shadowMapResolution);
+	virtual void setShadowMapIntensity(double shadowMapIntensity);
+	virtual void setShadowMapWorldSize(float worldSize);
+	void setLightSpecularIntensity(const float lightSpecularIntensity[3]);
+	virtual void setProjectiveTextureMatrices(const float viewMatrix[16], const float projectionMatrix[16]);
+	virtual void setProjectiveTexture(bool useProjectiveTexture);
+
+	virtual void resize(int width, int height);
+	virtual int getScreenWidth()
+	{
+		return m_screenWidth;
+	}
+	virtual int getScreenHeight()
+	{
+		return m_screenHeight;
+	}
+
+	virtual int getMaxShapeCapacity() const;
+
+	virtual int getInstanceCapacity() const;
+
+	virtual int getTotalNumInstances() const;
+
+	virtual void enableShadowMap();
+
+	virtual void setPlaneReflectionShapeIndex(int index);
+
+	virtual void clearZBuffer();
+
+	virtual void setRenderFrameBuffer(unsigned int renderFrameBuffer);
+};
+
+#endif  //GL_INSTANCING_RENDERER_H
diff --git a/engine/inc/bullet/OpenGLWindow/GLPrimInternalData.h b/engine/inc/bullet/OpenGLWindow/GLPrimInternalData.h
new file mode 100644
index 00000000..144732c0
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/GLPrimInternalData.h
@@ -0,0 +1,26 @@
+#ifndef PRIM_INTERNAL_DATA
+#define PRIM_INTERNAL_DATA
+
+#include "OpenGLInclude.h"
+
+struct PrimInternalData
+{
+	GLuint m_shaderProg;
+	GLint m_viewmatUniform;
+	GLint m_projMatUniform;
+	GLint m_positionUniform;
+	GLint m_colourAttribute;
+	GLint m_positionAttribute;
+	GLint m_textureAttribute;
+	GLuint m_vertexBuffer;
+	GLuint m_vertexBuffer2;
+
+	GLuint m_vertexArrayObject;
+	GLuint m_vertexArrayObject2;
+
+	GLuint m_indexBuffer;
+	GLuint m_indexBuffer2;
+	GLuint m_texturehandle;
+};
+
+#endif  //PRIM_INTERNAL_DATA
diff --git a/engine/inc/bullet/OpenGLWindow/GLPrimitiveRenderer.h b/engine/inc/bullet/OpenGLWindow/GLPrimitiveRenderer.h
new file mode 100644
index 00000000..5a5d70e7
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/GLPrimitiveRenderer.h
@@ -0,0 +1,82 @@
+#ifndef _GL_PRIMITIVE_RENDERER_H
+#define _GL_PRIMITIVE_RENDERER_H
+
+//#include "OpenGLInclude.h"
+
+struct PrimVec2
+{
+	PrimVec2()
+	{
+	}
+	PrimVec2(float x, float y)
+	{
+		p[0] = x;
+		p[1] = y;
+	}
+	float p[2];
+};
+
+struct PrimVec4
+{
+	PrimVec4() {}
+	PrimVec4(float x, float y, float z, float w)
+	{
+		p[0] = x;
+		p[1] = y;
+		p[2] = z;
+		p[3] = w;
+	}
+
+	float p[4];
+};
+
+struct PrimVertex
+{
+	PrimVertex(const PrimVec4& p, const PrimVec4& c, const PrimVec2& u)
+		: position(p),
+		  colour(c),
+		  uv(u)
+	{
+	}
+
+	PrimVertex()
+	{
+	}
+	PrimVec4 position;
+	PrimVec4 colour;
+	PrimVec2 uv;
+};
+
+class GLPrimitiveRenderer
+{
+	int m_screenWidth;
+	int m_screenHeight;
+
+	struct PrimInternalData* m_data;
+	struct PrimInternalData2* m_data2;
+	void loadBufferData();
+
+public:
+	GLPrimitiveRenderer(int screenWidth, int screenHeight);
+	virtual ~GLPrimitiveRenderer();
+
+	void drawRect(float x0, float y0, float x1, float y1, float color[4]);
+	void drawTexturedRect(float x0, float y0, float x1, float y1, float color[4], float u0, float v0, float u1, float v1, int useRGBA = 0);
+	void drawTexturedRect3D(const PrimVertex& v0, const PrimVertex& v1, const PrimVertex& v2, const PrimVertex& v3, float viewMat[16], float projMat[16], bool useRGBA = true);
+	void drawLine();  //float from[4], float to[4], float color[4]);
+	void setScreenSize(int width, int height);
+
+	void drawTexturedRect2(float x0, float y0, float x1, float y1, float color[4], float u0, float v0, float u1, float v1, int useRGBA = 0);
+	void drawTexturedRect2a(float x0, float y0, float x1, float y1, float color[4], float u0, float v0, float u1, float v1, int useRGBA = 0);
+	void flushBatchedRects();
+
+	void drawTexturedRect3D2Text(bool useRGBA = true);
+	void drawTexturedRect3D2(PrimVertex* vertices, int numVertices, bool useRGBA = true);
+
+	PrimInternalData* getData()
+	{
+		return m_data;
+	}
+};
+
+#endif  //_GL_PRIMITIVE_RENDERER_H
diff --git a/engine/inc/bullet/OpenGLWindow/GLRenderToTexture.h b/engine/inc/bullet/OpenGLWindow/GLRenderToTexture.h
new file mode 100644
index 00000000..081f2ec9
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/GLRenderToTexture.h
@@ -0,0 +1,30 @@
+
+#ifndef GL_RENDER_TO_TEXTURE_H
+#define GL_RENDER_TO_TEXTURE_H
+
+///See http://www.opengl-tutorial.org/intermediate-tutorials/tutorial-14-render-to-texture/
+#include "OpenGLInclude.h"
+
+enum
+{
+	RENDERTEXTURE_COLOR = 1,
+	RENDERTEXTURE_DEPTH,
+};
+struct GLRenderToTexture
+{
+	GLuint m_framebufferName;
+	GLuint m_depthrenderbuffer;
+	bool m_initialized;
+	int m_renderTextureType;
+
+public:
+	GLRenderToTexture();
+
+	void init(int width, int height, GLuint textureId, int renderTextureType = RENDERTEXTURE_COLOR);
+	bool enable();
+	void disable();
+
+	virtual ~GLRenderToTexture();
+};
+
+#endif  //GL_RENDER_TO_TEXTURE_H
diff --git a/engine/inc/bullet/OpenGLWindow/GwenOpenGL3CoreRenderer.h b/engine/inc/bullet/OpenGLWindow/GwenOpenGL3CoreRenderer.h
new file mode 100644
index 00000000..b28a45f8
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/GwenOpenGL3CoreRenderer.h
@@ -0,0 +1,372 @@
+
+#ifndef __GWEN_OPENGL3_CORE_RENDERER_H
+#define __GWEN_OPENGL3_CORE_RENDERER_H
+
+#include "Gwen/Gwen.h"
+#include "Gwen/BaseRender.h"
+#include "GLPrimitiveRenderer.h"
+#include "../OpenGLWindow/OpenGLInclude.h"
+
+struct sth_stash;
+#include "fontstash.h"
+#include "Gwen/Texture.h"
+
+#include "TwFonts.h"
+static float extraSpacing = 0.;  //6f;
+#include <assert.h>
+#include <math.h>
+
+template <class T>
+inline void MyClamp(T& a, const T& lb, const T& ub)
+{
+	if (a < lb)
+	{
+		a = lb;
+	}
+	else if (ub < a)
+	{
+		a = ub;
+	}
+}
+
+static GLuint BindFont(const CTexFont* _Font)
+{
+	GLuint TexID = 0;
+	glGenTextures(1, &TexID);
+	glBindTexture(GL_TEXTURE_2D, TexID);
+	glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);
+	glPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE);
+	glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+	glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
+	glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
+	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, _Font->m_TexWidth, _Font->m_TexHeight, 0, GL_RED, GL_UNSIGNED_BYTE, _Font->m_TexBytes);
+	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+	glBindTexture(GL_TEXTURE_2D, 0);
+
+	return TexID;
+}
+
+struct MyTextureLoader
+{
+	virtual ~MyTextureLoader()
+	{
+	}
+	virtual void LoadTexture(Gwen::Texture* pTexture) = 0;
+	virtual void FreeTexture(Gwen::Texture* pTexture) = 0;
+};
+
+class GwenOpenGL3CoreRenderer : public Gwen::Renderer::Base
+{
+	GLPrimitiveRenderer* m_primitiveRenderer;
+	float m_currentColor[4];
+	float m_yOffset;
+	sth_stash* m_font;
+	float m_screenWidth;
+	float m_screenHeight;
+	float m_fontScaling;
+	float m_retinaScale;
+	bool m_useTrueTypeFont;
+	const CTexFont* m_currentFont;
+
+	GLuint m_fontTextureId;
+	MyTextureLoader* m_textureLoader;
+
+public:
+	GwenOpenGL3CoreRenderer(GLPrimitiveRenderer* primRender, sth_stash* font, float screenWidth, float screenHeight, float retinaScale, MyTextureLoader* loader = 0)
+		: m_primitiveRenderer(primRender),
+		  m_font(font),
+		  m_screenWidth(screenWidth),
+		  m_screenHeight(screenHeight),
+		  m_retinaScale(retinaScale),
+		  m_useTrueTypeFont(false),
+		  m_textureLoader(loader)
+	{
+		///only enable true type fonts on Macbook Retina, it looks gorgeous
+		if (retinaScale == 2.0f)
+		{
+			m_useTrueTypeFont = true;
+		}
+		m_currentColor[0] = 1;
+		m_currentColor[1] = 1;
+		m_currentColor[2] = 1;
+		m_currentColor[3] = 1;
+
+		m_fontScaling = 16.f * m_retinaScale;
+
+		TwGenerateDefaultFonts();
+
+		m_currentFont = g_DefaultNormalFont;
+		//m_currentFont = g_DefaultNormalFontAA;
+
+		//m_currentFont = g_DefaultLargeFont;
+		m_fontTextureId = BindFont(m_currentFont);
+	}
+
+	virtual ~GwenOpenGL3CoreRenderer()
+	{
+		TwDeleteDefaultFonts();
+	}
+	virtual void Resize(int width, int height)
+	{
+		m_screenWidth = width;
+		m_screenHeight = height;
+	}
+
+	virtual void Begin()
+	{
+		m_yOffset = 0;
+		glEnable(GL_BLEND);
+		assert(glGetError() == GL_NO_ERROR);
+
+		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+		assert(glGetError() == GL_NO_ERROR);
+
+		assert(glGetError() == GL_NO_ERROR);
+
+		glDisable(GL_DEPTH_TEST);
+		assert(glGetError() == GL_NO_ERROR);
+		//glColor4ub(255,0,0,255);
+
+		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+		//	saveOpenGLState(width,height);//m_glutScreenWidth,m_glutScreenHeight);
+
+		assert(glGetError() == GL_NO_ERROR);
+
+		glDisable(GL_CULL_FACE);
+
+		glDisable(GL_DEPTH_TEST);
+		assert(glGetError() == GL_NO_ERROR);
+
+		glEnable(GL_BLEND);
+
+		assert(glGetError() == GL_NO_ERROR);
+	}
+	virtual void End()
+	{
+		glDisable(GL_BLEND);
+	}
+
+	virtual void StartClip()
+	{
+		if (m_useTrueTypeFont)
+			sth_flush_draw(m_font);
+		Gwen::Rect rect = ClipRegion();
+
+		// OpenGL's coords are from the bottom left
+		// so we need to translate them here.
+		{
+			GLint view[4];
+			glGetIntegerv(GL_VIEWPORT, &view[0]);
+			rect.y = view[3] / m_retinaScale - (rect.y + rect.h);
+		}
+
+		glScissor(m_retinaScale * rect.x * Scale(), m_retinaScale * rect.y * Scale(), m_retinaScale * rect.w * Scale(), m_retinaScale * rect.h * Scale());
+		glEnable(GL_SCISSOR_TEST);
+		//glDisable( GL_SCISSOR_TEST );
+	};
+
+	virtual void EndClip()
+	{
+		if (m_useTrueTypeFont)
+			sth_flush_draw(m_font);
+		glDisable(GL_SCISSOR_TEST);
+	};
+
+	virtual void SetDrawColor(Gwen::Color color)
+	{
+		m_currentColor[0] = color.r / 256.f;
+		m_currentColor[1] = color.g / 256.f;
+		m_currentColor[2] = color.b / 256.f;
+		m_currentColor[3] = color.a / 256.f;
+	}
+	virtual void DrawFilledRect(Gwen::Rect rect)
+	{
+		//		BT_PROFILE("GWEN_DrawFilledRect");
+		Translate(rect);
+
+		m_primitiveRenderer->drawRect(rect.x, rect.y + m_yOffset,
+									  rect.x + rect.w, rect.y + rect.h + m_yOffset, m_currentColor);
+
+		//		m_primitiveRenderer->drawTexturedRect2a(rect.x, rect.y+m_yOffset,
+		//		rect.x+rect.w, rect.y+rect.h+m_yOffset, m_currentColor,0,0,1,1);
+		//		m_yOffset+=rect.h+10;
+	}
+
+	void RenderText(Gwen::Font* pFont, Gwen::Point rasterPos, const Gwen::UnicodeString& text)
+	{
+		//		BT_PROFILE("GWEN_RenderText");
+
+		Gwen::String str = Gwen::Utility::UnicodeToString(text);
+		const char* unicodeText = (const char*)str.c_str();
+
+		Gwen::Rect r;
+		r.x = rasterPos.x;
+		r.y = rasterPos.y;
+		r.w = 0;
+		r.h = 0;
+
+		//
+		//printf("str = %s\n",unicodeText);
+		//int xpos=0;
+		//int ypos=0;
+		float dx;
+
+		int measureOnly = 0;
+
+		if (m_useTrueTypeFont)
+		{
+			float yoffset = 0.f;
+			if (m_retinaScale == 2.0f)
+			{
+				yoffset = -12;
+			}
+			Translate(r);
+			sth_draw_text(m_font,
+						  1, m_fontScaling,
+						  r.x, r.y + yoffset,
+						  unicodeText, &dx, m_screenWidth, m_screenHeight, measureOnly, m_retinaScale);
+		}
+		else
+		{
+			//float width = 0.f;
+			int pos = 0;
+			//float color[]={0.2f,0.2,0.2f,1.f};
+
+			glBindTexture(GL_TEXTURE_2D, m_fontTextureId);
+			float width = r.x;
+
+			while (unicodeText[pos])
+			{
+				int c = unicodeText[pos];
+				r.h = m_currentFont->m_CharHeight;
+				r.w = m_currentFont->m_CharWidth[c] + extraSpacing;
+				Gwen::Rect rect = r;
+				Translate(rect);
+
+				m_primitiveRenderer->drawTexturedRect2(rect.x, rect.y + m_yOffset, rect.x + rect.w, rect.y + rect.h + m_yOffset, m_currentColor, m_currentFont->m_CharU0[c], m_currentFont->m_CharV0[c], m_currentFont->m_CharU1[c], m_currentFont->m_CharV1[c]);
+
+				width += r.w;
+				r.x = width;
+				pos++;
+			}
+			{
+				m_primitiveRenderer->drawTexturedRect3D2Text(false);
+			}
+			glBindTexture(GL_TEXTURE_2D, 0);
+		}
+	}
+	Gwen::Point MeasureText(Gwen::Font* pFont, const Gwen::UnicodeString& text)
+	{
+		//		BT_PROFILE("GWEN_MeasureText");
+		Gwen::String str = Gwen::Utility::UnicodeToString(text);
+		const char* unicodeText = (const char*)str.c_str();
+
+		// printf("str = %s\n",unicodeText);
+		int xpos = 0;
+		int ypos = 0;
+
+		int measureOnly = 1;
+		float dx = 0;
+		if (m_useTrueTypeFont)
+		{
+			sth_draw_text(m_font,
+						  1, m_fontScaling,
+						  xpos, ypos,
+						  unicodeText, &dx, m_screenWidth, m_screenHeight, measureOnly);
+
+			Gwen::Point pt;
+
+			if (m_retinaScale == 2.0f)
+			{
+				pt.x = dx * Scale() / 2.f;
+				pt.y = m_fontScaling / 2 * Scale() + 1;
+			}
+			else
+			{
+				pt.x = dx * Scale();
+				pt.y = m_fontScaling * Scale() + 1;
+			}
+			return pt;
+		}
+		else
+		{
+			float width = 0.f;
+			int pos = 0;
+			while (unicodeText[pos])
+			{
+				width += m_currentFont->m_CharWidth[(int)unicodeText[pos]] + extraSpacing;
+				pos++;
+			}
+			Gwen::Point pt;
+			int fontHeight = m_currentFont->m_CharHeight;
+
+			pt.x = width * Scale();
+			pt.y = (fontHeight + 2) * Scale();
+
+			return pt;
+		}
+
+		return Gwen::Renderer::Base::MeasureText(pFont, text);
+	}
+
+	virtual void LoadTexture(Gwen::Texture* pTexture)
+	{
+		if (m_textureLoader)
+			m_textureLoader->LoadTexture(pTexture);
+	}
+	virtual void FreeTexture(Gwen::Texture* pTexture)
+	{
+		if (m_textureLoader)
+			m_textureLoader->FreeTexture(pTexture);
+	}
+
+	virtual void DrawTexturedRect(Gwen::Texture* pTexture, Gwen::Rect rect, float u1 = 0.0f, float v1 = 0.0f, float u2 = 1.0f, float v2 = 1.0f)
+	{
+		//		BT_PROFILE("DrawTexturedRect");
+		Translate(rect);
+
+		//float eraseColor[4] = {0,0,0,0};
+		//m_primitiveRenderer->drawRect(rect.x, rect.y+m_yOffset, rect.x+rect.w, rect.y+rect.h+m_yOffset, eraseColor);
+
+		GLint texHandle = (GLint)pTexture->m_intData;
+		//if (!texHandle)
+		//	return;
+
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D, texHandle);
+		//		glDisable(GL_DEPTH_TEST);
+
+		assert(glGetError() == GL_NO_ERROR);
+
+		/*	bool useFiltering = true;
+	if (useFiltering)
+	{
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	} else
+	{
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+	}
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+*/
+
+		//glEnable(GL_TEXTURE_2D);
+
+		//	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_NONE );
+		static float add = 0.0;
+		//add+=1./512.;//0.01;
+		float color[4] = {1, 1, 1, 1};
+
+		m_primitiveRenderer->drawTexturedRect(rect.x, rect.y + m_yOffset, rect.x + rect.w, rect.y + rect.h + m_yOffset, color, 0 + add, 0, 1 + add, 1, true);
+
+		assert(glGetError() == GL_NO_ERROR);
+	}
+};
+#endif  //__GWEN_OPENGL3_CORE_RENDERER_H
diff --git a/engine/inc/bullet/OpenGLWindow/LoadShader.h b/engine/inc/bullet/OpenGLWindow/LoadShader.h
new file mode 100644
index 00000000..b879a153
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/LoadShader.h
@@ -0,0 +1,17 @@
+#ifndef _LOAD_SHADER_H
+#define _LOAD_SHADER_H
+
+#include "OpenGLInclude.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif  //__cplusplus
+
+	GLuint gltLoadShaderPair(const char *szVertexProg, const char *szFragmentProg);
+
+#ifdef __cplusplus
+}
+#endif  //__cplusplus
+
+#endif  //_LOAD_SHADER_H
diff --git a/engine/inc/bullet/OpenGLWindow/MacOpenGLWindow.h b/engine/inc/bullet/OpenGLWindow/MacOpenGLWindow.h
new file mode 100644
index 00000000..f0bc34be
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/MacOpenGLWindow.h
@@ -0,0 +1,72 @@
+#ifndef MAC_OPENGL_WINDOW_H
+#define MAC_OPENGL_WINDOW_H
+
+#include "../CommonInterfaces/CommonWindowInterface.h"
+
+#define b3gDefaultOpenGLWindow MacOpenGLWindow
+
+class MacOpenGLWindow : public CommonWindowInterface
+{
+	struct MacOpenGLWindowInternalData* m_internalData;
+
+public:
+	MacOpenGLWindow();
+	virtual ~MacOpenGLWindow();
+
+	void init(int width, int height, const char* windowTitle);
+
+	void closeWindow();
+
+	void startRendering();
+
+	void endRendering();  //swap buffers
+
+	virtual bool requestedExit() const;
+
+	virtual void setRequestExit();
+
+	void getMouseCoordinates(int& x, int& y);
+
+	void runMainLoop();
+
+	virtual bool isModifierKeyPressed(int key);
+
+	void setMouseButtonCallback(b3MouseButtonCallback mouseCallback);
+
+	void setMouseMoveCallback(b3MouseMoveCallback mouseCallback);
+
+	void setResizeCallback(b3ResizeCallback resizeCallback);
+
+	void setKeyboardCallback(b3KeyboardCallback keyboardCallback);
+
+	virtual b3MouseMoveCallback getMouseMoveCallback();
+
+	virtual b3MouseButtonCallback getMouseButtonCallback();
+
+	virtual b3ResizeCallback getResizeCallback();
+
+	virtual b3WheelCallback getWheelCallback();
+
+	b3KeyboardCallback getKeyboardCallback();
+
+	void setWheelCallback(b3WheelCallback wheelCallback);
+
+	float getRetinaScale() const;
+
+	virtual void setAllowRetina(bool allow);
+
+	virtual void createWindow(const b3gWindowConstructionInfo& ci);
+
+	virtual float getTimeInSeconds();
+
+	virtual int getWidth() const;
+	virtual int getHeight() const;
+
+	virtual void setRenderCallback(b3RenderCallback renderCallback);
+
+	virtual void setWindowTitle(const char* title);
+
+	int fileOpenDialog(char* filename, int maxNameLength);
+};
+
+#endif
diff --git a/engine/inc/bullet/OpenGLWindow/MacOpenGLWindowObjC.h b/engine/inc/bullet/OpenGLWindow/MacOpenGLWindowObjC.h
new file mode 100644
index 00000000..3b6173d1
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/MacOpenGLWindowObjC.h
@@ -0,0 +1,72 @@
+#ifndef MAC_OPENGL_WINDOW_OBJC_H
+#define MAC_OPENGL_WINDOW_OBJC_H
+
+struct MacOpenGLWindowInternalData;
+
+#include "../CommonInterfaces/CommonCallbacks.h"
+
+struct MacWindowConstructionInfo
+{
+	int m_width;
+	int m_height;
+	int m_fullscreen;
+	int m_colorBitsPerPixel;
+	void* m_windowHandle;
+	const char* m_title;
+	int m_openglVersion;
+	int m_allowRetina;
+};
+
+enum
+{
+	MY_MAC_ALTKEY = 1,
+	MY_MAC_SHIFTKEY = 2,
+	MY_MAC_CONTROL_KEY = 4
+};
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	struct MacOpenGLWindowInternalData* Mac_createData();
+	void Mac_destroyData(struct MacOpenGLWindowInternalData* data);
+
+	int Mac_createWindow(struct MacOpenGLWindowInternalData* m_internalData, struct MacWindowConstructionInfo* ci);
+
+	void Mac_setWindowTitle(struct MacOpenGLWindowInternalData* data, const char* windowTitle);
+	int Mac_updateWindow(struct MacOpenGLWindowInternalData* m_internalData);
+	void Mac_swapBuffer(struct MacOpenGLWindowInternalData* m_internalData);
+	int Mac_requestedExit(struct MacOpenGLWindowInternalData* m_internalData);
+	void Mac_setRequestExit(struct MacOpenGLWindowInternalData* m_internalData);
+	float Mac_getRetinaScale(struct MacOpenGLWindowInternalData* m_internalData);
+	void Mac_setAllowRetina(struct MacOpenGLWindowInternalData* m_internalData, int allow);
+
+	int Mac_getWidth(struct MacOpenGLWindowInternalData* m_internalData);
+	int Mac_getHeight(struct MacOpenGLWindowInternalData* m_internalData);
+
+	int Mac_fileOpenDialog(char* filename, int maxNameLength);
+
+	void Mac_setKeyboardCallback(struct MacOpenGLWindowInternalData* m_internalData, b3KeyboardCallback keyboardCallback);
+	b3KeyboardCallback Mac_getKeyboardCallback(struct MacOpenGLWindowInternalData* m_internalData);
+	int Mac_isModifierKeyPressed(struct MacOpenGLWindowInternalData* m_internalData, int key);
+
+	void Mac_setMouseButtonCallback(struct MacOpenGLWindowInternalData* m_internalData, b3MouseButtonCallback mouseCallback);
+	b3MouseButtonCallback Mac_getMouseButtonCallback(struct MacOpenGLWindowInternalData* m_internalData);
+	void Mac_getMouseCoordinates(struct MacOpenGLWindowInternalData* m_internalData, int* xPtr, int* yPtr);
+	void Mac_setMouseMoveCallback(struct MacOpenGLWindowInternalData* m_internalData, b3MouseMoveCallback mouseCallback);
+	b3MouseMoveCallback Mac_getMouseMoveCallback(struct MacOpenGLWindowInternalData* m_internalData);
+
+	void Mac_setWheelCallback(struct MacOpenGLWindowInternalData* m_internalData, b3WheelCallback wheelCallback);
+	b3WheelCallback Mac_getWheelCallback(struct MacOpenGLWindowInternalData* m_internalData);
+
+	void Mac_setResizeCallback(struct MacOpenGLWindowInternalData* m_internalData, b3ResizeCallback resizeCallback);
+	b3ResizeCallback Mac_getResizeCallback(struct MacOpenGLWindowInternalData* m_internalData);
+
+	//void Mac_setRenderCallback(struct MacOpenGLWindowInternalData* m_internalData, b3RenderCallback renderCallback);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  //MAC_OPENGL_WINDOW_OBJC_H
diff --git a/engine/inc/bullet/OpenGLWindow/OpenGL2Include.h b/engine/inc/bullet/OpenGLWindow/OpenGL2Include.h
new file mode 100644
index 00000000..ce07038e
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/OpenGL2Include.h
@@ -0,0 +1,48 @@
+/*
+Copyright (c) 2012 Advanced Micro Devices, Inc.
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+//Originally written by Erwin Coumans
+
+#ifndef __OPENGL_INCLUDE_H
+#define __OPENGL_INCLUDE_H
+
+#ifdef BT_NO_GLAD
+#include "third_party/GL/gl/include/EGL/egl.h"
+#include "third_party/GL/gl/include/EGL/eglext.h"
+#include "third_party/GL/gl/include/GL/gl.h"
+#else
+
+#ifdef B3_USE_GLFW
+#include "glad/gl.h"
+#include <GLFW/glfw3.h>
+#else
+#include "glad/gl.h"
+#endif  //B3_USE_GLFW
+#endif  //BT_NO_GLAD
+
+//disable glGetError
+//#undef glGetError
+//#define glGetError MyGetError
+//
+//GLenum inline MyGetError()
+//{
+//	return 0;
+//}
+
+///on Linux only glDrawElementsInstancedARB is defined?!?
+//#ifdef __linux
+//#define glDrawElementsInstanced glDrawElementsInstancedARB
+//
+//#endif //__linux
+
+#endif  //__OPENGL_INCLUDE_H
diff --git a/engine/inc/bullet/OpenGLWindow/OpenGLInclude.h b/engine/inc/bullet/OpenGLWindow/OpenGLInclude.h
new file mode 100644
index 00000000..4000ceca
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/OpenGLInclude.h
@@ -0,0 +1,31 @@
+/*
+Copyright (c) 2012 Advanced Micro Devices, Inc.
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+//Originally written by Erwin Coumans
+
+#ifndef __OPENGL_INCLUDE_H
+#define __OPENGL_INCLUDE_H
+
+#ifdef BT_NO_GLAD
+#include "third_party/GL/gl/include/EGL/egl.h"
+#include "third_party/GL/gl/include/EGL/eglext.h"
+#include "third_party/GL/gl/include/GL/gl.h"
+#else
+#ifdef B3_USE_GLFW
+#include <glad/gl.h>
+#include <GLFW/glfw3.h>
+#else
+#include "glad/gl.h"
+#endif  //B3_USE_GLFW
+#endif  //BT_NO_GLAD
+#endif  //__OPENGL_INCLUDE_H
diff --git a/engine/inc/bullet/OpenGLWindow/Shaders/createShadowMapInstancingPS.h b/engine/inc/bullet/OpenGLWindow/Shaders/createShadowMapInstancingPS.h
new file mode 100644
index 00000000..8b2dce8f
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/Shaders/createShadowMapInstancingPS.h
@@ -0,0 +1,10 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* createShadowMapInstancingFragmentShader= \
+"#version 330\n"
+"precision highp float;\n"
+"layout(location = 0) out float fragmentdepth;\n"
+"void main(void)\n"
+"{\n"
+"	fragmentdepth = gl_FragCoord.z;\n"
+"}\n"
+;
diff --git a/engine/inc/bullet/OpenGLWindow/Shaders/createShadowMapInstancingVS.h b/engine/inc/bullet/OpenGLWindow/Shaders/createShadowMapInstancingVS.h
new file mode 100644
index 00000000..5e46a20f
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/Shaders/createShadowMapInstancingVS.h
@@ -0,0 +1,48 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* createShadowMapInstancingVertexShader= \
+"#version 330\n"
+"precision highp float;\n"
+"layout (location = 0) in vec4 position;\n"
+"layout (location = 1) in vec4 instance_position;\n"
+"layout (location = 2) in vec4 instance_quaternion;\n"
+"layout (location = 3) in vec2 uvcoords;\n"
+"layout (location = 4) in vec3 vertexnormal;\n"
+"layout (location = 5) in vec4 instance_color;\n"
+"layout (location = 6) in vec4 instance_scale_obUid;\n"
+"uniform mat4 depthMVP;\n"
+"vec4 quatMul ( in vec4 q1, in vec4 q2 )\n"
+"{\n"
+"    vec3  im = q1.w * q2.xyz + q1.xyz * q2.w + cross ( q1.xyz, q2.xyz );\n"
+"    vec4  dt = q1 * q2;\n"
+"    float re = dot ( dt, vec4 ( -1.0, -1.0, -1.0, 1.0 ) );\n"
+"    return vec4 ( im, re );\n"
+"}\n"
+"vec4 quatFromAxisAngle(vec4 axis, in float angle)\n"
+"{\n"
+"    float cah = cos(angle*0.5);\n"
+"    float sah = sin(angle*0.5);\n"
+"	float d = inversesqrt(dot(axis,axis));\n"
+"	vec4 q = vec4(axis.x*sah*d,axis.y*sah*d,axis.z*sah*d,cah);\n"
+"	return q;\n"
+"}\n"
+"//\n"
+"// vector rotation via quaternion\n"
+"//\n"
+"vec4 quatRotate3 ( in vec3 p, in vec4 q )\n"
+"{\n"
+"    vec4 temp = quatMul ( q, vec4 ( p, 0.0 ) );\n"
+"    return quatMul ( temp, vec4 ( -q.x, -q.y, -q.z, q.w ) );\n"
+"}\n"
+"vec4 quatRotate ( in vec4 p, in vec4 q )\n"
+"{\n"
+"    vec4 temp = quatMul ( q, p );\n"
+"    return quatMul ( temp, vec4 ( -q.x, -q.y, -q.z, q.w ) );\n"
+"}\n"
+"void main(void)\n"
+"{\n"
+"	vec4 q = instance_quaternion;\n"
+"	vec4 localcoord = quatRotate3( position.xyz*instance_scale_obUid.xyz,q);\n"
+"	vec4 vertexPos = depthMVP * vec4( (instance_position+localcoord).xyz,1);\n"
+"	gl_Position = vertexPos;\n"
+"}\n"
+;
diff --git a/engine/inc/bullet/OpenGLWindow/Shaders/instancingPS.h b/engine/inc/bullet/OpenGLWindow/Shaders/instancingPS.h
new file mode 100644
index 00000000..8e2ed9f2
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/Shaders/instancingPS.h
@@ -0,0 +1,35 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* instancingFragmentShader= \
+"#version 330\n"
+"precision highp float;\n"
+"in Fragment\n"
+"{\n"
+"     vec4 color;\n"
+"} fragment;\n"
+"in Vert\n"
+"{\n"
+"	vec2 texcoord;\n"
+"} vert;\n"
+"uniform sampler2D Diffuse;\n"
+"in vec3 lightDir,normal,ambient;\n"
+"out vec4 color;\n"
+"void main_textured(void)\n"
+"{\n"
+"   color  = vec4(0.1,0.2,0.3,0.3);\n"
+"}\n"
+"void main(void)\n"
+"{\n"
+"    vec4 texel = fragment.color*texture(Diffuse,vert.texcoord);//fragment.color;\n"
+"	vec3 ct,cf;\n"
+"	float intensity,at,af;\n"
+"	\n"
+"	intensity = 0.5+0.5*clamp( dot( normalize(normal),lightDir ), -1,1 );\n"
+"	cf = intensity*(vec3(1.0,1.0,1.0)-ambient)+ambient;\n"
+"	af = 1.0;\n"
+"		\n"
+"	ct = texel.rgb;\n"
+"	at = texel.a;\n"
+"		\n"
+"	color  = vec4(ct * cf, at * af);	\n"
+"}\n"
+;
diff --git a/engine/inc/bullet/OpenGLWindow/Shaders/instancingVS.h b/engine/inc/bullet/OpenGLWindow/Shaders/instancingVS.h
new file mode 100644
index 00000000..199bfe5a
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/Shaders/instancingVS.h
@@ -0,0 +1,69 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* instancingVertexShader= \
+"#version 330\n"
+"precision highp float;\n"
+"layout (location = 0) in vec4 position;\n"
+"layout (location = 1) in vec4 instance_position;\n"
+"layout (location = 2) in vec4 instance_quaternion;\n"
+"layout (location = 3) in vec2 uvcoords;\n"
+"layout (location = 4) in vec3 vertexnormal;\n"
+"layout (location = 5) in vec4 instance_color;\n"
+"layout (location = 6) in vec4 instance_scale_obUid;\n"
+"uniform mat4 ModelViewMatrix;\n"
+"uniform mat4 ProjectionMatrix;\n"
+"uniform vec3 lightDirIn;\n"
+"out Fragment\n"
+"{\n"
+"     vec4 color;\n"
+"} fragment;\n"
+"out Vert\n"
+"{\n"
+"	vec2 texcoord;\n"
+"} vert;\n"
+"vec4 quatMul ( in vec4 q1, in vec4 q2 )\n"
+"{\n"
+"    vec3  im = q1.w * q2.xyz + q1.xyz * q2.w + cross ( q1.xyz, q2.xyz );\n"
+"    vec4  dt = q1 * q2;\n"
+"    float re = dot ( dt, vec4 ( -1.0, -1.0, -1.0, 1.0 ) );\n"
+"    return vec4 ( im, re );\n"
+"}\n"
+"vec4 quatFromAxisAngle(vec4 axis, in float angle)\n"
+"{\n"
+"    float cah = cos(angle*0.5);\n"
+"    float sah = sin(angle*0.5);\n"
+"	float d = inversesqrt(dot(axis,axis));\n"
+"	vec4 q = vec4(axis.x*sah*d,axis.y*sah*d,axis.z*sah*d,cah);\n"
+"	return q;\n"
+"}\n"
+"//\n"
+"// vector rotation via quaternion\n"
+"//\n"
+"vec4 quatRotate3 ( in vec3 p, in vec4 q )\n"
+"{\n"
+"    vec4 temp = quatMul ( q, vec4 ( p, 0.0 ) );\n"
+"    return quatMul ( temp, vec4 ( -q.x, -q.y, -q.z, q.w ) );\n"
+"}\n"
+"vec4 quatRotate ( in vec4 p, in vec4 q )\n"
+"{\n"
+"    vec4 temp = quatMul ( q, p );\n"
+"    return quatMul ( temp, vec4 ( -q.x, -q.y, -q.z, q.w ) );\n"
+"}\n"
+"out vec3 lightDir,normal,ambient;\n"
+"void main(void)\n"
+"{\n"
+"	vec4 q = instance_quaternion;\n"
+"	ambient = vec3(0.5,.5,0.5);\n"
+"	\n"
+"	vec4 worldNormal =  (quatRotate3( vertexnormal,q));\n"
+"	normal = normalize(worldNormal).xyz;\n"
+"	\n"
+"	lightDir = lightDirIn;\n"
+"	\n"
+"	vec4 localcoord = quatRotate3( position.xyz*instance_scale_obUid.xyz,q);\n"
+"	vec4 vertexPos = ProjectionMatrix * ModelViewMatrix *(instance_position+localcoord);\n"
+"	gl_Position = vertexPos;\n"
+"	\n"
+"	fragment.color = instance_color;\n"
+"	vert.texcoord = uvcoords;\n"
+"}\n"
+;
diff --git a/engine/inc/bullet/OpenGLWindow/Shaders/linesPS.h b/engine/inc/bullet/OpenGLWindow/Shaders/linesPS.h
new file mode 100644
index 00000000..49a4cf3e
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/Shaders/linesPS.h
@@ -0,0 +1,10 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* linesFragmentShader= \
+"#version 150\n"
+"in vec4 colourV;\n"
+"out vec4 fragColour;\n"
+"void main(void)\n"
+"{\n"
+"    fragColour = colourV;\n"
+"}\n"
+;
diff --git a/engine/inc/bullet/OpenGLWindow/Shaders/linesVS.h b/engine/inc/bullet/OpenGLWindow/Shaders/linesVS.h
new file mode 100644
index 00000000..8fc6eb3e
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/Shaders/linesVS.h
@@ -0,0 +1,15 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* linesVertexShader= \
+"#version 150   \n"
+"uniform mat4 ModelViewMatrix;\n"
+"uniform mat4 ProjectionMatrix;\n"
+"uniform vec4 colour;\n"
+"in vec4 position;\n"
+"out vec4 colourV;\n"
+"void main (void)\n"
+"{\n"
+"    colourV = colour;\n"
+"		gl_Position = ProjectionMatrix * ModelViewMatrix * position;\n"
+"		\n"
+"}\n"
+;
diff --git a/engine/inc/bullet/OpenGLWindow/Shaders/pointSpritePS.h b/engine/inc/bullet/OpenGLWindow/Shaders/pointSpritePS.h
new file mode 100644
index 00000000..e0d57e23
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/Shaders/pointSpritePS.h
@@ -0,0 +1,33 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* pointSpriteFragmentShader= \
+"#version 330\n"
+"precision highp float;\n"
+"in Fragment\n"
+"{\n"
+"     vec4 color;\n"
+"} fragment;\n"
+"in vec3 ambient;\n"
+"out vec4 color;\n"
+"void main_textured(void)\n"
+"{\n"
+"    color =  fragment.color;//texture2D(Diffuse,vert.texcoord);//fragment.color;\n"
+"}\n"
+"void main(void)\n"
+"{\n"
+"	vec3 N;\n"
+"	N.xy = gl_PointCoord.st*vec2(2.0, -2.0) + vec2(-1.0, 1.0);\n"
+"    float mag = dot(N.xy, N.xy);\n"
+"    if (mag > 1.0) discard; \n"
+"    vec4 texel = fragment.color;//vec4(1,0,0,1);//fragment.color*texture(Diffuse,vert.texcoord);//fragment.color;\n"
+"	vec3 ct;\n"
+"	float at,af;\n"
+"	af = 1.0;\n"
+"		\n"
+"	ct = texel.rgb;\n"
+"	at = texel.a;\n"
+"		\n"
+" vec3 lightDir= vec3(1,0,0);\n"
+"	float diffuse = max(0.0, dot(lightDir, N));\n"
+"	color  = vec4(ct * diffuse, at * af);	\n"
+"}\n"
+;
diff --git a/engine/inc/bullet/OpenGLWindow/Shaders/pointSpriteVS.h b/engine/inc/bullet/OpenGLWindow/Shaders/pointSpriteVS.h
new file mode 100644
index 00000000..ba1ac583
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/Shaders/pointSpriteVS.h
@@ -0,0 +1,37 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* pointSpriteVertexShader= \
+"#version 330\n"
+"precision highp float;\n"
+"layout (location = 0) in vec4 position;\n"
+"layout (location = 1) in vec4 instance_position;\n"
+"layout (location = 3) in vec2 uvcoords;\n"
+"layout (location = 4) in vec3 vertexnormal;\n"
+"layout (location = 5) in vec4 instance_color;\n"
+"layout (location = 6) in vec4 instance_scale_obUid;\n"
+"uniform float screenWidth = 700.f;\n"
+"uniform mat4 ModelViewMatrix;\n"
+"uniform mat4 ProjectionMatrix;\n"
+"out Fragment\n"
+"{\n"
+"     vec4 color;\n"
+"} fragment;\n"
+"//\n"
+"// vector rotation via quaternion\n"
+"//\n"
+"out vec3 ambient;\n"
+"void main(void)\n"
+"{\n"
+"	ambient = vec3(0.3,.3,0.3);\n"
+"		\n"
+"		\n"
+"	vec4 axis = vec4(1,1,1,0);\n"
+"	vec4 vertexPos = ProjectionMatrix * ModelViewMatrix *(instance_position);\n"
+"	vec3 posEye = vec3(ModelViewMatrix * vec4(instance_position.xyz, 1.0));\n"
+"   float dist = length(posEye);\n"
+"	float pointRadius = 1.f;\n"
+"    gl_PointSize = instance_scale_obUid.x * pointRadius * (screenWidth / dist);\n"
+"	gl_Position = vertexPos;\n"
+"	\n"
+"	fragment.color = instance_color;\n"
+"}\n"
+;
diff --git a/engine/inc/bullet/OpenGLWindow/Shaders/projectiveTextureInstancingPS.h b/engine/inc/bullet/OpenGLWindow/Shaders/projectiveTextureInstancingPS.h
new file mode 100644
index 00000000..ce9a8a99
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/Shaders/projectiveTextureInstancingPS.h
@@ -0,0 +1,64 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* projectiveTextureInstancingFragmentShader= \
+"#version 330 core\n"
+"//precision highp float;\n"
+"in Fragment\n"
+"{\n"
+"     vec4 color;\n"
+"} fragment;\n"
+"uniform sampler2D Diffuse;\n"
+"uniform mat4 ViewMatrixInverse;\n"
+"uniform mat4 TextureMVP;\n"
+"in vec3 lightPos,cameraPosition, normal,ambient;\n"
+"in vec4 vertexPos;\n"
+"in float materialShininess;\n"
+"in vec3 lightSpecularIntensity;\n"
+"in vec3 materialSpecularColor;\n"
+"out vec4 color;\n"
+"void main(void)\n"
+"{\n"
+"    vec4 projcoords = TextureMVP * vertexPos;\n"
+"    vec2 texturecoords = projcoords.xy/projcoords.w;\n"
+"	vec4 texel = fragment.color*texture(Diffuse,texturecoords);\n"
+"	vec3 ct,cf;\n"
+"	float intensity,at,af;\n"
+"	if (fragment.color.w==0)\n"
+"		discard;\n"
+"	vec3 lightDir = normalize(lightPos);\n"
+"	\n"
+"	vec3 normalDir = normalize(normal);\n"
+" \n"
+"	intensity = 0.5+0.5*clamp( dot( normalDir,lightDir ), -1,1 );\n"
+"	\n"
+"	af = 1.0;\n"
+"		\n"
+"	ct = texel.rgb;\n"
+"	at = texel.a;\n"
+"		\n"
+"	//float bias = 0.005f;\n"
+"	\n"
+"	vec3 specularReflection;\n"
+"	\n"
+"	if (dot(normalDir, lightDir) < 0.0) \n"
+"	{\n"
+"		specularReflection = vec3(0.0, 0.0, 0.0);\n"
+"	}\n"
+"  else // light source on the right side\n"
+"	{\n"
+"		vec3 surfaceToLight = normalize(lightPos - vertexPos.xyz);\n"
+"    vec3 surfaceToCamera = normalize(cameraPosition - vertexPos.xyz);\n"
+"    \n"
+"    \n"
+"    float specularCoefficient = 0.0;\n"
+"		specularCoefficient = pow(max(0.0, dot(surfaceToCamera, reflect(-surfaceToLight, normalDir))), materialShininess);\n"
+"    specularReflection = specularCoefficient * materialSpecularColor * lightSpecularIntensity;\n"
+"  \n"
+"	}\n"
+"    \n"
+"	float visibility = 1.0;\n"
+"	intensity = 0.7*intensity  + 0.3*intensity*visibility;\n"
+"	\n"
+"	cf = intensity*(vec3(1.0,1.0,1.0)-ambient)+ambient+specularReflection*visibility;\n"
+"	color  = vec4(ct * cf, fragment.color.w);\n"
+"}\n"
+;
diff --git a/engine/inc/bullet/OpenGLWindow/Shaders/projectiveTextureInstancingVS.h b/engine/inc/bullet/OpenGLWindow/Shaders/projectiveTextureInstancingVS.h
new file mode 100644
index 00000000..550720b6
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/Shaders/projectiveTextureInstancingVS.h
@@ -0,0 +1,84 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* projectiveTextureInstancingVertexShader= \
+"#version 330 \n"
+"precision highp float;\n"
+"layout (location = 0) in vec4 position;\n"
+"layout (location = 1) in vec4 instance_position;\n"
+"layout (location = 2) in vec4 instance_quaternion;\n"
+"layout (location = 3) in vec2 uvcoords;\n"
+"layout (location = 4) in vec3 vertexnormal;\n"
+"layout (location = 5) in vec4 instance_color;\n"
+"layout (location = 6) in vec4 instance_scale_obUid;\n"
+"uniform mat4 TextureMVP;\n"
+"uniform mat4 MVP;\n"
+"uniform vec3 lightPosIn;\n"
+"uniform vec3 cameraPositionIn;\n"
+"uniform mat4 ViewMatrixInverse;\n"
+"uniform float materialShininessIn;\n"
+"uniform vec3 lightSpecularIntensityIn;\n"
+"uniform vec3 materialSpecularColorIn;\n"
+"out vec4 ShadowCoord;\n"
+"out Fragment\n"
+"{\n"
+"     vec4 color;\n"
+"} fragment;\n"
+"out Vert\n"
+"{\n"
+"	vec2 texcoord;\n"
+"} vert;\n"
+"vec4 quatMul ( in vec4 q1, in vec4 q2 )\n"
+"{\n"
+"    vec3  im = q1.w * q2.xyz + q1.xyz * q2.w + cross ( q1.xyz, q2.xyz );\n"
+"    vec4  dt = q1 * q2;\n"
+"    float re = dot ( dt, vec4 ( -1.0, -1.0, -1.0, 1.0 ) );\n"
+"    return vec4 ( im, re );\n"
+"}\n"
+"vec4 quatFromAxisAngle(vec4 axis, in float angle)\n"
+"{\n"
+"    float cah = cos(angle*0.5);\n"
+"    float sah = sin(angle*0.5);\n"
+"	float d = inversesqrt(dot(axis,axis));\n"
+"	vec4 q = vec4(axis.x*sah*d,axis.y*sah*d,axis.z*sah*d,cah);\n"
+"	return q;\n"
+"}\n"
+"//\n"
+"// vector rotation via quaternion\n"
+"//\n"
+"vec4 quatRotate3 ( in vec3 p, in vec4 q )\n"
+"{\n"
+"    vec4 temp = quatMul ( q, vec4 ( p, 0.0 ) );\n"
+"    return quatMul ( temp, vec4 ( -q.x, -q.y, -q.z, q.w ) );\n"
+"}\n"
+"vec4 quatRotate ( in vec4 p, in vec4 q )\n"
+"{\n"
+"    vec4 temp = quatMul ( q, p );\n"
+"    return quatMul ( temp, vec4 ( -q.x, -q.y, -q.z, q.w ) );\n"
+"}\n"
+"out vec3 lightPos,normal,ambient;\n"
+"out vec4 vertexPos;\n"
+"out vec3 cameraPosition;\n"
+"out float materialShininess;\n"
+"out vec3 lightSpecularIntensity;\n"
+"out vec3 materialSpecularColor;\n"
+"void main(void)\n"
+"{\n"
+"	vec4 q = instance_quaternion;\n"
+"	ambient = vec3(0.5,.5,0.5);\n"
+"			\n"
+"	vec4 worldNormal = (quatRotate3( vertexnormal,q));\n"
+"	\n"
+"	normal = worldNormal.xyz;\n"
+"	lightPos = lightPosIn;\n"
+"	cameraPosition = cameraPositionIn;\n"
+"	materialShininess = materialShininessIn;\n"
+"	lightSpecularIntensity = lightSpecularIntensityIn;\n"
+"	materialSpecularColor = materialSpecularColorIn;\n"
+"	\n"
+"	vec4 localcoord = quatRotate3( position.xyz*instance_scale_obUid.xyz,q);\n"
+"	vertexPos = vec4((instance_position+localcoord).xyz,1);\n"
+"	\n"
+"	vec4 vertexLoc = MVP* vec4((instance_position+localcoord).xyz,1);\n"
+"	gl_Position = vertexLoc;\n"
+"	fragment.color = instance_color;\n"
+"}\n"
+;
diff --git a/engine/inc/bullet/OpenGLWindow/Shaders/segmentationMaskInstancingPS.h b/engine/inc/bullet/OpenGLWindow/Shaders/segmentationMaskInstancingPS.h
new file mode 100644
index 00000000..08196f23
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/Shaders/segmentationMaskInstancingPS.h
@@ -0,0 +1,16 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* segmentationMaskInstancingFragmentShader= \
+"#version 330\n"
+"precision highp float;\n"
+"in vec4 scale_obuid;\n"
+"out vec4 color;\n"
+"void main(void)\n"
+"{\n"
+"	highp int obuid = int(scale_obuid.w);\n"
+"	float r = ((obuid>>0 )&0xff)*(1./255.f);\n"
+"	float g = ((obuid>>8 )&0xff)*(1./255.f);\n"
+"	float b = ((obuid>>16)&0xff)*(1./255.f);\n"
+"	float a = ((obuid>>24)&0xff)*(1./255.f);\n"
+"	color  = vec4(r,g,b,a);\n"
+"}\n"
+;
diff --git a/engine/inc/bullet/OpenGLWindow/Shaders/segmentationMaskInstancingVS.h b/engine/inc/bullet/OpenGLWindow/Shaders/segmentationMaskInstancingVS.h
new file mode 100644
index 00000000..b274a7d9
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/Shaders/segmentationMaskInstancingVS.h
@@ -0,0 +1,54 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* segmentationMaskInstancingVertexShader= \
+"#version 330\n"
+"precision highp float;\n"
+"layout (location = 0) in vec4 position;\n"
+"layout (location = 1) in vec4 instance_position;\n"
+"layout (location = 2) in vec4 instance_quaternion;\n"
+"layout (location = 5) in vec4 instance_color;\n"
+"layout (location = 6) in vec4 instance_scale_obUid;\n"
+"uniform mat4 ModelViewMatrix;\n"
+"uniform mat4 ProjectionMatrix;\n"
+"out vec4 scale_obuid;\n"
+"out Fragment\n"
+"{\n"
+"     vec4 color;\n"
+"} fragment;\n"
+"vec4 quatMul ( in vec4 q1, in vec4 q2 )\n"
+"{\n"
+"    vec3  im = q1.w * q2.xyz + q1.xyz * q2.w + cross ( q1.xyz, q2.xyz );\n"
+"    vec4  dt = q1 * q2;\n"
+"    float re = dot ( dt, vec4 ( -1.0, -1.0, -1.0, 1.0 ) );\n"
+"    return vec4 ( im, re );\n"
+"}\n"
+"vec4 quatFromAxisAngle(vec4 axis, in float angle)\n"
+"{\n"
+"    float cah = cos(angle*0.5);\n"
+"    float sah = sin(angle*0.5);\n"
+"	float d = inversesqrt(dot(axis,axis));\n"
+"	vec4 q = vec4(axis.x*sah*d,axis.y*sah*d,axis.z*sah*d,cah);\n"
+"	return q;\n"
+"}\n"
+"//\n"
+"// vector rotation via quaternion\n"
+"//\n"
+"vec4 quatRotate3 ( in vec3 p, in vec4 q )\n"
+"{\n"
+"    vec4 temp = quatMul ( q, vec4 ( p, 0.0 ) );\n"
+"    return quatMul ( temp, vec4 ( -q.x, -q.y, -q.z, q.w ) );\n"
+"}\n"
+"vec4 quatRotate ( in vec4 p, in vec4 q )\n"
+"{\n"
+"    vec4 temp = quatMul ( q, p );\n"
+"    return quatMul ( temp, vec4 ( -q.x, -q.y, -q.z, q.w ) );\n"
+"}\n"
+"void main(void)\n"
+"{\n"
+"	vec4 q = instance_quaternion;\n"
+"	vec4 localcoord = quatRotate3( position.xyz*instance_scale_obUid.xyz,q);\n"
+"	vec4 vertexPos = ProjectionMatrix * ModelViewMatrix *(instance_position+localcoord);\n"
+"	scale_obuid = instance_scale_obUid;\n"
+"	gl_Position = vertexPos;\n"
+"	fragment.color = instance_color;\n"
+"}\n"
+;
diff --git a/engine/inc/bullet/OpenGLWindow/Shaders/useShadowMapInstancingPS.h b/engine/inc/bullet/OpenGLWindow/Shaders/useShadowMapInstancingPS.h
new file mode 100644
index 00000000..f8b86b03
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/Shaders/useShadowMapInstancingPS.h
@@ -0,0 +1,70 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* useShadowMapInstancingFragmentShader= \
+"#version 330 core\n"
+"//precision highp float;\n"
+"in Fragment\n"
+"{\n"
+"     vec4 color;\n"
+"} fragment;\n"
+"in Vert\n"
+"{\n"
+"	vec2 texcoord;\n"
+"} vert;\n"
+"uniform sampler2D Diffuse;\n"
+"uniform sampler2DShadow shadowMap;\n"
+"uniform mat4 ViewMatrixInverse;\n"
+"in vec3 lightPos,cameraPosition, normal,ambient;\n"
+"in vec4 ShadowCoord;\n"
+"in vec4 vertexPos;\n"
+"in float materialShininess;\n"
+"in float shadowmapIntensity;\n"
+"in vec3 lightSpecularIntensity;\n"
+"in vec3 materialSpecularColor;\n"
+"out vec4 color;\n"
+"void main(void)\n"
+"{\n"
+"	vec4 texel = fragment.color*texture(Diffuse,vert.texcoord);\n"
+"	vec3 ct,cf;\n"
+"	float intensity,at,af;\n"
+"	if (fragment.color.w==0)\n"
+"		discard;\n"
+"	vec3 lightDir = normalize(lightPos);\n"
+"	\n"
+"	vec3 normalDir = normalize(normal);\n"
+" \n"
+"	intensity = 0.5+0.5*clamp( dot( normalDir,lightDir ), -1,1 );\n"
+"	\n"
+"	af = 1.0;\n"
+"		\n"
+"	ct = texel.rgb;\n"
+"	at = texel.a;\n"
+"		\n"
+"	//float bias = 0.005f;\n"
+"	\n"
+"	vec3 specularReflection;\n"
+"	\n"
+"	if (dot(normalDir, lightDir) < 0.0) \n"
+"	{\n"
+"		specularReflection = vec3(0.0, 0.0, 0.0);\n"
+"	}\n"
+"  else // light source on the right side\n"
+"	{\n"
+"		vec3 surfaceToLight = normalize(lightPos - vertexPos.xyz);\n"
+"    vec3 surfaceToCamera = normalize(cameraPosition - vertexPos.xyz);\n"
+"    \n"
+"    \n"
+"    float specularCoefficient = 0.0;\n"
+"		specularCoefficient = pow(max(0.0, dot(surfaceToCamera, reflect(-surfaceToLight, normalDir))), materialShininess);\n"
+"    specularReflection = specularCoefficient * materialSpecularColor * lightSpecularIntensity;\n"
+"  \n"
+"	}\n"
+"    \n"
+"	float visibility = texture(shadowMap, vec3(ShadowCoord.xy,(ShadowCoord.z)/ShadowCoord.w));\n"
+"	if (intensity<0.5)\n"
+"		visibility = 0;\n"
+"	intensity = (1.0-shadowmapIntensity)*intensity  + shadowmapIntensity*intensity*visibility;\n"
+"	\n"
+"	cf = intensity*(vec3(1.0,1.0,1.0)-ambient)+ambient+specularReflection*visibility;\n"
+"	color  = vec4(ct * cf, fragment.color.w);\n"
+"}\n"
+;
diff --git a/engine/inc/bullet/OpenGLWindow/Shaders/useShadowMapInstancingVS.h b/engine/inc/bullet/OpenGLWindow/Shaders/useShadowMapInstancingVS.h
new file mode 100644
index 00000000..ad8fe1b8
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/Shaders/useShadowMapInstancingVS.h
@@ -0,0 +1,92 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* useShadowMapInstancingVertexShader= \
+"#version 330 \n"
+"precision highp float;\n"
+"layout (location = 0) in vec4 position;\n"
+"layout (location = 1) in vec4 instance_position;\n"
+"layout (location = 2) in vec4 instance_quaternion;\n"
+"layout (location = 3) in vec2 uvcoords;\n"
+"layout (location = 4) in vec3 vertexnormal;\n"
+"layout (location = 5) in vec4 instance_color;\n"
+"layout (location = 6) in vec4 instance_scale_obUid;\n"
+"uniform mat4 ModelViewMatrix;\n"
+"uniform mat4 ProjectionMatrix;\n"
+"uniform mat4 DepthBiasModelViewProjectionMatrix;\n"
+"uniform mat4 MVP;\n"
+"uniform vec3 lightPosIn;\n"
+"uniform vec3 cameraPositionIn;\n"
+"uniform mat4 ViewMatrixInverse;\n"
+"uniform float materialShininessIn;\n"
+"uniform float shadowmapIntensityIn;\n"
+"uniform vec3 lightSpecularIntensityIn;\n"
+"uniform vec3 materialSpecularColorIn;\n"
+"out vec4 ShadowCoord;\n"
+"out Fragment\n"
+"{\n"
+"     vec4 color;\n"
+"} fragment;\n"
+"out Vert\n"
+"{\n"
+"	vec2 texcoord;\n"
+"} vert;\n"
+"vec4 quatMul ( in vec4 q1, in vec4 q2 )\n"
+"{\n"
+"    vec3  im = q1.w * q2.xyz + q1.xyz * q2.w + cross ( q1.xyz, q2.xyz );\n"
+"    vec4  dt = q1 * q2;\n"
+"    float re = dot ( dt, vec4 ( -1.0, -1.0, -1.0, 1.0 ) );\n"
+"    return vec4 ( im, re );\n"
+"}\n"
+"vec4 quatFromAxisAngle(vec4 axis, in float angle)\n"
+"{\n"
+"    float cah = cos(angle*0.5);\n"
+"    float sah = sin(angle*0.5);\n"
+"	float d = inversesqrt(dot(axis,axis));\n"
+"	vec4 q = vec4(axis.x*sah*d,axis.y*sah*d,axis.z*sah*d,cah);\n"
+"	return q;\n"
+"}\n"
+"//\n"
+"// vector rotation via quaternion\n"
+"//\n"
+"vec4 quatRotate3 ( in vec3 p, in vec4 q )\n"
+"{\n"
+"    vec4 temp = quatMul ( q, vec4 ( p, 0.0 ) );\n"
+"    return quatMul ( temp, vec4 ( -q.x, -q.y, -q.z, q.w ) );\n"
+"}\n"
+"vec4 quatRotate ( in vec4 p, in vec4 q )\n"
+"{\n"
+"    vec4 temp = quatMul ( q, p );\n"
+"    return quatMul ( temp, vec4 ( -q.x, -q.y, -q.z, q.w ) );\n"
+"}\n"
+"out vec3 lightPos,normal,ambient;\n"
+"out vec4 vertexPos;\n"
+"out vec3 cameraPosition;\n"
+"out float materialShininess;\n"
+"out float shadowmapIntensity;\n"
+"out vec3 lightSpecularIntensity;\n"
+"out vec3 materialSpecularColor;\n"
+"void main(void)\n"
+"{\n"
+"	vec4 q = instance_quaternion;\n"
+"	ambient = vec3(0.5,.5,0.5);\n"
+"			\n"
+"	vec4 worldNormal = (quatRotate3( vertexnormal,q));\n"
+"	\n"
+"	normal = worldNormal.xyz;\n"
+"	lightPos = lightPosIn;\n"
+"	cameraPosition = cameraPositionIn;\n"
+"	materialShininess = materialShininessIn;\n"
+"	\n"
+"	shadowmapIntensity = shadowmapIntensityIn;\n"
+"	lightSpecularIntensity = lightSpecularIntensityIn;\n"
+"	materialSpecularColor = materialSpecularColorIn;\n"
+"	\n"
+"	vec4 localcoord = quatRotate3( position.xyz*instance_scale_obUid.xyz,q);\n"
+"	vertexPos = vec4((instance_position+localcoord).xyz,1);\n"
+"	\n"
+"	vec4 vertexLoc = MVP* vec4((instance_position+localcoord).xyz,1);\n"
+"	gl_Position = vertexLoc;\n"
+"	ShadowCoord = DepthBiasModelViewProjectionMatrix * vec4((instance_position+localcoord).xyz,1);\n"
+"	fragment.color = instance_color;\n"
+"	vert.texcoord = uvcoords;\n"
+"}\n"
+;
diff --git a/engine/inc/bullet/OpenGLWindow/ShapeData.h b/engine/inc/bullet/OpenGLWindow/ShapeData.h
new file mode 100644
index 00000000..54c195a8
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/ShapeData.h
@@ -0,0 +1,59331 @@
+#ifndef SHAPE_DATA_H
+#define SHAPE_DATA_H
+
+#ifdef USE_BARREL_VERTICES
+static float barrel_vertices[] = {
+	0.0f, -0.5f, 0.0f, 1.0f, 0.0f, -1.0f, 0.0f, 0.5f, 0.5f,
+	0.282362f, -0.5f, -0.205148f, 1.0f, 0.0f, -1.0f, 0.0f, 0.5f, 0.5f,
+	0.349018f, -0.5f, 0.0f, 1.0f, 0.0f, -1.0f, 0.0f, 0.5f, 0.5f,
+	0.107853f, -0.5f, -0.331936f, 1.0f, 0.0f, -1.0f, 0.0f, 0.5f, 0.5f,
+	-0.107853f, -0.5f, -0.331936f, 1.0f, 0.0f, -1.0f, 0.0f, 0.5f, 0.5f,
+	0.107853f, -0.5f, -0.331936f, 1.0f, 0.0f, -1.0f, 0.0f, 0.5f, 0.5f,
+	-0.282362f, -0.5f, -0.205148f, 1.0f, 0.0f, -1.0f, 0.0f, 0.5f, 0.5f,
+	-0.349018f, -0.5f, 0.0f, 1.0f, 0.0f, -1.0f, 0.0f, 0.5f, 0.5f,
+	-0.282362f, -0.5f, 0.205148f, 1.0f, 0.0f, -1.0f, 0.0f, 0.5f, 0.5f,
+	-0.107853f, -0.5f, 0.331936f, 1.0f, 0.0f, -1.0f, 0.0f, 0.5f, 0.5f,
+	0.107853f, -0.5f, 0.331936f, 1.0f, 0.0f, -1.0f, 0.0f, 0.5f, 0.5f,
+	0.282362f, -0.5f, 0.205148f, 1.0f, 0.0f, -1.0f, 0.0f, 0.5f, 0.5f,
+	0.0f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.5f, 0.5f,
+	0.349018f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.5f, 0.5f,
+	0.282362f, 0.5f, -0.205148f, 1.0f, 0.0f, 1.0f, 0.0f, 0.5f, 0.5f,
+	0.107853f, 0.5f, -0.331936f, 1.0f, 0.0f, 1.0f, 0.0f, 0.5f, 0.5f,
+	0.107853f, 0.5f, -0.331936f, 1.0f, 0.0f, 1.0f, 0.0f, 0.5f, 0.5f,
+	-0.107853f, 0.5f, -0.331936f, 1.0f, 0.0f, 1.0f, 0.0f, 0.5f, 0.5f,
+	-0.282362f, 0.5f, -0.205148f, 1.0f, 0.0f, 1.0f, 0.0f, 0.5f, 0.5f,
+	-0.349018f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.5f, 0.5f,
+	-0.282362f, 0.5f, 0.205148f, 1.0f, 0.0f, 1.0f, 0.0f, 0.5f, 0.5f,
+	-0.107853f, 0.5f, 0.331936f, 1.0f, 0.0f, 1.0f, 0.0f, 0.5f, 0.5f,
+	0.107853f, 0.5f, 0.331936f, 1.0f, 0.0f, 1.0f, 0.0f, 0.5f, 0.5f,
+	0.282362f, 0.5f, 0.205148f, 1.0f, 0.0f, 1.0f, 0.0f, 0.5f, 0.5f,
+	0.349018f, -0.5f, 0.0f, 1.0f, 0.957307f, -0.289072f, 0.0f, 0.5f, 0.5f,
+	0.404509f, 0.0f, -0.293893f, 1.0f, 0.809017f, 0.0f, -0.587785f, 0.5f, 0.5f,
+	0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.5f, 0.5f,
+	0.282362f, -0.5f, -0.205148f, 1.0f, 0.774478f, -0.289072f, -0.562691f, 0.5f, 0.5f,
+	0.154508f, 0.0f, -0.475528f, 1.0f, 0.309017f, 0.0f, -0.951057f, 0.5f, 0.5f,
+	0.107853f, -0.5f, -0.331936f, 1.0f, 0.295824f, -0.289072f, -0.910453f, 0.5f, 0.5f,
+	0.107853f, -0.5f, -0.331936f, 1.0f, 0.295824f, -0.289072f, -0.910453f, 0.5f, 0.5f,
+	-0.154509f, 0.0f, -0.475528f, 1.0f, -0.309017f, 0.0f, -0.951057f, 0.5f, 0.5f,
+	0.154508f, 0.0f, -0.475528f, 1.0f, 0.309017f, 0.0f, -0.951057f, 0.5f, 0.5f,
+	-0.107853f, -0.5f, -0.331936f, 1.0f, -0.295824f, -0.289072f, -0.910453f, 0.5f, 0.5f,
+	-0.404509f, 0.0f, -0.293893f, 1.0f, -0.809017f, 0.0f, -0.587785f, 0.5f, 0.5f,
+	-0.282362f, -0.5f, -0.205148f, 1.0f, -0.774478f, -0.289072f, -0.562691f, 0.5f, 0.5f,
+	-0.5f, 0.0f, 0.0f, 1.0f, -1.0f, 0.0f, 0.0f, 0.5f, 0.5f,
+	-0.349018f, -0.5f, 0.0f, 1.0f, -0.957307f, -0.289072f, 0.0f, 0.5f, 0.5f,
+	-0.404508f, 0.0f, 0.293893f, 1.0f, -0.809017f, 0.0f, 0.587785f, 0.5f, 0.5f,
+	-0.282362f, -0.5f, 0.205148f, 1.0f, -0.774478f, -0.289072f, 0.562691f, 0.5f, 0.5f,
+	-0.154509f, 0.0f, 0.475528f, 1.0f, -0.309017f, 0.0f, 0.951056f, 0.5f, 0.5f,
+	-0.107853f, -0.5f, 0.331936f, 1.0f, -0.295824f, -0.289072f, 0.910453f, 0.5f, 0.5f,
+	0.154509f, 0.0f, 0.475528f, 1.0f, 0.309017f, 0.0f, 0.951056f, 0.5f, 0.5f,
+	0.107853f, -0.5f, 0.331936f, 1.0f, 0.295824f, -0.289072f, 0.910453f, 0.5f, 0.5f,
+	0.404509f, 0.0f, 0.293892f, 1.0f, 0.809017f, 0.0f, 0.587785f, 0.5f, 0.5f,
+	0.282362f, -0.5f, 0.205148f, 1.0f, 0.774478f, -0.289072f, 0.562691f, 0.5f, 0.5f,
+	0.282362f, 0.5f, -0.205148f, 1.0f, 0.774478f, 0.289072f, -0.562691f, 0.5f, 0.5f,
+	0.349018f, 0.5f, 0.0f, 1.0f, 0.957307f, 0.289072f, 0.0f, 0.5f, 0.5f,
+	0.107853f, 0.5f, -0.331936f, 1.0f, 0.295824f, 0.289072f, -0.910453f, 0.5f, 0.5f,
+	-0.107853f, 0.5f, -0.331936f, 1.0f, -0.295824f, 0.289072f, -0.910453f, 0.5f, 0.5f,
+	0.107853f, 0.5f, -0.331936f, 1.0f, 0.295824f, 0.289072f, -0.910453f, 0.5f, 0.5f,
+	-0.282362f, 0.5f, -0.205148f, 1.0f, -0.774478f, 0.289072f, -0.562691f, 0.5f, 0.5f,
+	-0.349018f, 0.5f, 0.0f, 1.0f, -0.957307f, 0.289072f, 0.0f, 0.5f, 0.5f,
+	-0.282362f, 0.5f, 0.205148f, 1.0f, -0.774478f, 0.289072f, 0.562691f, 0.5f, 0.5f,
+	-0.107853f, 0.5f, 0.331936f, 1.0f, -0.295824f, 0.289072f, 0.910453f, 0.5f, 0.5f,
+	0.107853f, 0.5f, 0.331936f, 1.0f, 0.295824f, 0.289072f, 0.910453f, 0.5f, 0.5f,
+	0.282362f, 0.5f, 0.205148f, 1.0f, 0.774478f, 0.289072f, 0.562691f, 0.5f, 0.5f};
+
+static int barrel_indices[] = {
+	0,
+	1,
+	2,
+	0,
+	3,
+	1,
+	0,
+	4,
+	5,
+	0,
+	6,
+	4,
+	0,
+	7,
+	6,
+	0,
+	8,
+	7,
+	0,
+	9,
+	8,
+	0,
+	10,
+	9,
+	0,
+	11,
+	10,
+	0,
+	2,
+	11,
+	12,
+	13,
+	14,
+	12,
+	14,
+	15,
+	12,
+	16,
+	17,
+	12,
+	17,
+	18,
+	12,
+	18,
+	19,
+	12,
+	19,
+	20,
+	12,
+	20,
+	21,
+	12,
+	21,
+	22,
+	12,
+	22,
+	23,
+	12,
+	23,
+	13,
+	24,
+	25,
+	26,
+	24,
+	27,
+	25,
+	27,
+	28,
+	25,
+	27,
+	29,
+	28,
+	30,
+	31,
+	32,
+	30,
+	33,
+	31,
+	33,
+	34,
+	31,
+	33,
+	35,
+	34,
+	35,
+	36,
+	34,
+	35,
+	37,
+	36,
+	37,
+	38,
+	36,
+	37,
+	39,
+	38,
+	39,
+	40,
+	38,
+	39,
+	41,
+	40,
+	41,
+	42,
+	40,
+	41,
+	43,
+	42,
+	43,
+	44,
+	42,
+	43,
+	45,
+	44,
+	45,
+	26,
+	44,
+	45,
+	24,
+	26,
+	26,
+	46,
+	47,
+	26,
+	25,
+	46,
+	25,
+	48,
+	46,
+	25,
+	28,
+	48,
+	32,
+	49,
+	50,
+	32,
+	31,
+	49,
+	31,
+	51,
+	49,
+	31,
+	34,
+	51,
+	34,
+	52,
+	51,
+	34,
+	36,
+	52,
+	36,
+	53,
+	52,
+	36,
+	38,
+	53,
+	38,
+	54,
+	53,
+	38,
+	40,
+	54,
+	40,
+	55,
+	54,
+	40,
+	42,
+	55,
+	42,
+	56,
+	55,
+	42,
+	44,
+	56,
+	44,
+	47,
+	56,
+	44,
+	26,
+	47,
+};
+#endif  //USE_BARREL_VERTICES
+
+///position xyz, unused w, normal, uv
+static const float cube_vertices[] =
+	{
+		-1.0f,
+		-1.0f,
+		1.0f,
+		1.0f,
+		0,
+		0,
+		1,
+		0,
+		0,  //0
+		1.0f,
+		-1.0f,
+		1.0f,
+		1.0f,
+		0,
+		0,
+		1,
+		1,
+		0,  //1
+		1.0f,
+		1.0f,
+		1.0f,
+		1.0f,
+		0,
+		0,
+		1,
+		1,
+		1,  //2
+		-1.0f,
+		1.0f,
+		1.0f,
+		1.0f,
+		0,
+		0,
+		1,
+		0,
+		1,  //3
+
+		-1.0f,
+		-1.0f,
+		-1.0f,
+		1.0f,
+		0,
+		0,
+		-1,
+		0,
+		0,  //4
+		1.0f,
+		-1.0f,
+		-1.0f,
+		1.0f,
+		0,
+		0,
+		-1,
+		1,
+		0,  //5
+		1.0f,
+		1.0f,
+		-1.0f,
+		1.0f,
+		0,
+		0,
+		-1,
+		1,
+		1,  //6
+		-1.0f,
+		1.0f,
+		-1.0f,
+		1.0f,
+		0,
+		0,
+		-1,
+		0,
+		1,  //7
+
+		-1.0f,
+		-1.0f,
+		-1.0f,
+		1.0f,
+		-1,
+		0,
+		0,
+		0,
+		0,
+		-1.0f,
+		1.0f,
+		-1.0f,
+		1.0f,
+		-1,
+		0,
+		0,
+		1,
+		0,
+		-1.0f,
+		1.0f,
+		1.0f,
+		1.0f,
+		-1,
+		0,
+		0,
+		1,
+		1,
+		-1.0f,
+		-1.0f,
+		1.0f,
+		1.0f,
+		-1,
+		0,
+		0,
+		0,
+		1,
+
+		1.0f,
+		-1.0f,
+		-1.0f,
+		1.0f,
+		1,
+		0,
+		0,
+		0,
+		0,
+		1.0f,
+		1.0f,
+		-1.0f,
+		1.0f,
+		1,
+		0,
+		0,
+		1,
+		0,
+		1.0f,
+		1.0f,
+		1.0f,
+		1.0f,
+		1,
+		0,
+		0,
+		1,
+		1,
+		1.0f,
+		-1.0f,
+		1.0f,
+		1.0f,
+		1,
+		0,
+		0,
+		0,
+		1,
+
+		-1.0f,
+		-1.0f,
+		-1.0f,
+		1.0f,
+		0,
+		-1,
+		0,
+		0,
+		0,
+		-1.0f,
+		-1.0f,
+		1.0f,
+		1.0f,
+		0,
+		-1,
+		0,
+		1,
+		0,
+		1.0f,
+		-1.0f,
+		1.0f,
+		1.0f,
+		0,
+		-1,
+		0,
+		1,
+		1,
+		1.0f,
+		-1.0f,
+		-1.0f,
+		1.0f,
+		0,
+		-1,
+		0,
+		0,
+		1,
+
+		-1.0f,
+		1.0f,
+		-1.0f,
+		1.0f,
+		0,
+		1,
+		0,
+		0,
+		0,
+		-1.0f,
+		1.0f,
+		1.0f,
+		1.0f,
+		0,
+		1,
+		0,
+		1,
+		0,
+		1.0f,
+		1.0f,
+		1.0f,
+		1.0f,
+		0,
+		1,
+		0,
+		1,
+		1,
+		1.0f,
+		1.0f,
+		-1.0f,
+		1.0f,
+		0,
+		1,
+		0,
+		0,
+		1,
+};
+
+///position xyz, unused w, normal, uv
+static const float cube_vertices_textured[] =
+	{
+		-1.0f,
+		-1.0f,
+		1.0f,
+		1.0f,
+		0,
+		0,
+		1,
+		0.75,
+		0.25,  //0//back
+		1.0f,
+		-1.0f,
+		1.0f,
+		1.0f,
+		0,
+		0,
+		1,
+		1,
+		0.25,  //1
+		1.0f,
+		1.0f,
+		1.0f,
+		1.0f,
+		0,
+		0,
+		1,
+		1,
+		0,  //2
+		-1.0f,
+		1.0f,
+		1.0f,
+		1.0f,
+		0,
+		0,
+		1,
+		0.75,
+		0,  //3
+
+		-1.0f,
+		-1.0f,
+		-1.0f,
+		1.0f,
+		0,
+		0,
+		-1,
+		0.5,
+		0.25,  //4//front
+		1.0f,
+		-1.0f,
+		-1.0f,
+		1.0f,
+		0,
+		0,
+		-1,
+		0.25,
+		0.25,  //5
+		1.0f,
+		1.0f,
+		-1.0f,
+		1.0f,
+		0,
+		0,
+		-1,
+		0.25,
+		0,  //6
+		-1.0f,
+		1.0f,
+		-1.0f,
+		1.0f,
+		0,
+		0,
+		-1,
+		0.5,
+		0,  //7
+
+		-1.0f,
+		-1.0f,
+		-1.0f,
+		1.0f,
+		-1,
+		0,
+		0,
+		0.5,
+		0,  //Right
+		-1.0f,
+		1.0f,
+		-1.0f,
+		1.0f,
+		-1,
+		0,
+		0,
+		0.75,
+		0,
+		-1.0f,
+		1.0f,
+		1.0f,
+		1.0f,
+		-1,
+		0,
+		0,
+		0.75,
+		0.25,
+		-1.0f,
+		-1.0f,
+		1.0f,
+		1.0f,
+		-1,
+		0,
+		0,
+		0.5,
+		0.25,
+
+		1.0f,
+		-1.0f,
+		-1.0f,
+		1.0f,
+		1,
+		0,
+		0,
+		0.25,
+		0.5,  //Left
+		1.0f,
+		1.0f,
+		-1.0f,
+		1.0f,
+		1,
+		0,
+		0,
+		0.25,
+		0.25,
+		1.0f,
+		1.0f,
+		1.0f,
+		1.0f,
+		1,
+		0,
+		0,
+		0.,
+		.25,
+		1.0f,
+		-1.0f,
+		1.0f,
+		1.0f,
+		1,
+		0,
+		0,
+		0,
+		.5,
+
+		-1.0f,
+		-1.0f,
+		-1.0f,
+		1.0f,
+		0,
+		-1,
+		0,
+		0.25,
+		0.5,  //bottom
+		-1.0f,
+		-1.0f,
+		1.0f,
+		1.0f,
+		0,
+		-1,
+		0,
+		0.25,
+		0.25,
+		1.0f,
+		-1.0f,
+		1.0f,
+		1.0f,
+		0,
+		-1,
+		0,
+		0.5,
+		0.25,
+		1.0f,
+		-1.0f,
+		-1.0f,
+		1.0f,
+		0,
+		-1,
+		0,
+		0.5,
+		0.5,
+
+		-1.0f,
+		1.0f,
+		-1.0f,
+		1.0f,
+		0,
+		1,
+		0,
+		0,
+		0,  //top
+		-1.0f,
+		1.0f,
+		1.0f,
+		1.0f,
+		0,
+		1,
+		0,
+		0,
+		0.25,
+		1.0f,
+		1.0f,
+		1.0f,
+		1.0f,
+		0,
+		1,
+		0,
+		0.25,
+		0.25,
+		1.0f,
+		1.0f,
+		-1.0f,
+		1.0f,
+		0,
+		1,
+		0,
+		0.25,
+		0,
+};
+
+///position xyz, unused w, normal, uv
+static const float cube_vertices2[] =
+	{
+		-1.5f,
+		-0.5f,
+		0.5f,
+		0.0f,
+		0,
+		0,
+		1,
+		0,
+		0,  //0
+		1.5f,
+		-0.5f,
+		0.5f,
+		0.0f,
+		0,
+		0,
+		1,
+		1,
+		0,  //1
+		1.5f,
+		0.5f,
+		0.5f,
+		0.0f,
+		0,
+		0,
+		1,
+		1,
+		1,  //2
+		-1.5f,
+		0.5f,
+		0.5f,
+		0.0f,
+		0,
+		0,
+		1,
+		0,
+		1,  //3
+
+		-1.5f,
+		-0.5f,
+		-0.5f,
+		0.5f,
+		0,
+		0,
+		-1,
+		0,
+		0,  //4
+		1.5f,
+		-0.5f,
+		-0.5f,
+		0.5f,
+		0,
+		0,
+		-1,
+		1,
+		0,  //5
+		1.5f,
+		0.5f,
+		-0.5f,
+		0.5f,
+		0,
+		0,
+		-1,
+		1,
+		1,  //6
+		-1.5f,
+		0.5f,
+		-0.5f,
+		0.5f,
+		0,
+		0,
+		-1,
+		0,
+		1,  //7
+
+		-1.5f,
+		-0.5f,
+		-0.5f,
+		0.5f,
+		-1,
+		0,
+		0,
+		0,
+		0,
+		-1.5f,
+		0.5f,
+		-0.5f,
+		0.5f,
+		-1,
+		0,
+		0,
+		1,
+		0,
+		-1.5f,
+		0.5f,
+		0.5f,
+		0.5f,
+		-1,
+		0,
+		0,
+		1,
+		1,
+		-1.5f,
+		-0.5f,
+		0.5f,
+		0.5f,
+		-1,
+		0,
+		0,
+		0,
+		1,
+
+		1.5f,
+		-0.5f,
+		-0.5f,
+		0.5f,
+		1,
+		0,
+		0,
+		0,
+		0,
+		1.5f,
+		0.5f,
+		-0.5f,
+		0.5f,
+		1,
+		0,
+		0,
+		1,
+		0,
+		1.5f,
+		0.5f,
+		0.5f,
+		0.5f,
+		1,
+		0,
+		0,
+		1,
+		1,
+		1.5f,
+		-0.5f,
+		0.5f,
+		0.5f,
+		1,
+		0,
+		0,
+		0,
+		1,
+
+		-1.5f,
+		-0.5f,
+		-0.5f,
+		0.5f,
+		0,
+		-1,
+		0,
+		0,
+		0,
+		-1.5f,
+		-0.5f,
+		0.5f,
+		0.5f,
+		0,
+		-1,
+		0,
+		1,
+		0,
+		1.5f,
+		-0.5f,
+		0.5f,
+		0.5f,
+		0,
+		-1,
+		0,
+		1,
+		1,
+		1.5f,
+		-0.5f,
+		-0.5f,
+		0.5f,
+		0,
+		-1,
+		0,
+		0,
+		1,
+
+		-1.5f,
+		0.5f,
+		-0.5f,
+		0.5f,
+		0,
+		1,
+		0,
+		0,
+		0,
+		-1.5f,
+		0.5f,
+		0.5f,
+		0.5f,
+		0,
+		1,
+		0,
+		1,
+		0,
+		1.5f,
+		0.5f,
+		0.5f,
+		0.5f,
+		0,
+		1,
+		0,
+		1,
+		1,
+		1.5f,
+		0.5f,
+		-0.5f,
+		0.5f,
+		0,
+		1,
+		0,
+		0,
+		1,
+};
+
+static const int cube_indices[] =
+	{
+		0, 1, 2, 0, 2, 3,  //ground face
+		6, 5, 4, 7, 6, 4,  //top face
+		10, 9, 8, 11, 10, 8,
+		12, 13, 14, 12, 14, 15,
+		18, 17, 16, 19, 18, 16,
+		20, 21, 22, 20, 22, 23};
+/*
+static const float fat_triangle[]=
+{
+	-6.158554,-0.000000,-0.000925,   0.5f,	0,  1,0,	0,1,
+	-0.028798,-0.000000,-0.000925,   0.5f,	0,  1,0,	0,1,
+	-6.158554,-0.000000,-6.130690,   0.5f,	0,  1,0,	0,1	
+};
+
+
+static const int fat_triangle_indices[]=
+{
+	0,1,2,3,4,5
+};
+
+static const float fat_triangle[]=
+{
+	-10.f, -10,  -0.05,  0.5f,	0,  1,0,	0,0,
+	-10.f,   0,  -0.05,  0.5f,	0,  1,0,	1,0,
+	10.f,   0,   -0.05,  0.5f,	0,  1,0,	1,1,
+	-10.f, -10,   0.05,  0.5f,	0,  1,0,	0,1,
+	-10.f,   0,   0.05,  0.5f,	0,  1,0,	0,1,
+	10.f,   0,    0.05,  0.5f,	0,  1,0,	0,0
+};
+*/
+#if 0
+static const float triangle_vertices[] =
+{
+	-1.f,	-0.15,  -1.f,  0.5f,	0,  1,0,	0,0,
+	-1.f,	-0.15,	1.f,   0.5f,	0,  1,0,	1,0,
+	1.f,	-0.15,  1.f,   0.5f,	0,	1,0,	1,1,
+	-1.f,	0.15,  -1.f,  0.5f,	0,  1,0,	0,0,
+	-1.f,	0.15,	1.f,   0.5f,	0,  1,0,	1,0,
+	1.f,	0.15,  1.f,   0.5f,	0,	1,0,	1,1,
+	
+};
+
+static const int triangle_indices[]=
+{
+	0,1,2,3,4,5
+};
+#endif
+
+static const float quad_vertices[] =
+	{
+		-1.f,
+		0,
+		-1.f,
+		0.5f,
+		0,
+		1,
+		0,
+		0,
+		0,
+		-1.f,
+		0,
+		1.f,
+		0.5f,
+		0,
+		1,
+		0,
+		1,
+		0,
+		1.f,
+		0,
+		1.f,
+		0.5f,
+		0,
+		1,
+		0,
+		1,
+		1,
+		1.f,
+		0,
+		-1.f,
+		0.5f,
+		0,
+		1,
+		0,
+		0,
+		1,
+};
+
+static const int quad_indices[] =
+	{
+		0, 1, 2, 0, 2, 3};
+
+static const float pyramid_vertices[] =
+	{
+		-1.f, 0, -1.f, 0.5f, 0, 1, 0, 0, 0,
+		-1.f, 0, 1.f, 0.5f, 0, 1, 0, 1, 0,
+		1.f, 0, 1.f, 0.5f, 0, 1, 0, 1, 1,
+		1.f, 0, -1.f, 0.5f, 0, 1, 0, 0, 1,
+		0, -1, 0, 0.5f, 0, 1, 0, 0, 1};
+
+static const int pyramid_indices[] =
+	{
+		0, 1, 2, 0, 2, 3,  //ground face
+		4, 1, 2, 4, 2, 3,
+		4, 3, 0, 4, 0, 1};
+
+static const float tetra_vertices[] =
+	{
+		0.f, 0.f, 1.f, 0.5f, 0, 1, 0, 0, 0,
+		1.f, -1.f, -1.f, 0.5f, 0, 1, 0, 1, 0,
+		-1.f, 1.f, -1.f, 0.5f, 0, 1, 0, 1, 1,
+		-1.f, -1, 1.f, 0.5f, 0, 1, 0, 0, 1};
+
+static const int tetra_indices[] =
+	{
+		0, 1, 2,  //ground face
+		2, 1, 3,
+		1, 0, 3,
+		0, 2, 3};
+
+static const float detailed_sphere_vertices[] =
+	{
+		0.000000f, -0.183479f, -0.983024f, 0.000000f, 0.000000f, -0.183479f, -0.983024f, 0.500000f, 0.408260f,
+		0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.500000f, 0.500000f,
+		0.174499f, -0.056698f, -0.983024f, 0.000000f, 0.174499f, -0.056698f, -0.983024f, 0.587250f, 0.471651f,
+		0.176851f, -0.243415f, -0.953663f, 0.000000f, 0.176851f, -0.243415f, -0.953663f, 0.588426f, 0.378293f,
+		0.174499f, -0.056698f, -0.983024f, 0.000000f, 0.174499f, -0.056698f, -0.983024f, 0.587250f, 0.471651f,
+		0.343074f, -0.111472f, -0.932670f, 0.000000f, 0.343074f, -0.111472f, -0.932670f, 0.671537f, 0.444264f,
+		0.000000f, -0.183479f, -0.983024f, 0.000000f, 0.000000f, -0.183479f, -0.983024f, 0.500000f, 0.408260f,
+		0.176851f, -0.243415f, -0.953663f, 0.000000f, 0.176851f, -0.243415f, -0.953663f, 0.588426f, 0.378293f,
+		0.000000f, -0.360730f, -0.932670f, 0.000000f, 0.000000f, -0.360730f, -0.932670f, 0.500000f, 0.319635f,
+		0.000000f, -0.183479f, -0.983024f, 0.000000f, 0.000000f, -0.183479f, -0.983024f, 0.500000f, 0.408260f,
+		0.174499f, -0.056698f, -0.983024f, 0.000000f, 0.174499f, -0.056698f, -0.983024f, 0.587250f, 0.471651f,
+		0.176851f, -0.243415f, -0.953663f, 0.000000f, 0.176851f, -0.243415f, -0.953663f, 0.588426f, 0.378293f,
+		0.345991f, -0.298381f, -0.889527f, 0.000000f, 0.345991f, -0.298381f, -0.889527f, 0.672996f, 0.350810f,
+		0.343074f, -0.111472f, -0.932670f, 0.000000f, 0.343074f, -0.111472f, -0.932670f, 0.671537f, 0.444264f,
+		0.500000f, -0.162460f, -0.850651f, 0.000000f, 0.500000f, -0.162460f, -0.850651f, 0.750000f, 0.418770f,
+		0.176860f, -0.421262f, -0.889527f, 0.000000f, 0.176860f, -0.421262f, -0.889527f, 0.588430f, 0.289369f,
+		0.176851f, -0.243415f, -0.953663f, 0.000000f, 0.176851f, -0.243415f, -0.953663f, 0.588426f, 0.378293f,
+		0.345991f, -0.298381f, -0.889527f, 0.000000f, 0.345991f, -0.298381f, -0.889527f, 0.672996f, 0.350810f,
+		0.000000f, -0.360730f, -0.932670f, 0.000000f, 0.000000f, -0.360730f, -0.932670f, 0.500000f, 0.319635f,
+		0.176860f, -0.421262f, -0.889527f, 0.000000f, 0.176860f, -0.421262f, -0.889527f, 0.588430f, 0.289369f,
+		0.000000f, -0.525731f, -0.850651f, 0.000000f, 0.000000f, -0.525731f, -0.850651f, 0.500000f, 0.237134f,
+		0.176851f, -0.243415f, -0.953663f, 0.000000f, 0.176851f, -0.243415f, -0.953663f, 0.588426f, 0.378293f,
+		0.343074f, -0.111472f, -0.932670f, 0.000000f, 0.343074f, -0.111472f, -0.932670f, 0.671537f, 0.444264f,
+		0.345991f, -0.298381f, -0.889527f, 0.000000f, 0.345991f, -0.298381f, -0.889527f, 0.672996f, 0.350810f,
+		0.000000f, -0.360730f, -0.932670f, 0.000000f, 0.000000f, -0.360730f, -0.932670f, 0.500000f, 0.319635f,
+		0.176851f, -0.243415f, -0.953663f, 0.000000f, 0.176851f, -0.243415f, -0.953663f, 0.588426f, 0.378293f,
+		0.176860f, -0.421262f, -0.889527f, 0.000000f, 0.176860f, -0.421262f, -0.889527f, 0.588430f, 0.289369f,
+		0.522851f, -0.355846f, -0.774597f, 0.000000f, 0.522851f, -0.355846f, -0.774597f, 0.761425f, 0.322077f,
+		0.500000f, -0.162460f, -0.850651f, 0.000000f, 0.500000f, -0.162460f, -0.850651f, 0.750000f, 0.418770f,
+		0.639949f, -0.207932f, -0.739749f, 0.000000f, 0.639949f, -0.207932f, -0.739749f, 0.819975f, 0.396034f,
+		0.356822f, -0.491123f, -0.794654f, 0.000000f, 0.356822f, -0.491123f, -0.794654f, 0.678411f, 0.254439f,
+		0.345991f, -0.298381f, -0.889527f, 0.000000f, 0.345991f, -0.298381f, -0.889527f, 0.672996f, 0.350810f,
+		0.522851f, -0.355846f, -0.774597f, 0.000000f, 0.522851f, -0.355846f, -0.774597f, 0.761425f, 0.322077f,
+		0.176860f, -0.421262f, -0.889527f, 0.000000f, 0.176860f, -0.421262f, -0.889527f, 0.588430f, 0.289369f,
+		0.356822f, -0.491123f, -0.794654f, 0.000000f, 0.356822f, -0.491123f, -0.794654f, 0.678411f, 0.254439f,
+		0.176860f, -0.607223f, -0.774597f, 0.000000f, 0.176860f, -0.607223f, -0.774597f, 0.588430f, 0.196389f,
+		0.000000f, -0.525731f, -0.850651f, 0.000000f, 0.000000f, -0.525731f, -0.850651f, 0.500000f, 0.237134f,
+		0.176860f, -0.607223f, -0.774597f, 0.000000f, 0.176860f, -0.607223f, -0.774597f, 0.588430f, 0.196389f,
+		0.000000f, -0.672883f, -0.739749f, 0.000000f, 0.000000f, -0.672883f, -0.739749f, 0.500000f, 0.163559f,
+		0.345991f, -0.298381f, -0.889527f, 0.000000f, 0.345991f, -0.298381f, -0.889527f, 0.672996f, 0.350810f,
+		0.500000f, -0.162460f, -0.850651f, 0.000000f, 0.500000f, -0.162460f, -0.850651f, 0.750000f, 0.418770f,
+		0.522851f, -0.355846f, -0.774597f, 0.000000f, 0.522851f, -0.355846f, -0.774597f, 0.761425f, 0.322077f,
+		0.176860f, -0.421262f, -0.889527f, 0.000000f, 0.176860f, -0.421262f, -0.889527f, 0.588430f, 0.289369f,
+		0.345991f, -0.298381f, -0.889527f, 0.000000f, 0.345991f, -0.298381f, -0.889527f, 0.672996f, 0.350810f,
+		0.356822f, -0.491123f, -0.794654f, 0.000000f, 0.356822f, -0.491123f, -0.794654f, 0.678411f, 0.254439f,
+		0.000000f, -0.525731f, -0.850651f, 0.000000f, 0.000000f, -0.525731f, -0.850651f, 0.500000f, 0.237134f,
+		0.176860f, -0.421262f, -0.889527f, 0.000000f, 0.176860f, -0.421262f, -0.889527f, 0.588430f, 0.289369f,
+		0.176860f, -0.607223f, -0.774597f, 0.000000f, 0.176860f, -0.607223f, -0.774597f, 0.588430f, 0.196389f,
+		0.653054f, -0.398142f, -0.644208f, 0.000000f, 0.653054f, -0.398142f, -0.644208f, 0.912551f, 0.300929f,
+		0.639949f, -0.207932f, -0.739749f, 0.000000f, 0.639949f, -0.207932f, -0.739749f, 0.819975f, 0.396034f,
+		0.758172f, -0.246345f, -0.603730f, 0.000000f, 0.758172f, -0.246345f, -0.603730f, 0.960321f, 0.396034f,
+		0.522851f, -0.533682f, -0.664689f, 0.000000f, 0.522851f, -0.533682f, -0.664689f, 0.892312f, 0.376828f,
+		0.522851f, -0.355846f, -0.774597f, 0.000000f, 0.522851f, -0.355846f, -0.774597f, 0.761425f, 0.322077f,
+		0.653054f, -0.398142f, -0.644208f, 0.000000f, 0.653054f, -0.398142f, -0.644208f, 0.912551f, 0.300929f,
+		0.345991f, -0.662178f, -0.664689f, 0.000000f, 0.345991f, -0.662178f, -0.664689f, 0.761425f, 0.233159f,
+		0.356822f, -0.491123f, -0.794654f, 0.000000f, 0.356822f, -0.491123f, -0.794654f, 0.678411f, 0.254439f,
+		0.522851f, -0.533682f, -0.664689f, 0.000000f, 0.522851f, -0.533682f, -0.664689f, 0.892312f, 0.376828f,
+		0.176860f, -0.607223f, -0.774597f, 0.000000f, 0.176860f, -0.607223f, -0.774597f, 0.588430f, 0.196389f,
+		0.345991f, -0.662178f, -0.664689f, 0.000000f, 0.345991f, -0.662178f, -0.664689f, 0.761425f, 0.233159f,
+		0.176851f, -0.744124f, -0.644208f, 0.000000f, 0.176851f, -0.744124f, -0.644208f, 0.826527f, 0.300929f,
+		0.000000f, -0.672883f, -0.739749f, 0.000000f, 0.000000f, -0.672883f, -0.739749f, 0.500000f, 0.163559f,
+		0.176851f, -0.744124f, -0.644208f, 0.000000f, 0.176851f, -0.744124f, -0.644208f, 0.826527f, 0.300929f,
+		0.000000f, -0.797189f, -0.603730f, 0.000000f, 0.000000f, -0.797189f, -0.603730f, 0.672996f, 0.168911f,
+		0.522851f, -0.355846f, -0.774597f, 0.000000f, 0.522851f, -0.355846f, -0.774597f, 0.761425f, 0.322077f,
+		0.639949f, -0.207932f, -0.739749f, 0.000000f, 0.639949f, -0.207932f, -0.739749f, 0.819975f, 0.396034f,
+		0.653054f, -0.398142f, -0.644208f, 0.000000f, 0.653054f, -0.398142f, -0.644208f, 0.912551f, 0.300929f,
+		0.356822f, -0.491123f, -0.794654f, 0.000000f, 0.356822f, -0.491123f, -0.794654f, 0.678411f, 0.254439f,
+		0.522851f, -0.355846f, -0.774597f, 0.000000f, 0.522851f, -0.355846f, -0.774597f, 0.761425f, 0.322077f,
+		0.522851f, -0.533682f, -0.664689f, 0.000000f, 0.522851f, -0.533682f, -0.664689f, 0.892312f, 0.376828f,
+		0.176860f, -0.607223f, -0.774597f, 0.000000f, 0.176860f, -0.607223f, -0.774597f, 0.588430f, 0.196389f,
+		0.356822f, -0.491123f, -0.794654f, 0.000000f, 0.356822f, -0.491123f, -0.794654f, 0.678411f, 0.254439f,
+		0.345991f, -0.662178f, -0.664689f, 0.000000f, 0.345991f, -0.662178f, -0.664689f, 0.761425f, 0.233159f,
+		0.000000f, -0.672883f, -0.739749f, 0.000000f, 0.000000f, -0.672883f, -0.739749f, 0.500000f, 0.163559f,
+		0.176860f, -0.607223f, -0.774597f, 0.000000f, 0.176860f, -0.607223f, -0.774597f, 0.588430f, 0.196389f,
+		0.176851f, -0.744124f, -0.644208f, 0.000000f, 0.176851f, -0.744124f, -0.644208f, 0.826527f, 0.300929f,
+		0.758172f, -0.429824f, -0.490334f, 0.000000f, 0.758172f, -0.429824f, -0.490334f, 0.588426f, 0.127938f,
+		0.758172f, -0.246345f, -0.603730f, 0.000000f, 0.758172f, -0.246345f, -0.603730f, 0.960321f, 0.396034f,
+		0.850651f, -0.276393f, -0.447214f, 0.000000f, 0.850651f, -0.276393f, -0.447214f, 0.500000f, 0.960321f,
+		0.639949f, -0.568662f, -0.516806f, 0.000000f, 0.639949f, -0.568662f, -0.516806f, 0.588426f, 0.912551f,
+		0.653054f, -0.398142f, -0.644208f, 0.000000f, 0.653054f, -0.398142f, -0.644208f, 0.912551f, 0.300929f,
+		0.758172f, -0.429824f, -0.490334f, 0.000000f, 0.758172f, -0.429824f, -0.490334f, 0.588426f, 0.127938f,
+		0.500000f, -0.688191f, -0.525731f, 0.000000f, 0.500000f, -0.688191f, -0.525731f, 0.500000f, 0.892312f,
+		0.522851f, -0.533682f, -0.664689f, 0.000000f, 0.522851f, -0.533682f, -0.664689f, 0.892312f, 0.376828f,
+		0.639949f, -0.568662f, -0.516806f, 0.000000f, 0.639949f, -0.568662f, -0.516806f, 0.588426f, 0.912551f,
+		0.345991f, -0.662178f, -0.664689f, 0.000000f, 0.345991f, -0.662178f, -0.664689f, 0.761425f, 0.233159f,
+		0.500000f, -0.688191f, -0.525731f, 0.000000f, 0.500000f, -0.688191f, -0.525731f, 0.500000f, 0.892312f,
+		0.343074f, -0.784354f, -0.516806f, 0.000000f, 0.343074f, -0.784354f, -0.516806f, 0.835614f, 0.285088f,
+		0.176851f, -0.744124f, -0.644208f, 0.000000f, 0.176851f, -0.744124f, -0.644208f, 0.826527f, 0.300929f,
+		0.343074f, -0.784354f, -0.516806f, 0.000000f, 0.343074f, -0.784354f, -0.516806f, 0.835614f, 0.285088f,
+		0.174499f, -0.853887f, -0.490334f, 0.000000f, 0.174499f, -0.853887f, -0.490334f, 0.814054f, 0.361804f,
+		0.000000f, -0.797189f, -0.603730f, 0.000000f, 0.000000f, -0.797189f, -0.603730f, 0.672996f, 0.168911f,
+		0.174499f, -0.853887f, -0.490334f, 0.000000f, 0.174499f, -0.853887f, -0.490334f, 0.814054f, 0.361804f,
+		0.000000f, -0.894427f, -0.447214f, 0.000000f, 0.000000f, -0.894427f, -0.447214f, 0.848850f, 0.215669f,
+		0.653054f, -0.398142f, -0.644208f, 0.000000f, 0.653054f, -0.398142f, -0.644208f, 0.912551f, 0.300929f,
+		0.758172f, -0.246345f, -0.603730f, 0.000000f, 0.758172f, -0.246345f, -0.603730f, 0.960321f, 0.396034f,
+		0.758172f, -0.429824f, -0.490334f, 0.000000f, 0.758172f, -0.429824f, -0.490334f, 0.588426f, 0.127938f,
+		0.522851f, -0.533682f, -0.664689f, 0.000000f, 0.522851f, -0.533682f, -0.664689f, 0.892312f, 0.376828f,
+		0.653054f, -0.398142f, -0.644208f, 0.000000f, 0.653054f, -0.398142f, -0.644208f, 0.912551f, 0.300929f,
+		0.639949f, -0.568662f, -0.516806f, 0.000000f, 0.639949f, -0.568662f, -0.516806f, 0.588426f, 0.912551f,
+		0.345991f, -0.662178f, -0.664689f, 0.000000f, 0.345991f, -0.662178f, -0.664689f, 0.761425f, 0.233159f,
+		0.522851f, -0.533682f, -0.664689f, 0.000000f, 0.522851f, -0.533682f, -0.664689f, 0.892312f, 0.376828f,
+		0.500000f, -0.688191f, -0.525731f, 0.000000f, 0.500000f, -0.688191f, -0.525731f, 0.500000f, 0.892312f,
+		0.176851f, -0.744124f, -0.644208f, 0.000000f, 0.176851f, -0.744124f, -0.644208f, 0.826527f, 0.300929f,
+		0.345991f, -0.662178f, -0.664689f, 0.000000f, 0.345991f, -0.662178f, -0.664689f, 0.761425f, 0.233159f,
+		0.343074f, -0.784354f, -0.516806f, 0.000000f, 0.343074f, -0.784354f, -0.516806f, 0.835614f, 0.285088f,
+		0.000000f, -0.797189f, -0.603730f, 0.000000f, 0.000000f, -0.797189f, -0.603730f, 0.672996f, 0.168911f,
+		0.176851f, -0.744124f, -0.644208f, 0.000000f, 0.176851f, -0.744124f, -0.644208f, 0.826527f, 0.300929f,
+		0.174499f, -0.853887f, -0.490334f, 0.000000f, 0.174499f, -0.853887f, -0.490334f, 0.814054f, 0.361804f,
+		0.174499f, -0.056698f, -0.983024f, 0.000000f, 0.174499f, -0.056698f, -0.983024f, 0.587250f, 0.471651f,
+		0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.500000f, 0.500000f,
+		0.107846f, 0.148438f, -0.983024f, 0.000000f, 0.107846f, 0.148438f, -0.983024f, 0.750000f, 0.853312f,
+		0.286151f, 0.092976f, -0.953663f, 0.000000f, 0.286151f, 0.092976f, -0.953663f, 0.761425f, 0.922791f,
+		0.107846f, 0.148438f, -0.983024f, 0.000000f, 0.107846f, 0.148438f, -0.983024f, 0.750000f, 0.853312f,
+		0.212032f, 0.291836f, -0.932670f, 0.000000f, 0.212032f, 0.291836f, -0.932670f, 0.819975f, 0.848850f,
+		0.174499f, -0.056698f, -0.983024f, 0.000000f, 0.174499f, -0.056698f, -0.983024f, 0.587250f, 0.471651f,
+		0.286151f, 0.092976f, -0.953663f, 0.000000f, 0.286151f, 0.092976f, -0.953663f, 0.761425f, 0.922791f,
+		0.343074f, -0.111472f, -0.932670f, 0.000000f, 0.343074f, -0.111472f, -0.932670f, 0.671537f, 0.444264f,
+		0.174499f, -0.056698f, -0.983024f, 0.000000f, 0.174499f, -0.056698f, -0.983024f, 0.587250f, 0.471651f,
+		0.107846f, 0.148438f, -0.983024f, 0.000000f, 0.107846f, 0.148438f, -0.983024f, 0.750000f, 0.853312f,
+		0.286151f, 0.092976f, -0.953663f, 0.000000f, 0.286151f, 0.092976f, -0.953663f, 0.761425f, 0.922791f,
+		0.390694f, 0.236853f, -0.889527f, 0.000000f, 0.390694f, 0.236853f, -0.889527f, 0.672996f, 0.922791f,
+		0.212032f, 0.291836f, -0.932670f, 0.000000f, 0.212032f, 0.291836f, -0.932670f, 0.819975f, 0.848850f,
+		0.309017f, 0.425325f, -0.850651f, 0.000000f, 0.309017f, 0.425325f, -0.850651f, 0.671537f, 0.848850f,
+		0.455297f, 0.038026f, -0.889527f, 0.000000f, 0.455297f, 0.038026f, -0.889527f, 0.587250f, 0.835614f,
+		0.286151f, 0.092976f, -0.953663f, 0.000000f, 0.286151f, 0.092976f, -0.953663f, 0.761425f, 0.922791f,
+		0.390694f, 0.236853f, -0.889527f, 0.000000f, 0.390694f, 0.236853f, -0.889527f, 0.672996f, 0.922791f,
+		0.343074f, -0.111472f, -0.932670f, 0.000000f, 0.343074f, -0.111472f, -0.932670f, 0.671537f, 0.444264f,
+		0.455297f, 0.038026f, -0.889527f, 0.000000f, 0.455297f, 0.038026f, -0.889527f, 0.587250f, 0.835614f,
+		0.500000f, -0.162460f, -0.850651f, 0.000000f, 0.500000f, -0.162460f, -0.850651f, 0.750000f, 0.418770f,
+		0.286151f, 0.092976f, -0.953663f, 0.000000f, 0.286151f, 0.092976f, -0.953663f, 0.761425f, 0.922791f,
+		0.212032f, 0.291836f, -0.932670f, 0.000000f, 0.212032f, 0.291836f, -0.932670f, 0.819975f, 0.848850f,
+		0.390694f, 0.236853f, -0.889527f, 0.000000f, 0.390694f, 0.236853f, -0.889527f, 0.672996f, 0.922791f,
+		0.343074f, -0.111472f, -0.932670f, 0.000000f, 0.343074f, -0.111472f, -0.932670f, 0.671537f, 0.444264f,
+		0.286151f, 0.092976f, -0.953663f, 0.000000f, 0.286151f, 0.092976f, -0.953663f, 0.761425f, 0.922791f,
+		0.455297f, 0.038026f, -0.889527f, 0.000000f, 0.455297f, 0.038026f, -0.889527f, 0.587250f, 0.835614f,
+		0.499999f, 0.387298f, -0.774597f, 0.000000f, 0.499999f, 0.387298f, -0.774597f, 0.500000f, 0.814054f,
+		0.309017f, 0.425325f, -0.850651f, 0.000000f, 0.309017f, 0.425325f, -0.850651f, 0.671537f, 0.848850f,
+		0.395510f, 0.544373f, -0.739749f, 0.000000f, 0.395510f, 0.544373f, -0.739749f, 0.922791f, 0.233159f,
+		0.577350f, 0.187592f, -0.794654f, 0.000000f, 0.577350f, 0.187592f, -0.794654f, 0.553923f, 0.574219f,
+		0.390694f, 0.236853f, -0.889527f, 0.000000f, 0.390694f, 0.236853f, -0.889527f, 0.672996f, 0.922791f,
+		0.499999f, 0.387298f, -0.774597f, 0.000000f, 0.499999f, 0.387298f, -0.774597f, 0.500000f, 0.814054f,
+		0.455297f, 0.038026f, -0.889527f, 0.000000f, 0.455297f, 0.038026f, -0.889527f, 0.587250f, 0.835614f,
+		0.577350f, 0.187592f, -0.794654f, 0.000000f, 0.577350f, 0.187592f, -0.794654f, 0.553923f, 0.574219f,
+		0.632156f, -0.019439f, -0.774597f, 0.000000f, 0.632156f, -0.019439f, -0.774597f, 0.643075f, 0.546488f,
+		0.500000f, -0.162460f, -0.850651f, 0.000000f, 0.500000f, -0.162460f, -0.850651f, 0.750000f, 0.418770f,
+		0.632156f, -0.019439f, -0.774597f, 0.000000f, 0.632156f, -0.019439f, -0.774597f, 0.643075f, 0.546488f,
+		0.639949f, -0.207932f, -0.739749f, 0.000000f, 0.639949f, -0.207932f, -0.739749f, 0.819975f, 0.396034f,
+		0.390694f, 0.236853f, -0.889527f, 0.000000f, 0.390694f, 0.236853f, -0.889527f, 0.672996f, 0.922791f,
+		0.309017f, 0.425325f, -0.850651f, 0.000000f, 0.309017f, 0.425325f, -0.850651f, 0.671537f, 0.848850f,
+		0.499999f, 0.387298f, -0.774597f, 0.000000f, 0.499999f, 0.387298f, -0.774597f, 0.500000f, 0.814054f,
+		0.455297f, 0.038026f, -0.889527f, 0.000000f, 0.455297f, 0.038026f, -0.889527f, 0.587250f, 0.835614f,
+		0.390694f, 0.236853f, -0.889527f, 0.000000f, 0.390694f, 0.236853f, -0.889527f, 0.672996f, 0.922791f,
+		0.577350f, 0.187592f, -0.794654f, 0.000000f, 0.577350f, 0.187592f, -0.794654f, 0.553923f, 0.574219f,
+		0.500000f, -0.162460f, -0.850651f, 0.000000f, 0.500000f, -0.162460f, -0.850651f, 0.750000f, 0.418770f,
+		0.455297f, 0.038026f, -0.889527f, 0.000000f, 0.455297f, 0.038026f, -0.889527f, 0.587250f, 0.835614f,
+		0.632156f, -0.019439f, -0.774597f, 0.000000f, 0.632156f, -0.019439f, -0.774597f, 0.643075f, 0.546488f,
+		0.580460f, 0.498058f, -0.644208f, 0.000000f, 0.580460f, 0.498058f, -0.644208f, 0.606016f, 0.645918f,
+		0.395510f, 0.544373f, -0.739749f, 0.000000f, 0.395510f, 0.544373f, -0.739749f, 0.922791f, 0.233159f,
+		0.468576f, 0.644939f, -0.603730f, 0.000000f, 0.468576f, 0.644939f, -0.603730f, 0.695347f, 0.618427f,
+		0.669131f, 0.332344f, -0.664689f, 0.000000f, 0.669131f, 0.332344f, -0.664689f, 0.654508f, 0.712663f,
+		0.499999f, 0.387298f, -0.774597f, 0.000000f, 0.499999f, 0.387298f, -0.774597f, 0.500000f, 0.814054f,
+		0.580460f, 0.498058f, -0.644208f, 0.000000f, 0.580460f, 0.498058f, -0.644208f, 0.606016f, 0.645918f,
+		0.736686f, 0.124433f, -0.664689f, 0.000000f, 0.736686f, 0.124433f, -0.664689f, 0.727648f, 0.519013f,
+		0.577350f, 0.187592f, -0.794654f, 0.000000f, 0.577350f, 0.187592f, -0.794654f, 0.553923f, 0.574219f,
+		0.669131f, 0.332344f, -0.664689f, 0.000000f, 0.669131f, 0.332344f, -0.664689f, 0.654508f, 0.712663f,
+		0.632156f, -0.019439f, -0.774597f, 0.000000f, 0.632156f, -0.019439f, -0.774597f, 0.643075f, 0.546488f,
+		0.736686f, 0.124433f, -0.664689f, 0.000000f, 0.736686f, 0.124433f, -0.664689f, 0.727648f, 0.519013f,
+		0.762354f, -0.061752f, -0.644208f, 0.000000f, 0.762354f, -0.061752f, -0.644208f, 0.750000f, 0.693649f,
+		0.639949f, -0.207932f, -0.739749f, 0.000000f, 0.639949f, -0.207932f, -0.739749f, 0.819975f, 0.396034f,
+		0.762354f, -0.061752f, -0.644208f, 0.000000f, 0.762354f, -0.061752f, -0.644208f, 0.750000f, 0.693649f,
+		0.758172f, -0.246345f, -0.603730f, 0.000000f, 0.758172f, -0.246345f, -0.603730f, 0.960321f, 0.396034f,
+		0.499999f, 0.387298f, -0.774597f, 0.000000f, 0.499999f, 0.387298f, -0.774597f, 0.500000f, 0.814054f,
+		0.395510f, 0.544373f, -0.739749f, 0.000000f, 0.395510f, 0.544373f, -0.739749f, 0.922791f, 0.233159f,
+		0.580460f, 0.498058f, -0.644208f, 0.000000f, 0.580460f, 0.498058f, -0.644208f, 0.606016f, 0.645918f,
+		0.577350f, 0.187592f, -0.794654f, 0.000000f, 0.577350f, 0.187592f, -0.794654f, 0.553923f, 0.574219f,
+		0.499999f, 0.387298f, -0.774597f, 0.000000f, 0.499999f, 0.387298f, -0.774597f, 0.500000f, 0.814054f,
+		0.669131f, 0.332344f, -0.664689f, 0.000000f, 0.669131f, 0.332344f, -0.664689f, 0.654508f, 0.712663f,
+		0.632156f, -0.019439f, -0.774597f, 0.000000f, 0.632156f, -0.019439f, -0.774597f, 0.643075f, 0.546488f,
+		0.577350f, 0.187592f, -0.794654f, 0.000000f, 0.577350f, 0.187592f, -0.794654f, 0.553923f, 0.574219f,
+		0.736686f, 0.124433f, -0.664689f, 0.000000f, 0.736686f, 0.124433f, -0.664689f, 0.727648f, 0.519013f,
+		0.639949f, -0.207932f, -0.739749f, 0.000000f, 0.639949f, -0.207932f, -0.739749f, 0.819975f, 0.396034f,
+		0.632156f, -0.019439f, -0.774597f, 0.000000f, 0.632156f, -0.019439f, -0.774597f, 0.643075f, 0.546488f,
+		0.762354f, -0.061752f, -0.644208f, 0.000000f, 0.762354f, -0.061752f, -0.644208f, 0.750000f, 0.693649f,
+		0.643075f, 0.588241f, -0.490334f, 0.000000f, 0.643075f, 0.588241f, -0.490334f, 0.697755f, 0.772187f,
+		0.468576f, 0.644939f, -0.603730f, 0.000000f, 0.468576f, 0.644939f, -0.603730f, 0.695347f, 0.618427f,
+		0.525731f, 0.723607f, -0.447214f, 0.000000f, 0.525731f, 0.723607f, -0.447214f, 0.788675f, 0.593796f,
+		0.738585f, 0.432902f, -0.516806f, 0.000000f, 0.738585f, 0.432902f, -0.516806f, 0.816078f, 0.490281f,
+		0.580460f, 0.498058f, -0.644208f, 0.000000f, 0.580460f, 0.498058f, -0.644208f, 0.606016f, 0.645918f,
+		0.643075f, 0.588241f, -0.490334f, 0.000000f, 0.643075f, 0.588241f, -0.490334f, 0.697755f, 0.772187f,
+		0.809017f, 0.262865f, -0.525731f, 0.000000f, 0.809017f, 0.262865f, -0.525731f, 0.790230f, 0.749029f,
+		0.669131f, 0.332344f, -0.664689f, 0.000000f, 0.669131f, 0.332344f, -0.664689f, 0.654508f, 0.712663f,
+		0.738585f, 0.432902f, -0.516806f, 0.000000f, 0.738585f, 0.432902f, -0.516806f, 0.816078f, 0.490281f,
+		0.736686f, 0.124433f, -0.664689f, 0.000000f, 0.736686f, 0.124433f, -0.664689f, 0.727648f, 0.519013f,
+		0.809017f, 0.262865f, -0.525731f, 0.000000f, 0.809017f, 0.262865f, -0.525731f, 0.790230f, 0.749029f,
+		0.851981f, 0.083904f, -0.516806f, 0.000000f, 0.851981f, 0.083904f, -0.516806f, 0.734288f, 0.822469f,
+		0.762354f, -0.061752f, -0.644208f, 0.000000f, 0.762354f, -0.061752f, -0.644208f, 0.750000f, 0.693649f,
+		0.851981f, 0.083904f, -0.516806f, 0.000000f, 0.851981f, 0.083904f, -0.516806f, 0.734288f, 0.822469f,
+		0.866018f, -0.097907f, -0.490334f, 0.000000f, 0.866018f, -0.097907f, -0.490334f, 0.834566f, 0.666172f,
+		0.758172f, -0.246345f, -0.603730f, 0.000000f, 0.758172f, -0.246345f, -0.603730f, 0.960321f, 0.396034f,
+		0.866018f, -0.097907f, -0.490334f, 0.000000f, 0.866018f, -0.097907f, -0.490334f, 0.834566f, 0.666172f,
+		0.850651f, -0.276393f, -0.447214f, 0.000000f, 0.850651f, -0.276393f, -0.447214f, 0.500000f, 0.960321f,
+		0.580460f, 0.498058f, -0.644208f, 0.000000f, 0.580460f, 0.498058f, -0.644208f, 0.606016f, 0.645918f,
+		0.468576f, 0.644939f, -0.603730f, 0.000000f, 0.468576f, 0.644939f, -0.603730f, 0.695347f, 0.618427f,
+		0.643075f, 0.588241f, -0.490334f, 0.000000f, 0.643075f, 0.588241f, -0.490334f, 0.697755f, 0.772187f,
+		0.669131f, 0.332344f, -0.664689f, 0.000000f, 0.669131f, 0.332344f, -0.664689f, 0.654508f, 0.712663f,
+		0.580460f, 0.498058f, -0.644208f, 0.000000f, 0.580460f, 0.498058f, -0.644208f, 0.606016f, 0.645918f,
+		0.738585f, 0.432902f, -0.516806f, 0.000000f, 0.738585f, 0.432902f, -0.516806f, 0.816078f, 0.490281f,
+		0.736686f, 0.124433f, -0.664689f, 0.000000f, 0.736686f, 0.124433f, -0.664689f, 0.727648f, 0.519013f,
+		0.669131f, 0.332344f, -0.664689f, 0.000000f, 0.669131f, 0.332344f, -0.664689f, 0.654508f, 0.712663f,
+		0.809017f, 0.262865f, -0.525731f, 0.000000f, 0.809017f, 0.262865f, -0.525731f, 0.790230f, 0.749029f,
+		0.762354f, -0.061752f, -0.644208f, 0.000000f, 0.762354f, -0.061752f, -0.644208f, 0.750000f, 0.693649f,
+		0.736686f, 0.124433f, -0.664689f, 0.000000f, 0.736686f, 0.124433f, -0.664689f, 0.727648f, 0.519013f,
+		0.851981f, 0.083904f, -0.516806f, 0.000000f, 0.851981f, 0.083904f, -0.516806f, 0.734288f, 0.822469f,
+		0.758172f, -0.246345f, -0.603730f, 0.000000f, 0.758172f, -0.246345f, -0.603730f, 0.960321f, 0.396034f,
+		0.762354f, -0.061752f, -0.644208f, 0.000000f, 0.762354f, -0.061752f, -0.644208f, 0.750000f, 0.693649f,
+		0.866018f, -0.097907f, -0.490334f, 0.000000f, 0.866018f, -0.097907f, -0.490334f, 0.834566f, 0.666172f,
+		0.107846f, 0.148438f, -0.983024f, 0.000000f, 0.107846f, 0.148438f, -0.983024f, 0.750000f, 0.853312f,
+		0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.500000f, 0.500000f,
+		-0.107846f, 0.148438f, -0.983024f, 0.000000f, -0.107846f, 0.148438f, -0.983024f, 0.868343f, 0.562217f,
+		0.000000f, 0.300877f, -0.953663f, 0.000000f, 0.000000f, 0.300877f, -0.953663f, 0.977745f, 0.490281f,
+		-0.107846f, 0.148438f, -0.983024f, 0.000000f, -0.107846f, 0.148438f, -0.983024f, 0.868343f, 0.562217f,
+		-0.212032f, 0.291836f, -0.932670f, 0.000000f, -0.212032f, 0.291836f, -0.932670f, 0.922791f, 0.562217f,
+		0.107846f, 0.148438f, -0.983024f, 0.000000f, 0.107846f, 0.148438f, -0.983024f, 0.750000f, 0.853312f,
+		0.000000f, 0.300877f, -0.953663f, 0.000000f, 0.000000f, 0.300877f, -0.953663f, 0.977745f, 0.490281f,
+		0.212032f, 0.291836f, -0.932670f, 0.000000f, 0.212032f, 0.291836f, -0.932670f, 0.819975f, 0.848850f,
+		0.107846f, 0.148438f, -0.983024f, 0.000000f, 0.107846f, 0.148438f, -0.983024f, 0.750000f, 0.853312f,
+		-0.107846f, 0.148438f, -0.983024f, 0.000000f, -0.107846f, 0.148438f, -0.983024f, 0.868343f, 0.562217f,
+		0.000000f, 0.300877f, -0.953663f, 0.000000f, 0.000000f, 0.300877f, -0.953663f, 0.977745f, 0.490281f,
+		-0.104529f, 0.444764f, -0.889527f, 0.000000f, -0.104529f, 0.444764f, -0.889527f, 0.912551f, 0.469124f,
+		-0.212032f, 0.291836f, -0.932670f, 0.000000f, -0.212032f, 0.291836f, -0.932670f, 0.922791f, 0.562217f,
+		-0.309017f, 0.425325f, -0.850651f, 0.000000f, -0.309017f, 0.425325f, -0.850651f, 0.881177f, 0.469124f,
+		0.104529f, 0.444764f, -0.889527f, 0.000000f, 0.104529f, 0.444764f, -0.889527f, 0.821537f, 0.835614f,
+		0.000000f, 0.300877f, -0.953663f, 0.000000f, 0.000000f, 0.300877f, -0.953663f, 0.977745f, 0.490281f,
+		-0.104529f, 0.444764f, -0.889527f, 0.000000f, -0.104529f, 0.444764f, -0.889527f, 0.912551f, 0.469124f,
+		0.212032f, 0.291836f, -0.932670f, 0.000000f, 0.212032f, 0.291836f, -0.932670f, 0.819975f, 0.848850f,
+		0.104529f, 0.444764f, -0.889527f, 0.000000f, 0.104529f, 0.444764f, -0.889527f, 0.821537f, 0.835614f,
+		0.309017f, 0.425325f, -0.850651f, 0.000000f, 0.309017f, 0.425325f, -0.850651f, 0.671537f, 0.848850f,
+		0.000000f, 0.300877f, -0.953663f, 0.000000f, 0.000000f, 0.300877f, -0.953663f, 0.977745f, 0.490281f,
+		-0.212032f, 0.291836f, -0.932670f, 0.000000f, -0.212032f, 0.291836f, -0.932670f, 0.922791f, 0.562217f,
+		-0.104529f, 0.444764f, -0.889527f, 0.000000f, -0.104529f, 0.444764f, -0.889527f, 0.912551f, 0.469124f,
+		0.212032f, 0.291836f, -0.932670f, 0.000000f, 0.212032f, 0.291836f, -0.932670f, 0.819975f, 0.848850f,
+		0.000000f, 0.300877f, -0.953663f, 0.000000f, 0.000000f, 0.300877f, -0.953663f, 0.977745f, 0.490281f,
+		0.104529f, 0.444764f, -0.889527f, 0.000000f, 0.104529f, 0.444764f, -0.889527f, 0.821537f, 0.835614f,
+		-0.213834f, 0.595209f, -0.774597f, 0.000000f, -0.213834f, 0.595209f, -0.774597f, 0.734288f, 0.892312f,
+		-0.309017f, 0.425325f, -0.850651f, 0.000000f, -0.309017f, 0.425325f, -0.850651f, 0.881177f, 0.469124f,
+		-0.395510f, 0.544373f, -0.739749f, 0.000000f, -0.395510f, 0.544373f, -0.739749f, 0.762866f, 0.814054f,
+		0.000000f, 0.607062f, -0.794654f, 0.000000f, 0.000000f, 0.607062f, -0.794654f, 0.848850f, 0.716451f,
+		-0.104529f, 0.444764f, -0.889527f, 0.000000f, -0.104529f, 0.444764f, -0.889527f, 0.912551f, 0.469124f,
+		-0.213834f, 0.595209f, -0.774597f, 0.000000f, -0.213834f, 0.595209f, -0.774597f, 0.734288f, 0.892312f,
+		0.104529f, 0.444764f, -0.889527f, 0.000000f, 0.104529f, 0.444764f, -0.889527f, 0.821537f, 0.835614f,
+		0.000000f, 0.607062f, -0.794654f, 0.000000f, 0.000000f, 0.607062f, -0.794654f, 0.848850f, 0.716451f,
+		0.213834f, 0.595209f, -0.774597f, 0.000000f, 0.213834f, 0.595209f, -0.774597f, 0.912551f, 0.749029f,
+		0.309017f, 0.425325f, -0.850651f, 0.000000f, 0.309017f, 0.425325f, -0.850651f, 0.671537f, 0.848850f,
+		0.213834f, 0.595209f, -0.774597f, 0.000000f, 0.213834f, 0.595209f, -0.774597f, 0.912551f, 0.749029f,
+		0.395510f, 0.544373f, -0.739749f, 0.000000f, 0.395510f, 0.544373f, -0.739749f, 0.922791f, 0.233159f,
+		-0.104529f, 0.444764f, -0.889527f, 0.000000f, -0.104529f, 0.444764f, -0.889527f, 0.912551f, 0.469124f,
+		-0.309017f, 0.425325f, -0.850651f, 0.000000f, -0.309017f, 0.425325f, -0.850651f, 0.881177f, 0.469124f,
+		-0.213834f, 0.595209f, -0.774597f, 0.000000f, -0.213834f, 0.595209f, -0.774597f, 0.734288f, 0.892312f,
+		0.104529f, 0.444764f, -0.889527f, 0.000000f, 0.104529f, 0.444764f, -0.889527f, 0.821537f, 0.835614f,
+		-0.104529f, 0.444764f, -0.889527f, 0.000000f, -0.104529f, 0.444764f, -0.889527f, 0.912551f, 0.469124f,
+		0.000000f, 0.607062f, -0.794654f, 0.000000f, 0.000000f, 0.607062f, -0.794654f, 0.848850f, 0.716451f,
+		0.309017f, 0.425325f, -0.850651f, 0.000000f, 0.309017f, 0.425325f, -0.850651f, 0.671537f, 0.848850f,
+		0.104529f, 0.444764f, -0.889527f, 0.000000f, 0.104529f, 0.444764f, -0.889527f, 0.821537f, 0.835614f,
+		0.213834f, 0.595209f, -0.774597f, 0.000000f, 0.213834f, 0.595209f, -0.774597f, 0.912551f, 0.749029f,
+		-0.294309f, 0.705959f, -0.644208f, 0.000000f, -0.294309f, 0.705959f, -0.644208f, 0.835614f, 0.794120f,
+		-0.395510f, 0.544373f, -0.739749f, 0.000000f, -0.395510f, 0.544373f, -0.739749f, 0.762866f, 0.814054f,
+		-0.468576f, 0.644939f, -0.603730f, 0.000000f, -0.468576f, 0.644939f, -0.603730f, 0.853312f, 0.631433f,
+		-0.109305f, 0.739082f, -0.664689f, 0.000000f, -0.109305f, 0.739082f, -0.664689f, 0.922791f, 0.666172f,
+		-0.213834f, 0.595209f, -0.774597f, 0.000000f, -0.213834f, 0.595209f, -0.774597f, 0.734288f, 0.892312f,
+		-0.294309f, 0.705959f, -0.644208f, 0.000000f, -0.294309f, 0.705959f, -0.644208f, 0.835614f, 0.794120f,
+		0.109305f, 0.739082f, -0.664689f, 0.000000f, 0.109305f, 0.739082f, -0.664689f, 0.848850f, 0.541952f,
+		0.000000f, 0.607062f, -0.794654f, 0.000000f, 0.000000f, 0.607062f, -0.794654f, 0.848850f, 0.716451f,
+		-0.109305f, 0.739082f, -0.664689f, 0.000000f, -0.109305f, 0.739082f, -0.664689f, 0.922791f, 0.666172f,
+		0.213834f, 0.595209f, -0.774597f, 0.000000f, 0.213834f, 0.595209f, -0.774597f, 0.912551f, 0.749029f,
+		0.109305f, 0.739082f, -0.664689f, 0.000000f, 0.109305f, 0.739082f, -0.664689f, 0.848850f, 0.541952f,
+		0.294310f, 0.705959f, -0.644208f, 0.000000f, 0.294310f, 0.705959f, -0.644208f, 0.835614f, 0.451046f,
+		0.395510f, 0.544373f, -0.739749f, 0.000000f, 0.395510f, 0.544373f, -0.739749f, 0.922791f, 0.233159f,
+		0.294310f, 0.705959f, -0.644208f, 0.000000f, 0.294310f, 0.705959f, -0.644208f, 0.835614f, 0.451046f,
+		0.468576f, 0.644939f, -0.603730f, 0.000000f, 0.468576f, 0.644939f, -0.603730f, 0.695347f, 0.618427f,
+		-0.213834f, 0.595209f, -0.774597f, 0.000000f, -0.213834f, 0.595209f, -0.774597f, 0.734288f, 0.892312f,
+		-0.395510f, 0.544373f, -0.739749f, 0.000000f, -0.395510f, 0.544373f, -0.739749f, 0.762866f, 0.814054f,
+		-0.294309f, 0.705959f, -0.644208f, 0.000000f, -0.294309f, 0.705959f, -0.644208f, 0.835614f, 0.794120f,
+		0.000000f, 0.607062f, -0.794654f, 0.000000f, 0.000000f, 0.607062f, -0.794654f, 0.848850f, 0.716451f,
+		-0.213834f, 0.595209f, -0.774597f, 0.000000f, -0.213834f, 0.595209f, -0.774597f, 0.734288f, 0.892312f,
+		-0.109305f, 0.739082f, -0.664689f, 0.000000f, -0.109305f, 0.739082f, -0.664689f, 0.922791f, 0.666172f,
+		0.213834f, 0.595209f, -0.774597f, 0.000000f, 0.213834f, 0.595209f, -0.774597f, 0.912551f, 0.749029f,
+		0.000000f, 0.607062f, -0.794654f, 0.000000f, 0.000000f, 0.607062f, -0.794654f, 0.848850f, 0.716451f,
+		0.109305f, 0.739082f, -0.664689f, 0.000000f, 0.109305f, 0.739082f, -0.664689f, 0.848850f, 0.541952f,
+		0.395510f, 0.544373f, -0.739749f, 0.000000f, 0.395510f, 0.544373f, -0.739749f, 0.922791f, 0.233159f,
+		0.213834f, 0.595209f, -0.774597f, 0.000000f, 0.213834f, 0.595209f, -0.774597f, 0.912551f, 0.749029f,
+		0.294310f, 0.705959f, -0.644208f, 0.000000f, 0.294310f, 0.705959f, -0.644208f, 0.835614f, 0.451046f,
+		-0.360730f, 0.793377f, -0.490334f, 0.000000f, -0.360730f, 0.793377f, -0.490334f, 0.790230f, 0.912551f,
+		-0.468576f, 0.644939f, -0.603730f, 0.000000f, -0.468576f, 0.644939f, -0.603730f, 0.853312f, 0.631433f,
+		-0.525731f, 0.723607f, -0.447214f, 0.000000f, -0.525731f, 0.723607f, -0.447214f, 0.446077f, 0.574219f,
+		-0.183479f, 0.836210f, -0.516806f, 0.000000f, -0.183479f, 0.836210f, -0.516806f, 0.500000f, 0.650438f,
+		-0.294309f, 0.705959f, -0.644208f, 0.000000f, -0.294309f, 0.705959f, -0.644208f, 0.835614f, 0.794120f,
+		-0.360730f, 0.793377f, -0.490334f, 0.000000f, -0.360730f, 0.793377f, -0.490334f, 0.790230f, 0.912551f,
+		0.000000f, 0.850651f, -0.525731f, 0.000000f, 0.000000f, 0.850651f, -0.525731f, 0.393984f, 0.645918f,
+		-0.109305f, 0.739082f, -0.664689f, 0.000000f, -0.109305f, 0.739082f, -0.664689f, 0.922791f, 0.666172f,
+		-0.183479f, 0.836210f, -0.516806f, 0.000000f, -0.183479f, 0.836210f, -0.516806f, 0.500000f, 0.650438f,
+		0.109305f, 0.739082f, -0.664689f, 0.000000f, 0.109305f, 0.739082f, -0.664689f, 0.848850f, 0.541952f,
+		0.000000f, 0.850651f, -0.525731f, 0.000000f, 0.000000f, 0.850651f, -0.525731f, 0.393984f, 0.645918f,
+		0.183479f, 0.836210f, -0.516806f, 0.000000f, 0.183479f, 0.836210f, -0.516806f, 0.447735f, 0.722382f,
+		0.294310f, 0.705959f, -0.644208f, 0.000000f, 0.294310f, 0.705959f, -0.644208f, 0.835614f, 0.451046f,
+		0.183479f, 0.836210f, -0.516806f, 0.000000f, 0.183479f, 0.836210f, -0.516806f, 0.447735f, 0.722382f,
+		0.360730f, 0.793377f, -0.490334f, 0.000000f, 0.360730f, 0.793377f, -0.490334f, 0.345491f, 0.712663f,
+		0.468576f, 0.644939f, -0.603730f, 0.000000f, 0.468576f, 0.644939f, -0.603730f, 0.695347f, 0.618427f,
+		0.360730f, 0.793377f, -0.490334f, 0.000000f, 0.360730f, 0.793377f, -0.490334f, 0.345491f, 0.712663f,
+		0.525731f, 0.723607f, -0.447214f, 0.000000f, 0.525731f, 0.723607f, -0.447214f, 0.788675f, 0.593796f,
+		-0.294309f, 0.705959f, -0.644208f, 0.000000f, -0.294309f, 0.705959f, -0.644208f, 0.835614f, 0.794120f,
+		-0.468576f, 0.644939f, -0.603730f, 0.000000f, -0.468576f, 0.644939f, -0.603730f, 0.853312f, 0.631433f,
+		-0.360730f, 0.793377f, -0.490334f, 0.000000f, -0.360730f, 0.793377f, -0.490334f, 0.790230f, 0.912551f,
+		-0.109305f, 0.739082f, -0.664689f, 0.000000f, -0.109305f, 0.739082f, -0.664689f, 0.922791f, 0.666172f,
+		-0.294309f, 0.705959f, -0.644208f, 0.000000f, -0.294309f, 0.705959f, -0.644208f, 0.835614f, 0.794120f,
+		-0.183479f, 0.836210f, -0.516806f, 0.000000f, -0.183479f, 0.836210f, -0.516806f, 0.500000f, 0.650438f,
+		0.109305f, 0.739082f, -0.664689f, 0.000000f, 0.109305f, 0.739082f, -0.664689f, 0.848850f, 0.541952f,
+		-0.109305f, 0.739082f, -0.664689f, 0.000000f, -0.109305f, 0.739082f, -0.664689f, 0.922791f, 0.666172f,
+		0.000000f, 0.850651f, -0.525731f, 0.000000f, 0.000000f, 0.850651f, -0.525731f, 0.393984f, 0.645918f,
+		0.294310f, 0.705959f, -0.644208f, 0.000000f, 0.294310f, 0.705959f, -0.644208f, 0.835614f, 0.451046f,
+		0.109305f, 0.739082f, -0.664689f, 0.000000f, 0.109305f, 0.739082f, -0.664689f, 0.848850f, 0.541952f,
+		0.183479f, 0.836210f, -0.516806f, 0.000000f, 0.183479f, 0.836210f, -0.516806f, 0.447735f, 0.722382f,
+		0.468576f, 0.644939f, -0.603730f, 0.000000f, 0.468576f, 0.644939f, -0.603730f, 0.695347f, 0.618427f,
+		0.294310f, 0.705959f, -0.644208f, 0.000000f, 0.294310f, 0.705959f, -0.644208f, 0.835614f, 0.451046f,
+		0.360730f, 0.793377f, -0.490334f, 0.000000f, 0.360730f, 0.793377f, -0.490334f, 0.345491f, 0.712663f,
+		0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.500000f, 0.500000f,
+		-0.174499f, -0.056698f, -0.983024f, 0.000000f, -0.174499f, -0.056698f, -0.983024f, 0.552265f, 0.722382f,
+		-0.107846f, 0.148438f, -0.983024f, 0.000000f, -0.107846f, 0.148438f, -0.983024f, 0.868343f, 0.562217f,
+		-0.286151f, 0.092976f, -0.953663f, 0.000000f, -0.286151f, 0.092976f, -0.953663f, 0.393083f, 0.797605f,
+		-0.174499f, -0.056698f, -0.983024f, 0.000000f, -0.174499f, -0.056698f, -0.983024f, 0.552265f, 0.722382f,
+		-0.343074f, -0.111472f, -0.932670f, 0.000000f, -0.343074f, -0.111472f, -0.932670f, 0.302245f, 0.772187f,
+		-0.107846f, 0.148438f, -0.983024f, 0.000000f, -0.107846f, 0.148438f, -0.983024f, 0.868343f, 0.562217f,
+		-0.286151f, 0.092976f, -0.953663f, 0.000000f, -0.286151f, 0.092976f, -0.953663f, 0.393083f, 0.797605f,
+		-0.212032f, 0.291836f, -0.932670f, 0.000000f, -0.212032f, 0.291836f, -0.932670f, 0.922791f, 0.562217f,
+		-0.107846f, 0.148438f, -0.983024f, 0.000000f, -0.107846f, 0.148438f, -0.983024f, 0.868343f, 0.562217f,
+		-0.174499f, -0.056698f, -0.983024f, 0.000000f, -0.174499f, -0.056698f, -0.983024f, 0.552265f, 0.722382f,
+		-0.286151f, 0.092976f, -0.953663f, 0.000000f, -0.286151f, 0.092976f, -0.953663f, 0.393083f, 0.797605f,
+		-0.455297f, 0.038026f, -0.889527f, 0.000000f, -0.455297f, 0.038026f, -0.889527f, 0.500000f, 0.803531f,
+		-0.343074f, -0.111472f, -0.932670f, 0.000000f, -0.343074f, -0.111472f, -0.932670f, 0.302245f, 0.772187f,
+		-0.500000f, -0.162460f, -0.850651f, 0.000000f, -0.500000f, -0.162460f, -0.850651f, 0.606917f, 0.797605f,
+		-0.286151f, 0.092976f, -0.953663f, 0.000000f, -0.286151f, 0.092976f, -0.953663f, 0.393083f, 0.797605f,
+		-0.455297f, 0.038026f, -0.889527f, 0.000000f, -0.455297f, 0.038026f, -0.889527f, 0.500000f, 0.803531f,
+		-0.390694f, 0.236853f, -0.889527f, 0.000000f, -0.390694f, 0.236853f, -0.889527f, 0.352845f, 0.852980f,
+		-0.212032f, 0.291836f, -0.932670f, 0.000000f, -0.212032f, 0.291836f, -0.932670f, 0.922791f, 0.562217f,
+		-0.390694f, 0.236853f, -0.889527f, 0.000000f, -0.390694f, 0.236853f, -0.889527f, 0.352845f, 0.852980f,
+		-0.309017f, 0.425325f, -0.850651f, 0.000000f, -0.309017f, 0.425325f, -0.850651f, 0.881177f, 0.469124f,
+		-0.286151f, 0.092976f, -0.953663f, 0.000000f, -0.286151f, 0.092976f, -0.953663f, 0.393083f, 0.797605f,
+		-0.343074f, -0.111472f, -0.932670f, 0.000000f, -0.343074f, -0.111472f, -0.932670f, 0.302245f, 0.772187f,
+		-0.455297f, 0.038026f, -0.889527f, 0.000000f, -0.455297f, 0.038026f, -0.889527f, 0.500000f, 0.803531f,
+		-0.212032f, 0.291836f, -0.932670f, 0.000000f, -0.212032f, 0.291836f, -0.932670f, 0.922791f, 0.562217f,
+		-0.286151f, 0.092976f, -0.953663f, 0.000000f, -0.286151f, 0.092976f, -0.953663f, 0.393083f, 0.797605f,
+		-0.390694f, 0.236853f, -0.889527f, 0.000000f, -0.390694f, 0.236853f, -0.889527f, 0.352845f, 0.852980f,
+		-0.632156f, -0.019439f, -0.774597f, 0.000000f, -0.632156f, -0.019439f, -0.774597f, 0.265712f, 0.822469f,
+		-0.500000f, -0.162460f, -0.850651f, 0.000000f, -0.500000f, -0.162460f, -0.850651f, 0.606917f, 0.797605f,
+		-0.639949f, -0.207932f, -0.739749f, 0.000000f, -0.639949f, -0.207932f, -0.739749f, 0.445347f, 0.869541f,
+		-0.577350f, 0.187593f, -0.794654f, 0.000000f, -0.577350f, 0.187593f, -0.794654f, 0.554653f, 0.869541f,
+		-0.455297f, 0.038026f, -0.889527f, 0.000000f, -0.455297f, 0.038026f, -0.889527f, 0.500000f, 0.803531f,
+		-0.632156f, -0.019439f, -0.774597f, 0.000000f, -0.632156f, -0.019439f, -0.774597f, 0.265712f, 0.822469f,
+		-0.390694f, 0.236853f, -0.889527f, 0.000000f, -0.390694f, 0.236853f, -0.889527f, 0.352845f, 0.852980f,
+		-0.577350f, 0.187593f, -0.794654f, 0.000000f, -0.577350f, 0.187593f, -0.794654f, 0.554653f, 0.869541f,
+		-0.499999f, 0.387299f, -0.774597f, 0.000000f, -0.499999f, 0.387299f, -0.774597f, 0.647155f, 0.852980f,
+		-0.309017f, 0.425325f, -0.850651f, 0.000000f, -0.309017f, 0.425325f, -0.850651f, 0.881177f, 0.469124f,
+		-0.499999f, 0.387299f, -0.774597f, 0.000000f, -0.499999f, 0.387299f, -0.774597f, 0.647155f, 0.852980f,
+		-0.395510f, 0.544373f, -0.739749f, 0.000000f, -0.395510f, 0.544373f, -0.739749f, 0.762866f, 0.814054f,
+		-0.455297f, 0.038026f, -0.889527f, 0.000000f, -0.455297f, 0.038026f, -0.889527f, 0.500000f, 0.803531f,
+		-0.500000f, -0.162460f, -0.850651f, 0.000000f, -0.500000f, -0.162460f, -0.850651f, 0.606917f, 0.797605f,
+		-0.632156f, -0.019439f, -0.774597f, 0.000000f, -0.632156f, -0.019439f, -0.774597f, 0.265712f, 0.822469f,
+		-0.390694f, 0.236853f, -0.889527f, 0.000000f, -0.390694f, 0.236853f, -0.889527f, 0.352845f, 0.852980f,
+		-0.455297f, 0.038026f, -0.889527f, 0.000000f, -0.455297f, 0.038026f, -0.889527f, 0.500000f, 0.803531f,
+		-0.577350f, 0.187593f, -0.794654f, 0.000000f, -0.577350f, 0.187593f, -0.794654f, 0.554653f, 0.869541f,
+		-0.309017f, 0.425325f, -0.850651f, 0.000000f, -0.309017f, 0.425325f, -0.850651f, 0.881177f, 0.469124f,
+		-0.390694f, 0.236853f, -0.889527f, 0.000000f, -0.390694f, 0.236853f, -0.889527f, 0.352845f, 0.852980f,
+		-0.499999f, 0.387299f, -0.774597f, 0.000000f, -0.499999f, 0.387299f, -0.774597f, 0.647155f, 0.852980f,
+		-0.762354f, -0.061751f, -0.644208f, 0.000000f, -0.762354f, -0.061751f, -0.644208f, 0.319635f, 0.835614f,
+		-0.639949f, -0.207932f, -0.739749f, 0.000000f, -0.639949f, -0.207932f, -0.739749f, 0.445347f, 0.869541f,
+		-0.758172f, -0.246345f, -0.603730f, 0.000000f, -0.758172f, -0.246345f, -0.603730f, 0.265712f, 0.892312f,
+		-0.736685f, 0.124433f, -0.664689f, 0.000000f, -0.736685f, 0.124433f, -0.664689f, 0.237134f, 0.814054f,
+		-0.632156f, -0.019439f, -0.774597f, 0.000000f, -0.632156f, -0.019439f, -0.774597f, 0.265712f, 0.822469f,
+		-0.762354f, -0.061751f, -0.644208f, 0.000000f, -0.762354f, -0.061751f, -0.644208f, 0.319635f, 0.835614f,
+		-0.577350f, 0.187593f, -0.794654f, 0.000000f, -0.577350f, 0.187593f, -0.794654f, 0.554653f, 0.869541f,
+		-0.736685f, 0.124433f, -0.664689f, 0.000000f, -0.736685f, 0.124433f, -0.664689f, 0.237134f, 0.814054f,
+		-0.669131f, 0.332344f, -0.664689f, 0.000000f, -0.669131f, 0.332344f, -0.664689f, 0.408260f, 0.848850f,
+		-0.499999f, 0.387299f, -0.774597f, 0.000000f, -0.499999f, 0.387299f, -0.774597f, 0.647155f, 0.852980f,
+		-0.669131f, 0.332344f, -0.664689f, 0.000000f, -0.669131f, 0.332344f, -0.664689f, 0.408260f, 0.848850f,
+		-0.580460f, 0.498058f, -0.644208f, 0.000000f, -0.580460f, 0.498058f, -0.644208f, 0.352845f, 0.912551f,
+		-0.395510f, 0.544373f, -0.739749f, 0.000000f, -0.395510f, 0.544373f, -0.739749f, 0.762866f, 0.814054f,
+		-0.580460f, 0.498058f, -0.644208f, 0.000000f, -0.580460f, 0.498058f, -0.644208f, 0.352845f, 0.912551f,
+		-0.468576f, 0.644939f, -0.603730f, 0.000000f, -0.468576f, 0.644939f, -0.603730f, 0.853312f, 0.631433f,
+		-0.632156f, -0.019439f, -0.774597f, 0.000000f, -0.632156f, -0.019439f, -0.774597f, 0.265712f, 0.822469f,
+		-0.639949f, -0.207932f, -0.739749f, 0.000000f, -0.639949f, -0.207932f, -0.739749f, 0.445347f, 0.869541f,
+		-0.762354f, -0.061751f, -0.644208f, 0.000000f, -0.762354f, -0.061751f, -0.644208f, 0.319635f, 0.835614f,
+		-0.577350f, 0.187593f, -0.794654f, 0.000000f, -0.577350f, 0.187593f, -0.794654f, 0.554653f, 0.869541f,
+		-0.632156f, -0.019439f, -0.774597f, 0.000000f, -0.632156f, -0.019439f, -0.774597f, 0.265712f, 0.822469f,
+		-0.736685f, 0.124433f, -0.664689f, 0.000000f, -0.736685f, 0.124433f, -0.664689f, 0.237134f, 0.814054f,
+		-0.499999f, 0.387299f, -0.774597f, 0.000000f, -0.499999f, 0.387299f, -0.774597f, 0.647155f, 0.852980f,
+		-0.577350f, 0.187593f, -0.794654f, 0.000000f, -0.577350f, 0.187593f, -0.794654f, 0.554653f, 0.869541f,
+		-0.669131f, 0.332344f, -0.664689f, 0.000000f, -0.669131f, 0.332344f, -0.664689f, 0.408260f, 0.848850f,
+		-0.395510f, 0.544373f, -0.739749f, 0.000000f, -0.395510f, 0.544373f, -0.739749f, 0.762866f, 0.814054f,
+		-0.499999f, 0.387299f, -0.774597f, 0.000000f, -0.499999f, 0.387299f, -0.774597f, 0.647155f, 0.852980f,
+		-0.580460f, 0.498058f, -0.644208f, 0.000000f, -0.580460f, 0.498058f, -0.644208f, 0.352845f, 0.912551f,
+		-0.866018f, -0.097907f, -0.490334f, 0.000000f, -0.866018f, -0.097907f, -0.490334f, 0.500000f, 0.853312f,
+		-0.758172f, -0.246345f, -0.603730f, 0.000000f, -0.758172f, -0.246345f, -0.603730f, 0.265712f, 0.892312f,
+		-0.850651f, -0.276393f, -0.447214f, 0.000000f, -0.850651f, -0.276393f, -0.447214f, 0.445347f, 0.922791f,
+		-0.851981f, 0.083904f, -0.516806f, 0.000000f, -0.851981f, 0.083904f, -0.516806f, 0.554653f, 0.922791f,
+		-0.762354f, -0.061751f, -0.644208f, 0.000000f, -0.762354f, -0.061751f, -0.644208f, 0.319635f, 0.835614f,
+		-0.866018f, -0.097907f, -0.490334f, 0.000000f, -0.866018f, -0.097907f, -0.490334f, 0.500000f, 0.853312f,
+		-0.809017f, 0.262866f, -0.525731f, 0.000000f, -0.809017f, 0.262866f, -0.525731f, 0.591739f, 0.848850f,
+		-0.736685f, 0.124433f, -0.664689f, 0.000000f, -0.736685f, 0.124433f, -0.664689f, 0.237134f, 0.814054f,
+		-0.851981f, 0.083904f, -0.516806f, 0.000000f, -0.851981f, 0.083904f, -0.516806f, 0.554653f, 0.922791f,
+		-0.669131f, 0.332344f, -0.664689f, 0.000000f, -0.669131f, 0.332344f, -0.664689f, 0.408260f, 0.848850f,
+		-0.809017f, 0.262866f, -0.525731f, 0.000000f, -0.809017f, 0.262866f, -0.525731f, 0.591739f, 0.848850f,
+		-0.738585f, 0.432902f, -0.516806f, 0.000000f, -0.738585f, 0.432902f, -0.516806f, 0.647155f, 0.912551f,
+		-0.580460f, 0.498058f, -0.644208f, 0.000000f, -0.580460f, 0.498058f, -0.644208f, 0.352845f, 0.912551f,
+		-0.738585f, 0.432902f, -0.516806f, 0.000000f, -0.738585f, 0.432902f, -0.516806f, 0.647155f, 0.912551f,
+		-0.643075f, 0.588241f, -0.490334f, 0.000000f, -0.643075f, 0.588241f, -0.490334f, 0.680365f, 0.835614f,
+		-0.468576f, 0.644939f, -0.603730f, 0.000000f, -0.468576f, 0.644939f, -0.603730f, 0.853312f, 0.631433f,
+		-0.643075f, 0.588241f, -0.490334f, 0.000000f, -0.643075f, 0.588241f, -0.490334f, 0.680365f, 0.835614f,
+		-0.525731f, 0.723607f, -0.447214f, 0.000000f, -0.525731f, 0.723607f, -0.447214f, 0.446077f, 0.574219f,
+		-0.762354f, -0.061751f, -0.644208f, 0.000000f, -0.762354f, -0.061751f, -0.644208f, 0.319635f, 0.835614f,
+		-0.758172f, -0.246345f, -0.603730f, 0.000000f, -0.758172f, -0.246345f, -0.603730f, 0.265712f, 0.892312f,
+		-0.866018f, -0.097907f, -0.490334f, 0.000000f, -0.866018f, -0.097907f, -0.490334f, 0.500000f, 0.853312f,
+		-0.736685f, 0.124433f, -0.664689f, 0.000000f, -0.736685f, 0.124433f, -0.664689f, 0.237134f, 0.814054f,
+		-0.762354f, -0.061751f, -0.644208f, 0.000000f, -0.762354f, -0.061751f, -0.644208f, 0.319635f, 0.835614f,
+		-0.851981f, 0.083904f, -0.516806f, 0.000000f, -0.851981f, 0.083904f, -0.516806f, 0.554653f, 0.922791f,
+		-0.669131f, 0.332344f, -0.664689f, 0.000000f, -0.669131f, 0.332344f, -0.664689f, 0.408260f, 0.848850f,
+		-0.736685f, 0.124433f, -0.664689f, 0.000000f, -0.736685f, 0.124433f, -0.664689f, 0.237134f, 0.814054f,
+		-0.809017f, 0.262866f, -0.525731f, 0.000000f, -0.809017f, 0.262866f, -0.525731f, 0.591739f, 0.848850f,
+		-0.580460f, 0.498058f, -0.644208f, 0.000000f, -0.580460f, 0.498058f, -0.644208f, 0.352845f, 0.912551f,
+		-0.669131f, 0.332344f, -0.664689f, 0.000000f, -0.669131f, 0.332344f, -0.664689f, 0.408260f, 0.848850f,
+		-0.738585f, 0.432902f, -0.516806f, 0.000000f, -0.738585f, 0.432902f, -0.516806f, 0.647155f, 0.912551f,
+		-0.468576f, 0.644939f, -0.603730f, 0.000000f, -0.468576f, 0.644939f, -0.603730f, 0.853312f, 0.631433f,
+		-0.580460f, 0.498058f, -0.644208f, 0.000000f, -0.580460f, 0.498058f, -0.644208f, 0.352845f, 0.912551f,
+		-0.643075f, 0.588241f, -0.490334f, 0.000000f, -0.643075f, 0.588241f, -0.490334f, 0.680365f, 0.835614f,
+		0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.500000f, 0.500000f,
+		0.000000f, -0.183479f, -0.983024f, 0.000000f, 0.000000f, -0.183479f, -0.983024f, 0.500000f, 0.408260f,
+		-0.174499f, -0.056698f, -0.983024f, 0.000000f, -0.174499f, -0.056698f, -0.983024f, 0.552265f, 0.722382f,
+		-0.176851f, -0.243415f, -0.953663f, 0.000000f, -0.176851f, -0.243415f, -0.953663f, 0.412750f, 0.471651f,
+		0.000000f, -0.183479f, -0.983024f, 0.000000f, 0.000000f, -0.183479f, -0.983024f, 0.500000f, 0.408260f,
+		0.000000f, -0.360730f, -0.932670f, 0.000000f, 0.000000f, -0.360730f, -0.932670f, 0.500000f, 0.319635f,
+		-0.174499f, -0.056698f, -0.983024f, 0.000000f, -0.174499f, -0.056698f, -0.983024f, 0.552265f, 0.722382f,
+		-0.176851f, -0.243415f, -0.953663f, 0.000000f, -0.176851f, -0.243415f, -0.953663f, 0.412750f, 0.471651f,
+		-0.343074f, -0.111472f, -0.932670f, 0.000000f, -0.343074f, -0.111472f, -0.932670f, 0.302245f, 0.772187f,
+		-0.174499f, -0.056698f, -0.983024f, 0.000000f, -0.174499f, -0.056698f, -0.983024f, 0.552265f, 0.722382f,
+		0.000000f, -0.183479f, -0.983024f, 0.000000f, 0.000000f, -0.183479f, -0.983024f, 0.500000f, 0.408260f,
+		-0.176851f, -0.243415f, -0.953663f, 0.000000f, -0.176851f, -0.243415f, -0.953663f, 0.412750f, 0.471651f,
+		-0.176860f, -0.421262f, -0.889527f, 0.000000f, -0.176860f, -0.421262f, -0.889527f, 0.356925f, 0.546488f,
+		0.000000f, -0.360730f, -0.932670f, 0.000000f, 0.000000f, -0.360730f, -0.932670f, 0.500000f, 0.319635f,
+		0.000000f, -0.525731f, -0.850651f, 0.000000f, 0.000000f, -0.525731f, -0.850651f, 0.500000f, 0.237134f,
+		-0.176851f, -0.243415f, -0.953663f, 0.000000f, -0.176851f, -0.243415f, -0.953663f, 0.412750f, 0.471651f,
+		-0.176860f, -0.421262f, -0.889527f, 0.000000f, -0.176860f, -0.421262f, -0.889527f, 0.356925f, 0.546488f,
+		-0.345991f, -0.298381f, -0.889527f, 0.000000f, -0.345991f, -0.298381f, -0.889527f, 0.328463f, 0.444264f,
+		-0.343074f, -0.111472f, -0.932670f, 0.000000f, -0.343074f, -0.111472f, -0.932670f, 0.302245f, 0.772187f,
+		-0.345991f, -0.298381f, -0.889527f, 0.000000f, -0.345991f, -0.298381f, -0.889527f, 0.328463f, 0.444264f,
+		-0.500000f, -0.162460f, -0.850651f, 0.000000f, -0.500000f, -0.162460f, -0.850651f, 0.606917f, 0.797605f,
+		-0.176851f, -0.243415f, -0.953663f, 0.000000f, -0.176851f, -0.243415f, -0.953663f, 0.412750f, 0.471651f,
+		0.000000f, -0.360730f, -0.932670f, 0.000000f, 0.000000f, -0.360730f, -0.932670f, 0.500000f, 0.319635f,
+		-0.176860f, -0.421262f, -0.889527f, 0.000000f, -0.176860f, -0.421262f, -0.889527f, 0.356925f, 0.546488f,
+		-0.343074f, -0.111472f, -0.932670f, 0.000000f, -0.343074f, -0.111472f, -0.932670f, 0.302245f, 0.772187f,
+		-0.176851f, -0.243415f, -0.953663f, 0.000000f, -0.176851f, -0.243415f, -0.953663f, 0.412750f, 0.471651f,
+		-0.345991f, -0.298381f, -0.889527f, 0.000000f, -0.345991f, -0.298381f, -0.889527f, 0.328463f, 0.444264f,
+		-0.176860f, -0.607223f, -0.774597f, 0.000000f, -0.176860f, -0.607223f, -0.774597f, 0.272352f, 0.519013f,
+		0.000000f, -0.525731f, -0.850651f, 0.000000f, 0.000000f, -0.525731f, -0.850651f, 0.500000f, 0.237134f,
+		0.000000f, -0.672883f, -0.739749f, 0.000000f, 0.000000f, -0.672883f, -0.739749f, 0.500000f, 0.163559f,
+		-0.356822f, -0.491123f, -0.794655f, 0.000000f, -0.356822f, -0.491123f, -0.794655f, 0.250000f, 0.418770f,
+		-0.176860f, -0.421262f, -0.889527f, 0.000000f, -0.176860f, -0.421262f, -0.889527f, 0.356925f, 0.546488f,
+		-0.176860f, -0.607223f, -0.774597f, 0.000000f, -0.176860f, -0.607223f, -0.774597f, 0.272352f, 0.519013f,
+		-0.345991f, -0.298381f, -0.889527f, 0.000000f, -0.345991f, -0.298381f, -0.889527f, 0.328463f, 0.444264f,
+		-0.356822f, -0.491123f, -0.794655f, 0.000000f, -0.356822f, -0.491123f, -0.794655f, 0.250000f, 0.418770f,
+		-0.522851f, -0.355846f, -0.774597f, 0.000000f, -0.522851f, -0.355846f, -0.774597f, 0.304653f, 0.618427f,
+		-0.500000f, -0.162460f, -0.850651f, 0.000000f, -0.500000f, -0.162460f, -0.850651f, 0.606917f, 0.797605f,
+		-0.522851f, -0.355846f, -0.774597f, 0.000000f, -0.522851f, -0.355846f, -0.774597f, 0.304653f, 0.618427f,
+		-0.639949f, -0.207932f, -0.739749f, 0.000000f, -0.639949f, -0.207932f, -0.739749f, 0.445347f, 0.869541f,
+		-0.176860f, -0.421262f, -0.889527f, 0.000000f, -0.176860f, -0.421262f, -0.889527f, 0.356925f, 0.546488f,
+		0.000000f, -0.525731f, -0.850651f, 0.000000f, 0.000000f, -0.525731f, -0.850651f, 0.500000f, 0.237134f,
+		-0.176860f, -0.607223f, -0.774597f, 0.000000f, -0.176860f, -0.607223f, -0.774597f, 0.272352f, 0.519013f,
+		-0.345991f, -0.298381f, -0.889527f, 0.000000f, -0.345991f, -0.298381f, -0.889527f, 0.328463f, 0.444264f,
+		-0.176860f, -0.421262f, -0.889527f, 0.000000f, -0.176860f, -0.421262f, -0.889527f, 0.356925f, 0.546488f,
+		-0.356822f, -0.491123f, -0.794655f, 0.000000f, -0.356822f, -0.491123f, -0.794655f, 0.250000f, 0.418770f,
+		-0.500000f, -0.162460f, -0.850651f, 0.000000f, -0.500000f, -0.162460f, -0.850651f, 0.606917f, 0.797605f,
+		-0.345991f, -0.298381f, -0.889527f, 0.000000f, -0.345991f, -0.298381f, -0.889527f, 0.328463f, 0.444264f,
+		-0.522851f, -0.355846f, -0.774597f, 0.000000f, -0.522851f, -0.355846f, -0.774597f, 0.304653f, 0.618427f,
+		-0.176851f, -0.744124f, -0.644208f, 0.000000f, -0.176851f, -0.744124f, -0.644208f, 0.183922f, 0.490281f,
+		0.000000f, -0.672883f, -0.739749f, 0.000000f, 0.000000f, -0.672883f, -0.739749f, 0.500000f, 0.163559f,
+		0.000000f, -0.797189f, -0.603730f, 0.000000f, 0.000000f, -0.797189f, -0.603730f, 0.672996f, 0.168911f,
+		-0.345991f, -0.662178f, -0.664689f, 0.000000f, -0.345991f, -0.662178f, -0.664689f, 0.180025f, 0.396034f,
+		-0.176860f, -0.607223f, -0.774597f, 0.000000f, -0.176860f, -0.607223f, -0.774597f, 0.272352f, 0.519013f,
+		-0.176851f, -0.744124f, -0.644208f, 0.000000f, -0.176851f, -0.744124f, -0.644208f, 0.183922f, 0.490281f,
+		-0.356822f, -0.491123f, -0.794655f, 0.000000f, -0.356822f, -0.491123f, -0.794655f, 0.250000f, 0.418770f,
+		-0.345991f, -0.662178f, -0.664689f, 0.000000f, -0.345991f, -0.662178f, -0.664689f, 0.180025f, 0.396034f,
+		-0.522851f, -0.533681f, -0.664689f, 0.000000f, -0.522851f, -0.533681f, -0.664689f, 0.211325f, 0.593796f,
+		-0.522851f, -0.355846f, -0.774597f, 0.000000f, -0.522851f, -0.355846f, -0.774597f, 0.304653f, 0.618427f,
+		-0.522851f, -0.533681f, -0.664689f, 0.000000f, -0.522851f, -0.533681f, -0.664689f, 0.211325f, 0.593796f,
+		-0.653054f, -0.398142f, -0.644208f, 0.000000f, -0.653054f, -0.398142f, -0.644208f, 0.250001f, 0.693650f,
+		-0.639949f, -0.207932f, -0.739749f, 0.000000f, -0.639949f, -0.207932f, -0.739749f, 0.445347f, 0.869541f,
+		-0.653054f, -0.398142f, -0.644208f, 0.000000f, -0.653054f, -0.398142f, -0.644208f, 0.250001f, 0.693650f,
+		-0.758172f, -0.246345f, -0.603730f, 0.000000f, -0.758172f, -0.246345f, -0.603730f, 0.265712f, 0.892312f,
+		-0.176860f, -0.607223f, -0.774597f, 0.000000f, -0.176860f, -0.607223f, -0.774597f, 0.272352f, 0.519013f,
+		0.000000f, -0.672883f, -0.739749f, 0.000000f, 0.000000f, -0.672883f, -0.739749f, 0.500000f, 0.163559f,
+		-0.176851f, -0.744124f, -0.644208f, 0.000000f, -0.176851f, -0.744124f, -0.644208f, 0.183922f, 0.490281f,
+		-0.356822f, -0.491123f, -0.794655f, 0.000000f, -0.356822f, -0.491123f, -0.794655f, 0.250000f, 0.418770f,
+		-0.176860f, -0.607223f, -0.774597f, 0.000000f, -0.176860f, -0.607223f, -0.774597f, 0.272352f, 0.519013f,
+		-0.345991f, -0.662178f, -0.664689f, 0.000000f, -0.345991f, -0.662178f, -0.664689f, 0.180025f, 0.396034f,
+		-0.522851f, -0.355846f, -0.774597f, 0.000000f, -0.522851f, -0.355846f, -0.774597f, 0.304653f, 0.618427f,
+		-0.356822f, -0.491123f, -0.794655f, 0.000000f, -0.356822f, -0.491123f, -0.794655f, 0.250000f, 0.418770f,
+		-0.522851f, -0.533681f, -0.664689f, 0.000000f, -0.522851f, -0.533681f, -0.664689f, 0.211325f, 0.593796f,
+		-0.639949f, -0.207932f, -0.739749f, 0.000000f, -0.639949f, -0.207932f, -0.739749f, 0.445347f, 0.869541f,
+		-0.522851f, -0.355846f, -0.774597f, 0.000000f, -0.522851f, -0.355846f, -0.774597f, 0.304653f, 0.618427f,
+		-0.653054f, -0.398142f, -0.644208f, 0.000000f, -0.653054f, -0.398142f, -0.644208f, 0.250001f, 0.693650f,
+		-0.174499f, -0.853887f, -0.490334f, 0.000000f, -0.174499f, -0.853887f, -0.490334f, 0.131658f, 0.562217f,
+		0.000000f, -0.797189f, -0.603730f, 0.000000f, 0.000000f, -0.797189f, -0.603730f, 0.672996f, 0.168911f,
+		0.000000f, -0.894427f, -0.447214f, 0.000000f, 0.000000f, -0.894427f, -0.447214f, 0.848850f, 0.215669f,
+		-0.343074f, -0.784354f, -0.516806f, 0.000000f, -0.343074f, -0.784354f, -0.516806f, 0.165435f, 0.666172f,
+		-0.176851f, -0.744124f, -0.644208f, 0.000000f, -0.176851f, -0.744124f, -0.644208f, 0.183922f, 0.490281f,
+		-0.174499f, -0.853887f, -0.490334f, 0.000000f, -0.174499f, -0.853887f, -0.490334f, 0.131658f, 0.562217f,
+		-0.500000f, -0.688191f, -0.525731f, 0.000000f, -0.500000f, -0.688191f, -0.525731f, 0.209770f, 0.749029f,
+		-0.345991f, -0.662178f, -0.664689f, 0.000000f, -0.345991f, -0.662178f, -0.664689f, 0.180025f, 0.396034f,
+		-0.343074f, -0.784354f, -0.516806f, 0.000000f, -0.343074f, -0.784354f, -0.516806f, 0.165435f, 0.666172f,
+		-0.522851f, -0.533681f, -0.664689f, 0.000000f, -0.522851f, -0.533681f, -0.664689f, 0.211325f, 0.593796f,
+		-0.500000f, -0.688191f, -0.525731f, 0.000000f, -0.500000f, -0.688191f, -0.525731f, 0.209770f, 0.749029f,
+		-0.639949f, -0.568662f, -0.516806f, 0.000000f, -0.639949f, -0.568662f, -0.516806f, 0.118823f, 0.469124f,
+		-0.653054f, -0.398142f, -0.644208f, 0.000000f, -0.653054f, -0.398142f, -0.644208f, 0.250001f, 0.693650f,
+		-0.639949f, -0.568662f, -0.516806f, 0.000000f, -0.639949f, -0.568662f, -0.516806f, 0.118823f, 0.469124f,
+		-0.758172f, -0.429824f, -0.490334f, 0.000000f, -0.758172f, -0.429824f, -0.490334f, 0.178463f, 0.835614f,
+		-0.758172f, -0.246345f, -0.603730f, 0.000000f, -0.758172f, -0.246345f, -0.603730f, 0.265712f, 0.892312f,
+		-0.758172f, -0.429824f, -0.490334f, 0.000000f, -0.758172f, -0.429824f, -0.490334f, 0.178463f, 0.835614f,
+		-0.850651f, -0.276393f, -0.447214f, 0.000000f, -0.850651f, -0.276393f, -0.447214f, 0.445347f, 0.922791f,
+		-0.176851f, -0.744124f, -0.644208f, 0.000000f, -0.176851f, -0.744124f, -0.644208f, 0.183922f, 0.490281f,
+		0.000000f, -0.797189f, -0.603730f, 0.000000f, 0.000000f, -0.797189f, -0.603730f, 0.672996f, 0.168911f,
+		-0.174499f, -0.853887f, -0.490334f, 0.000000f, -0.174499f, -0.853887f, -0.490334f, 0.131658f, 0.562217f,
+		-0.345991f, -0.662178f, -0.664689f, 0.000000f, -0.345991f, -0.662178f, -0.664689f, 0.180025f, 0.396034f,
+		-0.176851f, -0.744124f, -0.644208f, 0.000000f, -0.176851f, -0.744124f, -0.644208f, 0.183922f, 0.490281f,
+		-0.343074f, -0.784354f, -0.516806f, 0.000000f, -0.343074f, -0.784354f, -0.516806f, 0.165435f, 0.666172f,
+		-0.522851f, -0.533681f, -0.664689f, 0.000000f, -0.522851f, -0.533681f, -0.664689f, 0.211325f, 0.593796f,
+		-0.345991f, -0.662178f, -0.664689f, 0.000000f, -0.345991f, -0.662178f, -0.664689f, 0.180025f, 0.396034f,
+		-0.500000f, -0.688191f, -0.525731f, 0.000000f, -0.500000f, -0.688191f, -0.525731f, 0.209770f, 0.749029f,
+		-0.653054f, -0.398142f, -0.644208f, 0.000000f, -0.653054f, -0.398142f, -0.644208f, 0.250001f, 0.693650f,
+		-0.522851f, -0.533681f, -0.664689f, 0.000000f, -0.522851f, -0.533681f, -0.664689f, 0.211325f, 0.593796f,
+		-0.639949f, -0.568662f, -0.516806f, 0.000000f, -0.639949f, -0.568662f, -0.516806f, 0.118823f, 0.469124f,
+		-0.758172f, -0.246345f, -0.603730f, 0.000000f, -0.758172f, -0.246345f, -0.603730f, 0.265712f, 0.892312f,
+		-0.653054f, -0.398142f, -0.644208f, 0.000000f, -0.653054f, -0.398142f, -0.644208f, 0.250001f, 0.693650f,
+		-0.758172f, -0.429824f, -0.490334f, 0.000000f, -0.758172f, -0.429824f, -0.490334f, 0.178463f, 0.835614f,
+		0.107846f, -0.148438f, 0.983024f, 0.000000f, 0.107846f, -0.148438f, 0.983024f, 0.209770f, 0.912551f,
+		0.174499f, 0.056698f, 0.983024f, 0.000000f, 0.174499f, 0.056698f, 0.983024f, 0.411574f, 0.378293f,
+		0.000000f, 0.000000f, 1.000000f, 0.000000f, 0.000000f, 0.000000f, 1.000000f, 0.411570f, 0.289369f,
+		0.212032f, -0.291836f, 0.932670f, 0.000000f, 0.212032f, -0.291836f, 0.932670f, 0.327004f, 0.350810f,
+		0.286151f, -0.092976f, 0.953663f, 0.000000f, 0.286151f, -0.092976f, 0.953663f, 0.411570f, 0.196389f,
+		0.107846f, -0.148438f, 0.983024f, 0.000000f, 0.107846f, -0.148438f, 0.983024f, 0.209770f, 0.912551f,
+		0.286151f, -0.092976f, 0.953663f, 0.000000f, 0.286151f, -0.092976f, 0.953663f, 0.411570f, 0.196389f,
+		0.343074f, 0.111472f, 0.932670f, 0.000000f, 0.343074f, 0.111472f, 0.932670f, 0.321589f, 0.254439f,
+		0.174499f, 0.056698f, 0.983024f, 0.000000f, 0.174499f, 0.056698f, 0.983024f, 0.411574f, 0.378293f,
+		0.107846f, -0.148438f, 0.983024f, 0.000000f, 0.107846f, -0.148438f, 0.983024f, 0.209770f, 0.912551f,
+		0.286151f, -0.092976f, 0.953663f, 0.000000f, 0.286151f, -0.092976f, 0.953663f, 0.411570f, 0.196389f,
+		0.174499f, 0.056698f, 0.983024f, 0.000000f, 0.174499f, 0.056698f, 0.983024f, 0.411574f, 0.378293f,
+		0.309017f, -0.425325f, 0.850651f, 0.000000f, 0.309017f, -0.425325f, 0.850651f, 0.238575f, 0.322077f,
+		0.390694f, -0.236853f, 0.889527f, 0.000000f, 0.390694f, -0.236853f, 0.889527f, 0.411574f, 0.912551f,
+		0.212032f, -0.291836f, 0.932670f, 0.000000f, 0.212032f, -0.291836f, 0.932670f, 0.327004f, 0.350810f,
+		0.390694f, -0.236853f, 0.889527f, 0.000000f, 0.390694f, -0.236853f, 0.889527f, 0.411574f, 0.912551f,
+		0.455297f, -0.038026f, 0.889527f, 0.000000f, 0.455297f, -0.038026f, 0.889527f, 0.327004f, 0.168911f,
+		0.286151f, -0.092976f, 0.953663f, 0.000000f, 0.286151f, -0.092976f, 0.953663f, 0.411570f, 0.196389f,
+		0.455297f, -0.038026f, 0.889527f, 0.000000f, 0.455297f, -0.038026f, 0.889527f, 0.327004f, 0.168911f,
+		0.500000f, 0.162460f, 0.850651f, 0.000000f, 0.500000f, 0.162460f, 0.850651f, 0.411574f, 0.127938f,
+		0.343074f, 0.111472f, 0.932670f, 0.000000f, 0.343074f, 0.111472f, 0.932670f, 0.321589f, 0.254439f,
+		0.212032f, -0.291836f, 0.932670f, 0.000000f, 0.212032f, -0.291836f, 0.932670f, 0.327004f, 0.350810f,
+		0.390694f, -0.236853f, 0.889527f, 0.000000f, 0.390694f, -0.236853f, 0.889527f, 0.411574f, 0.912551f,
+		0.286151f, -0.092976f, 0.953663f, 0.000000f, 0.286151f, -0.092976f, 0.953663f, 0.411570f, 0.196389f,
+		0.455297f, -0.038026f, 0.889527f, 0.000000f, 0.455297f, -0.038026f, 0.889527f, 0.327004f, 0.168911f,
+		0.343074f, 0.111472f, 0.932670f, 0.000000f, 0.343074f, 0.111472f, 0.932670f, 0.321589f, 0.254439f,
+		0.286151f, -0.092976f, 0.953663f, 0.000000f, 0.286151f, -0.092976f, 0.953663f, 0.411570f, 0.196389f,
+		0.395510f, -0.544373f, 0.739749f, 0.000000f, 0.395510f, -0.544373f, 0.739749f, 0.238575f, 0.233160f,
+		0.499999f, -0.387298f, 0.774597f, 0.000000f, 0.499999f, -0.387298f, 0.774597f, 0.173473f, 0.300929f,
+		0.309017f, -0.425325f, 0.850651f, 0.000000f, 0.309017f, -0.425325f, 0.850651f, 0.238575f, 0.322077f,
+		0.499999f, -0.387298f, 0.774597f, 0.000000f, 0.499999f, -0.387298f, 0.774597f, 0.173473f, 0.300929f,
+		0.577350f, -0.187592f, 0.794654f, 0.000000f, 0.577350f, -0.187592f, 0.794654f, 0.412750f, 0.835614f,
+		0.390694f, -0.236853f, 0.889527f, 0.000000f, 0.390694f, -0.236853f, 0.889527f, 0.411574f, 0.912551f,
+		0.577350f, -0.187592f, 0.794654f, 0.000000f, 0.577350f, -0.187592f, 0.794654f, 0.412750f, 0.835614f,
+		0.632156f, 0.019439f, 0.774597f, 0.000000f, 0.632156f, 0.019439f, 0.774597f, 0.328463f, 0.848850f,
+		0.455297f, -0.038026f, 0.889527f, 0.000000f, 0.455297f, -0.038026f, 0.889527f, 0.327004f, 0.168911f,
+		0.632156f, 0.019439f, 0.774597f, 0.000000f, 0.632156f, 0.019439f, 0.774597f, 0.328463f, 0.848850f,
+		0.639949f, 0.207932f, 0.739749f, 0.000000f, 0.639949f, 0.207932f, 0.739749f, 0.250000f, 0.853312f,
+		0.500000f, 0.162460f, 0.850651f, 0.000000f, 0.500000f, 0.162460f, 0.850651f, 0.411574f, 0.127938f,
+		0.309017f, -0.425325f, 0.850651f, 0.000000f, 0.309017f, -0.425325f, 0.850651f, 0.238575f, 0.322077f,
+		0.499999f, -0.387298f, 0.774597f, 0.000000f, 0.499999f, -0.387298f, 0.774597f, 0.173473f, 0.300929f,
+		0.390694f, -0.236853f, 0.889527f, 0.000000f, 0.390694f, -0.236853f, 0.889527f, 0.411574f, 0.912551f,
+		0.390694f, -0.236853f, 0.889527f, 0.000000f, 0.390694f, -0.236853f, 0.889527f, 0.411574f, 0.912551f,
+		0.577350f, -0.187592f, 0.794654f, 0.000000f, 0.577350f, -0.187592f, 0.794654f, 0.412750f, 0.835614f,
+		0.455297f, -0.038026f, 0.889527f, 0.000000f, 0.455297f, -0.038026f, 0.889527f, 0.327004f, 0.168911f,
+		0.632156f, 0.019439f, 0.774597f, 0.000000f, 0.632156f, 0.019439f, 0.774597f, 0.328463f, 0.848850f,
+		0.500000f, 0.162460f, 0.850651f, 0.000000f, 0.500000f, 0.162460f, 0.850651f, 0.411574f, 0.127938f,
+		0.455297f, -0.038026f, 0.889527f, 0.000000f, 0.455297f, -0.038026f, 0.889527f, 0.327004f, 0.168911f,
+		0.468576f, -0.644939f, 0.603730f, 0.000000f, 0.468576f, -0.644939f, 0.603730f, 0.327004f, 0.922791f,
+		0.580460f, -0.498058f, 0.644208f, 0.000000f, 0.580460f, -0.498058f, 0.644208f, 0.238575f, 0.922791f,
+		0.395510f, -0.544373f, 0.739749f, 0.000000f, 0.395510f, -0.544373f, 0.739749f, 0.238575f, 0.233160f,
+		0.580460f, -0.498058f, 0.644208f, 0.000000f, 0.580460f, -0.498058f, 0.644208f, 0.238575f, 0.922791f,
+		0.669131f, -0.332344f, 0.664689f, 0.000000f, 0.669131f, -0.332344f, 0.664689f, 0.180025f, 0.848850f,
+		0.499999f, -0.387298f, 0.774597f, 0.000000f, 0.499999f, -0.387298f, 0.774597f, 0.173473f, 0.300929f,
+		0.669131f, -0.332344f, 0.664689f, 0.000000f, 0.669131f, -0.332344f, 0.664689f, 0.180025f, 0.848850f,
+		0.736685f, -0.124433f, 0.664689f, 0.000000f, 0.736685f, -0.124433f, 0.664689f, 0.922791f, 0.233160f,
+		0.577350f, -0.187592f, 0.794654f, 0.000000f, 0.577350f, -0.187592f, 0.794654f, 0.412750f, 0.835614f,
+		0.736685f, -0.124433f, 0.664689f, 0.000000f, 0.736685f, -0.124433f, 0.664689f, 0.922791f, 0.233160f,
+		0.762354f, 0.061751f, 0.644208f, 0.000000f, 0.762354f, 0.061751f, 0.644208f, 0.553923f, 0.425781f,
+		0.632156f, 0.019439f, 0.774597f, 0.000000f, 0.632156f, 0.019439f, 0.774597f, 0.328463f, 0.848850f,
+		0.762354f, 0.061751f, 0.644208f, 0.000000f, 0.762354f, 0.061751f, 0.644208f, 0.553923f, 0.425781f,
+		0.758172f, 0.246345f, 0.603730f, 0.000000f, 0.758172f, 0.246345f, 0.603730f, 0.587250f, 0.528349f,
+		0.639949f, 0.207932f, 0.739749f, 0.000000f, 0.639949f, 0.207932f, 0.739749f, 0.250000f, 0.853312f,
+		0.395510f, -0.544373f, 0.739749f, 0.000000f, 0.395510f, -0.544373f, 0.739749f, 0.238575f, 0.233160f,
+		0.580460f, -0.498058f, 0.644208f, 0.000000f, 0.580460f, -0.498058f, 0.644208f, 0.238575f, 0.922791f,
+		0.499999f, -0.387298f, 0.774597f, 0.000000f, 0.499999f, -0.387298f, 0.774597f, 0.173473f, 0.300929f,
+		0.499999f, -0.387298f, 0.774597f, 0.000000f, 0.499999f, -0.387298f, 0.774597f, 0.173473f, 0.300929f,
+		0.669131f, -0.332344f, 0.664689f, 0.000000f, 0.669131f, -0.332344f, 0.664689f, 0.180025f, 0.848850f,
+		0.577350f, -0.187592f, 0.794654f, 0.000000f, 0.577350f, -0.187592f, 0.794654f, 0.412750f, 0.835614f,
+		0.736685f, -0.124433f, 0.664689f, 0.000000f, 0.736685f, -0.124433f, 0.664689f, 0.922791f, 0.233160f,
+		0.632156f, 0.019439f, 0.774597f, 0.000000f, 0.632156f, 0.019439f, 0.774597f, 0.328463f, 0.848850f,
+		0.577350f, -0.187592f, 0.794654f, 0.000000f, 0.577350f, -0.187592f, 0.794654f, 0.412750f, 0.835614f,
+		0.762354f, 0.061751f, 0.644208f, 0.000000f, 0.762354f, 0.061751f, 0.644208f, 0.553923f, 0.425781f,
+		0.639949f, 0.207932f, 0.739749f, 0.000000f, 0.639949f, 0.207932f, 0.739749f, 0.250000f, 0.853312f,
+		0.632156f, 0.019439f, 0.774597f, 0.000000f, 0.632156f, 0.019439f, 0.774597f, 0.328463f, 0.848850f,
+		0.525731f, -0.723607f, 0.447214f, 0.000000f, 0.525731f, -0.723607f, 0.447214f, 0.606016f, 0.354082f,
+		0.643075f, -0.588241f, 0.490334f, 0.000000f, 0.643075f, -0.588241f, 0.490334f, 0.643075f, 0.453512f,
+		0.468576f, -0.644939f, 0.603730f, 0.000000f, 0.468576f, -0.644939f, 0.603730f, 0.327004f, 0.922791f,
+		0.643075f, -0.588241f, 0.490334f, 0.000000f, 0.643075f, -0.588241f, 0.490334f, 0.643075f, 0.453512f,
+		0.738585f, -0.432902f, 0.516806f, 0.000000f, 0.738585f, -0.432902f, 0.516806f, 0.671537f, 0.555736f,
+		0.580460f, -0.498058f, 0.644208f, 0.000000f, 0.580460f, -0.498058f, 0.644208f, 0.238575f, 0.922791f,
+		0.738585f, -0.432902f, 0.516806f, 0.000000f, 0.738585f, -0.432902f, 0.516806f, 0.671537f, 0.555736f,
+		0.809017f, -0.262866f, 0.525731f, 0.000000f, 0.809017f, -0.262866f, 0.525731f, 0.654508f, 0.287337f,
+		0.669131f, -0.332344f, 0.664689f, 0.000000f, 0.669131f, -0.332344f, 0.664689f, 0.180025f, 0.848850f,
+		0.809017f, -0.262866f, 0.525731f, 0.000000f, 0.809017f, -0.262866f, 0.525731f, 0.654508f, 0.287337f,
+		0.851981f, -0.083904f, 0.516806f, 0.000000f, 0.851981f, -0.083904f, 0.516806f, 0.695347f, 0.381573f,
+		0.736685f, -0.124433f, 0.664689f, 0.000000f, 0.736685f, -0.124433f, 0.664689f, 0.922791f, 0.233160f,
+		0.851981f, -0.083904f, 0.516806f, 0.000000f, 0.851981f, -0.083904f, 0.516806f, 0.695347f, 0.381573f,
+		0.866018f, 0.097907f, 0.490334f, 0.000000f, 0.866018f, 0.097907f, 0.490334f, 0.727648f, 0.480987f,
+		0.762354f, 0.061751f, 0.644208f, 0.000000f, 0.762354f, 0.061751f, 0.644208f, 0.553923f, 0.425781f,
+		0.866018f, 0.097907f, 0.490334f, 0.000000f, 0.866018f, 0.097907f, 0.490334f, 0.727648f, 0.480987f,
+		0.850651f, 0.276393f, 0.447214f, 0.000000f, 0.850651f, 0.276393f, 0.447214f, 0.750000f, 0.581230f,
+		0.758172f, 0.246345f, 0.603730f, 0.000000f, 0.758172f, 0.246345f, 0.603730f, 0.587250f, 0.528349f,
+		0.468576f, -0.644939f, 0.603730f, 0.000000f, 0.468576f, -0.644939f, 0.603730f, 0.327004f, 0.922791f,
+		0.643075f, -0.588241f, 0.490334f, 0.000000f, 0.643075f, -0.588241f, 0.490334f, 0.643075f, 0.453512f,
+		0.580460f, -0.498058f, 0.644208f, 0.000000f, 0.580460f, -0.498058f, 0.644208f, 0.238575f, 0.922791f,
+		0.580460f, -0.498058f, 0.644208f, 0.000000f, 0.580460f, -0.498058f, 0.644208f, 0.238575f, 0.922791f,
+		0.738585f, -0.432902f, 0.516806f, 0.000000f, 0.738585f, -0.432902f, 0.516806f, 0.671537f, 0.555736f,
+		0.669131f, -0.332344f, 0.664689f, 0.000000f, 0.669131f, -0.332344f, 0.664689f, 0.180025f, 0.848850f,
+		0.669131f, -0.332344f, 0.664689f, 0.000000f, 0.669131f, -0.332344f, 0.664689f, 0.180025f, 0.848850f,
+		0.809017f, -0.262866f, 0.525731f, 0.000000f, 0.809017f, -0.262866f, 0.525731f, 0.654508f, 0.287337f,
+		0.736685f, -0.124433f, 0.664689f, 0.000000f, 0.736685f, -0.124433f, 0.664689f, 0.922791f, 0.233160f,
+		0.851981f, -0.083904f, 0.516806f, 0.000000f, 0.851981f, -0.083904f, 0.516806f, 0.695347f, 0.381573f,
+		0.762354f, 0.061751f, 0.644208f, 0.000000f, 0.762354f, 0.061751f, 0.644208f, 0.553923f, 0.425781f,
+		0.736685f, -0.124433f, 0.664689f, 0.000000f, 0.736685f, -0.124433f, 0.664689f, 0.922791f, 0.233160f,
+		0.866018f, 0.097907f, 0.490334f, 0.000000f, 0.866018f, 0.097907f, 0.490334f, 0.727648f, 0.480987f,
+		0.758172f, 0.246345f, 0.603730f, 0.000000f, 0.758172f, 0.246345f, 0.603730f, 0.587250f, 0.528349f,
+		0.762354f, 0.061751f, 0.644208f, 0.000000f, 0.762354f, 0.061751f, 0.644208f, 0.553923f, 0.425781f,
+		0.174499f, 0.056698f, 0.983024f, 0.000000f, 0.174499f, 0.056698f, 0.983024f, 0.411574f, 0.378293f,
+		0.000000f, 0.183479f, 0.983024f, 0.000000f, 0.000000f, 0.183479f, 0.983024f, 0.697755f, 0.227814f,
+		0.000000f, 0.000000f, 1.000000f, 0.000000f, 0.000000f, 0.000000f, 1.000000f, 0.411570f, 0.289369f,
+		0.343074f, 0.111472f, 0.932670f, 0.000000f, 0.343074f, 0.111472f, 0.932670f, 0.321589f, 0.254439f,
+		0.176851f, 0.243415f, 0.953663f, 0.000000f, 0.176851f, 0.243415f, 0.953663f, 0.750000f, 0.306351f,
+		0.174499f, 0.056698f, 0.983024f, 0.000000f, 0.174499f, 0.056698f, 0.983024f, 0.411574f, 0.378293f,
+		0.176851f, 0.243415f, 0.953663f, 0.000000f, 0.176851f, 0.243415f, 0.953663f, 0.750000f, 0.306351f,
+		0.000000f, 0.360730f, 0.932670f, 0.000000f, 0.000000f, 0.360730f, 0.932670f, 0.788675f, 0.406204f,
+		0.000000f, 0.183479f, 0.983024f, 0.000000f, 0.000000f, 0.183479f, 0.983024f, 0.697755f, 0.227814f,
+		0.174499f, 0.056698f, 0.983024f, 0.000000f, 0.174499f, 0.056698f, 0.983024f, 0.411574f, 0.378293f,
+		0.176851f, 0.243415f, 0.953663f, 0.000000f, 0.176851f, 0.243415f, 0.953663f, 0.750000f, 0.306351f,
+		0.000000f, 0.183479f, 0.983024f, 0.000000f, 0.000000f, 0.183479f, 0.983024f, 0.697755f, 0.227814f,
+		0.500000f, 0.162460f, 0.850651f, 0.000000f, 0.500000f, 0.162460f, 0.850651f, 0.411574f, 0.127938f,
+		0.345991f, 0.298381f, 0.889527f, 0.000000f, 0.345991f, 0.298381f, 0.889527f, 0.816078f, 0.509719f,
+		0.343074f, 0.111472f, 0.932670f, 0.000000f, 0.343074f, 0.111472f, 0.932670f, 0.321589f, 0.254439f,
+		0.345991f, 0.298381f, 0.889527f, 0.000000f, 0.345991f, 0.298381f, 0.889527f, 0.816078f, 0.509719f,
+		0.176860f, 0.421262f, 0.889527f, 0.000000f, 0.176860f, 0.421262f, 0.889527f, 0.819975f, 0.603966f,
+		0.176851f, 0.243415f, 0.953663f, 0.000000f, 0.176851f, 0.243415f, 0.953663f, 0.750000f, 0.306351f,
+		0.176860f, 0.421262f, 0.889527f, 0.000000f, 0.176860f, 0.421262f, 0.889527f, 0.819975f, 0.603966f,
+		0.000000f, 0.525731f, 0.850651f, 0.000000f, 0.000000f, 0.525731f, 0.850651f, 0.734288f, 0.177530f,
+		0.000000f, 0.360730f, 0.932670f, 0.000000f, 0.000000f, 0.360730f, 0.932670f, 0.788675f, 0.406204f,
+		0.343074f, 0.111472f, 0.932670f, 0.000000f, 0.343074f, 0.111472f, 0.932670f, 0.321589f, 0.254439f,
+		0.345991f, 0.298381f, 0.889527f, 0.000000f, 0.345991f, 0.298381f, 0.889527f, 0.816078f, 0.509719f,
+		0.176851f, 0.243415f, 0.953663f, 0.000000f, 0.176851f, 0.243415f, 0.953663f, 0.750000f, 0.306351f,
+		0.176860f, 0.421262f, 0.889527f, 0.000000f, 0.176860f, 0.421262f, 0.889527f, 0.819975f, 0.603966f,
+		0.000000f, 0.360730f, 0.932670f, 0.000000f, 0.000000f, 0.360730f, 0.932670f, 0.788675f, 0.406204f,
+		0.176851f, 0.243415f, 0.953663f, 0.000000f, 0.176851f, 0.243415f, 0.953663f, 0.750000f, 0.306351f,
+		0.639949f, 0.207932f, 0.739749f, 0.000000f, 0.639949f, 0.207932f, 0.739749f, 0.250000f, 0.853312f,
+		0.522851f, 0.355846f, 0.774597f, 0.000000f, 0.522851f, 0.355846f, 0.774597f, 0.790230f, 0.250971f,
+		0.500000f, 0.162460f, 0.850651f, 0.000000f, 0.500000f, 0.162460f, 0.850651f, 0.411574f, 0.127938f,
+		0.522851f, 0.355846f, 0.774597f, 0.000000f, 0.522851f, 0.355846f, 0.774597f, 0.790230f, 0.250971f,
+		0.356822f, 0.491123f, 0.794654f, 0.000000f, 0.356822f, 0.491123f, 0.794654f, 0.834566f, 0.333828f,
+		0.345991f, 0.298381f, 0.889527f, 0.000000f, 0.345991f, 0.298381f, 0.889527f, 0.816078f, 0.509719f,
+		0.356822f, 0.491123f, 0.794654f, 0.000000f, 0.356822f, 0.491123f, 0.794654f, 0.834566f, 0.333828f,
+		0.176860f, 0.607223f, 0.774597f, 0.000000f, 0.176860f, 0.607223f, 0.774597f, 0.868343f, 0.437784f,
+		0.176860f, 0.421262f, 0.889527f, 0.000000f, 0.176860f, 0.421262f, 0.889527f, 0.819975f, 0.603966f,
+		0.176860f, 0.607223f, 0.774597f, 0.000000f, 0.176860f, 0.607223f, 0.774597f, 0.868343f, 0.437784f,
+		0.000000f, 0.672883f, 0.739749f, 0.000000f, 0.000000f, 0.672883f, 0.739749f, 0.258102f, 0.437784f,
+		0.000000f, 0.525731f, 0.850651f, 0.000000f, 0.000000f, 0.525731f, 0.850651f, 0.734288f, 0.177530f,
+		0.500000f, 0.162460f, 0.850651f, 0.000000f, 0.500000f, 0.162460f, 0.850651f, 0.411574f, 0.127938f,
+		0.522851f, 0.355846f, 0.774597f, 0.000000f, 0.522851f, 0.355846f, 0.774597f, 0.790230f, 0.250971f,
+		0.345991f, 0.298381f, 0.889527f, 0.000000f, 0.345991f, 0.298381f, 0.889527f, 0.816078f, 0.509719f,
+		0.345991f, 0.298381f, 0.889527f, 0.000000f, 0.345991f, 0.298381f, 0.889527f, 0.816078f, 0.509719f,
+		0.356822f, 0.491123f, 0.794654f, 0.000000f, 0.356822f, 0.491123f, 0.794654f, 0.834566f, 0.333828f,
+		0.176860f, 0.421262f, 0.889527f, 0.000000f, 0.176860f, 0.421262f, 0.889527f, 0.819975f, 0.603966f,
+		0.176860f, 0.607223f, 0.774597f, 0.000000f, 0.176860f, 0.607223f, 0.774597f, 0.868343f, 0.437784f,
+		0.000000f, 0.525731f, 0.850651f, 0.000000f, 0.000000f, 0.525731f, 0.850651f, 0.734288f, 0.177530f,
+		0.176860f, 0.421262f, 0.889527f, 0.000000f, 0.176860f, 0.421262f, 0.889527f, 0.819975f, 0.603966f,
+		0.758172f, 0.246345f, 0.603730f, 0.000000f, 0.758172f, 0.246345f, 0.603730f, 0.587250f, 0.528349f,
+		0.653054f, 0.398142f, 0.644208f, 0.000000f, 0.653054f, 0.398142f, 0.644208f, 0.268343f, 0.530876f,
+		0.639949f, 0.207932f, 0.739749f, 0.000000f, 0.639949f, 0.207932f, 0.739749f, 0.250000f, 0.853312f,
+		0.653054f, 0.398142f, 0.644208f, 0.000000f, 0.653054f, 0.398142f, 0.644208f, 0.268343f, 0.530876f,
+		0.522851f, 0.533681f, 0.664689f, 0.000000f, 0.522851f, 0.533681f, 0.664689f, 0.203148f, 0.509719f,
+		0.522851f, 0.355846f, 0.774597f, 0.000000f, 0.522851f, 0.355846f, 0.774597f, 0.790230f, 0.250971f,
+		0.522851f, 0.533681f, 0.664689f, 0.000000f, 0.522851f, 0.533681f, 0.664689f, 0.203148f, 0.509719f,
+		0.345991f, 0.662178f, 0.664689f, 0.000000f, 0.345991f, 0.662178f, 0.664689f, 0.288582f, 0.623173f,
+		0.356822f, 0.491123f, 0.794654f, 0.000000f, 0.356822f, 0.491123f, 0.794654f, 0.834566f, 0.333828f,
+		0.345991f, 0.662178f, 0.664689f, 0.000000f, 0.345991f, 0.662178f, 0.664689f, 0.288582f, 0.623173f,
+		0.176851f, 0.744124f, 0.644208f, 0.000000f, 0.176851f, 0.744124f, 0.644208f, 0.220572f, 0.603966f,
+		0.176860f, 0.607223f, 0.774597f, 0.000000f, 0.176860f, 0.607223f, 0.774597f, 0.868343f, 0.437784f,
+		0.176851f, 0.744124f, 0.644208f, 0.000000f, 0.176851f, 0.744124f, 0.644208f, 0.220572f, 0.603966f,
+		0.000000f, 0.797189f, 0.603730f, 0.000000f, 0.000000f, 0.797189f, 0.603730f, 0.881177f, 0.530876f,
+		0.000000f, 0.672883f, 0.739749f, 0.000000f, 0.000000f, 0.672883f, 0.739749f, 0.258102f, 0.437784f,
+		0.639949f, 0.207932f, 0.739749f, 0.000000f, 0.639949f, 0.207932f, 0.739749f, 0.250000f, 0.853312f,
+		0.653054f, 0.398142f, 0.644208f, 0.000000f, 0.653054f, 0.398142f, 0.644208f, 0.268343f, 0.530876f,
+		0.522851f, 0.355846f, 0.774597f, 0.000000f, 0.522851f, 0.355846f, 0.774597f, 0.790230f, 0.250971f,
+		0.522851f, 0.355846f, 0.774597f, 0.000000f, 0.522851f, 0.355846f, 0.774597f, 0.790230f, 0.250971f,
+		0.522851f, 0.533681f, 0.664689f, 0.000000f, 0.522851f, 0.533681f, 0.664689f, 0.203148f, 0.509719f,
+		0.356822f, 0.491123f, 0.794654f, 0.000000f, 0.356822f, 0.491123f, 0.794654f, 0.834566f, 0.333828f,
+		0.345991f, 0.662178f, 0.664689f, 0.000000f, 0.345991f, 0.662178f, 0.664689f, 0.288582f, 0.623173f,
+		0.176860f, 0.607223f, 0.774597f, 0.000000f, 0.176860f, 0.607223f, 0.774597f, 0.868343f, 0.437784f,
+		0.356822f, 0.491123f, 0.794654f, 0.000000f, 0.356822f, 0.491123f, 0.794654f, 0.834566f, 0.333828f,
+		0.176851f, 0.744124f, 0.644208f, 0.000000f, 0.176851f, 0.744124f, 0.644208f, 0.220572f, 0.603966f,
+		0.000000f, 0.672883f, 0.739749f, 0.000000f, 0.000000f, 0.672883f, 0.739749f, 0.258102f, 0.437784f,
+		0.176860f, 0.607223f, 0.774597f, 0.000000f, 0.176860f, 0.607223f, 0.774597f, 0.868343f, 0.437784f,
+		0.850651f, 0.276393f, 0.447214f, 0.000000f, 0.850651f, 0.276393f, 0.447214f, 0.750000f, 0.581230f,
+		0.758172f, 0.429824f, 0.490334f, 0.000000f, 0.758172f, 0.429824f, 0.490334f, 0.762866f, 0.366840f,
+		0.758172f, 0.246345f, 0.603730f, 0.000000f, 0.758172f, 0.246345f, 0.603730f, 0.587250f, 0.528349f,
+		0.758172f, 0.429824f, 0.490334f, 0.000000f, 0.758172f, 0.429824f, 0.490334f, 0.762866f, 0.366840f,
+		0.639949f, 0.568662f, 0.516806f, 0.000000f, 0.639949f, 0.568662f, 0.516806f, 0.821537f, 0.345280f,
+		0.653054f, 0.398142f, 0.644208f, 0.000000f, 0.653054f, 0.398142f, 0.644208f, 0.268343f, 0.530876f,
+		0.639949f, 0.568662f, 0.516806f, 0.000000f, 0.639949f, 0.568662f, 0.516806f, 0.821537f, 0.345280f,
+		0.500000f, 0.688191f, 0.525731f, 0.000000f, 0.500000f, 0.688191f, 0.525731f, 0.734288f, 0.288582f,
+		0.522851f, 0.533681f, 0.664689f, 0.000000f, 0.522851f, 0.533681f, 0.664689f, 0.203148f, 0.509719f,
+		0.500000f, 0.688191f, 0.525731f, 0.000000f, 0.500000f, 0.688191f, 0.525731f, 0.734288f, 0.288582f,
+		0.343074f, 0.784354f, 0.516806f, 0.000000f, 0.343074f, 0.784354f, 0.516806f, 0.345280f, 0.205880f,
+		0.345991f, 0.662178f, 0.664689f, 0.000000f, 0.345991f, 0.662178f, 0.664689f, 0.288582f, 0.623173f,
+		0.343074f, 0.784354f, 0.516806f, 0.000000f, 0.343074f, 0.784354f, 0.516806f, 0.345280f, 0.205880f,
+		0.174499f, 0.853887f, 0.490334f, 0.000000f, 0.174499f, 0.853887f, 0.490334f, 0.332044f, 0.283549f,
+		0.176851f, 0.744124f, 0.644208f, 0.000000f, 0.176851f, 0.744124f, 0.644208f, 0.220572f, 0.603966f,
+		0.174499f, 0.853887f, 0.490334f, 0.000000f, 0.174499f, 0.853887f, 0.490334f, 0.332044f, 0.283549f,
+		0.000000f, 0.894427f, 0.447214f, 0.000000f, 0.000000f, 0.894427f, 0.447214f, 0.268343f, 0.250971f,
+		0.000000f, 0.797189f, 0.603730f, 0.000000f, 0.000000f, 0.797189f, 0.603730f, 0.881177f, 0.530876f,
+		0.758172f, 0.246345f, 0.603730f, 0.000000f, 0.758172f, 0.246345f, 0.603730f, 0.587250f, 0.528349f,
+		0.758172f, 0.429824f, 0.490334f, 0.000000f, 0.758172f, 0.429824f, 0.490334f, 0.762866f, 0.366840f,
+		0.653054f, 0.398142f, 0.644208f, 0.000000f, 0.653054f, 0.398142f, 0.644208f, 0.268343f, 0.530876f,
+		0.653054f, 0.398142f, 0.644208f, 0.000000f, 0.653054f, 0.398142f, 0.644208f, 0.268343f, 0.530876f,
+		0.639949f, 0.568662f, 0.516806f, 0.000000f, 0.639949f, 0.568662f, 0.516806f, 0.821537f, 0.345280f,
+		0.522851f, 0.533681f, 0.664689f, 0.000000f, 0.522851f, 0.533681f, 0.664689f, 0.203148f, 0.509719f,
+		0.522851f, 0.533681f, 0.664689f, 0.000000f, 0.522851f, 0.533681f, 0.664689f, 0.203148f, 0.509719f,
+		0.500000f, 0.688191f, 0.525731f, 0.000000f, 0.500000f, 0.688191f, 0.525731f, 0.734288f, 0.288582f,
+		0.345991f, 0.662178f, 0.664689f, 0.000000f, 0.345991f, 0.662178f, 0.664689f, 0.288582f, 0.623173f,
+		0.343074f, 0.784354f, 0.516806f, 0.000000f, 0.343074f, 0.784354f, 0.516806f, 0.345280f, 0.205880f,
+		0.176851f, 0.744124f, 0.644208f, 0.000000f, 0.176851f, 0.744124f, 0.644208f, 0.220572f, 0.603966f,
+		0.345991f, 0.662178f, 0.664689f, 0.000000f, 0.345991f, 0.662178f, 0.664689f, 0.288582f, 0.623173f,
+		0.174499f, 0.853887f, 0.490334f, 0.000000f, 0.174499f, 0.853887f, 0.490334f, 0.332044f, 0.283549f,
+		0.000000f, 0.797189f, 0.603730f, 0.000000f, 0.000000f, 0.797189f, 0.603730f, 0.881177f, 0.530876f,
+		0.176851f, 0.744124f, 0.644208f, 0.000000f, 0.176851f, 0.744124f, 0.644208f, 0.220572f, 0.603966f,
+		0.000000f, 0.183479f, 0.983024f, 0.000000f, 0.000000f, 0.183479f, 0.983024f, 0.697755f, 0.227814f,
+		-0.174499f, 0.056698f, 0.983024f, 0.000000f, -0.174499f, 0.056698f, 0.983024f, 0.327581f, 0.368567f,
+		0.000000f, 0.000000f, 1.000000f, 0.000000f, 0.000000f, 0.000000f, 1.000000f, 0.411570f, 0.289369f,
+		0.000000f, 0.360730f, 0.932670f, 0.000000f, 0.000000f, 0.360730f, 0.932670f, 0.788675f, 0.406204f,
+		-0.176851f, 0.243415f, 0.953663f, 0.000000f, -0.176851f, 0.243415f, 0.953663f, 0.258102f, 0.333828f,
+		0.000000f, 0.183479f, 0.983024f, 0.000000f, 0.000000f, 0.183479f, 0.983024f, 0.697755f, 0.227814f,
+		-0.176851f, 0.243415f, 0.953663f, 0.000000f, -0.176851f, 0.243415f, 0.953663f, 0.258102f, 0.333828f,
+		-0.343074f, 0.111472f, 0.932670f, 0.000000f, -0.343074f, 0.111472f, 0.932670f, 0.332044f, 0.458048f,
+		-0.174499f, 0.056698f, 0.983024f, 0.000000f, -0.174499f, 0.056698f, 0.983024f, 0.327581f, 0.368567f,
+		-0.176851f, 0.243415f, 0.953663f, 0.000000f, -0.176851f, 0.243415f, 0.953663f, 0.258102f, 0.333828f,
+		-0.174499f, 0.056698f, 0.983024f, 0.000000f, -0.174499f, 0.056698f, 0.983024f, 0.327581f, 0.368567f,
+		0.000000f, 0.183479f, 0.983024f, 0.000000f, 0.000000f, 0.183479f, 0.983024f, 0.697755f, 0.227814f,
+		0.000000f, 0.525731f, 0.850651f, 0.000000f, 0.000000f, 0.525731f, 0.850651f, 0.734288f, 0.177530f,
+		-0.176860f, 0.421262f, 0.889527f, 0.000000f, -0.176860f, 0.421262f, 0.889527f, 0.345280f, 0.548954f,
+		0.000000f, 0.360730f, 0.932670f, 0.000000f, 0.000000f, 0.360730f, 0.932670f, 0.788675f, 0.406204f,
+		-0.176860f, 0.421262f, 0.889527f, 0.000000f, -0.176860f, 0.421262f, 0.889527f, 0.345280f, 0.548954f,
+		-0.345991f, 0.298381f, 0.889527f, 0.000000f, -0.345991f, 0.298381f, 0.889527f, 0.366840f, 0.638196f,
+		-0.176851f, 0.243415f, 0.953663f, 0.000000f, -0.176851f, 0.243415f, 0.953663f, 0.258102f, 0.333828f,
+		-0.345991f, 0.298381f, 0.889527f, 0.000000f, -0.345991f, 0.298381f, 0.889527f, 0.366840f, 0.638196f,
+		-0.500000f, 0.162460f, 0.850651f, 0.000000f, -0.500000f, 0.162460f, 0.850651f, 0.790230f, 0.268343f,
+		-0.343074f, 0.111472f, 0.932670f, 0.000000f, -0.343074f, 0.111472f, 0.932670f, 0.332044f, 0.458048f,
+		0.000000f, 0.360730f, 0.932670f, 0.000000f, 0.000000f, 0.360730f, 0.932670f, 0.788675f, 0.406204f,
+		-0.176860f, 0.421262f, 0.889527f, 0.000000f, -0.176860f, 0.421262f, 0.889527f, 0.345280f, 0.548954f,
+		-0.176851f, 0.243415f, 0.953663f, 0.000000f, -0.176851f, 0.243415f, 0.953663f, 0.258102f, 0.333828f,
+		-0.345991f, 0.298381f, 0.889527f, 0.000000f, -0.345991f, 0.298381f, 0.889527f, 0.366840f, 0.638196f,
+		-0.343074f, 0.111472f, 0.932670f, 0.000000f, -0.343074f, 0.111472f, 0.932670f, 0.332044f, 0.458048f,
+		-0.176851f, 0.243415f, 0.953663f, 0.000000f, -0.176851f, 0.243415f, 0.953663f, 0.258102f, 0.333828f,
+		0.000000f, 0.672883f, 0.739749f, 0.000000f, 0.000000f, 0.672883f, 0.739749f, 0.258102f, 0.437784f,
+		-0.176860f, 0.607223f, 0.774597f, 0.000000f, -0.176860f, 0.607223f, 0.774597f, 0.500000f, 0.591739f,
+		0.000000f, 0.525731f, 0.850651f, 0.000000f, 0.000000f, 0.525731f, 0.850651f, 0.734288f, 0.177530f,
+		-0.176860f, 0.607223f, 0.774597f, 0.000000f, -0.176860f, 0.607223f, 0.774597f, 0.500000f, 0.591739f,
+		-0.356822f, 0.491123f, 0.794654f, 0.000000f, -0.356822f, 0.491123f, 0.794654f, 0.588426f, 0.621707f,
+		-0.176860f, 0.421262f, 0.889527f, 0.000000f, -0.176860f, 0.421262f, 0.889527f, 0.345280f, 0.548954f,
+		-0.356822f, 0.491123f, 0.794654f, 0.000000f, -0.356822f, 0.491123f, 0.794654f, 0.588426f, 0.621707f,
+		-0.522851f, 0.355846f, 0.774597f, 0.000000f, -0.522851f, 0.355846f, 0.774597f, 0.500000f, 0.680365f,
+		-0.345991f, 0.298381f, 0.889527f, 0.000000f, -0.345991f, 0.298381f, 0.889527f, 0.366840f, 0.638196f,
+		-0.522851f, 0.355846f, 0.774597f, 0.000000f, -0.522851f, 0.355846f, 0.774597f, 0.500000f, 0.680365f,
+		-0.639949f, 0.207932f, 0.739749f, 0.000000f, -0.639949f, 0.207932f, 0.739749f, 0.672996f, 0.649190f,
+		-0.500000f, 0.162460f, 0.850651f, 0.000000f, -0.500000f, 0.162460f, 0.850651f, 0.790230f, 0.268343f,
+		0.000000f, 0.525731f, 0.850651f, 0.000000f, 0.000000f, 0.525731f, 0.850651f, 0.734288f, 0.177530f,
+		-0.176860f, 0.607223f, 0.774597f, 0.000000f, -0.176860f, 0.607223f, 0.774597f, 0.500000f, 0.591739f,
+		-0.176860f, 0.421262f, 0.889527f, 0.000000f, -0.176860f, 0.421262f, 0.889527f, 0.345280f, 0.548954f,
+		-0.356822f, 0.491123f, 0.794654f, 0.000000f, -0.356822f, 0.491123f, 0.794654f, 0.588426f, 0.621707f,
+		-0.345991f, 0.298381f, 0.889527f, 0.000000f, -0.345991f, 0.298381f, 0.889527f, 0.366840f, 0.638196f,
+		-0.176860f, 0.421262f, 0.889527f, 0.000000f, -0.176860f, 0.421262f, 0.889527f, 0.345280f, 0.548954f,
+		-0.522851f, 0.355846f, 0.774597f, 0.000000f, -0.522851f, 0.355846f, 0.774597f, 0.500000f, 0.680365f,
+		-0.500000f, 0.162460f, 0.850651f, 0.000000f, -0.500000f, 0.162460f, 0.850651f, 0.790230f, 0.268343f,
+		-0.345991f, 0.298381f, 0.889527f, 0.000000f, -0.345991f, 0.298381f, 0.889527f, 0.366840f, 0.638196f,
+		0.000000f, 0.797189f, 0.603730f, 0.000000f, 0.000000f, 0.797189f, 0.603730f, 0.881177f, 0.530876f,
+		-0.176851f, 0.744124f, 0.644208f, 0.000000f, -0.176851f, 0.744124f, 0.644208f, 0.588430f, 0.710631f,
+		0.000000f, 0.672883f, 0.739749f, 0.000000f, 0.000000f, 0.672883f, 0.739749f, 0.258102f, 0.437784f,
+		-0.176851f, 0.744124f, 0.644208f, 0.000000f, -0.176851f, 0.744124f, 0.644208f, 0.588430f, 0.710631f,
+		-0.345991f, 0.662178f, 0.664689f, 0.000000f, -0.345991f, 0.662178f, 0.664689f, 0.500000f, 0.762866f,
+		-0.176860f, 0.607223f, 0.774597f, 0.000000f, -0.176860f, 0.607223f, 0.774597f, 0.500000f, 0.591739f,
+		-0.345991f, 0.662178f, 0.664689f, 0.000000f, -0.345991f, 0.662178f, 0.664689f, 0.500000f, 0.762866f,
+		-0.522851f, 0.533682f, 0.664689f, 0.000000f, -0.522851f, 0.533682f, 0.664689f, 0.761425f, 0.677923f,
+		-0.356822f, 0.491123f, 0.794654f, 0.000000f, -0.356822f, 0.491123f, 0.794654f, 0.588426f, 0.621707f,
+		-0.522851f, 0.533682f, 0.664689f, 0.000000f, -0.522851f, 0.533682f, 0.664689f, 0.761425f, 0.677923f,
+		-0.653054f, 0.398142f, 0.644208f, 0.000000f, -0.653054f, 0.398142f, 0.644208f, 0.678411f, 0.745561f,
+		-0.522851f, 0.355846f, 0.774597f, 0.000000f, -0.522851f, 0.355846f, 0.774597f, 0.500000f, 0.680365f,
+		-0.653054f, 0.398142f, 0.644208f, 0.000000f, -0.653054f, 0.398142f, 0.644208f, 0.678411f, 0.745561f,
+		-0.758172f, 0.246345f, 0.603730f, 0.000000f, -0.758172f, 0.246345f, 0.603730f, 0.588430f, 0.803612f,
+		-0.639949f, 0.207932f, 0.739749f, 0.000000f, -0.639949f, 0.207932f, 0.739749f, 0.672996f, 0.649190f,
+		0.000000f, 0.672883f, 0.739749f, 0.000000f, 0.000000f, 0.672883f, 0.739749f, 0.258102f, 0.437784f,
+		-0.176851f, 0.744124f, 0.644208f, 0.000000f, -0.176851f, 0.744124f, 0.644208f, 0.588430f, 0.710631f,
+		-0.176860f, 0.607223f, 0.774597f, 0.000000f, -0.176860f, 0.607223f, 0.774597f, 0.500000f, 0.591739f,
+		-0.176860f, 0.607223f, 0.774597f, 0.000000f, -0.176860f, 0.607223f, 0.774597f, 0.500000f, 0.591739f,
+		-0.345991f, 0.662178f, 0.664689f, 0.000000f, -0.345991f, 0.662178f, 0.664689f, 0.500000f, 0.762866f,
+		-0.356822f, 0.491123f, 0.794654f, 0.000000f, -0.356822f, 0.491123f, 0.794654f, 0.588426f, 0.621707f,
+		-0.522851f, 0.533682f, 0.664689f, 0.000000f, -0.522851f, 0.533682f, 0.664689f, 0.761425f, 0.677923f,
+		-0.522851f, 0.355846f, 0.774597f, 0.000000f, -0.522851f, 0.355846f, 0.774597f, 0.500000f, 0.680365f,
+		-0.356822f, 0.491123f, 0.794654f, 0.000000f, -0.356822f, 0.491123f, 0.794654f, 0.588426f, 0.621707f,
+		-0.653054f, 0.398142f, 0.644208f, 0.000000f, -0.653054f, 0.398142f, 0.644208f, 0.678411f, 0.745561f,
+		-0.639949f, 0.207932f, 0.739749f, 0.000000f, -0.639949f, 0.207932f, 0.739749f, 0.672996f, 0.649190f,
+		-0.522851f, 0.355846f, 0.774597f, 0.000000f, -0.522851f, 0.355846f, 0.774597f, 0.500000f, 0.680365f,
+		0.000000f, 0.894427f, 0.447214f, 0.000000f, 0.000000f, 0.894427f, 0.447214f, 0.268343f, 0.250971f,
+		-0.174499f, 0.853887f, 0.490334f, 0.000000f, -0.174499f, 0.853887f, 0.490334f, 0.500000f, 0.836442f,
+		0.000000f, 0.797189f, 0.603730f, 0.000000f, 0.000000f, 0.797189f, 0.603730f, 0.881177f, 0.530876f,
+		-0.174499f, 0.853887f, 0.490334f, 0.000000f, -0.174499f, 0.853887f, 0.490334f, 0.500000f, 0.836442f,
+		-0.343074f, 0.784354f, 0.516806f, 0.000000f, -0.343074f, 0.784354f, 0.516806f, 0.268343f, 0.699071f,
+		-0.176851f, 0.744124f, 0.644208f, 0.000000f, -0.176851f, 0.744124f, 0.644208f, 0.588430f, 0.710631f,
+		-0.343074f, 0.784354f, 0.516806f, 0.000000f, -0.343074f, 0.784354f, 0.516806f, 0.268343f, 0.699071f,
+		-0.500000f, 0.688191f, 0.525731f, 0.000000f, -0.500000f, 0.688191f, 0.525731f, 0.826527f, 0.699071f,
+		-0.345991f, 0.662178f, 0.664689f, 0.000000f, -0.345991f, 0.662178f, 0.664689f, 0.500000f, 0.762866f,
+		-0.500000f, 0.688191f, 0.525731f, 0.000000f, -0.500000f, 0.688191f, 0.525731f, 0.826527f, 0.699071f,
+		-0.639949f, 0.568662f, 0.516806f, 0.000000f, -0.639949f, 0.568662f, 0.516806f, 0.761425f, 0.766840f,
+		-0.522851f, 0.533682f, 0.664689f, 0.000000f, -0.522851f, 0.533682f, 0.664689f, 0.761425f, 0.677923f,
+		-0.639949f, 0.568662f, 0.516806f, 0.000000f, -0.639949f, 0.568662f, 0.516806f, 0.761425f, 0.766840f,
+		-0.758172f, 0.429824f, 0.490334f, 0.000000f, -0.758172f, 0.429824f, 0.490334f, 0.672996f, 0.831089f,
+		-0.653054f, 0.398142f, 0.644208f, 0.000000f, -0.653054f, 0.398142f, 0.644208f, 0.678411f, 0.745561f,
+		-0.758172f, 0.429824f, 0.490334f, 0.000000f, -0.758172f, 0.429824f, 0.490334f, 0.672996f, 0.831089f,
+		-0.850651f, 0.276393f, 0.447214f, 0.000000f, -0.850651f, 0.276393f, 0.447214f, 0.588426f, 0.872062f,
+		-0.758172f, 0.246345f, 0.603730f, 0.000000f, -0.758172f, 0.246345f, 0.603730f, 0.588430f, 0.803612f,
+		0.000000f, 0.797189f, 0.603730f, 0.000000f, 0.000000f, 0.797189f, 0.603730f, 0.881177f, 0.530876f,
+		-0.174499f, 0.853887f, 0.490334f, 0.000000f, -0.174499f, 0.853887f, 0.490334f, 0.500000f, 0.836442f,
+		-0.176851f, 0.744124f, 0.644208f, 0.000000f, -0.176851f, 0.744124f, 0.644208f, 0.588430f, 0.710631f,
+		-0.176851f, 0.744124f, 0.644208f, 0.000000f, -0.176851f, 0.744124f, 0.644208f, 0.588430f, 0.710631f,
+		-0.343074f, 0.784354f, 0.516806f, 0.000000f, -0.343074f, 0.784354f, 0.516806f, 0.268343f, 0.699071f,
+		-0.345991f, 0.662178f, 0.664689f, 0.000000f, -0.345991f, 0.662178f, 0.664689f, 0.500000f, 0.762866f,
+		-0.500000f, 0.688191f, 0.525731f, 0.000000f, -0.500000f, 0.688191f, 0.525731f, 0.826527f, 0.699071f,
+		-0.522851f, 0.533682f, 0.664689f, 0.000000f, -0.522851f, 0.533682f, 0.664689f, 0.761425f, 0.677923f,
+		-0.345991f, 0.662178f, 0.664689f, 0.000000f, -0.345991f, 0.662178f, 0.664689f, 0.500000f, 0.762866f,
+		-0.639949f, 0.568662f, 0.516806f, 0.000000f, -0.639949f, 0.568662f, 0.516806f, 0.761425f, 0.766840f,
+		-0.653054f, 0.398142f, 0.644208f, 0.000000f, -0.653054f, 0.398142f, 0.644208f, 0.678411f, 0.745561f,
+		-0.522851f, 0.533682f, 0.664689f, 0.000000f, -0.522851f, 0.533682f, 0.664689f, 0.761425f, 0.677923f,
+		-0.758172f, 0.429824f, 0.490334f, 0.000000f, -0.758172f, 0.429824f, 0.490334f, 0.672996f, 0.831089f,
+		-0.758172f, 0.246345f, 0.603730f, 0.000000f, -0.758172f, 0.246345f, 0.603730f, 0.588430f, 0.803612f,
+		-0.653054f, 0.398142f, 0.644208f, 0.000000f, -0.653054f, 0.398142f, 0.644208f, 0.678411f, 0.745561f,
+		-0.174499f, 0.056698f, 0.983024f, 0.000000f, -0.174499f, 0.056698f, 0.983024f, 0.327581f, 0.368567f,
+		-0.107846f, -0.148438f, 0.983024f, 0.000000f, -0.107846f, -0.148438f, 0.983024f, 0.588426f, 0.268343f,
+		0.000000f, 0.000000f, 1.000000f, 0.000000f, 0.000000f, 0.000000f, 1.000000f, 0.411570f, 0.289369f,
+		-0.343074f, 0.111472f, 0.932670f, 0.000000f, -0.343074f, 0.111472f, 0.932670f, 0.332044f, 0.458048f,
+		-0.286151f, -0.092976f, 0.953663f, 0.000000f, -0.286151f, -0.092976f, 0.953663f, 0.500000f, 0.288582f,
+		-0.174499f, 0.056698f, 0.983024f, 0.000000f, -0.174499f, 0.056698f, 0.983024f, 0.327581f, 0.368567f,
+		-0.286151f, -0.092976f, 0.953663f, 0.000000f, -0.286151f, -0.092976f, 0.953663f, 0.500000f, 0.288582f,
+		-0.212032f, -0.291836f, 0.932670f, 0.000000f, -0.212032f, -0.291836f, 0.932670f, 0.500000f, 0.220572f,
+		-0.107846f, -0.148438f, 0.983024f, 0.000000f, -0.107846f, -0.148438f, 0.983024f, 0.588426f, 0.268343f,
+		-0.286151f, -0.092976f, 0.953663f, 0.000000f, -0.286151f, -0.092976f, 0.953663f, 0.500000f, 0.288582f,
+		-0.107846f, -0.148438f, 0.983024f, 0.000000f, -0.107846f, -0.148438f, 0.983024f, 0.588426f, 0.268343f,
+		-0.174499f, 0.056698f, 0.983024f, 0.000000f, -0.174499f, 0.056698f, 0.983024f, 0.327581f, 0.368567f,
+		-0.500000f, 0.162460f, 0.850651f, 0.000000f, -0.500000f, 0.162460f, 0.850651f, 0.790230f, 0.268343f,
+		-0.455297f, -0.038026f, 0.889527f, 0.000000f, -0.455297f, -0.038026f, 0.889527f, 0.345280f, 0.714912f,
+		-0.343074f, 0.111472f, 0.932670f, 0.000000f, -0.343074f, 0.111472f, 0.932670f, 0.332044f, 0.458048f,
+		-0.455297f, -0.038026f, 0.889527f, 0.000000f, -0.455297f, -0.038026f, 0.889527f, 0.345280f, 0.714912f,
+		-0.390694f, -0.236853f, 0.889527f, 0.000000f, -0.390694f, -0.236853f, 0.889527f, 0.332044f, 0.784331f,
+		-0.286151f, -0.092976f, 0.953663f, 0.000000f, -0.286151f, -0.092976f, 0.953663f, 0.500000f, 0.288582f,
+		-0.390694f, -0.236853f, 0.889527f, 0.000000f, -0.390694f, -0.236853f, 0.889527f, 0.332044f, 0.784331f,
+		-0.309017f, -0.425325f, 0.850651f, 0.000000f, -0.309017f, -0.425325f, 0.850651f, 0.819975f, 0.332044f,
+		-0.212032f, -0.291836f, 0.932670f, 0.000000f, -0.212032f, -0.291836f, 0.932670f, 0.500000f, 0.220572f,
+		-0.343074f, 0.111472f, 0.932670f, 0.000000f, -0.343074f, 0.111472f, 0.932670f, 0.332044f, 0.458048f,
+		-0.455297f, -0.038026f, 0.889527f, 0.000000f, -0.455297f, -0.038026f, 0.889527f, 0.345280f, 0.714912f,
+		-0.286151f, -0.092976f, 0.953663f, 0.000000f, -0.286151f, -0.092976f, 0.953663f, 0.500000f, 0.288582f,
+		-0.390694f, -0.236853f, 0.889527f, 0.000000f, -0.390694f, -0.236853f, 0.889527f, 0.332044f, 0.784331f,
+		-0.212032f, -0.291836f, 0.932670f, 0.000000f, -0.212032f, -0.291836f, 0.932670f, 0.500000f, 0.220572f,
+		-0.286151f, -0.092976f, 0.953663f, 0.000000f, -0.286151f, -0.092976f, 0.953663f, 0.500000f, 0.288582f,
+		-0.639949f, 0.207932f, 0.739749f, 0.000000f, -0.639949f, 0.207932f, 0.739749f, 0.672996f, 0.649190f,
+		-0.632156f, 0.019439f, 0.774597f, 0.000000f, -0.632156f, 0.019439f, 0.774597f, 0.750000f, 0.327581f,
+		-0.500000f, 0.162460f, 0.850651f, 0.000000f, -0.500000f, 0.162460f, 0.850651f, 0.790230f, 0.268343f,
+		-0.632156f, 0.019439f, 0.774597f, 0.000000f, -0.632156f, 0.019439f, 0.774597f, 0.750000f, 0.327581f,
+		-0.577350f, -0.187592f, 0.794654f, 0.000000f, -0.577350f, -0.187592f, 0.794654f, 0.761425f, 0.258102f,
+		-0.455297f, -0.038026f, 0.889527f, 0.000000f, -0.455297f, -0.038026f, 0.889527f, 0.345280f, 0.714912f,
+		-0.577350f, -0.187592f, 0.794654f, 0.000000f, -0.577350f, -0.187592f, 0.794654f, 0.761425f, 0.258102f,
+		-0.499999f, -0.387298f, 0.774597f, 0.000000f, -0.499999f, -0.387298f, 0.774597f, 0.671537f, 0.332044f,
+		-0.390694f, -0.236853f, 0.889527f, 0.000000f, -0.390694f, -0.236853f, 0.889527f, 0.332044f, 0.784331f,
+		-0.499999f, -0.387298f, 0.774597f, 0.000000f, -0.499999f, -0.387298f, 0.774597f, 0.671537f, 0.332044f,
+		-0.395511f, -0.544373f, 0.739749f, 0.000000f, -0.395511f, -0.544373f, 0.739749f, 0.672996f, 0.258102f,
+		-0.309017f, -0.425325f, 0.850651f, 0.000000f, -0.309017f, -0.425325f, 0.850651f, 0.819975f, 0.332044f,
+		-0.500000f, 0.162460f, 0.850651f, 0.000000f, -0.500000f, 0.162460f, 0.850651f, 0.790230f, 0.268343f,
+		-0.632156f, 0.019439f, 0.774597f, 0.000000f, -0.632156f, 0.019439f, 0.774597f, 0.750000f, 0.327581f,
+		-0.455297f, -0.038026f, 0.889527f, 0.000000f, -0.455297f, -0.038026f, 0.889527f, 0.345280f, 0.714912f,
+		-0.577350f, -0.187592f, 0.794654f, 0.000000f, -0.577350f, -0.187592f, 0.794654f, 0.761425f, 0.258102f,
+		-0.390694f, -0.236853f, 0.889527f, 0.000000f, -0.390694f, -0.236853f, 0.889527f, 0.332044f, 0.784331f,
+		-0.455297f, -0.038026f, 0.889527f, 0.000000f, -0.455297f, -0.038026f, 0.889527f, 0.345280f, 0.714912f,
+		-0.499999f, -0.387298f, 0.774597f, 0.000000f, -0.499999f, -0.387298f, 0.774597f, 0.671537f, 0.332044f,
+		-0.309017f, -0.425325f, 0.850651f, 0.000000f, -0.309017f, -0.425325f, 0.850651f, 0.819975f, 0.332044f,
+		-0.390694f, -0.236853f, 0.889527f, 0.000000f, -0.390694f, -0.236853f, 0.889527f, 0.332044f, 0.784331f,
+		-0.758172f, 0.246345f, 0.603730f, 0.000000f, -0.758172f, 0.246345f, 0.603730f, 0.588430f, 0.803612f,
+		-0.762354f, 0.061752f, 0.644208f, 0.000000f, -0.762354f, 0.061752f, 0.644208f, 0.587250f, 0.345280f,
+		-0.639949f, 0.207932f, 0.739749f, 0.000000f, -0.639949f, 0.207932f, 0.739749f, 0.672996f, 0.649190f,
+		-0.762354f, 0.061752f, 0.644208f, 0.000000f, -0.762354f, 0.061752f, 0.644208f, 0.587250f, 0.345280f,
+		-0.736686f, -0.124433f, 0.664689f, 0.000000f, -0.736686f, -0.124433f, 0.664689f, 0.500000f, 0.366840f,
+		-0.632156f, 0.019439f, 0.774597f, 0.000000f, -0.632156f, 0.019439f, 0.774597f, 0.750000f, 0.327581f,
+		-0.736686f, -0.124433f, 0.664689f, 0.000000f, -0.736686f, -0.124433f, 0.664689f, 0.500000f, 0.366840f,
+		-0.669131f, -0.332344f, 0.664689f, 0.000000f, -0.669131f, -0.332344f, 0.664689f, 0.258102f, 0.766840f,
+		-0.577350f, -0.187592f, 0.794654f, 0.000000f, -0.577350f, -0.187592f, 0.794654f, 0.761425f, 0.258102f,
+		-0.669131f, -0.332344f, 0.664689f, 0.000000f, -0.669131f, -0.332344f, 0.664689f, 0.258102f, 0.766840f,
+		-0.580461f, -0.498058f, 0.644208f, 0.000000f, -0.580461f, -0.498058f, 0.644208f, 0.412750f, 0.528349f,
+		-0.499999f, -0.387298f, 0.774597f, 0.000000f, -0.499999f, -0.387298f, 0.774597f, 0.671537f, 0.332044f,
+		-0.580461f, -0.498058f, 0.644208f, 0.000000f, -0.580461f, -0.498058f, 0.644208f, 0.412750f, 0.528349f,
+		-0.468576f, -0.644939f, 0.603730f, 0.000000f, -0.468576f, -0.644939f, 0.603730f, 0.411574f, 0.621707f,
+		-0.395511f, -0.544373f, 0.739749f, 0.000000f, -0.395511f, -0.544373f, 0.739749f, 0.672996f, 0.258102f,
+		-0.639949f, 0.207932f, 0.739749f, 0.000000f, -0.639949f, 0.207932f, 0.739749f, 0.672996f, 0.649190f,
+		-0.762354f, 0.061752f, 0.644208f, 0.000000f, -0.762354f, 0.061752f, 0.644208f, 0.587250f, 0.345280f,
+		-0.632156f, 0.019439f, 0.774597f, 0.000000f, -0.632156f, 0.019439f, 0.774597f, 0.750000f, 0.327581f,
+		-0.632156f, 0.019439f, 0.774597f, 0.000000f, -0.632156f, 0.019439f, 0.774597f, 0.750000f, 0.327581f,
+		-0.736686f, -0.124433f, 0.664689f, 0.000000f, -0.736686f, -0.124433f, 0.664689f, 0.500000f, 0.366840f,
+		-0.577350f, -0.187592f, 0.794654f, 0.000000f, -0.577350f, -0.187592f, 0.794654f, 0.761425f, 0.258102f,
+		-0.669131f, -0.332344f, 0.664689f, 0.000000f, -0.669131f, -0.332344f, 0.664689f, 0.258102f, 0.766840f,
+		-0.499999f, -0.387298f, 0.774597f, 0.000000f, -0.499999f, -0.387298f, 0.774597f, 0.671537f, 0.332044f,
+		-0.577350f, -0.187592f, 0.794654f, 0.000000f, -0.577350f, -0.187592f, 0.794654f, 0.761425f, 0.258102f,
+		-0.580461f, -0.498058f, 0.644208f, 0.000000f, -0.580461f, -0.498058f, 0.644208f, 0.412750f, 0.528349f,
+		-0.395511f, -0.544373f, 0.739749f, 0.000000f, -0.395511f, -0.544373f, 0.739749f, 0.672996f, 0.258102f,
+		-0.499999f, -0.387298f, 0.774597f, 0.000000f, -0.499999f, -0.387298f, 0.774597f, 0.671537f, 0.332044f,
+		-0.850651f, 0.276393f, 0.447214f, 0.000000f, -0.850651f, 0.276393f, 0.447214f, 0.588426f, 0.872062f,
+		-0.866018f, 0.097907f, 0.490334f, 0.000000f, -0.866018f, 0.097907f, 0.490334f, 0.328463f, 0.555736f,
+		-0.758172f, 0.246345f, 0.603730f, 0.000000f, -0.758172f, 0.246345f, 0.603730f, 0.588430f, 0.803612f,
+		-0.866018f, 0.097907f, 0.490334f, 0.000000f, -0.866018f, 0.097907f, 0.490334f, 0.328463f, 0.555736f,
+		-0.851981f, -0.083904f, 0.516806f, 0.000000f, -0.851981f, -0.083904f, 0.516806f, 0.411570f, 0.710631f,
+		-0.762354f, 0.061752f, 0.644208f, 0.000000f, -0.762354f, 0.061752f, 0.644208f, 0.587250f, 0.345280f,
+		-0.851981f, -0.083904f, 0.516806f, 0.000000f, -0.851981f, -0.083904f, 0.516806f, 0.411570f, 0.710631f,
+		-0.809017f, -0.262865f, 0.525731f, 0.000000f, -0.809017f, -0.262865f, 0.525731f, 0.327004f, 0.649190f,
+		-0.736686f, -0.124433f, 0.664689f, 0.000000f, -0.736686f, -0.124433f, 0.664689f, 0.500000f, 0.366840f,
+		-0.809017f, -0.262865f, 0.525731f, 0.000000f, -0.809017f, -0.262865f, 0.525731f, 0.327004f, 0.649190f,
+		-0.738585f, -0.432902f, 0.516806f, 0.000000f, -0.738585f, -0.432902f, 0.516806f, 0.250000f, 0.581230f,
+		-0.669131f, -0.332344f, 0.664689f, 0.000000f, -0.669131f, -0.332344f, 0.664689f, 0.258102f, 0.766840f,
+		-0.738585f, -0.432902f, 0.516806f, 0.000000f, -0.738585f, -0.432902f, 0.516806f, 0.250000f, 0.581230f,
+		-0.643075f, -0.588241f, 0.490334f, 0.000000f, -0.643075f, -0.588241f, 0.490334f, 0.411570f, 0.803612f,
+		-0.580461f, -0.498058f, 0.644208f, 0.000000f, -0.580461f, -0.498058f, 0.644208f, 0.412750f, 0.528349f,
+		-0.643075f, -0.588241f, 0.490334f, 0.000000f, -0.643075f, -0.588241f, 0.490334f, 0.411570f, 0.803612f,
+		-0.525731f, -0.723607f, 0.447214f, 0.000000f, -0.525731f, -0.723607f, 0.447214f, 0.321589f, 0.745561f,
+		-0.468576f, -0.644939f, 0.603730f, 0.000000f, -0.468576f, -0.644939f, 0.603730f, 0.411574f, 0.621707f,
+		-0.758172f, 0.246345f, 0.603730f, 0.000000f, -0.758172f, 0.246345f, 0.603730f, 0.588430f, 0.803612f,
+		-0.866018f, 0.097907f, 0.490334f, 0.000000f, -0.866018f, 0.097907f, 0.490334f, 0.328463f, 0.555736f,
+		-0.762354f, 0.061752f, 0.644208f, 0.000000f, -0.762354f, 0.061752f, 0.644208f, 0.587250f, 0.345280f,
+		-0.762354f, 0.061752f, 0.644208f, 0.000000f, -0.762354f, 0.061752f, 0.644208f, 0.587250f, 0.345280f,
+		-0.851981f, -0.083904f, 0.516806f, 0.000000f, -0.851981f, -0.083904f, 0.516806f, 0.411570f, 0.710631f,
+		-0.736686f, -0.124433f, 0.664689f, 0.000000f, -0.736686f, -0.124433f, 0.664689f, 0.500000f, 0.366840f,
+		-0.809017f, -0.262865f, 0.525731f, 0.000000f, -0.809017f, -0.262865f, 0.525731f, 0.327004f, 0.649190f,
+		-0.669131f, -0.332344f, 0.664689f, 0.000000f, -0.669131f, -0.332344f, 0.664689f, 0.258102f, 0.766840f,
+		-0.736686f, -0.124433f, 0.664689f, 0.000000f, -0.736686f, -0.124433f, 0.664689f, 0.500000f, 0.366840f,
+		-0.738585f, -0.432902f, 0.516806f, 0.000000f, -0.738585f, -0.432902f, 0.516806f, 0.250000f, 0.581230f,
+		-0.580461f, -0.498058f, 0.644208f, 0.000000f, -0.580461f, -0.498058f, 0.644208f, 0.412750f, 0.528349f,
+		-0.669131f, -0.332344f, 0.664689f, 0.000000f, -0.669131f, -0.332344f, 0.664689f, 0.258102f, 0.766840f,
+		-0.643075f, -0.588241f, 0.490334f, 0.000000f, -0.643075f, -0.588241f, 0.490334f, 0.411570f, 0.803612f,
+		-0.468576f, -0.644939f, 0.603730f, 0.000000f, -0.468576f, -0.644939f, 0.603730f, 0.411574f, 0.621707f,
+		-0.580461f, -0.498058f, 0.644208f, 0.000000f, -0.580461f, -0.498058f, 0.644208f, 0.412750f, 0.528349f,
+		-0.107846f, -0.148438f, 0.983024f, 0.000000f, -0.107846f, -0.148438f, 0.983024f, 0.588426f, 0.268343f,
+		0.107846f, -0.148438f, 0.983024f, 0.000000f, 0.107846f, -0.148438f, 0.983024f, 0.209770f, 0.912551f,
+		0.000000f, 0.000000f, 1.000000f, 0.000000f, 0.000000f, 0.000000f, 1.000000f, 0.411570f, 0.289369f,
+		-0.212032f, -0.291836f, 0.932670f, 0.000000f, -0.212032f, -0.291836f, 0.932670f, 0.500000f, 0.220572f,
+		-0.000000f, -0.300877f, 0.953663f, 0.000000f, -0.000000f, -0.300877f, 0.953663f, 0.238575f, 0.677923f,
+		-0.107846f, -0.148438f, 0.983024f, 0.000000f, -0.107846f, -0.148438f, 0.983024f, 0.588426f, 0.268343f,
+		-0.000000f, -0.300877f, 0.953663f, 0.000000f, -0.000000f, -0.300877f, 0.953663f, 0.238575f, 0.677923f,
+		0.212032f, -0.291836f, 0.932670f, 0.000000f, 0.212032f, -0.291836f, 0.932670f, 0.327004f, 0.350810f,
+		0.107846f, -0.148438f, 0.983024f, 0.000000f, 0.107846f, -0.148438f, 0.983024f, 0.209770f, 0.912551f,
+		-0.000000f, -0.300877f, 0.953663f, 0.000000f, -0.000000f, -0.300877f, 0.953663f, 0.238575f, 0.677923f,
+		0.107846f, -0.148438f, 0.983024f, 0.000000f, 0.107846f, -0.148438f, 0.983024f, 0.209770f, 0.912551f,
+		-0.107846f, -0.148438f, 0.983024f, 0.000000f, -0.107846f, -0.148438f, 0.983024f, 0.588426f, 0.268343f,
+		-0.309017f, -0.425325f, 0.850651f, 0.000000f, -0.309017f, -0.425325f, 0.850651f, 0.819975f, 0.332044f,
+		-0.104529f, -0.444764f, 0.889527f, 0.000000f, -0.104529f, -0.444764f, 0.889527f, 0.180025f, 0.603966f,
+		-0.212032f, -0.291836f, 0.932670f, 0.000000f, -0.212032f, -0.291836f, 0.932670f, 0.500000f, 0.220572f,
+		-0.104529f, -0.444764f, 0.889527f, 0.000000f, -0.104529f, -0.444764f, 0.889527f, 0.180025f, 0.603966f,
+		0.104529f, -0.444764f, 0.889527f, 0.000000f, 0.104529f, -0.444764f, 0.889527f, 0.411574f, 0.268343f,
+		-0.000000f, -0.300877f, 0.953663f, 0.000000f, -0.000000f, -0.300877f, 0.953663f, 0.238575f, 0.677923f,
+		0.104529f, -0.444764f, 0.889527f, 0.000000f, 0.104529f, -0.444764f, 0.889527f, 0.411574f, 0.268343f,
+		0.309017f, -0.425325f, 0.850651f, 0.000000f, 0.309017f, -0.425325f, 0.850651f, 0.238575f, 0.322077f,
+		0.212032f, -0.291836f, 0.932670f, 0.000000f, 0.212032f, -0.291836f, 0.932670f, 0.327004f, 0.350810f,
+		-0.212032f, -0.291836f, 0.932670f, 0.000000f, -0.212032f, -0.291836f, 0.932670f, 0.500000f, 0.220572f,
+		-0.104529f, -0.444764f, 0.889527f, 0.000000f, -0.104529f, -0.444764f, 0.889527f, 0.180025f, 0.603966f,
+		-0.000000f, -0.300877f, 0.953663f, 0.000000f, -0.000000f, -0.300877f, 0.953663f, 0.238575f, 0.677923f,
+		0.104529f, -0.444764f, 0.889527f, 0.000000f, 0.104529f, -0.444764f, 0.889527f, 0.411574f, 0.268343f,
+		0.212032f, -0.291836f, 0.932670f, 0.000000f, 0.212032f, -0.291836f, 0.932670f, 0.327004f, 0.350810f,
+		-0.000000f, -0.300877f, 0.953663f, 0.000000f, -0.000000f, -0.300877f, 0.953663f, 0.238575f, 0.677923f,
+		-0.395511f, -0.544373f, 0.739749f, 0.000000f, -0.395511f, -0.544373f, 0.739749f, 0.672996f, 0.258102f,
+		-0.213835f, -0.595209f, 0.774597f, 0.000000f, -0.213835f, -0.595209f, 0.774597f, 0.411574f, 0.872062f,
+		-0.309017f, -0.425325f, 0.850651f, 0.000000f, -0.309017f, -0.425325f, 0.850651f, 0.819975f, 0.332044f,
+		-0.213835f, -0.595209f, 0.774597f, 0.000000f, -0.213835f, -0.595209f, 0.774597f, 0.411574f, 0.872062f,
+		-0.000000f, -0.607062f, 0.794655f, 0.000000f, -0.000000f, -0.607062f, 0.794655f, 0.327004f, 0.831089f,
+		-0.104529f, -0.444764f, 0.889527f, 0.000000f, -0.104529f, -0.444764f, 0.889527f, 0.180025f, 0.603966f,
+		-0.000000f, -0.607062f, 0.794655f, 0.000000f, -0.000000f, -0.607062f, 0.794655f, 0.327004f, 0.831089f,
+		0.213834f, -0.595209f, 0.774597f, 0.000000f, 0.213834f, -0.595209f, 0.774597f, 0.238575f, 0.766841f,
+		0.104529f, -0.444764f, 0.889527f, 0.000000f, 0.104529f, -0.444764f, 0.889527f, 0.411574f, 0.268343f,
+		0.213834f, -0.595209f, 0.774597f, 0.000000f, 0.213834f, -0.595209f, 0.774597f, 0.238575f, 0.766841f,
+		0.395510f, -0.544373f, 0.739749f, 0.000000f, 0.395510f, -0.544373f, 0.739749f, 0.238575f, 0.233160f,
+		0.309017f, -0.425325f, 0.850651f, 0.000000f, 0.309017f, -0.425325f, 0.850651f, 0.238575f, 0.322077f,
+		-0.309017f, -0.425325f, 0.850651f, 0.000000f, -0.309017f, -0.425325f, 0.850651f, 0.819975f, 0.332044f,
+		-0.213835f, -0.595209f, 0.774597f, 0.000000f, -0.213835f, -0.595209f, 0.774597f, 0.411574f, 0.872062f,
+		-0.104529f, -0.444764f, 0.889527f, 0.000000f, -0.104529f, -0.444764f, 0.889527f, 0.180025f, 0.603966f,
+		-0.000000f, -0.607062f, 0.794655f, 0.000000f, -0.000000f, -0.607062f, 0.794655f, 0.327004f, 0.831089f,
+		0.104529f, -0.444764f, 0.889527f, 0.000000f, 0.104529f, -0.444764f, 0.889527f, 0.411574f, 0.268343f,
+		-0.104529f, -0.444764f, 0.889527f, 0.000000f, -0.104529f, -0.444764f, 0.889527f, 0.180025f, 0.603966f,
+		0.213834f, -0.595209f, 0.774597f, 0.000000f, 0.213834f, -0.595209f, 0.774597f, 0.238575f, 0.766841f,
+		0.309017f, -0.425325f, 0.850651f, 0.000000f, 0.309017f, -0.425325f, 0.850651f, 0.238575f, 0.322077f,
+		0.104529f, -0.444764f, 0.889527f, 0.000000f, 0.104529f, -0.444764f, 0.889527f, 0.411574f, 0.268343f,
+		-0.468576f, -0.644939f, 0.603730f, 0.000000f, -0.468576f, -0.644939f, 0.603730f, 0.411574f, 0.621707f,
+		-0.294310f, -0.705959f, 0.644208f, 0.000000f, -0.294310f, -0.705959f, 0.644208f, 0.173473f, 0.699071f,
+		-0.395511f, -0.544373f, 0.739749f, 0.000000f, -0.395511f, -0.544373f, 0.739749f, 0.672996f, 0.258102f,
+		-0.294310f, -0.705959f, 0.644208f, 0.000000f, -0.294310f, -0.705959f, 0.644208f, 0.173473f, 0.699071f,
+		-0.109305f, -0.739082f, 0.664689f, 0.000000f, -0.109305f, -0.739082f, 0.664689f, 0.412750f, 0.345280f,
+		-0.213835f, -0.595209f, 0.774597f, 0.000000f, -0.213835f, -0.595209f, 0.774597f, 0.411574f, 0.872062f,
+		-0.109305f, -0.739082f, 0.664689f, 0.000000f, -0.109305f, -0.739082f, 0.664689f, 0.412750f, 0.345280f,
+		0.109305f, -0.739082f, 0.664689f, 0.000000f, 0.109305f, -0.739082f, 0.664689f, 0.328463f, 0.332044f,
+		-0.000000f, -0.607062f, 0.794655f, 0.000000f, -0.000000f, -0.607062f, 0.794655f, 0.327004f, 0.831089f,
+		0.109305f, -0.739082f, 0.664689f, 0.000000f, 0.109305f, -0.739082f, 0.664689f, 0.328463f, 0.332044f,
+		0.294309f, -0.705959f, 0.644208f, 0.000000f, 0.294309f, -0.705959f, 0.644208f, 0.250000f, 0.327581f,
+		0.213834f, -0.595209f, 0.774597f, 0.000000f, 0.213834f, -0.595209f, 0.774597f, 0.238575f, 0.766841f,
+		0.294309f, -0.705959f, 0.644208f, 0.000000f, 0.294309f, -0.705959f, 0.644208f, 0.250000f, 0.327581f,
+		0.468576f, -0.644939f, 0.603730f, 0.000000f, 0.468576f, -0.644939f, 0.603730f, 0.327004f, 0.922791f,
+		0.395510f, -0.544373f, 0.739749f, 0.000000f, 0.395510f, -0.544373f, 0.739749f, 0.238575f, 0.233160f,
+		-0.395511f, -0.544373f, 0.739749f, 0.000000f, -0.395511f, -0.544373f, 0.739749f, 0.672996f, 0.258102f,
+		-0.294310f, -0.705959f, 0.644208f, 0.000000f, -0.294310f, -0.705959f, 0.644208f, 0.173473f, 0.699071f,
+		-0.213835f, -0.595209f, 0.774597f, 0.000000f, -0.213835f, -0.595209f, 0.774597f, 0.411574f, 0.872062f,
+		-0.213835f, -0.595209f, 0.774597f, 0.000000f, -0.213835f, -0.595209f, 0.774597f, 0.411574f, 0.872062f,
+		-0.109305f, -0.739082f, 0.664689f, 0.000000f, -0.109305f, -0.739082f, 0.664689f, 0.412750f, 0.345280f,
+		-0.000000f, -0.607062f, 0.794655f, 0.000000f, -0.000000f, -0.607062f, 0.794655f, 0.327004f, 0.831089f,
+		0.109305f, -0.739082f, 0.664689f, 0.000000f, 0.109305f, -0.739082f, 0.664689f, 0.328463f, 0.332044f,
+		0.213834f, -0.595209f, 0.774597f, 0.000000f, 0.213834f, -0.595209f, 0.774597f, 0.238575f, 0.766841f,
+		-0.000000f, -0.607062f, 0.794655f, 0.000000f, -0.000000f, -0.607062f, 0.794655f, 0.327004f, 0.831089f,
+		0.294309f, -0.705959f, 0.644208f, 0.000000f, 0.294309f, -0.705959f, 0.644208f, 0.250000f, 0.327581f,
+		0.395510f, -0.544373f, 0.739749f, 0.000000f, 0.395510f, -0.544373f, 0.739749f, 0.238575f, 0.233160f,
+		0.213834f, -0.595209f, 0.774597f, 0.000000f, 0.213834f, -0.595209f, 0.774597f, 0.238575f, 0.766841f,
+		-0.525731f, -0.723607f, 0.447214f, 0.000000f, -0.525731f, -0.723607f, 0.447214f, 0.321589f, 0.745561f,
+		-0.360730f, -0.793377f, 0.490334f, 0.000000f, -0.360730f, -0.793377f, 0.490334f, 0.327004f, 0.258102f,
+		-0.468576f, -0.644939f, 0.603730f, 0.000000f, -0.468576f, -0.644939f, 0.603730f, 0.411574f, 0.621707f,
+		-0.360730f, -0.793377f, 0.490334f, 0.000000f, -0.360730f, -0.793377f, 0.490334f, 0.327004f, 0.258102f,
+		-0.183479f, -0.836210f, 0.516806f, 0.000000f, -0.183479f, -0.836210f, 0.516806f, 0.180025f, 0.332044f,
+		-0.294310f, -0.705959f, 0.644208f, 0.000000f, -0.294310f, -0.705959f, 0.644208f, 0.173473f, 0.699071f,
+		-0.183479f, -0.836210f, 0.516806f, 0.000000f, -0.183479f, -0.836210f, 0.516806f, 0.180025f, 0.332044f,
+		-0.000000f, -0.850651f, 0.525731f, 0.000000f, -0.000000f, -0.850651f, 0.525731f, 0.238575f, 0.258102f,
+		-0.109305f, -0.739082f, 0.664689f, 0.000000f, -0.109305f, -0.739082f, 0.664689f, 0.412750f, 0.345280f,
+		-0.000000f, -0.850651f, 0.525731f, 0.000000f, -0.000000f, -0.850651f, 0.525731f, 0.238575f, 0.258102f,
+		0.183479f, -0.836210f, 0.516806f, 0.000000f, 0.183479f, -0.836210f, 0.516806f, 0.258102f, 0.766841f,
+		0.109305f, -0.739082f, 0.664689f, 0.000000f, 0.109305f, -0.739082f, 0.664689f, 0.328463f, 0.332044f,
+		0.183479f, -0.836210f, 0.516806f, 0.000000f, 0.183479f, -0.836210f, 0.516806f, 0.258102f, 0.766841f,
+		0.360730f, -0.793377f, 0.490334f, 0.000000f, 0.360730f, -0.793377f, 0.490334f, 0.446077f, 0.425781f,
+		0.294309f, -0.705959f, 0.644208f, 0.000000f, 0.294309f, -0.705959f, 0.644208f, 0.250000f, 0.327581f,
+		0.360730f, -0.793377f, 0.490334f, 0.000000f, 0.360730f, -0.793377f, 0.490334f, 0.446077f, 0.425781f,
+		0.525731f, -0.723607f, 0.447214f, 0.000000f, 0.525731f, -0.723607f, 0.447214f, 0.606016f, 0.354082f,
+		0.468576f, -0.644939f, 0.603730f, 0.000000f, 0.468576f, -0.644939f, 0.603730f, 0.327004f, 0.922791f,
+		-0.468576f, -0.644939f, 0.603730f, 0.000000f, -0.468576f, -0.644939f, 0.603730f, 0.411574f, 0.621707f,
+		-0.360730f, -0.793377f, 0.490334f, 0.000000f, -0.360730f, -0.793377f, 0.490334f, 0.327004f, 0.258102f,
+		-0.294310f, -0.705959f, 0.644208f, 0.000000f, -0.294310f, -0.705959f, 0.644208f, 0.173473f, 0.699071f,
+		-0.294310f, -0.705959f, 0.644208f, 0.000000f, -0.294310f, -0.705959f, 0.644208f, 0.173473f, 0.699071f,
+		-0.183479f, -0.836210f, 0.516806f, 0.000000f, -0.183479f, -0.836210f, 0.516806f, 0.180025f, 0.332044f,
+		-0.109305f, -0.739082f, 0.664689f, 0.000000f, -0.109305f, -0.739082f, 0.664689f, 0.412750f, 0.345280f,
+		-0.109305f, -0.739082f, 0.664689f, 0.000000f, -0.109305f, -0.739082f, 0.664689f, 0.412750f, 0.345280f,
+		-0.000000f, -0.850651f, 0.525731f, 0.000000f, -0.000000f, -0.850651f, 0.525731f, 0.238575f, 0.258102f,
+		0.109305f, -0.739082f, 0.664689f, 0.000000f, 0.109305f, -0.739082f, 0.664689f, 0.328463f, 0.332044f,
+		0.183479f, -0.836210f, 0.516806f, 0.000000f, 0.183479f, -0.836210f, 0.516806f, 0.258102f, 0.766841f,
+		0.294309f, -0.705959f, 0.644208f, 0.000000f, 0.294309f, -0.705959f, 0.644208f, 0.250000f, 0.327581f,
+		0.109305f, -0.739082f, 0.664689f, 0.000000f, 0.109305f, -0.739082f, 0.664689f, 0.328463f, 0.332044f,
+		0.360730f, -0.793377f, 0.490334f, 0.000000f, 0.360730f, -0.793377f, 0.490334f, 0.446077f, 0.425781f,
+		0.468576f, -0.644939f, 0.603730f, 0.000000f, 0.468576f, -0.644939f, 0.603730f, 0.327004f, 0.922791f,
+		0.294309f, -0.705959f, 0.644208f, 0.000000f, 0.294309f, -0.705959f, 0.644208f, 0.250000f, 0.327581f,
+		0.000000f, -0.894427f, -0.447214f, 0.000000f, 0.000000f, -0.894427f, -0.447214f, 0.848850f, 0.215669f,
+		0.174499f, -0.853887f, -0.490334f, 0.000000f, 0.174499f, -0.853887f, -0.490334f, 0.814054f, 0.361804f,
+		0.107846f, -0.945626f, -0.306855f, 0.000000f, 0.107846f, -0.945626f, -0.306855f, 0.356925f, 0.453512f,
+		0.174499f, -0.853887f, -0.490334f, 0.000000f, 0.174499f, -0.853887f, -0.490334f, 0.814054f, 0.361804f,
+		0.343074f, -0.784354f, -0.516806f, 0.000000f, 0.343074f, -0.784354f, -0.516806f, 0.835614f, 0.285088f,
+		0.286151f, -0.894562f, -0.343331f, 0.000000f, 0.286151f, -0.894562f, -0.343331f, 0.393984f, 0.354082f,
+		0.107846f, -0.945626f, -0.306855f, 0.000000f, 0.107846f, -0.945626f, -0.306855f, 0.356925f, 0.453512f,
+		0.286151f, -0.894562f, -0.343331f, 0.000000f, 0.286151f, -0.894562f, -0.343331f, 0.393984f, 0.354082f,
+		0.212032f, -0.964719f, -0.156077f, 0.000000f, 0.212032f, -0.964719f, -0.156077f, 0.272352f, 0.480987f,
+		0.174499f, -0.853887f, -0.490334f, 0.000000f, 0.174499f, -0.853887f, -0.490334f, 0.814054f, 0.361804f,
+		0.286151f, -0.894562f, -0.343331f, 0.000000f, 0.286151f, -0.894562f, -0.343331f, 0.393984f, 0.354082f,
+		0.107846f, -0.945626f, -0.306855f, 0.000000f, 0.107846f, -0.945626f, -0.306855f, 0.356925f, 0.453512f,
+		0.343074f, -0.784354f, -0.516806f, 0.000000f, 0.343074f, -0.784354f, -0.516806f, 0.835614f, 0.285088f,
+		0.500000f, -0.688191f, -0.525731f, 0.000000f, 0.500000f, -0.688191f, -0.525731f, 0.500000f, 0.892312f,
+		0.455297f, -0.812623f, -0.363797f, 0.000000f, 0.455297f, -0.812623f, -0.363797f, 0.304653f, 0.381573f,
+		0.286151f, -0.894562f, -0.343331f, 0.000000f, 0.286151f, -0.894562f, -0.343331f, 0.393984f, 0.354082f,
+		0.455297f, -0.812623f, -0.363797f, 0.000000f, 0.455297f, -0.812623f, -0.363797f, 0.304653f, 0.381573f,
+		0.390694f, -0.901541f, -0.185961f, 0.000000f, 0.390694f, -0.901541f, -0.185961f, 0.345491f, 0.287337f,
+		0.212032f, -0.964719f, -0.156077f, 0.000000f, 0.212032f, -0.964719f, -0.156077f, 0.272352f, 0.480987f,
+		0.390694f, -0.901541f, -0.185961f, 0.000000f, 0.390694f, -0.901541f, -0.185961f, 0.345491f, 0.287337f,
+		0.309017f, -0.951057f, 0.000000f, 0.000000f, 0.309017f, -0.951057f, 0.000000f, 0.183922f, 0.509719f,
+		0.343074f, -0.784354f, -0.516806f, 0.000000f, 0.343074f, -0.784354f, -0.516806f, 0.835614f, 0.285088f,
+		0.455297f, -0.812623f, -0.363797f, 0.000000f, 0.455297f, -0.812623f, -0.363797f, 0.304653f, 0.381573f,
+		0.286151f, -0.894562f, -0.343331f, 0.000000f, 0.286151f, -0.894562f, -0.343331f, 0.393984f, 0.354082f,
+		0.286151f, -0.894562f, -0.343331f, 0.000000f, 0.286151f, -0.894562f, -0.343331f, 0.393984f, 0.354082f,
+		0.390694f, -0.901541f, -0.185961f, 0.000000f, 0.390694f, -0.901541f, -0.185961f, 0.345491f, 0.287337f,
+		0.212032f, -0.964719f, -0.156077f, 0.000000f, 0.212032f, -0.964719f, -0.156077f, 0.272352f, 0.480987f,
+		0.500000f, -0.688191f, -0.525731f, 0.000000f, 0.500000f, -0.688191f, -0.525731f, 0.500000f, 0.892312f,
+		0.639949f, -0.568662f, -0.516806f, 0.000000f, 0.639949f, -0.568662f, -0.516806f, 0.588426f, 0.912551f,
+		0.632156f, -0.684127f, -0.363797f, 0.000000f, 0.632156f, -0.684127f, -0.363797f, 0.211325f, 0.406204f,
+		0.455297f, -0.812623f, -0.363797f, 0.000000f, 0.455297f, -0.812623f, -0.363797f, 0.304653f, 0.381573f,
+		0.632156f, -0.684127f, -0.363797f, 0.000000f, 0.632156f, -0.684127f, -0.363797f, 0.211325f, 0.406204f,
+		0.577350f, -0.794654f, -0.187593f, 0.000000f, 0.577350f, -0.794654f, -0.187593f, 0.250001f, 0.306351f,
+		0.390694f, -0.901541f, -0.185961f, 0.000000f, 0.390694f, -0.901541f, -0.185961f, 0.345491f, 0.287337f,
+		0.577350f, -0.794654f, -0.187593f, 0.000000f, 0.577350f, -0.794654f, -0.187593f, 0.250001f, 0.306351f,
+		0.499999f, -0.866026f, 0.000000f, 0.000000f, 0.499999f, -0.866026f, 0.000000f, 0.302244f, 0.227814f,
+		0.309017f, -0.951057f, 0.000000f, 0.000000f, 0.309017f, -0.951057f, 0.000000f, 0.183922f, 0.509719f,
+		0.499999f, -0.866026f, 0.000000f, 0.000000f, 0.499999f, -0.866026f, 0.000000f, 0.302244f, 0.227814f,
+		0.395510f, -0.905103f, 0.156077f, 0.000000f, 0.395510f, -0.905103f, 0.156077f, 0.131657f, 0.437784f,
+		0.455297f, -0.812623f, -0.363797f, 0.000000f, 0.455297f, -0.812623f, -0.363797f, 0.304653f, 0.381573f,
+		0.500000f, -0.688191f, -0.525731f, 0.000000f, 0.500000f, -0.688191f, -0.525731f, 0.500000f, 0.892312f,
+		0.632156f, -0.684127f, -0.363797f, 0.000000f, 0.632156f, -0.684127f, -0.363797f, 0.211325f, 0.406204f,
+		0.455297f, -0.812623f, -0.363797f, 0.000000f, 0.455297f, -0.812623f, -0.363797f, 0.304653f, 0.381573f,
+		0.577350f, -0.794654f, -0.187593f, 0.000000f, 0.577350f, -0.794654f, -0.187593f, 0.250001f, 0.306351f,
+		0.390694f, -0.901541f, -0.185961f, 0.000000f, 0.390694f, -0.901541f, -0.185961f, 0.345491f, 0.287337f,
+		0.309017f, -0.951057f, 0.000000f, 0.000000f, 0.309017f, -0.951057f, 0.000000f, 0.183922f, 0.509719f,
+		0.390694f, -0.901541f, -0.185961f, 0.000000f, 0.390694f, -0.901541f, -0.185961f, 0.345491f, 0.287337f,
+		0.499999f, -0.866026f, 0.000000f, 0.000000f, 0.499999f, -0.866026f, 0.000000f, 0.302244f, 0.227814f,
+		0.639949f, -0.568662f, -0.516806f, 0.000000f, 0.639949f, -0.568662f, -0.516806f, 0.588426f, 0.912551f,
+		0.758172f, -0.429824f, -0.490334f, 0.000000f, 0.758172f, -0.429824f, -0.490334f, 0.588426f, 0.127938f,
+		0.762354f, -0.548581f, -0.343331f, 0.000000f, 0.762354f, -0.548581f, -0.343331f, 0.165435f, 0.333828f,
+		0.632156f, -0.684127f, -0.363797f, 0.000000f, 0.632156f, -0.684127f, -0.363797f, 0.211325f, 0.406204f,
+		0.762354f, -0.548581f, -0.343331f, 0.000000f, 0.762354f, -0.548581f, -0.343331f, 0.165435f, 0.333828f,
+		0.736686f, -0.650164f, -0.185961f, 0.000000f, 0.736686f, -0.650164f, -0.185961f, 0.209769f, 0.250971f,
+		0.577350f, -0.794654f, -0.187593f, 0.000000f, 0.577350f, -0.794654f, -0.187593f, 0.250001f, 0.306351f,
+		0.736686f, -0.650164f, -0.185961f, 0.000000f, 0.736686f, -0.650164f, -0.185961f, 0.209769f, 0.250971f,
+		0.669131f, -0.743144f, 0.000000f, 0.000000f, 0.669131f, -0.743144f, 0.000000f, 0.265712f, 0.177530f,
+		0.499999f, -0.866026f, 0.000000f, 0.000000f, 0.499999f, -0.866026f, 0.000000f, 0.302244f, 0.227814f,
+		0.669131f, -0.743144f, 0.000000f, 0.000000f, 0.669131f, -0.743144f, 0.000000f, 0.265712f, 0.177530f,
+		0.580460f, -0.798935f, 0.157379f, 0.000000f, 0.580460f, -0.798935f, 0.157379f, 0.118823f, 0.530876f,
+		0.395510f, -0.905103f, 0.156077f, 0.000000f, 0.395510f, -0.905103f, 0.156077f, 0.131657f, 0.437784f,
+		0.580460f, -0.798935f, 0.157379f, 0.000000f, 0.580460f, -0.798935f, 0.157379f, 0.118823f, 0.530876f,
+		0.468576f, -0.828418f, 0.306855f, 0.000000f, 0.468576f, -0.828418f, 0.306855f, 0.178463f, 0.345280f,
+		0.632156f, -0.684127f, -0.363797f, 0.000000f, 0.632156f, -0.684127f, -0.363797f, 0.211325f, 0.406204f,
+		0.639949f, -0.568662f, -0.516806f, 0.000000f, 0.639949f, -0.568662f, -0.516806f, 0.588426f, 0.912551f,
+		0.762354f, -0.548581f, -0.343331f, 0.000000f, 0.762354f, -0.548581f, -0.343331f, 0.165435f, 0.333828f,
+		0.577350f, -0.794654f, -0.187593f, 0.000000f, 0.577350f, -0.794654f, -0.187593f, 0.250001f, 0.306351f,
+		0.632156f, -0.684127f, -0.363797f, 0.000000f, 0.632156f, -0.684127f, -0.363797f, 0.211325f, 0.406204f,
+		0.736686f, -0.650164f, -0.185961f, 0.000000f, 0.736686f, -0.650164f, -0.185961f, 0.209769f, 0.250971f,
+		0.499999f, -0.866026f, 0.000000f, 0.000000f, 0.499999f, -0.866026f, 0.000000f, 0.302244f, 0.227814f,
+		0.577350f, -0.794654f, -0.187593f, 0.000000f, 0.577350f, -0.794654f, -0.187593f, 0.250001f, 0.306351f,
+		0.669131f, -0.743144f, 0.000000f, 0.000000f, 0.669131f, -0.743144f, 0.000000f, 0.265712f, 0.177530f,
+		0.395510f, -0.905103f, 0.156077f, 0.000000f, 0.395510f, -0.905103f, 0.156077f, 0.131657f, 0.437784f,
+		0.499999f, -0.866026f, 0.000000f, 0.000000f, 0.499999f, -0.866026f, 0.000000f, 0.302244f, 0.227814f,
+		0.580460f, -0.798935f, 0.157379f, 0.000000f, 0.580460f, -0.798935f, 0.157379f, 0.118823f, 0.530876f,
+		0.758172f, -0.429824f, -0.490334f, 0.000000f, 0.758172f, -0.429824f, -0.490334f, 0.588426f, 0.127938f,
+		0.850651f, -0.276393f, -0.447214f, 0.000000f, 0.850651f, -0.276393f, -0.447214f, 0.500000f, 0.960321f,
+		0.866018f, -0.394782f, -0.306855f, 0.000000f, 0.866018f, -0.394782f, -0.306855f, 0.237134f, 0.366840f,
+		0.762354f, -0.548581f, -0.343331f, 0.000000f, 0.762354f, -0.548581f, -0.343331f, 0.165435f, 0.333828f,
+		0.866018f, -0.394782f, -0.306855f, 0.000000f, 0.866018f, -0.394782f, -0.306855f, 0.237134f, 0.366840f,
+		0.851981f, -0.499769f, -0.156077f, 0.000000f, 0.851981f, -0.499769f, -0.156077f, 0.265712f, 0.288582f,
+		0.736686f, -0.650164f, -0.185961f, 0.000000f, 0.736686f, -0.650164f, -0.185961f, 0.209769f, 0.250971f,
+		0.851981f, -0.499769f, -0.156077f, 0.000000f, 0.851981f, -0.499769f, -0.156077f, 0.265712f, 0.288582f,
+		0.809017f, -0.587785f, 0.000000f, 0.000000f, 0.809017f, -0.587785f, 0.000000f, 0.209769f, 0.268343f,
+		0.669131f, -0.743144f, 0.000000f, 0.000000f, 0.669131f, -0.743144f, 0.000000f, 0.265712f, 0.177530f,
+		0.809017f, -0.587785f, 0.000000f, 0.000000f, 0.809017f, -0.587785f, 0.000000f, 0.209769f, 0.268343f,
+		0.738585f, -0.655845f, 0.156077f, 0.000000f, 0.738585f, -0.655845f, 0.156077f, 0.500000f, 0.349562f,
+		0.580460f, -0.798935f, 0.157379f, 0.000000f, 0.580460f, -0.798935f, 0.157379f, 0.118823f, 0.530876f,
+		0.738585f, -0.655845f, 0.156077f, 0.000000f, 0.738585f, -0.655845f, 0.156077f, 0.500000f, 0.349562f,
+		0.643075f, -0.701637f, 0.306855f, 0.000000f, 0.643075f, -0.701637f, 0.306855f, 0.447735f, 0.277618f,
+		0.468576f, -0.828418f, 0.306855f, 0.000000f, 0.468576f, -0.828418f, 0.306855f, 0.178463f, 0.345280f,
+		0.643075f, -0.701637f, 0.306855f, 0.000000f, 0.643075f, -0.701637f, 0.306855f, 0.447735f, 0.277618f,
+		0.525731f, -0.723607f, 0.447214f, 0.000000f, 0.525731f, -0.723607f, 0.447214f, 0.606016f, 0.354082f,
+		0.762354f, -0.548581f, -0.343331f, 0.000000f, 0.762354f, -0.548581f, -0.343331f, 0.165435f, 0.333828f,
+		0.758172f, -0.429824f, -0.490334f, 0.000000f, 0.758172f, -0.429824f, -0.490334f, 0.588426f, 0.127938f,
+		0.866018f, -0.394782f, -0.306855f, 0.000000f, 0.866018f, -0.394782f, -0.306855f, 0.237134f, 0.366840f,
+		0.736686f, -0.650164f, -0.185961f, 0.000000f, 0.736686f, -0.650164f, -0.185961f, 0.209769f, 0.250971f,
+		0.762354f, -0.548581f, -0.343331f, 0.000000f, 0.762354f, -0.548581f, -0.343331f, 0.165435f, 0.333828f,
+		0.851981f, -0.499769f, -0.156077f, 0.000000f, 0.851981f, -0.499769f, -0.156077f, 0.265712f, 0.288582f,
+		0.669131f, -0.743144f, 0.000000f, 0.000000f, 0.669131f, -0.743144f, 0.000000f, 0.265712f, 0.177530f,
+		0.736686f, -0.650164f, -0.185961f, 0.000000f, 0.736686f, -0.650164f, -0.185961f, 0.209769f, 0.250971f,
+		0.809017f, -0.587785f, 0.000000f, 0.000000f, 0.809017f, -0.587785f, 0.000000f, 0.209769f, 0.268343f,
+		0.669131f, -0.743144f, 0.000000f, 0.000000f, 0.669131f, -0.743144f, 0.000000f, 0.265712f, 0.177530f,
+		0.738585f, -0.655845f, 0.156077f, 0.000000f, 0.738585f, -0.655845f, 0.156077f, 0.500000f, 0.349562f,
+		0.580460f, -0.798935f, 0.157379f, 0.000000f, 0.580460f, -0.798935f, 0.157379f, 0.118823f, 0.530876f,
+		0.468576f, -0.828418f, 0.306855f, 0.000000f, 0.468576f, -0.828418f, 0.306855f, 0.178463f, 0.345280f,
+		0.580460f, -0.798935f, 0.157379f, 0.000000f, 0.580460f, -0.798935f, 0.157379f, 0.118823f, 0.530876f,
+		0.643075f, -0.701637f, 0.306855f, 0.000000f, 0.643075f, -0.701637f, 0.306855f, 0.447735f, 0.277618f,
+		0.850651f, -0.276393f, -0.447214f, 0.000000f, 0.850651f, -0.276393f, -0.447214f, 0.500000f, 0.960321f,
+		0.866018f, -0.097907f, -0.490334f, 0.000000f, 0.866018f, -0.097907f, -0.490334f, 0.834566f, 0.666172f,
+		0.932670f, -0.189647f, -0.306855f, 0.000000f, 0.932670f, -0.189647f, -0.306855f, 0.552265f, 0.277618f,
+		0.866018f, -0.097907f, -0.490334f, 0.000000f, 0.866018f, -0.097907f, -0.490334f, 0.834566f, 0.666172f,
+		0.851981f, 0.083904f, -0.516806f, 0.000000f, 0.851981f, 0.083904f, -0.516806f, 0.734288f, 0.822469f,
+		0.939205f, -0.004289f, -0.343331f, 0.000000f, 0.939205f, -0.004289f, -0.343331f, 0.393082f, 0.202395f,
+		0.932670f, -0.189647f, -0.306855f, 0.000000f, 0.932670f, -0.189647f, -0.306855f, 0.552265f, 0.277618f,
+		0.939205f, -0.004289f, -0.343331f, 0.000000f, 0.939205f, -0.004289f, -0.343331f, 0.393082f, 0.202395f,
+		0.983024f, -0.096461f, -0.156077f, 0.000000f, 0.983024f, -0.096461f, -0.156077f, 0.500000f, 0.196469f,
+		0.866018f, -0.097907f, -0.490334f, 0.000000f, 0.866018f, -0.097907f, -0.490334f, 0.834566f, 0.666172f,
+		0.939205f, -0.004289f, -0.343331f, 0.000000f, 0.939205f, -0.004289f, -0.343331f, 0.393082f, 0.202395f,
+		0.932670f, -0.189647f, -0.306855f, 0.000000f, 0.932670f, -0.189647f, -0.306855f, 0.552265f, 0.277618f,
+		0.851981f, 0.083904f, -0.516806f, 0.000000f, 0.851981f, 0.083904f, -0.516806f, 0.734288f, 0.822469f,
+		0.809017f, 0.262865f, -0.525731f, 0.000000f, 0.809017f, 0.262865f, -0.525731f, 0.790230f, 0.749029f,
+		0.913545f, 0.181898f, -0.363797f, 0.000000f, 0.913545f, 0.181898f, -0.363797f, 0.606917f, 0.202395f,
+		0.939205f, -0.004289f, -0.343331f, 0.000000f, 0.939205f, -0.004289f, -0.343331f, 0.393082f, 0.202395f,
+		0.913545f, 0.181898f, -0.363797f, 0.000000f, 0.913545f, 0.181898f, -0.363797f, 0.606917f, 0.202395f,
+		0.978148f, 0.092981f, -0.185961f, 0.000000f, 0.978148f, 0.092981f, -0.185961f, 0.352845f, 0.147020f,
+		0.983024f, -0.096461f, -0.156077f, 0.000000f, 0.983024f, -0.096461f, -0.156077f, 0.500000f, 0.196469f,
+		0.978148f, 0.092981f, -0.185961f, 0.000000f, 0.978148f, 0.092981f, -0.185961f, 0.352845f, 0.147020f,
+		1.000000f, -0.000000f, 0.000000f, 0.000000f, 1.000000f, -0.000000f, 0.000000f, 0.445347f, 0.130459f,
+		0.851981f, 0.083904f, -0.516806f, 0.000000f, 0.851981f, 0.083904f, -0.516806f, 0.734288f, 0.822469f,
+		0.913545f, 0.181898f, -0.363797f, 0.000000f, 0.913545f, 0.181898f, -0.363797f, 0.606917f, 0.202395f,
+		0.939205f, -0.004289f, -0.343331f, 0.000000f, 0.939205f, -0.004289f, -0.343331f, 0.393082f, 0.202395f,
+		0.939205f, -0.004289f, -0.343331f, 0.000000f, 0.939205f, -0.004289f, -0.343331f, 0.393082f, 0.202395f,
+		0.978148f, 0.092981f, -0.185961f, 0.000000f, 0.978148f, 0.092981f, -0.185961f, 0.352845f, 0.147020f,
+		0.983024f, -0.096461f, -0.156077f, 0.000000f, 0.983024f, -0.096461f, -0.156077f, 0.500000f, 0.196469f,
+		0.809017f, 0.262865f, -0.525731f, 0.000000f, 0.809017f, 0.262865f, -0.525731f, 0.790230f, 0.749029f,
+		0.738585f, 0.432902f, -0.516806f, 0.000000f, 0.738585f, 0.432902f, -0.516806f, 0.816078f, 0.490281f,
+		0.845991f, 0.389809f, -0.363797f, 0.000000f, 0.845991f, 0.389809f, -0.363797f, 0.554653f, 0.130459f,
+		0.913545f, 0.181898f, -0.363797f, 0.000000f, 0.913545f, 0.181898f, -0.363797f, 0.606917f, 0.202395f,
+		0.845991f, 0.389809f, -0.363797f, 0.000000f, 0.845991f, 0.389809f, -0.363797f, 0.554653f, 0.130459f,
+		0.934172f, 0.303531f, -0.187593f, 0.000000f, 0.934172f, 0.303531f, -0.187593f, 0.647155f, 0.147020f,
+		0.978148f, 0.092981f, -0.185961f, 0.000000f, 0.978148f, 0.092981f, -0.185961f, 0.352845f, 0.147020f,
+		0.934172f, 0.303531f, -0.187593f, 0.000000f, 0.934172f, 0.303531f, -0.187593f, 0.647155f, 0.147020f,
+		0.978148f, 0.207911f, 0.000000f, 0.000000f, 0.978148f, 0.207911f, 0.000000f, 0.319635f, 0.345280f,
+		1.000000f, -0.000000f, 0.000000f, 0.000000f, 1.000000f, -0.000000f, 0.000000f, 0.445347f, 0.130459f,
+		0.978148f, 0.207911f, 0.000000f, 0.000000f, 0.978148f, 0.207911f, 0.000000f, 0.319635f, 0.345280f,
+		0.983024f, 0.096460f, 0.156077f, 0.000000f, 0.983024f, 0.096460f, 0.156077f, 0.408260f, 0.332044f,
+		0.913545f, 0.181898f, -0.363797f, 0.000000f, 0.913545f, 0.181898f, -0.363797f, 0.606917f, 0.202395f,
+		0.809017f, 0.262865f, -0.525731f, 0.000000f, 0.809017f, 0.262865f, -0.525731f, 0.790230f, 0.749029f,
+		0.845991f, 0.389809f, -0.363797f, 0.000000f, 0.845991f, 0.389809f, -0.363797f, 0.554653f, 0.130459f,
+		0.913545f, 0.181898f, -0.363797f, 0.000000f, 0.913545f, 0.181898f, -0.363797f, 0.606917f, 0.202395f,
+		0.934172f, 0.303531f, -0.187593f, 0.000000f, 0.934172f, 0.303531f, -0.187593f, 0.647155f, 0.147020f,
+		0.978148f, 0.092981f, -0.185961f, 0.000000f, 0.978148f, 0.092981f, -0.185961f, 0.352845f, 0.147020f,
+		1.000000f, -0.000000f, 0.000000f, 0.000000f, 1.000000f, -0.000000f, 0.000000f, 0.445347f, 0.130459f,
+		0.978148f, 0.092981f, -0.185961f, 0.000000f, 0.978148f, 0.092981f, -0.185961f, 0.352845f, 0.147020f,
+		0.978148f, 0.207911f, 0.000000f, 0.000000f, 0.978148f, 0.207911f, 0.000000f, 0.319635f, 0.345280f,
+		0.738585f, 0.432902f, -0.516806f, 0.000000f, 0.738585f, 0.432902f, -0.516806f, 0.816078f, 0.490281f,
+		0.643075f, 0.588241f, -0.490334f, 0.000000f, 0.643075f, 0.588241f, -0.490334f, 0.697755f, 0.772187f,
+		0.757312f, 0.555521f, -0.343331f, 0.000000f, 0.757312f, 0.555521f, -0.343331f, 0.352845f, 0.268343f,
+		0.845991f, 0.389809f, -0.363797f, 0.000000f, 0.845991f, 0.389809f, -0.363797f, 0.554653f, 0.130459f,
+		0.757312f, 0.555521f, -0.343331f, 0.000000f, 0.757312f, 0.555521f, -0.343331f, 0.352845f, 0.268343f,
+		0.845991f, 0.499718f, -0.185961f, 0.000000f, 0.845991f, 0.499718f, -0.185961f, 0.500000f, 0.327581f,
+		0.934172f, 0.303531f, -0.187593f, 0.000000f, 0.934172f, 0.303531f, -0.187593f, 0.647155f, 0.147020f,
+		0.845991f, 0.499718f, -0.185961f, 0.000000f, 0.845991f, 0.499718f, -0.185961f, 0.500000f, 0.327581f,
+		0.913545f, 0.406737f, 0.000000f, 0.000000f, 0.913545f, 0.406737f, 0.000000f, 0.445347f, 0.258102f,
+		0.978148f, 0.207911f, 0.000000f, 0.000000f, 0.978148f, 0.207911f, 0.000000f, 0.319635f, 0.345280f,
+		0.913545f, 0.406737f, 0.000000f, 0.000000f, 0.913545f, 0.406737f, 0.000000f, 0.445347f, 0.258102f,
+		0.939205f, 0.305166f, 0.157379f, 0.000000f, 0.939205f, 0.305166f, 0.157379f, 0.591739f, 0.332044f,
+		0.983024f, 0.096460f, 0.156077f, 0.000000f, 0.983024f, 0.096460f, 0.156077f, 0.408260f, 0.332044f,
+		0.939205f, 0.305166f, 0.157379f, 0.000000f, 0.939205f, 0.305166f, 0.157379f, 0.591739f, 0.332044f,
+		0.932670f, 0.189647f, 0.306855f, 0.000000f, 0.932670f, 0.189647f, 0.306855f, 0.554653f, 0.258102f,
+		0.845991f, 0.389809f, -0.363797f, 0.000000f, 0.845991f, 0.389809f, -0.363797f, 0.554653f, 0.130459f,
+		0.738585f, 0.432902f, -0.516806f, 0.000000f, 0.738585f, 0.432902f, -0.516806f, 0.816078f, 0.490281f,
+		0.757312f, 0.555521f, -0.343331f, 0.000000f, 0.757312f, 0.555521f, -0.343331f, 0.352845f, 0.268343f,
+		0.934172f, 0.303531f, -0.187593f, 0.000000f, 0.934172f, 0.303531f, -0.187593f, 0.647155f, 0.147020f,
+		0.845991f, 0.389809f, -0.363797f, 0.000000f, 0.845991f, 0.389809f, -0.363797f, 0.554653f, 0.130459f,
+		0.845991f, 0.499718f, -0.185961f, 0.000000f, 0.845991f, 0.499718f, -0.185961f, 0.500000f, 0.327581f,
+		0.978148f, 0.207911f, 0.000000f, 0.000000f, 0.978148f, 0.207911f, 0.000000f, 0.319635f, 0.345280f,
+		0.934172f, 0.303531f, -0.187593f, 0.000000f, 0.934172f, 0.303531f, -0.187593f, 0.647155f, 0.147020f,
+		0.913545f, 0.406737f, 0.000000f, 0.000000f, 0.913545f, 0.406737f, 0.000000f, 0.445347f, 0.258102f,
+		0.983024f, 0.096460f, 0.156077f, 0.000000f, 0.983024f, 0.096460f, 0.156077f, 0.408260f, 0.332044f,
+		0.978148f, 0.207911f, 0.000000f, 0.000000f, 0.978148f, 0.207911f, 0.000000f, 0.319635f, 0.345280f,
+		0.939205f, 0.305166f, 0.157379f, 0.000000f, 0.939205f, 0.305166f, 0.157379f, 0.591739f, 0.332044f,
+		0.643075f, 0.588241f, -0.490334f, 0.000000f, 0.643075f, 0.588241f, -0.490334f, 0.697755f, 0.772187f,
+		0.525731f, 0.723607f, -0.447214f, 0.000000f, 0.525731f, 0.723607f, -0.447214f, 0.788675f, 0.593796f,
+		0.643075f, 0.701637f, -0.306855f, 0.000000f, 0.643075f, 0.701637f, -0.306855f, 0.680365f, 0.345280f,
+		0.757312f, 0.555521f, -0.343331f, 0.000000f, 0.757312f, 0.555521f, -0.343331f, 0.352845f, 0.268343f,
+		0.643075f, 0.701637f, -0.306855f, 0.000000f, 0.643075f, 0.701637f, -0.306855f, 0.680365f, 0.345280f,
+		0.738585f, 0.655845f, -0.156077f, 0.000000f, 0.738585f, 0.655845f, -0.156077f, 0.647155f, 0.268343f,
+		0.845991f, 0.499718f, -0.185961f, 0.000000f, 0.845991f, 0.499718f, -0.185961f, 0.500000f, 0.327581f,
+		0.738585f, 0.655845f, -0.156077f, 0.000000f, 0.738585f, 0.655845f, -0.156077f, 0.647155f, 0.268343f,
+		0.809017f, 0.587785f, 0.000000f, 0.000000f, 0.809017f, 0.587785f, 0.000000f, 0.553923f, 0.743874f,
+		0.913545f, 0.406737f, 0.000000f, 0.000000f, 0.913545f, 0.406737f, 0.000000f, 0.445347f, 0.258102f,
+		0.809017f, 0.587785f, 0.000000f, 0.000000f, 0.809017f, 0.587785f, 0.000000f, 0.553923f, 0.743874f,
+		0.851981f, 0.499768f, 0.156077f, 0.000000f, 0.851981f, 0.499768f, 0.156077f, 0.643075f, 0.762112f,
+		0.939205f, 0.305166f, 0.157379f, 0.000000f, 0.939205f, 0.305166f, 0.157379f, 0.591739f, 0.332044f,
+		0.851981f, 0.499768f, 0.156077f, 0.000000f, 0.851981f, 0.499768f, 0.156077f, 0.643075f, 0.762112f,
+		0.866018f, 0.394782f, 0.306855f, 0.000000f, 0.866018f, 0.394782f, 0.306855f, 0.606016f, 0.668485f,
+		0.932670f, 0.189647f, 0.306855f, 0.000000f, 0.932670f, 0.189647f, 0.306855f, 0.554653f, 0.258102f,
+		0.866018f, 0.394782f, 0.306855f, 0.000000f, 0.866018f, 0.394782f, 0.306855f, 0.606016f, 0.668485f,
+		0.850651f, 0.276393f, 0.447214f, 0.000000f, 0.850651f, 0.276393f, 0.447214f, 0.750000f, 0.581230f,
+		0.757312f, 0.555521f, -0.343331f, 0.000000f, 0.757312f, 0.555521f, -0.343331f, 0.352845f, 0.268343f,
+		0.643075f, 0.588241f, -0.490334f, 0.000000f, 0.643075f, 0.588241f, -0.490334f, 0.697755f, 0.772187f,
+		0.643075f, 0.701637f, -0.306855f, 0.000000f, 0.643075f, 0.701637f, -0.306855f, 0.680365f, 0.345280f,
+		0.845991f, 0.499718f, -0.185961f, 0.000000f, 0.845991f, 0.499718f, -0.185961f, 0.500000f, 0.327581f,
+		0.757312f, 0.555521f, -0.343331f, 0.000000f, 0.757312f, 0.555521f, -0.343331f, 0.352845f, 0.268343f,
+		0.738585f, 0.655845f, -0.156077f, 0.000000f, 0.738585f, 0.655845f, -0.156077f, 0.647155f, 0.268343f,
+		0.913545f, 0.406737f, 0.000000f, 0.000000f, 0.913545f, 0.406737f, 0.000000f, 0.445347f, 0.258102f,
+		0.845991f, 0.499718f, -0.185961f, 0.000000f, 0.845991f, 0.499718f, -0.185961f, 0.500000f, 0.327581f,
+		0.809017f, 0.587785f, 0.000000f, 0.000000f, 0.809017f, 0.587785f, 0.000000f, 0.553923f, 0.743874f,
+		0.913545f, 0.406737f, 0.000000f, 0.000000f, 0.913545f, 0.406737f, 0.000000f, 0.445347f, 0.258102f,
+		0.851981f, 0.499768f, 0.156077f, 0.000000f, 0.851981f, 0.499768f, 0.156077f, 0.643075f, 0.762112f,
+		0.939205f, 0.305166f, 0.157379f, 0.000000f, 0.939205f, 0.305166f, 0.157379f, 0.591739f, 0.332044f,
+		0.932670f, 0.189647f, 0.306855f, 0.000000f, 0.932670f, 0.189647f, 0.306855f, 0.554653f, 0.258102f,
+		0.939205f, 0.305166f, 0.157379f, 0.000000f, 0.939205f, 0.305166f, 0.157379f, 0.591739f, 0.332044f,
+		0.866018f, 0.394782f, 0.306855f, 0.000000f, 0.866018f, 0.394782f, 0.306855f, 0.606016f, 0.668485f,
+		0.525731f, 0.723607f, -0.447214f, 0.000000f, 0.525731f, 0.723607f, -0.447214f, 0.788675f, 0.593796f,
+		0.360730f, 0.793377f, -0.490334f, 0.000000f, 0.360730f, 0.793377f, -0.490334f, 0.345491f, 0.712663f,
+		0.468576f, 0.828418f, -0.306855f, 0.000000f, 0.468576f, 0.828418f, -0.306855f, 0.727648f, 0.772345f,
+		0.360730f, 0.793377f, -0.490334f, 0.000000f, 0.360730f, 0.793377f, -0.490334f, 0.345491f, 0.712663f,
+		0.183479f, 0.836210f, -0.516806f, 0.000000f, 0.183479f, 0.836210f, -0.516806f, 0.447735f, 0.722382f,
+		0.294310f, 0.891911f, -0.343331f, 0.000000f, 0.294310f, 0.891911f, -0.343331f, 0.695347f, 0.683427f,
+		0.468576f, 0.828418f, -0.306855f, 0.000000f, 0.468576f, 0.828418f, -0.306855f, 0.727648f, 0.772345f,
+		0.294310f, 0.891911f, -0.343331f, 0.000000f, 0.294310f, 0.891911f, -0.343331f, 0.695347f, 0.683427f,
+		0.395511f, 0.905103f, -0.156077f, 0.000000f, 0.395511f, 0.905103f, -0.156077f, 0.654508f, 0.590447f,
+		0.360730f, 0.793377f, -0.490334f, 0.000000f, 0.360730f, 0.793377f, -0.490334f, 0.345491f, 0.712663f,
+		0.294310f, 0.891911f, -0.343331f, 0.000000f, 0.294310f, 0.891911f, -0.343331f, 0.695347f, 0.683427f,
+		0.468576f, 0.828418f, -0.306855f, 0.000000f, 0.468576f, 0.828418f, -0.306855f, 0.727648f, 0.772345f,
+		0.183479f, 0.836210f, -0.516806f, 0.000000f, 0.183479f, 0.836210f, -0.516806f, 0.447735f, 0.722382f,
+		0.000000f, 0.850651f, -0.525731f, 0.000000f, 0.000000f, 0.850651f, -0.525731f, 0.393984f, 0.645918f,
+		0.109305f, 0.925043f, -0.363797f, 0.000000f, 0.109305f, 0.925043f, -0.363797f, 0.816078f, 0.772345f,
+		0.294310f, 0.891911f, -0.343331f, 0.000000f, 0.294310f, 0.891911f, -0.343331f, 0.695347f, 0.683427f,
+		0.109305f, 0.925043f, -0.363797f, 0.000000f, 0.109305f, 0.925043f, -0.363797f, 0.816078f, 0.772345f,
+		0.213835f, 0.959006f, -0.185961f, 0.000000f, 0.213835f, 0.959006f, -0.185961f, 0.788675f, 0.684243f,
+		0.395511f, 0.905103f, -0.156077f, 0.000000f, 0.395511f, 0.905103f, -0.156077f, 0.654508f, 0.590447f,
+		0.213835f, 0.959006f, -0.185961f, 0.000000f, 0.213835f, 0.959006f, -0.185961f, 0.788675f, 0.684243f,
+		0.309017f, 0.951056f, 0.000000f, 0.000000f, 0.309017f, 0.951056f, 0.000000f, 0.750000f, 0.590447f,
+		0.183479f, 0.836210f, -0.516806f, 0.000000f, 0.183479f, 0.836210f, -0.516806f, 0.447735f, 0.722382f,
+		0.109305f, 0.925043f, -0.363797f, 0.000000f, 0.109305f, 0.925043f, -0.363797f, 0.816078f, 0.772345f,
+		0.294310f, 0.891911f, -0.343331f, 0.000000f, 0.294310f, 0.891911f, -0.343331f, 0.695347f, 0.683427f,
+		0.294310f, 0.891911f, -0.343331f, 0.000000f, 0.294310f, 0.891911f, -0.343331f, 0.695347f, 0.683427f,
+		0.213835f, 0.959006f, -0.185961f, 0.000000f, 0.213835f, 0.959006f, -0.185961f, 0.788675f, 0.684243f,
+		0.395511f, 0.905103f, -0.156077f, 0.000000f, 0.395511f, 0.905103f, -0.156077f, 0.654508f, 0.590447f,
+		0.000000f, 0.850651f, -0.525731f, 0.000000f, 0.000000f, 0.850651f, -0.525731f, 0.393984f, 0.645918f,
+		-0.183479f, 0.836210f, -0.516806f, 0.000000f, -0.183479f, 0.836210f, -0.516806f, 0.500000f, 0.650438f,
+		-0.109305f, 0.925043f, -0.363797f, 0.000000f, -0.109305f, 0.925043f, -0.363797f, 0.697755f, 0.512408f,
+		0.109305f, 0.925043f, -0.363797f, 0.000000f, 0.109305f, 0.925043f, -0.363797f, 0.816078f, 0.772345f,
+		-0.109305f, 0.925043f, -0.363797f, 0.000000f, -0.109305f, 0.925043f, -0.363797f, 0.697755f, 0.512408f,
+		0.000000f, 0.982247f, -0.187593f, 0.000000f, 0.000000f, 0.982247f, -0.187593f, 0.762112f, 0.225709f,
+		0.213835f, 0.959006f, -0.185961f, 0.000000f, 0.213835f, 0.959006f, -0.185961f, 0.788675f, 0.684243f,
+		0.000000f, 0.982247f, -0.187593f, 0.000000f, 0.000000f, 0.982247f, -0.187593f, 0.762112f, 0.225709f,
+		0.104529f, 0.994522f, 0.000000f, 0.000000f, 0.104529f, 0.994522f, 0.000000f, 0.772345f, 0.157937f,
+		0.309017f, 0.951056f, 0.000000f, 0.000000f, 0.309017f, 0.951056f, 0.000000f, 0.750000f, 0.590447f,
+		0.104529f, 0.994522f, 0.000000f, 0.000000f, 0.104529f, 0.994522f, 0.000000f, 0.772345f, 0.157937f,
+		0.212032f, 0.964719f, 0.156077f, 0.000000f, 0.212032f, 0.964719f, 0.156077f, 0.683427f, 0.174918f,
+		0.109305f, 0.925043f, -0.363797f, 0.000000f, 0.109305f, 0.925043f, -0.363797f, 0.816078f, 0.772345f,
+		0.000000f, 0.850651f, -0.525731f, 0.000000f, 0.000000f, 0.850651f, -0.525731f, 0.393984f, 0.645918f,
+		-0.109305f, 0.925043f, -0.363797f, 0.000000f, -0.109305f, 0.925043f, -0.363797f, 0.697755f, 0.512408f,
+		0.109305f, 0.925043f, -0.363797f, 0.000000f, 0.109305f, 0.925043f, -0.363797f, 0.816078f, 0.772345f,
+		0.000000f, 0.982247f, -0.187593f, 0.000000f, 0.000000f, 0.982247f, -0.187593f, 0.762112f, 0.225709f,
+		0.213835f, 0.959006f, -0.185961f, 0.000000f, 0.213835f, 0.959006f, -0.185961f, 0.788675f, 0.684243f,
+		0.309017f, 0.951056f, 0.000000f, 0.000000f, 0.309017f, 0.951056f, 0.000000f, 0.750000f, 0.590447f,
+		0.213835f, 0.959006f, -0.185961f, 0.000000f, 0.213835f, 0.959006f, -0.185961f, 0.788675f, 0.684243f,
+		0.104529f, 0.994522f, 0.000000f, 0.000000f, 0.104529f, 0.994522f, 0.000000f, 0.772345f, 0.157937f,
+		-0.183479f, 0.836210f, -0.516806f, 0.000000f, -0.183479f, 0.836210f, -0.516806f, 0.500000f, 0.650438f,
+		-0.360730f, 0.793377f, -0.490334f, 0.000000f, -0.360730f, 0.793377f, -0.490334f, 0.790230f, 0.912551f,
+		-0.294309f, 0.891911f, -0.343331f, 0.000000f, -0.294309f, 0.891911f, -0.343331f, 0.868343f, 0.683427f,
+		-0.109305f, 0.925043f, -0.363797f, 0.000000f, -0.109305f, 0.925043f, -0.363797f, 0.697755f, 0.512408f,
+		-0.294309f, 0.891911f, -0.343331f, 0.000000f, -0.294309f, 0.891911f, -0.343331f, 0.868343f, 0.683427f,
+		-0.213834f, 0.959006f, -0.185961f, 0.000000f, -0.213834f, 0.959006f, -0.185961f, 0.834566f, 0.590447f,
+		0.000000f, 0.982247f, -0.187593f, 0.000000f, 0.000000f, 0.982247f, -0.187593f, 0.762112f, 0.225709f,
+		-0.213834f, 0.959006f, -0.185961f, 0.000000f, -0.213834f, 0.959006f, -0.185961f, 0.834566f, 0.590447f,
+		-0.104529f, 0.994522f, 0.000000f, 0.000000f, -0.104529f, 0.994522f, 0.000000f, 0.790230f, 0.511757f,
+		0.104529f, 0.994522f, 0.000000f, 0.000000f, 0.104529f, 0.994522f, 0.000000f, 0.772345f, 0.157937f,
+		-0.104529f, 0.994522f, 0.000000f, 0.000000f, -0.104529f, 0.994522f, 0.000000f, 0.790230f, 0.511757f,
+		0.000000f, 0.987538f, 0.157379f, 0.000000f, 0.000000f, 0.987538f, 0.157379f, 0.734288f, 0.437019f,
+		0.212032f, 0.964719f, 0.156077f, 0.000000f, 0.212032f, 0.964719f, 0.156077f, 0.683427f, 0.174918f,
+		0.000000f, 0.987538f, 0.157379f, 0.000000f, 0.000000f, 0.987538f, 0.157379f, 0.734288f, 0.437019f,
+		0.107846f, 0.945626f, 0.306855f, 0.000000f, 0.107846f, 0.945626f, 0.306855f, 0.743874f, 0.302609f,
+		-0.109305f, 0.925043f, -0.363797f, 0.000000f, -0.109305f, 0.925043f, -0.363797f, 0.697755f, 0.512408f,
+		-0.183479f, 0.836210f, -0.516806f, 0.000000f, -0.183479f, 0.836210f, -0.516806f, 0.500000f, 0.650438f,
+		-0.294309f, 0.891911f, -0.343331f, 0.000000f, -0.294309f, 0.891911f, -0.343331f, 0.868343f, 0.683427f,
+		0.000000f, 0.982247f, -0.187593f, 0.000000f, 0.000000f, 0.982247f, -0.187593f, 0.762112f, 0.225709f,
+		-0.109305f, 0.925043f, -0.363797f, 0.000000f, -0.109305f, 0.925043f, -0.363797f, 0.697755f, 0.512408f,
+		-0.213834f, 0.959006f, -0.185961f, 0.000000f, -0.213834f, 0.959006f, -0.185961f, 0.834566f, 0.590447f,
+		0.104529f, 0.994522f, 0.000000f, 0.000000f, 0.104529f, 0.994522f, 0.000000f, 0.772345f, 0.157937f,
+		0.000000f, 0.982247f, -0.187593f, 0.000000f, 0.000000f, 0.982247f, -0.187593f, 0.762112f, 0.225709f,
+		-0.104529f, 0.994522f, 0.000000f, 0.000000f, -0.104529f, 0.994522f, 0.000000f, 0.790230f, 0.511757f,
+		0.212032f, 0.964719f, 0.156077f, 0.000000f, 0.212032f, 0.964719f, 0.156077f, 0.683427f, 0.174918f,
+		0.104529f, 0.994522f, 0.000000f, 0.000000f, 0.104529f, 0.994522f, 0.000000f, 0.772345f, 0.157937f,
+		0.000000f, 0.987538f, 0.157379f, 0.000000f, 0.000000f, 0.987538f, 0.157379f, 0.734288f, 0.437019f,
+		-0.360730f, 0.793377f, -0.490334f, 0.000000f, -0.360730f, 0.793377f, -0.490334f, 0.790230f, 0.912551f,
+		-0.525731f, 0.723607f, -0.447214f, 0.000000f, -0.525731f, 0.723607f, -0.447214f, 0.446077f, 0.574219f,
+		-0.468576f, 0.828418f, -0.306855f, 0.000000f, -0.468576f, 0.828418f, -0.306855f, 0.668485f, 0.250116f,
+		-0.294309f, 0.891911f, -0.343331f, 0.000000f, -0.294309f, 0.891911f, -0.343331f, 0.868343f, 0.683427f,
+		-0.468576f, 0.828418f, -0.306855f, 0.000000f, -0.468576f, 0.828418f, -0.306855f, 0.668485f, 0.250116f,
+		-0.395510f, 0.905103f, -0.156077f, 0.000000f, -0.395510f, 0.905103f, -0.156077f, 0.590447f, 0.206107f,
+		-0.213834f, 0.959006f, -0.185961f, 0.000000f, -0.213834f, 0.959006f, -0.185961f, 0.834566f, 0.590447f,
+		-0.395510f, 0.905103f, -0.156077f, 0.000000f, -0.395510f, 0.905103f, -0.156077f, 0.590447f, 0.206107f,
+		-0.309017f, 0.951057f, 0.000000f, 0.000000f, -0.309017f, 0.951057f, 0.000000f, 0.590447f, 0.128428f,
+		-0.104529f, 0.994522f, 0.000000f, 0.000000f, -0.104529f, 0.994522f, 0.000000f, 0.790230f, 0.511757f,
+		-0.309017f, 0.951057f, 0.000000f, 0.000000f, -0.309017f, 0.951057f, 0.000000f, 0.590447f, 0.128428f,
+		-0.212031f, 0.964719f, 0.156077f, 0.000000f, -0.212031f, 0.964719f, 0.156077f, 0.512408f, 0.172078f,
+		0.000000f, 0.987538f, 0.157379f, 0.000000f, 0.000000f, 0.987538f, 0.157379f, 0.734288f, 0.437019f,
+		-0.212031f, 0.964719f, 0.156077f, 0.000000f, -0.212031f, 0.964719f, 0.156077f, 0.512408f, 0.172078f,
+		-0.107846f, 0.945626f, 0.306855f, 0.000000f, -0.107846f, 0.945626f, 0.306855f, 0.869292f, 0.512408f,
+		0.107846f, 0.945626f, 0.306855f, 0.000000f, 0.107846f, 0.945626f, 0.306855f, 0.743874f, 0.302609f,
+		-0.107846f, 0.945626f, 0.306855f, 0.000000f, -0.107846f, 0.945626f, 0.306855f, 0.869292f, 0.512408f,
+		0.000000f, 0.894427f, 0.447214f, 0.000000f, 0.000000f, 0.894427f, 0.447214f, 0.268343f, 0.250971f,
+		-0.294309f, 0.891911f, -0.343331f, 0.000000f, -0.294309f, 0.891911f, -0.343331f, 0.868343f, 0.683427f,
+		-0.360730f, 0.793377f, -0.490334f, 0.000000f, -0.360730f, 0.793377f, -0.490334f, 0.790230f, 0.912551f,
+		-0.468576f, 0.828418f, -0.306855f, 0.000000f, -0.468576f, 0.828418f, -0.306855f, 0.668485f, 0.250116f,
+		-0.213834f, 0.959006f, -0.185961f, 0.000000f, -0.213834f, 0.959006f, -0.185961f, 0.834566f, 0.590447f,
+		-0.294309f, 0.891911f, -0.343331f, 0.000000f, -0.294309f, 0.891911f, -0.343331f, 0.868343f, 0.683427f,
+		-0.395510f, 0.905103f, -0.156077f, 0.000000f, -0.395510f, 0.905103f, -0.156077f, 0.590447f, 0.206107f,
+		-0.213834f, 0.959006f, -0.185961f, 0.000000f, -0.213834f, 0.959006f, -0.185961f, 0.834566f, 0.590447f,
+		-0.309017f, 0.951057f, 0.000000f, 0.000000f, -0.309017f, 0.951057f, 0.000000f, 0.590447f, 0.128428f,
+		-0.104529f, 0.994522f, 0.000000f, 0.000000f, -0.104529f, 0.994522f, 0.000000f, 0.790230f, 0.511757f,
+		-0.104529f, 0.994522f, 0.000000f, 0.000000f, -0.104529f, 0.994522f, 0.000000f, 0.790230f, 0.511757f,
+		-0.212031f, 0.964719f, 0.156077f, 0.000000f, -0.212031f, 0.964719f, 0.156077f, 0.512408f, 0.172078f,
+		0.000000f, 0.987538f, 0.157379f, 0.000000f, 0.000000f, 0.987538f, 0.157379f, 0.734288f, 0.437019f,
+		0.107846f, 0.945626f, 0.306855f, 0.000000f, 0.107846f, 0.945626f, 0.306855f, 0.743874f, 0.302609f,
+		0.000000f, 0.987538f, 0.157379f, 0.000000f, 0.000000f, 0.987538f, 0.157379f, 0.734288f, 0.437019f,
+		-0.107846f, 0.945626f, 0.306855f, 0.000000f, -0.107846f, 0.945626f, 0.306855f, 0.869292f, 0.512408f,
+		-0.525731f, 0.723607f, -0.447214f, 0.000000f, -0.525731f, 0.723607f, -0.447214f, 0.446077f, 0.574219f,
+		-0.643075f, 0.588241f, -0.490334f, 0.000000f, -0.643075f, 0.588241f, -0.490334f, 0.680365f, 0.835614f,
+		-0.643075f, 0.701637f, -0.306855f, 0.000000f, -0.643075f, 0.701637f, -0.306855f, 0.821537f, 0.437019f,
+		-0.643075f, 0.588241f, -0.490334f, 0.000000f, -0.643075f, 0.588241f, -0.490334f, 0.680365f, 0.835614f,
+		-0.738585f, 0.432902f, -0.516806f, 0.000000f, -0.738585f, 0.432902f, -0.516806f, 0.647155f, 0.912551f,
+		-0.757311f, 0.555521f, -0.343331f, 0.000000f, -0.757311f, 0.555521f, -0.343331f, 0.743874f, 0.405176f,
+		-0.643075f, 0.701637f, -0.306855f, 0.000000f, -0.643075f, 0.701637f, -0.306855f, 0.821537f, 0.437019f,
+		-0.757311f, 0.555521f, -0.343331f, 0.000000f, -0.757311f, 0.555521f, -0.343331f, 0.743874f, 0.405176f,
+		-0.738585f, 0.655845f, -0.156077f, 0.000000f, -0.738585f, 0.655845f, -0.156077f, 0.762112f, 0.497855f,
+		-0.643075f, 0.588241f, -0.490334f, 0.000000f, -0.643075f, 0.588241f, -0.490334f, 0.680365f, 0.835614f,
+		-0.757311f, 0.555521f, -0.343331f, 0.000000f, -0.757311f, 0.555521f, -0.343331f, 0.743874f, 0.405176f,
+		-0.643075f, 0.701637f, -0.306855f, 0.000000f, -0.643075f, 0.701637f, -0.306855f, 0.821537f, 0.437019f,
+		-0.738585f, 0.432902f, -0.516806f, 0.000000f, -0.738585f, 0.432902f, -0.516806f, 0.647155f, 0.912551f,
+		-0.809017f, 0.262866f, -0.525731f, 0.000000f, -0.809017f, 0.262866f, -0.525731f, 0.591739f, 0.848850f,
+		-0.845991f, 0.389810f, -0.363797f, 0.000000f, -0.845991f, 0.389810f, -0.363797f, 0.668485f, 0.451770f,
+		-0.757311f, 0.555521f, -0.343331f, 0.000000f, -0.757311f, 0.555521f, -0.343331f, 0.743874f, 0.405176f,
+		-0.845991f, 0.389810f, -0.363797f, 0.000000f, -0.845991f, 0.389810f, -0.363797f, 0.668485f, 0.451770f,
+		-0.845991f, 0.499718f, -0.185961f, 0.000000f, -0.845991f, 0.499718f, -0.185961f, 0.772345f, 0.590949f,
+		-0.738585f, 0.655845f, -0.156077f, 0.000000f, -0.738585f, 0.655845f, -0.156077f, 0.762112f, 0.497855f,
+		-0.845991f, 0.499718f, -0.185961f, 0.000000f, -0.845991f, 0.499718f, -0.185961f, 0.772345f, 0.590949f,
+		-0.809017f, 0.587785f, 0.000000f, 0.000000f, -0.809017f, 0.587785f, 0.000000f, 0.683427f, 0.546490f,
+		-0.738585f, 0.432902f, -0.516806f, 0.000000f, -0.738585f, 0.432902f, -0.516806f, 0.647155f, 0.912551f,
+		-0.845991f, 0.389810f, -0.363797f, 0.000000f, -0.845991f, 0.389810f, -0.363797f, 0.668485f, 0.451770f,
+		-0.757311f, 0.555521f, -0.343331f, 0.000000f, -0.757311f, 0.555521f, -0.343331f, 0.743874f, 0.405176f,
+		-0.757311f, 0.555521f, -0.343331f, 0.000000f, -0.757311f, 0.555521f, -0.343331f, 0.743874f, 0.405176f,
+		-0.845991f, 0.499718f, -0.185961f, 0.000000f, -0.845991f, 0.499718f, -0.185961f, 0.772345f, 0.590949f,
+		-0.738585f, 0.655845f, -0.156077f, 0.000000f, -0.738585f, 0.655845f, -0.156077f, 0.762112f, 0.497855f,
+		-0.809017f, 0.262866f, -0.525731f, 0.000000f, -0.809017f, 0.262866f, -0.525731f, 0.591739f, 0.848850f,
+		-0.851981f, 0.083904f, -0.516806f, 0.000000f, -0.851981f, 0.083904f, -0.516806f, 0.554653f, 0.922791f,
+		-0.913545f, 0.181899f, -0.363797f, 0.000000f, -0.913545f, 0.181899f, -0.363797f, 0.590447f, 0.500000f,
+		-0.845991f, 0.389810f, -0.363797f, 0.000000f, -0.845991f, 0.389810f, -0.363797f, 0.668485f, 0.451770f,
+		-0.913545f, 0.181899f, -0.363797f, 0.000000f, -0.913545f, 0.181899f, -0.363797f, 0.590447f, 0.500000f,
+		-0.934172f, 0.303531f, -0.187593f, 0.000000f, -0.934172f, 0.303531f, -0.187593f, 0.772345f, 0.694905f,
+		-0.845991f, 0.499718f, -0.185961f, 0.000000f, -0.845991f, 0.499718f, -0.185961f, 0.772345f, 0.590949f,
+		-0.934172f, 0.303531f, -0.187593f, 0.000000f, -0.934172f, 0.303531f, -0.187593f, 0.772345f, 0.694905f,
+		-0.913545f, 0.406737f, 0.000000f, 0.000000f, -0.913545f, 0.406737f, 0.000000f, 0.684243f, 0.651765f,
+		-0.809017f, 0.587785f, 0.000000f, 0.000000f, -0.809017f, 0.587785f, 0.000000f, 0.683427f, 0.546490f,
+		-0.913545f, 0.406737f, 0.000000f, 0.000000f, -0.913545f, 0.406737f, 0.000000f, 0.684243f, 0.651765f,
+		-0.851981f, 0.499769f, 0.156077f, 0.000000f, -0.851981f, 0.499769f, 0.156077f, 0.590447f, 0.603956f,
+		-0.809017f, 0.262866f, -0.525731f, 0.000000f, -0.809017f, 0.262866f, -0.525731f, 0.591739f, 0.848850f,
+		-0.913545f, 0.181899f, -0.363797f, 0.000000f, -0.913545f, 0.181899f, -0.363797f, 0.590447f, 0.500000f,
+		-0.845991f, 0.389810f, -0.363797f, 0.000000f, -0.845991f, 0.389810f, -0.363797f, 0.668485f, 0.451770f,
+		-0.845991f, 0.389810f, -0.363797f, 0.000000f, -0.845991f, 0.389810f, -0.363797f, 0.668485f, 0.451770f,
+		-0.934172f, 0.303531f, -0.187593f, 0.000000f, -0.934172f, 0.303531f, -0.187593f, 0.772345f, 0.694905f,
+		-0.845991f, 0.499718f, -0.185961f, 0.000000f, -0.845991f, 0.499718f, -0.185961f, 0.772345f, 0.590949f,
+		-0.845991f, 0.499718f, -0.185961f, 0.000000f, -0.845991f, 0.499718f, -0.185961f, 0.772345f, 0.590949f,
+		-0.913545f, 0.406737f, 0.000000f, 0.000000f, -0.913545f, 0.406737f, 0.000000f, 0.684243f, 0.651765f,
+		-0.809017f, 0.587785f, 0.000000f, 0.000000f, -0.809017f, 0.587785f, 0.000000f, 0.683427f, 0.546490f,
+		-0.851981f, 0.083904f, -0.516806f, 0.000000f, -0.851981f, 0.083904f, -0.516806f, 0.554653f, 0.922791f,
+		-0.866018f, -0.097907f, -0.490334f, 0.000000f, -0.866018f, -0.097907f, -0.490334f, 0.500000f, 0.853312f,
+		-0.939205f, -0.004289f, -0.343331f, 0.000000f, -0.939205f, -0.004289f, -0.343331f, 0.512408f, 0.548230f,
+		-0.913545f, 0.181899f, -0.363797f, 0.000000f, -0.913545f, 0.181899f, -0.363797f, 0.590447f, 0.500000f,
+		-0.939205f, -0.004289f, -0.343331f, 0.000000f, -0.939205f, -0.004289f, -0.343331f, 0.512408f, 0.548230f,
+		-0.978148f, 0.092981f, -0.185961f, 0.000000f, -0.978148f, 0.092981f, -0.185961f, 0.762112f, 0.777761f,
+		-0.934172f, 0.303531f, -0.187593f, 0.000000f, -0.934172f, 0.303531f, -0.187593f, 0.772345f, 0.694905f,
+		-0.978148f, 0.092981f, -0.185961f, 0.000000f, -0.978148f, 0.092981f, -0.185961f, 0.762112f, 0.777761f,
+		-0.978148f, 0.207911f, 0.000000f, 0.000000f, -0.978148f, 0.207911f, 0.000000f, 0.683427f, 0.749859f,
+		-0.913545f, 0.406737f, 0.000000f, 0.000000f, -0.913545f, 0.406737f, 0.000000f, 0.684243f, 0.651765f,
+		-0.978148f, 0.207911f, 0.000000f, 0.000000f, -0.978148f, 0.207911f, 0.000000f, 0.683427f, 0.749859f,
+		-0.939205f, 0.305166f, 0.157379f, 0.000000f, -0.939205f, 0.305166f, 0.157379f, 0.590447f, 0.703368f,
+		-0.851981f, 0.499769f, 0.156077f, 0.000000f, -0.851981f, 0.499769f, 0.156077f, 0.590447f, 0.603956f,
+		-0.939205f, 0.305166f, 0.157379f, 0.000000f, -0.939205f, 0.305166f, 0.157379f, 0.590447f, 0.703368f,
+		-0.866018f, 0.394783f, 0.306855f, 0.000000f, -0.866018f, 0.394783f, 0.306855f, 0.511757f, 0.652583f,
+		-0.913545f, 0.181899f, -0.363797f, 0.000000f, -0.913545f, 0.181899f, -0.363797f, 0.590447f, 0.500000f,
+		-0.851981f, 0.083904f, -0.516806f, 0.000000f, -0.851981f, 0.083904f, -0.516806f, 0.554653f, 0.922791f,
+		-0.939205f, -0.004289f, -0.343331f, 0.000000f, -0.939205f, -0.004289f, -0.343331f, 0.512408f, 0.548230f,
+		-0.934172f, 0.303531f, -0.187593f, 0.000000f, -0.934172f, 0.303531f, -0.187593f, 0.772345f, 0.694905f,
+		-0.913545f, 0.181899f, -0.363797f, 0.000000f, -0.913545f, 0.181899f, -0.363797f, 0.590447f, 0.500000f,
+		-0.978148f, 0.092981f, -0.185961f, 0.000000f, -0.978148f, 0.092981f, -0.185961f, 0.762112f, 0.777761f,
+		-0.934172f, 0.303531f, -0.187593f, 0.000000f, -0.934172f, 0.303531f, -0.187593f, 0.772345f, 0.694905f,
+		-0.978148f, 0.207911f, 0.000000f, 0.000000f, -0.978148f, 0.207911f, 0.000000f, 0.683427f, 0.749859f,
+		-0.913545f, 0.406737f, 0.000000f, 0.000000f, -0.913545f, 0.406737f, 0.000000f, 0.684243f, 0.651765f,
+		-0.851981f, 0.499769f, 0.156077f, 0.000000f, -0.851981f, 0.499769f, 0.156077f, 0.590447f, 0.603956f,
+		-0.913545f, 0.406737f, 0.000000f, 0.000000f, -0.913545f, 0.406737f, 0.000000f, 0.684243f, 0.651765f,
+		-0.939205f, 0.305166f, 0.157379f, 0.000000f, -0.939205f, 0.305166f, 0.157379f, 0.590447f, 0.703368f,
+		-0.866018f, -0.097907f, -0.490334f, 0.000000f, -0.866018f, -0.097907f, -0.490334f, 0.500000f, 0.853312f,
+		-0.850651f, -0.276393f, -0.447214f, 0.000000f, -0.850651f, -0.276393f, -0.447214f, 0.445347f, 0.922791f,
+		-0.932670f, -0.189647f, -0.306855f, 0.000000f, -0.932670f, -0.189647f, -0.306855f, 0.437019f, 0.594823f,
+		-0.939205f, -0.004289f, -0.343331f, 0.000000f, -0.939205f, -0.004289f, -0.343331f, 0.512408f, 0.548230f,
+		-0.932670f, -0.189647f, -0.306855f, 0.000000f, -0.932670f, -0.189647f, -0.306855f, 0.437019f, 0.594823f,
+		-0.983024f, -0.096460f, -0.156077f, 0.000000f, -0.983024f, -0.096460f, -0.156077f, 0.821537f, 0.743874f,
+		-0.978148f, 0.092981f, -0.185961f, 0.000000f, -0.978148f, 0.092981f, -0.185961f, 0.762112f, 0.777761f,
+		-0.983024f, -0.096460f, -0.156077f, 0.000000f, -0.983024f, -0.096460f, -0.156077f, 0.821537f, 0.743874f,
+		-1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.743874f, 0.850819f,
+		-0.978148f, 0.207911f, 0.000000f, 0.000000f, -0.978148f, 0.207911f, 0.000000f, 0.683427f, 0.749859f,
+		-1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.743874f, 0.850819f,
+		-0.983024f, 0.096461f, 0.156077f, 0.000000f, -0.983024f, 0.096461f, 0.156077f, 0.668485f, 0.827922f,
+		-0.939205f, 0.305166f, 0.157379f, 0.000000f, -0.939205f, 0.305166f, 0.157379f, 0.590447f, 0.703368f,
+		-0.983024f, 0.096461f, 0.156077f, 0.000000f, -0.983024f, 0.096461f, 0.156077f, 0.668485f, 0.827922f,
+		-0.932670f, 0.189647f, 0.306855f, 0.000000f, -0.932670f, 0.189647f, 0.306855f, 0.590447f, 0.793893f,
+		-0.866018f, 0.394783f, 0.306855f, 0.000000f, -0.866018f, 0.394783f, 0.306855f, 0.511757f, 0.652583f,
+		-0.932670f, 0.189647f, 0.306855f, 0.000000f, -0.932670f, 0.189647f, 0.306855f, 0.590447f, 0.793893f,
+		-0.850651f, 0.276393f, 0.447214f, 0.000000f, -0.850651f, 0.276393f, 0.447214f, 0.588426f, 0.872062f,
+		-0.939205f, -0.004289f, -0.343331f, 0.000000f, -0.939205f, -0.004289f, -0.343331f, 0.512408f, 0.548230f,
+		-0.866018f, -0.097907f, -0.490334f, 0.000000f, -0.866018f, -0.097907f, -0.490334f, 0.500000f, 0.853312f,
+		-0.932670f, -0.189647f, -0.306855f, 0.000000f, -0.932670f, -0.189647f, -0.306855f, 0.437019f, 0.594823f,
+		-0.978148f, 0.092981f, -0.185961f, 0.000000f, -0.978148f, 0.092981f, -0.185961f, 0.762112f, 0.777761f,
+		-0.939205f, -0.004289f, -0.343331f, 0.000000f, -0.939205f, -0.004289f, -0.343331f, 0.512408f, 0.548230f,
+		-0.983024f, -0.096460f, -0.156077f, 0.000000f, -0.983024f, -0.096460f, -0.156077f, 0.821537f, 0.743874f,
+		-0.978148f, 0.092981f, -0.185961f, 0.000000f, -0.978148f, 0.092981f, -0.185961f, 0.762112f, 0.777761f,
+		-1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.743874f, 0.850819f,
+		-0.978148f, 0.207911f, 0.000000f, 0.000000f, -0.978148f, 0.207911f, 0.000000f, 0.683427f, 0.749859f,
+		-0.978148f, 0.207911f, 0.000000f, 0.000000f, -0.978148f, 0.207911f, 0.000000f, 0.683427f, 0.749859f,
+		-0.983024f, 0.096461f, 0.156077f, 0.000000f, -0.983024f, 0.096461f, 0.156077f, 0.668485f, 0.827922f,
+		-0.939205f, 0.305166f, 0.157379f, 0.000000f, -0.939205f, 0.305166f, 0.157379f, 0.590447f, 0.703368f,
+		-0.939205f, 0.305166f, 0.157379f, 0.000000f, -0.939205f, 0.305166f, 0.157379f, 0.590447f, 0.703368f,
+		-0.932670f, 0.189647f, 0.306855f, 0.000000f, -0.932670f, 0.189647f, 0.306855f, 0.590447f, 0.793893f,
+		-0.866018f, 0.394783f, 0.306855f, 0.000000f, -0.866018f, 0.394783f, 0.306855f, 0.511757f, 0.652583f,
+		-0.850651f, -0.276393f, -0.447214f, 0.000000f, -0.850651f, -0.276393f, -0.447214f, 0.445347f, 0.922791f,
+		-0.758172f, -0.429824f, -0.490334f, 0.000000f, -0.758172f, -0.429824f, -0.490334f, 0.178463f, 0.835614f,
+		-0.866018f, -0.394782f, -0.306855f, 0.000000f, -0.866018f, -0.394782f, -0.306855f, 0.512408f, 0.749884f,
+		-0.758172f, -0.429824f, -0.490334f, 0.000000f, -0.758172f, -0.429824f, -0.490334f, 0.178463f, 0.835614f,
+		-0.639949f, -0.568662f, -0.516806f, 0.000000f, -0.639949f, -0.568662f, -0.516806f, 0.118823f, 0.469124f,
+		-0.762354f, -0.548581f, -0.343331f, 0.000000f, -0.762354f, -0.548581f, -0.343331f, 0.437019f, 0.697391f,
+		-0.866018f, -0.394782f, -0.306855f, 0.000000f, -0.866018f, -0.394782f, -0.306855f, 0.512408f, 0.749884f,
+		-0.762354f, -0.548581f, -0.343331f, 0.000000f, -0.762354f, -0.548581f, -0.343331f, 0.437019f, 0.697391f,
+		-0.851981f, -0.499768f, -0.156077f, 0.000000f, -0.851981f, -0.499768f, -0.156077f, 0.734288f, 0.743874f,
+		-0.758172f, -0.429824f, -0.490334f, 0.000000f, -0.758172f, -0.429824f, -0.490334f, 0.178463f, 0.835614f,
+		-0.762354f, -0.548581f, -0.343331f, 0.000000f, -0.762354f, -0.548581f, -0.343331f, 0.437019f, 0.697391f,
+		-0.866018f, -0.394782f, -0.306855f, 0.000000f, -0.866018f, -0.394782f, -0.306855f, 0.512408f, 0.749884f,
+		-0.639949f, -0.568662f, -0.516806f, 0.000000f, -0.639949f, -0.568662f, -0.516806f, 0.118823f, 0.469124f,
+		-0.500000f, -0.688191f, -0.525731f, 0.000000f, -0.500000f, -0.688191f, -0.525731f, 0.209770f, 0.749029f,
+		-0.632156f, -0.684127f, -0.363797f, 0.000000f, -0.632156f, -0.684127f, -0.363797f, 0.647155f, 0.762112f,
+		-0.762354f, -0.548581f, -0.343331f, 0.000000f, -0.762354f, -0.548581f, -0.343331f, 0.437019f, 0.697391f,
+		-0.632156f, -0.684127f, -0.363797f, 0.000000f, -0.632156f, -0.684127f, -0.363797f, 0.647155f, 0.762112f,
+		-0.736686f, -0.650164f, -0.185961f, 0.000000f, -0.736686f, -0.650164f, -0.185961f, 0.697756f, 0.668485f,
+		-0.851981f, -0.499768f, -0.156077f, 0.000000f, -0.851981f, -0.499768f, -0.156077f, 0.734288f, 0.743874f,
+		-0.736686f, -0.650164f, -0.185961f, 0.000000f, -0.736686f, -0.650164f, -0.185961f, 0.697756f, 0.668485f,
+		-0.809017f, -0.587785f, 0.000000f, 0.000000f, -0.809017f, -0.587785f, 0.000000f, 0.554653f, 0.772345f,
+		-0.639949f, -0.568662f, -0.516806f, 0.000000f, -0.639949f, -0.568662f, -0.516806f, 0.118823f, 0.469124f,
+		-0.632156f, -0.684127f, -0.363797f, 0.000000f, -0.632156f, -0.684127f, -0.363797f, 0.647155f, 0.762112f,
+		-0.762354f, -0.548581f, -0.343331f, 0.000000f, -0.762354f, -0.548581f, -0.343331f, 0.437019f, 0.697391f,
+		-0.762354f, -0.548581f, -0.343331f, 0.000000f, -0.762354f, -0.548581f, -0.343331f, 0.437019f, 0.697391f,
+		-0.736686f, -0.650164f, -0.185961f, 0.000000f, -0.736686f, -0.650164f, -0.185961f, 0.697756f, 0.668485f,
+		-0.851981f, -0.499768f, -0.156077f, 0.000000f, -0.851981f, -0.499768f, -0.156077f, 0.734288f, 0.743874f,
+		-0.500000f, -0.688191f, -0.525731f, 0.000000f, -0.500000f, -0.688191f, -0.525731f, 0.209770f, 0.749029f,
+		-0.343074f, -0.784354f, -0.516806f, 0.000000f, -0.343074f, -0.784354f, -0.516806f, 0.165435f, 0.666172f,
+		-0.455297f, -0.812623f, -0.363797f, 0.000000f, -0.455297f, -0.812623f, -0.363797f, 0.606918f, 0.683427f,
+		-0.632156f, -0.684127f, -0.363797f, 0.000000f, -0.632156f, -0.684127f, -0.363797f, 0.647155f, 0.762112f,
+		-0.455297f, -0.812623f, -0.363797f, 0.000000f, -0.455297f, -0.812623f, -0.363797f, 0.606918f, 0.683427f,
+		-0.577350f, -0.794654f, -0.187593f, 0.000000f, -0.577350f, -0.794654f, -0.187593f, 0.445347f, 0.772345f,
+		-0.736686f, -0.650164f, -0.185961f, 0.000000f, -0.736686f, -0.650164f, -0.185961f, 0.697756f, 0.668485f,
+		-0.577350f, -0.794654f, -0.187593f, 0.000000f, -0.577350f, -0.794654f, -0.187593f, 0.445347f, 0.772345f,
+		-0.669131f, -0.743144f, 0.000000f, 0.000000f, -0.669131f, -0.743144f, 0.000000f, 0.500000f, 0.684243f,
+		-0.809017f, -0.587785f, 0.000000f, 0.000000f, -0.809017f, -0.587785f, 0.000000f, 0.554653f, 0.772345f,
+		-0.669131f, -0.743144f, 0.000000f, 0.000000f, -0.669131f, -0.743144f, 0.000000f, 0.500000f, 0.684243f,
+		-0.738585f, -0.655845f, 0.156077f, 0.000000f, -0.738585f, -0.655845f, 0.156077f, 0.552265f, 0.590447f,
+		-0.500000f, -0.688191f, -0.525731f, 0.000000f, -0.500000f, -0.688191f, -0.525731f, 0.209770f, 0.749029f,
+		-0.455297f, -0.812623f, -0.363797f, 0.000000f, -0.455297f, -0.812623f, -0.363797f, 0.606918f, 0.683427f,
+		-0.632156f, -0.684127f, -0.363797f, 0.000000f, -0.632156f, -0.684127f, -0.363797f, 0.647155f, 0.762112f,
+		-0.632156f, -0.684127f, -0.363797f, 0.000000f, -0.632156f, -0.684127f, -0.363797f, 0.647155f, 0.762112f,
+		-0.577350f, -0.794654f, -0.187593f, 0.000000f, -0.577350f, -0.794654f, -0.187593f, 0.445347f, 0.772345f,
+		-0.736686f, -0.650164f, -0.185961f, 0.000000f, -0.736686f, -0.650164f, -0.185961f, 0.697756f, 0.668485f,
+		-0.736686f, -0.650164f, -0.185961f, 0.000000f, -0.736686f, -0.650164f, -0.185961f, 0.697756f, 0.668485f,
+		-0.669131f, -0.743144f, 0.000000f, 0.000000f, -0.669131f, -0.743144f, 0.000000f, 0.500000f, 0.684243f,
+		-0.809017f, -0.587785f, 0.000000f, 0.000000f, -0.809017f, -0.587785f, 0.000000f, 0.554653f, 0.772345f,
+		-0.343074f, -0.784354f, -0.516806f, 0.000000f, -0.343074f, -0.784354f, -0.516806f, 0.165435f, 0.666172f,
+		-0.174499f, -0.853887f, -0.490334f, 0.000000f, -0.174499f, -0.853887f, -0.490334f, 0.131658f, 0.562217f,
+		-0.286151f, -0.894562f, -0.343331f, 0.000000f, -0.286151f, -0.894562f, -0.343331f, 0.606016f, 0.512408f,
+		-0.455297f, -0.812623f, -0.363797f, 0.000000f, -0.455297f, -0.812623f, -0.363797f, 0.606918f, 0.683427f,
+		-0.286151f, -0.894562f, -0.343331f, 0.000000f, -0.286151f, -0.894562f, -0.343331f, 0.606016f, 0.512408f,
+		-0.390694f, -0.901541f, -0.185961f, 0.000000f, -0.390694f, -0.901541f, -0.185961f, 0.352845f, 0.762112f,
+		-0.577350f, -0.794654f, -0.187593f, 0.000000f, -0.577350f, -0.794654f, -0.187593f, 0.445347f, 0.772345f,
+		-0.390694f, -0.901541f, -0.185961f, 0.000000f, -0.390694f, -0.901541f, -0.185961f, 0.352845f, 0.762112f,
+		-0.499999f, -0.866026f, 0.000000f, 0.000000f, -0.499999f, -0.866026f, 0.000000f, 0.393083f, 0.683427f,
+		-0.669131f, -0.743144f, 0.000000f, 0.000000f, -0.669131f, -0.743144f, 0.000000f, 0.500000f, 0.684243f,
+		-0.499999f, -0.866026f, 0.000000f, 0.000000f, -0.499999f, -0.866026f, 0.000000f, 0.393083f, 0.683427f,
+		-0.580461f, -0.798935f, 0.157379f, 0.000000f, -0.580461f, -0.798935f, 0.157379f, 0.447735f, 0.590447f,
+		-0.738585f, -0.655845f, 0.156077f, 0.000000f, -0.738585f, -0.655845f, 0.156077f, 0.552265f, 0.590447f,
+		-0.580461f, -0.798935f, 0.157379f, 0.000000f, -0.580461f, -0.798935f, 0.157379f, 0.447735f, 0.590447f,
+		-0.643075f, -0.701637f, 0.306855f, 0.000000f, -0.643075f, -0.701637f, 0.306855f, 0.500000f, 0.511757f,
+		-0.455297f, -0.812623f, -0.363797f, 0.000000f, -0.455297f, -0.812623f, -0.363797f, 0.606918f, 0.683427f,
+		-0.343074f, -0.784354f, -0.516806f, 0.000000f, -0.343074f, -0.784354f, -0.516806f, 0.165435f, 0.666172f,
+		-0.286151f, -0.894562f, -0.343331f, 0.000000f, -0.286151f, -0.894562f, -0.343331f, 0.606016f, 0.512408f,
+		-0.577350f, -0.794654f, -0.187593f, 0.000000f, -0.577350f, -0.794654f, -0.187593f, 0.445347f, 0.772345f,
+		-0.455297f, -0.812623f, -0.363797f, 0.000000f, -0.455297f, -0.812623f, -0.363797f, 0.606918f, 0.683427f,
+		-0.390694f, -0.901541f, -0.185961f, 0.000000f, -0.390694f, -0.901541f, -0.185961f, 0.352845f, 0.762112f,
+		-0.577350f, -0.794654f, -0.187593f, 0.000000f, -0.577350f, -0.794654f, -0.187593f, 0.445347f, 0.772345f,
+		-0.499999f, -0.866026f, 0.000000f, 0.000000f, -0.499999f, -0.866026f, 0.000000f, 0.393083f, 0.683427f,
+		-0.669131f, -0.743144f, 0.000000f, 0.000000f, -0.669131f, -0.743144f, 0.000000f, 0.500000f, 0.684243f,
+		-0.738585f, -0.655845f, 0.156077f, 0.000000f, -0.738585f, -0.655845f, 0.156077f, 0.552265f, 0.590447f,
+		-0.669131f, -0.743144f, 0.000000f, 0.000000f, -0.669131f, -0.743144f, 0.000000f, 0.500000f, 0.684243f,
+		-0.580461f, -0.798935f, 0.157379f, 0.000000f, -0.580461f, -0.798935f, 0.157379f, 0.447735f, 0.590447f,
+		-0.174499f, -0.853887f, -0.490334f, 0.000000f, -0.174499f, -0.853887f, -0.490334f, 0.131658f, 0.562217f,
+		0.000000f, -0.894427f, -0.447214f, 0.000000f, 0.000000f, -0.894427f, -0.447214f, 0.848850f, 0.215669f,
+		-0.107846f, -0.945626f, -0.306855f, 0.000000f, -0.107846f, -0.945626f, -0.306855f, 0.553923f, 0.437019f,
+		-0.286151f, -0.894562f, -0.343331f, 0.000000f, -0.286151f, -0.894562f, -0.343331f, 0.606016f, 0.512408f,
+		-0.107846f, -0.945626f, -0.306855f, 0.000000f, -0.107846f, -0.945626f, -0.306855f, 0.553923f, 0.437019f,
+		-0.212032f, -0.964719f, -0.156077f, 0.000000f, -0.212032f, -0.964719f, -0.156077f, 0.265712f, 0.743874f,
+		-0.390694f, -0.901541f, -0.185961f, 0.000000f, -0.390694f, -0.901541f, -0.185961f, 0.352845f, 0.762112f,
+		-0.212032f, -0.964719f, -0.156077f, 0.000000f, -0.212032f, -0.964719f, -0.156077f, 0.265712f, 0.743874f,
+		-0.309017f, -0.951056f, 0.000000f, 0.000000f, -0.309017f, -0.951056f, 0.000000f, 0.302245f, 0.668485f,
+		-0.499999f, -0.866026f, 0.000000f, 0.000000f, -0.499999f, -0.866026f, 0.000000f, 0.393083f, 0.683427f,
+		-0.309017f, -0.951056f, 0.000000f, 0.000000f, -0.309017f, -0.951056f, 0.000000f, 0.302245f, 0.668485f,
+		-0.395511f, -0.905103f, 0.156077f, 0.000000f, -0.395511f, -0.905103f, 0.156077f, 0.345491f, 0.590447f,
+		-0.580461f, -0.798935f, 0.157379f, 0.000000f, -0.580461f, -0.798935f, 0.157379f, 0.447735f, 0.590447f,
+		-0.395511f, -0.905103f, 0.156077f, 0.000000f, -0.395511f, -0.905103f, 0.156077f, 0.345491f, 0.590447f,
+		-0.468576f, -0.828418f, 0.306855f, 0.000000f, -0.468576f, -0.828418f, 0.306855f, 0.393984f, 0.512408f,
+		-0.643075f, -0.701637f, 0.306855f, 0.000000f, -0.643075f, -0.701637f, 0.306855f, 0.500000f, 0.511757f,
+		-0.468576f, -0.828418f, 0.306855f, 0.000000f, -0.468576f, -0.828418f, 0.306855f, 0.393984f, 0.512408f,
+		-0.525731f, -0.723607f, 0.447214f, 0.000000f, -0.525731f, -0.723607f, 0.447214f, 0.321589f, 0.745561f,
+		-0.286151f, -0.894562f, -0.343331f, 0.000000f, -0.286151f, -0.894562f, -0.343331f, 0.606016f, 0.512408f,
+		-0.174499f, -0.853887f, -0.490334f, 0.000000f, -0.174499f, -0.853887f, -0.490334f, 0.131658f, 0.562217f,
+		-0.107846f, -0.945626f, -0.306855f, 0.000000f, -0.107846f, -0.945626f, -0.306855f, 0.553923f, 0.437019f,
+		-0.390694f, -0.901541f, -0.185961f, 0.000000f, -0.390694f, -0.901541f, -0.185961f, 0.352845f, 0.762112f,
+		-0.286151f, -0.894562f, -0.343331f, 0.000000f, -0.286151f, -0.894562f, -0.343331f, 0.606016f, 0.512408f,
+		-0.212032f, -0.964719f, -0.156077f, 0.000000f, -0.212032f, -0.964719f, -0.156077f, 0.265712f, 0.743874f,
+		-0.390694f, -0.901541f, -0.185961f, 0.000000f, -0.390694f, -0.901541f, -0.185961f, 0.352845f, 0.762112f,
+		-0.309017f, -0.951056f, 0.000000f, 0.000000f, -0.309017f, -0.951056f, 0.000000f, 0.302245f, 0.668485f,
+		-0.499999f, -0.866026f, 0.000000f, 0.000000f, -0.499999f, -0.866026f, 0.000000f, 0.393083f, 0.683427f,
+		-0.499999f, -0.866026f, 0.000000f, 0.000000f, -0.499999f, -0.866026f, 0.000000f, 0.393083f, 0.683427f,
+		-0.395511f, -0.905103f, 0.156077f, 0.000000f, -0.395511f, -0.905103f, 0.156077f, 0.345491f, 0.590447f,
+		-0.580461f, -0.798935f, 0.157379f, 0.000000f, -0.580461f, -0.798935f, 0.157379f, 0.447735f, 0.590447f,
+		-0.580461f, -0.798935f, 0.157379f, 0.000000f, -0.580461f, -0.798935f, 0.157379f, 0.447735f, 0.590447f,
+		-0.468576f, -0.828418f, 0.306855f, 0.000000f, -0.468576f, -0.828418f, 0.306855f, 0.393984f, 0.512408f,
+		-0.643075f, -0.701637f, 0.306855f, 0.000000f, -0.643075f, -0.701637f, 0.306855f, 0.500000f, 0.511757f,
+		0.932670f, 0.189647f, 0.306855f, 0.000000f, 0.932670f, 0.189647f, 0.306855f, 0.554653f, 0.258102f,
+		0.850651f, 0.276393f, 0.447214f, 0.000000f, 0.850651f, 0.276393f, 0.447214f, 0.750000f, 0.581230f,
+		0.866018f, 0.097907f, 0.490334f, 0.000000f, 0.866018f, 0.097907f, 0.490334f, 0.727648f, 0.480987f,
+		0.939205f, 0.004289f, 0.343331f, 0.000000f, 0.939205f, 0.004289f, 0.343331f, 0.446077f, 0.437019f,
+		0.866018f, 0.097907f, 0.490334f, 0.000000f, 0.866018f, 0.097907f, 0.490334f, 0.727648f, 0.480987f,
+		0.851981f, -0.083904f, 0.516806f, 0.000000f, 0.851981f, -0.083904f, 0.516806f, 0.695347f, 0.381573f,
+		0.983024f, 0.096460f, 0.156077f, 0.000000f, 0.983024f, 0.096460f, 0.156077f, 0.408260f, 0.332044f,
+		0.932670f, 0.189647f, 0.306855f, 0.000000f, 0.932670f, 0.189647f, 0.306855f, 0.554653f, 0.258102f,
+		0.939205f, 0.004289f, 0.343331f, 0.000000f, 0.939205f, 0.004289f, 0.343331f, 0.446077f, 0.437019f,
+		0.939205f, 0.004289f, 0.343331f, 0.000000f, 0.939205f, 0.004289f, 0.343331f, 0.446077f, 0.437019f,
+		0.932670f, 0.189647f, 0.306855f, 0.000000f, 0.932670f, 0.189647f, 0.306855f, 0.554653f, 0.258102f,
+		0.866018f, 0.097907f, 0.490334f, 0.000000f, 0.866018f, 0.097907f, 0.490334f, 0.727648f, 0.480987f,
+		0.913545f, -0.181898f, 0.363797f, 0.000000f, 0.913545f, -0.181898f, 0.363797f, 0.178463f, 0.743874f,
+		0.851981f, -0.083904f, 0.516806f, 0.000000f, 0.851981f, -0.083904f, 0.516806f, 0.695347f, 0.381573f,
+		0.809017f, -0.262866f, 0.525731f, 0.000000f, 0.809017f, -0.262866f, 0.525731f, 0.654508f, 0.287337f,
+		0.978148f, -0.092981f, 0.185961f, 0.000000f, 0.978148f, -0.092981f, 0.185961f, 0.437019f, 0.697392f,
+		0.939205f, 0.004289f, 0.343331f, 0.000000f, 0.939205f, 0.004289f, 0.343331f, 0.446077f, 0.437019f,
+		0.913545f, -0.181898f, 0.363797f, 0.000000f, 0.913545f, -0.181898f, 0.363797f, 0.178463f, 0.743874f,
+		1.000000f, -0.000000f, 0.000000f, 0.000000f, 1.000000f, -0.000000f, 0.000000f, 0.445347f, 0.130459f,
+		0.983024f, 0.096460f, 0.156077f, 0.000000f, 0.983024f, 0.096460f, 0.156077f, 0.408260f, 0.332044f,
+		0.978148f, -0.092981f, 0.185961f, 0.000000f, 0.978148f, -0.092981f, 0.185961f, 0.437019f, 0.697392f,
+		0.913545f, -0.181898f, 0.363797f, 0.000000f, 0.913545f, -0.181898f, 0.363797f, 0.178463f, 0.743874f,
+		0.939205f, 0.004289f, 0.343331f, 0.000000f, 0.939205f, 0.004289f, 0.343331f, 0.446077f, 0.437019f,
+		0.851981f, -0.083904f, 0.516806f, 0.000000f, 0.851981f, -0.083904f, 0.516806f, 0.695347f, 0.381573f,
+		0.978148f, -0.092981f, 0.185961f, 0.000000f, 0.978148f, -0.092981f, 0.185961f, 0.437019f, 0.697392f,
+		0.983024f, 0.096460f, 0.156077f, 0.000000f, 0.983024f, 0.096460f, 0.156077f, 0.408260f, 0.332044f,
+		0.939205f, 0.004289f, 0.343331f, 0.000000f, 0.939205f, 0.004289f, 0.343331f, 0.446077f, 0.437019f,
+		0.738585f, -0.432902f, 0.516806f, 0.000000f, 0.738585f, -0.432902f, 0.516806f, 0.671537f, 0.555736f,
+		0.845991f, -0.389809f, 0.363797f, 0.000000f, 0.845991f, -0.389809f, 0.363797f, 0.183922f, 0.772345f,
+		0.809017f, -0.262866f, 0.525731f, 0.000000f, 0.809017f, -0.262866f, 0.525731f, 0.654508f, 0.287337f,
+		0.845991f, -0.389809f, 0.363797f, 0.000000f, 0.845991f, -0.389809f, 0.363797f, 0.183922f, 0.772345f,
+		0.934172f, -0.303531f, 0.187593f, 0.000000f, 0.934172f, -0.303531f, 0.187593f, 0.272352f, 0.772345f,
+		0.913545f, -0.181898f, 0.363797f, 0.000000f, 0.913545f, -0.181898f, 0.363797f, 0.178463f, 0.743874f,
+		0.978148f, -0.207911f, 0.000000f, 0.000000f, 0.978148f, -0.207911f, 0.000000f, 0.211325f, 0.684243f,
+		0.978148f, -0.092981f, 0.185961f, 0.000000f, 0.978148f, -0.092981f, 0.185961f, 0.437019f, 0.697392f,
+		0.934172f, -0.303531f, 0.187593f, 0.000000f, 0.934172f, -0.303531f, 0.187593f, 0.272352f, 0.772345f,
+		0.978148f, -0.207911f, 0.000000f, 0.000000f, 0.978148f, -0.207911f, 0.000000f, 0.211325f, 0.684243f,
+		0.983024f, -0.096461f, -0.156077f, 0.000000f, 0.983024f, -0.096461f, -0.156077f, 0.500000f, 0.196469f,
+		1.000000f, -0.000000f, 0.000000f, 0.000000f, 1.000000f, -0.000000f, 0.000000f, 0.445347f, 0.130459f,
+		0.845991f, -0.389809f, 0.363797f, 0.000000f, 0.845991f, -0.389809f, 0.363797f, 0.183922f, 0.772345f,
+		0.913545f, -0.181898f, 0.363797f, 0.000000f, 0.913545f, -0.181898f, 0.363797f, 0.178463f, 0.743874f,
+		0.809017f, -0.262866f, 0.525731f, 0.000000f, 0.809017f, -0.262866f, 0.525731f, 0.654508f, 0.287337f,
+		0.934172f, -0.303531f, 0.187593f, 0.000000f, 0.934172f, -0.303531f, 0.187593f, 0.272352f, 0.772345f,
+		0.978148f, -0.092981f, 0.185961f, 0.000000f, 0.978148f, -0.092981f, 0.185961f, 0.437019f, 0.697392f,
+		0.913545f, -0.181898f, 0.363797f, 0.000000f, 0.913545f, -0.181898f, 0.363797f, 0.178463f, 0.743874f,
+		0.978148f, -0.207911f, 0.000000f, 0.000000f, 0.978148f, -0.207911f, 0.000000f, 0.211325f, 0.684243f,
+		1.000000f, -0.000000f, 0.000000f, 0.000000f, 1.000000f, -0.000000f, 0.000000f, 0.445347f, 0.130459f,
+		0.978148f, -0.092981f, 0.185961f, 0.000000f, 0.978148f, -0.092981f, 0.185961f, 0.437019f, 0.697392f,
+		0.643075f, -0.588241f, 0.490334f, 0.000000f, 0.643075f, -0.588241f, 0.490334f, 0.643075f, 0.453512f,
+		0.757311f, -0.555521f, 0.343331f, 0.000000f, 0.757311f, -0.555521f, 0.343331f, 0.131657f, 0.683427f,
+		0.738585f, -0.432902f, 0.516806f, 0.000000f, 0.738585f, -0.432902f, 0.516806f, 0.671537f, 0.555736f,
+		0.757311f, -0.555521f, 0.343331f, 0.000000f, 0.757311f, -0.555521f, 0.343331f, 0.131657f, 0.683427f,
+		0.845991f, -0.499718f, 0.185961f, 0.000000f, 0.845991f, -0.499718f, 0.185961f, 0.165435f, 0.590447f,
+		0.845991f, -0.389809f, 0.363797f, 0.000000f, 0.845991f, -0.389809f, 0.363797f, 0.183922f, 0.772345f,
+		0.845991f, -0.499718f, 0.185961f, 0.000000f, 0.845991f, -0.499718f, 0.185961f, 0.165435f, 0.590447f,
+		0.913545f, -0.406737f, 0.000000f, 0.000000f, 0.913545f, -0.406737f, 0.000000f, 0.356925f, 0.762112f,
+		0.934172f, -0.303531f, 0.187593f, 0.000000f, 0.934172f, -0.303531f, 0.187593f, 0.272352f, 0.772345f,
+		0.913545f, -0.406737f, 0.000000f, 0.000000f, 0.913545f, -0.406737f, 0.000000f, 0.356925f, 0.762112f,
+		0.939205f, -0.305166f, -0.157379f, 0.000000f, 0.939205f, -0.305166f, -0.157379f, 0.304653f, 0.683427f,
+		0.978148f, -0.207911f, 0.000000f, 0.000000f, 0.978148f, -0.207911f, 0.000000f, 0.211325f, 0.684243f,
+		0.939205f, -0.305166f, -0.157379f, 0.000000f, 0.939205f, -0.305166f, -0.157379f, 0.304653f, 0.683427f,
+		0.932670f, -0.189647f, -0.306855f, 0.000000f, 0.932670f, -0.189647f, -0.306855f, 0.552265f, 0.277618f,
+		0.983024f, -0.096461f, -0.156077f, 0.000000f, 0.983024f, -0.096461f, -0.156077f, 0.500000f, 0.196469f,
+		0.757311f, -0.555521f, 0.343331f, 0.000000f, 0.757311f, -0.555521f, 0.343331f, 0.131657f, 0.683427f,
+		0.845991f, -0.389809f, 0.363797f, 0.000000f, 0.845991f, -0.389809f, 0.363797f, 0.183922f, 0.772345f,
+		0.738585f, -0.432902f, 0.516806f, 0.000000f, 0.738585f, -0.432902f, 0.516806f, 0.671537f, 0.555736f,
+		0.845991f, -0.499718f, 0.185961f, 0.000000f, 0.845991f, -0.499718f, 0.185961f, 0.165435f, 0.590447f,
+		0.934172f, -0.303531f, 0.187593f, 0.000000f, 0.934172f, -0.303531f, 0.187593f, 0.272352f, 0.772345f,
+		0.845991f, -0.389809f, 0.363797f, 0.000000f, 0.845991f, -0.389809f, 0.363797f, 0.183922f, 0.772345f,
+		0.913545f, -0.406737f, 0.000000f, 0.000000f, 0.913545f, -0.406737f, 0.000000f, 0.356925f, 0.762112f,
+		0.978148f, -0.207911f, 0.000000f, 0.000000f, 0.978148f, -0.207911f, 0.000000f, 0.211325f, 0.684243f,
+		0.934172f, -0.303531f, 0.187593f, 0.000000f, 0.934172f, -0.303531f, 0.187593f, 0.272352f, 0.772345f,
+		0.939205f, -0.305166f, -0.157379f, 0.000000f, 0.939205f, -0.305166f, -0.157379f, 0.304653f, 0.683427f,
+		0.983024f, -0.096461f, -0.156077f, 0.000000f, 0.983024f, -0.096461f, -0.156077f, 0.500000f, 0.196469f,
+		0.978148f, -0.207911f, 0.000000f, 0.000000f, 0.978148f, -0.207911f, 0.000000f, 0.211325f, 0.684243f,
+		0.525731f, -0.723607f, 0.447214f, 0.000000f, 0.525731f, -0.723607f, 0.447214f, 0.606016f, 0.354082f,
+		0.643075f, -0.701637f, 0.306855f, 0.000000f, 0.643075f, -0.701637f, 0.306855f, 0.447735f, 0.277618f,
+		0.643075f, -0.588241f, 0.490334f, 0.000000f, 0.643075f, -0.588241f, 0.490334f, 0.643075f, 0.453512f,
+		0.643075f, -0.701637f, 0.306855f, 0.000000f, 0.643075f, -0.701637f, 0.306855f, 0.447735f, 0.277618f,
+		0.738585f, -0.655845f, 0.156077f, 0.000000f, 0.738585f, -0.655845f, 0.156077f, 0.500000f, 0.349562f,
+		0.757311f, -0.555521f, 0.343331f, 0.000000f, 0.757311f, -0.555521f, 0.343331f, 0.131657f, 0.683427f,
+		0.738585f, -0.655845f, 0.156077f, 0.000000f, 0.738585f, -0.655845f, 0.156077f, 0.500000f, 0.349562f,
+		0.809017f, -0.587785f, 0.000000f, 0.000000f, 0.809017f, -0.587785f, 0.000000f, 0.209769f, 0.268343f,
+		0.845991f, -0.499718f, 0.185961f, 0.000000f, 0.845991f, -0.499718f, 0.185961f, 0.165435f, 0.590447f,
+		0.809017f, -0.587785f, 0.000000f, 0.000000f, 0.809017f, -0.587785f, 0.000000f, 0.209769f, 0.268343f,
+		0.851981f, -0.499769f, -0.156077f, 0.000000f, 0.851981f, -0.499769f, -0.156077f, 0.265712f, 0.288582f,
+		0.913545f, -0.406737f, 0.000000f, 0.000000f, 0.913545f, -0.406737f, 0.000000f, 0.356925f, 0.762112f,
+		0.866018f, -0.394782f, -0.306855f, 0.000000f, 0.866018f, -0.394782f, -0.306855f, 0.237134f, 0.366840f,
+		0.939205f, -0.305166f, -0.157379f, 0.000000f, 0.939205f, -0.305166f, -0.157379f, 0.304653f, 0.683427f,
+		0.851981f, -0.499769f, -0.156077f, 0.000000f, 0.851981f, -0.499769f, -0.156077f, 0.265712f, 0.288582f,
+		0.866018f, -0.394782f, -0.306855f, 0.000000f, 0.866018f, -0.394782f, -0.306855f, 0.237134f, 0.366840f,
+		0.850651f, -0.276393f, -0.447214f, 0.000000f, 0.850651f, -0.276393f, -0.447214f, 0.500000f, 0.960321f,
+		0.932670f, -0.189647f, -0.306855f, 0.000000f, 0.932670f, -0.189647f, -0.306855f, 0.552265f, 0.277618f,
+		0.643075f, -0.701637f, 0.306855f, 0.000000f, 0.643075f, -0.701637f, 0.306855f, 0.447735f, 0.277618f,
+		0.757311f, -0.555521f, 0.343331f, 0.000000f, 0.757311f, -0.555521f, 0.343331f, 0.131657f, 0.683427f,
+		0.643075f, -0.588241f, 0.490334f, 0.000000f, 0.643075f, -0.588241f, 0.490334f, 0.643075f, 0.453512f,
+		0.738585f, -0.655845f, 0.156077f, 0.000000f, 0.738585f, -0.655845f, 0.156077f, 0.500000f, 0.349562f,
+		0.845991f, -0.499718f, 0.185961f, 0.000000f, 0.845991f, -0.499718f, 0.185961f, 0.165435f, 0.590447f,
+		0.757311f, -0.555521f, 0.343331f, 0.000000f, 0.757311f, -0.555521f, 0.343331f, 0.131657f, 0.683427f,
+		0.809017f, -0.587785f, 0.000000f, 0.000000f, 0.809017f, -0.587785f, 0.000000f, 0.209769f, 0.268343f,
+		0.913545f, -0.406737f, 0.000000f, 0.000000f, 0.913545f, -0.406737f, 0.000000f, 0.356925f, 0.762112f,
+		0.845991f, -0.499718f, 0.185961f, 0.000000f, 0.845991f, -0.499718f, 0.185961f, 0.165435f, 0.590447f,
+		0.851981f, -0.499769f, -0.156077f, 0.000000f, 0.851981f, -0.499769f, -0.156077f, 0.265712f, 0.288582f,
+		0.939205f, -0.305166f, -0.157379f, 0.000000f, 0.939205f, -0.305166f, -0.157379f, 0.304653f, 0.683427f,
+		0.913545f, -0.406737f, 0.000000f, 0.000000f, 0.913545f, -0.406737f, 0.000000f, 0.356925f, 0.762112f,
+		0.866018f, -0.394782f, -0.306855f, 0.000000f, 0.866018f, -0.394782f, -0.306855f, 0.237134f, 0.366840f,
+		0.932670f, -0.189647f, -0.306855f, 0.000000f, 0.932670f, -0.189647f, -0.306855f, 0.552265f, 0.277618f,
+		0.939205f, -0.305166f, -0.157379f, 0.000000f, 0.939205f, -0.305166f, -0.157379f, 0.304653f, 0.683427f,
+		0.107846f, 0.945626f, 0.306855f, 0.000000f, 0.107846f, 0.945626f, 0.306855f, 0.743874f, 0.302609f,
+		0.000000f, 0.894427f, 0.447214f, 0.000000f, 0.000000f, 0.894427f, 0.447214f, 0.268343f, 0.250971f,
+		0.174499f, 0.853887f, 0.490334f, 0.000000f, 0.174499f, 0.853887f, 0.490334f, 0.332044f, 0.283549f,
+		0.286151f, 0.894562f, 0.343331f, 0.000000f, 0.286151f, 0.894562f, 0.343331f, 0.250001f, 0.590447f,
+		0.174499f, 0.853887f, 0.490334f, 0.000000f, 0.174499f, 0.853887f, 0.490334f, 0.332044f, 0.283549f,
+		0.343074f, 0.784354f, 0.516806f, 0.000000f, 0.343074f, 0.784354f, 0.516806f, 0.345280f, 0.205880f,
+		0.212032f, 0.964719f, 0.156077f, 0.000000f, 0.212032f, 0.964719f, 0.156077f, 0.683427f, 0.174918f,
+		0.107846f, 0.945626f, 0.306855f, 0.000000f, 0.107846f, 0.945626f, 0.306855f, 0.743874f, 0.302609f,
+		0.286151f, 0.894562f, 0.343331f, 0.000000f, 0.286151f, 0.894562f, 0.343331f, 0.250001f, 0.590447f,
+		0.286151f, 0.894562f, 0.343331f, 0.000000f, 0.286151f, 0.894562f, 0.343331f, 0.250001f, 0.590447f,
+		0.107846f, 0.945626f, 0.306855f, 0.000000f, 0.107846f, 0.945626f, 0.306855f, 0.743874f, 0.302609f,
+		0.174499f, 0.853887f, 0.490334f, 0.000000f, 0.174499f, 0.853887f, 0.490334f, 0.332044f, 0.283549f,
+		0.455297f, 0.812623f, 0.363797f, 0.000000f, 0.455297f, 0.812623f, 0.363797f, 0.209769f, 0.511757f,
+		0.343074f, 0.784354f, 0.516806f, 0.000000f, 0.343074f, 0.784354f, 0.516806f, 0.345280f, 0.205880f,
+		0.500000f, 0.688191f, 0.525731f, 0.000000f, 0.500000f, 0.688191f, 0.525731f, 0.734288f, 0.288582f,
+		0.390694f, 0.901541f, 0.185961f, 0.000000f, 0.390694f, 0.901541f, 0.185961f, 0.130708f, 0.512408f,
+		0.286151f, 0.894562f, 0.343331f, 0.000000f, 0.286151f, 0.894562f, 0.343331f, 0.250001f, 0.590447f,
+		0.455297f, 0.812623f, 0.363797f, 0.000000f, 0.455297f, 0.812623f, 0.363797f, 0.209769f, 0.511757f,
+		0.309017f, 0.951056f, 0.000000f, 0.000000f, 0.309017f, 0.951056f, 0.000000f, 0.750000f, 0.590447f,
+		0.212032f, 0.964719f, 0.156077f, 0.000000f, 0.212032f, 0.964719f, 0.156077f, 0.683427f, 0.174918f,
+		0.390694f, 0.901541f, 0.185961f, 0.000000f, 0.390694f, 0.901541f, 0.185961f, 0.130708f, 0.512408f,
+		0.455297f, 0.812623f, 0.363797f, 0.000000f, 0.455297f, 0.812623f, 0.363797f, 0.209769f, 0.511757f,
+		0.286151f, 0.894562f, 0.343331f, 0.000000f, 0.286151f, 0.894562f, 0.343331f, 0.250001f, 0.590447f,
+		0.343074f, 0.784354f, 0.516806f, 0.000000f, 0.343074f, 0.784354f, 0.516806f, 0.345280f, 0.205880f,
+		0.390694f, 0.901541f, 0.185961f, 0.000000f, 0.390694f, 0.901541f, 0.185961f, 0.130708f, 0.512408f,
+		0.212032f, 0.964719f, 0.156077f, 0.000000f, 0.212032f, 0.964719f, 0.156077f, 0.683427f, 0.174918f,
+		0.286151f, 0.894562f, 0.343331f, 0.000000f, 0.286151f, 0.894562f, 0.343331f, 0.250001f, 0.590447f,
+		0.639949f, 0.568662f, 0.516806f, 0.000000f, 0.639949f, 0.568662f, 0.516806f, 0.821537f, 0.345280f,
+		0.632156f, 0.684127f, 0.363797f, 0.000000f, 0.632156f, 0.684127f, 0.363797f, 0.178463f, 0.437019f,
+		0.500000f, 0.688191f, 0.525731f, 0.000000f, 0.500000f, 0.688191f, 0.525731f, 0.734288f, 0.288582f,
+		0.632156f, 0.684127f, 0.363797f, 0.000000f, 0.632156f, 0.684127f, 0.363797f, 0.178463f, 0.437019f,
+		0.577350f, 0.794654f, 0.187593f, 0.000000f, 0.577350f, 0.794654f, 0.187593f, 0.446077f, 0.743874f,
+		0.455297f, 0.812623f, 0.363797f, 0.000000f, 0.455297f, 0.812623f, 0.363797f, 0.209769f, 0.511757f,
+		0.499999f, 0.866026f, 0.000000f, 0.000000f, 0.499999f, 0.866026f, 0.000000f, 0.393984f, 0.668485f,
+		0.390694f, 0.901541f, 0.185961f, 0.000000f, 0.390694f, 0.901541f, 0.185961f, 0.130708f, 0.512408f,
+		0.577350f, 0.794654f, 0.187593f, 0.000000f, 0.577350f, 0.794654f, 0.187593f, 0.446077f, 0.743874f,
+		0.499999f, 0.866026f, 0.000000f, 0.000000f, 0.499999f, 0.866026f, 0.000000f, 0.393984f, 0.668485f,
+		0.395511f, 0.905103f, -0.156077f, 0.000000f, 0.395511f, 0.905103f, -0.156077f, 0.654508f, 0.590447f,
+		0.309017f, 0.951056f, 0.000000f, 0.000000f, 0.309017f, 0.951056f, 0.000000f, 0.750000f, 0.590447f,
+		0.632156f, 0.684127f, 0.363797f, 0.000000f, 0.632156f, 0.684127f, 0.363797f, 0.178463f, 0.437019f,
+		0.455297f, 0.812623f, 0.363797f, 0.000000f, 0.455297f, 0.812623f, 0.363797f, 0.209769f, 0.511757f,
+		0.500000f, 0.688191f, 0.525731f, 0.000000f, 0.500000f, 0.688191f, 0.525731f, 0.734288f, 0.288582f,
+		0.577350f, 0.794654f, 0.187593f, 0.000000f, 0.577350f, 0.794654f, 0.187593f, 0.446077f, 0.743874f,
+		0.390694f, 0.901541f, 0.185961f, 0.000000f, 0.390694f, 0.901541f, 0.185961f, 0.130708f, 0.512408f,
+		0.455297f, 0.812623f, 0.363797f, 0.000000f, 0.455297f, 0.812623f, 0.363797f, 0.209769f, 0.511757f,
+		0.499999f, 0.866026f, 0.000000f, 0.000000f, 0.499999f, 0.866026f, 0.000000f, 0.393984f, 0.668485f,
+		0.309017f, 0.951056f, 0.000000f, 0.000000f, 0.309017f, 0.951056f, 0.000000f, 0.750000f, 0.590447f,
+		0.390694f, 0.901541f, 0.185961f, 0.000000f, 0.390694f, 0.901541f, 0.185961f, 0.130708f, 0.512408f,
+		0.758172f, 0.429824f, 0.490334f, 0.000000f, 0.758172f, 0.429824f, 0.490334f, 0.762866f, 0.366840f,
+		0.762354f, 0.548581f, 0.343331f, 0.000000f, 0.762354f, 0.548581f, 0.343331f, 0.302244f, 0.512408f,
+		0.639949f, 0.568662f, 0.516806f, 0.000000f, 0.639949f, 0.568662f, 0.516806f, 0.821537f, 0.345280f,
+		0.762354f, 0.548581f, 0.343331f, 0.000000f, 0.762354f, 0.548581f, 0.343331f, 0.302244f, 0.512408f,
+		0.736686f, 0.650164f, 0.185961f, 0.000000f, 0.736686f, 0.650164f, 0.185961f, 0.265712f, 0.437019f,
+		0.632156f, 0.684127f, 0.363797f, 0.000000f, 0.632156f, 0.684127f, 0.363797f, 0.178463f, 0.437019f,
+		0.736686f, 0.650164f, 0.185961f, 0.000000f, 0.736686f, 0.650164f, 0.185961f, 0.265712f, 0.437019f,
+		0.669131f, 0.743144f, 0.000000f, 0.000000f, 0.669131f, 0.743144f, 0.000000f, 0.418781f, 0.502145f,
+		0.577350f, 0.794654f, 0.187593f, 0.000000f, 0.577350f, 0.794654f, 0.187593f, 0.446077f, 0.743874f,
+		0.669131f, 0.743144f, 0.000000f, 0.000000f, 0.669131f, 0.743144f, 0.000000f, 0.418781f, 0.502145f,
+		0.580461f, 0.798935f, -0.157379f, 0.000000f, 0.580461f, 0.798935f, -0.157379f, 0.408548f, 0.409051f,
+		0.499999f, 0.866026f, 0.000000f, 0.000000f, 0.499999f, 0.866026f, 0.000000f, 0.393984f, 0.668485f,
+		0.580461f, 0.798935f, -0.157379f, 0.000000f, 0.580461f, 0.798935f, -0.157379f, 0.408548f, 0.409051f,
+		0.468576f, 0.828418f, -0.306855f, 0.000000f, 0.468576f, 0.828418f, -0.306855f, 0.727648f, 0.772345f,
+		0.395511f, 0.905103f, -0.156077f, 0.000000f, 0.395511f, 0.905103f, -0.156077f, 0.654508f, 0.590447f,
+		0.762354f, 0.548581f, 0.343331f, 0.000000f, 0.762354f, 0.548581f, 0.343331f, 0.302244f, 0.512408f,
+		0.632156f, 0.684127f, 0.363797f, 0.000000f, 0.632156f, 0.684127f, 0.363797f, 0.178463f, 0.437019f,
+		0.639949f, 0.568662f, 0.516806f, 0.000000f, 0.639949f, 0.568662f, 0.516806f, 0.821537f, 0.345280f,
+		0.736686f, 0.650164f, 0.185961f, 0.000000f, 0.736686f, 0.650164f, 0.185961f, 0.265712f, 0.437019f,
+		0.577350f, 0.794654f, 0.187593f, 0.000000f, 0.577350f, 0.794654f, 0.187593f, 0.446077f, 0.743874f,
+		0.632156f, 0.684127f, 0.363797f, 0.000000f, 0.632156f, 0.684127f, 0.363797f, 0.178463f, 0.437019f,
+		0.669131f, 0.743144f, 0.000000f, 0.000000f, 0.669131f, 0.743144f, 0.000000f, 0.418781f, 0.502145f,
+		0.499999f, 0.866026f, 0.000000f, 0.000000f, 0.499999f, 0.866026f, 0.000000f, 0.393984f, 0.668485f,
+		0.577350f, 0.794654f, 0.187593f, 0.000000f, 0.577350f, 0.794654f, 0.187593f, 0.446077f, 0.743874f,
+		0.580461f, 0.798935f, -0.157379f, 0.000000f, 0.580461f, 0.798935f, -0.157379f, 0.408548f, 0.409051f,
+		0.395511f, 0.905103f, -0.156077f, 0.000000f, 0.395511f, 0.905103f, -0.156077f, 0.654508f, 0.590447f,
+		0.499999f, 0.866026f, 0.000000f, 0.000000f, 0.499999f, 0.866026f, 0.000000f, 0.393984f, 0.668485f,
+		0.850651f, 0.276393f, 0.447214f, 0.000000f, 0.850651f, 0.276393f, 0.447214f, 0.750000f, 0.581230f,
+		0.866018f, 0.394782f, 0.306855f, 0.000000f, 0.866018f, 0.394782f, 0.306855f, 0.606016f, 0.668485f,
+		0.758172f, 0.429824f, 0.490334f, 0.000000f, 0.758172f, 0.429824f, 0.490334f, 0.762866f, 0.366840f,
+		0.866018f, 0.394782f, 0.306855f, 0.000000f, 0.866018f, 0.394782f, 0.306855f, 0.606016f, 0.668485f,
+		0.851981f, 0.499768f, 0.156077f, 0.000000f, 0.851981f, 0.499768f, 0.156077f, 0.643075f, 0.762112f,
+		0.762354f, 0.548581f, 0.343331f, 0.000000f, 0.762354f, 0.548581f, 0.343331f, 0.302244f, 0.512408f,
+		0.851981f, 0.499768f, 0.156077f, 0.000000f, 0.851981f, 0.499768f, 0.156077f, 0.643075f, 0.762112f,
+		0.809017f, 0.587785f, 0.000000f, 0.000000f, 0.809017f, 0.587785f, 0.000000f, 0.553923f, 0.743874f,
+		0.736686f, 0.650164f, 0.185961f, 0.000000f, 0.736686f, 0.650164f, 0.185961f, 0.265712f, 0.437019f,
+		0.809017f, 0.587785f, 0.000000f, 0.000000f, 0.809017f, 0.587785f, 0.000000f, 0.553923f, 0.743874f,
+		0.738585f, 0.655845f, -0.156077f, 0.000000f, 0.738585f, 0.655845f, -0.156077f, 0.647155f, 0.268343f,
+		0.669131f, 0.743144f, 0.000000f, 0.000000f, 0.669131f, 0.743144f, 0.000000f, 0.418781f, 0.502145f,
+		0.643075f, 0.701637f, -0.306855f, 0.000000f, 0.643075f, 0.701637f, -0.306855f, 0.680365f, 0.345280f,
+		0.580461f, 0.798935f, -0.157379f, 0.000000f, 0.580461f, 0.798935f, -0.157379f, 0.408548f, 0.409051f,
+		0.738585f, 0.655845f, -0.156077f, 0.000000f, 0.738585f, 0.655845f, -0.156077f, 0.647155f, 0.268343f,
+		0.643075f, 0.701637f, -0.306855f, 0.000000f, 0.643075f, 0.701637f, -0.306855f, 0.680365f, 0.345280f,
+		0.525731f, 0.723607f, -0.447214f, 0.000000f, 0.525731f, 0.723607f, -0.447214f, 0.788675f, 0.593796f,
+		0.468576f, 0.828418f, -0.306855f, 0.000000f, 0.468576f, 0.828418f, -0.306855f, 0.727648f, 0.772345f,
+		0.866018f, 0.394782f, 0.306855f, 0.000000f, 0.866018f, 0.394782f, 0.306855f, 0.606016f, 0.668485f,
+		0.762354f, 0.548581f, 0.343331f, 0.000000f, 0.762354f, 0.548581f, 0.343331f, 0.302244f, 0.512408f,
+		0.758172f, 0.429824f, 0.490334f, 0.000000f, 0.758172f, 0.429824f, 0.490334f, 0.762866f, 0.366840f,
+		0.851981f, 0.499768f, 0.156077f, 0.000000f, 0.851981f, 0.499768f, 0.156077f, 0.643075f, 0.762112f,
+		0.736686f, 0.650164f, 0.185961f, 0.000000f, 0.736686f, 0.650164f, 0.185961f, 0.265712f, 0.437019f,
+		0.762354f, 0.548581f, 0.343331f, 0.000000f, 0.762354f, 0.548581f, 0.343331f, 0.302244f, 0.512408f,
+		0.809017f, 0.587785f, 0.000000f, 0.000000f, 0.809017f, 0.587785f, 0.000000f, 0.553923f, 0.743874f,
+		0.669131f, 0.743144f, 0.000000f, 0.000000f, 0.669131f, 0.743144f, 0.000000f, 0.418781f, 0.502145f,
+		0.736686f, 0.650164f, 0.185961f, 0.000000f, 0.736686f, 0.650164f, 0.185961f, 0.265712f, 0.437019f,
+		0.738585f, 0.655845f, -0.156077f, 0.000000f, 0.738585f, 0.655845f, -0.156077f, 0.647155f, 0.268343f,
+		0.580461f, 0.798935f, -0.157379f, 0.000000f, 0.580461f, 0.798935f, -0.157379f, 0.408548f, 0.409051f,
+		0.669131f, 0.743144f, 0.000000f, 0.000000f, 0.669131f, 0.743144f, 0.000000f, 0.418781f, 0.502145f,
+		0.643075f, 0.701637f, -0.306855f, 0.000000f, 0.643075f, 0.701637f, -0.306855f, 0.680365f, 0.345280f,
+		0.468576f, 0.828418f, -0.306855f, 0.000000f, 0.468576f, 0.828418f, -0.306855f, 0.727648f, 0.772345f,
+		0.580461f, 0.798935f, -0.157379f, 0.000000f, 0.580461f, 0.798935f, -0.157379f, 0.408548f, 0.409051f,
+		-0.866018f, 0.394783f, 0.306855f, 0.000000f, -0.866018f, 0.394783f, 0.306855f, 0.511757f, 0.652583f,
+		-0.850651f, 0.276393f, 0.447214f, 0.000000f, -0.850651f, 0.276393f, 0.447214f, 0.588426f, 0.872062f,
+		-0.758172f, 0.429824f, 0.490334f, 0.000000f, -0.758172f, 0.429824f, 0.490334f, 0.672996f, 0.831089f,
+		-0.762354f, 0.548581f, 0.343331f, 0.000000f, -0.762354f, 0.548581f, 0.343331f, 0.497466f, 0.453510f,
+		-0.758172f, 0.429824f, 0.490334f, 0.000000f, -0.758172f, 0.429824f, 0.490334f, 0.672996f, 0.831089f,
+		-0.639949f, 0.568662f, 0.516806f, 0.000000f, -0.639949f, 0.568662f, 0.516806f, 0.761425f, 0.766840f,
+		-0.851981f, 0.499769f, 0.156077f, 0.000000f, -0.851981f, 0.499769f, 0.156077f, 0.590447f, 0.603956f,
+		-0.866018f, 0.394783f, 0.306855f, 0.000000f, -0.866018f, 0.394783f, 0.306855f, 0.511757f, 0.652583f,
+		-0.762354f, 0.548581f, 0.343331f, 0.000000f, -0.762354f, 0.548581f, 0.343331f, 0.497466f, 0.453510f,
+		-0.762354f, 0.548581f, 0.343331f, 0.000000f, -0.762354f, 0.548581f, 0.343331f, 0.497466f, 0.453510f,
+		-0.866018f, 0.394783f, 0.306855f, 0.000000f, -0.866018f, 0.394783f, 0.306855f, 0.511757f, 0.652583f,
+		-0.758172f, 0.429824f, 0.490334f, 0.000000f, -0.758172f, 0.429824f, 0.490334f, 0.672996f, 0.831089f,
+		-0.632156f, 0.684127f, 0.363797f, 0.000000f, -0.632156f, 0.684127f, 0.363797f, 0.408548f, 0.305095f,
+		-0.639949f, 0.568662f, 0.516806f, 0.000000f, -0.639949f, 0.568662f, 0.516806f, 0.761425f, 0.766840f,
+		-0.500000f, 0.688191f, 0.525731f, 0.000000f, -0.500000f, 0.688191f, 0.525731f, 0.826527f, 0.699071f,
+		-0.736685f, 0.650164f, 0.185961f, 0.000000f, -0.736685f, 0.650164f, 0.185961f, 0.496650f, 0.348235f,
+		-0.762354f, 0.548581f, 0.343331f, 0.000000f, -0.762354f, 0.548581f, 0.343331f, 0.497466f, 0.453510f,
+		-0.632156f, 0.684127f, 0.363797f, 0.000000f, -0.632156f, 0.684127f, 0.363797f, 0.408548f, 0.305095f,
+		-0.809017f, 0.587785f, 0.000000f, 0.000000f, -0.809017f, 0.587785f, 0.000000f, 0.683427f, 0.546490f,
+		-0.851981f, 0.499769f, 0.156077f, 0.000000f, -0.851981f, 0.499769f, 0.156077f, 0.590447f, 0.603956f,
+		-0.736685f, 0.650164f, 0.185961f, 0.000000f, -0.736685f, 0.650164f, 0.185961f, 0.496650f, 0.348235f,
+		-0.632156f, 0.684127f, 0.363797f, 0.000000f, -0.632156f, 0.684127f, 0.363797f, 0.408548f, 0.305095f,
+		-0.762354f, 0.548581f, 0.343331f, 0.000000f, -0.762354f, 0.548581f, 0.343331f, 0.497466f, 0.453510f,
+		-0.639949f, 0.568662f, 0.516806f, 0.000000f, -0.639949f, 0.568662f, 0.516806f, 0.761425f, 0.766840f,
+		-0.736685f, 0.650164f, 0.185961f, 0.000000f, -0.736685f, 0.650164f, 0.185961f, 0.496650f, 0.348235f,
+		-0.851981f, 0.499769f, 0.156077f, 0.000000f, -0.851981f, 0.499769f, 0.156077f, 0.590447f, 0.603956f,
+		-0.762354f, 0.548581f, 0.343331f, 0.000000f, -0.762354f, 0.548581f, 0.343331f, 0.497466f, 0.453510f,
+		-0.343074f, 0.784354f, 0.516806f, 0.000000f, -0.343074f, 0.784354f, 0.516806f, 0.268343f, 0.699071f,
+		-0.455297f, 0.812623f, 0.363797f, 0.000000f, -0.455297f, 0.812623f, 0.363797f, 0.590447f, 0.396044f,
+		-0.500000f, 0.688191f, 0.525731f, 0.000000f, -0.500000f, 0.688191f, 0.525731f, 0.826527f, 0.699071f,
+		-0.577350f, 0.794655f, 0.187593f, 0.000000f, -0.577350f, 0.794655f, 0.187593f, 0.418781f, 0.222239f,
+		-0.632156f, 0.684127f, 0.363797f, 0.000000f, -0.632156f, 0.684127f, 0.363797f, 0.408548f, 0.305095f,
+		-0.455297f, 0.812623f, 0.363797f, 0.000000f, -0.455297f, 0.812623f, 0.363797f, 0.590447f, 0.396044f,
+		-0.669131f, 0.743144f, 0.000000f, 0.000000f, -0.669131f, 0.743144f, 0.000000f, 0.497466f, 0.250141f,
+		-0.736685f, 0.650164f, 0.185961f, 0.000000f, -0.736685f, 0.650164f, 0.185961f, 0.496650f, 0.348235f,
+		-0.577350f, 0.794655f, 0.187593f, 0.000000f, -0.577350f, 0.794655f, 0.187593f, 0.418781f, 0.222239f,
+		-0.738585f, 0.655845f, -0.156077f, 0.000000f, -0.738585f, 0.655845f, -0.156077f, 0.762112f, 0.497855f,
+		-0.809017f, 0.587785f, 0.000000f, 0.000000f, -0.809017f, 0.587785f, 0.000000f, 0.683427f, 0.546490f,
+		-0.669131f, 0.743144f, 0.000000f, 0.000000f, -0.669131f, 0.743144f, 0.000000f, 0.497466f, 0.250141f,
+		-0.455297f, 0.812623f, 0.363797f, 0.000000f, -0.455297f, 0.812623f, 0.363797f, 0.590447f, 0.396044f,
+		-0.632156f, 0.684127f, 0.363797f, 0.000000f, -0.632156f, 0.684127f, 0.363797f, 0.408548f, 0.305095f,
+		-0.500000f, 0.688191f, 0.525731f, 0.000000f, -0.500000f, 0.688191f, 0.525731f, 0.826527f, 0.699071f,
+		-0.577350f, 0.794655f, 0.187593f, 0.000000f, -0.577350f, 0.794655f, 0.187593f, 0.418781f, 0.222239f,
+		-0.736685f, 0.650164f, 0.185961f, 0.000000f, -0.736685f, 0.650164f, 0.185961f, 0.496650f, 0.348235f,
+		-0.632156f, 0.684127f, 0.363797f, 0.000000f, -0.632156f, 0.684127f, 0.363797f, 0.408548f, 0.305095f,
+		-0.669131f, 0.743144f, 0.000000f, 0.000000f, -0.669131f, 0.743144f, 0.000000f, 0.497466f, 0.250141f,
+		-0.809017f, 0.587785f, 0.000000f, 0.000000f, -0.809017f, 0.587785f, 0.000000f, 0.683427f, 0.546490f,
+		-0.736685f, 0.650164f, 0.185961f, 0.000000f, -0.736685f, 0.650164f, 0.185961f, 0.496650f, 0.348235f,
+		-0.174499f, 0.853887f, 0.490334f, 0.000000f, -0.174499f, 0.853887f, 0.490334f, 0.500000f, 0.836442f,
+		-0.286151f, 0.894562f, 0.343331f, 0.000000f, -0.286151f, 0.894562f, 0.343331f, 0.590447f, 0.296632f,
+		-0.343074f, 0.784354f, 0.516806f, 0.000000f, -0.343074f, 0.784354f, 0.516806f, 0.268343f, 0.699071f,
+		-0.286151f, 0.894562f, 0.343331f, 0.000000f, -0.286151f, 0.894562f, 0.343331f, 0.590447f, 0.296632f,
+		-0.390694f, 0.901541f, 0.185961f, 0.000000f, -0.390694f, 0.901541f, 0.185961f, 0.669136f, 0.347417f,
+		-0.455297f, 0.812623f, 0.363797f, 0.000000f, -0.455297f, 0.812623f, 0.363797f, 0.590447f, 0.396044f,
+		-0.390694f, 0.901541f, 0.185961f, 0.000000f, -0.390694f, 0.901541f, 0.185961f, 0.669136f, 0.347417f,
+		-0.499999f, 0.866026f, 0.000000f, 0.000000f, -0.499999f, 0.866026f, 0.000000f, 0.437019f, 0.149181f,
+		-0.577350f, 0.794655f, 0.187593f, 0.000000f, -0.577350f, 0.794655f, 0.187593f, 0.418781f, 0.222239f,
+		-0.580460f, 0.798935f, -0.157379f, 0.000000f, -0.580460f, 0.798935f, -0.157379f, 0.643075f, 0.418781f,
+		-0.669131f, 0.743144f, 0.000000f, 0.000000f, -0.669131f, 0.743144f, 0.000000f, 0.497466f, 0.250141f,
+		-0.499999f, 0.866026f, 0.000000f, 0.000000f, -0.499999f, 0.866026f, 0.000000f, 0.437019f, 0.149181f,
+		-0.580460f, 0.798935f, -0.157379f, 0.000000f, -0.580460f, 0.798935f, -0.157379f, 0.643075f, 0.418781f,
+		-0.643075f, 0.701637f, -0.306855f, 0.000000f, -0.643075f, 0.701637f, -0.306855f, 0.821537f, 0.437019f,
+		-0.738585f, 0.655845f, -0.156077f, 0.000000f, -0.738585f, 0.655845f, -0.156077f, 0.762112f, 0.497855f,
+		-0.286151f, 0.894562f, 0.343331f, 0.000000f, -0.286151f, 0.894562f, 0.343331f, 0.590447f, 0.296632f,
+		-0.455297f, 0.812623f, 0.363797f, 0.000000f, -0.455297f, 0.812623f, 0.363797f, 0.590447f, 0.396044f,
+		-0.343074f, 0.784354f, 0.516806f, 0.000000f, -0.343074f, 0.784354f, 0.516806f, 0.268343f, 0.699071f,
+		-0.390694f, 0.901541f, 0.185961f, 0.000000f, -0.390694f, 0.901541f, 0.185961f, 0.669136f, 0.347417f,
+		-0.577350f, 0.794655f, 0.187593f, 0.000000f, -0.577350f, 0.794655f, 0.187593f, 0.418781f, 0.222239f,
+		-0.455297f, 0.812623f, 0.363797f, 0.000000f, -0.455297f, 0.812623f, 0.363797f, 0.590447f, 0.396044f,
+		-0.499999f, 0.866026f, 0.000000f, 0.000000f, -0.499999f, 0.866026f, 0.000000f, 0.437019f, 0.149181f,
+		-0.669131f, 0.743144f, 0.000000f, 0.000000f, -0.669131f, 0.743144f, 0.000000f, 0.497466f, 0.250141f,
+		-0.577350f, 0.794655f, 0.187593f, 0.000000f, -0.577350f, 0.794655f, 0.187593f, 0.418781f, 0.222239f,
+		-0.580460f, 0.798935f, -0.157379f, 0.000000f, -0.580460f, 0.798935f, -0.157379f, 0.643075f, 0.418781f,
+		-0.738585f, 0.655845f, -0.156077f, 0.000000f, -0.738585f, 0.655845f, -0.156077f, 0.762112f, 0.497855f,
+		-0.669131f, 0.743144f, 0.000000f, 0.000000f, -0.669131f, 0.743144f, 0.000000f, 0.497466f, 0.250141f,
+		0.000000f, 0.894427f, 0.447214f, 0.000000f, 0.000000f, 0.894427f, 0.447214f, 0.268343f, 0.250971f,
+		-0.107846f, 0.945626f, 0.306855f, 0.000000f, -0.107846f, 0.945626f, 0.306855f, 0.869292f, 0.512408f,
+		-0.174499f, 0.853887f, 0.490334f, 0.000000f, -0.174499f, 0.853887f, 0.490334f, 0.500000f, 0.836442f,
+		-0.107846f, 0.945626f, 0.306855f, 0.000000f, -0.107846f, 0.945626f, 0.306855f, 0.869292f, 0.512408f,
+		-0.212031f, 0.964719f, 0.156077f, 0.000000f, -0.212031f, 0.964719f, 0.156077f, 0.512408f, 0.172078f,
+		-0.286151f, 0.894562f, 0.343331f, 0.000000f, -0.286151f, 0.894562f, 0.343331f, 0.590447f, 0.296632f,
+		-0.212031f, 0.964719f, 0.156077f, 0.000000f, -0.212031f, 0.964719f, 0.156077f, 0.512408f, 0.172078f,
+		-0.309017f, 0.951057f, 0.000000f, 0.000000f, -0.309017f, 0.951057f, 0.000000f, 0.590447f, 0.128428f,
+		-0.390694f, 0.901541f, 0.185961f, 0.000000f, -0.390694f, 0.901541f, 0.185961f, 0.669136f, 0.347417f,
+		-0.395510f, 0.905103f, -0.156077f, 0.000000f, -0.395510f, 0.905103f, -0.156077f, 0.590447f, 0.206107f,
+		-0.499999f, 0.866026f, 0.000000f, 0.000000f, -0.499999f, 0.866026f, 0.000000f, 0.437019f, 0.149181f,
+		-0.309017f, 0.951057f, 0.000000f, 0.000000f, -0.309017f, 0.951057f, 0.000000f, 0.590447f, 0.128428f,
+		-0.468576f, 0.828418f, -0.306855f, 0.000000f, -0.468576f, 0.828418f, -0.306855f, 0.668485f, 0.250116f,
+		-0.580460f, 0.798935f, -0.157379f, 0.000000f, -0.580460f, 0.798935f, -0.157379f, 0.643075f, 0.418781f,
+		-0.395510f, 0.905103f, -0.156077f, 0.000000f, -0.395510f, 0.905103f, -0.156077f, 0.590447f, 0.206107f,
+		-0.525731f, 0.723607f, -0.447214f, 0.000000f, -0.525731f, 0.723607f, -0.447214f, 0.446077f, 0.574219f,
+		-0.643075f, 0.701637f, -0.306855f, 0.000000f, -0.643075f, 0.701637f, -0.306855f, 0.821537f, 0.437019f,
+		-0.468576f, 0.828418f, -0.306855f, 0.000000f, -0.468576f, 0.828418f, -0.306855f, 0.668485f, 0.250116f,
+		-0.107846f, 0.945626f, 0.306855f, 0.000000f, -0.107846f, 0.945626f, 0.306855f, 0.869292f, 0.512408f,
+		-0.286151f, 0.894562f, 0.343331f, 0.000000f, -0.286151f, 0.894562f, 0.343331f, 0.590447f, 0.296632f,
+		-0.174499f, 0.853887f, 0.490334f, 0.000000f, -0.174499f, 0.853887f, 0.490334f, 0.500000f, 0.836442f,
+		-0.212031f, 0.964719f, 0.156077f, 0.000000f, -0.212031f, 0.964719f, 0.156077f, 0.512408f, 0.172078f,
+		-0.390694f, 0.901541f, 0.185961f, 0.000000f, -0.390694f, 0.901541f, 0.185961f, 0.669136f, 0.347417f,
+		-0.286151f, 0.894562f, 0.343331f, 0.000000f, -0.286151f, 0.894562f, 0.343331f, 0.590447f, 0.296632f,
+		-0.309017f, 0.951057f, 0.000000f, 0.000000f, -0.309017f, 0.951057f, 0.000000f, 0.590447f, 0.128428f,
+		-0.499999f, 0.866026f, 0.000000f, 0.000000f, -0.499999f, 0.866026f, 0.000000f, 0.437019f, 0.149181f,
+		-0.390694f, 0.901541f, 0.185961f, 0.000000f, -0.390694f, 0.901541f, 0.185961f, 0.669136f, 0.347417f,
+		-0.395510f, 0.905103f, -0.156077f, 0.000000f, -0.395510f, 0.905103f, -0.156077f, 0.590447f, 0.206107f,
+		-0.580460f, 0.798935f, -0.157379f, 0.000000f, -0.580460f, 0.798935f, -0.157379f, 0.643075f, 0.418781f,
+		-0.499999f, 0.866026f, 0.000000f, 0.000000f, -0.499999f, 0.866026f, 0.000000f, 0.437019f, 0.149181f,
+		-0.468576f, 0.828418f, -0.306855f, 0.000000f, -0.468576f, 0.828418f, -0.306855f, 0.668485f, 0.250116f,
+		-0.643075f, 0.701637f, -0.306855f, 0.000000f, -0.643075f, 0.701637f, -0.306855f, 0.821537f, 0.437019f,
+		-0.580460f, 0.798935f, -0.157379f, 0.000000f, -0.580460f, 0.798935f, -0.157379f, 0.643075f, 0.418781f,
+		-0.643075f, -0.701637f, 0.306855f, 0.000000f, -0.643075f, -0.701637f, 0.306855f, 0.500000f, 0.511757f,
+		-0.525731f, -0.723607f, 0.447214f, 0.000000f, -0.525731f, -0.723607f, 0.447214f, 0.321589f, 0.745561f,
+		-0.643075f, -0.588241f, 0.490334f, 0.000000f, -0.643075f, -0.588241f, 0.490334f, 0.411570f, 0.803612f,
+		-0.757312f, -0.555521f, 0.343331f, 0.000000f, -0.757312f, -0.555521f, 0.343331f, 0.727648f, 0.408548f,
+		-0.643075f, -0.588241f, 0.490334f, 0.000000f, -0.643075f, -0.588241f, 0.490334f, 0.411570f, 0.803612f,
+		-0.738585f, -0.432902f, 0.516806f, 0.000000f, -0.738585f, -0.432902f, 0.516806f, 0.250000f, 0.581230f,
+		-0.738585f, -0.655845f, 0.156077f, 0.000000f, -0.738585f, -0.655845f, 0.156077f, 0.552265f, 0.590447f,
+		-0.643075f, -0.701637f, 0.306855f, 0.000000f, -0.643075f, -0.701637f, 0.306855f, 0.500000f, 0.511757f,
+		-0.757312f, -0.555521f, 0.343331f, 0.000000f, -0.757312f, -0.555521f, 0.343331f, 0.727648f, 0.408548f,
+		-0.757312f, -0.555521f, 0.343331f, 0.000000f, -0.757312f, -0.555521f, 0.343331f, 0.727648f, 0.408548f,
+		-0.643075f, -0.701637f, 0.306855f, 0.000000f, -0.643075f, -0.701637f, 0.306855f, 0.500000f, 0.511757f,
+		-0.643075f, -0.588241f, 0.490334f, 0.000000f, -0.643075f, -0.588241f, 0.490334f, 0.411570f, 0.803612f,
+		-0.845991f, -0.389809f, 0.363797f, 0.000000f, -0.845991f, -0.389809f, 0.363797f, 0.695347f, 0.497466f,
+		-0.738585f, -0.432902f, 0.516806f, 0.000000f, -0.738585f, -0.432902f, 0.516806f, 0.250000f, 0.581230f,
+		-0.809017f, -0.262865f, 0.525731f, 0.000000f, -0.809017f, -0.262865f, 0.525731f, 0.327004f, 0.649190f,
+		-0.845991f, -0.499718f, 0.185961f, 0.000000f, -0.845991f, -0.499718f, 0.185961f, 0.816078f, 0.408548f,
+		-0.757312f, -0.555521f, 0.343331f, 0.000000f, -0.757312f, -0.555521f, 0.343331f, 0.727648f, 0.408548f,
+		-0.845991f, -0.389809f, 0.363797f, 0.000000f, -0.845991f, -0.389809f, 0.363797f, 0.695347f, 0.497466f,
+		-0.809017f, -0.587785f, 0.000000f, 0.000000f, -0.809017f, -0.587785f, 0.000000f, 0.554653f, 0.772345f,
+		-0.738585f, -0.655845f, 0.156077f, 0.000000f, -0.738585f, -0.655845f, 0.156077f, 0.552265f, 0.590447f,
+		-0.845991f, -0.499718f, 0.185961f, 0.000000f, -0.845991f, -0.499718f, 0.185961f, 0.816078f, 0.408548f,
+		-0.845991f, -0.389809f, 0.363797f, 0.000000f, -0.845991f, -0.389809f, 0.363797f, 0.695347f, 0.497466f,
+		-0.757312f, -0.555521f, 0.343331f, 0.000000f, -0.757312f, -0.555521f, 0.343331f, 0.727648f, 0.408548f,
+		-0.738585f, -0.432902f, 0.516806f, 0.000000f, -0.738585f, -0.432902f, 0.516806f, 0.250000f, 0.581230f,
+		-0.845991f, -0.499718f, 0.185961f, 0.000000f, -0.845991f, -0.499718f, 0.185961f, 0.816078f, 0.408548f,
+		-0.738585f, -0.655845f, 0.156077f, 0.000000f, -0.738585f, -0.655845f, 0.156077f, 0.552265f, 0.590447f,
+		-0.757312f, -0.555521f, 0.343331f, 0.000000f, -0.757312f, -0.555521f, 0.343331f, 0.727648f, 0.408548f,
+		-0.851981f, -0.083904f, 0.516806f, 0.000000f, -0.851981f, -0.083904f, 0.516806f, 0.411570f, 0.710631f,
+		-0.913545f, -0.181898f, 0.363797f, 0.000000f, -0.913545f, -0.181898f, 0.363797f, 0.788675f, 0.496650f,
+		-0.809017f, -0.262865f, 0.525731f, 0.000000f, -0.809017f, -0.262865f, 0.525731f, 0.327004f, 0.649190f,
+		-0.934172f, -0.303531f, 0.187593f, 0.000000f, -0.934172f, -0.303531f, 0.187593f, 0.418781f, 0.774291f,
+		-0.845991f, -0.389809f, 0.363797f, 0.000000f, -0.845991f, -0.389809f, 0.363797f, 0.695347f, 0.497466f,
+		-0.913545f, -0.181898f, 0.363797f, 0.000000f, -0.913545f, -0.181898f, 0.363797f, 0.788675f, 0.496650f,
+		-0.913545f, -0.406737f, 0.000000f, 0.000000f, -0.913545f, -0.406737f, 0.000000f, 0.497466f, 0.825082f,
+		-0.845991f, -0.499718f, 0.185961f, 0.000000f, -0.845991f, -0.499718f, 0.185961f, 0.816078f, 0.408548f,
+		-0.934172f, -0.303531f, 0.187593f, 0.000000f, -0.934172f, -0.303531f, 0.187593f, 0.418781f, 0.774291f,
+		-0.851981f, -0.499768f, -0.156077f, 0.000000f, -0.851981f, -0.499768f, -0.156077f, 0.734288f, 0.743874f,
+		-0.809017f, -0.587785f, 0.000000f, 0.000000f, -0.809017f, -0.587785f, 0.000000f, 0.554653f, 0.772345f,
+		-0.913545f, -0.406737f, 0.000000f, 0.000000f, -0.913545f, -0.406737f, 0.000000f, 0.497466f, 0.825082f,
+		-0.913545f, -0.181898f, 0.363797f, 0.000000f, -0.913545f, -0.181898f, 0.363797f, 0.788675f, 0.496650f,
+		-0.845991f, -0.389809f, 0.363797f, 0.000000f, -0.845991f, -0.389809f, 0.363797f, 0.695347f, 0.497466f,
+		-0.809017f, -0.262865f, 0.525731f, 0.000000f, -0.809017f, -0.262865f, 0.525731f, 0.327004f, 0.649190f,
+		-0.934172f, -0.303531f, 0.187593f, 0.000000f, -0.934172f, -0.303531f, 0.187593f, 0.418781f, 0.774291f,
+		-0.845991f, -0.499718f, 0.185961f, 0.000000f, -0.845991f, -0.499718f, 0.185961f, 0.816078f, 0.408548f,
+		-0.845991f, -0.389809f, 0.363797f, 0.000000f, -0.845991f, -0.389809f, 0.363797f, 0.695347f, 0.497466f,
+		-0.913545f, -0.406737f, 0.000000f, 0.000000f, -0.913545f, -0.406737f, 0.000000f, 0.497466f, 0.825082f,
+		-0.809017f, -0.587785f, 0.000000f, 0.000000f, -0.809017f, -0.587785f, 0.000000f, 0.554653f, 0.772345f,
+		-0.845991f, -0.499718f, 0.185961f, 0.000000f, -0.845991f, -0.499718f, 0.185961f, 0.816078f, 0.408548f,
+		-0.866018f, 0.097907f, 0.490334f, 0.000000f, -0.866018f, 0.097907f, 0.490334f, 0.328463f, 0.555736f,
+		-0.939205f, 0.004289f, 0.343331f, 0.000000f, -0.939205f, 0.004289f, 0.343331f, 0.408548f, 0.842063f,
+		-0.851981f, -0.083904f, 0.516806f, 0.000000f, -0.851981f, -0.083904f, 0.516806f, 0.411570f, 0.710631f,
+		-0.939205f, 0.004289f, 0.343331f, 0.000000f, -0.939205f, 0.004289f, 0.343331f, 0.408548f, 0.842063f,
+		-0.978148f, -0.092980f, 0.185961f, 0.000000f, -0.978148f, -0.092980f, 0.185961f, 0.868343f, 0.497466f,
+		-0.913545f, -0.181898f, 0.363797f, 0.000000f, -0.913545f, -0.181898f, 0.363797f, 0.788675f, 0.496650f,
+		-0.978148f, -0.092980f, 0.185961f, 0.000000f, -0.978148f, -0.092980f, 0.185961f, 0.868343f, 0.497466f,
+		-0.978148f, -0.207911f, 0.000000f, 0.000000f, -0.978148f, -0.207911f, 0.000000f, 0.790231f, 0.669136f,
+		-0.934172f, -0.303531f, 0.187593f, 0.000000f, -0.934172f, -0.303531f, 0.187593f, 0.418781f, 0.774291f,
+		-0.939205f, -0.305166f, -0.157379f, 0.000000f, -0.939205f, -0.305166f, -0.157379f, 0.590447f, 0.871572f,
+		-0.913545f, -0.406737f, 0.000000f, 0.000000f, -0.913545f, -0.406737f, 0.000000f, 0.497466f, 0.825082f,
+		-0.978148f, -0.207911f, 0.000000f, 0.000000f, -0.978148f, -0.207911f, 0.000000f, 0.790231f, 0.669136f,
+		-0.939205f, -0.305166f, -0.157379f, 0.000000f, -0.939205f, -0.305166f, -0.157379f, 0.590447f, 0.871572f,
+		-0.866018f, -0.394782f, -0.306855f, 0.000000f, -0.866018f, -0.394782f, -0.306855f, 0.512408f, 0.749884f,
+		-0.851981f, -0.499768f, -0.156077f, 0.000000f, -0.851981f, -0.499768f, -0.156077f, 0.734288f, 0.743874f,
+		-0.939205f, 0.004289f, 0.343331f, 0.000000f, -0.939205f, 0.004289f, 0.343331f, 0.408548f, 0.842063f,
+		-0.913545f, -0.181898f, 0.363797f, 0.000000f, -0.913545f, -0.181898f, 0.363797f, 0.788675f, 0.496650f,
+		-0.851981f, -0.083904f, 0.516806f, 0.000000f, -0.851981f, -0.083904f, 0.516806f, 0.411570f, 0.710631f,
+		-0.978148f, -0.092980f, 0.185961f, 0.000000f, -0.978148f, -0.092980f, 0.185961f, 0.868343f, 0.497466f,
+		-0.934172f, -0.303531f, 0.187593f, 0.000000f, -0.934172f, -0.303531f, 0.187593f, 0.418781f, 0.774291f,
+		-0.913545f, -0.181898f, 0.363797f, 0.000000f, -0.913545f, -0.181898f, 0.363797f, 0.788675f, 0.496650f,
+		-0.978148f, -0.207911f, 0.000000f, 0.000000f, -0.978148f, -0.207911f, 0.000000f, 0.790231f, 0.669136f,
+		-0.913545f, -0.406737f, 0.000000f, 0.000000f, -0.913545f, -0.406737f, 0.000000f, 0.497466f, 0.825082f,
+		-0.934172f, -0.303531f, 0.187593f, 0.000000f, -0.934172f, -0.303531f, 0.187593f, 0.418781f, 0.774291f,
+		-0.939205f, -0.305166f, -0.157379f, 0.000000f, -0.939205f, -0.305166f, -0.157379f, 0.590447f, 0.871572f,
+		-0.851981f, -0.499768f, -0.156077f, 0.000000f, -0.851981f, -0.499768f, -0.156077f, 0.734288f, 0.743874f,
+		-0.913545f, -0.406737f, 0.000000f, 0.000000f, -0.913545f, -0.406737f, 0.000000f, 0.497466f, 0.825082f,
+		-0.850651f, 0.276393f, 0.447214f, 0.000000f, -0.850651f, 0.276393f, 0.447214f, 0.588426f, 0.872062f,
+		-0.932670f, 0.189647f, 0.306855f, 0.000000f, -0.932670f, 0.189647f, 0.306855f, 0.590447f, 0.793893f,
+		-0.866018f, 0.097907f, 0.490334f, 0.000000f, -0.866018f, 0.097907f, 0.490334f, 0.328463f, 0.555736f,
+		-0.932670f, 0.189647f, 0.306855f, 0.000000f, -0.932670f, 0.189647f, 0.306855f, 0.590447f, 0.793893f,
+		-0.983024f, 0.096461f, 0.156077f, 0.000000f, -0.983024f, 0.096461f, 0.156077f, 0.668485f, 0.827922f,
+		-0.939205f, 0.004289f, 0.343331f, 0.000000f, -0.939205f, 0.004289f, 0.343331f, 0.408548f, 0.842063f,
+		-0.983024f, 0.096461f, 0.156077f, 0.000000f, -0.983024f, 0.096461f, 0.156077f, 0.668485f, 0.827922f,
+		-1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.743874f, 0.850819f,
+		-0.978148f, -0.092980f, 0.185961f, 0.000000f, -0.978148f, -0.092980f, 0.185961f, 0.868343f, 0.497466f,
+		-0.983024f, -0.096460f, -0.156077f, 0.000000f, -0.983024f, -0.096460f, -0.156077f, 0.821537f, 0.743874f,
+		-0.978148f, -0.207911f, 0.000000f, 0.000000f, -0.978148f, -0.207911f, 0.000000f, 0.790231f, 0.669136f,
+		-1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.743874f, 0.850819f,
+		-0.932670f, -0.189647f, -0.306855f, 0.000000f, -0.932670f, -0.189647f, -0.306855f, 0.437019f, 0.594823f,
+		-0.939205f, -0.305166f, -0.157379f, 0.000000f, -0.939205f, -0.305166f, -0.157379f, 0.590447f, 0.871572f,
+		-0.983024f, -0.096460f, -0.156077f, 0.000000f, -0.983024f, -0.096460f, -0.156077f, 0.821537f, 0.743874f,
+		-0.850651f, -0.276393f, -0.447214f, 0.000000f, -0.850651f, -0.276393f, -0.447214f, 0.445347f, 0.922791f,
+		-0.866018f, -0.394782f, -0.306855f, 0.000000f, -0.866018f, -0.394782f, -0.306855f, 0.512408f, 0.749884f,
+		-0.932670f, -0.189647f, -0.306855f, 0.000000f, -0.932670f, -0.189647f, -0.306855f, 0.437019f, 0.594823f,
+		-0.932670f, 0.189647f, 0.306855f, 0.000000f, -0.932670f, 0.189647f, 0.306855f, 0.590447f, 0.793893f,
+		-0.939205f, 0.004289f, 0.343331f, 0.000000f, -0.939205f, 0.004289f, 0.343331f, 0.408548f, 0.842063f,
+		-0.866018f, 0.097907f, 0.490334f, 0.000000f, -0.866018f, 0.097907f, 0.490334f, 0.328463f, 0.555736f,
+		-0.983024f, 0.096461f, 0.156077f, 0.000000f, -0.983024f, 0.096461f, 0.156077f, 0.668485f, 0.827922f,
+		-0.978148f, -0.092980f, 0.185961f, 0.000000f, -0.978148f, -0.092980f, 0.185961f, 0.868343f, 0.497466f,
+		-0.939205f, 0.004289f, 0.343331f, 0.000000f, -0.939205f, 0.004289f, 0.343331f, 0.408548f, 0.842063f,
+		-1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.743874f, 0.850819f,
+		-0.978148f, -0.207911f, 0.000000f, 0.000000f, -0.978148f, -0.207911f, 0.000000f, 0.790231f, 0.669136f,
+		-0.978148f, -0.092980f, 0.185961f, 0.000000f, -0.978148f, -0.092980f, 0.185961f, 0.868343f, 0.497466f,
+		-0.983024f, -0.096460f, -0.156077f, 0.000000f, -0.983024f, -0.096460f, -0.156077f, 0.821537f, 0.743874f,
+		-0.939205f, -0.305166f, -0.157379f, 0.000000f, -0.939205f, -0.305166f, -0.157379f, 0.590447f, 0.871572f,
+		-0.978148f, -0.207911f, 0.000000f, 0.000000f, -0.978148f, -0.207911f, 0.000000f, 0.790231f, 0.669136f,
+		-0.932670f, -0.189647f, -0.306855f, 0.000000f, -0.932670f, -0.189647f, -0.306855f, 0.437019f, 0.594823f,
+		-0.866018f, -0.394782f, -0.306855f, 0.000000f, -0.866018f, -0.394782f, -0.306855f, 0.512408f, 0.749884f,
+		-0.939205f, -0.305166f, -0.157379f, 0.000000f, -0.939205f, -0.305166f, -0.157379f, 0.590447f, 0.871572f,
+		0.468576f, -0.828418f, 0.306855f, 0.000000f, 0.468576f, -0.828418f, 0.306855f, 0.178463f, 0.345280f,
+		0.525731f, -0.723607f, 0.447214f, 0.000000f, 0.525731f, -0.723607f, 0.447214f, 0.606016f, 0.354082f,
+		0.360730f, -0.793377f, 0.490334f, 0.000000f, 0.360730f, -0.793377f, 0.490334f, 0.446077f, 0.425781f,
+		0.294309f, -0.891911f, 0.343331f, 0.000000f, 0.294309f, -0.891911f, 0.343331f, 0.869292f, 0.668485f,
+		0.360730f, -0.793377f, 0.490334f, 0.000000f, 0.360730f, -0.793377f, 0.490334f, 0.446077f, 0.425781f,
+		0.183479f, -0.836210f, 0.516806f, 0.000000f, 0.183479f, -0.836210f, 0.516806f, 0.258102f, 0.766841f,
+		0.395510f, -0.905103f, 0.156077f, 0.000000f, 0.395510f, -0.905103f, 0.156077f, 0.131657f, 0.437784f,
+		0.468576f, -0.828418f, 0.306855f, 0.000000f, 0.468576f, -0.828418f, 0.306855f, 0.178463f, 0.345280f,
+		0.294309f, -0.891911f, 0.343331f, 0.000000f, 0.294309f, -0.891911f, 0.343331f, 0.869292f, 0.668485f,
+		0.294309f, -0.891911f, 0.343331f, 0.000000f, 0.294309f, -0.891911f, 0.343331f, 0.869292f, 0.668485f,
+		0.468576f, -0.828418f, 0.306855f, 0.000000f, 0.468576f, -0.828418f, 0.306855f, 0.178463f, 0.345280f,
+		0.360730f, -0.793377f, 0.490334f, 0.000000f, 0.360730f, -0.793377f, 0.490334f, 0.446077f, 0.425781f,
+		0.109305f, -0.925043f, 0.363797f, 0.000000f, 0.109305f, -0.925043f, 0.363797f, 0.183922f, 0.408548f,
+		0.183479f, -0.836210f, 0.516806f, 0.000000f, 0.183479f, -0.836210f, 0.516806f, 0.258102f, 0.766841f,
+		-0.000000f, -0.850651f, 0.525731f, 0.000000f, -0.000000f, -0.850651f, 0.525731f, 0.238575f, 0.258102f,
+		0.213834f, -0.959006f, 0.185961f, 0.000000f, 0.213834f, -0.959006f, 0.185961f, 0.272352f, 0.408548f,
+		0.294309f, -0.891911f, 0.343331f, 0.000000f, 0.294309f, -0.891911f, 0.343331f, 0.869292f, 0.668485f,
+		0.109305f, -0.925043f, 0.363797f, 0.000000f, 0.109305f, -0.925043f, 0.363797f, 0.183922f, 0.408548f,
+		0.309017f, -0.951057f, 0.000000f, 0.000000f, 0.309017f, -0.951057f, 0.000000f, 0.183922f, 0.509719f,
+		0.395510f, -0.905103f, 0.156077f, 0.000000f, 0.395510f, -0.905103f, 0.156077f, 0.131657f, 0.437784f,
+		0.213834f, -0.959006f, 0.185961f, 0.000000f, 0.213834f, -0.959006f, 0.185961f, 0.272352f, 0.408548f,
+		0.109305f, -0.925043f, 0.363797f, 0.000000f, 0.109305f, -0.925043f, 0.363797f, 0.183922f, 0.408548f,
+		0.294309f, -0.891911f, 0.343331f, 0.000000f, 0.294309f, -0.891911f, 0.343331f, 0.869292f, 0.668485f,
+		0.183479f, -0.836210f, 0.516806f, 0.000000f, 0.183479f, -0.836210f, 0.516806f, 0.258102f, 0.766841f,
+		0.213834f, -0.959006f, 0.185961f, 0.000000f, 0.213834f, -0.959006f, 0.185961f, 0.272352f, 0.408548f,
+		0.395510f, -0.905103f, 0.156077f, 0.000000f, 0.395510f, -0.905103f, 0.156077f, 0.131657f, 0.437784f,
+		0.294309f, -0.891911f, 0.343331f, 0.000000f, 0.294309f, -0.891911f, 0.343331f, 0.869292f, 0.668485f,
+		-0.183479f, -0.836210f, 0.516806f, 0.000000f, -0.183479f, -0.836210f, 0.516806f, 0.180025f, 0.332044f,
+		-0.109305f, -0.925043f, 0.363797f, 0.000000f, -0.109305f, -0.925043f, 0.363797f, 0.211325f, 0.496650f,
+		-0.000000f, -0.850651f, 0.525731f, 0.000000f, -0.000000f, -0.850651f, 0.525731f, 0.238575f, 0.258102f,
+		-0.109305f, -0.925043f, 0.363797f, 0.000000f, -0.109305f, -0.925043f, 0.363797f, 0.211325f, 0.496650f,
+		-0.000000f, -0.982247f, 0.187593f, 0.000000f, -0.000000f, -0.982247f, 0.187593f, 0.131658f, 0.497466f,
+		0.109305f, -0.925043f, 0.363797f, 0.000000f, 0.109305f, -0.925043f, 0.363797f, 0.183922f, 0.408548f,
+		0.104529f, -0.994522f, 0.000000f, 0.000000f, 0.104529f, -0.994522f, 0.000000f, 0.356925f, 0.418781f,
+		0.213834f, -0.959006f, 0.185961f, 0.000000f, 0.213834f, -0.959006f, 0.185961f, 0.272352f, 0.408548f,
+		-0.000000f, -0.982247f, 0.187593f, 0.000000f, -0.000000f, -0.982247f, 0.187593f, 0.131658f, 0.497466f,
+		0.104529f, -0.994522f, 0.000000f, 0.000000f, 0.104529f, -0.994522f, 0.000000f, 0.356925f, 0.418781f,
+		0.212032f, -0.964719f, -0.156077f, 0.000000f, 0.212032f, -0.964719f, -0.156077f, 0.272352f, 0.480987f,
+		0.309017f, -0.951057f, 0.000000f, 0.000000f, 0.309017f, -0.951057f, 0.000000f, 0.183922f, 0.509719f,
+		-0.109305f, -0.925043f, 0.363797f, 0.000000f, -0.109305f, -0.925043f, 0.363797f, 0.211325f, 0.496650f,
+		0.109305f, -0.925043f, 0.363797f, 0.000000f, 0.109305f, -0.925043f, 0.363797f, 0.183922f, 0.408548f,
+		-0.000000f, -0.850651f, 0.525731f, 0.000000f, -0.000000f, -0.850651f, 0.525731f, 0.238575f, 0.258102f,
+		-0.000000f, -0.982247f, 0.187593f, 0.000000f, -0.000000f, -0.982247f, 0.187593f, 0.131658f, 0.497466f,
+		0.213834f, -0.959006f, 0.185961f, 0.000000f, 0.213834f, -0.959006f, 0.185961f, 0.272352f, 0.408548f,
+		0.109305f, -0.925043f, 0.363797f, 0.000000f, 0.109305f, -0.925043f, 0.363797f, 0.183922f, 0.408548f,
+		0.104529f, -0.994522f, 0.000000f, 0.000000f, 0.104529f, -0.994522f, 0.000000f, 0.356925f, 0.418781f,
+		0.309017f, -0.951057f, 0.000000f, 0.000000f, 0.309017f, -0.951057f, 0.000000f, 0.183922f, 0.509719f,
+		0.213834f, -0.959006f, 0.185961f, 0.000000f, 0.213834f, -0.959006f, 0.185961f, 0.272352f, 0.408548f,
+		-0.360730f, -0.793377f, 0.490334f, 0.000000f, -0.360730f, -0.793377f, 0.490334f, 0.327004f, 0.258102f,
+		-0.294310f, -0.891911f, 0.343331f, 0.000000f, -0.294310f, -0.891911f, 0.343331f, 0.304653f, 0.497466f,
+		-0.183479f, -0.836210f, 0.516806f, 0.000000f, -0.183479f, -0.836210f, 0.516806f, 0.180025f, 0.332044f,
+		-0.294310f, -0.891911f, 0.343331f, 0.000000f, -0.294310f, -0.891911f, 0.343331f, 0.304653f, 0.497466f,
+		-0.213835f, -0.959006f, 0.185961f, 0.000000f, -0.213835f, -0.959006f, 0.185961f, 0.209770f, 0.669136f,
+		-0.109305f, -0.925043f, 0.363797f, 0.000000f, -0.109305f, -0.925043f, 0.363797f, 0.211325f, 0.496650f,
+		-0.213835f, -0.959006f, 0.185961f, 0.000000f, -0.213835f, -0.959006f, 0.185961f, 0.209770f, 0.669136f,
+		-0.104529f, -0.994522f, 0.000000f, 0.000000f, -0.104529f, -0.994522f, 0.000000f, 0.130708f, 0.668485f,
+		-0.000000f, -0.982247f, 0.187593f, 0.000000f, -0.000000f, -0.982247f, 0.187593f, 0.131658f, 0.497466f,
+		-0.104529f, -0.994522f, 0.000000f, 0.000000f, -0.104529f, -0.994522f, 0.000000f, 0.130708f, 0.668485f,
+		-0.000000f, -0.987538f, -0.157379f, 0.000000f, -0.000000f, -0.987538f, -0.157379f, 0.647155f, 0.418781f,
+		0.104529f, -0.994522f, 0.000000f, 0.000000f, 0.104529f, -0.994522f, 0.000000f, 0.356925f, 0.418781f,
+		-0.000000f, -0.987538f, -0.157379f, 0.000000f, -0.000000f, -0.987538f, -0.157379f, 0.647155f, 0.418781f,
+		0.107846f, -0.945626f, -0.306855f, 0.000000f, 0.107846f, -0.945626f, -0.306855f, 0.356925f, 0.453512f,
+		0.212032f, -0.964719f, -0.156077f, 0.000000f, 0.212032f, -0.964719f, -0.156077f, 0.272352f, 0.480987f,
+		-0.294310f, -0.891911f, 0.343331f, 0.000000f, -0.294310f, -0.891911f, 0.343331f, 0.304653f, 0.497466f,
+		-0.109305f, -0.925043f, 0.363797f, 0.000000f, -0.109305f, -0.925043f, 0.363797f, 0.211325f, 0.496650f,
+		-0.183479f, -0.836210f, 0.516806f, 0.000000f, -0.183479f, -0.836210f, 0.516806f, 0.180025f, 0.332044f,
+		-0.213835f, -0.959006f, 0.185961f, 0.000000f, -0.213835f, -0.959006f, 0.185961f, 0.209770f, 0.669136f,
+		-0.000000f, -0.982247f, 0.187593f, 0.000000f, -0.000000f, -0.982247f, 0.187593f, 0.131658f, 0.497466f,
+		-0.109305f, -0.925043f, 0.363797f, 0.000000f, -0.109305f, -0.925043f, 0.363797f, 0.211325f, 0.496650f,
+		-0.104529f, -0.994522f, 0.000000f, 0.000000f, -0.104529f, -0.994522f, 0.000000f, 0.130708f, 0.668485f,
+		0.104529f, -0.994522f, 0.000000f, 0.000000f, 0.104529f, -0.994522f, 0.000000f, 0.356925f, 0.418781f,
+		-0.000000f, -0.982247f, 0.187593f, 0.000000f, -0.000000f, -0.982247f, 0.187593f, 0.131658f, 0.497466f,
+		-0.000000f, -0.987538f, -0.157379f, 0.000000f, -0.000000f, -0.987538f, -0.157379f, 0.647155f, 0.418781f,
+		0.212032f, -0.964719f, -0.156077f, 0.000000f, 0.212032f, -0.964719f, -0.156077f, 0.272352f, 0.480987f,
+		0.104529f, -0.994522f, 0.000000f, 0.000000f, 0.104529f, -0.994522f, 0.000000f, 0.356925f, 0.418781f,
+		-0.525731f, -0.723607f, 0.447214f, 0.000000f, -0.525731f, -0.723607f, 0.447214f, 0.321589f, 0.745561f,
+		-0.468576f, -0.828418f, 0.306855f, 0.000000f, -0.468576f, -0.828418f, 0.306855f, 0.393984f, 0.512408f,
+		-0.360730f, -0.793377f, 0.490334f, 0.000000f, -0.360730f, -0.793377f, 0.490334f, 0.327004f, 0.258102f,
+		-0.468576f, -0.828418f, 0.306855f, 0.000000f, -0.468576f, -0.828418f, 0.306855f, 0.393984f, 0.512408f,
+		-0.395511f, -0.905103f, 0.156077f, 0.000000f, -0.395511f, -0.905103f, 0.156077f, 0.345491f, 0.590447f,
+		-0.294310f, -0.891911f, 0.343331f, 0.000000f, -0.294310f, -0.891911f, 0.343331f, 0.304653f, 0.497466f,
+		-0.395511f, -0.905103f, 0.156077f, 0.000000f, -0.395511f, -0.905103f, 0.156077f, 0.345491f, 0.590447f,
+		-0.309017f, -0.951056f, 0.000000f, 0.000000f, -0.309017f, -0.951056f, 0.000000f, 0.302245f, 0.668485f,
+		-0.213835f, -0.959006f, 0.185961f, 0.000000f, -0.213835f, -0.959006f, 0.185961f, 0.209770f, 0.669136f,
+		-0.212032f, -0.964719f, -0.156077f, 0.000000f, -0.212032f, -0.964719f, -0.156077f, 0.265712f, 0.743874f,
+		-0.104529f, -0.994522f, 0.000000f, 0.000000f, -0.104529f, -0.994522f, 0.000000f, 0.130708f, 0.668485f,
+		-0.309017f, -0.951056f, 0.000000f, 0.000000f, -0.309017f, -0.951056f, 0.000000f, 0.302245f, 0.668485f,
+		-0.107846f, -0.945626f, -0.306855f, 0.000000f, -0.107846f, -0.945626f, -0.306855f, 0.553923f, 0.437019f,
+		-0.000000f, -0.987538f, -0.157379f, 0.000000f, -0.000000f, -0.987538f, -0.157379f, 0.647155f, 0.418781f,
+		-0.212032f, -0.964719f, -0.156077f, 0.000000f, -0.212032f, -0.964719f, -0.156077f, 0.265712f, 0.743874f,
+		-0.107846f, -0.945626f, -0.306855f, 0.000000f, -0.107846f, -0.945626f, -0.306855f, 0.553923f, 0.437019f,
+		0.000000f, -0.894427f, -0.447214f, 0.000000f, 0.000000f, -0.894427f, -0.447214f, 0.848850f, 0.215669f,
+		0.107846f, -0.945626f, -0.306855f, 0.000000f, 0.107846f, -0.945626f, -0.306855f, 0.356925f, 0.453512f,
+		-0.468576f, -0.828418f, 0.306855f, 0.000000f, -0.468576f, -0.828418f, 0.306855f, 0.393984f, 0.512408f,
+		-0.294310f, -0.891911f, 0.343331f, 0.000000f, -0.294310f, -0.891911f, 0.343331f, 0.304653f, 0.497466f,
+		-0.360730f, -0.793377f, 0.490334f, 0.000000f, -0.360730f, -0.793377f, 0.490334f, 0.327004f, 0.258102f,
+		-0.395511f, -0.905103f, 0.156077f, 0.000000f, -0.395511f, -0.905103f, 0.156077f, 0.345491f, 0.590447f,
+		-0.213835f, -0.959006f, 0.185961f, 0.000000f, -0.213835f, -0.959006f, 0.185961f, 0.209770f, 0.669136f,
+		-0.294310f, -0.891911f, 0.343331f, 0.000000f, -0.294310f, -0.891911f, 0.343331f, 0.304653f, 0.497466f,
+		-0.309017f, -0.951056f, 0.000000f, 0.000000f, -0.309017f, -0.951056f, 0.000000f, 0.302245f, 0.668485f,
+		-0.104529f, -0.994522f, 0.000000f, 0.000000f, -0.104529f, -0.994522f, 0.000000f, 0.130708f, 0.668485f,
+		-0.213835f, -0.959006f, 0.185961f, 0.000000f, -0.213835f, -0.959006f, 0.185961f, 0.209770f, 0.669136f,
+		-0.212032f, -0.964719f, -0.156077f, 0.000000f, -0.212032f, -0.964719f, -0.156077f, 0.265712f, 0.743874f,
+		-0.000000f, -0.987538f, -0.157379f, 0.000000f, -0.000000f, -0.987538f, -0.157379f, 0.647155f, 0.418781f,
+		-0.104529f, -0.994522f, 0.000000f, 0.000000f, -0.104529f, -0.994522f, 0.000000f, 0.130708f, 0.668485f,
+		-0.107846f, -0.945626f, -0.306855f, 0.000000f, -0.107846f, -0.945626f, -0.306855f, 0.553923f, 0.437019f,
+		0.107846f, -0.945626f, -0.306855f, 0.000000f, 0.107846f, -0.945626f, -0.306855f, 0.356925f, 0.453512f,
+		-0.000000f, -0.987538f, -0.157379f, 0.000000f, -0.000000f, -0.987538f, -0.157379f, 0.647155f, 0.418781f};
+
+static const int detailed_sphere_indices[] =
+	{
+		0, 1, 2,
+		3, 4, 5,
+		6, 7, 8,
+		9, 10, 11,
+		12, 13, 14,
+		15, 16, 17,
+		18, 19, 20,
+		21, 22, 23,
+		24, 25, 26,
+		27, 28, 29,
+		30, 31, 32,
+		33, 34, 35,
+		36, 37, 38,
+		39, 40, 41,
+		42, 43, 44,
+		45, 46, 47,
+		48, 49, 50,
+		51, 52, 53,
+		54, 55, 56,
+		57, 58, 59,
+		60, 61, 62,
+		63, 64, 65,
+		66, 67, 68,
+		69, 70, 71,
+		72, 73, 74,
+		75, 76, 77,
+		78, 79, 80,
+		81, 82, 83,
+		84, 85, 86,
+		87, 88, 89,
+		90, 91, 92,
+		93, 94, 95,
+		96, 97, 98,
+		99, 100, 101,
+		102, 103, 104,
+		105, 106, 107,
+		108, 109, 110,
+		111, 112, 113,
+		114, 115, 116,
+		117, 118, 119,
+		120, 121, 122,
+		123, 124, 125,
+		126, 127, 128,
+		129, 130, 131,
+		132, 133, 134,
+		135, 136, 137,
+		138, 139, 140,
+		141, 142, 143,
+		144, 145, 146,
+		147, 148, 149,
+		150, 151, 152,
+		153, 154, 155,
+		156, 157, 158,
+		159, 160, 161,
+		162, 163, 164,
+		165, 166, 167,
+		168, 169, 170,
+		171, 172, 173,
+		174, 175, 176,
+		177, 178, 179,
+		180, 181, 182,
+		183, 184, 185,
+		186, 187, 188,
+		189, 190, 191,
+		192, 193, 194,
+		195, 196, 197,
+		198, 199, 200,
+		201, 202, 203,
+		204, 205, 206,
+		207, 208, 209,
+		210, 211, 212,
+		213, 214, 215,
+		216, 217, 218,
+		219, 220, 221,
+		222, 223, 224,
+		225, 226, 227,
+		228, 229, 230,
+		231, 232, 233,
+		234, 235, 236,
+		237, 238, 239,
+		240, 241, 242,
+		243, 244, 245,
+		246, 247, 248,
+		249, 250, 251,
+		252, 253, 254,
+		255, 256, 257,
+		258, 259, 260,
+		261, 262, 263,
+		264, 265, 266,
+		267, 268, 269,
+		270, 271, 272,
+		273, 274, 275,
+		276, 277, 278,
+		279, 280, 281,
+		282, 283, 284,
+		285, 286, 287,
+		288, 289, 290,
+		291, 292, 293,
+		294, 295, 296,
+		297, 298, 299,
+		300, 301, 302,
+		303, 304, 305,
+		306, 307, 308,
+		309, 310, 311,
+		312, 313, 314,
+		315, 316, 317,
+		318, 319, 320,
+		321, 322, 323,
+		324, 325, 326,
+		327, 328, 329,
+		330, 331, 332,
+		333, 334, 335,
+		336, 337, 338,
+		339, 340, 341,
+		342, 343, 344,
+		345, 346, 347,
+		348, 349, 350,
+		351, 352, 353,
+		354, 355, 356,
+		357, 358, 359,
+		360, 361, 362,
+		363, 364, 365,
+		366, 367, 368,
+		369, 370, 371,
+		372, 373, 374,
+		375, 376, 377,
+		378, 379, 380,
+		381, 382, 383,
+		384, 385, 386,
+		387, 388, 389,
+		390, 391, 392,
+		393, 394, 395,
+		396, 397, 398,
+		399, 400, 401,
+		402, 403, 404,
+		405, 406, 407,
+		408, 409, 410,
+		411, 412, 413,
+		414, 415, 416,
+		417, 418, 419,
+		420, 421, 422,
+		423, 424, 425,
+		426, 427, 428,
+		429, 430, 431,
+		432, 433, 434,
+		435, 436, 437,
+		438, 439, 440,
+		441, 442, 443,
+		444, 445, 446,
+		447, 448, 449,
+		450, 451, 452,
+		453, 454, 455,
+		456, 457, 458,
+		459, 460, 461,
+		462, 463, 464,
+		465, 466, 467,
+		468, 469, 470,
+		471, 472, 473,
+		474, 475, 476,
+		477, 478, 479,
+		480, 481, 482,
+		483, 484, 485,
+		486, 487, 488,
+		489, 490, 491,
+		492, 493, 494,
+		495, 496, 497,
+		498, 499, 500,
+		501, 502, 503,
+		504, 505, 506,
+		507, 508, 509,
+		510, 511, 512,
+		513, 514, 515,
+		516, 517, 518,
+		519, 520, 521,
+		522, 523, 524,
+		525, 526, 527,
+		528, 529, 530,
+		531, 532, 533,
+		534, 535, 536,
+		537, 538, 539,
+		540, 541, 542,
+		543, 544, 545,
+		546, 547, 548,
+		549, 550, 551,
+		552, 553, 554,
+		555, 556, 557,
+		558, 559, 560,
+		561, 562, 563,
+		564, 565, 566,
+		567, 568, 569,
+		570, 571, 572,
+		573, 574, 575,
+		576, 577, 578,
+		579, 580, 581,
+		582, 583, 584,
+		585, 586, 587,
+		588, 589, 590,
+		591, 592, 593,
+		594, 595, 596,
+		597, 598, 599,
+		600, 601, 602,
+		603, 604, 605,
+		606, 607, 608,
+		609, 610, 611,
+		612, 613, 614,
+		615, 616, 617,
+		618, 619, 620,
+		621, 622, 623,
+		624, 625, 626,
+		627, 628, 629,
+		630, 631, 632,
+		633, 634, 635,
+		636, 637, 638,
+		639, 640, 641,
+		642, 643, 644,
+		645, 646, 647,
+		648, 649, 650,
+		651, 652, 653,
+		654, 655, 656,
+		657, 658, 659,
+		660, 661, 662,
+		663, 664, 665,
+		666, 667, 668,
+		669, 670, 671,
+		672, 673, 674,
+		675, 676, 677,
+		678, 679, 680,
+		681, 682, 683,
+		684, 685, 686,
+		687, 688, 689,
+		690, 691, 692,
+		693, 694, 695,
+		696, 697, 698,
+		699, 700, 701,
+		702, 703, 704,
+		705, 706, 707,
+		708, 709, 710,
+		711, 712, 713,
+		714, 715, 716,
+		717, 718, 719,
+		720, 721, 722,
+		723, 724, 725,
+		726, 727, 728,
+		729, 730, 731,
+		732, 733, 734,
+		735, 736, 737,
+		738, 739, 740,
+		741, 742, 743,
+		744, 745, 746,
+		747, 748, 749,
+		750, 751, 752,
+		753, 754, 755,
+		756, 757, 758,
+		759, 760, 761,
+		762, 763, 764,
+		765, 766, 767,
+		768, 769, 770,
+		771, 772, 773,
+		774, 775, 776,
+		777, 778, 779,
+		780, 781, 782,
+		783, 784, 785,
+		786, 787, 788,
+		789, 790, 791,
+		792, 793, 794,
+		795, 796, 797,
+		798, 799, 800,
+		801, 802, 803,
+		804, 805, 806,
+		807, 808, 809,
+		810, 811, 812,
+		813, 814, 815,
+		816, 817, 818,
+		819, 820, 821,
+		822, 823, 824,
+		825, 826, 827,
+		828, 829, 830,
+		831, 832, 833,
+		834, 835, 836,
+		837, 838, 839,
+		840, 841, 842,
+		843, 844, 845,
+		846, 847, 848,
+		849, 850, 851,
+		852, 853, 854,
+		855, 856, 857,
+		858, 859, 860,
+		861, 862, 863,
+		864, 865, 866,
+		867, 868, 869,
+		870, 871, 872,
+		873, 874, 875,
+		876, 877, 878,
+		879, 880, 881,
+		882, 883, 884,
+		885, 886, 887,
+		888, 889, 890,
+		891, 892, 893,
+		894, 895, 896,
+		897, 898, 899,
+		900, 901, 902,
+		903, 904, 905,
+		906, 907, 908,
+		909, 910, 911,
+		912, 913, 914,
+		915, 916, 917,
+		918, 919, 920,
+		921, 922, 923,
+		924, 925, 926,
+		927, 928, 929,
+		930, 931, 932,
+		933, 934, 935,
+		936, 937, 938,
+		939, 940, 941,
+		942, 943, 944,
+		945, 946, 947,
+		948, 949, 950,
+		951, 952, 953,
+		954, 955, 956,
+		957, 958, 959,
+		960, 961, 962,
+		963, 964, 965,
+		966, 967, 968,
+		969, 970, 971,
+		972, 973, 974,
+		975, 976, 977,
+		978, 979, 980,
+		981, 982, 983,
+		984, 985, 986,
+		987, 988, 989,
+		990, 991, 992,
+		993, 994, 995,
+		996, 997, 998,
+		999, 1000, 1001,
+		1002, 1003, 1004,
+		1005, 1006, 1007,
+		1008, 1009, 1010,
+		1011, 1012, 1013,
+		1014, 1015, 1016,
+		1017, 1018, 1019,
+		1020, 1021, 1022,
+		1023, 1024, 1025,
+		1026, 1027, 1028,
+		1029, 1030, 1031,
+		1032, 1033, 1034,
+		1035, 1036, 1037,
+		1038, 1039, 1040,
+		1041, 1042, 1043,
+		1044, 1045, 1046,
+		1047, 1048, 1049,
+		1050, 1051, 1052,
+		1053, 1054, 1055,
+		1056, 1057, 1058,
+		1059, 1060, 1061,
+		1062, 1063, 1064,
+		1065, 1066, 1067,
+		1068, 1069, 1070,
+		1071, 1072, 1073,
+		1074, 1075, 1076,
+		1077, 1078, 1079,
+		1080, 1081, 1082,
+		1083, 1084, 1085,
+		1086, 1087, 1088,
+		1089, 1090, 1091,
+		1092, 1093, 1094,
+		1095, 1096, 1097,
+		1098, 1099, 1100,
+		1101, 1102, 1103,
+		1104, 1105, 1106,
+		1107, 1108, 1109,
+		1110, 1111, 1112,
+		1113, 1114, 1115,
+		1116, 1117, 1118,
+		1119, 1120, 1121,
+		1122, 1123, 1124,
+		1125, 1126, 1127,
+		1128, 1129, 1130,
+		1131, 1132, 1133,
+		1134, 1135, 1136,
+		1137, 1138, 1139,
+		1140, 1141, 1142,
+		1143, 1144, 1145,
+		1146, 1147, 1148,
+		1149, 1150, 1151,
+		1152, 1153, 1154,
+		1155, 1156, 1157,
+		1158, 1159, 1160,
+		1161, 1162, 1163,
+		1164, 1165, 1166,
+		1167, 1168, 1169,
+		1170, 1171, 1172,
+		1173, 1174, 1175,
+		1176, 1177, 1178,
+		1179, 1180, 1181,
+		1182, 1183, 1184,
+		1185, 1186, 1187,
+		1188, 1189, 1190,
+		1191, 1192, 1193,
+		1194, 1195, 1196,
+		1197, 1198, 1199,
+		1200, 1201, 1202,
+		1203, 1204, 1205,
+		1206, 1207, 1208,
+		1209, 1210, 1211,
+		1212, 1213, 1214,
+		1215, 1216, 1217,
+		1218, 1219, 1220,
+		1221, 1222, 1223,
+		1224, 1225, 1226,
+		1227, 1228, 1229,
+		1230, 1231, 1232,
+		1233, 1234, 1235,
+		1236, 1237, 1238,
+		1239, 1240, 1241,
+		1242, 1243, 1244,
+		1245, 1246, 1247,
+		1248, 1249, 1250,
+		1251, 1252, 1253,
+		1254, 1255, 1256,
+		1257, 1258, 1259,
+		1260, 1261, 1262,
+		1263, 1264, 1265,
+		1266, 1267, 1268,
+		1269, 1270, 1271,
+		1272, 1273, 1274,
+		1275, 1276, 1277,
+		1278, 1279, 1280,
+		1281, 1282, 1283,
+		1284, 1285, 1286,
+		1287, 1288, 1289,
+		1290, 1291, 1292,
+		1293, 1294, 1295,
+		1296, 1297, 1298,
+		1299, 1300, 1301,
+		1302, 1303, 1304,
+		1305, 1306, 1307,
+		1308, 1309, 1310,
+		1311, 1312, 1313,
+		1314, 1315, 1316,
+		1317, 1318, 1319,
+		1320, 1321, 1322,
+		1323, 1324, 1325,
+		1326, 1327, 1328,
+		1329, 1330, 1331,
+		1332, 1333, 1334,
+		1335, 1336, 1337,
+		1338, 1339, 1340,
+		1341, 1342, 1343,
+		1344, 1345, 1346,
+		1347, 1348, 1349,
+		1350, 1351, 1352,
+		1353, 1354, 1355,
+		1356, 1357, 1358,
+		1359, 1360, 1361,
+		1362, 1363, 1364,
+		1365, 1366, 1367,
+		1368, 1369, 1370,
+		1371, 1372, 1373,
+		1374, 1375, 1376,
+		1377, 1378, 1379,
+		1380, 1381, 1382,
+		1383, 1384, 1385,
+		1386, 1387, 1388,
+		1389, 1390, 1391,
+		1392, 1393, 1394,
+		1395, 1396, 1397,
+		1398, 1399, 1400,
+		1401, 1402, 1403,
+		1404, 1405, 1406,
+		1407, 1408, 1409,
+		1410, 1411, 1412,
+		1413, 1414, 1415,
+		1416, 1417, 1418,
+		1419, 1420, 1421,
+		1422, 1423, 1424,
+		1425, 1426, 1427,
+		1428, 1429, 1430,
+		1431, 1432, 1433,
+		1434, 1435, 1436,
+		1437, 1438, 1439,
+		1440, 1441, 1442,
+		1443, 1444, 1445,
+		1446, 1447, 1448,
+		1449, 1450, 1451,
+		1452, 1453, 1454,
+		1455, 1456, 1457,
+		1458, 1459, 1460,
+		1461, 1462, 1463,
+		1464, 1465, 1466,
+		1467, 1468, 1469,
+		1470, 1471, 1472,
+		1473, 1474, 1475,
+		1476, 1477, 1478,
+		1479, 1480, 1481,
+		1482, 1483, 1484,
+		1485, 1486, 1487,
+		1488, 1489, 1490,
+		1491, 1492, 1493,
+		1494, 1495, 1496,
+		1497, 1498, 1499,
+		1500, 1501, 1502,
+		1503, 1504, 1505,
+		1506, 1507, 1508,
+		1509, 1510, 1511,
+		1512, 1513, 1514,
+		1515, 1516, 1517,
+		1518, 1519, 1520,
+		1521, 1522, 1523,
+		1524, 1525, 1526,
+		1527, 1528, 1529,
+		1530, 1531, 1532,
+		1533, 1534, 1535,
+		1536, 1537, 1538,
+		1539, 1540, 1541,
+		1542, 1543, 1544,
+		1545, 1546, 1547,
+		1548, 1549, 1550,
+		1551, 1552, 1553,
+		1554, 1555, 1556,
+		1557, 1558, 1559,
+		1560, 1561, 1562,
+		1563, 1564, 1565,
+		1566, 1567, 1568,
+		1569, 1570, 1571,
+		1572, 1573, 1574,
+		1575, 1576, 1577,
+		1578, 1579, 1580,
+		1581, 1582, 1583,
+		1584, 1585, 1586,
+		1587, 1588, 1589,
+		1590, 1591, 1592,
+		1593, 1594, 1595,
+		1596, 1597, 1598,
+		1599, 1600, 1601,
+		1602, 1603, 1604,
+		1605, 1606, 1607,
+		1608, 1609, 1610,
+		1611, 1612, 1613,
+		1614, 1615, 1616,
+		1617, 1618, 1619,
+		1620, 1621, 1622,
+		1623, 1624, 1625,
+		1626, 1627, 1628,
+		1629, 1630, 1631,
+		1632, 1633, 1634,
+		1635, 1636, 1637,
+		1638, 1639, 1640,
+		1641, 1642, 1643,
+		1644, 1645, 1646,
+		1647, 1648, 1649,
+		1650, 1651, 1652,
+		1653, 1654, 1655,
+		1656, 1657, 1658,
+		1659, 1660, 1661,
+		1662, 1663, 1664,
+		1665, 1666, 1667,
+		1668, 1669, 1670,
+		1671, 1672, 1673,
+		1674, 1675, 1676,
+		1677, 1678, 1679,
+		1680, 1681, 1682,
+		1683, 1684, 1685,
+		1686, 1687, 1688,
+		1689, 1690, 1691,
+		1692, 1693, 1694,
+		1695, 1696, 1697,
+		1698, 1699, 1700,
+		1701, 1702, 1703,
+		1704, 1705, 1706,
+		1707, 1708, 1709,
+		1710, 1711, 1712,
+		1713, 1714, 1715,
+		1716, 1717, 1718,
+		1719, 1720, 1721,
+		1722, 1723, 1724,
+		1725, 1726, 1727,
+		1728, 1729, 1730,
+		1731, 1732, 1733,
+		1734, 1735, 1736,
+		1737, 1738, 1739,
+		1740, 1741, 1742,
+		1743, 1744, 1745,
+		1746, 1747, 1748,
+		1749, 1750, 1751,
+		1752, 1753, 1754,
+		1755, 1756, 1757,
+		1758, 1759, 1760,
+		1761, 1762, 1763,
+		1764, 1765, 1766,
+		1767, 1768, 1769,
+		1770, 1771, 1772,
+		1773, 1774, 1775,
+		1776, 1777, 1778,
+		1779, 1780, 1781,
+		1782, 1783, 1784,
+		1785, 1786, 1787,
+		1788, 1789, 1790,
+		1791, 1792, 1793,
+		1794, 1795, 1796,
+		1797, 1798, 1799,
+		1800, 1801, 1802,
+		1803, 1804, 1805,
+		1806, 1807, 1808,
+		1809, 1810, 1811,
+		1812, 1813, 1814,
+		1815, 1816, 1817,
+		1818, 1819, 1820,
+		1821, 1822, 1823,
+		1824, 1825, 1826,
+		1827, 1828, 1829,
+		1830, 1831, 1832,
+		1833, 1834, 1835,
+		1836, 1837, 1838,
+		1839, 1840, 1841,
+		1842, 1843, 1844,
+		1845, 1846, 1847,
+		1848, 1849, 1850,
+		1851, 1852, 1853,
+		1854, 1855, 1856,
+		1857, 1858, 1859,
+		1860, 1861, 1862,
+		1863, 1864, 1865,
+		1866, 1867, 1868,
+		1869, 1870, 1871,
+		1872, 1873, 1874,
+		1875, 1876, 1877,
+		1878, 1879, 1880,
+		1881, 1882, 1883,
+		1884, 1885, 1886,
+		1887, 1888, 1889,
+		1890, 1891, 1892,
+		1893, 1894, 1895,
+		1896, 1897, 1898,
+		1899, 1900, 1901,
+		1902, 1903, 1904,
+		1905, 1906, 1907,
+		1908, 1909, 1910,
+		1911, 1912, 1913,
+		1914, 1915, 1916,
+		1917, 1918, 1919,
+		1920, 1921, 1922,
+		1923, 1924, 1925,
+		1926, 1927, 1928,
+		1929, 1930, 1931,
+		1932, 1933, 1934,
+		1935, 1936, 1937,
+		1938, 1939, 1940,
+		1941, 1942, 1943,
+		1944, 1945, 1946,
+		1947, 1948, 1949,
+		1950, 1951, 1952,
+		1953, 1954, 1955,
+		1956, 1957, 1958,
+		1959, 1960, 1961,
+		1962, 1963, 1964,
+		1965, 1966, 1967,
+		1968, 1969, 1970,
+		1971, 1972, 1973,
+		1974, 1975, 1976,
+		1977, 1978, 1979,
+		1980, 1981, 1982,
+		1983, 1984, 1985,
+		1986, 1987, 1988,
+		1989, 1990, 1991,
+		1992, 1993, 1994,
+		1995, 1996, 1997,
+		1998, 1999, 2000,
+		2001, 2002, 2003,
+		2004, 2005, 2006,
+		2007, 2008, 2009,
+		2010, 2011, 2012,
+		2013, 2014, 2015,
+		2016, 2017, 2018,
+		2019, 2020, 2021,
+		2022, 2023, 2024,
+		2025, 2026, 2027,
+		2028, 2029, 2030,
+		2031, 2032, 2033,
+		2034, 2035, 2036,
+		2037, 2038, 2039,
+		2040, 2041, 2042,
+		2043, 2044, 2045,
+		2046, 2047, 2048,
+		2049, 2050, 2051,
+		2052, 2053, 2054,
+		2055, 2056, 2057,
+		2058, 2059, 2060,
+		2061, 2062, 2063,
+		2064, 2065, 2066,
+		2067, 2068, 2069,
+		2070, 2071, 2072,
+		2073, 2074, 2075,
+		2076, 2077, 2078,
+		2079, 2080, 2081,
+		2082, 2083, 2084,
+		2085, 2086, 2087,
+		2088, 2089, 2090,
+		2091, 2092, 2093,
+		2094, 2095, 2096,
+		2097, 2098, 2099,
+		2100, 2101, 2102,
+		2103, 2104, 2105,
+		2106, 2107, 2108,
+		2109, 2110, 2111,
+		2112, 2113, 2114,
+		2115, 2116, 2117,
+		2118, 2119, 2120,
+		2121, 2122, 2123,
+		2124, 2125, 2126,
+		2127, 2128, 2129,
+		2130, 2131, 2132,
+		2133, 2134, 2135,
+		2136, 2137, 2138,
+		2139, 2140, 2141,
+		2142, 2143, 2144,
+		2145, 2146, 2147,
+		2148, 2149, 2150,
+		2151, 2152, 2153,
+		2154, 2155, 2156,
+		2157, 2158, 2159};
+
+const float medium_sphere_vertices[] =
+	{
+		0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.999999f, 0.020053f,
+		0.203181f, -0.967950f, 0.147618f, 0.000000f, 0.203181f, -0.967950f, 0.147618f, 0.566902f, 0.400852f,
+		-0.077607f, -0.967950f, 0.238853f, 0.000000f, -0.077607f, -0.967950f, 0.238853f, 0.986368f, 0.352464f,
+		0.723607f, -0.447220f, 0.525725f, 0.000000f, 0.723607f, -0.447220f, 0.525725f, 0.779690f, 0.082142f,
+		0.609547f, -0.657519f, 0.442856f, 0.000000f, 0.609547f, -0.657519f, 0.442856f, 0.381800f, 0.317539f,
+		0.812729f, -0.502301f, 0.295238f, 0.000000f, 0.812729f, -0.502301f, 0.295238f, 0.918131f, 0.436615f,
+		0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.999999f, 0.020053f,
+		-0.077607f, -0.967950f, 0.238853f, 0.000000f, -0.077607f, -0.967950f, 0.238853f, 0.986368f, 0.352464f,
+		-0.251147f, -0.967949f, 0.000000f, 0.000000f, -0.251147f, -0.967949f, 0.000000f, 0.444254f, 0.709621f,
+		0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.999999f, 0.020053f,
+		-0.251147f, -0.967949f, 0.000000f, 0.000000f, -0.251147f, -0.967949f, 0.000000f, 0.444254f, 0.709621f,
+		-0.077607f, -0.967950f, -0.238853f, 0.000000f, -0.077607f, -0.967950f, -0.238853f, 0.043816f, 0.747734f,
+		0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.999999f, 0.020053f,
+		-0.077607f, -0.967950f, -0.238853f, 0.000000f, -0.077607f, -0.967950f, -0.238853f, 0.043816f, 0.747734f,
+		0.203181f, -0.967950f, -0.147618f, 0.000000f, 0.203181f, -0.967950f, -0.147618f, 0.966205f, 0.438787f,
+		0.723607f, -0.447220f, 0.525725f, 0.000000f, 0.723607f, -0.447220f, 0.525725f, 0.779690f, 0.082142f,
+		0.812729f, -0.502301f, 0.295238f, 0.000000f, 0.812729f, -0.502301f, 0.295238f, 0.918131f, 0.436615f,
+		0.860698f, -0.251151f, 0.442858f, 0.000000f, 0.860698f, -0.251151f, 0.442858f, 0.689049f, 0.234408f,
+		-0.276388f, -0.447220f, 0.850649f, 0.000000f, -0.276388f, -0.447220f, 0.850649f, 0.554423f, 0.061638f,
+		-0.029639f, -0.502302f, 0.864184f, 0.000000f, -0.029639f, -0.502302f, 0.864184f, 0.180731f, 0.340648f,
+		-0.155215f, -0.251152f, 0.955422f, 0.000000f, -0.155215f, -0.251152f, 0.955422f, 0.885924f, 0.257323f,
+		-0.894426f, -0.447216f, 0.000000f, 0.000000f, -0.894426f, -0.447216f, 0.000000f, 0.746383f, 0.351642f,
+		-0.831051f, -0.502299f, 0.238853f, 0.000000f, -0.831051f, -0.502299f, 0.238853f, 0.634945f, 0.715428f,
+		-0.956626f, -0.251149f, 0.147618f, 0.000000f, -0.956626f, -0.251149f, 0.147618f, 0.397050f, 0.226232f,
+		-0.276388f, -0.447220f, -0.850649f, 0.000000f, -0.276388f, -0.447220f, -0.850649f, 0.750122f, 0.271069f,
+		-0.483971f, -0.502302f, -0.716565f, 0.000000f, -0.483971f, -0.502302f, -0.716565f, 0.250122f, 0.728931f,
+		-0.436007f, -0.251152f, -0.864188f, 0.000000f, -0.436007f, -0.251152f, -0.864188f, 0.134945f, 0.284572f,
+		0.723607f, -0.447220f, -0.525725f, 0.000000f, 0.723607f, -0.447220f, -0.525725f, 0.791456f, 0.337315f,
+		0.531941f, -0.502302f, -0.681712f, 0.000000f, 0.531941f, -0.502302f, -0.681712f, 0.833640f, 0.738875f,
+		0.687159f, -0.251152f, -0.681715f, 0.000000f, 0.687159f, -0.251152f, -0.681715f, 0.268675f, 0.239476f,
+		0.723607f, -0.447220f, 0.525725f, 0.000000f, 0.723607f, -0.447220f, 0.525725f, 0.779690f, 0.082142f,
+		0.860698f, -0.251151f, 0.442858f, 0.000000f, 0.860698f, -0.251151f, 0.442858f, 0.689049f, 0.234408f,
+		0.687159f, -0.251152f, 0.681715f, 0.000000f, 0.687159f, -0.251152f, 0.681715f, 0.702477f, 0.326245f,
+		-0.276388f, -0.447220f, 0.850649f, 0.000000f, -0.276388f, -0.447220f, 0.850649f, 0.554423f, 0.061638f,
+		-0.155215f, -0.251152f, 0.955422f, 0.000000f, -0.155215f, -0.251152f, 0.955422f, 0.885924f, 0.257323f,
+		-0.436007f, -0.251152f, 0.864188f, 0.000000f, -0.436007f, -0.251152f, 0.864188f, 0.813138f, 0.249674f,
+		-0.894426f, -0.447216f, 0.000000f, 0.000000f, -0.894426f, -0.447216f, 0.000000f, 0.746383f, 0.351642f,
+		-0.956626f, -0.251149f, 0.147618f, 0.000000f, -0.956626f, -0.251149f, 0.147618f, 0.397050f, 0.226232f,
+		-0.956626f, -0.251149f, -0.147618f, 0.000000f, -0.956626f, -0.251149f, -0.147618f, 0.304489f, 0.071876f,
+		-0.276388f, -0.447220f, -0.850649f, 0.000000f, -0.276388f, -0.447220f, -0.850649f, 0.750122f, 0.271069f,
+		-0.436007f, -0.251152f, -0.864188f, 0.000000f, -0.436007f, -0.251152f, -0.864188f, 0.134945f, 0.284572f,
+		-0.155215f, -0.251152f, -0.955422f, 0.000000f, -0.155215f, -0.251152f, -0.955422f, 0.129692f, 0.189429f,
+		0.723607f, -0.447220f, -0.525725f, 0.000000f, 0.723607f, -0.447220f, -0.525725f, 0.791456f, 0.337315f,
+		0.687159f, -0.251152f, -0.681715f, 0.000000f, 0.687159f, -0.251152f, -0.681715f, 0.268675f, 0.239476f,
+		0.860698f, -0.251151f, -0.442858f, 0.000000f, 0.860698f, -0.251151f, -0.442858f, 0.543816f, 0.252266f,
+		0.276388f, 0.447220f, 0.850649f, 0.000000f, 0.276388f, 0.447220f, 0.850649f, 1.304489f, 0.071876f,
+		0.483971f, 0.502302f, 0.716565f, 0.000000f, 0.483971f, 0.502302f, 0.716565f, 1.036828f, 0.167036f,
+		0.232822f, 0.657519f, 0.716563f, 0.000000f, 0.232822f, 0.657519f, 0.716563f, 0.616405f, 0.395845f,
+		-0.723607f, 0.447220f, 0.525725f, 0.000000f, -0.723607f, 0.447220f, 0.525725f, 1.115709f, 0.094716f,
+		-0.531941f, 0.502302f, 0.681712f, 0.000000f, -0.531941f, 0.502302f, 0.681712f, 0.074553f, 0.260244f,
+		-0.609547f, 0.657519f, 0.442856f, 0.000000f, -0.609547f, 0.657519f, 0.442856f, 0.418131f, 0.563385f,
+		-0.723607f, 0.447220f, -0.525725f, 0.000000f, -0.723607f, 0.447220f, -0.525725f, 0.952607f, 0.099770f,
+		-0.812729f, 0.502301f, -0.295238f, 0.000000f, -0.812729f, 0.502301f, -0.295238f, 0.093723f, 0.349056f,
+		-0.609547f, 0.657519f, -0.442856f, 0.000000f, -0.609547f, 0.657519f, -0.442856f, 0.441249f, 0.481295f,
+		0.276388f, 0.447220f, -0.850649f, 0.000000f, 0.276388f, 0.447220f, -0.850649f, 0.768276f, 0.421330f,
+		0.029639f, 0.502302f, -0.864184f, 0.000000f, 0.029639f, 0.502302f, -0.864184f, 0.791278f, 0.505149f,
+		0.232822f, 0.657519f, -0.716563f, 0.000000f, 0.232822f, 0.657519f, -0.716563f, 0.467747f, 0.391208f,
+		0.894426f, 0.447216f, 0.000000f, 0.000000f, 0.894426f, 0.447216f, 0.000000f, 0.542767f, 0.333057f,
+		0.831051f, 0.502299f, -0.238853f, 0.000000f, 0.831051f, 0.502299f, -0.238853f, 0.891200f, 0.515555f,
+		0.753442f, 0.657515f, 0.000000f, 0.000000f, 0.753442f, 0.657515f, 0.000000f, 0.870330f, 0.424531f,
+		-0.232822f, -0.657519f, 0.716563f, 0.000000f, -0.232822f, -0.657519f, 0.716563f, 0.163633f, 0.429436f,
+		-0.029639f, -0.502302f, 0.864184f, 0.000000f, -0.029639f, -0.502302f, 0.864184f, 0.180731f, 0.340648f,
+		-0.276388f, -0.447220f, 0.850649f, 0.000000f, -0.276388f, -0.447220f, 0.850649f, 0.554423f, 0.061638f,
+		-0.162456f, -0.850654f, 0.499995f, 0.000000f, -0.162456f, -0.850654f, 0.499995f, 0.943007f, 0.371159f,
+		0.052790f, -0.723612f, 0.688185f, 0.000000f, 0.052790f, -0.723612f, 0.688185f, 0.219605f, 0.584779f,
+		-0.232822f, -0.657519f, 0.716563f, 0.000000f, -0.232822f, -0.657519f, 0.716563f, 0.163633f, 0.429436f,
+		-0.077607f, -0.967950f, 0.238853f, 0.000000f, -0.077607f, -0.967950f, 0.238853f, 0.986368f, 0.352464f,
+		0.138199f, -0.894429f, 0.425321f, 0.000000f, 0.138199f, -0.894429f, 0.425321f, 0.268276f, 0.578670f,
+		-0.162456f, -0.850654f, 0.499995f, 0.000000f, -0.162456f, -0.850654f, 0.499995f, 0.943007f, 0.371159f,
+		-0.232822f, -0.657519f, 0.716563f, 0.000000f, -0.232822f, -0.657519f, 0.716563f, 0.163633f, 0.429436f,
+		0.052790f, -0.723612f, 0.688185f, 0.000000f, 0.052790f, -0.723612f, 0.688185f, 0.219605f, 0.584779f,
+		-0.029639f, -0.502302f, 0.864184f, 0.000000f, -0.029639f, -0.502302f, 0.864184f, 0.180731f, 0.340648f,
+		0.052790f, -0.723612f, 0.688185f, 0.000000f, 0.052790f, -0.723612f, 0.688185f, 0.219605f, 0.584779f,
+		0.262869f, -0.525738f, 0.809012f, 0.000000f, 0.262869f, -0.525738f, 0.809012f, 0.137692f, 0.365246f,
+		-0.029639f, -0.502302f, 0.864184f, 0.000000f, -0.029639f, -0.502302f, 0.864184f, 0.180731f, 0.340648f,
+		-0.162456f, -0.850654f, 0.499995f, 0.000000f, -0.162456f, -0.850654f, 0.499995f, 0.943007f, 0.371159f,
+		0.138199f, -0.894429f, 0.425321f, 0.000000f, 0.138199f, -0.894429f, 0.425321f, 0.268276f, 0.578670f,
+		0.052790f, -0.723612f, 0.688185f, 0.000000f, 0.052790f, -0.723612f, 0.688185f, 0.219605f, 0.584779f,
+		0.138199f, -0.894429f, 0.425321f, 0.000000f, 0.138199f, -0.894429f, 0.425321f, 0.268276f, 0.578670f,
+		0.361805f, -0.723611f, 0.587779f, 0.000000f, 0.361805f, -0.723611f, 0.587779f, 0.191461f, 0.507219f,
+		0.052790f, -0.723612f, 0.688185f, 0.000000f, 0.052790f, -0.723612f, 0.688185f, 0.219605f, 0.584779f,
+		0.052790f, -0.723612f, 0.688185f, 0.000000f, 0.052790f, -0.723612f, 0.688185f, 0.219605f, 0.584779f,
+		0.361805f, -0.723611f, 0.587779f, 0.000000f, 0.361805f, -0.723611f, 0.587779f, 0.191461f, 0.507219f,
+		0.262869f, -0.525738f, 0.809012f, 0.000000f, 0.262869f, -0.525738f, 0.809012f, 0.137692f, 0.365246f,
+		0.361805f, -0.723611f, 0.587779f, 0.000000f, 0.361805f, -0.723611f, 0.587779f, 0.191461f, 0.507219f,
+		0.531941f, -0.502302f, 0.681712f, 0.000000f, 0.531941f, -0.502302f, 0.681712f, 0.363599f, 0.405960f,
+		0.262869f, -0.525738f, 0.809012f, 0.000000f, 0.262869f, -0.525738f, 0.809012f, 0.137692f, 0.365246f,
+		-0.077607f, -0.967950f, 0.238853f, 0.000000f, -0.077607f, -0.967950f, 0.238853f, 0.986368f, 0.352464f,
+		0.203181f, -0.967950f, 0.147618f, 0.000000f, 0.203181f, -0.967950f, 0.147618f, 0.566902f, 0.400852f,
+		0.138199f, -0.894429f, 0.425321f, 0.000000f, 0.138199f, -0.894429f, 0.425321f, 0.268276f, 0.578670f,
+		0.203181f, -0.967950f, 0.147618f, 0.000000f, 0.203181f, -0.967950f, 0.147618f, 0.566902f, 0.400852f,
+		0.425323f, -0.850654f, 0.309011f, 0.000000f, 0.425323f, -0.850654f, 0.309011f, 0.336927f, 0.341759f,
+		0.138199f, -0.894429f, 0.425321f, 0.000000f, 0.138199f, -0.894429f, 0.425321f, 0.268276f, 0.578670f,
+		0.138199f, -0.894429f, 0.425321f, 0.000000f, 0.138199f, -0.894429f, 0.425321f, 0.268276f, 0.578670f,
+		0.425323f, -0.850654f, 0.309011f, 0.000000f, 0.425323f, -0.850654f, 0.309011f, 0.336927f, 0.341759f,
+		0.361805f, -0.723611f, 0.587779f, 0.000000f, 0.361805f, -0.723611f, 0.587779f, 0.191461f, 0.507219f,
+		0.425323f, -0.850654f, 0.309011f, 0.000000f, 0.425323f, -0.850654f, 0.309011f, 0.336927f, 0.341759f,
+		0.609547f, -0.657519f, 0.442856f, 0.000000f, 0.609547f, -0.657519f, 0.442856f, 0.381800f, 0.317539f,
+		0.361805f, -0.723611f, 0.587779f, 0.000000f, 0.361805f, -0.723611f, 0.587779f, 0.191461f, 0.507219f,
+		0.361805f, -0.723611f, 0.587779f, 0.000000f, 0.361805f, -0.723611f, 0.587779f, 0.191461f, 0.507219f,
+		0.609547f, -0.657519f, 0.442856f, 0.000000f, 0.609547f, -0.657519f, 0.442856f, 0.381800f, 0.317539f,
+		0.531941f, -0.502302f, 0.681712f, 0.000000f, 0.531941f, -0.502302f, 0.681712f, 0.363599f, 0.405960f,
+		0.609547f, -0.657519f, 0.442856f, 0.000000f, 0.609547f, -0.657519f, 0.442856f, 0.381800f, 0.317539f,
+		0.723607f, -0.447220f, 0.525725f, 0.000000f, 0.723607f, -0.447220f, 0.525725f, 0.779690f, 0.082142f,
+		0.531941f, -0.502302f, 0.681712f, 0.000000f, 0.531941f, -0.502302f, 0.681712f, 0.363599f, 0.405960f,
+		0.812729f, -0.502301f, -0.295238f, 0.000000f, 0.812729f, -0.502301f, -0.295238f, 0.314480f, 0.411140f,
+		0.609547f, -0.657519f, -0.442856f, 0.000000f, 0.609547f, -0.657519f, -0.442856f, 0.517304f, 0.399254f,
+		0.723607f, -0.447220f, -0.525725f, 0.000000f, 0.723607f, -0.447220f, -0.525725f, 0.791456f, 0.337315f,
+		0.850648f, -0.525736f, 0.000000f, 0.000000f, 0.850648f, -0.525736f, 0.000000f, 0.115418f, 0.434134f,
+		0.670817f, -0.723611f, -0.162457f, 0.000000f, 0.670817f, -0.723611f, -0.162457f, 0.241373f, 0.501088f,
+		0.812729f, -0.502301f, -0.295238f, 0.000000f, 0.812729f, -0.502301f, -0.295238f, 0.314480f, 0.411140f,
+		0.812729f, -0.502301f, 0.295238f, 0.000000f, 0.812729f, -0.502301f, 0.295238f, 0.918131f, 0.436615f,
+		0.670817f, -0.723610f, 0.162458f, 0.000000f, 0.670817f, -0.723610f, 0.162458f, 0.211591f, 0.415486f,
+		0.850648f, -0.525736f, 0.000000f, 0.000000f, 0.850648f, -0.525736f, 0.000000f, 0.115418f, 0.434134f,
+		0.812729f, -0.502301f, -0.295238f, 0.000000f, 0.812729f, -0.502301f, -0.295238f, 0.314480f, 0.411140f,
+		0.670817f, -0.723611f, -0.162457f, 0.000000f, 0.670817f, -0.723611f, -0.162457f, 0.241373f, 0.501088f,
+		0.609547f, -0.657519f, -0.442856f, 0.000000f, 0.609547f, -0.657519f, -0.442856f, 0.517304f, 0.399254f,
+		0.670817f, -0.723611f, -0.162457f, 0.000000f, 0.670817f, -0.723611f, -0.162457f, 0.241373f, 0.501088f,
+		0.425323f, -0.850654f, -0.309011f, 0.000000f, 0.425323f, -0.850654f, -0.309011f, 0.719605f, 0.415221f,
+		0.609547f, -0.657519f, -0.442856f, 0.000000f, 0.609547f, -0.657519f, -0.442856f, 0.517304f, 0.399254f,
+		0.850648f, -0.525736f, 0.000000f, 0.000000f, 0.850648f, -0.525736f, 0.000000f, 0.115418f, 0.434134f,
+		0.670817f, -0.723610f, 0.162458f, 0.000000f, 0.670817f, -0.723610f, 0.162458f, 0.211591f, 0.415486f,
+		0.670817f, -0.723611f, -0.162457f, 0.000000f, 0.670817f, -0.723611f, -0.162457f, 0.241373f, 0.501088f,
+		0.670817f, -0.723610f, 0.162458f, 0.000000f, 0.670817f, -0.723610f, 0.162458f, 0.211591f, 0.415486f,
+		0.447211f, -0.894428f, 0.000001f, 0.000000f, 0.447211f, -0.894428f, 0.000001f, 0.291278f, 0.494851f,
+		0.670817f, -0.723611f, -0.162457f, 0.000000f, 0.670817f, -0.723611f, -0.162457f, 0.241373f, 0.501088f,
+		0.670817f, -0.723611f, -0.162457f, 0.000000f, 0.670817f, -0.723611f, -0.162457f, 0.241373f, 0.501088f,
+		0.447211f, -0.894428f, 0.000001f, 0.000000f, 0.447211f, -0.894428f, 0.000001f, 0.291278f, 0.494851f,
+		0.425323f, -0.850654f, -0.309011f, 0.000000f, 0.425323f, -0.850654f, -0.309011f, 0.719605f, 0.415221f,
+		0.447211f, -0.894428f, 0.000001f, 0.000000f, 0.447211f, -0.894428f, 0.000001f, 0.291278f, 0.494851f,
+		0.203181f, -0.967950f, -0.147618f, 0.000000f, 0.203181f, -0.967950f, -0.147618f, 0.966205f, 0.438787f,
+		0.425323f, -0.850654f, -0.309011f, 0.000000f, 0.425323f, -0.850654f, -0.309011f, 0.719605f, 0.415221f,
+		0.812729f, -0.502301f, 0.295238f, 0.000000f, 0.812729f, -0.502301f, 0.295238f, 0.918131f, 0.436615f,
+		0.609547f, -0.657519f, 0.442856f, 0.000000f, 0.609547f, -0.657519f, 0.442856f, 0.381800f, 0.317539f,
+		0.670817f, -0.723610f, 0.162458f, 0.000000f, 0.670817f, -0.723610f, 0.162458f, 0.211591f, 0.415486f,
+		0.609547f, -0.657519f, 0.442856f, 0.000000f, 0.609547f, -0.657519f, 0.442856f, 0.381800f, 0.317539f,
+		0.425323f, -0.850654f, 0.309011f, 0.000000f, 0.425323f, -0.850654f, 0.309011f, 0.336927f, 0.341759f,
+		0.670817f, -0.723610f, 0.162458f, 0.000000f, 0.670817f, -0.723610f, 0.162458f, 0.211591f, 0.415486f,
+		0.670817f, -0.723610f, 0.162458f, 0.000000f, 0.670817f, -0.723610f, 0.162458f, 0.211591f, 0.415486f,
+		0.425323f, -0.850654f, 0.309011f, 0.000000f, 0.425323f, -0.850654f, 0.309011f, 0.336927f, 0.341759f,
+		0.447211f, -0.894428f, 0.000001f, 0.000000f, 0.447211f, -0.894428f, 0.000001f, 0.291278f, 0.494851f,
+		0.425323f, -0.850654f, 0.309011f, 0.000000f, 0.425323f, -0.850654f, 0.309011f, 0.336927f, 0.341759f,
+		0.203181f, -0.967950f, 0.147618f, 0.000000f, 0.203181f, -0.967950f, 0.147618f, 0.566902f, 0.400852f,
+		0.447211f, -0.894428f, 0.000001f, 0.000000f, 0.447211f, -0.894428f, 0.000001f, 0.291278f, 0.494851f,
+		0.447211f, -0.894428f, 0.000001f, 0.000000f, 0.447211f, -0.894428f, 0.000001f, 0.291278f, 0.494851f,
+		0.203181f, -0.967950f, 0.147618f, 0.000000f, 0.203181f, -0.967950f, 0.147618f, 0.566902f, 0.400852f,
+		0.203181f, -0.967950f, -0.147618f, 0.000000f, 0.203181f, -0.967950f, -0.147618f, 0.966205f, 0.438787f,
+		0.203181f, -0.967950f, 0.147618f, 0.000000f, 0.203181f, -0.967950f, 0.147618f, 0.566902f, 0.400852f,
+		0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.999999f, 0.020053f,
+		0.203181f, -0.967950f, -0.147618f, 0.000000f, 0.203181f, -0.967950f, -0.147618f, 0.966205f, 0.438787f,
+		-0.753442f, -0.657515f, 0.000000f, 0.000000f, -0.753442f, -0.657515f, 0.000000f, 0.443007f, 0.628841f,
+		-0.831051f, -0.502299f, 0.238853f, 0.000000f, -0.831051f, -0.502299f, 0.238853f, 0.634945f, 0.715428f,
+		-0.894426f, -0.447216f, 0.000000f, 0.000000f, -0.894426f, -0.447216f, 0.000000f, 0.746383f, 0.351642f,
+		-0.525730f, -0.850652f, 0.000000f, 0.000000f, -0.525730f, -0.850652f, 0.000000f, 0.486368f, 0.647536f,
+		-0.638195f, -0.723609f, 0.262864f, 0.000000f, -0.638195f, -0.723609f, 0.262864f, 0.265485f, 0.408729f,
+		-0.753442f, -0.657515f, 0.000000f, 0.000000f, -0.753442f, -0.657515f, 0.000000f, 0.443007f, 0.628841f,
+		-0.251147f, -0.967949f, 0.000000f, 0.000000f, -0.251147f, -0.967949f, 0.000000f, 0.444254f, 0.709621f,
+		-0.361801f, -0.894428f, 0.262864f, 0.000000f, -0.361801f, -0.894428f, 0.262864f, 0.017304f, 0.600746f,
+		-0.525730f, -0.850652f, 0.000000f, 0.000000f, -0.525730f, -0.850652f, 0.000000f, 0.486368f, 0.647536f,
+		-0.753442f, -0.657515f, 0.000000f, 0.000000f, -0.753442f, -0.657515f, 0.000000f, 0.443007f, 0.628841f,
+		-0.638195f, -0.723609f, 0.262864f, 0.000000f, -0.638195f, -0.723609f, 0.262864f, 0.265485f, 0.408729f,
+		-0.831051f, -0.502299f, 0.238853f, 0.000000f, -0.831051f, -0.502299f, 0.238853f, 0.634945f, 0.715428f,
+		-0.638195f, -0.723609f, 0.262864f, 0.000000f, -0.638195f, -0.723609f, 0.262864f, 0.265485f, 0.408729f,
+		-0.688189f, -0.525736f, 0.499997f, 0.000000f, -0.688189f, -0.525736f, 0.499997f, 0.680731f, 0.659352f,
+		-0.831051f, -0.502299f, 0.238853f, 0.000000f, -0.831051f, -0.502299f, 0.238853f, 0.634945f, 0.715428f,
+		-0.525730f, -0.850652f, 0.000000f, 0.000000f, -0.525730f, -0.850652f, 0.000000f, 0.486368f, 0.647536f,
+		-0.361801f, -0.894428f, 0.262864f, 0.000000f, -0.361801f, -0.894428f, 0.262864f, 0.017304f, 0.600746f,
+		-0.638195f, -0.723609f, 0.262864f, 0.000000f, -0.638195f, -0.723609f, 0.262864f, 0.265485f, 0.408729f,
+		-0.361801f, -0.894428f, 0.262864f, 0.000000f, -0.361801f, -0.894428f, 0.262864f, 0.017304f, 0.600746f,
+		-0.447211f, -0.723610f, 0.525729f, 0.000000f, -0.447211f, -0.723610f, 0.525729f, 0.066902f, 0.599148f,
+		-0.638195f, -0.723609f, 0.262864f, 0.000000f, -0.638195f, -0.723609f, 0.262864f, 0.265485f, 0.408729f,
+		-0.638195f, -0.723609f, 0.262864f, 0.000000f, -0.638195f, -0.723609f, 0.262864f, 0.265485f, 0.408729f,
+		-0.447211f, -0.723610f, 0.525729f, 0.000000f, -0.447211f, -0.723610f, 0.525729f, 0.066902f, 0.599148f,
+		-0.688189f, -0.525736f, 0.499997f, 0.000000f, -0.688189f, -0.525736f, 0.499997f, 0.680731f, 0.659352f,
+		-0.447211f, -0.723610f, 0.525729f, 0.000000f, -0.447211f, -0.723610f, 0.525729f, 0.066902f, 0.599148f,
+		-0.483971f, -0.502302f, 0.716565f, 0.000000f, -0.483971f, -0.502302f, 0.716565f, 0.637692f, 0.634754f,
+		-0.688189f, -0.525736f, 0.499997f, 0.000000f, -0.688189f, -0.525736f, 0.499997f, 0.680731f, 0.659352f,
+		-0.251147f, -0.967949f, 0.000000f, 0.000000f, -0.251147f, -0.967949f, 0.000000f, 0.444254f, 0.709621f,
+		-0.077607f, -0.967950f, 0.238853f, 0.000000f, -0.077607f, -0.967950f, 0.238853f, 0.986368f, 0.352464f,
+		-0.361801f, -0.894428f, 0.262864f, 0.000000f, -0.361801f, -0.894428f, 0.262864f, 0.017304f, 0.600746f,
+		-0.077607f, -0.967950f, 0.238853f, 0.000000f, -0.077607f, -0.967950f, 0.238853f, 0.986368f, 0.352464f,
+		-0.162456f, -0.850654f, 0.499995f, 0.000000f, -0.162456f, -0.850654f, 0.499995f, 0.943007f, 0.371159f,
+		-0.361801f, -0.894428f, 0.262864f, 0.000000f, -0.361801f, -0.894428f, 0.262864f, 0.017304f, 0.600746f,
+		-0.361801f, -0.894428f, 0.262864f, 0.000000f, -0.361801f, -0.894428f, 0.262864f, 0.017304f, 0.600746f,
+		-0.162456f, -0.850654f, 0.499995f, 0.000000f, -0.162456f, -0.850654f, 0.499995f, 0.943007f, 0.371159f,
+		-0.447211f, -0.723610f, 0.525729f, 0.000000f, -0.447211f, -0.723610f, 0.525729f, 0.066902f, 0.599148f,
+		-0.162456f, -0.850654f, 0.499995f, 0.000000f, -0.162456f, -0.850654f, 0.499995f, 0.943007f, 0.371159f,
+		-0.232822f, -0.657519f, 0.716563f, 0.000000f, -0.232822f, -0.657519f, 0.716563f, 0.163633f, 0.429436f,
+		-0.447211f, -0.723610f, 0.525729f, 0.000000f, -0.447211f, -0.723610f, 0.525729f, 0.066902f, 0.599148f,
+		-0.447211f, -0.723610f, 0.525729f, 0.000000f, -0.447211f, -0.723610f, 0.525729f, 0.066902f, 0.599148f,
+		-0.232822f, -0.657519f, 0.716563f, 0.000000f, -0.232822f, -0.657519f, 0.716563f, 0.163633f, 0.429436f,
+		-0.483971f, -0.502302f, 0.716565f, 0.000000f, -0.483971f, -0.502302f, 0.716565f, 0.637692f, 0.634754f,
+		-0.232822f, -0.657519f, 0.716563f, 0.000000f, -0.232822f, -0.657519f, 0.716563f, 0.163633f, 0.429436f,
+		-0.276388f, -0.447220f, 0.850649f, 0.000000f, -0.276388f, -0.447220f, 0.850649f, 0.554423f, 0.061638f,
+		-0.483971f, -0.502302f, 0.716565f, 0.000000f, -0.483971f, -0.502302f, 0.716565f, 0.637692f, 0.634754f,
+		-0.232822f, -0.657519f, -0.716563f, 0.000000f, -0.232822f, -0.657519f, -0.716563f, 0.042767f, 0.666943f,
+		-0.483971f, -0.502302f, -0.716565f, 0.000000f, -0.483971f, -0.502302f, -0.716565f, 0.250122f, 0.728931f,
+		-0.276388f, -0.447220f, -0.850649f, 0.000000f, -0.276388f, -0.447220f, -0.850649f, 0.750122f, 0.271069f,
+		-0.162456f, -0.850654f, -0.499995f, 0.000000f, -0.162456f, -0.850654f, -0.499995f, 0.089135f, 0.684613f,
+		-0.447211f, -0.723611f, -0.525727f, 0.000000f, -0.447211f, -0.723611f, -0.525727f, 0.991338f, 0.520023f,
+		-0.232822f, -0.657519f, -0.716563f, 0.000000f, -0.232822f, -0.657519f, -0.716563f, 0.042767f, 0.666943f,
+		-0.077607f, -0.967950f, -0.238853f, 0.000000f, -0.077607f, -0.967950f, -0.238853f, 0.043816f, 0.747734f,
+		-0.361801f, -0.894429f, -0.262863f, 0.000000f, -0.361801f, -0.894429f, -0.262863f, 1.041434f, 0.519379f,
+		-0.162456f, -0.850654f, -0.499995f, 0.000000f, -0.162456f, -0.850654f, -0.499995f, 0.089135f, 0.684613f,
+		-0.232822f, -0.657519f, -0.716563f, 0.000000f, -0.232822f, -0.657519f, -0.716563f, 0.042767f, 0.666943f,
+		-0.447211f, -0.723611f, -0.525727f, 0.000000f, -0.447211f, -0.723611f, -0.525727f, 0.991338f, 0.520023f,
+		-0.483971f, -0.502302f, -0.716565f, 0.000000f, -0.483971f, -0.502302f, -0.716565f, 0.250122f, 0.728931f,
+		-0.447211f, -0.723611f, -0.525727f, 0.000000f, -0.447211f, -0.723611f, -0.525727f, 0.991338f, 0.520023f,
+		-0.688189f, -0.525736f, -0.499997f, 0.000000f, -0.688189f, -0.525736f, -0.499997f, 0.291456f, 0.662685f,
+		-0.483971f, -0.502302f, -0.716565f, 0.000000f, -0.483971f, -0.502302f, -0.716565f, 0.250122f, 0.728931f,
+		-0.162456f, -0.850654f, -0.499995f, 0.000000f, -0.162456f, -0.850654f, -0.499995f, 0.089135f, 0.684613f,
+		-0.361801f, -0.894429f, -0.262863f, 0.000000f, -0.361801f, -0.894429f, -0.262863f, 1.041434f, 0.519379f,
+		-0.447211f, -0.723611f, -0.525727f, 0.000000f, -0.447211f, -0.723611f, -0.525727f, 0.991338f, 0.520023f,
+		-0.361801f, -0.894429f, -0.262863f, 0.000000f, -0.361801f, -0.894429f, -0.262863f, 1.041434f, 0.519379f,
+		-0.638195f, -0.723609f, -0.262863f, 0.000000f, -0.638195f, -0.723609f, -0.262863f, 1.017304f, 0.600746f,
+		-0.447211f, -0.723611f, -0.525727f, 0.000000f, -0.447211f, -0.723611f, -0.525727f, 0.991338f, 0.520023f,
+		-0.447211f, -0.723611f, -0.525727f, 0.000000f, -0.447211f, -0.723611f, -0.525727f, 0.991338f, 0.520023f,
+		-0.638195f, -0.723609f, -0.262863f, 0.000000f, -0.638195f, -0.723609f, -0.262863f, 1.017304f, 0.600746f,
+		-0.688189f, -0.525736f, -0.499997f, 0.000000f, -0.688189f, -0.525736f, -0.499997f, 0.291456f, 0.662685f,
+		-0.638195f, -0.723609f, -0.262863f, 0.000000f, -0.638195f, -0.723609f, -0.262863f, 1.017304f, 0.600746f,
+		-0.831051f, -0.502299f, -0.238853f, 0.000000f, -0.831051f, -0.502299f, -0.238853f, 0.246383f, 0.648358f,
+		-0.688189f, -0.525736f, -0.499997f, 0.000000f, -0.688189f, -0.525736f, -0.499997f, 0.291456f, 0.662685f,
+		-0.077607f, -0.967950f, -0.238853f, 0.000000f, -0.077607f, -0.967950f, -0.238853f, 0.043816f, 0.747734f,
+		-0.251147f, -0.967949f, 0.000000f, 0.000000f, -0.251147f, -0.967949f, 0.000000f, 0.444254f, 0.709621f,
+		-0.361801f, -0.894429f, -0.262863f, 0.000000f, -0.361801f, -0.894429f, -0.262863f, 1.041434f, 0.519379f,
+		-0.251147f, -0.967949f, 0.000000f, 0.000000f, -0.251147f, -0.967949f, 0.000000f, 0.444254f, 0.709621f,
+		-0.525730f, -0.850652f, 0.000000f, 0.000000f, -0.525730f, -0.850652f, 0.000000f, 0.486368f, 0.647536f,
+		-0.361801f, -0.894429f, -0.262863f, 0.000000f, -0.361801f, -0.894429f, -0.262863f, 1.041434f, 0.519379f,
+		-0.361801f, -0.894429f, -0.262863f, 0.000000f, -0.361801f, -0.894429f, -0.262863f, 1.041434f, 0.519379f,
+		-0.525730f, -0.850652f, 0.000000f, 0.000000f, -0.525730f, -0.850652f, 0.000000f, 0.486368f, 0.647536f,
+		-0.638195f, -0.723609f, -0.262863f, 0.000000f, -0.638195f, -0.723609f, -0.262863f, 1.017304f, 0.600746f,
+		-0.525730f, -0.850652f, 0.000000f, 0.000000f, -0.525730f, -0.850652f, 0.000000f, 0.486368f, 0.647536f,
+		-0.753442f, -0.657515f, 0.000000f, 0.000000f, -0.753442f, -0.657515f, 0.000000f, 0.443007f, 0.628841f,
+		-0.638195f, -0.723609f, -0.262863f, 0.000000f, -0.638195f, -0.723609f, -0.262863f, 1.017304f, 0.600746f,
+		-0.638195f, -0.723609f, -0.262863f, 0.000000f, -0.638195f, -0.723609f, -0.262863f, 1.017304f, 0.600746f,
+		-0.753442f, -0.657515f, 0.000000f, 0.000000f, -0.753442f, -0.657515f, 0.000000f, 0.443007f, 0.628841f,
+		-0.831051f, -0.502299f, -0.238853f, 0.000000f, -0.831051f, -0.502299f, -0.238853f, 0.246383f, 0.648358f,
+		-0.753442f, -0.657515f, 0.000000f, 0.000000f, -0.753442f, -0.657515f, 0.000000f, 0.443007f, 0.628841f,
+		-0.894426f, -0.447216f, 0.000000f, 0.000000f, -0.894426f, -0.447216f, 0.000000f, 0.746383f, 0.351642f,
+		-0.831051f, -0.502299f, -0.238853f, 0.000000f, -0.831051f, -0.502299f, -0.238853f, 0.246383f, 0.648358f,
+		0.609547f, -0.657519f, -0.442856f, 0.000000f, 0.609547f, -0.657519f, -0.442856f, 0.517304f, 0.399254f,
+		0.531941f, -0.502302f, -0.681712f, 0.000000f, 0.531941f, -0.502302f, -0.681712f, 0.833640f, 0.738875f,
+		0.723607f, -0.447220f, -0.525725f, 0.000000f, 0.723607f, -0.447220f, -0.525725f, 0.791456f, 0.337315f,
+		0.425323f, -0.850654f, -0.309011f, 0.000000f, 0.425323f, -0.850654f, -0.309011f, 0.719605f, 0.415221f,
+		0.361804f, -0.723612f, -0.587779f, 0.000000f, 0.361804f, -0.723612f, -0.587779f, 1.014094f, 0.430832f,
+		0.609547f, -0.657519f, -0.442856f, 0.000000f, 0.609547f, -0.657519f, -0.442856f, 0.517304f, 0.399254f,
+		0.203181f, -0.967950f, -0.147618f, 0.000000f, 0.203181f, -0.967950f, -0.147618f, 0.966205f, 0.438787f,
+		0.138197f, -0.894429f, -0.425321f, 0.000000f, 0.138197f, -0.894429f, -0.425321f, 0.041434f, 0.519379f,
+		0.425323f, -0.850654f, -0.309011f, 0.000000f, 0.425323f, -0.850654f, -0.309011f, 0.719605f, 0.415221f,
+		0.609547f, -0.657519f, -0.442856f, 0.000000f, 0.609547f, -0.657519f, -0.442856f, 0.517304f, 0.399254f,
+		0.361804f, -0.723612f, -0.587779f, 0.000000f, 0.361804f, -0.723612f, -0.587779f, 1.014094f, 0.430832f,
+		0.531941f, -0.502302f, -0.681712f, 0.000000f, 0.531941f, -0.502302f, -0.681712f, 0.833640f, 0.738875f,
+		0.361804f, -0.723612f, -0.587779f, 0.000000f, 0.361804f, -0.723612f, -0.587779f, 1.014094f, 0.430832f,
+		0.262869f, -0.525738f, -0.809012f, 0.000000f, 0.262869f, -0.525738f, -0.809012f, 0.881800f, 0.682461f,
+		0.531941f, -0.502302f, -0.681712f, 0.000000f, 0.531941f, -0.502302f, -0.681712f, 0.833640f, 0.738875f,
+		0.425323f, -0.850654f, -0.309011f, 0.000000f, 0.425323f, -0.850654f, -0.309011f, 0.719605f, 0.415221f,
+		0.138197f, -0.894429f, -0.425321f, 0.000000f, 0.138197f, -0.894429f, -0.425321f, 0.041434f, 0.519379f,
+		0.361804f, -0.723612f, -0.587779f, 0.000000f, 0.361804f, -0.723612f, -0.587779f, 1.014094f, 0.430832f,
+		0.138197f, -0.894429f, -0.425321f, 0.000000f, 0.138197f, -0.894429f, -0.425321f, 0.041434f, 0.519379f,
+		0.052789f, -0.723611f, -0.688186f, 0.000000f, 0.052789f, -0.723611f, -0.688186f, 0.091499f, 0.516836f,
+		0.361804f, -0.723612f, -0.587779f, 0.000000f, 0.361804f, -0.723612f, -0.587779f, 1.014094f, 0.430832f,
+		0.361804f, -0.723612f, -0.587779f, 0.000000f, 0.361804f, -0.723612f, -0.587779f, 1.014094f, 0.430832f,
+		0.052789f, -0.723611f, -0.688186f, 0.000000f, 0.052789f, -0.723611f, -0.688186f, 0.091499f, 0.516836f,
+		0.262869f, -0.525738f, -0.809012f, 0.000000f, 0.262869f, -0.525738f, -0.809012f, 0.881800f, 0.682461f,
+		0.052789f, -0.723611f, -0.688186f, 0.000000f, 0.052789f, -0.723611f, -0.688186f, 0.091499f, 0.516836f,
+		-0.029639f, -0.502302f, -0.864184f, 0.000000f, -0.029639f, -0.502302f, -0.864184f, 0.836927f, 0.658241f,
+		0.262869f, -0.525738f, -0.809012f, 0.000000f, 0.262869f, -0.525738f, -0.809012f, 0.881800f, 0.682461f,
+		0.203181f, -0.967950f, -0.147618f, 0.000000f, 0.203181f, -0.967950f, -0.147618f, 0.966205f, 0.438787f,
+		-0.077607f, -0.967950f, -0.238853f, 0.000000f, -0.077607f, -0.967950f, -0.238853f, 0.043816f, 0.747734f,
+		0.138197f, -0.894429f, -0.425321f, 0.000000f, 0.138197f, -0.894429f, -0.425321f, 0.041434f, 0.519379f,
+		-0.077607f, -0.967950f, -0.238853f, 0.000000f, -0.077607f, -0.967950f, -0.238853f, 0.043816f, 0.747734f,
+		-0.162456f, -0.850654f, -0.499995f, 0.000000f, -0.162456f, -0.850654f, -0.499995f, 0.089135f, 0.684613f,
+		0.138197f, -0.894429f, -0.425321f, 0.000000f, 0.138197f, -0.894429f, -0.425321f, 0.041434f, 0.519379f,
+		0.138197f, -0.894429f, -0.425321f, 0.000000f, 0.138197f, -0.894429f, -0.425321f, 0.041434f, 0.519379f,
+		-0.162456f, -0.850654f, -0.499995f, 0.000000f, -0.162456f, -0.850654f, -0.499995f, 0.089135f, 0.684613f,
+		0.052789f, -0.723611f, -0.688186f, 0.000000f, 0.052789f, -0.723611f, -0.688186f, 0.091499f, 0.516836f,
+		-0.162456f, -0.850654f, -0.499995f, 0.000000f, -0.162456f, -0.850654f, -0.499995f, 0.089135f, 0.684613f,
+		-0.232822f, -0.657519f, -0.716563f, 0.000000f, -0.232822f, -0.657519f, -0.716563f, 0.042767f, 0.666943f,
+		0.052789f, -0.723611f, -0.688186f, 0.000000f, 0.052789f, -0.723611f, -0.688186f, 0.091499f, 0.516836f,
+		0.052789f, -0.723611f, -0.688186f, 0.000000f, 0.052789f, -0.723611f, -0.688186f, 0.091499f, 0.516836f,
+		-0.232822f, -0.657519f, -0.716563f, 0.000000f, -0.232822f, -0.657519f, -0.716563f, 0.042767f, 0.666943f,
+		-0.029639f, -0.502302f, -0.864184f, 0.000000f, -0.029639f, -0.502302f, -0.864184f, 0.836927f, 0.658241f,
+		-0.232822f, -0.657519f, -0.716563f, 0.000000f, -0.232822f, -0.657519f, -0.716563f, 0.042767f, 0.666943f,
+		-0.276388f, -0.447220f, -0.850649f, 0.000000f, -0.276388f, -0.447220f, -0.850649f, 0.750122f, 0.271069f,
+		-0.029639f, -0.502302f, -0.864184f, 0.000000f, -0.029639f, -0.502302f, -0.864184f, 0.836927f, 0.658241f,
+		0.956626f, 0.251149f, 0.147618f, 0.000000f, 0.956626f, 0.251149f, 0.147618f, 0.658365f, 0.135762f,
+		0.956626f, 0.251149f, -0.147618f, 0.000000f, 0.956626f, 0.251149f, -0.147618f, 0.610420f, 0.226784f,
+		0.894426f, 0.447216f, 0.000000f, 0.000000f, 0.894426f, 0.447216f, 0.000000f, 0.542767f, 0.333057f,
+		0.951058f, -0.000000f, 0.309013f, 0.000000f, 0.951058f, -0.000000f, 0.309013f, 0.646443f, 0.311386f,
+		1.000000f, 0.000000f, 0.000000f, 0.000000f, 1.000000f, 0.000000f, 0.000000f, 0.014094f, 0.430832f,
+		0.956626f, 0.251149f, 0.147618f, 0.000000f, 0.956626f, 0.251149f, 0.147618f, 0.658365f, 0.135762f,
+		0.860698f, -0.251151f, 0.442858f, 0.000000f, 0.860698f, -0.251151f, 0.442858f, 0.689049f, 0.234408f,
+		0.947213f, -0.276396f, 0.162458f, 0.000000f, 0.947213f, -0.276396f, 0.162458f, 0.067324f, 0.429118f,
+		0.951058f, -0.000000f, 0.309013f, 0.000000f, 0.951058f, -0.000000f, 0.309013f, 0.646443f, 0.311386f,
+		0.956626f, 0.251149f, 0.147618f, 0.000000f, 0.956626f, 0.251149f, 0.147618f, 0.658365f, 0.135762f,
+		1.000000f, 0.000000f, 0.000000f, 0.000000f, 1.000000f, 0.000000f, 0.000000f, 0.014094f, 0.430832f,
+		0.956626f, 0.251149f, -0.147618f, 0.000000f, 0.956626f, 0.251149f, -0.147618f, 0.610420f, 0.226784f,
+		1.000000f, 0.000000f, 0.000000f, 0.000000f, 1.000000f, 0.000000f, 0.000000f, 0.014094f, 0.430832f,
+		0.951058f, 0.000000f, -0.309013f, 0.000000f, 0.951058f, 0.000000f, -0.309013f, 0.546072f, 0.156902f,
+		0.956626f, 0.251149f, -0.147618f, 0.000000f, 0.956626f, 0.251149f, -0.147618f, 0.610420f, 0.226784f,
+		0.951058f, -0.000000f, 0.309013f, 0.000000f, 0.951058f, -0.000000f, 0.309013f, 0.646443f, 0.311386f,
+		0.947213f, -0.276396f, 0.162458f, 0.000000f, 0.947213f, -0.276396f, 0.162458f, 0.067324f, 0.429118f,
+		1.000000f, 0.000000f, 0.000000f, 0.000000f, 1.000000f, 0.000000f, 0.000000f, 0.014094f, 0.430832f,
+		0.947213f, -0.276396f, 0.162458f, 0.000000f, 0.947213f, -0.276396f, 0.162458f, 0.067324f, 0.429118f,
+		0.947213f, -0.276396f, -0.162458f, 0.000000f, 0.947213f, -0.276396f, -0.162458f, 0.711591f, 0.584513f,
+		1.000000f, 0.000000f, 0.000000f, 0.000000f, 1.000000f, 0.000000f, 0.000000f, 0.014094f, 0.430832f,
+		1.000000f, 0.000000f, 0.000000f, 0.000000f, 1.000000f, 0.000000f, 0.000000f, 0.014094f, 0.430832f,
+		0.947213f, -0.276396f, -0.162458f, 0.000000f, 0.947213f, -0.276396f, -0.162458f, 0.711591f, 0.584513f,
+		0.951058f, 0.000000f, -0.309013f, 0.000000f, 0.951058f, 0.000000f, -0.309013f, 0.546072f, 0.156902f,
+		0.947213f, -0.276396f, -0.162458f, 0.000000f, 0.947213f, -0.276396f, -0.162458f, 0.711591f, 0.584513f,
+		0.860698f, -0.251151f, -0.442858f, 0.000000f, 0.860698f, -0.251151f, -0.442858f, 0.543816f, 0.252266f,
+		0.951058f, 0.000000f, -0.309013f, 0.000000f, 0.951058f, 0.000000f, -0.309013f, 0.546072f, 0.156902f,
+		0.860698f, -0.251151f, 0.442858f, 0.000000f, 0.860698f, -0.251151f, 0.442858f, 0.689049f, 0.234408f,
+		0.812729f, -0.502301f, 0.295238f, 0.000000f, 0.812729f, -0.502301f, 0.295238f, 0.918131f, 0.436615f,
+		0.947213f, -0.276396f, 0.162458f, 0.000000f, 0.947213f, -0.276396f, 0.162458f, 0.067324f, 0.429118f,
+		0.812729f, -0.502301f, 0.295238f, 0.000000f, 0.812729f, -0.502301f, 0.295238f, 0.918131f, 0.436615f,
+		0.850648f, -0.525736f, 0.000000f, 0.000000f, 0.850648f, -0.525736f, 0.000000f, 0.115418f, 0.434134f,
+		0.947213f, -0.276396f, 0.162458f, 0.000000f, 0.947213f, -0.276396f, 0.162458f, 0.067324f, 0.429118f,
+		0.947213f, -0.276396f, 0.162458f, 0.000000f, 0.947213f, -0.276396f, 0.162458f, 0.067324f, 0.429118f,
+		0.850648f, -0.525736f, 0.000000f, 0.000000f, 0.850648f, -0.525736f, 0.000000f, 0.115418f, 0.434134f,
+		0.947213f, -0.276396f, -0.162458f, 0.000000f, 0.947213f, -0.276396f, -0.162458f, 0.711591f, 0.584513f,
+		0.850648f, -0.525736f, 0.000000f, 0.000000f, 0.850648f, -0.525736f, 0.000000f, 0.115418f, 0.434134f,
+		0.812729f, -0.502301f, -0.295238f, 0.000000f, 0.812729f, -0.502301f, -0.295238f, 0.314480f, 0.411140f,
+		0.947213f, -0.276396f, -0.162458f, 0.000000f, 0.947213f, -0.276396f, -0.162458f, 0.711591f, 0.584513f,
+		0.947213f, -0.276396f, -0.162458f, 0.000000f, 0.947213f, -0.276396f, -0.162458f, 0.711591f, 0.584513f,
+		0.812729f, -0.502301f, -0.295238f, 0.000000f, 0.812729f, -0.502301f, -0.295238f, 0.314480f, 0.411140f,
+		0.860698f, -0.251151f, -0.442858f, 0.000000f, 0.860698f, -0.251151f, -0.442858f, 0.543816f, 0.252266f,
+		0.812729f, -0.502301f, -0.295238f, 0.000000f, 0.812729f, -0.502301f, -0.295238f, 0.314480f, 0.411140f,
+		0.723607f, -0.447220f, -0.525725f, 0.000000f, 0.723607f, -0.447220f, -0.525725f, 0.791456f, 0.337315f,
+		0.860698f, -0.251151f, -0.442858f, 0.000000f, 0.860698f, -0.251151f, -0.442858f, 0.543816f, 0.252266f,
+		0.155215f, 0.251152f, 0.955422f, 0.000000f, 0.155215f, 0.251152f, 0.955422f, 0.944254f, 0.290379f,
+		0.436007f, 0.251152f, 0.864188f, 0.000000f, 0.436007f, 0.251152f, 0.864188f, 0.900083f, 0.348597f,
+		0.276388f, 0.447220f, 0.850649f, 0.000000f, 0.276388f, 0.447220f, 0.850649f, 1.304489f, 0.071876f,
+		-0.000000f, -0.000000f, 1.000000f, 0.000000f, -0.000000f, -0.000000f, 1.000000f, 0.846308f, 0.334943f,
+		0.309017f, 0.000000f, 0.951056f, 0.000000f, 0.309017f, 0.000000f, 0.951056f, 0.741373f, 0.498912f,
+		0.155215f, 0.251152f, 0.955422f, 0.000000f, 0.155215f, 0.251152f, 0.955422f, 0.944254f, 0.290379f,
+		-0.155215f, -0.251152f, 0.955422f, 0.000000f, -0.155215f, -0.251152f, 0.955422f, 0.885924f, 0.257323f,
+		0.138199f, -0.276398f, 0.951055f, 0.000000f, 0.138199f, -0.276398f, 0.951055f, 0.735205f, 0.674734f,
+		-0.000000f, -0.000000f, 1.000000f, 0.000000f, -0.000000f, -0.000000f, 1.000000f, 0.846308f, 0.334943f,
+		0.155215f, 0.251152f, 0.955422f, 0.000000f, 0.155215f, 0.251152f, 0.955422f, 0.944254f, 0.290379f,
+		0.309017f, 0.000000f, 0.951056f, 0.000000f, 0.309017f, 0.000000f, 0.951056f, 0.741373f, 0.498912f,
+		0.436007f, 0.251152f, 0.864188f, 0.000000f, 0.436007f, 0.251152f, 0.864188f, 0.900083f, 0.348597f,
+		0.309017f, 0.000000f, 0.951056f, 0.000000f, 0.309017f, 0.000000f, 0.951056f, 0.741373f, 0.498912f,
+		0.587786f, 0.000000f, 0.809017f, 0.000000f, 0.587786f, 0.000000f, 0.809017f, 0.757596f, 0.176140f,
+		0.436007f, 0.251152f, 0.864188f, 0.000000f, 0.436007f, 0.251152f, 0.864188f, 0.900083f, 0.348597f,
+		-0.000000f, -0.000000f, 1.000000f, 0.000000f, -0.000000f, -0.000000f, 1.000000f, 0.846308f, 0.334943f,
+		0.138199f, -0.276398f, 0.951055f, 0.000000f, 0.138199f, -0.276398f, 0.951055f, 0.735205f, 0.674734f,
+		0.309017f, 0.000000f, 0.951056f, 0.000000f, 0.309017f, 0.000000f, 0.951056f, 0.741373f, 0.498912f,
+		0.138199f, -0.276398f, 0.951055f, 0.000000f, 0.138199f, -0.276398f, 0.951055f, 0.735205f, 0.674734f,
+		0.447216f, -0.276398f, 0.850648f, 0.000000f, 0.447216f, -0.276398f, 0.850648f, 0.765485f, 0.591271f,
+		0.309017f, 0.000000f, 0.951056f, 0.000000f, 0.309017f, 0.000000f, 0.951056f, 0.741373f, 0.498912f,
+		0.309017f, 0.000000f, 0.951056f, 0.000000f, 0.309017f, 0.000000f, 0.951056f, 0.741373f, 0.498912f,
+		0.447216f, -0.276398f, 0.850648f, 0.000000f, 0.447216f, -0.276398f, 0.850648f, 0.765485f, 0.591271f,
+		0.587786f, 0.000000f, 0.809017f, 0.000000f, 0.587786f, 0.000000f, 0.809017f, 0.757596f, 0.176140f,
+		0.447216f, -0.276398f, 0.850648f, 0.000000f, 0.447216f, -0.276398f, 0.850648f, 0.765485f, 0.591271f,
+		0.687159f, -0.251152f, 0.681715f, 0.000000f, 0.687159f, -0.251152f, 0.681715f, 0.702477f, 0.326245f,
+		0.587786f, 0.000000f, 0.809017f, 0.000000f, 0.587786f, 0.000000f, 0.809017f, 0.757596f, 0.176140f,
+		-0.155215f, -0.251152f, 0.955422f, 0.000000f, -0.155215f, -0.251152f, 0.955422f, 0.885924f, 0.257323f,
+		-0.029639f, -0.502302f, 0.864184f, 0.000000f, -0.029639f, -0.502302f, 0.864184f, 0.180731f, 0.340648f,
+		0.138199f, -0.276398f, 0.951055f, 0.000000f, 0.138199f, -0.276398f, 0.951055f, 0.735205f, 0.674734f,
+		-0.029639f, -0.502302f, 0.864184f, 0.000000f, -0.029639f, -0.502302f, 0.864184f, 0.180731f, 0.340648f,
+		0.262869f, -0.525738f, 0.809012f, 0.000000f, 0.262869f, -0.525738f, 0.809012f, 0.137692f, 0.365246f,
+		0.138199f, -0.276398f, 0.951055f, 0.000000f, 0.138199f, -0.276398f, 0.951055f, 0.735205f, 0.674734f,
+		0.138199f, -0.276398f, 0.951055f, 0.000000f, 0.138199f, -0.276398f, 0.951055f, 0.735205f, 0.674734f,
+		0.262869f, -0.525738f, 0.809012f, 0.000000f, 0.262869f, -0.525738f, 0.809012f, 0.137692f, 0.365246f,
+		0.447216f, -0.276398f, 0.850648f, 0.000000f, 0.447216f, -0.276398f, 0.850648f, 0.765485f, 0.591271f,
+		0.262869f, -0.525738f, 0.809012f, 0.000000f, 0.262869f, -0.525738f, 0.809012f, 0.137692f, 0.365246f,
+		0.531941f, -0.502302f, 0.681712f, 0.000000f, 0.531941f, -0.502302f, 0.681712f, 0.363599f, 0.405960f,
+		0.447216f, -0.276398f, 0.850648f, 0.000000f, 0.447216f, -0.276398f, 0.850648f, 0.765485f, 0.591271f,
+		0.447216f, -0.276398f, 0.850648f, 0.000000f, 0.447216f, -0.276398f, 0.850648f, 0.765485f, 0.591271f,
+		0.531941f, -0.502302f, 0.681712f, 0.000000f, 0.531941f, -0.502302f, 0.681712f, 0.363599f, 0.405960f,
+		0.687159f, -0.251152f, 0.681715f, 0.000000f, 0.687159f, -0.251152f, 0.681715f, 0.702477f, 0.326245f,
+		0.531941f, -0.502302f, 0.681712f, 0.000000f, 0.531941f, -0.502302f, 0.681712f, 0.363599f, 0.405960f,
+		0.723607f, -0.447220f, 0.525725f, 0.000000f, 0.723607f, -0.447220f, 0.525725f, 0.779690f, 0.082142f,
+		0.687159f, -0.251152f, 0.681715f, 0.000000f, 0.687159f, -0.251152f, 0.681715f, 0.702477f, 0.326245f,
+		-0.860698f, 0.251151f, 0.442858f, 0.000000f, -0.860698f, 0.251151f, 0.442858f, 0.333640f, 0.261125f,
+		-0.687159f, 0.251152f, 0.681715f, 0.000000f, -0.687159f, 0.251152f, 0.681715f, 0.856930f, 0.159299f,
+		-0.723607f, 0.447220f, 0.525725f, 0.000000f, -0.723607f, 0.447220f, 0.525725f, 1.115709f, 0.094716f,
+		-0.951058f, -0.000000f, 0.309013f, 0.000000f, -0.951058f, -0.000000f, 0.309013f, 0.326823f, 0.166086f,
+		-0.809018f, 0.000000f, 0.587783f, 0.000000f, -0.809018f, 0.000000f, 0.587783f, 0.791096f, 0.672983f,
+		-0.860698f, 0.251151f, 0.442858f, 0.000000f, -0.860698f, 0.251151f, 0.442858f, 0.333640f, 0.261125f,
+		-0.956626f, -0.251149f, 0.147618f, 0.000000f, -0.956626f, -0.251149f, 0.147618f, 0.397050f, 0.226232f,
+		-0.861803f, -0.276396f, 0.425324f, 0.000000f, -0.861803f, -0.276396f, 0.425324f, 0.514094f, 0.569167f,
+		-0.951058f, -0.000000f, 0.309013f, 0.000000f, -0.951058f, -0.000000f, 0.309013f, 0.326823f, 0.166086f,
+		-0.860698f, 0.251151f, 0.442858f, 0.000000f, -0.860698f, 0.251151f, 0.442858f, 0.333640f, 0.261125f,
+		-0.809018f, 0.000000f, 0.587783f, 0.000000f, -0.809018f, 0.000000f, 0.587783f, 0.791096f, 0.672983f,
+		-0.687159f, 0.251152f, 0.681715f, 0.000000f, -0.687159f, 0.251152f, 0.681715f, 0.856930f, 0.159299f,
+		-0.809018f, 0.000000f, 0.587783f, 0.000000f, -0.809018f, 0.000000f, 0.587783f, 0.791096f, 0.672983f,
+		-0.587786f, 0.000000f, 0.809017f, 0.000000f, -0.587786f, 0.000000f, 0.809017f, 0.946597f, 0.195033f,
+		-0.687159f, 0.251152f, 0.681715f, 0.000000f, -0.687159f, 0.251152f, 0.681715f, 0.856930f, 0.159299f,
+		-0.951058f, -0.000000f, 0.309013f, 0.000000f, -0.951058f, -0.000000f, 0.309013f, 0.326823f, 0.166086f,
+		-0.861803f, -0.276396f, 0.425324f, 0.000000f, -0.861803f, -0.276396f, 0.425324f, 0.514094f, 0.569167f,
+		-0.809018f, 0.000000f, 0.587783f, 0.000000f, -0.809018f, 0.000000f, 0.587783f, 0.791096f, 0.672983f,
+		-0.861803f, -0.276396f, 0.425324f, 0.000000f, -0.861803f, -0.276396f, 0.425324f, 0.514094f, 0.569167f,
+		-0.670819f, -0.276397f, 0.688191f, 0.000000f, -0.670819f, -0.276397f, 0.688191f, 0.541434f, 0.480621f,
+		-0.809018f, 0.000000f, 0.587783f, 0.000000f, -0.809018f, 0.000000f, 0.587783f, 0.791096f, 0.672983f,
+		-0.809018f, 0.000000f, 0.587783f, 0.000000f, -0.809018f, 0.000000f, 0.587783f, 0.791096f, 0.672983f,
+		-0.670819f, -0.276397f, 0.688191f, 0.000000f, -0.670819f, -0.276397f, 0.688191f, 0.541434f, 0.480621f,
+		-0.587786f, 0.000000f, 0.809017f, 0.000000f, -0.587786f, 0.000000f, 0.809017f, 0.946597f, 0.195033f,
+		-0.670819f, -0.276397f, 0.688191f, 0.000000f, -0.670819f, -0.276397f, 0.688191f, 0.541434f, 0.480621f,
+		-0.436007f, -0.251152f, 0.864188f, 0.000000f, -0.436007f, -0.251152f, 0.864188f, 0.813138f, 0.249674f,
+		-0.587786f, 0.000000f, 0.809017f, 0.000000f, -0.587786f, 0.000000f, 0.809017f, 0.946597f, 0.195033f,
+		-0.956626f, -0.251149f, 0.147618f, 0.000000f, -0.956626f, -0.251149f, 0.147618f, 0.397050f, 0.226232f,
+		-0.831051f, -0.502299f, 0.238853f, 0.000000f, -0.831051f, -0.502299f, 0.238853f, 0.634945f, 0.715428f,
+		-0.861803f, -0.276396f, 0.425324f, 0.000000f, -0.861803f, -0.276396f, 0.425324f, 0.514094f, 0.569167f,
+		-0.831051f, -0.502299f, 0.238853f, 0.000000f, -0.831051f, -0.502299f, 0.238853f, 0.634945f, 0.715428f,
+		-0.688189f, -0.525736f, 0.499997f, 0.000000f, -0.688189f, -0.525736f, 0.499997f, 0.680731f, 0.659352f,
+		-0.861803f, -0.276396f, 0.425324f, 0.000000f, -0.861803f, -0.276396f, 0.425324f, 0.514094f, 0.569167f,
+		-0.861803f, -0.276396f, 0.425324f, 0.000000f, -0.861803f, -0.276396f, 0.425324f, 0.514094f, 0.569167f,
+		-0.688189f, -0.525736f, 0.499997f, 0.000000f, -0.688189f, -0.525736f, 0.499997f, 0.680731f, 0.659352f,
+		-0.670819f, -0.276397f, 0.688191f, 0.000000f, -0.670819f, -0.276397f, 0.688191f, 0.541434f, 0.480621f,
+		-0.688189f, -0.525736f, 0.499997f, 0.000000f, -0.688189f, -0.525736f, 0.499997f, 0.680731f, 0.659352f,
+		-0.483971f, -0.502302f, 0.716565f, 0.000000f, -0.483971f, -0.502302f, 0.716565f, 0.637692f, 0.634754f,
+		-0.670819f, -0.276397f, 0.688191f, 0.000000f, -0.670819f, -0.276397f, 0.688191f, 0.541434f, 0.480621f,
+		-0.670819f, -0.276397f, 0.688191f, 0.000000f, -0.670819f, -0.276397f, 0.688191f, 0.541434f, 0.480621f,
+		-0.483971f, -0.502302f, 0.716565f, 0.000000f, -0.483971f, -0.502302f, 0.716565f, 0.637692f, 0.634754f,
+		-0.436007f, -0.251152f, 0.864188f, 0.000000f, -0.436007f, -0.251152f, 0.864188f, 0.813138f, 0.249674f,
+		-0.483971f, -0.502302f, 0.716565f, 0.000000f, -0.483971f, -0.502302f, 0.716565f, 0.637692f, 0.634754f,
+		-0.276388f, -0.447220f, 0.850649f, 0.000000f, -0.276388f, -0.447220f, 0.850649f, 0.554423f, 0.061638f,
+		-0.436007f, -0.251152f, 0.864188f, 0.000000f, -0.436007f, -0.251152f, 0.864188f, 0.813138f, 0.249674f,
+		-0.687159f, 0.251152f, -0.681715f, 0.000000f, -0.687159f, 0.251152f, -0.681715f, 0.477658f, 0.222612f,
+		-0.860698f, 0.251151f, -0.442858f, 0.000000f, -0.860698f, 0.251151f, -0.442858f, 0.438926f, 0.305137f,
+		-0.723607f, 0.447220f, -0.525725f, 0.000000f, -0.723607f, 0.447220f, -0.525725f, 0.952607f, 0.099770f,
+		-0.587786f, -0.000000f, -0.809017f, 0.000000f, -0.587786f, -0.000000f, -0.809017f, 0.496685f, 0.312438f,
+		-0.809018f, -0.000000f, -0.587783f, 0.000000f, -0.809018f, -0.000000f, -0.587783f, 0.539894f, 0.656807f,
+		-0.687159f, 0.251152f, -0.681715f, 0.000000f, -0.687159f, 0.251152f, -0.681715f, 0.477658f, 0.222612f,
+		-0.436007f, -0.251152f, -0.864188f, 0.000000f, -0.436007f, -0.251152f, -0.864188f, 0.134945f, 0.284572f,
+		-0.670819f, -0.276397f, -0.688191f, 0.000000f, -0.670819f, -0.276397f, -0.688191f, 0.567324f, 0.570882f,
+		-0.587786f, -0.000000f, -0.809017f, 0.000000f, -0.587786f, -0.000000f, -0.809017f, 0.496685f, 0.312438f,
+		-0.687159f, 0.251152f, -0.681715f, 0.000000f, -0.687159f, 0.251152f, -0.681715f, 0.477658f, 0.222612f,
+		-0.809018f, -0.000000f, -0.587783f, 0.000000f, -0.809018f, -0.000000f, -0.587783f, 0.539894f, 0.656807f,
+		-0.860698f, 0.251151f, -0.442858f, 0.000000f, -0.860698f, 0.251151f, -0.442858f, 0.438926f, 0.305137f,
+		-0.809018f, -0.000000f, -0.587783f, 0.000000f, -0.809018f, -0.000000f, -0.587783f, 0.539894f, 0.656807f,
+		-0.951058f, 0.000000f, -0.309013f, 0.000000f, -0.951058f, 0.000000f, -0.309013f, 0.433048f, 0.129063f,
+		-0.860698f, 0.251151f, -0.442858f, 0.000000f, -0.860698f, 0.251151f, -0.442858f, 0.438926f, 0.305137f,
+		-0.587786f, -0.000000f, -0.809017f, 0.000000f, -0.587786f, -0.000000f, -0.809017f, 0.496685f, 0.312438f,
+		-0.670819f, -0.276397f, -0.688191f, 0.000000f, -0.670819f, -0.276397f, -0.688191f, 0.567324f, 0.570882f,
+		-0.809018f, -0.000000f, -0.587783f, 0.000000f, -0.809018f, -0.000000f, -0.587783f, 0.539894f, 0.656807f,
+		-0.670819f, -0.276397f, -0.688191f, 0.000000f, -0.670819f, -0.276397f, -0.688191f, 0.567324f, 0.570882f,
+		-0.861803f, -0.276396f, -0.425324f, 0.000000f, -0.861803f, -0.276396f, -0.425324f, 0.593723f, 0.650945f,
+		-0.809018f, -0.000000f, -0.587783f, 0.000000f, -0.809018f, -0.000000f, -0.587783f, 0.539894f, 0.656807f,
+		-0.809018f, -0.000000f, -0.587783f, 0.000000f, -0.809018f, -0.000000f, -0.587783f, 0.539894f, 0.656807f,
+		-0.861803f, -0.276396f, -0.425324f, 0.000000f, -0.861803f, -0.276396f, -0.425324f, 0.593723f, 0.650945f,
+		-0.951058f, 0.000000f, -0.309013f, 0.000000f, -0.951058f, 0.000000f, -0.309013f, 0.433048f, 0.129063f,
+		-0.861803f, -0.276396f, -0.425324f, 0.000000f, -0.861803f, -0.276396f, -0.425324f, 0.593723f, 0.650945f,
+		-0.956626f, -0.251149f, -0.147618f, 0.000000f, -0.956626f, -0.251149f, -0.147618f, 0.304489f, 0.071876f,
+		-0.951058f, 0.000000f, -0.309013f, 0.000000f, -0.951058f, 0.000000f, -0.309013f, 0.433048f, 0.129063f,
+		-0.436007f, -0.251152f, -0.864188f, 0.000000f, -0.436007f, -0.251152f, -0.864188f, 0.134945f, 0.284572f,
+		-0.483971f, -0.502302f, -0.716565f, 0.000000f, -0.483971f, -0.502302f, -0.716565f, 0.250122f, 0.728931f,
+		-0.670819f, -0.276397f, -0.688191f, 0.000000f, -0.670819f, -0.276397f, -0.688191f, 0.567324f, 0.570882f,
+		-0.483971f, -0.502302f, -0.716565f, 0.000000f, -0.483971f, -0.502302f, -0.716565f, 0.250122f, 0.728931f,
+		-0.688189f, -0.525736f, -0.499997f, 0.000000f, -0.688189f, -0.525736f, -0.499997f, 0.291456f, 0.662685f,
+		-0.670819f, -0.276397f, -0.688191f, 0.000000f, -0.670819f, -0.276397f, -0.688191f, 0.567324f, 0.570882f,
+		-0.670819f, -0.276397f, -0.688191f, 0.000000f, -0.670819f, -0.276397f, -0.688191f, 0.567324f, 0.570882f,
+		-0.688189f, -0.525736f, -0.499997f, 0.000000f, -0.688189f, -0.525736f, -0.499997f, 0.291456f, 0.662685f,
+		-0.861803f, -0.276396f, -0.425324f, 0.000000f, -0.861803f, -0.276396f, -0.425324f, 0.593723f, 0.650945f,
+		-0.688189f, -0.525736f, -0.499997f, 0.000000f, -0.688189f, -0.525736f, -0.499997f, 0.291456f, 0.662685f,
+		-0.831051f, -0.502299f, -0.238853f, 0.000000f, -0.831051f, -0.502299f, -0.238853f, 0.246383f, 0.648358f,
+		-0.861803f, -0.276396f, -0.425324f, 0.000000f, -0.861803f, -0.276396f, -0.425324f, 0.593723f, 0.650945f,
+		-0.861803f, -0.276396f, -0.425324f, 0.000000f, -0.861803f, -0.276396f, -0.425324f, 0.593723f, 0.650945f,
+		-0.831051f, -0.502299f, -0.238853f, 0.000000f, -0.831051f, -0.502299f, -0.238853f, 0.246383f, 0.648358f,
+		-0.956626f, -0.251149f, -0.147618f, 0.000000f, -0.956626f, -0.251149f, -0.147618f, 0.304489f, 0.071876f,
+		-0.831051f, -0.502299f, -0.238853f, 0.000000f, -0.831051f, -0.502299f, -0.238853f, 0.246383f, 0.648358f,
+		-0.894426f, -0.447216f, 0.000000f, 0.000000f, -0.894426f, -0.447216f, 0.000000f, 0.746383f, 0.351642f,
+		-0.956626f, -0.251149f, -0.147618f, 0.000000f, -0.956626f, -0.251149f, -0.147618f, 0.304489f, 0.071876f,
+		0.436007f, 0.251152f, -0.864188f, 0.000000f, 0.436007f, 0.251152f, -0.864188f, 0.221600f, 0.149916f,
+		0.155215f, 0.251152f, -0.955422f, 0.000000f, 0.155215f, 0.251152f, -0.955422f, 0.115709f, 0.094716f,
+		0.276388f, 0.447220f, -0.850649f, 0.000000f, 0.276388f, 0.447220f, -0.850649f, 0.768276f, 0.421330f,
+		0.587786f, -0.000000f, -0.809017f, 0.000000f, 0.587786f, -0.000000f, -0.809017f, 0.235205f, 0.325266f,
+		0.309017f, -0.000000f, -0.951056f, 0.000000f, 0.309017f, -0.000000f, -0.951056f, 0.316839f, 0.581107f,
+		0.436007f, 0.251152f, -0.864188f, 0.000000f, 0.436007f, 0.251152f, -0.864188f, 0.221600f, 0.149916f,
+		0.687159f, -0.251152f, -0.681715f, 0.000000f, 0.687159f, -0.251152f, -0.681715f, 0.268675f, 0.239476f,
+		0.447216f, -0.276398f, -0.850648f, 0.000000f, 0.447216f, -0.276398f, -0.850648f, 0.341211f, 0.489117f,
+		0.587786f, -0.000000f, -0.809017f, 0.000000f, 0.587786f, -0.000000f, -0.809017f, 0.235205f, 0.325266f,
+		0.436007f, 0.251152f, -0.864188f, 0.000000f, 0.436007f, 0.251152f, -0.864188f, 0.221600f, 0.149916f,
+		0.309017f, -0.000000f, -0.951056f, 0.000000f, 0.309017f, -0.000000f, -0.951056f, 0.316839f, 0.581107f,
+		0.155215f, 0.251152f, -0.955422f, 0.000000f, 0.155215f, 0.251152f, -0.955422f, 0.115709f, 0.094716f,
+		0.309017f, -0.000000f, -0.951056f, 0.000000f, 0.309017f, -0.000000f, -0.951056f, 0.316839f, 0.581107f,
+		0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.193762f, 0.248844f,
+		0.155215f, 0.251152f, -0.955422f, 0.000000f, 0.155215f, 0.251152f, -0.955422f, 0.115709f, 0.094716f,
+		0.587786f, -0.000000f, -0.809017f, 0.000000f, 0.587786f, -0.000000f, -0.809017f, 0.235205f, 0.325266f,
+		0.447216f, -0.276398f, -0.850648f, 0.000000f, 0.447216f, -0.276398f, -0.850648f, 0.341211f, 0.489117f,
+		0.309017f, -0.000000f, -0.951056f, 0.000000f, 0.309017f, -0.000000f, -0.951056f, 0.316839f, 0.581107f,
+		0.447216f, -0.276398f, -0.850648f, 0.000000f, 0.447216f, -0.276398f, -0.850648f, 0.341211f, 0.489117f,
+		0.138199f, -0.276398f, -0.951055f, 0.000000f, 0.138199f, -0.276398f, -0.951055f, 0.346308f, 0.665057f,
+		0.309017f, -0.000000f, -0.951056f, 0.000000f, 0.309017f, -0.000000f, -0.951056f, 0.316839f, 0.581107f,
+		0.309017f, -0.000000f, -0.951056f, 0.000000f, 0.309017f, -0.000000f, -0.951056f, 0.316839f, 0.581107f,
+		0.138199f, -0.276398f, -0.951055f, 0.000000f, 0.138199f, -0.276398f, -0.951055f, 0.346308f, 0.665057f,
+		0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.193762f, 0.248844f,
+		0.138199f, -0.276398f, -0.951055f, 0.000000f, 0.138199f, -0.276398f, -0.951055f, 0.346308f, 0.665057f,
+		-0.155215f, -0.251152f, -0.955422f, 0.000000f, -0.155215f, -0.251152f, -0.955422f, 0.129692f, 0.189429f,
+		0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.193762f, 0.248844f,
+		0.687159f, -0.251152f, -0.681715f, 0.000000f, 0.687159f, -0.251152f, -0.681715f, 0.268675f, 0.239476f,
+		0.531941f, -0.502302f, -0.681712f, 0.000000f, 0.531941f, -0.502302f, -0.681712f, 0.833640f, 0.738875f,
+		0.447216f, -0.276398f, -0.850648f, 0.000000f, 0.447216f, -0.276398f, -0.850648f, 0.341211f, 0.489117f,
+		0.531941f, -0.502302f, -0.681712f, 0.000000f, 0.531941f, -0.502302f, -0.681712f, 0.833640f, 0.738875f,
+		0.262869f, -0.525738f, -0.809012f, 0.000000f, 0.262869f, -0.525738f, -0.809012f, 0.881800f, 0.682461f,
+		0.447216f, -0.276398f, -0.850648f, 0.000000f, 0.447216f, -0.276398f, -0.850648f, 0.341211f, 0.489117f,
+		0.447216f, -0.276398f, -0.850648f, 0.000000f, 0.447216f, -0.276398f, -0.850648f, 0.341211f, 0.489117f,
+		0.262869f, -0.525738f, -0.809012f, 0.000000f, 0.262869f, -0.525738f, -0.809012f, 0.881800f, 0.682461f,
+		0.138199f, -0.276398f, -0.951055f, 0.000000f, 0.138199f, -0.276398f, -0.951055f, 0.346308f, 0.665057f,
+		0.262869f, -0.525738f, -0.809012f, 0.000000f, 0.262869f, -0.525738f, -0.809012f, 0.881800f, 0.682461f,
+		-0.029639f, -0.502302f, -0.864184f, 0.000000f, -0.029639f, -0.502302f, -0.864184f, 0.836927f, 0.658241f,
+		0.138199f, -0.276398f, -0.951055f, 0.000000f, 0.138199f, -0.276398f, -0.951055f, 0.346308f, 0.665057f,
+		0.138199f, -0.276398f, -0.951055f, 0.000000f, 0.138199f, -0.276398f, -0.951055f, 0.346308f, 0.665057f,
+		-0.029639f, -0.502302f, -0.864184f, 0.000000f, -0.029639f, -0.502302f, -0.864184f, 0.836927f, 0.658241f,
+		-0.155215f, -0.251152f, -0.955422f, 0.000000f, -0.155215f, -0.251152f, -0.955422f, 0.129692f, 0.189429f,
+		-0.029639f, -0.502302f, -0.864184f, 0.000000f, -0.029639f, -0.502302f, -0.864184f, 0.836927f, 0.658241f,
+		-0.276388f, -0.447220f, -0.850649f, 0.000000f, -0.276388f, -0.447220f, -0.850649f, 0.750122f, 0.271069f,
+		-0.155215f, -0.251152f, -0.955422f, 0.000000f, -0.155215f, -0.251152f, -0.955422f, 0.129692f, 0.189429f,
+		0.436007f, 0.251152f, 0.864188f, 0.000000f, 0.436007f, 0.251152f, 0.864188f, 0.900083f, 0.348597f,
+		0.483971f, 0.502302f, 0.716565f, 0.000000f, 0.483971f, 0.502302f, 0.716565f, 1.036828f, 0.167036f,
+		0.276388f, 0.447220f, 0.850649f, 0.000000f, 0.276388f, 0.447220f, 0.850649f, 1.304489f, 0.071876f,
+		0.587786f, 0.000000f, 0.809017f, 0.000000f, 0.587786f, 0.000000f, 0.809017f, 0.757596f, 0.176140f,
+		0.670820f, 0.276396f, 0.688190f, 0.000000f, 0.670820f, 0.276396f, 0.688190f, 0.370330f, 0.575469f,
+		0.436007f, 0.251152f, 0.864188f, 0.000000f, 0.436007f, 0.251152f, 0.864188f, 0.900083f, 0.348597f,
+		0.687159f, -0.251152f, 0.681715f, 0.000000f, 0.687159f, -0.251152f, 0.681715f, 0.702477f, 0.326245f,
+		0.809019f, -0.000002f, 0.587783f, 0.000000f, 0.809019f, -0.000002f, 0.587783f, 0.400083f, 0.651403f,
+		0.587786f, 0.000000f, 0.809017f, 0.000000f, 0.587786f, 0.000000f, 0.809017f, 0.757596f, 0.176140f,
+		0.436007f, 0.251152f, 0.864188f, 0.000000f, 0.436007f, 0.251152f, 0.864188f, 0.900083f, 0.348597f,
+		0.670820f, 0.276396f, 0.688190f, 0.000000f, 0.670820f, 0.276396f, 0.688190f, 0.370330f, 0.575469f,
+		0.483971f, 0.502302f, 0.716565f, 0.000000f, 0.483971f, 0.502302f, 0.716565f, 1.036828f, 0.167036f,
+		0.670820f, 0.276396f, 0.688190f, 0.000000f, 0.670820f, 0.276396f, 0.688190f, 0.370330f, 0.575469f,
+		0.688189f, 0.525736f, 0.499997f, 0.000000f, 0.688189f, 0.525736f, 0.499997f, 1.003325f, 0.262529f,
+		0.483971f, 0.502302f, 0.716565f, 0.000000f, 0.483971f, 0.502302f, 0.716565f, 1.036828f, 0.167036f,
+		0.587786f, 0.000000f, 0.809017f, 0.000000f, 0.587786f, 0.000000f, 0.809017f, 0.757596f, 0.176140f,
+		0.809019f, -0.000002f, 0.587783f, 0.000000f, 0.809019f, -0.000002f, 0.587783f, 0.400083f, 0.651403f,
+		0.670820f, 0.276396f, 0.688190f, 0.000000f, 0.670820f, 0.276396f, 0.688190f, 0.370330f, 0.575469f,
+		0.809019f, -0.000002f, 0.587783f, 0.000000f, 0.809019f, -0.000002f, 0.587783f, 0.400083f, 0.651403f,
+		0.861804f, 0.276394f, 0.425323f, 0.000000f, 0.861804f, 0.276394f, 0.425323f, 0.116405f, 0.604155f,
+		0.670820f, 0.276396f, 0.688190f, 0.000000f, 0.670820f, 0.276396f, 0.688190f, 0.370330f, 0.575469f,
+		0.670820f, 0.276396f, 0.688190f, 0.000000f, 0.670820f, 0.276396f, 0.688190f, 0.370330f, 0.575469f,
+		0.861804f, 0.276394f, 0.425323f, 0.000000f, 0.861804f, 0.276394f, 0.425323f, 0.116405f, 0.604155f,
+		0.688189f, 0.525736f, 0.499997f, 0.000000f, 0.688189f, 0.525736f, 0.499997f, 1.003325f, 0.262529f,
+		0.861804f, 0.276394f, 0.425323f, 0.000000f, 0.861804f, 0.276394f, 0.425323f, 0.116405f, 0.604155f,
+		0.831051f, 0.502299f, 0.238853f, 0.000000f, 0.831051f, 0.502299f, 0.238853f, 0.291096f, 0.327017f,
+		0.688189f, 0.525736f, 0.499997f, 0.000000f, 0.688189f, 0.525736f, 0.499997f, 1.003325f, 0.262529f,
+		0.687159f, -0.251152f, 0.681715f, 0.000000f, 0.687159f, -0.251152f, 0.681715f, 0.702477f, 0.326245f,
+		0.860698f, -0.251151f, 0.442858f, 0.000000f, 0.860698f, -0.251151f, 0.442858f, 0.689049f, 0.234408f,
+		0.809019f, -0.000002f, 0.587783f, 0.000000f, 0.809019f, -0.000002f, 0.587783f, 0.400083f, 0.651403f,
+		0.860698f, -0.251151f, 0.442858f, 0.000000f, 0.860698f, -0.251151f, 0.442858f, 0.689049f, 0.234408f,
+		0.951058f, -0.000000f, 0.309013f, 0.000000f, 0.951058f, -0.000000f, 0.309013f, 0.646443f, 0.311386f,
+		0.809019f, -0.000002f, 0.587783f, 0.000000f, 0.809019f, -0.000002f, 0.587783f, 0.400083f, 0.651403f,
+		0.809019f, -0.000002f, 0.587783f, 0.000000f, 0.809019f, -0.000002f, 0.587783f, 0.400083f, 0.651403f,
+		0.951058f, -0.000000f, 0.309013f, 0.000000f, 0.951058f, -0.000000f, 0.309013f, 0.646443f, 0.311386f,
+		0.861804f, 0.276394f, 0.425323f, 0.000000f, 0.861804f, 0.276394f, 0.425323f, 0.116405f, 0.604155f,
+		0.951058f, -0.000000f, 0.309013f, 0.000000f, 0.951058f, -0.000000f, 0.309013f, 0.646443f, 0.311386f,
+		0.956626f, 0.251149f, 0.147618f, 0.000000f, 0.956626f, 0.251149f, 0.147618f, 0.658365f, 0.135762f,
+		0.861804f, 0.276394f, 0.425323f, 0.000000f, 0.861804f, 0.276394f, 0.425323f, 0.116405f, 0.604155f,
+		0.861804f, 0.276394f, 0.425323f, 0.000000f, 0.861804f, 0.276394f, 0.425323f, 0.116405f, 0.604155f,
+		0.956626f, 0.251149f, 0.147618f, 0.000000f, 0.956626f, 0.251149f, 0.147618f, 0.658365f, 0.135762f,
+		0.831051f, 0.502299f, 0.238853f, 0.000000f, 0.831051f, 0.502299f, 0.238853f, 0.291096f, 0.327017f,
+		0.956626f, 0.251149f, 0.147618f, 0.000000f, 0.956626f, 0.251149f, 0.147618f, 0.658365f, 0.135762f,
+		0.894426f, 0.447216f, 0.000000f, 0.000000f, 0.894426f, 0.447216f, 0.000000f, 0.542767f, 0.333057f,
+		0.831051f, 0.502299f, 0.238853f, 0.000000f, 0.831051f, 0.502299f, 0.238853f, 0.291096f, 0.327017f,
+		-0.687159f, 0.251152f, 0.681715f, 0.000000f, -0.687159f, 0.251152f, 0.681715f, 0.856930f, 0.159299f,
+		-0.531941f, 0.502302f, 0.681712f, 0.000000f, -0.531941f, 0.502302f, 0.681712f, 0.074553f, 0.260244f,
+		-0.723607f, 0.447220f, 0.525725f, 0.000000f, -0.723607f, 0.447220f, 0.525725f, 1.115709f, 0.094716f,
+		-0.587786f, 0.000000f, 0.809017f, 0.000000f, -0.587786f, 0.000000f, 0.809017f, 0.946597f, 0.195033f,
+		-0.447216f, 0.276397f, 0.850649f, 0.000000f, -0.447216f, 0.276397f, 0.850649f, 0.141510f, 0.512645f,
+		-0.687159f, 0.251152f, 0.681715f, 0.000000f, -0.687159f, 0.251152f, 0.681715f, 0.856930f, 0.159299f,
+		-0.436007f, -0.251152f, 0.864188f, 0.000000f, -0.436007f, -0.251152f, 0.864188f, 0.813138f, 0.249674f,
+		-0.309017f, -0.000001f, 0.951056f, 0.000000f, -0.309017f, -0.000001f, 0.951056f, 0.146443f, 0.688614f,
+		-0.587786f, 0.000000f, 0.809017f, 0.000000f, -0.587786f, 0.000000f, 0.809017f, 0.946597f, 0.195033f,
+		-0.687159f, 0.251152f, 0.681715f, 0.000000f, -0.687159f, 0.251152f, 0.681715f, 0.856930f, 0.159299f,
+		-0.447216f, 0.276397f, 0.850649f, 0.000000f, -0.447216f, 0.276397f, 0.850649f, 0.141510f, 0.512645f,
+		-0.531941f, 0.502302f, 0.681712f, 0.000000f, -0.531941f, 0.502302f, 0.681712f, 0.074553f, 0.260244f,
+		-0.447216f, 0.276397f, 0.850649f, 0.000000f, -0.447216f, 0.276397f, 0.850649f, 0.141510f, 0.512645f,
+		-0.262869f, 0.525738f, 0.809012f, 0.000000f, -0.262869f, 0.525738f, 0.809012f, 0.036828f, 0.167036f,
+		-0.531941f, 0.502302f, 0.681712f, 0.000000f, -0.531941f, 0.502302f, 0.681712f, 0.074553f, 0.260244f,
+		-0.587786f, 0.000000f, 0.809017f, 0.000000f, -0.587786f, 0.000000f, 0.809017f, 0.946597f, 0.195033f,
+		-0.309017f, -0.000001f, 0.951056f, 0.000000f, -0.309017f, -0.000001f, 0.951056f, 0.146443f, 0.688614f,
+		-0.447216f, 0.276397f, 0.850649f, 0.000000f, -0.447216f, 0.276397f, 0.850649f, 0.141510f, 0.512645f,
+		-0.309017f, -0.000001f, 0.951056f, 0.000000f, -0.309017f, -0.000001f, 0.951056f, 0.146443f, 0.688614f,
+		-0.138199f, 0.276397f, 0.951055f, 0.000000f, -0.138199f, 0.276397f, 0.951055f, 0.171061f, 0.598834f,
+		-0.447216f, 0.276397f, 0.850649f, 0.000000f, -0.447216f, 0.276397f, 0.850649f, 0.141510f, 0.512645f,
+		-0.447216f, 0.276397f, 0.850649f, 0.000000f, -0.447216f, 0.276397f, 0.850649f, 0.141510f, 0.512645f,
+		-0.138199f, 0.276397f, 0.951055f, 0.000000f, -0.138199f, 0.276397f, 0.951055f, 0.171061f, 0.598834f,
+		-0.262869f, 0.525738f, 0.809012f, 0.000000f, -0.262869f, 0.525738f, 0.809012f, 0.036828f, 0.167036f,
+		-0.138199f, 0.276397f, 0.951055f, 0.000000f, -0.138199f, 0.276397f, 0.951055f, 0.171061f, 0.598834f,
+		0.029639f, 0.502302f, 0.864184f, 0.000000f, 0.029639f, 0.502302f, 0.864184f, 1.039894f, 0.343193f,
+		-0.262869f, 0.525738f, 0.809012f, 0.000000f, -0.262869f, 0.525738f, 0.809012f, 0.036828f, 0.167036f,
+		-0.436007f, -0.251152f, 0.864188f, 0.000000f, -0.436007f, -0.251152f, 0.864188f, 0.813138f, 0.249674f,
+		-0.155215f, -0.251152f, 0.955422f, 0.000000f, -0.155215f, -0.251152f, 0.955422f, 0.885924f, 0.257323f,
+		-0.309017f, -0.000001f, 0.951056f, 0.000000f, -0.309017f, -0.000001f, 0.951056f, 0.146443f, 0.688614f,
+		-0.155215f, -0.251152f, 0.955422f, 0.000000f, -0.155215f, -0.251152f, 0.955422f, 0.885924f, 0.257323f,
+		-0.000000f, -0.000000f, 1.000000f, 0.000000f, -0.000000f, -0.000000f, 1.000000f, 0.846308f, 0.334943f,
+		-0.309017f, -0.000001f, 0.951056f, 0.000000f, -0.309017f, -0.000001f, 0.951056f, 0.146443f, 0.688614f,
+		-0.309017f, -0.000001f, 0.951056f, 0.000000f, -0.309017f, -0.000001f, 0.951056f, 0.146443f, 0.688614f,
+		-0.000000f, -0.000000f, 1.000000f, 0.000000f, -0.000000f, -0.000000f, 1.000000f, 0.846308f, 0.334943f,
+		-0.138199f, 0.276397f, 0.951055f, 0.000000f, -0.138199f, 0.276397f, 0.951055f, 0.171061f, 0.598834f,
+		-0.000000f, -0.000000f, 1.000000f, 0.000000f, -0.000000f, -0.000000f, 1.000000f, 0.846308f, 0.334943f,
+		0.155215f, 0.251152f, 0.955422f, 0.000000f, 0.155215f, 0.251152f, 0.955422f, 0.944254f, 0.290379f,
+		-0.138199f, 0.276397f, 0.951055f, 0.000000f, -0.138199f, 0.276397f, 0.951055f, 0.171061f, 0.598834f,
+		-0.138199f, 0.276397f, 0.951055f, 0.000000f, -0.138199f, 0.276397f, 0.951055f, 0.171061f, 0.598834f,
+		0.155215f, 0.251152f, 0.955422f, 0.000000f, 0.155215f, 0.251152f, 0.955422f, 0.944254f, 0.290379f,
+		0.029639f, 0.502302f, 0.864184f, 0.000000f, 0.029639f, 0.502302f, 0.864184f, 1.039894f, 0.343193f,
+		0.155215f, 0.251152f, 0.955422f, 0.000000f, 0.155215f, 0.251152f, 0.955422f, 0.944254f, 0.290379f,
+		0.276388f, 0.447220f, 0.850649f, 0.000000f, 0.276388f, 0.447220f, 0.850649f, 1.304489f, 0.071876f,
+		0.029639f, 0.502302f, 0.864184f, 0.000000f, 0.029639f, 0.502302f, 0.864184f, 1.039894f, 0.343193f,
+		-0.860698f, 0.251151f, -0.442858f, 0.000000f, -0.860698f, 0.251151f, -0.442858f, 0.438926f, 0.305137f,
+		-0.812729f, 0.502301f, -0.295238f, 0.000000f, -0.812729f, 0.502301f, -0.295238f, 0.093723f, 0.349056f,
+		-0.723607f, 0.447220f, -0.525725f, 0.000000f, -0.723607f, 0.447220f, -0.525725f, 0.952607f, 0.099770f,
+		-0.951058f, 0.000000f, -0.309013f, 0.000000f, -0.951058f, 0.000000f, -0.309013f, 0.433048f, 0.129063f,
+		-0.947213f, 0.276396f, -0.162458f, 0.000000f, -0.947213f, 0.276396f, -0.162458f, 0.202477f, 0.673755f,
+		-0.860698f, 0.251151f, -0.442858f, 0.000000f, -0.860698f, 0.251151f, -0.442858f, 0.438926f, 0.305137f,
+		-0.956626f, -0.251149f, -0.147618f, 0.000000f, -0.956626f, -0.251149f, -0.147618f, 0.304489f, 0.071876f,
+		-1.000000f, 0.000001f, 0.000000f, 0.000000f, -1.000000f, 0.000001f, 0.000000f, 0.912676f, 0.606305f,
+		-0.951058f, 0.000000f, -0.309013f, 0.000000f, -0.951058f, 0.000000f, -0.309013f, 0.433048f, 0.129063f,
+		-0.860698f, 0.251151f, -0.442858f, 0.000000f, -0.860698f, 0.251151f, -0.442858f, 0.438926f, 0.305137f,
+		-0.947213f, 0.276396f, -0.162458f, 0.000000f, -0.947213f, 0.276396f, -0.162458f, 0.202477f, 0.673755f,
+		-0.812729f, 0.502301f, -0.295238f, 0.000000f, -0.812729f, 0.502301f, -0.295238f, 0.093723f, 0.349056f,
+		-0.947213f, 0.276396f, -0.162458f, 0.000000f, -0.947213f, 0.276396f, -0.162458f, 0.202477f, 0.673755f,
+		-0.850648f, 0.525736f, -0.000000f, 0.000000f, -0.850648f, 0.525736f, -0.000000f, 0.039894f, 0.343193f,
+		-0.812729f, 0.502301f, -0.295238f, 0.000000f, -0.812729f, 0.502301f, -0.295238f, 0.093723f, 0.349056f,
+		-0.951058f, 0.000000f, -0.309013f, 0.000000f, -0.951058f, 0.000000f, -0.309013f, 0.433048f, 0.129063f,
+		-1.000000f, 0.000001f, 0.000000f, 0.000000f, -1.000000f, 0.000001f, 0.000000f, 0.912676f, 0.606305f,
+		-0.947213f, 0.276396f, -0.162458f, 0.000000f, -0.947213f, 0.276396f, -0.162458f, 0.202477f, 0.673755f,
+		-1.000000f, 0.000001f, 0.000000f, 0.000000f, -1.000000f, 0.000001f, 0.000000f, 0.912676f, 0.606305f,
+		-0.947213f, 0.276397f, 0.162458f, 0.000000f, -0.947213f, 0.276397f, 0.162458f, 0.941248f, 0.518705f,
+		-0.947213f, 0.276396f, -0.162458f, 0.000000f, -0.947213f, 0.276396f, -0.162458f, 0.202477f, 0.673755f,
+		-0.947213f, 0.276396f, -0.162458f, 0.000000f, -0.947213f, 0.276396f, -0.162458f, 0.202477f, 0.673755f,
+		-0.947213f, 0.276397f, 0.162458f, 0.000000f, -0.947213f, 0.276397f, 0.162458f, 0.941248f, 0.518705f,
+		-0.850648f, 0.525736f, -0.000000f, 0.000000f, -0.850648f, 0.525736f, -0.000000f, 0.039894f, 0.343193f,
+		-0.947213f, 0.276397f, 0.162458f, 0.000000f, -0.947213f, 0.276397f, 0.162458f, 0.941248f, 0.518705f,
+		-0.812729f, 0.502301f, 0.295238f, 0.000000f, -0.812729f, 0.502301f, 0.295238f, 0.003325f, 0.262529f,
+		-0.850648f, 0.525736f, -0.000000f, 0.000000f, -0.850648f, 0.525736f, -0.000000f, 0.039894f, 0.343193f,
+		-0.956626f, -0.251149f, -0.147618f, 0.000000f, -0.956626f, -0.251149f, -0.147618f, 0.304489f, 0.071876f,
+		-0.956626f, -0.251149f, 0.147618f, 0.000000f, -0.956626f, -0.251149f, 0.147618f, 0.397050f, 0.226232f,
+		-1.000000f, 0.000001f, 0.000000f, 0.000000f, -1.000000f, 0.000001f, 0.000000f, 0.912676f, 0.606305f,
+		-0.956626f, -0.251149f, 0.147618f, 0.000000f, -0.956626f, -0.251149f, 0.147618f, 0.397050f, 0.226232f,
+		-0.951058f, -0.000000f, 0.309013f, 0.000000f, -0.951058f, -0.000000f, 0.309013f, 0.326823f, 0.166086f,
+		-1.000000f, 0.000001f, 0.000000f, 0.000000f, -1.000000f, 0.000001f, 0.000000f, 0.912676f, 0.606305f,
+		-1.000000f, 0.000001f, 0.000000f, 0.000000f, -1.000000f, 0.000001f, 0.000000f, 0.912676f, 0.606305f,
+		-0.951058f, -0.000000f, 0.309013f, 0.000000f, -0.951058f, -0.000000f, 0.309013f, 0.326823f, 0.166086f,
+		-0.947213f, 0.276397f, 0.162458f, 0.000000f, -0.947213f, 0.276397f, 0.162458f, 0.941248f, 0.518705f,
+		-0.951058f, -0.000000f, 0.309013f, 0.000000f, -0.951058f, -0.000000f, 0.309013f, 0.326823f, 0.166086f,
+		-0.860698f, 0.251151f, 0.442858f, 0.000000f, -0.860698f, 0.251151f, 0.442858f, 0.333640f, 0.261125f,
+		-0.947213f, 0.276397f, 0.162458f, 0.000000f, -0.947213f, 0.276397f, 0.162458f, 0.941248f, 0.518705f,
+		-0.947213f, 0.276397f, 0.162458f, 0.000000f, -0.947213f, 0.276397f, 0.162458f, 0.941248f, 0.518705f,
+		-0.860698f, 0.251151f, 0.442858f, 0.000000f, -0.860698f, 0.251151f, 0.442858f, 0.333640f, 0.261125f,
+		-0.812729f, 0.502301f, 0.295238f, 0.000000f, -0.812729f, 0.502301f, 0.295238f, 0.003325f, 0.262529f,
+		-0.860698f, 0.251151f, 0.442858f, 0.000000f, -0.860698f, 0.251151f, 0.442858f, 0.333640f, 0.261125f,
+		-0.723607f, 0.447220f, 0.525725f, 0.000000f, -0.723607f, 0.447220f, 0.525725f, 1.115709f, 0.094716f,
+		-0.812729f, 0.502301f, 0.295238f, 0.000000f, -0.812729f, 0.502301f, 0.295238f, 0.003325f, 0.262529f,
+		0.155215f, 0.251152f, -0.955422f, 0.000000f, 0.155215f, 0.251152f, -0.955422f, 0.115709f, 0.094716f,
+		0.029639f, 0.502302f, -0.864184f, 0.000000f, 0.029639f, 0.502302f, -0.864184f, 0.791278f, 0.505149f,
+		0.276388f, 0.447220f, -0.850649f, 0.000000f, 0.276388f, 0.447220f, -0.850649f, 0.768276f, 0.421330f,
+		0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.193762f, 0.248844f,
+		-0.138199f, 0.276397f, -0.951055f, 0.000000f, -0.138199f, 0.276397f, -0.951055f, 0.938926f, 0.694863f,
+		0.155215f, 0.251152f, -0.955422f, 0.000000f, 0.155215f, 0.251152f, -0.955422f, 0.115709f, 0.094716f,
+		-0.155215f, -0.251152f, -0.955422f, 0.000000f, -0.155215f, -0.251152f, -0.955422f, 0.129692f, 0.189429f,
+		-0.309016f, -0.000000f, -0.951057f, 0.000000f, -0.309016f, -0.000000f, -0.951057f, 0.967747f, 0.608792f,
+		0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.193762f, 0.248844f,
+		0.155215f, 0.251152f, -0.955422f, 0.000000f, 0.155215f, 0.251152f, -0.955422f, 0.115709f, 0.094716f,
+		-0.138199f, 0.276397f, -0.951055f, 0.000000f, -0.138199f, 0.276397f, -0.951055f, 0.938926f, 0.694863f,
+		0.029639f, 0.502302f, -0.864184f, 0.000000f, 0.029639f, 0.502302f, -0.864184f, 0.791278f, 0.505149f,
+		-0.138199f, 0.276397f, -0.951055f, 0.000000f, -0.138199f, 0.276397f, -0.951055f, 0.938926f, 0.694863f,
+		-0.262869f, 0.525738f, -0.809012f, 0.000000f, -0.262869f, 0.525738f, -0.809012f, 0.863599f, 0.594041f,
+		0.029639f, 0.502302f, -0.864184f, 0.000000f, 0.029639f, 0.502302f, -0.864184f, 0.791278f, 0.505149f,
+		0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.193762f, 0.248844f,
+		-0.309016f, -0.000000f, -0.951057f, 0.000000f, -0.309016f, -0.000000f, -0.951057f, 0.967747f, 0.608792f,
+		-0.138199f, 0.276397f, -0.951055f, 0.000000f, -0.138199f, 0.276397f, -0.951055f, 0.938926f, 0.694863f,
+		-0.309016f, -0.000000f, -0.951057f, 0.000000f, -0.309016f, -0.000000f, -0.951057f, 0.967747f, 0.608792f,
+		-0.447215f, 0.276397f, -0.850649f, 0.000000f, -0.447215f, 0.276397f, -0.850649f, 0.996685f, 0.687562f,
+		-0.138199f, 0.276397f, -0.951055f, 0.000000f, -0.138199f, 0.276397f, -0.951055f, 0.938926f, 0.694863f,
+		-0.138199f, 0.276397f, -0.951055f, 0.000000f, -0.138199f, 0.276397f, -0.951055f, 0.938926f, 0.694863f,
+		-0.447215f, 0.276397f, -0.850649f, 0.000000f, -0.447215f, 0.276397f, -0.850649f, 0.996685f, 0.687562f,
+		-0.262869f, 0.525738f, -0.809012f, 0.000000f, -0.262869f, 0.525738f, -0.809012f, 0.863599f, 0.594041f,
+		-0.447215f, 0.276397f, -0.850649f, 0.000000f, -0.447215f, 0.276397f, -0.850649f, 0.996685f, 0.687562f,
+		-0.531941f, 0.502302f, -0.681712f, 0.000000f, -0.531941f, 0.502302f, -0.681712f, 0.814480f, 0.588860f,
+		-0.262869f, 0.525738f, -0.809012f, 0.000000f, -0.262869f, 0.525738f, -0.809012f, 0.863599f, 0.594041f,
+		-0.155215f, -0.251152f, -0.955422f, 0.000000f, -0.155215f, -0.251152f, -0.955422f, 0.129692f, 0.189429f,
+		-0.436007f, -0.251152f, -0.864188f, 0.000000f, -0.436007f, -0.251152f, -0.864188f, 0.134945f, 0.284572f,
+		-0.309016f, -0.000000f, -0.951057f, 0.000000f, -0.309016f, -0.000000f, -0.951057f, 0.967747f, 0.608792f,
+		-0.436007f, -0.251152f, -0.864188f, 0.000000f, -0.436007f, -0.251152f, -0.864188f, 0.134945f, 0.284572f,
+		-0.587786f, -0.000000f, -0.809017f, 0.000000f, -0.587786f, -0.000000f, -0.809017f, 0.496685f, 0.312438f,
+		-0.309016f, -0.000000f, -0.951057f, 0.000000f, -0.309016f, -0.000000f, -0.951057f, 0.967747f, 0.608792f,
+		-0.309016f, -0.000000f, -0.951057f, 0.000000f, -0.309016f, -0.000000f, -0.951057f, 0.967747f, 0.608792f,
+		-0.587786f, -0.000000f, -0.809017f, 0.000000f, -0.587786f, -0.000000f, -0.809017f, 0.496685f, 0.312438f,
+		-0.447215f, 0.276397f, -0.850649f, 0.000000f, -0.447215f, 0.276397f, -0.850649f, 0.996685f, 0.687562f,
+		-0.587786f, -0.000000f, -0.809017f, 0.000000f, -0.587786f, -0.000000f, -0.809017f, 0.496685f, 0.312438f,
+		-0.687159f, 0.251152f, -0.681715f, 0.000000f, -0.687159f, 0.251152f, -0.681715f, 0.477658f, 0.222612f,
+		-0.447215f, 0.276397f, -0.850649f, 0.000000f, -0.447215f, 0.276397f, -0.850649f, 0.996685f, 0.687562f,
+		-0.447215f, 0.276397f, -0.850649f, 0.000000f, -0.447215f, 0.276397f, -0.850649f, 0.996685f, 0.687562f,
+		-0.687159f, 0.251152f, -0.681715f, 0.000000f, -0.687159f, 0.251152f, -0.681715f, 0.477658f, 0.222612f,
+		-0.531941f, 0.502302f, -0.681712f, 0.000000f, -0.531941f, 0.502302f, -0.681712f, 0.814480f, 0.588860f,
+		-0.687159f, 0.251152f, -0.681715f, 0.000000f, -0.687159f, 0.251152f, -0.681715f, 0.477658f, 0.222612f,
+		-0.723607f, 0.447220f, -0.525725f, 0.000000f, -0.723607f, 0.447220f, -0.525725f, 0.952607f, 0.099770f,
+		-0.531941f, 0.502302f, -0.681712f, 0.000000f, -0.531941f, 0.502302f, -0.681712f, 0.814480f, 0.588860f,
+		0.956626f, 0.251149f, -0.147618f, 0.000000f, 0.956626f, 0.251149f, -0.147618f, 0.610420f, 0.226784f,
+		0.831051f, 0.502299f, -0.238853f, 0.000000f, 0.831051f, 0.502299f, -0.238853f, 0.891200f, 0.515555f,
+		0.894426f, 0.447216f, 0.000000f, 0.000000f, 0.894426f, 0.447216f, 0.000000f, 0.542767f, 0.333057f,
+		0.951058f, 0.000000f, -0.309013f, 0.000000f, 0.951058f, 0.000000f, -0.309013f, 0.546072f, 0.156902f,
+		0.861804f, 0.276396f, -0.425322f, 0.000000f, 0.861804f, 0.276396f, -0.425322f, 1.042767f, 0.666943f,
+		0.956626f, 0.251149f, -0.147618f, 0.000000f, 0.956626f, 0.251149f, -0.147618f, 0.610420f, 0.226784f,
+		0.860698f, -0.251151f, -0.442858f, 0.000000f, 0.860698f, -0.251151f, -0.442858f, 0.543816f, 0.252266f,
+		0.809019f, 0.000000f, -0.587782f, 0.000000f, 0.809019f, 0.000000f, -0.587782f, 0.615709f, 0.905284f,
+		0.951058f, 0.000000f, -0.309013f, 0.000000f, 0.951058f, 0.000000f, -0.309013f, 0.546072f, 0.156902f,
+		0.956626f, 0.251149f, -0.147618f, 0.000000f, 0.956626f, 0.251149f, -0.147618f, 0.610420f, 0.226784f,
+		0.861804f, 0.276396f, -0.425322f, 0.000000f, 0.861804f, 0.276396f, -0.425322f, 1.042767f, 0.666943f,
+		0.831051f, 0.502299f, -0.238853f, 0.000000f, 0.831051f, 0.502299f, -0.238853f, 0.891200f, 0.515555f,
+		0.861804f, 0.276396f, -0.425322f, 0.000000f, 0.861804f, 0.276396f, -0.425322f, 1.042767f, 0.666943f,
+		0.688189f, 0.525736f, -0.499997f, 0.000000f, 0.688189f, 0.525736f, -0.499997f, 0.816839f, 0.418893f,
+		0.831051f, 0.502299f, -0.238853f, 0.000000f, 0.831051f, 0.502299f, -0.238853f, 0.891200f, 0.515555f,
+		0.951058f, 0.000000f, -0.309013f, 0.000000f, 0.951058f, 0.000000f, -0.309013f, 0.546072f, 0.156902f,
+		0.809019f, 0.000000f, -0.587782f, 0.000000f, 0.809019f, 0.000000f, -0.587782f, 0.615709f, 0.905284f,
+		0.861804f, 0.276396f, -0.425322f, 0.000000f, 0.861804f, 0.276396f, -0.425322f, 1.042767f, 0.666943f,
+		0.809019f, 0.000000f, -0.587782f, 0.000000f, 0.809019f, 0.000000f, -0.587782f, 0.615709f, 0.905284f,
+		0.670821f, 0.276397f, -0.688189f, 0.000000f, 0.670821f, 0.276397f, -0.688189f, 0.804489f, 0.928124f,
+		0.861804f, 0.276396f, -0.425322f, 0.000000f, 0.861804f, 0.276396f, -0.425322f, 1.042767f, 0.666943f,
+		0.861804f, 0.276396f, -0.425322f, 0.000000f, 0.861804f, 0.276396f, -0.425322f, 1.042767f, 0.666943f,
+		0.670821f, 0.276397f, -0.688189f, 0.000000f, 0.670821f, 0.276397f, -0.688189f, 0.804489f, 0.928124f,
+		0.688189f, 0.525736f, -0.499997f, 0.000000f, 0.688189f, 0.525736f, -0.499997f, 0.816839f, 0.418893f,
+		0.670821f, 0.276397f, -0.688189f, 0.000000f, 0.670821f, 0.276397f, -0.688189f, 0.804489f, 0.928124f,
+		0.483971f, 0.502302f, -0.716565f, 0.000000f, 0.483971f, 0.502302f, -0.716565f, 0.841211f, 0.510884f,
+		0.688189f, 0.525736f, -0.499997f, 0.000000f, 0.688189f, 0.525736f, -0.499997f, 0.816839f, 0.418893f,
+		0.860698f, -0.251151f, -0.442858f, 0.000000f, 0.860698f, -0.251151f, -0.442858f, 0.543816f, 0.252266f,
+		0.687159f, -0.251152f, -0.681715f, 0.000000f, 0.687159f, -0.251152f, -0.681715f, 0.268675f, 0.239476f,
+		0.809019f, 0.000000f, -0.587782f, 0.000000f, 0.809019f, 0.000000f, -0.587782f, 0.615709f, 0.905284f,
+		0.687159f, -0.251152f, -0.681715f, 0.000000f, 0.687159f, -0.251152f, -0.681715f, 0.268675f, 0.239476f,
+		0.587786f, -0.000000f, -0.809017f, 0.000000f, 0.587786f, -0.000000f, -0.809017f, 0.235205f, 0.325266f,
+		0.809019f, 0.000000f, -0.587782f, 0.000000f, 0.809019f, 0.000000f, -0.587782f, 0.615709f, 0.905284f,
+		0.809019f, 0.000000f, -0.587782f, 0.000000f, 0.809019f, 0.000000f, -0.587782f, 0.615709f, 0.905284f,
+		0.587786f, -0.000000f, -0.809017f, 0.000000f, 0.587786f, -0.000000f, -0.809017f, 0.235205f, 0.325266f,
+		0.670821f, 0.276397f, -0.688189f, 0.000000f, 0.670821f, 0.276397f, -0.688189f, 0.804489f, 0.928124f,
+		0.587786f, -0.000000f, -0.809017f, 0.000000f, 0.587786f, -0.000000f, -0.809017f, 0.235205f, 0.325266f,
+		0.436007f, 0.251152f, -0.864188f, 0.000000f, 0.436007f, 0.251152f, -0.864188f, 0.221600f, 0.149916f,
+		0.670821f, 0.276397f, -0.688189f, 0.000000f, 0.670821f, 0.276397f, -0.688189f, 0.804489f, 0.928124f,
+		0.670821f, 0.276397f, -0.688189f, 0.000000f, 0.670821f, 0.276397f, -0.688189f, 0.804489f, 0.928124f,
+		0.436007f, 0.251152f, -0.864188f, 0.000000f, 0.436007f, 0.251152f, -0.864188f, 0.221600f, 0.149916f,
+		0.483971f, 0.502302f, -0.716565f, 0.000000f, 0.483971f, 0.502302f, -0.716565f, 0.841211f, 0.510884f,
+		0.436007f, 0.251152f, -0.864188f, 0.000000f, 0.436007f, 0.251152f, -0.864188f, 0.221600f, 0.149916f,
+		0.276388f, 0.447220f, -0.850649f, 0.000000f, 0.276388f, 0.447220f, -0.850649f, 0.768276f, 0.421330f,
+		0.483971f, 0.502302f, -0.716565f, 0.000000f, 0.483971f, 0.502302f, -0.716565f, 0.841211f, 0.510884f,
+		0.077607f, 0.967950f, 0.238853f, 0.000000f, 0.077607f, 0.967950f, 0.238853f, 0.591499f, 0.483164f,
+		0.251147f, 0.967949f, 0.000000f, 0.000000f, 0.251147f, 0.967949f, 0.000000f, 0.663633f, 0.570564f,
+		0.000000f, 1.000000f, 0.000000f, 0.000000f, 0.000000f, 1.000000f, 0.000000f, 0.589135f, 0.315387f,
+		0.162456f, 0.850654f, 0.499995f, 0.000000f, 0.162456f, 0.850654f, 0.499995f, 0.641510f, 0.487355f,
+		0.361800f, 0.894429f, 0.262863f, 0.000000f, 0.361800f, 0.894429f, 0.262863f, 0.499999f, 0.979947f,
+		0.077607f, 0.967950f, 0.238853f, 0.000000f, 0.077607f, 0.967950f, 0.238853f, 0.591499f, 0.483164f,
+		0.232822f, 0.657519f, 0.716563f, 0.000000f, 0.232822f, 0.657519f, 0.716563f, 0.616405f, 0.395845f,
+		0.447209f, 0.723612f, 0.525728f, 0.000000f, 0.447209f, 0.723612f, 0.525728f, 0.629692f, 0.810571f,
+		0.162456f, 0.850654f, 0.499995f, 0.000000f, 0.162456f, 0.850654f, 0.499995f, 0.641510f, 0.487355f,
+		0.077607f, 0.967950f, 0.238853f, 0.000000f, 0.077607f, 0.967950f, 0.238853f, 0.591499f, 0.483164f,
+		0.361800f, 0.894429f, 0.262863f, 0.000000f, 0.361800f, 0.894429f, 0.262863f, 0.499999f, 0.979947f,
+		0.251147f, 0.967949f, 0.000000f, 0.000000f, 0.251147f, 0.967949f, 0.000000f, 0.663633f, 0.570564f,
+		0.361800f, 0.894429f, 0.262863f, 0.000000f, 0.361800f, 0.894429f, 0.262863f, 0.499999f, 0.979947f,
+		0.525730f, 0.850652f, 0.000000f, 0.000000f, 0.525730f, 0.850652f, 0.000000f, 0.615418f, 0.565866f,
+		0.251147f, 0.967949f, 0.000000f, 0.000000f, 0.251147f, 0.967949f, 0.000000f, 0.663633f, 0.570564f,
+		0.162456f, 0.850654f, 0.499995f, 0.000000f, 0.162456f, 0.850654f, 0.499995f, 0.641510f, 0.487355f,
+		0.447209f, 0.723612f, 0.525728f, 0.000000f, 0.447209f, 0.723612f, 0.525728f, 0.629692f, 0.810571f,
+		0.361800f, 0.894429f, 0.262863f, 0.000000f, 0.361800f, 0.894429f, 0.262863f, 0.499999f, 0.979947f,
+		0.447209f, 0.723612f, 0.525728f, 0.000000f, 0.447209f, 0.723612f, 0.525728f, 0.629692f, 0.810571f,
+		0.638194f, 0.723610f, 0.262864f, 0.000000f, 0.638194f, 0.723610f, 0.262864f, 0.721600f, 0.850084f,
+		0.361800f, 0.894429f, 0.262863f, 0.000000f, 0.361800f, 0.894429f, 0.262863f, 0.499999f, 0.979947f,
+		0.361800f, 0.894429f, 0.262863f, 0.000000f, 0.361800f, 0.894429f, 0.262863f, 0.499999f, 0.979947f,
+		0.638194f, 0.723610f, 0.262864f, 0.000000f, 0.638194f, 0.723610f, 0.262864f, 0.721600f, 0.850084f,
+		0.525730f, 0.850652f, 0.000000f, 0.000000f, 0.525730f, 0.850652f, 0.000000f, 0.615418f, 0.565866f,
+		0.638194f, 0.723610f, 0.262864f, 0.000000f, 0.638194f, 0.723610f, 0.262864f, 0.721600f, 0.850084f,
+		0.753442f, 0.657515f, 0.000000f, 0.000000f, 0.753442f, 0.657515f, 0.000000f, 0.870330f, 0.424531f,
+		0.525730f, 0.850652f, 0.000000f, 0.000000f, 0.525730f, 0.850652f, 0.000000f, 0.615418f, 0.565866f,
+		0.232822f, 0.657519f, 0.716563f, 0.000000f, 0.232822f, 0.657519f, 0.716563f, 0.616405f, 0.395845f,
+		0.483971f, 0.502302f, 0.716565f, 0.000000f, 0.483971f, 0.502302f, 0.716565f, 1.036828f, 0.167036f,
+		0.447209f, 0.723612f, 0.525728f, 0.000000f, 0.447209f, 0.723612f, 0.525728f, 0.629692f, 0.810571f,
+		0.483971f, 0.502302f, 0.716565f, 0.000000f, 0.483971f, 0.502302f, 0.716565f, 1.036828f, 0.167036f,
+		0.688189f, 0.525736f, 0.499997f, 0.000000f, 0.688189f, 0.525736f, 0.499997f, 1.003325f, 0.262529f,
+		0.447209f, 0.723612f, 0.525728f, 0.000000f, 0.447209f, 0.723612f, 0.525728f, 0.629692f, 0.810571f,
+		0.447209f, 0.723612f, 0.525728f, 0.000000f, 0.447209f, 0.723612f, 0.525728f, 0.629692f, 0.810571f,
+		0.688189f, 0.525736f, 0.499997f, 0.000000f, 0.688189f, 0.525736f, 0.499997f, 1.003325f, 0.262529f,
+		0.638194f, 0.723610f, 0.262864f, 0.000000f, 0.638194f, 0.723610f, 0.262864f, 0.721600f, 0.850084f,
+		0.688189f, 0.525736f, 0.499997f, 0.000000f, 0.688189f, 0.525736f, 0.499997f, 1.003325f, 0.262529f,
+		0.831051f, 0.502299f, 0.238853f, 0.000000f, 0.831051f, 0.502299f, 0.238853f, 0.291096f, 0.327017f,
+		0.638194f, 0.723610f, 0.262864f, 0.000000f, 0.638194f, 0.723610f, 0.262864f, 0.721600f, 0.850084f,
+		0.638194f, 0.723610f, 0.262864f, 0.000000f, 0.638194f, 0.723610f, 0.262864f, 0.721600f, 0.850084f,
+		0.831051f, 0.502299f, 0.238853f, 0.000000f, 0.831051f, 0.502299f, 0.238853f, 0.291096f, 0.327017f,
+		0.753442f, 0.657515f, 0.000000f, 0.000000f, 0.753442f, 0.657515f, 0.000000f, 0.870330f, 0.424531f,
+		0.831051f, 0.502299f, 0.238853f, 0.000000f, 0.831051f, 0.502299f, 0.238853f, 0.291096f, 0.327017f,
+		0.894426f, 0.447216f, 0.000000f, 0.000000f, 0.894426f, 0.447216f, 0.000000f, 0.542767f, 0.333057f,
+		0.753442f, 0.657515f, 0.000000f, 0.000000f, 0.753442f, 0.657515f, 0.000000f, 0.870330f, 0.424531f,
+		-0.203181f, 0.967950f, 0.147618f, 0.000000f, -0.203181f, 0.967950f, 0.147618f, 0.691461f, 0.492781f,
+		0.077607f, 0.967950f, 0.238853f, 0.000000f, 0.077607f, 0.967950f, 0.238853f, 0.591499f, 0.483164f,
+		0.000000f, 1.000000f, 0.000000f, 0.000000f, 0.000000f, 1.000000f, 0.000000f, 0.589135f, 0.315387f,
+		-0.425323f, 0.850654f, 0.309011f, 0.000000f, -0.425323f, 0.850654f, 0.309011f, 0.671061f, 0.401166f,
+		-0.138197f, 0.894430f, 0.425320f, 0.000000f, -0.138197f, 0.894430f, 0.425320f, 0.693762f, 0.751156f,
+		-0.203181f, 0.967950f, 0.147618f, 0.000000f, -0.203181f, 0.967950f, 0.147618f, 0.691461f, 0.492781f,
+		-0.609547f, 0.657519f, 0.442856f, 0.000000f, -0.609547f, 0.657519f, 0.442856f, 0.418131f, 0.563385f,
+		-0.361804f, 0.723612f, 0.587778f, 0.000000f, -0.361804f, 0.723612f, 0.587778f, 0.826823f, 0.833914f,
+		-0.425323f, 0.850654f, 0.309011f, 0.000000f, -0.425323f, 0.850654f, 0.309011f, 0.671061f, 0.401166f,
+		-0.203181f, 0.967950f, 0.147618f, 0.000000f, -0.203181f, 0.967950f, 0.147618f, 0.691461f, 0.492781f,
+		-0.138197f, 0.894430f, 0.425320f, 0.000000f, -0.138197f, 0.894430f, 0.425320f, 0.693762f, 0.751156f,
+		0.077607f, 0.967950f, 0.238853f, 0.000000f, 0.077607f, 0.967950f, 0.238853f, 0.591499f, 0.483164f,
+		-0.138197f, 0.894430f, 0.425320f, 0.000000f, -0.138197f, 0.894430f, 0.425320f, 0.693762f, 0.751156f,
+		0.162456f, 0.850654f, 0.499995f, 0.000000f, 0.162456f, 0.850654f, 0.499995f, 0.641510f, 0.487355f,
+		0.077607f, 0.967950f, 0.238853f, 0.000000f, 0.077607f, 0.967950f, 0.238853f, 0.591499f, 0.483164f,
+		-0.425323f, 0.850654f, 0.309011f, 0.000000f, -0.425323f, 0.850654f, 0.309011f, 0.671061f, 0.401166f,
+		-0.361804f, 0.723612f, 0.587778f, 0.000000f, -0.361804f, 0.723612f, 0.587778f, 0.826823f, 0.833914f,
+		-0.138197f, 0.894430f, 0.425320f, 0.000000f, -0.138197f, 0.894430f, 0.425320f, 0.693762f, 0.751156f,
+		-0.361804f, 0.723612f, 0.587778f, 0.000000f, -0.361804f, 0.723612f, 0.587778f, 0.826823f, 0.833914f,
+		-0.052790f, 0.723612f, 0.688185f, 0.000000f, -0.052790f, 0.723612f, 0.688185f, 0.768674f, 0.760524f,
+		-0.138197f, 0.894430f, 0.425320f, 0.000000f, -0.138197f, 0.894430f, 0.425320f, 0.693762f, 0.751156f,
+		-0.138197f, 0.894430f, 0.425320f, 0.000000f, -0.138197f, 0.894430f, 0.425320f, 0.693762f, 0.751156f,
+		-0.052790f, 0.723612f, 0.688185f, 0.000000f, -0.052790f, 0.723612f, 0.688185f, 0.768674f, 0.760524f,
+		0.162456f, 0.850654f, 0.499995f, 0.000000f, 0.162456f, 0.850654f, 0.499995f, 0.641510f, 0.487355f,
+		-0.052790f, 0.723612f, 0.688185f, 0.000000f, -0.052790f, 0.723612f, 0.688185f, 0.768674f, 0.760524f,
+		0.232822f, 0.657519f, 0.716563f, 0.000000f, 0.232822f, 0.657519f, 0.716563f, 0.616405f, 0.395845f,
+		0.162456f, 0.850654f, 0.499995f, 0.000000f, 0.162456f, 0.850654f, 0.499995f, 0.641510f, 0.487355f,
+		-0.609547f, 0.657519f, 0.442856f, 0.000000f, -0.609547f, 0.657519f, 0.442856f, 0.418131f, 0.563385f,
+		-0.531941f, 0.502302f, 0.681712f, 0.000000f, -0.531941f, 0.502302f, 0.681712f, 0.074553f, 0.260244f,
+		-0.361804f, 0.723612f, 0.587778f, 0.000000f, -0.361804f, 0.723612f, 0.587778f, 0.826823f, 0.833914f,
+		-0.531941f, 0.502302f, 0.681712f, 0.000000f, -0.531941f, 0.502302f, 0.681712f, 0.074553f, 0.260244f,
+		-0.262869f, 0.525738f, 0.809012f, 0.000000f, -0.262869f, 0.525738f, 0.809012f, 0.036828f, 0.167036f,
+		-0.361804f, 0.723612f, 0.587778f, 0.000000f, -0.361804f, 0.723612f, 0.587778f, 0.826823f, 0.833914f,
+		-0.361804f, 0.723612f, 0.587778f, 0.000000f, -0.361804f, 0.723612f, 0.587778f, 0.826823f, 0.833914f,
+		-0.262869f, 0.525738f, 0.809012f, 0.000000f, -0.262869f, 0.525738f, 0.809012f, 0.036828f, 0.167036f,
+		-0.052790f, 0.723612f, 0.688185f, 0.000000f, -0.052790f, 0.723612f, 0.688185f, 0.768674f, 0.760524f,
+		-0.262869f, 0.525738f, 0.809012f, 0.000000f, -0.262869f, 0.525738f, 0.809012f, 0.036828f, 0.167036f,
+		0.029639f, 0.502302f, 0.864184f, 0.000000f, 0.029639f, 0.502302f, 0.864184f, 1.039894f, 0.343193f,
+		-0.052790f, 0.723612f, 0.688185f, 0.000000f, -0.052790f, 0.723612f, 0.688185f, 0.768674f, 0.760524f,
+		-0.052790f, 0.723612f, 0.688185f, 0.000000f, -0.052790f, 0.723612f, 0.688185f, 0.768674f, 0.760524f,
+		0.029639f, 0.502302f, 0.864184f, 0.000000f, 0.029639f, 0.502302f, 0.864184f, 1.039894f, 0.343193f,
+		0.232822f, 0.657519f, 0.716563f, 0.000000f, 0.232822f, 0.657519f, 0.716563f, 0.616405f, 0.395845f,
+		0.029639f, 0.502302f, 0.864184f, 0.000000f, 0.029639f, 0.502302f, 0.864184f, 1.039894f, 0.343193f,
+		0.276388f, 0.447220f, 0.850649f, 0.000000f, 0.276388f, 0.447220f, 0.850649f, 1.304489f, 0.071876f,
+		0.232822f, 0.657519f, 0.716563f, 0.000000f, 0.232822f, 0.657519f, 0.716563f, 0.616405f, 0.395845f,
+		-0.203181f, 0.967950f, -0.147618f, 0.000000f, -0.203181f, 0.967950f, -0.147618f, 0.466205f, 0.561213f,
+		-0.203181f, 0.967950f, 0.147618f, 0.000000f, -0.203181f, 0.967950f, 0.147618f, 0.691461f, 0.492781f,
+		0.000000f, 1.000000f, 0.000000f, 0.000000f, 0.000000f, 1.000000f, 0.000000f, 0.589135f, 0.315387f,
+		-0.425323f, 0.850654f, -0.309011f, 0.000000f, -0.425323f, 0.850654f, -0.309011f, 0.391200f, 0.484445f,
+		-0.447210f, 0.894429f, 0.000000f, 0.000000f, -0.447210f, 0.894429f, 0.000000f, 0.452607f, 0.900230f,
+		-0.203181f, 0.967950f, -0.147618f, 0.000000f, -0.203181f, 0.967950f, -0.147618f, 0.466205f, 0.561213f,
+		-0.609547f, 0.657519f, -0.442856f, 0.000000f, -0.609547f, 0.657519f, -0.442856f, 0.441249f, 0.481295f,
+		-0.670817f, 0.723611f, -0.162457f, 0.000000f, -0.670817f, 0.723611f, -0.162457f, 0.446597f, 0.804967f,
+		-0.425323f, 0.850654f, -0.309011f, 0.000000f, -0.425323f, 0.850654f, -0.309011f, 0.391200f, 0.484445f,
+		-0.203181f, 0.967950f, -0.147618f, 0.000000f, -0.203181f, 0.967950f, -0.147618f, 0.466205f, 0.561213f,
+		-0.447210f, 0.894429f, 0.000000f, 0.000000f, -0.447210f, 0.894429f, 0.000000f, 0.452607f, 0.900230f,
+		-0.203181f, 0.967950f, 0.147618f, 0.000000f, -0.203181f, 0.967950f, 0.147618f, 0.691461f, 0.492781f,
+		-0.447210f, 0.894429f, 0.000000f, 0.000000f, -0.447210f, 0.894429f, 0.000000f, 0.452607f, 0.900230f,
+		-0.425323f, 0.850654f, 0.309011f, 0.000000f, -0.425323f, 0.850654f, 0.309011f, 0.671061f, 0.401166f,
+		-0.203181f, 0.967950f, 0.147618f, 0.000000f, -0.203181f, 0.967950f, 0.147618f, 0.691461f, 0.492781f,
+		-0.425323f, 0.850654f, -0.309011f, 0.000000f, -0.425323f, 0.850654f, -0.309011f, 0.391200f, 0.484445f,
+		-0.670817f, 0.723611f, -0.162457f, 0.000000f, -0.670817f, 0.723611f, -0.162457f, 0.446597f, 0.804967f,
+		-0.447210f, 0.894429f, 0.000000f, 0.000000f, -0.447210f, 0.894429f, 0.000000f, 0.452607f, 0.900230f,
+		-0.670817f, 0.723611f, -0.162457f, 0.000000f, -0.670817f, 0.723611f, -0.162457f, 0.446597f, 0.804967f,
+		-0.670817f, 0.723611f, 0.162457f, 0.000000f, -0.670817f, 0.723611f, 0.162457f, 0.536828f, 0.832965f,
+		-0.447210f, 0.894429f, 0.000000f, 0.000000f, -0.447210f, 0.894429f, 0.000000f, 0.452607f, 0.900230f,
+		-0.447210f, 0.894429f, 0.000000f, 0.000000f, -0.447210f, 0.894429f, 0.000000f, 0.452607f, 0.900230f,
+		-0.670817f, 0.723611f, 0.162457f, 0.000000f, -0.670817f, 0.723611f, 0.162457f, 0.536828f, 0.832965f,
+		-0.425323f, 0.850654f, 0.309011f, 0.000000f, -0.425323f, 0.850654f, 0.309011f, 0.671061f, 0.401166f,
+		-0.670817f, 0.723611f, 0.162457f, 0.000000f, -0.670817f, 0.723611f, 0.162457f, 0.536828f, 0.832965f,
+		-0.609547f, 0.657519f, 0.442856f, 0.000000f, -0.609547f, 0.657519f, 0.442856f, 0.418131f, 0.563385f,
+		-0.425323f, 0.850654f, 0.309011f, 0.000000f, -0.425323f, 0.850654f, 0.309011f, 0.671061f, 0.401166f,
+		-0.609547f, 0.657519f, -0.442856f, 0.000000f, -0.609547f, 0.657519f, -0.442856f, 0.441249f, 0.481295f,
+		-0.812729f, 0.502301f, -0.295238f, 0.000000f, -0.812729f, 0.502301f, -0.295238f, 0.093723f, 0.349056f,
+		-0.670817f, 0.723611f, -0.162457f, 0.000000f, -0.670817f, 0.723611f, -0.162457f, 0.446597f, 0.804967f,
+		-0.812729f, 0.502301f, -0.295238f, 0.000000f, -0.812729f, 0.502301f, -0.295238f, 0.093723f, 0.349056f,
+		-0.850648f, 0.525736f, -0.000000f, 0.000000f, -0.850648f, 0.525736f, -0.000000f, 0.039894f, 0.343193f,
+		-0.670817f, 0.723611f, -0.162457f, 0.000000f, -0.670817f, 0.723611f, -0.162457f, 0.446597f, 0.804967f,
+		-0.670817f, 0.723611f, -0.162457f, 0.000000f, -0.670817f, 0.723611f, -0.162457f, 0.446597f, 0.804967f,
+		-0.850648f, 0.525736f, -0.000000f, 0.000000f, -0.850648f, 0.525736f, -0.000000f, 0.039894f, 0.343193f,
+		-0.670817f, 0.723611f, 0.162457f, 0.000000f, -0.670817f, 0.723611f, 0.162457f, 0.536828f, 0.832965f,
+		-0.850648f, 0.525736f, -0.000000f, 0.000000f, -0.850648f, 0.525736f, -0.000000f, 0.039894f, 0.343193f,
+		-0.812729f, 0.502301f, 0.295238f, 0.000000f, -0.812729f, 0.502301f, 0.295238f, 0.003325f, 0.262529f,
+		-0.670817f, 0.723611f, 0.162457f, 0.000000f, -0.670817f, 0.723611f, 0.162457f, 0.536828f, 0.832965f,
+		-0.670817f, 0.723611f, 0.162457f, 0.000000f, -0.670817f, 0.723611f, 0.162457f, 0.536828f, 0.832965f,
+		-0.812729f, 0.502301f, 0.295238f, 0.000000f, -0.812729f, 0.502301f, 0.295238f, 0.003325f, 0.262529f,
+		-0.609547f, 0.657519f, 0.442856f, 0.000000f, -0.609547f, 0.657519f, 0.442856f, 0.418131f, 0.563385f,
+		-0.812729f, 0.502301f, 0.295238f, 0.000000f, -0.812729f, 0.502301f, 0.295238f, 0.003325f, 0.262529f,
+		-0.723607f, 0.447220f, 0.525725f, 0.000000f, -0.723607f, 0.447220f, 0.525725f, 1.115709f, 0.094716f,
+		-0.609547f, 0.657519f, 0.442856f, 0.000000f, -0.609547f, 0.657519f, 0.442856f, 0.418131f, 0.563385f,
+		0.077607f, 0.967950f, -0.238853f, 0.000000f, 0.077607f, 0.967950f, -0.238853f, 0.412677f, 0.393695f,
+		-0.203181f, 0.967950f, -0.147618f, 0.000000f, -0.203181f, 0.967950f, -0.147618f, 0.466205f, 0.561213f,
+		0.000000f, 1.000000f, 0.000000f, 0.000000f, 0.000000f, 1.000000f, 0.000000f, 0.589135f, 0.315387f,
+		0.162456f, 0.850654f, -0.499995f, 0.000000f, 0.162456f, 0.850654f, -0.499995f, 0.491338f, 0.479977f,
+		-0.138197f, 0.894430f, -0.425320f, 0.000000f, -0.138197f, 0.894430f, -0.425320f, 0.503325f, 0.737471f,
+		0.077607f, 0.967950f, -0.238853f, 0.000000f, 0.077607f, 0.967950f, -0.238853f, 0.412677f, 0.393695f,
+		0.232822f, 0.657519f, -0.716563f, 0.000000f, 0.232822f, 0.657519f, -0.716563f, 0.467747f, 0.391208f,
+		-0.052790f, 0.723612f, -0.688185f, 0.000000f, -0.052790f, 0.723612f, -0.688185f, 0.574552f, 0.739757f,
+		0.162456f, 0.850654f, -0.499995f, 0.000000f, 0.162456f, 0.850654f, -0.499995f, 0.491338f, 0.479977f,
+		0.077607f, 0.967950f, -0.238853f, 0.000000f, 0.077607f, 0.967950f, -0.238853f, 0.412677f, 0.393695f,
+		-0.138197f, 0.894430f, -0.425320f, 0.000000f, -0.138197f, 0.894430f, -0.425320f, 0.503325f, 0.737471f,
+		-0.203181f, 0.967950f, -0.147618f, 0.000000f, -0.203181f, 0.967950f, -0.147618f, 0.466205f, 0.561213f,
+		-0.138197f, 0.894430f, -0.425320f, 0.000000f, -0.138197f, 0.894430f, -0.425320f, 0.503325f, 0.737471f,
+		-0.425323f, 0.850654f, -0.309011f, 0.000000f, -0.425323f, 0.850654f, -0.309011f, 0.391200f, 0.484445f,
+		-0.203181f, 0.967950f, -0.147618f, 0.000000f, -0.203181f, 0.967950f, -0.147618f, 0.466205f, 0.561213f,
+		0.162456f, 0.850654f, -0.499995f, 0.000000f, 0.162456f, 0.850654f, -0.499995f, 0.491338f, 0.479977f,
+		-0.052790f, 0.723612f, -0.688185f, 0.000000f, -0.052790f, 0.723612f, -0.688185f, 0.574552f, 0.739757f,
+		-0.138197f, 0.894430f, -0.425320f, 0.000000f, -0.138197f, 0.894430f, -0.425320f, 0.503325f, 0.737471f,
+		-0.052790f, 0.723612f, -0.688185f, 0.000000f, -0.052790f, 0.723612f, -0.688185f, 0.574552f, 0.739757f,
+		-0.361804f, 0.723612f, -0.587778f, 0.000000f, -0.361804f, 0.723612f, -0.587778f, 0.279690f, 0.917858f,
+		-0.138197f, 0.894430f, -0.425320f, 0.000000f, -0.138197f, 0.894430f, -0.425320f, 0.503325f, 0.737471f,
+		-0.138197f, 0.894430f, -0.425320f, 0.000000f, -0.138197f, 0.894430f, -0.425320f, 0.503325f, 0.737471f,
+		-0.361804f, 0.723612f, -0.587778f, 0.000000f, -0.361804f, 0.723612f, -0.587778f, 0.279690f, 0.917858f,
+		-0.425323f, 0.850654f, -0.309011f, 0.000000f, -0.425323f, 0.850654f, -0.309011f, 0.391200f, 0.484445f,
+		-0.361804f, 0.723612f, -0.587778f, 0.000000f, -0.361804f, 0.723612f, -0.587778f, 0.279690f, 0.917858f,
+		-0.609547f, 0.657519f, -0.442856f, 0.000000f, -0.609547f, 0.657519f, -0.442856f, 0.441249f, 0.481295f,
+		-0.425323f, 0.850654f, -0.309011f, 0.000000f, -0.425323f, 0.850654f, -0.309011f, 0.391200f, 0.484445f,
+		0.232822f, 0.657519f, -0.716563f, 0.000000f, 0.232822f, 0.657519f, -0.716563f, 0.467747f, 0.391208f,
+		0.029639f, 0.502302f, -0.864184f, 0.000000f, 0.029639f, 0.502302f, -0.864184f, 0.791278f, 0.505149f,
+		-0.052790f, 0.723612f, -0.688185f, 0.000000f, -0.052790f, 0.723612f, -0.688185f, 0.574552f, 0.739757f,
+		0.029639f, 0.502302f, -0.864184f, 0.000000f, 0.029639f, 0.502302f, -0.864184f, 0.791278f, 0.505149f,
+		-0.262869f, 0.525738f, -0.809012f, 0.000000f, -0.262869f, 0.525738f, -0.809012f, 0.863599f, 0.594041f,
+		-0.052790f, 0.723612f, -0.688185f, 0.000000f, -0.052790f, 0.723612f, -0.688185f, 0.574552f, 0.739757f,
+		-0.052790f, 0.723612f, -0.688185f, 0.000000f, -0.052790f, 0.723612f, -0.688185f, 0.574552f, 0.739757f,
+		-0.262869f, 0.525738f, -0.809012f, 0.000000f, -0.262869f, 0.525738f, -0.809012f, 0.863599f, 0.594041f,
+		-0.361804f, 0.723612f, -0.587778f, 0.000000f, -0.361804f, 0.723612f, -0.587778f, 0.279690f, 0.917858f,
+		-0.262869f, 0.525738f, -0.809012f, 0.000000f, -0.262869f, 0.525738f, -0.809012f, 0.863599f, 0.594041f,
+		-0.531941f, 0.502302f, -0.681712f, 0.000000f, -0.531941f, 0.502302f, -0.681712f, 0.814480f, 0.588860f,
+		-0.361804f, 0.723612f, -0.587778f, 0.000000f, -0.361804f, 0.723612f, -0.587778f, 0.279690f, 0.917858f,
+		-0.361804f, 0.723612f, -0.587778f, 0.000000f, -0.361804f, 0.723612f, -0.587778f, 0.279690f, 0.917858f,
+		-0.531941f, 0.502302f, -0.681712f, 0.000000f, -0.531941f, 0.502302f, -0.681712f, 0.814480f, 0.588860f,
+		-0.609547f, 0.657519f, -0.442856f, 0.000000f, -0.609547f, 0.657519f, -0.442856f, 0.441249f, 0.481295f,
+		-0.531941f, 0.502302f, -0.681712f, 0.000000f, -0.531941f, 0.502302f, -0.681712f, 0.814480f, 0.588860f,
+		-0.723607f, 0.447220f, -0.525725f, 0.000000f, -0.723607f, 0.447220f, -0.525725f, 0.952607f, 0.099770f,
+		-0.609547f, 0.657519f, -0.442856f, 0.000000f, -0.609547f, 0.657519f, -0.442856f, 0.441249f, 0.481295f,
+		0.251147f, 0.967949f, 0.000000f, 0.000000f, 0.251147f, 0.967949f, 0.000000f, 0.663633f, 0.570564f,
+		0.077607f, 0.967950f, -0.238853f, 0.000000f, 0.077607f, 0.967950f, -0.238853f, 0.412677f, 0.393695f,
+		0.000000f, 1.000000f, 0.000000f, 0.000000f, 0.000000f, 1.000000f, 0.000000f, 0.589135f, 0.315387f,
+		0.525730f, 0.850652f, 0.000000f, 0.000000f, 0.525730f, 0.850652f, 0.000000f, 0.615418f, 0.565866f,
+		0.361800f, 0.894429f, -0.262863f, 0.000000f, 0.361800f, 0.894429f, -0.262863f, 0.257596f, 0.823860f,
+		0.251147f, 0.967949f, 0.000000f, 0.000000f, 0.251147f, 0.967949f, 0.000000f, 0.663633f, 0.570564f,
+		0.753442f, 0.657515f, 0.000000f, 0.000000f, 0.753442f, 0.657515f, 0.000000f, 0.870330f, 0.424531f,
+		0.638194f, 0.723610f, -0.262864f, 0.000000f, 0.638194f, 0.723610f, -0.262864f, 0.356930f, 0.840702f,
+		0.525730f, 0.850652f, 0.000000f, 0.000000f, 0.525730f, 0.850652f, 0.000000f, 0.615418f, 0.565866f,
+		0.251147f, 0.967949f, 0.000000f, 0.000000f, 0.251147f, 0.967949f, 0.000000f, 0.663633f, 0.570564f,
+		0.361800f, 0.894429f, -0.262863f, 0.000000f, 0.361800f, 0.894429f, -0.262863f, 0.257596f, 0.823860f,
+		0.077607f, 0.967950f, -0.238853f, 0.000000f, 0.077607f, 0.967950f, -0.238853f, 0.412677f, 0.393695f,
+		0.361800f, 0.894429f, -0.262863f, 0.000000f, 0.361800f, 0.894429f, -0.262863f, 0.257596f, 0.823860f,
+		0.162456f, 0.850654f, -0.499995f, 0.000000f, 0.162456f, 0.850654f, -0.499995f, 0.491338f, 0.479977f,
+		0.077607f, 0.967950f, -0.238853f, 0.000000f, 0.077607f, 0.967950f, -0.238853f, 0.412677f, 0.393695f,
+		0.525730f, 0.850652f, 0.000000f, 0.000000f, 0.525730f, 0.850652f, 0.000000f, 0.615418f, 0.565866f,
+		0.638194f, 0.723610f, -0.262864f, 0.000000f, 0.638194f, 0.723610f, -0.262864f, 0.356930f, 0.840702f,
+		0.361800f, 0.894429f, -0.262863f, 0.000000f, 0.361800f, 0.894429f, -0.262863f, 0.257596f, 0.823860f,
+		0.638194f, 0.723610f, -0.262864f, 0.000000f, 0.638194f, 0.723610f, -0.262864f, 0.356930f, 0.840702f,
+		0.447209f, 0.723612f, -0.525728f, 0.000000f, 0.447209f, 0.723612f, -0.525728f, 0.313138f, 0.750327f,
+		0.361800f, 0.894429f, -0.262863f, 0.000000f, 0.361800f, 0.894429f, -0.262863f, 0.257596f, 0.823860f,
+		0.361800f, 0.894429f, -0.262863f, 0.000000f, 0.361800f, 0.894429f, -0.262863f, 0.257596f, 0.823860f,
+		0.447209f, 0.723612f, -0.525728f, 0.000000f, 0.447209f, 0.723612f, -0.525728f, 0.313138f, 0.750327f,
+		0.162456f, 0.850654f, -0.499995f, 0.000000f, 0.162456f, 0.850654f, -0.499995f, 0.491338f, 0.479977f,
+		0.447209f, 0.723612f, -0.525728f, 0.000000f, 0.447209f, 0.723612f, -0.525728f, 0.313138f, 0.750327f,
+		0.232822f, 0.657519f, -0.716563f, 0.000000f, 0.232822f, 0.657519f, -0.716563f, 0.467747f, 0.391208f,
+		0.162456f, 0.850654f, -0.499995f, 0.000000f, 0.162456f, 0.850654f, -0.499995f, 0.491338f, 0.479977f,
+		0.753442f, 0.657515f, 0.000000f, 0.000000f, 0.753442f, 0.657515f, 0.000000f, 0.870330f, 0.424531f,
+		0.831051f, 0.502299f, -0.238853f, 0.000000f, 0.831051f, 0.502299f, -0.238853f, 0.891200f, 0.515555f,
+		0.638194f, 0.723610f, -0.262864f, 0.000000f, 0.638194f, 0.723610f, -0.262864f, 0.356930f, 0.840702f,
+		0.831051f, 0.502299f, -0.238853f, 0.000000f, 0.831051f, 0.502299f, -0.238853f, 0.891200f, 0.515555f,
+		0.688189f, 0.525736f, -0.499997f, 0.000000f, 0.688189f, 0.525736f, -0.499997f, 0.816839f, 0.418893f,
+		0.638194f, 0.723610f, -0.262864f, 0.000000f, 0.638194f, 0.723610f, -0.262864f, 0.356930f, 0.840702f,
+		0.638194f, 0.723610f, -0.262864f, 0.000000f, 0.638194f, 0.723610f, -0.262864f, 0.356930f, 0.840702f,
+		0.688189f, 0.525736f, -0.499997f, 0.000000f, 0.688189f, 0.525736f, -0.499997f, 0.816839f, 0.418893f,
+		0.447209f, 0.723612f, -0.525728f, 0.000000f, 0.447209f, 0.723612f, -0.525728f, 0.313138f, 0.750327f,
+		0.688189f, 0.525736f, -0.499997f, 0.000000f, 0.688189f, 0.525736f, -0.499997f, 0.816839f, 0.418893f,
+		0.483971f, 0.502302f, -0.716565f, 0.000000f, 0.483971f, 0.502302f, -0.716565f, 0.841211f, 0.510884f,
+		0.447209f, 0.723612f, -0.525728f, 0.000000f, 0.447209f, 0.723612f, -0.525728f, 0.313138f, 0.750327f,
+		0.447209f, 0.723612f, -0.525728f, 0.000000f, 0.447209f, 0.723612f, -0.525728f, 0.313138f, 0.750327f,
+		0.483971f, 0.502302f, -0.716565f, 0.000000f, 0.483971f, 0.502302f, -0.716565f, 0.841211f, 0.510884f,
+		0.232822f, 0.657519f, -0.716563f, 0.000000f, 0.232822f, 0.657519f, -0.716563f, 0.467747f, 0.391208f,
+		0.483971f, 0.502302f, -0.716565f, 0.000000f, 0.483971f, 0.502302f, -0.716565f, 0.841211f, 0.510884f,
+		0.276388f, 0.447220f, -0.850649f, 0.000000f, 0.276388f, 0.447220f, -0.850649f, 0.768276f, 0.421330f,
+		0.232822f, 0.657519f, -0.716563f, 0.000000f, 0.232822f, 0.657519f, -0.716563f, 0.467747f, 0.391208f};
+
+const int medium_sphere_indices[] =
+	{
+		0, 1, 2,
+		3, 4, 5,
+		6, 7, 8,
+		9, 10, 11,
+		12, 13, 14,
+		15, 16, 17,
+		18, 19, 20,
+		21, 22, 23,
+		24, 25, 26,
+		27, 28, 29,
+		30, 31, 32,
+		33, 34, 35,
+		36, 37, 38,
+		39, 40, 41,
+		42, 43, 44,
+		45, 46, 47,
+		48, 49, 50,
+		51, 52, 53,
+		54, 55, 56,
+		57, 58, 59,
+		60, 61, 62,
+		63, 64, 65,
+		66, 67, 68,
+		69, 70, 71,
+		72, 73, 74,
+		75, 76, 77,
+		78, 79, 80,
+		81, 82, 83,
+		84, 85, 86,
+		87, 88, 89,
+		90, 91, 92,
+		93, 94, 95,
+		96, 97, 98,
+		99, 100, 101,
+		102, 103, 104,
+		105, 106, 107,
+		108, 109, 110,
+		111, 112, 113,
+		114, 115, 116,
+		117, 118, 119,
+		120, 121, 122,
+		123, 124, 125,
+		126, 127, 128,
+		129, 130, 131,
+		132, 133, 134,
+		135, 136, 137,
+		138, 139, 140,
+		141, 142, 143,
+		144, 145, 146,
+		147, 148, 149,
+		150, 151, 152,
+		153, 154, 155,
+		156, 157, 158,
+		159, 160, 161,
+		162, 163, 164,
+		165, 166, 167,
+		168, 169, 170,
+		171, 172, 173,
+		174, 175, 176,
+		177, 178, 179,
+		180, 181, 182,
+		183, 184, 185,
+		186, 187, 188,
+		189, 190, 191,
+		192, 193, 194,
+		195, 196, 197,
+		198, 199, 200,
+		201, 202, 203,
+		204, 205, 206,
+		207, 208, 209,
+		210, 211, 212,
+		213, 214, 215,
+		216, 217, 218,
+		219, 220, 221,
+		222, 223, 224,
+		225, 226, 227,
+		228, 229, 230,
+		231, 232, 233,
+		234, 235, 236,
+		237, 238, 239,
+		240, 241, 242,
+		243, 244, 245,
+		246, 247, 248,
+		249, 250, 251,
+		252, 253, 254,
+		255, 256, 257,
+		258, 259, 260,
+		261, 262, 263,
+		264, 265, 266,
+		267, 268, 269,
+		270, 271, 272,
+		273, 274, 275,
+		276, 277, 278,
+		279, 280, 281,
+		282, 283, 284,
+		285, 286, 287,
+		288, 289, 290,
+		291, 292, 293,
+		294, 295, 296,
+		297, 298, 299,
+		300, 301, 302,
+		303, 304, 305,
+		306, 307, 308,
+		309, 310, 311,
+		312, 313, 314,
+		315, 316, 317,
+		318, 319, 320,
+		321, 322, 323,
+		324, 325, 326,
+		327, 328, 329,
+		330, 331, 332,
+		333, 334, 335,
+		336, 337, 338,
+		339, 340, 341,
+		342, 343, 344,
+		345, 346, 347,
+		348, 349, 350,
+		351, 352, 353,
+		354, 355, 356,
+		357, 358, 359,
+		360, 361, 362,
+		363, 364, 365,
+		366, 367, 368,
+		369, 370, 371,
+		372, 373, 374,
+		375, 376, 377,
+		378, 379, 380,
+		381, 382, 383,
+		384, 385, 386,
+		387, 388, 389,
+		390, 391, 392,
+		393, 394, 395,
+		396, 397, 398,
+		399, 400, 401,
+		402, 403, 404,
+		405, 406, 407,
+		408, 409, 410,
+		411, 412, 413,
+		414, 415, 416,
+		417, 418, 419,
+		420, 421, 422,
+		423, 424, 425,
+		426, 427, 428,
+		429, 430, 431,
+		432, 433, 434,
+		435, 436, 437,
+		438, 439, 440,
+		441, 442, 443,
+		444, 445, 446,
+		447, 448, 449,
+		450, 451, 452,
+		453, 454, 455,
+		456, 457, 458,
+		459, 460, 461,
+		462, 463, 464,
+		465, 466, 467,
+		468, 469, 470,
+		471, 472, 473,
+		474, 475, 476,
+		477, 478, 479,
+		480, 481, 482,
+		483, 484, 485,
+		486, 487, 488,
+		489, 490, 491,
+		492, 493, 494,
+		495, 496, 497,
+		498, 499, 500,
+		501, 502, 503,
+		504, 505, 506,
+		507, 508, 509,
+		510, 511, 512,
+		513, 514, 515,
+		516, 517, 518,
+		519, 520, 521,
+		522, 523, 524,
+		525, 526, 527,
+		528, 529, 530,
+		531, 532, 533,
+		534, 535, 536,
+		537, 538, 539,
+		540, 541, 542,
+		543, 544, 545,
+		546, 547, 548,
+		549, 550, 551,
+		552, 553, 554,
+		555, 556, 557,
+		558, 559, 560,
+		561, 562, 563,
+		564, 565, 566,
+		567, 568, 569,
+		570, 571, 572,
+		573, 574, 575,
+		576, 577, 578,
+		579, 580, 581,
+		582, 583, 584,
+		585, 586, 587,
+		588, 589, 590,
+		591, 592, 593,
+		594, 595, 596,
+		597, 598, 599,
+		600, 601, 602,
+		603, 604, 605,
+		606, 607, 608,
+		609, 610, 611,
+		612, 613, 614,
+		615, 616, 617,
+		618, 619, 620,
+		621, 622, 623,
+		624, 625, 626,
+		627, 628, 629,
+		630, 631, 632,
+		633, 634, 635,
+		636, 637, 638,
+		639, 640, 641,
+		642, 643, 644,
+		645, 646, 647,
+		648, 649, 650,
+		651, 652, 653,
+		654, 655, 656,
+		657, 658, 659,
+		660, 661, 662,
+		663, 664, 665,
+		666, 667, 668,
+		669, 670, 671,
+		672, 673, 674,
+		675, 676, 677,
+		678, 679, 680,
+		681, 682, 683,
+		684, 685, 686,
+		687, 688, 689,
+		690, 691, 692,
+		693, 694, 695,
+		696, 697, 698,
+		699, 700, 701,
+		702, 703, 704,
+		705, 706, 707,
+		708, 709, 710,
+		711, 712, 713,
+		714, 715, 716,
+		717, 718, 719,
+		720, 721, 722,
+		723, 724, 725,
+		726, 727, 728,
+		729, 730, 731,
+		732, 733, 734,
+		735, 736, 737,
+		738, 739, 740,
+		741, 742, 743,
+		744, 745, 746,
+		747, 748, 749,
+		750, 751, 752,
+		753, 754, 755,
+		756, 757, 758,
+		759, 760, 761,
+		762, 763, 764,
+		765, 766, 767,
+		768, 769, 770,
+		771, 772, 773,
+		774, 775, 776,
+		777, 778, 779,
+		780, 781, 782,
+		783, 784, 785,
+		786, 787, 788,
+		789, 790, 791,
+		792, 793, 794,
+		795, 796, 797,
+		798, 799, 800,
+		801, 802, 803,
+		804, 805, 806,
+		807, 808, 809,
+		810, 811, 812,
+		813, 814, 815,
+		816, 817, 818,
+		819, 820, 821,
+		822, 823, 824,
+		825, 826, 827,
+		828, 829, 830,
+		831, 832, 833,
+		834, 835, 836,
+		837, 838, 839,
+		840, 841, 842,
+		843, 844, 845,
+		846, 847, 848,
+		849, 850, 851,
+		852, 853, 854,
+		855, 856, 857,
+		858, 859, 860,
+		861, 862, 863,
+		864, 865, 866,
+		867, 868, 869,
+		870, 871, 872,
+		873, 874, 875,
+		876, 877, 878,
+		879, 880, 881,
+		882, 883, 884,
+		885, 886, 887,
+		888, 889, 890,
+		891, 892, 893,
+		894, 895, 896,
+		897, 898, 899,
+		900, 901, 902,
+		903, 904, 905,
+		906, 907, 908,
+		909, 910, 911,
+		912, 913, 914,
+		915, 916, 917,
+		918, 919, 920,
+		921, 922, 923,
+		924, 925, 926,
+		927, 928, 929,
+		930, 931, 932,
+		933, 934, 935,
+		936, 937, 938,
+		939, 940, 941,
+		942, 943, 944,
+		945, 946, 947,
+		948, 949, 950,
+		951, 952, 953,
+		954, 955, 956,
+		957, 958, 959};
+
+const float low_sphere_vertices[] =
+	{
+		0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.999999f, 0.020053f,
+		0.425323f, -0.850654f, 0.309011f, 0.000000f, 0.425323f, -0.850654f, 0.309011f, 0.336927f, 0.341759f,
+		-0.162456f, -0.850654f, 0.499995f, 0.000000f, -0.162456f, -0.850654f, 0.499995f, 0.391200f, 0.484445f,
+		0.723607f, -0.447220f, 0.525725f, 0.000000f, 0.723607f, -0.447220f, 0.525725f, 0.757596f, 0.176140f,
+		0.425323f, -0.850654f, 0.309011f, 0.000000f, 0.425323f, -0.850654f, 0.309011f, 0.336927f, 0.341759f,
+		0.850648f, -0.525736f, 0.000000f, 0.000000f, 0.850648f, -0.525736f, 0.000000f, 0.235205f, 0.325266f,
+		0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.999999f, 0.020053f,
+		-0.162456f, -0.850654f, 0.499995f, 0.000000f, -0.162456f, -0.850654f, 0.499995f, 0.391200f, 0.484445f,
+		-0.525730f, -0.850652f, 0.000000f, 0.000000f, -0.525730f, -0.850652f, 0.000000f, 0.943007f, 0.371159f,
+		0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.999999f, 0.020053f,
+		-0.525730f, -0.850652f, 0.000000f, 0.000000f, -0.525730f, -0.850652f, 0.000000f, 0.943007f, 0.371159f,
+		-0.162456f, -0.850654f, -0.499995f, 0.000000f, -0.162456f, -0.850654f, -0.499995f, 0.991338f, 0.520023f,
+		0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.999999f, 0.020053f,
+		-0.162456f, -0.850654f, -0.499995f, 0.000000f, -0.162456f, -0.850654f, -0.499995f, 0.991338f, 0.520023f,
+		0.425323f, -0.850654f, -0.309011f, 0.000000f, 0.425323f, -0.850654f, -0.309011f, 0.137692f, 0.365246f,
+		0.723607f, -0.447220f, 0.525725f, 0.000000f, 0.723607f, -0.447220f, 0.525725f, 0.757596f, 0.176140f,
+		0.850648f, -0.525736f, 0.000000f, 0.000000f, 0.850648f, -0.525736f, 0.000000f, 0.235205f, 0.325266f,
+		0.951058f, 0.000000f, 0.309013f, 0.000000f, 0.951058f, 0.000000f, 0.309013f, 0.291278f, 0.494851f,
+		-0.276388f, -0.447220f, 0.850649f, 0.000000f, -0.276388f, -0.447220f, 0.850649f, 0.546072f, 0.156902f,
+		0.262869f, -0.525738f, 0.809012f, 0.000000f, 0.262869f, -0.525738f, 0.809012f, 0.438926f, 0.305137f,
+		0.000000f, 0.000000f, 1.000000f, 0.000000f, 0.000000f, 0.000000f, 1.000000f, 0.891200f, 0.515555f,
+		-0.894426f, -0.447216f, 0.000000f, 0.000000f, -0.894426f, -0.447216f, 0.000000f, 0.746383f, 0.351642f,
+		-0.688189f, -0.525736f, 0.499997f, 0.000000f, -0.688189f, -0.525736f, 0.499997f, 0.191461f, 0.507219f,
+		-0.951058f, 0.000000f, 0.309013f, 0.000000f, -0.951058f, 0.000000f, 0.309013f, 0.735205f, 0.674734f,
+		-0.276388f, -0.447220f, -0.850649f, 0.000000f, -0.276388f, -0.447220f, -0.850649f, 0.846308f, 0.334943f,
+		-0.688189f, -0.525736f, -0.499997f, 0.000000f, -0.688189f, -0.525736f, -0.499997f, 1.039894f, 0.343193f,
+		-0.587786f, 0.000000f, -0.809017f, 0.000000f, -0.587786f, 0.000000f, -0.809017f, 0.443007f, 0.628841f,
+		0.723607f, -0.447220f, -0.525725f, 0.000000f, 0.723607f, -0.447220f, -0.525725f, 1.326823f, 0.166086f,
+		0.262869f, -0.525738f, -0.809012f, 0.000000f, 0.262869f, -0.525738f, -0.809012f, 0.691461f, 0.492781f,
+		0.587786f, 0.000000f, -0.809017f, 0.000000f, 0.587786f, 0.000000f, -0.809017f, 0.446597f, 0.804967f,
+		0.723607f, -0.447220f, 0.525725f, 0.000000f, 0.723607f, -0.447220f, 0.525725f, 0.757596f, 0.176140f,
+		0.951058f, 0.000000f, 0.309013f, 0.000000f, 0.951058f, 0.000000f, 0.309013f, 0.291278f, 0.494851f,
+		0.587786f, 0.000000f, 0.809017f, 0.000000f, 0.587786f, 0.000000f, 0.809017f, 0.091499f, 0.516836f,
+		-0.276388f, -0.447220f, 0.850649f, 0.000000f, -0.276388f, -0.447220f, 0.850649f, 0.546072f, 0.156902f,
+		0.000000f, 0.000000f, 1.000000f, 0.000000f, 0.000000f, 0.000000f, 1.000000f, 0.891200f, 0.515555f,
+		-0.587786f, 0.000000f, 0.809017f, 0.000000f, -0.587786f, 0.000000f, 0.809017f, 0.637692f, 0.634754f,
+		-0.894426f, -0.447216f, 0.000000f, 0.000000f, -0.894426f, -0.447216f, 0.000000f, 0.746383f, 0.351642f,
+		-0.951058f, 0.000000f, 0.309013f, 0.000000f, -0.951058f, 0.000000f, 0.309013f, 0.735205f, 0.674734f,
+		-0.951058f, 0.000000f, -0.309013f, 0.000000f, -0.951058f, 0.000000f, -0.309013f, 0.629692f, 0.810571f,
+		-0.276388f, -0.447220f, -0.850649f, 0.000000f, -0.276388f, -0.447220f, -0.850649f, 0.846308f, 0.334943f,
+		-0.587786f, 0.000000f, -0.809017f, 0.000000f, -0.587786f, 0.000000f, -0.809017f, 0.443007f, 0.628841f,
+		0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.539894f, 0.656807f,
+		0.723607f, -0.447220f, -0.525725f, 0.000000f, 0.723607f, -0.447220f, -0.525725f, 1.326823f, 0.166086f,
+		0.587786f, 0.000000f, -0.809017f, 0.000000f, 0.587786f, 0.000000f, -0.809017f, 0.446597f, 0.804967f,
+		0.951058f, 0.000000f, -0.309013f, 0.000000f, 0.951058f, 0.000000f, -0.309013f, 0.491338f, 0.479977f,
+		0.276388f, 0.447220f, 0.850649f, 0.000000f, 0.276388f, 0.447220f, 0.850649f, 1.129692f, 0.189429f,
+		0.688189f, 0.525736f, 0.499997f, 0.000000f, 0.688189f, 0.525736f, 0.499997f, 0.246383f, 0.648358f,
+		0.162456f, 0.850654f, 0.499995f, 0.000000f, 0.162456f, 0.850654f, 0.499995f, 0.836927f, 0.658241f,
+		-0.723607f, 0.447220f, 0.525725f, 0.000000f, -0.723607f, 0.447220f, 0.525725f, 0.946597f, 0.195033f,
+		-0.262869f, 0.525738f, 0.809012f, 0.000000f, -0.262869f, 0.525738f, 0.809012f, 0.346308f, 0.665057f,
+		-0.425323f, 0.850654f, 0.309011f, 0.000000f, -0.425323f, 0.850654f, 0.309011f, 0.938926f, 0.694863f,
+		-0.723607f, 0.447220f, -0.525725f, 0.000000f, -0.723607f, 0.447220f, -0.525725f, 0.791278f, 0.505149f,
+		-0.850648f, 0.525736f, 0.000000f, 0.000000f, -0.850648f, 0.525736f, 0.000000f, 0.257596f, 0.823860f,
+		-0.425323f, 0.850654f, -0.309011f, 0.000000f, -0.425323f, 0.850654f, -0.309011f, 0.826823f, 0.833914f,
+		0.276388f, 0.447220f, -0.850649f, 0.000000f, 0.276388f, 0.447220f, -0.850649f, 0.542767f, 0.333057f,
+		-0.262869f, 0.525738f, -0.809012f, 0.000000f, -0.262869f, 0.525738f, -0.809012f, 0.042767f, 0.666943f,
+		0.162456f, 0.850654f, -0.499995f, 0.000000f, 0.162456f, 0.850654f, -0.499995f, 0.326823f, 0.166086f,
+		0.894426f, 0.447216f, 0.000000f, 0.000000f, 0.894426f, 0.447216f, 0.000000f, 0.646443f, 0.311386f,
+		0.688189f, 0.525736f, -0.499997f, 0.000000f, 0.688189f, 0.525736f, -0.499997f, 0.146443f, 0.688614f,
+		0.525730f, 0.850652f, 0.000000f, 0.000000f, 0.525730f, 0.850652f, 0.000000f, 0.046072f, 0.843098f,
+		-0.162456f, -0.850654f, 0.499995f, 0.000000f, -0.162456f, -0.850654f, 0.499995f, 0.391200f, 0.484445f,
+		0.262869f, -0.525738f, 0.809012f, 0.000000f, 0.262869f, -0.525738f, 0.809012f, 0.438926f, 0.305137f,
+		-0.276388f, -0.447220f, 0.850649f, 0.000000f, -0.276388f, -0.447220f, 0.850649f, 0.546072f, 0.156902f,
+		-0.162456f, -0.850654f, 0.499995f, 0.000000f, -0.162456f, -0.850654f, 0.499995f, 0.391200f, 0.484445f,
+		0.425323f, -0.850654f, 0.309011f, 0.000000f, 0.425323f, -0.850654f, 0.309011f, 0.336927f, 0.341759f,
+		0.262869f, -0.525738f, 0.809012f, 0.000000f, 0.262869f, -0.525738f, 0.809012f, 0.438926f, 0.305137f,
+		0.425323f, -0.850654f, 0.309011f, 0.000000f, 0.425323f, -0.850654f, 0.309011f, 0.336927f, 0.341759f,
+		0.723607f, -0.447220f, 0.525725f, 0.000000f, 0.723607f, -0.447220f, 0.525725f, 0.757596f, 0.176140f,
+		0.262869f, -0.525738f, 0.809012f, 0.000000f, 0.262869f, -0.525738f, 0.809012f, 0.438926f, 0.305137f,
+		0.850648f, -0.525736f, 0.000000f, 0.000000f, 0.850648f, -0.525736f, 0.000000f, 0.235205f, 0.325266f,
+		0.425323f, -0.850654f, -0.309011f, 0.000000f, 0.425323f, -0.850654f, -0.309011f, 0.137692f, 0.365246f,
+		0.723607f, -0.447220f, -0.525725f, 0.000000f, 0.723607f, -0.447220f, -0.525725f, 1.326823f, 0.166086f,
+		0.850648f, -0.525736f, 0.000000f, 0.000000f, 0.850648f, -0.525736f, 0.000000f, 0.235205f, 0.325266f,
+		0.425323f, -0.850654f, 0.309011f, 0.000000f, 0.425323f, -0.850654f, 0.309011f, 0.336927f, 0.341759f,
+		0.425323f, -0.850654f, -0.309011f, 0.000000f, 0.425323f, -0.850654f, -0.309011f, 0.137692f, 0.365246f,
+		0.425323f, -0.850654f, 0.309011f, 0.000000f, 0.425323f, -0.850654f, 0.309011f, 0.336927f, 0.341759f,
+		0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.999999f, 0.020053f,
+		0.425323f, -0.850654f, -0.309011f, 0.000000f, 0.425323f, -0.850654f, -0.309011f, 0.137692f, 0.365246f,
+		-0.525730f, -0.850652f, 0.000000f, 0.000000f, -0.525730f, -0.850652f, 0.000000f, 0.943007f, 0.371159f,
+		-0.688189f, -0.525736f, 0.499997f, 0.000000f, -0.688189f, -0.525736f, 0.499997f, 0.191461f, 0.507219f,
+		-0.894426f, -0.447216f, 0.000000f, 0.000000f, -0.894426f, -0.447216f, 0.000000f, 0.746383f, 0.351642f,
+		-0.525730f, -0.850652f, 0.000000f, 0.000000f, -0.525730f, -0.850652f, 0.000000f, 0.943007f, 0.371159f,
+		-0.162456f, -0.850654f, 0.499995f, 0.000000f, -0.162456f, -0.850654f, 0.499995f, 0.391200f, 0.484445f,
+		-0.688189f, -0.525736f, 0.499997f, 0.000000f, -0.688189f, -0.525736f, 0.499997f, 0.191461f, 0.507219f,
+		-0.162456f, -0.850654f, 0.499995f, 0.000000f, -0.162456f, -0.850654f, 0.499995f, 0.391200f, 0.484445f,
+		-0.276388f, -0.447220f, 0.850649f, 0.000000f, -0.276388f, -0.447220f, 0.850649f, 0.546072f, 0.156902f,
+		-0.688189f, -0.525736f, 0.499997f, 0.000000f, -0.688189f, -0.525736f, 0.499997f, 0.191461f, 0.507219f,
+		-0.162456f, -0.850654f, -0.499995f, 0.000000f, -0.162456f, -0.850654f, -0.499995f, 0.991338f, 0.520023f,
+		-0.688189f, -0.525736f, -0.499997f, 0.000000f, -0.688189f, -0.525736f, -0.499997f, 1.039894f, 0.343193f,
+		-0.276388f, -0.447220f, -0.850649f, 0.000000f, -0.276388f, -0.447220f, -0.850649f, 0.846308f, 0.334943f,
+		-0.162456f, -0.850654f, -0.499995f, 0.000000f, -0.162456f, -0.850654f, -0.499995f, 0.991338f, 0.520023f,
+		-0.525730f, -0.850652f, 0.000000f, 0.000000f, -0.525730f, -0.850652f, 0.000000f, 0.943007f, 0.371159f,
+		-0.688189f, -0.525736f, -0.499997f, 0.000000f, -0.688189f, -0.525736f, -0.499997f, 1.039894f, 0.343193f,
+		-0.525730f, -0.850652f, 0.000000f, 0.000000f, -0.525730f, -0.850652f, 0.000000f, 0.943007f, 0.371159f,
+		-0.894426f, -0.447216f, 0.000000f, 0.000000f, -0.894426f, -0.447216f, 0.000000f, 0.746383f, 0.351642f,
+		-0.688189f, -0.525736f, -0.499997f, 0.000000f, -0.688189f, -0.525736f, -0.499997f, 1.039894f, 0.343193f,
+		0.425323f, -0.850654f, -0.309011f, 0.000000f, 0.425323f, -0.850654f, -0.309011f, 0.137692f, 0.365246f,
+		0.262869f, -0.525738f, -0.809012f, 0.000000f, 0.262869f, -0.525738f, -0.809012f, 0.691461f, 0.492781f,
+		0.723607f, -0.447220f, -0.525725f, 0.000000f, 0.723607f, -0.447220f, -0.525725f, 1.326823f, 0.166086f,
+		0.425323f, -0.850654f, -0.309011f, 0.000000f, 0.425323f, -0.850654f, -0.309011f, 0.137692f, 0.365246f,
+		-0.162456f, -0.850654f, -0.499995f, 0.000000f, -0.162456f, -0.850654f, -0.499995f, 0.991338f, 0.520023f,
+		0.262869f, -0.525738f, -0.809012f, 0.000000f, 0.262869f, -0.525738f, -0.809012f, 0.691461f, 0.492781f,
+		-0.162456f, -0.850654f, -0.499995f, 0.000000f, -0.162456f, -0.850654f, -0.499995f, 0.991338f, 0.520023f,
+		-0.276388f, -0.447220f, -0.850649f, 0.000000f, -0.276388f, -0.447220f, -0.850649f, 0.846308f, 0.334943f,
+		0.262869f, -0.525738f, -0.809012f, 0.000000f, 0.262869f, -0.525738f, -0.809012f, 0.691461f, 0.492781f,
+		0.951058f, 0.000000f, 0.309013f, 0.000000f, 0.951058f, 0.000000f, 0.309013f, 0.291278f, 0.494851f,
+		0.951058f, 0.000000f, -0.309013f, 0.000000f, 0.951058f, 0.000000f, -0.309013f, 0.491338f, 0.479977f,
+		0.894426f, 0.447216f, 0.000000f, 0.000000f, 0.894426f, 0.447216f, 0.000000f, 0.646443f, 0.311386f,
+		0.951058f, 0.000000f, 0.309013f, 0.000000f, 0.951058f, 0.000000f, 0.309013f, 0.291278f, 0.494851f,
+		0.850648f, -0.525736f, 0.000000f, 0.000000f, 0.850648f, -0.525736f, 0.000000f, 0.235205f, 0.325266f,
+		0.951058f, 0.000000f, -0.309013f, 0.000000f, 0.951058f, 0.000000f, -0.309013f, 0.491338f, 0.479977f,
+		0.850648f, -0.525736f, 0.000000f, 0.000000f, 0.850648f, -0.525736f, 0.000000f, 0.235205f, 0.325266f,
+		0.723607f, -0.447220f, -0.525725f, 0.000000f, 0.723607f, -0.447220f, -0.525725f, 1.326823f, 0.166086f,
+		0.951058f, 0.000000f, -0.309013f, 0.000000f, 0.951058f, 0.000000f, -0.309013f, 0.491338f, 0.479977f,
+		0.000000f, 0.000000f, 1.000000f, 0.000000f, 0.000000f, 0.000000f, 1.000000f, 0.891200f, 0.515555f,
+		0.587786f, 0.000000f, 0.809017f, 0.000000f, 0.587786f, 0.000000f, 0.809017f, 0.091499f, 0.516836f,
+		0.276388f, 0.447220f, 0.850649f, 0.000000f, 0.276388f, 0.447220f, 0.850649f, 1.129692f, 0.189429f,
+		0.000000f, 0.000000f, 1.000000f, 0.000000f, 0.000000f, 0.000000f, 1.000000f, 0.891200f, 0.515555f,
+		0.262869f, -0.525738f, 0.809012f, 0.000000f, 0.262869f, -0.525738f, 0.809012f, 0.438926f, 0.305137f,
+		0.587786f, 0.000000f, 0.809017f, 0.000000f, 0.587786f, 0.000000f, 0.809017f, 0.091499f, 0.516836f,
+		0.262869f, -0.525738f, 0.809012f, 0.000000f, 0.262869f, -0.525738f, 0.809012f, 0.438926f, 0.305137f,
+		0.723607f, -0.447220f, 0.525725f, 0.000000f, 0.723607f, -0.447220f, 0.525725f, 0.757596f, 0.176140f,
+		0.587786f, 0.000000f, 0.809017f, 0.000000f, 0.587786f, 0.000000f, 0.809017f, 0.091499f, 0.516836f,
+		-0.951058f, 0.000000f, 0.309013f, 0.000000f, -0.951058f, 0.000000f, 0.309013f, 0.735205f, 0.674734f,
+		-0.587786f, 0.000000f, 0.809017f, 0.000000f, -0.587786f, 0.000000f, 0.809017f, 0.637692f, 0.634754f,
+		-0.723607f, 0.447220f, 0.525725f, 0.000000f, -0.723607f, 0.447220f, 0.525725f, 0.946597f, 0.195033f,
+		-0.951058f, 0.000000f, 0.309013f, 0.000000f, -0.951058f, 0.000000f, 0.309013f, 0.735205f, 0.674734f,
+		-0.688189f, -0.525736f, 0.499997f, 0.000000f, -0.688189f, -0.525736f, 0.499997f, 0.191461f, 0.507219f,
+		-0.587786f, 0.000000f, 0.809017f, 0.000000f, -0.587786f, 0.000000f, 0.809017f, 0.637692f, 0.634754f,
+		-0.688189f, -0.525736f, 0.499997f, 0.000000f, -0.688189f, -0.525736f, 0.499997f, 0.191461f, 0.507219f,
+		-0.276388f, -0.447220f, 0.850649f, 0.000000f, -0.276388f, -0.447220f, 0.850649f, 0.546072f, 0.156902f,
+		-0.587786f, 0.000000f, 0.809017f, 0.000000f, -0.587786f, 0.000000f, 0.809017f, 0.637692f, 0.634754f,
+		-0.587786f, 0.000000f, -0.809017f, 0.000000f, -0.587786f, 0.000000f, -0.809017f, 0.443007f, 0.628841f,
+		-0.951058f, 0.000000f, -0.309013f, 0.000000f, -0.951058f, 0.000000f, -0.309013f, 0.629692f, 0.810571f,
+		-0.723607f, 0.447220f, -0.525725f, 0.000000f, -0.723607f, 0.447220f, -0.525725f, 0.791278f, 0.505149f,
+		-0.587786f, 0.000000f, -0.809017f, 0.000000f, -0.587786f, 0.000000f, -0.809017f, 0.443007f, 0.628841f,
+		-0.688189f, -0.525736f, -0.499997f, 0.000000f, -0.688189f, -0.525736f, -0.499997f, 1.039894f, 0.343193f,
+		-0.951058f, 0.000000f, -0.309013f, 0.000000f, -0.951058f, 0.000000f, -0.309013f, 0.629692f, 0.810571f,
+		-0.688189f, -0.525736f, -0.499997f, 0.000000f, -0.688189f, -0.525736f, -0.499997f, 1.039894f, 0.343193f,
+		-0.894426f, -0.447216f, 0.000000f, 0.000000f, -0.894426f, -0.447216f, 0.000000f, 0.746383f, 0.351642f,
+		-0.951058f, 0.000000f, -0.309013f, 0.000000f, -0.951058f, 0.000000f, -0.309013f, 0.629692f, 0.810571f,
+		0.587786f, 0.000000f, -0.809017f, 0.000000f, 0.587786f, 0.000000f, -0.809017f, 0.446597f, 0.804967f,
+		0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.539894f, 0.656807f,
+		0.276388f, 0.447220f, -0.850649f, 0.000000f, 0.276388f, 0.447220f, -0.850649f, 0.542767f, 0.333057f,
+		0.587786f, 0.000000f, -0.809017f, 0.000000f, 0.587786f, 0.000000f, -0.809017f, 0.446597f, 0.804967f,
+		0.262869f, -0.525738f, -0.809012f, 0.000000f, 0.262869f, -0.525738f, -0.809012f, 0.691461f, 0.492781f,
+		0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.539894f, 0.656807f,
+		0.262869f, -0.525738f, -0.809012f, 0.000000f, 0.262869f, -0.525738f, -0.809012f, 0.691461f, 0.492781f,
+		-0.276388f, -0.447220f, -0.850649f, 0.000000f, -0.276388f, -0.447220f, -0.850649f, 0.846308f, 0.334943f,
+		0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.539894f, 0.656807f,
+		0.587786f, 0.000000f, 0.809017f, 0.000000f, 0.587786f, 0.000000f, 0.809017f, 0.091499f, 0.516836f,
+		0.688189f, 0.525736f, 0.499997f, 0.000000f, 0.688189f, 0.525736f, 0.499997f, 0.246383f, 0.648358f,
+		0.276388f, 0.447220f, 0.850649f, 0.000000f, 0.276388f, 0.447220f, 0.850649f, 1.129692f, 0.189429f,
+		0.587786f, 0.000000f, 0.809017f, 0.000000f, 0.587786f, 0.000000f, 0.809017f, 0.091499f, 0.516836f,
+		0.951058f, 0.000000f, 0.309013f, 0.000000f, 0.951058f, 0.000000f, 0.309013f, 0.291278f, 0.494851f,
+		0.688189f, 0.525736f, 0.499997f, 0.000000f, 0.688189f, 0.525736f, 0.499997f, 0.246383f, 0.648358f,
+		0.951058f, 0.000000f, 0.309013f, 0.000000f, 0.951058f, 0.000000f, 0.309013f, 0.291278f, 0.494851f,
+		0.894426f, 0.447216f, 0.000000f, 0.000000f, 0.894426f, 0.447216f, 0.000000f, 0.646443f, 0.311386f,
+		0.688189f, 0.525736f, 0.499997f, 0.000000f, 0.688189f, 0.525736f, 0.499997f, 0.246383f, 0.648358f,
+		-0.587786f, 0.000000f, 0.809017f, 0.000000f, -0.587786f, 0.000000f, 0.809017f, 0.637692f, 0.634754f,
+		-0.262869f, 0.525738f, 0.809012f, 0.000000f, -0.262869f, 0.525738f, 0.809012f, 0.346308f, 0.665057f,
+		-0.723607f, 0.447220f, 0.525725f, 0.000000f, -0.723607f, 0.447220f, 0.525725f, 0.946597f, 0.195033f,
+		-0.587786f, 0.000000f, 0.809017f, 0.000000f, -0.587786f, 0.000000f, 0.809017f, 0.637692f, 0.634754f,
+		0.000000f, 0.000000f, 1.000000f, 0.000000f, 0.000000f, 0.000000f, 1.000000f, 0.891200f, 0.515555f,
+		-0.262869f, 0.525738f, 0.809012f, 0.000000f, -0.262869f, 0.525738f, 0.809012f, 0.346308f, 0.665057f,
+		0.000000f, 0.000000f, 1.000000f, 0.000000f, 0.000000f, 0.000000f, 1.000000f, 0.891200f, 0.515555f,
+		0.276388f, 0.447220f, 0.850649f, 0.000000f, 0.276388f, 0.447220f, 0.850649f, 1.129692f, 0.189429f,
+		-0.262869f, 0.525738f, 0.809012f, 0.000000f, -0.262869f, 0.525738f, 0.809012f, 0.346308f, 0.665057f,
+		-0.951058f, 0.000000f, -0.309013f, 0.000000f, -0.951058f, 0.000000f, -0.309013f, 0.629692f, 0.810571f,
+		-0.850648f, 0.525736f, 0.000000f, 0.000000f, -0.850648f, 0.525736f, 0.000000f, 0.257596f, 0.823860f,
+		-0.723607f, 0.447220f, -0.525725f, 0.000000f, -0.723607f, 0.447220f, -0.525725f, 0.791278f, 0.505149f,
+		-0.951058f, 0.000000f, -0.309013f, 0.000000f, -0.951058f, 0.000000f, -0.309013f, 0.629692f, 0.810571f,
+		-0.951058f, 0.000000f, 0.309013f, 0.000000f, -0.951058f, 0.000000f, 0.309013f, 0.735205f, 0.674734f,
+		-0.850648f, 0.525736f, 0.000000f, 0.000000f, -0.850648f, 0.525736f, 0.000000f, 0.257596f, 0.823860f,
+		-0.951058f, 0.000000f, 0.309013f, 0.000000f, -0.951058f, 0.000000f, 0.309013f, 0.735205f, 0.674734f,
+		-0.723607f, 0.447220f, 0.525725f, 0.000000f, -0.723607f, 0.447220f, 0.525725f, 0.946597f, 0.195033f,
+		-0.850648f, 0.525736f, 0.000000f, 0.000000f, -0.850648f, 0.525736f, 0.000000f, 0.257596f, 0.823860f,
+		0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.539894f, 0.656807f,
+		-0.262869f, 0.525738f, -0.809012f, 0.000000f, -0.262869f, 0.525738f, -0.809012f, 0.042767f, 0.666943f,
+		0.276388f, 0.447220f, -0.850649f, 0.000000f, 0.276388f, 0.447220f, -0.850649f, 0.542767f, 0.333057f,
+		0.000000f, 0.000000f, -1.000000f, 0.000000f, 0.000000f, 0.000000f, -1.000000f, 0.539894f, 0.656807f,
+		-0.587786f, 0.000000f, -0.809017f, 0.000000f, -0.587786f, 0.000000f, -0.809017f, 0.443007f, 0.628841f,
+		-0.262869f, 0.525738f, -0.809012f, 0.000000f, -0.262869f, 0.525738f, -0.809012f, 0.042767f, 0.666943f,
+		-0.587786f, 0.000000f, -0.809017f, 0.000000f, -0.587786f, 0.000000f, -0.809017f, 0.443007f, 0.628841f,
+		-0.723607f, 0.447220f, -0.525725f, 0.000000f, -0.723607f, 0.447220f, -0.525725f, 0.791278f, 0.505149f,
+		-0.262869f, 0.525738f, -0.809012f, 0.000000f, -0.262869f, 0.525738f, -0.809012f, 0.042767f, 0.666943f,
+		0.951058f, 0.000000f, -0.309013f, 0.000000f, 0.951058f, 0.000000f, -0.309013f, 0.491338f, 0.479977f,
+		0.688189f, 0.525736f, -0.499997f, 0.000000f, 0.688189f, 0.525736f, -0.499997f, 0.146443f, 0.688614f,
+		0.894426f, 0.447216f, 0.000000f, 0.000000f, 0.894426f, 0.447216f, 0.000000f, 0.646443f, 0.311386f,
+		0.951058f, 0.000000f, -0.309013f, 0.000000f, 0.951058f, 0.000000f, -0.309013f, 0.491338f, 0.479977f,
+		0.587786f, 0.000000f, -0.809017f, 0.000000f, 0.587786f, 0.000000f, -0.809017f, 0.446597f, 0.804967f,
+		0.688189f, 0.525736f, -0.499997f, 0.000000f, 0.688189f, 0.525736f, -0.499997f, 0.146443f, 0.688614f,
+		0.587786f, 0.000000f, -0.809017f, 0.000000f, 0.587786f, 0.000000f, -0.809017f, 0.446597f, 0.804967f,
+		0.276388f, 0.447220f, -0.850649f, 0.000000f, 0.276388f, 0.447220f, -0.850649f, 0.542767f, 0.333057f,
+		0.688189f, 0.525736f, -0.499997f, 0.000000f, 0.688189f, 0.525736f, -0.499997f, 0.146443f, 0.688614f,
+		0.162456f, 0.850654f, 0.499995f, 0.000000f, 0.162456f, 0.850654f, 0.499995f, 0.836927f, 0.658241f,
+		0.525730f, 0.850652f, 0.000000f, 0.000000f, 0.525730f, 0.850652f, 0.000000f, 0.046072f, 0.843098f,
+		0.000000f, 1.000000f, 0.000000f, 0.000000f, 0.000000f, 1.000000f, 0.000000f, 0.591499f, 0.483164f,
+		0.162456f, 0.850654f, 0.499995f, 0.000000f, 0.162456f, 0.850654f, 0.499995f, 0.836927f, 0.658241f,
+		0.688189f, 0.525736f, 0.499997f, 0.000000f, 0.688189f, 0.525736f, 0.499997f, 0.246383f, 0.648358f,
+		0.525730f, 0.850652f, 0.000000f, 0.000000f, 0.525730f, 0.850652f, 0.000000f, 0.046072f, 0.843098f,
+		0.688189f, 0.525736f, 0.499997f, 0.000000f, 0.688189f, 0.525736f, 0.499997f, 0.246383f, 0.648358f,
+		0.894426f, 0.447216f, 0.000000f, 0.000000f, 0.894426f, 0.447216f, 0.000000f, 0.646443f, 0.311386f,
+		0.525730f, 0.850652f, 0.000000f, 0.000000f, 0.525730f, 0.850652f, 0.000000f, 0.046072f, 0.843098f,
+		-0.425323f, 0.850654f, 0.309011f, 0.000000f, -0.425323f, 0.850654f, 0.309011f, 0.938926f, 0.694863f,
+		0.162456f, 0.850654f, 0.499995f, 0.000000f, 0.162456f, 0.850654f, 0.499995f, 0.836927f, 0.658241f,
+		0.000000f, 1.000000f, 0.000000f, 0.000000f, 0.000000f, 1.000000f, 0.000000f, 0.591499f, 0.483164f,
+		-0.425323f, 0.850654f, 0.309011f, 0.000000f, -0.425323f, 0.850654f, 0.309011f, 0.938926f, 0.694863f,
+		-0.262869f, 0.525738f, 0.809012f, 0.000000f, -0.262869f, 0.525738f, 0.809012f, 0.346308f, 0.665057f,
+		0.162456f, 0.850654f, 0.499995f, 0.000000f, 0.162456f, 0.850654f, 0.499995f, 0.836927f, 0.658241f,
+		-0.262869f, 0.525738f, 0.809012f, 0.000000f, -0.262869f, 0.525738f, 0.809012f, 0.346308f, 0.665057f,
+		0.276388f, 0.447220f, 0.850649f, 0.000000f, 0.276388f, 0.447220f, 0.850649f, 1.129692f, 0.189429f,
+		0.162456f, 0.850654f, 0.499995f, 0.000000f, 0.162456f, 0.850654f, 0.499995f, 0.836927f, 0.658241f,
+		-0.425323f, 0.850654f, -0.309011f, 0.000000f, -0.425323f, 0.850654f, -0.309011f, 0.826823f, 0.833914f,
+		-0.425323f, 0.850654f, 0.309011f, 0.000000f, -0.425323f, 0.850654f, 0.309011f, 0.938926f, 0.694863f,
+		0.000000f, 1.000000f, 0.000000f, 0.000000f, 0.000000f, 1.000000f, 0.000000f, 0.591499f, 0.483164f,
+		-0.425323f, 0.850654f, -0.309011f, 0.000000f, -0.425323f, 0.850654f, -0.309011f, 0.826823f, 0.833914f,
+		-0.850648f, 0.525736f, 0.000000f, 0.000000f, -0.850648f, 0.525736f, 0.000000f, 0.257596f, 0.823860f,
+		-0.425323f, 0.850654f, 0.309011f, 0.000000f, -0.425323f, 0.850654f, 0.309011f, 0.938926f, 0.694863f,
+		-0.850648f, 0.525736f, 0.000000f, 0.000000f, -0.850648f, 0.525736f, 0.000000f, 0.257596f, 0.823860f,
+		-0.723607f, 0.447220f, 0.525725f, 0.000000f, -0.723607f, 0.447220f, 0.525725f, 0.946597f, 0.195033f,
+		-0.425323f, 0.850654f, 0.309011f, 0.000000f, -0.425323f, 0.850654f, 0.309011f, 0.938926f, 0.694863f,
+		0.162456f, 0.850654f, -0.499995f, 0.000000f, 0.162456f, 0.850654f, -0.499995f, 0.326823f, 0.166086f,
+		-0.425323f, 0.850654f, -0.309011f, 0.000000f, -0.425323f, 0.850654f, -0.309011f, 0.826823f, 0.833914f,
+		0.000000f, 1.000000f, 0.000000f, 0.000000f, 0.000000f, 1.000000f, 0.000000f, 0.591499f, 0.483164f,
+		0.162456f, 0.850654f, -0.499995f, 0.000000f, 0.162456f, 0.850654f, -0.499995f, 0.326823f, 0.166086f,
+		-0.262869f, 0.525738f, -0.809012f, 0.000000f, -0.262869f, 0.525738f, -0.809012f, 0.042767f, 0.666943f,
+		-0.425323f, 0.850654f, -0.309011f, 0.000000f, -0.425323f, 0.850654f, -0.309011f, 0.826823f, 0.833914f,
+		-0.262869f, 0.525738f, -0.809012f, 0.000000f, -0.262869f, 0.525738f, -0.809012f, 0.042767f, 0.666943f,
+		-0.723607f, 0.447220f, -0.525725f, 0.000000f, -0.723607f, 0.447220f, -0.525725f, 0.791278f, 0.505149f,
+		-0.425323f, 0.850654f, -0.309011f, 0.000000f, -0.425323f, 0.850654f, -0.309011f, 0.826823f, 0.833914f,
+		0.525730f, 0.850652f, 0.000000f, 0.000000f, 0.525730f, 0.850652f, 0.000000f, 0.046072f, 0.843098f,
+		0.162456f, 0.850654f, -0.499995f, 0.000000f, 0.162456f, 0.850654f, -0.499995f, 0.326823f, 0.166086f,
+		0.000000f, 1.000000f, 0.000000f, 0.000000f, 0.000000f, 1.000000f, 0.000000f, 0.591499f, 0.483164f,
+		0.525730f, 0.850652f, 0.000000f, 0.000000f, 0.525730f, 0.850652f, 0.000000f, 0.046072f, 0.843098f,
+		0.688189f, 0.525736f, -0.499997f, 0.000000f, 0.688189f, 0.525736f, -0.499997f, 0.146443f, 0.688614f,
+		0.162456f, 0.850654f, -0.499995f, 0.000000f, 0.162456f, 0.850654f, -0.499995f, 0.326823f, 0.166086f,
+		0.688189f, 0.525736f, -0.499997f, 0.000000f, 0.688189f, 0.525736f, -0.499997f, 0.146443f, 0.688614f,
+		0.276388f, 0.447220f, -0.850649f, 0.000000f, 0.276388f, 0.447220f, -0.850649f, 0.542767f, 0.333057f,
+		0.162456f, 0.850654f, -0.499995f, 0.000000f, 0.162456f, 0.850654f, -0.499995f, 0.326823f, 0.166086f};
+
+const int low_sphere_indices[] =
+	{
+		0, 1, 2,
+		3, 4, 5,
+		6, 7, 8,
+		9, 10, 11,
+		12, 13, 14,
+		15, 16, 17,
+		18, 19, 20,
+		21, 22, 23,
+		24, 25, 26,
+		27, 28, 29,
+		30, 31, 32,
+		33, 34, 35,
+		36, 37, 38,
+		39, 40, 41,
+		42, 43, 44,
+		45, 46, 47,
+		48, 49, 50,
+		51, 52, 53,
+		54, 55, 56,
+		57, 58, 59,
+		60, 61, 62,
+		63, 64, 65,
+		66, 67, 68,
+		69, 70, 71,
+		72, 73, 74,
+		75, 76, 77,
+		78, 79, 80,
+		81, 82, 83,
+		84, 85, 86,
+		87, 88, 89,
+		90, 91, 92,
+		93, 94, 95,
+		96, 97, 98,
+		99, 100, 101,
+		102, 103, 104,
+		105, 106, 107,
+		108, 109, 110,
+		111, 112, 113,
+		114, 115, 116,
+		117, 118, 119,
+		120, 121, 122,
+		123, 124, 125,
+		126, 127, 128,
+		129, 130, 131,
+		132, 133, 134,
+		135, 136, 137,
+		138, 139, 140,
+		141, 142, 143,
+		144, 145, 146,
+		147, 148, 149,
+		150, 151, 152,
+		153, 154, 155,
+		156, 157, 158,
+		159, 160, 161,
+		162, 163, 164,
+		165, 166, 167,
+		168, 169, 170,
+		171, 172, 173,
+		174, 175, 176,
+		177, 178, 179,
+		180, 181, 182,
+		183, 184, 185,
+		186, 187, 188,
+		189, 190, 191,
+		192, 193, 194,
+		195, 196, 197,
+		198, 199, 200,
+		201, 202, 203,
+		204, 205, 206,
+		207, 208, 209,
+		210, 211, 212,
+		213, 214, 215,
+		216, 217, 218,
+		219, 220, 221,
+		222, 223, 224,
+		225, 226, 227,
+		228, 229, 230,
+		231, 232, 233,
+		234, 235, 236,
+		237, 238, 239};
+
+const float point_sphere_vertices[] =
+	{
+		0.000000,
+		0.000000,
+		0.000000,
+		0.000000,
+		0.000000,
+		-1.000000,
+		0.000000,
+		0.48f,
+		0.48f,
+};
+
+const int point_sphere_indices[] =
+	{
+		0};
+
+const float textured_detailed_sphere_vertices[] =
+	{
+		-0.493414f,
+		-0.080891f,
+		0.000000f,
+		0.000000f,
+		-0.986900f,
+		-0.161200f,
+		0.000000f,
+		1.000000f,
+		0.448300f,
+		-0.499267f,
+		-0.027069f,
+		0.000000f,
+		0.000000f,
+		-0.998500f,
+		-0.054000f,
+		0.000000f,
+		1.000000f,
+		0.482800f,
+		-0.489673f,
+		-0.027069f,
+		-0.097402f,
+		0.000000f,
+		-0.979300f,
+		-0.054000f,
+		-0.194800f,
+		0.968800f,
+		0.482800f,
+		-0.493414f,
+		-0.080891f,
+		0.000000f,
+		0.000000f,
+		-0.986900f,
+		-0.161200f,
+		0.000000f,
+		1.000000f,
+		0.448300f,
+		-0.489673f,
+		-0.027069f,
+		-0.097402f,
+		0.000000f,
+		-0.979300f,
+		-0.054000f,
+		-0.194800f,
+		0.968800f,
+		0.482800f,
+		-0.483932f,
+		-0.080891f,
+		-0.096260f,
+		0.000000f,
+		-0.967900f,
+		-0.161200f,
+		-0.192500f,
+		0.968800f,
+		0.448300f,
+		-0.159651f,
+		0.473826f,
+		0.000000f,
+		0.000000f,
+		-0.322300f,
+		0.946600f,
+		0.000000f,
+		1.000000f,
+		0.896600f,
+		-0.107485f,
+		0.488310f,
+		0.000000f,
+		0.000000f,
+		-0.218200f,
+		0.975900f,
+		0.000000f,
+		1.000000f,
+		0.931000f,
+		-0.105420f,
+		0.488310f,
+		-0.020969f,
+		0.000000f,
+		-0.214000f,
+		0.975900f,
+		-0.042500f,
+		0.968800f,
+		0.931000f,
+		-0.159651f,
+		0.473826f,
+		0.000000f,
+		0.000000f,
+		-0.322300f,
+		0.946600f,
+		0.000000f,
+		1.000000f,
+		0.896600f,
+		-0.105420f,
+		0.488310f,
+		-0.020969f,
+		0.000000f,
+		-0.214000f,
+		0.975900f,
+		-0.042500f,
+		0.968800f,
+		0.931000f,
+		-0.156583f,
+		0.473826f,
+		-0.031146f,
+		0.000000f,
+		-0.316100f,
+		0.946600f,
+		-0.062900f,
+		0.968800f,
+		0.896600f,
+		-0.481775f,
+		-0.133764f,
+		0.000000f,
+		0.000000f,
+		-0.963800f,
+		-0.266600f,
+		0.000000f,
+		1.000000f,
+		0.413800f,
+		-0.493414f,
+		-0.080891f,
+		0.000000f,
+		0.000000f,
+		-0.986900f,
+		-0.161200f,
+		0.000000f,
+		1.000000f,
+		0.448300f,
+		-0.483932f,
+		-0.080891f,
+		-0.096260f,
+		0.000000f,
+		-0.967900f,
+		-0.161200f,
+		-0.192500f,
+		0.968800f,
+		0.448300f,
+		-0.481775f,
+		-0.133764f,
+		0.000000f,
+		0.000000f,
+		-0.963800f,
+		-0.266600f,
+		0.000000f,
+		1.000000f,
+		0.413800f,
+		-0.483932f,
+		-0.080891f,
+		-0.096260f,
+		0.000000f,
+		-0.967900f,
+		-0.161200f,
+		-0.192500f,
+		0.968800f,
+		0.448300f,
+		-0.472518f,
+		-0.133764f,
+		-0.093989f,
+		0.000000f,
+		-0.945200f,
+		-0.266600f,
+		-0.188000f,
+		0.968800f,
+		0.413800f,
+		-0.209945f,
+		0.453788f,
+		0.000000f,
+		0.000000f,
+		-0.422700f,
+		0.906300f,
+		0.000000f,
+		1.000000f,
+		0.862100f,
+		-0.159651f,
+		0.473826f,
+		0.000000f,
+		0.000000f,
+		-0.322300f,
+		0.946600f,
+		0.000000f,
+		1.000000f,
+		0.896600f,
+		-0.156583f,
+		0.473826f,
+		-0.031146f,
+		0.000000f,
+		-0.316100f,
+		0.946600f,
+		-0.062900f,
+		0.968800f,
+		0.896600f,
+		-0.209945f,
+		0.453788f,
+		0.000000f,
+		0.000000f,
+		-0.422700f,
+		0.906300f,
+		0.000000f,
+		1.000000f,
+		0.862100f,
+		-0.156583f,
+		0.473826f,
+		-0.031146f,
+		0.000000f,
+		-0.316100f,
+		0.946600f,
+		-0.062900f,
+		0.968800f,
+		0.896600f,
+		-0.205911f,
+		0.453788f,
+		-0.040958f,
+		0.000000f,
+		-0.414500f,
+		0.906300f,
+		-0.082400f,
+		0.968800f,
+		0.862100f,
+		-0.464489f,
+		-0.185069f,
+		0.000000f,
+		0.000000f,
+		-0.929400f,
+		-0.369000f,
+		0.000000f,
+		1.000000f,
+		0.379300f,
+		-0.481775f,
+		-0.133764f,
+		0.000000f,
+		0.000000f,
+		-0.963800f,
+		-0.266600f,
+		0.000000f,
+		1.000000f,
+		0.413800f,
+		-0.472518f,
+		-0.133764f,
+		-0.093989f,
+		0.000000f,
+		-0.945200f,
+		-0.266600f,
+		-0.188000f,
+		0.968800f,
+		0.413800f,
+		-0.464489f,
+		-0.185069f,
+		0.000000f,
+		0.000000f,
+		-0.929400f,
+		-0.369000f,
+		0.000000f,
+		1.000000f,
+		0.379300f,
+		-0.472518f,
+		-0.133764f,
+		-0.093989f,
+		0.000000f,
+		-0.945200f,
+		-0.266600f,
+		-0.188000f,
+		0.968800f,
+		0.413800f,
+		-0.455563f,
+		-0.185069f,
+		-0.090617f,
+		0.000000f,
+		-0.911600f,
+		-0.369000f,
+		-0.181300f,
+		0.968800f,
+		0.379300f,
+		-0.257777f,
+		0.428429f,
+		0.000000f,
+		0.000000f,
+		-0.518000f,
+		0.855300f,
+		0.000000f,
+		1.000000f,
+		0.827600f,
+		-0.209945f,
+		0.453788f,
+		0.000000f,
+		0.000000f,
+		-0.422700f,
+		0.906300f,
+		0.000000f,
+		1.000000f,
+		0.862100f,
+		-0.205911f,
+		0.453788f,
+		-0.040958f,
+		0.000000f,
+		-0.414500f,
+		0.906300f,
+		-0.082400f,
+		0.968800f,
+		0.862100f,
+		-0.257777f,
+		0.428429f,
+		0.000000f,
+		0.000000f,
+		-0.518000f,
+		0.855300f,
+		0.000000f,
+		1.000000f,
+		0.827600f,
+		-0.205911f,
+		0.453788f,
+		-0.040958f,
+		0.000000f,
+		-0.414500f,
+		0.906300f,
+		-0.082400f,
+		0.968800f,
+		0.862100f,
+		-0.252824f,
+		0.428429f,
+		-0.050290f,
+		0.000000f,
+		-0.508100f,
+		0.855300f,
+		-0.101000f,
+		0.968800f,
+		0.827600f,
+		-0.441756f,
+		-0.234204f,
+		0.000000f,
+		0.000000f,
+		-0.884200f,
+		-0.467000f,
+		0.000000f,
+		1.000000f,
+		0.344800f,
+		-0.464489f,
+		-0.185069f,
+		0.000000f,
+		0.000000f,
+		-0.929400f,
+		-0.369000f,
+		0.000000f,
+		1.000000f,
+		0.379300f,
+		-0.455563f,
+		-0.185069f,
+		-0.090617f,
+		0.000000f,
+		-0.911600f,
+		-0.369000f,
+		-0.181300f,
+		0.968800f,
+		0.379300f,
+		-0.441756f,
+		-0.234204f,
+		0.000000f,
+		0.000000f,
+		-0.884200f,
+		-0.467000f,
+		0.000000f,
+		1.000000f,
+		0.344800f,
+		-0.455563f,
+		-0.185069f,
+		-0.090617f,
+		0.000000f,
+		-0.911600f,
+		-0.369000f,
+		-0.181300f,
+		0.968800f,
+		0.379300f,
+		-0.433268f,
+		-0.234204f,
+		-0.086182f,
+		0.000000f,
+		-0.867200f,
+		-0.467000f,
+		-0.172500f,
+		0.968800f,
+		0.344800f,
+		-0.302587f,
+		0.398046f,
+		0.000000f,
+		0.000000f,
+		-0.607300f,
+		0.794500f,
+		0.000000f,
+		1.000000f,
+		0.793100f,
+		-0.257777f,
+		0.428429f,
+		0.000000f,
+		0.000000f,
+		-0.518000f,
+		0.855300f,
+		0.000000f,
+		1.000000f,
+		0.827600f,
+		-0.252824f,
+		0.428429f,
+		-0.050290f,
+		0.000000f,
+		-0.508100f,
+		0.855300f,
+		-0.101000f,
+		0.968800f,
+		0.827600f,
+		-0.302587f,
+		0.398046f,
+		0.000000f,
+		0.000000f,
+		-0.607300f,
+		0.794500f,
+		0.000000f,
+		1.000000f,
+		0.793100f,
+		-0.252824f,
+		0.428429f,
+		-0.050290f,
+		0.000000f,
+		-0.508100f,
+		0.855300f,
+		-0.101000f,
+		0.968800f,
+		0.827600f,
+		-0.296773f,
+		0.398046f,
+		-0.059032f,
+		0.000000f,
+		-0.595600f,
+		0.794500f,
+		-0.118500f,
+		0.968800f,
+		0.793100f,
+		-0.413844f,
+		-0.280594f,
+		0.000000f,
+		0.000000f,
+		-0.828700f,
+		-0.559600f,
+		0.000000f,
+		1.000000f,
+		0.310300f,
+		-0.441756f,
+		-0.234204f,
+		0.000000f,
+		0.000000f,
+		-0.884200f,
+		-0.467000f,
+		0.000000f,
+		1.000000f,
+		0.344800f,
+		-0.433268f,
+		-0.234204f,
+		-0.086182f,
+		0.000000f,
+		-0.867200f,
+		-0.467000f,
+		-0.172500f,
+		0.968800f,
+		0.344800f,
+		-0.413844f,
+		-0.280594f,
+		0.000000f,
+		0.000000f,
+		-0.828700f,
+		-0.559600f,
+		0.000000f,
+		1.000000f,
+		0.310300f,
+		-0.433268f,
+		-0.234204f,
+		-0.086182f,
+		0.000000f,
+		-0.867200f,
+		-0.467000f,
+		-0.172500f,
+		0.968800f,
+		0.344800f,
+		-0.405892f,
+		-0.280594f,
+		-0.080737f,
+		0.000000f,
+		-0.812800f,
+		-0.559600f,
+		-0.161700f,
+		0.968800f,
+		0.310300f,
+		-0.343850f,
+		0.362998f,
+		0.000000f,
+		0.000000f,
+		-0.689400f,
+		0.724300f,
+		0.000000f,
+		1.000000f,
+		0.758600f,
+		-0.302587f,
+		0.398046f,
+		0.000000f,
+		0.000000f,
+		-0.607300f,
+		0.794500f,
+		0.000000f,
+		1.000000f,
+		0.793100f,
+		-0.296773f,
+		0.398046f,
+		-0.059032f,
+		0.000000f,
+		-0.595600f,
+		0.794500f,
+		-0.118500f,
+		0.968800f,
+		0.793100f,
+		-0.343850f,
+		0.362998f,
+		0.000000f,
+		0.000000f,
+		-0.689400f,
+		0.724300f,
+		0.000000f,
+		1.000000f,
+		0.758600f,
+		-0.296773f,
+		0.398046f,
+		-0.059032f,
+		0.000000f,
+		-0.595600f,
+		0.794500f,
+		-0.118500f,
+		0.968800f,
+		0.793100f,
+		-0.337243f,
+		0.362998f,
+		-0.067082f,
+		0.000000f,
+		-0.676200f,
+		0.724300f,
+		-0.134500f,
+		0.968800f,
+		0.758600f,
+		-0.381081f,
+		-0.323693f,
+		0.000000f,
+		0.000000f,
+		-0.763500f,
+		-0.645700f,
+		0.000000f,
+		1.000000f,
+		0.275900f,
+		-0.413844f,
+		-0.280594f,
+		0.000000f,
+		0.000000f,
+		-0.828700f,
+		-0.559600f,
+		0.000000f,
+		1.000000f,
+		0.310300f,
+		-0.405892f,
+		-0.280594f,
+		-0.080737f,
+		0.000000f,
+		-0.812800f,
+		-0.559600f,
+		-0.161700f,
+		0.968800f,
+		0.310300f,
+		-0.381081f,
+		-0.323693f,
+		0.000000f,
+		0.000000f,
+		-0.763500f,
+		-0.645700f,
+		0.000000f,
+		1.000000f,
+		0.275900f,
+		-0.405892f,
+		-0.280594f,
+		-0.080737f,
+		0.000000f,
+		-0.812800f,
+		-0.559600f,
+		-0.161700f,
+		0.968800f,
+		0.310300f,
+		-0.373759f,
+		-0.323693f,
+		-0.074345f,
+		0.000000f,
+		-0.748900f,
+		-0.645700f,
+		-0.149000f,
+		0.968800f,
+		0.275900f,
+		-0.381081f,
+		0.323693f,
+		0.000000f,
+		0.000000f,
+		-0.763500f,
+		0.645700f,
+		0.000000f,
+		1.000000f,
+		0.724100f,
+		-0.343850f,
+		0.362998f,
+		0.000000f,
+		0.000000f,
+		-0.689400f,
+		0.724300f,
+		0.000000f,
+		1.000000f,
+		0.758600f,
+		-0.337243f,
+		0.362998f,
+		-0.067082f,
+		0.000000f,
+		-0.676200f,
+		0.724300f,
+		-0.134500f,
+		0.968800f,
+		0.758600f,
+		-0.381081f,
+		0.323693f,
+		0.000000f,
+		0.000000f,
+		-0.763500f,
+		0.645700f,
+		0.000000f,
+		1.000000f,
+		0.724100f,
+		-0.337243f,
+		0.362998f,
+		-0.067082f,
+		0.000000f,
+		-0.676200f,
+		0.724300f,
+		-0.134500f,
+		0.968800f,
+		0.758600f,
+		-0.373758f,
+		0.323693f,
+		-0.074345f,
+		0.000000f,
+		-0.748900f,
+		0.645700f,
+		-0.149000f,
+		0.968800f,
+		0.724100f,
+		-0.343850f,
+		-0.362998f,
+		0.000000f,
+		0.000000f,
+		-0.689400f,
+		-0.724300f,
+		0.000000f,
+		1.000000f,
+		0.241400f,
+		-0.381081f,
+		-0.323693f,
+		0.000000f,
+		0.000000f,
+		-0.763500f,
+		-0.645700f,
+		0.000000f,
+		1.000000f,
+		0.275900f,
+		-0.373759f,
+		-0.323693f,
+		-0.074345f,
+		0.000000f,
+		-0.748900f,
+		-0.645700f,
+		-0.149000f,
+		0.968800f,
+		0.275900f,
+		-0.343850f,
+		-0.362998f,
+		0.000000f,
+		0.000000f,
+		-0.689400f,
+		-0.724300f,
+		0.000000f,
+		1.000000f,
+		0.241400f,
+		-0.373759f,
+		-0.323693f,
+		-0.074345f,
+		0.000000f,
+		-0.748900f,
+		-0.645700f,
+		-0.149000f,
+		0.968800f,
+		0.275900f,
+		-0.337243f,
+		-0.362998f,
+		-0.067082f,
+		0.000000f,
+		-0.676200f,
+		-0.724300f,
+		-0.134500f,
+		0.968800f,
+		0.241400f,
+		-0.413844f,
+		0.280594f,
+		0.000000f,
+		0.000000f,
+		-0.828700f,
+		0.559600f,
+		0.000000f,
+		1.000000f,
+		0.689700f,
+		-0.381081f,
+		0.323693f,
+		0.000000f,
+		0.000000f,
+		-0.763500f,
+		0.645700f,
+		0.000000f,
+		1.000000f,
+		0.724100f,
+		-0.373758f,
+		0.323693f,
+		-0.074345f,
+		0.000000f,
+		-0.748900f,
+		0.645700f,
+		-0.149000f,
+		0.968800f,
+		0.724100f,
+		-0.413844f,
+		0.280594f,
+		0.000000f,
+		0.000000f,
+		-0.828700f,
+		0.559600f,
+		0.000000f,
+		1.000000f,
+		0.689700f,
+		-0.373758f,
+		0.323693f,
+		-0.074345f,
+		0.000000f,
+		-0.748900f,
+		0.645700f,
+		-0.149000f,
+		0.968800f,
+		0.724100f,
+		-0.405892f,
+		0.280594f,
+		-0.080737f,
+		0.000000f,
+		-0.812800f,
+		0.559600f,
+		-0.161700f,
+		0.968800f,
+		0.689700f,
+		-0.302588f,
+		-0.398046f,
+		0.000000f,
+		0.000000f,
+		-0.607300f,
+		-0.794500f,
+		0.000000f,
+		1.000000f,
+		0.206900f,
+		-0.343850f,
+		-0.362998f,
+		0.000000f,
+		0.000000f,
+		-0.689400f,
+		-0.724300f,
+		0.000000f,
+		1.000000f,
+		0.241400f,
+		-0.337243f,
+		-0.362998f,
+		-0.067082f,
+		0.000000f,
+		-0.676200f,
+		-0.724300f,
+		-0.134500f,
+		0.968800f,
+		0.241400f,
+		-0.302588f,
+		-0.398046f,
+		0.000000f,
+		0.000000f,
+		-0.607300f,
+		-0.794500f,
+		0.000000f,
+		1.000000f,
+		0.206900f,
+		-0.337243f,
+		-0.362998f,
+		-0.067082f,
+		0.000000f,
+		-0.676200f,
+		-0.724300f,
+		-0.134500f,
+		0.968800f,
+		0.241400f,
+		-0.296773f,
+		-0.398046f,
+		-0.059032f,
+		0.000000f,
+		-0.595600f,
+		-0.794500f,
+		-0.118500f,
+		0.968800f,
+		0.206900f,
+		-0.441756f,
+		0.234204f,
+		0.000000f,
+		0.000000f,
+		-0.884200f,
+		0.467000f,
+		0.000000f,
+		1.000000f,
+		0.655200f,
+		-0.413844f,
+		0.280594f,
+		0.000000f,
+		0.000000f,
+		-0.828700f,
+		0.559600f,
+		0.000000f,
+		1.000000f,
+		0.689700f,
+		-0.405892f,
+		0.280594f,
+		-0.080737f,
+		0.000000f,
+		-0.812800f,
+		0.559600f,
+		-0.161700f,
+		0.968800f,
+		0.689700f,
+		-0.441756f,
+		0.234204f,
+		0.000000f,
+		0.000000f,
+		-0.884200f,
+		0.467000f,
+		0.000000f,
+		1.000000f,
+		0.655200f,
+		-0.405892f,
+		0.280594f,
+		-0.080737f,
+		0.000000f,
+		-0.812800f,
+		0.559600f,
+		-0.161700f,
+		0.968800f,
+		0.689700f,
+		-0.433268f,
+		0.234204f,
+		-0.086182f,
+		0.000000f,
+		-0.867200f,
+		0.467000f,
+		-0.172500f,
+		0.968800f,
+		0.655200f,
+		-0.257777f,
+		-0.428429f,
+		0.000000f,
+		0.000000f,
+		-0.518000f,
+		-0.855300f,
+		0.000000f,
+		1.000000f,
+		0.172400f,
+		-0.302588f,
+		-0.398046f,
+		0.000000f,
+		0.000000f,
+		-0.607300f,
+		-0.794500f,
+		0.000000f,
+		1.000000f,
+		0.206900f,
+		-0.296773f,
+		-0.398046f,
+		-0.059032f,
+		0.000000f,
+		-0.595600f,
+		-0.794500f,
+		-0.118500f,
+		0.968800f,
+		0.206900f,
+		-0.257777f,
+		-0.428429f,
+		0.000000f,
+		0.000000f,
+		-0.518000f,
+		-0.855300f,
+		0.000000f,
+		1.000000f,
+		0.172400f,
+		-0.296773f,
+		-0.398046f,
+		-0.059032f,
+		0.000000f,
+		-0.595600f,
+		-0.794500f,
+		-0.118500f,
+		0.968800f,
+		0.206900f,
+		-0.252824f,
+		-0.428429f,
+		-0.050290f,
+		0.000000f,
+		-0.508100f,
+		-0.855300f,
+		-0.101000f,
+		0.968800f,
+		0.172400f,
+		-0.464489f,
+		0.185069f,
+		0.000000f,
+		0.000000f,
+		-0.929400f,
+		0.369000f,
+		0.000000f,
+		1.000000f,
+		0.620700f,
+		-0.441756f,
+		0.234204f,
+		0.000000f,
+		0.000000f,
+		-0.884200f,
+		0.467000f,
+		0.000000f,
+		1.000000f,
+		0.655200f,
+		-0.433268f,
+		0.234204f,
+		-0.086182f,
+		0.000000f,
+		-0.867200f,
+		0.467000f,
+		-0.172500f,
+		0.968800f,
+		0.655200f,
+		-0.464489f,
+		0.185069f,
+		0.000000f,
+		0.000000f,
+		-0.929400f,
+		0.369000f,
+		0.000000f,
+		1.000000f,
+		0.620700f,
+		-0.433268f,
+		0.234204f,
+		-0.086182f,
+		0.000000f,
+		-0.867200f,
+		0.467000f,
+		-0.172500f,
+		0.968800f,
+		0.655200f,
+		-0.455563f,
+		0.185069f,
+		-0.090617f,
+		0.000000f,
+		-0.911600f,
+		0.369000f,
+		-0.181300f,
+		0.968800f,
+		0.620700f,
+		-0.209945f,
+		-0.453788f,
+		0.000000f,
+		0.000000f,
+		-0.422700f,
+		-0.906300f,
+		0.000000f,
+		1.000000f,
+		0.137900f,
+		-0.257777f,
+		-0.428429f,
+		0.000000f,
+		0.000000f,
+		-0.518000f,
+		-0.855300f,
+		0.000000f,
+		1.000000f,
+		0.172400f,
+		-0.252824f,
+		-0.428429f,
+		-0.050290f,
+		0.000000f,
+		-0.508100f,
+		-0.855300f,
+		-0.101000f,
+		0.968800f,
+		0.172400f,
+		-0.209945f,
+		-0.453788f,
+		0.000000f,
+		0.000000f,
+		-0.422700f,
+		-0.906300f,
+		0.000000f,
+		1.000000f,
+		0.137900f,
+		-0.252824f,
+		-0.428429f,
+		-0.050290f,
+		0.000000f,
+		-0.508100f,
+		-0.855300f,
+		-0.101000f,
+		0.968800f,
+		0.172400f,
+		-0.205911f,
+		-0.453788f,
+		-0.040958f,
+		0.000000f,
+		-0.414500f,
+		-0.906300f,
+		-0.082400f,
+		0.968800f,
+		0.137900f,
+		-0.481775f,
+		0.133764f,
+		0.000000f,
+		0.000000f,
+		-0.963800f,
+		0.266600f,
+		0.000000f,
+		1.000000f,
+		0.586200f,
+		-0.464489f,
+		0.185069f,
+		0.000000f,
+		0.000000f,
+		-0.929400f,
+		0.369000f,
+		0.000000f,
+		1.000000f,
+		0.620700f,
+		-0.455563f,
+		0.185069f,
+		-0.090617f,
+		0.000000f,
+		-0.911600f,
+		0.369000f,
+		-0.181300f,
+		0.968800f,
+		0.620700f,
+		-0.481775f,
+		0.133764f,
+		0.000000f,
+		0.000000f,
+		-0.963800f,
+		0.266600f,
+		0.000000f,
+		1.000000f,
+		0.586200f,
+		-0.455563f,
+		0.185069f,
+		-0.090617f,
+		0.000000f,
+		-0.911600f,
+		0.369000f,
+		-0.181300f,
+		0.968800f,
+		0.620700f,
+		-0.472518f,
+		0.133764f,
+		-0.093989f,
+		0.000000f,
+		-0.945200f,
+		0.266600f,
+		-0.188000f,
+		0.968800f,
+		0.586200f,
+		-0.159651f,
+		-0.473826f,
+		0.000000f,
+		0.000000f,
+		-0.322300f,
+		-0.946600f,
+		0.000000f,
+		1.000000f,
+		0.103400f,
+		-0.209945f,
+		-0.453788f,
+		0.000000f,
+		0.000000f,
+		-0.422700f,
+		-0.906300f,
+		0.000000f,
+		1.000000f,
+		0.137900f,
+		-0.205911f,
+		-0.453788f,
+		-0.040958f,
+		0.000000f,
+		-0.414500f,
+		-0.906300f,
+		-0.082400f,
+		0.968800f,
+		0.137900f,
+		-0.159651f,
+		-0.473826f,
+		0.000000f,
+		0.000000f,
+		-0.322300f,
+		-0.946600f,
+		0.000000f,
+		1.000000f,
+		0.103400f,
+		-0.205911f,
+		-0.453788f,
+		-0.040958f,
+		0.000000f,
+		-0.414500f,
+		-0.906300f,
+		-0.082400f,
+		0.968800f,
+		0.137900f,
+		-0.156584f,
+		-0.473826f,
+		-0.031147f,
+		0.000000f,
+		-0.316100f,
+		-0.946600f,
+		-0.062900f,
+		0.968800f,
+		0.103400f,
+		-0.493414f,
+		0.080891f,
+		0.000000f,
+		0.000000f,
+		-0.986900f,
+		0.161200f,
+		0.000000f,
+		1.000000f,
+		0.551700f,
+		-0.481775f,
+		0.133764f,
+		0.000000f,
+		0.000000f,
+		-0.963800f,
+		0.266600f,
+		0.000000f,
+		1.000000f,
+		0.586200f,
+		-0.472518f,
+		0.133764f,
+		-0.093989f,
+		0.000000f,
+		-0.945200f,
+		0.266600f,
+		-0.188000f,
+		0.968800f,
+		0.586200f,
+		-0.493414f,
+		0.080891f,
+		0.000000f,
+		0.000000f,
+		-0.986900f,
+		0.161200f,
+		0.000000f,
+		1.000000f,
+		0.551700f,
+		-0.472518f,
+		0.133764f,
+		-0.093989f,
+		0.000000f,
+		-0.945200f,
+		0.266600f,
+		-0.188000f,
+		0.968800f,
+		0.586200f,
+		-0.483932f,
+		0.080891f,
+		-0.096260f,
+		0.000000f,
+		-0.967900f,
+		0.161200f,
+		-0.192500f,
+		0.968800f,
+		0.551700f,
+		-0.107486f,
+		-0.488310f,
+		0.000000f,
+		0.000000f,
+		-0.218200f,
+		-0.975900f,
+		0.000000f,
+		1.000000f,
+		0.069000f,
+		-0.159651f,
+		-0.473826f,
+		0.000000f,
+		0.000000f,
+		-0.322300f,
+		-0.946600f,
+		0.000000f,
+		1.000000f,
+		0.103400f,
+		-0.156584f,
+		-0.473826f,
+		-0.031147f,
+		0.000000f,
+		-0.316100f,
+		-0.946600f,
+		-0.062900f,
+		0.968800f,
+		0.103400f,
+		-0.107486f,
+		-0.488310f,
+		0.000000f,
+		0.000000f,
+		-0.218200f,
+		-0.975900f,
+		0.000000f,
+		1.000000f,
+		0.069000f,
+		-0.156584f,
+		-0.473826f,
+		-0.031147f,
+		0.000000f,
+		-0.316100f,
+		-0.946600f,
+		-0.062900f,
+		0.968800f,
+		0.103400f,
+		-0.105421f,
+		-0.488310f,
+		-0.020970f,
+		0.000000f,
+		-0.214000f,
+		-0.975900f,
+		-0.042500f,
+		0.968800f,
+		0.069000f,
+		-0.499267f,
+		0.027069f,
+		0.000000f,
+		0.000000f,
+		-0.998500f,
+		0.054000f,
+		0.000000f,
+		1.000000f,
+		0.517200f,
+		-0.493414f,
+		0.080891f,
+		0.000000f,
+		0.000000f,
+		-0.986900f,
+		0.161200f,
+		0.000000f,
+		1.000000f,
+		0.551700f,
+		-0.483932f,
+		0.080891f,
+		-0.096260f,
+		0.000000f,
+		-0.967900f,
+		0.161200f,
+		-0.192500f,
+		0.968800f,
+		0.551700f,
+		-0.499267f,
+		0.027069f,
+		0.000000f,
+		0.000000f,
+		-0.998500f,
+		0.054000f,
+		0.000000f,
+		1.000000f,
+		0.517200f,
+		-0.483932f,
+		0.080891f,
+		-0.096260f,
+		0.000000f,
+		-0.967900f,
+		0.161200f,
+		-0.192500f,
+		0.968800f,
+		0.551700f,
+		-0.489673f,
+		0.027069f,
+		-0.097402f,
+		0.000000f,
+		-0.979300f,
+		0.054000f,
+		-0.194800f,
+		0.968800f,
+		0.517200f,
+		-0.054060f,
+		0.497069f,
+		0.000000f,
+		0.000000f,
+		-0.111500f,
+		0.993700f,
+		0.000000f,
+		0.427200f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.423900f,
+		0.960300f,
+		-0.053021f,
+		0.497069f,
+		-0.010546f,
+		0.000000f,
+		-0.109300f,
+		0.993700f,
+		-0.021700f,
+		0.429000f,
+		0.962300f,
+		-0.054060f,
+		-0.497069f,
+		0.000000f,
+		0.000000f,
+		-0.111500f,
+		-0.993700f,
+		0.000000f,
+		1.000000f,
+		0.034500f,
+		-0.107486f,
+		-0.488310f,
+		0.000000f,
+		0.000000f,
+		-0.218200f,
+		-0.975900f,
+		0.000000f,
+		1.000000f,
+		0.069000f,
+		-0.105421f,
+		-0.488310f,
+		-0.020970f,
+		0.000000f,
+		-0.214000f,
+		-0.975900f,
+		-0.042500f,
+		0.968800f,
+		0.069000f,
+		-0.054060f,
+		-0.497069f,
+		0.000000f,
+		0.000000f,
+		-0.111500f,
+		-0.993700f,
+		0.000000f,
+		1.000000f,
+		0.034500f,
+		-0.105421f,
+		-0.488310f,
+		-0.020970f,
+		0.000000f,
+		-0.214000f,
+		-0.975900f,
+		-0.042500f,
+		0.968800f,
+		0.069000f,
+		-0.053021f,
+		-0.497069f,
+		-0.010546f,
+		0.000000f,
+		-0.109300f,
+		-0.993700f,
+		-0.021700f,
+		0.968800f,
+		0.034500f,
+		-0.499267f,
+		-0.027069f,
+		0.000000f,
+		0.000000f,
+		-0.998500f,
+		-0.054000f,
+		0.000000f,
+		1.000000f,
+		0.482800f,
+		-0.499267f,
+		0.027069f,
+		0.000000f,
+		0.000000f,
+		-0.998500f,
+		0.054000f,
+		0.000000f,
+		1.000000f,
+		0.517200f,
+		-0.489673f,
+		0.027069f,
+		-0.097402f,
+		0.000000f,
+		-0.979300f,
+		0.054000f,
+		-0.194800f,
+		0.968800f,
+		0.517200f,
+		-0.499267f,
+		-0.027069f,
+		0.000000f,
+		0.000000f,
+		-0.998500f,
+		-0.054000f,
+		0.000000f,
+		1.000000f,
+		0.482800f,
+		-0.489673f,
+		0.027069f,
+		-0.097402f,
+		0.000000f,
+		-0.979300f,
+		0.054000f,
+		-0.194800f,
+		0.968800f,
+		0.517200f,
+		-0.489673f,
+		-0.027069f,
+		-0.097402f,
+		0.000000f,
+		-0.979300f,
+		-0.054000f,
+		-0.194800f,
+		0.968800f,
+		0.482800f,
+		-0.107485f,
+		0.488310f,
+		0.000000f,
+		0.000000f,
+		-0.218200f,
+		0.975900f,
+		0.000000f,
+		1.000000f,
+		0.931000f,
+		-0.054060f,
+		0.497069f,
+		0.000000f,
+		0.000000f,
+		-0.111500f,
+		0.993700f,
+		0.000000f,
+		1.000000f,
+		0.965500f,
+		-0.053021f,
+		0.497069f,
+		-0.010546f,
+		0.000000f,
+		-0.109300f,
+		0.993700f,
+		-0.021700f,
+		0.968800f,
+		0.965500f,
+		-0.107485f,
+		0.488310f,
+		0.000000f,
+		0.000000f,
+		-0.218200f,
+		0.975900f,
+		0.000000f,
+		1.000000f,
+		0.931000f,
+		-0.053021f,
+		0.497069f,
+		-0.010546f,
+		0.000000f,
+		-0.109300f,
+		0.993700f,
+		-0.021700f,
+		0.968800f,
+		0.965500f,
+		-0.105420f,
+		0.488310f,
+		-0.020969f,
+		0.000000f,
+		-0.214000f,
+		0.975900f,
+		-0.042500f,
+		0.968800f,
+		0.931000f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.495500f,
+		0.051000f,
+		-0.054060f,
+		-0.497069f,
+		0.000000f,
+		0.000000f,
+		-0.111500f,
+		-0.993700f,
+		0.000000f,
+		0.494200f,
+		0.053800f,
+		-0.053021f,
+		-0.497069f,
+		-0.010546f,
+		0.000000f,
+		-0.109300f,
+		-0.993700f,
+		-0.021700f,
+		0.491600f,
+		0.053800f,
+		-0.489673f,
+		0.027069f,
+		-0.097402f,
+		0.000000f,
+		-0.979300f,
+		0.054000f,
+		-0.194800f,
+		0.968800f,
+		0.517200f,
+		-0.483932f,
+		0.080891f,
+		-0.096260f,
+		0.000000f,
+		-0.967900f,
+		0.161200f,
+		-0.192500f,
+		0.968800f,
+		0.551700f,
+		-0.455855f,
+		0.080891f,
+		-0.188821f,
+		0.000000f,
+		-0.911800f,
+		0.161200f,
+		-0.377700f,
+		0.937500f,
+		0.551700f,
+		-0.489673f,
+		0.027069f,
+		-0.097402f,
+		0.000000f,
+		-0.979300f,
+		0.054000f,
+		-0.194800f,
+		0.968800f,
+		0.517200f,
+		-0.455855f,
+		0.080891f,
+		-0.188821f,
+		0.000000f,
+		-0.911800f,
+		0.161200f,
+		-0.377700f,
+		0.937500f,
+		0.551700f,
+		-0.461262f,
+		0.027069f,
+		-0.191061f,
+		0.000000f,
+		-0.922500f,
+		0.054000f,
+		-0.382100f,
+		0.937500f,
+		0.517200f,
+		-0.053021f,
+		0.497069f,
+		-0.010546f,
+		0.000000f,
+		-0.109300f,
+		0.993700f,
+		-0.021700f,
+		0.429000f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.423900f,
+		0.960300f,
+		-0.049945f,
+		0.497069f,
+		-0.020688f,
+		0.000000f,
+		-0.103000f,
+		0.993700f,
+		-0.042600f,
+		0.430800f,
+		0.962300f,
+		-0.053021f,
+		-0.497069f,
+		-0.010546f,
+		0.000000f,
+		-0.109300f,
+		-0.993700f,
+		-0.021700f,
+		0.968800f,
+		0.034500f,
+		-0.105421f,
+		-0.488310f,
+		-0.020970f,
+		0.000000f,
+		-0.214000f,
+		-0.975900f,
+		-0.042500f,
+		0.968800f,
+		0.069000f,
+		-0.099304f,
+		-0.488310f,
+		-0.041133f,
+		0.000000f,
+		-0.201600f,
+		-0.975900f,
+		-0.083500f,
+		0.937500f,
+		0.069000f,
+		-0.053021f,
+		-0.497069f,
+		-0.010546f,
+		0.000000f,
+		-0.109300f,
+		-0.993700f,
+		-0.021700f,
+		0.968800f,
+		0.034500f,
+		-0.099304f,
+		-0.488310f,
+		-0.041133f,
+		0.000000f,
+		-0.201600f,
+		-0.975900f,
+		-0.083500f,
+		0.937500f,
+		0.069000f,
+		-0.049945f,
+		-0.497069f,
+		-0.020688f,
+		0.000000f,
+		-0.103000f,
+		-0.993700f,
+		-0.042600f,
+		0.937500f,
+		0.034500f,
+		-0.489673f,
+		-0.027069f,
+		-0.097402f,
+		0.000000f,
+		-0.979300f,
+		-0.054000f,
+		-0.194800f,
+		0.968800f,
+		0.482800f,
+		-0.489673f,
+		0.027069f,
+		-0.097402f,
+		0.000000f,
+		-0.979300f,
+		0.054000f,
+		-0.194800f,
+		0.968800f,
+		0.517200f,
+		-0.461262f,
+		0.027069f,
+		-0.191061f,
+		0.000000f,
+		-0.922500f,
+		0.054000f,
+		-0.382100f,
+		0.937500f,
+		0.517200f,
+		-0.489673f,
+		-0.027069f,
+		-0.097402f,
+		0.000000f,
+		-0.979300f,
+		-0.054000f,
+		-0.194800f,
+		0.968800f,
+		0.482800f,
+		-0.461262f,
+		0.027069f,
+		-0.191061f,
+		0.000000f,
+		-0.922500f,
+		0.054000f,
+		-0.382100f,
+		0.937500f,
+		0.517200f,
+		-0.461262f,
+		-0.027069f,
+		-0.191061f,
+		0.000000f,
+		-0.922500f,
+		-0.054000f,
+		-0.382100f,
+		0.937500f,
+		0.482800f,
+		-0.105420f,
+		0.488310f,
+		-0.020969f,
+		0.000000f,
+		-0.214000f,
+		0.975900f,
+		-0.042500f,
+		0.968800f,
+		0.931000f,
+		-0.053021f,
+		0.497069f,
+		-0.010546f,
+		0.000000f,
+		-0.109300f,
+		0.993700f,
+		-0.021700f,
+		0.968800f,
+		0.965500f,
+		-0.049945f,
+		0.497069f,
+		-0.020688f,
+		0.000000f,
+		-0.103000f,
+		0.993700f,
+		-0.042600f,
+		0.937500f,
+		0.965500f,
+		-0.105420f,
+		0.488310f,
+		-0.020969f,
+		0.000000f,
+		-0.214000f,
+		0.975900f,
+		-0.042500f,
+		0.968800f,
+		0.931000f,
+		-0.049945f,
+		0.497069f,
+		-0.020688f,
+		0.000000f,
+		-0.103000f,
+		0.993700f,
+		-0.042600f,
+		0.937500f,
+		0.965500f,
+		-0.099303f,
+		0.488310f,
+		-0.041132f,
+		0.000000f,
+		-0.201600f,
+		0.975900f,
+		-0.083500f,
+		0.937500f,
+		0.931000f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.495500f,
+		0.051000f,
+		-0.053021f,
+		-0.497069f,
+		-0.010546f,
+		0.000000f,
+		-0.109300f,
+		-0.993700f,
+		-0.021700f,
+		0.491600f,
+		0.053800f,
+		-0.049945f,
+		-0.497069f,
+		-0.020688f,
+		0.000000f,
+		-0.103000f,
+		-0.993700f,
+		-0.042600f,
+		0.489000f,
+		0.053800f,
+		-0.483932f,
+		-0.080891f,
+		-0.096260f,
+		0.000000f,
+		-0.967900f,
+		-0.161200f,
+		-0.192500f,
+		0.968800f,
+		0.448300f,
+		-0.489673f,
+		-0.027069f,
+		-0.097402f,
+		0.000000f,
+		-0.979300f,
+		-0.054000f,
+		-0.194800f,
+		0.968800f,
+		0.482800f,
+		-0.461262f,
+		-0.027069f,
+		-0.191061f,
+		0.000000f,
+		-0.922500f,
+		-0.054000f,
+		-0.382100f,
+		0.937500f,
+		0.482800f,
+		-0.483932f,
+		-0.080891f,
+		-0.096260f,
+		0.000000f,
+		-0.967900f,
+		-0.161200f,
+		-0.192500f,
+		0.968800f,
+		0.448300f,
+		-0.461262f,
+		-0.027069f,
+		-0.191061f,
+		0.000000f,
+		-0.922500f,
+		-0.054000f,
+		-0.382100f,
+		0.937500f,
+		0.482800f,
+		-0.455855f,
+		-0.080891f,
+		-0.188821f,
+		0.000000f,
+		-0.911800f,
+		-0.161200f,
+		-0.377700f,
+		0.937500f,
+		0.448300f,
+		-0.156583f,
+		0.473826f,
+		-0.031146f,
+		0.000000f,
+		-0.316100f,
+		0.946600f,
+		-0.062900f,
+		0.968800f,
+		0.896600f,
+		-0.105420f,
+		0.488310f,
+		-0.020969f,
+		0.000000f,
+		-0.214000f,
+		0.975900f,
+		-0.042500f,
+		0.968800f,
+		0.931000f,
+		-0.099303f,
+		0.488310f,
+		-0.041132f,
+		0.000000f,
+		-0.201600f,
+		0.975900f,
+		-0.083500f,
+		0.937500f,
+		0.931000f,
+		-0.156583f,
+		0.473826f,
+		-0.031146f,
+		0.000000f,
+		-0.316100f,
+		0.946600f,
+		-0.062900f,
+		0.968800f,
+		0.896600f,
+		-0.099303f,
+		0.488310f,
+		-0.041132f,
+		0.000000f,
+		-0.201600f,
+		0.975900f,
+		-0.083500f,
+		0.937500f,
+		0.931000f,
+		-0.147498f,
+		0.473826f,
+		-0.061095f,
+		0.000000f,
+		-0.297800f,
+		0.946600f,
+		-0.123300f,
+		0.937500f,
+		0.896600f,
+		-0.472518f,
+		-0.133764f,
+		-0.093989f,
+		0.000000f,
+		-0.945200f,
+		-0.266600f,
+		-0.188000f,
+		0.968800f,
+		0.413800f,
+		-0.483932f,
+		-0.080891f,
+		-0.096260f,
+		0.000000f,
+		-0.967900f,
+		-0.161200f,
+		-0.192500f,
+		0.968800f,
+		0.448300f,
+		-0.455855f,
+		-0.080891f,
+		-0.188821f,
+		0.000000f,
+		-0.911800f,
+		-0.161200f,
+		-0.377700f,
+		0.937500f,
+		0.448300f,
+		-0.472518f,
+		-0.133764f,
+		-0.093989f,
+		0.000000f,
+		-0.945200f,
+		-0.266600f,
+		-0.188000f,
+		0.968800f,
+		0.413800f,
+		-0.455855f,
+		-0.080891f,
+		-0.188821f,
+		0.000000f,
+		-0.911800f,
+		-0.161200f,
+		-0.377700f,
+		0.937500f,
+		0.448300f,
+		-0.445102f,
+		-0.133764f,
+		-0.184367f,
+		0.000000f,
+		-0.890400f,
+		-0.266600f,
+		-0.368800f,
+		0.937500f,
+		0.413800f,
+		-0.205911f,
+		0.453788f,
+		-0.040958f,
+		0.000000f,
+		-0.414500f,
+		0.906300f,
+		-0.082400f,
+		0.968800f,
+		0.862100f,
+		-0.156583f,
+		0.473826f,
+		-0.031146f,
+		0.000000f,
+		-0.316100f,
+		0.946600f,
+		-0.062900f,
+		0.968800f,
+		0.896600f,
+		-0.147498f,
+		0.473826f,
+		-0.061095f,
+		0.000000f,
+		-0.297800f,
+		0.946600f,
+		-0.123300f,
+		0.937500f,
+		0.896600f,
+		-0.205911f,
+		0.453788f,
+		-0.040958f,
+		0.000000f,
+		-0.414500f,
+		0.906300f,
+		-0.082400f,
+		0.968800f,
+		0.862100f,
+		-0.147498f,
+		0.473826f,
+		-0.061095f,
+		0.000000f,
+		-0.297800f,
+		0.946600f,
+		-0.123300f,
+		0.937500f,
+		0.896600f,
+		-0.193963f,
+		0.453788f,
+		-0.080342f,
+		0.000000f,
+		-0.390500f,
+		0.906300f,
+		-0.161700f,
+		0.937500f,
+		0.862100f,
+		-0.455563f,
+		-0.185069f,
+		-0.090617f,
+		0.000000f,
+		-0.911600f,
+		-0.369000f,
+		-0.181300f,
+		0.968800f,
+		0.379300f,
+		-0.472518f,
+		-0.133764f,
+		-0.093989f,
+		0.000000f,
+		-0.945200f,
+		-0.266600f,
+		-0.188000f,
+		0.968800f,
+		0.413800f,
+		-0.445102f,
+		-0.133764f,
+		-0.184367f,
+		0.000000f,
+		-0.890400f,
+		-0.266600f,
+		-0.368800f,
+		0.937500f,
+		0.413800f,
+		-0.455563f,
+		-0.185069f,
+		-0.090617f,
+		0.000000f,
+		-0.911600f,
+		-0.369000f,
+		-0.181300f,
+		0.968800f,
+		0.379300f,
+		-0.445102f,
+		-0.133764f,
+		-0.184367f,
+		0.000000f,
+		-0.890400f,
+		-0.266600f,
+		-0.368800f,
+		0.937500f,
+		0.413800f,
+		-0.429132f,
+		-0.185069f,
+		-0.177752f,
+		0.000000f,
+		-0.858700f,
+		-0.369000f,
+		-0.355700f,
+		0.937500f,
+		0.379300f,
+		-0.252824f,
+		0.428429f,
+		-0.050290f,
+		0.000000f,
+		-0.508100f,
+		0.855300f,
+		-0.101000f,
+		0.968800f,
+		0.827600f,
+		-0.205911f,
+		0.453788f,
+		-0.040958f,
+		0.000000f,
+		-0.414500f,
+		0.906300f,
+		-0.082400f,
+		0.968800f,
+		0.862100f,
+		-0.193963f,
+		0.453788f,
+		-0.080342f,
+		0.000000f,
+		-0.390500f,
+		0.906300f,
+		-0.161700f,
+		0.937500f,
+		0.862100f,
+		-0.252824f,
+		0.428429f,
+		-0.050290f,
+		0.000000f,
+		-0.508100f,
+		0.855300f,
+		-0.101000f,
+		0.968800f,
+		0.827600f,
+		-0.193963f,
+		0.453788f,
+		-0.080342f,
+		0.000000f,
+		-0.390500f,
+		0.906300f,
+		-0.161700f,
+		0.937500f,
+		0.862100f,
+		-0.238155f,
+		0.428429f,
+		-0.098647f,
+		0.000000f,
+		-0.478600f,
+		0.855300f,
+		-0.198200f,
+		0.937500f,
+		0.827600f,
+		-0.433268f,
+		-0.234204f,
+		-0.086182f,
+		0.000000f,
+		-0.867200f,
+		-0.467000f,
+		-0.172500f,
+		0.968800f,
+		0.344800f,
+		-0.455563f,
+		-0.185069f,
+		-0.090617f,
+		0.000000f,
+		-0.911600f,
+		-0.369000f,
+		-0.181300f,
+		0.968800f,
+		0.379300f,
+		-0.429132f,
+		-0.185069f,
+		-0.177752f,
+		0.000000f,
+		-0.858700f,
+		-0.369000f,
+		-0.355700f,
+		0.937500f,
+		0.379300f,
+		-0.433268f,
+		-0.234204f,
+		-0.086182f,
+		0.000000f,
+		-0.867200f,
+		-0.467000f,
+		-0.172500f,
+		0.968800f,
+		0.344800f,
+		-0.429132f,
+		-0.185069f,
+		-0.177752f,
+		0.000000f,
+		-0.858700f,
+		-0.369000f,
+		-0.355700f,
+		0.937500f,
+		0.379300f,
+		-0.408130f,
+		-0.234204f,
+		-0.169052f,
+		0.000000f,
+		-0.816900f,
+		-0.467000f,
+		-0.338400f,
+		0.937500f,
+		0.344800f,
+		-0.296773f,
+		0.398046f,
+		-0.059032f,
+		0.000000f,
+		-0.595600f,
+		0.794500f,
+		-0.118500f,
+		0.968800f,
+		0.793100f,
+		-0.252824f,
+		0.428429f,
+		-0.050290f,
+		0.000000f,
+		-0.508100f,
+		0.855300f,
+		-0.101000f,
+		0.968800f,
+		0.827600f,
+		-0.238155f,
+		0.428429f,
+		-0.098647f,
+		0.000000f,
+		-0.478600f,
+		0.855300f,
+		-0.198200f,
+		0.937500f,
+		0.827600f,
+		-0.296773f,
+		0.398046f,
+		-0.059032f,
+		0.000000f,
+		-0.595600f,
+		0.794500f,
+		-0.118500f,
+		0.968800f,
+		0.793100f,
+		-0.238155f,
+		0.428429f,
+		-0.098647f,
+		0.000000f,
+		-0.478600f,
+		0.855300f,
+		-0.198200f,
+		0.937500f,
+		0.827600f,
+		-0.279554f,
+		0.398046f,
+		-0.115795f,
+		0.000000f,
+		-0.561100f,
+		0.794500f,
+		-0.232400f,
+		0.937500f,
+		0.793100f,
+		-0.405892f,
+		-0.280594f,
+		-0.080737f,
+		0.000000f,
+		-0.812800f,
+		-0.559600f,
+		-0.161700f,
+		0.968800f,
+		0.310300f,
+		-0.433268f,
+		-0.234204f,
+		-0.086182f,
+		0.000000f,
+		-0.867200f,
+		-0.467000f,
+		-0.172500f,
+		0.968800f,
+		0.344800f,
+		-0.408130f,
+		-0.234204f,
+		-0.169052f,
+		0.000000f,
+		-0.816900f,
+		-0.467000f,
+		-0.338400f,
+		0.937500f,
+		0.344800f,
+		-0.405892f,
+		-0.280594f,
+		-0.080737f,
+		0.000000f,
+		-0.812800f,
+		-0.559600f,
+		-0.161700f,
+		0.968800f,
+		0.310300f,
+		-0.408130f,
+		-0.234204f,
+		-0.169052f,
+		0.000000f,
+		-0.816900f,
+		-0.467000f,
+		-0.338400f,
+		0.937500f,
+		0.344800f,
+		-0.382342f,
+		-0.280594f,
+		-0.158371f,
+		0.000000f,
+		-0.765600f,
+		-0.559600f,
+		-0.317100f,
+		0.937500f,
+		0.310300f,
+		-0.337243f,
+		0.362998f,
+		-0.067082f,
+		0.000000f,
+		-0.676200f,
+		0.724300f,
+		-0.134500f,
+		0.968800f,
+		0.758600f,
+		-0.296773f,
+		0.398046f,
+		-0.059032f,
+		0.000000f,
+		-0.595600f,
+		0.794500f,
+		-0.118500f,
+		0.968800f,
+		0.793100f,
+		-0.279554f,
+		0.398046f,
+		-0.115795f,
+		0.000000f,
+		-0.561100f,
+		0.794500f,
+		-0.232400f,
+		0.937500f,
+		0.793100f,
+		-0.337243f,
+		0.362998f,
+		-0.067082f,
+		0.000000f,
+		-0.676200f,
+		0.724300f,
+		-0.134500f,
+		0.968800f,
+		0.758600f,
+		-0.279554f,
+		0.398046f,
+		-0.115795f,
+		0.000000f,
+		-0.561100f,
+		0.794500f,
+		-0.232400f,
+		0.937500f,
+		0.793100f,
+		-0.317676f,
+		0.362998f,
+		-0.131585f,
+		0.000000f,
+		-0.637000f,
+		0.724300f,
+		-0.263800f,
+		0.937500f,
+		0.758600f,
+		-0.373759f,
+		-0.323693f,
+		-0.074345f,
+		0.000000f,
+		-0.748900f,
+		-0.645700f,
+		-0.149000f,
+		0.968800f,
+		0.275900f,
+		-0.405892f,
+		-0.280594f,
+		-0.080737f,
+		0.000000f,
+		-0.812800f,
+		-0.559600f,
+		-0.161700f,
+		0.968800f,
+		0.310300f,
+		-0.382342f,
+		-0.280594f,
+		-0.158371f,
+		0.000000f,
+		-0.765600f,
+		-0.559600f,
+		-0.317100f,
+		0.937500f,
+		0.310300f,
+		-0.373759f,
+		-0.323693f,
+		-0.074345f,
+		0.000000f,
+		-0.748900f,
+		-0.645700f,
+		-0.149000f,
+		0.968800f,
+		0.275900f,
+		-0.382342f,
+		-0.280594f,
+		-0.158371f,
+		0.000000f,
+		-0.765600f,
+		-0.559600f,
+		-0.317100f,
+		0.937500f,
+		0.310300f,
+		-0.352073f,
+		-0.323693f,
+		-0.145834f,
+		0.000000f,
+		-0.705400f,
+		-0.645700f,
+		-0.292200f,
+		0.937500f,
+		0.275900f,
+		-0.373758f,
+		0.323693f,
+		-0.074345f,
+		0.000000f,
+		-0.748900f,
+		0.645700f,
+		-0.149000f,
+		0.968800f,
+		0.724100f,
+		-0.337243f,
+		0.362998f,
+		-0.067082f,
+		0.000000f,
+		-0.676200f,
+		0.724300f,
+		-0.134500f,
+		0.968800f,
+		0.758600f,
+		-0.317676f,
+		0.362998f,
+		-0.131585f,
+		0.000000f,
+		-0.637000f,
+		0.724300f,
+		-0.263800f,
+		0.937500f,
+		0.758600f,
+		-0.373758f,
+		0.323693f,
+		-0.074345f,
+		0.000000f,
+		-0.748900f,
+		0.645700f,
+		-0.149000f,
+		0.968800f,
+		0.724100f,
+		-0.317676f,
+		0.362998f,
+		-0.131585f,
+		0.000000f,
+		-0.637000f,
+		0.724300f,
+		-0.263800f,
+		0.937500f,
+		0.758600f,
+		-0.352073f,
+		0.323693f,
+		-0.145833f,
+		0.000000f,
+		-0.705400f,
+		0.645700f,
+		-0.292200f,
+		0.937500f,
+		0.724100f,
+		-0.337243f,
+		-0.362998f,
+		-0.067082f,
+		0.000000f,
+		-0.676200f,
+		-0.724300f,
+		-0.134500f,
+		0.968800f,
+		0.241400f,
+		-0.373759f,
+		-0.323693f,
+		-0.074345f,
+		0.000000f,
+		-0.748900f,
+		-0.645700f,
+		-0.149000f,
+		0.968800f,
+		0.275900f,
+		-0.352073f,
+		-0.323693f,
+		-0.145834f,
+		0.000000f,
+		-0.705400f,
+		-0.645700f,
+		-0.292200f,
+		0.937500f,
+		0.275900f,
+		-0.337243f,
+		-0.362998f,
+		-0.067082f,
+		0.000000f,
+		-0.676200f,
+		-0.724300f,
+		-0.134500f,
+		0.968800f,
+		0.241400f,
+		-0.352073f,
+		-0.323693f,
+		-0.145834f,
+		0.000000f,
+		-0.705400f,
+		-0.645700f,
+		-0.292200f,
+		0.937500f,
+		0.275900f,
+		-0.317676f,
+		-0.362998f,
+		-0.131585f,
+		0.000000f,
+		-0.637000f,
+		-0.724300f,
+		-0.263800f,
+		0.937500f,
+		0.241400f,
+		-0.405892f,
+		0.280594f,
+		-0.080737f,
+		0.000000f,
+		-0.812800f,
+		0.559600f,
+		-0.161700f,
+		0.968800f,
+		0.689700f,
+		-0.373758f,
+		0.323693f,
+		-0.074345f,
+		0.000000f,
+		-0.748900f,
+		0.645700f,
+		-0.149000f,
+		0.968800f,
+		0.724100f,
+		-0.352073f,
+		0.323693f,
+		-0.145833f,
+		0.000000f,
+		-0.705400f,
+		0.645700f,
+		-0.292200f,
+		0.937500f,
+		0.724100f,
+		-0.405892f,
+		0.280594f,
+		-0.080737f,
+		0.000000f,
+		-0.812800f,
+		0.559600f,
+		-0.161700f,
+		0.968800f,
+		0.689700f,
+		-0.352073f,
+		0.323693f,
+		-0.145833f,
+		0.000000f,
+		-0.705400f,
+		0.645700f,
+		-0.292200f,
+		0.937500f,
+		0.724100f,
+		-0.382342f,
+		0.280594f,
+		-0.158371f,
+		0.000000f,
+		-0.765600f,
+		0.559600f,
+		-0.317100f,
+		0.937500f,
+		0.689700f,
+		-0.296773f,
+		-0.398046f,
+		-0.059032f,
+		0.000000f,
+		-0.595600f,
+		-0.794500f,
+		-0.118500f,
+		0.968800f,
+		0.206900f,
+		-0.337243f,
+		-0.362998f,
+		-0.067082f,
+		0.000000f,
+		-0.676200f,
+		-0.724300f,
+		-0.134500f,
+		0.968800f,
+		0.241400f,
+		-0.317676f,
+		-0.362998f,
+		-0.131585f,
+		0.000000f,
+		-0.637000f,
+		-0.724300f,
+		-0.263800f,
+		0.937500f,
+		0.241400f,
+		-0.296773f,
+		-0.398046f,
+		-0.059032f,
+		0.000000f,
+		-0.595600f,
+		-0.794500f,
+		-0.118500f,
+		0.968800f,
+		0.206900f,
+		-0.317676f,
+		-0.362998f,
+		-0.131585f,
+		0.000000f,
+		-0.637000f,
+		-0.724300f,
+		-0.263800f,
+		0.937500f,
+		0.241400f,
+		-0.279554f,
+		-0.398046f,
+		-0.115795f,
+		0.000000f,
+		-0.561100f,
+		-0.794500f,
+		-0.232400f,
+		0.937500f,
+		0.206900f,
+		-0.433268f,
+		0.234204f,
+		-0.086182f,
+		0.000000f,
+		-0.867200f,
+		0.467000f,
+		-0.172500f,
+		0.968800f,
+		0.655200f,
+		-0.405892f,
+		0.280594f,
+		-0.080737f,
+		0.000000f,
+		-0.812800f,
+		0.559600f,
+		-0.161700f,
+		0.968800f,
+		0.689700f,
+		-0.382342f,
+		0.280594f,
+		-0.158371f,
+		0.000000f,
+		-0.765600f,
+		0.559600f,
+		-0.317100f,
+		0.937500f,
+		0.689700f,
+		-0.433268f,
+		0.234204f,
+		-0.086182f,
+		0.000000f,
+		-0.867200f,
+		0.467000f,
+		-0.172500f,
+		0.968800f,
+		0.655200f,
+		-0.382342f,
+		0.280594f,
+		-0.158371f,
+		0.000000f,
+		-0.765600f,
+		0.559600f,
+		-0.317100f,
+		0.937500f,
+		0.689700f,
+		-0.408130f,
+		0.234204f,
+		-0.169052f,
+		0.000000f,
+		-0.816900f,
+		0.467000f,
+		-0.338400f,
+		0.937500f,
+		0.655200f,
+		-0.252824f,
+		-0.428429f,
+		-0.050290f,
+		0.000000f,
+		-0.508100f,
+		-0.855300f,
+		-0.101000f,
+		0.968800f,
+		0.172400f,
+		-0.296773f,
+		-0.398046f,
+		-0.059032f,
+		0.000000f,
+		-0.595600f,
+		-0.794500f,
+		-0.118500f,
+		0.968800f,
+		0.206900f,
+		-0.279554f,
+		-0.398046f,
+		-0.115795f,
+		0.000000f,
+		-0.561100f,
+		-0.794500f,
+		-0.232400f,
+		0.937500f,
+		0.206900f,
+		-0.252824f,
+		-0.428429f,
+		-0.050290f,
+		0.000000f,
+		-0.508100f,
+		-0.855300f,
+		-0.101000f,
+		0.968800f,
+		0.172400f,
+		-0.279554f,
+		-0.398046f,
+		-0.115795f,
+		0.000000f,
+		-0.561100f,
+		-0.794500f,
+		-0.232400f,
+		0.937500f,
+		0.206900f,
+		-0.238155f,
+		-0.428429f,
+		-0.098647f,
+		0.000000f,
+		-0.478600f,
+		-0.855300f,
+		-0.198200f,
+		0.937500f,
+		0.172400f,
+		-0.455563f,
+		0.185069f,
+		-0.090617f,
+		0.000000f,
+		-0.911600f,
+		0.369000f,
+		-0.181300f,
+		0.968800f,
+		0.620700f,
+		-0.433268f,
+		0.234204f,
+		-0.086182f,
+		0.000000f,
+		-0.867200f,
+		0.467000f,
+		-0.172500f,
+		0.968800f,
+		0.655200f,
+		-0.408130f,
+		0.234204f,
+		-0.169052f,
+		0.000000f,
+		-0.816900f,
+		0.467000f,
+		-0.338400f,
+		0.937500f,
+		0.655200f,
+		-0.455563f,
+		0.185069f,
+		-0.090617f,
+		0.000000f,
+		-0.911600f,
+		0.369000f,
+		-0.181300f,
+		0.968800f,
+		0.620700f,
+		-0.408130f,
+		0.234204f,
+		-0.169052f,
+		0.000000f,
+		-0.816900f,
+		0.467000f,
+		-0.338400f,
+		0.937500f,
+		0.655200f,
+		-0.429132f,
+		0.185069f,
+		-0.177752f,
+		0.000000f,
+		-0.858700f,
+		0.369000f,
+		-0.355700f,
+		0.937500f,
+		0.620700f,
+		-0.205911f,
+		-0.453788f,
+		-0.040958f,
+		0.000000f,
+		-0.414500f,
+		-0.906300f,
+		-0.082400f,
+		0.968800f,
+		0.137900f,
+		-0.252824f,
+		-0.428429f,
+		-0.050290f,
+		0.000000f,
+		-0.508100f,
+		-0.855300f,
+		-0.101000f,
+		0.968800f,
+		0.172400f,
+		-0.238155f,
+		-0.428429f,
+		-0.098647f,
+		0.000000f,
+		-0.478600f,
+		-0.855300f,
+		-0.198200f,
+		0.937500f,
+		0.172400f,
+		-0.205911f,
+		-0.453788f,
+		-0.040958f,
+		0.000000f,
+		-0.414500f,
+		-0.906300f,
+		-0.082400f,
+		0.968800f,
+		0.137900f,
+		-0.238155f,
+		-0.428429f,
+		-0.098647f,
+		0.000000f,
+		-0.478600f,
+		-0.855300f,
+		-0.198200f,
+		0.937500f,
+		0.172400f,
+		-0.193964f,
+		-0.453788f,
+		-0.080342f,
+		0.000000f,
+		-0.390500f,
+		-0.906300f,
+		-0.161700f,
+		0.937500f,
+		0.137900f,
+		-0.472518f,
+		0.133764f,
+		-0.093989f,
+		0.000000f,
+		-0.945200f,
+		0.266600f,
+		-0.188000f,
+		0.968800f,
+		0.586200f,
+		-0.455563f,
+		0.185069f,
+		-0.090617f,
+		0.000000f,
+		-0.911600f,
+		0.369000f,
+		-0.181300f,
+		0.968800f,
+		0.620700f,
+		-0.429132f,
+		0.185069f,
+		-0.177752f,
+		0.000000f,
+		-0.858700f,
+		0.369000f,
+		-0.355700f,
+		0.937500f,
+		0.620700f,
+		-0.472518f,
+		0.133764f,
+		-0.093989f,
+		0.000000f,
+		-0.945200f,
+		0.266600f,
+		-0.188000f,
+		0.968800f,
+		0.586200f,
+		-0.429132f,
+		0.185069f,
+		-0.177752f,
+		0.000000f,
+		-0.858700f,
+		0.369000f,
+		-0.355700f,
+		0.937500f,
+		0.620700f,
+		-0.445102f,
+		0.133764f,
+		-0.184367f,
+		0.000000f,
+		-0.890400f,
+		0.266600f,
+		-0.368800f,
+		0.937500f,
+		0.586200f,
+		-0.156584f,
+		-0.473826f,
+		-0.031147f,
+		0.000000f,
+		-0.316100f,
+		-0.946600f,
+		-0.062900f,
+		0.968800f,
+		0.103400f,
+		-0.205911f,
+		-0.453788f,
+		-0.040958f,
+		0.000000f,
+		-0.414500f,
+		-0.906300f,
+		-0.082400f,
+		0.968800f,
+		0.137900f,
+		-0.193964f,
+		-0.453788f,
+		-0.080342f,
+		0.000000f,
+		-0.390500f,
+		-0.906300f,
+		-0.161700f,
+		0.937500f,
+		0.137900f,
+		-0.156584f,
+		-0.473826f,
+		-0.031147f,
+		0.000000f,
+		-0.316100f,
+		-0.946600f,
+		-0.062900f,
+		0.968800f,
+		0.103400f,
+		-0.193964f,
+		-0.453788f,
+		-0.080342f,
+		0.000000f,
+		-0.390500f,
+		-0.906300f,
+		-0.161700f,
+		0.937500f,
+		0.137900f,
+		-0.147499f,
+		-0.473826f,
+		-0.061095f,
+		0.000000f,
+		-0.297800f,
+		-0.946600f,
+		-0.123300f,
+		0.937500f,
+		0.103400f,
+		-0.483932f,
+		0.080891f,
+		-0.096260f,
+		0.000000f,
+		-0.967900f,
+		0.161200f,
+		-0.192500f,
+		0.968800f,
+		0.551700f,
+		-0.472518f,
+		0.133764f,
+		-0.093989f,
+		0.000000f,
+		-0.945200f,
+		0.266600f,
+		-0.188000f,
+		0.968800f,
+		0.586200f,
+		-0.445102f,
+		0.133764f,
+		-0.184367f,
+		0.000000f,
+		-0.890400f,
+		0.266600f,
+		-0.368800f,
+		0.937500f,
+		0.586200f,
+		-0.483932f,
+		0.080891f,
+		-0.096260f,
+		0.000000f,
+		-0.967900f,
+		0.161200f,
+		-0.192500f,
+		0.968800f,
+		0.551700f,
+		-0.445102f,
+		0.133764f,
+		-0.184367f,
+		0.000000f,
+		-0.890400f,
+		0.266600f,
+		-0.368800f,
+		0.937500f,
+		0.586200f,
+		-0.455855f,
+		0.080891f,
+		-0.188821f,
+		0.000000f,
+		-0.911800f,
+		0.161200f,
+		-0.377700f,
+		0.937500f,
+		0.551700f,
+		-0.105421f,
+		-0.488310f,
+		-0.020970f,
+		0.000000f,
+		-0.214000f,
+		-0.975900f,
+		-0.042500f,
+		0.968800f,
+		0.069000f,
+		-0.156584f,
+		-0.473826f,
+		-0.031147f,
+		0.000000f,
+		-0.316100f,
+		-0.946600f,
+		-0.062900f,
+		0.968800f,
+		0.103400f,
+		-0.147499f,
+		-0.473826f,
+		-0.061095f,
+		0.000000f,
+		-0.297800f,
+		-0.946600f,
+		-0.123300f,
+		0.937500f,
+		0.103400f,
+		-0.105421f,
+		-0.488310f,
+		-0.020970f,
+		0.000000f,
+		-0.214000f,
+		-0.975900f,
+		-0.042500f,
+		0.968800f,
+		0.069000f,
+		-0.147499f,
+		-0.473826f,
+		-0.061095f,
+		0.000000f,
+		-0.297800f,
+		-0.946600f,
+		-0.123300f,
+		0.937500f,
+		0.103400f,
+		-0.099304f,
+		-0.488310f,
+		-0.041133f,
+		0.000000f,
+		-0.201600f,
+		-0.975900f,
+		-0.083500f,
+		0.937500f,
+		0.069000f,
+		-0.317676f,
+		-0.362998f,
+		-0.131585f,
+		0.000000f,
+		-0.637000f,
+		-0.724300f,
+		-0.263800f,
+		0.937500f,
+		0.241400f,
+		-0.352073f,
+		-0.323693f,
+		-0.145834f,
+		0.000000f,
+		-0.705400f,
+		-0.645700f,
+		-0.292200f,
+		0.937500f,
+		0.275900f,
+		-0.316857f,
+		-0.323693f,
+		-0.211717f,
+		0.000000f,
+		-0.634900f,
+		-0.645700f,
+		-0.424200f,
+		0.906300f,
+		0.275900f,
+		-0.317676f,
+		-0.362998f,
+		-0.131585f,
+		0.000000f,
+		-0.637000f,
+		-0.724300f,
+		-0.263800f,
+		0.937500f,
+		0.241400f,
+		-0.316857f,
+		-0.323693f,
+		-0.211717f,
+		0.000000f,
+		-0.634900f,
+		-0.645700f,
+		-0.424200f,
+		0.906300f,
+		0.275900f,
+		-0.285901f,
+		-0.362998f,
+		-0.191032f,
+		0.000000f,
+		-0.573300f,
+		-0.724300f,
+		-0.383000f,
+		0.906300f,
+		0.241400f,
+		-0.382342f,
+		0.280594f,
+		-0.158371f,
+		0.000000f,
+		-0.765600f,
+		0.559600f,
+		-0.317100f,
+		0.937500f,
+		0.689700f,
+		-0.352073f,
+		0.323693f,
+		-0.145833f,
+		0.000000f,
+		-0.705400f,
+		0.645700f,
+		-0.292200f,
+		0.937500f,
+		0.724100f,
+		-0.316857f,
+		0.323693f,
+		-0.211717f,
+		0.000000f,
+		-0.634900f,
+		0.645700f,
+		-0.424200f,
+		0.906300f,
+		0.724100f,
+		-0.382342f,
+		0.280594f,
+		-0.158371f,
+		0.000000f,
+		-0.765600f,
+		0.559600f,
+		-0.317100f,
+		0.937500f,
+		0.689700f,
+		-0.316857f,
+		0.323693f,
+		-0.211717f,
+		0.000000f,
+		-0.634900f,
+		0.645700f,
+		-0.424200f,
+		0.906300f,
+		0.724100f,
+		-0.344099f,
+		0.280594f,
+		-0.229919f,
+		0.000000f,
+		-0.689100f,
+		0.559600f,
+		-0.460400f,
+		0.906300f,
+		0.689700f,
+		-0.279554f,
+		-0.398046f,
+		-0.115795f,
+		0.000000f,
+		-0.561100f,
+		-0.794500f,
+		-0.232400f,
+		0.937500f,
+		0.206900f,
+		-0.317676f,
+		-0.362998f,
+		-0.131585f,
+		0.000000f,
+		-0.637000f,
+		-0.724300f,
+		-0.263800f,
+		0.937500f,
+		0.241400f,
+		-0.285901f,
+		-0.362998f,
+		-0.191032f,
+		0.000000f,
+		-0.573300f,
+		-0.724300f,
+		-0.383000f,
+		0.906300f,
+		0.241400f,
+		-0.279554f,
+		-0.398046f,
+		-0.115795f,
+		0.000000f,
+		-0.561100f,
+		-0.794500f,
+		-0.232400f,
+		0.937500f,
+		0.206900f,
+		-0.285901f,
+		-0.362998f,
+		-0.191032f,
+		0.000000f,
+		-0.573300f,
+		-0.724300f,
+		-0.383000f,
+		0.906300f,
+		0.241400f,
+		-0.251592f,
+		-0.398046f,
+		-0.168108f,
+		0.000000f,
+		-0.505000f,
+		-0.794500f,
+		-0.337400f,
+		0.906300f,
+		0.206900f,
+		-0.408130f,
+		0.234204f,
+		-0.169052f,
+		0.000000f,
+		-0.816900f,
+		0.467000f,
+		-0.338400f,
+		0.937500f,
+		0.655200f,
+		-0.382342f,
+		0.280594f,
+		-0.158371f,
+		0.000000f,
+		-0.765600f,
+		0.559600f,
+		-0.317100f,
+		0.937500f,
+		0.689700f,
+		-0.344099f,
+		0.280594f,
+		-0.229919f,
+		0.000000f,
+		-0.689100f,
+		0.559600f,
+		-0.460400f,
+		0.906300f,
+		0.689700f,
+		-0.408130f,
+		0.234204f,
+		-0.169052f,
+		0.000000f,
+		-0.816900f,
+		0.467000f,
+		-0.338400f,
+		0.937500f,
+		0.655200f,
+		-0.344099f,
+		0.280594f,
+		-0.229919f,
+		0.000000f,
+		-0.689100f,
+		0.559600f,
+		-0.460400f,
+		0.906300f,
+		0.689700f,
+		-0.367307f,
+		0.234204f,
+		-0.245426f,
+		0.000000f,
+		-0.735200f,
+		0.467000f,
+		-0.491300f,
+		0.906300f,
+		0.655200f,
+		-0.238155f,
+		-0.428429f,
+		-0.098647f,
+		0.000000f,
+		-0.478600f,
+		-0.855300f,
+		-0.198200f,
+		0.937500f,
+		0.172400f,
+		-0.279554f,
+		-0.398046f,
+		-0.115795f,
+		0.000000f,
+		-0.561100f,
+		-0.794500f,
+		-0.232400f,
+		0.937500f,
+		0.206900f,
+		-0.251592f,
+		-0.398046f,
+		-0.168108f,
+		0.000000f,
+		-0.505000f,
+		-0.794500f,
+		-0.337400f,
+		0.906300f,
+		0.206900f,
+		-0.238155f,
+		-0.428429f,
+		-0.098647f,
+		0.000000f,
+		-0.478600f,
+		-0.855300f,
+		-0.198200f,
+		0.937500f,
+		0.172400f,
+		-0.251592f,
+		-0.398046f,
+		-0.168108f,
+		0.000000f,
+		-0.505000f,
+		-0.794500f,
+		-0.337400f,
+		0.906300f,
+		0.206900f,
+		-0.214334f,
+		-0.428429f,
+		-0.143213f,
+		0.000000f,
+		-0.430700f,
+		-0.855300f,
+		-0.287800f,
+		0.906300f,
+		0.172400f,
+		-0.429132f,
+		0.185069f,
+		-0.177752f,
+		0.000000f,
+		-0.858700f,
+		0.369000f,
+		-0.355700f,
+		0.937500f,
+		0.620700f,
+		-0.408130f,
+		0.234204f,
+		-0.169052f,
+		0.000000f,
+		-0.816900f,
+		0.467000f,
+		-0.338400f,
+		0.937500f,
+		0.655200f,
+		-0.367307f,
+		0.234204f,
+		-0.245426f,
+		0.000000f,
+		-0.735200f,
+		0.467000f,
+		-0.491300f,
+		0.906300f,
+		0.655200f,
+		-0.429132f,
+		0.185069f,
+		-0.177752f,
+		0.000000f,
+		-0.858700f,
+		0.369000f,
+		-0.355700f,
+		0.937500f,
+		0.620700f,
+		-0.367307f,
+		0.234204f,
+		-0.245426f,
+		0.000000f,
+		-0.735200f,
+		0.467000f,
+		-0.491300f,
+		0.906300f,
+		0.655200f,
+		-0.386208f,
+		0.185069f,
+		-0.258056f,
+		0.000000f,
+		-0.772800f,
+		0.369000f,
+		-0.516300f,
+		0.906200f,
+		0.620700f,
+		-0.193964f,
+		-0.453788f,
+		-0.080342f,
+		0.000000f,
+		-0.390500f,
+		-0.906300f,
+		-0.161700f,
+		0.937500f,
+		0.137900f,
+		-0.238155f,
+		-0.428429f,
+		-0.098647f,
+		0.000000f,
+		-0.478600f,
+		-0.855300f,
+		-0.198200f,
+		0.937500f,
+		0.172400f,
+		-0.214334f,
+		-0.428429f,
+		-0.143213f,
+		0.000000f,
+		-0.430700f,
+		-0.855300f,
+		-0.287800f,
+		0.906300f,
+		0.172400f,
+		-0.193964f,
+		-0.453788f,
+		-0.080342f,
+		0.000000f,
+		-0.390500f,
+		-0.906300f,
+		-0.161700f,
+		0.937500f,
+		0.137900f,
+		-0.214334f,
+		-0.428429f,
+		-0.143213f,
+		0.000000f,
+		-0.430700f,
+		-0.855300f,
+		-0.287800f,
+		0.906300f,
+		0.172400f,
+		-0.174563f,
+		-0.453788f,
+		-0.116639f,
+		0.000000f,
+		-0.351400f,
+		-0.906300f,
+		-0.234800f,
+		0.906300f,
+		0.137900f,
+		-0.445102f,
+		0.133764f,
+		-0.184367f,
+		0.000000f,
+		-0.890400f,
+		0.266600f,
+		-0.368800f,
+		0.937500f,
+		0.586200f,
+		-0.429132f,
+		0.185069f,
+		-0.177752f,
+		0.000000f,
+		-0.858700f,
+		0.369000f,
+		-0.355700f,
+		0.937500f,
+		0.620700f,
+		-0.386208f,
+		0.185069f,
+		-0.258056f,
+		0.000000f,
+		-0.772800f,
+		0.369000f,
+		-0.516300f,
+		0.906200f,
+		0.620700f,
+		-0.445102f,
+		0.133764f,
+		-0.184367f,
+		0.000000f,
+		-0.890400f,
+		0.266600f,
+		-0.368800f,
+		0.937500f,
+		0.586200f,
+		-0.386208f,
+		0.185069f,
+		-0.258056f,
+		0.000000f,
+		-0.772800f,
+		0.369000f,
+		-0.516300f,
+		0.906200f,
+		0.620700f,
+		-0.400582f,
+		0.133764f,
+		-0.267659f,
+		0.000000f,
+		-0.801400f,
+		0.266600f,
+		-0.535400f,
+		0.906300f,
+		0.586200f,
+		-0.147499f,
+		-0.473826f,
+		-0.061095f,
+		0.000000f,
+		-0.297800f,
+		-0.946600f,
+		-0.123300f,
+		0.937500f,
+		0.103400f,
+		-0.193964f,
+		-0.453788f,
+		-0.080342f,
+		0.000000f,
+		-0.390500f,
+		-0.906300f,
+		-0.161700f,
+		0.937500f,
+		0.137900f,
+		-0.174563f,
+		-0.453788f,
+		-0.116639f,
+		0.000000f,
+		-0.351400f,
+		-0.906300f,
+		-0.234800f,
+		0.906300f,
+		0.137900f,
+		-0.147499f,
+		-0.473826f,
+		-0.061095f,
+		0.000000f,
+		-0.297800f,
+		-0.946600f,
+		-0.123300f,
+		0.937500f,
+		0.103400f,
+		-0.174563f,
+		-0.453788f,
+		-0.116639f,
+		0.000000f,
+		-0.351400f,
+		-0.906300f,
+		-0.234800f,
+		0.906300f,
+		0.137900f,
+		-0.132745f,
+		-0.473826f,
+		-0.088697f,
+		0.000000f,
+		-0.268000f,
+		-0.946600f,
+		-0.179100f,
+		0.906300f,
+		0.103400f,
+		-0.455855f,
+		0.080891f,
+		-0.188821f,
+		0.000000f,
+		-0.911800f,
+		0.161200f,
+		-0.377700f,
+		0.937500f,
+		0.551700f,
+		-0.445102f,
+		0.133764f,
+		-0.184367f,
+		0.000000f,
+		-0.890400f,
+		0.266600f,
+		-0.368800f,
+		0.937500f,
+		0.586200f,
+		-0.400582f,
+		0.133764f,
+		-0.267659f,
+		0.000000f,
+		-0.801400f,
+		0.266600f,
+		-0.535400f,
+		0.906300f,
+		0.586200f,
+		-0.455855f,
+		0.080891f,
+		-0.188821f,
+		0.000000f,
+		-0.911800f,
+		0.161200f,
+		-0.377700f,
+		0.937500f,
+		0.551700f,
+		-0.400582f,
+		0.133764f,
+		-0.267659f,
+		0.000000f,
+		-0.801400f,
+		0.266600f,
+		-0.535400f,
+		0.906300f,
+		0.586200f,
+		-0.410258f,
+		0.080891f,
+		-0.274125f,
+		0.000000f,
+		-0.820600f,
+		0.161200f,
+		-0.548300f,
+		0.906300f,
+		0.551700f,
+		-0.099304f,
+		-0.488310f,
+		-0.041133f,
+		0.000000f,
+		-0.201600f,
+		-0.975900f,
+		-0.083500f,
+		0.937500f,
+		0.069000f,
+		-0.147499f,
+		-0.473826f,
+		-0.061095f,
+		0.000000f,
+		-0.297800f,
+		-0.946600f,
+		-0.123300f,
+		0.937500f,
+		0.103400f,
+		-0.132745f,
+		-0.473826f,
+		-0.088697f,
+		0.000000f,
+		-0.268000f,
+		-0.946600f,
+		-0.179100f,
+		0.906300f,
+		0.103400f,
+		-0.099304f,
+		-0.488310f,
+		-0.041133f,
+		0.000000f,
+		-0.201600f,
+		-0.975900f,
+		-0.083500f,
+		0.937500f,
+		0.069000f,
+		-0.132745f,
+		-0.473826f,
+		-0.088697f,
+		0.000000f,
+		-0.268000f,
+		-0.946600f,
+		-0.179100f,
+		0.906300f,
+		0.103400f,
+		-0.089371f,
+		-0.488310f,
+		-0.059715f,
+		0.000000f,
+		-0.181400f,
+		-0.975900f,
+		-0.121200f,
+		0.906300f,
+		0.069000f,
+		-0.461262f,
+		0.027069f,
+		-0.191061f,
+		0.000000f,
+		-0.922500f,
+		0.054000f,
+		-0.382100f,
+		0.937500f,
+		0.517200f,
+		-0.455855f,
+		0.080891f,
+		-0.188821f,
+		0.000000f,
+		-0.911800f,
+		0.161200f,
+		-0.377700f,
+		0.937500f,
+		0.551700f,
+		-0.410258f,
+		0.080891f,
+		-0.274125f,
+		0.000000f,
+		-0.820600f,
+		0.161200f,
+		-0.548300f,
+		0.906300f,
+		0.551700f,
+		-0.461262f,
+		0.027069f,
+		-0.191061f,
+		0.000000f,
+		-0.922500f,
+		0.054000f,
+		-0.382100f,
+		0.937500f,
+		0.517200f,
+		-0.410258f,
+		0.080891f,
+		-0.274125f,
+		0.000000f,
+		-0.820600f,
+		0.161200f,
+		-0.548300f,
+		0.906300f,
+		0.551700f,
+		-0.415125f,
+		0.027069f,
+		-0.277377f,
+		0.000000f,
+		-0.830300f,
+		0.054000f,
+		-0.554700f,
+		0.906300f,
+		0.517200f,
+		-0.049945f,
+		0.497069f,
+		-0.020688f,
+		0.000000f,
+		-0.103000f,
+		0.993700f,
+		-0.042600f,
+		0.430800f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.423900f,
+		0.960300f,
+		-0.044949f,
+		0.497069f,
+		-0.030034f,
+		0.000000f,
+		-0.092700f,
+		0.993700f,
+		-0.061900f,
+		0.432600f,
+		0.962300f,
+		-0.049945f,
+		-0.497069f,
+		-0.020688f,
+		0.000000f,
+		-0.103000f,
+		-0.993700f,
+		-0.042600f,
+		0.937500f,
+		0.034500f,
+		-0.099304f,
+		-0.488310f,
+		-0.041133f,
+		0.000000f,
+		-0.201600f,
+		-0.975900f,
+		-0.083500f,
+		0.937500f,
+		0.069000f,
+		-0.089371f,
+		-0.488310f,
+		-0.059715f,
+		0.000000f,
+		-0.181400f,
+		-0.975900f,
+		-0.121200f,
+		0.906300f,
+		0.069000f,
+		-0.049945f,
+		-0.497069f,
+		-0.020688f,
+		0.000000f,
+		-0.103000f,
+		-0.993700f,
+		-0.042600f,
+		0.937500f,
+		0.034500f,
+		-0.089371f,
+		-0.488310f,
+		-0.059715f,
+		0.000000f,
+		-0.181400f,
+		-0.975900f,
+		-0.121200f,
+		0.906300f,
+		0.069000f,
+		-0.044949f,
+		-0.497069f,
+		-0.030034f,
+		0.000000f,
+		-0.092700f,
+		-0.993700f,
+		-0.061900f,
+		0.906300f,
+		0.034500f,
+		-0.461262f,
+		-0.027069f,
+		-0.191061f,
+		0.000000f,
+		-0.922500f,
+		-0.054000f,
+		-0.382100f,
+		0.937500f,
+		0.482800f,
+		-0.461262f,
+		0.027069f,
+		-0.191061f,
+		0.000000f,
+		-0.922500f,
+		0.054000f,
+		-0.382100f,
+		0.937500f,
+		0.517200f,
+		-0.415125f,
+		0.027069f,
+		-0.277377f,
+		0.000000f,
+		-0.830300f,
+		0.054000f,
+		-0.554700f,
+		0.906300f,
+		0.517200f,
+		-0.461262f,
+		-0.027069f,
+		-0.191061f,
+		0.000000f,
+		-0.922500f,
+		-0.054000f,
+		-0.382100f,
+		0.937500f,
+		0.482800f,
+		-0.415125f,
+		0.027069f,
+		-0.277377f,
+		0.000000f,
+		-0.830300f,
+		0.054000f,
+		-0.554700f,
+		0.906300f,
+		0.517200f,
+		-0.415125f,
+		-0.027069f,
+		-0.277377f,
+		0.000000f,
+		-0.830300f,
+		-0.054000f,
+		-0.554700f,
+		0.906300f,
+		0.482800f,
+		-0.099303f,
+		0.488310f,
+		-0.041132f,
+		0.000000f,
+		-0.201600f,
+		0.975900f,
+		-0.083500f,
+		0.937500f,
+		0.931000f,
+		-0.049945f,
+		0.497069f,
+		-0.020688f,
+		0.000000f,
+		-0.103000f,
+		0.993700f,
+		-0.042600f,
+		0.937500f,
+		0.965500f,
+		-0.044949f,
+		0.497069f,
+		-0.030034f,
+		0.000000f,
+		-0.092700f,
+		0.993700f,
+		-0.061900f,
+		0.906300f,
+		0.965500f,
+		-0.099303f,
+		0.488310f,
+		-0.041132f,
+		0.000000f,
+		-0.201600f,
+		0.975900f,
+		-0.083500f,
+		0.937500f,
+		0.931000f,
+		-0.044949f,
+		0.497069f,
+		-0.030034f,
+		0.000000f,
+		-0.092700f,
+		0.993700f,
+		-0.061900f,
+		0.906300f,
+		0.965500f,
+		-0.089371f,
+		0.488310f,
+		-0.059715f,
+		0.000000f,
+		-0.181400f,
+		0.975900f,
+		-0.121200f,
+		0.906300f,
+		0.931000f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.495500f,
+		0.051000f,
+		-0.049945f,
+		-0.497069f,
+		-0.020688f,
+		0.000000f,
+		-0.103000f,
+		-0.993700f,
+		-0.042600f,
+		0.489000f,
+		0.053800f,
+		-0.044949f,
+		-0.497069f,
+		-0.030034f,
+		0.000000f,
+		-0.092700f,
+		-0.993700f,
+		-0.061900f,
+		0.486400f,
+		0.053800f,
+		-0.455855f,
+		-0.080891f,
+		-0.188821f,
+		0.000000f,
+		-0.911800f,
+		-0.161200f,
+		-0.377700f,
+		0.937500f,
+		0.448300f,
+		-0.461262f,
+		-0.027069f,
+		-0.191061f,
+		0.000000f,
+		-0.922500f,
+		-0.054000f,
+		-0.382100f,
+		0.937500f,
+		0.482800f,
+		-0.415125f,
+		-0.027069f,
+		-0.277377f,
+		0.000000f,
+		-0.830300f,
+		-0.054000f,
+		-0.554700f,
+		0.906300f,
+		0.482800f,
+		-0.455855f,
+		-0.080891f,
+		-0.188821f,
+		0.000000f,
+		-0.911800f,
+		-0.161200f,
+		-0.377700f,
+		0.937500f,
+		0.448300f,
+		-0.415125f,
+		-0.027069f,
+		-0.277377f,
+		0.000000f,
+		-0.830300f,
+		-0.054000f,
+		-0.554700f,
+		0.906300f,
+		0.482800f,
+		-0.410258f,
+		-0.080891f,
+		-0.274125f,
+		0.000000f,
+		-0.820600f,
+		-0.161200f,
+		-0.548300f,
+		0.906300f,
+		0.448300f,
+		-0.147498f,
+		0.473826f,
+		-0.061095f,
+		0.000000f,
+		-0.297800f,
+		0.946600f,
+		-0.123300f,
+		0.937500f,
+		0.896600f,
+		-0.099303f,
+		0.488310f,
+		-0.041132f,
+		0.000000f,
+		-0.201600f,
+		0.975900f,
+		-0.083500f,
+		0.937500f,
+		0.931000f,
+		-0.089371f,
+		0.488310f,
+		-0.059715f,
+		0.000000f,
+		-0.181400f,
+		0.975900f,
+		-0.121200f,
+		0.906300f,
+		0.931000f,
+		-0.147498f,
+		0.473826f,
+		-0.061095f,
+		0.000000f,
+		-0.297800f,
+		0.946600f,
+		-0.123300f,
+		0.937500f,
+		0.896600f,
+		-0.089371f,
+		0.488310f,
+		-0.059715f,
+		0.000000f,
+		-0.181400f,
+		0.975900f,
+		-0.121200f,
+		0.906300f,
+		0.931000f,
+		-0.132745f,
+		0.473826f,
+		-0.088697f,
+		0.000000f,
+		-0.268000f,
+		0.946600f,
+		-0.179100f,
+		0.906300f,
+		0.896600f,
+		-0.445102f,
+		-0.133764f,
+		-0.184367f,
+		0.000000f,
+		-0.890400f,
+		-0.266600f,
+		-0.368800f,
+		0.937500f,
+		0.413800f,
+		-0.455855f,
+		-0.080891f,
+		-0.188821f,
+		0.000000f,
+		-0.911800f,
+		-0.161200f,
+		-0.377700f,
+		0.937500f,
+		0.448300f,
+		-0.410258f,
+		-0.080891f,
+		-0.274125f,
+		0.000000f,
+		-0.820600f,
+		-0.161200f,
+		-0.548300f,
+		0.906300f,
+		0.448300f,
+		-0.445102f,
+		-0.133764f,
+		-0.184367f,
+		0.000000f,
+		-0.890400f,
+		-0.266600f,
+		-0.368800f,
+		0.937500f,
+		0.413800f,
+		-0.410258f,
+		-0.080891f,
+		-0.274125f,
+		0.000000f,
+		-0.820600f,
+		-0.161200f,
+		-0.548300f,
+		0.906300f,
+		0.448300f,
+		-0.400582f,
+		-0.133764f,
+		-0.267659f,
+		0.000000f,
+		-0.801400f,
+		-0.266600f,
+		-0.535400f,
+		0.906300f,
+		0.413800f,
+		-0.193963f,
+		0.453788f,
+		-0.080342f,
+		0.000000f,
+		-0.390500f,
+		0.906300f,
+		-0.161700f,
+		0.937500f,
+		0.862100f,
+		-0.147498f,
+		0.473826f,
+		-0.061095f,
+		0.000000f,
+		-0.297800f,
+		0.946600f,
+		-0.123300f,
+		0.937500f,
+		0.896600f,
+		-0.132745f,
+		0.473826f,
+		-0.088697f,
+		0.000000f,
+		-0.268000f,
+		0.946600f,
+		-0.179100f,
+		0.906300f,
+		0.896600f,
+		-0.193963f,
+		0.453788f,
+		-0.080342f,
+		0.000000f,
+		-0.390500f,
+		0.906300f,
+		-0.161700f,
+		0.937500f,
+		0.862100f,
+		-0.132745f,
+		0.473826f,
+		-0.088697f,
+		0.000000f,
+		-0.268000f,
+		0.946600f,
+		-0.179100f,
+		0.906300f,
+		0.896600f,
+		-0.174562f,
+		0.453788f,
+		-0.116638f,
+		0.000000f,
+		-0.351400f,
+		0.906300f,
+		-0.234800f,
+		0.906300f,
+		0.862100f,
+		-0.429132f,
+		-0.185069f,
+		-0.177752f,
+		0.000000f,
+		-0.858700f,
+		-0.369000f,
+		-0.355700f,
+		0.937500f,
+		0.379300f,
+		-0.445102f,
+		-0.133764f,
+		-0.184367f,
+		0.000000f,
+		-0.890400f,
+		-0.266600f,
+		-0.368800f,
+		0.937500f,
+		0.413800f,
+		-0.400582f,
+		-0.133764f,
+		-0.267659f,
+		0.000000f,
+		-0.801400f,
+		-0.266600f,
+		-0.535400f,
+		0.906300f,
+		0.413800f,
+		-0.429132f,
+		-0.185069f,
+		-0.177752f,
+		0.000000f,
+		-0.858700f,
+		-0.369000f,
+		-0.355700f,
+		0.937500f,
+		0.379300f,
+		-0.400582f,
+		-0.133764f,
+		-0.267659f,
+		0.000000f,
+		-0.801400f,
+		-0.266600f,
+		-0.535400f,
+		0.906300f,
+		0.413800f,
+		-0.386208f,
+		-0.185069f,
+		-0.258056f,
+		0.000000f,
+		-0.772800f,
+		-0.369000f,
+		-0.516300f,
+		0.906300f,
+		0.379300f,
+		-0.238155f,
+		0.428429f,
+		-0.098647f,
+		0.000000f,
+		-0.478600f,
+		0.855300f,
+		-0.198200f,
+		0.937500f,
+		0.827600f,
+		-0.193963f,
+		0.453788f,
+		-0.080342f,
+		0.000000f,
+		-0.390500f,
+		0.906300f,
+		-0.161700f,
+		0.937500f,
+		0.862100f,
+		-0.174562f,
+		0.453788f,
+		-0.116638f,
+		0.000000f,
+		-0.351400f,
+		0.906300f,
+		-0.234800f,
+		0.906300f,
+		0.862100f,
+		-0.238155f,
+		0.428429f,
+		-0.098647f,
+		0.000000f,
+		-0.478600f,
+		0.855300f,
+		-0.198200f,
+		0.937500f,
+		0.827600f,
+		-0.174562f,
+		0.453788f,
+		-0.116638f,
+		0.000000f,
+		-0.351400f,
+		0.906300f,
+		-0.234800f,
+		0.906300f,
+		0.862100f,
+		-0.214334f,
+		0.428429f,
+		-0.143213f,
+		0.000000f,
+		-0.430700f,
+		0.855300f,
+		-0.287800f,
+		0.906300f,
+		0.827600f,
+		-0.408130f,
+		-0.234204f,
+		-0.169052f,
+		0.000000f,
+		-0.816900f,
+		-0.467000f,
+		-0.338400f,
+		0.937500f,
+		0.344800f,
+		-0.429132f,
+		-0.185069f,
+		-0.177752f,
+		0.000000f,
+		-0.858700f,
+		-0.369000f,
+		-0.355700f,
+		0.937500f,
+		0.379300f,
+		-0.386208f,
+		-0.185069f,
+		-0.258056f,
+		0.000000f,
+		-0.772800f,
+		-0.369000f,
+		-0.516300f,
+		0.906300f,
+		0.379300f,
+		-0.408130f,
+		-0.234204f,
+		-0.169052f,
+		0.000000f,
+		-0.816900f,
+		-0.467000f,
+		-0.338400f,
+		0.937500f,
+		0.344800f,
+		-0.386208f,
+		-0.185069f,
+		-0.258056f,
+		0.000000f,
+		-0.772800f,
+		-0.369000f,
+		-0.516300f,
+		0.906300f,
+		0.379300f,
+		-0.367307f,
+		-0.234204f,
+		-0.245427f,
+		0.000000f,
+		-0.735200f,
+		-0.467000f,
+		-0.491300f,
+		0.906300f,
+		0.344800f,
+		-0.279554f,
+		0.398046f,
+		-0.115795f,
+		0.000000f,
+		-0.561100f,
+		0.794500f,
+		-0.232400f,
+		0.937500f,
+		0.793100f,
+		-0.238155f,
+		0.428429f,
+		-0.098647f,
+		0.000000f,
+		-0.478600f,
+		0.855300f,
+		-0.198200f,
+		0.937500f,
+		0.827600f,
+		-0.214334f,
+		0.428429f,
+		-0.143213f,
+		0.000000f,
+		-0.430700f,
+		0.855300f,
+		-0.287800f,
+		0.906300f,
+		0.827600f,
+		-0.279554f,
+		0.398046f,
+		-0.115795f,
+		0.000000f,
+		-0.561100f,
+		0.794500f,
+		-0.232400f,
+		0.937500f,
+		0.793100f,
+		-0.214334f,
+		0.428429f,
+		-0.143213f,
+		0.000000f,
+		-0.430700f,
+		0.855300f,
+		-0.287800f,
+		0.906300f,
+		0.827600f,
+		-0.251592f,
+		0.398046f,
+		-0.168108f,
+		0.000000f,
+		-0.504900f,
+		0.794500f,
+		-0.337400f,
+		0.906300f,
+		0.793100f,
+		-0.382342f,
+		-0.280594f,
+		-0.158371f,
+		0.000000f,
+		-0.765600f,
+		-0.559600f,
+		-0.317100f,
+		0.937500f,
+		0.310300f,
+		-0.408130f,
+		-0.234204f,
+		-0.169052f,
+		0.000000f,
+		-0.816900f,
+		-0.467000f,
+		-0.338400f,
+		0.937500f,
+		0.344800f,
+		-0.367307f,
+		-0.234204f,
+		-0.245427f,
+		0.000000f,
+		-0.735200f,
+		-0.467000f,
+		-0.491300f,
+		0.906300f,
+		0.344800f,
+		-0.382342f,
+		-0.280594f,
+		-0.158371f,
+		0.000000f,
+		-0.765600f,
+		-0.559600f,
+		-0.317100f,
+		0.937500f,
+		0.310300f,
+		-0.367307f,
+		-0.234204f,
+		-0.245427f,
+		0.000000f,
+		-0.735200f,
+		-0.467000f,
+		-0.491300f,
+		0.906300f,
+		0.344800f,
+		-0.344099f,
+		-0.280594f,
+		-0.229919f,
+		0.000000f,
+		-0.689100f,
+		-0.559600f,
+		-0.460400f,
+		0.906300f,
+		0.310300f,
+		-0.317676f,
+		0.362998f,
+		-0.131585f,
+		0.000000f,
+		-0.637000f,
+		0.724300f,
+		-0.263800f,
+		0.937500f,
+		0.758600f,
+		-0.279554f,
+		0.398046f,
+		-0.115795f,
+		0.000000f,
+		-0.561100f,
+		0.794500f,
+		-0.232400f,
+		0.937500f,
+		0.793100f,
+		-0.251592f,
+		0.398046f,
+		-0.168108f,
+		0.000000f,
+		-0.504900f,
+		0.794500f,
+		-0.337400f,
+		0.906300f,
+		0.793100f,
+		-0.317676f,
+		0.362998f,
+		-0.131585f,
+		0.000000f,
+		-0.637000f,
+		0.724300f,
+		-0.263800f,
+		0.937500f,
+		0.758600f,
+		-0.251592f,
+		0.398046f,
+		-0.168108f,
+		0.000000f,
+		-0.504900f,
+		0.794500f,
+		-0.337400f,
+		0.906300f,
+		0.793100f,
+		-0.285901f,
+		0.362998f,
+		-0.191032f,
+		0.000000f,
+		-0.573300f,
+		0.724300f,
+		-0.383000f,
+		0.906300f,
+		0.758600f,
+		-0.352073f,
+		-0.323693f,
+		-0.145834f,
+		0.000000f,
+		-0.705400f,
+		-0.645700f,
+		-0.292200f,
+		0.937500f,
+		0.275900f,
+		-0.382342f,
+		-0.280594f,
+		-0.158371f,
+		0.000000f,
+		-0.765600f,
+		-0.559600f,
+		-0.317100f,
+		0.937500f,
+		0.310300f,
+		-0.344099f,
+		-0.280594f,
+		-0.229919f,
+		0.000000f,
+		-0.689100f,
+		-0.559600f,
+		-0.460400f,
+		0.906300f,
+		0.310300f,
+		-0.352073f,
+		-0.323693f,
+		-0.145834f,
+		0.000000f,
+		-0.705400f,
+		-0.645700f,
+		-0.292200f,
+		0.937500f,
+		0.275900f,
+		-0.344099f,
+		-0.280594f,
+		-0.229919f,
+		0.000000f,
+		-0.689100f,
+		-0.559600f,
+		-0.460400f,
+		0.906300f,
+		0.310300f,
+		-0.316857f,
+		-0.323693f,
+		-0.211717f,
+		0.000000f,
+		-0.634900f,
+		-0.645700f,
+		-0.424200f,
+		0.906300f,
+		0.275900f,
+		-0.352073f,
+		0.323693f,
+		-0.145833f,
+		0.000000f,
+		-0.705400f,
+		0.645700f,
+		-0.292200f,
+		0.937500f,
+		0.724100f,
+		-0.317676f,
+		0.362998f,
+		-0.131585f,
+		0.000000f,
+		-0.637000f,
+		0.724300f,
+		-0.263800f,
+		0.937500f,
+		0.758600f,
+		-0.285901f,
+		0.362998f,
+		-0.191032f,
+		0.000000f,
+		-0.573300f,
+		0.724300f,
+		-0.383000f,
+		0.906300f,
+		0.758600f,
+		-0.352073f,
+		0.323693f,
+		-0.145833f,
+		0.000000f,
+		-0.705400f,
+		0.645700f,
+		-0.292200f,
+		0.937500f,
+		0.724100f,
+		-0.285901f,
+		0.362998f,
+		-0.191032f,
+		0.000000f,
+		-0.573300f,
+		0.724300f,
+		-0.383000f,
+		0.906300f,
+		0.758600f,
+		-0.316857f,
+		0.323693f,
+		-0.211717f,
+		0.000000f,
+		-0.634900f,
+		0.645700f,
+		-0.424200f,
+		0.906300f,
+		0.724100f,
+		-0.132745f,
+		0.473826f,
+		-0.088697f,
+		0.000000f,
+		-0.268000f,
+		0.946600f,
+		-0.179100f,
+		0.906300f,
+		0.896600f,
+		-0.089371f,
+		0.488310f,
+		-0.059715f,
+		0.000000f,
+		-0.181400f,
+		0.975900f,
+		-0.121200f,
+		0.906300f,
+		0.931000f,
+		-0.076003f,
+		0.488310f,
+		-0.076003f,
+		0.000000f,
+		-0.154300f,
+		0.975900f,
+		-0.154300f,
+		0.875000f,
+		0.931000f,
+		-0.132745f,
+		0.473826f,
+		-0.088697f,
+		0.000000f,
+		-0.268000f,
+		0.946600f,
+		-0.179100f,
+		0.906300f,
+		0.896600f,
+		-0.076003f,
+		0.488310f,
+		-0.076003f,
+		0.000000f,
+		-0.154300f,
+		0.975900f,
+		-0.154300f,
+		0.875000f,
+		0.931000f,
+		-0.112890f,
+		0.473826f,
+		-0.112890f,
+		0.000000f,
+		-0.227900f,
+		0.946600f,
+		-0.227900f,
+		0.875000f,
+		0.896600f,
+		-0.400582f,
+		-0.133764f,
+		-0.267659f,
+		0.000000f,
+		-0.801400f,
+		-0.266600f,
+		-0.535400f,
+		0.906300f,
+		0.413800f,
+		-0.410258f,
+		-0.080891f,
+		-0.274125f,
+		0.000000f,
+		-0.820600f,
+		-0.161200f,
+		-0.548300f,
+		0.906300f,
+		0.448300f,
+		-0.348896f,
+		-0.080891f,
+		-0.348895f,
+		0.000000f,
+		-0.697800f,
+		-0.161200f,
+		-0.697800f,
+		0.875000f,
+		0.448300f,
+		-0.400582f,
+		-0.133764f,
+		-0.267659f,
+		0.000000f,
+		-0.801400f,
+		-0.266600f,
+		-0.535400f,
+		0.906300f,
+		0.413800f,
+		-0.348896f,
+		-0.080891f,
+		-0.348895f,
+		0.000000f,
+		-0.697800f,
+		-0.161200f,
+		-0.697800f,
+		0.875000f,
+		0.448300f,
+		-0.340667f,
+		-0.133764f,
+		-0.340666f,
+		0.000000f,
+		-0.681500f,
+		-0.266600f,
+		-0.681500f,
+		0.875000f,
+		0.413800f,
+		-0.174562f,
+		0.453788f,
+		-0.116638f,
+		0.000000f,
+		-0.351400f,
+		0.906300f,
+		-0.234800f,
+		0.906300f,
+		0.862100f,
+		-0.132745f,
+		0.473826f,
+		-0.088697f,
+		0.000000f,
+		-0.268000f,
+		0.946600f,
+		-0.179100f,
+		0.906300f,
+		0.896600f,
+		-0.112890f,
+		0.473826f,
+		-0.112890f,
+		0.000000f,
+		-0.227900f,
+		0.946600f,
+		-0.227900f,
+		0.875000f,
+		0.896600f,
+		-0.174562f,
+		0.453788f,
+		-0.116638f,
+		0.000000f,
+		-0.351400f,
+		0.906300f,
+		-0.234800f,
+		0.906300f,
+		0.862100f,
+		-0.112890f,
+		0.473826f,
+		-0.112890f,
+		0.000000f,
+		-0.227900f,
+		0.946600f,
+		-0.227900f,
+		0.875000f,
+		0.896600f,
+		-0.148454f,
+		0.453788f,
+		-0.148453f,
+		0.000000f,
+		-0.298900f,
+		0.906300f,
+		-0.298900f,
+		0.875000f,
+		0.862100f,
+		-0.386208f,
+		-0.185069f,
+		-0.258056f,
+		0.000000f,
+		-0.772800f,
+		-0.369000f,
+		-0.516300f,
+		0.906300f,
+		0.379300f,
+		-0.400582f,
+		-0.133764f,
+		-0.267659f,
+		0.000000f,
+		-0.801400f,
+		-0.266600f,
+		-0.535400f,
+		0.906300f,
+		0.413800f,
+		-0.340667f,
+		-0.133764f,
+		-0.340666f,
+		0.000000f,
+		-0.681500f,
+		-0.266600f,
+		-0.681500f,
+		0.875000f,
+		0.413800f,
+		-0.386208f,
+		-0.185069f,
+		-0.258056f,
+		0.000000f,
+		-0.772800f,
+		-0.369000f,
+		-0.516300f,
+		0.906300f,
+		0.379300f,
+		-0.340667f,
+		-0.133764f,
+		-0.340666f,
+		0.000000f,
+		-0.681500f,
+		-0.266600f,
+		-0.681500f,
+		0.875000f,
+		0.413800f,
+		-0.328443f,
+		-0.185069f,
+		-0.328443f,
+		0.000000f,
+		-0.657200f,
+		-0.369000f,
+		-0.657200f,
+		0.875000f,
+		0.379300f,
+		-0.214334f,
+		0.428429f,
+		-0.143213f,
+		0.000000f,
+		-0.430700f,
+		0.855300f,
+		-0.287800f,
+		0.906300f,
+		0.827600f,
+		-0.174562f,
+		0.453788f,
+		-0.116638f,
+		0.000000f,
+		-0.351400f,
+		0.906300f,
+		-0.234800f,
+		0.906300f,
+		0.862100f,
+		-0.148454f,
+		0.453788f,
+		-0.148453f,
+		0.000000f,
+		-0.298900f,
+		0.906300f,
+		-0.298900f,
+		0.875000f,
+		0.862100f,
+		-0.214334f,
+		0.428429f,
+		-0.143213f,
+		0.000000f,
+		-0.430700f,
+		0.855300f,
+		-0.287800f,
+		0.906300f,
+		0.827600f,
+		-0.148454f,
+		0.453788f,
+		-0.148453f,
+		0.000000f,
+		-0.298900f,
+		0.906300f,
+		-0.298900f,
+		0.875000f,
+		0.862100f,
+		-0.182276f,
+		0.428429f,
+		-0.182276f,
+		0.000000f,
+		-0.366300f,
+		0.855300f,
+		-0.366300f,
+		0.875000f,
+		0.827600f,
+		-0.367307f,
+		-0.234204f,
+		-0.245427f,
+		0.000000f,
+		-0.735200f,
+		-0.467000f,
+		-0.491300f,
+		0.906300f,
+		0.344800f,
+		-0.386208f,
+		-0.185069f,
+		-0.258056f,
+		0.000000f,
+		-0.772800f,
+		-0.369000f,
+		-0.516300f,
+		0.906300f,
+		0.379300f,
+		-0.328443f,
+		-0.185069f,
+		-0.328443f,
+		0.000000f,
+		-0.657200f,
+		-0.369000f,
+		-0.657200f,
+		0.875000f,
+		0.379300f,
+		-0.367307f,
+		-0.234204f,
+		-0.245427f,
+		0.000000f,
+		-0.735200f,
+		-0.467000f,
+		-0.491300f,
+		0.906300f,
+		0.344800f,
+		-0.328443f,
+		-0.185069f,
+		-0.328443f,
+		0.000000f,
+		-0.657200f,
+		-0.369000f,
+		-0.657200f,
+		0.875000f,
+		0.379300f,
+		-0.312369f,
+		-0.234204f,
+		-0.312369f,
+		0.000000f,
+		-0.625200f,
+		-0.467000f,
+		-0.625200f,
+		0.875000f,
+		0.344800f,
+		-0.251592f,
+		0.398046f,
+		-0.168108f,
+		0.000000f,
+		-0.504900f,
+		0.794500f,
+		-0.337400f,
+		0.906300f,
+		0.793100f,
+		-0.214334f,
+		0.428429f,
+		-0.143213f,
+		0.000000f,
+		-0.430700f,
+		0.855300f,
+		-0.287800f,
+		0.906300f,
+		0.827600f,
+		-0.182276f,
+		0.428429f,
+		-0.182276f,
+		0.000000f,
+		-0.366300f,
+		0.855300f,
+		-0.366300f,
+		0.875000f,
+		0.827600f,
+		-0.251592f,
+		0.398046f,
+		-0.168108f,
+		0.000000f,
+		-0.504900f,
+		0.794500f,
+		-0.337400f,
+		0.906300f,
+		0.793100f,
+		-0.182276f,
+		0.428429f,
+		-0.182276f,
+		0.000000f,
+		-0.366300f,
+		0.855300f,
+		-0.366300f,
+		0.875000f,
+		0.827600f,
+		-0.213961f,
+		0.398046f,
+		-0.213961f,
+		0.000000f,
+		-0.429400f,
+		0.794500f,
+		-0.429400f,
+		0.875000f,
+		0.793100f,
+		-0.344099f,
+		-0.280594f,
+		-0.229919f,
+		0.000000f,
+		-0.689100f,
+		-0.559600f,
+		-0.460400f,
+		0.906300f,
+		0.310300f,
+		-0.367307f,
+		-0.234204f,
+		-0.245427f,
+		0.000000f,
+		-0.735200f,
+		-0.467000f,
+		-0.491300f,
+		0.906300f,
+		0.344800f,
+		-0.312369f,
+		-0.234204f,
+		-0.312369f,
+		0.000000f,
+		-0.625200f,
+		-0.467000f,
+		-0.625200f,
+		0.875000f,
+		0.344800f,
+		-0.344099f,
+		-0.280594f,
+		-0.229919f,
+		0.000000f,
+		-0.689100f,
+		-0.559600f,
+		-0.460400f,
+		0.906300f,
+		0.310300f,
+		-0.312369f,
+		-0.234204f,
+		-0.312369f,
+		0.000000f,
+		-0.625200f,
+		-0.467000f,
+		-0.625200f,
+		0.875000f,
+		0.344800f,
+		-0.292632f,
+		-0.280594f,
+		-0.292632f,
+		0.000000f,
+		-0.586000f,
+		-0.559600f,
+		-0.586000f,
+		0.875000f,
+		0.310300f,
+		-0.285901f,
+		0.362998f,
+		-0.191032f,
+		0.000000f,
+		-0.573300f,
+		0.724300f,
+		-0.383000f,
+		0.906300f,
+		0.758600f,
+		-0.251592f,
+		0.398046f,
+		-0.168108f,
+		0.000000f,
+		-0.504900f,
+		0.794500f,
+		-0.337400f,
+		0.906300f,
+		0.793100f,
+		-0.213961f,
+		0.398046f,
+		-0.213961f,
+		0.000000f,
+		-0.429400f,
+		0.794500f,
+		-0.429400f,
+		0.875000f,
+		0.793100f,
+		-0.285901f,
+		0.362998f,
+		-0.191032f,
+		0.000000f,
+		-0.573300f,
+		0.724300f,
+		-0.383000f,
+		0.906300f,
+		0.758600f,
+		-0.213961f,
+		0.398046f,
+		-0.213961f,
+		0.000000f,
+		-0.429400f,
+		0.794500f,
+		-0.429400f,
+		0.875000f,
+		0.793100f,
+		-0.243139f,
+		0.362998f,
+		-0.243138f,
+		0.000000f,
+		-0.487500f,
+		0.724300f,
+		-0.487500f,
+		0.875000f,
+		0.758600f,
+		-0.316857f,
+		-0.323693f,
+		-0.211717f,
+		0.000000f,
+		-0.634900f,
+		-0.645700f,
+		-0.424200f,
+		0.906300f,
+		0.275900f,
+		-0.344099f,
+		-0.280594f,
+		-0.229919f,
+		0.000000f,
+		-0.689100f,
+		-0.559600f,
+		-0.460400f,
+		0.906300f,
+		0.310300f,
+		-0.292632f,
+		-0.280594f,
+		-0.292632f,
+		0.000000f,
+		-0.586000f,
+		-0.559600f,
+		-0.586000f,
+		0.875000f,
+		0.310300f,
+		-0.316857f,
+		-0.323693f,
+		-0.211717f,
+		0.000000f,
+		-0.634900f,
+		-0.645700f,
+		-0.424200f,
+		0.906300f,
+		0.275900f,
+		-0.292632f,
+		-0.280594f,
+		-0.292632f,
+		0.000000f,
+		-0.586000f,
+		-0.559600f,
+		-0.586000f,
+		0.875000f,
+		0.310300f,
+		-0.269465f,
+		-0.323693f,
+		-0.269464f,
+		0.000000f,
+		-0.539900f,
+		-0.645700f,
+		-0.539900f,
+		0.875000f,
+		0.275900f,
+		-0.316857f,
+		0.323693f,
+		-0.211717f,
+		0.000000f,
+		-0.634900f,
+		0.645700f,
+		-0.424200f,
+		0.906300f,
+		0.724100f,
+		-0.285901f,
+		0.362998f,
+		-0.191032f,
+		0.000000f,
+		-0.573300f,
+		0.724300f,
+		-0.383000f,
+		0.906300f,
+		0.758600f,
+		-0.243139f,
+		0.362998f,
+		-0.243138f,
+		0.000000f,
+		-0.487500f,
+		0.724300f,
+		-0.487500f,
+		0.875000f,
+		0.758600f,
+		-0.316857f,
+		0.323693f,
+		-0.211717f,
+		0.000000f,
+		-0.634900f,
+		0.645700f,
+		-0.424200f,
+		0.906300f,
+		0.724100f,
+		-0.243139f,
+		0.362998f,
+		-0.243138f,
+		0.000000f,
+		-0.487500f,
+		0.724300f,
+		-0.487500f,
+		0.875000f,
+		0.758600f,
+		-0.269465f,
+		0.323693f,
+		-0.269464f,
+		0.000000f,
+		-0.539900f,
+		0.645700f,
+		-0.539900f,
+		0.875000f,
+		0.724100f,
+		-0.285901f,
+		-0.362998f,
+		-0.191032f,
+		0.000000f,
+		-0.573300f,
+		-0.724300f,
+		-0.383000f,
+		0.906300f,
+		0.241400f,
+		-0.316857f,
+		-0.323693f,
+		-0.211717f,
+		0.000000f,
+		-0.634900f,
+		-0.645700f,
+		-0.424200f,
+		0.906300f,
+		0.275900f,
+		-0.269465f,
+		-0.323693f,
+		-0.269464f,
+		0.000000f,
+		-0.539900f,
+		-0.645700f,
+		-0.539900f,
+		0.875000f,
+		0.275900f,
+		-0.285901f,
+		-0.362998f,
+		-0.191032f,
+		0.000000f,
+		-0.573300f,
+		-0.724300f,
+		-0.383000f,
+		0.906300f,
+		0.241400f,
+		-0.269465f,
+		-0.323693f,
+		-0.269464f,
+		0.000000f,
+		-0.539900f,
+		-0.645700f,
+		-0.539900f,
+		0.875000f,
+		0.275900f,
+		-0.243139f,
+		-0.362998f,
+		-0.243138f,
+		0.000000f,
+		-0.487500f,
+		-0.724300f,
+		-0.487500f,
+		0.875000f,
+		0.241400f,
+		-0.344099f,
+		0.280594f,
+		-0.229919f,
+		0.000000f,
+		-0.689100f,
+		0.559600f,
+		-0.460400f,
+		0.906300f,
+		0.689700f,
+		-0.316857f,
+		0.323693f,
+		-0.211717f,
+		0.000000f,
+		-0.634900f,
+		0.645700f,
+		-0.424200f,
+		0.906300f,
+		0.724100f,
+		-0.269465f,
+		0.323693f,
+		-0.269464f,
+		0.000000f,
+		-0.539900f,
+		0.645700f,
+		-0.539900f,
+		0.875000f,
+		0.724100f,
+		-0.344099f,
+		0.280594f,
+		-0.229919f,
+		0.000000f,
+		-0.689100f,
+		0.559600f,
+		-0.460400f,
+		0.906300f,
+		0.689700f,
+		-0.269465f,
+		0.323693f,
+		-0.269464f,
+		0.000000f,
+		-0.539900f,
+		0.645700f,
+		-0.539900f,
+		0.875000f,
+		0.724100f,
+		-0.292632f,
+		0.280594f,
+		-0.292632f,
+		0.000000f,
+		-0.586000f,
+		0.559600f,
+		-0.586000f,
+		0.875000f,
+		0.689700f,
+		-0.251592f,
+		-0.398046f,
+		-0.168108f,
+		0.000000f,
+		-0.505000f,
+		-0.794500f,
+		-0.337400f,
+		0.906300f,
+		0.206900f,
+		-0.285901f,
+		-0.362998f,
+		-0.191032f,
+		0.000000f,
+		-0.573300f,
+		-0.724300f,
+		-0.383000f,
+		0.906300f,
+		0.241400f,
+		-0.243139f,
+		-0.362998f,
+		-0.243138f,
+		0.000000f,
+		-0.487500f,
+		-0.724300f,
+		-0.487500f,
+		0.875000f,
+		0.241400f,
+		-0.251592f,
+		-0.398046f,
+		-0.168108f,
+		0.000000f,
+		-0.505000f,
+		-0.794500f,
+		-0.337400f,
+		0.906300f,
+		0.206900f,
+		-0.243139f,
+		-0.362998f,
+		-0.243138f,
+		0.000000f,
+		-0.487500f,
+		-0.724300f,
+		-0.487500f,
+		0.875000f,
+		0.241400f,
+		-0.213961f,
+		-0.398046f,
+		-0.213961f,
+		0.000000f,
+		-0.429400f,
+		-0.794500f,
+		-0.429400f,
+		0.875000f,
+		0.206900f,
+		-0.367307f,
+		0.234204f,
+		-0.245426f,
+		0.000000f,
+		-0.735200f,
+		0.467000f,
+		-0.491300f,
+		0.906300f,
+		0.655200f,
+		-0.344099f,
+		0.280594f,
+		-0.229919f,
+		0.000000f,
+		-0.689100f,
+		0.559600f,
+		-0.460400f,
+		0.906300f,
+		0.689700f,
+		-0.292632f,
+		0.280594f,
+		-0.292632f,
+		0.000000f,
+		-0.586000f,
+		0.559600f,
+		-0.586000f,
+		0.875000f,
+		0.689700f,
+		-0.367307f,
+		0.234204f,
+		-0.245426f,
+		0.000000f,
+		-0.735200f,
+		0.467000f,
+		-0.491300f,
+		0.906300f,
+		0.655200f,
+		-0.292632f,
+		0.280594f,
+		-0.292632f,
+		0.000000f,
+		-0.586000f,
+		0.559600f,
+		-0.586000f,
+		0.875000f,
+		0.689700f,
+		-0.312369f,
+		0.234204f,
+		-0.312369f,
+		0.000000f,
+		-0.625200f,
+		0.467000f,
+		-0.625200f,
+		0.875000f,
+		0.655200f,
+		-0.214334f,
+		-0.428429f,
+		-0.143213f,
+		0.000000f,
+		-0.430700f,
+		-0.855300f,
+		-0.287800f,
+		0.906300f,
+		0.172400f,
+		-0.251592f,
+		-0.398046f,
+		-0.168108f,
+		0.000000f,
+		-0.505000f,
+		-0.794500f,
+		-0.337400f,
+		0.906300f,
+		0.206900f,
+		-0.213961f,
+		-0.398046f,
+		-0.213961f,
+		0.000000f,
+		-0.429400f,
+		-0.794500f,
+		-0.429400f,
+		0.875000f,
+		0.206900f,
+		-0.214334f,
+		-0.428429f,
+		-0.143213f,
+		0.000000f,
+		-0.430700f,
+		-0.855300f,
+		-0.287800f,
+		0.906300f,
+		0.172400f,
+		-0.213961f,
+		-0.398046f,
+		-0.213961f,
+		0.000000f,
+		-0.429400f,
+		-0.794500f,
+		-0.429400f,
+		0.875000f,
+		0.206900f,
+		-0.182276f,
+		-0.428429f,
+		-0.182276f,
+		0.000000f,
+		-0.366300f,
+		-0.855300f,
+		-0.366300f,
+		0.875000f,
+		0.172400f,
+		-0.386208f,
+		0.185069f,
+		-0.258056f,
+		0.000000f,
+		-0.772800f,
+		0.369000f,
+		-0.516300f,
+		0.906200f,
+		0.620700f,
+		-0.367307f,
+		0.234204f,
+		-0.245426f,
+		0.000000f,
+		-0.735200f,
+		0.467000f,
+		-0.491300f,
+		0.906300f,
+		0.655200f,
+		-0.312369f,
+		0.234204f,
+		-0.312369f,
+		0.000000f,
+		-0.625200f,
+		0.467000f,
+		-0.625200f,
+		0.875000f,
+		0.655200f,
+		-0.386208f,
+		0.185069f,
+		-0.258056f,
+		0.000000f,
+		-0.772800f,
+		0.369000f,
+		-0.516300f,
+		0.906200f,
+		0.620700f,
+		-0.312369f,
+		0.234204f,
+		-0.312369f,
+		0.000000f,
+		-0.625200f,
+		0.467000f,
+		-0.625200f,
+		0.875000f,
+		0.655200f,
+		-0.328443f,
+		0.185069f,
+		-0.328443f,
+		0.000000f,
+		-0.657200f,
+		0.369000f,
+		-0.657200f,
+		0.875000f,
+		0.620700f,
+		-0.174563f,
+		-0.453788f,
+		-0.116639f,
+		0.000000f,
+		-0.351400f,
+		-0.906300f,
+		-0.234800f,
+		0.906300f,
+		0.137900f,
+		-0.214334f,
+		-0.428429f,
+		-0.143213f,
+		0.000000f,
+		-0.430700f,
+		-0.855300f,
+		-0.287800f,
+		0.906300f,
+		0.172400f,
+		-0.182276f,
+		-0.428429f,
+		-0.182276f,
+		0.000000f,
+		-0.366300f,
+		-0.855300f,
+		-0.366300f,
+		0.875000f,
+		0.172400f,
+		-0.174563f,
+		-0.453788f,
+		-0.116639f,
+		0.000000f,
+		-0.351400f,
+		-0.906300f,
+		-0.234800f,
+		0.906300f,
+		0.137900f,
+		-0.182276f,
+		-0.428429f,
+		-0.182276f,
+		0.000000f,
+		-0.366300f,
+		-0.855300f,
+		-0.366300f,
+		0.875000f,
+		0.172400f,
+		-0.148454f,
+		-0.453788f,
+		-0.148453f,
+		0.000000f,
+		-0.298900f,
+		-0.906300f,
+		-0.298900f,
+		0.875000f,
+		0.137900f,
+		-0.400582f,
+		0.133764f,
+		-0.267659f,
+		0.000000f,
+		-0.801400f,
+		0.266600f,
+		-0.535400f,
+		0.906300f,
+		0.586200f,
+		-0.386208f,
+		0.185069f,
+		-0.258056f,
+		0.000000f,
+		-0.772800f,
+		0.369000f,
+		-0.516300f,
+		0.906200f,
+		0.620700f,
+		-0.328443f,
+		0.185069f,
+		-0.328443f,
+		0.000000f,
+		-0.657200f,
+		0.369000f,
+		-0.657200f,
+		0.875000f,
+		0.620700f,
+		-0.400582f,
+		0.133764f,
+		-0.267659f,
+		0.000000f,
+		-0.801400f,
+		0.266600f,
+		-0.535400f,
+		0.906300f,
+		0.586200f,
+		-0.328443f,
+		0.185069f,
+		-0.328443f,
+		0.000000f,
+		-0.657200f,
+		0.369000f,
+		-0.657200f,
+		0.875000f,
+		0.620700f,
+		-0.340667f,
+		0.133764f,
+		-0.340666f,
+		0.000000f,
+		-0.681500f,
+		0.266600f,
+		-0.681500f,
+		0.875000f,
+		0.586200f,
+		-0.132745f,
+		-0.473826f,
+		-0.088697f,
+		0.000000f,
+		-0.268000f,
+		-0.946600f,
+		-0.179100f,
+		0.906300f,
+		0.103400f,
+		-0.174563f,
+		-0.453788f,
+		-0.116639f,
+		0.000000f,
+		-0.351400f,
+		-0.906300f,
+		-0.234800f,
+		0.906300f,
+		0.137900f,
+		-0.148454f,
+		-0.453788f,
+		-0.148453f,
+		0.000000f,
+		-0.298900f,
+		-0.906300f,
+		-0.298900f,
+		0.875000f,
+		0.137900f,
+		-0.132745f,
+		-0.473826f,
+		-0.088697f,
+		0.000000f,
+		-0.268000f,
+		-0.946600f,
+		-0.179100f,
+		0.906300f,
+		0.103400f,
+		-0.148454f,
+		-0.453788f,
+		-0.148453f,
+		0.000000f,
+		-0.298900f,
+		-0.906300f,
+		-0.298900f,
+		0.875000f,
+		0.137900f,
+		-0.112890f,
+		-0.473826f,
+		-0.112890f,
+		0.000000f,
+		-0.227900f,
+		-0.946600f,
+		-0.227900f,
+		0.875000f,
+		0.103400f,
+		-0.410258f,
+		0.080891f,
+		-0.274125f,
+		0.000000f,
+		-0.820600f,
+		0.161200f,
+		-0.548300f,
+		0.906300f,
+		0.551700f,
+		-0.400582f,
+		0.133764f,
+		-0.267659f,
+		0.000000f,
+		-0.801400f,
+		0.266600f,
+		-0.535400f,
+		0.906300f,
+		0.586200f,
+		-0.340667f,
+		0.133764f,
+		-0.340666f,
+		0.000000f,
+		-0.681500f,
+		0.266600f,
+		-0.681500f,
+		0.875000f,
+		0.586200f,
+		-0.410258f,
+		0.080891f,
+		-0.274125f,
+		0.000000f,
+		-0.820600f,
+		0.161200f,
+		-0.548300f,
+		0.906300f,
+		0.551700f,
+		-0.340667f,
+		0.133764f,
+		-0.340666f,
+		0.000000f,
+		-0.681500f,
+		0.266600f,
+		-0.681500f,
+		0.875000f,
+		0.586200f,
+		-0.348896f,
+		0.080891f,
+		-0.348895f,
+		0.000000f,
+		-0.697800f,
+		0.161200f,
+		-0.697800f,
+		0.875000f,
+		0.551700f,
+		-0.089371f,
+		-0.488310f,
+		-0.059715f,
+		0.000000f,
+		-0.181400f,
+		-0.975900f,
+		-0.121200f,
+		0.906300f,
+		0.069000f,
+		-0.132745f,
+		-0.473826f,
+		-0.088697f,
+		0.000000f,
+		-0.268000f,
+		-0.946600f,
+		-0.179100f,
+		0.906300f,
+		0.103400f,
+		-0.112890f,
+		-0.473826f,
+		-0.112890f,
+		0.000000f,
+		-0.227900f,
+		-0.946600f,
+		-0.227900f,
+		0.875000f,
+		0.103400f,
+		-0.089371f,
+		-0.488310f,
+		-0.059715f,
+		0.000000f,
+		-0.181400f,
+		-0.975900f,
+		-0.121200f,
+		0.906300f,
+		0.069000f,
+		-0.112890f,
+		-0.473826f,
+		-0.112890f,
+		0.000000f,
+		-0.227900f,
+		-0.946600f,
+		-0.227900f,
+		0.875000f,
+		0.103400f,
+		-0.076004f,
+		-0.488310f,
+		-0.076003f,
+		0.000000f,
+		-0.154300f,
+		-0.975900f,
+		-0.154300f,
+		0.875000f,
+		0.069000f,
+		-0.415125f,
+		0.027069f,
+		-0.277377f,
+		0.000000f,
+		-0.830300f,
+		0.054000f,
+		-0.554700f,
+		0.906300f,
+		0.517200f,
+		-0.410258f,
+		0.080891f,
+		-0.274125f,
+		0.000000f,
+		-0.820600f,
+		0.161200f,
+		-0.548300f,
+		0.906300f,
+		0.551700f,
+		-0.348896f,
+		0.080891f,
+		-0.348895f,
+		0.000000f,
+		-0.697800f,
+		0.161200f,
+		-0.697800f,
+		0.875000f,
+		0.551700f,
+		-0.415125f,
+		0.027069f,
+		-0.277377f,
+		0.000000f,
+		-0.830300f,
+		0.054000f,
+		-0.554700f,
+		0.906300f,
+		0.517200f,
+		-0.348896f,
+		0.080891f,
+		-0.348895f,
+		0.000000f,
+		-0.697800f,
+		0.161200f,
+		-0.697800f,
+		0.875000f,
+		0.551700f,
+		-0.353035f,
+		0.027069f,
+		-0.353034f,
+		0.000000f,
+		-0.706100f,
+		0.054000f,
+		-0.706100f,
+		0.875000f,
+		0.517200f,
+		-0.044949f,
+		0.497069f,
+		-0.030034f,
+		0.000000f,
+		-0.092700f,
+		0.993700f,
+		-0.061900f,
+		0.432600f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.423900f,
+		0.960300f,
+		-0.038226f,
+		0.497069f,
+		-0.038226f,
+		0.000000f,
+		-0.078800f,
+		0.993700f,
+		-0.078800f,
+		0.434400f,
+		0.962300f,
+		-0.044949f,
+		-0.497069f,
+		-0.030034f,
+		0.000000f,
+		-0.092700f,
+		-0.993700f,
+		-0.061900f,
+		0.906300f,
+		0.034500f,
+		-0.089371f,
+		-0.488310f,
+		-0.059715f,
+		0.000000f,
+		-0.181400f,
+		-0.975900f,
+		-0.121200f,
+		0.906300f,
+		0.069000f,
+		-0.076004f,
+		-0.488310f,
+		-0.076003f,
+		0.000000f,
+		-0.154300f,
+		-0.975900f,
+		-0.154300f,
+		0.875000f,
+		0.069000f,
+		-0.044949f,
+		-0.497069f,
+		-0.030034f,
+		0.000000f,
+		-0.092700f,
+		-0.993700f,
+		-0.061900f,
+		0.906300f,
+		0.034500f,
+		-0.076004f,
+		-0.488310f,
+		-0.076003f,
+		0.000000f,
+		-0.154300f,
+		-0.975900f,
+		-0.154300f,
+		0.875000f,
+		0.069000f,
+		-0.038226f,
+		-0.497069f,
+		-0.038226f,
+		0.000000f,
+		-0.078800f,
+		-0.993700f,
+		-0.078800f,
+		0.875000f,
+		0.034500f,
+		-0.415125f,
+		-0.027069f,
+		-0.277377f,
+		0.000000f,
+		-0.830300f,
+		-0.054000f,
+		-0.554700f,
+		0.906300f,
+		0.482800f,
+		-0.415125f,
+		0.027069f,
+		-0.277377f,
+		0.000000f,
+		-0.830300f,
+		0.054000f,
+		-0.554700f,
+		0.906300f,
+		0.517200f,
+		-0.353035f,
+		0.027069f,
+		-0.353034f,
+		0.000000f,
+		-0.706100f,
+		0.054000f,
+		-0.706100f,
+		0.875000f,
+		0.517200f,
+		-0.415125f,
+		-0.027069f,
+		-0.277377f,
+		0.000000f,
+		-0.830300f,
+		-0.054000f,
+		-0.554700f,
+		0.906300f,
+		0.482800f,
+		-0.353035f,
+		0.027069f,
+		-0.353034f,
+		0.000000f,
+		-0.706100f,
+		0.054000f,
+		-0.706100f,
+		0.875000f,
+		0.517200f,
+		-0.353035f,
+		-0.027069f,
+		-0.353034f,
+		0.000000f,
+		-0.706100f,
+		-0.054000f,
+		-0.706100f,
+		0.875000f,
+		0.482800f,
+		-0.089371f,
+		0.488310f,
+		-0.059715f,
+		0.000000f,
+		-0.181400f,
+		0.975900f,
+		-0.121200f,
+		0.906300f,
+		0.931000f,
+		-0.044949f,
+		0.497069f,
+		-0.030034f,
+		0.000000f,
+		-0.092700f,
+		0.993700f,
+		-0.061900f,
+		0.906300f,
+		0.965500f,
+		-0.038226f,
+		0.497069f,
+		-0.038226f,
+		0.000000f,
+		-0.078800f,
+		0.993700f,
+		-0.078800f,
+		0.875000f,
+		0.965500f,
+		-0.089371f,
+		0.488310f,
+		-0.059715f,
+		0.000000f,
+		-0.181400f,
+		0.975900f,
+		-0.121200f,
+		0.906300f,
+		0.931000f,
+		-0.038226f,
+		0.497069f,
+		-0.038226f,
+		0.000000f,
+		-0.078800f,
+		0.993700f,
+		-0.078800f,
+		0.875000f,
+		0.965500f,
+		-0.076003f,
+		0.488310f,
+		-0.076003f,
+		0.000000f,
+		-0.154300f,
+		0.975900f,
+		-0.154300f,
+		0.875000f,
+		0.931000f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.495500f,
+		0.051000f,
+		-0.044949f,
+		-0.497069f,
+		-0.030034f,
+		0.000000f,
+		-0.092700f,
+		-0.993700f,
+		-0.061900f,
+		0.486400f,
+		0.053800f,
+		-0.038226f,
+		-0.497069f,
+		-0.038226f,
+		0.000000f,
+		-0.078800f,
+		-0.993700f,
+		-0.078800f,
+		0.483700f,
+		0.053800f,
+		-0.410258f,
+		-0.080891f,
+		-0.274125f,
+		0.000000f,
+		-0.820600f,
+		-0.161200f,
+		-0.548300f,
+		0.906300f,
+		0.448300f,
+		-0.415125f,
+		-0.027069f,
+		-0.277377f,
+		0.000000f,
+		-0.830300f,
+		-0.054000f,
+		-0.554700f,
+		0.906300f,
+		0.482800f,
+		-0.353035f,
+		-0.027069f,
+		-0.353034f,
+		0.000000f,
+		-0.706100f,
+		-0.054000f,
+		-0.706100f,
+		0.875000f,
+		0.482800f,
+		-0.410258f,
+		-0.080891f,
+		-0.274125f,
+		0.000000f,
+		-0.820600f,
+		-0.161200f,
+		-0.548300f,
+		0.906300f,
+		0.448300f,
+		-0.353035f,
+		-0.027069f,
+		-0.353034f,
+		0.000000f,
+		-0.706100f,
+		-0.054000f,
+		-0.706100f,
+		0.875000f,
+		0.482800f,
+		-0.348896f,
+		-0.080891f,
+		-0.348895f,
+		0.000000f,
+		-0.697800f,
+		-0.161200f,
+		-0.697800f,
+		0.875000f,
+		0.448300f,
+		-0.328443f,
+		0.185069f,
+		-0.328443f,
+		0.000000f,
+		-0.657200f,
+		0.369000f,
+		-0.657200f,
+		0.875000f,
+		0.620700f,
+		-0.312369f,
+		0.234204f,
+		-0.312369f,
+		0.000000f,
+		-0.625200f,
+		0.467000f,
+		-0.625200f,
+		0.875000f,
+		0.655200f,
+		-0.245427f,
+		0.234204f,
+		-0.367307f,
+		0.000000f,
+		-0.491300f,
+		0.467000f,
+		-0.735200f,
+		0.843800f,
+		0.655200f,
+		-0.328443f,
+		0.185069f,
+		-0.328443f,
+		0.000000f,
+		-0.657200f,
+		0.369000f,
+		-0.657200f,
+		0.875000f,
+		0.620700f,
+		-0.245427f,
+		0.234204f,
+		-0.367307f,
+		0.000000f,
+		-0.491300f,
+		0.467000f,
+		-0.735200f,
+		0.843800f,
+		0.655200f,
+		-0.258056f,
+		0.185069f,
+		-0.386207f,
+		0.000000f,
+		-0.516300f,
+		0.369000f,
+		-0.772800f,
+		0.843800f,
+		0.620700f,
+		-0.148454f,
+		-0.453788f,
+		-0.148453f,
+		0.000000f,
+		-0.298900f,
+		-0.906300f,
+		-0.298900f,
+		0.875000f,
+		0.137900f,
+		-0.182276f,
+		-0.428429f,
+		-0.182276f,
+		0.000000f,
+		-0.366300f,
+		-0.855300f,
+		-0.366300f,
+		0.875000f,
+		0.172400f,
+		-0.143213f,
+		-0.428429f,
+		-0.214334f,
+		0.000000f,
+		-0.287800f,
+		-0.855300f,
+		-0.430700f,
+		0.843800f,
+		0.172400f,
+		-0.148454f,
+		-0.453788f,
+		-0.148453f,
+		0.000000f,
+		-0.298900f,
+		-0.906300f,
+		-0.298900f,
+		0.875000f,
+		0.137900f,
+		-0.143213f,
+		-0.428429f,
+		-0.214334f,
+		0.000000f,
+		-0.287800f,
+		-0.855300f,
+		-0.430700f,
+		0.843800f,
+		0.172400f,
+		-0.116640f,
+		-0.453788f,
+		-0.174562f,
+		0.000000f,
+		-0.234800f,
+		-0.906300f,
+		-0.351400f,
+		0.843800f,
+		0.137900f,
+		-0.340667f,
+		0.133764f,
+		-0.340666f,
+		0.000000f,
+		-0.681500f,
+		0.266600f,
+		-0.681500f,
+		0.875000f,
+		0.586200f,
+		-0.328443f,
+		0.185069f,
+		-0.328443f,
+		0.000000f,
+		-0.657200f,
+		0.369000f,
+		-0.657200f,
+		0.875000f,
+		0.620700f,
+		-0.258056f,
+		0.185069f,
+		-0.386207f,
+		0.000000f,
+		-0.516300f,
+		0.369000f,
+		-0.772800f,
+		0.843800f,
+		0.620700f,
+		-0.340667f,
+		0.133764f,
+		-0.340666f,
+		0.000000f,
+		-0.681500f,
+		0.266600f,
+		-0.681500f,
+		0.875000f,
+		0.586200f,
+		-0.258056f,
+		0.185069f,
+		-0.386207f,
+		0.000000f,
+		-0.516300f,
+		0.369000f,
+		-0.772800f,
+		0.843800f,
+		0.620700f,
+		-0.267660f,
+		0.133764f,
+		-0.400581f,
+		0.000000f,
+		-0.535400f,
+		0.266600f,
+		-0.801400f,
+		0.843800f,
+		0.586200f,
+		-0.112890f,
+		-0.473826f,
+		-0.112890f,
+		0.000000f,
+		-0.227900f,
+		-0.946600f,
+		-0.227900f,
+		0.875000f,
+		0.103400f,
+		-0.148454f,
+		-0.453788f,
+		-0.148453f,
+		0.000000f,
+		-0.298900f,
+		-0.906300f,
+		-0.298900f,
+		0.875000f,
+		0.137900f,
+		-0.116640f,
+		-0.453788f,
+		-0.174562f,
+		0.000000f,
+		-0.234800f,
+		-0.906300f,
+		-0.351400f,
+		0.843800f,
+		0.137900f,
+		-0.112890f,
+		-0.473826f,
+		-0.112890f,
+		0.000000f,
+		-0.227900f,
+		-0.946600f,
+		-0.227900f,
+		0.875000f,
+		0.103400f,
+		-0.116640f,
+		-0.453788f,
+		-0.174562f,
+		0.000000f,
+		-0.234800f,
+		-0.906300f,
+		-0.351400f,
+		0.843800f,
+		0.137900f,
+		-0.088698f,
+		-0.473826f,
+		-0.132745f,
+		0.000000f,
+		-0.179100f,
+		-0.946600f,
+		-0.268000f,
+		0.843800f,
+		0.103400f,
+		-0.348896f,
+		0.080891f,
+		-0.348895f,
+		0.000000f,
+		-0.697800f,
+		0.161200f,
+		-0.697800f,
+		0.875000f,
+		0.551700f,
+		-0.340667f,
+		0.133764f,
+		-0.340666f,
+		0.000000f,
+		-0.681500f,
+		0.266600f,
+		-0.681500f,
+		0.875000f,
+		0.586200f,
+		-0.267660f,
+		0.133764f,
+		-0.400581f,
+		0.000000f,
+		-0.535400f,
+		0.266600f,
+		-0.801400f,
+		0.843800f,
+		0.586200f,
+		-0.348896f,
+		0.080891f,
+		-0.348895f,
+		0.000000f,
+		-0.697800f,
+		0.161200f,
+		-0.697800f,
+		0.875000f,
+		0.551700f,
+		-0.267660f,
+		0.133764f,
+		-0.400581f,
+		0.000000f,
+		-0.535400f,
+		0.266600f,
+		-0.801400f,
+		0.843800f,
+		0.586200f,
+		-0.274126f,
+		0.080891f,
+		-0.410257f,
+		0.000000f,
+		-0.548300f,
+		0.161200f,
+		-0.820600f,
+		0.843800f,
+		0.551700f,
+		-0.076004f,
+		-0.488310f,
+		-0.076003f,
+		0.000000f,
+		-0.154300f,
+		-0.975900f,
+		-0.154300f,
+		0.875000f,
+		0.069000f,
+		-0.112890f,
+		-0.473826f,
+		-0.112890f,
+		0.000000f,
+		-0.227900f,
+		-0.946600f,
+		-0.227900f,
+		0.875000f,
+		0.103400f,
+		-0.088698f,
+		-0.473826f,
+		-0.132745f,
+		0.000000f,
+		-0.179100f,
+		-0.946600f,
+		-0.268000f,
+		0.843800f,
+		0.103400f,
+		-0.076004f,
+		-0.488310f,
+		-0.076003f,
+		0.000000f,
+		-0.154300f,
+		-0.975900f,
+		-0.154300f,
+		0.875000f,
+		0.069000f,
+		-0.088698f,
+		-0.473826f,
+		-0.132745f,
+		0.000000f,
+		-0.179100f,
+		-0.946600f,
+		-0.268000f,
+		0.843800f,
+		0.103400f,
+		-0.059716f,
+		-0.488310f,
+		-0.089370f,
+		0.000000f,
+		-0.121200f,
+		-0.975900f,
+		-0.181400f,
+		0.843800f,
+		0.069000f,
+		-0.353035f,
+		0.027069f,
+		-0.353034f,
+		0.000000f,
+		-0.706100f,
+		0.054000f,
+		-0.706100f,
+		0.875000f,
+		0.517200f,
+		-0.348896f,
+		0.080891f,
+		-0.348895f,
+		0.000000f,
+		-0.697800f,
+		0.161200f,
+		-0.697800f,
+		0.875000f,
+		0.551700f,
+		-0.274126f,
+		0.080891f,
+		-0.410257f,
+		0.000000f,
+		-0.548300f,
+		0.161200f,
+		-0.820600f,
+		0.843800f,
+		0.551700f,
+		-0.353035f,
+		0.027069f,
+		-0.353034f,
+		0.000000f,
+		-0.706100f,
+		0.054000f,
+		-0.706100f,
+		0.875000f,
+		0.517200f,
+		-0.274126f,
+		0.080891f,
+		-0.410257f,
+		0.000000f,
+		-0.548300f,
+		0.161200f,
+		-0.820600f,
+		0.843800f,
+		0.551700f,
+		-0.277378f,
+		0.027069f,
+		-0.415125f,
+		0.000000f,
+		-0.554700f,
+		0.054000f,
+		-0.830300f,
+		0.843800f,
+		0.517200f,
+		-0.038226f,
+		0.497069f,
+		-0.038226f,
+		0.000000f,
+		-0.078800f,
+		0.993700f,
+		-0.078800f,
+		0.434400f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.423900f,
+		0.960300f,
+		-0.030034f,
+		0.497069f,
+		-0.044948f,
+		0.000000f,
+		-0.061900f,
+		0.993700f,
+		-0.092700f,
+		0.436200f,
+		0.962300f,
+		-0.038226f,
+		-0.497069f,
+		-0.038226f,
+		0.000000f,
+		-0.078800f,
+		-0.993700f,
+		-0.078800f,
+		0.875000f,
+		0.034500f,
+		-0.076004f,
+		-0.488310f,
+		-0.076003f,
+		0.000000f,
+		-0.154300f,
+		-0.975900f,
+		-0.154300f,
+		0.875000f,
+		0.069000f,
+		-0.059716f,
+		-0.488310f,
+		-0.089370f,
+		0.000000f,
+		-0.121200f,
+		-0.975900f,
+		-0.181400f,
+		0.843800f,
+		0.069000f,
+		-0.038226f,
+		-0.497069f,
+		-0.038226f,
+		0.000000f,
+		-0.078800f,
+		-0.993700f,
+		-0.078800f,
+		0.875000f,
+		0.034500f,
+		-0.059716f,
+		-0.488310f,
+		-0.089370f,
+		0.000000f,
+		-0.121200f,
+		-0.975900f,
+		-0.181400f,
+		0.843800f,
+		0.069000f,
+		-0.030034f,
+		-0.497069f,
+		-0.044949f,
+		0.000000f,
+		-0.061900f,
+		-0.993700f,
+		-0.092700f,
+		0.843800f,
+		0.034500f,
+		-0.353035f,
+		-0.027069f,
+		-0.353034f,
+		0.000000f,
+		-0.706100f,
+		-0.054000f,
+		-0.706100f,
+		0.875000f,
+		0.482800f,
+		-0.353035f,
+		0.027069f,
+		-0.353034f,
+		0.000000f,
+		-0.706100f,
+		0.054000f,
+		-0.706100f,
+		0.875000f,
+		0.517200f,
+		-0.277378f,
+		0.027069f,
+		-0.415125f,
+		0.000000f,
+		-0.554700f,
+		0.054000f,
+		-0.830300f,
+		0.843800f,
+		0.517200f,
+		-0.353035f,
+		-0.027069f,
+		-0.353034f,
+		0.000000f,
+		-0.706100f,
+		-0.054000f,
+		-0.706100f,
+		0.875000f,
+		0.482800f,
+		-0.277378f,
+		0.027069f,
+		-0.415125f,
+		0.000000f,
+		-0.554700f,
+		0.054000f,
+		-0.830300f,
+		0.843800f,
+		0.517200f,
+		-0.277378f,
+		-0.027069f,
+		-0.415125f,
+		0.000000f,
+		-0.554700f,
+		-0.054000f,
+		-0.830300f,
+		0.843800f,
+		0.482800f,
+		-0.076003f,
+		0.488310f,
+		-0.076003f,
+		0.000000f,
+		-0.154300f,
+		0.975900f,
+		-0.154300f,
+		0.875000f,
+		0.931000f,
+		-0.038226f,
+		0.497069f,
+		-0.038226f,
+		0.000000f,
+		-0.078800f,
+		0.993700f,
+		-0.078800f,
+		0.875000f,
+		0.965500f,
+		-0.030034f,
+		0.497069f,
+		-0.044948f,
+		0.000000f,
+		-0.061900f,
+		0.993700f,
+		-0.092700f,
+		0.843800f,
+		0.965500f,
+		-0.076003f,
+		0.488310f,
+		-0.076003f,
+		0.000000f,
+		-0.154300f,
+		0.975900f,
+		-0.154300f,
+		0.875000f,
+		0.931000f,
+		-0.030034f,
+		0.497069f,
+		-0.044948f,
+		0.000000f,
+		-0.061900f,
+		0.993700f,
+		-0.092700f,
+		0.843800f,
+		0.965500f,
+		-0.059716f,
+		0.488310f,
+		-0.089370f,
+		0.000000f,
+		-0.121200f,
+		0.975900f,
+		-0.181400f,
+		0.843800f,
+		0.931000f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.495500f,
+		0.051000f,
+		-0.038226f,
+		-0.497069f,
+		-0.038226f,
+		0.000000f,
+		-0.078800f,
+		-0.993700f,
+		-0.078800f,
+		0.483700f,
+		0.053800f,
+		-0.030034f,
+		-0.497069f,
+		-0.044949f,
+		0.000000f,
+		-0.061900f,
+		-0.993700f,
+		-0.092700f,
+		0.481100f,
+		0.053800f,
+		-0.348896f,
+		-0.080891f,
+		-0.348895f,
+		0.000000f,
+		-0.697800f,
+		-0.161200f,
+		-0.697800f,
+		0.875000f,
+		0.448300f,
+		-0.353035f,
+		-0.027069f,
+		-0.353034f,
+		0.000000f,
+		-0.706100f,
+		-0.054000f,
+		-0.706100f,
+		0.875000f,
+		0.482800f,
+		-0.277378f,
+		-0.027069f,
+		-0.415125f,
+		0.000000f,
+		-0.554700f,
+		-0.054000f,
+		-0.830300f,
+		0.843800f,
+		0.482800f,
+		-0.348896f,
+		-0.080891f,
+		-0.348895f,
+		0.000000f,
+		-0.697800f,
+		-0.161200f,
+		-0.697800f,
+		0.875000f,
+		0.448300f,
+		-0.277378f,
+		-0.027069f,
+		-0.415125f,
+		0.000000f,
+		-0.554700f,
+		-0.054000f,
+		-0.830300f,
+		0.843800f,
+		0.482800f,
+		-0.274126f,
+		-0.080891f,
+		-0.410257f,
+		0.000000f,
+		-0.548300f,
+		-0.161200f,
+		-0.820600f,
+		0.843800f,
+		0.448300f,
+		-0.112890f,
+		0.473826f,
+		-0.112890f,
+		0.000000f,
+		-0.227900f,
+		0.946600f,
+		-0.227900f,
+		0.875000f,
+		0.896600f,
+		-0.076003f,
+		0.488310f,
+		-0.076003f,
+		0.000000f,
+		-0.154300f,
+		0.975900f,
+		-0.154300f,
+		0.875000f,
+		0.931000f,
+		-0.059716f,
+		0.488310f,
+		-0.089370f,
+		0.000000f,
+		-0.121200f,
+		0.975900f,
+		-0.181400f,
+		0.843800f,
+		0.931000f,
+		-0.112890f,
+		0.473826f,
+		-0.112890f,
+		0.000000f,
+		-0.227900f,
+		0.946600f,
+		-0.227900f,
+		0.875000f,
+		0.896600f,
+		-0.059716f,
+		0.488310f,
+		-0.089370f,
+		0.000000f,
+		-0.121200f,
+		0.975900f,
+		-0.181400f,
+		0.843800f,
+		0.931000f,
+		-0.088698f,
+		0.473826f,
+		-0.132745f,
+		0.000000f,
+		-0.179100f,
+		0.946600f,
+		-0.268000f,
+		0.843800f,
+		0.896600f,
+		-0.340667f,
+		-0.133764f,
+		-0.340666f,
+		0.000000f,
+		-0.681500f,
+		-0.266600f,
+		-0.681500f,
+		0.875000f,
+		0.413800f,
+		-0.348896f,
+		-0.080891f,
+		-0.348895f,
+		0.000000f,
+		-0.697800f,
+		-0.161200f,
+		-0.697800f,
+		0.875000f,
+		0.448300f,
+		-0.274126f,
+		-0.080891f,
+		-0.410257f,
+		0.000000f,
+		-0.548300f,
+		-0.161200f,
+		-0.820600f,
+		0.843800f,
+		0.448300f,
+		-0.340667f,
+		-0.133764f,
+		-0.340666f,
+		0.000000f,
+		-0.681500f,
+		-0.266600f,
+		-0.681500f,
+		0.875000f,
+		0.413800f,
+		-0.274126f,
+		-0.080891f,
+		-0.410257f,
+		0.000000f,
+		-0.548300f,
+		-0.161200f,
+		-0.820600f,
+		0.843800f,
+		0.448300f,
+		-0.267660f,
+		-0.133764f,
+		-0.400581f,
+		0.000000f,
+		-0.535400f,
+		-0.266600f,
+		-0.801400f,
+		0.843800f,
+		0.413800f,
+		-0.148454f,
+		0.453788f,
+		-0.148453f,
+		0.000000f,
+		-0.298900f,
+		0.906300f,
+		-0.298900f,
+		0.875000f,
+		0.862100f,
+		-0.112890f,
+		0.473826f,
+		-0.112890f,
+		0.000000f,
+		-0.227900f,
+		0.946600f,
+		-0.227900f,
+		0.875000f,
+		0.896600f,
+		-0.088698f,
+		0.473826f,
+		-0.132745f,
+		0.000000f,
+		-0.179100f,
+		0.946600f,
+		-0.268000f,
+		0.843800f,
+		0.896600f,
+		-0.148454f,
+		0.453788f,
+		-0.148453f,
+		0.000000f,
+		-0.298900f,
+		0.906300f,
+		-0.298900f,
+		0.875000f,
+		0.862100f,
+		-0.088698f,
+		0.473826f,
+		-0.132745f,
+		0.000000f,
+		-0.179100f,
+		0.946600f,
+		-0.268000f,
+		0.843800f,
+		0.896600f,
+		-0.116639f,
+		0.453788f,
+		-0.174562f,
+		0.000000f,
+		-0.234800f,
+		0.906300f,
+		-0.351400f,
+		0.843800f,
+		0.862100f,
+		-0.328443f,
+		-0.185069f,
+		-0.328443f,
+		0.000000f,
+		-0.657200f,
+		-0.369000f,
+		-0.657200f,
+		0.875000f,
+		0.379300f,
+		-0.340667f,
+		-0.133764f,
+		-0.340666f,
+		0.000000f,
+		-0.681500f,
+		-0.266600f,
+		-0.681500f,
+		0.875000f,
+		0.413800f,
+		-0.267660f,
+		-0.133764f,
+		-0.400581f,
+		0.000000f,
+		-0.535400f,
+		-0.266600f,
+		-0.801400f,
+		0.843800f,
+		0.413800f,
+		-0.328443f,
+		-0.185069f,
+		-0.328443f,
+		0.000000f,
+		-0.657200f,
+		-0.369000f,
+		-0.657200f,
+		0.875000f,
+		0.379300f,
+		-0.267660f,
+		-0.133764f,
+		-0.400581f,
+		0.000000f,
+		-0.535400f,
+		-0.266600f,
+		-0.801400f,
+		0.843800f,
+		0.413800f,
+		-0.258056f,
+		-0.185069f,
+		-0.386207f,
+		0.000000f,
+		-0.516300f,
+		-0.369000f,
+		-0.772800f,
+		0.843800f,
+		0.379300f,
+		-0.182276f,
+		0.428429f,
+		-0.182276f,
+		0.000000f,
+		-0.366300f,
+		0.855300f,
+		-0.366300f,
+		0.875000f,
+		0.827600f,
+		-0.148454f,
+		0.453788f,
+		-0.148453f,
+		0.000000f,
+		-0.298900f,
+		0.906300f,
+		-0.298900f,
+		0.875000f,
+		0.862100f,
+		-0.116639f,
+		0.453788f,
+		-0.174562f,
+		0.000000f,
+		-0.234800f,
+		0.906300f,
+		-0.351400f,
+		0.843800f,
+		0.862100f,
+		-0.182276f,
+		0.428429f,
+		-0.182276f,
+		0.000000f,
+		-0.366300f,
+		0.855300f,
+		-0.366300f,
+		0.875000f,
+		0.827600f,
+		-0.116639f,
+		0.453788f,
+		-0.174562f,
+		0.000000f,
+		-0.234800f,
+		0.906300f,
+		-0.351400f,
+		0.843800f,
+		0.862100f,
+		-0.143213f,
+		0.428429f,
+		-0.214334f,
+		0.000000f,
+		-0.287800f,
+		0.855300f,
+		-0.430700f,
+		0.843800f,
+		0.827600f,
+		-0.312369f,
+		-0.234204f,
+		-0.312369f,
+		0.000000f,
+		-0.625200f,
+		-0.467000f,
+		-0.625200f,
+		0.875000f,
+		0.344800f,
+		-0.328443f,
+		-0.185069f,
+		-0.328443f,
+		0.000000f,
+		-0.657200f,
+		-0.369000f,
+		-0.657200f,
+		0.875000f,
+		0.379300f,
+		-0.258056f,
+		-0.185069f,
+		-0.386207f,
+		0.000000f,
+		-0.516300f,
+		-0.369000f,
+		-0.772800f,
+		0.843800f,
+		0.379300f,
+		-0.312369f,
+		-0.234204f,
+		-0.312369f,
+		0.000000f,
+		-0.625200f,
+		-0.467000f,
+		-0.625200f,
+		0.875000f,
+		0.344800f,
+		-0.258056f,
+		-0.185069f,
+		-0.386207f,
+		0.000000f,
+		-0.516300f,
+		-0.369000f,
+		-0.772800f,
+		0.843800f,
+		0.379300f,
+		-0.245427f,
+		-0.234204f,
+		-0.367307f,
+		0.000000f,
+		-0.491300f,
+		-0.467000f,
+		-0.735200f,
+		0.843800f,
+		0.344800f,
+		-0.213961f,
+		0.398046f,
+		-0.213961f,
+		0.000000f,
+		-0.429400f,
+		0.794500f,
+		-0.429400f,
+		0.875000f,
+		0.793100f,
+		-0.182276f,
+		0.428429f,
+		-0.182276f,
+		0.000000f,
+		-0.366300f,
+		0.855300f,
+		-0.366300f,
+		0.875000f,
+		0.827600f,
+		-0.143213f,
+		0.428429f,
+		-0.214334f,
+		0.000000f,
+		-0.287800f,
+		0.855300f,
+		-0.430700f,
+		0.843800f,
+		0.827600f,
+		-0.213961f,
+		0.398046f,
+		-0.213961f,
+		0.000000f,
+		-0.429400f,
+		0.794500f,
+		-0.429400f,
+		0.875000f,
+		0.793100f,
+		-0.143213f,
+		0.428429f,
+		-0.214334f,
+		0.000000f,
+		-0.287800f,
+		0.855300f,
+		-0.430700f,
+		0.843800f,
+		0.827600f,
+		-0.168108f,
+		0.398046f,
+		-0.251592f,
+		0.000000f,
+		-0.337400f,
+		0.794500f,
+		-0.504900f,
+		0.843800f,
+		0.793100f,
+		-0.292632f,
+		-0.280594f,
+		-0.292632f,
+		0.000000f,
+		-0.586000f,
+		-0.559600f,
+		-0.586000f,
+		0.875000f,
+		0.310300f,
+		-0.312369f,
+		-0.234204f,
+		-0.312369f,
+		0.000000f,
+		-0.625200f,
+		-0.467000f,
+		-0.625200f,
+		0.875000f,
+		0.344800f,
+		-0.245427f,
+		-0.234204f,
+		-0.367307f,
+		0.000000f,
+		-0.491300f,
+		-0.467000f,
+		-0.735200f,
+		0.843800f,
+		0.344800f,
+		-0.292632f,
+		-0.280594f,
+		-0.292632f,
+		0.000000f,
+		-0.586000f,
+		-0.559600f,
+		-0.586000f,
+		0.875000f,
+		0.310300f,
+		-0.245427f,
+		-0.234204f,
+		-0.367307f,
+		0.000000f,
+		-0.491300f,
+		-0.467000f,
+		-0.735200f,
+		0.843800f,
+		0.344800f,
+		-0.229920f,
+		-0.280594f,
+		-0.344099f,
+		0.000000f,
+		-0.460400f,
+		-0.559600f,
+		-0.689100f,
+		0.843800f,
+		0.310300f,
+		-0.243139f,
+		0.362998f,
+		-0.243138f,
+		0.000000f,
+		-0.487500f,
+		0.724300f,
+		-0.487500f,
+		0.875000f,
+		0.758600f,
+		-0.213961f,
+		0.398046f,
+		-0.213961f,
+		0.000000f,
+		-0.429400f,
+		0.794500f,
+		-0.429400f,
+		0.875000f,
+		0.793100f,
+		-0.168108f,
+		0.398046f,
+		-0.251592f,
+		0.000000f,
+		-0.337400f,
+		0.794500f,
+		-0.504900f,
+		0.843800f,
+		0.793100f,
+		-0.243139f,
+		0.362998f,
+		-0.243138f,
+		0.000000f,
+		-0.487500f,
+		0.724300f,
+		-0.487500f,
+		0.875000f,
+		0.758600f,
+		-0.168108f,
+		0.398046f,
+		-0.251592f,
+		0.000000f,
+		-0.337400f,
+		0.794500f,
+		-0.504900f,
+		0.843800f,
+		0.793100f,
+		-0.191033f,
+		0.362998f,
+		-0.285900f,
+		0.000000f,
+		-0.383000f,
+		0.724300f,
+		-0.573300f,
+		0.843800f,
+		0.758600f,
+		-0.269465f,
+		-0.323693f,
+		-0.269464f,
+		0.000000f,
+		-0.539900f,
+		-0.645700f,
+		-0.539900f,
+		0.875000f,
+		0.275900f,
+		-0.292632f,
+		-0.280594f,
+		-0.292632f,
+		0.000000f,
+		-0.586000f,
+		-0.559600f,
+		-0.586000f,
+		0.875000f,
+		0.310300f,
+		-0.229920f,
+		-0.280594f,
+		-0.344099f,
+		0.000000f,
+		-0.460400f,
+		-0.559600f,
+		-0.689100f,
+		0.843800f,
+		0.310300f,
+		-0.269465f,
+		-0.323693f,
+		-0.269464f,
+		0.000000f,
+		-0.539900f,
+		-0.645700f,
+		-0.539900f,
+		0.875000f,
+		0.275900f,
+		-0.229920f,
+		-0.280594f,
+		-0.344099f,
+		0.000000f,
+		-0.460400f,
+		-0.559600f,
+		-0.689100f,
+		0.843800f,
+		0.310300f,
+		-0.211718f,
+		-0.323693f,
+		-0.316857f,
+		0.000000f,
+		-0.424200f,
+		-0.645700f,
+		-0.634900f,
+		0.843800f,
+		0.275900f,
+		-0.269465f,
+		0.323693f,
+		-0.269464f,
+		0.000000f,
+		-0.539900f,
+		0.645700f,
+		-0.539900f,
+		0.875000f,
+		0.724100f,
+		-0.243139f,
+		0.362998f,
+		-0.243138f,
+		0.000000f,
+		-0.487500f,
+		0.724300f,
+		-0.487500f,
+		0.875000f,
+		0.758600f,
+		-0.191033f,
+		0.362998f,
+		-0.285900f,
+		0.000000f,
+		-0.383000f,
+		0.724300f,
+		-0.573300f,
+		0.843800f,
+		0.758600f,
+		-0.269465f,
+		0.323693f,
+		-0.269464f,
+		0.000000f,
+		-0.539900f,
+		0.645700f,
+		-0.539900f,
+		0.875000f,
+		0.724100f,
+		-0.191033f,
+		0.362998f,
+		-0.285900f,
+		0.000000f,
+		-0.383000f,
+		0.724300f,
+		-0.573300f,
+		0.843800f,
+		0.758600f,
+		-0.211718f,
+		0.323693f,
+		-0.316857f,
+		0.000000f,
+		-0.424200f,
+		0.645700f,
+		-0.634900f,
+		0.843800f,
+		0.724100f,
+		-0.243139f,
+		-0.362998f,
+		-0.243138f,
+		0.000000f,
+		-0.487500f,
+		-0.724300f,
+		-0.487500f,
+		0.875000f,
+		0.241400f,
+		-0.269465f,
+		-0.323693f,
+		-0.269464f,
+		0.000000f,
+		-0.539900f,
+		-0.645700f,
+		-0.539900f,
+		0.875000f,
+		0.275900f,
+		-0.211718f,
+		-0.323693f,
+		-0.316857f,
+		0.000000f,
+		-0.424200f,
+		-0.645700f,
+		-0.634900f,
+		0.843800f,
+		0.275900f,
+		-0.243139f,
+		-0.362998f,
+		-0.243138f,
+		0.000000f,
+		-0.487500f,
+		-0.724300f,
+		-0.487500f,
+		0.875000f,
+		0.241400f,
+		-0.211718f,
+		-0.323693f,
+		-0.316857f,
+		0.000000f,
+		-0.424200f,
+		-0.645700f,
+		-0.634900f,
+		0.843800f,
+		0.275900f,
+		-0.191033f,
+		-0.362998f,
+		-0.285901f,
+		0.000000f,
+		-0.383000f,
+		-0.724300f,
+		-0.573300f,
+		0.843800f,
+		0.241400f,
+		-0.292632f,
+		0.280594f,
+		-0.292632f,
+		0.000000f,
+		-0.586000f,
+		0.559600f,
+		-0.586000f,
+		0.875000f,
+		0.689700f,
+		-0.269465f,
+		0.323693f,
+		-0.269464f,
+		0.000000f,
+		-0.539900f,
+		0.645700f,
+		-0.539900f,
+		0.875000f,
+		0.724100f,
+		-0.211718f,
+		0.323693f,
+		-0.316857f,
+		0.000000f,
+		-0.424200f,
+		0.645700f,
+		-0.634900f,
+		0.843800f,
+		0.724100f,
+		-0.292632f,
+		0.280594f,
+		-0.292632f,
+		0.000000f,
+		-0.586000f,
+		0.559600f,
+		-0.586000f,
+		0.875000f,
+		0.689700f,
+		-0.211718f,
+		0.323693f,
+		-0.316857f,
+		0.000000f,
+		-0.424200f,
+		0.645700f,
+		-0.634900f,
+		0.843800f,
+		0.724100f,
+		-0.229920f,
+		0.280594f,
+		-0.344099f,
+		0.000000f,
+		-0.460400f,
+		0.559600f,
+		-0.689100f,
+		0.843800f,
+		0.689700f,
+		-0.213961f,
+		-0.398046f,
+		-0.213961f,
+		0.000000f,
+		-0.429400f,
+		-0.794500f,
+		-0.429400f,
+		0.875000f,
+		0.206900f,
+		-0.243139f,
+		-0.362998f,
+		-0.243138f,
+		0.000000f,
+		-0.487500f,
+		-0.724300f,
+		-0.487500f,
+		0.875000f,
+		0.241400f,
+		-0.191033f,
+		-0.362998f,
+		-0.285901f,
+		0.000000f,
+		-0.383000f,
+		-0.724300f,
+		-0.573300f,
+		0.843800f,
+		0.241400f,
+		-0.213961f,
+		-0.398046f,
+		-0.213961f,
+		0.000000f,
+		-0.429400f,
+		-0.794500f,
+		-0.429400f,
+		0.875000f,
+		0.206900f,
+		-0.191033f,
+		-0.362998f,
+		-0.285901f,
+		0.000000f,
+		-0.383000f,
+		-0.724300f,
+		-0.573300f,
+		0.843800f,
+		0.241400f,
+		-0.168108f,
+		-0.398046f,
+		-0.251592f,
+		0.000000f,
+		-0.337400f,
+		-0.794500f,
+		-0.505000f,
+		0.843800f,
+		0.206900f,
+		-0.312369f,
+		0.234204f,
+		-0.312369f,
+		0.000000f,
+		-0.625200f,
+		0.467000f,
+		-0.625200f,
+		0.875000f,
+		0.655200f,
+		-0.292632f,
+		0.280594f,
+		-0.292632f,
+		0.000000f,
+		-0.586000f,
+		0.559600f,
+		-0.586000f,
+		0.875000f,
+		0.689700f,
+		-0.229920f,
+		0.280594f,
+		-0.344099f,
+		0.000000f,
+		-0.460400f,
+		0.559600f,
+		-0.689100f,
+		0.843800f,
+		0.689700f,
+		-0.312369f,
+		0.234204f,
+		-0.312369f,
+		0.000000f,
+		-0.625200f,
+		0.467000f,
+		-0.625200f,
+		0.875000f,
+		0.655200f,
+		-0.229920f,
+		0.280594f,
+		-0.344099f,
+		0.000000f,
+		-0.460400f,
+		0.559600f,
+		-0.689100f,
+		0.843800f,
+		0.689700f,
+		-0.245427f,
+		0.234204f,
+		-0.367307f,
+		0.000000f,
+		-0.491300f,
+		0.467000f,
+		-0.735200f,
+		0.843800f,
+		0.655200f,
+		-0.182276f,
+		-0.428429f,
+		-0.182276f,
+		0.000000f,
+		-0.366300f,
+		-0.855300f,
+		-0.366300f,
+		0.875000f,
+		0.172400f,
+		-0.213961f,
+		-0.398046f,
+		-0.213961f,
+		0.000000f,
+		-0.429400f,
+		-0.794500f,
+		-0.429400f,
+		0.875000f,
+		0.206900f,
+		-0.168108f,
+		-0.398046f,
+		-0.251592f,
+		0.000000f,
+		-0.337400f,
+		-0.794500f,
+		-0.505000f,
+		0.843800f,
+		0.206900f,
+		-0.182276f,
+		-0.428429f,
+		-0.182276f,
+		0.000000f,
+		-0.366300f,
+		-0.855300f,
+		-0.366300f,
+		0.875000f,
+		0.172400f,
+		-0.168108f,
+		-0.398046f,
+		-0.251592f,
+		0.000000f,
+		-0.337400f,
+		-0.794500f,
+		-0.505000f,
+		0.843800f,
+		0.206900f,
+		-0.143213f,
+		-0.428429f,
+		-0.214334f,
+		0.000000f,
+		-0.287800f,
+		-0.855300f,
+		-0.430700f,
+		0.843800f,
+		0.172400f,
+		-0.245427f,
+		-0.234204f,
+		-0.367307f,
+		0.000000f,
+		-0.491300f,
+		-0.467000f,
+		-0.735200f,
+		0.843800f,
+		0.344800f,
+		-0.258056f,
+		-0.185069f,
+		-0.386207f,
+		0.000000f,
+		-0.516300f,
+		-0.369000f,
+		-0.772800f,
+		0.843800f,
+		0.379300f,
+		-0.177752f,
+		-0.185069f,
+		-0.429131f,
+		0.000000f,
+		-0.355700f,
+		-0.369000f,
+		-0.858700f,
+		0.812500f,
+		0.379300f,
+		-0.245427f,
+		-0.234204f,
+		-0.367307f,
+		0.000000f,
+		-0.491300f,
+		-0.467000f,
+		-0.735200f,
+		0.843800f,
+		0.344800f,
+		-0.177752f,
+		-0.185069f,
+		-0.429131f,
+		0.000000f,
+		-0.355700f,
+		-0.369000f,
+		-0.858700f,
+		0.812500f,
+		0.379300f,
+		-0.169053f,
+		-0.234204f,
+		-0.408129f,
+		0.000000f,
+		-0.338400f,
+		-0.467000f,
+		-0.816900f,
+		0.812500f,
+		0.344800f,
+		-0.168108f,
+		0.398046f,
+		-0.251592f,
+		0.000000f,
+		-0.337400f,
+		0.794500f,
+		-0.504900f,
+		0.843800f,
+		0.793100f,
+		-0.143213f,
+		0.428429f,
+		-0.214334f,
+		0.000000f,
+		-0.287800f,
+		0.855300f,
+		-0.430700f,
+		0.843800f,
+		0.827600f,
+		-0.098647f,
+		0.428429f,
+		-0.238155f,
+		0.000000f,
+		-0.198200f,
+		0.855300f,
+		-0.478600f,
+		0.812500f,
+		0.827600f,
+		-0.168108f,
+		0.398046f,
+		-0.251592f,
+		0.000000f,
+		-0.337400f,
+		0.794500f,
+		-0.504900f,
+		0.843800f,
+		0.793100f,
+		-0.098647f,
+		0.428429f,
+		-0.238155f,
+		0.000000f,
+		-0.198200f,
+		0.855300f,
+		-0.478600f,
+		0.812500f,
+		0.827600f,
+		-0.115796f,
+		0.398046f,
+		-0.279554f,
+		0.000000f,
+		-0.232400f,
+		0.794500f,
+		-0.561100f,
+		0.812500f,
+		0.793100f,
+		-0.229920f,
+		-0.280594f,
+		-0.344099f,
+		0.000000f,
+		-0.460400f,
+		-0.559600f,
+		-0.689100f,
+		0.843800f,
+		0.310300f,
+		-0.245427f,
+		-0.234204f,
+		-0.367307f,
+		0.000000f,
+		-0.491300f,
+		-0.467000f,
+		-0.735200f,
+		0.843800f,
+		0.344800f,
+		-0.169053f,
+		-0.234204f,
+		-0.408129f,
+		0.000000f,
+		-0.338400f,
+		-0.467000f,
+		-0.816900f,
+		0.812500f,
+		0.344800f,
+		-0.229920f,
+		-0.280594f,
+		-0.344099f,
+		0.000000f,
+		-0.460400f,
+		-0.559600f,
+		-0.689100f,
+		0.843800f,
+		0.310300f,
+		-0.169053f,
+		-0.234204f,
+		-0.408129f,
+		0.000000f,
+		-0.338400f,
+		-0.467000f,
+		-0.816900f,
+		0.812500f,
+		0.344800f,
+		-0.158371f,
+		-0.280594f,
+		-0.382342f,
+		0.000000f,
+		-0.317100f,
+		-0.559600f,
+		-0.765600f,
+		0.812500f,
+		0.310300f,
+		-0.191033f,
+		0.362998f,
+		-0.285900f,
+		0.000000f,
+		-0.383000f,
+		0.724300f,
+		-0.573300f,
+		0.843800f,
+		0.758600f,
+		-0.168108f,
+		0.398046f,
+		-0.251592f,
+		0.000000f,
+		-0.337400f,
+		0.794500f,
+		-0.504900f,
+		0.843800f,
+		0.793100f,
+		-0.115796f,
+		0.398046f,
+		-0.279554f,
+		0.000000f,
+		-0.232400f,
+		0.794500f,
+		-0.561100f,
+		0.812500f,
+		0.793100f,
+		-0.191033f,
+		0.362998f,
+		-0.285900f,
+		0.000000f,
+		-0.383000f,
+		0.724300f,
+		-0.573300f,
+		0.843800f,
+		0.758600f,
+		-0.115796f,
+		0.398046f,
+		-0.279554f,
+		0.000000f,
+		-0.232400f,
+		0.794500f,
+		-0.561100f,
+		0.812500f,
+		0.793100f,
+		-0.131586f,
+		0.362998f,
+		-0.317676f,
+		0.000000f,
+		-0.263800f,
+		0.724300f,
+		-0.637000f,
+		0.812500f,
+		0.758600f,
+		-0.211718f,
+		-0.323693f,
+		-0.316857f,
+		0.000000f,
+		-0.424200f,
+		-0.645700f,
+		-0.634900f,
+		0.843800f,
+		0.275900f,
+		-0.229920f,
+		-0.280594f,
+		-0.344099f,
+		0.000000f,
+		-0.460400f,
+		-0.559600f,
+		-0.689100f,
+		0.843800f,
+		0.310300f,
+		-0.158371f,
+		-0.280594f,
+		-0.382342f,
+		0.000000f,
+		-0.317100f,
+		-0.559600f,
+		-0.765600f,
+		0.812500f,
+		0.310300f,
+		-0.211718f,
+		-0.323693f,
+		-0.316857f,
+		0.000000f,
+		-0.424200f,
+		-0.645700f,
+		-0.634900f,
+		0.843800f,
+		0.275900f,
+		-0.158371f,
+		-0.280594f,
+		-0.382342f,
+		0.000000f,
+		-0.317100f,
+		-0.559600f,
+		-0.765600f,
+		0.812500f,
+		0.310300f,
+		-0.145834f,
+		-0.323693f,
+		-0.352073f,
+		0.000000f,
+		-0.292200f,
+		-0.645700f,
+		-0.705400f,
+		0.812500f,
+		0.275900f,
+		-0.211718f,
+		0.323693f,
+		-0.316857f,
+		0.000000f,
+		-0.424200f,
+		0.645700f,
+		-0.634900f,
+		0.843800f,
+		0.724100f,
+		-0.191033f,
+		0.362998f,
+		-0.285900f,
+		0.000000f,
+		-0.383000f,
+		0.724300f,
+		-0.573300f,
+		0.843800f,
+		0.758600f,
+		-0.131586f,
+		0.362998f,
+		-0.317676f,
+		0.000000f,
+		-0.263800f,
+		0.724300f,
+		-0.637000f,
+		0.812500f,
+		0.758600f,
+		-0.211718f,
+		0.323693f,
+		-0.316857f,
+		0.000000f,
+		-0.424200f,
+		0.645700f,
+		-0.634900f,
+		0.843800f,
+		0.724100f,
+		-0.131586f,
+		0.362998f,
+		-0.317676f,
+		0.000000f,
+		-0.263800f,
+		0.724300f,
+		-0.637000f,
+		0.812500f,
+		0.758600f,
+		-0.145834f,
+		0.323693f,
+		-0.352073f,
+		0.000000f,
+		-0.292200f,
+		0.645700f,
+		-0.705400f,
+		0.812500f,
+		0.724100f,
+		-0.191033f,
+		-0.362998f,
+		-0.285901f,
+		0.000000f,
+		-0.383000f,
+		-0.724300f,
+		-0.573300f,
+		0.843800f,
+		0.241400f,
+		-0.211718f,
+		-0.323693f,
+		-0.316857f,
+		0.000000f,
+		-0.424200f,
+		-0.645700f,
+		-0.634900f,
+		0.843800f,
+		0.275900f,
+		-0.145834f,
+		-0.323693f,
+		-0.352073f,
+		0.000000f,
+		-0.292200f,
+		-0.645700f,
+		-0.705400f,
+		0.812500f,
+		0.275900f,
+		-0.191033f,
+		-0.362998f,
+		-0.285901f,
+		0.000000f,
+		-0.383000f,
+		-0.724300f,
+		-0.573300f,
+		0.843800f,
+		0.241400f,
+		-0.145834f,
+		-0.323693f,
+		-0.352073f,
+		0.000000f,
+		-0.292200f,
+		-0.645700f,
+		-0.705400f,
+		0.812500f,
+		0.275900f,
+		-0.131586f,
+		-0.362998f,
+		-0.317676f,
+		0.000000f,
+		-0.263800f,
+		-0.724300f,
+		-0.637000f,
+		0.812500f,
+		0.241400f,
+		-0.229920f,
+		0.280594f,
+		-0.344099f,
+		0.000000f,
+		-0.460400f,
+		0.559600f,
+		-0.689100f,
+		0.843800f,
+		0.689700f,
+		-0.211718f,
+		0.323693f,
+		-0.316857f,
+		0.000000f,
+		-0.424200f,
+		0.645700f,
+		-0.634900f,
+		0.843800f,
+		0.724100f,
+		-0.145834f,
+		0.323693f,
+		-0.352073f,
+		0.000000f,
+		-0.292200f,
+		0.645700f,
+		-0.705400f,
+		0.812500f,
+		0.724100f,
+		-0.229920f,
+		0.280594f,
+		-0.344099f,
+		0.000000f,
+		-0.460400f,
+		0.559600f,
+		-0.689100f,
+		0.843800f,
+		0.689700f,
+		-0.145834f,
+		0.323693f,
+		-0.352073f,
+		0.000000f,
+		-0.292200f,
+		0.645700f,
+		-0.705400f,
+		0.812500f,
+		0.724100f,
+		-0.158371f,
+		0.280594f,
+		-0.382342f,
+		0.000000f,
+		-0.317100f,
+		0.559600f,
+		-0.765600f,
+		0.812500f,
+		0.689700f,
+		-0.168108f,
+		-0.398046f,
+		-0.251592f,
+		0.000000f,
+		-0.337400f,
+		-0.794500f,
+		-0.505000f,
+		0.843800f,
+		0.206900f,
+		-0.191033f,
+		-0.362998f,
+		-0.285901f,
+		0.000000f,
+		-0.383000f,
+		-0.724300f,
+		-0.573300f,
+		0.843800f,
+		0.241400f,
+		-0.131586f,
+		-0.362998f,
+		-0.317676f,
+		0.000000f,
+		-0.263800f,
+		-0.724300f,
+		-0.637000f,
+		0.812500f,
+		0.241400f,
+		-0.168108f,
+		-0.398046f,
+		-0.251592f,
+		0.000000f,
+		-0.337400f,
+		-0.794500f,
+		-0.505000f,
+		0.843800f,
+		0.206900f,
+		-0.131586f,
+		-0.362998f,
+		-0.317676f,
+		0.000000f,
+		-0.263800f,
+		-0.724300f,
+		-0.637000f,
+		0.812500f,
+		0.241400f,
+		-0.115796f,
+		-0.398046f,
+		-0.279554f,
+		0.000000f,
+		-0.232400f,
+		-0.794500f,
+		-0.561100f,
+		0.812500f,
+		0.206900f,
+		-0.245427f,
+		0.234204f,
+		-0.367307f,
+		0.000000f,
+		-0.491300f,
+		0.467000f,
+		-0.735200f,
+		0.843800f,
+		0.655200f,
+		-0.229920f,
+		0.280594f,
+		-0.344099f,
+		0.000000f,
+		-0.460400f,
+		0.559600f,
+		-0.689100f,
+		0.843800f,
+		0.689700f,
+		-0.158371f,
+		0.280594f,
+		-0.382342f,
+		0.000000f,
+		-0.317100f,
+		0.559600f,
+		-0.765600f,
+		0.812500f,
+		0.689700f,
+		-0.245427f,
+		0.234204f,
+		-0.367307f,
+		0.000000f,
+		-0.491300f,
+		0.467000f,
+		-0.735200f,
+		0.843800f,
+		0.655200f,
+		-0.158371f,
+		0.280594f,
+		-0.382342f,
+		0.000000f,
+		-0.317100f,
+		0.559600f,
+		-0.765600f,
+		0.812500f,
+		0.689700f,
+		-0.169053f,
+		0.234204f,
+		-0.408129f,
+		0.000000f,
+		-0.338400f,
+		0.467000f,
+		-0.816900f,
+		0.812500f,
+		0.655200f,
+		-0.143213f,
+		-0.428429f,
+		-0.214334f,
+		0.000000f,
+		-0.287800f,
+		-0.855300f,
+		-0.430700f,
+		0.843800f,
+		0.172400f,
+		-0.168108f,
+		-0.398046f,
+		-0.251592f,
+		0.000000f,
+		-0.337400f,
+		-0.794500f,
+		-0.505000f,
+		0.843800f,
+		0.206900f,
+		-0.115796f,
+		-0.398046f,
+		-0.279554f,
+		0.000000f,
+		-0.232400f,
+		-0.794500f,
+		-0.561100f,
+		0.812500f,
+		0.206900f,
+		-0.143213f,
+		-0.428429f,
+		-0.214334f,
+		0.000000f,
+		-0.287800f,
+		-0.855300f,
+		-0.430700f,
+		0.843800f,
+		0.172400f,
+		-0.115796f,
+		-0.398046f,
+		-0.279554f,
+		0.000000f,
+		-0.232400f,
+		-0.794500f,
+		-0.561100f,
+		0.812500f,
+		0.206900f,
+		-0.098647f,
+		-0.428429f,
+		-0.238155f,
+		0.000000f,
+		-0.198200f,
+		-0.855300f,
+		-0.478600f,
+		0.812500f,
+		0.172400f,
+		-0.258056f,
+		0.185069f,
+		-0.386207f,
+		0.000000f,
+		-0.516300f,
+		0.369000f,
+		-0.772800f,
+		0.843800f,
+		0.620700f,
+		-0.245427f,
+		0.234204f,
+		-0.367307f,
+		0.000000f,
+		-0.491300f,
+		0.467000f,
+		-0.735200f,
+		0.843800f,
+		0.655200f,
+		-0.169053f,
+		0.234204f,
+		-0.408129f,
+		0.000000f,
+		-0.338400f,
+		0.467000f,
+		-0.816900f,
+		0.812500f,
+		0.655200f,
+		-0.258056f,
+		0.185069f,
+		-0.386207f,
+		0.000000f,
+		-0.516300f,
+		0.369000f,
+		-0.772800f,
+		0.843800f,
+		0.620700f,
+		-0.169053f,
+		0.234204f,
+		-0.408129f,
+		0.000000f,
+		-0.338400f,
+		0.467000f,
+		-0.816900f,
+		0.812500f,
+		0.655200f,
+		-0.177752f,
+		0.185069f,
+		-0.429131f,
+		0.000000f,
+		-0.355700f,
+		0.369000f,
+		-0.858700f,
+		0.812500f,
+		0.620700f,
+		-0.116640f,
+		-0.453788f,
+		-0.174562f,
+		0.000000f,
+		-0.234800f,
+		-0.906300f,
+		-0.351400f,
+		0.843800f,
+		0.137900f,
+		-0.143213f,
+		-0.428429f,
+		-0.214334f,
+		0.000000f,
+		-0.287800f,
+		-0.855300f,
+		-0.430700f,
+		0.843800f,
+		0.172400f,
+		-0.098647f,
+		-0.428429f,
+		-0.238155f,
+		0.000000f,
+		-0.198200f,
+		-0.855300f,
+		-0.478600f,
+		0.812500f,
+		0.172400f,
+		-0.116640f,
+		-0.453788f,
+		-0.174562f,
+		0.000000f,
+		-0.234800f,
+		-0.906300f,
+		-0.351400f,
+		0.843800f,
+		0.137900f,
+		-0.098647f,
+		-0.428429f,
+		-0.238155f,
+		0.000000f,
+		-0.198200f,
+		-0.855300f,
+		-0.478600f,
+		0.812500f,
+		0.172400f,
+		-0.080343f,
+		-0.453788f,
+		-0.193963f,
+		0.000000f,
+		-0.161700f,
+		-0.906300f,
+		-0.390500f,
+		0.812500f,
+		0.137900f,
+		-0.267660f,
+		0.133764f,
+		-0.400581f,
+		0.000000f,
+		-0.535400f,
+		0.266600f,
+		-0.801400f,
+		0.843800f,
+		0.586200f,
+		-0.258056f,
+		0.185069f,
+		-0.386207f,
+		0.000000f,
+		-0.516300f,
+		0.369000f,
+		-0.772800f,
+		0.843800f,
+		0.620700f,
+		-0.177752f,
+		0.185069f,
+		-0.429131f,
+		0.000000f,
+		-0.355700f,
+		0.369000f,
+		-0.858700f,
+		0.812500f,
+		0.620700f,
+		-0.267660f,
+		0.133764f,
+		-0.400581f,
+		0.000000f,
+		-0.535400f,
+		0.266600f,
+		-0.801400f,
+		0.843800f,
+		0.586200f,
+		-0.177752f,
+		0.185069f,
+		-0.429131f,
+		0.000000f,
+		-0.355700f,
+		0.369000f,
+		-0.858700f,
+		0.812500f,
+		0.620700f,
+		-0.184367f,
+		0.133764f,
+		-0.445101f,
+		0.000000f,
+		-0.368800f,
+		0.266600f,
+		-0.890400f,
+		0.812500f,
+		0.586200f,
+		-0.088698f,
+		-0.473826f,
+		-0.132745f,
+		0.000000f,
+		-0.179100f,
+		-0.946600f,
+		-0.268000f,
+		0.843800f,
+		0.103400f,
+		-0.116640f,
+		-0.453788f,
+		-0.174562f,
+		0.000000f,
+		-0.234800f,
+		-0.906300f,
+		-0.351400f,
+		0.843800f,
+		0.137900f,
+		-0.080343f,
+		-0.453788f,
+		-0.193963f,
+		0.000000f,
+		-0.161700f,
+		-0.906300f,
+		-0.390500f,
+		0.812500f,
+		0.137900f,
+		-0.088698f,
+		-0.473826f,
+		-0.132745f,
+		0.000000f,
+		-0.179100f,
+		-0.946600f,
+		-0.268000f,
+		0.843800f,
+		0.103400f,
+		-0.080343f,
+		-0.453788f,
+		-0.193963f,
+		0.000000f,
+		-0.161700f,
+		-0.906300f,
+		-0.390500f,
+		0.812500f,
+		0.137900f,
+		-0.061096f,
+		-0.473826f,
+		-0.147498f,
+		0.000000f,
+		-0.123300f,
+		-0.946600f,
+		-0.297800f,
+		0.812500f,
+		0.103400f,
+		-0.274126f,
+		0.080891f,
+		-0.410257f,
+		0.000000f,
+		-0.548300f,
+		0.161200f,
+		-0.820600f,
+		0.843800f,
+		0.551700f,
+		-0.267660f,
+		0.133764f,
+		-0.400581f,
+		0.000000f,
+		-0.535400f,
+		0.266600f,
+		-0.801400f,
+		0.843800f,
+		0.586200f,
+		-0.184367f,
+		0.133764f,
+		-0.445101f,
+		0.000000f,
+		-0.368800f,
+		0.266600f,
+		-0.890400f,
+		0.812500f,
+		0.586200f,
+		-0.274126f,
+		0.080891f,
+		-0.410257f,
+		0.000000f,
+		-0.548300f,
+		0.161200f,
+		-0.820600f,
+		0.843800f,
+		0.551700f,
+		-0.184367f,
+		0.133764f,
+		-0.445101f,
+		0.000000f,
+		-0.368800f,
+		0.266600f,
+		-0.890400f,
+		0.812500f,
+		0.586200f,
+		-0.188821f,
+		0.080891f,
+		-0.455854f,
+		0.000000f,
+		-0.377700f,
+		0.161200f,
+		-0.911800f,
+		0.812500f,
+		0.551700f,
+		-0.059716f,
+		-0.488310f,
+		-0.089370f,
+		0.000000f,
+		-0.121200f,
+		-0.975900f,
+		-0.181400f,
+		0.843800f,
+		0.069000f,
+		-0.088698f,
+		-0.473826f,
+		-0.132745f,
+		0.000000f,
+		-0.179100f,
+		-0.946600f,
+		-0.268000f,
+		0.843800f,
+		0.103400f,
+		-0.061096f,
+		-0.473826f,
+		-0.147498f,
+		0.000000f,
+		-0.123300f,
+		-0.946600f,
+		-0.297800f,
+		0.812500f,
+		0.103400f,
+		-0.059716f,
+		-0.488310f,
+		-0.089370f,
+		0.000000f,
+		-0.121200f,
+		-0.975900f,
+		-0.181400f,
+		0.843800f,
+		0.069000f,
+		-0.061096f,
+		-0.473826f,
+		-0.147498f,
+		0.000000f,
+		-0.123300f,
+		-0.946600f,
+		-0.297800f,
+		0.812500f,
+		0.103400f,
+		-0.041133f,
+		-0.488310f,
+		-0.099303f,
+		0.000000f,
+		-0.083500f,
+		-0.975900f,
+		-0.201600f,
+		0.812500f,
+		0.069000f,
+		-0.277378f,
+		0.027069f,
+		-0.415125f,
+		0.000000f,
+		-0.554700f,
+		0.054000f,
+		-0.830300f,
+		0.843800f,
+		0.517200f,
+		-0.274126f,
+		0.080891f,
+		-0.410257f,
+		0.000000f,
+		-0.548300f,
+		0.161200f,
+		-0.820600f,
+		0.843800f,
+		0.551700f,
+		-0.188821f,
+		0.080891f,
+		-0.455854f,
+		0.000000f,
+		-0.377700f,
+		0.161200f,
+		-0.911800f,
+		0.812500f,
+		0.551700f,
+		-0.277378f,
+		0.027069f,
+		-0.415125f,
+		0.000000f,
+		-0.554700f,
+		0.054000f,
+		-0.830300f,
+		0.843800f,
+		0.517200f,
+		-0.188821f,
+		0.080891f,
+		-0.455854f,
+		0.000000f,
+		-0.377700f,
+		0.161200f,
+		-0.911800f,
+		0.812500f,
+		0.551700f,
+		-0.191061f,
+		0.027069f,
+		-0.461262f,
+		0.000000f,
+		-0.382100f,
+		0.054000f,
+		-0.922500f,
+		0.812500f,
+		0.517200f,
+		-0.030034f,
+		0.497069f,
+		-0.044948f,
+		0.000000f,
+		-0.061900f,
+		0.993700f,
+		-0.092700f,
+		0.436200f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.423900f,
+		0.960300f,
+		-0.020688f,
+		0.497069f,
+		-0.049944f,
+		0.000000f,
+		-0.042600f,
+		0.993700f,
+		-0.103000f,
+		0.438100f,
+		0.962300f,
+		-0.030034f,
+		-0.497069f,
+		-0.044949f,
+		0.000000f,
+		-0.061900f,
+		-0.993700f,
+		-0.092700f,
+		0.843800f,
+		0.034500f,
+		-0.059716f,
+		-0.488310f,
+		-0.089370f,
+		0.000000f,
+		-0.121200f,
+		-0.975900f,
+		-0.181400f,
+		0.843800f,
+		0.069000f,
+		-0.041133f,
+		-0.488310f,
+		-0.099303f,
+		0.000000f,
+		-0.083500f,
+		-0.975900f,
+		-0.201600f,
+		0.812500f,
+		0.069000f,
+		-0.030034f,
+		-0.497069f,
+		-0.044949f,
+		0.000000f,
+		-0.061900f,
+		-0.993700f,
+		-0.092700f,
+		0.843800f,
+		0.034500f,
+		-0.041133f,
+		-0.488310f,
+		-0.099303f,
+		0.000000f,
+		-0.083500f,
+		-0.975900f,
+		-0.201600f,
+		0.812500f,
+		0.069000f,
+		-0.020688f,
+		-0.497069f,
+		-0.049945f,
+		0.000000f,
+		-0.042600f,
+		-0.993700f,
+		-0.103000f,
+		0.812500f,
+		0.034500f,
+		-0.277378f,
+		-0.027069f,
+		-0.415125f,
+		0.000000f,
+		-0.554700f,
+		-0.054000f,
+		-0.830300f,
+		0.843800f,
+		0.482800f,
+		-0.277378f,
+		0.027069f,
+		-0.415125f,
+		0.000000f,
+		-0.554700f,
+		0.054000f,
+		-0.830300f,
+		0.843800f,
+		0.517200f,
+		-0.191061f,
+		0.027069f,
+		-0.461262f,
+		0.000000f,
+		-0.382100f,
+		0.054000f,
+		-0.922500f,
+		0.812500f,
+		0.517200f,
+		-0.277378f,
+		-0.027069f,
+		-0.415125f,
+		0.000000f,
+		-0.554700f,
+		-0.054000f,
+		-0.830300f,
+		0.843800f,
+		0.482800f,
+		-0.191061f,
+		0.027069f,
+		-0.461262f,
+		0.000000f,
+		-0.382100f,
+		0.054000f,
+		-0.922500f,
+		0.812500f,
+		0.517200f,
+		-0.191061f,
+		-0.027069f,
+		-0.461262f,
+		0.000000f,
+		-0.382100f,
+		-0.054000f,
+		-0.922500f,
+		0.812500f,
+		0.482800f,
+		-0.059716f,
+		0.488310f,
+		-0.089370f,
+		0.000000f,
+		-0.121200f,
+		0.975900f,
+		-0.181400f,
+		0.843800f,
+		0.931000f,
+		-0.030034f,
+		0.497069f,
+		-0.044948f,
+		0.000000f,
+		-0.061900f,
+		0.993700f,
+		-0.092700f,
+		0.843800f,
+		0.965500f,
+		-0.020688f,
+		0.497069f,
+		-0.049944f,
+		0.000000f,
+		-0.042600f,
+		0.993700f,
+		-0.103000f,
+		0.812500f,
+		0.965500f,
+		-0.059716f,
+		0.488310f,
+		-0.089370f,
+		0.000000f,
+		-0.121200f,
+		0.975900f,
+		-0.181400f,
+		0.843800f,
+		0.931000f,
+		-0.020688f,
+		0.497069f,
+		-0.049944f,
+		0.000000f,
+		-0.042600f,
+		0.993700f,
+		-0.103000f,
+		0.812500f,
+		0.965500f,
+		-0.041133f,
+		0.488310f,
+		-0.099303f,
+		0.000000f,
+		-0.083500f,
+		0.975900f,
+		-0.201600f,
+		0.812500f,
+		0.931000f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.495500f,
+		0.051000f,
+		-0.030034f,
+		-0.497069f,
+		-0.044949f,
+		0.000000f,
+		-0.061900f,
+		-0.993700f,
+		-0.092700f,
+		0.481100f,
+		0.053800f,
+		-0.020688f,
+		-0.497069f,
+		-0.049945f,
+		0.000000f,
+		-0.042600f,
+		-0.993700f,
+		-0.103000f,
+		0.478500f,
+		0.053800f,
+		-0.274126f,
+		-0.080891f,
+		-0.410257f,
+		0.000000f,
+		-0.548300f,
+		-0.161200f,
+		-0.820600f,
+		0.843800f,
+		0.448300f,
+		-0.277378f,
+		-0.027069f,
+		-0.415125f,
+		0.000000f,
+		-0.554700f,
+		-0.054000f,
+		-0.830300f,
+		0.843800f,
+		0.482800f,
+		-0.191061f,
+		-0.027069f,
+		-0.461262f,
+		0.000000f,
+		-0.382100f,
+		-0.054000f,
+		-0.922500f,
+		0.812500f,
+		0.482800f,
+		-0.274126f,
+		-0.080891f,
+		-0.410257f,
+		0.000000f,
+		-0.548300f,
+		-0.161200f,
+		-0.820600f,
+		0.843800f,
+		0.448300f,
+		-0.191061f,
+		-0.027069f,
+		-0.461262f,
+		0.000000f,
+		-0.382100f,
+		-0.054000f,
+		-0.922500f,
+		0.812500f,
+		0.482800f,
+		-0.188821f,
+		-0.080891f,
+		-0.455854f,
+		0.000000f,
+		-0.377700f,
+		-0.161200f,
+		-0.911800f,
+		0.812500f,
+		0.448300f,
+		-0.088698f,
+		0.473826f,
+		-0.132745f,
+		0.000000f,
+		-0.179100f,
+		0.946600f,
+		-0.268000f,
+		0.843800f,
+		0.896600f,
+		-0.059716f,
+		0.488310f,
+		-0.089370f,
+		0.000000f,
+		-0.121200f,
+		0.975900f,
+		-0.181400f,
+		0.843800f,
+		0.931000f,
+		-0.041133f,
+		0.488310f,
+		-0.099303f,
+		0.000000f,
+		-0.083500f,
+		0.975900f,
+		-0.201600f,
+		0.812500f,
+		0.931000f,
+		-0.088698f,
+		0.473826f,
+		-0.132745f,
+		0.000000f,
+		-0.179100f,
+		0.946600f,
+		-0.268000f,
+		0.843800f,
+		0.896600f,
+		-0.041133f,
+		0.488310f,
+		-0.099303f,
+		0.000000f,
+		-0.083500f,
+		0.975900f,
+		-0.201600f,
+		0.812500f,
+		0.931000f,
+		-0.061096f,
+		0.473826f,
+		-0.147498f,
+		0.000000f,
+		-0.123300f,
+		0.946600f,
+		-0.297800f,
+		0.812500f,
+		0.896600f,
+		-0.267660f,
+		-0.133764f,
+		-0.400581f,
+		0.000000f,
+		-0.535400f,
+		-0.266600f,
+		-0.801400f,
+		0.843800f,
+		0.413800f,
+		-0.274126f,
+		-0.080891f,
+		-0.410257f,
+		0.000000f,
+		-0.548300f,
+		-0.161200f,
+		-0.820600f,
+		0.843800f,
+		0.448300f,
+		-0.188821f,
+		-0.080891f,
+		-0.455854f,
+		0.000000f,
+		-0.377700f,
+		-0.161200f,
+		-0.911800f,
+		0.812500f,
+		0.448300f,
+		-0.267660f,
+		-0.133764f,
+		-0.400581f,
+		0.000000f,
+		-0.535400f,
+		-0.266600f,
+		-0.801400f,
+		0.843800f,
+		0.413800f,
+		-0.188821f,
+		-0.080891f,
+		-0.455854f,
+		0.000000f,
+		-0.377700f,
+		-0.161200f,
+		-0.911800f,
+		0.812500f,
+		0.448300f,
+		-0.184367f,
+		-0.133764f,
+		-0.445101f,
+		0.000000f,
+		-0.368800f,
+		-0.266600f,
+		-0.890400f,
+		0.812500f,
+		0.413800f,
+		-0.116639f,
+		0.453788f,
+		-0.174562f,
+		0.000000f,
+		-0.234800f,
+		0.906300f,
+		-0.351400f,
+		0.843800f,
+		0.862100f,
+		-0.088698f,
+		0.473826f,
+		-0.132745f,
+		0.000000f,
+		-0.179100f,
+		0.946600f,
+		-0.268000f,
+		0.843800f,
+		0.896600f,
+		-0.061096f,
+		0.473826f,
+		-0.147498f,
+		0.000000f,
+		-0.123300f,
+		0.946600f,
+		-0.297800f,
+		0.812500f,
+		0.896600f,
+		-0.116639f,
+		0.453788f,
+		-0.174562f,
+		0.000000f,
+		-0.234800f,
+		0.906300f,
+		-0.351400f,
+		0.843800f,
+		0.862100f,
+		-0.061096f,
+		0.473826f,
+		-0.147498f,
+		0.000000f,
+		-0.123300f,
+		0.946600f,
+		-0.297800f,
+		0.812500f,
+		0.896600f,
+		-0.080343f,
+		0.453788f,
+		-0.193963f,
+		0.000000f,
+		-0.161700f,
+		0.906300f,
+		-0.390500f,
+		0.812500f,
+		0.862100f,
+		-0.258056f,
+		-0.185069f,
+		-0.386207f,
+		0.000000f,
+		-0.516300f,
+		-0.369000f,
+		-0.772800f,
+		0.843800f,
+		0.379300f,
+		-0.267660f,
+		-0.133764f,
+		-0.400581f,
+		0.000000f,
+		-0.535400f,
+		-0.266600f,
+		-0.801400f,
+		0.843800f,
+		0.413800f,
+		-0.184367f,
+		-0.133764f,
+		-0.445101f,
+		0.000000f,
+		-0.368800f,
+		-0.266600f,
+		-0.890400f,
+		0.812500f,
+		0.413800f,
+		-0.258056f,
+		-0.185069f,
+		-0.386207f,
+		0.000000f,
+		-0.516300f,
+		-0.369000f,
+		-0.772800f,
+		0.843800f,
+		0.379300f,
+		-0.184367f,
+		-0.133764f,
+		-0.445101f,
+		0.000000f,
+		-0.368800f,
+		-0.266600f,
+		-0.890400f,
+		0.812500f,
+		0.413800f,
+		-0.177752f,
+		-0.185069f,
+		-0.429131f,
+		0.000000f,
+		-0.355700f,
+		-0.369000f,
+		-0.858700f,
+		0.812500f,
+		0.379300f,
+		-0.143213f,
+		0.428429f,
+		-0.214334f,
+		0.000000f,
+		-0.287800f,
+		0.855300f,
+		-0.430700f,
+		0.843800f,
+		0.827600f,
+		-0.116639f,
+		0.453788f,
+		-0.174562f,
+		0.000000f,
+		-0.234800f,
+		0.906300f,
+		-0.351400f,
+		0.843800f,
+		0.862100f,
+		-0.080343f,
+		0.453788f,
+		-0.193963f,
+		0.000000f,
+		-0.161700f,
+		0.906300f,
+		-0.390500f,
+		0.812500f,
+		0.862100f,
+		-0.143213f,
+		0.428429f,
+		-0.214334f,
+		0.000000f,
+		-0.287800f,
+		0.855300f,
+		-0.430700f,
+		0.843800f,
+		0.827600f,
+		-0.080343f,
+		0.453788f,
+		-0.193963f,
+		0.000000f,
+		-0.161700f,
+		0.906300f,
+		-0.390500f,
+		0.812500f,
+		0.862100f,
+		-0.098647f,
+		0.428429f,
+		-0.238155f,
+		0.000000f,
+		-0.198200f,
+		0.855300f,
+		-0.478600f,
+		0.812500f,
+		0.827600f,
+		-0.041133f,
+		-0.488310f,
+		-0.099303f,
+		0.000000f,
+		-0.083500f,
+		-0.975900f,
+		-0.201600f,
+		0.812500f,
+		0.069000f,
+		-0.061096f,
+		-0.473826f,
+		-0.147498f,
+		0.000000f,
+		-0.123300f,
+		-0.946600f,
+		-0.297800f,
+		0.812500f,
+		0.103400f,
+		-0.031147f,
+		-0.473826f,
+		-0.156583f,
+		0.000000f,
+		-0.062900f,
+		-0.946600f,
+		-0.316100f,
+		0.781300f,
+		0.103400f,
+		-0.041133f,
+		-0.488310f,
+		-0.099303f,
+		0.000000f,
+		-0.083500f,
+		-0.975900f,
+		-0.201600f,
+		0.812500f,
+		0.069000f,
+		-0.031147f,
+		-0.473826f,
+		-0.156583f,
+		0.000000f,
+		-0.062900f,
+		-0.946600f,
+		-0.316100f,
+		0.781300f,
+		0.103400f,
+		-0.020970f,
+		-0.488310f,
+		-0.105420f,
+		0.000000f,
+		-0.042500f,
+		-0.975900f,
+		-0.214000f,
+		0.781300f,
+		0.069000f,
+		-0.191061f,
+		0.027069f,
+		-0.461262f,
+		0.000000f,
+		-0.382100f,
+		0.054000f,
+		-0.922500f,
+		0.812500f,
+		0.517200f,
+		-0.188821f,
+		0.080891f,
+		-0.455854f,
+		0.000000f,
+		-0.377700f,
+		0.161200f,
+		-0.911800f,
+		0.812500f,
+		0.551700f,
+		-0.096261f,
+		0.080891f,
+		-0.483932f,
+		0.000000f,
+		-0.192500f,
+		0.161200f,
+		-0.967900f,
+		0.781300f,
+		0.551700f,
+		-0.191061f,
+		0.027069f,
+		-0.461262f,
+		0.000000f,
+		-0.382100f,
+		0.054000f,
+		-0.922500f,
+		0.812500f,
+		0.517200f,
+		-0.096261f,
+		0.080891f,
+		-0.483932f,
+		0.000000f,
+		-0.192500f,
+		0.161200f,
+		-0.967900f,
+		0.781300f,
+		0.551700f,
+		-0.097402f,
+		0.027069f,
+		-0.489673f,
+		0.000000f,
+		-0.194800f,
+		0.054000f,
+		-0.979300f,
+		0.781300f,
+		0.517200f,
+		-0.020688f,
+		0.497069f,
+		-0.049944f,
+		0.000000f,
+		-0.042600f,
+		0.993700f,
+		-0.103000f,
+		0.438100f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.423900f,
+		0.960300f,
+		-0.010547f,
+		0.497069f,
+		-0.053020f,
+		0.000000f,
+		-0.021700f,
+		0.993700f,
+		-0.109300f,
+		0.439900f,
+		0.962300f,
+		-0.020688f,
+		-0.497069f,
+		-0.049945f,
+		0.000000f,
+		-0.042600f,
+		-0.993700f,
+		-0.103000f,
+		0.812500f,
+		0.034500f,
+		-0.041133f,
+		-0.488310f,
+		-0.099303f,
+		0.000000f,
+		-0.083500f,
+		-0.975900f,
+		-0.201600f,
+		0.812500f,
+		0.069000f,
+		-0.020970f,
+		-0.488310f,
+		-0.105420f,
+		0.000000f,
+		-0.042500f,
+		-0.975900f,
+		-0.214000f,
+		0.781300f,
+		0.069000f,
+		-0.020688f,
+		-0.497069f,
+		-0.049945f,
+		0.000000f,
+		-0.042600f,
+		-0.993700f,
+		-0.103000f,
+		0.812500f,
+		0.034500f,
+		-0.020970f,
+		-0.488310f,
+		-0.105420f,
+		0.000000f,
+		-0.042500f,
+		-0.975900f,
+		-0.214000f,
+		0.781300f,
+		0.069000f,
+		-0.010547f,
+		-0.497069f,
+		-0.053020f,
+		0.000000f,
+		-0.021700f,
+		-0.993700f,
+		-0.109300f,
+		0.781300f,
+		0.034500f,
+		-0.191061f,
+		-0.027069f,
+		-0.461262f,
+		0.000000f,
+		-0.382100f,
+		-0.054000f,
+		-0.922500f,
+		0.812500f,
+		0.482800f,
+		-0.191061f,
+		0.027069f,
+		-0.461262f,
+		0.000000f,
+		-0.382100f,
+		0.054000f,
+		-0.922500f,
+		0.812500f,
+		0.517200f,
+		-0.097402f,
+		0.027069f,
+		-0.489673f,
+		0.000000f,
+		-0.194800f,
+		0.054000f,
+		-0.979300f,
+		0.781300f,
+		0.517200f,
+		-0.191061f,
+		-0.027069f,
+		-0.461262f,
+		0.000000f,
+		-0.382100f,
+		-0.054000f,
+		-0.922500f,
+		0.812500f,
+		0.482800f,
+		-0.097402f,
+		0.027069f,
+		-0.489673f,
+		0.000000f,
+		-0.194800f,
+		0.054000f,
+		-0.979300f,
+		0.781300f,
+		0.517200f,
+		-0.097402f,
+		-0.027069f,
+		-0.489673f,
+		0.000000f,
+		-0.194800f,
+		-0.054000f,
+		-0.979300f,
+		0.781300f,
+		0.482800f,
+		-0.041133f,
+		0.488310f,
+		-0.099303f,
+		0.000000f,
+		-0.083500f,
+		0.975900f,
+		-0.201600f,
+		0.812500f,
+		0.931000f,
+		-0.020688f,
+		0.497069f,
+		-0.049944f,
+		0.000000f,
+		-0.042600f,
+		0.993700f,
+		-0.103000f,
+		0.812500f,
+		0.965500f,
+		-0.010547f,
+		0.497069f,
+		-0.053020f,
+		0.000000f,
+		-0.021700f,
+		0.993700f,
+		-0.109300f,
+		0.781300f,
+		0.965500f,
+		-0.041133f,
+		0.488310f,
+		-0.099303f,
+		0.000000f,
+		-0.083500f,
+		0.975900f,
+		-0.201600f,
+		0.812500f,
+		0.931000f,
+		-0.010547f,
+		0.497069f,
+		-0.053020f,
+		0.000000f,
+		-0.021700f,
+		0.993700f,
+		-0.109300f,
+		0.781300f,
+		0.965500f,
+		-0.020970f,
+		0.488310f,
+		-0.105420f,
+		0.000000f,
+		-0.042500f,
+		0.975900f,
+		-0.214000f,
+		0.781300f,
+		0.931000f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.495500f,
+		0.051000f,
+		-0.020688f,
+		-0.497069f,
+		-0.049945f,
+		0.000000f,
+		-0.042600f,
+		-0.993700f,
+		-0.103000f,
+		0.478500f,
+		0.053800f,
+		-0.010547f,
+		-0.497069f,
+		-0.053020f,
+		0.000000f,
+		-0.021700f,
+		-0.993700f,
+		-0.109300f,
+		0.475900f,
+		0.053800f,
+		-0.188821f,
+		-0.080891f,
+		-0.455854f,
+		0.000000f,
+		-0.377700f,
+		-0.161200f,
+		-0.911800f,
+		0.812500f,
+		0.448300f,
+		-0.191061f,
+		-0.027069f,
+		-0.461262f,
+		0.000000f,
+		-0.382100f,
+		-0.054000f,
+		-0.922500f,
+		0.812500f,
+		0.482800f,
+		-0.097402f,
+		-0.027069f,
+		-0.489673f,
+		0.000000f,
+		-0.194800f,
+		-0.054000f,
+		-0.979300f,
+		0.781300f,
+		0.482800f,
+		-0.188821f,
+		-0.080891f,
+		-0.455854f,
+		0.000000f,
+		-0.377700f,
+		-0.161200f,
+		-0.911800f,
+		0.812500f,
+		0.448300f,
+		-0.097402f,
+		-0.027069f,
+		-0.489673f,
+		0.000000f,
+		-0.194800f,
+		-0.054000f,
+		-0.979300f,
+		0.781300f,
+		0.482800f,
+		-0.096261f,
+		-0.080891f,
+		-0.483932f,
+		0.000000f,
+		-0.192500f,
+		-0.161200f,
+		-0.967900f,
+		0.781300f,
+		0.448300f,
+		-0.061096f,
+		0.473826f,
+		-0.147498f,
+		0.000000f,
+		-0.123300f,
+		0.946600f,
+		-0.297800f,
+		0.812500f,
+		0.896600f,
+		-0.041133f,
+		0.488310f,
+		-0.099303f,
+		0.000000f,
+		-0.083500f,
+		0.975900f,
+		-0.201600f,
+		0.812500f,
+		0.931000f,
+		-0.020970f,
+		0.488310f,
+		-0.105420f,
+		0.000000f,
+		-0.042500f,
+		0.975900f,
+		-0.214000f,
+		0.781300f,
+		0.931000f,
+		-0.061096f,
+		0.473826f,
+		-0.147498f,
+		0.000000f,
+		-0.123300f,
+		0.946600f,
+		-0.297800f,
+		0.812500f,
+		0.896600f,
+		-0.020970f,
+		0.488310f,
+		-0.105420f,
+		0.000000f,
+		-0.042500f,
+		0.975900f,
+		-0.214000f,
+		0.781300f,
+		0.931000f,
+		-0.031147f,
+		0.473826f,
+		-0.156583f,
+		0.000000f,
+		-0.062900f,
+		0.946600f,
+		-0.316100f,
+		0.781300f,
+		0.896600f,
+		-0.184367f,
+		-0.133764f,
+		-0.445101f,
+		0.000000f,
+		-0.368800f,
+		-0.266600f,
+		-0.890400f,
+		0.812500f,
+		0.413800f,
+		-0.188821f,
+		-0.080891f,
+		-0.455854f,
+		0.000000f,
+		-0.377700f,
+		-0.161200f,
+		-0.911800f,
+		0.812500f,
+		0.448300f,
+		-0.096261f,
+		-0.080891f,
+		-0.483932f,
+		0.000000f,
+		-0.192500f,
+		-0.161200f,
+		-0.967900f,
+		0.781300f,
+		0.448300f,
+		-0.184367f,
+		-0.133764f,
+		-0.445101f,
+		0.000000f,
+		-0.368800f,
+		-0.266600f,
+		-0.890400f,
+		0.812500f,
+		0.413800f,
+		-0.096261f,
+		-0.080891f,
+		-0.483932f,
+		0.000000f,
+		-0.192500f,
+		-0.161200f,
+		-0.967900f,
+		0.781300f,
+		0.448300f,
+		-0.093990f,
+		-0.133764f,
+		-0.472517f,
+		0.000000f,
+		-0.188000f,
+		-0.266600f,
+		-0.945200f,
+		0.781300f,
+		0.413800f,
+		-0.080343f,
+		0.453788f,
+		-0.193963f,
+		0.000000f,
+		-0.161700f,
+		0.906300f,
+		-0.390500f,
+		0.812500f,
+		0.862100f,
+		-0.061096f,
+		0.473826f,
+		-0.147498f,
+		0.000000f,
+		-0.123300f,
+		0.946600f,
+		-0.297800f,
+		0.812500f,
+		0.896600f,
+		-0.031147f,
+		0.473826f,
+		-0.156583f,
+		0.000000f,
+		-0.062900f,
+		0.946600f,
+		-0.316100f,
+		0.781300f,
+		0.896600f,
+		-0.080343f,
+		0.453788f,
+		-0.193963f,
+		0.000000f,
+		-0.161700f,
+		0.906300f,
+		-0.390500f,
+		0.812500f,
+		0.862100f,
+		-0.031147f,
+		0.473826f,
+		-0.156583f,
+		0.000000f,
+		-0.062900f,
+		0.946600f,
+		-0.316100f,
+		0.781300f,
+		0.896600f,
+		-0.040959f,
+		0.453788f,
+		-0.205910f,
+		0.000000f,
+		-0.082400f,
+		0.906300f,
+		-0.414500f,
+		0.781300f,
+		0.862100f,
+		-0.177752f,
+		-0.185069f,
+		-0.429131f,
+		0.000000f,
+		-0.355700f,
+		-0.369000f,
+		-0.858700f,
+		0.812500f,
+		0.379300f,
+		-0.184367f,
+		-0.133764f,
+		-0.445101f,
+		0.000000f,
+		-0.368800f,
+		-0.266600f,
+		-0.890400f,
+		0.812500f,
+		0.413800f,
+		-0.093990f,
+		-0.133764f,
+		-0.472517f,
+		0.000000f,
+		-0.188000f,
+		-0.266600f,
+		-0.945200f,
+		0.781300f,
+		0.413800f,
+		-0.177752f,
+		-0.185069f,
+		-0.429131f,
+		0.000000f,
+		-0.355700f,
+		-0.369000f,
+		-0.858700f,
+		0.812500f,
+		0.379300f,
+		-0.093990f,
+		-0.133764f,
+		-0.472517f,
+		0.000000f,
+		-0.188000f,
+		-0.266600f,
+		-0.945200f,
+		0.781300f,
+		0.413800f,
+		-0.090618f,
+		-0.185069f,
+		-0.455563f,
+		0.000000f,
+		-0.181300f,
+		-0.369000f,
+		-0.911600f,
+		0.781300f,
+		0.379300f,
+		-0.098647f,
+		0.428429f,
+		-0.238155f,
+		0.000000f,
+		-0.198200f,
+		0.855300f,
+		-0.478600f,
+		0.812500f,
+		0.827600f,
+		-0.080343f,
+		0.453788f,
+		-0.193963f,
+		0.000000f,
+		-0.161700f,
+		0.906300f,
+		-0.390500f,
+		0.812500f,
+		0.862100f,
+		-0.040959f,
+		0.453788f,
+		-0.205910f,
+		0.000000f,
+		-0.082400f,
+		0.906300f,
+		-0.414500f,
+		0.781300f,
+		0.862100f,
+		-0.098647f,
+		0.428429f,
+		-0.238155f,
+		0.000000f,
+		-0.198200f,
+		0.855300f,
+		-0.478600f,
+		0.812500f,
+		0.827600f,
+		-0.040959f,
+		0.453788f,
+		-0.205910f,
+		0.000000f,
+		-0.082400f,
+		0.906300f,
+		-0.414500f,
+		0.781300f,
+		0.862100f,
+		-0.050290f,
+		0.428429f,
+		-0.252824f,
+		0.000000f,
+		-0.101000f,
+		0.855300f,
+		-0.508100f,
+		0.781300f,
+		0.827600f,
+		-0.169053f,
+		-0.234204f,
+		-0.408129f,
+		0.000000f,
+		-0.338400f,
+		-0.467000f,
+		-0.816900f,
+		0.812500f,
+		0.344800f,
+		-0.177752f,
+		-0.185069f,
+		-0.429131f,
+		0.000000f,
+		-0.355700f,
+		-0.369000f,
+		-0.858700f,
+		0.812500f,
+		0.379300f,
+		-0.090618f,
+		-0.185069f,
+		-0.455563f,
+		0.000000f,
+		-0.181300f,
+		-0.369000f,
+		-0.911600f,
+		0.781300f,
+		0.379300f,
+		-0.169053f,
+		-0.234204f,
+		-0.408129f,
+		0.000000f,
+		-0.338400f,
+		-0.467000f,
+		-0.816900f,
+		0.812500f,
+		0.344800f,
+		-0.090618f,
+		-0.185069f,
+		-0.455563f,
+		0.000000f,
+		-0.181300f,
+		-0.369000f,
+		-0.911600f,
+		0.781300f,
+		0.379300f,
+		-0.086182f,
+		-0.234204f,
+		-0.433268f,
+		0.000000f,
+		-0.172500f,
+		-0.467000f,
+		-0.867200f,
+		0.781300f,
+		0.344800f,
+		-0.115796f,
+		0.398046f,
+		-0.279554f,
+		0.000000f,
+		-0.232400f,
+		0.794500f,
+		-0.561100f,
+		0.812500f,
+		0.793100f,
+		-0.098647f,
+		0.428429f,
+		-0.238155f,
+		0.000000f,
+		-0.198200f,
+		0.855300f,
+		-0.478600f,
+		0.812500f,
+		0.827600f,
+		-0.050290f,
+		0.428429f,
+		-0.252824f,
+		0.000000f,
+		-0.101000f,
+		0.855300f,
+		-0.508100f,
+		0.781300f,
+		0.827600f,
+		-0.115796f,
+		0.398046f,
+		-0.279554f,
+		0.000000f,
+		-0.232400f,
+		0.794500f,
+		-0.561100f,
+		0.812500f,
+		0.793100f,
+		-0.050290f,
+		0.428429f,
+		-0.252824f,
+		0.000000f,
+		-0.101000f,
+		0.855300f,
+		-0.508100f,
+		0.781300f,
+		0.827600f,
+		-0.059032f,
+		0.398046f,
+		-0.296773f,
+		0.000000f,
+		-0.118500f,
+		0.794500f,
+		-0.595600f,
+		0.781300f,
+		0.793100f,
+		-0.158371f,
+		-0.280594f,
+		-0.382342f,
+		0.000000f,
+		-0.317100f,
+		-0.559600f,
+		-0.765600f,
+		0.812500f,
+		0.310300f,
+		-0.169053f,
+		-0.234204f,
+		-0.408129f,
+		0.000000f,
+		-0.338400f,
+		-0.467000f,
+		-0.816900f,
+		0.812500f,
+		0.344800f,
+		-0.086182f,
+		-0.234204f,
+		-0.433268f,
+		0.000000f,
+		-0.172500f,
+		-0.467000f,
+		-0.867200f,
+		0.781300f,
+		0.344800f,
+		-0.158371f,
+		-0.280594f,
+		-0.382342f,
+		0.000000f,
+		-0.317100f,
+		-0.559600f,
+		-0.765600f,
+		0.812500f,
+		0.310300f,
+		-0.086182f,
+		-0.234204f,
+		-0.433268f,
+		0.000000f,
+		-0.172500f,
+		-0.467000f,
+		-0.867200f,
+		0.781300f,
+		0.344800f,
+		-0.080738f,
+		-0.280594f,
+		-0.405892f,
+		0.000000f,
+		-0.161700f,
+		-0.559600f,
+		-0.812800f,
+		0.781300f,
+		0.310300f,
+		-0.131586f,
+		0.362998f,
+		-0.317676f,
+		0.000000f,
+		-0.263800f,
+		0.724300f,
+		-0.637000f,
+		0.812500f,
+		0.758600f,
+		-0.115796f,
+		0.398046f,
+		-0.279554f,
+		0.000000f,
+		-0.232400f,
+		0.794500f,
+		-0.561100f,
+		0.812500f,
+		0.793100f,
+		-0.059032f,
+		0.398046f,
+		-0.296773f,
+		0.000000f,
+		-0.118500f,
+		0.794500f,
+		-0.595600f,
+		0.781300f,
+		0.793100f,
+		-0.131586f,
+		0.362998f,
+		-0.317676f,
+		0.000000f,
+		-0.263800f,
+		0.724300f,
+		-0.637000f,
+		0.812500f,
+		0.758600f,
+		-0.059032f,
+		0.398046f,
+		-0.296773f,
+		0.000000f,
+		-0.118500f,
+		0.794500f,
+		-0.595600f,
+		0.781300f,
+		0.793100f,
+		-0.067082f,
+		0.362998f,
+		-0.337242f,
+		0.000000f,
+		-0.134500f,
+		0.724300f,
+		-0.676200f,
+		0.781300f,
+		0.758600f,
+		-0.145834f,
+		-0.323693f,
+		-0.352073f,
+		0.000000f,
+		-0.292200f,
+		-0.645700f,
+		-0.705400f,
+		0.812500f,
+		0.275900f,
+		-0.158371f,
+		-0.280594f,
+		-0.382342f,
+		0.000000f,
+		-0.317100f,
+		-0.559600f,
+		-0.765600f,
+		0.812500f,
+		0.310300f,
+		-0.080738f,
+		-0.280594f,
+		-0.405892f,
+		0.000000f,
+		-0.161700f,
+		-0.559600f,
+		-0.812800f,
+		0.781300f,
+		0.310300f,
+		-0.145834f,
+		-0.323693f,
+		-0.352073f,
+		0.000000f,
+		-0.292200f,
+		-0.645700f,
+		-0.705400f,
+		0.812500f,
+		0.275900f,
+		-0.080738f,
+		-0.280594f,
+		-0.405892f,
+		0.000000f,
+		-0.161700f,
+		-0.559600f,
+		-0.812800f,
+		0.781300f,
+		0.310300f,
+		-0.074345f,
+		-0.323693f,
+		-0.373758f,
+		0.000000f,
+		-0.149000f,
+		-0.645700f,
+		-0.748900f,
+		0.781300f,
+		0.275900f,
+		-0.145834f,
+		0.323693f,
+		-0.352073f,
+		0.000000f,
+		-0.292200f,
+		0.645700f,
+		-0.705400f,
+		0.812500f,
+		0.724100f,
+		-0.131586f,
+		0.362998f,
+		-0.317676f,
+		0.000000f,
+		-0.263800f,
+		0.724300f,
+		-0.637000f,
+		0.812500f,
+		0.758600f,
+		-0.067082f,
+		0.362998f,
+		-0.337242f,
+		0.000000f,
+		-0.134500f,
+		0.724300f,
+		-0.676200f,
+		0.781300f,
+		0.758600f,
+		-0.145834f,
+		0.323693f,
+		-0.352073f,
+		0.000000f,
+		-0.292200f,
+		0.645700f,
+		-0.705400f,
+		0.812500f,
+		0.724100f,
+		-0.067082f,
+		0.362998f,
+		-0.337242f,
+		0.000000f,
+		-0.134500f,
+		0.724300f,
+		-0.676200f,
+		0.781300f,
+		0.758600f,
+		-0.074345f,
+		0.323693f,
+		-0.373758f,
+		0.000000f,
+		-0.149000f,
+		0.645700f,
+		-0.748900f,
+		0.781300f,
+		0.724100f,
+		-0.131586f,
+		-0.362998f,
+		-0.317676f,
+		0.000000f,
+		-0.263800f,
+		-0.724300f,
+		-0.637000f,
+		0.812500f,
+		0.241400f,
+		-0.145834f,
+		-0.323693f,
+		-0.352073f,
+		0.000000f,
+		-0.292200f,
+		-0.645700f,
+		-0.705400f,
+		0.812500f,
+		0.275900f,
+		-0.074345f,
+		-0.323693f,
+		-0.373758f,
+		0.000000f,
+		-0.149000f,
+		-0.645700f,
+		-0.748900f,
+		0.781300f,
+		0.275900f,
+		-0.131586f,
+		-0.362998f,
+		-0.317676f,
+		0.000000f,
+		-0.263800f,
+		-0.724300f,
+		-0.637000f,
+		0.812500f,
+		0.241400f,
+		-0.074345f,
+		-0.323693f,
+		-0.373758f,
+		0.000000f,
+		-0.149000f,
+		-0.645700f,
+		-0.748900f,
+		0.781300f,
+		0.275900f,
+		-0.067082f,
+		-0.362998f,
+		-0.337243f,
+		0.000000f,
+		-0.134500f,
+		-0.724300f,
+		-0.676200f,
+		0.781300f,
+		0.241400f,
+		-0.158371f,
+		0.280594f,
+		-0.382342f,
+		0.000000f,
+		-0.317100f,
+		0.559600f,
+		-0.765600f,
+		0.812500f,
+		0.689700f,
+		-0.145834f,
+		0.323693f,
+		-0.352073f,
+		0.000000f,
+		-0.292200f,
+		0.645700f,
+		-0.705400f,
+		0.812500f,
+		0.724100f,
+		-0.074345f,
+		0.323693f,
+		-0.373758f,
+		0.000000f,
+		-0.149000f,
+		0.645700f,
+		-0.748900f,
+		0.781300f,
+		0.724100f,
+		-0.158371f,
+		0.280594f,
+		-0.382342f,
+		0.000000f,
+		-0.317100f,
+		0.559600f,
+		-0.765600f,
+		0.812500f,
+		0.689700f,
+		-0.074345f,
+		0.323693f,
+		-0.373758f,
+		0.000000f,
+		-0.149000f,
+		0.645700f,
+		-0.748900f,
+		0.781300f,
+		0.724100f,
+		-0.080738f,
+		0.280594f,
+		-0.405892f,
+		0.000000f,
+		-0.161700f,
+		0.559600f,
+		-0.812800f,
+		0.781300f,
+		0.689700f,
+		-0.115796f,
+		-0.398046f,
+		-0.279554f,
+		0.000000f,
+		-0.232400f,
+		-0.794500f,
+		-0.561100f,
+		0.812500f,
+		0.206900f,
+		-0.131586f,
+		-0.362998f,
+		-0.317676f,
+		0.000000f,
+		-0.263800f,
+		-0.724300f,
+		-0.637000f,
+		0.812500f,
+		0.241400f,
+		-0.067082f,
+		-0.362998f,
+		-0.337243f,
+		0.000000f,
+		-0.134500f,
+		-0.724300f,
+		-0.676200f,
+		0.781300f,
+		0.241400f,
+		-0.115796f,
+		-0.398046f,
+		-0.279554f,
+		0.000000f,
+		-0.232400f,
+		-0.794500f,
+		-0.561100f,
+		0.812500f,
+		0.206900f,
+		-0.067082f,
+		-0.362998f,
+		-0.337243f,
+		0.000000f,
+		-0.134500f,
+		-0.724300f,
+		-0.676200f,
+		0.781300f,
+		0.241400f,
+		-0.059032f,
+		-0.398046f,
+		-0.296773f,
+		0.000000f,
+		-0.118500f,
+		-0.794500f,
+		-0.595600f,
+		0.781300f,
+		0.206900f,
+		-0.169053f,
+		0.234204f,
+		-0.408129f,
+		0.000000f,
+		-0.338400f,
+		0.467000f,
+		-0.816900f,
+		0.812500f,
+		0.655200f,
+		-0.158371f,
+		0.280594f,
+		-0.382342f,
+		0.000000f,
+		-0.317100f,
+		0.559600f,
+		-0.765600f,
+		0.812500f,
+		0.689700f,
+		-0.080738f,
+		0.280594f,
+		-0.405892f,
+		0.000000f,
+		-0.161700f,
+		0.559600f,
+		-0.812800f,
+		0.781300f,
+		0.689700f,
+		-0.169053f,
+		0.234204f,
+		-0.408129f,
+		0.000000f,
+		-0.338400f,
+		0.467000f,
+		-0.816900f,
+		0.812500f,
+		0.655200f,
+		-0.080738f,
+		0.280594f,
+		-0.405892f,
+		0.000000f,
+		-0.161700f,
+		0.559600f,
+		-0.812800f,
+		0.781300f,
+		0.689700f,
+		-0.086182f,
+		0.234204f,
+		-0.433268f,
+		0.000000f,
+		-0.172500f,
+		0.467000f,
+		-0.867200f,
+		0.781300f,
+		0.655200f,
+		-0.098647f,
+		-0.428429f,
+		-0.238155f,
+		0.000000f,
+		-0.198200f,
+		-0.855300f,
+		-0.478600f,
+		0.812500f,
+		0.172400f,
+		-0.115796f,
+		-0.398046f,
+		-0.279554f,
+		0.000000f,
+		-0.232400f,
+		-0.794500f,
+		-0.561100f,
+		0.812500f,
+		0.206900f,
+		-0.059032f,
+		-0.398046f,
+		-0.296773f,
+		0.000000f,
+		-0.118500f,
+		-0.794500f,
+		-0.595600f,
+		0.781300f,
+		0.206900f,
+		-0.098647f,
+		-0.428429f,
+		-0.238155f,
+		0.000000f,
+		-0.198200f,
+		-0.855300f,
+		-0.478600f,
+		0.812500f,
+		0.172400f,
+		-0.059032f,
+		-0.398046f,
+		-0.296773f,
+		0.000000f,
+		-0.118500f,
+		-0.794500f,
+		-0.595600f,
+		0.781300f,
+		0.206900f,
+		-0.050290f,
+		-0.428429f,
+		-0.252824f,
+		0.000000f,
+		-0.101000f,
+		-0.855300f,
+		-0.508100f,
+		0.781300f,
+		0.172400f,
+		-0.177752f,
+		0.185069f,
+		-0.429131f,
+		0.000000f,
+		-0.355700f,
+		0.369000f,
+		-0.858700f,
+		0.812500f,
+		0.620700f,
+		-0.169053f,
+		0.234204f,
+		-0.408129f,
+		0.000000f,
+		-0.338400f,
+		0.467000f,
+		-0.816900f,
+		0.812500f,
+		0.655200f,
+		-0.086182f,
+		0.234204f,
+		-0.433268f,
+		0.000000f,
+		-0.172500f,
+		0.467000f,
+		-0.867200f,
+		0.781300f,
+		0.655200f,
+		-0.177752f,
+		0.185069f,
+		-0.429131f,
+		0.000000f,
+		-0.355700f,
+		0.369000f,
+		-0.858700f,
+		0.812500f,
+		0.620700f,
+		-0.086182f,
+		0.234204f,
+		-0.433268f,
+		0.000000f,
+		-0.172500f,
+		0.467000f,
+		-0.867200f,
+		0.781300f,
+		0.655200f,
+		-0.090618f,
+		0.185069f,
+		-0.455563f,
+		0.000000f,
+		-0.181300f,
+		0.369000f,
+		-0.911600f,
+		0.781300f,
+		0.620700f,
+		-0.080343f,
+		-0.453788f,
+		-0.193963f,
+		0.000000f,
+		-0.161700f,
+		-0.906300f,
+		-0.390500f,
+		0.812500f,
+		0.137900f,
+		-0.098647f,
+		-0.428429f,
+		-0.238155f,
+		0.000000f,
+		-0.198200f,
+		-0.855300f,
+		-0.478600f,
+		0.812500f,
+		0.172400f,
+		-0.050290f,
+		-0.428429f,
+		-0.252824f,
+		0.000000f,
+		-0.101000f,
+		-0.855300f,
+		-0.508100f,
+		0.781300f,
+		0.172400f,
+		-0.080343f,
+		-0.453788f,
+		-0.193963f,
+		0.000000f,
+		-0.161700f,
+		-0.906300f,
+		-0.390500f,
+		0.812500f,
+		0.137900f,
+		-0.050290f,
+		-0.428429f,
+		-0.252824f,
+		0.000000f,
+		-0.101000f,
+		-0.855300f,
+		-0.508100f,
+		0.781300f,
+		0.172400f,
+		-0.040959f,
+		-0.453788f,
+		-0.205911f,
+		0.000000f,
+		-0.082400f,
+		-0.906300f,
+		-0.414500f,
+		0.781300f,
+		0.137900f,
+		-0.184367f,
+		0.133764f,
+		-0.445101f,
+		0.000000f,
+		-0.368800f,
+		0.266600f,
+		-0.890400f,
+		0.812500f,
+		0.586200f,
+		-0.177752f,
+		0.185069f,
+		-0.429131f,
+		0.000000f,
+		-0.355700f,
+		0.369000f,
+		-0.858700f,
+		0.812500f,
+		0.620700f,
+		-0.090618f,
+		0.185069f,
+		-0.455563f,
+		0.000000f,
+		-0.181300f,
+		0.369000f,
+		-0.911600f,
+		0.781300f,
+		0.620700f,
+		-0.184367f,
+		0.133764f,
+		-0.445101f,
+		0.000000f,
+		-0.368800f,
+		0.266600f,
+		-0.890400f,
+		0.812500f,
+		0.586200f,
+		-0.090618f,
+		0.185069f,
+		-0.455563f,
+		0.000000f,
+		-0.181300f,
+		0.369000f,
+		-0.911600f,
+		0.781300f,
+		0.620700f,
+		-0.093990f,
+		0.133764f,
+		-0.472517f,
+		0.000000f,
+		-0.188000f,
+		0.266600f,
+		-0.945200f,
+		0.781300f,
+		0.586200f,
+		-0.061096f,
+		-0.473826f,
+		-0.147498f,
+		0.000000f,
+		-0.123300f,
+		-0.946600f,
+		-0.297800f,
+		0.812500f,
+		0.103400f,
+		-0.080343f,
+		-0.453788f,
+		-0.193963f,
+		0.000000f,
+		-0.161700f,
+		-0.906300f,
+		-0.390500f,
+		0.812500f,
+		0.137900f,
+		-0.040959f,
+		-0.453788f,
+		-0.205911f,
+		0.000000f,
+		-0.082400f,
+		-0.906300f,
+		-0.414500f,
+		0.781300f,
+		0.137900f,
+		-0.061096f,
+		-0.473826f,
+		-0.147498f,
+		0.000000f,
+		-0.123300f,
+		-0.946600f,
+		-0.297800f,
+		0.812500f,
+		0.103400f,
+		-0.040959f,
+		-0.453788f,
+		-0.205911f,
+		0.000000f,
+		-0.082400f,
+		-0.906300f,
+		-0.414500f,
+		0.781300f,
+		0.137900f,
+		-0.031147f,
+		-0.473826f,
+		-0.156583f,
+		0.000000f,
+		-0.062900f,
+		-0.946600f,
+		-0.316100f,
+		0.781300f,
+		0.103400f,
+		-0.188821f,
+		0.080891f,
+		-0.455854f,
+		0.000000f,
+		-0.377700f,
+		0.161200f,
+		-0.911800f,
+		0.812500f,
+		0.551700f,
+		-0.184367f,
+		0.133764f,
+		-0.445101f,
+		0.000000f,
+		-0.368800f,
+		0.266600f,
+		-0.890400f,
+		0.812500f,
+		0.586200f,
+		-0.093990f,
+		0.133764f,
+		-0.472517f,
+		0.000000f,
+		-0.188000f,
+		0.266600f,
+		-0.945200f,
+		0.781300f,
+		0.586200f,
+		-0.188821f,
+		0.080891f,
+		-0.455854f,
+		0.000000f,
+		-0.377700f,
+		0.161200f,
+		-0.911800f,
+		0.812500f,
+		0.551700f,
+		-0.093990f,
+		0.133764f,
+		-0.472517f,
+		0.000000f,
+		-0.188000f,
+		0.266600f,
+		-0.945200f,
+		0.781300f,
+		0.586200f,
+		-0.096261f,
+		0.080891f,
+		-0.483932f,
+		0.000000f,
+		-0.192500f,
+		0.161200f,
+		-0.967900f,
+		0.781300f,
+		0.551700f,
+		-0.067082f,
+		-0.362998f,
+		-0.337243f,
+		0.000000f,
+		-0.134500f,
+		-0.724300f,
+		-0.676200f,
+		0.781300f,
+		0.241400f,
+		-0.074345f,
+		-0.323693f,
+		-0.373758f,
+		0.000000f,
+		-0.149000f,
+		-0.645700f,
+		-0.748900f,
+		0.781300f,
+		0.275900f,
+		-0.000000f,
+		-0.323693f,
+		-0.381081f,
+		0.000000f,
+		0.000000f,
+		-0.645700f,
+		-0.763500f,
+		0.750000f,
+		0.275900f,
+		-0.067082f,
+		-0.362998f,
+		-0.337243f,
+		0.000000f,
+		-0.134500f,
+		-0.724300f,
+		-0.676200f,
+		0.781300f,
+		0.241400f,
+		-0.000000f,
+		-0.323693f,
+		-0.381081f,
+		0.000000f,
+		0.000000f,
+		-0.645700f,
+		-0.763500f,
+		0.750000f,
+		0.275900f,
+		-0.000000f,
+		-0.362998f,
+		-0.343850f,
+		0.000000f,
+		0.000000f,
+		-0.724300f,
+		-0.689400f,
+		0.750000f,
+		0.241400f,
+		-0.080738f,
+		0.280594f,
+		-0.405892f,
+		0.000000f,
+		-0.161700f,
+		0.559600f,
+		-0.812800f,
+		0.781300f,
+		0.689700f,
+		-0.074345f,
+		0.323693f,
+		-0.373758f,
+		0.000000f,
+		-0.149000f,
+		0.645700f,
+		-0.748900f,
+		0.781300f,
+		0.724100f,
+		-0.000000f,
+		0.323693f,
+		-0.381081f,
+		0.000000f,
+		0.000000f,
+		0.645700f,
+		-0.763500f,
+		0.750000f,
+		0.724100f,
+		-0.080738f,
+		0.280594f,
+		-0.405892f,
+		0.000000f,
+		-0.161700f,
+		0.559600f,
+		-0.812800f,
+		0.781300f,
+		0.689700f,
+		-0.000000f,
+		0.323693f,
+		-0.381081f,
+		0.000000f,
+		0.000000f,
+		0.645700f,
+		-0.763500f,
+		0.750000f,
+		0.724100f,
+		-0.000000f,
+		0.280594f,
+		-0.413844f,
+		0.000000f,
+		0.000000f,
+		0.559600f,
+		-0.828700f,
+		0.750000f,
+		0.689700f,
+		-0.059032f,
+		-0.398046f,
+		-0.296773f,
+		0.000000f,
+		-0.118500f,
+		-0.794500f,
+		-0.595600f,
+		0.781300f,
+		0.206900f,
+		-0.067082f,
+		-0.362998f,
+		-0.337243f,
+		0.000000f,
+		-0.134500f,
+		-0.724300f,
+		-0.676200f,
+		0.781300f,
+		0.241400f,
+		-0.000000f,
+		-0.362998f,
+		-0.343850f,
+		0.000000f,
+		0.000000f,
+		-0.724300f,
+		-0.689400f,
+		0.750000f,
+		0.241400f,
+		-0.059032f,
+		-0.398046f,
+		-0.296773f,
+		0.000000f,
+		-0.118500f,
+		-0.794500f,
+		-0.595600f,
+		0.781300f,
+		0.206900f,
+		-0.000000f,
+		-0.362998f,
+		-0.343850f,
+		0.000000f,
+		0.000000f,
+		-0.724300f,
+		-0.689400f,
+		0.750000f,
+		0.241400f,
+		-0.000000f,
+		-0.398046f,
+		-0.302587f,
+		0.000000f,
+		0.000000f,
+		-0.794500f,
+		-0.607300f,
+		0.750000f,
+		0.206900f,
+		-0.086182f,
+		0.234204f,
+		-0.433268f,
+		0.000000f,
+		-0.172500f,
+		0.467000f,
+		-0.867200f,
+		0.781300f,
+		0.655200f,
+		-0.080738f,
+		0.280594f,
+		-0.405892f,
+		0.000000f,
+		-0.161700f,
+		0.559600f,
+		-0.812800f,
+		0.781300f,
+		0.689700f,
+		-0.000000f,
+		0.280594f,
+		-0.413844f,
+		0.000000f,
+		0.000000f,
+		0.559600f,
+		-0.828700f,
+		0.750000f,
+		0.689700f,
+		-0.086182f,
+		0.234204f,
+		-0.433268f,
+		0.000000f,
+		-0.172500f,
+		0.467000f,
+		-0.867200f,
+		0.781300f,
+		0.655200f,
+		-0.000000f,
+		0.280594f,
+		-0.413844f,
+		0.000000f,
+		0.000000f,
+		0.559600f,
+		-0.828700f,
+		0.750000f,
+		0.689700f,
+		-0.000000f,
+		0.234204f,
+		-0.441756f,
+		0.000000f,
+		0.000000f,
+		0.467000f,
+		-0.884200f,
+		0.750000f,
+		0.655200f,
+		-0.050290f,
+		-0.428429f,
+		-0.252824f,
+		0.000000f,
+		-0.101000f,
+		-0.855300f,
+		-0.508100f,
+		0.781300f,
+		0.172400f,
+		-0.059032f,
+		-0.398046f,
+		-0.296773f,
+		0.000000f,
+		-0.118500f,
+		-0.794500f,
+		-0.595600f,
+		0.781300f,
+		0.206900f,
+		-0.000000f,
+		-0.398046f,
+		-0.302587f,
+		0.000000f,
+		0.000000f,
+		-0.794500f,
+		-0.607300f,
+		0.750000f,
+		0.206900f,
+		-0.050290f,
+		-0.428429f,
+		-0.252824f,
+		0.000000f,
+		-0.101000f,
+		-0.855300f,
+		-0.508100f,
+		0.781300f,
+		0.172400f,
+		-0.000000f,
+		-0.398046f,
+		-0.302587f,
+		0.000000f,
+		0.000000f,
+		-0.794500f,
+		-0.607300f,
+		0.750000f,
+		0.206900f,
+		-0.000000f,
+		-0.428429f,
+		-0.257776f,
+		0.000000f,
+		0.000000f,
+		-0.855300f,
+		-0.518000f,
+		0.750000f,
+		0.172400f,
+		-0.090618f,
+		0.185069f,
+		-0.455563f,
+		0.000000f,
+		-0.181300f,
+		0.369000f,
+		-0.911600f,
+		0.781300f,
+		0.620700f,
+		-0.086182f,
+		0.234204f,
+		-0.433268f,
+		0.000000f,
+		-0.172500f,
+		0.467000f,
+		-0.867200f,
+		0.781300f,
+		0.655200f,
+		-0.000000f,
+		0.234204f,
+		-0.441756f,
+		0.000000f,
+		0.000000f,
+		0.467000f,
+		-0.884200f,
+		0.750000f,
+		0.655200f,
+		-0.090618f,
+		0.185069f,
+		-0.455563f,
+		0.000000f,
+		-0.181300f,
+		0.369000f,
+		-0.911600f,
+		0.781300f,
+		0.620700f,
+		-0.000000f,
+		0.234204f,
+		-0.441756f,
+		0.000000f,
+		0.000000f,
+		0.467000f,
+		-0.884200f,
+		0.750000f,
+		0.655200f,
+		-0.000000f,
+		0.185069f,
+		-0.464488f,
+		0.000000f,
+		0.000000f,
+		0.369000f,
+		-0.929400f,
+		0.750000f,
+		0.620700f,
+		-0.040959f,
+		-0.453788f,
+		-0.205911f,
+		0.000000f,
+		-0.082400f,
+		-0.906300f,
+		-0.414500f,
+		0.781300f,
+		0.137900f,
+		-0.050290f,
+		-0.428429f,
+		-0.252824f,
+		0.000000f,
+		-0.101000f,
+		-0.855300f,
+		-0.508100f,
+		0.781300f,
+		0.172400f,
+		-0.000000f,
+		-0.428429f,
+		-0.257776f,
+		0.000000f,
+		0.000000f,
+		-0.855300f,
+		-0.518000f,
+		0.750000f,
+		0.172400f,
+		-0.040959f,
+		-0.453788f,
+		-0.205911f,
+		0.000000f,
+		-0.082400f,
+		-0.906300f,
+		-0.414500f,
+		0.781300f,
+		0.137900f,
+		-0.000000f,
+		-0.428429f,
+		-0.257776f,
+		0.000000f,
+		0.000000f,
+		-0.855300f,
+		-0.518000f,
+		0.750000f,
+		0.172400f,
+		-0.000000f,
+		-0.453788f,
+		-0.209945f,
+		0.000000f,
+		0.000000f,
+		-0.906300f,
+		-0.422700f,
+		0.750000f,
+		0.137900f,
+		-0.093990f,
+		0.133764f,
+		-0.472517f,
+		0.000000f,
+		-0.188000f,
+		0.266600f,
+		-0.945200f,
+		0.781300f,
+		0.586200f,
+		-0.090618f,
+		0.185069f,
+		-0.455563f,
+		0.000000f,
+		-0.181300f,
+		0.369000f,
+		-0.911600f,
+		0.781300f,
+		0.620700f,
+		-0.000000f,
+		0.185069f,
+		-0.464488f,
+		0.000000f,
+		0.000000f,
+		0.369000f,
+		-0.929400f,
+		0.750000f,
+		0.620700f,
+		-0.093990f,
+		0.133764f,
+		-0.472517f,
+		0.000000f,
+		-0.188000f,
+		0.266600f,
+		-0.945200f,
+		0.781300f,
+		0.586200f,
+		-0.000000f,
+		0.185069f,
+		-0.464488f,
+		0.000000f,
+		0.000000f,
+		0.369000f,
+		-0.929400f,
+		0.750000f,
+		0.620700f,
+		-0.000000f,
+		0.133764f,
+		-0.481775f,
+		0.000000f,
+		0.000000f,
+		0.266600f,
+		-0.963800f,
+		0.750000f,
+		0.586200f,
+		-0.031147f,
+		-0.473826f,
+		-0.156583f,
+		0.000000f,
+		-0.062900f,
+		-0.946600f,
+		-0.316100f,
+		0.781300f,
+		0.103400f,
+		-0.040959f,
+		-0.453788f,
+		-0.205911f,
+		0.000000f,
+		-0.082400f,
+		-0.906300f,
+		-0.414500f,
+		0.781300f,
+		0.137900f,
+		-0.000000f,
+		-0.453788f,
+		-0.209945f,
+		0.000000f,
+		0.000000f,
+		-0.906300f,
+		-0.422700f,
+		0.750000f,
+		0.137900f,
+		-0.031147f,
+		-0.473826f,
+		-0.156583f,
+		0.000000f,
+		-0.062900f,
+		-0.946600f,
+		-0.316100f,
+		0.781300f,
+		0.103400f,
+		-0.000000f,
+		-0.453788f,
+		-0.209945f,
+		0.000000f,
+		0.000000f,
+		-0.906300f,
+		-0.422700f,
+		0.750000f,
+		0.137900f,
+		-0.000000f,
+		-0.473826f,
+		-0.159651f,
+		0.000000f,
+		0.000000f,
+		-0.946600f,
+		-0.322300f,
+		0.750000f,
+		0.103400f,
+		-0.096261f,
+		0.080891f,
+		-0.483932f,
+		0.000000f,
+		-0.192500f,
+		0.161200f,
+		-0.967900f,
+		0.781300f,
+		0.551700f,
+		-0.093990f,
+		0.133764f,
+		-0.472517f,
+		0.000000f,
+		-0.188000f,
+		0.266600f,
+		-0.945200f,
+		0.781300f,
+		0.586200f,
+		-0.000000f,
+		0.133764f,
+		-0.481775f,
+		0.000000f,
+		0.000000f,
+		0.266600f,
+		-0.963800f,
+		0.750000f,
+		0.586200f,
+		-0.096261f,
+		0.080891f,
+		-0.483932f,
+		0.000000f,
+		-0.192500f,
+		0.161200f,
+		-0.967900f,
+		0.781300f,
+		0.551700f,
+		-0.000000f,
+		0.133764f,
+		-0.481775f,
+		0.000000f,
+		0.000000f,
+		0.266600f,
+		-0.963800f,
+		0.750000f,
+		0.586200f,
+		-0.000000f,
+		0.080891f,
+		-0.493412f,
+		0.000000f,
+		0.000000f,
+		0.161200f,
+		-0.986900f,
+		0.750000f,
+		0.551700f,
+		-0.020970f,
+		-0.488310f,
+		-0.105420f,
+		0.000000f,
+		-0.042500f,
+		-0.975900f,
+		-0.214000f,
+		0.781300f,
+		0.069000f,
+		-0.031147f,
+		-0.473826f,
+		-0.156583f,
+		0.000000f,
+		-0.062900f,
+		-0.946600f,
+		-0.316100f,
+		0.781300f,
+		0.103400f,
+		-0.000000f,
+		-0.473826f,
+		-0.159651f,
+		0.000000f,
+		0.000000f,
+		-0.946600f,
+		-0.322300f,
+		0.750000f,
+		0.103400f,
+		-0.020970f,
+		-0.488310f,
+		-0.105420f,
+		0.000000f,
+		-0.042500f,
+		-0.975900f,
+		-0.214000f,
+		0.781300f,
+		0.069000f,
+		-0.000000f,
+		-0.473826f,
+		-0.159651f,
+		0.000000f,
+		0.000000f,
+		-0.946600f,
+		-0.322300f,
+		0.750000f,
+		0.103400f,
+		-0.000000f,
+		-0.488310f,
+		-0.107485f,
+		0.000000f,
+		0.000000f,
+		-0.975900f,
+		-0.218200f,
+		0.750000f,
+		0.069000f,
+		-0.097402f,
+		0.027069f,
+		-0.489673f,
+		0.000000f,
+		-0.194800f,
+		0.054000f,
+		-0.979300f,
+		0.781300f,
+		0.517200f,
+		-0.096261f,
+		0.080891f,
+		-0.483932f,
+		0.000000f,
+		-0.192500f,
+		0.161200f,
+		-0.967900f,
+		0.781300f,
+		0.551700f,
+		-0.000000f,
+		0.080891f,
+		-0.493412f,
+		0.000000f,
+		0.000000f,
+		0.161200f,
+		-0.986900f,
+		0.750000f,
+		0.551700f,
+		-0.097402f,
+		0.027069f,
+		-0.489673f,
+		0.000000f,
+		-0.194800f,
+		0.054000f,
+		-0.979300f,
+		0.781300f,
+		0.517200f,
+		-0.000000f,
+		0.080891f,
+		-0.493412f,
+		0.000000f,
+		0.000000f,
+		0.161200f,
+		-0.986900f,
+		0.750000f,
+		0.551700f,
+		-0.000000f,
+		0.027069f,
+		-0.499266f,
+		0.000000f,
+		0.000000f,
+		0.054000f,
+		-0.998500f,
+		0.750000f,
+		0.517200f,
+		-0.010547f,
+		0.497069f,
+		-0.053020f,
+		0.000000f,
+		-0.021700f,
+		0.993700f,
+		-0.109300f,
+		0.439900f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.423900f,
+		0.960300f,
+		-0.000000f,
+		0.497069f,
+		-0.054059f,
+		0.000000f,
+		0.000000f,
+		0.993700f,
+		-0.111500f,
+		0.441700f,
+		0.962300f,
+		-0.010547f,
+		-0.497069f,
+		-0.053020f,
+		0.000000f,
+		-0.021700f,
+		-0.993700f,
+		-0.109300f,
+		0.781300f,
+		0.034500f,
+		-0.020970f,
+		-0.488310f,
+		-0.105420f,
+		0.000000f,
+		-0.042500f,
+		-0.975900f,
+		-0.214000f,
+		0.781300f,
+		0.069000f,
+		-0.000000f,
+		-0.488310f,
+		-0.107485f,
+		0.000000f,
+		0.000000f,
+		-0.975900f,
+		-0.218200f,
+		0.750000f,
+		0.069000f,
+		-0.010547f,
+		-0.497069f,
+		-0.053020f,
+		0.000000f,
+		-0.021700f,
+		-0.993700f,
+		-0.109300f,
+		0.781300f,
+		0.034500f,
+		-0.000000f,
+		-0.488310f,
+		-0.107485f,
+		0.000000f,
+		0.000000f,
+		-0.975900f,
+		-0.218200f,
+		0.750000f,
+		0.069000f,
+		-0.000000f,
+		-0.497069f,
+		-0.054060f,
+		0.000000f,
+		0.000000f,
+		-0.993700f,
+		-0.111500f,
+		0.750000f,
+		0.034500f,
+		-0.097402f,
+		-0.027069f,
+		-0.489673f,
+		0.000000f,
+		-0.194800f,
+		-0.054000f,
+		-0.979300f,
+		0.781300f,
+		0.482800f,
+		-0.097402f,
+		0.027069f,
+		-0.489673f,
+		0.000000f,
+		-0.194800f,
+		0.054000f,
+		-0.979300f,
+		0.781300f,
+		0.517200f,
+		-0.000000f,
+		0.027069f,
+		-0.499266f,
+		0.000000f,
+		0.000000f,
+		0.054000f,
+		-0.998500f,
+		0.750000f,
+		0.517200f,
+		-0.097402f,
+		-0.027069f,
+		-0.489673f,
+		0.000000f,
+		-0.194800f,
+		-0.054000f,
+		-0.979300f,
+		0.781300f,
+		0.482800f,
+		-0.000000f,
+		0.027069f,
+		-0.499266f,
+		0.000000f,
+		0.000000f,
+		0.054000f,
+		-0.998500f,
+		0.750000f,
+		0.517200f,
+		-0.000000f,
+		-0.027069f,
+		-0.499266f,
+		0.000000f,
+		0.000000f,
+		-0.054000f,
+		-0.998500f,
+		0.750000f,
+		0.482800f,
+		-0.020970f,
+		0.488310f,
+		-0.105420f,
+		0.000000f,
+		-0.042500f,
+		0.975900f,
+		-0.214000f,
+		0.781300f,
+		0.931000f,
+		-0.010547f,
+		0.497069f,
+		-0.053020f,
+		0.000000f,
+		-0.021700f,
+		0.993700f,
+		-0.109300f,
+		0.781300f,
+		0.965500f,
+		-0.000000f,
+		0.497069f,
+		-0.054059f,
+		0.000000f,
+		0.000000f,
+		0.993700f,
+		-0.111500f,
+		0.750000f,
+		0.965500f,
+		-0.020970f,
+		0.488310f,
+		-0.105420f,
+		0.000000f,
+		-0.042500f,
+		0.975900f,
+		-0.214000f,
+		0.781300f,
+		0.931000f,
+		-0.000000f,
+		0.497069f,
+		-0.054059f,
+		0.000000f,
+		0.000000f,
+		0.993700f,
+		-0.111500f,
+		0.750000f,
+		0.965500f,
+		-0.000000f,
+		0.488310f,
+		-0.107485f,
+		0.000000f,
+		0.000000f,
+		0.975900f,
+		-0.218200f,
+		0.750000f,
+		0.931000f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.495500f,
+		0.051000f,
+		-0.010547f,
+		-0.497069f,
+		-0.053020f,
+		0.000000f,
+		-0.021700f,
+		-0.993700f,
+		-0.109300f,
+		0.475900f,
+		0.053800f,
+		-0.000000f,
+		-0.497069f,
+		-0.054060f,
+		0.000000f,
+		0.000000f,
+		-0.993700f,
+		-0.111500f,
+		0.473300f,
+		0.053800f,
+		-0.096261f,
+		-0.080891f,
+		-0.483932f,
+		0.000000f,
+		-0.192500f,
+		-0.161200f,
+		-0.967900f,
+		0.781300f,
+		0.448300f,
+		-0.097402f,
+		-0.027069f,
+		-0.489673f,
+		0.000000f,
+		-0.194800f,
+		-0.054000f,
+		-0.979300f,
+		0.781300f,
+		0.482800f,
+		-0.000000f,
+		-0.027069f,
+		-0.499266f,
+		0.000000f,
+		0.000000f,
+		-0.054000f,
+		-0.998500f,
+		0.750000f,
+		0.482800f,
+		-0.096261f,
+		-0.080891f,
+		-0.483932f,
+		0.000000f,
+		-0.192500f,
+		-0.161200f,
+		-0.967900f,
+		0.781300f,
+		0.448300f,
+		-0.000000f,
+		-0.027069f,
+		-0.499266f,
+		0.000000f,
+		0.000000f,
+		-0.054000f,
+		-0.998500f,
+		0.750000f,
+		0.482800f,
+		-0.000000f,
+		-0.080891f,
+		-0.493412f,
+		0.000000f,
+		0.000000f,
+		-0.161200f,
+		-0.986900f,
+		0.750000f,
+		0.448300f,
+		-0.031147f,
+		0.473826f,
+		-0.156583f,
+		0.000000f,
+		-0.062900f,
+		0.946600f,
+		-0.316100f,
+		0.781300f,
+		0.896600f,
+		-0.020970f,
+		0.488310f,
+		-0.105420f,
+		0.000000f,
+		-0.042500f,
+		0.975900f,
+		-0.214000f,
+		0.781300f,
+		0.931000f,
+		-0.000000f,
+		0.488310f,
+		-0.107485f,
+		0.000000f,
+		0.000000f,
+		0.975900f,
+		-0.218200f,
+		0.750000f,
+		0.931000f,
+		-0.031147f,
+		0.473826f,
+		-0.156583f,
+		0.000000f,
+		-0.062900f,
+		0.946600f,
+		-0.316100f,
+		0.781300f,
+		0.896600f,
+		-0.000000f,
+		0.488310f,
+		-0.107485f,
+		0.000000f,
+		0.000000f,
+		0.975900f,
+		-0.218200f,
+		0.750000f,
+		0.931000f,
+		-0.000000f,
+		0.473826f,
+		-0.159651f,
+		0.000000f,
+		0.000000f,
+		0.946600f,
+		-0.322300f,
+		0.750000f,
+		0.896600f,
+		-0.093990f,
+		-0.133764f,
+		-0.472517f,
+		0.000000f,
+		-0.188000f,
+		-0.266600f,
+		-0.945200f,
+		0.781300f,
+		0.413800f,
+		-0.096261f,
+		-0.080891f,
+		-0.483932f,
+		0.000000f,
+		-0.192500f,
+		-0.161200f,
+		-0.967900f,
+		0.781300f,
+		0.448300f,
+		-0.000000f,
+		-0.080891f,
+		-0.493412f,
+		0.000000f,
+		0.000000f,
+		-0.161200f,
+		-0.986900f,
+		0.750000f,
+		0.448300f,
+		-0.093990f,
+		-0.133764f,
+		-0.472517f,
+		0.000000f,
+		-0.188000f,
+		-0.266600f,
+		-0.945200f,
+		0.781300f,
+		0.413800f,
+		-0.000000f,
+		-0.080891f,
+		-0.493412f,
+		0.000000f,
+		0.000000f,
+		-0.161200f,
+		-0.986900f,
+		0.750000f,
+		0.448300f,
+		-0.000000f,
+		-0.133764f,
+		-0.481775f,
+		0.000000f,
+		0.000000f,
+		-0.266600f,
+		-0.963800f,
+		0.750000f,
+		0.413800f,
+		-0.040959f,
+		0.453788f,
+		-0.205910f,
+		0.000000f,
+		-0.082400f,
+		0.906300f,
+		-0.414500f,
+		0.781300f,
+		0.862100f,
+		-0.031147f,
+		0.473826f,
+		-0.156583f,
+		0.000000f,
+		-0.062900f,
+		0.946600f,
+		-0.316100f,
+		0.781300f,
+		0.896600f,
+		-0.000000f,
+		0.473826f,
+		-0.159651f,
+		0.000000f,
+		0.000000f,
+		0.946600f,
+		-0.322300f,
+		0.750000f,
+		0.896600f,
+		-0.040959f,
+		0.453788f,
+		-0.205910f,
+		0.000000f,
+		-0.082400f,
+		0.906300f,
+		-0.414500f,
+		0.781300f,
+		0.862100f,
+		-0.000000f,
+		0.473826f,
+		-0.159651f,
+		0.000000f,
+		0.000000f,
+		0.946600f,
+		-0.322300f,
+		0.750000f,
+		0.896600f,
+		-0.000000f,
+		0.453788f,
+		-0.209944f,
+		0.000000f,
+		0.000000f,
+		0.906300f,
+		-0.422700f,
+		0.750000f,
+		0.862100f,
+		-0.090618f,
+		-0.185069f,
+		-0.455563f,
+		0.000000f,
+		-0.181300f,
+		-0.369000f,
+		-0.911600f,
+		0.781300f,
+		0.379300f,
+		-0.093990f,
+		-0.133764f,
+		-0.472517f,
+		0.000000f,
+		-0.188000f,
+		-0.266600f,
+		-0.945200f,
+		0.781300f,
+		0.413800f,
+		-0.000000f,
+		-0.133764f,
+		-0.481775f,
+		0.000000f,
+		0.000000f,
+		-0.266600f,
+		-0.963800f,
+		0.750000f,
+		0.413800f,
+		-0.090618f,
+		-0.185069f,
+		-0.455563f,
+		0.000000f,
+		-0.181300f,
+		-0.369000f,
+		-0.911600f,
+		0.781300f,
+		0.379300f,
+		-0.000000f,
+		-0.133764f,
+		-0.481775f,
+		0.000000f,
+		0.000000f,
+		-0.266600f,
+		-0.963800f,
+		0.750000f,
+		0.413800f,
+		-0.000000f,
+		-0.185069f,
+		-0.464488f,
+		0.000000f,
+		0.000000f,
+		-0.369000f,
+		-0.929400f,
+		0.750000f,
+		0.379300f,
+		-0.050290f,
+		0.428429f,
+		-0.252824f,
+		0.000000f,
+		-0.101000f,
+		0.855300f,
+		-0.508100f,
+		0.781300f,
+		0.827600f,
+		-0.040959f,
+		0.453788f,
+		-0.205910f,
+		0.000000f,
+		-0.082400f,
+		0.906300f,
+		-0.414500f,
+		0.781300f,
+		0.862100f,
+		-0.000000f,
+		0.453788f,
+		-0.209944f,
+		0.000000f,
+		0.000000f,
+		0.906300f,
+		-0.422700f,
+		0.750000f,
+		0.862100f,
+		-0.050290f,
+		0.428429f,
+		-0.252824f,
+		0.000000f,
+		-0.101000f,
+		0.855300f,
+		-0.508100f,
+		0.781300f,
+		0.827600f,
+		-0.000000f,
+		0.453788f,
+		-0.209944f,
+		0.000000f,
+		0.000000f,
+		0.906300f,
+		-0.422700f,
+		0.750000f,
+		0.862100f,
+		-0.000000f,
+		0.428429f,
+		-0.257776f,
+		0.000000f,
+		0.000000f,
+		0.855300f,
+		-0.518000f,
+		0.750000f,
+		0.827600f,
+		-0.086182f,
+		-0.234204f,
+		-0.433268f,
+		0.000000f,
+		-0.172500f,
+		-0.467000f,
+		-0.867200f,
+		0.781300f,
+		0.344800f,
+		-0.090618f,
+		-0.185069f,
+		-0.455563f,
+		0.000000f,
+		-0.181300f,
+		-0.369000f,
+		-0.911600f,
+		0.781300f,
+		0.379300f,
+		-0.000000f,
+		-0.185069f,
+		-0.464488f,
+		0.000000f,
+		0.000000f,
+		-0.369000f,
+		-0.929400f,
+		0.750000f,
+		0.379300f,
+		-0.086182f,
+		-0.234204f,
+		-0.433268f,
+		0.000000f,
+		-0.172500f,
+		-0.467000f,
+		-0.867200f,
+		0.781300f,
+		0.344800f,
+		-0.000000f,
+		-0.185069f,
+		-0.464488f,
+		0.000000f,
+		0.000000f,
+		-0.369000f,
+		-0.929400f,
+		0.750000f,
+		0.379300f,
+		-0.000000f,
+		-0.234204f,
+		-0.441756f,
+		0.000000f,
+		0.000000f,
+		-0.467000f,
+		-0.884200f,
+		0.750000f,
+		0.344800f,
+		-0.059032f,
+		0.398046f,
+		-0.296773f,
+		0.000000f,
+		-0.118500f,
+		0.794500f,
+		-0.595600f,
+		0.781300f,
+		0.793100f,
+		-0.050290f,
+		0.428429f,
+		-0.252824f,
+		0.000000f,
+		-0.101000f,
+		0.855300f,
+		-0.508100f,
+		0.781300f,
+		0.827600f,
+		-0.000000f,
+		0.428429f,
+		-0.257776f,
+		0.000000f,
+		0.000000f,
+		0.855300f,
+		-0.518000f,
+		0.750000f,
+		0.827600f,
+		-0.059032f,
+		0.398046f,
+		-0.296773f,
+		0.000000f,
+		-0.118500f,
+		0.794500f,
+		-0.595600f,
+		0.781300f,
+		0.793100f,
+		-0.000000f,
+		0.428429f,
+		-0.257776f,
+		0.000000f,
+		0.000000f,
+		0.855300f,
+		-0.518000f,
+		0.750000f,
+		0.827600f,
+		-0.000000f,
+		0.398046f,
+		-0.302586f,
+		0.000000f,
+		0.000000f,
+		0.794500f,
+		-0.607300f,
+		0.750000f,
+		0.793100f,
+		-0.080738f,
+		-0.280594f,
+		-0.405892f,
+		0.000000f,
+		-0.161700f,
+		-0.559600f,
+		-0.812800f,
+		0.781300f,
+		0.310300f,
+		-0.086182f,
+		-0.234204f,
+		-0.433268f,
+		0.000000f,
+		-0.172500f,
+		-0.467000f,
+		-0.867200f,
+		0.781300f,
+		0.344800f,
+		-0.000000f,
+		-0.234204f,
+		-0.441756f,
+		0.000000f,
+		0.000000f,
+		-0.467000f,
+		-0.884200f,
+		0.750000f,
+		0.344800f,
+		-0.080738f,
+		-0.280594f,
+		-0.405892f,
+		0.000000f,
+		-0.161700f,
+		-0.559600f,
+		-0.812800f,
+		0.781300f,
+		0.310300f,
+		-0.000000f,
+		-0.234204f,
+		-0.441756f,
+		0.000000f,
+		0.000000f,
+		-0.467000f,
+		-0.884200f,
+		0.750000f,
+		0.344800f,
+		-0.000000f,
+		-0.280594f,
+		-0.413844f,
+		0.000000f,
+		0.000000f,
+		-0.559600f,
+		-0.828700f,
+		0.750000f,
+		0.310300f,
+		-0.067082f,
+		0.362998f,
+		-0.337242f,
+		0.000000f,
+		-0.134500f,
+		0.724300f,
+		-0.676200f,
+		0.781300f,
+		0.758600f,
+		-0.059032f,
+		0.398046f,
+		-0.296773f,
+		0.000000f,
+		-0.118500f,
+		0.794500f,
+		-0.595600f,
+		0.781300f,
+		0.793100f,
+		-0.000000f,
+		0.398046f,
+		-0.302586f,
+		0.000000f,
+		0.000000f,
+		0.794500f,
+		-0.607300f,
+		0.750000f,
+		0.793100f,
+		-0.067082f,
+		0.362998f,
+		-0.337242f,
+		0.000000f,
+		-0.134500f,
+		0.724300f,
+		-0.676200f,
+		0.781300f,
+		0.758600f,
+		-0.000000f,
+		0.398046f,
+		-0.302586f,
+		0.000000f,
+		0.000000f,
+		0.794500f,
+		-0.607300f,
+		0.750000f,
+		0.793100f,
+		-0.000000f,
+		0.362998f,
+		-0.343849f,
+		0.000000f,
+		0.000000f,
+		0.724300f,
+		-0.689400f,
+		0.750000f,
+		0.758600f,
+		-0.074345f,
+		-0.323693f,
+		-0.373758f,
+		0.000000f,
+		-0.149000f,
+		-0.645700f,
+		-0.748900f,
+		0.781300f,
+		0.275900f,
+		-0.080738f,
+		-0.280594f,
+		-0.405892f,
+		0.000000f,
+		-0.161700f,
+		-0.559600f,
+		-0.812800f,
+		0.781300f,
+		0.310300f,
+		-0.000000f,
+		-0.280594f,
+		-0.413844f,
+		0.000000f,
+		0.000000f,
+		-0.559600f,
+		-0.828700f,
+		0.750000f,
+		0.310300f,
+		-0.074345f,
+		-0.323693f,
+		-0.373758f,
+		0.000000f,
+		-0.149000f,
+		-0.645700f,
+		-0.748900f,
+		0.781300f,
+		0.275900f,
+		-0.000000f,
+		-0.280594f,
+		-0.413844f,
+		0.000000f,
+		0.000000f,
+		-0.559600f,
+		-0.828700f,
+		0.750000f,
+		0.310300f,
+		-0.000000f,
+		-0.323693f,
+		-0.381081f,
+		0.000000f,
+		0.000000f,
+		-0.645700f,
+		-0.763500f,
+		0.750000f,
+		0.275900f,
+		-0.074345f,
+		0.323693f,
+		-0.373758f,
+		0.000000f,
+		-0.149000f,
+		0.645700f,
+		-0.748900f,
+		0.781300f,
+		0.724100f,
+		-0.067082f,
+		0.362998f,
+		-0.337242f,
+		0.000000f,
+		-0.134500f,
+		0.724300f,
+		-0.676200f,
+		0.781300f,
+		0.758600f,
+		-0.000000f,
+		0.362998f,
+		-0.343849f,
+		0.000000f,
+		0.000000f,
+		0.724300f,
+		-0.689400f,
+		0.750000f,
+		0.758600f,
+		-0.074345f,
+		0.323693f,
+		-0.373758f,
+		0.000000f,
+		-0.149000f,
+		0.645700f,
+		-0.748900f,
+		0.781300f,
+		0.724100f,
+		-0.000000f,
+		0.362998f,
+		-0.343849f,
+		0.000000f,
+		0.000000f,
+		0.724300f,
+		-0.689400f,
+		0.750000f,
+		0.758600f,
+		-0.000000f,
+		0.323693f,
+		-0.381081f,
+		0.000000f,
+		0.000000f,
+		0.645700f,
+		-0.763500f,
+		0.750000f,
+		0.724100f,
+		-0.000000f,
+		0.473826f,
+		-0.159651f,
+		0.000000f,
+		0.000000f,
+		0.946600f,
+		-0.322300f,
+		0.750000f,
+		0.896600f,
+		-0.000000f,
+		0.488310f,
+		-0.107485f,
+		0.000000f,
+		0.000000f,
+		0.975900f,
+		-0.218200f,
+		0.750000f,
+		0.931000f,
+		0.020969f,
+		0.488310f,
+		-0.105420f,
+		0.000000f,
+		0.042500f,
+		0.975900f,
+		-0.214000f,
+		0.718800f,
+		0.931000f,
+		-0.000000f,
+		0.473826f,
+		-0.159651f,
+		0.000000f,
+		0.000000f,
+		0.946600f,
+		-0.322300f,
+		0.750000f,
+		0.896600f,
+		0.020969f,
+		0.488310f,
+		-0.105420f,
+		0.000000f,
+		0.042500f,
+		0.975900f,
+		-0.214000f,
+		0.718800f,
+		0.931000f,
+		0.031146f,
+		0.473826f,
+		-0.156583f,
+		0.000000f,
+		0.062900f,
+		0.946600f,
+		-0.316100f,
+		0.718800f,
+		0.896600f,
+		-0.000000f,
+		-0.133764f,
+		-0.481775f,
+		0.000000f,
+		0.000000f,
+		-0.266600f,
+		-0.963800f,
+		0.750000f,
+		0.413800f,
+		-0.000000f,
+		-0.080891f,
+		-0.493412f,
+		0.000000f,
+		0.000000f,
+		-0.161200f,
+		-0.986900f,
+		0.750000f,
+		0.448300f,
+		0.096259f,
+		-0.080891f,
+		-0.483932f,
+		0.000000f,
+		0.192500f,
+		-0.161200f,
+		-0.967900f,
+		0.718800f,
+		0.448300f,
+		-0.000000f,
+		-0.133764f,
+		-0.481775f,
+		0.000000f,
+		0.000000f,
+		-0.266600f,
+		-0.963800f,
+		0.750000f,
+		0.413800f,
+		0.096259f,
+		-0.080891f,
+		-0.483932f,
+		0.000000f,
+		0.192500f,
+		-0.161200f,
+		-0.967900f,
+		0.718800f,
+		0.448300f,
+		0.093989f,
+		-0.133764f,
+		-0.472517f,
+		0.000000f,
+		0.188000f,
+		-0.266600f,
+		-0.945200f,
+		0.718800f,
+		0.413800f,
+		-0.000000f,
+		0.453788f,
+		-0.209944f,
+		0.000000f,
+		0.000000f,
+		0.906300f,
+		-0.422700f,
+		0.750000f,
+		0.862100f,
+		-0.000000f,
+		0.473826f,
+		-0.159651f,
+		0.000000f,
+		0.000000f,
+		0.946600f,
+		-0.322300f,
+		0.750000f,
+		0.896600f,
+		0.031146f,
+		0.473826f,
+		-0.156583f,
+		0.000000f,
+		0.062900f,
+		0.946600f,
+		-0.316100f,
+		0.718800f,
+		0.896600f,
+		-0.000000f,
+		0.453788f,
+		-0.209944f,
+		0.000000f,
+		0.000000f,
+		0.906300f,
+		-0.422700f,
+		0.750000f,
+		0.862100f,
+		0.031146f,
+		0.473826f,
+		-0.156583f,
+		0.000000f,
+		0.062900f,
+		0.946600f,
+		-0.316100f,
+		0.718800f,
+		0.896600f,
+		0.040957f,
+		0.453788f,
+		-0.205910f,
+		0.000000f,
+		0.082400f,
+		0.906300f,
+		-0.414500f,
+		0.718800f,
+		0.862100f,
+		-0.000000f,
+		-0.185069f,
+		-0.464488f,
+		0.000000f,
+		0.000000f,
+		-0.369000f,
+		-0.929400f,
+		0.750000f,
+		0.379300f,
+		-0.000000f,
+		-0.133764f,
+		-0.481775f,
+		0.000000f,
+		0.000000f,
+		-0.266600f,
+		-0.963800f,
+		0.750000f,
+		0.413800f,
+		0.093989f,
+		-0.133764f,
+		-0.472517f,
+		0.000000f,
+		0.188000f,
+		-0.266600f,
+		-0.945200f,
+		0.718800f,
+		0.413800f,
+		-0.000000f,
+		-0.185069f,
+		-0.464488f,
+		0.000000f,
+		0.000000f,
+		-0.369000f,
+		-0.929400f,
+		0.750000f,
+		0.379300f,
+		0.093989f,
+		-0.133764f,
+		-0.472517f,
+		0.000000f,
+		0.188000f,
+		-0.266600f,
+		-0.945200f,
+		0.718800f,
+		0.413800f,
+		0.090617f,
+		-0.185069f,
+		-0.455563f,
+		0.000000f,
+		0.181300f,
+		-0.369000f,
+		-0.911600f,
+		0.718800f,
+		0.379300f,
+		-0.000000f,
+		0.428429f,
+		-0.257776f,
+		0.000000f,
+		0.000000f,
+		0.855300f,
+		-0.518000f,
+		0.750000f,
+		0.827600f,
+		-0.000000f,
+		0.453788f,
+		-0.209944f,
+		0.000000f,
+		0.000000f,
+		0.906300f,
+		-0.422700f,
+		0.750000f,
+		0.862100f,
+		0.040957f,
+		0.453788f,
+		-0.205910f,
+		0.000000f,
+		0.082400f,
+		0.906300f,
+		-0.414500f,
+		0.718800f,
+		0.862100f,
+		-0.000000f,
+		0.428429f,
+		-0.257776f,
+		0.000000f,
+		0.000000f,
+		0.855300f,
+		-0.518000f,
+		0.750000f,
+		0.827600f,
+		0.040957f,
+		0.453788f,
+		-0.205910f,
+		0.000000f,
+		0.082400f,
+		0.906300f,
+		-0.414500f,
+		0.718800f,
+		0.862100f,
+		0.050290f,
+		0.428429f,
+		-0.252824f,
+		0.000000f,
+		0.101000f,
+		0.855300f,
+		-0.508100f,
+		0.718800f,
+		0.827600f,
+		-0.000000f,
+		-0.234204f,
+		-0.441756f,
+		0.000000f,
+		0.000000f,
+		-0.467000f,
+		-0.884200f,
+		0.750000f,
+		0.344800f,
+		-0.000000f,
+		-0.185069f,
+		-0.464488f,
+		0.000000f,
+		0.000000f,
+		-0.369000f,
+		-0.929400f,
+		0.750000f,
+		0.379300f,
+		0.090617f,
+		-0.185069f,
+		-0.455563f,
+		0.000000f,
+		0.181300f,
+		-0.369000f,
+		-0.911600f,
+		0.718800f,
+		0.379300f,
+		-0.000000f,
+		-0.234204f,
+		-0.441756f,
+		0.000000f,
+		0.000000f,
+		-0.467000f,
+		-0.884200f,
+		0.750000f,
+		0.344800f,
+		0.090617f,
+		-0.185069f,
+		-0.455563f,
+		0.000000f,
+		0.181300f,
+		-0.369000f,
+		-0.911600f,
+		0.718800f,
+		0.379300f,
+		0.086182f,
+		-0.234204f,
+		-0.433268f,
+		0.000000f,
+		0.172500f,
+		-0.467000f,
+		-0.867200f,
+		0.718800f,
+		0.344800f,
+		-0.000000f,
+		0.398046f,
+		-0.302586f,
+		0.000000f,
+		0.000000f,
+		0.794500f,
+		-0.607300f,
+		0.750000f,
+		0.793100f,
+		-0.000000f,
+		0.428429f,
+		-0.257776f,
+		0.000000f,
+		0.000000f,
+		0.855300f,
+		-0.518000f,
+		0.750000f,
+		0.827600f,
+		0.050290f,
+		0.428429f,
+		-0.252824f,
+		0.000000f,
+		0.101000f,
+		0.855300f,
+		-0.508100f,
+		0.718800f,
+		0.827600f,
+		-0.000000f,
+		0.398046f,
+		-0.302586f,
+		0.000000f,
+		0.000000f,
+		0.794500f,
+		-0.607300f,
+		0.750000f,
+		0.793100f,
+		0.050290f,
+		0.428429f,
+		-0.252824f,
+		0.000000f,
+		0.101000f,
+		0.855300f,
+		-0.508100f,
+		0.718800f,
+		0.827600f,
+		0.059032f,
+		0.398046f,
+		-0.296773f,
+		0.000000f,
+		0.118500f,
+		0.794500f,
+		-0.595600f,
+		0.718800f,
+		0.793100f,
+		-0.000000f,
+		-0.280594f,
+		-0.413844f,
+		0.000000f,
+		0.000000f,
+		-0.559600f,
+		-0.828700f,
+		0.750000f,
+		0.310300f,
+		-0.000000f,
+		-0.234204f,
+		-0.441756f,
+		0.000000f,
+		0.000000f,
+		-0.467000f,
+		-0.884200f,
+		0.750000f,
+		0.344800f,
+		0.086182f,
+		-0.234204f,
+		-0.433268f,
+		0.000000f,
+		0.172500f,
+		-0.467000f,
+		-0.867200f,
+		0.718800f,
+		0.344800f,
+		-0.000000f,
+		-0.280594f,
+		-0.413844f,
+		0.000000f,
+		0.000000f,
+		-0.559600f,
+		-0.828700f,
+		0.750000f,
+		0.310300f,
+		0.086182f,
+		-0.234204f,
+		-0.433268f,
+		0.000000f,
+		0.172500f,
+		-0.467000f,
+		-0.867200f,
+		0.718800f,
+		0.344800f,
+		0.080737f,
+		-0.280594f,
+		-0.405892f,
+		0.000000f,
+		0.161700f,
+		-0.559600f,
+		-0.812800f,
+		0.718800f,
+		0.310300f,
+		-0.000000f,
+		0.362998f,
+		-0.343849f,
+		0.000000f,
+		0.000000f,
+		0.724300f,
+		-0.689400f,
+		0.750000f,
+		0.758600f,
+		-0.000000f,
+		0.398046f,
+		-0.302586f,
+		0.000000f,
+		0.000000f,
+		0.794500f,
+		-0.607300f,
+		0.750000f,
+		0.793100f,
+		0.059032f,
+		0.398046f,
+		-0.296773f,
+		0.000000f,
+		0.118500f,
+		0.794500f,
+		-0.595600f,
+		0.718800f,
+		0.793100f,
+		-0.000000f,
+		0.362998f,
+		-0.343849f,
+		0.000000f,
+		0.000000f,
+		0.724300f,
+		-0.689400f,
+		0.750000f,
+		0.758600f,
+		0.059032f,
+		0.398046f,
+		-0.296773f,
+		0.000000f,
+		0.118500f,
+		0.794500f,
+		-0.595600f,
+		0.718800f,
+		0.793100f,
+		0.067081f,
+		0.362998f,
+		-0.337242f,
+		0.000000f,
+		0.134500f,
+		0.724300f,
+		-0.676200f,
+		0.718800f,
+		0.758600f,
+		-0.000000f,
+		-0.323693f,
+		-0.381081f,
+		0.000000f,
+		0.000000f,
+		-0.645700f,
+		-0.763500f,
+		0.750000f,
+		0.275900f,
+		-0.000000f,
+		-0.280594f,
+		-0.413844f,
+		0.000000f,
+		0.000000f,
+		-0.559600f,
+		-0.828700f,
+		0.750000f,
+		0.310300f,
+		0.080737f,
+		-0.280594f,
+		-0.405892f,
+		0.000000f,
+		0.161700f,
+		-0.559600f,
+		-0.812800f,
+		0.718800f,
+		0.310300f,
+		-0.000000f,
+		-0.323693f,
+		-0.381081f,
+		0.000000f,
+		0.000000f,
+		-0.645700f,
+		-0.763500f,
+		0.750000f,
+		0.275900f,
+		0.080737f,
+		-0.280594f,
+		-0.405892f,
+		0.000000f,
+		0.161700f,
+		-0.559600f,
+		-0.812800f,
+		0.718800f,
+		0.310300f,
+		0.074345f,
+		-0.323693f,
+		-0.373758f,
+		0.000000f,
+		0.149000f,
+		-0.645700f,
+		-0.748900f,
+		0.718800f,
+		0.275900f,
+		-0.000000f,
+		0.323693f,
+		-0.381081f,
+		0.000000f,
+		0.000000f,
+		0.645700f,
+		-0.763500f,
+		0.750000f,
+		0.724100f,
+		-0.000000f,
+		0.362998f,
+		-0.343849f,
+		0.000000f,
+		0.000000f,
+		0.724300f,
+		-0.689400f,
+		0.750000f,
+		0.758600f,
+		0.067081f,
+		0.362998f,
+		-0.337242f,
+		0.000000f,
+		0.134500f,
+		0.724300f,
+		-0.676200f,
+		0.718800f,
+		0.758600f,
+		-0.000000f,
+		0.323693f,
+		-0.381081f,
+		0.000000f,
+		0.000000f,
+		0.645700f,
+		-0.763500f,
+		0.750000f,
+		0.724100f,
+		0.067081f,
+		0.362998f,
+		-0.337242f,
+		0.000000f,
+		0.134500f,
+		0.724300f,
+		-0.676200f,
+		0.718800f,
+		0.758600f,
+		0.074345f,
+		0.323693f,
+		-0.373758f,
+		0.000000f,
+		0.149000f,
+		0.645700f,
+		-0.748900f,
+		0.718800f,
+		0.724100f,
+		-0.000000f,
+		-0.362998f,
+		-0.343850f,
+		0.000000f,
+		0.000000f,
+		-0.724300f,
+		-0.689400f,
+		0.750000f,
+		0.241400f,
+		-0.000000f,
+		-0.323693f,
+		-0.381081f,
+		0.000000f,
+		0.000000f,
+		-0.645700f,
+		-0.763500f,
+		0.750000f,
+		0.275900f,
+		0.074345f,
+		-0.323693f,
+		-0.373758f,
+		0.000000f,
+		0.149000f,
+		-0.645700f,
+		-0.748900f,
+		0.718800f,
+		0.275900f,
+		-0.000000f,
+		-0.362998f,
+		-0.343850f,
+		0.000000f,
+		0.000000f,
+		-0.724300f,
+		-0.689400f,
+		0.750000f,
+		0.241400f,
+		0.074345f,
+		-0.323693f,
+		-0.373758f,
+		0.000000f,
+		0.149000f,
+		-0.645700f,
+		-0.748900f,
+		0.718800f,
+		0.275900f,
+		0.067081f,
+		-0.362998f,
+		-0.337243f,
+		0.000000f,
+		0.134500f,
+		-0.724300f,
+		-0.676200f,
+		0.718800f,
+		0.241400f,
+		-0.000000f,
+		0.280594f,
+		-0.413844f,
+		0.000000f,
+		0.000000f,
+		0.559600f,
+		-0.828700f,
+		0.750000f,
+		0.689700f,
+		-0.000000f,
+		0.323693f,
+		-0.381081f,
+		0.000000f,
+		0.000000f,
+		0.645700f,
+		-0.763500f,
+		0.750000f,
+		0.724100f,
+		0.074345f,
+		0.323693f,
+		-0.373758f,
+		0.000000f,
+		0.149000f,
+		0.645700f,
+		-0.748900f,
+		0.718800f,
+		0.724100f,
+		-0.000000f,
+		0.280594f,
+		-0.413844f,
+		0.000000f,
+		0.000000f,
+		0.559600f,
+		-0.828700f,
+		0.750000f,
+		0.689700f,
+		0.074345f,
+		0.323693f,
+		-0.373758f,
+		0.000000f,
+		0.149000f,
+		0.645700f,
+		-0.748900f,
+		0.718800f,
+		0.724100f,
+		0.080737f,
+		0.280594f,
+		-0.405892f,
+		0.000000f,
+		0.161700f,
+		0.559600f,
+		-0.812800f,
+		0.718800f,
+		0.689700f,
+		-0.000000f,
+		-0.398046f,
+		-0.302587f,
+		0.000000f,
+		0.000000f,
+		-0.794500f,
+		-0.607300f,
+		0.750000f,
+		0.206900f,
+		-0.000000f,
+		-0.362998f,
+		-0.343850f,
+		0.000000f,
+		0.000000f,
+		-0.724300f,
+		-0.689400f,
+		0.750000f,
+		0.241400f,
+		0.067081f,
+		-0.362998f,
+		-0.337243f,
+		0.000000f,
+		0.134500f,
+		-0.724300f,
+		-0.676200f,
+		0.718800f,
+		0.241400f,
+		-0.000000f,
+		-0.398046f,
+		-0.302587f,
+		0.000000f,
+		0.000000f,
+		-0.794500f,
+		-0.607300f,
+		0.750000f,
+		0.206900f,
+		0.067081f,
+		-0.362998f,
+		-0.337243f,
+		0.000000f,
+		0.134500f,
+		-0.724300f,
+		-0.676200f,
+		0.718800f,
+		0.241400f,
+		0.059032f,
+		-0.398046f,
+		-0.296773f,
+		0.000000f,
+		0.118500f,
+		-0.794500f,
+		-0.595600f,
+		0.718800f,
+		0.206900f,
+		-0.000000f,
+		0.234204f,
+		-0.441756f,
+		0.000000f,
+		0.000000f,
+		0.467000f,
+		-0.884200f,
+		0.750000f,
+		0.655200f,
+		-0.000000f,
+		0.280594f,
+		-0.413844f,
+		0.000000f,
+		0.000000f,
+		0.559600f,
+		-0.828700f,
+		0.750000f,
+		0.689700f,
+		0.080737f,
+		0.280594f,
+		-0.405892f,
+		0.000000f,
+		0.161700f,
+		0.559600f,
+		-0.812800f,
+		0.718800f,
+		0.689700f,
+		-0.000000f,
+		0.234204f,
+		-0.441756f,
+		0.000000f,
+		0.000000f,
+		0.467000f,
+		-0.884200f,
+		0.750000f,
+		0.655200f,
+		0.080737f,
+		0.280594f,
+		-0.405892f,
+		0.000000f,
+		0.161700f,
+		0.559600f,
+		-0.812800f,
+		0.718800f,
+		0.689700f,
+		0.086182f,
+		0.234204f,
+		-0.433268f,
+		0.000000f,
+		0.172500f,
+		0.467000f,
+		-0.867200f,
+		0.718800f,
+		0.655200f,
+		-0.000000f,
+		-0.428429f,
+		-0.257776f,
+		0.000000f,
+		0.000000f,
+		-0.855300f,
+		-0.518000f,
+		0.750000f,
+		0.172400f,
+		-0.000000f,
+		-0.398046f,
+		-0.302587f,
+		0.000000f,
+		0.000000f,
+		-0.794500f,
+		-0.607300f,
+		0.750000f,
+		0.206900f,
+		0.059032f,
+		-0.398046f,
+		-0.296773f,
+		0.000000f,
+		0.118500f,
+		-0.794500f,
+		-0.595600f,
+		0.718800f,
+		0.206900f,
+		-0.000000f,
+		-0.428429f,
+		-0.257776f,
+		0.000000f,
+		0.000000f,
+		-0.855300f,
+		-0.518000f,
+		0.750000f,
+		0.172400f,
+		0.059032f,
+		-0.398046f,
+		-0.296773f,
+		0.000000f,
+		0.118500f,
+		-0.794500f,
+		-0.595600f,
+		0.718800f,
+		0.206900f,
+		0.050290f,
+		-0.428429f,
+		-0.252824f,
+		0.000000f,
+		0.101000f,
+		-0.855300f,
+		-0.508100f,
+		0.718800f,
+		0.172400f,
+		-0.000000f,
+		0.185069f,
+		-0.464488f,
+		0.000000f,
+		0.000000f,
+		0.369000f,
+		-0.929400f,
+		0.750000f,
+		0.620700f,
+		-0.000000f,
+		0.234204f,
+		-0.441756f,
+		0.000000f,
+		0.000000f,
+		0.467000f,
+		-0.884200f,
+		0.750000f,
+		0.655200f,
+		0.086182f,
+		0.234204f,
+		-0.433268f,
+		0.000000f,
+		0.172500f,
+		0.467000f,
+		-0.867200f,
+		0.718800f,
+		0.655200f,
+		-0.000000f,
+		0.185069f,
+		-0.464488f,
+		0.000000f,
+		0.000000f,
+		0.369000f,
+		-0.929400f,
+		0.750000f,
+		0.620700f,
+		0.086182f,
+		0.234204f,
+		-0.433268f,
+		0.000000f,
+		0.172500f,
+		0.467000f,
+		-0.867200f,
+		0.718800f,
+		0.655200f,
+		0.090617f,
+		0.185069f,
+		-0.455563f,
+		0.000000f,
+		0.181300f,
+		0.369000f,
+		-0.911600f,
+		0.718800f,
+		0.620700f,
+		-0.000000f,
+		-0.453788f,
+		-0.209945f,
+		0.000000f,
+		0.000000f,
+		-0.906300f,
+		-0.422700f,
+		0.750000f,
+		0.137900f,
+		-0.000000f,
+		-0.428429f,
+		-0.257776f,
+		0.000000f,
+		0.000000f,
+		-0.855300f,
+		-0.518000f,
+		0.750000f,
+		0.172400f,
+		0.050290f,
+		-0.428429f,
+		-0.252824f,
+		0.000000f,
+		0.101000f,
+		-0.855300f,
+		-0.508100f,
+		0.718800f,
+		0.172400f,
+		-0.000000f,
+		-0.453788f,
+		-0.209945f,
+		0.000000f,
+		0.000000f,
+		-0.906300f,
+		-0.422700f,
+		0.750000f,
+		0.137900f,
+		0.050290f,
+		-0.428429f,
+		-0.252824f,
+		0.000000f,
+		0.101000f,
+		-0.855300f,
+		-0.508100f,
+		0.718800f,
+		0.172400f,
+		0.040957f,
+		-0.453788f,
+		-0.205911f,
+		0.000000f,
+		0.082400f,
+		-0.906300f,
+		-0.414500f,
+		0.718800f,
+		0.137900f,
+		-0.000000f,
+		0.133764f,
+		-0.481775f,
+		0.000000f,
+		0.000000f,
+		0.266600f,
+		-0.963800f,
+		0.750000f,
+		0.586200f,
+		-0.000000f,
+		0.185069f,
+		-0.464488f,
+		0.000000f,
+		0.000000f,
+		0.369000f,
+		-0.929400f,
+		0.750000f,
+		0.620700f,
+		0.090617f,
+		0.185069f,
+		-0.455563f,
+		0.000000f,
+		0.181300f,
+		0.369000f,
+		-0.911600f,
+		0.718800f,
+		0.620700f,
+		-0.000000f,
+		0.133764f,
+		-0.481775f,
+		0.000000f,
+		0.000000f,
+		0.266600f,
+		-0.963800f,
+		0.750000f,
+		0.586200f,
+		0.090617f,
+		0.185069f,
+		-0.455563f,
+		0.000000f,
+		0.181300f,
+		0.369000f,
+		-0.911600f,
+		0.718800f,
+		0.620700f,
+		0.093989f,
+		0.133764f,
+		-0.472517f,
+		0.000000f,
+		0.188000f,
+		0.266600f,
+		-0.945200f,
+		0.718800f,
+		0.586200f,
+		-0.000000f,
+		-0.473826f,
+		-0.159651f,
+		0.000000f,
+		0.000000f,
+		-0.946600f,
+		-0.322300f,
+		0.750000f,
+		0.103400f,
+		-0.000000f,
+		-0.453788f,
+		-0.209945f,
+		0.000000f,
+		0.000000f,
+		-0.906300f,
+		-0.422700f,
+		0.750000f,
+		0.137900f,
+		0.040957f,
+		-0.453788f,
+		-0.205911f,
+		0.000000f,
+		0.082400f,
+		-0.906300f,
+		-0.414500f,
+		0.718800f,
+		0.137900f,
+		-0.000000f,
+		-0.473826f,
+		-0.159651f,
+		0.000000f,
+		0.000000f,
+		-0.946600f,
+		-0.322300f,
+		0.750000f,
+		0.103400f,
+		0.040957f,
+		-0.453788f,
+		-0.205911f,
+		0.000000f,
+		0.082400f,
+		-0.906300f,
+		-0.414500f,
+		0.718800f,
+		0.137900f,
+		0.031146f,
+		-0.473826f,
+		-0.156583f,
+		0.000000f,
+		0.062900f,
+		-0.946600f,
+		-0.316100f,
+		0.718800f,
+		0.103400f,
+		-0.000000f,
+		0.080891f,
+		-0.493412f,
+		0.000000f,
+		0.000000f,
+		0.161200f,
+		-0.986900f,
+		0.750000f,
+		0.551700f,
+		-0.000000f,
+		0.133764f,
+		-0.481775f,
+		0.000000f,
+		0.000000f,
+		0.266600f,
+		-0.963800f,
+		0.750000f,
+		0.586200f,
+		0.093989f,
+		0.133764f,
+		-0.472517f,
+		0.000000f,
+		0.188000f,
+		0.266600f,
+		-0.945200f,
+		0.718800f,
+		0.586200f,
+		-0.000000f,
+		0.080891f,
+		-0.493412f,
+		0.000000f,
+		0.000000f,
+		0.161200f,
+		-0.986900f,
+		0.750000f,
+		0.551700f,
+		0.093989f,
+		0.133764f,
+		-0.472517f,
+		0.000000f,
+		0.188000f,
+		0.266600f,
+		-0.945200f,
+		0.718800f,
+		0.586200f,
+		0.096259f,
+		0.080891f,
+		-0.483932f,
+		0.000000f,
+		0.192500f,
+		0.161200f,
+		-0.967900f,
+		0.718800f,
+		0.551700f,
+		-0.000000f,
+		-0.488310f,
+		-0.107485f,
+		0.000000f,
+		0.000000f,
+		-0.975900f,
+		-0.218200f,
+		0.750000f,
+		0.069000f,
+		-0.000000f,
+		-0.473826f,
+		-0.159651f,
+		0.000000f,
+		0.000000f,
+		-0.946600f,
+		-0.322300f,
+		0.750000f,
+		0.103400f,
+		0.031146f,
+		-0.473826f,
+		-0.156583f,
+		0.000000f,
+		0.062900f,
+		-0.946600f,
+		-0.316100f,
+		0.718800f,
+		0.103400f,
+		-0.000000f,
+		-0.488310f,
+		-0.107485f,
+		0.000000f,
+		0.000000f,
+		-0.975900f,
+		-0.218200f,
+		0.750000f,
+		0.069000f,
+		0.031146f,
+		-0.473826f,
+		-0.156583f,
+		0.000000f,
+		0.062900f,
+		-0.946600f,
+		-0.316100f,
+		0.718800f,
+		0.103400f,
+		0.020969f,
+		-0.488310f,
+		-0.105420f,
+		0.000000f,
+		0.042500f,
+		-0.975900f,
+		-0.214000f,
+		0.718800f,
+		0.069000f,
+		-0.000000f,
+		0.027069f,
+		-0.499266f,
+		0.000000f,
+		0.000000f,
+		0.054000f,
+		-0.998500f,
+		0.750000f,
+		0.517200f,
+		-0.000000f,
+		0.080891f,
+		-0.493412f,
+		0.000000f,
+		0.000000f,
+		0.161200f,
+		-0.986900f,
+		0.750000f,
+		0.551700f,
+		0.096259f,
+		0.080891f,
+		-0.483932f,
+		0.000000f,
+		0.192500f,
+		0.161200f,
+		-0.967900f,
+		0.718800f,
+		0.551700f,
+		-0.000000f,
+		0.027069f,
+		-0.499266f,
+		0.000000f,
+		0.000000f,
+		0.054000f,
+		-0.998500f,
+		0.750000f,
+		0.517200f,
+		0.096259f,
+		0.080891f,
+		-0.483932f,
+		0.000000f,
+		0.192500f,
+		0.161200f,
+		-0.967900f,
+		0.718800f,
+		0.551700f,
+		0.097401f,
+		0.027069f,
+		-0.489673f,
+		0.000000f,
+		0.194800f,
+		0.054000f,
+		-0.979300f,
+		0.718800f,
+		0.517200f,
+		-0.000000f,
+		0.497069f,
+		-0.054059f,
+		0.000000f,
+		0.000000f,
+		0.993700f,
+		-0.111500f,
+		0.441700f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.423900f,
+		0.960300f,
+		0.010546f,
+		0.497069f,
+		-0.053020f,
+		0.000000f,
+		0.021700f,
+		0.993700f,
+		-0.109300f,
+		0.443500f,
+		0.962300f,
+		-0.000000f,
+		-0.497069f,
+		-0.054060f,
+		0.000000f,
+		0.000000f,
+		-0.993700f,
+		-0.111500f,
+		0.750000f,
+		0.034500f,
+		-0.000000f,
+		-0.488310f,
+		-0.107485f,
+		0.000000f,
+		0.000000f,
+		-0.975900f,
+		-0.218200f,
+		0.750000f,
+		0.069000f,
+		0.020969f,
+		-0.488310f,
+		-0.105420f,
+		0.000000f,
+		0.042500f,
+		-0.975900f,
+		-0.214000f,
+		0.718800f,
+		0.069000f,
+		-0.000000f,
+		-0.497069f,
+		-0.054060f,
+		0.000000f,
+		0.000000f,
+		-0.993700f,
+		-0.111500f,
+		0.750000f,
+		0.034500f,
+		0.020969f,
+		-0.488310f,
+		-0.105420f,
+		0.000000f,
+		0.042500f,
+		-0.975900f,
+		-0.214000f,
+		0.718800f,
+		0.069000f,
+		0.010546f,
+		-0.497069f,
+		-0.053020f,
+		0.000000f,
+		0.021700f,
+		-0.993700f,
+		-0.109300f,
+		0.718800f,
+		0.034500f,
+		-0.000000f,
+		-0.027069f,
+		-0.499266f,
+		0.000000f,
+		0.000000f,
+		-0.054000f,
+		-0.998500f,
+		0.750000f,
+		0.482800f,
+		-0.000000f,
+		0.027069f,
+		-0.499266f,
+		0.000000f,
+		0.000000f,
+		0.054000f,
+		-0.998500f,
+		0.750000f,
+		0.517200f,
+		0.097401f,
+		0.027069f,
+		-0.489673f,
+		0.000000f,
+		0.194800f,
+		0.054000f,
+		-0.979300f,
+		0.718800f,
+		0.517200f,
+		-0.000000f,
+		-0.027069f,
+		-0.499266f,
+		0.000000f,
+		0.000000f,
+		-0.054000f,
+		-0.998500f,
+		0.750000f,
+		0.482800f,
+		0.097401f,
+		0.027069f,
+		-0.489673f,
+		0.000000f,
+		0.194800f,
+		0.054000f,
+		-0.979300f,
+		0.718800f,
+		0.517200f,
+		0.097401f,
+		-0.027069f,
+		-0.489673f,
+		0.000000f,
+		0.194800f,
+		-0.054000f,
+		-0.979300f,
+		0.718800f,
+		0.482800f,
+		-0.000000f,
+		0.488310f,
+		-0.107485f,
+		0.000000f,
+		0.000000f,
+		0.975900f,
+		-0.218200f,
+		0.750000f,
+		0.931000f,
+		-0.000000f,
+		0.497069f,
+		-0.054059f,
+		0.000000f,
+		0.000000f,
+		0.993700f,
+		-0.111500f,
+		0.750000f,
+		0.965500f,
+		0.010546f,
+		0.497069f,
+		-0.053020f,
+		0.000000f,
+		0.021700f,
+		0.993700f,
+		-0.109300f,
+		0.718800f,
+		0.965500f,
+		-0.000000f,
+		0.488310f,
+		-0.107485f,
+		0.000000f,
+		0.000000f,
+		0.975900f,
+		-0.218200f,
+		0.750000f,
+		0.931000f,
+		0.010546f,
+		0.497069f,
+		-0.053020f,
+		0.000000f,
+		0.021700f,
+		0.993700f,
+		-0.109300f,
+		0.718800f,
+		0.965500f,
+		0.020969f,
+		0.488310f,
+		-0.105420f,
+		0.000000f,
+		0.042500f,
+		0.975900f,
+		-0.214000f,
+		0.718800f,
+		0.931000f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.495500f,
+		0.051000f,
+		-0.000000f,
+		-0.497069f,
+		-0.054060f,
+		0.000000f,
+		0.000000f,
+		-0.993700f,
+		-0.111500f,
+		0.473300f,
+		0.053800f,
+		0.010546f,
+		-0.497069f,
+		-0.053020f,
+		0.000000f,
+		0.021700f,
+		-0.993700f,
+		-0.109300f,
+		0.470600f,
+		0.053800f,
+		-0.000000f,
+		-0.080891f,
+		-0.493412f,
+		0.000000f,
+		0.000000f,
+		-0.161200f,
+		-0.986900f,
+		0.750000f,
+		0.448300f,
+		-0.000000f,
+		-0.027069f,
+		-0.499266f,
+		0.000000f,
+		0.000000f,
+		-0.054000f,
+		-0.998500f,
+		0.750000f,
+		0.482800f,
+		0.097401f,
+		-0.027069f,
+		-0.489673f,
+		0.000000f,
+		0.194800f,
+		-0.054000f,
+		-0.979300f,
+		0.718800f,
+		0.482800f,
+		-0.000000f,
+		-0.080891f,
+		-0.493412f,
+		0.000000f,
+		0.000000f,
+		-0.161200f,
+		-0.986900f,
+		0.750000f,
+		0.448300f,
+		0.097401f,
+		-0.027069f,
+		-0.489673f,
+		0.000000f,
+		0.194800f,
+		-0.054000f,
+		-0.979300f,
+		0.718800f,
+		0.482800f,
+		0.096259f,
+		-0.080891f,
+		-0.483932f,
+		0.000000f,
+		0.192500f,
+		-0.161200f,
+		-0.967900f,
+		0.718800f,
+		0.448300f,
+		0.090617f,
+		0.185069f,
+		-0.455563f,
+		0.000000f,
+		0.181300f,
+		0.369000f,
+		-0.911600f,
+		0.718800f,
+		0.620700f,
+		0.086182f,
+		0.234204f,
+		-0.433268f,
+		0.000000f,
+		0.172500f,
+		0.467000f,
+		-0.867200f,
+		0.718800f,
+		0.655200f,
+		0.169052f,
+		0.234204f,
+		-0.408129f,
+		0.000000f,
+		0.338400f,
+		0.467000f,
+		-0.816900f,
+		0.687500f,
+		0.655200f,
+		0.090617f,
+		0.185069f,
+		-0.455563f,
+		0.000000f,
+		0.181300f,
+		0.369000f,
+		-0.911600f,
+		0.718800f,
+		0.620700f,
+		0.169052f,
+		0.234204f,
+		-0.408129f,
+		0.000000f,
+		0.338400f,
+		0.467000f,
+		-0.816900f,
+		0.687500f,
+		0.655200f,
+		0.177751f,
+		0.185069f,
+		-0.429130f,
+		0.000000f,
+		0.355700f,
+		0.369000f,
+		-0.858700f,
+		0.687500f,
+		0.620700f,
+		0.040957f,
+		-0.453788f,
+		-0.205911f,
+		0.000000f,
+		0.082400f,
+		-0.906300f,
+		-0.414500f,
+		0.718800f,
+		0.137900f,
+		0.050290f,
+		-0.428429f,
+		-0.252824f,
+		0.000000f,
+		0.101000f,
+		-0.855300f,
+		-0.508100f,
+		0.718800f,
+		0.172400f,
+		0.098646f,
+		-0.428429f,
+		-0.238155f,
+		0.000000f,
+		0.198200f,
+		-0.855300f,
+		-0.478600f,
+		0.687500f,
+		0.172400f,
+		0.040957f,
+		-0.453788f,
+		-0.205911f,
+		0.000000f,
+		0.082400f,
+		-0.906300f,
+		-0.414500f,
+		0.718800f,
+		0.137900f,
+		0.098646f,
+		-0.428429f,
+		-0.238155f,
+		0.000000f,
+		0.198200f,
+		-0.855300f,
+		-0.478600f,
+		0.687500f,
+		0.172400f,
+		0.080342f,
+		-0.453788f,
+		-0.193963f,
+		0.000000f,
+		0.161700f,
+		-0.906300f,
+		-0.390500f,
+		0.687500f,
+		0.137900f,
+		0.093989f,
+		0.133764f,
+		-0.472517f,
+		0.000000f,
+		0.188000f,
+		0.266600f,
+		-0.945200f,
+		0.718800f,
+		0.586200f,
+		0.090617f,
+		0.185069f,
+		-0.455563f,
+		0.000000f,
+		0.181300f,
+		0.369000f,
+		-0.911600f,
+		0.718800f,
+		0.620700f,
+		0.177751f,
+		0.185069f,
+		-0.429130f,
+		0.000000f,
+		0.355700f,
+		0.369000f,
+		-0.858700f,
+		0.687500f,
+		0.620700f,
+		0.093989f,
+		0.133764f,
+		-0.472517f,
+		0.000000f,
+		0.188000f,
+		0.266600f,
+		-0.945200f,
+		0.718800f,
+		0.586200f,
+		0.177751f,
+		0.185069f,
+		-0.429130f,
+		0.000000f,
+		0.355700f,
+		0.369000f,
+		-0.858700f,
+		0.687500f,
+		0.620700f,
+		0.184366f,
+		0.133764f,
+		-0.445101f,
+		0.000000f,
+		0.368800f,
+		0.266600f,
+		-0.890400f,
+		0.687500f,
+		0.586200f,
+		0.031146f,
+		-0.473826f,
+		-0.156583f,
+		0.000000f,
+		0.062900f,
+		-0.946600f,
+		-0.316100f,
+		0.718800f,
+		0.103400f,
+		0.040957f,
+		-0.453788f,
+		-0.205911f,
+		0.000000f,
+		0.082400f,
+		-0.906300f,
+		-0.414500f,
+		0.718800f,
+		0.137900f,
+		0.080342f,
+		-0.453788f,
+		-0.193963f,
+		0.000000f,
+		0.161700f,
+		-0.906300f,
+		-0.390500f,
+		0.687500f,
+		0.137900f,
+		0.031146f,
+		-0.473826f,
+		-0.156583f,
+		0.000000f,
+		0.062900f,
+		-0.946600f,
+		-0.316100f,
+		0.718800f,
+		0.103400f,
+		0.080342f,
+		-0.453788f,
+		-0.193963f,
+		0.000000f,
+		0.161700f,
+		-0.906300f,
+		-0.390500f,
+		0.687500f,
+		0.137900f,
+		0.061095f,
+		-0.473826f,
+		-0.147498f,
+		0.000000f,
+		0.123300f,
+		-0.946600f,
+		-0.297800f,
+		0.687500f,
+		0.103400f,
+		0.096259f,
+		0.080891f,
+		-0.483932f,
+		0.000000f,
+		0.192500f,
+		0.161200f,
+		-0.967900f,
+		0.718800f,
+		0.551700f,
+		0.093989f,
+		0.133764f,
+		-0.472517f,
+		0.000000f,
+		0.188000f,
+		0.266600f,
+		-0.945200f,
+		0.718800f,
+		0.586200f,
+		0.184366f,
+		0.133764f,
+		-0.445101f,
+		0.000000f,
+		0.368800f,
+		0.266600f,
+		-0.890400f,
+		0.687500f,
+		0.586200f,
+		0.096259f,
+		0.080891f,
+		-0.483932f,
+		0.000000f,
+		0.192500f,
+		0.161200f,
+		-0.967900f,
+		0.718800f,
+		0.551700f,
+		0.184366f,
+		0.133764f,
+		-0.445101f,
+		0.000000f,
+		0.368800f,
+		0.266600f,
+		-0.890400f,
+		0.687500f,
+		0.586200f,
+		0.188820f,
+		0.080891f,
+		-0.455854f,
+		0.000000f,
+		0.377700f,
+		0.161200f,
+		-0.911800f,
+		0.687500f,
+		0.551700f,
+		0.020969f,
+		-0.488310f,
+		-0.105420f,
+		0.000000f,
+		0.042500f,
+		-0.975900f,
+		-0.214000f,
+		0.718800f,
+		0.069000f,
+		0.031146f,
+		-0.473826f,
+		-0.156583f,
+		0.000000f,
+		0.062900f,
+		-0.946600f,
+		-0.316100f,
+		0.718800f,
+		0.103400f,
+		0.061095f,
+		-0.473826f,
+		-0.147498f,
+		0.000000f,
+		0.123300f,
+		-0.946600f,
+		-0.297800f,
+		0.687500f,
+		0.103400f,
+		0.020969f,
+		-0.488310f,
+		-0.105420f,
+		0.000000f,
+		0.042500f,
+		-0.975900f,
+		-0.214000f,
+		0.718800f,
+		0.069000f,
+		0.061095f,
+		-0.473826f,
+		-0.147498f,
+		0.000000f,
+		0.123300f,
+		-0.946600f,
+		-0.297800f,
+		0.687500f,
+		0.103400f,
+		0.041132f,
+		-0.488310f,
+		-0.099303f,
+		0.000000f,
+		0.083500f,
+		-0.975900f,
+		-0.201600f,
+		0.687500f,
+		0.069000f,
+		0.097401f,
+		0.027069f,
+		-0.489673f,
+		0.000000f,
+		0.194800f,
+		0.054000f,
+		-0.979300f,
+		0.718800f,
+		0.517200f,
+		0.096259f,
+		0.080891f,
+		-0.483932f,
+		0.000000f,
+		0.192500f,
+		0.161200f,
+		-0.967900f,
+		0.718800f,
+		0.551700f,
+		0.188820f,
+		0.080891f,
+		-0.455854f,
+		0.000000f,
+		0.377700f,
+		0.161200f,
+		-0.911800f,
+		0.687500f,
+		0.551700f,
+		0.097401f,
+		0.027069f,
+		-0.489673f,
+		0.000000f,
+		0.194800f,
+		0.054000f,
+		-0.979300f,
+		0.718800f,
+		0.517200f,
+		0.188820f,
+		0.080891f,
+		-0.455854f,
+		0.000000f,
+		0.377700f,
+		0.161200f,
+		-0.911800f,
+		0.687500f,
+		0.551700f,
+		0.191060f,
+		0.027069f,
+		-0.461262f,
+		0.000000f,
+		0.382100f,
+		0.054000f,
+		-0.922500f,
+		0.687500f,
+		0.517200f,
+		0.010546f,
+		0.497069f,
+		-0.053020f,
+		0.000000f,
+		0.021700f,
+		0.993700f,
+		-0.109300f,
+		0.443500f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.423900f,
+		0.960300f,
+		0.020687f,
+		0.497069f,
+		-0.049944f,
+		0.000000f,
+		0.042600f,
+		0.993700f,
+		-0.103000f,
+		0.445300f,
+		0.962300f,
+		0.010546f,
+		-0.497069f,
+		-0.053020f,
+		0.000000f,
+		0.021700f,
+		-0.993700f,
+		-0.109300f,
+		0.718800f,
+		0.034500f,
+		0.020969f,
+		-0.488310f,
+		-0.105420f,
+		0.000000f,
+		0.042500f,
+		-0.975900f,
+		-0.214000f,
+		0.718800f,
+		0.069000f,
+		0.041132f,
+		-0.488310f,
+		-0.099303f,
+		0.000000f,
+		0.083500f,
+		-0.975900f,
+		-0.201600f,
+		0.687500f,
+		0.069000f,
+		0.010546f,
+		-0.497069f,
+		-0.053020f,
+		0.000000f,
+		0.021700f,
+		-0.993700f,
+		-0.109300f,
+		0.718800f,
+		0.034500f,
+		0.041132f,
+		-0.488310f,
+		-0.099303f,
+		0.000000f,
+		0.083500f,
+		-0.975900f,
+		-0.201600f,
+		0.687500f,
+		0.069000f,
+		0.020687f,
+		-0.497069f,
+		-0.049945f,
+		0.000000f,
+		0.042600f,
+		-0.993700f,
+		-0.103000f,
+		0.687500f,
+		0.034500f,
+		0.097401f,
+		-0.027069f,
+		-0.489673f,
+		0.000000f,
+		0.194800f,
+		-0.054000f,
+		-0.979300f,
+		0.718800f,
+		0.482800f,
+		0.097401f,
+		0.027069f,
+		-0.489673f,
+		0.000000f,
+		0.194800f,
+		0.054000f,
+		-0.979300f,
+		0.718800f,
+		0.517200f,
+		0.191060f,
+		0.027069f,
+		-0.461262f,
+		0.000000f,
+		0.382100f,
+		0.054000f,
+		-0.922500f,
+		0.687500f,
+		0.517200f,
+		0.097401f,
+		-0.027069f,
+		-0.489673f,
+		0.000000f,
+		0.194800f,
+		-0.054000f,
+		-0.979300f,
+		0.718800f,
+		0.482800f,
+		0.191060f,
+		0.027069f,
+		-0.461262f,
+		0.000000f,
+		0.382100f,
+		0.054000f,
+		-0.922500f,
+		0.687500f,
+		0.517200f,
+		0.191060f,
+		-0.027069f,
+		-0.461262f,
+		0.000000f,
+		0.382100f,
+		-0.054000f,
+		-0.922500f,
+		0.687500f,
+		0.482800f,
+		0.020969f,
+		0.488310f,
+		-0.105420f,
+		0.000000f,
+		0.042500f,
+		0.975900f,
+		-0.214000f,
+		0.718800f,
+		0.931000f,
+		0.010546f,
+		0.497069f,
+		-0.053020f,
+		0.000000f,
+		0.021700f,
+		0.993700f,
+		-0.109300f,
+		0.718800f,
+		0.965500f,
+		0.020687f,
+		0.497069f,
+		-0.049944f,
+		0.000000f,
+		0.042600f,
+		0.993700f,
+		-0.103000f,
+		0.687500f,
+		0.965500f,
+		0.020969f,
+		0.488310f,
+		-0.105420f,
+		0.000000f,
+		0.042500f,
+		0.975900f,
+		-0.214000f,
+		0.718800f,
+		0.931000f,
+		0.020687f,
+		0.497069f,
+		-0.049944f,
+		0.000000f,
+		0.042600f,
+		0.993700f,
+		-0.103000f,
+		0.687500f,
+		0.965500f,
+		0.041132f,
+		0.488310f,
+		-0.099303f,
+		0.000000f,
+		0.083500f,
+		0.975900f,
+		-0.201600f,
+		0.687500f,
+		0.931000f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.495500f,
+		0.051000f,
+		0.010546f,
+		-0.497069f,
+		-0.053020f,
+		0.000000f,
+		0.021700f,
+		-0.993700f,
+		-0.109300f,
+		0.470600f,
+		0.053800f,
+		0.020687f,
+		-0.497069f,
+		-0.049945f,
+		0.000000f,
+		0.042600f,
+		-0.993700f,
+		-0.103000f,
+		0.468000f,
+		0.053800f,
+		0.096259f,
+		-0.080891f,
+		-0.483932f,
+		0.000000f,
+		0.192500f,
+		-0.161200f,
+		-0.967900f,
+		0.718800f,
+		0.448300f,
+		0.097401f,
+		-0.027069f,
+		-0.489673f,
+		0.000000f,
+		0.194800f,
+		-0.054000f,
+		-0.979300f,
+		0.718800f,
+		0.482800f,
+		0.191060f,
+		-0.027069f,
+		-0.461262f,
+		0.000000f,
+		0.382100f,
+		-0.054000f,
+		-0.922500f,
+		0.687500f,
+		0.482800f,
+		0.096259f,
+		-0.080891f,
+		-0.483932f,
+		0.000000f,
+		0.192500f,
+		-0.161200f,
+		-0.967900f,
+		0.718800f,
+		0.448300f,
+		0.191060f,
+		-0.027069f,
+		-0.461262f,
+		0.000000f,
+		0.382100f,
+		-0.054000f,
+		-0.922500f,
+		0.687500f,
+		0.482800f,
+		0.188820f,
+		-0.080891f,
+		-0.455854f,
+		0.000000f,
+		0.377700f,
+		-0.161200f,
+		-0.911800f,
+		0.687500f,
+		0.448300f,
+		0.031146f,
+		0.473826f,
+		-0.156583f,
+		0.000000f,
+		0.062900f,
+		0.946600f,
+		-0.316100f,
+		0.718800f,
+		0.896600f,
+		0.020969f,
+		0.488310f,
+		-0.105420f,
+		0.000000f,
+		0.042500f,
+		0.975900f,
+		-0.214000f,
+		0.718800f,
+		0.931000f,
+		0.041132f,
+		0.488310f,
+		-0.099303f,
+		0.000000f,
+		0.083500f,
+		0.975900f,
+		-0.201600f,
+		0.687500f,
+		0.931000f,
+		0.031146f,
+		0.473826f,
+		-0.156583f,
+		0.000000f,
+		0.062900f,
+		0.946600f,
+		-0.316100f,
+		0.718800f,
+		0.896600f,
+		0.041132f,
+		0.488310f,
+		-0.099303f,
+		0.000000f,
+		0.083500f,
+		0.975900f,
+		-0.201600f,
+		0.687500f,
+		0.931000f,
+		0.061095f,
+		0.473826f,
+		-0.147498f,
+		0.000000f,
+		0.123300f,
+		0.946600f,
+		-0.297800f,
+		0.687500f,
+		0.896600f,
+		0.093989f,
+		-0.133764f,
+		-0.472517f,
+		0.000000f,
+		0.188000f,
+		-0.266600f,
+		-0.945200f,
+		0.718800f,
+		0.413800f,
+		0.096259f,
+		-0.080891f,
+		-0.483932f,
+		0.000000f,
+		0.192500f,
+		-0.161200f,
+		-0.967900f,
+		0.718800f,
+		0.448300f,
+		0.188820f,
+		-0.080891f,
+		-0.455854f,
+		0.000000f,
+		0.377700f,
+		-0.161200f,
+		-0.911800f,
+		0.687500f,
+		0.448300f,
+		0.093989f,
+		-0.133764f,
+		-0.472517f,
+		0.000000f,
+		0.188000f,
+		-0.266600f,
+		-0.945200f,
+		0.718800f,
+		0.413800f,
+		0.188820f,
+		-0.080891f,
+		-0.455854f,
+		0.000000f,
+		0.377700f,
+		-0.161200f,
+		-0.911800f,
+		0.687500f,
+		0.448300f,
+		0.184366f,
+		-0.133764f,
+		-0.445101f,
+		0.000000f,
+		0.368800f,
+		-0.266600f,
+		-0.890400f,
+		0.687500f,
+		0.413800f,
+		0.040957f,
+		0.453788f,
+		-0.205910f,
+		0.000000f,
+		0.082400f,
+		0.906300f,
+		-0.414500f,
+		0.718800f,
+		0.862100f,
+		0.031146f,
+		0.473826f,
+		-0.156583f,
+		0.000000f,
+		0.062900f,
+		0.946600f,
+		-0.316100f,
+		0.718800f,
+		0.896600f,
+		0.061095f,
+		0.473826f,
+		-0.147498f,
+		0.000000f,
+		0.123300f,
+		0.946600f,
+		-0.297800f,
+		0.687500f,
+		0.896600f,
+		0.040957f,
+		0.453788f,
+		-0.205910f,
+		0.000000f,
+		0.082400f,
+		0.906300f,
+		-0.414500f,
+		0.718800f,
+		0.862100f,
+		0.061095f,
+		0.473826f,
+		-0.147498f,
+		0.000000f,
+		0.123300f,
+		0.946600f,
+		-0.297800f,
+		0.687500f,
+		0.896600f,
+		0.080342f,
+		0.453788f,
+		-0.193963f,
+		0.000000f,
+		0.161700f,
+		0.906300f,
+		-0.390500f,
+		0.687500f,
+		0.862100f,
+		0.090617f,
+		-0.185069f,
+		-0.455563f,
+		0.000000f,
+		0.181300f,
+		-0.369000f,
+		-0.911600f,
+		0.718800f,
+		0.379300f,
+		0.093989f,
+		-0.133764f,
+		-0.472517f,
+		0.000000f,
+		0.188000f,
+		-0.266600f,
+		-0.945200f,
+		0.718800f,
+		0.413800f,
+		0.184366f,
+		-0.133764f,
+		-0.445101f,
+		0.000000f,
+		0.368800f,
+		-0.266600f,
+		-0.890400f,
+		0.687500f,
+		0.413800f,
+		0.090617f,
+		-0.185069f,
+		-0.455563f,
+		0.000000f,
+		0.181300f,
+		-0.369000f,
+		-0.911600f,
+		0.718800f,
+		0.379300f,
+		0.184366f,
+		-0.133764f,
+		-0.445101f,
+		0.000000f,
+		0.368800f,
+		-0.266600f,
+		-0.890400f,
+		0.687500f,
+		0.413800f,
+		0.177751f,
+		-0.185069f,
+		-0.429130f,
+		0.000000f,
+		0.355700f,
+		-0.369000f,
+		-0.858700f,
+		0.687500f,
+		0.379300f,
+		0.050290f,
+		0.428429f,
+		-0.252824f,
+		0.000000f,
+		0.101000f,
+		0.855300f,
+		-0.508100f,
+		0.718800f,
+		0.827600f,
+		0.040957f,
+		0.453788f,
+		-0.205910f,
+		0.000000f,
+		0.082400f,
+		0.906300f,
+		-0.414500f,
+		0.718800f,
+		0.862100f,
+		0.080342f,
+		0.453788f,
+		-0.193963f,
+		0.000000f,
+		0.161700f,
+		0.906300f,
+		-0.390500f,
+		0.687500f,
+		0.862100f,
+		0.050290f,
+		0.428429f,
+		-0.252824f,
+		0.000000f,
+		0.101000f,
+		0.855300f,
+		-0.508100f,
+		0.718800f,
+		0.827600f,
+		0.080342f,
+		0.453788f,
+		-0.193963f,
+		0.000000f,
+		0.161700f,
+		0.906300f,
+		-0.390500f,
+		0.687500f,
+		0.862100f,
+		0.098646f,
+		0.428429f,
+		-0.238155f,
+		0.000000f,
+		0.198200f,
+		0.855300f,
+		-0.478600f,
+		0.687500f,
+		0.827600f,
+		0.086182f,
+		-0.234204f,
+		-0.433268f,
+		0.000000f,
+		0.172500f,
+		-0.467000f,
+		-0.867200f,
+		0.718800f,
+		0.344800f,
+		0.090617f,
+		-0.185069f,
+		-0.455563f,
+		0.000000f,
+		0.181300f,
+		-0.369000f,
+		-0.911600f,
+		0.718800f,
+		0.379300f,
+		0.177751f,
+		-0.185069f,
+		-0.429130f,
+		0.000000f,
+		0.355700f,
+		-0.369000f,
+		-0.858700f,
+		0.687500f,
+		0.379300f,
+		0.086182f,
+		-0.234204f,
+		-0.433268f,
+		0.000000f,
+		0.172500f,
+		-0.467000f,
+		-0.867200f,
+		0.718800f,
+		0.344800f,
+		0.177751f,
+		-0.185069f,
+		-0.429130f,
+		0.000000f,
+		0.355700f,
+		-0.369000f,
+		-0.858700f,
+		0.687500f,
+		0.379300f,
+		0.169052f,
+		-0.234204f,
+		-0.408129f,
+		0.000000f,
+		0.338400f,
+		-0.467000f,
+		-0.816900f,
+		0.687500f,
+		0.344800f,
+		0.059032f,
+		0.398046f,
+		-0.296773f,
+		0.000000f,
+		0.118500f,
+		0.794500f,
+		-0.595600f,
+		0.718800f,
+		0.793100f,
+		0.050290f,
+		0.428429f,
+		-0.252824f,
+		0.000000f,
+		0.101000f,
+		0.855300f,
+		-0.508100f,
+		0.718800f,
+		0.827600f,
+		0.098646f,
+		0.428429f,
+		-0.238155f,
+		0.000000f,
+		0.198200f,
+		0.855300f,
+		-0.478600f,
+		0.687500f,
+		0.827600f,
+		0.059032f,
+		0.398046f,
+		-0.296773f,
+		0.000000f,
+		0.118500f,
+		0.794500f,
+		-0.595600f,
+		0.718800f,
+		0.793100f,
+		0.098646f,
+		0.428429f,
+		-0.238155f,
+		0.000000f,
+		0.198200f,
+		0.855300f,
+		-0.478600f,
+		0.687500f,
+		0.827600f,
+		0.115795f,
+		0.398046f,
+		-0.279554f,
+		0.000000f,
+		0.232400f,
+		0.794500f,
+		-0.561100f,
+		0.687500f,
+		0.793100f,
+		0.080737f,
+		-0.280594f,
+		-0.405892f,
+		0.000000f,
+		0.161700f,
+		-0.559600f,
+		-0.812800f,
+		0.718800f,
+		0.310300f,
+		0.086182f,
+		-0.234204f,
+		-0.433268f,
+		0.000000f,
+		0.172500f,
+		-0.467000f,
+		-0.867200f,
+		0.718800f,
+		0.344800f,
+		0.169052f,
+		-0.234204f,
+		-0.408129f,
+		0.000000f,
+		0.338400f,
+		-0.467000f,
+		-0.816900f,
+		0.687500f,
+		0.344800f,
+		0.080737f,
+		-0.280594f,
+		-0.405892f,
+		0.000000f,
+		0.161700f,
+		-0.559600f,
+		-0.812800f,
+		0.718800f,
+		0.310300f,
+		0.169052f,
+		-0.234204f,
+		-0.408129f,
+		0.000000f,
+		0.338400f,
+		-0.467000f,
+		-0.816900f,
+		0.687500f,
+		0.344800f,
+		0.158371f,
+		-0.280594f,
+		-0.382342f,
+		0.000000f,
+		0.317100f,
+		-0.559600f,
+		-0.765600f,
+		0.687500f,
+		0.310300f,
+		0.067081f,
+		0.362998f,
+		-0.337242f,
+		0.000000f,
+		0.134500f,
+		0.724300f,
+		-0.676200f,
+		0.718800f,
+		0.758600f,
+		0.059032f,
+		0.398046f,
+		-0.296773f,
+		0.000000f,
+		0.118500f,
+		0.794500f,
+		-0.595600f,
+		0.718800f,
+		0.793100f,
+		0.115795f,
+		0.398046f,
+		-0.279554f,
+		0.000000f,
+		0.232400f,
+		0.794500f,
+		-0.561100f,
+		0.687500f,
+		0.793100f,
+		0.067081f,
+		0.362998f,
+		-0.337242f,
+		0.000000f,
+		0.134500f,
+		0.724300f,
+		-0.676200f,
+		0.718800f,
+		0.758600f,
+		0.115795f,
+		0.398046f,
+		-0.279554f,
+		0.000000f,
+		0.232400f,
+		0.794500f,
+		-0.561100f,
+		0.687500f,
+		0.793100f,
+		0.131585f,
+		0.362998f,
+		-0.317675f,
+		0.000000f,
+		0.263800f,
+		0.724300f,
+		-0.637000f,
+		0.687500f,
+		0.758600f,
+		0.074345f,
+		-0.323693f,
+		-0.373758f,
+		0.000000f,
+		0.149000f,
+		-0.645700f,
+		-0.748900f,
+		0.718800f,
+		0.275900f,
+		0.080737f,
+		-0.280594f,
+		-0.405892f,
+		0.000000f,
+		0.161700f,
+		-0.559600f,
+		-0.812800f,
+		0.718800f,
+		0.310300f,
+		0.158371f,
+		-0.280594f,
+		-0.382342f,
+		0.000000f,
+		0.317100f,
+		-0.559600f,
+		-0.765600f,
+		0.687500f,
+		0.310300f,
+		0.074345f,
+		-0.323693f,
+		-0.373758f,
+		0.000000f,
+		0.149000f,
+		-0.645700f,
+		-0.748900f,
+		0.718800f,
+		0.275900f,
+		0.158371f,
+		-0.280594f,
+		-0.382342f,
+		0.000000f,
+		0.317100f,
+		-0.559600f,
+		-0.765600f,
+		0.687500f,
+		0.310300f,
+		0.145833f,
+		-0.323693f,
+		-0.352073f,
+		0.000000f,
+		0.292200f,
+		-0.645700f,
+		-0.705400f,
+		0.687500f,
+		0.275900f,
+		0.074345f,
+		0.323693f,
+		-0.373758f,
+		0.000000f,
+		0.149000f,
+		0.645700f,
+		-0.748900f,
+		0.718800f,
+		0.724100f,
+		0.067081f,
+		0.362998f,
+		-0.337242f,
+		0.000000f,
+		0.134500f,
+		0.724300f,
+		-0.676200f,
+		0.718800f,
+		0.758600f,
+		0.131585f,
+		0.362998f,
+		-0.317675f,
+		0.000000f,
+		0.263800f,
+		0.724300f,
+		-0.637000f,
+		0.687500f,
+		0.758600f,
+		0.074345f,
+		0.323693f,
+		-0.373758f,
+		0.000000f,
+		0.149000f,
+		0.645700f,
+		-0.748900f,
+		0.718800f,
+		0.724100f,
+		0.131585f,
+		0.362998f,
+		-0.317675f,
+		0.000000f,
+		0.263800f,
+		0.724300f,
+		-0.637000f,
+		0.687500f,
+		0.758600f,
+		0.145832f,
+		0.323693f,
+		-0.352073f,
+		0.000000f,
+		0.292200f,
+		0.645700f,
+		-0.705400f,
+		0.687500f,
+		0.724100f,
+		0.067081f,
+		-0.362998f,
+		-0.337243f,
+		0.000000f,
+		0.134500f,
+		-0.724300f,
+		-0.676200f,
+		0.718800f,
+		0.241400f,
+		0.074345f,
+		-0.323693f,
+		-0.373758f,
+		0.000000f,
+		0.149000f,
+		-0.645700f,
+		-0.748900f,
+		0.718800f,
+		0.275900f,
+		0.145833f,
+		-0.323693f,
+		-0.352073f,
+		0.000000f,
+		0.292200f,
+		-0.645700f,
+		-0.705400f,
+		0.687500f,
+		0.275900f,
+		0.067081f,
+		-0.362998f,
+		-0.337243f,
+		0.000000f,
+		0.134500f,
+		-0.724300f,
+		-0.676200f,
+		0.718800f,
+		0.241400f,
+		0.145833f,
+		-0.323693f,
+		-0.352073f,
+		0.000000f,
+		0.292200f,
+		-0.645700f,
+		-0.705400f,
+		0.687500f,
+		0.275900f,
+		0.131585f,
+		-0.362998f,
+		-0.317676f,
+		0.000000f,
+		0.263800f,
+		-0.724300f,
+		-0.637000f,
+		0.687500f,
+		0.241400f,
+		0.080737f,
+		0.280594f,
+		-0.405892f,
+		0.000000f,
+		0.161700f,
+		0.559600f,
+		-0.812800f,
+		0.718800f,
+		0.689700f,
+		0.074345f,
+		0.323693f,
+		-0.373758f,
+		0.000000f,
+		0.149000f,
+		0.645700f,
+		-0.748900f,
+		0.718800f,
+		0.724100f,
+		0.145832f,
+		0.323693f,
+		-0.352073f,
+		0.000000f,
+		0.292200f,
+		0.645700f,
+		-0.705400f,
+		0.687500f,
+		0.724100f,
+		0.080737f,
+		0.280594f,
+		-0.405892f,
+		0.000000f,
+		0.161700f,
+		0.559600f,
+		-0.812800f,
+		0.718800f,
+		0.689700f,
+		0.145832f,
+		0.323693f,
+		-0.352073f,
+		0.000000f,
+		0.292200f,
+		0.645700f,
+		-0.705400f,
+		0.687500f,
+		0.724100f,
+		0.158371f,
+		0.280594f,
+		-0.382342f,
+		0.000000f,
+		0.317100f,
+		0.559600f,
+		-0.765600f,
+		0.687500f,
+		0.689700f,
+		0.059032f,
+		-0.398046f,
+		-0.296773f,
+		0.000000f,
+		0.118500f,
+		-0.794500f,
+		-0.595600f,
+		0.718800f,
+		0.206900f,
+		0.067081f,
+		-0.362998f,
+		-0.337243f,
+		0.000000f,
+		0.134500f,
+		-0.724300f,
+		-0.676200f,
+		0.718800f,
+		0.241400f,
+		0.131585f,
+		-0.362998f,
+		-0.317676f,
+		0.000000f,
+		0.263800f,
+		-0.724300f,
+		-0.637000f,
+		0.687500f,
+		0.241400f,
+		0.059032f,
+		-0.398046f,
+		-0.296773f,
+		0.000000f,
+		0.118500f,
+		-0.794500f,
+		-0.595600f,
+		0.718800f,
+		0.206900f,
+		0.131585f,
+		-0.362998f,
+		-0.317676f,
+		0.000000f,
+		0.263800f,
+		-0.724300f,
+		-0.637000f,
+		0.687500f,
+		0.241400f,
+		0.115795f,
+		-0.398046f,
+		-0.279554f,
+		0.000000f,
+		0.232400f,
+		-0.794500f,
+		-0.561100f,
+		0.687500f,
+		0.206900f,
+		0.086182f,
+		0.234204f,
+		-0.433268f,
+		0.000000f,
+		0.172500f,
+		0.467000f,
+		-0.867200f,
+		0.718800f,
+		0.655200f,
+		0.080737f,
+		0.280594f,
+		-0.405892f,
+		0.000000f,
+		0.161700f,
+		0.559600f,
+		-0.812800f,
+		0.718800f,
+		0.689700f,
+		0.158371f,
+		0.280594f,
+		-0.382342f,
+		0.000000f,
+		0.317100f,
+		0.559600f,
+		-0.765600f,
+		0.687500f,
+		0.689700f,
+		0.086182f,
+		0.234204f,
+		-0.433268f,
+		0.000000f,
+		0.172500f,
+		0.467000f,
+		-0.867200f,
+		0.718800f,
+		0.655200f,
+		0.158371f,
+		0.280594f,
+		-0.382342f,
+		0.000000f,
+		0.317100f,
+		0.559600f,
+		-0.765600f,
+		0.687500f,
+		0.689700f,
+		0.169052f,
+		0.234204f,
+		-0.408129f,
+		0.000000f,
+		0.338400f,
+		0.467000f,
+		-0.816900f,
+		0.687500f,
+		0.655200f,
+		0.050290f,
+		-0.428429f,
+		-0.252824f,
+		0.000000f,
+		0.101000f,
+		-0.855300f,
+		-0.508100f,
+		0.718800f,
+		0.172400f,
+		0.059032f,
+		-0.398046f,
+		-0.296773f,
+		0.000000f,
+		0.118500f,
+		-0.794500f,
+		-0.595600f,
+		0.718800f,
+		0.206900f,
+		0.115795f,
+		-0.398046f,
+		-0.279554f,
+		0.000000f,
+		0.232400f,
+		-0.794500f,
+		-0.561100f,
+		0.687500f,
+		0.206900f,
+		0.050290f,
+		-0.428429f,
+		-0.252824f,
+		0.000000f,
+		0.101000f,
+		-0.855300f,
+		-0.508100f,
+		0.718800f,
+		0.172400f,
+		0.115795f,
+		-0.398046f,
+		-0.279554f,
+		0.000000f,
+		0.232400f,
+		-0.794500f,
+		-0.561100f,
+		0.687500f,
+		0.206900f,
+		0.098646f,
+		-0.428429f,
+		-0.238155f,
+		0.000000f,
+		0.198200f,
+		-0.855300f,
+		-0.478600f,
+		0.687500f,
+		0.172400f,
+		0.169052f,
+		-0.234204f,
+		-0.408129f,
+		0.000000f,
+		0.338400f,
+		-0.467000f,
+		-0.816900f,
+		0.687500f,
+		0.344800f,
+		0.177751f,
+		-0.185069f,
+		-0.429130f,
+		0.000000f,
+		0.355700f,
+		-0.369000f,
+		-0.858700f,
+		0.687500f,
+		0.379300f,
+		0.258055f,
+		-0.185069f,
+		-0.386207f,
+		0.000000f,
+		0.516300f,
+		-0.369000f,
+		-0.772800f,
+		0.656300f,
+		0.379300f,
+		0.169052f,
+		-0.234204f,
+		-0.408129f,
+		0.000000f,
+		0.338400f,
+		-0.467000f,
+		-0.816900f,
+		0.687500f,
+		0.344800f,
+		0.258055f,
+		-0.185069f,
+		-0.386207f,
+		0.000000f,
+		0.516300f,
+		-0.369000f,
+		-0.772800f,
+		0.656300f,
+		0.379300f,
+		0.245426f,
+		-0.234204f,
+		-0.367306f,
+		0.000000f,
+		0.491300f,
+		-0.467000f,
+		-0.735200f,
+		0.656300f,
+		0.344800f,
+		0.115795f,
+		0.398046f,
+		-0.279554f,
+		0.000000f,
+		0.232400f,
+		0.794500f,
+		-0.561100f,
+		0.687500f,
+		0.793100f,
+		0.098646f,
+		0.428429f,
+		-0.238155f,
+		0.000000f,
+		0.198200f,
+		0.855300f,
+		-0.478600f,
+		0.687500f,
+		0.827600f,
+		0.143212f,
+		0.428429f,
+		-0.214334f,
+		0.000000f,
+		0.287800f,
+		0.855300f,
+		-0.430700f,
+		0.656300f,
+		0.827600f,
+		0.115795f,
+		0.398046f,
+		-0.279554f,
+		0.000000f,
+		0.232400f,
+		0.794500f,
+		-0.561100f,
+		0.687500f,
+		0.793100f,
+		0.143212f,
+		0.428429f,
+		-0.214334f,
+		0.000000f,
+		0.287800f,
+		0.855300f,
+		-0.430700f,
+		0.656300f,
+		0.827600f,
+		0.168107f,
+		0.398046f,
+		-0.251592f,
+		0.000000f,
+		0.337400f,
+		0.794500f,
+		-0.504900f,
+		0.656300f,
+		0.793100f,
+		0.158371f,
+		-0.280594f,
+		-0.382342f,
+		0.000000f,
+		0.317100f,
+		-0.559600f,
+		-0.765600f,
+		0.687500f,
+		0.310300f,
+		0.169052f,
+		-0.234204f,
+		-0.408129f,
+		0.000000f,
+		0.338400f,
+		-0.467000f,
+		-0.816900f,
+		0.687500f,
+		0.344800f,
+		0.245426f,
+		-0.234204f,
+		-0.367306f,
+		0.000000f,
+		0.491300f,
+		-0.467000f,
+		-0.735200f,
+		0.656300f,
+		0.344800f,
+		0.158371f,
+		-0.280594f,
+		-0.382342f,
+		0.000000f,
+		0.317100f,
+		-0.559600f,
+		-0.765600f,
+		0.687500f,
+		0.310300f,
+		0.245426f,
+		-0.234204f,
+		-0.367306f,
+		0.000000f,
+		0.491300f,
+		-0.467000f,
+		-0.735200f,
+		0.656300f,
+		0.344800f,
+		0.229919f,
+		-0.280594f,
+		-0.344099f,
+		0.000000f,
+		0.460400f,
+		-0.559600f,
+		-0.689100f,
+		0.656300f,
+		0.310300f,
+		0.131585f,
+		0.362998f,
+		-0.317675f,
+		0.000000f,
+		0.263800f,
+		0.724300f,
+		-0.637000f,
+		0.687500f,
+		0.758600f,
+		0.115795f,
+		0.398046f,
+		-0.279554f,
+		0.000000f,
+		0.232400f,
+		0.794500f,
+		-0.561100f,
+		0.687500f,
+		0.793100f,
+		0.168107f,
+		0.398046f,
+		-0.251592f,
+		0.000000f,
+		0.337400f,
+		0.794500f,
+		-0.504900f,
+		0.656300f,
+		0.793100f,
+		0.131585f,
+		0.362998f,
+		-0.317675f,
+		0.000000f,
+		0.263800f,
+		0.724300f,
+		-0.637000f,
+		0.687500f,
+		0.758600f,
+		0.168107f,
+		0.398046f,
+		-0.251592f,
+		0.000000f,
+		0.337400f,
+		0.794500f,
+		-0.504900f,
+		0.656300f,
+		0.793100f,
+		0.191032f,
+		0.362998f,
+		-0.285900f,
+		0.000000f,
+		0.383000f,
+		0.724300f,
+		-0.573300f,
+		0.656300f,
+		0.758600f,
+		0.145833f,
+		-0.323693f,
+		-0.352073f,
+		0.000000f,
+		0.292200f,
+		-0.645700f,
+		-0.705400f,
+		0.687500f,
+		0.275900f,
+		0.158371f,
+		-0.280594f,
+		-0.382342f,
+		0.000000f,
+		0.317100f,
+		-0.559600f,
+		-0.765600f,
+		0.687500f,
+		0.310300f,
+		0.229919f,
+		-0.280594f,
+		-0.344099f,
+		0.000000f,
+		0.460400f,
+		-0.559600f,
+		-0.689100f,
+		0.656300f,
+		0.310300f,
+		0.145833f,
+		-0.323693f,
+		-0.352073f,
+		0.000000f,
+		0.292200f,
+		-0.645700f,
+		-0.705400f,
+		0.687500f,
+		0.275900f,
+		0.229919f,
+		-0.280594f,
+		-0.344099f,
+		0.000000f,
+		0.460400f,
+		-0.559600f,
+		-0.689100f,
+		0.656300f,
+		0.310300f,
+		0.211717f,
+		-0.323693f,
+		-0.316857f,
+		0.000000f,
+		0.424200f,
+		-0.645700f,
+		-0.634900f,
+		0.656300f,
+		0.275900f,
+		0.145832f,
+		0.323693f,
+		-0.352073f,
+		0.000000f,
+		0.292200f,
+		0.645700f,
+		-0.705400f,
+		0.687500f,
+		0.724100f,
+		0.131585f,
+		0.362998f,
+		-0.317675f,
+		0.000000f,
+		0.263800f,
+		0.724300f,
+		-0.637000f,
+		0.687500f,
+		0.758600f,
+		0.191032f,
+		0.362998f,
+		-0.285900f,
+		0.000000f,
+		0.383000f,
+		0.724300f,
+		-0.573300f,
+		0.656300f,
+		0.758600f,
+		0.145832f,
+		0.323693f,
+		-0.352073f,
+		0.000000f,
+		0.292200f,
+		0.645700f,
+		-0.705400f,
+		0.687500f,
+		0.724100f,
+		0.191032f,
+		0.362998f,
+		-0.285900f,
+		0.000000f,
+		0.383000f,
+		0.724300f,
+		-0.573300f,
+		0.656300f,
+		0.758600f,
+		0.211717f,
+		0.323693f,
+		-0.316857f,
+		0.000000f,
+		0.424200f,
+		0.645700f,
+		-0.634900f,
+		0.656300f,
+		0.724100f,
+		0.131585f,
+		-0.362998f,
+		-0.317676f,
+		0.000000f,
+		0.263800f,
+		-0.724300f,
+		-0.637000f,
+		0.687500f,
+		0.241400f,
+		0.145833f,
+		-0.323693f,
+		-0.352073f,
+		0.000000f,
+		0.292200f,
+		-0.645700f,
+		-0.705400f,
+		0.687500f,
+		0.275900f,
+		0.211717f,
+		-0.323693f,
+		-0.316857f,
+		0.000000f,
+		0.424200f,
+		-0.645700f,
+		-0.634900f,
+		0.656300f,
+		0.275900f,
+		0.131585f,
+		-0.362998f,
+		-0.317676f,
+		0.000000f,
+		0.263800f,
+		-0.724300f,
+		-0.637000f,
+		0.687500f,
+		0.241400f,
+		0.211717f,
+		-0.323693f,
+		-0.316857f,
+		0.000000f,
+		0.424200f,
+		-0.645700f,
+		-0.634900f,
+		0.656300f,
+		0.275900f,
+		0.191032f,
+		-0.362998f,
+		-0.285900f,
+		0.000000f,
+		0.383000f,
+		-0.724300f,
+		-0.573300f,
+		0.656300f,
+		0.241400f,
+		0.158371f,
+		0.280594f,
+		-0.382342f,
+		0.000000f,
+		0.317100f,
+		0.559600f,
+		-0.765600f,
+		0.687500f,
+		0.689700f,
+		0.145832f,
+		0.323693f,
+		-0.352073f,
+		0.000000f,
+		0.292200f,
+		0.645700f,
+		-0.705400f,
+		0.687500f,
+		0.724100f,
+		0.211717f,
+		0.323693f,
+		-0.316857f,
+		0.000000f,
+		0.424200f,
+		0.645700f,
+		-0.634900f,
+		0.656300f,
+		0.724100f,
+		0.158371f,
+		0.280594f,
+		-0.382342f,
+		0.000000f,
+		0.317100f,
+		0.559600f,
+		-0.765600f,
+		0.687500f,
+		0.689700f,
+		0.211717f,
+		0.323693f,
+		-0.316857f,
+		0.000000f,
+		0.424200f,
+		0.645700f,
+		-0.634900f,
+		0.656300f,
+		0.724100f,
+		0.229919f,
+		0.280594f,
+		-0.344099f,
+		0.000000f,
+		0.460400f,
+		0.559600f,
+		-0.689100f,
+		0.656300f,
+		0.689700f,
+		0.115795f,
+		-0.398046f,
+		-0.279554f,
+		0.000000f,
+		0.232400f,
+		-0.794500f,
+		-0.561100f,
+		0.687500f,
+		0.206900f,
+		0.131585f,
+		-0.362998f,
+		-0.317676f,
+		0.000000f,
+		0.263800f,
+		-0.724300f,
+		-0.637000f,
+		0.687500f,
+		0.241400f,
+		0.191032f,
+		-0.362998f,
+		-0.285900f,
+		0.000000f,
+		0.383000f,
+		-0.724300f,
+		-0.573300f,
+		0.656300f,
+		0.241400f,
+		0.115795f,
+		-0.398046f,
+		-0.279554f,
+		0.000000f,
+		0.232400f,
+		-0.794500f,
+		-0.561100f,
+		0.687500f,
+		0.206900f,
+		0.191032f,
+		-0.362998f,
+		-0.285900f,
+		0.000000f,
+		0.383000f,
+		-0.724300f,
+		-0.573300f,
+		0.656300f,
+		0.241400f,
+		0.168108f,
+		-0.398046f,
+		-0.251592f,
+		0.000000f,
+		0.337400f,
+		-0.794500f,
+		-0.505000f,
+		0.656300f,
+		0.206900f,
+		0.169052f,
+		0.234204f,
+		-0.408129f,
+		0.000000f,
+		0.338400f,
+		0.467000f,
+		-0.816900f,
+		0.687500f,
+		0.655200f,
+		0.158371f,
+		0.280594f,
+		-0.382342f,
+		0.000000f,
+		0.317100f,
+		0.559600f,
+		-0.765600f,
+		0.687500f,
+		0.689700f,
+		0.229919f,
+		0.280594f,
+		-0.344099f,
+		0.000000f,
+		0.460400f,
+		0.559600f,
+		-0.689100f,
+		0.656300f,
+		0.689700f,
+		0.169052f,
+		0.234204f,
+		-0.408129f,
+		0.000000f,
+		0.338400f,
+		0.467000f,
+		-0.816900f,
+		0.687500f,
+		0.655200f,
+		0.229919f,
+		0.280594f,
+		-0.344099f,
+		0.000000f,
+		0.460400f,
+		0.559600f,
+		-0.689100f,
+		0.656300f,
+		0.689700f,
+		0.245426f,
+		0.234204f,
+		-0.367306f,
+		0.000000f,
+		0.491300f,
+		0.467000f,
+		-0.735200f,
+		0.656300f,
+		0.655200f,
+		0.098646f,
+		-0.428429f,
+		-0.238155f,
+		0.000000f,
+		0.198200f,
+		-0.855300f,
+		-0.478600f,
+		0.687500f,
+		0.172400f,
+		0.115795f,
+		-0.398046f,
+		-0.279554f,
+		0.000000f,
+		0.232400f,
+		-0.794500f,
+		-0.561100f,
+		0.687500f,
+		0.206900f,
+		0.168108f,
+		-0.398046f,
+		-0.251592f,
+		0.000000f,
+		0.337400f,
+		-0.794500f,
+		-0.505000f,
+		0.656300f,
+		0.206900f,
+		0.098646f,
+		-0.428429f,
+		-0.238155f,
+		0.000000f,
+		0.198200f,
+		-0.855300f,
+		-0.478600f,
+		0.687500f,
+		0.172400f,
+		0.168108f,
+		-0.398046f,
+		-0.251592f,
+		0.000000f,
+		0.337400f,
+		-0.794500f,
+		-0.505000f,
+		0.656300f,
+		0.206900f,
+		0.143212f,
+		-0.428429f,
+		-0.214334f,
+		0.000000f,
+		0.287800f,
+		-0.855300f,
+		-0.430700f,
+		0.656300f,
+		0.172400f,
+		0.177751f,
+		0.185069f,
+		-0.429130f,
+		0.000000f,
+		0.355700f,
+		0.369000f,
+		-0.858700f,
+		0.687500f,
+		0.620700f,
+		0.169052f,
+		0.234204f,
+		-0.408129f,
+		0.000000f,
+		0.338400f,
+		0.467000f,
+		-0.816900f,
+		0.687500f,
+		0.655200f,
+		0.245426f,
+		0.234204f,
+		-0.367306f,
+		0.000000f,
+		0.491300f,
+		0.467000f,
+		-0.735200f,
+		0.656300f,
+		0.655200f,
+		0.177751f,
+		0.185069f,
+		-0.429130f,
+		0.000000f,
+		0.355700f,
+		0.369000f,
+		-0.858700f,
+		0.687500f,
+		0.620700f,
+		0.245426f,
+		0.234204f,
+		-0.367306f,
+		0.000000f,
+		0.491300f,
+		0.467000f,
+		-0.735200f,
+		0.656300f,
+		0.655200f,
+		0.258055f,
+		0.185069f,
+		-0.386207f,
+		0.000000f,
+		0.516300f,
+		0.369000f,
+		-0.772800f,
+		0.656300f,
+		0.620700f,
+		0.080342f,
+		-0.453788f,
+		-0.193963f,
+		0.000000f,
+		0.161700f,
+		-0.906300f,
+		-0.390500f,
+		0.687500f,
+		0.137900f,
+		0.098646f,
+		-0.428429f,
+		-0.238155f,
+		0.000000f,
+		0.198200f,
+		-0.855300f,
+		-0.478600f,
+		0.687500f,
+		0.172400f,
+		0.143212f,
+		-0.428429f,
+		-0.214334f,
+		0.000000f,
+		0.287800f,
+		-0.855300f,
+		-0.430700f,
+		0.656300f,
+		0.172400f,
+		0.080342f,
+		-0.453788f,
+		-0.193963f,
+		0.000000f,
+		0.161700f,
+		-0.906300f,
+		-0.390500f,
+		0.687500f,
+		0.137900f,
+		0.143212f,
+		-0.428429f,
+		-0.214334f,
+		0.000000f,
+		0.287800f,
+		-0.855300f,
+		-0.430700f,
+		0.656300f,
+		0.172400f,
+		0.116638f,
+		-0.453788f,
+		-0.174562f,
+		0.000000f,
+		0.234800f,
+		-0.906300f,
+		-0.351400f,
+		0.656300f,
+		0.137900f,
+		0.184366f,
+		0.133764f,
+		-0.445101f,
+		0.000000f,
+		0.368800f,
+		0.266600f,
+		-0.890400f,
+		0.687500f,
+		0.586200f,
+		0.177751f,
+		0.185069f,
+		-0.429130f,
+		0.000000f,
+		0.355700f,
+		0.369000f,
+		-0.858700f,
+		0.687500f,
+		0.620700f,
+		0.258055f,
+		0.185069f,
+		-0.386207f,
+		0.000000f,
+		0.516300f,
+		0.369000f,
+		-0.772800f,
+		0.656300f,
+		0.620700f,
+		0.184366f,
+		0.133764f,
+		-0.445101f,
+		0.000000f,
+		0.368800f,
+		0.266600f,
+		-0.890400f,
+		0.687500f,
+		0.586200f,
+		0.258055f,
+		0.185069f,
+		-0.386207f,
+		0.000000f,
+		0.516300f,
+		0.369000f,
+		-0.772800f,
+		0.656300f,
+		0.620700f,
+		0.267659f,
+		0.133764f,
+		-0.400580f,
+		0.000000f,
+		0.535400f,
+		0.266600f,
+		-0.801400f,
+		0.656300f,
+		0.586200f,
+		0.061095f,
+		-0.473826f,
+		-0.147498f,
+		0.000000f,
+		0.123300f,
+		-0.946600f,
+		-0.297800f,
+		0.687500f,
+		0.103400f,
+		0.080342f,
+		-0.453788f,
+		-0.193963f,
+		0.000000f,
+		0.161700f,
+		-0.906300f,
+		-0.390500f,
+		0.687500f,
+		0.137900f,
+		0.116638f,
+		-0.453788f,
+		-0.174562f,
+		0.000000f,
+		0.234800f,
+		-0.906300f,
+		-0.351400f,
+		0.656300f,
+		0.137900f,
+		0.061095f,
+		-0.473826f,
+		-0.147498f,
+		0.000000f,
+		0.123300f,
+		-0.946600f,
+		-0.297800f,
+		0.687500f,
+		0.103400f,
+		0.116638f,
+		-0.453788f,
+		-0.174562f,
+		0.000000f,
+		0.234800f,
+		-0.906300f,
+		-0.351400f,
+		0.656300f,
+		0.137900f,
+		0.088697f,
+		-0.473826f,
+		-0.132745f,
+		0.000000f,
+		0.179100f,
+		-0.946600f,
+		-0.268000f,
+		0.656300f,
+		0.103400f,
+		0.188820f,
+		0.080891f,
+		-0.455854f,
+		0.000000f,
+		0.377700f,
+		0.161200f,
+		-0.911800f,
+		0.687500f,
+		0.551700f,
+		0.184366f,
+		0.133764f,
+		-0.445101f,
+		0.000000f,
+		0.368800f,
+		0.266600f,
+		-0.890400f,
+		0.687500f,
+		0.586200f,
+		0.267659f,
+		0.133764f,
+		-0.400580f,
+		0.000000f,
+		0.535400f,
+		0.266600f,
+		-0.801400f,
+		0.656300f,
+		0.586200f,
+		0.188820f,
+		0.080891f,
+		-0.455854f,
+		0.000000f,
+		0.377700f,
+		0.161200f,
+		-0.911800f,
+		0.687500f,
+		0.551700f,
+		0.267659f,
+		0.133764f,
+		-0.400580f,
+		0.000000f,
+		0.535400f,
+		0.266600f,
+		-0.801400f,
+		0.656300f,
+		0.586200f,
+		0.274125f,
+		0.080891f,
+		-0.410257f,
+		0.000000f,
+		0.548300f,
+		0.161200f,
+		-0.820600f,
+		0.656300f,
+		0.551700f,
+		0.041132f,
+		-0.488310f,
+		-0.099303f,
+		0.000000f,
+		0.083500f,
+		-0.975900f,
+		-0.201600f,
+		0.687500f,
+		0.069000f,
+		0.061095f,
+		-0.473826f,
+		-0.147498f,
+		0.000000f,
+		0.123300f,
+		-0.946600f,
+		-0.297800f,
+		0.687500f,
+		0.103400f,
+		0.088697f,
+		-0.473826f,
+		-0.132745f,
+		0.000000f,
+		0.179100f,
+		-0.946600f,
+		-0.268000f,
+		0.656300f,
+		0.103400f,
+		0.041132f,
+		-0.488310f,
+		-0.099303f,
+		0.000000f,
+		0.083500f,
+		-0.975900f,
+		-0.201600f,
+		0.687500f,
+		0.069000f,
+		0.088697f,
+		-0.473826f,
+		-0.132745f,
+		0.000000f,
+		0.179100f,
+		-0.946600f,
+		-0.268000f,
+		0.656300f,
+		0.103400f,
+		0.059715f,
+		-0.488310f,
+		-0.089370f,
+		0.000000f,
+		0.121200f,
+		-0.975900f,
+		-0.181400f,
+		0.656300f,
+		0.069000f,
+		0.191060f,
+		0.027069f,
+		-0.461262f,
+		0.000000f,
+		0.382100f,
+		0.054000f,
+		-0.922500f,
+		0.687500f,
+		0.517200f,
+		0.188820f,
+		0.080891f,
+		-0.455854f,
+		0.000000f,
+		0.377700f,
+		0.161200f,
+		-0.911800f,
+		0.687500f,
+		0.551700f,
+		0.274125f,
+		0.080891f,
+		-0.410257f,
+		0.000000f,
+		0.548300f,
+		0.161200f,
+		-0.820600f,
+		0.656300f,
+		0.551700f,
+		0.191060f,
+		0.027069f,
+		-0.461262f,
+		0.000000f,
+		0.382100f,
+		0.054000f,
+		-0.922500f,
+		0.687500f,
+		0.517200f,
+		0.274125f,
+		0.080891f,
+		-0.410257f,
+		0.000000f,
+		0.548300f,
+		0.161200f,
+		-0.820600f,
+		0.656300f,
+		0.551700f,
+		0.277377f,
+		0.027069f,
+		-0.415125f,
+		0.000000f,
+		0.554700f,
+		0.054000f,
+		-0.830300f,
+		0.656300f,
+		0.517200f,
+		0.020687f,
+		0.497069f,
+		-0.049944f,
+		0.000000f,
+		0.042600f,
+		0.993700f,
+		-0.103000f,
+		0.445300f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.423900f,
+		0.960300f,
+		0.030033f,
+		0.497069f,
+		-0.044948f,
+		0.000000f,
+		0.061900f,
+		0.993700f,
+		-0.092700f,
+		0.447100f,
+		0.962300f,
+		0.020687f,
+		-0.497069f,
+		-0.049945f,
+		0.000000f,
+		0.042600f,
+		-0.993700f,
+		-0.103000f,
+		0.687500f,
+		0.034500f,
+		0.041132f,
+		-0.488310f,
+		-0.099303f,
+		0.000000f,
+		0.083500f,
+		-0.975900f,
+		-0.201600f,
+		0.687500f,
+		0.069000f,
+		0.059715f,
+		-0.488310f,
+		-0.089370f,
+		0.000000f,
+		0.121200f,
+		-0.975900f,
+		-0.181400f,
+		0.656300f,
+		0.069000f,
+		0.020687f,
+		-0.497069f,
+		-0.049945f,
+		0.000000f,
+		0.042600f,
+		-0.993700f,
+		-0.103000f,
+		0.687500f,
+		0.034500f,
+		0.059715f,
+		-0.488310f,
+		-0.089370f,
+		0.000000f,
+		0.121200f,
+		-0.975900f,
+		-0.181400f,
+		0.656300f,
+		0.069000f,
+		0.030034f,
+		-0.497069f,
+		-0.044949f,
+		0.000000f,
+		0.061900f,
+		-0.993700f,
+		-0.092700f,
+		0.656300f,
+		0.034500f,
+		0.191060f,
+		-0.027069f,
+		-0.461262f,
+		0.000000f,
+		0.382100f,
+		-0.054000f,
+		-0.922500f,
+		0.687500f,
+		0.482800f,
+		0.191060f,
+		0.027069f,
+		-0.461262f,
+		0.000000f,
+		0.382100f,
+		0.054000f,
+		-0.922500f,
+		0.687500f,
+		0.517200f,
+		0.277377f,
+		0.027069f,
+		-0.415125f,
+		0.000000f,
+		0.554700f,
+		0.054000f,
+		-0.830300f,
+		0.656300f,
+		0.517200f,
+		0.191060f,
+		-0.027069f,
+		-0.461262f,
+		0.000000f,
+		0.382100f,
+		-0.054000f,
+		-0.922500f,
+		0.687500f,
+		0.482800f,
+		0.277377f,
+		0.027069f,
+		-0.415125f,
+		0.000000f,
+		0.554700f,
+		0.054000f,
+		-0.830300f,
+		0.656300f,
+		0.517200f,
+		0.277377f,
+		-0.027069f,
+		-0.415125f,
+		0.000000f,
+		0.554700f,
+		-0.054000f,
+		-0.830300f,
+		0.656300f,
+		0.482800f,
+		0.041132f,
+		0.488310f,
+		-0.099303f,
+		0.000000f,
+		0.083500f,
+		0.975900f,
+		-0.201600f,
+		0.687500f,
+		0.931000f,
+		0.020687f,
+		0.497069f,
+		-0.049944f,
+		0.000000f,
+		0.042600f,
+		0.993700f,
+		-0.103000f,
+		0.687500f,
+		0.965500f,
+		0.030033f,
+		0.497069f,
+		-0.044948f,
+		0.000000f,
+		0.061900f,
+		0.993700f,
+		-0.092700f,
+		0.656300f,
+		0.965500f,
+		0.041132f,
+		0.488310f,
+		-0.099303f,
+		0.000000f,
+		0.083500f,
+		0.975900f,
+		-0.201600f,
+		0.687500f,
+		0.931000f,
+		0.030033f,
+		0.497069f,
+		-0.044948f,
+		0.000000f,
+		0.061900f,
+		0.993700f,
+		-0.092700f,
+		0.656300f,
+		0.965500f,
+		0.059715f,
+		0.488310f,
+		-0.089370f,
+		0.000000f,
+		0.121200f,
+		0.975900f,
+		-0.181400f,
+		0.656300f,
+		0.931000f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.495500f,
+		0.051000f,
+		0.020687f,
+		-0.497069f,
+		-0.049945f,
+		0.000000f,
+		0.042600f,
+		-0.993700f,
+		-0.103000f,
+		0.468000f,
+		0.053800f,
+		0.030034f,
+		-0.497069f,
+		-0.044949f,
+		0.000000f,
+		0.061900f,
+		-0.993700f,
+		-0.092700f,
+		0.465400f,
+		0.053800f,
+		0.188820f,
+		-0.080891f,
+		-0.455854f,
+		0.000000f,
+		0.377700f,
+		-0.161200f,
+		-0.911800f,
+		0.687500f,
+		0.448300f,
+		0.191060f,
+		-0.027069f,
+		-0.461262f,
+		0.000000f,
+		0.382100f,
+		-0.054000f,
+		-0.922500f,
+		0.687500f,
+		0.482800f,
+		0.277377f,
+		-0.027069f,
+		-0.415125f,
+		0.000000f,
+		0.554700f,
+		-0.054000f,
+		-0.830300f,
+		0.656300f,
+		0.482800f,
+		0.188820f,
+		-0.080891f,
+		-0.455854f,
+		0.000000f,
+		0.377700f,
+		-0.161200f,
+		-0.911800f,
+		0.687500f,
+		0.448300f,
+		0.277377f,
+		-0.027069f,
+		-0.415125f,
+		0.000000f,
+		0.554700f,
+		-0.054000f,
+		-0.830300f,
+		0.656300f,
+		0.482800f,
+		0.274125f,
+		-0.080891f,
+		-0.410257f,
+		0.000000f,
+		0.548300f,
+		-0.161200f,
+		-0.820600f,
+		0.656300f,
+		0.448300f,
+		0.061095f,
+		0.473826f,
+		-0.147498f,
+		0.000000f,
+		0.123300f,
+		0.946600f,
+		-0.297800f,
+		0.687500f,
+		0.896600f,
+		0.041132f,
+		0.488310f,
+		-0.099303f,
+		0.000000f,
+		0.083500f,
+		0.975900f,
+		-0.201600f,
+		0.687500f,
+		0.931000f,
+		0.059715f,
+		0.488310f,
+		-0.089370f,
+		0.000000f,
+		0.121200f,
+		0.975900f,
+		-0.181400f,
+		0.656300f,
+		0.931000f,
+		0.061095f,
+		0.473826f,
+		-0.147498f,
+		0.000000f,
+		0.123300f,
+		0.946600f,
+		-0.297800f,
+		0.687500f,
+		0.896600f,
+		0.059715f,
+		0.488310f,
+		-0.089370f,
+		0.000000f,
+		0.121200f,
+		0.975900f,
+		-0.181400f,
+		0.656300f,
+		0.931000f,
+		0.088697f,
+		0.473826f,
+		-0.132745f,
+		0.000000f,
+		0.179100f,
+		0.946600f,
+		-0.268000f,
+		0.656300f,
+		0.896600f,
+		0.184366f,
+		-0.133764f,
+		-0.445101f,
+		0.000000f,
+		0.368800f,
+		-0.266600f,
+		-0.890400f,
+		0.687500f,
+		0.413800f,
+		0.188820f,
+		-0.080891f,
+		-0.455854f,
+		0.000000f,
+		0.377700f,
+		-0.161200f,
+		-0.911800f,
+		0.687500f,
+		0.448300f,
+		0.274125f,
+		-0.080891f,
+		-0.410257f,
+		0.000000f,
+		0.548300f,
+		-0.161200f,
+		-0.820600f,
+		0.656300f,
+		0.448300f,
+		0.184366f,
+		-0.133764f,
+		-0.445101f,
+		0.000000f,
+		0.368800f,
+		-0.266600f,
+		-0.890400f,
+		0.687500f,
+		0.413800f,
+		0.274125f,
+		-0.080891f,
+		-0.410257f,
+		0.000000f,
+		0.548300f,
+		-0.161200f,
+		-0.820600f,
+		0.656300f,
+		0.448300f,
+		0.267659f,
+		-0.133764f,
+		-0.400580f,
+		0.000000f,
+		0.535400f,
+		-0.266600f,
+		-0.801400f,
+		0.656300f,
+		0.413800f,
+		0.080342f,
+		0.453788f,
+		-0.193963f,
+		0.000000f,
+		0.161700f,
+		0.906300f,
+		-0.390500f,
+		0.687500f,
+		0.862100f,
+		0.061095f,
+		0.473826f,
+		-0.147498f,
+		0.000000f,
+		0.123300f,
+		0.946600f,
+		-0.297800f,
+		0.687500f,
+		0.896600f,
+		0.088697f,
+		0.473826f,
+		-0.132745f,
+		0.000000f,
+		0.179100f,
+		0.946600f,
+		-0.268000f,
+		0.656300f,
+		0.896600f,
+		0.080342f,
+		0.453788f,
+		-0.193963f,
+		0.000000f,
+		0.161700f,
+		0.906300f,
+		-0.390500f,
+		0.687500f,
+		0.862100f,
+		0.088697f,
+		0.473826f,
+		-0.132745f,
+		0.000000f,
+		0.179100f,
+		0.946600f,
+		-0.268000f,
+		0.656300f,
+		0.896600f,
+		0.116638f,
+		0.453788f,
+		-0.174562f,
+		0.000000f,
+		0.234800f,
+		0.906300f,
+		-0.351400f,
+		0.656300f,
+		0.862100f,
+		0.177751f,
+		-0.185069f,
+		-0.429130f,
+		0.000000f,
+		0.355700f,
+		-0.369000f,
+		-0.858700f,
+		0.687500f,
+		0.379300f,
+		0.184366f,
+		-0.133764f,
+		-0.445101f,
+		0.000000f,
+		0.368800f,
+		-0.266600f,
+		-0.890400f,
+		0.687500f,
+		0.413800f,
+		0.267659f,
+		-0.133764f,
+		-0.400580f,
+		0.000000f,
+		0.535400f,
+		-0.266600f,
+		-0.801400f,
+		0.656300f,
+		0.413800f,
+		0.177751f,
+		-0.185069f,
+		-0.429130f,
+		0.000000f,
+		0.355700f,
+		-0.369000f,
+		-0.858700f,
+		0.687500f,
+		0.379300f,
+		0.267659f,
+		-0.133764f,
+		-0.400580f,
+		0.000000f,
+		0.535400f,
+		-0.266600f,
+		-0.801400f,
+		0.656300f,
+		0.413800f,
+		0.258055f,
+		-0.185069f,
+		-0.386207f,
+		0.000000f,
+		0.516300f,
+		-0.369000f,
+		-0.772800f,
+		0.656300f,
+		0.379300f,
+		0.098646f,
+		0.428429f,
+		-0.238155f,
+		0.000000f,
+		0.198200f,
+		0.855300f,
+		-0.478600f,
+		0.687500f,
+		0.827600f,
+		0.080342f,
+		0.453788f,
+		-0.193963f,
+		0.000000f,
+		0.161700f,
+		0.906300f,
+		-0.390500f,
+		0.687500f,
+		0.862100f,
+		0.116638f,
+		0.453788f,
+		-0.174562f,
+		0.000000f,
+		0.234800f,
+		0.906300f,
+		-0.351400f,
+		0.656300f,
+		0.862100f,
+		0.098646f,
+		0.428429f,
+		-0.238155f,
+		0.000000f,
+		0.198200f,
+		0.855300f,
+		-0.478600f,
+		0.687500f,
+		0.827600f,
+		0.116638f,
+		0.453788f,
+		-0.174562f,
+		0.000000f,
+		0.234800f,
+		0.906300f,
+		-0.351400f,
+		0.656300f,
+		0.862100f,
+		0.143212f,
+		0.428429f,
+		-0.214334f,
+		0.000000f,
+		0.287800f,
+		0.855300f,
+		-0.430700f,
+		0.656300f,
+		0.827600f,
+		0.059715f,
+		-0.488310f,
+		-0.089370f,
+		0.000000f,
+		0.121200f,
+		-0.975900f,
+		-0.181400f,
+		0.656300f,
+		0.069000f,
+		0.088697f,
+		-0.473826f,
+		-0.132745f,
+		0.000000f,
+		0.179100f,
+		-0.946600f,
+		-0.268000f,
+		0.656300f,
+		0.103400f,
+		0.112889f,
+		-0.473826f,
+		-0.112890f,
+		0.000000f,
+		0.227900f,
+		-0.946600f,
+		-0.227900f,
+		0.625000f,
+		0.103400f,
+		0.059715f,
+		-0.488310f,
+		-0.089370f,
+		0.000000f,
+		0.121200f,
+		-0.975900f,
+		-0.181400f,
+		0.656300f,
+		0.069000f,
+		0.112889f,
+		-0.473826f,
+		-0.112890f,
+		0.000000f,
+		0.227900f,
+		-0.946600f,
+		-0.227900f,
+		0.625000f,
+		0.103400f,
+		0.076003f,
+		-0.488310f,
+		-0.076003f,
+		0.000000f,
+		0.154300f,
+		-0.975900f,
+		-0.154300f,
+		0.625000f,
+		0.069000f,
+		0.277377f,
+		0.027069f,
+		-0.415125f,
+		0.000000f,
+		0.554700f,
+		0.054000f,
+		-0.830300f,
+		0.656300f,
+		0.517200f,
+		0.274125f,
+		0.080891f,
+		-0.410257f,
+		0.000000f,
+		0.548300f,
+		0.161200f,
+		-0.820600f,
+		0.656300f,
+		0.551700f,
+		0.348895f,
+		0.080891f,
+		-0.348895f,
+		0.000000f,
+		0.697800f,
+		0.161200f,
+		-0.697800f,
+		0.625000f,
+		0.551700f,
+		0.277377f,
+		0.027069f,
+		-0.415125f,
+		0.000000f,
+		0.554700f,
+		0.054000f,
+		-0.830300f,
+		0.656300f,
+		0.517200f,
+		0.348895f,
+		0.080891f,
+		-0.348895f,
+		0.000000f,
+		0.697800f,
+		0.161200f,
+		-0.697800f,
+		0.625000f,
+		0.551700f,
+		0.353034f,
+		0.027069f,
+		-0.353034f,
+		0.000000f,
+		0.706100f,
+		0.054000f,
+		-0.706100f,
+		0.625000f,
+		0.517200f,
+		0.030033f,
+		0.497069f,
+		-0.044948f,
+		0.000000f,
+		0.061900f,
+		0.993700f,
+		-0.092700f,
+		0.447100f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.423900f,
+		0.960300f,
+		0.038225f,
+		0.497069f,
+		-0.038226f,
+		0.000000f,
+		0.078800f,
+		0.993700f,
+		-0.078800f,
+		0.449000f,
+		0.962300f,
+		0.030034f,
+		-0.497069f,
+		-0.044949f,
+		0.000000f,
+		0.061900f,
+		-0.993700f,
+		-0.092700f,
+		0.656300f,
+		0.034500f,
+		0.059715f,
+		-0.488310f,
+		-0.089370f,
+		0.000000f,
+		0.121200f,
+		-0.975900f,
+		-0.181400f,
+		0.656300f,
+		0.069000f,
+		0.076003f,
+		-0.488310f,
+		-0.076003f,
+		0.000000f,
+		0.154300f,
+		-0.975900f,
+		-0.154300f,
+		0.625000f,
+		0.069000f,
+		0.030034f,
+		-0.497069f,
+		-0.044949f,
+		0.000000f,
+		0.061900f,
+		-0.993700f,
+		-0.092700f,
+		0.656300f,
+		0.034500f,
+		0.076003f,
+		-0.488310f,
+		-0.076003f,
+		0.000000f,
+		0.154300f,
+		-0.975900f,
+		-0.154300f,
+		0.625000f,
+		0.069000f,
+		0.038226f,
+		-0.497069f,
+		-0.038226f,
+		0.000000f,
+		0.078800f,
+		-0.993700f,
+		-0.078800f,
+		0.625000f,
+		0.034500f,
+		0.277377f,
+		-0.027069f,
+		-0.415125f,
+		0.000000f,
+		0.554700f,
+		-0.054000f,
+		-0.830300f,
+		0.656300f,
+		0.482800f,
+		0.277377f,
+		0.027069f,
+		-0.415125f,
+		0.000000f,
+		0.554700f,
+		0.054000f,
+		-0.830300f,
+		0.656300f,
+		0.517200f,
+		0.353034f,
+		0.027069f,
+		-0.353034f,
+		0.000000f,
+		0.706100f,
+		0.054000f,
+		-0.706100f,
+		0.625000f,
+		0.517200f,
+		0.277377f,
+		-0.027069f,
+		-0.415125f,
+		0.000000f,
+		0.554700f,
+		-0.054000f,
+		-0.830300f,
+		0.656300f,
+		0.482800f,
+		0.353034f,
+		0.027069f,
+		-0.353034f,
+		0.000000f,
+		0.706100f,
+		0.054000f,
+		-0.706100f,
+		0.625000f,
+		0.517200f,
+		0.353034f,
+		-0.027069f,
+		-0.353034f,
+		0.000000f,
+		0.706100f,
+		-0.054000f,
+		-0.706100f,
+		0.625000f,
+		0.482800f,
+		0.059715f,
+		0.488310f,
+		-0.089370f,
+		0.000000f,
+		0.121200f,
+		0.975900f,
+		-0.181400f,
+		0.656300f,
+		0.931000f,
+		0.030033f,
+		0.497069f,
+		-0.044948f,
+		0.000000f,
+		0.061900f,
+		0.993700f,
+		-0.092700f,
+		0.656300f,
+		0.965500f,
+		0.038225f,
+		0.497069f,
+		-0.038226f,
+		0.000000f,
+		0.078800f,
+		0.993700f,
+		-0.078800f,
+		0.625000f,
+		0.965500f,
+		0.059715f,
+		0.488310f,
+		-0.089370f,
+		0.000000f,
+		0.121200f,
+		0.975900f,
+		-0.181400f,
+		0.656300f,
+		0.931000f,
+		0.038225f,
+		0.497069f,
+		-0.038226f,
+		0.000000f,
+		0.078800f,
+		0.993700f,
+		-0.078800f,
+		0.625000f,
+		0.965500f,
+		0.076003f,
+		0.488310f,
+		-0.076003f,
+		0.000000f,
+		0.154300f,
+		0.975900f,
+		-0.154300f,
+		0.625000f,
+		0.931000f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.495500f,
+		0.051000f,
+		0.030034f,
+		-0.497069f,
+		-0.044949f,
+		0.000000f,
+		0.061900f,
+		-0.993700f,
+		-0.092700f,
+		0.465400f,
+		0.053800f,
+		0.038226f,
+		-0.497069f,
+		-0.038226f,
+		0.000000f,
+		0.078800f,
+		-0.993700f,
+		-0.078800f,
+		0.462800f,
+		0.053800f,
+		0.274125f,
+		-0.080891f,
+		-0.410257f,
+		0.000000f,
+		0.548300f,
+		-0.161200f,
+		-0.820600f,
+		0.656300f,
+		0.448300f,
+		0.277377f,
+		-0.027069f,
+		-0.415125f,
+		0.000000f,
+		0.554700f,
+		-0.054000f,
+		-0.830300f,
+		0.656300f,
+		0.482800f,
+		0.353034f,
+		-0.027069f,
+		-0.353034f,
+		0.000000f,
+		0.706100f,
+		-0.054000f,
+		-0.706100f,
+		0.625000f,
+		0.482800f,
+		0.274125f,
+		-0.080891f,
+		-0.410257f,
+		0.000000f,
+		0.548300f,
+		-0.161200f,
+		-0.820600f,
+		0.656300f,
+		0.448300f,
+		0.353034f,
+		-0.027069f,
+		-0.353034f,
+		0.000000f,
+		0.706100f,
+		-0.054000f,
+		-0.706100f,
+		0.625000f,
+		0.482800f,
+		0.348895f,
+		-0.080891f,
+		-0.348895f,
+		0.000000f,
+		0.697800f,
+		-0.161200f,
+		-0.697800f,
+		0.625000f,
+		0.448300f,
+		0.088697f,
+		0.473826f,
+		-0.132745f,
+		0.000000f,
+		0.179100f,
+		0.946600f,
+		-0.268000f,
+		0.656300f,
+		0.896600f,
+		0.059715f,
+		0.488310f,
+		-0.089370f,
+		0.000000f,
+		0.121200f,
+		0.975900f,
+		-0.181400f,
+		0.656300f,
+		0.931000f,
+		0.076003f,
+		0.488310f,
+		-0.076003f,
+		0.000000f,
+		0.154300f,
+		0.975900f,
+		-0.154300f,
+		0.625000f,
+		0.931000f,
+		0.088697f,
+		0.473826f,
+		-0.132745f,
+		0.000000f,
+		0.179100f,
+		0.946600f,
+		-0.268000f,
+		0.656300f,
+		0.896600f,
+		0.076003f,
+		0.488310f,
+		-0.076003f,
+		0.000000f,
+		0.154300f,
+		0.975900f,
+		-0.154300f,
+		0.625000f,
+		0.931000f,
+		0.112889f,
+		0.473826f,
+		-0.112890f,
+		0.000000f,
+		0.227900f,
+		0.946600f,
+		-0.227900f,
+		0.625000f,
+		0.896600f,
+		0.267659f,
+		-0.133764f,
+		-0.400580f,
+		0.000000f,
+		0.535400f,
+		-0.266600f,
+		-0.801400f,
+		0.656300f,
+		0.413800f,
+		0.274125f,
+		-0.080891f,
+		-0.410257f,
+		0.000000f,
+		0.548300f,
+		-0.161200f,
+		-0.820600f,
+		0.656300f,
+		0.448300f,
+		0.348895f,
+		-0.080891f,
+		-0.348895f,
+		0.000000f,
+		0.697800f,
+		-0.161200f,
+		-0.697800f,
+		0.625000f,
+		0.448300f,
+		0.267659f,
+		-0.133764f,
+		-0.400580f,
+		0.000000f,
+		0.535400f,
+		-0.266600f,
+		-0.801400f,
+		0.656300f,
+		0.413800f,
+		0.348895f,
+		-0.080891f,
+		-0.348895f,
+		0.000000f,
+		0.697800f,
+		-0.161200f,
+		-0.697800f,
+		0.625000f,
+		0.448300f,
+		0.340665f,
+		-0.133764f,
+		-0.340666f,
+		0.000000f,
+		0.681500f,
+		-0.266600f,
+		-0.681500f,
+		0.625000f,
+		0.413800f,
+		0.116638f,
+		0.453788f,
+		-0.174562f,
+		0.000000f,
+		0.234800f,
+		0.906300f,
+		-0.351400f,
+		0.656300f,
+		0.862100f,
+		0.088697f,
+		0.473826f,
+		-0.132745f,
+		0.000000f,
+		0.179100f,
+		0.946600f,
+		-0.268000f,
+		0.656300f,
+		0.896600f,
+		0.112889f,
+		0.473826f,
+		-0.112890f,
+		0.000000f,
+		0.227900f,
+		0.946600f,
+		-0.227900f,
+		0.625000f,
+		0.896600f,
+		0.116638f,
+		0.453788f,
+		-0.174562f,
+		0.000000f,
+		0.234800f,
+		0.906300f,
+		-0.351400f,
+		0.656300f,
+		0.862100f,
+		0.112889f,
+		0.473826f,
+		-0.112890f,
+		0.000000f,
+		0.227900f,
+		0.946600f,
+		-0.227900f,
+		0.625000f,
+		0.896600f,
+		0.148453f,
+		0.453788f,
+		-0.148453f,
+		0.000000f,
+		0.298900f,
+		0.906300f,
+		-0.298900f,
+		0.625000f,
+		0.862100f,
+		0.258055f,
+		-0.185069f,
+		-0.386207f,
+		0.000000f,
+		0.516300f,
+		-0.369000f,
+		-0.772800f,
+		0.656300f,
+		0.379300f,
+		0.267659f,
+		-0.133764f,
+		-0.400580f,
+		0.000000f,
+		0.535400f,
+		-0.266600f,
+		-0.801400f,
+		0.656300f,
+		0.413800f,
+		0.340665f,
+		-0.133764f,
+		-0.340666f,
+		0.000000f,
+		0.681500f,
+		-0.266600f,
+		-0.681500f,
+		0.625000f,
+		0.413800f,
+		0.258055f,
+		-0.185069f,
+		-0.386207f,
+		0.000000f,
+		0.516300f,
+		-0.369000f,
+		-0.772800f,
+		0.656300f,
+		0.379300f,
+		0.340665f,
+		-0.133764f,
+		-0.340666f,
+		0.000000f,
+		0.681500f,
+		-0.266600f,
+		-0.681500f,
+		0.625000f,
+		0.413800f,
+		0.328442f,
+		-0.185069f,
+		-0.328443f,
+		0.000000f,
+		0.657200f,
+		-0.369000f,
+		-0.657200f,
+		0.625000f,
+		0.379300f,
+		0.143212f,
+		0.428429f,
+		-0.214334f,
+		0.000000f,
+		0.287800f,
+		0.855300f,
+		-0.430700f,
+		0.656300f,
+		0.827600f,
+		0.116638f,
+		0.453788f,
+		-0.174562f,
+		0.000000f,
+		0.234800f,
+		0.906300f,
+		-0.351400f,
+		0.656300f,
+		0.862100f,
+		0.148453f,
+		0.453788f,
+		-0.148453f,
+		0.000000f,
+		0.298900f,
+		0.906300f,
+		-0.298900f,
+		0.625000f,
+		0.862100f,
+		0.143212f,
+		0.428429f,
+		-0.214334f,
+		0.000000f,
+		0.287800f,
+		0.855300f,
+		-0.430700f,
+		0.656300f,
+		0.827600f,
+		0.148453f,
+		0.453788f,
+		-0.148453f,
+		0.000000f,
+		0.298900f,
+		0.906300f,
+		-0.298900f,
+		0.625000f,
+		0.862100f,
+		0.182275f,
+		0.428429f,
+		-0.182276f,
+		0.000000f,
+		0.366300f,
+		0.855300f,
+		-0.366300f,
+		0.625000f,
+		0.827600f,
+		0.245426f,
+		-0.234204f,
+		-0.367306f,
+		0.000000f,
+		0.491300f,
+		-0.467000f,
+		-0.735200f,
+		0.656300f,
+		0.344800f,
+		0.258055f,
+		-0.185069f,
+		-0.386207f,
+		0.000000f,
+		0.516300f,
+		-0.369000f,
+		-0.772800f,
+		0.656300f,
+		0.379300f,
+		0.328442f,
+		-0.185069f,
+		-0.328443f,
+		0.000000f,
+		0.657200f,
+		-0.369000f,
+		-0.657200f,
+		0.625000f,
+		0.379300f,
+		0.245426f,
+		-0.234204f,
+		-0.367306f,
+		0.000000f,
+		0.491300f,
+		-0.467000f,
+		-0.735200f,
+		0.656300f,
+		0.344800f,
+		0.328442f,
+		-0.185069f,
+		-0.328443f,
+		0.000000f,
+		0.657200f,
+		-0.369000f,
+		-0.657200f,
+		0.625000f,
+		0.379300f,
+		0.312368f,
+		-0.234204f,
+		-0.312368f,
+		0.000000f,
+		0.625200f,
+		-0.467000f,
+		-0.625200f,
+		0.625000f,
+		0.344800f,
+		0.168107f,
+		0.398046f,
+		-0.251592f,
+		0.000000f,
+		0.337400f,
+		0.794500f,
+		-0.504900f,
+		0.656300f,
+		0.793100f,
+		0.143212f,
+		0.428429f,
+		-0.214334f,
+		0.000000f,
+		0.287800f,
+		0.855300f,
+		-0.430700f,
+		0.656300f,
+		0.827600f,
+		0.182275f,
+		0.428429f,
+		-0.182276f,
+		0.000000f,
+		0.366300f,
+		0.855300f,
+		-0.366300f,
+		0.625000f,
+		0.827600f,
+		0.168107f,
+		0.398046f,
+		-0.251592f,
+		0.000000f,
+		0.337400f,
+		0.794500f,
+		-0.504900f,
+		0.656300f,
+		0.793100f,
+		0.182275f,
+		0.428429f,
+		-0.182276f,
+		0.000000f,
+		0.366300f,
+		0.855300f,
+		-0.366300f,
+		0.625000f,
+		0.827600f,
+		0.213960f,
+		0.398046f,
+		-0.213961f,
+		0.000000f,
+		0.429400f,
+		0.794500f,
+		-0.429400f,
+		0.625000f,
+		0.793100f,
+		0.229919f,
+		-0.280594f,
+		-0.344099f,
+		0.000000f,
+		0.460400f,
+		-0.559600f,
+		-0.689100f,
+		0.656300f,
+		0.310300f,
+		0.245426f,
+		-0.234204f,
+		-0.367306f,
+		0.000000f,
+		0.491300f,
+		-0.467000f,
+		-0.735200f,
+		0.656300f,
+		0.344800f,
+		0.312368f,
+		-0.234204f,
+		-0.312368f,
+		0.000000f,
+		0.625200f,
+		-0.467000f,
+		-0.625200f,
+		0.625000f,
+		0.344800f,
+		0.229919f,
+		-0.280594f,
+		-0.344099f,
+		0.000000f,
+		0.460400f,
+		-0.559600f,
+		-0.689100f,
+		0.656300f,
+		0.310300f,
+		0.312368f,
+		-0.234204f,
+		-0.312368f,
+		0.000000f,
+		0.625200f,
+		-0.467000f,
+		-0.625200f,
+		0.625000f,
+		0.344800f,
+		0.292632f,
+		-0.280594f,
+		-0.292632f,
+		0.000000f,
+		0.586000f,
+		-0.559600f,
+		-0.586000f,
+		0.625000f,
+		0.310300f,
+		0.191032f,
+		0.362998f,
+		-0.285900f,
+		0.000000f,
+		0.383000f,
+		0.724300f,
+		-0.573300f,
+		0.656300f,
+		0.758600f,
+		0.168107f,
+		0.398046f,
+		-0.251592f,
+		0.000000f,
+		0.337400f,
+		0.794500f,
+		-0.504900f,
+		0.656300f,
+		0.793100f,
+		0.213960f,
+		0.398046f,
+		-0.213961f,
+		0.000000f,
+		0.429400f,
+		0.794500f,
+		-0.429400f,
+		0.625000f,
+		0.793100f,
+		0.191032f,
+		0.362998f,
+		-0.285900f,
+		0.000000f,
+		0.383000f,
+		0.724300f,
+		-0.573300f,
+		0.656300f,
+		0.758600f,
+		0.213960f,
+		0.398046f,
+		-0.213961f,
+		0.000000f,
+		0.429400f,
+		0.794500f,
+		-0.429400f,
+		0.625000f,
+		0.793100f,
+		0.243137f,
+		0.362998f,
+		-0.243138f,
+		0.000000f,
+		0.487500f,
+		0.724300f,
+		-0.487500f,
+		0.625000f,
+		0.758600f,
+		0.211717f,
+		-0.323693f,
+		-0.316857f,
+		0.000000f,
+		0.424200f,
+		-0.645700f,
+		-0.634900f,
+		0.656300f,
+		0.275900f,
+		0.229919f,
+		-0.280594f,
+		-0.344099f,
+		0.000000f,
+		0.460400f,
+		-0.559600f,
+		-0.689100f,
+		0.656300f,
+		0.310300f,
+		0.292632f,
+		-0.280594f,
+		-0.292632f,
+		0.000000f,
+		0.586000f,
+		-0.559600f,
+		-0.586000f,
+		0.625000f,
+		0.310300f,
+		0.211717f,
+		-0.323693f,
+		-0.316857f,
+		0.000000f,
+		0.424200f,
+		-0.645700f,
+		-0.634900f,
+		0.656300f,
+		0.275900f,
+		0.292632f,
+		-0.280594f,
+		-0.292632f,
+		0.000000f,
+		0.586000f,
+		-0.559600f,
+		-0.586000f,
+		0.625000f,
+		0.310300f,
+		0.269464f,
+		-0.323693f,
+		-0.269464f,
+		0.000000f,
+		0.539900f,
+		-0.645700f,
+		-0.539900f,
+		0.625000f,
+		0.275900f,
+		0.211717f,
+		0.323693f,
+		-0.316857f,
+		0.000000f,
+		0.424200f,
+		0.645700f,
+		-0.634900f,
+		0.656300f,
+		0.724100f,
+		0.191032f,
+		0.362998f,
+		-0.285900f,
+		0.000000f,
+		0.383000f,
+		0.724300f,
+		-0.573300f,
+		0.656300f,
+		0.758600f,
+		0.243137f,
+		0.362998f,
+		-0.243138f,
+		0.000000f,
+		0.487500f,
+		0.724300f,
+		-0.487500f,
+		0.625000f,
+		0.758600f,
+		0.211717f,
+		0.323693f,
+		-0.316857f,
+		0.000000f,
+		0.424200f,
+		0.645700f,
+		-0.634900f,
+		0.656300f,
+		0.724100f,
+		0.243137f,
+		0.362998f,
+		-0.243138f,
+		0.000000f,
+		0.487500f,
+		0.724300f,
+		-0.487500f,
+		0.625000f,
+		0.758600f,
+		0.269464f,
+		0.323693f,
+		-0.269464f,
+		0.000000f,
+		0.539900f,
+		0.645700f,
+		-0.539900f,
+		0.625000f,
+		0.724100f,
+		0.191032f,
+		-0.362998f,
+		-0.285900f,
+		0.000000f,
+		0.383000f,
+		-0.724300f,
+		-0.573300f,
+		0.656300f,
+		0.241400f,
+		0.211717f,
+		-0.323693f,
+		-0.316857f,
+		0.000000f,
+		0.424200f,
+		-0.645700f,
+		-0.634900f,
+		0.656300f,
+		0.275900f,
+		0.269464f,
+		-0.323693f,
+		-0.269464f,
+		0.000000f,
+		0.539900f,
+		-0.645700f,
+		-0.539900f,
+		0.625000f,
+		0.275900f,
+		0.191032f,
+		-0.362998f,
+		-0.285900f,
+		0.000000f,
+		0.383000f,
+		-0.724300f,
+		-0.573300f,
+		0.656300f,
+		0.241400f,
+		0.269464f,
+		-0.323693f,
+		-0.269464f,
+		0.000000f,
+		0.539900f,
+		-0.645700f,
+		-0.539900f,
+		0.625000f,
+		0.275900f,
+		0.243137f,
+		-0.362998f,
+		-0.243138f,
+		0.000000f,
+		0.487500f,
+		-0.724300f,
+		-0.487500f,
+		0.625000f,
+		0.241400f,
+		0.229919f,
+		0.280594f,
+		-0.344099f,
+		0.000000f,
+		0.460400f,
+		0.559600f,
+		-0.689100f,
+		0.656300f,
+		0.689700f,
+		0.211717f,
+		0.323693f,
+		-0.316857f,
+		0.000000f,
+		0.424200f,
+		0.645700f,
+		-0.634900f,
+		0.656300f,
+		0.724100f,
+		0.269464f,
+		0.323693f,
+		-0.269464f,
+		0.000000f,
+		0.539900f,
+		0.645700f,
+		-0.539900f,
+		0.625000f,
+		0.724100f,
+		0.229919f,
+		0.280594f,
+		-0.344099f,
+		0.000000f,
+		0.460400f,
+		0.559600f,
+		-0.689100f,
+		0.656300f,
+		0.689700f,
+		0.269464f,
+		0.323693f,
+		-0.269464f,
+		0.000000f,
+		0.539900f,
+		0.645700f,
+		-0.539900f,
+		0.625000f,
+		0.724100f,
+		0.292632f,
+		0.280594f,
+		-0.292632f,
+		0.000000f,
+		0.586000f,
+		0.559600f,
+		-0.586000f,
+		0.625000f,
+		0.689700f,
+		0.168108f,
+		-0.398046f,
+		-0.251592f,
+		0.000000f,
+		0.337400f,
+		-0.794500f,
+		-0.505000f,
+		0.656300f,
+		0.206900f,
+		0.191032f,
+		-0.362998f,
+		-0.285900f,
+		0.000000f,
+		0.383000f,
+		-0.724300f,
+		-0.573300f,
+		0.656300f,
+		0.241400f,
+		0.243137f,
+		-0.362998f,
+		-0.243138f,
+		0.000000f,
+		0.487500f,
+		-0.724300f,
+		-0.487500f,
+		0.625000f,
+		0.241400f,
+		0.168108f,
+		-0.398046f,
+		-0.251592f,
+		0.000000f,
+		0.337400f,
+		-0.794500f,
+		-0.505000f,
+		0.656300f,
+		0.206900f,
+		0.243137f,
+		-0.362998f,
+		-0.243138f,
+		0.000000f,
+		0.487500f,
+		-0.724300f,
+		-0.487500f,
+		0.625000f,
+		0.241400f,
+		0.213960f,
+		-0.398046f,
+		-0.213961f,
+		0.000000f,
+		0.429400f,
+		-0.794500f,
+		-0.429400f,
+		0.625000f,
+		0.206900f,
+		0.245426f,
+		0.234204f,
+		-0.367306f,
+		0.000000f,
+		0.491300f,
+		0.467000f,
+		-0.735200f,
+		0.656300f,
+		0.655200f,
+		0.229919f,
+		0.280594f,
+		-0.344099f,
+		0.000000f,
+		0.460400f,
+		0.559600f,
+		-0.689100f,
+		0.656300f,
+		0.689700f,
+		0.292632f,
+		0.280594f,
+		-0.292632f,
+		0.000000f,
+		0.586000f,
+		0.559600f,
+		-0.586000f,
+		0.625000f,
+		0.689700f,
+		0.245426f,
+		0.234204f,
+		-0.367306f,
+		0.000000f,
+		0.491300f,
+		0.467000f,
+		-0.735200f,
+		0.656300f,
+		0.655200f,
+		0.292632f,
+		0.280594f,
+		-0.292632f,
+		0.000000f,
+		0.586000f,
+		0.559600f,
+		-0.586000f,
+		0.625000f,
+		0.689700f,
+		0.312368f,
+		0.234204f,
+		-0.312368f,
+		0.000000f,
+		0.625200f,
+		0.467000f,
+		-0.625200f,
+		0.625000f,
+		0.655200f,
+		0.143212f,
+		-0.428429f,
+		-0.214334f,
+		0.000000f,
+		0.287800f,
+		-0.855300f,
+		-0.430700f,
+		0.656300f,
+		0.172400f,
+		0.168108f,
+		-0.398046f,
+		-0.251592f,
+		0.000000f,
+		0.337400f,
+		-0.794500f,
+		-0.505000f,
+		0.656300f,
+		0.206900f,
+		0.213960f,
+		-0.398046f,
+		-0.213961f,
+		0.000000f,
+		0.429400f,
+		-0.794500f,
+		-0.429400f,
+		0.625000f,
+		0.206900f,
+		0.143212f,
+		-0.428429f,
+		-0.214334f,
+		0.000000f,
+		0.287800f,
+		-0.855300f,
+		-0.430700f,
+		0.656300f,
+		0.172400f,
+		0.213960f,
+		-0.398046f,
+		-0.213961f,
+		0.000000f,
+		0.429400f,
+		-0.794500f,
+		-0.429400f,
+		0.625000f,
+		0.206900f,
+		0.182275f,
+		-0.428429f,
+		-0.182276f,
+		0.000000f,
+		0.366300f,
+		-0.855300f,
+		-0.366300f,
+		0.625000f,
+		0.172400f,
+		0.258055f,
+		0.185069f,
+		-0.386207f,
+		0.000000f,
+		0.516300f,
+		0.369000f,
+		-0.772800f,
+		0.656300f,
+		0.620700f,
+		0.245426f,
+		0.234204f,
+		-0.367306f,
+		0.000000f,
+		0.491300f,
+		0.467000f,
+		-0.735200f,
+		0.656300f,
+		0.655200f,
+		0.312368f,
+		0.234204f,
+		-0.312368f,
+		0.000000f,
+		0.625200f,
+		0.467000f,
+		-0.625200f,
+		0.625000f,
+		0.655200f,
+		0.258055f,
+		0.185069f,
+		-0.386207f,
+		0.000000f,
+		0.516300f,
+		0.369000f,
+		-0.772800f,
+		0.656300f,
+		0.620700f,
+		0.312368f,
+		0.234204f,
+		-0.312368f,
+		0.000000f,
+		0.625200f,
+		0.467000f,
+		-0.625200f,
+		0.625000f,
+		0.655200f,
+		0.328442f,
+		0.185069f,
+		-0.328443f,
+		0.000000f,
+		0.657200f,
+		0.369000f,
+		-0.657200f,
+		0.625000f,
+		0.620700f,
+		0.116638f,
+		-0.453788f,
+		-0.174562f,
+		0.000000f,
+		0.234800f,
+		-0.906300f,
+		-0.351400f,
+		0.656300f,
+		0.137900f,
+		0.143212f,
+		-0.428429f,
+		-0.214334f,
+		0.000000f,
+		0.287800f,
+		-0.855300f,
+		-0.430700f,
+		0.656300f,
+		0.172400f,
+		0.182275f,
+		-0.428429f,
+		-0.182276f,
+		0.000000f,
+		0.366300f,
+		-0.855300f,
+		-0.366300f,
+		0.625000f,
+		0.172400f,
+		0.116638f,
+		-0.453788f,
+		-0.174562f,
+		0.000000f,
+		0.234800f,
+		-0.906300f,
+		-0.351400f,
+		0.656300f,
+		0.137900f,
+		0.182275f,
+		-0.428429f,
+		-0.182276f,
+		0.000000f,
+		0.366300f,
+		-0.855300f,
+		-0.366300f,
+		0.625000f,
+		0.172400f,
+		0.148453f,
+		-0.453788f,
+		-0.148453f,
+		0.000000f,
+		0.298900f,
+		-0.906300f,
+		-0.298900f,
+		0.625000f,
+		0.137900f,
+		0.267659f,
+		0.133764f,
+		-0.400580f,
+		0.000000f,
+		0.535400f,
+		0.266600f,
+		-0.801400f,
+		0.656300f,
+		0.586200f,
+		0.258055f,
+		0.185069f,
+		-0.386207f,
+		0.000000f,
+		0.516300f,
+		0.369000f,
+		-0.772800f,
+		0.656300f,
+		0.620700f,
+		0.328442f,
+		0.185069f,
+		-0.328443f,
+		0.000000f,
+		0.657200f,
+		0.369000f,
+		-0.657200f,
+		0.625000f,
+		0.620700f,
+		0.267659f,
+		0.133764f,
+		-0.400580f,
+		0.000000f,
+		0.535400f,
+		0.266600f,
+		-0.801400f,
+		0.656300f,
+		0.586200f,
+		0.328442f,
+		0.185069f,
+		-0.328443f,
+		0.000000f,
+		0.657200f,
+		0.369000f,
+		-0.657200f,
+		0.625000f,
+		0.620700f,
+		0.340665f,
+		0.133764f,
+		-0.340666f,
+		0.000000f,
+		0.681500f,
+		0.266600f,
+		-0.681500f,
+		0.625000f,
+		0.586200f,
+		0.088697f,
+		-0.473826f,
+		-0.132745f,
+		0.000000f,
+		0.179100f,
+		-0.946600f,
+		-0.268000f,
+		0.656300f,
+		0.103400f,
+		0.116638f,
+		-0.453788f,
+		-0.174562f,
+		0.000000f,
+		0.234800f,
+		-0.906300f,
+		-0.351400f,
+		0.656300f,
+		0.137900f,
+		0.148453f,
+		-0.453788f,
+		-0.148453f,
+		0.000000f,
+		0.298900f,
+		-0.906300f,
+		-0.298900f,
+		0.625000f,
+		0.137900f,
+		0.088697f,
+		-0.473826f,
+		-0.132745f,
+		0.000000f,
+		0.179100f,
+		-0.946600f,
+		-0.268000f,
+		0.656300f,
+		0.103400f,
+		0.148453f,
+		-0.453788f,
+		-0.148453f,
+		0.000000f,
+		0.298900f,
+		-0.906300f,
+		-0.298900f,
+		0.625000f,
+		0.137900f,
+		0.112889f,
+		-0.473826f,
+		-0.112890f,
+		0.000000f,
+		0.227900f,
+		-0.946600f,
+		-0.227900f,
+		0.625000f,
+		0.103400f,
+		0.274125f,
+		0.080891f,
+		-0.410257f,
+		0.000000f,
+		0.548300f,
+		0.161200f,
+		-0.820600f,
+		0.656300f,
+		0.551700f,
+		0.267659f,
+		0.133764f,
+		-0.400580f,
+		0.000000f,
+		0.535400f,
+		0.266600f,
+		-0.801400f,
+		0.656300f,
+		0.586200f,
+		0.340665f,
+		0.133764f,
+		-0.340666f,
+		0.000000f,
+		0.681500f,
+		0.266600f,
+		-0.681500f,
+		0.625000f,
+		0.586200f,
+		0.274125f,
+		0.080891f,
+		-0.410257f,
+		0.000000f,
+		0.548300f,
+		0.161200f,
+		-0.820600f,
+		0.656300f,
+		0.551700f,
+		0.340665f,
+		0.133764f,
+		-0.340666f,
+		0.000000f,
+		0.681500f,
+		0.266600f,
+		-0.681500f,
+		0.625000f,
+		0.586200f,
+		0.348895f,
+		0.080891f,
+		-0.348895f,
+		0.000000f,
+		0.697800f,
+		0.161200f,
+		-0.697800f,
+		0.625000f,
+		0.551700f,
+		0.269464f,
+		0.323693f,
+		-0.269464f,
+		0.000000f,
+		0.539900f,
+		0.645700f,
+		-0.539900f,
+		0.625000f,
+		0.724100f,
+		0.243137f,
+		0.362998f,
+		-0.243138f,
+		0.000000f,
+		0.487500f,
+		0.724300f,
+		-0.487500f,
+		0.625000f,
+		0.758600f,
+		0.285899f,
+		0.362998f,
+		-0.191032f,
+		0.000000f,
+		0.573300f,
+		0.724300f,
+		-0.383000f,
+		0.593800f,
+		0.758600f,
+		0.269464f,
+		0.323693f,
+		-0.269464f,
+		0.000000f,
+		0.539900f,
+		0.645700f,
+		-0.539900f,
+		0.625000f,
+		0.724100f,
+		0.285899f,
+		0.362998f,
+		-0.191032f,
+		0.000000f,
+		0.573300f,
+		0.724300f,
+		-0.383000f,
+		0.593800f,
+		0.758600f,
+		0.316857f,
+		0.323693f,
+		-0.211717f,
+		0.000000f,
+		0.634900f,
+		0.645700f,
+		-0.424200f,
+		0.593800f,
+		0.724100f,
+		0.243137f,
+		-0.362998f,
+		-0.243138f,
+		0.000000f,
+		0.487500f,
+		-0.724300f,
+		-0.487500f,
+		0.625000f,
+		0.241400f,
+		0.269464f,
+		-0.323693f,
+		-0.269464f,
+		0.000000f,
+		0.539900f,
+		-0.645700f,
+		-0.539900f,
+		0.625000f,
+		0.275900f,
+		0.316857f,
+		-0.323693f,
+		-0.211717f,
+		0.000000f,
+		0.634900f,
+		-0.645700f,
+		-0.424200f,
+		0.593800f,
+		0.275900f,
+		0.243137f,
+		-0.362998f,
+		-0.243138f,
+		0.000000f,
+		0.487500f,
+		-0.724300f,
+		-0.487500f,
+		0.625000f,
+		0.241400f,
+		0.316857f,
+		-0.323693f,
+		-0.211717f,
+		0.000000f,
+		0.634900f,
+		-0.645700f,
+		-0.424200f,
+		0.593800f,
+		0.275900f,
+		0.285900f,
+		-0.362998f,
+		-0.191032f,
+		0.000000f,
+		0.573300f,
+		-0.724300f,
+		-0.383000f,
+		0.593800f,
+		0.241400f,
+		0.292632f,
+		0.280594f,
+		-0.292632f,
+		0.000000f,
+		0.586000f,
+		0.559600f,
+		-0.586000f,
+		0.625000f,
+		0.689700f,
+		0.269464f,
+		0.323693f,
+		-0.269464f,
+		0.000000f,
+		0.539900f,
+		0.645700f,
+		-0.539900f,
+		0.625000f,
+		0.724100f,
+		0.316857f,
+		0.323693f,
+		-0.211717f,
+		0.000000f,
+		0.634900f,
+		0.645700f,
+		-0.424200f,
+		0.593800f,
+		0.724100f,
+		0.292632f,
+		0.280594f,
+		-0.292632f,
+		0.000000f,
+		0.586000f,
+		0.559600f,
+		-0.586000f,
+		0.625000f,
+		0.689700f,
+		0.316857f,
+		0.323693f,
+		-0.211717f,
+		0.000000f,
+		0.634900f,
+		0.645700f,
+		-0.424200f,
+		0.593800f,
+		0.724100f,
+		0.344098f,
+		0.280594f,
+		-0.229919f,
+		0.000000f,
+		0.689100f,
+		0.559600f,
+		-0.460400f,
+		0.593800f,
+		0.689700f,
+		0.213960f,
+		-0.398046f,
+		-0.213961f,
+		0.000000f,
+		0.429400f,
+		-0.794500f,
+		-0.429400f,
+		0.625000f,
+		0.206900f,
+		0.243137f,
+		-0.362998f,
+		-0.243138f,
+		0.000000f,
+		0.487500f,
+		-0.724300f,
+		-0.487500f,
+		0.625000f,
+		0.241400f,
+		0.285900f,
+		-0.362998f,
+		-0.191032f,
+		0.000000f,
+		0.573300f,
+		-0.724300f,
+		-0.383000f,
+		0.593800f,
+		0.241400f,
+		0.213960f,
+		-0.398046f,
+		-0.213961f,
+		0.000000f,
+		0.429400f,
+		-0.794500f,
+		-0.429400f,
+		0.625000f,
+		0.206900f,
+		0.285900f,
+		-0.362998f,
+		-0.191032f,
+		0.000000f,
+		0.573300f,
+		-0.724300f,
+		-0.383000f,
+		0.593800f,
+		0.241400f,
+		0.251591f,
+		-0.398046f,
+		-0.168108f,
+		0.000000f,
+		0.505000f,
+		-0.794500f,
+		-0.337400f,
+		0.593800f,
+		0.206900f,
+		0.312368f,
+		0.234204f,
+		-0.312368f,
+		0.000000f,
+		0.625200f,
+		0.467000f,
+		-0.625200f,
+		0.625000f,
+		0.655200f,
+		0.292632f,
+		0.280594f,
+		-0.292632f,
+		0.000000f,
+		0.586000f,
+		0.559600f,
+		-0.586000f,
+		0.625000f,
+		0.689700f,
+		0.344098f,
+		0.280594f,
+		-0.229919f,
+		0.000000f,
+		0.689100f,
+		0.559600f,
+		-0.460400f,
+		0.593800f,
+		0.689700f,
+		0.312368f,
+		0.234204f,
+		-0.312368f,
+		0.000000f,
+		0.625200f,
+		0.467000f,
+		-0.625200f,
+		0.625000f,
+		0.655200f,
+		0.344098f,
+		0.280594f,
+		-0.229919f,
+		0.000000f,
+		0.689100f,
+		0.559600f,
+		-0.460400f,
+		0.593800f,
+		0.689700f,
+		0.367306f,
+		0.234204f,
+		-0.245426f,
+		0.000000f,
+		0.735200f,
+		0.467000f,
+		-0.491300f,
+		0.593800f,
+		0.655200f,
+		0.182275f,
+		-0.428429f,
+		-0.182276f,
+		0.000000f,
+		0.366300f,
+		-0.855300f,
+		-0.366300f,
+		0.625000f,
+		0.172400f,
+		0.213960f,
+		-0.398046f,
+		-0.213961f,
+		0.000000f,
+		0.429400f,
+		-0.794500f,
+		-0.429400f,
+		0.625000f,
+		0.206900f,
+		0.251591f,
+		-0.398046f,
+		-0.168108f,
+		0.000000f,
+		0.505000f,
+		-0.794500f,
+		-0.337400f,
+		0.593800f,
+		0.206900f,
+		0.182275f,
+		-0.428429f,
+		-0.182276f,
+		0.000000f,
+		0.366300f,
+		-0.855300f,
+		-0.366300f,
+		0.625000f,
+		0.172400f,
+		0.251591f,
+		-0.398046f,
+		-0.168108f,
+		0.000000f,
+		0.505000f,
+		-0.794500f,
+		-0.337400f,
+		0.593800f,
+		0.206900f,
+		0.214333f,
+		-0.428429f,
+		-0.143213f,
+		0.000000f,
+		0.430700f,
+		-0.855300f,
+		-0.287800f,
+		0.593800f,
+		0.172400f,
+		0.328442f,
+		0.185069f,
+		-0.328443f,
+		0.000000f,
+		0.657200f,
+		0.369000f,
+		-0.657200f,
+		0.625000f,
+		0.620700f,
+		0.312368f,
+		0.234204f,
+		-0.312368f,
+		0.000000f,
+		0.625200f,
+		0.467000f,
+		-0.625200f,
+		0.625000f,
+		0.655200f,
+		0.367306f,
+		0.234204f,
+		-0.245426f,
+		0.000000f,
+		0.735200f,
+		0.467000f,
+		-0.491300f,
+		0.593800f,
+		0.655200f,
+		0.328442f,
+		0.185069f,
+		-0.328443f,
+		0.000000f,
+		0.657200f,
+		0.369000f,
+		-0.657200f,
+		0.625000f,
+		0.620700f,
+		0.367306f,
+		0.234204f,
+		-0.245426f,
+		0.000000f,
+		0.735200f,
+		0.467000f,
+		-0.491300f,
+		0.593800f,
+		0.655200f,
+		0.386207f,
+		0.185069f,
+		-0.258056f,
+		0.000000f,
+		0.772800f,
+		0.369000f,
+		-0.516300f,
+		0.593800f,
+		0.620700f,
+		0.148453f,
+		-0.453788f,
+		-0.148453f,
+		0.000000f,
+		0.298900f,
+		-0.906300f,
+		-0.298900f,
+		0.625000f,
+		0.137900f,
+		0.182275f,
+		-0.428429f,
+		-0.182276f,
+		0.000000f,
+		0.366300f,
+		-0.855300f,
+		-0.366300f,
+		0.625000f,
+		0.172400f,
+		0.214333f,
+		-0.428429f,
+		-0.143213f,
+		0.000000f,
+		0.430700f,
+		-0.855300f,
+		-0.287800f,
+		0.593800f,
+		0.172400f,
+		0.148453f,
+		-0.453788f,
+		-0.148453f,
+		0.000000f,
+		0.298900f,
+		-0.906300f,
+		-0.298900f,
+		0.625000f,
+		0.137900f,
+		0.214333f,
+		-0.428429f,
+		-0.143213f,
+		0.000000f,
+		0.430700f,
+		-0.855300f,
+		-0.287800f,
+		0.593800f,
+		0.172400f,
+		0.174562f,
+		-0.453788f,
+		-0.116639f,
+		0.000000f,
+		0.351400f,
+		-0.906300f,
+		-0.234800f,
+		0.593800f,
+		0.137900f,
+		0.340665f,
+		0.133764f,
+		-0.340666f,
+		0.000000f,
+		0.681500f,
+		0.266600f,
+		-0.681500f,
+		0.625000f,
+		0.586200f,
+		0.328442f,
+		0.185069f,
+		-0.328443f,
+		0.000000f,
+		0.657200f,
+		0.369000f,
+		-0.657200f,
+		0.625000f,
+		0.620700f,
+		0.386207f,
+		0.185069f,
+		-0.258056f,
+		0.000000f,
+		0.772800f,
+		0.369000f,
+		-0.516300f,
+		0.593800f,
+		0.620700f,
+		0.340665f,
+		0.133764f,
+		-0.340666f,
+		0.000000f,
+		0.681500f,
+		0.266600f,
+		-0.681500f,
+		0.625000f,
+		0.586200f,
+		0.386207f,
+		0.185069f,
+		-0.258056f,
+		0.000000f,
+		0.772800f,
+		0.369000f,
+		-0.516300f,
+		0.593800f,
+		0.620700f,
+		0.400580f,
+		0.133764f,
+		-0.267659f,
+		0.000000f,
+		0.801400f,
+		0.266600f,
+		-0.535400f,
+		0.593800f,
+		0.586200f,
+		0.112889f,
+		-0.473826f,
+		-0.112890f,
+		0.000000f,
+		0.227900f,
+		-0.946600f,
+		-0.227900f,
+		0.625000f,
+		0.103400f,
+		0.148453f,
+		-0.453788f,
+		-0.148453f,
+		0.000000f,
+		0.298900f,
+		-0.906300f,
+		-0.298900f,
+		0.625000f,
+		0.137900f,
+		0.174562f,
+		-0.453788f,
+		-0.116639f,
+		0.000000f,
+		0.351400f,
+		-0.906300f,
+		-0.234800f,
+		0.593800f,
+		0.137900f,
+		0.112889f,
+		-0.473826f,
+		-0.112890f,
+		0.000000f,
+		0.227900f,
+		-0.946600f,
+		-0.227900f,
+		0.625000f,
+		0.103400f,
+		0.174562f,
+		-0.453788f,
+		-0.116639f,
+		0.000000f,
+		0.351400f,
+		-0.906300f,
+		-0.234800f,
+		0.593800f,
+		0.137900f,
+		0.132744f,
+		-0.473826f,
+		-0.088697f,
+		0.000000f,
+		0.268000f,
+		-0.946600f,
+		-0.179100f,
+		0.593800f,
+		0.103400f,
+		0.348895f,
+		0.080891f,
+		-0.348895f,
+		0.000000f,
+		0.697800f,
+		0.161200f,
+		-0.697800f,
+		0.625000f,
+		0.551700f,
+		0.340665f,
+		0.133764f,
+		-0.340666f,
+		0.000000f,
+		0.681500f,
+		0.266600f,
+		-0.681500f,
+		0.625000f,
+		0.586200f,
+		0.400580f,
+		0.133764f,
+		-0.267659f,
+		0.000000f,
+		0.801400f,
+		0.266600f,
+		-0.535400f,
+		0.593800f,
+		0.586200f,
+		0.348895f,
+		0.080891f,
+		-0.348895f,
+		0.000000f,
+		0.697800f,
+		0.161200f,
+		-0.697800f,
+		0.625000f,
+		0.551700f,
+		0.400580f,
+		0.133764f,
+		-0.267659f,
+		0.000000f,
+		0.801400f,
+		0.266600f,
+		-0.535400f,
+		0.593800f,
+		0.586200f,
+		0.410257f,
+		0.080891f,
+		-0.274125f,
+		0.000000f,
+		0.820600f,
+		0.161200f,
+		-0.548300f,
+		0.593800f,
+		0.551700f,
+		0.076003f,
+		-0.488310f,
+		-0.076003f,
+		0.000000f,
+		0.154300f,
+		-0.975900f,
+		-0.154300f,
+		0.625000f,
+		0.069000f,
+		0.112889f,
+		-0.473826f,
+		-0.112890f,
+		0.000000f,
+		0.227900f,
+		-0.946600f,
+		-0.227900f,
+		0.625000f,
+		0.103400f,
+		0.132744f,
+		-0.473826f,
+		-0.088697f,
+		0.000000f,
+		0.268000f,
+		-0.946600f,
+		-0.179100f,
+		0.593800f,
+		0.103400f,
+		0.076003f,
+		-0.488310f,
+		-0.076003f,
+		0.000000f,
+		0.154300f,
+		-0.975900f,
+		-0.154300f,
+		0.625000f,
+		0.069000f,
+		0.132744f,
+		-0.473826f,
+		-0.088697f,
+		0.000000f,
+		0.268000f,
+		-0.946600f,
+		-0.179100f,
+		0.593800f,
+		0.103400f,
+		0.089370f,
+		-0.488310f,
+		-0.059715f,
+		0.000000f,
+		0.181400f,
+		-0.975900f,
+		-0.121200f,
+		0.593800f,
+		0.069000f,
+		0.353034f,
+		0.027069f,
+		-0.353034f,
+		0.000000f,
+		0.706100f,
+		0.054000f,
+		-0.706100f,
+		0.625000f,
+		0.517200f,
+		0.348895f,
+		0.080891f,
+		-0.348895f,
+		0.000000f,
+		0.697800f,
+		0.161200f,
+		-0.697800f,
+		0.625000f,
+		0.551700f,
+		0.410257f,
+		0.080891f,
+		-0.274125f,
+		0.000000f,
+		0.820600f,
+		0.161200f,
+		-0.548300f,
+		0.593800f,
+		0.551700f,
+		0.353034f,
+		0.027069f,
+		-0.353034f,
+		0.000000f,
+		0.706100f,
+		0.054000f,
+		-0.706100f,
+		0.625000f,
+		0.517200f,
+		0.410257f,
+		0.080891f,
+		-0.274125f,
+		0.000000f,
+		0.820600f,
+		0.161200f,
+		-0.548300f,
+		0.593800f,
+		0.551700f,
+		0.415124f,
+		0.027069f,
+		-0.277377f,
+		0.000000f,
+		0.830300f,
+		0.054000f,
+		-0.554700f,
+		0.593800f,
+		0.517200f,
+		0.038225f,
+		0.497069f,
+		-0.038226f,
+		0.000000f,
+		0.078800f,
+		0.993700f,
+		-0.078800f,
+		0.449000f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.423900f,
+		0.960300f,
+		0.044948f,
+		0.497069f,
+		-0.030034f,
+		0.000000f,
+		0.092700f,
+		0.993700f,
+		-0.061900f,
+		0.450800f,
+		0.962300f,
+		0.038226f,
+		-0.497069f,
+		-0.038226f,
+		0.000000f,
+		0.078800f,
+		-0.993700f,
+		-0.078800f,
+		0.625000f,
+		0.034500f,
+		0.076003f,
+		-0.488310f,
+		-0.076003f,
+		0.000000f,
+		0.154300f,
+		-0.975900f,
+		-0.154300f,
+		0.625000f,
+		0.069000f,
+		0.089370f,
+		-0.488310f,
+		-0.059715f,
+		0.000000f,
+		0.181400f,
+		-0.975900f,
+		-0.121200f,
+		0.593800f,
+		0.069000f,
+		0.038226f,
+		-0.497069f,
+		-0.038226f,
+		0.000000f,
+		0.078800f,
+		-0.993700f,
+		-0.078800f,
+		0.625000f,
+		0.034500f,
+		0.089370f,
+		-0.488310f,
+		-0.059715f,
+		0.000000f,
+		0.181400f,
+		-0.975900f,
+		-0.121200f,
+		0.593800f,
+		0.069000f,
+		0.044948f,
+		-0.497069f,
+		-0.030034f,
+		0.000000f,
+		0.092700f,
+		-0.993700f,
+		-0.061900f,
+		0.593800f,
+		0.034500f,
+		0.353034f,
+		-0.027069f,
+		-0.353034f,
+		0.000000f,
+		0.706100f,
+		-0.054000f,
+		-0.706100f,
+		0.625000f,
+		0.482800f,
+		0.353034f,
+		0.027069f,
+		-0.353034f,
+		0.000000f,
+		0.706100f,
+		0.054000f,
+		-0.706100f,
+		0.625000f,
+		0.517200f,
+		0.415124f,
+		0.027069f,
+		-0.277377f,
+		0.000000f,
+		0.830300f,
+		0.054000f,
+		-0.554700f,
+		0.593800f,
+		0.517200f,
+		0.353034f,
+		-0.027069f,
+		-0.353034f,
+		0.000000f,
+		0.706100f,
+		-0.054000f,
+		-0.706100f,
+		0.625000f,
+		0.482800f,
+		0.415124f,
+		0.027069f,
+		-0.277377f,
+		0.000000f,
+		0.830300f,
+		0.054000f,
+		-0.554700f,
+		0.593800f,
+		0.517200f,
+		0.415124f,
+		-0.027069f,
+		-0.277377f,
+		0.000000f,
+		0.830300f,
+		-0.054000f,
+		-0.554700f,
+		0.593800f,
+		0.482800f,
+		0.076003f,
+		0.488310f,
+		-0.076003f,
+		0.000000f,
+		0.154300f,
+		0.975900f,
+		-0.154300f,
+		0.625000f,
+		0.931000f,
+		0.038225f,
+		0.497069f,
+		-0.038226f,
+		0.000000f,
+		0.078800f,
+		0.993700f,
+		-0.078800f,
+		0.625000f,
+		0.965500f,
+		0.044948f,
+		0.497069f,
+		-0.030034f,
+		0.000000f,
+		0.092700f,
+		0.993700f,
+		-0.061900f,
+		0.593800f,
+		0.965500f,
+		0.076003f,
+		0.488310f,
+		-0.076003f,
+		0.000000f,
+		0.154300f,
+		0.975900f,
+		-0.154300f,
+		0.625000f,
+		0.931000f,
+		0.044948f,
+		0.497069f,
+		-0.030034f,
+		0.000000f,
+		0.092700f,
+		0.993700f,
+		-0.061900f,
+		0.593800f,
+		0.965500f,
+		0.089370f,
+		0.488310f,
+		-0.059715f,
+		0.000000f,
+		0.181400f,
+		0.975900f,
+		-0.121200f,
+		0.593800f,
+		0.931000f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.495500f,
+		0.051000f,
+		0.038226f,
+		-0.497069f,
+		-0.038226f,
+		0.000000f,
+		0.078800f,
+		-0.993700f,
+		-0.078800f,
+		0.462800f,
+		0.053800f,
+		0.044948f,
+		-0.497069f,
+		-0.030034f,
+		0.000000f,
+		0.092700f,
+		-0.993700f,
+		-0.061900f,
+		0.460200f,
+		0.053800f,
+		0.348895f,
+		-0.080891f,
+		-0.348895f,
+		0.000000f,
+		0.697800f,
+		-0.161200f,
+		-0.697800f,
+		0.625000f,
+		0.448300f,
+		0.353034f,
+		-0.027069f,
+		-0.353034f,
+		0.000000f,
+		0.706100f,
+		-0.054000f,
+		-0.706100f,
+		0.625000f,
+		0.482800f,
+		0.415124f,
+		-0.027069f,
+		-0.277377f,
+		0.000000f,
+		0.830300f,
+		-0.054000f,
+		-0.554700f,
+		0.593800f,
+		0.482800f,
+		0.348895f,
+		-0.080891f,
+		-0.348895f,
+		0.000000f,
+		0.697800f,
+		-0.161200f,
+		-0.697800f,
+		0.625000f,
+		0.448300f,
+		0.415124f,
+		-0.027069f,
+		-0.277377f,
+		0.000000f,
+		0.830300f,
+		-0.054000f,
+		-0.554700f,
+		0.593800f,
+		0.482800f,
+		0.410257f,
+		-0.080891f,
+		-0.274125f,
+		0.000000f,
+		0.820600f,
+		-0.161200f,
+		-0.548300f,
+		0.593800f,
+		0.448300f,
+		0.112889f,
+		0.473826f,
+		-0.112890f,
+		0.000000f,
+		0.227900f,
+		0.946600f,
+		-0.227900f,
+		0.625000f,
+		0.896600f,
+		0.076003f,
+		0.488310f,
+		-0.076003f,
+		0.000000f,
+		0.154300f,
+		0.975900f,
+		-0.154300f,
+		0.625000f,
+		0.931000f,
+		0.089370f,
+		0.488310f,
+		-0.059715f,
+		0.000000f,
+		0.181400f,
+		0.975900f,
+		-0.121200f,
+		0.593800f,
+		0.931000f,
+		0.112889f,
+		0.473826f,
+		-0.112890f,
+		0.000000f,
+		0.227900f,
+		0.946600f,
+		-0.227900f,
+		0.625000f,
+		0.896600f,
+		0.089370f,
+		0.488310f,
+		-0.059715f,
+		0.000000f,
+		0.181400f,
+		0.975900f,
+		-0.121200f,
+		0.593800f,
+		0.931000f,
+		0.132744f,
+		0.473826f,
+		-0.088697f,
+		0.000000f,
+		0.268000f,
+		0.946600f,
+		-0.179100f,
+		0.593800f,
+		0.896600f,
+		0.340665f,
+		-0.133764f,
+		-0.340666f,
+		0.000000f,
+		0.681500f,
+		-0.266600f,
+		-0.681500f,
+		0.625000f,
+		0.413800f,
+		0.348895f,
+		-0.080891f,
+		-0.348895f,
+		0.000000f,
+		0.697800f,
+		-0.161200f,
+		-0.697800f,
+		0.625000f,
+		0.448300f,
+		0.410257f,
+		-0.080891f,
+		-0.274125f,
+		0.000000f,
+		0.820600f,
+		-0.161200f,
+		-0.548300f,
+		0.593800f,
+		0.448300f,
+		0.340665f,
+		-0.133764f,
+		-0.340666f,
+		0.000000f,
+		0.681500f,
+		-0.266600f,
+		-0.681500f,
+		0.625000f,
+		0.413800f,
+		0.410257f,
+		-0.080891f,
+		-0.274125f,
+		0.000000f,
+		0.820600f,
+		-0.161200f,
+		-0.548300f,
+		0.593800f,
+		0.448300f,
+		0.400580f,
+		-0.133764f,
+		-0.267659f,
+		0.000000f,
+		0.801400f,
+		-0.266600f,
+		-0.535400f,
+		0.593800f,
+		0.413800f,
+		0.148453f,
+		0.453788f,
+		-0.148453f,
+		0.000000f,
+		0.298900f,
+		0.906300f,
+		-0.298900f,
+		0.625000f,
+		0.862100f,
+		0.112889f,
+		0.473826f,
+		-0.112890f,
+		0.000000f,
+		0.227900f,
+		0.946600f,
+		-0.227900f,
+		0.625000f,
+		0.896600f,
+		0.132744f,
+		0.473826f,
+		-0.088697f,
+		0.000000f,
+		0.268000f,
+		0.946600f,
+		-0.179100f,
+		0.593800f,
+		0.896600f,
+		0.148453f,
+		0.453788f,
+		-0.148453f,
+		0.000000f,
+		0.298900f,
+		0.906300f,
+		-0.298900f,
+		0.625000f,
+		0.862100f,
+		0.132744f,
+		0.473826f,
+		-0.088697f,
+		0.000000f,
+		0.268000f,
+		0.946600f,
+		-0.179100f,
+		0.593800f,
+		0.896600f,
+		0.174562f,
+		0.453788f,
+		-0.116638f,
+		0.000000f,
+		0.351400f,
+		0.906300f,
+		-0.234800f,
+		0.593800f,
+		0.862100f,
+		0.328442f,
+		-0.185069f,
+		-0.328443f,
+		0.000000f,
+		0.657200f,
+		-0.369000f,
+		-0.657200f,
+		0.625000f,
+		0.379300f,
+		0.340665f,
+		-0.133764f,
+		-0.340666f,
+		0.000000f,
+		0.681500f,
+		-0.266600f,
+		-0.681500f,
+		0.625000f,
+		0.413800f,
+		0.400580f,
+		-0.133764f,
+		-0.267659f,
+		0.000000f,
+		0.801400f,
+		-0.266600f,
+		-0.535400f,
+		0.593800f,
+		0.413800f,
+		0.328442f,
+		-0.185069f,
+		-0.328443f,
+		0.000000f,
+		0.657200f,
+		-0.369000f,
+		-0.657200f,
+		0.625000f,
+		0.379300f,
+		0.400580f,
+		-0.133764f,
+		-0.267659f,
+		0.000000f,
+		0.801400f,
+		-0.266600f,
+		-0.535400f,
+		0.593800f,
+		0.413800f,
+		0.386207f,
+		-0.185069f,
+		-0.258056f,
+		0.000000f,
+		0.772800f,
+		-0.369000f,
+		-0.516300f,
+		0.593800f,
+		0.379300f,
+		0.182275f,
+		0.428429f,
+		-0.182276f,
+		0.000000f,
+		0.366300f,
+		0.855300f,
+		-0.366300f,
+		0.625000f,
+		0.827600f,
+		0.148453f,
+		0.453788f,
+		-0.148453f,
+		0.000000f,
+		0.298900f,
+		0.906300f,
+		-0.298900f,
+		0.625000f,
+		0.862100f,
+		0.174562f,
+		0.453788f,
+		-0.116638f,
+		0.000000f,
+		0.351400f,
+		0.906300f,
+		-0.234800f,
+		0.593800f,
+		0.862100f,
+		0.182275f,
+		0.428429f,
+		-0.182276f,
+		0.000000f,
+		0.366300f,
+		0.855300f,
+		-0.366300f,
+		0.625000f,
+		0.827600f,
+		0.174562f,
+		0.453788f,
+		-0.116638f,
+		0.000000f,
+		0.351400f,
+		0.906300f,
+		-0.234800f,
+		0.593800f,
+		0.862100f,
+		0.214333f,
+		0.428429f,
+		-0.143213f,
+		0.000000f,
+		0.430700f,
+		0.855300f,
+		-0.287800f,
+		0.593800f,
+		0.827600f,
+		0.312368f,
+		-0.234204f,
+		-0.312368f,
+		0.000000f,
+		0.625200f,
+		-0.467000f,
+		-0.625200f,
+		0.625000f,
+		0.344800f,
+		0.328442f,
+		-0.185069f,
+		-0.328443f,
+		0.000000f,
+		0.657200f,
+		-0.369000f,
+		-0.657200f,
+		0.625000f,
+		0.379300f,
+		0.386207f,
+		-0.185069f,
+		-0.258056f,
+		0.000000f,
+		0.772800f,
+		-0.369000f,
+		-0.516300f,
+		0.593800f,
+		0.379300f,
+		0.312368f,
+		-0.234204f,
+		-0.312368f,
+		0.000000f,
+		0.625200f,
+		-0.467000f,
+		-0.625200f,
+		0.625000f,
+		0.344800f,
+		0.386207f,
+		-0.185069f,
+		-0.258056f,
+		0.000000f,
+		0.772800f,
+		-0.369000f,
+		-0.516300f,
+		0.593800f,
+		0.379300f,
+		0.367306f,
+		-0.234204f,
+		-0.245426f,
+		0.000000f,
+		0.735200f,
+		-0.467000f,
+		-0.491300f,
+		0.593800f,
+		0.344800f,
+		0.213960f,
+		0.398046f,
+		-0.213961f,
+		0.000000f,
+		0.429400f,
+		0.794500f,
+		-0.429400f,
+		0.625000f,
+		0.793100f,
+		0.182275f,
+		0.428429f,
+		-0.182276f,
+		0.000000f,
+		0.366300f,
+		0.855300f,
+		-0.366300f,
+		0.625000f,
+		0.827600f,
+		0.214333f,
+		0.428429f,
+		-0.143213f,
+		0.000000f,
+		0.430700f,
+		0.855300f,
+		-0.287800f,
+		0.593800f,
+		0.827600f,
+		0.213960f,
+		0.398046f,
+		-0.213961f,
+		0.000000f,
+		0.429400f,
+		0.794500f,
+		-0.429400f,
+		0.625000f,
+		0.793100f,
+		0.214333f,
+		0.428429f,
+		-0.143213f,
+		0.000000f,
+		0.430700f,
+		0.855300f,
+		-0.287800f,
+		0.593800f,
+		0.827600f,
+		0.251591f,
+		0.398046f,
+		-0.168108f,
+		0.000000f,
+		0.504900f,
+		0.794500f,
+		-0.337400f,
+		0.593800f,
+		0.793100f,
+		0.292632f,
+		-0.280594f,
+		-0.292632f,
+		0.000000f,
+		0.586000f,
+		-0.559600f,
+		-0.586000f,
+		0.625000f,
+		0.310300f,
+		0.312368f,
+		-0.234204f,
+		-0.312368f,
+		0.000000f,
+		0.625200f,
+		-0.467000f,
+		-0.625200f,
+		0.625000f,
+		0.344800f,
+		0.367306f,
+		-0.234204f,
+		-0.245426f,
+		0.000000f,
+		0.735200f,
+		-0.467000f,
+		-0.491300f,
+		0.593800f,
+		0.344800f,
+		0.292632f,
+		-0.280594f,
+		-0.292632f,
+		0.000000f,
+		0.586000f,
+		-0.559600f,
+		-0.586000f,
+		0.625000f,
+		0.310300f,
+		0.367306f,
+		-0.234204f,
+		-0.245426f,
+		0.000000f,
+		0.735200f,
+		-0.467000f,
+		-0.491300f,
+		0.593800f,
+		0.344800f,
+		0.344099f,
+		-0.280594f,
+		-0.229919f,
+		0.000000f,
+		0.689100f,
+		-0.559600f,
+		-0.460400f,
+		0.593800f,
+		0.310300f,
+		0.243137f,
+		0.362998f,
+		-0.243138f,
+		0.000000f,
+		0.487500f,
+		0.724300f,
+		-0.487500f,
+		0.625000f,
+		0.758600f,
+		0.213960f,
+		0.398046f,
+		-0.213961f,
+		0.000000f,
+		0.429400f,
+		0.794500f,
+		-0.429400f,
+		0.625000f,
+		0.793100f,
+		0.251591f,
+		0.398046f,
+		-0.168108f,
+		0.000000f,
+		0.504900f,
+		0.794500f,
+		-0.337400f,
+		0.593800f,
+		0.793100f,
+		0.243137f,
+		0.362998f,
+		-0.243138f,
+		0.000000f,
+		0.487500f,
+		0.724300f,
+		-0.487500f,
+		0.625000f,
+		0.758600f,
+		0.251591f,
+		0.398046f,
+		-0.168108f,
+		0.000000f,
+		0.504900f,
+		0.794500f,
+		-0.337400f,
+		0.593800f,
+		0.793100f,
+		0.285899f,
+		0.362998f,
+		-0.191032f,
+		0.000000f,
+		0.573300f,
+		0.724300f,
+		-0.383000f,
+		0.593800f,
+		0.758600f,
+		0.269464f,
+		-0.323693f,
+		-0.269464f,
+		0.000000f,
+		0.539900f,
+		-0.645700f,
+		-0.539900f,
+		0.625000f,
+		0.275900f,
+		0.292632f,
+		-0.280594f,
+		-0.292632f,
+		0.000000f,
+		0.586000f,
+		-0.559600f,
+		-0.586000f,
+		0.625000f,
+		0.310300f,
+		0.344099f,
+		-0.280594f,
+		-0.229919f,
+		0.000000f,
+		0.689100f,
+		-0.559600f,
+		-0.460400f,
+		0.593800f,
+		0.310300f,
+		0.269464f,
+		-0.323693f,
+		-0.269464f,
+		0.000000f,
+		0.539900f,
+		-0.645700f,
+		-0.539900f,
+		0.625000f,
+		0.275900f,
+		0.344099f,
+		-0.280594f,
+		-0.229919f,
+		0.000000f,
+		0.689100f,
+		-0.559600f,
+		-0.460400f,
+		0.593800f,
+		0.310300f,
+		0.316857f,
+		-0.323693f,
+		-0.211717f,
+		0.000000f,
+		0.634900f,
+		-0.645700f,
+		-0.424200f,
+		0.593800f,
+		0.275900f,
+		0.410257f,
+		-0.080891f,
+		-0.274125f,
+		0.000000f,
+		0.820600f,
+		-0.161200f,
+		-0.548300f,
+		0.593800f,
+		0.448300f,
+		0.415124f,
+		-0.027069f,
+		-0.277377f,
+		0.000000f,
+		0.830300f,
+		-0.054000f,
+		-0.554700f,
+		0.593800f,
+		0.482800f,
+		0.461262f,
+		-0.027069f,
+		-0.191061f,
+		0.000000f,
+		0.922500f,
+		-0.054000f,
+		-0.382100f,
+		0.562500f,
+		0.482800f,
+		0.410257f,
+		-0.080891f,
+		-0.274125f,
+		0.000000f,
+		0.820600f,
+		-0.161200f,
+		-0.548300f,
+		0.593800f,
+		0.448300f,
+		0.461262f,
+		-0.027069f,
+		-0.191061f,
+		0.000000f,
+		0.922500f,
+		-0.054000f,
+		-0.382100f,
+		0.562500f,
+		0.482800f,
+		0.455853f,
+		-0.080891f,
+		-0.188821f,
+		0.000000f,
+		0.911800f,
+		-0.161200f,
+		-0.377700f,
+		0.562500f,
+		0.448300f,
+		0.132744f,
+		0.473826f,
+		-0.088697f,
+		0.000000f,
+		0.268000f,
+		0.946600f,
+		-0.179100f,
+		0.593800f,
+		0.896600f,
+		0.089370f,
+		0.488310f,
+		-0.059715f,
+		0.000000f,
+		0.181400f,
+		0.975900f,
+		-0.121200f,
+		0.593800f,
+		0.931000f,
+		0.099303f,
+		0.488310f,
+		-0.041132f,
+		0.000000f,
+		0.201600f,
+		0.975900f,
+		-0.083500f,
+		0.562500f,
+		0.931000f,
+		0.132744f,
+		0.473826f,
+		-0.088697f,
+		0.000000f,
+		0.268000f,
+		0.946600f,
+		-0.179100f,
+		0.593800f,
+		0.896600f,
+		0.099303f,
+		0.488310f,
+		-0.041132f,
+		0.000000f,
+		0.201600f,
+		0.975900f,
+		-0.083500f,
+		0.562500f,
+		0.931000f,
+		0.147497f,
+		0.473826f,
+		-0.061095f,
+		0.000000f,
+		0.297800f,
+		0.946600f,
+		-0.123300f,
+		0.562500f,
+		0.896600f,
+		0.400580f,
+		-0.133764f,
+		-0.267659f,
+		0.000000f,
+		0.801400f,
+		-0.266600f,
+		-0.535400f,
+		0.593800f,
+		0.413800f,
+		0.410257f,
+		-0.080891f,
+		-0.274125f,
+		0.000000f,
+		0.820600f,
+		-0.161200f,
+		-0.548300f,
+		0.593800f,
+		0.448300f,
+		0.455853f,
+		-0.080891f,
+		-0.188821f,
+		0.000000f,
+		0.911800f,
+		-0.161200f,
+		-0.377700f,
+		0.562500f,
+		0.448300f,
+		0.400580f,
+		-0.133764f,
+		-0.267659f,
+		0.000000f,
+		0.801400f,
+		-0.266600f,
+		-0.535400f,
+		0.593800f,
+		0.413800f,
+		0.455853f,
+		-0.080891f,
+		-0.188821f,
+		0.000000f,
+		0.911800f,
+		-0.161200f,
+		-0.377700f,
+		0.562500f,
+		0.448300f,
+		0.445101f,
+		-0.133764f,
+		-0.184367f,
+		0.000000f,
+		0.890400f,
+		-0.266600f,
+		-0.368800f,
+		0.562500f,
+		0.413800f,
+		0.174562f,
+		0.453788f,
+		-0.116638f,
+		0.000000f,
+		0.351400f,
+		0.906300f,
+		-0.234800f,
+		0.593800f,
+		0.862100f,
+		0.132744f,
+		0.473826f,
+		-0.088697f,
+		0.000000f,
+		0.268000f,
+		0.946600f,
+		-0.179100f,
+		0.593800f,
+		0.896600f,
+		0.147497f,
+		0.473826f,
+		-0.061095f,
+		0.000000f,
+		0.297800f,
+		0.946600f,
+		-0.123300f,
+		0.562500f,
+		0.896600f,
+		0.174562f,
+		0.453788f,
+		-0.116638f,
+		0.000000f,
+		0.351400f,
+		0.906300f,
+		-0.234800f,
+		0.593800f,
+		0.862100f,
+		0.147497f,
+		0.473826f,
+		-0.061095f,
+		0.000000f,
+		0.297800f,
+		0.946600f,
+		-0.123300f,
+		0.562500f,
+		0.896600f,
+		0.193962f,
+		0.453788f,
+		-0.080342f,
+		0.000000f,
+		0.390500f,
+		0.906300f,
+		-0.161700f,
+		0.562500f,
+		0.862100f,
+		0.386207f,
+		-0.185069f,
+		-0.258056f,
+		0.000000f,
+		0.772800f,
+		-0.369000f,
+		-0.516300f,
+		0.593800f,
+		0.379300f,
+		0.400580f,
+		-0.133764f,
+		-0.267659f,
+		0.000000f,
+		0.801400f,
+		-0.266600f,
+		-0.535400f,
+		0.593800f,
+		0.413800f,
+		0.445101f,
+		-0.133764f,
+		-0.184367f,
+		0.000000f,
+		0.890400f,
+		-0.266600f,
+		-0.368800f,
+		0.562500f,
+		0.413800f,
+		0.386207f,
+		-0.185069f,
+		-0.258056f,
+		0.000000f,
+		0.772800f,
+		-0.369000f,
+		-0.516300f,
+		0.593800f,
+		0.379300f,
+		0.445101f,
+		-0.133764f,
+		-0.184367f,
+		0.000000f,
+		0.890400f,
+		-0.266600f,
+		-0.368800f,
+		0.562500f,
+		0.413800f,
+		0.429130f,
+		-0.185069f,
+		-0.177751f,
+		0.000000f,
+		0.858700f,
+		-0.369000f,
+		-0.355700f,
+		0.562500f,
+		0.379300f,
+		0.214333f,
+		0.428429f,
+		-0.143213f,
+		0.000000f,
+		0.430700f,
+		0.855300f,
+		-0.287800f,
+		0.593800f,
+		0.827600f,
+		0.174562f,
+		0.453788f,
+		-0.116638f,
+		0.000000f,
+		0.351400f,
+		0.906300f,
+		-0.234800f,
+		0.593800f,
+		0.862100f,
+		0.193962f,
+		0.453788f,
+		-0.080342f,
+		0.000000f,
+		0.390500f,
+		0.906300f,
+		-0.161700f,
+		0.562500f,
+		0.862100f,
+		0.214333f,
+		0.428429f,
+		-0.143213f,
+		0.000000f,
+		0.430700f,
+		0.855300f,
+		-0.287800f,
+		0.593800f,
+		0.827600f,
+		0.193962f,
+		0.453788f,
+		-0.080342f,
+		0.000000f,
+		0.390500f,
+		0.906300f,
+		-0.161700f,
+		0.562500f,
+		0.862100f,
+		0.238154f,
+		0.428429f,
+		-0.098647f,
+		0.000000f,
+		0.478600f,
+		0.855300f,
+		-0.198200f,
+		0.562500f,
+		0.827600f,
+		0.367306f,
+		-0.234204f,
+		-0.245426f,
+		0.000000f,
+		0.735200f,
+		-0.467000f,
+		-0.491300f,
+		0.593800f,
+		0.344800f,
+		0.386207f,
+		-0.185069f,
+		-0.258056f,
+		0.000000f,
+		0.772800f,
+		-0.369000f,
+		-0.516300f,
+		0.593800f,
+		0.379300f,
+		0.429130f,
+		-0.185069f,
+		-0.177751f,
+		0.000000f,
+		0.858700f,
+		-0.369000f,
+		-0.355700f,
+		0.562500f,
+		0.379300f,
+		0.367306f,
+		-0.234204f,
+		-0.245426f,
+		0.000000f,
+		0.735200f,
+		-0.467000f,
+		-0.491300f,
+		0.593800f,
+		0.344800f,
+		0.429130f,
+		-0.185069f,
+		-0.177751f,
+		0.000000f,
+		0.858700f,
+		-0.369000f,
+		-0.355700f,
+		0.562500f,
+		0.379300f,
+		0.408128f,
+		-0.234204f,
+		-0.169052f,
+		0.000000f,
+		0.816900f,
+		-0.467000f,
+		-0.338400f,
+		0.562500f,
+		0.344800f,
+		0.251591f,
+		0.398046f,
+		-0.168108f,
+		0.000000f,
+		0.504900f,
+		0.794500f,
+		-0.337400f,
+		0.593800f,
+		0.793100f,
+		0.214333f,
+		0.428429f,
+		-0.143213f,
+		0.000000f,
+		0.430700f,
+		0.855300f,
+		-0.287800f,
+		0.593800f,
+		0.827600f,
+		0.238154f,
+		0.428429f,
+		-0.098647f,
+		0.000000f,
+		0.478600f,
+		0.855300f,
+		-0.198200f,
+		0.562500f,
+		0.827600f,
+		0.251591f,
+		0.398046f,
+		-0.168108f,
+		0.000000f,
+		0.504900f,
+		0.794500f,
+		-0.337400f,
+		0.593800f,
+		0.793100f,
+		0.238154f,
+		0.428429f,
+		-0.098647f,
+		0.000000f,
+		0.478600f,
+		0.855300f,
+		-0.198200f,
+		0.562500f,
+		0.827600f,
+		0.279553f,
+		0.398046f,
+		-0.115795f,
+		0.000000f,
+		0.561100f,
+		0.794500f,
+		-0.232400f,
+		0.562500f,
+		0.793100f,
+		0.344099f,
+		-0.280594f,
+		-0.229919f,
+		0.000000f,
+		0.689100f,
+		-0.559600f,
+		-0.460400f,
+		0.593800f,
+		0.310300f,
+		0.367306f,
+		-0.234204f,
+		-0.245426f,
+		0.000000f,
+		0.735200f,
+		-0.467000f,
+		-0.491300f,
+		0.593800f,
+		0.344800f,
+		0.408128f,
+		-0.234204f,
+		-0.169052f,
+		0.000000f,
+		0.816900f,
+		-0.467000f,
+		-0.338400f,
+		0.562500f,
+		0.344800f,
+		0.344099f,
+		-0.280594f,
+		-0.229919f,
+		0.000000f,
+		0.689100f,
+		-0.559600f,
+		-0.460400f,
+		0.593800f,
+		0.310300f,
+		0.408128f,
+		-0.234204f,
+		-0.169052f,
+		0.000000f,
+		0.816900f,
+		-0.467000f,
+		-0.338400f,
+		0.562500f,
+		0.344800f,
+		0.382342f,
+		-0.280594f,
+		-0.158371f,
+		0.000000f,
+		0.765600f,
+		-0.559600f,
+		-0.317100f,
+		0.562500f,
+		0.310300f,
+		0.285899f,
+		0.362998f,
+		-0.191032f,
+		0.000000f,
+		0.573300f,
+		0.724300f,
+		-0.383000f,
+		0.593800f,
+		0.758600f,
+		0.251591f,
+		0.398046f,
+		-0.168108f,
+		0.000000f,
+		0.504900f,
+		0.794500f,
+		-0.337400f,
+		0.593800f,
+		0.793100f,
+		0.279553f,
+		0.398046f,
+		-0.115795f,
+		0.000000f,
+		0.561100f,
+		0.794500f,
+		-0.232400f,
+		0.562500f,
+		0.793100f,
+		0.285899f,
+		0.362998f,
+		-0.191032f,
+		0.000000f,
+		0.573300f,
+		0.724300f,
+		-0.383000f,
+		0.593800f,
+		0.758600f,
+		0.279553f,
+		0.398046f,
+		-0.115795f,
+		0.000000f,
+		0.561100f,
+		0.794500f,
+		-0.232400f,
+		0.562500f,
+		0.793100f,
+		0.317674f,
+		0.362998f,
+		-0.131585f,
+		0.000000f,
+		0.637000f,
+		0.724300f,
+		-0.263800f,
+		0.562500f,
+		0.758600f,
+		0.316857f,
+		-0.323693f,
+		-0.211717f,
+		0.000000f,
+		0.634900f,
+		-0.645700f,
+		-0.424200f,
+		0.593800f,
+		0.275900f,
+		0.344099f,
+		-0.280594f,
+		-0.229919f,
+		0.000000f,
+		0.689100f,
+		-0.559600f,
+		-0.460400f,
+		0.593800f,
+		0.310300f,
+		0.382342f,
+		-0.280594f,
+		-0.158371f,
+		0.000000f,
+		0.765600f,
+		-0.559600f,
+		-0.317100f,
+		0.562500f,
+		0.310300f,
+		0.316857f,
+		-0.323693f,
+		-0.211717f,
+		0.000000f,
+		0.634900f,
+		-0.645700f,
+		-0.424200f,
+		0.593800f,
+		0.275900f,
+		0.382342f,
+		-0.280594f,
+		-0.158371f,
+		0.000000f,
+		0.765600f,
+		-0.559600f,
+		-0.317100f,
+		0.562500f,
+		0.310300f,
+		0.352072f,
+		-0.323693f,
+		-0.145833f,
+		0.000000f,
+		0.705400f,
+		-0.645700f,
+		-0.292200f,
+		0.562500f,
+		0.275900f,
+		0.316857f,
+		0.323693f,
+		-0.211717f,
+		0.000000f,
+		0.634900f,
+		0.645700f,
+		-0.424200f,
+		0.593800f,
+		0.724100f,
+		0.285899f,
+		0.362998f,
+		-0.191032f,
+		0.000000f,
+		0.573300f,
+		0.724300f,
+		-0.383000f,
+		0.593800f,
+		0.758600f,
+		0.317674f,
+		0.362998f,
+		-0.131585f,
+		0.000000f,
+		0.637000f,
+		0.724300f,
+		-0.263800f,
+		0.562500f,
+		0.758600f,
+		0.316857f,
+		0.323693f,
+		-0.211717f,
+		0.000000f,
+		0.634900f,
+		0.645700f,
+		-0.424200f,
+		0.593800f,
+		0.724100f,
+		0.317674f,
+		0.362998f,
+		-0.131585f,
+		0.000000f,
+		0.637000f,
+		0.724300f,
+		-0.263800f,
+		0.562500f,
+		0.758600f,
+		0.352072f,
+		0.323693f,
+		-0.145833f,
+		0.000000f,
+		0.705400f,
+		0.645700f,
+		-0.292200f,
+		0.562500f,
+		0.724100f,
+		0.285900f,
+		-0.362998f,
+		-0.191032f,
+		0.000000f,
+		0.573300f,
+		-0.724300f,
+		-0.383000f,
+		0.593800f,
+		0.241400f,
+		0.316857f,
+		-0.323693f,
+		-0.211717f,
+		0.000000f,
+		0.634900f,
+		-0.645700f,
+		-0.424200f,
+		0.593800f,
+		0.275900f,
+		0.352072f,
+		-0.323693f,
+		-0.145833f,
+		0.000000f,
+		0.705400f,
+		-0.645700f,
+		-0.292200f,
+		0.562500f,
+		0.275900f,
+		0.285900f,
+		-0.362998f,
+		-0.191032f,
+		0.000000f,
+		0.573300f,
+		-0.724300f,
+		-0.383000f,
+		0.593800f,
+		0.241400f,
+		0.352072f,
+		-0.323693f,
+		-0.145833f,
+		0.000000f,
+		0.705400f,
+		-0.645700f,
+		-0.292200f,
+		0.562500f,
+		0.275900f,
+		0.317675f,
+		-0.362998f,
+		-0.131585f,
+		0.000000f,
+		0.637000f,
+		-0.724300f,
+		-0.263800f,
+		0.562500f,
+		0.241400f,
+		0.344098f,
+		0.280594f,
+		-0.229919f,
+		0.000000f,
+		0.689100f,
+		0.559600f,
+		-0.460400f,
+		0.593800f,
+		0.689700f,
+		0.316857f,
+		0.323693f,
+		-0.211717f,
+		0.000000f,
+		0.634900f,
+		0.645700f,
+		-0.424200f,
+		0.593800f,
+		0.724100f,
+		0.352072f,
+		0.323693f,
+		-0.145833f,
+		0.000000f,
+		0.705400f,
+		0.645700f,
+		-0.292200f,
+		0.562500f,
+		0.724100f,
+		0.344098f,
+		0.280594f,
+		-0.229919f,
+		0.000000f,
+		0.689100f,
+		0.559600f,
+		-0.460400f,
+		0.593800f,
+		0.689700f,
+		0.352072f,
+		0.323693f,
+		-0.145833f,
+		0.000000f,
+		0.705400f,
+		0.645700f,
+		-0.292200f,
+		0.562500f,
+		0.724100f,
+		0.382342f,
+		0.280594f,
+		-0.158371f,
+		0.000000f,
+		0.765600f,
+		0.559600f,
+		-0.317100f,
+		0.562500f,
+		0.689700f,
+		0.251591f,
+		-0.398046f,
+		-0.168108f,
+		0.000000f,
+		0.505000f,
+		-0.794500f,
+		-0.337400f,
+		0.593800f,
+		0.206900f,
+		0.285900f,
+		-0.362998f,
+		-0.191032f,
+		0.000000f,
+		0.573300f,
+		-0.724300f,
+		-0.383000f,
+		0.593800f,
+		0.241400f,
+		0.317675f,
+		-0.362998f,
+		-0.131585f,
+		0.000000f,
+		0.637000f,
+		-0.724300f,
+		-0.263800f,
+		0.562500f,
+		0.241400f,
+		0.251591f,
+		-0.398046f,
+		-0.168108f,
+		0.000000f,
+		0.505000f,
+		-0.794500f,
+		-0.337400f,
+		0.593800f,
+		0.206900f,
+		0.317675f,
+		-0.362998f,
+		-0.131585f,
+		0.000000f,
+		0.637000f,
+		-0.724300f,
+		-0.263800f,
+		0.562500f,
+		0.241400f,
+		0.279553f,
+		-0.398046f,
+		-0.115795f,
+		0.000000f,
+		0.561100f,
+		-0.794500f,
+		-0.232400f,
+		0.562500f,
+		0.206900f,
+		0.367306f,
+		0.234204f,
+		-0.245426f,
+		0.000000f,
+		0.735200f,
+		0.467000f,
+		-0.491300f,
+		0.593800f,
+		0.655200f,
+		0.344098f,
+		0.280594f,
+		-0.229919f,
+		0.000000f,
+		0.689100f,
+		0.559600f,
+		-0.460400f,
+		0.593800f,
+		0.689700f,
+		0.382342f,
+		0.280594f,
+		-0.158371f,
+		0.000000f,
+		0.765600f,
+		0.559600f,
+		-0.317100f,
+		0.562500f,
+		0.689700f,
+		0.367306f,
+		0.234204f,
+		-0.245426f,
+		0.000000f,
+		0.735200f,
+		0.467000f,
+		-0.491300f,
+		0.593800f,
+		0.655200f,
+		0.382342f,
+		0.280594f,
+		-0.158371f,
+		0.000000f,
+		0.765600f,
+		0.559600f,
+		-0.317100f,
+		0.562500f,
+		0.689700f,
+		0.408128f,
+		0.234204f,
+		-0.169052f,
+		0.000000f,
+		0.816900f,
+		0.467000f,
+		-0.338400f,
+		0.562500f,
+		0.655200f,
+		0.214333f,
+		-0.428429f,
+		-0.143213f,
+		0.000000f,
+		0.430700f,
+		-0.855300f,
+		-0.287800f,
+		0.593800f,
+		0.172400f,
+		0.251591f,
+		-0.398046f,
+		-0.168108f,
+		0.000000f,
+		0.505000f,
+		-0.794500f,
+		-0.337400f,
+		0.593800f,
+		0.206900f,
+		0.279553f,
+		-0.398046f,
+		-0.115795f,
+		0.000000f,
+		0.561100f,
+		-0.794500f,
+		-0.232400f,
+		0.562500f,
+		0.206900f,
+		0.214333f,
+		-0.428429f,
+		-0.143213f,
+		0.000000f,
+		0.430700f,
+		-0.855300f,
+		-0.287800f,
+		0.593800f,
+		0.172400f,
+		0.279553f,
+		-0.398046f,
+		-0.115795f,
+		0.000000f,
+		0.561100f,
+		-0.794500f,
+		-0.232400f,
+		0.562500f,
+		0.206900f,
+		0.238154f,
+		-0.428429f,
+		-0.098647f,
+		0.000000f,
+		0.478600f,
+		-0.855300f,
+		-0.198200f,
+		0.562500f,
+		0.172400f,
+		0.386207f,
+		0.185069f,
+		-0.258056f,
+		0.000000f,
+		0.772800f,
+		0.369000f,
+		-0.516300f,
+		0.593800f,
+		0.620700f,
+		0.367306f,
+		0.234204f,
+		-0.245426f,
+		0.000000f,
+		0.735200f,
+		0.467000f,
+		-0.491300f,
+		0.593800f,
+		0.655200f,
+		0.408128f,
+		0.234204f,
+		-0.169052f,
+		0.000000f,
+		0.816900f,
+		0.467000f,
+		-0.338400f,
+		0.562500f,
+		0.655200f,
+		0.386207f,
+		0.185069f,
+		-0.258056f,
+		0.000000f,
+		0.772800f,
+		0.369000f,
+		-0.516300f,
+		0.593800f,
+		0.620700f,
+		0.408128f,
+		0.234204f,
+		-0.169052f,
+		0.000000f,
+		0.816900f,
+		0.467000f,
+		-0.338400f,
+		0.562500f,
+		0.655200f,
+		0.429130f,
+		0.185069f,
+		-0.177751f,
+		0.000000f,
+		0.858700f,
+		0.369000f,
+		-0.355700f,
+		0.562500f,
+		0.620700f,
+		0.174562f,
+		-0.453788f,
+		-0.116639f,
+		0.000000f,
+		0.351400f,
+		-0.906300f,
+		-0.234800f,
+		0.593800f,
+		0.137900f,
+		0.214333f,
+		-0.428429f,
+		-0.143213f,
+		0.000000f,
+		0.430700f,
+		-0.855300f,
+		-0.287800f,
+		0.593800f,
+		0.172400f,
+		0.238154f,
+		-0.428429f,
+		-0.098647f,
+		0.000000f,
+		0.478600f,
+		-0.855300f,
+		-0.198200f,
+		0.562500f,
+		0.172400f,
+		0.174562f,
+		-0.453788f,
+		-0.116639f,
+		0.000000f,
+		0.351400f,
+		-0.906300f,
+		-0.234800f,
+		0.593800f,
+		0.137900f,
+		0.238154f,
+		-0.428429f,
+		-0.098647f,
+		0.000000f,
+		0.478600f,
+		-0.855300f,
+		-0.198200f,
+		0.562500f,
+		0.172400f,
+		0.193963f,
+		-0.453788f,
+		-0.080342f,
+		0.000000f,
+		0.390500f,
+		-0.906300f,
+		-0.161700f,
+		0.562500f,
+		0.137900f,
+		0.400580f,
+		0.133764f,
+		-0.267659f,
+		0.000000f,
+		0.801400f,
+		0.266600f,
+		-0.535400f,
+		0.593800f,
+		0.586200f,
+		0.386207f,
+		0.185069f,
+		-0.258056f,
+		0.000000f,
+		0.772800f,
+		0.369000f,
+		-0.516300f,
+		0.593800f,
+		0.620700f,
+		0.429130f,
+		0.185069f,
+		-0.177751f,
+		0.000000f,
+		0.858700f,
+		0.369000f,
+		-0.355700f,
+		0.562500f,
+		0.620700f,
+		0.400580f,
+		0.133764f,
+		-0.267659f,
+		0.000000f,
+		0.801400f,
+		0.266600f,
+		-0.535400f,
+		0.593800f,
+		0.586200f,
+		0.429130f,
+		0.185069f,
+		-0.177751f,
+		0.000000f,
+		0.858700f,
+		0.369000f,
+		-0.355700f,
+		0.562500f,
+		0.620700f,
+		0.445101f,
+		0.133764f,
+		-0.184367f,
+		0.000000f,
+		0.890400f,
+		0.266600f,
+		-0.368800f,
+		0.562500f,
+		0.586200f,
+		0.132744f,
+		-0.473826f,
+		-0.088697f,
+		0.000000f,
+		0.268000f,
+		-0.946600f,
+		-0.179100f,
+		0.593800f,
+		0.103400f,
+		0.174562f,
+		-0.453788f,
+		-0.116639f,
+		0.000000f,
+		0.351400f,
+		-0.906300f,
+		-0.234800f,
+		0.593800f,
+		0.137900f,
+		0.193963f,
+		-0.453788f,
+		-0.080342f,
+		0.000000f,
+		0.390500f,
+		-0.906300f,
+		-0.161700f,
+		0.562500f,
+		0.137900f,
+		0.132744f,
+		-0.473826f,
+		-0.088697f,
+		0.000000f,
+		0.268000f,
+		-0.946600f,
+		-0.179100f,
+		0.593800f,
+		0.103400f,
+		0.193963f,
+		-0.453788f,
+		-0.080342f,
+		0.000000f,
+		0.390500f,
+		-0.906300f,
+		-0.161700f,
+		0.562500f,
+		0.137900f,
+		0.147498f,
+		-0.473826f,
+		-0.061095f,
+		0.000000f,
+		0.297800f,
+		-0.946600f,
+		-0.123300f,
+		0.562500f,
+		0.103400f,
+		0.410257f,
+		0.080891f,
+		-0.274125f,
+		0.000000f,
+		0.820600f,
+		0.161200f,
+		-0.548300f,
+		0.593800f,
+		0.551700f,
+		0.400580f,
+		0.133764f,
+		-0.267659f,
+		0.000000f,
+		0.801400f,
+		0.266600f,
+		-0.535400f,
+		0.593800f,
+		0.586200f,
+		0.445101f,
+		0.133764f,
+		-0.184367f,
+		0.000000f,
+		0.890400f,
+		0.266600f,
+		-0.368800f,
+		0.562500f,
+		0.586200f,
+		0.410257f,
+		0.080891f,
+		-0.274125f,
+		0.000000f,
+		0.820600f,
+		0.161200f,
+		-0.548300f,
+		0.593800f,
+		0.551700f,
+		0.445101f,
+		0.133764f,
+		-0.184367f,
+		0.000000f,
+		0.890400f,
+		0.266600f,
+		-0.368800f,
+		0.562500f,
+		0.586200f,
+		0.455853f,
+		0.080891f,
+		-0.188821f,
+		0.000000f,
+		0.911800f,
+		0.161200f,
+		-0.377700f,
+		0.562500f,
+		0.551700f,
+		0.089370f,
+		-0.488310f,
+		-0.059715f,
+		0.000000f,
+		0.181400f,
+		-0.975900f,
+		-0.121200f,
+		0.593800f,
+		0.069000f,
+		0.132744f,
+		-0.473826f,
+		-0.088697f,
+		0.000000f,
+		0.268000f,
+		-0.946600f,
+		-0.179100f,
+		0.593800f,
+		0.103400f,
+		0.147498f,
+		-0.473826f,
+		-0.061095f,
+		0.000000f,
+		0.297800f,
+		-0.946600f,
+		-0.123300f,
+		0.562500f,
+		0.103400f,
+		0.089370f,
+		-0.488310f,
+		-0.059715f,
+		0.000000f,
+		0.181400f,
+		-0.975900f,
+		-0.121200f,
+		0.593800f,
+		0.069000f,
+		0.147498f,
+		-0.473826f,
+		-0.061095f,
+		0.000000f,
+		0.297800f,
+		-0.946600f,
+		-0.123300f,
+		0.562500f,
+		0.103400f,
+		0.099303f,
+		-0.488310f,
+		-0.041133f,
+		0.000000f,
+		0.201600f,
+		-0.975900f,
+		-0.083500f,
+		0.562500f,
+		0.069000f,
+		0.415124f,
+		0.027069f,
+		-0.277377f,
+		0.000000f,
+		0.830300f,
+		0.054000f,
+		-0.554700f,
+		0.593800f,
+		0.517200f,
+		0.410257f,
+		0.080891f,
+		-0.274125f,
+		0.000000f,
+		0.820600f,
+		0.161200f,
+		-0.548300f,
+		0.593800f,
+		0.551700f,
+		0.455853f,
+		0.080891f,
+		-0.188821f,
+		0.000000f,
+		0.911800f,
+		0.161200f,
+		-0.377700f,
+		0.562500f,
+		0.551700f,
+		0.415124f,
+		0.027069f,
+		-0.277377f,
+		0.000000f,
+		0.830300f,
+		0.054000f,
+		-0.554700f,
+		0.593800f,
+		0.517200f,
+		0.455853f,
+		0.080891f,
+		-0.188821f,
+		0.000000f,
+		0.911800f,
+		0.161200f,
+		-0.377700f,
+		0.562500f,
+		0.551700f,
+		0.461262f,
+		0.027069f,
+		-0.191061f,
+		0.000000f,
+		0.922500f,
+		0.054000f,
+		-0.382100f,
+		0.562500f,
+		0.517200f,
+		0.044948f,
+		0.497069f,
+		-0.030034f,
+		0.000000f,
+		0.092700f,
+		0.993700f,
+		-0.061900f,
+		0.450800f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.423900f,
+		0.960300f,
+		0.049943f,
+		0.497069f,
+		-0.020688f,
+		0.000000f,
+		0.103000f,
+		0.993700f,
+		-0.042600f,
+		0.452600f,
+		0.962300f,
+		0.044948f,
+		-0.497069f,
+		-0.030034f,
+		0.000000f,
+		0.092700f,
+		-0.993700f,
+		-0.061900f,
+		0.593800f,
+		0.034500f,
+		0.089370f,
+		-0.488310f,
+		-0.059715f,
+		0.000000f,
+		0.181400f,
+		-0.975900f,
+		-0.121200f,
+		0.593800f,
+		0.069000f,
+		0.099303f,
+		-0.488310f,
+		-0.041133f,
+		0.000000f,
+		0.201600f,
+		-0.975900f,
+		-0.083500f,
+		0.562500f,
+		0.069000f,
+		0.044948f,
+		-0.497069f,
+		-0.030034f,
+		0.000000f,
+		0.092700f,
+		-0.993700f,
+		-0.061900f,
+		0.593800f,
+		0.034500f,
+		0.099303f,
+		-0.488310f,
+		-0.041133f,
+		0.000000f,
+		0.201600f,
+		-0.975900f,
+		-0.083500f,
+		0.562500f,
+		0.069000f,
+		0.049944f,
+		-0.497069f,
+		-0.020688f,
+		0.000000f,
+		0.103000f,
+		-0.993700f,
+		-0.042600f,
+		0.562500f,
+		0.034500f,
+		0.415124f,
+		-0.027069f,
+		-0.277377f,
+		0.000000f,
+		0.830300f,
+		-0.054000f,
+		-0.554700f,
+		0.593800f,
+		0.482800f,
+		0.415124f,
+		0.027069f,
+		-0.277377f,
+		0.000000f,
+		0.830300f,
+		0.054000f,
+		-0.554700f,
+		0.593800f,
+		0.517200f,
+		0.461262f,
+		0.027069f,
+		-0.191061f,
+		0.000000f,
+		0.922500f,
+		0.054000f,
+		-0.382100f,
+		0.562500f,
+		0.517200f,
+		0.415124f,
+		-0.027069f,
+		-0.277377f,
+		0.000000f,
+		0.830300f,
+		-0.054000f,
+		-0.554700f,
+		0.593800f,
+		0.482800f,
+		0.461262f,
+		0.027069f,
+		-0.191061f,
+		0.000000f,
+		0.922500f,
+		0.054000f,
+		-0.382100f,
+		0.562500f,
+		0.517200f,
+		0.461262f,
+		-0.027069f,
+		-0.191061f,
+		0.000000f,
+		0.922500f,
+		-0.054000f,
+		-0.382100f,
+		0.562500f,
+		0.482800f,
+		0.089370f,
+		0.488310f,
+		-0.059715f,
+		0.000000f,
+		0.181400f,
+		0.975900f,
+		-0.121200f,
+		0.593800f,
+		0.931000f,
+		0.044948f,
+		0.497069f,
+		-0.030034f,
+		0.000000f,
+		0.092700f,
+		0.993700f,
+		-0.061900f,
+		0.593800f,
+		0.965500f,
+		0.049943f,
+		0.497069f,
+		-0.020688f,
+		0.000000f,
+		0.103000f,
+		0.993700f,
+		-0.042600f,
+		0.562500f,
+		0.965500f,
+		0.089370f,
+		0.488310f,
+		-0.059715f,
+		0.000000f,
+		0.181400f,
+		0.975900f,
+		-0.121200f,
+		0.593800f,
+		0.931000f,
+		0.049943f,
+		0.497069f,
+		-0.020688f,
+		0.000000f,
+		0.103000f,
+		0.993700f,
+		-0.042600f,
+		0.562500f,
+		0.965500f,
+		0.099303f,
+		0.488310f,
+		-0.041132f,
+		0.000000f,
+		0.201600f,
+		0.975900f,
+		-0.083500f,
+		0.562500f,
+		0.931000f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.495500f,
+		0.051000f,
+		0.044948f,
+		-0.497069f,
+		-0.030034f,
+		0.000000f,
+		0.092700f,
+		-0.993700f,
+		-0.061900f,
+		0.460200f,
+		0.053800f,
+		0.049944f,
+		-0.497069f,
+		-0.020688f,
+		0.000000f,
+		0.103000f,
+		-0.993700f,
+		-0.042600f,
+		0.457500f,
+		0.053800f,
+		0.238154f,
+		-0.428429f,
+		-0.098647f,
+		0.000000f,
+		0.478600f,
+		-0.855300f,
+		-0.198200f,
+		0.562500f,
+		0.172400f,
+		0.279553f,
+		-0.398046f,
+		-0.115795f,
+		0.000000f,
+		0.561100f,
+		-0.794500f,
+		-0.232400f,
+		0.562500f,
+		0.206900f,
+		0.296772f,
+		-0.398046f,
+		-0.059032f,
+		0.000000f,
+		0.595600f,
+		-0.794500f,
+		-0.118500f,
+		0.531200f,
+		0.206900f,
+		0.238154f,
+		-0.428429f,
+		-0.098647f,
+		0.000000f,
+		0.478600f,
+		-0.855300f,
+		-0.198200f,
+		0.562500f,
+		0.172400f,
+		0.296772f,
+		-0.398046f,
+		-0.059032f,
+		0.000000f,
+		0.595600f,
+		-0.794500f,
+		-0.118500f,
+		0.531200f,
+		0.206900f,
+		0.252823f,
+		-0.428429f,
+		-0.050290f,
+		0.000000f,
+		0.508100f,
+		-0.855300f,
+		-0.101000f,
+		0.531200f,
+		0.172400f,
+		0.429130f,
+		0.185069f,
+		-0.177751f,
+		0.000000f,
+		0.858700f,
+		0.369000f,
+		-0.355700f,
+		0.562500f,
+		0.620700f,
+		0.408128f,
+		0.234204f,
+		-0.169052f,
+		0.000000f,
+		0.816900f,
+		0.467000f,
+		-0.338400f,
+		0.562500f,
+		0.655200f,
+		0.433267f,
+		0.234204f,
+		-0.086182f,
+		0.000000f,
+		0.867200f,
+		0.467000f,
+		-0.172500f,
+		0.531200f,
+		0.655200f,
+		0.429130f,
+		0.185069f,
+		-0.177751f,
+		0.000000f,
+		0.858700f,
+		0.369000f,
+		-0.355700f,
+		0.562500f,
+		0.620700f,
+		0.433267f,
+		0.234204f,
+		-0.086182f,
+		0.000000f,
+		0.867200f,
+		0.467000f,
+		-0.172500f,
+		0.531200f,
+		0.655200f,
+		0.455563f,
+		0.185069f,
+		-0.090617f,
+		0.000000f,
+		0.911600f,
+		0.369000f,
+		-0.181300f,
+		0.531200f,
+		0.620700f,
+		0.193963f,
+		-0.453788f,
+		-0.080342f,
+		0.000000f,
+		0.390500f,
+		-0.906300f,
+		-0.161700f,
+		0.562500f,
+		0.137900f,
+		0.238154f,
+		-0.428429f,
+		-0.098647f,
+		0.000000f,
+		0.478600f,
+		-0.855300f,
+		-0.198200f,
+		0.562500f,
+		0.172400f,
+		0.252823f,
+		-0.428429f,
+		-0.050290f,
+		0.000000f,
+		0.508100f,
+		-0.855300f,
+		-0.101000f,
+		0.531200f,
+		0.172400f,
+		0.193963f,
+		-0.453788f,
+		-0.080342f,
+		0.000000f,
+		0.390500f,
+		-0.906300f,
+		-0.161700f,
+		0.562500f,
+		0.137900f,
+		0.252823f,
+		-0.428429f,
+		-0.050290f,
+		0.000000f,
+		0.508100f,
+		-0.855300f,
+		-0.101000f,
+		0.531200f,
+		0.172400f,
+		0.205910f,
+		-0.453788f,
+		-0.040958f,
+		0.000000f,
+		0.414500f,
+		-0.906300f,
+		-0.082400f,
+		0.531200f,
+		0.137900f,
+		0.445101f,
+		0.133764f,
+		-0.184367f,
+		0.000000f,
+		0.890400f,
+		0.266600f,
+		-0.368800f,
+		0.562500f,
+		0.586200f,
+		0.429130f,
+		0.185069f,
+		-0.177751f,
+		0.000000f,
+		0.858700f,
+		0.369000f,
+		-0.355700f,
+		0.562500f,
+		0.620700f,
+		0.455563f,
+		0.185069f,
+		-0.090617f,
+		0.000000f,
+		0.911600f,
+		0.369000f,
+		-0.181300f,
+		0.531200f,
+		0.620700f,
+		0.445101f,
+		0.133764f,
+		-0.184367f,
+		0.000000f,
+		0.890400f,
+		0.266600f,
+		-0.368800f,
+		0.562500f,
+		0.586200f,
+		0.455563f,
+		0.185069f,
+		-0.090617f,
+		0.000000f,
+		0.911600f,
+		0.369000f,
+		-0.181300f,
+		0.531200f,
+		0.620700f,
+		0.472517f,
+		0.133764f,
+		-0.093989f,
+		0.000000f,
+		0.945200f,
+		0.266600f,
+		-0.188000f,
+		0.531200f,
+		0.586200f,
+		0.147498f,
+		-0.473826f,
+		-0.061095f,
+		0.000000f,
+		0.297800f,
+		-0.946600f,
+		-0.123300f,
+		0.562500f,
+		0.103400f,
+		0.193963f,
+		-0.453788f,
+		-0.080342f,
+		0.000000f,
+		0.390500f,
+		-0.906300f,
+		-0.161700f,
+		0.562500f,
+		0.137900f,
+		0.205910f,
+		-0.453788f,
+		-0.040958f,
+		0.000000f,
+		0.414500f,
+		-0.906300f,
+		-0.082400f,
+		0.531200f,
+		0.137900f,
+		0.147498f,
+		-0.473826f,
+		-0.061095f,
+		0.000000f,
+		0.297800f,
+		-0.946600f,
+		-0.123300f,
+		0.562500f,
+		0.103400f,
+		0.205910f,
+		-0.453788f,
+		-0.040958f,
+		0.000000f,
+		0.414500f,
+		-0.906300f,
+		-0.082400f,
+		0.531200f,
+		0.137900f,
+		0.156583f,
+		-0.473826f,
+		-0.031147f,
+		0.000000f,
+		0.316100f,
+		-0.946600f,
+		-0.062900f,
+		0.531300f,
+		0.103400f,
+		0.455853f,
+		0.080891f,
+		-0.188821f,
+		0.000000f,
+		0.911800f,
+		0.161200f,
+		-0.377700f,
+		0.562500f,
+		0.551700f,
+		0.445101f,
+		0.133764f,
+		-0.184367f,
+		0.000000f,
+		0.890400f,
+		0.266600f,
+		-0.368800f,
+		0.562500f,
+		0.586200f,
+		0.472517f,
+		0.133764f,
+		-0.093989f,
+		0.000000f,
+		0.945200f,
+		0.266600f,
+		-0.188000f,
+		0.531200f,
+		0.586200f,
+		0.455853f,
+		0.080891f,
+		-0.188821f,
+		0.000000f,
+		0.911800f,
+		0.161200f,
+		-0.377700f,
+		0.562500f,
+		0.551700f,
+		0.472517f,
+		0.133764f,
+		-0.093989f,
+		0.000000f,
+		0.945200f,
+		0.266600f,
+		-0.188000f,
+		0.531200f,
+		0.586200f,
+		0.483932f,
+		0.080891f,
+		-0.096260f,
+		0.000000f,
+		0.967900f,
+		0.161200f,
+		-0.192500f,
+		0.531200f,
+		0.551700f,
+		0.099303f,
+		-0.488310f,
+		-0.041133f,
+		0.000000f,
+		0.201600f,
+		-0.975900f,
+		-0.083500f,
+		0.562500f,
+		0.069000f,
+		0.147498f,
+		-0.473826f,
+		-0.061095f,
+		0.000000f,
+		0.297800f,
+		-0.946600f,
+		-0.123300f,
+		0.562500f,
+		0.103400f,
+		0.156583f,
+		-0.473826f,
+		-0.031147f,
+		0.000000f,
+		0.316100f,
+		-0.946600f,
+		-0.062900f,
+		0.531300f,
+		0.103400f,
+		0.099303f,
+		-0.488310f,
+		-0.041133f,
+		0.000000f,
+		0.201600f,
+		-0.975900f,
+		-0.083500f,
+		0.562500f,
+		0.069000f,
+		0.156583f,
+		-0.473826f,
+		-0.031147f,
+		0.000000f,
+		0.316100f,
+		-0.946600f,
+		-0.062900f,
+		0.531300f,
+		0.103400f,
+		0.105420f,
+		-0.488310f,
+		-0.020970f,
+		0.000000f,
+		0.214000f,
+		-0.975900f,
+		-0.042500f,
+		0.531300f,
+		0.069000f,
+		0.461262f,
+		0.027069f,
+		-0.191061f,
+		0.000000f,
+		0.922500f,
+		0.054000f,
+		-0.382100f,
+		0.562500f,
+		0.517200f,
+		0.455853f,
+		0.080891f,
+		-0.188821f,
+		0.000000f,
+		0.911800f,
+		0.161200f,
+		-0.377700f,
+		0.562500f,
+		0.551700f,
+		0.483932f,
+		0.080891f,
+		-0.096260f,
+		0.000000f,
+		0.967900f,
+		0.161200f,
+		-0.192500f,
+		0.531200f,
+		0.551700f,
+		0.461262f,
+		0.027069f,
+		-0.191061f,
+		0.000000f,
+		0.922500f,
+		0.054000f,
+		-0.382100f,
+		0.562500f,
+		0.517200f,
+		0.483932f,
+		0.080891f,
+		-0.096260f,
+		0.000000f,
+		0.967900f,
+		0.161200f,
+		-0.192500f,
+		0.531200f,
+		0.551700f,
+		0.489673f,
+		0.027069f,
+		-0.097402f,
+		0.000000f,
+		0.979300f,
+		0.054000f,
+		-0.194800f,
+		0.531200f,
+		0.517200f,
+		0.049943f,
+		0.497069f,
+		-0.020688f,
+		0.000000f,
+		0.103000f,
+		0.993700f,
+		-0.042600f,
+		0.452600f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.423900f,
+		0.960300f,
+		0.053020f,
+		0.497069f,
+		-0.010546f,
+		0.000000f,
+		0.109300f,
+		0.993700f,
+		-0.021700f,
+		0.454400f,
+		0.962300f,
+		0.049944f,
+		-0.497069f,
+		-0.020688f,
+		0.000000f,
+		0.103000f,
+		-0.993700f,
+		-0.042600f,
+		0.562500f,
+		0.034500f,
+		0.099303f,
+		-0.488310f,
+		-0.041133f,
+		0.000000f,
+		0.201600f,
+		-0.975900f,
+		-0.083500f,
+		0.562500f,
+		0.069000f,
+		0.105420f,
+		-0.488310f,
+		-0.020970f,
+		0.000000f,
+		0.214000f,
+		-0.975900f,
+		-0.042500f,
+		0.531300f,
+		0.069000f,
+		0.049944f,
+		-0.497069f,
+		-0.020688f,
+		0.000000f,
+		0.103000f,
+		-0.993700f,
+		-0.042600f,
+		0.562500f,
+		0.034500f,
+		0.105420f,
+		-0.488310f,
+		-0.020970f,
+		0.000000f,
+		0.214000f,
+		-0.975900f,
+		-0.042500f,
+		0.531300f,
+		0.069000f,
+		0.053020f,
+		-0.497069f,
+		-0.010546f,
+		0.000000f,
+		0.109300f,
+		-0.993700f,
+		-0.021700f,
+		0.531300f,
+		0.034500f,
+		0.461262f,
+		-0.027069f,
+		-0.191061f,
+		0.000000f,
+		0.922500f,
+		-0.054000f,
+		-0.382100f,
+		0.562500f,
+		0.482800f,
+		0.461262f,
+		0.027069f,
+		-0.191061f,
+		0.000000f,
+		0.922500f,
+		0.054000f,
+		-0.382100f,
+		0.562500f,
+		0.517200f,
+		0.489673f,
+		0.027069f,
+		-0.097402f,
+		0.000000f,
+		0.979300f,
+		0.054000f,
+		-0.194800f,
+		0.531200f,
+		0.517200f,
+		0.461262f,
+		-0.027069f,
+		-0.191061f,
+		0.000000f,
+		0.922500f,
+		-0.054000f,
+		-0.382100f,
+		0.562500f,
+		0.482800f,
+		0.489673f,
+		0.027069f,
+		-0.097402f,
+		0.000000f,
+		0.979300f,
+		0.054000f,
+		-0.194800f,
+		0.531200f,
+		0.517200f,
+		0.489673f,
+		-0.027069f,
+		-0.097402f,
+		0.000000f,
+		0.979300f,
+		-0.054000f,
+		-0.194800f,
+		0.531200f,
+		0.482800f,
+		0.099303f,
+		0.488310f,
+		-0.041132f,
+		0.000000f,
+		0.201600f,
+		0.975900f,
+		-0.083500f,
+		0.562500f,
+		0.931000f,
+		0.049943f,
+		0.497069f,
+		-0.020688f,
+		0.000000f,
+		0.103000f,
+		0.993700f,
+		-0.042600f,
+		0.562500f,
+		0.965500f,
+		0.053020f,
+		0.497069f,
+		-0.010546f,
+		0.000000f,
+		0.109300f,
+		0.993700f,
+		-0.021700f,
+		0.531300f,
+		0.965500f,
+		0.099303f,
+		0.488310f,
+		-0.041132f,
+		0.000000f,
+		0.201600f,
+		0.975900f,
+		-0.083500f,
+		0.562500f,
+		0.931000f,
+		0.053020f,
+		0.497069f,
+		-0.010546f,
+		0.000000f,
+		0.109300f,
+		0.993700f,
+		-0.021700f,
+		0.531300f,
+		0.965500f,
+		0.105419f,
+		0.488310f,
+		-0.020969f,
+		0.000000f,
+		0.214000f,
+		0.975900f,
+		-0.042500f,
+		0.531300f,
+		0.931000f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.495500f,
+		0.051000f,
+		0.049944f,
+		-0.497069f,
+		-0.020688f,
+		0.000000f,
+		0.103000f,
+		-0.993700f,
+		-0.042600f,
+		0.457500f,
+		0.053800f,
+		0.053020f,
+		-0.497069f,
+		-0.010546f,
+		0.000000f,
+		0.109300f,
+		-0.993700f,
+		-0.021700f,
+		0.454900f,
+		0.053800f,
+		0.455853f,
+		-0.080891f,
+		-0.188821f,
+		0.000000f,
+		0.911800f,
+		-0.161200f,
+		-0.377700f,
+		0.562500f,
+		0.448300f,
+		0.461262f,
+		-0.027069f,
+		-0.191061f,
+		0.000000f,
+		0.922500f,
+		-0.054000f,
+		-0.382100f,
+		0.562500f,
+		0.482800f,
+		0.489673f,
+		-0.027069f,
+		-0.097402f,
+		0.000000f,
+		0.979300f,
+		-0.054000f,
+		-0.194800f,
+		0.531200f,
+		0.482800f,
+		0.455853f,
+		-0.080891f,
+		-0.188821f,
+		0.000000f,
+		0.911800f,
+		-0.161200f,
+		-0.377700f,
+		0.562500f,
+		0.448300f,
+		0.489673f,
+		-0.027069f,
+		-0.097402f,
+		0.000000f,
+		0.979300f,
+		-0.054000f,
+		-0.194800f,
+		0.531200f,
+		0.482800f,
+		0.483932f,
+		-0.080891f,
+		-0.096260f,
+		0.000000f,
+		0.967900f,
+		-0.161200f,
+		-0.192500f,
+		0.531200f,
+		0.448300f,
+		0.147497f,
+		0.473826f,
+		-0.061095f,
+		0.000000f,
+		0.297800f,
+		0.946600f,
+		-0.123300f,
+		0.562500f,
+		0.896600f,
+		0.099303f,
+		0.488310f,
+		-0.041132f,
+		0.000000f,
+		0.201600f,
+		0.975900f,
+		-0.083500f,
+		0.562500f,
+		0.931000f,
+		0.105419f,
+		0.488310f,
+		-0.020969f,
+		0.000000f,
+		0.214000f,
+		0.975900f,
+		-0.042500f,
+		0.531300f,
+		0.931000f,
+		0.147497f,
+		0.473826f,
+		-0.061095f,
+		0.000000f,
+		0.297800f,
+		0.946600f,
+		-0.123300f,
+		0.562500f,
+		0.896600f,
+		0.105419f,
+		0.488310f,
+		-0.020969f,
+		0.000000f,
+		0.214000f,
+		0.975900f,
+		-0.042500f,
+		0.531300f,
+		0.931000f,
+		0.156582f,
+		0.473826f,
+		-0.031146f,
+		0.000000f,
+		0.316100f,
+		0.946600f,
+		-0.062900f,
+		0.531300f,
+		0.896600f,
+		0.445101f,
+		-0.133764f,
+		-0.184367f,
+		0.000000f,
+		0.890400f,
+		-0.266600f,
+		-0.368800f,
+		0.562500f,
+		0.413800f,
+		0.455853f,
+		-0.080891f,
+		-0.188821f,
+		0.000000f,
+		0.911800f,
+		-0.161200f,
+		-0.377700f,
+		0.562500f,
+		0.448300f,
+		0.483932f,
+		-0.080891f,
+		-0.096260f,
+		0.000000f,
+		0.967900f,
+		-0.161200f,
+		-0.192500f,
+		0.531200f,
+		0.448300f,
+		0.445101f,
+		-0.133764f,
+		-0.184367f,
+		0.000000f,
+		0.890400f,
+		-0.266600f,
+		-0.368800f,
+		0.562500f,
+		0.413800f,
+		0.483932f,
+		-0.080891f,
+		-0.096260f,
+		0.000000f,
+		0.967900f,
+		-0.161200f,
+		-0.192500f,
+		0.531200f,
+		0.448300f,
+		0.472517f,
+		-0.133764f,
+		-0.093989f,
+		0.000000f,
+		0.945200f,
+		-0.266600f,
+		-0.188000f,
+		0.531200f,
+		0.413800f,
+		0.193962f,
+		0.453788f,
+		-0.080342f,
+		0.000000f,
+		0.390500f,
+		0.906300f,
+		-0.161700f,
+		0.562500f,
+		0.862100f,
+		0.147497f,
+		0.473826f,
+		-0.061095f,
+		0.000000f,
+		0.297800f,
+		0.946600f,
+		-0.123300f,
+		0.562500f,
+		0.896600f,
+		0.156582f,
+		0.473826f,
+		-0.031146f,
+		0.000000f,
+		0.316100f,
+		0.946600f,
+		-0.062900f,
+		0.531300f,
+		0.896600f,
+		0.193962f,
+		0.453788f,
+		-0.080342f,
+		0.000000f,
+		0.390500f,
+		0.906300f,
+		-0.161700f,
+		0.562500f,
+		0.862100f,
+		0.156582f,
+		0.473826f,
+		-0.031146f,
+		0.000000f,
+		0.316100f,
+		0.946600f,
+		-0.062900f,
+		0.531300f,
+		0.896600f,
+		0.205910f,
+		0.453788f,
+		-0.040958f,
+		0.000000f,
+		0.414500f,
+		0.906300f,
+		-0.082400f,
+		0.531300f,
+		0.862100f,
+		0.429130f,
+		-0.185069f,
+		-0.177751f,
+		0.000000f,
+		0.858700f,
+		-0.369000f,
+		-0.355700f,
+		0.562500f,
+		0.379300f,
+		0.445101f,
+		-0.133764f,
+		-0.184367f,
+		0.000000f,
+		0.890400f,
+		-0.266600f,
+		-0.368800f,
+		0.562500f,
+		0.413800f,
+		0.472517f,
+		-0.133764f,
+		-0.093989f,
+		0.000000f,
+		0.945200f,
+		-0.266600f,
+		-0.188000f,
+		0.531200f,
+		0.413800f,
+		0.429130f,
+		-0.185069f,
+		-0.177751f,
+		0.000000f,
+		0.858700f,
+		-0.369000f,
+		-0.355700f,
+		0.562500f,
+		0.379300f,
+		0.472517f,
+		-0.133764f,
+		-0.093989f,
+		0.000000f,
+		0.945200f,
+		-0.266600f,
+		-0.188000f,
+		0.531200f,
+		0.413800f,
+		0.455563f,
+		-0.185069f,
+		-0.090617f,
+		0.000000f,
+		0.911600f,
+		-0.369000f,
+		-0.181300f,
+		0.531200f,
+		0.379300f,
+		0.238154f,
+		0.428429f,
+		-0.098647f,
+		0.000000f,
+		0.478600f,
+		0.855300f,
+		-0.198200f,
+		0.562500f,
+		0.827600f,
+		0.193962f,
+		0.453788f,
+		-0.080342f,
+		0.000000f,
+		0.390500f,
+		0.906300f,
+		-0.161700f,
+		0.562500f,
+		0.862100f,
+		0.205910f,
+		0.453788f,
+		-0.040958f,
+		0.000000f,
+		0.414500f,
+		0.906300f,
+		-0.082400f,
+		0.531300f,
+		0.862100f,
+		0.238154f,
+		0.428429f,
+		-0.098647f,
+		0.000000f,
+		0.478600f,
+		0.855300f,
+		-0.198200f,
+		0.562500f,
+		0.827600f,
+		0.205910f,
+		0.453788f,
+		-0.040958f,
+		0.000000f,
+		0.414500f,
+		0.906300f,
+		-0.082400f,
+		0.531300f,
+		0.862100f,
+		0.252823f,
+		0.428429f,
+		-0.050290f,
+		0.000000f,
+		0.508100f,
+		0.855300f,
+		-0.101000f,
+		0.531300f,
+		0.827600f,
+		0.408128f,
+		-0.234204f,
+		-0.169052f,
+		0.000000f,
+		0.816900f,
+		-0.467000f,
+		-0.338400f,
+		0.562500f,
+		0.344800f,
+		0.429130f,
+		-0.185069f,
+		-0.177751f,
+		0.000000f,
+		0.858700f,
+		-0.369000f,
+		-0.355700f,
+		0.562500f,
+		0.379300f,
+		0.455563f,
+		-0.185069f,
+		-0.090617f,
+		0.000000f,
+		0.911600f,
+		-0.369000f,
+		-0.181300f,
+		0.531200f,
+		0.379300f,
+		0.408128f,
+		-0.234204f,
+		-0.169052f,
+		0.000000f,
+		0.816900f,
+		-0.467000f,
+		-0.338400f,
+		0.562500f,
+		0.344800f,
+		0.455563f,
+		-0.185069f,
+		-0.090617f,
+		0.000000f,
+		0.911600f,
+		-0.369000f,
+		-0.181300f,
+		0.531200f,
+		0.379300f,
+		0.433267f,
+		-0.234204f,
+		-0.086182f,
+		0.000000f,
+		0.867200f,
+		-0.467000f,
+		-0.172500f,
+		0.531200f,
+		0.344800f,
+		0.279553f,
+		0.398046f,
+		-0.115795f,
+		0.000000f,
+		0.561100f,
+		0.794500f,
+		-0.232400f,
+		0.562500f,
+		0.793100f,
+		0.238154f,
+		0.428429f,
+		-0.098647f,
+		0.000000f,
+		0.478600f,
+		0.855300f,
+		-0.198200f,
+		0.562500f,
+		0.827600f,
+		0.252823f,
+		0.428429f,
+		-0.050290f,
+		0.000000f,
+		0.508100f,
+		0.855300f,
+		-0.101000f,
+		0.531300f,
+		0.827600f,
+		0.279553f,
+		0.398046f,
+		-0.115795f,
+		0.000000f,
+		0.561100f,
+		0.794500f,
+		-0.232400f,
+		0.562500f,
+		0.793100f,
+		0.252823f,
+		0.428429f,
+		-0.050290f,
+		0.000000f,
+		0.508100f,
+		0.855300f,
+		-0.101000f,
+		0.531300f,
+		0.827600f,
+		0.296772f,
+		0.398046f,
+		-0.059032f,
+		0.000000f,
+		0.595600f,
+		0.794500f,
+		-0.118500f,
+		0.531300f,
+		0.793100f,
+		0.382342f,
+		-0.280594f,
+		-0.158371f,
+		0.000000f,
+		0.765600f,
+		-0.559600f,
+		-0.317100f,
+		0.562500f,
+		0.310300f,
+		0.408128f,
+		-0.234204f,
+		-0.169052f,
+		0.000000f,
+		0.816900f,
+		-0.467000f,
+		-0.338400f,
+		0.562500f,
+		0.344800f,
+		0.433267f,
+		-0.234204f,
+		-0.086182f,
+		0.000000f,
+		0.867200f,
+		-0.467000f,
+		-0.172500f,
+		0.531200f,
+		0.344800f,
+		0.382342f,
+		-0.280594f,
+		-0.158371f,
+		0.000000f,
+		0.765600f,
+		-0.559600f,
+		-0.317100f,
+		0.562500f,
+		0.310300f,
+		0.433267f,
+		-0.234204f,
+		-0.086182f,
+		0.000000f,
+		0.867200f,
+		-0.467000f,
+		-0.172500f,
+		0.531200f,
+		0.344800f,
+		0.405892f,
+		-0.280594f,
+		-0.080737f,
+		0.000000f,
+		0.812800f,
+		-0.559600f,
+		-0.161700f,
+		0.531200f,
+		0.310300f,
+		0.317674f,
+		0.362998f,
+		-0.131585f,
+		0.000000f,
+		0.637000f,
+		0.724300f,
+		-0.263800f,
+		0.562500f,
+		0.758600f,
+		0.279553f,
+		0.398046f,
+		-0.115795f,
+		0.000000f,
+		0.561100f,
+		0.794500f,
+		-0.232400f,
+		0.562500f,
+		0.793100f,
+		0.296772f,
+		0.398046f,
+		-0.059032f,
+		0.000000f,
+		0.595600f,
+		0.794500f,
+		-0.118500f,
+		0.531300f,
+		0.793100f,
+		0.317674f,
+		0.362998f,
+		-0.131585f,
+		0.000000f,
+		0.637000f,
+		0.724300f,
+		-0.263800f,
+		0.562500f,
+		0.758600f,
+		0.296772f,
+		0.398046f,
+		-0.059032f,
+		0.000000f,
+		0.595600f,
+		0.794500f,
+		-0.118500f,
+		0.531300f,
+		0.793100f,
+		0.337242f,
+		0.362998f,
+		-0.067082f,
+		0.000000f,
+		0.676200f,
+		0.724300f,
+		-0.134500f,
+		0.531300f,
+		0.758600f,
+		0.352072f,
+		-0.323693f,
+		-0.145833f,
+		0.000000f,
+		0.705400f,
+		-0.645700f,
+		-0.292200f,
+		0.562500f,
+		0.275900f,
+		0.382342f,
+		-0.280594f,
+		-0.158371f,
+		0.000000f,
+		0.765600f,
+		-0.559600f,
+		-0.317100f,
+		0.562500f,
+		0.310300f,
+		0.405892f,
+		-0.280594f,
+		-0.080737f,
+		0.000000f,
+		0.812800f,
+		-0.559600f,
+		-0.161700f,
+		0.531200f,
+		0.310300f,
+		0.352072f,
+		-0.323693f,
+		-0.145833f,
+		0.000000f,
+		0.705400f,
+		-0.645700f,
+		-0.292200f,
+		0.562500f,
+		0.275900f,
+		0.405892f,
+		-0.280594f,
+		-0.080737f,
+		0.000000f,
+		0.812800f,
+		-0.559600f,
+		-0.161700f,
+		0.531200f,
+		0.310300f,
+		0.373758f,
+		-0.323693f,
+		-0.074345f,
+		0.000000f,
+		0.748900f,
+		-0.645700f,
+		-0.149000f,
+		0.531200f,
+		0.275900f,
+		0.352072f,
+		0.323693f,
+		-0.145833f,
+		0.000000f,
+		0.705400f,
+		0.645700f,
+		-0.292200f,
+		0.562500f,
+		0.724100f,
+		0.317674f,
+		0.362998f,
+		-0.131585f,
+		0.000000f,
+		0.637000f,
+		0.724300f,
+		-0.263800f,
+		0.562500f,
+		0.758600f,
+		0.337242f,
+		0.362998f,
+		-0.067082f,
+		0.000000f,
+		0.676200f,
+		0.724300f,
+		-0.134500f,
+		0.531300f,
+		0.758600f,
+		0.352072f,
+		0.323693f,
+		-0.145833f,
+		0.000000f,
+		0.705400f,
+		0.645700f,
+		-0.292200f,
+		0.562500f,
+		0.724100f,
+		0.337242f,
+		0.362998f,
+		-0.067082f,
+		0.000000f,
+		0.676200f,
+		0.724300f,
+		-0.134500f,
+		0.531300f,
+		0.758600f,
+		0.373758f,
+		0.323693f,
+		-0.074345f,
+		0.000000f,
+		0.748900f,
+		0.645700f,
+		-0.149000f,
+		0.531200f,
+		0.724100f,
+		0.317675f,
+		-0.362998f,
+		-0.131585f,
+		0.000000f,
+		0.637000f,
+		-0.724300f,
+		-0.263800f,
+		0.562500f,
+		0.241400f,
+		0.352072f,
+		-0.323693f,
+		-0.145833f,
+		0.000000f,
+		0.705400f,
+		-0.645700f,
+		-0.292200f,
+		0.562500f,
+		0.275900f,
+		0.373758f,
+		-0.323693f,
+		-0.074345f,
+		0.000000f,
+		0.748900f,
+		-0.645700f,
+		-0.149000f,
+		0.531200f,
+		0.275900f,
+		0.317675f,
+		-0.362998f,
+		-0.131585f,
+		0.000000f,
+		0.637000f,
+		-0.724300f,
+		-0.263800f,
+		0.562500f,
+		0.241400f,
+		0.373758f,
+		-0.323693f,
+		-0.074345f,
+		0.000000f,
+		0.748900f,
+		-0.645700f,
+		-0.149000f,
+		0.531200f,
+		0.275900f,
+		0.337242f,
+		-0.362998f,
+		-0.067082f,
+		0.000000f,
+		0.676200f,
+		-0.724300f,
+		-0.134500f,
+		0.531200f,
+		0.241400f,
+		0.382342f,
+		0.280594f,
+		-0.158371f,
+		0.000000f,
+		0.765600f,
+		0.559600f,
+		-0.317100f,
+		0.562500f,
+		0.689700f,
+		0.352072f,
+		0.323693f,
+		-0.145833f,
+		0.000000f,
+		0.705400f,
+		0.645700f,
+		-0.292200f,
+		0.562500f,
+		0.724100f,
+		0.373758f,
+		0.323693f,
+		-0.074345f,
+		0.000000f,
+		0.748900f,
+		0.645700f,
+		-0.149000f,
+		0.531200f,
+		0.724100f,
+		0.382342f,
+		0.280594f,
+		-0.158371f,
+		0.000000f,
+		0.765600f,
+		0.559600f,
+		-0.317100f,
+		0.562500f,
+		0.689700f,
+		0.373758f,
+		0.323693f,
+		-0.074345f,
+		0.000000f,
+		0.748900f,
+		0.645700f,
+		-0.149000f,
+		0.531200f,
+		0.724100f,
+		0.405892f,
+		0.280594f,
+		-0.080737f,
+		0.000000f,
+		0.812800f,
+		0.559600f,
+		-0.161700f,
+		0.531300f,
+		0.689700f,
+		0.279553f,
+		-0.398046f,
+		-0.115795f,
+		0.000000f,
+		0.561100f,
+		-0.794500f,
+		-0.232400f,
+		0.562500f,
+		0.206900f,
+		0.317675f,
+		-0.362998f,
+		-0.131585f,
+		0.000000f,
+		0.637000f,
+		-0.724300f,
+		-0.263800f,
+		0.562500f,
+		0.241400f,
+		0.337242f,
+		-0.362998f,
+		-0.067082f,
+		0.000000f,
+		0.676200f,
+		-0.724300f,
+		-0.134500f,
+		0.531200f,
+		0.241400f,
+		0.279553f,
+		-0.398046f,
+		-0.115795f,
+		0.000000f,
+		0.561100f,
+		-0.794500f,
+		-0.232400f,
+		0.562500f,
+		0.206900f,
+		0.337242f,
+		-0.362998f,
+		-0.067082f,
+		0.000000f,
+		0.676200f,
+		-0.724300f,
+		-0.134500f,
+		0.531200f,
+		0.241400f,
+		0.296772f,
+		-0.398046f,
+		-0.059032f,
+		0.000000f,
+		0.595600f,
+		-0.794500f,
+		-0.118500f,
+		0.531200f,
+		0.206900f,
+		0.408128f,
+		0.234204f,
+		-0.169052f,
+		0.000000f,
+		0.816900f,
+		0.467000f,
+		-0.338400f,
+		0.562500f,
+		0.655200f,
+		0.382342f,
+		0.280594f,
+		-0.158371f,
+		0.000000f,
+		0.765600f,
+		0.559600f,
+		-0.317100f,
+		0.562500f,
+		0.689700f,
+		0.405892f,
+		0.280594f,
+		-0.080737f,
+		0.000000f,
+		0.812800f,
+		0.559600f,
+		-0.161700f,
+		0.531300f,
+		0.689700f,
+		0.408128f,
+		0.234204f,
+		-0.169052f,
+		0.000000f,
+		0.816900f,
+		0.467000f,
+		-0.338400f,
+		0.562500f,
+		0.655200f,
+		0.405892f,
+		0.280594f,
+		-0.080737f,
+		0.000000f,
+		0.812800f,
+		0.559600f,
+		-0.161700f,
+		0.531300f,
+		0.689700f,
+		0.433267f,
+		0.234204f,
+		-0.086182f,
+		0.000000f,
+		0.867200f,
+		0.467000f,
+		-0.172500f,
+		0.531200f,
+		0.655200f,
+		0.433267f,
+		-0.234204f,
+		-0.086182f,
+		0.000000f,
+		0.867200f,
+		-0.467000f,
+		-0.172500f,
+		0.531200f,
+		0.344800f,
+		0.455563f,
+		-0.185069f,
+		-0.090617f,
+		0.000000f,
+		0.911600f,
+		-0.369000f,
+		-0.181300f,
+		0.531200f,
+		0.379300f,
+		0.464487f,
+		-0.185069f,
+		0.000000f,
+		0.000000f,
+		0.929400f,
+		-0.369000f,
+		0.000000f,
+		0.500000f,
+		0.379300f,
+		0.433267f,
+		-0.234204f,
+		-0.086182f,
+		0.000000f,
+		0.867200f,
+		-0.467000f,
+		-0.172500f,
+		0.531200f,
+		0.344800f,
+		0.464487f,
+		-0.185069f,
+		0.000000f,
+		0.000000f,
+		0.929400f,
+		-0.369000f,
+		0.000000f,
+		0.500000f,
+		0.379300f,
+		0.441755f,
+		-0.234204f,
+		0.000000f,
+		0.000000f,
+		0.884200f,
+		-0.467000f,
+		0.000000f,
+		0.500000f,
+		0.344800f,
+		0.296772f,
+		0.398046f,
+		-0.059032f,
+		0.000000f,
+		0.595600f,
+		0.794500f,
+		-0.118500f,
+		0.531300f,
+		0.793100f,
+		0.252823f,
+		0.428429f,
+		-0.050290f,
+		0.000000f,
+		0.508100f,
+		0.855300f,
+		-0.101000f,
+		0.531300f,
+		0.827600f,
+		0.257776f,
+		0.428429f,
+		-0.000000f,
+		0.000000f,
+		0.518000f,
+		0.855300f,
+		0.000000f,
+		0.500000f,
+		0.827600f,
+		0.296772f,
+		0.398046f,
+		-0.059032f,
+		0.000000f,
+		0.595600f,
+		0.794500f,
+		-0.118500f,
+		0.531300f,
+		0.793100f,
+		0.257776f,
+		0.428429f,
+		-0.000000f,
+		0.000000f,
+		0.518000f,
+		0.855300f,
+		0.000000f,
+		0.500000f,
+		0.827600f,
+		0.302586f,
+		0.398046f,
+		0.000000f,
+		0.000000f,
+		0.607300f,
+		0.794500f,
+		0.000000f,
+		0.500000f,
+		0.793100f,
+		0.405892f,
+		-0.280594f,
+		-0.080737f,
+		0.000000f,
+		0.812800f,
+		-0.559600f,
+		-0.161700f,
+		0.531200f,
+		0.310300f,
+		0.433267f,
+		-0.234204f,
+		-0.086182f,
+		0.000000f,
+		0.867200f,
+		-0.467000f,
+		-0.172500f,
+		0.531200f,
+		0.344800f,
+		0.441755f,
+		-0.234204f,
+		0.000000f,
+		0.000000f,
+		0.884200f,
+		-0.467000f,
+		0.000000f,
+		0.500000f,
+		0.344800f,
+		0.405892f,
+		-0.280594f,
+		-0.080737f,
+		0.000000f,
+		0.812800f,
+		-0.559600f,
+		-0.161700f,
+		0.531200f,
+		0.310300f,
+		0.441755f,
+		-0.234204f,
+		0.000000f,
+		0.000000f,
+		0.884200f,
+		-0.467000f,
+		0.000000f,
+		0.500000f,
+		0.344800f,
+		0.413844f,
+		-0.280594f,
+		0.000000f,
+		0.000000f,
+		0.828700f,
+		-0.559600f,
+		0.000000f,
+		0.500000f,
+		0.310300f,
+		0.337242f,
+		0.362998f,
+		-0.067082f,
+		0.000000f,
+		0.676200f,
+		0.724300f,
+		-0.134500f,
+		0.531300f,
+		0.758600f,
+		0.296772f,
+		0.398046f,
+		-0.059032f,
+		0.000000f,
+		0.595600f,
+		0.794500f,
+		-0.118500f,
+		0.531300f,
+		0.793100f,
+		0.302586f,
+		0.398046f,
+		0.000000f,
+		0.000000f,
+		0.607300f,
+		0.794500f,
+		0.000000f,
+		0.500000f,
+		0.793100f,
+		0.337242f,
+		0.362998f,
+		-0.067082f,
+		0.000000f,
+		0.676200f,
+		0.724300f,
+		-0.134500f,
+		0.531300f,
+		0.758600f,
+		0.302586f,
+		0.398046f,
+		0.000000f,
+		0.000000f,
+		0.607300f,
+		0.794500f,
+		0.000000f,
+		0.500000f,
+		0.793100f,
+		0.343848f,
+		0.362998f,
+		-0.000000f,
+		0.000000f,
+		0.689400f,
+		0.724300f,
+		0.000000f,
+		0.500000f,
+		0.758600f,
+		0.373758f,
+		-0.323693f,
+		-0.074345f,
+		0.000000f,
+		0.748900f,
+		-0.645700f,
+		-0.149000f,
+		0.531200f,
+		0.275900f,
+		0.405892f,
+		-0.280594f,
+		-0.080737f,
+		0.000000f,
+		0.812800f,
+		-0.559600f,
+		-0.161700f,
+		0.531200f,
+		0.310300f,
+		0.413844f,
+		-0.280594f,
+		0.000000f,
+		0.000000f,
+		0.828700f,
+		-0.559600f,
+		0.000000f,
+		0.500000f,
+		0.310300f,
+		0.373758f,
+		-0.323693f,
+		-0.074345f,
+		0.000000f,
+		0.748900f,
+		-0.645700f,
+		-0.149000f,
+		0.531200f,
+		0.275900f,
+		0.413844f,
+		-0.280594f,
+		0.000000f,
+		0.000000f,
+		0.828700f,
+		-0.559600f,
+		0.000000f,
+		0.500000f,
+		0.310300f,
+		0.381080f,
+		-0.323693f,
+		0.000000f,
+		0.000000f,
+		0.763500f,
+		-0.645700f,
+		0.000000f,
+		0.500000f,
+		0.275900f,
+		0.373758f,
+		0.323693f,
+		-0.074345f,
+		0.000000f,
+		0.748900f,
+		0.645700f,
+		-0.149000f,
+		0.531200f,
+		0.724100f,
+		0.337242f,
+		0.362998f,
+		-0.067082f,
+		0.000000f,
+		0.676200f,
+		0.724300f,
+		-0.134500f,
+		0.531300f,
+		0.758600f,
+		0.343848f,
+		0.362998f,
+		-0.000000f,
+		0.000000f,
+		0.689400f,
+		0.724300f,
+		0.000000f,
+		0.500000f,
+		0.758600f,
+		0.373758f,
+		0.323693f,
+		-0.074345f,
+		0.000000f,
+		0.748900f,
+		0.645700f,
+		-0.149000f,
+		0.531200f,
+		0.724100f,
+		0.343848f,
+		0.362998f,
+		-0.000000f,
+		0.000000f,
+		0.689400f,
+		0.724300f,
+		0.000000f,
+		0.500000f,
+		0.758600f,
+		0.381080f,
+		0.323693f,
+		0.000000f,
+		0.000000f,
+		0.763500f,
+		0.645700f,
+		0.000000f,
+		0.500000f,
+		0.724100f,
+		0.337242f,
+		-0.362998f,
+		-0.067082f,
+		0.000000f,
+		0.676200f,
+		-0.724300f,
+		-0.134500f,
+		0.531200f,
+		0.241400f,
+		0.373758f,
+		-0.323693f,
+		-0.074345f,
+		0.000000f,
+		0.748900f,
+		-0.645700f,
+		-0.149000f,
+		0.531200f,
+		0.275900f,
+		0.381080f,
+		-0.323693f,
+		0.000000f,
+		0.000000f,
+		0.763500f,
+		-0.645700f,
+		0.000000f,
+		0.500000f,
+		0.275900f,
+		0.337242f,
+		-0.362998f,
+		-0.067082f,
+		0.000000f,
+		0.676200f,
+		-0.724300f,
+		-0.134500f,
+		0.531200f,
+		0.241400f,
+		0.381080f,
+		-0.323693f,
+		0.000000f,
+		0.000000f,
+		0.763500f,
+		-0.645700f,
+		0.000000f,
+		0.500000f,
+		0.275900f,
+		0.343849f,
+		-0.362998f,
+		0.000000f,
+		0.000000f,
+		0.689400f,
+		-0.724300f,
+		0.000000f,
+		0.500000f,
+		0.241400f,
+		0.405892f,
+		0.280594f,
+		-0.080737f,
+		0.000000f,
+		0.812800f,
+		0.559600f,
+		-0.161700f,
+		0.531300f,
+		0.689700f,
+		0.373758f,
+		0.323693f,
+		-0.074345f,
+		0.000000f,
+		0.748900f,
+		0.645700f,
+		-0.149000f,
+		0.531200f,
+		0.724100f,
+		0.381080f,
+		0.323693f,
+		0.000000f,
+		0.000000f,
+		0.763500f,
+		0.645700f,
+		0.000000f,
+		0.500000f,
+		0.724100f,
+		0.405892f,
+		0.280594f,
+		-0.080737f,
+		0.000000f,
+		0.812800f,
+		0.559600f,
+		-0.161700f,
+		0.531300f,
+		0.689700f,
+		0.381080f,
+		0.323693f,
+		0.000000f,
+		0.000000f,
+		0.763500f,
+		0.645700f,
+		0.000000f,
+		0.500000f,
+		0.724100f,
+		0.413844f,
+		0.280594f,
+		0.000000f,
+		0.000000f,
+		0.828700f,
+		0.559600f,
+		0.000000f,
+		0.500000f,
+		0.689700f,
+		0.296772f,
+		-0.398046f,
+		-0.059032f,
+		0.000000f,
+		0.595600f,
+		-0.794500f,
+		-0.118500f,
+		0.531200f,
+		0.206900f,
+		0.337242f,
+		-0.362998f,
+		-0.067082f,
+		0.000000f,
+		0.676200f,
+		-0.724300f,
+		-0.134500f,
+		0.531200f,
+		0.241400f,
+		0.343849f,
+		-0.362998f,
+		0.000000f,
+		0.000000f,
+		0.689400f,
+		-0.724300f,
+		0.000000f,
+		0.500000f,
+		0.241400f,
+		0.296772f,
+		-0.398046f,
+		-0.059032f,
+		0.000000f,
+		0.595600f,
+		-0.794500f,
+		-0.118500f,
+		0.531200f,
+		0.206900f,
+		0.343849f,
+		-0.362998f,
+		0.000000f,
+		0.000000f,
+		0.689400f,
+		-0.724300f,
+		0.000000f,
+		0.500000f,
+		0.241400f,
+		0.302586f,
+		-0.398046f,
+		0.000000f,
+		0.000000f,
+		0.607300f,
+		-0.794500f,
+		0.000000f,
+		0.500000f,
+		0.206900f,
+		0.433267f,
+		0.234204f,
+		-0.086182f,
+		0.000000f,
+		0.867200f,
+		0.467000f,
+		-0.172500f,
+		0.531200f,
+		0.655200f,
+		0.405892f,
+		0.280594f,
+		-0.080737f,
+		0.000000f,
+		0.812800f,
+		0.559600f,
+		-0.161700f,
+		0.531300f,
+		0.689700f,
+		0.413844f,
+		0.280594f,
+		0.000000f,
+		0.000000f,
+		0.828700f,
+		0.559600f,
+		0.000000f,
+		0.500000f,
+		0.689700f,
+		0.433267f,
+		0.234204f,
+		-0.086182f,
+		0.000000f,
+		0.867200f,
+		0.467000f,
+		-0.172500f,
+		0.531200f,
+		0.655200f,
+		0.413844f,
+		0.280594f,
+		0.000000f,
+		0.000000f,
+		0.828700f,
+		0.559600f,
+		0.000000f,
+		0.500000f,
+		0.689700f,
+		0.441755f,
+		0.234204f,
+		0.000000f,
+		0.000000f,
+		0.884200f,
+		0.467000f,
+		0.000000f,
+		0.500000f,
+		0.655200f,
+		0.252823f,
+		-0.428429f,
+		-0.050290f,
+		0.000000f,
+		0.508100f,
+		-0.855300f,
+		-0.101000f,
+		0.531200f,
+		0.172400f,
+		0.296772f,
+		-0.398046f,
+		-0.059032f,
+		0.000000f,
+		0.595600f,
+		-0.794500f,
+		-0.118500f,
+		0.531200f,
+		0.206900f,
+		0.302586f,
+		-0.398046f,
+		0.000000f,
+		0.000000f,
+		0.607300f,
+		-0.794500f,
+		0.000000f,
+		0.500000f,
+		0.206900f,
+		0.252823f,
+		-0.428429f,
+		-0.050290f,
+		0.000000f,
+		0.508100f,
+		-0.855300f,
+		-0.101000f,
+		0.531200f,
+		0.172400f,
+		0.302586f,
+		-0.398046f,
+		0.000000f,
+		0.000000f,
+		0.607300f,
+		-0.794500f,
+		0.000000f,
+		0.500000f,
+		0.206900f,
+		0.257776f,
+		-0.428429f,
+		0.000000f,
+		0.000000f,
+		0.518000f,
+		-0.855300f,
+		0.000000f,
+		0.500000f,
+		0.172400f,
+		0.455563f,
+		0.185069f,
+		-0.090617f,
+		0.000000f,
+		0.911600f,
+		0.369000f,
+		-0.181300f,
+		0.531200f,
+		0.620700f,
+		0.433267f,
+		0.234204f,
+		-0.086182f,
+		0.000000f,
+		0.867200f,
+		0.467000f,
+		-0.172500f,
+		0.531200f,
+		0.655200f,
+		0.441755f,
+		0.234204f,
+		0.000000f,
+		0.000000f,
+		0.884200f,
+		0.467000f,
+		0.000000f,
+		0.500000f,
+		0.655200f,
+		0.455563f,
+		0.185069f,
+		-0.090617f,
+		0.000000f,
+		0.911600f,
+		0.369000f,
+		-0.181300f,
+		0.531200f,
+		0.620700f,
+		0.441755f,
+		0.234204f,
+		0.000000f,
+		0.000000f,
+		0.884200f,
+		0.467000f,
+		0.000000f,
+		0.500000f,
+		0.655200f,
+		0.464487f,
+		0.185069f,
+		0.000000f,
+		0.000000f,
+		0.929400f,
+		0.369000f,
+		0.000000f,
+		0.500000f,
+		0.620700f,
+		0.205910f,
+		-0.453788f,
+		-0.040958f,
+		0.000000f,
+		0.414500f,
+		-0.906300f,
+		-0.082400f,
+		0.531200f,
+		0.137900f,
+		0.252823f,
+		-0.428429f,
+		-0.050290f,
+		0.000000f,
+		0.508100f,
+		-0.855300f,
+		-0.101000f,
+		0.531200f,
+		0.172400f,
+		0.257776f,
+		-0.428429f,
+		0.000000f,
+		0.000000f,
+		0.518000f,
+		-0.855300f,
+		0.000000f,
+		0.500000f,
+		0.172400f,
+		0.205910f,
+		-0.453788f,
+		-0.040958f,
+		0.000000f,
+		0.414500f,
+		-0.906300f,
+		-0.082400f,
+		0.531200f,
+		0.137900f,
+		0.257776f,
+		-0.428429f,
+		0.000000f,
+		0.000000f,
+		0.518000f,
+		-0.855300f,
+		0.000000f,
+		0.500000f,
+		0.172400f,
+		0.209944f,
+		-0.453788f,
+		0.000000f,
+		0.000000f,
+		0.422700f,
+		-0.906300f,
+		0.000000f,
+		0.500000f,
+		0.137900f,
+		0.472517f,
+		0.133764f,
+		-0.093989f,
+		0.000000f,
+		0.945200f,
+		0.266600f,
+		-0.188000f,
+		0.531200f,
+		0.586200f,
+		0.455563f,
+		0.185069f,
+		-0.090617f,
+		0.000000f,
+		0.911600f,
+		0.369000f,
+		-0.181300f,
+		0.531200f,
+		0.620700f,
+		0.464487f,
+		0.185069f,
+		0.000000f,
+		0.000000f,
+		0.929400f,
+		0.369000f,
+		0.000000f,
+		0.500000f,
+		0.620700f,
+		0.472517f,
+		0.133764f,
+		-0.093989f,
+		0.000000f,
+		0.945200f,
+		0.266600f,
+		-0.188000f,
+		0.531200f,
+		0.586200f,
+		0.464487f,
+		0.185069f,
+		0.000000f,
+		0.000000f,
+		0.929400f,
+		0.369000f,
+		0.000000f,
+		0.500000f,
+		0.620700f,
+		0.481774f,
+		0.133764f,
+		0.000000f,
+		0.000000f,
+		0.963800f,
+		0.266600f,
+		0.000000f,
+		0.500000f,
+		0.586200f,
+		0.156583f,
+		-0.473826f,
+		-0.031147f,
+		0.000000f,
+		0.316100f,
+		-0.946600f,
+		-0.062900f,
+		0.531300f,
+		0.103400f,
+		0.205910f,
+		-0.453788f,
+		-0.040958f,
+		0.000000f,
+		0.414500f,
+		-0.906300f,
+		-0.082400f,
+		0.531200f,
+		0.137900f,
+		0.209944f,
+		-0.453788f,
+		0.000000f,
+		0.000000f,
+		0.422700f,
+		-0.906300f,
+		0.000000f,
+		0.500000f,
+		0.137900f,
+		0.156583f,
+		-0.473826f,
+		-0.031147f,
+		0.000000f,
+		0.316100f,
+		-0.946600f,
+		-0.062900f,
+		0.531300f,
+		0.103400f,
+		0.209944f,
+		-0.453788f,
+		0.000000f,
+		0.000000f,
+		0.422700f,
+		-0.906300f,
+		0.000000f,
+		0.500000f,
+		0.137900f,
+		0.159650f,
+		-0.473826f,
+		-0.000000f,
+		0.000000f,
+		0.322300f,
+		-0.946600f,
+		0.000000f,
+		0.500000f,
+		0.103400f,
+		0.483932f,
+		0.080891f,
+		-0.096260f,
+		0.000000f,
+		0.967900f,
+		0.161200f,
+		-0.192500f,
+		0.531200f,
+		0.551700f,
+		0.472517f,
+		0.133764f,
+		-0.093989f,
+		0.000000f,
+		0.945200f,
+		0.266600f,
+		-0.188000f,
+		0.531200f,
+		0.586200f,
+		0.481774f,
+		0.133764f,
+		0.000000f,
+		0.000000f,
+		0.963800f,
+		0.266600f,
+		0.000000f,
+		0.500000f,
+		0.586200f,
+		0.483932f,
+		0.080891f,
+		-0.096260f,
+		0.000000f,
+		0.967900f,
+		0.161200f,
+		-0.192500f,
+		0.531200f,
+		0.551700f,
+		0.481774f,
+		0.133764f,
+		0.000000f,
+		0.000000f,
+		0.963800f,
+		0.266600f,
+		0.000000f,
+		0.500000f,
+		0.586200f,
+		0.493412f,
+		0.080891f,
+		0.000000f,
+		0.000000f,
+		0.986900f,
+		0.161200f,
+		0.000000f,
+		0.500000f,
+		0.551700f,
+		0.105420f,
+		-0.488310f,
+		-0.020970f,
+		0.000000f,
+		0.214000f,
+		-0.975900f,
+		-0.042500f,
+		0.531300f,
+		0.069000f,
+		0.156583f,
+		-0.473826f,
+		-0.031147f,
+		0.000000f,
+		0.316100f,
+		-0.946600f,
+		-0.062900f,
+		0.531300f,
+		0.103400f,
+		0.159650f,
+		-0.473826f,
+		-0.000000f,
+		0.000000f,
+		0.322300f,
+		-0.946600f,
+		0.000000f,
+		0.500000f,
+		0.103400f,
+		0.105420f,
+		-0.488310f,
+		-0.020970f,
+		0.000000f,
+		0.214000f,
+		-0.975900f,
+		-0.042500f,
+		0.531300f,
+		0.069000f,
+		0.159650f,
+		-0.473826f,
+		-0.000000f,
+		0.000000f,
+		0.322300f,
+		-0.946600f,
+		0.000000f,
+		0.500000f,
+		0.103400f,
+		0.107484f,
+		-0.488310f,
+		0.000000f,
+		0.000000f,
+		0.218200f,
+		-0.975900f,
+		0.000000f,
+		0.500000f,
+		0.069000f,
+		0.489673f,
+		0.027069f,
+		-0.097402f,
+		0.000000f,
+		0.979300f,
+		0.054000f,
+		-0.194800f,
+		0.531200f,
+		0.517200f,
+		0.483932f,
+		0.080891f,
+		-0.096260f,
+		0.000000f,
+		0.967900f,
+		0.161200f,
+		-0.192500f,
+		0.531200f,
+		0.551700f,
+		0.493412f,
+		0.080891f,
+		0.000000f,
+		0.000000f,
+		0.986900f,
+		0.161200f,
+		0.000000f,
+		0.500000f,
+		0.551700f,
+		0.489673f,
+		0.027069f,
+		-0.097402f,
+		0.000000f,
+		0.979300f,
+		0.054000f,
+		-0.194800f,
+		0.531200f,
+		0.517200f,
+		0.493412f,
+		0.080891f,
+		0.000000f,
+		0.000000f,
+		0.986900f,
+		0.161200f,
+		0.000000f,
+		0.500000f,
+		0.551700f,
+		0.499265f,
+		0.027069f,
+		0.000000f,
+		0.000000f,
+		0.998500f,
+		0.054000f,
+		0.000000f,
+		0.500000f,
+		0.517200f,
+		0.053020f,
+		0.497069f,
+		-0.010546f,
+		0.000000f,
+		0.109300f,
+		0.993700f,
+		-0.021700f,
+		0.454400f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.482000f,
+		0.960300f,
+		0.054058f,
+		0.497069f,
+		0.000000f,
+		0.000000f,
+		0.111500f,
+		0.993700f,
+		0.000000f,
+		0.456200f,
+		0.962300f,
+		0.053020f,
+		-0.497069f,
+		-0.010546f,
+		0.000000f,
+		0.109300f,
+		-0.993700f,
+		-0.021700f,
+		0.531300f,
+		0.034500f,
+		0.105420f,
+		-0.488310f,
+		-0.020970f,
+		0.000000f,
+		0.214000f,
+		-0.975900f,
+		-0.042500f,
+		0.531300f,
+		0.069000f,
+		0.107484f,
+		-0.488310f,
+		0.000000f,
+		0.000000f,
+		0.218200f,
+		-0.975900f,
+		0.000000f,
+		0.500000f,
+		0.069000f,
+		0.053020f,
+		-0.497069f,
+		-0.010546f,
+		0.000000f,
+		0.109300f,
+		-0.993700f,
+		-0.021700f,
+		0.531300f,
+		0.034500f,
+		0.107484f,
+		-0.488310f,
+		0.000000f,
+		0.000000f,
+		0.218200f,
+		-0.975900f,
+		0.000000f,
+		0.500000f,
+		0.069000f,
+		0.054059f,
+		-0.497069f,
+		0.000000f,
+		0.000000f,
+		0.111500f,
+		-0.993700f,
+		0.000000f,
+		0.500000f,
+		0.034500f,
+		0.489673f,
+		-0.027069f,
+		-0.097402f,
+		0.000000f,
+		0.979300f,
+		-0.054000f,
+		-0.194800f,
+		0.531200f,
+		0.482800f,
+		0.489673f,
+		0.027069f,
+		-0.097402f,
+		0.000000f,
+		0.979300f,
+		0.054000f,
+		-0.194800f,
+		0.531200f,
+		0.517200f,
+		0.499265f,
+		0.027069f,
+		0.000000f,
+		0.000000f,
+		0.998500f,
+		0.054000f,
+		0.000000f,
+		0.500000f,
+		0.517200f,
+		0.489673f,
+		-0.027069f,
+		-0.097402f,
+		0.000000f,
+		0.979300f,
+		-0.054000f,
+		-0.194800f,
+		0.531200f,
+		0.482800f,
+		0.499265f,
+		0.027069f,
+		0.000000f,
+		0.000000f,
+		0.998500f,
+		0.054000f,
+		0.000000f,
+		0.500000f,
+		0.517200f,
+		0.499265f,
+		-0.027069f,
+		0.000000f,
+		0.000000f,
+		0.998500f,
+		-0.054000f,
+		0.000000f,
+		0.500000f,
+		0.482800f,
+		0.105419f,
+		0.488310f,
+		-0.020969f,
+		0.000000f,
+		0.214000f,
+		0.975900f,
+		-0.042500f,
+		0.531300f,
+		0.931000f,
+		0.053020f,
+		0.497069f,
+		-0.010546f,
+		0.000000f,
+		0.109300f,
+		0.993700f,
+		-0.021700f,
+		0.531300f,
+		0.965500f,
+		0.054058f,
+		0.497069f,
+		0.000000f,
+		0.000000f,
+		0.111500f,
+		0.993700f,
+		0.000000f,
+		0.500000f,
+		0.965500f,
+		0.105419f,
+		0.488310f,
+		-0.020969f,
+		0.000000f,
+		0.214000f,
+		0.975900f,
+		-0.042500f,
+		0.531300f,
+		0.931000f,
+		0.054058f,
+		0.497069f,
+		0.000000f,
+		0.000000f,
+		0.111500f,
+		0.993700f,
+		0.000000f,
+		0.500000f,
+		0.965500f,
+		0.107484f,
+		0.488310f,
+		0.000000f,
+		0.000000f,
+		0.218200f,
+		0.975900f,
+		0.000000f,
+		0.500000f,
+		0.931000f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.495500f,
+		0.051000f,
+		0.053020f,
+		-0.497069f,
+		-0.010546f,
+		0.000000f,
+		0.109300f,
+		-0.993700f,
+		-0.021700f,
+		0.454900f,
+		0.053800f,
+		0.054059f,
+		-0.497069f,
+		0.000000f,
+		0.000000f,
+		0.111500f,
+		-0.993700f,
+		0.000000f,
+		0.452300f,
+		0.053800f,
+		0.483932f,
+		-0.080891f,
+		-0.096260f,
+		0.000000f,
+		0.967900f,
+		-0.161200f,
+		-0.192500f,
+		0.531200f,
+		0.448300f,
+		0.489673f,
+		-0.027069f,
+		-0.097402f,
+		0.000000f,
+		0.979300f,
+		-0.054000f,
+		-0.194800f,
+		0.531200f,
+		0.482800f,
+		0.499265f,
+		-0.027069f,
+		0.000000f,
+		0.000000f,
+		0.998500f,
+		-0.054000f,
+		0.000000f,
+		0.500000f,
+		0.482800f,
+		0.483932f,
+		-0.080891f,
+		-0.096260f,
+		0.000000f,
+		0.967900f,
+		-0.161200f,
+		-0.192500f,
+		0.531200f,
+		0.448300f,
+		0.499265f,
+		-0.027069f,
+		0.000000f,
+		0.000000f,
+		0.998500f,
+		-0.054000f,
+		0.000000f,
+		0.500000f,
+		0.482800f,
+		0.493412f,
+		-0.080891f,
+		0.000000f,
+		0.000000f,
+		0.986900f,
+		-0.161200f,
+		0.000000f,
+		0.500000f,
+		0.448300f,
+		0.156582f,
+		0.473826f,
+		-0.031146f,
+		0.000000f,
+		0.316100f,
+		0.946600f,
+		-0.062900f,
+		0.531300f,
+		0.896600f,
+		0.105419f,
+		0.488310f,
+		-0.020969f,
+		0.000000f,
+		0.214000f,
+		0.975900f,
+		-0.042500f,
+		0.531300f,
+		0.931000f,
+		0.107484f,
+		0.488310f,
+		0.000000f,
+		0.000000f,
+		0.218200f,
+		0.975900f,
+		0.000000f,
+		0.500000f,
+		0.931000f,
+		0.156582f,
+		0.473826f,
+		-0.031146f,
+		0.000000f,
+		0.316100f,
+		0.946600f,
+		-0.062900f,
+		0.531300f,
+		0.896600f,
+		0.107484f,
+		0.488310f,
+		0.000000f,
+		0.000000f,
+		0.218200f,
+		0.975900f,
+		0.000000f,
+		0.500000f,
+		0.931000f,
+		0.159650f,
+		0.473826f,
+		0.000000f,
+		0.000000f,
+		0.322300f,
+		0.946600f,
+		0.000000f,
+		0.500000f,
+		0.896600f,
+		0.472517f,
+		-0.133764f,
+		-0.093989f,
+		0.000000f,
+		0.945200f,
+		-0.266600f,
+		-0.188000f,
+		0.531200f,
+		0.413800f,
+		0.483932f,
+		-0.080891f,
+		-0.096260f,
+		0.000000f,
+		0.967900f,
+		-0.161200f,
+		-0.192500f,
+		0.531200f,
+		0.448300f,
+		0.493412f,
+		-0.080891f,
+		0.000000f,
+		0.000000f,
+		0.986900f,
+		-0.161200f,
+		0.000000f,
+		0.500000f,
+		0.448300f,
+		0.472517f,
+		-0.133764f,
+		-0.093989f,
+		0.000000f,
+		0.945200f,
+		-0.266600f,
+		-0.188000f,
+		0.531200f,
+		0.413800f,
+		0.493412f,
+		-0.080891f,
+		0.000000f,
+		0.000000f,
+		0.986900f,
+		-0.161200f,
+		0.000000f,
+		0.500000f,
+		0.448300f,
+		0.481774f,
+		-0.133764f,
+		0.000000f,
+		0.000000f,
+		0.963800f,
+		-0.266600f,
+		0.000000f,
+		0.500000f,
+		0.413800f,
+		0.205910f,
+		0.453788f,
+		-0.040958f,
+		0.000000f,
+		0.414500f,
+		0.906300f,
+		-0.082400f,
+		0.531300f,
+		0.862100f,
+		0.156582f,
+		0.473826f,
+		-0.031146f,
+		0.000000f,
+		0.316100f,
+		0.946600f,
+		-0.062900f,
+		0.531300f,
+		0.896600f,
+		0.159650f,
+		0.473826f,
+		0.000000f,
+		0.000000f,
+		0.322300f,
+		0.946600f,
+		0.000000f,
+		0.500000f,
+		0.896600f,
+		0.205910f,
+		0.453788f,
+		-0.040958f,
+		0.000000f,
+		0.414500f,
+		0.906300f,
+		-0.082400f,
+		0.531300f,
+		0.862100f,
+		0.159650f,
+		0.473826f,
+		0.000000f,
+		0.000000f,
+		0.322300f,
+		0.946600f,
+		0.000000f,
+		0.500000f,
+		0.896600f,
+		0.209944f,
+		0.453788f,
+		0.000000f,
+		0.000000f,
+		0.422700f,
+		0.906300f,
+		0.000000f,
+		0.500000f,
+		0.862100f,
+		0.455563f,
+		-0.185069f,
+		-0.090617f,
+		0.000000f,
+		0.911600f,
+		-0.369000f,
+		-0.181300f,
+		0.531200f,
+		0.379300f,
+		0.472517f,
+		-0.133764f,
+		-0.093989f,
+		0.000000f,
+		0.945200f,
+		-0.266600f,
+		-0.188000f,
+		0.531200f,
+		0.413800f,
+		0.481774f,
+		-0.133764f,
+		0.000000f,
+		0.000000f,
+		0.963800f,
+		-0.266600f,
+		0.000000f,
+		0.500000f,
+		0.413800f,
+		0.455563f,
+		-0.185069f,
+		-0.090617f,
+		0.000000f,
+		0.911600f,
+		-0.369000f,
+		-0.181300f,
+		0.531200f,
+		0.379300f,
+		0.481774f,
+		-0.133764f,
+		0.000000f,
+		0.000000f,
+		0.963800f,
+		-0.266600f,
+		0.000000f,
+		0.500000f,
+		0.413800f,
+		0.464487f,
+		-0.185069f,
+		0.000000f,
+		0.000000f,
+		0.929400f,
+		-0.369000f,
+		0.000000f,
+		0.500000f,
+		0.379300f,
+		0.252823f,
+		0.428429f,
+		-0.050290f,
+		0.000000f,
+		0.508100f,
+		0.855300f,
+		-0.101000f,
+		0.531300f,
+		0.827600f,
+		0.205910f,
+		0.453788f,
+		-0.040958f,
+		0.000000f,
+		0.414500f,
+		0.906300f,
+		-0.082400f,
+		0.531300f,
+		0.862100f,
+		0.209944f,
+		0.453788f,
+		0.000000f,
+		0.000000f,
+		0.422700f,
+		0.906300f,
+		0.000000f,
+		0.500000f,
+		0.862100f,
+		0.252823f,
+		0.428429f,
+		-0.050290f,
+		0.000000f,
+		0.508100f,
+		0.855300f,
+		-0.101000f,
+		0.531300f,
+		0.827600f,
+		0.209944f,
+		0.453788f,
+		0.000000f,
+		0.000000f,
+		0.422700f,
+		0.906300f,
+		0.000000f,
+		0.500000f,
+		0.862100f,
+		0.257776f,
+		0.428429f,
+		-0.000000f,
+		0.000000f,
+		0.518000f,
+		0.855300f,
+		0.000000f,
+		0.500000f,
+		0.827600f,
+		0.107484f,
+		-0.488310f,
+		0.000000f,
+		0.000000f,
+		0.218200f,
+		-0.975900f,
+		0.000000f,
+		0.500000f,
+		0.069000f,
+		0.159650f,
+		-0.473826f,
+		-0.000000f,
+		0.000000f,
+		0.322300f,
+		-0.946600f,
+		0.000000f,
+		0.500000f,
+		0.103400f,
+		0.156583f,
+		-0.473826f,
+		0.031147f,
+		0.000000f,
+		0.316100f,
+		-0.946600f,
+		0.062900f,
+		0.468700f,
+		0.103400f,
+		0.107484f,
+		-0.488310f,
+		0.000000f,
+		0.000000f,
+		0.218200f,
+		-0.975900f,
+		0.000000f,
+		0.500000f,
+		0.069000f,
+		0.156583f,
+		-0.473826f,
+		0.031147f,
+		0.000000f,
+		0.316100f,
+		-0.946600f,
+		0.062900f,
+		0.468700f,
+		0.103400f,
+		0.105420f,
+		-0.488310f,
+		0.020970f,
+		0.000000f,
+		0.214000f,
+		-0.975900f,
+		0.042500f,
+		0.468700f,
+		0.069000f,
+		0.499265f,
+		0.027069f,
+		0.000000f,
+		0.000000f,
+		0.998500f,
+		0.054000f,
+		0.000000f,
+		0.500000f,
+		0.517200f,
+		0.493412f,
+		0.080891f,
+		0.000000f,
+		0.000000f,
+		0.986900f,
+		0.161200f,
+		0.000000f,
+		0.500000f,
+		0.551700f,
+		0.483932f,
+		0.080891f,
+		0.096260f,
+		0.000000f,
+		0.967900f,
+		0.161200f,
+		0.192500f,
+		0.468700f,
+		0.551700f,
+		0.499265f,
+		0.027069f,
+		0.000000f,
+		0.000000f,
+		0.998500f,
+		0.054000f,
+		0.000000f,
+		0.500000f,
+		0.517200f,
+		0.483932f,
+		0.080891f,
+		0.096260f,
+		0.000000f,
+		0.967900f,
+		0.161200f,
+		0.192500f,
+		0.468700f,
+		0.551700f,
+		0.489673f,
+		0.027069f,
+		0.097402f,
+		0.000000f,
+		0.979300f,
+		0.054000f,
+		0.194800f,
+		0.468700f,
+		0.517200f,
+		0.054058f,
+		0.497069f,
+		0.000000f,
+		0.000000f,
+		0.111500f,
+		0.993700f,
+		0.000000f,
+		0.456200f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.482000f,
+		0.960300f,
+		0.053020f,
+		0.497069f,
+		0.010546f,
+		0.000000f,
+		0.109300f,
+		0.993700f,
+		0.021700f,
+		0.458000f,
+		0.962300f,
+		0.054059f,
+		-0.497069f,
+		0.000000f,
+		0.000000f,
+		0.111500f,
+		-0.993700f,
+		0.000000f,
+		0.500000f,
+		0.034500f,
+		0.107484f,
+		-0.488310f,
+		0.000000f,
+		0.000000f,
+		0.218200f,
+		-0.975900f,
+		0.000000f,
+		0.500000f,
+		0.069000f,
+		0.105420f,
+		-0.488310f,
+		0.020970f,
+		0.000000f,
+		0.214000f,
+		-0.975900f,
+		0.042500f,
+		0.468700f,
+		0.069000f,
+		0.054059f,
+		-0.497069f,
+		0.000000f,
+		0.000000f,
+		0.111500f,
+		-0.993700f,
+		0.000000f,
+		0.500000f,
+		0.034500f,
+		0.105420f,
+		-0.488310f,
+		0.020970f,
+		0.000000f,
+		0.214000f,
+		-0.975900f,
+		0.042500f,
+		0.468700f,
+		0.069000f,
+		0.053020f,
+		-0.497069f,
+		0.010546f,
+		0.000000f,
+		0.109300f,
+		-0.993700f,
+		0.021700f,
+		0.468700f,
+		0.034500f,
+		0.499265f,
+		-0.027069f,
+		0.000000f,
+		0.000000f,
+		0.998500f,
+		-0.054000f,
+		0.000000f,
+		0.500000f,
+		0.482800f,
+		0.499265f,
+		0.027069f,
+		0.000000f,
+		0.000000f,
+		0.998500f,
+		0.054000f,
+		0.000000f,
+		0.500000f,
+		0.517200f,
+		0.489673f,
+		0.027069f,
+		0.097402f,
+		0.000000f,
+		0.979300f,
+		0.054000f,
+		0.194800f,
+		0.468700f,
+		0.517200f,
+		0.499265f,
+		-0.027069f,
+		0.000000f,
+		0.000000f,
+		0.998500f,
+		-0.054000f,
+		0.000000f,
+		0.500000f,
+		0.482800f,
+		0.489673f,
+		0.027069f,
+		0.097402f,
+		0.000000f,
+		0.979300f,
+		0.054000f,
+		0.194800f,
+		0.468700f,
+		0.517200f,
+		0.489673f,
+		-0.027069f,
+		0.097402f,
+		0.000000f,
+		0.979300f,
+		-0.054000f,
+		0.194800f,
+		0.468700f,
+		0.482800f,
+		0.107484f,
+		0.488310f,
+		0.000000f,
+		0.000000f,
+		0.218200f,
+		0.975900f,
+		0.000000f,
+		0.500000f,
+		0.931000f,
+		0.054058f,
+		0.497069f,
+		0.000000f,
+		0.000000f,
+		0.111500f,
+		0.993700f,
+		0.000000f,
+		0.500000f,
+		0.965500f,
+		0.053020f,
+		0.497069f,
+		0.010546f,
+		0.000000f,
+		0.109300f,
+		0.993700f,
+		0.021700f,
+		0.468700f,
+		0.965500f,
+		0.107484f,
+		0.488310f,
+		0.000000f,
+		0.000000f,
+		0.218200f,
+		0.975900f,
+		0.000000f,
+		0.500000f,
+		0.931000f,
+		0.053020f,
+		0.497069f,
+		0.010546f,
+		0.000000f,
+		0.109300f,
+		0.993700f,
+		0.021700f,
+		0.468700f,
+		0.965500f,
+		0.105419f,
+		0.488310f,
+		0.020970f,
+		0.000000f,
+		0.214000f,
+		0.975900f,
+		0.042500f,
+		0.468700f,
+		0.931000f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.411700f,
+		0.051000f,
+		0.054059f,
+		-0.497069f,
+		0.000000f,
+		0.000000f,
+		0.111500f,
+		-0.993700f,
+		0.000000f,
+		0.452300f,
+		0.053800f,
+		0.053020f,
+		-0.497069f,
+		0.010546f,
+		0.000000f,
+		0.109300f,
+		-0.993700f,
+		0.021700f,
+		0.449700f,
+		0.053800f,
+		0.493412f,
+		-0.080891f,
+		0.000000f,
+		0.000000f,
+		0.986900f,
+		-0.161200f,
+		0.000000f,
+		0.500000f,
+		0.448300f,
+		0.499265f,
+		-0.027069f,
+		0.000000f,
+		0.000000f,
+		0.998500f,
+		-0.054000f,
+		0.000000f,
+		0.500000f,
+		0.482800f,
+		0.489673f,
+		-0.027069f,
+		0.097402f,
+		0.000000f,
+		0.979300f,
+		-0.054000f,
+		0.194800f,
+		0.468700f,
+		0.482800f,
+		0.493412f,
+		-0.080891f,
+		0.000000f,
+		0.000000f,
+		0.986900f,
+		-0.161200f,
+		0.000000f,
+		0.500000f,
+		0.448300f,
+		0.489673f,
+		-0.027069f,
+		0.097402f,
+		0.000000f,
+		0.979300f,
+		-0.054000f,
+		0.194800f,
+		0.468700f,
+		0.482800f,
+		0.483932f,
+		-0.080891f,
+		0.096260f,
+		0.000000f,
+		0.967900f,
+		-0.161200f,
+		0.192500f,
+		0.468700f,
+		0.448300f,
+		0.159650f,
+		0.473826f,
+		0.000000f,
+		0.000000f,
+		0.322300f,
+		0.946600f,
+		0.000000f,
+		0.500000f,
+		0.896600f,
+		0.107484f,
+		0.488310f,
+		0.000000f,
+		0.000000f,
+		0.218200f,
+		0.975900f,
+		0.000000f,
+		0.500000f,
+		0.931000f,
+		0.105419f,
+		0.488310f,
+		0.020970f,
+		0.000000f,
+		0.214000f,
+		0.975900f,
+		0.042500f,
+		0.468700f,
+		0.931000f,
+		0.159650f,
+		0.473826f,
+		0.000000f,
+		0.000000f,
+		0.322300f,
+		0.946600f,
+		0.000000f,
+		0.500000f,
+		0.896600f,
+		0.105419f,
+		0.488310f,
+		0.020970f,
+		0.000000f,
+		0.214000f,
+		0.975900f,
+		0.042500f,
+		0.468700f,
+		0.931000f,
+		0.156582f,
+		0.473826f,
+		0.031146f,
+		0.000000f,
+		0.316100f,
+		0.946600f,
+		0.062900f,
+		0.468700f,
+		0.896600f,
+		0.481774f,
+		-0.133764f,
+		0.000000f,
+		0.000000f,
+		0.963800f,
+		-0.266600f,
+		0.000000f,
+		0.500000f,
+		0.413800f,
+		0.493412f,
+		-0.080891f,
+		0.000000f,
+		0.000000f,
+		0.986900f,
+		-0.161200f,
+		0.000000f,
+		0.500000f,
+		0.448300f,
+		0.483932f,
+		-0.080891f,
+		0.096260f,
+		0.000000f,
+		0.967900f,
+		-0.161200f,
+		0.192500f,
+		0.468700f,
+		0.448300f,
+		0.481774f,
+		-0.133764f,
+		0.000000f,
+		0.000000f,
+		0.963800f,
+		-0.266600f,
+		0.000000f,
+		0.500000f,
+		0.413800f,
+		0.483932f,
+		-0.080891f,
+		0.096260f,
+		0.000000f,
+		0.967900f,
+		-0.161200f,
+		0.192500f,
+		0.468700f,
+		0.448300f,
+		0.472517f,
+		-0.133764f,
+		0.093989f,
+		0.000000f,
+		0.945200f,
+		-0.266600f,
+		0.188000f,
+		0.468700f,
+		0.413800f,
+		0.209944f,
+		0.453788f,
+		0.000000f,
+		0.000000f,
+		0.422700f,
+		0.906300f,
+		0.000000f,
+		0.500000f,
+		0.862100f,
+		0.159650f,
+		0.473826f,
+		0.000000f,
+		0.000000f,
+		0.322300f,
+		0.946600f,
+		0.000000f,
+		0.500000f,
+		0.896600f,
+		0.156582f,
+		0.473826f,
+		0.031146f,
+		0.000000f,
+		0.316100f,
+		0.946600f,
+		0.062900f,
+		0.468700f,
+		0.896600f,
+		0.209944f,
+		0.453788f,
+		0.000000f,
+		0.000000f,
+		0.422700f,
+		0.906300f,
+		0.000000f,
+		0.500000f,
+		0.862100f,
+		0.156582f,
+		0.473826f,
+		0.031146f,
+		0.000000f,
+		0.316100f,
+		0.946600f,
+		0.062900f,
+		0.468700f,
+		0.896600f,
+		0.205910f,
+		0.453788f,
+		0.040958f,
+		0.000000f,
+		0.414500f,
+		0.906300f,
+		0.082400f,
+		0.468700f,
+		0.862100f,
+		0.464487f,
+		-0.185069f,
+		0.000000f,
+		0.000000f,
+		0.929400f,
+		-0.369000f,
+		0.000000f,
+		0.500000f,
+		0.379300f,
+		0.481774f,
+		-0.133764f,
+		0.000000f,
+		0.000000f,
+		0.963800f,
+		-0.266600f,
+		0.000000f,
+		0.500000f,
+		0.413800f,
+		0.472517f,
+		-0.133764f,
+		0.093989f,
+		0.000000f,
+		0.945200f,
+		-0.266600f,
+		0.188000f,
+		0.468700f,
+		0.413800f,
+		0.464487f,
+		-0.185069f,
+		0.000000f,
+		0.000000f,
+		0.929400f,
+		-0.369000f,
+		0.000000f,
+		0.500000f,
+		0.379300f,
+		0.472517f,
+		-0.133764f,
+		0.093989f,
+		0.000000f,
+		0.945200f,
+		-0.266600f,
+		0.188000f,
+		0.468700f,
+		0.413800f,
+		0.455563f,
+		-0.185069f,
+		0.090617f,
+		0.000000f,
+		0.911600f,
+		-0.369000f,
+		0.181300f,
+		0.468700f,
+		0.379300f,
+		0.257776f,
+		0.428429f,
+		-0.000000f,
+		0.000000f,
+		0.518000f,
+		0.855300f,
+		0.000000f,
+		0.500000f,
+		0.827600f,
+		0.209944f,
+		0.453788f,
+		0.000000f,
+		0.000000f,
+		0.422700f,
+		0.906300f,
+		0.000000f,
+		0.500000f,
+		0.862100f,
+		0.205910f,
+		0.453788f,
+		0.040958f,
+		0.000000f,
+		0.414500f,
+		0.906300f,
+		0.082400f,
+		0.468700f,
+		0.862100f,
+		0.257776f,
+		0.428429f,
+		-0.000000f,
+		0.000000f,
+		0.518000f,
+		0.855300f,
+		0.000000f,
+		0.500000f,
+		0.827600f,
+		0.205910f,
+		0.453788f,
+		0.040958f,
+		0.000000f,
+		0.414500f,
+		0.906300f,
+		0.082400f,
+		0.468700f,
+		0.862100f,
+		0.252823f,
+		0.428429f,
+		0.050290f,
+		0.000000f,
+		0.508100f,
+		0.855300f,
+		0.101000f,
+		0.468700f,
+		0.827600f,
+		0.441755f,
+		-0.234204f,
+		0.000000f,
+		0.000000f,
+		0.884200f,
+		-0.467000f,
+		0.000000f,
+		0.500000f,
+		0.344800f,
+		0.464487f,
+		-0.185069f,
+		0.000000f,
+		0.000000f,
+		0.929400f,
+		-0.369000f,
+		0.000000f,
+		0.500000f,
+		0.379300f,
+		0.455563f,
+		-0.185069f,
+		0.090617f,
+		0.000000f,
+		0.911600f,
+		-0.369000f,
+		0.181300f,
+		0.468700f,
+		0.379300f,
+		0.441755f,
+		-0.234204f,
+		0.000000f,
+		0.000000f,
+		0.884200f,
+		-0.467000f,
+		0.000000f,
+		0.500000f,
+		0.344800f,
+		0.455563f,
+		-0.185069f,
+		0.090617f,
+		0.000000f,
+		0.911600f,
+		-0.369000f,
+		0.181300f,
+		0.468700f,
+		0.379300f,
+		0.433267f,
+		-0.234204f,
+		0.086182f,
+		0.000000f,
+		0.867200f,
+		-0.467000f,
+		0.172500f,
+		0.468700f,
+		0.344800f,
+		0.302586f,
+		0.398046f,
+		0.000000f,
+		0.000000f,
+		0.607300f,
+		0.794500f,
+		0.000000f,
+		0.500000f,
+		0.793100f,
+		0.257776f,
+		0.428429f,
+		-0.000000f,
+		0.000000f,
+		0.518000f,
+		0.855300f,
+		0.000000f,
+		0.500000f,
+		0.827600f,
+		0.252823f,
+		0.428429f,
+		0.050290f,
+		0.000000f,
+		0.508100f,
+		0.855300f,
+		0.101000f,
+		0.468700f,
+		0.827600f,
+		0.302586f,
+		0.398046f,
+		0.000000f,
+		0.000000f,
+		0.607300f,
+		0.794500f,
+		0.000000f,
+		0.500000f,
+		0.793100f,
+		0.252823f,
+		0.428429f,
+		0.050290f,
+		0.000000f,
+		0.508100f,
+		0.855300f,
+		0.101000f,
+		0.468700f,
+		0.827600f,
+		0.296772f,
+		0.398046f,
+		0.059032f,
+		0.000000f,
+		0.595600f,
+		0.794500f,
+		0.118500f,
+		0.468700f,
+		0.793100f,
+		0.413844f,
+		-0.280594f,
+		0.000000f,
+		0.000000f,
+		0.828700f,
+		-0.559600f,
+		0.000000f,
+		0.500000f,
+		0.310300f,
+		0.441755f,
+		-0.234204f,
+		0.000000f,
+		0.000000f,
+		0.884200f,
+		-0.467000f,
+		0.000000f,
+		0.500000f,
+		0.344800f,
+		0.433267f,
+		-0.234204f,
+		0.086182f,
+		0.000000f,
+		0.867200f,
+		-0.467000f,
+		0.172500f,
+		0.468700f,
+		0.344800f,
+		0.413844f,
+		-0.280594f,
+		0.000000f,
+		0.000000f,
+		0.828700f,
+		-0.559600f,
+		0.000000f,
+		0.500000f,
+		0.310300f,
+		0.433267f,
+		-0.234204f,
+		0.086182f,
+		0.000000f,
+		0.867200f,
+		-0.467000f,
+		0.172500f,
+		0.468700f,
+		0.344800f,
+		0.405892f,
+		-0.280594f,
+		0.080737f,
+		0.000000f,
+		0.812800f,
+		-0.559600f,
+		0.161700f,
+		0.468700f,
+		0.310300f,
+		0.343848f,
+		0.362998f,
+		-0.000000f,
+		0.000000f,
+		0.689400f,
+		0.724300f,
+		0.000000f,
+		0.500000f,
+		0.758600f,
+		0.302586f,
+		0.398046f,
+		0.000000f,
+		0.000000f,
+		0.607300f,
+		0.794500f,
+		0.000000f,
+		0.500000f,
+		0.793100f,
+		0.296772f,
+		0.398046f,
+		0.059032f,
+		0.000000f,
+		0.595600f,
+		0.794500f,
+		0.118500f,
+		0.468700f,
+		0.793100f,
+		0.343848f,
+		0.362998f,
+		-0.000000f,
+		0.000000f,
+		0.689400f,
+		0.724300f,
+		0.000000f,
+		0.500000f,
+		0.758600f,
+		0.296772f,
+		0.398046f,
+		0.059032f,
+		0.000000f,
+		0.595600f,
+		0.794500f,
+		0.118500f,
+		0.468700f,
+		0.793100f,
+		0.337242f,
+		0.362998f,
+		0.067082f,
+		0.000000f,
+		0.676200f,
+		0.724300f,
+		0.134500f,
+		0.468800f,
+		0.758600f,
+		0.381080f,
+		-0.323693f,
+		0.000000f,
+		0.000000f,
+		0.763500f,
+		-0.645700f,
+		0.000000f,
+		0.500000f,
+		0.275900f,
+		0.413844f,
+		-0.280594f,
+		0.000000f,
+		0.000000f,
+		0.828700f,
+		-0.559600f,
+		0.000000f,
+		0.500000f,
+		0.310300f,
+		0.405892f,
+		-0.280594f,
+		0.080737f,
+		0.000000f,
+		0.812800f,
+		-0.559600f,
+		0.161700f,
+		0.468700f,
+		0.310300f,
+		0.381080f,
+		-0.323693f,
+		0.000000f,
+		0.000000f,
+		0.763500f,
+		-0.645700f,
+		0.000000f,
+		0.500000f,
+		0.275900f,
+		0.405892f,
+		-0.280594f,
+		0.080737f,
+		0.000000f,
+		0.812800f,
+		-0.559600f,
+		0.161700f,
+		0.468700f,
+		0.310300f,
+		0.373758f,
+		-0.323693f,
+		0.074345f,
+		0.000000f,
+		0.748900f,
+		-0.645700f,
+		0.149000f,
+		0.468700f,
+		0.275900f,
+		0.381080f,
+		0.323693f,
+		0.000000f,
+		0.000000f,
+		0.763500f,
+		0.645700f,
+		0.000000f,
+		0.500000f,
+		0.724100f,
+		0.343848f,
+		0.362998f,
+		-0.000000f,
+		0.000000f,
+		0.689400f,
+		0.724300f,
+		0.000000f,
+		0.500000f,
+		0.758600f,
+		0.337242f,
+		0.362998f,
+		0.067082f,
+		0.000000f,
+		0.676200f,
+		0.724300f,
+		0.134500f,
+		0.468800f,
+		0.758600f,
+		0.381080f,
+		0.323693f,
+		0.000000f,
+		0.000000f,
+		0.763500f,
+		0.645700f,
+		0.000000f,
+		0.500000f,
+		0.724100f,
+		0.337242f,
+		0.362998f,
+		0.067082f,
+		0.000000f,
+		0.676200f,
+		0.724300f,
+		0.134500f,
+		0.468800f,
+		0.758600f,
+		0.373758f,
+		0.323693f,
+		0.074345f,
+		0.000000f,
+		0.748900f,
+		0.645700f,
+		0.149000f,
+		0.468700f,
+		0.724100f,
+		0.343849f,
+		-0.362998f,
+		0.000000f,
+		0.000000f,
+		0.689400f,
+		-0.724300f,
+		0.000000f,
+		0.500000f,
+		0.241400f,
+		0.381080f,
+		-0.323693f,
+		0.000000f,
+		0.000000f,
+		0.763500f,
+		-0.645700f,
+		0.000000f,
+		0.500000f,
+		0.275900f,
+		0.373758f,
+		-0.323693f,
+		0.074345f,
+		0.000000f,
+		0.748900f,
+		-0.645700f,
+		0.149000f,
+		0.468700f,
+		0.275900f,
+		0.343849f,
+		-0.362998f,
+		0.000000f,
+		0.000000f,
+		0.689400f,
+		-0.724300f,
+		0.000000f,
+		0.500000f,
+		0.241400f,
+		0.373758f,
+		-0.323693f,
+		0.074345f,
+		0.000000f,
+		0.748900f,
+		-0.645700f,
+		0.149000f,
+		0.468700f,
+		0.275900f,
+		0.337242f,
+		-0.362998f,
+		0.067082f,
+		0.000000f,
+		0.676200f,
+		-0.724300f,
+		0.134500f,
+		0.468700f,
+		0.241400f,
+		0.413844f,
+		0.280594f,
+		0.000000f,
+		0.000000f,
+		0.828700f,
+		0.559600f,
+		0.000000f,
+		0.500000f,
+		0.689700f,
+		0.381080f,
+		0.323693f,
+		0.000000f,
+		0.000000f,
+		0.763500f,
+		0.645700f,
+		0.000000f,
+		0.500000f,
+		0.724100f,
+		0.373758f,
+		0.323693f,
+		0.074345f,
+		0.000000f,
+		0.748900f,
+		0.645700f,
+		0.149000f,
+		0.468700f,
+		0.724100f,
+		0.413844f,
+		0.280594f,
+		0.000000f,
+		0.000000f,
+		0.828700f,
+		0.559600f,
+		0.000000f,
+		0.500000f,
+		0.689700f,
+		0.373758f,
+		0.323693f,
+		0.074345f,
+		0.000000f,
+		0.748900f,
+		0.645700f,
+		0.149000f,
+		0.468700f,
+		0.724100f,
+		0.405892f,
+		0.280594f,
+		0.080737f,
+		0.000000f,
+		0.812800f,
+		0.559600f,
+		0.161700f,
+		0.468700f,
+		0.689700f,
+		0.302586f,
+		-0.398046f,
+		0.000000f,
+		0.000000f,
+		0.607300f,
+		-0.794500f,
+		0.000000f,
+		0.500000f,
+		0.206900f,
+		0.343849f,
+		-0.362998f,
+		0.000000f,
+		0.000000f,
+		0.689400f,
+		-0.724300f,
+		0.000000f,
+		0.500000f,
+		0.241400f,
+		0.337242f,
+		-0.362998f,
+		0.067082f,
+		0.000000f,
+		0.676200f,
+		-0.724300f,
+		0.134500f,
+		0.468700f,
+		0.241400f,
+		0.302586f,
+		-0.398046f,
+		0.000000f,
+		0.000000f,
+		0.607300f,
+		-0.794500f,
+		0.000000f,
+		0.500000f,
+		0.206900f,
+		0.337242f,
+		-0.362998f,
+		0.067082f,
+		0.000000f,
+		0.676200f,
+		-0.724300f,
+		0.134500f,
+		0.468700f,
+		0.241400f,
+		0.296772f,
+		-0.398046f,
+		0.059032f,
+		0.000000f,
+		0.595600f,
+		-0.794500f,
+		0.118500f,
+		0.468700f,
+		0.206900f,
+		0.441755f,
+		0.234204f,
+		0.000000f,
+		0.000000f,
+		0.884200f,
+		0.467000f,
+		0.000000f,
+		0.500000f,
+		0.655200f,
+		0.413844f,
+		0.280594f,
+		0.000000f,
+		0.000000f,
+		0.828700f,
+		0.559600f,
+		0.000000f,
+		0.500000f,
+		0.689700f,
+		0.405892f,
+		0.280594f,
+		0.080737f,
+		0.000000f,
+		0.812800f,
+		0.559600f,
+		0.161700f,
+		0.468700f,
+		0.689700f,
+		0.441755f,
+		0.234204f,
+		0.000000f,
+		0.000000f,
+		0.884200f,
+		0.467000f,
+		0.000000f,
+		0.500000f,
+		0.655200f,
+		0.405892f,
+		0.280594f,
+		0.080737f,
+		0.000000f,
+		0.812800f,
+		0.559600f,
+		0.161700f,
+		0.468700f,
+		0.689700f,
+		0.433267f,
+		0.234204f,
+		0.086182f,
+		0.000000f,
+		0.867200f,
+		0.467000f,
+		0.172500f,
+		0.468700f,
+		0.655200f,
+		0.257776f,
+		-0.428429f,
+		0.000000f,
+		0.000000f,
+		0.518000f,
+		-0.855300f,
+		0.000000f,
+		0.500000f,
+		0.172400f,
+		0.302586f,
+		-0.398046f,
+		0.000000f,
+		0.000000f,
+		0.607300f,
+		-0.794500f,
+		0.000000f,
+		0.500000f,
+		0.206900f,
+		0.296772f,
+		-0.398046f,
+		0.059032f,
+		0.000000f,
+		0.595600f,
+		-0.794500f,
+		0.118500f,
+		0.468700f,
+		0.206900f,
+		0.257776f,
+		-0.428429f,
+		0.000000f,
+		0.000000f,
+		0.518000f,
+		-0.855300f,
+		0.000000f,
+		0.500000f,
+		0.172400f,
+		0.296772f,
+		-0.398046f,
+		0.059032f,
+		0.000000f,
+		0.595600f,
+		-0.794500f,
+		0.118500f,
+		0.468700f,
+		0.206900f,
+		0.252823f,
+		-0.428429f,
+		0.050290f,
+		0.000000f,
+		0.508100f,
+		-0.855300f,
+		0.101000f,
+		0.468700f,
+		0.172400f,
+		0.464487f,
+		0.185069f,
+		0.000000f,
+		0.000000f,
+		0.929400f,
+		0.369000f,
+		0.000000f,
+		0.500000f,
+		0.620700f,
+		0.441755f,
+		0.234204f,
+		0.000000f,
+		0.000000f,
+		0.884200f,
+		0.467000f,
+		0.000000f,
+		0.500000f,
+		0.655200f,
+		0.433267f,
+		0.234204f,
+		0.086182f,
+		0.000000f,
+		0.867200f,
+		0.467000f,
+		0.172500f,
+		0.468700f,
+		0.655200f,
+		0.464487f,
+		0.185069f,
+		0.000000f,
+		0.000000f,
+		0.929400f,
+		0.369000f,
+		0.000000f,
+		0.500000f,
+		0.620700f,
+		0.433267f,
+		0.234204f,
+		0.086182f,
+		0.000000f,
+		0.867200f,
+		0.467000f,
+		0.172500f,
+		0.468700f,
+		0.655200f,
+		0.455563f,
+		0.185069f,
+		0.090617f,
+		0.000000f,
+		0.911600f,
+		0.369000f,
+		0.181300f,
+		0.468700f,
+		0.620700f,
+		0.209944f,
+		-0.453788f,
+		0.000000f,
+		0.000000f,
+		0.422700f,
+		-0.906300f,
+		0.000000f,
+		0.500000f,
+		0.137900f,
+		0.257776f,
+		-0.428429f,
+		0.000000f,
+		0.000000f,
+		0.518000f,
+		-0.855300f,
+		0.000000f,
+		0.500000f,
+		0.172400f,
+		0.252823f,
+		-0.428429f,
+		0.050290f,
+		0.000000f,
+		0.508100f,
+		-0.855300f,
+		0.101000f,
+		0.468700f,
+		0.172400f,
+		0.209944f,
+		-0.453788f,
+		0.000000f,
+		0.000000f,
+		0.422700f,
+		-0.906300f,
+		0.000000f,
+		0.500000f,
+		0.137900f,
+		0.252823f,
+		-0.428429f,
+		0.050290f,
+		0.000000f,
+		0.508100f,
+		-0.855300f,
+		0.101000f,
+		0.468700f,
+		0.172400f,
+		0.205910f,
+		-0.453788f,
+		0.040958f,
+		0.000000f,
+		0.414500f,
+		-0.906300f,
+		0.082400f,
+		0.468700f,
+		0.137900f,
+		0.481774f,
+		0.133764f,
+		0.000000f,
+		0.000000f,
+		0.963800f,
+		0.266600f,
+		0.000000f,
+		0.500000f,
+		0.586200f,
+		0.464487f,
+		0.185069f,
+		0.000000f,
+		0.000000f,
+		0.929400f,
+		0.369000f,
+		0.000000f,
+		0.500000f,
+		0.620700f,
+		0.455563f,
+		0.185069f,
+		0.090617f,
+		0.000000f,
+		0.911600f,
+		0.369000f,
+		0.181300f,
+		0.468700f,
+		0.620700f,
+		0.481774f,
+		0.133764f,
+		0.000000f,
+		0.000000f,
+		0.963800f,
+		0.266600f,
+		0.000000f,
+		0.500000f,
+		0.586200f,
+		0.455563f,
+		0.185069f,
+		0.090617f,
+		0.000000f,
+		0.911600f,
+		0.369000f,
+		0.181300f,
+		0.468700f,
+		0.620700f,
+		0.472517f,
+		0.133764f,
+		0.093989f,
+		0.000000f,
+		0.945200f,
+		0.266600f,
+		0.188000f,
+		0.468700f,
+		0.586200f,
+		0.159650f,
+		-0.473826f,
+		-0.000000f,
+		0.000000f,
+		0.322300f,
+		-0.946600f,
+		0.000000f,
+		0.500000f,
+		0.103400f,
+		0.209944f,
+		-0.453788f,
+		0.000000f,
+		0.000000f,
+		0.422700f,
+		-0.906300f,
+		0.000000f,
+		0.500000f,
+		0.137900f,
+		0.205910f,
+		-0.453788f,
+		0.040958f,
+		0.000000f,
+		0.414500f,
+		-0.906300f,
+		0.082400f,
+		0.468700f,
+		0.137900f,
+		0.159650f,
+		-0.473826f,
+		-0.000000f,
+		0.000000f,
+		0.322300f,
+		-0.946600f,
+		0.000000f,
+		0.500000f,
+		0.103400f,
+		0.205910f,
+		-0.453788f,
+		0.040958f,
+		0.000000f,
+		0.414500f,
+		-0.906300f,
+		0.082400f,
+		0.468700f,
+		0.137900f,
+		0.156583f,
+		-0.473826f,
+		0.031147f,
+		0.000000f,
+		0.316100f,
+		-0.946600f,
+		0.062900f,
+		0.468700f,
+		0.103400f,
+		0.493412f,
+		0.080891f,
+		0.000000f,
+		0.000000f,
+		0.986900f,
+		0.161200f,
+		0.000000f,
+		0.500000f,
+		0.551700f,
+		0.481774f,
+		0.133764f,
+		0.000000f,
+		0.000000f,
+		0.963800f,
+		0.266600f,
+		0.000000f,
+		0.500000f,
+		0.586200f,
+		0.472517f,
+		0.133764f,
+		0.093989f,
+		0.000000f,
+		0.945200f,
+		0.266600f,
+		0.188000f,
+		0.468700f,
+		0.586200f,
+		0.493412f,
+		0.080891f,
+		0.000000f,
+		0.000000f,
+		0.986900f,
+		0.161200f,
+		0.000000f,
+		0.500000f,
+		0.551700f,
+		0.472517f,
+		0.133764f,
+		0.093989f,
+		0.000000f,
+		0.945200f,
+		0.266600f,
+		0.188000f,
+		0.468700f,
+		0.586200f,
+		0.483932f,
+		0.080891f,
+		0.096260f,
+		0.000000f,
+		0.967900f,
+		0.161200f,
+		0.192500f,
+		0.468700f,
+		0.551700f,
+		0.373758f,
+		0.323693f,
+		0.074345f,
+		0.000000f,
+		0.748900f,
+		0.645700f,
+		0.149000f,
+		0.468700f,
+		0.724100f,
+		0.337242f,
+		0.362998f,
+		0.067082f,
+		0.000000f,
+		0.676200f,
+		0.724300f,
+		0.134500f,
+		0.468800f,
+		0.758600f,
+		0.317674f,
+		0.362998f,
+		0.131585f,
+		0.000000f,
+		0.637000f,
+		0.724300f,
+		0.263800f,
+		0.437500f,
+		0.758600f,
+		0.373758f,
+		0.323693f,
+		0.074345f,
+		0.000000f,
+		0.748900f,
+		0.645700f,
+		0.149000f,
+		0.468700f,
+		0.724100f,
+		0.317674f,
+		0.362998f,
+		0.131585f,
+		0.000000f,
+		0.637000f,
+		0.724300f,
+		0.263800f,
+		0.437500f,
+		0.758600f,
+		0.352072f,
+		0.323693f,
+		0.145833f,
+		0.000000f,
+		0.705400f,
+		0.645700f,
+		0.292200f,
+		0.437500f,
+		0.724100f,
+		0.337242f,
+		-0.362998f,
+		0.067082f,
+		0.000000f,
+		0.676200f,
+		-0.724300f,
+		0.134500f,
+		0.468700f,
+		0.241400f,
+		0.373758f,
+		-0.323693f,
+		0.074345f,
+		0.000000f,
+		0.748900f,
+		-0.645700f,
+		0.149000f,
+		0.468700f,
+		0.275900f,
+		0.352072f,
+		-0.323693f,
+		0.145834f,
+		0.000000f,
+		0.705400f,
+		-0.645700f,
+		0.292200f,
+		0.437500f,
+		0.275900f,
+		0.337242f,
+		-0.362998f,
+		0.067082f,
+		0.000000f,
+		0.676200f,
+		-0.724300f,
+		0.134500f,
+		0.468700f,
+		0.241400f,
+		0.352072f,
+		-0.323693f,
+		0.145834f,
+		0.000000f,
+		0.705400f,
+		-0.645700f,
+		0.292200f,
+		0.437500f,
+		0.275900f,
+		0.317675f,
+		-0.362998f,
+		0.131585f,
+		0.000000f,
+		0.637000f,
+		-0.724300f,
+		0.263800f,
+		0.437500f,
+		0.241400f,
+		0.405892f,
+		0.280594f,
+		0.080737f,
+		0.000000f,
+		0.812800f,
+		0.559600f,
+		0.161700f,
+		0.468700f,
+		0.689700f,
+		0.373758f,
+		0.323693f,
+		0.074345f,
+		0.000000f,
+		0.748900f,
+		0.645700f,
+		0.149000f,
+		0.468700f,
+		0.724100f,
+		0.352072f,
+		0.323693f,
+		0.145833f,
+		0.000000f,
+		0.705400f,
+		0.645700f,
+		0.292200f,
+		0.437500f,
+		0.724100f,
+		0.405892f,
+		0.280594f,
+		0.080737f,
+		0.000000f,
+		0.812800f,
+		0.559600f,
+		0.161700f,
+		0.468700f,
+		0.689700f,
+		0.352072f,
+		0.323693f,
+		0.145833f,
+		0.000000f,
+		0.705400f,
+		0.645700f,
+		0.292200f,
+		0.437500f,
+		0.724100f,
+		0.382342f,
+		0.280594f,
+		0.158371f,
+		0.000000f,
+		0.765600f,
+		0.559600f,
+		0.317100f,
+		0.437500f,
+		0.689700f,
+		0.296772f,
+		-0.398046f,
+		0.059032f,
+		0.000000f,
+		0.595600f,
+		-0.794500f,
+		0.118500f,
+		0.468700f,
+		0.206900f,
+		0.337242f,
+		-0.362998f,
+		0.067082f,
+		0.000000f,
+		0.676200f,
+		-0.724300f,
+		0.134500f,
+		0.468700f,
+		0.241400f,
+		0.317675f,
+		-0.362998f,
+		0.131585f,
+		0.000000f,
+		0.637000f,
+		-0.724300f,
+		0.263800f,
+		0.437500f,
+		0.241400f,
+		0.296772f,
+		-0.398046f,
+		0.059032f,
+		0.000000f,
+		0.595600f,
+		-0.794500f,
+		0.118500f,
+		0.468700f,
+		0.206900f,
+		0.317675f,
+		-0.362998f,
+		0.131585f,
+		0.000000f,
+		0.637000f,
+		-0.724300f,
+		0.263800f,
+		0.437500f,
+		0.241400f,
+		0.279553f,
+		-0.398046f,
+		0.115795f,
+		0.000000f,
+		0.561100f,
+		-0.794500f,
+		0.232400f,
+		0.437500f,
+		0.206900f,
+		0.433267f,
+		0.234204f,
+		0.086182f,
+		0.000000f,
+		0.867200f,
+		0.467000f,
+		0.172500f,
+		0.468700f,
+		0.655200f,
+		0.405892f,
+		0.280594f,
+		0.080737f,
+		0.000000f,
+		0.812800f,
+		0.559600f,
+		0.161700f,
+		0.468700f,
+		0.689700f,
+		0.382342f,
+		0.280594f,
+		0.158371f,
+		0.000000f,
+		0.765600f,
+		0.559600f,
+		0.317100f,
+		0.437500f,
+		0.689700f,
+		0.433267f,
+		0.234204f,
+		0.086182f,
+		0.000000f,
+		0.867200f,
+		0.467000f,
+		0.172500f,
+		0.468700f,
+		0.655200f,
+		0.382342f,
+		0.280594f,
+		0.158371f,
+		0.000000f,
+		0.765600f,
+		0.559600f,
+		0.317100f,
+		0.437500f,
+		0.689700f,
+		0.408128f,
+		0.234204f,
+		0.169052f,
+		0.000000f,
+		0.816900f,
+		0.467000f,
+		0.338400f,
+		0.437500f,
+		0.655200f,
+		0.252823f,
+		-0.428429f,
+		0.050290f,
+		0.000000f,
+		0.508100f,
+		-0.855300f,
+		0.101000f,
+		0.468700f,
+		0.172400f,
+		0.296772f,
+		-0.398046f,
+		0.059032f,
+		0.000000f,
+		0.595600f,
+		-0.794500f,
+		0.118500f,
+		0.468700f,
+		0.206900f,
+		0.279553f,
+		-0.398046f,
+		0.115795f,
+		0.000000f,
+		0.561100f,
+		-0.794500f,
+		0.232400f,
+		0.437500f,
+		0.206900f,
+		0.252823f,
+		-0.428429f,
+		0.050290f,
+		0.000000f,
+		0.508100f,
+		-0.855300f,
+		0.101000f,
+		0.468700f,
+		0.172400f,
+		0.279553f,
+		-0.398046f,
+		0.115795f,
+		0.000000f,
+		0.561100f,
+		-0.794500f,
+		0.232400f,
+		0.437500f,
+		0.206900f,
+		0.238154f,
+		-0.428429f,
+		0.098647f,
+		0.000000f,
+		0.478600f,
+		-0.855300f,
+		0.198200f,
+		0.437500f,
+		0.172400f,
+		0.455563f,
+		0.185069f,
+		0.090617f,
+		0.000000f,
+		0.911600f,
+		0.369000f,
+		0.181300f,
+		0.468700f,
+		0.620700f,
+		0.433267f,
+		0.234204f,
+		0.086182f,
+		0.000000f,
+		0.867200f,
+		0.467000f,
+		0.172500f,
+		0.468700f,
+		0.655200f,
+		0.408128f,
+		0.234204f,
+		0.169052f,
+		0.000000f,
+		0.816900f,
+		0.467000f,
+		0.338400f,
+		0.437500f,
+		0.655200f,
+		0.455563f,
+		0.185069f,
+		0.090617f,
+		0.000000f,
+		0.911600f,
+		0.369000f,
+		0.181300f,
+		0.468700f,
+		0.620700f,
+		0.408128f,
+		0.234204f,
+		0.169052f,
+		0.000000f,
+		0.816900f,
+		0.467000f,
+		0.338400f,
+		0.437500f,
+		0.655200f,
+		0.429130f,
+		0.185069f,
+		0.177752f,
+		0.000000f,
+		0.858700f,
+		0.369000f,
+		0.355700f,
+		0.437500f,
+		0.620700f,
+		0.205910f,
+		-0.453788f,
+		0.040958f,
+		0.000000f,
+		0.414500f,
+		-0.906300f,
+		0.082400f,
+		0.468700f,
+		0.137900f,
+		0.252823f,
+		-0.428429f,
+		0.050290f,
+		0.000000f,
+		0.508100f,
+		-0.855300f,
+		0.101000f,
+		0.468700f,
+		0.172400f,
+		0.238154f,
+		-0.428429f,
+		0.098647f,
+		0.000000f,
+		0.478600f,
+		-0.855300f,
+		0.198200f,
+		0.437500f,
+		0.172400f,
+		0.205910f,
+		-0.453788f,
+		0.040958f,
+		0.000000f,
+		0.414500f,
+		-0.906300f,
+		0.082400f,
+		0.468700f,
+		0.137900f,
+		0.238154f,
+		-0.428429f,
+		0.098647f,
+		0.000000f,
+		0.478600f,
+		-0.855300f,
+		0.198200f,
+		0.437500f,
+		0.172400f,
+		0.193963f,
+		-0.453788f,
+		0.080342f,
+		0.000000f,
+		0.390500f,
+		-0.906300f,
+		0.161700f,
+		0.437500f,
+		0.137900f,
+		0.472517f,
+		0.133764f,
+		0.093989f,
+		0.000000f,
+		0.945200f,
+		0.266600f,
+		0.188000f,
+		0.468700f,
+		0.586200f,
+		0.455563f,
+		0.185069f,
+		0.090617f,
+		0.000000f,
+		0.911600f,
+		0.369000f,
+		0.181300f,
+		0.468700f,
+		0.620700f,
+		0.429130f,
+		0.185069f,
+		0.177752f,
+		0.000000f,
+		0.858700f,
+		0.369000f,
+		0.355700f,
+		0.437500f,
+		0.620700f,
+		0.472517f,
+		0.133764f,
+		0.093989f,
+		0.000000f,
+		0.945200f,
+		0.266600f,
+		0.188000f,
+		0.468700f,
+		0.586200f,
+		0.429130f,
+		0.185069f,
+		0.177752f,
+		0.000000f,
+		0.858700f,
+		0.369000f,
+		0.355700f,
+		0.437500f,
+		0.620700f,
+		0.445101f,
+		0.133764f,
+		0.184367f,
+		0.000000f,
+		0.890400f,
+		0.266600f,
+		0.368800f,
+		0.437500f,
+		0.586200f,
+		0.156583f,
+		-0.473826f,
+		0.031147f,
+		0.000000f,
+		0.316100f,
+		-0.946600f,
+		0.062900f,
+		0.468700f,
+		0.103400f,
+		0.205910f,
+		-0.453788f,
+		0.040958f,
+		0.000000f,
+		0.414500f,
+		-0.906300f,
+		0.082400f,
+		0.468700f,
+		0.137900f,
+		0.193963f,
+		-0.453788f,
+		0.080342f,
+		0.000000f,
+		0.390500f,
+		-0.906300f,
+		0.161700f,
+		0.437500f,
+		0.137900f,
+		0.156583f,
+		-0.473826f,
+		0.031147f,
+		0.000000f,
+		0.316100f,
+		-0.946600f,
+		0.062900f,
+		0.468700f,
+		0.103400f,
+		0.193963f,
+		-0.453788f,
+		0.080342f,
+		0.000000f,
+		0.390500f,
+		-0.906300f,
+		0.161700f,
+		0.437500f,
+		0.137900f,
+		0.147498f,
+		-0.473826f,
+		0.061095f,
+		0.000000f,
+		0.297800f,
+		-0.946600f,
+		0.123300f,
+		0.437500f,
+		0.103400f,
+		0.483932f,
+		0.080891f,
+		0.096260f,
+		0.000000f,
+		0.967900f,
+		0.161200f,
+		0.192500f,
+		0.468700f,
+		0.551700f,
+		0.472517f,
+		0.133764f,
+		0.093989f,
+		0.000000f,
+		0.945200f,
+		0.266600f,
+		0.188000f,
+		0.468700f,
+		0.586200f,
+		0.445101f,
+		0.133764f,
+		0.184367f,
+		0.000000f,
+		0.890400f,
+		0.266600f,
+		0.368800f,
+		0.437500f,
+		0.586200f,
+		0.483932f,
+		0.080891f,
+		0.096260f,
+		0.000000f,
+		0.967900f,
+		0.161200f,
+		0.192500f,
+		0.468700f,
+		0.551700f,
+		0.445101f,
+		0.133764f,
+		0.184367f,
+		0.000000f,
+		0.890400f,
+		0.266600f,
+		0.368800f,
+		0.437500f,
+		0.586200f,
+		0.455853f,
+		0.080891f,
+		0.188821f,
+		0.000000f,
+		0.911800f,
+		0.161200f,
+		0.377700f,
+		0.437500f,
+		0.551700f,
+		0.105420f,
+		-0.488310f,
+		0.020970f,
+		0.000000f,
+		0.214000f,
+		-0.975900f,
+		0.042500f,
+		0.468700f,
+		0.069000f,
+		0.156583f,
+		-0.473826f,
+		0.031147f,
+		0.000000f,
+		0.316100f,
+		-0.946600f,
+		0.062900f,
+		0.468700f,
+		0.103400f,
+		0.147498f,
+		-0.473826f,
+		0.061095f,
+		0.000000f,
+		0.297800f,
+		-0.946600f,
+		0.123300f,
+		0.437500f,
+		0.103400f,
+		0.105420f,
+		-0.488310f,
+		0.020970f,
+		0.000000f,
+		0.214000f,
+		-0.975900f,
+		0.042500f,
+		0.468700f,
+		0.069000f,
+		0.147498f,
+		-0.473826f,
+		0.061095f,
+		0.000000f,
+		0.297800f,
+		-0.946600f,
+		0.123300f,
+		0.437500f,
+		0.103400f,
+		0.099303f,
+		-0.488310f,
+		0.041133f,
+		0.000000f,
+		0.201600f,
+		-0.975900f,
+		0.083500f,
+		0.437500f,
+		0.069000f,
+		0.489673f,
+		0.027069f,
+		0.097402f,
+		0.000000f,
+		0.979300f,
+		0.054000f,
+		0.194800f,
+		0.468700f,
+		0.517200f,
+		0.483932f,
+		0.080891f,
+		0.096260f,
+		0.000000f,
+		0.967900f,
+		0.161200f,
+		0.192500f,
+		0.468700f,
+		0.551700f,
+		0.455853f,
+		0.080891f,
+		0.188821f,
+		0.000000f,
+		0.911800f,
+		0.161200f,
+		0.377700f,
+		0.437500f,
+		0.551700f,
+		0.489673f,
+		0.027069f,
+		0.097402f,
+		0.000000f,
+		0.979300f,
+		0.054000f,
+		0.194800f,
+		0.468700f,
+		0.517200f,
+		0.455853f,
+		0.080891f,
+		0.188821f,
+		0.000000f,
+		0.911800f,
+		0.161200f,
+		0.377700f,
+		0.437500f,
+		0.551700f,
+		0.461261f,
+		0.027069f,
+		0.191061f,
+		0.000000f,
+		0.922500f,
+		0.054000f,
+		0.382100f,
+		0.437500f,
+		0.517200f,
+		0.053020f,
+		0.497069f,
+		0.010546f,
+		0.000000f,
+		0.109300f,
+		0.993700f,
+		0.021700f,
+		0.458000f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.482000f,
+		0.960300f,
+		0.049943f,
+		0.497069f,
+		0.020688f,
+		0.000000f,
+		0.103000f,
+		0.993700f,
+		0.042600f,
+		0.459900f,
+		0.962300f,
+		0.053020f,
+		-0.497069f,
+		0.010546f,
+		0.000000f,
+		0.109300f,
+		-0.993700f,
+		0.021700f,
+		0.468700f,
+		0.034500f,
+		0.105420f,
+		-0.488310f,
+		0.020970f,
+		0.000000f,
+		0.214000f,
+		-0.975900f,
+		0.042500f,
+		0.468700f,
+		0.069000f,
+		0.099303f,
+		-0.488310f,
+		0.041133f,
+		0.000000f,
+		0.201600f,
+		-0.975900f,
+		0.083500f,
+		0.437500f,
+		0.069000f,
+		0.053020f,
+		-0.497069f,
+		0.010546f,
+		0.000000f,
+		0.109300f,
+		-0.993700f,
+		0.021700f,
+		0.468700f,
+		0.034500f,
+		0.099303f,
+		-0.488310f,
+		0.041133f,
+		0.000000f,
+		0.201600f,
+		-0.975900f,
+		0.083500f,
+		0.437500f,
+		0.069000f,
+		0.049944f,
+		-0.497069f,
+		0.020688f,
+		0.000000f,
+		0.103000f,
+		-0.993700f,
+		0.042600f,
+		0.437500f,
+		0.034500f,
+		0.489673f,
+		-0.027069f,
+		0.097402f,
+		0.000000f,
+		0.979300f,
+		-0.054000f,
+		0.194800f,
+		0.468700f,
+		0.482800f,
+		0.489673f,
+		0.027069f,
+		0.097402f,
+		0.000000f,
+		0.979300f,
+		0.054000f,
+		0.194800f,
+		0.468700f,
+		0.517200f,
+		0.461261f,
+		0.027069f,
+		0.191061f,
+		0.000000f,
+		0.922500f,
+		0.054000f,
+		0.382100f,
+		0.437500f,
+		0.517200f,
+		0.489673f,
+		-0.027069f,
+		0.097402f,
+		0.000000f,
+		0.979300f,
+		-0.054000f,
+		0.194800f,
+		0.468700f,
+		0.482800f,
+		0.461261f,
+		0.027069f,
+		0.191061f,
+		0.000000f,
+		0.922500f,
+		0.054000f,
+		0.382100f,
+		0.437500f,
+		0.517200f,
+		0.461261f,
+		-0.027069f,
+		0.191061f,
+		0.000000f,
+		0.922500f,
+		-0.054000f,
+		0.382100f,
+		0.437500f,
+		0.482800f,
+		0.105419f,
+		0.488310f,
+		0.020970f,
+		0.000000f,
+		0.214000f,
+		0.975900f,
+		0.042500f,
+		0.468700f,
+		0.931000f,
+		0.053020f,
+		0.497069f,
+		0.010546f,
+		0.000000f,
+		0.109300f,
+		0.993700f,
+		0.021700f,
+		0.468700f,
+		0.965500f,
+		0.049943f,
+		0.497069f,
+		0.020688f,
+		0.000000f,
+		0.103000f,
+		0.993700f,
+		0.042600f,
+		0.437500f,
+		0.965500f,
+		0.105419f,
+		0.488310f,
+		0.020970f,
+		0.000000f,
+		0.214000f,
+		0.975900f,
+		0.042500f,
+		0.468700f,
+		0.931000f,
+		0.049943f,
+		0.497069f,
+		0.020688f,
+		0.000000f,
+		0.103000f,
+		0.993700f,
+		0.042600f,
+		0.437500f,
+		0.965500f,
+		0.099303f,
+		0.488310f,
+		0.041132f,
+		0.000000f,
+		0.201600f,
+		0.975900f,
+		0.083500f,
+		0.437500f,
+		0.931000f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.411700f,
+		0.051000f,
+		0.053020f,
+		-0.497069f,
+		0.010546f,
+		0.000000f,
+		0.109300f,
+		-0.993700f,
+		0.021700f,
+		0.449700f,
+		0.053800f,
+		0.049944f,
+		-0.497069f,
+		0.020688f,
+		0.000000f,
+		0.103000f,
+		-0.993700f,
+		0.042600f,
+		0.447100f,
+		0.053800f,
+		0.483932f,
+		-0.080891f,
+		0.096260f,
+		0.000000f,
+		0.967900f,
+		-0.161200f,
+		0.192500f,
+		0.468700f,
+		0.448300f,
+		0.489673f,
+		-0.027069f,
+		0.097402f,
+		0.000000f,
+		0.979300f,
+		-0.054000f,
+		0.194800f,
+		0.468700f,
+		0.482800f,
+		0.461261f,
+		-0.027069f,
+		0.191061f,
+		0.000000f,
+		0.922500f,
+		-0.054000f,
+		0.382100f,
+		0.437500f,
+		0.482800f,
+		0.483932f,
+		-0.080891f,
+		0.096260f,
+		0.000000f,
+		0.967900f,
+		-0.161200f,
+		0.192500f,
+		0.468700f,
+		0.448300f,
+		0.461261f,
+		-0.027069f,
+		0.191061f,
+		0.000000f,
+		0.922500f,
+		-0.054000f,
+		0.382100f,
+		0.437500f,
+		0.482800f,
+		0.455853f,
+		-0.080891f,
+		0.188821f,
+		0.000000f,
+		0.911800f,
+		-0.161200f,
+		0.377700f,
+		0.437500f,
+		0.448300f,
+		0.156582f,
+		0.473826f,
+		0.031146f,
+		0.000000f,
+		0.316100f,
+		0.946600f,
+		0.062900f,
+		0.468700f,
+		0.896600f,
+		0.105419f,
+		0.488310f,
+		0.020970f,
+		0.000000f,
+		0.214000f,
+		0.975900f,
+		0.042500f,
+		0.468700f,
+		0.931000f,
+		0.099303f,
+		0.488310f,
+		0.041132f,
+		0.000000f,
+		0.201600f,
+		0.975900f,
+		0.083500f,
+		0.437500f,
+		0.931000f,
+		0.156582f,
+		0.473826f,
+		0.031146f,
+		0.000000f,
+		0.316100f,
+		0.946600f,
+		0.062900f,
+		0.468700f,
+		0.896600f,
+		0.099303f,
+		0.488310f,
+		0.041132f,
+		0.000000f,
+		0.201600f,
+		0.975900f,
+		0.083500f,
+		0.437500f,
+		0.931000f,
+		0.147497f,
+		0.473826f,
+		0.061095f,
+		0.000000f,
+		0.297800f,
+		0.946600f,
+		0.123300f,
+		0.437500f,
+		0.896600f,
+		0.472517f,
+		-0.133764f,
+		0.093989f,
+		0.000000f,
+		0.945200f,
+		-0.266600f,
+		0.188000f,
+		0.468700f,
+		0.413800f,
+		0.483932f,
+		-0.080891f,
+		0.096260f,
+		0.000000f,
+		0.967900f,
+		-0.161200f,
+		0.192500f,
+		0.468700f,
+		0.448300f,
+		0.455853f,
+		-0.080891f,
+		0.188821f,
+		0.000000f,
+		0.911800f,
+		-0.161200f,
+		0.377700f,
+		0.437500f,
+		0.448300f,
+		0.472517f,
+		-0.133764f,
+		0.093989f,
+		0.000000f,
+		0.945200f,
+		-0.266600f,
+		0.188000f,
+		0.468700f,
+		0.413800f,
+		0.455853f,
+		-0.080891f,
+		0.188821f,
+		0.000000f,
+		0.911800f,
+		-0.161200f,
+		0.377700f,
+		0.437500f,
+		0.448300f,
+		0.445101f,
+		-0.133764f,
+		0.184367f,
+		0.000000f,
+		0.890400f,
+		-0.266600f,
+		0.368800f,
+		0.437500f,
+		0.413800f,
+		0.205910f,
+		0.453788f,
+		0.040958f,
+		0.000000f,
+		0.414500f,
+		0.906300f,
+		0.082400f,
+		0.468700f,
+		0.862100f,
+		0.156582f,
+		0.473826f,
+		0.031146f,
+		0.000000f,
+		0.316100f,
+		0.946600f,
+		0.062900f,
+		0.468700f,
+		0.896600f,
+		0.147497f,
+		0.473826f,
+		0.061095f,
+		0.000000f,
+		0.297800f,
+		0.946600f,
+		0.123300f,
+		0.437500f,
+		0.896600f,
+		0.205910f,
+		0.453788f,
+		0.040958f,
+		0.000000f,
+		0.414500f,
+		0.906300f,
+		0.082400f,
+		0.468700f,
+		0.862100f,
+		0.147497f,
+		0.473826f,
+		0.061095f,
+		0.000000f,
+		0.297800f,
+		0.946600f,
+		0.123300f,
+		0.437500f,
+		0.896600f,
+		0.193962f,
+		0.453788f,
+		0.080342f,
+		0.000000f,
+		0.390500f,
+		0.906300f,
+		0.161700f,
+		0.437500f,
+		0.862100f,
+		0.455563f,
+		-0.185069f,
+		0.090617f,
+		0.000000f,
+		0.911600f,
+		-0.369000f,
+		0.181300f,
+		0.468700f,
+		0.379300f,
+		0.472517f,
+		-0.133764f,
+		0.093989f,
+		0.000000f,
+		0.945200f,
+		-0.266600f,
+		0.188000f,
+		0.468700f,
+		0.413800f,
+		0.445101f,
+		-0.133764f,
+		0.184367f,
+		0.000000f,
+		0.890400f,
+		-0.266600f,
+		0.368800f,
+		0.437500f,
+		0.413800f,
+		0.455563f,
+		-0.185069f,
+		0.090617f,
+		0.000000f,
+		0.911600f,
+		-0.369000f,
+		0.181300f,
+		0.468700f,
+		0.379300f,
+		0.445101f,
+		-0.133764f,
+		0.184367f,
+		0.000000f,
+		0.890400f,
+		-0.266600f,
+		0.368800f,
+		0.437500f,
+		0.413800f,
+		0.429130f,
+		-0.185069f,
+		0.177752f,
+		0.000000f,
+		0.858700f,
+		-0.369000f,
+		0.355700f,
+		0.437500f,
+		0.379300f,
+		0.252823f,
+		0.428429f,
+		0.050290f,
+		0.000000f,
+		0.508100f,
+		0.855300f,
+		0.101000f,
+		0.468700f,
+		0.827600f,
+		0.205910f,
+		0.453788f,
+		0.040958f,
+		0.000000f,
+		0.414500f,
+		0.906300f,
+		0.082400f,
+		0.468700f,
+		0.862100f,
+		0.193962f,
+		0.453788f,
+		0.080342f,
+		0.000000f,
+		0.390500f,
+		0.906300f,
+		0.161700f,
+		0.437500f,
+		0.862100f,
+		0.252823f,
+		0.428429f,
+		0.050290f,
+		0.000000f,
+		0.508100f,
+		0.855300f,
+		0.101000f,
+		0.468700f,
+		0.827600f,
+		0.193962f,
+		0.453788f,
+		0.080342f,
+		0.000000f,
+		0.390500f,
+		0.906300f,
+		0.161700f,
+		0.437500f,
+		0.862100f,
+		0.238154f,
+		0.428429f,
+		0.098646f,
+		0.000000f,
+		0.478600f,
+		0.855300f,
+		0.198200f,
+		0.437500f,
+		0.827600f,
+		0.433267f,
+		-0.234204f,
+		0.086182f,
+		0.000000f,
+		0.867200f,
+		-0.467000f,
+		0.172500f,
+		0.468700f,
+		0.344800f,
+		0.455563f,
+		-0.185069f,
+		0.090617f,
+		0.000000f,
+		0.911600f,
+		-0.369000f,
+		0.181300f,
+		0.468700f,
+		0.379300f,
+		0.429130f,
+		-0.185069f,
+		0.177752f,
+		0.000000f,
+		0.858700f,
+		-0.369000f,
+		0.355700f,
+		0.437500f,
+		0.379300f,
+		0.433267f,
+		-0.234204f,
+		0.086182f,
+		0.000000f,
+		0.867200f,
+		-0.467000f,
+		0.172500f,
+		0.468700f,
+		0.344800f,
+		0.429130f,
+		-0.185069f,
+		0.177752f,
+		0.000000f,
+		0.858700f,
+		-0.369000f,
+		0.355700f,
+		0.437500f,
+		0.379300f,
+		0.408128f,
+		-0.234204f,
+		0.169052f,
+		0.000000f,
+		0.816900f,
+		-0.467000f,
+		0.338400f,
+		0.437500f,
+		0.344800f,
+		0.296772f,
+		0.398046f,
+		0.059032f,
+		0.000000f,
+		0.595600f,
+		0.794500f,
+		0.118500f,
+		0.468700f,
+		0.793100f,
+		0.252823f,
+		0.428429f,
+		0.050290f,
+		0.000000f,
+		0.508100f,
+		0.855300f,
+		0.101000f,
+		0.468700f,
+		0.827600f,
+		0.238154f,
+		0.428429f,
+		0.098646f,
+		0.000000f,
+		0.478600f,
+		0.855300f,
+		0.198200f,
+		0.437500f,
+		0.827600f,
+		0.296772f,
+		0.398046f,
+		0.059032f,
+		0.000000f,
+		0.595600f,
+		0.794500f,
+		0.118500f,
+		0.468700f,
+		0.793100f,
+		0.238154f,
+		0.428429f,
+		0.098646f,
+		0.000000f,
+		0.478600f,
+		0.855300f,
+		0.198200f,
+		0.437500f,
+		0.827600f,
+		0.279553f,
+		0.398046f,
+		0.115795f,
+		0.000000f,
+		0.561100f,
+		0.794500f,
+		0.232400f,
+		0.437500f,
+		0.793100f,
+		0.405892f,
+		-0.280594f,
+		0.080737f,
+		0.000000f,
+		0.812800f,
+		-0.559600f,
+		0.161700f,
+		0.468700f,
+		0.310300f,
+		0.433267f,
+		-0.234204f,
+		0.086182f,
+		0.000000f,
+		0.867200f,
+		-0.467000f,
+		0.172500f,
+		0.468700f,
+		0.344800f,
+		0.408128f,
+		-0.234204f,
+		0.169052f,
+		0.000000f,
+		0.816900f,
+		-0.467000f,
+		0.338400f,
+		0.437500f,
+		0.344800f,
+		0.405892f,
+		-0.280594f,
+		0.080737f,
+		0.000000f,
+		0.812800f,
+		-0.559600f,
+		0.161700f,
+		0.468700f,
+		0.310300f,
+		0.408128f,
+		-0.234204f,
+		0.169052f,
+		0.000000f,
+		0.816900f,
+		-0.467000f,
+		0.338400f,
+		0.437500f,
+		0.344800f,
+		0.382342f,
+		-0.280594f,
+		0.158371f,
+		0.000000f,
+		0.765600f,
+		-0.559600f,
+		0.317100f,
+		0.437500f,
+		0.310300f,
+		0.337242f,
+		0.362998f,
+		0.067082f,
+		0.000000f,
+		0.676200f,
+		0.724300f,
+		0.134500f,
+		0.468800f,
+		0.758600f,
+		0.296772f,
+		0.398046f,
+		0.059032f,
+		0.000000f,
+		0.595600f,
+		0.794500f,
+		0.118500f,
+		0.468700f,
+		0.793100f,
+		0.279553f,
+		0.398046f,
+		0.115795f,
+		0.000000f,
+		0.561100f,
+		0.794500f,
+		0.232400f,
+		0.437500f,
+		0.793100f,
+		0.337242f,
+		0.362998f,
+		0.067082f,
+		0.000000f,
+		0.676200f,
+		0.724300f,
+		0.134500f,
+		0.468800f,
+		0.758600f,
+		0.279553f,
+		0.398046f,
+		0.115795f,
+		0.000000f,
+		0.561100f,
+		0.794500f,
+		0.232400f,
+		0.437500f,
+		0.793100f,
+		0.317674f,
+		0.362998f,
+		0.131585f,
+		0.000000f,
+		0.637000f,
+		0.724300f,
+		0.263800f,
+		0.437500f,
+		0.758600f,
+		0.373758f,
+		-0.323693f,
+		0.074345f,
+		0.000000f,
+		0.748900f,
+		-0.645700f,
+		0.149000f,
+		0.468700f,
+		0.275900f,
+		0.405892f,
+		-0.280594f,
+		0.080737f,
+		0.000000f,
+		0.812800f,
+		-0.559600f,
+		0.161700f,
+		0.468700f,
+		0.310300f,
+		0.382342f,
+		-0.280594f,
+		0.158371f,
+		0.000000f,
+		0.765600f,
+		-0.559600f,
+		0.317100f,
+		0.437500f,
+		0.310300f,
+		0.373758f,
+		-0.323693f,
+		0.074345f,
+		0.000000f,
+		0.748900f,
+		-0.645700f,
+		0.149000f,
+		0.468700f,
+		0.275900f,
+		0.382342f,
+		-0.280594f,
+		0.158371f,
+		0.000000f,
+		0.765600f,
+		-0.559600f,
+		0.317100f,
+		0.437500f,
+		0.310300f,
+		0.352072f,
+		-0.323693f,
+		0.145834f,
+		0.000000f,
+		0.705400f,
+		-0.645700f,
+		0.292200f,
+		0.437500f,
+		0.275900f,
+		0.455853f,
+		-0.080891f,
+		0.188821f,
+		0.000000f,
+		0.911800f,
+		-0.161200f,
+		0.377700f,
+		0.437500f,
+		0.448300f,
+		0.461261f,
+		-0.027069f,
+		0.191061f,
+		0.000000f,
+		0.922500f,
+		-0.054000f,
+		0.382100f,
+		0.437500f,
+		0.482800f,
+		0.415124f,
+		-0.027069f,
+		0.277377f,
+		0.000000f,
+		0.830300f,
+		-0.054000f,
+		0.554700f,
+		0.406200f,
+		0.482800f,
+		0.455853f,
+		-0.080891f,
+		0.188821f,
+		0.000000f,
+		0.911800f,
+		-0.161200f,
+		0.377700f,
+		0.437500f,
+		0.448300f,
+		0.415124f,
+		-0.027069f,
+		0.277377f,
+		0.000000f,
+		0.830300f,
+		-0.054000f,
+		0.554700f,
+		0.406200f,
+		0.482800f,
+		0.410257f,
+		-0.080891f,
+		0.274125f,
+		0.000000f,
+		0.820600f,
+		-0.161200f,
+		0.548300f,
+		0.406200f,
+		0.448300f,
+		0.147497f,
+		0.473826f,
+		0.061095f,
+		0.000000f,
+		0.297800f,
+		0.946600f,
+		0.123300f,
+		0.437500f,
+		0.896600f,
+		0.099303f,
+		0.488310f,
+		0.041132f,
+		0.000000f,
+		0.201600f,
+		0.975900f,
+		0.083500f,
+		0.437500f,
+		0.931000f,
+		0.089370f,
+		0.488310f,
+		0.059715f,
+		0.000000f,
+		0.181400f,
+		0.975900f,
+		0.121200f,
+		0.406200f,
+		0.931000f,
+		0.147497f,
+		0.473826f,
+		0.061095f,
+		0.000000f,
+		0.297800f,
+		0.946600f,
+		0.123300f,
+		0.437500f,
+		0.896600f,
+		0.089370f,
+		0.488310f,
+		0.059715f,
+		0.000000f,
+		0.181400f,
+		0.975900f,
+		0.121200f,
+		0.406200f,
+		0.931000f,
+		0.132744f,
+		0.473826f,
+		0.088697f,
+		0.000000f,
+		0.268000f,
+		0.946600f,
+		0.179100f,
+		0.406200f,
+		0.896600f,
+		0.445101f,
+		-0.133764f,
+		0.184367f,
+		0.000000f,
+		0.890400f,
+		-0.266600f,
+		0.368800f,
+		0.437500f,
+		0.413800f,
+		0.455853f,
+		-0.080891f,
+		0.188821f,
+		0.000000f,
+		0.911800f,
+		-0.161200f,
+		0.377700f,
+		0.437500f,
+		0.448300f,
+		0.410257f,
+		-0.080891f,
+		0.274125f,
+		0.000000f,
+		0.820600f,
+		-0.161200f,
+		0.548300f,
+		0.406200f,
+		0.448300f,
+		0.445101f,
+		-0.133764f,
+		0.184367f,
+		0.000000f,
+		0.890400f,
+		-0.266600f,
+		0.368800f,
+		0.437500f,
+		0.413800f,
+		0.410257f,
+		-0.080891f,
+		0.274125f,
+		0.000000f,
+		0.820600f,
+		-0.161200f,
+		0.548300f,
+		0.406200f,
+		0.448300f,
+		0.400580f,
+		-0.133764f,
+		0.267659f,
+		0.000000f,
+		0.801400f,
+		-0.266600f,
+		0.535400f,
+		0.406200f,
+		0.413800f,
+		0.193962f,
+		0.453788f,
+		0.080342f,
+		0.000000f,
+		0.390500f,
+		0.906300f,
+		0.161700f,
+		0.437500f,
+		0.862100f,
+		0.147497f,
+		0.473826f,
+		0.061095f,
+		0.000000f,
+		0.297800f,
+		0.946600f,
+		0.123300f,
+		0.437500f,
+		0.896600f,
+		0.132744f,
+		0.473826f,
+		0.088697f,
+		0.000000f,
+		0.268000f,
+		0.946600f,
+		0.179100f,
+		0.406200f,
+		0.896600f,
+		0.193962f,
+		0.453788f,
+		0.080342f,
+		0.000000f,
+		0.390500f,
+		0.906300f,
+		0.161700f,
+		0.437500f,
+		0.862100f,
+		0.132744f,
+		0.473826f,
+		0.088697f,
+		0.000000f,
+		0.268000f,
+		0.946600f,
+		0.179100f,
+		0.406200f,
+		0.896600f,
+		0.174562f,
+		0.453788f,
+		0.116638f,
+		0.000000f,
+		0.351400f,
+		0.906300f,
+		0.234800f,
+		0.406200f,
+		0.862100f,
+		0.429130f,
+		-0.185069f,
+		0.177752f,
+		0.000000f,
+		0.858700f,
+		-0.369000f,
+		0.355700f,
+		0.437500f,
+		0.379300f,
+		0.445101f,
+		-0.133764f,
+		0.184367f,
+		0.000000f,
+		0.890400f,
+		-0.266600f,
+		0.368800f,
+		0.437500f,
+		0.413800f,
+		0.400580f,
+		-0.133764f,
+		0.267659f,
+		0.000000f,
+		0.801400f,
+		-0.266600f,
+		0.535400f,
+		0.406200f,
+		0.413800f,
+		0.429130f,
+		-0.185069f,
+		0.177752f,
+		0.000000f,
+		0.858700f,
+		-0.369000f,
+		0.355700f,
+		0.437500f,
+		0.379300f,
+		0.400580f,
+		-0.133764f,
+		0.267659f,
+		0.000000f,
+		0.801400f,
+		-0.266600f,
+		0.535400f,
+		0.406200f,
+		0.413800f,
+		0.386207f,
+		-0.185069f,
+		0.258056f,
+		0.000000f,
+		0.772800f,
+		-0.369000f,
+		0.516300f,
+		0.406200f,
+		0.379300f,
+		0.238154f,
+		0.428429f,
+		0.098646f,
+		0.000000f,
+		0.478600f,
+		0.855300f,
+		0.198200f,
+		0.437500f,
+		0.827600f,
+		0.193962f,
+		0.453788f,
+		0.080342f,
+		0.000000f,
+		0.390500f,
+		0.906300f,
+		0.161700f,
+		0.437500f,
+		0.862100f,
+		0.174562f,
+		0.453788f,
+		0.116638f,
+		0.000000f,
+		0.351400f,
+		0.906300f,
+		0.234800f,
+		0.406200f,
+		0.862100f,
+		0.238154f,
+		0.428429f,
+		0.098646f,
+		0.000000f,
+		0.478600f,
+		0.855300f,
+		0.198200f,
+		0.437500f,
+		0.827600f,
+		0.174562f,
+		0.453788f,
+		0.116638f,
+		0.000000f,
+		0.351400f,
+		0.906300f,
+		0.234800f,
+		0.406200f,
+		0.862100f,
+		0.214333f,
+		0.428429f,
+		0.143213f,
+		0.000000f,
+		0.430700f,
+		0.855300f,
+		0.287800f,
+		0.406200f,
+		0.827600f,
+		0.408128f,
+		-0.234204f,
+		0.169052f,
+		0.000000f,
+		0.816900f,
+		-0.467000f,
+		0.338400f,
+		0.437500f,
+		0.344800f,
+		0.429130f,
+		-0.185069f,
+		0.177752f,
+		0.000000f,
+		0.858700f,
+		-0.369000f,
+		0.355700f,
+		0.437500f,
+		0.379300f,
+		0.386207f,
+		-0.185069f,
+		0.258056f,
+		0.000000f,
+		0.772800f,
+		-0.369000f,
+		0.516300f,
+		0.406200f,
+		0.379300f,
+		0.408128f,
+		-0.234204f,
+		0.169052f,
+		0.000000f,
+		0.816900f,
+		-0.467000f,
+		0.338400f,
+		0.437500f,
+		0.344800f,
+		0.386207f,
+		-0.185069f,
+		0.258056f,
+		0.000000f,
+		0.772800f,
+		-0.369000f,
+		0.516300f,
+		0.406200f,
+		0.379300f,
+		0.367306f,
+		-0.234204f,
+		0.245426f,
+		0.000000f,
+		0.735200f,
+		-0.467000f,
+		0.491300f,
+		0.406200f,
+		0.344800f,
+		0.279553f,
+		0.398046f,
+		0.115795f,
+		0.000000f,
+		0.561100f,
+		0.794500f,
+		0.232400f,
+		0.437500f,
+		0.793100f,
+		0.238154f,
+		0.428429f,
+		0.098646f,
+		0.000000f,
+		0.478600f,
+		0.855300f,
+		0.198200f,
+		0.437500f,
+		0.827600f,
+		0.214333f,
+		0.428429f,
+		0.143213f,
+		0.000000f,
+		0.430700f,
+		0.855300f,
+		0.287800f,
+		0.406200f,
+		0.827600f,
+		0.279553f,
+		0.398046f,
+		0.115795f,
+		0.000000f,
+		0.561100f,
+		0.794500f,
+		0.232400f,
+		0.437500f,
+		0.793100f,
+		0.214333f,
+		0.428429f,
+		0.143213f,
+		0.000000f,
+		0.430700f,
+		0.855300f,
+		0.287800f,
+		0.406200f,
+		0.827600f,
+		0.251591f,
+		0.398046f,
+		0.168108f,
+		0.000000f,
+		0.505000f,
+		0.794500f,
+		0.337400f,
+		0.406200f,
+		0.793100f,
+		0.382342f,
+		-0.280594f,
+		0.158371f,
+		0.000000f,
+		0.765600f,
+		-0.559600f,
+		0.317100f,
+		0.437500f,
+		0.310300f,
+		0.408128f,
+		-0.234204f,
+		0.169052f,
+		0.000000f,
+		0.816900f,
+		-0.467000f,
+		0.338400f,
+		0.437500f,
+		0.344800f,
+		0.367306f,
+		-0.234204f,
+		0.245426f,
+		0.000000f,
+		0.735200f,
+		-0.467000f,
+		0.491300f,
+		0.406200f,
+		0.344800f,
+		0.382342f,
+		-0.280594f,
+		0.158371f,
+		0.000000f,
+		0.765600f,
+		-0.559600f,
+		0.317100f,
+		0.437500f,
+		0.310300f,
+		0.367306f,
+		-0.234204f,
+		0.245426f,
+		0.000000f,
+		0.735200f,
+		-0.467000f,
+		0.491300f,
+		0.406200f,
+		0.344800f,
+		0.344098f,
+		-0.280594f,
+		0.229919f,
+		0.000000f,
+		0.689100f,
+		-0.559600f,
+		0.460400f,
+		0.406200f,
+		0.310300f,
+		0.317674f,
+		0.362998f,
+		0.131585f,
+		0.000000f,
+		0.637000f,
+		0.724300f,
+		0.263800f,
+		0.437500f,
+		0.758600f,
+		0.279553f,
+		0.398046f,
+		0.115795f,
+		0.000000f,
+		0.561100f,
+		0.794500f,
+		0.232400f,
+		0.437500f,
+		0.793100f,
+		0.251591f,
+		0.398046f,
+		0.168108f,
+		0.000000f,
+		0.505000f,
+		0.794500f,
+		0.337400f,
+		0.406200f,
+		0.793100f,
+		0.317674f,
+		0.362998f,
+		0.131585f,
+		0.000000f,
+		0.637000f,
+		0.724300f,
+		0.263800f,
+		0.437500f,
+		0.758600f,
+		0.251591f,
+		0.398046f,
+		0.168108f,
+		0.000000f,
+		0.505000f,
+		0.794500f,
+		0.337400f,
+		0.406200f,
+		0.793100f,
+		0.285899f,
+		0.362998f,
+		0.191032f,
+		0.000000f,
+		0.573300f,
+		0.724300f,
+		0.383000f,
+		0.406200f,
+		0.758600f,
+		0.352072f,
+		-0.323693f,
+		0.145834f,
+		0.000000f,
+		0.705400f,
+		-0.645700f,
+		0.292200f,
+		0.437500f,
+		0.275900f,
+		0.382342f,
+		-0.280594f,
+		0.158371f,
+		0.000000f,
+		0.765600f,
+		-0.559600f,
+		0.317100f,
+		0.437500f,
+		0.310300f,
+		0.344098f,
+		-0.280594f,
+		0.229919f,
+		0.000000f,
+		0.689100f,
+		-0.559600f,
+		0.460400f,
+		0.406200f,
+		0.310300f,
+		0.352072f,
+		-0.323693f,
+		0.145834f,
+		0.000000f,
+		0.705400f,
+		-0.645700f,
+		0.292200f,
+		0.437500f,
+		0.275900f,
+		0.344098f,
+		-0.280594f,
+		0.229919f,
+		0.000000f,
+		0.689100f,
+		-0.559600f,
+		0.460400f,
+		0.406200f,
+		0.310300f,
+		0.316857f,
+		-0.323693f,
+		0.211717f,
+		0.000000f,
+		0.634900f,
+		-0.645700f,
+		0.424200f,
+		0.406200f,
+		0.275900f,
+		0.352072f,
+		0.323693f,
+		0.145833f,
+		0.000000f,
+		0.705400f,
+		0.645700f,
+		0.292200f,
+		0.437500f,
+		0.724100f,
+		0.317674f,
+		0.362998f,
+		0.131585f,
+		0.000000f,
+		0.637000f,
+		0.724300f,
+		0.263800f,
+		0.437500f,
+		0.758600f,
+		0.285899f,
+		0.362998f,
+		0.191032f,
+		0.000000f,
+		0.573300f,
+		0.724300f,
+		0.383000f,
+		0.406200f,
+		0.758600f,
+		0.352072f,
+		0.323693f,
+		0.145833f,
+		0.000000f,
+		0.705400f,
+		0.645700f,
+		0.292200f,
+		0.437500f,
+		0.724100f,
+		0.285899f,
+		0.362998f,
+		0.191032f,
+		0.000000f,
+		0.573300f,
+		0.724300f,
+		0.383000f,
+		0.406200f,
+		0.758600f,
+		0.316857f,
+		0.323693f,
+		0.211717f,
+		0.000000f,
+		0.634900f,
+		0.645700f,
+		0.424200f,
+		0.406200f,
+		0.724100f,
+		0.317675f,
+		-0.362998f,
+		0.131585f,
+		0.000000f,
+		0.637000f,
+		-0.724300f,
+		0.263800f,
+		0.437500f,
+		0.241400f,
+		0.352072f,
+		-0.323693f,
+		0.145834f,
+		0.000000f,
+		0.705400f,
+		-0.645700f,
+		0.292200f,
+		0.437500f,
+		0.275900f,
+		0.316857f,
+		-0.323693f,
+		0.211717f,
+		0.000000f,
+		0.634900f,
+		-0.645700f,
+		0.424200f,
+		0.406200f,
+		0.275900f,
+		0.317675f,
+		-0.362998f,
+		0.131585f,
+		0.000000f,
+		0.637000f,
+		-0.724300f,
+		0.263800f,
+		0.437500f,
+		0.241400f,
+		0.316857f,
+		-0.323693f,
+		0.211717f,
+		0.000000f,
+		0.634900f,
+		-0.645700f,
+		0.424200f,
+		0.406200f,
+		0.275900f,
+		0.285900f,
+		-0.362998f,
+		0.191032f,
+		0.000000f,
+		0.573300f,
+		-0.724300f,
+		0.383000f,
+		0.406200f,
+		0.241400f,
+		0.382342f,
+		0.280594f,
+		0.158371f,
+		0.000000f,
+		0.765600f,
+		0.559600f,
+		0.317100f,
+		0.437500f,
+		0.689700f,
+		0.352072f,
+		0.323693f,
+		0.145833f,
+		0.000000f,
+		0.705400f,
+		0.645700f,
+		0.292200f,
+		0.437500f,
+		0.724100f,
+		0.316857f,
+		0.323693f,
+		0.211717f,
+		0.000000f,
+		0.634900f,
+		0.645700f,
+		0.424200f,
+		0.406200f,
+		0.724100f,
+		0.382342f,
+		0.280594f,
+		0.158371f,
+		0.000000f,
+		0.765600f,
+		0.559600f,
+		0.317100f,
+		0.437500f,
+		0.689700f,
+		0.316857f,
+		0.323693f,
+		0.211717f,
+		0.000000f,
+		0.634900f,
+		0.645700f,
+		0.424200f,
+		0.406200f,
+		0.724100f,
+		0.344098f,
+		0.280594f,
+		0.229919f,
+		0.000000f,
+		0.689100f,
+		0.559600f,
+		0.460400f,
+		0.406200f,
+		0.689700f,
+		0.279553f,
+		-0.398046f,
+		0.115795f,
+		0.000000f,
+		0.561100f,
+		-0.794500f,
+		0.232400f,
+		0.437500f,
+		0.206900f,
+		0.317675f,
+		-0.362998f,
+		0.131585f,
+		0.000000f,
+		0.637000f,
+		-0.724300f,
+		0.263800f,
+		0.437500f,
+		0.241400f,
+		0.285900f,
+		-0.362998f,
+		0.191032f,
+		0.000000f,
+		0.573300f,
+		-0.724300f,
+		0.383000f,
+		0.406200f,
+		0.241400f,
+		0.279553f,
+		-0.398046f,
+		0.115795f,
+		0.000000f,
+		0.561100f,
+		-0.794500f,
+		0.232400f,
+		0.437500f,
+		0.206900f,
+		0.285900f,
+		-0.362998f,
+		0.191032f,
+		0.000000f,
+		0.573300f,
+		-0.724300f,
+		0.383000f,
+		0.406200f,
+		0.241400f,
+		0.251591f,
+		-0.398046f,
+		0.168108f,
+		0.000000f,
+		0.504900f,
+		-0.794500f,
+		0.337400f,
+		0.406200f,
+		0.206900f,
+		0.408128f,
+		0.234204f,
+		0.169052f,
+		0.000000f,
+		0.816900f,
+		0.467000f,
+		0.338400f,
+		0.437500f,
+		0.655200f,
+		0.382342f,
+		0.280594f,
+		0.158371f,
+		0.000000f,
+		0.765600f,
+		0.559600f,
+		0.317100f,
+		0.437500f,
+		0.689700f,
+		0.344098f,
+		0.280594f,
+		0.229919f,
+		0.000000f,
+		0.689100f,
+		0.559600f,
+		0.460400f,
+		0.406200f,
+		0.689700f,
+		0.408128f,
+		0.234204f,
+		0.169052f,
+		0.000000f,
+		0.816900f,
+		0.467000f,
+		0.338400f,
+		0.437500f,
+		0.655200f,
+		0.344098f,
+		0.280594f,
+		0.229919f,
+		0.000000f,
+		0.689100f,
+		0.559600f,
+		0.460400f,
+		0.406200f,
+		0.689700f,
+		0.367306f,
+		0.234204f,
+		0.245426f,
+		0.000000f,
+		0.735200f,
+		0.467000f,
+		0.491300f,
+		0.406200f,
+		0.655200f,
+		0.238154f,
+		-0.428429f,
+		0.098647f,
+		0.000000f,
+		0.478600f,
+		-0.855300f,
+		0.198200f,
+		0.437500f,
+		0.172400f,
+		0.279553f,
+		-0.398046f,
+		0.115795f,
+		0.000000f,
+		0.561100f,
+		-0.794500f,
+		0.232400f,
+		0.437500f,
+		0.206900f,
+		0.251591f,
+		-0.398046f,
+		0.168108f,
+		0.000000f,
+		0.504900f,
+		-0.794500f,
+		0.337400f,
+		0.406200f,
+		0.206900f,
+		0.238154f,
+		-0.428429f,
+		0.098647f,
+		0.000000f,
+		0.478600f,
+		-0.855300f,
+		0.198200f,
+		0.437500f,
+		0.172400f,
+		0.251591f,
+		-0.398046f,
+		0.168108f,
+		0.000000f,
+		0.504900f,
+		-0.794500f,
+		0.337400f,
+		0.406200f,
+		0.206900f,
+		0.214333f,
+		-0.428429f,
+		0.143213f,
+		0.000000f,
+		0.430700f,
+		-0.855300f,
+		0.287800f,
+		0.406200f,
+		0.172400f,
+		0.429130f,
+		0.185069f,
+		0.177752f,
+		0.000000f,
+		0.858700f,
+		0.369000f,
+		0.355700f,
+		0.437500f,
+		0.620700f,
+		0.408128f,
+		0.234204f,
+		0.169052f,
+		0.000000f,
+		0.816900f,
+		0.467000f,
+		0.338400f,
+		0.437500f,
+		0.655200f,
+		0.367306f,
+		0.234204f,
+		0.245426f,
+		0.000000f,
+		0.735200f,
+		0.467000f,
+		0.491300f,
+		0.406200f,
+		0.655200f,
+		0.429130f,
+		0.185069f,
+		0.177752f,
+		0.000000f,
+		0.858700f,
+		0.369000f,
+		0.355700f,
+		0.437500f,
+		0.620700f,
+		0.367306f,
+		0.234204f,
+		0.245426f,
+		0.000000f,
+		0.735200f,
+		0.467000f,
+		0.491300f,
+		0.406200f,
+		0.655200f,
+		0.386207f,
+		0.185069f,
+		0.258056f,
+		0.000000f,
+		0.772800f,
+		0.369000f,
+		0.516300f,
+		0.406200f,
+		0.620700f,
+		0.193963f,
+		-0.453788f,
+		0.080342f,
+		0.000000f,
+		0.390500f,
+		-0.906300f,
+		0.161700f,
+		0.437500f,
+		0.137900f,
+		0.238154f,
+		-0.428429f,
+		0.098647f,
+		0.000000f,
+		0.478600f,
+		-0.855300f,
+		0.198200f,
+		0.437500f,
+		0.172400f,
+		0.214333f,
+		-0.428429f,
+		0.143213f,
+		0.000000f,
+		0.430700f,
+		-0.855300f,
+		0.287800f,
+		0.406200f,
+		0.172400f,
+		0.193963f,
+		-0.453788f,
+		0.080342f,
+		0.000000f,
+		0.390500f,
+		-0.906300f,
+		0.161700f,
+		0.437500f,
+		0.137900f,
+		0.214333f,
+		-0.428429f,
+		0.143213f,
+		0.000000f,
+		0.430700f,
+		-0.855300f,
+		0.287800f,
+		0.406200f,
+		0.172400f,
+		0.174562f,
+		-0.453788f,
+		0.116639f,
+		0.000000f,
+		0.351400f,
+		-0.906300f,
+		0.234800f,
+		0.406200f,
+		0.137900f,
+		0.445101f,
+		0.133764f,
+		0.184367f,
+		0.000000f,
+		0.890400f,
+		0.266600f,
+		0.368800f,
+		0.437500f,
+		0.586200f,
+		0.429130f,
+		0.185069f,
+		0.177752f,
+		0.000000f,
+		0.858700f,
+		0.369000f,
+		0.355700f,
+		0.437500f,
+		0.620700f,
+		0.386207f,
+		0.185069f,
+		0.258056f,
+		0.000000f,
+		0.772800f,
+		0.369000f,
+		0.516300f,
+		0.406200f,
+		0.620700f,
+		0.445101f,
+		0.133764f,
+		0.184367f,
+		0.000000f,
+		0.890400f,
+		0.266600f,
+		0.368800f,
+		0.437500f,
+		0.586200f,
+		0.386207f,
+		0.185069f,
+		0.258056f,
+		0.000000f,
+		0.772800f,
+		0.369000f,
+		0.516300f,
+		0.406200f,
+		0.620700f,
+		0.400580f,
+		0.133764f,
+		0.267659f,
+		0.000000f,
+		0.801400f,
+		0.266600f,
+		0.535400f,
+		0.406200f,
+		0.586200f,
+		0.147498f,
+		-0.473826f,
+		0.061095f,
+		0.000000f,
+		0.297800f,
+		-0.946600f,
+		0.123300f,
+		0.437500f,
+		0.103400f,
+		0.193963f,
+		-0.453788f,
+		0.080342f,
+		0.000000f,
+		0.390500f,
+		-0.906300f,
+		0.161700f,
+		0.437500f,
+		0.137900f,
+		0.174562f,
+		-0.453788f,
+		0.116639f,
+		0.000000f,
+		0.351400f,
+		-0.906300f,
+		0.234800f,
+		0.406200f,
+		0.137900f,
+		0.147498f,
+		-0.473826f,
+		0.061095f,
+		0.000000f,
+		0.297800f,
+		-0.946600f,
+		0.123300f,
+		0.437500f,
+		0.103400f,
+		0.174562f,
+		-0.453788f,
+		0.116639f,
+		0.000000f,
+		0.351400f,
+		-0.906300f,
+		0.234800f,
+		0.406200f,
+		0.137900f,
+		0.132744f,
+		-0.473826f,
+		0.088697f,
+		0.000000f,
+		0.268000f,
+		-0.946600f,
+		0.179100f,
+		0.406200f,
+		0.103400f,
+		0.455853f,
+		0.080891f,
+		0.188821f,
+		0.000000f,
+		0.911800f,
+		0.161200f,
+		0.377700f,
+		0.437500f,
+		0.551700f,
+		0.445101f,
+		0.133764f,
+		0.184367f,
+		0.000000f,
+		0.890400f,
+		0.266600f,
+		0.368800f,
+		0.437500f,
+		0.586200f,
+		0.400580f,
+		0.133764f,
+		0.267659f,
+		0.000000f,
+		0.801400f,
+		0.266600f,
+		0.535400f,
+		0.406200f,
+		0.586200f,
+		0.455853f,
+		0.080891f,
+		0.188821f,
+		0.000000f,
+		0.911800f,
+		0.161200f,
+		0.377700f,
+		0.437500f,
+		0.551700f,
+		0.400580f,
+		0.133764f,
+		0.267659f,
+		0.000000f,
+		0.801400f,
+		0.266600f,
+		0.535400f,
+		0.406200f,
+		0.586200f,
+		0.410257f,
+		0.080891f,
+		0.274125f,
+		0.000000f,
+		0.820600f,
+		0.161200f,
+		0.548300f,
+		0.406200f,
+		0.551700f,
+		0.099303f,
+		-0.488310f,
+		0.041133f,
+		0.000000f,
+		0.201600f,
+		-0.975900f,
+		0.083500f,
+		0.437500f,
+		0.069000f,
+		0.147498f,
+		-0.473826f,
+		0.061095f,
+		0.000000f,
+		0.297800f,
+		-0.946600f,
+		0.123300f,
+		0.437500f,
+		0.103400f,
+		0.132744f,
+		-0.473826f,
+		0.088697f,
+		0.000000f,
+		0.268000f,
+		-0.946600f,
+		0.179100f,
+		0.406200f,
+		0.103400f,
+		0.099303f,
+		-0.488310f,
+		0.041133f,
+		0.000000f,
+		0.201600f,
+		-0.975900f,
+		0.083500f,
+		0.437500f,
+		0.069000f,
+		0.132744f,
+		-0.473826f,
+		0.088697f,
+		0.000000f,
+		0.268000f,
+		-0.946600f,
+		0.179100f,
+		0.406200f,
+		0.103400f,
+		0.089370f,
+		-0.488310f,
+		0.059715f,
+		0.000000f,
+		0.181400f,
+		-0.975900f,
+		0.121200f,
+		0.406200f,
+		0.069000f,
+		0.461261f,
+		0.027069f,
+		0.191061f,
+		0.000000f,
+		0.922500f,
+		0.054000f,
+		0.382100f,
+		0.437500f,
+		0.517200f,
+		0.455853f,
+		0.080891f,
+		0.188821f,
+		0.000000f,
+		0.911800f,
+		0.161200f,
+		0.377700f,
+		0.437500f,
+		0.551700f,
+		0.410257f,
+		0.080891f,
+		0.274125f,
+		0.000000f,
+		0.820600f,
+		0.161200f,
+		0.548300f,
+		0.406200f,
+		0.551700f,
+		0.461261f,
+		0.027069f,
+		0.191061f,
+		0.000000f,
+		0.922500f,
+		0.054000f,
+		0.382100f,
+		0.437500f,
+		0.517200f,
+		0.410257f,
+		0.080891f,
+		0.274125f,
+		0.000000f,
+		0.820600f,
+		0.161200f,
+		0.548300f,
+		0.406200f,
+		0.551700f,
+		0.415124f,
+		0.027069f,
+		0.277377f,
+		0.000000f,
+		0.830300f,
+		0.054000f,
+		0.554700f,
+		0.406200f,
+		0.517200f,
+		0.049943f,
+		0.497069f,
+		0.020688f,
+		0.000000f,
+		0.103000f,
+		0.993700f,
+		0.042600f,
+		0.459900f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.482000f,
+		0.960300f,
+		0.044948f,
+		0.497069f,
+		0.030034f,
+		0.000000f,
+		0.092700f,
+		0.993700f,
+		0.061900f,
+		0.461700f,
+		0.962300f,
+		0.049944f,
+		-0.497069f,
+		0.020688f,
+		0.000000f,
+		0.103000f,
+		-0.993700f,
+		0.042600f,
+		0.437500f,
+		0.034500f,
+		0.099303f,
+		-0.488310f,
+		0.041133f,
+		0.000000f,
+		0.201600f,
+		-0.975900f,
+		0.083500f,
+		0.437500f,
+		0.069000f,
+		0.089370f,
+		-0.488310f,
+		0.059715f,
+		0.000000f,
+		0.181400f,
+		-0.975900f,
+		0.121200f,
+		0.406200f,
+		0.069000f,
+		0.049944f,
+		-0.497069f,
+		0.020688f,
+		0.000000f,
+		0.103000f,
+		-0.993700f,
+		0.042600f,
+		0.437500f,
+		0.034500f,
+		0.089370f,
+		-0.488310f,
+		0.059715f,
+		0.000000f,
+		0.181400f,
+		-0.975900f,
+		0.121200f,
+		0.406200f,
+		0.069000f,
+		0.044948f,
+		-0.497069f,
+		0.030034f,
+		0.000000f,
+		0.092700f,
+		-0.993700f,
+		0.061900f,
+		0.406200f,
+		0.034500f,
+		0.461261f,
+		-0.027069f,
+		0.191061f,
+		0.000000f,
+		0.922500f,
+		-0.054000f,
+		0.382100f,
+		0.437500f,
+		0.482800f,
+		0.461261f,
+		0.027069f,
+		0.191061f,
+		0.000000f,
+		0.922500f,
+		0.054000f,
+		0.382100f,
+		0.437500f,
+		0.517200f,
+		0.415124f,
+		0.027069f,
+		0.277377f,
+		0.000000f,
+		0.830300f,
+		0.054000f,
+		0.554700f,
+		0.406200f,
+		0.517200f,
+		0.461261f,
+		-0.027069f,
+		0.191061f,
+		0.000000f,
+		0.922500f,
+		-0.054000f,
+		0.382100f,
+		0.437500f,
+		0.482800f,
+		0.415124f,
+		0.027069f,
+		0.277377f,
+		0.000000f,
+		0.830300f,
+		0.054000f,
+		0.554700f,
+		0.406200f,
+		0.517200f,
+		0.415124f,
+		-0.027069f,
+		0.277377f,
+		0.000000f,
+		0.830300f,
+		-0.054000f,
+		0.554700f,
+		0.406200f,
+		0.482800f,
+		0.099303f,
+		0.488310f,
+		0.041132f,
+		0.000000f,
+		0.201600f,
+		0.975900f,
+		0.083500f,
+		0.437500f,
+		0.931000f,
+		0.049943f,
+		0.497069f,
+		0.020688f,
+		0.000000f,
+		0.103000f,
+		0.993700f,
+		0.042600f,
+		0.437500f,
+		0.965500f,
+		0.044948f,
+		0.497069f,
+		0.030034f,
+		0.000000f,
+		0.092700f,
+		0.993700f,
+		0.061900f,
+		0.406200f,
+		0.965500f,
+		0.099303f,
+		0.488310f,
+		0.041132f,
+		0.000000f,
+		0.201600f,
+		0.975900f,
+		0.083500f,
+		0.437500f,
+		0.931000f,
+		0.044948f,
+		0.497069f,
+		0.030034f,
+		0.000000f,
+		0.092700f,
+		0.993700f,
+		0.061900f,
+		0.406200f,
+		0.965500f,
+		0.089370f,
+		0.488310f,
+		0.059715f,
+		0.000000f,
+		0.181400f,
+		0.975900f,
+		0.121200f,
+		0.406200f,
+		0.931000f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.411700f,
+		0.051000f,
+		0.049944f,
+		-0.497069f,
+		0.020688f,
+		0.000000f,
+		0.103000f,
+		-0.993700f,
+		0.042600f,
+		0.447100f,
+		0.053800f,
+		0.044948f,
+		-0.497069f,
+		0.030034f,
+		0.000000f,
+		0.092700f,
+		-0.993700f,
+		0.061900f,
+		0.444400f,
+		0.053800f,
+		0.214333f,
+		-0.428429f,
+		0.143213f,
+		0.000000f,
+		0.430700f,
+		-0.855300f,
+		0.287800f,
+		0.406200f,
+		0.172400f,
+		0.251591f,
+		-0.398046f,
+		0.168108f,
+		0.000000f,
+		0.504900f,
+		-0.794500f,
+		0.337400f,
+		0.406200f,
+		0.206900f,
+		0.213960f,
+		-0.398046f,
+		0.213961f,
+		0.000000f,
+		0.429400f,
+		-0.794500f,
+		0.429400f,
+		0.375000f,
+		0.206900f,
+		0.214333f,
+		-0.428429f,
+		0.143213f,
+		0.000000f,
+		0.430700f,
+		-0.855300f,
+		0.287800f,
+		0.406200f,
+		0.172400f,
+		0.213960f,
+		-0.398046f,
+		0.213961f,
+		0.000000f,
+		0.429400f,
+		-0.794500f,
+		0.429400f,
+		0.375000f,
+		0.206900f,
+		0.182275f,
+		-0.428429f,
+		0.182276f,
+		0.000000f,
+		0.366300f,
+		-0.855300f,
+		0.366300f,
+		0.375000f,
+		0.172400f,
+		0.386207f,
+		0.185069f,
+		0.258056f,
+		0.000000f,
+		0.772800f,
+		0.369000f,
+		0.516300f,
+		0.406200f,
+		0.620700f,
+		0.367306f,
+		0.234204f,
+		0.245426f,
+		0.000000f,
+		0.735200f,
+		0.467000f,
+		0.491300f,
+		0.406200f,
+		0.655200f,
+		0.312368f,
+		0.234204f,
+		0.312368f,
+		0.000000f,
+		0.625200f,
+		0.467000f,
+		0.625200f,
+		0.375000f,
+		0.655200f,
+		0.386207f,
+		0.185069f,
+		0.258056f,
+		0.000000f,
+		0.772800f,
+		0.369000f,
+		0.516300f,
+		0.406200f,
+		0.620700f,
+		0.312368f,
+		0.234204f,
+		0.312368f,
+		0.000000f,
+		0.625200f,
+		0.467000f,
+		0.625200f,
+		0.375000f,
+		0.655200f,
+		0.328442f,
+		0.185069f,
+		0.328443f,
+		0.000000f,
+		0.657200f,
+		0.369000f,
+		0.657200f,
+		0.375000f,
+		0.620700f,
+		0.174562f,
+		-0.453788f,
+		0.116639f,
+		0.000000f,
+		0.351400f,
+		-0.906300f,
+		0.234800f,
+		0.406200f,
+		0.137900f,
+		0.214333f,
+		-0.428429f,
+		0.143213f,
+		0.000000f,
+		0.430700f,
+		-0.855300f,
+		0.287800f,
+		0.406200f,
+		0.172400f,
+		0.182275f,
+		-0.428429f,
+		0.182276f,
+		0.000000f,
+		0.366300f,
+		-0.855300f,
+		0.366300f,
+		0.375000f,
+		0.172400f,
+		0.174562f,
+		-0.453788f,
+		0.116639f,
+		0.000000f,
+		0.351400f,
+		-0.906300f,
+		0.234800f,
+		0.406200f,
+		0.137900f,
+		0.182275f,
+		-0.428429f,
+		0.182276f,
+		0.000000f,
+		0.366300f,
+		-0.855300f,
+		0.366300f,
+		0.375000f,
+		0.172400f,
+		0.148453f,
+		-0.453788f,
+		0.148453f,
+		0.000000f,
+		0.298900f,
+		-0.906300f,
+		0.298900f,
+		0.375000f,
+		0.137900f,
+		0.400580f,
+		0.133764f,
+		0.267659f,
+		0.000000f,
+		0.801400f,
+		0.266600f,
+		0.535400f,
+		0.406200f,
+		0.586200f,
+		0.386207f,
+		0.185069f,
+		0.258056f,
+		0.000000f,
+		0.772800f,
+		0.369000f,
+		0.516300f,
+		0.406200f,
+		0.620700f,
+		0.328442f,
+		0.185069f,
+		0.328443f,
+		0.000000f,
+		0.657200f,
+		0.369000f,
+		0.657200f,
+		0.375000f,
+		0.620700f,
+		0.400580f,
+		0.133764f,
+		0.267659f,
+		0.000000f,
+		0.801400f,
+		0.266600f,
+		0.535400f,
+		0.406200f,
+		0.586200f,
+		0.328442f,
+		0.185069f,
+		0.328443f,
+		0.000000f,
+		0.657200f,
+		0.369000f,
+		0.657200f,
+		0.375000f,
+		0.620700f,
+		0.340665f,
+		0.133764f,
+		0.340666f,
+		0.000000f,
+		0.681500f,
+		0.266600f,
+		0.681500f,
+		0.375000f,
+		0.586200f,
+		0.132744f,
+		-0.473826f,
+		0.088697f,
+		0.000000f,
+		0.268000f,
+		-0.946600f,
+		0.179100f,
+		0.406200f,
+		0.103400f,
+		0.174562f,
+		-0.453788f,
+		0.116639f,
+		0.000000f,
+		0.351400f,
+		-0.906300f,
+		0.234800f,
+		0.406200f,
+		0.137900f,
+		0.148453f,
+		-0.453788f,
+		0.148453f,
+		0.000000f,
+		0.298900f,
+		-0.906300f,
+		0.298900f,
+		0.375000f,
+		0.137900f,
+		0.132744f,
+		-0.473826f,
+		0.088697f,
+		0.000000f,
+		0.268000f,
+		-0.946600f,
+		0.179100f,
+		0.406200f,
+		0.103400f,
+		0.148453f,
+		-0.453788f,
+		0.148453f,
+		0.000000f,
+		0.298900f,
+		-0.906300f,
+		0.298900f,
+		0.375000f,
+		0.137900f,
+		0.112889f,
+		-0.473826f,
+		0.112890f,
+		0.000000f,
+		0.227900f,
+		-0.946600f,
+		0.227900f,
+		0.375000f,
+		0.103400f,
+		0.410257f,
+		0.080891f,
+		0.274125f,
+		0.000000f,
+		0.820600f,
+		0.161200f,
+		0.548300f,
+		0.406200f,
+		0.551700f,
+		0.400580f,
+		0.133764f,
+		0.267659f,
+		0.000000f,
+		0.801400f,
+		0.266600f,
+		0.535400f,
+		0.406200f,
+		0.586200f,
+		0.340665f,
+		0.133764f,
+		0.340666f,
+		0.000000f,
+		0.681500f,
+		0.266600f,
+		0.681500f,
+		0.375000f,
+		0.586200f,
+		0.410257f,
+		0.080891f,
+		0.274125f,
+		0.000000f,
+		0.820600f,
+		0.161200f,
+		0.548300f,
+		0.406200f,
+		0.551700f,
+		0.340665f,
+		0.133764f,
+		0.340666f,
+		0.000000f,
+		0.681500f,
+		0.266600f,
+		0.681500f,
+		0.375000f,
+		0.586200f,
+		0.348895f,
+		0.080891f,
+		0.348895f,
+		0.000000f,
+		0.697800f,
+		0.161200f,
+		0.697800f,
+		0.375000f,
+		0.551700f,
+		0.089370f,
+		-0.488310f,
+		0.059715f,
+		0.000000f,
+		0.181400f,
+		-0.975900f,
+		0.121200f,
+		0.406200f,
+		0.069000f,
+		0.132744f,
+		-0.473826f,
+		0.088697f,
+		0.000000f,
+		0.268000f,
+		-0.946600f,
+		0.179100f,
+		0.406200f,
+		0.103400f,
+		0.112889f,
+		-0.473826f,
+		0.112890f,
+		0.000000f,
+		0.227900f,
+		-0.946600f,
+		0.227900f,
+		0.375000f,
+		0.103400f,
+		0.089370f,
+		-0.488310f,
+		0.059715f,
+		0.000000f,
+		0.181400f,
+		-0.975900f,
+		0.121200f,
+		0.406200f,
+		0.069000f,
+		0.112889f,
+		-0.473826f,
+		0.112890f,
+		0.000000f,
+		0.227900f,
+		-0.946600f,
+		0.227900f,
+		0.375000f,
+		0.103400f,
+		0.076003f,
+		-0.488310f,
+		0.076003f,
+		0.000000f,
+		0.154300f,
+		-0.975900f,
+		0.154300f,
+		0.375000f,
+		0.069000f,
+		0.415124f,
+		0.027069f,
+		0.277377f,
+		0.000000f,
+		0.830300f,
+		0.054000f,
+		0.554700f,
+		0.406200f,
+		0.517200f,
+		0.410257f,
+		0.080891f,
+		0.274125f,
+		0.000000f,
+		0.820600f,
+		0.161200f,
+		0.548300f,
+		0.406200f,
+		0.551700f,
+		0.348895f,
+		0.080891f,
+		0.348895f,
+		0.000000f,
+		0.697800f,
+		0.161200f,
+		0.697800f,
+		0.375000f,
+		0.551700f,
+		0.415124f,
+		0.027069f,
+		0.277377f,
+		0.000000f,
+		0.830300f,
+		0.054000f,
+		0.554700f,
+		0.406200f,
+		0.517200f,
+		0.348895f,
+		0.080891f,
+		0.348895f,
+		0.000000f,
+		0.697800f,
+		0.161200f,
+		0.697800f,
+		0.375000f,
+		0.551700f,
+		0.353034f,
+		0.027069f,
+		0.353034f,
+		0.000000f,
+		0.706100f,
+		0.054000f,
+		0.706100f,
+		0.375000f,
+		0.517200f,
+		0.044948f,
+		0.497069f,
+		0.030034f,
+		0.000000f,
+		0.092700f,
+		0.993700f,
+		0.061900f,
+		0.461700f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.482000f,
+		0.960300f,
+		0.038225f,
+		0.497069f,
+		0.038226f,
+		0.000000f,
+		0.078800f,
+		0.993700f,
+		0.078800f,
+		0.463500f,
+		0.962300f,
+		0.044948f,
+		-0.497069f,
+		0.030034f,
+		0.000000f,
+		0.092700f,
+		-0.993700f,
+		0.061900f,
+		0.406200f,
+		0.034500f,
+		0.089370f,
+		-0.488310f,
+		0.059715f,
+		0.000000f,
+		0.181400f,
+		-0.975900f,
+		0.121200f,
+		0.406200f,
+		0.069000f,
+		0.076003f,
+		-0.488310f,
+		0.076003f,
+		0.000000f,
+		0.154300f,
+		-0.975900f,
+		0.154300f,
+		0.375000f,
+		0.069000f,
+		0.044948f,
+		-0.497069f,
+		0.030034f,
+		0.000000f,
+		0.092700f,
+		-0.993700f,
+		0.061900f,
+		0.406200f,
+		0.034500f,
+		0.076003f,
+		-0.488310f,
+		0.076003f,
+		0.000000f,
+		0.154300f,
+		-0.975900f,
+		0.154300f,
+		0.375000f,
+		0.069000f,
+		0.038226f,
+		-0.497069f,
+		0.038226f,
+		0.000000f,
+		0.078800f,
+		-0.993700f,
+		0.078800f,
+		0.375000f,
+		0.034500f,
+		0.415124f,
+		-0.027069f,
+		0.277377f,
+		0.000000f,
+		0.830300f,
+		-0.054000f,
+		0.554700f,
+		0.406200f,
+		0.482800f,
+		0.415124f,
+		0.027069f,
+		0.277377f,
+		0.000000f,
+		0.830300f,
+		0.054000f,
+		0.554700f,
+		0.406200f,
+		0.517200f,
+		0.353034f,
+		0.027069f,
+		0.353034f,
+		0.000000f,
+		0.706100f,
+		0.054000f,
+		0.706100f,
+		0.375000f,
+		0.517200f,
+		0.415124f,
+		-0.027069f,
+		0.277377f,
+		0.000000f,
+		0.830300f,
+		-0.054000f,
+		0.554700f,
+		0.406200f,
+		0.482800f,
+		0.353034f,
+		0.027069f,
+		0.353034f,
+		0.000000f,
+		0.706100f,
+		0.054000f,
+		0.706100f,
+		0.375000f,
+		0.517200f,
+		0.353034f,
+		-0.027069f,
+		0.353034f,
+		0.000000f,
+		0.706100f,
+		-0.054000f,
+		0.706100f,
+		0.375000f,
+		0.482800f,
+		0.089370f,
+		0.488310f,
+		0.059715f,
+		0.000000f,
+		0.181400f,
+		0.975900f,
+		0.121200f,
+		0.406200f,
+		0.931000f,
+		0.044948f,
+		0.497069f,
+		0.030034f,
+		0.000000f,
+		0.092700f,
+		0.993700f,
+		0.061900f,
+		0.406200f,
+		0.965500f,
+		0.038225f,
+		0.497069f,
+		0.038226f,
+		0.000000f,
+		0.078800f,
+		0.993700f,
+		0.078800f,
+		0.375000f,
+		0.965500f,
+		0.089370f,
+		0.488310f,
+		0.059715f,
+		0.000000f,
+		0.181400f,
+		0.975900f,
+		0.121200f,
+		0.406200f,
+		0.931000f,
+		0.038225f,
+		0.497069f,
+		0.038226f,
+		0.000000f,
+		0.078800f,
+		0.993700f,
+		0.078800f,
+		0.375000f,
+		0.965500f,
+		0.076003f,
+		0.488310f,
+		0.076003f,
+		0.000000f,
+		0.154300f,
+		0.975900f,
+		0.154300f,
+		0.375000f,
+		0.931000f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.411700f,
+		0.051000f,
+		0.044948f,
+		-0.497069f,
+		0.030034f,
+		0.000000f,
+		0.092700f,
+		-0.993700f,
+		0.061900f,
+		0.444400f,
+		0.053800f,
+		0.038226f,
+		-0.497069f,
+		0.038226f,
+		0.000000f,
+		0.078800f,
+		-0.993700f,
+		0.078800f,
+		0.441800f,
+		0.053800f,
+		0.410257f,
+		-0.080891f,
+		0.274125f,
+		0.000000f,
+		0.820600f,
+		-0.161200f,
+		0.548300f,
+		0.406200f,
+		0.448300f,
+		0.415124f,
+		-0.027069f,
+		0.277377f,
+		0.000000f,
+		0.830300f,
+		-0.054000f,
+		0.554700f,
+		0.406200f,
+		0.482800f,
+		0.353034f,
+		-0.027069f,
+		0.353034f,
+		0.000000f,
+		0.706100f,
+		-0.054000f,
+		0.706100f,
+		0.375000f,
+		0.482800f,
+		0.410257f,
+		-0.080891f,
+		0.274125f,
+		0.000000f,
+		0.820600f,
+		-0.161200f,
+		0.548300f,
+		0.406200f,
+		0.448300f,
+		0.353034f,
+		-0.027069f,
+		0.353034f,
+		0.000000f,
+		0.706100f,
+		-0.054000f,
+		0.706100f,
+		0.375000f,
+		0.482800f,
+		0.348895f,
+		-0.080891f,
+		0.348895f,
+		0.000000f,
+		0.697800f,
+		-0.161200f,
+		0.697800f,
+		0.375000f,
+		0.448300f,
+		0.132744f,
+		0.473826f,
+		0.088697f,
+		0.000000f,
+		0.268000f,
+		0.946600f,
+		0.179100f,
+		0.406200f,
+		0.896600f,
+		0.089370f,
+		0.488310f,
+		0.059715f,
+		0.000000f,
+		0.181400f,
+		0.975900f,
+		0.121200f,
+		0.406200f,
+		0.931000f,
+		0.076003f,
+		0.488310f,
+		0.076003f,
+		0.000000f,
+		0.154300f,
+		0.975900f,
+		0.154300f,
+		0.375000f,
+		0.931000f,
+		0.132744f,
+		0.473826f,
+		0.088697f,
+		0.000000f,
+		0.268000f,
+		0.946600f,
+		0.179100f,
+		0.406200f,
+		0.896600f,
+		0.076003f,
+		0.488310f,
+		0.076003f,
+		0.000000f,
+		0.154300f,
+		0.975900f,
+		0.154300f,
+		0.375000f,
+		0.931000f,
+		0.112889f,
+		0.473826f,
+		0.112889f,
+		0.000000f,
+		0.227900f,
+		0.946600f,
+		0.227900f,
+		0.375000f,
+		0.896600f,
+		0.400580f,
+		-0.133764f,
+		0.267659f,
+		0.000000f,
+		0.801400f,
+		-0.266600f,
+		0.535400f,
+		0.406200f,
+		0.413800f,
+		0.410257f,
+		-0.080891f,
+		0.274125f,
+		0.000000f,
+		0.820600f,
+		-0.161200f,
+		0.548300f,
+		0.406200f,
+		0.448300f,
+		0.348895f,
+		-0.080891f,
+		0.348895f,
+		0.000000f,
+		0.697800f,
+		-0.161200f,
+		0.697800f,
+		0.375000f,
+		0.448300f,
+		0.400580f,
+		-0.133764f,
+		0.267659f,
+		0.000000f,
+		0.801400f,
+		-0.266600f,
+		0.535400f,
+		0.406200f,
+		0.413800f,
+		0.348895f,
+		-0.080891f,
+		0.348895f,
+		0.000000f,
+		0.697800f,
+		-0.161200f,
+		0.697800f,
+		0.375000f,
+		0.448300f,
+		0.340665f,
+		-0.133764f,
+		0.340666f,
+		0.000000f,
+		0.681500f,
+		-0.266600f,
+		0.681500f,
+		0.375000f,
+		0.413800f,
+		0.174562f,
+		0.453788f,
+		0.116638f,
+		0.000000f,
+		0.351400f,
+		0.906300f,
+		0.234800f,
+		0.406200f,
+		0.862100f,
+		0.132744f,
+		0.473826f,
+		0.088697f,
+		0.000000f,
+		0.268000f,
+		0.946600f,
+		0.179100f,
+		0.406200f,
+		0.896600f,
+		0.112889f,
+		0.473826f,
+		0.112889f,
+		0.000000f,
+		0.227900f,
+		0.946600f,
+		0.227900f,
+		0.375000f,
+		0.896600f,
+		0.174562f,
+		0.453788f,
+		0.116638f,
+		0.000000f,
+		0.351400f,
+		0.906300f,
+		0.234800f,
+		0.406200f,
+		0.862100f,
+		0.112889f,
+		0.473826f,
+		0.112889f,
+		0.000000f,
+		0.227900f,
+		0.946600f,
+		0.227900f,
+		0.375000f,
+		0.896600f,
+		0.148453f,
+		0.453788f,
+		0.148453f,
+		0.000000f,
+		0.298900f,
+		0.906300f,
+		0.298900f,
+		0.375000f,
+		0.862100f,
+		0.386207f,
+		-0.185069f,
+		0.258056f,
+		0.000000f,
+		0.772800f,
+		-0.369000f,
+		0.516300f,
+		0.406200f,
+		0.379300f,
+		0.400580f,
+		-0.133764f,
+		0.267659f,
+		0.000000f,
+		0.801400f,
+		-0.266600f,
+		0.535400f,
+		0.406200f,
+		0.413800f,
+		0.340665f,
+		-0.133764f,
+		0.340666f,
+		0.000000f,
+		0.681500f,
+		-0.266600f,
+		0.681500f,
+		0.375000f,
+		0.413800f,
+		0.386207f,
+		-0.185069f,
+		0.258056f,
+		0.000000f,
+		0.772800f,
+		-0.369000f,
+		0.516300f,
+		0.406200f,
+		0.379300f,
+		0.340665f,
+		-0.133764f,
+		0.340666f,
+		0.000000f,
+		0.681500f,
+		-0.266600f,
+		0.681500f,
+		0.375000f,
+		0.413800f,
+		0.328442f,
+		-0.185069f,
+		0.328443f,
+		0.000000f,
+		0.657200f,
+		-0.369000f,
+		0.657200f,
+		0.375000f,
+		0.379300f,
+		0.214333f,
+		0.428429f,
+		0.143213f,
+		0.000000f,
+		0.430700f,
+		0.855300f,
+		0.287800f,
+		0.406200f,
+		0.827600f,
+		0.174562f,
+		0.453788f,
+		0.116638f,
+		0.000000f,
+		0.351400f,
+		0.906300f,
+		0.234800f,
+		0.406200f,
+		0.862100f,
+		0.148453f,
+		0.453788f,
+		0.148453f,
+		0.000000f,
+		0.298900f,
+		0.906300f,
+		0.298900f,
+		0.375000f,
+		0.862100f,
+		0.214333f,
+		0.428429f,
+		0.143213f,
+		0.000000f,
+		0.430700f,
+		0.855300f,
+		0.287800f,
+		0.406200f,
+		0.827600f,
+		0.148453f,
+		0.453788f,
+		0.148453f,
+		0.000000f,
+		0.298900f,
+		0.906300f,
+		0.298900f,
+		0.375000f,
+		0.862100f,
+		0.182275f,
+		0.428429f,
+		0.182276f,
+		0.000000f,
+		0.366300f,
+		0.855300f,
+		0.366300f,
+		0.375000f,
+		0.827600f,
+		0.367306f,
+		-0.234204f,
+		0.245426f,
+		0.000000f,
+		0.735200f,
+		-0.467000f,
+		0.491300f,
+		0.406200f,
+		0.344800f,
+		0.386207f,
+		-0.185069f,
+		0.258056f,
+		0.000000f,
+		0.772800f,
+		-0.369000f,
+		0.516300f,
+		0.406200f,
+		0.379300f,
+		0.328442f,
+		-0.185069f,
+		0.328443f,
+		0.000000f,
+		0.657200f,
+		-0.369000f,
+		0.657200f,
+		0.375000f,
+		0.379300f,
+		0.367306f,
+		-0.234204f,
+		0.245426f,
+		0.000000f,
+		0.735200f,
+		-0.467000f,
+		0.491300f,
+		0.406200f,
+		0.344800f,
+		0.328442f,
+		-0.185069f,
+		0.328443f,
+		0.000000f,
+		0.657200f,
+		-0.369000f,
+		0.657200f,
+		0.375000f,
+		0.379300f,
+		0.312368f,
+		-0.234204f,
+		0.312368f,
+		0.000000f,
+		0.625200f,
+		-0.467000f,
+		0.625200f,
+		0.375000f,
+		0.344800f,
+		0.251591f,
+		0.398046f,
+		0.168108f,
+		0.000000f,
+		0.505000f,
+		0.794500f,
+		0.337400f,
+		0.406200f,
+		0.793100f,
+		0.214333f,
+		0.428429f,
+		0.143213f,
+		0.000000f,
+		0.430700f,
+		0.855300f,
+		0.287800f,
+		0.406200f,
+		0.827600f,
+		0.182275f,
+		0.428429f,
+		0.182276f,
+		0.000000f,
+		0.366300f,
+		0.855300f,
+		0.366300f,
+		0.375000f,
+		0.827600f,
+		0.251591f,
+		0.398046f,
+		0.168108f,
+		0.000000f,
+		0.505000f,
+		0.794500f,
+		0.337400f,
+		0.406200f,
+		0.793100f,
+		0.182275f,
+		0.428429f,
+		0.182276f,
+		0.000000f,
+		0.366300f,
+		0.855300f,
+		0.366300f,
+		0.375000f,
+		0.827600f,
+		0.213960f,
+		0.398046f,
+		0.213961f,
+		0.000000f,
+		0.429400f,
+		0.794500f,
+		0.429400f,
+		0.375000f,
+		0.793100f,
+		0.344098f,
+		-0.280594f,
+		0.229919f,
+		0.000000f,
+		0.689100f,
+		-0.559600f,
+		0.460400f,
+		0.406200f,
+		0.310300f,
+		0.367306f,
+		-0.234204f,
+		0.245426f,
+		0.000000f,
+		0.735200f,
+		-0.467000f,
+		0.491300f,
+		0.406200f,
+		0.344800f,
+		0.312368f,
+		-0.234204f,
+		0.312368f,
+		0.000000f,
+		0.625200f,
+		-0.467000f,
+		0.625200f,
+		0.375000f,
+		0.344800f,
+		0.344098f,
+		-0.280594f,
+		0.229919f,
+		0.000000f,
+		0.689100f,
+		-0.559600f,
+		0.460400f,
+		0.406200f,
+		0.310300f,
+		0.312368f,
+		-0.234204f,
+		0.312368f,
+		0.000000f,
+		0.625200f,
+		-0.467000f,
+		0.625200f,
+		0.375000f,
+		0.344800f,
+		0.292632f,
+		-0.280594f,
+		0.292632f,
+		0.000000f,
+		0.586000f,
+		-0.559600f,
+		0.586000f,
+		0.375000f,
+		0.310300f,
+		0.285899f,
+		0.362998f,
+		0.191032f,
+		0.000000f,
+		0.573300f,
+		0.724300f,
+		0.383000f,
+		0.406200f,
+		0.758600f,
+		0.251591f,
+		0.398046f,
+		0.168108f,
+		0.000000f,
+		0.505000f,
+		0.794500f,
+		0.337400f,
+		0.406200f,
+		0.793100f,
+		0.213960f,
+		0.398046f,
+		0.213961f,
+		0.000000f,
+		0.429400f,
+		0.794500f,
+		0.429400f,
+		0.375000f,
+		0.793100f,
+		0.285899f,
+		0.362998f,
+		0.191032f,
+		0.000000f,
+		0.573300f,
+		0.724300f,
+		0.383000f,
+		0.406200f,
+		0.758600f,
+		0.213960f,
+		0.398046f,
+		0.213961f,
+		0.000000f,
+		0.429400f,
+		0.794500f,
+		0.429400f,
+		0.375000f,
+		0.793100f,
+		0.243137f,
+		0.362998f,
+		0.243138f,
+		0.000000f,
+		0.487500f,
+		0.724300f,
+		0.487500f,
+		0.375000f,
+		0.758600f,
+		0.316857f,
+		-0.323693f,
+		0.211717f,
+		0.000000f,
+		0.634900f,
+		-0.645700f,
+		0.424200f,
+		0.406200f,
+		0.275900f,
+		0.344098f,
+		-0.280594f,
+		0.229919f,
+		0.000000f,
+		0.689100f,
+		-0.559600f,
+		0.460400f,
+		0.406200f,
+		0.310300f,
+		0.292632f,
+		-0.280594f,
+		0.292632f,
+		0.000000f,
+		0.586000f,
+		-0.559600f,
+		0.586000f,
+		0.375000f,
+		0.310300f,
+		0.316857f,
+		-0.323693f,
+		0.211717f,
+		0.000000f,
+		0.634900f,
+		-0.645700f,
+		0.424200f,
+		0.406200f,
+		0.275900f,
+		0.292632f,
+		-0.280594f,
+		0.292632f,
+		0.000000f,
+		0.586000f,
+		-0.559600f,
+		0.586000f,
+		0.375000f,
+		0.310300f,
+		0.269464f,
+		-0.323693f,
+		0.269464f,
+		0.000000f,
+		0.539900f,
+		-0.645700f,
+		0.539900f,
+		0.375000f,
+		0.275900f,
+		0.316857f,
+		0.323693f,
+		0.211717f,
+		0.000000f,
+		0.634900f,
+		0.645700f,
+		0.424200f,
+		0.406200f,
+		0.724100f,
+		0.285899f,
+		0.362998f,
+		0.191032f,
+		0.000000f,
+		0.573300f,
+		0.724300f,
+		0.383000f,
+		0.406200f,
+		0.758600f,
+		0.243137f,
+		0.362998f,
+		0.243138f,
+		0.000000f,
+		0.487500f,
+		0.724300f,
+		0.487500f,
+		0.375000f,
+		0.758600f,
+		0.316857f,
+		0.323693f,
+		0.211717f,
+		0.000000f,
+		0.634900f,
+		0.645700f,
+		0.424200f,
+		0.406200f,
+		0.724100f,
+		0.243137f,
+		0.362998f,
+		0.243138f,
+		0.000000f,
+		0.487500f,
+		0.724300f,
+		0.487500f,
+		0.375000f,
+		0.758600f,
+		0.269464f,
+		0.323693f,
+		0.269464f,
+		0.000000f,
+		0.539900f,
+		0.645700f,
+		0.539900f,
+		0.375000f,
+		0.724100f,
+		0.285900f,
+		-0.362998f,
+		0.191032f,
+		0.000000f,
+		0.573300f,
+		-0.724300f,
+		0.383000f,
+		0.406200f,
+		0.241400f,
+		0.316857f,
+		-0.323693f,
+		0.211717f,
+		0.000000f,
+		0.634900f,
+		-0.645700f,
+		0.424200f,
+		0.406200f,
+		0.275900f,
+		0.269464f,
+		-0.323693f,
+		0.269464f,
+		0.000000f,
+		0.539900f,
+		-0.645700f,
+		0.539900f,
+		0.375000f,
+		0.275900f,
+		0.285900f,
+		-0.362998f,
+		0.191032f,
+		0.000000f,
+		0.573300f,
+		-0.724300f,
+		0.383000f,
+		0.406200f,
+		0.241400f,
+		0.269464f,
+		-0.323693f,
+		0.269464f,
+		0.000000f,
+		0.539900f,
+		-0.645700f,
+		0.539900f,
+		0.375000f,
+		0.275900f,
+		0.243137f,
+		-0.362998f,
+		0.243138f,
+		0.000000f,
+		0.487500f,
+		-0.724300f,
+		0.487500f,
+		0.375000f,
+		0.241400f,
+		0.344098f,
+		0.280594f,
+		0.229919f,
+		0.000000f,
+		0.689100f,
+		0.559600f,
+		0.460400f,
+		0.406200f,
+		0.689700f,
+		0.316857f,
+		0.323693f,
+		0.211717f,
+		0.000000f,
+		0.634900f,
+		0.645700f,
+		0.424200f,
+		0.406200f,
+		0.724100f,
+		0.269464f,
+		0.323693f,
+		0.269464f,
+		0.000000f,
+		0.539900f,
+		0.645700f,
+		0.539900f,
+		0.375000f,
+		0.724100f,
+		0.344098f,
+		0.280594f,
+		0.229919f,
+		0.000000f,
+		0.689100f,
+		0.559600f,
+		0.460400f,
+		0.406200f,
+		0.689700f,
+		0.269464f,
+		0.323693f,
+		0.269464f,
+		0.000000f,
+		0.539900f,
+		0.645700f,
+		0.539900f,
+		0.375000f,
+		0.724100f,
+		0.292632f,
+		0.280594f,
+		0.292632f,
+		0.000000f,
+		0.586000f,
+		0.559600f,
+		0.586000f,
+		0.375000f,
+		0.689700f,
+		0.251591f,
+		-0.398046f,
+		0.168108f,
+		0.000000f,
+		0.504900f,
+		-0.794500f,
+		0.337400f,
+		0.406200f,
+		0.206900f,
+		0.285900f,
+		-0.362998f,
+		0.191032f,
+		0.000000f,
+		0.573300f,
+		-0.724300f,
+		0.383000f,
+		0.406200f,
+		0.241400f,
+		0.243137f,
+		-0.362998f,
+		0.243138f,
+		0.000000f,
+		0.487500f,
+		-0.724300f,
+		0.487500f,
+		0.375000f,
+		0.241400f,
+		0.251591f,
+		-0.398046f,
+		0.168108f,
+		0.000000f,
+		0.504900f,
+		-0.794500f,
+		0.337400f,
+		0.406200f,
+		0.206900f,
+		0.243137f,
+		-0.362998f,
+		0.243138f,
+		0.000000f,
+		0.487500f,
+		-0.724300f,
+		0.487500f,
+		0.375000f,
+		0.241400f,
+		0.213960f,
+		-0.398046f,
+		0.213961f,
+		0.000000f,
+		0.429400f,
+		-0.794500f,
+		0.429400f,
+		0.375000f,
+		0.206900f,
+		0.367306f,
+		0.234204f,
+		0.245426f,
+		0.000000f,
+		0.735200f,
+		0.467000f,
+		0.491300f,
+		0.406200f,
+		0.655200f,
+		0.344098f,
+		0.280594f,
+		0.229919f,
+		0.000000f,
+		0.689100f,
+		0.559600f,
+		0.460400f,
+		0.406200f,
+		0.689700f,
+		0.292632f,
+		0.280594f,
+		0.292632f,
+		0.000000f,
+		0.586000f,
+		0.559600f,
+		0.586000f,
+		0.375000f,
+		0.689700f,
+		0.367306f,
+		0.234204f,
+		0.245426f,
+		0.000000f,
+		0.735200f,
+		0.467000f,
+		0.491300f,
+		0.406200f,
+		0.655200f,
+		0.292632f,
+		0.280594f,
+		0.292632f,
+		0.000000f,
+		0.586000f,
+		0.559600f,
+		0.586000f,
+		0.375000f,
+		0.689700f,
+		0.312368f,
+		0.234204f,
+		0.312368f,
+		0.000000f,
+		0.625200f,
+		0.467000f,
+		0.625200f,
+		0.375000f,
+		0.655200f,
+		0.182275f,
+		0.428429f,
+		0.182276f,
+		0.000000f,
+		0.366300f,
+		0.855300f,
+		0.366300f,
+		0.375000f,
+		0.827600f,
+		0.148453f,
+		0.453788f,
+		0.148453f,
+		0.000000f,
+		0.298900f,
+		0.906300f,
+		0.298900f,
+		0.375000f,
+		0.862100f,
+		0.116638f,
+		0.453788f,
+		0.174562f,
+		0.000000f,
+		0.234800f,
+		0.906300f,
+		0.351400f,
+		0.343700f,
+		0.862100f,
+		0.182275f,
+		0.428429f,
+		0.182276f,
+		0.000000f,
+		0.366300f,
+		0.855300f,
+		0.366300f,
+		0.375000f,
+		0.827600f,
+		0.116638f,
+		0.453788f,
+		0.174562f,
+		0.000000f,
+		0.234800f,
+		0.906300f,
+		0.351400f,
+		0.343700f,
+		0.862100f,
+		0.143212f,
+		0.428429f,
+		0.214333f,
+		0.000000f,
+		0.287800f,
+		0.855300f,
+		0.430700f,
+		0.343700f,
+		0.827600f,
+		0.312368f,
+		-0.234204f,
+		0.312368f,
+		0.000000f,
+		0.625200f,
+		-0.467000f,
+		0.625200f,
+		0.375000f,
+		0.344800f,
+		0.328442f,
+		-0.185069f,
+		0.328443f,
+		0.000000f,
+		0.657200f,
+		-0.369000f,
+		0.657200f,
+		0.375000f,
+		0.379300f,
+		0.258055f,
+		-0.185069f,
+		0.386207f,
+		0.000000f,
+		0.516300f,
+		-0.369000f,
+		0.772800f,
+		0.343700f,
+		0.379300f,
+		0.312368f,
+		-0.234204f,
+		0.312368f,
+		0.000000f,
+		0.625200f,
+		-0.467000f,
+		0.625200f,
+		0.375000f,
+		0.344800f,
+		0.258055f,
+		-0.185069f,
+		0.386207f,
+		0.000000f,
+		0.516300f,
+		-0.369000f,
+		0.772800f,
+		0.343700f,
+		0.379300f,
+		0.245426f,
+		-0.234204f,
+		0.367306f,
+		0.000000f,
+		0.491300f,
+		-0.467000f,
+		0.735200f,
+		0.343700f,
+		0.344800f,
+		0.213960f,
+		0.398046f,
+		0.213961f,
+		0.000000f,
+		0.429400f,
+		0.794500f,
+		0.429400f,
+		0.375000f,
+		0.793100f,
+		0.182275f,
+		0.428429f,
+		0.182276f,
+		0.000000f,
+		0.366300f,
+		0.855300f,
+		0.366300f,
+		0.375000f,
+		0.827600f,
+		0.143212f,
+		0.428429f,
+		0.214333f,
+		0.000000f,
+		0.287800f,
+		0.855300f,
+		0.430700f,
+		0.343700f,
+		0.827600f,
+		0.213960f,
+		0.398046f,
+		0.213961f,
+		0.000000f,
+		0.429400f,
+		0.794500f,
+		0.429400f,
+		0.375000f,
+		0.793100f,
+		0.143212f,
+		0.428429f,
+		0.214333f,
+		0.000000f,
+		0.287800f,
+		0.855300f,
+		0.430700f,
+		0.343700f,
+		0.827600f,
+		0.168107f,
+		0.398046f,
+		0.251592f,
+		0.000000f,
+		0.337400f,
+		0.794500f,
+		0.505000f,
+		0.343700f,
+		0.793100f,
+		0.292632f,
+		-0.280594f,
+		0.292632f,
+		0.000000f,
+		0.586000f,
+		-0.559600f,
+		0.586000f,
+		0.375000f,
+		0.310300f,
+		0.312368f,
+		-0.234204f,
+		0.312368f,
+		0.000000f,
+		0.625200f,
+		-0.467000f,
+		0.625200f,
+		0.375000f,
+		0.344800f,
+		0.245426f,
+		-0.234204f,
+		0.367306f,
+		0.000000f,
+		0.491300f,
+		-0.467000f,
+		0.735200f,
+		0.343700f,
+		0.344800f,
+		0.292632f,
+		-0.280594f,
+		0.292632f,
+		0.000000f,
+		0.586000f,
+		-0.559600f,
+		0.586000f,
+		0.375000f,
+		0.310300f,
+		0.245426f,
+		-0.234204f,
+		0.367306f,
+		0.000000f,
+		0.491300f,
+		-0.467000f,
+		0.735200f,
+		0.343700f,
+		0.344800f,
+		0.229919f,
+		-0.280594f,
+		0.344099f,
+		0.000000f,
+		0.460400f,
+		-0.559600f,
+		0.689100f,
+		0.343700f,
+		0.310300f,
+		0.243137f,
+		0.362998f,
+		0.243138f,
+		0.000000f,
+		0.487500f,
+		0.724300f,
+		0.487500f,
+		0.375000f,
+		0.758600f,
+		0.213960f,
+		0.398046f,
+		0.213961f,
+		0.000000f,
+		0.429400f,
+		0.794500f,
+		0.429400f,
+		0.375000f,
+		0.793100f,
+		0.168107f,
+		0.398046f,
+		0.251592f,
+		0.000000f,
+		0.337400f,
+		0.794500f,
+		0.505000f,
+		0.343700f,
+		0.793100f,
+		0.243137f,
+		0.362998f,
+		0.243138f,
+		0.000000f,
+		0.487500f,
+		0.724300f,
+		0.487500f,
+		0.375000f,
+		0.758600f,
+		0.168107f,
+		0.398046f,
+		0.251592f,
+		0.000000f,
+		0.337400f,
+		0.794500f,
+		0.505000f,
+		0.343700f,
+		0.793100f,
+		0.191032f,
+		0.362998f,
+		0.285900f,
+		0.000000f,
+		0.383000f,
+		0.724300f,
+		0.573300f,
+		0.343700f,
+		0.758600f,
+		0.269464f,
+		-0.323693f,
+		0.269464f,
+		0.000000f,
+		0.539900f,
+		-0.645700f,
+		0.539900f,
+		0.375000f,
+		0.275900f,
+		0.292632f,
+		-0.280594f,
+		0.292632f,
+		0.000000f,
+		0.586000f,
+		-0.559600f,
+		0.586000f,
+		0.375000f,
+		0.310300f,
+		0.229919f,
+		-0.280594f,
+		0.344099f,
+		0.000000f,
+		0.460400f,
+		-0.559600f,
+		0.689100f,
+		0.343700f,
+		0.310300f,
+		0.269464f,
+		-0.323693f,
+		0.269464f,
+		0.000000f,
+		0.539900f,
+		-0.645700f,
+		0.539900f,
+		0.375000f,
+		0.275900f,
+		0.229919f,
+		-0.280594f,
+		0.344099f,
+		0.000000f,
+		0.460400f,
+		-0.559600f,
+		0.689100f,
+		0.343700f,
+		0.310300f,
+		0.211717f,
+		-0.323693f,
+		0.316857f,
+		0.000000f,
+		0.424200f,
+		-0.645700f,
+		0.634900f,
+		0.343700f,
+		0.275900f,
+		0.269464f,
+		0.323693f,
+		0.269464f,
+		0.000000f,
+		0.539900f,
+		0.645700f,
+		0.539900f,
+		0.375000f,
+		0.724100f,
+		0.243137f,
+		0.362998f,
+		0.243138f,
+		0.000000f,
+		0.487500f,
+		0.724300f,
+		0.487500f,
+		0.375000f,
+		0.758600f,
+		0.191032f,
+		0.362998f,
+		0.285900f,
+		0.000000f,
+		0.383000f,
+		0.724300f,
+		0.573300f,
+		0.343700f,
+		0.758600f,
+		0.269464f,
+		0.323693f,
+		0.269464f,
+		0.000000f,
+		0.539900f,
+		0.645700f,
+		0.539900f,
+		0.375000f,
+		0.724100f,
+		0.191032f,
+		0.362998f,
+		0.285900f,
+		0.000000f,
+		0.383000f,
+		0.724300f,
+		0.573300f,
+		0.343700f,
+		0.758600f,
+		0.211717f,
+		0.323693f,
+		0.316857f,
+		0.000000f,
+		0.424200f,
+		0.645700f,
+		0.634900f,
+		0.343700f,
+		0.724100f,
+		0.243137f,
+		-0.362998f,
+		0.243138f,
+		0.000000f,
+		0.487500f,
+		-0.724300f,
+		0.487500f,
+		0.375000f,
+		0.241400f,
+		0.269464f,
+		-0.323693f,
+		0.269464f,
+		0.000000f,
+		0.539900f,
+		-0.645700f,
+		0.539900f,
+		0.375000f,
+		0.275900f,
+		0.211717f,
+		-0.323693f,
+		0.316857f,
+		0.000000f,
+		0.424200f,
+		-0.645700f,
+		0.634900f,
+		0.343700f,
+		0.275900f,
+		0.243137f,
+		-0.362998f,
+		0.243138f,
+		0.000000f,
+		0.487500f,
+		-0.724300f,
+		0.487500f,
+		0.375000f,
+		0.241400f,
+		0.211717f,
+		-0.323693f,
+		0.316857f,
+		0.000000f,
+		0.424200f,
+		-0.645700f,
+		0.634900f,
+		0.343700f,
+		0.275900f,
+		0.191032f,
+		-0.362998f,
+		0.285900f,
+		0.000000f,
+		0.383000f,
+		-0.724300f,
+		0.573300f,
+		0.343700f,
+		0.241400f,
+		0.292632f,
+		0.280594f,
+		0.292632f,
+		0.000000f,
+		0.586000f,
+		0.559600f,
+		0.586000f,
+		0.375000f,
+		0.689700f,
+		0.269464f,
+		0.323693f,
+		0.269464f,
+		0.000000f,
+		0.539900f,
+		0.645700f,
+		0.539900f,
+		0.375000f,
+		0.724100f,
+		0.211717f,
+		0.323693f,
+		0.316857f,
+		0.000000f,
+		0.424200f,
+		0.645700f,
+		0.634900f,
+		0.343700f,
+		0.724100f,
+		0.292632f,
+		0.280594f,
+		0.292632f,
+		0.000000f,
+		0.586000f,
+		0.559600f,
+		0.586000f,
+		0.375000f,
+		0.689700f,
+		0.211717f,
+		0.323693f,
+		0.316857f,
+		0.000000f,
+		0.424200f,
+		0.645700f,
+		0.634900f,
+		0.343700f,
+		0.724100f,
+		0.229919f,
+		0.280594f,
+		0.344099f,
+		0.000000f,
+		0.460400f,
+		0.559600f,
+		0.689100f,
+		0.343700f,
+		0.689700f,
+		0.213960f,
+		-0.398046f,
+		0.213961f,
+		0.000000f,
+		0.429400f,
+		-0.794500f,
+		0.429400f,
+		0.375000f,
+		0.206900f,
+		0.243137f,
+		-0.362998f,
+		0.243138f,
+		0.000000f,
+		0.487500f,
+		-0.724300f,
+		0.487500f,
+		0.375000f,
+		0.241400f,
+		0.191032f,
+		-0.362998f,
+		0.285900f,
+		0.000000f,
+		0.383000f,
+		-0.724300f,
+		0.573300f,
+		0.343700f,
+		0.241400f,
+		0.213960f,
+		-0.398046f,
+		0.213961f,
+		0.000000f,
+		0.429400f,
+		-0.794500f,
+		0.429400f,
+		0.375000f,
+		0.206900f,
+		0.191032f,
+		-0.362998f,
+		0.285900f,
+		0.000000f,
+		0.383000f,
+		-0.724300f,
+		0.573300f,
+		0.343700f,
+		0.241400f,
+		0.168107f,
+		-0.398046f,
+		0.251592f,
+		0.000000f,
+		0.337400f,
+		-0.794500f,
+		0.505000f,
+		0.343700f,
+		0.206900f,
+		0.312368f,
+		0.234204f,
+		0.312368f,
+		0.000000f,
+		0.625200f,
+		0.467000f,
+		0.625200f,
+		0.375000f,
+		0.655200f,
+		0.292632f,
+		0.280594f,
+		0.292632f,
+		0.000000f,
+		0.586000f,
+		0.559600f,
+		0.586000f,
+		0.375000f,
+		0.689700f,
+		0.229919f,
+		0.280594f,
+		0.344099f,
+		0.000000f,
+		0.460400f,
+		0.559600f,
+		0.689100f,
+		0.343700f,
+		0.689700f,
+		0.312368f,
+		0.234204f,
+		0.312368f,
+		0.000000f,
+		0.625200f,
+		0.467000f,
+		0.625200f,
+		0.375000f,
+		0.655200f,
+		0.229919f,
+		0.280594f,
+		0.344099f,
+		0.000000f,
+		0.460400f,
+		0.559600f,
+		0.689100f,
+		0.343700f,
+		0.689700f,
+		0.245426f,
+		0.234204f,
+		0.367306f,
+		0.000000f,
+		0.491300f,
+		0.467000f,
+		0.735200f,
+		0.343700f,
+		0.655200f,
+		0.182275f,
+		-0.428429f,
+		0.182276f,
+		0.000000f,
+		0.366300f,
+		-0.855300f,
+		0.366300f,
+		0.375000f,
+		0.172400f,
+		0.213960f,
+		-0.398046f,
+		0.213961f,
+		0.000000f,
+		0.429400f,
+		-0.794500f,
+		0.429400f,
+		0.375000f,
+		0.206900f,
+		0.168107f,
+		-0.398046f,
+		0.251592f,
+		0.000000f,
+		0.337400f,
+		-0.794500f,
+		0.505000f,
+		0.343700f,
+		0.206900f,
+		0.182275f,
+		-0.428429f,
+		0.182276f,
+		0.000000f,
+		0.366300f,
+		-0.855300f,
+		0.366300f,
+		0.375000f,
+		0.172400f,
+		0.168107f,
+		-0.398046f,
+		0.251592f,
+		0.000000f,
+		0.337400f,
+		-0.794500f,
+		0.505000f,
+		0.343700f,
+		0.206900f,
+		0.143212f,
+		-0.428429f,
+		0.214334f,
+		0.000000f,
+		0.287800f,
+		-0.855300f,
+		0.430700f,
+		0.343700f,
+		0.172400f,
+		0.328442f,
+		0.185069f,
+		0.328443f,
+		0.000000f,
+		0.657200f,
+		0.369000f,
+		0.657200f,
+		0.375000f,
+		0.620700f,
+		0.312368f,
+		0.234204f,
+		0.312368f,
+		0.000000f,
+		0.625200f,
+		0.467000f,
+		0.625200f,
+		0.375000f,
+		0.655200f,
+		0.245426f,
+		0.234204f,
+		0.367306f,
+		0.000000f,
+		0.491300f,
+		0.467000f,
+		0.735200f,
+		0.343700f,
+		0.655200f,
+		0.328442f,
+		0.185069f,
+		0.328443f,
+		0.000000f,
+		0.657200f,
+		0.369000f,
+		0.657200f,
+		0.375000f,
+		0.620700f,
+		0.245426f,
+		0.234204f,
+		0.367306f,
+		0.000000f,
+		0.491300f,
+		0.467000f,
+		0.735200f,
+		0.343700f,
+		0.655200f,
+		0.258055f,
+		0.185069f,
+		0.386207f,
+		0.000000f,
+		0.516300f,
+		0.369000f,
+		0.772800f,
+		0.343700f,
+		0.620700f,
+		0.148453f,
+		-0.453788f,
+		0.148453f,
+		0.000000f,
+		0.298900f,
+		-0.906300f,
+		0.298900f,
+		0.375000f,
+		0.137900f,
+		0.182275f,
+		-0.428429f,
+		0.182276f,
+		0.000000f,
+		0.366300f,
+		-0.855300f,
+		0.366300f,
+		0.375000f,
+		0.172400f,
+		0.143212f,
+		-0.428429f,
+		0.214334f,
+		0.000000f,
+		0.287800f,
+		-0.855300f,
+		0.430700f,
+		0.343700f,
+		0.172400f,
+		0.148453f,
+		-0.453788f,
+		0.148453f,
+		0.000000f,
+		0.298900f,
+		-0.906300f,
+		0.298900f,
+		0.375000f,
+		0.137900f,
+		0.143212f,
+		-0.428429f,
+		0.214334f,
+		0.000000f,
+		0.287800f,
+		-0.855300f,
+		0.430700f,
+		0.343700f,
+		0.172400f,
+		0.116638f,
+		-0.453788f,
+		0.174562f,
+		0.000000f,
+		0.234800f,
+		-0.906300f,
+		0.351400f,
+		0.343700f,
+		0.137900f,
+		0.340665f,
+		0.133764f,
+		0.340666f,
+		0.000000f,
+		0.681500f,
+		0.266600f,
+		0.681500f,
+		0.375000f,
+		0.586200f,
+		0.328442f,
+		0.185069f,
+		0.328443f,
+		0.000000f,
+		0.657200f,
+		0.369000f,
+		0.657200f,
+		0.375000f,
+		0.620700f,
+		0.258055f,
+		0.185069f,
+		0.386207f,
+		0.000000f,
+		0.516300f,
+		0.369000f,
+		0.772800f,
+		0.343700f,
+		0.620700f,
+		0.340665f,
+		0.133764f,
+		0.340666f,
+		0.000000f,
+		0.681500f,
+		0.266600f,
+		0.681500f,
+		0.375000f,
+		0.586200f,
+		0.258055f,
+		0.185069f,
+		0.386207f,
+		0.000000f,
+		0.516300f,
+		0.369000f,
+		0.772800f,
+		0.343700f,
+		0.620700f,
+		0.267659f,
+		0.133764f,
+		0.400581f,
+		0.000000f,
+		0.535400f,
+		0.266600f,
+		0.801400f,
+		0.343700f,
+		0.586200f,
+		0.112889f,
+		-0.473826f,
+		0.112890f,
+		0.000000f,
+		0.227900f,
+		-0.946600f,
+		0.227900f,
+		0.375000f,
+		0.103400f,
+		0.148453f,
+		-0.453788f,
+		0.148453f,
+		0.000000f,
+		0.298900f,
+		-0.906300f,
+		0.298900f,
+		0.375000f,
+		0.137900f,
+		0.116638f,
+		-0.453788f,
+		0.174562f,
+		0.000000f,
+		0.234800f,
+		-0.906300f,
+		0.351400f,
+		0.343700f,
+		0.137900f,
+		0.112889f,
+		-0.473826f,
+		0.112890f,
+		0.000000f,
+		0.227900f,
+		-0.946600f,
+		0.227900f,
+		0.375000f,
+		0.103400f,
+		0.116638f,
+		-0.453788f,
+		0.174562f,
+		0.000000f,
+		0.234800f,
+		-0.906300f,
+		0.351400f,
+		0.343700f,
+		0.137900f,
+		0.088697f,
+		-0.473826f,
+		0.132745f,
+		0.000000f,
+		0.179100f,
+		-0.946600f,
+		0.268000f,
+		0.343700f,
+		0.103400f,
+		0.348895f,
+		0.080891f,
+		0.348895f,
+		0.000000f,
+		0.697800f,
+		0.161200f,
+		0.697800f,
+		0.375000f,
+		0.551700f,
+		0.340665f,
+		0.133764f,
+		0.340666f,
+		0.000000f,
+		0.681500f,
+		0.266600f,
+		0.681500f,
+		0.375000f,
+		0.586200f,
+		0.267659f,
+		0.133764f,
+		0.400581f,
+		0.000000f,
+		0.535400f,
+		0.266600f,
+		0.801400f,
+		0.343700f,
+		0.586200f,
+		0.348895f,
+		0.080891f,
+		0.348895f,
+		0.000000f,
+		0.697800f,
+		0.161200f,
+		0.697800f,
+		0.375000f,
+		0.551700f,
+		0.267659f,
+		0.133764f,
+		0.400581f,
+		0.000000f,
+		0.535400f,
+		0.266600f,
+		0.801400f,
+		0.343700f,
+		0.586200f,
+		0.274125f,
+		0.080891f,
+		0.410257f,
+		0.000000f,
+		0.548300f,
+		0.161200f,
+		0.820600f,
+		0.343700f,
+		0.551700f,
+		0.076003f,
+		-0.488310f,
+		0.076003f,
+		0.000000f,
+		0.154300f,
+		-0.975900f,
+		0.154300f,
+		0.375000f,
+		0.069000f,
+		0.112889f,
+		-0.473826f,
+		0.112890f,
+		0.000000f,
+		0.227900f,
+		-0.946600f,
+		0.227900f,
+		0.375000f,
+		0.103400f,
+		0.088697f,
+		-0.473826f,
+		0.132745f,
+		0.000000f,
+		0.179100f,
+		-0.946600f,
+		0.268000f,
+		0.343700f,
+		0.103400f,
+		0.076003f,
+		-0.488310f,
+		0.076003f,
+		0.000000f,
+		0.154300f,
+		-0.975900f,
+		0.154300f,
+		0.375000f,
+		0.069000f,
+		0.088697f,
+		-0.473826f,
+		0.132745f,
+		0.000000f,
+		0.179100f,
+		-0.946600f,
+		0.268000f,
+		0.343700f,
+		0.103400f,
+		0.059715f,
+		-0.488310f,
+		0.089370f,
+		0.000000f,
+		0.121200f,
+		-0.975900f,
+		0.181400f,
+		0.343700f,
+		0.069000f,
+		0.353034f,
+		0.027069f,
+		0.353034f,
+		0.000000f,
+		0.706100f,
+		0.054000f,
+		0.706100f,
+		0.375000f,
+		0.517200f,
+		0.348895f,
+		0.080891f,
+		0.348895f,
+		0.000000f,
+		0.697800f,
+		0.161200f,
+		0.697800f,
+		0.375000f,
+		0.551700f,
+		0.274125f,
+		0.080891f,
+		0.410257f,
+		0.000000f,
+		0.548300f,
+		0.161200f,
+		0.820600f,
+		0.343700f,
+		0.551700f,
+		0.353034f,
+		0.027069f,
+		0.353034f,
+		0.000000f,
+		0.706100f,
+		0.054000f,
+		0.706100f,
+		0.375000f,
+		0.517200f,
+		0.274125f,
+		0.080891f,
+		0.410257f,
+		0.000000f,
+		0.548300f,
+		0.161200f,
+		0.820600f,
+		0.343700f,
+		0.551700f,
+		0.277377f,
+		0.027069f,
+		0.415125f,
+		0.000000f,
+		0.554700f,
+		0.054000f,
+		0.830300f,
+		0.343700f,
+		0.517200f,
+		0.038225f,
+		0.497069f,
+		0.038226f,
+		0.000000f,
+		0.078800f,
+		0.993700f,
+		0.078800f,
+		0.463500f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.482000f,
+		0.960300f,
+		0.030033f,
+		0.497069f,
+		0.044948f,
+		0.000000f,
+		0.061900f,
+		0.993700f,
+		0.092700f,
+		0.465300f,
+		0.962300f,
+		0.038226f,
+		-0.497069f,
+		0.038226f,
+		0.000000f,
+		0.078800f,
+		-0.993700f,
+		0.078800f,
+		0.375000f,
+		0.034500f,
+		0.076003f,
+		-0.488310f,
+		0.076003f,
+		0.000000f,
+		0.154300f,
+		-0.975900f,
+		0.154300f,
+		0.375000f,
+		0.069000f,
+		0.059715f,
+		-0.488310f,
+		0.089370f,
+		0.000000f,
+		0.121200f,
+		-0.975900f,
+		0.181400f,
+		0.343700f,
+		0.069000f,
+		0.038226f,
+		-0.497069f,
+		0.038226f,
+		0.000000f,
+		0.078800f,
+		-0.993700f,
+		0.078800f,
+		0.375000f,
+		0.034500f,
+		0.059715f,
+		-0.488310f,
+		0.089370f,
+		0.000000f,
+		0.121200f,
+		-0.975900f,
+		0.181400f,
+		0.343700f,
+		0.069000f,
+		0.030034f,
+		-0.497069f,
+		0.044949f,
+		0.000000f,
+		0.061900f,
+		-0.993700f,
+		0.092700f,
+		0.343700f,
+		0.034500f,
+		0.353034f,
+		-0.027069f,
+		0.353034f,
+		0.000000f,
+		0.706100f,
+		-0.054000f,
+		0.706100f,
+		0.375000f,
+		0.482800f,
+		0.353034f,
+		0.027069f,
+		0.353034f,
+		0.000000f,
+		0.706100f,
+		0.054000f,
+		0.706100f,
+		0.375000f,
+		0.517200f,
+		0.277377f,
+		0.027069f,
+		0.415125f,
+		0.000000f,
+		0.554700f,
+		0.054000f,
+		0.830300f,
+		0.343700f,
+		0.517200f,
+		0.353034f,
+		-0.027069f,
+		0.353034f,
+		0.000000f,
+		0.706100f,
+		-0.054000f,
+		0.706100f,
+		0.375000f,
+		0.482800f,
+		0.277377f,
+		0.027069f,
+		0.415125f,
+		0.000000f,
+		0.554700f,
+		0.054000f,
+		0.830300f,
+		0.343700f,
+		0.517200f,
+		0.277377f,
+		-0.027069f,
+		0.415125f,
+		0.000000f,
+		0.554700f,
+		-0.054000f,
+		0.830300f,
+		0.343700f,
+		0.482800f,
+		0.076003f,
+		0.488310f,
+		0.076003f,
+		0.000000f,
+		0.154300f,
+		0.975900f,
+		0.154300f,
+		0.375000f,
+		0.931000f,
+		0.038225f,
+		0.497069f,
+		0.038226f,
+		0.000000f,
+		0.078800f,
+		0.993700f,
+		0.078800f,
+		0.375000f,
+		0.965500f,
+		0.030033f,
+		0.497069f,
+		0.044948f,
+		0.000000f,
+		0.061900f,
+		0.993700f,
+		0.092700f,
+		0.343700f,
+		0.965500f,
+		0.076003f,
+		0.488310f,
+		0.076003f,
+		0.000000f,
+		0.154300f,
+		0.975900f,
+		0.154300f,
+		0.375000f,
+		0.931000f,
+		0.030033f,
+		0.497069f,
+		0.044948f,
+		0.000000f,
+		0.061900f,
+		0.993700f,
+		0.092700f,
+		0.343700f,
+		0.965500f,
+		0.059715f,
+		0.488310f,
+		0.089370f,
+		0.000000f,
+		0.121200f,
+		0.975900f,
+		0.181400f,
+		0.343700f,
+		0.931000f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.411700f,
+		0.051000f,
+		0.038226f,
+		-0.497069f,
+		0.038226f,
+		0.000000f,
+		0.078800f,
+		-0.993700f,
+		0.078800f,
+		0.441800f,
+		0.053800f,
+		0.030034f,
+		-0.497069f,
+		0.044949f,
+		0.000000f,
+		0.061900f,
+		-0.993700f,
+		0.092700f,
+		0.439200f,
+		0.053800f,
+		0.348895f,
+		-0.080891f,
+		0.348895f,
+		0.000000f,
+		0.697800f,
+		-0.161200f,
+		0.697800f,
+		0.375000f,
+		0.448300f,
+		0.353034f,
+		-0.027069f,
+		0.353034f,
+		0.000000f,
+		0.706100f,
+		-0.054000f,
+		0.706100f,
+		0.375000f,
+		0.482800f,
+		0.277377f,
+		-0.027069f,
+		0.415125f,
+		0.000000f,
+		0.554700f,
+		-0.054000f,
+		0.830300f,
+		0.343700f,
+		0.482800f,
+		0.348895f,
+		-0.080891f,
+		0.348895f,
+		0.000000f,
+		0.697800f,
+		-0.161200f,
+		0.697800f,
+		0.375000f,
+		0.448300f,
+		0.277377f,
+		-0.027069f,
+		0.415125f,
+		0.000000f,
+		0.554700f,
+		-0.054000f,
+		0.830300f,
+		0.343700f,
+		0.482800f,
+		0.274125f,
+		-0.080891f,
+		0.410257f,
+		0.000000f,
+		0.548300f,
+		-0.161200f,
+		0.820600f,
+		0.343700f,
+		0.448300f,
+		0.112889f,
+		0.473826f,
+		0.112889f,
+		0.000000f,
+		0.227900f,
+		0.946600f,
+		0.227900f,
+		0.375000f,
+		0.896600f,
+		0.076003f,
+		0.488310f,
+		0.076003f,
+		0.000000f,
+		0.154300f,
+		0.975900f,
+		0.154300f,
+		0.375000f,
+		0.931000f,
+		0.059715f,
+		0.488310f,
+		0.089370f,
+		0.000000f,
+		0.121200f,
+		0.975900f,
+		0.181400f,
+		0.343700f,
+		0.931000f,
+		0.112889f,
+		0.473826f,
+		0.112889f,
+		0.000000f,
+		0.227900f,
+		0.946600f,
+		0.227900f,
+		0.375000f,
+		0.896600f,
+		0.059715f,
+		0.488310f,
+		0.089370f,
+		0.000000f,
+		0.121200f,
+		0.975900f,
+		0.181400f,
+		0.343700f,
+		0.931000f,
+		0.088697f,
+		0.473826f,
+		0.132745f,
+		0.000000f,
+		0.179100f,
+		0.946600f,
+		0.268000f,
+		0.343700f,
+		0.896600f,
+		0.340665f,
+		-0.133764f,
+		0.340666f,
+		0.000000f,
+		0.681500f,
+		-0.266600f,
+		0.681500f,
+		0.375000f,
+		0.413800f,
+		0.348895f,
+		-0.080891f,
+		0.348895f,
+		0.000000f,
+		0.697800f,
+		-0.161200f,
+		0.697800f,
+		0.375000f,
+		0.448300f,
+		0.274125f,
+		-0.080891f,
+		0.410257f,
+		0.000000f,
+		0.548300f,
+		-0.161200f,
+		0.820600f,
+		0.343700f,
+		0.448300f,
+		0.340665f,
+		-0.133764f,
+		0.340666f,
+		0.000000f,
+		0.681500f,
+		-0.266600f,
+		0.681500f,
+		0.375000f,
+		0.413800f,
+		0.274125f,
+		-0.080891f,
+		0.410257f,
+		0.000000f,
+		0.548300f,
+		-0.161200f,
+		0.820600f,
+		0.343700f,
+		0.448300f,
+		0.267659f,
+		-0.133764f,
+		0.400581f,
+		0.000000f,
+		0.535400f,
+		-0.266600f,
+		0.801400f,
+		0.343700f,
+		0.413800f,
+		0.148453f,
+		0.453788f,
+		0.148453f,
+		0.000000f,
+		0.298900f,
+		0.906300f,
+		0.298900f,
+		0.375000f,
+		0.862100f,
+		0.112889f,
+		0.473826f,
+		0.112889f,
+		0.000000f,
+		0.227900f,
+		0.946600f,
+		0.227900f,
+		0.375000f,
+		0.896600f,
+		0.088697f,
+		0.473826f,
+		0.132745f,
+		0.000000f,
+		0.179100f,
+		0.946600f,
+		0.268000f,
+		0.343700f,
+		0.896600f,
+		0.148453f,
+		0.453788f,
+		0.148453f,
+		0.000000f,
+		0.298900f,
+		0.906300f,
+		0.298900f,
+		0.375000f,
+		0.862100f,
+		0.088697f,
+		0.473826f,
+		0.132745f,
+		0.000000f,
+		0.179100f,
+		0.946600f,
+		0.268000f,
+		0.343700f,
+		0.896600f,
+		0.116638f,
+		0.453788f,
+		0.174562f,
+		0.000000f,
+		0.234800f,
+		0.906300f,
+		0.351400f,
+		0.343700f,
+		0.862100f,
+		0.328442f,
+		-0.185069f,
+		0.328443f,
+		0.000000f,
+		0.657200f,
+		-0.369000f,
+		0.657200f,
+		0.375000f,
+		0.379300f,
+		0.340665f,
+		-0.133764f,
+		0.340666f,
+		0.000000f,
+		0.681500f,
+		-0.266600f,
+		0.681500f,
+		0.375000f,
+		0.413800f,
+		0.267659f,
+		-0.133764f,
+		0.400581f,
+		0.000000f,
+		0.535400f,
+		-0.266600f,
+		0.801400f,
+		0.343700f,
+		0.413800f,
+		0.328442f,
+		-0.185069f,
+		0.328443f,
+		0.000000f,
+		0.657200f,
+		-0.369000f,
+		0.657200f,
+		0.375000f,
+		0.379300f,
+		0.267659f,
+		-0.133764f,
+		0.400581f,
+		0.000000f,
+		0.535400f,
+		-0.266600f,
+		0.801400f,
+		0.343700f,
+		0.413800f,
+		0.258055f,
+		-0.185069f,
+		0.386207f,
+		0.000000f,
+		0.516300f,
+		-0.369000f,
+		0.772800f,
+		0.343700f,
+		0.379300f,
+		0.274125f,
+		0.080891f,
+		0.410257f,
+		0.000000f,
+		0.548300f,
+		0.161200f,
+		0.820600f,
+		0.343700f,
+		0.551700f,
+		0.267659f,
+		0.133764f,
+		0.400581f,
+		0.000000f,
+		0.535400f,
+		0.266600f,
+		0.801400f,
+		0.343700f,
+		0.586200f,
+		0.184366f,
+		0.133764f,
+		0.445101f,
+		0.000000f,
+		0.368800f,
+		0.266600f,
+		0.890400f,
+		0.312500f,
+		0.586200f,
+		0.274125f,
+		0.080891f,
+		0.410257f,
+		0.000000f,
+		0.548300f,
+		0.161200f,
+		0.820600f,
+		0.343700f,
+		0.551700f,
+		0.184366f,
+		0.133764f,
+		0.445101f,
+		0.000000f,
+		0.368800f,
+		0.266600f,
+		0.890400f,
+		0.312500f,
+		0.586200f,
+		0.188820f,
+		0.080891f,
+		0.455853f,
+		0.000000f,
+		0.377700f,
+		0.161200f,
+		0.911800f,
+		0.312500f,
+		0.551700f,
+		0.059715f,
+		-0.488310f,
+		0.089370f,
+		0.000000f,
+		0.121200f,
+		-0.975900f,
+		0.181400f,
+		0.343700f,
+		0.069000f,
+		0.088697f,
+		-0.473826f,
+		0.132745f,
+		0.000000f,
+		0.179100f,
+		-0.946600f,
+		0.268000f,
+		0.343700f,
+		0.103400f,
+		0.061095f,
+		-0.473826f,
+		0.147498f,
+		0.000000f,
+		0.123300f,
+		-0.946600f,
+		0.297800f,
+		0.312500f,
+		0.103400f,
+		0.059715f,
+		-0.488310f,
+		0.089370f,
+		0.000000f,
+		0.121200f,
+		-0.975900f,
+		0.181400f,
+		0.343700f,
+		0.069000f,
+		0.061095f,
+		-0.473826f,
+		0.147498f,
+		0.000000f,
+		0.123300f,
+		-0.946600f,
+		0.297800f,
+		0.312500f,
+		0.103400f,
+		0.041132f,
+		-0.488310f,
+		0.099303f,
+		0.000000f,
+		0.083500f,
+		-0.975900f,
+		0.201600f,
+		0.312500f,
+		0.069000f,
+		0.277377f,
+		0.027069f,
+		0.415125f,
+		0.000000f,
+		0.554700f,
+		0.054000f,
+		0.830300f,
+		0.343700f,
+		0.517200f,
+		0.274125f,
+		0.080891f,
+		0.410257f,
+		0.000000f,
+		0.548300f,
+		0.161200f,
+		0.820600f,
+		0.343700f,
+		0.551700f,
+		0.188820f,
+		0.080891f,
+		0.455853f,
+		0.000000f,
+		0.377700f,
+		0.161200f,
+		0.911800f,
+		0.312500f,
+		0.551700f,
+		0.277377f,
+		0.027069f,
+		0.415125f,
+		0.000000f,
+		0.554700f,
+		0.054000f,
+		0.830300f,
+		0.343700f,
+		0.517200f,
+		0.188820f,
+		0.080891f,
+		0.455853f,
+		0.000000f,
+		0.377700f,
+		0.161200f,
+		0.911800f,
+		0.312500f,
+		0.551700f,
+		0.191060f,
+		0.027069f,
+		0.461262f,
+		0.000000f,
+		0.382100f,
+		0.054000f,
+		0.922500f,
+		0.312500f,
+		0.517200f,
+		0.030033f,
+		0.497069f,
+		0.044948f,
+		0.000000f,
+		0.061900f,
+		0.993700f,
+		0.092700f,
+		0.465300f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.482000f,
+		0.960300f,
+		0.020687f,
+		0.497069f,
+		0.049944f,
+		0.000000f,
+		0.042600f,
+		0.993700f,
+		0.103000f,
+		0.467100f,
+		0.962300f,
+		0.030034f,
+		-0.497069f,
+		0.044949f,
+		0.000000f,
+		0.061900f,
+		-0.993700f,
+		0.092700f,
+		0.343700f,
+		0.034500f,
+		0.059715f,
+		-0.488310f,
+		0.089370f,
+		0.000000f,
+		0.121200f,
+		-0.975900f,
+		0.181400f,
+		0.343700f,
+		0.069000f,
+		0.041132f,
+		-0.488310f,
+		0.099303f,
+		0.000000f,
+		0.083500f,
+		-0.975900f,
+		0.201600f,
+		0.312500f,
+		0.069000f,
+		0.030034f,
+		-0.497069f,
+		0.044949f,
+		0.000000f,
+		0.061900f,
+		-0.993700f,
+		0.092700f,
+		0.343700f,
+		0.034500f,
+		0.041132f,
+		-0.488310f,
+		0.099303f,
+		0.000000f,
+		0.083500f,
+		-0.975900f,
+		0.201600f,
+		0.312500f,
+		0.069000f,
+		0.020687f,
+		-0.497069f,
+		0.049945f,
+		0.000000f,
+		0.042600f,
+		-0.993700f,
+		0.103000f,
+		0.312500f,
+		0.034500f,
+		0.277377f,
+		-0.027069f,
+		0.415125f,
+		0.000000f,
+		0.554700f,
+		-0.054000f,
+		0.830300f,
+		0.343700f,
+		0.482800f,
+		0.277377f,
+		0.027069f,
+		0.415125f,
+		0.000000f,
+		0.554700f,
+		0.054000f,
+		0.830300f,
+		0.343700f,
+		0.517200f,
+		0.191060f,
+		0.027069f,
+		0.461262f,
+		0.000000f,
+		0.382100f,
+		0.054000f,
+		0.922500f,
+		0.312500f,
+		0.517200f,
+		0.277377f,
+		-0.027069f,
+		0.415125f,
+		0.000000f,
+		0.554700f,
+		-0.054000f,
+		0.830300f,
+		0.343700f,
+		0.482800f,
+		0.191060f,
+		0.027069f,
+		0.461262f,
+		0.000000f,
+		0.382100f,
+		0.054000f,
+		0.922500f,
+		0.312500f,
+		0.517200f,
+		0.191060f,
+		-0.027069f,
+		0.461262f,
+		0.000000f,
+		0.382100f,
+		-0.054000f,
+		0.922500f,
+		0.312500f,
+		0.482800f,
+		0.059715f,
+		0.488310f,
+		0.089370f,
+		0.000000f,
+		0.121200f,
+		0.975900f,
+		0.181400f,
+		0.343700f,
+		0.931000f,
+		0.030033f,
+		0.497069f,
+		0.044948f,
+		0.000000f,
+		0.061900f,
+		0.993700f,
+		0.092700f,
+		0.343700f,
+		0.965500f,
+		0.020687f,
+		0.497069f,
+		0.049944f,
+		0.000000f,
+		0.042600f,
+		0.993700f,
+		0.103000f,
+		0.312500f,
+		0.965500f,
+		0.059715f,
+		0.488310f,
+		0.089370f,
+		0.000000f,
+		0.121200f,
+		0.975900f,
+		0.181400f,
+		0.343700f,
+		0.931000f,
+		0.020687f,
+		0.497069f,
+		0.049944f,
+		0.000000f,
+		0.042600f,
+		0.993700f,
+		0.103000f,
+		0.312500f,
+		0.965500f,
+		0.041132f,
+		0.488310f,
+		0.099303f,
+		0.000000f,
+		0.083500f,
+		0.975900f,
+		0.201600f,
+		0.312500f,
+		0.931000f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.411700f,
+		0.051000f,
+		0.030034f,
+		-0.497069f,
+		0.044949f,
+		0.000000f,
+		0.061900f,
+		-0.993700f,
+		0.092700f,
+		0.439200f,
+		0.053800f,
+		0.020687f,
+		-0.497069f,
+		0.049945f,
+		0.000000f,
+		0.042600f,
+		-0.993700f,
+		0.103000f,
+		0.436600f,
+		0.053800f,
+		0.274125f,
+		-0.080891f,
+		0.410257f,
+		0.000000f,
+		0.548300f,
+		-0.161200f,
+		0.820600f,
+		0.343700f,
+		0.448300f,
+		0.277377f,
+		-0.027069f,
+		0.415125f,
+		0.000000f,
+		0.554700f,
+		-0.054000f,
+		0.830300f,
+		0.343700f,
+		0.482800f,
+		0.191060f,
+		-0.027069f,
+		0.461262f,
+		0.000000f,
+		0.382100f,
+		-0.054000f,
+		0.922500f,
+		0.312500f,
+		0.482800f,
+		0.274125f,
+		-0.080891f,
+		0.410257f,
+		0.000000f,
+		0.548300f,
+		-0.161200f,
+		0.820600f,
+		0.343700f,
+		0.448300f,
+		0.191060f,
+		-0.027069f,
+		0.461262f,
+		0.000000f,
+		0.382100f,
+		-0.054000f,
+		0.922500f,
+		0.312500f,
+		0.482800f,
+		0.188820f,
+		-0.080891f,
+		0.455853f,
+		0.000000f,
+		0.377700f,
+		-0.161200f,
+		0.911800f,
+		0.312500f,
+		0.448300f,
+		0.088697f,
+		0.473826f,
+		0.132745f,
+		0.000000f,
+		0.179100f,
+		0.946600f,
+		0.268000f,
+		0.343700f,
+		0.896600f,
+		0.059715f,
+		0.488310f,
+		0.089370f,
+		0.000000f,
+		0.121200f,
+		0.975900f,
+		0.181400f,
+		0.343700f,
+		0.931000f,
+		0.041132f,
+		0.488310f,
+		0.099303f,
+		0.000000f,
+		0.083500f,
+		0.975900f,
+		0.201600f,
+		0.312500f,
+		0.931000f,
+		0.088697f,
+		0.473826f,
+		0.132745f,
+		0.000000f,
+		0.179100f,
+		0.946600f,
+		0.268000f,
+		0.343700f,
+		0.896600f,
+		0.041132f,
+		0.488310f,
+		0.099303f,
+		0.000000f,
+		0.083500f,
+		0.975900f,
+		0.201600f,
+		0.312500f,
+		0.931000f,
+		0.061095f,
+		0.473826f,
+		0.147498f,
+		0.000000f,
+		0.123300f,
+		0.946600f,
+		0.297800f,
+		0.312500f,
+		0.896600f,
+		0.267659f,
+		-0.133764f,
+		0.400581f,
+		0.000000f,
+		0.535400f,
+		-0.266600f,
+		0.801400f,
+		0.343700f,
+		0.413800f,
+		0.274125f,
+		-0.080891f,
+		0.410257f,
+		0.000000f,
+		0.548300f,
+		-0.161200f,
+		0.820600f,
+		0.343700f,
+		0.448300f,
+		0.188820f,
+		-0.080891f,
+		0.455853f,
+		0.000000f,
+		0.377700f,
+		-0.161200f,
+		0.911800f,
+		0.312500f,
+		0.448300f,
+		0.267659f,
+		-0.133764f,
+		0.400581f,
+		0.000000f,
+		0.535400f,
+		-0.266600f,
+		0.801400f,
+		0.343700f,
+		0.413800f,
+		0.188820f,
+		-0.080891f,
+		0.455853f,
+		0.000000f,
+		0.377700f,
+		-0.161200f,
+		0.911800f,
+		0.312500f,
+		0.448300f,
+		0.184366f,
+		-0.133764f,
+		0.445101f,
+		0.000000f,
+		0.368800f,
+		-0.266600f,
+		0.890400f,
+		0.312500f,
+		0.413800f,
+		0.116638f,
+		0.453788f,
+		0.174562f,
+		0.000000f,
+		0.234800f,
+		0.906300f,
+		0.351400f,
+		0.343700f,
+		0.862100f,
+		0.088697f,
+		0.473826f,
+		0.132745f,
+		0.000000f,
+		0.179100f,
+		0.946600f,
+		0.268000f,
+		0.343700f,
+		0.896600f,
+		0.061095f,
+		0.473826f,
+		0.147498f,
+		0.000000f,
+		0.123300f,
+		0.946600f,
+		0.297800f,
+		0.312500f,
+		0.896600f,
+		0.116638f,
+		0.453788f,
+		0.174562f,
+		0.000000f,
+		0.234800f,
+		0.906300f,
+		0.351400f,
+		0.343700f,
+		0.862100f,
+		0.061095f,
+		0.473826f,
+		0.147498f,
+		0.000000f,
+		0.123300f,
+		0.946600f,
+		0.297800f,
+		0.312500f,
+		0.896600f,
+		0.080342f,
+		0.453788f,
+		0.193963f,
+		0.000000f,
+		0.161700f,
+		0.906300f,
+		0.390500f,
+		0.312500f,
+		0.862100f,
+		0.258055f,
+		-0.185069f,
+		0.386207f,
+		0.000000f,
+		0.516300f,
+		-0.369000f,
+		0.772800f,
+		0.343700f,
+		0.379300f,
+		0.267659f,
+		-0.133764f,
+		0.400581f,
+		0.000000f,
+		0.535400f,
+		-0.266600f,
+		0.801400f,
+		0.343700f,
+		0.413800f,
+		0.184366f,
+		-0.133764f,
+		0.445101f,
+		0.000000f,
+		0.368800f,
+		-0.266600f,
+		0.890400f,
+		0.312500f,
+		0.413800f,
+		0.258055f,
+		-0.185069f,
+		0.386207f,
+		0.000000f,
+		0.516300f,
+		-0.369000f,
+		0.772800f,
+		0.343700f,
+		0.379300f,
+		0.184366f,
+		-0.133764f,
+		0.445101f,
+		0.000000f,
+		0.368800f,
+		-0.266600f,
+		0.890400f,
+		0.312500f,
+		0.413800f,
+		0.177751f,
+		-0.185069f,
+		0.429130f,
+		0.000000f,
+		0.355700f,
+		-0.369000f,
+		0.858700f,
+		0.312500f,
+		0.379300f,
+		0.143212f,
+		0.428429f,
+		0.214333f,
+		0.000000f,
+		0.287800f,
+		0.855300f,
+		0.430700f,
+		0.343700f,
+		0.827600f,
+		0.116638f,
+		0.453788f,
+		0.174562f,
+		0.000000f,
+		0.234800f,
+		0.906300f,
+		0.351400f,
+		0.343700f,
+		0.862100f,
+		0.080342f,
+		0.453788f,
+		0.193963f,
+		0.000000f,
+		0.161700f,
+		0.906300f,
+		0.390500f,
+		0.312500f,
+		0.862100f,
+		0.143212f,
+		0.428429f,
+		0.214333f,
+		0.000000f,
+		0.287800f,
+		0.855300f,
+		0.430700f,
+		0.343700f,
+		0.827600f,
+		0.080342f,
+		0.453788f,
+		0.193963f,
+		0.000000f,
+		0.161700f,
+		0.906300f,
+		0.390500f,
+		0.312500f,
+		0.862100f,
+		0.098646f,
+		0.428429f,
+		0.238155f,
+		0.000000f,
+		0.198200f,
+		0.855300f,
+		0.478600f,
+		0.312500f,
+		0.827600f,
+		0.245426f,
+		-0.234204f,
+		0.367306f,
+		0.000000f,
+		0.491300f,
+		-0.467000f,
+		0.735200f,
+		0.343700f,
+		0.344800f,
+		0.258055f,
+		-0.185069f,
+		0.386207f,
+		0.000000f,
+		0.516300f,
+		-0.369000f,
+		0.772800f,
+		0.343700f,
+		0.379300f,
+		0.177751f,
+		-0.185069f,
+		0.429130f,
+		0.000000f,
+		0.355700f,
+		-0.369000f,
+		0.858700f,
+		0.312500f,
+		0.379300f,
+		0.245426f,
+		-0.234204f,
+		0.367306f,
+		0.000000f,
+		0.491300f,
+		-0.467000f,
+		0.735200f,
+		0.343700f,
+		0.344800f,
+		0.177751f,
+		-0.185069f,
+		0.429130f,
+		0.000000f,
+		0.355700f,
+		-0.369000f,
+		0.858700f,
+		0.312500f,
+		0.379300f,
+		0.169052f,
+		-0.234204f,
+		0.408129f,
+		0.000000f,
+		0.338400f,
+		-0.467000f,
+		0.816900f,
+		0.312500f,
+		0.344800f,
+		0.168107f,
+		0.398046f,
+		0.251592f,
+		0.000000f,
+		0.337400f,
+		0.794500f,
+		0.505000f,
+		0.343700f,
+		0.793100f,
+		0.143212f,
+		0.428429f,
+		0.214333f,
+		0.000000f,
+		0.287800f,
+		0.855300f,
+		0.430700f,
+		0.343700f,
+		0.827600f,
+		0.098646f,
+		0.428429f,
+		0.238155f,
+		0.000000f,
+		0.198200f,
+		0.855300f,
+		0.478600f,
+		0.312500f,
+		0.827600f,
+		0.168107f,
+		0.398046f,
+		0.251592f,
+		0.000000f,
+		0.337400f,
+		0.794500f,
+		0.505000f,
+		0.343700f,
+		0.793100f,
+		0.098646f,
+		0.428429f,
+		0.238155f,
+		0.000000f,
+		0.198200f,
+		0.855300f,
+		0.478600f,
+		0.312500f,
+		0.827600f,
+		0.115795f,
+		0.398046f,
+		0.279554f,
+		0.000000f,
+		0.232400f,
+		0.794500f,
+		0.561100f,
+		0.312500f,
+		0.793100f,
+		0.229919f,
+		-0.280594f,
+		0.344099f,
+		0.000000f,
+		0.460400f,
+		-0.559600f,
+		0.689100f,
+		0.343700f,
+		0.310300f,
+		0.245426f,
+		-0.234204f,
+		0.367306f,
+		0.000000f,
+		0.491300f,
+		-0.467000f,
+		0.735200f,
+		0.343700f,
+		0.344800f,
+		0.169052f,
+		-0.234204f,
+		0.408129f,
+		0.000000f,
+		0.338400f,
+		-0.467000f,
+		0.816900f,
+		0.312500f,
+		0.344800f,
+		0.229919f,
+		-0.280594f,
+		0.344099f,
+		0.000000f,
+		0.460400f,
+		-0.559600f,
+		0.689100f,
+		0.343700f,
+		0.310300f,
+		0.169052f,
+		-0.234204f,
+		0.408129f,
+		0.000000f,
+		0.338400f,
+		-0.467000f,
+		0.816900f,
+		0.312500f,
+		0.344800f,
+		0.158370f,
+		-0.280594f,
+		0.382342f,
+		0.000000f,
+		0.317100f,
+		-0.559600f,
+		0.765600f,
+		0.312500f,
+		0.310300f,
+		0.191032f,
+		0.362998f,
+		0.285900f,
+		0.000000f,
+		0.383000f,
+		0.724300f,
+		0.573300f,
+		0.343700f,
+		0.758600f,
+		0.168107f,
+		0.398046f,
+		0.251592f,
+		0.000000f,
+		0.337400f,
+		0.794500f,
+		0.505000f,
+		0.343700f,
+		0.793100f,
+		0.115795f,
+		0.398046f,
+		0.279554f,
+		0.000000f,
+		0.232400f,
+		0.794500f,
+		0.561100f,
+		0.312500f,
+		0.793100f,
+		0.191032f,
+		0.362998f,
+		0.285900f,
+		0.000000f,
+		0.383000f,
+		0.724300f,
+		0.573300f,
+		0.343700f,
+		0.758600f,
+		0.115795f,
+		0.398046f,
+		0.279554f,
+		0.000000f,
+		0.232400f,
+		0.794500f,
+		0.561100f,
+		0.312500f,
+		0.793100f,
+		0.131585f,
+		0.362998f,
+		0.317675f,
+		0.000000f,
+		0.263800f,
+		0.724300f,
+		0.637000f,
+		0.312500f,
+		0.758600f,
+		0.211717f,
+		-0.323693f,
+		0.316857f,
+		0.000000f,
+		0.424200f,
+		-0.645700f,
+		0.634900f,
+		0.343700f,
+		0.275900f,
+		0.229919f,
+		-0.280594f,
+		0.344099f,
+		0.000000f,
+		0.460400f,
+		-0.559600f,
+		0.689100f,
+		0.343700f,
+		0.310300f,
+		0.158370f,
+		-0.280594f,
+		0.382342f,
+		0.000000f,
+		0.317100f,
+		-0.559600f,
+		0.765600f,
+		0.312500f,
+		0.310300f,
+		0.211717f,
+		-0.323693f,
+		0.316857f,
+		0.000000f,
+		0.424200f,
+		-0.645700f,
+		0.634900f,
+		0.343700f,
+		0.275900f,
+		0.158370f,
+		-0.280594f,
+		0.382342f,
+		0.000000f,
+		0.317100f,
+		-0.559600f,
+		0.765600f,
+		0.312500f,
+		0.310300f,
+		0.145832f,
+		-0.323693f,
+		0.352073f,
+		0.000000f,
+		0.292200f,
+		-0.645700f,
+		0.705400f,
+		0.312500f,
+		0.275900f,
+		0.211717f,
+		0.323693f,
+		0.316857f,
+		0.000000f,
+		0.424200f,
+		0.645700f,
+		0.634900f,
+		0.343700f,
+		0.724100f,
+		0.191032f,
+		0.362998f,
+		0.285900f,
+		0.000000f,
+		0.383000f,
+		0.724300f,
+		0.573300f,
+		0.343700f,
+		0.758600f,
+		0.131585f,
+		0.362998f,
+		0.317675f,
+		0.000000f,
+		0.263800f,
+		0.724300f,
+		0.637000f,
+		0.312500f,
+		0.758600f,
+		0.211717f,
+		0.323693f,
+		0.316857f,
+		0.000000f,
+		0.424200f,
+		0.645700f,
+		0.634900f,
+		0.343700f,
+		0.724100f,
+		0.131585f,
+		0.362998f,
+		0.317675f,
+		0.000000f,
+		0.263800f,
+		0.724300f,
+		0.637000f,
+		0.312500f,
+		0.758600f,
+		0.145832f,
+		0.323693f,
+		0.352073f,
+		0.000000f,
+		0.292200f,
+		0.645700f,
+		0.705400f,
+		0.312500f,
+		0.724100f,
+		0.191032f,
+		-0.362998f,
+		0.285900f,
+		0.000000f,
+		0.383000f,
+		-0.724300f,
+		0.573300f,
+		0.343700f,
+		0.241400f,
+		0.211717f,
+		-0.323693f,
+		0.316857f,
+		0.000000f,
+		0.424200f,
+		-0.645700f,
+		0.634900f,
+		0.343700f,
+		0.275900f,
+		0.145832f,
+		-0.323693f,
+		0.352073f,
+		0.000000f,
+		0.292200f,
+		-0.645700f,
+		0.705400f,
+		0.312500f,
+		0.275900f,
+		0.191032f,
+		-0.362998f,
+		0.285900f,
+		0.000000f,
+		0.383000f,
+		-0.724300f,
+		0.573300f,
+		0.343700f,
+		0.241400f,
+		0.145832f,
+		-0.323693f,
+		0.352073f,
+		0.000000f,
+		0.292200f,
+		-0.645700f,
+		0.705400f,
+		0.312500f,
+		0.275900f,
+		0.131585f,
+		-0.362998f,
+		0.317676f,
+		0.000000f,
+		0.263800f,
+		-0.724300f,
+		0.637000f,
+		0.312500f,
+		0.241400f,
+		0.229919f,
+		0.280594f,
+		0.344099f,
+		0.000000f,
+		0.460400f,
+		0.559600f,
+		0.689100f,
+		0.343700f,
+		0.689700f,
+		0.211717f,
+		0.323693f,
+		0.316857f,
+		0.000000f,
+		0.424200f,
+		0.645700f,
+		0.634900f,
+		0.343700f,
+		0.724100f,
+		0.145832f,
+		0.323693f,
+		0.352073f,
+		0.000000f,
+		0.292200f,
+		0.645700f,
+		0.705400f,
+		0.312500f,
+		0.724100f,
+		0.229919f,
+		0.280594f,
+		0.344099f,
+		0.000000f,
+		0.460400f,
+		0.559600f,
+		0.689100f,
+		0.343700f,
+		0.689700f,
+		0.145832f,
+		0.323693f,
+		0.352073f,
+		0.000000f,
+		0.292200f,
+		0.645700f,
+		0.705400f,
+		0.312500f,
+		0.724100f,
+		0.158370f,
+		0.280594f,
+		0.382342f,
+		0.000000f,
+		0.317100f,
+		0.559600f,
+		0.765600f,
+		0.312500f,
+		0.689700f,
+		0.168107f,
+		-0.398046f,
+		0.251592f,
+		0.000000f,
+		0.337400f,
+		-0.794500f,
+		0.505000f,
+		0.343700f,
+		0.206900f,
+		0.191032f,
+		-0.362998f,
+		0.285900f,
+		0.000000f,
+		0.383000f,
+		-0.724300f,
+		0.573300f,
+		0.343700f,
+		0.241400f,
+		0.131585f,
+		-0.362998f,
+		0.317676f,
+		0.000000f,
+		0.263800f,
+		-0.724300f,
+		0.637000f,
+		0.312500f,
+		0.241400f,
+		0.168107f,
+		-0.398046f,
+		0.251592f,
+		0.000000f,
+		0.337400f,
+		-0.794500f,
+		0.505000f,
+		0.343700f,
+		0.206900f,
+		0.131585f,
+		-0.362998f,
+		0.317676f,
+		0.000000f,
+		0.263800f,
+		-0.724300f,
+		0.637000f,
+		0.312500f,
+		0.241400f,
+		0.115795f,
+		-0.398046f,
+		0.279554f,
+		0.000000f,
+		0.232400f,
+		-0.794500f,
+		0.561100f,
+		0.312500f,
+		0.206900f,
+		0.245426f,
+		0.234204f,
+		0.367306f,
+		0.000000f,
+		0.491300f,
+		0.467000f,
+		0.735200f,
+		0.343700f,
+		0.655200f,
+		0.229919f,
+		0.280594f,
+		0.344099f,
+		0.000000f,
+		0.460400f,
+		0.559600f,
+		0.689100f,
+		0.343700f,
+		0.689700f,
+		0.158370f,
+		0.280594f,
+		0.382342f,
+		0.000000f,
+		0.317100f,
+		0.559600f,
+		0.765600f,
+		0.312500f,
+		0.689700f,
+		0.245426f,
+		0.234204f,
+		0.367306f,
+		0.000000f,
+		0.491300f,
+		0.467000f,
+		0.735200f,
+		0.343700f,
+		0.655200f,
+		0.158370f,
+		0.280594f,
+		0.382342f,
+		0.000000f,
+		0.317100f,
+		0.559600f,
+		0.765600f,
+		0.312500f,
+		0.689700f,
+		0.169052f,
+		0.234204f,
+		0.408129f,
+		0.000000f,
+		0.338400f,
+		0.467000f,
+		0.816900f,
+		0.312500f,
+		0.655200f,
+		0.143212f,
+		-0.428429f,
+		0.214334f,
+		0.000000f,
+		0.287800f,
+		-0.855300f,
+		0.430700f,
+		0.343700f,
+		0.172400f,
+		0.168107f,
+		-0.398046f,
+		0.251592f,
+		0.000000f,
+		0.337400f,
+		-0.794500f,
+		0.505000f,
+		0.343700f,
+		0.206900f,
+		0.115795f,
+		-0.398046f,
+		0.279554f,
+		0.000000f,
+		0.232400f,
+		-0.794500f,
+		0.561100f,
+		0.312500f,
+		0.206900f,
+		0.143212f,
+		-0.428429f,
+		0.214334f,
+		0.000000f,
+		0.287800f,
+		-0.855300f,
+		0.430700f,
+		0.343700f,
+		0.172400f,
+		0.115795f,
+		-0.398046f,
+		0.279554f,
+		0.000000f,
+		0.232400f,
+		-0.794500f,
+		0.561100f,
+		0.312500f,
+		0.206900f,
+		0.098646f,
+		-0.428429f,
+		0.238155f,
+		0.000000f,
+		0.198200f,
+		-0.855300f,
+		0.478600f,
+		0.312500f,
+		0.172400f,
+		0.258055f,
+		0.185069f,
+		0.386207f,
+		0.000000f,
+		0.516300f,
+		0.369000f,
+		0.772800f,
+		0.343700f,
+		0.620700f,
+		0.245426f,
+		0.234204f,
+		0.367306f,
+		0.000000f,
+		0.491300f,
+		0.467000f,
+		0.735200f,
+		0.343700f,
+		0.655200f,
+		0.169052f,
+		0.234204f,
+		0.408129f,
+		0.000000f,
+		0.338400f,
+		0.467000f,
+		0.816900f,
+		0.312500f,
+		0.655200f,
+		0.258055f,
+		0.185069f,
+		0.386207f,
+		0.000000f,
+		0.516300f,
+		0.369000f,
+		0.772800f,
+		0.343700f,
+		0.620700f,
+		0.169052f,
+		0.234204f,
+		0.408129f,
+		0.000000f,
+		0.338400f,
+		0.467000f,
+		0.816900f,
+		0.312500f,
+		0.655200f,
+		0.177751f,
+		0.185069f,
+		0.429130f,
+		0.000000f,
+		0.355700f,
+		0.369000f,
+		0.858700f,
+		0.312500f,
+		0.620700f,
+		0.116638f,
+		-0.453788f,
+		0.174562f,
+		0.000000f,
+		0.234800f,
+		-0.906300f,
+		0.351400f,
+		0.343700f,
+		0.137900f,
+		0.143212f,
+		-0.428429f,
+		0.214334f,
+		0.000000f,
+		0.287800f,
+		-0.855300f,
+		0.430700f,
+		0.343700f,
+		0.172400f,
+		0.098646f,
+		-0.428429f,
+		0.238155f,
+		0.000000f,
+		0.198200f,
+		-0.855300f,
+		0.478600f,
+		0.312500f,
+		0.172400f,
+		0.116638f,
+		-0.453788f,
+		0.174562f,
+		0.000000f,
+		0.234800f,
+		-0.906300f,
+		0.351400f,
+		0.343700f,
+		0.137900f,
+		0.098646f,
+		-0.428429f,
+		0.238155f,
+		0.000000f,
+		0.198200f,
+		-0.855300f,
+		0.478600f,
+		0.312500f,
+		0.172400f,
+		0.080342f,
+		-0.453788f,
+		0.193963f,
+		0.000000f,
+		0.161700f,
+		-0.906300f,
+		0.390500f,
+		0.312500f,
+		0.137900f,
+		0.267659f,
+		0.133764f,
+		0.400581f,
+		0.000000f,
+		0.535400f,
+		0.266600f,
+		0.801400f,
+		0.343700f,
+		0.586200f,
+		0.258055f,
+		0.185069f,
+		0.386207f,
+		0.000000f,
+		0.516300f,
+		0.369000f,
+		0.772800f,
+		0.343700f,
+		0.620700f,
+		0.177751f,
+		0.185069f,
+		0.429130f,
+		0.000000f,
+		0.355700f,
+		0.369000f,
+		0.858700f,
+		0.312500f,
+		0.620700f,
+		0.267659f,
+		0.133764f,
+		0.400581f,
+		0.000000f,
+		0.535400f,
+		0.266600f,
+		0.801400f,
+		0.343700f,
+		0.586200f,
+		0.177751f,
+		0.185069f,
+		0.429130f,
+		0.000000f,
+		0.355700f,
+		0.369000f,
+		0.858700f,
+		0.312500f,
+		0.620700f,
+		0.184366f,
+		0.133764f,
+		0.445101f,
+		0.000000f,
+		0.368800f,
+		0.266600f,
+		0.890400f,
+		0.312500f,
+		0.586200f,
+		0.088697f,
+		-0.473826f,
+		0.132745f,
+		0.000000f,
+		0.179100f,
+		-0.946600f,
+		0.268000f,
+		0.343700f,
+		0.103400f,
+		0.116638f,
+		-0.453788f,
+		0.174562f,
+		0.000000f,
+		0.234800f,
+		-0.906300f,
+		0.351400f,
+		0.343700f,
+		0.137900f,
+		0.080342f,
+		-0.453788f,
+		0.193963f,
+		0.000000f,
+		0.161700f,
+		-0.906300f,
+		0.390500f,
+		0.312500f,
+		0.137900f,
+		0.088697f,
+		-0.473826f,
+		0.132745f,
+		0.000000f,
+		0.179100f,
+		-0.946600f,
+		0.268000f,
+		0.343700f,
+		0.103400f,
+		0.080342f,
+		-0.453788f,
+		0.193963f,
+		0.000000f,
+		0.161700f,
+		-0.906300f,
+		0.390500f,
+		0.312500f,
+		0.137900f,
+		0.061095f,
+		-0.473826f,
+		0.147498f,
+		0.000000f,
+		0.123300f,
+		-0.946600f,
+		0.297800f,
+		0.312500f,
+		0.103400f,
+		0.145832f,
+		-0.323693f,
+		0.352073f,
+		0.000000f,
+		0.292200f,
+		-0.645700f,
+		0.705400f,
+		0.312500f,
+		0.275900f,
+		0.158370f,
+		-0.280594f,
+		0.382342f,
+		0.000000f,
+		0.317100f,
+		-0.559600f,
+		0.765600f,
+		0.312500f,
+		0.310300f,
+		0.080737f,
+		-0.280594f,
+		0.405892f,
+		0.000000f,
+		0.161700f,
+		-0.559600f,
+		0.812800f,
+		0.281200f,
+		0.310300f,
+		0.145832f,
+		-0.323693f,
+		0.352073f,
+		0.000000f,
+		0.292200f,
+		-0.645700f,
+		0.705400f,
+		0.312500f,
+		0.275900f,
+		0.080737f,
+		-0.280594f,
+		0.405892f,
+		0.000000f,
+		0.161700f,
+		-0.559600f,
+		0.812800f,
+		0.281200f,
+		0.310300f,
+		0.074345f,
+		-0.323693f,
+		0.373758f,
+		0.000000f,
+		0.149000f,
+		-0.645700f,
+		0.748900f,
+		0.281200f,
+		0.275900f,
+		0.145832f,
+		0.323693f,
+		0.352073f,
+		0.000000f,
+		0.292200f,
+		0.645700f,
+		0.705400f,
+		0.312500f,
+		0.724100f,
+		0.131585f,
+		0.362998f,
+		0.317675f,
+		0.000000f,
+		0.263800f,
+		0.724300f,
+		0.637000f,
+		0.312500f,
+		0.758600f,
+		0.067081f,
+		0.362998f,
+		0.337242f,
+		0.000000f,
+		0.134500f,
+		0.724300f,
+		0.676200f,
+		0.281200f,
+		0.758600f,
+		0.145832f,
+		0.323693f,
+		0.352073f,
+		0.000000f,
+		0.292200f,
+		0.645700f,
+		0.705400f,
+		0.312500f,
+		0.724100f,
+		0.067081f,
+		0.362998f,
+		0.337242f,
+		0.000000f,
+		0.134500f,
+		0.724300f,
+		0.676200f,
+		0.281200f,
+		0.758600f,
+		0.074345f,
+		0.323693f,
+		0.373758f,
+		0.000000f,
+		0.149000f,
+		0.645700f,
+		0.748900f,
+		0.281200f,
+		0.724100f,
+		0.131585f,
+		-0.362998f,
+		0.317676f,
+		0.000000f,
+		0.263800f,
+		-0.724300f,
+		0.637000f,
+		0.312500f,
+		0.241400f,
+		0.145832f,
+		-0.323693f,
+		0.352073f,
+		0.000000f,
+		0.292200f,
+		-0.645700f,
+		0.705400f,
+		0.312500f,
+		0.275900f,
+		0.074345f,
+		-0.323693f,
+		0.373758f,
+		0.000000f,
+		0.149000f,
+		-0.645700f,
+		0.748900f,
+		0.281200f,
+		0.275900f,
+		0.131585f,
+		-0.362998f,
+		0.317676f,
+		0.000000f,
+		0.263800f,
+		-0.724300f,
+		0.637000f,
+		0.312500f,
+		0.241400f,
+		0.074345f,
+		-0.323693f,
+		0.373758f,
+		0.000000f,
+		0.149000f,
+		-0.645700f,
+		0.748900f,
+		0.281200f,
+		0.275900f,
+		0.067081f,
+		-0.362998f,
+		0.337243f,
+		0.000000f,
+		0.134500f,
+		-0.724300f,
+		0.676200f,
+		0.281200f,
+		0.241400f,
+		0.158370f,
+		0.280594f,
+		0.382342f,
+		0.000000f,
+		0.317100f,
+		0.559600f,
+		0.765600f,
+		0.312500f,
+		0.689700f,
+		0.145832f,
+		0.323693f,
+		0.352073f,
+		0.000000f,
+		0.292200f,
+		0.645700f,
+		0.705400f,
+		0.312500f,
+		0.724100f,
+		0.074345f,
+		0.323693f,
+		0.373758f,
+		0.000000f,
+		0.149000f,
+		0.645700f,
+		0.748900f,
+		0.281200f,
+		0.724100f,
+		0.158370f,
+		0.280594f,
+		0.382342f,
+		0.000000f,
+		0.317100f,
+		0.559600f,
+		0.765600f,
+		0.312500f,
+		0.689700f,
+		0.074345f,
+		0.323693f,
+		0.373758f,
+		0.000000f,
+		0.149000f,
+		0.645700f,
+		0.748900f,
+		0.281200f,
+		0.724100f,
+		0.080737f,
+		0.280594f,
+		0.405892f,
+		0.000000f,
+		0.161700f,
+		0.559600f,
+		0.812800f,
+		0.281200f,
+		0.689700f,
+		0.115795f,
+		-0.398046f,
+		0.279554f,
+		0.000000f,
+		0.232400f,
+		-0.794500f,
+		0.561100f,
+		0.312500f,
+		0.206900f,
+		0.131585f,
+		-0.362998f,
+		0.317676f,
+		0.000000f,
+		0.263800f,
+		-0.724300f,
+		0.637000f,
+		0.312500f,
+		0.241400f,
+		0.067081f,
+		-0.362998f,
+		0.337243f,
+		0.000000f,
+		0.134500f,
+		-0.724300f,
+		0.676200f,
+		0.281200f,
+		0.241400f,
+		0.115795f,
+		-0.398046f,
+		0.279554f,
+		0.000000f,
+		0.232400f,
+		-0.794500f,
+		0.561100f,
+		0.312500f,
+		0.206900f,
+		0.067081f,
+		-0.362998f,
+		0.337243f,
+		0.000000f,
+		0.134500f,
+		-0.724300f,
+		0.676200f,
+		0.281200f,
+		0.241400f,
+		0.059031f,
+		-0.398046f,
+		0.296773f,
+		0.000000f,
+		0.118500f,
+		-0.794500f,
+		0.595600f,
+		0.281200f,
+		0.206900f,
+		0.169052f,
+		0.234204f,
+		0.408129f,
+		0.000000f,
+		0.338400f,
+		0.467000f,
+		0.816900f,
+		0.312500f,
+		0.655200f,
+		0.158370f,
+		0.280594f,
+		0.382342f,
+		0.000000f,
+		0.317100f,
+		0.559600f,
+		0.765600f,
+		0.312500f,
+		0.689700f,
+		0.080737f,
+		0.280594f,
+		0.405892f,
+		0.000000f,
+		0.161700f,
+		0.559600f,
+		0.812800f,
+		0.281200f,
+		0.689700f,
+		0.169052f,
+		0.234204f,
+		0.408129f,
+		0.000000f,
+		0.338400f,
+		0.467000f,
+		0.816900f,
+		0.312500f,
+		0.655200f,
+		0.080737f,
+		0.280594f,
+		0.405892f,
+		0.000000f,
+		0.161700f,
+		0.559600f,
+		0.812800f,
+		0.281200f,
+		0.689700f,
+		0.086181f,
+		0.234204f,
+		0.433267f,
+		0.000000f,
+		0.172500f,
+		0.467000f,
+		0.867200f,
+		0.281200f,
+		0.655200f,
+		0.098646f,
+		-0.428429f,
+		0.238155f,
+		0.000000f,
+		0.198200f,
+		-0.855300f,
+		0.478600f,
+		0.312500f,
+		0.172400f,
+		0.115795f,
+		-0.398046f,
+		0.279554f,
+		0.000000f,
+		0.232400f,
+		-0.794500f,
+		0.561100f,
+		0.312500f,
+		0.206900f,
+		0.059031f,
+		-0.398046f,
+		0.296773f,
+		0.000000f,
+		0.118500f,
+		-0.794500f,
+		0.595600f,
+		0.281200f,
+		0.206900f,
+		0.098646f,
+		-0.428429f,
+		0.238155f,
+		0.000000f,
+		0.198200f,
+		-0.855300f,
+		0.478600f,
+		0.312500f,
+		0.172400f,
+		0.059031f,
+		-0.398046f,
+		0.296773f,
+		0.000000f,
+		0.118500f,
+		-0.794500f,
+		0.595600f,
+		0.281200f,
+		0.206900f,
+		0.050289f,
+		-0.428429f,
+		0.252824f,
+		0.000000f,
+		0.101000f,
+		-0.855300f,
+		0.508100f,
+		0.281200f,
+		0.172400f,
+		0.177751f,
+		0.185069f,
+		0.429130f,
+		0.000000f,
+		0.355700f,
+		0.369000f,
+		0.858700f,
+		0.312500f,
+		0.620700f,
+		0.169052f,
+		0.234204f,
+		0.408129f,
+		0.000000f,
+		0.338400f,
+		0.467000f,
+		0.816900f,
+		0.312500f,
+		0.655200f,
+		0.086181f,
+		0.234204f,
+		0.433267f,
+		0.000000f,
+		0.172500f,
+		0.467000f,
+		0.867200f,
+		0.281200f,
+		0.655200f,
+		0.177751f,
+		0.185069f,
+		0.429130f,
+		0.000000f,
+		0.355700f,
+		0.369000f,
+		0.858700f,
+		0.312500f,
+		0.620700f,
+		0.086181f,
+		0.234204f,
+		0.433267f,
+		0.000000f,
+		0.172500f,
+		0.467000f,
+		0.867200f,
+		0.281200f,
+		0.655200f,
+		0.090617f,
+		0.185069f,
+		0.455563f,
+		0.000000f,
+		0.181300f,
+		0.369000f,
+		0.911600f,
+		0.281200f,
+		0.620700f,
+		0.080342f,
+		-0.453788f,
+		0.193963f,
+		0.000000f,
+		0.161700f,
+		-0.906300f,
+		0.390500f,
+		0.312500f,
+		0.137900f,
+		0.098646f,
+		-0.428429f,
+		0.238155f,
+		0.000000f,
+		0.198200f,
+		-0.855300f,
+		0.478600f,
+		0.312500f,
+		0.172400f,
+		0.050289f,
+		-0.428429f,
+		0.252824f,
+		0.000000f,
+		0.101000f,
+		-0.855300f,
+		0.508100f,
+		0.281200f,
+		0.172400f,
+		0.080342f,
+		-0.453788f,
+		0.193963f,
+		0.000000f,
+		0.161700f,
+		-0.906300f,
+		0.390500f,
+		0.312500f,
+		0.137900f,
+		0.050289f,
+		-0.428429f,
+		0.252824f,
+		0.000000f,
+		0.101000f,
+		-0.855300f,
+		0.508100f,
+		0.281200f,
+		0.172400f,
+		0.040957f,
+		-0.453788f,
+		0.205910f,
+		0.000000f,
+		0.082400f,
+		-0.906300f,
+		0.414500f,
+		0.281200f,
+		0.137900f,
+		0.184366f,
+		0.133764f,
+		0.445101f,
+		0.000000f,
+		0.368800f,
+		0.266600f,
+		0.890400f,
+		0.312500f,
+		0.586200f,
+		0.177751f,
+		0.185069f,
+		0.429130f,
+		0.000000f,
+		0.355700f,
+		0.369000f,
+		0.858700f,
+		0.312500f,
+		0.620700f,
+		0.090617f,
+		0.185069f,
+		0.455563f,
+		0.000000f,
+		0.181300f,
+		0.369000f,
+		0.911600f,
+		0.281200f,
+		0.620700f,
+		0.184366f,
+		0.133764f,
+		0.445101f,
+		0.000000f,
+		0.368800f,
+		0.266600f,
+		0.890400f,
+		0.312500f,
+		0.586200f,
+		0.090617f,
+		0.185069f,
+		0.455563f,
+		0.000000f,
+		0.181300f,
+		0.369000f,
+		0.911600f,
+		0.281200f,
+		0.620700f,
+		0.093989f,
+		0.133764f,
+		0.472517f,
+		0.000000f,
+		0.188000f,
+		0.266600f,
+		0.945200f,
+		0.281200f,
+		0.586200f,
+		0.061095f,
+		-0.473826f,
+		0.147498f,
+		0.000000f,
+		0.123300f,
+		-0.946600f,
+		0.297800f,
+		0.312500f,
+		0.103400f,
+		0.080342f,
+		-0.453788f,
+		0.193963f,
+		0.000000f,
+		0.161700f,
+		-0.906300f,
+		0.390500f,
+		0.312500f,
+		0.137900f,
+		0.040957f,
+		-0.453788f,
+		0.205910f,
+		0.000000f,
+		0.082400f,
+		-0.906300f,
+		0.414500f,
+		0.281200f,
+		0.137900f,
+		0.061095f,
+		-0.473826f,
+		0.147498f,
+		0.000000f,
+		0.123300f,
+		-0.946600f,
+		0.297800f,
+		0.312500f,
+		0.103400f,
+		0.040957f,
+		-0.453788f,
+		0.205910f,
+		0.000000f,
+		0.082400f,
+		-0.906300f,
+		0.414500f,
+		0.281200f,
+		0.137900f,
+		0.031146f,
+		-0.473826f,
+		0.156583f,
+		0.000000f,
+		0.062900f,
+		-0.946600f,
+		0.316100f,
+		0.281200f,
+		0.103400f,
+		0.188820f,
+		0.080891f,
+		0.455853f,
+		0.000000f,
+		0.377700f,
+		0.161200f,
+		0.911800f,
+		0.312500f,
+		0.551700f,
+		0.184366f,
+		0.133764f,
+		0.445101f,
+		0.000000f,
+		0.368800f,
+		0.266600f,
+		0.890400f,
+		0.312500f,
+		0.586200f,
+		0.093989f,
+		0.133764f,
+		0.472517f,
+		0.000000f,
+		0.188000f,
+		0.266600f,
+		0.945200f,
+		0.281200f,
+		0.586200f,
+		0.188820f,
+		0.080891f,
+		0.455853f,
+		0.000000f,
+		0.377700f,
+		0.161200f,
+		0.911800f,
+		0.312500f,
+		0.551700f,
+		0.093989f,
+		0.133764f,
+		0.472517f,
+		0.000000f,
+		0.188000f,
+		0.266600f,
+		0.945200f,
+		0.281200f,
+		0.586200f,
+		0.096259f,
+		0.080891f,
+		0.483932f,
+		0.000000f,
+		0.192500f,
+		0.161200f,
+		0.967900f,
+		0.281200f,
+		0.551700f,
+		0.041132f,
+		-0.488310f,
+		0.099303f,
+		0.000000f,
+		0.083500f,
+		-0.975900f,
+		0.201600f,
+		0.312500f,
+		0.069000f,
+		0.061095f,
+		-0.473826f,
+		0.147498f,
+		0.000000f,
+		0.123300f,
+		-0.946600f,
+		0.297800f,
+		0.312500f,
+		0.103400f,
+		0.031146f,
+		-0.473826f,
+		0.156583f,
+		0.000000f,
+		0.062900f,
+		-0.946600f,
+		0.316100f,
+		0.281200f,
+		0.103400f,
+		0.041132f,
+		-0.488310f,
+		0.099303f,
+		0.000000f,
+		0.083500f,
+		-0.975900f,
+		0.201600f,
+		0.312500f,
+		0.069000f,
+		0.031146f,
+		-0.473826f,
+		0.156583f,
+		0.000000f,
+		0.062900f,
+		-0.946600f,
+		0.316100f,
+		0.281200f,
+		0.103400f,
+		0.020969f,
+		-0.488310f,
+		0.105420f,
+		0.000000f,
+		0.042500f,
+		-0.975900f,
+		0.214000f,
+		0.281200f,
+		0.069000f,
+		0.191060f,
+		0.027069f,
+		0.461262f,
+		0.000000f,
+		0.382100f,
+		0.054000f,
+		0.922500f,
+		0.312500f,
+		0.517200f,
+		0.188820f,
+		0.080891f,
+		0.455853f,
+		0.000000f,
+		0.377700f,
+		0.161200f,
+		0.911800f,
+		0.312500f,
+		0.551700f,
+		0.096259f,
+		0.080891f,
+		0.483932f,
+		0.000000f,
+		0.192500f,
+		0.161200f,
+		0.967900f,
+		0.281200f,
+		0.551700f,
+		0.191060f,
+		0.027069f,
+		0.461262f,
+		0.000000f,
+		0.382100f,
+		0.054000f,
+		0.922500f,
+		0.312500f,
+		0.517200f,
+		0.096259f,
+		0.080891f,
+		0.483932f,
+		0.000000f,
+		0.192500f,
+		0.161200f,
+		0.967900f,
+		0.281200f,
+		0.551700f,
+		0.097401f,
+		0.027069f,
+		0.489673f,
+		0.000000f,
+		0.194800f,
+		0.054000f,
+		0.979300f,
+		0.281200f,
+		0.517200f,
+		0.020687f,
+		0.497069f,
+		0.049944f,
+		0.000000f,
+		0.042600f,
+		0.993700f,
+		0.103000f,
+		0.467100f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.482000f,
+		0.960300f,
+		0.010546f,
+		0.497069f,
+		0.053020f,
+		0.000000f,
+		0.021700f,
+		0.993700f,
+		0.109300f,
+		0.468900f,
+		0.962300f,
+		0.020687f,
+		-0.497069f,
+		0.049945f,
+		0.000000f,
+		0.042600f,
+		-0.993700f,
+		0.103000f,
+		0.312500f,
+		0.034500f,
+		0.041132f,
+		-0.488310f,
+		0.099303f,
+		0.000000f,
+		0.083500f,
+		-0.975900f,
+		0.201600f,
+		0.312500f,
+		0.069000f,
+		0.020969f,
+		-0.488310f,
+		0.105420f,
+		0.000000f,
+		0.042500f,
+		-0.975900f,
+		0.214000f,
+		0.281200f,
+		0.069000f,
+		0.020687f,
+		-0.497069f,
+		0.049945f,
+		0.000000f,
+		0.042600f,
+		-0.993700f,
+		0.103000f,
+		0.312500f,
+		0.034500f,
+		0.020969f,
+		-0.488310f,
+		0.105420f,
+		0.000000f,
+		0.042500f,
+		-0.975900f,
+		0.214000f,
+		0.281200f,
+		0.069000f,
+		0.010546f,
+		-0.497069f,
+		0.053020f,
+		0.000000f,
+		0.021700f,
+		-0.993700f,
+		0.109300f,
+		0.281200f,
+		0.034500f,
+		0.191060f,
+		-0.027069f,
+		0.461262f,
+		0.000000f,
+		0.382100f,
+		-0.054000f,
+		0.922500f,
+		0.312500f,
+		0.482800f,
+		0.191060f,
+		0.027069f,
+		0.461262f,
+		0.000000f,
+		0.382100f,
+		0.054000f,
+		0.922500f,
+		0.312500f,
+		0.517200f,
+		0.097401f,
+		0.027069f,
+		0.489673f,
+		0.000000f,
+		0.194800f,
+		0.054000f,
+		0.979300f,
+		0.281200f,
+		0.517200f,
+		0.191060f,
+		-0.027069f,
+		0.461262f,
+		0.000000f,
+		0.382100f,
+		-0.054000f,
+		0.922500f,
+		0.312500f,
+		0.482800f,
+		0.097401f,
+		0.027069f,
+		0.489673f,
+		0.000000f,
+		0.194800f,
+		0.054000f,
+		0.979300f,
+		0.281200f,
+		0.517200f,
+		0.097401f,
+		-0.027069f,
+		0.489673f,
+		0.000000f,
+		0.194800f,
+		-0.054000f,
+		0.979300f,
+		0.281200f,
+		0.482800f,
+		0.041132f,
+		0.488310f,
+		0.099303f,
+		0.000000f,
+		0.083500f,
+		0.975900f,
+		0.201600f,
+		0.312500f,
+		0.931000f,
+		0.020687f,
+		0.497069f,
+		0.049944f,
+		0.000000f,
+		0.042600f,
+		0.993700f,
+		0.103000f,
+		0.312500f,
+		0.965500f,
+		0.010546f,
+		0.497069f,
+		0.053020f,
+		0.000000f,
+		0.021700f,
+		0.993700f,
+		0.109300f,
+		0.281200f,
+		0.965500f,
+		0.041132f,
+		0.488310f,
+		0.099303f,
+		0.000000f,
+		0.083500f,
+		0.975900f,
+		0.201600f,
+		0.312500f,
+		0.931000f,
+		0.010546f,
+		0.497069f,
+		0.053020f,
+		0.000000f,
+		0.021700f,
+		0.993700f,
+		0.109300f,
+		0.281200f,
+		0.965500f,
+		0.020969f,
+		0.488310f,
+		0.105420f,
+		0.000000f,
+		0.042500f,
+		0.975900f,
+		0.214000f,
+		0.281200f,
+		0.931000f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.411700f,
+		0.051000f,
+		0.020687f,
+		-0.497069f,
+		0.049945f,
+		0.000000f,
+		0.042600f,
+		-0.993700f,
+		0.103000f,
+		0.436600f,
+		0.053800f,
+		0.010546f,
+		-0.497069f,
+		0.053020f,
+		0.000000f,
+		0.021700f,
+		-0.993700f,
+		0.109300f,
+		0.434000f,
+		0.053800f,
+		0.188820f,
+		-0.080891f,
+		0.455853f,
+		0.000000f,
+		0.377700f,
+		-0.161200f,
+		0.911800f,
+		0.312500f,
+		0.448300f,
+		0.191060f,
+		-0.027069f,
+		0.461262f,
+		0.000000f,
+		0.382100f,
+		-0.054000f,
+		0.922500f,
+		0.312500f,
+		0.482800f,
+		0.097401f,
+		-0.027069f,
+		0.489673f,
+		0.000000f,
+		0.194800f,
+		-0.054000f,
+		0.979300f,
+		0.281200f,
+		0.482800f,
+		0.188820f,
+		-0.080891f,
+		0.455853f,
+		0.000000f,
+		0.377700f,
+		-0.161200f,
+		0.911800f,
+		0.312500f,
+		0.448300f,
+		0.097401f,
+		-0.027069f,
+		0.489673f,
+		0.000000f,
+		0.194800f,
+		-0.054000f,
+		0.979300f,
+		0.281200f,
+		0.482800f,
+		0.096259f,
+		-0.080891f,
+		0.483932f,
+		0.000000f,
+		0.192500f,
+		-0.161200f,
+		0.967900f,
+		0.281200f,
+		0.448300f,
+		0.061095f,
+		0.473826f,
+		0.147498f,
+		0.000000f,
+		0.123300f,
+		0.946600f,
+		0.297800f,
+		0.312500f,
+		0.896600f,
+		0.041132f,
+		0.488310f,
+		0.099303f,
+		0.000000f,
+		0.083500f,
+		0.975900f,
+		0.201600f,
+		0.312500f,
+		0.931000f,
+		0.020969f,
+		0.488310f,
+		0.105420f,
+		0.000000f,
+		0.042500f,
+		0.975900f,
+		0.214000f,
+		0.281200f,
+		0.931000f,
+		0.061095f,
+		0.473826f,
+		0.147498f,
+		0.000000f,
+		0.123300f,
+		0.946600f,
+		0.297800f,
+		0.312500f,
+		0.896600f,
+		0.020969f,
+		0.488310f,
+		0.105420f,
+		0.000000f,
+		0.042500f,
+		0.975900f,
+		0.214000f,
+		0.281200f,
+		0.931000f,
+		0.031146f,
+		0.473826f,
+		0.156583f,
+		0.000000f,
+		0.062900f,
+		0.946600f,
+		0.316100f,
+		0.281200f,
+		0.896600f,
+		0.184366f,
+		-0.133764f,
+		0.445101f,
+		0.000000f,
+		0.368800f,
+		-0.266600f,
+		0.890400f,
+		0.312500f,
+		0.413800f,
+		0.188820f,
+		-0.080891f,
+		0.455853f,
+		0.000000f,
+		0.377700f,
+		-0.161200f,
+		0.911800f,
+		0.312500f,
+		0.448300f,
+		0.096259f,
+		-0.080891f,
+		0.483932f,
+		0.000000f,
+		0.192500f,
+		-0.161200f,
+		0.967900f,
+		0.281200f,
+		0.448300f,
+		0.184366f,
+		-0.133764f,
+		0.445101f,
+		0.000000f,
+		0.368800f,
+		-0.266600f,
+		0.890400f,
+		0.312500f,
+		0.413800f,
+		0.096259f,
+		-0.080891f,
+		0.483932f,
+		0.000000f,
+		0.192500f,
+		-0.161200f,
+		0.967900f,
+		0.281200f,
+		0.448300f,
+		0.093989f,
+		-0.133764f,
+		0.472517f,
+		0.000000f,
+		0.188000f,
+		-0.266600f,
+		0.945200f,
+		0.281200f,
+		0.413800f,
+		0.080342f,
+		0.453788f,
+		0.193963f,
+		0.000000f,
+		0.161700f,
+		0.906300f,
+		0.390500f,
+		0.312500f,
+		0.862100f,
+		0.061095f,
+		0.473826f,
+		0.147498f,
+		0.000000f,
+		0.123300f,
+		0.946600f,
+		0.297800f,
+		0.312500f,
+		0.896600f,
+		0.031146f,
+		0.473826f,
+		0.156583f,
+		0.000000f,
+		0.062900f,
+		0.946600f,
+		0.316100f,
+		0.281200f,
+		0.896600f,
+		0.080342f,
+		0.453788f,
+		0.193963f,
+		0.000000f,
+		0.161700f,
+		0.906300f,
+		0.390500f,
+		0.312500f,
+		0.862100f,
+		0.031146f,
+		0.473826f,
+		0.156583f,
+		0.000000f,
+		0.062900f,
+		0.946600f,
+		0.316100f,
+		0.281200f,
+		0.896600f,
+		0.040957f,
+		0.453788f,
+		0.205910f,
+		0.000000f,
+		0.082400f,
+		0.906300f,
+		0.414500f,
+		0.281200f,
+		0.862100f,
+		0.177751f,
+		-0.185069f,
+		0.429130f,
+		0.000000f,
+		0.355700f,
+		-0.369000f,
+		0.858700f,
+		0.312500f,
+		0.379300f,
+		0.184366f,
+		-0.133764f,
+		0.445101f,
+		0.000000f,
+		0.368800f,
+		-0.266600f,
+		0.890400f,
+		0.312500f,
+		0.413800f,
+		0.093989f,
+		-0.133764f,
+		0.472517f,
+		0.000000f,
+		0.188000f,
+		-0.266600f,
+		0.945200f,
+		0.281200f,
+		0.413800f,
+		0.177751f,
+		-0.185069f,
+		0.429130f,
+		0.000000f,
+		0.355700f,
+		-0.369000f,
+		0.858700f,
+		0.312500f,
+		0.379300f,
+		0.093989f,
+		-0.133764f,
+		0.472517f,
+		0.000000f,
+		0.188000f,
+		-0.266600f,
+		0.945200f,
+		0.281200f,
+		0.413800f,
+		0.090617f,
+		-0.185069f,
+		0.455563f,
+		0.000000f,
+		0.181300f,
+		-0.369000f,
+		0.911600f,
+		0.281200f,
+		0.379300f,
+		0.098646f,
+		0.428429f,
+		0.238155f,
+		0.000000f,
+		0.198200f,
+		0.855300f,
+		0.478600f,
+		0.312500f,
+		0.827600f,
+		0.080342f,
+		0.453788f,
+		0.193963f,
+		0.000000f,
+		0.161700f,
+		0.906300f,
+		0.390500f,
+		0.312500f,
+		0.862100f,
+		0.040957f,
+		0.453788f,
+		0.205910f,
+		0.000000f,
+		0.082400f,
+		0.906300f,
+		0.414500f,
+		0.281200f,
+		0.862100f,
+		0.098646f,
+		0.428429f,
+		0.238155f,
+		0.000000f,
+		0.198200f,
+		0.855300f,
+		0.478600f,
+		0.312500f,
+		0.827600f,
+		0.040957f,
+		0.453788f,
+		0.205910f,
+		0.000000f,
+		0.082400f,
+		0.906300f,
+		0.414500f,
+		0.281200f,
+		0.862100f,
+		0.050289f,
+		0.428429f,
+		0.252823f,
+		0.000000f,
+		0.101000f,
+		0.855300f,
+		0.508100f,
+		0.281200f,
+		0.827600f,
+		0.169052f,
+		-0.234204f,
+		0.408129f,
+		0.000000f,
+		0.338400f,
+		-0.467000f,
+		0.816900f,
+		0.312500f,
+		0.344800f,
+		0.177751f,
+		-0.185069f,
+		0.429130f,
+		0.000000f,
+		0.355700f,
+		-0.369000f,
+		0.858700f,
+		0.312500f,
+		0.379300f,
+		0.090617f,
+		-0.185069f,
+		0.455563f,
+		0.000000f,
+		0.181300f,
+		-0.369000f,
+		0.911600f,
+		0.281200f,
+		0.379300f,
+		0.169052f,
+		-0.234204f,
+		0.408129f,
+		0.000000f,
+		0.338400f,
+		-0.467000f,
+		0.816900f,
+		0.312500f,
+		0.344800f,
+		0.090617f,
+		-0.185069f,
+		0.455563f,
+		0.000000f,
+		0.181300f,
+		-0.369000f,
+		0.911600f,
+		0.281200f,
+		0.379300f,
+		0.086181f,
+		-0.234204f,
+		0.433267f,
+		0.000000f,
+		0.172500f,
+		-0.467000f,
+		0.867200f,
+		0.281200f,
+		0.344800f,
+		0.115795f,
+		0.398046f,
+		0.279554f,
+		0.000000f,
+		0.232400f,
+		0.794500f,
+		0.561100f,
+		0.312500f,
+		0.793100f,
+		0.098646f,
+		0.428429f,
+		0.238155f,
+		0.000000f,
+		0.198200f,
+		0.855300f,
+		0.478600f,
+		0.312500f,
+		0.827600f,
+		0.050289f,
+		0.428429f,
+		0.252823f,
+		0.000000f,
+		0.101000f,
+		0.855300f,
+		0.508100f,
+		0.281200f,
+		0.827600f,
+		0.115795f,
+		0.398046f,
+		0.279554f,
+		0.000000f,
+		0.232400f,
+		0.794500f,
+		0.561100f,
+		0.312500f,
+		0.793100f,
+		0.050289f,
+		0.428429f,
+		0.252823f,
+		0.000000f,
+		0.101000f,
+		0.855300f,
+		0.508100f,
+		0.281200f,
+		0.827600f,
+		0.059032f,
+		0.398046f,
+		0.296773f,
+		0.000000f,
+		0.118500f,
+		0.794500f,
+		0.595600f,
+		0.281200f,
+		0.793100f,
+		0.158370f,
+		-0.280594f,
+		0.382342f,
+		0.000000f,
+		0.317100f,
+		-0.559600f,
+		0.765600f,
+		0.312500f,
+		0.310300f,
+		0.169052f,
+		-0.234204f,
+		0.408129f,
+		0.000000f,
+		0.338400f,
+		-0.467000f,
+		0.816900f,
+		0.312500f,
+		0.344800f,
+		0.086181f,
+		-0.234204f,
+		0.433267f,
+		0.000000f,
+		0.172500f,
+		-0.467000f,
+		0.867200f,
+		0.281200f,
+		0.344800f,
+		0.158370f,
+		-0.280594f,
+		0.382342f,
+		0.000000f,
+		0.317100f,
+		-0.559600f,
+		0.765600f,
+		0.312500f,
+		0.310300f,
+		0.086181f,
+		-0.234204f,
+		0.433267f,
+		0.000000f,
+		0.172500f,
+		-0.467000f,
+		0.867200f,
+		0.281200f,
+		0.344800f,
+		0.080737f,
+		-0.280594f,
+		0.405892f,
+		0.000000f,
+		0.161700f,
+		-0.559600f,
+		0.812800f,
+		0.281200f,
+		0.310300f,
+		0.131585f,
+		0.362998f,
+		0.317675f,
+		0.000000f,
+		0.263800f,
+		0.724300f,
+		0.637000f,
+		0.312500f,
+		0.758600f,
+		0.115795f,
+		0.398046f,
+		0.279554f,
+		0.000000f,
+		0.232400f,
+		0.794500f,
+		0.561100f,
+		0.312500f,
+		0.793100f,
+		0.059032f,
+		0.398046f,
+		0.296773f,
+		0.000000f,
+		0.118500f,
+		0.794500f,
+		0.595600f,
+		0.281200f,
+		0.793100f,
+		0.131585f,
+		0.362998f,
+		0.317675f,
+		0.000000f,
+		0.263800f,
+		0.724300f,
+		0.637000f,
+		0.312500f,
+		0.758600f,
+		0.059032f,
+		0.398046f,
+		0.296773f,
+		0.000000f,
+		0.118500f,
+		0.794500f,
+		0.595600f,
+		0.281200f,
+		0.793100f,
+		0.067081f,
+		0.362998f,
+		0.337242f,
+		0.000000f,
+		0.134500f,
+		0.724300f,
+		0.676200f,
+		0.281200f,
+		0.758600f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.411700f,
+		0.051000f,
+		0.010546f,
+		-0.497069f,
+		0.053020f,
+		0.000000f,
+		0.021700f,
+		-0.993700f,
+		0.109300f,
+		0.434000f,
+		0.053800f,
+		-0.000000f,
+		-0.497069f,
+		0.054060f,
+		0.000000f,
+		0.000000f,
+		-0.993700f,
+		0.111500f,
+		0.431300f,
+		0.053800f,
+		0.096259f,
+		-0.080891f,
+		0.483932f,
+		0.000000f,
+		0.192500f,
+		-0.161200f,
+		0.967900f,
+		0.281200f,
+		0.448300f,
+		0.097401f,
+		-0.027069f,
+		0.489673f,
+		0.000000f,
+		0.194800f,
+		-0.054000f,
+		0.979300f,
+		0.281200f,
+		0.482800f,
+		-0.000000f,
+		-0.027069f,
+		0.499266f,
+		0.000000f,
+		0.000000f,
+		-0.054000f,
+		0.998500f,
+		0.250000f,
+		0.482800f,
+		0.096259f,
+		-0.080891f,
+		0.483932f,
+		0.000000f,
+		0.192500f,
+		-0.161200f,
+		0.967900f,
+		0.281200f,
+		0.448300f,
+		-0.000000f,
+		-0.027069f,
+		0.499266f,
+		0.000000f,
+		0.000000f,
+		-0.054000f,
+		0.998500f,
+		0.250000f,
+		0.482800f,
+		-0.000000f,
+		-0.080891f,
+		0.493412f,
+		0.000000f,
+		0.000000f,
+		-0.161200f,
+		0.986900f,
+		0.250000f,
+		0.448300f,
+		0.031146f,
+		0.473826f,
+		0.156583f,
+		0.000000f,
+		0.062900f,
+		0.946600f,
+		0.316100f,
+		0.281200f,
+		0.896600f,
+		0.020969f,
+		0.488310f,
+		0.105420f,
+		0.000000f,
+		0.042500f,
+		0.975900f,
+		0.214000f,
+		0.281200f,
+		0.931000f,
+		-0.000000f,
+		0.488310f,
+		0.107484f,
+		0.000000f,
+		0.000000f,
+		0.975900f,
+		0.218200f,
+		0.250000f,
+		0.931000f,
+		0.031146f,
+		0.473826f,
+		0.156583f,
+		0.000000f,
+		0.062900f,
+		0.946600f,
+		0.316100f,
+		0.281200f,
+		0.896600f,
+		-0.000000f,
+		0.488310f,
+		0.107484f,
+		0.000000f,
+		0.000000f,
+		0.975900f,
+		0.218200f,
+		0.250000f,
+		0.931000f,
+		-0.000000f,
+		0.473826f,
+		0.159650f,
+		0.000000f,
+		0.000000f,
+		0.946600f,
+		0.322300f,
+		0.250000f,
+		0.896600f,
+		0.093989f,
+		-0.133764f,
+		0.472517f,
+		0.000000f,
+		0.188000f,
+		-0.266600f,
+		0.945200f,
+		0.281200f,
+		0.413800f,
+		0.096259f,
+		-0.080891f,
+		0.483932f,
+		0.000000f,
+		0.192500f,
+		-0.161200f,
+		0.967900f,
+		0.281200f,
+		0.448300f,
+		-0.000000f,
+		-0.080891f,
+		0.493412f,
+		0.000000f,
+		0.000000f,
+		-0.161200f,
+		0.986900f,
+		0.250000f,
+		0.448300f,
+		0.093989f,
+		-0.133764f,
+		0.472517f,
+		0.000000f,
+		0.188000f,
+		-0.266600f,
+		0.945200f,
+		0.281200f,
+		0.413800f,
+		-0.000000f,
+		-0.080891f,
+		0.493412f,
+		0.000000f,
+		0.000000f,
+		-0.161200f,
+		0.986900f,
+		0.250000f,
+		0.448300f,
+		-0.000000f,
+		-0.133764f,
+		0.481775f,
+		0.000000f,
+		0.000000f,
+		-0.266600f,
+		0.963800f,
+		0.250000f,
+		0.413800f,
+		0.040957f,
+		0.453788f,
+		0.205910f,
+		0.000000f,
+		0.082400f,
+		0.906300f,
+		0.414500f,
+		0.281200f,
+		0.862100f,
+		0.031146f,
+		0.473826f,
+		0.156583f,
+		0.000000f,
+		0.062900f,
+		0.946600f,
+		0.316100f,
+		0.281200f,
+		0.896600f,
+		-0.000000f,
+		0.473826f,
+		0.159650f,
+		0.000000f,
+		0.000000f,
+		0.946600f,
+		0.322300f,
+		0.250000f,
+		0.896600f,
+		0.040957f,
+		0.453788f,
+		0.205910f,
+		0.000000f,
+		0.082400f,
+		0.906300f,
+		0.414500f,
+		0.281200f,
+		0.862100f,
+		-0.000000f,
+		0.473826f,
+		0.159650f,
+		0.000000f,
+		0.000000f,
+		0.946600f,
+		0.322300f,
+		0.250000f,
+		0.896600f,
+		-0.000000f,
+		0.453788f,
+		0.209944f,
+		0.000000f,
+		0.000000f,
+		0.906300f,
+		0.422700f,
+		0.250000f,
+		0.862100f,
+		0.090617f,
+		-0.185069f,
+		0.455563f,
+		0.000000f,
+		0.181300f,
+		-0.369000f,
+		0.911600f,
+		0.281200f,
+		0.379300f,
+		0.093989f,
+		-0.133764f,
+		0.472517f,
+		0.000000f,
+		0.188000f,
+		-0.266600f,
+		0.945200f,
+		0.281200f,
+		0.413800f,
+		-0.000000f,
+		-0.133764f,
+		0.481775f,
+		0.000000f,
+		0.000000f,
+		-0.266600f,
+		0.963800f,
+		0.250000f,
+		0.413800f,
+		0.090617f,
+		-0.185069f,
+		0.455563f,
+		0.000000f,
+		0.181300f,
+		-0.369000f,
+		0.911600f,
+		0.281200f,
+		0.379300f,
+		-0.000000f,
+		-0.133764f,
+		0.481775f,
+		0.000000f,
+		0.000000f,
+		-0.266600f,
+		0.963800f,
+		0.250000f,
+		0.413800f,
+		-0.000000f,
+		-0.185069f,
+		0.464487f,
+		0.000000f,
+		0.000000f,
+		-0.369000f,
+		0.929400f,
+		0.250000f,
+		0.379300f,
+		0.050289f,
+		0.428429f,
+		0.252823f,
+		0.000000f,
+		0.101000f,
+		0.855300f,
+		0.508100f,
+		0.281200f,
+		0.827600f,
+		0.040957f,
+		0.453788f,
+		0.205910f,
+		0.000000f,
+		0.082400f,
+		0.906300f,
+		0.414500f,
+		0.281200f,
+		0.862100f,
+		-0.000000f,
+		0.453788f,
+		0.209944f,
+		0.000000f,
+		0.000000f,
+		0.906300f,
+		0.422700f,
+		0.250000f,
+		0.862100f,
+		0.050289f,
+		0.428429f,
+		0.252823f,
+		0.000000f,
+		0.101000f,
+		0.855300f,
+		0.508100f,
+		0.281200f,
+		0.827600f,
+		-0.000000f,
+		0.453788f,
+		0.209944f,
+		0.000000f,
+		0.000000f,
+		0.906300f,
+		0.422700f,
+		0.250000f,
+		0.862100f,
+		-0.000000f,
+		0.428429f,
+		0.257776f,
+		0.000000f,
+		0.000000f,
+		0.855300f,
+		0.518000f,
+		0.250000f,
+		0.827600f,
+		0.086181f,
+		-0.234204f,
+		0.433267f,
+		0.000000f,
+		0.172500f,
+		-0.467000f,
+		0.867200f,
+		0.281200f,
+		0.344800f,
+		0.090617f,
+		-0.185069f,
+		0.455563f,
+		0.000000f,
+		0.181300f,
+		-0.369000f,
+		0.911600f,
+		0.281200f,
+		0.379300f,
+		-0.000000f,
+		-0.185069f,
+		0.464487f,
+		0.000000f,
+		0.000000f,
+		-0.369000f,
+		0.929400f,
+		0.250000f,
+		0.379300f,
+		0.086181f,
+		-0.234204f,
+		0.433267f,
+		0.000000f,
+		0.172500f,
+		-0.467000f,
+		0.867200f,
+		0.281200f,
+		0.344800f,
+		-0.000000f,
+		-0.185069f,
+		0.464487f,
+		0.000000f,
+		0.000000f,
+		-0.369000f,
+		0.929400f,
+		0.250000f,
+		0.379300f,
+		-0.000000f,
+		-0.234204f,
+		0.441756f,
+		0.000000f,
+		0.000000f,
+		-0.467000f,
+		0.884200f,
+		0.250000f,
+		0.344800f,
+		0.059032f,
+		0.398046f,
+		0.296773f,
+		0.000000f,
+		0.118500f,
+		0.794500f,
+		0.595600f,
+		0.281200f,
+		0.793100f,
+		0.050289f,
+		0.428429f,
+		0.252823f,
+		0.000000f,
+		0.101000f,
+		0.855300f,
+		0.508100f,
+		0.281200f,
+		0.827600f,
+		-0.000000f,
+		0.428429f,
+		0.257776f,
+		0.000000f,
+		0.000000f,
+		0.855300f,
+		0.518000f,
+		0.250000f,
+		0.827600f,
+		0.059032f,
+		0.398046f,
+		0.296773f,
+		0.000000f,
+		0.118500f,
+		0.794500f,
+		0.595600f,
+		0.281200f,
+		0.793100f,
+		-0.000000f,
+		0.428429f,
+		0.257776f,
+		0.000000f,
+		0.000000f,
+		0.855300f,
+		0.518000f,
+		0.250000f,
+		0.827600f,
+		-0.000000f,
+		0.398046f,
+		0.302586f,
+		0.000000f,
+		0.000000f,
+		0.794500f,
+		0.607300f,
+		0.250000f,
+		0.793100f,
+		0.080737f,
+		-0.280594f,
+		0.405892f,
+		0.000000f,
+		0.161700f,
+		-0.559600f,
+		0.812800f,
+		0.281200f,
+		0.310300f,
+		0.086181f,
+		-0.234204f,
+		0.433267f,
+		0.000000f,
+		0.172500f,
+		-0.467000f,
+		0.867200f,
+		0.281200f,
+		0.344800f,
+		-0.000000f,
+		-0.234204f,
+		0.441756f,
+		0.000000f,
+		0.000000f,
+		-0.467000f,
+		0.884200f,
+		0.250000f,
+		0.344800f,
+		0.080737f,
+		-0.280594f,
+		0.405892f,
+		0.000000f,
+		0.161700f,
+		-0.559600f,
+		0.812800f,
+		0.281200f,
+		0.310300f,
+		-0.000000f,
+		-0.234204f,
+		0.441756f,
+		0.000000f,
+		0.000000f,
+		-0.467000f,
+		0.884200f,
+		0.250000f,
+		0.344800f,
+		-0.000000f,
+		-0.280594f,
+		0.413844f,
+		0.000000f,
+		0.000000f,
+		-0.559600f,
+		0.828700f,
+		0.250000f,
+		0.310300f,
+		0.067081f,
+		0.362998f,
+		0.337242f,
+		0.000000f,
+		0.134500f,
+		0.724300f,
+		0.676200f,
+		0.281200f,
+		0.758600f,
+		0.059032f,
+		0.398046f,
+		0.296773f,
+		0.000000f,
+		0.118500f,
+		0.794500f,
+		0.595600f,
+		0.281200f,
+		0.793100f,
+		-0.000000f,
+		0.398046f,
+		0.302586f,
+		0.000000f,
+		0.000000f,
+		0.794500f,
+		0.607300f,
+		0.250000f,
+		0.793100f,
+		0.067081f,
+		0.362998f,
+		0.337242f,
+		0.000000f,
+		0.134500f,
+		0.724300f,
+		0.676200f,
+		0.281200f,
+		0.758600f,
+		-0.000000f,
+		0.398046f,
+		0.302586f,
+		0.000000f,
+		0.000000f,
+		0.794500f,
+		0.607300f,
+		0.250000f,
+		0.793100f,
+		-0.000000f,
+		0.362998f,
+		0.343849f,
+		0.000000f,
+		0.000000f,
+		0.724300f,
+		0.689400f,
+		0.250000f,
+		0.758600f,
+		0.074345f,
+		-0.323693f,
+		0.373758f,
+		0.000000f,
+		0.149000f,
+		-0.645700f,
+		0.748900f,
+		0.281200f,
+		0.275900f,
+		0.080737f,
+		-0.280594f,
+		0.405892f,
+		0.000000f,
+		0.161700f,
+		-0.559600f,
+		0.812800f,
+		0.281200f,
+		0.310300f,
+		-0.000000f,
+		-0.280594f,
+		0.413844f,
+		0.000000f,
+		0.000000f,
+		-0.559600f,
+		0.828700f,
+		0.250000f,
+		0.310300f,
+		0.074345f,
+		-0.323693f,
+		0.373758f,
+		0.000000f,
+		0.149000f,
+		-0.645700f,
+		0.748900f,
+		0.281200f,
+		0.275900f,
+		-0.000000f,
+		-0.280594f,
+		0.413844f,
+		0.000000f,
+		0.000000f,
+		-0.559600f,
+		0.828700f,
+		0.250000f,
+		0.310300f,
+		-0.000000f,
+		-0.323693f,
+		0.381081f,
+		0.000000f,
+		0.000000f,
+		-0.645700f,
+		0.763500f,
+		0.250000f,
+		0.275900f,
+		0.074345f,
+		0.323693f,
+		0.373758f,
+		0.000000f,
+		0.149000f,
+		0.645700f,
+		0.748900f,
+		0.281200f,
+		0.724100f,
+		0.067081f,
+		0.362998f,
+		0.337242f,
+		0.000000f,
+		0.134500f,
+		0.724300f,
+		0.676200f,
+		0.281200f,
+		0.758600f,
+		-0.000000f,
+		0.362998f,
+		0.343849f,
+		0.000000f,
+		0.000000f,
+		0.724300f,
+		0.689400f,
+		0.250000f,
+		0.758600f,
+		0.074345f,
+		0.323693f,
+		0.373758f,
+		0.000000f,
+		0.149000f,
+		0.645700f,
+		0.748900f,
+		0.281200f,
+		0.724100f,
+		-0.000000f,
+		0.362998f,
+		0.343849f,
+		0.000000f,
+		0.000000f,
+		0.724300f,
+		0.689400f,
+		0.250000f,
+		0.758600f,
+		-0.000000f,
+		0.323693f,
+		0.381081f,
+		0.000000f,
+		0.000000f,
+		0.645700f,
+		0.763500f,
+		0.250000f,
+		0.724100f,
+		0.067081f,
+		-0.362998f,
+		0.337243f,
+		0.000000f,
+		0.134500f,
+		-0.724300f,
+		0.676200f,
+		0.281200f,
+		0.241400f,
+		0.074345f,
+		-0.323693f,
+		0.373758f,
+		0.000000f,
+		0.149000f,
+		-0.645700f,
+		0.748900f,
+		0.281200f,
+		0.275900f,
+		-0.000000f,
+		-0.323693f,
+		0.381081f,
+		0.000000f,
+		0.000000f,
+		-0.645700f,
+		0.763500f,
+		0.250000f,
+		0.275900f,
+		0.067081f,
+		-0.362998f,
+		0.337243f,
+		0.000000f,
+		0.134500f,
+		-0.724300f,
+		0.676200f,
+		0.281200f,
+		0.241400f,
+		-0.000000f,
+		-0.323693f,
+		0.381081f,
+		0.000000f,
+		0.000000f,
+		-0.645700f,
+		0.763500f,
+		0.250000f,
+		0.275900f,
+		-0.000000f,
+		-0.362998f,
+		0.343849f,
+		0.000000f,
+		0.000000f,
+		-0.724300f,
+		0.689500f,
+		0.250000f,
+		0.241400f,
+		0.080737f,
+		0.280594f,
+		0.405892f,
+		0.000000f,
+		0.161700f,
+		0.559600f,
+		0.812800f,
+		0.281200f,
+		0.689700f,
+		0.074345f,
+		0.323693f,
+		0.373758f,
+		0.000000f,
+		0.149000f,
+		0.645700f,
+		0.748900f,
+		0.281200f,
+		0.724100f,
+		-0.000000f,
+		0.323693f,
+		0.381081f,
+		0.000000f,
+		0.000000f,
+		0.645700f,
+		0.763500f,
+		0.250000f,
+		0.724100f,
+		0.080737f,
+		0.280594f,
+		0.405892f,
+		0.000000f,
+		0.161700f,
+		0.559600f,
+		0.812800f,
+		0.281200f,
+		0.689700f,
+		-0.000000f,
+		0.323693f,
+		0.381081f,
+		0.000000f,
+		0.000000f,
+		0.645700f,
+		0.763500f,
+		0.250000f,
+		0.724100f,
+		-0.000000f,
+		0.280594f,
+		0.413844f,
+		0.000000f,
+		0.000000f,
+		0.559600f,
+		0.828700f,
+		0.250000f,
+		0.689700f,
+		0.059031f,
+		-0.398046f,
+		0.296773f,
+		0.000000f,
+		0.118500f,
+		-0.794500f,
+		0.595600f,
+		0.281200f,
+		0.206900f,
+		0.067081f,
+		-0.362998f,
+		0.337243f,
+		0.000000f,
+		0.134500f,
+		-0.724300f,
+		0.676200f,
+		0.281200f,
+		0.241400f,
+		-0.000000f,
+		-0.362998f,
+		0.343849f,
+		0.000000f,
+		0.000000f,
+		-0.724300f,
+		0.689500f,
+		0.250000f,
+		0.241400f,
+		0.059031f,
+		-0.398046f,
+		0.296773f,
+		0.000000f,
+		0.118500f,
+		-0.794500f,
+		0.595600f,
+		0.281200f,
+		0.206900f,
+		-0.000000f,
+		-0.362998f,
+		0.343849f,
+		0.000000f,
+		0.000000f,
+		-0.724300f,
+		0.689500f,
+		0.250000f,
+		0.241400f,
+		-0.000000f,
+		-0.398046f,
+		0.302586f,
+		0.000000f,
+		0.000000f,
+		-0.794500f,
+		0.607300f,
+		0.250000f,
+		0.206900f,
+		0.086181f,
+		0.234204f,
+		0.433267f,
+		0.000000f,
+		0.172500f,
+		0.467000f,
+		0.867200f,
+		0.281200f,
+		0.655200f,
+		0.080737f,
+		0.280594f,
+		0.405892f,
+		0.000000f,
+		0.161700f,
+		0.559600f,
+		0.812800f,
+		0.281200f,
+		0.689700f,
+		-0.000000f,
+		0.280594f,
+		0.413844f,
+		0.000000f,
+		0.000000f,
+		0.559600f,
+		0.828700f,
+		0.250000f,
+		0.689700f,
+		0.086181f,
+		0.234204f,
+		0.433267f,
+		0.000000f,
+		0.172500f,
+		0.467000f,
+		0.867200f,
+		0.281200f,
+		0.655200f,
+		-0.000000f,
+		0.280594f,
+		0.413844f,
+		0.000000f,
+		0.000000f,
+		0.559600f,
+		0.828700f,
+		0.250000f,
+		0.689700f,
+		-0.000000f,
+		0.234204f,
+		0.441756f,
+		0.000000f,
+		0.000000f,
+		0.467000f,
+		0.884200f,
+		0.250000f,
+		0.655200f,
+		0.050289f,
+		-0.428429f,
+		0.252824f,
+		0.000000f,
+		0.101000f,
+		-0.855300f,
+		0.508100f,
+		0.281200f,
+		0.172400f,
+		0.059031f,
+		-0.398046f,
+		0.296773f,
+		0.000000f,
+		0.118500f,
+		-0.794500f,
+		0.595600f,
+		0.281200f,
+		0.206900f,
+		-0.000000f,
+		-0.398046f,
+		0.302586f,
+		0.000000f,
+		0.000000f,
+		-0.794500f,
+		0.607300f,
+		0.250000f,
+		0.206900f,
+		0.050289f,
+		-0.428429f,
+		0.252824f,
+		0.000000f,
+		0.101000f,
+		-0.855300f,
+		0.508100f,
+		0.281200f,
+		0.172400f,
+		-0.000000f,
+		-0.398046f,
+		0.302586f,
+		0.000000f,
+		0.000000f,
+		-0.794500f,
+		0.607300f,
+		0.250000f,
+		0.206900f,
+		-0.000000f,
+		-0.428429f,
+		0.257776f,
+		0.000000f,
+		0.000000f,
+		-0.855300f,
+		0.518000f,
+		0.250000f,
+		0.172400f,
+		0.090617f,
+		0.185069f,
+		0.455563f,
+		0.000000f,
+		0.181300f,
+		0.369000f,
+		0.911600f,
+		0.281200f,
+		0.620700f,
+		0.086181f,
+		0.234204f,
+		0.433267f,
+		0.000000f,
+		0.172500f,
+		0.467000f,
+		0.867200f,
+		0.281200f,
+		0.655200f,
+		-0.000000f,
+		0.234204f,
+		0.441756f,
+		0.000000f,
+		0.000000f,
+		0.467000f,
+		0.884200f,
+		0.250000f,
+		0.655200f,
+		0.090617f,
+		0.185069f,
+		0.455563f,
+		0.000000f,
+		0.181300f,
+		0.369000f,
+		0.911600f,
+		0.281200f,
+		0.620700f,
+		-0.000000f,
+		0.234204f,
+		0.441756f,
+		0.000000f,
+		0.000000f,
+		0.467000f,
+		0.884200f,
+		0.250000f,
+		0.655200f,
+		-0.000000f,
+		0.185069f,
+		0.464487f,
+		0.000000f,
+		0.000000f,
+		0.369000f,
+		0.929400f,
+		0.250000f,
+		0.620700f,
+		0.040957f,
+		-0.453788f,
+		0.205910f,
+		0.000000f,
+		0.082400f,
+		-0.906300f,
+		0.414500f,
+		0.281200f,
+		0.137900f,
+		0.050289f,
+		-0.428429f,
+		0.252824f,
+		0.000000f,
+		0.101000f,
+		-0.855300f,
+		0.508100f,
+		0.281200f,
+		0.172400f,
+		-0.000000f,
+		-0.428429f,
+		0.257776f,
+		0.000000f,
+		0.000000f,
+		-0.855300f,
+		0.518000f,
+		0.250000f,
+		0.172400f,
+		0.040957f,
+		-0.453788f,
+		0.205910f,
+		0.000000f,
+		0.082400f,
+		-0.906300f,
+		0.414500f,
+		0.281200f,
+		0.137900f,
+		-0.000000f,
+		-0.428429f,
+		0.257776f,
+		0.000000f,
+		0.000000f,
+		-0.855300f,
+		0.518000f,
+		0.250000f,
+		0.172400f,
+		-0.000000f,
+		-0.453788f,
+		0.209944f,
+		0.000000f,
+		0.000000f,
+		-0.906300f,
+		0.422700f,
+		0.250000f,
+		0.137900f,
+		0.093989f,
+		0.133764f,
+		0.472517f,
+		0.000000f,
+		0.188000f,
+		0.266600f,
+		0.945200f,
+		0.281200f,
+		0.586200f,
+		0.090617f,
+		0.185069f,
+		0.455563f,
+		0.000000f,
+		0.181300f,
+		0.369000f,
+		0.911600f,
+		0.281200f,
+		0.620700f,
+		-0.000000f,
+		0.185069f,
+		0.464487f,
+		0.000000f,
+		0.000000f,
+		0.369000f,
+		0.929400f,
+		0.250000f,
+		0.620700f,
+		0.093989f,
+		0.133764f,
+		0.472517f,
+		0.000000f,
+		0.188000f,
+		0.266600f,
+		0.945200f,
+		0.281200f,
+		0.586200f,
+		-0.000000f,
+		0.185069f,
+		0.464487f,
+		0.000000f,
+		0.000000f,
+		0.369000f,
+		0.929400f,
+		0.250000f,
+		0.620700f,
+		-0.000000f,
+		0.133764f,
+		0.481775f,
+		0.000000f,
+		0.000000f,
+		0.266600f,
+		0.963800f,
+		0.250000f,
+		0.586200f,
+		0.031146f,
+		-0.473826f,
+		0.156583f,
+		0.000000f,
+		0.062900f,
+		-0.946600f,
+		0.316100f,
+		0.281200f,
+		0.103400f,
+		0.040957f,
+		-0.453788f,
+		0.205910f,
+		0.000000f,
+		0.082400f,
+		-0.906300f,
+		0.414500f,
+		0.281200f,
+		0.137900f,
+		-0.000000f,
+		-0.453788f,
+		0.209944f,
+		0.000000f,
+		0.000000f,
+		-0.906300f,
+		0.422700f,
+		0.250000f,
+		0.137900f,
+		0.031146f,
+		-0.473826f,
+		0.156583f,
+		0.000000f,
+		0.062900f,
+		-0.946600f,
+		0.316100f,
+		0.281200f,
+		0.103400f,
+		-0.000000f,
+		-0.453788f,
+		0.209944f,
+		0.000000f,
+		0.000000f,
+		-0.906300f,
+		0.422700f,
+		0.250000f,
+		0.137900f,
+		-0.000000f,
+		-0.473826f,
+		0.159651f,
+		0.000000f,
+		0.000000f,
+		-0.946600f,
+		0.322300f,
+		0.250000f,
+		0.103400f,
+		0.096259f,
+		0.080891f,
+		0.483932f,
+		0.000000f,
+		0.192500f,
+		0.161200f,
+		0.967900f,
+		0.281200f,
+		0.551700f,
+		0.093989f,
+		0.133764f,
+		0.472517f,
+		0.000000f,
+		0.188000f,
+		0.266600f,
+		0.945200f,
+		0.281200f,
+		0.586200f,
+		-0.000000f,
+		0.133764f,
+		0.481775f,
+		0.000000f,
+		0.000000f,
+		0.266600f,
+		0.963800f,
+		0.250000f,
+		0.586200f,
+		0.096259f,
+		0.080891f,
+		0.483932f,
+		0.000000f,
+		0.192500f,
+		0.161200f,
+		0.967900f,
+		0.281200f,
+		0.551700f,
+		-0.000000f,
+		0.133764f,
+		0.481775f,
+		0.000000f,
+		0.000000f,
+		0.266600f,
+		0.963800f,
+		0.250000f,
+		0.586200f,
+		-0.000000f,
+		0.080891f,
+		0.493412f,
+		0.000000f,
+		0.000000f,
+		0.161200f,
+		0.986900f,
+		0.250000f,
+		0.551700f,
+		0.020969f,
+		-0.488310f,
+		0.105420f,
+		0.000000f,
+		0.042500f,
+		-0.975900f,
+		0.214000f,
+		0.281200f,
+		0.069000f,
+		0.031146f,
+		-0.473826f,
+		0.156583f,
+		0.000000f,
+		0.062900f,
+		-0.946600f,
+		0.316100f,
+		0.281200f,
+		0.103400f,
+		-0.000000f,
+		-0.473826f,
+		0.159651f,
+		0.000000f,
+		0.000000f,
+		-0.946600f,
+		0.322300f,
+		0.250000f,
+		0.103400f,
+		0.020969f,
+		-0.488310f,
+		0.105420f,
+		0.000000f,
+		0.042500f,
+		-0.975900f,
+		0.214000f,
+		0.281200f,
+		0.069000f,
+		-0.000000f,
+		-0.473826f,
+		0.159651f,
+		0.000000f,
+		0.000000f,
+		-0.946600f,
+		0.322300f,
+		0.250000f,
+		0.103400f,
+		-0.000000f,
+		-0.488310f,
+		0.107485f,
+		0.000000f,
+		0.000000f,
+		-0.975900f,
+		0.218200f,
+		0.250000f,
+		0.069000f,
+		0.097401f,
+		0.027069f,
+		0.489673f,
+		0.000000f,
+		0.194800f,
+		0.054000f,
+		0.979300f,
+		0.281200f,
+		0.517200f,
+		0.096259f,
+		0.080891f,
+		0.483932f,
+		0.000000f,
+		0.192500f,
+		0.161200f,
+		0.967900f,
+		0.281200f,
+		0.551700f,
+		-0.000000f,
+		0.080891f,
+		0.493412f,
+		0.000000f,
+		0.000000f,
+		0.161200f,
+		0.986900f,
+		0.250000f,
+		0.551700f,
+		0.097401f,
+		0.027069f,
+		0.489673f,
+		0.000000f,
+		0.194800f,
+		0.054000f,
+		0.979300f,
+		0.281200f,
+		0.517200f,
+		-0.000000f,
+		0.080891f,
+		0.493412f,
+		0.000000f,
+		0.000000f,
+		0.161200f,
+		0.986900f,
+		0.250000f,
+		0.551700f,
+		-0.000000f,
+		0.027069f,
+		0.499266f,
+		0.000000f,
+		0.000000f,
+		0.054000f,
+		0.998500f,
+		0.250000f,
+		0.517200f,
+		0.010546f,
+		0.497069f,
+		0.053020f,
+		0.000000f,
+		0.021700f,
+		0.993700f,
+		0.109300f,
+		0.468900f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.482000f,
+		0.960300f,
+		-0.000000f,
+		0.497069f,
+		0.054059f,
+		0.000000f,
+		0.000000f,
+		0.993700f,
+		0.111500f,
+		0.470800f,
+		0.962300f,
+		0.010546f,
+		-0.497069f,
+		0.053020f,
+		0.000000f,
+		0.021700f,
+		-0.993700f,
+		0.109300f,
+		0.281200f,
+		0.034500f,
+		0.020969f,
+		-0.488310f,
+		0.105420f,
+		0.000000f,
+		0.042500f,
+		-0.975900f,
+		0.214000f,
+		0.281200f,
+		0.069000f,
+		-0.000000f,
+		-0.488310f,
+		0.107485f,
+		0.000000f,
+		0.000000f,
+		-0.975900f,
+		0.218200f,
+		0.250000f,
+		0.069000f,
+		0.010546f,
+		-0.497069f,
+		0.053020f,
+		0.000000f,
+		0.021700f,
+		-0.993700f,
+		0.109300f,
+		0.281200f,
+		0.034500f,
+		-0.000000f,
+		-0.488310f,
+		0.107485f,
+		0.000000f,
+		0.000000f,
+		-0.975900f,
+		0.218200f,
+		0.250000f,
+		0.069000f,
+		-0.000000f,
+		-0.497069f,
+		0.054060f,
+		0.000000f,
+		0.000000f,
+		-0.993700f,
+		0.111500f,
+		0.250000f,
+		0.034500f,
+		0.097401f,
+		-0.027069f,
+		0.489673f,
+		0.000000f,
+		0.194800f,
+		-0.054000f,
+		0.979300f,
+		0.281200f,
+		0.482800f,
+		0.097401f,
+		0.027069f,
+		0.489673f,
+		0.000000f,
+		0.194800f,
+		0.054000f,
+		0.979300f,
+		0.281200f,
+		0.517200f,
+		-0.000000f,
+		0.027069f,
+		0.499266f,
+		0.000000f,
+		0.000000f,
+		0.054000f,
+		0.998500f,
+		0.250000f,
+		0.517200f,
+		0.097401f,
+		-0.027069f,
+		0.489673f,
+		0.000000f,
+		0.194800f,
+		-0.054000f,
+		0.979300f,
+		0.281200f,
+		0.482800f,
+		-0.000000f,
+		0.027069f,
+		0.499266f,
+		0.000000f,
+		0.000000f,
+		0.054000f,
+		0.998500f,
+		0.250000f,
+		0.517200f,
+		-0.000000f,
+		-0.027069f,
+		0.499266f,
+		0.000000f,
+		0.000000f,
+		-0.054000f,
+		0.998500f,
+		0.250000f,
+		0.482800f,
+		0.020969f,
+		0.488310f,
+		0.105420f,
+		0.000000f,
+		0.042500f,
+		0.975900f,
+		0.214000f,
+		0.281200f,
+		0.931000f,
+		0.010546f,
+		0.497069f,
+		0.053020f,
+		0.000000f,
+		0.021700f,
+		0.993700f,
+		0.109300f,
+		0.281200f,
+		0.965500f,
+		-0.000000f,
+		0.497069f,
+		0.054059f,
+		0.000000f,
+		0.000000f,
+		0.993700f,
+		0.111500f,
+		0.250000f,
+		0.965500f,
+		0.020969f,
+		0.488310f,
+		0.105420f,
+		0.000000f,
+		0.042500f,
+		0.975900f,
+		0.214000f,
+		0.281200f,
+		0.931000f,
+		-0.000000f,
+		0.497069f,
+		0.054059f,
+		0.000000f,
+		0.000000f,
+		0.993700f,
+		0.111500f,
+		0.250000f,
+		0.965500f,
+		-0.000000f,
+		0.488310f,
+		0.107484f,
+		0.000000f,
+		0.000000f,
+		0.975900f,
+		0.218200f,
+		0.250000f,
+		0.931000f,
+		-0.000000f,
+		-0.428429f,
+		0.257776f,
+		0.000000f,
+		0.000000f,
+		-0.855300f,
+		0.518000f,
+		0.250000f,
+		0.172400f,
+		-0.000000f,
+		-0.398046f,
+		0.302586f,
+		0.000000f,
+		0.000000f,
+		-0.794500f,
+		0.607300f,
+		0.250000f,
+		0.206900f,
+		-0.059032f,
+		-0.398046f,
+		0.296773f,
+		0.000000f,
+		-0.118500f,
+		-0.794500f,
+		0.595600f,
+		0.218700f,
+		0.206900f,
+		-0.000000f,
+		-0.428429f,
+		0.257776f,
+		0.000000f,
+		0.000000f,
+		-0.855300f,
+		0.518000f,
+		0.250000f,
+		0.172400f,
+		-0.059032f,
+		-0.398046f,
+		0.296773f,
+		0.000000f,
+		-0.118500f,
+		-0.794500f,
+		0.595600f,
+		0.218700f,
+		0.206900f,
+		-0.050290f,
+		-0.428429f,
+		0.252824f,
+		0.000000f,
+		-0.101000f,
+		-0.855300f,
+		0.508100f,
+		0.218700f,
+		0.172400f,
+		-0.000000f,
+		0.185069f,
+		0.464487f,
+		0.000000f,
+		0.000000f,
+		0.369000f,
+		0.929400f,
+		0.250000f,
+		0.620700f,
+		-0.000000f,
+		0.234204f,
+		0.441756f,
+		0.000000f,
+		0.000000f,
+		0.467000f,
+		0.884200f,
+		0.250000f,
+		0.655200f,
+		-0.086182f,
+		0.234204f,
+		0.433267f,
+		0.000000f,
+		-0.172500f,
+		0.467000f,
+		0.867200f,
+		0.218700f,
+		0.655200f,
+		-0.000000f,
+		0.185069f,
+		0.464487f,
+		0.000000f,
+		0.000000f,
+		0.369000f,
+		0.929400f,
+		0.250000f,
+		0.620700f,
+		-0.086182f,
+		0.234204f,
+		0.433267f,
+		0.000000f,
+		-0.172500f,
+		0.467000f,
+		0.867200f,
+		0.218700f,
+		0.655200f,
+		-0.090618f,
+		0.185069f,
+		0.455563f,
+		0.000000f,
+		-0.181300f,
+		0.369000f,
+		0.911600f,
+		0.218700f,
+		0.620700f,
+		-0.000000f,
+		-0.453788f,
+		0.209944f,
+		0.000000f,
+		0.000000f,
+		-0.906300f,
+		0.422700f,
+		0.250000f,
+		0.137900f,
+		-0.000000f,
+		-0.428429f,
+		0.257776f,
+		0.000000f,
+		0.000000f,
+		-0.855300f,
+		0.518000f,
+		0.250000f,
+		0.172400f,
+		-0.050290f,
+		-0.428429f,
+		0.252824f,
+		0.000000f,
+		-0.101000f,
+		-0.855300f,
+		0.508100f,
+		0.218700f,
+		0.172400f,
+		-0.000000f,
+		-0.453788f,
+		0.209944f,
+		0.000000f,
+		0.000000f,
+		-0.906300f,
+		0.422700f,
+		0.250000f,
+		0.137900f,
+		-0.050290f,
+		-0.428429f,
+		0.252824f,
+		0.000000f,
+		-0.101000f,
+		-0.855300f,
+		0.508100f,
+		0.218700f,
+		0.172400f,
+		-0.040959f,
+		-0.453788f,
+		0.205910f,
+		0.000000f,
+		-0.082400f,
+		-0.906300f,
+		0.414500f,
+		0.218700f,
+		0.137900f,
+		-0.000000f,
+		0.133764f,
+		0.481775f,
+		0.000000f,
+		0.000000f,
+		0.266600f,
+		0.963800f,
+		0.250000f,
+		0.586200f,
+		-0.000000f,
+		0.185069f,
+		0.464487f,
+		0.000000f,
+		0.000000f,
+		0.369000f,
+		0.929400f,
+		0.250000f,
+		0.620700f,
+		-0.090618f,
+		0.185069f,
+		0.455563f,
+		0.000000f,
+		-0.181300f,
+		0.369000f,
+		0.911600f,
+		0.218700f,
+		0.620700f,
+		-0.000000f,
+		0.133764f,
+		0.481775f,
+		0.000000f,
+		0.000000f,
+		0.266600f,
+		0.963800f,
+		0.250000f,
+		0.586200f,
+		-0.090618f,
+		0.185069f,
+		0.455563f,
+		0.000000f,
+		-0.181300f,
+		0.369000f,
+		0.911600f,
+		0.218700f,
+		0.620700f,
+		-0.093990f,
+		0.133764f,
+		0.472517f,
+		0.000000f,
+		-0.188000f,
+		0.266600f,
+		0.945200f,
+		0.218700f,
+		0.586200f,
+		-0.000000f,
+		-0.473826f,
+		0.159651f,
+		0.000000f,
+		0.000000f,
+		-0.946600f,
+		0.322300f,
+		0.250000f,
+		0.103400f,
+		-0.000000f,
+		-0.453788f,
+		0.209944f,
+		0.000000f,
+		0.000000f,
+		-0.906300f,
+		0.422700f,
+		0.250000f,
+		0.137900f,
+		-0.040959f,
+		-0.453788f,
+		0.205910f,
+		0.000000f,
+		-0.082400f,
+		-0.906300f,
+		0.414500f,
+		0.218700f,
+		0.137900f,
+		-0.000000f,
+		-0.473826f,
+		0.159651f,
+		0.000000f,
+		0.000000f,
+		-0.946600f,
+		0.322300f,
+		0.250000f,
+		0.103400f,
+		-0.040959f,
+		-0.453788f,
+		0.205910f,
+		0.000000f,
+		-0.082400f,
+		-0.906300f,
+		0.414500f,
+		0.218700f,
+		0.137900f,
+		-0.031147f,
+		-0.473826f,
+		0.156583f,
+		0.000000f,
+		-0.062900f,
+		-0.946600f,
+		0.316100f,
+		0.218700f,
+		0.103400f,
+		-0.000000f,
+		0.080891f,
+		0.493412f,
+		0.000000f,
+		0.000000f,
+		0.161200f,
+		0.986900f,
+		0.250000f,
+		0.551700f,
+		-0.000000f,
+		0.133764f,
+		0.481775f,
+		0.000000f,
+		0.000000f,
+		0.266600f,
+		0.963800f,
+		0.250000f,
+		0.586200f,
+		-0.093990f,
+		0.133764f,
+		0.472517f,
+		0.000000f,
+		-0.188000f,
+		0.266600f,
+		0.945200f,
+		0.218700f,
+		0.586200f,
+		-0.000000f,
+		0.080891f,
+		0.493412f,
+		0.000000f,
+		0.000000f,
+		0.161200f,
+		0.986900f,
+		0.250000f,
+		0.551700f,
+		-0.093990f,
+		0.133764f,
+		0.472517f,
+		0.000000f,
+		-0.188000f,
+		0.266600f,
+		0.945200f,
+		0.218700f,
+		0.586200f,
+		-0.096261f,
+		0.080891f,
+		0.483932f,
+		0.000000f,
+		-0.192500f,
+		0.161200f,
+		0.967900f,
+		0.218700f,
+		0.551700f,
+		-0.000000f,
+		-0.488310f,
+		0.107485f,
+		0.000000f,
+		0.000000f,
+		-0.975900f,
+		0.218200f,
+		0.250000f,
+		0.069000f,
+		-0.000000f,
+		-0.473826f,
+		0.159651f,
+		0.000000f,
+		0.000000f,
+		-0.946600f,
+		0.322300f,
+		0.250000f,
+		0.103400f,
+		-0.031147f,
+		-0.473826f,
+		0.156583f,
+		0.000000f,
+		-0.062900f,
+		-0.946600f,
+		0.316100f,
+		0.218700f,
+		0.103400f,
+		-0.000000f,
+		-0.488310f,
+		0.107485f,
+		0.000000f,
+		0.000000f,
+		-0.975900f,
+		0.218200f,
+		0.250000f,
+		0.069000f,
+		-0.031147f,
+		-0.473826f,
+		0.156583f,
+		0.000000f,
+		-0.062900f,
+		-0.946600f,
+		0.316100f,
+		0.218700f,
+		0.103400f,
+		-0.020970f,
+		-0.488310f,
+		0.105420f,
+		0.000000f,
+		-0.042500f,
+		-0.975900f,
+		0.214000f,
+		0.218700f,
+		0.069000f,
+		-0.000000f,
+		0.027069f,
+		0.499266f,
+		0.000000f,
+		0.000000f,
+		0.054000f,
+		0.998500f,
+		0.250000f,
+		0.517200f,
+		-0.000000f,
+		0.080891f,
+		0.493412f,
+		0.000000f,
+		0.000000f,
+		0.161200f,
+		0.986900f,
+		0.250000f,
+		0.551700f,
+		-0.096261f,
+		0.080891f,
+		0.483932f,
+		0.000000f,
+		-0.192500f,
+		0.161200f,
+		0.967900f,
+		0.218700f,
+		0.551700f,
+		-0.000000f,
+		0.027069f,
+		0.499266f,
+		0.000000f,
+		0.000000f,
+		0.054000f,
+		0.998500f,
+		0.250000f,
+		0.517200f,
+		-0.096261f,
+		0.080891f,
+		0.483932f,
+		0.000000f,
+		-0.192500f,
+		0.161200f,
+		0.967900f,
+		0.218700f,
+		0.551700f,
+		-0.097402f,
+		0.027069f,
+		0.489673f,
+		0.000000f,
+		-0.194800f,
+		0.054000f,
+		0.979300f,
+		0.218700f,
+		0.517200f,
+		-0.000000f,
+		0.497069f,
+		0.054059f,
+		0.000000f,
+		0.000000f,
+		0.993700f,
+		0.111500f,
+		0.470800f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.482000f,
+		0.960300f,
+		-0.010547f,
+		0.497069f,
+		0.053020f,
+		0.000000f,
+		-0.021700f,
+		0.993700f,
+		0.109300f,
+		0.472600f,
+		0.962300f,
+		-0.000000f,
+		-0.497069f,
+		0.054060f,
+		0.000000f,
+		0.000000f,
+		-0.993700f,
+		0.111500f,
+		0.250000f,
+		0.034500f,
+		-0.000000f,
+		-0.488310f,
+		0.107485f,
+		0.000000f,
+		0.000000f,
+		-0.975900f,
+		0.218200f,
+		0.250000f,
+		0.069000f,
+		-0.020970f,
+		-0.488310f,
+		0.105420f,
+		0.000000f,
+		-0.042500f,
+		-0.975900f,
+		0.214000f,
+		0.218700f,
+		0.069000f,
+		-0.000000f,
+		-0.497069f,
+		0.054060f,
+		0.000000f,
+		0.000000f,
+		-0.993700f,
+		0.111500f,
+		0.250000f,
+		0.034500f,
+		-0.020970f,
+		-0.488310f,
+		0.105420f,
+		0.000000f,
+		-0.042500f,
+		-0.975900f,
+		0.214000f,
+		0.218700f,
+		0.069000f,
+		-0.010547f,
+		-0.497069f,
+		0.053020f,
+		0.000000f,
+		-0.021700f,
+		-0.993700f,
+		0.109300f,
+		0.218700f,
+		0.034500f,
+		-0.000000f,
+		-0.027069f,
+		0.499266f,
+		0.000000f,
+		0.000000f,
+		-0.054000f,
+		0.998500f,
+		0.250000f,
+		0.482800f,
+		-0.000000f,
+		0.027069f,
+		0.499266f,
+		0.000000f,
+		0.000000f,
+		0.054000f,
+		0.998500f,
+		0.250000f,
+		0.517200f,
+		-0.097402f,
+		0.027069f,
+		0.489673f,
+		0.000000f,
+		-0.194800f,
+		0.054000f,
+		0.979300f,
+		0.218700f,
+		0.517200f,
+		-0.000000f,
+		-0.027069f,
+		0.499266f,
+		0.000000f,
+		0.000000f,
+		-0.054000f,
+		0.998500f,
+		0.250000f,
+		0.482800f,
+		-0.097402f,
+		0.027069f,
+		0.489673f,
+		0.000000f,
+		-0.194800f,
+		0.054000f,
+		0.979300f,
+		0.218700f,
+		0.517200f,
+		-0.097402f,
+		-0.027069f,
+		0.489673f,
+		0.000000f,
+		-0.194800f,
+		-0.054000f,
+		0.979300f,
+		0.218700f,
+		0.482800f,
+		-0.000000f,
+		0.488310f,
+		0.107484f,
+		0.000000f,
+		0.000000f,
+		0.975900f,
+		0.218200f,
+		0.250000f,
+		0.931000f,
+		-0.000000f,
+		0.497069f,
+		0.054059f,
+		0.000000f,
+		0.000000f,
+		0.993700f,
+		0.111500f,
+		0.250000f,
+		0.965500f,
+		-0.010547f,
+		0.497069f,
+		0.053020f,
+		0.000000f,
+		-0.021700f,
+		0.993700f,
+		0.109300f,
+		0.218700f,
+		0.965500f,
+		-0.000000f,
+		0.488310f,
+		0.107484f,
+		0.000000f,
+		0.000000f,
+		0.975900f,
+		0.218200f,
+		0.250000f,
+		0.931000f,
+		-0.010547f,
+		0.497069f,
+		0.053020f,
+		0.000000f,
+		-0.021700f,
+		0.993700f,
+		0.109300f,
+		0.218700f,
+		0.965500f,
+		-0.020970f,
+		0.488310f,
+		0.105420f,
+		0.000000f,
+		-0.042500f,
+		0.975900f,
+		0.214000f,
+		0.218700f,
+		0.931000f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.411700f,
+		0.051000f,
+		-0.000000f,
+		-0.497069f,
+		0.054060f,
+		0.000000f,
+		0.000000f,
+		-0.993700f,
+		0.111500f,
+		0.431300f,
+		0.053800f,
+		-0.010547f,
+		-0.497069f,
+		0.053020f,
+		0.000000f,
+		-0.021700f,
+		-0.993700f,
+		0.109300f,
+		0.428700f,
+		0.053800f,
+		-0.000000f,
+		-0.080891f,
+		0.493412f,
+		0.000000f,
+		0.000000f,
+		-0.161200f,
+		0.986900f,
+		0.250000f,
+		0.448300f,
+		-0.000000f,
+		-0.027069f,
+		0.499266f,
+		0.000000f,
+		0.000000f,
+		-0.054000f,
+		0.998500f,
+		0.250000f,
+		0.482800f,
+		-0.097402f,
+		-0.027069f,
+		0.489673f,
+		0.000000f,
+		-0.194800f,
+		-0.054000f,
+		0.979300f,
+		0.218700f,
+		0.482800f,
+		-0.000000f,
+		-0.080891f,
+		0.493412f,
+		0.000000f,
+		0.000000f,
+		-0.161200f,
+		0.986900f,
+		0.250000f,
+		0.448300f,
+		-0.097402f,
+		-0.027069f,
+		0.489673f,
+		0.000000f,
+		-0.194800f,
+		-0.054000f,
+		0.979300f,
+		0.218700f,
+		0.482800f,
+		-0.096261f,
+		-0.080891f,
+		0.483932f,
+		0.000000f,
+		-0.192500f,
+		-0.161200f,
+		0.967900f,
+		0.218700f,
+		0.448300f,
+		-0.000000f,
+		0.473826f,
+		0.159650f,
+		0.000000f,
+		0.000000f,
+		0.946600f,
+		0.322300f,
+		0.250000f,
+		0.896600f,
+		-0.000000f,
+		0.488310f,
+		0.107484f,
+		0.000000f,
+		0.000000f,
+		0.975900f,
+		0.218200f,
+		0.250000f,
+		0.931000f,
+		-0.020970f,
+		0.488310f,
+		0.105420f,
+		0.000000f,
+		-0.042500f,
+		0.975900f,
+		0.214000f,
+		0.218700f,
+		0.931000f,
+		-0.000000f,
+		0.473826f,
+		0.159650f,
+		0.000000f,
+		0.000000f,
+		0.946600f,
+		0.322300f,
+		0.250000f,
+		0.896600f,
+		-0.020970f,
+		0.488310f,
+		0.105420f,
+		0.000000f,
+		-0.042500f,
+		0.975900f,
+		0.214000f,
+		0.218700f,
+		0.931000f,
+		-0.031147f,
+		0.473826f,
+		0.156583f,
+		0.000000f,
+		-0.062900f,
+		0.946600f,
+		0.316100f,
+		0.218700f,
+		0.896600f,
+		-0.000000f,
+		-0.133764f,
+		0.481775f,
+		0.000000f,
+		0.000000f,
+		-0.266600f,
+		0.963800f,
+		0.250000f,
+		0.413800f,
+		-0.000000f,
+		-0.080891f,
+		0.493412f,
+		0.000000f,
+		0.000000f,
+		-0.161200f,
+		0.986900f,
+		0.250000f,
+		0.448300f,
+		-0.096261f,
+		-0.080891f,
+		0.483932f,
+		0.000000f,
+		-0.192500f,
+		-0.161200f,
+		0.967900f,
+		0.218700f,
+		0.448300f,
+		-0.000000f,
+		-0.133764f,
+		0.481775f,
+		0.000000f,
+		0.000000f,
+		-0.266600f,
+		0.963800f,
+		0.250000f,
+		0.413800f,
+		-0.096261f,
+		-0.080891f,
+		0.483932f,
+		0.000000f,
+		-0.192500f,
+		-0.161200f,
+		0.967900f,
+		0.218700f,
+		0.448300f,
+		-0.093990f,
+		-0.133764f,
+		0.472517f,
+		0.000000f,
+		-0.188000f,
+		-0.266600f,
+		0.945200f,
+		0.218700f,
+		0.413800f,
+		-0.000000f,
+		0.453788f,
+		0.209944f,
+		0.000000f,
+		0.000000f,
+		0.906300f,
+		0.422700f,
+		0.250000f,
+		0.862100f,
+		-0.000000f,
+		0.473826f,
+		0.159650f,
+		0.000000f,
+		0.000000f,
+		0.946600f,
+		0.322300f,
+		0.250000f,
+		0.896600f,
+		-0.031147f,
+		0.473826f,
+		0.156583f,
+		0.000000f,
+		-0.062900f,
+		0.946600f,
+		0.316100f,
+		0.218700f,
+		0.896600f,
+		-0.000000f,
+		0.453788f,
+		0.209944f,
+		0.000000f,
+		0.000000f,
+		0.906300f,
+		0.422700f,
+		0.250000f,
+		0.862100f,
+		-0.031147f,
+		0.473826f,
+		0.156583f,
+		0.000000f,
+		-0.062900f,
+		0.946600f,
+		0.316100f,
+		0.218700f,
+		0.896600f,
+		-0.040959f,
+		0.453788f,
+		0.205910f,
+		0.000000f,
+		-0.082400f,
+		0.906300f,
+		0.414500f,
+		0.218700f,
+		0.862100f,
+		-0.000000f,
+		-0.185069f,
+		0.464487f,
+		0.000000f,
+		0.000000f,
+		-0.369000f,
+		0.929400f,
+		0.250000f,
+		0.379300f,
+		-0.000000f,
+		-0.133764f,
+		0.481775f,
+		0.000000f,
+		0.000000f,
+		-0.266600f,
+		0.963800f,
+		0.250000f,
+		0.413800f,
+		-0.093990f,
+		-0.133764f,
+		0.472517f,
+		0.000000f,
+		-0.188000f,
+		-0.266600f,
+		0.945200f,
+		0.218700f,
+		0.413800f,
+		-0.000000f,
+		-0.185069f,
+		0.464487f,
+		0.000000f,
+		0.000000f,
+		-0.369000f,
+		0.929400f,
+		0.250000f,
+		0.379300f,
+		-0.093990f,
+		-0.133764f,
+		0.472517f,
+		0.000000f,
+		-0.188000f,
+		-0.266600f,
+		0.945200f,
+		0.218700f,
+		0.413800f,
+		-0.090618f,
+		-0.185069f,
+		0.455563f,
+		0.000000f,
+		-0.181300f,
+		-0.369000f,
+		0.911600f,
+		0.218700f,
+		0.379300f,
+		-0.000000f,
+		0.428429f,
+		0.257776f,
+		0.000000f,
+		0.000000f,
+		0.855300f,
+		0.518000f,
+		0.250000f,
+		0.827600f,
+		-0.000000f,
+		0.453788f,
+		0.209944f,
+		0.000000f,
+		0.000000f,
+		0.906300f,
+		0.422700f,
+		0.250000f,
+		0.862100f,
+		-0.040959f,
+		0.453788f,
+		0.205910f,
+		0.000000f,
+		-0.082400f,
+		0.906300f,
+		0.414500f,
+		0.218700f,
+		0.862100f,
+		-0.000000f,
+		0.428429f,
+		0.257776f,
+		0.000000f,
+		0.000000f,
+		0.855300f,
+		0.518000f,
+		0.250000f,
+		0.827600f,
+		-0.040959f,
+		0.453788f,
+		0.205910f,
+		0.000000f,
+		-0.082400f,
+		0.906300f,
+		0.414500f,
+		0.218700f,
+		0.862100f,
+		-0.050290f,
+		0.428429f,
+		0.252823f,
+		0.000000f,
+		-0.101000f,
+		0.855300f,
+		0.508100f,
+		0.218700f,
+		0.827600f,
+		-0.000000f,
+		-0.234204f,
+		0.441756f,
+		0.000000f,
+		0.000000f,
+		-0.467000f,
+		0.884200f,
+		0.250000f,
+		0.344800f,
+		-0.000000f,
+		-0.185069f,
+		0.464487f,
+		0.000000f,
+		0.000000f,
+		-0.369000f,
+		0.929400f,
+		0.250000f,
+		0.379300f,
+		-0.090618f,
+		-0.185069f,
+		0.455563f,
+		0.000000f,
+		-0.181300f,
+		-0.369000f,
+		0.911600f,
+		0.218700f,
+		0.379300f,
+		-0.000000f,
+		-0.234204f,
+		0.441756f,
+		0.000000f,
+		0.000000f,
+		-0.467000f,
+		0.884200f,
+		0.250000f,
+		0.344800f,
+		-0.090618f,
+		-0.185069f,
+		0.455563f,
+		0.000000f,
+		-0.181300f,
+		-0.369000f,
+		0.911600f,
+		0.218700f,
+		0.379300f,
+		-0.086182f,
+		-0.234204f,
+		0.433267f,
+		0.000000f,
+		-0.172500f,
+		-0.467000f,
+		0.867200f,
+		0.218700f,
+		0.344800f,
+		-0.000000f,
+		0.398046f,
+		0.302586f,
+		0.000000f,
+		0.000000f,
+		0.794500f,
+		0.607300f,
+		0.250000f,
+		0.793100f,
+		-0.000000f,
+		0.428429f,
+		0.257776f,
+		0.000000f,
+		0.000000f,
+		0.855300f,
+		0.518000f,
+		0.250000f,
+		0.827600f,
+		-0.050290f,
+		0.428429f,
+		0.252823f,
+		0.000000f,
+		-0.101000f,
+		0.855300f,
+		0.508100f,
+		0.218700f,
+		0.827600f,
+		-0.000000f,
+		0.398046f,
+		0.302586f,
+		0.000000f,
+		0.000000f,
+		0.794500f,
+		0.607300f,
+		0.250000f,
+		0.793100f,
+		-0.050290f,
+		0.428429f,
+		0.252823f,
+		0.000000f,
+		-0.101000f,
+		0.855300f,
+		0.508100f,
+		0.218700f,
+		0.827600f,
+		-0.059032f,
+		0.398046f,
+		0.296773f,
+		0.000000f,
+		-0.118500f,
+		0.794500f,
+		0.595600f,
+		0.218700f,
+		0.793100f,
+		-0.000000f,
+		-0.280594f,
+		0.413844f,
+		0.000000f,
+		0.000000f,
+		-0.559600f,
+		0.828700f,
+		0.250000f,
+		0.310300f,
+		-0.000000f,
+		-0.234204f,
+		0.441756f,
+		0.000000f,
+		0.000000f,
+		-0.467000f,
+		0.884200f,
+		0.250000f,
+		0.344800f,
+		-0.086182f,
+		-0.234204f,
+		0.433267f,
+		0.000000f,
+		-0.172500f,
+		-0.467000f,
+		0.867200f,
+		0.218700f,
+		0.344800f,
+		-0.000000f,
+		-0.280594f,
+		0.413844f,
+		0.000000f,
+		0.000000f,
+		-0.559600f,
+		0.828700f,
+		0.250000f,
+		0.310300f,
+		-0.086182f,
+		-0.234204f,
+		0.433267f,
+		0.000000f,
+		-0.172500f,
+		-0.467000f,
+		0.867200f,
+		0.218700f,
+		0.344800f,
+		-0.080738f,
+		-0.280594f,
+		0.405892f,
+		0.000000f,
+		-0.161700f,
+		-0.559600f,
+		0.812800f,
+		0.218700f,
+		0.310300f,
+		-0.000000f,
+		0.362998f,
+		0.343849f,
+		0.000000f,
+		0.000000f,
+		0.724300f,
+		0.689400f,
+		0.250000f,
+		0.758600f,
+		-0.000000f,
+		0.398046f,
+		0.302586f,
+		0.000000f,
+		0.000000f,
+		0.794500f,
+		0.607300f,
+		0.250000f,
+		0.793100f,
+		-0.059032f,
+		0.398046f,
+		0.296773f,
+		0.000000f,
+		-0.118500f,
+		0.794500f,
+		0.595600f,
+		0.218700f,
+		0.793100f,
+		-0.000000f,
+		0.362998f,
+		0.343849f,
+		0.000000f,
+		0.000000f,
+		0.724300f,
+		0.689400f,
+		0.250000f,
+		0.758600f,
+		-0.059032f,
+		0.398046f,
+		0.296773f,
+		0.000000f,
+		-0.118500f,
+		0.794500f,
+		0.595600f,
+		0.218700f,
+		0.793100f,
+		-0.067082f,
+		0.362998f,
+		0.337242f,
+		0.000000f,
+		-0.134500f,
+		0.724300f,
+		0.676200f,
+		0.218700f,
+		0.758600f,
+		-0.000000f,
+		-0.323693f,
+		0.381081f,
+		0.000000f,
+		0.000000f,
+		-0.645700f,
+		0.763500f,
+		0.250000f,
+		0.275900f,
+		-0.000000f,
+		-0.280594f,
+		0.413844f,
+		0.000000f,
+		0.000000f,
+		-0.559600f,
+		0.828700f,
+		0.250000f,
+		0.310300f,
+		-0.080738f,
+		-0.280594f,
+		0.405892f,
+		0.000000f,
+		-0.161700f,
+		-0.559600f,
+		0.812800f,
+		0.218700f,
+		0.310300f,
+		-0.000000f,
+		-0.323693f,
+		0.381081f,
+		0.000000f,
+		0.000000f,
+		-0.645700f,
+		0.763500f,
+		0.250000f,
+		0.275900f,
+		-0.080738f,
+		-0.280594f,
+		0.405892f,
+		0.000000f,
+		-0.161700f,
+		-0.559600f,
+		0.812800f,
+		0.218700f,
+		0.310300f,
+		-0.074345f,
+		-0.323693f,
+		0.373758f,
+		0.000000f,
+		-0.149000f,
+		-0.645700f,
+		0.748900f,
+		0.218700f,
+		0.275900f,
+		-0.000000f,
+		0.323693f,
+		0.381081f,
+		0.000000f,
+		0.000000f,
+		0.645700f,
+		0.763500f,
+		0.250000f,
+		0.724100f,
+		-0.000000f,
+		0.362998f,
+		0.343849f,
+		0.000000f,
+		0.000000f,
+		0.724300f,
+		0.689400f,
+		0.250000f,
+		0.758600f,
+		-0.067082f,
+		0.362998f,
+		0.337242f,
+		0.000000f,
+		-0.134500f,
+		0.724300f,
+		0.676200f,
+		0.218700f,
+		0.758600f,
+		-0.000000f,
+		0.323693f,
+		0.381081f,
+		0.000000f,
+		0.000000f,
+		0.645700f,
+		0.763500f,
+		0.250000f,
+		0.724100f,
+		-0.067082f,
+		0.362998f,
+		0.337242f,
+		0.000000f,
+		-0.134500f,
+		0.724300f,
+		0.676200f,
+		0.218700f,
+		0.758600f,
+		-0.074345f,
+		0.323693f,
+		0.373758f,
+		0.000000f,
+		-0.149000f,
+		0.645700f,
+		0.748900f,
+		0.218700f,
+		0.724100f,
+		-0.000000f,
+		-0.362998f,
+		0.343849f,
+		0.000000f,
+		0.000000f,
+		-0.724300f,
+		0.689500f,
+		0.250000f,
+		0.241400f,
+		-0.000000f,
+		-0.323693f,
+		0.381081f,
+		0.000000f,
+		0.000000f,
+		-0.645700f,
+		0.763500f,
+		0.250000f,
+		0.275900f,
+		-0.074345f,
+		-0.323693f,
+		0.373758f,
+		0.000000f,
+		-0.149000f,
+		-0.645700f,
+		0.748900f,
+		0.218700f,
+		0.275900f,
+		-0.000000f,
+		-0.362998f,
+		0.343849f,
+		0.000000f,
+		0.000000f,
+		-0.724300f,
+		0.689500f,
+		0.250000f,
+		0.241400f,
+		-0.074345f,
+		-0.323693f,
+		0.373758f,
+		0.000000f,
+		-0.149000f,
+		-0.645700f,
+		0.748900f,
+		0.218700f,
+		0.275900f,
+		-0.067082f,
+		-0.362998f,
+		0.337242f,
+		0.000000f,
+		-0.134500f,
+		-0.724300f,
+		0.676200f,
+		0.218700f,
+		0.241400f,
+		-0.000000f,
+		0.280594f,
+		0.413844f,
+		0.000000f,
+		0.000000f,
+		0.559600f,
+		0.828700f,
+		0.250000f,
+		0.689700f,
+		-0.000000f,
+		0.323693f,
+		0.381081f,
+		0.000000f,
+		0.000000f,
+		0.645700f,
+		0.763500f,
+		0.250000f,
+		0.724100f,
+		-0.074345f,
+		0.323693f,
+		0.373758f,
+		0.000000f,
+		-0.149000f,
+		0.645700f,
+		0.748900f,
+		0.218700f,
+		0.724100f,
+		-0.000000f,
+		0.280594f,
+		0.413844f,
+		0.000000f,
+		0.000000f,
+		0.559600f,
+		0.828700f,
+		0.250000f,
+		0.689700f,
+		-0.074345f,
+		0.323693f,
+		0.373758f,
+		0.000000f,
+		-0.149000f,
+		0.645700f,
+		0.748900f,
+		0.218700f,
+		0.724100f,
+		-0.080738f,
+		0.280594f,
+		0.405892f,
+		0.000000f,
+		-0.161700f,
+		0.559600f,
+		0.812800f,
+		0.218700f,
+		0.689700f,
+		-0.000000f,
+		-0.398046f,
+		0.302586f,
+		0.000000f,
+		0.000000f,
+		-0.794500f,
+		0.607300f,
+		0.250000f,
+		0.206900f,
+		-0.000000f,
+		-0.362998f,
+		0.343849f,
+		0.000000f,
+		0.000000f,
+		-0.724300f,
+		0.689500f,
+		0.250000f,
+		0.241400f,
+		-0.067082f,
+		-0.362998f,
+		0.337242f,
+		0.000000f,
+		-0.134500f,
+		-0.724300f,
+		0.676200f,
+		0.218700f,
+		0.241400f,
+		-0.000000f,
+		-0.398046f,
+		0.302586f,
+		0.000000f,
+		0.000000f,
+		-0.794500f,
+		0.607300f,
+		0.250000f,
+		0.206900f,
+		-0.067082f,
+		-0.362998f,
+		0.337242f,
+		0.000000f,
+		-0.134500f,
+		-0.724300f,
+		0.676200f,
+		0.218700f,
+		0.241400f,
+		-0.059032f,
+		-0.398046f,
+		0.296773f,
+		0.000000f,
+		-0.118500f,
+		-0.794500f,
+		0.595600f,
+		0.218700f,
+		0.206900f,
+		-0.000000f,
+		0.234204f,
+		0.441756f,
+		0.000000f,
+		0.000000f,
+		0.467000f,
+		0.884200f,
+		0.250000f,
+		0.655200f,
+		-0.000000f,
+		0.280594f,
+		0.413844f,
+		0.000000f,
+		0.000000f,
+		0.559600f,
+		0.828700f,
+		0.250000f,
+		0.689700f,
+		-0.080738f,
+		0.280594f,
+		0.405892f,
+		0.000000f,
+		-0.161700f,
+		0.559600f,
+		0.812800f,
+		0.218700f,
+		0.689700f,
+		-0.000000f,
+		0.234204f,
+		0.441756f,
+		0.000000f,
+		0.000000f,
+		0.467000f,
+		0.884200f,
+		0.250000f,
+		0.655200f,
+		-0.080738f,
+		0.280594f,
+		0.405892f,
+		0.000000f,
+		-0.161700f,
+		0.559600f,
+		0.812800f,
+		0.218700f,
+		0.689700f,
+		-0.086182f,
+		0.234204f,
+		0.433267f,
+		0.000000f,
+		-0.172500f,
+		0.467000f,
+		0.867200f,
+		0.218700f,
+		0.655200f,
+		-0.050290f,
+		0.428429f,
+		0.252823f,
+		0.000000f,
+		-0.101000f,
+		0.855300f,
+		0.508100f,
+		0.218700f,
+		0.827600f,
+		-0.040959f,
+		0.453788f,
+		0.205910f,
+		0.000000f,
+		-0.082400f,
+		0.906300f,
+		0.414500f,
+		0.218700f,
+		0.862100f,
+		-0.080343f,
+		0.453788f,
+		0.193963f,
+		0.000000f,
+		-0.161700f,
+		0.906300f,
+		0.390500f,
+		0.187500f,
+		0.862100f,
+		-0.050290f,
+		0.428429f,
+		0.252823f,
+		0.000000f,
+		-0.101000f,
+		0.855300f,
+		0.508100f,
+		0.218700f,
+		0.827600f,
+		-0.080343f,
+		0.453788f,
+		0.193963f,
+		0.000000f,
+		-0.161700f,
+		0.906300f,
+		0.390500f,
+		0.187500f,
+		0.862100f,
+		-0.098647f,
+		0.428429f,
+		0.238154f,
+		0.000000f,
+		-0.198200f,
+		0.855300f,
+		0.478600f,
+		0.187500f,
+		0.827600f,
+		-0.086182f,
+		-0.234204f,
+		0.433267f,
+		0.000000f,
+		-0.172500f,
+		-0.467000f,
+		0.867200f,
+		0.218700f,
+		0.344800f,
+		-0.090618f,
+		-0.185069f,
+		0.455563f,
+		0.000000f,
+		-0.181300f,
+		-0.369000f,
+		0.911600f,
+		0.218700f,
+		0.379300f,
+		-0.177752f,
+		-0.185069f,
+		0.429130f,
+		0.000000f,
+		-0.355700f,
+		-0.369000f,
+		0.858700f,
+		0.187500f,
+		0.379300f,
+		-0.086182f,
+		-0.234204f,
+		0.433267f,
+		0.000000f,
+		-0.172500f,
+		-0.467000f,
+		0.867200f,
+		0.218700f,
+		0.344800f,
+		-0.177752f,
+		-0.185069f,
+		0.429130f,
+		0.000000f,
+		-0.355700f,
+		-0.369000f,
+		0.858700f,
+		0.187500f,
+		0.379300f,
+		-0.169053f,
+		-0.234204f,
+		0.408128f,
+		0.000000f,
+		-0.338400f,
+		-0.467000f,
+		0.816900f,
+		0.187500f,
+		0.344800f,
+		-0.059032f,
+		0.398046f,
+		0.296773f,
+		0.000000f,
+		-0.118500f,
+		0.794500f,
+		0.595600f,
+		0.218700f,
+		0.793100f,
+		-0.050290f,
+		0.428429f,
+		0.252823f,
+		0.000000f,
+		-0.101000f,
+		0.855300f,
+		0.508100f,
+		0.218700f,
+		0.827600f,
+		-0.098647f,
+		0.428429f,
+		0.238154f,
+		0.000000f,
+		-0.198200f,
+		0.855300f,
+		0.478600f,
+		0.187500f,
+		0.827600f,
+		-0.059032f,
+		0.398046f,
+		0.296773f,
+		0.000000f,
+		-0.118500f,
+		0.794500f,
+		0.595600f,
+		0.218700f,
+		0.793100f,
+		-0.098647f,
+		0.428429f,
+		0.238154f,
+		0.000000f,
+		-0.198200f,
+		0.855300f,
+		0.478600f,
+		0.187500f,
+		0.827600f,
+		-0.115796f,
+		0.398046f,
+		0.279554f,
+		0.000000f,
+		-0.232400f,
+		0.794500f,
+		0.561100f,
+		0.187500f,
+		0.793100f,
+		-0.080738f,
+		-0.280594f,
+		0.405892f,
+		0.000000f,
+		-0.161700f,
+		-0.559600f,
+		0.812800f,
+		0.218700f,
+		0.310300f,
+		-0.086182f,
+		-0.234204f,
+		0.433267f,
+		0.000000f,
+		-0.172500f,
+		-0.467000f,
+		0.867200f,
+		0.218700f,
+		0.344800f,
+		-0.169053f,
+		-0.234204f,
+		0.408128f,
+		0.000000f,
+		-0.338400f,
+		-0.467000f,
+		0.816900f,
+		0.187500f,
+		0.344800f,
+		-0.080738f,
+		-0.280594f,
+		0.405892f,
+		0.000000f,
+		-0.161700f,
+		-0.559600f,
+		0.812800f,
+		0.218700f,
+		0.310300f,
+		-0.169053f,
+		-0.234204f,
+		0.408128f,
+		0.000000f,
+		-0.338400f,
+		-0.467000f,
+		0.816900f,
+		0.187500f,
+		0.344800f,
+		-0.158371f,
+		-0.280594f,
+		0.382342f,
+		0.000000f,
+		-0.317100f,
+		-0.559600f,
+		0.765600f,
+		0.187500f,
+		0.310300f,
+		-0.067082f,
+		0.362998f,
+		0.337242f,
+		0.000000f,
+		-0.134500f,
+		0.724300f,
+		0.676200f,
+		0.218700f,
+		0.758600f,
+		-0.059032f,
+		0.398046f,
+		0.296773f,
+		0.000000f,
+		-0.118500f,
+		0.794500f,
+		0.595600f,
+		0.218700f,
+		0.793100f,
+		-0.115796f,
+		0.398046f,
+		0.279554f,
+		0.000000f,
+		-0.232400f,
+		0.794500f,
+		0.561100f,
+		0.187500f,
+		0.793100f,
+		-0.067082f,
+		0.362998f,
+		0.337242f,
+		0.000000f,
+		-0.134500f,
+		0.724300f,
+		0.676200f,
+		0.218700f,
+		0.758600f,
+		-0.115796f,
+		0.398046f,
+		0.279554f,
+		0.000000f,
+		-0.232400f,
+		0.794500f,
+		0.561100f,
+		0.187500f,
+		0.793100f,
+		-0.131586f,
+		0.362998f,
+		0.317675f,
+		0.000000f,
+		-0.263800f,
+		0.724300f,
+		0.637000f,
+		0.187500f,
+		0.758600f,
+		-0.074345f,
+		-0.323693f,
+		0.373758f,
+		0.000000f,
+		-0.149000f,
+		-0.645700f,
+		0.748900f,
+		0.218700f,
+		0.275900f,
+		-0.080738f,
+		-0.280594f,
+		0.405892f,
+		0.000000f,
+		-0.161700f,
+		-0.559600f,
+		0.812800f,
+		0.218700f,
+		0.310300f,
+		-0.158371f,
+		-0.280594f,
+		0.382342f,
+		0.000000f,
+		-0.317100f,
+		-0.559600f,
+		0.765600f,
+		0.187500f,
+		0.310300f,
+		-0.074345f,
+		-0.323693f,
+		0.373758f,
+		0.000000f,
+		-0.149000f,
+		-0.645700f,
+		0.748900f,
+		0.218700f,
+		0.275900f,
+		-0.158371f,
+		-0.280594f,
+		0.382342f,
+		0.000000f,
+		-0.317100f,
+		-0.559600f,
+		0.765600f,
+		0.187500f,
+		0.310300f,
+		-0.145834f,
+		-0.323693f,
+		0.352073f,
+		0.000000f,
+		-0.292200f,
+		-0.645700f,
+		0.705400f,
+		0.187500f,
+		0.275900f,
+		-0.074345f,
+		0.323693f,
+		0.373758f,
+		0.000000f,
+		-0.149000f,
+		0.645700f,
+		0.748900f,
+		0.218700f,
+		0.724100f,
+		-0.067082f,
+		0.362998f,
+		0.337242f,
+		0.000000f,
+		-0.134500f,
+		0.724300f,
+		0.676200f,
+		0.218700f,
+		0.758600f,
+		-0.131586f,
+		0.362998f,
+		0.317675f,
+		0.000000f,
+		-0.263800f,
+		0.724300f,
+		0.637000f,
+		0.187500f,
+		0.758600f,
+		-0.074345f,
+		0.323693f,
+		0.373758f,
+		0.000000f,
+		-0.149000f,
+		0.645700f,
+		0.748900f,
+		0.218700f,
+		0.724100f,
+		-0.131586f,
+		0.362998f,
+		0.317675f,
+		0.000000f,
+		-0.263800f,
+		0.724300f,
+		0.637000f,
+		0.187500f,
+		0.758600f,
+		-0.145834f,
+		0.323693f,
+		0.352073f,
+		0.000000f,
+		-0.292200f,
+		0.645700f,
+		0.705400f,
+		0.187500f,
+		0.724100f,
+		-0.067082f,
+		-0.362998f,
+		0.337242f,
+		0.000000f,
+		-0.134500f,
+		-0.724300f,
+		0.676200f,
+		0.218700f,
+		0.241400f,
+		-0.074345f,
+		-0.323693f,
+		0.373758f,
+		0.000000f,
+		-0.149000f,
+		-0.645700f,
+		0.748900f,
+		0.218700f,
+		0.275900f,
+		-0.145834f,
+		-0.323693f,
+		0.352073f,
+		0.000000f,
+		-0.292200f,
+		-0.645700f,
+		0.705400f,
+		0.187500f,
+		0.275900f,
+		-0.067082f,
+		-0.362998f,
+		0.337242f,
+		0.000000f,
+		-0.134500f,
+		-0.724300f,
+		0.676200f,
+		0.218700f,
+		0.241400f,
+		-0.145834f,
+		-0.323693f,
+		0.352073f,
+		0.000000f,
+		-0.292200f,
+		-0.645700f,
+		0.705400f,
+		0.187500f,
+		0.275900f,
+		-0.131586f,
+		-0.362998f,
+		0.317675f,
+		0.000000f,
+		-0.263800f,
+		-0.724300f,
+		0.637000f,
+		0.187500f,
+		0.241400f,
+		-0.080738f,
+		0.280594f,
+		0.405892f,
+		0.000000f,
+		-0.161700f,
+		0.559600f,
+		0.812800f,
+		0.218700f,
+		0.689700f,
+		-0.074345f,
+		0.323693f,
+		0.373758f,
+		0.000000f,
+		-0.149000f,
+		0.645700f,
+		0.748900f,
+		0.218700f,
+		0.724100f,
+		-0.145834f,
+		0.323693f,
+		0.352073f,
+		0.000000f,
+		-0.292200f,
+		0.645700f,
+		0.705400f,
+		0.187500f,
+		0.724100f,
+		-0.080738f,
+		0.280594f,
+		0.405892f,
+		0.000000f,
+		-0.161700f,
+		0.559600f,
+		0.812800f,
+		0.218700f,
+		0.689700f,
+		-0.145834f,
+		0.323693f,
+		0.352073f,
+		0.000000f,
+		-0.292200f,
+		0.645700f,
+		0.705400f,
+		0.187500f,
+		0.724100f,
+		-0.158371f,
+		0.280594f,
+		0.382342f,
+		0.000000f,
+		-0.317100f,
+		0.559600f,
+		0.765600f,
+		0.187500f,
+		0.689700f,
+		-0.059032f,
+		-0.398046f,
+		0.296773f,
+		0.000000f,
+		-0.118500f,
+		-0.794500f,
+		0.595600f,
+		0.218700f,
+		0.206900f,
+		-0.067082f,
+		-0.362998f,
+		0.337242f,
+		0.000000f,
+		-0.134500f,
+		-0.724300f,
+		0.676200f,
+		0.218700f,
+		0.241400f,
+		-0.131586f,
+		-0.362998f,
+		0.317675f,
+		0.000000f,
+		-0.263800f,
+		-0.724300f,
+		0.637000f,
+		0.187500f,
+		0.241400f,
+		-0.059032f,
+		-0.398046f,
+		0.296773f,
+		0.000000f,
+		-0.118500f,
+		-0.794500f,
+		0.595600f,
+		0.218700f,
+		0.206900f,
+		-0.131586f,
+		-0.362998f,
+		0.317675f,
+		0.000000f,
+		-0.263800f,
+		-0.724300f,
+		0.637000f,
+		0.187500f,
+		0.241400f,
+		-0.115796f,
+		-0.398046f,
+		0.279554f,
+		0.000000f,
+		-0.232400f,
+		-0.794500f,
+		0.561100f,
+		0.187500f,
+		0.206900f,
+		-0.086182f,
+		0.234204f,
+		0.433267f,
+		0.000000f,
+		-0.172500f,
+		0.467000f,
+		0.867200f,
+		0.218700f,
+		0.655200f,
+		-0.080738f,
+		0.280594f,
+		0.405892f,
+		0.000000f,
+		-0.161700f,
+		0.559600f,
+		0.812800f,
+		0.218700f,
+		0.689700f,
+		-0.158371f,
+		0.280594f,
+		0.382342f,
+		0.000000f,
+		-0.317100f,
+		0.559600f,
+		0.765600f,
+		0.187500f,
+		0.689700f,
+		-0.086182f,
+		0.234204f,
+		0.433267f,
+		0.000000f,
+		-0.172500f,
+		0.467000f,
+		0.867200f,
+		0.218700f,
+		0.655200f,
+		-0.158371f,
+		0.280594f,
+		0.382342f,
+		0.000000f,
+		-0.317100f,
+		0.559600f,
+		0.765600f,
+		0.187500f,
+		0.689700f,
+		-0.169053f,
+		0.234204f,
+		0.408128f,
+		0.000000f,
+		-0.338400f,
+		0.467000f,
+		0.816900f,
+		0.187500f,
+		0.655200f,
+		-0.050290f,
+		-0.428429f,
+		0.252824f,
+		0.000000f,
+		-0.101000f,
+		-0.855300f,
+		0.508100f,
+		0.218700f,
+		0.172400f,
+		-0.059032f,
+		-0.398046f,
+		0.296773f,
+		0.000000f,
+		-0.118500f,
+		-0.794500f,
+		0.595600f,
+		0.218700f,
+		0.206900f,
+		-0.115796f,
+		-0.398046f,
+		0.279554f,
+		0.000000f,
+		-0.232400f,
+		-0.794500f,
+		0.561100f,
+		0.187500f,
+		0.206900f,
+		-0.050290f,
+		-0.428429f,
+		0.252824f,
+		0.000000f,
+		-0.101000f,
+		-0.855300f,
+		0.508100f,
+		0.218700f,
+		0.172400f,
+		-0.115796f,
+		-0.398046f,
+		0.279554f,
+		0.000000f,
+		-0.232400f,
+		-0.794500f,
+		0.561100f,
+		0.187500f,
+		0.206900f,
+		-0.098647f,
+		-0.428429f,
+		0.238155f,
+		0.000000f,
+		-0.198200f,
+		-0.855300f,
+		0.478600f,
+		0.187500f,
+		0.172400f,
+		-0.090618f,
+		0.185069f,
+		0.455563f,
+		0.000000f,
+		-0.181300f,
+		0.369000f,
+		0.911600f,
+		0.218700f,
+		0.620700f,
+		-0.086182f,
+		0.234204f,
+		0.433267f,
+		0.000000f,
+		-0.172500f,
+		0.467000f,
+		0.867200f,
+		0.218700f,
+		0.655200f,
+		-0.169053f,
+		0.234204f,
+		0.408128f,
+		0.000000f,
+		-0.338400f,
+		0.467000f,
+		0.816900f,
+		0.187500f,
+		0.655200f,
+		-0.090618f,
+		0.185069f,
+		0.455563f,
+		0.000000f,
+		-0.181300f,
+		0.369000f,
+		0.911600f,
+		0.218700f,
+		0.620700f,
+		-0.169053f,
+		0.234204f,
+		0.408128f,
+		0.000000f,
+		-0.338400f,
+		0.467000f,
+		0.816900f,
+		0.187500f,
+		0.655200f,
+		-0.177752f,
+		0.185069f,
+		0.429130f,
+		0.000000f,
+		-0.355700f,
+		0.369000f,
+		0.858700f,
+		0.187500f,
+		0.620700f,
+		-0.040959f,
+		-0.453788f,
+		0.205910f,
+		0.000000f,
+		-0.082400f,
+		-0.906300f,
+		0.414500f,
+		0.218700f,
+		0.137900f,
+		-0.050290f,
+		-0.428429f,
+		0.252824f,
+		0.000000f,
+		-0.101000f,
+		-0.855300f,
+		0.508100f,
+		0.218700f,
+		0.172400f,
+		-0.098647f,
+		-0.428429f,
+		0.238155f,
+		0.000000f,
+		-0.198200f,
+		-0.855300f,
+		0.478600f,
+		0.187500f,
+		0.172400f,
+		-0.040959f,
+		-0.453788f,
+		0.205910f,
+		0.000000f,
+		-0.082400f,
+		-0.906300f,
+		0.414500f,
+		0.218700f,
+		0.137900f,
+		-0.098647f,
+		-0.428429f,
+		0.238155f,
+		0.000000f,
+		-0.198200f,
+		-0.855300f,
+		0.478600f,
+		0.187500f,
+		0.172400f,
+		-0.080343f,
+		-0.453788f,
+		0.193963f,
+		0.000000f,
+		-0.161700f,
+		-0.906300f,
+		0.390500f,
+		0.187500f,
+		0.137900f,
+		-0.093990f,
+		0.133764f,
+		0.472517f,
+		0.000000f,
+		-0.188000f,
+		0.266600f,
+		0.945200f,
+		0.218700f,
+		0.586200f,
+		-0.090618f,
+		0.185069f,
+		0.455563f,
+		0.000000f,
+		-0.181300f,
+		0.369000f,
+		0.911600f,
+		0.218700f,
+		0.620700f,
+		-0.177752f,
+		0.185069f,
+		0.429130f,
+		0.000000f,
+		-0.355700f,
+		0.369000f,
+		0.858700f,
+		0.187500f,
+		0.620700f,
+		-0.093990f,
+		0.133764f,
+		0.472517f,
+		0.000000f,
+		-0.188000f,
+		0.266600f,
+		0.945200f,
+		0.218700f,
+		0.586200f,
+		-0.177752f,
+		0.185069f,
+		0.429130f,
+		0.000000f,
+		-0.355700f,
+		0.369000f,
+		0.858700f,
+		0.187500f,
+		0.620700f,
+		-0.184367f,
+		0.133764f,
+		0.445101f,
+		0.000000f,
+		-0.368800f,
+		0.266600f,
+		0.890400f,
+		0.187500f,
+		0.586200f,
+		-0.031147f,
+		-0.473826f,
+		0.156583f,
+		0.000000f,
+		-0.062900f,
+		-0.946600f,
+		0.316100f,
+		0.218700f,
+		0.103400f,
+		-0.040959f,
+		-0.453788f,
+		0.205910f,
+		0.000000f,
+		-0.082400f,
+		-0.906300f,
+		0.414500f,
+		0.218700f,
+		0.137900f,
+		-0.080343f,
+		-0.453788f,
+		0.193963f,
+		0.000000f,
+		-0.161700f,
+		-0.906300f,
+		0.390500f,
+		0.187500f,
+		0.137900f,
+		-0.031147f,
+		-0.473826f,
+		0.156583f,
+		0.000000f,
+		-0.062900f,
+		-0.946600f,
+		0.316100f,
+		0.218700f,
+		0.103400f,
+		-0.080343f,
+		-0.453788f,
+		0.193963f,
+		0.000000f,
+		-0.161700f,
+		-0.906300f,
+		0.390500f,
+		0.187500f,
+		0.137900f,
+		-0.061096f,
+		-0.473826f,
+		0.147498f,
+		0.000000f,
+		-0.123300f,
+		-0.946600f,
+		0.297800f,
+		0.187500f,
+		0.103400f,
+		-0.096261f,
+		0.080891f,
+		0.483932f,
+		0.000000f,
+		-0.192500f,
+		0.161200f,
+		0.967900f,
+		0.218700f,
+		0.551700f,
+		-0.093990f,
+		0.133764f,
+		0.472517f,
+		0.000000f,
+		-0.188000f,
+		0.266600f,
+		0.945200f,
+		0.218700f,
+		0.586200f,
+		-0.184367f,
+		0.133764f,
+		0.445101f,
+		0.000000f,
+		-0.368800f,
+		0.266600f,
+		0.890400f,
+		0.187500f,
+		0.586200f,
+		-0.096261f,
+		0.080891f,
+		0.483932f,
+		0.000000f,
+		-0.192500f,
+		0.161200f,
+		0.967900f,
+		0.218700f,
+		0.551700f,
+		-0.184367f,
+		0.133764f,
+		0.445101f,
+		0.000000f,
+		-0.368800f,
+		0.266600f,
+		0.890400f,
+		0.187500f,
+		0.586200f,
+		-0.188821f,
+		0.080891f,
+		0.455853f,
+		0.000000f,
+		-0.377700f,
+		0.161200f,
+		0.911800f,
+		0.187500f,
+		0.551700f,
+		-0.020970f,
+		-0.488310f,
+		0.105420f,
+		0.000000f,
+		-0.042500f,
+		-0.975900f,
+		0.214000f,
+		0.218700f,
+		0.069000f,
+		-0.031147f,
+		-0.473826f,
+		0.156583f,
+		0.000000f,
+		-0.062900f,
+		-0.946600f,
+		0.316100f,
+		0.218700f,
+		0.103400f,
+		-0.061096f,
+		-0.473826f,
+		0.147498f,
+		0.000000f,
+		-0.123300f,
+		-0.946600f,
+		0.297800f,
+		0.187500f,
+		0.103400f,
+		-0.020970f,
+		-0.488310f,
+		0.105420f,
+		0.000000f,
+		-0.042500f,
+		-0.975900f,
+		0.214000f,
+		0.218700f,
+		0.069000f,
+		-0.061096f,
+		-0.473826f,
+		0.147498f,
+		0.000000f,
+		-0.123300f,
+		-0.946600f,
+		0.297800f,
+		0.187500f,
+		0.103400f,
+		-0.041133f,
+		-0.488310f,
+		0.099303f,
+		0.000000f,
+		-0.083500f,
+		-0.975900f,
+		0.201600f,
+		0.187500f,
+		0.069000f,
+		-0.097402f,
+		0.027069f,
+		0.489673f,
+		0.000000f,
+		-0.194800f,
+		0.054000f,
+		0.979300f,
+		0.218700f,
+		0.517200f,
+		-0.096261f,
+		0.080891f,
+		0.483932f,
+		0.000000f,
+		-0.192500f,
+		0.161200f,
+		0.967900f,
+		0.218700f,
+		0.551700f,
+		-0.188821f,
+		0.080891f,
+		0.455853f,
+		0.000000f,
+		-0.377700f,
+		0.161200f,
+		0.911800f,
+		0.187500f,
+		0.551700f,
+		-0.097402f,
+		0.027069f,
+		0.489673f,
+		0.000000f,
+		-0.194800f,
+		0.054000f,
+		0.979300f,
+		0.218700f,
+		0.517200f,
+		-0.188821f,
+		0.080891f,
+		0.455853f,
+		0.000000f,
+		-0.377700f,
+		0.161200f,
+		0.911800f,
+		0.187500f,
+		0.551700f,
+		-0.191061f,
+		0.027069f,
+		0.461262f,
+		0.000000f,
+		-0.382100f,
+		0.054000f,
+		0.922500f,
+		0.187500f,
+		0.517200f,
+		-0.010547f,
+		0.497069f,
+		0.053020f,
+		0.000000f,
+		-0.021700f,
+		0.993700f,
+		0.109300f,
+		0.472600f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.482000f,
+		0.960300f,
+		-0.020688f,
+		0.497069f,
+		0.049944f,
+		0.000000f,
+		-0.042600f,
+		0.993700f,
+		0.103000f,
+		0.474400f,
+		0.962300f,
+		-0.010547f,
+		-0.497069f,
+		0.053020f,
+		0.000000f,
+		-0.021700f,
+		-0.993700f,
+		0.109300f,
+		0.218700f,
+		0.034500f,
+		-0.020970f,
+		-0.488310f,
+		0.105420f,
+		0.000000f,
+		-0.042500f,
+		-0.975900f,
+		0.214000f,
+		0.218700f,
+		0.069000f,
+		-0.041133f,
+		-0.488310f,
+		0.099303f,
+		0.000000f,
+		-0.083500f,
+		-0.975900f,
+		0.201600f,
+		0.187500f,
+		0.069000f,
+		-0.010547f,
+		-0.497069f,
+		0.053020f,
+		0.000000f,
+		-0.021700f,
+		-0.993700f,
+		0.109300f,
+		0.218700f,
+		0.034500f,
+		-0.041133f,
+		-0.488310f,
+		0.099303f,
+		0.000000f,
+		-0.083500f,
+		-0.975900f,
+		0.201600f,
+		0.187500f,
+		0.069000f,
+		-0.020688f,
+		-0.497069f,
+		0.049945f,
+		0.000000f,
+		-0.042600f,
+		-0.993700f,
+		0.103000f,
+		0.187500f,
+		0.034500f,
+		-0.097402f,
+		-0.027069f,
+		0.489673f,
+		0.000000f,
+		-0.194800f,
+		-0.054000f,
+		0.979300f,
+		0.218700f,
+		0.482800f,
+		-0.097402f,
+		0.027069f,
+		0.489673f,
+		0.000000f,
+		-0.194800f,
+		0.054000f,
+		0.979300f,
+		0.218700f,
+		0.517200f,
+		-0.191061f,
+		0.027069f,
+		0.461262f,
+		0.000000f,
+		-0.382100f,
+		0.054000f,
+		0.922500f,
+		0.187500f,
+		0.517200f,
+		-0.097402f,
+		-0.027069f,
+		0.489673f,
+		0.000000f,
+		-0.194800f,
+		-0.054000f,
+		0.979300f,
+		0.218700f,
+		0.482800f,
+		-0.191061f,
+		0.027069f,
+		0.461262f,
+		0.000000f,
+		-0.382100f,
+		0.054000f,
+		0.922500f,
+		0.187500f,
+		0.517200f,
+		-0.191061f,
+		-0.027069f,
+		0.461262f,
+		0.000000f,
+		-0.382100f,
+		-0.054000f,
+		0.922500f,
+		0.187500f,
+		0.482800f,
+		-0.020970f,
+		0.488310f,
+		0.105420f,
+		0.000000f,
+		-0.042500f,
+		0.975900f,
+		0.214000f,
+		0.218700f,
+		0.931000f,
+		-0.010547f,
+		0.497069f,
+		0.053020f,
+		0.000000f,
+		-0.021700f,
+		0.993700f,
+		0.109300f,
+		0.218700f,
+		0.965500f,
+		-0.020688f,
+		0.497069f,
+		0.049944f,
+		0.000000f,
+		-0.042600f,
+		0.993700f,
+		0.103000f,
+		0.187500f,
+		0.965500f,
+		-0.020970f,
+		0.488310f,
+		0.105420f,
+		0.000000f,
+		-0.042500f,
+		0.975900f,
+		0.214000f,
+		0.218700f,
+		0.931000f,
+		-0.020688f,
+		0.497069f,
+		0.049944f,
+		0.000000f,
+		-0.042600f,
+		0.993700f,
+		0.103000f,
+		0.187500f,
+		0.965500f,
+		-0.041133f,
+		0.488310f,
+		0.099303f,
+		0.000000f,
+		-0.083500f,
+		0.975900f,
+		0.201600f,
+		0.187500f,
+		0.931000f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.411700f,
+		0.051000f,
+		-0.010547f,
+		-0.497069f,
+		0.053020f,
+		0.000000f,
+		-0.021700f,
+		-0.993700f,
+		0.109300f,
+		0.428700f,
+		0.053800f,
+		-0.020688f,
+		-0.497069f,
+		0.049945f,
+		0.000000f,
+		-0.042600f,
+		-0.993700f,
+		0.103000f,
+		0.426100f,
+		0.053800f,
+		-0.096261f,
+		-0.080891f,
+		0.483932f,
+		0.000000f,
+		-0.192500f,
+		-0.161200f,
+		0.967900f,
+		0.218700f,
+		0.448300f,
+		-0.097402f,
+		-0.027069f,
+		0.489673f,
+		0.000000f,
+		-0.194800f,
+		-0.054000f,
+		0.979300f,
+		0.218700f,
+		0.482800f,
+		-0.191061f,
+		-0.027069f,
+		0.461262f,
+		0.000000f,
+		-0.382100f,
+		-0.054000f,
+		0.922500f,
+		0.187500f,
+		0.482800f,
+		-0.096261f,
+		-0.080891f,
+		0.483932f,
+		0.000000f,
+		-0.192500f,
+		-0.161200f,
+		0.967900f,
+		0.218700f,
+		0.448300f,
+		-0.191061f,
+		-0.027069f,
+		0.461262f,
+		0.000000f,
+		-0.382100f,
+		-0.054000f,
+		0.922500f,
+		0.187500f,
+		0.482800f,
+		-0.188821f,
+		-0.080891f,
+		0.455853f,
+		0.000000f,
+		-0.377700f,
+		-0.161200f,
+		0.911800f,
+		0.187500f,
+		0.448300f,
+		-0.031147f,
+		0.473826f,
+		0.156583f,
+		0.000000f,
+		-0.062900f,
+		0.946600f,
+		0.316100f,
+		0.218700f,
+		0.896600f,
+		-0.020970f,
+		0.488310f,
+		0.105420f,
+		0.000000f,
+		-0.042500f,
+		0.975900f,
+		0.214000f,
+		0.218700f,
+		0.931000f,
+		-0.041133f,
+		0.488310f,
+		0.099303f,
+		0.000000f,
+		-0.083500f,
+		0.975900f,
+		0.201600f,
+		0.187500f,
+		0.931000f,
+		-0.031147f,
+		0.473826f,
+		0.156583f,
+		0.000000f,
+		-0.062900f,
+		0.946600f,
+		0.316100f,
+		0.218700f,
+		0.896600f,
+		-0.041133f,
+		0.488310f,
+		0.099303f,
+		0.000000f,
+		-0.083500f,
+		0.975900f,
+		0.201600f,
+		0.187500f,
+		0.931000f,
+		-0.061096f,
+		0.473826f,
+		0.147498f,
+		0.000000f,
+		-0.123300f,
+		0.946600f,
+		0.297800f,
+		0.187500f,
+		0.896600f,
+		-0.093990f,
+		-0.133764f,
+		0.472517f,
+		0.000000f,
+		-0.188000f,
+		-0.266600f,
+		0.945200f,
+		0.218700f,
+		0.413800f,
+		-0.096261f,
+		-0.080891f,
+		0.483932f,
+		0.000000f,
+		-0.192500f,
+		-0.161200f,
+		0.967900f,
+		0.218700f,
+		0.448300f,
+		-0.188821f,
+		-0.080891f,
+		0.455853f,
+		0.000000f,
+		-0.377700f,
+		-0.161200f,
+		0.911800f,
+		0.187500f,
+		0.448300f,
+		-0.093990f,
+		-0.133764f,
+		0.472517f,
+		0.000000f,
+		-0.188000f,
+		-0.266600f,
+		0.945200f,
+		0.218700f,
+		0.413800f,
+		-0.188821f,
+		-0.080891f,
+		0.455853f,
+		0.000000f,
+		-0.377700f,
+		-0.161200f,
+		0.911800f,
+		0.187500f,
+		0.448300f,
+		-0.184367f,
+		-0.133764f,
+		0.445101f,
+		0.000000f,
+		-0.368800f,
+		-0.266600f,
+		0.890400f,
+		0.187500f,
+		0.413800f,
+		-0.040959f,
+		0.453788f,
+		0.205910f,
+		0.000000f,
+		-0.082400f,
+		0.906300f,
+		0.414500f,
+		0.218700f,
+		0.862100f,
+		-0.031147f,
+		0.473826f,
+		0.156583f,
+		0.000000f,
+		-0.062900f,
+		0.946600f,
+		0.316100f,
+		0.218700f,
+		0.896600f,
+		-0.061096f,
+		0.473826f,
+		0.147498f,
+		0.000000f,
+		-0.123300f,
+		0.946600f,
+		0.297800f,
+		0.187500f,
+		0.896600f,
+		-0.040959f,
+		0.453788f,
+		0.205910f,
+		0.000000f,
+		-0.082400f,
+		0.906300f,
+		0.414500f,
+		0.218700f,
+		0.862100f,
+		-0.061096f,
+		0.473826f,
+		0.147498f,
+		0.000000f,
+		-0.123300f,
+		0.946600f,
+		0.297800f,
+		0.187500f,
+		0.896600f,
+		-0.080343f,
+		0.453788f,
+		0.193963f,
+		0.000000f,
+		-0.161700f,
+		0.906300f,
+		0.390500f,
+		0.187500f,
+		0.862100f,
+		-0.090618f,
+		-0.185069f,
+		0.455563f,
+		0.000000f,
+		-0.181300f,
+		-0.369000f,
+		0.911600f,
+		0.218700f,
+		0.379300f,
+		-0.093990f,
+		-0.133764f,
+		0.472517f,
+		0.000000f,
+		-0.188000f,
+		-0.266600f,
+		0.945200f,
+		0.218700f,
+		0.413800f,
+		-0.184367f,
+		-0.133764f,
+		0.445101f,
+		0.000000f,
+		-0.368800f,
+		-0.266600f,
+		0.890400f,
+		0.187500f,
+		0.413800f,
+		-0.090618f,
+		-0.185069f,
+		0.455563f,
+		0.000000f,
+		-0.181300f,
+		-0.369000f,
+		0.911600f,
+		0.218700f,
+		0.379300f,
+		-0.184367f,
+		-0.133764f,
+		0.445101f,
+		0.000000f,
+		-0.368800f,
+		-0.266600f,
+		0.890400f,
+		0.187500f,
+		0.413800f,
+		-0.177752f,
+		-0.185069f,
+		0.429130f,
+		0.000000f,
+		-0.355700f,
+		-0.369000f,
+		0.858700f,
+		0.187500f,
+		0.379300f,
+		-0.188821f,
+		0.080891f,
+		0.455853f,
+		0.000000f,
+		-0.377700f,
+		0.161200f,
+		0.911800f,
+		0.187500f,
+		0.551700f,
+		-0.184367f,
+		0.133764f,
+		0.445101f,
+		0.000000f,
+		-0.368800f,
+		0.266600f,
+		0.890400f,
+		0.187500f,
+		0.586200f,
+		-0.267660f,
+		0.133764f,
+		0.400580f,
+		0.000000f,
+		-0.535400f,
+		0.266600f,
+		0.801400f,
+		0.156200f,
+		0.586200f,
+		-0.188821f,
+		0.080891f,
+		0.455853f,
+		0.000000f,
+		-0.377700f,
+		0.161200f,
+		0.911800f,
+		0.187500f,
+		0.551700f,
+		-0.267660f,
+		0.133764f,
+		0.400580f,
+		0.000000f,
+		-0.535400f,
+		0.266600f,
+		0.801400f,
+		0.156200f,
+		0.586200f,
+		-0.274125f,
+		0.080891f,
+		0.410257f,
+		0.000000f,
+		-0.548300f,
+		0.161200f,
+		0.820600f,
+		0.156200f,
+		0.551700f,
+		-0.041133f,
+		-0.488310f,
+		0.099303f,
+		0.000000f,
+		-0.083500f,
+		-0.975900f,
+		0.201600f,
+		0.187500f,
+		0.069000f,
+		-0.061096f,
+		-0.473826f,
+		0.147498f,
+		0.000000f,
+		-0.123300f,
+		-0.946600f,
+		0.297800f,
+		0.187500f,
+		0.103400f,
+		-0.088698f,
+		-0.473826f,
+		0.132745f,
+		0.000000f,
+		-0.179100f,
+		-0.946600f,
+		0.268000f,
+		0.156200f,
+		0.103400f,
+		-0.041133f,
+		-0.488310f,
+		0.099303f,
+		0.000000f,
+		-0.083500f,
+		-0.975900f,
+		0.201600f,
+		0.187500f,
+		0.069000f,
+		-0.088698f,
+		-0.473826f,
+		0.132745f,
+		0.000000f,
+		-0.179100f,
+		-0.946600f,
+		0.268000f,
+		0.156200f,
+		0.103400f,
+		-0.059716f,
+		-0.488310f,
+		0.089370f,
+		0.000000f,
+		-0.121200f,
+		-0.975900f,
+		0.181400f,
+		0.156200f,
+		0.069000f,
+		-0.191061f,
+		0.027069f,
+		0.461262f,
+		0.000000f,
+		-0.382100f,
+		0.054000f,
+		0.922500f,
+		0.187500f,
+		0.517200f,
+		-0.188821f,
+		0.080891f,
+		0.455853f,
+		0.000000f,
+		-0.377700f,
+		0.161200f,
+		0.911800f,
+		0.187500f,
+		0.551700f,
+		-0.274125f,
+		0.080891f,
+		0.410257f,
+		0.000000f,
+		-0.548300f,
+		0.161200f,
+		0.820600f,
+		0.156200f,
+		0.551700f,
+		-0.191061f,
+		0.027069f,
+		0.461262f,
+		0.000000f,
+		-0.382100f,
+		0.054000f,
+		0.922500f,
+		0.187500f,
+		0.517200f,
+		-0.274125f,
+		0.080891f,
+		0.410257f,
+		0.000000f,
+		-0.548300f,
+		0.161200f,
+		0.820600f,
+		0.156200f,
+		0.551700f,
+		-0.277378f,
+		0.027069f,
+		0.415125f,
+		0.000000f,
+		-0.554700f,
+		0.054000f,
+		0.830300f,
+		0.156200f,
+		0.517200f,
+		-0.020688f,
+		0.497069f,
+		0.049944f,
+		0.000000f,
+		-0.042600f,
+		0.993700f,
+		0.103000f,
+		0.474400f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.482000f,
+		0.960300f,
+		-0.030034f,
+		0.497069f,
+		0.044948f,
+		0.000000f,
+		-0.061900f,
+		0.993700f,
+		0.092700f,
+		0.476200f,
+		0.962300f,
+		-0.020688f,
+		-0.497069f,
+		0.049945f,
+		0.000000f,
+		-0.042600f,
+		-0.993700f,
+		0.103000f,
+		0.187500f,
+		0.034500f,
+		-0.041133f,
+		-0.488310f,
+		0.099303f,
+		0.000000f,
+		-0.083500f,
+		-0.975900f,
+		0.201600f,
+		0.187500f,
+		0.069000f,
+		-0.059716f,
+		-0.488310f,
+		0.089370f,
+		0.000000f,
+		-0.121200f,
+		-0.975900f,
+		0.181400f,
+		0.156200f,
+		0.069000f,
+		-0.020688f,
+		-0.497069f,
+		0.049945f,
+		0.000000f,
+		-0.042600f,
+		-0.993700f,
+		0.103000f,
+		0.187500f,
+		0.034500f,
+		-0.059716f,
+		-0.488310f,
+		0.089370f,
+		0.000000f,
+		-0.121200f,
+		-0.975900f,
+		0.181400f,
+		0.156200f,
+		0.069000f,
+		-0.030034f,
+		-0.497069f,
+		0.044949f,
+		0.000000f,
+		-0.061900f,
+		-0.993700f,
+		0.092700f,
+		0.156200f,
+		0.034500f,
+		-0.191061f,
+		-0.027069f,
+		0.461262f,
+		0.000000f,
+		-0.382100f,
+		-0.054000f,
+		0.922500f,
+		0.187500f,
+		0.482800f,
+		-0.191061f,
+		0.027069f,
+		0.461262f,
+		0.000000f,
+		-0.382100f,
+		0.054000f,
+		0.922500f,
+		0.187500f,
+		0.517200f,
+		-0.277378f,
+		0.027069f,
+		0.415125f,
+		0.000000f,
+		-0.554700f,
+		0.054000f,
+		0.830300f,
+		0.156200f,
+		0.517200f,
+		-0.191061f,
+		-0.027069f,
+		0.461262f,
+		0.000000f,
+		-0.382100f,
+		-0.054000f,
+		0.922500f,
+		0.187500f,
+		0.482800f,
+		-0.277378f,
+		0.027069f,
+		0.415125f,
+		0.000000f,
+		-0.554700f,
+		0.054000f,
+		0.830300f,
+		0.156200f,
+		0.517200f,
+		-0.277378f,
+		-0.027069f,
+		0.415125f,
+		0.000000f,
+		-0.554700f,
+		-0.054000f,
+		0.830300f,
+		0.156200f,
+		0.482800f,
+		-0.041133f,
+		0.488310f,
+		0.099303f,
+		0.000000f,
+		-0.083500f,
+		0.975900f,
+		0.201600f,
+		0.187500f,
+		0.931000f,
+		-0.020688f,
+		0.497069f,
+		0.049944f,
+		0.000000f,
+		-0.042600f,
+		0.993700f,
+		0.103000f,
+		0.187500f,
+		0.965500f,
+		-0.030034f,
+		0.497069f,
+		0.044948f,
+		0.000000f,
+		-0.061900f,
+		0.993700f,
+		0.092700f,
+		0.156200f,
+		0.965500f,
+		-0.041133f,
+		0.488310f,
+		0.099303f,
+		0.000000f,
+		-0.083500f,
+		0.975900f,
+		0.201600f,
+		0.187500f,
+		0.931000f,
+		-0.030034f,
+		0.497069f,
+		0.044948f,
+		0.000000f,
+		-0.061900f,
+		0.993700f,
+		0.092700f,
+		0.156200f,
+		0.965500f,
+		-0.059716f,
+		0.488310f,
+		0.089370f,
+		0.000000f,
+		-0.121200f,
+		0.975900f,
+		0.181400f,
+		0.156200f,
+		0.931000f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.411700f,
+		0.051000f,
+		-0.020688f,
+		-0.497069f,
+		0.049945f,
+		0.000000f,
+		-0.042600f,
+		-0.993700f,
+		0.103000f,
+		0.426100f,
+		0.053800f,
+		-0.030034f,
+		-0.497069f,
+		0.044949f,
+		0.000000f,
+		-0.061900f,
+		-0.993700f,
+		0.092700f,
+		0.423500f,
+		0.053800f,
+		-0.188821f,
+		-0.080891f,
+		0.455853f,
+		0.000000f,
+		-0.377700f,
+		-0.161200f,
+		0.911800f,
+		0.187500f,
+		0.448300f,
+		-0.191061f,
+		-0.027069f,
+		0.461262f,
+		0.000000f,
+		-0.382100f,
+		-0.054000f,
+		0.922500f,
+		0.187500f,
+		0.482800f,
+		-0.277378f,
+		-0.027069f,
+		0.415125f,
+		0.000000f,
+		-0.554700f,
+		-0.054000f,
+		0.830300f,
+		0.156200f,
+		0.482800f,
+		-0.188821f,
+		-0.080891f,
+		0.455853f,
+		0.000000f,
+		-0.377700f,
+		-0.161200f,
+		0.911800f,
+		0.187500f,
+		0.448300f,
+		-0.277378f,
+		-0.027069f,
+		0.415125f,
+		0.000000f,
+		-0.554700f,
+		-0.054000f,
+		0.830300f,
+		0.156200f,
+		0.482800f,
+		-0.274125f,
+		-0.080891f,
+		0.410257f,
+		0.000000f,
+		-0.548300f,
+		-0.161200f,
+		0.820600f,
+		0.156200f,
+		0.448300f,
+		-0.061096f,
+		0.473826f,
+		0.147498f,
+		0.000000f,
+		-0.123300f,
+		0.946600f,
+		0.297800f,
+		0.187500f,
+		0.896600f,
+		-0.041133f,
+		0.488310f,
+		0.099303f,
+		0.000000f,
+		-0.083500f,
+		0.975900f,
+		0.201600f,
+		0.187500f,
+		0.931000f,
+		-0.059716f,
+		0.488310f,
+		0.089370f,
+		0.000000f,
+		-0.121200f,
+		0.975900f,
+		0.181400f,
+		0.156200f,
+		0.931000f,
+		-0.061096f,
+		0.473826f,
+		0.147498f,
+		0.000000f,
+		-0.123300f,
+		0.946600f,
+		0.297800f,
+		0.187500f,
+		0.896600f,
+		-0.059716f,
+		0.488310f,
+		0.089370f,
+		0.000000f,
+		-0.121200f,
+		0.975900f,
+		0.181400f,
+		0.156200f,
+		0.931000f,
+		-0.088698f,
+		0.473826f,
+		0.132745f,
+		0.000000f,
+		-0.179100f,
+		0.946600f,
+		0.268000f,
+		0.156200f,
+		0.896600f,
+		-0.184367f,
+		-0.133764f,
+		0.445101f,
+		0.000000f,
+		-0.368800f,
+		-0.266600f,
+		0.890400f,
+		0.187500f,
+		0.413800f,
+		-0.188821f,
+		-0.080891f,
+		0.455853f,
+		0.000000f,
+		-0.377700f,
+		-0.161200f,
+		0.911800f,
+		0.187500f,
+		0.448300f,
+		-0.274125f,
+		-0.080891f,
+		0.410257f,
+		0.000000f,
+		-0.548300f,
+		-0.161200f,
+		0.820600f,
+		0.156200f,
+		0.448300f,
+		-0.184367f,
+		-0.133764f,
+		0.445101f,
+		0.000000f,
+		-0.368800f,
+		-0.266600f,
+		0.890400f,
+		0.187500f,
+		0.413800f,
+		-0.274125f,
+		-0.080891f,
+		0.410257f,
+		0.000000f,
+		-0.548300f,
+		-0.161200f,
+		0.820600f,
+		0.156200f,
+		0.448300f,
+		-0.267660f,
+		-0.133764f,
+		0.400580f,
+		0.000000f,
+		-0.535400f,
+		-0.266600f,
+		0.801400f,
+		0.156200f,
+		0.413800f,
+		-0.080343f,
+		0.453788f,
+		0.193963f,
+		0.000000f,
+		-0.161700f,
+		0.906300f,
+		0.390500f,
+		0.187500f,
+		0.862100f,
+		-0.061096f,
+		0.473826f,
+		0.147498f,
+		0.000000f,
+		-0.123300f,
+		0.946600f,
+		0.297800f,
+		0.187500f,
+		0.896600f,
+		-0.088698f,
+		0.473826f,
+		0.132745f,
+		0.000000f,
+		-0.179100f,
+		0.946600f,
+		0.268000f,
+		0.156200f,
+		0.896600f,
+		-0.080343f,
+		0.453788f,
+		0.193963f,
+		0.000000f,
+		-0.161700f,
+		0.906300f,
+		0.390500f,
+		0.187500f,
+		0.862100f,
+		-0.088698f,
+		0.473826f,
+		0.132745f,
+		0.000000f,
+		-0.179100f,
+		0.946600f,
+		0.268000f,
+		0.156200f,
+		0.896600f,
+		-0.116639f,
+		0.453788f,
+		0.174562f,
+		0.000000f,
+		-0.234800f,
+		0.906300f,
+		0.351400f,
+		0.156200f,
+		0.862100f,
+		-0.177752f,
+		-0.185069f,
+		0.429130f,
+		0.000000f,
+		-0.355700f,
+		-0.369000f,
+		0.858700f,
+		0.187500f,
+		0.379300f,
+		-0.184367f,
+		-0.133764f,
+		0.445101f,
+		0.000000f,
+		-0.368800f,
+		-0.266600f,
+		0.890400f,
+		0.187500f,
+		0.413800f,
+		-0.267660f,
+		-0.133764f,
+		0.400580f,
+		0.000000f,
+		-0.535400f,
+		-0.266600f,
+		0.801400f,
+		0.156200f,
+		0.413800f,
+		-0.177752f,
+		-0.185069f,
+		0.429130f,
+		0.000000f,
+		-0.355700f,
+		-0.369000f,
+		0.858700f,
+		0.187500f,
+		0.379300f,
+		-0.267660f,
+		-0.133764f,
+		0.400580f,
+		0.000000f,
+		-0.535400f,
+		-0.266600f,
+		0.801400f,
+		0.156200f,
+		0.413800f,
+		-0.258056f,
+		-0.185069f,
+		0.386207f,
+		0.000000f,
+		-0.516300f,
+		-0.369000f,
+		0.772800f,
+		0.156200f,
+		0.379300f,
+		-0.098647f,
+		0.428429f,
+		0.238154f,
+		0.000000f,
+		-0.198200f,
+		0.855300f,
+		0.478600f,
+		0.187500f,
+		0.827600f,
+		-0.080343f,
+		0.453788f,
+		0.193963f,
+		0.000000f,
+		-0.161700f,
+		0.906300f,
+		0.390500f,
+		0.187500f,
+		0.862100f,
+		-0.116639f,
+		0.453788f,
+		0.174562f,
+		0.000000f,
+		-0.234800f,
+		0.906300f,
+		0.351400f,
+		0.156200f,
+		0.862100f,
+		-0.098647f,
+		0.428429f,
+		0.238154f,
+		0.000000f,
+		-0.198200f,
+		0.855300f,
+		0.478600f,
+		0.187500f,
+		0.827600f,
+		-0.116639f,
+		0.453788f,
+		0.174562f,
+		0.000000f,
+		-0.234800f,
+		0.906300f,
+		0.351400f,
+		0.156200f,
+		0.862100f,
+		-0.143213f,
+		0.428429f,
+		0.214333f,
+		0.000000f,
+		-0.287800f,
+		0.855300f,
+		0.430700f,
+		0.156200f,
+		0.827600f,
+		-0.169053f,
+		-0.234204f,
+		0.408128f,
+		0.000000f,
+		-0.338400f,
+		-0.467000f,
+		0.816900f,
+		0.187500f,
+		0.344800f,
+		-0.177752f,
+		-0.185069f,
+		0.429130f,
+		0.000000f,
+		-0.355700f,
+		-0.369000f,
+		0.858700f,
+		0.187500f,
+		0.379300f,
+		-0.258056f,
+		-0.185069f,
+		0.386207f,
+		0.000000f,
+		-0.516300f,
+		-0.369000f,
+		0.772800f,
+		0.156200f,
+		0.379300f,
+		-0.169053f,
+		-0.234204f,
+		0.408128f,
+		0.000000f,
+		-0.338400f,
+		-0.467000f,
+		0.816900f,
+		0.187500f,
+		0.344800f,
+		-0.258056f,
+		-0.185069f,
+		0.386207f,
+		0.000000f,
+		-0.516300f,
+		-0.369000f,
+		0.772800f,
+		0.156200f,
+		0.379300f,
+		-0.245427f,
+		-0.234204f,
+		0.367306f,
+		0.000000f,
+		-0.491300f,
+		-0.467000f,
+		0.735200f,
+		0.156200f,
+		0.344800f,
+		-0.115796f,
+		0.398046f,
+		0.279554f,
+		0.000000f,
+		-0.232400f,
+		0.794500f,
+		0.561100f,
+		0.187500f,
+		0.793100f,
+		-0.098647f,
+		0.428429f,
+		0.238154f,
+		0.000000f,
+		-0.198200f,
+		0.855300f,
+		0.478600f,
+		0.187500f,
+		0.827600f,
+		-0.143213f,
+		0.428429f,
+		0.214333f,
+		0.000000f,
+		-0.287800f,
+		0.855300f,
+		0.430700f,
+		0.156200f,
+		0.827600f,
+		-0.115796f,
+		0.398046f,
+		0.279554f,
+		0.000000f,
+		-0.232400f,
+		0.794500f,
+		0.561100f,
+		0.187500f,
+		0.793100f,
+		-0.143213f,
+		0.428429f,
+		0.214333f,
+		0.000000f,
+		-0.287800f,
+		0.855300f,
+		0.430700f,
+		0.156200f,
+		0.827600f,
+		-0.168108f,
+		0.398046f,
+		0.251592f,
+		0.000000f,
+		-0.337400f,
+		0.794500f,
+		0.505000f,
+		0.156200f,
+		0.793100f,
+		-0.158371f,
+		-0.280594f,
+		0.382342f,
+		0.000000f,
+		-0.317100f,
+		-0.559600f,
+		0.765600f,
+		0.187500f,
+		0.310300f,
+		-0.169053f,
+		-0.234204f,
+		0.408128f,
+		0.000000f,
+		-0.338400f,
+		-0.467000f,
+		0.816900f,
+		0.187500f,
+		0.344800f,
+		-0.245427f,
+		-0.234204f,
+		0.367306f,
+		0.000000f,
+		-0.491300f,
+		-0.467000f,
+		0.735200f,
+		0.156200f,
+		0.344800f,
+		-0.158371f,
+		-0.280594f,
+		0.382342f,
+		0.000000f,
+		-0.317100f,
+		-0.559600f,
+		0.765600f,
+		0.187500f,
+		0.310300f,
+		-0.245427f,
+		-0.234204f,
+		0.367306f,
+		0.000000f,
+		-0.491300f,
+		-0.467000f,
+		0.735200f,
+		0.156200f,
+		0.344800f,
+		-0.229920f,
+		-0.280594f,
+		0.344099f,
+		0.000000f,
+		-0.460400f,
+		-0.559600f,
+		0.689100f,
+		0.156200f,
+		0.310300f,
+		-0.131586f,
+		0.362998f,
+		0.317675f,
+		0.000000f,
+		-0.263800f,
+		0.724300f,
+		0.637000f,
+		0.187500f,
+		0.758600f,
+		-0.115796f,
+		0.398046f,
+		0.279554f,
+		0.000000f,
+		-0.232400f,
+		0.794500f,
+		0.561100f,
+		0.187500f,
+		0.793100f,
+		-0.168108f,
+		0.398046f,
+		0.251592f,
+		0.000000f,
+		-0.337400f,
+		0.794500f,
+		0.505000f,
+		0.156200f,
+		0.793100f,
+		-0.131586f,
+		0.362998f,
+		0.317675f,
+		0.000000f,
+		-0.263800f,
+		0.724300f,
+		0.637000f,
+		0.187500f,
+		0.758600f,
+		-0.168108f,
+		0.398046f,
+		0.251592f,
+		0.000000f,
+		-0.337400f,
+		0.794500f,
+		0.505000f,
+		0.156200f,
+		0.793100f,
+		-0.191033f,
+		0.362998f,
+		0.285900f,
+		0.000000f,
+		-0.383000f,
+		0.724300f,
+		0.573300f,
+		0.156200f,
+		0.758600f,
+		-0.145834f,
+		-0.323693f,
+		0.352073f,
+		0.000000f,
+		-0.292200f,
+		-0.645700f,
+		0.705400f,
+		0.187500f,
+		0.275900f,
+		-0.158371f,
+		-0.280594f,
+		0.382342f,
+		0.000000f,
+		-0.317100f,
+		-0.559600f,
+		0.765600f,
+		0.187500f,
+		0.310300f,
+		-0.229920f,
+		-0.280594f,
+		0.344099f,
+		0.000000f,
+		-0.460400f,
+		-0.559600f,
+		0.689100f,
+		0.156200f,
+		0.310300f,
+		-0.145834f,
+		-0.323693f,
+		0.352073f,
+		0.000000f,
+		-0.292200f,
+		-0.645700f,
+		0.705400f,
+		0.187500f,
+		0.275900f,
+		-0.229920f,
+		-0.280594f,
+		0.344099f,
+		0.000000f,
+		-0.460400f,
+		-0.559600f,
+		0.689100f,
+		0.156200f,
+		0.310300f,
+		-0.211718f,
+		-0.323693f,
+		0.316857f,
+		0.000000f,
+		-0.424200f,
+		-0.645700f,
+		0.634900f,
+		0.156200f,
+		0.275900f,
+		-0.145834f,
+		0.323693f,
+		0.352073f,
+		0.000000f,
+		-0.292200f,
+		0.645700f,
+		0.705400f,
+		0.187500f,
+		0.724100f,
+		-0.131586f,
+		0.362998f,
+		0.317675f,
+		0.000000f,
+		-0.263800f,
+		0.724300f,
+		0.637000f,
+		0.187500f,
+		0.758600f,
+		-0.191033f,
+		0.362998f,
+		0.285900f,
+		0.000000f,
+		-0.383000f,
+		0.724300f,
+		0.573300f,
+		0.156200f,
+		0.758600f,
+		-0.145834f,
+		0.323693f,
+		0.352073f,
+		0.000000f,
+		-0.292200f,
+		0.645700f,
+		0.705400f,
+		0.187500f,
+		0.724100f,
+		-0.191033f,
+		0.362998f,
+		0.285900f,
+		0.000000f,
+		-0.383000f,
+		0.724300f,
+		0.573300f,
+		0.156200f,
+		0.758600f,
+		-0.211718f,
+		0.323693f,
+		0.316857f,
+		0.000000f,
+		-0.424200f,
+		0.645700f,
+		0.634900f,
+		0.156200f,
+		0.724100f,
+		-0.131586f,
+		-0.362998f,
+		0.317675f,
+		0.000000f,
+		-0.263800f,
+		-0.724300f,
+		0.637000f,
+		0.187500f,
+		0.241400f,
+		-0.145834f,
+		-0.323693f,
+		0.352073f,
+		0.000000f,
+		-0.292200f,
+		-0.645700f,
+		0.705400f,
+		0.187500f,
+		0.275900f,
+		-0.211718f,
+		-0.323693f,
+		0.316857f,
+		0.000000f,
+		-0.424200f,
+		-0.645700f,
+		0.634900f,
+		0.156200f,
+		0.275900f,
+		-0.131586f,
+		-0.362998f,
+		0.317675f,
+		0.000000f,
+		-0.263800f,
+		-0.724300f,
+		0.637000f,
+		0.187500f,
+		0.241400f,
+		-0.211718f,
+		-0.323693f,
+		0.316857f,
+		0.000000f,
+		-0.424200f,
+		-0.645700f,
+		0.634900f,
+		0.156200f,
+		0.275900f,
+		-0.191033f,
+		-0.362998f,
+		0.285900f,
+		0.000000f,
+		-0.383000f,
+		-0.724300f,
+		0.573300f,
+		0.156200f,
+		0.241400f,
+		-0.158371f,
+		0.280594f,
+		0.382342f,
+		0.000000f,
+		-0.317100f,
+		0.559600f,
+		0.765600f,
+		0.187500f,
+		0.689700f,
+		-0.145834f,
+		0.323693f,
+		0.352073f,
+		0.000000f,
+		-0.292200f,
+		0.645700f,
+		0.705400f,
+		0.187500f,
+		0.724100f,
+		-0.211718f,
+		0.323693f,
+		0.316857f,
+		0.000000f,
+		-0.424200f,
+		0.645700f,
+		0.634900f,
+		0.156200f,
+		0.724100f,
+		-0.158371f,
+		0.280594f,
+		0.382342f,
+		0.000000f,
+		-0.317100f,
+		0.559600f,
+		0.765600f,
+		0.187500f,
+		0.689700f,
+		-0.211718f,
+		0.323693f,
+		0.316857f,
+		0.000000f,
+		-0.424200f,
+		0.645700f,
+		0.634900f,
+		0.156200f,
+		0.724100f,
+		-0.229920f,
+		0.280594f,
+		0.344099f,
+		0.000000f,
+		-0.460400f,
+		0.559600f,
+		0.689100f,
+		0.156200f,
+		0.689700f,
+		-0.115796f,
+		-0.398046f,
+		0.279554f,
+		0.000000f,
+		-0.232400f,
+		-0.794500f,
+		0.561100f,
+		0.187500f,
+		0.206900f,
+		-0.131586f,
+		-0.362998f,
+		0.317675f,
+		0.000000f,
+		-0.263800f,
+		-0.724300f,
+		0.637000f,
+		0.187500f,
+		0.241400f,
+		-0.191033f,
+		-0.362998f,
+		0.285900f,
+		0.000000f,
+		-0.383000f,
+		-0.724300f,
+		0.573300f,
+		0.156200f,
+		0.241400f,
+		-0.115796f,
+		-0.398046f,
+		0.279554f,
+		0.000000f,
+		-0.232400f,
+		-0.794500f,
+		0.561100f,
+		0.187500f,
+		0.206900f,
+		-0.191033f,
+		-0.362998f,
+		0.285900f,
+		0.000000f,
+		-0.383000f,
+		-0.724300f,
+		0.573300f,
+		0.156200f,
+		0.241400f,
+		-0.168108f,
+		-0.398046f,
+		0.251592f,
+		0.000000f,
+		-0.337400f,
+		-0.794500f,
+		0.504900f,
+		0.156200f,
+		0.206900f,
+		-0.169053f,
+		0.234204f,
+		0.408128f,
+		0.000000f,
+		-0.338400f,
+		0.467000f,
+		0.816900f,
+		0.187500f,
+		0.655200f,
+		-0.158371f,
+		0.280594f,
+		0.382342f,
+		0.000000f,
+		-0.317100f,
+		0.559600f,
+		0.765600f,
+		0.187500f,
+		0.689700f,
+		-0.229920f,
+		0.280594f,
+		0.344099f,
+		0.000000f,
+		-0.460400f,
+		0.559600f,
+		0.689100f,
+		0.156200f,
+		0.689700f,
+		-0.169053f,
+		0.234204f,
+		0.408128f,
+		0.000000f,
+		-0.338400f,
+		0.467000f,
+		0.816900f,
+		0.187500f,
+		0.655200f,
+		-0.229920f,
+		0.280594f,
+		0.344099f,
+		0.000000f,
+		-0.460400f,
+		0.559600f,
+		0.689100f,
+		0.156200f,
+		0.689700f,
+		-0.245427f,
+		0.234204f,
+		0.367306f,
+		0.000000f,
+		-0.491300f,
+		0.467000f,
+		0.735200f,
+		0.156200f,
+		0.655200f,
+		-0.098647f,
+		-0.428429f,
+		0.238155f,
+		0.000000f,
+		-0.198200f,
+		-0.855300f,
+		0.478600f,
+		0.187500f,
+		0.172400f,
+		-0.115796f,
+		-0.398046f,
+		0.279554f,
+		0.000000f,
+		-0.232400f,
+		-0.794500f,
+		0.561100f,
+		0.187500f,
+		0.206900f,
+		-0.168108f,
+		-0.398046f,
+		0.251592f,
+		0.000000f,
+		-0.337400f,
+		-0.794500f,
+		0.504900f,
+		0.156200f,
+		0.206900f,
+		-0.098647f,
+		-0.428429f,
+		0.238155f,
+		0.000000f,
+		-0.198200f,
+		-0.855300f,
+		0.478600f,
+		0.187500f,
+		0.172400f,
+		-0.168108f,
+		-0.398046f,
+		0.251592f,
+		0.000000f,
+		-0.337400f,
+		-0.794500f,
+		0.504900f,
+		0.156200f,
+		0.206900f,
+		-0.143213f,
+		-0.428429f,
+		0.214334f,
+		0.000000f,
+		-0.287800f,
+		-0.855300f,
+		0.430700f,
+		0.156200f,
+		0.172400f,
+		-0.177752f,
+		0.185069f,
+		0.429130f,
+		0.000000f,
+		-0.355700f,
+		0.369000f,
+		0.858700f,
+		0.187500f,
+		0.620700f,
+		-0.169053f,
+		0.234204f,
+		0.408128f,
+		0.000000f,
+		-0.338400f,
+		0.467000f,
+		0.816900f,
+		0.187500f,
+		0.655200f,
+		-0.245427f,
+		0.234204f,
+		0.367306f,
+		0.000000f,
+		-0.491300f,
+		0.467000f,
+		0.735200f,
+		0.156200f,
+		0.655200f,
+		-0.177752f,
+		0.185069f,
+		0.429130f,
+		0.000000f,
+		-0.355700f,
+		0.369000f,
+		0.858700f,
+		0.187500f,
+		0.620700f,
+		-0.245427f,
+		0.234204f,
+		0.367306f,
+		0.000000f,
+		-0.491300f,
+		0.467000f,
+		0.735200f,
+		0.156200f,
+		0.655200f,
+		-0.258056f,
+		0.185069f,
+		0.386207f,
+		0.000000f,
+		-0.516300f,
+		0.369000f,
+		0.772800f,
+		0.156200f,
+		0.620700f,
+		-0.080343f,
+		-0.453788f,
+		0.193963f,
+		0.000000f,
+		-0.161700f,
+		-0.906300f,
+		0.390500f,
+		0.187500f,
+		0.137900f,
+		-0.098647f,
+		-0.428429f,
+		0.238155f,
+		0.000000f,
+		-0.198200f,
+		-0.855300f,
+		0.478600f,
+		0.187500f,
+		0.172400f,
+		-0.143213f,
+		-0.428429f,
+		0.214334f,
+		0.000000f,
+		-0.287800f,
+		-0.855300f,
+		0.430700f,
+		0.156200f,
+		0.172400f,
+		-0.080343f,
+		-0.453788f,
+		0.193963f,
+		0.000000f,
+		-0.161700f,
+		-0.906300f,
+		0.390500f,
+		0.187500f,
+		0.137900f,
+		-0.143213f,
+		-0.428429f,
+		0.214334f,
+		0.000000f,
+		-0.287800f,
+		-0.855300f,
+		0.430700f,
+		0.156200f,
+		0.172400f,
+		-0.116639f,
+		-0.453788f,
+		0.174562f,
+		0.000000f,
+		-0.234800f,
+		-0.906300f,
+		0.351400f,
+		0.156200f,
+		0.137900f,
+		-0.184367f,
+		0.133764f,
+		0.445101f,
+		0.000000f,
+		-0.368800f,
+		0.266600f,
+		0.890400f,
+		0.187500f,
+		0.586200f,
+		-0.177752f,
+		0.185069f,
+		0.429130f,
+		0.000000f,
+		-0.355700f,
+		0.369000f,
+		0.858700f,
+		0.187500f,
+		0.620700f,
+		-0.258056f,
+		0.185069f,
+		0.386207f,
+		0.000000f,
+		-0.516300f,
+		0.369000f,
+		0.772800f,
+		0.156200f,
+		0.620700f,
+		-0.184367f,
+		0.133764f,
+		0.445101f,
+		0.000000f,
+		-0.368800f,
+		0.266600f,
+		0.890400f,
+		0.187500f,
+		0.586200f,
+		-0.258056f,
+		0.185069f,
+		0.386207f,
+		0.000000f,
+		-0.516300f,
+		0.369000f,
+		0.772800f,
+		0.156200f,
+		0.620700f,
+		-0.267660f,
+		0.133764f,
+		0.400580f,
+		0.000000f,
+		-0.535400f,
+		0.266600f,
+		0.801400f,
+		0.156200f,
+		0.586200f,
+		-0.061096f,
+		-0.473826f,
+		0.147498f,
+		0.000000f,
+		-0.123300f,
+		-0.946600f,
+		0.297800f,
+		0.187500f,
+		0.103400f,
+		-0.080343f,
+		-0.453788f,
+		0.193963f,
+		0.000000f,
+		-0.161700f,
+		-0.906300f,
+		0.390500f,
+		0.187500f,
+		0.137900f,
+		-0.116639f,
+		-0.453788f,
+		0.174562f,
+		0.000000f,
+		-0.234800f,
+		-0.906300f,
+		0.351400f,
+		0.156200f,
+		0.137900f,
+		-0.061096f,
+		-0.473826f,
+		0.147498f,
+		0.000000f,
+		-0.123300f,
+		-0.946600f,
+		0.297800f,
+		0.187500f,
+		0.103400f,
+		-0.116639f,
+		-0.453788f,
+		0.174562f,
+		0.000000f,
+		-0.234800f,
+		-0.906300f,
+		0.351400f,
+		0.156200f,
+		0.137900f,
+		-0.088698f,
+		-0.473826f,
+		0.132745f,
+		0.000000f,
+		-0.179100f,
+		-0.946600f,
+		0.268000f,
+		0.156200f,
+		0.103400f,
+		-0.211718f,
+		-0.323693f,
+		0.316857f,
+		0.000000f,
+		-0.424200f,
+		-0.645700f,
+		0.634900f,
+		0.156200f,
+		0.275900f,
+		-0.229920f,
+		-0.280594f,
+		0.344099f,
+		0.000000f,
+		-0.460400f,
+		-0.559600f,
+		0.689100f,
+		0.156200f,
+		0.310300f,
+		-0.292632f,
+		-0.280594f,
+		0.292632f,
+		0.000000f,
+		-0.586000f,
+		-0.559600f,
+		0.586000f,
+		0.125000f,
+		0.310300f,
+		-0.211718f,
+		-0.323693f,
+		0.316857f,
+		0.000000f,
+		-0.424200f,
+		-0.645700f,
+		0.634900f,
+		0.156200f,
+		0.275900f,
+		-0.292632f,
+		-0.280594f,
+		0.292632f,
+		0.000000f,
+		-0.586000f,
+		-0.559600f,
+		0.586000f,
+		0.125000f,
+		0.310300f,
+		-0.269465f,
+		-0.323693f,
+		0.269464f,
+		0.000000f,
+		-0.539900f,
+		-0.645700f,
+		0.539900f,
+		0.125000f,
+		0.275900f,
+		-0.211718f,
+		0.323693f,
+		0.316857f,
+		0.000000f,
+		-0.424200f,
+		0.645700f,
+		0.634900f,
+		0.156200f,
+		0.724100f,
+		-0.191033f,
+		0.362998f,
+		0.285900f,
+		0.000000f,
+		-0.383000f,
+		0.724300f,
+		0.573300f,
+		0.156200f,
+		0.758600f,
+		-0.243139f,
+		0.362998f,
+		0.243138f,
+		0.000000f,
+		-0.487500f,
+		0.724300f,
+		0.487500f,
+		0.125000f,
+		0.758600f,
+		-0.211718f,
+		0.323693f,
+		0.316857f,
+		0.000000f,
+		-0.424200f,
+		0.645700f,
+		0.634900f,
+		0.156200f,
+		0.724100f,
+		-0.243139f,
+		0.362998f,
+		0.243138f,
+		0.000000f,
+		-0.487500f,
+		0.724300f,
+		0.487500f,
+		0.125000f,
+		0.758600f,
+		-0.269465f,
+		0.323693f,
+		0.269464f,
+		0.000000f,
+		-0.539900f,
+		0.645700f,
+		0.539900f,
+		0.125000f,
+		0.724100f,
+		-0.191033f,
+		-0.362998f,
+		0.285900f,
+		0.000000f,
+		-0.383000f,
+		-0.724300f,
+		0.573300f,
+		0.156200f,
+		0.241400f,
+		-0.211718f,
+		-0.323693f,
+		0.316857f,
+		0.000000f,
+		-0.424200f,
+		-0.645700f,
+		0.634900f,
+		0.156200f,
+		0.275900f,
+		-0.269465f,
+		-0.323693f,
+		0.269464f,
+		0.000000f,
+		-0.539900f,
+		-0.645700f,
+		0.539900f,
+		0.125000f,
+		0.275900f,
+		-0.191033f,
+		-0.362998f,
+		0.285900f,
+		0.000000f,
+		-0.383000f,
+		-0.724300f,
+		0.573300f,
+		0.156200f,
+		0.241400f,
+		-0.269465f,
+		-0.323693f,
+		0.269464f,
+		0.000000f,
+		-0.539900f,
+		-0.645700f,
+		0.539900f,
+		0.125000f,
+		0.275900f,
+		-0.243139f,
+		-0.362998f,
+		0.243138f,
+		0.000000f,
+		-0.487500f,
+		-0.724300f,
+		0.487500f,
+		0.125000f,
+		0.241400f,
+		-0.229920f,
+		0.280594f,
+		0.344099f,
+		0.000000f,
+		-0.460400f,
+		0.559600f,
+		0.689100f,
+		0.156200f,
+		0.689700f,
+		-0.211718f,
+		0.323693f,
+		0.316857f,
+		0.000000f,
+		-0.424200f,
+		0.645700f,
+		0.634900f,
+		0.156200f,
+		0.724100f,
+		-0.269465f,
+		0.323693f,
+		0.269464f,
+		0.000000f,
+		-0.539900f,
+		0.645700f,
+		0.539900f,
+		0.125000f,
+		0.724100f,
+		-0.229920f,
+		0.280594f,
+		0.344099f,
+		0.000000f,
+		-0.460400f,
+		0.559600f,
+		0.689100f,
+		0.156200f,
+		0.689700f,
+		-0.269465f,
+		0.323693f,
+		0.269464f,
+		0.000000f,
+		-0.539900f,
+		0.645700f,
+		0.539900f,
+		0.125000f,
+		0.724100f,
+		-0.292632f,
+		0.280594f,
+		0.292632f,
+		0.000000f,
+		-0.586000f,
+		0.559600f,
+		0.586000f,
+		0.125000f,
+		0.689700f,
+		-0.168108f,
+		-0.398046f,
+		0.251592f,
+		0.000000f,
+		-0.337400f,
+		-0.794500f,
+		0.504900f,
+		0.156200f,
+		0.206900f,
+		-0.191033f,
+		-0.362998f,
+		0.285900f,
+		0.000000f,
+		-0.383000f,
+		-0.724300f,
+		0.573300f,
+		0.156200f,
+		0.241400f,
+		-0.243139f,
+		-0.362998f,
+		0.243138f,
+		0.000000f,
+		-0.487500f,
+		-0.724300f,
+		0.487500f,
+		0.125000f,
+		0.241400f,
+		-0.168108f,
+		-0.398046f,
+		0.251592f,
+		0.000000f,
+		-0.337400f,
+		-0.794500f,
+		0.504900f,
+		0.156200f,
+		0.206900f,
+		-0.243139f,
+		-0.362998f,
+		0.243138f,
+		0.000000f,
+		-0.487500f,
+		-0.724300f,
+		0.487500f,
+		0.125000f,
+		0.241400f,
+		-0.213961f,
+		-0.398046f,
+		0.213961f,
+		0.000000f,
+		-0.429400f,
+		-0.794500f,
+		0.429400f,
+		0.125000f,
+		0.206900f,
+		-0.245427f,
+		0.234204f,
+		0.367306f,
+		0.000000f,
+		-0.491300f,
+		0.467000f,
+		0.735200f,
+		0.156200f,
+		0.655200f,
+		-0.229920f,
+		0.280594f,
+		0.344099f,
+		0.000000f,
+		-0.460400f,
+		0.559600f,
+		0.689100f,
+		0.156200f,
+		0.689700f,
+		-0.292632f,
+		0.280594f,
+		0.292632f,
+		0.000000f,
+		-0.586000f,
+		0.559600f,
+		0.586000f,
+		0.125000f,
+		0.689700f,
+		-0.245427f,
+		0.234204f,
+		0.367306f,
+		0.000000f,
+		-0.491300f,
+		0.467000f,
+		0.735200f,
+		0.156200f,
+		0.655200f,
+		-0.292632f,
+		0.280594f,
+		0.292632f,
+		0.000000f,
+		-0.586000f,
+		0.559600f,
+		0.586000f,
+		0.125000f,
+		0.689700f,
+		-0.312369f,
+		0.234204f,
+		0.312368f,
+		0.000000f,
+		-0.625200f,
+		0.467000f,
+		0.625200f,
+		0.125000f,
+		0.655200f,
+		-0.143213f,
+		-0.428429f,
+		0.214334f,
+		0.000000f,
+		-0.287800f,
+		-0.855300f,
+		0.430700f,
+		0.156200f,
+		0.172400f,
+		-0.168108f,
+		-0.398046f,
+		0.251592f,
+		0.000000f,
+		-0.337400f,
+		-0.794500f,
+		0.504900f,
+		0.156200f,
+		0.206900f,
+		-0.213961f,
+		-0.398046f,
+		0.213961f,
+		0.000000f,
+		-0.429400f,
+		-0.794500f,
+		0.429400f,
+		0.125000f,
+		0.206900f,
+		-0.143213f,
+		-0.428429f,
+		0.214334f,
+		0.000000f,
+		-0.287800f,
+		-0.855300f,
+		0.430700f,
+		0.156200f,
+		0.172400f,
+		-0.213961f,
+		-0.398046f,
+		0.213961f,
+		0.000000f,
+		-0.429400f,
+		-0.794500f,
+		0.429400f,
+		0.125000f,
+		0.206900f,
+		-0.182276f,
+		-0.428429f,
+		0.182276f,
+		0.000000f,
+		-0.366300f,
+		-0.855300f,
+		0.366300f,
+		0.125000f,
+		0.172400f,
+		-0.258056f,
+		0.185069f,
+		0.386207f,
+		0.000000f,
+		-0.516300f,
+		0.369000f,
+		0.772800f,
+		0.156200f,
+		0.620700f,
+		-0.245427f,
+		0.234204f,
+		0.367306f,
+		0.000000f,
+		-0.491300f,
+		0.467000f,
+		0.735200f,
+		0.156200f,
+		0.655200f,
+		-0.312369f,
+		0.234204f,
+		0.312368f,
+		0.000000f,
+		-0.625200f,
+		0.467000f,
+		0.625200f,
+		0.125000f,
+		0.655200f,
+		-0.258056f,
+		0.185069f,
+		0.386207f,
+		0.000000f,
+		-0.516300f,
+		0.369000f,
+		0.772800f,
+		0.156200f,
+		0.620700f,
+		-0.312369f,
+		0.234204f,
+		0.312368f,
+		0.000000f,
+		-0.625200f,
+		0.467000f,
+		0.625200f,
+		0.125000f,
+		0.655200f,
+		-0.328443f,
+		0.185069f,
+		0.328443f,
+		0.000000f,
+		-0.657200f,
+		0.369000f,
+		0.657200f,
+		0.125000f,
+		0.620700f,
+		-0.116639f,
+		-0.453788f,
+		0.174562f,
+		0.000000f,
+		-0.234800f,
+		-0.906300f,
+		0.351400f,
+		0.156200f,
+		0.137900f,
+		-0.143213f,
+		-0.428429f,
+		0.214334f,
+		0.000000f,
+		-0.287800f,
+		-0.855300f,
+		0.430700f,
+		0.156200f,
+		0.172400f,
+		-0.182276f,
+		-0.428429f,
+		0.182276f,
+		0.000000f,
+		-0.366300f,
+		-0.855300f,
+		0.366300f,
+		0.125000f,
+		0.172400f,
+		-0.116639f,
+		-0.453788f,
+		0.174562f,
+		0.000000f,
+		-0.234800f,
+		-0.906300f,
+		0.351400f,
+		0.156200f,
+		0.137900f,
+		-0.182276f,
+		-0.428429f,
+		0.182276f,
+		0.000000f,
+		-0.366300f,
+		-0.855300f,
+		0.366300f,
+		0.125000f,
+		0.172400f,
+		-0.148454f,
+		-0.453788f,
+		0.148453f,
+		0.000000f,
+		-0.298900f,
+		-0.906300f,
+		0.298900f,
+		0.125000f,
+		0.137900f,
+		-0.267660f,
+		0.133764f,
+		0.400580f,
+		0.000000f,
+		-0.535400f,
+		0.266600f,
+		0.801400f,
+		0.156200f,
+		0.586200f,
+		-0.258056f,
+		0.185069f,
+		0.386207f,
+		0.000000f,
+		-0.516300f,
+		0.369000f,
+		0.772800f,
+		0.156200f,
+		0.620700f,
+		-0.328443f,
+		0.185069f,
+		0.328443f,
+		0.000000f,
+		-0.657200f,
+		0.369000f,
+		0.657200f,
+		0.125000f,
+		0.620700f,
+		-0.267660f,
+		0.133764f,
+		0.400580f,
+		0.000000f,
+		-0.535400f,
+		0.266600f,
+		0.801400f,
+		0.156200f,
+		0.586200f,
+		-0.328443f,
+		0.185069f,
+		0.328443f,
+		0.000000f,
+		-0.657200f,
+		0.369000f,
+		0.657200f,
+		0.125000f,
+		0.620700f,
+		-0.340667f,
+		0.133764f,
+		0.340666f,
+		0.000000f,
+		-0.681500f,
+		0.266600f,
+		0.681500f,
+		0.125000f,
+		0.586200f,
+		-0.088698f,
+		-0.473826f,
+		0.132745f,
+		0.000000f,
+		-0.179100f,
+		-0.946600f,
+		0.268000f,
+		0.156200f,
+		0.103400f,
+		-0.116639f,
+		-0.453788f,
+		0.174562f,
+		0.000000f,
+		-0.234800f,
+		-0.906300f,
+		0.351400f,
+		0.156200f,
+		0.137900f,
+		-0.148454f,
+		-0.453788f,
+		0.148453f,
+		0.000000f,
+		-0.298900f,
+		-0.906300f,
+		0.298900f,
+		0.125000f,
+		0.137900f,
+		-0.088698f,
+		-0.473826f,
+		0.132745f,
+		0.000000f,
+		-0.179100f,
+		-0.946600f,
+		0.268000f,
+		0.156200f,
+		0.103400f,
+		-0.148454f,
+		-0.453788f,
+		0.148453f,
+		0.000000f,
+		-0.298900f,
+		-0.906300f,
+		0.298900f,
+		0.125000f,
+		0.137900f,
+		-0.112890f,
+		-0.473826f,
+		0.112890f,
+		0.000000f,
+		-0.227900f,
+		-0.946600f,
+		0.227900f,
+		0.125000f,
+		0.103400f,
+		-0.274125f,
+		0.080891f,
+		0.410257f,
+		0.000000f,
+		-0.548300f,
+		0.161200f,
+		0.820600f,
+		0.156200f,
+		0.551700f,
+		-0.267660f,
+		0.133764f,
+		0.400580f,
+		0.000000f,
+		-0.535400f,
+		0.266600f,
+		0.801400f,
+		0.156200f,
+		0.586200f,
+		-0.340667f,
+		0.133764f,
+		0.340666f,
+		0.000000f,
+		-0.681500f,
+		0.266600f,
+		0.681500f,
+		0.125000f,
+		0.586200f,
+		-0.274125f,
+		0.080891f,
+		0.410257f,
+		0.000000f,
+		-0.548300f,
+		0.161200f,
+		0.820600f,
+		0.156200f,
+		0.551700f,
+		-0.340667f,
+		0.133764f,
+		0.340666f,
+		0.000000f,
+		-0.681500f,
+		0.266600f,
+		0.681500f,
+		0.125000f,
+		0.586200f,
+		-0.348895f,
+		0.080891f,
+		0.348895f,
+		0.000000f,
+		-0.697800f,
+		0.161200f,
+		0.697800f,
+		0.125000f,
+		0.551700f,
+		-0.059716f,
+		-0.488310f,
+		0.089370f,
+		0.000000f,
+		-0.121200f,
+		-0.975900f,
+		0.181400f,
+		0.156200f,
+		0.069000f,
+		-0.088698f,
+		-0.473826f,
+		0.132745f,
+		0.000000f,
+		-0.179100f,
+		-0.946600f,
+		0.268000f,
+		0.156200f,
+		0.103400f,
+		-0.112890f,
+		-0.473826f,
+		0.112890f,
+		0.000000f,
+		-0.227900f,
+		-0.946600f,
+		0.227900f,
+		0.125000f,
+		0.103400f,
+		-0.059716f,
+		-0.488310f,
+		0.089370f,
+		0.000000f,
+		-0.121200f,
+		-0.975900f,
+		0.181400f,
+		0.156200f,
+		0.069000f,
+		-0.112890f,
+		-0.473826f,
+		0.112890f,
+		0.000000f,
+		-0.227900f,
+		-0.946600f,
+		0.227900f,
+		0.125000f,
+		0.103400f,
+		-0.076004f,
+		-0.488310f,
+		0.076003f,
+		0.000000f,
+		-0.154300f,
+		-0.975900f,
+		0.154300f,
+		0.125000f,
+		0.069000f,
+		-0.277378f,
+		0.027069f,
+		0.415125f,
+		0.000000f,
+		-0.554700f,
+		0.054000f,
+		0.830300f,
+		0.156200f,
+		0.517200f,
+		-0.274125f,
+		0.080891f,
+		0.410257f,
+		0.000000f,
+		-0.548300f,
+		0.161200f,
+		0.820600f,
+		0.156200f,
+		0.551700f,
+		-0.348895f,
+		0.080891f,
+		0.348895f,
+		0.000000f,
+		-0.697800f,
+		0.161200f,
+		0.697800f,
+		0.125000f,
+		0.551700f,
+		-0.277378f,
+		0.027069f,
+		0.415125f,
+		0.000000f,
+		-0.554700f,
+		0.054000f,
+		0.830300f,
+		0.156200f,
+		0.517200f,
+		-0.348895f,
+		0.080891f,
+		0.348895f,
+		0.000000f,
+		-0.697800f,
+		0.161200f,
+		0.697800f,
+		0.125000f,
+		0.551700f,
+		-0.353035f,
+		0.027069f,
+		0.353034f,
+		0.000000f,
+		-0.706100f,
+		0.054000f,
+		0.706100f,
+		0.125000f,
+		0.517200f,
+		-0.030034f,
+		0.497069f,
+		0.044948f,
+		0.000000f,
+		-0.061900f,
+		0.993700f,
+		0.092700f,
+		0.476200f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.482000f,
+		0.960300f,
+		-0.038226f,
+		0.497069f,
+		0.038226f,
+		0.000000f,
+		-0.078800f,
+		0.993700f,
+		0.078800f,
+		0.478000f,
+		0.962300f,
+		-0.030034f,
+		-0.497069f,
+		0.044949f,
+		0.000000f,
+		-0.061900f,
+		-0.993700f,
+		0.092700f,
+		0.156200f,
+		0.034500f,
+		-0.059716f,
+		-0.488310f,
+		0.089370f,
+		0.000000f,
+		-0.121200f,
+		-0.975900f,
+		0.181400f,
+		0.156200f,
+		0.069000f,
+		-0.076004f,
+		-0.488310f,
+		0.076003f,
+		0.000000f,
+		-0.154300f,
+		-0.975900f,
+		0.154300f,
+		0.125000f,
+		0.069000f,
+		-0.030034f,
+		-0.497069f,
+		0.044949f,
+		0.000000f,
+		-0.061900f,
+		-0.993700f,
+		0.092700f,
+		0.156200f,
+		0.034500f,
+		-0.076004f,
+		-0.488310f,
+		0.076003f,
+		0.000000f,
+		-0.154300f,
+		-0.975900f,
+		0.154300f,
+		0.125000f,
+		0.069000f,
+		-0.038226f,
+		-0.497069f,
+		0.038226f,
+		0.000000f,
+		-0.078800f,
+		-0.993700f,
+		0.078800f,
+		0.125000f,
+		0.034500f,
+		-0.277378f,
+		-0.027069f,
+		0.415125f,
+		0.000000f,
+		-0.554700f,
+		-0.054000f,
+		0.830300f,
+		0.156200f,
+		0.482800f,
+		-0.277378f,
+		0.027069f,
+		0.415125f,
+		0.000000f,
+		-0.554700f,
+		0.054000f,
+		0.830300f,
+		0.156200f,
+		0.517200f,
+		-0.353035f,
+		0.027069f,
+		0.353034f,
+		0.000000f,
+		-0.706100f,
+		0.054000f,
+		0.706100f,
+		0.125000f,
+		0.517200f,
+		-0.277378f,
+		-0.027069f,
+		0.415125f,
+		0.000000f,
+		-0.554700f,
+		-0.054000f,
+		0.830300f,
+		0.156200f,
+		0.482800f,
+		-0.353035f,
+		0.027069f,
+		0.353034f,
+		0.000000f,
+		-0.706100f,
+		0.054000f,
+		0.706100f,
+		0.125000f,
+		0.517200f,
+		-0.353035f,
+		-0.027069f,
+		0.353034f,
+		0.000000f,
+		-0.706100f,
+		-0.054000f,
+		0.706100f,
+		0.125000f,
+		0.482800f,
+		-0.059716f,
+		0.488310f,
+		0.089370f,
+		0.000000f,
+		-0.121200f,
+		0.975900f,
+		0.181400f,
+		0.156200f,
+		0.931000f,
+		-0.030034f,
+		0.497069f,
+		0.044948f,
+		0.000000f,
+		-0.061900f,
+		0.993700f,
+		0.092700f,
+		0.156200f,
+		0.965500f,
+		-0.038226f,
+		0.497069f,
+		0.038226f,
+		0.000000f,
+		-0.078800f,
+		0.993700f,
+		0.078800f,
+		0.125000f,
+		0.965500f,
+		-0.059716f,
+		0.488310f,
+		0.089370f,
+		0.000000f,
+		-0.121200f,
+		0.975900f,
+		0.181400f,
+		0.156200f,
+		0.931000f,
+		-0.038226f,
+		0.497069f,
+		0.038226f,
+		0.000000f,
+		-0.078800f,
+		0.993700f,
+		0.078800f,
+		0.125000f,
+		0.965500f,
+		-0.076003f,
+		0.488310f,
+		0.076003f,
+		0.000000f,
+		-0.154300f,
+		0.975900f,
+		0.154300f,
+		0.125000f,
+		0.931000f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.411700f,
+		0.051000f,
+		-0.030034f,
+		-0.497069f,
+		0.044949f,
+		0.000000f,
+		-0.061900f,
+		-0.993700f,
+		0.092700f,
+		0.423500f,
+		0.053800f,
+		-0.038226f,
+		-0.497069f,
+		0.038226f,
+		0.000000f,
+		-0.078800f,
+		-0.993700f,
+		0.078800f,
+		0.420900f,
+		0.053800f,
+		-0.274125f,
+		-0.080891f,
+		0.410257f,
+		0.000000f,
+		-0.548300f,
+		-0.161200f,
+		0.820600f,
+		0.156200f,
+		0.448300f,
+		-0.277378f,
+		-0.027069f,
+		0.415125f,
+		0.000000f,
+		-0.554700f,
+		-0.054000f,
+		0.830300f,
+		0.156200f,
+		0.482800f,
+		-0.353035f,
+		-0.027069f,
+		0.353034f,
+		0.000000f,
+		-0.706100f,
+		-0.054000f,
+		0.706100f,
+		0.125000f,
+		0.482800f,
+		-0.274125f,
+		-0.080891f,
+		0.410257f,
+		0.000000f,
+		-0.548300f,
+		-0.161200f,
+		0.820600f,
+		0.156200f,
+		0.448300f,
+		-0.353035f,
+		-0.027069f,
+		0.353034f,
+		0.000000f,
+		-0.706100f,
+		-0.054000f,
+		0.706100f,
+		0.125000f,
+		0.482800f,
+		-0.348895f,
+		-0.080891f,
+		0.348895f,
+		0.000000f,
+		-0.697800f,
+		-0.161200f,
+		0.697800f,
+		0.125000f,
+		0.448300f,
+		-0.088698f,
+		0.473826f,
+		0.132745f,
+		0.000000f,
+		-0.179100f,
+		0.946600f,
+		0.268000f,
+		0.156200f,
+		0.896600f,
+		-0.059716f,
+		0.488310f,
+		0.089370f,
+		0.000000f,
+		-0.121200f,
+		0.975900f,
+		0.181400f,
+		0.156200f,
+		0.931000f,
+		-0.076003f,
+		0.488310f,
+		0.076003f,
+		0.000000f,
+		-0.154300f,
+		0.975900f,
+		0.154300f,
+		0.125000f,
+		0.931000f,
+		-0.088698f,
+		0.473826f,
+		0.132745f,
+		0.000000f,
+		-0.179100f,
+		0.946600f,
+		0.268000f,
+		0.156200f,
+		0.896600f,
+		-0.076003f,
+		0.488310f,
+		0.076003f,
+		0.000000f,
+		-0.154300f,
+		0.975900f,
+		0.154300f,
+		0.125000f,
+		0.931000f,
+		-0.112890f,
+		0.473826f,
+		0.112889f,
+		0.000000f,
+		-0.227900f,
+		0.946600f,
+		0.227900f,
+		0.125000f,
+		0.896600f,
+		-0.267660f,
+		-0.133764f,
+		0.400580f,
+		0.000000f,
+		-0.535400f,
+		-0.266600f,
+		0.801400f,
+		0.156200f,
+		0.413800f,
+		-0.274125f,
+		-0.080891f,
+		0.410257f,
+		0.000000f,
+		-0.548300f,
+		-0.161200f,
+		0.820600f,
+		0.156200f,
+		0.448300f,
+		-0.348895f,
+		-0.080891f,
+		0.348895f,
+		0.000000f,
+		-0.697800f,
+		-0.161200f,
+		0.697800f,
+		0.125000f,
+		0.448300f,
+		-0.267660f,
+		-0.133764f,
+		0.400580f,
+		0.000000f,
+		-0.535400f,
+		-0.266600f,
+		0.801400f,
+		0.156200f,
+		0.413800f,
+		-0.348895f,
+		-0.080891f,
+		0.348895f,
+		0.000000f,
+		-0.697800f,
+		-0.161200f,
+		0.697800f,
+		0.125000f,
+		0.448300f,
+		-0.340667f,
+		-0.133764f,
+		0.340666f,
+		0.000000f,
+		-0.681500f,
+		-0.266600f,
+		0.681500f,
+		0.125000f,
+		0.413800f,
+		-0.116639f,
+		0.453788f,
+		0.174562f,
+		0.000000f,
+		-0.234800f,
+		0.906300f,
+		0.351400f,
+		0.156200f,
+		0.862100f,
+		-0.088698f,
+		0.473826f,
+		0.132745f,
+		0.000000f,
+		-0.179100f,
+		0.946600f,
+		0.268000f,
+		0.156200f,
+		0.896600f,
+		-0.112890f,
+		0.473826f,
+		0.112889f,
+		0.000000f,
+		-0.227900f,
+		0.946600f,
+		0.227900f,
+		0.125000f,
+		0.896600f,
+		-0.116639f,
+		0.453788f,
+		0.174562f,
+		0.000000f,
+		-0.234800f,
+		0.906300f,
+		0.351400f,
+		0.156200f,
+		0.862100f,
+		-0.112890f,
+		0.473826f,
+		0.112889f,
+		0.000000f,
+		-0.227900f,
+		0.946600f,
+		0.227900f,
+		0.125000f,
+		0.896600f,
+		-0.148454f,
+		0.453788f,
+		0.148453f,
+		0.000000f,
+		-0.298900f,
+		0.906300f,
+		0.298900f,
+		0.125000f,
+		0.862100f,
+		-0.258056f,
+		-0.185069f,
+		0.386207f,
+		0.000000f,
+		-0.516300f,
+		-0.369000f,
+		0.772800f,
+		0.156200f,
+		0.379300f,
+		-0.267660f,
+		-0.133764f,
+		0.400580f,
+		0.000000f,
+		-0.535400f,
+		-0.266600f,
+		0.801400f,
+		0.156200f,
+		0.413800f,
+		-0.340667f,
+		-0.133764f,
+		0.340666f,
+		0.000000f,
+		-0.681500f,
+		-0.266600f,
+		0.681500f,
+		0.125000f,
+		0.413800f,
+		-0.258056f,
+		-0.185069f,
+		0.386207f,
+		0.000000f,
+		-0.516300f,
+		-0.369000f,
+		0.772800f,
+		0.156200f,
+		0.379300f,
+		-0.340667f,
+		-0.133764f,
+		0.340666f,
+		0.000000f,
+		-0.681500f,
+		-0.266600f,
+		0.681500f,
+		0.125000f,
+		0.413800f,
+		-0.328443f,
+		-0.185069f,
+		0.328443f,
+		0.000000f,
+		-0.657200f,
+		-0.369000f,
+		0.657200f,
+		0.125000f,
+		0.379300f,
+		-0.143213f,
+		0.428429f,
+		0.214333f,
+		0.000000f,
+		-0.287800f,
+		0.855300f,
+		0.430700f,
+		0.156200f,
+		0.827600f,
+		-0.116639f,
+		0.453788f,
+		0.174562f,
+		0.000000f,
+		-0.234800f,
+		0.906300f,
+		0.351400f,
+		0.156200f,
+		0.862100f,
+		-0.148454f,
+		0.453788f,
+		0.148453f,
+		0.000000f,
+		-0.298900f,
+		0.906300f,
+		0.298900f,
+		0.125000f,
+		0.862100f,
+		-0.143213f,
+		0.428429f,
+		0.214333f,
+		0.000000f,
+		-0.287800f,
+		0.855300f,
+		0.430700f,
+		0.156200f,
+		0.827600f,
+		-0.148454f,
+		0.453788f,
+		0.148453f,
+		0.000000f,
+		-0.298900f,
+		0.906300f,
+		0.298900f,
+		0.125000f,
+		0.862100f,
+		-0.182276f,
+		0.428429f,
+		0.182276f,
+		0.000000f,
+		-0.366300f,
+		0.855300f,
+		0.366300f,
+		0.125000f,
+		0.827600f,
+		-0.245427f,
+		-0.234204f,
+		0.367306f,
+		0.000000f,
+		-0.491300f,
+		-0.467000f,
+		0.735200f,
+		0.156200f,
+		0.344800f,
+		-0.258056f,
+		-0.185069f,
+		0.386207f,
+		0.000000f,
+		-0.516300f,
+		-0.369000f,
+		0.772800f,
+		0.156200f,
+		0.379300f,
+		-0.328443f,
+		-0.185069f,
+		0.328443f,
+		0.000000f,
+		-0.657200f,
+		-0.369000f,
+		0.657200f,
+		0.125000f,
+		0.379300f,
+		-0.245427f,
+		-0.234204f,
+		0.367306f,
+		0.000000f,
+		-0.491300f,
+		-0.467000f,
+		0.735200f,
+		0.156200f,
+		0.344800f,
+		-0.328443f,
+		-0.185069f,
+		0.328443f,
+		0.000000f,
+		-0.657200f,
+		-0.369000f,
+		0.657200f,
+		0.125000f,
+		0.379300f,
+		-0.312369f,
+		-0.234204f,
+		0.312368f,
+		0.000000f,
+		-0.625200f,
+		-0.467000f,
+		0.625200f,
+		0.125000f,
+		0.344800f,
+		-0.168108f,
+		0.398046f,
+		0.251592f,
+		0.000000f,
+		-0.337400f,
+		0.794500f,
+		0.505000f,
+		0.156200f,
+		0.793100f,
+		-0.143213f,
+		0.428429f,
+		0.214333f,
+		0.000000f,
+		-0.287800f,
+		0.855300f,
+		0.430700f,
+		0.156200f,
+		0.827600f,
+		-0.182276f,
+		0.428429f,
+		0.182276f,
+		0.000000f,
+		-0.366300f,
+		0.855300f,
+		0.366300f,
+		0.125000f,
+		0.827600f,
+		-0.168108f,
+		0.398046f,
+		0.251592f,
+		0.000000f,
+		-0.337400f,
+		0.794500f,
+		0.505000f,
+		0.156200f,
+		0.793100f,
+		-0.182276f,
+		0.428429f,
+		0.182276f,
+		0.000000f,
+		-0.366300f,
+		0.855300f,
+		0.366300f,
+		0.125000f,
+		0.827600f,
+		-0.213961f,
+		0.398046f,
+		0.213961f,
+		0.000000f,
+		-0.429400f,
+		0.794500f,
+		0.429400f,
+		0.125000f,
+		0.793100f,
+		-0.229920f,
+		-0.280594f,
+		0.344099f,
+		0.000000f,
+		-0.460400f,
+		-0.559600f,
+		0.689100f,
+		0.156200f,
+		0.310300f,
+		-0.245427f,
+		-0.234204f,
+		0.367306f,
+		0.000000f,
+		-0.491300f,
+		-0.467000f,
+		0.735200f,
+		0.156200f,
+		0.344800f,
+		-0.312369f,
+		-0.234204f,
+		0.312368f,
+		0.000000f,
+		-0.625200f,
+		-0.467000f,
+		0.625200f,
+		0.125000f,
+		0.344800f,
+		-0.229920f,
+		-0.280594f,
+		0.344099f,
+		0.000000f,
+		-0.460400f,
+		-0.559600f,
+		0.689100f,
+		0.156200f,
+		0.310300f,
+		-0.312369f,
+		-0.234204f,
+		0.312368f,
+		0.000000f,
+		-0.625200f,
+		-0.467000f,
+		0.625200f,
+		0.125000f,
+		0.344800f,
+		-0.292632f,
+		-0.280594f,
+		0.292632f,
+		0.000000f,
+		-0.586000f,
+		-0.559600f,
+		0.586000f,
+		0.125000f,
+		0.310300f,
+		-0.191033f,
+		0.362998f,
+		0.285900f,
+		0.000000f,
+		-0.383000f,
+		0.724300f,
+		0.573300f,
+		0.156200f,
+		0.758600f,
+		-0.168108f,
+		0.398046f,
+		0.251592f,
+		0.000000f,
+		-0.337400f,
+		0.794500f,
+		0.505000f,
+		0.156200f,
+		0.793100f,
+		-0.213961f,
+		0.398046f,
+		0.213961f,
+		0.000000f,
+		-0.429400f,
+		0.794500f,
+		0.429400f,
+		0.125000f,
+		0.793100f,
+		-0.191033f,
+		0.362998f,
+		0.285900f,
+		0.000000f,
+		-0.383000f,
+		0.724300f,
+		0.573300f,
+		0.156200f,
+		0.758600f,
+		-0.213961f,
+		0.398046f,
+		0.213961f,
+		0.000000f,
+		-0.429400f,
+		0.794500f,
+		0.429400f,
+		0.125000f,
+		0.793100f,
+		-0.243139f,
+		0.362998f,
+		0.243138f,
+		0.000000f,
+		-0.487500f,
+		0.724300f,
+		0.487500f,
+		0.125000f,
+		0.758600f,
+		-0.076003f,
+		0.488310f,
+		0.076003f,
+		0.000000f,
+		-0.154300f,
+		0.975900f,
+		0.154300f,
+		0.125000f,
+		0.931000f,
+		-0.038226f,
+		0.497069f,
+		0.038226f,
+		0.000000f,
+		-0.078800f,
+		0.993700f,
+		0.078800f,
+		0.125000f,
+		0.965500f,
+		-0.044949f,
+		0.497069f,
+		0.030034f,
+		0.000000f,
+		-0.092700f,
+		0.993700f,
+		0.061900f,
+		0.093700f,
+		0.965500f,
+		-0.076003f,
+		0.488310f,
+		0.076003f,
+		0.000000f,
+		-0.154300f,
+		0.975900f,
+		0.154300f,
+		0.125000f,
+		0.931000f,
+		-0.044949f,
+		0.497069f,
+		0.030034f,
+		0.000000f,
+		-0.092700f,
+		0.993700f,
+		0.061900f,
+		0.093700f,
+		0.965500f,
+		-0.089370f,
+		0.488310f,
+		0.059715f,
+		0.000000f,
+		-0.181400f,
+		0.975900f,
+		0.121200f,
+		0.093700f,
+		0.931000f,
+		-0.348895f,
+		-0.080891f,
+		0.348895f,
+		0.000000f,
+		-0.697800f,
+		-0.161200f,
+		0.697800f,
+		0.125000f,
+		0.448300f,
+		-0.353035f,
+		-0.027069f,
+		0.353034f,
+		0.000000f,
+		-0.706100f,
+		-0.054000f,
+		0.706100f,
+		0.125000f,
+		0.482800f,
+		-0.415125f,
+		-0.027069f,
+		0.277377f,
+		0.000000f,
+		-0.830300f,
+		-0.054000f,
+		0.554700f,
+		0.093700f,
+		0.482800f,
+		-0.348895f,
+		-0.080891f,
+		0.348895f,
+		0.000000f,
+		-0.697800f,
+		-0.161200f,
+		0.697800f,
+		0.125000f,
+		0.448300f,
+		-0.415125f,
+		-0.027069f,
+		0.277377f,
+		0.000000f,
+		-0.830300f,
+		-0.054000f,
+		0.554700f,
+		0.093700f,
+		0.482800f,
+		-0.410258f,
+		-0.080891f,
+		0.274125f,
+		0.000000f,
+		-0.820600f,
+		-0.161200f,
+		0.548300f,
+		0.093700f,
+		0.448300f,
+		-0.038226f,
+		-0.497069f,
+		0.038226f,
+		0.000000f,
+		-0.078800f,
+		-0.993700f,
+		0.078800f,
+		0.125000f,
+		0.034500f,
+		-0.076004f,
+		-0.488310f,
+		0.076003f,
+		0.000000f,
+		-0.154300f,
+		-0.975900f,
+		0.154300f,
+		0.125000f,
+		0.069000f,
+		-0.089371f,
+		-0.488310f,
+		0.059715f,
+		0.000000f,
+		-0.181400f,
+		-0.975900f,
+		0.121200f,
+		0.093700f,
+		0.069000f,
+		-0.038226f,
+		-0.497069f,
+		0.038226f,
+		0.000000f,
+		-0.078800f,
+		-0.993700f,
+		0.078800f,
+		0.125000f,
+		0.034500f,
+		-0.089371f,
+		-0.488310f,
+		0.059715f,
+		0.000000f,
+		-0.181400f,
+		-0.975900f,
+		0.121200f,
+		0.093700f,
+		0.069000f,
+		-0.044949f,
+		-0.497069f,
+		0.030034f,
+		0.000000f,
+		-0.092700f,
+		-0.993700f,
+		0.061900f,
+		0.093700f,
+		0.034500f,
+		-0.112890f,
+		0.473826f,
+		0.112889f,
+		0.000000f,
+		-0.227900f,
+		0.946600f,
+		0.227900f,
+		0.125000f,
+		0.896600f,
+		-0.076003f,
+		0.488310f,
+		0.076003f,
+		0.000000f,
+		-0.154300f,
+		0.975900f,
+		0.154300f,
+		0.125000f,
+		0.931000f,
+		-0.089370f,
+		0.488310f,
+		0.059715f,
+		0.000000f,
+		-0.181400f,
+		0.975900f,
+		0.121200f,
+		0.093700f,
+		0.931000f,
+		-0.112890f,
+		0.473826f,
+		0.112889f,
+		0.000000f,
+		-0.227900f,
+		0.946600f,
+		0.227900f,
+		0.125000f,
+		0.896600f,
+		-0.089370f,
+		0.488310f,
+		0.059715f,
+		0.000000f,
+		-0.181400f,
+		0.975900f,
+		0.121200f,
+		0.093700f,
+		0.931000f,
+		-0.132745f,
+		0.473826f,
+		0.088697f,
+		0.000000f,
+		-0.268000f,
+		0.946600f,
+		0.179100f,
+		0.093700f,
+		0.896600f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.411700f,
+		0.051000f,
+		-0.038226f,
+		-0.497069f,
+		0.038226f,
+		0.000000f,
+		-0.078800f,
+		-0.993700f,
+		0.078800f,
+		0.420900f,
+		0.053800f,
+		-0.044949f,
+		-0.497069f,
+		0.030034f,
+		0.000000f,
+		-0.092700f,
+		-0.993700f,
+		0.061900f,
+		0.418200f,
+		0.053800f,
+		-0.148454f,
+		0.453788f,
+		0.148453f,
+		0.000000f,
+		-0.298900f,
+		0.906300f,
+		0.298900f,
+		0.125000f,
+		0.862100f,
+		-0.112890f,
+		0.473826f,
+		0.112889f,
+		0.000000f,
+		-0.227900f,
+		0.946600f,
+		0.227900f,
+		0.125000f,
+		0.896600f,
+		-0.132745f,
+		0.473826f,
+		0.088697f,
+		0.000000f,
+		-0.268000f,
+		0.946600f,
+		0.179100f,
+		0.093700f,
+		0.896600f,
+		-0.148454f,
+		0.453788f,
+		0.148453f,
+		0.000000f,
+		-0.298900f,
+		0.906300f,
+		0.298900f,
+		0.125000f,
+		0.862100f,
+		-0.132745f,
+		0.473826f,
+		0.088697f,
+		0.000000f,
+		-0.268000f,
+		0.946600f,
+		0.179100f,
+		0.093700f,
+		0.896600f,
+		-0.174562f,
+		0.453788f,
+		0.116638f,
+		0.000000f,
+		-0.351400f,
+		0.906300f,
+		0.234800f,
+		0.093700f,
+		0.862100f,
+		-0.182276f,
+		0.428429f,
+		0.182276f,
+		0.000000f,
+		-0.366300f,
+		0.855300f,
+		0.366300f,
+		0.125000f,
+		0.827600f,
+		-0.148454f,
+		0.453788f,
+		0.148453f,
+		0.000000f,
+		-0.298900f,
+		0.906300f,
+		0.298900f,
+		0.125000f,
+		0.862100f,
+		-0.174562f,
+		0.453788f,
+		0.116638f,
+		0.000000f,
+		-0.351400f,
+		0.906300f,
+		0.234800f,
+		0.093700f,
+		0.862100f,
+		-0.182276f,
+		0.428429f,
+		0.182276f,
+		0.000000f,
+		-0.366300f,
+		0.855300f,
+		0.366300f,
+		0.125000f,
+		0.827600f,
+		-0.174562f,
+		0.453788f,
+		0.116638f,
+		0.000000f,
+		-0.351400f,
+		0.906300f,
+		0.234800f,
+		0.093700f,
+		0.862100f,
+		-0.214334f,
+		0.428429f,
+		0.143213f,
+		0.000000f,
+		-0.430700f,
+		0.855300f,
+		0.287800f,
+		0.093700f,
+		0.827600f,
+		-0.340667f,
+		-0.133764f,
+		0.340666f,
+		0.000000f,
+		-0.681500f,
+		-0.266600f,
+		0.681500f,
+		0.125000f,
+		0.413800f,
+		-0.348895f,
+		-0.080891f,
+		0.348895f,
+		0.000000f,
+		-0.697800f,
+		-0.161200f,
+		0.697800f,
+		0.125000f,
+		0.448300f,
+		-0.410258f,
+		-0.080891f,
+		0.274125f,
+		0.000000f,
+		-0.820600f,
+		-0.161200f,
+		0.548300f,
+		0.093700f,
+		0.448300f,
+		-0.340667f,
+		-0.133764f,
+		0.340666f,
+		0.000000f,
+		-0.681500f,
+		-0.266600f,
+		0.681500f,
+		0.125000f,
+		0.413800f,
+		-0.410258f,
+		-0.080891f,
+		0.274125f,
+		0.000000f,
+		-0.820600f,
+		-0.161200f,
+		0.548300f,
+		0.093700f,
+		0.448300f,
+		-0.400581f,
+		-0.133764f,
+		0.267659f,
+		0.000000f,
+		-0.801400f,
+		-0.266600f,
+		0.535400f,
+		0.093700f,
+		0.413800f,
+		-0.213961f,
+		0.398046f,
+		0.213961f,
+		0.000000f,
+		-0.429400f,
+		0.794500f,
+		0.429400f,
+		0.125000f,
+		0.793100f,
+		-0.182276f,
+		0.428429f,
+		0.182276f,
+		0.000000f,
+		-0.366300f,
+		0.855300f,
+		0.366300f,
+		0.125000f,
+		0.827600f,
+		-0.214334f,
+		0.428429f,
+		0.143213f,
+		0.000000f,
+		-0.430700f,
+		0.855300f,
+		0.287800f,
+		0.093700f,
+		0.827600f,
+		-0.213961f,
+		0.398046f,
+		0.213961f,
+		0.000000f,
+		-0.429400f,
+		0.794500f,
+		0.429400f,
+		0.125000f,
+		0.793100f,
+		-0.214334f,
+		0.428429f,
+		0.143213f,
+		0.000000f,
+		-0.430700f,
+		0.855300f,
+		0.287800f,
+		0.093700f,
+		0.827600f,
+		-0.251592f,
+		0.398046f,
+		0.168108f,
+		0.000000f,
+		-0.505000f,
+		0.794500f,
+		0.337400f,
+		0.093700f,
+		0.793100f,
+		-0.328443f,
+		-0.185069f,
+		0.328443f,
+		0.000000f,
+		-0.657200f,
+		-0.369000f,
+		0.657200f,
+		0.125000f,
+		0.379300f,
+		-0.340667f,
+		-0.133764f,
+		0.340666f,
+		0.000000f,
+		-0.681500f,
+		-0.266600f,
+		0.681500f,
+		0.125000f,
+		0.413800f,
+		-0.400581f,
+		-0.133764f,
+		0.267659f,
+		0.000000f,
+		-0.801400f,
+		-0.266600f,
+		0.535400f,
+		0.093700f,
+		0.413800f,
+		-0.328443f,
+		-0.185069f,
+		0.328443f,
+		0.000000f,
+		-0.657200f,
+		-0.369000f,
+		0.657200f,
+		0.125000f,
+		0.379300f,
+		-0.400581f,
+		-0.133764f,
+		0.267659f,
+		0.000000f,
+		-0.801400f,
+		-0.266600f,
+		0.535400f,
+		0.093700f,
+		0.413800f,
+		-0.386208f,
+		-0.185069f,
+		0.258056f,
+		0.000000f,
+		-0.772800f,
+		-0.369000f,
+		0.516300f,
+		0.093700f,
+		0.379300f,
+		-0.243139f,
+		0.362998f,
+		0.243138f,
+		0.000000f,
+		-0.487500f,
+		0.724300f,
+		0.487500f,
+		0.125000f,
+		0.758600f,
+		-0.213961f,
+		0.398046f,
+		0.213961f,
+		0.000000f,
+		-0.429400f,
+		0.794500f,
+		0.429400f,
+		0.125000f,
+		0.793100f,
+		-0.251592f,
+		0.398046f,
+		0.168108f,
+		0.000000f,
+		-0.505000f,
+		0.794500f,
+		0.337400f,
+		0.093700f,
+		0.793100f,
+		-0.243139f,
+		0.362998f,
+		0.243138f,
+		0.000000f,
+		-0.487500f,
+		0.724300f,
+		0.487500f,
+		0.125000f,
+		0.758600f,
+		-0.251592f,
+		0.398046f,
+		0.168108f,
+		0.000000f,
+		-0.505000f,
+		0.794500f,
+		0.337400f,
+		0.093700f,
+		0.793100f,
+		-0.285901f,
+		0.362998f,
+		0.191032f,
+		0.000000f,
+		-0.573300f,
+		0.724300f,
+		0.383000f,
+		0.093700f,
+		0.758600f,
+		-0.312369f,
+		-0.234204f,
+		0.312368f,
+		0.000000f,
+		-0.625200f,
+		-0.467000f,
+		0.625200f,
+		0.125000f,
+		0.344800f,
+		-0.328443f,
+		-0.185069f,
+		0.328443f,
+		0.000000f,
+		-0.657200f,
+		-0.369000f,
+		0.657200f,
+		0.125000f,
+		0.379300f,
+		-0.386208f,
+		-0.185069f,
+		0.258056f,
+		0.000000f,
+		-0.772800f,
+		-0.369000f,
+		0.516300f,
+		0.093700f,
+		0.379300f,
+		-0.312369f,
+		-0.234204f,
+		0.312368f,
+		0.000000f,
+		-0.625200f,
+		-0.467000f,
+		0.625200f,
+		0.125000f,
+		0.344800f,
+		-0.386208f,
+		-0.185069f,
+		0.258056f,
+		0.000000f,
+		-0.772800f,
+		-0.369000f,
+		0.516300f,
+		0.093700f,
+		0.379300f,
+		-0.367307f,
+		-0.234204f,
+		0.245426f,
+		0.000000f,
+		-0.735200f,
+		-0.467000f,
+		0.491300f,
+		0.093700f,
+		0.344800f,
+		-0.269465f,
+		0.323693f,
+		0.269464f,
+		0.000000f,
+		-0.539900f,
+		0.645700f,
+		0.539900f,
+		0.125000f,
+		0.724100f,
+		-0.243139f,
+		0.362998f,
+		0.243138f,
+		0.000000f,
+		-0.487500f,
+		0.724300f,
+		0.487500f,
+		0.125000f,
+		0.758600f,
+		-0.285901f,
+		0.362998f,
+		0.191032f,
+		0.000000f,
+		-0.573300f,
+		0.724300f,
+		0.383000f,
+		0.093700f,
+		0.758600f,
+		-0.269465f,
+		0.323693f,
+		0.269464f,
+		0.000000f,
+		-0.539900f,
+		0.645700f,
+		0.539900f,
+		0.125000f,
+		0.724100f,
+		-0.285901f,
+		0.362998f,
+		0.191032f,
+		0.000000f,
+		-0.573300f,
+		0.724300f,
+		0.383000f,
+		0.093700f,
+		0.758600f,
+		-0.316857f,
+		0.323693f,
+		0.211717f,
+		0.000000f,
+		-0.634900f,
+		0.645700f,
+		0.424200f,
+		0.093700f,
+		0.724100f,
+		-0.292632f,
+		-0.280594f,
+		0.292632f,
+		0.000000f,
+		-0.586000f,
+		-0.559600f,
+		0.586000f,
+		0.125000f,
+		0.310300f,
+		-0.312369f,
+		-0.234204f,
+		0.312368f,
+		0.000000f,
+		-0.625200f,
+		-0.467000f,
+		0.625200f,
+		0.125000f,
+		0.344800f,
+		-0.367307f,
+		-0.234204f,
+		0.245426f,
+		0.000000f,
+		-0.735200f,
+		-0.467000f,
+		0.491300f,
+		0.093700f,
+		0.344800f,
+		-0.292632f,
+		-0.280594f,
+		0.292632f,
+		0.000000f,
+		-0.586000f,
+		-0.559600f,
+		0.586000f,
+		0.125000f,
+		0.310300f,
+		-0.367307f,
+		-0.234204f,
+		0.245426f,
+		0.000000f,
+		-0.735200f,
+		-0.467000f,
+		0.491300f,
+		0.093700f,
+		0.344800f,
+		-0.344099f,
+		-0.280594f,
+		0.229919f,
+		0.000000f,
+		-0.689100f,
+		-0.559600f,
+		0.460400f,
+		0.093700f,
+		0.310300f,
+		-0.292632f,
+		0.280594f,
+		0.292632f,
+		0.000000f,
+		-0.586000f,
+		0.559600f,
+		0.586000f,
+		0.125000f,
+		0.689700f,
+		-0.269465f,
+		0.323693f,
+		0.269464f,
+		0.000000f,
+		-0.539900f,
+		0.645700f,
+		0.539900f,
+		0.125000f,
+		0.724100f,
+		-0.316857f,
+		0.323693f,
+		0.211717f,
+		0.000000f,
+		-0.634900f,
+		0.645700f,
+		0.424200f,
+		0.093700f,
+		0.724100f,
+		-0.292632f,
+		0.280594f,
+		0.292632f,
+		0.000000f,
+		-0.586000f,
+		0.559600f,
+		0.586000f,
+		0.125000f,
+		0.689700f,
+		-0.316857f,
+		0.323693f,
+		0.211717f,
+		0.000000f,
+		-0.634900f,
+		0.645700f,
+		0.424200f,
+		0.093700f,
+		0.724100f,
+		-0.344099f,
+		0.280594f,
+		0.229919f,
+		0.000000f,
+		-0.689100f,
+		0.559600f,
+		0.460400f,
+		0.093700f,
+		0.689700f,
+		-0.269465f,
+		-0.323693f,
+		0.269464f,
+		0.000000f,
+		-0.539900f,
+		-0.645700f,
+		0.539900f,
+		0.125000f,
+		0.275900f,
+		-0.292632f,
+		-0.280594f,
+		0.292632f,
+		0.000000f,
+		-0.586000f,
+		-0.559600f,
+		0.586000f,
+		0.125000f,
+		0.310300f,
+		-0.344099f,
+		-0.280594f,
+		0.229919f,
+		0.000000f,
+		-0.689100f,
+		-0.559600f,
+		0.460400f,
+		0.093700f,
+		0.310300f,
+		-0.269465f,
+		-0.323693f,
+		0.269464f,
+		0.000000f,
+		-0.539900f,
+		-0.645700f,
+		0.539900f,
+		0.125000f,
+		0.275900f,
+		-0.344099f,
+		-0.280594f,
+		0.229919f,
+		0.000000f,
+		-0.689100f,
+		-0.559600f,
+		0.460400f,
+		0.093700f,
+		0.310300f,
+		-0.316857f,
+		-0.323693f,
+		0.211717f,
+		0.000000f,
+		-0.634900f,
+		-0.645700f,
+		0.424200f,
+		0.093700f,
+		0.275900f,
+		-0.312369f,
+		0.234204f,
+		0.312368f,
+		0.000000f,
+		-0.625200f,
+		0.467000f,
+		0.625200f,
+		0.125000f,
+		0.655200f,
+		-0.292632f,
+		0.280594f,
+		0.292632f,
+		0.000000f,
+		-0.586000f,
+		0.559600f,
+		0.586000f,
+		0.125000f,
+		0.689700f,
+		-0.344099f,
+		0.280594f,
+		0.229919f,
+		0.000000f,
+		-0.689100f,
+		0.559600f,
+		0.460400f,
+		0.093700f,
+		0.689700f,
+		-0.312369f,
+		0.234204f,
+		0.312368f,
+		0.000000f,
+		-0.625200f,
+		0.467000f,
+		0.625200f,
+		0.125000f,
+		0.655200f,
+		-0.344099f,
+		0.280594f,
+		0.229919f,
+		0.000000f,
+		-0.689100f,
+		0.559600f,
+		0.460400f,
+		0.093700f,
+		0.689700f,
+		-0.367307f,
+		0.234204f,
+		0.245426f,
+		0.000000f,
+		-0.735200f,
+		0.467000f,
+		0.491300f,
+		0.093700f,
+		0.655200f,
+		-0.243139f,
+		-0.362998f,
+		0.243138f,
+		0.000000f,
+		-0.487500f,
+		-0.724300f,
+		0.487500f,
+		0.125000f,
+		0.241400f,
+		-0.269465f,
+		-0.323693f,
+		0.269464f,
+		0.000000f,
+		-0.539900f,
+		-0.645700f,
+		0.539900f,
+		0.125000f,
+		0.275900f,
+		-0.316857f,
+		-0.323693f,
+		0.211717f,
+		0.000000f,
+		-0.634900f,
+		-0.645700f,
+		0.424200f,
+		0.093700f,
+		0.275900f,
+		-0.243139f,
+		-0.362998f,
+		0.243138f,
+		0.000000f,
+		-0.487500f,
+		-0.724300f,
+		0.487500f,
+		0.125000f,
+		0.241400f,
+		-0.316857f,
+		-0.323693f,
+		0.211717f,
+		0.000000f,
+		-0.634900f,
+		-0.645700f,
+		0.424200f,
+		0.093700f,
+		0.275900f,
+		-0.285901f,
+		-0.362998f,
+		0.191032f,
+		0.000000f,
+		-0.573300f,
+		-0.724300f,
+		0.383000f,
+		0.093700f,
+		0.241400f,
+		-0.328443f,
+		0.185069f,
+		0.328443f,
+		0.000000f,
+		-0.657200f,
+		0.369000f,
+		0.657200f,
+		0.125000f,
+		0.620700f,
+		-0.312369f,
+		0.234204f,
+		0.312368f,
+		0.000000f,
+		-0.625200f,
+		0.467000f,
+		0.625200f,
+		0.125000f,
+		0.655200f,
+		-0.367307f,
+		0.234204f,
+		0.245426f,
+		0.000000f,
+		-0.735200f,
+		0.467000f,
+		0.491300f,
+		0.093700f,
+		0.655200f,
+		-0.328443f,
+		0.185069f,
+		0.328443f,
+		0.000000f,
+		-0.657200f,
+		0.369000f,
+		0.657200f,
+		0.125000f,
+		0.620700f,
+		-0.367307f,
+		0.234204f,
+		0.245426f,
+		0.000000f,
+		-0.735200f,
+		0.467000f,
+		0.491300f,
+		0.093700f,
+		0.655200f,
+		-0.386208f,
+		0.185069f,
+		0.258056f,
+		0.000000f,
+		-0.772800f,
+		0.369000f,
+		0.516300f,
+		0.093700f,
+		0.620700f,
+		-0.213961f,
+		-0.398046f,
+		0.213961f,
+		0.000000f,
+		-0.429400f,
+		-0.794500f,
+		0.429400f,
+		0.125000f,
+		0.206900f,
+		-0.243139f,
+		-0.362998f,
+		0.243138f,
+		0.000000f,
+		-0.487500f,
+		-0.724300f,
+		0.487500f,
+		0.125000f,
+		0.241400f,
+		-0.285901f,
+		-0.362998f,
+		0.191032f,
+		0.000000f,
+		-0.573300f,
+		-0.724300f,
+		0.383000f,
+		0.093700f,
+		0.241400f,
+		-0.213961f,
+		-0.398046f,
+		0.213961f,
+		0.000000f,
+		-0.429400f,
+		-0.794500f,
+		0.429400f,
+		0.125000f,
+		0.206900f,
+		-0.285901f,
+		-0.362998f,
+		0.191032f,
+		0.000000f,
+		-0.573300f,
+		-0.724300f,
+		0.383000f,
+		0.093700f,
+		0.241400f,
+		-0.251592f,
+		-0.398046f,
+		0.168108f,
+		0.000000f,
+		-0.505000f,
+		-0.794500f,
+		0.337400f,
+		0.093700f,
+		0.206900f,
+		-0.340667f,
+		0.133764f,
+		0.340666f,
+		0.000000f,
+		-0.681500f,
+		0.266600f,
+		0.681500f,
+		0.125000f,
+		0.586200f,
+		-0.328443f,
+		0.185069f,
+		0.328443f,
+		0.000000f,
+		-0.657200f,
+		0.369000f,
+		0.657200f,
+		0.125000f,
+		0.620700f,
+		-0.386208f,
+		0.185069f,
+		0.258056f,
+		0.000000f,
+		-0.772800f,
+		0.369000f,
+		0.516300f,
+		0.093700f,
+		0.620700f,
+		-0.340667f,
+		0.133764f,
+		0.340666f,
+		0.000000f,
+		-0.681500f,
+		0.266600f,
+		0.681500f,
+		0.125000f,
+		0.586200f,
+		-0.386208f,
+		0.185069f,
+		0.258056f,
+		0.000000f,
+		-0.772800f,
+		0.369000f,
+		0.516300f,
+		0.093700f,
+		0.620700f,
+		-0.400581f,
+		0.133764f,
+		0.267659f,
+		0.000000f,
+		-0.801400f,
+		0.266600f,
+		0.535400f,
+		0.093700f,
+		0.586200f,
+		-0.182276f,
+		-0.428429f,
+		0.182276f,
+		0.000000f,
+		-0.366300f,
+		-0.855300f,
+		0.366300f,
+		0.125000f,
+		0.172400f,
+		-0.213961f,
+		-0.398046f,
+		0.213961f,
+		0.000000f,
+		-0.429400f,
+		-0.794500f,
+		0.429400f,
+		0.125000f,
+		0.206900f,
+		-0.251592f,
+		-0.398046f,
+		0.168108f,
+		0.000000f,
+		-0.505000f,
+		-0.794500f,
+		0.337400f,
+		0.093700f,
+		0.206900f,
+		-0.182276f,
+		-0.428429f,
+		0.182276f,
+		0.000000f,
+		-0.366300f,
+		-0.855300f,
+		0.366300f,
+		0.125000f,
+		0.172400f,
+		-0.251592f,
+		-0.398046f,
+		0.168108f,
+		0.000000f,
+		-0.505000f,
+		-0.794500f,
+		0.337400f,
+		0.093700f,
+		0.206900f,
+		-0.214334f,
+		-0.428429f,
+		0.143213f,
+		0.000000f,
+		-0.430700f,
+		-0.855300f,
+		0.287800f,
+		0.093700f,
+		0.172400f,
+		-0.348895f,
+		0.080891f,
+		0.348895f,
+		0.000000f,
+		-0.697800f,
+		0.161200f,
+		0.697800f,
+		0.125000f,
+		0.551700f,
+		-0.340667f,
+		0.133764f,
+		0.340666f,
+		0.000000f,
+		-0.681500f,
+		0.266600f,
+		0.681500f,
+		0.125000f,
+		0.586200f,
+		-0.400581f,
+		0.133764f,
+		0.267659f,
+		0.000000f,
+		-0.801400f,
+		0.266600f,
+		0.535400f,
+		0.093700f,
+		0.586200f,
+		-0.348895f,
+		0.080891f,
+		0.348895f,
+		0.000000f,
+		-0.697800f,
+		0.161200f,
+		0.697800f,
+		0.125000f,
+		0.551700f,
+		-0.400581f,
+		0.133764f,
+		0.267659f,
+		0.000000f,
+		-0.801400f,
+		0.266600f,
+		0.535400f,
+		0.093700f,
+		0.586200f,
+		-0.410258f,
+		0.080891f,
+		0.274125f,
+		0.000000f,
+		-0.820600f,
+		0.161200f,
+		0.548300f,
+		0.093700f,
+		0.551700f,
+		-0.148454f,
+		-0.453788f,
+		0.148453f,
+		0.000000f,
+		-0.298900f,
+		-0.906300f,
+		0.298900f,
+		0.125000f,
+		0.137900f,
+		-0.182276f,
+		-0.428429f,
+		0.182276f,
+		0.000000f,
+		-0.366300f,
+		-0.855300f,
+		0.366300f,
+		0.125000f,
+		0.172400f,
+		-0.214334f,
+		-0.428429f,
+		0.143213f,
+		0.000000f,
+		-0.430700f,
+		-0.855300f,
+		0.287800f,
+		0.093700f,
+		0.172400f,
+		-0.148454f,
+		-0.453788f,
+		0.148453f,
+		0.000000f,
+		-0.298900f,
+		-0.906300f,
+		0.298900f,
+		0.125000f,
+		0.137900f,
+		-0.214334f,
+		-0.428429f,
+		0.143213f,
+		0.000000f,
+		-0.430700f,
+		-0.855300f,
+		0.287800f,
+		0.093700f,
+		0.172400f,
+		-0.174562f,
+		-0.453788f,
+		0.116638f,
+		0.000000f,
+		-0.351400f,
+		-0.906300f,
+		0.234800f,
+		0.093700f,
+		0.137900f,
+		-0.353035f,
+		0.027069f,
+		0.353034f,
+		0.000000f,
+		-0.706100f,
+		0.054000f,
+		0.706100f,
+		0.125000f,
+		0.517200f,
+		-0.348895f,
+		0.080891f,
+		0.348895f,
+		0.000000f,
+		-0.697800f,
+		0.161200f,
+		0.697800f,
+		0.125000f,
+		0.551700f,
+		-0.410258f,
+		0.080891f,
+		0.274125f,
+		0.000000f,
+		-0.820600f,
+		0.161200f,
+		0.548300f,
+		0.093700f,
+		0.551700f,
+		-0.353035f,
+		0.027069f,
+		0.353034f,
+		0.000000f,
+		-0.706100f,
+		0.054000f,
+		0.706100f,
+		0.125000f,
+		0.517200f,
+		-0.410258f,
+		0.080891f,
+		0.274125f,
+		0.000000f,
+		-0.820600f,
+		0.161200f,
+		0.548300f,
+		0.093700f,
+		0.551700f,
+		-0.415125f,
+		0.027069f,
+		0.277377f,
+		0.000000f,
+		-0.830300f,
+		0.054000f,
+		0.554700f,
+		0.093700f,
+		0.517200f,
+		-0.112890f,
+		-0.473826f,
+		0.112890f,
+		0.000000f,
+		-0.227900f,
+		-0.946600f,
+		0.227900f,
+		0.125000f,
+		0.103400f,
+		-0.148454f,
+		-0.453788f,
+		0.148453f,
+		0.000000f,
+		-0.298900f,
+		-0.906300f,
+		0.298900f,
+		0.125000f,
+		0.137900f,
+		-0.174562f,
+		-0.453788f,
+		0.116638f,
+		0.000000f,
+		-0.351400f,
+		-0.906300f,
+		0.234800f,
+		0.093700f,
+		0.137900f,
+		-0.112890f,
+		-0.473826f,
+		0.112890f,
+		0.000000f,
+		-0.227900f,
+		-0.946600f,
+		0.227900f,
+		0.125000f,
+		0.103400f,
+		-0.174562f,
+		-0.453788f,
+		0.116638f,
+		0.000000f,
+		-0.351400f,
+		-0.906300f,
+		0.234800f,
+		0.093700f,
+		0.137900f,
+		-0.132745f,
+		-0.473826f,
+		0.088697f,
+		0.000000f,
+		-0.268000f,
+		-0.946600f,
+		0.179100f,
+		0.093700f,
+		0.103400f,
+		-0.038226f,
+		0.497069f,
+		0.038226f,
+		0.000000f,
+		-0.078800f,
+		0.993700f,
+		0.078800f,
+		0.478000f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.482000f,
+		0.960300f,
+		-0.044949f,
+		0.497069f,
+		0.030034f,
+		0.000000f,
+		-0.092700f,
+		0.993700f,
+		0.061900f,
+		0.479800f,
+		0.962300f,
+		-0.353035f,
+		-0.027069f,
+		0.353034f,
+		0.000000f,
+		-0.706100f,
+		-0.054000f,
+		0.706100f,
+		0.125000f,
+		0.482800f,
+		-0.353035f,
+		0.027069f,
+		0.353034f,
+		0.000000f,
+		-0.706100f,
+		0.054000f,
+		0.706100f,
+		0.125000f,
+		0.517200f,
+		-0.415125f,
+		0.027069f,
+		0.277377f,
+		0.000000f,
+		-0.830300f,
+		0.054000f,
+		0.554700f,
+		0.093700f,
+		0.517200f,
+		-0.353035f,
+		-0.027069f,
+		0.353034f,
+		0.000000f,
+		-0.706100f,
+		-0.054000f,
+		0.706100f,
+		0.125000f,
+		0.482800f,
+		-0.415125f,
+		0.027069f,
+		0.277377f,
+		0.000000f,
+		-0.830300f,
+		0.054000f,
+		0.554700f,
+		0.093700f,
+		0.517200f,
+		-0.415125f,
+		-0.027069f,
+		0.277377f,
+		0.000000f,
+		-0.830300f,
+		-0.054000f,
+		0.554700f,
+		0.093700f,
+		0.482800f,
+		-0.076004f,
+		-0.488310f,
+		0.076003f,
+		0.000000f,
+		-0.154300f,
+		-0.975900f,
+		0.154300f,
+		0.125000f,
+		0.069000f,
+		-0.112890f,
+		-0.473826f,
+		0.112890f,
+		0.000000f,
+		-0.227900f,
+		-0.946600f,
+		0.227900f,
+		0.125000f,
+		0.103400f,
+		-0.132745f,
+		-0.473826f,
+		0.088697f,
+		0.000000f,
+		-0.268000f,
+		-0.946600f,
+		0.179100f,
+		0.093700f,
+		0.103400f,
+		-0.076004f,
+		-0.488310f,
+		0.076003f,
+		0.000000f,
+		-0.154300f,
+		-0.975900f,
+		0.154300f,
+		0.125000f,
+		0.069000f,
+		-0.132745f,
+		-0.473826f,
+		0.088697f,
+		0.000000f,
+		-0.268000f,
+		-0.946600f,
+		0.179100f,
+		0.093700f,
+		0.103400f,
+		-0.089371f,
+		-0.488310f,
+		0.059715f,
+		0.000000f,
+		-0.181400f,
+		-0.975900f,
+		0.121200f,
+		0.093700f,
+		0.069000f,
+		-0.285901f,
+		-0.362998f,
+		0.191032f,
+		0.000000f,
+		-0.573300f,
+		-0.724300f,
+		0.383000f,
+		0.093700f,
+		0.241400f,
+		-0.316857f,
+		-0.323693f,
+		0.211717f,
+		0.000000f,
+		-0.634900f,
+		-0.645700f,
+		0.424200f,
+		0.093700f,
+		0.275900f,
+		-0.352073f,
+		-0.323693f,
+		0.145833f,
+		0.000000f,
+		-0.705400f,
+		-0.645700f,
+		0.292200f,
+		0.062500f,
+		0.275900f,
+		-0.285901f,
+		-0.362998f,
+		0.191032f,
+		0.000000f,
+		-0.573300f,
+		-0.724300f,
+		0.383000f,
+		0.093700f,
+		0.241400f,
+		-0.352073f,
+		-0.323693f,
+		0.145833f,
+		0.000000f,
+		-0.705400f,
+		-0.645700f,
+		0.292200f,
+		0.062500f,
+		0.275900f,
+		-0.317676f,
+		-0.362998f,
+		0.131585f,
+		0.000000f,
+		-0.637000f,
+		-0.724300f,
+		0.263800f,
+		0.062500f,
+		0.241400f,
+		-0.344099f,
+		0.280594f,
+		0.229919f,
+		0.000000f,
+		-0.689100f,
+		0.559600f,
+		0.460400f,
+		0.093700f,
+		0.689700f,
+		-0.316857f,
+		0.323693f,
+		0.211717f,
+		0.000000f,
+		-0.634900f,
+		0.645700f,
+		0.424200f,
+		0.093700f,
+		0.724100f,
+		-0.352073f,
+		0.323693f,
+		0.145833f,
+		0.000000f,
+		-0.705400f,
+		0.645700f,
+		0.292200f,
+		0.062500f,
+		0.724100f,
+		-0.344099f,
+		0.280594f,
+		0.229919f,
+		0.000000f,
+		-0.689100f,
+		0.559600f,
+		0.460400f,
+		0.093700f,
+		0.689700f,
+		-0.352073f,
+		0.323693f,
+		0.145833f,
+		0.000000f,
+		-0.705400f,
+		0.645700f,
+		0.292200f,
+		0.062500f,
+		0.724100f,
+		-0.382342f,
+		0.280594f,
+		0.158371f,
+		0.000000f,
+		-0.765600f,
+		0.559600f,
+		0.317100f,
+		0.062500f,
+		0.689700f,
+		-0.251592f,
+		-0.398046f,
+		0.168108f,
+		0.000000f,
+		-0.505000f,
+		-0.794500f,
+		0.337400f,
+		0.093700f,
+		0.206900f,
+		-0.285901f,
+		-0.362998f,
+		0.191032f,
+		0.000000f,
+		-0.573300f,
+		-0.724300f,
+		0.383000f,
+		0.093700f,
+		0.241400f,
+		-0.317676f,
+		-0.362998f,
+		0.131585f,
+		0.000000f,
+		-0.637000f,
+		-0.724300f,
+		0.263800f,
+		0.062500f,
+		0.241400f,
+		-0.251592f,
+		-0.398046f,
+		0.168108f,
+		0.000000f,
+		-0.505000f,
+		-0.794500f,
+		0.337400f,
+		0.093700f,
+		0.206900f,
+		-0.317676f,
+		-0.362998f,
+		0.131585f,
+		0.000000f,
+		-0.637000f,
+		-0.724300f,
+		0.263800f,
+		0.062500f,
+		0.241400f,
+		-0.279554f,
+		-0.398046f,
+		0.115795f,
+		0.000000f,
+		-0.561100f,
+		-0.794500f,
+		0.232400f,
+		0.062500f,
+		0.206900f,
+		-0.367307f,
+		0.234204f,
+		0.245426f,
+		0.000000f,
+		-0.735200f,
+		0.467000f,
+		0.491300f,
+		0.093700f,
+		0.655200f,
+		-0.344099f,
+		0.280594f,
+		0.229919f,
+		0.000000f,
+		-0.689100f,
+		0.559600f,
+		0.460400f,
+		0.093700f,
+		0.689700f,
+		-0.382342f,
+		0.280594f,
+		0.158371f,
+		0.000000f,
+		-0.765600f,
+		0.559600f,
+		0.317100f,
+		0.062500f,
+		0.689700f,
+		-0.367307f,
+		0.234204f,
+		0.245426f,
+		0.000000f,
+		-0.735200f,
+		0.467000f,
+		0.491300f,
+		0.093700f,
+		0.655200f,
+		-0.382342f,
+		0.280594f,
+		0.158371f,
+		0.000000f,
+		-0.765600f,
+		0.559600f,
+		0.317100f,
+		0.062500f,
+		0.689700f,
+		-0.408129f,
+		0.234204f,
+		0.169052f,
+		0.000000f,
+		-0.816900f,
+		0.467000f,
+		0.338400f,
+		0.062500f,
+		0.655200f,
+		-0.214334f,
+		-0.428429f,
+		0.143213f,
+		0.000000f,
+		-0.430700f,
+		-0.855300f,
+		0.287800f,
+		0.093700f,
+		0.172400f,
+		-0.251592f,
+		-0.398046f,
+		0.168108f,
+		0.000000f,
+		-0.505000f,
+		-0.794500f,
+		0.337400f,
+		0.093700f,
+		0.206900f,
+		-0.279554f,
+		-0.398046f,
+		0.115795f,
+		0.000000f,
+		-0.561100f,
+		-0.794500f,
+		0.232400f,
+		0.062500f,
+		0.206900f,
+		-0.214334f,
+		-0.428429f,
+		0.143213f,
+		0.000000f,
+		-0.430700f,
+		-0.855300f,
+		0.287800f,
+		0.093700f,
+		0.172400f,
+		-0.279554f,
+		-0.398046f,
+		0.115795f,
+		0.000000f,
+		-0.561100f,
+		-0.794500f,
+		0.232400f,
+		0.062500f,
+		0.206900f,
+		-0.238155f,
+		-0.428429f,
+		0.098646f,
+		0.000000f,
+		-0.478600f,
+		-0.855300f,
+		0.198200f,
+		0.062500f,
+		0.172400f,
+		-0.386208f,
+		0.185069f,
+		0.258056f,
+		0.000000f,
+		-0.772800f,
+		0.369000f,
+		0.516300f,
+		0.093700f,
+		0.620700f,
+		-0.367307f,
+		0.234204f,
+		0.245426f,
+		0.000000f,
+		-0.735200f,
+		0.467000f,
+		0.491300f,
+		0.093700f,
+		0.655200f,
+		-0.408129f,
+		0.234204f,
+		0.169052f,
+		0.000000f,
+		-0.816900f,
+		0.467000f,
+		0.338400f,
+		0.062500f,
+		0.655200f,
+		-0.386208f,
+		0.185069f,
+		0.258056f,
+		0.000000f,
+		-0.772800f,
+		0.369000f,
+		0.516300f,
+		0.093700f,
+		0.620700f,
+		-0.408129f,
+		0.234204f,
+		0.169052f,
+		0.000000f,
+		-0.816900f,
+		0.467000f,
+		0.338400f,
+		0.062500f,
+		0.655200f,
+		-0.429131f,
+		0.185069f,
+		0.177751f,
+		0.000000f,
+		-0.858700f,
+		0.369000f,
+		0.355700f,
+		0.062500f,
+		0.620700f,
+		-0.174562f,
+		-0.453788f,
+		0.116638f,
+		0.000000f,
+		-0.351400f,
+		-0.906300f,
+		0.234800f,
+		0.093700f,
+		0.137900f,
+		-0.214334f,
+		-0.428429f,
+		0.143213f,
+		0.000000f,
+		-0.430700f,
+		-0.855300f,
+		0.287800f,
+		0.093700f,
+		0.172400f,
+		-0.238155f,
+		-0.428429f,
+		0.098646f,
+		0.000000f,
+		-0.478600f,
+		-0.855300f,
+		0.198200f,
+		0.062500f,
+		0.172400f,
+		-0.174562f,
+		-0.453788f,
+		0.116638f,
+		0.000000f,
+		-0.351400f,
+		-0.906300f,
+		0.234800f,
+		0.093700f,
+		0.137900f,
+		-0.238155f,
+		-0.428429f,
+		0.098646f,
+		0.000000f,
+		-0.478600f,
+		-0.855300f,
+		0.198200f,
+		0.062500f,
+		0.172400f,
+		-0.193963f,
+		-0.453788f,
+		0.080342f,
+		0.000000f,
+		-0.390500f,
+		-0.906300f,
+		0.161700f,
+		0.062500f,
+		0.137900f,
+		-0.400581f,
+		0.133764f,
+		0.267659f,
+		0.000000f,
+		-0.801400f,
+		0.266600f,
+		0.535400f,
+		0.093700f,
+		0.586200f,
+		-0.386208f,
+		0.185069f,
+		0.258056f,
+		0.000000f,
+		-0.772800f,
+		0.369000f,
+		0.516300f,
+		0.093700f,
+		0.620700f,
+		-0.429131f,
+		0.185069f,
+		0.177751f,
+		0.000000f,
+		-0.858700f,
+		0.369000f,
+		0.355700f,
+		0.062500f,
+		0.620700f,
+		-0.400581f,
+		0.133764f,
+		0.267659f,
+		0.000000f,
+		-0.801400f,
+		0.266600f,
+		0.535400f,
+		0.093700f,
+		0.586200f,
+		-0.429131f,
+		0.185069f,
+		0.177751f,
+		0.000000f,
+		-0.858700f,
+		0.369000f,
+		0.355700f,
+		0.062500f,
+		0.620700f,
+		-0.445102f,
+		0.133764f,
+		0.184367f,
+		0.000000f,
+		-0.890400f,
+		0.266600f,
+		0.368800f,
+		0.062500f,
+		0.586200f,
+		-0.132745f,
+		-0.473826f,
+		0.088697f,
+		0.000000f,
+		-0.268000f,
+		-0.946600f,
+		0.179100f,
+		0.093700f,
+		0.103400f,
+		-0.174562f,
+		-0.453788f,
+		0.116638f,
+		0.000000f,
+		-0.351400f,
+		-0.906300f,
+		0.234800f,
+		0.093700f,
+		0.137900f,
+		-0.193963f,
+		-0.453788f,
+		0.080342f,
+		0.000000f,
+		-0.390500f,
+		-0.906300f,
+		0.161700f,
+		0.062500f,
+		0.137900f,
+		-0.132745f,
+		-0.473826f,
+		0.088697f,
+		0.000000f,
+		-0.268000f,
+		-0.946600f,
+		0.179100f,
+		0.093700f,
+		0.103400f,
+		-0.193963f,
+		-0.453788f,
+		0.080342f,
+		0.000000f,
+		-0.390500f,
+		-0.906300f,
+		0.161700f,
+		0.062500f,
+		0.137900f,
+		-0.147499f,
+		-0.473826f,
+		0.061095f,
+		0.000000f,
+		-0.297800f,
+		-0.946600f,
+		0.123300f,
+		0.062500f,
+		0.103400f,
+		-0.410258f,
+		0.080891f,
+		0.274125f,
+		0.000000f,
+		-0.820600f,
+		0.161200f,
+		0.548300f,
+		0.093700f,
+		0.551700f,
+		-0.400581f,
+		0.133764f,
+		0.267659f,
+		0.000000f,
+		-0.801400f,
+		0.266600f,
+		0.535400f,
+		0.093700f,
+		0.586200f,
+		-0.445102f,
+		0.133764f,
+		0.184367f,
+		0.000000f,
+		-0.890400f,
+		0.266600f,
+		0.368800f,
+		0.062500f,
+		0.586200f,
+		-0.410258f,
+		0.080891f,
+		0.274125f,
+		0.000000f,
+		-0.820600f,
+		0.161200f,
+		0.548300f,
+		0.093700f,
+		0.551700f,
+		-0.445102f,
+		0.133764f,
+		0.184367f,
+		0.000000f,
+		-0.890400f,
+		0.266600f,
+		0.368800f,
+		0.062500f,
+		0.586200f,
+		-0.455854f,
+		0.080891f,
+		0.188820f,
+		0.000000f,
+		-0.911800f,
+		0.161200f,
+		0.377700f,
+		0.062500f,
+		0.551700f,
+		-0.089371f,
+		-0.488310f,
+		0.059715f,
+		0.000000f,
+		-0.181400f,
+		-0.975900f,
+		0.121200f,
+		0.093700f,
+		0.069000f,
+		-0.132745f,
+		-0.473826f,
+		0.088697f,
+		0.000000f,
+		-0.268000f,
+		-0.946600f,
+		0.179100f,
+		0.093700f,
+		0.103400f,
+		-0.147499f,
+		-0.473826f,
+		0.061095f,
+		0.000000f,
+		-0.297800f,
+		-0.946600f,
+		0.123300f,
+		0.062500f,
+		0.103400f,
+		-0.089371f,
+		-0.488310f,
+		0.059715f,
+		0.000000f,
+		-0.181400f,
+		-0.975900f,
+		0.121200f,
+		0.093700f,
+		0.069000f,
+		-0.147499f,
+		-0.473826f,
+		0.061095f,
+		0.000000f,
+		-0.297800f,
+		-0.946600f,
+		0.123300f,
+		0.062500f,
+		0.103400f,
+		-0.099303f,
+		-0.488310f,
+		0.041132f,
+		0.000000f,
+		-0.201600f,
+		-0.975900f,
+		0.083500f,
+		0.062500f,
+		0.069000f,
+		-0.415125f,
+		0.027069f,
+		0.277377f,
+		0.000000f,
+		-0.830300f,
+		0.054000f,
+		0.554700f,
+		0.093700f,
+		0.517200f,
+		-0.410258f,
+		0.080891f,
+		0.274125f,
+		0.000000f,
+		-0.820600f,
+		0.161200f,
+		0.548300f,
+		0.093700f,
+		0.551700f,
+		-0.455854f,
+		0.080891f,
+		0.188820f,
+		0.000000f,
+		-0.911800f,
+		0.161200f,
+		0.377700f,
+		0.062500f,
+		0.551700f,
+		-0.415125f,
+		0.027069f,
+		0.277377f,
+		0.000000f,
+		-0.830300f,
+		0.054000f,
+		0.554700f,
+		0.093700f,
+		0.517200f,
+		-0.455854f,
+		0.080891f,
+		0.188820f,
+		0.000000f,
+		-0.911800f,
+		0.161200f,
+		0.377700f,
+		0.062500f,
+		0.551700f,
+		-0.461262f,
+		0.027069f,
+		0.191060f,
+		0.000000f,
+		-0.922500f,
+		0.054000f,
+		0.382100f,
+		0.062500f,
+		0.517200f,
+		-0.044949f,
+		0.497069f,
+		0.030034f,
+		0.000000f,
+		-0.092700f,
+		0.993700f,
+		0.061900f,
+		0.479800f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.482000f,
+		0.960300f,
+		-0.049945f,
+		0.497069f,
+		0.020688f,
+		0.000000f,
+		-0.103000f,
+		0.993700f,
+		0.042600f,
+		0.481700f,
+		0.962300f,
+		-0.044949f,
+		-0.497069f,
+		0.030034f,
+		0.000000f,
+		-0.092700f,
+		-0.993700f,
+		0.061900f,
+		0.093700f,
+		0.034500f,
+		-0.089371f,
+		-0.488310f,
+		0.059715f,
+		0.000000f,
+		-0.181400f,
+		-0.975900f,
+		0.121200f,
+		0.093700f,
+		0.069000f,
+		-0.099303f,
+		-0.488310f,
+		0.041132f,
+		0.000000f,
+		-0.201600f,
+		-0.975900f,
+		0.083500f,
+		0.062500f,
+		0.069000f,
+		-0.044949f,
+		-0.497069f,
+		0.030034f,
+		0.000000f,
+		-0.092700f,
+		-0.993700f,
+		0.061900f,
+		0.093700f,
+		0.034500f,
+		-0.099303f,
+		-0.488310f,
+		0.041132f,
+		0.000000f,
+		-0.201600f,
+		-0.975900f,
+		0.083500f,
+		0.062500f,
+		0.069000f,
+		-0.049945f,
+		-0.497069f,
+		0.020688f,
+		0.000000f,
+		-0.103000f,
+		-0.993700f,
+		0.042600f,
+		0.062500f,
+		0.034500f,
+		-0.415125f,
+		-0.027069f,
+		0.277377f,
+		0.000000f,
+		-0.830300f,
+		-0.054000f,
+		0.554700f,
+		0.093700f,
+		0.482800f,
+		-0.415125f,
+		0.027069f,
+		0.277377f,
+		0.000000f,
+		-0.830300f,
+		0.054000f,
+		0.554700f,
+		0.093700f,
+		0.517200f,
+		-0.461262f,
+		0.027069f,
+		0.191060f,
+		0.000000f,
+		-0.922500f,
+		0.054000f,
+		0.382100f,
+		0.062500f,
+		0.517200f,
+		-0.415125f,
+		-0.027069f,
+		0.277377f,
+		0.000000f,
+		-0.830300f,
+		-0.054000f,
+		0.554700f,
+		0.093700f,
+		0.482800f,
+		-0.461262f,
+		0.027069f,
+		0.191060f,
+		0.000000f,
+		-0.922500f,
+		0.054000f,
+		0.382100f,
+		0.062500f,
+		0.517200f,
+		-0.461262f,
+		-0.027069f,
+		0.191060f,
+		0.000000f,
+		-0.922500f,
+		-0.054000f,
+		0.382100f,
+		0.062500f,
+		0.482800f,
+		-0.089370f,
+		0.488310f,
+		0.059715f,
+		0.000000f,
+		-0.181400f,
+		0.975900f,
+		0.121200f,
+		0.093700f,
+		0.931000f,
+		-0.044949f,
+		0.497069f,
+		0.030034f,
+		0.000000f,
+		-0.092700f,
+		0.993700f,
+		0.061900f,
+		0.093700f,
+		0.965500f,
+		-0.049945f,
+		0.497069f,
+		0.020688f,
+		0.000000f,
+		-0.103000f,
+		0.993700f,
+		0.042600f,
+		0.062500f,
+		0.965500f,
+		-0.089370f,
+		0.488310f,
+		0.059715f,
+		0.000000f,
+		-0.181400f,
+		0.975900f,
+		0.121200f,
+		0.093700f,
+		0.931000f,
+		-0.049945f,
+		0.497069f,
+		0.020688f,
+		0.000000f,
+		-0.103000f,
+		0.993700f,
+		0.042600f,
+		0.062500f,
+		0.965500f,
+		-0.099303f,
+		0.488310f,
+		0.041132f,
+		0.000000f,
+		-0.201600f,
+		0.975900f,
+		0.083500f,
+		0.062500f,
+		0.931000f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.411700f,
+		0.051000f,
+		-0.044949f,
+		-0.497069f,
+		0.030034f,
+		0.000000f,
+		-0.092700f,
+		-0.993700f,
+		0.061900f,
+		0.418200f,
+		0.053800f,
+		-0.049945f,
+		-0.497069f,
+		0.020688f,
+		0.000000f,
+		-0.103000f,
+		-0.993700f,
+		0.042600f,
+		0.415600f,
+		0.053800f,
+		-0.410258f,
+		-0.080891f,
+		0.274125f,
+		0.000000f,
+		-0.820600f,
+		-0.161200f,
+		0.548300f,
+		0.093700f,
+		0.448300f,
+		-0.415125f,
+		-0.027069f,
+		0.277377f,
+		0.000000f,
+		-0.830300f,
+		-0.054000f,
+		0.554700f,
+		0.093700f,
+		0.482800f,
+		-0.461262f,
+		-0.027069f,
+		0.191060f,
+		0.000000f,
+		-0.922500f,
+		-0.054000f,
+		0.382100f,
+		0.062500f,
+		0.482800f,
+		-0.410258f,
+		-0.080891f,
+		0.274125f,
+		0.000000f,
+		-0.820600f,
+		-0.161200f,
+		0.548300f,
+		0.093700f,
+		0.448300f,
+		-0.461262f,
+		-0.027069f,
+		0.191060f,
+		0.000000f,
+		-0.922500f,
+		-0.054000f,
+		0.382100f,
+		0.062500f,
+		0.482800f,
+		-0.455854f,
+		-0.080891f,
+		0.188820f,
+		0.000000f,
+		-0.911800f,
+		-0.161200f,
+		0.377700f,
+		0.062500f,
+		0.448300f,
+		-0.132745f,
+		0.473826f,
+		0.088697f,
+		0.000000f,
+		-0.268000f,
+		0.946600f,
+		0.179100f,
+		0.093700f,
+		0.896600f,
+		-0.089370f,
+		0.488310f,
+		0.059715f,
+		0.000000f,
+		-0.181400f,
+		0.975900f,
+		0.121200f,
+		0.093700f,
+		0.931000f,
+		-0.099303f,
+		0.488310f,
+		0.041132f,
+		0.000000f,
+		-0.201600f,
+		0.975900f,
+		0.083500f,
+		0.062500f,
+		0.931000f,
+		-0.132745f,
+		0.473826f,
+		0.088697f,
+		0.000000f,
+		-0.268000f,
+		0.946600f,
+		0.179100f,
+		0.093700f,
+		0.896600f,
+		-0.099303f,
+		0.488310f,
+		0.041132f,
+		0.000000f,
+		-0.201600f,
+		0.975900f,
+		0.083500f,
+		0.062500f,
+		0.931000f,
+		-0.147498f,
+		0.473826f,
+		0.061095f,
+		0.000000f,
+		-0.297800f,
+		0.946600f,
+		0.123300f,
+		0.062500f,
+		0.896600f,
+		-0.400581f,
+		-0.133764f,
+		0.267659f,
+		0.000000f,
+		-0.801400f,
+		-0.266600f,
+		0.535400f,
+		0.093700f,
+		0.413800f,
+		-0.410258f,
+		-0.080891f,
+		0.274125f,
+		0.000000f,
+		-0.820600f,
+		-0.161200f,
+		0.548300f,
+		0.093700f,
+		0.448300f,
+		-0.455854f,
+		-0.080891f,
+		0.188820f,
+		0.000000f,
+		-0.911800f,
+		-0.161200f,
+		0.377700f,
+		0.062500f,
+		0.448300f,
+		-0.400581f,
+		-0.133764f,
+		0.267659f,
+		0.000000f,
+		-0.801400f,
+		-0.266600f,
+		0.535400f,
+		0.093700f,
+		0.413800f,
+		-0.455854f,
+		-0.080891f,
+		0.188820f,
+		0.000000f,
+		-0.911800f,
+		-0.161200f,
+		0.377700f,
+		0.062500f,
+		0.448300f,
+		-0.445102f,
+		-0.133764f,
+		0.184367f,
+		0.000000f,
+		-0.890400f,
+		-0.266600f,
+		0.368800f,
+		0.062500f,
+		0.413800f,
+		-0.174562f,
+		0.453788f,
+		0.116638f,
+		0.000000f,
+		-0.351400f,
+		0.906300f,
+		0.234800f,
+		0.093700f,
+		0.862100f,
+		-0.132745f,
+		0.473826f,
+		0.088697f,
+		0.000000f,
+		-0.268000f,
+		0.946600f,
+		0.179100f,
+		0.093700f,
+		0.896600f,
+		-0.147498f,
+		0.473826f,
+		0.061095f,
+		0.000000f,
+		-0.297800f,
+		0.946600f,
+		0.123300f,
+		0.062500f,
+		0.896600f,
+		-0.174562f,
+		0.453788f,
+		0.116638f,
+		0.000000f,
+		-0.351400f,
+		0.906300f,
+		0.234800f,
+		0.093700f,
+		0.862100f,
+		-0.147498f,
+		0.473826f,
+		0.061095f,
+		0.000000f,
+		-0.297800f,
+		0.946600f,
+		0.123300f,
+		0.062500f,
+		0.896600f,
+		-0.193963f,
+		0.453788f,
+		0.080342f,
+		0.000000f,
+		-0.390500f,
+		0.906300f,
+		0.161700f,
+		0.062500f,
+		0.862100f,
+		-0.386208f,
+		-0.185069f,
+		0.258056f,
+		0.000000f,
+		-0.772800f,
+		-0.369000f,
+		0.516300f,
+		0.093700f,
+		0.379300f,
+		-0.400581f,
+		-0.133764f,
+		0.267659f,
+		0.000000f,
+		-0.801400f,
+		-0.266600f,
+		0.535400f,
+		0.093700f,
+		0.413800f,
+		-0.445102f,
+		-0.133764f,
+		0.184367f,
+		0.000000f,
+		-0.890400f,
+		-0.266600f,
+		0.368800f,
+		0.062500f,
+		0.413800f,
+		-0.386208f,
+		-0.185069f,
+		0.258056f,
+		0.000000f,
+		-0.772800f,
+		-0.369000f,
+		0.516300f,
+		0.093700f,
+		0.379300f,
+		-0.445102f,
+		-0.133764f,
+		0.184367f,
+		0.000000f,
+		-0.890400f,
+		-0.266600f,
+		0.368800f,
+		0.062500f,
+		0.413800f,
+		-0.429131f,
+		-0.185069f,
+		0.177751f,
+		0.000000f,
+		-0.858700f,
+		-0.369000f,
+		0.355700f,
+		0.062500f,
+		0.379300f,
+		-0.214334f,
+		0.428429f,
+		0.143213f,
+		0.000000f,
+		-0.430700f,
+		0.855300f,
+		0.287800f,
+		0.093700f,
+		0.827600f,
+		-0.174562f,
+		0.453788f,
+		0.116638f,
+		0.000000f,
+		-0.351400f,
+		0.906300f,
+		0.234800f,
+		0.093700f,
+		0.862100f,
+		-0.193963f,
+		0.453788f,
+		0.080342f,
+		0.000000f,
+		-0.390500f,
+		0.906300f,
+		0.161700f,
+		0.062500f,
+		0.862100f,
+		-0.214334f,
+		0.428429f,
+		0.143213f,
+		0.000000f,
+		-0.430700f,
+		0.855300f,
+		0.287800f,
+		0.093700f,
+		0.827600f,
+		-0.193963f,
+		0.453788f,
+		0.080342f,
+		0.000000f,
+		-0.390500f,
+		0.906300f,
+		0.161700f,
+		0.062500f,
+		0.862100f,
+		-0.238155f,
+		0.428429f,
+		0.098646f,
+		0.000000f,
+		-0.478600f,
+		0.855300f,
+		0.198200f,
+		0.062500f,
+		0.827600f,
+		-0.367307f,
+		-0.234204f,
+		0.245426f,
+		0.000000f,
+		-0.735200f,
+		-0.467000f,
+		0.491300f,
+		0.093700f,
+		0.344800f,
+		-0.386208f,
+		-0.185069f,
+		0.258056f,
+		0.000000f,
+		-0.772800f,
+		-0.369000f,
+		0.516300f,
+		0.093700f,
+		0.379300f,
+		-0.429131f,
+		-0.185069f,
+		0.177751f,
+		0.000000f,
+		-0.858700f,
+		-0.369000f,
+		0.355700f,
+		0.062500f,
+		0.379300f,
+		-0.367307f,
+		-0.234204f,
+		0.245426f,
+		0.000000f,
+		-0.735200f,
+		-0.467000f,
+		0.491300f,
+		0.093700f,
+		0.344800f,
+		-0.429131f,
+		-0.185069f,
+		0.177751f,
+		0.000000f,
+		-0.858700f,
+		-0.369000f,
+		0.355700f,
+		0.062500f,
+		0.379300f,
+		-0.408129f,
+		-0.234204f,
+		0.169052f,
+		0.000000f,
+		-0.816900f,
+		-0.467000f,
+		0.338400f,
+		0.062500f,
+		0.344800f,
+		-0.251592f,
+		0.398046f,
+		0.168108f,
+		0.000000f,
+		-0.505000f,
+		0.794500f,
+		0.337400f,
+		0.093700f,
+		0.793100f,
+		-0.214334f,
+		0.428429f,
+		0.143213f,
+		0.000000f,
+		-0.430700f,
+		0.855300f,
+		0.287800f,
+		0.093700f,
+		0.827600f,
+		-0.238155f,
+		0.428429f,
+		0.098646f,
+		0.000000f,
+		-0.478600f,
+		0.855300f,
+		0.198200f,
+		0.062500f,
+		0.827600f,
+		-0.251592f,
+		0.398046f,
+		0.168108f,
+		0.000000f,
+		-0.505000f,
+		0.794500f,
+		0.337400f,
+		0.093700f,
+		0.793100f,
+		-0.238155f,
+		0.428429f,
+		0.098646f,
+		0.000000f,
+		-0.478600f,
+		0.855300f,
+		0.198200f,
+		0.062500f,
+		0.827600f,
+		-0.279554f,
+		0.398046f,
+		0.115795f,
+		0.000000f,
+		-0.561100f,
+		0.794500f,
+		0.232400f,
+		0.062500f,
+		0.793100f,
+		-0.344099f,
+		-0.280594f,
+		0.229919f,
+		0.000000f,
+		-0.689100f,
+		-0.559600f,
+		0.460400f,
+		0.093700f,
+		0.310300f,
+		-0.367307f,
+		-0.234204f,
+		0.245426f,
+		0.000000f,
+		-0.735200f,
+		-0.467000f,
+		0.491300f,
+		0.093700f,
+		0.344800f,
+		-0.408129f,
+		-0.234204f,
+		0.169052f,
+		0.000000f,
+		-0.816900f,
+		-0.467000f,
+		0.338400f,
+		0.062500f,
+		0.344800f,
+		-0.344099f,
+		-0.280594f,
+		0.229919f,
+		0.000000f,
+		-0.689100f,
+		-0.559600f,
+		0.460400f,
+		0.093700f,
+		0.310300f,
+		-0.408129f,
+		-0.234204f,
+		0.169052f,
+		0.000000f,
+		-0.816900f,
+		-0.467000f,
+		0.338400f,
+		0.062500f,
+		0.344800f,
+		-0.382342f,
+		-0.280594f,
+		0.158371f,
+		0.000000f,
+		-0.765600f,
+		-0.559600f,
+		0.317100f,
+		0.062500f,
+		0.310300f,
+		-0.285901f,
+		0.362998f,
+		0.191032f,
+		0.000000f,
+		-0.573300f,
+		0.724300f,
+		0.383000f,
+		0.093700f,
+		0.758600f,
+		-0.251592f,
+		0.398046f,
+		0.168108f,
+		0.000000f,
+		-0.505000f,
+		0.794500f,
+		0.337400f,
+		0.093700f,
+		0.793100f,
+		-0.279554f,
+		0.398046f,
+		0.115795f,
+		0.000000f,
+		-0.561100f,
+		0.794500f,
+		0.232400f,
+		0.062500f,
+		0.793100f,
+		-0.285901f,
+		0.362998f,
+		0.191032f,
+		0.000000f,
+		-0.573300f,
+		0.724300f,
+		0.383000f,
+		0.093700f,
+		0.758600f,
+		-0.279554f,
+		0.398046f,
+		0.115795f,
+		0.000000f,
+		-0.561100f,
+		0.794500f,
+		0.232400f,
+		0.062500f,
+		0.793100f,
+		-0.317676f,
+		0.362998f,
+		0.131585f,
+		0.000000f,
+		-0.637000f,
+		0.724300f,
+		0.263800f,
+		0.062500f,
+		0.758600f,
+		-0.316857f,
+		-0.323693f,
+		0.211717f,
+		0.000000f,
+		-0.634900f,
+		-0.645700f,
+		0.424200f,
+		0.093700f,
+		0.275900f,
+		-0.344099f,
+		-0.280594f,
+		0.229919f,
+		0.000000f,
+		-0.689100f,
+		-0.559600f,
+		0.460400f,
+		0.093700f,
+		0.310300f,
+		-0.382342f,
+		-0.280594f,
+		0.158371f,
+		0.000000f,
+		-0.765600f,
+		-0.559600f,
+		0.317100f,
+		0.062500f,
+		0.310300f,
+		-0.316857f,
+		-0.323693f,
+		0.211717f,
+		0.000000f,
+		-0.634900f,
+		-0.645700f,
+		0.424200f,
+		0.093700f,
+		0.275900f,
+		-0.382342f,
+		-0.280594f,
+		0.158371f,
+		0.000000f,
+		-0.765600f,
+		-0.559600f,
+		0.317100f,
+		0.062500f,
+		0.310300f,
+		-0.352073f,
+		-0.323693f,
+		0.145833f,
+		0.000000f,
+		-0.705400f,
+		-0.645700f,
+		0.292200f,
+		0.062500f,
+		0.275900f,
+		-0.316857f,
+		0.323693f,
+		0.211717f,
+		0.000000f,
+		-0.634900f,
+		0.645700f,
+		0.424200f,
+		0.093700f,
+		0.724100f,
+		-0.285901f,
+		0.362998f,
+		0.191032f,
+		0.000000f,
+		-0.573300f,
+		0.724300f,
+		0.383000f,
+		0.093700f,
+		0.758600f,
+		-0.317676f,
+		0.362998f,
+		0.131585f,
+		0.000000f,
+		-0.637000f,
+		0.724300f,
+		0.263800f,
+		0.062500f,
+		0.758600f,
+		-0.316857f,
+		0.323693f,
+		0.211717f,
+		0.000000f,
+		-0.634900f,
+		0.645700f,
+		0.424200f,
+		0.093700f,
+		0.724100f,
+		-0.317676f,
+		0.362998f,
+		0.131585f,
+		0.000000f,
+		-0.637000f,
+		0.724300f,
+		0.263800f,
+		0.062500f,
+		0.758600f,
+		-0.352073f,
+		0.323693f,
+		0.145833f,
+		0.000000f,
+		-0.705400f,
+		0.645700f,
+		0.292200f,
+		0.062500f,
+		0.724100f,
+		-0.445102f,
+		-0.133764f,
+		0.184367f,
+		0.000000f,
+		-0.890400f,
+		-0.266600f,
+		0.368800f,
+		0.062500f,
+		0.413800f,
+		-0.455854f,
+		-0.080891f,
+		0.188820f,
+		0.000000f,
+		-0.911800f,
+		-0.161200f,
+		0.377700f,
+		0.062500f,
+		0.448300f,
+		-0.483932f,
+		-0.080891f,
+		0.096260f,
+		0.000000f,
+		-0.967900f,
+		-0.161200f,
+		0.192500f,
+		0.031200f,
+		0.448300f,
+		-0.445102f,
+		-0.133764f,
+		0.184367f,
+		0.000000f,
+		-0.890400f,
+		-0.266600f,
+		0.368800f,
+		0.062500f,
+		0.413800f,
+		-0.483932f,
+		-0.080891f,
+		0.096260f,
+		0.000000f,
+		-0.967900f,
+		-0.161200f,
+		0.192500f,
+		0.031200f,
+		0.448300f,
+		-0.472517f,
+		-0.133764f,
+		0.093989f,
+		0.000000f,
+		-0.945200f,
+		-0.266600f,
+		0.188000f,
+		0.031200f,
+		0.413800f,
+		-0.193963f,
+		0.453788f,
+		0.080342f,
+		0.000000f,
+		-0.390500f,
+		0.906300f,
+		0.161700f,
+		0.062500f,
+		0.862100f,
+		-0.147498f,
+		0.473826f,
+		0.061095f,
+		0.000000f,
+		-0.297800f,
+		0.946600f,
+		0.123300f,
+		0.062500f,
+		0.896600f,
+		-0.156583f,
+		0.473826f,
+		0.031146f,
+		0.000000f,
+		-0.316100f,
+		0.946600f,
+		0.062900f,
+		0.031200f,
+		0.896600f,
+		-0.193963f,
+		0.453788f,
+		0.080342f,
+		0.000000f,
+		-0.390500f,
+		0.906300f,
+		0.161700f,
+		0.062500f,
+		0.862100f,
+		-0.156583f,
+		0.473826f,
+		0.031146f,
+		0.000000f,
+		-0.316100f,
+		0.946600f,
+		0.062900f,
+		0.031200f,
+		0.896600f,
+		-0.205911f,
+		0.453788f,
+		0.040958f,
+		0.000000f,
+		-0.414500f,
+		0.906300f,
+		0.082400f,
+		0.031200f,
+		0.862100f,
+		-0.429131f,
+		-0.185069f,
+		0.177751f,
+		0.000000f,
+		-0.858700f,
+		-0.369000f,
+		0.355700f,
+		0.062500f,
+		0.379300f,
+		-0.445102f,
+		-0.133764f,
+		0.184367f,
+		0.000000f,
+		-0.890400f,
+		-0.266600f,
+		0.368800f,
+		0.062500f,
+		0.413800f,
+		-0.472517f,
+		-0.133764f,
+		0.093989f,
+		0.000000f,
+		-0.945200f,
+		-0.266600f,
+		0.188000f,
+		0.031200f,
+		0.413800f,
+		-0.429131f,
+		-0.185069f,
+		0.177751f,
+		0.000000f,
+		-0.858700f,
+		-0.369000f,
+		0.355700f,
+		0.062500f,
+		0.379300f,
+		-0.472517f,
+		-0.133764f,
+		0.093989f,
+		0.000000f,
+		-0.945200f,
+		-0.266600f,
+		0.188000f,
+		0.031200f,
+		0.413800f,
+		-0.455563f,
+		-0.185069f,
+		0.090617f,
+		0.000000f,
+		-0.911600f,
+		-0.369000f,
+		0.181300f,
+		0.031200f,
+		0.379300f,
+		-0.238155f,
+		0.428429f,
+		0.098646f,
+		0.000000f,
+		-0.478600f,
+		0.855300f,
+		0.198200f,
+		0.062500f,
+		0.827600f,
+		-0.193963f,
+		0.453788f,
+		0.080342f,
+		0.000000f,
+		-0.390500f,
+		0.906300f,
+		0.161700f,
+		0.062500f,
+		0.862100f,
+		-0.205911f,
+		0.453788f,
+		0.040958f,
+		0.000000f,
+		-0.414500f,
+		0.906300f,
+		0.082400f,
+		0.031200f,
+		0.862100f,
+		-0.238155f,
+		0.428429f,
+		0.098646f,
+		0.000000f,
+		-0.478600f,
+		0.855300f,
+		0.198200f,
+		0.062500f,
+		0.827600f,
+		-0.205911f,
+		0.453788f,
+		0.040958f,
+		0.000000f,
+		-0.414500f,
+		0.906300f,
+		0.082400f,
+		0.031200f,
+		0.862100f,
+		-0.252824f,
+		0.428429f,
+		0.050290f,
+		0.000000f,
+		-0.508100f,
+		0.855300f,
+		0.101000f,
+		0.031200f,
+		0.827600f,
+		-0.408129f,
+		-0.234204f,
+		0.169052f,
+		0.000000f,
+		-0.816900f,
+		-0.467000f,
+		0.338400f,
+		0.062500f,
+		0.344800f,
+		-0.429131f,
+		-0.185069f,
+		0.177751f,
+		0.000000f,
+		-0.858700f,
+		-0.369000f,
+		0.355700f,
+		0.062500f,
+		0.379300f,
+		-0.455563f,
+		-0.185069f,
+		0.090617f,
+		0.000000f,
+		-0.911600f,
+		-0.369000f,
+		0.181300f,
+		0.031200f,
+		0.379300f,
+		-0.408129f,
+		-0.234204f,
+		0.169052f,
+		0.000000f,
+		-0.816900f,
+		-0.467000f,
+		0.338400f,
+		0.062500f,
+		0.344800f,
+		-0.455563f,
+		-0.185069f,
+		0.090617f,
+		0.000000f,
+		-0.911600f,
+		-0.369000f,
+		0.181300f,
+		0.031200f,
+		0.379300f,
+		-0.433268f,
+		-0.234204f,
+		0.086182f,
+		0.000000f,
+		-0.867200f,
+		-0.467000f,
+		0.172500f,
+		0.031200f,
+		0.344800f,
+		-0.279554f,
+		0.398046f,
+		0.115795f,
+		0.000000f,
+		-0.561100f,
+		0.794500f,
+		0.232400f,
+		0.062500f,
+		0.793100f,
+		-0.238155f,
+		0.428429f,
+		0.098646f,
+		0.000000f,
+		-0.478600f,
+		0.855300f,
+		0.198200f,
+		0.062500f,
+		0.827600f,
+		-0.252824f,
+		0.428429f,
+		0.050290f,
+		0.000000f,
+		-0.508100f,
+		0.855300f,
+		0.101000f,
+		0.031200f,
+		0.827600f,
+		-0.279554f,
+		0.398046f,
+		0.115795f,
+		0.000000f,
+		-0.561100f,
+		0.794500f,
+		0.232400f,
+		0.062500f,
+		0.793100f,
+		-0.252824f,
+		0.428429f,
+		0.050290f,
+		0.000000f,
+		-0.508100f,
+		0.855300f,
+		0.101000f,
+		0.031200f,
+		0.827600f,
+		-0.296773f,
+		0.398046f,
+		0.059032f,
+		0.000000f,
+		-0.595600f,
+		0.794500f,
+		0.118500f,
+		0.031200f,
+		0.793100f,
+		-0.382342f,
+		-0.280594f,
+		0.158371f,
+		0.000000f,
+		-0.765600f,
+		-0.559600f,
+		0.317100f,
+		0.062500f,
+		0.310300f,
+		-0.408129f,
+		-0.234204f,
+		0.169052f,
+		0.000000f,
+		-0.816900f,
+		-0.467000f,
+		0.338400f,
+		0.062500f,
+		0.344800f,
+		-0.433268f,
+		-0.234204f,
+		0.086182f,
+		0.000000f,
+		-0.867200f,
+		-0.467000f,
+		0.172500f,
+		0.031200f,
+		0.344800f,
+		-0.382342f,
+		-0.280594f,
+		0.158371f,
+		0.000000f,
+		-0.765600f,
+		-0.559600f,
+		0.317100f,
+		0.062500f,
+		0.310300f,
+		-0.433268f,
+		-0.234204f,
+		0.086182f,
+		0.000000f,
+		-0.867200f,
+		-0.467000f,
+		0.172500f,
+		0.031200f,
+		0.344800f,
+		-0.405892f,
+		-0.280594f,
+		0.080737f,
+		0.000000f,
+		-0.812800f,
+		-0.559600f,
+		0.161700f,
+		0.031200f,
+		0.310300f,
+		-0.317676f,
+		0.362998f,
+		0.131585f,
+		0.000000f,
+		-0.637000f,
+		0.724300f,
+		0.263800f,
+		0.062500f,
+		0.758600f,
+		-0.279554f,
+		0.398046f,
+		0.115795f,
+		0.000000f,
+		-0.561100f,
+		0.794500f,
+		0.232400f,
+		0.062500f,
+		0.793100f,
+		-0.296773f,
+		0.398046f,
+		0.059032f,
+		0.000000f,
+		-0.595600f,
+		0.794500f,
+		0.118500f,
+		0.031200f,
+		0.793100f,
+		-0.317676f,
+		0.362998f,
+		0.131585f,
+		0.000000f,
+		-0.637000f,
+		0.724300f,
+		0.263800f,
+		0.062500f,
+		0.758600f,
+		-0.296773f,
+		0.398046f,
+		0.059032f,
+		0.000000f,
+		-0.595600f,
+		0.794500f,
+		0.118500f,
+		0.031200f,
+		0.793100f,
+		-0.337243f,
+		0.362998f,
+		0.067082f,
+		0.000000f,
+		-0.676200f,
+		0.724300f,
+		0.134500f,
+		0.031200f,
+		0.758600f,
+		-0.352073f,
+		-0.323693f,
+		0.145833f,
+		0.000000f,
+		-0.705400f,
+		-0.645700f,
+		0.292200f,
+		0.062500f,
+		0.275900f,
+		-0.382342f,
+		-0.280594f,
+		0.158371f,
+		0.000000f,
+		-0.765600f,
+		-0.559600f,
+		0.317100f,
+		0.062500f,
+		0.310300f,
+		-0.405892f,
+		-0.280594f,
+		0.080737f,
+		0.000000f,
+		-0.812800f,
+		-0.559600f,
+		0.161700f,
+		0.031200f,
+		0.310300f,
+		-0.352073f,
+		-0.323693f,
+		0.145833f,
+		0.000000f,
+		-0.705400f,
+		-0.645700f,
+		0.292200f,
+		0.062500f,
+		0.275900f,
+		-0.405892f,
+		-0.280594f,
+		0.080737f,
+		0.000000f,
+		-0.812800f,
+		-0.559600f,
+		0.161700f,
+		0.031200f,
+		0.310300f,
+		-0.373758f,
+		-0.323693f,
+		0.074345f,
+		0.000000f,
+		-0.748900f,
+		-0.645700f,
+		0.149000f,
+		0.031200f,
+		0.275900f,
+		-0.352073f,
+		0.323693f,
+		0.145833f,
+		0.000000f,
+		-0.705400f,
+		0.645700f,
+		0.292200f,
+		0.062500f,
+		0.724100f,
+		-0.317676f,
+		0.362998f,
+		0.131585f,
+		0.000000f,
+		-0.637000f,
+		0.724300f,
+		0.263800f,
+		0.062500f,
+		0.758600f,
+		-0.337243f,
+		0.362998f,
+		0.067082f,
+		0.000000f,
+		-0.676200f,
+		0.724300f,
+		0.134500f,
+		0.031200f,
+		0.758600f,
+		-0.352073f,
+		0.323693f,
+		0.145833f,
+		0.000000f,
+		-0.705400f,
+		0.645700f,
+		0.292200f,
+		0.062500f,
+		0.724100f,
+		-0.337243f,
+		0.362998f,
+		0.067082f,
+		0.000000f,
+		-0.676200f,
+		0.724300f,
+		0.134500f,
+		0.031200f,
+		0.758600f,
+		-0.373758f,
+		0.323693f,
+		0.074345f,
+		0.000000f,
+		-0.748900f,
+		0.645700f,
+		0.149000f,
+		0.031200f,
+		0.724100f,
+		-0.317676f,
+		-0.362998f,
+		0.131585f,
+		0.000000f,
+		-0.637000f,
+		-0.724300f,
+		0.263800f,
+		0.062500f,
+		0.241400f,
+		-0.352073f,
+		-0.323693f,
+		0.145833f,
+		0.000000f,
+		-0.705400f,
+		-0.645700f,
+		0.292200f,
+		0.062500f,
+		0.275900f,
+		-0.373758f,
+		-0.323693f,
+		0.074345f,
+		0.000000f,
+		-0.748900f,
+		-0.645700f,
+		0.149000f,
+		0.031200f,
+		0.275900f,
+		-0.317676f,
+		-0.362998f,
+		0.131585f,
+		0.000000f,
+		-0.637000f,
+		-0.724300f,
+		0.263800f,
+		0.062500f,
+		0.241400f,
+		-0.373758f,
+		-0.323693f,
+		0.074345f,
+		0.000000f,
+		-0.748900f,
+		-0.645700f,
+		0.149000f,
+		0.031200f,
+		0.275900f,
+		-0.337243f,
+		-0.362998f,
+		0.067082f,
+		0.000000f,
+		-0.676200f,
+		-0.724300f,
+		0.134500f,
+		0.031200f,
+		0.241400f,
+		-0.382342f,
+		0.280594f,
+		0.158371f,
+		0.000000f,
+		-0.765600f,
+		0.559600f,
+		0.317100f,
+		0.062500f,
+		0.689700f,
+		-0.352073f,
+		0.323693f,
+		0.145833f,
+		0.000000f,
+		-0.705400f,
+		0.645700f,
+		0.292200f,
+		0.062500f,
+		0.724100f,
+		-0.373758f,
+		0.323693f,
+		0.074345f,
+		0.000000f,
+		-0.748900f,
+		0.645700f,
+		0.149000f,
+		0.031200f,
+		0.724100f,
+		-0.382342f,
+		0.280594f,
+		0.158371f,
+		0.000000f,
+		-0.765600f,
+		0.559600f,
+		0.317100f,
+		0.062500f,
+		0.689700f,
+		-0.373758f,
+		0.323693f,
+		0.074345f,
+		0.000000f,
+		-0.748900f,
+		0.645700f,
+		0.149000f,
+		0.031200f,
+		0.724100f,
+		-0.405892f,
+		0.280594f,
+		0.080737f,
+		0.000000f,
+		-0.812800f,
+		0.559600f,
+		0.161700f,
+		0.031200f,
+		0.689700f,
+		-0.279554f,
+		-0.398046f,
+		0.115795f,
+		0.000000f,
+		-0.561100f,
+		-0.794500f,
+		0.232400f,
+		0.062500f,
+		0.206900f,
+		-0.317676f,
+		-0.362998f,
+		0.131585f,
+		0.000000f,
+		-0.637000f,
+		-0.724300f,
+		0.263800f,
+		0.062500f,
+		0.241400f,
+		-0.337243f,
+		-0.362998f,
+		0.067082f,
+		0.000000f,
+		-0.676200f,
+		-0.724300f,
+		0.134500f,
+		0.031200f,
+		0.241400f,
+		-0.279554f,
+		-0.398046f,
+		0.115795f,
+		0.000000f,
+		-0.561100f,
+		-0.794500f,
+		0.232400f,
+		0.062500f,
+		0.206900f,
+		-0.337243f,
+		-0.362998f,
+		0.067082f,
+		0.000000f,
+		-0.676200f,
+		-0.724300f,
+		0.134500f,
+		0.031200f,
+		0.241400f,
+		-0.296773f,
+		-0.398046f,
+		0.059032f,
+		0.000000f,
+		-0.595600f,
+		-0.794500f,
+		0.118500f,
+		0.031200f,
+		0.206900f,
+		-0.408129f,
+		0.234204f,
+		0.169052f,
+		0.000000f,
+		-0.816900f,
+		0.467000f,
+		0.338400f,
+		0.062500f,
+		0.655200f,
+		-0.382342f,
+		0.280594f,
+		0.158371f,
+		0.000000f,
+		-0.765600f,
+		0.559600f,
+		0.317100f,
+		0.062500f,
+		0.689700f,
+		-0.405892f,
+		0.280594f,
+		0.080737f,
+		0.000000f,
+		-0.812800f,
+		0.559600f,
+		0.161700f,
+		0.031200f,
+		0.689700f,
+		-0.408129f,
+		0.234204f,
+		0.169052f,
+		0.000000f,
+		-0.816900f,
+		0.467000f,
+		0.338400f,
+		0.062500f,
+		0.655200f,
+		-0.405892f,
+		0.280594f,
+		0.080737f,
+		0.000000f,
+		-0.812800f,
+		0.559600f,
+		0.161700f,
+		0.031200f,
+		0.689700f,
+		-0.433268f,
+		0.234204f,
+		0.086182f,
+		0.000000f,
+		-0.867200f,
+		0.467000f,
+		0.172500f,
+		0.031200f,
+		0.655200f,
+		-0.238155f,
+		-0.428429f,
+		0.098646f,
+		0.000000f,
+		-0.478600f,
+		-0.855300f,
+		0.198200f,
+		0.062500f,
+		0.172400f,
+		-0.279554f,
+		-0.398046f,
+		0.115795f,
+		0.000000f,
+		-0.561100f,
+		-0.794500f,
+		0.232400f,
+		0.062500f,
+		0.206900f,
+		-0.296773f,
+		-0.398046f,
+		0.059032f,
+		0.000000f,
+		-0.595600f,
+		-0.794500f,
+		0.118500f,
+		0.031200f,
+		0.206900f,
+		-0.238155f,
+		-0.428429f,
+		0.098646f,
+		0.000000f,
+		-0.478600f,
+		-0.855300f,
+		0.198200f,
+		0.062500f,
+		0.172400f,
+		-0.296773f,
+		-0.398046f,
+		0.059032f,
+		0.000000f,
+		-0.595600f,
+		-0.794500f,
+		0.118500f,
+		0.031200f,
+		0.206900f,
+		-0.252824f,
+		-0.428429f,
+		0.050290f,
+		0.000000f,
+		-0.508100f,
+		-0.855300f,
+		0.101000f,
+		0.031200f,
+		0.172400f,
+		-0.429131f,
+		0.185069f,
+		0.177751f,
+		0.000000f,
+		-0.858700f,
+		0.369000f,
+		0.355700f,
+		0.062500f,
+		0.620700f,
+		-0.408129f,
+		0.234204f,
+		0.169052f,
+		0.000000f,
+		-0.816900f,
+		0.467000f,
+		0.338400f,
+		0.062500f,
+		0.655200f,
+		-0.433268f,
+		0.234204f,
+		0.086182f,
+		0.000000f,
+		-0.867200f,
+		0.467000f,
+		0.172500f,
+		0.031200f,
+		0.655200f,
+		-0.429131f,
+		0.185069f,
+		0.177751f,
+		0.000000f,
+		-0.858700f,
+		0.369000f,
+		0.355700f,
+		0.062500f,
+		0.620700f,
+		-0.433268f,
+		0.234204f,
+		0.086182f,
+		0.000000f,
+		-0.867200f,
+		0.467000f,
+		0.172500f,
+		0.031200f,
+		0.655200f,
+		-0.455563f,
+		0.185069f,
+		0.090617f,
+		0.000000f,
+		-0.911600f,
+		0.369000f,
+		0.181300f,
+		0.031200f,
+		0.620700f,
+		-0.193963f,
+		-0.453788f,
+		0.080342f,
+		0.000000f,
+		-0.390500f,
+		-0.906300f,
+		0.161700f,
+		0.062500f,
+		0.137900f,
+		-0.238155f,
+		-0.428429f,
+		0.098646f,
+		0.000000f,
+		-0.478600f,
+		-0.855300f,
+		0.198200f,
+		0.062500f,
+		0.172400f,
+		-0.252824f,
+		-0.428429f,
+		0.050290f,
+		0.000000f,
+		-0.508100f,
+		-0.855300f,
+		0.101000f,
+		0.031200f,
+		0.172400f,
+		-0.193963f,
+		-0.453788f,
+		0.080342f,
+		0.000000f,
+		-0.390500f,
+		-0.906300f,
+		0.161700f,
+		0.062500f,
+		0.137900f,
+		-0.252824f,
+		-0.428429f,
+		0.050290f,
+		0.000000f,
+		-0.508100f,
+		-0.855300f,
+		0.101000f,
+		0.031200f,
+		0.172400f,
+		-0.205911f,
+		-0.453788f,
+		0.040958f,
+		0.000000f,
+		-0.414500f,
+		-0.906300f,
+		0.082400f,
+		0.031200f,
+		0.137900f,
+		-0.445102f,
+		0.133764f,
+		0.184367f,
+		0.000000f,
+		-0.890400f,
+		0.266600f,
+		0.368800f,
+		0.062500f,
+		0.586200f,
+		-0.429131f,
+		0.185069f,
+		0.177751f,
+		0.000000f,
+		-0.858700f,
+		0.369000f,
+		0.355700f,
+		0.062500f,
+		0.620700f,
+		-0.455563f,
+		0.185069f,
+		0.090617f,
+		0.000000f,
+		-0.911600f,
+		0.369000f,
+		0.181300f,
+		0.031200f,
+		0.620700f,
+		-0.445102f,
+		0.133764f,
+		0.184367f,
+		0.000000f,
+		-0.890400f,
+		0.266600f,
+		0.368800f,
+		0.062500f,
+		0.586200f,
+		-0.455563f,
+		0.185069f,
+		0.090617f,
+		0.000000f,
+		-0.911600f,
+		0.369000f,
+		0.181300f,
+		0.031200f,
+		0.620700f,
+		-0.472517f,
+		0.133764f,
+		0.093989f,
+		0.000000f,
+		-0.945200f,
+		0.266600f,
+		0.188000f,
+		0.031200f,
+		0.586200f,
+		-0.147499f,
+		-0.473826f,
+		0.061095f,
+		0.000000f,
+		-0.297800f,
+		-0.946600f,
+		0.123300f,
+		0.062500f,
+		0.103400f,
+		-0.193963f,
+		-0.453788f,
+		0.080342f,
+		0.000000f,
+		-0.390500f,
+		-0.906300f,
+		0.161700f,
+		0.062500f,
+		0.137900f,
+		-0.205911f,
+		-0.453788f,
+		0.040958f,
+		0.000000f,
+		-0.414500f,
+		-0.906300f,
+		0.082400f,
+		0.031200f,
+		0.137900f,
+		-0.147499f,
+		-0.473826f,
+		0.061095f,
+		0.000000f,
+		-0.297800f,
+		-0.946600f,
+		0.123300f,
+		0.062500f,
+		0.103400f,
+		-0.205911f,
+		-0.453788f,
+		0.040958f,
+		0.000000f,
+		-0.414500f,
+		-0.906300f,
+		0.082400f,
+		0.031200f,
+		0.137900f,
+		-0.156584f,
+		-0.473826f,
+		0.031147f,
+		0.000000f,
+		-0.316100f,
+		-0.946600f,
+		0.062900f,
+		0.031200f,
+		0.103400f,
+		-0.455854f,
+		0.080891f,
+		0.188820f,
+		0.000000f,
+		-0.911800f,
+		0.161200f,
+		0.377700f,
+		0.062500f,
+		0.551700f,
+		-0.445102f,
+		0.133764f,
+		0.184367f,
+		0.000000f,
+		-0.890400f,
+		0.266600f,
+		0.368800f,
+		0.062500f,
+		0.586200f,
+		-0.472517f,
+		0.133764f,
+		0.093989f,
+		0.000000f,
+		-0.945200f,
+		0.266600f,
+		0.188000f,
+		0.031200f,
+		0.586200f,
+		-0.455854f,
+		0.080891f,
+		0.188820f,
+		0.000000f,
+		-0.911800f,
+		0.161200f,
+		0.377700f,
+		0.062500f,
+		0.551700f,
+		-0.472517f,
+		0.133764f,
+		0.093989f,
+		0.000000f,
+		-0.945200f,
+		0.266600f,
+		0.188000f,
+		0.031200f,
+		0.586200f,
+		-0.483932f,
+		0.080891f,
+		0.096260f,
+		0.000000f,
+		-0.967900f,
+		0.161200f,
+		0.192500f,
+		0.031200f,
+		0.551700f,
+		-0.099303f,
+		-0.488310f,
+		0.041132f,
+		0.000000f,
+		-0.201600f,
+		-0.975900f,
+		0.083500f,
+		0.062500f,
+		0.069000f,
+		-0.147499f,
+		-0.473826f,
+		0.061095f,
+		0.000000f,
+		-0.297800f,
+		-0.946600f,
+		0.123300f,
+		0.062500f,
+		0.103400f,
+		-0.156584f,
+		-0.473826f,
+		0.031147f,
+		0.000000f,
+		-0.316100f,
+		-0.946600f,
+		0.062900f,
+		0.031200f,
+		0.103400f,
+		-0.099303f,
+		-0.488310f,
+		0.041132f,
+		0.000000f,
+		-0.201600f,
+		-0.975900f,
+		0.083500f,
+		0.062500f,
+		0.069000f,
+		-0.156584f,
+		-0.473826f,
+		0.031147f,
+		0.000000f,
+		-0.316100f,
+		-0.946600f,
+		0.062900f,
+		0.031200f,
+		0.103400f,
+		-0.105420f,
+		-0.488310f,
+		0.020970f,
+		0.000000f,
+		-0.214000f,
+		-0.975900f,
+		0.042500f,
+		0.031200f,
+		0.069000f,
+		-0.461262f,
+		0.027069f,
+		0.191060f,
+		0.000000f,
+		-0.922500f,
+		0.054000f,
+		0.382100f,
+		0.062500f,
+		0.517200f,
+		-0.455854f,
+		0.080891f,
+		0.188820f,
+		0.000000f,
+		-0.911800f,
+		0.161200f,
+		0.377700f,
+		0.062500f,
+		0.551700f,
+		-0.483932f,
+		0.080891f,
+		0.096260f,
+		0.000000f,
+		-0.967900f,
+		0.161200f,
+		0.192500f,
+		0.031200f,
+		0.551700f,
+		-0.461262f,
+		0.027069f,
+		0.191060f,
+		0.000000f,
+		-0.922500f,
+		0.054000f,
+		0.382100f,
+		0.062500f,
+		0.517200f,
+		-0.483932f,
+		0.080891f,
+		0.096260f,
+		0.000000f,
+		-0.967900f,
+		0.161200f,
+		0.192500f,
+		0.031200f,
+		0.551700f,
+		-0.489673f,
+		0.027069f,
+		0.097402f,
+		0.000000f,
+		-0.979300f,
+		0.054000f,
+		0.194800f,
+		0.031200f,
+		0.517200f,
+		-0.049945f,
+		0.497069f,
+		0.020688f,
+		0.000000f,
+		-0.103000f,
+		0.993700f,
+		0.042600f,
+		0.481700f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.482000f,
+		0.960300f,
+		-0.053020f,
+		0.497069f,
+		0.010546f,
+		0.000000f,
+		-0.109300f,
+		0.993700f,
+		0.021700f,
+		0.483500f,
+		0.962300f,
+		-0.049945f,
+		-0.497069f,
+		0.020688f,
+		0.000000f,
+		-0.103000f,
+		-0.993700f,
+		0.042600f,
+		0.062500f,
+		0.034500f,
+		-0.099303f,
+		-0.488310f,
+		0.041132f,
+		0.000000f,
+		-0.201600f,
+		-0.975900f,
+		0.083500f,
+		0.062500f,
+		0.069000f,
+		-0.105420f,
+		-0.488310f,
+		0.020970f,
+		0.000000f,
+		-0.214000f,
+		-0.975900f,
+		0.042500f,
+		0.031200f,
+		0.069000f,
+		-0.049945f,
+		-0.497069f,
+		0.020688f,
+		0.000000f,
+		-0.103000f,
+		-0.993700f,
+		0.042600f,
+		0.062500f,
+		0.034500f,
+		-0.105420f,
+		-0.488310f,
+		0.020970f,
+		0.000000f,
+		-0.214000f,
+		-0.975900f,
+		0.042500f,
+		0.031200f,
+		0.069000f,
+		-0.053021f,
+		-0.497069f,
+		0.010546f,
+		0.000000f,
+		-0.109300f,
+		-0.993700f,
+		0.021700f,
+		0.031200f,
+		0.034500f,
+		-0.461262f,
+		-0.027069f,
+		0.191060f,
+		0.000000f,
+		-0.922500f,
+		-0.054000f,
+		0.382100f,
+		0.062500f,
+		0.482800f,
+		-0.461262f,
+		0.027069f,
+		0.191060f,
+		0.000000f,
+		-0.922500f,
+		0.054000f,
+		0.382100f,
+		0.062500f,
+		0.517200f,
+		-0.489673f,
+		0.027069f,
+		0.097402f,
+		0.000000f,
+		-0.979300f,
+		0.054000f,
+		0.194800f,
+		0.031200f,
+		0.517200f,
+		-0.461262f,
+		-0.027069f,
+		0.191060f,
+		0.000000f,
+		-0.922500f,
+		-0.054000f,
+		0.382100f,
+		0.062500f,
+		0.482800f,
+		-0.489673f,
+		0.027069f,
+		0.097402f,
+		0.000000f,
+		-0.979300f,
+		0.054000f,
+		0.194800f,
+		0.031200f,
+		0.517200f,
+		-0.489673f,
+		-0.027069f,
+		0.097402f,
+		0.000000f,
+		-0.979300f,
+		-0.054000f,
+		0.194800f,
+		0.031200f,
+		0.482800f,
+		-0.099303f,
+		0.488310f,
+		0.041132f,
+		0.000000f,
+		-0.201600f,
+		0.975900f,
+		0.083500f,
+		0.062500f,
+		0.931000f,
+		-0.049945f,
+		0.497069f,
+		0.020688f,
+		0.000000f,
+		-0.103000f,
+		0.993700f,
+		0.042600f,
+		0.062500f,
+		0.965500f,
+		-0.053020f,
+		0.497069f,
+		0.010546f,
+		0.000000f,
+		-0.109300f,
+		0.993700f,
+		0.021700f,
+		0.031200f,
+		0.965500f,
+		-0.099303f,
+		0.488310f,
+		0.041132f,
+		0.000000f,
+		-0.201600f,
+		0.975900f,
+		0.083500f,
+		0.062500f,
+		0.931000f,
+		-0.053020f,
+		0.497069f,
+		0.010546f,
+		0.000000f,
+		-0.109300f,
+		0.993700f,
+		0.021700f,
+		0.031200f,
+		0.965500f,
+		-0.105420f,
+		0.488310f,
+		0.020969f,
+		0.000000f,
+		-0.214000f,
+		0.975900f,
+		0.042500f,
+		0.031200f,
+		0.931000f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.411700f,
+		0.051000f,
+		-0.049945f,
+		-0.497069f,
+		0.020688f,
+		0.000000f,
+		-0.103000f,
+		-0.993700f,
+		0.042600f,
+		0.415600f,
+		0.053800f,
+		-0.053021f,
+		-0.497069f,
+		0.010546f,
+		0.000000f,
+		-0.109300f,
+		-0.993700f,
+		0.021700f,
+		0.413000f,
+		0.053800f,
+		-0.455854f,
+		-0.080891f,
+		0.188820f,
+		0.000000f,
+		-0.911800f,
+		-0.161200f,
+		0.377700f,
+		0.062500f,
+		0.448300f,
+		-0.461262f,
+		-0.027069f,
+		0.191060f,
+		0.000000f,
+		-0.922500f,
+		-0.054000f,
+		0.382100f,
+		0.062500f,
+		0.482800f,
+		-0.489673f,
+		-0.027069f,
+		0.097402f,
+		0.000000f,
+		-0.979300f,
+		-0.054000f,
+		0.194800f,
+		0.031200f,
+		0.482800f,
+		-0.455854f,
+		-0.080891f,
+		0.188820f,
+		0.000000f,
+		-0.911800f,
+		-0.161200f,
+		0.377700f,
+		0.062500f,
+		0.448300f,
+		-0.489673f,
+		-0.027069f,
+		0.097402f,
+		0.000000f,
+		-0.979300f,
+		-0.054000f,
+		0.194800f,
+		0.031200f,
+		0.482800f,
+		-0.483932f,
+		-0.080891f,
+		0.096260f,
+		0.000000f,
+		-0.967900f,
+		-0.161200f,
+		0.192500f,
+		0.031200f,
+		0.448300f,
+		-0.147498f,
+		0.473826f,
+		0.061095f,
+		0.000000f,
+		-0.297800f,
+		0.946600f,
+		0.123300f,
+		0.062500f,
+		0.896600f,
+		-0.099303f,
+		0.488310f,
+		0.041132f,
+		0.000000f,
+		-0.201600f,
+		0.975900f,
+		0.083500f,
+		0.062500f,
+		0.931000f,
+		-0.105420f,
+		0.488310f,
+		0.020969f,
+		0.000000f,
+		-0.214000f,
+		0.975900f,
+		0.042500f,
+		0.031200f,
+		0.931000f,
+		-0.147498f,
+		0.473826f,
+		0.061095f,
+		0.000000f,
+		-0.297800f,
+		0.946600f,
+		0.123300f,
+		0.062500f,
+		0.896600f,
+		-0.105420f,
+		0.488310f,
+		0.020969f,
+		0.000000f,
+		-0.214000f,
+		0.975900f,
+		0.042500f,
+		0.031200f,
+		0.931000f,
+		-0.156583f,
+		0.473826f,
+		0.031146f,
+		0.000000f,
+		-0.316100f,
+		0.946600f,
+		0.062900f,
+		0.031200f,
+		0.896600f,
+		-0.205911f,
+		-0.453788f,
+		0.040958f,
+		0.000000f,
+		-0.414500f,
+		-0.906300f,
+		0.082400f,
+		0.031200f,
+		0.137900f,
+		-0.252824f,
+		-0.428429f,
+		0.050290f,
+		0.000000f,
+		-0.508100f,
+		-0.855300f,
+		0.101000f,
+		0.031200f,
+		0.172400f,
+		-0.257777f,
+		-0.428429f,
+		0.000000f,
+		0.000000f,
+		-0.518000f,
+		-0.855300f,
+		0.000000f,
+		0.000000f,
+		0.172400f,
+		-0.205911f,
+		-0.453788f,
+		0.040958f,
+		0.000000f,
+		-0.414500f,
+		-0.906300f,
+		0.082400f,
+		0.031200f,
+		0.137900f,
+		-0.257777f,
+		-0.428429f,
+		0.000000f,
+		0.000000f,
+		-0.518000f,
+		-0.855300f,
+		0.000000f,
+		0.000000f,
+		0.172400f,
+		-0.209945f,
+		-0.453788f,
+		0.000000f,
+		0.000000f,
+		-0.422700f,
+		-0.906300f,
+		0.000000f,
+		0.000000f,
+		0.137900f,
+		-0.472517f,
+		0.133764f,
+		0.093989f,
+		0.000000f,
+		-0.945200f,
+		0.266600f,
+		0.188000f,
+		0.031200f,
+		0.586200f,
+		-0.455563f,
+		0.185069f,
+		0.090617f,
+		0.000000f,
+		-0.911600f,
+		0.369000f,
+		0.181300f,
+		0.031200f,
+		0.620700f,
+		-0.464489f,
+		0.185069f,
+		0.000000f,
+		0.000000f,
+		-0.929400f,
+		0.369000f,
+		0.000000f,
+		0.000000f,
+		0.620700f,
+		-0.472517f,
+		0.133764f,
+		0.093989f,
+		0.000000f,
+		-0.945200f,
+		0.266600f,
+		0.188000f,
+		0.031200f,
+		0.586200f,
+		-0.464489f,
+		0.185069f,
+		0.000000f,
+		0.000000f,
+		-0.929400f,
+		0.369000f,
+		0.000000f,
+		0.000000f,
+		0.620700f,
+		-0.481775f,
+		0.133764f,
+		0.000000f,
+		0.000000f,
+		-0.963800f,
+		0.266600f,
+		0.000000f,
+		0.000000f,
+		0.586200f,
+		-0.156584f,
+		-0.473826f,
+		0.031147f,
+		0.000000f,
+		-0.316100f,
+		-0.946600f,
+		0.062900f,
+		0.031200f,
+		0.103400f,
+		-0.205911f,
+		-0.453788f,
+		0.040958f,
+		0.000000f,
+		-0.414500f,
+		-0.906300f,
+		0.082400f,
+		0.031200f,
+		0.137900f,
+		-0.209945f,
+		-0.453788f,
+		0.000000f,
+		0.000000f,
+		-0.422700f,
+		-0.906300f,
+		0.000000f,
+		0.000000f,
+		0.137900f,
+		-0.156584f,
+		-0.473826f,
+		0.031147f,
+		0.000000f,
+		-0.316100f,
+		-0.946600f,
+		0.062900f,
+		0.031200f,
+		0.103400f,
+		-0.209945f,
+		-0.453788f,
+		0.000000f,
+		0.000000f,
+		-0.422700f,
+		-0.906300f,
+		0.000000f,
+		0.000000f,
+		0.137900f,
+		-0.159651f,
+		-0.473826f,
+		0.000000f,
+		0.000000f,
+		-0.322300f,
+		-0.946600f,
+		0.000000f,
+		0.000000f,
+		0.103400f,
+		-0.483932f,
+		0.080891f,
+		0.096260f,
+		0.000000f,
+		-0.967900f,
+		0.161200f,
+		0.192500f,
+		0.031200f,
+		0.551700f,
+		-0.472517f,
+		0.133764f,
+		0.093989f,
+		0.000000f,
+		-0.945200f,
+		0.266600f,
+		0.188000f,
+		0.031200f,
+		0.586200f,
+		-0.481775f,
+		0.133764f,
+		0.000000f,
+		0.000000f,
+		-0.963800f,
+		0.266600f,
+		0.000000f,
+		0.000000f,
+		0.586200f,
+		-0.483932f,
+		0.080891f,
+		0.096260f,
+		0.000000f,
+		-0.967900f,
+		0.161200f,
+		0.192500f,
+		0.031200f,
+		0.551700f,
+		-0.481775f,
+		0.133764f,
+		0.000000f,
+		0.000000f,
+		-0.963800f,
+		0.266600f,
+		0.000000f,
+		0.000000f,
+		0.586200f,
+		-0.493414f,
+		0.080891f,
+		0.000000f,
+		0.000000f,
+		-0.986900f,
+		0.161200f,
+		0.000000f,
+		0.000000f,
+		0.551700f,
+		-0.105420f,
+		-0.488310f,
+		0.020970f,
+		0.000000f,
+		-0.214000f,
+		-0.975900f,
+		0.042500f,
+		0.031200f,
+		0.069000f,
+		-0.156584f,
+		-0.473826f,
+		0.031147f,
+		0.000000f,
+		-0.316100f,
+		-0.946600f,
+		0.062900f,
+		0.031200f,
+		0.103400f,
+		-0.159651f,
+		-0.473826f,
+		0.000000f,
+		0.000000f,
+		-0.322300f,
+		-0.946600f,
+		0.000000f,
+		0.000000f,
+		0.103400f,
+		-0.105420f,
+		-0.488310f,
+		0.020970f,
+		0.000000f,
+		-0.214000f,
+		-0.975900f,
+		0.042500f,
+		0.031200f,
+		0.069000f,
+		-0.159651f,
+		-0.473826f,
+		0.000000f,
+		0.000000f,
+		-0.322300f,
+		-0.946600f,
+		0.000000f,
+		0.000000f,
+		0.103400f,
+		-0.107486f,
+		-0.488310f,
+		0.000000f,
+		0.000000f,
+		-0.218200f,
+		-0.975900f,
+		0.000000f,
+		0.000000f,
+		0.069000f,
+		-0.489673f,
+		0.027069f,
+		0.097402f,
+		0.000000f,
+		-0.979300f,
+		0.054000f,
+		0.194800f,
+		0.031200f,
+		0.517200f,
+		-0.483932f,
+		0.080891f,
+		0.096260f,
+		0.000000f,
+		-0.967900f,
+		0.161200f,
+		0.192500f,
+		0.031200f,
+		0.551700f,
+		-0.493414f,
+		0.080891f,
+		0.000000f,
+		0.000000f,
+		-0.986900f,
+		0.161200f,
+		0.000000f,
+		0.000000f,
+		0.551700f,
+		-0.489673f,
+		0.027069f,
+		0.097402f,
+		0.000000f,
+		-0.979300f,
+		0.054000f,
+		0.194800f,
+		0.031200f,
+		0.517200f,
+		-0.493414f,
+		0.080891f,
+		0.000000f,
+		0.000000f,
+		-0.986900f,
+		0.161200f,
+		0.000000f,
+		0.000000f,
+		0.551700f,
+		-0.499267f,
+		0.027069f,
+		0.000000f,
+		0.000000f,
+		-0.998500f,
+		0.054000f,
+		0.000000f,
+		0.000000f,
+		0.517200f,
+		-0.053020f,
+		0.497069f,
+		0.010546f,
+		0.000000f,
+		-0.109300f,
+		0.993700f,
+		0.021700f,
+		0.425300f,
+		0.962300f,
+		-0.000000f,
+		0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		1.000000f,
+		0.000000f,
+		0.423900f,
+		0.960300f,
+		-0.054060f,
+		0.497069f,
+		0.000000f,
+		0.000000f,
+		-0.111500f,
+		0.993700f,
+		0.000000f,
+		0.427200f,
+		0.962300f,
+		-0.053021f,
+		-0.497069f,
+		0.010546f,
+		0.000000f,
+		-0.109300f,
+		-0.993700f,
+		0.021700f,
+		0.031200f,
+		0.034500f,
+		-0.105420f,
+		-0.488310f,
+		0.020970f,
+		0.000000f,
+		-0.214000f,
+		-0.975900f,
+		0.042500f,
+		0.031200f,
+		0.069000f,
+		-0.107486f,
+		-0.488310f,
+		0.000000f,
+		0.000000f,
+		-0.218200f,
+		-0.975900f,
+		0.000000f,
+		0.000000f,
+		0.069000f,
+		-0.053021f,
+		-0.497069f,
+		0.010546f,
+		0.000000f,
+		-0.109300f,
+		-0.993700f,
+		0.021700f,
+		0.031200f,
+		0.034500f,
+		-0.107486f,
+		-0.488310f,
+		0.000000f,
+		0.000000f,
+		-0.218200f,
+		-0.975900f,
+		0.000000f,
+		0.000000f,
+		0.069000f,
+		-0.054060f,
+		-0.497069f,
+		0.000000f,
+		0.000000f,
+		-0.111500f,
+		-0.993700f,
+		0.000000f,
+		0.000000f,
+		0.034500f,
+		-0.489673f,
+		-0.027069f,
+		0.097402f,
+		0.000000f,
+		-0.979300f,
+		-0.054000f,
+		0.194800f,
+		0.031200f,
+		0.482800f,
+		-0.489673f,
+		0.027069f,
+		0.097402f,
+		0.000000f,
+		-0.979300f,
+		0.054000f,
+		0.194800f,
+		0.031200f,
+		0.517200f,
+		-0.499267f,
+		0.027069f,
+		0.000000f,
+		0.000000f,
+		-0.998500f,
+		0.054000f,
+		0.000000f,
+		0.000000f,
+		0.517200f,
+		-0.489673f,
+		-0.027069f,
+		0.097402f,
+		0.000000f,
+		-0.979300f,
+		-0.054000f,
+		0.194800f,
+		0.031200f,
+		0.482800f,
+		-0.499267f,
+		0.027069f,
+		0.000000f,
+		0.000000f,
+		-0.998500f,
+		0.054000f,
+		0.000000f,
+		0.000000f,
+		0.517200f,
+		-0.499267f,
+		-0.027069f,
+		0.000000f,
+		0.000000f,
+		-0.998500f,
+		-0.054000f,
+		0.000000f,
+		0.000000f,
+		0.482800f,
+		-0.105420f,
+		0.488310f,
+		0.020969f,
+		0.000000f,
+		-0.214000f,
+		0.975900f,
+		0.042500f,
+		1.031200f,
+		0.931000f,
+		-0.053020f,
+		0.497069f,
+		0.010546f,
+		0.000000f,
+		-0.109300f,
+		0.993700f,
+		0.021700f,
+		1.031200f,
+		0.965500f,
+		-0.054060f,
+		0.497069f,
+		0.000000f,
+		0.000000f,
+		-0.111500f,
+		0.993700f,
+		0.000000f,
+		1.000000f,
+		0.965500f,
+		-0.105420f,
+		0.488310f,
+		0.020969f,
+		0.000000f,
+		-0.214000f,
+		0.975900f,
+		0.042500f,
+		1.031200f,
+		0.931000f,
+		-0.054060f,
+		0.497069f,
+		0.000000f,
+		0.000000f,
+		-0.111500f,
+		0.993700f,
+		0.000000f,
+		1.000000f,
+		0.965500f,
+		-0.107485f,
+		0.488310f,
+		0.000000f,
+		0.000000f,
+		-0.218200f,
+		0.975900f,
+		0.000000f,
+		1.000000f,
+		0.931000f,
+		-0.000000f,
+		-0.500000f,
+		0.000000f,
+		0.000000f,
+		0.000000f,
+		-1.000000f,
+		0.000000f,
+		0.411700f,
+		0.051000f,
+		-0.053021f,
+		-0.497069f,
+		0.010546f,
+		0.000000f,
+		-0.109300f,
+		-0.993700f,
+		0.021700f,
+		0.413000f,
+		0.053800f,
+		-0.054060f,
+		-0.497069f,
+		0.000000f,
+		0.000000f,
+		-0.111500f,
+		-0.993700f,
+		0.000000f,
+		0.410400f,
+		0.053800f,
+		-0.483932f,
+		-0.080891f,
+		0.096260f,
+		0.000000f,
+		-0.967900f,
+		-0.161200f,
+		0.192500f,
+		0.031200f,
+		0.448300f,
+		-0.489673f,
+		-0.027069f,
+		0.097402f,
+		0.000000f,
+		-0.979300f,
+		-0.054000f,
+		0.194800f,
+		0.031200f,
+		0.482800f,
+		-0.499267f,
+		-0.027069f,
+		0.000000f,
+		0.000000f,
+		-0.998500f,
+		-0.054000f,
+		0.000000f,
+		0.000000f,
+		0.482800f,
+		-0.483932f,
+		-0.080891f,
+		0.096260f,
+		0.000000f,
+		-0.967900f,
+		-0.161200f,
+		0.192500f,
+		0.031200f,
+		0.448300f,
+		-0.499267f,
+		-0.027069f,
+		0.000000f,
+		0.000000f,
+		-0.998500f,
+		-0.054000f,
+		0.000000f,
+		0.000000f,
+		0.482800f,
+		-0.493414f,
+		-0.080891f,
+		0.000000f,
+		0.000000f,
+		-0.986900f,
+		-0.161200f,
+		0.000000f,
+		0.000000f,
+		0.448300f,
+		-0.156583f,
+		0.473826f,
+		0.031146f,
+		0.000000f,
+		-0.316100f,
+		0.946600f,
+		0.062900f,
+		1.031200f,
+		0.896600f,
+		-0.105420f,
+		0.488310f,
+		0.020969f,
+		0.000000f,
+		-0.214000f,
+		0.975900f,
+		0.042500f,
+		1.031200f,
+		0.931000f,
+		-0.107485f,
+		0.488310f,
+		0.000000f,
+		0.000000f,
+		-0.218200f,
+		0.975900f,
+		0.000000f,
+		1.000000f,
+		0.931000f,
+		-0.156583f,
+		0.473826f,
+		0.031146f,
+		0.000000f,
+		-0.316100f,
+		0.946600f,
+		0.062900f,
+		1.031200f,
+		0.896600f,
+		-0.107485f,
+		0.488310f,
+		0.000000f,
+		0.000000f,
+		-0.218200f,
+		0.975900f,
+		0.000000f,
+		1.000000f,
+		0.931000f,
+		-0.159651f,
+		0.473826f,
+		0.000000f,
+		0.000000f,
+		-0.322300f,
+		0.946600f,
+		0.000000f,
+		1.000000f,
+		0.896600f,
+		-0.472517f,
+		-0.133764f,
+		0.093989f,
+		0.000000f,
+		-0.945200f,
+		-0.266600f,
+		0.188000f,
+		0.031200f,
+		0.413800f,
+		-0.483932f,
+		-0.080891f,
+		0.096260f,
+		0.000000f,
+		-0.967900f,
+		-0.161200f,
+		0.192500f,
+		0.031200f,
+		0.448300f,
+		-0.493414f,
+		-0.080891f,
+		0.000000f,
+		0.000000f,
+		-0.986900f,
+		-0.161200f,
+		0.000000f,
+		0.000000f,
+		0.448300f,
+		-0.472517f,
+		-0.133764f,
+		0.093989f,
+		0.000000f,
+		-0.945200f,
+		-0.266600f,
+		0.188000f,
+		0.031200f,
+		0.413800f,
+		-0.493414f,
+		-0.080891f,
+		0.000000f,
+		0.000000f,
+		-0.986900f,
+		-0.161200f,
+		0.000000f,
+		0.000000f,
+		0.448300f,
+		-0.481775f,
+		-0.133764f,
+		0.000000f,
+		0.000000f,
+		-0.963800f,
+		-0.266600f,
+		0.000000f,
+		0.000000f,
+		0.413800f,
+		-0.205911f,
+		0.453788f,
+		0.040958f,
+		0.000000f,
+		-0.414500f,
+		0.906300f,
+		0.082400f,
+		0.031200f,
+		0.862100f,
+		-0.156583f,
+		0.473826f,
+		0.031146f,
+		0.000000f,
+		-0.316100f,
+		0.946600f,
+		0.062900f,
+		0.031200f,
+		0.896600f,
+		-0.159651f,
+		0.473826f,
+		0.000000f,
+		0.000000f,
+		-0.322300f,
+		0.946600f,
+		0.000000f,
+		0.000000f,
+		0.896600f,
+		-0.205911f,
+		0.453788f,
+		0.040958f,
+		0.000000f,
+		-0.414500f,
+		0.906300f,
+		0.082400f,
+		0.031200f,
+		0.862100f,
+		-0.159651f,
+		0.473826f,
+		0.000000f,
+		0.000000f,
+		-0.322300f,
+		0.946600f,
+		0.000000f,
+		0.000000f,
+		0.896600f,
+		-0.209945f,
+		0.453788f,
+		0.000000f,
+		0.000000f,
+		-0.422700f,
+		0.906300f,
+		0.000000f,
+		0.000000f,
+		0.862100f,
+		-0.455563f,
+		-0.185069f,
+		0.090617f,
+		0.000000f,
+		-0.911600f,
+		-0.369000f,
+		0.181300f,
+		0.031200f,
+		0.379300f,
+		-0.472517f,
+		-0.133764f,
+		0.093989f,
+		0.000000f,
+		-0.945200f,
+		-0.266600f,
+		0.188000f,
+		0.031200f,
+		0.413800f,
+		-0.481775f,
+		-0.133764f,
+		0.000000f,
+		0.000000f,
+		-0.963800f,
+		-0.266600f,
+		0.000000f,
+		0.000000f,
+		0.413800f,
+		-0.455563f,
+		-0.185069f,
+		0.090617f,
+		0.000000f,
+		-0.911600f,
+		-0.369000f,
+		0.181300f,
+		0.031200f,
+		0.379300f,
+		-0.481775f,
+		-0.133764f,
+		0.000000f,
+		0.000000f,
+		-0.963800f,
+		-0.266600f,
+		0.000000f,
+		0.000000f,
+		0.413800f,
+		-0.464489f,
+		-0.185069f,
+		0.000000f,
+		0.000000f,
+		-0.929400f,
+		-0.369000f,
+		0.000000f,
+		0.000000f,
+		0.379300f,
+		-0.252824f,
+		0.428429f,
+		0.050290f,
+		0.000000f,
+		-0.508100f,
+		0.855300f,
+		0.101000f,
+		0.031200f,
+		0.827600f,
+		-0.205911f,
+		0.453788f,
+		0.040958f,
+		0.000000f,
+		-0.414500f,
+		0.906300f,
+		0.082400f,
+		0.031200f,
+		0.862100f,
+		-0.209945f,
+		0.453788f,
+		0.000000f,
+		0.000000f,
+		-0.422700f,
+		0.906300f,
+		0.000000f,
+		0.000000f,
+		0.862100f,
+		-0.252824f,
+		0.428429f,
+		0.050290f,
+		0.000000f,
+		-0.508100f,
+		0.855300f,
+		0.101000f,
+		0.031200f,
+		0.827600f,
+		-0.209945f,
+		0.453788f,
+		0.000000f,
+		0.000000f,
+		-0.422700f,
+		0.906300f,
+		0.000000f,
+		0.000000f,
+		0.862100f,
+		-0.257777f,
+		0.428429f,
+		0.000000f,
+		0.000000f,
+		-0.518000f,
+		0.855300f,
+		0.000000f,
+		0.000000f,
+		0.827600f,
+		-0.433268f,
+		-0.234204f,
+		0.086182f,
+		0.000000f,
+		-0.867200f,
+		-0.467000f,
+		0.172500f,
+		0.031200f,
+		0.344800f,
+		-0.455563f,
+		-0.185069f,
+		0.090617f,
+		0.000000f,
+		-0.911600f,
+		-0.369000f,
+		0.181300f,
+		0.031200f,
+		0.379300f,
+		-0.464489f,
+		-0.185069f,
+		0.000000f,
+		0.000000f,
+		-0.929400f,
+		-0.369000f,
+		0.000000f,
+		0.000000f,
+		0.379300f,
+		-0.433268f,
+		-0.234204f,
+		0.086182f,
+		0.000000f,
+		-0.867200f,
+		-0.467000f,
+		0.172500f,
+		0.031200f,
+		0.344800f,
+		-0.464489f,
+		-0.185069f,
+		0.000000f,
+		0.000000f,
+		-0.929400f,
+		-0.369000f,
+		0.000000f,
+		0.000000f,
+		0.379300f,
+		-0.441756f,
+		-0.234204f,
+		0.000000f,
+		0.000000f,
+		-0.884200f,
+		-0.467000f,
+		0.000000f,
+		0.000000f,
+		0.344800f,
+		-0.296773f,
+		0.398046f,
+		0.059032f,
+		0.000000f,
+		-0.595600f,
+		0.794500f,
+		0.118500f,
+		0.031200f,
+		0.793100f,
+		-0.252824f,
+		0.428429f,
+		0.050290f,
+		0.000000f,
+		-0.508100f,
+		0.855300f,
+		0.101000f,
+		0.031200f,
+		0.827600f,
+		-0.257777f,
+		0.428429f,
+		0.000000f,
+		0.000000f,
+		-0.518000f,
+		0.855300f,
+		0.000000f,
+		0.000000f,
+		0.827600f,
+		-0.296773f,
+		0.398046f,
+		0.059032f,
+		0.000000f,
+		-0.595600f,
+		0.794500f,
+		0.118500f,
+		0.031200f,
+		0.793100f,
+		-0.257777f,
+		0.428429f,
+		0.000000f,
+		0.000000f,
+		-0.518000f,
+		0.855300f,
+		0.000000f,
+		0.000000f,
+		0.827600f,
+		-0.302587f,
+		0.398046f,
+		0.000000f,
+		0.000000f,
+		-0.607300f,
+		0.794500f,
+		0.000000f,
+		0.000000f,
+		0.793100f,
+		-0.405892f,
+		-0.280594f,
+		0.080737f,
+		0.000000f,
+		-0.812800f,
+		-0.559600f,
+		0.161700f,
+		0.031200f,
+		0.310300f,
+		-0.433268f,
+		-0.234204f,
+		0.086182f,
+		0.000000f,
+		-0.867200f,
+		-0.467000f,
+		0.172500f,
+		0.031200f,
+		0.344800f,
+		-0.441756f,
+		-0.234204f,
+		0.000000f,
+		0.000000f,
+		-0.884200f,
+		-0.467000f,
+		0.000000f,
+		0.000000f,
+		0.344800f,
+		-0.405892f,
+		-0.280594f,
+		0.080737f,
+		0.000000f,
+		-0.812800f,
+		-0.559600f,
+		0.161700f,
+		0.031200f,
+		0.310300f,
+		-0.441756f,
+		-0.234204f,
+		0.000000f,
+		0.000000f,
+		-0.884200f,
+		-0.467000f,
+		0.000000f,
+		0.000000f,
+		0.344800f,
+		-0.413844f,
+		-0.280594f,
+		0.000000f,
+		0.000000f,
+		-0.828700f,
+		-0.559600f,
+		0.000000f,
+		0.000000f,
+		0.310300f,
+		-0.337243f,
+		0.362998f,
+		0.067082f,
+		0.000000f,
+		-0.676200f,
+		0.724300f,
+		0.134500f,
+		0.031200f,
+		0.758600f,
+		-0.296773f,
+		0.398046f,
+		0.059032f,
+		0.000000f,
+		-0.595600f,
+		0.794500f,
+		0.118500f,
+		0.031200f,
+		0.793100f,
+		-0.302587f,
+		0.398046f,
+		0.000000f,
+		0.000000f,
+		-0.607300f,
+		0.794500f,
+		0.000000f,
+		0.000000f,
+		0.793100f,
+		-0.337243f,
+		0.362998f,
+		0.067082f,
+		0.000000f,
+		-0.676200f,
+		0.724300f,
+		0.134500f,
+		0.031200f,
+		0.758600f,
+		-0.302587f,
+		0.398046f,
+		0.000000f,
+		0.000000f,
+		-0.607300f,
+		0.794500f,
+		0.000000f,
+		0.000000f,
+		0.793100f,
+		-0.343850f,
+		0.362998f,
+		0.000000f,
+		0.000000f,
+		-0.689400f,
+		0.724300f,
+		0.000000f,
+		0.000000f,
+		0.758600f,
+		-0.373758f,
+		-0.323693f,
+		0.074345f,
+		0.000000f,
+		-0.748900f,
+		-0.645700f,
+		0.149000f,
+		0.031200f,
+		0.275900f,
+		-0.405892f,
+		-0.280594f,
+		0.080737f,
+		0.000000f,
+		-0.812800f,
+		-0.559600f,
+		0.161700f,
+		0.031200f,
+		0.310300f,
+		-0.413844f,
+		-0.280594f,
+		0.000000f,
+		0.000000f,
+		-0.828700f,
+		-0.559600f,
+		0.000000f,
+		0.000000f,
+		0.310300f,
+		-0.373758f,
+		-0.323693f,
+		0.074345f,
+		0.000000f,
+		-0.748900f,
+		-0.645700f,
+		0.149000f,
+		0.031200f,
+		0.275900f,
+		-0.413844f,
+		-0.280594f,
+		0.000000f,
+		0.000000f,
+		-0.828700f,
+		-0.559600f,
+		0.000000f,
+		0.000000f,
+		0.310300f,
+		-0.381081f,
+		-0.323693f,
+		0.000000f,
+		0.000000f,
+		-0.763500f,
+		-0.645700f,
+		0.000000f,
+		0.000000f,
+		0.275900f,
+		-0.373758f,
+		0.323693f,
+		0.074345f,
+		0.000000f,
+		-0.748900f,
+		0.645700f,
+		0.149000f,
+		0.031200f,
+		0.724100f,
+		-0.337243f,
+		0.362998f,
+		0.067082f,
+		0.000000f,
+		-0.676200f,
+		0.724300f,
+		0.134500f,
+		0.031200f,
+		0.758600f,
+		-0.343850f,
+		0.362998f,
+		0.000000f,
+		0.000000f,
+		-0.689400f,
+		0.724300f,
+		0.000000f,
+		0.000000f,
+		0.758600f,
+		-0.373758f,
+		0.323693f,
+		0.074345f,
+		0.000000f,
+		-0.748900f,
+		0.645700f,
+		0.149000f,
+		0.031200f,
+		0.724100f,
+		-0.343850f,
+		0.362998f,
+		0.000000f,
+		0.000000f,
+		-0.689400f,
+		0.724300f,
+		0.000000f,
+		0.000000f,
+		0.758600f,
+		-0.381081f,
+		0.323693f,
+		0.000000f,
+		0.000000f,
+		-0.763500f,
+		0.645700f,
+		0.000000f,
+		0.000000f,
+		0.724100f,
+		-0.337243f,
+		-0.362998f,
+		0.067082f,
+		0.000000f,
+		-0.676200f,
+		-0.724300f,
+		0.134500f,
+		0.031200f,
+		0.241400f,
+		-0.373758f,
+		-0.323693f,
+		0.074345f,
+		0.000000f,
+		-0.748900f,
+		-0.645700f,
+		0.149000f,
+		0.031200f,
+		0.275900f,
+		-0.381081f,
+		-0.323693f,
+		0.000000f,
+		0.000000f,
+		-0.763500f,
+		-0.645700f,
+		0.000000f,
+		0.000000f,
+		0.275900f,
+		-0.337243f,
+		-0.362998f,
+		0.067082f,
+		0.000000f,
+		-0.676200f,
+		-0.724300f,
+		0.134500f,
+		0.031200f,
+		0.241400f,
+		-0.381081f,
+		-0.323693f,
+		0.000000f,
+		0.000000f,
+		-0.763500f,
+		-0.645700f,
+		0.000000f,
+		0.000000f,
+		0.275900f,
+		-0.343850f,
+		-0.362998f,
+		0.000000f,
+		0.000000f,
+		-0.689400f,
+		-0.724300f,
+		0.000000f,
+		0.000000f,
+		0.241400f,
+		-0.405892f,
+		0.280594f,
+		0.080737f,
+		0.000000f,
+		-0.812800f,
+		0.559600f,
+		0.161700f,
+		0.031200f,
+		0.689700f,
+		-0.373758f,
+		0.323693f,
+		0.074345f,
+		0.000000f,
+		-0.748900f,
+		0.645700f,
+		0.149000f,
+		0.031200f,
+		0.724100f,
+		-0.381081f,
+		0.323693f,
+		0.000000f,
+		0.000000f,
+		-0.763500f,
+		0.645700f,
+		0.000000f,
+		0.000000f,
+		0.724100f,
+		-0.405892f,
+		0.280594f,
+		0.080737f,
+		0.000000f,
+		-0.812800f,
+		0.559600f,
+		0.161700f,
+		0.031200f,
+		0.689700f,
+		-0.381081f,
+		0.323693f,
+		0.000000f,
+		0.000000f,
+		-0.763500f,
+		0.645700f,
+		0.000000f,
+		0.000000f,
+		0.724100f,
+		-0.413844f,
+		0.280594f,
+		0.000000f,
+		0.000000f,
+		-0.828700f,
+		0.559600f,
+		0.000000f,
+		0.000000f,
+		0.689700f,
+		-0.296773f,
+		-0.398046f,
+		0.059032f,
+		0.000000f,
+		-0.595600f,
+		-0.794500f,
+		0.118500f,
+		0.031200f,
+		0.206900f,
+		-0.337243f,
+		-0.362998f,
+		0.067082f,
+		0.000000f,
+		-0.676200f,
+		-0.724300f,
+		0.134500f,
+		0.031200f,
+		0.241400f,
+		-0.343850f,
+		-0.362998f,
+		0.000000f,
+		0.000000f,
+		-0.689400f,
+		-0.724300f,
+		0.000000f,
+		0.000000f,
+		0.241400f,
+		-0.296773f,
+		-0.398046f,
+		0.059032f,
+		0.000000f,
+		-0.595600f,
+		-0.794500f,
+		0.118500f,
+		0.031200f,
+		0.206900f,
+		-0.343850f,
+		-0.362998f,
+		0.000000f,
+		0.000000f,
+		-0.689400f,
+		-0.724300f,
+		0.000000f,
+		0.000000f,
+		0.241400f,
+		-0.302588f,
+		-0.398046f,
+		0.000000f,
+		0.000000f,
+		-0.607300f,
+		-0.794500f,
+		0.000000f,
+		0.000000f,
+		0.206900f,
+		-0.433268f,
+		0.234204f,
+		0.086182f,
+		0.000000f,
+		-0.867200f,
+		0.467000f,
+		0.172500f,
+		0.031200f,
+		0.655200f,
+		-0.405892f,
+		0.280594f,
+		0.080737f,
+		0.000000f,
+		-0.812800f,
+		0.559600f,
+		0.161700f,
+		0.031200f,
+		0.689700f,
+		-0.413844f,
+		0.280594f,
+		0.000000f,
+		0.000000f,
+		-0.828700f,
+		0.559600f,
+		0.000000f,
+		0.000000f,
+		0.689700f,
+		-0.433268f,
+		0.234204f,
+		0.086182f,
+		0.000000f,
+		-0.867200f,
+		0.467000f,
+		0.172500f,
+		0.031200f,
+		0.655200f,
+		-0.413844f,
+		0.280594f,
+		0.000000f,
+		0.000000f,
+		-0.828700f,
+		0.559600f,
+		0.000000f,
+		0.000000f,
+		0.689700f,
+		-0.441756f,
+		0.234204f,
+		0.000000f,
+		0.000000f,
+		-0.884200f,
+		0.467000f,
+		0.000000f,
+		0.000000f,
+		0.655200f,
+		-0.252824f,
+		-0.428429f,
+		0.050290f,
+		0.000000f,
+		-0.508100f,
+		-0.855300f,
+		0.101000f,
+		0.031200f,
+		0.172400f,
+		-0.296773f,
+		-0.398046f,
+		0.059032f,
+		0.000000f,
+		-0.595600f,
+		-0.794500f,
+		0.118500f,
+		0.031200f,
+		0.206900f,
+		-0.302588f,
+		-0.398046f,
+		0.000000f,
+		0.000000f,
+		-0.607300f,
+		-0.794500f,
+		0.000000f,
+		0.000000f,
+		0.206900f,
+		-0.252824f,
+		-0.428429f,
+		0.050290f,
+		0.000000f,
+		-0.508100f,
+		-0.855300f,
+		0.101000f,
+		0.031200f,
+		0.172400f,
+		-0.302588f,
+		-0.398046f,
+		0.000000f,
+		0.000000f,
+		-0.607300f,
+		-0.794500f,
+		0.000000f,
+		0.000000f,
+		0.206900f,
+		-0.257777f,
+		-0.428429f,
+		0.000000f,
+		0.000000f,
+		-0.518000f,
+		-0.855300f,
+		0.000000f,
+		0.000000f,
+		0.172400f,
+		-0.455563f,
+		0.185069f,
+		0.090617f,
+		0.000000f,
+		-0.911600f,
+		0.369000f,
+		0.181300f,
+		0.031200f,
+		0.620700f,
+		-0.433268f,
+		0.234204f,
+		0.086182f,
+		0.000000f,
+		-0.867200f,
+		0.467000f,
+		0.172500f,
+		0.031200f,
+		0.655200f,
+		-0.441756f,
+		0.234204f,
+		0.000000f,
+		0.000000f,
+		-0.884200f,
+		0.467000f,
+		0.000000f,
+		0.000000f,
+		0.655200f,
+		-0.455563f,
+		0.185069f,
+		0.090617f,
+		0.000000f,
+		-0.911600f,
+		0.369000f,
+		0.181300f,
+		0.031200f,
+		0.620700f,
+		-0.441756f,
+		0.234204f,
+		0.000000f,
+		0.000000f,
+		-0.884200f,
+		0.467000f,
+		0.000000f,
+		0.000000f,
+		0.655200f,
+		-0.464489f,
+		0.185069f,
+		0.000000f,
+		0.000000f,
+		-0.929400f,
+		0.369000f,
+		0.000000f,
+		0.000000f,
+		0.620700f,
+};
+
+const int textured_detailed_sphere_indices[] =
+	{
+		0,
+		1,
+		2,
+		3,
+		4,
+		5,
+		6,
+		7,
+		8,
+		9,
+		10,
+		11,
+		12,
+		13,
+		14,
+		15,
+		16,
+		17,
+		18,
+		19,
+		20,
+		21,
+		22,
+		23,
+		24,
+		25,
+		26,
+		27,
+		28,
+		29,
+		30,
+		31,
+		32,
+		33,
+		34,
+		35,
+		36,
+		37,
+		38,
+		39,
+		40,
+		41,
+		42,
+		43,
+		44,
+		45,
+		46,
+		47,
+		48,
+		49,
+		50,
+		51,
+		52,
+		53,
+		54,
+		55,
+		56,
+		57,
+		58,
+		59,
+		60,
+		61,
+		62,
+		63,
+		64,
+		65,
+		66,
+		67,
+		68,
+		69,
+		70,
+		71,
+		72,
+		73,
+		74,
+		75,
+		76,
+		77,
+		78,
+		79,
+		80,
+		81,
+		82,
+		83,
+		84,
+		85,
+		86,
+		87,
+		88,
+		89,
+		90,
+		91,
+		92,
+		93,
+		94,
+		95,
+		96,
+		97,
+		98,
+		99,
+		100,
+		101,
+		102,
+		103,
+		104,
+		105,
+		106,
+		107,
+		108,
+		109,
+		110,
+		111,
+		112,
+		113,
+		114,
+		115,
+		116,
+		117,
+		118,
+		119,
+		120,
+		121,
+		122,
+		123,
+		124,
+		125,
+		126,
+		127,
+		128,
+		129,
+		130,
+		131,
+		132,
+		133,
+		134,
+		135,
+		136,
+		137,
+		138,
+		139,
+		140,
+		141,
+		142,
+		143,
+		144,
+		145,
+		146,
+		147,
+		148,
+		149,
+		150,
+		151,
+		152,
+		153,
+		154,
+		155,
+		156,
+		157,
+		158,
+		159,
+		160,
+		161,
+		162,
+		163,
+		164,
+		165,
+		166,
+		167,
+		168,
+		169,
+		170,
+		171,
+		172,
+		173,
+		174,
+		175,
+		176,
+		177,
+		178,
+		179,
+		180,
+		181,
+		182,
+		183,
+		184,
+		185,
+		186,
+		187,
+		188,
+		189,
+		190,
+		191,
+		192,
+		193,
+		194,
+		195,
+		196,
+		197,
+		198,
+		199,
+		200,
+		201,
+		202,
+		203,
+		204,
+		205,
+		206,
+		207,
+		208,
+		209,
+		210,
+		211,
+		212,
+		213,
+		214,
+		215,
+		216,
+		217,
+		218,
+		219,
+		220,
+		221,
+		222,
+		223,
+		224,
+		225,
+		226,
+		227,
+		228,
+		229,
+		230,
+		231,
+		232,
+		233,
+		234,
+		235,
+		236,
+		237,
+		238,
+		239,
+		240,
+		241,
+		242,
+		243,
+		244,
+		245,
+		246,
+		247,
+		248,
+		249,
+		250,
+		251,
+		252,
+		253,
+		254,
+		255,
+		256,
+		257,
+		258,
+		259,
+		260,
+		261,
+		262,
+		263,
+		264,
+		265,
+		266,
+		267,
+		268,
+		269,
+		270,
+		271,
+		272,
+		273,
+		274,
+		275,
+		276,
+		277,
+		278,
+		279,
+		280,
+		281,
+		282,
+		283,
+		284,
+		285,
+		286,
+		287,
+		288,
+		289,
+		290,
+		291,
+		292,
+		293,
+		294,
+		295,
+		296,
+		297,
+		298,
+		299,
+		300,
+		301,
+		302,
+		303,
+		304,
+		305,
+		306,
+		307,
+		308,
+		309,
+		310,
+		311,
+		312,
+		313,
+		314,
+		315,
+		316,
+		317,
+		318,
+		319,
+		320,
+		321,
+		322,
+		323,
+		324,
+		325,
+		326,
+		327,
+		328,
+		329,
+		330,
+		331,
+		332,
+		333,
+		334,
+		335,
+		336,
+		337,
+		338,
+		339,
+		340,
+		341,
+		342,
+		343,
+		344,
+		345,
+		346,
+		347,
+		348,
+		349,
+		350,
+		351,
+		352,
+		353,
+		354,
+		355,
+		356,
+		357,
+		358,
+		359,
+		360,
+		361,
+		362,
+		363,
+		364,
+		365,
+		366,
+		367,
+		368,
+		369,
+		370,
+		371,
+		372,
+		373,
+		374,
+		375,
+		376,
+		377,
+		378,
+		379,
+		380,
+		381,
+		382,
+		383,
+		384,
+		385,
+		386,
+		387,
+		388,
+		389,
+		390,
+		391,
+		392,
+		393,
+		394,
+		395,
+		396,
+		397,
+		398,
+		399,
+		400,
+		401,
+		402,
+		403,
+		404,
+		405,
+		406,
+		407,
+		408,
+		409,
+		410,
+		411,
+		412,
+		413,
+		414,
+		415,
+		416,
+		417,
+		418,
+		419,
+		420,
+		421,
+		422,
+		423,
+		424,
+		425,
+		426,
+		427,
+		428,
+		429,
+		430,
+		431,
+		432,
+		433,
+		434,
+		435,
+		436,
+		437,
+		438,
+		439,
+		440,
+		441,
+		442,
+		443,
+		444,
+		445,
+		446,
+		447,
+		448,
+		449,
+		450,
+		451,
+		452,
+		453,
+		454,
+		455,
+		456,
+		457,
+		458,
+		459,
+		460,
+		461,
+		462,
+		463,
+		464,
+		465,
+		466,
+		467,
+		468,
+		469,
+		470,
+		471,
+		472,
+		473,
+		474,
+		475,
+		476,
+		477,
+		478,
+		479,
+		480,
+		481,
+		482,
+		483,
+		484,
+		485,
+		486,
+		487,
+		488,
+		489,
+		490,
+		491,
+		492,
+		493,
+		494,
+		495,
+		496,
+		497,
+		498,
+		499,
+		500,
+		501,
+		502,
+		503,
+		504,
+		505,
+		506,
+		507,
+		508,
+		509,
+		510,
+		511,
+		512,
+		513,
+		514,
+		515,
+		516,
+		517,
+		518,
+		519,
+		520,
+		521,
+		522,
+		523,
+		524,
+		525,
+		526,
+		527,
+		528,
+		529,
+		530,
+		531,
+		532,
+		533,
+		534,
+		535,
+		536,
+		537,
+		538,
+		539,
+		540,
+		541,
+		542,
+		543,
+		544,
+		545,
+		546,
+		547,
+		548,
+		549,
+		550,
+		551,
+		552,
+		553,
+		554,
+		555,
+		556,
+		557,
+		558,
+		559,
+		560,
+		561,
+		562,
+		563,
+		564,
+		565,
+		566,
+		567,
+		568,
+		569,
+		570,
+		571,
+		572,
+		573,
+		574,
+		575,
+		576,
+		577,
+		578,
+		579,
+		580,
+		581,
+		582,
+		583,
+		584,
+		585,
+		586,
+		587,
+		588,
+		589,
+		590,
+		591,
+		592,
+		593,
+		594,
+		595,
+		596,
+		597,
+		598,
+		599,
+		600,
+		601,
+		602,
+		603,
+		604,
+		605,
+		606,
+		607,
+		608,
+		609,
+		610,
+		611,
+		612,
+		613,
+		614,
+		615,
+		616,
+		617,
+		618,
+		619,
+		620,
+		621,
+		622,
+		623,
+		624,
+		625,
+		626,
+		627,
+		628,
+		629,
+		630,
+		631,
+		632,
+		633,
+		634,
+		635,
+		636,
+		637,
+		638,
+		639,
+		640,
+		641,
+		642,
+		643,
+		644,
+		645,
+		646,
+		647,
+		648,
+		649,
+		650,
+		651,
+		652,
+		653,
+		654,
+		655,
+		656,
+		657,
+		658,
+		659,
+		660,
+		661,
+		662,
+		663,
+		664,
+		665,
+		666,
+		667,
+		668,
+		669,
+		670,
+		671,
+		672,
+		673,
+		674,
+		675,
+		676,
+		677,
+		678,
+		679,
+		680,
+		681,
+		682,
+		683,
+		684,
+		685,
+		686,
+		687,
+		688,
+		689,
+		690,
+		691,
+		692,
+		693,
+		694,
+		695,
+		696,
+		697,
+		698,
+		699,
+		700,
+		701,
+		702,
+		703,
+		704,
+		705,
+		706,
+		707,
+		708,
+		709,
+		710,
+		711,
+		712,
+		713,
+		714,
+		715,
+		716,
+		717,
+		718,
+		719,
+		720,
+		721,
+		722,
+		723,
+		724,
+		725,
+		726,
+		727,
+		728,
+		729,
+		730,
+		731,
+		732,
+		733,
+		734,
+		735,
+		736,
+		737,
+		738,
+		739,
+		740,
+		741,
+		742,
+		743,
+		744,
+		745,
+		746,
+		747,
+		748,
+		749,
+		750,
+		751,
+		752,
+		753,
+		754,
+		755,
+		756,
+		757,
+		758,
+		759,
+		760,
+		761,
+		762,
+		763,
+		764,
+		765,
+		766,
+		767,
+		768,
+		769,
+		770,
+		771,
+		772,
+		773,
+		774,
+		775,
+		776,
+		777,
+		778,
+		779,
+		780,
+		781,
+		782,
+		783,
+		784,
+		785,
+		786,
+		787,
+		788,
+		789,
+		790,
+		791,
+		792,
+		793,
+		794,
+		795,
+		796,
+		797,
+		798,
+		799,
+		800,
+		801,
+		802,
+		803,
+		804,
+		805,
+		806,
+		807,
+		808,
+		809,
+		810,
+		811,
+		812,
+		813,
+		814,
+		815,
+		816,
+		817,
+		818,
+		819,
+		820,
+		821,
+		822,
+		823,
+		824,
+		825,
+		826,
+		827,
+		828,
+		829,
+		830,
+		831,
+		832,
+		833,
+		834,
+		835,
+		836,
+		837,
+		838,
+		839,
+		840,
+		841,
+		842,
+		843,
+		844,
+		845,
+		846,
+		847,
+		848,
+		849,
+		850,
+		851,
+		852,
+		853,
+		854,
+		855,
+		856,
+		857,
+		858,
+		859,
+		860,
+		861,
+		862,
+		863,
+		864,
+		865,
+		866,
+		867,
+		868,
+		869,
+		870,
+		871,
+		872,
+		873,
+		874,
+		875,
+		876,
+		877,
+		878,
+		879,
+		880,
+		881,
+		882,
+		883,
+		884,
+		885,
+		886,
+		887,
+		888,
+		889,
+		890,
+		891,
+		892,
+		893,
+		894,
+		895,
+		896,
+		897,
+		898,
+		899,
+		900,
+		901,
+		902,
+		903,
+		904,
+		905,
+		906,
+		907,
+		908,
+		909,
+		910,
+		911,
+		912,
+		913,
+		914,
+		915,
+		916,
+		917,
+		918,
+		919,
+		920,
+		921,
+		922,
+		923,
+		924,
+		925,
+		926,
+		927,
+		928,
+		929,
+		930,
+		931,
+		932,
+		933,
+		934,
+		935,
+		936,
+		937,
+		938,
+		939,
+		940,
+		941,
+		942,
+		943,
+		944,
+		945,
+		946,
+		947,
+		948,
+		949,
+		950,
+		951,
+		952,
+		953,
+		954,
+		955,
+		956,
+		957,
+		958,
+		959,
+		960,
+		961,
+		962,
+		963,
+		964,
+		965,
+		966,
+		967,
+		968,
+		969,
+		970,
+		971,
+		972,
+		973,
+		974,
+		975,
+		976,
+		977,
+		978,
+		979,
+		980,
+		981,
+		982,
+		983,
+		984,
+		985,
+		986,
+		987,
+		988,
+		989,
+		990,
+		991,
+		992,
+		993,
+		994,
+		995,
+		996,
+		997,
+		998,
+		999,
+		1000,
+		1001,
+		1002,
+		1003,
+		1004,
+		1005,
+		1006,
+		1007,
+		1008,
+		1009,
+		1010,
+		1011,
+		1012,
+		1013,
+		1014,
+		1015,
+		1016,
+		1017,
+		1018,
+		1019,
+		1020,
+		1021,
+		1022,
+		1023,
+		1024,
+		1025,
+		1026,
+		1027,
+		1028,
+		1029,
+		1030,
+		1031,
+		1032,
+		1033,
+		1034,
+		1035,
+		1036,
+		1037,
+		1038,
+		1039,
+		1040,
+		1041,
+		1042,
+		1043,
+		1044,
+		1045,
+		1046,
+		1047,
+		1048,
+		1049,
+		1050,
+		1051,
+		1052,
+		1053,
+		1054,
+		1055,
+		1056,
+		1057,
+		1058,
+		1059,
+		1060,
+		1061,
+		1062,
+		1063,
+		1064,
+		1065,
+		1066,
+		1067,
+		1068,
+		1069,
+		1070,
+		1071,
+		1072,
+		1073,
+		1074,
+		1075,
+		1076,
+		1077,
+		1078,
+		1079,
+		1080,
+		1081,
+		1082,
+		1083,
+		1084,
+		1085,
+		1086,
+		1087,
+		1088,
+		1089,
+		1090,
+		1091,
+		1092,
+		1093,
+		1094,
+		1095,
+		1096,
+		1097,
+		1098,
+		1099,
+		1100,
+		1101,
+		1102,
+		1103,
+		1104,
+		1105,
+		1106,
+		1107,
+		1108,
+		1109,
+		1110,
+		1111,
+		1112,
+		1113,
+		1114,
+		1115,
+		1116,
+		1117,
+		1118,
+		1119,
+		1120,
+		1121,
+		1122,
+		1123,
+		1124,
+		1125,
+		1126,
+		1127,
+		1128,
+		1129,
+		1130,
+		1131,
+		1132,
+		1133,
+		1134,
+		1135,
+		1136,
+		1137,
+		1138,
+		1139,
+		1140,
+		1141,
+		1142,
+		1143,
+		1144,
+		1145,
+		1146,
+		1147,
+		1148,
+		1149,
+		1150,
+		1151,
+		1152,
+		1153,
+		1154,
+		1155,
+		1156,
+		1157,
+		1158,
+		1159,
+		1160,
+		1161,
+		1162,
+		1163,
+		1164,
+		1165,
+		1166,
+		1167,
+		1168,
+		1169,
+		1170,
+		1171,
+		1172,
+		1173,
+		1174,
+		1175,
+		1176,
+		1177,
+		1178,
+		1179,
+		1180,
+		1181,
+		1182,
+		1183,
+		1184,
+		1185,
+		1186,
+		1187,
+		1188,
+		1189,
+		1190,
+		1191,
+		1192,
+		1193,
+		1194,
+		1195,
+		1196,
+		1197,
+		1198,
+		1199,
+		1200,
+		1201,
+		1202,
+		1203,
+		1204,
+		1205,
+		1206,
+		1207,
+		1208,
+		1209,
+		1210,
+		1211,
+		1212,
+		1213,
+		1214,
+		1215,
+		1216,
+		1217,
+		1218,
+		1219,
+		1220,
+		1221,
+		1222,
+		1223,
+		1224,
+		1225,
+		1226,
+		1227,
+		1228,
+		1229,
+		1230,
+		1231,
+		1232,
+		1233,
+		1234,
+		1235,
+		1236,
+		1237,
+		1238,
+		1239,
+		1240,
+		1241,
+		1242,
+		1243,
+		1244,
+		1245,
+		1246,
+		1247,
+		1248,
+		1249,
+		1250,
+		1251,
+		1252,
+		1253,
+		1254,
+		1255,
+		1256,
+		1257,
+		1258,
+		1259,
+		1260,
+		1261,
+		1262,
+		1263,
+		1264,
+		1265,
+		1266,
+		1267,
+		1268,
+		1269,
+		1270,
+		1271,
+		1272,
+		1273,
+		1274,
+		1275,
+		1276,
+		1277,
+		1278,
+		1279,
+		1280,
+		1281,
+		1282,
+		1283,
+		1284,
+		1285,
+		1286,
+		1287,
+		1288,
+		1289,
+		1290,
+		1291,
+		1292,
+		1293,
+		1294,
+		1295,
+		1296,
+		1297,
+		1298,
+		1299,
+		1300,
+		1301,
+		1302,
+		1303,
+		1304,
+		1305,
+		1306,
+		1307,
+		1308,
+		1309,
+		1310,
+		1311,
+		1312,
+		1313,
+		1314,
+		1315,
+		1316,
+		1317,
+		1318,
+		1319,
+		1320,
+		1321,
+		1322,
+		1323,
+		1324,
+		1325,
+		1326,
+		1327,
+		1328,
+		1329,
+		1330,
+		1331,
+		1332,
+		1333,
+		1334,
+		1335,
+		1336,
+		1337,
+		1338,
+		1339,
+		1340,
+		1341,
+		1342,
+		1343,
+		1344,
+		1345,
+		1346,
+		1347,
+		1348,
+		1349,
+		1350,
+		1351,
+		1352,
+		1353,
+		1354,
+		1355,
+		1356,
+		1357,
+		1358,
+		1359,
+		1360,
+		1361,
+		1362,
+		1363,
+		1364,
+		1365,
+		1366,
+		1367,
+		1368,
+		1369,
+		1370,
+		1371,
+		1372,
+		1373,
+		1374,
+		1375,
+		1376,
+		1377,
+		1378,
+		1379,
+		1380,
+		1381,
+		1382,
+		1383,
+		1384,
+		1385,
+		1386,
+		1387,
+		1388,
+		1389,
+		1390,
+		1391,
+		1392,
+		1393,
+		1394,
+		1395,
+		1396,
+		1397,
+		1398,
+		1399,
+		1400,
+		1401,
+		1402,
+		1403,
+		1404,
+		1405,
+		1406,
+		1407,
+		1408,
+		1409,
+		1410,
+		1411,
+		1412,
+		1413,
+		1414,
+		1415,
+		1416,
+		1417,
+		1418,
+		1419,
+		1420,
+		1421,
+		1422,
+		1423,
+		1424,
+		1425,
+		1426,
+		1427,
+		1428,
+		1429,
+		1430,
+		1431,
+		1432,
+		1433,
+		1434,
+		1435,
+		1436,
+		1437,
+		1438,
+		1439,
+		1440,
+		1441,
+		1442,
+		1443,
+		1444,
+		1445,
+		1446,
+		1447,
+		1448,
+		1449,
+		1450,
+		1451,
+		1452,
+		1453,
+		1454,
+		1455,
+		1456,
+		1457,
+		1458,
+		1459,
+		1460,
+		1461,
+		1462,
+		1463,
+		1464,
+		1465,
+		1466,
+		1467,
+		1468,
+		1469,
+		1470,
+		1471,
+		1472,
+		1473,
+		1474,
+		1475,
+		1476,
+		1477,
+		1478,
+		1479,
+		1480,
+		1481,
+		1482,
+		1483,
+		1484,
+		1485,
+		1486,
+		1487,
+		1488,
+		1489,
+		1490,
+		1491,
+		1492,
+		1493,
+		1494,
+		1495,
+		1496,
+		1497,
+		1498,
+		1499,
+		1500,
+		1501,
+		1502,
+		1503,
+		1504,
+		1505,
+		1506,
+		1507,
+		1508,
+		1509,
+		1510,
+		1511,
+		1512,
+		1513,
+		1514,
+		1515,
+		1516,
+		1517,
+		1518,
+		1519,
+		1520,
+		1521,
+		1522,
+		1523,
+		1524,
+		1525,
+		1526,
+		1527,
+		1528,
+		1529,
+		1530,
+		1531,
+		1532,
+		1533,
+		1534,
+		1535,
+		1536,
+		1537,
+		1538,
+		1539,
+		1540,
+		1541,
+		1542,
+		1543,
+		1544,
+		1545,
+		1546,
+		1547,
+		1548,
+		1549,
+		1550,
+		1551,
+		1552,
+		1553,
+		1554,
+		1555,
+		1556,
+		1557,
+		1558,
+		1559,
+		1560,
+		1561,
+		1562,
+		1563,
+		1564,
+		1565,
+		1566,
+		1567,
+		1568,
+		1569,
+		1570,
+		1571,
+		1572,
+		1573,
+		1574,
+		1575,
+		1576,
+		1577,
+		1578,
+		1579,
+		1580,
+		1581,
+		1582,
+		1583,
+		1584,
+		1585,
+		1586,
+		1587,
+		1588,
+		1589,
+		1590,
+		1591,
+		1592,
+		1593,
+		1594,
+		1595,
+		1596,
+		1597,
+		1598,
+		1599,
+		1600,
+		1601,
+		1602,
+		1603,
+		1604,
+		1605,
+		1606,
+		1607,
+		1608,
+		1609,
+		1610,
+		1611,
+		1612,
+		1613,
+		1614,
+		1615,
+		1616,
+		1617,
+		1618,
+		1619,
+		1620,
+		1621,
+		1622,
+		1623,
+		1624,
+		1625,
+		1626,
+		1627,
+		1628,
+		1629,
+		1630,
+		1631,
+		1632,
+		1633,
+		1634,
+		1635,
+		1636,
+		1637,
+		1638,
+		1639,
+		1640,
+		1641,
+		1642,
+		1643,
+		1644,
+		1645,
+		1646,
+		1647,
+		1648,
+		1649,
+		1650,
+		1651,
+		1652,
+		1653,
+		1654,
+		1655,
+		1656,
+		1657,
+		1658,
+		1659,
+		1660,
+		1661,
+		1662,
+		1663,
+		1664,
+		1665,
+		1666,
+		1667,
+		1668,
+		1669,
+		1670,
+		1671,
+		1672,
+		1673,
+		1674,
+		1675,
+		1676,
+		1677,
+		1678,
+		1679,
+		1680,
+		1681,
+		1682,
+		1683,
+		1684,
+		1685,
+		1686,
+		1687,
+		1688,
+		1689,
+		1690,
+		1691,
+		1692,
+		1693,
+		1694,
+		1695,
+		1696,
+		1697,
+		1698,
+		1699,
+		1700,
+		1701,
+		1702,
+		1703,
+		1704,
+		1705,
+		1706,
+		1707,
+		1708,
+		1709,
+		1710,
+		1711,
+		1712,
+		1713,
+		1714,
+		1715,
+		1716,
+		1717,
+		1718,
+		1719,
+		1720,
+		1721,
+		1722,
+		1723,
+		1724,
+		1725,
+		1726,
+		1727,
+		1728,
+		1729,
+		1730,
+		1731,
+		1732,
+		1733,
+		1734,
+		1735,
+		1736,
+		1737,
+		1738,
+		1739,
+		1740,
+		1741,
+		1742,
+		1743,
+		1744,
+		1745,
+		1746,
+		1747,
+		1748,
+		1749,
+		1750,
+		1751,
+		1752,
+		1753,
+		1754,
+		1755,
+		1756,
+		1757,
+		1758,
+		1759,
+		1760,
+		1761,
+		1762,
+		1763,
+		1764,
+		1765,
+		1766,
+		1767,
+		1768,
+		1769,
+		1770,
+		1771,
+		1772,
+		1773,
+		1774,
+		1775,
+		1776,
+		1777,
+		1778,
+		1779,
+		1780,
+		1781,
+		1782,
+		1783,
+		1784,
+		1785,
+		1786,
+		1787,
+		1788,
+		1789,
+		1790,
+		1791,
+		1792,
+		1793,
+		1794,
+		1795,
+		1796,
+		1797,
+		1798,
+		1799,
+		1800,
+		1801,
+		1802,
+		1803,
+		1804,
+		1805,
+		1806,
+		1807,
+		1808,
+		1809,
+		1810,
+		1811,
+		1812,
+		1813,
+		1814,
+		1815,
+		1816,
+		1817,
+		1818,
+		1819,
+		1820,
+		1821,
+		1822,
+		1823,
+		1824,
+		1825,
+		1826,
+		1827,
+		1828,
+		1829,
+		1830,
+		1831,
+		1832,
+		1833,
+		1834,
+		1835,
+		1836,
+		1837,
+		1838,
+		1839,
+		1840,
+		1841,
+		1842,
+		1843,
+		1844,
+		1845,
+		1846,
+		1847,
+		1848,
+		1849,
+		1850,
+		1851,
+		1852,
+		1853,
+		1854,
+		1855,
+		1856,
+		1857,
+		1858,
+		1859,
+		1860,
+		1861,
+		1862,
+		1863,
+		1864,
+		1865,
+		1866,
+		1867,
+		1868,
+		1869,
+		1870,
+		1871,
+		1872,
+		1873,
+		1874,
+		1875,
+		1876,
+		1877,
+		1878,
+		1879,
+		1880,
+		1881,
+		1882,
+		1883,
+		1884,
+		1885,
+		1886,
+		1887,
+		1888,
+		1889,
+		1890,
+		1891,
+		1892,
+		1893,
+		1894,
+		1895,
+		1896,
+		1897,
+		1898,
+		1899,
+		1900,
+		1901,
+		1902,
+		1903,
+		1904,
+		1905,
+		1906,
+		1907,
+		1908,
+		1909,
+		1910,
+		1911,
+		1912,
+		1913,
+		1914,
+		1915,
+		1916,
+		1917,
+		1918,
+		1919,
+		1920,
+		1921,
+		1922,
+		1923,
+		1924,
+		1925,
+		1926,
+		1927,
+		1928,
+		1929,
+		1930,
+		1931,
+		1932,
+		1933,
+		1934,
+		1935,
+		1936,
+		1937,
+		1938,
+		1939,
+		1940,
+		1941,
+		1942,
+		1943,
+		1944,
+		1945,
+		1946,
+		1947,
+		1948,
+		1949,
+		1950,
+		1951,
+		1952,
+		1953,
+		1954,
+		1955,
+		1956,
+		1957,
+		1958,
+		1959,
+		1960,
+		1961,
+		1962,
+		1963,
+		1964,
+		1965,
+		1966,
+		1967,
+		1968,
+		1969,
+		1970,
+		1971,
+		1972,
+		1973,
+		1974,
+		1975,
+		1976,
+		1977,
+		1978,
+		1979,
+		1980,
+		1981,
+		1982,
+		1983,
+		1984,
+		1985,
+		1986,
+		1987,
+		1988,
+		1989,
+		1990,
+		1991,
+		1992,
+		1993,
+		1994,
+		1995,
+		1996,
+		1997,
+		1998,
+		1999,
+		2000,
+		2001,
+		2002,
+		2003,
+		2004,
+		2005,
+		2006,
+		2007,
+		2008,
+		2009,
+		2010,
+		2011,
+		2012,
+		2013,
+		2014,
+		2015,
+		2016,
+		2017,
+		2018,
+		2019,
+		2020,
+		2021,
+		2022,
+		2023,
+		2024,
+		2025,
+		2026,
+		2027,
+		2028,
+		2029,
+		2030,
+		2031,
+		2032,
+		2033,
+		2034,
+		2035,
+		2036,
+		2037,
+		2038,
+		2039,
+		2040,
+		2041,
+		2042,
+		2043,
+		2044,
+		2045,
+		2046,
+		2047,
+		2048,
+		2049,
+		2050,
+		2051,
+		2052,
+		2053,
+		2054,
+		2055,
+		2056,
+		2057,
+		2058,
+		2059,
+		2060,
+		2061,
+		2062,
+		2063,
+		2064,
+		2065,
+		2066,
+		2067,
+		2068,
+		2069,
+		2070,
+		2071,
+		2072,
+		2073,
+		2074,
+		2075,
+		2076,
+		2077,
+		2078,
+		2079,
+		2080,
+		2081,
+		2082,
+		2083,
+		2084,
+		2085,
+		2086,
+		2087,
+		2088,
+		2089,
+		2090,
+		2091,
+		2092,
+		2093,
+		2094,
+		2095,
+		2096,
+		2097,
+		2098,
+		2099,
+		2100,
+		2101,
+		2102,
+		2103,
+		2104,
+		2105,
+		2106,
+		2107,
+		2108,
+		2109,
+		2110,
+		2111,
+		2112,
+		2113,
+		2114,
+		2115,
+		2116,
+		2117,
+		2118,
+		2119,
+		2120,
+		2121,
+		2122,
+		2123,
+		2124,
+		2125,
+		2126,
+		2127,
+		2128,
+		2129,
+		2130,
+		2131,
+		2132,
+		2133,
+		2134,
+		2135,
+		2136,
+		2137,
+		2138,
+		2139,
+		2140,
+		2141,
+		2142,
+		2143,
+		2144,
+		2145,
+		2146,
+		2147,
+		2148,
+		2149,
+		2150,
+		2151,
+		2152,
+		2153,
+		2154,
+		2155,
+		2156,
+		2157,
+		2158,
+		2159,
+		2160,
+		2161,
+		2162,
+		2163,
+		2164,
+		2165,
+		2166,
+		2167,
+		2168,
+		2169,
+		2170,
+		2171,
+		2172,
+		2173,
+		2174,
+		2175,
+		2176,
+		2177,
+		2178,
+		2179,
+		2180,
+		2181,
+		2182,
+		2183,
+		2184,
+		2185,
+		2186,
+		2187,
+		2188,
+		2189,
+		2190,
+		2191,
+		2192,
+		2193,
+		2194,
+		2195,
+		2196,
+		2197,
+		2198,
+		2199,
+		2200,
+		2201,
+		2202,
+		2203,
+		2204,
+		2205,
+		2206,
+		2207,
+		2208,
+		2209,
+		2210,
+		2211,
+		2212,
+		2213,
+		2214,
+		2215,
+		2216,
+		2217,
+		2218,
+		2219,
+		2220,
+		2221,
+		2222,
+		2223,
+		2224,
+		2225,
+		2226,
+		2227,
+		2228,
+		2229,
+		2230,
+		2231,
+		2232,
+		2233,
+		2234,
+		2235,
+		2236,
+		2237,
+		2238,
+		2239,
+		2240,
+		2241,
+		2242,
+		2243,
+		2244,
+		2245,
+		2246,
+		2247,
+		2248,
+		2249,
+		2250,
+		2251,
+		2252,
+		2253,
+		2254,
+		2255,
+		2256,
+		2257,
+		2258,
+		2259,
+		2260,
+		2261,
+		2262,
+		2263,
+		2264,
+		2265,
+		2266,
+		2267,
+		2268,
+		2269,
+		2270,
+		2271,
+		2272,
+		2273,
+		2274,
+		2275,
+		2276,
+		2277,
+		2278,
+		2279,
+		2280,
+		2281,
+		2282,
+		2283,
+		2284,
+		2285,
+		2286,
+		2287,
+		2288,
+		2289,
+		2290,
+		2291,
+		2292,
+		2293,
+		2294,
+		2295,
+		2296,
+		2297,
+		2298,
+		2299,
+		2300,
+		2301,
+		2302,
+		2303,
+		2304,
+		2305,
+		2306,
+		2307,
+		2308,
+		2309,
+		2310,
+		2311,
+		2312,
+		2313,
+		2314,
+		2315,
+		2316,
+		2317,
+		2318,
+		2319,
+		2320,
+		2321,
+		2322,
+		2323,
+		2324,
+		2325,
+		2326,
+		2327,
+		2328,
+		2329,
+		2330,
+		2331,
+		2332,
+		2333,
+		2334,
+		2335,
+		2336,
+		2337,
+		2338,
+		2339,
+		2340,
+		2341,
+		2342,
+		2343,
+		2344,
+		2345,
+		2346,
+		2347,
+		2348,
+		2349,
+		2350,
+		2351,
+		2352,
+		2353,
+		2354,
+		2355,
+		2356,
+		2357,
+		2358,
+		2359,
+		2360,
+		2361,
+		2362,
+		2363,
+		2364,
+		2365,
+		2366,
+		2367,
+		2368,
+		2369,
+		2370,
+		2371,
+		2372,
+		2373,
+		2374,
+		2375,
+		2376,
+		2377,
+		2378,
+		2379,
+		2380,
+		2381,
+		2382,
+		2383,
+		2384,
+		2385,
+		2386,
+		2387,
+		2388,
+		2389,
+		2390,
+		2391,
+		2392,
+		2393,
+		2394,
+		2395,
+		2396,
+		2397,
+		2398,
+		2399,
+		2400,
+		2401,
+		2402,
+		2403,
+		2404,
+		2405,
+		2406,
+		2407,
+		2408,
+		2409,
+		2410,
+		2411,
+		2412,
+		2413,
+		2414,
+		2415,
+		2416,
+		2417,
+		2418,
+		2419,
+		2420,
+		2421,
+		2422,
+		2423,
+		2424,
+		2425,
+		2426,
+		2427,
+		2428,
+		2429,
+		2430,
+		2431,
+		2432,
+		2433,
+		2434,
+		2435,
+		2436,
+		2437,
+		2438,
+		2439,
+		2440,
+		2441,
+		2442,
+		2443,
+		2444,
+		2445,
+		2446,
+		2447,
+		2448,
+		2449,
+		2450,
+		2451,
+		2452,
+		2453,
+		2454,
+		2455,
+		2456,
+		2457,
+		2458,
+		2459,
+		2460,
+		2461,
+		2462,
+		2463,
+		2464,
+		2465,
+		2466,
+		2467,
+		2468,
+		2469,
+		2470,
+		2471,
+		2472,
+		2473,
+		2474,
+		2475,
+		2476,
+		2477,
+		2478,
+		2479,
+		2480,
+		2481,
+		2482,
+		2483,
+		2484,
+		2485,
+		2486,
+		2487,
+		2488,
+		2489,
+		2490,
+		2491,
+		2492,
+		2493,
+		2494,
+		2495,
+		2496,
+		2497,
+		2498,
+		2499,
+		2500,
+		2501,
+		2502,
+		2503,
+		2504,
+		2505,
+		2506,
+		2507,
+		2508,
+		2509,
+		2510,
+		2511,
+		2512,
+		2513,
+		2514,
+		2515,
+		2516,
+		2517,
+		2518,
+		2519,
+		2520,
+		2521,
+		2522,
+		2523,
+		2524,
+		2525,
+		2526,
+		2527,
+		2528,
+		2529,
+		2530,
+		2531,
+		2532,
+		2533,
+		2534,
+		2535,
+		2536,
+		2537,
+		2538,
+		2539,
+		2540,
+		2541,
+		2542,
+		2543,
+		2544,
+		2545,
+		2546,
+		2547,
+		2548,
+		2549,
+		2550,
+		2551,
+		2552,
+		2553,
+		2554,
+		2555,
+		2556,
+		2557,
+		2558,
+		2559,
+		2560,
+		2561,
+		2562,
+		2563,
+		2564,
+		2565,
+		2566,
+		2567,
+		2568,
+		2569,
+		2570,
+		2571,
+		2572,
+		2573,
+		2574,
+		2575,
+		2576,
+		2577,
+		2578,
+		2579,
+		2580,
+		2581,
+		2582,
+		2583,
+		2584,
+		2585,
+		2586,
+		2587,
+		2588,
+		2589,
+		2590,
+		2591,
+		2592,
+		2593,
+		2594,
+		2595,
+		2596,
+		2597,
+		2598,
+		2599,
+		2600,
+		2601,
+		2602,
+		2603,
+		2604,
+		2605,
+		2606,
+		2607,
+		2608,
+		2609,
+		2610,
+		2611,
+		2612,
+		2613,
+		2614,
+		2615,
+		2616,
+		2617,
+		2618,
+		2619,
+		2620,
+		2621,
+		2622,
+		2623,
+		2624,
+		2625,
+		2626,
+		2627,
+		2628,
+		2629,
+		2630,
+		2631,
+		2632,
+		2633,
+		2634,
+		2635,
+		2636,
+		2637,
+		2638,
+		2639,
+		2640,
+		2641,
+		2642,
+		2643,
+		2644,
+		2645,
+		2646,
+		2647,
+		2648,
+		2649,
+		2650,
+		2651,
+		2652,
+		2653,
+		2654,
+		2655,
+		2656,
+		2657,
+		2658,
+		2659,
+		2660,
+		2661,
+		2662,
+		2663,
+		2664,
+		2665,
+		2666,
+		2667,
+		2668,
+		2669,
+		2670,
+		2671,
+		2672,
+		2673,
+		2674,
+		2675,
+		2676,
+		2677,
+		2678,
+		2679,
+		2680,
+		2681,
+		2682,
+		2683,
+		2684,
+		2685,
+		2686,
+		2687,
+		2688,
+		2689,
+		2690,
+		2691,
+		2692,
+		2693,
+		2694,
+		2695,
+		2696,
+		2697,
+		2698,
+		2699,
+		2700,
+		2701,
+		2702,
+		2703,
+		2704,
+		2705,
+		2706,
+		2707,
+		2708,
+		2709,
+		2710,
+		2711,
+		2712,
+		2713,
+		2714,
+		2715,
+		2716,
+		2717,
+		2718,
+		2719,
+		2720,
+		2721,
+		2722,
+		2723,
+		2724,
+		2725,
+		2726,
+		2727,
+		2728,
+		2729,
+		2730,
+		2731,
+		2732,
+		2733,
+		2734,
+		2735,
+		2736,
+		2737,
+		2738,
+		2739,
+		2740,
+		2741,
+		2742,
+		2743,
+		2744,
+		2745,
+		2746,
+		2747,
+		2748,
+		2749,
+		2750,
+		2751,
+		2752,
+		2753,
+		2754,
+		2755,
+		2756,
+		2757,
+		2758,
+		2759,
+		2760,
+		2761,
+		2762,
+		2763,
+		2764,
+		2765,
+		2766,
+		2767,
+		2768,
+		2769,
+		2770,
+		2771,
+		2772,
+		2773,
+		2774,
+		2775,
+		2776,
+		2777,
+		2778,
+		2779,
+		2780,
+		2781,
+		2782,
+		2783,
+		2784,
+		2785,
+		2786,
+		2787,
+		2788,
+		2789,
+		2790,
+		2791,
+		2792,
+		2793,
+		2794,
+		2795,
+		2796,
+		2797,
+		2798,
+		2799,
+		2800,
+		2801,
+		2802,
+		2803,
+		2804,
+		2805,
+		2806,
+		2807,
+		2808,
+		2809,
+		2810,
+		2811,
+		2812,
+		2813,
+		2814,
+		2815,
+		2816,
+		2817,
+		2818,
+		2819,
+		2820,
+		2821,
+		2822,
+		2823,
+		2824,
+		2825,
+		2826,
+		2827,
+		2828,
+		2829,
+		2830,
+		2831,
+		2832,
+		2833,
+		2834,
+		2835,
+		2836,
+		2837,
+		2838,
+		2839,
+		2840,
+		2841,
+		2842,
+		2843,
+		2844,
+		2845,
+		2846,
+		2847,
+		2848,
+		2849,
+		2850,
+		2851,
+		2852,
+		2853,
+		2854,
+		2855,
+		2856,
+		2857,
+		2858,
+		2859,
+		2860,
+		2861,
+		2862,
+		2863,
+		2864,
+		2865,
+		2866,
+		2867,
+		2868,
+		2869,
+		2870,
+		2871,
+		2872,
+		2873,
+		2874,
+		2875,
+		2876,
+		2877,
+		2878,
+		2879,
+		2880,
+		2881,
+		2882,
+		2883,
+		2884,
+		2885,
+		2886,
+		2887,
+		2888,
+		2889,
+		2890,
+		2891,
+		2892,
+		2893,
+		2894,
+		2895,
+		2896,
+		2897,
+		2898,
+		2899,
+		2900,
+		2901,
+		2902,
+		2903,
+		2904,
+		2905,
+		2906,
+		2907,
+		2908,
+		2909,
+		2910,
+		2911,
+		2912,
+		2913,
+		2914,
+		2915,
+		2916,
+		2917,
+		2918,
+		2919,
+		2920,
+		2921,
+		2922,
+		2923,
+		2924,
+		2925,
+		2926,
+		2927,
+		2928,
+		2929,
+		2930,
+		2931,
+		2932,
+		2933,
+		2934,
+		2935,
+		2936,
+		2937,
+		2938,
+		2939,
+		2940,
+		2941,
+		2942,
+		2943,
+		2944,
+		2945,
+		2946,
+		2947,
+		2948,
+		2949,
+		2950,
+		2951,
+		2952,
+		2953,
+		2954,
+		2955,
+		2956,
+		2957,
+		2958,
+		2959,
+		2960,
+		2961,
+		2962,
+		2963,
+		2964,
+		2965,
+		2966,
+		2967,
+		2968,
+		2969,
+		2970,
+		2971,
+		2972,
+		2973,
+		2974,
+		2975,
+		2976,
+		2977,
+		2978,
+		2979,
+		2980,
+		2981,
+		2982,
+		2983,
+		2984,
+		2985,
+		2986,
+		2987,
+		2988,
+		2989,
+		2990,
+		2991,
+		2992,
+		2993,
+		2994,
+		2995,
+		2996,
+		2997,
+		2998,
+		2999,
+		3000,
+		3001,
+		3002,
+		3003,
+		3004,
+		3005,
+		3006,
+		3007,
+		3008,
+		3009,
+		3010,
+		3011,
+		3012,
+		3013,
+		3014,
+		3015,
+		3016,
+		3017,
+		3018,
+		3019,
+		3020,
+		3021,
+		3022,
+		3023,
+		3024,
+		3025,
+		3026,
+		3027,
+		3028,
+		3029,
+		3030,
+		3031,
+		3032,
+		3033,
+		3034,
+		3035,
+		3036,
+		3037,
+		3038,
+		3039,
+		3040,
+		3041,
+		3042,
+		3043,
+		3044,
+		3045,
+		3046,
+		3047,
+		3048,
+		3049,
+		3050,
+		3051,
+		3052,
+		3053,
+		3054,
+		3055,
+		3056,
+		3057,
+		3058,
+		3059,
+		3060,
+		3061,
+		3062,
+		3063,
+		3064,
+		3065,
+		3066,
+		3067,
+		3068,
+		3069,
+		3070,
+		3071,
+		3072,
+		3073,
+		3074,
+		3075,
+		3076,
+		3077,
+		3078,
+		3079,
+		3080,
+		3081,
+		3082,
+		3083,
+		3084,
+		3085,
+		3086,
+		3087,
+		3088,
+		3089,
+		3090,
+		3091,
+		3092,
+		3093,
+		3094,
+		3095,
+		3096,
+		3097,
+		3098,
+		3099,
+		3100,
+		3101,
+		3102,
+		3103,
+		3104,
+		3105,
+		3106,
+		3107,
+		3108,
+		3109,
+		3110,
+		3111,
+		3112,
+		3113,
+		3114,
+		3115,
+		3116,
+		3117,
+		3118,
+		3119,
+		3120,
+		3121,
+		3122,
+		3123,
+		3124,
+		3125,
+		3126,
+		3127,
+		3128,
+		3129,
+		3130,
+		3131,
+		3132,
+		3133,
+		3134,
+		3135,
+		3136,
+		3137,
+		3138,
+		3139,
+		3140,
+		3141,
+		3142,
+		3143,
+		3144,
+		3145,
+		3146,
+		3147,
+		3148,
+		3149,
+		3150,
+		3151,
+		3152,
+		3153,
+		3154,
+		3155,
+		3156,
+		3157,
+		3158,
+		3159,
+		3160,
+		3161,
+		3162,
+		3163,
+		3164,
+		3165,
+		3166,
+		3167,
+		3168,
+		3169,
+		3170,
+		3171,
+		3172,
+		3173,
+		3174,
+		3175,
+		3176,
+		3177,
+		3178,
+		3179,
+		3180,
+		3181,
+		3182,
+		3183,
+		3184,
+		3185,
+		3186,
+		3187,
+		3188,
+		3189,
+		3190,
+		3191,
+		3192,
+		3193,
+		3194,
+		3195,
+		3196,
+		3197,
+		3198,
+		3199,
+		3200,
+		3201,
+		3202,
+		3203,
+		3204,
+		3205,
+		3206,
+		3207,
+		3208,
+		3209,
+		3210,
+		3211,
+		3212,
+		3213,
+		3214,
+		3215,
+		3216,
+		3217,
+		3218,
+		3219,
+		3220,
+		3221,
+		3222,
+		3223,
+		3224,
+		3225,
+		3226,
+		3227,
+		3228,
+		3229,
+		3230,
+		3231,
+		3232,
+		3233,
+		3234,
+		3235,
+		3236,
+		3237,
+		3238,
+		3239,
+		3240,
+		3241,
+		3242,
+		3243,
+		3244,
+		3245,
+		3246,
+		3247,
+		3248,
+		3249,
+		3250,
+		3251,
+		3252,
+		3253,
+		3254,
+		3255,
+		3256,
+		3257,
+		3258,
+		3259,
+		3260,
+		3261,
+		3262,
+		3263,
+		3264,
+		3265,
+		3266,
+		3267,
+		3268,
+		3269,
+		3270,
+		3271,
+		3272,
+		3273,
+		3274,
+		3275,
+		3276,
+		3277,
+		3278,
+		3279,
+		3280,
+		3281,
+		3282,
+		3283,
+		3284,
+		3285,
+		3286,
+		3287,
+		3288,
+		3289,
+		3290,
+		3291,
+		3292,
+		3293,
+		3294,
+		3295,
+		3296,
+		3297,
+		3298,
+		3299,
+		3300,
+		3301,
+		3302,
+		3303,
+		3304,
+		3305,
+		3306,
+		3307,
+		3308,
+		3309,
+		3310,
+		3311,
+		3312,
+		3313,
+		3314,
+		3315,
+		3316,
+		3317,
+		3318,
+		3319,
+		3320,
+		3321,
+		3322,
+		3323,
+		3324,
+		3325,
+		3326,
+		3327,
+		3328,
+		3329,
+		3330,
+		3331,
+		3332,
+		3333,
+		3334,
+		3335,
+		3336,
+		3337,
+		3338,
+		3339,
+		3340,
+		3341,
+		3342,
+		3343,
+		3344,
+		3345,
+		3346,
+		3347,
+		3348,
+		3349,
+		3350,
+		3351,
+		3352,
+		3353,
+		3354,
+		3355,
+		3356,
+		3357,
+		3358,
+		3359,
+		3360,
+		3361,
+		3362,
+		3363,
+		3364,
+		3365,
+		3366,
+		3367,
+		3368,
+		3369,
+		3370,
+		3371,
+		3372,
+		3373,
+		3374,
+		3375,
+		3376,
+		3377,
+		3378,
+		3379,
+		3380,
+		3381,
+		3382,
+		3383,
+		3384,
+		3385,
+		3386,
+		3387,
+		3388,
+		3389,
+		3390,
+		3391,
+		3392,
+		3393,
+		3394,
+		3395,
+		3396,
+		3397,
+		3398,
+		3399,
+		3400,
+		3401,
+		3402,
+		3403,
+		3404,
+		3405,
+		3406,
+		3407,
+		3408,
+		3409,
+		3410,
+		3411,
+		3412,
+		3413,
+		3414,
+		3415,
+		3416,
+		3417,
+		3418,
+		3419,
+		3420,
+		3421,
+		3422,
+		3423,
+		3424,
+		3425,
+		3426,
+		3427,
+		3428,
+		3429,
+		3430,
+		3431,
+		3432,
+		3433,
+		3434,
+		3435,
+		3436,
+		3437,
+		3438,
+		3439,
+		3440,
+		3441,
+		3442,
+		3443,
+		3444,
+		3445,
+		3446,
+		3447,
+		3448,
+		3449,
+		3450,
+		3451,
+		3452,
+		3453,
+		3454,
+		3455,
+		3456,
+		3457,
+		3458,
+		3459,
+		3460,
+		3461,
+		3462,
+		3463,
+		3464,
+		3465,
+		3466,
+		3467,
+		3468,
+		3469,
+		3470,
+		3471,
+		3472,
+		3473,
+		3474,
+		3475,
+		3476,
+		3477,
+		3478,
+		3479,
+		3480,
+		3481,
+		3482,
+		3483,
+		3484,
+		3485,
+		3486,
+		3487,
+		3488,
+		3489,
+		3490,
+		3491,
+		3492,
+		3493,
+		3494,
+		3495,
+		3496,
+		3497,
+		3498,
+		3499,
+		3500,
+		3501,
+		3502,
+		3503,
+		3504,
+		3505,
+		3506,
+		3507,
+		3508,
+		3509,
+		3510,
+		3511,
+		3512,
+		3513,
+		3514,
+		3515,
+		3516,
+		3517,
+		3518,
+		3519,
+		3520,
+		3521,
+		3522,
+		3523,
+		3524,
+		3525,
+		3526,
+		3527,
+		3528,
+		3529,
+		3530,
+		3531,
+		3532,
+		3533,
+		3534,
+		3535,
+		3536,
+		3537,
+		3538,
+		3539,
+		3540,
+		3541,
+		3542,
+		3543,
+		3544,
+		3545,
+		3546,
+		3547,
+		3548,
+		3549,
+		3550,
+		3551,
+		3552,
+		3553,
+		3554,
+		3555,
+		3556,
+		3557,
+		3558,
+		3559,
+		3560,
+		3561,
+		3562,
+		3563,
+		3564,
+		3565,
+		3566,
+		3567,
+		3568,
+		3569,
+		3570,
+		3571,
+		3572,
+		3573,
+		3574,
+		3575,
+		3576,
+		3577,
+		3578,
+		3579,
+		3580,
+		3581,
+		3582,
+		3583,
+		3584,
+		3585,
+		3586,
+		3587,
+		3588,
+		3589,
+		3590,
+		3591,
+		3592,
+		3593,
+		3594,
+		3595,
+		3596,
+		3597,
+		3598,
+		3599,
+		3600,
+		3601,
+		3602,
+		3603,
+		3604,
+		3605,
+		3606,
+		3607,
+		3608,
+		3609,
+		3610,
+		3611,
+		3612,
+		3613,
+		3614,
+		3615,
+		3616,
+		3617,
+		3618,
+		3619,
+		3620,
+		3621,
+		3622,
+		3623,
+		3624,
+		3625,
+		3626,
+		3627,
+		3628,
+		3629,
+		3630,
+		3631,
+		3632,
+		3633,
+		3634,
+		3635,
+		3636,
+		3637,
+		3638,
+		3639,
+		3640,
+		3641,
+		3642,
+		3643,
+		3644,
+		3645,
+		3646,
+		3647,
+		3648,
+		3649,
+		3650,
+		3651,
+		3652,
+		3653,
+		3654,
+		3655,
+		3656,
+		3657,
+		3658,
+		3659,
+		3660,
+		3661,
+		3662,
+		3663,
+		3664,
+		3665,
+		3666,
+		3667,
+		3668,
+		3669,
+		3670,
+		3671,
+		3672,
+		3673,
+		3674,
+		3675,
+		3676,
+		3677,
+		3678,
+		3679,
+		3680,
+		3681,
+		3682,
+		3683,
+		3684,
+		3685,
+		3686,
+		3687,
+		3688,
+		3689,
+		3690,
+		3691,
+		3692,
+		3693,
+		3694,
+		3695,
+		3696,
+		3697,
+		3698,
+		3699,
+		3700,
+		3701,
+		3702,
+		3703,
+		3704,
+		3705,
+		3706,
+		3707,
+		3708,
+		3709,
+		3710,
+		3711,
+		3712,
+		3713,
+		3714,
+		3715,
+		3716,
+		3717,
+		3718,
+		3719,
+		3720,
+		3721,
+		3722,
+		3723,
+		3724,
+		3725,
+		3726,
+		3727,
+		3728,
+		3729,
+		3730,
+		3731,
+		3732,
+		3733,
+		3734,
+		3735,
+		3736,
+		3737,
+		3738,
+		3739,
+		3740,
+		3741,
+		3742,
+		3743,
+		3744,
+		3745,
+		3746,
+		3747,
+		3748,
+		3749,
+		3750,
+		3751,
+		3752,
+		3753,
+		3754,
+		3755,
+		3756,
+		3757,
+		3758,
+		3759,
+		3760,
+		3761,
+		3762,
+		3763,
+		3764,
+		3765,
+		3766,
+		3767,
+		3768,
+		3769,
+		3770,
+		3771,
+		3772,
+		3773,
+		3774,
+		3775,
+		3776,
+		3777,
+		3778,
+		3779,
+		3780,
+		3781,
+		3782,
+		3783,
+		3784,
+		3785,
+		3786,
+		3787,
+		3788,
+		3789,
+		3790,
+		3791,
+		3792,
+		3793,
+		3794,
+		3795,
+		3796,
+		3797,
+		3798,
+		3799,
+		3800,
+		3801,
+		3802,
+		3803,
+		3804,
+		3805,
+		3806,
+		3807,
+		3808,
+		3809,
+		3810,
+		3811,
+		3812,
+		3813,
+		3814,
+		3815,
+		3816,
+		3817,
+		3818,
+		3819,
+		3820,
+		3821,
+		3822,
+		3823,
+		3824,
+		3825,
+		3826,
+		3827,
+		3828,
+		3829,
+		3830,
+		3831,
+		3832,
+		3833,
+		3834,
+		3835,
+		3836,
+		3837,
+		3838,
+		3839,
+		3840,
+		3841,
+		3842,
+		3843,
+		3844,
+		3845,
+		3846,
+		3847,
+		3848,
+		3849,
+		3850,
+		3851,
+		3852,
+		3853,
+		3854,
+		3855,
+		3856,
+		3857,
+		3858,
+		3859,
+		3860,
+		3861,
+		3862,
+		3863,
+		3864,
+		3865,
+		3866,
+		3867,
+		3868,
+		3869,
+		3870,
+		3871,
+		3872,
+		3873,
+		3874,
+		3875,
+		3876,
+		3877,
+		3878,
+		3879,
+		3880,
+		3881,
+		3882,
+		3883,
+		3884,
+		3885,
+		3886,
+		3887,
+		3888,
+		3889,
+		3890,
+		3891,
+		3892,
+		3893,
+		3894,
+		3895,
+		3896,
+		3897,
+		3898,
+		3899,
+		3900,
+		3901,
+		3902,
+		3903,
+		3904,
+		3905,
+		3906,
+		3907,
+		3908,
+		3909,
+		3910,
+		3911,
+		3912,
+		3913,
+		3914,
+		3915,
+		3916,
+		3917,
+		3918,
+		3919,
+		3920,
+		3921,
+		3922,
+		3923,
+		3924,
+		3925,
+		3926,
+		3927,
+		3928,
+		3929,
+		3930,
+		3931,
+		3932,
+		3933,
+		3934,
+		3935,
+		3936,
+		3937,
+		3938,
+		3939,
+		3940,
+		3941,
+		3942,
+		3943,
+		3944,
+		3945,
+		3946,
+		3947,
+		3948,
+		3949,
+		3950,
+		3951,
+		3952,
+		3953,
+		3954,
+		3955,
+		3956,
+		3957,
+		3958,
+		3959,
+		3960,
+		3961,
+		3962,
+		3963,
+		3964,
+		3965,
+		3966,
+		3967,
+		3968,
+		3969,
+		3970,
+		3971,
+		3972,
+		3973,
+		3974,
+		3975,
+		3976,
+		3977,
+		3978,
+		3979,
+		3980,
+		3981,
+		3982,
+		3983,
+		3984,
+		3985,
+		3986,
+		3987,
+		3988,
+		3989,
+		3990,
+		3991,
+		3992,
+		3993,
+		3994,
+		3995,
+		3996,
+		3997,
+		3998,
+		3999,
+		4000,
+		4001,
+		4002,
+		4003,
+		4004,
+		4005,
+		4006,
+		4007,
+		4008,
+		4009,
+		4010,
+		4011,
+		4012,
+		4013,
+		4014,
+		4015,
+		4016,
+		4017,
+		4018,
+		4019,
+		4020,
+		4021,
+		4022,
+		4023,
+		4024,
+		4025,
+		4026,
+		4027,
+		4028,
+		4029,
+		4030,
+		4031,
+		4032,
+		4033,
+		4034,
+		4035,
+		4036,
+		4037,
+		4038,
+		4039,
+		4040,
+		4041,
+		4042,
+		4043,
+		4044,
+		4045,
+		4046,
+		4047,
+		4048,
+		4049,
+		4050,
+		4051,
+		4052,
+		4053,
+		4054,
+		4055,
+		4056,
+		4057,
+		4058,
+		4059,
+		4060,
+		4061,
+		4062,
+		4063,
+		4064,
+		4065,
+		4066,
+		4067,
+		4068,
+		4069,
+		4070,
+		4071,
+		4072,
+		4073,
+		4074,
+		4075,
+		4076,
+		4077,
+		4078,
+		4079,
+		4080,
+		4081,
+		4082,
+		4083,
+		4084,
+		4085,
+		4086,
+		4087,
+		4088,
+		4089,
+		4090,
+		4091,
+		4092,
+		4093,
+		4094,
+		4095,
+		4096,
+		4097,
+		4098,
+		4099,
+		4100,
+		4101,
+		4102,
+		4103,
+		4104,
+		4105,
+		4106,
+		4107,
+		4108,
+		4109,
+		4110,
+		4111,
+		4112,
+		4113,
+		4114,
+		4115,
+		4116,
+		4117,
+		4118,
+		4119,
+		4120,
+		4121,
+		4122,
+		4123,
+		4124,
+		4125,
+		4126,
+		4127,
+		4128,
+		4129,
+		4130,
+		4131,
+		4132,
+		4133,
+		4134,
+		4135,
+		4136,
+		4137,
+		4138,
+		4139,
+		4140,
+		4141,
+		4142,
+		4143,
+		4144,
+		4145,
+		4146,
+		4147,
+		4148,
+		4149,
+		4150,
+		4151,
+		4152,
+		4153,
+		4154,
+		4155,
+		4156,
+		4157,
+		4158,
+		4159,
+		4160,
+		4161,
+		4162,
+		4163,
+		4164,
+		4165,
+		4166,
+		4167,
+		4168,
+		4169,
+		4170,
+		4171,
+		4172,
+		4173,
+		4174,
+		4175,
+		4176,
+		4177,
+		4178,
+		4179,
+		4180,
+		4181,
+		4182,
+		4183,
+		4184,
+		4185,
+		4186,
+		4187,
+		4188,
+		4189,
+		4190,
+		4191,
+		4192,
+		4193,
+		4194,
+		4195,
+		4196,
+		4197,
+		4198,
+		4199,
+		4200,
+		4201,
+		4202,
+		4203,
+		4204,
+		4205,
+		4206,
+		4207,
+		4208,
+		4209,
+		4210,
+		4211,
+		4212,
+		4213,
+		4214,
+		4215,
+		4216,
+		4217,
+		4218,
+		4219,
+		4220,
+		4221,
+		4222,
+		4223,
+		4224,
+		4225,
+		4226,
+		4227,
+		4228,
+		4229,
+		4230,
+		4231,
+		4232,
+		4233,
+		4234,
+		4235,
+		4236,
+		4237,
+		4238,
+		4239,
+		4240,
+		4241,
+		4242,
+		4243,
+		4244,
+		4245,
+		4246,
+		4247,
+		4248,
+		4249,
+		4250,
+		4251,
+		4252,
+		4253,
+		4254,
+		4255,
+		4256,
+		4257,
+		4258,
+		4259,
+		4260,
+		4261,
+		4262,
+		4263,
+		4264,
+		4265,
+		4266,
+		4267,
+		4268,
+		4269,
+		4270,
+		4271,
+		4272,
+		4273,
+		4274,
+		4275,
+		4276,
+		4277,
+		4278,
+		4279,
+		4280,
+		4281,
+		4282,
+		4283,
+		4284,
+		4285,
+		4286,
+		4287,
+		4288,
+		4289,
+		4290,
+		4291,
+		4292,
+		4293,
+		4294,
+		4295,
+		4296,
+		4297,
+		4298,
+		4299,
+		4300,
+		4301,
+		4302,
+		4303,
+		4304,
+		4305,
+		4306,
+		4307,
+		4308,
+		4309,
+		4310,
+		4311,
+		4312,
+		4313,
+		4314,
+		4315,
+		4316,
+		4317,
+		4318,
+		4319,
+		4320,
+		4321,
+		4322,
+		4323,
+		4324,
+		4325,
+		4326,
+		4327,
+		4328,
+		4329,
+		4330,
+		4331,
+		4332,
+		4333,
+		4334,
+		4335,
+		4336,
+		4337,
+		4338,
+		4339,
+		4340,
+		4341,
+		4342,
+		4343,
+		4344,
+		4345,
+		4346,
+		4347,
+		4348,
+		4349,
+		4350,
+		4351,
+		4352,
+		4353,
+		4354,
+		4355,
+		4356,
+		4357,
+		4358,
+		4359,
+		4360,
+		4361,
+		4362,
+		4363,
+		4364,
+		4365,
+		4366,
+		4367,
+		4368,
+		4369,
+		4370,
+		4371,
+		4372,
+		4373,
+		4374,
+		4375,
+		4376,
+		4377,
+		4378,
+		4379,
+		4380,
+		4381,
+		4382,
+		4383,
+		4384,
+		4385,
+		4386,
+		4387,
+		4388,
+		4389,
+		4390,
+		4391,
+		4392,
+		4393,
+		4394,
+		4395,
+		4396,
+		4397,
+		4398,
+		4399,
+		4400,
+		4401,
+		4402,
+		4403,
+		4404,
+		4405,
+		4406,
+		4407,
+		4408,
+		4409,
+		4410,
+		4411,
+		4412,
+		4413,
+		4414,
+		4415,
+		4416,
+		4417,
+		4418,
+		4419,
+		4420,
+		4421,
+		4422,
+		4423,
+		4424,
+		4425,
+		4426,
+		4427,
+		4428,
+		4429,
+		4430,
+		4431,
+		4432,
+		4433,
+		4434,
+		4435,
+		4436,
+		4437,
+		4438,
+		4439,
+		4440,
+		4441,
+		4442,
+		4443,
+		4444,
+		4445,
+		4446,
+		4447,
+		4448,
+		4449,
+		4450,
+		4451,
+		4452,
+		4453,
+		4454,
+		4455,
+		4456,
+		4457,
+		4458,
+		4459,
+		4460,
+		4461,
+		4462,
+		4463,
+		4464,
+		4465,
+		4466,
+		4467,
+		4468,
+		4469,
+		4470,
+		4471,
+		4472,
+		4473,
+		4474,
+		4475,
+		4476,
+		4477,
+		4478,
+		4479,
+		4480,
+		4481,
+		4482,
+		4483,
+		4484,
+		4485,
+		4486,
+		4487,
+		4488,
+		4489,
+		4490,
+		4491,
+		4492,
+		4493,
+		4494,
+		4495,
+		4496,
+		4497,
+		4498,
+		4499,
+		4500,
+		4501,
+		4502,
+		4503,
+		4504,
+		4505,
+		4506,
+		4507,
+		4508,
+		4509,
+		4510,
+		4511,
+		4512,
+		4513,
+		4514,
+		4515,
+		4516,
+		4517,
+		4518,
+		4519,
+		4520,
+		4521,
+		4522,
+		4523,
+		4524,
+		4525,
+		4526,
+		4527,
+		4528,
+		4529,
+		4530,
+		4531,
+		4532,
+		4533,
+		4534,
+		4535,
+		4536,
+		4537,
+		4538,
+		4539,
+		4540,
+		4541,
+		4542,
+		4543,
+		4544,
+		4545,
+		4546,
+		4547,
+		4548,
+		4549,
+		4550,
+		4551,
+		4552,
+		4553,
+		4554,
+		4555,
+		4556,
+		4557,
+		4558,
+		4559,
+		4560,
+		4561,
+		4562,
+		4563,
+		4564,
+		4565,
+		4566,
+		4567,
+		4568,
+		4569,
+		4570,
+		4571,
+		4572,
+		4573,
+		4574,
+		4575,
+		4576,
+		4577,
+		4578,
+		4579,
+		4580,
+		4581,
+		4582,
+		4583,
+		4584,
+		4585,
+		4586,
+		4587,
+		4588,
+		4589,
+		4590,
+		4591,
+		4592,
+		4593,
+		4594,
+		4595,
+		4596,
+		4597,
+		4598,
+		4599,
+		4600,
+		4601,
+		4602,
+		4603,
+		4604,
+		4605,
+		4606,
+		4607,
+		4608,
+		4609,
+		4610,
+		4611,
+		4612,
+		4613,
+		4614,
+		4615,
+		4616,
+		4617,
+		4618,
+		4619,
+		4620,
+		4621,
+		4622,
+		4623,
+		4624,
+		4625,
+		4626,
+		4627,
+		4628,
+		4629,
+		4630,
+		4631,
+		4632,
+		4633,
+		4634,
+		4635,
+		4636,
+		4637,
+		4638,
+		4639,
+		4640,
+		4641,
+		4642,
+		4643,
+		4644,
+		4645,
+		4646,
+		4647,
+		4648,
+		4649,
+		4650,
+		4651,
+		4652,
+		4653,
+		4654,
+		4655,
+		4656,
+		4657,
+		4658,
+		4659,
+		4660,
+		4661,
+		4662,
+		4663,
+		4664,
+		4665,
+		4666,
+		4667,
+		4668,
+		4669,
+		4670,
+		4671,
+		4672,
+		4673,
+		4674,
+		4675,
+		4676,
+		4677,
+		4678,
+		4679,
+		4680,
+		4681,
+		4682,
+		4683,
+		4684,
+		4685,
+		4686,
+		4687,
+		4688,
+		4689,
+		4690,
+		4691,
+		4692,
+		4693,
+		4694,
+		4695,
+		4696,
+		4697,
+		4698,
+		4699,
+		4700,
+		4701,
+		4702,
+		4703,
+		4704,
+		4705,
+		4706,
+		4707,
+		4708,
+		4709,
+		4710,
+		4711,
+		4712,
+		4713,
+		4714,
+		4715,
+		4716,
+		4717,
+		4718,
+		4719,
+		4720,
+		4721,
+		4722,
+		4723,
+		4724,
+		4725,
+		4726,
+		4727,
+		4728,
+		4729,
+		4730,
+		4731,
+		4732,
+		4733,
+		4734,
+		4735,
+		4736,
+		4737,
+		4738,
+		4739,
+		4740,
+		4741,
+		4742,
+		4743,
+		4744,
+		4745,
+		4746,
+		4747,
+		4748,
+		4749,
+		4750,
+		4751,
+		4752,
+		4753,
+		4754,
+		4755,
+		4756,
+		4757,
+		4758,
+		4759,
+		4760,
+		4761,
+		4762,
+		4763,
+		4764,
+		4765,
+		4766,
+		4767,
+		4768,
+		4769,
+		4770,
+		4771,
+		4772,
+		4773,
+		4774,
+		4775,
+		4776,
+		4777,
+		4778,
+		4779,
+		4780,
+		4781,
+		4782,
+		4783,
+		4784,
+		4785,
+		4786,
+		4787,
+		4788,
+		4789,
+		4790,
+		4791,
+		4792,
+		4793,
+		4794,
+		4795,
+		4796,
+		4797,
+		4798,
+		4799,
+		4800,
+		4801,
+		4802,
+		4803,
+		4804,
+		4805,
+		4806,
+		4807,
+		4808,
+		4809,
+		4810,
+		4811,
+		4812,
+		4813,
+		4814,
+		4815,
+		4816,
+		4817,
+		4818,
+		4819,
+		4820,
+		4821,
+		4822,
+		4823,
+		4824,
+		4825,
+		4826,
+		4827,
+		4828,
+		4829,
+		4830,
+		4831,
+		4832,
+		4833,
+		4834,
+		4835,
+		4836,
+		4837,
+		4838,
+		4839,
+		4840,
+		4841,
+		4842,
+		4843,
+		4844,
+		4845,
+		4846,
+		4847,
+		4848,
+		4849,
+		4850,
+		4851,
+		4852,
+		4853,
+		4854,
+		4855,
+		4856,
+		4857,
+		4858,
+		4859,
+		4860,
+		4861,
+		4862,
+		4863,
+		4864,
+		4865,
+		4866,
+		4867,
+		4868,
+		4869,
+		4870,
+		4871,
+		4872,
+		4873,
+		4874,
+		4875,
+		4876,
+		4877,
+		4878,
+		4879,
+		4880,
+		4881,
+		4882,
+		4883,
+		4884,
+		4885,
+		4886,
+		4887,
+		4888,
+		4889,
+		4890,
+		4891,
+		4892,
+		4893,
+		4894,
+		4895,
+		4896,
+		4897,
+		4898,
+		4899,
+		4900,
+		4901,
+		4902,
+		4903,
+		4904,
+		4905,
+		4906,
+		4907,
+		4908,
+		4909,
+		4910,
+		4911,
+		4912,
+		4913,
+		4914,
+		4915,
+		4916,
+		4917,
+		4918,
+		4919,
+		4920,
+		4921,
+		4922,
+		4923,
+		4924,
+		4925,
+		4926,
+		4927,
+		4928,
+		4929,
+		4930,
+		4931,
+		4932,
+		4933,
+		4934,
+		4935,
+		4936,
+		4937,
+		4938,
+		4939,
+		4940,
+		4941,
+		4942,
+		4943,
+		4944,
+		4945,
+		4946,
+		4947,
+		4948,
+		4949,
+		4950,
+		4951,
+		4952,
+		4953,
+		4954,
+		4955,
+		4956,
+		4957,
+		4958,
+		4959,
+		4960,
+		4961,
+		4962,
+		4963,
+		4964,
+		4965,
+		4966,
+		4967,
+		4968,
+		4969,
+		4970,
+		4971,
+		4972,
+		4973,
+		4974,
+		4975,
+		4976,
+		4977,
+		4978,
+		4979,
+		4980,
+		4981,
+		4982,
+		4983,
+		4984,
+		4985,
+		4986,
+		4987,
+		4988,
+		4989,
+		4990,
+		4991,
+		4992,
+		4993,
+		4994,
+		4995,
+		4996,
+		4997,
+		4998,
+		4999,
+		5000,
+		5001,
+		5002,
+		5003,
+		5004,
+		5005,
+		5006,
+		5007,
+		5008,
+		5009,
+		5010,
+		5011,
+		5012,
+		5013,
+		5014,
+		5015,
+		5016,
+		5017,
+		5018,
+		5019,
+		5020,
+		5021,
+		5022,
+		5023,
+		5024,
+		5025,
+		5026,
+		5027,
+		5028,
+		5029,
+		5030,
+		5031,
+		5032,
+		5033,
+		5034,
+		5035,
+		5036,
+		5037,
+		5038,
+		5039,
+		5040,
+		5041,
+		5042,
+		5043,
+		5044,
+		5045,
+		5046,
+		5047,
+		5048,
+		5049,
+		5050,
+		5051,
+		5052,
+		5053,
+		5054,
+		5055,
+		5056,
+		5057,
+		5058,
+		5059,
+		5060,
+		5061,
+		5062,
+		5063,
+		5064,
+		5065,
+		5066,
+		5067,
+		5068,
+		5069,
+		5070,
+		5071,
+		5072,
+		5073,
+		5074,
+		5075,
+		5076,
+		5077,
+		5078,
+		5079,
+		5080,
+		5081,
+		5082,
+		5083,
+		5084,
+		5085,
+		5086,
+		5087,
+		5088,
+		5089,
+		5090,
+		5091,
+		5092,
+		5093,
+		5094,
+		5095,
+		5096,
+		5097,
+		5098,
+		5099,
+		5100,
+		5101,
+		5102,
+		5103,
+		5104,
+		5105,
+		5106,
+		5107,
+		5108,
+		5109,
+		5110,
+		5111,
+		5112,
+		5113,
+		5114,
+		5115,
+		5116,
+		5117,
+		5118,
+		5119,
+		5120,
+		5121,
+		5122,
+		5123,
+		5124,
+		5125,
+		5126,
+		5127,
+		5128,
+		5129,
+		5130,
+		5131,
+		5132,
+		5133,
+		5134,
+		5135,
+		5136,
+		5137,
+		5138,
+		5139,
+		5140,
+		5141,
+		5142,
+		5143,
+		5144,
+		5145,
+		5146,
+		5147,
+		5148,
+		5149,
+		5150,
+		5151,
+		5152,
+		5153,
+		5154,
+		5155,
+		5156,
+		5157,
+		5158,
+		5159,
+		5160,
+		5161,
+		5162,
+		5163,
+		5164,
+		5165,
+		5166,
+		5167,
+		5168,
+		5169,
+		5170,
+		5171,
+		5172,
+		5173,
+		5174,
+		5175,
+		5176,
+		5177,
+		5178,
+		5179,
+		5180,
+		5181,
+		5182,
+		5183,
+		5184,
+		5185,
+		5186,
+		5187,
+		5188,
+		5189,
+		5190,
+		5191,
+		5192,
+		5193,
+		5194,
+		5195,
+		5196,
+		5197,
+		5198,
+		5199,
+		5200,
+		5201,
+		5202,
+		5203,
+		5204,
+		5205,
+		5206,
+		5207,
+		5208,
+		5209,
+		5210,
+		5211,
+		5212,
+		5213,
+		5214,
+		5215,
+		5216,
+		5217,
+		5218,
+		5219,
+		5220,
+		5221,
+		5222,
+		5223,
+		5224,
+		5225,
+		5226,
+		5227,
+		5228,
+		5229,
+		5230,
+		5231,
+		5232,
+		5233,
+		5234,
+		5235,
+		5236,
+		5237,
+		5238,
+		5239,
+		5240,
+		5241,
+		5242,
+		5243,
+		5244,
+		5245,
+		5246,
+		5247,
+		5248,
+		5249,
+		5250,
+		5251,
+		5252,
+		5253,
+		5254,
+		5255,
+		5256,
+		5257,
+		5258,
+		5259,
+		5260,
+		5261,
+		5262,
+		5263,
+		5264,
+		5265,
+		5266,
+		5267,
+		5268,
+		5269,
+		5270,
+		5271,
+		5272,
+		5273,
+		5274,
+		5275,
+		5276,
+		5277,
+		5278,
+		5279,
+		5280,
+		5281,
+		5282,
+		5283,
+		5284,
+		5285,
+		5286,
+		5287,
+		5288,
+		5289,
+		5290,
+		5291,
+		5292,
+		5293,
+		5294,
+		5295,
+		5296,
+		5297,
+		5298,
+		5299,
+		5300,
+		5301,
+		5302,
+		5303,
+		5304,
+		5305,
+		5306,
+		5307,
+		5308,
+		5309,
+		5310,
+		5311,
+		5312,
+		5313,
+		5314,
+		5315,
+		5316,
+		5317,
+		5318,
+		5319,
+		5320,
+		5321,
+		5322,
+		5323,
+		5324,
+		5325,
+		5326,
+		5327,
+		5328,
+		5329,
+		5330,
+		5331,
+		5332,
+		5333,
+		5334,
+		5335,
+		5336,
+		5337,
+		5338,
+		5339,
+		5340,
+		5341,
+		5342,
+		5343,
+		5344,
+		5345,
+		5346,
+		5347,
+		5348,
+		5349,
+		5350,
+		5351,
+		5352,
+		5353,
+		5354,
+		5355,
+		5356,
+		5357,
+		5358,
+		5359,
+		5360,
+		5361,
+		5362,
+		5363,
+		5364,
+		5365,
+		5366,
+		5367,
+		5368,
+		5369,
+		5370,
+		5371,
+		5372,
+		5373,
+		5374,
+		5375,
+};
+
+#endif  //SHAPE_DATA_H
diff --git a/engine/inc/bullet/OpenGLWindow/SimpleCamera.h b/engine/inc/bullet/OpenGLWindow/SimpleCamera.h
new file mode 100644
index 00000000..c50ff67c
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/SimpleCamera.h
@@ -0,0 +1,60 @@
+#ifndef SIMPLE_CAMERA_H
+#define SIMPLE_CAMERA_H
+
+#include "../CommonInterfaces/CommonCameraInterface.h"
+
+struct SimpleCamera : public CommonCameraInterface
+{
+	struct SimpleCameraInternalData* m_data;
+
+	SimpleCamera();
+	virtual ~SimpleCamera();
+
+	void update();
+	virtual void getCameraProjectionMatrix(float m[16]) const;
+	virtual void getCameraViewMatrix(float m[16]) const;
+
+	virtual void setVRCamera(const float viewMat[16], const float projectionMatrix[16]);
+	virtual bool getVRCamera(float viewMat[16], float projectionMatrix[16]);
+
+	virtual void setVRCameraOffsetTransform(const float offset[16]);
+	virtual void disableVRCamera();
+
+	virtual bool isVRCamera() const;
+
+	virtual void getCameraTargetPosition(float pos[3]) const;
+	virtual void getCameraPosition(float pos[3]) const;
+
+	virtual void getCameraTargetPosition(double pos[3]) const;
+	virtual void getCameraPosition(double pos[3]) const;
+
+	virtual void setCameraTargetPosition(float x, float y, float z);
+	virtual void setCameraDistance(float dist);
+	virtual float getCameraDistance() const;
+
+	virtual void setCameraUpVector(float x, float y, float z);
+	void getCameraUpVector(float up[3]) const;
+
+	void getCameraForwardVector(float fwd[3]) const;
+
+	///the setCameraUpAxis will call the 'setCameraUpVector' and 'setCameraForwardVector'
+	virtual void setCameraUpAxis(int axis);
+	virtual int getCameraUpAxis() const;
+
+	virtual void setCameraYaw(float yaw);
+	virtual float getCameraYaw() const;
+
+	virtual void setCameraPitch(float pitch);
+	virtual float getCameraPitch() const;
+
+	virtual void setAspectRatio(float ratio);
+	virtual float getAspectRatio() const;
+
+	virtual float getCameraFrustumFar() const;
+	virtual float getCameraFrustumNear() const;
+
+	virtual void setCameraFrustumFar(float far);
+	virtual void setCameraFrustumNear(float near);
+};
+
+#endif  //SIMPLE_CAMERA_H
diff --git a/engine/inc/bullet/OpenGLWindow/SimpleOpenGL2App.h b/engine/inc/bullet/OpenGLWindow/SimpleOpenGL2App.h
new file mode 100644
index 00000000..467ed169
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/SimpleOpenGL2App.h
@@ -0,0 +1,32 @@
+#ifndef SIMPLE_OPENGL2_APP_H
+#define SIMPLE_OPENGL2_APP_H
+
+#include "../CommonInterfaces/CommonGraphicsAppInterface.h"
+
+class SimpleOpenGL2App : public CommonGraphicsApp
+{
+protected:
+	struct SimpleOpenGL2AppInternalData* m_data;
+
+public:
+	SimpleOpenGL2App(const char* title, int width, int height);
+	virtual ~SimpleOpenGL2App();
+
+	virtual void drawGrid(DrawGridData data = DrawGridData());
+	virtual void setUpAxis(int axis);
+	virtual int getUpAxis() const;
+
+	virtual void swapBuffer();
+	virtual void drawText(const char* txt, int posX, int posY, float size, float colorRGBA[4]);
+
+	virtual void drawTexturedRect(float x0, float y0, float x1, float y1, float color[4], float u0, float v0, float u1, float v1, int useRGBA){};
+	virtual void setBackgroundColor(float red, float green, float blue);
+	virtual int registerCubeShape(float halfExtentsX, float halfExtentsY, float halfExtentsZ, int textureIndex = -1, float textureScaling = 1);
+
+	virtual int registerGraphicsUnitSphereShape(EnumSphereLevelOfDetail lod, int textureId = -1);
+	virtual void drawText3D(const char* txt, float posX, float posZY, float posZ, float size);
+	virtual void drawText3D(const char* txt, float position[3], float orientation[4], float color[4], float size, int optionFlag);
+
+	virtual void registerGrid(int xres, int yres, float color0[4], float color1[4]);
+};
+#endif  //SIMPLE_OPENGL2_APP_H
\ No newline at end of file
diff --git a/engine/inc/bullet/OpenGLWindow/SimpleOpenGL2Renderer.h b/engine/inc/bullet/OpenGLWindow/SimpleOpenGL2Renderer.h
new file mode 100644
index 00000000..19cc8cc1
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/SimpleOpenGL2Renderer.h
@@ -0,0 +1,93 @@
+
+#ifndef SIMPLE_OPENGL2_RENDERER_H
+#define SIMPLE_OPENGL2_RENDERER_H
+
+#include "../CommonInterfaces/CommonRenderInterface.h"
+#include "SimpleCamera.h"
+
+class SimpleOpenGL2Renderer : public CommonRenderInterface
+{
+	struct SimpleOpenGL2RendererInternalData* m_data;
+
+	void drawSceneInternal(int pass, int cameraUpAxis);
+	void drawOpenGL(int instanceIndex);
+
+public:
+	SimpleOpenGL2Renderer(int width, int height);
+	virtual ~SimpleOpenGL2Renderer();
+
+	virtual void init();
+
+	virtual void updateCamera(int upAxis);
+
+	virtual const CommonCameraInterface* getActiveCamera() const;
+	virtual CommonCameraInterface* getActiveCamera();
+	virtual void setActiveCamera(CommonCameraInterface* cam);
+
+	virtual void setLightPosition(const float lightPos[3]);
+	virtual void setLightPosition(const double lightPos[3]);
+	virtual void setShadowMapResolution(int shadowMapResolution) {}
+	virtual void setShadowMapIntensity(double shadowMapIntensity) {}
+	virtual void setShadowMapWorldSize(float worldSize) {}
+	virtual void resize(int width, int height);
+
+	virtual void removeAllInstances();
+	virtual void removeGraphicsInstance(int instanceUid);
+
+	virtual bool readSingleInstanceTransformToCPU(float* position, float* orientation, int srcIndex);
+	virtual void writeSingleInstanceColorToCPU(const float* color, int srcIndex);
+	virtual void writeSingleInstanceColorToCPU(const double* color, int srcIndex);
+	virtual void writeSingleInstanceScaleToCPU(const float* scale, int srcIndex);
+	virtual void writeSingleInstanceScaleToCPU(const double* scale, int srcIndex);
+	virtual void writeSingleInstanceSpecularColorToCPU(const double* specular, int srcIndex) {}
+	virtual void writeSingleInstanceSpecularColorToCPU(const float* specular, int srcIndex) {}
+	virtual void writeSingleInstanceFlagsToCPU(int flags, int srcIndex) {}
+	virtual void getCameraViewMatrix(float viewMat[16]) const;
+	virtual void getCameraProjectionMatrix(float projMat[16]) const;
+	virtual void drawTexturedTriangleMesh(float worldPosition[3], float worldOrientation[4], const float* vertices, int numvertices, const unsigned int* indices, int numIndices, float color[4], int textureIndex = -1, int vertexLayout = 0)
+	{
+	}
+
+	virtual void renderScene();
+
+	virtual int getScreenWidth();
+	virtual int getScreenHeight();
+	virtual int registerTexture(const unsigned char* texels, int width, int height, bool flipTexelsY);
+	virtual void updateTexture(int textureIndex, const unsigned char* texels, bool flipTexelsY);
+	virtual void activateTexture(int textureIndex);
+	virtual void removeTexture(int textureIndex);
+
+	virtual int registerGraphicsInstance(int shapeIndex, const double* position, const double* quaternion, const double* color, const double* scaling);
+
+	virtual int registerGraphicsInstance(int shapeIndex, const float* position, const float* quaternion, const float* color, const float* scaling);
+
+	virtual void drawLines(const float* positions, const float color[4], int numPoints, int pointStrideInBytes, const unsigned int* indices, int numIndices, float pointDrawSize);
+
+	virtual void drawLine(const float from[4], const float to[4], const float color[4], float lineWidth);
+
+	virtual int registerShape(const float* vertices, int numvertices, const int* indices, int numIndices, int primitiveType = B3_GL_TRIANGLES, int textureIndex = -1);
+
+	virtual void writeSingleInstanceTransformToCPU(const float* position, const float* orientation, int srcIndex);
+
+	virtual void writeSingleInstanceTransformToCPU(const double* position, const double* orientation, int srcIndex);
+
+	virtual int getTotalNumInstances() const;
+
+	virtual void writeTransforms();
+
+	virtual void drawLine(const double from[4], const double to[4], const double color[4], double lineWidth);
+
+	virtual void drawPoint(const float* position, const float color[4], float pointDrawSize);
+
+	virtual void drawPoint(const double* position, const double color[4], double pointDrawSize);
+
+	virtual void updateShape(int shapeIndex, const float* vertices, int numVertices);
+
+	virtual void clearZBuffer();
+
+	virtual struct GLInstanceRendererInternalData* getInternalData()
+	{
+		return 0;
+	}
+};
+#endif  //SIMPLE_OPENGL2_RENDERER_H
diff --git a/engine/inc/bullet/OpenGLWindow/SimpleOpenGL3App.h b/engine/inc/bullet/OpenGLWindow/SimpleOpenGL3App.h
new file mode 100644
index 00000000..c90f4738
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/SimpleOpenGL3App.h
@@ -0,0 +1,44 @@
+#ifndef SIMPLE_OPENGL3_APP_H
+#define SIMPLE_OPENGL3_APP_H
+
+#include "../OpenGLWindow/GLInstancingRenderer.h"
+#include "../OpenGLWindow/GLPrimitiveRenderer.h"
+#include "../CommonInterfaces/CommonWindowInterface.h"
+
+#include "../CommonInterfaces/CommonGraphicsAppInterface.h"
+
+struct SimpleOpenGL3App : public CommonGraphicsApp
+{
+	struct SimpleInternalData* m_data;
+
+	class GLPrimitiveRenderer* m_primRenderer;
+	class GLInstancingRenderer* m_instancingRenderer;
+	virtual void setBackgroundColor(float red, float green, float blue);
+	virtual void setMp4Fps(int fps);
+
+	SimpleOpenGL3App(const char* title, int width, int height, bool allowRetina = true, int windowType = 0, int renderDevice = -1, int maxNumObjectCapacity = 128 * 1024, int maxShapeCapacityInBytes = 128 * 1024 * 1024);
+
+	virtual ~SimpleOpenGL3App();
+
+	virtual int registerCubeShape(float halfExtentsX = 1.f, float halfExtentsY = 1.f, float halfExtentsZ = 1.f, int textureIndex = -1, float textureScaling = 1);
+	virtual int registerGraphicsUnitSphereShape(EnumSphereLevelOfDetail lod, int textureId = -1);
+	virtual void registerGrid(int xres, int yres, float color0[4], float color1[4]);
+	void dumpNextFrameToPng(const char* pngFilename);
+	void dumpFramesToVideo(const char* mp4Filename);
+	virtual void getScreenPixels(unsigned char* rgbaBuffer, int bufferSizeInBytes, float* depthBuffer, int depthBufferSizeInBytes);
+	virtual void setViewport(int width, int height);
+
+	void drawGrid(DrawGridData data = DrawGridData());
+	virtual void setUpAxis(int axis);
+	virtual int getUpAxis() const;
+
+	virtual void swapBuffer();
+	virtual void drawText(const char* txt, int posX, int posY, float size, float colorRGBA[4]);
+	virtual void drawText3D(const char* txt, float posX, float posZY, float posZ, float size);
+	virtual void drawText3D(const char* txt, float position[3], float orientation[4], float color[4], float size, int optionFlag);
+
+	virtual void drawTexturedRect(float x0, float y0, float x1, float y1, float color[4], float u0, float v0, float u1, float v1, int useRGBA);
+	struct sth_stash* getFontStash();
+};
+
+#endif  //SIMPLE_OPENGL3_APP_H
diff --git a/engine/inc/bullet/OpenGLWindow/TwFonts.h b/engine/inc/bullet/OpenGLWindow/TwFonts.h
new file mode 100644
index 00000000..6980ae4b
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/TwFonts.h
@@ -0,0 +1,62 @@
+//  ---------------------------------------------------------------------------
+//
+//  @file       TwFonts.h
+//  @brief      Bitmaps fonts
+//  @author     Philippe Decaudin - http://www.antisphere.com
+//  @license    This file is part of the AntTweakBar library.
+//              For conditions of distribution and use, see License.txt
+//
+//  note:       Private header
+//
+//  ---------------------------------------------------------------------------
+
+#if !defined ANT_TW_FONTS_INCLUDED
+#define ANT_TW_FONTS_INCLUDED
+
+//#include <AntTweakBar.h>
+
+/*
+A source bitmap includes 224 characters starting from ascii char 32 (i.e. space) to ascii char 255:
+  
+ !"#$%&'()*+,-./0123456789:;<=>?
+@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_
+`abcdefghijklmnopqrstuvwxyz{|}~
+€�‚ƒ„…†‡ˆ‰Š‹Œ�Ž��‘’“”•–—˜™š›œ�žŸ
+ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿
+ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞß
+àáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ
+
+First column of a source bitmap is a delimiter with color=zero at the end of each line of characters.
+Last row of a line of characters is a delimiter with color=zero at the last pixel of each character.
+
+*/
+
+struct CTexFont
+{
+	unsigned char *m_TexBytes;
+	int m_TexWidth;   // power of 2
+	int m_TexHeight;  // power of 2
+	float m_CharU0[256];
+	float m_CharV0[256];
+	float m_CharU1[256];
+	float m_CharV1[256];
+	int m_CharWidth[256];
+	int m_CharHeight;
+	int m_NbCharRead;
+
+	CTexFont();
+	~CTexFont();
+};
+
+CTexFont *TwGenerateFont(const unsigned char *_Bitmap, int _BmWidth, int _BmHeight);
+
+extern CTexFont *g_DefaultSmallFont;
+extern CTexFont *g_DefaultNormalFont;
+extern CTexFont *g_DefaultNormalFontAA;
+extern CTexFont *g_DefaultLargeFont;
+extern CTexFont *g_DefaultFixed1Font;
+
+void TwGenerateDefaultFonts();
+void TwDeleteDefaultFonts();
+
+#endif  // !defined ANT_TW_FONTS_INCLUDED
diff --git a/engine/inc/bullet/OpenGLWindow/Win32InternalWindowData.h b/engine/inc/bullet/OpenGLWindow/Win32InternalWindowData.h
new file mode 100644
index 00000000..542ab74c
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/Win32InternalWindowData.h
@@ -0,0 +1,65 @@
+
+#ifndef WIN32_INTERNAL_WINDOW_DATA_H
+#define WIN32_INTERNAL_WINDOW_DATA_H
+
+#include <windows.h>
+
+struct InternalData2
+{
+	HWND m_hWnd;
+	;
+	int m_fullWindowWidth;  //includes borders etc
+	int m_fullWindowHeight;
+
+	int m_openglViewportWidth;  //just the 3d viewport/client area
+	int m_openglViewportHeight;
+
+	HDC m_hDC;
+	HGLRC m_hRC;
+	bool m_OpenGLInitialized;
+	int m_oldScreenWidth;
+	int m_oldHeight;
+	int m_oldBitsPerPel;
+	bool m_quit;
+	int m_mouseLButton;
+	int m_mouseRButton;
+	int m_mouseMButton;
+	int m_mouseXpos;
+	int m_mouseYpos;
+
+	int m_internalKeyModifierFlags;
+
+	b3WheelCallback m_wheelCallback;
+	b3MouseMoveCallback m_mouseMoveCallback;
+	b3MouseButtonCallback m_mouseButtonCallback;
+	b3ResizeCallback m_resizeCallback;
+	b3KeyboardCallback m_keyboardCallback;
+
+	InternalData2()
+	{
+		m_hWnd = 0;
+		m_mouseLButton = 0;
+		m_mouseRButton = 0;
+		m_mouseMButton = 0;
+		m_internalKeyModifierFlags = 0;
+		m_fullWindowWidth = 0;
+		m_fullWindowHeight = 0;
+		m_openglViewportHeight = 0;
+		m_openglViewportWidth = 0;
+		m_hDC = 0;
+		m_hRC = 0;
+		m_OpenGLInitialized = false;
+		m_oldScreenWidth = 0;
+		m_oldHeight = 0;
+		m_oldBitsPerPel = 0;
+		m_quit = false;
+
+		m_keyboardCallback = 0;
+		m_mouseMoveCallback = 0;
+		m_mouseButtonCallback = 0;
+		m_resizeCallback = 0;
+		m_wheelCallback = 0;
+	}
+};
+
+#endif  //WIN32_INTERNAL_WINDOW_DATA_H
\ No newline at end of file
diff --git a/engine/inc/bullet/OpenGLWindow/Win32OpenGLWindow.h b/engine/inc/bullet/OpenGLWindow/Win32OpenGLWindow.h
new file mode 100644
index 00000000..7864df83
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/Win32OpenGLWindow.h
@@ -0,0 +1,56 @@
+/*
+Copyright (c) 2012 Advanced Micro Devices, Inc.  
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+//Originally written by Erwin Coumans
+
+#ifndef _WIN32_OPENGL_RENDER_MANAGER_H
+#define _WIN32_OPENGL_RENDER_MANAGER_H
+
+#include "Win32Window.h"
+
+#define b3gDefaultOpenGLWindow Win32OpenGLWindow
+
+class Win32OpenGLWindow : public Win32Window
+{
+	bool m_OpenGLInitialized;
+
+protected:
+	void enableOpenGL();
+
+	void disableOpenGL();
+
+public:
+	Win32OpenGLWindow();
+
+	virtual ~Win32OpenGLWindow();
+
+	virtual void createWindow(const b3gWindowConstructionInfo& ci);
+
+	virtual void closeWindow();
+
+	virtual void startRendering();
+
+	virtual void renderAllObjects();
+
+	virtual void endRendering();
+
+	virtual float getRetinaScale() const { return 1.f; }
+	virtual void setAllowRetina(bool /*allowRetina*/){};
+
+	virtual int getWidth() const;
+	virtual int getHeight() const;
+
+	virtual int fileOpenDialog(char* fileName, int maxFileNameLength);
+};
+
+#endif  //_WIN32_OPENGL_RENDER_MANAGER_H
diff --git a/engine/inc/bullet/OpenGLWindow/Win32Window.h b/engine/inc/bullet/OpenGLWindow/Win32Window.h
new file mode 100644
index 00000000..dcf81980
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/Win32Window.h
@@ -0,0 +1,78 @@
+/*
+Copyright (c) 2012 Advanced Micro Devices, Inc.  
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+//Originally written by Erwin Coumans
+
+#ifndef _WIN32_WINDOW_H
+#define _WIN32_WINDOW_H
+
+struct InternalData2;
+
+#include "../CommonInterfaces/CommonWindowInterface.h"
+
+class Win32Window : public CommonWindowInterface
+{
+protected:
+	struct InternalData2* m_data;
+
+	void pumpMessage();
+
+public:
+	Win32Window();
+
+	virtual ~Win32Window();
+
+	virtual void createWindow(const b3gWindowConstructionInfo& ci);
+
+	virtual void switchFullScreen(bool fullscreen, int width = 0, int height = 0, int colorBitsPerPixel = 0);
+
+	virtual void closeWindow();
+
+	virtual void runMainLoop();
+
+	virtual void startRendering();
+
+	virtual void renderAllObjects();
+
+	virtual void endRendering();
+
+	virtual float getTimeInSeconds();
+
+	virtual void setDebugMessage(int x, int y, const char* message);
+
+	virtual bool requestedExit() const;
+
+	virtual void setRequestExit();
+
+	virtual void getMouseCoordinates(int& x, int& y);
+
+	virtual void setMouseMoveCallback(b3MouseMoveCallback mouseCallback);
+	virtual void setMouseButtonCallback(b3MouseButtonCallback mouseCallback);
+	virtual void setResizeCallback(b3ResizeCallback resizeCallback);
+	virtual void setWheelCallback(b3WheelCallback wheelCallback);
+	virtual void setKeyboardCallback(b3KeyboardCallback keyboardCallback);
+
+	virtual b3MouseMoveCallback getMouseMoveCallback();
+	virtual b3MouseButtonCallback getMouseButtonCallback();
+	virtual b3ResizeCallback getResizeCallback();
+	virtual b3WheelCallback getWheelCallback();
+	virtual b3KeyboardCallback getKeyboardCallback();
+
+	virtual void setRenderCallback(b3RenderCallback renderCallback);
+
+	virtual void setWindowTitle(const char* title);
+
+	virtual bool isModifierKeyPressed(int key);
+};
+
+#endif  //_WIN32_WINDOW_H
\ No newline at end of file
diff --git a/engine/inc/bullet/OpenGLWindow/X11OpenGLWindow.h b/engine/inc/bullet/OpenGLWindow/X11OpenGLWindow.h
new file mode 100644
index 00000000..8170acba
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/X11OpenGLWindow.h
@@ -0,0 +1,72 @@
+#ifndef X11_OPENGL_WINDOW_H
+#define X11_OPENGL_WINDOW_H
+
+#define b3gDefaultOpenGLWindow X11OpenGLWindow
+
+#include "../CommonInterfaces/CommonWindowInterface.h"
+
+class X11OpenGLWindow : public CommonWindowInterface
+{
+	struct InternalData2* m_data;
+	bool m_OpenGLInitialized;
+	bool m_requestedExit;
+
+protected:
+	void enableOpenGL();
+
+	void disableOpenGL();
+
+	void pumpMessage();
+
+	int getAsciiCodeFromVirtualKeycode(int orgCode);
+
+public:
+	X11OpenGLWindow();
+
+	virtual ~X11OpenGLWindow();
+
+	virtual void createWindow(const b3gWindowConstructionInfo& ci);
+
+	virtual void closeWindow();
+
+	virtual void startRendering();
+
+	virtual void renderAllObjects();
+
+	virtual void endRendering();
+
+	virtual float getRetinaScale() const { return 1.f; }
+	virtual void setAllowRetina(bool /*allowRetina*/){};
+
+	virtual void runMainLoop();
+	virtual float getTimeInSeconds();
+
+	virtual bool requestedExit() const;
+	virtual void setRequestExit();
+
+	virtual bool isModifierKeyPressed(int key);
+
+	virtual void setMouseMoveCallback(b3MouseMoveCallback mouseCallback);
+	virtual void setMouseButtonCallback(b3MouseButtonCallback mouseCallback);
+	virtual void setResizeCallback(b3ResizeCallback resizeCallback);
+	virtual void setWheelCallback(b3WheelCallback wheelCallback);
+	virtual void setKeyboardCallback(b3KeyboardCallback keyboardCallback);
+
+	virtual b3MouseMoveCallback getMouseMoveCallback();
+	virtual b3MouseButtonCallback getMouseButtonCallback();
+	virtual b3ResizeCallback getResizeCallback();
+	virtual b3WheelCallback getWheelCallback();
+	virtual b3KeyboardCallback getKeyboardCallback();
+
+	virtual void setRenderCallback(b3RenderCallback renderCallback);
+
+	virtual void setWindowTitle(const char* title);
+
+	virtual int getWidth() const;
+
+	virtual int getHeight() const;
+
+	int fileOpenDialog(char* filename, int maxNameLength);
+};
+
+#endif
diff --git a/engine/inc/bullet/OpenGLWindow/fontstash.h b/engine/inc/bullet/OpenGLWindow/fontstash.h
new file mode 100644
index 00000000..a7817110
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/fontstash.h
@@ -0,0 +1,154 @@
+//
+// Copyright (c) 2011 Andreas Krinke andreas.krinke@gmx.de
+// Copyright (c) 2009 Mikko Mononen memon@inside.org
+//
+// This software is provided 'as-is', without any express or implied
+// warranty.  In no event will the authors be held liable for any damages
+// arising from the use of this software.
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would be
+//    appreciated but is not required.
+// 2. Altered source versions must be plainly marked as such, and must not be
+//    misrepresented as being the original software.
+// 3. This notice may not be removed or altered from any source distribution.
+//
+
+#ifndef FONTSTASH_H
+#define FONTSTASH_H
+
+#define MAX_ROWS 128
+#define VERT_COUNT (16 * 128)
+#define INDEX_COUNT (VERT_COUNT * 2)
+
+struct vec2
+{
+	vec2(float x, float y)
+	{
+		p[0] = x;
+		p[1] = y;
+	}
+	float p[2];
+};
+
+struct vec4
+{
+	vec4(float x, float y, float z, float w)
+	{
+		p[0] = x;
+		p[1] = y;
+		p[2] = z;
+		p[3] = w;
+	}
+
+	float p[4];
+};
+
+typedef struct
+{
+	vec4 position;
+	vec4 colour;
+	vec2 uv;
+} Vertex;
+
+struct sth_quad
+{
+	float x0, y0, s0, t0;
+	float x1, y1, s1, t1;
+};
+
+struct sth_row
+{
+	short x, y, h;
+};
+
+struct sth_glyph
+{
+	unsigned int codepoint;
+	short size;
+	struct sth_texture* texture;
+	int x0_, y0, x1, y1;
+	float xadv, xoff, yoff;
+	int next;
+};
+
+struct sth_texture
+{
+	union {
+		void* m_userData;
+		int m_userId;
+	};
+
+	unsigned char* m_texels;
+
+	// TODO: replace rows with pointer
+	struct sth_row rows[MAX_ROWS];
+	int nrows;
+	int nverts;
+
+	Vertex newverts[VERT_COUNT];
+	struct sth_texture* next;
+};
+
+struct RenderCallbacks
+{
+	virtual ~RenderCallbacks() {}
+	virtual void setColorRGBA(float color[4]) = 0;
+	virtual void setWorldPosition(float pos[3]) = 0;
+	virtual void setWorldOrientation(float orn[4]) = 0;
+	virtual void updateTexture(sth_texture* texture, sth_glyph* glyph, int textureWidth, int textureHeight) = 0;
+	virtual void render(sth_texture* texture) = 0;
+};
+
+struct sth_stash* sth_create(int cachew, int cacheh, RenderCallbacks* callbacks);
+
+int sth_add_font(struct sth_stash* stash, const char* path);
+int sth_add_font_from_memory(struct sth_stash* stash, unsigned char* buffer);
+
+int sth_add_bitmap_font(struct sth_stash* stash, int ascent, int descent, int line_gap);
+/*void sth_add_glyph(struct sth_stash* stash, int idx, unsigned int uid, const char* s,
+                  short size, short base, int x, int y, int w, int h,
+                  float xoffset, float yoffset, float xadvance);
+				  */
+
+void sth_begin_draw(struct sth_stash* stash);
+void sth_end_draw(struct sth_stash* stash);
+
+void sth_draw_texture(struct sth_stash* stash,
+					  int idx, float size,
+					  float x, float y,
+					  int screenwidth, int screenheight,
+					  const char* s, float* dx, float colorRGBA[4]);
+
+void sth_flush_draw(struct sth_stash* stash);
+
+void sth_draw_text3D(struct sth_stash* stash,
+					 int idx, float fontSize,
+					 float x, float y, float z,
+					 const char* s, float* dx, float textScale, float colorRGBA[4], int bla);
+
+void sth_draw_text(struct sth_stash* stash,
+				   int idx, float size,
+				   float x, float y, const char* string, float* dx, int screenwidth, int screenheight, int measureOnly, float retinaScale, float colorRGBA[4]);
+
+inline void sth_draw_text(struct sth_stash* stash,
+						  int idx, float size,
+						  float x, float y, const char* string, float* dx, int screenwidth, int screenheight, int measureOnly = false, float retinaScale = 1.)
+{
+	float colorRGBA[4] = {1, 1, 1, 1};
+	sth_draw_text(stash, idx, size, x, y, string, dx, screenwidth, screenheight, measureOnly, retinaScale, colorRGBA);
+}
+
+void sth_dim_text(struct sth_stash* stash, int idx, float size, const char* string,
+				  float* minx, float* miny, float* maxx, float* maxy);
+
+void sth_vmetrics(struct sth_stash* stash,
+				  int idx, float size,
+				  float* ascender, float* descender, float* lineh);
+
+void sth_delete(struct sth_stash* stash);
+
+#endif  // FONTSTASH_H
diff --git a/engine/inc/bullet/OpenGLWindow/opengl_fontstashcallbacks.h b/engine/inc/bullet/OpenGLWindow/opengl_fontstashcallbacks.h
new file mode 100644
index 00000000..f09387b4
--- /dev/null
+++ b/engine/inc/bullet/OpenGLWindow/opengl_fontstashcallbacks.h
@@ -0,0 +1,51 @@
+#ifndef _OPENGL_FONTSTASH_CALLBACKS_H
+#define _OPENGL_FONTSTASH_CALLBACKS_H
+
+#include "fontstash.h"
+struct PrimInternalData;
+class GLPrimitiveRenderer;
+
+struct InternalOpenGL2RenderCallbacks : public RenderCallbacks
+{
+	virtual PrimInternalData* getData() = 0;
+
+	virtual ~InternalOpenGL2RenderCallbacks();
+
+	virtual void updateTexture(sth_texture* texture, sth_glyph* glyph, int textureWidth, int textureHeight);
+	virtual void render(sth_texture* texture);
+
+	void display2();
+};
+
+void dumpTextureToPng(int screenWidth, int screenHeight, const char* fileName);
+
+struct SimpleOpenGL2RenderCallbacks : public InternalOpenGL2RenderCallbacks
+{
+	PrimInternalData* m_data;
+	virtual PrimInternalData* getData()
+	{
+		return m_data;
+	}
+	SimpleOpenGL2RenderCallbacks(PrimInternalData* data)
+		: m_data(data)
+	{
+	}
+	virtual ~SimpleOpenGL2RenderCallbacks()
+	{
+	}
+};
+
+struct OpenGL2RenderCallbacks : public InternalOpenGL2RenderCallbacks
+{
+	GLPrimitiveRenderer* m_primRender2;
+	virtual PrimInternalData* getData();
+
+	virtual void setWorldPosition(float pos[3]) {}
+	virtual void setWorldOrientation(float orn[4]) {}
+	virtual void setColorRGBA(float color[4]) {}
+
+	OpenGL2RenderCallbacks(GLPrimitiveRenderer* primRender);
+	virtual ~OpenGL2RenderCallbacks();
+};
+
+#endif  //_OPENGL_FONTSTASH_CALLBACKS_H
diff --git a/engine/inc/bullet/Planar2D/Planar2D.h b/engine/inc/bullet/Planar2D/Planar2D.h
new file mode 100644
index 00000000..0cbf950f
--- /dev/null
+++ b/engine/inc/bullet/Planar2D/Planar2D.h
@@ -0,0 +1,20 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef PLANAR2D_H
+#define PLANAR2D_H
+
+class CommonExampleInterface* Planar2DCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //BOX2D_DEMO_H
diff --git a/engine/inc/bullet/Raycast/RaytestDemo.h b/engine/inc/bullet/Raycast/RaytestDemo.h
new file mode 100644
index 00000000..fcd76ba8
--- /dev/null
+++ b/engine/inc/bullet/Raycast/RaytestDemo.h
@@ -0,0 +1,20 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef BT_RAYTEST_DEMO_H
+#define BT_RAYTEST_DEMO_H
+
+class CommonExampleInterface* RaytestCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //BT_RAYTEST_DEMO_H
diff --git a/engine/inc/bullet/RenderingExamples/CoordinateSystemDemo.h b/engine/inc/bullet/RenderingExamples/CoordinateSystemDemo.h
new file mode 100644
index 00000000..12b44139
--- /dev/null
+++ b/engine/inc/bullet/RenderingExamples/CoordinateSystemDemo.h
@@ -0,0 +1,6 @@
+#ifndef COORDINATE_SYSTEM_DEMO_H
+#define COORDINATE_SYSTEM_DEMO_H
+
+class CommonExampleInterface* CoordinateSystemCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //COORDINATE_SYSTEM_DEMO_H
diff --git a/engine/inc/bullet/RenderingExamples/DynamicTexturedCubeDemo.h b/engine/inc/bullet/RenderingExamples/DynamicTexturedCubeDemo.h
new file mode 100644
index 00000000..0665e273
--- /dev/null
+++ b/engine/inc/bullet/RenderingExamples/DynamicTexturedCubeDemo.h
@@ -0,0 +1,6 @@
+#ifndef DYNAMIC_TEXTURED_CUBE_DEMO_H
+#define DYNAMIC_TEXTURED_CUBE_DEMO_H
+
+class CommonExampleInterface* DynamicTexturedCubeDemoCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //DYNAMIC_TEXTURED_CUBE_DEMO_H
diff --git a/engine/inc/bullet/RenderingExamples/RaytracerSetup.h b/engine/inc/bullet/RenderingExamples/RaytracerSetup.h
new file mode 100644
index 00000000..d586a96c
--- /dev/null
+++ b/engine/inc/bullet/RenderingExamples/RaytracerSetup.h
@@ -0,0 +1,6 @@
+#ifndef RAYTRACER_SETUP_H
+#define RAYTRACER_SETUP_H
+
+class CommonExampleInterface* RayTracerCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //RAYTRACER_SETUP_H
diff --git a/engine/inc/bullet/RenderingExamples/RenderInstancingDemo.h b/engine/inc/bullet/RenderingExamples/RenderInstancingDemo.h
new file mode 100644
index 00000000..75cc7046
--- /dev/null
+++ b/engine/inc/bullet/RenderingExamples/RenderInstancingDemo.h
@@ -0,0 +1,6 @@
+#ifndef RENDER_INSTANCING_DEMO_H
+#define RENDER_INSTANCING_DEMO_H
+
+class CommonExampleInterface* RenderInstancingCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //RENDER_INSTANCING_DEMO_H
diff --git a/engine/inc/bullet/RenderingExamples/TimeSeriesCanvas.h b/engine/inc/bullet/RenderingExamples/TimeSeriesCanvas.h
new file mode 100644
index 00000000..86e6e5dd
--- /dev/null
+++ b/engine/inc/bullet/RenderingExamples/TimeSeriesCanvas.h
@@ -0,0 +1,23 @@
+#ifndef TIME_SERIES_CANVAS_H
+#define TIME_SERIES_CANVAS_H
+
+class TimeSeriesCanvas
+{
+protected:
+	struct TimeSeriesInternalData* m_internalData;
+	void shift1PixelToLeft();
+
+public:
+	TimeSeriesCanvas(struct Common2dCanvasInterface* canvasInterface, int width, int height, const char* windowTitle);
+	virtual ~TimeSeriesCanvas();
+
+	void setupTimeSeries(float yScale, int ticksPerSecond, int startTime, bool clearCanvas = true);
+	void addDataSource(const char* dataSourceLabel, unsigned char red, unsigned char green, unsigned char blue);
+	void insertDataAtCurrentTime(float value, int dataSourceIndex, bool connectToPrevious);
+	float getCurrentTime() const;
+	void grapicalPrintf(const char* str, void* fontData, int rasterposx, int rasterposy, unsigned char red, unsigned char green, unsigned char blue, unsigned char alpha);
+
+	virtual void nextTick();
+};
+
+#endif  //TIME_SERIES_CANVAS_H
\ No newline at end of file
diff --git a/engine/inc/bullet/RenderingExamples/TimeSeriesExample.h b/engine/inc/bullet/RenderingExamples/TimeSeriesExample.h
new file mode 100644
index 00000000..d38f9996
--- /dev/null
+++ b/engine/inc/bullet/RenderingExamples/TimeSeriesExample.h
@@ -0,0 +1,6 @@
+#ifndef TIME_SERIES_EXAMPLE_H
+#define TIME_SERIES_EXAMPLE_H
+
+class CommonExampleInterface* TimeSeriesCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //TIME_SERIES_EXAMPLE_H
diff --git a/engine/inc/bullet/RenderingExamples/TimeSeriesFontData.h b/engine/inc/bullet/RenderingExamples/TimeSeriesFontData.h
new file mode 100644
index 00000000..9c8a9d5d
--- /dev/null
+++ b/engine/inc/bullet/RenderingExamples/TimeSeriesFontData.h
@@ -0,0 +1,6 @@
+#ifndef TIME_SERIES_FONT_DATA_H
+#define TIME_SERIES_FONT_DATA_H
+
+extern unsigned char sTimeSeriesFontData[];
+
+#endif  //TIME_SERIES_FONT_DATA_H
diff --git a/engine/inc/bullet/RenderingExamples/TinyRendererSetup.h b/engine/inc/bullet/RenderingExamples/TinyRendererSetup.h
new file mode 100644
index 00000000..19ebbd56
--- /dev/null
+++ b/engine/inc/bullet/RenderingExamples/TinyRendererSetup.h
@@ -0,0 +1,6 @@
+#ifndef TINYRENDERER_SETUP_H
+#define TINYRENDERER_SETUP_H
+
+class CommonExampleInterface* TinyRendererCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //TINYRENDERER_SETUP_H
diff --git a/engine/inc/bullet/RenderingExamples/TinyVRGui.h b/engine/inc/bullet/RenderingExamples/TinyVRGui.h
new file mode 100644
index 00000000..f03deff7
--- /dev/null
+++ b/engine/inc/bullet/RenderingExamples/TinyVRGui.h
@@ -0,0 +1,22 @@
+
+#ifndef TINY_VR_GUI_H
+#define TINY_VR_GUI_H
+
+#include "Bullet3Common/b3Transform.h"
+
+class TinyVRGui
+{
+	struct TinyVRGuiInternalData* m_data;
+
+public:
+	TinyVRGui(struct ComboBoxParams& params, struct CommonRenderInterface* renderer);
+	virtual ~TinyVRGui();
+
+	bool init();
+	void tick(b3Scalar deltaTime, const b3Transform& guiWorldTransform);
+
+	void clearTextArea();
+	void grapicalPrintf(const char* str, int rasterposx, int rasterposy, unsigned char red, unsigned char green, unsigned char blue, unsigned char alpha);
+};
+
+#endif  //TINY_VR_GUI_H
diff --git a/engine/inc/bullet/RigidBody/KinematicRigidBodyExample.h b/engine/inc/bullet/RigidBody/KinematicRigidBodyExample.h
new file mode 100644
index 00000000..a996d207
--- /dev/null
+++ b/engine/inc/bullet/RigidBody/KinematicRigidBodyExample.h
@@ -0,0 +1,21 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2015 Google Inc. http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef KINEMATIC_RIGID_BODY_EXAMPLE_H
+#define KINEMATIC_RIGID_BODY_EXAMPLE_H
+
+class CommonExampleInterface* KinematicRigidBodyExampleCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //KINEMATIC_RIGID_BODY_EXAMPLE_H
diff --git a/engine/inc/bullet/RigidBody/RigidBodySoftContact.h b/engine/inc/bullet/RigidBody/RigidBodySoftContact.h
new file mode 100644
index 00000000..967d64d2
--- /dev/null
+++ b/engine/inc/bullet/RigidBody/RigidBodySoftContact.h
@@ -0,0 +1,21 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2015 Google Inc. http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef RIGID_BODY_SOFT_CONTACT_H
+#define RIGID_BODY_SOFT_CONTACT_H
+
+class CommonExampleInterface* RigidBodySoftContactCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //RIGID_BODY_SOFT_CONTACT_H
diff --git a/engine/inc/bullet/RobotSimulator/MinitaurSetup.h b/engine/inc/bullet/RobotSimulator/MinitaurSetup.h
new file mode 100644
index 00000000..9b6c6c9b
--- /dev/null
+++ b/engine/inc/bullet/RobotSimulator/MinitaurSetup.h
@@ -0,0 +1,19 @@
+#ifndef MINITAUR_SIMULATION_SETUP_H
+#define MINITAUR_SIMULATION_SETUP_H
+
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btQuaternion.h"
+class MinitaurSetup
+{
+	struct MinitaurSetupInternalData* m_data;
+	void resetPose(class b3RobotSimulatorClientAPI_NoGUI* sim);
+
+public:
+	MinitaurSetup();
+	virtual ~MinitaurSetup();
+
+	int setupMinitaur(class b3RobotSimulatorClientAPI_NoGUI* sim, const class btVector3& startPos = btVector3(0, 0, 0), const class btQuaternion& startOrn = btQuaternion(0, 0, 0, 1));
+
+	void setDesiredMotorAngle(class b3RobotSimulatorClientAPI_NoGUI* sim, const char* motorName, double desiredAngle, double maxTorque = 3, double kp = 0.1, double kd = 0.9);
+};
+#endif  //MINITAUR_SIMULATION_SETUP_H
diff --git a/engine/inc/bullet/RobotSimulator/MinitaurSimulatorExample.h b/engine/inc/bullet/RobotSimulator/MinitaurSimulatorExample.h
new file mode 100644
index 00000000..bfa940c7
--- /dev/null
+++ b/engine/inc/bullet/RobotSimulator/MinitaurSimulatorExample.h
@@ -0,0 +1,22 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2019 Google Inc. http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef MINITAUR_SIMULATOR_EXAMPLE_H
+#define MINITAUR_SIMULATOR_EXAMPLE_H
+
+
+class CommonExampleInterface* MinitaurSimulatorExampleCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //MINITAUR_SIMULATOR_EXAMPLE_H
diff --git a/engine/inc/bullet/RobotSimulator/b3RobotSimulatorClientAPI.h b/engine/inc/bullet/RobotSimulator/b3RobotSimulatorClientAPI.h
new file mode 100644
index 00000000..656b1423
--- /dev/null
+++ b/engine/inc/bullet/RobotSimulator/b3RobotSimulatorClientAPI.h
@@ -0,0 +1,27 @@
+#ifndef B3_ROBOT_SIMULATOR_CLIENT_API_GUI_H
+#define B3_ROBOT_SIMULATOR_CLIENT_API_GUI_H
+
+#include "../SharedMemory/b3RobotSimulatorClientAPI_NoGUI.h"
+
+///The b3RobotSimulatorClientAPI_GUI is pretty much the C++ version of pybullet
+///as documented in the pybullet Quickstart Guide
+///https://docs.google.com/document/d/10sXEhzFRSnvFcl3XxNGhnD4N2SedqwdAvK3dsihxVUA
+class b3RobotSimulatorClientAPI : public b3RobotSimulatorClientAPI_NoGUI
+{
+public:
+	b3RobotSimulatorClientAPI();
+
+	virtual ~b3RobotSimulatorClientAPI();
+
+	virtual bool connect(int mode, const std::string& hostName = "localhost", int portOrKey = -1);
+
+	virtual void renderScene();
+
+	virtual void debugDraw(int debugDrawMode);
+
+	virtual bool mouseMoveCallback(float x, float y);
+
+	virtual bool mouseButtonCallback(int button, int state, float x, float y);
+};
+
+#endif  //B3_ROBOT_SIMULATOR_CLIENT_API_H
diff --git a/engine/inc/bullet/RoboticsLearning/GripperGraspExample.h b/engine/inc/bullet/RoboticsLearning/GripperGraspExample.h
new file mode 100644
index 00000000..110068b8
--- /dev/null
+++ b/engine/inc/bullet/RoboticsLearning/GripperGraspExample.h
@@ -0,0 +1,31 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2016 Google Inc. http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef GRIPPER_GRASP_EXAMPLE_H
+#define GRIPPER_GRASP_EXAMPLE_H
+
+enum GripperGraspExampleOptions
+{
+	eGRIPPER_GRASP = 1,
+	eTWO_POINT_GRASP = 2,
+	eONE_MOTOR_GRASP = 4,
+	eGRASP_SOFT_BODY = 8,
+	eSOFTBODY_MULTIBODY_COUPLING = 16,
+	eGRASP_DEFORMABLE_CLOTH = 32,
+};
+
+class CommonExampleInterface* GripperGraspExampleCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //GRIPPER_GRASP_EXAMPLE_H
diff --git a/engine/inc/bullet/RoboticsLearning/KukaGraspExample.h b/engine/inc/bullet/RoboticsLearning/KukaGraspExample.h
new file mode 100644
index 00000000..b5175c8f
--- /dev/null
+++ b/engine/inc/bullet/RoboticsLearning/KukaGraspExample.h
@@ -0,0 +1,26 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2016 Google Inc. http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef KUKA_GRASP_EXAMPLE_H
+#define KUKA_GRASP_EXAMPLE_H
+
+enum KukaGraspExampleOptions
+{
+	eKUKA_GRASP_DLS_IK = 1,
+};
+
+class CommonExampleInterface* KukaGraspExampleCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //KUKA_GRASP_EXAMPLE_H
diff --git a/engine/inc/bullet/RoboticsLearning/R2D2GraspExample.h b/engine/inc/bullet/RoboticsLearning/R2D2GraspExample.h
new file mode 100644
index 00000000..5e8c674a
--- /dev/null
+++ b/engine/inc/bullet/RoboticsLearning/R2D2GraspExample.h
@@ -0,0 +1,28 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2016 Google Inc. http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef R2D2_GRASP_EXAMPLE_H
+#define R2D2_GRASP_EXAMPLE_H
+
+enum RobotLearningExampleOptions
+{
+	eROBOTIC_LEARN_GRASP = 1,
+	eROBOTIC_LEARN_COMPLIANT_CONTACT = 2,
+	eROBOTIC_LEARN_ROLLING_FRICTION = 4,
+};
+
+class CommonExampleInterface* R2D2GraspExampleCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //R2D2_GRASP_EXAMPLE_H
diff --git a/engine/inc/bullet/RollingFrictionDemo/RollingFrictionDemo.h b/engine/inc/bullet/RollingFrictionDemo/RollingFrictionDemo.h
new file mode 100644
index 00000000..2362cc59
--- /dev/null
+++ b/engine/inc/bullet/RollingFrictionDemo/RollingFrictionDemo.h
@@ -0,0 +1,20 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef _ROLLING_FRICTION_DEMO_H
+#define _ROLLING_FRICTION_DEMO_H
+
+class CommonExampleInterface* RollingFrictionCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //_ROLLING_FRICTION_DEMO_H
diff --git a/engine/inc/bullet/SharedMemory/BodyJointInfoUtility.h b/engine/inc/bullet/SharedMemory/BodyJointInfoUtility.h
new file mode 100644
index 00000000..0be4814b
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/BodyJointInfoUtility.h
@@ -0,0 +1,121 @@
+#ifndef BODY_JOINT_INFO_UTILITY_H
+#define BODY_JOINT_INFO_UTILITY_H
+
+#include "Bullet3Common/b3Logging.h"
+
+namespace Bullet
+{
+class btMultiBodyDoubleData;
+class btMultiBodyFloatData;
+};  // namespace Bullet
+
+inline char* strDup(const char* const str)
+{
+#ifdef _WIN32
+	return _strdup(str);
+#else
+	return strdup(str);
+#endif
+}
+
+template <typename T, typename U>
+void addJointInfoFromMultiBodyData(const T* mb, U* bodyJoints, bool verboseOutput)
+{
+	int numDofs = 0;
+	if (mb->m_baseMass>0)
+	{
+		numDofs = 6;
+	}
+
+	if (mb->m_baseName)
+	{
+		if (verboseOutput)
+		{
+			b3Printf("mb->m_baseName = %s\n", mb->m_baseName);
+		}
+	}
+	int qOffset = 7;
+	int uOffset = 6;
+
+	for (int link = 0; link < mb->m_numLinks; link++)
+	{
+		{
+			b3JointInfo info;
+			info.m_jointName[0] = 0;
+			info.m_linkName[0] = 0;
+			info.m_flags = 0;
+			info.m_jointIndex = link;
+			info.m_qIndex =
+				(0 < mb->m_links[link].m_posVarCount) ? qOffset : -1;
+			info.m_uIndex =
+				(0 < mb->m_links[link].m_dofCount) ? uOffset : -1;
+
+			if (mb->m_links[link].m_linkName)
+			{
+				if (verboseOutput)
+				{
+					b3Printf("mb->m_links[%d].m_linkName = %s\n", link,
+							 mb->m_links[link].m_linkName);
+				}
+				strcpy(info.m_linkName, mb->m_links[link].m_linkName);
+			}
+			if (mb->m_links[link].m_jointName)
+			{
+				if (verboseOutput)
+				{
+					b3Printf("mb->m_links[%d].m_jointName = %s\n", link,
+							 mb->m_links[link].m_jointName);
+				}
+				strcpy(info.m_jointName, mb->m_links[link].m_jointName);
+				//info.m_jointName = strDup(mb->m_links[link].m_jointName);
+			}
+
+			info.m_jointType = mb->m_links[link].m_jointType;
+			info.m_jointDamping = mb->m_links[link].m_jointDamping;
+			info.m_jointFriction = mb->m_links[link].m_jointFriction;
+			info.m_jointLowerLimit = mb->m_links[link].m_jointLowerLimit;
+			info.m_jointUpperLimit = mb->m_links[link].m_jointUpperLimit;
+			info.m_jointMaxForce = mb->m_links[link].m_jointMaxForce;
+			info.m_jointMaxVelocity = mb->m_links[link].m_jointMaxVelocity;
+
+			info.m_parentFrame[0] = mb->m_links[link].m_parentComToThisPivotOffset.m_floats[0];
+			info.m_parentFrame[1] = mb->m_links[link].m_parentComToThisPivotOffset.m_floats[1];
+			info.m_parentFrame[2] = mb->m_links[link].m_parentComToThisPivotOffset.m_floats[2];
+			info.m_parentFrame[3] = mb->m_links[link].m_zeroRotParentToThis.m_floats[0];
+			info.m_parentFrame[4] = mb->m_links[link].m_zeroRotParentToThis.m_floats[1];
+			info.m_parentFrame[5] = mb->m_links[link].m_zeroRotParentToThis.m_floats[2];
+			info.m_parentFrame[6] = mb->m_links[link].m_zeroRotParentToThis.m_floats[3];
+
+			info.m_jointAxis[0] = 0;
+			info.m_jointAxis[1] = 0;
+			info.m_jointAxis[2] = 0;
+			info.m_parentIndex = mb->m_links[link].m_parentIndex;
+
+			if (info.m_jointType == eRevoluteType)
+			{
+				info.m_jointAxis[0] = mb->m_links[link].m_jointAxisTop[0].m_floats[0];
+				info.m_jointAxis[1] = mb->m_links[link].m_jointAxisTop[0].m_floats[1];
+				info.m_jointAxis[2] = mb->m_links[link].m_jointAxisTop[0].m_floats[2];
+			}
+			if (info.m_jointType == ePrismaticType)
+			{
+				info.m_jointAxis[0] = mb->m_links[link].m_jointAxisBottom[0].m_floats[0];
+				info.m_jointAxis[1] = mb->m_links[link].m_jointAxisBottom[0].m_floats[1];
+				info.m_jointAxis[2] = mb->m_links[link].m_jointAxisBottom[0].m_floats[2];
+			}
+
+			if ((mb->m_links[link].m_jointType == eRevoluteType) ||
+				(mb->m_links[link].m_jointType == ePrismaticType))
+			{
+				info.m_flags |= JOINT_HAS_MOTORIZED_POWER;
+			}
+			bodyJoints->m_jointInfo.push_back(info);
+		}
+		qOffset += mb->m_links[link].m_posVarCount;
+		uOffset += mb->m_links[link].m_dofCount;
+		numDofs += mb->m_links[link].m_dofCount;
+	}
+	bodyJoints->m_numDofs = numDofs;
+}
+
+#endif  //BODY_JOINT_INFO_UTILITY_H
diff --git a/engine/inc/bullet/SharedMemory/GraphicsClientExample.h b/engine/inc/bullet/SharedMemory/GraphicsClientExample.h
new file mode 100644
index 00000000..403fa31d
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/GraphicsClientExample.h
@@ -0,0 +1,7 @@
+#ifndef GRAPHICS_CLIENT_EXAMPLE_H
+#define GRAPHICS_CLIENT_EXAMPLE_H
+
+
+class CommonExampleInterface* GraphicsClientCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //GRAPHICS_CLIENT_EXAMPLE_H
diff --git a/engine/inc/bullet/SharedMemory/GraphicsServerExample.h b/engine/inc/bullet/SharedMemory/GraphicsServerExample.h
new file mode 100644
index 00000000..ac459675
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/GraphicsServerExample.h
@@ -0,0 +1,6 @@
+#ifndef GRAPHICS_SERVER_EXAMPLE_H
+#define GRAPHICS_SERVER_EXAMPLE_H
+
+class CommonExampleInterface* GraphicsServerCreateFuncBullet(struct CommonExampleOptions& options);
+
+#endif  //GRAPHICS_SERVER_EXAMPLE_H
diff --git a/engine/inc/bullet/SharedMemory/GraphicsSharedMemoryBlock.h b/engine/inc/bullet/SharedMemory/GraphicsSharedMemoryBlock.h
new file mode 100644
index 00000000..10891964
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/GraphicsSharedMemoryBlock.h
@@ -0,0 +1,41 @@
+#ifndef GRAPHICS_SHARED_MEMORY_BLOCK_H
+#define GRAPHICS_SHARED_MEMORY_BLOCK_H
+
+#define GRAPHICS_SHARED_MEMORY_MAX_COMMANDS 1
+
+#include "GraphicsSharedMemoryCommands.h"
+
+struct GraphicsSharedMemoryBlock
+{
+	int m_magicId;
+	struct GraphicsSharedMemoryCommand m_clientCommands[GRAPHICS_SHARED_MEMORY_MAX_COMMANDS];
+	struct GraphicsSharedMemoryStatus m_serverCommands[GRAPHICS_SHARED_MEMORY_MAX_COMMANDS];
+
+	int m_numClientCommands;
+	int m_numProcessedClientCommands;
+
+	int m_numServerCommands;
+	int m_numProcessedServerCommands;
+
+	char m_bulletStreamData[GRAPHICS_SHARED_MEMORY_MAX_STREAM_CHUNK_SIZE];
+};
+
+//http://stackoverflow.com/questions/24736304/unable-to-use-inline-in-declaration-get-error-c2054
+#ifdef _WIN32
+__inline
+#else
+inline
+#endif
+	void
+	InitSharedMemoryBlock(struct GraphicsSharedMemoryBlock* sharedMemoryBlock)
+{
+	sharedMemoryBlock->m_numClientCommands = 0;
+	sharedMemoryBlock->m_numServerCommands = 0;
+	sharedMemoryBlock->m_numProcessedClientCommands = 0;
+	sharedMemoryBlock->m_numProcessedServerCommands = 0;
+	sharedMemoryBlock->m_magicId = GRAPHICS_SHARED_MEMORY_MAGIC_NUMBER;
+}
+
+#define GRAPHICS_SHARED_MEMORY_SIZE sizeof(GraphicsSharedMemoryBlock)
+
+#endif  //GRAPHICS_SHARED_MEMORY_BLOCK_H
diff --git a/engine/inc/bullet/SharedMemory/GraphicsSharedMemoryCommands.h b/engine/inc/bullet/SharedMemory/GraphicsSharedMemoryCommands.h
new file mode 100644
index 00000000..2fbaf459
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/GraphicsSharedMemoryCommands.h
@@ -0,0 +1,192 @@
+#ifndef GRAPHICS_SHARED_MEMORY_COMMANDS_H
+#define GRAPHICS_SHARED_MEMORY_COMMANDS_H
+
+//this is a very experimental draft of commands. We will iterate on this API (commands, arguments etc)
+
+#include "GraphicsSharedMemoryPublic.h"
+
+#ifdef __GNUC__
+#include <stdint.h>
+typedef int32_t smInt32a_t;
+typedef int64_t smInt64a_t;
+typedef uint32_t smUint32a_t;
+typedef uint64_t smUint64a_t;
+#elif defined(_MSC_VER)
+typedef __int32 smInt32a_t;
+typedef __int64 smInt64a_t;
+typedef unsigned __int32 smUint32a_t;
+typedef unsigned __int64 smUint64a_t;
+#else
+typedef int smInt32a_t;
+typedef long long int smInt64a_t;
+typedef unsigned int smUint32a_t;
+typedef unsigned long long int smUint64a_t;
+#endif
+
+#ifdef __APPLE__
+#define GRAPHICS_SHARED_MEMORY_MAX_STREAM_CHUNK_SIZE (512 * 1024)
+#else
+ #define GRAPHICS_SHARED_MEMORY_MAX_STREAM_CHUNK_SIZE (4 * 1024 * 1024)
+#endif
+
+struct GraphicsCommand0
+{
+	int bla;
+};
+
+struct GraphicsUpAxisCommand
+{
+	int m_enableUpAxisY;
+};
+
+struct GraphicsStatus0
+{
+	int bla;
+};
+
+struct GraphicsVisualizerFlagCommand
+{
+	int m_visualizerFlag;
+	int m_enable;
+};
+
+struct GraphicsUploadDataCommand
+{
+	int m_numBytes;
+	int m_dataOffset;
+	int m_dataSlot;
+};
+
+struct GraphicRegisterTextureCommand
+{
+	int m_width;
+	int m_height;
+};
+
+struct GraphicsRegisterTextureStatus
+{
+	int m_textureId;
+};
+
+struct GraphicsRegisterGraphicsShapeCommand
+{
+	int m_numVertices;
+	int m_numIndices;
+	int m_primitiveType;
+	int m_textureId;
+};
+
+struct GraphicsRegisterGraphicsShapeStatus
+{
+	int m_shapeId;
+};
+
+struct GraphicsRegisterGraphicsInstanceCommand
+{
+	
+	int m_shapeIndex;
+	float m_position[4];
+	float m_quaternion[4];
+	float m_color[4];
+	float m_scaling[4];
+};
+
+struct GraphicsRegisterGraphicsInstanceStatus
+{
+	int m_graphicsInstanceId;
+};
+
+struct GraphicsSyncTransformsCommand
+{
+	int m_numPositions;
+};
+
+struct GraphicsRemoveInstanceCommand
+{
+	int m_graphicsUid;
+};
+
+struct GraphicsChangeRGBAColorCommand
+{
+	int m_graphicsUid;
+	double m_rgbaColor[4];
+};
+
+struct GraphicsChangeScalingCommand
+{
+	int m_graphicsUid;
+	double m_scaling[3];
+};
+
+
+
+struct GraphicsGetCameraInfoStatus
+{
+	int width;
+	int height;
+	float viewMatrix[16];
+	float projectionMatrix[16];
+	float camUp[3];
+	float camForward[3];
+	float hor[3];
+	float vert[3];
+	float yaw;
+	float pitch;
+	float camDist;
+	float camTarget[3];
+};
+
+
+struct GraphicsSharedMemoryCommand
+{
+	int m_type;
+	smUint64a_t m_timeStamp;
+	int m_sequenceNumber;
+
+	//m_updateFlags is a bit fields to tell which parameters need updating
+	//for example m_updateFlags = SIM_PARAM_UPDATE_DELTA_TIME | SIM_PARAM_UPDATE_NUM_SOLVER_ITERATIONS;
+	int m_updateFlags;
+
+	union {
+		struct GraphicsCommand0 m_graphicsCommand0;
+		struct GraphicsUpAxisCommand m_upAxisYCommand;
+		struct GraphicsVisualizerFlagCommand m_visualizerFlagCommand;
+		struct GraphicsUploadDataCommand m_uploadDataCommand;
+		struct GraphicRegisterTextureCommand m_registerTextureCommand;
+		struct GraphicsRegisterGraphicsShapeCommand m_registerGraphicsShapeCommand;
+		struct GraphicsRegisterGraphicsInstanceCommand m_registerGraphicsInstanceCommand;
+		struct GraphicsSyncTransformsCommand m_syncTransformsCommand;
+		struct GraphicsRemoveInstanceCommand m_removeGraphicsInstanceCommand;
+		struct GraphicsChangeRGBAColorCommand m_changeRGBAColorCommand;
+		struct GraphicsChangeScalingCommand m_changeScalingCommand;
+	};
+};
+
+struct GraphicsSharedMemoryStatus
+{
+	int m_type;
+
+	smUint64a_t m_timeStamp;
+	int m_sequenceNumber;
+
+	//m_streamBytes is only for internal purposes
+	int m_numDataStreamBytes;
+	char* m_dataStream;
+
+	//m_updateFlags is a bit fields to tell which parameters were updated,
+	//m_updateFlags is ignored for most status messages
+	int m_updateFlags;
+
+	union {
+		
+		struct GraphicsStatus0 m_graphicsStatus0;
+		struct GraphicsRegisterTextureStatus m_registerTextureStatus;
+		struct GraphicsRegisterGraphicsShapeStatus m_registerGraphicsShapeStatus;
+		struct GraphicsRegisterGraphicsInstanceStatus m_registerGraphicsInstanceStatus;
+		struct GraphicsGetCameraInfoStatus m_getCameraInfoStatus;
+	};
+};
+
+typedef struct GraphicsSharedMemoryStatus GraphicsSharedMemoryStatus_t;
+
+#endif  //GRAPHICS_SHARED_MEMORY_COMMANDS_H
diff --git a/engine/inc/bullet/SharedMemory/GraphicsSharedMemoryPublic.h b/engine/inc/bullet/SharedMemory/GraphicsSharedMemoryPublic.h
new file mode 100644
index 00000000..4a80736b
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/GraphicsSharedMemoryPublic.h
@@ -0,0 +1,52 @@
+#ifndef GRAPHICS_SHARED_MEMORY_PUBLIC_H
+#define GRAPHICS_SHARED_MEMORY_PUBLIC_H
+
+#define GRAPHICS_SHARED_MEMORY_KEY 11347
+///increase the SHARED_MEMORY_MAGIC_NUMBER whenever incompatible changes are made in the structures
+///my convention is year/month/day/rev
+//Please don't replace an existing magic number:
+//instead, only ADD a new one at the top, comment-out previous one
+
+#define GRAPHICS_SHARED_MEMORY_MAGIC_NUMBER 201904030
+enum EnumGraphicsSharedMemoryClientCommand
+{
+	GFX_CMD_INVALID = 0,
+	GFX_CMD_0,
+	GFX_CMD_SET_VISUALIZER_FLAG,
+	GFX_CMD_UPLOAD_DATA,
+	GFX_CMD_REGISTER_TEXTURE,
+	GFX_CMD_REGISTER_GRAPHICS_SHAPE,
+	GFX_CMD_REGISTER_GRAPHICS_INSTANCE,
+	GFX_CMD_SYNCHRONIZE_TRANSFORMS,
+	GFX_CMD_REMOVE_ALL_GRAPHICS_INSTANCES,
+	GFX_CMD_REMOVE_SINGLE_GRAPHICS_INSTANCE,
+	GFX_CMD_CHANGE_RGBA_COLOR,
+	GFX_CMD_GET_CAMERA_INFO,
+	GFX_CMD_CHANGE_SCALING,
+	//don't go beyond this command!
+	GFX_CMD_MAX_CLIENT_COMMANDS,
+};
+
+enum EnumGraphicsSharedMemoryServerStatus
+{
+	GFX_CMD_SHARED_MEMORY_NOT_INITIALIZED = 0,
+	//GFX_CMD_CLIENT_COMMAND_COMPLETED is a generic 'completed' status that doesn't need special handling on the client
+	GFX_CMD_CLIENT_COMMAND_COMPLETED,
+	GFX_CMD_CLIENT_COMMAND_FAILED,
+	GFX_CMD_REGISTER_TEXTURE_COMPLETED,
+	GFX_CMD_REGISTER_TEXTURE_FAILED,
+	GFX_CMD_REGISTER_GRAPHICS_SHAPE_COMPLETED,
+	GFX_CMD_REGISTER_GRAPHICS_SHAPE_FAILED,
+	GFX_CMD_REGISTER_GRAPHICS_INSTANCE_COMPLETED,
+	GFX_CMD_REGISTER_GRAPHICS_INSTANCE_FAILED,
+	GFX_CMD_GET_CAMERA_INFO_COMPLETED,
+	GFX_CMD_GET_CAMERA_INFO_FAILED,
+	//don't go beyond 'CMD_MAX_SERVER_COMMANDS!
+	GFX_CMD_MAX_SERVER_COMMANDS
+};
+
+
+
+
+
+#endif  //GRAPHICS_SHARED_MEMORY_PUBLIC_H
diff --git a/engine/inc/bullet/SharedMemory/IKTrajectoryHelper.h b/engine/inc/bullet/SharedMemory/IKTrajectoryHelper.h
new file mode 100644
index 00000000..cdbe7a23
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/IKTrajectoryHelper.h
@@ -0,0 +1,44 @@
+#ifndef IK_TRAJECTORY_HELPER_H
+#define IK_TRAJECTORY_HELPER_H
+
+enum IK2_Method
+{
+	IK2_JACOB_TRANS = 0,
+	IK2_PURE_PSEUDO,
+	IK2_DLS,
+	IK2_SDLS,
+	IK2_DLS_SVD,
+	IK2_VEL_DLS,
+	IK2_VEL_DLS_WITH_ORIENTATION,
+	IK2_VEL_DLS_WITH_NULLSPACE,
+	IK2_VEL_DLS_WITH_ORIENTATION_NULLSPACE,
+	IK2_VEL_SDLS,
+	IK2_VEL_SDLS_WITH_ORIENTATION,
+};
+
+class IKTrajectoryHelper
+{
+	struct IKTrajectoryHelperInternalData* m_data;
+
+public:
+	IKTrajectoryHelper();
+	virtual ~IKTrajectoryHelper();
+
+	bool computeIK(const double endEffectorTargetPosition[3],
+				   const double endEffectorTargetOrientation[4],
+				   const double endEffectorWorldPosition[3],
+				   const double endEffectorWorldOrientation[4],
+				   const double* q_old, int numQ, int endEffectorIndex,
+				   double* q_new, int ikMethod, const double* linear_jacobian, const double* angular_jacobian, int jacobian_size, const double dampIk[6]);
+
+	bool computeIK2(
+		const double* endEffectorTargetPositions,
+		const double* endEffectorCurrentPositions,
+		int numEndEffectors,
+		const double* q_current, int numQ,
+		double* q_new, int ikMethod, const double* linear_jacobians, const double dampIk[6]);
+
+	bool computeNullspaceVel(int numQ, const double* q_current, const double* lower_limit, const double* upper_limit, const double* joint_range, const double* rest_pose);
+	bool setDampingCoeff(int numQ, const double* coeff);
+};
+#endif  //IK_TRAJECTORY_HELPER_H
diff --git a/engine/inc/bullet/SharedMemory/InProcessMemory.h b/engine/inc/bullet/SharedMemory/InProcessMemory.h
new file mode 100644
index 00000000..d9b19c6a
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/InProcessMemory.h
@@ -0,0 +1,18 @@
+#ifndef IN_PROCESS_MEMORY_H
+#define IN_PROCESS_MEMORY_H
+
+#include "SharedMemoryInterface.h"
+
+class InProcessMemory : public SharedMemoryInterface
+{
+	struct InProcessMemoryInternalData* m_data;
+
+public:
+	InProcessMemory();
+	virtual ~InProcessMemory();
+
+	virtual void* allocateSharedMemory(int key, int size, bool allowCreation);
+	virtual void releaseSharedMemory(int key, int size);
+};
+
+#endif
diff --git a/engine/inc/bullet/SharedMemory/PhysicsClient.h b/engine/inc/bullet/SharedMemory/PhysicsClient.h
new file mode 100644
index 00000000..33c139ef
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/PhysicsClient.h
@@ -0,0 +1,94 @@
+#ifndef BT_PHYSICS_CLIENT_API_H
+#define BT_PHYSICS_CLIENT_API_H
+
+//#include "SharedMemoryCommands.h"
+#include "LinearMath/btVector3.h"
+
+class PhysicsClient
+{
+public:
+	virtual ~PhysicsClient();
+
+	// return true if connection succesfull, can also check 'isConnected'
+	virtual bool connect() = 0;
+
+	virtual void disconnectSharedMemory() = 0;
+
+	virtual bool isConnected() const = 0;
+
+	// return non-null if there is a status, nullptr otherwise
+	virtual const struct SharedMemoryStatus* processServerStatus() = 0;
+
+	virtual struct SharedMemoryCommand* getAvailableSharedMemoryCommand() = 0;
+
+	virtual bool canSubmitCommand() const = 0;
+
+	virtual bool submitClientCommand(const struct SharedMemoryCommand& command) = 0;
+
+	virtual int getNumBodies() const = 0;
+
+	virtual int getBodyUniqueId(int serialIndex) const = 0;
+
+	virtual bool getBodyInfo(int bodyUniqueId, struct b3BodyInfo& info) const = 0;
+
+	virtual int getNumJoints(int bodyUniqueId) const = 0;
+
+	virtual int getNumDofs(int bodyUniqueId) const = 0;
+
+	virtual bool getJointInfo(int bodyUniqueId, int jointIndex, struct b3JointInfo& info) const = 0;
+
+	virtual int getNumUserConstraints() const = 0;
+
+	virtual int getUserConstraintInfo(int constraintUniqueId, struct b3UserConstraint& info) const = 0;
+
+	virtual int getUserConstraintId(int serialIndex) const = 0;
+
+	virtual void setSharedMemoryKey(int key) = 0;
+
+	virtual void uploadBulletFileToSharedMemory(const char* data, int len) = 0;
+
+	virtual void uploadRaysToSharedMemory(struct SharedMemoryCommand& command, const double* rayFromWorldArray, const double* rayToWorldArray, int numRays) = 0;
+
+	virtual int getNumDebugLines() const = 0;
+
+	virtual const float* getDebugLinesFrom() const = 0;
+	virtual const float* getDebugLinesTo() const = 0;
+	virtual const float* getDebugLinesColor() const = 0;
+
+	virtual void getCachedCameraImage(struct b3CameraImageData* cameraData) = 0;
+
+	virtual void getCachedContactPointInformation(struct b3ContactInformation* contactPointData) = 0;
+
+	virtual void getCachedOverlappingObjects(struct b3AABBOverlapData* overlappingObjects) = 0;
+
+	virtual void getCachedVisualShapeInformation(struct b3VisualShapeInformation* visualShapesInfo) = 0;
+
+	virtual void getCachedCollisionShapeInformation(struct b3CollisionShapeInformation* collisionShapesInfo) = 0;
+
+	virtual void getCachedMeshData(struct b3MeshData* meshData) = 0;
+
+	virtual void getCachedVREvents(struct b3VREventsData* vrEventsData) = 0;
+
+	virtual void getCachedKeyboardEvents(struct b3KeyboardEventsData* keyboardEventsData) = 0;
+
+	virtual void getCachedMouseEvents(struct b3MouseEventsData* mouseEventsData) = 0;
+
+	virtual void getCachedRaycastHits(struct b3RaycastInformation* raycastHits) = 0;
+
+	virtual void getCachedMassMatrix(int dofCountCheck, double* massMatrix) = 0;
+
+	virtual bool getCachedReturnData(struct b3UserDataValue* returnData) = 0;
+
+	virtual void setTimeOut(double timeOutInSeconds) = 0;
+	virtual double getTimeOut() const = 0;
+
+	virtual bool getCachedUserData(int userDataId, struct b3UserDataValue& valueOut) const = 0;
+	virtual int getCachedUserDataId(int bodyUniqueId, int linkIndex, int visualShapeIndex, const char* key) const = 0;
+	virtual int getNumUserData(int bodyUniqueId) const = 0;
+	virtual void getUserDataInfo(int bodyUniqueId, int userDataIndex, const char** keyOut, int* userDataIdOut, int* linkIndexOut, int* visualShapeIndexOut) const = 0;
+
+	virtual void pushProfileTiming(const char* timingName) = 0;
+	virtual void popProfileTiming() = 0;
+};
+
+#endif  // BT_PHYSICS_CLIENT_API_H
diff --git a/engine/inc/bullet/SharedMemory/PhysicsClientC_API.h b/engine/inc/bullet/SharedMemory/PhysicsClientC_API.h
new file mode 100644
index 00000000..318263b2
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/PhysicsClientC_API.h
@@ -0,0 +1,740 @@
+#ifndef PHYSICS_CLIENT_C_API_H
+#define PHYSICS_CLIENT_C_API_H
+
+//#include "SharedMemoryBlock.h"
+#include "SharedMemoryPublic.h"
+
+#define B3_DECLARE_HANDLE(name) \
+	typedef struct name##__     \
+	{                           \
+		int unused;             \
+	} * name
+
+B3_DECLARE_HANDLE(b3PhysicsClientHandle);
+B3_DECLARE_HANDLE(b3SharedMemoryCommandHandle);
+B3_DECLARE_HANDLE(b3SharedMemoryStatusHandle);
+
+#ifdef _WIN32
+#define B3_SHARED_API __declspec(dllexport)
+#elif defined(__GNUC__)
+#define B3_SHARED_API __attribute__((visibility("default")))
+#else
+#define B3_SHARED_API
+#endif
+
+///There are several connection methods, see following header files:
+#include "PhysicsClientSharedMemory_C_API.h"
+#include "PhysicsClientSharedMemory2_C_API.h"
+#include "PhysicsDirectC_API.h"
+
+#ifdef BT_ENABLE_ENET
+#include "PhysicsClientUDP_C_API.h"
+#endif
+
+#ifdef BT_ENABLE_CLSOCKET
+#include "PhysicsClientTCP_C_API.h"
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	///b3DisconnectSharedMemory will disconnect the client from the server and cleanup memory.
+	B3_SHARED_API void b3DisconnectSharedMemory(b3PhysicsClientHandle physClient);
+
+	///There can only be 1 outstanding command. Check if a command can be send.
+	B3_SHARED_API int b3CanSubmitCommand(b3PhysicsClientHandle physClient);
+
+	///blocking submit command and wait for status
+	B3_SHARED_API b3SharedMemoryStatusHandle b3SubmitClientCommandAndWaitStatus(b3PhysicsClientHandle physClient, b3SharedMemoryCommandHandle commandHandle);
+
+	///In general it is better to use b3SubmitClientCommandAndWaitStatus. b3SubmitClientCommand is a non-blocking submit
+	///command, which requires checking for the status manually, using b3ProcessServerStatus. Also, before sending the
+	///next command, make sure to check if you can send a command using 'b3CanSubmitCommand'.
+	B3_SHARED_API int b3SubmitClientCommand(b3PhysicsClientHandle physClient, b3SharedMemoryCommandHandle commandHandle);
+
+	///non-blocking check status
+	B3_SHARED_API b3SharedMemoryStatusHandle b3ProcessServerStatus(b3PhysicsClientHandle physClient);
+
+	/// Get the physics server return status type. See EnumSharedMemoryServerStatus in SharedMemoryPublic.h for error codes.
+	B3_SHARED_API int b3GetStatusType(b3SharedMemoryStatusHandle statusHandle);
+
+	///Plugin system, load and unload a plugin, execute a command
+	B3_SHARED_API b3SharedMemoryCommandHandle b3CreateCustomCommand(b3PhysicsClientHandle physClient);
+	B3_SHARED_API void b3CustomCommandLoadPlugin(b3SharedMemoryCommandHandle commandHandle, const char* pluginPath);
+	B3_SHARED_API void b3CustomCommandLoadPluginSetPostFix(b3SharedMemoryCommandHandle commandHandle, const char* postFix);
+	B3_SHARED_API int b3GetStatusPluginUniqueId(b3SharedMemoryStatusHandle statusHandle);
+	B3_SHARED_API int b3GetStatusPluginCommandResult(b3SharedMemoryStatusHandle statusHandle);
+	B3_SHARED_API int b3GetStatusPluginCommandReturnData(b3PhysicsClientHandle physClient, struct b3UserDataValue* valueOut);
+	
+	B3_SHARED_API void b3CustomCommandUnloadPlugin(b3SharedMemoryCommandHandle commandHandle, int pluginUniqueId);
+	B3_SHARED_API void b3CustomCommandExecutePluginCommand(b3SharedMemoryCommandHandle commandHandle, int pluginUniqueId, const char* textArguments);
+	B3_SHARED_API void b3CustomCommandExecuteAddIntArgument(b3SharedMemoryCommandHandle commandHandle, int intVal);
+	B3_SHARED_API void b3CustomCommandExecuteAddFloatArgument(b3SharedMemoryCommandHandle commandHandle, float floatVal);
+
+	B3_SHARED_API int b3GetStatusBodyIndices(b3SharedMemoryStatusHandle statusHandle, int* bodyIndicesOut, int bodyIndicesCapacity);
+
+	B3_SHARED_API int b3GetStatusBodyIndex(b3SharedMemoryStatusHandle statusHandle);
+
+	B3_SHARED_API int b3GetStatusActualState(b3SharedMemoryStatusHandle statusHandle,
+											 int* bodyUniqueId,
+											 int* numDegreeOfFreedomQ,
+											 int* numDegreeOfFreedomU,
+											 const double* rootLocalInertialFrame[],
+											 const double* actualStateQ[],
+											 const double* actualStateQdot[],
+											 const double* jointReactionForces[]);
+
+	B3_SHARED_API int b3GetStatusActualState2(b3SharedMemoryStatusHandle statusHandle,
+											  int* bodyUniqueId,
+											  int* numLinks,
+											  int* numDegreeOfFreedomQ,
+											  int* numDegreeOfFreedomU,
+											  const double* rootLocalInertialFrame[],
+											  const double* actualStateQ[],
+											  const double* actualStateQdot[],
+											  const double* jointReactionForces[],
+											  const double* linkLocalInertialFrames[],
+											  const double* jointMotorForces[],
+											  const double* linkStates[],
+											  const double* linkWorldVelocities[]);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3RequestCollisionInfoCommandInit(b3PhysicsClientHandle physClient, int bodyUniqueId);
+	B3_SHARED_API int b3GetStatusAABB(b3SharedMemoryStatusHandle statusHandle, int linkIndex, double aabbMin[/*3*/], double aabbMax[/*3*/]);
+
+	///If you re-connected to an existing server, or server changed otherwise, sync the body info and user constraints etc.
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitSyncBodyInfoCommand(b3PhysicsClientHandle physClient);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitRemoveBodyCommand(b3PhysicsClientHandle physClient, int bodyUniqueId);
+
+	///return the total number of bodies in the simulation
+	B3_SHARED_API int b3GetNumBodies(b3PhysicsClientHandle physClient);
+
+	/// return the body unique id, given the index in range [0 , b3GetNumBodies() )
+	B3_SHARED_API int b3GetBodyUniqueId(b3PhysicsClientHandle physClient, int serialIndex);
+
+	///given a body unique id, return the body information. See b3BodyInfo in SharedMemoryPublic.h
+	B3_SHARED_API int b3GetBodyInfo(b3PhysicsClientHandle physClient, int bodyUniqueId, struct b3BodyInfo* info);
+
+	///give a unique body index (after loading the body) return the number of joints.
+	B3_SHARED_API int b3GetNumJoints(b3PhysicsClientHandle physClient, int bodyUniqueId);
+	  ///give a unique body index (after loading the body) return the number of degrees of freedom (DoF).
+        B3_SHARED_API int b3GetNumDofs(b3PhysicsClientHandle physClient, int bodyUniqueId);
+	
+	///compute the number of degrees of freedom for this body.
+	///Return -1 for unsupported spherical joint, -2 for unsupported planar joint.
+	B3_SHARED_API int b3ComputeDofCount(b3PhysicsClientHandle physClient, int bodyUniqueId);
+
+	///given a body and joint index, return the joint information. See b3JointInfo in SharedMemoryPublic.h
+	B3_SHARED_API int b3GetJointInfo(b3PhysicsClientHandle physClient, int bodyUniqueId, int jointIndex, struct b3JointInfo* info);
+
+	///user data handling
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitSyncUserDataCommand(b3PhysicsClientHandle physClient);
+	B3_SHARED_API void b3AddBodyToSyncUserDataRequest(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueId);
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitAddUserDataCommand(b3PhysicsClientHandle physClient, int bodyUniqueId, int linkIndex, int visualShapeIndex, const char* key, enum UserDataValueType valueType, int valueLength, const void* valueData);
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitRemoveUserDataCommand(b3PhysicsClientHandle physClient, int userDataId);
+
+	B3_SHARED_API int b3GetUserData(b3PhysicsClientHandle physClient, int userDataId, struct b3UserDataValue* valueOut);
+	B3_SHARED_API int b3GetUserDataId(b3PhysicsClientHandle physClient, int bodyUniqueId, int linkIndex, int visualShapeIndex, const char* key);
+	B3_SHARED_API int b3GetUserDataIdFromStatus(b3SharedMemoryStatusHandle statusHandle);
+	B3_SHARED_API int b3GetNumUserData(b3PhysicsClientHandle physClient, int bodyUniqueId);
+	B3_SHARED_API void b3GetUserDataInfo(b3PhysicsClientHandle physClient, int bodyUniqueId, int userDataIndex, const char** keyOut, int* userDataIdOut, int* linkIndexOut, int* visualShapeIndexOut);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3GetDynamicsInfoCommandInit(b3PhysicsClientHandle physClient, int bodyUniqueId, int linkIndex);
+	B3_SHARED_API b3SharedMemoryCommandHandle b3GetDynamicsInfoCommandInit2(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueId, int linkIndex);
+
+	///given a body unique id and link index, return the dynamics information. See b3DynamicsInfo in SharedMemoryPublic.h
+	B3_SHARED_API int b3GetDynamicsInfo(b3SharedMemoryStatusHandle statusHandle, struct b3DynamicsInfo* info);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitChangeDynamicsInfo(b3PhysicsClientHandle physClient);
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitChangeDynamicsInfo2(b3SharedMemoryCommandHandle commandHandle);
+
+	B3_SHARED_API int b3ChangeDynamicsInfoSetMass(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueId, int linkIndex, double mass);
+	B3_SHARED_API int b3ChangeDynamicsInfoSetLocalInertiaDiagonal(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueId, int linkIndex, const double localInertiaDiagonal[]);
+	B3_SHARED_API int b3ChangeDynamicsInfoSetAnisotropicFriction(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueId, int linkIndex, const double anisotropicFriction[]);
+	B3_SHARED_API int b3ChangeDynamicsInfoSetJointLimit(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueId, int linkIndex, double jointLowerLimit, double jointUpperLimit);
+	B3_SHARED_API int b3ChangeDynamicsInfoSetJointLimitForce(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueId, int linkIndex, double jointLimitForce);
+	B3_SHARED_API int b3ChangeDynamicsInfoSetDynamicType(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueId, int linkIndex, int dynamicType);
+	
+	
+	B3_SHARED_API int b3ChangeDynamicsInfoSetLateralFriction(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueId, int linkIndex, double lateralFriction);
+	B3_SHARED_API int b3ChangeDynamicsInfoSetSpinningFriction(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueId, int linkIndex, double friction);
+	B3_SHARED_API int b3ChangeDynamicsInfoSetRollingFriction(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueId, int linkIndex, double friction);
+	B3_SHARED_API int b3ChangeDynamicsInfoSetRestitution(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueId, int linkIndex, double restitution);
+	B3_SHARED_API int b3ChangeDynamicsInfoSetLinearDamping(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueId, double linearDamping);
+	B3_SHARED_API int b3ChangeDynamicsInfoSetAngularDamping(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueId, double angularDamping);
+	B3_SHARED_API int b3ChangeDynamicsInfoSetJointDamping(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueId, int linkIndex, double jointDamping);
+	
+	B3_SHARED_API int b3ChangeDynamicsInfoSetContactStiffnessAndDamping(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueId, int linkIndex, double contactStiffness, double contactDamping);
+	B3_SHARED_API int b3ChangeDynamicsInfoSetFrictionAnchor(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueId, int linkIndex, int frictionAnchor);
+	B3_SHARED_API int b3ChangeDynamicsInfoSetCcdSweptSphereRadius(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueId, int linkIndex, double ccdSweptSphereRadius);
+	B3_SHARED_API int b3ChangeDynamicsInfoSetContactProcessingThreshold(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueId, int linkIndex, double contactProcessingThreshold);
+	B3_SHARED_API int b3ChangeDynamicsInfoSetActivationState(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueId, int activationState);
+	B3_SHARED_API int b3ChangeDynamicsInfoSetMaxJointVelocity(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueId, double maxJointVelocity);
+	B3_SHARED_API int b3ChangeDynamicsInfoSetCollisionMargin(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueId, double collisionMargin);
+	
+	
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitCreateUserConstraintCommand(b3PhysicsClientHandle physClient, int parentBodyUniqueId, int parentJointIndex, int childBodyUniqueId, int childJointIndex, struct b3JointInfo* info);
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitCreateUserConstraintCommand2(b3SharedMemoryCommandHandle commandHandle, int parentBodyUniqueId, int parentJointIndex, int childBodyUniqueId, int childJointIndex, struct b3JointInfo* info);
+
+	///return a unique id for the user constraint, after successful creation, or -1 for an invalid constraint id
+	B3_SHARED_API int b3GetStatusUserConstraintUniqueId(b3SharedMemoryStatusHandle statusHandle);
+
+	///change parameters of an existing user constraint
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitChangeUserConstraintCommand(b3PhysicsClientHandle physClient, int userConstraintUniqueId);
+	B3_SHARED_API int b3InitChangeUserConstraintSetPivotInB(b3SharedMemoryCommandHandle commandHandle, const double jointChildPivot[/*3*/]);
+	B3_SHARED_API int b3InitChangeUserConstraintSetFrameInB(b3SharedMemoryCommandHandle commandHandle, const double jointChildFrameOrn[/*4*/]);
+	B3_SHARED_API int b3InitChangeUserConstraintSetMaxForce(b3SharedMemoryCommandHandle commandHandle, double maxAppliedForce);
+	B3_SHARED_API int b3InitChangeUserConstraintSetGearRatio(b3SharedMemoryCommandHandle commandHandle, double gearRatio);
+	B3_SHARED_API int b3InitChangeUserConstraintSetGearAuxLink(b3SharedMemoryCommandHandle commandHandle, int gearAuxLink);
+	B3_SHARED_API int b3InitChangeUserConstraintSetRelativePositionTarget(b3SharedMemoryCommandHandle commandHandle, double relativePositionTarget);
+	B3_SHARED_API int b3InitChangeUserConstraintSetERP(b3SharedMemoryCommandHandle commandHandle, double erp);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitRemoveUserConstraintCommand(b3PhysicsClientHandle physClient, int userConstraintUniqueId);
+
+	B3_SHARED_API int b3GetNumUserConstraints(b3PhysicsClientHandle physClient);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitGetUserConstraintStateCommand(b3PhysicsClientHandle physClient, int constraintUniqueId);
+	B3_SHARED_API int b3GetStatusUserConstraintState(b3SharedMemoryStatusHandle statusHandle, struct b3UserConstraintState* constraintState);
+
+	B3_SHARED_API int b3GetUserConstraintInfo(b3PhysicsClientHandle physClient, int constraintUniqueId, struct b3UserConstraint* info);
+	/// return the user constraint id, given the index in range [0 , b3GetNumUserConstraints() )
+	B3_SHARED_API int b3GetUserConstraintId(b3PhysicsClientHandle physClient, int serialIndex);
+
+	///Request physics debug lines for debug visualization. The flags in debugMode are the same as used in Bullet
+	///See btIDebugDraw::DebugDrawModes in Bullet/src/LinearMath/btIDebugDraw.h
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitRequestDebugLinesCommand(b3PhysicsClientHandle physClient, int debugMode);
+
+	///Get the pointers to the physics debug line information, after b3InitRequestDebugLinesCommand returns
+	///status CMD_DEBUG_LINES_COMPLETED
+	B3_SHARED_API void b3GetDebugLines(b3PhysicsClientHandle physClient, struct b3DebugLines* lines);
+
+	///configure the 3D OpenGL debug visualizer (enable/disable GUI widgets, shadows, position camera etc)
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitConfigureOpenGLVisualizer(b3PhysicsClientHandle physClient);
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitConfigureOpenGLVisualizer2(b3SharedMemoryCommandHandle commandHandle);
+	B3_SHARED_API void b3ConfigureOpenGLVisualizerSetVisualizationFlags(b3SharedMemoryCommandHandle commandHandle, int flag, int enabled);
+	B3_SHARED_API void b3ConfigureOpenGLVisualizerSetLightPosition(b3SharedMemoryCommandHandle commandHandle, const float lightPosition[3]);
+	B3_SHARED_API void b3ConfigureOpenGLVisualizerSetShadowMapResolution(b3SharedMemoryCommandHandle commandHandle, int shadowMapResolution);
+	B3_SHARED_API void b3ConfigureOpenGLVisualizerSetShadowMapIntensity(b3SharedMemoryCommandHandle commandHandle, double shadowMapIntensity);
+	
+	B3_SHARED_API void b3ConfigureOpenGLVisualizerSetShadowMapWorldSize(b3SharedMemoryCommandHandle commandHandle, int shadowMapWorldSize);
+	B3_SHARED_API void b3ConfigureOpenGLVisualizerSetRemoteSyncTransformInterval(b3SharedMemoryCommandHandle commandHandle, double remoteSyncTransformInterval);
+	
+	B3_SHARED_API void b3ConfigureOpenGLVisualizerSetViewMatrix(b3SharedMemoryCommandHandle commandHandle, float cameraDistance, float cameraPitch, float cameraYaw, const float cameraTargetPosition[/*3*/]);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitRequestOpenGLVisualizerCameraCommand(b3PhysicsClientHandle physClient);
+	B3_SHARED_API int b3GetStatusOpenGLVisualizerCamera(b3SharedMemoryStatusHandle statusHandle, struct b3OpenGLVisualizerCameraInfo* camera);
+
+	/// Add/remove user-specific debug lines and debug text messages
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitUserDebugDrawAddLine3D(b3PhysicsClientHandle physClient, const double fromXYZ[/*3*/], const double toXYZ[/*3*/], const double colorRGB[/*3*/], double lineWidth, double lifeTime);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitUserDebugDrawAddText3D(b3PhysicsClientHandle physClient, const char* txt, const double positionXYZ[/*3*/], const double colorRGB[/*3*/], double textSize, double lifeTime);
+	B3_SHARED_API void b3UserDebugTextSetOptionFlags(b3SharedMemoryCommandHandle commandHandle, int optionFlags);
+	B3_SHARED_API void b3UserDebugTextSetOrientation(b3SharedMemoryCommandHandle commandHandle, const double orientation[/*4*/]);
+	B3_SHARED_API void b3UserDebugItemSetReplaceItemUniqueId(b3SharedMemoryCommandHandle commandHandle, int replaceItem);
+
+	B3_SHARED_API void b3UserDebugItemSetParentObject(b3SharedMemoryCommandHandle commandHandle, int objectUniqueId, int linkIndex);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitUserDebugAddParameter(b3PhysicsClientHandle physClient, const char* txt, double rangeMin, double rangeMax, double startValue);
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitUserDebugReadParameter(b3PhysicsClientHandle physClient, int debugItemUniqueId);
+	B3_SHARED_API int b3GetStatusDebugParameterValue(b3SharedMemoryStatusHandle statusHandle, double* paramValue);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitUserDebugDrawRemove(b3PhysicsClientHandle physClient, int debugItemUniqueId);
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitUserDebugDrawRemoveAll(b3PhysicsClientHandle physClient);
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitUserRemoveAllParameters(b3PhysicsClientHandle physClient);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitDebugDrawingCommand(b3PhysicsClientHandle physClient);
+	B3_SHARED_API void b3SetDebugObjectColor(b3SharedMemoryCommandHandle commandHandle, int objectUniqueId, int linkIndex, const double objectColorRGB[/*3*/]);
+	B3_SHARED_API void b3RemoveDebugObjectColor(b3SharedMemoryCommandHandle commandHandle, int objectUniqueId, int linkIndex);
+
+	///All debug items unique Ids are positive: a negative unique Id means failure.
+	B3_SHARED_API int b3GetDebugItemUniqueId(b3SharedMemoryStatusHandle statusHandle);
+
+	///request an image from a simulated camera, using a software renderer.
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitRequestCameraImage(b3PhysicsClientHandle physClient);
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitRequestCameraImage2(b3SharedMemoryCommandHandle commandHandle);
+	B3_SHARED_API void b3RequestCameraImageSetCameraMatrices(b3SharedMemoryCommandHandle commandHandle, float viewMatrix[/*16*/], float projectionMatrix[/*16*/]);
+	B3_SHARED_API void b3RequestCameraImageSetPixelResolution(b3SharedMemoryCommandHandle commandHandle, int width, int height);
+	B3_SHARED_API void b3RequestCameraImageSetLightDirection(b3SharedMemoryCommandHandle commandHandle, const float lightDirection[/*3*/]);
+	B3_SHARED_API void b3RequestCameraImageSetLightColor(b3SharedMemoryCommandHandle commandHandle, const float lightColor[/*3*/]);
+	B3_SHARED_API void b3RequestCameraImageSetLightDistance(b3SharedMemoryCommandHandle commandHandle, float lightDistance);
+	B3_SHARED_API void b3RequestCameraImageSetLightAmbientCoeff(b3SharedMemoryCommandHandle commandHandle, float lightAmbientCoeff);
+	B3_SHARED_API void b3RequestCameraImageSetLightDiffuseCoeff(b3SharedMemoryCommandHandle commandHandle, float lightDiffuseCoeff);
+	B3_SHARED_API void b3RequestCameraImageSetLightSpecularCoeff(b3SharedMemoryCommandHandle commandHandle, float lightSpecularCoeff);
+	B3_SHARED_API void b3RequestCameraImageSetShadow(b3SharedMemoryCommandHandle commandHandle, int hasShadow);
+	B3_SHARED_API void b3RequestCameraImageSelectRenderer(b3SharedMemoryCommandHandle commandHandle, int renderer);
+	B3_SHARED_API void b3RequestCameraImageSetFlags(b3SharedMemoryCommandHandle commandHandle, int flags);
+
+	B3_SHARED_API void b3GetCameraImageData(b3PhysicsClientHandle physClient, struct b3CameraImageData* imageData);
+
+	///set projective texture camera matrices.
+	B3_SHARED_API void b3RequestCameraImageSetProjectiveTextureMatrices(b3SharedMemoryCommandHandle commandHandle, float viewMatrix[/*16*/], float projectionMatrix[/*16*/]);
+
+	///compute a view matrix, helper function for b3RequestCameraImageSetCameraMatrices
+	B3_SHARED_API void b3ComputeViewMatrixFromPositions(const float cameraPosition[/*3*/], const float cameraTargetPosition[/*3*/], const float cameraUp[/*3*/], float viewMatrix[/*16*/]);
+	B3_SHARED_API void b3ComputeViewMatrixFromYawPitchRoll(const float cameraTargetPosition[/*3*/], float distance, float yaw, float pitch, float roll, int upAxis, float viewMatrix[/*16*/]);
+	B3_SHARED_API void b3ComputePositionFromViewMatrix(const float viewMatrix[/*16*/], float cameraPosition[/*3*/], float cameraTargetPosition[/*3*/], float cameraUp[/*3*/]);
+
+	///compute a projection matrix, helper function for b3RequestCameraImageSetCameraMatrices
+	B3_SHARED_API void b3ComputeProjectionMatrix(float left, float right, float bottom, float top, float nearVal, float farVal, float projectionMatrix[/*16*/]);
+	B3_SHARED_API void b3ComputeProjectionMatrixFOV(float fov, float aspect, float nearVal, float farVal, float projectionMatrix[/*16*/]);
+
+	/* obsolete, please use b3ComputeViewProjectionMatrices */
+	B3_SHARED_API void b3RequestCameraImageSetViewMatrix(b3SharedMemoryCommandHandle commandHandle, const float cameraPosition[/*3*/], const float cameraTargetPosition[/*3*/], const float cameraUp[/*3*/]);
+	/* obsolete, please use b3ComputeViewProjectionMatrices */
+	B3_SHARED_API void b3RequestCameraImageSetViewMatrix2(b3SharedMemoryCommandHandle commandHandle, const float cameraTargetPosition[/*3*/], float distance, float yaw, float pitch, float roll, int upAxis);
+	/* obsolete, please use b3ComputeViewProjectionMatrices */
+	B3_SHARED_API void b3RequestCameraImageSetProjectionMatrix(b3SharedMemoryCommandHandle commandHandle, float left, float right, float bottom, float top, float nearVal, float farVal);
+	/* obsolete, please use b3ComputeViewProjectionMatrices */
+	B3_SHARED_API void b3RequestCameraImageSetFOVProjectionMatrix(b3SharedMemoryCommandHandle commandHandle, float fov, float aspect, float nearVal, float farVal);
+
+	///request an contact point information
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitRequestContactPointInformation(b3PhysicsClientHandle physClient);
+	B3_SHARED_API void b3SetContactFilterBodyA(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueIdA);
+	B3_SHARED_API void b3SetContactFilterBodyB(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueIdB);
+	B3_SHARED_API void b3SetContactFilterLinkA(b3SharedMemoryCommandHandle commandHandle, int linkIndexA);
+	B3_SHARED_API void b3SetContactFilterLinkB(b3SharedMemoryCommandHandle commandHandle, int linkIndexB);
+	B3_SHARED_API void b3GetContactPointInformation(b3PhysicsClientHandle physClient, struct b3ContactInformation* contactPointData);
+
+	///compute the closest points between two bodies
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitClosestDistanceQuery(b3PhysicsClientHandle physClient);
+	B3_SHARED_API void b3SetClosestDistanceFilterBodyA(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueIdA);
+	B3_SHARED_API void b3SetClosestDistanceFilterLinkA(b3SharedMemoryCommandHandle commandHandle, int linkIndexA);
+	B3_SHARED_API void b3SetClosestDistanceFilterBodyB(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueIdB);
+	B3_SHARED_API void b3SetClosestDistanceFilterLinkB(b3SharedMemoryCommandHandle commandHandle, int linkIndexB);
+	B3_SHARED_API void b3SetClosestDistanceThreshold(b3SharedMemoryCommandHandle commandHandle, double distance);
+
+	B3_SHARED_API void b3SetClosestDistanceFilterCollisionShapeA(b3SharedMemoryCommandHandle commandHandle, int collisionShapeA);
+	B3_SHARED_API void b3SetClosestDistanceFilterCollisionShapeB(b3SharedMemoryCommandHandle commandHandle, int collisionShapeB);
+	B3_SHARED_API void b3SetClosestDistanceFilterCollisionShapePositionA(b3SharedMemoryCommandHandle commandHandle, const double collisionShapePositionA[/*3*/]);
+	B3_SHARED_API void b3SetClosestDistanceFilterCollisionShapePositionB(b3SharedMemoryCommandHandle commandHandle, const double collisionShapePositionB[/*3*/]);
+	B3_SHARED_API void b3SetClosestDistanceFilterCollisionShapeOrientationA(b3SharedMemoryCommandHandle commandHandle, const double collisionShapeOrientationA[/*4*/]);
+	B3_SHARED_API void b3SetClosestDistanceFilterCollisionShapeOrientationB(b3SharedMemoryCommandHandle commandHandle, const double collisionShapeOrientationB[/*4*/]);
+
+	B3_SHARED_API void b3GetClosestPointInformation(b3PhysicsClientHandle physClient, struct b3ContactInformation* contactPointInfo);
+
+	///get all the bodies that touch a given axis aligned bounding box specified in world space (min and max coordinates)
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitAABBOverlapQuery(b3PhysicsClientHandle physClient, const double aabbMin[/*3*/], const double aabbMax[/*3*/]);
+	B3_SHARED_API void b3GetAABBOverlapResults(b3PhysicsClientHandle physClient, struct b3AABBOverlapData* data);
+
+	//request visual shape information
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitRequestVisualShapeInformation(b3PhysicsClientHandle physClient, int bodyUniqueIdA);
+	B3_SHARED_API void b3GetVisualShapeInformation(b3PhysicsClientHandle physClient, struct b3VisualShapeInformation* visualShapeInfo);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitRequestCollisionShapeInformation(b3PhysicsClientHandle physClient, int bodyUniqueId, int linkIndex);
+	B3_SHARED_API void b3GetCollisionShapeInformation(b3PhysicsClientHandle physClient, struct b3CollisionShapeInformation* collisionShapeInfo);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitLoadTexture(b3PhysicsClientHandle physClient, const char* filename);
+	B3_SHARED_API int b3GetStatusTextureUniqueId(b3SharedMemoryStatusHandle statusHandle);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3CreateChangeTextureCommandInit(b3PhysicsClientHandle physClient, int textureUniqueId, int width, int height, const char* rgbPixels);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitUpdateVisualShape(b3PhysicsClientHandle physClient, int bodyUniqueId, int jointIndex, int shapeIndex, int textureUniqueId);
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitUpdateVisualShape2(b3PhysicsClientHandle physClient, int bodyUniqueId, int jointIndex, int shapeIndex);
+	B3_SHARED_API void b3UpdateVisualShapeTexture(b3SharedMemoryCommandHandle commandHandle, int textureUniqueId);
+	B3_SHARED_API void b3UpdateVisualShapeRGBAColor(b3SharedMemoryCommandHandle commandHandle, const double rgbaColor[/*4*/]);
+	B3_SHARED_API void b3UpdateVisualShapeFlags(b3SharedMemoryCommandHandle commandHandle, int flags);
+	
+	B3_SHARED_API void b3UpdateVisualShapeSpecularColor(b3SharedMemoryCommandHandle commandHandle, const double specularColor[/*3*/]);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitPhysicsParamCommand(b3PhysicsClientHandle physClient);
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitPhysicsParamCommand2(b3SharedMemoryCommandHandle commandHandle);
+	B3_SHARED_API int b3PhysicsParamSetGravity(b3SharedMemoryCommandHandle commandHandle, double gravx, double gravy, double gravz);
+	B3_SHARED_API int b3PhysicsParamSetTimeStep(b3SharedMemoryCommandHandle commandHandle, double timeStep);
+	B3_SHARED_API int b3PhysicsParamSetDefaultContactERP(b3SharedMemoryCommandHandle commandHandle, double defaultContactERP);
+	B3_SHARED_API int b3PhysicsParamSetDefaultNonContactERP(b3SharedMemoryCommandHandle commandHandle, double defaultNonContactERP);
+	B3_SHARED_API int b3PhysicsParamSetDefaultFrictionERP(b3SharedMemoryCommandHandle commandHandle, double frictionERP);
+	B3_SHARED_API int b3PhysicsParamSetDefaultGlobalCFM(b3SharedMemoryCommandHandle commandHandle, double defaultGlobalCFM);
+	B3_SHARED_API int b3PhysicsParamSetDefaultFrictionCFM(b3SharedMemoryCommandHandle commandHandle, double frictionCFM);
+	B3_SHARED_API int b3PhysicsParamSetNumSubSteps(b3SharedMemoryCommandHandle commandHandle, int numSubSteps);
+	B3_SHARED_API int b3PhysicsParamSetRealTimeSimulation(b3SharedMemoryCommandHandle commandHandle, int enableRealTimeSimulation);
+	B3_SHARED_API int b3PhysicsParamSetNumSolverIterations(b3SharedMemoryCommandHandle commandHandle, int numSolverIterations);
+	B3_SHARED_API int b3PhysicsParamSetNumNonContactInnerIterations(b3SharedMemoryCommandHandle commandHandle, int numMotorIterations);
+	B3_SHARED_API int b3PhysicsParamSetWarmStartingFactor(b3SharedMemoryCommandHandle commandHandle, double warmStartingFactor);
+	B3_SHARED_API int b3PhysicsParamSetArticulatedWarmStartingFactor(b3SharedMemoryCommandHandle commandHandle, double warmStartingFactor);
+	B3_SHARED_API int b3PhysicsParamSetCollisionFilterMode(b3SharedMemoryCommandHandle commandHandle, int filterMode);
+	B3_SHARED_API int b3PhysicsParamSetUseSplitImpulse(b3SharedMemoryCommandHandle commandHandle, int useSplitImpulse);
+	B3_SHARED_API int b3PhysicsParamSetSplitImpulsePenetrationThreshold(b3SharedMemoryCommandHandle commandHandle, double splitImpulsePenetrationThreshold);
+	B3_SHARED_API int b3PhysicsParamSetContactBreakingThreshold(b3SharedMemoryCommandHandle commandHandle, double contactBreakingThreshold);
+	B3_SHARED_API int b3PhysicsParamSetMaxNumCommandsPer1ms(b3SharedMemoryCommandHandle commandHandle, int maxNumCmdPer1ms);
+	B3_SHARED_API int b3PhysicsParamSetEnableFileCaching(b3SharedMemoryCommandHandle commandHandle, int enableFileCaching);
+	B3_SHARED_API int b3PhysicsParamSetRestitutionVelocityThreshold(b3SharedMemoryCommandHandle commandHandle, double restitutionVelocityThreshold);
+	B3_SHARED_API int b3PhysicsParamSetEnableConeFriction(b3SharedMemoryCommandHandle commandHandle, int enableConeFriction);
+	B3_SHARED_API int b3PhysicsParameterSetDeterministicOverlappingPairs(b3SharedMemoryCommandHandle commandHandle, int deterministicOverlappingPairs);
+	B3_SHARED_API int b3PhysicsParameterSetAllowedCcdPenetration(b3SharedMemoryCommandHandle commandHandle, double allowedCcdPenetration);
+	B3_SHARED_API int b3PhysicsParameterSetJointFeedbackMode(b3SharedMemoryCommandHandle commandHandle, int jointFeedbackMode);
+	B3_SHARED_API int b3PhysicsParamSetSolverResidualThreshold(b3SharedMemoryCommandHandle commandHandle, double solverResidualThreshold);
+	B3_SHARED_API int b3PhysicsParamSetContactSlop(b3SharedMemoryCommandHandle commandHandle, double contactSlop);
+	B3_SHARED_API int b3PhysicsParameterSetEnableSAT(b3SharedMemoryCommandHandle commandHandle, int enableSAT);
+	B3_SHARED_API int b3PhysicsParameterSetConstraintSolverType(b3SharedMemoryCommandHandle commandHandle, int constraintSolverType);
+	B3_SHARED_API int b3PhysicsParameterSetMinimumSolverIslandSize(b3SharedMemoryCommandHandle commandHandle, int minimumSolverIslandSize);
+	B3_SHARED_API int b3PhysicsParamSetSolverAnalytics(b3SharedMemoryCommandHandle commandHandle, int reportSolverAnalytics);
+	B3_SHARED_API int b3PhysicsParameterSetSparseSdfVoxelSize(b3SharedMemoryCommandHandle commandHandle, double sparseSdfVoxelSize);
+	                  
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitRequestPhysicsParamCommand(b3PhysicsClientHandle physClient);
+	B3_SHARED_API int b3GetStatusPhysicsSimulationParameters(b3SharedMemoryStatusHandle statusHandle, struct b3PhysicsSimulationParameters* params);
+
+	//b3PhysicsParamSetInternalSimFlags is for internal/temporary/easter-egg/experimental demo purposes
+	//Use at own risk: magic things may or my not happen when calling this API
+	B3_SHARED_API int b3PhysicsParamSetInternalSimFlags(b3SharedMemoryCommandHandle commandHandle, int flags);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitStepSimulationCommand(b3PhysicsClientHandle physClient);
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitStepSimulationCommand2(b3SharedMemoryCommandHandle commandHandle);
+
+	B3_SHARED_API int b3GetStatusForwardDynamicsAnalyticsData(b3SharedMemoryStatusHandle statusHandle, struct b3ForwardDynamicsAnalyticsArgs* analyticsData);
+
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitResetSimulationCommand(b3PhysicsClientHandle physClient);
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitResetSimulationCommand2(b3SharedMemoryCommandHandle commandHandle);
+	B3_SHARED_API int b3InitResetSimulationSetFlags(b3SharedMemoryCommandHandle commandHandle, int flags);
+	///Load a robot from a URDF file. Status type will CMD_URDF_LOADING_COMPLETED.
+	///Access the robot from the unique body index, through b3GetStatusBodyIndex(statusHandle);
+	B3_SHARED_API b3SharedMemoryCommandHandle b3LoadUrdfCommandInit(b3PhysicsClientHandle physClient, const char* urdfFileName);
+	B3_SHARED_API b3SharedMemoryCommandHandle b3LoadUrdfCommandInit2(b3SharedMemoryCommandHandle commandHandle, const char* urdfFileName);
+	B3_SHARED_API int b3LoadUrdfCommandSetStartPosition(b3SharedMemoryCommandHandle commandHandle, double startPosX, double startPosY, double startPosZ);
+	B3_SHARED_API int b3LoadUrdfCommandSetStartOrientation(b3SharedMemoryCommandHandle commandHandle, double startOrnX, double startOrnY, double startOrnZ, double startOrnW);
+	B3_SHARED_API int b3LoadUrdfCommandSetUseMultiBody(b3SharedMemoryCommandHandle commandHandle, int useMultiBody);
+	B3_SHARED_API int b3LoadUrdfCommandSetUseFixedBase(b3SharedMemoryCommandHandle commandHandle, int useFixedBase);
+	B3_SHARED_API int b3LoadUrdfCommandSetFlags(b3SharedMemoryCommandHandle commandHandle, int flags);
+	B3_SHARED_API int b3LoadUrdfCommandSetGlobalScaling(b3SharedMemoryCommandHandle commandHandle, double globalScaling);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3SaveStateCommandInit(b3PhysicsClientHandle physClient);
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitRemoveStateCommand(b3PhysicsClientHandle physClient, int stateId);
+	B3_SHARED_API int b3GetStatusGetStateId(b3SharedMemoryStatusHandle statusHandle);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3LoadStateCommandInit(b3PhysicsClientHandle physClient);
+	B3_SHARED_API int b3LoadStateSetStateId(b3SharedMemoryCommandHandle commandHandle, int stateId);
+	B3_SHARED_API int b3LoadStateSetFileName(b3SharedMemoryCommandHandle commandHandle, const char* fileName);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3LoadBulletCommandInit(b3PhysicsClientHandle physClient, const char* fileName);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3SaveBulletCommandInit(b3PhysicsClientHandle physClient, const char* fileName);
+	B3_SHARED_API b3SharedMemoryCommandHandle b3LoadMJCFCommandInit(b3PhysicsClientHandle physClient, const char* fileName);
+	B3_SHARED_API b3SharedMemoryCommandHandle b3LoadMJCFCommandInit2(b3SharedMemoryCommandHandle commandHandle, const char* fileName);
+	B3_SHARED_API void b3LoadMJCFCommandSetFlags(b3SharedMemoryCommandHandle commandHandle, int flags);
+
+	///compute the forces to achieve an acceleration, given a state q and qdot using inverse dynamics
+	B3_SHARED_API b3SharedMemoryCommandHandle b3CalculateInverseDynamicsCommandInit(b3PhysicsClientHandle physClient, int bodyUniqueId,
+																					const double* jointPositionsQ, const double* jointVelocitiesQdot, const double* jointAccelerations);
+	B3_SHARED_API b3SharedMemoryCommandHandle b3CalculateInverseDynamicsCommandInit2(b3PhysicsClientHandle physClient, int bodyUniqueId,
+		const double* jointPositionsQ, int dofCountQ, const double* jointVelocitiesQdot, const double* jointAccelerations, int dofCountQdot);
+	B3_SHARED_API void b3CalculateInverseDynamicsSetFlags(b3SharedMemoryCommandHandle commandHandle, int flags);
+
+	B3_SHARED_API int b3GetStatusInverseDynamicsJointForces(b3SharedMemoryStatusHandle statusHandle,
+															int* bodyUniqueId,
+															int* dofCount,
+															double* jointForces);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3CalculateJacobianCommandInit(b3PhysicsClientHandle physClient, int bodyUniqueId, int linkIndex, const double* localPosition, const double* jointPositionsQ, const double* jointVelocitiesQdot, const double* jointAccelerations);
+	B3_SHARED_API int b3GetStatusJacobian(b3SharedMemoryStatusHandle statusHandle,
+										  int* dofCount,
+										  double* linearJacobian,
+										  double* angularJacobian);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3CalculateMassMatrixCommandInit(b3PhysicsClientHandle physClient, int bodyUniqueId, const double* jointPositionsQ, int dofCountQ);
+	B3_SHARED_API void b3CalculateMassMatrixSetFlags(b3SharedMemoryCommandHandle commandHandle, int flags);
+	///the mass matrix is stored in column-major layout of size dofCount*dofCount
+	B3_SHARED_API int b3GetStatusMassMatrix(b3PhysicsClientHandle physClient, b3SharedMemoryStatusHandle statusHandle, int* dofCount, double* massMatrix);
+
+	///compute the joint positions to move the end effector to a desired target using inverse kinematics
+	B3_SHARED_API b3SharedMemoryCommandHandle b3CalculateInverseKinematicsCommandInit(b3PhysicsClientHandle physClient, int bodyUniqueId);
+	B3_SHARED_API void b3CalculateInverseKinematicsAddTargetPurePosition(b3SharedMemoryCommandHandle commandHandle, int endEffectorLinkIndex, const double targetPosition[/*3*/]);
+	B3_SHARED_API void b3CalculateInverseKinematicsAddTargetsPurePosition(b3SharedMemoryCommandHandle commandHandle, int numEndEffectorLinkIndices, const int* endEffectorIndices, const double* targetPositions);
+	B3_SHARED_API void b3CalculateInverseKinematicsAddTargetPositionWithOrientation(b3SharedMemoryCommandHandle commandHandle, int endEffectorLinkIndex, const double targetPosition[/*3*/], const double targetOrientation[/*4*/]);
+	B3_SHARED_API void b3CalculateInverseKinematicsPosWithNullSpaceVel(b3SharedMemoryCommandHandle commandHandle, int numDof, int endEffectorLinkIndex, const double targetPosition[/*3*/], const double* lowerLimit, const double* upperLimit, const double* jointRange, const double* restPose);
+	B3_SHARED_API void b3CalculateInverseKinematicsPosOrnWithNullSpaceVel(b3SharedMemoryCommandHandle commandHandle, int numDof, int endEffectorLinkIndex, const double targetPosition[/*3*/], const double targetOrientation[/*4*/], const double* lowerLimit, const double* upperLimit, const double* jointRange, const double* restPose);
+	B3_SHARED_API void b3CalculateInverseKinematicsSetJointDamping(b3SharedMemoryCommandHandle commandHandle, int numDof, const double* jointDampingCoeff);
+	B3_SHARED_API void b3CalculateInverseKinematicsSelectSolver(b3SharedMemoryCommandHandle commandHandle, int solver);
+	B3_SHARED_API int b3GetStatusInverseKinematicsJointPositions(b3SharedMemoryStatusHandle statusHandle,
+																 int* bodyUniqueId,
+																 int* dofCount,
+																 double* jointPositions);
+
+	B3_SHARED_API void b3CalculateInverseKinematicsSetCurrentPositions(b3SharedMemoryCommandHandle commandHandle, int numDof, const double* currentJointPositions);
+	B3_SHARED_API void b3CalculateInverseKinematicsSetMaxNumIterations(b3SharedMemoryCommandHandle commandHandle, int maxNumIterations);
+	B3_SHARED_API void b3CalculateInverseKinematicsSetResidualThreshold(b3SharedMemoryCommandHandle commandHandle, double residualThreshold);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3CollisionFilterCommandInit(b3PhysicsClientHandle physClient);
+	B3_SHARED_API void b3SetCollisionFilterPair(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueIdA,
+												int bodyUniqueIdB, int linkIndexA, int linkIndexB, int enableCollision);
+	B3_SHARED_API void b3SetCollisionFilterGroupMask(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueIdA,
+													 int linkIndexA, int collisionFilterGroup, int collisionFilterMask);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3LoadSdfCommandInit(b3PhysicsClientHandle physClient, const char* sdfFileName);
+	B3_SHARED_API b3SharedMemoryCommandHandle b3LoadSdfCommandInit2(b3SharedMemoryCommandHandle commandHandle, const char* sdfFileName);
+
+	B3_SHARED_API int b3LoadSdfCommandSetUseMultiBody(b3SharedMemoryCommandHandle commandHandle, int useMultiBody);
+	B3_SHARED_API int b3LoadSdfCommandSetUseGlobalScaling(b3SharedMemoryCommandHandle commandHandle, double globalScaling);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3SaveWorldCommandInit(b3PhysicsClientHandle physClient, const char* sdfFileName);
+
+	///The b3JointControlCommandInit method is obsolete, use b3JointControlCommandInit2 instead
+	B3_SHARED_API b3SharedMemoryCommandHandle b3JointControlCommandInit(b3PhysicsClientHandle physClient, int controlMode);
+
+	///Set joint motor control variables such as desired position/angle, desired velocity,
+	///applied joint forces, dependent on the control mode (CONTROL_MODE_VELOCITY or CONTROL_MODE_TORQUE)
+	B3_SHARED_API b3SharedMemoryCommandHandle b3JointControlCommandInit2(b3PhysicsClientHandle physClient, int bodyUniqueId, int controlMode);
+	B3_SHARED_API b3SharedMemoryCommandHandle b3JointControlCommandInit2Internal(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueId, int controlMode);
+
+	///Only use when controlMode is CONTROL_MODE_POSITION_VELOCITY_PD
+	B3_SHARED_API int b3JointControlSetDesiredPosition(b3SharedMemoryCommandHandle commandHandle, int qIndex, double value);
+	B3_SHARED_API int b3JointControlSetDesiredPositionMultiDof(b3SharedMemoryCommandHandle commandHandle, int qIndex, const double* position, int dofCount);
+
+	B3_SHARED_API int b3JointControlSetKp(b3SharedMemoryCommandHandle commandHandle, int dofIndex, double value);
+	B3_SHARED_API int b3JointControlSetKd(b3SharedMemoryCommandHandle commandHandle, int dofIndex, double value);
+	B3_SHARED_API int b3JointControlSetMaximumVelocity(b3SharedMemoryCommandHandle commandHandle, int dofIndex, double maximumVelocity);
+
+	///Only use when controlMode is CONTROL_MODE_VELOCITY
+	B3_SHARED_API int b3JointControlSetDesiredVelocity(b3SharedMemoryCommandHandle commandHandle, int dofIndex, double value); /* find a better name for dof/q/u indices, point to b3JointInfo */
+	B3_SHARED_API int b3JointControlSetDesiredVelocityMultiDof(b3SharedMemoryCommandHandle commandHandle, int dofIndex, const double* velocity, int dofCount);
+	B3_SHARED_API int b3JointControlSetDesiredVelocityMultiDof2(b3SharedMemoryCommandHandle commandHandle, int dofIndex, const double* velocity, int dofCount);
+
+	B3_SHARED_API int b3JointControlSetMaximumForce(b3SharedMemoryCommandHandle commandHandle, int dofIndex, double value);
+	B3_SHARED_API int b3JointControlSetDesiredForceTorqueMultiDof(b3SharedMemoryCommandHandle commandHandle, int dofIndex, double* forces, int dofCount);
+	
+	///Only use if when controlMode is CONTROL_MODE_TORQUE,
+	B3_SHARED_API int b3JointControlSetDesiredForceTorque(b3SharedMemoryCommandHandle commandHandle, int dofIndex, double value);
+
+	///the creation of collision shapes and rigid bodies etc is likely going to change,
+	///but good to have a b3CreateBoxShapeCommandInit for now
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3CreateCollisionShapeCommandInit(b3PhysicsClientHandle physClient);
+	B3_SHARED_API int b3CreateCollisionShapeAddSphere(b3SharedMemoryCommandHandle commandHandle, double radius);
+	B3_SHARED_API int b3CreateCollisionShapeAddBox(b3SharedMemoryCommandHandle commandHandle, const double halfExtents[/*3*/]);
+	B3_SHARED_API int b3CreateCollisionShapeAddCapsule(b3SharedMemoryCommandHandle commandHandle, double radius, double height);
+	B3_SHARED_API int b3CreateCollisionShapeAddCylinder(b3SharedMemoryCommandHandle commandHandle, double radius, double height);
+	B3_SHARED_API int b3CreateCollisionShapeAddHeightfield(b3SharedMemoryCommandHandle commandHandle, const char* fileName, const double meshScale[/*3*/], double textureScaling);
+	B3_SHARED_API int b3CreateCollisionShapeAddHeightfield2(b3PhysicsClientHandle physClient, b3SharedMemoryCommandHandle commandHandle, const double meshScale[/*3*/], double textureScaling, float* heightfieldData, int numHeightfieldRows, int numHeightfieldColumns, int replaceHeightfieldIndex);
+	
+	B3_SHARED_API int b3CreateCollisionShapeAddPlane(b3SharedMemoryCommandHandle commandHandle, const double planeNormal[/*3*/], double planeConstant);
+	B3_SHARED_API int b3CreateCollisionShapeAddMesh(b3SharedMemoryCommandHandle commandHandle, const char* fileName, const double meshScale[/*3*/]);
+	B3_SHARED_API int b3CreateCollisionShapeAddConvexMesh(b3PhysicsClientHandle physClient, b3SharedMemoryCommandHandle commandHandle, const double meshScale[/*3*/], const double* vertices, int numVertices);
+	B3_SHARED_API int b3CreateCollisionShapeAddConcaveMesh(b3PhysicsClientHandle physClient, b3SharedMemoryCommandHandle commandHandle, const double meshScale[/*3*/], const double* vertices, int numVertices, const int* indices, int numIndices);
+	B3_SHARED_API void b3CreateCollisionSetFlag(b3SharedMemoryCommandHandle commandHandle, int shapeIndex, int flags);
+	B3_SHARED_API void b3CreateCollisionShapeSetChildTransform(b3SharedMemoryCommandHandle commandHandle, int shapeIndex, const double childPosition[/*3*/], const double childOrientation[/*4*/]);
+	B3_SHARED_API int b3GetStatusCollisionShapeUniqueId(b3SharedMemoryStatusHandle statusHandle);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitRemoveCollisionShapeCommand(b3PhysicsClientHandle physClient, int collisionShapeId);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3GetMeshDataCommandInit(b3PhysicsClientHandle physClient, int bodyUniqueId, int linkIndex);
+	B3_SHARED_API void b3GetMeshDataSetCollisionShapeIndex(b3SharedMemoryCommandHandle commandHandle, int shapeIndex);
+	B3_SHARED_API void b3GetMeshDataSetFlags(b3SharedMemoryCommandHandle commandHandle, int flags);
+	
+	B3_SHARED_API void b3GetMeshData(b3PhysicsClientHandle physClient, struct b3MeshData* meshData);
+
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3CreateVisualShapeCommandInit(b3PhysicsClientHandle physClient);
+	B3_SHARED_API int b3CreateVisualShapeAddSphere(b3SharedMemoryCommandHandle commandHandle, double radius);
+	B3_SHARED_API int b3CreateVisualShapeAddBox(b3SharedMemoryCommandHandle commandHandle, const double halfExtents[/*3*/]);
+	B3_SHARED_API int b3CreateVisualShapeAddCapsule(b3SharedMemoryCommandHandle commandHandle, double radius, double height);
+	B3_SHARED_API int b3CreateVisualShapeAddCylinder(b3SharedMemoryCommandHandle commandHandle, double radius, double height);
+	B3_SHARED_API int b3CreateVisualShapeAddPlane(b3SharedMemoryCommandHandle commandHandle, const double planeNormal[/*3*/], double planeConstant);
+	B3_SHARED_API int b3CreateVisualShapeAddMesh(b3SharedMemoryCommandHandle commandHandle, const char* fileName, const double meshScale[/*3*/]);
+	B3_SHARED_API int b3CreateVisualShapeAddMesh2(b3PhysicsClientHandle physClient, b3SharedMemoryCommandHandle commandHandle, const double meshScale[/*3*/], const double* vertices, int numVertices, const int* indices, int numIndices, const double* normals, int numNormals, const double* uvs, int numUVs);
+
+
+	B3_SHARED_API void b3CreateVisualSetFlag(b3SharedMemoryCommandHandle commandHandle, int shapeIndex, int flags);
+	B3_SHARED_API void b3CreateVisualShapeSetChildTransform(b3SharedMemoryCommandHandle commandHandle, int shapeIndex, const double childPosition[/*3*/], const double childOrientation[/*4*/]);
+	B3_SHARED_API void b3CreateVisualShapeSetSpecularColor(b3SharedMemoryCommandHandle commandHandle, int shapeIndex, const double specularColor[/*3*/]);
+	B3_SHARED_API void b3CreateVisualShapeSetRGBAColor(b3SharedMemoryCommandHandle commandHandle, int shapeIndex, const double rgbaColor[/*4*/]);
+
+	B3_SHARED_API int b3GetStatusVisualShapeUniqueId(b3SharedMemoryStatusHandle statusHandle);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3CreateMultiBodyCommandInit(b3PhysicsClientHandle physClient);
+	B3_SHARED_API int b3CreateMultiBodyBase(b3SharedMemoryCommandHandle commandHandle, double mass, int collisionShapeUnique, int visualShapeUniqueId, const double basePosition[/*3*/], const double baseOrientation[/*4*/], const double baseInertialFramePosition[/*3*/], const double baseInertialFrameOrientation[/*4*/]);
+
+	B3_SHARED_API int b3CreateMultiBodyLink(b3SharedMemoryCommandHandle commandHandle, double linkMass, double linkCollisionShapeIndex,
+											double linkVisualShapeIndex,
+											const double linkPosition[/*3*/],
+											const double linkOrientation[/*4*/],
+											const double linkInertialFramePosition[/*3*/],
+											const double linkInertialFrameOrientation[/*4*/],
+											int linkParentIndex,
+											int linkJointType,
+											const double linkJointAxis[/*3*/]);
+
+	//batch creation is an performance feature to create a large number of multi bodies in one command
+	B3_SHARED_API int b3CreateMultiBodySetBatchPositions(b3PhysicsClientHandle physClient, b3SharedMemoryCommandHandle commandHandle, double* batchPositions, int numBatchObjects);
+
+	//useMaximalCoordinates are disabled by default, enabling them is experimental and not fully supported yet
+	B3_SHARED_API void b3CreateMultiBodyUseMaximalCoordinates(b3SharedMemoryCommandHandle commandHandle);
+	B3_SHARED_API void b3CreateMultiBodySetFlags(b3SharedMemoryCommandHandle commandHandle, int flags);
+
+	//int b3CreateMultiBodyAddLink(b3SharedMemoryCommandHandle commandHandle, int jointType, int parentLinkIndex, double linkMass, int linkCollisionShapeUnique, int linkVisualShapeUniqueId);
+
+	///create a box of size (1,1,1) at world origin (0,0,0) at orientation quat (0,0,0,1)
+	///after that, you can optionally adjust the initial position, orientation and size
+	B3_SHARED_API b3SharedMemoryCommandHandle b3CreateBoxShapeCommandInit(b3PhysicsClientHandle physClient);
+	B3_SHARED_API int b3CreateBoxCommandSetStartPosition(b3SharedMemoryCommandHandle commandHandle, double startPosX, double startPosY, double startPosZ);
+	B3_SHARED_API int b3CreateBoxCommandSetStartOrientation(b3SharedMemoryCommandHandle commandHandle, double startOrnX, double startOrnY, double startOrnZ, double startOrnW);
+	B3_SHARED_API int b3CreateBoxCommandSetHalfExtents(b3SharedMemoryCommandHandle commandHandle, double halfExtentsX, double halfExtentsY, double halfExtentsZ);
+	B3_SHARED_API int b3CreateBoxCommandSetMass(b3SharedMemoryCommandHandle commandHandle, double mass);
+	B3_SHARED_API int b3CreateBoxCommandSetCollisionShapeType(b3SharedMemoryCommandHandle commandHandle, int collisionShapeType);
+	B3_SHARED_API int b3CreateBoxCommandSetColorRGBA(b3SharedMemoryCommandHandle commandHandle, double red, double green, double blue, double alpha);
+
+	///b3CreatePoseCommandInit will initialize (teleport) the pose of a body/robot. You can individually set the base position,
+	///base orientation and joint angles. This will set all velocities of base and joints to zero.
+	///This is not a robot control command using actuators/joint motors, but manual repositioning the robot.
+	B3_SHARED_API b3SharedMemoryCommandHandle b3CreatePoseCommandInit(b3PhysicsClientHandle physClient, int bodyUniqueId);
+	B3_SHARED_API b3SharedMemoryCommandHandle b3CreatePoseCommandInit2(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueId);
+
+	B3_SHARED_API int b3CreatePoseCommandSetBasePosition(b3SharedMemoryCommandHandle commandHandle, double startPosX, double startPosY, double startPosZ);
+	B3_SHARED_API int b3CreatePoseCommandSetBaseOrientation(b3SharedMemoryCommandHandle commandHandle, double startOrnX, double startOrnY, double startOrnZ, double startOrnW);
+	B3_SHARED_API int b3CreatePoseCommandSetBaseLinearVelocity(b3SharedMemoryCommandHandle commandHandle, const double linVel[/*3*/]);
+	B3_SHARED_API int b3CreatePoseCommandSetBaseAngularVelocity(b3SharedMemoryCommandHandle commandHandle, const double angVel[/*3*/]);
+	B3_SHARED_API int b3CreatePoseCommandSetBaseScaling(b3SharedMemoryCommandHandle commandHandle, double scaling[/* 3*/]);
+
+
+	B3_SHARED_API int b3CreatePoseCommandSetJointPositions(b3SharedMemoryCommandHandle commandHandle, int numJointPositions, const double* jointPositions);
+	B3_SHARED_API int b3CreatePoseCommandSetJointPosition(b3PhysicsClientHandle physClient, b3SharedMemoryCommandHandle commandHandle, int jointIndex, double jointPosition);
+	B3_SHARED_API int b3CreatePoseCommandSetJointPositionMultiDof(b3PhysicsClientHandle physClient, b3SharedMemoryCommandHandle commandHandle, int jointIndex, const double* jointPosition, int posSize);
+
+	B3_SHARED_API int b3CreatePoseCommandSetQ(b3SharedMemoryCommandHandle commandHandle, int numJointPositions, const double* q, const int* hasQ);
+	B3_SHARED_API int b3CreatePoseCommandSetQdots(b3SharedMemoryCommandHandle commandHandle, int numJointVelocities, const double* qDots, const int* hasQdots);
+
+	B3_SHARED_API int b3CreatePoseCommandSetJointVelocities(b3PhysicsClientHandle physClient, b3SharedMemoryCommandHandle commandHandle, int numJointVelocities, const double* jointVelocities);
+	B3_SHARED_API int b3CreatePoseCommandSetJointVelocity(b3PhysicsClientHandle physClient, b3SharedMemoryCommandHandle commandHandle, int jointIndex, double jointVelocity);
+	B3_SHARED_API int b3CreatePoseCommandSetJointVelocityMultiDof(b3PhysicsClientHandle physClient, b3SharedMemoryCommandHandle commandHandle, int jointIndex, const double* jointVelocity, int velSize);
+	
+	///We are currently not reading the sensor information from the URDF file, and programmatically assign sensors.
+	///This is rather inconsistent, to mix programmatical creation with loading from file.
+	B3_SHARED_API b3SharedMemoryCommandHandle b3CreateSensorCommandInit(b3PhysicsClientHandle physClient, int bodyUniqueId);
+	B3_SHARED_API int b3CreateSensorEnable6DofJointForceTorqueSensor(b3SharedMemoryCommandHandle commandHandle, int jointIndex, int enable);
+	///b3CreateSensorEnableIMUForLink is not implemented yet.
+	///For now, if the IMU is located in the root link, use the root world transform to mimic an IMU.
+	B3_SHARED_API int b3CreateSensorEnableIMUForLink(b3SharedMemoryCommandHandle commandHandle, int linkIndex, int enable);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3RequestActualStateCommandInit(b3PhysicsClientHandle physClient, int bodyUniqueId);
+	B3_SHARED_API b3SharedMemoryCommandHandle b3RequestActualStateCommandInit2(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueId);
+
+	B3_SHARED_API int b3RequestActualStateCommandComputeLinkVelocity(b3SharedMemoryCommandHandle commandHandle, int computeLinkVelocity);
+	B3_SHARED_API int b3RequestActualStateCommandComputeForwardKinematics(b3SharedMemoryCommandHandle commandHandle, int computeForwardKinematics);
+
+	B3_SHARED_API int b3GetJointState(b3PhysicsClientHandle physClient, b3SharedMemoryStatusHandle statusHandle, int jointIndex, struct b3JointSensorState* state);
+	B3_SHARED_API int b3GetJointStateMultiDof(b3PhysicsClientHandle physClient, b3SharedMemoryStatusHandle statusHandle, int jointIndex, struct b3JointSensorState2* state);
+	B3_SHARED_API int b3GetLinkState(b3PhysicsClientHandle physClient, b3SharedMemoryStatusHandle statusHandle, int linkIndex, struct b3LinkState* state);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3PickBody(b3PhysicsClientHandle physClient, double rayFromWorldX,
+														 double rayFromWorldY, double rayFromWorldZ,
+														 double rayToWorldX, double rayToWorldY, double rayToWorldZ);
+	B3_SHARED_API b3SharedMemoryCommandHandle b3MovePickedBody(b3PhysicsClientHandle physClient, double rayFromWorldX,
+															   double rayFromWorldY, double rayFromWorldZ,
+															   double rayToWorldX, double rayToWorldY,
+															   double rayToWorldZ);
+	B3_SHARED_API b3SharedMemoryCommandHandle b3RemovePickingConstraint(b3PhysicsClientHandle physClient);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3CreateRaycastCommandInit(b3PhysicsClientHandle physClient, double rayFromWorldX,
+																		 double rayFromWorldY, double rayFromWorldZ,
+																		 double rayToWorldX, double rayToWorldY, double rayToWorldZ);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3CreateRaycastBatchCommandInit(b3PhysicsClientHandle physClient);
+	// Sets the number of threads to use to compute the ray intersections for the batch. Specify 0 to let Bullet decide, 1 (default) for single core execution, 2 or more to select the number of threads to use.
+	B3_SHARED_API void b3RaycastBatchSetNumThreads(b3SharedMemoryCommandHandle commandHandle, int numThreads);
+	//max num rays for b3RaycastBatchAddRay is MAX_RAY_INTERSECTION_BATCH_SIZE
+	B3_SHARED_API void b3RaycastBatchAddRay(b3SharedMemoryCommandHandle commandHandle, const double rayFromWorld[/*3*/], const double rayToWorld[/*3*/]);
+	//max num rays for b3RaycastBatchAddRays is MAX_RAY_INTERSECTION_BATCH_SIZE_STREAMING
+	B3_SHARED_API void b3RaycastBatchAddRays(b3PhysicsClientHandle physClient, b3SharedMemoryCommandHandle commandHandle, const double* rayFromWorld, const double* rayToWorld, int numRays);
+	B3_SHARED_API void b3RaycastBatchSetParentObject(b3SharedMemoryCommandHandle commandHandle, int parentObjectUniqueId, int parentLinkIndex);
+	B3_SHARED_API void b3RaycastBatchSetReportHitNumber(b3SharedMemoryCommandHandle commandHandle, int reportHitNumber);
+	B3_SHARED_API void b3RaycastBatchSetCollisionFilterMask(b3SharedMemoryCommandHandle commandHandle, int collisionFilterMask);
+	B3_SHARED_API void b3RaycastBatchSetFractionEpsilon(b3SharedMemoryCommandHandle commandHandle, double fractionEpsilon);
+	
+	B3_SHARED_API void b3GetRaycastInformation(b3PhysicsClientHandle physClient, struct b3RaycastInformation* raycastInfo);
+
+	/// Apply external force at the body (or link) center of mass, in world space/Cartesian coordinates.
+	B3_SHARED_API b3SharedMemoryCommandHandle b3ApplyExternalForceCommandInit(b3PhysicsClientHandle physClient);
+	B3_SHARED_API void b3ApplyExternalForce(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueId, int linkId, const double force[/*3*/], const double position[/*3*/], int flag);
+	B3_SHARED_API void b3ApplyExternalTorque(b3SharedMemoryCommandHandle commandHandle, int bodyUniqueId, int linkId, const double torque[/*3*/], int flag);
+
+	///experiments of robots interacting with non-rigid objects (such as btSoftBody)
+	B3_SHARED_API b3SharedMemoryCommandHandle b3LoadSoftBodyCommandInit(b3PhysicsClientHandle physClient, const char* fileName);
+	B3_SHARED_API int b3LoadSoftBodySetScale(b3SharedMemoryCommandHandle commandHandle, double scale);
+	B3_SHARED_API int b3LoadSoftBodySetMass(b3SharedMemoryCommandHandle commandHandle, double mass);
+	B3_SHARED_API int b3LoadSoftBodySetCollisionMargin(b3SharedMemoryCommandHandle commandHandle, double collisionMargin);
+	B3_SHARED_API int b3LoadSoftBodySetStartPosition(b3SharedMemoryCommandHandle commandHandle, double startPosX, double startPosY, double startPosZ);
+	B3_SHARED_API int b3LoadSoftBodySetStartOrientation(b3SharedMemoryCommandHandle commandHandle, double startOrnX, double startOrnY, double startOrnZ, double startOrnW);
+    B3_SHARED_API int b3LoadSoftBodyUpdateSimMesh(b3SharedMemoryCommandHandle commandHandle, const char* filename);
+	B3_SHARED_API int b3LoadSoftBodyAddCorotatedForce(b3SharedMemoryCommandHandle commandHandle, double corotatedMu, double corotatedLambda);
+    B3_SHARED_API int b3LoadSoftBodyAddCorotatedForce(b3SharedMemoryCommandHandle commandHandle, double corotatedMu, double corotatedLambda);
+	B3_SHARED_API int b3LoadSoftBodyAddNeoHookeanForce(b3SharedMemoryCommandHandle commandHandle, double NeoHookeanMu, double NeoHookeanLambda, double NeoHookeanDamping);
+	B3_SHARED_API int b3LoadSoftBodyAddMassSpringForce(b3SharedMemoryCommandHandle commandHandle, double springElasticStiffness , double springDampingStiffness);
+	B3_SHARED_API int b3LoadSoftBodyAddGravityForce(b3SharedMemoryCommandHandle commandHandle, double gravityX, double gravityY, double gravityZ);
+	B3_SHARED_API int b3LoadSoftBodySetCollisionHardness(b3SharedMemoryCommandHandle commandHandle, double collisionHardness);
+	B3_SHARED_API int b3LoadSoftBodySetSelfCollision(b3SharedMemoryCommandHandle commandHandle, int useSelfCollision);
+	B3_SHARED_API int b3LoadSoftBodySetRepulsionStiffness(b3SharedMemoryCommandHandle commandHandle, double stiffness);
+	B3_SHARED_API int b3LoadSoftBodyUseFaceContact(b3SharedMemoryCommandHandle commandHandle, int useFaceContact);
+	B3_SHARED_API int b3LoadSoftBodySetFrictionCoefficient(b3SharedMemoryCommandHandle commandHandle, double frictionCoefficient);
+	B3_SHARED_API int b3LoadSoftBodyUseBendingSprings(b3SharedMemoryCommandHandle commandHandle, int useBendingSprings, double bendingStiffness);
+    B3_SHARED_API int b3LoadSoftBodyUseAllDirectionDampingSprings(b3SharedMemoryCommandHandle commandHandle, int useAllDirectionDamping);
+	
+	B3_SHARED_API b3SharedMemoryCommandHandle b3InitCreateSoftBodyAnchorConstraintCommand(b3PhysicsClientHandle physClient, int softBodyUniqueId, int nodeIndex, int bodyUniqueId, int linkIndex, const double bodyFramePosition[3]);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3RequestVREventsCommandInit(b3PhysicsClientHandle physClient);
+	B3_SHARED_API void b3VREventsSetDeviceTypeFilter(b3SharedMemoryCommandHandle commandHandle, int deviceTypeFilter);
+
+	B3_SHARED_API void b3GetVREventsData(b3PhysicsClientHandle physClient, struct b3VREventsData* vrEventsData);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3SetVRCameraStateCommandInit(b3PhysicsClientHandle physClient);
+	B3_SHARED_API int b3SetVRCameraRootPosition(b3SharedMemoryCommandHandle commandHandle, const double rootPos[/*3*/]);
+	B3_SHARED_API int b3SetVRCameraRootOrientation(b3SharedMemoryCommandHandle commandHandle, const double rootOrn[/*4*/]);
+	B3_SHARED_API int b3SetVRCameraTrackingObject(b3SharedMemoryCommandHandle commandHandle, int objectUniqueId);
+	B3_SHARED_API int b3SetVRCameraTrackingObjectFlag(b3SharedMemoryCommandHandle commandHandle, int flag);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3RequestKeyboardEventsCommandInit(b3PhysicsClientHandle physClient);
+	B3_SHARED_API b3SharedMemoryCommandHandle b3RequestKeyboardEventsCommandInit2(b3SharedMemoryCommandHandle commandHandle);
+	B3_SHARED_API void b3GetKeyboardEventsData(b3PhysicsClientHandle physClient, struct b3KeyboardEventsData* keyboardEventsData);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3RequestMouseEventsCommandInit(b3PhysicsClientHandle physClient);
+	B3_SHARED_API void b3GetMouseEventsData(b3PhysicsClientHandle physClient, struct b3MouseEventsData* mouseEventsData);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3StateLoggingCommandInit(b3PhysicsClientHandle physClient);
+	B3_SHARED_API int b3StateLoggingStart(b3SharedMemoryCommandHandle commandHandle, int loggingType, const char* fileName);
+	B3_SHARED_API int b3StateLoggingAddLoggingObjectUniqueId(b3SharedMemoryCommandHandle commandHandle, int objectUniqueId);
+	B3_SHARED_API int b3StateLoggingSetMaxLogDof(b3SharedMemoryCommandHandle commandHandle, int maxLogDof);
+	B3_SHARED_API int b3StateLoggingSetLinkIndexA(b3SharedMemoryCommandHandle commandHandle, int linkIndexA);
+	B3_SHARED_API int b3StateLoggingSetLinkIndexB(b3SharedMemoryCommandHandle commandHandle, int linkIndexB);
+	B3_SHARED_API int b3StateLoggingSetBodyAUniqueId(b3SharedMemoryCommandHandle commandHandle, int bodyAUniqueId);
+	B3_SHARED_API int b3StateLoggingSetBodyBUniqueId(b3SharedMemoryCommandHandle commandHandle, int bodyBUniqueId);
+	B3_SHARED_API int b3StateLoggingSetDeviceTypeFilter(b3SharedMemoryCommandHandle commandHandle, int deviceTypeFilter);
+	B3_SHARED_API int b3StateLoggingSetLogFlags(b3SharedMemoryCommandHandle commandHandle, int logFlags);
+
+	B3_SHARED_API int b3GetStatusLoggingUniqueId(b3SharedMemoryStatusHandle statusHandle);
+	B3_SHARED_API int b3StateLoggingStop(b3SharedMemoryCommandHandle commandHandle, int loggingUid);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3ProfileTimingCommandInit(b3PhysicsClientHandle physClient, const char* name);
+	B3_SHARED_API void b3SetProfileTimingDuractionInMicroSeconds(b3SharedMemoryCommandHandle commandHandle, int duration);
+	B3_SHARED_API void b3SetProfileTimingType(b3SharedMemoryCommandHandle commandHandle, int type);
+
+	B3_SHARED_API void b3PushProfileTiming(b3PhysicsClientHandle physClient, const char* timingName);
+	B3_SHARED_API void b3PopProfileTiming(b3PhysicsClientHandle physClient);
+
+	B3_SHARED_API void b3SetTimeOut(b3PhysicsClientHandle physClient, double timeOutInSeconds);
+	B3_SHARED_API double b3GetTimeOut(b3PhysicsClientHandle physClient);
+
+	B3_SHARED_API b3SharedMemoryCommandHandle b3SetAdditionalSearchPath(b3PhysicsClientHandle physClient, const char* path);
+
+	B3_SHARED_API void b3MultiplyTransforms(const double posA[/*3*/], const double ornA[/*4*/], const double posB[/*3*/], const double ornB[/*4*/], double outPos[/*3*/], double outOrn[/*4*/]);
+	B3_SHARED_API void b3InvertTransform(const double pos[/*3*/], const double orn[/*4*/], double outPos[/*3*/], double outOrn[/*4*/]);
+	B3_SHARED_API void b3QuaternionSlerp(const double startQuat[/*4*/], const double endQuat[/*4*/], double interpolationFraction, double outOrn[/*4*/]);
+	B3_SHARED_API void b3GetQuaternionFromAxisAngle(const double axis[/*3*/], double angle, double outQuat[/*4*/]);
+	B3_SHARED_API void b3GetAxisAngleFromQuaternion(const double quat[/*4*/], double axis[/*3*/], double* angle);
+	B3_SHARED_API void b3GetQuaternionDifference(const double startQuat[/*4*/], const double endQuat[/*4*/], double outOrn[/*4*/]);
+	B3_SHARED_API void b3GetAxisDifferenceQuaternion(const double startQuat[/*4*/], const double endQuat[/*4*/], double axisOut[/*3*/]);
+	B3_SHARED_API void b3CalculateVelocityQuaternion(const double startQuat[/*4*/], const double endQuat[/*4*/], double deltaTime, double angVelOut[/*3*/]);
+	B3_SHARED_API void b3RotateVector(const double quat[/*4*/], const double vec[/*3*/], double vecOut[/*3*/]);
+
+#ifdef BT_ENABLE_VHACD
+	B3_SHARED_API void b3VHACD(const char* fileNameInput, const char* fileNameOutput, const char* fileNameLogging,
+		double concavity, double alpha, double beta, double gamma, double minVolumePerCH, int resolution,
+		int maxNumVerticesPerCH, int depth, int planeDownsampling, int convexhullDownsampling,
+		int pca, int mode, int convexhullApproximation);
+
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  //PHYSICS_CLIENT_C_API_H
diff --git a/engine/inc/bullet/SharedMemory/PhysicsClientExample.h b/engine/inc/bullet/SharedMemory/PhysicsClientExample.h
new file mode 100644
index 00000000..f1c3dc45
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/PhysicsClientExample.h
@@ -0,0 +1,13 @@
+#ifndef PHYSICS_CLIENT_EXAMPLE_H
+#define PHYSICS_CLIENT_EXAMPLE_H
+
+enum ClientExampleOptions
+{
+	eCLIENTEXAMPLE_LOOPBACK = 1,
+	eCLIENTEXAMPLE_DIRECT = 2,
+	eCLIENTEXAMPLE_SERVER = 3,
+};
+
+class CommonExampleInterface* PhysicsClientCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //PHYSICS_CLIENT_EXAMPLE_H
diff --git a/engine/inc/bullet/SharedMemory/PhysicsClientGRPC.h b/engine/inc/bullet/SharedMemory/PhysicsClientGRPC.h
new file mode 100644
index 00000000..dc78d635
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/PhysicsClientGRPC.h
@@ -0,0 +1,37 @@
+#ifndef PHYSICS_CLIENT_GRPC_H
+#define PHYSICS_CLIENT_GRPC_H
+
+#include "PhysicsDirect.h"
+#include "PhysicsCommandProcessorInterface.h"
+
+class GRPCNetworkedPhysicsProcessor : public PhysicsCommandProcessorInterface
+{
+	struct GRPCNetworkedInternalData* m_data;
+
+public:
+	GRPCNetworkedPhysicsProcessor(const char* hostName, int port);
+
+	virtual ~GRPCNetworkedPhysicsProcessor();
+
+	virtual bool connect();
+
+	virtual void disconnect();
+
+	virtual bool isConnected() const;
+
+	virtual bool processCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+
+	virtual bool receiveStatus(struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+
+	virtual void renderScene(int renderFlags);
+
+	virtual void physicsDebugDraw(int debugDrawFlags);
+
+	virtual void setGuiHelper(struct GUIHelperInterface* guiHelper);
+
+	virtual void setTimeOut(double timeOutInSeconds);
+
+	virtual void reportNotifications() {}
+};
+
+#endif  //PHYSICS_CLIENT_GRPC_H
diff --git a/engine/inc/bullet/SharedMemory/PhysicsClientGRPC_C_API.h b/engine/inc/bullet/SharedMemory/PhysicsClientGRPC_C_API.h
new file mode 100644
index 00000000..a61984b4
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/PhysicsClientGRPC_C_API.h
@@ -0,0 +1,18 @@
+#ifndef PHYSICS_CLIENT_GRPC_C_API_H
+#define PHYSICS_CLIENT_GRPC_C_API_H
+
+#include "PhysicsClientC_API.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	///send physics commands using GRPC connection
+	B3_SHARED_API b3PhysicsClientHandle b3ConnectPhysicsGRPC(const char* hostName, int port);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  //PHYSICS_CLIENT_GRPC_C_API_H
diff --git a/engine/inc/bullet/SharedMemory/PhysicsClientSharedMemory.h b/engine/inc/bullet/SharedMemory/PhysicsClientSharedMemory.h
new file mode 100644
index 00000000..f1a67c52
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/PhysicsClientSharedMemory.h
@@ -0,0 +1,107 @@
+#ifndef BT_PHYSICS_CLIENT_SHARED_MEMORY_API_H
+#define BT_PHYSICS_CLIENT_SHARED_MEMORY_API_H
+
+#include "PhysicsClient.h"
+
+//#include "SharedMemoryCommands.h"
+#include "LinearMath/btVector3.h"
+
+class PhysicsClientSharedMemory : public PhysicsClient
+{
+	
+
+protected:
+	struct PhysicsClientSharedMemoryInternalData* m_data;
+	virtual void setSharedMemoryInterface(class SharedMemoryInterface* sharedMem);
+	void processBodyJointInfo(int bodyUniqueId, const struct SharedMemoryStatus& serverCmd);
+	void resetData();
+	void removeCachedBody(int bodyUniqueId);
+	void clearCachedBodies();
+	virtual void renderSceneInternal(){};
+
+public:
+	PhysicsClientSharedMemory();
+	virtual ~PhysicsClientSharedMemory();
+
+	// return true if connection succesfull, can also check 'isConnected'
+	virtual bool connect();
+
+	virtual void disconnectSharedMemory();
+
+	virtual bool isConnected() const;
+
+	// return non-null if there is a status, nullptr otherwise
+	virtual const struct SharedMemoryStatus* processServerStatus();
+
+	virtual struct SharedMemoryCommand* getAvailableSharedMemoryCommand();
+
+	virtual bool canSubmitCommand() const;
+
+	virtual bool submitClientCommand(const struct SharedMemoryCommand& command);
+
+	virtual int getNumBodies() const;
+
+	virtual int getBodyUniqueId(int serialIndex) const;
+
+	virtual bool getBodyInfo(int bodyUniqueId, struct b3BodyInfo& info) const;
+
+	virtual int getNumJoints(int bodyUniqueId) const;
+
+	virtual int getNumDofs(int bodyUniqueId) const;
+
+	virtual bool getJointInfo(int bodyUniqueId, int jointIndex, struct b3JointInfo& info) const;
+
+	virtual int getNumUserConstraints() const;
+
+	virtual int getUserConstraintInfo(int constraintUniqueId, struct b3UserConstraint& info) const;
+
+	virtual int getUserConstraintId(int serialIndex) const;
+
+	virtual void setSharedMemoryKey(int key);
+
+	virtual void uploadBulletFileToSharedMemory(const char* data, int len);
+
+	virtual void uploadRaysToSharedMemory(struct SharedMemoryCommand& command, const double* rayFromWorldArray, const double* rayToWorldArray, int numRays);
+
+	virtual int getNumDebugLines() const;
+
+	virtual const float* getDebugLinesFrom() const;
+	virtual const float* getDebugLinesTo() const;
+	virtual const float* getDebugLinesColor() const;
+	virtual void getCachedCameraImage(struct b3CameraImageData* cameraData);
+
+	virtual void getCachedContactPointInformation(struct b3ContactInformation* contactPointData);
+
+	virtual void getCachedOverlappingObjects(struct b3AABBOverlapData* overlappingObjects);
+
+	virtual void getCachedVisualShapeInformation(struct b3VisualShapeInformation* visualShapesInfo);
+
+	virtual void getCachedCollisionShapeInformation(struct b3CollisionShapeInformation* collisionShapesInfo);
+
+	virtual void getCachedMeshData(struct b3MeshData* meshData);
+
+	virtual void getCachedVREvents(struct b3VREventsData* vrEventsData);
+
+	virtual void getCachedKeyboardEvents(struct b3KeyboardEventsData* keyboardEventsData);
+
+	virtual void getCachedMouseEvents(struct b3MouseEventsData* mouseEventsData);
+
+	virtual void getCachedRaycastHits(struct b3RaycastInformation* raycastHits);
+
+	virtual void getCachedMassMatrix(int dofCountCheck, double* massMatrix);
+
+	virtual bool getCachedReturnData(b3UserDataValue* returnData);
+
+	virtual void setTimeOut(double timeOutInSeconds);
+	virtual double getTimeOut() const;
+
+	virtual bool getCachedUserData(int userDataId, struct b3UserDataValue& valueOut) const;
+	virtual int getCachedUserDataId(int bodyUniqueId, int linkIndex, int visualShapeIndex, const char* key) const;
+	virtual int getNumUserData(int bodyUniqueId) const;
+	virtual void getUserDataInfo(int bodyUniqueId, int userDataIndex, const char** keyOut, int* userDataIdOut, int* linkIndexOut, int* visualShapeIndexOut) const;
+
+	virtual void pushProfileTiming(const char* timingName);
+	virtual void popProfileTiming();
+};
+
+#endif  // BT_PHYSICS_CLIENT_API_H
diff --git a/engine/inc/bullet/SharedMemory/PhysicsClientSharedMemory2.h b/engine/inc/bullet/SharedMemory/PhysicsClientSharedMemory2.h
new file mode 100644
index 00000000..473ee0ec
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/PhysicsClientSharedMemory2.h
@@ -0,0 +1,17 @@
+#ifndef PHYSICS_CLIENT_SHARED_MEMORY3_H
+#define PHYSICS_CLIENT_SHARED_MEMORY3_H
+
+#include "PhysicsDirect.h"
+
+class PhysicsClientSharedMemory2 : public PhysicsDirect
+{
+	class SharedMemoryCommandProcessor* m_proc;
+
+public:
+	PhysicsClientSharedMemory2(SharedMemoryCommandProcessor* proc);
+	virtual ~PhysicsClientSharedMemory2();
+
+	void setSharedMemoryInterface(class SharedMemoryInterface* sharedMem);
+};
+
+#endif  //PHYSICS_CLIENT_SHARED_MEMORY3_H
\ No newline at end of file
diff --git a/engine/inc/bullet/SharedMemory/PhysicsClientSharedMemory2_C_API.h b/engine/inc/bullet/SharedMemory/PhysicsClientSharedMemory2_C_API.h
new file mode 100644
index 00000000..0f711b4b
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/PhysicsClientSharedMemory2_C_API.h
@@ -0,0 +1,17 @@
+#ifndef PHYSICS_CLIENT_SHARED_MEMORY2_H
+#define PHYSICS_CLIENT_SHARED_MEMORY2_H
+
+#include "PhysicsClientC_API.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	b3PhysicsClientHandle b3ConnectSharedMemory2(int key);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  //PHYSICS_CLIENT_SHARED_MEMORY2_H
diff --git a/engine/inc/bullet/SharedMemory/PhysicsClientSharedMemory_C_API.h b/engine/inc/bullet/SharedMemory/PhysicsClientSharedMemory_C_API.h
new file mode 100644
index 00000000..31f217cb
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/PhysicsClientSharedMemory_C_API.h
@@ -0,0 +1,17 @@
+#ifndef PHYSICS_CLIENT_SHARED_MEMORY_H
+#define PHYSICS_CLIENT_SHARED_MEMORY_H
+
+#include "PhysicsClientC_API.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	B3_SHARED_API b3PhysicsClientHandle b3ConnectSharedMemory(int key);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  //PHYSICS_CLIENT_SHARED_MEMORY_H
diff --git a/engine/inc/bullet/SharedMemory/PhysicsClientTCP.h b/engine/inc/bullet/SharedMemory/PhysicsClientTCP.h
new file mode 100644
index 00000000..ec24b656
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/PhysicsClientTCP.h
@@ -0,0 +1,37 @@
+#ifndef PHYSICS_CLIENT_TCP_H
+#define PHYSICS_CLIENT_TCP_H
+
+#include "PhysicsDirect.h"
+#include "PhysicsCommandProcessorInterface.h"
+
+class TcpNetworkedPhysicsProcessor : public PhysicsCommandProcessorInterface
+{
+	struct TcpNetworkedInternalData* m_data;
+
+public:
+	TcpNetworkedPhysicsProcessor(const char* hostName, int port);
+
+	virtual ~TcpNetworkedPhysicsProcessor();
+
+	virtual bool connect();
+
+	virtual void disconnect();
+
+	virtual bool isConnected() const;
+
+	virtual bool processCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+
+	virtual bool receiveStatus(struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+
+	virtual void renderScene(int renderFlags);
+
+	virtual void physicsDebugDraw(int debugDrawFlags);
+
+	virtual void setGuiHelper(struct GUIHelperInterface* guiHelper);
+
+	virtual void setTimeOut(double timeOutInSeconds);
+
+	virtual void reportNotifications() {}
+};
+
+#endif  //PHYSICS_CLIENT_TCP_H
diff --git a/engine/inc/bullet/SharedMemory/PhysicsClientTCP_C_API.h b/engine/inc/bullet/SharedMemory/PhysicsClientTCP_C_API.h
new file mode 100644
index 00000000..541349fe
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/PhysicsClientTCP_C_API.h
@@ -0,0 +1,18 @@
+#ifndef PHYSICS_CLIENT_TCP_C_API_H
+#define PHYSICS_CLIENT_TCP_C_API_H
+
+#include "PhysicsClientC_API.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	///send physics commands using TCP networking
+	B3_SHARED_API b3PhysicsClientHandle b3ConnectPhysicsTCP(const char* hostName, int port);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  //PHYSICS_CLIENT_TCP_C_API_H
diff --git a/engine/inc/bullet/SharedMemory/PhysicsClientUDP.h b/engine/inc/bullet/SharedMemory/PhysicsClientUDP.h
new file mode 100644
index 00000000..0aaa7791
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/PhysicsClientUDP.h
@@ -0,0 +1,37 @@
+#ifndef PHYSICS_CLIENT_UDP_H
+#define PHYSICS_CLIENT_UDP_H
+
+#include "PhysicsDirect.h"
+#include "PhysicsCommandProcessorInterface.h"
+
+class UdpNetworkedPhysicsProcessor : public PhysicsCommandProcessorInterface
+{
+	struct UdpNetworkedInternalData* m_data;
+
+public:
+	UdpNetworkedPhysicsProcessor(const char* hostName, int port);
+
+	virtual ~UdpNetworkedPhysicsProcessor();
+
+	virtual bool connect();
+
+	virtual void disconnect();
+
+	virtual bool isConnected() const;
+
+	virtual bool processCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+
+	virtual bool receiveStatus(struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+
+	virtual void renderScene(int renderFlags);
+
+	virtual void physicsDebugDraw(int debugDrawFlags);
+
+	virtual void setGuiHelper(struct GUIHelperInterface* guiHelper);
+
+	virtual void setTimeOut(double timeOutInSeconds);
+
+	virtual void reportNotifications() {}
+};
+
+#endif  //PHYSICS_CLIENT_UDP_H
diff --git a/engine/inc/bullet/SharedMemory/PhysicsClientUDP_C_API.h b/engine/inc/bullet/SharedMemory/PhysicsClientUDP_C_API.h
new file mode 100644
index 00000000..3381e84a
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/PhysicsClientUDP_C_API.h
@@ -0,0 +1,18 @@
+#ifndef PHYSICS_CLIENT_UDP_C_API_H
+#define PHYSICS_CLIENT_UDP_C_API_H
+
+#include "PhysicsClientC_API.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	///send physics commands using UDP networking
+	B3_SHARED_API b3PhysicsClientHandle b3ConnectPhysicsUDP(const char* hostName, int port);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  //PHYSICS_CLIENT_UDP_C_API_H
diff --git a/engine/inc/bullet/SharedMemory/PhysicsCommandProcessorInterface.h b/engine/inc/bullet/SharedMemory/PhysicsCommandProcessorInterface.h
new file mode 100644
index 00000000..11a2280c
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/PhysicsCommandProcessorInterface.h
@@ -0,0 +1,62 @@
+#ifndef PHYSICS_COMMAND_PROCESSOR_INTERFACE_H
+#define PHYSICS_COMMAND_PROCESSOR_INTERFACE_H
+
+enum PhysicsCommandRenderFlags
+{
+	COV_DISABLE_SYNC_RENDERING = 1
+};
+
+class PhysicsCommandProcessorInterface
+{
+public:
+	virtual ~PhysicsCommandProcessorInterface() {}
+
+	virtual bool connect() = 0;
+
+	virtual void disconnect() = 0;
+
+	virtual bool isConnected() const = 0;
+
+	virtual bool processCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes) = 0;
+
+	virtual bool receiveStatus(struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes) = 0;
+
+	virtual void renderScene(int renderFlags) = 0;
+	virtual void physicsDebugDraw(int debugDrawFlags) = 0;
+	virtual void setGuiHelper(struct GUIHelperInterface* guiHelper) = 0;
+	virtual void setTimeOut(double timeOutInSeconds) = 0;
+
+	virtual void reportNotifications() = 0;
+};
+
+class btVector3;
+class btQuaternion;
+
+class CommandProcessorInterface : public PhysicsCommandProcessorInterface
+{
+public:
+	virtual ~CommandProcessorInterface() {}
+
+	virtual void syncPhysicsToGraphics() = 0;
+	virtual void stepSimulationRealTime(double dtInSec, const struct b3VRControllerEvent* vrControllerEvents, int numVRControllerEvents, const struct b3KeyboardEvent* keyEvents, int numKeyEvents, const struct b3MouseEvent* mouseEvents, int numMouseEvents) = 0;
+	virtual void enableRealTimeSimulation(bool enableRealTimeSim) = 0;
+	virtual bool isRealTimeSimulationEnabled() const = 0;
+
+	virtual void enableCommandLogging(bool enable, const char* fileName) = 0;
+	virtual void replayFromLogFile(const char* fileName) = 0;
+	virtual void replayLogCommand(char* bufferServerToClient, int bufferSizeInBytes) = 0;
+
+	virtual bool pickBody(const btVector3& rayFromWorld, const btVector3& rayToWorld) = 0;
+	virtual bool movePickedBody(const btVector3& rayFromWorld, const btVector3& rayToWorld) = 0;
+	virtual void removePickingConstraint() = 0;
+
+	virtual const btVector3& getVRTeleportPosition() const = 0;
+	virtual void setVRTeleportPosition(const btVector3& vrReleportPos) = 0;
+
+	virtual const btQuaternion& getVRTeleportOrientation() const = 0;
+	virtual void setVRTeleportOrientation(const btQuaternion& vrReleportOrn) = 0;
+
+	virtual void processClientCommands() = 0;
+};
+
+#endif  //PHYSICS_COMMAND_PROCESSOR_INTERFACE_H
diff --git a/engine/inc/bullet/SharedMemory/PhysicsDirect.h b/engine/inc/bullet/SharedMemory/PhysicsDirect.h
new file mode 100644
index 00000000..2e09a95d
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/PhysicsDirect.h
@@ -0,0 +1,136 @@
+#ifndef PHYSICS_DIRECT_H
+#define PHYSICS_DIRECT_H
+
+//#include "SharedMemoryCommands.h"
+
+#include "PhysicsClient.h"
+#include "LinearMath/btVector3.h"
+
+///PhysicsDirect executes the commands directly, without transporting them or having a separate server executing commands
+class PhysicsDirect : public PhysicsClient
+{
+protected:
+	struct PhysicsDirectInternalData* m_data;
+
+	bool processDebugLines(const struct SharedMemoryCommand& orgCommand);
+
+	bool processCamera(const struct SharedMemoryCommand& orgCommand);
+
+	bool processContactPointData(const struct SharedMemoryCommand& orgCommand);
+
+	bool processOverlappingObjects(const struct SharedMemoryCommand& orgCommand);
+
+	bool processVisualShapeData(const struct SharedMemoryCommand& orgCommand);
+
+	bool processMeshData(const struct SharedMemoryCommand& orgCommand);
+
+	void processBodyJointInfo(int bodyUniqueId, const struct SharedMemoryStatus& serverCmd);
+
+	void processAddUserData(const struct SharedMemoryStatus& serverCmd);
+
+	bool processCustomCommand(const struct SharedMemoryCommand& orgCommand);
+
+	void postProcessStatus(const struct SharedMemoryStatus& serverCmd);
+
+	void resetData();
+
+	void removeCachedBody(int bodyUniqueId);
+
+	void clearCachedBodies();
+
+public:
+	PhysicsDirect(class PhysicsCommandProcessorInterface* physSdk, bool passSdkOwnership);
+
+	virtual ~PhysicsDirect();
+
+	// return true if connection succesfull, can also check 'isConnected'
+	//it is OK to pass a null pointer for the gui helper
+	virtual bool connect();
+
+	////todo: rename to 'disconnect'
+	virtual void disconnectSharedMemory();
+
+	virtual bool isConnected() const;
+
+	// return non-null if there is a status, nullptr otherwise
+	virtual const SharedMemoryStatus* processServerStatus();
+
+	virtual SharedMemoryCommand* getAvailableSharedMemoryCommand();
+
+	virtual bool canSubmitCommand() const;
+
+	virtual bool submitClientCommand(const struct SharedMemoryCommand& command);
+
+	virtual int getNumBodies() const;
+
+	virtual int getBodyUniqueId(int serialIndex) const;
+
+	virtual bool getBodyInfo(int bodyUniqueId, struct b3BodyInfo& info) const;
+
+	virtual int getNumJoints(int bodyUniqueId) const;
+
+	virtual int getNumDofs(int bodyUniqueId) const;
+
+	virtual bool getJointInfo(int bodyIndex, int jointIndex, struct b3JointInfo& info) const;
+
+	virtual int getNumUserConstraints() const;
+
+	virtual int getUserConstraintInfo(int constraintUniqueId, struct b3UserConstraint& info) const;
+
+	virtual int getUserConstraintId(int serialIndex) const;
+
+	///todo: move this out of the
+	virtual void setSharedMemoryKey(int key);
+
+	void uploadBulletFileToSharedMemory(const char* data, int len);
+
+	virtual void uploadRaysToSharedMemory(struct SharedMemoryCommand& command, const double* rayFromWorldArray, const double* rayToWorldArray, int numRays);
+
+	virtual int getNumDebugLines() const;
+
+	virtual const float* getDebugLinesFrom() const;
+	virtual const float* getDebugLinesTo() const;
+	virtual const float* getDebugLinesColor() const;
+
+	virtual void getCachedCameraImage(b3CameraImageData* cameraData);
+
+	virtual void getCachedContactPointInformation(struct b3ContactInformation* contactPointData);
+
+	virtual void getCachedOverlappingObjects(struct b3AABBOverlapData* overlappingObjects);
+
+	virtual void getCachedVisualShapeInformation(struct b3VisualShapeInformation* visualShapesInfo);
+
+	virtual void getCachedCollisionShapeInformation(struct b3CollisionShapeInformation* collisionShapesInfo);
+
+	virtual void getCachedMeshData(struct b3MeshData* meshData);
+
+	virtual void getCachedVREvents(struct b3VREventsData* vrEventsData);
+
+	virtual void getCachedKeyboardEvents(struct b3KeyboardEventsData* keyboardEventsData);
+
+	virtual void getCachedMouseEvents(struct b3MouseEventsData* mouseEventsData);
+
+	virtual void getCachedRaycastHits(struct b3RaycastInformation* raycastHits);
+
+	virtual void getCachedMassMatrix(int dofCountCheck, double* massMatrix);
+
+	virtual bool getCachedReturnData(b3UserDataValue* returnData);
+
+	//the following APIs are for internal use for visualization:
+	virtual bool connect(struct GUIHelperInterface* guiHelper);
+	virtual void renderScene();
+	virtual void debugDraw(int debugDrawMode);
+
+	virtual void setTimeOut(double timeOutInSeconds);
+	virtual double getTimeOut() const;
+
+	virtual bool getCachedUserData(int userDataId, struct b3UserDataValue& valueOut) const;
+	virtual int getCachedUserDataId(int bodyUniqueId, int linkIndex, int visualShapeIndex, const char* key) const;
+	virtual int getNumUserData(int bodyUniqueId) const;
+	virtual void getUserDataInfo(int bodyUniqueId, int userDataIndex, const char** keyOut, int* userDataIdOut, int* linkIndexOut, int* visualShapeIndexOut) const;
+
+	virtual void pushProfileTiming(const char* timingName);
+	virtual void popProfileTiming();
+};
+
+#endif  //PHYSICS_DIRECT_H
diff --git a/engine/inc/bullet/SharedMemory/PhysicsDirectC_API.h b/engine/inc/bullet/SharedMemory/PhysicsDirectC_API.h
new file mode 100644
index 00000000..cde48820
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/PhysicsDirectC_API.h
@@ -0,0 +1,18 @@
+#ifndef PHYSICS_DIRECT_C_API_H
+#define PHYSICS_DIRECT_C_API_H
+
+#include "PhysicsClientC_API.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	///think more about naming. Directly execute commands without transport (no shared memory, UDP, socket, grpc etc)
+	B3_SHARED_API b3PhysicsClientHandle b3ConnectPhysicsDirect();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  //PHYSICS_DIRECT_C_API_H
diff --git a/engine/inc/bullet/SharedMemory/PhysicsLoopBack.h b/engine/inc/bullet/SharedMemory/PhysicsLoopBack.h
new file mode 100644
index 00000000..4626aac8
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/PhysicsLoopBack.h
@@ -0,0 +1,105 @@
+#ifndef PHYSICS_LOOP_BACK_H
+#define PHYSICS_LOOP_BACK_H
+
+//#include "SharedMemoryCommands.h"
+
+#include "PhysicsClient.h"
+#include "LinearMath/btVector3.h"
+
+///todo: the PhysicsClient API was designed with shared memory in mind,
+///now it become more general we need to move out the shared memory specifics away
+///for example naming [disconnectSharedMemory -> disconnect] [ move setSharedMemoryKey to shared memory specific subclass ]
+
+class PhysicsLoopBack : public PhysicsClient
+{
+	struct PhysicsLoopBackInternalData* m_data;
+
+public:
+	PhysicsLoopBack();
+
+	virtual ~PhysicsLoopBack();
+
+	// return true if connection succesfull, can also check 'isConnected'
+	virtual bool connect();
+
+	////todo: rename to 'disconnect'
+	virtual void disconnectSharedMemory();
+
+	virtual bool isConnected() const;
+
+	// return non-null if there is a status, nullptr otherwise
+	virtual const SharedMemoryStatus* processServerStatus();
+
+	virtual SharedMemoryCommand* getAvailableSharedMemoryCommand();
+
+	virtual bool canSubmitCommand() const;
+
+	virtual bool submitClientCommand(const struct SharedMemoryCommand& command);
+
+	virtual int getNumBodies() const;
+
+	virtual int getBodyUniqueId(int serialIndex) const;
+
+	virtual bool getBodyInfo(int bodyUniqueId, struct b3BodyInfo& info) const;
+
+	virtual int getNumJoints(int bodyUniqueId) const;
+
+	virtual int getNumDofs(int bodyUniqueId) const;
+
+	virtual bool getJointInfo(int bodyIndex, int jointIndex, struct b3JointInfo& info) const;
+
+	virtual int getNumUserConstraints() const;
+
+	virtual int getUserConstraintInfo(int constraintUniqueId, struct b3UserConstraint& info) const;
+
+	virtual int getUserConstraintId(int serialIndex) const;
+
+	///todo: move this out of the
+	virtual void setSharedMemoryKey(int key);
+
+	void uploadBulletFileToSharedMemory(const char* data, int len);
+
+	virtual void uploadRaysToSharedMemory(struct SharedMemoryCommand& command, const double* rayFromWorldArray, const double* rayToWorldArray, int numRays);
+
+	virtual int getNumDebugLines() const;
+
+	virtual const float* getDebugLinesFrom() const;
+	virtual const float* getDebugLinesTo() const;
+	virtual const float* getDebugLinesColor() const;
+	virtual void getCachedCameraImage(struct b3CameraImageData* cameraData);
+
+	virtual void getCachedContactPointInformation(struct b3ContactInformation* contactPointData);
+
+	virtual void getCachedOverlappingObjects(struct b3AABBOverlapData* overlappingObjects);
+
+	virtual void getCachedVisualShapeInformation(struct b3VisualShapeInformation* visualShapesInfo);
+
+	virtual void getCachedCollisionShapeInformation(struct b3CollisionShapeInformation* collisionShapesInfo);
+
+	virtual void getCachedMeshData(struct b3MeshData* meshData);
+
+	virtual void getCachedVREvents(struct b3VREventsData* vrEventsData);
+
+	virtual void getCachedKeyboardEvents(struct b3KeyboardEventsData* keyboardEventsData);
+
+	virtual void getCachedMouseEvents(struct b3MouseEventsData* mouseEventsData);
+
+	virtual void getCachedRaycastHits(struct b3RaycastInformation* raycastHits);
+
+	virtual void getCachedMassMatrix(int dofCountCheck, double* massMatrix);
+
+	virtual bool getCachedReturnData(struct b3UserDataValue* returnData);
+
+	virtual void setTimeOut(double timeOutInSeconds);
+	virtual double getTimeOut() const;
+
+	virtual bool getCachedUserData(int userDataId, struct b3UserDataValue& valueOut) const;
+	virtual int getCachedUserDataId(int bodyUniqueId, int linkIndex, int visualShapeIndex, const char* key) const;
+	virtual int getNumUserData(int bodyUniqueId) const;
+	virtual void getUserDataInfo(int bodyUniqueId, int userDataIndex, const char** keyOut, int* userDataIdOut, int* linkIndexOut, int* visualShapeIndexOut) const;
+
+	virtual void pushProfileTiming(const char* timingName);
+	virtual void popProfileTiming();
+};
+
+#endif  //PHYSICS_LOOP_BACK_H
diff --git a/engine/inc/bullet/SharedMemory/PhysicsLoopBackC_API.h b/engine/inc/bullet/SharedMemory/PhysicsLoopBackC_API.h
new file mode 100644
index 00000000..feb41faf
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/PhysicsLoopBackC_API.h
@@ -0,0 +1,18 @@
+#ifndef PHYSICS_LOOPBACK_C_API_H
+#define PHYSICS_LOOPBACK_C_API_H
+
+#include "PhysicsClientC_API.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	///think more about naming. The b3ConnectPhysicsLoopback
+	b3PhysicsClientHandle b3ConnectPhysicsLoopback(int key);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  //PHYSICS_LOOPBACK_C_API_H
diff --git a/engine/inc/bullet/SharedMemory/PhysicsServer.h b/engine/inc/bullet/SharedMemory/PhysicsServer.h
new file mode 100644
index 00000000..2a940abd
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/PhysicsServer.h
@@ -0,0 +1,37 @@
+#ifndef PHYSICS_SERVER_H
+#define PHYSICS_SERVER_H
+
+#include "LinearMath/btVector3.h"
+
+class PhysicsServer
+{
+public:
+	virtual ~PhysicsServer();
+
+	virtual void setSharedMemoryKey(int key) = 0;
+
+	virtual bool connectSharedMemory(struct GUIHelperInterface* guiHelper) = 0;
+
+	virtual void disconnectSharedMemory(bool deInitializeSharedMemory) = 0;
+
+	virtual void processClientCommands() = 0;
+
+	//	virtual bool	supportsJointMotor(class btMultiBody* body, int linkIndex)=0;
+
+	//@todo(erwincoumans) Should we have shared memory commands for picking objects?
+	///The pickBody method will try to pick the first body along a ray, return true if succeeds, false otherwise
+	virtual bool pickBody(const btVector3& rayFromWorld, const btVector3& rayToWorld) { return false; }
+	virtual bool movePickedBody(const btVector3& rayFromWorld, const btVector3& rayToWorld) { return false; }
+	virtual void removePickingConstraint() {}
+
+	//for physicsDebugDraw and renderScene are mainly for debugging purposes
+	//and for physics visualization. The idea is that physicsDebugDraw can also send wireframe
+	//to a physics client, over shared memory
+	virtual void physicsDebugDraw(int debugDrawFlags) {}
+	virtual void renderScene(int renderFlags) {}
+
+	virtual void enableCommandLogging(bool enable, const char* fileName) {}
+	virtual void replayFromLogFile(const char* fileName) {}
+};
+
+#endif  //PHYSICS_SERVER_H
diff --git a/engine/inc/bullet/SharedMemory/PhysicsServerCommandProcessor.h b/engine/inc/bullet/SharedMemory/PhysicsServerCommandProcessor.h
new file mode 100644
index 00000000..cbc4cbab
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/PhysicsServerCommandProcessor.h
@@ -0,0 +1,190 @@
+#ifndef PHYSICS_SERVER_COMMAND_PROCESSOR_H
+#define PHYSICS_SERVER_COMMAND_PROCESSOR_H
+
+#include "LinearMath/btHashMap.h"
+#include "LinearMath/btVector3.h"
+
+#include "PhysicsCommandProcessorInterface.h"
+#include "../Importers/ImportURDFDemo/UrdfParser.h"
+
+struct SharedMemLines
+{
+	btVector3 m_from;
+	btVector3 m_to;
+	btVector3 m_color;
+};
+
+///todo: naming. Perhaps PhysicsSdkCommandprocessor?
+class PhysicsServerCommandProcessor : public CommandProcessorInterface
+{
+	struct PhysicsServerCommandProcessorInternalData* m_data;
+
+	void resetSimulation(int flags = 0);
+	void createThreadPool();
+
+	class btDeformableMultiBodyDynamicsWorld* getDeformableWorld();
+	class btSoftMultiBodyDynamicsWorld* getSoftWorld();
+
+protected:
+	bool processStateLoggingCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRequestCameraImageCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processSaveWorldCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processCreateCollisionShapeCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processCreateVisualShapeCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRequestMeshDataCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processCustomCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processUserDebugDrawCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processSetVRCameraStateCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRequestVREventsCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRequestMouseEventsCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRequestKeyboardEventsCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRequestRaycastIntersectionsCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRequestDebugLinesCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processSyncBodyInfoCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processSendDesiredStateCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRequestActualStateCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRequestContactpointInformationCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRequestBodyInfoCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processLoadSDFCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processCreateMultiBodyCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processCreateMultiBodyCommandSingle(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+
+	bool processLoadURDFCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processLoadSoftBodyCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processCreateSensorCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processProfileTimingCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRequestCollisionInfoCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processForwardDynamicsCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRequestInternalDataCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processChangeDynamicsInfoCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processSetAdditionalSearchPathCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processGetDynamicsInfoCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRequestPhysicsSimulationParametersCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processSendPhysicsParametersCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processInitPoseCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processResetSimulationCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processCreateRigidBodyCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processPickBodyCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processMovePickedBodyCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRemovePickingConstraintCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRequestAabbOverlapCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRequestOpenGLVisualizeCameraCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processConfigureOpenGLVisualizerCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processInverseDynamicsCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processCalculateJacobianCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processCalculateMassMatrixCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processApplyExternalForceCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRemoveBodyCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processCreateUserConstraintCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processCalculateInverseKinematicsCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processCalculateInverseKinematicsCommand2(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRequestVisualShapeInfoCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRequestCollisionShapeInfoCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processUpdateVisualShapeCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processChangeTextureCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processLoadTextureCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processLoadBulletCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processSaveBulletCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processLoadMJCFCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRestoreStateCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processSaveStateCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRemoveStateCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processSyncUserDataCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRequestUserDataCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processAddUserDataCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRemoveUserDataCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processCollisionFilterCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+
+	int extractCollisionShapes(const class btCollisionShape* colShape, const class btTransform& transform, struct b3CollisionShapeData* collisionShapeBuffer, int maxCollisionShapes);
+
+	bool loadSdf(const char* fileName, char* bufferServerToClient, int bufferSizeInBytes, bool useMultiBody, int flags, btScalar globalScaling);
+
+	bool loadUrdf(const char* fileName, const class btVector3& pos, const class btQuaternion& orn,
+				  bool useMultiBody, bool useFixedBase, int* bodyUniqueIdPtr, char* bufferServerToClient, int bufferSizeInBytes, int flags, btScalar globalScaling);
+
+	bool loadMjcf(const char* fileName, char* bufferServerToClient, int bufferSizeInBytes, bool useMultiBody, int flags);
+
+	bool processImportedObjects(const char* fileName, char* bufferServerToClient, int bufferSizeInBytes, bool useMultiBody, int flags, class URDFImporterInterface& u2b);
+	bool processDeformable(const UrdfDeformable& deformable, const btVector3& pos, const btQuaternion& orn, int* bodyUniqueId, char* bufferServerToClient, int bufferSizeInBytes, btScalar scale, bool useSelfCollision);
+
+	bool supportsJointMotor(class btMultiBody* body, int linkIndex);
+
+	int createBodyInfoStream(int bodyUniqueId, char* bufferServerToClient, int bufferSizeInBytes);
+	void deleteCachedInverseDynamicsBodies();
+	void deleteCachedInverseKinematicsBodies();
+	void deleteStateLoggers();
+
+public:
+	PhysicsServerCommandProcessor();
+	virtual ~PhysicsServerCommandProcessor();
+
+	void createJointMotors(class btMultiBody* body);
+
+	virtual void createEmptyDynamicsWorld(int flags = 0);
+	virtual void deleteDynamicsWorld();
+
+	virtual bool connect()
+	{
+		return true;
+	};
+
+	virtual void disconnect() {}
+
+	virtual bool isConnected() const
+	{
+		return true;
+	}
+
+	virtual bool processCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+
+	virtual bool receiveStatus(struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes)
+	{
+		return false;
+	};
+
+	virtual void renderScene(int renderFlags);
+	virtual void physicsDebugDraw(int debugDrawFlags);
+	virtual void setGuiHelper(struct GUIHelperInterface* guiHelper);
+	virtual void syncPhysicsToGraphics();
+	virtual void syncPhysicsToGraphics2();
+
+	//@todo(erwincoumans) Should we have shared memory commands for picking objects?
+	///The pickBody method will try to pick the first body along a ray, return true if succeeds, false otherwise
+	virtual bool pickBody(const btVector3& rayFromWorld, const btVector3& rayToWorld);
+	virtual bool movePickedBody(const btVector3& rayFromWorld, const btVector3& rayToWorld);
+	virtual void removePickingConstraint();
+
+	//logging /playback the shared memory commands
+	virtual void enableCommandLogging(bool enable, const char* fileName);
+	virtual void replayFromLogFile(const char* fileName);
+	virtual void replayLogCommand(char* bufferServerToClient, int bufferSizeInBytes);
+
+	//logging of object states (position etc)
+	virtual void reportNotifications();
+	virtual void processClientCommands();
+	void tickPlugins(btScalar timeStep, bool isPreTick);
+	void logObjectStates(btScalar timeStep);
+	void processCollisionForces(btScalar timeStep);
+
+	virtual void stepSimulationRealTime(double dtInSec, const struct b3VRControllerEvent* vrControllerEvents, int numVRControllerEvents, const struct b3KeyboardEvent* keyEvents, int numKeyEvents, const struct b3MouseEvent* mouseEvents, int numMouseEvents);
+
+	virtual void enableRealTimeSimulation(bool enableRealTimeSim);
+	virtual bool isRealTimeSimulationEnabled() const;
+
+	void applyJointDamping(int bodyUniqueId);
+
+	virtual void setTimeOut(double timeOutInSeconds);
+
+	virtual const btVector3& getVRTeleportPosition() const;
+	virtual void setVRTeleportPosition(const btVector3& vrTeleportPos);
+
+	virtual const btQuaternion& getVRTeleportOrientation() const;
+	virtual void setVRTeleportOrientation(const btQuaternion& vrTeleportOrn);
+
+private:
+	void addBodyChangedNotifications();
+	int addUserData(int bodyUniqueId, int linkIndex, int visualShapeIndex, const char* key, const char* valueBytes, int valueLength, int valueType);
+	void addUserData(const btHashMap<btHashString, std::string>& user_data_entries, int bodyUniqueId, int linkIndex = -1, int visualShapeIndex = -1);
+};
+
+#endif  //PHYSICS_SERVER_COMMAND_PROCESSOR_H
diff --git a/engine/inc/bullet/SharedMemory/PhysicsServerExample.h b/engine/inc/bullet/SharedMemory/PhysicsServerExample.h
new file mode 100644
index 00000000..63f40146
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/PhysicsServerExample.h
@@ -0,0 +1,15 @@
+#ifndef PHYSICS_SERVER_EXAMPLE_H
+#define PHYSICS_SERVER_EXAMPLE_H
+
+enum PhysicsServerOptions
+{
+	PHYSICS_SERVER_ENABLE_COMMAND_LOGGING = 1,
+	PHYSICS_SERVER_REPLAY_FROM_COMMAND_LOG = 2,
+	PHYSICS_SERVER_USE_RTC_CLOCK = 4,
+};
+
+///Don't use PhysicsServerCreateFuncInternal directly
+///Use PhysicsServerCreateFuncBullet2 instead, or initialize options.m_commandProcessor
+class CommonExampleInterface* PhysicsServerCreateFuncInternal(struct CommonExampleOptions& options);
+
+#endif  //PHYSICS_SERVER_EXAMPLE_H
diff --git a/engine/inc/bullet/SharedMemory/PhysicsServerExampleBullet2.h b/engine/inc/bullet/SharedMemory/PhysicsServerExampleBullet2.h
new file mode 100644
index 00000000..750b61b2
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/PhysicsServerExampleBullet2.h
@@ -0,0 +1,7 @@
+
+#ifndef PHYSICS_SERVER_EXAMPLE_BULLET_2_H
+#define PHYSICS_SERVER_EXAMPLE_BULLET_2_H
+
+class CommonExampleInterface* PhysicsServerCreateFuncBullet2(struct CommonExampleOptions& options);
+
+#endif  //PHYSICS_SERVER_EXAMPLE_BULLET_2_H
diff --git a/engine/inc/bullet/SharedMemory/PhysicsServerSharedMemory.h b/engine/inc/bullet/SharedMemory/PhysicsServerSharedMemory.h
new file mode 100644
index 00000000..26b660cf
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/PhysicsServerSharedMemory.h
@@ -0,0 +1,58 @@
+#ifndef PHYSICS_SERVER_SHARED_MEMORY_H
+#define PHYSICS_SERVER_SHARED_MEMORY_H
+
+#include "PhysicsServer.h"
+#include "LinearMath/btQuaternion.h"
+
+class PhysicsServerSharedMemory : public PhysicsServer
+{
+	struct PhysicsServerSharedMemoryInternalData* m_data;
+
+protected:
+	void releaseSharedMemory();
+
+public:
+	PhysicsServerSharedMemory(struct CommandProcessorCreationInterface* commandProcessorCreator, class SharedMemoryInterface* sharedMem, int bla);
+	virtual ~PhysicsServerSharedMemory();
+
+	virtual void setSharedMemoryKey(int key);
+
+	//todo: implement option to allocated shared memory from client
+	virtual bool connectSharedMemory(struct GUIHelperInterface* guiHelper);
+
+	virtual void disconnectSharedMemory(bool deInitializeSharedMemory);
+
+	virtual void processClientCommands();
+
+	virtual void stepSimulationRealTime(double dtInSec, const struct b3VRControllerEvent* vrEvents, int numVREvents, const struct b3KeyboardEvent* keyEvents, int numKeyEvents, const struct b3MouseEvent* mouseEvents, int numMouseEvents);
+
+	virtual void enableRealTimeSimulation(bool enableRealTimeSim);
+	virtual bool isRealTimeSimulationEnabled() const;
+
+	virtual void reportNotifications();
+
+	//bool	supportsJointMotor(class btMultiBody* body, int linkIndex);
+
+	///The pickBody method will try to pick the first body along a ray, return true if succeeds, false otherwise
+	virtual bool pickBody(const btVector3& rayFromWorld, const btVector3& rayToWorld);
+	virtual bool movePickedBody(const btVector3& rayFromWorld, const btVector3& rayToWorld);
+	virtual void removePickingConstraint();
+
+	virtual const btVector3& getVRTeleportPosition() const;
+	virtual void setVRTeleportPosition(const btVector3& vrTeleportPos);
+
+	virtual const btQuaternion& getVRTeleportOrientation() const;
+	virtual void setVRTeleportOrientation(const btQuaternion& vrTeleportOrn);
+
+	//for physicsDebugDraw and renderScene are mainly for debugging purposes
+	//and for physics visualization. The idea is that physicsDebugDraw can also send wireframe
+	//to a physics client, over shared memory
+	void physicsDebugDraw(int debugDrawFlags);
+	void renderScene(int renderFlags);
+	void syncPhysicsToGraphics();
+
+	void enableCommandLogging(bool enable, const char* fileName);
+	void replayFromLogFile(const char* fileName);
+};
+
+#endif  //PHYSICS_SERVER_EXAMPLESHARED_MEMORY_H
diff --git a/engine/inc/bullet/SharedMemory/PosixSharedMemory.h b/engine/inc/bullet/SharedMemory/PosixSharedMemory.h
new file mode 100644
index 00000000..be915741
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/PosixSharedMemory.h
@@ -0,0 +1,18 @@
+#ifndef POSIX_SHARED_MEMORY_H
+#define POSIX_SHARED_MEMORY_H
+
+#include "SharedMemoryInterface.h"
+
+class PosixSharedMemory : public SharedMemoryInterface
+{
+	struct PosixSharedMemoryInteralData* m_internalData;
+
+public:
+	PosixSharedMemory();
+	virtual ~PosixSharedMemory();
+
+	virtual void* allocateSharedMemory(int key, int size, bool allowCreation);
+	virtual void releaseSharedMemory(int key, int size);
+};
+
+#endif  //
diff --git a/engine/inc/bullet/SharedMemory/RemoteGUIHelper.h b/engine/inc/bullet/SharedMemory/RemoteGUIHelper.h
new file mode 100644
index 00000000..3d74b03f
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/RemoteGUIHelper.h
@@ -0,0 +1,78 @@
+#ifndef REMOTE_HELPER_H
+#define REMOTE_HELPER_H
+
+#include "../CommonInterfaces/CommonGUIHelperInterface.h"
+
+///a RemoteGUIHelper will connect to an existing graphics server through shared memory
+struct RemoteGUIHelper : public GUIHelperInterface
+{
+	struct RemoteGUIHelperInternalData* m_data;
+
+	RemoteGUIHelper();
+
+	virtual ~RemoteGUIHelper();
+
+	bool isConnected() const;
+
+	virtual void setVisualizerFlag(int flag, int enable);
+
+	virtual void createRigidBodyGraphicsObject(btRigidBody* body, const btVector3& color);
+
+	virtual void createCollisionObjectGraphicsObject(btCollisionObject* body, const btVector3& color);
+
+	virtual void createCollisionShapeGraphicsObject(btCollisionShape* collisionShape);
+
+	virtual bool getCameraInfo(int* width, int* height, float viewMatrix[16], float projectionMatrix[16], float camUp[3], float camForward[3], float hor[3], float vert[3], float* yaw, float* pitch, float* camDist, float camTarget[3]) const;
+
+	virtual void syncPhysicsToGraphics(const btDiscreteDynamicsWorld* rbWorld);
+	virtual void syncPhysicsToGraphics2(const class btDiscreteDynamicsWorld* rbWorld);
+	virtual void syncPhysicsToGraphics2(const GUISyncPosition* positions, int numPositions);
+
+	virtual void render(const btDiscreteDynamicsWorld* rbWorld);
+
+	virtual void createPhysicsDebugDrawer(btDiscreteDynamicsWorld* rbWorld);
+
+	virtual int registerTexture(const unsigned char* texels, int width, int height);
+	virtual int registerGraphicsShape(const float* vertices, int numvertices, const int* indices, int numIndices, int primitiveType, int textureId);
+	virtual int registerGraphicsInstance(int shapeIndex, const float* position, const float* quaternion, const float* color, const float* scaling);
+	virtual void removeAllGraphicsInstances();
+	virtual void removeGraphicsInstance(int graphicsUid);
+	virtual void changeRGBAColor(int instanceUid, const double rgbaColor[4]);
+	virtual void changeScaling(int instanceUid, const double scaling[3]);
+
+	virtual Common2dCanvasInterface* get2dCanvasInterface();
+
+	virtual CommonParameterInterface* getParameterInterface();
+
+	virtual CommonRenderInterface* getRenderInterface();
+
+	virtual CommonGraphicsApp* getAppInterface();
+
+	virtual void setUpAxis(int axis);
+	
+	virtual void resetCamera(float camDist, float yaw, float pitch, float camPosX, float camPosY, float camPosZ);
+	
+	virtual void copyCameraImageData(const float viewMatrix[16], const float projectionMatrix[16],
+									 unsigned char* pixelsRGBA, int rgbaBufferSizeInPixels,
+									 float* depthBuffer, int depthBufferSizeInPixels,
+									 int* segmentationMaskBuffer, int segmentationMaskBufferSizeInPixels,
+									 int startPixelIndex, int width, int height, int* numPixelsCopied);
+
+	virtual void setProjectiveTextureMatrices(const float viewMatrix[16], const float projectionMatrix[16]);
+	
+	virtual void setProjectiveTexture(bool useProjectiveTexture);
+
+	virtual void autogenerateGraphicsObjects(btDiscreteDynamicsWorld* rbWorld);
+
+	virtual void drawText3D(const char* txt, float posX, float posZY, float posZ, float size);
+
+	virtual void drawText3D(const char* txt, float position[3], float orientation[4], float color[4], float size, int optionFlag);
+
+	virtual int addUserDebugLine(const double debugLineFromXYZ[3], const double debugLineToXYZ[3], const double debugLineColorRGB[3], double lineWidth, double lifeTime, int trackingVisualShapeIndex, int replaceItemUid);
+	virtual void removeUserDebugItem(int debugItemUniqueId);
+	virtual void removeAllUserDebugItems();
+
+	int uploadData(const unsigned char* data, int sizeInBytes, int slot);
+};
+
+#endif  //REMOTE_HELPER_H
diff --git a/engine/inc/bullet/SharedMemory/RemoteGUIHelperTCP.h b/engine/inc/bullet/SharedMemory/RemoteGUIHelperTCP.h
new file mode 100644
index 00000000..606eab58
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/RemoteGUIHelperTCP.h
@@ -0,0 +1,75 @@
+#ifndef REMOTE_HELPER_TCP_H
+#define REMOTE_HELPER_TCP_H
+
+#include "../CommonInterfaces/CommonGUIHelperInterface.h"
+
+///a RemoteGUIHelper will connect to an existing graphics server over TCP
+struct RemoteGUIHelperTCP : public GUIHelperInterface
+{
+	struct RemoteGUIHelperTCPInternalData* m_data;
+
+	RemoteGUIHelperTCP(const char* hostName, int port);
+
+	virtual ~RemoteGUIHelperTCP();
+
+	virtual void setVisualizerFlag(int flag, int enable);
+
+	virtual void createRigidBodyGraphicsObject(btRigidBody* body, const btVector3& color);
+
+	virtual void createCollisionObjectGraphicsObject(btCollisionObject* body, const btVector3& color);
+
+	virtual void createCollisionShapeGraphicsObject(btCollisionShape* collisionShape);
+
+	virtual bool getCameraInfo(int* width, int* height, float viewMatrix[16], float projectionMatrix[16], float camUp[3], float camForward[3], float hor[3], float vert[3], float* yaw, float* pitch, float* camDist, float camTarget[3]) const;
+
+	virtual void syncPhysicsToGraphics(const btDiscreteDynamicsWorld* rbWorld);
+	virtual void syncPhysicsToGraphics2(const class btDiscreteDynamicsWorld* rbWorld);
+	virtual void syncPhysicsToGraphics2(const GUISyncPosition* positions, int numPositions);
+
+	virtual void render(const btDiscreteDynamicsWorld* rbWorld);
+
+	virtual void createPhysicsDebugDrawer(btDiscreteDynamicsWorld* rbWorld);
+
+	virtual int registerTexture(const unsigned char* texels, int width, int height);
+	virtual int registerGraphicsShape(const float* vertices, int numvertices, const int* indices, int numIndices, int primitiveType, int textureId);
+	virtual int registerGraphicsInstance(int shapeIndex, const float* position, const float* quaternion, const float* color, const float* scaling);
+	virtual void removeAllGraphicsInstances();
+	virtual void removeGraphicsInstance(int graphicsUid);
+	virtual void changeRGBAColor(int instanceUid, const double rgbaColor[4]);
+
+	virtual Common2dCanvasInterface* get2dCanvasInterface();
+
+	virtual CommonParameterInterface* getParameterInterface();
+
+	virtual CommonRenderInterface* getRenderInterface();
+
+	virtual CommonGraphicsApp* getAppInterface();
+
+	virtual void setUpAxis(int axis);
+	
+	virtual void resetCamera(float camDist, float yaw, float pitch, float camPosX, float camPosY, float camPosZ);
+	
+	virtual void copyCameraImageData(const float viewMatrix[16], const float projectionMatrix[16],
+									 unsigned char* pixelsRGBA, int rgbaBufferSizeInPixels,
+									 float* depthBuffer, int depthBufferSizeInPixels,
+									 int* segmentationMaskBuffer, int segmentationMaskBufferSizeInPixels,
+									 int startPixelIndex, int width, int height, int* numPixelsCopied);
+
+	virtual void setProjectiveTextureMatrices(const float viewMatrix[16], const float projectionMatrix[16]);
+	
+	virtual void setProjectiveTexture(bool useProjectiveTexture);
+
+	virtual void autogenerateGraphicsObjects(btDiscreteDynamicsWorld* rbWorld);
+
+	virtual void drawText3D(const char* txt, float posX, float posZY, float posZ, float size);
+
+	virtual void drawText3D(const char* txt, float position[3], float orientation[4], float color[4], float size, int optionFlag);
+
+	virtual int addUserDebugLine(const double debugLineFromXYZ[3], const double debugLineToXYZ[3], const double debugLineColorRGB[3], double lineWidth, double lifeTime, int trackingVisualShapeIndex, int replaceItemUid);
+	virtual void removeUserDebugItem(int debugItemUniqueId);
+	virtual void removeAllUserDebugItems();
+
+	int uploadData(const unsigned char* data, int sizeInBytes, int slot);
+};
+
+#endif  //REMOTE_HELPER_TCP_H
diff --git a/engine/inc/bullet/SharedMemory/RobotControlExample.h b/engine/inc/bullet/SharedMemory/RobotControlExample.h
new file mode 100644
index 00000000..82bc81a7
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/RobotControlExample.h
@@ -0,0 +1,13 @@
+#ifndef ROBOT_CONTROL_EXAMPLE_H
+#define ROBOT_CONTROL_EXAMPLE_H
+
+enum EnumRobotControls
+{
+	ROBOT_VELOCITY_CONTROL = 0,
+	ROBOT_PD_CONTROL,
+	ROBOT_PING_PONG_JOINT_FEEDBACK,
+};
+
+class CommonExampleInterface* RobotControlExampleCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //ROBOT_CONTROL_EXAMPLE_H
diff --git a/engine/inc/bullet/SharedMemory/SharedMemoryBlock.h b/engine/inc/bullet/SharedMemory/SharedMemoryBlock.h
new file mode 100644
index 00000000..54d89698
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/SharedMemoryBlock.h
@@ -0,0 +1,44 @@
+#ifndef SHARED_MEMORY_BLOCK_H
+#define SHARED_MEMORY_BLOCK_H
+
+#define SHARED_MEMORY_MAX_COMMANDS 1
+
+#include "SharedMemoryCommands.h"
+
+struct SharedMemoryBlock
+{
+	int m_magicId;
+	struct SharedMemoryCommand m_clientCommands[SHARED_MEMORY_MAX_COMMANDS];
+	struct SharedMemoryStatus m_serverCommands[SHARED_MEMORY_MAX_COMMANDS];
+
+	int m_numClientCommands;
+	int m_numProcessedClientCommands;
+
+	int m_numServerCommands;
+	int m_numProcessedServerCommands;
+
+	
+	//m_bulletStreamDataServerToClient is used to send (debug) data from server to client, for
+	//example to provide all details of a multibody including joint/link names, after loading a URDF file.
+	char m_bulletStreamDataServerToClientRefactor[SHARED_MEMORY_MAX_STREAM_CHUNK_SIZE];
+};
+
+//http://stackoverflow.com/questions/24736304/unable-to-use-inline-in-declaration-get-error-c2054
+#ifdef _WIN32
+__inline
+#else
+inline
+#endif
+	void
+	InitSharedMemoryBlock(struct SharedMemoryBlock* sharedMemoryBlock)
+{
+	sharedMemoryBlock->m_numClientCommands = 0;
+	sharedMemoryBlock->m_numServerCommands = 0;
+	sharedMemoryBlock->m_numProcessedClientCommands = 0;
+	sharedMemoryBlock->m_numProcessedServerCommands = 0;
+	sharedMemoryBlock->m_magicId = SHARED_MEMORY_MAGIC_NUMBER;
+}
+
+#define SHARED_MEMORY_SIZE sizeof(SharedMemoryBlock)
+
+#endif  //SHARED_MEMORY_BLOCK_H
diff --git a/engine/inc/bullet/SharedMemory/SharedMemoryCommandProcessor.h b/engine/inc/bullet/SharedMemory/SharedMemoryCommandProcessor.h
new file mode 100644
index 00000000..80fff4ef
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/SharedMemoryCommandProcessor.h
@@ -0,0 +1,36 @@
+#ifndef SHARED_MEMORY_COMMAND_PROCESSOR_H
+#define SHARED_MEMORY_COMMAND_PROCESSOR_H
+
+#include "PhysicsCommandProcessorInterface.h"
+
+class SharedMemoryCommandProcessor : public PhysicsCommandProcessorInterface
+{
+	struct SharedMemoryCommandProcessorInternalData* m_data;
+
+public:
+	SharedMemoryCommandProcessor();
+
+	virtual ~SharedMemoryCommandProcessor();
+
+	virtual bool connect();
+
+	virtual void disconnect();
+
+	virtual bool isConnected() const;
+
+	virtual bool processCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+
+	virtual bool receiveStatus(struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+
+	virtual void renderScene(int renderFlags);
+	virtual void physicsDebugDraw(int debugDrawFlags);
+	virtual void setGuiHelper(struct GUIHelperInterface* guiHelper);
+
+	void setSharedMemoryInterface(class SharedMemoryInterface* sharedMem);
+	void setSharedMemoryKey(int key);
+	virtual void setTimeOut(double timeOutInSeconds);
+
+	virtual void reportNotifications() {}
+};
+
+#endif  //SHARED_MEMORY_COMMAND_PROCESSOR_H
diff --git a/engine/inc/bullet/SharedMemory/SharedMemoryCommands.h b/engine/inc/bullet/SharedMemory/SharedMemoryCommands.h
new file mode 100644
index 00000000..a019a58c
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/SharedMemoryCommands.h
@@ -0,0 +1,1283 @@
+#ifndef SHARED_MEMORY_COMMANDS_H
+#define SHARED_MEMORY_COMMANDS_H
+
+//this is a very experimental draft of commands. We will iterate on this API (commands, arguments etc)
+
+#include "SharedMemoryPublic.h"
+
+#ifdef __GNUC__
+#include <stdint.h>
+typedef int32_t smInt32_t;
+typedef int64_t smInt64_t;
+typedef uint32_t smUint32_t;
+typedef uint64_t smUint64_t;
+#elif defined(_MSC_VER)
+typedef __int32 smInt32_t;
+typedef __int64 smInt64_t;
+typedef unsigned __int32 smUint32_t;
+typedef unsigned __int64 smUint64_t;
+#else
+typedef int smInt32_t;
+typedef long long int smInt64_t;
+typedef unsigned int smUint32_t;
+typedef unsigned long long int smUint64_t;
+#endif
+
+#ifdef __APPLE__
+#define SHARED_MEMORY_MAX_STREAM_CHUNK_SIZE (1024 * 1024)
+#else
+#define SHARED_MEMORY_MAX_STREAM_CHUNK_SIZE (8 * 1024 * 1024)
+#endif
+
+#define SHARED_MEMORY_SERVER_TEST_C
+#define MAX_DEGREE_OF_FREEDOM 128
+#define MAX_NUM_SENSORS 256
+#define MAX_URDF_FILENAME_LENGTH 1024
+#define MAX_SDF_FILENAME_LENGTH 1024
+#define MAX_FILENAME_LENGTH MAX_URDF_FILENAME_LENGTH
+#define MAX_NUM_LINKS MAX_DEGREE_OF_FREEDOM
+
+
+struct TmpFloat3
+{
+	float m_x;
+	float m_y;
+	float m_z;
+};
+
+#ifdef _WIN32
+__inline
+#else
+inline
+#endif
+	TmpFloat3
+	CreateTmpFloat3(float x, float y, float z)
+{
+	TmpFloat3 tmp;
+	tmp.m_x = x;
+	tmp.m_y = y;
+	tmp.m_z = z;
+	return tmp;
+}
+
+enum EnumSdfArgsUpdateFlags
+{
+	SDF_ARGS_FILE_NAME = 1,
+};
+
+struct SdfArgs
+{
+	char m_sdfFileName[MAX_URDF_FILENAME_LENGTH];
+	int m_useMultiBody;
+	double m_globalScaling;
+};
+
+struct FileArgs
+{
+	char m_fileName[MAX_URDF_FILENAME_LENGTH];
+	int m_stateId;
+};
+
+enum EnumLoadStateArgsUpdateFlags
+{
+	CMD_LOAD_STATE_HAS_STATEID = 1,
+	CMD_LOAD_STATE_HAS_FILENAME = 2,
+};
+
+enum EnumUrdfArgsUpdateFlags
+{
+	URDF_ARGS_FILE_NAME = 1,
+	URDF_ARGS_INITIAL_POSITION = 2,
+	URDF_ARGS_INITIAL_ORIENTATION = 4,
+	URDF_ARGS_USE_MULTIBODY = 8,
+	URDF_ARGS_USE_FIXED_BASE = 16,
+	URDF_ARGS_HAS_CUSTOM_URDF_FLAGS = 32,
+	URDF_ARGS_USE_GLOBAL_SCALING = 64,
+};
+
+struct UrdfArgs
+{
+	char m_urdfFileName[MAX_URDF_FILENAME_LENGTH];
+	double m_initialPosition[3];
+	double m_initialOrientation[4];
+	int m_useMultiBody;
+	int m_useFixedBase;
+	int m_urdfFlags;
+	double m_globalScaling;
+};
+
+struct MjcfArgs
+{
+	char m_mjcfFileName[MAX_URDF_FILENAME_LENGTH];
+	int m_useMultiBody;
+	int m_flags;
+};
+
+struct b3SearchPathfArgs
+{
+	char m_path[MAX_FILENAME_LENGTH];
+};
+
+enum CustomCommandEnum
+{
+	CMD_CUSTOM_COMMAND_LOAD_PLUGIN = 1,
+	CMD_CUSTOM_COMMAND_UNLOAD_PLUGIN = 2,
+	CMD_CUSTOM_COMMAND_EXECUTE_PLUGIN_COMMAND = 4,
+	CMD_CUSTOM_COMMAND_LOAD_PLUGIN_POSTFIX = 8,
+};
+
+struct b3CustomCommand
+{
+	int m_pluginUniqueId;
+	b3PluginArguments m_arguments;
+	char m_pluginPath[MAX_FILENAME_LENGTH];
+	char m_postFix[MAX_FILENAME_LENGTH];
+	int m_startingReturnBytes;
+};
+
+struct b3CustomCommandResultArgs
+{
+	int m_pluginUniqueId;
+	int m_executeCommandResult;
+	int m_returnDataType;
+	int m_returnDataSizeInBytes;
+	int m_returnDataStart;
+};
+
+struct BulletDataStreamArgs
+{
+	char m_bulletFileName[MAX_FILENAME_LENGTH];
+	int m_bodyUniqueId;
+	char m_bodyName[MAX_FILENAME_LENGTH];
+};
+
+enum EnumChangeDynamicsInfoFlags
+{
+	CHANGE_DYNAMICS_INFO_SET_MASS = 1,
+	CHANGE_DYNAMICS_INFO_SET_COM = 2,
+	CHANGE_DYNAMICS_INFO_SET_LATERAL_FRICTION = 4,
+	CHANGE_DYNAMICS_INFO_SET_SPINNING_FRICTION = 8,
+	CHANGE_DYNAMICS_INFO_SET_ROLLING_FRICTION = 16,
+	CHANGE_DYNAMICS_INFO_SET_RESTITUTION = 32,
+	CHANGE_DYNAMICS_INFO_SET_LINEAR_DAMPING = 64,
+	CHANGE_DYNAMICS_INFO_SET_ANGULAR_DAMPING = 128,
+	CHANGE_DYNAMICS_INFO_SET_CONTACT_STIFFNESS_AND_DAMPING = 256,
+	CHANGE_DYNAMICS_INFO_SET_FRICTION_ANCHOR = 512,
+	CHANGE_DYNAMICS_INFO_SET_LOCAL_INERTIA_DIAGONAL = 1024,
+	CHANGE_DYNAMICS_INFO_SET_CCD_SWEPT_SPHERE_RADIUS = 2048,
+	CHANGE_DYNAMICS_INFO_SET_CONTACT_PROCESSING_THRESHOLD = 4096,
+	CHANGE_DYNAMICS_INFO_SET_ACTIVATION_STATE = 8192,
+	CHANGE_DYNAMICS_INFO_SET_JOINT_DAMPING = 16384,
+	CHANGE_DYNAMICS_INFO_SET_ANISOTROPIC_FRICTION = 32768,
+	CHANGE_DYNAMICS_INFO_SET_MAX_JOINT_VELOCITY = 1<<16,	
+	CHANGE_DYNAMICS_INFO_SET_COLLISION_MARGIN = 1 << 17,
+	CHANGE_DYNAMICS_INFO_SET_JOINT_LIMITS = 1 << 18,
+	CHANGE_DYNAMICS_INFO_SET_JOINT_LIMIT_MAX_FORCE = 1 << 19,
+	CHANGE_DYNAMICS_INFO_SET_DYNAMIC_TYPE = 1 << 20,
+};
+
+struct ChangeDynamicsInfoArgs
+{
+	int m_bodyUniqueId;
+	int m_linkIndex;
+	double m_mass;
+	double m_COM[3];
+	double m_lateralFriction;
+	double m_spinningFriction;
+	double m_rollingFriction;
+	double m_restitution;
+	double m_linearDamping;
+	double m_angularDamping;
+	double m_contactStiffness;
+	double m_contactDamping;
+	double m_localInertiaDiagonal[3];
+	int m_frictionAnchor;
+	double m_ccdSweptSphereRadius;
+	double m_contactProcessingThreshold;
+	int m_activationState;
+	double m_jointDamping;
+	double m_anisotropicFriction[3];
+	double m_maxJointVelocity;
+	double m_collisionMargin;
+	
+	double m_jointLowerLimit;
+	double m_jointUpperLimit;
+	double m_jointLimitForce;
+	
+	int m_dynamicType;
+};
+
+struct GetDynamicsInfoArgs
+{
+	int m_bodyUniqueId;
+	int m_linkIndex;
+};
+
+struct SetJointFeedbackArgs
+{
+	int m_bodyUniqueId;
+	int m_linkId;
+	int m_isEnabled;
+};
+
+enum EnumInitPoseFlags
+{
+	INIT_POSE_HAS_INITIAL_POSITION = 1,
+	INIT_POSE_HAS_INITIAL_ORIENTATION = 2,
+	INIT_POSE_HAS_JOINT_STATE = 4,
+	INIT_POSE_HAS_BASE_LINEAR_VELOCITY = 8,
+	INIT_POSE_HAS_BASE_ANGULAR_VELOCITY = 16,
+	INIT_POSE_HAS_JOINT_VELOCITY = 32,
+	INIT_POSE_HAS_SCALING=64,
+};
+
+///InitPoseArgs is mainly to initialize (teleport) the robot in a particular position
+///No motors or controls are needed to initialize the pose. It is similar to
+///moving a robot to a starting place, while it is switched off. It is only called
+///at the start of a robot control session. All velocities and control forces are cleared to zero.
+struct InitPoseArgs
+{
+	int m_bodyUniqueId;
+	int m_hasInitialStateQ[MAX_DEGREE_OF_FREEDOM];
+	double m_initialStateQ[MAX_DEGREE_OF_FREEDOM];
+	int m_hasInitialStateQdot[MAX_DEGREE_OF_FREEDOM];
+	double m_initialStateQdot[MAX_DEGREE_OF_FREEDOM];
+	double m_scaling[3];
+};
+
+struct RequestDebugLinesArgs
+{
+	int m_debugMode;
+	int m_startingLineIndex;
+};
+
+struct RequestPixelDataArgs
+{
+	float m_viewMatrix[16];
+	float m_projectionMatrix[16];
+	int m_startPixelIndex;
+	int m_pixelWidth;
+	int m_pixelHeight;
+	float m_lightDirection[3];
+	float m_lightColor[3];
+	float m_lightDistance;
+	float m_lightAmbientCoeff;
+	float m_lightDiffuseCoeff;
+	float m_lightSpecularCoeff;
+	int m_hasShadow;
+	int m_flags;
+	float m_projectiveTextureViewMatrix[16];
+	float m_projectiveTextureProjectionMatrix[16];
+};
+
+enum EnumRequestPixelDataUpdateFlags
+{
+	REQUEST_PIXEL_ARGS_HAS_CAMERA_MATRICES = 1,
+	REQUEST_PIXEL_ARGS_SET_PIXEL_WIDTH_HEIGHT = 2,
+	REQUEST_PIXEL_ARGS_SET_LIGHT_DIRECTION = 4,
+	REQUEST_PIXEL_ARGS_SET_LIGHT_COLOR = 8,
+	REQUEST_PIXEL_ARGS_SET_LIGHT_DISTANCE = 16,
+	REQUEST_PIXEL_ARGS_SET_SHADOW = 32,
+	REQUEST_PIXEL_ARGS_SET_AMBIENT_COEFF = 64,
+	REQUEST_PIXEL_ARGS_SET_DIFFUSE_COEFF = 128,
+	REQUEST_PIXEL_ARGS_SET_SPECULAR_COEFF = 256,
+	REQUEST_PIXEL_ARGS_HAS_FLAGS = 512,
+	REQUEST_PIXEL_ARGS_HAS_PROJECTIVE_TEXTURE_MATRICES = 1024,
+
+	//don't exceed (1<<15), because this enum is shared with EnumRenderer in SharedMemoryPublic.h
+
+};
+
+enum EnumRequestContactDataUpdateFlags
+{
+	CMD_REQUEST_CONTACT_POINT_HAS_QUERY_MODE = 1,
+	CMD_REQUEST_CONTACT_POINT_HAS_CLOSEST_DISTANCE_THRESHOLD = 2,
+	CMD_REQUEST_CONTACT_POINT_HAS_LINK_INDEX_A_FILTER = 4,
+	CMD_REQUEST_CONTACT_POINT_HAS_LINK_INDEX_B_FILTER = 8,
+
+	CMD_REQUEST_CONTACT_POINT_HAS_COLLISION_SHAPE_A = 16,
+	CMD_REQUEST_CONTACT_POINT_HAS_COLLISION_SHAPE_B = 32,
+	CMD_REQUEST_CONTACT_POINT_HAS_COLLISION_SHAPE_POSITION_A = 64,
+	CMD_REQUEST_CONTACT_POINT_HAS_COLLISION_SHAPE_POSITION_B = 128,
+	CMD_REQUEST_CONTACT_POINT_HAS_COLLISION_SHAPE_ORIENTATION_A = 256,
+	CMD_REQUEST_CONTACT_POINT_HAS_COLLISION_SHAPE_ORIENTATION_B = 512,
+
+};
+
+struct RequestRaycastIntersections
+{
+	// The number of threads that Bullet may use to perform the ray casts.
+	// 0: Let Bullet decide
+	// 1: Use a single thread (i.e. no multi-threading)
+	// 2 or more: Number of threads to use.
+	int m_numThreads;
+	int m_numCommandRays;
+	//m_numCommandRays command rays are stored in m_fromToRays
+	b3RayData m_fromToRays[MAX_RAY_INTERSECTION_BATCH_SIZE];
+
+	int m_numStreamingRays;
+	//optional m_parentObjectUniqueId (-1 for unused)
+	int m_parentObjectUniqueId;
+	int m_parentLinkIndex;
+	int m_reportHitNumber;
+	int m_collisionFilterMask;
+	double m_fractionEpsilon;
+	//streaming ray data stored in shared memory streaming part. (size m_numStreamingRays )
+};
+
+struct SendRaycastHits
+{
+	int m_numRaycastHits;
+	// Actual ray result data stored in shared memory streaming part.
+};
+
+struct RequestContactDataArgs
+{
+	int m_startingContactPointIndex;
+	int m_objectAIndexFilter;
+	int m_objectBIndexFilter;
+	int m_linkIndexAIndexFilter;
+	int m_linkIndexBIndexFilter;
+	double m_closestDistanceThreshold;
+
+	int m_collisionShapeA;
+	int m_collisionShapeB;
+	double m_collisionShapePositionA[3];
+	double m_collisionShapePositionB[3];
+	double m_collisionShapeOrientationA[4];
+	double m_collisionShapeOrientationB[4];
+
+	int m_mode;
+};
+
+struct RequestOverlappingObjectsArgs
+{
+	int m_startingOverlappingObjectIndex;
+	double m_aabbQueryMin[3];
+	double m_aabbQueryMax[3];
+};
+
+struct RequestVisualShapeDataArgs
+{
+	int m_bodyUniqueId;
+	int m_startingVisualShapeIndex;
+};
+
+struct RequestCollisionShapeDataArgs
+{
+	int m_bodyUniqueId;
+	int m_linkIndex;
+};
+
+enum EnumUpdateVisualShapeData
+{
+	CMD_UPDATE_VISUAL_SHAPE_TEXTURE = 1,
+	CMD_UPDATE_VISUAL_SHAPE_RGBA_COLOR = 2,
+	CMD_UPDATE_VISUAL_SHAPE_SPECULAR_COLOR = 4,
+	CMD_UPDATE_VISUAL_SHAPE_FLAGS = 8,
+};
+
+
+
+struct UpdateVisualShapeDataArgs
+{
+	int m_bodyUniqueId;
+	int m_jointIndex;
+	int m_shapeIndex;
+	int m_textureUniqueId;
+	double m_rgbaColor[4];
+	double m_specularColor[3];
+	int m_flags;
+};
+
+struct LoadTextureArgs
+{
+	char m_textureFileName[MAX_FILENAME_LENGTH];
+};
+
+struct b3LoadTextureResultArgs
+{
+	int m_textureUniqueId;
+};
+
+struct SendVisualShapeDataArgs
+{
+	int m_bodyUniqueId;
+	int m_startingVisualShapeIndex;
+	int m_numVisualShapesCopied;
+	int m_numRemainingVisualShapes;
+};
+
+struct SendCollisionShapeDataArgs
+{
+	int m_bodyUniqueId;
+	int m_linkIndex;
+	int m_numCollisionShapes;
+};
+
+struct SendDebugLinesArgs
+{
+	int m_startingLineIndex;
+	int m_numDebugLines;
+	int m_numRemainingDebugLines;
+};
+
+struct SendPixelDataArgs
+{
+	int m_imageWidth;
+	int m_imageHeight;
+
+	int m_startingPixelIndex;
+	int m_numPixelsCopied;
+	int m_numRemainingPixels;
+};
+
+struct PickBodyArgs
+{
+	double m_rayFromWorld[3];
+	double m_rayToWorld[3];
+};
+
+///Controlling a robot involves sending the desired state to its joint motor controllers.
+///The control mode determines the state variables used for motor control.
+struct SendDesiredStateArgs
+{
+	int m_bodyUniqueId;
+	int m_controlMode;
+
+	//PD parameters in case m_controlMode == CONTROL_MODE_POSITION_VELOCITY_PD
+	double m_Kp[MAX_DEGREE_OF_FREEDOM];  //indexed by degree of freedom, 6 for base, and then the dofs for each link
+	double m_Kd[MAX_DEGREE_OF_FREEDOM];  //indexed by degree of freedom, 6 for base, and then the dofs for each link
+	double m_rhsClamp[MAX_DEGREE_OF_FREEDOM];
+
+	int m_hasDesiredStateFlags[MAX_DEGREE_OF_FREEDOM];
+
+	//desired state is only written by the client, read-only access by server is expected
+
+	//m_desiredStateQ is indexed by position variables,
+	//starting with 3 base position variables, 4 base orientation variables (quaternion), then link position variables
+	double m_desiredStateQ[MAX_DEGREE_OF_FREEDOM];
+
+	//m_desiredStateQdot is index by velocity degrees of freedom, 3 linear and 3 angular variables for the base and then link velocity variables
+	double m_desiredStateQdot[MAX_DEGREE_OF_FREEDOM];
+
+	//m_desiredStateForceTorque is either the actual applied force/torque (in CONTROL_MODE_TORQUE) or
+	//or the maximum applied force/torque for the PD/motor/constraint to reach the desired velocity in CONTROL_MODE_VELOCITY and CONTROL_MODE_POSITION_VELOCITY_PD mode
+	//indexed by degree of freedom, 6 dof base, and then dofs for each link
+	double m_desiredStateForceTorque[MAX_DEGREE_OF_FREEDOM];
+};
+
+enum EnumSimDesiredStateUpdateFlags
+{
+	SIM_DESIRED_STATE_HAS_Q = 1,
+	SIM_DESIRED_STATE_HAS_QDOT = 2,
+	SIM_DESIRED_STATE_HAS_KD = 4,
+	SIM_DESIRED_STATE_HAS_KP = 8,
+	SIM_DESIRED_STATE_HAS_MAX_FORCE = 16,
+	SIM_DESIRED_STATE_HAS_RHS_CLAMP = 32,
+};
+
+enum EnumSimParamUpdateFlags
+{
+	SIM_PARAM_UPDATE_DELTA_TIME = 1,
+	SIM_PARAM_UPDATE_GRAVITY = 1<<1,
+	SIM_PARAM_UPDATE_NUM_SOLVER_ITERATIONS = 1<<2,
+	SIM_PARAM_UPDATE_NUM_SIMULATION_SUB_STEPS = 1<<3,
+	SIM_PARAM_UPDATE_REAL_TIME_SIMULATION = 1<<4,
+	SIM_PARAM_UPDATE_DEFAULT_CONTACT_ERP = 1<<5,
+	SIM_PARAM_UPDATE_INTERNAL_SIMULATION_FLAGS = 1<<6,
+	SIM_PARAM_UPDATE_USE_SPLIT_IMPULSE = 1<<7,
+	SIM_PARAM_UPDATE_SPLIT_IMPULSE_PENETRATION_THRESHOLD = 1<<8,
+	SIM_PARAM_UPDATE_COLLISION_FILTER_MODE = 1 << 9,
+	SIM_PARAM_UPDATE_CONTACT_BREAKING_THRESHOLD = 1 << 10,
+	SIM_PARAM_ENABLE_CONE_FRICTION = 1 << 11,
+	SIM_PARAM_ENABLE_FILE_CACHING = 1 << 12,
+	SIM_PARAM_UPDATE_RESTITUTION_VELOCITY_THRESHOLD = 1 << 13,
+	SIM_PARAM_UPDATE_DEFAULT_NON_CONTACT_ERP = 1 << 14,
+	SIM_PARAM_UPDATE_DEFAULT_FRICTION_ERP = 1 << 15,
+	SIM_PARAM_UPDATE_DETERMINISTIC_OVERLAPPING_PAIRS = 1 << 16,
+	SIM_PARAM_UPDATE_CCD_ALLOWED_PENETRATION = 1 << 17,
+	SIM_PARAM_UPDATE_JOINT_FEEDBACK_MODE = 1 << 18,
+	SIM_PARAM_UPDATE_DEFAULT_GLOBAL_CFM = 1 << 19,
+	SIM_PARAM_UPDATE_DEFAULT_FRICTION_CFM = 1 << 20,
+	SIM_PARAM_UPDATE_SOLVER_RESIDULAL_THRESHOLD = 1 << 21,
+	SIM_PARAM_UPDATE_CONTACT_SLOP = 1 << 22,
+	SIM_PARAM_ENABLE_SAT = 1 << 23,
+	SIM_PARAM_CONSTRAINT_SOLVER_TYPE = 1 << 24,
+	SIM_PARAM_CONSTRAINT_MIN_SOLVER_ISLAND_SIZE = 1 << 25,
+	SIM_PARAM_REPORT_CONSTRAINT_SOLVER_ANALYTICS = 1 << 26,
+	SIM_PARAM_UPDATE_WARM_STARTING_FACTOR = 1 << 27,
+	SIM_PARAM_UPDATE_ARTICULATED_WARM_STARTING_FACTOR = 1 << 28,
+	SIM_PARAM_UPDATE_SPARSE_SDF = 1 << 29,
+	SIM_PARAM_UPDATE_NUM_NONCONTACT_INNER_ITERATIONS = 1 << 30,
+};
+
+enum EnumLoadSoftBodyUpdateFlags
+{
+	LOAD_SOFT_BODY_FILE_NAME = 1,
+	LOAD_SOFT_BODY_UPDATE_SCALE = 1<<1,
+	LOAD_SOFT_BODY_UPDATE_MASS = 1<<2,
+	LOAD_SOFT_BODY_UPDATE_COLLISION_MARGIN = 1<<3,
+	LOAD_SOFT_BODY_INITIAL_POSITION = 1<<4,
+	LOAD_SOFT_BODY_INITIAL_ORIENTATION = 1<<5,
+	LOAD_SOFT_BODY_ADD_COROTATED_FORCE = 1<<6,
+	LOAD_SOFT_BODY_ADD_MASS_SPRING_FORCE = 1<<7,
+	LOAD_SOFT_BODY_ADD_GRAVITY_FORCE = 1<<8,
+	LOAD_SOFT_BODY_SET_COLLISION_HARDNESS = 1<<9,
+	LOAD_SOFT_BODY_SET_FRICTION_COEFFICIENT = 1<<10,
+	LOAD_SOFT_BODY_ADD_BENDING_SPRINGS = 1<<11,
+	LOAD_SOFT_BODY_ADD_NEOHOOKEAN_FORCE = 1<<12,
+	LOAD_SOFT_BODY_USE_SELF_COLLISION = 1<<13,
+	LOAD_SOFT_BODY_USE_FACE_CONTACT = 1<<14,
+	LOAD_SOFT_BODY_SIM_MESH = 1<<15,
+	LOAD_SOFT_BODY_SET_REPULSION_STIFFNESS = 1<<16,
+	LOAD_SOFT_BODY_SET_DAMPING_SPRING_MODE = 1<<17,
+	LOAD_SOFT_BODY_SET_GRAVITY_FACTOR = 1<<18,
+};
+
+enum EnumSimParamInternalSimFlags
+{
+	SIM_PARAM_INTERNAL_CREATE_ROBOT_ASSETS = 1,
+};
+
+///Controlling a robot involves sending the desired state to its joint motor controllers.
+///The control mode determines the state variables used for motor control.
+
+struct LoadSoftBodyArgs
+{
+	char m_fileName[MAX_FILENAME_LENGTH];
+	double m_scale;
+	double m_mass;
+	double m_collisionMargin;
+	double m_initialPosition[3];
+    double m_initialOrientation[4];
+    double m_springElasticStiffness;
+    double m_springDampingStiffness;
+	int m_dampAllDirections;
+    double m_springBendingStiffness;
+    double m_corotatedMu;
+    double m_corotatedLambda;
+    int m_useBendingSprings;
+    double m_collisionHardness;
+    int m_useSelfCollision;
+    double m_frictionCoeff;
+    double m_NeoHookeanMu;
+    double m_NeoHookeanLambda;
+    double m_NeoHookeanDamping;
+    int m_useFaceContact;
+    char m_simFileName[MAX_FILENAME_LENGTH];
+	double m_repulsionStiffness;
+	double m_gravFactor;
+};
+
+struct b3LoadSoftBodyResultArgs
+{
+	int m_objectUniqueId;
+};
+
+struct RequestActualStateArgs
+{
+	int m_bodyUniqueId;
+};
+
+struct SendActualStateArgs
+{
+	int m_bodyUniqueId;
+	int m_numLinks;
+	int m_numDegreeOfFreedomQ;
+	int m_numDegreeOfFreedomU;
+
+	double m_rootLocalInertialFrame[7];
+	struct SendActualStateSharedMemoryStorage* m_stateDetails;
+
+};
+
+struct SendActualStateSharedMemoryStorage
+{
+	//actual state is only written by the server, read-only access by client is expected
+	double m_actualStateQ[MAX_DEGREE_OF_FREEDOM];
+	double m_actualStateQdot[MAX_DEGREE_OF_FREEDOM];
+
+	//measured 6DOF force/torque sensors: force[x,y,z] and torque[x,y,z]
+	double m_jointReactionForces[6 * MAX_DEGREE_OF_FREEDOM];
+
+	double m_jointMotorForce[MAX_DEGREE_OF_FREEDOM];
+	double m_jointMotorForceMultiDof[MAX_DEGREE_OF_FREEDOM];
+
+	double m_linkState[7 * MAX_NUM_LINKS];
+	double m_linkWorldVelocities[6 * MAX_NUM_LINKS];  //linear velocity and angular velocity in world space (x/y/z each).
+	double m_linkLocalInertialFrames[7 * MAX_NUM_LINKS];
+};
+
+struct b3SendCollisionInfoArgs
+{
+	int m_numLinks;
+	double m_rootWorldAABBMin[3];
+	double m_rootWorldAABBMax[3];
+
+	double m_linkWorldAABBsMin[3 * MAX_NUM_LINKS];
+	double m_linkWorldAABBsMax[3 * MAX_NUM_LINKS];
+};
+
+struct b3RequestCollisionInfoArgs
+{
+	int m_bodyUniqueId;
+};
+
+enum EnumSensorTypes
+{
+	SENSOR_FORCE_TORQUE = 1,
+	SENSOR_IMU = 2,
+};
+
+struct CreateSensorArgs
+{
+	int m_bodyUniqueId;
+	int m_numJointSensorChanges;
+	int m_sensorType[MAX_DEGREE_OF_FREEDOM];
+
+	///todo: clean up the duplication, make sure no-one else is using those members directly (use C-API header instead)
+	int m_jointIndex[MAX_DEGREE_OF_FREEDOM];
+	int m_enableJointForceSensor[MAX_DEGREE_OF_FREEDOM];
+
+	int m_linkIndex[MAX_DEGREE_OF_FREEDOM];
+	int m_enableSensor[MAX_DEGREE_OF_FREEDOM];
+};
+
+typedef struct SharedMemoryCommand SharedMemoryCommand_t;
+
+enum EnumBoxShapeFlags
+{
+	BOX_SHAPE_HAS_INITIAL_POSITION = 1,
+	BOX_SHAPE_HAS_INITIAL_ORIENTATION = 2,
+	BOX_SHAPE_HAS_HALF_EXTENTS = 4,
+	BOX_SHAPE_HAS_MASS = 8,
+	BOX_SHAPE_HAS_COLLISION_SHAPE_TYPE = 16,
+	BOX_SHAPE_HAS_COLOR = 32,
+};
+///This command will be replaced to allow arbitrary collision shape types
+struct CreateBoxShapeArgs
+{
+	double m_halfExtentsX;
+	double m_halfExtentsY;
+	double m_halfExtentsZ;
+
+	double m_mass;
+	int m_collisionShapeType;  //see SharedMemoryPublic.h
+
+	double m_initialPosition[3];
+	double m_initialOrientation[4];
+	double m_colorRGBA[4];
+};
+
+struct b3ObjectArgs
+{
+	int m_numBodies;
+	int m_bodyUniqueIds[MAX_SDF_BODIES];
+	int m_numUserConstraints;
+	int m_userConstraintUniqueIds[MAX_SDF_BODIES];
+	int m_numUserCollisionShapes;
+	int m_userCollisionShapes[MAX_SDF_BODIES];
+};
+
+struct b3Profile
+{
+	char m_name[MAX_FILENAME_LENGTH];
+	int m_durationInMicroSeconds;
+	int m_type;
+};
+
+struct SdfLoadedArgs
+{
+	int m_numBodies;
+	int m_bodyUniqueIds[MAX_SDF_BODIES];
+	int m_numUserConstraints;
+	int m_userConstraintUniqueIds[MAX_SDF_BODIES];
+
+	///@todo(erwincoumans) load cameras, lights etc
+	//int m_numCameras;
+	//int m_numLights;
+};
+
+struct SdfRequestInfoArgs
+{
+	int m_bodyUniqueId;
+};
+
+///flags for b3ApplyExternalTorque and b3ApplyExternalForce
+enum EnumExternalForcePrivateFlags
+{
+	//    EF_LINK_FRAME=1,
+	//    EF_WORLD_FRAME=2,
+	EF_TORQUE = 4,
+	EF_FORCE = 8,
+};
+
+struct ExternalForceArgs
+{
+	int m_numForcesAndTorques;
+	int m_bodyUniqueIds[MAX_SDF_BODIES];
+	int m_linkIds[MAX_SDF_BODIES];
+	double m_forcesAndTorques[3 * MAX_SDF_BODIES];
+	double m_positions[3 * MAX_SDF_BODIES];
+	int m_forceFlags[MAX_SDF_BODIES];
+};
+
+enum EnumSdfRequestInfoFlags
+{
+	SDF_REQUEST_INFO_BODY = 1,
+	//SDF_REQUEST_INFO_CAMERA=2,
+};
+
+struct CalculateInverseDynamicsArgs
+{
+	int m_bodyUniqueId;
+	int m_dofCountQ;
+	int m_dofCountQdot;
+	double m_jointPositionsQ[MAX_DEGREE_OF_FREEDOM];
+	double m_jointVelocitiesQdot[MAX_DEGREE_OF_FREEDOM];
+	double m_jointAccelerations[MAX_DEGREE_OF_FREEDOM];
+	int m_flags;
+};
+
+struct CalculateInverseDynamicsResultArgs
+{
+	int m_bodyUniqueId;
+	int m_dofCount;
+	double m_jointForces[MAX_DEGREE_OF_FREEDOM];
+};
+
+struct CalculateJacobianArgs
+{
+	int m_bodyUniqueId;
+	int m_linkIndex;
+	double m_localPosition[3];
+	double m_jointPositionsQ[MAX_DEGREE_OF_FREEDOM];
+	double m_jointVelocitiesQdot[MAX_DEGREE_OF_FREEDOM];
+	double m_jointAccelerations[MAX_DEGREE_OF_FREEDOM];
+};
+
+struct CalculateJacobianResultArgs
+{
+	int m_dofCount;
+	double m_linearJacobian[3 * MAX_DEGREE_OF_FREEDOM];
+	double m_angularJacobian[3 * MAX_DEGREE_OF_FREEDOM];
+};
+
+struct CalculateMassMatrixArgs
+{
+	int m_bodyUniqueId;
+	double m_jointPositionsQ[MAX_DEGREE_OF_FREEDOM];
+	int m_dofCountQ;
+	int m_flags;
+};
+
+struct CalculateMassMatrixResultArgs
+{
+	int m_dofCount;
+};
+
+enum b3EnumCollisionFilterFlags
+{
+	B3_COLLISION_FILTER_PAIR = 1,
+	B3_COLLISION_FILTER_GROUP_MASK = 2,
+};
+
+struct b3CollisionFilterArgs
+{
+	int m_bodyUniqueIdA;
+	int m_bodyUniqueIdB;
+	int m_linkIndexA;
+	int m_linkIndexB;
+	int m_enableCollision;
+	int m_collisionFilterGroup;
+	int m_collisionFilterMask;
+};
+
+struct CalculateInverseKinematicsArgs
+{
+	int m_bodyUniqueId;
+	//	double m_jointPositionsQ[MAX_DEGREE_OF_FREEDOM];
+	double m_targetPositions[MAX_DEGREE_OF_FREEDOM*3];
+	int m_numEndEffectorLinkIndices;
+	double m_targetOrientation[MAX_DEGREE_OF_FREEDOM*4];  //orientation represented as quaternion, x,y,z,w
+	int m_endEffectorLinkIndices[MAX_DEGREE_OF_FREEDOM];
+	double m_lowerLimit[MAX_DEGREE_OF_FREEDOM];
+	double m_upperLimit[MAX_DEGREE_OF_FREEDOM];
+	double m_jointRange[MAX_DEGREE_OF_FREEDOM];
+	double m_restPose[MAX_DEGREE_OF_FREEDOM];
+	double m_jointDamping[MAX_DEGREE_OF_FREEDOM];
+	double m_currentPositions[MAX_DEGREE_OF_FREEDOM];
+	int m_maxNumIterations;
+	double m_residualThreshold;
+};
+
+struct CalculateInverseKinematicsResultArgs
+{
+	int m_bodyUniqueId;
+	int m_dofCount;
+	double m_jointPositions[MAX_DEGREE_OF_FREEDOM];
+};
+
+
+enum EnumBodyChangeFlags
+{
+	BODY_DELETE_FLAG = 1,
+};
+
+enum EnumUserDebugDrawFlags
+{
+	USER_DEBUG_HAS_LINE = 1,
+	USER_DEBUG_HAS_TEXT = 2,
+	USER_DEBUG_REMOVE_ONE_ITEM = 4,
+	USER_DEBUG_REMOVE_ALL = 8,
+	USER_DEBUG_SET_CUSTOM_OBJECT_COLOR = 16,
+	USER_DEBUG_REMOVE_CUSTOM_OBJECT_COLOR = 32,
+	USER_DEBUG_ADD_PARAMETER = 64,
+	USER_DEBUG_READ_PARAMETER = 128,
+	USER_DEBUG_HAS_OPTION_FLAGS = 256,
+	USER_DEBUG_HAS_TEXT_ORIENTATION = 512,
+	USER_DEBUG_HAS_PARENT_OBJECT = 1024,
+	USER_DEBUG_HAS_REPLACE_ITEM_UNIQUE_ID = 2048,
+	USER_DEBUG_REMOVE_ALL_PARAMETERS = 4096,
+};
+
+struct UserDebugDrawArgs
+{
+	double m_debugLineFromXYZ[3];
+	double m_debugLineToXYZ[3];
+	double m_debugLineColorRGB[3];
+	double m_lineWidth;
+
+	double m_lifeTime;
+	int m_itemUniqueId;
+
+	char m_text[MAX_FILENAME_LENGTH];
+	double m_textPositionXYZ[3];
+	double m_textOrientation[4];
+	int m_parentObjectUniqueId;
+	int m_parentLinkIndex;
+	double m_textColorRGB[3];
+	double m_textSize;
+	int m_optionFlags;
+	int m_replaceItemUniqueId;
+
+	double m_rangeMin;
+	double m_rangeMax;
+	double m_startValue;
+
+	double m_objectDebugColorRGB[3];
+	int m_objectUniqueId;
+	int m_linkIndex;
+};
+
+struct UserDebugDrawResultArgs
+{
+	int m_debugItemUniqueId;
+	double m_parameterValue;
+};
+
+struct SendVREvents
+{
+	int m_numVRControllerEvents;
+	b3VRControllerEvent m_controllerEvents[MAX_VR_CONTROLLERS];
+};
+
+struct SendKeyboardEvents
+{
+	int m_numKeyboardEvents;
+	b3KeyboardEvent m_keyboardEvents[MAX_KEYBOARD_EVENTS];
+};
+
+struct SendMouseEvents
+{
+	int m_numMouseEvents;
+	b3MouseEvent m_mouseEvents[MAX_MOUSE_EVENTS];
+};
+
+enum eVRCameraEnums
+{
+	VR_CAMERA_ROOT_POSITION = 1,
+	VR_CAMERA_ROOT_ORIENTATION = 2,
+	VR_CAMERA_ROOT_TRACKING_OBJECT = 4,
+	VR_CAMERA_FLAG = 8,
+};
+
+enum eStateLoggingEnums
+{
+	STATE_LOGGING_START_LOG = 1,
+	STATE_LOGGING_STOP_LOG = 2,
+	STATE_LOGGING_FILTER_OBJECT_UNIQUE_ID = 4,
+	STATE_LOGGING_MAX_LOG_DOF = 8,
+	STATE_LOGGING_FILTER_LINK_INDEX_A = 16,
+	STATE_LOGGING_FILTER_LINK_INDEX_B = 32,
+	STATE_LOGGING_FILTER_BODY_UNIQUE_ID_A = 64,
+	STATE_LOGGING_FILTER_BODY_UNIQUE_ID_B = 128,
+	STATE_LOGGING_FILTER_DEVICE_TYPE = 256,
+	STATE_LOGGING_LOG_FLAGS = 512
+};
+
+struct VRCameraState
+{
+	double m_rootPosition[3];
+	double m_rootOrientation[4];
+	int m_trackingObjectUniqueId;
+	int m_trackingObjectFlag;
+};
+
+struct StateLoggingRequest
+{
+	char m_fileName[MAX_FILENAME_LENGTH];
+	int m_logType;           //Minitaur, generic robot, VR states, contact points
+	int m_numBodyUniqueIds;  ////only if STATE_LOGGING_FILTER_OBJECT_UNIQUE_ID flag is set
+	int m_bodyUniqueIds[MAX_SDF_BODIES];
+	int m_loggingUniqueId;
+	int m_maxLogDof;
+	int m_linkIndexA;        // only if STATE_LOGGING_FILTER_LINK_INDEX_A flag is set
+	int m_linkIndexB;        // only if STATE_LOGGING_FILTER_LINK_INDEX_B flag is set
+	int m_bodyUniqueIdA;     // only if STATE_LOGGING_FILTER_BODY_UNIQUE_ID_A flag is set
+	int m_bodyUniqueIdB;     // only if STATE_LOGGING_FILTER_BODY_UNIQUE_ID_B flag is set
+	int m_deviceFilterType;  //user to select (filter) which VR devices to log
+	int m_logFlags;
+};
+
+struct StateLoggingResultArgs
+{
+	int m_loggingUniqueId;
+};
+
+enum InternalOpenGLVisualizerUpdateFlags
+{
+	COV_SET_CAMERA_VIEW_MATRIX = 1,
+	COV_SET_FLAGS = 2,
+	COV_SET_LIGHT_POSITION = 4,
+	COV_SET_SHADOWMAP_RESOLUTION = 8,
+	COV_SET_SHADOWMAP_WORLD_SIZE = 16,
+	COV_SET_REMOTE_SYNC_TRANSFORM_INTERVAL = 32,
+	COV_SET_SHADOWMAP_INTENSITY = 64,
+};
+
+struct ConfigureOpenGLVisualizerRequest
+{
+	double m_cameraDistance;
+	double m_cameraPitch;
+	double m_cameraYaw;
+	double m_cameraTargetPosition[3];
+	double m_lightPosition[3];
+	int m_shadowMapResolution;
+	int m_shadowMapWorldSize;
+	double m_remoteSyncTransformInterval;
+	int m_setFlag;
+	int m_setEnabled;
+	double m_shadowMapIntensity;
+};
+
+enum
+{
+	URDF_GEOM_HAS_RADIUS = 1,
+};
+
+struct b3CreateUserShapeData
+{
+	int m_type;  //see UrdfGeomTypes
+
+	int m_hasChildTransform;
+	double m_childPosition[3];
+	double m_childOrientation[4];
+
+	double m_sphereRadius;
+	double m_boxHalfExtents[3];
+	double m_capsuleRadius;
+	double m_capsuleHeight;
+	int m_hasFromTo;
+	double m_capsuleFrom[3];
+	double m_capsuleTo[3];
+	double m_planeNormal[3];
+	double m_planeConstant;
+
+	int m_meshFileType;
+	char m_meshFileName[VISUAL_SHAPE_MAX_PATH_LEN];
+	double m_meshScale[3];
+	int m_collisionFlags;
+	int m_visualFlags;
+	int m_numVertices;
+	int m_numIndices;
+	int m_numUVs;
+	int m_numNormals;
+	double m_heightfieldTextureScaling;
+	int m_numHeightfieldRows;
+	int m_numHeightfieldColumns;
+	double m_rgbaColor[4];
+	double m_specularColor[3];
+	int m_replaceHeightfieldIndex;
+};
+
+#define MAX_COMPOUND_COLLISION_SHAPES 16
+
+struct b3CreateUserShapeArgs
+{
+	int m_numUserShapes;
+	b3CreateUserShapeData m_shapes[MAX_COMPOUND_COLLISION_SHAPES];
+};
+
+
+
+struct b3CreateUserShapeResultArgs
+{
+	int m_userShapeUniqueId;
+};
+
+#define MAX_CREATE_MULTI_BODY_LINKS MAX_DEGREE_OF_FREEDOM
+enum eCreateMultiBodyEnum
+{
+	MULTI_BODY_HAS_BASE = 1,
+	MULT_BODY_USE_MAXIMAL_COORDINATES = 2,
+	MULT_BODY_HAS_FLAGS = 4,
+};
+struct b3CreateMultiBodyArgs
+{
+	char m_bodyName[1024];
+	int m_baseLinkIndex;
+
+	double m_linkPositions[3 * MAX_CREATE_MULTI_BODY_LINKS];
+	double m_linkOrientations[4 * MAX_CREATE_MULTI_BODY_LINKS];
+
+	int m_numLinks;
+	double m_linkMasses[MAX_CREATE_MULTI_BODY_LINKS];
+	double m_linkInertias[MAX_CREATE_MULTI_BODY_LINKS * 3];
+
+	double m_linkInertialFramePositions[MAX_CREATE_MULTI_BODY_LINKS * 3];
+	double m_linkInertialFrameOrientations[MAX_CREATE_MULTI_BODY_LINKS * 4];
+
+	int m_linkCollisionShapeUniqueIds[MAX_CREATE_MULTI_BODY_LINKS];
+	int m_linkVisualShapeUniqueIds[MAX_CREATE_MULTI_BODY_LINKS];
+	int m_linkParentIndices[MAX_CREATE_MULTI_BODY_LINKS];
+	int m_linkJointTypes[MAX_CREATE_MULTI_BODY_LINKS];
+	double m_linkJointAxis[3 * MAX_CREATE_MULTI_BODY_LINKS];
+	int m_flags;
+	int m_numBatchObjects;
+
+};
+
+struct b3CreateMultiBodyResultArgs
+{
+	int m_bodyUniqueId;
+};
+
+struct b3ChangeTextureArgs
+{
+	int m_textureUniqueId;
+	int m_width;
+	int m_height;
+};
+
+struct b3StateSerializationArguments
+{
+	char m_fileName[MAX_URDF_FILENAME_LENGTH];
+	int m_stateId;
+};
+
+struct SyncUserDataRequestArgs
+{
+	// The number of bodies for which we'd like to sync the user data of. When 0, all bodies are synced.
+	int m_numRequestedBodies;
+	// The body IDs for which we'd like to sync the user data of.
+	int m_requestedBodyIds[MAX_REQUESTED_BODIES_LENGTH];
+};
+
+struct SyncUserDataArgs
+{
+	// User data identifiers stored in m_bulletStreamDataServerToClientRefactor
+	// as as array of integers.
+	int m_numUserDataIdentifiers;
+	// Whether the client should clear its user data cache.
+	bool m_clearCachedUserDataEntries;
+};
+
+struct UserDataRequestArgs
+{
+	int m_userDataId;
+};
+
+struct UserDataResponseArgs
+{
+	int m_userDataId;
+	int m_bodyUniqueId;
+	int m_linkIndex;
+	int m_visualShapeIndex;
+	int m_valueType;
+	int m_valueLength;
+	char m_key[MAX_USER_DATA_KEY_LENGTH];
+	// Value data stored in m_bulletStreamDataServerToClientRefactor.
+};
+
+struct AddUserDataRequestArgs
+{
+	int m_bodyUniqueId;
+	int m_linkIndex;
+	int m_visualShapeIndex;
+	int m_valueType;
+	int m_valueLength;
+	char m_key[MAX_USER_DATA_KEY_LENGTH];
+	// Value data stored in m_bulletStreamDataServerToClientRefactor.
+};
+
+struct b3RequestMeshDataArgs
+{
+	int m_bodyUniqueId;
+	int m_linkIndex;
+	int m_startingVertex;
+	int m_collisionShapeIndex;
+	int m_flags;
+};
+
+struct b3SendMeshDataArgs
+{
+	int m_numVerticesCopied;
+	int m_startingVertex;
+	int m_numVerticesRemaining;
+};
+
+struct SharedMemoryCommand
+{
+	int m_type;
+	smUint64_t m_timeStamp;
+	int m_sequenceNumber;
+
+	//m_updateFlags is a bit fields to tell which parameters need updating
+	//for example m_updateFlags = SIM_PARAM_UPDATE_DELTA_TIME | SIM_PARAM_UPDATE_NUM_SOLVER_ITERATIONS;
+	int m_updateFlags;
+
+	union {
+		struct UrdfArgs m_urdfArguments;
+		struct SdfArgs m_sdfArguments;
+		struct MjcfArgs m_mjcfArguments;
+		struct FileArgs m_fileArguments;
+		struct SdfRequestInfoArgs m_sdfRequestInfoArgs;
+		struct ChangeDynamicsInfoArgs m_changeDynamicsInfoArgs;
+		struct GetDynamicsInfoArgs m_getDynamicsInfoArgs;
+		struct InitPoseArgs m_initPoseArgs;
+		struct b3PhysicsSimulationParameters m_physSimParamArgs;
+		struct BulletDataStreamArgs m_dataStreamArguments;
+		struct SendDesiredStateArgs m_sendDesiredStateCommandArgument;
+		struct RequestActualStateArgs m_requestActualStateInformationCommandArgument;
+		struct CreateSensorArgs m_createSensorArguments;
+		struct CreateBoxShapeArgs m_createBoxShapeArguments;
+		struct RequestDebugLinesArgs m_requestDebugLinesArguments;
+		struct RequestPixelDataArgs m_requestPixelDataArguments;
+		struct PickBodyArgs m_pickBodyArguments;
+		struct ExternalForceArgs m_externalForceArguments;
+		struct CalculateInverseDynamicsArgs m_calculateInverseDynamicsArguments;
+		struct CalculateJacobianArgs m_calculateJacobianArguments;
+		struct CalculateMassMatrixArgs m_calculateMassMatrixArguments;
+		struct b3UserConstraint m_userConstraintArguments;
+		struct RequestContactDataArgs m_requestContactPointArguments;
+		struct RequestOverlappingObjectsArgs m_requestOverlappingObjectsArgs;
+		struct RequestVisualShapeDataArgs m_requestVisualShapeDataArguments;
+		struct UpdateVisualShapeDataArgs m_updateVisualShapeDataArguments;
+		struct LoadTextureArgs m_loadTextureArguments;
+		struct CalculateInverseKinematicsArgs m_calculateInverseKinematicsArguments;
+		struct UserDebugDrawArgs m_userDebugDrawArgs;
+		struct RequestRaycastIntersections m_requestRaycastIntersections;
+		struct LoadSoftBodyArgs m_loadSoftBodyArguments;
+		struct VRCameraState m_vrCameraStateArguments;
+		struct StateLoggingRequest m_stateLoggingArguments;
+		struct ConfigureOpenGLVisualizerRequest m_configureOpenGLVisualizerArguments;
+		struct b3ObjectArgs m_removeObjectArgs;
+		struct b3Profile m_profile;
+		struct b3CreateUserShapeArgs m_createUserShapeArgs;
+		struct b3CreateMultiBodyArgs m_createMultiBodyArgs;
+		struct b3RequestCollisionInfoArgs m_requestCollisionInfoArgs;
+		struct b3ChangeTextureArgs m_changeTextureArgs;
+		struct b3SearchPathfArgs m_searchPathArgs;
+		struct b3CustomCommand m_customCommandArgs;
+		struct b3StateSerializationArguments m_loadStateArguments;
+		struct RequestCollisionShapeDataArgs m_requestCollisionShapeDataArguments;
+		struct SyncUserDataRequestArgs m_syncUserDataRequestArgs;
+		struct UserDataRequestArgs m_userDataRequestArgs;
+		struct AddUserDataRequestArgs m_addUserDataRequestArgs;
+		struct UserDataRequestArgs m_removeUserDataRequestArgs;
+		struct b3CollisionFilterArgs m_collisionFilterArgs;
+		struct b3RequestMeshDataArgs m_requestMeshDataArgs;
+	};
+};
+
+struct RigidBodyCreateArgs
+{
+	int m_bodyUniqueId;
+};
+
+struct SendContactDataArgs
+{
+	int m_startingContactPointIndex;
+	int m_numContactPointsCopied;
+	int m_numRemainingContactPoints;
+};
+
+struct SendOverlappingObjectsArgs
+{
+	int m_startingOverlappingObjectIndex;
+	int m_numOverlappingObjectsCopied;
+	int m_numRemainingOverlappingObjects;
+};
+
+struct SharedMemoryStatus
+{
+	int m_type;
+
+	smUint64_t m_timeStamp;
+	int m_sequenceNumber;
+
+	//m_streamBytes is only for internal purposes
+	int m_numDataStreamBytes;
+	char* m_dataStream;
+
+	//m_updateFlags is a bit fields to tell which parameters were updated,
+	//m_updateFlags is ignored for most status messages
+	int m_updateFlags;
+
+	union {
+		struct BulletDataStreamArgs m_dataStreamArguments;
+		struct SdfLoadedArgs m_sdfLoadedArgs;
+		struct SendActualStateArgs m_sendActualStateArgs;
+		struct SendDebugLinesArgs m_sendDebugLinesArgs;
+		struct SendPixelDataArgs m_sendPixelDataArguments;
+		struct RigidBodyCreateArgs m_rigidBodyCreateArgs;
+		struct CalculateInverseDynamicsResultArgs m_inverseDynamicsResultArgs;
+		struct CalculateJacobianResultArgs m_jacobianResultArgs;
+		struct CalculateMassMatrixResultArgs m_massMatrixResultArgs;
+		struct SendContactDataArgs m_sendContactPointArgs;
+		struct SendOverlappingObjectsArgs m_sendOverlappingObjectsArgs;
+		struct CalculateInverseKinematicsResultArgs m_inverseKinematicsResultArgs;
+		struct SendVisualShapeDataArgs m_sendVisualShapeArgs;
+		struct UserDebugDrawResultArgs m_userDebugDrawArgs;
+		struct b3UserConstraint m_userConstraintResultArgs;
+		struct b3UserConstraintState m_userConstraintStateResultArgs;
+		struct SendVREvents m_sendVREvents;
+		struct SendKeyboardEvents m_sendKeyboardEvents;
+		struct SendRaycastHits m_raycastHits;
+		struct StateLoggingResultArgs m_stateLoggingResultArgs;
+		struct b3OpenGLVisualizerCameraInfo m_visualizerCameraResultArgs;
+		struct b3ObjectArgs m_removeObjectArgs;
+		struct b3DynamicsInfo m_dynamicsInfo;
+		struct b3CreateUserShapeResultArgs m_createUserShapeResultArgs;
+		struct b3CreateMultiBodyResultArgs m_createMultiBodyResultArgs;
+		struct b3SendCollisionInfoArgs m_sendCollisionInfoArgs;
+		struct SendMouseEvents m_sendMouseEvents;
+		struct b3LoadTextureResultArgs m_loadTextureResultArguments;
+		struct b3CustomCommandResultArgs m_customCommandResultArgs;
+		struct b3PhysicsSimulationParameters m_simulationParameterResultArgs;
+		struct b3StateSerializationArguments m_saveStateResultArgs;
+		struct b3LoadSoftBodyResultArgs m_loadSoftBodyResultArguments;
+		struct SendCollisionShapeDataArgs m_sendCollisionShapeArgs;
+		struct SyncUserDataArgs m_syncUserDataArgs;
+		struct UserDataResponseArgs m_userDataResponseArgs;
+		struct UserDataRequestArgs m_removeUserDataResponseArgs;
+		struct b3ForwardDynamicsAnalyticsArgs m_forwardDynamicsAnalyticsArgs;
+		struct b3SendMeshDataArgs m_sendMeshDataArgs;
+	};
+};
+
+typedef struct SharedMemoryStatus SharedMemoryStatus_t;
+
+#endif  //SHARED_MEMORY_COMMANDS_H
diff --git a/engine/inc/bullet/SharedMemory/SharedMemoryCommon.h b/engine/inc/bullet/SharedMemory/SharedMemoryCommon.h
new file mode 100644
index 00000000..d31f0fe9
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/SharedMemoryCommon.h
@@ -0,0 +1,21 @@
+#ifndef SHARED_MEMORY_COMMON_H
+#define SHARED_MEMORY_COMMON_H
+
+#include "../CommonInterfaces/CommonMultiBodyBase.h"
+
+class SharedMemoryCommon : public CommonExampleInterface
+{
+protected:
+	struct GUIHelperInterface* m_guiHelper;
+
+public:
+	SharedMemoryCommon(GUIHelperInterface* helper)
+		: m_guiHelper(helper)
+	{
+	}
+
+	virtual void setSharedMemoryKey(int key) = 0;
+	virtual bool wantsTermination() = 0;
+	virtual bool isConnected() = 0;
+};
+#endif  //
diff --git a/engine/inc/bullet/SharedMemory/SharedMemoryInProcessPhysicsC_API.h b/engine/inc/bullet/SharedMemory/SharedMemoryInProcessPhysicsC_API.h
new file mode 100644
index 00000000..7b7472b4
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/SharedMemoryInProcessPhysicsC_API.h
@@ -0,0 +1,43 @@
+
+#ifndef IN_PROCESS_PHYSICS_C_API_H
+#define IN_PROCESS_PHYSICS_C_API_H
+
+#include "PhysicsClientC_API.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	///think more about naming. The b3ConnectPhysicsLoopback
+	B3_SHARED_API b3PhysicsClientHandle b3CreateInProcessPhysicsServerAndConnect(int argc, char* argv[]);
+	B3_SHARED_API b3PhysicsClientHandle b3CreateInProcessPhysicsServerAndConnectMainThread(int argc, char* argv[]);
+
+	B3_SHARED_API b3PhysicsClientHandle b3CreateInProcessPhysicsServerAndConnectSharedMemory(int argc, char* argv[]);
+	B3_SHARED_API b3PhysicsClientHandle b3CreateInProcessPhysicsServerAndConnectMainThreadSharedMemory(int argc, char* argv[]);
+
+	B3_SHARED_API b3PhysicsClientHandle b3CreateInProcessGraphicsServerAndConnectSharedMemory(int port);
+	B3_SHARED_API b3PhysicsClientHandle b3CreateInProcessGraphicsServerAndConnectMainThreadSharedMemory(int port);
+	
+
+	B3_SHARED_API b3PhysicsClientHandle b3CreateInProcessPhysicsServerFromExistingExampleBrowserAndConnect(void* guiHelperPtr);
+	//create a shared memory physics server, with a DummyGUIHelper (no graphics)
+	B3_SHARED_API b3PhysicsClientHandle b3CreateInProcessPhysicsServerFromExistingExampleBrowserAndConnect2(void* guiHelperPtr);
+	//create a shared memory physics server, with a DummyGUIHelper (no graphics) and allow to set shared memory key
+	B3_SHARED_API b3PhysicsClientHandle b3CreateInProcessPhysicsServerFromExistingExampleBrowserAndConnect3(void* guiHelperPtr, int sharedMemoryKey);
+	//create a shared memory physics server, with a RemoteGUIHelper (connect to remote graphics server) and allow to set shared memory key
+	B3_SHARED_API b3PhysicsClientHandle b3CreateInProcessPhysicsServerFromExistingExampleBrowserAndConnect4(void* guiHelperPtr, int sharedMemoryKey);
+#ifdef BT_ENABLE_CLSOCKET
+	B3_SHARED_API b3PhysicsClientHandle b3CreateInProcessPhysicsServerFromExistingExampleBrowserAndConnectTCP(const char* hostName, int port);
+#endif	
+	///ignore the following APIs, they are for internal use for example browser
+	void b3InProcessRenderSceneInternal(b3PhysicsClientHandle clientHandle);
+	void b3InProcessDebugDrawInternal(b3PhysicsClientHandle clientHandle, int debugDrawMode);
+	int b3InProcessMouseMoveCallback(b3PhysicsClientHandle clientHandle, float x, float y);
+	int b3InProcessMouseButtonCallback(b3PhysicsClientHandle clientHandle, int button, int state, float x, float y);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  //IN_PROCESS_PHYSICS_C_API_H
diff --git a/engine/inc/bullet/SharedMemory/SharedMemoryInterface.h b/engine/inc/bullet/SharedMemory/SharedMemoryInterface.h
new file mode 100644
index 00000000..af3f3297
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/SharedMemoryInterface.h
@@ -0,0 +1,15 @@
+#ifndef SHARED_MEMORY_INTERFACE_H
+#define SHARED_MEMORY_INTERFACE_H
+
+class SharedMemoryInterface
+{
+public:
+	virtual ~SharedMemoryInterface()
+	{
+	}
+
+	virtual void* allocateSharedMemory(int key, int size, bool allowCreation) = 0;
+	virtual void releaseSharedMemory(int key, int size) = 0;
+};
+
+#endif
diff --git a/engine/inc/bullet/SharedMemory/SharedMemoryPublic.h b/engine/inc/bullet/SharedMemory/SharedMemoryPublic.h
new file mode 100644
index 00000000..775f9f70
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/SharedMemoryPublic.h
@@ -0,0 +1,1115 @@
+#ifndef SHARED_MEMORY_PUBLIC_H
+#define SHARED_MEMORY_PUBLIC_H
+
+#define SHARED_MEMORY_KEY 12347
+///increase the SHARED_MEMORY_MAGIC_NUMBER whenever incompatible changes are made in the structures
+///my convention is year/month/day/rev
+//Please don't replace an existing magic number:
+//instead, only ADD a new one at the top, comment-out previous one
+
+
+
+#define SHARED_MEMORY_MAGIC_NUMBER 202010061
+//#define SHARED_MEMORY_MAGIC_NUMBER 202007060
+//#define SHARED_MEMORY_MAGIC_NUMBER 202005070
+//#define SHARED_MEMORY_MAGIC_NUMBER 202002030
+//#define SHARED_MEMORY_MAGIC_NUMBER 202001230
+//#define SHARED_MEMORY_MAGIC_NUMBER 201911280
+//#define SHARED_MEMORY_MAGIC_NUMBER 201911180
+//#define SHARED_MEMORY_MAGIC_NUMBER 201909030
+//#define SHARED_MEMORY_MAGIC_NUMBER 201908110
+//#define SHARED_MEMORY_MAGIC_NUMBER 201908050
+//#define SHARED_MEMORY_MAGIC_NUMBER 2019060190
+//#define SHARED_MEMORY_MAGIC_NUMBER 201904030
+//#define SHARED_MEMORY_MAGIC_NUMBER 201902120
+//#define SHARED_MEMORY_MAGIC_NUMBER 201811260
+//#define SHARED_MEMORY_MAGIC_NUMBER 201810250
+//#define SHARED_MEMORY_MAGIC_NUMBER 201809030
+//#define SHARED_MEMORY_MAGIC_NUMBER 201809010
+//#define SHARED_MEMORY_MAGIC_NUMBER 201807040
+//#define SHARED_MEMORY_MAGIC_NUMBER 201806150
+//#define SHARED_MEMORY_MAGIC_NUMBER 201806020
+//#define SHARED_MEMORY_MAGIC_NUMBER 201801170
+//#define SHARED_MEMORY_MAGIC_NUMBER 201801080
+//#define SHARED_MEMORY_MAGIC_NUMBER 201801010
+//#define SHARED_MEMORY_MAGIC_NUMBER 201710180
+//#define SHARED_MEMORY_MAGIC_NUMBER 201710050
+//#define SHARED_MEMORY_MAGIC_NUMBER 201708270
+//#define SHARED_MEMORY_MAGIC_NUMBER 201707140
+//#define SHARED_MEMORY_MAGIC_NUMBER 201706015
+//#define SHARED_MEMORY_MAGIC_NUMBER 201706001
+//#define SHARED_MEMORY_MAGIC_NUMBER 201703024
+
+enum EnumSharedMemoryClientCommand
+{
+	CMD_INVALID = 0,
+	CMD_LOAD_SDF,
+	CMD_LOAD_URDF,
+	CMD_LOAD_BULLET,
+	CMD_SAVE_BULLET,
+	CMD_LOAD_MJCF,
+	CMD_LOAD_SOFT_BODY,
+	CMD_SEND_BULLET_DATA_STREAM,
+	CMD_CREATE_BOX_COLLISION_SHAPE,
+	CMD_CREATE_RIGID_BODY,
+	CMD_DELETE_RIGID_BODY,
+	CMD_CREATE_SENSOR,  ///enable or disable joint feedback for force/torque sensors
+	CMD_INIT_POSE,
+	CMD_SEND_PHYSICS_SIMULATION_PARAMETERS,
+	CMD_SEND_DESIRED_STATE,  //todo: reconsider naming, for example SET_JOINT_CONTROL_VARIABLE?
+	CMD_REQUEST_ACTUAL_STATE,
+	CMD_REQUEST_DEBUG_LINES,
+	CMD_REQUEST_BODY_INFO,
+	CMD_REQUEST_INTERNAL_DATA,
+	CMD_STEP_FORWARD_SIMULATION,
+	CMD_RESET_SIMULATION,
+	CMD_PICK_BODY,
+	CMD_MOVE_PICKED_BODY,
+	CMD_REMOVE_PICKING_CONSTRAINT_BODY,
+	CMD_REQUEST_CAMERA_IMAGE_DATA,
+	CMD_APPLY_EXTERNAL_FORCE,
+	CMD_CALCULATE_INVERSE_DYNAMICS,
+	CMD_CALCULATE_INVERSE_KINEMATICS,
+	CMD_CALCULATE_JACOBIAN,
+	CMD_CALCULATE_MASS_MATRIX,
+	CMD_USER_CONSTRAINT,
+	CMD_REQUEST_CONTACT_POINT_INFORMATION,
+	CMD_REQUEST_RAY_CAST_INTERSECTIONS,
+
+	CMD_REQUEST_AABB_OVERLAP,
+
+	CMD_SAVE_WORLD,
+	CMD_REQUEST_VISUAL_SHAPE_INFO,
+	CMD_UPDATE_VISUAL_SHAPE,
+	CMD_LOAD_TEXTURE,
+	CMD_SET_SHADOW,
+	CMD_USER_DEBUG_DRAW,
+	CMD_REQUEST_VR_EVENTS_DATA,
+	CMD_SET_VR_CAMERA_STATE,
+	CMD_SYNC_BODY_INFO,
+	CMD_STATE_LOGGING,
+	CMD_CONFIGURE_OPENGL_VISUALIZER,
+	CMD_REQUEST_KEYBOARD_EVENTS_DATA,
+	CMD_REQUEST_OPENGL_VISUALIZER_CAMERA,
+	CMD_REMOVE_BODY,
+	CMD_CHANGE_DYNAMICS_INFO,
+	CMD_GET_DYNAMICS_INFO,
+	CMD_PROFILE_TIMING,
+	CMD_CREATE_COLLISION_SHAPE,
+	CMD_CREATE_VISUAL_SHAPE,
+	CMD_CREATE_MULTI_BODY,
+	CMD_REQUEST_COLLISION_INFO,
+	CMD_REQUEST_MOUSE_EVENTS_DATA,
+	CMD_CHANGE_TEXTURE,
+	CMD_SET_ADDITIONAL_SEARCH_PATH,
+	CMD_CUSTOM_COMMAND,
+	CMD_REQUEST_PHYSICS_SIMULATION_PARAMETERS,
+	CMD_SAVE_STATE,
+	CMD_RESTORE_STATE,
+	CMD_REMOVE_STATE,
+	CMD_REQUEST_COLLISION_SHAPE_INFO,
+
+	CMD_SYNC_USER_DATA,
+	CMD_REQUEST_USER_DATA,
+	CMD_ADD_USER_DATA,
+	CMD_REMOVE_USER_DATA,
+	CMD_COLLISION_FILTER,
+	CMD_REQUEST_MESH_DATA,
+
+	//don't go beyond this command!
+	CMD_MAX_CLIENT_COMMANDS,
+};
+
+enum EnumSharedMemoryServerStatus
+{
+	CMD_SHARED_MEMORY_NOT_INITIALIZED = 0,
+	CMD_WAITING_FOR_CLIENT_COMMAND,
+	//CMD_CLIENT_COMMAND_COMPLETED is a generic 'completed' status that doesn't need special handling on the client
+	CMD_CLIENT_COMMAND_COMPLETED,
+	//the server will skip unknown command and report a status 'CMD_UNKNOWN_COMMAND_FLUSHED'
+	CMD_UNKNOWN_COMMAND_FLUSHED,
+	CMD_SDF_LOADING_COMPLETED,
+	CMD_SDF_LOADING_FAILED,
+	CMD_URDF_LOADING_COMPLETED,
+	CMD_URDF_LOADING_FAILED,
+	CMD_BULLET_LOADING_COMPLETED,
+	CMD_BULLET_LOADING_FAILED,
+	CMD_BULLET_SAVING_COMPLETED,
+	CMD_BULLET_SAVING_FAILED,
+	CMD_MJCF_LOADING_COMPLETED,
+	CMD_MJCF_LOADING_FAILED,
+	CMD_REQUEST_INTERNAL_DATA_COMPLETED,
+	CMD_REQUEST_INTERNAL_DATA_FAILED,
+	CMD_BULLET_DATA_STREAM_RECEIVED_COMPLETED,
+	CMD_BULLET_DATA_STREAM_RECEIVED_FAILED,
+	CMD_BOX_COLLISION_SHAPE_CREATION_COMPLETED,
+	CMD_RIGID_BODY_CREATION_COMPLETED,
+	CMD_SET_JOINT_FEEDBACK_COMPLETED,
+	CMD_ACTUAL_STATE_UPDATE_COMPLETED,
+	CMD_ACTUAL_STATE_UPDATE_FAILED,
+	CMD_DEBUG_LINES_COMPLETED,
+	CMD_DEBUG_LINES_OVERFLOW_FAILED,
+	CMD_DESIRED_STATE_RECEIVED_COMPLETED,
+	CMD_STEP_FORWARD_SIMULATION_COMPLETED,
+	CMD_RESET_SIMULATION_COMPLETED,
+	CMD_CAMERA_IMAGE_COMPLETED,
+	CMD_CAMERA_IMAGE_FAILED,
+	CMD_BODY_INFO_COMPLETED,
+	CMD_BODY_INFO_FAILED,
+	CMD_INVALID_STATUS,
+	CMD_CALCULATED_INVERSE_DYNAMICS_COMPLETED,
+	CMD_CALCULATED_INVERSE_DYNAMICS_FAILED,
+	CMD_CALCULATED_JACOBIAN_COMPLETED,
+	CMD_CALCULATED_JACOBIAN_FAILED,
+	CMD_CALCULATED_MASS_MATRIX_COMPLETED,
+	CMD_CALCULATED_MASS_MATRIX_FAILED,
+	CMD_CONTACT_POINT_INFORMATION_COMPLETED,
+	CMD_CONTACT_POINT_INFORMATION_FAILED,
+	CMD_REQUEST_AABB_OVERLAP_COMPLETED,
+	CMD_REQUEST_AABB_OVERLAP_FAILED,
+	CMD_CALCULATE_INVERSE_KINEMATICS_COMPLETED,
+	CMD_CALCULATE_INVERSE_KINEMATICS_FAILED,
+	CMD_SAVE_WORLD_COMPLETED,
+	CMD_SAVE_WORLD_FAILED,
+	CMD_VISUAL_SHAPE_INFO_COMPLETED,
+	CMD_VISUAL_SHAPE_INFO_FAILED,
+	CMD_VISUAL_SHAPE_UPDATE_COMPLETED,
+	CMD_VISUAL_SHAPE_UPDATE_FAILED,
+	CMD_LOAD_TEXTURE_COMPLETED,
+	CMD_LOAD_TEXTURE_FAILED,
+	CMD_USER_DEBUG_DRAW_COMPLETED,
+	CMD_USER_DEBUG_DRAW_PARAMETER_COMPLETED,
+	CMD_USER_DEBUG_DRAW_FAILED,
+	CMD_USER_CONSTRAINT_COMPLETED,
+	CMD_USER_CONSTRAINT_INFO_COMPLETED,
+	CMD_USER_CONSTRAINT_REQUEST_STATE_COMPLETED,
+	CMD_REMOVE_USER_CONSTRAINT_COMPLETED,
+	CMD_CHANGE_USER_CONSTRAINT_COMPLETED,
+	CMD_REMOVE_USER_CONSTRAINT_FAILED,
+	CMD_CHANGE_USER_CONSTRAINT_FAILED,
+	CMD_USER_CONSTRAINT_FAILED,
+	CMD_REQUEST_VR_EVENTS_DATA_COMPLETED,
+	CMD_REQUEST_RAY_CAST_INTERSECTIONS_COMPLETED,
+	CMD_SYNC_BODY_INFO_COMPLETED,
+	CMD_SYNC_BODY_INFO_FAILED,
+	CMD_STATE_LOGGING_COMPLETED,
+	CMD_STATE_LOGGING_START_COMPLETED,
+	CMD_STATE_LOGGING_FAILED,
+	CMD_REQUEST_KEYBOARD_EVENTS_DATA_COMPLETED,
+	CMD_REQUEST_KEYBOARD_EVENTS_DATA_FAILED,
+	CMD_REQUEST_OPENGL_VISUALIZER_CAMERA_FAILED,
+	CMD_REQUEST_OPENGL_VISUALIZER_CAMERA_COMPLETED,
+	CMD_REMOVE_BODY_COMPLETED,
+	CMD_REMOVE_BODY_FAILED,
+	CMD_GET_DYNAMICS_INFO_COMPLETED,
+	CMD_GET_DYNAMICS_INFO_FAILED,
+	CMD_CREATE_COLLISION_SHAPE_FAILED,
+	CMD_CREATE_COLLISION_SHAPE_COMPLETED,
+	CMD_CREATE_VISUAL_SHAPE_FAILED,
+	CMD_CREATE_VISUAL_SHAPE_COMPLETED,
+	CMD_CREATE_MULTI_BODY_FAILED,
+	CMD_CREATE_MULTI_BODY_COMPLETED,
+	CMD_REQUEST_COLLISION_INFO_COMPLETED,
+	CMD_REQUEST_COLLISION_INFO_FAILED,
+	CMD_REQUEST_MOUSE_EVENTS_DATA_COMPLETED,
+	CMD_CHANGE_TEXTURE_COMMAND_FAILED,
+	CMD_CUSTOM_COMMAND_COMPLETED,
+	CMD_CUSTOM_COMMAND_FAILED,
+	CMD_REQUEST_PHYSICS_SIMULATION_PARAMETERS_COMPLETED,
+	CMD_SAVE_STATE_FAILED,
+	CMD_SAVE_STATE_COMPLETED,
+	CMD_RESTORE_STATE_FAILED,
+	CMD_RESTORE_STATE_COMPLETED,
+	CMD_COLLISION_SHAPE_INFO_COMPLETED,
+	CMD_COLLISION_SHAPE_INFO_FAILED,
+	CMD_LOAD_SOFT_BODY_FAILED,
+	CMD_LOAD_SOFT_BODY_COMPLETED,
+
+	CMD_SYNC_USER_DATA_COMPLETED,
+	CMD_SYNC_USER_DATA_FAILED,
+	CMD_REQUEST_USER_DATA_COMPLETED,
+	CMD_REQUEST_USER_DATA_FAILED,
+	CMD_ADD_USER_DATA_COMPLETED,
+	CMD_ADD_USER_DATA_FAILED,
+	CMD_REMOVE_USER_DATA_COMPLETED,
+	CMD_REMOVE_USER_DATA_FAILED,
+	CMD_REMOVE_STATE_COMPLETED,
+	CMD_REMOVE_STATE_FAILED,
+
+	CMD_REQUEST_MESH_DATA_COMPLETED,
+	CMD_REQUEST_MESH_DATA_FAILED,
+
+	//don't go beyond 'CMD_MAX_SERVER_COMMANDS!
+	CMD_MAX_SERVER_COMMANDS
+};
+
+enum JointInfoFlags
+{
+	JOINT_HAS_MOTORIZED_POWER = 1,
+};
+
+enum
+{
+	COLLISION_SHAPE_TYPE_BOX = 1,
+	COLLISION_SHAPE_TYPE_CYLINDER_X,
+	COLLISION_SHAPE_TYPE_CYLINDER_Y,
+	COLLISION_SHAPE_TYPE_CYLINDER_Z,
+	COLLISION_SHAPE_TYPE_CAPSULE_X,
+	COLLISION_SHAPE_TYPE_CAPSULE_Y,
+	COLLISION_SHAPE_TYPE_CAPSULE_Z,
+	COLLISION_SHAPE_TYPE_SPHERE
+};
+
+// copied from btMultiBodyLink.h
+enum JointType
+{
+	eRevoluteType = 0,
+	ePrismaticType = 1,
+	eSphericalType = 2,
+	ePlanarType = 3,
+	eFixedType = 4,
+	ePoint2PointType = 5,
+	eGearType = 6
+};
+
+enum b3JointInfoFlags
+{
+	eJointChangeMaxForce = 1,
+	eJointChangeChildFramePosition = 2,
+	eJointChangeChildFrameOrientation = 4,
+};
+
+struct b3JointInfo
+{
+	char m_linkName[1024];
+	char m_jointName[1024];
+	int m_jointType;
+	int m_qIndex;
+	int m_uIndex;
+	int m_jointIndex;
+	int m_flags;
+	double m_jointDamping;
+	double m_jointFriction;
+	double m_jointLowerLimit;
+	double m_jointUpperLimit;
+	double m_jointMaxForce;
+	double m_jointMaxVelocity;
+	double m_parentFrame[7];  // position and orientation (quaternion)
+	double m_childFrame[7];   // ^^^
+	double m_jointAxis[3];    // joint axis in parent local frame
+	int m_parentIndex;
+	int m_qSize;
+	int m_uSize;
+};
+
+enum UserDataValueType
+{
+	// Data represents generic byte array.
+	USER_DATA_VALUE_TYPE_BYTES = 0,
+	// Data represents C-string
+	USER_DATA_VALUE_TYPE_STRING = 1,
+};
+
+struct b3UserDataValue
+{
+	int m_type;
+	int m_length;
+	const char* m_data1;
+};
+
+enum EnumUserConstraintFlags
+{
+	USER_CONSTRAINT_ADD_CONSTRAINT = 1,
+	USER_CONSTRAINT_REMOVE_CONSTRAINT = 2,
+	USER_CONSTRAINT_CHANGE_CONSTRAINT = 4,
+	USER_CONSTRAINT_CHANGE_PIVOT_IN_B = 8,
+	USER_CONSTRAINT_CHANGE_FRAME_ORN_IN_B = 16,
+	USER_CONSTRAINT_CHANGE_MAX_FORCE = 32,
+	USER_CONSTRAINT_REQUEST_INFO = 64,
+	USER_CONSTRAINT_CHANGE_GEAR_RATIO = 128,
+	USER_CONSTRAINT_CHANGE_GEAR_AUX_LINK = 256,
+	USER_CONSTRAINT_CHANGE_RELATIVE_POSITION_TARGET = 512,
+	USER_CONSTRAINT_CHANGE_ERP = 1024,
+	USER_CONSTRAINT_REQUEST_STATE = 2048,
+	USER_CONSTRAINT_ADD_SOFT_BODY_ANCHOR = 4096,
+};
+
+struct b3UserConstraint
+{
+	int m_parentBodyIndex;
+	int m_parentJointIndex;
+	int m_childBodyIndex;
+	int m_childJointIndex;
+	double m_parentFrame[7];
+	double m_childFrame[7];
+	double m_jointAxis[3];
+	int m_jointType;
+	double m_maxAppliedForce;
+	int m_userConstraintUniqueId;
+	double m_gearRatio;
+	int m_gearAuxLink;
+	double m_relativePositionTarget;
+	double m_erp;
+};
+
+struct b3BodyInfo
+{
+	char m_baseName[1024];
+	char m_bodyName[1024];  // for btRigidBody, it does not have a base, but can still have a body name from urdf
+};
+
+enum DynamicsActivationState
+{
+	eActivationStateEnableSleeping = 1,
+	eActivationStateDisableSleeping = 2,
+	eActivationStateWakeUp = 4,
+	eActivationStateSleep = 8,
+	eActivationStateEnableWakeup = 16,
+	eActivationStateDisableWakeup = 32,
+};
+
+enum b3BodyType
+{
+	BT_RIGID_BODY = 1,
+	BT_MULTI_BODY = 2,
+	BT_SOFT_BODY = 3,
+};
+
+struct b3DynamicsInfo
+{
+	double m_mass;
+	double m_localInertialDiagonal[3];
+	double m_localInertialFrame[7];
+	double m_lateralFrictionCoeff;
+
+	double m_rollingFrictionCoeff;
+	double m_spinningFrictionCoeff;
+	double m_restitution;
+	double m_contactStiffness;
+	double m_contactDamping;
+	int m_activationState;
+	int m_bodyType;
+	double m_angularDamping;
+	double m_linearDamping;
+	double m_ccdSweptSphereRadius;
+	double m_contactProcessingThreshold;
+	int m_frictionAnchor;
+	double m_collisionMargin;
+	int m_dynamicType;
+};
+
+// copied from btMultiBodyLink.h
+enum SensorType
+{
+	eSensorForceTorqueType = 1,
+};
+
+struct b3JointSensorState
+{
+	double m_jointPosition;
+	double m_jointVelocity;
+	double m_jointForceTorque[6]; /* note to roboticists: this is NOT the motor torque/force, but the spatial reaction force vector at joint */
+	double m_jointMotorTorque;
+};
+
+struct b3JointSensorState2
+{
+	double m_jointPosition[4];
+	double m_jointVelocity[3];
+	double m_jointReactionForceTorque[6]; /* note to roboticists: this is NOT the motor torque/force, but the spatial reaction force vector at joint */
+	double m_jointMotorTorqueMultiDof[3];
+	int m_qDofSize;
+	int m_uDofSize;
+};
+
+struct b3DebugLines
+{
+	int m_numDebugLines;
+	const float* m_linesFrom;   //float x,y,z times 'm_numDebugLines'.
+	const float* m_linesTo;     //float x,y,z times 'm_numDebugLines'.
+	const float* m_linesColor;  //float red,green,blue times 'm_numDebugLines'.
+};
+
+struct b3OverlappingObject
+{
+	int m_objectUniqueId;
+	int m_linkIndex;
+};
+
+struct b3AABBOverlapData
+{
+	int m_numOverlappingObjects;
+	struct b3OverlappingObject* m_overlappingObjects;
+};
+
+struct b3CameraImageData
+{
+	int m_pixelWidth;
+	int m_pixelHeight;
+	const unsigned char* m_rgbColorData;  //3*m_pixelWidth*m_pixelHeight bytes
+	const float* m_depthValues;           //m_pixelWidth*m_pixelHeight floats
+	const int* m_segmentationMaskValues;  //m_pixelWidth*m_pixelHeight ints
+};
+
+struct b3MeshVertex
+{
+	double x, y, z, w;
+};
+
+
+enum eMeshDataFlags
+{
+	B3_MESH_DATA_SIMULATION_MESH=1,
+	B3_MESH_DATA_SIMULATION_INDICES,
+	B3_MESH_DATA_GRAPHICS_INDICES,
+};
+
+enum eMeshDataEnum
+{
+	B3_MESH_DATA_COLLISIONSHAPEINDEX=1,
+	B3_MESH_DATA_FLAGS=2,
+};
+
+struct b3MeshData
+{
+	int m_numVertices;
+	struct b3MeshVertex* m_vertices;
+};
+
+struct b3OpenGLVisualizerCameraInfo
+{
+	int m_width;
+	int m_height;
+	float m_viewMatrix[16];
+	float m_projectionMatrix[16];
+
+	float m_camUp[3];
+	float m_camForward[3];
+
+	float m_horizontal[3];
+	float m_vertical[3];
+
+	float m_yaw;
+	float m_pitch;
+	float m_dist;
+	float m_target[3];
+};
+
+struct b3UserConstraintState
+{
+	double m_appliedConstraintForces[6];
+	int m_numDofs;
+};
+
+enum b3VREventType
+{
+	VR_CONTROLLER_MOVE_EVENT = 1,
+	VR_CONTROLLER_BUTTON_EVENT = 2,
+	VR_HMD_MOVE_EVENT = 4,
+	VR_GENERIC_TRACKER_MOVE_EVENT = 8,
+};
+
+#define MAX_VR_ANALOG_AXIS 5
+#define MAX_VR_BUTTONS 64
+#define MAX_VR_CONTROLLERS 8
+
+#define MAX_KEYBOARD_EVENTS 256
+#define MAX_MOUSE_EVENTS 256
+
+#define MAX_SDF_BODIES 512
+#define MAX_USER_DATA_KEY_LENGTH 256
+#define MAX_REQUESTED_BODIES_LENGTH 256
+
+enum b3VRButtonInfo
+{
+	eButtonIsDown = 1,
+	eButtonTriggered = 2,
+	eButtonReleased = 4,
+};
+
+enum eVRDeviceTypeEnums
+{
+	VR_DEVICE_CONTROLLER = 1,
+	VR_DEVICE_HMD = 2,
+	VR_DEVICE_GENERIC_TRACKER = 4,
+};
+
+enum EVRCameraFlags
+{
+	VR_CAMERA_TRACK_OBJECT_ORIENTATION = 1,
+};
+
+struct b3VRControllerEvent
+{
+	int m_controllerId;  //valid for VR_CONTROLLER_MOVE_EVENT and VR_CONTROLLER_BUTTON_EVENT
+	int m_deviceType;
+	int m_numMoveEvents;
+	int m_numButtonEvents;
+
+	float m_pos[4];  //valid for VR_CONTROLLER_MOVE_EVENT and VR_CONTROLLER_BUTTON_EVENT
+	float m_orn[4];  //valid for VR_CONTROLLER_MOVE_EVENT and VR_CONTROLLER_BUTTON_EVENT
+
+	float m_analogAxis;                             //valid if VR_CONTROLLER_MOVE_EVENT
+	float m_auxAnalogAxis[MAX_VR_ANALOG_AXIS * 2];  //store x,y per axis, only valid if VR_CONTROLLER_MOVE_EVENT
+	int m_buttons[MAX_VR_BUTTONS];                  //valid if VR_CONTROLLER_BUTTON_EVENT, see b3VRButtonInfo
+};
+
+struct b3VREventsData
+{
+	int m_numControllerEvents;
+	struct b3VRControllerEvent* m_controllerEvents;
+};
+
+struct b3KeyboardEvent
+{
+	int m_keyCode;   //ascii
+	int m_keyState;  // see b3VRButtonInfo
+};
+
+struct b3KeyboardEventsData
+{
+	int m_numKeyboardEvents;
+	struct b3KeyboardEvent* m_keyboardEvents;
+};
+
+enum eMouseEventTypeEnums
+{
+	MOUSE_MOVE_EVENT = 1,
+	MOUSE_BUTTON_EVENT = 2,
+};
+
+struct b3MouseEvent
+{
+	int m_eventType;
+	float m_mousePosX;
+	float m_mousePosY;
+	int m_buttonIndex;
+	int m_buttonState;
+};
+
+struct b3MouseEventsData
+{
+	int m_numMouseEvents;
+	struct b3MouseEvent* m_mouseEvents;
+};
+
+enum b3NotificationType
+{
+	SIMULATION_RESET = 0,
+	BODY_ADDED = 1,
+	BODY_REMOVED = 2,
+	USER_DATA_ADDED = 3,
+	USER_DATA_REMOVED = 4,
+	LINK_DYNAMICS_CHANGED = 5,
+	VISUAL_SHAPE_CHANGED = 6,
+	TRANSFORM_CHANGED = 7,
+	SIMULATION_STEPPED = 8,
+	SOFTBODY_CHANGED = 9,
+};
+
+enum b3ResetSimulationFlags
+{
+	RESET_USE_DEFORMABLE_WORLD=1,
+	RESET_USE_DISCRETE_DYNAMICS_WORLD=2,
+	RESET_USE_SIMPLE_BROADPHASE=4,
+};
+
+struct b3BodyNotificationArgs
+{
+	int m_bodyUniqueId;
+};
+
+struct b3UserDataNotificationArgs
+{
+	int m_bodyUniqueId;
+	int m_linkIndex;
+	int m_visualShapeIndex;
+	int m_userDataId;
+	char m_key[MAX_USER_DATA_KEY_LENGTH];
+};
+
+struct b3LinkNotificationArgs
+{
+	int m_bodyUniqueId;
+	int m_linkIndex;
+};
+
+struct b3VisualShapeNotificationArgs
+{
+	int m_bodyUniqueId;
+	int m_linkIndex;
+	int m_visualShapeIndex;
+};
+
+struct b3TransformChangeNotificationArgs
+{
+	int m_bodyUniqueId;
+	int m_linkIndex;
+	double m_worldPosition[3];
+	double m_worldRotation[4];
+	double m_localScaling[3];
+};
+
+struct b3SoftBodyChangeNotificationArgs
+{
+	int m_bodyUniqueId;
+	int m_linkIndex;
+};
+
+struct b3Notification
+{
+	int m_notificationType;
+	union {
+		struct b3BodyNotificationArgs m_bodyArgs;
+		struct b3UserDataNotificationArgs m_userDataArgs;
+		struct b3LinkNotificationArgs m_linkArgs;
+		struct b3VisualShapeNotificationArgs m_visualShapeArgs;
+		struct b3TransformChangeNotificationArgs m_transformChangeArgs;
+		struct b3SoftBodyChangeNotificationArgs m_softBodyChangeArgs;
+	};
+};
+
+struct b3ContactPointData
+{
+	//todo: expose some contact flags, such as telling which fields below are valid
+	int m_contactFlags;
+	int m_bodyUniqueIdA;
+	int m_bodyUniqueIdB;
+	int m_linkIndexA;
+	int m_linkIndexB;
+	double m_positionOnAInWS[3];       //contact point location on object A, in world space coordinates
+	double m_positionOnBInWS[3];       //contact point location on object A, in world space coordinates
+	double m_contactNormalOnBInWS[3];  //the separating contact normal, pointing from object B towards object A
+	double m_contactDistance;          //negative number is penetration, positive is distance.
+
+	double m_normalForce;
+
+	double m_linearFrictionForce1;
+	double m_linearFrictionForce2;
+	double m_linearFrictionDirection1[3];
+	double m_linearFrictionDirection2[3];
+};
+
+enum
+{
+	CONTACT_QUERY_MODE_REPORT_EXISTING_CONTACT_POINTS = 0,
+	CONTACT_QUERY_MODE_COMPUTE_CLOSEST_POINTS = 1,
+};
+
+enum b3StateLoggingType
+{
+	STATE_LOGGING_MINITAUR = 0,
+	STATE_LOGGING_GENERIC_ROBOT = 1,
+	STATE_LOGGING_VR_CONTROLLERS = 2,
+	STATE_LOGGING_VIDEO_MP4 = 3,
+	STATE_LOGGING_COMMANDS = 4,
+	STATE_LOGGING_CONTACT_POINTS = 5,
+	STATE_LOGGING_PROFILE_TIMINGS = 6,
+	STATE_LOGGING_ALL_COMMANDS = 7,
+	STATE_REPLAY_ALL_COMMANDS = 8,
+	STATE_LOGGING_CUSTOM_TIMER = 9,
+};
+
+struct b3ContactInformation
+{
+	int m_numContactPoints;
+	struct b3ContactPointData* m_contactPointData;
+};
+
+struct b3RayData
+{
+	double m_rayFromPosition[3];
+	double m_rayToPosition[3];
+};
+
+struct b3RayHitInfo
+{
+	double m_hitFraction;
+	int m_hitObjectUniqueId;
+	int m_hitObjectLinkIndex;
+	double m_hitPositionWorld[3];
+	double m_hitNormalWorld[3];
+};
+
+struct b3RaycastInformation
+{
+	int m_numRayHits;
+	struct b3RayHitInfo* m_rayHits;
+};
+
+typedef union {
+	struct b3RayData a;
+	struct b3RayHitInfo b;
+} RAY_DATA_UNION;
+
+#define MAX_RAY_INTERSECTION_BATCH_SIZE 256
+
+#ifdef __APPLE__
+#define MAX_RAY_INTERSECTION_BATCH_SIZE_STREAMING (4 * 1024)
+#else
+#define MAX_RAY_INTERSECTION_BATCH_SIZE_STREAMING (16 * 1024)
+#endif
+
+#define MAX_RAY_HITS MAX_RAY_INTERSECTION_BATCH_SIZE
+#define VISUAL_SHAPE_MAX_PATH_LEN 1024
+
+enum b3VisualShapeDataFlags
+{
+	eVISUAL_SHAPE_DATA_TEXTURE_UNIQUE_IDS = 1,
+};
+
+struct b3VisualShapeData
+{
+	int m_objectUniqueId;
+	int m_linkIndex;
+	int m_visualGeometryType;  //box primitive, sphere primitive, triangle mesh
+	double m_dimensions[3];    //meaning depends on m_visualGeometryType
+	char m_meshAssetFileName[VISUAL_SHAPE_MAX_PATH_LEN];
+	double m_localVisualFrame[7];  //pos[3], orn[4]
+								   //todo: add more data if necessary (material color etc, although material can be in asset file .obj file)
+	double m_rgbaColor[4];
+	int m_tinyRendererTextureId;
+	int m_textureUniqueId;
+	int m_openglTextureId;
+};
+
+struct b3VisualShapeInformation
+{
+	int m_numVisualShapes;
+	struct b3VisualShapeData* m_visualShapeData;
+};
+
+struct b3CollisionShapeData
+{
+	int m_objectUniqueId;
+	int m_linkIndex;
+	int m_collisionGeometryType;      //GEOM_BOX, GEOM_SPHERE etc
+	double m_dimensions[3];           //meaning depends on m_visualGeometryType GEOM_BOX: extents, GEOM_SPHERE: radius, GEOM_CAPSULE+GEOM_CYLINDER:length, radius, GEOM_MESH: mesh scale
+	double m_localCollisionFrame[7];  //pos[3], orn[4]
+	char m_meshAssetFileName[VISUAL_SHAPE_MAX_PATH_LEN];
+};
+
+struct b3CollisionShapeInformation
+{
+	int m_numCollisionShapes;
+	struct b3CollisionShapeData* m_collisionShapeData;
+};
+
+enum eLinkStateFlags
+{
+	ACTUAL_STATE_COMPUTE_LINKVELOCITY = 1,
+	ACTUAL_STATE_COMPUTE_FORWARD_KINEMATICS = 2,
+};
+
+///b3LinkState provides extra information such as the Cartesian world coordinates
+///center of mass (COM) of the link, relative to the world reference frame.
+///Orientation is a quaternion x,y,z,w
+///Note: to compute the URDF link frame (which equals the joint frame at joint position 0)
+///use URDF link frame = link COM frame * inertiaFrame.inverse()
+struct b3LinkState
+{
+	//m_worldPosition and m_worldOrientation of the Center Of Mass (COM)
+	double m_worldPosition[3];
+	double m_worldOrientation[4];
+
+	double m_localInertialPosition[3];
+	double m_localInertialOrientation[4];
+
+	///world position and orientation of the (URDF) link frame
+	double m_worldLinkFramePosition[3];
+	double m_worldLinkFrameOrientation[4];
+
+	double m_worldLinearVelocity[3];   //only valid when ACTUAL_STATE_COMPUTE_LINKVELOCITY is set (b3RequestActualStateCommandComputeLinkVelocity)
+	double m_worldAngularVelocity[3];  //only valid when ACTUAL_STATE_COMPUTE_LINKVELOCITY is set (b3RequestActualStateCommandComputeLinkVelocity)
+
+	double m_worldAABBMin[3];  //world space bounding minium and maximum box corners.
+	double m_worldAABBMax[3];
+};
+
+//todo: discuss and decide about control mode and combinations
+enum
+{
+	//    POSITION_CONTROL=0,
+	CONTROL_MODE_VELOCITY = 0,
+	CONTROL_MODE_TORQUE,
+	CONTROL_MODE_POSITION_VELOCITY_PD,
+	CONTROL_MODE_PD,  // The standard PD control implemented as soft constraint.
+	CONTROL_MODE_STABLE_PD,
+};
+
+///flags for b3ApplyExternalTorque and b3ApplyExternalForce
+enum EnumExternalForceFlags
+{
+	EF_LINK_FRAME = 1,
+	EF_WORLD_FRAME = 2,
+};
+
+///flags to pick the renderer for synthetic camera
+enum EnumRenderer
+{
+	ER_TINY_RENDERER = (1 << 16),
+	ER_BULLET_HARDWARE_OPENGL = (1 << 17),
+	//ER_FIRE_RAYS=(1<<18),
+};
+
+enum EnumRendererAuxFlags
+{
+	ER_SEGMENTATION_MASK_OBJECT_AND_LINKINDEX = 1,
+	ER_USE_PROJECTIVE_TEXTURE = 2,
+	ER_NO_SEGMENTATION_MASK = 4,
+};
+
+///flags to pick the IK solver and other options
+enum EnumCalculateInverseKinematicsFlags
+{
+	IK_DLS = 0,
+	IK_SDLS = 1,  //TODO: can add other IK solvers
+	IK_HAS_TARGET_POSITION = 16,
+	IK_HAS_TARGET_ORIENTATION = 32,
+	IK_HAS_NULL_SPACE_VELOCITY = 64,
+	IK_HAS_JOINT_DAMPING = 128,
+	IK_HAS_CURRENT_JOINT_POSITIONS = 256,
+	IK_HAS_MAX_ITERATIONS = 512,
+	IK_HAS_RESIDUAL_THRESHOLD = 1024,
+};
+
+enum b3ConfigureDebugVisualizerEnum
+{
+	COV_ENABLE_GUI = 1,
+	COV_ENABLE_SHADOWS,
+	COV_ENABLE_WIREFRAME,
+	COV_ENABLE_VR_TELEPORTING,
+	COV_ENABLE_VR_PICKING,
+	COV_ENABLE_VR_RENDER_CONTROLLERS,
+	COV_ENABLE_RENDERING,
+	COV_ENABLE_SYNC_RENDERING_INTERNAL,
+	COV_ENABLE_KEYBOARD_SHORTCUTS,
+	COV_ENABLE_MOUSE_PICKING,
+	COV_ENABLE_Y_AXIS_UP,
+	COV_ENABLE_TINY_RENDERER,
+	COV_ENABLE_RGB_BUFFER_PREVIEW,
+	COV_ENABLE_DEPTH_BUFFER_PREVIEW,
+	COV_ENABLE_SEGMENTATION_MARK_PREVIEW,
+	COV_ENABLE_PLANAR_REFLECTION,
+	COV_ENABLE_SINGLE_STEP_RENDERING,
+};
+
+enum b3AddUserDebugItemEnum
+{
+	DEB_DEBUG_TEXT_ALWAYS_FACE_CAMERA = 1,
+	DEB_DEBUG_TEXT_USE_TRUE_TYPE_FONTS = 2,
+	DEB_DEBUG_TEXT_HAS_TRACKING_OBJECT = 4,
+};
+
+enum eCONNECT_METHOD
+{
+	eCONNECT_GUI = 1,
+	eCONNECT_DIRECT = 2,
+	eCONNECT_SHARED_MEMORY = 3,
+	eCONNECT_UDP = 4,
+	eCONNECT_TCP = 5,
+	eCONNECT_EXISTING_EXAMPLE_BROWSER = 6,
+	eCONNECT_GUI_SERVER = 7,
+	eCONNECT_GUI_MAIN_THREAD = 8,
+	eCONNECT_SHARED_MEMORY_SERVER = 9,
+	eCONNECT_DART = 10,
+	eCONNECT_MUJOCO = 11,
+	eCONNECT_GRPC = 12,
+	eCONNECT_PHYSX=13,
+	eCONNECT_SHARED_MEMORY_GUI=14,
+	eCONNECT_GRAPHICS_SERVER = 15,
+	eCONNECT_GRAPHICS_SERVER_TCP = 16,
+	eCONNECT_GRAPHICS_SERVER_MAIN_THREAD=17
+};
+
+enum eURDF_Flags
+{
+	URDF_USE_INERTIA_FROM_FILE = 2,  //sync with URDFJointTypes.h 'ConvertURDFFlags'
+	URDF_USE_SELF_COLLISION = 8,     //see CUF_USE_SELF_COLLISION
+	URDF_USE_SELF_COLLISION_EXCLUDE_PARENT = 16,
+	URDF_USE_SELF_COLLISION_EXCLUDE_ALL_PARENTS = 32,
+	URDF_RESERVED = 64,
+	URDF_USE_IMPLICIT_CYLINDER = 128,
+	URDF_GLOBAL_VELOCITIES_MB = 256,
+	MJCF_COLORS_FROM_FILE = 512,
+	URDF_ENABLE_CACHED_GRAPHICS_SHAPES = 1024,
+	URDF_ENABLE_SLEEPING = 2048,
+	URDF_INITIALIZE_SAT_FEATURES = 4096,
+	URDF_USE_SELF_COLLISION_INCLUDE_PARENT = 8192,
+	URDF_PARSE_SENSORS = 16384,
+	URDF_USE_MATERIAL_COLORS_FROM_MTL = 32768,
+	URDF_USE_MATERIAL_TRANSPARANCY_FROM_MTL = 65536,
+	URDF_MAINTAIN_LINK_ORDER = 131072,
+	URDF_ENABLE_WAKEUP = 1 << 18,
+	URDF_MERGE_FIXED_LINKS = 1 << 19,
+	URDF_IGNORE_VISUAL_SHAPES = 1 << 20,
+	URDF_IGNORE_COLLISION_SHAPES = 1 << 21,
+	URDF_PRINT_URDF_INFO = 1 << 22,
+	URDF_GOOGLEY_UNDEFINED_COLORS = 1 << 23,
+};
+
+enum eUrdfGeomTypes  //sync with UrdfParser UrdfGeomTypes
+{
+	GEOM_SPHERE = 2,
+	GEOM_BOX,
+	GEOM_CYLINDER,
+	GEOM_MESH,
+	GEOM_PLANE,
+	GEOM_CAPSULE,  //non-standard URDF?
+	GEOM_SDF,      //signed-distance-field, non-standard URDF
+	GEOM_HEIGHTFIELD,
+	GEOM_UNKNOWN,
+};
+
+enum eUrdfCollisionFlags
+{
+	GEOM_FORCE_CONCAVE_TRIMESH = 1,
+	GEOM_CONCAVE_INTERNAL_EDGE = 2,
+	GEOM_INITIALIZE_SAT_FEATURES = URDF_INITIALIZE_SAT_FEATURES,
+};
+
+enum eUrdfVisualFlags
+{
+	GEOM_VISUAL_HAS_RGBA_COLOR = 1,
+	GEOM_VISUAL_HAS_SPECULAR_COLOR = 2,
+};
+
+enum eStateLoggingFlags
+{
+	STATE_LOG_JOINT_MOTOR_TORQUES = 1,
+	STATE_LOG_JOINT_USER_TORQUES = 2,
+	STATE_LOG_JOINT_TORQUES = STATE_LOG_JOINT_MOTOR_TORQUES + STATE_LOG_JOINT_USER_TORQUES,
+};
+
+enum eJointFeedbackModes
+{
+	JOINT_FEEDBACK_IN_WORLD_SPACE = 1,
+	JOINT_FEEDBACK_IN_JOINT_FRAME = 2,
+};
+
+#define B3_MAX_PLUGIN_ARG_SIZE 128
+#define B3_MAX_PLUGIN_ARG_TEXT_LEN 1024
+
+struct b3PluginArguments
+{
+	char m_text[B3_MAX_PLUGIN_ARG_TEXT_LEN];
+	int m_numInts;
+	int m_ints[B3_MAX_PLUGIN_ARG_SIZE];
+	int m_numFloats;
+	double m_floats[B3_MAX_PLUGIN_ARG_SIZE];
+};
+
+enum eInternalSimFlags
+{
+	eVRTinyGUI = 1<<1,
+	eDeformableAlternativeIndexing = 1<<2,
+};
+
+struct b3PhysicsSimulationParameters
+{
+	double m_deltaTime;
+	double m_simulationTimestamp;  // user logging timestamp of simulation.
+	double m_gravityAcceleration[3];
+	int m_numSimulationSubSteps;
+	int m_numSolverIterations;
+	double m_warmStartingFactor;
+	double m_articulatedWarmStartingFactor;
+	int m_useRealTimeSimulation;
+	int m_useSplitImpulse;
+	double m_splitImpulsePenetrationThreshold;
+	double m_contactBreakingThreshold;
+	int m_internalSimFlags;
+	double m_defaultContactERP;
+	int m_collisionFilterMode;
+	int m_enableFileCaching;
+	double m_restitutionVelocityThreshold;
+	double m_defaultNonContactERP;
+	double m_frictionERP;
+	double m_defaultGlobalCFM;
+	double m_frictionCFM;
+	int m_enableConeFriction;
+	int m_deterministicOverlappingPairs;
+	double m_allowedCcdPenetration;
+	int m_jointFeedbackMode;
+	double m_solverResidualThreshold;
+	double m_contactSlop;
+	int m_enableSAT;
+	int m_constraintSolverType;
+	int m_minimumSolverIslandSize;
+	int m_reportSolverAnalytics;
+	double m_sparseSdfVoxelSize;
+	int m_numNonContactInnerIterations;
+};
+
+
+enum eConstraintSolverTypes
+{
+	eConstraintSolverLCP_SI = 1,
+	eConstraintSolverLCP_PGS,
+	eConstraintSolverLCP_DANTZIG,
+	eConstraintSolverLCP_LEMKE,
+	eConstraintSolverLCP_NNCG,
+	eConstraintSolverLCP_BLOCK_PGS,
+};
+
+struct b3ForwardDynamicsAnalyticsIslandData
+{
+	int m_islandId;
+	int m_numBodies;
+	int m_numContactManifolds;
+	int m_numIterationsUsed;
+	double m_remainingLeastSquaresResidual;
+};
+
+#define MAX_ISLANDS_ANALYTICS 64
+
+struct b3ForwardDynamicsAnalyticsArgs
+{
+	int m_numSteps;
+	int m_numIslands;
+	int m_numSolverCalls;
+	struct b3ForwardDynamicsAnalyticsIslandData m_islandData[MAX_ISLANDS_ANALYTICS];
+};
+
+enum eDynamicTypes
+{
+	eDynamic= 0,
+	eStatic= 1,
+	eKinematic= 2
+};
+
+enum eFileIOActions
+{
+	eAddFileIOAction = 1024,//avoid collision with eFileIOTypes
+	eRemoveFileIOAction,
+};
+
+
+enum eFileIOTypes
+{
+	ePosixFileIO = 1,
+	eZipFileIO,
+	eCNSFileIO,
+	eInMemoryFileIO,
+};
+
+enum eEnumUpdateVisualShapeFlags
+{
+	eVISUAL_SHAPE_DOUBLE_SIDED = 4,//see B3_INSTANCE_DOUBLE_SIDED
+};
+
+//limits for vertices/indices in PyBullet::createCollisionShape
+//Make sure the data fits in SHARED_MEMORY_MAX_STREAM_CHUNK_SIZE
+//(numVertices*sizeof(double)*3 + numIndices*sizeof(int)) < SHARED_MEMORY_MAX_STREAM_CHUNK_SIZE
+
+
+#ifdef __APPLE__
+#define B3_MAX_NUM_VERTICES 8192
+#define B3_MAX_NUM_INDICES 32768
+#else
+#define B3_MAX_NUM_VERTICES 131072
+#define B3_MAX_NUM_INDICES 524288
+#endif
+
+
+#endif  //SHARED_MEMORY_PUBLIC_H
diff --git a/engine/inc/bullet/SharedMemory/SharedMemoryUserData.h b/engine/inc/bullet/SharedMemory/SharedMemoryUserData.h
new file mode 100644
index 00000000..d605f2f8
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/SharedMemoryUserData.h
@@ -0,0 +1,96 @@
+#ifndef SHARED_MEMORY_USER_DATA_H
+#define SHARED_MEMORY_USER_DATA_H
+
+#include <string>
+#include "LinearMath/btAlignedObjectArray.h"
+#include "LinearMath/btHashMap.h"
+#include "SharedMemoryPublic.h"
+
+struct SharedMemoryUserData
+{
+	std::string m_key;
+	int m_type;
+
+	int m_bodyUniqueId;
+	int m_linkIndex;
+	int m_visualShapeIndex;
+
+	btAlignedObjectArray<char> m_bytes;
+
+	SharedMemoryUserData()
+		: m_type(-1), m_bodyUniqueId(-1), m_linkIndex(-1), m_visualShapeIndex(-1)
+	{
+	}
+
+	SharedMemoryUserData(const char* key, int bodyUniqueId, int linkIndex, int visualShapeIndex)
+		: m_key(key), m_type(-1), m_bodyUniqueId(bodyUniqueId), m_linkIndex(linkIndex), m_visualShapeIndex(visualShapeIndex)
+	{
+	}
+
+	void replaceValue(const char* bytes, int len, int type)
+	{
+		m_type = type;
+		m_bytes.resize(len);
+		for (int i = 0; i < len; i++)
+		{
+			m_bytes[i] = bytes[i];
+		}
+	}
+
+	virtual ~SharedMemoryUserData()
+	{
+	}
+
+	void clear()
+	{
+		m_bytes.clear();
+		m_type = -1;
+	}
+};
+
+struct SharedMemoryUserDataHashKey
+{
+	unsigned int m_hash;
+
+	btHashString m_key;
+	btHashInt m_bodyUniqueId;
+	btHashInt m_linkIndex;
+	btHashInt m_visualShapeIndex;
+
+	SIMD_FORCE_INLINE unsigned int getHash() const
+	{
+		return m_hash;
+	}
+
+	SharedMemoryUserDataHashKey() : m_hash(0) {}
+
+	SharedMemoryUserDataHashKey(const struct SharedMemoryUserData* userData)
+		: m_key(userData->m_key.c_str()),
+		  m_bodyUniqueId(userData->m_bodyUniqueId),
+		  m_linkIndex(userData->m_linkIndex),
+		  m_visualShapeIndex(userData->m_visualShapeIndex)
+	{
+		calculateHash();
+	}
+
+	SharedMemoryUserDataHashKey(const char* key, int bodyUniqueId, int linkIndex, int visualShapeIndex)
+		: m_key(key), m_bodyUniqueId(bodyUniqueId), m_linkIndex(linkIndex), m_visualShapeIndex(visualShapeIndex)
+	{
+		calculateHash();
+	}
+
+	void calculateHash()
+	{
+		m_hash = m_key.getHash() ^ m_bodyUniqueId.getHash() ^ m_linkIndex.getHash() ^ m_visualShapeIndex.getHash();
+	}
+
+	bool equals(const SharedMemoryUserDataHashKey& other) const
+	{
+		return m_bodyUniqueId.equals(other.m_bodyUniqueId) &&
+			   m_linkIndex.equals(other.m_linkIndex) &&
+			   m_visualShapeIndex.equals(other.m_visualShapeIndex) &&
+			   m_key.equals(other.m_key);
+	}
+};
+
+#endif  //SHARED_MEMORY_USER_DATA_H
diff --git a/engine/inc/bullet/SharedMemory/Win32SharedMemory.h b/engine/inc/bullet/SharedMemory/Win32SharedMemory.h
new file mode 100644
index 00000000..dfa37c7d
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/Win32SharedMemory.h
@@ -0,0 +1,32 @@
+#ifndef WIN32_SHARED_MEMORY_H
+#define WIN32_SHARED_MEMORY_H
+
+#include "SharedMemoryInterface.h"
+
+class Win32SharedMemory : public SharedMemoryInterface
+{
+	struct Win32SharedMemoryInteralData* m_internalData;
+
+public:
+	Win32SharedMemory();
+	virtual ~Win32SharedMemory();
+
+	virtual void* allocateSharedMemory(int key, int size, bool allowCreation);
+	virtual void releaseSharedMemory(int key, int size);
+};
+
+class Win32SharedMemoryServer : public Win32SharedMemory
+{
+public:
+	Win32SharedMemoryServer();
+	virtual ~Win32SharedMemoryServer();
+};
+
+class Win32SharedMemoryClient : public Win32SharedMemory
+{
+public:
+	Win32SharedMemoryClient();
+	virtual ~Win32SharedMemoryClient();
+};
+
+#endif  //WIN32_SHARED_MEMORY_H
diff --git a/engine/inc/bullet/SharedMemory/b3PluginManager.h b/engine/inc/bullet/SharedMemory/b3PluginManager.h
new file mode 100644
index 00000000..240c3e2f
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/b3PluginManager.h
@@ -0,0 +1,77 @@
+#ifndef B3_PLUGIN_MANAGER_H
+#define B3_PLUGIN_MANAGER_H
+
+#include "plugins/b3PluginAPI.h"
+
+enum b3PluginManagerTickMode
+{
+	B3_PRE_TICK_MODE = 1,
+	B3_POST_TICK_MODE,
+	B3_PROCESS_CLIENT_COMMANDS_TICK,
+};
+
+struct b3PluginFunctions
+{
+	//required
+	PFN_INIT m_initFunc;
+	PFN_EXIT m_exitFunc;
+	PFN_EXECUTE m_executeCommandFunc;
+
+	//optional
+	PFN_TICK m_preTickFunc;
+	PFN_TICK m_postTickFunc;
+	PFN_GET_RENDER_INTERFACE m_getRendererFunc;
+	PFN_TICK m_processClientCommandsFunc;
+	PFN_TICK m_processNotificationsFunc;
+	PFN_GET_COLLISION_INTERFACE m_getCollisionFunc;
+	PFN_GET_FILEIO_INTERFACE m_fileIoFunc;
+	
+	b3PluginFunctions(PFN_INIT initFunc, PFN_EXIT exitFunc, PFN_EXECUTE executeCommandFunc)
+		:m_initFunc(initFunc),
+		m_exitFunc(exitFunc),
+		m_executeCommandFunc(executeCommandFunc),
+		m_preTickFunc(0),
+		m_postTickFunc(0),
+		m_getRendererFunc(0),
+		m_processClientCommandsFunc(0),
+		m_processNotificationsFunc(0),
+		m_getCollisionFunc(0),
+		m_fileIoFunc(0)
+	{
+	}
+};
+
+class b3PluginManager
+{
+	struct b3PluginManagerInternalData* m_data;
+
+public:
+	b3PluginManager(class PhysicsCommandProcessorInterface* physSdk);
+	virtual ~b3PluginManager();
+
+	int loadPlugin(const char* pluginPath, const char* postFixStr = "");
+	void unloadPlugin(int pluginUniqueId);
+	int executePluginCommand(int pluginUniqueId, const struct b3PluginArguments* arguments);
+	void addEvents(const struct b3VRControllerEvent* vrControllerEvents, int numVRControllerEvents, const struct b3KeyboardEvent* keyEvents, int numKeyEvents, const struct b3MouseEvent* mouseEvents, int numMouseEvents);
+	void clearEvents();
+
+	void addNotification(const struct b3Notification& notification);
+	void reportNotifications();
+
+	void tickPlugins(double timeStep, b3PluginManagerTickMode tickMode);
+
+	int registerStaticLinkedPlugin(const char* pluginPath, b3PluginFunctions& functions, bool initPlugin = true);
+
+	void selectPluginRenderer(int pluginUniqueId);
+	struct UrdfRenderingInterface* getRenderInterface();
+
+	void selectFileIOPlugin(int pluginUniqueId);
+	struct CommonFileIOInterface* getFileIOInterface();
+
+	void selectCollisionPlugin(int pluginUniqueId);
+	struct b3PluginCollisionInterface* getCollisionInterface();
+
+	const struct b3UserDataValue* getReturnData(int pluginUniqueId);
+};
+
+#endif  //B3_PLUGIN_MANAGER_H
diff --git a/engine/inc/bullet/SharedMemory/b3RobotSimulatorClientAPI_InternalData.h b/engine/inc/bullet/SharedMemory/b3RobotSimulatorClientAPI_InternalData.h
new file mode 100644
index 00000000..34994ddf
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/b3RobotSimulatorClientAPI_InternalData.h
@@ -0,0 +1,18 @@
+#ifndef B3_ROBOT_SIMULATOR_CLIENT_API_INTERNAL_DATA_H
+#define B3_ROBOT_SIMULATOR_CLIENT_API_INTERNAL_DATA_H
+
+#include "../SharedMemory/PhysicsClientC_API.h"
+
+struct b3RobotSimulatorClientAPI_InternalData
+{
+	b3PhysicsClientHandle m_physicsClientHandle;
+	struct GUIHelperInterface* m_guiHelper;
+
+	b3RobotSimulatorClientAPI_InternalData()
+		: m_physicsClientHandle(0),
+		  m_guiHelper(0)
+	{
+	}
+};
+
+#endif  //B3_ROBOT_SIMULATOR_CLIENT_API_INTERNAL_DATA_H
\ No newline at end of file
diff --git a/engine/inc/bullet/SharedMemory/b3RobotSimulatorClientAPI_NoDirect.h b/engine/inc/bullet/SharedMemory/b3RobotSimulatorClientAPI_NoDirect.h
new file mode 100644
index 00000000..5c8f9e2f
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/b3RobotSimulatorClientAPI_NoDirect.h
@@ -0,0 +1,914 @@
+#ifndef B3_ROBOT_SIMULATOR_CLIENT_API_NO_DIRECT_H
+#define B3_ROBOT_SIMULATOR_CLIENT_API_NO_DIRECT_H
+
+///The b3RobotSimulatorClientAPI is pretty much the C++ version of pybullet
+///as documented in the pybullet Quickstart Guide
+///https://docs.google.com/document/d/10sXEhzFRSnvFcl3XxNGhnD4N2SedqwdAvK3dsihxVUA
+
+#include "SharedMemoryPublic.h"
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btQuaternion.h"
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btAlignedObjectArray.h"
+
+#include <string>
+
+struct b3RobotSimulatorLoadUrdfFileArgs
+{
+	btVector3 m_startPosition;
+	btQuaternion m_startOrientation;
+	bool m_forceOverrideFixedBase;
+	bool m_useMultiBody;
+	int m_flags;
+
+	b3RobotSimulatorLoadUrdfFileArgs(const btVector3 &startPos, const btQuaternion &startOrn)
+		: m_startPosition(startPos),
+		  m_startOrientation(startOrn),
+		  m_forceOverrideFixedBase(false),
+		  m_useMultiBody(true),
+		  m_flags(0)
+	{
+	}
+
+	b3RobotSimulatorLoadUrdfFileArgs()
+		: m_startPosition(btVector3(0, 0, 0)),
+		  m_startOrientation(btQuaternion(0, 0, 0, 1)),
+		  m_forceOverrideFixedBase(false),
+		  m_useMultiBody(true),
+		  m_flags(0)
+	{
+	}
+};
+
+struct b3RobotSimulatorLoadSdfFileArgs
+{
+	bool m_forceOverrideFixedBase;
+	bool m_useMultiBody;
+
+	b3RobotSimulatorLoadSdfFileArgs()
+		: m_forceOverrideFixedBase(false),
+		  m_useMultiBody(true)
+	{
+	}
+};
+
+struct b3RobotSimulatorLoadSoftBodyArgs
+{
+	btVector3 m_startPosition;
+	btQuaternion m_startOrientation;
+	double m_scale;
+	double m_mass;
+	double m_collisionMargin;
+
+	b3RobotSimulatorLoadSoftBodyArgs(const btVector3 &startPos, const btQuaternion &startOrn, const double &scale, const double &mass, const double &collisionMargin)
+		: m_startPosition(startPos),
+		  m_startOrientation(startOrn),
+		  m_scale(scale),
+		  m_mass(mass),
+		  m_collisionMargin(collisionMargin)
+	{
+	}
+
+	b3RobotSimulatorLoadSoftBodyArgs(const btVector3 &startPos, const btQuaternion &startOrn)
+	{
+		b3RobotSimulatorLoadSoftBodyArgs(startPos, startOrn, 1.0, 1.0, 0.02);
+	}
+
+	b3RobotSimulatorLoadSoftBodyArgs()
+	{
+		b3RobotSimulatorLoadSoftBodyArgs(btVector3(0, 0, 0), btQuaternion(0, 0, 0, 1));
+	}
+
+	b3RobotSimulatorLoadSoftBodyArgs(double scale, double mass, double collisionMargin)
+		: m_startPosition(btVector3(0, 0, 0)),
+		  m_startOrientation(btQuaternion(0, 0, 0, 1)),
+		  m_scale(scale),
+		  m_mass(mass),
+		  m_collisionMargin(collisionMargin)
+	{
+	}
+};
+
+
+struct b3RobotSimulatorLoadDeformableBodyArgs
+{
+	btVector3 m_startPosition;
+	btQuaternion m_startOrientation;
+	double m_scale;
+	double m_mass;
+	double m_collisionMargin;
+	double m_springElasticStiffness;
+	double m_springDampingStiffness;
+	double m_springBendingStiffness;
+	double m_NeoHookeanMu;
+	double m_NeoHookeanLambda;
+	double m_NeoHookeanDamping;
+	bool m_useSelfCollision;
+	bool m_useFaceContact;
+	bool m_useBendingSprings;
+	double m_frictionCoeff;
+
+	b3RobotSimulatorLoadDeformableBodyArgs(const btVector3 &startPos, const btQuaternion &startOrn, const double &scale, const double &mass, const double &collisionMargin)
+	: m_startPosition(startPos),
+	m_startOrientation(startOrn),
+	m_scale(scale),
+	m_mass(mass),
+	m_collisionMargin(collisionMargin),
+	m_springElasticStiffness(-1),
+	m_springDampingStiffness(-1),
+	m_springBendingStiffness(-1),
+	m_NeoHookeanMu(-1),
+	m_NeoHookeanDamping(-1),
+	m_useSelfCollision(false),
+	m_useFaceContact(false),
+	m_useBendingSprings(false),
+	m_frictionCoeff(0)
+	{
+	}
+
+	b3RobotSimulatorLoadDeformableBodyArgs(const btVector3 &startPos, const btQuaternion &startOrn)
+	{
+		b3RobotSimulatorLoadSoftBodyArgs(startPos, startOrn, 1.0, 1.0, 0.02);
+	}
+
+	b3RobotSimulatorLoadDeformableBodyArgs()
+	{
+		b3RobotSimulatorLoadSoftBodyArgs(btVector3(0, 0, 0), btQuaternion(0, 0, 0, 1));
+	}
+
+	b3RobotSimulatorLoadDeformableBodyArgs(double scale, double mass, double collisionMargin)
+	: m_startPosition(btVector3(0, 0, 0)),
+	m_startOrientation(btQuaternion(0, 0, 0, 1)),
+	m_scale(scale),
+	m_mass(mass),
+	m_collisionMargin(collisionMargin)
+	{
+	}
+};
+
+
+struct b3RobotSimulatorLoadFileResults
+{
+	btAlignedObjectArray<int> m_uniqueObjectIds;
+	b3RobotSimulatorLoadFileResults()
+	{
+	}
+};
+
+struct b3RobotSimulatorChangeVisualShapeArgs
+{
+	int m_objectUniqueId;
+	int m_linkIndex;
+	int m_shapeIndex;
+	int m_textureUniqueId;
+	btVector4 m_rgbaColor;
+	bool m_hasRgbaColor;
+	btVector3 m_specularColor;
+	bool m_hasSpecularColor;
+
+	b3RobotSimulatorChangeVisualShapeArgs()
+		: m_objectUniqueId(-1),
+		  m_linkIndex(-1),
+		  m_shapeIndex(-1),
+		  m_textureUniqueId(-2),
+		  m_rgbaColor(0, 0, 0, 1),
+		  m_hasRgbaColor(false),
+		  m_specularColor(1, 1, 1),
+		  m_hasSpecularColor(false)
+	{
+	}
+};
+
+struct b3RobotSimulatorJointMotorArgs
+{
+	int m_controlMode;
+
+	double m_targetPosition;
+	double m_kp;
+
+	double m_targetVelocity;
+	double m_kd;
+
+	double m_maxTorqueValue;
+
+	b3RobotSimulatorJointMotorArgs(int controlMode)
+		: m_controlMode(controlMode),
+		  m_targetPosition(0),
+		  m_kp(0.1),
+		  m_targetVelocity(0),
+		  m_kd(0.9),
+		  m_maxTorqueValue(1000)
+	{
+	}
+};
+
+enum b3RobotSimulatorInverseKinematicsFlags
+{
+	B3_HAS_IK_TARGET_ORIENTATION = 1,
+	B3_HAS_NULL_SPACE_VELOCITY = 2,
+	B3_HAS_JOINT_DAMPING = 4,
+	B3_HAS_CURRENT_POSITIONS = 8,
+};
+
+struct b3RobotSimulatorInverseKinematicArgs
+{
+	int m_bodyUniqueId;
+	double m_endEffectorTargetPosition[3];
+	double m_endEffectorTargetOrientation[4];
+	int m_endEffectorLinkIndex;
+	int m_flags;
+	int m_numDegreeOfFreedom;
+	btAlignedObjectArray<double> m_lowerLimits;
+	btAlignedObjectArray<double> m_upperLimits;
+	btAlignedObjectArray<double> m_jointRanges;
+	btAlignedObjectArray<double> m_restPoses;
+	btAlignedObjectArray<double> m_jointDamping;
+	btAlignedObjectArray<double> m_currentJointPositions;
+
+	b3RobotSimulatorInverseKinematicArgs()
+		: m_bodyUniqueId(-1),
+		  m_endEffectorLinkIndex(-1),
+		  m_flags(0)
+	{
+		m_endEffectorTargetPosition[0] = 0;
+		m_endEffectorTargetPosition[1] = 0;
+		m_endEffectorTargetPosition[2] = 0;
+
+		m_endEffectorTargetOrientation[0] = 0;
+		m_endEffectorTargetOrientation[1] = 0;
+		m_endEffectorTargetOrientation[2] = 0;
+		m_endEffectorTargetOrientation[3] = 1;
+	}
+};
+
+struct b3RobotSimulatorInverseKinematicsResults
+{
+	int m_bodyUniqueId;
+	btAlignedObjectArray<double> m_calculatedJointPositions;
+};
+
+struct b3JointStates2
+{
+	int m_bodyUniqueId;
+	int m_numDegreeOfFreedomQ;
+	int m_numDegreeOfFreedomU;
+	btTransform m_rootLocalInertialFrame;
+	btAlignedObjectArray<double> m_actualStateQ;
+	btAlignedObjectArray<double> m_actualStateQdot;
+	btAlignedObjectArray<double> m_jointReactionForces;
+};
+
+struct b3RobotSimulatorJointMotorArrayArgs
+{
+	int m_controlMode;
+	int m_numControlledDofs;
+
+	int *m_jointIndices;
+
+	double *m_targetPositions;
+	double *m_kps;
+
+	double *m_targetVelocities;
+	double *m_kds;
+
+	double *m_forces;
+
+	b3RobotSimulatorJointMotorArrayArgs(int controlMode, int numControlledDofs)
+		: m_controlMode(controlMode),
+		  m_numControlledDofs(numControlledDofs),
+		  m_jointIndices(NULL),
+		  m_targetPositions(NULL),
+		  m_kps(NULL),
+		  m_targetVelocities(NULL),
+		  m_kds(NULL),
+		  m_forces(NULL)
+	{
+	}
+};
+
+struct b3RobotSimulatorGetCameraImageArgs
+{
+	int m_width;
+	int m_height;
+	float *m_viewMatrix;
+	float *m_projectionMatrix;
+	float *m_lightDirection;
+	float *m_lightColor;
+	float m_lightDistance;
+	int m_hasShadow;
+	float m_lightAmbientCoeff;
+	float m_lightDiffuseCoeff;
+	float m_lightSpecularCoeff;
+	int m_renderer;
+
+	b3RobotSimulatorGetCameraImageArgs(int width, int height)
+		: m_width(width),
+		  m_height(height),
+		  m_viewMatrix(NULL),
+		  m_projectionMatrix(NULL),
+		  m_lightDirection(NULL),
+		  m_lightColor(NULL),
+		  m_lightDistance(-1),
+		  m_hasShadow(-1),
+		  m_lightAmbientCoeff(-1),
+		  m_lightDiffuseCoeff(-1),
+		  m_lightSpecularCoeff(-1),
+		  m_renderer(-1)
+	{
+	}
+};
+
+struct b3RobotSimulatorSetPhysicsEngineParameters : b3PhysicsSimulationParameters
+{
+	b3RobotSimulatorSetPhysicsEngineParameters()
+	{
+		m_deltaTime = -1;
+		m_gravityAcceleration[0] = 0;
+		m_gravityAcceleration[1] = 0;
+		m_gravityAcceleration[2] = 0;
+
+		m_numSimulationSubSteps = -1;
+		m_numSolverIterations = -1;
+		m_useRealTimeSimulation = -1;
+		m_useSplitImpulse = -1;
+		m_splitImpulsePenetrationThreshold = -1;
+		m_contactBreakingThreshold = -1;
+		m_internalSimFlags = -1;
+		m_defaultContactERP = -1;
+		m_collisionFilterMode = -1;
+		m_enableFileCaching = -1;
+		m_restitutionVelocityThreshold = -1;
+		m_defaultNonContactERP = -1;
+		m_frictionERP = -1;
+		m_defaultGlobalCFM = -1;
+		m_frictionCFM = -1;
+		m_enableConeFriction = -1;
+		m_deterministicOverlappingPairs = -1;
+		m_allowedCcdPenetration = -1;
+		m_jointFeedbackMode = -1;
+		m_solverResidualThreshold = -1;
+		m_contactSlop = -1;
+
+		m_collisionFilterMode = -1;
+		m_contactBreakingThreshold = -1;
+
+		m_enableFileCaching = -1;
+		m_restitutionVelocityThreshold = -1;
+
+		m_frictionERP = -1;
+		m_solverResidualThreshold = -1;
+		m_constraintSolverType = -1;
+		m_minimumSolverIslandSize = -1;
+	}
+};
+
+struct b3RobotSimulatorChangeDynamicsArgs
+{
+	double m_mass;
+	double m_lateralFriction;
+	double m_spinningFriction;
+	double m_rollingFriction;
+	double m_restitution;
+	double m_linearDamping;
+	double m_angularDamping;
+	double m_contactStiffness;
+	double m_contactDamping;
+	int m_frictionAnchor;
+	int m_activationState;
+
+	b3RobotSimulatorChangeDynamicsArgs()
+		: m_mass(-1),
+		  m_lateralFriction(-1),
+		  m_spinningFriction(-1),
+		  m_rollingFriction(-1),
+		  m_restitution(-1),
+		  m_linearDamping(-1),
+		  m_angularDamping(-1),
+		  m_contactStiffness(-1),
+		  m_contactDamping(-1),
+		  m_frictionAnchor(-1),
+		  m_activationState(-1)
+	{
+	}
+};
+
+struct b3RobotSimulatorAddUserDebugLineArgs
+{
+	double m_colorRGB[3];
+	double m_lineWidth;
+	double m_lifeTime;
+	int m_parentObjectUniqueId;
+	int m_parentLinkIndex;
+
+	b3RobotSimulatorAddUserDebugLineArgs()
+		: m_lineWidth(1),
+		  m_lifeTime(0),
+		  m_parentObjectUniqueId(-1),
+		  m_parentLinkIndex(-1)
+	{
+		m_colorRGB[0] = 1;
+		m_colorRGB[1] = 1;
+		m_colorRGB[2] = 1;
+	}
+};
+
+enum b3AddUserDebugTextFlags
+{
+	DEBUG_TEXT_HAS_ORIENTATION = 1
+};
+
+struct b3RobotSimulatorAddUserDebugTextArgs
+{
+	double m_colorRGB[3];
+	double m_size;
+	double m_lifeTime;
+	double m_textOrientation[4];
+	int m_parentObjectUniqueId;
+	int m_parentLinkIndex;
+	int m_flags;
+
+	b3RobotSimulatorAddUserDebugTextArgs()
+		: m_size(1),
+		  m_lifeTime(0),
+		  m_parentObjectUniqueId(-1),
+		  m_parentLinkIndex(-1),
+		  m_flags(0)
+	{
+		m_colorRGB[0] = 1;
+		m_colorRGB[1] = 1;
+		m_colorRGB[2] = 1;
+
+		m_textOrientation[0] = 0;
+		m_textOrientation[1] = 0;
+		m_textOrientation[2] = 0;
+		m_textOrientation[3] = 1;
+	}
+};
+
+struct b3RobotSimulatorGetContactPointsArgs
+{
+	int m_bodyUniqueIdA;
+	int m_bodyUniqueIdB;
+	int m_linkIndexA;
+	int m_linkIndexB;
+
+	b3RobotSimulatorGetContactPointsArgs()
+		: m_bodyUniqueIdA(-1),
+		  m_bodyUniqueIdB(-1),
+		  m_linkIndexA(-2),
+		  m_linkIndexB(-2)
+	{
+	}
+};
+
+struct b3RobotSimulatorCreateCollisionShapeArgs
+{
+	int m_shapeType;
+	double m_radius;
+	btVector3 m_halfExtents;
+	double m_height;
+	char *m_fileName;
+	btVector3 m_meshScale;
+	btVector3 m_planeNormal;
+	int m_flags;
+
+	double m_heightfieldTextureScaling;
+	btAlignedObjectArray<float> m_heightfieldData;
+	int m_numHeightfieldRows;
+	int m_numHeightfieldColumns;
+	int m_replaceHeightfieldIndex;
+
+	b3RobotSimulatorCreateCollisionShapeArgs()
+		: m_shapeType(-1),
+		  m_radius(0.5),
+		  m_height(1),
+		  m_fileName(NULL),
+		  m_flags(0),
+		  m_heightfieldTextureScaling(1),
+		  m_numHeightfieldRows(0),
+		  m_numHeightfieldColumns(0),
+		  m_replaceHeightfieldIndex(-1)
+	{
+		m_halfExtents.m_floats[0] = 1;
+		m_halfExtents.m_floats[1] = 1;
+		m_halfExtents.m_floats[2] = 1;
+
+		m_meshScale.m_floats[0] = 1;
+		m_meshScale.m_floats[1] = 1;
+		m_meshScale.m_floats[2] = 1;
+
+		m_planeNormal.m_floats[0] = 0;
+		m_planeNormal.m_floats[1] = 0;
+		m_planeNormal.m_floats[2] = 1;
+	}
+};
+
+
+struct b3RobotSimulatorCreateVisualShapeArgs
+{
+	int m_shapeType;
+	double m_radius;
+	btVector3 m_halfExtents;
+	double m_height;
+	char* m_fileName;
+	btVector3 m_meshScale;
+	btVector3 m_planeNormal;
+	int m_flags;
+	b3RobotSimulatorCreateVisualShapeArgs()
+		: m_shapeType(-1),
+		m_radius(0.5),
+		m_height(1),
+		m_fileName(NULL),
+		m_flags(0)
+	{
+		m_halfExtents.m_floats[0] = 1;
+		m_halfExtents.m_floats[1] = 1;
+		m_halfExtents.m_floats[2] = 1;
+
+		m_meshScale.m_floats[0] = 1;
+		m_meshScale.m_floats[1] = 1;
+		m_meshScale.m_floats[2] = 1;
+
+		m_planeNormal.m_floats[0] = 0;
+		m_planeNormal.m_floats[1] = 0;
+		m_planeNormal.m_floats[2] = 1;
+	}
+};
+
+struct b3RobotSimulatorCreateMultiBodyArgs
+{
+	double m_baseMass;
+	int m_baseCollisionShapeIndex;
+	int m_baseVisualShapeIndex;
+	btVector3 m_basePosition;
+	btQuaternion m_baseOrientation;
+	btVector3 m_baseInertialFramePosition;
+	btQuaternion m_baseInertialFrameOrientation;
+
+	int m_numLinks;
+	double *m_linkMasses;
+	int *m_linkCollisionShapeIndices;
+	int *m_linkVisualShapeIndices;
+	btVector3 *m_linkPositions;
+	btQuaternion *m_linkOrientations;
+	btVector3 *m_linkInertialFramePositions;
+	btQuaternion *m_linkInertialFrameOrientations;
+	int *m_linkParentIndices;
+	int *m_linkJointTypes;
+	btVector3 *m_linkJointAxes;
+	btAlignedObjectArray<btVector3> m_batchPositions;
+	int m_useMaximalCoordinates;
+
+	b3RobotSimulatorCreateMultiBodyArgs()
+		: m_baseMass(0), m_baseCollisionShapeIndex(-1), m_baseVisualShapeIndex(-1), m_numLinks(0), m_linkMasses(NULL), m_linkCollisionShapeIndices(NULL), m_linkVisualShapeIndices(NULL), m_linkPositions(NULL), m_linkOrientations(NULL), m_linkInertialFramePositions(NULL), m_linkInertialFrameOrientations(NULL), m_linkParentIndices(NULL), m_linkJointTypes(NULL), m_linkJointAxes(NULL), m_useMaximalCoordinates(0)
+	{
+		m_basePosition.setValue(0, 0, 0);
+		m_baseOrientation.setValue(0, 0, 0, 1);
+		m_baseInertialFramePosition.setValue(0, 0, 0);
+		m_baseInertialFrameOrientation.setValue(0, 0, 0, 1);
+	}
+};
+
+
+struct b3RobotUserConstraint : public b3UserConstraint
+{
+	int m_userUpdateFlags;//see EnumUserConstraintFlags
+
+	void setErp(double erp)
+	{
+		m_erp = erp;
+		m_userUpdateFlags |= USER_CONSTRAINT_CHANGE_ERP;
+	}
+	
+	void setMaxAppliedForce(double maxForce)
+	{
+		m_maxAppliedForce = maxForce;
+		m_userUpdateFlags |= USER_CONSTRAINT_CHANGE_MAX_FORCE;
+	}
+	
+	void setGearRatio(double gearRatio)
+	{
+		m_gearRatio = gearRatio;
+		m_userUpdateFlags |= USER_CONSTRAINT_CHANGE_GEAR_RATIO;
+	}
+
+	void setGearAuxLink(int link)
+	{
+		m_gearAuxLink = link;
+		m_userUpdateFlags |= USER_CONSTRAINT_CHANGE_GEAR_AUX_LINK;
+	}
+
+	void setRelativePositionTarget(double target)
+	{
+		m_relativePositionTarget = target;
+		m_userUpdateFlags |= USER_CONSTRAINT_CHANGE_RELATIVE_POSITION_TARGET;
+	}
+
+	void setChildPivot(double pivot[3])
+	{
+		m_childFrame[0] = pivot[0];
+		m_childFrame[1] = pivot[1];
+		m_childFrame[2] = pivot[2];
+		m_userUpdateFlags |= USER_CONSTRAINT_CHANGE_PIVOT_IN_B;
+	}
+
+	void setChildFrameOrientation(double orn[4])
+	{
+		m_childFrame[3] = orn[0];
+		m_childFrame[4] = orn[1];
+		m_childFrame[5] = orn[2];
+		m_childFrame[6] = orn[3];
+		m_userUpdateFlags |= USER_CONSTRAINT_CHANGE_FRAME_ORN_IN_B;
+	}
+
+	b3RobotUserConstraint()
+		:m_userUpdateFlags(0)
+	{
+		m_parentBodyIndex = -1;
+		m_parentJointIndex = -1;
+		m_childBodyIndex = -1;
+		m_childJointIndex = -1;
+		//position
+		m_parentFrame[0] = 0;
+		m_parentFrame[1] = 0;
+		m_parentFrame[2] = 0;
+		//orientation quaternion [x,y,z,w]
+		m_parentFrame[3] = 0;
+		m_parentFrame[4] = 0;
+		m_parentFrame[5] = 0;
+		m_parentFrame[6] = 1;
+
+		//position
+		m_childFrame[0] = 0;
+		m_childFrame[1] = 0;
+		m_childFrame[2] = 0;
+		//orientation quaternion [x,y,z,w]
+		m_childFrame[3] = 0;
+		m_childFrame[4] = 0;
+		m_childFrame[5] = 0;
+		m_childFrame[6] = 1;
+
+		m_jointAxis[0] = 0;
+		m_jointAxis[1] = 0;
+		m_jointAxis[2] = 1;
+
+		m_jointType = eFixedType;
+
+		m_maxAppliedForce = 500;
+		m_userConstraintUniqueId = -1;
+		m_gearRatio = -1;
+		m_gearAuxLink = -1;
+		m_relativePositionTarget = 0;
+		m_erp = 0;
+	}
+};
+
+struct b3RobotJointInfo : public b3JointInfo
+{
+	b3RobotJointInfo()
+	{
+		m_linkName[0] = 0;
+		m_jointName[0] = 0;
+		m_jointType = eFixedType;
+		m_qIndex = -1;
+		m_uIndex = -1;
+		m_jointIndex = -1;
+		m_flags = 0;
+		m_jointDamping = 0;
+		m_jointFriction = 0;
+		m_jointLowerLimit = 1;
+		m_jointUpperLimit = -1;
+		m_jointMaxForce = 500;
+		m_jointMaxVelocity = 100;
+		m_parentIndex = -1;
+
+		//position
+		m_parentFrame[0] = 0;
+		m_parentFrame[1] = 0;
+		m_parentFrame[2] = 0;
+		//orientation quaternion [x,y,z,w]
+		m_parentFrame[3] = 0;
+		m_parentFrame[4] = 0;
+		m_parentFrame[5] = 0;
+		m_parentFrame[6] = 1;
+
+		//position
+		m_childFrame[0] = 0;
+		m_childFrame[1] = 0;
+		m_childFrame[2] = 0;
+		//orientation quaternion [x,y,z,w]
+		m_childFrame[3] = 0;
+		m_childFrame[4] = 0;
+		m_childFrame[5] = 0;
+		m_childFrame[6] = 1;
+
+		m_jointAxis[0] = 0;
+		m_jointAxis[1] = 0;
+		m_jointAxis[2] = 1;
+	}
+};
+
+class b3RobotSimulatorClientAPI_NoDirect
+{
+protected:
+	struct b3RobotSimulatorClientAPI_InternalData *m_data;
+
+public:
+	b3RobotSimulatorClientAPI_NoDirect();
+	virtual ~b3RobotSimulatorClientAPI_NoDirect();
+
+	//No 'connect', use setInternalData to bypass the connect method, pass an existing client
+	virtual void setInternalData(struct b3RobotSimulatorClientAPI_InternalData *data);
+
+	void disconnect();
+
+	bool isConnected() const;
+
+	void setTimeOut(double timeOutInSec);
+
+	void syncBodies();
+
+	void resetSimulation();
+    
+	void resetSimulation(int flag);
+
+	btQuaternion getQuaternionFromEuler(const btVector3 &rollPitchYaw);
+	btVector3 getEulerFromQuaternion(const btQuaternion &quat);
+
+	int loadURDF(const std::string &fileName, const struct b3RobotSimulatorLoadUrdfFileArgs &args = b3RobotSimulatorLoadUrdfFileArgs());
+	bool loadSDF(const std::string &fileName, b3RobotSimulatorLoadFileResults &results, const struct b3RobotSimulatorLoadSdfFileArgs &args = b3RobotSimulatorLoadSdfFileArgs());
+	bool loadMJCF(const std::string &fileName, b3RobotSimulatorLoadFileResults &results);
+	bool loadBullet(const std::string &fileName, b3RobotSimulatorLoadFileResults &results);
+	bool saveBullet(const std::string &fileName);
+
+	int loadTexture(const std::string &fileName);
+
+	bool changeVisualShape(const struct b3RobotSimulatorChangeVisualShapeArgs &args);
+
+	bool savePythonWorld(const std::string &fileName);
+
+	bool getBodyInfo(int bodyUniqueId, struct b3BodyInfo *bodyInfo);
+
+	bool getBasePositionAndOrientation(int bodyUniqueId, btVector3 &basePosition, btQuaternion &baseOrientation) const;
+	bool resetBasePositionAndOrientation(int bodyUniqueId, const btVector3 &basePosition, const btQuaternion &baseOrientation);
+
+	bool getBaseVelocity(int bodyUniqueId, btVector3 &baseLinearVelocity, btVector3 &baseAngularVelocity) const;
+	bool resetBaseVelocity(int bodyUniqueId, const btVector3 &linearVelocity, const btVector3 &angularVelocity) const;
+
+	int getNumJoints(int bodyUniqueId) const;
+
+	bool getJointInfo(int bodyUniqueId, int jointIndex, b3JointInfo *jointInfo);
+
+	int createConstraint(int parentBodyIndex, int parentJointIndex, int childBodyIndex, int childJointIndex, b3JointInfo *jointInfo);
+
+	int changeConstraint(int constraintId, b3RobotUserConstraint*jointInfo);
+
+	void removeConstraint(int constraintId);
+
+	bool getConstraintInfo(int constraintUniqueId, struct b3UserConstraint &constraintInfo);
+
+	bool getJointState(int bodyUniqueId, int jointIndex, struct b3JointSensorState *state);
+
+	bool getJointStates(int bodyUniqueId, b3JointStates2 &state);
+
+	bool resetJointState(int bodyUniqueId, int jointIndex, double targetValue);
+
+	void setJointMotorControl(int bodyUniqueId, int jointIndex, const struct b3RobotSimulatorJointMotorArgs &args);
+
+	bool setJointMotorControlArray(int bodyUniqueId, int controlMode, int numControlledDofs,
+								   int *jointIndices, double *targetVelocities, double *targetPositions,
+								   double *forces, double *kps, double *kds);
+
+	void stepSimulation();
+
+	bool canSubmitCommand() const;
+
+	void setRealTimeSimulation(bool enableRealTimeSimulation);
+
+	void setInternalSimFlags(int flags);
+
+	void setGravity(const btVector3 &gravityAcceleration);
+
+	void setTimeStep(double timeStepInSeconds);
+	void setNumSimulationSubSteps(int numSubSteps);
+	void setNumSolverIterations(int numIterations);
+	void setContactBreakingThreshold(double threshold);
+
+	int computeDofCount(int bodyUniqueId) const;
+	
+	bool calculateInverseKinematics(const struct b3RobotSimulatorInverseKinematicArgs &args, struct b3RobotSimulatorInverseKinematicsResults &results);
+
+	int calculateMassMatrix(int bodyUniqueId, const double* jointPositions, int numJointPositions, double* massMatrix, int flags);
+	
+	bool getBodyJacobian(int bodyUniqueId, int linkIndex, const double *localPosition, const double *jointPositions, const double *jointVelocities, const double *jointAccelerations, double *linearJacobian, double *angularJacobian);
+
+	void configureDebugVisualizer(enum b3ConfigureDebugVisualizerEnum flag, int enable);
+	void resetDebugVisualizerCamera(double cameraDistance, double cameraPitch, double cameraYaw, const btVector3 &targetPos);
+
+	int startStateLogging(b3StateLoggingType loggingType, const std::string &fileName, const btAlignedObjectArray<int> &objectUniqueIds = btAlignedObjectArray<int>(), int maxLogDof = -1);
+	void stopStateLogging(int stateLoggerUniqueId);
+
+	void getVREvents(b3VREventsData *vrEventsData, int deviceTypeFilter);
+	void getKeyboardEvents(b3KeyboardEventsData *keyboardEventsData);
+
+	void submitProfileTiming(const std::string &profileName);
+
+	// JFC: added these 24 methods
+
+	void getMouseEvents(b3MouseEventsData *mouseEventsData);
+
+	bool getLinkState(int bodyUniqueId, int linkIndex, int computeLinkVelocity, int computeForwardKinematics, b3LinkState *linkState);
+
+	bool getCameraImage(int width, int height, struct b3RobotSimulatorGetCameraImageArgs args, b3CameraImageData &imageData);
+
+	bool calculateInverseDynamics(int bodyUniqueId, double *jointPositions, double *jointVelocities, double *jointAccelerations, double *jointForcesOutput);
+
+	int getNumBodies() const;
+
+	int getBodyUniqueId(int bodyId) const;
+
+	bool removeBody(int bodyUniqueId);
+
+	bool getDynamicsInfo(int bodyUniqueId, int linkIndex, b3DynamicsInfo *dynamicsInfo);
+
+	bool changeDynamics(int bodyUniqueId, int linkIndex, struct b3RobotSimulatorChangeDynamicsArgs &args);
+
+	int addUserDebugParameter(const char *paramName, double rangeMin, double rangeMax, double startValue);
+
+	double readUserDebugParameter(int itemUniqueId);
+
+	bool removeUserDebugItem(int itemUniqueId);
+
+	int addUserDebugText(const char *text, double *textPosition, struct b3RobotSimulatorAddUserDebugTextArgs &args);
+
+	int addUserDebugText(const char *text, btVector3 &textPosition, struct b3RobotSimulatorAddUserDebugTextArgs &args);
+
+	int addUserDebugLine(double *fromXYZ, double *toXYZ, struct b3RobotSimulatorAddUserDebugLineArgs &args);
+
+	int addUserDebugLine(btVector3 &fromXYZ, btVector3 &toXYZ, struct b3RobotSimulatorAddUserDebugLineArgs &args);
+
+	bool setJointMotorControlArray(int bodyUniqueId, struct b3RobotSimulatorJointMotorArrayArgs &args);
+
+	bool setPhysicsEngineParameter(const struct b3RobotSimulatorSetPhysicsEngineParameters &args);
+
+	bool getPhysicsEngineParameters(struct b3RobotSimulatorSetPhysicsEngineParameters &args);
+
+	bool applyExternalForce(int objectUniqueId, int linkIndex, double *force, double *position, int flags);
+
+	bool applyExternalForce(int objectUniqueId, int linkIndex, btVector3 &force, btVector3 &position, int flags);
+
+	bool applyExternalTorque(int objectUniqueId, int linkIndex, double *torque, int flags);
+
+	bool applyExternalTorque(int objectUniqueId, int linkIndex, btVector3 &torque, int flags);
+
+	bool enableJointForceTorqueSensor(int bodyUniqueId, int jointIndex, bool enable);
+
+	bool getDebugVisualizerCamera(struct b3OpenGLVisualizerCameraInfo *cameraInfo);
+
+	bool getContactPoints(struct b3RobotSimulatorGetContactPointsArgs &args, struct b3ContactInformation *contactInfo);
+
+	bool getClosestPoints(struct b3RobotSimulatorGetContactPointsArgs &args, double distance, struct b3ContactInformation *contactInfo);
+
+	bool getOverlappingObjects(double *aabbMin, double *aabbMax, struct b3AABBOverlapData *overlapData);
+
+	bool getOverlappingObjects(btVector3 &aabbMin, btVector3 &aabbMax, struct b3AABBOverlapData *overlapData);
+
+	bool getAABB(int bodyUniqueId, int linkIndex, double *aabbMin, double *aabbMax);
+
+	bool getAABB(int bodyUniqueId, int linkIndex, btVector3 &aabbMin, btVector3 &aabbMax);
+
+	int createVisualShape(int shapeType, struct b3RobotSimulatorCreateVisualShapeArgs& args);
+
+	int createCollisionShape(int shapeType, struct b3RobotSimulatorCreateCollisionShapeArgs &args);
+
+	int createMultiBody(struct b3RobotSimulatorCreateMultiBodyArgs &args);
+
+	int getNumConstraints() const;
+
+	int getConstraintUniqueId(int serialIndex);
+
+	void loadSoftBody(const std::string &fileName, const struct b3RobotSimulatorLoadSoftBodyArgs &args);
+    
+	void loadDeformableBody(const std::string &fileName, const struct b3RobotSimulatorLoadDeformableBodyArgs &args);
+
+	virtual void setGuiHelper(struct GUIHelperInterface *guiHelper);
+	virtual struct GUIHelperInterface *getGuiHelper();
+
+	bool getCollisionShapeData(int bodyUniqueId, int linkIndex, b3CollisionShapeInformation &collisionShapeInfo);
+
+	bool getVisualShapeData(int bodyUniqueId, struct b3VisualShapeInformation &visualShapeInfo);
+
+	int saveStateToMemory();
+	void restoreStateFromMemory(int stateId);
+	void removeState(int stateUniqueId);
+
+	int getAPIVersion() const
+	{
+		return SHARED_MEMORY_MAGIC_NUMBER;
+	}
+	void setAdditionalSearchPath(const std::string &path);
+    
+    void setCollisionFilterGroupMask(int bodyUniqueIdA, int linkIndexA, int collisionFilterGroup, int collisionFilterMask);
+};
+
+#endif  //B3_ROBOT_SIMULATOR_CLIENT_API_NO_DIRECT_H
diff --git a/engine/inc/bullet/SharedMemory/b3RobotSimulatorClientAPI_NoGUI.h b/engine/inc/bullet/SharedMemory/b3RobotSimulatorClientAPI_NoGUI.h
new file mode 100644
index 00000000..b0a4a8de
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/b3RobotSimulatorClientAPI_NoGUI.h
@@ -0,0 +1,18 @@
+#ifndef B3_ROBOT_SIMULATOR_CLIENT_API_H
+#define B3_ROBOT_SIMULATOR_CLIENT_API_H
+
+#include "b3RobotSimulatorClientAPI_NoDirect.h"
+
+///The b3RobotSimulatorClientAPI is pretty much the C++ version of pybullet
+///as documented in the pybullet Quickstart Guide
+///https://docs.google.com/document/d/10sXEhzFRSnvFcl3XxNGhnD4N2SedqwdAvK3dsihxVUA
+class b3RobotSimulatorClientAPI_NoGUI : public b3RobotSimulatorClientAPI_NoDirect
+{
+public:
+	b3RobotSimulatorClientAPI_NoGUI();
+	virtual ~b3RobotSimulatorClientAPI_NoGUI();
+
+	bool connect(int mode, const std::string& hostName = "localhost", int portOrKey = -1);
+};
+
+#endif  //B3_ROBOT_SIMULATOR_CLIENT_API_H
diff --git a/engine/inc/bullet/SharedMemory/dart/DARTPhysicsC_API.h b/engine/inc/bullet/SharedMemory/dart/DARTPhysicsC_API.h
new file mode 100644
index 00000000..48aeb70d
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/dart/DARTPhysicsC_API.h
@@ -0,0 +1,21 @@
+#ifndef DART_PHYSICS_C_API_H
+#define DART_PHYSICS_C_API_H
+
+#ifdef BT_ENABLE_DART
+
+#include "../PhysicsClientC_API.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	//think more about naming. The b3ConnectPhysicsLoopback
+	B3_SHARED_API b3PhysicsClientHandle b3ConnectPhysicsDART();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  //BT_ENABLE_DART
+#endif  //DART_PHYSICS_C_API_H
diff --git a/engine/inc/bullet/SharedMemory/dart/DARTPhysicsClient.h b/engine/inc/bullet/SharedMemory/dart/DARTPhysicsClient.h
new file mode 100644
index 00000000..45700914
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/dart/DARTPhysicsClient.h
@@ -0,0 +1,121 @@
+#ifndef DART_PHYSICS_CLIENT_H
+#define DART_PHYSICS_CLIENT_H
+
+#include "../PhysicsClient.h"
+
+///PhysicsDirect executes the commands directly, without transporting them or having a separate server executing commands
+class DARTPhysicsClient : public PhysicsClient
+{
+protected:
+	struct DARTPhysicsDirectInternalData* m_data;
+
+	bool processDebugLines(const struct SharedMemoryCommand& orgCommand);
+
+	bool processCamera(const struct SharedMemoryCommand& orgCommand);
+
+	bool processContactPointData(const struct SharedMemoryCommand& orgCommand);
+
+	bool processOverlappingObjects(const struct SharedMemoryCommand& orgCommand);
+
+	bool processVisualShapeData(const struct SharedMemoryCommand& orgCommand);
+
+	void processBodyJointInfo(int bodyUniqueId, const struct SharedMemoryStatus& serverCmd);
+
+	void processAddUserData(const struct SharedMemoryStatus& serverCmd);
+
+	void postProcessStatus(const struct SharedMemoryStatus& serverCmd);
+
+	void resetData();
+
+	void removeCachedBody(int bodyUniqueId);
+
+public:
+	DARTPhysicsClient(class PhysicsCommandProcessorInterface* physSdk, bool passSdkOwnership);
+
+	virtual ~DARTPhysicsClient();
+
+	// return true if connection succesfull, can also check 'isConnected'
+	//it is OK to pass a null pointer for the gui helper
+	virtual bool connect();
+
+	////todo: rename to 'disconnect'
+	virtual void disconnectSharedMemory();
+
+	virtual bool isConnected() const;
+
+	// return non-null if there is a status, nullptr otherwise
+	virtual const SharedMemoryStatus* processServerStatus();
+
+	virtual SharedMemoryCommand* getAvailableSharedMemoryCommand();
+
+	virtual bool canSubmitCommand() const;
+
+	virtual bool submitClientCommand(const struct SharedMemoryCommand& command);
+
+	virtual int getNumBodies() const;
+
+	virtual int getBodyUniqueId(int serialIndex) const;
+
+	virtual bool getBodyInfo(int bodyUniqueId, struct b3BodyInfo& info) const;
+
+	virtual int getNumJoints(int bodyIndex) const;
+
+	virtual bool getJointInfo(int bodyIndex, int jointIndex, struct b3JointInfo& info) const;
+
+	virtual int getNumUserConstraints() const;
+
+	virtual int getUserConstraintInfo(int constraintUniqueId, struct b3UserConstraint& info) const;
+
+	virtual int getUserConstraintId(int serialIndex) const;
+
+	///todo: move this out of the
+	virtual void setSharedMemoryKey(int key);
+
+	void uploadBulletFileToSharedMemory(const char* data, int len);
+
+	virtual void uploadRaysToSharedMemory(struct SharedMemoryCommand& command, const double* rayFromWorldArray, const double* rayToWorldArray, int numRays);
+
+	virtual int getNumDebugLines() const;
+
+	virtual const float* getDebugLinesFrom() const;
+	virtual const float* getDebugLinesTo() const;
+	virtual const float* getDebugLinesColor() const;
+
+	virtual void getCachedCameraImage(b3CameraImageData* cameraData);
+
+	virtual void getCachedContactPointInformation(struct b3ContactInformation* contactPointData);
+
+	virtual void getCachedOverlappingObjects(struct b3AABBOverlapData* overlappingObjects);
+
+	virtual void getCachedVisualShapeInformation(struct b3VisualShapeInformation* visualShapesInfo);
+
+	virtual void getCachedCollisionShapeInformation(struct b3CollisionShapeInformation* collisionShapesInfo);
+
+	virtual void getCachedVREvents(struct b3VREventsData* vrEventsData);
+
+	virtual void getCachedKeyboardEvents(struct b3KeyboardEventsData* keyboardEventsData);
+
+	virtual void getCachedMouseEvents(struct b3MouseEventsData* mouseEventsData);
+
+	virtual void getCachedRaycastHits(struct b3RaycastInformation* raycastHits);
+
+	virtual void getCachedMassMatrix(int dofCountCheck, double* massMatrix);
+
+	//the following APIs are for internal use for visualization:
+	virtual bool connect(struct GUIHelperInterface* guiHelper);
+	virtual void renderScene();
+	virtual void debugDraw(int debugDrawMode);
+
+	virtual void setTimeOut(double timeOutInSeconds);
+	virtual double getTimeOut() const;
+
+	virtual bool getCachedUserData(int bodyUniqueId, int linkIndex, int userDataId, struct b3UserDataValue& valueOut) const;
+	virtual int getCachedUserDataId(int bodyUniqueId, int linkIndex, const char* key) const;
+	virtual int getNumUserData(int bodyUniqueId, int linkIndex) const;
+	virtual void getUserDataInfo(int bodyUniqueId, int linkIndex, int userDataIndex, const char** keyOut, int* userDataIdOut) const;
+
+	virtual void pushProfileTiming(const char* timingName);
+	virtual void popProfileTiming();
+};
+
+#endif  //DART_PHYSICS__H
diff --git a/engine/inc/bullet/SharedMemory/dart/DARTPhysicsServerCommandProcessor.h b/engine/inc/bullet/SharedMemory/dart/DARTPhysicsServerCommandProcessor.h
new file mode 100644
index 00000000..af028598
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/dart/DARTPhysicsServerCommandProcessor.h
@@ -0,0 +1,29 @@
+#ifndef DART_PHYSICS_SERVER_COMMAND_PROCESSOR_H
+#define DART_PHYSICS_SERVER_COMMAND_PROCESSOR_H
+
+#include "../PhysicsCommandProcessorInterface.h"
+
+class DARTPhysicsServerCommandProcessor : public PhysicsCommandProcessorInterface
+{
+public:
+	DARTPhysicsServerCommandProcessor();
+
+	virtual ~DARTPhysicsServerCommandProcessor();
+
+	virtual bool connect();
+
+	virtual void disconnect();
+
+	virtual bool isConnected() const;
+
+	virtual bool processCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+
+	virtual bool receiveStatus(struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+
+	virtual void renderScene(int renderFlags) {}
+	virtual void physicsDebugDraw(int debugDrawFlags) {}
+	virtual void setGuiHelper(struct GUIHelperInterface* guiHelper) {}
+	virtual void setTimeOut(double timeOutInSeconds) {}
+};
+
+#endif  //DART_PHYSICS_COMMAND_PROCESSOR_H
diff --git a/engine/inc/bullet/SharedMemory/grpc/ConvertGRPCBullet.h b/engine/inc/bullet/SharedMemory/grpc/ConvertGRPCBullet.h
new file mode 100644
index 00000000..4279eeeb
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/grpc/ConvertGRPCBullet.h
@@ -0,0 +1,21 @@
+
+#ifndef BT_CONVERT_GRPC_BULLET_H
+#define BT_CONVERT_GRPC_BULLET_H
+
+#include "../PhysicsClientC_API.h"
+
+namespace pybullet_grpc
+{
+class PyBulletCommand;
+class PyBulletStatus;
+};  // namespace pybullet_grpc
+
+struct SharedMemoryCommand* convertGRPCToBulletCommand(const pybullet_grpc::PyBulletCommand& grpcCommand, struct SharedMemoryCommand& cmd);
+
+pybullet_grpc::PyBulletCommand* convertBulletToGRPCCommand(const struct SharedMemoryCommand& clientCmd, pybullet_grpc::PyBulletCommand& grpcCommand);
+
+bool convertGRPCToStatus(const pybullet_grpc::PyBulletStatus& grpcReply, struct SharedMemoryStatus& serverStatus, char* bufferServerToClient, int bufferSizeInBytes);
+
+bool convertStatusToGRPC(const struct SharedMemoryStatus& serverStatus, char* bufferServerToClient, int bufferSizeInBytes, pybullet_grpc::PyBulletStatus& grpcReply);
+
+#endif  //BT_CONVERT_GRPC_BULLET_H
\ No newline at end of file
diff --git a/engine/inc/bullet/SharedMemory/mujoco/MuJoCoPhysicsC_API.h b/engine/inc/bullet/SharedMemory/mujoco/MuJoCoPhysicsC_API.h
new file mode 100644
index 00000000..adb5df24
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/mujoco/MuJoCoPhysicsC_API.h
@@ -0,0 +1,21 @@
+#ifndef MUJOCO_PHYSICS_C_API_H
+#define MUJOCO_PHYSICS_C_API_H
+
+#ifdef BT_ENABLE_MUJOCO
+
+#include "../PhysicsClientC_API.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	//think more about naming. The b3ConnectPhysicsLoopback
+	B3_SHARED_API b3PhysicsClientHandle b3ConnectPhysicsMuJoCo();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  //BT_ENABLE_MUJOCO
+#endif  //MUJOCO_PHYSICS_C_API_H
diff --git a/engine/inc/bullet/SharedMemory/mujoco/MuJoCoPhysicsClient.h b/engine/inc/bullet/SharedMemory/mujoco/MuJoCoPhysicsClient.h
new file mode 100644
index 00000000..bbbe3181
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/mujoco/MuJoCoPhysicsClient.h
@@ -0,0 +1,121 @@
+#ifndef MUJOCO_PHYSICS_CLIENT_H
+#define MUJOCO_PHYSICS_CLIENT_H
+
+#include "../PhysicsClient.h"
+
+///PhysicsDirect executes the commands directly, without transporting them or having a separate server executing commands
+class MuJoCoPhysicsClient : public PhysicsClient
+{
+protected:
+	struct MuJoCoPhysicsDirectInternalData* m_data;
+
+	bool processDebugLines(const struct SharedMemoryCommand& orgCommand);
+
+	bool processCamera(const struct SharedMemoryCommand& orgCommand);
+
+	bool processContactPointData(const struct SharedMemoryCommand& orgCommand);
+
+	bool processOverlappingObjects(const struct SharedMemoryCommand& orgCommand);
+
+	bool processVisualShapeData(const struct SharedMemoryCommand& orgCommand);
+
+	void processBodyJointInfo(int bodyUniqueId, const struct SharedMemoryStatus& serverCmd);
+
+	void processAddUserData(const struct SharedMemoryStatus& serverCmd);
+
+	void postProcessStatus(const struct SharedMemoryStatus& serverCmd);
+
+	void resetData();
+
+	void removeCachedBody(int bodyUniqueId);
+
+public:
+	MuJoCoPhysicsClient(class PhysicsCommandProcessorInterface* physSdk, bool passSdkOwnership);
+
+	virtual ~MuJoCoPhysicsClient();
+
+	// return true if connection succesfull, can also check 'isConnected'
+	//it is OK to pass a null pointer for the gui helper
+	virtual bool connect();
+
+	////todo: rename to 'disconnect'
+	virtual void disconnectSharedMemory();
+
+	virtual bool isConnected() const;
+
+	// return non-null if there is a status, nullptr otherwise
+	virtual const SharedMemoryStatus* processServerStatus();
+
+	virtual SharedMemoryCommand* getAvailableSharedMemoryCommand();
+
+	virtual bool canSubmitCommand() const;
+
+	virtual bool submitClientCommand(const struct SharedMemoryCommand& command);
+
+	virtual int getNumBodies() const;
+
+	virtual int getBodyUniqueId(int serialIndex) const;
+
+	virtual bool getBodyInfo(int bodyUniqueId, struct b3BodyInfo& info) const;
+
+	virtual int getNumJoints(int bodyIndex) const;
+
+	virtual bool getJointInfo(int bodyIndex, int jointIndex, struct b3JointInfo& info) const;
+
+	virtual int getNumUserConstraints() const;
+
+	virtual int getUserConstraintInfo(int constraintUniqueId, struct b3UserConstraint& info) const;
+
+	virtual int getUserConstraintId(int serialIndex) const;
+
+	///todo: move this out of the
+	virtual void setSharedMemoryKey(int key);
+
+	void uploadBulletFileToSharedMemory(const char* data, int len);
+
+	virtual void uploadRaysToSharedMemory(struct SharedMemoryCommand& command, const double* rayFromWorldArray, const double* rayToWorldArray, int numRays);
+
+	virtual int getNumDebugLines() const;
+
+	virtual const float* getDebugLinesFrom() const;
+	virtual const float* getDebugLinesTo() const;
+	virtual const float* getDebugLinesColor() const;
+
+	virtual void getCachedCameraImage(b3CameraImageData* cameraData);
+
+	virtual void getCachedContactPointInformation(struct b3ContactInformation* contactPointData);
+
+	virtual void getCachedOverlappingObjects(struct b3AABBOverlapData* overlappingObjects);
+
+	virtual void getCachedVisualShapeInformation(struct b3VisualShapeInformation* visualShapesInfo);
+
+	virtual void getCachedCollisionShapeInformation(struct b3CollisionShapeInformation* collisionShapesInfo);
+
+	virtual void getCachedVREvents(struct b3VREventsData* vrEventsData);
+
+	virtual void getCachedKeyboardEvents(struct b3KeyboardEventsData* keyboardEventsData);
+
+	virtual void getCachedMouseEvents(struct b3MouseEventsData* mouseEventsData);
+
+	virtual void getCachedRaycastHits(struct b3RaycastInformation* raycastHits);
+
+	virtual void getCachedMassMatrix(int dofCountCheck, double* massMatrix);
+
+	//the following APIs are for internal use for visualization:
+	virtual bool connect(struct GUIHelperInterface* guiHelper);
+	virtual void renderScene();
+	virtual void debugDraw(int debugDrawMode);
+
+	virtual void setTimeOut(double timeOutInSeconds);
+	virtual double getTimeOut() const;
+
+	virtual bool getCachedUserData(int bodyUniqueId, int linkIndex, int userDataId, struct b3UserDataValue& valueOut) const;
+	virtual int getCachedUserDataId(int bodyUniqueId, int linkIndex, const char* key) const;
+	virtual int getNumUserData(int bodyUniqueId, int linkIndex) const;
+	virtual void getUserDataInfo(int bodyUniqueId, int linkIndex, int userDataIndex, const char** keyOut, int* userDataIdOut) const;
+
+	virtual void pushProfileTiming(const char* timingName);
+	virtual void popProfileTiming();
+};
+
+#endif  //MUJOCO_PHYSICS_CLIENT_H
diff --git a/engine/inc/bullet/SharedMemory/mujoco/MuJoCoPhysicsServerCommandProcessor.h b/engine/inc/bullet/SharedMemory/mujoco/MuJoCoPhysicsServerCommandProcessor.h
new file mode 100644
index 00000000..8e0e2bfc
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/mujoco/MuJoCoPhysicsServerCommandProcessor.h
@@ -0,0 +1,43 @@
+#ifndef MUJOCO_PHYSICS_SERVER_COMMAND_PROCESSOR_H
+#define MUJOCO_PHYSICS_SERVER_COMMAND_PROCESSOR_H
+
+#include "../PhysicsCommandProcessorInterface.h"
+
+class MuJoCoPhysicsServerCommandProcessor : public PhysicsCommandProcessorInterface
+{
+	struct MuJoCoPhysicsServerCommandProcessorInternalData* m_data;
+
+	bool processSyncBodyInfoCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRequestInternalDataCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processSyncUserDataCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processLoadMJCFCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRequestBodyInfoCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processForwardDynamicsCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processSendPhysicsParametersCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRequestActualStateCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processResetSimulationCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+
+	void resetSimulation();
+
+public:
+	MuJoCoPhysicsServerCommandProcessor();
+
+	virtual ~MuJoCoPhysicsServerCommandProcessor();
+
+	virtual bool connect();
+
+	virtual void disconnect();
+
+	virtual bool isConnected() const;
+
+	virtual bool processCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+
+	virtual bool receiveStatus(struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+
+	virtual void renderScene(int renderFlags) {}
+	virtual void physicsDebugDraw(int debugDrawFlags) {}
+	virtual void setGuiHelper(struct GUIHelperInterface* guiHelper) {}
+	virtual void setTimeOut(double timeOutInSeconds) {}
+};
+
+#endif  //MUJOCO_PHYSICS_COMMAND_PROCESSOR_H
diff --git a/engine/inc/bullet/SharedMemory/physx/PhysXC_API.h b/engine/inc/bullet/SharedMemory/physx/PhysXC_API.h
new file mode 100644
index 00000000..42d117fb
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/physx/PhysXC_API.h
@@ -0,0 +1,20 @@
+#ifndef PHYSX_C_API_H
+#define PHYSX_C_API_H
+
+#ifdef BT_ENABLE_PHYSX
+
+#include "../PhysicsClientC_API.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	B3_SHARED_API b3PhysicsClientHandle b3ConnectPhysX(int argc, char* argv[]);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  //BT_ENABLE_PHYSX
+#endif  //PHYSX_C_API_H
diff --git a/engine/inc/bullet/SharedMemory/physx/PhysXServerCommandProcessor.h b/engine/inc/bullet/SharedMemory/physx/PhysXServerCommandProcessor.h
new file mode 100644
index 00000000..7566268e
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/physx/PhysXServerCommandProcessor.h
@@ -0,0 +1,57 @@
+#ifndef PHYSX_SERVER_COMMAND_PROCESSOR_H
+#define PHYSX_SERVER_COMMAND_PROCESSOR_H
+
+#include "../PhysicsCommandProcessorInterface.h"
+
+class PhysXServerCommandProcessor : public PhysicsCommandProcessorInterface
+{
+	struct PhysXServerCommandProcessorInternalData* m_data;
+
+	bool processSyncBodyInfoCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRequestInternalDataCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processSyncUserDataCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processLoadURDFCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRequestBodyInfoCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processForwardDynamicsCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processSendPhysicsParametersCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRequestActualStateCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processResetSimulationCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processInitPoseCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processSendDesiredStateCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processChangeDynamicsInfoCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRequestPhysicsSimulationParametersCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRequestContactpointInformationCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processCreateCollisionShapeCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processSetAdditionalSearchPathCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processUserDebugDrawCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+	bool processRequestCameraImageCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+
+	bool processCustomCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+
+	void resetSimulation();
+	bool processStateLoggingCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+
+public:
+	PhysXServerCommandProcessor(int argc, char* argv[]);
+
+	virtual ~PhysXServerCommandProcessor();
+
+	virtual bool connect();
+
+	virtual void disconnect();
+
+	virtual bool isConnected() const;
+
+	virtual bool processCommand(const struct SharedMemoryCommand& clientCmd, struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+
+	virtual bool receiveStatus(struct SharedMemoryStatus& serverStatusOut, char* bufferServerToClient, int bufferSizeInBytes);
+
+	virtual void renderScene(int renderFlags) {}
+	virtual void physicsDebugDraw(int debugDrawFlags) {}
+	virtual void setGuiHelper(struct GUIHelperInterface* guiHelper) {}
+	virtual void setTimeOut(double timeOutInSeconds) {}
+
+	virtual void reportNotifications() {}
+};
+
+#endif  //PHYSX_SERVER_COMMAND_PROCESSOR_H
diff --git a/engine/inc/bullet/SharedMemory/physx/PhysXUrdfImporter.h b/engine/inc/bullet/SharedMemory/physx/PhysXUrdfImporter.h
new file mode 100644
index 00000000..2caef42c
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/physx/PhysXUrdfImporter.h
@@ -0,0 +1,116 @@
+#ifndef PHYSX_URDF_IMPORTER_H
+#define PHYSX_URDF_IMPORTER_H
+
+#include "../../Importers/ImportURDFDemo/URDFImporterInterface.h"
+#include "../../Importers/ImportURDFDemo/UrdfRenderingInterface.h"
+
+struct PhysXURDFTexture
+{
+	int m_width;
+	int m_height;
+	unsigned char* textureData1;
+	bool m_isCached;
+};
+
+
+
+
+
+///PhysXURDFImporter can deal with URDF and SDF files
+class PhysXURDFImporter : public URDFImporterInterface
+{
+	struct PhysXURDFInternalData* m_data;
+
+public:
+	PhysXURDFImporter(struct CommonFileIOInterface* fileIO=0,double globalScaling=1, int flags=0);
+
+	virtual ~PhysXURDFImporter();
+
+	virtual bool loadURDF(const char* fileName, bool forceFixedBase = false);
+
+	//warning: some quick test to load SDF: we 'activate' a model, so we can re-use URDF code path
+	virtual bool loadSDF(const char* fileName, bool forceFixedBase = false);
+	virtual int getNumModels() const;
+	virtual void activateModel(int modelIndex);
+	virtual void setBodyUniqueId(int bodyId);
+	virtual int getBodyUniqueId() const;
+	const char* getPathPrefix();
+
+	void printTree();  //for debugging
+
+	virtual int getRootLinkIndex() const;
+
+	virtual void getLinkChildIndices(int linkIndex, btAlignedObjectArray<int>& childLinkIndices) const;
+
+	virtual std::string getBodyName() const;
+
+	virtual std::string getLinkName(int linkIndex) const;
+
+	virtual bool getLinkColor(int linkIndex, btVector4& colorRGBA) const;
+
+	virtual bool getLinkColor2(int linkIndex, UrdfMaterialColor& matCol) const;
+
+	virtual void setLinkColor2(int linkIndex, struct UrdfMaterialColor& matCol) const;
+
+	virtual bool getLinkContactInfo(int urdflinkIndex, URDFLinkContactInfo& contactInfo) const;
+
+	virtual bool getLinkAudioSource(int linkIndex, SDFAudioSource& audioSource) const;
+
+	virtual std::string getJointName(int linkIndex) const;
+
+	virtual void getMassAndInertia(int linkIndex, btScalar& mass, btVector3& localInertiaDiagonal, btTransform& inertialFrame) const;
+	virtual void getMassAndInertia2(int urdfLinkIndex, btScalar& mass, btVector3& localInertiaDiagonal, btTransform& inertialFrame, int flags) const;
+
+	virtual bool getJointInfo(int urdfLinkIndex, btTransform& parent2joint, btTransform& linkTransformInWorld, btVector3& jointAxisInJointSpace, int& jointType, btScalar& jointLowerLimit, btScalar& jointUpperLimit, btScalar& jointDamping, btScalar& jointFriction) const;
+	virtual bool getJointInfo2(int urdfLinkIndex, btTransform& parent2joint, btTransform& linkTransformInWorld, btVector3& jointAxisInJointSpace, int& jointType, btScalar& jointLowerLimit, btScalar& jointUpperLimit, btScalar& jointDamping, btScalar& jointFriction, btScalar& jointMaxForce, btScalar& jointMaxVelocity) const;
+
+	virtual bool getRootTransformInWorld(btTransform& rootTransformInWorld) const;
+	virtual void setRootTransformInWorld(const btTransform& rootTransformInWorld);
+
+	
+
+	virtual int convertLinkVisualShapes3(
+		int linkIndex, const char* pathPrefix, const btTransform& localInertiaFrame,
+		const struct UrdfLink* linkPtr, const UrdfModel* model,
+		int collisionObjectUniqueId, int bodyUniqueId, struct   CommonFileIOInterface* fileIO) const;
+
+	virtual void convertLinkVisualShapes2(int linkIndex, int urdfIndex, const char* pathPrefix, const btTransform& inertialFrame, class btCollisionObject* colObj, int bodyUniqueId) const;
+
+	class btCollisionShape* convertURDFToCollisionShape(const struct UrdfCollision* collision, const char* urdfPathPrefix) const
+	{
+		return 0;
+	}
+
+	virtual int getUrdfFromCollisionShape(const btCollisionShape* collisionShape, UrdfCollision& collision) const;
+
+	///todo(erwincoumans) refactor this convertLinkCollisionShapes/memory allocation
+
+	virtual class btCompoundShape* convertLinkCollisionShapes(int linkIndex, const char* pathPrefix, const btTransform& localInertiaFrame) const
+	{
+		return 0;
+	}
+
+	virtual const struct UrdfLink* getUrdfLink(int urdfLinkIndex) const;
+
+	virtual const struct UrdfModel* getUrdfModel() const;
+
+	virtual int getCollisionGroupAndMask(int linkIndex, int& colGroup, int& colMask) const;
+
+	virtual int getNumAllocatedCollisionShapes() const;
+	virtual class btCollisionShape* getAllocatedCollisionShape(int index);
+
+	virtual int getNumAllocatedMeshInterfaces() const;
+	virtual class btStridingMeshInterface* getAllocatedMeshInterface(int index);
+
+	virtual int getNumAllocatedTextures() const;
+	virtual int getAllocatedTexture(int index) const;
+
+	virtual void setEnableTinyRenderer(bool enable);
+	//void convertURDFToVisualShapeInternal(const struct UrdfVisual* visual, const char* urdfPathPrefix, const class btTransform& visualTransform, btAlignedObjectArray<struct GLInstanceVertex>& verticesOut, btAlignedObjectArray<int>& indicesOut, btAlignedObjectArray<struct PhysXURDFTexture>& texturesOut, struct b3ImportMeshData& meshData) const;
+
+
+	int getNumPhysXLinks() const;
+
+};
+
+#endif  //PHYSX_URDF_IMPORTER_H
diff --git a/engine/inc/bullet/SharedMemory/physx/PhysXUserData.h b/engine/inc/bullet/SharedMemory/physx/PhysXUserData.h
new file mode 100644
index 00000000..b4149ee0
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/physx/PhysXUserData.h
@@ -0,0 +1,10 @@
+#ifndef PHYSX_USER_DATA_H
+#define PHYSX_USER_DATA_H
+
+struct MyPhysXUserData
+{
+	int m_graphicsUniqueId;
+	int m_bodyUniqueId;
+	int m_linkIndex;
+};
+#endif //PHYSX_USER_DATA_H
\ No newline at end of file
diff --git a/engine/inc/bullet/SharedMemory/physx/URDF2PhysX.h b/engine/inc/bullet/SharedMemory/physx/URDF2PhysX.h
new file mode 100644
index 00000000..8cae67c4
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/physx/URDF2PhysX.h
@@ -0,0 +1,26 @@
+#ifndef URDF2PHYSX_H
+#define URDF2PHYSX_H
+
+#include "Bullet3Common/b3AlignedObjectArray.h"
+#include "../../Importers/ImportURDFDemo/URDFJointTypes.h"
+
+namespace physx
+{
+	class PxBase;
+	class PxFoundation;
+	class PxPhysics;
+	class PxDefaultCpuDispatcher;
+	class PxScene;
+	class PxCooking;
+	class PxArticulationReducedCoordinate;
+};
+
+struct UrdfVisualShapeCache2
+{
+	b3AlignedObjectArray<UrdfMaterialColor> m_cachedUrdfLinkColors;
+	b3AlignedObjectArray<int> m_cachedUrdfLinkVisualShapeIndices;
+};
+
+physx::PxBase* URDF2PhysX(physx::PxFoundation* foundation, physx::PxPhysics* physics, physx::PxCooking* cooking, physx::PxScene* scene, class PhysXURDFImporter& u2p, int flags, const char* pathPrefix, const class btTransform& rootTransformInWorldSpace,struct CommonFileIOInterface* fileIO, bool createActiculation);
+
+#endif //URDF2PHYSX_H
\ No newline at end of file
diff --git a/engine/inc/bullet/SharedMemory/plugins/b3PluginAPI.h b/engine/inc/bullet/SharedMemory/plugins/b3PluginAPI.h
new file mode 100644
index 00000000..ef983abd
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/plugins/b3PluginAPI.h
@@ -0,0 +1,39 @@
+#ifndef B3_PLUGIN_API_H
+#define B3_PLUGIN_API_H
+
+#ifdef _WIN32
+#define B3_SHARED_API __declspec(dllexport)
+#elif defined(__GNUC__)
+#define B3_SHARED_API __attribute__((visibility("default")))
+#else
+#define B3_SHARED_API
+#endif
+
+#if defined(_WIN32)
+#define B3_API_ENTRY
+#define B3_API_CALL __cdecl
+#define B3_CALLBACK __cdecl
+#else
+#define B3_API_ENTRY
+#define B3_API_CALL
+#define B3_CALLBACK
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+	/* Plugin API */
+	typedef B3_API_ENTRY int(B3_API_CALL* PFN_INIT)(struct b3PluginContext* context);
+	typedef B3_API_ENTRY void(B3_API_CALL* PFN_EXIT)(struct b3PluginContext* context);
+	typedef B3_API_ENTRY int(B3_API_CALL* PFN_EXECUTE)(struct b3PluginContext* context, const struct b3PluginArguments* arguments);
+	typedef B3_API_ENTRY int(B3_API_CALL* PFN_TICK)(struct b3PluginContext* context);
+
+	typedef B3_API_ENTRY struct UrdfRenderingInterface*(B3_API_CALL* PFN_GET_RENDER_INTERFACE)(struct b3PluginContext* context);
+	typedef B3_API_ENTRY struct b3PluginCollisionInterface*(B3_API_CALL* PFN_GET_COLLISION_INTERFACE)(struct b3PluginContext* context);
+	typedef B3_API_ENTRY struct CommonFileIOInterface*(B3_API_CALL* PFN_GET_FILEIO_INTERFACE)(struct b3PluginContext* context);
+#ifdef __cplusplus
+}
+#endif
+
+#endif  //B3_PLUGIN_API_H
diff --git a/engine/inc/bullet/SharedMemory/plugins/b3PluginCollisionInterface.h b/engine/inc/bullet/SharedMemory/plugins/b3PluginCollisionInterface.h
new file mode 100644
index 00000000..e0e39439
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/plugins/b3PluginCollisionInterface.h
@@ -0,0 +1,32 @@
+#ifndef B3_PLUGIN_COLLISION_INTERFACE_H
+#define B3_PLUGIN_COLLISION_INTERFACE_H
+
+enum b3PluginCollisionFilterModes
+{
+	B3_FILTER_GROUPAMASKB_AND_GROUPBMASKA = 0,
+	B3_FILTER_GROUPAMASKB_OR_GROUPBMASKA
+};
+
+struct b3PluginCollisionInterface
+{
+	virtual void setBroadphaseCollisionFilter(
+		int objectUniqueIdA, int objectUniqueIdB,
+		int linkIndexA, int linkIndexB,
+		bool enableCollision) = 0;
+
+	virtual void removeBroadphaseCollisionFilter(
+		int objectUniqueIdA, int objectUniqueIdB,
+		int linkIndexA, int linkIndexB) = 0;
+
+	virtual int getNumRules() const = 0;
+
+	virtual void resetAll() = 0;
+
+	virtual int needsBroadphaseCollision(int objectUniqueIdA, int linkIndexA,
+										 int collisionFilterGroupA, int collisionFilterMaskA,
+										 int objectUniqueIdB, int linkIndexB,
+										 int collisionFilterGroupB, int collisionFilterMaskB,
+										 int filterMode) = 0;
+};
+
+#endif  //B3_PLUGIN_COLLISION_INTERFACE_H
\ No newline at end of file
diff --git a/engine/inc/bullet/SharedMemory/plugins/b3PluginContext.h b/engine/inc/bullet/SharedMemory/plugins/b3PluginContext.h
new file mode 100644
index 00000000..045c9c2a
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/plugins/b3PluginContext.h
@@ -0,0 +1,31 @@
+#ifndef B3_PLUGIN_CONTEXT_H
+#define B3_PLUGIN_CONTEXT_H
+
+#include "../PhysicsClientC_API.h"
+
+struct b3PluginContext
+{
+	b3PhysicsClientHandle m_physClient;
+
+	//plugin can modify the m_userPointer to store persistent object pointer (class or struct instance etc)
+	void* m_userPointer;
+
+	//plugin can provide additional return data for executePluginCommand.
+	//Lifetime of this m_returnData pointer is minimum of 
+	//next call to the next executePluginCommand or plugin termination.
+	b3UserDataValue* m_returnData;
+
+	const struct b3VRControllerEvent* m_vrControllerEvents;
+	int m_numVRControllerEvents;
+	const struct b3KeyboardEvent* m_keyEvents;
+	int m_numKeyEvents;
+	const struct b3MouseEvent* m_mouseEvents;
+	int m_numMouseEvents;
+	const struct b3Notification* m_notifications;
+	int m_numNotifications;
+
+	//only used for grpc/processClientCommands
+	class PhysicsCommandProcessorInterface* m_rpcCommandProcessorInterface;
+};
+
+#endif  //B3_PLUGIN_CONTEXT_H
\ No newline at end of file
diff --git a/engine/inc/bullet/SharedMemory/plugins/b3PluginFileIOInterface.h b/engine/inc/bullet/SharedMemory/plugins/b3PluginFileIOInterface.h
new file mode 100644
index 00000000..57c00cff
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/plugins/b3PluginFileIOInterface.h
@@ -0,0 +1 @@
+#error
\ No newline at end of file
diff --git a/engine/inc/bullet/SharedMemory/plugins/collisionFilterPlugin/collisionFilterPlugin.h b/engine/inc/bullet/SharedMemory/plugins/collisionFilterPlugin/collisionFilterPlugin.h
new file mode 100644
index 00000000..27e39223
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/plugins/collisionFilterPlugin/collisionFilterPlugin.h
@@ -0,0 +1,23 @@
+#ifndef COLLISION_FILTER_PLUGIN_H
+#define COLLISION_FILTER_PLUGIN_H
+
+#include "../b3PluginAPI.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	//the following 3 APIs are required
+	B3_SHARED_API int initPlugin_collisionFilterPlugin(struct b3PluginContext* context);
+	B3_SHARED_API void exitPlugin_collisionFilterPlugin(struct b3PluginContext* context);
+	B3_SHARED_API int executePluginCommand_collisionFilterPlugin(struct b3PluginContext* context, const struct b3PluginArguments* arguments);
+
+	//all the APIs below are optional
+	B3_SHARED_API struct b3PluginCollisionInterface* getCollisionInterface_collisionFilterPlugin(struct b3PluginContext* context);
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif  //#define COLLISION_FILTER_PLUGIN_H
diff --git a/engine/inc/bullet/SharedMemory/plugins/eglPlugin/eglRendererPlugin.h b/engine/inc/bullet/SharedMemory/plugins/eglPlugin/eglRendererPlugin.h
new file mode 100644
index 00000000..dd6eea82
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/plugins/eglPlugin/eglRendererPlugin.h
@@ -0,0 +1,23 @@
+#ifndef EGL_RENDERER_PLUGIN_H
+#define EGL_RENDERER_PLUGIN_H
+
+#include "../b3PluginAPI.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	//initPlugin, exitPlugin and executePluginCommand are required, otherwise plugin won't load
+	B3_SHARED_API int initPlugin_eglRendererPlugin(struct b3PluginContext* context);
+	B3_SHARED_API void exitPlugin_eglRendererPlugin(struct b3PluginContext* context);
+	B3_SHARED_API int executePluginCommand_eglRendererPlugin(struct b3PluginContext* context, const struct b3PluginArguments* arguments);
+
+	//all the APIs below are optional
+	B3_SHARED_API struct UrdfRenderingInterface* getRenderInterface_eglRendererPlugin(struct b3PluginContext* context);
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif  //#define EGL_RENDERER_PLUGIN_H
diff --git a/engine/inc/bullet/SharedMemory/plugins/eglPlugin/eglRendererVisualShapeConverter.h b/engine/inc/bullet/SharedMemory/plugins/eglPlugin/eglRendererVisualShapeConverter.h
new file mode 100644
index 00000000..3247bb48
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/plugins/eglPlugin/eglRendererVisualShapeConverter.h
@@ -0,0 +1,75 @@
+#ifndef EGL_RENDERER_VISUAL_SHAPE_CONVERTER_H
+#define EGL_RENDERER_VISUAL_SHAPE_CONVERTER_H
+
+#include "../../../Importers/ImportURDFDemo/UrdfRenderingInterface.h"
+
+struct EGLRendererVisualShapeConverter : public UrdfRenderingInterface
+{
+	struct EGLRendererVisualShapeConverterInternalData* m_data;
+
+	EGLRendererVisualShapeConverter();
+
+	virtual ~EGLRendererVisualShapeConverter();
+
+	virtual int convertVisualShapes(int linkIndex, const char* pathPrefix, const btTransform& localInertiaFrame, const UrdfLink* linkPtr, const UrdfModel* model, int orgGraphicsUniqueId, int bodyUniqueId, struct CommonFileIOInterface* fileIO);
+
+	virtual int getNumVisualShapes(int bodyUniqueId);
+
+	virtual int getVisualShapesData(int bodyUniqueId, int shapeIndex, struct b3VisualShapeData* shapeData);
+
+	virtual int registerShapeAndInstance(const b3VisualShapeData& visualShape, const float* vertices, int numvertices, const int* indices, int numIndices, int primitiveType, int textureId, int orgGraphicsUniqueId, int bodyUniqueId, int linkIndex);
+
+	virtual void updateShape(int shapeUniqueId, const btVector3* vertices, int numVertices, const btVector3* normals, int numNormals);
+
+	virtual void changeRGBAColor(int bodyUniqueId, int linkIndex, int shapeIndex, const double rgbaColor[4]);
+
+	virtual void changeInstanceFlags(int bodyUniqueId, int linkIndex, int shapeIndex, int flags);
+
+	virtual void changeShapeTexture(int objectUniqueId, int linkIndex, int shapeIndex, int textureUniqueId);
+
+	virtual void removeVisualShape(int shapeUid);
+
+	virtual void setUpAxis(int axis);
+
+	virtual void resetCamera(float camDist, float yaw, float pitch, float camPosX, float camPosY, float camPosZ);
+
+	virtual void clearBuffers(struct TGAColor& clearColor);
+
+	virtual void resetAll();
+
+	virtual void getWidthAndHeight(int& width, int& height);
+	virtual void setWidthAndHeight(int width, int height);
+	virtual void setLightDirection(float x, float y, float z);
+	virtual void setLightColor(float x, float y, float z);
+	virtual void setLightDistance(float dist);
+	virtual void setLightAmbientCoeff(float ambientCoeff);
+	virtual void setLightDiffuseCoeff(float diffuseCoeff);
+	virtual void setLightSpecularCoeff(float specularCoeff);
+	virtual void setShadow(bool hasShadow);
+	virtual void setFlags(int flags);
+
+	virtual void copyCameraImageData(unsigned char* pixelsRGBA, int rgbaBufferSizeInPixels, float* depthBuffer, int depthBufferSizeInPixels, int* segmentationMaskBuffer, int segmentationMaskSizeInPixels, int startPixelIndex, int* widthPtr, int* heightPtr, int* numPixelsCopied);
+	void copyCameraImageDataGL(unsigned char* pixelsRGBA, int rgbaBufferSizeInPixels, float* depthBuffer, int depthBufferSizeInPixels, int* segmentationMaskBuffer, int segmentationMaskSizeInPixels, int startPixelIndex, int* widthPtr, int* heightPtr, int* numPixelsCopied);
+
+	virtual void render();
+	virtual void render(const float viewMat[16], const float projMat[16]);
+
+	virtual int loadTextureFile(const char* filename, struct CommonFileIOInterface* fileIO);
+	virtual int registerTexture(unsigned char* texels, int width, int height);
+	virtual int registerTextureInternal(unsigned char* texels, int width, int height);
+	
+
+	virtual void setProjectiveTextureMatrices(const float viewMatrix[16], const float projectionMatrix[16]);
+	virtual void setProjectiveTexture(bool useProjectiveTexture);
+
+	virtual void syncTransform(int shapeUid, const class btTransform& worldTransform, const class btVector3& localScaling);
+
+	virtual void mouseMoveCallback(float x, float y);
+	virtual void mouseButtonCallback(int button, int state, float x, float y);
+
+	virtual bool getCameraInfo(int* width, int* height, float viewMatrix[16], float projectionMatrix[16], float camUp[3], float camForward[3], float hor[3], float vert[3], float* yaw, float* pitch, float* camDist, float cameraTarget[3]) const;
+	
+
+};
+
+#endif  //EGL_RENDERER_VISUAL_SHAPE_CONVERTER_H
diff --git a/engine/inc/bullet/SharedMemory/plugins/fileIOPlugin/fileIOPlugin.h b/engine/inc/bullet/SharedMemory/plugins/fileIOPlugin/fileIOPlugin.h
new file mode 100644
index 00000000..6a850390
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/plugins/fileIOPlugin/fileIOPlugin.h
@@ -0,0 +1,24 @@
+#ifndef FILE_IO_PLUGIN_H
+#define FILE_IO_PLUGIN_H
+
+#include "../b3PluginAPI.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	//initPlugin, exitPlugin and executePluginCommand are required, otherwise plugin won't load
+	B3_SHARED_API int initPlugin_fileIOPlugin(struct b3PluginContext* context);
+	B3_SHARED_API void exitPlugin_fileIOPlugin(struct b3PluginContext* context);
+	B3_SHARED_API int executePluginCommand_fileIOPlugin(struct b3PluginContext* context, const struct b3PluginArguments* arguments);
+
+	//all the APIs below are optional
+	B3_SHARED_API struct CommonFileIOInterface* getFileIOFunc_fileIOPlugin(struct b3PluginContext* context);
+	
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif  //#define FILE_IO_PLUGIN_H
diff --git a/engine/inc/bullet/SharedMemory/plugins/fileIOPlugin/zipFileIO.h b/engine/inc/bullet/SharedMemory/plugins/fileIOPlugin/zipFileIO.h
new file mode 100644
index 00000000..ab1a5ace
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/plugins/fileIOPlugin/zipFileIO.h
@@ -0,0 +1,305 @@
+
+#include "minizip/unzip.h"
+
+#define B3_ZIP_FILEIO_MAX_FILES   1024
+
+struct ZipFileIO : public CommonFileIOInterface
+{
+	std::string m_zipfileName;
+
+	unzFile	m_fileHandles[B3_ZIP_FILEIO_MAX_FILES ];
+	int m_numFileHandles;
+	unzFile m_zipfile;
+	voidpf m_stream;
+	unz_global_info m_global_info;
+	bool m_memoryFile;
+	b3AlignedObjectArray<char> m_buffer;
+	
+	ZipFileIO(int fileIOType, const char* zipfileName, CommonFileIOInterface* wrapperFileIO)
+		:CommonFileIOInterface(fileIOType,0),
+		m_zipfileName(zipfileName),
+		m_numFileHandles(0),
+		m_stream(0),
+		m_memoryFile(false)
+	{
+		m_pathPrefix = m_zipfileName.c_str();
+		for (int i=0;i<B3_ZIP_FILEIO_MAX_FILES ;i++)
+		{
+			m_fileHandles[i]=0;
+		}
+		m_zipfile = unzOpen(m_zipfileName.c_str());
+
+		if (m_zipfile == 0)
+		{
+			int fileIO = wrapperFileIO->fileOpen(m_zipfileName.c_str(), "rb");
+			if (fileIO >= 0)
+			{
+				int stream_size = wrapperFileIO->getFileSize(fileIO);
+				m_buffer.resize(stream_size);
+				int read_bytes = wrapperFileIO->fileRead(fileIO, &m_buffer[0], stream_size);
+				b3Assert(read_bytes == stream_size);
+				if (read_bytes != stream_size)
+				{
+					printf("Error: mismatch reading file %s, expected %d bytes, read %d\n", m_zipfileName.c_str(), stream_size, read_bytes);
+				}
+				zlib_filefunc_def api;  // callbacks for in-mem file
+				
+				m_stream = mem_simple_create_file(&api, &m_buffer[0], stream_size);
+
+				m_zipfile = unzAttach(m_stream, &api);
+				m_memoryFile = true;
+				wrapperFileIO->fileClose(fileIO);
+			}
+		}
+	}
+
+	
+		
+	static bool FileIOPluginFindFile(void* userPtr, const char* orgFileName, char* relativeFileName, int maxRelativeFileNameMaxLen)
+	{
+		ZipFileIO* fileIo = (ZipFileIO*) userPtr;
+		return fileIo->findFile(orgFileName, relativeFileName, maxRelativeFileNameMaxLen);
+	}
+
+	void closeZipFile()
+	{
+		if (m_zipfile)
+		{
+			if (m_memoryFile)
+			{
+				unzDetach(&m_zipfile);
+			}
+			else
+			{
+				unzClose(m_zipfile);
+			}
+		}
+		m_zipfile = 0;
+	}
+
+	virtual ~ZipFileIO()
+	{
+		for (int i=0;i<B3_ZIP_FILEIO_MAX_FILES;i++)
+		{
+			fileClose(i);
+		}
+		closeZipFile();
+		if (m_stream)
+		{
+			mem_simple_destroy_file(m_stream);
+		}
+	}
+
+	
+	virtual int fileOpen(const char* fileName, const char* mode)
+	{
+		
+		//search a free slot
+		int slot = -1;
+		for (int i=0;i<B3_ZIP_FILEIO_MAX_FILES ;i++)
+		{
+			if (m_fileHandles[i]==0)
+			{
+				slot=i;
+				break;
+			}
+		}
+		if (slot>=0)
+		{
+			
+			if (m_zipfile == NULL)
+			{
+				printf("%s: not found\n", m_zipfileName.c_str());
+				slot = -1;
+			} else
+			{
+				
+				int result = 0;
+				result = unzGetGlobalInfo(m_zipfile, &m_global_info );
+				if (result != UNZ_OK)
+				{
+					printf("could not read file global info from %s\n", m_zipfileName.c_str());
+					slot = -1;
+				}
+			}
+			if (slot >=0)
+			{
+				int result = unzLocateFile(m_zipfile, fileName, 0);
+				if (result == UNZ_OK)
+				{
+					unz_file_info info;
+					result = unzGetCurrentFileInfo(m_zipfile, &info, NULL, 0, NULL, 0, NULL, 0);
+					if (result != UNZ_OK)
+					{
+						printf("unzGetCurrentFileInfo() != UNZ_OK (%d)\n", result);
+						slot=-1;
+					}
+					else
+					{
+						result = unzOpenCurrentFile(m_zipfile);
+						if (result == UNZ_OK)
+						{
+							printf("zipFile::fileOpen %s in mode %s in fileHandle %d\n", fileName, mode, slot);
+							m_fileHandles[slot] = m_zipfile;
+						} else
+						{
+							slot=-1;
+						}
+					}
+				} else
+				{
+					slot=-1;
+					
+				}
+			}
+		}
+		return slot;
+	}
+	virtual int fileRead(int fileHandle, char* destBuffer, int numBytes)
+	{
+		int result = -1;
+		if (fileHandle>=0 && fileHandle < B3_ZIP_FILEIO_MAX_FILES )
+		{
+			unzFile f = m_fileHandles[fileHandle];
+			if (f)
+			{
+				result = unzReadCurrentFile(f, destBuffer,numBytes);
+				//::fread(destBuffer, 1, numBytes, f);
+			}
+		}
+		return result;
+			
+	}
+	virtual int fileWrite(int fileHandle,const char* sourceBuffer, int numBytes)
+	{
+#if 0
+		if (fileHandle>=0 && fileHandle < B3_ZIP_FILEIO_MAX_FILES )
+		{
+			FILE* f = m_fileHandles[fileHandle];
+			if (f)
+			{
+				return ::fwrite(sourceBuffer, 1, numBytes,m_fileHandles[fileHandle]);
+			}
+		}
+#endif
+		return -1;
+	}
+	virtual void fileClose(int fileHandle)
+	{
+		if (fileHandle>=0 && fileHandle < B3_ZIP_FILEIO_MAX_FILES )
+		{
+			unzFile f = m_fileHandles[fileHandle];
+			if (f)
+			{
+				printf("zipFile::fileClose slot %d\n", fileHandle);
+				m_fileHandles[fileHandle]=0;
+			}
+		}
+	}
+
+	virtual bool findResourcePath(const char* fileName, char* relativeFileName, int relativeFileNameSizeInBytes)
+	{
+		return b3ResourcePath::findResourcePath(fileName, relativeFileName, relativeFileNameSizeInBytes, ZipFileIO::FileIOPluginFindFile, this);
+	}
+
+
+	virtual bool findFile(const char* orgFileName, char* relativeFileName, int maxRelativeFileNameMaxLen)
+	{
+		int fileHandle = -1;
+		fileHandle = fileOpen(orgFileName, "rb");
+		if (fileHandle>=0)
+		{
+			//printf("original file found: [%s]\n", orgFileName);
+			sprintf(relativeFileName, "%s", orgFileName);
+			fileClose(fileHandle);
+			return true;
+		}
+
+		//printf("Trying various directories, relative to current working directory\n");
+		const char* prefix[] = {"./", "./data/", "../data/", "../../data/", "../../../data/", "../../../../data/"};
+		int numPrefixes = sizeof(prefix) / sizeof(const char*);
+
+		int f = 0;
+		bool fileFound = false;
+
+		for (int i = 0; !f && i < numPrefixes; i++)
+		{
+#ifdef _MSC_VER
+			sprintf_s(relativeFileName, maxRelativeFileNameMaxLen, "%s%s", prefix[i], orgFileName);
+#else
+			sprintf(relativeFileName, "%s%s", prefix[i], orgFileName);
+#endif
+			f = fileOpen(relativeFileName, "rb");
+			if (f>=0)
+			{
+				fileFound = true;
+				break;
+			}
+		}
+		if (f>=0)
+		{
+			fileClose(f);
+		}
+
+		return fileFound;
+	}
+	virtual char* readLine(int fileHandle, char* destBuffer, int numBytes)
+	{
+		int numRead = 0;
+				
+		if (fileHandle>=0 && fileHandle < B3_ZIP_FILEIO_MAX_FILES )
+		{
+			unzFile f = m_fileHandles[fileHandle];
+			if (f)
+			{
+				//return ::fgets(destBuffer, numBytes, m_fileHandles[fileHandle]);
+				char c = 0;
+				do
+				{
+					fileRead(fileHandle,&c,1);
+					if (c && c!='\n')
+					{
+						if (c!=13)
+						{
+							destBuffer[numRead++]=c;
+						} else
+						{
+							destBuffer[numRead++]=0;
+						}
+					}
+				} while (c != 0 && c != '\n' && numRead<(numBytes-1));
+			}
+		}
+		if (numRead<numBytes && numRead>0)
+		{
+			destBuffer[numRead]=0;
+			return &destBuffer[0];
+		}
+		return 0;
+	}
+	virtual int getFileSize(int fileHandle)
+	{
+		int size=0;
+
+		if (fileHandle>=0 && fileHandle < B3_ZIP_FILEIO_MAX_FILES )
+		{
+			unzFile f = m_fileHandles[fileHandle];
+			if (f)
+			{
+				unz_file_info info;
+				int result = unzGetCurrentFileInfo(f, &info, NULL, 0, NULL, 0, NULL, 0);
+				if (result == UNZ_OK)
+				{
+					size = info.uncompressed_size;
+				}
+			}
+		}
+		return size;
+	}
+
+	virtual void enableFileCaching(bool enable)
+	{
+		(void)enable;
+	}
+
+};
diff --git a/engine/inc/bullet/SharedMemory/plugins/grpcPlugin/grpcPlugin.h b/engine/inc/bullet/SharedMemory/plugins/grpcPlugin/grpcPlugin.h
new file mode 100644
index 00000000..1e1e2367
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/plugins/grpcPlugin/grpcPlugin.h
@@ -0,0 +1,26 @@
+#ifndef GRPC_PLUGIN_H
+#define GRPC_PLUGIN_H
+
+#include "../b3PluginAPI.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	//the following 3 APIs are required
+	B3_SHARED_API int initPlugin_grpcPlugin(struct b3PluginContext* context);
+	B3_SHARED_API void exitPlugin_grpcPlugin(struct b3PluginContext* context);
+	B3_SHARED_API int executePluginCommand_grpcPlugin(struct b3PluginContext* context, const struct b3PluginArguments* arguments);
+
+	//all the APIs below are optional
+	B3_SHARED_API int preTickPluginCallback_grpcPlugin(struct b3PluginContext* context);
+	B3_SHARED_API int postTickPluginCallback_grpcPlugin(struct b3PluginContext* context);
+
+	B3_SHARED_API int processClientCommands_grpcPlugin(struct b3PluginContext* context);
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif  //#define GRPC_PLUGIN_H
diff --git a/engine/inc/bullet/SharedMemory/plugins/pdControlPlugin/pdControlPlugin.h b/engine/inc/bullet/SharedMemory/plugins/pdControlPlugin/pdControlPlugin.h
new file mode 100644
index 00000000..1fc86912
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/plugins/pdControlPlugin/pdControlPlugin.h
@@ -0,0 +1,30 @@
+#ifndef PID_CONTROL_PLUGIN_H
+#define PID_CONTROL_PLUGIN_H
+
+#include "../b3PluginAPI.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	//the following 3 APIs are required
+	B3_SHARED_API int initPlugin_pdControlPlugin(struct b3PluginContext* context);
+	B3_SHARED_API void exitPlugin_pdControlPlugin(struct b3PluginContext* context);
+	B3_SHARED_API int executePluginCommand_pdControlPlugin(struct b3PluginContext* context, const struct b3PluginArguments* arguments);
+
+	///
+	enum PDControlCommandEnum
+	{
+		eSetPDControl = 1,
+		eRemovePDControl = 2,
+	};
+
+	//all the APIs below are optional
+	B3_SHARED_API int preTickPluginCallback_pdControlPlugin(struct b3PluginContext* context);
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif  //#define PID_CONTROL_PLUGIN_H
diff --git a/engine/inc/bullet/SharedMemory/plugins/stablePDPlugin/BulletConversion.h b/engine/inc/bullet/SharedMemory/plugins/stablePDPlugin/BulletConversion.h
new file mode 100644
index 00000000..0ae62c9e
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/plugins/stablePDPlugin/BulletConversion.h
@@ -0,0 +1,9 @@
+#ifndef BULLET_CONVERSION_H
+#define BULLET_CONVERSION_H
+
+class btMultiBody;
+#include "MathUtil.h"
+void btExtractJointBodyFromBullet(const btMultiBody* bulletMB, Eigen::MatrixXd& bodyDefs, Eigen::MatrixXd& jointMat);
+
+
+#endif  //BULLET_CONVERSION_H
\ No newline at end of file
diff --git a/engine/inc/bullet/SharedMemory/plugins/stablePDPlugin/KinTree.h b/engine/inc/bullet/SharedMemory/plugins/stablePDPlugin/KinTree.h
new file mode 100644
index 00000000..a1c459f4
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/plugins/stablePDPlugin/KinTree.h
@@ -0,0 +1,270 @@
+#pragma once
+
+#include <vector>
+#include <fstream>
+#include "Shape.h"
+#ifdef USE_JSON
+#include "json/json.h"
+#endif
+#include "MathUtil.h"
+
+class cKinTree
+{
+public:
+	// description of the joint tree representing an articulated figure
+	enum eJointType
+	{
+		eJointTypeRevolute,
+		eJointTypePlanar,
+		eJointTypePrismatic,
+		eJointTypeFixed,
+		eJointTypeSpherical,
+		eJointTypeNone,
+		eJointTypeMax
+	};
+
+	enum eJointDesc
+	{
+		eJointDescType,
+		eJointDescParent,
+		eJointDescAttachX,
+		eJointDescAttachY,
+		eJointDescAttachZ,
+		eJointDescAttachThetaX, // euler angles order rot(Z) * rot(Y) * rot(X)
+		eJointDescAttachThetaY,
+		eJointDescAttachThetaZ,
+		eJointDescLimLow0,
+		eJointDescLimLow1,
+		eJointDescLimLow2,
+		eJointDescLimHigh0,
+		eJointDescLimHigh1,
+		eJointDescLimHigh2,
+		eJointDescTorqueLim,
+		eJointDescForceLim,
+		eJointDescIsEndEffector,
+		eJointDescDiffWeight,
+		eJointDescParamOffset,
+		eJointDescMax
+	};
+	typedef Eigen::Matrix<double, 1, eJointDescMax> tJointDesc;
+
+	enum eBodyParam
+	{
+		eBodyParamShape,
+		eBodyParamMass,
+		eBodyParamColGroup, // 0 collides with nothing and 1 collides with everything
+		eBodyParamEnableFallContact,
+		eBodyParamAttachX,
+		eBodyParamAttachY,
+		eBodyParamAttachZ,
+		eBodyParamAttachThetaX, // Euler angles order XYZ
+		eBodyParamAttachThetaY,
+		eBodyParamAttachThetaZ,
+		eBodyParam0,
+		eBodyParam1,
+		eBodyParam2,
+		eBodyColorR,
+		eBodyColorG,
+		eBodyColorB,
+		eBodyColorA,
+		eBodyParamMax
+	};
+	typedef Eigen::Matrix<double, 1, eBodyParamMax> tBodyDef;
+
+	enum eDrawShape
+	{
+		eDrawShapeShape,
+		eDrawShapeParentJoint,
+		eDrawShapeAttachX,
+		eDrawShapeAttachY,
+		eDrawShapeAttachZ,
+		eDrawShapeAttachThetaX, // Euler angles order XYZ
+		eDrawShapeAttachThetaY,
+		eDrawShapeAttachThetaZ,
+		eDrawShapeParam0,
+		eDrawShapeParam1,
+		eDrawShapeParam2,
+		eDrawShapeColorR,
+		eDrawShapeColorG,
+		eDrawShapeColorB,
+		eDrawShapeColorA,
+		eDrawShapeMeshID,
+		eDrawShapeParamMax
+	};
+	typedef Eigen::Matrix<double, 1, eDrawShapeParamMax> tDrawShapeDef;
+
+	static const int gInvalidJointID;
+	static const int gPosDim;
+	static const int gRotDim;
+	static const int gRootDim;
+
+	static bool HasValidRoot(const Eigen::MatrixXd& joint_mat);
+	static tVector GetRootPos(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& state);
+	static void SetRootPos(const Eigen::MatrixXd& joint_mat, const tVector& pos, Eigen::VectorXd& out_state);
+	static tQuaternion GetRootRot(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& state);
+	static void SetRootRot(const Eigen::MatrixXd& joint_mat, const tQuaternion& rot, Eigen::VectorXd& out_state);
+	static tVector GetRootVel(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& vel);
+	static void SetRootVel(const Eigen::MatrixXd& joint_mat, const tVector& vel, Eigen::VectorXd& out_vel);
+	static tVector GetRootAngVel(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& vel);
+	static void SetRootAngVel(const Eigen::MatrixXd& joint_mat, const tVector& ang_vel, Eigen::VectorXd& out_vel);
+
+	static tVector CalcJointWorldPos(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& state, int joint_id);
+	static tVector LocalToWorldPos(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& state, int parent_id, const tVector& attach_pt);
+	static tQuaternion CalcJointWorldRot(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& state, int joint_id);
+	static void CalcJointWorldTheta(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& state, int joint_id, tVector& out_axis, double& out_theta);
+	
+	static tVector CalcJointWorldVel(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& state, const Eigen::VectorXd& vel, int joint_id);
+	static tVector CalcWorldVel(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& state, const Eigen::VectorXd& vel, int parent_id, const tVector& attach_pt);
+	static tVector CalcJointWorldAngularVel(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& state, const Eigen::VectorXd& vel, int joint_id);
+	static tVector CalcWorldAngularVel(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& state, const Eigen::VectorXd& vel, int parent_id, const tVector& attach_pt);
+
+	static int GetNumDof(const Eigen::MatrixXd& joint_mat);
+	static void ApplyStep(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& step, Eigen::VectorXd& out_pose);
+
+	static Eigen::VectorXi FindJointChain(const Eigen::MatrixXd& joint_mat, int joint_beg, int joint_end);
+	static bool IsAncestor(const Eigen::MatrixXd& joint_mat, int child_joint, int ancestor_joint, int& out_len);
+	static double CalcChainLength(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXi& chain);
+
+	static void CalcAABB(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& state, tVector& out_min, tVector& out_max);
+
+	static int GetParamOffset(const Eigen::MatrixXd& joint_mat, int joint_id);
+	static int GetParamSize(const Eigen::MatrixXd& joint_mat, int joint_id);
+	static int GetJointParamSize(eJointType joint_type);
+	static void GetJointParams(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& state, int j, Eigen::VectorXd& out_params);
+	static void SetJointParams(const Eigen::MatrixXd& joint_mat, int j, const Eigen::VectorXd& params, Eigen::VectorXd& out_state);
+	static eJointType GetJointType(const Eigen::MatrixXd& joint_mat, int joint_id);
+	static int GetParent(const Eigen::MatrixXd& joint_mat, int joint_id);
+	static bool HasParent(const Eigen::MatrixXd& joint_mat, int joint_id);
+	static bool IsRoot(const Eigen::MatrixXd& joint_mat, int joint_id);
+	static bool IsJointActuated(const Eigen::MatrixXd& joint_mat, int joint_id);
+	static double GetTorqueLimit(const Eigen::MatrixXd& joint_mat, int joint_id);
+	static double GetForceLimit(const Eigen::MatrixXd& joint_mat, int joint_id);
+	static bool IsEndEffector(const Eigen::MatrixXd& joint_mat, int joint_id);
+	
+	static tVector GetJointLimLow(const Eigen::MatrixXd& joint_mat, int joint_id);
+	static tVector GetJointLimHigh(const Eigen::MatrixXd& joint_mat, int joint_id);
+	static double GetJointDiffWeight(const Eigen::MatrixXd& joint_mat, int joint_id);
+	
+	static double CalcLinkLength(const Eigen::MatrixXd& joint_mat, int joint_id);
+	static tVector GetAttachPt(const Eigen::MatrixXd& joint_mat, int joint_id);
+	static tVector GetAttachTheta(const Eigen::MatrixXd& joint_mat, int joint_id);
+
+	// calculates the longest chain in the subtree of each joint
+	static void CalcMaxSubChainLengths(const Eigen::MatrixXd& joint_mat, Eigen::VectorXd& out_lengths);
+	static void CalcSubTreeMasses(const Eigen::MatrixXd& joint_mat, const Eigen::MatrixXd& body_defs, Eigen::VectorXd& out_masses);
+	
+	static tMatrix BuildAttachTrans(const Eigen::MatrixXd& joint_mat, int joint_id);
+	static tMatrix ChildParentTrans(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& state, int joint_id);
+	static tMatrix ParentChildTrans(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& state, int joint_id);
+	static tMatrix JointWorldTrans(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& state, int joint_id);
+	static tMatrix WorldJointTrans(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& state, int joint_id);
+
+#ifdef USE_JSON
+	static bool Load(const Json::Value& root, Eigen::MatrixXd& out_joint_mat);
+	static bool ParseBodyDef(const Json::Value& root, tBodyDef& out_def);
+	static bool ParseDrawShapeDef(const Json::Value& root, tDrawShapeDef& out_def);
+	static std::string BuildJointMatJson(const Eigen::MatrixXd& joint_mat);
+	static std::string BuildJointJson(int id, const tJointDesc& joint_desc);
+	static bool ParseJoint(const Json::Value& root, tJointDesc& out_joint_desc);
+#endif
+
+	static int GetNumJoints(const Eigen::MatrixXd& joint_mat);
+	static int GetRoot(const Eigen::MatrixXd& joint_mat);
+	static void FindChildren(const Eigen::MatrixXd& joint_mat, int joint_id, Eigen::VectorXi& out_children);
+
+	static bool LoadBodyDefs(const std::string& char_file, Eigen::MatrixXd& out_body_defs);
+	
+	static bool LoadDrawShapeDefs(const std::string& char_file, Eigen::MatrixXd& out_draw_defs);
+	
+	static cShape::eShape GetBodyShape(const Eigen::MatrixXd& body_defs, int part_id);
+	static tVector GetBodyAttachPt(const Eigen::MatrixXd& body_defs, int part_id);
+	static tVector GetBodyAttachTheta(const Eigen::MatrixXd& body_defs, int part_id);
+	static void GetBodyRotation(const Eigen::MatrixXd& body_defs, int part_id, tVector& out_axis, double& out_theta);
+	static double GetBodyMass(const Eigen::MatrixXd& body_defs, int part_id);
+	static int GetBodyColGroup(const Eigen::MatrixXd& body_defs, int part_id);
+	static bool GetBodyEnableFallContact(const Eigen::MatrixXd& body_defs, int part_id);
+	static void SetBodyEnableFallContact(int part_id, bool enable, Eigen::MatrixXd& out_body_defs);
+	static tVector GetBodySize(const Eigen::MatrixXd& body_defs, int part_id);
+	static tVector GetBodyColor(const Eigen::MatrixXd& body_defs, int part_id);
+	static double CalcTotalMass(const Eigen::MatrixXd& body_defs);
+	static bool IsValidBody(const Eigen::MatrixXd& body_defs, int part_id);
+	static tVector GetBodyLocalCoM(const Eigen::MatrixXd& body_defs, int part_id);
+
+	static int GetDrawShapeParentJoint(const tDrawShapeDef& shape);
+	static tVector GetDrawShapeAttachPt(const tDrawShapeDef& shape);
+	static tVector GetDrawShapeAttachTheta(const tDrawShapeDef& shape);
+	static void GetDrawShapeRotation(const tDrawShapeDef& shape, tVector& out_axis, double& out_theta);
+	static tVector GetDrawShapeColor(const tDrawShapeDef& shape);
+	static int GetDrawShapeMeshID(const tDrawShapeDef& shape);
+
+	static tVector CalcBodyPartPos(const Eigen::MatrixXd& joint_mat, const Eigen::MatrixXd& body_defs, const Eigen::VectorXd& state, int part_id);
+	static tVector CalcBodyPartVel(const Eigen::MatrixXd& joint_mat, const Eigen::MatrixXd& body_defs, const Eigen::VectorXd& state, const Eigen::VectorXd& vel, int part_id);
+	static void CalcBodyPartRotation(const Eigen::MatrixXd& joint_mat, const Eigen::MatrixXd& body_defs, const Eigen::VectorXd& state, int part_id, tVector& out_axis, double& out_theta);
+	static tMatrix BodyWorldTrans(const Eigen::MatrixXd& joint_mat, const Eigen::MatrixXd& body_defs, const Eigen::VectorXd& state, int part_id);
+	static tMatrix BodyJointTrans(const Eigen::MatrixXd& body_defs, int part_id);
+
+	static tJointDesc BuildJointDesc(eJointType joint_type, int parent_id, const tVector& attach_pt);
+	static tJointDesc BuildJointDesc();
+	static tBodyDef BuildBodyDef();
+	static tDrawShapeDef BuildDrawShapeDef();
+
+	static void BuildDefaultPose(const Eigen::MatrixXd& joint_mat, Eigen::VectorXd& out_pose);
+	static void BuildDefaultVel(const Eigen::MatrixXd& joint_mat, Eigen::VectorXd& out_vel);
+
+	static void CalcPoseDiff(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& pose0, const Eigen::VectorXd& pose1, Eigen::VectorXd& out_diff);
+	static tVector CalcRootPosDiff(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& pose0, const Eigen::VectorXd& pose1);
+	static tQuaternion CalcRootRotDiff(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& pose0, const Eigen::VectorXd& pose1);
+	static double CalcPoseErr(const Eigen::MatrixXd& joint_mat, int joint_id, const Eigen::VectorXd& pose0, const Eigen::VectorXd& pose1);
+	static double CalcRootPosErr(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& pose0, const Eigen::VectorXd& pose1);
+	static double CalcRootRotErr(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& pose0, const Eigen::VectorXd& pose1);
+
+	static void CalcVelDiff(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& vel0, const Eigen::VectorXd& vel1, Eigen::VectorXd& out_diff);
+	static tVector CalcRootVelDiff(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& pose0, const Eigen::VectorXd& pose1);
+	static tVector CalcRootAngVelDiff(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& pose0, const Eigen::VectorXd& pose1);
+	static double CalcVelErr(const Eigen::MatrixXd& joint_mat, int joint_id, const Eigen::VectorXd& vel0, const Eigen::VectorXd& vel1);
+	static double CalcRootVelErr(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& vel0, const Eigen::VectorXd& vel1);
+	static double CalcRootAngVelErr(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& vel0, const Eigen::VectorXd& vel1);
+
+	static void CalcVel(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& pose0, const Eigen::VectorXd& pose1, double dt, Eigen::VectorXd& out_vel);
+
+	static void PostProcessPose(const Eigen::MatrixXd& joint_mat, Eigen::VectorXd& out_pose);
+	static void LerpPoses(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& pose0, const Eigen::VectorXd& pose1, double lerp, Eigen::VectorXd& out_pose);
+	static void VelToPoseDiff(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& pose, const Eigen::VectorXd& vel, Eigen::VectorXd& out_pose_diff);
+
+	static double CalcHeading(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& pose);
+	static tQuaternion CalcHeadingRot(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& pose);
+	static tMatrix BuildHeadingTrans(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& pose);
+	static tMatrix BuildOriginTrans(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& pose);
+	static void NormalizePoseHeading(const Eigen::MatrixXd& joint_mat, Eigen::VectorXd& out_pose);
+	static void NormalizePoseHeading(const Eigen::MatrixXd& joint_mat, Eigen::VectorXd& out_pose, Eigen::VectorXd& out_vel);
+
+	
+
+protected:
+	static bool ParseJointType(const std::string& type_str, eJointType& out_joint_type);
+	static void PostProcessJointMat(Eigen::MatrixXd& out_joint_mat);
+
+	static tMatrix ChildParentTransRoot(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& state, int joint_id);
+	static tMatrix ChildParentTransRevolute(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& state, int joint_id);
+	static tMatrix ChildParentTransPlanar(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& state, int joint_id);
+	static tMatrix ChildParentTransFixed(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& state, int joint_id);
+	static tMatrix ChildParentTransPrismatic(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& state, int joint_id);
+	static tMatrix ChildParentTransSpherical(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& state, int joint_id);
+
+	static void BuildDefaultPoseRoot(const Eigen::MatrixXd& joint_mat, Eigen::VectorXd& out_pose);
+	static void BuildDefaultPoseRevolute(Eigen::VectorXd& out_pose);
+	static void BuildDefaultPosePrismatic(Eigen::VectorXd& out_pose);
+	static void BuildDefaultPosePlanar(Eigen::VectorXd& out_pose);
+	static void BuildDefaultPoseFixed(Eigen::VectorXd& out_pose);
+	static void BuildDefaultPoseSpherical(Eigen::VectorXd& out_pose);
+
+	static void BuildDefaultVelRoot(const Eigen::MatrixXd& joint_mat, Eigen::VectorXd& out_pose);
+	static void BuildDefaultVelRevolute(Eigen::VectorXd& out_pose);
+	static void BuildDefaultVelPrismatic(Eigen::VectorXd& out_pose);
+	static void BuildDefaultVelPlanar(Eigen::VectorXd& out_pose);
+	static void BuildDefaultVelFixed(Eigen::VectorXd& out_pose);
+	static void BuildDefaultVelSpherical(Eigen::VectorXd& out_pose);
+
+	static void CalcJointPoseDiff(const Eigen::MatrixXd& joint_mat, int joint_id, const Eigen::VectorXd& pose0, const Eigen::VectorXd& pose1, Eigen::VectorXd& out_diff);
+	static void CalcJointVelDiff(const Eigen::MatrixXd& joint_mat, int joint_id, const Eigen::VectorXd& vel0, const Eigen::VectorXd& vel1, Eigen::VectorXd& out_diff);
+};
diff --git a/engine/inc/bullet/SharedMemory/plugins/stablePDPlugin/MathUtil.h b/engine/inc/bullet/SharedMemory/plugins/stablePDPlugin/MathUtil.h
new file mode 100644
index 00000000..4c443235
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/plugins/stablePDPlugin/MathUtil.h
@@ -0,0 +1,131 @@
+#pragma once
+
+
+#include "Eigen/Dense"
+#include "Eigen/StdVector"
+#include "Eigen/Geometry"
+
+#define _USE_MATH_DEFINES
+#include "math.h"
+
+const int gInvalidIdx = -1;
+
+// for convenience define standard vector for rendering
+typedef Eigen::Vector4d tVector;
+typedef Eigen::Vector4d tVector3;
+typedef Eigen::Matrix4d tMatrix;
+typedef Eigen::Matrix3d tMatrix3;
+typedef Eigen::Quaterniond tQuaternion;
+
+
+const double gRadiansToDegrees = 57.2957795;
+const double gDegreesToRadians = 1.0 / gRadiansToDegrees;
+const tVector gGravity = tVector(0, -9.8, 0, 0);
+const double gInchesToMeters = 0.0254;
+const double gFeetToMeters = 0.3048;
+
+class cMathUtil
+{
+public:
+	enum eAxis
+	{
+		eAxisX,
+		eAxisY,
+		eAxisZ,
+		eAxisMax
+	};
+
+	static int Clamp(int val, int min, int max);
+	static void Clamp(const Eigen::VectorXd& min, const Eigen::VectorXd& max, Eigen::VectorXd& out_vec);
+	static double Clamp(double val, double min, double max);
+	static double Saturate(double val);
+	static double Lerp(double t, double val0, double val1);
+
+	static double NormalizeAngle(double theta);
+
+	static double SmoothStep(double t);
+
+	// matrices
+	static tMatrix TranslateMat(const tVector& trans);
+	static tMatrix ScaleMat(double scale);
+	static tMatrix ScaleMat(const tVector& scale);
+	static tMatrix RotateMat(const tVector& euler); // euler angles order rot(Z) * rot(Y) * rot(X)
+	static tMatrix RotateMat(const tVector& axis, double theta);
+	static tMatrix RotateMat(const tQuaternion& q);
+	static tMatrix CrossMat(const tVector& a);
+	// inverts a transformation consisting only of rotations and translations
+	static tMatrix InvRigidMat(const tMatrix& mat);
+	static tVector GetRigidTrans(const tMatrix& mat);
+	static tVector InvEuler(const tVector& euler);
+	static void RotMatToAxisAngle(const tMatrix& mat, tVector& out_axis, double& out_theta);
+	static tVector RotMatToEuler(const tMatrix& mat);
+	static tQuaternion RotMatToQuaternion(const tMatrix& mat);
+	static void EulerToAxisAngle(const tVector& euler, tVector& out_axis, double& out_theta);
+	
+	static tMatrix DirToRotMat(const tVector& dir, const tVector& up);
+
+	static void DeltaRot(const tVector& axis0, double theta0, const tVector& axis1, double theta1,
+							tVector& out_axis, double& out_theta);
+	static tMatrix DeltaRot(const tMatrix& R0, const tMatrix& R1);
+
+	static tQuaternion EulerToQuaternion(const tVector& euler);
+	
+	static tQuaternion AxisAngleToQuaternion(const tVector& axis, double theta);
+	static void QuaternionToAxisAngle(const tQuaternion& q, tVector& out_axis, double& out_theta);
+	static tMatrix BuildQuaternionDiffMat(const tQuaternion& q);
+	static tVector CalcQuaternionVel(const tQuaternion& q0, const tQuaternion& q1, double dt);
+	static tVector CalcQuaternionVelRel(const tQuaternion& q0, const tQuaternion& q1, double dt);
+	static tQuaternion VecToQuat(const tVector& v);
+	static tVector QuatToVec(const tQuaternion& q);
+	static tQuaternion QuatDiff(const tQuaternion& q0, const tQuaternion& q1);
+	static double QuatDiffTheta(const tQuaternion& q0, const tQuaternion& q1);
+	static double QuatTheta(const tQuaternion& dq);
+	static tQuaternion VecDiffQuat(const tVector& v0, const tVector& v1);
+	static tVector QuatRotVec(const tQuaternion& q, const tVector& dir);
+	static tQuaternion MirrorQuaternion(const tQuaternion& q, eAxis axis);
+
+	static double Sign(double val);
+	static int Sign(int val);
+
+	static double AddAverage(double avg0, int count0, double avg1, int count1);
+	static tVector AddAverage(const tVector& avg0, int count0, const tVector& avg1, int count1);
+	static void AddAverage(const Eigen::VectorXd& avg0, int count0, const Eigen::VectorXd& avg1, int count1, Eigen::VectorXd& out_result);
+	static void CalcSoftmax(const Eigen::VectorXd& vals, double temp, Eigen::VectorXd& out_prob);
+	static double EvalGaussian(const Eigen::VectorXd& mean, const Eigen::VectorXd& covar, const Eigen::VectorXd& sample);
+	static double EvalGaussian(double mean, double covar, double sample);
+	static double CalcGaussianPartition(const Eigen::VectorXd& covar);
+	static double EvalGaussianLogp(double mean, double covar, double sample);
+	static double EvalGaussianLogp(const Eigen::VectorXd& mean, const Eigen::VectorXd& covar, const Eigen::VectorXd& sample);
+	static double Sigmoid(double x);
+	static double Sigmoid(double x, double gamma, double bias);
+
+	static tVector CalcBarycentric(const tVector& p, const tVector& a, const tVector& b, const tVector& c);
+
+	static bool ContainsAABB(const tVector& pt, const tVector& aabb_min, const tVector& aabb_max);
+	static bool ContainsAABB(const tVector& aabb_min0, const tVector& aabb_max0, const tVector& aabb_min1, const tVector& aabb_max1);
+	static bool ContainsAABBXZ(const tVector& pt, const tVector& aabb_min, const tVector& aabb_max);
+	static bool ContainsAABBXZ(const tVector& aabb_min0, const tVector& aabb_max0, const tVector& aabb_min1, const tVector& aabb_max1);
+	static void CalcAABBIntersection(const tVector& aabb_min0, const tVector& aabb_max0, const tVector& aabb_min1, const tVector& aabb_max1,
+									tVector& out_min, tVector& out_max);
+	static void CalcAABBUnion(const tVector& aabb_min0, const tVector& aabb_max0, const tVector& aabb_min1, const tVector& aabb_max1,
+								tVector& out_min, tVector& out_max);
+	static bool IntersectAABB(const tVector& aabb_min0, const tVector& aabb_max0, const tVector& aabb_min1, const tVector& aabb_max1);
+	static bool IntersectAABBXZ(const tVector& aabb_min0, const tVector& aabb_max0, const tVector& aabb_min1, const tVector& aabb_max1);
+
+	// check if curr_val and curr_val - delta belong to different intervals
+	static bool CheckNextInterval(double delta, double curr_val, double int_size);
+
+	
+	static void QuatSwingTwistDecomposition(const tQuaternion& q, const tVector& dir, tQuaternion& out_swing, tQuaternion& out_twist);
+	static tQuaternion ProjectQuat(const tQuaternion& q, const tVector& dir);
+
+	static void ButterworthFilter(double dt, double cutoff, Eigen::VectorXd& out_x);
+	
+private:
+	
+	template <typename T>
+	static T SignAux(T val)
+	{
+		return (T(0) < val) - (val < T(0));
+	}
+};
diff --git a/engine/inc/bullet/SharedMemory/plugins/stablePDPlugin/RBDModel.h b/engine/inc/bullet/SharedMemory/plugins/stablePDPlugin/RBDModel.h
new file mode 100644
index 00000000..93b48457
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/plugins/stablePDPlugin/RBDModel.h
@@ -0,0 +1,71 @@
+#pragma once
+
+#include "SpAlg.h"
+#include "MathUtil.h"
+
+// this class is mostly to help with efficiency by precomputing some useful
+// quantities for RBD calculations
+class cRBDModel
+{
+public:
+	EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+	cRBDModel();
+	virtual ~cRBDModel();
+
+	virtual void Init(const Eigen::MatrixXd& joint_mat, const Eigen::MatrixXd& body_defs, const tVector& gravity);
+	virtual void Update(const Eigen::VectorXd& pose, const Eigen::VectorXd& vel);
+
+	virtual int GetNumDof() const;
+	virtual int GetNumJoints() const;
+
+	virtual const tVector& GetGravity() const;
+	virtual void SetGravity(const tVector& gravity);
+
+	virtual const Eigen::MatrixXd& GetJointMat() const;
+	virtual const Eigen::MatrixXd& GetBodyDefs() const;
+	virtual const Eigen::VectorXd& GetPose() const;
+	virtual const Eigen::VectorXd& GetVel() const;
+	virtual int GetParent(int j) const;
+
+	virtual const Eigen::MatrixXd& GetMassMat() const;
+	virtual const Eigen::VectorXd& GetBiasForce() const;
+	virtual Eigen::MatrixXd& GetInertiaBuffer();
+
+	virtual tMatrix GetChildParentMat(int j) const;
+	virtual tMatrix GetParentChildMat(int j) const;
+	virtual cSpAlg::tSpTrans GetSpChildParentTrans(int j) const;
+	virtual cSpAlg::tSpTrans GetSpParentChildTrans(int j) const;
+
+	virtual tMatrix GetWorldJointMat(int j) const;
+	virtual tMatrix GetJointWorldMat(int j) const;
+	virtual cSpAlg::tSpTrans GetSpWorldJointTrans(int j) const;
+	virtual cSpAlg::tSpTrans GetSpJointWorldTrans(int j) const;
+
+	virtual const Eigen::Block<const Eigen::MatrixXd> GetJointSubspace(int j) const;
+	virtual tVector CalcJointWorldPos(int j) const;
+
+protected:
+	tVector mGravity;
+	Eigen::MatrixXd mJointMat;
+	Eigen::MatrixXd mBodyDefs;
+	Eigen::VectorXd mPose;
+	Eigen::VectorXd mVel;
+
+	Eigen::MatrixXd mJointSubspaceArr;
+	Eigen::MatrixXd mChildParentMatArr;
+	Eigen::MatrixXd mSpWorldJointTransArr;
+	Eigen::MatrixXd mMassMat;
+	Eigen::VectorXd mBiasForce;
+	Eigen::MatrixXd mInertiaBuffer;
+
+	virtual void SetPose(const Eigen::VectorXd& pose);
+	virtual void SetVel(const Eigen::VectorXd& vel);
+
+	virtual void InitJointSubspaceArr();
+
+	virtual void UpdateJointSubspaceArr();
+	virtual void UpdateChildParentMatArr();
+	virtual void UpdateSpWorldTrans();
+	virtual void UpdateMassMat();
+	virtual void UpdateBiasForce();
+};
diff --git a/engine/inc/bullet/SharedMemory/plugins/stablePDPlugin/RBDUtil.h b/engine/inc/bullet/SharedMemory/plugins/stablePDPlugin/RBDUtil.h
new file mode 100644
index 00000000..aae03ebd
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/plugins/stablePDPlugin/RBDUtil.h
@@ -0,0 +1,85 @@
+#pragma once
+
+#include <vector>
+#include <fstream>
+
+#include "RBDModel.h"
+#include "KinTree.h"
+
+class cRBDUtil
+{
+public:
+	static void SolveInvDyna(const cRBDModel& model, const Eigen::VectorXd& acc, Eigen::VectorXd& out_tau);
+
+	static void SolveForDyna(const cRBDModel& model, const Eigen::VectorXd& tau, Eigen::VectorXd& out_acc);
+	static void SolveForDyna(const cRBDModel& model, const Eigen::VectorXd& tau, const Eigen::VectorXd& total_force, Eigen::VectorXd& out_acc);
+
+	static void BuildMassMat(const cRBDModel& model, Eigen::MatrixXd& out_mass_mat);
+	static void BuildMassMat(const cRBDModel& model, Eigen::MatrixXd& inertia_buffer, Eigen::MatrixXd& out_mass_mat);
+	static void BuildBiasForce(const cRBDModel& model, Eigen::VectorXd& out_bias_force);
+
+	static void CalcGravityForce(const cRBDModel& model, Eigen::VectorXd& out_g_force);
+
+	static void BuildEndEffectorJacobian(const cRBDModel& model, int joint_id, Eigen::MatrixXd& out_J);
+	static void BuildEndEffectorJacobian(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& pose, int joint_id, Eigen::MatrixXd& out_J);
+	static Eigen::MatrixXd MultJacobianEndEff(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& vel, const Eigen::MatrixXd& J, int joint_id);
+
+	static void BuildJacobian(const cRBDModel& model, Eigen::MatrixXd& out_J);
+	static Eigen::MatrixXd ExtractEndEffJacobian(const Eigen::MatrixXd& joint_mat, const Eigen::MatrixXd& J, int joint_id);
+
+	static void BuildCOMJacobian(const cRBDModel& model, Eigen::MatrixXd& out_J);
+	static void BuildCOMJacobian(const cRBDModel& model, const Eigen::MatrixXd& J, Eigen::MatrixXd& out_J);
+	static void BuildJacobianDot(const cRBDModel& model, Eigen::MatrixXd& out_J_dot);
+
+	static cSpAlg::tSpVec BuildCOMVelProdAcc(const cRBDModel& model);
+	static cSpAlg::tSpVec BuildCOMVelProdAccAux(const cRBDModel& model, const Eigen::MatrixXd& Jd);
+	static cSpAlg::tSpVec CalcVelProdAcc(const cRBDModel& model, const Eigen::MatrixXd& Jd, int joint_id);
+
+	static cSpAlg::tSpVec CalcJointWorldVel(const cRBDModel& model, int joint_id);
+	static cSpAlg::tSpVec CalcJointWorldVel(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& state, const Eigen::VectorXd& vel, int joint_id);
+	static cSpAlg::tSpVec CalcWorldVel(const cRBDModel& model, int joint_id);
+	static cSpAlg::tSpVec CalcWorldVel(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& state, const Eigen::VectorXd& vel, int joint_id);
+
+
+	static tVector CalcCoMPos(const cRBDModel& model);
+	static tVector CalcCoMVel(const cRBDModel& model);
+	static tVector CalcCoMVel(const Eigen::MatrixXd& joint_mat, const Eigen::MatrixXd& body_defs, const Eigen::VectorXd& pose, const Eigen::VectorXd& vel);
+	static void CalcCoM(const cRBDModel& model, tVector& out_com, tVector& out_vel);
+	static void CalcCoM(const Eigen::MatrixXd& joint_mat, const Eigen::MatrixXd& body_defs, const Eigen::VectorXd& pose, const Eigen::VectorXd& vel,
+						tVector& out_com, tVector& out_vel);
+
+	static cSpAlg::tSpTrans BuildParentChildTransform(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& pose, int j);
+	static cSpAlg::tSpTrans BuildChildParentTransform(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& pose, int j);
+	
+	// extract a cSpAlg::tSpTrans from a matrix presentating a stack of transforms
+	static void CalcWorldJointTransforms(const cRBDModel& model, Eigen::MatrixXd& out_trans_arr);
+	static bool IsConstJointSubspace(const Eigen::MatrixXd& joint_mat, int j);
+	static Eigen::MatrixXd BuildJointSubspace(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& pose, int j);
+
+	static cSpAlg::tSpMat BuildMomentInertia(const Eigen::MatrixXd& body_defs, int part_id);
+
+protected:
+
+	static Eigen::MatrixXd BuildJointSubspaceRoot(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& pose);
+	static Eigen::MatrixXd BuildJointSubspaceRevolute(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& pose, int j);
+	static Eigen::MatrixXd BuildJointSubspacePrismatic(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& pose, int j);
+	static Eigen::MatrixXd BuildJointSubspacePlanar(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& pose, int j);
+	static Eigen::MatrixXd BuildJointSubspaceFixed(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& pose, int j);
+	static Eigen::MatrixXd BuildJointSubspaceSpherical(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& pose, int j);
+
+	static cSpAlg::tSpVec BuildCj(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& q, const Eigen::VectorXd& q_dot, int j);
+	static cSpAlg::tSpVec BuildCjRoot(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& q, const Eigen::VectorXd& q_dot, int j);
+	static cSpAlg::tSpVec BuildCjRevolute(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& q_dot, int j);
+	static cSpAlg::tSpVec BuildCjPrismatic(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& q_dot, int j);
+	static cSpAlg::tSpVec BuildCjPlanar(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& q_dot, int j);
+	static cSpAlg::tSpVec BuildCjFixed(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& q_dot, int j);
+	static cSpAlg::tSpVec BuildCjSpherical(const Eigen::MatrixXd& joint_mat, const Eigen::VectorXd& q_dot, int j);
+
+	static cSpAlg::tSpMat BuildMomentInertiaBox(const Eigen::MatrixXd& body_defs, int part_id);
+	static cSpAlg::tSpMat BuildMomentInertiaCapsule(const Eigen::MatrixXd& body_defs, int part_id);
+	static cSpAlg::tSpMat BuildMomentInertiaSphere(const Eigen::MatrixXd& body_defs, int part_id);
+	static cSpAlg::tSpMat BuildMomentInertiaCylinder(const Eigen::MatrixXd& body_defs, int part_id);
+
+	// builds the spatial inertial matrix in the coordinate frame of the parent joint
+	static cSpAlg::tSpMat BuildInertiaSpatialMat(const Eigen::MatrixXd& body_defs, int part_id);
+};
\ No newline at end of file
diff --git a/engine/inc/bullet/SharedMemory/plugins/stablePDPlugin/Shape.h b/engine/inc/bullet/SharedMemory/plugins/stablePDPlugin/Shape.h
new file mode 100644
index 00000000..e58fdf06
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/plugins/stablePDPlugin/Shape.h
@@ -0,0 +1,20 @@
+#pragma once
+
+#include <string>
+
+class cShape
+{
+public:
+	enum eShape
+	{
+		eShapeNull,
+		eShapeBox,
+		eShapeCapsule,
+		eShapeSphere,
+		eShapeCylinder,
+		eShapePlane,
+		eShapeMax,
+	};
+
+	static bool ParseShape(const std::string& str, cShape::eShape& out_shape);
+};
\ No newline at end of file
diff --git a/engine/inc/bullet/SharedMemory/plugins/stablePDPlugin/SpAlg.h b/engine/inc/bullet/SharedMemory/plugins/stablePDPlugin/SpAlg.h
new file mode 100644
index 00000000..71051c1a
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/plugins/stablePDPlugin/SpAlg.h
@@ -0,0 +1,70 @@
+#pragma once
+
+#include "MathUtil.h"
+
+#define gSpVecSize 6
+#define gSVTransRows 3
+#define gSVTransCols 4
+
+
+// spatial algebra util
+class cSpAlg
+{
+public:
+	
+
+	typedef Eigen::Matrix<double, gSVTransRows, gSVTransCols> tSpTrans;
+	typedef Eigen::Matrix<double, gSpVecSize, 1> tSpVec;
+	typedef Eigen::Matrix<double, gSpVecSize, gSpVecSize> tSpMat;
+
+	static tSpVec ConvertCoordM(const tSpVec& m0, const tVector& origin0, const tVector& origin1);
+	// rows of R shoold be the basis for the coordinate frame centered ar origin
+	static tSpVec ConvertCoordM(const tSpVec& m0, const tVector& origin0, const tMatrix& R0, const tVector& origin1, const tMatrix& R1);
+	// R is a rotation from coord frame 0 to coord frame 1
+	static tSpVec ConvertCoordM(const tSpVec& m0, const tVector& origin0, const tVector& origin1, const tMatrix& R);
+
+	static tSpVec ConvertCoordF(const tSpVec& m0, const tVector& origin0, const tVector& origin1);
+	static tSpVec ConvertCoordF(const tSpVec& m0, const tVector& origin0, const tMatrix& R0, const tVector& origin1, const tMatrix& R1);
+	static tSpVec ConvertCoordF(const tSpVec& m0, const tVector& origin0, const tVector& origin1, const tMatrix& R);
+
+	static tSpVec CrossM(const tSpVec& sv, const tSpVec& m);
+	static Eigen::MatrixXd CrossMs(const tSpVec& sv, const Eigen::MatrixXd& ms);
+	static tSpVec CrossF(const tSpVec& sv, const tSpVec& f);
+	static Eigen::MatrixXd CrossFs(const tSpVec& sv, const Eigen::MatrixXd& fs);
+
+	// Spatial Vector methods
+	static tSpVec BuildSV(const tVector& v);
+	static tSpVec BuildSV(const tVector& o, const tVector& v);
+	static tVector GetOmega(const tSpVec& sv);
+	static void SetOmega(const tVector& o, tSpVec& out_sv);
+	static tVector GetV(const tSpVec& sv);
+	static void SetV(const tVector& v, tSpVec& out_sv);
+
+	// tSpTrans methods
+	static tSpTrans BuildTrans();
+	static tSpTrans BuildTrans(const tMatrix& E, const tVector& r);
+	static tSpTrans BuildTrans(const tVector& r);
+
+	static tSpTrans MatToTrans(const tMatrix& mat);
+	static tMatrix TransToMat(const tSpTrans& X);
+	static tSpMat BuildSpatialMatM(const tSpTrans& X);
+	static tSpMat BuildSpatialMatF(const tSpTrans& X);
+	static tSpTrans InvTrans(const tSpTrans& X);
+	static tMatrix GetRot(const tSpTrans& X);
+	static void SetRot(const tMatrix& E, tSpTrans& out_X);
+	static tVector GetRad(const tSpTrans& X);
+	static void SetRad(const tVector& r, tSpTrans& out_X);
+
+	static tSpVec ApplyTransM(const tSpTrans& X, const tSpVec& sv);
+	static tSpVec ApplyTransF(const tSpTrans& X, const tSpVec& sv);
+	static Eigen::MatrixXd ApplyTransM(const tSpTrans& X, const Eigen::MatrixXd& sm);
+	static Eigen::MatrixXd ApplyTransF(const tSpTrans& X, const Eigen::MatrixXd& sm);
+	static tSpVec ApplyInvTransM(const tSpTrans& X, const tSpVec& sv);
+	static tSpVec ApplyInvTransF(const tSpTrans& X, const tSpVec& sv);
+	static Eigen::MatrixXd ApplyInvTransM(const tSpTrans& X, const Eigen::MatrixXd& sm);
+	static Eigen::MatrixXd ApplyInvTransF(const tSpTrans& X, const Eigen::MatrixXd& sm);
+	static tSpTrans CompTrans(const tSpTrans& X0, const tSpTrans& X1);
+	
+	// extract a tSpTrans from a matrix presentating a stack of transforms
+	static tSpTrans GetTrans(const Eigen::MatrixXd& trans_arr, int j);
+};
diff --git a/engine/inc/bullet/SharedMemory/plugins/testPlugin/testplugin.h b/engine/inc/bullet/SharedMemory/plugins/testPlugin/testplugin.h
new file mode 100644
index 00000000..830e6fb5
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/plugins/testPlugin/testplugin.h
@@ -0,0 +1,24 @@
+#ifndef TEST_PLUGIN_H
+#define TEST_PLUGIN_H
+
+#include "../b3PluginAPI.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	//initPlugin, exitPlugin and executePluginCommand are required, otherwise plugin won't load
+	B3_SHARED_API int initPlugin_testPlugin(struct b3PluginContext* context);
+	B3_SHARED_API void exitPlugin_testPlugin(struct b3PluginContext* context);
+	B3_SHARED_API int executePluginCommand_testPlugin(struct b3PluginContext* context, const struct b3PluginArguments* arguments);
+
+	//all the APIs below are optional
+	B3_SHARED_API int preTickPluginCallback_testPlugin(struct b3PluginContext* context);
+	B3_SHARED_API int postTickPluginCallback_testPlugin(struct b3PluginContext* context);
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif  //#define TEST_PLUGIN_H
diff --git a/engine/inc/bullet/SharedMemory/plugins/tinyRendererPlugin/TinyRendererVisualShapeConverter.h b/engine/inc/bullet/SharedMemory/plugins/tinyRendererPlugin/TinyRendererVisualShapeConverter.h
new file mode 100644
index 00000000..e0c342de
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/plugins/tinyRendererPlugin/TinyRendererVisualShapeConverter.h
@@ -0,0 +1,63 @@
+#ifndef TINY_RENDERER_VISUAL_SHAPE_CONVERTER_H
+#define TINY_RENDERER_VISUAL_SHAPE_CONVERTER_H
+
+#include "../../../Importers/ImportURDFDemo/UrdfRenderingInterface.h"
+
+struct TinyRendererVisualShapeConverter : public UrdfRenderingInterface
+{
+	struct TinyRendererVisualShapeConverterInternalData* m_data;
+
+	TinyRendererVisualShapeConverter();
+
+	virtual ~TinyRendererVisualShapeConverter();
+
+	virtual int convertVisualShapes(int linkIndex, const char* pathPrefix, const btTransform& localInertiaFrame, const UrdfLink* linkPtr, const UrdfModel* model, int orgGraphicsUniqueId, int bodyUniqueId, struct CommonFileIOInterface* fileIO);
+
+	//returns a shapeUniqueId
+	virtual int registerShapeAndInstance(const b3VisualShapeData& visualShape, const float* vertices, int numvertices, const int* indices, int numIndices, int primitiveType, int textureId, int orgGraphicsUniqueId, int bodyUniqueId, int linkIndex);
+
+	virtual void updateShape(int shapeUniqueId, const btVector3* vertices, int numVertices, const btVector3* normals, int numNormals);
+
+	virtual void removeVisualShape(int shapeUniqueId);
+
+	virtual int getNumVisualShapes(int bodyUniqueId);
+
+	virtual int getVisualShapesData(int bodyUniqueId, int shapeIndex, struct b3VisualShapeData* shapeData);
+
+	virtual void changeRGBAColor(int bodyUniqueId, int linkIndex, int shapeIndex, const double rgbaColor[4]);
+
+	virtual void changeInstanceFlags(int bodyUniqueId, int linkIndex, int shapeIndex, int flags);
+
+	virtual void changeShapeTexture(int bodyUniqueId, int linkIndex, int shapeIndex, int textureUniqueId);
+
+	virtual void setUpAxis(int axis);
+
+	virtual void resetCamera(float camDist, float yaw, float pitch, float camPosX, float camPosY, float camPosZ);
+
+	virtual void clearBuffers(struct TGAColor& clearColor);
+
+	virtual void resetAll();
+
+	virtual void getWidthAndHeight(int& width, int& height);
+	virtual void setWidthAndHeight(int width, int height);
+	virtual void setLightDirection(float x, float y, float z);
+	virtual void setLightColor(float x, float y, float z);
+	virtual void setLightDistance(float dist);
+	virtual void setLightAmbientCoeff(float ambientCoeff);
+	virtual void setLightDiffuseCoeff(float diffuseCoeff);
+	virtual void setLightSpecularCoeff(float specularCoeff);
+	virtual void setShadow(bool hasShadow);
+	virtual void setFlags(int flags);
+
+	virtual void copyCameraImageData(unsigned char* pixelsRGBA, int rgbaBufferSizeInPixels, float* depthBuffer, int depthBufferSizeInPixels, int* segmentationMaskBuffer, int segmentationMaskSizeInPixels, int startPixelIndex, int* widthPtr, int* heightPtr, int* numPixelsCopied);
+
+	virtual void render();
+	virtual void render(const float viewMat[16], const float projMat[16]);
+
+	virtual int loadTextureFile(const char* filename, struct CommonFileIOInterface* fileIO);
+	virtual int registerTexture(unsigned char* texels, int width, int height);
+
+	virtual void syncTransform(int shapeUniqueId, const class btTransform& worldTransform, const class btVector3& localScaling);
+};
+
+#endif  //TINY_RENDERER_VISUAL_SHAPE_CONVERTER_H
diff --git a/engine/inc/bullet/SharedMemory/plugins/tinyRendererPlugin/tinyRendererPlugin.h b/engine/inc/bullet/SharedMemory/plugins/tinyRendererPlugin/tinyRendererPlugin.h
new file mode 100644
index 00000000..a7a4a0b0
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/plugins/tinyRendererPlugin/tinyRendererPlugin.h
@@ -0,0 +1,23 @@
+#ifndef TINY_RENDERER_PLUGIN_H
+#define TINY_RENDERER_PLUGIN_H
+
+#include "../b3PluginAPI.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	//initPlugin, exitPlugin and executePluginCommand are required, otherwise plugin won't load
+	B3_SHARED_API int initPlugin_tinyRendererPlugin(struct b3PluginContext* context);
+	B3_SHARED_API void exitPlugin_tinyRendererPlugin(struct b3PluginContext* context);
+	B3_SHARED_API int executePluginCommand_tinyRendererPlugin(struct b3PluginContext* context, const struct b3PluginArguments* arguments);
+
+	//all the APIs below are optional
+	B3_SHARED_API struct UrdfRenderingInterface* getRenderInterface_tinyRendererPlugin(struct b3PluginContext* context);
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif  //#define TEST_PLUGIN_H
diff --git a/engine/inc/bullet/SharedMemory/plugins/vrSyncPlugin/vrSyncPlugin.h b/engine/inc/bullet/SharedMemory/plugins/vrSyncPlugin/vrSyncPlugin.h
new file mode 100644
index 00000000..7dcc4b54
--- /dev/null
+++ b/engine/inc/bullet/SharedMemory/plugins/vrSyncPlugin/vrSyncPlugin.h
@@ -0,0 +1,23 @@
+#ifndef TEST_PLUGIN_H
+#define TEST_PLUGIN_H
+
+#include "../b3PluginAPI.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	//initPlugin, exitPlugin and executePluginCommand are required, otherwise plugin won't load
+	B3_SHARED_API int initPlugin_vrSyncPlugin(struct b3PluginContext* context);
+	B3_SHARED_API void exitPlugin_vrSyncPlugin(struct b3PluginContext* context);
+	B3_SHARED_API int executePluginCommand_vrSyncPlugin(struct b3PluginContext* context, const struct b3PluginArguments* arguments);
+
+	//optional APIs
+	B3_SHARED_API int preTickPluginCallback_vrSyncPlugin(struct b3PluginContext* context);
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif  //#define TEST_PLUGIN_H
diff --git a/engine/inc/bullet/SoftDemo/BunnyMesh.h b/engine/inc/bullet/SoftDemo/BunnyMesh.h
new file mode 100644
index 00000000..1a69f874
--- /dev/null
+++ b/engine/inc/bullet/SoftDemo/BunnyMesh.h
@@ -0,0 +1,1372 @@
+#ifndef BUNNY_MESH_H_
+#define BUNNY_MESH_H_
+
+//***************************THE FAMOUS BUNNY TRIMESH********************************************//
+
+#define REAL btScalar
+const int BUNNY_NUM_TRIANGLES = 902;
+const int BUNNY_NUM_VERTICES = 453;
+const int BUNNY_NUM_INDICES = BUNNY_NUM_TRIANGLES * 3;
+
+static REAL gVerticesBunny[BUNNY_NUM_VERTICES * 3] = {
+	REAL(-0.334392), REAL(0.133007), REAL(0.062259),
+	REAL(-0.350189), REAL(0.150354), REAL(-0.147769),
+	REAL(-0.234201), REAL(0.343811), REAL(-0.174307),
+	REAL(-0.200259), REAL(0.285207), REAL(0.093749),
+	REAL(0.003520), REAL(0.475208), REAL(-0.159365),
+	REAL(0.001856), REAL(0.419203), REAL(0.098582),
+	REAL(-0.252802), REAL(0.093666), REAL(0.237538),
+	REAL(-0.162901), REAL(0.237984), REAL(0.206905),
+	REAL(0.000865), REAL(0.318141), REAL(0.235370),
+	REAL(-0.414624), REAL(0.164083), REAL(-0.278254),
+	REAL(-0.262213), REAL(0.357334), REAL(-0.293246),
+	REAL(0.004628), REAL(0.482694), REAL(-0.338626),
+	REAL(-0.402162), REAL(0.133528), REAL(-0.443247),
+	REAL(-0.243781), REAL(0.324275), REAL(-0.436763),
+	REAL(0.005293), REAL(0.437592), REAL(-0.458332),
+	REAL(-0.339884), REAL(-0.041150), REAL(-0.668211),
+	REAL(-0.248382), REAL(0.255825), REAL(-0.627493),
+	REAL(0.006261), REAL(0.376103), REAL(-0.631506),
+	REAL(-0.216201), REAL(-0.126776), REAL(-0.886936),
+	REAL(-0.171075), REAL(0.011544), REAL(-0.881386),
+	REAL(-0.181074), REAL(0.098223), REAL(-0.814779),
+	REAL(-0.119891), REAL(0.218786), REAL(-0.760153),
+	REAL(-0.078895), REAL(0.276780), REAL(-0.739281),
+	REAL(0.006801), REAL(0.310959), REAL(-0.735661),
+	REAL(-0.168842), REAL(0.102387), REAL(-0.920381),
+	REAL(-0.104072), REAL(0.177278), REAL(-0.952530),
+	REAL(-0.129704), REAL(0.211848), REAL(-0.836678),
+	REAL(-0.099875), REAL(0.310931), REAL(-0.799381),
+	REAL(0.007237), REAL(0.361687), REAL(-0.794439),
+	REAL(-0.077913), REAL(0.258753), REAL(-0.921640),
+	REAL(0.007957), REAL(0.282241), REAL(-0.931680),
+	REAL(-0.252222), REAL(-0.550401), REAL(-0.557810),
+	REAL(-0.267633), REAL(-0.603419), REAL(-0.655209),
+	REAL(-0.446838), REAL(-0.118517), REAL(-0.466159),
+	REAL(-0.459488), REAL(-0.093017), REAL(-0.311341),
+	REAL(-0.370645), REAL(-0.100108), REAL(-0.159454),
+	REAL(-0.371984), REAL(-0.091991), REAL(-0.011044),
+	REAL(-0.328945), REAL(-0.098269), REAL(0.088659),
+	REAL(-0.282452), REAL(-0.018862), REAL(0.311501),
+	REAL(-0.352403), REAL(-0.131341), REAL(0.144902),
+	REAL(-0.364126), REAL(-0.200299), REAL(0.202388),
+	REAL(-0.283965), REAL(-0.231869), REAL(0.023668),
+	REAL(-0.298943), REAL(-0.155218), REAL(0.369716),
+	REAL(-0.293787), REAL(-0.121856), REAL(0.419097),
+	REAL(-0.290163), REAL(-0.290797), REAL(0.107824),
+	REAL(-0.264165), REAL(-0.272849), REAL(0.036347),
+	REAL(-0.228567), REAL(-0.372573), REAL(0.290309),
+	REAL(-0.190431), REAL(-0.286997), REAL(0.421917),
+	REAL(-0.191039), REAL(-0.240973), REAL(0.507118),
+	REAL(-0.287272), REAL(-0.276431), REAL(-0.065444),
+	REAL(-0.295675), REAL(-0.280818), REAL(-0.174200),
+	REAL(-0.399537), REAL(-0.313131), REAL(-0.376167),
+	REAL(-0.392666), REAL(-0.488581), REAL(-0.427494),
+	REAL(-0.331669), REAL(-0.570185), REAL(-0.466054),
+	REAL(-0.282290), REAL(-0.618140), REAL(-0.589220),
+	REAL(-0.374238), REAL(-0.594882), REAL(-0.323298),
+	REAL(-0.381071), REAL(-0.629723), REAL(-0.350777),
+	REAL(-0.382112), REAL(-0.624060), REAL(-0.221577),
+	REAL(-0.272701), REAL(-0.566522), REAL(0.259157),
+	REAL(-0.256702), REAL(-0.663406), REAL(0.286079),
+	REAL(-0.280948), REAL(-0.428359), REAL(0.055790),
+	REAL(-0.184974), REAL(-0.508894), REAL(0.326265),
+	REAL(-0.279971), REAL(-0.526918), REAL(0.395319),
+	REAL(-0.282599), REAL(-0.663393), REAL(0.412411),
+	REAL(-0.188329), REAL(-0.475093), REAL(0.417954),
+	REAL(-0.263384), REAL(-0.663396), REAL(0.466604),
+	REAL(-0.209063), REAL(-0.663393), REAL(0.509344),
+	REAL(-0.002044), REAL(-0.319624), REAL(0.553078),
+	REAL(-0.001266), REAL(-0.371260), REAL(0.413296),
+	REAL(-0.219753), REAL(-0.339762), REAL(-0.040921),
+	REAL(-0.256986), REAL(-0.282511), REAL(-0.006349),
+	REAL(-0.271706), REAL(-0.260881), REAL(0.001764),
+	REAL(-0.091191), REAL(-0.419184), REAL(-0.045912),
+	REAL(-0.114944), REAL(-0.429752), REAL(-0.124739),
+	REAL(-0.113970), REAL(-0.382987), REAL(-0.188540),
+	REAL(-0.243012), REAL(-0.464942), REAL(-0.242850),
+	REAL(-0.314815), REAL(-0.505402), REAL(-0.324768),
+	REAL(0.002774), REAL(-0.437526), REAL(-0.262766),
+	REAL(-0.072625), REAL(-0.417748), REAL(-0.221440),
+	REAL(-0.160112), REAL(-0.476932), REAL(-0.293450),
+	REAL(0.003859), REAL(-0.453425), REAL(-0.443916),
+	REAL(-0.120363), REAL(-0.581567), REAL(-0.438689),
+	REAL(-0.091499), REAL(-0.584191), REAL(-0.294511),
+	REAL(-0.116469), REAL(-0.599861), REAL(-0.188308),
+	REAL(-0.208032), REAL(-0.513640), REAL(-0.134649),
+	REAL(-0.235749), REAL(-0.610017), REAL(-0.040939),
+	REAL(-0.344916), REAL(-0.622487), REAL(-0.085380),
+	REAL(-0.336401), REAL(-0.531864), REAL(-0.212298),
+	REAL(0.001961), REAL(-0.459550), REAL(-0.135547),
+	REAL(-0.058296), REAL(-0.430536), REAL(-0.043440),
+	REAL(0.001378), REAL(-0.449511), REAL(-0.037762),
+	REAL(-0.130135), REAL(-0.510222), REAL(0.079144),
+	REAL(0.000142), REAL(-0.477549), REAL(0.157064),
+	REAL(-0.114284), REAL(-0.453206), REAL(0.304397),
+	REAL(-0.000592), REAL(-0.443558), REAL(0.285401),
+	REAL(-0.056215), REAL(-0.663402), REAL(0.326073),
+	REAL(-0.026248), REAL(-0.568010), REAL(0.273318),
+	REAL(-0.049261), REAL(-0.531064), REAL(0.389854),
+	REAL(-0.127096), REAL(-0.663398), REAL(0.479316),
+	REAL(-0.058384), REAL(-0.663401), REAL(0.372891),
+	REAL(-0.303961), REAL(0.054199), REAL(0.625921),
+	REAL(-0.268594), REAL(0.193403), REAL(0.502766),
+	REAL(-0.277159), REAL(0.126123), REAL(0.443289),
+	REAL(-0.287605), REAL(-0.005722), REAL(0.531844),
+	REAL(-0.231396), REAL(-0.121289), REAL(0.587387),
+	REAL(-0.253475), REAL(-0.081797), REAL(0.756541),
+	REAL(-0.195164), REAL(-0.137969), REAL(0.728011),
+	REAL(-0.167673), REAL(-0.156573), REAL(0.609388),
+	REAL(-0.145917), REAL(-0.169029), REAL(0.697600),
+	REAL(-0.077776), REAL(-0.214247), REAL(0.622586),
+	REAL(-0.076873), REAL(-0.214971), REAL(0.696301),
+	REAL(-0.002341), REAL(-0.233135), REAL(0.622859),
+	REAL(-0.002730), REAL(-0.213526), REAL(0.691267),
+	REAL(-0.003136), REAL(-0.192628), REAL(0.762731),
+	REAL(-0.056136), REAL(-0.201222), REAL(0.763806),
+	REAL(-0.114589), REAL(-0.166192), REAL(0.770723),
+	REAL(-0.155145), REAL(-0.129632), REAL(0.791738),
+	REAL(-0.183611), REAL(-0.058705), REAL(0.847012),
+	REAL(-0.165562), REAL(0.001980), REAL(0.833386),
+	REAL(-0.220084), REAL(0.019914), REAL(0.768935),
+	REAL(-0.255730), REAL(0.090306), REAL(0.670782),
+	REAL(-0.255594), REAL(0.113833), REAL(0.663389),
+	REAL(-0.226380), REAL(0.212655), REAL(0.617740),
+	REAL(-0.003367), REAL(-0.195342), REAL(0.799680),
+	REAL(-0.029743), REAL(-0.210508), REAL(0.827180),
+	REAL(-0.003818), REAL(-0.194783), REAL(0.873636),
+	REAL(-0.004116), REAL(-0.157907), REAL(0.931268),
+	REAL(-0.031280), REAL(-0.184555), REAL(0.889476),
+	REAL(-0.059885), REAL(-0.184448), REAL(0.841330),
+	REAL(-0.135333), REAL(-0.164332), REAL(0.878200),
+	REAL(-0.085574), REAL(-0.170948), REAL(0.925547),
+	REAL(-0.163833), REAL(-0.094170), REAL(0.897114),
+	REAL(-0.138444), REAL(-0.104250), REAL(0.945975),
+	REAL(-0.083497), REAL(-0.084934), REAL(0.979607),
+	REAL(-0.004433), REAL(-0.146642), REAL(0.985872),
+	REAL(-0.150715), REAL(0.032650), REAL(0.884111),
+	REAL(-0.135892), REAL(-0.035520), REAL(0.945455),
+	REAL(-0.070612), REAL(0.036849), REAL(0.975733),
+	REAL(-0.004458), REAL(-0.042526), REAL(1.015670),
+	REAL(-0.004249), REAL(0.046042), REAL(1.003240),
+	REAL(-0.086969), REAL(0.133224), REAL(0.947633),
+	REAL(-0.003873), REAL(0.161605), REAL(0.970499),
+	REAL(-0.125544), REAL(0.140012), REAL(0.917678),
+	REAL(-0.125651), REAL(0.250246), REAL(0.857602),
+	REAL(-0.003127), REAL(0.284070), REAL(0.878870),
+	REAL(-0.159174), REAL(0.125726), REAL(0.888878),
+	REAL(-0.183807), REAL(0.196970), REAL(0.844480),
+	REAL(-0.159890), REAL(0.291736), REAL(0.732480),
+	REAL(-0.199495), REAL(0.207230), REAL(0.779864),
+	REAL(-0.206182), REAL(0.164608), REAL(0.693257),
+	REAL(-0.186315), REAL(0.160689), REAL(0.817193),
+	REAL(-0.192827), REAL(0.166706), REAL(0.782271),
+	REAL(-0.175112), REAL(0.110008), REAL(0.860621),
+	REAL(-0.161022), REAL(0.057420), REAL(0.855111),
+	REAL(-0.172319), REAL(0.036155), REAL(0.816189),
+	REAL(-0.190318), REAL(0.064083), REAL(0.760605),
+	REAL(-0.195072), REAL(0.129179), REAL(0.731104),
+	REAL(-0.203126), REAL(0.410287), REAL(0.680536),
+	REAL(-0.216677), REAL(0.309274), REAL(0.642272),
+	REAL(-0.241515), REAL(0.311485), REAL(0.587832),
+	REAL(-0.002209), REAL(0.366663), REAL(0.749413),
+	REAL(-0.088230), REAL(0.396265), REAL(0.678635),
+	REAL(-0.170147), REAL(0.109517), REAL(0.840784),
+	REAL(-0.160521), REAL(0.067766), REAL(0.830650),
+	REAL(-0.181546), REAL(0.139805), REAL(0.812146),
+	REAL(-0.180495), REAL(0.148568), REAL(0.776087),
+	REAL(-0.180255), REAL(0.129125), REAL(0.744192),
+	REAL(-0.186298), REAL(0.078308), REAL(0.769352),
+	REAL(-0.167622), REAL(0.060539), REAL(0.806675),
+	REAL(-0.189876), REAL(0.102760), REAL(0.802582),
+	REAL(-0.108340), REAL(0.455446), REAL(0.657174),
+	REAL(-0.241585), REAL(0.527592), REAL(0.669296),
+	REAL(-0.265676), REAL(0.513366), REAL(0.634594),
+	REAL(-0.203073), REAL(0.478550), REAL(0.581526),
+	REAL(-0.266772), REAL(0.642330), REAL(0.602061),
+	REAL(-0.216961), REAL(0.564846), REAL(0.535435),
+	REAL(-0.202210), REAL(0.525495), REAL(0.475944),
+	REAL(-0.193888), REAL(0.467925), REAL(0.520606),
+	REAL(-0.265837), REAL(0.757267), REAL(0.500933),
+	REAL(-0.240306), REAL(0.653440), REAL(0.463215),
+	REAL(-0.309239), REAL(0.776868), REAL(0.304726),
+	REAL(-0.271009), REAL(0.683094), REAL(0.382018),
+	REAL(-0.312111), REAL(0.671099), REAL(0.286687),
+	REAL(-0.268791), REAL(0.624342), REAL(0.377231),
+	REAL(-0.302457), REAL(0.533996), REAL(0.360289),
+	REAL(-0.263656), REAL(0.529310), REAL(0.412564),
+	REAL(-0.282311), REAL(0.415167), REAL(0.447666),
+	REAL(-0.239201), REAL(0.442096), REAL(0.495604),
+	REAL(-0.220043), REAL(0.569026), REAL(0.445877),
+	REAL(-0.001263), REAL(0.395631), REAL(0.602029),
+	REAL(-0.057345), REAL(0.442535), REAL(0.572224),
+	REAL(-0.088927), REAL(0.506333), REAL(0.529106),
+	REAL(-0.125738), REAL(0.535076), REAL(0.612913),
+	REAL(-0.126251), REAL(0.577170), REAL(0.483159),
+	REAL(-0.149594), REAL(0.611520), REAL(0.557731),
+	REAL(-0.163188), REAL(0.660791), REAL(0.491080),
+	REAL(-0.172482), REAL(0.663387), REAL(0.415416),
+	REAL(-0.160464), REAL(0.591710), REAL(0.370659),
+	REAL(-0.156445), REAL(0.536396), REAL(0.378302),
+	REAL(-0.136496), REAL(0.444358), REAL(0.425226),
+	REAL(-0.095564), REAL(0.373768), REAL(0.473659),
+	REAL(-0.104146), REAL(0.315912), REAL(0.498104),
+	REAL(-0.000496), REAL(0.384194), REAL(0.473817),
+	REAL(-0.000183), REAL(0.297770), REAL(0.401486),
+	REAL(-0.129042), REAL(0.270145), REAL(0.434495),
+	REAL(0.000100), REAL(0.272963), REAL(0.349138),
+	REAL(-0.113060), REAL(0.236984), REAL(0.385554),
+	REAL(0.007260), REAL(0.016311), REAL(-0.883396),
+	REAL(0.007865), REAL(0.122104), REAL(-0.956137),
+	REAL(-0.032842), REAL(0.115282), REAL(-0.953252),
+	REAL(-0.089115), REAL(0.108449), REAL(-0.950317),
+	REAL(-0.047440), REAL(0.014729), REAL(-0.882756),
+	REAL(-0.104458), REAL(0.013137), REAL(-0.882070),
+	REAL(-0.086439), REAL(-0.584866), REAL(-0.608343),
+	REAL(-0.115026), REAL(-0.662605), REAL(-0.436732),
+	REAL(-0.071683), REAL(-0.665372), REAL(-0.606385),
+	REAL(-0.257884), REAL(-0.665381), REAL(-0.658052),
+	REAL(-0.272542), REAL(-0.665381), REAL(-0.592063),
+	REAL(-0.371322), REAL(-0.665382), REAL(-0.353620),
+	REAL(-0.372362), REAL(-0.665381), REAL(-0.224420),
+	REAL(-0.335166), REAL(-0.665380), REAL(-0.078623),
+	REAL(-0.225999), REAL(-0.665375), REAL(-0.038981),
+	REAL(-0.106719), REAL(-0.665374), REAL(-0.186351),
+	REAL(-0.081749), REAL(-0.665372), REAL(-0.292554),
+	REAL(0.006943), REAL(-0.091505), REAL(-0.858354),
+	REAL(0.006117), REAL(-0.280985), REAL(-0.769967),
+	REAL(0.004495), REAL(-0.502360), REAL(-0.559799),
+	REAL(-0.198638), REAL(-0.302135), REAL(-0.845816),
+	REAL(-0.237395), REAL(-0.542544), REAL(-0.587188),
+	REAL(-0.270001), REAL(-0.279489), REAL(-0.669861),
+	REAL(-0.134547), REAL(-0.119852), REAL(-0.959004),
+	REAL(-0.052088), REAL(-0.122463), REAL(-0.944549),
+	REAL(-0.124463), REAL(-0.293508), REAL(-0.899566),
+	REAL(-0.047616), REAL(-0.289643), REAL(-0.879292),
+	REAL(-0.168595), REAL(-0.529132), REAL(-0.654931),
+	REAL(-0.099793), REAL(-0.515719), REAL(-0.645873),
+	REAL(-0.186168), REAL(-0.605282), REAL(-0.724690),
+	REAL(-0.112970), REAL(-0.583097), REAL(-0.707469),
+	REAL(-0.108152), REAL(-0.665375), REAL(-0.700408),
+	REAL(-0.183019), REAL(-0.665378), REAL(-0.717630),
+	REAL(-0.349529), REAL(-0.334459), REAL(-0.511985),
+	REAL(-0.141182), REAL(-0.437705), REAL(-0.798194),
+	REAL(-0.212670), REAL(-0.448725), REAL(-0.737447),
+	REAL(-0.261111), REAL(-0.414945), REAL(-0.613835),
+	REAL(-0.077364), REAL(-0.431480), REAL(-0.778113),
+	REAL(0.005174), REAL(-0.425277), REAL(-0.651592),
+	REAL(0.089236), REAL(-0.431732), REAL(-0.777093),
+	REAL(0.271006), REAL(-0.415749), REAL(-0.610577),
+	REAL(0.223981), REAL(-0.449384), REAL(-0.734774),
+	REAL(0.153275), REAL(-0.438150), REAL(-0.796391),
+	REAL(0.358414), REAL(-0.335529), REAL(-0.507649),
+	REAL(0.193434), REAL(-0.665946), REAL(-0.715325),
+	REAL(0.118363), REAL(-0.665717), REAL(-0.699021),
+	REAL(0.123515), REAL(-0.583454), REAL(-0.706020),
+	REAL(0.196851), REAL(-0.605860), REAL(-0.722345),
+	REAL(0.109788), REAL(-0.516035), REAL(-0.644590),
+	REAL(0.178656), REAL(-0.529656), REAL(-0.652804),
+	REAL(0.061157), REAL(-0.289807), REAL(-0.878626),
+	REAL(0.138234), REAL(-0.293905), REAL(-0.897958),
+	REAL(0.066933), REAL(-0.122643), REAL(-0.943820),
+	REAL(0.149571), REAL(-0.120281), REAL(-0.957264),
+	REAL(0.280989), REAL(-0.280321), REAL(-0.666487),
+	REAL(0.246581), REAL(-0.543275), REAL(-0.584224),
+	REAL(0.211720), REAL(-0.302754), REAL(-0.843303),
+	REAL(0.086966), REAL(-0.665627), REAL(-0.291520),
+	REAL(0.110634), REAL(-0.665702), REAL(-0.185021),
+	REAL(0.228099), REAL(-0.666061), REAL(-0.036201),
+	REAL(0.337743), REAL(-0.666396), REAL(-0.074503),
+	REAL(0.376722), REAL(-0.666513), REAL(-0.219833),
+	REAL(0.377265), REAL(-0.666513), REAL(-0.349036),
+	REAL(0.281411), REAL(-0.666217), REAL(-0.588670),
+	REAL(0.267564), REAL(-0.666174), REAL(-0.654834),
+	REAL(0.080745), REAL(-0.665602), REAL(-0.605452),
+	REAL(0.122016), REAL(-0.662963), REAL(-0.435280),
+	REAL(0.095767), REAL(-0.585141), REAL(-0.607228),
+	REAL(0.118944), REAL(0.012799), REAL(-0.880702),
+	REAL(0.061944), REAL(0.014564), REAL(-0.882086),
+	REAL(0.104725), REAL(0.108156), REAL(-0.949130),
+	REAL(0.048513), REAL(0.115159), REAL(-0.952753),
+	REAL(0.112696), REAL(0.236643), REAL(0.386937),
+	REAL(0.128177), REAL(0.269757), REAL(0.436071),
+	REAL(0.102643), REAL(0.315600), REAL(0.499370),
+	REAL(0.094535), REAL(0.373481), REAL(0.474824),
+	REAL(0.136270), REAL(0.443946), REAL(0.426895),
+	REAL(0.157071), REAL(0.535923), REAL(0.380222),
+	REAL(0.161350), REAL(0.591224), REAL(0.372630),
+	REAL(0.173035), REAL(0.662865), REAL(0.417531),
+	REAL(0.162808), REAL(0.660299), REAL(0.493077),
+	REAL(0.148250), REAL(0.611070), REAL(0.559555),
+	REAL(0.125719), REAL(0.576790), REAL(0.484702),
+	REAL(0.123489), REAL(0.534699), REAL(0.614440),
+	REAL(0.087621), REAL(0.506066), REAL(0.530188),
+	REAL(0.055321), REAL(0.442365), REAL(0.572915),
+	REAL(0.219936), REAL(0.568361), REAL(0.448571),
+	REAL(0.238099), REAL(0.441375), REAL(0.498528),
+	REAL(0.281711), REAL(0.414315), REAL(0.451121),
+	REAL(0.263833), REAL(0.528513), REAL(0.415794),
+	REAL(0.303284), REAL(0.533081), REAL(0.363998),
+	REAL(0.269687), REAL(0.623528), REAL(0.380528),
+	REAL(0.314255), REAL(0.670153), REAL(0.290524),
+	REAL(0.272023), REAL(0.682273), REAL(0.385343),
+	REAL(0.311480), REAL(0.775931), REAL(0.308527),
+	REAL(0.240239), REAL(0.652714), REAL(0.466159),
+	REAL(0.265619), REAL(0.756464), REAL(0.504187),
+	REAL(0.192562), REAL(0.467341), REAL(0.522972),
+	REAL(0.201605), REAL(0.524885), REAL(0.478417),
+	REAL(0.215743), REAL(0.564193), REAL(0.538084),
+	REAL(0.264969), REAL(0.641527), REAL(0.605317),
+	REAL(0.201031), REAL(0.477940), REAL(0.584002),
+	REAL(0.263086), REAL(0.512567), REAL(0.637832),
+	REAL(0.238615), REAL(0.526867), REAL(0.672237),
+	REAL(0.105309), REAL(0.455123), REAL(0.658482),
+	REAL(0.183993), REAL(0.102195), REAL(0.804872),
+	REAL(0.161563), REAL(0.060042), REAL(0.808692),
+	REAL(0.180748), REAL(0.077754), REAL(0.771600),
+	REAL(0.175168), REAL(0.128588), REAL(0.746368),
+	REAL(0.175075), REAL(0.148030), REAL(0.778264),
+	REAL(0.175658), REAL(0.139265), REAL(0.814333),
+	REAL(0.154191), REAL(0.067291), REAL(0.832578),
+	REAL(0.163818), REAL(0.109013), REAL(0.842830),
+	REAL(0.084760), REAL(0.396004), REAL(0.679695),
+	REAL(0.238888), REAL(0.310760), REAL(0.590775),
+	REAL(0.213380), REAL(0.308625), REAL(0.644905),
+	REAL(0.199666), REAL(0.409678), REAL(0.683003),
+	REAL(0.190143), REAL(0.128597), REAL(0.733463),
+	REAL(0.184833), REAL(0.063516), REAL(0.762902),
+	REAL(0.166070), REAL(0.035644), REAL(0.818261),
+	REAL(0.154361), REAL(0.056943), REAL(0.857042),
+	REAL(0.168542), REAL(0.109489), REAL(0.862725),
+	REAL(0.187387), REAL(0.166131), REAL(0.784599),
+	REAL(0.180428), REAL(0.160135), REAL(0.819438),
+	REAL(0.201823), REAL(0.163991), REAL(0.695756),
+	REAL(0.194206), REAL(0.206635), REAL(0.782275),
+	REAL(0.155438), REAL(0.291260), REAL(0.734412),
+	REAL(0.177696), REAL(0.196424), REAL(0.846693),
+	REAL(0.152305), REAL(0.125256), REAL(0.890786),
+	REAL(0.119546), REAL(0.249876), REAL(0.859104),
+	REAL(0.118369), REAL(0.139643), REAL(0.919173),
+	REAL(0.079410), REAL(0.132973), REAL(0.948652),
+	REAL(0.062419), REAL(0.036648), REAL(0.976547),
+	REAL(0.127847), REAL(-0.035919), REAL(0.947070),
+	REAL(0.143624), REAL(0.032206), REAL(0.885913),
+	REAL(0.074888), REAL(-0.085173), REAL(0.980577),
+	REAL(0.130184), REAL(-0.104656), REAL(0.947620),
+	REAL(0.156201), REAL(-0.094653), REAL(0.899074),
+	REAL(0.077366), REAL(-0.171194), REAL(0.926545),
+	REAL(0.127722), REAL(-0.164729), REAL(0.879810),
+	REAL(0.052670), REAL(-0.184618), REAL(0.842019),
+	REAL(0.023477), REAL(-0.184638), REAL(0.889811),
+	REAL(0.022626), REAL(-0.210587), REAL(0.827500),
+	REAL(0.223089), REAL(0.211976), REAL(0.620493),
+	REAL(0.251444), REAL(0.113067), REAL(0.666494),
+	REAL(0.251419), REAL(0.089540), REAL(0.673887),
+	REAL(0.214360), REAL(0.019258), REAL(0.771595),
+	REAL(0.158999), REAL(0.001490), REAL(0.835374),
+	REAL(0.176696), REAL(-0.059249), REAL(0.849218),
+	REAL(0.148696), REAL(-0.130091), REAL(0.793599),
+	REAL(0.108290), REAL(-0.166528), REAL(0.772088),
+	REAL(0.049820), REAL(-0.201382), REAL(0.764454),
+	REAL(0.071341), REAL(-0.215195), REAL(0.697209),
+	REAL(0.073148), REAL(-0.214475), REAL(0.623510),
+	REAL(0.140502), REAL(-0.169461), REAL(0.699354),
+	REAL(0.163374), REAL(-0.157073), REAL(0.611416),
+	REAL(0.189466), REAL(-0.138550), REAL(0.730366),
+	REAL(0.247593), REAL(-0.082554), REAL(0.759610),
+	REAL(0.227468), REAL(-0.121982), REAL(0.590197),
+	REAL(0.284702), REAL(-0.006586), REAL(0.535347),
+	REAL(0.275741), REAL(0.125287), REAL(0.446676),
+	REAL(0.266650), REAL(0.192594), REAL(0.506044),
+	REAL(0.300086), REAL(0.053287), REAL(0.629620),
+	REAL(0.055450), REAL(-0.663935), REAL(0.375065),
+	REAL(0.122854), REAL(-0.664138), REAL(0.482323),
+	REAL(0.046520), REAL(-0.531571), REAL(0.391918),
+	REAL(0.024824), REAL(-0.568450), REAL(0.275106),
+	REAL(0.053855), REAL(-0.663931), REAL(0.328224),
+	REAL(0.112829), REAL(-0.453549), REAL(0.305788),
+	REAL(0.131265), REAL(-0.510617), REAL(0.080746),
+	REAL(0.061174), REAL(-0.430716), REAL(-0.042710),
+	REAL(0.341019), REAL(-0.532887), REAL(-0.208150),
+	REAL(0.347705), REAL(-0.623533), REAL(-0.081139),
+	REAL(0.238040), REAL(-0.610732), REAL(-0.038037),
+	REAL(0.211764), REAL(-0.514274), REAL(-0.132078),
+	REAL(0.120605), REAL(-0.600219), REAL(-0.186856),
+	REAL(0.096985), REAL(-0.584476), REAL(-0.293357),
+	REAL(0.127621), REAL(-0.581941), REAL(-0.437170),
+	REAL(0.165902), REAL(-0.477425), REAL(-0.291453),
+	REAL(0.077720), REAL(-0.417975), REAL(-0.220519),
+	REAL(0.320892), REAL(-0.506363), REAL(-0.320874),
+	REAL(0.248214), REAL(-0.465684), REAL(-0.239842),
+	REAL(0.118764), REAL(-0.383338), REAL(-0.187114),
+	REAL(0.118816), REAL(-0.430106), REAL(-0.123307),
+	REAL(0.094131), REAL(-0.419464), REAL(-0.044777),
+	REAL(0.274526), REAL(-0.261706), REAL(0.005110),
+	REAL(0.259842), REAL(-0.283292), REAL(-0.003185),
+	REAL(0.222861), REAL(-0.340431), REAL(-0.038210),
+	REAL(0.204445), REAL(-0.664380), REAL(0.513353),
+	REAL(0.259286), REAL(-0.664547), REAL(0.471281),
+	REAL(0.185402), REAL(-0.476020), REAL(0.421718),
+	REAL(0.279163), REAL(-0.664604), REAL(0.417328),
+	REAL(0.277157), REAL(-0.528122), REAL(0.400208),
+	REAL(0.183069), REAL(-0.509812), REAL(0.329995),
+	REAL(0.282599), REAL(-0.429210), REAL(0.059242),
+	REAL(0.254816), REAL(-0.664541), REAL(0.290687),
+	REAL(0.271436), REAL(-0.567707), REAL(0.263966),
+	REAL(0.386561), REAL(-0.625221), REAL(-0.216870),
+	REAL(0.387086), REAL(-0.630883), REAL(-0.346073),
+	REAL(0.380021), REAL(-0.596021), REAL(-0.318679),
+	REAL(0.291269), REAL(-0.619007), REAL(-0.585707),
+	REAL(0.339280), REAL(-0.571198), REAL(-0.461946),
+	REAL(0.400045), REAL(-0.489778), REAL(-0.422640),
+	REAL(0.406817), REAL(-0.314349), REAL(-0.371230),
+	REAL(0.300588), REAL(-0.281718), REAL(-0.170549),
+	REAL(0.290866), REAL(-0.277304), REAL(-0.061905),
+	REAL(0.187735), REAL(-0.241545), REAL(0.509437),
+	REAL(0.188032), REAL(-0.287569), REAL(0.424234),
+	REAL(0.227520), REAL(-0.373262), REAL(0.293102),
+	REAL(0.266526), REAL(-0.273650), REAL(0.039597),
+	REAL(0.291592), REAL(-0.291676), REAL(0.111386),
+	REAL(0.291914), REAL(-0.122741), REAL(0.422683),
+	REAL(0.297574), REAL(-0.156119), REAL(0.373368),
+	REAL(0.286603), REAL(-0.232731), REAL(0.027162),
+	REAL(0.364663), REAL(-0.201399), REAL(0.206850),
+	REAL(0.353855), REAL(-0.132408), REAL(0.149228),
+	REAL(0.282208), REAL(-0.019715), REAL(0.314960),
+	REAL(0.331187), REAL(-0.099266), REAL(0.092701),
+	REAL(0.375463), REAL(-0.093120), REAL(-0.006467),
+	REAL(0.375917), REAL(-0.101236), REAL(-0.154882),
+	REAL(0.466635), REAL(-0.094416), REAL(-0.305669),
+	REAL(0.455805), REAL(-0.119881), REAL(-0.460632),
+	REAL(0.277465), REAL(-0.604242), REAL(-0.651871),
+	REAL(0.261022), REAL(-0.551176), REAL(-0.554667),
+	REAL(0.093627), REAL(0.258494), REAL(-0.920589),
+	REAL(0.114248), REAL(0.310608), REAL(-0.798070),
+	REAL(0.144232), REAL(0.211434), REAL(-0.835001),
+	REAL(0.119916), REAL(0.176940), REAL(-0.951159),
+	REAL(0.184061), REAL(0.101854), REAL(-0.918220),
+	REAL(0.092431), REAL(0.276521), REAL(-0.738231),
+	REAL(0.133504), REAL(0.218403), REAL(-0.758602),
+	REAL(0.194987), REAL(0.097655), REAL(-0.812476),
+	REAL(0.185542), REAL(0.011005), REAL(-0.879202),
+	REAL(0.230315), REAL(-0.127450), REAL(-0.884202),
+	REAL(0.260471), REAL(0.255056), REAL(-0.624378),
+	REAL(0.351567), REAL(-0.042194), REAL(-0.663976),
+	REAL(0.253742), REAL(0.323524), REAL(-0.433716),
+	REAL(0.411612), REAL(0.132299), REAL(-0.438264),
+	REAL(0.270513), REAL(0.356530), REAL(-0.289984),
+	REAL(0.422146), REAL(0.162819), REAL(-0.273130),
+	REAL(0.164724), REAL(0.237490), REAL(0.208912),
+	REAL(0.253806), REAL(0.092900), REAL(0.240640),
+	REAL(0.203608), REAL(0.284597), REAL(0.096223),
+	REAL(0.241006), REAL(0.343093), REAL(-0.171396),
+	REAL(0.356076), REAL(0.149288), REAL(-0.143443),
+	REAL(0.337656), REAL(0.131992), REAL(0.066374)};
+
+static int gIndicesBunny[BUNNY_NUM_TRIANGLES][3] = {
+	{126, 134, 133},
+	{342, 138, 134},
+	{133, 134, 138},
+	{126, 342, 134},
+	{312, 316, 317},
+	{169, 163, 162},
+	{312, 317, 319},
+	{312, 319, 318},
+	{169, 162, 164},
+	{169, 168, 163},
+	{312, 314, 315},
+	{169, 164, 165},
+	{169, 167, 168},
+	{312, 315, 316},
+	{312, 313, 314},
+	{169, 165, 166},
+	{169, 166, 167},
+	{312, 318, 313},
+	{308, 304, 305},
+	{308, 305, 306},
+	{179, 181, 188},
+	{177, 173, 175},
+	{177, 175, 176},
+	{302, 293, 300},
+	{322, 294, 304},
+	{188, 176, 175},
+	{188, 175, 179},
+	{158, 177, 187},
+	{305, 293, 302},
+	{305, 302, 306},
+	{322, 304, 308},
+	{188, 181, 183},
+	{158, 173, 177},
+	{293, 298, 300},
+	{304, 294, 296},
+	{304, 296, 305},
+	{185, 176, 188},
+	{185, 188, 183},
+	{187, 177, 176},
+	{187, 176, 185},
+	{305, 296, 298},
+	{305, 298, 293},
+	{436, 432, 28},
+	{436, 28, 23},
+	{434, 278, 431},
+	{30, 208, 209},
+	{30, 209, 29},
+	{19, 20, 24},
+	{208, 207, 211},
+	{208, 211, 209},
+	{19, 210, 212},
+	{433, 434, 431},
+	{433, 431, 432},
+	{433, 432, 436},
+	{436, 437, 433},
+	{277, 275, 276},
+	{277, 276, 278},
+	{209, 210, 25},
+	{21, 26, 24},
+	{21, 24, 20},
+	{25, 26, 27},
+	{25, 27, 29},
+	{435, 439, 277},
+	{439, 275, 277},
+	{432, 431, 30},
+	{432, 30, 28},
+	{433, 437, 438},
+	{433, 438, 435},
+	{434, 277, 278},
+	{24, 25, 210},
+	{24, 26, 25},
+	{29, 27, 28},
+	{29, 28, 30},
+	{19, 24, 210},
+	{208, 30, 431},
+	{208, 431, 278},
+	{435, 434, 433},
+	{435, 277, 434},
+	{25, 29, 209},
+	{27, 22, 23},
+	{27, 23, 28},
+	{26, 22, 27},
+	{26, 21, 22},
+	{212, 210, 209},
+	{212, 209, 211},
+	{207, 208, 278},
+	{207, 278, 276},
+	{439, 435, 438},
+	{12, 9, 10},
+	{12, 10, 13},
+	{2, 3, 5},
+	{2, 5, 4},
+	{16, 13, 14},
+	{16, 14, 17},
+	{22, 21, 16},
+	{13, 10, 11},
+	{13, 11, 14},
+	{1, 0, 3},
+	{1, 3, 2},
+	{15, 12, 16},
+	{19, 18, 15},
+	{19, 15, 16},
+	{19, 16, 20},
+	{9, 1, 2},
+	{9, 2, 10},
+	{3, 7, 8},
+	{3, 8, 5},
+	{16, 17, 23},
+	{16, 23, 22},
+	{21, 20, 16},
+	{10, 2, 4},
+	{10, 4, 11},
+	{0, 6, 7},
+	{0, 7, 3},
+	{12, 13, 16},
+	{451, 446, 445},
+	{451, 445, 450},
+	{442, 440, 439},
+	{442, 439, 438},
+	{442, 438, 441},
+	{421, 420, 422},
+	{412, 411, 426},
+	{412, 426, 425},
+	{408, 405, 407},
+	{413, 67, 68},
+	{413, 68, 414},
+	{391, 390, 412},
+	{80, 384, 386},
+	{404, 406, 378},
+	{390, 391, 377},
+	{390, 377, 88},
+	{400, 415, 375},
+	{398, 396, 395},
+	{398, 395, 371},
+	{398, 371, 370},
+	{112, 359, 358},
+	{112, 358, 113},
+	{351, 352, 369},
+	{125, 349, 348},
+	{345, 343, 342},
+	{342, 340, 339},
+	{341, 335, 337},
+	{328, 341, 327},
+	{331, 323, 333},
+	{331, 322, 323},
+	{327, 318, 319},
+	{327, 319, 328},
+	{315, 314, 324},
+	{302, 300, 301},
+	{302, 301, 303},
+	{320, 311, 292},
+	{285, 284, 289},
+	{310, 307, 288},
+	{310, 288, 290},
+	{321, 350, 281},
+	{321, 281, 282},
+	{423, 448, 367},
+	{272, 273, 384},
+	{272, 384, 274},
+	{264, 265, 382},
+	{264, 382, 383},
+	{440, 442, 261},
+	{440, 261, 263},
+	{252, 253, 254},
+	{252, 254, 251},
+	{262, 256, 249},
+	{262, 249, 248},
+	{228, 243, 242},
+	{228, 31, 243},
+	{213, 215, 238},
+	{213, 238, 237},
+	{19, 212, 230},
+	{224, 225, 233},
+	{224, 233, 231},
+	{217, 218, 56},
+	{217, 56, 54},
+	{217, 216, 239},
+	{217, 239, 238},
+	{217, 238, 215},
+	{218, 217, 215},
+	{218, 215, 214},
+	{6, 102, 206},
+	{186, 199, 200},
+	{197, 182, 180},
+	{170, 171, 157},
+	{201, 200, 189},
+	{170, 190, 191},
+	{170, 191, 192},
+	{175, 174, 178},
+	{175, 178, 179},
+	{168, 167, 155},
+	{122, 149, 158},
+	{122, 158, 159},
+	{135, 153, 154},
+	{135, 154, 118},
+	{143, 140, 141},
+	{143, 141, 144},
+	{132, 133, 136},
+	{130, 126, 133},
+	{124, 125, 127},
+	{122, 101, 100},
+	{122, 100, 121},
+	{110, 108, 107},
+	{110, 107, 109},
+	{98, 99, 97},
+	{98, 97, 64},
+	{98, 64, 66},
+	{87, 55, 57},
+	{83, 82, 79},
+	{83, 79, 84},
+	{78, 74, 50},
+	{49, 71, 41},
+	{49, 41, 37},
+	{49, 37, 36},
+	{58, 44, 60},
+	{60, 59, 58},
+	{51, 34, 33},
+	{39, 40, 42},
+	{39, 42, 38},
+	{243, 240, 33},
+	{243, 33, 229},
+	{39, 38, 6},
+	{44, 46, 40},
+	{55, 56, 57},
+	{64, 62, 65},
+	{64, 65, 66},
+	{41, 71, 45},
+	{75, 50, 51},
+	{81, 79, 82},
+	{77, 88, 73},
+	{93, 92, 94},
+	{68, 47, 46},
+	{96, 97, 99},
+	{96, 99, 95},
+	{110, 109, 111},
+	{111, 112, 110},
+	{114, 113, 123},
+	{114, 123, 124},
+	{132, 131, 129},
+	{133, 137, 136},
+	{135, 142, 145},
+	{145, 152, 135},
+	{149, 147, 157},
+	{157, 158, 149},
+	{164, 150, 151},
+	{153, 163, 168},
+	{153, 168, 154},
+	{185, 183, 182},
+	{185, 182, 184},
+	{161, 189, 190},
+	{200, 199, 191},
+	{200, 191, 190},
+	{180, 178, 195},
+	{180, 195, 196},
+	{102, 101, 204},
+	{102, 204, 206},
+	{43, 48, 104},
+	{43, 104, 103},
+	{216, 217, 54},
+	{216, 54, 32},
+	{207, 224, 231},
+	{230, 212, 211},
+	{230, 211, 231},
+	{227, 232, 241},
+	{227, 241, 242},
+	{235, 234, 241},
+	{235, 241, 244},
+	{430, 248, 247},
+	{272, 274, 253},
+	{272, 253, 252},
+	{439, 260, 275},
+	{225, 224, 259},
+	{225, 259, 257},
+	{269, 270, 407},
+	{269, 407, 405},
+	{270, 269, 273},
+	{270, 273, 272},
+	{273, 269, 268},
+	{273, 268, 267},
+	{273, 267, 266},
+	{273, 266, 265},
+	{273, 265, 264},
+	{448, 279, 367},
+	{281, 350, 368},
+	{285, 286, 301},
+	{290, 323, 310},
+	{290, 311, 323},
+	{282, 281, 189},
+	{292, 311, 290},
+	{292, 290, 291},
+	{307, 306, 302},
+	{307, 302, 303},
+	{316, 315, 324},
+	{316, 324, 329},
+	{331, 351, 350},
+	{330, 334, 335},
+	{330, 335, 328},
+	{341, 337, 338},
+	{344, 355, 354},
+	{346, 345, 348},
+	{346, 348, 347},
+	{364, 369, 352},
+	{364, 352, 353},
+	{365, 363, 361},
+	{365, 361, 362},
+	{376, 401, 402},
+	{373, 372, 397},
+	{373, 397, 400},
+	{376, 92, 377},
+	{381, 378, 387},
+	{381, 387, 385},
+	{386, 77, 80},
+	{390, 389, 412},
+	{416, 417, 401},
+	{403, 417, 415},
+	{408, 429, 430},
+	{419, 423, 418},
+	{427, 428, 444},
+	{427, 444, 446},
+	{437, 436, 441},
+	{450, 445, 11},
+	{450, 11, 4},
+	{447, 449, 5},
+	{447, 5, 8},
+	{441, 438, 437},
+	{425, 426, 451},
+	{425, 451, 452},
+	{417, 421, 415},
+	{408, 407, 429},
+	{399, 403, 400},
+	{399, 400, 397},
+	{394, 393, 416},
+	{389, 411, 412},
+	{386, 383, 385},
+	{408, 387, 378},
+	{408, 378, 406},
+	{377, 391, 376},
+	{94, 375, 415},
+	{372, 373, 374},
+	{372, 374, 370},
+	{359, 111, 360},
+	{359, 112, 111},
+	{113, 358, 349},
+	{113, 349, 123},
+	{346, 343, 345},
+	{343, 340, 342},
+	{338, 336, 144},
+	{338, 144, 141},
+	{327, 341, 354},
+	{327, 354, 326},
+	{331, 350, 321},
+	{331, 321, 322},
+	{314, 313, 326},
+	{314, 326, 325},
+	{300, 298, 299},
+	{300, 299, 301},
+	{288, 287, 289},
+	{189, 292, 282},
+	{287, 288, 303},
+	{284, 285, 297},
+	{368, 280, 281},
+	{448, 447, 279},
+	{274, 226, 255},
+	{267, 268, 404},
+	{267, 404, 379},
+	{429, 262, 430},
+	{439, 440, 260},
+	{257, 258, 249},
+	{257, 249, 246},
+	{430, 262, 248},
+	{234, 228, 242},
+	{234, 242, 241},
+	{237, 238, 239},
+	{237, 239, 236},
+	{15, 18, 227},
+	{15, 227, 229},
+	{222, 223, 82},
+	{222, 82, 83},
+	{214, 215, 213},
+	{214, 213, 81},
+	{38, 102, 6},
+	{122, 159, 200},
+	{122, 200, 201},
+	{174, 171, 192},
+	{174, 192, 194},
+	{197, 193, 198},
+	{190, 170, 161},
+	{181, 179, 178},
+	{181, 178, 180},
+	{166, 156, 155},
+	{163, 153, 152},
+	{163, 152, 162},
+	{120, 156, 149},
+	{120, 149, 121},
+	{152, 153, 135},
+	{140, 143, 142},
+	{135, 131, 132},
+	{135, 132, 136},
+	{130, 129, 128},
+	{130, 128, 127},
+	{100, 105, 119},
+	{100, 119, 120},
+	{106, 104, 107},
+	{106, 107, 108},
+	{91, 95, 59},
+	{93, 94, 68},
+	{91, 89, 92},
+	{76, 53, 55},
+	{76, 55, 87},
+	{81, 78, 79},
+	{74, 73, 49},
+	{69, 60, 45},
+	{58, 62, 64},
+	{58, 64, 61},
+	{53, 31, 32},
+	{32, 54, 53},
+	{42, 43, 38},
+	{35, 36, 0},
+	{35, 0, 1},
+	{34, 35, 1},
+	{34, 1, 9},
+	{44, 40, 41},
+	{44, 41, 45},
+	{33, 240, 51},
+	{63, 62, 58},
+	{63, 58, 59},
+	{45, 71, 70},
+	{76, 75, 51},
+	{76, 51, 52},
+	{86, 85, 84},
+	{86, 84, 87},
+	{89, 72, 73},
+	{89, 73, 88},
+	{91, 92, 96},
+	{91, 96, 95},
+	{72, 91, 60},
+	{72, 60, 69},
+	{104, 106, 105},
+	{119, 105, 117},
+	{119, 117, 118},
+	{124, 127, 128},
+	{117, 116, 129},
+	{117, 129, 131},
+	{118, 117, 131},
+	{135, 140, 142},
+	{146, 150, 152},
+	{146, 152, 145},
+	{149, 122, 121},
+	{166, 165, 151},
+	{166, 151, 156},
+	{158, 172, 173},
+	{161, 160, 189},
+	{199, 198, 193},
+	{199, 193, 191},
+	{204, 201, 202},
+	{178, 174, 194},
+	{200, 159, 186},
+	{109, 48, 67},
+	{48, 107, 104},
+	{216, 32, 236},
+	{216, 236, 239},
+	{223, 214, 81},
+	{223, 81, 82},
+	{33, 12, 15},
+	{32, 228, 234},
+	{32, 234, 236},
+	{240, 31, 52},
+	{256, 255, 246},
+	{256, 246, 249},
+	{258, 263, 248},
+	{258, 248, 249},
+	{275, 260, 259},
+	{275, 259, 276},
+	{207, 276, 259},
+	{270, 271, 429},
+	{270, 429, 407},
+	{413, 418, 366},
+	{413, 366, 365},
+	{368, 367, 279},
+	{368, 279, 280},
+	{303, 301, 286},
+	{303, 286, 287},
+	{283, 282, 292},
+	{283, 292, 291},
+	{320, 292, 189},
+	{298, 296, 297},
+	{298, 297, 299},
+	{318, 327, 326},
+	{318, 326, 313},
+	{329, 330, 317},
+	{336, 333, 320},
+	{326, 354, 353},
+	{334, 332, 333},
+	{334, 333, 336},
+	{342, 339, 139},
+	{342, 139, 138},
+	{345, 342, 126},
+	{347, 357, 356},
+	{369, 368, 351},
+	{363, 356, 357},
+	{363, 357, 361},
+	{366, 367, 368},
+	{366, 368, 369},
+	{375, 373, 400},
+	{92, 90, 377},
+	{409, 387, 408},
+	{386, 385, 387},
+	{386, 387, 388},
+	{412, 394, 391},
+	{396, 398, 399},
+	{408, 406, 405},
+	{415, 421, 419},
+	{415, 419, 414},
+	{425, 452, 448},
+	{425, 448, 424},
+	{444, 441, 443},
+	{448, 452, 449},
+	{448, 449, 447},
+	{446, 444, 443},
+	{446, 443, 445},
+	{250, 247, 261},
+	{250, 261, 428},
+	{421, 422, 423},
+	{421, 423, 419},
+	{427, 410, 250},
+	{417, 403, 401},
+	{403, 402, 401},
+	{420, 392, 412},
+	{420, 412, 425},
+	{420, 425, 424},
+	{386, 411, 389},
+	{383, 382, 381},
+	{383, 381, 385},
+	{378, 379, 404},
+	{372, 371, 395},
+	{372, 395, 397},
+	{371, 372, 370},
+	{361, 359, 360},
+	{361, 360, 362},
+	{368, 350, 351},
+	{349, 347, 348},
+	{356, 355, 344},
+	{356, 344, 346},
+	{344, 341, 340},
+	{344, 340, 343},
+	{338, 337, 336},
+	{328, 335, 341},
+	{324, 352, 351},
+	{324, 351, 331},
+	{320, 144, 336},
+	{314, 325, 324},
+	{322, 308, 309},
+	{310, 309, 307},
+	{287, 286, 289},
+	{203, 280, 279},
+	{203, 279, 205},
+	{297, 295, 283},
+	{297, 283, 284},
+	{447, 205, 279},
+	{274, 384, 80},
+	{274, 80, 226},
+	{266, 267, 379},
+	{266, 379, 380},
+	{225, 257, 246},
+	{225, 246, 245},
+	{256, 254, 253},
+	{256, 253, 255},
+	{430, 247, 250},
+	{226, 235, 244},
+	{226, 244, 245},
+	{232, 233, 244},
+	{232, 244, 241},
+	{230, 18, 19},
+	{32, 31, 228},
+	{219, 220, 86},
+	{219, 86, 57},
+	{226, 213, 235},
+	{206, 7, 6},
+	{122, 201, 101},
+	{201, 204, 101},
+	{180, 196, 197},
+	{170, 192, 171},
+	{200, 190, 189},
+	{194, 193, 195},
+	{183, 181, 180},
+	{183, 180, 182},
+	{155, 154, 168},
+	{149, 156, 151},
+	{149, 151, 148},
+	{155, 156, 120},
+	{145, 142, 143},
+	{145, 143, 146},
+	{136, 137, 140},
+	{133, 132, 130},
+	{128, 129, 116},
+	{100, 120, 121},
+	{110, 112, 113},
+	{110, 113, 114},
+	{66, 65, 63},
+	{66, 63, 99},
+	{66, 99, 98},
+	{96, 46, 61},
+	{89, 88, 90},
+	{86, 87, 57},
+	{80, 78, 81},
+	{72, 69, 49},
+	{67, 48, 47},
+	{67, 47, 68},
+	{56, 55, 53},
+	{50, 49, 36},
+	{50, 36, 35},
+	{40, 39, 41},
+	{242, 243, 229},
+	{242, 229, 227},
+	{6, 37, 39},
+	{42, 47, 48},
+	{42, 48, 43},
+	{61, 46, 44},
+	{45, 70, 69},
+	{69, 70, 71},
+	{69, 71, 49},
+	{74, 78, 77},
+	{83, 84, 85},
+	{73, 74, 77},
+	{93, 96, 92},
+	{68, 46, 93},
+	{95, 99, 63},
+	{95, 63, 59},
+	{115, 108, 110},
+	{115, 110, 114},
+	{125, 126, 127},
+	{129, 130, 132},
+	{137, 133, 138},
+	{137, 138, 139},
+	{148, 146, 143},
+	{148, 143, 147},
+	{119, 118, 154},
+	{161, 147, 143},
+	{165, 164, 151},
+	{158, 157, 171},
+	{158, 171, 172},
+	{159, 158, 187},
+	{159, 187, 186},
+	{194, 192, 191},
+	{194, 191, 193},
+	{189, 202, 201},
+	{182, 197, 184},
+	{205, 8, 7},
+	{48, 109, 107},
+	{218, 219, 57},
+	{218, 57, 56},
+	{207, 231, 211},
+	{232, 230, 231},
+	{232, 231, 233},
+	{53, 52, 31},
+	{388, 411, 386},
+	{409, 430, 250},
+	{262, 429, 254},
+	{262, 254, 256},
+	{442, 444, 428},
+	{273, 264, 383},
+	{273, 383, 384},
+	{429, 271, 251},
+	{429, 251, 254},
+	{413, 365, 362},
+	{67, 413, 360},
+	{282, 283, 295},
+	{285, 301, 299},
+	{202, 281, 280},
+	{284, 283, 291},
+	{284, 291, 289},
+	{320, 189, 160},
+	{308, 306, 307},
+	{307, 309, 308},
+	{319, 317, 330},
+	{319, 330, 328},
+	{353, 352, 324},
+	{332, 331, 333},
+	{340, 341, 338},
+	{354, 341, 344},
+	{349, 358, 357},
+	{349, 357, 347},
+	{364, 355, 356},
+	{364, 356, 363},
+	{364, 365, 366},
+	{364, 366, 369},
+	{374, 376, 402},
+	{375, 92, 373},
+	{77, 389, 390},
+	{382, 380, 381},
+	{389, 77, 386},
+	{393, 394, 412},
+	{393, 412, 392},
+	{401, 394, 416},
+	{415, 400, 403},
+	{411, 410, 427},
+	{411, 427, 426},
+	{422, 420, 424},
+	{247, 248, 263},
+	{247, 263, 261},
+	{445, 443, 14},
+	{445, 14, 11},
+	{449, 450, 4},
+	{449, 4, 5},
+	{443, 441, 17},
+	{443, 17, 14},
+	{436, 23, 17},
+	{436, 17, 441},
+	{424, 448, 422},
+	{448, 423, 422},
+	{414, 419, 418},
+	{414, 418, 413},
+	{406, 404, 405},
+	{399, 397, 395},
+	{399, 395, 396},
+	{420, 416, 392},
+	{388, 410, 411},
+	{386, 384, 383},
+	{390, 88, 77},
+	{375, 94, 92},
+	{415, 414, 68},
+	{415, 68, 94},
+	{370, 374, 402},
+	{370, 402, 398},
+	{361, 357, 358},
+	{361, 358, 359},
+	{125, 348, 126},
+	{346, 344, 343},
+	{340, 338, 339},
+	{337, 335, 334},
+	{337, 334, 336},
+	{325, 353, 324},
+	{324, 331, 332},
+	{324, 332, 329},
+	{323, 322, 309},
+	{323, 309, 310},
+	{294, 295, 297},
+	{294, 297, 296},
+	{289, 286, 285},
+	{202, 280, 203},
+	{288, 307, 303},
+	{282, 295, 321},
+	{67, 360, 111},
+	{418, 423, 367},
+	{418, 367, 366},
+	{272, 252, 251},
+	{272, 251, 271},
+	{272, 271, 270},
+	{255, 253, 274},
+	{265, 266, 380},
+	{265, 380, 382},
+	{442, 428, 261},
+	{440, 263, 258},
+	{440, 258, 260},
+	{409, 250, 410},
+	{255, 226, 245},
+	{255, 245, 246},
+	{31, 240, 243},
+	{236, 234, 235},
+	{236, 235, 237},
+	{233, 225, 245},
+	{233, 245, 244},
+	{220, 221, 85},
+	{220, 85, 86},
+	{81, 213, 226},
+	{81, 226, 80},
+	{7, 206, 205},
+	{186, 184, 198},
+	{186, 198, 199},
+	{204, 203, 205},
+	{204, 205, 206},
+	{195, 193, 196},
+	{171, 174, 172},
+	{173, 174, 175},
+	{173, 172, 174},
+	{155, 167, 166},
+	{160, 161, 143},
+	{160, 143, 144},
+	{119, 154, 155},
+	{148, 151, 150},
+	{148, 150, 146},
+	{140, 137, 139},
+	{140, 139, 141},
+	{127, 126, 130},
+	{114, 124, 128},
+	{114, 128, 115},
+	{117, 105, 106},
+	{117, 106, 116},
+	{104, 105, 100},
+	{104, 100, 103},
+	{59, 60, 91},
+	{97, 96, 61},
+	{97, 61, 64},
+	{91, 72, 89},
+	{87, 84, 79},
+	{87, 79, 76},
+	{78, 80, 77},
+	{49, 50, 74},
+	{60, 44, 45},
+	{61, 44, 58},
+	{51, 50, 35},
+	{51, 35, 34},
+	{39, 37, 41},
+	{33, 34, 9},
+	{33, 9, 12},
+	{0, 36, 37},
+	{0, 37, 6},
+	{40, 46, 47},
+	{40, 47, 42},
+	{53, 54, 56},
+	{65, 62, 63},
+	{72, 49, 73},
+	{79, 78, 75},
+	{79, 75, 76},
+	{52, 53, 76},
+	{92, 89, 90},
+	{96, 93, 46},
+	{102, 103, 100},
+	{102, 100, 101},
+	{116, 106, 108},
+	{116, 108, 115},
+	{123, 125, 124},
+	{116, 115, 128},
+	{118, 131, 135},
+	{140, 135, 136},
+	{148, 147, 149},
+	{120, 119, 155},
+	{164, 162, 152},
+	{164, 152, 150},
+	{157, 147, 161},
+	{157, 161, 170},
+	{186, 187, 185},
+	{186, 185, 184},
+	{193, 197, 196},
+	{202, 203, 204},
+	{194, 195, 178},
+	{198, 184, 197},
+	{67, 111, 109},
+	{38, 43, 103},
+	{38, 103, 102},
+	{214, 223, 222},
+	{214, 222, 221},
+	{214, 221, 220},
+	{214, 220, 219},
+	{214, 219, 218},
+	{213, 237, 235},
+	{221, 222, 83},
+	{221, 83, 85},
+	{15, 229, 33},
+	{227, 18, 230},
+	{227, 230, 232},
+	{52, 51, 240},
+	{75, 78, 50},
+	{408, 430, 409},
+	{260, 258, 257},
+	{260, 257, 259},
+	{224, 207, 259},
+	{268, 269, 405},
+	{268, 405, 404},
+	{413, 362, 360},
+	{447, 8, 205},
+	{299, 297, 285},
+	{189, 281, 202},
+	{290, 288, 289},
+	{290, 289, 291},
+	{322, 321, 295},
+	{322, 295, 294},
+	{333, 323, 311},
+	{333, 311, 320},
+	{317, 316, 329},
+	{320, 160, 144},
+	{353, 325, 326},
+	{329, 332, 334},
+	{329, 334, 330},
+	{339, 338, 141},
+	{339, 141, 139},
+	{348, 345, 126},
+	{347, 356, 346},
+	{123, 349, 125},
+	{364, 353, 354},
+	{364, 354, 355},
+	{365, 364, 363},
+	{376, 391, 394},
+	{376, 394, 401},
+	{92, 376, 374},
+	{92, 374, 373},
+	{377, 90, 88},
+	{380, 379, 378},
+	{380, 378, 381},
+	{388, 387, 409},
+	{388, 409, 410},
+	{416, 393, 392},
+	{399, 398, 402},
+	{399, 402, 403},
+	{250, 428, 427},
+	{421, 417, 416},
+	{421, 416, 420},
+	{426, 427, 446},
+	{426, 446, 451},
+	{444, 442, 441},
+	{452, 451, 450},
+	{452, 450, 449}};
+
+//***************************THE END OF FAMOUS BUNNY TRIMESH********************************************//
+
+#endif  //BUNNY_MESH_H_
diff --git a/engine/inc/bullet/SoftDemo/SoftDemo.h b/engine/inc/bullet/SoftDemo/SoftDemo.h
new file mode 100644
index 00000000..16de2051
--- /dev/null
+++ b/engine/inc/bullet/SoftDemo/SoftDemo.h
@@ -0,0 +1,24 @@
+
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+///btSoftBody implementation by Nathanael Presson
+
+#ifndef SOFT_DEMO_H
+#define SOFT_DEMO_H
+
+class CommonExampleInterface* SoftDemoCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //CCD_PHYSICS_DEMO_H
diff --git a/engine/inc/bullet/SoftDemo/TorusMesh.h b/engine/inc/bullet/SoftDemo/TorusMesh.h
new file mode 100644
index 00000000..20f358fb
--- /dev/null
+++ b/engine/inc/bullet/SoftDemo/TorusMesh.h
@@ -0,0 +1,916 @@
+#ifndef TORUS_MESH_H_
+#define TORUS_MESH_H_
+
+//*************************** NOT REALLY FAMOUS TORUS ********************************************//
+
+#define Real btScalar
+const int NUM_TRIANGLES = 600;
+const int NUM_VERTICES = 300;
+const int NUM_INDICES = NUM_TRIANGLES * 3;
+
+static Real gVertices[NUM_VERTICES * 3] = {
+	Real(2.5), Real(0), Real(0),
+	Real(2.405), Real(0.294), Real(0),
+	Real(2.155), Real(0.476), Real(0),
+	Real(1.845), Real(0.476), Real(0),
+	Real(1.595), Real(0.294), Real(0),
+	Real(1.5), Real(0), Real(0),
+	Real(1.595), Real(-0.294), Real(0),
+	Real(1.845), Real(-0.476), Real(0),
+	Real(2.155), Real(-0.476), Real(0),
+	Real(2.405), Real(-0.294), Real(0),
+	Real(2.445), Real(0), Real(0.52),
+	Real(2.352), Real(0.294), Real(0.5),
+	Real(2.107), Real(0.476), Real(0.448),
+	Real(1.805), Real(0.476), Real(0.384),
+	Real(1.561), Real(0.294), Real(0.332),
+	Real(1.467), Real(0), Real(0.312),
+	Real(1.561), Real(-0.294), Real(0.332),
+	Real(1.805), Real(-0.476), Real(0.384),
+	Real(2.107), Real(-0.476), Real(0.448),
+	Real(2.352), Real(-0.294), Real(0.5),
+	Real(2.284), Real(0), Real(1.017),
+	Real(2.197), Real(0.294), Real(0.978),
+	Real(1.968), Real(0.476), Real(0.876),
+	Real(1.686), Real(0.476), Real(0.751),
+	Real(1.458), Real(0.294), Real(0.649),
+	Real(1.37), Real(0), Real(0.61),
+	Real(1.458), Real(-0.294), Real(0.649),
+	Real(1.686), Real(-0.476), Real(0.751),
+	Real(1.968), Real(-0.476), Real(0.876),
+	Real(2.197), Real(-0.294), Real(0.978),
+	Real(2.023), Real(0), Real(1.469),
+	Real(1.945), Real(0.294), Real(1.413),
+	Real(1.743), Real(0.476), Real(1.266),
+	Real(1.493), Real(0.476), Real(1.085),
+	Real(1.291), Real(0.294), Real(0.938),
+	Real(1.214), Real(0), Real(0.882),
+	Real(1.291), Real(-0.294), Real(0.938),
+	Real(1.493), Real(-0.476), Real(1.085),
+	Real(1.743), Real(-0.476), Real(1.266),
+	Real(1.945), Real(-0.294), Real(1.413),
+	Real(1.673), Real(0), Real(1.858),
+	Real(1.609), Real(0.294), Real(1.787),
+	Real(1.442), Real(0.476), Real(1.601),
+	Real(1.235), Real(0.476), Real(1.371),
+	Real(1.068), Real(0.294), Real(1.186),
+	Real(1.004), Real(0), Real(1.115),
+	Real(1.068), Real(-0.294), Real(1.186),
+	Real(1.235), Real(-0.476), Real(1.371),
+	Real(1.442), Real(-0.476), Real(1.601),
+	Real(1.609), Real(-0.294), Real(1.787),
+	Real(1.25), Real(0), Real(2.165),
+	Real(1.202), Real(0.294), Real(2.082),
+	Real(1.077), Real(0.476), Real(1.866),
+	Real(0.923), Real(0.476), Real(1.598),
+	Real(0.798), Real(0.294), Real(1.382),
+	Real(0.75), Real(0), Real(1.299),
+	Real(0.798), Real(-0.294), Real(1.382),
+	Real(0.923), Real(-0.476), Real(1.598),
+	Real(1.077), Real(-0.476), Real(1.866),
+	Real(1.202), Real(-0.294), Real(2.082),
+	Real(0.773), Real(0), Real(2.378),
+	Real(0.743), Real(0.294), Real(2.287),
+	Real(0.666), Real(0.476), Real(2.049),
+	Real(0.57), Real(0.476), Real(1.755),
+	Real(0.493), Real(0.294), Real(1.517),
+	Real(0.464), Real(0), Real(1.427),
+	Real(0.493), Real(-0.294), Real(1.517),
+	Real(0.57), Real(-0.476), Real(1.755),
+	Real(0.666), Real(-0.476), Real(2.049),
+	Real(0.743), Real(-0.294), Real(2.287),
+	Real(0.261), Real(0), Real(2.486),
+	Real(0.251), Real(0.294), Real(2.391),
+	Real(0.225), Real(0.476), Real(2.143),
+	Real(0.193), Real(0.476), Real(1.835),
+	Real(0.167), Real(0.294), Real(1.587),
+	Real(0.157), Real(0), Real(1.492),
+	Real(0.167), Real(-0.294), Real(1.587),
+	Real(0.193), Real(-0.476), Real(1.835),
+	Real(0.225), Real(-0.476), Real(2.143),
+	Real(0.251), Real(-0.294), Real(2.391),
+	Real(-0.261), Real(0), Real(2.486),
+	Real(-0.251), Real(0.294), Real(2.391),
+	Real(-0.225), Real(0.476), Real(2.143),
+	Real(-0.193), Real(0.476), Real(1.835),
+	Real(-0.167), Real(0.294), Real(1.587),
+	Real(-0.157), Real(0), Real(1.492),
+	Real(-0.167), Real(-0.294), Real(1.587),
+	Real(-0.193), Real(-0.476), Real(1.835),
+	Real(-0.225), Real(-0.476), Real(2.143),
+	Real(-0.251), Real(-0.294), Real(2.391),
+	Real(-0.773), Real(0), Real(2.378),
+	Real(-0.743), Real(0.294), Real(2.287),
+	Real(-0.666), Real(0.476), Real(2.049),
+	Real(-0.57), Real(0.476), Real(1.755),
+	Real(-0.493), Real(0.294), Real(1.517),
+	Real(-0.464), Real(0), Real(1.427),
+	Real(-0.493), Real(-0.294), Real(1.517),
+	Real(-0.57), Real(-0.476), Real(1.755),
+	Real(-0.666), Real(-0.476), Real(2.049),
+	Real(-0.743), Real(-0.294), Real(2.287),
+	Real(-1.25), Real(0), Real(2.165),
+	Real(-1.202), Real(0.294), Real(2.082),
+	Real(-1.077), Real(0.476), Real(1.866),
+	Real(-0.923), Real(0.476), Real(1.598),
+	Real(-0.798), Real(0.294), Real(1.382),
+	Real(-0.75), Real(0), Real(1.299),
+	Real(-0.798), Real(-0.294), Real(1.382),
+	Real(-0.923), Real(-0.476), Real(1.598),
+	Real(-1.077), Real(-0.476), Real(1.866),
+	Real(-1.202), Real(-0.294), Real(2.082),
+	Real(-1.673), Real(0), Real(1.858),
+	Real(-1.609), Real(0.294), Real(1.787),
+	Real(-1.442), Real(0.476), Real(1.601),
+	Real(-1.235), Real(0.476), Real(1.371),
+	Real(-1.068), Real(0.294), Real(1.186),
+	Real(-1.004), Real(0), Real(1.115),
+	Real(-1.068), Real(-0.294), Real(1.186),
+	Real(-1.235), Real(-0.476), Real(1.371),
+	Real(-1.442), Real(-0.476), Real(1.601),
+	Real(-1.609), Real(-0.294), Real(1.787),
+	Real(-2.023), Real(0), Real(1.469),
+	Real(-1.945), Real(0.294), Real(1.413),
+	Real(-1.743), Real(0.476), Real(1.266),
+	Real(-1.493), Real(0.476), Real(1.085),
+	Real(-1.291), Real(0.294), Real(0.938),
+	Real(-1.214), Real(0), Real(0.882),
+	Real(-1.291), Real(-0.294), Real(0.938),
+	Real(-1.493), Real(-0.476), Real(1.085),
+	Real(-1.743), Real(-0.476), Real(1.266),
+	Real(-1.945), Real(-0.294), Real(1.413),
+	Real(-2.284), Real(0), Real(1.017),
+	Real(-2.197), Real(0.294), Real(0.978),
+	Real(-1.968), Real(0.476), Real(0.876),
+	Real(-1.686), Real(0.476), Real(0.751),
+	Real(-1.458), Real(0.294), Real(0.649),
+	Real(-1.37), Real(0), Real(0.61),
+	Real(-1.458), Real(-0.294), Real(0.649),
+	Real(-1.686), Real(-0.476), Real(0.751),
+	Real(-1.968), Real(-0.476), Real(0.876),
+	Real(-2.197), Real(-0.294), Real(0.978),
+	Real(-2.445), Real(0), Real(0.52),
+	Real(-2.352), Real(0.294), Real(0.5),
+	Real(-2.107), Real(0.476), Real(0.448),
+	Real(-1.805), Real(0.476), Real(0.384),
+	Real(-1.561), Real(0.294), Real(0.332),
+	Real(-1.467), Real(0), Real(0.312),
+	Real(-1.561), Real(-0.294), Real(0.332),
+	Real(-1.805), Real(-0.476), Real(0.384),
+	Real(-2.107), Real(-0.476), Real(0.448),
+	Real(-2.352), Real(-0.294), Real(0.5),
+	Real(-2.5), Real(0), Real(0),
+	Real(-2.405), Real(0.294), Real(0),
+	Real(-2.155), Real(0.476), Real(0),
+	Real(-1.845), Real(0.476), Real(0),
+	Real(-1.595), Real(0.294), Real(0),
+	Real(-1.5), Real(0), Real(0),
+	Real(-1.595), Real(-0.294), Real(0),
+	Real(-1.845), Real(-0.476), Real(0),
+	Real(-2.155), Real(-0.476), Real(0),
+	Real(-2.405), Real(-0.294), Real(0),
+	Real(-2.445), Real(0), Real(-0.52),
+	Real(-2.352), Real(0.294), Real(-0.5),
+	Real(-2.107), Real(0.476), Real(-0.448),
+	Real(-1.805), Real(0.476), Real(-0.384),
+	Real(-1.561), Real(0.294), Real(-0.332),
+	Real(-1.467), Real(0), Real(-0.312),
+	Real(-1.561), Real(-0.294), Real(-0.332),
+	Real(-1.805), Real(-0.476), Real(-0.384),
+	Real(-2.107), Real(-0.476), Real(-0.448),
+	Real(-2.352), Real(-0.294), Real(-0.5),
+	Real(-2.284), Real(0), Real(-1.017),
+	Real(-2.197), Real(0.294), Real(-0.978),
+	Real(-1.968), Real(0.476), Real(-0.876),
+	Real(-1.686), Real(0.476), Real(-0.751),
+	Real(-1.458), Real(0.294), Real(-0.649),
+	Real(-1.37), Real(0), Real(-0.61),
+	Real(-1.458), Real(-0.294), Real(-0.649),
+	Real(-1.686), Real(-0.476), Real(-0.751),
+	Real(-1.968), Real(-0.476), Real(-0.876),
+	Real(-2.197), Real(-0.294), Real(-0.978),
+	Real(-2.023), Real(0), Real(-1.469),
+	Real(-1.945), Real(0.294), Real(-1.413),
+	Real(-1.743), Real(0.476), Real(-1.266),
+	Real(-1.493), Real(0.476), Real(-1.085),
+	Real(-1.291), Real(0.294), Real(-0.938),
+	Real(-1.214), Real(0), Real(-0.882),
+	Real(-1.291), Real(-0.294), Real(-0.938),
+	Real(-1.493), Real(-0.476), Real(-1.085),
+	Real(-1.743), Real(-0.476), Real(-1.266),
+	Real(-1.945), Real(-0.294), Real(-1.413),
+	Real(-1.673), Real(0), Real(-1.858),
+	Real(-1.609), Real(0.294), Real(-1.787),
+	Real(-1.442), Real(0.476), Real(-1.601),
+	Real(-1.235), Real(0.476), Real(-1.371),
+	Real(-1.068), Real(0.294), Real(-1.186),
+	Real(-1.004), Real(0), Real(-1.115),
+	Real(-1.068), Real(-0.294), Real(-1.186),
+	Real(-1.235), Real(-0.476), Real(-1.371),
+	Real(-1.442), Real(-0.476), Real(-1.601),
+	Real(-1.609), Real(-0.294), Real(-1.787),
+	Real(-1.25), Real(0), Real(-2.165),
+	Real(-1.202), Real(0.294), Real(-2.082),
+	Real(-1.077), Real(0.476), Real(-1.866),
+	Real(-0.923), Real(0.476), Real(-1.598),
+	Real(-0.798), Real(0.294), Real(-1.382),
+	Real(-0.75), Real(0), Real(-1.299),
+	Real(-0.798), Real(-0.294), Real(-1.382),
+	Real(-0.923), Real(-0.476), Real(-1.598),
+	Real(-1.077), Real(-0.476), Real(-1.866),
+	Real(-1.202), Real(-0.294), Real(-2.082),
+	Real(-0.773), Real(0), Real(-2.378),
+	Real(-0.743), Real(0.294), Real(-2.287),
+	Real(-0.666), Real(0.476), Real(-2.049),
+	Real(-0.57), Real(0.476), Real(-1.755),
+	Real(-0.493), Real(0.294), Real(-1.517),
+	Real(-0.464), Real(0), Real(-1.427),
+	Real(-0.493), Real(-0.294), Real(-1.517),
+	Real(-0.57), Real(-0.476), Real(-1.755),
+	Real(-0.666), Real(-0.476), Real(-2.049),
+	Real(-0.743), Real(-0.294), Real(-2.287),
+	Real(-0.261), Real(0), Real(-2.486),
+	Real(-0.251), Real(0.294), Real(-2.391),
+	Real(-0.225), Real(0.476), Real(-2.143),
+	Real(-0.193), Real(0.476), Real(-1.835),
+	Real(-0.167), Real(0.294), Real(-1.587),
+	Real(-0.157), Real(0), Real(-1.492),
+	Real(-0.167), Real(-0.294), Real(-1.587),
+	Real(-0.193), Real(-0.476), Real(-1.835),
+	Real(-0.225), Real(-0.476), Real(-2.143),
+	Real(-0.251), Real(-0.294), Real(-2.391),
+	Real(0.261), Real(0), Real(-2.486),
+	Real(0.251), Real(0.294), Real(-2.391),
+	Real(0.225), Real(0.476), Real(-2.143),
+	Real(0.193), Real(0.476), Real(-1.835),
+	Real(0.167), Real(0.294), Real(-1.587),
+	Real(0.157), Real(0), Real(-1.492),
+	Real(0.167), Real(-0.294), Real(-1.587),
+	Real(0.193), Real(-0.476), Real(-1.835),
+	Real(0.225), Real(-0.476), Real(-2.143),
+	Real(0.251), Real(-0.294), Real(-2.391),
+	Real(0.773), Real(0), Real(-2.378),
+	Real(0.743), Real(0.294), Real(-2.287),
+	Real(0.666), Real(0.476), Real(-2.049),
+	Real(0.57), Real(0.476), Real(-1.755),
+	Real(0.493), Real(0.294), Real(-1.517),
+	Real(0.464), Real(0), Real(-1.427),
+	Real(0.493), Real(-0.294), Real(-1.517),
+	Real(0.57), Real(-0.476), Real(-1.755),
+	Real(0.666), Real(-0.476), Real(-2.049),
+	Real(0.743), Real(-0.294), Real(-2.287),
+	Real(1.25), Real(0), Real(-2.165),
+	Real(1.202), Real(0.294), Real(-2.082),
+	Real(1.077), Real(0.476), Real(-1.866),
+	Real(0.923), Real(0.476), Real(-1.598),
+	Real(0.798), Real(0.294), Real(-1.382),
+	Real(0.75), Real(0), Real(-1.299),
+	Real(0.798), Real(-0.294), Real(-1.382),
+	Real(0.923), Real(-0.476), Real(-1.598),
+	Real(1.077), Real(-0.476), Real(-1.866),
+	Real(1.202), Real(-0.294), Real(-2.082),
+	Real(1.673), Real(0), Real(-1.858),
+	Real(1.609), Real(0.294), Real(-1.787),
+	Real(1.442), Real(0.476), Real(-1.601),
+	Real(1.235), Real(0.476), Real(-1.371),
+	Real(1.068), Real(0.294), Real(-1.186),
+	Real(1.004), Real(0), Real(-1.115),
+	Real(1.068), Real(-0.294), Real(-1.186),
+	Real(1.235), Real(-0.476), Real(-1.371),
+	Real(1.442), Real(-0.476), Real(-1.601),
+	Real(1.609), Real(-0.294), Real(-1.787),
+	Real(2.023), Real(0), Real(-1.469),
+	Real(1.945), Real(0.294), Real(-1.413),
+	Real(1.743), Real(0.476), Real(-1.266),
+	Real(1.493), Real(0.476), Real(-1.085),
+	Real(1.291), Real(0.294), Real(-0.938),
+	Real(1.214), Real(0), Real(-0.882),
+	Real(1.291), Real(-0.294), Real(-0.938),
+	Real(1.493), Real(-0.476), Real(-1.085),
+	Real(1.743), Real(-0.476), Real(-1.266),
+	Real(1.945), Real(-0.294), Real(-1.413),
+	Real(2.284), Real(0), Real(-1.017),
+	Real(2.197), Real(0.294), Real(-0.978),
+	Real(1.968), Real(0.476), Real(-0.876),
+	Real(1.686), Real(0.476), Real(-0.751),
+	Real(1.458), Real(0.294), Real(-0.649),
+	Real(1.37), Real(0), Real(-0.61),
+	Real(1.458), Real(-0.294), Real(-0.649),
+	Real(1.686), Real(-0.476), Real(-0.751),
+	Real(1.968), Real(-0.476), Real(-0.876),
+	Real(2.197), Real(-0.294), Real(-0.978),
+	Real(2.445), Real(0), Real(-0.52),
+	Real(2.352), Real(0.294), Real(-0.5),
+	Real(2.107), Real(0.476), Real(-0.448),
+	Real(1.805), Real(0.476), Real(-0.384),
+	Real(1.561), Real(0.294), Real(-0.332),
+	Real(1.467), Real(0), Real(-0.312),
+	Real(1.561), Real(-0.294), Real(-0.332),
+	Real(1.805), Real(-0.476), Real(-0.384),
+	Real(2.107), Real(-0.476), Real(-0.448),
+	Real(2.352), Real(-0.294), Real(-0.5)};
+
+static int gIndices[NUM_TRIANGLES][3] = {
+	{0, 1, 11},
+	{1, 2, 12},
+	{2, 3, 13},
+	{3, 4, 14},
+	{4, 5, 15},
+	{5, 6, 16},
+	{6, 7, 17},
+	{7, 8, 18},
+	{8, 9, 19},
+	{9, 0, 10},
+	{10, 11, 21},
+	{11, 12, 22},
+	{12, 13, 23},
+	{13, 14, 24},
+	{14, 15, 25},
+	{15, 16, 26},
+	{16, 17, 27},
+	{17, 18, 28},
+	{18, 19, 29},
+	{19, 10, 20},
+	{20, 21, 31},
+	{21, 22, 32},
+	{22, 23, 33},
+	{23, 24, 34},
+	{24, 25, 35},
+	{25, 26, 36},
+	{26, 27, 37},
+	{27, 28, 38},
+	{28, 29, 39},
+	{29, 20, 30},
+	{30, 31, 41},
+	{31, 32, 42},
+	{32, 33, 43},
+	{33, 34, 44},
+	{34, 35, 45},
+	{35, 36, 46},
+	{36, 37, 47},
+	{37, 38, 48},
+	{38, 39, 49},
+	{39, 30, 40},
+	{40, 41, 51},
+	{41, 42, 52},
+	{42, 43, 53},
+	{43, 44, 54},
+	{44, 45, 55},
+	{45, 46, 56},
+	{46, 47, 57},
+	{47, 48, 58},
+	{48, 49, 59},
+	{49, 40, 50},
+	{50, 51, 61},
+	{51, 52, 62},
+	{52, 53, 63},
+	{53, 54, 64},
+	{54, 55, 65},
+	{55, 56, 66},
+	{56, 57, 67},
+	{57, 58, 68},
+	{58, 59, 69},
+	{59, 50, 60},
+	{60, 61, 71},
+	{61, 62, 72},
+	{62, 63, 73},
+	{63, 64, 74},
+	{64, 65, 75},
+	{65, 66, 76},
+	{66, 67, 77},
+	{67, 68, 78},
+	{68, 69, 79},
+	{69, 60, 70},
+	{70, 71, 81},
+	{71, 72, 82},
+	{72, 73, 83},
+	{73, 74, 84},
+	{74, 75, 85},
+	{75, 76, 86},
+	{76, 77, 87},
+	{77, 78, 88},
+	{78, 79, 89},
+	{79, 70, 80},
+	{80, 81, 91},
+	{81, 82, 92},
+	{82, 83, 93},
+	{83, 84, 94},
+	{84, 85, 95},
+	{85, 86, 96},
+	{86, 87, 97},
+	{87, 88, 98},
+	{88, 89, 99},
+	{89, 80, 90},
+	{90, 91, 101},
+	{91, 92, 102},
+	{92, 93, 103},
+	{93, 94, 104},
+	{94, 95, 105},
+	{95, 96, 106},
+	{96, 97, 107},
+	{97, 98, 108},
+	{98, 99, 109},
+	{99, 90, 100},
+	{100, 101, 111},
+	{101, 102, 112},
+	{102, 103, 113},
+	{103, 104, 114},
+	{104, 105, 115},
+	{105, 106, 116},
+	{106, 107, 117},
+	{107, 108, 118},
+	{108, 109, 119},
+	{109, 100, 110},
+	{110, 111, 121},
+	{111, 112, 122},
+	{112, 113, 123},
+	{113, 114, 124},
+	{114, 115, 125},
+	{115, 116, 126},
+	{116, 117, 127},
+	{117, 118, 128},
+	{118, 119, 129},
+	{119, 110, 120},
+	{120, 121, 131},
+	{121, 122, 132},
+	{122, 123, 133},
+	{123, 124, 134},
+	{124, 125, 135},
+	{125, 126, 136},
+	{126, 127, 137},
+	{127, 128, 138},
+	{128, 129, 139},
+	{129, 120, 130},
+	{130, 131, 141},
+	{131, 132, 142},
+	{132, 133, 143},
+	{133, 134, 144},
+	{134, 135, 145},
+	{135, 136, 146},
+	{136, 137, 147},
+	{137, 138, 148},
+	{138, 139, 149},
+	{139, 130, 140},
+	{140, 141, 151},
+	{141, 142, 152},
+	{142, 143, 153},
+	{143, 144, 154},
+	{144, 145, 155},
+	{145, 146, 156},
+	{146, 147, 157},
+	{147, 148, 158},
+	{148, 149, 159},
+	{149, 140, 150},
+	{150, 151, 161},
+	{151, 152, 162},
+	{152, 153, 163},
+	{153, 154, 164},
+	{154, 155, 165},
+	{155, 156, 166},
+	{156, 157, 167},
+	{157, 158, 168},
+	{158, 159, 169},
+	{159, 150, 160},
+	{160, 161, 171},
+	{161, 162, 172},
+	{162, 163, 173},
+	{163, 164, 174},
+	{164, 165, 175},
+	{165, 166, 176},
+	{166, 167, 177},
+	{167, 168, 178},
+	{168, 169, 179},
+	{169, 160, 170},
+	{170, 171, 181},
+	{171, 172, 182},
+	{172, 173, 183},
+	{173, 174, 184},
+	{174, 175, 185},
+	{175, 176, 186},
+	{176, 177, 187},
+	{177, 178, 188},
+	{178, 179, 189},
+	{179, 170, 180},
+	{180, 181, 191},
+	{181, 182, 192},
+	{182, 183, 193},
+	{183, 184, 194},
+	{184, 185, 195},
+	{185, 186, 196},
+	{186, 187, 197},
+	{187, 188, 198},
+	{188, 189, 199},
+	{189, 180, 190},
+	{190, 191, 201},
+	{191, 192, 202},
+	{192, 193, 203},
+	{193, 194, 204},
+	{194, 195, 205},
+	{195, 196, 206},
+	{196, 197, 207},
+	{197, 198, 208},
+	{198, 199, 209},
+	{199, 190, 200},
+	{200, 201, 211},
+	{201, 202, 212},
+	{202, 203, 213},
+	{203, 204, 214},
+	{204, 205, 215},
+	{205, 206, 216},
+	{206, 207, 217},
+	{207, 208, 218},
+	{208, 209, 219},
+	{209, 200, 210},
+	{210, 211, 221},
+	{211, 212, 222},
+	{212, 213, 223},
+	{213, 214, 224},
+	{214, 215, 225},
+	{215, 216, 226},
+	{216, 217, 227},
+	{217, 218, 228},
+	{218, 219, 229},
+	{219, 210, 220},
+	{220, 221, 231},
+	{221, 222, 232},
+	{222, 223, 233},
+	{223, 224, 234},
+	{224, 225, 235},
+	{225, 226, 236},
+	{226, 227, 237},
+	{227, 228, 238},
+	{228, 229, 239},
+	{229, 220, 230},
+	{230, 231, 241},
+	{231, 232, 242},
+	{232, 233, 243},
+	{233, 234, 244},
+	{234, 235, 245},
+	{235, 236, 246},
+	{236, 237, 247},
+	{237, 238, 248},
+	{238, 239, 249},
+	{239, 230, 240},
+	{240, 241, 251},
+	{241, 242, 252},
+	{242, 243, 253},
+	{243, 244, 254},
+	{244, 245, 255},
+	{245, 246, 256},
+	{246, 247, 257},
+	{247, 248, 258},
+	{248, 249, 259},
+	{249, 240, 250},
+	{250, 251, 261},
+	{251, 252, 262},
+	{252, 253, 263},
+	{253, 254, 264},
+	{254, 255, 265},
+	{255, 256, 266},
+	{256, 257, 267},
+	{257, 258, 268},
+	{258, 259, 269},
+	{259, 250, 260},
+	{260, 261, 271},
+	{261, 262, 272},
+	{262, 263, 273},
+	{263, 264, 274},
+	{264, 265, 275},
+	{265, 266, 276},
+	{266, 267, 277},
+	{267, 268, 278},
+	{268, 269, 279},
+	{269, 260, 270},
+	{270, 271, 281},
+	{271, 272, 282},
+	{272, 273, 283},
+	{273, 274, 284},
+	{274, 275, 285},
+	{275, 276, 286},
+	{276, 277, 287},
+	{277, 278, 288},
+	{278, 279, 289},
+	{279, 270, 280},
+	{280, 281, 291},
+	{281, 282, 292},
+	{282, 283, 293},
+	{283, 284, 294},
+	{284, 285, 295},
+	{285, 286, 296},
+	{286, 287, 297},
+	{287, 288, 298},
+	{288, 289, 299},
+	{289, 280, 290},
+	{290, 291, 1},
+	{291, 292, 2},
+	{292, 293, 3},
+	{293, 294, 4},
+	{294, 295, 5},
+	{295, 296, 6},
+	{296, 297, 7},
+	{297, 298, 8},
+	{298, 299, 9},
+	{299, 290, 0},
+	{0, 11, 10},
+	{1, 12, 11},
+	{2, 13, 12},
+	{3, 14, 13},
+	{4, 15, 14},
+	{5, 16, 15},
+	{6, 17, 16},
+	{7, 18, 17},
+	{8, 19, 18},
+	{9, 10, 19},
+	{10, 21, 20},
+	{11, 22, 21},
+	{12, 23, 22},
+	{13, 24, 23},
+	{14, 25, 24},
+	{15, 26, 25},
+	{16, 27, 26},
+	{17, 28, 27},
+	{18, 29, 28},
+	{19, 20, 29},
+	{20, 31, 30},
+	{21, 32, 31},
+	{22, 33, 32},
+	{23, 34, 33},
+	{24, 35, 34},
+	{25, 36, 35},
+	{26, 37, 36},
+	{27, 38, 37},
+	{28, 39, 38},
+	{29, 30, 39},
+	{30, 41, 40},
+	{31, 42, 41},
+	{32, 43, 42},
+	{33, 44, 43},
+	{34, 45, 44},
+	{35, 46, 45},
+	{36, 47, 46},
+	{37, 48, 47},
+	{38, 49, 48},
+	{39, 40, 49},
+	{40, 51, 50},
+	{41, 52, 51},
+	{42, 53, 52},
+	{43, 54, 53},
+	{44, 55, 54},
+	{45, 56, 55},
+	{46, 57, 56},
+	{47, 58, 57},
+	{48, 59, 58},
+	{49, 50, 59},
+	{50, 61, 60},
+	{51, 62, 61},
+	{52, 63, 62},
+	{53, 64, 63},
+	{54, 65, 64},
+	{55, 66, 65},
+	{56, 67, 66},
+	{57, 68, 67},
+	{58, 69, 68},
+	{59, 60, 69},
+	{60, 71, 70},
+	{61, 72, 71},
+	{62, 73, 72},
+	{63, 74, 73},
+	{64, 75, 74},
+	{65, 76, 75},
+	{66, 77, 76},
+	{67, 78, 77},
+	{68, 79, 78},
+	{69, 70, 79},
+	{70, 81, 80},
+	{71, 82, 81},
+	{72, 83, 82},
+	{73, 84, 83},
+	{74, 85, 84},
+	{75, 86, 85},
+	{76, 87, 86},
+	{77, 88, 87},
+	{78, 89, 88},
+	{79, 80, 89},
+	{80, 91, 90},
+	{81, 92, 91},
+	{82, 93, 92},
+	{83, 94, 93},
+	{84, 95, 94},
+	{85, 96, 95},
+	{86, 97, 96},
+	{87, 98, 97},
+	{88, 99, 98},
+	{89, 90, 99},
+	{90, 101, 100},
+	{91, 102, 101},
+	{92, 103, 102},
+	{93, 104, 103},
+	{94, 105, 104},
+	{95, 106, 105},
+	{96, 107, 106},
+	{97, 108, 107},
+	{98, 109, 108},
+	{99, 100, 109},
+	{100, 111, 110},
+	{101, 112, 111},
+	{102, 113, 112},
+	{103, 114, 113},
+	{104, 115, 114},
+	{105, 116, 115},
+	{106, 117, 116},
+	{107, 118, 117},
+	{108, 119, 118},
+	{109, 110, 119},
+	{110, 121, 120},
+	{111, 122, 121},
+	{112, 123, 122},
+	{113, 124, 123},
+	{114, 125, 124},
+	{115, 126, 125},
+	{116, 127, 126},
+	{117, 128, 127},
+	{118, 129, 128},
+	{119, 120, 129},
+	{120, 131, 130},
+	{121, 132, 131},
+	{122, 133, 132},
+	{123, 134, 133},
+	{124, 135, 134},
+	{125, 136, 135},
+	{126, 137, 136},
+	{127, 138, 137},
+	{128, 139, 138},
+	{129, 130, 139},
+	{130, 141, 140},
+	{131, 142, 141},
+	{132, 143, 142},
+	{133, 144, 143},
+	{134, 145, 144},
+	{135, 146, 145},
+	{136, 147, 146},
+	{137, 148, 147},
+	{138, 149, 148},
+	{139, 140, 149},
+	{140, 151, 150},
+	{141, 152, 151},
+	{142, 153, 152},
+	{143, 154, 153},
+	{144, 155, 154},
+	{145, 156, 155},
+	{146, 157, 156},
+	{147, 158, 157},
+	{148, 159, 158},
+	{149, 150, 159},
+	{150, 161, 160},
+	{151, 162, 161},
+	{152, 163, 162},
+	{153, 164, 163},
+	{154, 165, 164},
+	{155, 166, 165},
+	{156, 167, 166},
+	{157, 168, 167},
+	{158, 169, 168},
+	{159, 160, 169},
+	{160, 171, 170},
+	{161, 172, 171},
+	{162, 173, 172},
+	{163, 174, 173},
+	{164, 175, 174},
+	{165, 176, 175},
+	{166, 177, 176},
+	{167, 178, 177},
+	{168, 179, 178},
+	{169, 170, 179},
+	{170, 181, 180},
+	{171, 182, 181},
+	{172, 183, 182},
+	{173, 184, 183},
+	{174, 185, 184},
+	{175, 186, 185},
+	{176, 187, 186},
+	{177, 188, 187},
+	{178, 189, 188},
+	{179, 180, 189},
+	{180, 191, 190},
+	{181, 192, 191},
+	{182, 193, 192},
+	{183, 194, 193},
+	{184, 195, 194},
+	{185, 196, 195},
+	{186, 197, 196},
+	{187, 198, 197},
+	{188, 199, 198},
+	{189, 190, 199},
+	{190, 201, 200},
+	{191, 202, 201},
+	{192, 203, 202},
+	{193, 204, 203},
+	{194, 205, 204},
+	{195, 206, 205},
+	{196, 207, 206},
+	{197, 208, 207},
+	{198, 209, 208},
+	{199, 200, 209},
+	{200, 211, 210},
+	{201, 212, 211},
+	{202, 213, 212},
+	{203, 214, 213},
+	{204, 215, 214},
+	{205, 216, 215},
+	{206, 217, 216},
+	{207, 218, 217},
+	{208, 219, 218},
+	{209, 210, 219},
+	{210, 221, 220},
+	{211, 222, 221},
+	{212, 223, 222},
+	{213, 224, 223},
+	{214, 225, 224},
+	{215, 226, 225},
+	{216, 227, 226},
+	{217, 228, 227},
+	{218, 229, 228},
+	{219, 220, 229},
+	{220, 231, 230},
+	{221, 232, 231},
+	{222, 233, 232},
+	{223, 234, 233},
+	{224, 235, 234},
+	{225, 236, 235},
+	{226, 237, 236},
+	{227, 238, 237},
+	{228, 239, 238},
+	{229, 230, 239},
+	{230, 241, 240},
+	{231, 242, 241},
+	{232, 243, 242},
+	{233, 244, 243},
+	{234, 245, 244},
+	{235, 246, 245},
+	{236, 247, 246},
+	{237, 248, 247},
+	{238, 249, 248},
+	{239, 240, 249},
+	{240, 251, 250},
+	{241, 252, 251},
+	{242, 253, 252},
+	{243, 254, 253},
+	{244, 255, 254},
+	{245, 256, 255},
+	{246, 257, 256},
+	{247, 258, 257},
+	{248, 259, 258},
+	{249, 250, 259},
+	{250, 261, 260},
+	{251, 262, 261},
+	{252, 263, 262},
+	{253, 264, 263},
+	{254, 265, 264},
+	{255, 266, 265},
+	{256, 267, 266},
+	{257, 268, 267},
+	{258, 269, 268},
+	{259, 260, 269},
+	{260, 271, 270},
+	{261, 272, 271},
+	{262, 273, 272},
+	{263, 274, 273},
+	{264, 275, 274},
+	{265, 276, 275},
+	{266, 277, 276},
+	{267, 278, 277},
+	{268, 279, 278},
+	{269, 270, 279},
+	{270, 281, 280},
+	{271, 282, 281},
+	{272, 283, 282},
+	{273, 284, 283},
+	{274, 285, 284},
+	{275, 286, 285},
+	{276, 287, 286},
+	{277, 288, 287},
+	{278, 289, 288},
+	{279, 280, 289},
+	{280, 291, 290},
+	{281, 292, 291},
+	{282, 293, 292},
+	{283, 294, 293},
+	{284, 295, 294},
+	{285, 296, 295},
+	{286, 297, 296},
+	{287, 298, 297},
+	{288, 299, 298},
+	{289, 290, 299},
+	{290, 1, 0},
+	{291, 2, 1},
+	{292, 3, 2},
+	{293, 4, 3},
+	{294, 5, 4},
+	{295, 6, 5},
+	{296, 7, 6},
+	{297, 8, 7},
+	{298, 9, 8},
+	{299, 0, 9},
+};
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/BussIK/Jacobian.h b/engine/inc/bullet/ThirdPartyLibs/BussIK/Jacobian.h
new file mode 100644
index 00000000..915e56aa
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/BussIK/Jacobian.h
@@ -0,0 +1,146 @@
+
+/*
+*
+* Inverse Kinematics software, with several solvers including
+* Selectively Damped Least Squares Method
+* Damped Least Squares Method
+* Pure Pseudoinverse Method
+* Jacobian Transpose Method
+*
+*
+* Author: Samuel R. Buss, sbuss@ucsd.edu.
+* Web page: http://www.math.ucsd.edu/~sbuss/ResearchWeb/ikmethods/index.html
+*
+*
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*
+*
+*/
+
+#include "Node.h"
+#include "Tree.h"
+#include "MathMisc.h"
+#include "LinearR3.h"
+#include "VectorRn.h"
+#include "MatrixRmn.h"
+
+#ifndef _CLASS_JACOBIAN
+#define _CLASS_JACOBIAN
+
+#ifdef _DYNAMIC
+const double BASEMAXDIST = 0.02;
+#else
+const double MAXDIST = 0.08;  // optimal value for double Y shape : 0.08
+#endif
+const double DELTA = 0.4;
+const long double LAMBDA = 2.0;  // only for DLS. optimal : 0.24
+const double NEARZERO = 0.0000000001;
+
+enum UpdateMode
+{
+	JACOB_Undefined = 0,
+	JACOB_JacobianTranspose = 1,
+	JACOB_PseudoInverse = 2,
+	JACOB_DLS = 3,
+	JACOB_SDLS = 4
+};
+
+class Jacobian
+{
+public:
+	Jacobian(Tree*);
+	Jacobian(bool useAngularJacobian, int nDof, int numEndEffectors);
+
+	void ComputeJacobian(VectorR3* targets);
+	const MatrixRmn& ActiveJacobian() const { return *Jactive; }
+	void SetJendActive() { Jactive = &Jend; }  // The default setting is Jend.
+	void SetJtargetActive() { Jactive = &Jtarget; }
+	void SetJendTrans(MatrixRmn& J);
+	void SetDeltaS(VectorRn& S);
+
+	void CalcDeltaThetas(MatrixRmn& AugMat);  // Use this only if the Current Mode has been set.
+	void ZeroDeltaThetas();
+	void CalcDeltaThetasTranspose();
+	void CalcDeltaThetasPseudoinverse();
+	void CalcDeltaThetasDLS(MatrixRmn& AugMat);
+	void CalcDeltaThetasDLS2(const VectorRn& dVec, MatrixRmn& AugMat);
+	void CalcDeltaThetasDLSwithSVD();
+	void CalcDeltaThetasSDLS();
+	void CalcDeltaThetasDLSwithNullspace(const VectorRn& desiredV, MatrixRmn& AugMat);
+
+	void UpdateThetas();
+	void UpdateThetaDot();
+	double UpdateErrorArray(VectorR3* targets);  // Returns sum of errors
+	const VectorRn& GetErrorArray() const { return errorArray; }
+	void UpdatedSClampValue(VectorR3* targets);
+
+	void SetCurrentMode(UpdateMode mode) { CurrentUpdateMode = mode; }
+	UpdateMode GetCurrentMode() const { return CurrentUpdateMode; }
+	void SetDampingDLS(double lambda)
+	{
+		DampingLambda = lambda;
+		DampingLambdaSq = Square(lambda);
+	}
+
+	void Reset();
+
+	static void CompareErrors(const Jacobian& j1, const Jacobian& j2, double* weightedDist1, double* weightedDist2);
+	static void CountErrors(const Jacobian& j1, const Jacobian& j2, int* numBetter1, int* numBetter2, int* numTies);
+
+	int GetNumRows() { return nRow; }
+	int GetNumCols() { return nCol; }
+
+public:
+	Tree* m_tree;     // tree associated with this Jacobian matrix
+	int m_nEffector;  // Number of end effectors
+	int nJoint;       // Number of joints
+	int nRow;         // Total number of rows the real J (= 3*number of end effectors for now)
+	int nCol;         // Total number of columns in the real J (= number of joints for now)
+
+	MatrixRmn Jend;     // Jacobian matrix based on end effector positions
+	MatrixRmn Jtarget;  // Jacobian matrix based on target positions
+	MatrixRmn Jnorms;   // Norms of 3-vectors in active Jacobian (SDLS only)
+
+	MatrixRmn U;  // J = U * Diag(w) * V^T	(Singular Value Decomposition)
+	VectorRn w;
+	MatrixRmn V;
+
+	UpdateMode CurrentUpdateMode;
+
+	VectorRn dS;         // delta s
+	VectorRn dT1;        // delta t		--  these are delta S values clamped to smaller magnitude
+	VectorRn dSclamp;    // Value to clamp magnitude of dT at.
+	VectorRn dTheta;     // delta theta
+	VectorRn dPreTheta;  // delta theta for single eigenvalue  (SDLS only)
+
+	VectorRn errorArray;  // Distance of end effectors from target after updating
+
+	// Parameters for pseudoinverses
+	static const double PseudoInverseThresholdFactor;  // Threshold for treating eigenvalue as zero (fraction of largest eigenvalue)
+
+	// Parameters for damped least squares
+	static const double DefaultDampingLambda;
+	double DampingLambda;
+	double DampingLambdaSq;
+	//double DampingLambdaSDLS;
+
+	// Cap on max. value of changes in angles in single update step
+	static const double MaxAngleJtranspose;
+	static const double MaxAnglePseudoinverse;
+	static const double MaxAngleDLS;
+	static const double MaxAngleSDLS;
+	MatrixRmn* Jactive;
+
+	void CalcdTClampedFromdS();
+	static const double BaseMaxTargetDist;
+};
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/BussIK/LinearR2.h b/engine/inc/bullet/ThirdPartyLibs/BussIK/LinearR2.h
new file mode 100644
index 00000000..b99f998c
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/BussIK/LinearR2.h
@@ -0,0 +1,1025 @@
+/*
+*
+* Mathematics Subpackage (VrMath)
+*
+*
+* Author: Samuel R. Buss, sbuss@ucsd.edu.
+* Web page: http://math.ucsd.edu/~sbuss/MathCG
+*
+*
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*
+*
+*/
+
+//
+// Linear Algebra Classes over R2
+//
+//
+// A. Vector and Position classes
+//
+//    A.1. VectorR2: a column vector of length 2
+//
+//	  A.2. VectorHgR2 - homogenous vector for R2 (a 3-Vector)
+//
+// B. Matrix Classes
+//
+//	  B.1 LinearMapR2 - arbitrary linear map; 2x2 real matrix
+//
+//	  B.2 RotationMapR2 - orthonormal 2x2 matrix
+//
+
+#ifndef LINEAR_R2_H
+#define LINEAR_R2_H
+
+#include <math.h>
+#include <assert.h>
+#include <iostream>
+#include "MathMisc.h"
+using namespace std;
+
+class VectorR2;  // R2 Vector
+class VectorHgR2;
+class Matrix2x2;
+class LinearMapR2;    // 2x2 real matrix
+class AffineMapR3;    // Affine Map (3x4 Matrix)
+class RotationMapR2;  // 2x2 rotation map
+
+// **************************************
+// VectorR2 class                       *
+// * * * * * * * * * * * * * * * * * * **
+
+class VectorR2
+{
+public:
+	double x, y;  // The x & y  coordinates.
+
+public:
+	VectorR2() : x(0.0), y(0.0) {}
+	VectorR2(double xVal, double yVal)
+		: x(xVal), y(yVal) {}
+	VectorR2(const VectorHgR2& uH);
+
+	VectorR2& SetZero()
+	{
+		x = 0.0;
+		y = 0.0;
+		return *this;
+	}
+	VectorR2& Set(double xx, double yy)
+	{
+		x = xx;
+		y = yy;
+		return *this;
+	}
+	VectorR2& Load(const double* v);
+	VectorR2& Load(const float* v);
+	void Dump(double* v) const;
+	void Dump(float* v) const;
+
+	static const VectorR2 Zero;
+	static const VectorR2 UnitX;
+	static const VectorR2 UnitY;
+	static const VectorR2 NegUnitX;
+	static const VectorR2 NegUnitY;
+
+	VectorR2& operator+=(const VectorR2& v)
+	{
+		x += v.x;
+		y += v.y;
+		return (*this);
+	}
+	VectorR2& operator-=(const VectorR2& v)
+	{
+		x -= v.x;
+		y -= v.y;
+		return (*this);
+	}
+	VectorR2& operator*=(double m)
+	{
+		x *= m;
+		y *= m;
+		return (*this);
+	}
+	VectorR2& operator/=(double m)
+	{
+		double mInv = 1.0 / m;
+		x *= mInv;
+		y *= mInv;
+		return (*this);
+	}
+	VectorR2 operator-() const { return (VectorR2(-x, -y)); }
+	VectorR2& ArrayProd(const VectorR2&);  // Component-wise product
+
+	VectorR2& AddScaled(const VectorR2& u, double s);
+
+	double Norm() const { return (sqrt(x * x + y * y)); }
+	double L1Norm() const { return (Max(fabs(x), fabs(y))); }
+	double Dist(const VectorR2& u) const;    // Distance from u
+	double DistSq(const VectorR2& u) const;  // Distance from u
+	double NormSq() const { return (x * x + y * y); }
+	double MaxAbs() const;
+	VectorR2& Normalize()
+	{
+		*this /= Norm();
+		return *this;
+	}                      // No error checking
+	VectorR2& MakeUnit();  // Normalize() with error checking
+	VectorR2& ReNormalize();
+	bool IsUnit(double tolerance = 1.0e-15) const
+	{
+		double norm = Norm();
+		return (1.0 + tolerance >= norm && norm >= 1.0 - tolerance);
+	}
+	bool IsZero() const { return (x == 0.0 && y == 0.0); }
+	bool NearZero(double tolerance) const { return (MaxAbs() <= tolerance); }
+	// tolerance should be non-negative
+
+	VectorR2& Rotate(double theta);  // rotate through angle theta
+	VectorR2& Rotate(double costheta, double sintheta);
+};
+
+inline VectorR2 operator+(const VectorR2& u, const VectorR2& v);
+inline VectorR2 operator-(const VectorR2& u, const VectorR2& v);
+inline VectorR2 operator*(const VectorR2& u, double m);
+inline VectorR2 operator*(double m, const VectorR2& u);
+inline VectorR2 operator/(const VectorR2& u, double m);
+inline int operator==(const VectorR2& u, const VectorR2& v);
+
+inline double operator^(const VectorR2& u, const VectorR2& v);  // Dot Product
+inline VectorR2 ArrayProd(const VectorR2& u, const VectorR2& v);
+
+inline double Mag(const VectorR2& u) { return u.Norm(); }
+inline double Dist(const VectorR2& u, const VectorR2& v) { return u.Dist(v); }
+inline double DistSq(const VectorR2& u, const VectorR2& v) { return u.DistSq(v); }
+inline double NormalizeError(const VectorR2&);
+
+// ****************************************
+// VectorHgR2 class                       *
+// * * * * * * * * * * * * * * * * * * * **
+
+class VectorHgR2
+{
+public:
+	double x, y, w;  // The x & y & w coordinates.
+
+public:
+	VectorHgR2() : x(0.0), y(0.0), w(1.0) {}
+	VectorHgR2(double xVal, double yVal)
+		: x(xVal), y(yVal), w(1.0) {}
+	VectorHgR2(double xVal, double yVal, double wVal)
+		: x(xVal), y(yVal), w(wVal) {}
+	VectorHgR2(const VectorR2& u) : x(u.x), y(u.y), w(1.0) {}
+};
+
+// ********************************************************************
+// Matrix2x2     - base class for 2x2 matrices                        *
+// * * * * * * * * * * * * * * * * * * * * * **************************
+
+class Matrix2x2
+{
+public:
+	double m11, m12, m21, m22;
+
+	// Implements a 2x2 matrix: m_i_j - row-i and column-j entry
+
+	static const Matrix2x2 Identity;
+
+public:
+	inline Matrix2x2();
+	inline Matrix2x2(const VectorR2&, const VectorR2&);  // Sets by columns!
+	inline Matrix2x2(double, double, double, double);    // Sets by columns
+
+	inline void SetIdentity();  // Set to the identity map
+	inline void SetZero();      // Set to the zero map
+	inline void Set(const VectorR2&, const VectorR2&);
+	inline void Set(double, double, double, double);
+	inline void SetByRows(const VectorR2&, const VectorR2&);
+	inline void SetByRows(double, double, double, double);
+	inline void SetColumn1(double, double);
+	inline void SetColumn2(double, double);
+	inline void SetColumn1(const VectorR2&);
+	inline void SetColumn2(const VectorR2&);
+	inline VectorR2 Column1() const;
+	inline VectorR2 Column2() const;
+
+	inline void SetRow1(double, double);
+	inline void SetRow2(double, double);
+	inline void SetRow1(const VectorR2&);
+	inline void SetRow2(const VectorR2&);
+	inline VectorR2 Row1() const;
+	inline VectorR2 Row2() const;
+
+	inline void SetDiagonal(double, double);
+	inline void SetDiagonal(const VectorR2&);
+	inline double Diagonal(int);
+
+	inline void MakeTranspose();                 // Transposes it.
+	inline void operator*=(const Matrix2x2& B);  // Matrix product
+	inline Matrix2x2& ReNormalize();
+
+	inline void Transform(VectorR2*) const;
+	inline void Transform(const VectorR2& src, VectorR2* dest) const;
+};
+
+inline double NormalizeError(const Matrix2x2&);
+inline VectorR2 operator*(const Matrix2x2&, const VectorR2&);
+
+ostream& operator<<(ostream& os, const Matrix2x2& A);
+
+// *****************************************
+// LinearMapR2 class                       *
+// * * * * * * * * * * * * * * * * * * * * *
+
+class LinearMapR2 : public Matrix2x2
+{
+public:
+	LinearMapR2();
+	LinearMapR2(const VectorR2&, const VectorR2&);  // Sets by columns!
+	LinearMapR2(double, double, double, double);    // Sets by columns
+	LinearMapR2(const Matrix2x2&);
+
+	inline void Negate();
+	inline LinearMapR2& operator+=(const Matrix2x2&);
+	inline LinearMapR2& operator-=(const Matrix2x2&);
+	inline LinearMapR2& operator*=(double);
+	inline LinearMapR2& operator/=(double);
+	inline LinearMapR2& operator*=(const Matrix2x2&);  // Matrix product
+
+	inline LinearMapR2 Transpose() const;
+	inline double Determinant() const;      // Returns the determinant
+	LinearMapR2 Inverse() const;            // Returns inverse
+	LinearMapR2& Invert();                  // Converts into inverse.
+	VectorR2 Solve(const VectorR2&) const;  // Returns solution
+	LinearMapR2 PseudoInverse() const;      // Returns pseudo-inverse TO DO
+	VectorR2 PseudoSolve(const VectorR2&);  // Finds least squares solution TO DO
+};
+
+inline LinearMapR2 operator+(const LinearMapR2&, const LinearMapR2&);
+inline LinearMapR2 operator-(const Matrix2x2&);
+inline LinearMapR2 operator-(const LinearMapR2&, const LinearMapR2&);
+inline LinearMapR2 operator*(const LinearMapR2&, double);
+inline LinearMapR2 operator*(double, const LinearMapR2&);
+inline LinearMapR2 operator/(const LinearMapR2&, double);
+inline LinearMapR2 operator*(const Matrix2x2&, const LinearMapR2&);
+inline LinearMapR2 operator*(const LinearMapR2&, const Matrix2x2&);
+inline LinearMapR2 operator*(const LinearMapR2&, const LinearMapR2&);
+// Matrix product (composition)
+
+// *******************************************
+// RotationMapR2class                        *
+// * * * * * * * * * * * * * * * * * * * * * *
+
+class RotationMapR2 : public Matrix2x2
+{
+public:
+	RotationMapR2();
+	RotationMapR2(const VectorR2&, const VectorR2&);  // Sets by columns!
+	RotationMapR2(double, double, double, double);    // Sets by columns!
+
+	RotationMapR2& SetZero();  // IT IS AN ERROR TO USE THIS FUNCTION!
+
+	inline RotationMapR2& operator*=(const RotationMapR2&);  // Matrix product
+
+	inline RotationMapR2 Transpose() const;
+	inline RotationMapR2 Inverse() const { return Transpose(); };  // Returns the transpose
+	inline RotationMapR2& Invert()
+	{
+		MakeTranspose();
+		return *this;
+	};                                              // Transposes it.
+	inline VectorR2 Invert(const VectorR2&) const;  // Returns solution
+};
+
+inline RotationMapR2 operator*(const RotationMapR2&, const RotationMapR2&);
+// Matrix product (composition)
+
+// ***************************************************************
+// * 2-space vector and matrix utilities (prototypes)			 *
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+// Returns the angle between vectors u and v.
+//		Use AngleUnit if both vectors are unit vectors
+inline double Angle(const VectorR2& u, const VectorR2& v);
+inline double AngleUnit(const VectorR2& u, const VectorR2& v);
+
+// Returns a righthanded orthonormal basis to complement vector  u
+//		The vector u must be unit.
+inline VectorR2 GetOrtho(const VectorR2& u);
+
+// Projections
+
+inline VectorR2 ProjectToUnit(const VectorR2& u, const VectorR2& v);
+// Project u onto v
+inline VectorR2 ProjectPerpUnit(const VectorR2& u, const VectorR2& v);
+// Project perp to v
+// v must be a unit vector.
+
+// Projection maps (LinearMapR2's)
+
+inline LinearMapR2 VectorProjectMap(const VectorR2& u);
+
+inline LinearMapR2 PerpProjectMap(const VectorR2& u);
+// u - must be unit vector.
+
+// Rotation Maps
+
+inline RotationMapR2 RotateToMap(const VectorR2& fromVec, const VectorR2& toVec);
+// fromVec and toVec should be unit vectors
+
+// ***************************************************************
+// * Stream Output Routines	(Prototypes)						 *
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ostream& operator<<(ostream& os, const VectorR2& u);
+
+// *****************************************************
+// * VectorR2 class - inlined functions				   *
+// * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+inline VectorR2& VectorR2::Load(const double* v)
+{
+	x = *v;
+	y = *(v + 1);
+	return *this;
+}
+
+inline VectorR2& VectorR2::Load(const float* v)
+{
+	x = *v;
+	y = *(v + 1);
+	return *this;
+}
+
+inline void VectorR2::Dump(double* v) const
+{
+	*v = x;
+	*(v + 1) = y;
+}
+
+inline void VectorR2::Dump(float* v) const
+{
+	*v = (float)x;
+	*(v + 1) = (float)y;
+}
+
+inline VectorR2& VectorR2::ArrayProd(const VectorR2& v)  // Component-wise Product
+{
+	x *= v.x;
+	y *= v.y;
+	return (*this);
+}
+
+inline VectorR2& VectorR2::MakeUnit()  // Convert to unit vector (or leave zero).
+{
+	double nSq = NormSq();
+	if (nSq != 0.0)
+	{
+		*this /= sqrt(nSq);
+	}
+	return *this;
+}
+
+inline VectorR2& VectorR2::ReNormalize()  // Convert near unit back to unit
+{
+	double nSq = NormSq();
+	double mFact = 1.0 - 0.5 * (nSq - 1.0);  // Multiplicative factor
+	*this *= mFact;
+	return *this;
+}
+
+// Rotate through angle theta
+inline VectorR2& VectorR2::Rotate(double theta)
+{
+	double costheta = cos(theta);
+	double sintheta = sin(theta);
+	double tempx = x * costheta - y * sintheta;
+	y = y * costheta + x * sintheta;
+	x = tempx;
+	return *this;
+}
+
+inline VectorR2& VectorR2::Rotate(double costheta, double sintheta)
+{
+	double tempx = x * costheta + y * sintheta;
+	y = y * costheta - x * sintheta;
+	x = tempx;
+	return *this;
+}
+
+inline double VectorR2::MaxAbs() const
+{
+	double m;
+	m = (x >= 0.0) ? x : -x;
+	if (y > m)
+		m = y;
+	else if (-y > m)
+		m = -y;
+	return m;
+}
+
+inline VectorR2 operator+(const VectorR2& u, const VectorR2& v)
+{
+	return VectorR2(u.x + v.x, u.y + v.y);
+}
+inline VectorR2 operator-(const VectorR2& u, const VectorR2& v)
+{
+	return VectorR2(u.x - v.x, u.y - v.y);
+}
+inline VectorR2 operator*(const VectorR2& u, double m)
+{
+	return VectorR2(u.x * m, u.y * m);
+}
+inline VectorR2 operator*(double m, const VectorR2& u)
+{
+	return VectorR2(u.x * m, u.y * m);
+}
+inline VectorR2 operator/(const VectorR2& u, double m)
+{
+	double mInv = 1.0 / m;
+	return VectorR2(u.x * mInv, u.y * mInv);
+}
+
+inline int operator==(const VectorR2& u, const VectorR2& v)
+{
+	return (u.x == v.x && u.y == v.y);
+}
+
+inline double operator^(const VectorR2& u, const VectorR2& v)  // Dot Product
+{
+	return (u.x * v.x + u.y * v.y);
+}
+
+inline VectorR2 ArrayProd(const VectorR2& u, const VectorR2& v)
+{
+	return (VectorR2(u.x * v.x, u.y * v.y));
+}
+
+inline VectorR2& VectorR2::AddScaled(const VectorR2& u, double s)
+{
+	x += s * u.x;
+	y += s * u.y;
+	return (*this);
+}
+
+inline VectorR2::VectorR2(const VectorHgR2& uH)
+	: x(uH.x), y(uH.y)
+{
+	*this /= uH.w;
+}
+
+inline double NormalizeError(const VectorR2& u)
+{
+	double discrepancy;
+	discrepancy = u.x * u.x + u.y * u.y - 1.0;
+	if (discrepancy < 0.0)
+	{
+		discrepancy = -discrepancy;
+	}
+	return discrepancy;
+}
+
+inline double VectorR2::Dist(const VectorR2& u) const  // Distance from u
+{
+	return sqrt(DistSq(u));
+}
+
+inline double VectorR2::DistSq(const VectorR2& u) const  // Distance from u
+{
+	return ((x - u.x) * (x - u.x) + (y - u.y) * (y - u.y));
+}
+
+// *********************************************************
+// * Matrix2x2 class - inlined functions				   *
+// * * * * * * * * * * * * * * * * * * * * * * * * * * *****
+
+inline Matrix2x2::Matrix2x2() {}
+
+inline Matrix2x2::Matrix2x2(const VectorR2& u, const VectorR2& v)
+{
+	m11 = u.x;  // Column 1
+	m21 = u.y;
+	m12 = v.x;  // Column 2
+	m22 = v.y;
+}
+
+inline Matrix2x2::Matrix2x2(double a11, double a21, double a12, double a22)
+// Values specified in column order!!!
+{
+	m11 = a11;  // Row 1
+	m12 = a12;
+	m21 = a21;  // Row 2
+	m22 = a22;
+}
+
+inline void Matrix2x2::SetIdentity()
+{
+	m11 = m22 = 1.0;
+	m12 = m21 = 0.0;
+}
+
+inline void Matrix2x2::Set(const VectorR2& u, const VectorR2& v)
+{
+	m11 = u.x;  // Column 1
+	m21 = u.y;
+	m12 = v.x;  // Column 2
+	m22 = v.y;
+}
+
+inline void Matrix2x2::Set(double a11, double a21, double a12, double a22)
+// Values specified in column order!!!
+{
+	m11 = a11;  // Row 1
+	m12 = a12;
+	m21 = a21;  // Row 2
+	m22 = a22;
+}
+
+inline void Matrix2x2::SetZero()
+{
+	m11 = m12 = m21 = m22 = 0.0;
+}
+
+inline void Matrix2x2::SetByRows(const VectorR2& u, const VectorR2& v)
+{
+	m11 = u.x;  // Row 1
+	m12 = u.y;
+	m21 = v.x;  // Row 2
+	m22 = v.y;
+}
+
+inline void Matrix2x2::SetByRows(double a11, double a12, double a21, double a22)
+// Values specified in row order!!!
+{
+	m11 = a11;  // Row 1
+	m12 = a12;
+	m21 = a21;  // Row 2
+	m22 = a22;
+}
+
+inline void Matrix2x2::SetColumn1(double x, double y)
+{
+	m11 = x;
+	m21 = y;
+}
+
+inline void Matrix2x2::SetColumn2(double x, double y)
+{
+	m12 = x;
+	m22 = y;
+}
+
+inline void Matrix2x2::SetColumn1(const VectorR2& u)
+{
+	m11 = u.x;
+	m21 = u.y;
+}
+
+inline void Matrix2x2::SetColumn2(const VectorR2& u)
+{
+	m12 = u.x;
+	m22 = u.y;
+}
+
+VectorR2 Matrix2x2::Column1() const
+{
+	return (VectorR2(m11, m21));
+}
+
+VectorR2 Matrix2x2::Column2() const
+{
+	return (VectorR2(m12, m22));
+}
+
+inline void Matrix2x2::SetRow1(double x, double y)
+{
+	m11 = x;
+	m12 = y;
+}
+
+inline void Matrix2x2::SetRow2(double x, double y)
+{
+	m21 = x;
+	m22 = y;
+}
+
+inline void Matrix2x2::SetRow1(const VectorR2& u)
+{
+	m11 = u.x;
+	m12 = u.y;
+}
+
+inline void Matrix2x2::SetRow2(const VectorR2& u)
+{
+	m21 = u.x;
+	m22 = u.y;
+}
+
+VectorR2 Matrix2x2::Row1() const
+{
+	return (VectorR2(m11, m12));
+}
+
+VectorR2 Matrix2x2::Row2() const
+{
+	return (VectorR2(m21, m22));
+}
+
+inline void Matrix2x2::SetDiagonal(double x, double y)
+{
+	m11 = x;
+	m22 = y;
+}
+
+inline void Matrix2x2::SetDiagonal(const VectorR2& u)
+{
+	SetDiagonal(u.x, u.y);
+}
+
+inline double Matrix2x2::Diagonal(int i)
+{
+	switch (i)
+	{
+		case 0:
+			return m11;
+		case 1:
+			return m22;
+		default:
+			assert(0);
+			return 0.0;
+	}
+}
+inline void Matrix2x2::MakeTranspose()  // Transposes it.
+{
+	double temp;
+	temp = m12;
+	m12 = m21;
+	m21 = temp;
+}
+
+inline void Matrix2x2::operator*=(const Matrix2x2& B)  // Matrix product
+{
+	double t1;  // temporary value
+
+	t1 = m11 * B.m11 + m12 * B.m21;
+	m12 = m11 * B.m12 + m12 * B.m22;
+	m11 = t1;
+
+	t1 = m21 * B.m11 + m22 * B.m21;
+	m22 = m21 * B.m12 + m22 * B.m22;
+	m21 = t1;
+}
+
+inline Matrix2x2& Matrix2x2::ReNormalize()  // Re-normalizes nearly orthonormal matrix
+{
+	double alpha = m11 * m11 + m21 * m21;  // First column's norm squared
+	double beta = m12 * m12 + m22 * m22;   // Second column's norm squared
+	alpha = 1.0 - 0.5 * (alpha - 1.0);     // Get mult. factor
+	beta = 1.0 - 0.5 * (beta - 1.0);
+	m11 *= alpha;  // Renormalize first column
+	m21 *= alpha;
+	m12 *= beta;  // Renormalize second column
+	m22 *= beta;
+	alpha = m11 * m12 + m21 * m22;  // Columns' inner product
+	alpha *= 0.5;                   //    times 1/2
+	double temp;
+	temp = m11 - alpha * m12;  // Subtract alpha times other column
+	m12 -= alpha * m11;
+	m11 = temp;
+	temp = m21 - alpha * m22;
+	m22 -= alpha * m21;
+	m11 = temp;
+	return *this;
+}
+
+// Gives a measure of how far the matrix is from being normalized.
+//		Mostly intended for diagnostic purposes.
+inline double NormalizeError(const Matrix2x2& A)
+{
+	double discrepancy;
+	double newdisc;
+	discrepancy = A.m11 * A.m11 + A.m21 * A.m21 - 1.0;  // First column - inner product - 1
+	if (discrepancy < 0.0)
+	{
+		discrepancy = -discrepancy;
+	}
+	newdisc = A.m12 * A.m12 + A.m22 * A.m22 - 1.0;  // Second column inner product - 1
+	if (newdisc < 0.0)
+	{
+		newdisc = -newdisc;
+	}
+	if (newdisc > discrepancy)
+	{
+		discrepancy = newdisc;
+	}
+	newdisc = A.m11 * A.m12 + A.m21 * A.m22;  // Inner product of two columns
+	if (newdisc < 0.0)
+	{
+		newdisc = -newdisc;
+	}
+	if (newdisc > discrepancy)
+	{
+		discrepancy = newdisc;
+	}
+	return discrepancy;
+}
+
+inline VectorR2 operator*(const Matrix2x2& A, const VectorR2& u)
+{
+	return (VectorR2(A.m11 * u.x + A.m12 * u.y,
+					 A.m21 * u.x + A.m22 * u.y));
+}
+
+inline void Matrix2x2::Transform(VectorR2* u) const
+{
+	double newX;
+	newX = m11 * u->x + m12 * u->y;
+	u->y = m21 * u->x + m22 * u->y;
+	u->x = newX;
+}
+
+inline void Matrix2x2::Transform(const VectorR2& src, VectorR2* dest) const
+{
+	dest->x = m11 * src.x + m12 * src.y;
+	dest->y = m21 * src.x + m22 * src.y;
+}
+
+// ******************************************************
+// * LinearMapR2 class - inlined functions				*
+// * * * * * * * * * * * * * * * * * * * * * * * * * * **
+
+inline LinearMapR2::LinearMapR2()
+{
+	SetZero();
+	return;
+}
+
+inline LinearMapR2::LinearMapR2(const VectorR2& u, const VectorR2& v)
+	: Matrix2x2(u, v)
+{
+}
+
+inline LinearMapR2::LinearMapR2(double a11, double a21, double a12, double a22)
+	// Values specified in column order!!!
+	: Matrix2x2(a11, a21, a12, a22)
+{
+}
+
+inline LinearMapR2::LinearMapR2(const Matrix2x2& A)
+	: Matrix2x2(A)
+{
+}
+
+inline void LinearMapR2::Negate()
+{
+	m11 = -m11;
+	m12 = -m12;
+	m21 = -m21;
+	m22 = -m22;
+}
+
+inline LinearMapR2& LinearMapR2::operator+=(const Matrix2x2& B)
+{
+	m11 += B.m11;
+	m12 += B.m12;
+	m21 += B.m21;
+	m22 += B.m22;
+	return (*this);
+}
+
+inline LinearMapR2& LinearMapR2::operator-=(const Matrix2x2& B)
+{
+	m11 -= B.m11;
+	m12 -= B.m12;
+	m21 -= B.m21;
+	m22 -= B.m22;
+	return (*this);
+}
+
+inline LinearMapR2 operator+(const LinearMapR2& A, const LinearMapR2& B)
+{
+	return (LinearMapR2(A.m11 + B.m11, A.m21 + B.m21,
+						A.m12 + B.m12, A.m22 + B.m22));
+}
+
+inline LinearMapR2 operator-(const Matrix2x2& A)
+{
+	return (LinearMapR2(-A.m11, -A.m21, -A.m12, -A.m22));
+}
+
+inline LinearMapR2 operator-(const LinearMapR2& A, const LinearMapR2& B)
+{
+	return (LinearMapR2(A.m11 - B.m11, A.m21 - B.m21,
+						A.m12 - B.m12, A.m22 - B.m22));
+}
+
+inline LinearMapR2& LinearMapR2::operator*=(double b)
+{
+	m11 *= b;
+	m12 *= b;
+	m21 *= b;
+	m22 *= b;
+	return (*this);
+}
+
+inline LinearMapR2 operator*(const LinearMapR2& A, double b)
+{
+	return (LinearMapR2(A.m11 * b, A.m21 * b,
+						A.m12 * b, A.m22 * b));
+}
+
+inline LinearMapR2 operator*(double b, const LinearMapR2& A)
+{
+	return (LinearMapR2(A.m11 * b, A.m21 * b,
+						A.m12 * b, A.m22 * b));
+}
+
+inline LinearMapR2 operator/(const LinearMapR2& A, double b)
+{
+	double bInv = 1.0 / b;
+	return (A * bInv);
+}
+
+inline LinearMapR2& LinearMapR2::operator/=(double b)
+{
+	double bInv = 1.0 / b;
+	return (*this *= bInv);
+}
+
+inline LinearMapR2 LinearMapR2::Transpose() const  // Returns the transpose
+{
+	return (LinearMapR2(m11, m12, m21, m22));
+}
+
+inline LinearMapR2& LinearMapR2::operator*=(const Matrix2x2& B)  // Matrix product
+{
+	(*this).Matrix2x2::operator*=(B);
+
+	return (*this);
+}
+
+inline LinearMapR2 operator*(const LinearMapR2& A, const Matrix2x2& B)
+{
+	LinearMapR2 AA(A);
+	AA.Matrix2x2::operator*=(B);
+	return AA;
+}
+
+inline LinearMapR2 operator*(const Matrix2x2& A, const LinearMapR2& B)
+{
+	LinearMapR2 AA(A);
+	AA.Matrix2x2::operator*=(B);
+	return AA;
+}
+
+inline LinearMapR2 operator*(const LinearMapR2& A, const LinearMapR2& B)
+{
+	LinearMapR2 AA(A);
+	AA.Matrix2x2::operator*=(B);
+	return AA;
+}
+
+inline double LinearMapR2::Determinant() const  // Returns the determinant
+{
+	return (m11 * m22 - m12 * m21);
+}
+
+// ******************************************************
+// * RotationMapR2 class - inlined functions			*
+// * * * * * * * * * * * * * * * * * * * * * * * * * * **
+
+inline RotationMapR2::RotationMapR2()
+{
+	SetIdentity();
+	return;
+}
+
+inline RotationMapR2::RotationMapR2(const VectorR2& u, const VectorR2& v)
+	: Matrix2x2(u, v)
+{
+}
+
+inline RotationMapR2::RotationMapR2(
+	double a11, double a21, double a12, double a22)
+	// Values specified in column order!!!
+	: Matrix2x2(a11, a21, a12, a22)
+{
+}
+
+inline RotationMapR2 RotationMapR2::Transpose() const  // Returns the transpose
+{
+	return (RotationMapR2(m11, m12,
+						  m21, m22));
+}
+
+inline VectorR2 RotationMapR2::Invert(const VectorR2& u) const  // Returns solution
+{
+	return (VectorR2(m11 * u.x + m21 * u.y,  // Multiply with Transpose
+					 m12 * u.x + m22 * u.y));
+}
+
+inline RotationMapR2& RotationMapR2::operator*=(const RotationMapR2& B)  // Matrix product
+{
+	(*this).Matrix2x2::operator*=(B);
+
+	return (*this);
+}
+
+inline RotationMapR2 operator*(const RotationMapR2& A, const RotationMapR2& B)
+{
+	RotationMapR2 AA(A);
+	AA.Matrix2x2::operator*=(B);
+	return AA;
+}
+
+// ***************************************************************
+// * 2-space vector and matrix utilities (inlined functions)	 *
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+// Returns a righthanded orthonormal basis to complement vector  u
+//		The vector u must be unit.
+inline VectorR2 GetOrtho(const VectorR2& u)
+{
+	return VectorR2(-u.y, u.x);
+}
+
+// Returns the projection of u onto unit v
+inline VectorR2 ProjectToUnit(const VectorR2& u, const VectorR2& v)
+{
+	return (u ^ v) * v;
+}
+
+// Returns the projection of u onto the plane perpindicular to the unit vector v
+inline VectorR2 ProjectPerpUnit(const VectorR2& u, const VectorR2& v)
+{
+	return (u - ((u ^ v) * v));
+}
+
+// Returns the projection of u onto the plane perpindicular to the unit vector v
+//    This one is more stable when u and v are nearly equal.
+inline VectorR2 ProjectPerpUnitDiff(const VectorR2& u, const VectorR2& v)
+{
+	VectorR2 ans = u;
+	ans -= v;
+	ans -= ((ans ^ v) * v);
+	return ans;  // ans = (u-v) - ((u-v)^v)*v
+}
+
+// Returns the solid angle between vectors u and v.
+inline double Angle(const VectorR2& u, const VectorR2& v)
+{
+	double nSqU = u.NormSq();
+	double nSqV = v.NormSq();
+	if (nSqU == 0.0 && nSqV == 0.0)
+	{
+		return (0.0);
+	}
+	else
+	{
+		return (AngleUnit(u / sqrt(nSqU), v / sqrt(nSqV)));
+	}
+}
+
+inline double AngleUnit(const VectorR2& u, const VectorR2& v)
+{
+	return (atan2((ProjectPerpUnit(v, u)).Norm(), u ^ v));
+}
+
+// Projection maps (LinearMapR2's)
+
+// VectorProjectMap returns map projecting onto a given vector u.
+//		u should be a unit vector (otherwise the returned map is
+//		scaled according to the magnitude of u.
+inline LinearMapR2 VectorProjectMap(const VectorR2& u)
+{
+	double xy = u.x * u.y;
+	return (LinearMapR2(u.x * u.x, xy, xy, u.y * u.y));
+}
+
+// PlaneProjectMap returns map projecting onto a given plane.
+//		The plane is the plane orthognal to u.
+//		u must be a unit vector (otherwise the returned map is
+//		garbage).
+inline LinearMapR2 PerpProjectMap(const VectorR2& u)
+{
+	double nxy = -u.x * u.y;
+	return (LinearMapR2(1.0 - u.x * u.x, nxy, nxy, 1.0 - u.y * u.y));
+}
+
+// fromVec and toVec should be unit vectors
+inline RotationMapR2 RotateToMap(const VectorR2& fromVec, const VectorR2& toVec)
+{
+	double costheta = fromVec.x * toVec.x + fromVec.y * toVec.y;
+	double sintheta = fromVec.x * toVec.y - fromVec.y * toVec.x;
+	return (RotationMapR2(costheta, sintheta, -sintheta, costheta));
+}
+
+#endif  // LINEAR_R2_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/BussIK/LinearR3.h b/engine/inc/bullet/ThirdPartyLibs/BussIK/LinearR3.h
new file mode 100644
index 00000000..a989be77
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/BussIK/LinearR3.h
@@ -0,0 +1,2127 @@
+/*
+*
+* Mathematics Subpackage (VrMath)
+*
+*
+* Author: Samuel R. Buss, sbuss@ucsd.edu.
+* Web page: http://math.ucsd.edu/~sbuss/MathCG
+*
+*
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*
+*
+*/
+
+//
+// Linear Algebra Classes over R3
+//
+//
+// A. Vector and Position classes
+//
+//    A.1. VectorR3: a real column vector of length 3.
+//
+//	  A.2. VectorHgR3: a column vector of length 4 which is
+//			the homogenous representation of a vector in 3-space
+//
+// B. Matrix Classes
+//
+//	  B.1 LinearMapR3 - arbitrary linear map; 3x3 real matrix
+//
+//	  B.2 AffineMapR3 - arbitrary affine map; a 3x4 real matrix
+//
+//	  B.3 RotationMapR3 - orthonormal 3x3 matrix
+//
+//	  B.4 RigidMapR3 - RotationMapR3 plus displacement
+//
+
+#ifndef LINEAR_R3_H
+#define LINEAR_R3_H
+
+#include <math.h>
+#include <assert.h>
+#include <iostream>
+#include "MathMisc.h"
+using namespace std;
+
+class VectorR3;    // Space Vector (length 3)
+class VectorHgR3;  // Homogenous Space Vector
+class VectorR4;    // Space Vector (length 4)
+
+class LinearMapR3;    // Linear Map (3x3 Matrix)
+class AffineMapR3;    // Affine Map (3x4 Matrix)
+class RotationMapR3;  // Rotation (3x3 orthonormal matrix)
+class RigidMapR3;     // 3x4 matrix, first 3 columns orthonormal
+
+// Most for internal use:
+class Matrix3x3;
+class Matrix3x4;
+
+class Quaternion;
+
+// **************************************
+// VectorR3 class                       *
+// * * * * * * * * * * * * * * * * * * **
+
+class VectorR3
+{
+public:
+	double x, y, z;  // The x & y & z coordinates.
+
+	static const VectorR3 Zero;
+	static const VectorR3 UnitX;
+	static const VectorR3 UnitY;
+	static const VectorR3 UnitZ;
+	static const VectorR3 NegUnitX;
+	static const VectorR3 NegUnitY;
+	static const VectorR3 NegUnitZ;
+
+public:
+	VectorR3() : x(0.0), y(0.0), z(0.0) {}
+	VectorR3(double xVal, double yVal, double zVal)
+		: x(xVal), y(yVal), z(zVal) {}
+	VectorR3(const VectorHgR3& uH);
+
+	VectorR3& Set(const Quaternion&);  // Convert quat to rotation vector
+	VectorR3& Set(double xx, double yy, double zz)
+	{
+		x = xx;
+		y = yy;
+		z = zz;
+		return *this;
+	}
+	VectorR3& SetFromHg(const VectorR4&);  // Convert homogeneous VectorR4 to VectorR3
+	VectorR3& SetZero()
+	{
+		x = 0.0;
+		y = 0.0;
+		z = 0.0;
+		return *this;
+	}
+	VectorR3& Load(const double* v);
+	VectorR3& Load(const float* v);
+	void Dump(double* v) const;
+	void Dump(float* v) const;
+
+	inline double operator[](int i);
+
+	VectorR3& operator=(const VectorR3& v)
+	{
+		x = v.x;
+		y = v.y;
+		z = v.z;
+		return (*this);
+	}
+	VectorR3& operator+=(const VectorR3& v)
+	{
+		x += v.x;
+		y += v.y;
+		z += v.z;
+		return (*this);
+	}
+	VectorR3& operator-=(const VectorR3& v)
+	{
+		x -= v.x;
+		y -= v.y;
+		z -= v.z;
+		return (*this);
+	}
+	VectorR3& operator*=(double m)
+	{
+		x *= m;
+		y *= m;
+		z *= m;
+		return (*this);
+	}
+	VectorR3& operator/=(double m)
+	{
+		double mInv = 1.0 / m;
+		x *= mInv;
+		y *= mInv;
+		z *= mInv;
+		return (*this);
+	}
+	VectorR3 operator-() const { return (VectorR3(-x, -y, -z)); }
+	VectorR3& operator*=(const VectorR3& v);  // Cross Product
+	VectorR3& ArrayProd(const VectorR3&);     // Component-wise product
+
+	VectorR3& AddScaled(const VectorR3& u, double s);
+
+	bool IsZero() const { return (x == 0.0 && y == 0.0 && z == 0.0); }
+	double Norm() const { return ((double)sqrt(x * x + y * y + z * z)); }
+	double NormSq() const { return (x * x + y * y + z * z); }
+	double MaxAbs() const;
+	double Dist(const VectorR3& u) const;    // Distance from u
+	double DistSq(const VectorR3& u) const;  // Distance from u squared
+	VectorR3& Negate()
+	{
+		x = -x;
+		y = -y;
+		z = -z;
+		return *this;
+	}
+	VectorR3& Normalize()
+	{
+		*this /= Norm();
+		return *this;
+	}                             // No error checking
+	inline VectorR3& MakeUnit();  // Normalize() with error checking
+	inline VectorR3& ReNormalize();
+	bool IsUnit() const
+	{
+		double norm = Norm();
+		return (1.000001 >= norm && norm >= 0.999999);
+	}
+	bool IsUnit(double tolerance) const
+	{
+		double norm = Norm();
+		return (1.0 + tolerance >= norm && norm >= 1.0 - tolerance);
+	}
+	bool NearZero(double tolerance) const { return (MaxAbs() <= tolerance); }
+	// tolerance should be non-negative
+
+	double YaxisDistSq() const { return (x * x + z * z); }
+	double YaxisDist() const { return sqrt(x * x + z * z); }
+
+	VectorR3& Rotate(double theta, const VectorR3& u);     // rotate around u.
+	VectorR3& RotateUnitInDirection(const VectorR3& dir);  // rotate in direction dir
+	VectorR3& Rotate(const Quaternion&);                   // Rotate according to quaternion
+
+	friend ostream& operator<<(ostream& os, const VectorR3& u);
+};
+
+inline VectorR3 operator+(const VectorR3& u, const VectorR3& v);
+inline VectorR3 operator-(const VectorR3& u, const VectorR3& v);
+inline VectorR3 operator*(const VectorR3& u, double m);
+inline VectorR3 operator*(double m, const VectorR3& u);
+inline VectorR3 operator/(const VectorR3& u, double m);
+inline int operator==(const VectorR3& u, const VectorR3& v);
+
+inline double operator^(const VectorR3& u, const VectorR3& v);    // Dot Product
+inline VectorR3 operator*(const VectorR3& u, const VectorR3& v);  // Cross Product
+inline VectorR3 ArrayProd(const VectorR3& u, const VectorR3& v);
+
+inline double Mag(const VectorR3& u) { return u.Norm(); }
+inline double Dist(const VectorR3& u, const VectorR3& v) { return u.Dist(v); }
+inline double DistSq(const VectorR3& u, const VectorR3& v) { return u.DistSq(v); }
+inline double NormalizeError(const VectorR3& u);
+
+extern const VectorR3 UnitVecIR3;
+extern const VectorR3 UnitVecJR3;
+extern const VectorR3 UnitVecKR3;
+
+inline VectorR3 ToVectorR3(const Quaternion& q)
+{
+	return VectorR3().Set(q);
+}
+
+// ****************************************
+// VectorHgR3 class                       *
+// * * * * * * * * * * * * * * * * * * * **
+
+class VectorHgR3
+{
+public:
+	double x, y, z, w;  // The x & y & z & w coordinates.
+
+public:
+	VectorHgR3() : x(0.0), y(0.0), z(0.0), w(1.0) {}
+	VectorHgR3(double xVal, double yVal, double zVal)
+		: x(xVal), y(yVal), z(zVal), w(1.0) {}
+	VectorHgR3(double xVal, double yVal, double zVal, double wVal)
+		: x(xVal), y(yVal), z(zVal), w(wVal) {}
+	VectorHgR3(const VectorR3& u) : x(u.x), y(u.y), z(u.z), w(1.0) {}
+};
+
+//
+// Advanced vector and position functions (prototypes)
+//
+
+VectorR3 Interpolate(const VectorR3& start, const VectorR3& end, double a);
+
+// *****************************************
+// Matrix3x3 class                         *
+// * * * * * * * * * * * * * * * * * * * * *
+
+class Matrix3x3
+{
+public:
+	double m11, m12, m13, m21, m22, m23, m31, m32, m33;
+
+	// Implements a 3x3 matrix: m_i_j - row-i and column-j entry
+
+	static const Matrix3x3 Identity;
+
+public:
+	inline Matrix3x3();
+	inline Matrix3x3(const VectorR3&, const VectorR3&, const VectorR3&);  // Sets by columns!
+	inline Matrix3x3(double, double, double, double, double, double,
+					 double, double, double);  // Sets by columns
+
+	inline void SetIdentity();             // Set to the identity map
+	inline void Set(const Matrix3x3&);     // Set to the matrix.
+	inline void Set3x3(const Matrix3x4&);  // Set to the 3x3 part of the matrix.
+	inline void Set(const VectorR3&, const VectorR3&, const VectorR3&);
+	inline void Set(double, double, double,
+					double, double, double,
+					double, double, double);
+	inline void SetByRows(double, double, double, double, double, double,
+						  double, double, double);
+	inline void SetByRows(const VectorR3&, const VectorR3&, const VectorR3&);
+
+	inline void SetColumn1(double, double, double);
+	inline void SetColumn2(double, double, double);
+	inline void SetColumn3(double, double, double);
+	inline void SetColumn1(const VectorR3&);
+	inline void SetColumn2(const VectorR3&);
+	inline void SetColumn3(const VectorR3&);
+	inline VectorR3 Column1() const;
+	inline VectorR3 Column2() const;
+	inline VectorR3 Column3() const;
+
+	inline void SetRow1(double, double, double);
+	inline void SetRow2(double, double, double);
+	inline void SetRow3(double, double, double);
+	inline void SetRow1(const VectorR3&);
+	inline void SetRow2(const VectorR3&);
+	inline void SetRow3(const VectorR3&);
+	inline VectorR3 Row1() const;
+	inline VectorR3 Row2() const;
+	inline VectorR3 Row3() const;
+
+	inline void SetDiagonal(double, double, double);
+	inline void SetDiagonal(const VectorR3&);
+	inline double Diagonal(int);
+
+	inline void MakeTranspose();  // Transposes it.
+	Matrix3x3& ReNormalize();
+	VectorR3 Solve(const VectorR3&) const;  // Returns solution
+
+	inline void Transform(VectorR3*) const;
+	inline void Transform(const VectorR3& src, VectorR3* dest) const;
+
+protected:
+	void OperatorTimesEquals(const Matrix3x3&);  // Internal use only
+	void SetZero();                              // Set to the zero map
+};
+
+inline VectorR3 operator*(const Matrix3x3&, const VectorR3&);
+
+ostream& operator<<(ostream& os, const Matrix3x3& A);
+
+// *****************************************
+// Matrix3x4 class                         *
+// * * * * * * * * * * * * * * * * * * * * *
+
+class Matrix3x4
+{
+public:
+	double m11, m12, m13, m21, m22, m23, m31, m32, m33;
+	double m14;
+	double m24;
+	double m34;
+
+	static const Matrix3x4 Identity;
+
+public:
+	// Constructors set by columns!
+	Matrix3x4() {}
+	Matrix3x4(const VectorR3&, const VectorR3&, const VectorR3&, const VectorR3&);
+	Matrix3x4(double, double, double, double, double, double,
+			  double, double, double, double, double, double);  // Sets by columns
+	Matrix3x4(const Matrix3x3&, const VectorR3&);
+
+	void SetIdentity();                           // Set to the identity map
+	void Set(const Matrix3x4&);                   // Set to the matrix.
+	void Set3x3(const Matrix3x3&);                // Set linear part to the matrix.
+	void Set(const Matrix3x3&, const VectorR3&);  // Set to the matrix plus 4th column
+	void Set(const VectorR3&, const VectorR3&, const VectorR3&, const VectorR3&);
+	void Set(double, double, double,
+			 double, double, double,
+			 double, double, double,
+			 double, double, double);  // Sets by columns
+	void Set3x3(double, double, double,
+				double, double, double,
+				double, double, double);  // Sets by columns
+	void SetByRows(double, double, double, double, double, double,
+				   double, double, double, double, double, double);
+
+	void SetColumn1(double, double, double);
+	void SetColumn2(double, double, double);
+	void SetColumn3(double, double, double);
+	void SetColumn4(double, double, double);
+	void SetColumn1(const VectorR3&);
+	void SetColumn2(const VectorR3&);
+	void SetColumn3(const VectorR3&);
+	void SetColumn4(const VectorR3&);
+	VectorR3 Column1() const;
+	VectorR3 Column2() const;
+	VectorR3 Column3() const;
+	VectorR3 Column4() const;
+	void SetRow1(double x, double y, double z, double w);
+	void SetRow2(double x, double y, double z, double w);
+	void SetRow3(double x, double y, double z, double w);
+	void SetRow4(double x, double y, double z, double w);
+
+	Matrix3x4& ApplyTranslationLeft(const VectorR3& u);
+	Matrix3x4& ApplyTranslationRight(const VectorR3& u);
+	Matrix3x4& ApplyYRotationLeft(double theta);
+	Matrix3x4& ApplyYRotationLeft(double costheta, double sintheta);
+
+	Matrix3x4& ReNormalize();
+	VectorR3 Solve(const VectorR3&) const;  // Returns solution
+
+	inline void Transform(VectorR3*) const;
+	inline void Transform3x3(VectorR3*) const;
+	inline void Transform(const VectorR3& src, VectorR3* dest) const;
+	inline void Transform3x3(const VectorR3& src, VectorR3* dest) const;
+	inline void Transform3x3Transpose(VectorR3* dest) const;
+	inline void Transform3x3Transpose(const VectorR3& src, VectorR3* dest) const;
+
+protected:
+	void SetZero();                              // Set to the zero map
+	void OperatorTimesEquals(const Matrix3x3&);  // Internal use only
+	void OperatorTimesEquals(const Matrix3x4&);  // Internal use only
+};
+
+inline VectorR3 operator*(const Matrix3x4&, const VectorR3&);
+
+ostream& operator<<(ostream& os, const Matrix3x4& A);
+
+// *****************************************
+// LinearMapR3 class                       *
+// * * * * * * * * * * * * * * * * * * * * *
+
+class LinearMapR3 : public Matrix3x3
+{
+public:
+	LinearMapR3();
+	LinearMapR3(const VectorR3&, const VectorR3&, const VectorR3&);
+	LinearMapR3(double, double, double, double, double, double,
+				double, double, double);  // Sets by columns
+	LinearMapR3(const Matrix3x3&);
+
+	void SetZero();  // Set to the zero map
+	inline void Negate();
+
+	inline LinearMapR3& operator+=(const Matrix3x3&);
+	inline LinearMapR3& operator-=(const Matrix3x3&);
+	inline LinearMapR3& operator*=(double);
+	inline LinearMapR3& operator/=(double);
+	LinearMapR3& operator*=(const Matrix3x3&);  // Matrix product
+
+	inline LinearMapR3 Transpose() const;   // Returns the transpose
+	double Determinant() const;             // Returns the determinant
+	LinearMapR3 Inverse() const;            // Returns inverse
+	LinearMapR3& Invert();                  // Converts into inverse.
+	VectorR3 Solve(const VectorR3&) const;  // Returns solution
+	LinearMapR3 PseudoInverse() const;      // Returns pseudo-inverse TO DO
+	VectorR3 PseudoSolve(const VectorR3&);  // Finds least squares solution TO DO
+};
+
+inline LinearMapR3 operator+(const LinearMapR3&, const Matrix3x3&);
+inline LinearMapR3 operator+(const Matrix3x3&, const LinearMapR3&);
+inline LinearMapR3 operator-(const LinearMapR3&);
+inline LinearMapR3 operator-(const LinearMapR3&, const Matrix3x3&);
+inline LinearMapR3 operator-(const Matrix3x3&, const LinearMapR3&);
+inline LinearMapR3 operator*(const LinearMapR3&, double);
+inline LinearMapR3 operator*(double, const LinearMapR3&);
+inline LinearMapR3 operator/(const LinearMapR3&, double);
+LinearMapR3 operator*(const LinearMapR3&, const LinearMapR3&);
+// Matrix product (composition)
+
+// *****************************************************
+// * AffineMapR3 class                 				   *
+// * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+class AffineMapR3 : public Matrix3x4
+{
+public:
+	AffineMapR3();
+	AffineMapR3(double, double, double, double, double, double,
+				double, double, double, double, double, double);  // Sets by columns
+	AffineMapR3(const VectorR3&, const VectorR3&, const VectorR3&, const VectorR3&);
+	AffineMapR3(const LinearMapR3&, const VectorR3&);
+
+	void SetIdentity();  // Set to the identity map
+	void SetZero();      // Set to the zero map
+
+	AffineMapR3& operator+=(const Matrix3x4&);
+	AffineMapR3& operator-=(const Matrix3x4&);
+	AffineMapR3& operator*=(double);
+	AffineMapR3& operator/=(double);
+	AffineMapR3& operator*=(const Matrix3x3&);  // Composition
+	AffineMapR3& operator*=(const Matrix3x4&);  // Composition
+
+	AffineMapR3& ApplyTranslationLeft(const VectorR3& u)
+	{
+		Matrix3x4::ApplyTranslationLeft(u);
+		return *this;
+	}
+	AffineMapR3& ApplyTranslationRight(const VectorR3& u)
+	{
+		Matrix3x4::ApplyTranslationRight(u);
+		return *this;
+	}
+	AffineMapR3& ApplyYRotationLeft(double theta)
+	{
+		Matrix3x4::ApplyYRotationLeft(theta);
+		return *this;
+	}
+	AffineMapR3& ApplyYRotationLeft(double costheta, double sintheta)
+	{
+		Matrix3x4::ApplyYRotationLeft(costheta, sintheta);
+		return *this;
+	}
+
+	AffineMapR3 Inverse() const;            // Returns inverse
+	AffineMapR3& Invert();                  // Converts into inverse.
+	VectorR3 Solve(const VectorR3&) const;  // Returns solution
+	AffineMapR3 PseudoInverse() const;      // Returns pseudo-inverse // TO DO
+	VectorR3 PseudoSolve(const VectorR3&);  // Least squares solution // TO DO
+};
+
+inline AffineMapR3 operator+(const AffineMapR3&, const Matrix3x4&);
+inline AffineMapR3 operator+(const Matrix3x4&, const AffineMapR3&);
+inline AffineMapR3 operator+(const AffineMapR3&, const Matrix3x3&);
+inline AffineMapR3 operator+(const Matrix3x3&, const AffineMapR3&);
+inline AffineMapR3 operator-(const AffineMapR3&, const Matrix3x4&);
+inline AffineMapR3 operator-(const Matrix3x4&, const AffineMapR3&);
+inline AffineMapR3 operator-(const AffineMapR3&, const Matrix3x3&);
+inline AffineMapR3 operator-(const Matrix3x3&, const AffineMapR3&);
+inline AffineMapR3 operator*(const AffineMapR3&, double);
+inline AffineMapR3 operator*(double, const AffineMapR3&);
+inline AffineMapR3 operator/(const AffineMapR3&, double);
+
+// Composition operators
+AffineMapR3 operator*(const AffineMapR3&, const AffineMapR3&);
+AffineMapR3 operator*(const LinearMapR3&, const AffineMapR3&);
+AffineMapR3 operator*(const AffineMapR3&, const LinearMapR3&);
+
+// *******************************************
+// RotationMapR3 class                       *
+// * * * * * * * * * * * * * * * * * * * * * *
+
+class RotationMapR3 : public Matrix3x3
+{
+public:
+	RotationMapR3();
+	RotationMapR3(const VectorR3&, const VectorR3&, const VectorR3&);
+	RotationMapR3(double, double, double, double, double, double,
+				  double, double, double);
+
+	RotationMapR3& Set(const Quaternion&);
+	RotationMapR3& Set(const VectorR3&, double theta);  // Set rotation axis and angle
+	RotationMapR3& Set(const VectorR3&, double sintheta, double costheta);
+
+	RotationMapR3& operator*=(const RotationMapR3&);  // Matrix product
+
+	RotationMapR3 Transpose() const { return Inverse(); };  // Returns the transpose
+	RotationMapR3 Inverse() const;                          // Returns inverse
+	RotationMapR3& Invert();                                // Converts into inverse.
+	VectorR3 Solve(const VectorR3&) const;                  // Returns solution	// Was named Invert
+
+	bool ToAxisAndAngle(VectorR3* u, double* theta) const;  // returns unit vector u and angle
+};
+
+RotationMapR3 operator*(const RotationMapR3&, const RotationMapR3&);
+// Matrix product (composition)
+
+inline RotationMapR3 ToRotationMapR3(const Quaternion& q)
+{
+	return (RotationMapR3().Set(q));
+}
+
+ostream& operator<<(ostream& os, const RotationMapR3& A);
+
+// ***************************************************************
+// * RigidMapR3 class - prototypes.								 *													 *
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+class RigidMapR3 : public Matrix3x4
+{
+public:
+	RigidMapR3();
+	RigidMapR3(const VectorR3&, const VectorR3&, const VectorR3&, const VectorR3&);
+	RigidMapR3(double, double, double, double, double, double,
+			   double, double, double, double, double, double);
+	RigidMapR3(const Matrix3x3&, const VectorR3&);
+
+	RigidMapR3& Set(const Matrix3x3&, const VectorR3&);      // Set to RotationMap & Vector
+	RigidMapR3& SetTranslationPart(const VectorR3&);         // Set the translation part
+	RigidMapR3& SetTranslationPart(double, double, double);  // Set the translation part
+	RigidMapR3& SetRotationPart(const Matrix3x3&);           // Set the rotation part
+	RigidMapR3& SetRotationPart(const Quaternion&);
+	RigidMapR3& SetRotationPart(const VectorR3&, double theta);  // Set rotation axis and angle
+	RigidMapR3& SetRotationPart(const VectorR3&, double sintheta, double costheta);
+
+	RigidMapR3& ApplyTranslationLeft(const VectorR3& u)
+	{
+		Matrix3x4::ApplyTranslationLeft(u);
+		return *this;
+	}
+	RigidMapR3& ApplyTranslationRight(const VectorR3& u)
+	{
+		Matrix3x4::ApplyTranslationRight(u);
+		return *this;
+	}
+	RigidMapR3& ApplyYRotationLeft(double theta)
+	{
+		Matrix3x4::ApplyYRotationLeft(theta);
+		return *this;
+	}
+	RigidMapR3& ApplyYRotationLeft(double costheta, double sintheta)
+	{
+		Matrix3x4::ApplyYRotationLeft(costheta, sintheta);
+		return *this;
+	}
+
+	RigidMapR3& operator*=(const RotationMapR3&);  // Composition
+	RigidMapR3& operator*=(const RigidMapR3&);     // Composition
+
+	RigidMapR3 Inverse() const;  // Returns inverse
+	RigidMapR3& Invert();        // Converts into inverse.
+
+	bool CalcGlideRotation(VectorR3* u, VectorR3* v,
+						   double* glideDist, double* rotation) const;
+
+	void Transform3x3Inverse(VectorR3* dest) const
+	{
+		Matrix3x4::Transform3x3Transpose(dest);
+	}
+	void Transform3x3Inverse(const VectorR3& src, VectorR3* dest) const
+	{
+		Matrix3x4::Transform3x3Transpose(src, dest);
+	}
+};
+
+// ***************************************************************
+// * 3-space vector and matrix utilities (prototypes)			 *
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+// Returns the solid angle between vectors v and w.
+inline double SolidAngle(const VectorR3& v, const VectorR3& w);
+
+// Returns a righthanded orthonormal basis to complement unit vector x
+void GetOrtho(const VectorR3& x, VectorR3& y, VectorR3& z);
+// Returns a vector v orthonormal to unit vector x
+void GetOrtho(const VectorR3& x, VectorR3& y);
+
+// Projections
+
+// The next three functions are templated below.
+//inline VectorR3 ProjectToUnit ( const VectorR3& u, const VectorR3& v); // Project u onto v
+//inline VectorR3 ProjectPerpUnit ( const VectorR3& u, const VectorR3 & v); // Project perp to v
+//inline VectorR3 ProjectPerpUnitDiff ( const VectorR3& u, const VectorR3& v)
+// v must be a unit vector.
+
+// Projection maps (LinearMapR3s)
+
+inline LinearMapR3 VectorProjectMap(const VectorR3& u);
+inline LinearMapR3 PlaneProjectMap(const VectorR3& w);
+inline LinearMapR3 PlaneProjectMap(const VectorR3& u, const VectorR3& v);
+// u,v,w - must be unit vector.  u and v must be orthonormal and
+// specify the plane they are parallel to.  w specifies the plane
+// it is orthogonal to.
+
+// VrRotate is similar to glRotate.  Returns a matrix (RotationMapR3)
+//		that will perform the rotation.  u should be a unit vector.
+RotationMapR3 VrRotate(double theta, const VectorR3& u);
+RotationMapR3 VrRotate(double costheta, double sintheta, const VectorR3& u);
+RotationMapR3 VrRotateAlign(const VectorR3& fromVec, const VectorR3& toVec);
+RotationMapR3 RotateToMap(const VectorR3& fromVec, const VectorR3& toVec);
+// fromVec and toVec should be unit vectors for RotateToMap
+
+// ***************************************************************
+// * Stream Output Routines	(Prototypes)						 *
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ostream& operator<<(ostream& os, const VectorR3& u);
+
+// *****************************************************
+// * VectorR3 class - inlined functions				   *
+// * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+inline VectorR3& VectorR3::Load(const double* v)
+{
+	x = *v;
+	y = *(v + 1);
+	z = *(v + 2);
+	return *this;
+}
+
+inline VectorR3& VectorR3::Load(const float* v)
+{
+	x = *v;
+	y = *(v + 1);
+	z = *(v + 2);
+	return *this;
+}
+
+inline void VectorR3::Dump(double* v) const
+{
+	*v = x;
+	*(v + 1) = y;
+	*(v + 2) = z;
+}
+
+inline void VectorR3::Dump(float* v) const
+{
+	*v = (float)x;
+	*(v + 1) = (float)y;
+	*(v + 2) = (float)z;
+}
+
+inline double VectorR3::operator[](int i)
+{
+	switch (i)
+	{
+		case 0:
+			return x;
+		case 1:
+			return y;
+		case 2:
+			return z;
+		default:
+			assert(0);
+			return 0.0;
+	}
+}
+
+inline VectorR3& VectorR3::MakeUnit()  // Convert to unit vector (or leave zero).
+{
+	double nSq = NormSq();
+	if (nSq != 0.0)
+	{
+		*this /= sqrt(nSq);
+	}
+	return *this;
+}
+
+inline VectorR3 operator+(const VectorR3& u, const VectorR3& v)
+{
+	return VectorR3(u.x + v.x, u.y + v.y, u.z + v.z);
+}
+inline VectorR3 operator-(const VectorR3& u, const VectorR3& v)
+{
+	return VectorR3(u.x - v.x, u.y - v.y, u.z - v.z);
+}
+inline VectorR3 operator*(const VectorR3& u, double m)
+{
+	return VectorR3(u.x * m, u.y * m, u.z * m);
+}
+inline VectorR3 operator*(double m, const VectorR3& u)
+{
+	return VectorR3(u.x * m, u.y * m, u.z * m);
+}
+inline VectorR3 operator/(const VectorR3& u, double m)
+{
+	double mInv = 1.0 / m;
+	return VectorR3(u.x * mInv, u.y * mInv, u.z * mInv);
+}
+
+inline int operator==(const VectorR3& u, const VectorR3& v)
+{
+	return (u.x == v.x && u.y == v.y && u.z == v.z);
+}
+
+inline double operator^(const VectorR3& u, const VectorR3& v)  // Dot Product
+{
+	return (u.x * v.x + u.y * v.y + u.z * v.z);
+}
+
+inline VectorR3 operator*(const VectorR3& u, const VectorR3& v)  // Cross Product
+{
+	return (VectorR3(u.y * v.z - u.z * v.y,
+					 u.z * v.x - u.x * v.z,
+					 u.x * v.y - u.y * v.x));
+}
+
+inline VectorR3 ArrayProd(const VectorR3& u, const VectorR3& v)
+{
+	return (VectorR3(u.x * v.x, u.y * v.y, u.z * v.z));
+}
+
+inline VectorR3& VectorR3::operator*=(const VectorR3& v)  // Cross Product
+{
+	double tx = x, ty = y;
+	x = y * v.z - z * v.y;
+	y = z * v.x - tx * v.z;
+	z = tx * v.y - ty * v.x;
+	return (*this);
+}
+
+inline VectorR3& VectorR3::ArrayProd(const VectorR3& v)  // Component-wise Product
+{
+	x *= v.x;
+	y *= v.y;
+	z *= v.z;
+	return (*this);
+}
+
+inline VectorR3& VectorR3::AddScaled(const VectorR3& u, double s)
+{
+	x += s * u.x;
+	y += s * u.y;
+	z += s * u.z;
+	return (*this);
+}
+
+inline VectorR3::VectorR3(const VectorHgR3& uH)
+	: x(uH.x), y(uH.y), z(uH.z)
+{
+	*this /= uH.w;
+}
+
+inline VectorR3& VectorR3::ReNormalize()  // Convert near unit back to unit
+{
+	double nSq = NormSq();
+	double mFact = 1.0 - 0.5 * (nSq - 1.0);  // Multiplicative factor
+	*this *= mFact;
+	return *this;
+}
+
+inline double NormalizeError(const VectorR3& u)
+{
+	double discrepancy;
+	discrepancy = u.x * u.x + u.y * u.y + u.z * u.z - 1.0;
+	if (discrepancy < 0.0)
+	{
+		discrepancy = -discrepancy;
+	}
+	return discrepancy;
+}
+
+inline double VectorR3::Dist(const VectorR3& u) const  // Distance from u
+{
+	return sqrt(DistSq(u));
+}
+
+inline double VectorR3::DistSq(const VectorR3& u) const  // Distance from u
+{
+	return ((x - u.x) * (x - u.x) + (y - u.y) * (y - u.y) + (z - u.z) * (z - u.z));
+}
+
+//
+// Interpolation routines (not just Spherical Interpolation)
+//
+
+// Interpolate(start,end,frac) - linear interpolation
+//		- allows overshooting the end points
+inline VectorR3 Interpolate(const VectorR3& start, const VectorR3& end, double a)
+{
+	VectorR3 ret;
+	Lerp(start, end, a, ret);
+	return ret;
+}
+
+// ******************************************************
+// * Matrix3x3  class - inlined functions				*
+// * * * * * * * * * * * * * * * * * * * * * * * * * * **
+
+inline Matrix3x3::Matrix3x3() {}
+
+inline Matrix3x3::Matrix3x3(const VectorR3& u, const VectorR3& v,
+							const VectorR3& s)
+{
+	m11 = u.x;  // Column 1
+	m21 = u.y;
+	m31 = u.z;
+	m12 = v.x;  // Column 2
+	m22 = v.y;
+	m32 = v.z;
+	m13 = s.x;  // Column 3
+	m23 = s.y;
+	m33 = s.z;
+}
+
+inline Matrix3x3::Matrix3x3(double a11, double a21, double a31,
+							double a12, double a22, double a32,
+							double a13, double a23, double a33)
+// Values specified in column order!!!
+{
+	m11 = a11;  // Row 1
+	m12 = a12;
+	m13 = a13;
+	m21 = a21;  // Row 2
+	m22 = a22;
+	m23 = a23;
+	m31 = a31;  // Row 3
+	m32 = a32;
+	m33 = a33;
+}
+
+inline void Matrix3x3::SetIdentity()
+{
+	m11 = m22 = m33 = 1.0;
+	m12 = m13 = m21 = m23 = m31 = m32 = 0.0;
+}
+
+inline void Matrix3x3::SetZero()
+{
+	m11 = m12 = m13 = m21 = m22 = m23 = m31 = m32 = m33 = 0.0;
+}
+
+inline void Matrix3x3::Set(const Matrix3x3& A)  // Set to the matrix.
+{
+	m11 = A.m11;
+	m21 = A.m21;
+	m31 = A.m31;
+	m12 = A.m12;
+	m22 = A.m22;
+	m32 = A.m32;
+	m13 = A.m13;
+	m23 = A.m23;
+	m33 = A.m33;
+}
+
+inline void Matrix3x3::Set3x3(const Matrix3x4& A)  // Set to the 3x3 part of the matrix.
+{
+	m11 = A.m11;
+	m21 = A.m21;
+	m31 = A.m31;
+	m12 = A.m12;
+	m22 = A.m22;
+	m32 = A.m32;
+	m13 = A.m13;
+	m23 = A.m23;
+	m33 = A.m33;
+}
+
+inline void Matrix3x3::Set(const VectorR3& u, const VectorR3& v,
+						   const VectorR3& w)
+{
+	m11 = u.x;  // Column 1
+	m21 = u.y;
+	m31 = u.z;
+	m12 = v.x;  // Column 2
+	m22 = v.y;
+	m32 = v.z;
+	m13 = w.x;  // Column 3
+	m23 = w.y;
+	m33 = w.z;
+}
+
+inline void Matrix3x3::Set(double a11, double a21, double a31,
+						   double a12, double a22, double a32,
+						   double a13, double a23, double a33)
+// Values specified in column order!!!
+{
+	m11 = a11;  // Row 1
+	m12 = a12;
+	m13 = a13;
+	m21 = a21;  // Row 2
+	m22 = a22;
+	m23 = a23;
+	m31 = a31;  // Row 3
+	m32 = a32;
+	m33 = a33;
+}
+
+inline void Matrix3x3::SetByRows(double a11, double a12, double a13,
+								 double a21, double a22, double a23,
+								 double a31, double a32, double a33)
+// Values specified in row order!!!
+{
+	m11 = a11;  // Row 1
+	m12 = a12;
+	m13 = a13;
+	m21 = a21;  // Row 2
+	m22 = a22;
+	m23 = a23;
+	m31 = a31;  // Row 3
+	m32 = a32;
+	m33 = a33;
+}
+
+inline void Matrix3x3::SetByRows(const VectorR3& u, const VectorR3& v,
+								 const VectorR3& s)
+{
+	m11 = u.x;  // Row 1
+	m12 = u.y;
+	m13 = u.z;
+	m21 = v.x;  // Row 2
+	m22 = v.y;
+	m23 = v.z;
+	m31 = s.x;  // Row 3
+	m32 = s.y;
+	m33 = s.z;
+}
+
+inline void Matrix3x3::SetColumn1(double x, double y, double z)
+{
+	m11 = x;
+	m21 = y;
+	m31 = z;
+}
+
+inline void Matrix3x3::SetColumn2(double x, double y, double z)
+{
+	m12 = x;
+	m22 = y;
+	m32 = z;
+}
+
+inline void Matrix3x3::SetColumn3(double x, double y, double z)
+{
+	m13 = x;
+	m23 = y;
+	m33 = z;
+}
+
+inline void Matrix3x3::SetColumn1(const VectorR3& u)
+{
+	m11 = u.x;
+	m21 = u.y;
+	m31 = u.z;
+}
+
+inline void Matrix3x3::SetColumn2(const VectorR3& u)
+{
+	m12 = u.x;
+	m22 = u.y;
+	m32 = u.z;
+}
+
+inline void Matrix3x3::SetColumn3(const VectorR3& u)
+{
+	m13 = u.x;
+	m23 = u.y;
+	m33 = u.z;
+}
+
+inline void Matrix3x3::SetRow1(double x, double y, double z)
+{
+	m11 = x;
+	m12 = y;
+	m13 = z;
+}
+
+inline void Matrix3x3::SetRow2(double x, double y, double z)
+{
+	m21 = x;
+	m22 = y;
+	m23 = z;
+}
+
+inline void Matrix3x3::SetRow3(double x, double y, double z)
+{
+	m31 = x;
+	m32 = y;
+	m33 = z;
+}
+
+inline VectorR3 Matrix3x3::Column1() const
+{
+	return (VectorR3(m11, m21, m31));
+}
+
+inline VectorR3 Matrix3x3::Column2() const
+{
+	return (VectorR3(m12, m22, m32));
+}
+
+inline VectorR3 Matrix3x3::Column3() const
+{
+	return (VectorR3(m13, m23, m33));
+}
+
+inline VectorR3 Matrix3x3::Row1() const
+{
+	return (VectorR3(m11, m12, m13));
+}
+
+inline VectorR3 Matrix3x3::Row2() const
+{
+	return (VectorR3(m21, m22, m23));
+}
+
+inline VectorR3 Matrix3x3::Row3() const
+{
+	return (VectorR3(m31, m32, m33));
+}
+
+inline void Matrix3x3::SetDiagonal(double x, double y, double z)
+{
+	m11 = x;
+	m22 = y;
+	m33 = z;
+}
+
+inline void Matrix3x3::SetDiagonal(const VectorR3& u)
+{
+	SetDiagonal(u.x, u.y, u.z);
+}
+
+inline double Matrix3x3::Diagonal(int i)
+{
+	switch (i)
+	{
+		case 0:
+			return m11;
+		case 1:
+			return m22;
+		case 2:
+			return m33;
+		default:
+			assert(0);
+			return 0.0;
+	}
+}
+
+inline void Matrix3x3::MakeTranspose()  // Transposes it.
+{
+	double temp;
+	temp = m12;
+	m12 = m21;
+	m21 = temp;
+	temp = m13;
+	m13 = m31;
+	m31 = temp;
+	temp = m23;
+	m23 = m32;
+	m32 = temp;
+}
+
+inline VectorR3 operator*(const Matrix3x3& A, const VectorR3& u)
+{
+	return (VectorR3(A.m11 * u.x + A.m12 * u.y + A.m13 * u.z,
+					 A.m21 * u.x + A.m22 * u.y + A.m23 * u.z,
+					 A.m31 * u.x + A.m32 * u.y + A.m33 * u.z));
+}
+
+inline void Matrix3x3::Transform(VectorR3* u) const
+{
+	double newX, newY;
+	newX = m11 * u->x + m12 * u->y + m13 * u->z;
+	newY = m21 * u->x + m22 * u->y + m23 * u->z;
+	u->z = m31 * u->x + m32 * u->y + m33 * u->z;
+	u->x = newX;
+	u->y = newY;
+}
+
+inline void Matrix3x3::Transform(const VectorR3& src, VectorR3* dest) const
+{
+	dest->x = m11 * src.x + m12 * src.y + m13 * src.z;
+	dest->y = m21 * src.x + m22 * src.y + m23 * src.z;
+	dest->z = m31 * src.x + m32 * src.y + m33 * src.z;
+}
+
+// ******************************************************
+// * Matrix3x4  class - inlined functions				*
+// * * * * * * * * * * * * * * * * * * * * * * * * * * **
+
+inline Matrix3x4::Matrix3x4(const VectorR3& u, const VectorR3& v,
+							const VectorR3& s, const VectorR3& t)
+{
+	m11 = u.x;  // Column 1
+	m21 = u.y;
+	m31 = u.z;
+	m12 = v.x;  // Column 2
+	m22 = v.y;
+	m32 = v.z;
+	m13 = s.x;  // Column 3
+	m23 = s.y;
+	m33 = s.z;
+	m14 = t.x;
+	m24 = t.y;
+	m34 = t.z;
+}
+
+inline Matrix3x4::Matrix3x4(double a11, double a21, double a31,
+							double a12, double a22, double a32,
+							double a13, double a23, double a33,
+							double a14, double a24, double a34)
+{               // Values in COLUMN order!
+	m11 = a11;  // Row 1
+	m12 = a12;
+	m13 = a13;
+	m14 = a14;
+	m21 = a21;  // Row 2
+	m22 = a22;
+	m23 = a23;
+	m24 = a24;
+	m31 = a31;  // Row 3
+	m32 = a32;
+	m33 = a33;
+	m34 = a34;
+}
+
+inline Matrix3x4::Matrix3x4(const Matrix3x3& A, const VectorR3& u)
+{
+	Set(A, u);
+}
+
+inline void Matrix3x4::SetIdentity()  // Set to the identity map
+{
+	m11 = m22 = m33 = 1.0;
+	m12 = m13 = m21 = m23 = m31 = m32 = 0.0;
+	m14 = m24 = m34 = 0.0;
+}
+
+inline void Matrix3x4::SetZero()  // Set to the zero map
+{
+	m11 = m22 = m33 = 0.0;
+	m12 = m13 = m21 = m23 = m31 = m32 = 0.0;
+	m14 = m24 = m34 = 0.0;
+}
+
+inline void Matrix3x4::Set(const Matrix3x4& A)  // Set to the matrix.
+{
+	m11 = A.m11;
+	m21 = A.m21;
+	m31 = A.m31;
+	m12 = A.m12;
+	m22 = A.m22;
+	m32 = A.m32;
+	m13 = A.m13;
+	m23 = A.m23;
+	m33 = A.m33;
+	m14 = A.m14;
+	m24 = A.m24;
+	m34 = A.m34;
+}
+
+inline void Matrix3x4::Set(const Matrix3x3& A, const VectorR3& t)  // Set to the matrix plus 4th column
+{
+	m11 = A.m11;
+	m21 = A.m21;
+	m31 = A.m31;
+	m12 = A.m12;
+	m22 = A.m22;
+	m32 = A.m32;
+	m13 = A.m13;
+	m23 = A.m23;
+	m33 = A.m33;
+	m14 = t.x;  // Column 4
+	m24 = t.y;
+	m34 = t.z;
+}
+
+// Set linear part to the matrix
+inline void Matrix3x4::Set3x3(const Matrix3x3& A)
+{
+	m11 = A.m11;
+	m21 = A.m21;
+	m31 = A.m31;
+	m12 = A.m12;
+	m22 = A.m22;
+	m32 = A.m32;
+	m13 = A.m13;
+	m23 = A.m23;
+	m33 = A.m33;
+}
+
+inline void Matrix3x4::Set(const VectorR3& u, const VectorR3& v,
+						   const VectorR3& w, const VectorR3& t)
+{
+	m11 = u.x;  // Column 1
+	m21 = u.y;
+	m31 = u.z;
+	m12 = v.x;  // Column 2
+	m22 = v.y;
+	m32 = v.z;
+	m13 = w.x;  // Column 3
+	m23 = w.y;
+	m33 = w.z;
+	m14 = t.x;  // Column 4
+	m24 = t.y;
+	m34 = t.z;
+}
+
+inline void Matrix3x4::Set(double a11, double a21, double a31,
+						   double a12, double a22, double a32,
+						   double a13, double a23, double a33,
+						   double a14, double a24, double a34)
+// Values specified in column order!!!
+{
+	m11 = a11;  // Row 1
+	m12 = a12;
+	m13 = a13;
+	m14 = a14;
+	m21 = a21;  // Row 2
+	m22 = a22;
+	m23 = a23;
+	m24 = a24;
+	m31 = a31;  // Row 3
+	m32 = a32;
+	m33 = a33;
+	m34 = a34;
+}
+
+inline void Matrix3x4::Set3x3(double a11, double a21, double a31,
+							  double a12, double a22, double a32,
+							  double a13, double a23, double a33)
+// Values specified in column order!!!
+{
+	m11 = a11;  // Row 1
+	m12 = a12;
+	m13 = a13;
+	m21 = a21;  // Row 2
+	m22 = a22;
+	m23 = a23;
+	m31 = a31;  // Row 3
+	m32 = a32;
+	m33 = a33;
+}
+
+inline void Matrix3x4::SetByRows(double a11, double a12, double a13, double a14,
+								 double a21, double a22, double a23, double a24,
+								 double a31, double a32, double a33, double a34)
+// Values specified in row order!!!
+{
+	m11 = a11;  // Row 1
+	m12 = a12;
+	m13 = a13;
+	m14 = a14;
+	m21 = a21;  // Row 2
+	m22 = a22;
+	m23 = a23;
+	m24 = a24;
+	m31 = a31;  // Row 3
+	m32 = a32;
+	m33 = a33;
+	m34 = a34;
+}
+
+inline void Matrix3x4::SetColumn1(double x, double y, double z)
+{
+	m11 = x;
+	m21 = y;
+	m31 = z;
+}
+
+inline void Matrix3x4::SetColumn2(double x, double y, double z)
+{
+	m12 = x;
+	m22 = y;
+	m32 = z;
+}
+
+inline void Matrix3x4::SetColumn3(double x, double y, double z)
+{
+	m13 = x;
+	m23 = y;
+	m33 = z;
+}
+
+inline void Matrix3x4::SetColumn4(double x, double y, double z)
+{
+	m14 = x;
+	m24 = y;
+	m34 = z;
+}
+
+inline void Matrix3x4::SetColumn1(const VectorR3& u)
+{
+	m11 = u.x;
+	m21 = u.y;
+	m31 = u.z;
+}
+
+inline void Matrix3x4::SetColumn2(const VectorR3& u)
+{
+	m12 = u.x;
+	m22 = u.y;
+	m32 = u.z;
+}
+
+inline void Matrix3x4::SetColumn3(const VectorR3& u)
+{
+	m13 = u.x;
+	m23 = u.y;
+	m33 = u.z;
+}
+
+inline void Matrix3x4::SetColumn4(const VectorR3& u)
+{
+	m14 = u.x;
+	m24 = u.y;
+	m34 = u.z;
+}
+
+inline VectorR3 Matrix3x4::Column1() const
+{
+	return (VectorR3(m11, m21, m31));
+}
+
+inline VectorR3 Matrix3x4::Column2() const
+{
+	return (VectorR3(m12, m22, m32));
+}
+
+inline VectorR3 Matrix3x4::Column3() const
+{
+	return (VectorR3(m13, m23, m33));
+}
+
+inline VectorR3 Matrix3x4::Column4() const
+{
+	return (VectorR3(m14, m24, m34));
+}
+
+inline void Matrix3x4::SetRow1(double x, double y, double z, double w)
+{
+	m11 = x;
+	m12 = y;
+	m13 = z;
+	m14 = w;
+}
+
+inline void Matrix3x4::SetRow2(double x, double y, double z, double w)
+{
+	m21 = x;
+	m22 = y;
+	m23 = z;
+	m24 = w;
+}
+
+inline void Matrix3x4::SetRow3(double x, double y, double z, double w)
+{
+	m31 = x;
+	m32 = y;
+	m33 = z;
+	m34 = w;
+}
+
+// Left multiply with a translation (so the translation is applied afterwards).
+inline Matrix3x4& Matrix3x4::ApplyTranslationLeft(const VectorR3& u)
+{
+	m14 += u.x;
+	m24 += u.y;
+	m34 += u.z;
+	return *this;
+}
+
+// Right multiply with a translation (so the translation is applied first).
+inline Matrix3x4& Matrix3x4::ApplyTranslationRight(const VectorR3& u)
+{
+	double new14 = m14 + m11 * u.x + m12 * u.y + m13 * u.z;
+	double new24 = m24 + m21 * u.x + m22 * u.y + m23 * u.z;
+	m34 = m34 + m31 * u.x + m32 * u.y + m33 * u.z;
+	m14 = new14;
+	m24 = new24;
+	return *this;
+}
+
+// Left-multiply with a rotation around the y-axis.
+inline Matrix3x4& Matrix3x4::ApplyYRotationLeft(double theta)
+{
+	double costheta = cos(theta);
+	double sintheta = sin(theta);
+	return ApplyYRotationLeft(costheta, sintheta);
+}
+
+inline Matrix3x4& Matrix3x4::ApplyYRotationLeft(double costheta, double sintheta)
+{
+	double tmp;
+	tmp = costheta * m11 + sintheta * m31;
+	m31 = costheta * m31 - sintheta * m11;
+	m11 = tmp;
+
+	tmp = costheta * m12 + sintheta * m32;
+	m32 = costheta * m32 - sintheta * m12;
+	m12 = tmp;
+
+	tmp = costheta * m13 + sintheta * m33;
+	m33 = costheta * m33 - sintheta * m13;
+	m13 = tmp;
+
+	tmp = costheta * m14 + sintheta * m34;
+	m34 = costheta * m34 - sintheta * m14;
+	m14 = tmp;
+
+	return *this;
+}
+
+inline VectorR3 Matrix3x4::Solve(const VectorR3& u) const  // Returns solution
+{
+	Matrix3x3 A;
+	A.Set3x3(*this);
+	return (A.Solve(VectorR3(m14 - u.x, m24 - u.y, m34 - u.z)));
+}
+
+inline void Matrix3x4::Transform(VectorR3* u) const
+{
+	double newX, newY;
+	newX = m11 * u->x + m12 * u->y + m13 * u->z + m14;
+	newY = m21 * u->x + m22 * u->y + m23 * u->z + m24;
+	u->z = m31 * u->x + m32 * u->y + m33 * u->z + m34;
+	u->x = newX;
+	u->y = newY;
+}
+
+inline void Matrix3x4::Transform3x3(VectorR3* u) const
+{
+	double newX, newY;
+	newX = m11 * u->x + m12 * u->y + m13 * u->z;
+	newY = m21 * u->x + m22 * u->y + m23 * u->z;
+	u->z = m31 * u->x + m32 * u->y + m33 * u->z;
+	u->x = newX;
+	u->y = newY;
+}
+
+inline void Matrix3x4::Transform(const VectorR3& src, VectorR3* dest) const
+{
+	dest->x = m11 * src.x + m12 * src.y + m13 * src.z + m14;
+	dest->y = m21 * src.x + m22 * src.y + m23 * src.z + m24;
+	dest->z = m31 * src.x + m32 * src.y + m33 * src.z + m34;
+}
+
+inline void Matrix3x4::Transform3x3(const VectorR3& src, VectorR3* dest) const
+{
+	dest->x = m11 * src.x + m12 * src.y + m13 * src.z;
+	dest->y = m21 * src.x + m22 * src.y + m23 * src.z;
+	dest->z = m31 * src.x + m32 * src.y + m33 * src.z;
+}
+
+inline void Matrix3x4::Transform3x3Transpose(VectorR3* u) const
+{
+	double newX, newY;
+	newX = m11 * u->x + m21 * u->y + m31 * u->z;
+	newY = m12 * u->x + m22 * u->y + m32 * u->z;
+	u->z = m13 * u->x + m23 * u->y + m33 * u->z;
+	u->x = newX;
+	u->y = newY;
+}
+
+inline void Matrix3x4::Transform3x3Transpose(const VectorR3& src, VectorR3* dest) const
+{
+	dest->x = m11 * src.x + m21 * src.y + m31 * src.z;
+	dest->y = m12 * src.x + m22 * src.y + m32 * src.z;
+	dest->z = m13 * src.x + m23 * src.y + m33 * src.z;
+}
+
+inline VectorR3 operator*(const Matrix3x4& A, const VectorR3& u)
+{
+	return (VectorR3(A.m11 * u.x + A.m12 * u.y + A.m13 * u.z + A.m14,
+					 A.m21 * u.x + A.m22 * u.y + A.m23 * u.z + A.m24,
+					 A.m31 * u.x + A.m32 * u.y + A.m33 * u.z + A.m34));
+}
+
+// ******************************************************
+// * LinearMapR3 class - inlined functions				*
+// * * * * * * * * * * * * * * * * * * * * * * * * * * **
+
+inline LinearMapR3::LinearMapR3()
+{
+	SetZero();
+	return;
+}
+
+inline LinearMapR3::LinearMapR3(const VectorR3& u, const VectorR3& v,
+								const VectorR3& s)
+	: Matrix3x3(u, v, s)
+{
+}
+
+inline LinearMapR3::LinearMapR3(
+	double a11, double a21, double a31,
+	double a12, double a22, double a32,
+	double a13, double a23, double a33)
+	// Values specified in column order!!!
+	: Matrix3x3(a11, a21, a31, a12, a22, a32, a13, a23, a33)
+{
+}
+
+inline LinearMapR3::LinearMapR3(const Matrix3x3& A)
+	: Matrix3x3(A)
+{
+}
+
+inline void LinearMapR3::SetZero()
+{
+	Matrix3x3::SetZero();
+}
+
+inline void LinearMapR3::Negate()
+{
+	m11 = -m11;  // Row 1
+	m12 = -m12;
+	m13 = -m13;
+	m21 = -m21;  // Row 2
+	m22 = -m22;
+	m23 = -m23;
+	m31 = -m31;  // Row 3
+	m32 = -m32;
+	m33 = -m33;
+}
+
+inline LinearMapR3& LinearMapR3::operator+=(const Matrix3x3& B)
+{
+	m11 += B.m11;
+	m12 += B.m12;
+	m13 += B.m13;
+	m21 += B.m21;
+	m22 += B.m22;
+	m23 += B.m23;
+	m31 += B.m31;
+	m32 += B.m32;
+	m33 += B.m33;
+	return (*this);
+}
+
+inline LinearMapR3& LinearMapR3::operator-=(const Matrix3x3& B)
+{
+	m11 -= B.m11;
+	m12 -= B.m12;
+	m13 -= B.m13;
+	m21 -= B.m21;
+	m22 -= B.m22;
+	m23 -= B.m23;
+	m31 -= B.m31;
+	m32 -= B.m32;
+	m33 -= B.m33;
+	return (*this);
+}
+
+inline LinearMapR3 operator+(const LinearMapR3& A, const Matrix3x3& B)
+{
+	return (LinearMapR3(A.m11 + B.m11, A.m21 + B.m21, A.m31 + B.m31,
+						A.m12 + B.m12, A.m22 + B.m22, A.m32 + B.m32,
+						A.m13 + B.m13, A.m23 + B.m23, A.m33 + B.m33));
+}
+
+inline LinearMapR3 operator+(const Matrix3x3& A, const LinearMapR3& B)
+{
+	return (LinearMapR3(A.m11 + B.m11, A.m21 + B.m21, A.m31 + B.m31,
+						A.m12 + B.m12, A.m22 + B.m22, A.m32 + B.m32,
+						A.m13 + B.m13, A.m23 + B.m23, A.m33 + B.m33));
+}
+
+inline LinearMapR3 operator-(const LinearMapR3& A)
+{
+	return (LinearMapR3(-A.m11, -A.m21, -A.m31,
+						-A.m12, -A.m22, -A.m32,
+						-A.m13, -A.m23, -A.m33));
+}
+
+inline LinearMapR3 operator-(const Matrix3x3& A, const LinearMapR3& B)
+{
+	return (LinearMapR3(A.m11 - B.m11, A.m21 - B.m21, A.m31 - B.m31,
+						A.m12 - B.m12, A.m22 - B.m22, A.m32 - B.m32,
+						A.m13 - B.m13, A.m23 - B.m23, A.m33 - B.m33));
+}
+
+inline LinearMapR3 operator-(const LinearMapR3& A, const Matrix3x3& B)
+{
+	return (LinearMapR3(A.m11 - B.m11, A.m21 - B.m21, A.m31 - B.m31,
+						A.m12 - B.m12, A.m22 - B.m22, A.m32 - B.m32,
+						A.m13 - B.m13, A.m23 - B.m23, A.m33 - B.m33));
+}
+
+inline LinearMapR3& LinearMapR3::operator*=(double b)
+{
+	m11 *= b;
+	m12 *= b;
+	m13 *= b;
+	m21 *= b;
+	m22 *= b;
+	m23 *= b;
+	m31 *= b;
+	m32 *= b;
+	m33 *= b;
+	return (*this);
+}
+
+inline LinearMapR3 operator*(const LinearMapR3& A, double b)
+{
+	return (LinearMapR3(A.m11 * b, A.m21 * b, A.m31 * b,
+						A.m12 * b, A.m22 * b, A.m32 * b,
+						A.m13 * b, A.m23 * b, A.m33 * b));
+}
+
+inline LinearMapR3 operator*(double b, const LinearMapR3& A)
+{
+	return (LinearMapR3(A.m11 * b, A.m21 * b, A.m31 * b,
+						A.m12 * b, A.m22 * b, A.m32 * b,
+						A.m13 * b, A.m23 * b, A.m33 * b));
+}
+
+inline LinearMapR3 operator/(const LinearMapR3& A, double b)
+{
+	double bInv = 1.0 / b;
+	return (LinearMapR3(A.m11 * bInv, A.m21 * bInv, A.m31 * bInv,
+						A.m12 * bInv, A.m22 * bInv, A.m32 * bInv,
+						A.m13 * bInv, A.m23 * bInv, A.m33 * bInv));
+}
+
+inline LinearMapR3& LinearMapR3::operator/=(double b)
+{
+	double bInv = 1.0 / b;
+	return (*this *= bInv);
+}
+
+inline LinearMapR3& LinearMapR3::operator*=(const Matrix3x3& B)  // Matrix product
+{
+	OperatorTimesEquals(B);
+	return (*this);
+}
+
+inline VectorR3 LinearMapR3::Solve(const VectorR3& u) const  // Returns solution
+{
+	return (Matrix3x3::Solve(u));
+}
+
+inline LinearMapR3 LinearMapR3::Transpose() const  // Returns the transpose
+{
+	return (LinearMapR3(m11, m12, m13, m21, m22, m23, m31, m32, m33));
+}
+
+// ******************************************************
+// * AffineMapR3 class - inlined functions				*
+// * * * * * * * * * * * * * * * * * * * * * * * * * * **
+
+inline AffineMapR3::AffineMapR3(double a11, double a21, double a31,
+								double a12, double a22, double a32,
+								double a13, double a23, double a33,
+								double a14, double a24, double a34)
+{               // Values in COLUMN order!
+	m11 = a11;  // Row 1
+	m12 = a12;
+	m13 = a13;
+	m14 = a14;
+	m21 = a21;  // Row 2
+	m22 = a22;
+	m23 = a23;
+	m24 = a24;
+	m31 = a31;  // Row 3
+	m32 = a32;
+	m33 = a33;
+	m34 = a34;
+}
+
+inline AffineMapR3::AffineMapR3(const VectorR3& u, const VectorR3& v,
+								const VectorR3& w, const VectorR3& t)
+{
+	m11 = u.x;  // Column 1
+	m21 = u.y;
+	m31 = u.z;
+	m12 = v.x;  // Column 2
+	m22 = v.y;
+	m32 = v.z;
+	m13 = w.x;  // Column 3
+	m23 = w.y;
+	m33 = w.z;
+	m14 = t.x;  // Column 4
+	m24 = t.y;
+	m34 = t.z;
+}
+
+inline AffineMapR3::AffineMapR3(const LinearMapR3& A, const VectorR3& t)
+{
+	m11 = A.m11;
+	m12 = A.m12;
+	m13 = A.m13;
+	m14 = t.x;
+	m21 = A.m21;
+	m22 = A.m22;
+	m23 = A.m23;
+	m24 = t.y;
+	m31 = A.m31;
+	m32 = A.m32;
+	m33 = A.m33;
+	m34 = t.z;
+}
+
+inline void AffineMapR3::SetIdentity()
+{
+	Matrix3x4::SetIdentity();
+}
+
+inline void AffineMapR3::SetZero()
+{
+	Matrix3x4::SetZero();
+}
+
+inline VectorR3 AffineMapR3::Solve(const VectorR3& u) const  // Returns solution
+{
+	return (Matrix3x4::Solve(u));
+}
+
+inline AffineMapR3& AffineMapR3::operator+=(const Matrix3x4& B)
+{
+	m11 += B.m11;
+	m21 += B.m21;
+	m31 += B.m31;
+	m12 += B.m12;
+	m22 += B.m22;
+	m32 += B.m32;
+	m13 += B.m13;
+	m23 += B.m23;
+	m33 += B.m33;
+	m14 += B.m14;
+	m24 += B.m24;
+	m34 += B.m34;
+	return (*this);
+}
+
+inline AffineMapR3& AffineMapR3::operator-=(const Matrix3x4& B)
+{
+	m11 -= B.m11;
+	m21 -= B.m21;
+	m31 -= B.m31;
+	m12 -= B.m12;
+	m22 -= B.m22;
+	m32 -= B.m32;
+	m13 -= B.m13;
+	m23 -= B.m23;
+	m33 -= B.m33;
+	m14 -= B.m14;
+	m24 -= B.m24;
+	m34 -= B.m34;
+	return (*this);
+}
+
+inline AffineMapR3 operator+(const AffineMapR3& A, const AffineMapR3& B)
+{
+	return (AffineMapR3(A.m11 + B.m11, A.m21 + B.m21, A.m31 + B.m31,
+						A.m12 + B.m12, A.m22 + B.m22, A.m32 + B.m32,
+						A.m13 + B.m13, A.m23 + B.m23, A.m33 + B.m33,
+						A.m14 + B.m14, A.m23 + B.m24, A.m34 + B.m34));
+}
+
+inline AffineMapR3 operator+(const AffineMapR3& A, const Matrix3x3& B)
+{
+	return (AffineMapR3(A.m11 + B.m11, A.m21 + B.m21, A.m31 + B.m31,
+						A.m12 + B.m12, A.m22 + B.m22, A.m32 + B.m32,
+						A.m13 + B.m13, A.m23 + B.m23, A.m33 + B.m33,
+						A.m14, A.m23, A.m34));
+}
+
+inline AffineMapR3 operator+(const Matrix3x3& B, const AffineMapR3& A)
+{
+	return (AffineMapR3(A.m11 + B.m11, A.m21 + B.m21, A.m31 + B.m31,
+						A.m12 + B.m12, A.m22 + B.m22, A.m32 + B.m32,
+						A.m13 + B.m13, A.m23 + B.m23, A.m33 + B.m33,
+						A.m14, A.m23, A.m34));
+}
+
+inline AffineMapR3 operator-(const AffineMapR3& A, const AffineMapR3& B)
+{
+	return (AffineMapR3(A.m11 - B.m11, A.m21 - B.m21, A.m31 - B.m31,
+						A.m12 - B.m12, A.m22 - B.m22, A.m32 - B.m32,
+						A.m13 - B.m13, A.m23 - B.m23, A.m33 - B.m33,
+						A.m14 - B.m14, A.m23 - B.m24, A.m34 - B.m34));
+}
+
+inline AffineMapR3 operator-(const AffineMapR3& A, const LinearMapR3& B)
+{
+	return (AffineMapR3(A.m11 - B.m11, A.m21 - B.m21, A.m31 - B.m31,
+						A.m12 - B.m12, A.m22 - B.m22, A.m32 - B.m32,
+						A.m13 - B.m13, A.m23 - B.m23, A.m33 - B.m33,
+						A.m14, A.m23, A.m34));
+}
+
+inline AffineMapR3 operator-(const LinearMapR3& B, const AffineMapR3& A)
+{
+	return (AffineMapR3(A.m11 - B.m11, A.m21 - B.m21, A.m31 - B.m31,
+						A.m12 - B.m12, A.m22 - B.m22, A.m32 - B.m32,
+						A.m13 - B.m13, A.m23 - B.m23, A.m33 - B.m33,
+						A.m14, A.m23, A.m34));
+}
+
+inline AffineMapR3& AffineMapR3::operator*=(double b)
+{
+	m11 *= b;
+	m12 *= b;
+	m13 *= b;
+	m21 *= b;
+	m22 *= b;
+	m23 *= b;
+	m31 *= b;
+	m32 *= b;
+	m33 *= b;
+	m14 *= b;
+	m24 *= b;
+	m34 *= b;
+	return (*this);
+}
+
+inline AffineMapR3 operator*(const AffineMapR3& A, double b)
+{
+	return (AffineMapR3(A.m11 * b, A.m21 * b, A.m31 * b,
+						A.m12 * b, A.m22 * b, A.m32 * b,
+						A.m13 * b, A.m23 * b, A.m33 * b,
+						A.m14 * b, A.m24 * b, A.m34 * b));
+}
+
+inline AffineMapR3 operator*(double b, const AffineMapR3& A)
+{
+	return (AffineMapR3(A.m11 * b, A.m21 * b, A.m31 * b,
+						A.m12 * b, A.m22 * b, A.m32 * b,
+						A.m13 * b, A.m23 * b, A.m33 * b,
+						A.m14 * b, A.m24 * b, A.m34 * b));
+}
+
+inline AffineMapR3& AffineMapR3::operator/=(double b)
+{
+	double bInv = 1.0 / b;
+	*this *= bInv;
+	return (*this);
+}
+
+inline AffineMapR3 operator/(const AffineMapR3& A, double b)
+{
+	double bInv = 1.0 / b;
+	return (AffineMapR3(A.m11 * bInv, A.m21 * bInv, A.m31 * bInv,
+						A.m12 * bInv, A.m22 * bInv, A.m32 * bInv,
+						A.m13 * bInv, A.m23 * bInv, A.m33 * bInv,
+						A.m14 * bInv, A.m24 * bInv, A.m34 * bInv));
+}
+
+inline AffineMapR3& AffineMapR3::operator*=(const Matrix3x3& B)  // Composition
+{
+	OperatorTimesEquals(B);
+	return (*this);
+}
+
+inline AffineMapR3& AffineMapR3::operator*=(const Matrix3x4& B)  // Composition
+{
+	OperatorTimesEquals(B);
+	return (*this);
+}
+
+// **************************************************************
+// RotationMapR3 class (inlined functions)                      *
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * **
+
+inline RotationMapR3::RotationMapR3()
+{
+	SetIdentity();
+	return;
+}
+
+inline RotationMapR3::RotationMapR3(const VectorR3& u, const VectorR3& v,
+									const VectorR3& s)
+	: Matrix3x3(u, v, s)
+{
+}
+
+inline RotationMapR3::RotationMapR3(
+	double a11, double a21, double a31,
+	double a12, double a22, double a32,
+	double a13, double a23, double a33)
+	// Values specified in column order!!!
+	: Matrix3x3(a11, a21, a31, a12, a22, a32, a13, a23, a33)
+{
+}
+
+inline RotationMapR3 RotationMapR3::Inverse() const  // Returns inverse
+{
+	return (RotationMapR3(m11, m12, m13,  // In column order!
+						  m21, m22, m23,
+						  m31, m32, m33));
+}
+
+inline RotationMapR3& RotationMapR3::Invert()  // Converts into inverse.
+{
+	double temp;
+	temp = m12;
+	m12 = m21;
+	m21 = temp;
+	temp = m13;
+	m13 = m31;
+	m31 = temp;
+	temp = m23;
+	m23 = m32;
+	m32 = temp;
+	return (*this);
+}
+
+inline VectorR3 RotationMapR3::Solve(const VectorR3& u) const  // Returns solution
+{
+	return (VectorR3(m11 * u.x + m21 * u.y + m31 * u.z,
+					 m12 * u.x + m22 * u.y + m32 * u.z,
+					 m13 * u.x + m23 * u.y + m33 * u.z));
+}
+
+inline RotationMapR3& RotationMapR3::operator*=(const RotationMapR3& B)  // Matrix product
+{
+	OperatorTimesEquals(B);
+	return (*this);
+}
+
+// **************************************************************
+// RigidMapR3 class (inlined functions)		                    *
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * **
+
+inline RigidMapR3::RigidMapR3()
+{
+	SetIdentity();
+	return;
+}
+
+inline RigidMapR3::RigidMapR3(const VectorR3& u, const VectorR3& v,
+							  const VectorR3& s, const VectorR3& t)
+	: Matrix3x4(u, v, s, t)
+{
+}
+
+inline RigidMapR3::RigidMapR3(
+	double a11, double a21, double a31,
+	double a12, double a22, double a32,
+	double a13, double a23, double a33,
+	double a14, double a24, double a34)
+	// Values specified in column order!!!
+	: Matrix3x4(a11, a21, a31, a12, a22, a32, a13, a23, a33, a14, a24, a34)
+{
+}
+
+inline RigidMapR3::RigidMapR3(const Matrix3x3& A, const VectorR3& u)  // Set to RotationMap & Vector
+	: Matrix3x4(A, u)
+{
+}
+
+inline RigidMapR3& RigidMapR3::Set(const Matrix3x3& A, const VectorR3& u)  // Set to RotationMap & Vector
+{
+	Matrix3x4::Set(A, u);
+	return *this;
+}
+
+inline RigidMapR3& RigidMapR3::SetTranslationPart(const VectorR3& u)  // Set the translation part
+{
+	SetColumn4(u);
+	return *this;
+}
+
+inline RigidMapR3& RigidMapR3::SetTranslationPart(double x, double y, double z)  // Set the translation part
+{
+	SetColumn4(x, y, z);
+	return *this;
+}
+
+inline RigidMapR3& RigidMapR3::SetRotationPart(const Matrix3x3& A)  // Set the rotation part
+{
+	Matrix3x4::Set3x3(A);
+	return *this;
+}
+
+inline RigidMapR3& RigidMapR3::operator*=(const RotationMapR3& B)  // Composition
+{
+	OperatorTimesEquals(B);
+	return (*this);
+}
+
+inline RigidMapR3& RigidMapR3::operator*=(const RigidMapR3& B)  // Composition
+{
+	OperatorTimesEquals(B);
+	return (*this);
+}
+
+inline RigidMapR3 RigidMapR3::Inverse() const  // Returns inverse
+{
+	double new14 = -(m11 * m14 + m21 * m24 + m31 * m34);
+	double new24 = -(m12 * m14 + m22 * m24 + m32 * m34);
+	double new34 = -(m13 * m14 + m23 * m24 + m33 * m34);
+	return (RigidMapR3(m11, m12, m13,  // In column order!
+					   m21, m22, m23,
+					   m31, m32, m33,
+					   new14, new24, new34));
+}
+
+inline RigidMapR3& RigidMapR3::Invert()  // Converts into inverse.
+{
+	double new14 = -(m11 * m14 + m21 * m24 + m31 * m34);
+	double new24 = -(m12 * m14 + m22 * m24 + m32 * m34);
+	m34 = -(m13 * m14 + m23 * m24 + m33 * m34);
+	m14 = new14;
+	m24 = new24;
+
+	double temp;
+	temp = m12;
+	m12 = m21;
+	m21 = temp;
+	temp = m13;
+	m13 = m31;
+	m31 = temp;
+	temp = m23;
+	m23 = m32;
+	m32 = temp;
+	return (*this);
+}
+
+// ***************************************************************
+// * 3-space vector and matrix utilities (inlined functions)	 *
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+// Returns the projection of u onto unit v
+inline VectorR3 ProjectToUnit(const VectorR3& u, const VectorR3& v)
+{
+	return (u ^ v) * v;
+}
+
+// Returns the projection of u onto the plane perpindicular to the unit vector v
+inline VectorR3 ProjectPerpUnit(const VectorR3& u, const VectorR3& v)
+{
+	return (u - ((u ^ v) * v));
+}
+
+// Returns the projection of u onto the plane perpindicular to the unit vector v
+//    This one is more stable when u and v are nearly equal.
+inline VectorR3 ProjectPerpUnitDiff(const VectorR3& u, const VectorR3& v)
+{
+	VectorR3 ans = u;
+	ans -= v;
+	ans -= ((ans ^ v) * v);
+	return ans;  // ans = (u-v) - ((u-v)^v)*v
+}
+
+// VectorProjectMap returns map projecting onto a given vector u.
+//		u should be a unit vector (otherwise the returned map is
+//		scaled according to the magnitude of u.
+inline LinearMapR3 VectorProjectMap(const VectorR3& u)
+{
+	double a = u.x * u.y;
+	double b = u.x * u.z;
+	double c = u.y * u.z;
+	return (LinearMapR3(u.x * u.x, a, b,
+						a, u.y * u.y, c,
+						b, c, u.z * u.z));
+}
+
+// PlaneProjectMap returns map projecting onto a given plane.
+//		The plane is the plane orthognal to w.
+//		w must be a unit vector (otherwise the returned map is
+//		garbage).
+inline LinearMapR3 PlaneProjectMap(const VectorR3& w)
+{
+	double a = -w.x * w.y;
+	double b = -w.x * w.z;
+	double c = -w.y * w.z;
+	return (LinearMapR3(1.0 - w.x * w.x, a, b,
+						a, 1.0 - w.y * w.y, c,
+						b, c, 1.0 - w.z * w.z));
+}
+
+// PlaneProjectMap returns map projecting onto a given plane.
+//		The plane is the plane containing the two orthonormal vectors u,v.
+//		If u, v are orthonormal, this is a projection with scaling.
+//		If they are not orthonormal, the results are more difficult
+//		to interpret.
+inline LinearMapR3 PlaneProjectMap(const VectorR3& u, const VectorR3& v)
+{
+	double a = u.x * u.y + v.x * v.y;
+	double b = u.x * u.z + v.x * v.z;
+	double c = u.y * u.z + v.y * v.z;
+	return (LinearMapR3(u.x * u.x + v.x * v.x, a, b,
+						a, u.y * u.y + u.y * u.y, c,
+						b, c, u.z * u.z + v.z * v.z));
+}
+
+// Returns the solid angle between unit vectors v and w.
+inline double SolidAngle(const VectorR3& v, const VectorR3& w)
+{
+	return atan2((v * w).Norm(), v ^ w);
+}
+
+#endif
+
+// ******************* End of header material ********************
diff --git a/engine/inc/bullet/ThirdPartyLibs/BussIK/LinearR4.h b/engine/inc/bullet/ThirdPartyLibs/BussIK/LinearR4.h
new file mode 100644
index 00000000..4c033a9e
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/BussIK/LinearR4.h
@@ -0,0 +1,1171 @@
+/*
+*
+* Mathematics Subpackage (VrMath)
+*
+*
+* Author: Samuel R. Buss, sbuss@ucsd.edu.
+* Web page: http://math.ucsd.edu/~sbuss/MathCG
+*
+*
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*
+*
+*/
+
+//
+// Linear Algebra Classes over R4
+//
+//
+// A. Vector and Position classes
+//
+//    A.1. VectorR4: a column vector of length 4
+//
+// B. Matrix Classes
+//
+//	  B.1 LinearMapR4 - arbitrary linear map; 4x4 real matrix
+//
+//	  B.2 RotationMapR4 - orthonormal 4x4 matrix
+//
+
+#ifndef LINEAR_R4_H
+#define LINEAR_R4_H
+
+#include <math.h>
+#include <assert.h>
+#include <iostream>
+#include "LinearR3.h"
+using namespace std;
+
+class VectorR4;       // R4 Vector
+class LinearMapR4;    // 4x4 real matrix
+class RotationMapR4;  // 4x4 rotation map
+
+// **************************************
+// VectorR4 class                       *
+// * * * * * * * * * * * * * * * * * * **
+
+class VectorR4
+{
+public:
+	double x, y, z, w;  // The x & y & z & w coordinates.
+
+	static const VectorR4 Zero;
+	static const VectorR4 UnitX;
+	static const VectorR4 UnitY;
+	static const VectorR4 UnitZ;
+	static const VectorR4 UnitW;
+	static const VectorR4 NegUnitX;
+	static const VectorR4 NegUnitY;
+	static const VectorR4 NegUnitZ;
+	static const VectorR4 NegUnitW;
+
+public:
+	VectorR4() : x(0.0), y(0.0), z(0.0), w(0.0) {}
+	VectorR4(double xVal, double yVal, double zVal, double wVal)
+		: x(xVal), y(yVal), z(zVal), w(wVal) {}
+	VectorR4(const Quaternion& q);  // Definition with Quaternion routines
+
+	VectorR4& SetZero()
+	{
+		x = 0.0;
+		y = 0.0;
+		z = 0.0;
+		w = 0.0;
+		return *this;
+	}
+	VectorR4& Set(double xx, double yy, double zz, double ww)
+	{
+		x = xx;
+		y = yy;
+		z = zz;
+		w = ww;
+		return *this;
+	}
+	VectorR4& Set(const Quaternion&);  // Defined with Quaternion
+	VectorR4& Set(const VectorHgR3& h)
+	{
+		x = h.x;
+		y = h.y;
+		z = h.z;
+		w = h.w;
+		return *this;
+	}
+	VectorR4& Load(const double* v);
+	VectorR4& Load(const float* v);
+	void Dump(double* v) const;
+	void Dump(float* v) const;
+
+	VectorR4& operator+=(const VectorR4& v)
+	{
+		x += v.x;
+		y += v.y;
+		z += v.z;
+		w += v.w;
+		return (*this);
+	}
+	VectorR4& operator-=(const VectorR4& v)
+	{
+		x -= v.x;
+		y -= v.y;
+		z -= v.z;
+		w -= v.w;
+		return (*this);
+	}
+	VectorR4& operator*=(double m)
+	{
+		x *= m;
+		y *= m;
+		z *= m;
+		w *= m;
+		return (*this);
+	}
+	VectorR4& operator/=(double m)
+	{
+		double mInv = 1.0 / m;
+		x *= mInv;
+		y *= mInv;
+		z *= mInv;
+		w *= mInv;
+		return (*this);
+	}
+	VectorR4 operator-() const { return (VectorR4(-x, -y, -z, -w)); }
+	VectorR4& ArrayProd(const VectorR4&);   // Component-wise product
+	VectorR4& ArrayProd3(const VectorR3&);  // Component-wise product
+
+	VectorR4& AddScaled(const VectorR4& u, double s);
+
+	double Norm() const { return ((double)sqrt(x * x + y * y + z * z + w * w)); }
+	double NormSq() const { return (x * x + y * y + z * z + w * w); }
+	double Dist(const VectorR4& u) const;    // Distance from u
+	double DistSq(const VectorR4& u) const;  // Distance from u
+	double MaxAbs() const;
+	VectorR4& Normalize()
+	{
+		*this /= Norm();
+		return *this;
+	}                             // No error checking
+	inline VectorR4& MakeUnit();  // Normalize() with error checking
+	inline VectorR4& ReNormalize();
+	bool IsUnit() const
+	{
+		double norm = Norm();
+		return (1.000001 >= norm && norm >= 0.999999);
+	}
+	bool IsUnit(double tolerance) const
+	{
+		double norm = Norm();
+		return (1.0 + tolerance >= norm && norm >= 1.0 - tolerance);
+	}
+	bool IsZero() const { return (x == 0.0 && y == 0.0 && z == 0.0 && w == 0.0); }
+	bool NearZero(double tolerance) const { return (MaxAbs() <= tolerance); }
+	// tolerance should be non-negative
+
+	VectorR4& RotateUnitInDirection(const VectorR4& dir);  // rotate in direction dir
+};
+
+inline VectorR4 operator+(const VectorR4& u, const VectorR4& v);
+inline VectorR4 operator-(const VectorR4& u, const VectorR4& v);
+inline VectorR4 operator*(const VectorR4& u, double m);
+inline VectorR4 operator*(double m, const VectorR4& u);
+inline VectorR4 operator/(const VectorR4& u, double m);
+inline int operator==(const VectorR4& u, const VectorR4& v);
+
+inline double operator^(const VectorR4& u, const VectorR4& v);  // Dot Product
+inline VectorR4 ArrayProd(const VectorR4& u, const VectorR4& v);
+
+inline double Mag(const VectorR4& u) { return u.Norm(); }
+inline double Dist(const VectorR4& u, const VectorR4& v) { return u.Dist(v); }
+inline double DistSq(const VectorR4& u, const VectorR4& v) { return u.DistSq(v); }
+inline double NormalizeError(const VectorR4& u);
+
+// ********************************************************************
+// Matrix4x4     - base class for 4x4 matrices                        *
+// * * * * * * * * * * * * * * * * * * * * * **************************
+
+class Matrix4x4
+{
+public:
+	double m11, m12, m13, m14, m21, m22, m23, m24,
+		m31, m32, m33, m34, m41, m42, m43, m44;
+
+	// Implements a 4x4 matrix: m_i_j - row-i and column-j entry
+
+	static const Matrix4x4 Identity;
+
+public:
+	Matrix4x4();
+	Matrix4x4(const VectorR4&, const VectorR4&,
+			  const VectorR4&, const VectorR4&);  // Sets by columns!
+	Matrix4x4(double, double, double, double,
+			  double, double, double, double,
+			  double, double, double, double,
+			  double, double, double, double);  // Sets by columns
+
+	inline void SetIdentity();          // Set to the identity map
+	inline void SetZero();              // Set to the zero map
+	inline void Set(const Matrix4x4&);  // Set to the matrix.
+	inline void Set(const VectorR4&, const VectorR4&,
+					const VectorR4&, const VectorR4&);
+	inline void Set(double, double, double, double,
+					double, double, double, double,
+					double, double, double, double,
+					double, double, double, double);
+	inline void SetByRows(const VectorR4&, const VectorR4&,
+						  const VectorR4&, const VectorR4&);
+	inline void SetByRows(double, double, double, double,
+						  double, double, double, double,
+						  double, double, double, double,
+						  double, double, double, double);
+	inline void SetColumn1(double, double, double, double);
+	inline void SetColumn2(double, double, double, double);
+	inline void SetColumn3(double, double, double, double);
+	inline void SetColumn4(double, double, double, double);
+	inline void SetColumn1(const VectorR4&);
+	inline void SetColumn2(const VectorR4&);
+	inline void SetColumn3(const VectorR4&);
+	inline void SetColumn4(const VectorR4&);
+	inline VectorR4 Column1() const;
+	inline VectorR4 Column2() const;
+	inline VectorR4 Column3() const;
+	inline VectorR4 Column4() const;
+
+	inline void SetDiagonal(double, double, double, double);
+	inline void SetDiagonal(const VectorR4&);
+	inline double Diagonal(int);
+
+	inline void MakeTranspose();          // Transposes it.
+	void operator*=(const Matrix4x4& B);  // Matrix product
+
+	Matrix4x4& ReNormalize();
+};
+
+inline VectorR4 operator*(const Matrix4x4&, const VectorR4&);
+
+ostream& operator<<(ostream& os, const Matrix4x4& A);
+
+// *****************************************
+// LinearMapR4 class                       *
+// * * * * * * * * * * * * * * * * * * * * *
+
+class LinearMapR4 : public Matrix4x4
+{
+public:
+	LinearMapR4();
+	LinearMapR4(const VectorR4&, const VectorR4&,
+				const VectorR4&, const VectorR4&);  // Sets by columns!
+	LinearMapR4(double, double, double, double,
+				double, double, double, double,
+				double, double, double, double,
+				double, double, double, double);  // Sets by columns
+	LinearMapR4(const Matrix4x4&);
+
+	inline LinearMapR4& operator+=(const LinearMapR4&);
+	inline LinearMapR4& operator-=(const LinearMapR4&);
+	inline LinearMapR4& operator*=(double);
+	inline LinearMapR4& operator/=(double);
+	inline LinearMapR4& operator*=(const Matrix4x4&);  // Matrix product
+
+	inline LinearMapR4 Transpose() const;
+	double Determinant() const;             // Returns the determinant
+	LinearMapR4 Inverse() const;            // Returns inverse
+	LinearMapR4& Invert();                  // Converts into inverse.
+	VectorR4 Solve(const VectorR4&) const;  // Returns solution
+	LinearMapR4 PseudoInverse() const;      // Returns pseudo-inverse TO DO
+	VectorR4 PseudoSolve(const VectorR4&);  // Finds least squares solution TO DO
+};
+
+inline LinearMapR4 operator+(const LinearMapR4&, const LinearMapR4&);
+inline LinearMapR4 operator-(const LinearMapR4&);
+inline LinearMapR4 operator-(const LinearMapR4&, const LinearMapR4&);
+inline LinearMapR4 operator*(const LinearMapR4&, double);
+inline LinearMapR4 operator*(double, const LinearMapR4&);
+inline LinearMapR4 operator/(const LinearMapR4&, double);
+inline LinearMapR4 operator*(const Matrix4x4&, const LinearMapR4&);
+inline LinearMapR4 operator*(const LinearMapR4&, const Matrix4x4&);
+// Matrix product (composition)
+
+// *******************************************
+// RotationMapR4 class                        *
+// * * * * * * * * * * * * * * * * * * * * * *
+
+class RotationMapR4 : public Matrix4x4
+{
+public:
+	RotationMapR4();
+	RotationMapR4(const VectorR4&, const VectorR4&,
+				  const VectorR4&, const VectorR4&);  // Sets by columns!
+	RotationMapR4(double, double, double, double,
+				  double, double, double, double,
+				  double, double, double, double,
+				  double, double, double, double);  // Sets by columns!
+
+	RotationMapR4& SetZero();  // IT IS AN ERROR TO USE THIS FUNCTION!
+
+	inline RotationMapR4& operator*=(const RotationMapR4&);  // Matrix product
+
+	inline RotationMapR4 Transpose() const;
+	inline RotationMapR4 Inverse() const { return Transpose(); };  // Returns the transpose
+	inline RotationMapR4& Invert()
+	{
+		MakeTranspose();
+		return *this;
+	};                                              // Transposes it.
+	inline VectorR4 Invert(const VectorR4&) const;  // Returns solution
+};
+
+inline RotationMapR4 operator*(const RotationMapR4&, const RotationMapR4&);
+// Matrix product (composition)
+
+// ***************************************************************
+// * 4-space vector and matrix utilities (prototypes)			 *
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+// Returns the angle between vectors u and v.
+//		Use SolidAngleUnit if both vectors are unit vectors
+inline double SolidAngle(const VectorR4& u, const VectorR4& v);
+inline double SolidAngleUnit(const VectorR4 u, const VectorR4 v);
+
+// Returns a righthanded orthonormal basis to complement vectors u,v,w.
+//		The vectors u,v,w must be unit and orthonormal.
+void GetOrtho(const VectorR4& u, RotationMapR4& rotmap);
+void GetOrtho(const VectorR4& u, const VectorR4& v, RotationMapR4& rotmap);
+void GetOrtho(const VectorR4& u, const VectorR4& v, const VectorR4& w,
+			  RotationMapR4& rotmap);
+void GetOrtho(int j, RotationMapR4& rotmap);  // Mainly for internal use
+
+// Projections
+
+inline VectorR4 ProjectToUnit(const VectorR4& u, const VectorR4& v);
+// Project u onto v
+inline VectorR4 ProjectPerpUnit(const VectorR4& u, const VectorR4& v);
+// Project perp to v
+inline VectorR4 ProjectPerpUnitDiff(const VectorR4& u, const VectorR4& v);
+// v must be a unit vector.
+
+// Returns the projection of u onto unit v
+inline VectorR4 ProjectToUnit(const VectorR4& u, const VectorR4& v)
+{
+	return (u ^ v) * v;
+}
+
+// Returns the projection of u onto the plane perpindicular to the unit vector v
+inline VectorR4 ProjectPerpUnit(const VectorR4& u, const VectorR4& v)
+{
+	return (u - ((u ^ v) * v));
+}
+
+// Returns the projection of u onto the plane perpindicular to the unit vector v
+//    This one is more stable when u and v are nearly equal.
+inline VectorR4 ProjectPerpUnitDiff(const VectorR4& u, const VectorR4& v)
+{
+	VectorR4 ans = u;
+	ans -= v;
+	ans -= ((ans ^ v) * v);
+	return ans;  // ans = (u-v) - ((u-v)^v)*v
+}
+
+// Projection maps (LinearMapR4's)
+
+// VectorProjectMap returns map projecting onto a given vector u.
+//		u should be a unit vector (otherwise the returned map is
+//		scaled according to the magnitude of u.
+inline void VectorProjectMap(const VectorR4& u, LinearMapR4& M)
+{
+	double a = u.x * u.y;
+	double b = u.x * u.z;
+	double c = u.x * u.w;
+	double d = u.y * u.z;
+	double e = u.y * u.w;
+	double f = u.z * u.w;
+	M.Set(u.x * u.x, a, b, c,
+		  a, u.y * u.y, d, e,
+		  b, d, u.z * u.z, f,
+		  c, e, f, u.w * u.w);
+}
+
+inline LinearMapR4 VectorProjectMap(const VectorR4& u)
+{
+	LinearMapR4 result;
+	VectorProjectMap(u, result);
+	return result;
+}
+
+inline LinearMapR4 PerpProjectMap(const VectorR4& u);
+// u - must be unit vector.
+
+LinearMapR4 TimesTranspose(const VectorR4& u, const VectorR4& v);  // u * v^T.
+inline void TimesTranspose(const VectorR4& u, const VectorR4& v, LinearMapR4& M);
+
+// Rotation Maps
+
+RotationMapR4 RotateToMap(const VectorR4& fromVec, const VectorR4& toVec);
+// fromVec and toVec should be unit vectors
+
+// ***************************************************************
+// * Stream Output Routines	(Prototypes)						 *
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ostream& operator<<(ostream& os, const VectorR4& u);
+
+// *****************************************************
+// * VectorR4 class - inlined functions				   *
+// * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+inline VectorR4& VectorR4::Load(const double* v)
+{
+	x = *v;
+	y = *(v + 1);
+	z = *(v + 2);
+	w = *(v + 3);
+	return *this;
+}
+
+inline VectorR4& VectorR4::Load(const float* v)
+{
+	x = *v;
+	y = *(v + 1);
+	z = *(v + 2);
+	w = *(v + 3);
+	return *this;
+}
+
+inline void VectorR4::Dump(double* v) const
+{
+	*v = x;
+	*(v + 1) = y;
+	*(v + 2) = z;
+	*(v + 3) = w;
+}
+
+inline void VectorR4::Dump(float* v) const
+{
+	*v = (float)x;
+	*(v + 1) = (float)y;
+	*(v + 2) = (float)z;
+	*(v + 3) = (float)w;
+}
+
+inline VectorR4& VectorR4::MakeUnit()  // Convert to unit vector (or leave zero).
+{
+	double nSq = NormSq();
+	if (nSq != 0.0)
+	{
+		*this /= sqrt(nSq);
+	}
+	return *this;
+}
+
+inline VectorR4 operator+(const VectorR4& u, const VectorR4& v)
+{
+	return VectorR4(u.x + v.x, u.y + v.y, u.z + v.z, u.w + v.w);
+}
+inline VectorR4 operator-(const VectorR4& u, const VectorR4& v)
+{
+	return VectorR4(u.x - v.x, u.y - v.y, u.z - v.z, u.w - v.w);
+}
+inline VectorR4 operator*(const VectorR4& u, double m)
+{
+	return VectorR4(u.x * m, u.y * m, u.z * m, u.w * m);
+}
+inline VectorR4 operator*(double m, const VectorR4& u)
+{
+	return VectorR4(u.x * m, u.y * m, u.z * m, u.w * m);
+}
+inline VectorR4 operator/(const VectorR4& u, double m)
+{
+	double mInv = 1.0 / m;
+	return VectorR4(u.x * mInv, u.y * mInv, u.z * mInv, u.w * mInv);
+}
+
+inline int operator==(const VectorR4& u, const VectorR4& v)
+{
+	return (u.x == v.x && u.y == v.y && u.z == v.z && u.w == v.w);
+}
+
+inline double operator^(const VectorR4& u, const VectorR4& v)  // Dot Product
+{
+	return (u.x * v.x + u.y * v.y + u.z * v.z + u.w * v.w);
+}
+
+inline VectorR4 ArrayProd(const VectorR4& u, const VectorR4& v)
+{
+	return (VectorR4(u.x * v.x, u.y * v.y, u.z * v.z, u.w * v.w));
+}
+
+inline VectorR4& VectorR4::ArrayProd(const VectorR4& v)  // Component-wise Product
+{
+	x *= v.x;
+	y *= v.y;
+	z *= v.z;
+	w *= v.w;
+	return (*this);
+}
+
+inline VectorR4& VectorR4::ArrayProd3(const VectorR3& v)  // Component-wise Product
+{
+	x *= v.x;
+	y *= v.y;
+	z *= v.z;
+	return (*this);
+}
+
+inline VectorR4& VectorR4::AddScaled(const VectorR4& u, double s)
+{
+	x += s * u.x;
+	y += s * u.y;
+	z += s * u.z;
+	w += s * u.w;
+	return (*this);
+}
+
+inline VectorR4& VectorR4::ReNormalize()  // Convert near unit back to unit
+{
+	double nSq = NormSq();
+	double mFact = 1.0 - 0.5 * (nSq - 1.0);  // Multiplicative factor
+	*this *= mFact;
+	return *this;
+}
+
+inline double NormalizeError(const VectorR4& u)
+{
+	double discrepancy;
+	discrepancy = u.x * u.x + u.y * u.y + u.z * u.z + u.w * u.w - 1.0;
+	if (discrepancy < 0.0)
+	{
+		discrepancy = -discrepancy;
+	}
+	return discrepancy;
+}
+
+inline VectorR3& VectorR3::SetFromHg(const VectorR4& v)
+{
+	double wInv = 1.0 / v.w;
+	x = v.x * wInv;
+	y = v.y * wInv;
+	z = v.z * wInv;
+	return *this;
+}
+
+inline double VectorR4::Dist(const VectorR4& u) const  // Distance from u
+{
+	return sqrt(DistSq(u));
+}
+
+inline double VectorR4::DistSq(const VectorR4& u) const  // Distance from u
+{
+	return ((x - u.x) * (x - u.x) + (y - u.y) * (y - u.y) + (z - u.z) * (z - u.z) + (w - u.w) * (w - u.w));
+}
+
+// *********************************************************
+// * Matrix4x4 class - inlined functions				   *
+// * * * * * * * * * * * * * * * * * * * * * * * * * * *****
+
+inline Matrix4x4::Matrix4x4() {}
+
+inline Matrix4x4::Matrix4x4(const VectorR4& u, const VectorR4& v,
+							const VectorR4& s, const VectorR4& t)
+{
+	m11 = u.x;  // Column 1
+	m21 = u.y;
+	m31 = u.z;
+	m41 = u.w;
+	m12 = v.x;  // Column 2
+	m22 = v.y;
+	m32 = v.z;
+	m42 = v.w;
+	m13 = s.x;  // Column 3
+	m23 = s.y;
+	m33 = s.z;
+	m43 = s.w;
+	m14 = t.x;  // Column 4
+	m24 = t.y;
+	m34 = t.z;
+	m44 = t.w;
+}
+
+inline Matrix4x4::Matrix4x4(double a11, double a21, double a31, double a41,
+							double a12, double a22, double a32, double a42,
+							double a13, double a23, double a33, double a43,
+							double a14, double a24, double a34, double a44)
+// Values specified in column order!!!
+{
+	m11 = a11;  // Row 1
+	m12 = a12;
+	m13 = a13;
+	m14 = a14;
+	m21 = a21;  // Row 2
+	m22 = a22;
+	m23 = a23;
+	m24 = a24;
+	m31 = a31;  // Row 3
+	m32 = a32;
+	m33 = a33;
+	m34 = a34;
+	m41 = a41;  // Row 4
+	m42 = a42;
+	m43 = a43;
+	m44 = a44;
+}
+
+/*
+inline Matrix4x4::Matrix4x4 ( const Matrix4x4& A)
+	: m11(A.m11), m12(A.m12), m13(A.m13), m14(A.m14),
+	  m21(A.m21), m22(A.m22), m23(A.m23), m24(A.m24),
+	  m31(A.m31), m32(A.m32), m33(A.m33), m34(A.m34),
+	  m41(A.m41), m42(A.m42), m43(A.m43), m44(A.m44) {} */
+
+inline void Matrix4x4::SetIdentity()
+{
+	m12 = m13 = m14 =
+		m21 = m23 = m24 =
+			m31 = m32 = m34 =
+				m41 = m42 = m43 = 0.0;
+	m11 = m22 = m33 = m44 = 1.0;
+}
+
+inline void Matrix4x4::Set(const VectorR4& u, const VectorR4& v,
+						   const VectorR4& s, const VectorR4& t)
+{
+	m11 = u.x;  // Column 1
+	m21 = u.y;
+	m31 = u.z;
+	m41 = u.w;
+	m12 = v.x;  // Column 2
+	m22 = v.y;
+	m32 = v.z;
+	m42 = v.w;
+	m13 = s.x;  // Column 3
+	m23 = s.y;
+	m33 = s.z;
+	m43 = s.w;
+	m14 = t.x;  // Column 4
+	m24 = t.y;
+	m34 = t.z;
+	m44 = t.w;
+}
+
+inline void Matrix4x4::Set(double a11, double a21, double a31, double a41,
+						   double a12, double a22, double a32, double a42,
+						   double a13, double a23, double a33, double a43,
+						   double a14, double a24, double a34, double a44)
+// Values specified in column order!!!
+{
+	m11 = a11;  // Row 1
+	m12 = a12;
+	m13 = a13;
+	m14 = a14;
+	m21 = a21;  // Row 2
+	m22 = a22;
+	m23 = a23;
+	m24 = a24;
+	m31 = a31;  // Row 3
+	m32 = a32;
+	m33 = a33;
+	m34 = a34;
+	m41 = a41;  // Row 4
+	m42 = a42;
+	m43 = a43;
+	m44 = a44;
+}
+
+inline void Matrix4x4::Set(const Matrix4x4& M)  // Set to the matrix.
+{
+	m11 = M.m11;
+	m12 = M.m12;
+	m13 = M.m13;
+	m14 = M.m14;
+	m21 = M.m21;
+	m22 = M.m22;
+	m23 = M.m23;
+	m24 = M.m24;
+	m31 = M.m31;
+	m32 = M.m32;
+	m33 = M.m33;
+	m34 = M.m34;
+	m41 = M.m41;
+	m42 = M.m42;
+	m43 = M.m43;
+	m44 = M.m44;
+}
+
+inline void Matrix4x4::SetZero()
+{
+	m11 = m12 = m13 = m14 = m21 = m22 = m23 = m24 = m31 = m32 = m33 = m34 = m41 = m42 = m43 = m44 = 0.0;
+}
+
+inline void Matrix4x4::SetByRows(const VectorR4& u, const VectorR4& v,
+								 const VectorR4& s, const VectorR4& t)
+{
+	m11 = u.x;  // Row 1
+	m12 = u.y;
+	m13 = u.z;
+	m14 = u.w;
+	m21 = v.x;  // Row 2
+	m22 = v.y;
+	m23 = v.z;
+	m24 = v.w;
+	m31 = s.x;  // Row 3
+	m32 = s.y;
+	m33 = s.z;
+	m34 = s.w;
+	m41 = t.x;  // Row 4
+	m42 = t.y;
+	m43 = t.z;
+	m44 = t.w;
+}
+
+inline void Matrix4x4::SetByRows(double a11, double a12, double a13, double a14,
+								 double a21, double a22, double a23, double a24,
+								 double a31, double a32, double a33, double a34,
+								 double a41, double a42, double a43, double a44)
+// Values specified in row order!!!
+{
+	m11 = a11;  // Row 1
+	m12 = a12;
+	m13 = a13;
+	m14 = a14;
+	m21 = a21;  // Row 2
+	m22 = a22;
+	m23 = a23;
+	m24 = a24;
+	m31 = a31;  // Row 3
+	m32 = a32;
+	m33 = a33;
+	m34 = a34;
+	m41 = a41;  // Row 4
+	m42 = a42;
+	m43 = a43;
+	m44 = a44;
+}
+
+inline void Matrix4x4::SetColumn1(double x, double y, double z, double w)
+{
+	m11 = x;
+	m21 = y;
+	m31 = z;
+	m41 = w;
+}
+
+inline void Matrix4x4::SetColumn2(double x, double y, double z, double w)
+{
+	m12 = x;
+	m22 = y;
+	m32 = z;
+	m42 = w;
+}
+
+inline void Matrix4x4::SetColumn3(double x, double y, double z, double w)
+{
+	m13 = x;
+	m23 = y;
+	m33 = z;
+	m43 = w;
+}
+
+inline void Matrix4x4::SetColumn4(double x, double y, double z, double w)
+{
+	m14 = x;
+	m24 = y;
+	m34 = z;
+	m44 = w;
+}
+
+inline void Matrix4x4::SetColumn1(const VectorR4& u)
+{
+	m11 = u.x;
+	m21 = u.y;
+	m31 = u.z;
+	m41 = u.w;
+}
+
+inline void Matrix4x4::SetColumn2(const VectorR4& u)
+{
+	m12 = u.x;
+	m22 = u.y;
+	m32 = u.z;
+	m42 = u.w;
+}
+
+inline void Matrix4x4::SetColumn3(const VectorR4& u)
+{
+	m13 = u.x;
+	m23 = u.y;
+	m33 = u.z;
+	m43 = u.w;
+}
+
+inline void Matrix4x4::SetColumn4(const VectorR4& u)
+{
+	m14 = u.x;
+	m24 = u.y;
+	m34 = u.z;
+	m44 = u.w;
+}
+
+VectorR4 Matrix4x4::Column1() const
+{
+	return (VectorR4(m11, m21, m31, m41));
+}
+
+VectorR4 Matrix4x4::Column2() const
+{
+	return (VectorR4(m12, m22, m32, m42));
+}
+
+VectorR4 Matrix4x4::Column3() const
+{
+	return (VectorR4(m13, m23, m33, m43));
+}
+
+VectorR4 Matrix4x4::Column4() const
+{
+	return (VectorR4(m14, m24, m34, m44));
+}
+
+inline void Matrix4x4::SetDiagonal(double x, double y,
+								   double z, double w)
+{
+	m11 = x;
+	m22 = y;
+	m33 = z;
+	m44 = w;
+}
+
+inline void Matrix4x4::SetDiagonal(const VectorR4& u)
+{
+	SetDiagonal(u.x, u.y, u.z, u.w);
+}
+
+inline double Matrix4x4::Diagonal(int i)
+{
+	switch (i)
+	{
+		case 0:
+			return m11;
+		case 1:
+			return m22;
+		case 2:
+			return m33;
+		case 3:
+			return m44;
+		default:
+			assert(0);
+			return 0.0;
+	}
+}
+
+inline void Matrix4x4::MakeTranspose()  // Transposes it.
+{
+	double temp;
+	temp = m12;
+	m12 = m21;
+	m21 = temp;
+	temp = m13;
+	m13 = m31;
+	m31 = temp;
+	temp = m14;
+	m14 = m41;
+	m41 = temp;
+	temp = m23;
+	m23 = m32;
+	m32 = temp;
+	temp = m24;
+	m24 = m42;
+	m42 = temp;
+	temp = m34;
+	m34 = m43;
+	m43 = temp;
+}
+
+inline VectorR4 operator*(const Matrix4x4& A, const VectorR4& u)
+{
+	VectorR4 ret;
+	ret.x = A.m11 * u.x + A.m12 * u.y + A.m13 * u.z + A.m14 * u.w;
+	ret.y = A.m21 * u.x + A.m22 * u.y + A.m23 * u.z + A.m24 * u.w;
+	ret.z = A.m31 * u.x + A.m32 * u.y + A.m33 * u.z + A.m34 * u.w;
+	ret.w = A.m41 * u.x + A.m42 * u.y + A.m43 * u.z + A.m44 * u.w;
+	return ret;
+}
+
+// ******************************************************
+// * LinearMapR4 class - inlined functions				*
+// * * * * * * * * * * * * * * * * * * * * * * * * * * **
+
+inline LinearMapR4::LinearMapR4()
+{
+	SetZero();
+	return;
+}
+
+inline LinearMapR4::LinearMapR4(const VectorR4& u, const VectorR4& v,
+								const VectorR4& s, const VectorR4& t)
+	: Matrix4x4(u, v, s, t)
+{
+}
+
+inline LinearMapR4::LinearMapR4(
+	double a11, double a21, double a31, double a41,
+	double a12, double a22, double a32, double a42,
+	double a13, double a23, double a33, double a43,
+	double a14, double a24, double a34, double a44)
+	// Values specified in column order!!!
+	: Matrix4x4(a11, a21, a31, a41, a12, a22, a32, a42,
+				a13, a23, a33, a43, a14, a24, a34, a44)
+{
+}
+
+inline LinearMapR4::LinearMapR4(const Matrix4x4& A)
+	: Matrix4x4(A)
+{
+}
+
+inline LinearMapR4& LinearMapR4::operator+=(const LinearMapR4& B)
+{
+	m11 += B.m11;
+	m12 += B.m12;
+	m13 += B.m13;
+	m14 += B.m14;
+	m21 += B.m21;
+	m22 += B.m22;
+	m23 += B.m23;
+	m24 += B.m24;
+	m31 += B.m31;
+	m32 += B.m32;
+	m33 += B.m33;
+	m34 += B.m34;
+	m41 += B.m41;
+	m42 += B.m42;
+	m43 += B.m43;
+	m44 += B.m44;
+	return (*this);
+}
+
+inline LinearMapR4& LinearMapR4::operator-=(const LinearMapR4& B)
+{
+	m11 -= B.m11;
+	m12 -= B.m12;
+	m13 -= B.m13;
+	m14 -= B.m14;
+	m21 -= B.m21;
+	m22 -= B.m22;
+	m23 -= B.m23;
+	m24 -= B.m24;
+	m31 -= B.m31;
+	m32 -= B.m32;
+	m33 -= B.m33;
+	m34 -= B.m34;
+	m41 -= B.m41;
+	m42 -= B.m42;
+	m43 -= B.m43;
+	m44 -= B.m44;
+	return (*this);
+}
+
+inline LinearMapR4 operator+(const LinearMapR4& A, const LinearMapR4& B)
+{
+	return (LinearMapR4(A.m11 + B.m11, A.m21 + B.m21, A.m31 + B.m31, A.m41 + B.m41,
+						A.m12 + B.m12, A.m22 + B.m22, A.m32 + B.m32, A.m42 + B.m42,
+						A.m13 + B.m13, A.m23 + B.m23, A.m33 + B.m33, A.m43 + B.m43,
+						A.m14 + B.m14, A.m24 + B.m24, A.m34 + B.m34, A.m44 + B.m44));
+}
+
+inline LinearMapR4 operator-(const LinearMapR4& A)
+{
+	return (LinearMapR4(-A.m11, -A.m21, -A.m31, -A.m41,
+						-A.m12, -A.m22, -A.m32, -A.m42,
+						-A.m13, -A.m23, -A.m33, -A.m43,
+						-A.m14, -A.m24, -A.m34, -A.m44));
+}
+
+inline LinearMapR4 operator-(const LinearMapR4& A, const LinearMapR4& B)
+{
+	return (LinearMapR4(A.m11 - B.m11, A.m21 - B.m21, A.m31 - B.m31, A.m41 - B.m41,
+						A.m12 - B.m12, A.m22 - B.m22, A.m32 - B.m32, A.m42 - B.m42,
+						A.m13 - B.m13, A.m23 - B.m23, A.m33 - B.m33, A.m43 - B.m43,
+						A.m14 - B.m14, A.m24 - B.m24, A.m34 - B.m34, A.m44 - B.m44));
+}
+
+inline LinearMapR4& LinearMapR4::operator*=(double b)
+{
+	m11 *= b;
+	m12 *= b;
+	m13 *= b;
+	m14 *= b;
+	m21 *= b;
+	m22 *= b;
+	m23 *= b;
+	m24 *= b;
+	m31 *= b;
+	m32 *= b;
+	m33 *= b;
+	m34 *= b;
+	m41 *= b;
+	m42 *= b;
+	m43 *= b;
+	m44 *= b;
+	return (*this);
+}
+
+inline LinearMapR4 operator*(const LinearMapR4& A, double b)
+{
+	return (LinearMapR4(A.m11 * b, A.m21 * b, A.m31 * b, A.m41 * b,
+						A.m12 * b, A.m22 * b, A.m32 * b, A.m42 * b,
+						A.m13 * b, A.m23 * b, A.m33 * b, A.m43 * b,
+						A.m14 * b, A.m24 * b, A.m34 * b, A.m44 * b));
+}
+
+inline LinearMapR4 operator*(double b, const LinearMapR4& A)
+{
+	return (LinearMapR4(A.m11 * b, A.m21 * b, A.m31 * b, A.m41 * b,
+						A.m12 * b, A.m22 * b, A.m32 * b, A.m42 * b,
+						A.m13 * b, A.m23 * b, A.m33 * b, A.m43 * b,
+						A.m14 * b, A.m24 * b, A.m34 * b, A.m44 * b));
+}
+
+inline LinearMapR4 operator/(const LinearMapR4& A, double b)
+{
+	double bInv = 1.0 / b;
+	return (A * bInv);
+}
+
+inline LinearMapR4& LinearMapR4::operator/=(double b)
+{
+	double bInv = 1.0 / b;
+	return (*this *= bInv);
+}
+
+inline VectorR4 operator*(const LinearMapR4& A, const VectorR4& u)
+{
+	return (VectorR4(A.m11 * u.x + A.m12 * u.y + A.m13 * u.z + A.m14 * u.w,
+					 A.m21 * u.x + A.m22 * u.y + A.m23 * u.z + A.m24 * u.w,
+					 A.m31 * u.x + A.m32 * u.y + A.m33 * u.z + A.m34 * u.w,
+					 A.m41 * u.x + A.m42 * u.y + A.m43 * u.z + A.m44 * u.w));
+}
+
+inline LinearMapR4 LinearMapR4::Transpose() const  // Returns the transpose
+{
+	return (LinearMapR4(m11, m12, m13, m14,
+						m21, m22, m23, m24,
+						m31, m32, m33, m34,
+						m41, m42, m43, m44));
+}
+
+inline LinearMapR4& LinearMapR4::operator*=(const Matrix4x4& B)  // Matrix product
+{
+	(*this).Matrix4x4::operator*=(B);
+
+	return (*this);
+}
+
+inline LinearMapR4 operator*(const LinearMapR4& A, const Matrix4x4& B)
+{
+	LinearMapR4 AA(A);
+	AA.Matrix4x4::operator*=(B);
+	return AA;
+}
+
+inline LinearMapR4 operator*(const Matrix4x4& A, const LinearMapR4& B)
+{
+	LinearMapR4 AA(A);
+	AA.Matrix4x4::operator*=(B);
+	return AA;
+}
+
+// ******************************************************
+// * RotationMapR4 class - inlined functions			*
+// * * * * * * * * * * * * * * * * * * * * * * * * * * **
+
+inline RotationMapR4::RotationMapR4()
+{
+	SetIdentity();
+	return;
+}
+
+inline RotationMapR4::RotationMapR4(const VectorR4& u, const VectorR4& v,
+									const VectorR4& s, const VectorR4& t)
+	: Matrix4x4(u, v, s, t)
+{
+}
+
+inline RotationMapR4::RotationMapR4(
+	double a11, double a21, double a31, double a41,
+	double a12, double a22, double a32, double a42,
+	double a13, double a23, double a33, double a43,
+	double a14, double a24, double a34, double a44)
+	// Values specified in column order!!!
+	: Matrix4x4(a11, a21, a31, a41, a12, a22, a32, a42,
+				a13, a23, a33, a43, a14, a24, a34, a44)
+{
+}
+
+inline RotationMapR4 RotationMapR4::Transpose() const  // Returns the transpose
+{
+	return (RotationMapR4(m11, m12, m13, m14,
+						  m21, m22, m23, m24,
+						  m31, m32, m33, m34,
+						  m41, m42, m43, m44));
+}
+
+inline VectorR4 RotationMapR4::Invert(const VectorR4& u) const  // Returns solution
+{
+	return (VectorR4(m11 * u.x + m21 * u.y + m31 * u.z + m41 * u.w,
+					 m12 * u.x + m22 * u.y + m32 * u.z + m42 * u.w,
+					 m13 * u.x + m23 * u.y + m33 * u.z + m43 * u.w,
+					 m14 * u.x + m24 * u.y + m34 * u.z + m44 * u.w));
+}
+
+inline RotationMapR4& RotationMapR4::operator*=(const RotationMapR4& B)  // Matrix product
+{
+	(*this).Matrix4x4::operator*=(B);
+
+	return (*this);
+}
+
+inline RotationMapR4 operator*(const RotationMapR4& A, const RotationMapR4& B)
+{
+	RotationMapR4 AA(A);
+	AA.Matrix4x4::operator*=(B);
+	return AA;
+}
+
+// ***************************************************************
+// * 4-space vector and matrix utilities (inlined functions)	 *
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+inline void TimesTranspose(const VectorR4& u, const VectorR4& v, LinearMapR4& M)
+{
+	M.Set(v.x * u.x, v.x * u.y, v.x * u.z, v.x * u.w,  // Set by columns!
+		  v.y * u.x, v.y * u.y, v.y * u.z, v.y * u.w,
+		  v.z * u.x, v.z * u.y, v.z * u.z, v.z * u.w,
+		  v.w * u.x, v.w * u.y, v.w * u.z, v.w * u.w);
+}
+
+// Returns the solid angle between vectors u and v (not necessarily unit vectors)
+inline double SolidAngle(const VectorR4& u, const VectorR4& v)
+{
+	double nSqU = u.NormSq();
+	double nSqV = v.NormSq();
+	if (nSqU == 0.0 && nSqV == 0.0)
+	{
+		return (0.0);
+	}
+	else
+	{
+		return (SolidAngleUnit(u / sqrt(nSqU), v / sqrt(nSqV)));
+	}
+}
+
+inline double SolidAngleUnit(const VectorR4 u, const VectorR4 v)
+{
+	return (atan2(ProjectPerpUnit(v, u).Norm(), u ^ v));
+}
+
+#endif  // LINEAR_R4_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/BussIK/MathMisc.h b/engine/inc/bullet/ThirdPartyLibs/BussIK/MathMisc.h
new file mode 100644
index 00000000..c5d15715
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/BussIK/MathMisc.h
@@ -0,0 +1,447 @@
+/*
+*
+* Mathematics Subpackage (VrMath)
+*
+*
+* Author: Samuel R. Buss, sbuss@ucsd.edu.
+* Web page: http://math.ucsd.edu/~sbuss/MathCG
+*
+*
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*
+*
+*/
+
+#ifndef MATH_MISC_H
+#define MATH_MISC_H
+
+#include <math.h>
+
+//
+// Commonly used constants
+//
+
+const double PI = 3.1415926535897932384626433832795028841972;
+const double PI2 = 2.0 * PI;
+const double PI4 = 4.0 * PI;
+const double PISq = PI * PI;
+const double PIhalves = 0.5 * PI;
+const double PIthirds = PI / 3.0;
+const double PItwothirds = PI2 / 3.0;
+const double PIfourths = 0.25 * PI;
+const double PIsixths = PI / 6.0;
+const double PIsixthsSq = PIsixths * PIsixths;
+const double PItwelfths = PI / 12.0;
+const double PItwelfthsSq = PItwelfths * PItwelfths;
+const double PIinv = 1.0 / PI;
+const double PI2inv = 0.5 / PI;
+const double PIhalfinv = 2.0 / PI;
+
+const double RadiansToDegrees = 180.0 / PI;
+const double DegreesToRadians = PI / 180;
+
+const double OneThird = 1.0 / 3.0;
+const double TwoThirds = 2.0 / 3.0;
+const double OneSixth = 1.0 / 6.0;
+const double OneEighth = 1.0 / 8.0;
+const double OneTwelfth = 1.0 / 12.0;
+
+const double Root2 = sqrt(2.0);
+const double Root3 = sqrt(3.0);
+const double Root2Inv = 1.0 / Root2;  // sqrt(2)/2
+const double HalfRoot3 = sqrtf(3) / 2.0;
+
+const double LnTwo = log(2.0);
+const double LnTwoInv = 1.0 / log(2.0);
+
+// Special purpose constants
+const double OnePlusEpsilon15 = 1.0 + 1.0e-15;
+const double OneMinusEpsilon15 = 1.0 - 1.0e-15;
+
+inline double ZeroValue(const double& x)
+{
+	return 0.0;
+}
+
+//
+// Comparisons
+//
+
+template <class T>
+inline T Min(T x, T y)
+{
+	return (x < y ? x : y);
+}
+
+template <class T>
+inline T Max(T x, T y)
+{
+	return (y < x ? x : y);
+}
+
+template <class T>
+inline T ClampRange(T x, T min, T max)
+{
+	if (x < min)
+	{
+		return min;
+	}
+	if (x > max)
+	{
+		return max;
+	}
+	return x;
+}
+
+template <class T>
+inline bool ClampRange(T* x, T min, T max)
+{
+	if ((*x) < min)
+	{
+		(*x) = min;
+		return false;
+	}
+	else if ((*x) > max)
+	{
+		(*x) = max;
+		return false;
+	}
+	else
+	{
+		return true;
+	}
+}
+
+template <class T>
+inline bool ClampMin(T* x, T min)
+{
+	if ((*x) < min)
+	{
+		(*x) = min;
+		return false;
+	}
+	return true;
+}
+
+template <class T>
+inline bool ClampMax(T* x, T max)
+{
+	if ((*x) > max)
+	{
+		(*x) = max;
+		return false;
+	}
+	return true;
+}
+
+template <class T>
+inline T& UpdateMin(const T& x, T& y)
+{
+	if (x < y)
+	{
+		y = x;
+	}
+	return y;
+}
+
+template <class T>
+inline T& UpdateMax(const T& x, T& y)
+{
+	if (x > y)
+	{
+		y = x;
+	}
+	return y;
+}
+
+template <class T>
+inline bool SameSignNonzero(T x, T y)
+{
+	if (x < 0)
+	{
+		return (y < 0);
+	}
+	else if (0 < x)
+	{
+		return (0 < y);
+	}
+	else
+	{
+		return false;
+	}
+}
+
+inline double Mag(double x)
+{
+	return fabs(x);
+}
+
+inline double Dist(double x, double y)
+{
+	return fabs(x - y);
+}
+
+template <class T>
+inline bool NearEqual(T a, T b, double tolerance)
+{
+	a -= b;
+	return (Mag(a) <= tolerance);
+}
+
+inline bool EqualZeroFuzzy(double x)
+{
+	return (fabs(x) <= 1.0e-14);
+}
+
+inline bool NearZero(double x, double tolerance)
+{
+	return (fabs(x) <= tolerance);
+}
+
+inline bool LessOrEqualFuzzy(double x, double y)
+{
+	if (x <= y)
+	{
+		return true;
+	}
+
+	if (y > 0.0)
+	{
+		if (x > 0.0)
+		{
+			return (x * OneMinusEpsilon15 < y * OnePlusEpsilon15);
+		}
+		else
+		{
+			return (y < 1.0e-15);  // x==0 in this case
+		}
+	}
+	else if (y < 0.0)
+	{
+		if (x < 0.0)
+		{
+			return (x * OnePlusEpsilon15 < y * OneMinusEpsilon15);
+		}
+		else
+		{
+			return (y > -1.0e-15);  // x==0 in this case
+		}
+	}
+	else
+	{
+		return (-1.0e-15 < x && x < 1.0e-15);
+	}
+}
+
+inline bool GreaterOrEqualFuzzy(double x, double y)
+{
+	return LessOrEqualFuzzy(y, x);
+}
+
+inline bool UpdateMaxAbs(double* maxabs, double updateval)
+{
+	if (updateval > *maxabs)
+	{
+		*maxabs = updateval;
+		return true;
+	}
+	else if (-updateval > *maxabs)
+	{
+		*maxabs = -updateval;
+		return true;
+	}
+	else
+	{
+		return false;
+	}
+}
+
+// **********************************************************
+// Combinations and averages.								*
+// **********************************************************
+
+template <class T>
+void averageOf(const T& a, const T& b, T& c)
+{
+	c = a;
+	c += b;
+	c *= 0.5;
+}
+
+template <class T>
+void Lerp(const T& a, const T& b, double alpha, T& c)
+{
+	double beta = 1.0 - alpha;
+	if (beta > alpha)
+	{
+		c = b;
+		c *= alpha / beta;
+		c += a;
+		c *= beta;
+	}
+	else
+	{
+		c = a;
+		c *= beta / alpha;
+		c += b;
+		c *= alpha;
+	}
+}
+
+template <class T>
+T Lerp(const T& a, const T& b, double alpha)
+{
+	T ret;
+	Lerp(a, b, alpha, ret);
+	return ret;
+}
+
+// **********************************************************
+// Trigonometry												*
+// **********************************************************
+
+// TimesCot(x) returns x*cot(x)
+inline double TimesCot(double x)
+{
+	if (-1.0e-5 < x && x < 1.0e-5)
+	{
+		return 1.0 + x * OneThird;
+	}
+	else
+	{
+		return (x * cos(x) / sin(x));
+	}
+}
+
+// SineOver(x) returns sin(x)/x.
+inline double SineOver(double x)
+{
+	if (-1.0e-5 < x && x < 1.0e-5)
+	{
+		return 1.0 - x * x * OneSixth;
+	}
+	else
+	{
+		return sin(x) / x;
+	}
+}
+// OverSine(x) returns x/sin(x).
+inline double OverSine(double x)
+{
+	if (-1.0e-5 < x && x < 1.0e-5)
+	{
+		return 1.0 + x * x * OneSixth;
+	}
+	else
+	{
+		return x / sin(x);
+	}
+}
+
+inline double SafeAsin(double x)
+{
+	if (x <= -1.0)
+	{
+		return -PIhalves;
+	}
+	else if (x >= 1.0)
+	{
+		return PIhalves;
+	}
+	else
+	{
+		return asin(x);
+	}
+}
+
+inline double SafeAcos(double x)
+{
+	if (x <= -1.0)
+	{
+		return PI;
+	}
+	else if (x >= 1.0)
+	{
+		return 0.0;
+	}
+	else
+	{
+		return acos(x);
+	}
+}
+
+// **********************************************************************
+// Roots and powers														*
+// **********************************************************************
+
+// Square(x) returns x*x,  of course!
+
+template <class T>
+inline T Square(T x)
+{
+	return (x * x);
+}
+
+// Cube(x) returns x*x*x,  of course!
+
+template <class T>
+inline T Cube(T x)
+{
+	return (x * x * x);
+}
+
+// SafeSqrt(x) = returns sqrt(max(x, 0.0));
+
+inline double SafeSqrt(double x)
+{
+	if (x <= 0.0)
+	{
+		return 0.0;
+	}
+	else
+	{
+		return sqrt(x);
+	}
+}
+
+// SignedSqrt(a, s) returns (sign(s)*sqrt(a)).
+inline double SignedSqrt(double a, double sgn)
+{
+	if (sgn == 0.0)
+	{
+		return 0.0;
+	}
+	else
+	{
+		return (sgn > 0.0 ? sqrt(a) : -sqrt(a));
+	}
+}
+
+// Template version of Sign function
+
+template <class T>
+inline int Sign(T x)
+{
+	if (x < 0)
+	{
+		return -1;
+	}
+	else if (x == 0)
+	{
+		return 0;
+	}
+	else
+	{
+		return 1;
+	}
+}
+
+#endif  // #ifndef MATH_MISC_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/BussIK/MatrixRmn.h b/engine/inc/bullet/ThirdPartyLibs/BussIK/MatrixRmn.h
new file mode 100644
index 00000000..343e79b9
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/BussIK/MatrixRmn.h
@@ -0,0 +1,417 @@
+/*
+*
+* Mathematics Subpackage (VrMath)
+*
+*
+* Author: Samuel R. Buss, sbuss@ucsd.edu.
+* Web page: http://math.ucsd.edu/~sbuss/MathCG
+*
+*
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*
+*
+*/
+
+//
+// MatrixRmn:  Matrix over reals  (Variable dimensional vector)
+//
+//    Not very sophisticated yet.  Needs more functionality
+//		To do: better handling of resizing.
+//
+
+#ifndef MATRIX_RMN_H
+#define MATRIX_RMN_H
+
+#include <math.h>
+#include <assert.h>
+#include "LinearR3.h"
+#include "VectorRn.h"
+
+class MatrixRmn
+{
+public:
+	MatrixRmn();                            // Null constructor
+	MatrixRmn(long numRows, long numCols);  // Constructor with length
+	~MatrixRmn();                           // Destructor
+
+	void SetSize(long numRows, long numCols);
+	long GetNumRows() const { return NumRows; }
+	long GetNumColumns() const { return NumCols; }
+	void SetZero();
+
+	// Return entry in row i and column j.
+	double Get(long i, long j) const;
+	void GetTriple(long i, long j, VectorR3* retValue) const;
+
+	// Use GetPtr to get pointer into the array (efficient)
+	// Is friendly in that anyone can change the array contents (be careful!)
+	// The entries are in column order!!!
+	// Use this with care.  You may call GetRowStride and GetColStride to navigate
+	//			within the matrix.  I do not expect these values to ever change.
+	const double* GetPtr() const;
+	double* GetPtr();
+	const double* GetPtr(long i, long j) const;
+	double* GetPtr(long i, long j);
+	const double* GetColumnPtr(long j) const;
+	double* GetColumnPtr(long j);
+	const double* GetRowPtr(long i) const;
+	double* GetRowPtr(long i);
+	long GetRowStride() const { return NumRows; }  // Step size (stride) along a row
+	long GetColStride() const { return 1; }        // Step size (stide) along a column
+
+	void Set(long i, long j, double val);
+	void SetTriple(long i, long c, const VectorR3& u);
+
+	void SetIdentity();
+	void SetDiagonalEntries(double d);
+	void SetDiagonalEntries(const VectorRn& d);
+	void SetSuperDiagonalEntries(double d);
+	void SetSuperDiagonalEntries(const VectorRn& d);
+	void SetSubDiagonalEntries(double d);
+	void SetSubDiagonalEntries(const VectorRn& d);
+	void SetColumn(long i, const VectorRn& d);
+	void SetRow(long i, const VectorRn& d);
+	void SetSequence(const VectorRn& d, long startRow, long startCol, long deltaRow, long deltaCol);
+
+	// Loads matrix in as a sub-matrix.  (i,j) is the base point. Defaults to (0,0).
+	// The "Tranpose" versions load the transpose of A.
+	void LoadAsSubmatrix(const MatrixRmn& A);
+	void LoadAsSubmatrix(long i, long j, const MatrixRmn& A);
+	void LoadAsSubmatrixTranspose(const MatrixRmn& A);
+	void LoadAsSubmatrixTranspose(long i, long j, const MatrixRmn& A);
+
+	// Norms
+	double FrobeniusNormSq() const;
+	double FrobeniusNorm() const;
+
+	// Operations on VectorRn's
+	void Multiply(const VectorRn& v, VectorRn& result) const;           // result = (this)*(v)
+	void MultiplyTranspose(const VectorRn& v, VectorRn& result) const;  // Equivalent to mult by row vector on left
+	double DotProductColumn(const VectorRn& v, long colNum) const;      // Returns dot product of v with i-th column
+
+	// Operations on MatrixRmn's
+	MatrixRmn& operator*=(double);
+	MatrixRmn& operator/=(double d)
+	{
+		assert(d != 0.0);
+		*this *= (1.0 / d);
+		return *this;
+	}
+	MatrixRmn& AddScaled(const MatrixRmn& B, double factor);
+	MatrixRmn& operator+=(const MatrixRmn& B);
+	MatrixRmn& operator-=(const MatrixRmn& B);
+	static MatrixRmn& Multiply(const MatrixRmn& A, const MatrixRmn& B, MatrixRmn& dst);           // Sets dst = A*B.
+	static MatrixRmn& MultiplyTranspose(const MatrixRmn& A, const MatrixRmn& B, MatrixRmn& dst);  // Sets dst = A*(B-tranpose).
+	static MatrixRmn& TransposeMultiply(const MatrixRmn& A, const MatrixRmn& B, MatrixRmn& dst);  // Sets dst = (A-transpose)*B.
+
+	// Miscellaneous operation
+	MatrixRmn& AddToDiagonal(double d);  // Adds d to each diagonal
+	MatrixRmn& AddToDiagonal(const VectorRn& dVec);
+
+	// Solving systems of linear equations
+	void Solve(const VectorRn& b, VectorRn* x, MatrixRmn& AugMat) const;  // Solves the equation   (*this)*x = b;    Uses row operations.  Assumes *this is invertible.
+
+	// Row Echelon Form and Reduced Row Echelon Form routines
+	// Row echelon form here allows non-negative entries (instead of 1's) in the positions of lead variables.
+	void ConvertToRefNoFree();                   // Converts the matrix in place to row echelon form -- assumption is no free variables will be found
+	void ConvertToRef(int numVars);              // Converts the matrix in place to row echelon form -- numVars is number of columns to work with.
+	void ConvertToRef(int numVars, double eps);  // Same, but eps is the measure of closeness to zero
+
+	// Givens transformation
+	static void CalcGivensValues(double a, double b, double* c, double* s);
+	void PostApplyGivens(double c, double s, long idx);              // Applies Givens transform to columns idx and idx+1.
+	void PostApplyGivens(double c, double s, long idx1, long idx2);  // Applies Givens transform to columns idx1 and idx2.
+
+	// Singular value decomposition
+	void ComputeSVD(MatrixRmn& U, VectorRn& w, MatrixRmn& V) const;
+	// Good for debugging SVD computations (I recommend this be used for any new application to check for bugs/instability).
+	bool DebugCheckSVD(const MatrixRmn& U, const VectorRn& w, const MatrixRmn& V) const;
+	// Compute inverse of a matrix, the result is written in R
+	void ComputeInverse(MatrixRmn& R) const;
+	// Debug matrix inverse computation
+	bool DebugCheckInverse(const MatrixRmn& MInv) const;
+
+	// Some useful routines for experts who understand the inner workings of these classes.
+	inline static double DotArray(long length, const double* ptrA, long strideA, const double* ptrB, long strideB);
+	inline static void CopyArrayScale(long length, const double* from, long fromStride, double* to, long toStride, double scale);
+	inline static void AddArrayScale(long length, const double* from, long fromStride, double* to, long toStride, double scale);
+
+private:
+	long NumRows;    // Number of rows
+	long NumCols;    // Number of columns
+	double* x;       // Array of vector entries - stored in column order
+	long AllocSize;  // Allocated size of the x array
+
+
+	// Internal helper routines for SVD calculations
+	static void CalcBidiagonal(MatrixRmn& U, MatrixRmn& V, VectorRn& w, VectorRn& superDiag);
+	void ConvertBidiagToDiagonal(MatrixRmn& U, MatrixRmn& V, VectorRn& w, VectorRn& superDiag) const;
+	static void SvdHouseholder(double* basePt,
+							   long colLength, long numCols, long colStride, long rowStride,
+							   double* retFirstEntry);
+	void ExpandHouseholders(long numXforms, int numZerosSkipped, const double* basePt, long colStride, long rowStride);
+	static bool UpdateBidiagIndices(long* firstDiagIdx, long* lastBidiagIdx, VectorRn& w, VectorRn& superDiag, double eps);
+	static void ApplyGivensCBTD(double cosine, double sine, double* a, double* b, double* c, double* d);
+	static void ApplyGivensCBTD(double cosine, double sine, double* a, double* b, double* c,
+								double d, double* e, double* f);
+	static void ClearRowWithDiagonalZero(long firstBidiagIdx, long lastBidiagIdx,
+										 MatrixRmn& U, double* wPtr, double* sdPtr, double eps);
+	static void ClearColumnWithDiagonalZero(long endIdx, MatrixRmn& V, double* wPtr, double* sdPtr, double eps);
+	bool DebugCalcBidiagCheck(const MatrixRmn& U, const VectorRn& w, const VectorRn& superDiag, const MatrixRmn& V) const;
+};
+
+inline MatrixRmn::MatrixRmn()
+{
+	NumRows = 0;
+	NumCols = 0;
+	x = 0;
+	AllocSize = 0;
+}
+
+inline MatrixRmn::MatrixRmn(long numRows, long numCols)
+{
+	NumRows = 0;
+	NumCols = 0;
+	x = 0;
+	AllocSize = 0;
+	SetSize(numRows, numCols);
+}
+
+inline MatrixRmn::~MatrixRmn()
+{
+	delete[] x;
+}
+
+// Resize.
+// If the array space is decreased, the information about the allocated length is lost.
+inline void MatrixRmn::SetSize(long numRows, long numCols)
+{
+	assert(numRows > 0 && numCols > 0);
+	long newLength = numRows * numCols;
+	if (newLength > AllocSize)
+	{
+		delete[] x;
+		AllocSize = Max(newLength, AllocSize << 1);
+		x = new double[AllocSize];
+	}
+	NumRows = numRows;
+	NumCols = numCols;
+}
+
+// Zero out the entire vector
+inline void MatrixRmn::SetZero()
+{
+	double* target = x;
+	for (long i = NumRows * NumCols; i > 0; i--)
+	{
+		*(target++) = 0.0;
+	}
+}
+
+// Return entry in row i and column j.
+inline double MatrixRmn::Get(long i, long j) const
+{
+	assert(i < NumRows && j < NumCols);
+	return *(x + j * NumRows + i);
+}
+
+// Return a VectorR3 out of a column.  Starts at row 3*i, in column j.
+inline void MatrixRmn::GetTriple(long i, long j, VectorR3* retValue) const
+{
+	long ii = 3 * i;
+	assert(0 <= i && ii + 2 < NumRows && 0 <= j && j < NumCols);
+	retValue->Load(x + j * NumRows + ii);
+}
+
+// Get a pointer to the (0,0) entry.
+// The entries are in column order.
+// This version gives read-only pointer
+inline const double* MatrixRmn::GetPtr() const
+{
+	return x;
+}
+
+// Get a pointer to the (0,0) entry.
+// The entries are in column order.
+inline double* MatrixRmn::GetPtr()
+{
+	return x;
+}
+
+// Get a pointer to the (i,j) entry.
+// The entries are in column order.
+// This version gives read-only pointer
+inline const double* MatrixRmn::GetPtr(long i, long j) const
+{
+	assert(0 <= i && i < NumRows && 0 <= j && j < NumCols);
+	return (x + j * NumRows + i);
+}
+
+// Get a pointer to the (i,j) entry.
+// The entries are in column order.
+// This version gives pointer to writable data
+inline double* MatrixRmn::GetPtr(long i, long j)
+{
+	assert(i < NumRows && j < NumCols);
+	return (x + j * NumRows + i);
+}
+
+// Get a pointer to the j-th column.
+// The entries are in column order.
+// This version gives read-only pointer
+inline const double* MatrixRmn::GetColumnPtr(long j) const
+{
+	assert(0 <= j && j < NumCols);
+	return (x + j * NumRows);
+}
+
+// Get a pointer to the j-th column.
+// This version gives pointer to writable data
+inline double* MatrixRmn::GetColumnPtr(long j)
+{
+	assert(0 <= j && j < NumCols);
+	return (x + j * NumRows);
+}
+
+/// Get a pointer to the i-th row
+// The entries are in column order.
+// This version gives read-only pointer
+inline const double* MatrixRmn::GetRowPtr(long i) const
+{
+	assert(0 <= i && i < NumRows);
+	return (x + i);
+}
+
+// Get a pointer to the i-th row
+// This version gives pointer to writable data
+inline double* MatrixRmn::GetRowPtr(long i)
+{
+	assert(0 <= i && i < NumRows);
+	return (x + i);
+}
+
+// Set the (i,j) entry of the matrix
+inline void MatrixRmn::Set(long i, long j, double val)
+{
+	assert(i < NumRows && j < NumCols);
+	*(x + j * NumRows + i) = val;
+}
+
+// Set the i-th triple in the j-th column to u's three values
+inline void MatrixRmn::SetTriple(long i, long j, const VectorR3& u)
+{
+	long ii = 3 * i;
+	assert(0 <= i && ii + 2 < NumRows && 0 <= j && j < NumCols);
+	u.Dump(x + j * NumRows + ii);
+}
+
+// Set to be equal to the identity matrix
+inline void MatrixRmn::SetIdentity()
+{
+	assert(NumRows == NumCols);
+	SetZero();
+	SetDiagonalEntries(1.0);
+}
+
+inline MatrixRmn& MatrixRmn::operator*=(double mult)
+{
+	double* aPtr = x;
+	for (long i = NumRows * NumCols; i > 0; i--)
+	{
+		(*(aPtr++)) *= mult;
+	}
+	return (*this);
+}
+
+inline MatrixRmn& MatrixRmn::AddScaled(const MatrixRmn& B, double factor)
+{
+	assert(NumRows == B.NumRows && NumCols == B.NumCols);
+	double* aPtr = x;
+	double* bPtr = B.x;
+	for (long i = NumRows * NumCols; i > 0; i--)
+	{
+		(*(aPtr++)) += (*(bPtr++)) * factor;
+	}
+	return (*this);
+}
+
+inline MatrixRmn& MatrixRmn::operator+=(const MatrixRmn& B)
+{
+	assert(NumRows == B.NumRows && NumCols == B.NumCols);
+	double* aPtr = x;
+	double* bPtr = B.x;
+	for (long i = NumRows * NumCols; i > 0; i--)
+	{
+		(*(aPtr++)) += *(bPtr++);
+	}
+	return (*this);
+}
+
+inline MatrixRmn& MatrixRmn::operator-=(const MatrixRmn& B)
+{
+	assert(NumRows == B.NumRows && NumCols == B.NumCols);
+	double* aPtr = x;
+	double* bPtr = B.x;
+	for (long i = NumRows * NumCols; i > 0; i--)
+	{
+		(*(aPtr++)) -= *(bPtr++);
+	}
+	return (*this);
+}
+
+inline double MatrixRmn::FrobeniusNormSq() const
+{
+	double* aPtr = x;
+	double result = 0.0;
+	for (long i = NumRows * NumCols; i > 0; i--)
+	{
+		result += Square(*(aPtr++));
+	}
+	return result;
+}
+
+// Helper routine to calculate dot product
+inline double MatrixRmn::DotArray(long length, const double* ptrA, long strideA, const double* ptrB, long strideB)
+{
+	double result = 0.0;
+	for (; length > 0; length--)
+	{
+		result += (*ptrA) * (*ptrB);
+		ptrA += strideA;
+		ptrB += strideB;
+	}
+	return result;
+}
+
+// Helper routine: copies and scales an array (src and dest may be equal, or overlap)
+inline void MatrixRmn::CopyArrayScale(long length, const double* from, long fromStride, double* to, long toStride, double scale)
+{
+	for (; length > 0; length--)
+	{
+		*to = (*from) * scale;
+		from += fromStride;
+		to += toStride;
+	}
+}
+
+// Helper routine: adds a scaled array
+//	fromArray = toArray*scale.
+inline void MatrixRmn::AddArrayScale(long length, const double* from, long fromStride, double* to, long toStride, double scale)
+{
+	for (; length > 0; length--)
+	{
+		*to += (*from) * scale;
+		from += fromStride;
+		to += toStride;
+	}
+}
+
+#endif  //MATRIX_RMN_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/BussIK/Node.h b/engine/inc/bullet/ThirdPartyLibs/BussIK/Node.h
new file mode 100644
index 00000000..ad1d61ad
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/BussIK/Node.h
@@ -0,0 +1,109 @@
+/*
+*
+* Mathematics Subpackage (VrMath)
+*
+*
+* Author: Samuel R. Buss, sbuss@ucsd.edu.
+* Web page: http://math.ucsd.edu/~sbuss/MathCG
+*
+*
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*
+*
+*/
+
+#ifndef _CLASS_NODE
+#define _CLASS_NODE
+
+#include "LinearR3.h"
+
+enum Purpose
+{
+	JOINT,
+	EFFECTOR
+};
+
+class VectorR3;
+
+class Node
+{
+	friend class Tree;
+
+public:
+	Node(const VectorR3&, const VectorR3&, double, Purpose, double minTheta = -PI, double maxTheta = PI, double restAngle = 0.);
+
+	void PrintNode();
+	void InitNode();
+
+	const VectorR3& GetAttach() const { return attach; }
+
+	double GetTheta() const { return theta; }
+	double AddToTheta(double& delta)
+	{
+		//double orgTheta = theta;
+		theta += delta;
+#if 0
+		if (theta < minTheta)
+			theta = minTheta;
+		if (theta > maxTheta)
+			theta = maxTheta;
+		double actualDelta = theta - orgTheta;
+		delta = actualDelta;
+#endif
+		return theta;
+	}
+
+	double UpdateTheta(double& delta)
+	{
+		theta = delta;
+		return theta;
+	}
+
+	const VectorR3& GetS() const { return s; }
+	const VectorR3& GetW() const { return w; }
+
+	double GetMinTheta() const { return minTheta; }
+	double GetMaxTheta() const { return maxTheta; }
+	double GetRestAngle() const { return restAngle; };
+	void SetTheta(double newTheta) { theta = newTheta; }
+	void ComputeS(void);
+	void ComputeW(void);
+
+	bool IsEffector() const { return purpose == EFFECTOR; }
+	bool IsJoint() const { return purpose == JOINT; }
+	int GetEffectorNum() const { return seqNumEffector; }
+	int GetJointNum() const { return seqNumJoint; }
+
+	bool IsFrozen() const { return freezed; }
+	void Freeze() { freezed = true; }
+	void UnFreeze() { freezed = false; }
+
+	//private:
+	bool freezed;        // Is this node frozen?
+	int seqNumJoint;     // sequence number if this node is a joint
+	int seqNumEffector;  // sequence number if this node is an effector
+	double size;         // size
+	Purpose purpose;     // joint / effector / both
+	VectorR3 attach;     // attachment point
+	VectorR3 r;          // relative position vector
+	VectorR3 v;          // rotation axis
+	double theta;        // joint angle (radian)
+	double minTheta;     // lower limit of joint angle
+	double maxTheta;     // upper limit of joint angle
+	double restAngle;    // rest position angle
+	VectorR3 s;          // GLobal Position
+	VectorR3 w;          // Global rotation axis
+	Node* left;          // left child
+	Node* right;         // right sibling
+	Node* realparent;    // pointer to real parent
+};
+
+#endif
\ No newline at end of file
diff --git a/engine/inc/bullet/ThirdPartyLibs/BussIK/Spherical.h b/engine/inc/bullet/ThirdPartyLibs/BussIK/Spherical.h
new file mode 100644
index 00000000..31f87a94
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/BussIK/Spherical.h
@@ -0,0 +1,293 @@
+/*
+*
+* Mathematics Subpackage (VrMath)
+*
+*
+* Author: Samuel R. Buss, sbuss@ucsd.edu.
+* Web page: http://math.ucsd.edu/~sbuss/MathCG
+*
+*
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*
+*
+*/
+
+//
+// Spherical Operations Classes
+//
+//
+// B. SphericalInterpolator
+//
+// OrientationR3
+//
+// A. Quaternion
+//
+// B. RotationMapR3		// Elsewhere
+//
+// C. EulerAnglesR3		// TO DO
+//
+//
+// Functions for spherical operations
+// A. Many routines for rotation and averaging on a sphere
+//
+
+#ifndef SPHERICAL_H
+#define SPHERICAL_H
+
+#include "LinearR3.h"
+#include "LinearR4.h"
+#include "MathMisc.h"
+
+class SphericalInterpolator;     // Spherical linear interpolation of vectors
+class SphericalBSpInterpolator;  // Spherical Bspline interpolation of vector
+class Quaternion;                // Quaternion (x,y,z,w) values.
+class EulerAnglesR3;             // Euler Angles
+
+// *****************************************************
+// SphericalInterpolator class                         *
+//    - Does linear interpolation (slerp-ing)		   *
+// * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+class SphericalInterpolator
+{
+private:
+	VectorR3 startDir, endDir;  // Unit vectors (starting and ending)
+	double startLen, endLen;    // Magnitudes of the vectors
+	double rotRate;             // Angle between start and end vectors
+
+public:
+	SphericalInterpolator(const VectorR3& u, const VectorR3& v);
+
+	VectorR3 InterValue(double frac) const;
+};
+
+// ***************************************************************
+// * Quaternion class - prototypes								 *
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+class Quaternion
+{
+public:
+	double x, y, z, w;
+
+public:
+	Quaternion() : x(0.0), y(0.0), z(0.0), w(1.0){};
+	Quaternion(double, double, double, double);
+
+	inline Quaternion& Set(double xx, double yy, double zz, double ww);
+	inline Quaternion& Set(const VectorR4&);
+	Quaternion& Set(const EulerAnglesR3&);
+	Quaternion& Set(const RotationMapR3&);
+	Quaternion& SetRotate(const VectorR3&);
+
+	Quaternion& SetIdentity();   // Set to the identity map
+	Quaternion Inverse() const;  // Return the Inverse
+	Quaternion& Invert();        // Invert this quaternion
+
+	double Angle();  // Angle of rotation
+	double Norm();   // Norm of x,y,z component
+
+	Quaternion& operator*=(const Quaternion&);
+};
+
+Quaternion operator*(const Quaternion&, const Quaternion&);
+
+inline Quaternion ToQuat(const VectorR4& v)
+{
+	return Quaternion(v.x, v.y, v.z, v.w);
+}
+
+inline double Quaternion::Norm()
+{
+	return sqrt(x * x + y * y + z * z);
+}
+
+inline double Quaternion::Angle()
+{
+	double halfAngle = asin(Norm());
+	return halfAngle + halfAngle;
+}
+
+// ****************************************************************
+// Solid Geometry Routines										  *
+// ****************************************************************
+
+// Compute the angle formed by two geodesics on the unit sphere.
+//	Three unit vectors u,v,w specify the geodesics u-v and v-w which
+//  meet at vertex uv.  The angle from v-w to v-u is returned.  This
+//  is always in the range [0, 2PI).
+double SphereAngle(const VectorR3& u, const VectorR3& v, const VectorR3& w);
+
+//  Compute the area of a triangle on the unit sphere.  Three unit vectors
+//		specify the corners of the triangle in COUNTERCLOCKWISE order.
+inline double SphericalTriangleArea(
+	const VectorR3& u, const VectorR3& v, const VectorR3& w)
+{
+	double AngleA = SphereAngle(u, v, w);
+	double AngleB = SphereAngle(v, w, u);
+	double AngleC = SphereAngle(w, u, v);
+	return (AngleA + AngleB + AngleC - PI);
+}
+
+// ****************************************************************
+// Spherical Mean routines										  *
+// ****************************************************************
+
+// Weighted sum of vectors
+VectorR3 WeightedSum(long Num, const VectorR3 vv[], const double weights[]);
+VectorR4 WeightedSum(long Num, const VectorR4 vv[], const double weights[]);
+
+// Weighted average of vectors on the sphere.
+//		Sum of weights should equal one (but no checking is done)
+VectorR3 ComputeMeanSphere(long Num, const VectorR3 vv[], const double weights[],
+						   double tolerance = 1.0e-15, double bkuptolerance = 1.0e-13);
+VectorR3 ComputeMeanSphere(long Num, const VectorR3 vv[], const double weights[],
+						   const VectorR3& InitialVec,
+						   double tolerance = 1.0e-15, double bkuptolerance = 1.0e-13);
+VectorR4 ComputeMeanSphere(long Num, const VectorR4 vv[], const double weights[],
+						   double tolerance = 1.0e-15, double bkuptolerance = 1.0e-13);
+Quaternion ComputeMeanQuat(long Num, const Quaternion qq[], const double weights[],
+						   double tolerance = 1.0e-15, double bkuptolerance = 1.0e-13);
+
+// Next functions mostly for internal use.
+//		It takes an initial estimate InitialVec (and a flag for
+//		indicating quaternions).
+VectorR4 ComputeMeanSphere(long Num, const VectorR4 vv[], const double weights[],
+						   const VectorR4& InitialVec, int QuatFlag = 0,
+						   double tolerance = 1.0e-15, double bkuptolerance = 1.0e-13);
+const int SPHERICAL_NOTQUAT = 0;
+const int SPHERICAL_QUAT = 1;
+
+// Slow version, mostly for testing
+VectorR3 ComputeMeanSphereSlow(long Num, const VectorR3 vv[], const double weights[],
+							   double tolerance = 1.0e-16, double bkuptolerance = 5.0e-16);
+VectorR4 ComputeMeanSphereSlow(long Num, const VectorR4 vv[], const double weights[],
+							   double tolerance = 1.0e-16, double bkuptolerance = 5.0e-16);
+VectorR3 ComputeMeanSphereOld(long Num, const VectorR3 vv[], const double weights[],
+							  double tolerance = 1.0e-15, double bkuptolerance = 1.0e-13);
+VectorR4 ComputeMeanSphereOld(long Num, const VectorR4 vv[], const double weights[],
+							  const VectorR4& InitialVec, int QuatFlag,
+							  double tolerance = 1.0e-15, double bkuptolerance = 1.0e-13);
+
+// Solves a system of spherical-mean equalities, where the system is
+// given as a tridiagonal matrix.
+void SolveTriDiagSphere(int numPoints,
+						const double* tridiagvalues, const VectorR3* c,
+						VectorR3* p,
+						double accuracy = 1.0e-15, double bkupaccuracy = 1.0e-13);
+void SolveTriDiagSphere(int numPoints,
+						const double* tridiagvalues, const VectorR4* c,
+						VectorR4* p,
+						double accuracy = 1.0e-15, double bkupaccuracy = 1.0e-13);
+
+//  The "Slow" version uses a simpler but slower iteration with a linear rate of
+//		convergence.  The base version uses a Newton iteration with a quadratic
+//		rate of convergence.
+void SolveTriDiagSphereSlow(int numPoints,
+							const double* tridiagvalues, const VectorR3* c,
+							VectorR3* p,
+							double accuracy = 1.0e-15, double bkupaccuracy = 5.0e-15);
+void SolveTriDiagSphereSlow(int numPoints,
+							const double* tridiagvalues, const VectorR4* c,
+							VectorR4* p,
+							double accuracy = 1.0e-15, double bkupaccuracy = 5.0e-15);
+
+// The "Unstable" version probably shouldn't be used except for very short sequences
+//		of knots.  Mostly it's used for testing purposes now.
+void SolveTriDiagSphereUnstable(int numPoints,
+								const double* tridiagvalues, const VectorR3* c,
+								VectorR3* p,
+								double accuracy = 1.0e-15, double bkupaccuracy = 1.0e-13);
+void SolveTriDiagSphereHelperUnstable(int numPoints,
+									  const double* tridiagvalues, const VectorR3* c,
+									  const VectorR3& p0value,
+									  VectorR3* p,
+									  double accuracy = 1.0e-15, double bkupaccuracy = 1.0e-13);
+
+// ***************************************************************
+// * Quaternion class - inlined member functions				 *
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+inline VectorR4::VectorR4(const Quaternion& q)
+	: x(q.x), y(q.y), z(q.z), w(q.w)
+{
+}
+
+inline VectorR4& VectorR4::Set(const Quaternion& q)
+{
+	x = q.x;
+	y = q.y;
+	z = q.z;
+	w = q.w;
+	return *this;
+}
+
+inline Quaternion::Quaternion(double xx, double yy, double zz, double ww)
+	: x(xx), y(yy), z(zz), w(ww)
+{
+}
+
+inline Quaternion& Quaternion::Set(double xx, double yy, double zz, double ww)
+{
+	x = xx;
+	y = yy;
+	z = zz;
+	w = ww;
+	return *this;
+}
+
+inline Quaternion& Quaternion::Set(const VectorR4& u)
+{
+	x = u.x;
+	y = u.y;
+	z = u.z;
+	w = u.w;
+	return *this;
+}
+
+inline Quaternion& Quaternion::SetIdentity()
+{
+	x = y = z = 0.0;
+	w = 1.0;
+	return *this;
+}
+
+inline Quaternion operator*(const Quaternion& q1, const Quaternion& q2)
+{
+	Quaternion q(q1);
+	q *= q2;
+	return q;
+}
+
+inline Quaternion& Quaternion::operator*=(const Quaternion& q)
+{
+	double wnew = w * q.w - (x * q.x + y * q.y + z * q.z);
+	double xnew = w * q.x + q.w * x + (y * q.z - z * q.y);
+	double ynew = w * q.y + q.w * y + (z * q.x - x * q.z);
+	z = w * q.z + q.w * z + (x * q.y - y * q.x);
+	w = wnew;
+	x = xnew;
+	y = ynew;
+	return *this;
+}
+
+inline Quaternion Quaternion::Inverse() const  // Return the Inverse
+{
+	return (Quaternion(x, y, z, -w));
+}
+
+inline Quaternion& Quaternion::Invert()  // Invert this quaternion
+{
+	w = -w;
+	return *this;
+}
+
+#endif  // SPHERICAL_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/BussIK/Tree.h b/engine/inc/bullet/ThirdPartyLibs/BussIK/Tree.h
new file mode 100644
index 00000000..737f5706
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/BussIK/Tree.h
@@ -0,0 +1,96 @@
+/*
+*
+* Inverse Kinematics software, with several solvers including
+* Selectively Damped Least Squares Method
+* Damped Least Squares Method
+* Pure Pseudoinverse Method
+* Jacobian Transpose Method
+*
+*
+* Author: Samuel R. Buss, sbuss@ucsd.edu.
+* Web page: http://www.math.ucsd.edu/~sbuss/ResearchWeb/ikmethods/index.html
+*
+*
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*
+*
+*/
+
+#include "LinearR3.h"
+#include "Node.h"
+
+#ifndef _CLASS_TREE
+#define _CLASS_TREE
+
+class Tree
+{
+public:
+	Tree();
+
+	int GetNumNode() const { return nNode; }
+	int GetNumEffector() const { return nEffector; }
+	int GetNumJoint() const { return nJoint; }
+	void InsertRoot(Node*);
+	void InsertLeftChild(Node* parent, Node* child);
+	void InsertRightSibling(Node* parent, Node* child);
+
+	// Accessors based on node numbers
+	Node* GetJoint(int);
+	Node* GetEffector(int);
+	const VectorR3& GetEffectorPosition(int);
+
+	// Accessors for tree traversal
+	Node* GetRoot() const { return root; }
+	Node* GetSuccessor(const Node*) const;
+	Node* GetParent(const Node* node) const { return node->realparent; }
+
+	void Compute();
+
+	void Print();
+	void Init();
+	void UnFreeze();
+
+private:
+	Node* root;
+	int nNode;  // nNode = nEffector + nJoint
+	int nEffector;
+	int nJoint;
+	void SetSeqNum(Node*);
+	Node* SearchJoint(Node*, int);
+	Node* SearchEffector(Node*, int);
+	void ComputeTree(Node*);
+
+	void PrintTree(Node*);
+	void InitTree(Node*);
+	void UnFreezeTree(Node*);
+};
+
+inline Node* Tree::GetSuccessor(const Node* node) const
+{
+	if (node->left)
+	{
+		return node->left;
+	}
+	while (true)
+	{
+		if (node->right)
+		{
+			return (node->right);
+		}
+		node = node->realparent;
+		if (!node)
+		{
+			return 0;  // Back to root, finished traversal
+		}
+	}
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/inc/bullet/ThirdPartyLibs/BussIK/VectorRn.h b/engine/inc/bullet/ThirdPartyLibs/BussIK/VectorRn.h
new file mode 100644
index 00000000..a7a5ba04
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/BussIK/VectorRn.h
@@ -0,0 +1,275 @@
+/*
+*
+* Mathematics Subpackage (VrMath)
+*
+*
+* Author: Samuel R. Buss, sbuss@ucsd.edu.
+* Web page: http://math.ucsd.edu/~sbuss/MathCG
+*
+*
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*
+*
+*/
+
+//
+// VectorRn:  Vector over Rn  (Variable length vector)
+//
+//    Not very sophisticated yet.  Needs more functionality
+//		To do: better handling of resizing.
+//
+
+#ifndef VECTOR_RN_H
+#define VECTOR_RN_H
+
+#include <math.h>
+#include <assert.h>
+#include "LinearR3.h"
+
+class VectorRn
+{
+	friend class MatrixRmn;
+
+public:
+	VectorRn();             // Null constructor
+	VectorRn(long length);  // Constructor with length
+	~VectorRn();            // Destructor
+
+	void SetLength(long newLength);
+	long GetLength() const { return length; }
+
+	void SetZero();
+	void Fill(double d);
+	void Load(const double* d);
+	void LoadScaled(const double* d, double scaleFactor);
+	void Set(const VectorRn& src);
+
+	// Two access methods identical in functionality
+	// Subscripts are ZERO-BASED!!
+	const double& operator[](long i) const
+	{
+		assert(0 <= i && i < length);
+		return *(x + i);
+	}
+	double& operator[](long i)
+	{
+		assert(0 <= i && i < length);
+		return *(x + i);
+	}
+	double Get(long i) const
+	{
+		assert(0 <= i && i < length);
+		return *(x + i);
+	}
+
+	// Use GetPtr to get pointer into the array (efficient)
+	// Is friendly in that anyone can change the array contents (be careful!)
+	const double* GetPtr(long i) const
+	{
+		assert(0 <= i && i < length);
+		return (x + i);
+	}
+	double* GetPtr(long i)
+	{
+		assert(0 <= i && i < length);
+		return (x + i);
+	}
+	const double* GetPtr() const { return x; }
+	double* GetPtr() { return x; }
+
+	void Set(long i, double val) { assert(0 <= i && i < length), *(x + i) = val; }
+	void SetTriple(long i, const VectorR3& u);
+
+	VectorRn& operator+=(const VectorRn& src);
+	VectorRn& operator-=(const VectorRn& src);
+	void AddScaled(const VectorRn& src, double scaleFactor);
+
+	VectorRn& operator*=(double f);
+	double NormSq() const;
+	double Norm() const { return sqrt(NormSq()); }
+
+	double MaxAbs() const;
+
+private:
+	long length;       // Logical or actual length
+	long AllocLength;  // Allocated length
+	double* x;         // Array of vector entries
+
+	static VectorRn WorkVector;  // Serves as a temporary vector
+	static VectorRn& GetWorkVector() { return WorkVector; }
+	static VectorRn& GetWorkVector(long len)
+	{
+		WorkVector.SetLength(len);
+		return WorkVector;
+	}
+};
+
+inline VectorRn::VectorRn()
+{
+	length = 0;
+	AllocLength = 0;
+	x = 0;
+}
+
+inline VectorRn::VectorRn(long initLength)
+{
+	length = 0;
+	AllocLength = 0;
+	x = 0;
+	SetLength(initLength);
+}
+
+inline VectorRn::~VectorRn()
+{
+	delete[] x;
+}
+
+// Resize.
+// If the array is shortened, the information about the allocated length is lost.
+inline void VectorRn::SetLength(long newLength)
+{
+	assert(newLength > 0);
+	if (newLength > AllocLength)
+	{
+		delete[] x;
+		AllocLength = Max(newLength, AllocLength << 1);
+		x = new double[AllocLength];
+	}
+	length = newLength;
+}
+
+// Zero out the entire vector
+inline void VectorRn::SetZero()
+{
+	double* target = x;
+	for (long i = length; i > 0; i--)
+	{
+		*(target++) = 0.0;
+	}
+}
+
+// Set the value of the i-th triple of entries in the vector
+inline void VectorRn::SetTriple(long i, const VectorR3& u)
+{
+	long j = 3 * i;
+	assert(0 <= j && j + 2 < length);
+	u.Dump(x + j);
+}
+
+inline void VectorRn::Fill(double d)
+{
+	double* to = x;
+	for (long i = length; i > 0; i--)
+	{
+		*(to++) = d;
+	}
+}
+
+inline void VectorRn::Load(const double* d)
+{
+	double* to = x;
+	for (long i = length; i > 0; i--)
+	{
+		*(to++) = *(d++);
+	}
+}
+
+inline void VectorRn::LoadScaled(const double* d, double scaleFactor)
+{
+	double* to = x;
+	for (long i = length; i > 0; i--)
+	{
+		*(to++) = (*(d++)) * scaleFactor;
+	}
+}
+
+inline void VectorRn::Set(const VectorRn& src)
+{
+	assert(src.length == this->length);
+	double* to = x;
+	double* from = src.x;
+	for (long i = length; i > 0; i--)
+	{
+		*(to++) = *(from++);
+	}
+}
+
+inline VectorRn& VectorRn::operator+=(const VectorRn& src)
+{
+	assert(src.length == this->length);
+	double* to = x;
+	double* from = src.x;
+	for (long i = length; i > 0; i--)
+	{
+		*(to++) += *(from++);
+	}
+	return *this;
+}
+
+inline VectorRn& VectorRn::operator-=(const VectorRn& src)
+{
+	assert(src.length == this->length);
+	double* to = x;
+	double* from = src.x;
+	for (long i = length; i > 0; i--)
+	{
+		*(to++) -= *(from++);
+	}
+	return *this;
+}
+
+inline void VectorRn::AddScaled(const VectorRn& src, double scaleFactor)
+{
+	assert(src.length == this->length);
+	double* to = x;
+	double* from = src.x;
+	for (long i = length; i > 0; i--)
+	{
+		*(to++) += (*(from++)) * scaleFactor;
+	}
+}
+
+inline VectorRn& VectorRn::operator*=(double f)
+{
+	double* target = x;
+	for (long i = length; i > 0; i--)
+	{
+		*(target++) *= f;
+	}
+	return *this;
+}
+
+inline double VectorRn::NormSq() const
+{
+	double* target = x;
+	double res = 0.0;
+	for (long i = length; i > 0; i--)
+	{
+		res += (*target) * (*target);
+		target++;
+	}
+	return res;
+}
+
+inline double Dot(const VectorRn& u, const VectorRn& v)
+{
+	assert(u.GetLength() == v.GetLength());
+	double res = 0.0;
+	const double* p = u.GetPtr();
+	const double* q = v.GetPtr();
+	for (long i = u.GetLength(); i > 0; i--)
+	{
+		res += (*(p++)) * (*(q++));
+	}
+	return res;
+}
+
+#endif  //VECTOR_RN_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Cholesky/LDLT.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Cholesky/LDLT.h
new file mode 100644
index 00000000..968427b3
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Cholesky/LDLT.h
@@ -0,0 +1,668 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2011 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Keir Mierle <mierle@gmail.com>
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2011 Timothy E. Holy <tim.holy@gmail.com >
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_LDLT_H
+#define EIGEN_LDLT_H
+
+namespace Eigen {
+
+namespace internal {
+  template<typename MatrixType, int UpLo> struct LDLT_Traits;
+
+  // PositiveSemiDef means positive semi-definite and non-zero; same for NegativeSemiDef
+  enum SignMatrix { PositiveSemiDef, NegativeSemiDef, ZeroSign, Indefinite };
+}
+
+/** \ingroup Cholesky_Module
+  *
+  * \class LDLT
+  *
+  * \brief Robust Cholesky decomposition of a matrix with pivoting
+  *
+  * \tparam _MatrixType the type of the matrix of which to compute the LDL^T Cholesky decomposition
+  * \tparam _UpLo the triangular part that will be used for the decompositon: Lower (default) or Upper.
+  *             The other triangular part won't be read.
+  *
+  * Perform a robust Cholesky decomposition of a positive semidefinite or negative semidefinite
+  * matrix \f$ A \f$ such that \f$ A =  P^TLDL^*P \f$, where P is a permutation matrix, L
+  * is lower triangular with a unit diagonal and D is a diagonal matrix.
+  *
+  * The decomposition uses pivoting to ensure stability, so that L will have
+  * zeros in the bottom right rank(A) - n submatrix. Avoiding the square root
+  * on D also stabilizes the computation.
+  *
+  * Remember that Cholesky decompositions are not rank-revealing. Also, do not use a Cholesky
+  * decomposition to determine whether a system of equations has a solution.
+  *
+  * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
+  * 
+  * \sa MatrixBase::ldlt(), SelfAdjointView::ldlt(), class LLT
+  */
+template<typename _MatrixType, int _UpLo> class LDLT
+{
+  public:
+    typedef _MatrixType MatrixType;
+    enum {
+      RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
+      UpLo = _UpLo
+    };
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef Matrix<Scalar, RowsAtCompileTime, 1, 0, MaxRowsAtCompileTime, 1> TmpMatrixType;
+
+    typedef Transpositions<RowsAtCompileTime, MaxRowsAtCompileTime> TranspositionType;
+    typedef PermutationMatrix<RowsAtCompileTime, MaxRowsAtCompileTime> PermutationType;
+
+    typedef internal::LDLT_Traits<MatrixType,UpLo> Traits;
+
+    /** \brief Default Constructor.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via LDLT::compute(const MatrixType&).
+      */
+    LDLT()
+      : m_matrix(),
+        m_transpositions(),
+        m_sign(internal::ZeroSign),
+        m_isInitialized(false)
+    {}
+
+    /** \brief Default Constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem \a size.
+      * \sa LDLT()
+      */
+    explicit LDLT(Index size)
+      : m_matrix(size, size),
+        m_transpositions(size),
+        m_temporary(size),
+        m_sign(internal::ZeroSign),
+        m_isInitialized(false)
+    {}
+
+    /** \brief Constructor with decomposition
+      *
+      * This calculates the decomposition for the input \a matrix.
+      *
+      * \sa LDLT(Index size)
+      */
+    template<typename InputType>
+    explicit LDLT(const EigenBase<InputType>& matrix)
+      : m_matrix(matrix.rows(), matrix.cols()),
+        m_transpositions(matrix.rows()),
+        m_temporary(matrix.rows()),
+        m_sign(internal::ZeroSign),
+        m_isInitialized(false)
+    {
+      compute(matrix.derived());
+    }
+
+    /** \brief Constructs a LDLT factorization from a given matrix
+      *
+      * This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when \c MatrixType is a Eigen::Ref.
+      *
+      * \sa LDLT(const EigenBase&)
+      */
+    template<typename InputType>
+    explicit LDLT(EigenBase<InputType>& matrix)
+      : m_matrix(matrix.derived()),
+        m_transpositions(matrix.rows()),
+        m_temporary(matrix.rows()),
+        m_sign(internal::ZeroSign),
+        m_isInitialized(false)
+    {
+      compute(matrix.derived());
+    }
+
+    /** Clear any existing decomposition
+     * \sa rankUpdate(w,sigma)
+     */
+    void setZero()
+    {
+      m_isInitialized = false;
+    }
+
+    /** \returns a view of the upper triangular matrix U */
+    inline typename Traits::MatrixU matrixU() const
+    {
+      eigen_assert(m_isInitialized && "LDLT is not initialized.");
+      return Traits::getU(m_matrix);
+    }
+
+    /** \returns a view of the lower triangular matrix L */
+    inline typename Traits::MatrixL matrixL() const
+    {
+      eigen_assert(m_isInitialized && "LDLT is not initialized.");
+      return Traits::getL(m_matrix);
+    }
+
+    /** \returns the permutation matrix P as a transposition sequence.
+      */
+    inline const TranspositionType& transpositionsP() const
+    {
+      eigen_assert(m_isInitialized && "LDLT is not initialized.");
+      return m_transpositions;
+    }
+
+    /** \returns the coefficients of the diagonal matrix D */
+    inline Diagonal<const MatrixType> vectorD() const
+    {
+      eigen_assert(m_isInitialized && "LDLT is not initialized.");
+      return m_matrix.diagonal();
+    }
+
+    /** \returns true if the matrix is positive (semidefinite) */
+    inline bool isPositive() const
+    {
+      eigen_assert(m_isInitialized && "LDLT is not initialized.");
+      return m_sign == internal::PositiveSemiDef || m_sign == internal::ZeroSign;
+    }
+
+    /** \returns true if the matrix is negative (semidefinite) */
+    inline bool isNegative(void) const
+    {
+      eigen_assert(m_isInitialized && "LDLT is not initialized.");
+      return m_sign == internal::NegativeSemiDef || m_sign == internal::ZeroSign;
+    }
+
+    /** \returns a solution x of \f$ A x = b \f$ using the current decomposition of A.
+      *
+      * This function also supports in-place solves using the syntax <tt>x = decompositionObject.solve(x)</tt> .
+      *
+      * \note_about_checking_solutions
+      *
+      * More precisely, this method solves \f$ A x = b \f$ using the decomposition \f$ A = P^T L D L^* P \f$
+      * by solving the systems \f$ P^T y_1 = b \f$, \f$ L y_2 = y_1 \f$, \f$ D y_3 = y_2 \f$,
+      * \f$ L^* y_4 = y_3 \f$ and \f$ P x = y_4 \f$ in succession. If the matrix \f$ A \f$ is singular, then
+      * \f$ D \f$ will also be singular (all the other matrices are invertible). In that case, the
+      * least-square solution of \f$ D y_3 = y_2 \f$ is computed. This does not mean that this function
+      * computes the least-square solution of \f$ A x = b \f$ is \f$ A \f$ is singular.
+      *
+      * \sa MatrixBase::ldlt(), SelfAdjointView::ldlt()
+      */
+    template<typename Rhs>
+    inline const Solve<LDLT, Rhs>
+    solve(const MatrixBase<Rhs>& b) const
+    {
+      eigen_assert(m_isInitialized && "LDLT is not initialized.");
+      eigen_assert(m_matrix.rows()==b.rows()
+                && "LDLT::solve(): invalid number of rows of the right hand side matrix b");
+      return Solve<LDLT, Rhs>(*this, b.derived());
+    }
+
+    template<typename Derived>
+    bool solveInPlace(MatrixBase<Derived> &bAndX) const;
+
+    template<typename InputType>
+    LDLT& compute(const EigenBase<InputType>& matrix);
+
+    /** \returns an estimate of the reciprocal condition number of the matrix of
+     *  which \c *this is the LDLT decomposition.
+     */
+    RealScalar rcond() const
+    {
+      eigen_assert(m_isInitialized && "LDLT is not initialized.");
+      return internal::rcond_estimate_helper(m_l1_norm, *this);
+    }
+
+    template <typename Derived>
+    LDLT& rankUpdate(const MatrixBase<Derived>& w, const RealScalar& alpha=1);
+
+    /** \returns the internal LDLT decomposition matrix
+      *
+      * TODO: document the storage layout
+      */
+    inline const MatrixType& matrixLDLT() const
+    {
+      eigen_assert(m_isInitialized && "LDLT is not initialized.");
+      return m_matrix;
+    }
+
+    MatrixType reconstructedMatrix() const;
+
+    /** \returns the adjoint of \c *this, that is, a const reference to the decomposition itself as the underlying matrix is self-adjoint.
+      *
+      * This method is provided for compatibility with other matrix decompositions, thus enabling generic code such as:
+      * \code x = decomposition.adjoint().solve(b) \endcode
+      */
+    const LDLT& adjoint() const { return *this; };
+
+    inline Index rows() const { return m_matrix.rows(); }
+    inline Index cols() const { return m_matrix.cols(); }
+
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was succesful,
+      *          \c NumericalIssue if the factorization failed because of a zero pivot.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "LDLT is not initialized.");
+      return m_info;
+    }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename RhsType, typename DstType>
+    void _solve_impl(const RhsType &rhs, DstType &dst) const;
+    #endif
+
+  protected:
+
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+    }
+
+    /** \internal
+      * Used to compute and store the Cholesky decomposition A = L D L^* = U^* D U.
+      * The strict upper part is used during the decomposition, the strict lower
+      * part correspond to the coefficients of L (its diagonal is equal to 1 and
+      * is not stored), and the diagonal entries correspond to D.
+      */
+    MatrixType m_matrix;
+    RealScalar m_l1_norm;
+    TranspositionType m_transpositions;
+    TmpMatrixType m_temporary;
+    internal::SignMatrix m_sign;
+    bool m_isInitialized;
+    ComputationInfo m_info;
+};
+
+namespace internal {
+
+template<int UpLo> struct ldlt_inplace;
+
+template<> struct ldlt_inplace<Lower>
+{
+  template<typename MatrixType, typename TranspositionType, typename Workspace>
+  static bool unblocked(MatrixType& mat, TranspositionType& transpositions, Workspace& temp, SignMatrix& sign)
+  {
+    using std::abs;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef typename TranspositionType::StorageIndex IndexType;
+    eigen_assert(mat.rows()==mat.cols());
+    const Index size = mat.rows();
+    bool found_zero_pivot = false;
+    bool ret = true;
+
+    if (size <= 1)
+    {
+      transpositions.setIdentity();
+      if (numext::real(mat.coeff(0,0)) > static_cast<RealScalar>(0) ) sign = PositiveSemiDef;
+      else if (numext::real(mat.coeff(0,0)) < static_cast<RealScalar>(0)) sign = NegativeSemiDef;
+      else sign = ZeroSign;
+      return true;
+    }
+
+    for (Index k = 0; k < size; ++k)
+    {
+      // Find largest diagonal element
+      Index index_of_biggest_in_corner;
+      mat.diagonal().tail(size-k).cwiseAbs().maxCoeff(&index_of_biggest_in_corner);
+      index_of_biggest_in_corner += k;
+
+      transpositions.coeffRef(k) = IndexType(index_of_biggest_in_corner);
+      if(k != index_of_biggest_in_corner)
+      {
+        // apply the transposition while taking care to consider only
+        // the lower triangular part
+        Index s = size-index_of_biggest_in_corner-1; // trailing size after the biggest element
+        mat.row(k).head(k).swap(mat.row(index_of_biggest_in_corner).head(k));
+        mat.col(k).tail(s).swap(mat.col(index_of_biggest_in_corner).tail(s));
+        std::swap(mat.coeffRef(k,k),mat.coeffRef(index_of_biggest_in_corner,index_of_biggest_in_corner));
+        for(Index i=k+1;i<index_of_biggest_in_corner;++i)
+        {
+          Scalar tmp = mat.coeffRef(i,k);
+          mat.coeffRef(i,k) = numext::conj(mat.coeffRef(index_of_biggest_in_corner,i));
+          mat.coeffRef(index_of_biggest_in_corner,i) = numext::conj(tmp);
+        }
+        if(NumTraits<Scalar>::IsComplex)
+          mat.coeffRef(index_of_biggest_in_corner,k) = numext::conj(mat.coeff(index_of_biggest_in_corner,k));
+      }
+
+      // partition the matrix:
+      //       A00 |  -  |  -
+      // lu  = A10 | A11 |  -
+      //       A20 | A21 | A22
+      Index rs = size - k - 1;
+      Block<MatrixType,Dynamic,1> A21(mat,k+1,k,rs,1);
+      Block<MatrixType,1,Dynamic> A10(mat,k,0,1,k);
+      Block<MatrixType,Dynamic,Dynamic> A20(mat,k+1,0,rs,k);
+
+      if(k>0)
+      {
+        temp.head(k) = mat.diagonal().real().head(k).asDiagonal() * A10.adjoint();
+        mat.coeffRef(k,k) -= (A10 * temp.head(k)).value();
+        if(rs>0)
+          A21.noalias() -= A20 * temp.head(k);
+      }
+
+      // In some previous versions of Eigen (e.g., 3.2.1), the scaling was omitted if the pivot
+      // was smaller than the cutoff value. However, since LDLT is not rank-revealing
+      // we should only make sure that we do not introduce INF or NaN values.
+      // Remark that LAPACK also uses 0 as the cutoff value.
+      RealScalar realAkk = numext::real(mat.coeffRef(k,k));
+      bool pivot_is_valid = (abs(realAkk) > RealScalar(0));
+
+      if(k==0 && !pivot_is_valid)
+      {
+        // The entire diagonal is zero, there is nothing more to do
+        // except filling the transpositions, and checking whether the matrix is zero.
+        sign = ZeroSign;
+        for(Index j = 0; j<size; ++j)
+        {
+          transpositions.coeffRef(j) = IndexType(j);
+          ret = ret && (mat.col(j).tail(size-j-1).array()==Scalar(0)).all();
+        }
+        return ret;
+      }
+
+      if((rs>0) && pivot_is_valid)
+        A21 /= realAkk;
+
+      if(found_zero_pivot && pivot_is_valid) ret = false; // factorization failed
+      else if(!pivot_is_valid) found_zero_pivot = true;
+
+      if (sign == PositiveSemiDef) {
+        if (realAkk < static_cast<RealScalar>(0)) sign = Indefinite;
+      } else if (sign == NegativeSemiDef) {
+        if (realAkk > static_cast<RealScalar>(0)) sign = Indefinite;
+      } else if (sign == ZeroSign) {
+        if (realAkk > static_cast<RealScalar>(0)) sign = PositiveSemiDef;
+        else if (realAkk < static_cast<RealScalar>(0)) sign = NegativeSemiDef;
+      }
+    }
+
+    return ret;
+  }
+
+  // Reference for the algorithm: Davis and Hager, "Multiple Rank
+  // Modifications of a Sparse Cholesky Factorization" (Algorithm 1)
+  // Trivial rearrangements of their computations (Timothy E. Holy)
+  // allow their algorithm to work for rank-1 updates even if the
+  // original matrix is not of full rank.
+  // Here only rank-1 updates are implemented, to reduce the
+  // requirement for intermediate storage and improve accuracy
+  template<typename MatrixType, typename WDerived>
+  static bool updateInPlace(MatrixType& mat, MatrixBase<WDerived>& w, const typename MatrixType::RealScalar& sigma=1)
+  {
+    using numext::isfinite;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+
+    const Index size = mat.rows();
+    eigen_assert(mat.cols() == size && w.size()==size);
+
+    RealScalar alpha = 1;
+
+    // Apply the update
+    for (Index j = 0; j < size; j++)
+    {
+      // Check for termination due to an original decomposition of low-rank
+      if (!(isfinite)(alpha))
+        break;
+
+      // Update the diagonal terms
+      RealScalar dj = numext::real(mat.coeff(j,j));
+      Scalar wj = w.coeff(j);
+      RealScalar swj2 = sigma*numext::abs2(wj);
+      RealScalar gamma = dj*alpha + swj2;
+
+      mat.coeffRef(j,j) += swj2/alpha;
+      alpha += swj2/dj;
+
+
+      // Update the terms of L
+      Index rs = size-j-1;
+      w.tail(rs) -= wj * mat.col(j).tail(rs);
+      if(gamma != 0)
+        mat.col(j).tail(rs) += (sigma*numext::conj(wj)/gamma)*w.tail(rs);
+    }
+    return true;
+  }
+
+  template<typename MatrixType, typename TranspositionType, typename Workspace, typename WType>
+  static bool update(MatrixType& mat, const TranspositionType& transpositions, Workspace& tmp, const WType& w, const typename MatrixType::RealScalar& sigma=1)
+  {
+    // Apply the permutation to the input w
+    tmp = transpositions * w;
+
+    return ldlt_inplace<Lower>::updateInPlace(mat,tmp,sigma);
+  }
+};
+
+template<> struct ldlt_inplace<Upper>
+{
+  template<typename MatrixType, typename TranspositionType, typename Workspace>
+  static EIGEN_STRONG_INLINE bool unblocked(MatrixType& mat, TranspositionType& transpositions, Workspace& temp, SignMatrix& sign)
+  {
+    Transpose<MatrixType> matt(mat);
+    return ldlt_inplace<Lower>::unblocked(matt, transpositions, temp, sign);
+  }
+
+  template<typename MatrixType, typename TranspositionType, typename Workspace, typename WType>
+  static EIGEN_STRONG_INLINE bool update(MatrixType& mat, TranspositionType& transpositions, Workspace& tmp, WType& w, const typename MatrixType::RealScalar& sigma=1)
+  {
+    Transpose<MatrixType> matt(mat);
+    return ldlt_inplace<Lower>::update(matt, transpositions, tmp, w.conjugate(), sigma);
+  }
+};
+
+template<typename MatrixType> struct LDLT_Traits<MatrixType,Lower>
+{
+  typedef const TriangularView<const MatrixType, UnitLower> MatrixL;
+  typedef const TriangularView<const typename MatrixType::AdjointReturnType, UnitUpper> MatrixU;
+  static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); }
+  static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoint()); }
+};
+
+template<typename MatrixType> struct LDLT_Traits<MatrixType,Upper>
+{
+  typedef const TriangularView<const typename MatrixType::AdjointReturnType, UnitLower> MatrixL;
+  typedef const TriangularView<const MatrixType, UnitUpper> MatrixU;
+  static inline MatrixL getL(const MatrixType& m) { return MatrixL(m.adjoint()); }
+  static inline MatrixU getU(const MatrixType& m) { return MatrixU(m); }
+};
+
+} // end namespace internal
+
+/** Compute / recompute the LDLT decomposition A = L D L^* = U^* D U of \a matrix
+  */
+template<typename MatrixType, int _UpLo>
+template<typename InputType>
+LDLT<MatrixType,_UpLo>& LDLT<MatrixType,_UpLo>::compute(const EigenBase<InputType>& a)
+{
+  check_template_parameters();
+
+  eigen_assert(a.rows()==a.cols());
+  const Index size = a.rows();
+
+  m_matrix = a.derived();
+
+  // Compute matrix L1 norm = max abs column sum.
+  m_l1_norm = RealScalar(0);
+  // TODO move this code to SelfAdjointView
+  for (Index col = 0; col < size; ++col) {
+    RealScalar abs_col_sum;
+    if (_UpLo == Lower)
+      abs_col_sum = m_matrix.col(col).tail(size - col).template lpNorm<1>() + m_matrix.row(col).head(col).template lpNorm<1>();
+    else
+      abs_col_sum = m_matrix.col(col).head(col).template lpNorm<1>() + m_matrix.row(col).tail(size - col).template lpNorm<1>();
+    if (abs_col_sum > m_l1_norm)
+      m_l1_norm = abs_col_sum;
+  }
+
+  m_transpositions.resize(size);
+  m_isInitialized = false;
+  m_temporary.resize(size);
+  m_sign = internal::ZeroSign;
+
+  m_info = internal::ldlt_inplace<UpLo>::unblocked(m_matrix, m_transpositions, m_temporary, m_sign) ? Success : NumericalIssue;
+
+  m_isInitialized = true;
+  return *this;
+}
+
+/** Update the LDLT decomposition:  given A = L D L^T, efficiently compute the decomposition of A + sigma w w^T.
+ * \param w a vector to be incorporated into the decomposition.
+ * \param sigma a scalar, +1 for updates and -1 for "downdates," which correspond to removing previously-added column vectors. Optional; default value is +1.
+ * \sa setZero()
+  */
+template<typename MatrixType, int _UpLo>
+template<typename Derived>
+LDLT<MatrixType,_UpLo>& LDLT<MatrixType,_UpLo>::rankUpdate(const MatrixBase<Derived>& w, const typename LDLT<MatrixType,_UpLo>::RealScalar& sigma)
+{
+  typedef typename TranspositionType::StorageIndex IndexType;
+  const Index size = w.rows();
+  if (m_isInitialized)
+  {
+    eigen_assert(m_matrix.rows()==size);
+  }
+  else
+  {
+    m_matrix.resize(size,size);
+    m_matrix.setZero();
+    m_transpositions.resize(size);
+    for (Index i = 0; i < size; i++)
+      m_transpositions.coeffRef(i) = IndexType(i);
+    m_temporary.resize(size);
+    m_sign = sigma>=0 ? internal::PositiveSemiDef : internal::NegativeSemiDef;
+    m_isInitialized = true;
+  }
+
+  internal::ldlt_inplace<UpLo>::update(m_matrix, m_transpositions, m_temporary, w, sigma);
+
+  return *this;
+}
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename _MatrixType, int _UpLo>
+template<typename RhsType, typename DstType>
+void LDLT<_MatrixType,_UpLo>::_solve_impl(const RhsType &rhs, DstType &dst) const
+{
+  eigen_assert(rhs.rows() == rows());
+  // dst = P b
+  dst = m_transpositions * rhs;
+
+  // dst = L^-1 (P b)
+  matrixL().solveInPlace(dst);
+
+  // dst = D^-1 (L^-1 P b)
+  // more precisely, use pseudo-inverse of D (see bug 241)
+  using std::abs;
+  const typename Diagonal<const MatrixType>::RealReturnType vecD(vectorD());
+  // In some previous versions, tolerance was set to the max of 1/highest and the maximal diagonal entry * epsilon
+  // as motivated by LAPACK's xGELSS:
+  // RealScalar tolerance = numext::maxi(vecD.array().abs().maxCoeff() * NumTraits<RealScalar>::epsilon(),RealScalar(1) / NumTraits<RealScalar>::highest());
+  // However, LDLT is not rank revealing, and so adjusting the tolerance wrt to the highest
+  // diagonal element is not well justified and leads to numerical issues in some cases.
+  // Moreover, Lapack's xSYTRS routines use 0 for the tolerance.
+  RealScalar tolerance = RealScalar(1) / NumTraits<RealScalar>::highest();
+
+  for (Index i = 0; i < vecD.size(); ++i)
+  {
+    if(abs(vecD(i)) > tolerance)
+      dst.row(i) /= vecD(i);
+    else
+      dst.row(i).setZero();
+  }
+
+  // dst = L^-T (D^-1 L^-1 P b)
+  matrixU().solveInPlace(dst);
+
+  // dst = P^-1 (L^-T D^-1 L^-1 P b) = A^-1 b
+  dst = m_transpositions.transpose() * dst;
+}
+#endif
+
+/** \internal use x = ldlt_object.solve(x);
+  *
+  * This is the \em in-place version of solve().
+  *
+  * \param bAndX represents both the right-hand side matrix b and result x.
+  *
+  * \returns true always! If you need to check for existence of solutions, use another decomposition like LU, QR, or SVD.
+  *
+  * This version avoids a copy when the right hand side matrix b is not
+  * needed anymore.
+  *
+  * \sa LDLT::solve(), MatrixBase::ldlt()
+  */
+template<typename MatrixType,int _UpLo>
+template<typename Derived>
+bool LDLT<MatrixType,_UpLo>::solveInPlace(MatrixBase<Derived> &bAndX) const
+{
+  eigen_assert(m_isInitialized && "LDLT is not initialized.");
+  eigen_assert(m_matrix.rows() == bAndX.rows());
+
+  bAndX = this->solve(bAndX);
+
+  return true;
+}
+
+/** \returns the matrix represented by the decomposition,
+ * i.e., it returns the product: P^T L D L^* P.
+ * This function is provided for debug purpose. */
+template<typename MatrixType, int _UpLo>
+MatrixType LDLT<MatrixType,_UpLo>::reconstructedMatrix() const
+{
+  eigen_assert(m_isInitialized && "LDLT is not initialized.");
+  const Index size = m_matrix.rows();
+  MatrixType res(size,size);
+
+  // P
+  res.setIdentity();
+  res = transpositionsP() * res;
+  // L^* P
+  res = matrixU() * res;
+  // D(L^*P)
+  res = vectorD().real().asDiagonal() * res;
+  // L(DL^*P)
+  res = matrixL() * res;
+  // P^T (LDL^*P)
+  res = transpositionsP().transpose() * res;
+
+  return res;
+}
+
+/** \cholesky_module
+  * \returns the Cholesky decomposition with full pivoting without square root of \c *this
+  * \sa MatrixBase::ldlt()
+  */
+template<typename MatrixType, unsigned int UpLo>
+inline const LDLT<typename SelfAdjointView<MatrixType, UpLo>::PlainObject, UpLo>
+SelfAdjointView<MatrixType, UpLo>::ldlt() const
+{
+  return LDLT<PlainObject,UpLo>(m_matrix);
+}
+
+/** \cholesky_module
+  * \returns the Cholesky decomposition with full pivoting without square root of \c *this
+  * \sa SelfAdjointView::ldlt()
+  */
+template<typename Derived>
+inline const LDLT<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::ldlt() const
+{
+  return LDLT<PlainObject>(derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_LDLT_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Cholesky/LLT.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Cholesky/LLT.h
new file mode 100644
index 00000000..814174d4
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Cholesky/LLT.h
@@ -0,0 +1,541 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_LLT_H
+#define EIGEN_LLT_H
+
+namespace Eigen {
+
+namespace internal{
+template<typename MatrixType, int UpLo> struct LLT_Traits;
+}
+
+/** \ingroup Cholesky_Module
+  *
+  * \class LLT
+  *
+  * \brief Standard Cholesky decomposition (LL^T) of a matrix and associated features
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the LL^T Cholesky decomposition
+  * \tparam _UpLo the triangular part that will be used for the decompositon: Lower (default) or Upper.
+  *               The other triangular part won't be read.
+  *
+  * This class performs a LL^T Cholesky decomposition of a symmetric, positive definite
+  * matrix A such that A = LL^* = U^*U, where L is lower triangular.
+  *
+  * While the Cholesky decomposition is particularly useful to solve selfadjoint problems like  D^*D x = b,
+  * for that purpose, we recommend the Cholesky decomposition without square root which is more stable
+  * and even faster. Nevertheless, this standard Cholesky decomposition remains useful in many other
+  * situations like generalised eigen problems with hermitian matrices.
+  *
+  * Remember that Cholesky decompositions are not rank-revealing. This LLT decomposition is only stable on positive definite matrices,
+  * use LDLT instead for the semidefinite case. Also, do not use a Cholesky decomposition to determine whether a system of equations
+  * has a solution.
+  *
+  * Example: \include LLT_example.cpp
+  * Output: \verbinclude LLT_example.out
+  *
+  * \b Performance: for best performance, it is recommended to use a column-major storage format
+  * with the Lower triangular part (the default), or, equivalently, a row-major storage format
+  * with the Upper triangular part. Otherwise, you might get a 20% slowdown for the full factorization
+  * step, and rank-updates can be up to 3 times slower.
+  *
+  * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
+  *
+  * Note that during the decomposition, only the lower (or upper, as defined by _UpLo) triangular part of A is considered.
+  * Therefore, the strict lower part does not have to store correct values.
+  *
+  * \sa MatrixBase::llt(), SelfAdjointView::llt(), class LDLT
+  */
+template<typename _MatrixType, int _UpLo> class LLT
+{
+  public:
+    typedef _MatrixType MatrixType;
+    enum {
+      RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+    typedef typename MatrixType::StorageIndex StorageIndex;
+
+    enum {
+      PacketSize = internal::packet_traits<Scalar>::size,
+      AlignmentMask = int(PacketSize)-1,
+      UpLo = _UpLo
+    };
+
+    typedef internal::LLT_Traits<MatrixType,UpLo> Traits;
+
+    /**
+      * \brief Default Constructor.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via LLT::compute(const MatrixType&).
+      */
+    LLT() : m_matrix(), m_isInitialized(false) {}
+
+    /** \brief Default Constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem \a size.
+      * \sa LLT()
+      */
+    explicit LLT(Index size) : m_matrix(size, size),
+                    m_isInitialized(false) {}
+
+    template<typename InputType>
+    explicit LLT(const EigenBase<InputType>& matrix)
+      : m_matrix(matrix.rows(), matrix.cols()),
+        m_isInitialized(false)
+    {
+      compute(matrix.derived());
+    }
+
+    /** \brief Constructs a LDLT factorization from a given matrix
+      *
+      * This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when
+      * \c MatrixType is a Eigen::Ref.
+      *
+      * \sa LLT(const EigenBase&)
+      */
+    template<typename InputType>
+    explicit LLT(EigenBase<InputType>& matrix)
+      : m_matrix(matrix.derived()),
+        m_isInitialized(false)
+    {
+      compute(matrix.derived());
+    }
+
+    /** \returns a view of the upper triangular matrix U */
+    inline typename Traits::MatrixU matrixU() const
+    {
+      eigen_assert(m_isInitialized && "LLT is not initialized.");
+      return Traits::getU(m_matrix);
+    }
+
+    /** \returns a view of the lower triangular matrix L */
+    inline typename Traits::MatrixL matrixL() const
+    {
+      eigen_assert(m_isInitialized && "LLT is not initialized.");
+      return Traits::getL(m_matrix);
+    }
+
+    /** \returns the solution x of \f$ A x = b \f$ using the current decomposition of A.
+      *
+      * Since this LLT class assumes anyway that the matrix A is invertible, the solution
+      * theoretically exists and is unique regardless of b.
+      *
+      * Example: \include LLT_solve.cpp
+      * Output: \verbinclude LLT_solve.out
+      *
+      * \sa solveInPlace(), MatrixBase::llt(), SelfAdjointView::llt()
+      */
+    template<typename Rhs>
+    inline const Solve<LLT, Rhs>
+    solve(const MatrixBase<Rhs>& b) const
+    {
+      eigen_assert(m_isInitialized && "LLT is not initialized.");
+      eigen_assert(m_matrix.rows()==b.rows()
+                && "LLT::solve(): invalid number of rows of the right hand side matrix b");
+      return Solve<LLT, Rhs>(*this, b.derived());
+    }
+
+    template<typename Derived>
+    void solveInPlace(const MatrixBase<Derived> &bAndX) const;
+
+    template<typename InputType>
+    LLT& compute(const EigenBase<InputType>& matrix);
+
+    /** \returns an estimate of the reciprocal condition number of the matrix of
+      *  which \c *this is the Cholesky decomposition.
+      */
+    RealScalar rcond() const
+    {
+      eigen_assert(m_isInitialized && "LLT is not initialized.");
+      eigen_assert(m_info == Success && "LLT failed because matrix appears to be negative");
+      return internal::rcond_estimate_helper(m_l1_norm, *this);
+    }
+
+    /** \returns the LLT decomposition matrix
+      *
+      * TODO: document the storage layout
+      */
+    inline const MatrixType& matrixLLT() const
+    {
+      eigen_assert(m_isInitialized && "LLT is not initialized.");
+      return m_matrix;
+    }
+
+    MatrixType reconstructedMatrix() const;
+
+
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was succesful,
+      *          \c NumericalIssue if the matrix.appears not to be positive definite.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "LLT is not initialized.");
+      return m_info;
+    }
+
+    /** \returns the adjoint of \c *this, that is, a const reference to the decomposition itself as the underlying matrix is self-adjoint.
+      *
+      * This method is provided for compatibility with other matrix decompositions, thus enabling generic code such as:
+      * \code x = decomposition.adjoint().solve(b) \endcode
+      */
+    const LLT& adjoint() const { return *this; };
+
+    inline Index rows() const { return m_matrix.rows(); }
+    inline Index cols() const { return m_matrix.cols(); }
+
+    template<typename VectorType>
+    LLT rankUpdate(const VectorType& vec, const RealScalar& sigma = 1);
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename RhsType, typename DstType>
+    void _solve_impl(const RhsType &rhs, DstType &dst) const;
+    #endif
+
+  protected:
+
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+    }
+
+    /** \internal
+      * Used to compute and store L
+      * The strict upper part is not used and even not initialized.
+      */
+    MatrixType m_matrix;
+    RealScalar m_l1_norm;
+    bool m_isInitialized;
+    ComputationInfo m_info;
+};
+
+namespace internal {
+
+template<typename Scalar, int UpLo> struct llt_inplace;
+
+template<typename MatrixType, typename VectorType>
+static Index llt_rank_update_lower(MatrixType& mat, const VectorType& vec, const typename MatrixType::RealScalar& sigma)
+{
+  using std::sqrt;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef typename MatrixType::ColXpr ColXpr;
+  typedef typename internal::remove_all<ColXpr>::type ColXprCleaned;
+  typedef typename ColXprCleaned::SegmentReturnType ColXprSegment;
+  typedef Matrix<Scalar,Dynamic,1> TempVectorType;
+  typedef typename TempVectorType::SegmentReturnType TempVecSegment;
+
+  Index n = mat.cols();
+  eigen_assert(mat.rows()==n && vec.size()==n);
+
+  TempVectorType temp;
+
+  if(sigma>0)
+  {
+    // This version is based on Givens rotations.
+    // It is faster than the other one below, but only works for updates,
+    // i.e., for sigma > 0
+    temp = sqrt(sigma) * vec;
+
+    for(Index i=0; i<n; ++i)
+    {
+      JacobiRotation<Scalar> g;
+      g.makeGivens(mat(i,i), -temp(i), &mat(i,i));
+
+      Index rs = n-i-1;
+      if(rs>0)
+      {
+        ColXprSegment x(mat.col(i).tail(rs));
+        TempVecSegment y(temp.tail(rs));
+        apply_rotation_in_the_plane(x, y, g);
+      }
+    }
+  }
+  else
+  {
+    temp = vec;
+    RealScalar beta = 1;
+    for(Index j=0; j<n; ++j)
+    {
+      RealScalar Ljj = numext::real(mat.coeff(j,j));
+      RealScalar dj = numext::abs2(Ljj);
+      Scalar wj = temp.coeff(j);
+      RealScalar swj2 = sigma*numext::abs2(wj);
+      RealScalar gamma = dj*beta + swj2;
+
+      RealScalar x = dj + swj2/beta;
+      if (x<=RealScalar(0))
+        return j;
+      RealScalar nLjj = sqrt(x);
+      mat.coeffRef(j,j) = nLjj;
+      beta += swj2/dj;
+
+      // Update the terms of L
+      Index rs = n-j-1;
+      if(rs)
+      {
+        temp.tail(rs) -= (wj/Ljj) * mat.col(j).tail(rs);
+        if(gamma != 0)
+          mat.col(j).tail(rs) = (nLjj/Ljj) * mat.col(j).tail(rs) + (nLjj * sigma*numext::conj(wj)/gamma)*temp.tail(rs);
+      }
+    }
+  }
+  return -1;
+}
+
+template<typename Scalar> struct llt_inplace<Scalar, Lower>
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  template<typename MatrixType>
+  static Index unblocked(MatrixType& mat)
+  {
+    using std::sqrt;
+
+    eigen_assert(mat.rows()==mat.cols());
+    const Index size = mat.rows();
+    for(Index k = 0; k < size; ++k)
+    {
+      Index rs = size-k-1; // remaining size
+
+      Block<MatrixType,Dynamic,1> A21(mat,k+1,k,rs,1);
+      Block<MatrixType,1,Dynamic> A10(mat,k,0,1,k);
+      Block<MatrixType,Dynamic,Dynamic> A20(mat,k+1,0,rs,k);
+
+      RealScalar x = numext::real(mat.coeff(k,k));
+      if (k>0) x -= A10.squaredNorm();
+      if (x<=RealScalar(0))
+        return k;
+      mat.coeffRef(k,k) = x = sqrt(x);
+      if (k>0 && rs>0) A21.noalias() -= A20 * A10.adjoint();
+      if (rs>0) A21 /= x;
+    }
+    return -1;
+  }
+
+  template<typename MatrixType>
+  static Index blocked(MatrixType& m)
+  {
+    eigen_assert(m.rows()==m.cols());
+    Index size = m.rows();
+    if(size<32)
+      return unblocked(m);
+
+    Index blockSize = size/8;
+    blockSize = (blockSize/16)*16;
+    blockSize = (std::min)((std::max)(blockSize,Index(8)), Index(128));
+
+    for (Index k=0; k<size; k+=blockSize)
+    {
+      // partition the matrix:
+      //       A00 |  -  |  -
+      // lu  = A10 | A11 |  -
+      //       A20 | A21 | A22
+      Index bs = (std::min)(blockSize, size-k);
+      Index rs = size - k - bs;
+      Block<MatrixType,Dynamic,Dynamic> A11(m,k,   k,   bs,bs);
+      Block<MatrixType,Dynamic,Dynamic> A21(m,k+bs,k,   rs,bs);
+      Block<MatrixType,Dynamic,Dynamic> A22(m,k+bs,k+bs,rs,rs);
+
+      Index ret;
+      if((ret=unblocked(A11))>=0) return k+ret;
+      if(rs>0) A11.adjoint().template triangularView<Upper>().template solveInPlace<OnTheRight>(A21);
+      if(rs>0) A22.template selfadjointView<Lower>().rankUpdate(A21,typename NumTraits<RealScalar>::Literal(-1)); // bottleneck
+    }
+    return -1;
+  }
+
+  template<typename MatrixType, typename VectorType>
+  static Index rankUpdate(MatrixType& mat, const VectorType& vec, const RealScalar& sigma)
+  {
+    return Eigen::internal::llt_rank_update_lower(mat, vec, sigma);
+  }
+};
+
+template<typename Scalar> struct llt_inplace<Scalar, Upper>
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  template<typename MatrixType>
+  static EIGEN_STRONG_INLINE Index unblocked(MatrixType& mat)
+  {
+    Transpose<MatrixType> matt(mat);
+    return llt_inplace<Scalar, Lower>::unblocked(matt);
+  }
+  template<typename MatrixType>
+  static EIGEN_STRONG_INLINE Index blocked(MatrixType& mat)
+  {
+    Transpose<MatrixType> matt(mat);
+    return llt_inplace<Scalar, Lower>::blocked(matt);
+  }
+  template<typename MatrixType, typename VectorType>
+  static Index rankUpdate(MatrixType& mat, const VectorType& vec, const RealScalar& sigma)
+  {
+    Transpose<MatrixType> matt(mat);
+    return llt_inplace<Scalar, Lower>::rankUpdate(matt, vec.conjugate(), sigma);
+  }
+};
+
+template<typename MatrixType> struct LLT_Traits<MatrixType,Lower>
+{
+  typedef const TriangularView<const MatrixType, Lower> MatrixL;
+  typedef const TriangularView<const typename MatrixType::AdjointReturnType, Upper> MatrixU;
+  static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); }
+  static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoint()); }
+  static bool inplace_decomposition(MatrixType& m)
+  { return llt_inplace<typename MatrixType::Scalar, Lower>::blocked(m)==-1; }
+};
+
+template<typename MatrixType> struct LLT_Traits<MatrixType,Upper>
+{
+  typedef const TriangularView<const typename MatrixType::AdjointReturnType, Lower> MatrixL;
+  typedef const TriangularView<const MatrixType, Upper> MatrixU;
+  static inline MatrixL getL(const MatrixType& m) { return MatrixL(m.adjoint()); }
+  static inline MatrixU getU(const MatrixType& m) { return MatrixU(m); }
+  static bool inplace_decomposition(MatrixType& m)
+  { return llt_inplace<typename MatrixType::Scalar, Upper>::blocked(m)==-1; }
+};
+
+} // end namespace internal
+
+/** Computes / recomputes the Cholesky decomposition A = LL^* = U^*U of \a matrix
+  *
+  * \returns a reference to *this
+  *
+  * Example: \include TutorialLinAlgComputeTwice.cpp
+  * Output: \verbinclude TutorialLinAlgComputeTwice.out
+  */
+template<typename MatrixType, int _UpLo>
+template<typename InputType>
+LLT<MatrixType,_UpLo>& LLT<MatrixType,_UpLo>::compute(const EigenBase<InputType>& a)
+{
+  check_template_parameters();
+
+  eigen_assert(a.rows()==a.cols());
+  const Index size = a.rows();
+  m_matrix.resize(size, size);
+  if (!internal::is_same_dense(m_matrix, a.derived()))
+    m_matrix = a.derived();
+
+  // Compute matrix L1 norm = max abs column sum.
+  m_l1_norm = RealScalar(0);
+  // TODO move this code to SelfAdjointView
+  for (Index col = 0; col < size; ++col) {
+    RealScalar abs_col_sum;
+    if (_UpLo == Lower)
+      abs_col_sum = m_matrix.col(col).tail(size - col).template lpNorm<1>() + m_matrix.row(col).head(col).template lpNorm<1>();
+    else
+      abs_col_sum = m_matrix.col(col).head(col).template lpNorm<1>() + m_matrix.row(col).tail(size - col).template lpNorm<1>();
+    if (abs_col_sum > m_l1_norm)
+      m_l1_norm = abs_col_sum;
+  }
+
+  m_isInitialized = true;
+  bool ok = Traits::inplace_decomposition(m_matrix);
+  m_info = ok ? Success : NumericalIssue;
+
+  return *this;
+}
+
+/** Performs a rank one update (or dowdate) of the current decomposition.
+  * If A = LL^* before the rank one update,
+  * then after it we have LL^* = A + sigma * v v^* where \a v must be a vector
+  * of same dimension.
+  */
+template<typename _MatrixType, int _UpLo>
+template<typename VectorType>
+LLT<_MatrixType,_UpLo> LLT<_MatrixType,_UpLo>::rankUpdate(const VectorType& v, const RealScalar& sigma)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(VectorType);
+  eigen_assert(v.size()==m_matrix.cols());
+  eigen_assert(m_isInitialized);
+  if(internal::llt_inplace<typename MatrixType::Scalar, UpLo>::rankUpdate(m_matrix,v,sigma)>=0)
+    m_info = NumericalIssue;
+  else
+    m_info = Success;
+
+  return *this;
+}
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename _MatrixType,int _UpLo>
+template<typename RhsType, typename DstType>
+void LLT<_MatrixType,_UpLo>::_solve_impl(const RhsType &rhs, DstType &dst) const
+{
+  dst = rhs;
+  solveInPlace(dst);
+}
+#endif
+
+/** \internal use x = llt_object.solve(x);
+  *
+  * This is the \em in-place version of solve().
+  *
+  * \param bAndX represents both the right-hand side matrix b and result x.
+  *
+  * This version avoids a copy when the right hand side matrix b is not needed anymore.
+  *
+  * \warning The parameter is only marked 'const' to make the C++ compiler accept a temporary expression here.
+  * This function will const_cast it, so constness isn't honored here.
+  *
+  * \sa LLT::solve(), MatrixBase::llt()
+  */
+template<typename MatrixType, int _UpLo>
+template<typename Derived>
+void LLT<MatrixType,_UpLo>::solveInPlace(const MatrixBase<Derived> &bAndX) const
+{
+  eigen_assert(m_isInitialized && "LLT is not initialized.");
+  eigen_assert(m_matrix.rows()==bAndX.rows());
+  matrixL().solveInPlace(bAndX);
+  matrixU().solveInPlace(bAndX);
+}
+
+/** \returns the matrix represented by the decomposition,
+ * i.e., it returns the product: L L^*.
+ * This function is provided for debug purpose. */
+template<typename MatrixType, int _UpLo>
+MatrixType LLT<MatrixType,_UpLo>::reconstructedMatrix() const
+{
+  eigen_assert(m_isInitialized && "LLT is not initialized.");
+  return matrixL() * matrixL().adjoint().toDenseMatrix();
+}
+
+/** \cholesky_module
+  * \returns the LLT decomposition of \c *this
+  * \sa SelfAdjointView::llt()
+  */
+template<typename Derived>
+inline const LLT<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::llt() const
+{
+  return LLT<PlainObject>(derived());
+}
+
+/** \cholesky_module
+  * \returns the LLT decomposition of \c *this
+  * \sa SelfAdjointView::llt()
+  */
+template<typename MatrixType, unsigned int UpLo>
+inline const LLT<typename SelfAdjointView<MatrixType, UpLo>::PlainObject, UpLo>
+SelfAdjointView<MatrixType, UpLo>::llt() const
+{
+  return LLT<PlainObject,UpLo>(m_matrix);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_LLT_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Cholesky/LLT_LAPACKE.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Cholesky/LLT_LAPACKE.h
new file mode 100644
index 00000000..bc6489e6
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Cholesky/LLT_LAPACKE.h
@@ -0,0 +1,99 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to LAPACKe
+ *     LLt decomposition based on LAPACKE_?potrf function.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_LLT_LAPACKE_H
+#define EIGEN_LLT_LAPACKE_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename Scalar> struct lapacke_llt;
+
+#define EIGEN_LAPACKE_LLT(EIGTYPE, BLASTYPE, LAPACKE_PREFIX) \
+template<> struct lapacke_llt<EIGTYPE> \
+{ \
+  template<typename MatrixType> \
+  static inline Index potrf(MatrixType& m, char uplo) \
+  { \
+    lapack_int matrix_order; \
+    lapack_int size, lda, info, StorageOrder; \
+    EIGTYPE* a; \
+    eigen_assert(m.rows()==m.cols()); \
+    /* Set up parameters for ?potrf */ \
+    size = convert_index<lapack_int>(m.rows()); \
+    StorageOrder = MatrixType::Flags&RowMajorBit?RowMajor:ColMajor; \
+    matrix_order = StorageOrder==RowMajor ? LAPACK_ROW_MAJOR : LAPACK_COL_MAJOR; \
+    a = &(m.coeffRef(0,0)); \
+    lda = convert_index<lapack_int>(m.outerStride()); \
+\
+    info = LAPACKE_##LAPACKE_PREFIX##potrf( matrix_order, uplo, size, (BLASTYPE*)a, lda ); \
+    info = (info==0) ? -1 : info>0 ? info-1 : size; \
+    return info; \
+  } \
+}; \
+template<> struct llt_inplace<EIGTYPE, Lower> \
+{ \
+  template<typename MatrixType> \
+  static Index blocked(MatrixType& m) \
+  { \
+    return lapacke_llt<EIGTYPE>::potrf(m, 'L'); \
+  } \
+  template<typename MatrixType, typename VectorType> \
+  static Index rankUpdate(MatrixType& mat, const VectorType& vec, const typename MatrixType::RealScalar& sigma) \
+  { return Eigen::internal::llt_rank_update_lower(mat, vec, sigma); } \
+}; \
+template<> struct llt_inplace<EIGTYPE, Upper> \
+{ \
+  template<typename MatrixType> \
+  static Index blocked(MatrixType& m) \
+  { \
+    return lapacke_llt<EIGTYPE>::potrf(m, 'U'); \
+  } \
+  template<typename MatrixType, typename VectorType> \
+  static Index rankUpdate(MatrixType& mat, const VectorType& vec, const typename MatrixType::RealScalar& sigma) \
+  { \
+    Transpose<MatrixType> matt(mat); \
+    return llt_inplace<EIGTYPE, Lower>::rankUpdate(matt, vec.conjugate(), sigma); \
+  } \
+};
+
+EIGEN_LAPACKE_LLT(double, double, d)
+EIGEN_LAPACKE_LLT(float, float, s)
+EIGEN_LAPACKE_LLT(dcomplex, lapack_complex_double, z)
+EIGEN_LAPACKE_LLT(scomplex, lapack_complex_float, c)
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_LLT_LAPACKE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/CholmodSupport/CholmodSupport.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/CholmodSupport/CholmodSupport.h
new file mode 100644
index 00000000..dc199ece
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/CholmodSupport/CholmodSupport.h
@@ -0,0 +1,682 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CHOLMODSUPPORT_H
+#define EIGEN_CHOLMODSUPPORT_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename Scalar> struct cholmod_configure_matrix;
+
+template<> struct cholmod_configure_matrix<double> {
+  template<typename CholmodType>
+  static void run(CholmodType& mat) {
+    mat.xtype = CHOLMOD_REAL;
+    mat.dtype = CHOLMOD_DOUBLE;
+  }
+};
+
+template<> struct cholmod_configure_matrix<std::complex<double> > {
+  template<typename CholmodType>
+  static void run(CholmodType& mat) {
+    mat.xtype = CHOLMOD_COMPLEX;
+    mat.dtype = CHOLMOD_DOUBLE;
+  }
+};
+
+// Other scalar types are not yet supported by Cholmod
+// template<> struct cholmod_configure_matrix<float> {
+//   template<typename CholmodType>
+//   static void run(CholmodType& mat) {
+//     mat.xtype = CHOLMOD_REAL;
+//     mat.dtype = CHOLMOD_SINGLE;
+//   }
+// };
+//
+// template<> struct cholmod_configure_matrix<std::complex<float> > {
+//   template<typename CholmodType>
+//   static void run(CholmodType& mat) {
+//     mat.xtype = CHOLMOD_COMPLEX;
+//     mat.dtype = CHOLMOD_SINGLE;
+//   }
+// };
+
+} // namespace internal
+
+/** Wraps the Eigen sparse matrix \a mat into a Cholmod sparse matrix object.
+  * Note that the data are shared.
+  */
+template<typename _Scalar, int _Options, typename _StorageIndex>
+cholmod_sparse viewAsCholmod(Ref<SparseMatrix<_Scalar,_Options,_StorageIndex> > mat)
+{
+  cholmod_sparse res;
+  res.nzmax   = mat.nonZeros();
+  res.nrow    = mat.rows();
+  res.ncol    = mat.cols();
+  res.p       = mat.outerIndexPtr();
+  res.i       = mat.innerIndexPtr();
+  res.x       = mat.valuePtr();
+  res.z       = 0;
+  res.sorted  = 1;
+  if(mat.isCompressed())
+  {
+    res.packed  = 1;
+    res.nz = 0;
+  }
+  else
+  {
+    res.packed  = 0;
+    res.nz = mat.innerNonZeroPtr();
+  }
+
+  res.dtype   = 0;
+  res.stype   = -1;
+  
+  if (internal::is_same<_StorageIndex,int>::value)
+  {
+    res.itype = CHOLMOD_INT;
+  }
+  else if (internal::is_same<_StorageIndex,long>::value)
+  {
+    res.itype = CHOLMOD_LONG;
+  }
+  else
+  {
+    eigen_assert(false && "Index type not supported yet");
+  }
+
+  // setup res.xtype
+  internal::cholmod_configure_matrix<_Scalar>::run(res);
+  
+  res.stype = 0;
+  
+  return res;
+}
+
+template<typename _Scalar, int _Options, typename _Index>
+const cholmod_sparse viewAsCholmod(const SparseMatrix<_Scalar,_Options,_Index>& mat)
+{
+  cholmod_sparse res = viewAsCholmod(Ref<SparseMatrix<_Scalar,_Options,_Index> >(mat.const_cast_derived()));
+  return res;
+}
+
+template<typename _Scalar, int _Options, typename _Index>
+const cholmod_sparse viewAsCholmod(const SparseVector<_Scalar,_Options,_Index>& mat)
+{
+  cholmod_sparse res = viewAsCholmod(Ref<SparseMatrix<_Scalar,_Options,_Index> >(mat.const_cast_derived()));
+  return res;
+}
+
+/** Returns a view of the Eigen sparse matrix \a mat as Cholmod sparse matrix.
+  * The data are not copied but shared. */
+template<typename _Scalar, int _Options, typename _Index, unsigned int UpLo>
+cholmod_sparse viewAsCholmod(const SparseSelfAdjointView<const SparseMatrix<_Scalar,_Options,_Index>, UpLo>& mat)
+{
+  cholmod_sparse res = viewAsCholmod(Ref<SparseMatrix<_Scalar,_Options,_Index> >(mat.matrix().const_cast_derived()));
+  
+  if(UpLo==Upper) res.stype =  1;
+  if(UpLo==Lower) res.stype = -1;
+  // swap stype for rowmajor matrices (only works for real matrices)
+  EIGEN_STATIC_ASSERT((_Options & RowMajorBit) == 0 || NumTraits<_Scalar>::IsComplex == 0, THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
+  if(_Options & RowMajorBit) res.stype *=-1;
+
+  return res;
+}
+
+/** Returns a view of the Eigen \b dense matrix \a mat as Cholmod dense matrix.
+  * The data are not copied but shared. */
+template<typename Derived>
+cholmod_dense viewAsCholmod(MatrixBase<Derived>& mat)
+{
+  EIGEN_STATIC_ASSERT((internal::traits<Derived>::Flags&RowMajorBit)==0,THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
+  typedef typename Derived::Scalar Scalar;
+
+  cholmod_dense res;
+  res.nrow   = mat.rows();
+  res.ncol   = mat.cols();
+  res.nzmax  = res.nrow * res.ncol;
+  res.d      = Derived::IsVectorAtCompileTime ? mat.derived().size() : mat.derived().outerStride();
+  res.x      = (void*)(mat.derived().data());
+  res.z      = 0;
+
+  internal::cholmod_configure_matrix<Scalar>::run(res);
+
+  return res;
+}
+
+/** Returns a view of the Cholmod sparse matrix \a cm as an Eigen sparse matrix.
+  * The data are not copied but shared. */
+template<typename Scalar, int Flags, typename StorageIndex>
+MappedSparseMatrix<Scalar,Flags,StorageIndex> viewAsEigen(cholmod_sparse& cm)
+{
+  return MappedSparseMatrix<Scalar,Flags,StorageIndex>
+         (cm.nrow, cm.ncol, static_cast<StorageIndex*>(cm.p)[cm.ncol],
+          static_cast<StorageIndex*>(cm.p), static_cast<StorageIndex*>(cm.i),static_cast<Scalar*>(cm.x) );
+}
+
+namespace internal {
+
+// template specializations for int and long that call the correct cholmod method
+
+#define EIGEN_CHOLMOD_SPECIALIZE0(ret, name) \
+    template<typename _StorageIndex> inline ret cm_ ## name       (cholmod_common &Common) { return cholmod_ ## name   (&Common); } \
+    template<>                       inline ret cm_ ## name<long> (cholmod_common &Common) { return cholmod_l_ ## name (&Common); }
+
+#define EIGEN_CHOLMOD_SPECIALIZE1(ret, name, t1, a1) \
+    template<typename _StorageIndex> inline ret cm_ ## name       (t1& a1, cholmod_common &Common) { return cholmod_ ## name   (&a1, &Common); } \
+    template<>                       inline ret cm_ ## name<long> (t1& a1, cholmod_common &Common) { return cholmod_l_ ## name (&a1, &Common); }
+
+EIGEN_CHOLMOD_SPECIALIZE0(int, start)
+EIGEN_CHOLMOD_SPECIALIZE0(int, finish)
+
+EIGEN_CHOLMOD_SPECIALIZE1(int, free_factor, cholmod_factor*, L)
+EIGEN_CHOLMOD_SPECIALIZE1(int, free_dense,  cholmod_dense*,  X)
+EIGEN_CHOLMOD_SPECIALIZE1(int, free_sparse, cholmod_sparse*, A)
+
+EIGEN_CHOLMOD_SPECIALIZE1(cholmod_factor*, analyze, cholmod_sparse, A)
+
+template<typename _StorageIndex> inline cholmod_dense*  cm_solve         (int sys, cholmod_factor& L, cholmod_dense&  B, cholmod_common &Common) { return cholmod_solve     (sys, &L, &B, &Common); }
+template<>                       inline cholmod_dense*  cm_solve<long>   (int sys, cholmod_factor& L, cholmod_dense&  B, cholmod_common &Common) { return cholmod_l_solve   (sys, &L, &B, &Common); }
+
+template<typename _StorageIndex> inline cholmod_sparse* cm_spsolve       (int sys, cholmod_factor& L, cholmod_sparse& B, cholmod_common &Common) { return cholmod_spsolve   (sys, &L, &B, &Common); }
+template<>                       inline cholmod_sparse* cm_spsolve<long> (int sys, cholmod_factor& L, cholmod_sparse& B, cholmod_common &Common) { return cholmod_l_spsolve (sys, &L, &B, &Common); }
+
+template<typename _StorageIndex>
+inline int  cm_factorize_p       (cholmod_sparse*  A, double beta[2], _StorageIndex* fset, std::size_t fsize, cholmod_factor* L, cholmod_common &Common) { return cholmod_factorize_p   (A, beta, fset, fsize, L, &Common); }
+template<>
+inline int  cm_factorize_p<long> (cholmod_sparse*  A, double beta[2], long* fset,          std::size_t fsize, cholmod_factor* L, cholmod_common &Common) { return cholmod_l_factorize_p (A, beta, fset, fsize, L, &Common); }
+
+#undef EIGEN_CHOLMOD_SPECIALIZE0
+#undef EIGEN_CHOLMOD_SPECIALIZE1
+
+}  // namespace internal
+
+
+enum CholmodMode {
+  CholmodAuto, CholmodSimplicialLLt, CholmodSupernodalLLt, CholmodLDLt
+};
+
+
+/** \ingroup CholmodSupport_Module
+  * \class CholmodBase
+  * \brief The base class for the direct Cholesky factorization of Cholmod
+  * \sa class CholmodSupernodalLLT, class CholmodSimplicialLDLT, class CholmodSimplicialLLT
+  */
+template<typename _MatrixType, int _UpLo, typename Derived>
+class CholmodBase : public SparseSolverBase<Derived>
+{
+  protected:
+    typedef SparseSolverBase<Derived> Base;
+    using Base::derived;
+    using Base::m_isInitialized;
+  public:
+    typedef _MatrixType MatrixType;
+    enum { UpLo = _UpLo };
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef MatrixType CholMatrixType;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    enum {
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+
+  public:
+
+    CholmodBase()
+      : m_cholmodFactor(0), m_info(Success), m_factorizationIsOk(false), m_analysisIsOk(false)
+    {
+      EIGEN_STATIC_ASSERT((internal::is_same<double,RealScalar>::value), CHOLMOD_SUPPORTS_DOUBLE_PRECISION_ONLY);
+      m_shiftOffset[0] = m_shiftOffset[1] = 0.0;
+      internal::cm_start<StorageIndex>(m_cholmod);
+    }
+
+    explicit CholmodBase(const MatrixType& matrix)
+      : m_cholmodFactor(0), m_info(Success), m_factorizationIsOk(false), m_analysisIsOk(false)
+    {
+      EIGEN_STATIC_ASSERT((internal::is_same<double,RealScalar>::value), CHOLMOD_SUPPORTS_DOUBLE_PRECISION_ONLY);
+      m_shiftOffset[0] = m_shiftOffset[1] = 0.0;
+      internal::cm_start<StorageIndex>(m_cholmod);
+      compute(matrix);
+    }
+
+    ~CholmodBase()
+    {
+      if(m_cholmodFactor)
+        internal::cm_free_factor<StorageIndex>(m_cholmodFactor, m_cholmod);
+      internal::cm_finish<StorageIndex>(m_cholmod);
+    }
+    
+    inline StorageIndex cols() const { return internal::convert_index<StorageIndex, Index>(m_cholmodFactor->n); }
+    inline StorageIndex rows() const { return internal::convert_index<StorageIndex, Index>(m_cholmodFactor->n); }
+    
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the matrix.appears to be negative.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_info;
+    }
+
+    /** Computes the sparse Cholesky decomposition of \a matrix */
+    Derived& compute(const MatrixType& matrix)
+    {
+      analyzePattern(matrix);
+      factorize(matrix);
+      return derived();
+    }
+    
+    /** Performs a symbolic decomposition on the sparsity pattern of \a matrix.
+      *
+      * This function is particularly useful when solving for several problems having the same structure.
+      * 
+      * \sa factorize()
+      */
+    void analyzePattern(const MatrixType& matrix)
+    {
+      if(m_cholmodFactor)
+      {
+        internal::cm_free_factor<StorageIndex>(m_cholmodFactor, m_cholmod);
+        m_cholmodFactor = 0;
+      }
+      cholmod_sparse A = viewAsCholmod(matrix.template selfadjointView<UpLo>());
+      m_cholmodFactor = internal::cm_analyze<StorageIndex>(A, m_cholmod);
+      
+      this->m_isInitialized = true;
+      this->m_info = Success;
+      m_analysisIsOk = true;
+      m_factorizationIsOk = false;
+    }
+    
+    /** Performs a numeric decomposition of \a matrix
+      *
+      * The given matrix must have the same sparsity pattern as the matrix on which the symbolic decomposition has been performed.
+      *
+      * \sa analyzePattern()
+      */
+    void factorize(const MatrixType& matrix)
+    {
+      eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
+      cholmod_sparse A = viewAsCholmod(matrix.template selfadjointView<UpLo>());
+      internal::cm_factorize_p<StorageIndex>(&A, m_shiftOffset, 0, 0, m_cholmodFactor, m_cholmod);
+
+      // If the factorization failed, minor is the column at which it did. On success minor == n.
+      this->m_info = (m_cholmodFactor->minor == m_cholmodFactor->n ? Success : NumericalIssue);
+      m_factorizationIsOk = true;
+    }
+    
+    /** Returns a reference to the Cholmod's configuration structure to get a full control over the performed operations.
+     *  See the Cholmod user guide for details. */
+    cholmod_common& cholmod() { return m_cholmod; }
+    
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** \internal */
+    template<typename Rhs,typename Dest>
+    void _solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &dest) const
+    {
+      eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or symbolic()/numeric()");
+      const Index size = m_cholmodFactor->n;
+      EIGEN_UNUSED_VARIABLE(size);
+      eigen_assert(size==b.rows());
+      
+      // Cholmod needs column-major storage without inner-stride, which corresponds to the default behavior of Ref.
+      Ref<const Matrix<typename Rhs::Scalar,Dynamic,Dynamic,ColMajor> > b_ref(b.derived());
+
+      cholmod_dense b_cd = viewAsCholmod(b_ref);
+      cholmod_dense* x_cd = internal::cm_solve<StorageIndex>(CHOLMOD_A, *m_cholmodFactor, b_cd, m_cholmod);
+      if(!x_cd)
+      {
+        this->m_info = NumericalIssue;
+        return;
+      }
+      // TODO optimize this copy by swapping when possible (be careful with alignment, etc.)
+      // NOTE Actually, the copy can be avoided by calling cholmod_solve2 instead of cholmod_solve
+      dest = Matrix<Scalar,Dest::RowsAtCompileTime,Dest::ColsAtCompileTime>::Map(reinterpret_cast<Scalar*>(x_cd->x),b.rows(),b.cols());
+      internal::cm_free_dense<StorageIndex>(x_cd, m_cholmod);
+    }
+    
+    /** \internal */
+    template<typename RhsDerived, typename DestDerived>
+    void _solve_impl(const SparseMatrixBase<RhsDerived> &b, SparseMatrixBase<DestDerived> &dest) const
+    {
+      eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or symbolic()/numeric()");
+      const Index size = m_cholmodFactor->n;
+      EIGEN_UNUSED_VARIABLE(size);
+      eigen_assert(size==b.rows());
+
+      // note: cs stands for Cholmod Sparse
+      Ref<SparseMatrix<typename RhsDerived::Scalar,ColMajor,typename RhsDerived::StorageIndex> > b_ref(b.const_cast_derived());
+      cholmod_sparse b_cs = viewAsCholmod(b_ref);
+      cholmod_sparse* x_cs = internal::cm_spsolve<StorageIndex>(CHOLMOD_A, *m_cholmodFactor, b_cs, m_cholmod);
+      if(!x_cs)
+      {
+        this->m_info = NumericalIssue;
+        return;
+      }
+      // TODO optimize this copy by swapping when possible (be careful with alignment, etc.)
+      // NOTE cholmod_spsolve in fact just calls the dense solver for blocks of 4 columns at a time (similar to Eigen's sparse solver)
+      dest.derived() = viewAsEigen<typename DestDerived::Scalar,ColMajor,typename DestDerived::StorageIndex>(*x_cs);
+      internal::cm_free_sparse<StorageIndex>(x_cs, m_cholmod);
+    }
+    #endif // EIGEN_PARSED_BY_DOXYGEN
+    
+    
+    /** Sets the shift parameter that will be used to adjust the diagonal coefficients during the numerical factorization.
+      *
+      * During the numerical factorization, an offset term is added to the diagonal coefficients:\n
+      * \c d_ii = \a offset + \c d_ii
+      *
+      * The default is \a offset=0.
+      *
+      * \returns a reference to \c *this.
+      */
+    Derived& setShift(const RealScalar& offset)
+    {
+      m_shiftOffset[0] = double(offset);
+      return derived();
+    }
+    
+    /** \returns the determinant of the underlying matrix from the current factorization */
+    Scalar determinant() const
+    {
+      using std::exp;
+      return exp(logDeterminant());
+    }
+
+    /** \returns the log determinant of the underlying matrix from the current factorization */
+    Scalar logDeterminant() const
+    {
+      using std::log;
+      using numext::real;
+      eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or symbolic()/numeric()");
+
+      RealScalar logDet = 0;
+      Scalar *x = static_cast<Scalar*>(m_cholmodFactor->x);
+      if (m_cholmodFactor->is_super)
+      {
+        // Supernodal factorization stored as a packed list of dense column-major blocs,
+        // as described by the following structure:
+
+        // super[k] == index of the first column of the j-th super node
+        StorageIndex *super = static_cast<StorageIndex*>(m_cholmodFactor->super);
+        // pi[k] == offset to the description of row indices
+        StorageIndex *pi = static_cast<StorageIndex*>(m_cholmodFactor->pi);
+        // px[k] == offset to the respective dense block
+        StorageIndex *px = static_cast<StorageIndex*>(m_cholmodFactor->px);
+
+        Index nb_super_nodes = m_cholmodFactor->nsuper;
+        for (Index k=0; k < nb_super_nodes; ++k)
+        {
+          StorageIndex ncols = super[k + 1] - super[k];
+          StorageIndex nrows = pi[k + 1] - pi[k];
+
+          Map<const Array<Scalar,1,Dynamic>, 0, InnerStride<> > sk(x + px[k], ncols, InnerStride<>(nrows+1));
+          logDet += sk.real().log().sum();
+        }
+      }
+      else
+      {
+        // Simplicial factorization stored as standard CSC matrix.
+        StorageIndex *p = static_cast<StorageIndex*>(m_cholmodFactor->p);
+        Index size = m_cholmodFactor->n;
+        for (Index k=0; k<size; ++k)
+          logDet += log(real( x[p[k]] ));
+      }
+      if (m_cholmodFactor->is_ll)
+        logDet *= 2.0;
+      return logDet;
+    };
+
+    template<typename Stream>
+    void dumpMemory(Stream& /*s*/)
+    {}
+    
+  protected:
+    mutable cholmod_common m_cholmod;
+    cholmod_factor* m_cholmodFactor;
+    double m_shiftOffset[2];
+    mutable ComputationInfo m_info;
+    int m_factorizationIsOk;
+    int m_analysisIsOk;
+};
+
+/** \ingroup CholmodSupport_Module
+  * \class CholmodSimplicialLLT
+  * \brief A simplicial direct Cholesky (LLT) factorization and solver based on Cholmod
+  *
+  * This class allows to solve for A.X = B sparse linear problems via a simplicial LL^T Cholesky factorization
+  * using the Cholmod library.
+  * This simplicial variant is equivalent to Eigen's built-in SimplicialLLT class. Therefore, it has little practical interest.
+  * The sparse matrix A must be selfadjoint and positive definite. The vectors or matrices
+  * X and B can be either dense or sparse.
+  *
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam _UpLo the triangular part that will be used for the computations. It can be Lower
+  *               or Upper. Default is Lower.
+  *
+  * \implsparsesolverconcept
+  *
+  * This class supports all kind of SparseMatrix<>: row or column major; upper, lower, or both; compressed or non compressed.
+  *
+  * \warning Only double precision real and complex scalar types are supported by Cholmod.
+  *
+  * \sa \ref TutorialSparseSolverConcept, class CholmodSupernodalLLT, class SimplicialLLT
+  */
+template<typename _MatrixType, int _UpLo = Lower>
+class CholmodSimplicialLLT : public CholmodBase<_MatrixType, _UpLo, CholmodSimplicialLLT<_MatrixType, _UpLo> >
+{
+    typedef CholmodBase<_MatrixType, _UpLo, CholmodSimplicialLLT> Base;
+    using Base::m_cholmod;
+    
+  public:
+    
+    typedef _MatrixType MatrixType;
+    
+    CholmodSimplicialLLT() : Base() { init(); }
+
+    CholmodSimplicialLLT(const MatrixType& matrix) : Base()
+    {
+      init();
+      this->compute(matrix);
+    }
+
+    ~CholmodSimplicialLLT() {}
+  protected:
+    void init()
+    {
+      m_cholmod.final_asis = 0;
+      m_cholmod.supernodal = CHOLMOD_SIMPLICIAL;
+      m_cholmod.final_ll = 1;
+    }
+};
+
+
+/** \ingroup CholmodSupport_Module
+  * \class CholmodSimplicialLDLT
+  * \brief A simplicial direct Cholesky (LDLT) factorization and solver based on Cholmod
+  *
+  * This class allows to solve for A.X = B sparse linear problems via a simplicial LDL^T Cholesky factorization
+  * using the Cholmod library.
+  * This simplicial variant is equivalent to Eigen's built-in SimplicialLDLT class. Therefore, it has little practical interest.
+  * The sparse matrix A must be selfadjoint and positive definite. The vectors or matrices
+  * X and B can be either dense or sparse.
+  *
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam _UpLo the triangular part that will be used for the computations. It can be Lower
+  *               or Upper. Default is Lower.
+  *
+  * \implsparsesolverconcept
+  *
+  * This class supports all kind of SparseMatrix<>: row or column major; upper, lower, or both; compressed or non compressed.
+  *
+  * \warning Only double precision real and complex scalar types are supported by Cholmod.
+  *
+  * \sa \ref TutorialSparseSolverConcept, class CholmodSupernodalLLT, class SimplicialLDLT
+  */
+template<typename _MatrixType, int _UpLo = Lower>
+class CholmodSimplicialLDLT : public CholmodBase<_MatrixType, _UpLo, CholmodSimplicialLDLT<_MatrixType, _UpLo> >
+{
+    typedef CholmodBase<_MatrixType, _UpLo, CholmodSimplicialLDLT> Base;
+    using Base::m_cholmod;
+    
+  public:
+    
+    typedef _MatrixType MatrixType;
+    
+    CholmodSimplicialLDLT() : Base() { init(); }
+
+    CholmodSimplicialLDLT(const MatrixType& matrix) : Base()
+    {
+      init();
+      this->compute(matrix);
+    }
+
+    ~CholmodSimplicialLDLT() {}
+  protected:
+    void init()
+    {
+      m_cholmod.final_asis = 1;
+      m_cholmod.supernodal = CHOLMOD_SIMPLICIAL;
+    }
+};
+
+/** \ingroup CholmodSupport_Module
+  * \class CholmodSupernodalLLT
+  * \brief A supernodal Cholesky (LLT) factorization and solver based on Cholmod
+  *
+  * This class allows to solve for A.X = B sparse linear problems via a supernodal LL^T Cholesky factorization
+  * using the Cholmod library.
+  * This supernodal variant performs best on dense enough problems, e.g., 3D FEM, or very high order 2D FEM.
+  * The sparse matrix A must be selfadjoint and positive definite. The vectors or matrices
+  * X and B can be either dense or sparse.
+  *
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam _UpLo the triangular part that will be used for the computations. It can be Lower
+  *               or Upper. Default is Lower.
+  *
+  * \implsparsesolverconcept
+  *
+  * This class supports all kind of SparseMatrix<>: row or column major; upper, lower, or both; compressed or non compressed.
+  *
+  * \warning Only double precision real and complex scalar types are supported by Cholmod.
+  *
+  * \sa \ref TutorialSparseSolverConcept
+  */
+template<typename _MatrixType, int _UpLo = Lower>
+class CholmodSupernodalLLT : public CholmodBase<_MatrixType, _UpLo, CholmodSupernodalLLT<_MatrixType, _UpLo> >
+{
+    typedef CholmodBase<_MatrixType, _UpLo, CholmodSupernodalLLT> Base;
+    using Base::m_cholmod;
+    
+  public:
+    
+    typedef _MatrixType MatrixType;
+    
+    CholmodSupernodalLLT() : Base() { init(); }
+
+    CholmodSupernodalLLT(const MatrixType& matrix) : Base()
+    {
+      init();
+      this->compute(matrix);
+    }
+
+    ~CholmodSupernodalLLT() {}
+  protected:
+    void init()
+    {
+      m_cholmod.final_asis = 1;
+      m_cholmod.supernodal = CHOLMOD_SUPERNODAL;
+    }
+};
+
+/** \ingroup CholmodSupport_Module
+  * \class CholmodDecomposition
+  * \brief A general Cholesky factorization and solver based on Cholmod
+  *
+  * This class allows to solve for A.X = B sparse linear problems via a LL^T or LDL^T Cholesky factorization
+  * using the Cholmod library. The sparse matrix A must be selfadjoint and positive definite. The vectors or matrices
+  * X and B can be either dense or sparse.
+  *
+  * This variant permits to change the underlying Cholesky method at runtime.
+  * On the other hand, it does not provide access to the result of the factorization.
+  * The default is to let Cholmod automatically choose between a simplicial and supernodal factorization.
+  *
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam _UpLo the triangular part that will be used for the computations. It can be Lower
+  *               or Upper. Default is Lower.
+  *
+  * \implsparsesolverconcept
+  *
+  * This class supports all kind of SparseMatrix<>: row or column major; upper, lower, or both; compressed or non compressed.
+  *
+  * \warning Only double precision real and complex scalar types are supported by Cholmod.
+  *
+  * \sa \ref TutorialSparseSolverConcept
+  */
+template<typename _MatrixType, int _UpLo = Lower>
+class CholmodDecomposition : public CholmodBase<_MatrixType, _UpLo, CholmodDecomposition<_MatrixType, _UpLo> >
+{
+    typedef CholmodBase<_MatrixType, _UpLo, CholmodDecomposition> Base;
+    using Base::m_cholmod;
+    
+  public:
+    
+    typedef _MatrixType MatrixType;
+    
+    CholmodDecomposition() : Base() { init(); }
+
+    CholmodDecomposition(const MatrixType& matrix) : Base()
+    {
+      init();
+      this->compute(matrix);
+    }
+
+    ~CholmodDecomposition() {}
+    
+    void setMode(CholmodMode mode)
+    {
+      switch(mode)
+      {
+        case CholmodAuto:
+          m_cholmod.final_asis = 1;
+          m_cholmod.supernodal = CHOLMOD_AUTO;
+          break;
+        case CholmodSimplicialLLt:
+          m_cholmod.final_asis = 0;
+          m_cholmod.supernodal = CHOLMOD_SIMPLICIAL;
+          m_cholmod.final_ll = 1;
+          break;
+        case CholmodSupernodalLLt:
+          m_cholmod.final_asis = 1;
+          m_cholmod.supernodal = CHOLMOD_SUPERNODAL;
+          break;
+        case CholmodLDLt:
+          m_cholmod.final_asis = 1;
+          m_cholmod.supernodal = CHOLMOD_SIMPLICIAL;
+          break;
+        default:
+          break;
+      }
+    }
+  protected:
+    void init()
+    {
+      m_cholmod.final_asis = 1;
+      m_cholmod.supernodal = CHOLMOD_AUTO;
+    }
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_CHOLMODSUPPORT_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/ArithmeticSequence.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/ArithmeticSequence.h
new file mode 100644
index 00000000..ada1571f
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/ArithmeticSequence.h
@@ -0,0 +1,350 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2017 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ARITHMETIC_SEQUENCE_H
+#define EIGEN_ARITHMETIC_SEQUENCE_H
+
+namespace Eigen {
+
+namespace internal {
+
+#if (!EIGEN_HAS_CXX11) || !((!EIGEN_COMP_GNUC) || EIGEN_COMP_GNUC>=48)
+template<typename T> struct aseq_negate {};
+
+template<> struct aseq_negate<Index> {
+  typedef Index type;
+};
+
+template<int N> struct aseq_negate<FixedInt<N> > {
+  typedef FixedInt<-N> type;
+};
+
+// Compilation error in the following case:
+template<> struct aseq_negate<FixedInt<DynamicIndex> > {};
+
+template<typename FirstType,typename SizeType,typename IncrType,
+         bool FirstIsSymbolic=Symbolic::is_symbolic<FirstType>::value,
+         bool SizeIsSymbolic =Symbolic::is_symbolic<SizeType>::value>
+struct aseq_reverse_first_type {
+  typedef Index type;
+};
+
+template<typename FirstType,typename SizeType,typename IncrType>
+struct aseq_reverse_first_type<FirstType,SizeType,IncrType,true,true> {
+  typedef Symbolic::AddExpr<FirstType,
+                            Symbolic::ProductExpr<Symbolic::AddExpr<SizeType,Symbolic::ValueExpr<FixedInt<-1> > >,
+                                                  Symbolic::ValueExpr<IncrType> >
+                           > type;
+};
+
+template<typename SizeType,typename IncrType,typename EnableIf = void>
+struct aseq_reverse_first_type_aux {
+  typedef Index type;
+};
+
+template<typename SizeType,typename IncrType>
+struct aseq_reverse_first_type_aux<SizeType,IncrType,typename internal::enable_if<bool((SizeType::value+IncrType::value)|0x1)>::type> {
+  typedef FixedInt<(SizeType::value-1)*IncrType::value> type;
+};
+
+template<typename FirstType,typename SizeType,typename IncrType>
+struct aseq_reverse_first_type<FirstType,SizeType,IncrType,true,false> {
+  typedef typename aseq_reverse_first_type_aux<SizeType,IncrType>::type Aux;
+  typedef Symbolic::AddExpr<FirstType,Symbolic::ValueExpr<Aux> > type;
+};
+
+template<typename FirstType,typename SizeType,typename IncrType>
+struct aseq_reverse_first_type<FirstType,SizeType,IncrType,false,true> {
+  typedef Symbolic::AddExpr<Symbolic::ProductExpr<Symbolic::AddExpr<SizeType,Symbolic::ValueExpr<FixedInt<-1> > >,
+                                                  Symbolic::ValueExpr<IncrType> >,
+                            Symbolic::ValueExpr<> > type;
+};
+#endif
+
+// Helper to cleanup the type of the increment:
+template<typename T> struct cleanup_seq_incr {
+  typedef typename cleanup_index_type<T,DynamicIndex>::type type;
+};
+
+}
+
+//--------------------------------------------------------------------------------
+// seq(first,last,incr) and seqN(first,size,incr)
+//--------------------------------------------------------------------------------
+
+template<typename FirstType=Index,typename SizeType=Index,typename IncrType=internal::FixedInt<1> >
+class ArithmeticSequence;
+
+template<typename FirstType,typename SizeType,typename IncrType>
+ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,
+                   typename internal::cleanup_index_type<SizeType>::type,
+                   typename internal::cleanup_seq_incr<IncrType>::type >
+seqN(FirstType first, SizeType size, IncrType incr);
+
+/** \class ArithmeticSequence
+  * \ingroup Core_Module
+  *
+  * This class represents an arithmetic progression \f$ a_0, a_1, a_2, ..., a_{n-1}\f$ defined by
+  * its \em first value \f$ a_0 \f$, its \em size (aka length) \em n, and the \em increment (aka stride)
+  * that is equal to \f$ a_{i+1}-a_{i}\f$ for any \em i.
+  *
+  * It is internally used as the return type of the Eigen::seq and Eigen::seqN functions, and as the input arguments
+  * of DenseBase::operator()(const RowIndices&, const ColIndices&), and most of the time this is the
+  * only way it is used.
+  *
+  * \tparam FirstType type of the first element, usually an Index,
+  *                   but internally it can be a symbolic expression
+  * \tparam SizeType type representing the size of the sequence, usually an Index
+  *                  or a compile time integral constant. Internally, it can also be a symbolic expression
+  * \tparam IncrType type of the increment, can be a runtime Index, or a compile time integral constant (default is compile-time 1)
+  *
+  * \sa Eigen::seq, Eigen::seqN, DenseBase::operator()(const RowIndices&, const ColIndices&), class IndexedView
+  */
+template<typename FirstType,typename SizeType,typename IncrType>
+class ArithmeticSequence
+{
+public:
+  ArithmeticSequence(FirstType first, SizeType size) : m_first(first), m_size(size) {}
+  ArithmeticSequence(FirstType first, SizeType size, IncrType incr) : m_first(first), m_size(size), m_incr(incr) {}
+
+  enum {
+    SizeAtCompileTime = internal::get_fixed_value<SizeType>::value,
+    IncrAtCompileTime = internal::get_fixed_value<IncrType,DynamicIndex>::value
+  };
+
+  /** \returns the size, i.e., number of elements, of the sequence */
+  Index size()  const { return m_size; }
+
+  /** \returns the first element \f$ a_0 \f$ in the sequence */
+  Index first()  const { return m_first; }
+
+  /** \returns the value \f$ a_i \f$ at index \a i in the sequence. */
+  Index operator[](Index i) const { return m_first + i * m_incr; }
+
+  const FirstType& firstObject() const { return m_first; }
+  const SizeType&  sizeObject()  const { return m_size; }
+  const IncrType&  incrObject()  const { return m_incr; }
+
+protected:
+  FirstType m_first;
+  SizeType  m_size;
+  IncrType  m_incr;
+
+public:
+
+#if EIGEN_HAS_CXX11 && ((!EIGEN_COMP_GNUC) || EIGEN_COMP_GNUC>=48)
+  auto reverse() const -> decltype(Eigen::seqN(m_first+(m_size+fix<-1>())*m_incr,m_size,-m_incr)) {
+    return seqN(m_first+(m_size+fix<-1>())*m_incr,m_size,-m_incr);
+  }
+#else
+protected:
+  typedef typename internal::aseq_negate<IncrType>::type ReverseIncrType;
+  typedef typename internal::aseq_reverse_first_type<FirstType,SizeType,IncrType>::type ReverseFirstType;
+public:
+  ArithmeticSequence<ReverseFirstType,SizeType,ReverseIncrType>
+  reverse() const {
+    return seqN(m_first+(m_size+fix<-1>())*m_incr,m_size,-m_incr);
+  }
+#endif
+};
+
+/** \returns an ArithmeticSequence starting at \a first, of length \a size, and increment \a incr
+  *
+  * \sa seqN(FirstType,SizeType), seq(FirstType,LastType,IncrType) */
+template<typename FirstType,typename SizeType,typename IncrType>
+ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,typename internal::cleanup_index_type<SizeType>::type,typename internal::cleanup_seq_incr<IncrType>::type >
+seqN(FirstType first, SizeType size, IncrType incr)  {
+  return ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,typename internal::cleanup_index_type<SizeType>::type,typename internal::cleanup_seq_incr<IncrType>::type>(first,size,incr);
+}
+
+/** \returns an ArithmeticSequence starting at \a first, of length \a size, and unit increment
+  *
+  * \sa seqN(FirstType,SizeType,IncrType), seq(FirstType,LastType) */
+template<typename FirstType,typename SizeType>
+ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,typename internal::cleanup_index_type<SizeType>::type >
+seqN(FirstType first, SizeType size)  {
+  return ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,typename internal::cleanup_index_type<SizeType>::type>(first,size);
+}
+
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+
+/** \returns an ArithmeticSequence starting at \a f, up (or down) to \a l, and with positive (or negative) increment \a incr
+  *
+  * It is essentially an alias to:
+  * \code
+  * seqN(f, (l-f+incr)/incr, incr);
+  * \endcode
+  *
+  * \sa seqN(FirstType,SizeType,IncrType), seq(FirstType,LastType)
+  */
+template<typename FirstType,typename LastType, typename IncrType>
+auto seq(FirstType f, LastType l, IncrType incr);
+
+/** \returns an ArithmeticSequence starting at \a f, up (or down) to \a l, and unit increment
+  *
+  * It is essentially an alias to:
+  * \code
+  * seqN(f,l-f+1);
+  * \endcode
+  *
+  * \sa seqN(FirstType,SizeType), seq(FirstType,LastType,IncrType)
+  */
+template<typename FirstType,typename LastType>
+auto seq(FirstType f, LastType l);
+
+#else // EIGEN_PARSED_BY_DOXYGEN
+
+#if EIGEN_HAS_CXX11
+template<typename FirstType,typename LastType>
+auto seq(FirstType f, LastType l) -> decltype(seqN(typename internal::cleanup_index_type<FirstType>::type(f),
+                                                   (  typename internal::cleanup_index_type<LastType>::type(l)
+                                                    - typename internal::cleanup_index_type<FirstType>::type(f)+fix<1>())))
+{
+  return seqN(typename internal::cleanup_index_type<FirstType>::type(f),
+              (typename internal::cleanup_index_type<LastType>::type(l)
+               -typename internal::cleanup_index_type<FirstType>::type(f)+fix<1>()));
+}
+
+template<typename FirstType,typename LastType, typename IncrType>
+auto seq(FirstType f, LastType l, IncrType incr)
+  -> decltype(seqN(typename internal::cleanup_index_type<FirstType>::type(f),
+                   (   typename internal::cleanup_index_type<LastType>::type(l)
+                     - typename internal::cleanup_index_type<FirstType>::type(f)+typename internal::cleanup_seq_incr<IncrType>::type(incr)
+                   ) / typename internal::cleanup_seq_incr<IncrType>::type(incr),
+                   typename internal::cleanup_seq_incr<IncrType>::type(incr)))
+{
+  typedef typename internal::cleanup_seq_incr<IncrType>::type CleanedIncrType;
+  return seqN(typename internal::cleanup_index_type<FirstType>::type(f),
+              ( typename internal::cleanup_index_type<LastType>::type(l)
+               -typename internal::cleanup_index_type<FirstType>::type(f)+CleanedIncrType(incr)) / CleanedIncrType(incr),
+              CleanedIncrType(incr));
+}
+#else
+
+template<typename FirstType,typename LastType>
+typename internal::enable_if<!(Symbolic::is_symbolic<FirstType>::value || Symbolic::is_symbolic<LastType>::value),
+                             ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,Index> >::type
+seq(FirstType f, LastType l)
+{
+  return seqN(typename internal::cleanup_index_type<FirstType>::type(f),
+              Index((typename internal::cleanup_index_type<LastType>::type(l)-typename internal::cleanup_index_type<FirstType>::type(f)+fix<1>())));
+}
+
+template<typename FirstTypeDerived,typename LastType>
+typename internal::enable_if<!Symbolic::is_symbolic<LastType>::value,
+    ArithmeticSequence<FirstTypeDerived, Symbolic::AddExpr<Symbolic::AddExpr<Symbolic::NegateExpr<FirstTypeDerived>,Symbolic::ValueExpr<> >,
+                                                            Symbolic::ValueExpr<internal::FixedInt<1> > > > >::type
+seq(const Symbolic::BaseExpr<FirstTypeDerived> &f, LastType l)
+{
+  return seqN(f.derived(),(typename internal::cleanup_index_type<LastType>::type(l)-f.derived()+fix<1>()));
+}
+
+template<typename FirstType,typename LastTypeDerived>
+typename internal::enable_if<!Symbolic::is_symbolic<FirstType>::value,
+    ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,
+                        Symbolic::AddExpr<Symbolic::AddExpr<LastTypeDerived,Symbolic::ValueExpr<> >,
+                                          Symbolic::ValueExpr<internal::FixedInt<1> > > > >::type
+seq(FirstType f, const Symbolic::BaseExpr<LastTypeDerived> &l)
+{
+  return seqN(typename internal::cleanup_index_type<FirstType>::type(f),(l.derived()-typename internal::cleanup_index_type<FirstType>::type(f)+fix<1>()));
+}
+
+template<typename FirstTypeDerived,typename LastTypeDerived>
+ArithmeticSequence<FirstTypeDerived,
+                    Symbolic::AddExpr<Symbolic::AddExpr<LastTypeDerived,Symbolic::NegateExpr<FirstTypeDerived> >,Symbolic::ValueExpr<internal::FixedInt<1> > > >
+seq(const Symbolic::BaseExpr<FirstTypeDerived> &f, const Symbolic::BaseExpr<LastTypeDerived> &l)
+{
+  return seqN(f.derived(),(l.derived()-f.derived()+fix<1>()));
+}
+
+
+template<typename FirstType,typename LastType, typename IncrType>
+typename internal::enable_if<!(Symbolic::is_symbolic<FirstType>::value || Symbolic::is_symbolic<LastType>::value),
+    ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,Index,typename internal::cleanup_seq_incr<IncrType>::type> >::type
+seq(FirstType f, LastType l, IncrType incr)
+{
+  typedef typename internal::cleanup_seq_incr<IncrType>::type CleanedIncrType;
+  return seqN(typename internal::cleanup_index_type<FirstType>::type(f),
+              Index((typename internal::cleanup_index_type<LastType>::type(l)-typename internal::cleanup_index_type<FirstType>::type(f)+CleanedIncrType(incr))/CleanedIncrType(incr)), incr);
+}
+
+template<typename FirstTypeDerived,typename LastType, typename IncrType>
+typename internal::enable_if<!Symbolic::is_symbolic<LastType>::value,
+    ArithmeticSequence<FirstTypeDerived,
+                        Symbolic::QuotientExpr<Symbolic::AddExpr<Symbolic::AddExpr<Symbolic::NegateExpr<FirstTypeDerived>,
+                                                                                   Symbolic::ValueExpr<> >,
+                                                                 Symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >,
+                                              Symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >,
+                        typename internal::cleanup_seq_incr<IncrType>::type> >::type
+seq(const Symbolic::BaseExpr<FirstTypeDerived> &f, LastType l, IncrType incr)
+{
+  typedef typename internal::cleanup_seq_incr<IncrType>::type CleanedIncrType;
+  return seqN(f.derived(),(typename internal::cleanup_index_type<LastType>::type(l)-f.derived()+CleanedIncrType(incr))/CleanedIncrType(incr), incr);
+}
+
+template<typename FirstType,typename LastTypeDerived, typename IncrType>
+typename internal::enable_if<!Symbolic::is_symbolic<FirstType>::value,
+    ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,
+                        Symbolic::QuotientExpr<Symbolic::AddExpr<Symbolic::AddExpr<LastTypeDerived,Symbolic::ValueExpr<> >,
+                                                                 Symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >,
+                                               Symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >,
+                        typename internal::cleanup_seq_incr<IncrType>::type> >::type
+seq(FirstType f, const Symbolic::BaseExpr<LastTypeDerived> &l, IncrType incr)
+{
+  typedef typename internal::cleanup_seq_incr<IncrType>::type CleanedIncrType;
+  return seqN(typename internal::cleanup_index_type<FirstType>::type(f),
+              (l.derived()-typename internal::cleanup_index_type<FirstType>::type(f)+CleanedIncrType(incr))/CleanedIncrType(incr), incr);
+}
+
+template<typename FirstTypeDerived,typename LastTypeDerived, typename IncrType>
+ArithmeticSequence<FirstTypeDerived,
+                    Symbolic::QuotientExpr<Symbolic::AddExpr<Symbolic::AddExpr<LastTypeDerived,
+                                                                               Symbolic::NegateExpr<FirstTypeDerived> >,
+                                                             Symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >,
+                                          Symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >,
+                    typename internal::cleanup_seq_incr<IncrType>::type>
+seq(const Symbolic::BaseExpr<FirstTypeDerived> &f, const Symbolic::BaseExpr<LastTypeDerived> &l, IncrType incr)
+{
+  typedef typename internal::cleanup_seq_incr<IncrType>::type CleanedIncrType;
+  return seqN(f.derived(),(l.derived()-f.derived()+CleanedIncrType(incr))/CleanedIncrType(incr), incr);
+}
+#endif
+
+#endif // EIGEN_PARSED_BY_DOXYGEN
+
+namespace internal {
+
+// Convert a symbolic span into a usable one (i.e., remove last/end "keywords")
+template<typename T>
+struct make_size_type {
+  typedef typename internal::conditional<Symbolic::is_symbolic<T>::value, Index, T>::type type;
+};
+
+template<typename FirstType,typename SizeType,typename IncrType,int XprSize>
+struct IndexedViewCompatibleType<ArithmeticSequence<FirstType,SizeType,IncrType>, XprSize> {
+  typedef ArithmeticSequence<Index,typename make_size_type<SizeType>::type,IncrType> type;
+};
+
+template<typename FirstType,typename SizeType,typename IncrType>
+ArithmeticSequence<Index,typename make_size_type<SizeType>::type,IncrType>
+makeIndexedViewCompatible(const ArithmeticSequence<FirstType,SizeType,IncrType>& ids, Index size,SpecializedType) {
+  return ArithmeticSequence<Index,typename make_size_type<SizeType>::type,IncrType>(
+            eval_expr_given_size(ids.firstObject(),size),eval_expr_given_size(ids.sizeObject(),size),ids.incrObject());
+}
+
+template<typename FirstType,typename SizeType,typename IncrType>
+struct get_compile_time_incr<ArithmeticSequence<FirstType,SizeType,IncrType> > {
+  enum { value = get_fixed_value<IncrType,DynamicIndex>::value };
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_ARITHMETIC_SEQUENCE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Array.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Array.h
new file mode 100644
index 00000000..e10020d4
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Array.h
@@ -0,0 +1,331 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ARRAY_H
+#define EIGEN_ARRAY_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+struct traits<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > : traits<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
+{
+  typedef ArrayXpr XprKind;
+  typedef ArrayBase<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > XprBase;
+};
+}
+
+/** \class Array
+  * \ingroup Core_Module
+  *
+  * \brief General-purpose arrays with easy API for coefficient-wise operations
+  *
+  * The %Array class is very similar to the Matrix class. It provides
+  * general-purpose one- and two-dimensional arrays. The difference between the
+  * %Array and the %Matrix class is primarily in the API: the API for the
+  * %Array class provides easy access to coefficient-wise operations, while the
+  * API for the %Matrix class provides easy access to linear-algebra
+  * operations.
+  *
+  * See documentation of class Matrix for detailed information on the template parameters
+  * storage layout.
+  *
+  * This class can be extended with the help of the plugin mechanism described on the page
+  * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_ARRAY_PLUGIN.
+  *
+  * \sa \blank \ref TutorialArrayClass, \ref TopicClassHierarchy
+  */
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+class Array
+  : public PlainObjectBase<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
+{
+  public:
+
+    typedef PlainObjectBase<Array> Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Array)
+
+    enum { Options = _Options };
+    typedef typename Base::PlainObject PlainObject;
+
+  protected:
+    template <typename Derived, typename OtherDerived, bool IsVector>
+    friend struct internal::conservative_resize_like_impl;
+
+    using Base::m_storage;
+
+  public:
+
+    using Base::base;
+    using Base::coeff;
+    using Base::coeffRef;
+
+    /**
+      * The usage of
+      *   using Base::operator=;
+      * fails on MSVC. Since the code below is working with GCC and MSVC, we skipped
+      * the usage of 'using'. This should be done only for operator=.
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array& operator=(const EigenBase<OtherDerived> &other)
+    {
+      return Base::operator=(other);
+    }
+
+    /** Set all the entries to \a value.
+      * \sa DenseBase::setConstant(), DenseBase::fill()
+      */
+    /* This overload is needed because the usage of
+      *   using Base::operator=;
+      * fails on MSVC. Since the code below is working with GCC and MSVC, we skipped
+      * the usage of 'using'. This should be done only for operator=.
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array& operator=(const Scalar &value)
+    {
+      Base::setConstant(value);
+      return *this;
+    }
+
+    /** Copies the value of the expression \a other into \c *this with automatic resizing.
+      *
+      * *this might be resized to match the dimensions of \a other. If *this was a null matrix (not already initialized),
+      * it will be initialized.
+      *
+      * Note that copying a row-vector into a vector (and conversely) is allowed.
+      * The resizing, if any, is then done in the appropriate way so that row-vectors
+      * remain row-vectors and vectors remain vectors.
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array& operator=(const DenseBase<OtherDerived>& other)
+    {
+      return Base::_set(other);
+    }
+
+    /** This is a special case of the templated operator=. Its purpose is to
+      * prevent a default operator= from hiding the templated operator=.
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array& operator=(const Array& other)
+    {
+      return Base::_set(other);
+    }
+    
+    /** Default constructor.
+      *
+      * For fixed-size matrices, does nothing.
+      *
+      * For dynamic-size matrices, creates an empty matrix of size 0. Does not allocate any array. Such a matrix
+      * is called a null matrix. This constructor is the unique way to create null matrices: resizing
+      * a matrix to 0 is not supported.
+      *
+      * \sa resize(Index,Index)
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array() : Base()
+    {
+      Base::_check_template_params();
+      EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+    }
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    // FIXME is it still needed ??
+    /** \internal */
+    EIGEN_DEVICE_FUNC
+    Array(internal::constructor_without_unaligned_array_assert)
+      : Base(internal::constructor_without_unaligned_array_assert())
+    {
+      Base::_check_template_params();
+      EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+    }
+#endif
+
+#if EIGEN_HAS_RVALUE_REFERENCES
+    EIGEN_DEVICE_FUNC
+    Array(Array&& other) EIGEN_NOEXCEPT_IF(std::is_nothrow_move_constructible<Scalar>::value)
+      : Base(std::move(other))
+    {
+      Base::_check_template_params();
+      if (RowsAtCompileTime!=Dynamic && ColsAtCompileTime!=Dynamic)
+        Base::_set_noalias(other);
+    }
+    EIGEN_DEVICE_FUNC
+    Array& operator=(Array&& other) EIGEN_NOEXCEPT_IF(std::is_nothrow_move_assignable<Scalar>::value)
+    {
+      other.swap(*this);
+      return *this;
+    }
+#endif
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE explicit Array(const T& x)
+    {
+      Base::_check_template_params();
+      Base::template _init1<T>(x);
+    }
+
+    template<typename T0, typename T1>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array(const T0& val0, const T1& val1)
+    {
+      Base::_check_template_params();
+      this->template _init2<T0,T1>(val0, val1);
+    }
+    #else
+    /** \brief Constructs a fixed-sized array initialized with coefficients starting at \a data */
+    EIGEN_DEVICE_FUNC explicit Array(const Scalar *data);
+    /** Constructs a vector or row-vector with given dimension. \only_for_vectors
+      *
+      * Note that this is only useful for dynamic-size vectors. For fixed-size vectors,
+      * it is redundant to pass the dimension here, so it makes more sense to use the default
+      * constructor Array() instead.
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE explicit Array(Index dim);
+    /** constructs an initialized 1x1 Array with the given coefficient */
+    Array(const Scalar& value);
+    /** constructs an uninitialized array with \a rows rows and \a cols columns.
+      *
+      * This is useful for dynamic-size arrays. For fixed-size arrays,
+      * it is redundant to pass these parameters, so one should use the default constructor
+      * Array() instead. */
+    Array(Index rows, Index cols);
+    /** constructs an initialized 2D vector with given coefficients */
+    Array(const Scalar& val0, const Scalar& val1);
+    #endif
+
+    /** constructs an initialized 3D vector with given coefficients */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array(const Scalar& val0, const Scalar& val1, const Scalar& val2)
+    {
+      Base::_check_template_params();
+      EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Array, 3)
+      m_storage.data()[0] = val0;
+      m_storage.data()[1] = val1;
+      m_storage.data()[2] = val2;
+    }
+    /** constructs an initialized 4D vector with given coefficients */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array(const Scalar& val0, const Scalar& val1, const Scalar& val2, const Scalar& val3)
+    {
+      Base::_check_template_params();
+      EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Array, 4)
+      m_storage.data()[0] = val0;
+      m_storage.data()[1] = val1;
+      m_storage.data()[2] = val2;
+      m_storage.data()[3] = val3;
+    }
+
+    /** Copy constructor */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array(const Array& other)
+            : Base(other)
+    { }
+
+  private:
+    struct PrivateType {};
+  public:
+
+    /** \sa MatrixBase::operator=(const EigenBase<OtherDerived>&) */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array(const EigenBase<OtherDerived> &other,
+                              typename internal::enable_if<internal::is_convertible<typename OtherDerived::Scalar,Scalar>::value,
+                                                           PrivateType>::type = PrivateType())
+      : Base(other.derived())
+    { }
+
+    EIGEN_DEVICE_FUNC inline Index innerStride() const { return 1; }
+    EIGEN_DEVICE_FUNC inline Index outerStride() const { return this->innerSize(); }
+
+    #ifdef EIGEN_ARRAY_PLUGIN
+    #include EIGEN_ARRAY_PLUGIN
+    #endif
+
+  private:
+
+    template<typename MatrixType, typename OtherDerived, bool SwapPointers>
+    friend struct internal::matrix_swap_impl;
+};
+
+/** \defgroup arraytypedefs Global array typedefs
+  * \ingroup Core_Module
+  *
+  * Eigen defines several typedef shortcuts for most common 1D and 2D array types.
+  *
+  * The general patterns are the following:
+  *
+  * \c ArrayRowsColsType where \c Rows and \c Cols can be \c 2,\c 3,\c 4 for fixed size square matrices or \c X for dynamic size,
+  * and where \c Type can be \c i for integer, \c f for float, \c d for double, \c cf for complex float, \c cd
+  * for complex double.
+  *
+  * For example, \c Array33d is a fixed-size 3x3 array type of doubles, and \c ArrayXXf is a dynamic-size matrix of floats.
+  *
+  * There are also \c ArraySizeType which are self-explanatory. For example, \c Array4cf is
+  * a fixed-size 1D array of 4 complex floats.
+  *
+  * \sa class Array
+  */
+
+#define EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, Size, SizeSuffix)   \
+/** \ingroup arraytypedefs */                                    \
+typedef Array<Type, Size, Size> Array##SizeSuffix##SizeSuffix##TypeSuffix;  \
+/** \ingroup arraytypedefs */                                    \
+typedef Array<Type, Size, 1>    Array##SizeSuffix##TypeSuffix;
+
+#define EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Type, TypeSuffix, Size)         \
+/** \ingroup arraytypedefs */                                    \
+typedef Array<Type, Size, Dynamic> Array##Size##X##TypeSuffix;  \
+/** \ingroup arraytypedefs */                                    \
+typedef Array<Type, Dynamic, Size> Array##X##Size##TypeSuffix;
+
+#define EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(Type, TypeSuffix) \
+EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, 2, 2) \
+EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, 3, 3) \
+EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, 4, 4) \
+EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, Dynamic, X) \
+EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Type, TypeSuffix, 2) \
+EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Type, TypeSuffix, 3) \
+EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Type, TypeSuffix, 4)
+
+EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(int,                  i)
+EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(float,                f)
+EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(double,               d)
+EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(std::complex<float>,  cf)
+EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(std::complex<double>, cd)
+
+#undef EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES
+#undef EIGEN_MAKE_ARRAY_TYPEDEFS
+
+#undef EIGEN_MAKE_ARRAY_TYPEDEFS_LARGE
+
+#define EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, SizeSuffix) \
+using Eigen::Matrix##SizeSuffix##TypeSuffix; \
+using Eigen::Vector##SizeSuffix##TypeSuffix; \
+using Eigen::RowVector##SizeSuffix##TypeSuffix;
+
+#define EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(TypeSuffix) \
+EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, 2) \
+EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, 3) \
+EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, 4) \
+EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, X) \
+
+#define EIGEN_USING_ARRAY_TYPEDEFS \
+EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(i) \
+EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(f) \
+EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(d) \
+EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(cf) \
+EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(cd)
+
+} // end namespace Eigen
+
+#endif // EIGEN_ARRAY_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/ArrayBase.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/ArrayBase.h
new file mode 100644
index 00000000..9da960f0
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/ArrayBase.h
@@ -0,0 +1,226 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ARRAYBASE_H
+#define EIGEN_ARRAYBASE_H
+
+namespace Eigen { 
+
+template<typename ExpressionType> class MatrixWrapper;
+
+/** \class ArrayBase
+  * \ingroup Core_Module
+  *
+  * \brief Base class for all 1D and 2D array, and related expressions
+  *
+  * An array is similar to a dense vector or matrix. While matrices are mathematical
+  * objects with well defined linear algebra operators, an array is just a collection
+  * of scalar values arranged in a one or two dimensionnal fashion. As the main consequence,
+  * all operations applied to an array are performed coefficient wise. Furthermore,
+  * arrays support scalar math functions of the c++ standard library (e.g., std::sin(x)), and convenient
+  * constructors allowing to easily write generic code working for both scalar values
+  * and arrays.
+  *
+  * This class is the base that is inherited by all array expression types.
+  *
+  * \tparam Derived is the derived type, e.g., an array or an expression type.
+  *
+  * This class can be extended with the help of the plugin mechanism described on the page
+  * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_ARRAYBASE_PLUGIN.
+  *
+  * \sa class MatrixBase, \ref TopicClassHierarchy
+  */
+template<typename Derived> class ArrayBase
+  : public DenseBase<Derived>
+{
+  public:
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** The base class for a given storage type. */
+    typedef ArrayBase StorageBaseType;
+
+    typedef ArrayBase Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl;
+
+    typedef typename internal::traits<Derived>::StorageKind StorageKind;
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    typedef typename internal::packet_traits<Scalar>::type PacketScalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    typedef DenseBase<Derived> Base;
+    using Base::RowsAtCompileTime;
+    using Base::ColsAtCompileTime;
+    using Base::SizeAtCompileTime;
+    using Base::MaxRowsAtCompileTime;
+    using Base::MaxColsAtCompileTime;
+    using Base::MaxSizeAtCompileTime;
+    using Base::IsVectorAtCompileTime;
+    using Base::Flags;
+    
+    using Base::derived;
+    using Base::const_cast_derived;
+    using Base::rows;
+    using Base::cols;
+    using Base::size;
+    using Base::coeff;
+    using Base::coeffRef;
+    using Base::lazyAssign;
+    using Base::operator-;
+    using Base::operator=;
+    using Base::operator+=;
+    using Base::operator-=;
+    using Base::operator*=;
+    using Base::operator/=;
+
+    typedef typename Base::CoeffReturnType CoeffReturnType;
+
+#endif // not EIGEN_PARSED_BY_DOXYGEN
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    typedef typename Base::PlainObject PlainObject;
+
+    /** \internal Represents a matrix with all coefficients equal to one another*/
+    typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,PlainObject> ConstantReturnType;
+#endif // not EIGEN_PARSED_BY_DOXYGEN
+
+#define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::ArrayBase
+#define EIGEN_DOC_UNARY_ADDONS(X,Y)
+#   include "../plugins/MatrixCwiseUnaryOps.h"
+#   include "../plugins/ArrayCwiseUnaryOps.h"
+#   include "../plugins/CommonCwiseBinaryOps.h"
+#   include "../plugins/MatrixCwiseBinaryOps.h"
+#   include "../plugins/ArrayCwiseBinaryOps.h"
+#   ifdef EIGEN_ARRAYBASE_PLUGIN
+#     include EIGEN_ARRAYBASE_PLUGIN
+#   endif
+#undef EIGEN_CURRENT_STORAGE_BASE_CLASS
+#undef EIGEN_DOC_UNARY_ADDONS
+
+    /** Special case of the template operator=, in order to prevent the compiler
+      * from generating a default operator= (issue hit with g++ 4.1)
+      */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator=(const ArrayBase& other)
+    {
+      internal::call_assignment(derived(), other.derived());
+      return derived();
+    }
+    
+    /** Set all the entries to \a value.
+      * \sa DenseBase::setConstant(), DenseBase::fill() */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator=(const Scalar &value)
+    { Base::setConstant(value); return derived(); }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator+=(const Scalar& scalar);
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator-=(const Scalar& scalar);
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator+=(const ArrayBase<OtherDerived>& other);
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator-=(const ArrayBase<OtherDerived>& other);
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator*=(const ArrayBase<OtherDerived>& other);
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator/=(const ArrayBase<OtherDerived>& other);
+
+  public:
+    EIGEN_DEVICE_FUNC
+    ArrayBase<Derived>& array() { return *this; }
+    EIGEN_DEVICE_FUNC
+    const ArrayBase<Derived>& array() const { return *this; }
+
+    /** \returns an \link Eigen::MatrixBase Matrix \endlink expression of this array
+      * \sa MatrixBase::array() */
+    EIGEN_DEVICE_FUNC
+    MatrixWrapper<Derived> matrix() { return MatrixWrapper<Derived>(derived()); }
+    EIGEN_DEVICE_FUNC
+    const MatrixWrapper<const Derived> matrix() const { return MatrixWrapper<const Derived>(derived()); }
+
+//     template<typename Dest>
+//     inline void evalTo(Dest& dst) const { dst = matrix(); }
+
+  protected:
+    EIGEN_DEVICE_FUNC
+    ArrayBase() : Base() {}
+
+  private:
+    explicit ArrayBase(Index);
+    ArrayBase(Index,Index);
+    template<typename OtherDerived> explicit ArrayBase(const ArrayBase<OtherDerived>&);
+  protected:
+    // mixing arrays and matrices is not legal
+    template<typename OtherDerived> Derived& operator+=(const MatrixBase<OtherDerived>& )
+    {EIGEN_STATIC_ASSERT(std::ptrdiff_t(sizeof(typename OtherDerived::Scalar))==-1,YOU_CANNOT_MIX_ARRAYS_AND_MATRICES); return *this;}
+    // mixing arrays and matrices is not legal
+    template<typename OtherDerived> Derived& operator-=(const MatrixBase<OtherDerived>& )
+    {EIGEN_STATIC_ASSERT(std::ptrdiff_t(sizeof(typename OtherDerived::Scalar))==-1,YOU_CANNOT_MIX_ARRAYS_AND_MATRICES); return *this;}
+};
+
+/** replaces \c *this by \c *this - \a other.
+  *
+  * \returns a reference to \c *this
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived &
+ArrayBase<Derived>::operator-=(const ArrayBase<OtherDerived> &other)
+{
+  call_assignment(derived(), other.derived(), internal::sub_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+/** replaces \c *this by \c *this + \a other.
+  *
+  * \returns a reference to \c *this
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived &
+ArrayBase<Derived>::operator+=(const ArrayBase<OtherDerived>& other)
+{
+  call_assignment(derived(), other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+/** replaces \c *this by \c *this * \a other coefficient wise.
+  *
+  * \returns a reference to \c *this
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived &
+ArrayBase<Derived>::operator*=(const ArrayBase<OtherDerived>& other)
+{
+  call_assignment(derived(), other.derived(), internal::mul_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+/** replaces \c *this by \c *this / \a other coefficient wise.
+  *
+  * \returns a reference to \c *this
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived &
+ArrayBase<Derived>::operator/=(const ArrayBase<OtherDerived>& other)
+{
+  call_assignment(derived(), other.derived(), internal::div_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_ARRAYBASE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/ArrayWrapper.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/ArrayWrapper.h
new file mode 100644
index 00000000..688aadd6
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/ArrayWrapper.h
@@ -0,0 +1,209 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ARRAYWRAPPER_H
+#define EIGEN_ARRAYWRAPPER_H
+
+namespace Eigen { 
+
+/** \class ArrayWrapper
+  * \ingroup Core_Module
+  *
+  * \brief Expression of a mathematical vector or matrix as an array object
+  *
+  * This class is the return type of MatrixBase::array(), and most of the time
+  * this is the only way it is use.
+  *
+  * \sa MatrixBase::array(), class MatrixWrapper
+  */
+
+namespace internal {
+template<typename ExpressionType>
+struct traits<ArrayWrapper<ExpressionType> >
+  : public traits<typename remove_all<typename ExpressionType::Nested>::type >
+{
+  typedef ArrayXpr XprKind;
+  // Let's remove NestByRefBit
+  enum {
+    Flags0 = traits<typename remove_all<typename ExpressionType::Nested>::type >::Flags,
+    LvalueBitFlag = is_lvalue<ExpressionType>::value ? LvalueBit : 0,
+    Flags = (Flags0 & ~(NestByRefBit | LvalueBit)) | LvalueBitFlag
+  };
+};
+}
+
+template<typename ExpressionType>
+class ArrayWrapper : public ArrayBase<ArrayWrapper<ExpressionType> >
+{
+  public:
+    typedef ArrayBase<ArrayWrapper> Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(ArrayWrapper)
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(ArrayWrapper)
+    typedef typename internal::remove_all<ExpressionType>::type NestedExpression;
+
+    typedef typename internal::conditional<
+                       internal::is_lvalue<ExpressionType>::value,
+                       Scalar,
+                       const Scalar
+                     >::type ScalarWithConstIfNotLvalue;
+
+    typedef typename internal::ref_selector<ExpressionType>::non_const_type NestedExpressionType;
+
+    using Base::coeffRef;
+
+    EIGEN_DEVICE_FUNC
+    explicit EIGEN_STRONG_INLINE ArrayWrapper(ExpressionType& matrix) : m_expression(matrix) {}
+
+    EIGEN_DEVICE_FUNC
+    inline Index rows() const { return m_expression.rows(); }
+    EIGEN_DEVICE_FUNC
+    inline Index cols() const { return m_expression.cols(); }
+    EIGEN_DEVICE_FUNC
+    inline Index outerStride() const { return m_expression.outerStride(); }
+    EIGEN_DEVICE_FUNC
+    inline Index innerStride() const { return m_expression.innerStride(); }
+
+    EIGEN_DEVICE_FUNC
+    inline ScalarWithConstIfNotLvalue* data() { return m_expression.data(); }
+    EIGEN_DEVICE_FUNC
+    inline const Scalar* data() const { return m_expression.data(); }
+
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index rowId, Index colId) const
+    {
+      return m_expression.coeffRef(rowId, colId);
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index index) const
+    {
+      return m_expression.coeffRef(index);
+    }
+
+    template<typename Dest>
+    EIGEN_DEVICE_FUNC
+    inline void evalTo(Dest& dst) const { dst = m_expression; }
+
+    const typename internal::remove_all<NestedExpressionType>::type& 
+    EIGEN_DEVICE_FUNC
+    nestedExpression() const 
+    {
+      return m_expression;
+    }
+
+    /** Forwards the resizing request to the nested expression
+      * \sa DenseBase::resize(Index)  */
+    EIGEN_DEVICE_FUNC
+    void resize(Index newSize) { m_expression.resize(newSize); }
+    /** Forwards the resizing request to the nested expression
+      * \sa DenseBase::resize(Index,Index)*/
+    EIGEN_DEVICE_FUNC
+    void resize(Index rows, Index cols) { m_expression.resize(rows,cols); }
+
+  protected:
+    NestedExpressionType m_expression;
+};
+
+/** \class MatrixWrapper
+  * \ingroup Core_Module
+  *
+  * \brief Expression of an array as a mathematical vector or matrix
+  *
+  * This class is the return type of ArrayBase::matrix(), and most of the time
+  * this is the only way it is use.
+  *
+  * \sa MatrixBase::matrix(), class ArrayWrapper
+  */
+
+namespace internal {
+template<typename ExpressionType>
+struct traits<MatrixWrapper<ExpressionType> >
+ : public traits<typename remove_all<typename ExpressionType::Nested>::type >
+{
+  typedef MatrixXpr XprKind;
+  // Let's remove NestByRefBit
+  enum {
+    Flags0 = traits<typename remove_all<typename ExpressionType::Nested>::type >::Flags,
+    LvalueBitFlag = is_lvalue<ExpressionType>::value ? LvalueBit : 0,
+    Flags = (Flags0 & ~(NestByRefBit | LvalueBit)) | LvalueBitFlag
+  };
+};
+}
+
+template<typename ExpressionType>
+class MatrixWrapper : public MatrixBase<MatrixWrapper<ExpressionType> >
+{
+  public:
+    typedef MatrixBase<MatrixWrapper<ExpressionType> > Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(MatrixWrapper)
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(MatrixWrapper)
+    typedef typename internal::remove_all<ExpressionType>::type NestedExpression;
+
+    typedef typename internal::conditional<
+                       internal::is_lvalue<ExpressionType>::value,
+                       Scalar,
+                       const Scalar
+                     >::type ScalarWithConstIfNotLvalue;
+
+    typedef typename internal::ref_selector<ExpressionType>::non_const_type NestedExpressionType;
+
+    using Base::coeffRef;
+
+    EIGEN_DEVICE_FUNC
+    explicit inline MatrixWrapper(ExpressionType& matrix) : m_expression(matrix) {}
+
+    EIGEN_DEVICE_FUNC
+    inline Index rows() const { return m_expression.rows(); }
+    EIGEN_DEVICE_FUNC
+    inline Index cols() const { return m_expression.cols(); }
+    EIGEN_DEVICE_FUNC
+    inline Index outerStride() const { return m_expression.outerStride(); }
+    EIGEN_DEVICE_FUNC
+    inline Index innerStride() const { return m_expression.innerStride(); }
+
+    EIGEN_DEVICE_FUNC
+    inline ScalarWithConstIfNotLvalue* data() { return m_expression.data(); }
+    EIGEN_DEVICE_FUNC
+    inline const Scalar* data() const { return m_expression.data(); }
+
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index rowId, Index colId) const
+    {
+      return m_expression.derived().coeffRef(rowId, colId);
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index index) const
+    {
+      return m_expression.coeffRef(index);
+    }
+
+    EIGEN_DEVICE_FUNC
+    const typename internal::remove_all<NestedExpressionType>::type& 
+    nestedExpression() const 
+    {
+      return m_expression;
+    }
+
+    /** Forwards the resizing request to the nested expression
+      * \sa DenseBase::resize(Index)  */
+    EIGEN_DEVICE_FUNC
+    void resize(Index newSize) { m_expression.resize(newSize); }
+    /** Forwards the resizing request to the nested expression
+      * \sa DenseBase::resize(Index,Index)*/
+    EIGEN_DEVICE_FUNC
+    void resize(Index rows, Index cols) { m_expression.resize(rows,cols); }
+
+  protected:
+    NestedExpressionType m_expression;
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_ARRAYWRAPPER_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Assign.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Assign.h
new file mode 100644
index 00000000..655412ef
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Assign.h
@@ -0,0 +1,90 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007 Michael Olbrich <michael.olbrich@gmx.net>
+// Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ASSIGN_H
+#define EIGEN_ASSIGN_H
+
+namespace Eigen {
+
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>
+  ::lazyAssign(const DenseBase<OtherDerived>& other)
+{
+  enum{
+    SameType = internal::is_same<typename Derived::Scalar,typename OtherDerived::Scalar>::value
+  };
+
+  EIGEN_STATIC_ASSERT_LVALUE(Derived)
+  EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Derived,OtherDerived)
+  EIGEN_STATIC_ASSERT(SameType,YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+
+  eigen_assert(rows() == other.rows() && cols() == other.cols());
+  internal::call_assignment_no_alias(derived(),other.derived());
+  
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::operator=(const DenseBase<OtherDerived>& other)
+{
+  internal::call_assignment(derived(), other.derived());
+  return derived();
+}
+
+template<typename Derived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::operator=(const DenseBase& other)
+{
+  internal::call_assignment(derived(), other.derived());
+  return derived();
+}
+
+template<typename Derived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::operator=(const MatrixBase& other)
+{
+  internal::call_assignment(derived(), other.derived());
+  return derived();
+}
+
+template<typename Derived>
+template <typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::operator=(const DenseBase<OtherDerived>& other)
+{
+  internal::call_assignment(derived(), other.derived());
+  return derived();
+}
+
+template<typename Derived>
+template <typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::operator=(const EigenBase<OtherDerived>& other)
+{
+  internal::call_assignment(derived(), other.derived());
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::operator=(const ReturnByValue<OtherDerived>& other)
+{
+  other.derived().evalTo(derived());
+  return derived();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_ASSIGN_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/AssignEvaluator.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/AssignEvaluator.h
new file mode 100644
index 00000000..dbe435d8
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/AssignEvaluator.h
@@ -0,0 +1,935 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2011-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2011-2012 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ASSIGN_EVALUATOR_H
+#define EIGEN_ASSIGN_EVALUATOR_H
+
+namespace Eigen {
+
+// This implementation is based on Assign.h
+
+namespace internal {
+  
+/***************************************************************************
+* Part 1 : the logic deciding a strategy for traversal and unrolling       *
+***************************************************************************/
+
+// copy_using_evaluator_traits is based on assign_traits
+
+template <typename DstEvaluator, typename SrcEvaluator, typename AssignFunc>
+struct copy_using_evaluator_traits
+{
+  typedef typename DstEvaluator::XprType Dst;
+  typedef typename Dst::Scalar DstScalar;
+  
+  enum {
+    DstFlags = DstEvaluator::Flags,
+    SrcFlags = SrcEvaluator::Flags
+  };
+  
+public:
+  enum {
+    DstAlignment = DstEvaluator::Alignment,
+    SrcAlignment = SrcEvaluator::Alignment,
+    DstHasDirectAccess = (DstFlags & DirectAccessBit) == DirectAccessBit,
+    JointAlignment = EIGEN_PLAIN_ENUM_MIN(DstAlignment,SrcAlignment)
+  };
+
+private:
+  enum {
+    InnerSize = int(Dst::IsVectorAtCompileTime) ? int(Dst::SizeAtCompileTime)
+              : int(DstFlags)&RowMajorBit ? int(Dst::ColsAtCompileTime)
+              : int(Dst::RowsAtCompileTime),
+    InnerMaxSize = int(Dst::IsVectorAtCompileTime) ? int(Dst::MaxSizeAtCompileTime)
+              : int(DstFlags)&RowMajorBit ? int(Dst::MaxColsAtCompileTime)
+              : int(Dst::MaxRowsAtCompileTime),
+    OuterStride = int(outer_stride_at_compile_time<Dst>::ret),
+    MaxSizeAtCompileTime = Dst::SizeAtCompileTime
+  };
+
+  // TODO distinguish between linear traversal and inner-traversals
+  typedef typename find_best_packet<DstScalar,Dst::SizeAtCompileTime>::type LinearPacketType;
+  typedef typename find_best_packet<DstScalar,InnerSize>::type InnerPacketType;
+
+  enum {
+    LinearPacketSize = unpacket_traits<LinearPacketType>::size,
+    InnerPacketSize = unpacket_traits<InnerPacketType>::size
+  };
+
+public:
+  enum {
+    LinearRequiredAlignment = unpacket_traits<LinearPacketType>::alignment,
+    InnerRequiredAlignment = unpacket_traits<InnerPacketType>::alignment
+  };
+
+private:
+  enum {
+    DstIsRowMajor = DstFlags&RowMajorBit,
+    SrcIsRowMajor = SrcFlags&RowMajorBit,
+    StorageOrdersAgree = (int(DstIsRowMajor) == int(SrcIsRowMajor)),
+    MightVectorize = bool(StorageOrdersAgree)
+                  && (int(DstFlags) & int(SrcFlags) & ActualPacketAccessBit)
+                  && bool(functor_traits<AssignFunc>::PacketAccess),
+    MayInnerVectorize  = MightVectorize
+                       && int(InnerSize)!=Dynamic && int(InnerSize)%int(InnerPacketSize)==0
+                       && int(OuterStride)!=Dynamic && int(OuterStride)%int(InnerPacketSize)==0
+                       && (EIGEN_UNALIGNED_VECTORIZE  || int(JointAlignment)>=int(InnerRequiredAlignment)),
+    MayLinearize = bool(StorageOrdersAgree) && (int(DstFlags) & int(SrcFlags) & LinearAccessBit),
+    MayLinearVectorize = bool(MightVectorize) && bool(MayLinearize) && bool(DstHasDirectAccess)
+                       && (EIGEN_UNALIGNED_VECTORIZE || (int(DstAlignment)>=int(LinearRequiredAlignment)) || MaxSizeAtCompileTime == Dynamic),
+      /* If the destination isn't aligned, we have to do runtime checks and we don't unroll,
+         so it's only good for large enough sizes. */
+    MaySliceVectorize  = bool(MightVectorize) && bool(DstHasDirectAccess)
+                       && (int(InnerMaxSize)==Dynamic || int(InnerMaxSize)>=(EIGEN_UNALIGNED_VECTORIZE?InnerPacketSize:(3*InnerPacketSize)))
+      /* slice vectorization can be slow, so we only want it if the slices are big, which is
+         indicated by InnerMaxSize rather than InnerSize, think of the case of a dynamic block
+         in a fixed-size matrix
+         However, with EIGEN_UNALIGNED_VECTORIZE and unrolling, slice vectorization is still worth it */
+  };
+
+public:
+  enum {
+    Traversal = int(MayLinearVectorize) && (LinearPacketSize>InnerPacketSize) ? int(LinearVectorizedTraversal)
+              : int(MayInnerVectorize)   ? int(InnerVectorizedTraversal)
+              : int(MayLinearVectorize)  ? int(LinearVectorizedTraversal)
+              : int(MaySliceVectorize)   ? int(SliceVectorizedTraversal)
+              : int(MayLinearize)        ? int(LinearTraversal)
+                                         : int(DefaultTraversal),
+    Vectorized = int(Traversal) == InnerVectorizedTraversal
+              || int(Traversal) == LinearVectorizedTraversal
+              || int(Traversal) == SliceVectorizedTraversal
+  };
+
+  typedef typename conditional<int(Traversal)==LinearVectorizedTraversal, LinearPacketType, InnerPacketType>::type PacketType;
+
+private:
+  enum {
+    ActualPacketSize    = int(Traversal)==LinearVectorizedTraversal ? LinearPacketSize
+                        : Vectorized ? InnerPacketSize
+                        : 1,
+    UnrollingLimit      = EIGEN_UNROLLING_LIMIT * ActualPacketSize,
+    MayUnrollCompletely = int(Dst::SizeAtCompileTime) != Dynamic
+                       && int(Dst::SizeAtCompileTime) * (int(DstEvaluator::CoeffReadCost)+int(SrcEvaluator::CoeffReadCost)) <= int(UnrollingLimit),
+    MayUnrollInner      = int(InnerSize) != Dynamic
+                       && int(InnerSize) * (int(DstEvaluator::CoeffReadCost)+int(SrcEvaluator::CoeffReadCost)) <= int(UnrollingLimit)
+  };
+
+public:
+  enum {
+    Unrolling = (int(Traversal) == int(InnerVectorizedTraversal) || int(Traversal) == int(DefaultTraversal))
+                ? (
+                    int(MayUnrollCompletely) ? int(CompleteUnrolling)
+                  : int(MayUnrollInner)      ? int(InnerUnrolling)
+                                             : int(NoUnrolling)
+                  )
+              : int(Traversal) == int(LinearVectorizedTraversal)
+                ? ( bool(MayUnrollCompletely) && ( EIGEN_UNALIGNED_VECTORIZE || (int(DstAlignment)>=int(LinearRequiredAlignment)))
+                          ? int(CompleteUnrolling)
+                          : int(NoUnrolling) )
+              : int(Traversal) == int(LinearTraversal)
+                ? ( bool(MayUnrollCompletely) ? int(CompleteUnrolling) 
+                                              : int(NoUnrolling) )
+#if EIGEN_UNALIGNED_VECTORIZE
+              : int(Traversal) == int(SliceVectorizedTraversal)
+                ? ( bool(MayUnrollInner) ? int(InnerUnrolling)
+                                         : int(NoUnrolling) )
+#endif
+              : int(NoUnrolling)
+  };
+
+#ifdef EIGEN_DEBUG_ASSIGN
+  static void debug()
+  {
+    std::cerr << "DstXpr: " << typeid(typename DstEvaluator::XprType).name() << std::endl;
+    std::cerr << "SrcXpr: " << typeid(typename SrcEvaluator::XprType).name() << std::endl;
+    std::cerr.setf(std::ios::hex, std::ios::basefield);
+    std::cerr << "DstFlags" << " = " << DstFlags << " (" << demangle_flags(DstFlags) << " )" << std::endl;
+    std::cerr << "SrcFlags" << " = " << SrcFlags << " (" << demangle_flags(SrcFlags) << " )" << std::endl;
+    std::cerr.unsetf(std::ios::hex);
+    EIGEN_DEBUG_VAR(DstAlignment)
+    EIGEN_DEBUG_VAR(SrcAlignment)
+    EIGEN_DEBUG_VAR(LinearRequiredAlignment)
+    EIGEN_DEBUG_VAR(InnerRequiredAlignment)
+    EIGEN_DEBUG_VAR(JointAlignment)
+    EIGEN_DEBUG_VAR(InnerSize)
+    EIGEN_DEBUG_VAR(InnerMaxSize)
+    EIGEN_DEBUG_VAR(LinearPacketSize)
+    EIGEN_DEBUG_VAR(InnerPacketSize)
+    EIGEN_DEBUG_VAR(ActualPacketSize)
+    EIGEN_DEBUG_VAR(StorageOrdersAgree)
+    EIGEN_DEBUG_VAR(MightVectorize)
+    EIGEN_DEBUG_VAR(MayLinearize)
+    EIGEN_DEBUG_VAR(MayInnerVectorize)
+    EIGEN_DEBUG_VAR(MayLinearVectorize)
+    EIGEN_DEBUG_VAR(MaySliceVectorize)
+    std::cerr << "Traversal" << " = " << Traversal << " (" << demangle_traversal(Traversal) << ")" << std::endl;
+    EIGEN_DEBUG_VAR(SrcEvaluator::CoeffReadCost)
+    EIGEN_DEBUG_VAR(UnrollingLimit)
+    EIGEN_DEBUG_VAR(MayUnrollCompletely)
+    EIGEN_DEBUG_VAR(MayUnrollInner)
+    std::cerr << "Unrolling" << " = " << Unrolling << " (" << demangle_unrolling(Unrolling) << ")" << std::endl;
+    std::cerr << std::endl;
+  }
+#endif
+};
+
+/***************************************************************************
+* Part 2 : meta-unrollers
+***************************************************************************/
+
+/************************
+*** Default traversal ***
+************************/
+
+template<typename Kernel, int Index, int Stop>
+struct copy_using_evaluator_DefaultTraversal_CompleteUnrolling
+{
+  // FIXME: this is not very clean, perhaps this information should be provided by the kernel?
+  typedef typename Kernel::DstEvaluatorType DstEvaluatorType;
+  typedef typename DstEvaluatorType::XprType DstXprType;
+  
+  enum {
+    outer = Index / DstXprType::InnerSizeAtCompileTime,
+    inner = Index % DstXprType::InnerSizeAtCompileTime
+  };
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    kernel.assignCoeffByOuterInner(outer, inner);
+    copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, Index+1, Stop>::run(kernel);
+  }
+};
+
+template<typename Kernel, int Stop>
+struct copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, Stop, Stop>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel&) { }
+};
+
+template<typename Kernel, int Index_, int Stop>
+struct copy_using_evaluator_DefaultTraversal_InnerUnrolling
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel, Index outer)
+  {
+    kernel.assignCoeffByOuterInner(outer, Index_);
+    copy_using_evaluator_DefaultTraversal_InnerUnrolling<Kernel, Index_+1, Stop>::run(kernel, outer);
+  }
+};
+
+template<typename Kernel, int Stop>
+struct copy_using_evaluator_DefaultTraversal_InnerUnrolling<Kernel, Stop, Stop>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel&, Index) { }
+};
+
+/***********************
+*** Linear traversal ***
+***********************/
+
+template<typename Kernel, int Index, int Stop>
+struct copy_using_evaluator_LinearTraversal_CompleteUnrolling
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel& kernel)
+  {
+    kernel.assignCoeff(Index);
+    copy_using_evaluator_LinearTraversal_CompleteUnrolling<Kernel, Index+1, Stop>::run(kernel);
+  }
+};
+
+template<typename Kernel, int Stop>
+struct copy_using_evaluator_LinearTraversal_CompleteUnrolling<Kernel, Stop, Stop>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel&) { }
+};
+
+/**************************
+*** Inner vectorization ***
+**************************/
+
+template<typename Kernel, int Index, int Stop>
+struct copy_using_evaluator_innervec_CompleteUnrolling
+{
+  // FIXME: this is not very clean, perhaps this information should be provided by the kernel?
+  typedef typename Kernel::DstEvaluatorType DstEvaluatorType;
+  typedef typename DstEvaluatorType::XprType DstXprType;
+  typedef typename Kernel::PacketType PacketType;
+  
+  enum {
+    outer = Index / DstXprType::InnerSizeAtCompileTime,
+    inner = Index % DstXprType::InnerSizeAtCompileTime,
+    SrcAlignment = Kernel::AssignmentTraits::SrcAlignment,
+    DstAlignment = Kernel::AssignmentTraits::DstAlignment
+  };
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    kernel.template assignPacketByOuterInner<DstAlignment, SrcAlignment, PacketType>(outer, inner);
+    enum { NextIndex = Index + unpacket_traits<PacketType>::size };
+    copy_using_evaluator_innervec_CompleteUnrolling<Kernel, NextIndex, Stop>::run(kernel);
+  }
+};
+
+template<typename Kernel, int Stop>
+struct copy_using_evaluator_innervec_CompleteUnrolling<Kernel, Stop, Stop>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel&) { }
+};
+
+template<typename Kernel, int Index_, int Stop, int SrcAlignment, int DstAlignment>
+struct copy_using_evaluator_innervec_InnerUnrolling
+{
+  typedef typename Kernel::PacketType PacketType;
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel, Index outer)
+  {
+    kernel.template assignPacketByOuterInner<DstAlignment, SrcAlignment, PacketType>(outer, Index_);
+    enum { NextIndex = Index_ + unpacket_traits<PacketType>::size };
+    copy_using_evaluator_innervec_InnerUnrolling<Kernel, NextIndex, Stop, SrcAlignment, DstAlignment>::run(kernel, outer);
+  }
+};
+
+template<typename Kernel, int Stop, int SrcAlignment, int DstAlignment>
+struct copy_using_evaluator_innervec_InnerUnrolling<Kernel, Stop, Stop, SrcAlignment, DstAlignment>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &, Index) { }
+};
+
+/***************************************************************************
+* Part 3 : implementation of all cases
+***************************************************************************/
+
+// dense_assignment_loop is based on assign_impl
+
+template<typename Kernel,
+         int Traversal = Kernel::AssignmentTraits::Traversal,
+         int Unrolling = Kernel::AssignmentTraits::Unrolling>
+struct dense_assignment_loop;
+
+/************************
+*** Default traversal ***
+************************/
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, DefaultTraversal, NoUnrolling>
+{
+  EIGEN_DEVICE_FUNC static void EIGEN_STRONG_INLINE run(Kernel &kernel)
+  {
+    for(Index outer = 0; outer < kernel.outerSize(); ++outer) {
+      for(Index inner = 0; inner < kernel.innerSize(); ++inner) {
+        kernel.assignCoeffByOuterInner(outer, inner);
+      }
+    }
+  }
+};
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, DefaultTraversal, CompleteUnrolling>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
+    copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, 0, DstXprType::SizeAtCompileTime>::run(kernel);
+  }
+};
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, DefaultTraversal, InnerUnrolling>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
+
+    const Index outerSize = kernel.outerSize();
+    for(Index outer = 0; outer < outerSize; ++outer)
+      copy_using_evaluator_DefaultTraversal_InnerUnrolling<Kernel, 0, DstXprType::InnerSizeAtCompileTime>::run(kernel, outer);
+  }
+};
+
+/***************************
+*** Linear vectorization ***
+***************************/
+
+
+// The goal of unaligned_dense_assignment_loop is simply to factorize the handling
+// of the non vectorizable beginning and ending parts
+
+template <bool IsAligned = false>
+struct unaligned_dense_assignment_loop
+{
+  // if IsAligned = true, then do nothing
+  template <typename Kernel>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel&, Index, Index) {}
+};
+
+template <>
+struct unaligned_dense_assignment_loop<false>
+{
+  // MSVC must not inline this functions. If it does, it fails to optimize the
+  // packet access path.
+  // FIXME check which version exhibits this issue
+#if EIGEN_COMP_MSVC
+  template <typename Kernel>
+  static EIGEN_DONT_INLINE void run(Kernel &kernel,
+                                    Index start,
+                                    Index end)
+#else
+  template <typename Kernel>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel,
+                                      Index start,
+                                      Index end)
+#endif
+  {
+    for (Index index = start; index < end; ++index)
+      kernel.assignCoeff(index);
+  }
+};
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, LinearVectorizedTraversal, NoUnrolling>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    const Index size = kernel.size();
+    typedef typename Kernel::Scalar Scalar;
+    typedef typename Kernel::PacketType PacketType;
+    enum {
+      requestedAlignment = Kernel::AssignmentTraits::LinearRequiredAlignment,
+      packetSize = unpacket_traits<PacketType>::size,
+      dstIsAligned = int(Kernel::AssignmentTraits::DstAlignment)>=int(requestedAlignment),
+      dstAlignment = packet_traits<Scalar>::AlignedOnScalar ? int(requestedAlignment)
+                                                            : int(Kernel::AssignmentTraits::DstAlignment),
+      srcAlignment = Kernel::AssignmentTraits::JointAlignment
+    };
+    const Index alignedStart = dstIsAligned ? 0 : internal::first_aligned<requestedAlignment>(kernel.dstDataPtr(), size);
+    const Index alignedEnd = alignedStart + ((size-alignedStart)/packetSize)*packetSize;
+
+    unaligned_dense_assignment_loop<dstIsAligned!=0>::run(kernel, 0, alignedStart);
+
+    for(Index index = alignedStart; index < alignedEnd; index += packetSize)
+      kernel.template assignPacket<dstAlignment, srcAlignment, PacketType>(index);
+
+    unaligned_dense_assignment_loop<>::run(kernel, alignedEnd, size);
+  }
+};
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, LinearVectorizedTraversal, CompleteUnrolling>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
+    typedef typename Kernel::PacketType PacketType;
+    
+    enum { size = DstXprType::SizeAtCompileTime,
+           packetSize =unpacket_traits<PacketType>::size,
+           alignedSize = (size/packetSize)*packetSize };
+
+    copy_using_evaluator_innervec_CompleteUnrolling<Kernel, 0, alignedSize>::run(kernel);
+    copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, alignedSize, size>::run(kernel);
+  }
+};
+
+/**************************
+*** Inner vectorization ***
+**************************/
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, InnerVectorizedTraversal, NoUnrolling>
+{
+  typedef typename Kernel::PacketType PacketType;
+  enum {
+    SrcAlignment = Kernel::AssignmentTraits::SrcAlignment,
+    DstAlignment = Kernel::AssignmentTraits::DstAlignment
+  };
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    const Index innerSize = kernel.innerSize();
+    const Index outerSize = kernel.outerSize();
+    const Index packetSize = unpacket_traits<PacketType>::size;
+    for(Index outer = 0; outer < outerSize; ++outer)
+      for(Index inner = 0; inner < innerSize; inner+=packetSize)
+        kernel.template assignPacketByOuterInner<DstAlignment, SrcAlignment, PacketType>(outer, inner);
+  }
+};
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, InnerVectorizedTraversal, CompleteUnrolling>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
+    copy_using_evaluator_innervec_CompleteUnrolling<Kernel, 0, DstXprType::SizeAtCompileTime>::run(kernel);
+  }
+};
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, InnerVectorizedTraversal, InnerUnrolling>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
+    typedef typename Kernel::AssignmentTraits Traits;
+    const Index outerSize = kernel.outerSize();
+    for(Index outer = 0; outer < outerSize; ++outer)
+      copy_using_evaluator_innervec_InnerUnrolling<Kernel, 0, DstXprType::InnerSizeAtCompileTime,
+                                                   Traits::SrcAlignment, Traits::DstAlignment>::run(kernel, outer);
+  }
+};
+
+/***********************
+*** Linear traversal ***
+***********************/
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, LinearTraversal, NoUnrolling>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    const Index size = kernel.size();
+    for(Index i = 0; i < size; ++i)
+      kernel.assignCoeff(i);
+  }
+};
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, LinearTraversal, CompleteUnrolling>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
+    copy_using_evaluator_LinearTraversal_CompleteUnrolling<Kernel, 0, DstXprType::SizeAtCompileTime>::run(kernel);
+  }
+};
+
+/**************************
+*** Slice vectorization ***
+***************************/
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, SliceVectorizedTraversal, NoUnrolling>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    typedef typename Kernel::Scalar Scalar;
+    typedef typename Kernel::PacketType PacketType;
+    enum {
+      packetSize = unpacket_traits<PacketType>::size,
+      requestedAlignment = int(Kernel::AssignmentTraits::InnerRequiredAlignment),
+      alignable = packet_traits<Scalar>::AlignedOnScalar || int(Kernel::AssignmentTraits::DstAlignment)>=sizeof(Scalar),
+      dstIsAligned = int(Kernel::AssignmentTraits::DstAlignment)>=int(requestedAlignment),
+      dstAlignment = alignable ? int(requestedAlignment)
+                               : int(Kernel::AssignmentTraits::DstAlignment)
+    };
+    const Scalar *dst_ptr = kernel.dstDataPtr();
+    if((!bool(dstIsAligned)) && (UIntPtr(dst_ptr) % sizeof(Scalar))>0)
+    {
+      // the pointer is not aligend-on scalar, so alignment is not possible
+      return dense_assignment_loop<Kernel,DefaultTraversal,NoUnrolling>::run(kernel);
+    }
+    const Index packetAlignedMask = packetSize - 1;
+    const Index innerSize = kernel.innerSize();
+    const Index outerSize = kernel.outerSize();
+    const Index alignedStep = alignable ? (packetSize - kernel.outerStride() % packetSize) & packetAlignedMask : 0;
+    Index alignedStart = ((!alignable) || bool(dstIsAligned)) ? 0 : internal::first_aligned<requestedAlignment>(dst_ptr, innerSize);
+
+    for(Index outer = 0; outer < outerSize; ++outer)
+    {
+      const Index alignedEnd = alignedStart + ((innerSize-alignedStart) & ~packetAlignedMask);
+      // do the non-vectorizable part of the assignment
+      for(Index inner = 0; inner<alignedStart ; ++inner)
+        kernel.assignCoeffByOuterInner(outer, inner);
+
+      // do the vectorizable part of the assignment
+      for(Index inner = alignedStart; inner<alignedEnd; inner+=packetSize)
+        kernel.template assignPacketByOuterInner<dstAlignment, Unaligned, PacketType>(outer, inner);
+
+      // do the non-vectorizable part of the assignment
+      for(Index inner = alignedEnd; inner<innerSize ; ++inner)
+        kernel.assignCoeffByOuterInner(outer, inner);
+
+      alignedStart = numext::mini((alignedStart+alignedStep)%packetSize, innerSize);
+    }
+  }
+};
+
+#if EIGEN_UNALIGNED_VECTORIZE
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, SliceVectorizedTraversal, InnerUnrolling>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
+    typedef typename Kernel::PacketType PacketType;
+
+    enum { size = DstXprType::InnerSizeAtCompileTime,
+           packetSize =unpacket_traits<PacketType>::size,
+           vectorizableSize = (size/packetSize)*packetSize };
+
+    for(Index outer = 0; outer < kernel.outerSize(); ++outer)
+    {
+      copy_using_evaluator_innervec_InnerUnrolling<Kernel, 0, vectorizableSize, 0, 0>::run(kernel, outer);
+      copy_using_evaluator_DefaultTraversal_InnerUnrolling<Kernel, vectorizableSize, size>::run(kernel, outer);
+    }
+  }
+};
+#endif
+
+
+/***************************************************************************
+* Part 4 : Generic dense assignment kernel
+***************************************************************************/
+
+// This class generalize the assignment of a coefficient (or packet) from one dense evaluator
+// to another dense writable evaluator.
+// It is parametrized by the two evaluators, and the actual assignment functor.
+// This abstraction level permits to keep the evaluation loops as simple and as generic as possible.
+// One can customize the assignment using this generic dense_assignment_kernel with different
+// functors, or by completely overloading it, by-passing a functor.
+template<typename DstEvaluatorTypeT, typename SrcEvaluatorTypeT, typename Functor, int Version = Specialized>
+class generic_dense_assignment_kernel
+{
+protected:
+  typedef typename DstEvaluatorTypeT::XprType DstXprType;
+  typedef typename SrcEvaluatorTypeT::XprType SrcXprType;
+public:
+  
+  typedef DstEvaluatorTypeT DstEvaluatorType;
+  typedef SrcEvaluatorTypeT SrcEvaluatorType;
+  typedef typename DstEvaluatorType::Scalar Scalar;
+  typedef copy_using_evaluator_traits<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor> AssignmentTraits;
+  typedef typename AssignmentTraits::PacketType PacketType;
+  
+  
+  EIGEN_DEVICE_FUNC generic_dense_assignment_kernel(DstEvaluatorType &dst, const SrcEvaluatorType &src, const Functor &func, DstXprType& dstExpr)
+    : m_dst(dst), m_src(src), m_functor(func), m_dstExpr(dstExpr)
+  {
+    #ifdef EIGEN_DEBUG_ASSIGN
+    AssignmentTraits::debug();
+    #endif
+  }
+  
+  EIGEN_DEVICE_FUNC Index size() const        { return m_dstExpr.size(); }
+  EIGEN_DEVICE_FUNC Index innerSize() const   { return m_dstExpr.innerSize(); }
+  EIGEN_DEVICE_FUNC Index outerSize() const   { return m_dstExpr.outerSize(); }
+  EIGEN_DEVICE_FUNC Index rows() const        { return m_dstExpr.rows(); }
+  EIGEN_DEVICE_FUNC Index cols() const        { return m_dstExpr.cols(); }
+  EIGEN_DEVICE_FUNC Index outerStride() const { return m_dstExpr.outerStride(); }
+  
+  EIGEN_DEVICE_FUNC DstEvaluatorType& dstEvaluator() { return m_dst; }
+  EIGEN_DEVICE_FUNC const SrcEvaluatorType& srcEvaluator() const { return m_src; }
+  
+  /// Assign src(row,col) to dst(row,col) through the assignment functor.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(Index row, Index col)
+  {
+    m_functor.assignCoeff(m_dst.coeffRef(row,col), m_src.coeff(row,col));
+  }
+  
+  /// \sa assignCoeff(Index,Index)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(Index index)
+  {
+    m_functor.assignCoeff(m_dst.coeffRef(index), m_src.coeff(index));
+  }
+  
+  /// \sa assignCoeff(Index,Index)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeffByOuterInner(Index outer, Index inner)
+  {
+    Index row = rowIndexByOuterInner(outer, inner); 
+    Index col = colIndexByOuterInner(outer, inner); 
+    assignCoeff(row, col);
+  }
+  
+  
+  template<int StoreMode, int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignPacket(Index row, Index col)
+  {
+    m_functor.template assignPacket<StoreMode>(&m_dst.coeffRef(row,col), m_src.template packet<LoadMode,PacketType>(row,col));
+  }
+  
+  template<int StoreMode, int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignPacket(Index index)
+  {
+    m_functor.template assignPacket<StoreMode>(&m_dst.coeffRef(index), m_src.template packet<LoadMode,PacketType>(index));
+  }
+  
+  template<int StoreMode, int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignPacketByOuterInner(Index outer, Index inner)
+  {
+    Index row = rowIndexByOuterInner(outer, inner); 
+    Index col = colIndexByOuterInner(outer, inner);
+    assignPacket<StoreMode,LoadMode,PacketType>(row, col);
+  }
+  
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Index rowIndexByOuterInner(Index outer, Index inner)
+  {
+    typedef typename DstEvaluatorType::ExpressionTraits Traits;
+    return int(Traits::RowsAtCompileTime) == 1 ? 0
+      : int(Traits::ColsAtCompileTime) == 1 ? inner
+      : int(DstEvaluatorType::Flags)&RowMajorBit ? outer
+      : inner;
+  }
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Index colIndexByOuterInner(Index outer, Index inner)
+  {
+    typedef typename DstEvaluatorType::ExpressionTraits Traits;
+    return int(Traits::ColsAtCompileTime) == 1 ? 0
+      : int(Traits::RowsAtCompileTime) == 1 ? inner
+      : int(DstEvaluatorType::Flags)&RowMajorBit ? inner
+      : outer;
+  }
+
+  EIGEN_DEVICE_FUNC const Scalar* dstDataPtr() const
+  {
+    return m_dstExpr.data();
+  }
+  
+protected:
+  DstEvaluatorType& m_dst;
+  const SrcEvaluatorType& m_src;
+  const Functor &m_functor;
+  // TODO find a way to avoid the needs of the original expression
+  DstXprType& m_dstExpr;
+};
+
+/***************************************************************************
+* Part 5 : Entry point for dense rectangular assignment
+***************************************************************************/
+
+template<typename DstXprType,typename SrcXprType, typename Functor>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void resize_if_allowed(DstXprType &dst, const SrcXprType& src, const Functor &/*func*/)
+{
+  EIGEN_ONLY_USED_FOR_DEBUG(dst);
+  EIGEN_ONLY_USED_FOR_DEBUG(src);
+  eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
+}
+
+template<typename DstXprType,typename SrcXprType, typename T1, typename T2>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void resize_if_allowed(DstXprType &dst, const SrcXprType& src, const internal::assign_op<T1,T2> &/*func*/)
+{
+  Index dstRows = src.rows();
+  Index dstCols = src.cols();
+  if(((dst.rows()!=dstRows) || (dst.cols()!=dstCols)))
+    dst.resize(dstRows, dstCols);
+  eigen_assert(dst.rows() == dstRows && dst.cols() == dstCols);
+}
+
+template<typename DstXprType, typename SrcXprType, typename Functor>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src, const Functor &func)
+{
+  typedef evaluator<DstXprType> DstEvaluatorType;
+  typedef evaluator<SrcXprType> SrcEvaluatorType;
+
+  SrcEvaluatorType srcEvaluator(src);
+
+  // NOTE To properly handle A = (A*A.transpose())/s with A rectangular,
+  // we need to resize the destination after the source evaluator has been created.
+  resize_if_allowed(dst, src, func);
+
+  DstEvaluatorType dstEvaluator(dst);
+    
+  typedef generic_dense_assignment_kernel<DstEvaluatorType,SrcEvaluatorType,Functor> Kernel;
+  Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
+
+  dense_assignment_loop<Kernel>::run(kernel);
+}
+
+template<typename DstXprType, typename SrcXprType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src)
+{
+  call_dense_assignment_loop(dst, src, internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar>());
+}
+
+/***************************************************************************
+* Part 6 : Generic assignment
+***************************************************************************/
+
+// Based on the respective shapes of the destination and source,
+// the class AssignmentKind determine the kind of assignment mechanism.
+// AssignmentKind must define a Kind typedef.
+template<typename DstShape, typename SrcShape> struct AssignmentKind;
+
+// Assignement kind defined in this file:
+struct Dense2Dense {};
+struct EigenBase2EigenBase {};
+
+template<typename,typename> struct AssignmentKind { typedef EigenBase2EigenBase Kind; };
+template<> struct AssignmentKind<DenseShape,DenseShape> { typedef Dense2Dense Kind; };
+    
+// This is the main assignment class
+template< typename DstXprType, typename SrcXprType, typename Functor,
+          typename Kind = typename AssignmentKind< typename evaluator_traits<DstXprType>::Shape , typename evaluator_traits<SrcXprType>::Shape >::Kind,
+          typename EnableIf = void>
+struct Assignment;
+
+
+// The only purpose of this call_assignment() function is to deal with noalias() / "assume-aliasing" and automatic transposition.
+// Indeed, I (Gael) think that this concept of "assume-aliasing" was a mistake, and it makes thing quite complicated.
+// So this intermediate function removes everything related to "assume-aliasing" such that Assignment
+// does not has to bother about these annoying details.
+
+template<typename Dst, typename Src>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_assignment(Dst& dst, const Src& src)
+{
+  call_assignment(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
+}
+template<typename Dst, typename Src>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_assignment(const Dst& dst, const Src& src)
+{
+  call_assignment(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
+}
+                     
+// Deal with "assume-aliasing"
+template<typename Dst, typename Src, typename Func>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_assignment(Dst& dst, const Src& src, const Func& func, typename enable_if< evaluator_assume_aliasing<Src>::value, void*>::type = 0)
+{
+  typename plain_matrix_type<Src>::type tmp(src);
+  call_assignment_no_alias(dst, tmp, func);
+}
+
+template<typename Dst, typename Src, typename Func>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_assignment(Dst& dst, const Src& src, const Func& func, typename enable_if<!evaluator_assume_aliasing<Src>::value, void*>::type = 0)
+{
+  call_assignment_no_alias(dst, src, func);
+}
+
+// by-pass "assume-aliasing"
+// When there is no aliasing, we require that 'dst' has been properly resized
+template<typename Dst, template <typename> class StorageBase, typename Src, typename Func>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_assignment(NoAlias<Dst,StorageBase>& dst, const Src& src, const Func& func)
+{
+  call_assignment_no_alias(dst.expression(), src, func);
+}
+
+
+template<typename Dst, typename Src, typename Func>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_assignment_no_alias(Dst& dst, const Src& src, const Func& func)
+{
+  enum {
+    NeedToTranspose = (    (int(Dst::RowsAtCompileTime) == 1 && int(Src::ColsAtCompileTime) == 1)
+                        || (int(Dst::ColsAtCompileTime) == 1 && int(Src::RowsAtCompileTime) == 1)
+                      ) && int(Dst::SizeAtCompileTime) != 1
+  };
+
+  typedef typename internal::conditional<NeedToTranspose, Transpose<Dst>, Dst>::type ActualDstTypeCleaned;
+  typedef typename internal::conditional<NeedToTranspose, Transpose<Dst>, Dst&>::type ActualDstType;
+  ActualDstType actualDst(dst);
+  
+  // TODO check whether this is the right place to perform these checks:
+  EIGEN_STATIC_ASSERT_LVALUE(Dst)
+  EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(ActualDstTypeCleaned,Src)
+  EIGEN_CHECK_BINARY_COMPATIBILIY(Func,typename ActualDstTypeCleaned::Scalar,typename Src::Scalar);
+  
+  Assignment<ActualDstTypeCleaned,Src,Func>::run(actualDst, src, func);
+}
+template<typename Dst, typename Src>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_assignment_no_alias(Dst& dst, const Src& src)
+{
+  call_assignment_no_alias(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
+}
+
+template<typename Dst, typename Src, typename Func>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_assignment_no_alias_no_transpose(Dst& dst, const Src& src, const Func& func)
+{
+  // TODO check whether this is the right place to perform these checks:
+  EIGEN_STATIC_ASSERT_LVALUE(Dst)
+  EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Dst,Src)
+  EIGEN_CHECK_BINARY_COMPATIBILIY(Func,typename Dst::Scalar,typename Src::Scalar);
+
+  Assignment<Dst,Src,Func>::run(dst, src, func);
+}
+template<typename Dst, typename Src>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_assignment_no_alias_no_transpose(Dst& dst, const Src& src)
+{
+  call_assignment_no_alias_no_transpose(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
+}
+
+// forward declaration
+template<typename Dst, typename Src> void check_for_aliasing(const Dst &dst, const Src &src);
+
+// Generic Dense to Dense assignment
+// Note that the last template argument "Weak" is needed to make it possible to perform
+// both partial specialization+SFINAE without ambiguous specialization
+template< typename DstXprType, typename SrcXprType, typename Functor, typename Weak>
+struct Assignment<DstXprType, SrcXprType, Functor, Dense2Dense, Weak>
+{
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE void run(DstXprType &dst, const SrcXprType &src, const Functor &func)
+  {
+#ifndef EIGEN_NO_DEBUG
+    internal::check_for_aliasing(dst, src);
+#endif
+    
+    call_dense_assignment_loop(dst, src, func);
+  }
+};
+
+// Generic assignment through evalTo.
+// TODO: not sure we have to keep that one, but it helps porting current code to new evaluator mechanism.
+// Note that the last template argument "Weak" is needed to make it possible to perform
+// both partial specialization+SFINAE without ambiguous specialization
+template< typename DstXprType, typename SrcXprType, typename Functor, typename Weak>
+struct Assignment<DstXprType, SrcXprType, Functor, EigenBase2EigenBase, Weak>
+{
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
+    src.evalTo(dst);
+  }
+
+  // NOTE The following two functions are templated to avoid their instanciation if not needed
+  //      This is needed because some expressions supports evalTo only and/or have 'void' as scalar type.
+  template<typename SrcScalarType>
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<typename DstXprType::Scalar,SrcScalarType> &/*func*/)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
+    src.addTo(dst);
+  }
+
+  template<typename SrcScalarType>
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<typename DstXprType::Scalar,SrcScalarType> &/*func*/)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
+    src.subTo(dst);
+  }
+};
+
+} // namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_ASSIGN_EVALUATOR_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Assign_MKL.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Assign_MKL.h
new file mode 100644
index 00000000..6c2ab926
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Assign_MKL.h
@@ -0,0 +1,176 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+ Copyright (C) 2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+ 
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to Intel(R) MKL
+ *   MKL VML support for coefficient-wise unary Eigen expressions like a=b.sin()
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_ASSIGN_VML_H
+#define EIGEN_ASSIGN_VML_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename Dst, typename Src>
+class vml_assign_traits
+{
+  private:
+    enum {
+      DstHasDirectAccess = Dst::Flags & DirectAccessBit,
+      SrcHasDirectAccess = Src::Flags & DirectAccessBit,
+      StorageOrdersAgree = (int(Dst::IsRowMajor) == int(Src::IsRowMajor)),
+      InnerSize = int(Dst::IsVectorAtCompileTime) ? int(Dst::SizeAtCompileTime)
+                : int(Dst::Flags)&RowMajorBit ? int(Dst::ColsAtCompileTime)
+                : int(Dst::RowsAtCompileTime),
+      InnerMaxSize  = int(Dst::IsVectorAtCompileTime) ? int(Dst::MaxSizeAtCompileTime)
+                    : int(Dst::Flags)&RowMajorBit ? int(Dst::MaxColsAtCompileTime)
+                    : int(Dst::MaxRowsAtCompileTime),
+      MaxSizeAtCompileTime = Dst::SizeAtCompileTime,
+
+      MightEnableVml = StorageOrdersAgree && DstHasDirectAccess && SrcHasDirectAccess && Src::InnerStrideAtCompileTime==1 && Dst::InnerStrideAtCompileTime==1,
+      MightLinearize = MightEnableVml && (int(Dst::Flags) & int(Src::Flags) & LinearAccessBit),
+      VmlSize = MightLinearize ? MaxSizeAtCompileTime : InnerMaxSize,
+      LargeEnough = VmlSize==Dynamic || VmlSize>=EIGEN_MKL_VML_THRESHOLD
+    };
+  public:
+    enum {
+      EnableVml = MightEnableVml && LargeEnough,
+      Traversal = MightLinearize ? LinearTraversal : DefaultTraversal
+    };
+};
+
+#define EIGEN_PP_EXPAND(ARG) ARG
+#if !defined (EIGEN_FAST_MATH) || (EIGEN_FAST_MATH != 1)
+#define EIGEN_VMLMODE_EXPAND_LA , VML_HA
+#else
+#define EIGEN_VMLMODE_EXPAND_LA , VML_LA
+#endif
+
+#define EIGEN_VMLMODE_EXPAND__ 
+
+#define EIGEN_VMLMODE_PREFIX_LA vm
+#define EIGEN_VMLMODE_PREFIX__  v
+#define EIGEN_VMLMODE_PREFIX(VMLMODE) EIGEN_CAT(EIGEN_VMLMODE_PREFIX_,VMLMODE)
+
+#define EIGEN_MKL_VML_DECLARE_UNARY_CALL(EIGENOP, VMLOP, EIGENTYPE, VMLTYPE, VMLMODE)                                           \
+  template< typename DstXprType, typename SrcXprNested>                                                                         \
+  struct Assignment<DstXprType, CwiseUnaryOp<scalar_##EIGENOP##_op<EIGENTYPE>, SrcXprNested>, assign_op<EIGENTYPE,EIGENTYPE>,   \
+                   Dense2Dense, typename enable_if<vml_assign_traits<DstXprType,SrcXprNested>::EnableVml>::type> {              \
+    typedef CwiseUnaryOp<scalar_##EIGENOP##_op<EIGENTYPE>, SrcXprNested> SrcXprType;                                            \
+    static void run(DstXprType &dst, const SrcXprType &src, const assign_op<EIGENTYPE,EIGENTYPE> &/*func*/) {                   \
+      eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());                                                       \
+      if(vml_assign_traits<DstXprType,SrcXprNested>::Traversal==LinearTraversal) {                                              \
+        VMLOP(dst.size(), (const VMLTYPE*)src.nestedExpression().data(),                                                        \
+              (VMLTYPE*)dst.data() EIGEN_PP_EXPAND(EIGEN_VMLMODE_EXPAND_##VMLMODE) );                                           \
+      } else {                                                                                                                  \
+        const Index outerSize = dst.outerSize();                                                                                \
+        for(Index outer = 0; outer < outerSize; ++outer) {                                                                      \
+          const EIGENTYPE *src_ptr = src.IsRowMajor ? &(src.nestedExpression().coeffRef(outer,0)) :                             \
+                                                      &(src.nestedExpression().coeffRef(0, outer));                             \
+          EIGENTYPE *dst_ptr = dst.IsRowMajor ? &(dst.coeffRef(outer,0)) : &(dst.coeffRef(0, outer));                           \
+          VMLOP( dst.innerSize(), (const VMLTYPE*)src_ptr,                                                                      \
+                (VMLTYPE*)dst_ptr EIGEN_PP_EXPAND(EIGEN_VMLMODE_EXPAND_##VMLMODE));                                             \
+        }                                                                                                                       \
+      }                                                                                                                         \
+    }                                                                                                                           \
+  };                                                                                                                            \
+
+
+#define EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(EIGENOP, VMLOP, VMLMODE)                                                         \
+  EIGEN_MKL_VML_DECLARE_UNARY_CALL(EIGENOP, EIGEN_CAT(EIGEN_VMLMODE_PREFIX(VMLMODE),s##VMLOP), float, float, VMLMODE)           \
+  EIGEN_MKL_VML_DECLARE_UNARY_CALL(EIGENOP, EIGEN_CAT(EIGEN_VMLMODE_PREFIX(VMLMODE),d##VMLOP), double, double, VMLMODE)
+
+#define EIGEN_MKL_VML_DECLARE_UNARY_CALLS_CPLX(EIGENOP, VMLOP, VMLMODE)                                                         \
+  EIGEN_MKL_VML_DECLARE_UNARY_CALL(EIGENOP, EIGEN_CAT(EIGEN_VMLMODE_PREFIX(VMLMODE),c##VMLOP), scomplex, MKL_Complex8, VMLMODE) \
+  EIGEN_MKL_VML_DECLARE_UNARY_CALL(EIGENOP, EIGEN_CAT(EIGEN_VMLMODE_PREFIX(VMLMODE),z##VMLOP), dcomplex, MKL_Complex16, VMLMODE)
+  
+#define EIGEN_MKL_VML_DECLARE_UNARY_CALLS(EIGENOP, VMLOP, VMLMODE)                                                              \
+  EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(EIGENOP, VMLOP, VMLMODE)                                                               \
+  EIGEN_MKL_VML_DECLARE_UNARY_CALLS_CPLX(EIGENOP, VMLOP, VMLMODE)
+
+  
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(sin,   Sin,   LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(asin,  Asin,  LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(sinh,  Sinh,  LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(cos,   Cos,   LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(acos,  Acos,  LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(cosh,  Cosh,  LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(tan,   Tan,   LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(atan,  Atan,  LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(tanh,  Tanh,  LA)
+// EIGEN_MKL_VML_DECLARE_UNARY_CALLS(abs,   Abs,    _)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(exp,   Exp,   LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(log,   Ln,    LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(log10, Log10, LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(sqrt,  Sqrt,  _)
+
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(square, Sqr,   _)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS_CPLX(arg, Arg,      _)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(round, Round,  _)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(floor, Floor,  _)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(ceil,  Ceil,   _)
+
+#define EIGEN_MKL_VML_DECLARE_POW_CALL(EIGENOP, VMLOP, EIGENTYPE, VMLTYPE, VMLMODE)                                           \
+  template< typename DstXprType, typename SrcXprNested, typename Plain>                                                       \
+  struct Assignment<DstXprType, CwiseBinaryOp<scalar_##EIGENOP##_op<EIGENTYPE,EIGENTYPE>, SrcXprNested,                       \
+                    const CwiseNullaryOp<internal::scalar_constant_op<EIGENTYPE>,Plain> >, assign_op<EIGENTYPE,EIGENTYPE>,    \
+                   Dense2Dense, typename enable_if<vml_assign_traits<DstXprType,SrcXprNested>::EnableVml>::type> {            \
+    typedef CwiseBinaryOp<scalar_##EIGENOP##_op<EIGENTYPE,EIGENTYPE>, SrcXprNested,                                           \
+                    const CwiseNullaryOp<internal::scalar_constant_op<EIGENTYPE>,Plain> > SrcXprType;                         \
+    static void run(DstXprType &dst, const SrcXprType &src, const assign_op<EIGENTYPE,EIGENTYPE> &/*func*/) {                 \
+      eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());                                                     \
+      VMLTYPE exponent = reinterpret_cast<const VMLTYPE&>(src.rhs().functor().m_other);                                       \
+      if(vml_assign_traits<DstXprType,SrcXprNested>::Traversal==LinearTraversal)                                              \
+      {                                                                                                                       \
+        VMLOP( dst.size(), (const VMLTYPE*)src.lhs().data(), exponent,                                                        \
+              (VMLTYPE*)dst.data() EIGEN_PP_EXPAND(EIGEN_VMLMODE_EXPAND_##VMLMODE) );                                         \
+      } else {                                                                                                                \
+        const Index outerSize = dst.outerSize();                                                                              \
+        for(Index outer = 0; outer < outerSize; ++outer) {                                                                    \
+          const EIGENTYPE *src_ptr = src.IsRowMajor ? &(src.lhs().coeffRef(outer,0)) :                                        \
+                                                      &(src.lhs().coeffRef(0, outer));                                        \
+          EIGENTYPE *dst_ptr = dst.IsRowMajor ? &(dst.coeffRef(outer,0)) : &(dst.coeffRef(0, outer));                         \
+          VMLOP( dst.innerSize(), (const VMLTYPE*)src_ptr, exponent,                                                          \
+                 (VMLTYPE*)dst_ptr EIGEN_PP_EXPAND(EIGEN_VMLMODE_EXPAND_##VMLMODE));                                          \
+        }                                                                                                                     \
+      }                                                                                                                       \
+    }                                                                                                                         \
+  };
+  
+EIGEN_MKL_VML_DECLARE_POW_CALL(pow, vmsPowx, float,    float,         LA)
+EIGEN_MKL_VML_DECLARE_POW_CALL(pow, vmdPowx, double,   double,        LA)
+EIGEN_MKL_VML_DECLARE_POW_CALL(pow, vmcPowx, scomplex, MKL_Complex8,  LA)
+EIGEN_MKL_VML_DECLARE_POW_CALL(pow, vmzPowx, dcomplex, MKL_Complex16, LA)
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_ASSIGN_VML_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/BandMatrix.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/BandMatrix.h
new file mode 100644
index 00000000..4978c914
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/BandMatrix.h
@@ -0,0 +1,353 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_BANDMATRIX_H
+#define EIGEN_BANDMATRIX_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename Derived>
+class BandMatrixBase : public EigenBase<Derived>
+{
+  public:
+
+    enum {
+      Flags = internal::traits<Derived>::Flags,
+      CoeffReadCost = internal::traits<Derived>::CoeffReadCost,
+      RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
+      ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
+      MaxRowsAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = internal::traits<Derived>::MaxColsAtCompileTime,
+      Supers = internal::traits<Derived>::Supers,
+      Subs   = internal::traits<Derived>::Subs,
+      Options = internal::traits<Derived>::Options
+    };
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    typedef Matrix<Scalar,RowsAtCompileTime,ColsAtCompileTime> DenseMatrixType;
+    typedef typename DenseMatrixType::StorageIndex StorageIndex;
+    typedef typename internal::traits<Derived>::CoefficientsType CoefficientsType;
+    typedef EigenBase<Derived> Base;
+
+  protected:
+    enum {
+      DataRowsAtCompileTime = ((Supers!=Dynamic) && (Subs!=Dynamic))
+                            ? 1 + Supers + Subs
+                            : Dynamic,
+      SizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_DYNAMIC(RowsAtCompileTime,ColsAtCompileTime)
+    };
+
+  public:
+    
+    using Base::derived;
+    using Base::rows;
+    using Base::cols;
+
+    /** \returns the number of super diagonals */
+    inline Index supers() const { return derived().supers(); }
+
+    /** \returns the number of sub diagonals */
+    inline Index subs() const { return derived().subs(); }
+    
+    /** \returns an expression of the underlying coefficient matrix */
+    inline const CoefficientsType& coeffs() const { return derived().coeffs(); }
+    
+    /** \returns an expression of the underlying coefficient matrix */
+    inline CoefficientsType& coeffs() { return derived().coeffs(); }
+
+    /** \returns a vector expression of the \a i -th column,
+      * only the meaningful part is returned.
+      * \warning the internal storage must be column major. */
+    inline Block<CoefficientsType,Dynamic,1> col(Index i)
+    {
+      EIGEN_STATIC_ASSERT((Options&RowMajor)==0,THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
+      Index start = 0;
+      Index len = coeffs().rows();
+      if (i<=supers())
+      {
+        start = supers()-i;
+        len = (std::min)(rows(),std::max<Index>(0,coeffs().rows() - (supers()-i)));
+      }
+      else if (i>=rows()-subs())
+        len = std::max<Index>(0,coeffs().rows() - (i + 1 - rows() + subs()));
+      return Block<CoefficientsType,Dynamic,1>(coeffs(), start, i, len, 1);
+    }
+
+    /** \returns a vector expression of the main diagonal */
+    inline Block<CoefficientsType,1,SizeAtCompileTime> diagonal()
+    { return Block<CoefficientsType,1,SizeAtCompileTime>(coeffs(),supers(),0,1,(std::min)(rows(),cols())); }
+
+    /** \returns a vector expression of the main diagonal (const version) */
+    inline const Block<const CoefficientsType,1,SizeAtCompileTime> diagonal() const
+    { return Block<const CoefficientsType,1,SizeAtCompileTime>(coeffs(),supers(),0,1,(std::min)(rows(),cols())); }
+
+    template<int Index> struct DiagonalIntReturnType {
+      enum {
+        ReturnOpposite = (Options&SelfAdjoint) && (((Index)>0 && Supers==0) || ((Index)<0 && Subs==0)),
+        Conjugate = ReturnOpposite && NumTraits<Scalar>::IsComplex,
+        ActualIndex = ReturnOpposite ? -Index : Index,
+        DiagonalSize = (RowsAtCompileTime==Dynamic || ColsAtCompileTime==Dynamic)
+                     ? Dynamic
+                     : (ActualIndex<0
+                     ? EIGEN_SIZE_MIN_PREFER_DYNAMIC(ColsAtCompileTime, RowsAtCompileTime + ActualIndex)
+                     : EIGEN_SIZE_MIN_PREFER_DYNAMIC(RowsAtCompileTime, ColsAtCompileTime - ActualIndex))
+      };
+      typedef Block<CoefficientsType,1, DiagonalSize> BuildType;
+      typedef typename internal::conditional<Conjugate,
+                 CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>,BuildType >,
+                 BuildType>::type Type;
+    };
+
+    /** \returns a vector expression of the \a N -th sub or super diagonal */
+    template<int N> inline typename DiagonalIntReturnType<N>::Type diagonal()
+    {
+      return typename DiagonalIntReturnType<N>::BuildType(coeffs(), supers()-N, (std::max)(0,N), 1, diagonalLength(N));
+    }
+
+    /** \returns a vector expression of the \a N -th sub or super diagonal */
+    template<int N> inline const typename DiagonalIntReturnType<N>::Type diagonal() const
+    {
+      return typename DiagonalIntReturnType<N>::BuildType(coeffs(), supers()-N, (std::max)(0,N), 1, diagonalLength(N));
+    }
+
+    /** \returns a vector expression of the \a i -th sub or super diagonal */
+    inline Block<CoefficientsType,1,Dynamic> diagonal(Index i)
+    {
+      eigen_assert((i<0 && -i<=subs()) || (i>=0 && i<=supers()));
+      return Block<CoefficientsType,1,Dynamic>(coeffs(), supers()-i, std::max<Index>(0,i), 1, diagonalLength(i));
+    }
+
+    /** \returns a vector expression of the \a i -th sub or super diagonal */
+    inline const Block<const CoefficientsType,1,Dynamic> diagonal(Index i) const
+    {
+      eigen_assert((i<0 && -i<=subs()) || (i>=0 && i<=supers()));
+      return Block<const CoefficientsType,1,Dynamic>(coeffs(), supers()-i, std::max<Index>(0,i), 1, diagonalLength(i));
+    }
+    
+    template<typename Dest> inline void evalTo(Dest& dst) const
+    {
+      dst.resize(rows(),cols());
+      dst.setZero();
+      dst.diagonal() = diagonal();
+      for (Index i=1; i<=supers();++i)
+        dst.diagonal(i) = diagonal(i);
+      for (Index i=1; i<=subs();++i)
+        dst.diagonal(-i) = diagonal(-i);
+    }
+
+    DenseMatrixType toDenseMatrix() const
+    {
+      DenseMatrixType res(rows(),cols());
+      evalTo(res);
+      return res;
+    }
+
+  protected:
+
+    inline Index diagonalLength(Index i) const
+    { return i<0 ? (std::min)(cols(),rows()+i) : (std::min)(rows(),cols()-i); }
+};
+
+/**
+  * \class BandMatrix
+  * \ingroup Core_Module
+  *
+  * \brief Represents a rectangular matrix with a banded storage
+  *
+  * \tparam _Scalar Numeric type, i.e. float, double, int
+  * \tparam _Rows Number of rows, or \b Dynamic
+  * \tparam _Cols Number of columns, or \b Dynamic
+  * \tparam _Supers Number of super diagonal
+  * \tparam _Subs Number of sub diagonal
+  * \tparam _Options A combination of either \b #RowMajor or \b #ColMajor, and of \b #SelfAdjoint
+  *                  The former controls \ref TopicStorageOrders "storage order", and defaults to
+  *                  column-major. The latter controls whether the matrix represents a selfadjoint
+  *                  matrix in which case either Supers of Subs have to be null.
+  *
+  * \sa class TridiagonalMatrix
+  */
+
+template<typename _Scalar, int _Rows, int _Cols, int _Supers, int _Subs, int _Options>
+struct traits<BandMatrix<_Scalar,_Rows,_Cols,_Supers,_Subs,_Options> >
+{
+  typedef _Scalar Scalar;
+  typedef Dense StorageKind;
+  typedef Eigen::Index StorageIndex;
+  enum {
+    CoeffReadCost = NumTraits<Scalar>::ReadCost,
+    RowsAtCompileTime = _Rows,
+    ColsAtCompileTime = _Cols,
+    MaxRowsAtCompileTime = _Rows,
+    MaxColsAtCompileTime = _Cols,
+    Flags = LvalueBit,
+    Supers = _Supers,
+    Subs = _Subs,
+    Options = _Options,
+    DataRowsAtCompileTime = ((Supers!=Dynamic) && (Subs!=Dynamic)) ? 1 + Supers + Subs : Dynamic
+  };
+  typedef Matrix<Scalar,DataRowsAtCompileTime,ColsAtCompileTime,Options&RowMajor?RowMajor:ColMajor> CoefficientsType;
+};
+
+template<typename _Scalar, int Rows, int Cols, int Supers, int Subs, int Options>
+class BandMatrix : public BandMatrixBase<BandMatrix<_Scalar,Rows,Cols,Supers,Subs,Options> >
+{
+  public:
+
+    typedef typename internal::traits<BandMatrix>::Scalar Scalar;
+    typedef typename internal::traits<BandMatrix>::StorageIndex StorageIndex;
+    typedef typename internal::traits<BandMatrix>::CoefficientsType CoefficientsType;
+
+    explicit inline BandMatrix(Index rows=Rows, Index cols=Cols, Index supers=Supers, Index subs=Subs)
+      : m_coeffs(1+supers+subs,cols),
+        m_rows(rows), m_supers(supers), m_subs(subs)
+    {
+    }
+
+    /** \returns the number of columns */
+    inline Index rows() const { return m_rows.value(); }
+
+    /** \returns the number of rows */
+    inline Index cols() const { return m_coeffs.cols(); }
+
+    /** \returns the number of super diagonals */
+    inline Index supers() const { return m_supers.value(); }
+
+    /** \returns the number of sub diagonals */
+    inline Index subs() const { return m_subs.value(); }
+
+    inline const CoefficientsType& coeffs() const { return m_coeffs; }
+    inline CoefficientsType& coeffs() { return m_coeffs; }
+
+  protected:
+
+    CoefficientsType m_coeffs;
+    internal::variable_if_dynamic<Index, Rows>   m_rows;
+    internal::variable_if_dynamic<Index, Supers> m_supers;
+    internal::variable_if_dynamic<Index, Subs>   m_subs;
+};
+
+template<typename _CoefficientsType,int _Rows, int _Cols, int _Supers, int _Subs,int _Options>
+class BandMatrixWrapper;
+
+template<typename _CoefficientsType,int _Rows, int _Cols, int _Supers, int _Subs,int _Options>
+struct traits<BandMatrixWrapper<_CoefficientsType,_Rows,_Cols,_Supers,_Subs,_Options> >
+{
+  typedef typename _CoefficientsType::Scalar Scalar;
+  typedef typename _CoefficientsType::StorageKind StorageKind;
+  typedef typename _CoefficientsType::StorageIndex StorageIndex;
+  enum {
+    CoeffReadCost = internal::traits<_CoefficientsType>::CoeffReadCost,
+    RowsAtCompileTime = _Rows,
+    ColsAtCompileTime = _Cols,
+    MaxRowsAtCompileTime = _Rows,
+    MaxColsAtCompileTime = _Cols,
+    Flags = LvalueBit,
+    Supers = _Supers,
+    Subs = _Subs,
+    Options = _Options,
+    DataRowsAtCompileTime = ((Supers!=Dynamic) && (Subs!=Dynamic)) ? 1 + Supers + Subs : Dynamic
+  };
+  typedef _CoefficientsType CoefficientsType;
+};
+
+template<typename _CoefficientsType,int _Rows, int _Cols, int _Supers, int _Subs,int _Options>
+class BandMatrixWrapper : public BandMatrixBase<BandMatrixWrapper<_CoefficientsType,_Rows,_Cols,_Supers,_Subs,_Options> >
+{
+  public:
+
+    typedef typename internal::traits<BandMatrixWrapper>::Scalar Scalar;
+    typedef typename internal::traits<BandMatrixWrapper>::CoefficientsType CoefficientsType;
+    typedef typename internal::traits<BandMatrixWrapper>::StorageIndex StorageIndex;
+
+    explicit inline BandMatrixWrapper(const CoefficientsType& coeffs, Index rows=_Rows, Index cols=_Cols, Index supers=_Supers, Index subs=_Subs)
+      : m_coeffs(coeffs),
+        m_rows(rows), m_supers(supers), m_subs(subs)
+    {
+      EIGEN_UNUSED_VARIABLE(cols);
+      //internal::assert(coeffs.cols()==cols() && (supers()+subs()+1)==coeffs.rows());
+    }
+
+    /** \returns the number of columns */
+    inline Index rows() const { return m_rows.value(); }
+
+    /** \returns the number of rows */
+    inline Index cols() const { return m_coeffs.cols(); }
+
+    /** \returns the number of super diagonals */
+    inline Index supers() const { return m_supers.value(); }
+
+    /** \returns the number of sub diagonals */
+    inline Index subs() const { return m_subs.value(); }
+
+    inline const CoefficientsType& coeffs() const { return m_coeffs; }
+
+  protected:
+
+    const CoefficientsType& m_coeffs;
+    internal::variable_if_dynamic<Index, _Rows>   m_rows;
+    internal::variable_if_dynamic<Index, _Supers> m_supers;
+    internal::variable_if_dynamic<Index, _Subs>   m_subs;
+};
+
+/**
+  * \class TridiagonalMatrix
+  * \ingroup Core_Module
+  *
+  * \brief Represents a tridiagonal matrix with a compact banded storage
+  *
+  * \tparam Scalar Numeric type, i.e. float, double, int
+  * \tparam Size Number of rows and cols, or \b Dynamic
+  * \tparam Options Can be 0 or \b SelfAdjoint
+  *
+  * \sa class BandMatrix
+  */
+template<typename Scalar, int Size, int Options>
+class TridiagonalMatrix : public BandMatrix<Scalar,Size,Size,Options&SelfAdjoint?0:1,1,Options|RowMajor>
+{
+    typedef BandMatrix<Scalar,Size,Size,Options&SelfAdjoint?0:1,1,Options|RowMajor> Base;
+    typedef typename Base::StorageIndex StorageIndex;
+  public:
+    explicit TridiagonalMatrix(Index size = Size) : Base(size,size,Options&SelfAdjoint?0:1,1) {}
+
+    inline typename Base::template DiagonalIntReturnType<1>::Type super()
+    { return Base::template diagonal<1>(); }
+    inline const typename Base::template DiagonalIntReturnType<1>::Type super() const
+    { return Base::template diagonal<1>(); }
+    inline typename Base::template DiagonalIntReturnType<-1>::Type sub()
+    { return Base::template diagonal<-1>(); }
+    inline const typename Base::template DiagonalIntReturnType<-1>::Type sub() const
+    { return Base::template diagonal<-1>(); }
+  protected:
+};
+
+
+struct BandShape {};
+
+template<typename _Scalar, int _Rows, int _Cols, int _Supers, int _Subs, int _Options>
+struct evaluator_traits<BandMatrix<_Scalar,_Rows,_Cols,_Supers,_Subs,_Options> >
+  : public evaluator_traits_base<BandMatrix<_Scalar,_Rows,_Cols,_Supers,_Subs,_Options> >
+{
+  typedef BandShape Shape;
+};
+
+template<typename _CoefficientsType,int _Rows, int _Cols, int _Supers, int _Subs,int _Options>
+struct evaluator_traits<BandMatrixWrapper<_CoefficientsType,_Rows,_Cols,_Supers,_Subs,_Options> >
+  : public evaluator_traits_base<BandMatrixWrapper<_CoefficientsType,_Rows,_Cols,_Supers,_Subs,_Options> >
+{
+  typedef BandShape Shape;
+};
+
+template<> struct AssignmentKind<DenseShape,BandShape> { typedef EigenBase2EigenBase Kind; };
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_BANDMATRIX_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Block.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Block.h
new file mode 100644
index 00000000..11de45c2
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Block.h
@@ -0,0 +1,452 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_BLOCK_H
+#define EIGEN_BLOCK_H
+
+namespace Eigen { 
+
+namespace internal {
+template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
+struct traits<Block<XprType, BlockRows, BlockCols, InnerPanel> > : traits<XprType>
+{
+  typedef typename traits<XprType>::Scalar Scalar;
+  typedef typename traits<XprType>::StorageKind StorageKind;
+  typedef typename traits<XprType>::XprKind XprKind;
+  typedef typename ref_selector<XprType>::type XprTypeNested;
+  typedef typename remove_reference<XprTypeNested>::type _XprTypeNested;
+  enum{
+    MatrixRows = traits<XprType>::RowsAtCompileTime,
+    MatrixCols = traits<XprType>::ColsAtCompileTime,
+    RowsAtCompileTime = MatrixRows == 0 ? 0 : BlockRows,
+    ColsAtCompileTime = MatrixCols == 0 ? 0 : BlockCols,
+    MaxRowsAtCompileTime = BlockRows==0 ? 0
+                         : RowsAtCompileTime != Dynamic ? int(RowsAtCompileTime)
+                         : int(traits<XprType>::MaxRowsAtCompileTime),
+    MaxColsAtCompileTime = BlockCols==0 ? 0
+                         : ColsAtCompileTime != Dynamic ? int(ColsAtCompileTime)
+                         : int(traits<XprType>::MaxColsAtCompileTime),
+
+    XprTypeIsRowMajor = (int(traits<XprType>::Flags)&RowMajorBit) != 0,
+    IsRowMajor = (MaxRowsAtCompileTime==1&&MaxColsAtCompileTime!=1) ? 1
+               : (MaxColsAtCompileTime==1&&MaxRowsAtCompileTime!=1) ? 0
+               : XprTypeIsRowMajor,
+    HasSameStorageOrderAsXprType = (IsRowMajor == XprTypeIsRowMajor),
+    InnerSize = IsRowMajor ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
+    InnerStrideAtCompileTime = HasSameStorageOrderAsXprType
+                             ? int(inner_stride_at_compile_time<XprType>::ret)
+                             : int(outer_stride_at_compile_time<XprType>::ret),
+    OuterStrideAtCompileTime = HasSameStorageOrderAsXprType
+                             ? int(outer_stride_at_compile_time<XprType>::ret)
+                             : int(inner_stride_at_compile_time<XprType>::ret),
+
+    // FIXME, this traits is rather specialized for dense object and it needs to be cleaned further
+    FlagsLvalueBit = is_lvalue<XprType>::value ? LvalueBit : 0,
+    FlagsRowMajorBit = IsRowMajor ? RowMajorBit : 0,
+    Flags = (traits<XprType>::Flags & (DirectAccessBit | (InnerPanel?CompressedAccessBit:0))) | FlagsLvalueBit | FlagsRowMajorBit,
+    // FIXME DirectAccessBit should not be handled by expressions
+    // 
+    // Alignment is needed by MapBase's assertions
+    // We can sefely set it to false here. Internal alignment errors will be detected by an eigen_internal_assert in the respective evaluator
+    Alignment = 0
+  };
+};
+
+template<typename XprType, int BlockRows=Dynamic, int BlockCols=Dynamic, bool InnerPanel = false,
+         bool HasDirectAccess = internal::has_direct_access<XprType>::ret> class BlockImpl_dense;
+         
+} // end namespace internal
+
+template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel, typename StorageKind> class BlockImpl;
+
+/** \class Block
+  * \ingroup Core_Module
+  *
+  * \brief Expression of a fixed-size or dynamic-size block
+  *
+  * \tparam XprType the type of the expression in which we are taking a block
+  * \tparam BlockRows the number of rows of the block we are taking at compile time (optional)
+  * \tparam BlockCols the number of columns of the block we are taking at compile time (optional)
+  * \tparam InnerPanel is true, if the block maps to a set of rows of a row major matrix or
+  *         to set of columns of a column major matrix (optional). The parameter allows to determine
+  *         at compile time whether aligned access is possible on the block expression.
+  *
+  * This class represents an expression of either a fixed-size or dynamic-size block. It is the return
+  * type of DenseBase::block(Index,Index,Index,Index) and DenseBase::block<int,int>(Index,Index) and
+  * most of the time this is the only way it is used.
+  *
+  * However, if you want to directly maniputate block expressions,
+  * for instance if you want to write a function returning such an expression, you
+  * will need to use this class.
+  *
+  * Here is an example illustrating the dynamic case:
+  * \include class_Block.cpp
+  * Output: \verbinclude class_Block.out
+  *
+  * \note Even though this expression has dynamic size, in the case where \a XprType
+  * has fixed size, this expression inherits a fixed maximal size which means that evaluating
+  * it does not cause a dynamic memory allocation.
+  *
+  * Here is an example illustrating the fixed-size case:
+  * \include class_FixedBlock.cpp
+  * Output: \verbinclude class_FixedBlock.out
+  *
+  * \sa DenseBase::block(Index,Index,Index,Index), DenseBase::block(Index,Index), class VectorBlock
+  */
+template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel> class Block
+  : public BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, typename internal::traits<XprType>::StorageKind>
+{
+    typedef BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, typename internal::traits<XprType>::StorageKind> Impl;
+  public:
+    //typedef typename Impl::Base Base;
+    typedef Impl Base;
+    EIGEN_GENERIC_PUBLIC_INTERFACE(Block)
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Block)
+    
+    typedef typename internal::remove_all<XprType>::type NestedExpression;
+  
+    /** Column or Row constructor
+      */
+    EIGEN_DEVICE_FUNC
+    inline Block(XprType& xpr, Index i) : Impl(xpr,i)
+    {
+      eigen_assert( (i>=0) && (
+          ((BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) && i<xpr.rows())
+        ||((BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) && i<xpr.cols())));
+    }
+
+    /** Fixed-size constructor
+      */
+    EIGEN_DEVICE_FUNC
+    inline Block(XprType& xpr, Index startRow, Index startCol)
+      : Impl(xpr, startRow, startCol)
+    {
+      EIGEN_STATIC_ASSERT(RowsAtCompileTime!=Dynamic && ColsAtCompileTime!=Dynamic,THIS_METHOD_IS_ONLY_FOR_FIXED_SIZE)
+      eigen_assert(startRow >= 0 && BlockRows >= 0 && startRow + BlockRows <= xpr.rows()
+             && startCol >= 0 && BlockCols >= 0 && startCol + BlockCols <= xpr.cols());
+    }
+
+    /** Dynamic-size constructor
+      */
+    EIGEN_DEVICE_FUNC
+    inline Block(XprType& xpr,
+          Index startRow, Index startCol,
+          Index blockRows, Index blockCols)
+      : Impl(xpr, startRow, startCol, blockRows, blockCols)
+    {
+      eigen_assert((RowsAtCompileTime==Dynamic || RowsAtCompileTime==blockRows)
+          && (ColsAtCompileTime==Dynamic || ColsAtCompileTime==blockCols));
+      eigen_assert(startRow >= 0 && blockRows >= 0 && startRow  <= xpr.rows() - blockRows
+          && startCol >= 0 && blockCols >= 0 && startCol <= xpr.cols() - blockCols);
+    }
+};
+         
+// The generic default implementation for dense block simplu forward to the internal::BlockImpl_dense
+// that must be specialized for direct and non-direct access...
+template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
+class BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, Dense>
+  : public internal::BlockImpl_dense<XprType, BlockRows, BlockCols, InnerPanel>
+{
+    typedef internal::BlockImpl_dense<XprType, BlockRows, BlockCols, InnerPanel> Impl;
+    typedef typename XprType::StorageIndex StorageIndex;
+  public:
+    typedef Impl Base;
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(BlockImpl)
+    EIGEN_DEVICE_FUNC inline BlockImpl(XprType& xpr, Index i) : Impl(xpr,i) {}
+    EIGEN_DEVICE_FUNC inline BlockImpl(XprType& xpr, Index startRow, Index startCol) : Impl(xpr, startRow, startCol) {}
+    EIGEN_DEVICE_FUNC
+    inline BlockImpl(XprType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
+      : Impl(xpr, startRow, startCol, blockRows, blockCols) {}
+};
+
+namespace internal {
+
+/** \internal Internal implementation of dense Blocks in the general case. */
+template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel, bool HasDirectAccess> class BlockImpl_dense
+  : public internal::dense_xpr_base<Block<XprType, BlockRows, BlockCols, InnerPanel> >::type
+{
+    typedef Block<XprType, BlockRows, BlockCols, InnerPanel> BlockType;
+    typedef typename internal::ref_selector<XprType>::non_const_type XprTypeNested;
+  public:
+
+    typedef typename internal::dense_xpr_base<BlockType>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(BlockType)
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(BlockImpl_dense)
+
+    // class InnerIterator; // FIXME apparently never used
+
+    /** Column or Row constructor
+      */
+    EIGEN_DEVICE_FUNC
+    inline BlockImpl_dense(XprType& xpr, Index i)
+      : m_xpr(xpr),
+        // It is a row if and only if BlockRows==1 and BlockCols==XprType::ColsAtCompileTime,
+        // and it is a column if and only if BlockRows==XprType::RowsAtCompileTime and BlockCols==1,
+        // all other cases are invalid.
+        // The case a 1x1 matrix seems ambiguous, but the result is the same anyway.
+        m_startRow( (BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) ? i : 0),
+        m_startCol( (BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) ? i : 0),
+        m_blockRows(BlockRows==1 ? 1 : xpr.rows()),
+        m_blockCols(BlockCols==1 ? 1 : xpr.cols())
+    {}
+
+    /** Fixed-size constructor
+      */
+    EIGEN_DEVICE_FUNC
+    inline BlockImpl_dense(XprType& xpr, Index startRow, Index startCol)
+      : m_xpr(xpr), m_startRow(startRow), m_startCol(startCol),
+                    m_blockRows(BlockRows), m_blockCols(BlockCols)
+    {}
+
+    /** Dynamic-size constructor
+      */
+    EIGEN_DEVICE_FUNC
+    inline BlockImpl_dense(XprType& xpr,
+          Index startRow, Index startCol,
+          Index blockRows, Index blockCols)
+      : m_xpr(xpr), m_startRow(startRow), m_startCol(startCol),
+                    m_blockRows(blockRows), m_blockCols(blockCols)
+    {}
+
+    EIGEN_DEVICE_FUNC inline Index rows() const { return m_blockRows.value(); }
+    EIGEN_DEVICE_FUNC inline Index cols() const { return m_blockCols.value(); }
+
+    EIGEN_DEVICE_FUNC
+    inline Scalar& coeffRef(Index rowId, Index colId)
+    {
+      EIGEN_STATIC_ASSERT_LVALUE(XprType)
+      return m_xpr.coeffRef(rowId + m_startRow.value(), colId + m_startCol.value());
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index rowId, Index colId) const
+    {
+      return m_xpr.derived().coeffRef(rowId + m_startRow.value(), colId + m_startCol.value());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const CoeffReturnType coeff(Index rowId, Index colId) const
+    {
+      return m_xpr.coeff(rowId + m_startRow.value(), colId + m_startCol.value());
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline Scalar& coeffRef(Index index)
+    {
+      EIGEN_STATIC_ASSERT_LVALUE(XprType)
+      return m_xpr.coeffRef(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
+                            m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index index) const
+    {
+      return m_xpr.coeffRef(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
+                            m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline const CoeffReturnType coeff(Index index) const
+    {
+      return m_xpr.coeff(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
+                         m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
+    }
+
+    template<int LoadMode>
+    inline PacketScalar packet(Index rowId, Index colId) const
+    {
+      return m_xpr.template packet<Unaligned>(rowId + m_startRow.value(), colId + m_startCol.value());
+    }
+
+    template<int LoadMode>
+    inline void writePacket(Index rowId, Index colId, const PacketScalar& val)
+    {
+      m_xpr.template writePacket<Unaligned>(rowId + m_startRow.value(), colId + m_startCol.value(), val);
+    }
+
+    template<int LoadMode>
+    inline PacketScalar packet(Index index) const
+    {
+      return m_xpr.template packet<Unaligned>
+              (m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
+               m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
+    }
+
+    template<int LoadMode>
+    inline void writePacket(Index index, const PacketScalar& val)
+    {
+      m_xpr.template writePacket<Unaligned>
+         (m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
+          m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0), val);
+    }
+
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    /** \sa MapBase::data() */
+    EIGEN_DEVICE_FUNC inline const Scalar* data() const;
+    EIGEN_DEVICE_FUNC inline Index innerStride() const;
+    EIGEN_DEVICE_FUNC inline Index outerStride() const;
+    #endif
+
+    EIGEN_DEVICE_FUNC
+    const typename internal::remove_all<XprTypeNested>::type& nestedExpression() const
+    { 
+      return m_xpr; 
+    }
+
+    EIGEN_DEVICE_FUNC
+    XprType& nestedExpression() { return m_xpr; }
+      
+    EIGEN_DEVICE_FUNC
+    StorageIndex startRow() const
+    { 
+      return m_startRow.value(); 
+    }
+      
+    EIGEN_DEVICE_FUNC
+    StorageIndex startCol() const
+    { 
+      return m_startCol.value(); 
+    }
+
+  protected:
+
+    XprTypeNested m_xpr;
+    const internal::variable_if_dynamic<StorageIndex, (XprType::RowsAtCompileTime == 1 && BlockRows==1) ? 0 : Dynamic> m_startRow;
+    const internal::variable_if_dynamic<StorageIndex, (XprType::ColsAtCompileTime == 1 && BlockCols==1) ? 0 : Dynamic> m_startCol;
+    const internal::variable_if_dynamic<StorageIndex, RowsAtCompileTime> m_blockRows;
+    const internal::variable_if_dynamic<StorageIndex, ColsAtCompileTime> m_blockCols;
+};
+
+/** \internal Internal implementation of dense Blocks in the direct access case.*/
+template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
+class BlockImpl_dense<XprType,BlockRows,BlockCols, InnerPanel,true>
+  : public MapBase<Block<XprType, BlockRows, BlockCols, InnerPanel> >
+{
+    typedef Block<XprType, BlockRows, BlockCols, InnerPanel> BlockType;
+    typedef typename internal::ref_selector<XprType>::non_const_type XprTypeNested;
+    enum {
+      XprTypeIsRowMajor = (int(traits<XprType>::Flags)&RowMajorBit) != 0
+    };
+  public:
+
+    typedef MapBase<BlockType> Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(BlockType)
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(BlockImpl_dense)
+
+    /** Column or Row constructor
+      */
+    EIGEN_DEVICE_FUNC
+    inline BlockImpl_dense(XprType& xpr, Index i)
+      : Base(xpr.data() + i * (    ((BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) && (!XprTypeIsRowMajor)) 
+                                || ((BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) && ( XprTypeIsRowMajor)) ? xpr.innerStride() : xpr.outerStride()),
+             BlockRows==1 ? 1 : xpr.rows(),
+             BlockCols==1 ? 1 : xpr.cols()),
+        m_xpr(xpr),
+        m_startRow( (BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) ? i : 0),
+        m_startCol( (BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) ? i : 0)
+    {
+      init();
+    }
+
+    /** Fixed-size constructor
+      */
+    EIGEN_DEVICE_FUNC
+    inline BlockImpl_dense(XprType& xpr, Index startRow, Index startCol)
+      : Base(xpr.data()+xpr.innerStride()*(XprTypeIsRowMajor?startCol:startRow) + xpr.outerStride()*(XprTypeIsRowMajor?startRow:startCol)),
+        m_xpr(xpr), m_startRow(startRow), m_startCol(startCol)
+    {
+      init();
+    }
+
+    /** Dynamic-size constructor
+      */
+    EIGEN_DEVICE_FUNC
+    inline BlockImpl_dense(XprType& xpr,
+          Index startRow, Index startCol,
+          Index blockRows, Index blockCols)
+      : Base(xpr.data()+xpr.innerStride()*(XprTypeIsRowMajor?startCol:startRow) + xpr.outerStride()*(XprTypeIsRowMajor?startRow:startCol), blockRows, blockCols),
+        m_xpr(xpr), m_startRow(startRow), m_startCol(startCol)
+    {
+      init();
+    }
+
+    EIGEN_DEVICE_FUNC
+    const typename internal::remove_all<XprTypeNested>::type& nestedExpression() const
+    { 
+      return m_xpr; 
+    }
+
+    EIGEN_DEVICE_FUNC
+    XprType& nestedExpression() { return m_xpr; }
+      
+    /** \sa MapBase::innerStride() */
+    EIGEN_DEVICE_FUNC
+    inline Index innerStride() const
+    {
+      return internal::traits<BlockType>::HasSameStorageOrderAsXprType
+             ? m_xpr.innerStride()
+             : m_xpr.outerStride();
+    }
+
+    /** \sa MapBase::outerStride() */
+    EIGEN_DEVICE_FUNC
+    inline Index outerStride() const
+    {
+      return m_outerStride;
+    }
+
+    EIGEN_DEVICE_FUNC
+    StorageIndex startRow() const
+    {
+      return m_startRow.value();
+    }
+
+    EIGEN_DEVICE_FUNC
+    StorageIndex startCol() const
+    {
+      return m_startCol.value();
+    }
+
+  #ifndef __SUNPRO_CC
+  // FIXME sunstudio is not friendly with the above friend...
+  // META-FIXME there is no 'friend' keyword around here. Is this obsolete?
+  protected:
+  #endif
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** \internal used by allowAligned() */
+    EIGEN_DEVICE_FUNC
+    inline BlockImpl_dense(XprType& xpr, const Scalar* data, Index blockRows, Index blockCols)
+      : Base(data, blockRows, blockCols), m_xpr(xpr)
+    {
+      init();
+    }
+    #endif
+
+  protected:
+    EIGEN_DEVICE_FUNC
+    void init()
+    {
+      m_outerStride = internal::traits<BlockType>::HasSameStorageOrderAsXprType
+                    ? m_xpr.outerStride()
+                    : m_xpr.innerStride();
+    }
+
+    XprTypeNested m_xpr;
+    const internal::variable_if_dynamic<StorageIndex, (XprType::RowsAtCompileTime == 1 && BlockRows==1) ? 0 : Dynamic> m_startRow;
+    const internal::variable_if_dynamic<StorageIndex, (XprType::ColsAtCompileTime == 1 && BlockCols==1) ? 0 : Dynamic> m_startCol;
+    Index m_outerStride;
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_BLOCK_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/BooleanRedux.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/BooleanRedux.h
new file mode 100644
index 00000000..ccf51906
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/BooleanRedux.h
@@ -0,0 +1,162 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ALLANDANY_H
+#define EIGEN_ALLANDANY_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename Derived, int UnrollCount, int Rows>
+struct all_unroller
+{
+  enum {
+    col = (UnrollCount-1) / Rows,
+    row = (UnrollCount-1) % Rows
+  };
+
+  static inline bool run(const Derived &mat)
+  {
+    return all_unroller<Derived, UnrollCount-1, Rows>::run(mat) && mat.coeff(row, col);
+  }
+};
+
+template<typename Derived, int Rows>
+struct all_unroller<Derived, 0, Rows>
+{
+  static inline bool run(const Derived &/*mat*/) { return true; }
+};
+
+template<typename Derived, int Rows>
+struct all_unroller<Derived, Dynamic, Rows>
+{
+  static inline bool run(const Derived &) { return false; }
+};
+
+template<typename Derived, int UnrollCount, int Rows>
+struct any_unroller
+{
+  enum {
+    col = (UnrollCount-1) / Rows,
+    row = (UnrollCount-1) % Rows
+  };
+  
+  static inline bool run(const Derived &mat)
+  {
+    return any_unroller<Derived, UnrollCount-1, Rows>::run(mat) || mat.coeff(row, col);
+  }
+};
+
+template<typename Derived, int Rows>
+struct any_unroller<Derived, 0, Rows>
+{
+  static inline bool run(const Derived & /*mat*/) { return false; }
+};
+
+template<typename Derived, int Rows>
+struct any_unroller<Derived, Dynamic, Rows>
+{
+  static inline bool run(const Derived &) { return false; }
+};
+
+} // end namespace internal
+
+/** \returns true if all coefficients are true
+  *
+  * Example: \include MatrixBase_all.cpp
+  * Output: \verbinclude MatrixBase_all.out
+  *
+  * \sa any(), Cwise::operator<()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline bool DenseBase<Derived>::all() const
+{
+  typedef internal::evaluator<Derived> Evaluator;
+  enum {
+    unroll = SizeAtCompileTime != Dynamic
+          && SizeAtCompileTime * (Evaluator::CoeffReadCost + NumTraits<Scalar>::AddCost) <= EIGEN_UNROLLING_LIMIT
+  };
+  Evaluator evaluator(derived());
+  if(unroll)
+    return internal::all_unroller<Evaluator, unroll ? int(SizeAtCompileTime) : Dynamic, internal::traits<Derived>::RowsAtCompileTime>::run(evaluator);
+  else
+  {
+    for(Index j = 0; j < cols(); ++j)
+      for(Index i = 0; i < rows(); ++i)
+        if (!evaluator.coeff(i, j)) return false;
+    return true;
+  }
+}
+
+/** \returns true if at least one coefficient is true
+  *
+  * \sa all()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline bool DenseBase<Derived>::any() const
+{
+  typedef internal::evaluator<Derived> Evaluator;
+  enum {
+    unroll = SizeAtCompileTime != Dynamic
+          && SizeAtCompileTime * (Evaluator::CoeffReadCost + NumTraits<Scalar>::AddCost) <= EIGEN_UNROLLING_LIMIT
+  };
+  Evaluator evaluator(derived());
+  if(unroll)
+    return internal::any_unroller<Evaluator, unroll ? int(SizeAtCompileTime) : Dynamic, internal::traits<Derived>::RowsAtCompileTime>::run(evaluator);
+  else
+  {
+    for(Index j = 0; j < cols(); ++j)
+      for(Index i = 0; i < rows(); ++i)
+        if (evaluator.coeff(i, j)) return true;
+    return false;
+  }
+}
+
+/** \returns the number of coefficients which evaluate to true
+  *
+  * \sa all(), any()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline Eigen::Index DenseBase<Derived>::count() const
+{
+  return derived().template cast<bool>().template cast<Index>().sum();
+}
+
+/** \returns true is \c *this contains at least one Not A Number (NaN).
+  *
+  * \sa allFinite()
+  */
+template<typename Derived>
+inline bool DenseBase<Derived>::hasNaN() const
+{
+#if EIGEN_COMP_MSVC || (defined __FAST_MATH__)
+  return derived().array().isNaN().any();
+#else
+  return !((derived().array()==derived().array()).all());
+#endif
+}
+
+/** \returns true if \c *this contains only finite numbers, i.e., no NaN and no +/-INF values.
+  *
+  * \sa hasNaN()
+  */
+template<typename Derived>
+inline bool DenseBase<Derived>::allFinite() const
+{
+#if EIGEN_COMP_MSVC || (defined __FAST_MATH__)
+  return derived().array().isFinite().all();
+#else
+  return !((derived()-derived()).hasNaN());
+#endif
+}
+    
+} // end namespace Eigen
+
+#endif // EIGEN_ALLANDANY_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/CommaInitializer.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/CommaInitializer.h
new file mode 100644
index 00000000..35fdbb81
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/CommaInitializer.h
@@ -0,0 +1,160 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMMAINITIALIZER_H
+#define EIGEN_COMMAINITIALIZER_H
+
+namespace Eigen { 
+
+/** \class CommaInitializer
+  * \ingroup Core_Module
+  *
+  * \brief Helper class used by the comma initializer operator
+  *
+  * This class is internally used to implement the comma initializer feature. It is
+  * the return type of MatrixBase::operator<<, and most of the time this is the only
+  * way it is used.
+  *
+  * \sa \blank \ref MatrixBaseCommaInitRef "MatrixBase::operator<<", CommaInitializer::finished()
+  */
+template<typename XprType>
+struct CommaInitializer
+{
+  typedef typename XprType::Scalar Scalar;
+
+  EIGEN_DEVICE_FUNC
+  inline CommaInitializer(XprType& xpr, const Scalar& s)
+    : m_xpr(xpr), m_row(0), m_col(1), m_currentBlockRows(1)
+  {
+    m_xpr.coeffRef(0,0) = s;
+  }
+
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC
+  inline CommaInitializer(XprType& xpr, const DenseBase<OtherDerived>& other)
+    : m_xpr(xpr), m_row(0), m_col(other.cols()), m_currentBlockRows(other.rows())
+  {
+    m_xpr.block(0, 0, other.rows(), other.cols()) = other;
+  }
+
+  /* Copy/Move constructor which transfers ownership. This is crucial in 
+   * absence of return value optimization to avoid assertions during destruction. */
+  // FIXME in C++11 mode this could be replaced by a proper RValue constructor
+  EIGEN_DEVICE_FUNC
+  inline CommaInitializer(const CommaInitializer& o)
+  : m_xpr(o.m_xpr), m_row(o.m_row), m_col(o.m_col), m_currentBlockRows(o.m_currentBlockRows) {
+    // Mark original object as finished. In absence of R-value references we need to const_cast:
+    const_cast<CommaInitializer&>(o).m_row = m_xpr.rows();
+    const_cast<CommaInitializer&>(o).m_col = m_xpr.cols();
+    const_cast<CommaInitializer&>(o).m_currentBlockRows = 0;
+  }
+
+  /* inserts a scalar value in the target matrix */
+  EIGEN_DEVICE_FUNC
+  CommaInitializer& operator,(const Scalar& s)
+  {
+    if (m_col==m_xpr.cols())
+    {
+      m_row+=m_currentBlockRows;
+      m_col = 0;
+      m_currentBlockRows = 1;
+      eigen_assert(m_row<m_xpr.rows()
+        && "Too many rows passed to comma initializer (operator<<)");
+    }
+    eigen_assert(m_col<m_xpr.cols()
+      && "Too many coefficients passed to comma initializer (operator<<)");
+    eigen_assert(m_currentBlockRows==1);
+    m_xpr.coeffRef(m_row, m_col++) = s;
+    return *this;
+  }
+
+  /* inserts a matrix expression in the target matrix */
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC
+  CommaInitializer& operator,(const DenseBase<OtherDerived>& other)
+  {
+    if (m_col==m_xpr.cols() && (other.cols()!=0 || other.rows()!=m_currentBlockRows))
+    {
+      m_row+=m_currentBlockRows;
+      m_col = 0;
+      m_currentBlockRows = other.rows();
+      eigen_assert(m_row+m_currentBlockRows<=m_xpr.rows()
+        && "Too many rows passed to comma initializer (operator<<)");
+    }
+    eigen_assert((m_col + other.cols() <= m_xpr.cols())
+      && "Too many coefficients passed to comma initializer (operator<<)");
+    eigen_assert(m_currentBlockRows==other.rows());
+    m_xpr.template block<OtherDerived::RowsAtCompileTime, OtherDerived::ColsAtCompileTime>
+                    (m_row, m_col, other.rows(), other.cols()) = other;
+    m_col += other.cols();
+    return *this;
+  }
+
+  EIGEN_DEVICE_FUNC
+  inline ~CommaInitializer()
+#if defined VERIFY_RAISES_ASSERT && (!defined EIGEN_NO_ASSERTION_CHECKING) && defined EIGEN_EXCEPTIONS
+  EIGEN_EXCEPTION_SPEC(Eigen::eigen_assert_exception)
+#endif
+  {
+      finished();
+  }
+
+  /** \returns the built matrix once all its coefficients have been set.
+    * Calling finished is 100% optional. Its purpose is to write expressions
+    * like this:
+    * \code
+    * quaternion.fromRotationMatrix((Matrix3f() << axis0, axis1, axis2).finished());
+    * \endcode
+    */
+  EIGEN_DEVICE_FUNC
+  inline XprType& finished() {
+      eigen_assert(((m_row+m_currentBlockRows) == m_xpr.rows() || m_xpr.cols() == 0)
+           && m_col == m_xpr.cols()
+           && "Too few coefficients passed to comma initializer (operator<<)");
+      return m_xpr;
+  }
+
+  XprType& m_xpr;           // target expression
+  Index m_row;              // current row id
+  Index m_col;              // current col id
+  Index m_currentBlockRows; // current block height
+};
+
+/** \anchor MatrixBaseCommaInitRef
+  * Convenient operator to set the coefficients of a matrix.
+  *
+  * The coefficients must be provided in a row major order and exactly match
+  * the size of the matrix. Otherwise an assertion is raised.
+  *
+  * Example: \include MatrixBase_set.cpp
+  * Output: \verbinclude MatrixBase_set.out
+  * 
+  * \note According the c++ standard, the argument expressions of this comma initializer are evaluated in arbitrary order.
+  *
+  * \sa CommaInitializer::finished(), class CommaInitializer
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline CommaInitializer<Derived> DenseBase<Derived>::operator<< (const Scalar& s)
+{
+  return CommaInitializer<Derived>(*static_cast<Derived*>(this), s);
+}
+
+/** \sa operator<<(const Scalar&) */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC inline CommaInitializer<Derived>
+DenseBase<Derived>::operator<<(const DenseBase<OtherDerived>& other)
+{
+  return CommaInitializer<Derived>(*static_cast<Derived *>(this), other);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_COMMAINITIALIZER_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/ConditionEstimator.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/ConditionEstimator.h
new file mode 100644
index 00000000..aa7efdc7
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/ConditionEstimator.h
@@ -0,0 +1,175 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Rasmus Munk Larsen (rmlarsen@google.com)
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CONDITIONESTIMATOR_H
+#define EIGEN_CONDITIONESTIMATOR_H
+
+namespace Eigen {
+
+namespace internal {
+
+template <typename Vector, typename RealVector, bool IsComplex>
+struct rcond_compute_sign {
+  static inline Vector run(const Vector& v) {
+    const RealVector v_abs = v.cwiseAbs();
+    return (v_abs.array() == static_cast<typename Vector::RealScalar>(0))
+            .select(Vector::Ones(v.size()), v.cwiseQuotient(v_abs));
+  }
+};
+
+// Partial specialization to avoid elementwise division for real vectors.
+template <typename Vector>
+struct rcond_compute_sign<Vector, Vector, false> {
+  static inline Vector run(const Vector& v) {
+    return (v.array() < static_cast<typename Vector::RealScalar>(0))
+           .select(-Vector::Ones(v.size()), Vector::Ones(v.size()));
+  }
+};
+
+/**
+  * \returns an estimate of ||inv(matrix)||_1 given a decomposition of
+  * \a matrix that implements .solve() and .adjoint().solve() methods.
+  *
+  * This function implements Algorithms 4.1 and 5.1 from
+  *   http://www.maths.manchester.ac.uk/~higham/narep/narep135.pdf
+  * which also forms the basis for the condition number estimators in
+  * LAPACK. Since at most 10 calls to the solve method of dec are
+  * performed, the total cost is O(dims^2), as opposed to O(dims^3)
+  * needed to compute the inverse matrix explicitly.
+  *
+  * The most common usage is in estimating the condition number
+  * ||matrix||_1 * ||inv(matrix)||_1. The first term ||matrix||_1 can be
+  * computed directly in O(n^2) operations.
+  *
+  * Supports the following decompositions: FullPivLU, PartialPivLU, LDLT, and
+  * LLT.
+  *
+  * \sa FullPivLU, PartialPivLU, LDLT, LLT.
+  */
+template <typename Decomposition>
+typename Decomposition::RealScalar rcond_invmatrix_L1_norm_estimate(const Decomposition& dec)
+{
+  typedef typename Decomposition::MatrixType MatrixType;
+  typedef typename Decomposition::Scalar Scalar;
+  typedef typename Decomposition::RealScalar RealScalar;
+  typedef typename internal::plain_col_type<MatrixType>::type Vector;
+  typedef typename internal::plain_col_type<MatrixType, RealScalar>::type RealVector;
+  const bool is_complex = (NumTraits<Scalar>::IsComplex != 0);
+
+  eigen_assert(dec.rows() == dec.cols());
+  const Index n = dec.rows();
+  if (n == 0)
+    return 0;
+
+  // Disable Index to float conversion warning
+#ifdef __INTEL_COMPILER
+  #pragma warning push
+  #pragma warning ( disable : 2259 )
+#endif
+  Vector v = dec.solve(Vector::Ones(n) / Scalar(n));
+#ifdef __INTEL_COMPILER
+  #pragma warning pop
+#endif
+
+  // lower_bound is a lower bound on
+  //   ||inv(matrix)||_1  = sup_v ||inv(matrix) v||_1 / ||v||_1
+  // and is the objective maximized by the ("super-") gradient ascent
+  // algorithm below.
+  RealScalar lower_bound = v.template lpNorm<1>();
+  if (n == 1)
+    return lower_bound;
+
+  // Gradient ascent algorithm follows: We know that the optimum is achieved at
+  // one of the simplices v = e_i, so in each iteration we follow a
+  // super-gradient to move towards the optimal one.
+  RealScalar old_lower_bound = lower_bound;
+  Vector sign_vector(n);
+  Vector old_sign_vector;
+  Index v_max_abs_index = -1;
+  Index old_v_max_abs_index = v_max_abs_index;
+  for (int k = 0; k < 4; ++k)
+  {
+    sign_vector = internal::rcond_compute_sign<Vector, RealVector, is_complex>::run(v);
+    if (k > 0 && !is_complex && sign_vector == old_sign_vector) {
+      // Break if the solution stagnated.
+      break;
+    }
+    // v_max_abs_index = argmax |real( inv(matrix)^T * sign_vector )|
+    v = dec.adjoint().solve(sign_vector);
+    v.real().cwiseAbs().maxCoeff(&v_max_abs_index);
+    if (v_max_abs_index == old_v_max_abs_index) {
+      // Break if the solution stagnated.
+      break;
+    }
+    // Move to the new simplex e_j, where j = v_max_abs_index.
+    v = dec.solve(Vector::Unit(n, v_max_abs_index));  // v = inv(matrix) * e_j.
+    lower_bound = v.template lpNorm<1>();
+    if (lower_bound <= old_lower_bound) {
+      // Break if the gradient step did not increase the lower_bound.
+      break;
+    }
+    if (!is_complex) {
+      old_sign_vector = sign_vector;
+    }
+    old_v_max_abs_index = v_max_abs_index;
+    old_lower_bound = lower_bound;
+  }
+  // The following calculates an independent estimate of ||matrix||_1 by
+  // multiplying matrix by a vector with entries of slowly increasing
+  // magnitude and alternating sign:
+  //   v_i = (-1)^{i} (1 + (i / (dim-1))), i = 0,...,dim-1.
+  // This improvement to Hager's algorithm above is due to Higham. It was
+  // added to make the algorithm more robust in certain corner cases where
+  // large elements in the matrix might otherwise escape detection due to
+  // exact cancellation (especially when op and op_adjoint correspond to a
+  // sequence of backsubstitutions and permutations), which could cause
+  // Hager's algorithm to vastly underestimate ||matrix||_1.
+  Scalar alternating_sign(RealScalar(1));
+  for (Index i = 0; i < n; ++i) {
+    // The static_cast is needed when Scalar is a complex and RealScalar implements expression templates
+    v[i] = alternating_sign * static_cast<RealScalar>(RealScalar(1) + (RealScalar(i) / (RealScalar(n - 1))));
+    alternating_sign = -alternating_sign;
+  }
+  v = dec.solve(v);
+  const RealScalar alternate_lower_bound = (2 * v.template lpNorm<1>()) / (3 * RealScalar(n));
+  return numext::maxi(lower_bound, alternate_lower_bound);
+}
+
+/** \brief Reciprocal condition number estimator.
+  *
+  * Computing a decomposition of a dense matrix takes O(n^3) operations, while
+  * this method estimates the condition number quickly and reliably in O(n^2)
+  * operations.
+  *
+  * \returns an estimate of the reciprocal condition number
+  * (1 / (||matrix||_1 * ||inv(matrix)||_1)) of matrix, given ||matrix||_1 and
+  * its decomposition. Supports the following decompositions: FullPivLU,
+  * PartialPivLU, LDLT, and LLT.
+  *
+  * \sa FullPivLU, PartialPivLU, LDLT, LLT.
+  */
+template <typename Decomposition>
+typename Decomposition::RealScalar
+rcond_estimate_helper(typename Decomposition::RealScalar matrix_norm, const Decomposition& dec)
+{
+  typedef typename Decomposition::RealScalar RealScalar;
+  eigen_assert(dec.rows() == dec.cols());
+  if (dec.rows() == 0)              return RealScalar(1);
+  if (matrix_norm == RealScalar(0)) return RealScalar(0);
+  if (dec.rows() == 1)              return RealScalar(1);
+  const RealScalar inverse_matrix_norm = rcond_invmatrix_L1_norm_estimate(dec);
+  return (inverse_matrix_norm == RealScalar(0) ? RealScalar(0)
+                                               : (RealScalar(1) / inverse_matrix_norm) / matrix_norm);
+}
+
+}  // namespace internal
+
+}  // namespace Eigen
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/CoreEvaluators.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/CoreEvaluators.h
new file mode 100644
index 00000000..15b361b3
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/CoreEvaluators.h
@@ -0,0 +1,1728 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2011-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2011-2012 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+#ifndef EIGEN_COREEVALUATORS_H
+#define EIGEN_COREEVALUATORS_H
+
+namespace Eigen {
+  
+namespace internal {
+
+// This class returns the evaluator kind from the expression storage kind.
+// Default assumes index based accessors
+template<typename StorageKind>
+struct storage_kind_to_evaluator_kind {
+  typedef IndexBased Kind;
+};
+
+// This class returns the evaluator shape from the expression storage kind.
+// It can be Dense, Sparse, Triangular, Diagonal, SelfAdjoint, Band, etc.
+template<typename StorageKind> struct storage_kind_to_shape;
+
+template<> struct storage_kind_to_shape<Dense>                  { typedef DenseShape Shape;           };
+template<> struct storage_kind_to_shape<SolverStorage>          { typedef SolverShape Shape;           };
+template<> struct storage_kind_to_shape<PermutationStorage>     { typedef PermutationShape Shape;     };
+template<> struct storage_kind_to_shape<TranspositionsStorage>  { typedef TranspositionsShape Shape;  };
+
+// Evaluators have to be specialized with respect to various criteria such as:
+//  - storage/structure/shape
+//  - scalar type
+//  - etc.
+// Therefore, we need specialization of evaluator providing additional template arguments for each kind of evaluators.
+// We currently distinguish the following kind of evaluators:
+// - unary_evaluator    for expressions taking only one arguments (CwiseUnaryOp, CwiseUnaryView, Transpose, MatrixWrapper, ArrayWrapper, Reverse, Replicate)
+// - binary_evaluator   for expression taking two arguments (CwiseBinaryOp)
+// - ternary_evaluator   for expression taking three arguments (CwiseTernaryOp)
+// - product_evaluator  for linear algebra products (Product); special case of binary_evaluator because it requires additional tags for dispatching.
+// - mapbase_evaluator  for Map, Block, Ref
+// - block_evaluator    for Block (special dispatching to a mapbase_evaluator or unary_evaluator)
+
+template< typename T,
+          typename Arg1Kind   = typename evaluator_traits<typename T::Arg1>::Kind,
+          typename Arg2Kind   = typename evaluator_traits<typename T::Arg2>::Kind,
+          typename Arg3Kind   = typename evaluator_traits<typename T::Arg3>::Kind,
+          typename Arg1Scalar = typename traits<typename T::Arg1>::Scalar,
+          typename Arg2Scalar = typename traits<typename T::Arg2>::Scalar,
+          typename Arg3Scalar = typename traits<typename T::Arg3>::Scalar> struct ternary_evaluator;
+
+template< typename T,
+          typename LhsKind   = typename evaluator_traits<typename T::Lhs>::Kind,
+          typename RhsKind   = typename evaluator_traits<typename T::Rhs>::Kind,
+          typename LhsScalar = typename traits<typename T::Lhs>::Scalar,
+          typename RhsScalar = typename traits<typename T::Rhs>::Scalar> struct binary_evaluator;
+
+template< typename T,
+          typename Kind   = typename evaluator_traits<typename T::NestedExpression>::Kind,
+          typename Scalar = typename T::Scalar> struct unary_evaluator;
+          
+// evaluator_traits<T> contains traits for evaluator<T> 
+
+template<typename T>
+struct evaluator_traits_base
+{
+  // by default, get evaluator kind and shape from storage
+  typedef typename storage_kind_to_evaluator_kind<typename traits<T>::StorageKind>::Kind Kind;
+  typedef typename storage_kind_to_shape<typename traits<T>::StorageKind>::Shape Shape;
+};
+
+// Default evaluator traits
+template<typename T>
+struct evaluator_traits : public evaluator_traits_base<T>
+{
+};
+
+template<typename T, typename Shape = typename evaluator_traits<T>::Shape >
+struct evaluator_assume_aliasing {
+  static const bool value = false;
+};
+
+// By default, we assume a unary expression:
+template<typename T>
+struct evaluator : public unary_evaluator<T>
+{
+  typedef unary_evaluator<T> Base;
+  EIGEN_DEVICE_FUNC explicit evaluator(const T& xpr) : Base(xpr) {}
+};
+
+
+// TODO: Think about const-correctness
+template<typename T>
+struct evaluator<const T>
+  : evaluator<T>
+{
+  EIGEN_DEVICE_FUNC
+  explicit evaluator(const T& xpr) : evaluator<T>(xpr) {}
+};
+
+// ---------- base class for all evaluators ----------
+
+template<typename ExpressionType>
+struct evaluator_base
+{
+  // TODO that's not very nice to have to propagate all these traits. They are currently only needed to handle outer,inner indices.
+  typedef traits<ExpressionType> ExpressionTraits;
+  
+  enum {
+    Alignment = 0
+  };
+  // noncopyable:
+  // Don't make this class inherit noncopyable as this kills EBO (Empty Base Optimization)
+  // and make complex evaluator much larger than then should do.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE evaluator_base() {}
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ~evaluator_base() {}
+private:
+  EIGEN_DEVICE_FUNC evaluator_base(const evaluator_base&);
+  EIGEN_DEVICE_FUNC const evaluator_base& operator=(const evaluator_base&);
+};
+
+// -------------------- Matrix and Array --------------------
+//
+// evaluator<PlainObjectBase> is a common base class for the
+// Matrix and Array evaluators.
+// Here we directly specialize evaluator. This is not really a unary expression, and it is, by definition, dense,
+// so no need for more sophisticated dispatching.
+
+// this helper permits to completely eliminate m_outerStride if it is known at compiletime.
+template<typename Scalar,int OuterStride> class plainobjectbase_evaluator_data {
+public:
+  EIGEN_DEVICE_FUNC plainobjectbase_evaluator_data(const Scalar* ptr, Index outerStride) : data(ptr)
+  {
+    EIGEN_ONLY_USED_FOR_DEBUG(outerStride);
+    eigen_internal_assert(outerStride==OuterStride);
+  }
+  EIGEN_DEVICE_FUNC Index outerStride() const { return OuterStride; }
+  const Scalar *data;
+};
+
+template<typename Scalar> class plainobjectbase_evaluator_data<Scalar,Dynamic> {
+public:
+  EIGEN_DEVICE_FUNC plainobjectbase_evaluator_data(const Scalar* ptr, Index outerStride) : data(ptr), m_outerStride(outerStride) {}
+  EIGEN_DEVICE_FUNC Index outerStride() const { return m_outerStride; }
+  const Scalar *data;
+protected:
+  Index m_outerStride;
+};
+
+template<typename Derived>
+struct evaluator<PlainObjectBase<Derived> >
+  : evaluator_base<Derived>
+{
+  typedef PlainObjectBase<Derived> PlainObjectType;
+  typedef typename PlainObjectType::Scalar Scalar;
+  typedef typename PlainObjectType::CoeffReturnType CoeffReturnType;
+
+  enum {
+    IsRowMajor = PlainObjectType::IsRowMajor,
+    IsVectorAtCompileTime = PlainObjectType::IsVectorAtCompileTime,
+    RowsAtCompileTime = PlainObjectType::RowsAtCompileTime,
+    ColsAtCompileTime = PlainObjectType::ColsAtCompileTime,
+    
+    CoeffReadCost = NumTraits<Scalar>::ReadCost,
+    Flags = traits<Derived>::EvaluatorFlags,
+    Alignment = traits<Derived>::Alignment
+  };
+  enum {
+    // We do not need to know the outer stride for vectors
+    OuterStrideAtCompileTime = IsVectorAtCompileTime  ? 0
+                                                      : int(IsRowMajor) ? ColsAtCompileTime
+                                                                        : RowsAtCompileTime
+  };
+
+  EIGEN_DEVICE_FUNC evaluator()
+    : m_d(0,OuterStrideAtCompileTime)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  EIGEN_DEVICE_FUNC explicit evaluator(const PlainObjectType& m)
+    : m_d(m.data(),IsVectorAtCompileTime ? 0 : m.outerStride())
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    if (IsRowMajor)
+      return m_d.data[row * m_d.outerStride() + col];
+    else
+      return m_d.data[row + col * m_d.outerStride()];
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return m_d.data[index];
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index row, Index col)
+  {
+    if (IsRowMajor)
+      return const_cast<Scalar*>(m_d.data)[row * m_d.outerStride() + col];
+    else
+      return const_cast<Scalar*>(m_d.data)[row + col * m_d.outerStride()];
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index index)
+  {
+    return const_cast<Scalar*>(m_d.data)[index];
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index row, Index col) const
+  {
+    if (IsRowMajor)
+      return ploadt<PacketType, LoadMode>(m_d.data + row * m_d.outerStride() + col);
+    else
+      return ploadt<PacketType, LoadMode>(m_d.data + row + col * m_d.outerStride());
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index index) const
+  {
+    return ploadt<PacketType, LoadMode>(m_d.data + index);
+  }
+
+  template<int StoreMode,typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index row, Index col, const PacketType& x)
+  {
+    if (IsRowMajor)
+      return pstoret<Scalar, PacketType, StoreMode>
+	            (const_cast<Scalar*>(m_d.data) + row * m_d.outerStride() + col, x);
+    else
+      return pstoret<Scalar, PacketType, StoreMode>
+                    (const_cast<Scalar*>(m_d.data) + row + col * m_d.outerStride(), x);
+  }
+
+  template<int StoreMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index index, const PacketType& x)
+  {
+    return pstoret<Scalar, PacketType, StoreMode>(const_cast<Scalar*>(m_d.data) + index, x);
+  }
+
+protected:
+
+  plainobjectbase_evaluator_data<Scalar,OuterStrideAtCompileTime> m_d;
+};
+
+template<typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
+struct evaluator<Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols> >
+  : evaluator<PlainObjectBase<Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols> > >
+{
+  typedef Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols> XprType;
+  
+  EIGEN_DEVICE_FUNC evaluator() {}
+
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType& m)
+    : evaluator<PlainObjectBase<XprType> >(m) 
+  { }
+};
+
+template<typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
+struct evaluator<Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols> >
+  : evaluator<PlainObjectBase<Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols> > >
+{
+  typedef Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols> XprType;
+
+  EIGEN_DEVICE_FUNC evaluator() {}
+  
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType& m)
+    : evaluator<PlainObjectBase<XprType> >(m) 
+  { }
+};
+
+// -------------------- Transpose --------------------
+
+template<typename ArgType>
+struct unary_evaluator<Transpose<ArgType>, IndexBased>
+  : evaluator_base<Transpose<ArgType> >
+{
+  typedef Transpose<ArgType> XprType;
+  
+  enum {
+    CoeffReadCost = evaluator<ArgType>::CoeffReadCost,    
+    Flags = evaluator<ArgType>::Flags ^ RowMajorBit,
+    Alignment = evaluator<ArgType>::Alignment
+  };
+
+  EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& t) : m_argImpl(t.nestedExpression()) {}
+
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    return m_argImpl.coeff(col, row);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return m_argImpl.coeff(index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index row, Index col)
+  {
+    return m_argImpl.coeffRef(col, row);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  typename XprType::Scalar& coeffRef(Index index)
+  {
+    return m_argImpl.coeffRef(index);
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index row, Index col) const
+  {
+    return m_argImpl.template packet<LoadMode,PacketType>(col, row);
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index index) const
+  {
+    return m_argImpl.template packet<LoadMode,PacketType>(index);
+  }
+
+  template<int StoreMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index row, Index col, const PacketType& x)
+  {
+    m_argImpl.template writePacket<StoreMode,PacketType>(col, row, x);
+  }
+
+  template<int StoreMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index index, const PacketType& x)
+  {
+    m_argImpl.template writePacket<StoreMode,PacketType>(index, x);
+  }
+
+protected:
+  evaluator<ArgType> m_argImpl;
+};
+
+// -------------------- CwiseNullaryOp --------------------
+// Like Matrix and Array, this is not really a unary expression, so we directly specialize evaluator.
+// Likewise, there is not need to more sophisticated dispatching here.
+
+template<typename Scalar,typename NullaryOp,
+         bool has_nullary = has_nullary_operator<NullaryOp>::value,
+         bool has_unary   = has_unary_operator<NullaryOp>::value,
+         bool has_binary  = has_binary_operator<NullaryOp>::value>
+struct nullary_wrapper
+{
+  template <typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i, IndexType j) const { return op(i,j); }
+  template <typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i) const { return op(i); }
+
+  template <typename T, typename IndexType> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexType j) const { return op.template packetOp<T>(i,j); }
+  template <typename T, typename IndexType> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i) const { return op.template packetOp<T>(i); }
+};
+
+template<typename Scalar,typename NullaryOp>
+struct nullary_wrapper<Scalar,NullaryOp,true,false,false>
+{
+  template <typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType=0, IndexType=0) const { return op(); }
+  template <typename T, typename IndexType> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType=0, IndexType=0) const { return op.template packetOp<T>(); }
+};
+
+template<typename Scalar,typename NullaryOp>
+struct nullary_wrapper<Scalar,NullaryOp,false,false,true>
+{
+  template <typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i, IndexType j=0) const { return op(i,j); }
+  template <typename T, typename IndexType> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexType j=0) const { return op.template packetOp<T>(i,j); }
+};
+
+// We need the following specialization for vector-only functors assigned to a runtime vector,
+// for instance, using linspace and assigning a RowVectorXd to a MatrixXd or even a row of a MatrixXd.
+// In this case, i==0 and j is used for the actual iteration.
+template<typename Scalar,typename NullaryOp>
+struct nullary_wrapper<Scalar,NullaryOp,false,true,false>
+{
+  template <typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i, IndexType j) const {
+    eigen_assert(i==0 || j==0);
+    return op(i+j);
+  }
+  template <typename T, typename IndexType> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexType j) const {
+    eigen_assert(i==0 || j==0);
+    return op.template packetOp<T>(i+j);
+  }
+
+  template <typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i) const { return op(i); }
+  template <typename T, typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i) const { return op.template packetOp<T>(i); }
+};
+
+template<typename Scalar,typename NullaryOp>
+struct nullary_wrapper<Scalar,NullaryOp,false,false,false> {};
+
+#if 0 && EIGEN_COMP_MSVC>0
+// Disable this ugly workaround. This is now handled in traits<Ref>::match,
+// but this piece of code might still become handly if some other weird compilation
+// erros pop up again.
+
+// MSVC exhibits a weird compilation error when
+// compiling:
+//    Eigen::MatrixXf A = MatrixXf::Random(3,3);
+//    Ref<const MatrixXf> R = 2.f*A;
+// and that has_*ary_operator<scalar_constant_op<float>> have not been instantiated yet.
+// The "problem" is that evaluator<2.f*A> is instantiated by traits<Ref>::match<2.f*A>
+// and at that time has_*ary_operator<T> returns true regardless of T.
+// Then nullary_wrapper is badly instantiated as nullary_wrapper<.,.,true,true,true>.
+// The trick is thus to defer the proper instantiation of nullary_wrapper when coeff(),
+// and packet() are really instantiated as implemented below:
+
+// This is a simple wrapper around Index to enforce the re-instantiation of
+// has_*ary_operator when needed.
+template<typename T> struct nullary_wrapper_workaround_msvc {
+  nullary_wrapper_workaround_msvc(const T&);
+  operator T()const;
+};
+
+template<typename Scalar,typename NullaryOp>
+struct nullary_wrapper<Scalar,NullaryOp,true,true,true>
+{
+  template <typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i, IndexType j) const {
+    return nullary_wrapper<Scalar,NullaryOp,
+    has_nullary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
+    has_unary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
+    has_binary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value>().operator()(op,i,j);
+  }
+  template <typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i) const {
+    return nullary_wrapper<Scalar,NullaryOp,
+    has_nullary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
+    has_unary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
+    has_binary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value>().operator()(op,i);
+  }
+
+  template <typename T, typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexType j) const {
+    return nullary_wrapper<Scalar,NullaryOp,
+    has_nullary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
+    has_unary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
+    has_binary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value>().template packetOp<T>(op,i,j);
+  }
+  template <typename T, typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i) const {
+    return nullary_wrapper<Scalar,NullaryOp,
+    has_nullary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
+    has_unary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
+    has_binary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value>().template packetOp<T>(op,i);
+  }
+};
+#endif // MSVC workaround
+
+template<typename NullaryOp, typename PlainObjectType>
+struct evaluator<CwiseNullaryOp<NullaryOp,PlainObjectType> >
+  : evaluator_base<CwiseNullaryOp<NullaryOp,PlainObjectType> >
+{
+  typedef CwiseNullaryOp<NullaryOp,PlainObjectType> XprType;
+  typedef typename internal::remove_all<PlainObjectType>::type PlainObjectTypeCleaned;
+  
+  enum {
+    CoeffReadCost = internal::functor_traits<NullaryOp>::Cost,
+    
+    Flags = (evaluator<PlainObjectTypeCleaned>::Flags
+          &  (  HereditaryBits
+              | (functor_has_linear_access<NullaryOp>::ret  ? LinearAccessBit : 0)
+              | (functor_traits<NullaryOp>::PacketAccess    ? PacketAccessBit : 0)))
+          | (functor_traits<NullaryOp>::IsRepeatable ? 0 : EvalBeforeNestingBit),
+    Alignment = AlignedMax
+  };
+
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType& n)
+    : m_functor(n.functor()), m_wrapper()
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  template <typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(IndexType row, IndexType col) const
+  {
+    return m_wrapper(m_functor, row, col);
+  }
+
+  template <typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(IndexType index) const
+  {
+    return m_wrapper(m_functor,index);
+  }
+
+  template<int LoadMode, typename PacketType, typename IndexType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(IndexType row, IndexType col) const
+  {
+    return m_wrapper.template packetOp<PacketType>(m_functor, row, col);
+  }
+
+  template<int LoadMode, typename PacketType, typename IndexType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(IndexType index) const
+  {
+    return m_wrapper.template packetOp<PacketType>(m_functor, index);
+  }
+
+protected:
+  const NullaryOp m_functor;
+  const internal::nullary_wrapper<CoeffReturnType,NullaryOp> m_wrapper;
+};
+
+// -------------------- CwiseUnaryOp --------------------
+
+template<typename UnaryOp, typename ArgType>
+struct unary_evaluator<CwiseUnaryOp<UnaryOp, ArgType>, IndexBased >
+  : evaluator_base<CwiseUnaryOp<UnaryOp, ArgType> >
+{
+  typedef CwiseUnaryOp<UnaryOp, ArgType> XprType;
+  
+  enum {
+    CoeffReadCost = evaluator<ArgType>::CoeffReadCost + functor_traits<UnaryOp>::Cost,
+    
+    Flags = evaluator<ArgType>::Flags
+          & (HereditaryBits | LinearAccessBit | (functor_traits<UnaryOp>::PacketAccess ? PacketAccessBit : 0)),
+    Alignment = evaluator<ArgType>::Alignment
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit unary_evaluator(const XprType& op) : m_d(op)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<UnaryOp>::Cost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    return m_d.func()(m_d.argImpl.coeff(row, col));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return m_d.func()(m_d.argImpl.coeff(index));
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index row, Index col) const
+  {
+    return m_d.func().packetOp(m_d.argImpl.template packet<LoadMode, PacketType>(row, col));
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index index) const
+  {
+    return m_d.func().packetOp(m_d.argImpl.template packet<LoadMode, PacketType>(index));
+  }
+
+protected:
+
+  // this helper permits to completely eliminate the functor if it is empty
+  class Data : private UnaryOp
+  {
+  public:
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Data(const XprType& xpr) : UnaryOp(xpr.functor()), argImpl(xpr.nestedExpression()) {}
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const UnaryOp& func() const { return static_cast<const UnaryOp&>(*this); }
+    evaluator<ArgType> argImpl;
+  };
+
+  Data m_d;
+};
+
+// -------------------- CwiseTernaryOp --------------------
+
+// this is a ternary expression
+template<typename TernaryOp, typename Arg1, typename Arg2, typename Arg3>
+struct evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> >
+  : public ternary_evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> >
+{
+  typedef CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> XprType;
+  typedef ternary_evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> > Base;
+  
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr) : Base(xpr) {}
+};
+
+template<typename TernaryOp, typename Arg1, typename Arg2, typename Arg3>
+struct ternary_evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3>, IndexBased, IndexBased>
+  : evaluator_base<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> >
+{
+  typedef CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> XprType;
+  
+  enum {
+    CoeffReadCost = evaluator<Arg1>::CoeffReadCost + evaluator<Arg2>::CoeffReadCost + evaluator<Arg3>::CoeffReadCost + functor_traits<TernaryOp>::Cost,
+    
+    Arg1Flags = evaluator<Arg1>::Flags,
+    Arg2Flags = evaluator<Arg2>::Flags,
+    Arg3Flags = evaluator<Arg3>::Flags,
+    SameType = is_same<typename Arg1::Scalar,typename Arg2::Scalar>::value && is_same<typename Arg1::Scalar,typename Arg3::Scalar>::value,
+    StorageOrdersAgree = (int(Arg1Flags)&RowMajorBit)==(int(Arg2Flags)&RowMajorBit) && (int(Arg1Flags)&RowMajorBit)==(int(Arg3Flags)&RowMajorBit),
+    Flags0 = (int(Arg1Flags) | int(Arg2Flags) | int(Arg3Flags)) & (
+        HereditaryBits
+        | (int(Arg1Flags) & int(Arg2Flags) & int(Arg3Flags) &
+           ( (StorageOrdersAgree ? LinearAccessBit : 0)
+           | (functor_traits<TernaryOp>::PacketAccess && StorageOrdersAgree && SameType ? PacketAccessBit : 0)
+           )
+        )
+     ),
+    Flags = (Flags0 & ~RowMajorBit) | (Arg1Flags & RowMajorBit),
+    Alignment = EIGEN_PLAIN_ENUM_MIN(
+        EIGEN_PLAIN_ENUM_MIN(evaluator<Arg1>::Alignment, evaluator<Arg2>::Alignment),
+        evaluator<Arg3>::Alignment)
+  };
+
+  EIGEN_DEVICE_FUNC explicit ternary_evaluator(const XprType& xpr) : m_d(xpr)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<TernaryOp>::Cost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    return m_d.func()(m_d.arg1Impl.coeff(row, col), m_d.arg2Impl.coeff(row, col), m_d.arg3Impl.coeff(row, col));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return m_d.func()(m_d.arg1Impl.coeff(index), m_d.arg2Impl.coeff(index), m_d.arg3Impl.coeff(index));
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index row, Index col) const
+  {
+    return m_d.func().packetOp(m_d.arg1Impl.template packet<LoadMode,PacketType>(row, col),
+                               m_d.arg2Impl.template packet<LoadMode,PacketType>(row, col),
+                               m_d.arg3Impl.template packet<LoadMode,PacketType>(row, col));
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index index) const
+  {
+    return m_d.func().packetOp(m_d.arg1Impl.template packet<LoadMode,PacketType>(index),
+                               m_d.arg2Impl.template packet<LoadMode,PacketType>(index),
+                               m_d.arg3Impl.template packet<LoadMode,PacketType>(index));
+  }
+
+protected:
+  // this helper permits to completely eliminate the functor if it is empty
+  struct Data : private TernaryOp
+  {
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Data(const XprType& xpr) : TernaryOp(xpr.functor()), arg1Impl(xpr.arg1()), arg2Impl(xpr.arg2()), arg3Impl(xpr.arg3()) {}
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TernaryOp& func() const { return static_cast<const TernaryOp&>(*this); }
+    evaluator<Arg1> arg1Impl;
+    evaluator<Arg2> arg2Impl;
+    evaluator<Arg3> arg3Impl;
+  };
+
+  Data m_d;
+};
+
+// -------------------- CwiseBinaryOp --------------------
+
+// this is a binary expression
+template<typename BinaryOp, typename Lhs, typename Rhs>
+struct evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
+  : public binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
+{
+  typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
+  typedef binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs> > Base;
+  
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr) : Base(xpr) {}
+};
+
+template<typename BinaryOp, typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>, IndexBased, IndexBased>
+  : evaluator_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
+{
+  typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
+  
+  enum {
+    CoeffReadCost = evaluator<Lhs>::CoeffReadCost + evaluator<Rhs>::CoeffReadCost + functor_traits<BinaryOp>::Cost,
+    
+    LhsFlags = evaluator<Lhs>::Flags,
+    RhsFlags = evaluator<Rhs>::Flags,
+    SameType = is_same<typename Lhs::Scalar,typename Rhs::Scalar>::value,
+    StorageOrdersAgree = (int(LhsFlags)&RowMajorBit)==(int(RhsFlags)&RowMajorBit),
+    Flags0 = (int(LhsFlags) | int(RhsFlags)) & (
+        HereditaryBits
+      | (int(LhsFlags) & int(RhsFlags) &
+           ( (StorageOrdersAgree ? LinearAccessBit : 0)
+           | (functor_traits<BinaryOp>::PacketAccess && StorageOrdersAgree && SameType ? PacketAccessBit : 0)
+           )
+        )
+     ),
+    Flags = (Flags0 & ~RowMajorBit) | (LhsFlags & RowMajorBit),
+    Alignment = EIGEN_PLAIN_ENUM_MIN(evaluator<Lhs>::Alignment,evaluator<Rhs>::Alignment)
+  };
+
+  EIGEN_DEVICE_FUNC explicit binary_evaluator(const XprType& xpr) : m_d(xpr)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<BinaryOp>::Cost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    return m_d.func()(m_d.lhsImpl.coeff(row, col), m_d.rhsImpl.coeff(row, col));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return m_d.func()(m_d.lhsImpl.coeff(index), m_d.rhsImpl.coeff(index));
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index row, Index col) const
+  {
+    return m_d.func().packetOp(m_d.lhsImpl.template packet<LoadMode,PacketType>(row, col),
+                               m_d.rhsImpl.template packet<LoadMode,PacketType>(row, col));
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index index) const
+  {
+    return m_d.func().packetOp(m_d.lhsImpl.template packet<LoadMode,PacketType>(index),
+                               m_d.rhsImpl.template packet<LoadMode,PacketType>(index));
+  }
+
+protected:
+
+  // this helper permits to completely eliminate the functor if it is empty
+  struct Data : private BinaryOp
+  {
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Data(const XprType& xpr) : BinaryOp(xpr.functor()), lhsImpl(xpr.lhs()), rhsImpl(xpr.rhs()) {}
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const BinaryOp& func() const { return static_cast<const BinaryOp&>(*this); }
+    evaluator<Lhs> lhsImpl;
+    evaluator<Rhs> rhsImpl;
+  };
+
+  Data m_d;
+};
+
+// -------------------- CwiseUnaryView --------------------
+
+template<typename UnaryOp, typename ArgType>
+struct unary_evaluator<CwiseUnaryView<UnaryOp, ArgType>, IndexBased>
+  : evaluator_base<CwiseUnaryView<UnaryOp, ArgType> >
+{
+  typedef CwiseUnaryView<UnaryOp, ArgType> XprType;
+  
+  enum {
+    CoeffReadCost = evaluator<ArgType>::CoeffReadCost + functor_traits<UnaryOp>::Cost,
+    
+    Flags = (evaluator<ArgType>::Flags & (HereditaryBits | LinearAccessBit | DirectAccessBit)),
+    
+    Alignment = 0 // FIXME it is not very clear why alignment is necessarily lost...
+  };
+
+  EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& op) : m_d(op)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<UnaryOp>::Cost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    return m_d.func()(m_d.argImpl.coeff(row, col));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return m_d.func()(m_d.argImpl.coeff(index));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index row, Index col)
+  {
+    return m_d.func()(m_d.argImpl.coeffRef(row, col));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index index)
+  {
+    return m_d.func()(m_d.argImpl.coeffRef(index));
+  }
+
+protected:
+
+  // this helper permits to completely eliminate the functor if it is empty
+  struct Data : private UnaryOp
+  {
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Data(const XprType& xpr) : UnaryOp(xpr.functor()), argImpl(xpr.nestedExpression()) {}
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const UnaryOp& func() const { return static_cast<const UnaryOp&>(*this); }
+    evaluator<ArgType> argImpl;
+  };
+
+  Data m_d;
+};
+
+// -------------------- Map --------------------
+
+// FIXME perhaps the PlainObjectType could be provided by Derived::PlainObject ?
+// but that might complicate template specialization
+template<typename Derived, typename PlainObjectType>
+struct mapbase_evaluator;
+
+template<typename Derived, typename PlainObjectType>
+struct mapbase_evaluator : evaluator_base<Derived>
+{
+  typedef Derived  XprType;
+  typedef typename XprType::PointerType PointerType;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  
+  enum {
+    IsRowMajor = XprType::RowsAtCompileTime,
+    ColsAtCompileTime = XprType::ColsAtCompileTime,
+    CoeffReadCost = NumTraits<Scalar>::ReadCost
+  };
+
+  EIGEN_DEVICE_FUNC explicit mapbase_evaluator(const XprType& map)
+    : m_data(const_cast<PointerType>(map.data())),
+      m_innerStride(map.innerStride()),
+      m_outerStride(map.outerStride())
+  {
+    EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(evaluator<Derived>::Flags&PacketAccessBit, internal::inner_stride_at_compile_time<Derived>::ret==1),
+                        PACKET_ACCESS_REQUIRES_TO_HAVE_INNER_STRIDE_FIXED_TO_1);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    return m_data[col * colStride() + row * rowStride()];
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return m_data[index * m_innerStride.value()];
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index row, Index col)
+  {
+    return m_data[col * colStride() + row * rowStride()];
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index index)
+  {
+    return m_data[index * m_innerStride.value()];
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index row, Index col) const
+  {
+    PointerType ptr = m_data + row * rowStride() + col * colStride();
+    return internal::ploadt<PacketType, LoadMode>(ptr);
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index index) const
+  {
+    return internal::ploadt<PacketType, LoadMode>(m_data + index * m_innerStride.value());
+  }
+
+  template<int StoreMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index row, Index col, const PacketType& x)
+  {
+    PointerType ptr = m_data + row * rowStride() + col * colStride();
+    return internal::pstoret<Scalar, PacketType, StoreMode>(ptr, x);
+  }
+
+  template<int StoreMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index index, const PacketType& x)
+  {
+    internal::pstoret<Scalar, PacketType, StoreMode>(m_data + index * m_innerStride.value(), x);
+  }
+protected:
+  EIGEN_DEVICE_FUNC
+  inline Index rowStride() const { return XprType::IsRowMajor ? m_outerStride.value() : m_innerStride.value(); }
+  EIGEN_DEVICE_FUNC
+  inline Index colStride() const { return XprType::IsRowMajor ? m_innerStride.value() : m_outerStride.value(); }
+
+  PointerType m_data;
+  const internal::variable_if_dynamic<Index, XprType::InnerStrideAtCompileTime> m_innerStride;
+  const internal::variable_if_dynamic<Index, XprType::OuterStrideAtCompileTime> m_outerStride;
+};
+
+template<typename PlainObjectType, int MapOptions, typename StrideType> 
+struct evaluator<Map<PlainObjectType, MapOptions, StrideType> >
+  : public mapbase_evaluator<Map<PlainObjectType, MapOptions, StrideType>, PlainObjectType>
+{
+  typedef Map<PlainObjectType, MapOptions, StrideType> XprType;
+  typedef typename XprType::Scalar Scalar;
+  // TODO: should check for smaller packet types once we can handle multi-sized packet types
+  typedef typename packet_traits<Scalar>::type PacketScalar;
+  
+  enum {
+    InnerStrideAtCompileTime = StrideType::InnerStrideAtCompileTime == 0
+                             ? int(PlainObjectType::InnerStrideAtCompileTime)
+                             : int(StrideType::InnerStrideAtCompileTime),
+    OuterStrideAtCompileTime = StrideType::OuterStrideAtCompileTime == 0
+                             ? int(PlainObjectType::OuterStrideAtCompileTime)
+                             : int(StrideType::OuterStrideAtCompileTime),
+    HasNoInnerStride = InnerStrideAtCompileTime == 1,
+    HasNoOuterStride = StrideType::OuterStrideAtCompileTime == 0,
+    HasNoStride = HasNoInnerStride && HasNoOuterStride,
+    IsDynamicSize = PlainObjectType::SizeAtCompileTime==Dynamic,
+    
+    PacketAccessMask = bool(HasNoInnerStride) ? ~int(0) : ~int(PacketAccessBit),
+    LinearAccessMask = bool(HasNoStride) || bool(PlainObjectType::IsVectorAtCompileTime) ? ~int(0) : ~int(LinearAccessBit),
+    Flags = int( evaluator<PlainObjectType>::Flags) & (LinearAccessMask&PacketAccessMask),
+    
+    Alignment = int(MapOptions)&int(AlignedMask)
+  };
+
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType& map)
+    : mapbase_evaluator<XprType, PlainObjectType>(map) 
+  { }
+};
+
+// -------------------- Ref --------------------
+
+template<typename PlainObjectType, int RefOptions, typename StrideType> 
+struct evaluator<Ref<PlainObjectType, RefOptions, StrideType> >
+  : public mapbase_evaluator<Ref<PlainObjectType, RefOptions, StrideType>, PlainObjectType>
+{
+  typedef Ref<PlainObjectType, RefOptions, StrideType> XprType;
+  
+  enum {
+    Flags = evaluator<Map<PlainObjectType, RefOptions, StrideType> >::Flags,
+    Alignment = evaluator<Map<PlainObjectType, RefOptions, StrideType> >::Alignment
+  };
+
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType& ref)
+    : mapbase_evaluator<XprType, PlainObjectType>(ref) 
+  { }
+};
+
+// -------------------- Block --------------------
+
+template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel,
+         bool HasDirectAccess = internal::has_direct_access<ArgType>::ret> struct block_evaluator;
+         
+template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel> 
+struct evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel> >
+  : block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel>
+{
+  typedef Block<ArgType, BlockRows, BlockCols, InnerPanel> XprType;
+  typedef typename XprType::Scalar Scalar;
+  // TODO: should check for smaller packet types once we can handle multi-sized packet types
+  typedef typename packet_traits<Scalar>::type PacketScalar;
+  
+  enum {
+    CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+    
+    RowsAtCompileTime = traits<XprType>::RowsAtCompileTime,
+    ColsAtCompileTime = traits<XprType>::ColsAtCompileTime,
+    MaxRowsAtCompileTime = traits<XprType>::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = traits<XprType>::MaxColsAtCompileTime,
+    
+    ArgTypeIsRowMajor = (int(evaluator<ArgType>::Flags)&RowMajorBit) != 0,
+    IsRowMajor = (MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1) ? 1
+               : (MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1) ? 0
+               : ArgTypeIsRowMajor,
+    HasSameStorageOrderAsArgType = (IsRowMajor == ArgTypeIsRowMajor),
+    InnerSize = IsRowMajor ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
+    InnerStrideAtCompileTime = HasSameStorageOrderAsArgType
+                             ? int(inner_stride_at_compile_time<ArgType>::ret)
+                             : int(outer_stride_at_compile_time<ArgType>::ret),
+    OuterStrideAtCompileTime = HasSameStorageOrderAsArgType
+                             ? int(outer_stride_at_compile_time<ArgType>::ret)
+                             : int(inner_stride_at_compile_time<ArgType>::ret),
+    MaskPacketAccessBit = (InnerStrideAtCompileTime == 1) ? PacketAccessBit : 0,
+    
+    FlagsLinearAccessBit = (RowsAtCompileTime == 1 || ColsAtCompileTime == 1 || (InnerPanel && (evaluator<ArgType>::Flags&LinearAccessBit))) ? LinearAccessBit : 0,    
+    FlagsRowMajorBit = XprType::Flags&RowMajorBit,
+    Flags0 = evaluator<ArgType>::Flags & ( (HereditaryBits & ~RowMajorBit) |
+                                           DirectAccessBit |
+                                           MaskPacketAccessBit),
+    Flags = Flags0 | FlagsLinearAccessBit | FlagsRowMajorBit,
+    
+    PacketAlignment = unpacket_traits<PacketScalar>::alignment,
+    Alignment0 = (InnerPanel && (OuterStrideAtCompileTime!=Dynamic) && (((OuterStrideAtCompileTime * int(sizeof(Scalar))) % int(PacketAlignment)) == 0)) ? int(PacketAlignment) : 0,
+    Alignment = EIGEN_PLAIN_ENUM_MIN(evaluator<ArgType>::Alignment, Alignment0)
+  };
+  typedef block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel> block_evaluator_type;
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType& block) : block_evaluator_type(block)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+};
+
+// no direct-access => dispatch to a unary evaluator
+template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
+struct block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel, /*HasDirectAccess*/ false>
+  : unary_evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel> >
+{
+  typedef Block<ArgType, BlockRows, BlockCols, InnerPanel> XprType;
+
+  EIGEN_DEVICE_FUNC explicit block_evaluator(const XprType& block)
+    : unary_evaluator<XprType>(block) 
+  {}
+};
+
+template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
+struct unary_evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel>, IndexBased>
+  : evaluator_base<Block<ArgType, BlockRows, BlockCols, InnerPanel> >
+{
+  typedef Block<ArgType, BlockRows, BlockCols, InnerPanel> XprType;
+
+  EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& block)
+    : m_argImpl(block.nestedExpression()), 
+      m_startRow(block.startRow()), 
+      m_startCol(block.startCol()) 
+  { }
+ 
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  enum {
+    RowsAtCompileTime = XprType::RowsAtCompileTime
+  };
+ 
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  { 
+    return m_argImpl.coeff(m_startRow.value() + row, m_startCol.value() + col); 
+  }
+  
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  { 
+    return coeff(RowsAtCompileTime == 1 ? 0 : index, RowsAtCompileTime == 1 ? index : 0);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index row, Index col)
+  { 
+    return m_argImpl.coeffRef(m_startRow.value() + row, m_startCol.value() + col); 
+  }
+  
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index index)
+  { 
+    return coeffRef(RowsAtCompileTime == 1 ? 0 : index, RowsAtCompileTime == 1 ? index : 0);
+  }
+ 
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index row, Index col) const 
+  { 
+    return m_argImpl.template packet<LoadMode,PacketType>(m_startRow.value() + row, m_startCol.value() + col); 
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index index) const 
+  { 
+    return packet<LoadMode,PacketType>(RowsAtCompileTime == 1 ? 0 : index,
+                                       RowsAtCompileTime == 1 ? index : 0);
+  }
+  
+  template<int StoreMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index row, Index col, const PacketType& x) 
+  {
+    return m_argImpl.template writePacket<StoreMode,PacketType>(m_startRow.value() + row, m_startCol.value() + col, x); 
+  }
+  
+  template<int StoreMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index index, const PacketType& x) 
+  {
+    return writePacket<StoreMode,PacketType>(RowsAtCompileTime == 1 ? 0 : index,
+                                             RowsAtCompileTime == 1 ? index : 0,
+                                             x);
+  }
+ 
+protected:
+  evaluator<ArgType> m_argImpl;
+  const variable_if_dynamic<Index, (ArgType::RowsAtCompileTime == 1 && BlockRows==1) ? 0 : Dynamic> m_startRow;
+  const variable_if_dynamic<Index, (ArgType::ColsAtCompileTime == 1 && BlockCols==1) ? 0 : Dynamic> m_startCol;
+};
+
+// TODO: This evaluator does not actually use the child evaluator; 
+// all action is via the data() as returned by the Block expression.
+
+template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel> 
+struct block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel, /* HasDirectAccess */ true>
+  : mapbase_evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel>,
+                      typename Block<ArgType, BlockRows, BlockCols, InnerPanel>::PlainObject>
+{
+  typedef Block<ArgType, BlockRows, BlockCols, InnerPanel> XprType;
+  typedef typename XprType::Scalar Scalar;
+
+  EIGEN_DEVICE_FUNC explicit block_evaluator(const XprType& block)
+    : mapbase_evaluator<XprType, typename XprType::PlainObject>(block) 
+  {
+    // TODO: for the 3.3 release, this should be turned to an internal assertion, but let's keep it as is for the beta lifetime
+    eigen_assert(((internal::UIntPtr(block.data()) % EIGEN_PLAIN_ENUM_MAX(1,evaluator<XprType>::Alignment)) == 0) && "data is not aligned");
+  }
+};
+
+
+// -------------------- Select --------------------
+// NOTE shall we introduce a ternary_evaluator?
+
+// TODO enable vectorization for Select
+template<typename ConditionMatrixType, typename ThenMatrixType, typename ElseMatrixType>
+struct evaluator<Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> >
+  : evaluator_base<Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> >
+{
+  typedef Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> XprType;
+  enum {
+    CoeffReadCost = evaluator<ConditionMatrixType>::CoeffReadCost
+                  + EIGEN_PLAIN_ENUM_MAX(evaluator<ThenMatrixType>::CoeffReadCost,
+                                         evaluator<ElseMatrixType>::CoeffReadCost),
+
+    Flags = (unsigned int)evaluator<ThenMatrixType>::Flags & evaluator<ElseMatrixType>::Flags & HereditaryBits,
+    
+    Alignment = EIGEN_PLAIN_ENUM_MIN(evaluator<ThenMatrixType>::Alignment, evaluator<ElseMatrixType>::Alignment)
+  };
+
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType& select)
+    : m_conditionImpl(select.conditionMatrix()),
+      m_thenImpl(select.thenMatrix()),
+      m_elseImpl(select.elseMatrix())
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+ 
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    if (m_conditionImpl.coeff(row, col))
+      return m_thenImpl.coeff(row, col);
+    else
+      return m_elseImpl.coeff(row, col);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    if (m_conditionImpl.coeff(index))
+      return m_thenImpl.coeff(index);
+    else
+      return m_elseImpl.coeff(index);
+  }
+ 
+protected:
+  evaluator<ConditionMatrixType> m_conditionImpl;
+  evaluator<ThenMatrixType> m_thenImpl;
+  evaluator<ElseMatrixType> m_elseImpl;
+};
+
+
+// -------------------- Replicate --------------------
+
+template<typename ArgType, int RowFactor, int ColFactor> 
+struct unary_evaluator<Replicate<ArgType, RowFactor, ColFactor> >
+  : evaluator_base<Replicate<ArgType, RowFactor, ColFactor> >
+{
+  typedef Replicate<ArgType, RowFactor, ColFactor> XprType;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  enum {
+    Factor = (RowFactor==Dynamic || ColFactor==Dynamic) ? Dynamic : RowFactor*ColFactor
+  };
+  typedef typename internal::nested_eval<ArgType,Factor>::type ArgTypeNested;
+  typedef typename internal::remove_all<ArgTypeNested>::type ArgTypeNestedCleaned;
+  
+  enum {
+    CoeffReadCost = evaluator<ArgTypeNestedCleaned>::CoeffReadCost,
+    LinearAccessMask = XprType::IsVectorAtCompileTime ? LinearAccessBit : 0,
+    Flags = (evaluator<ArgTypeNestedCleaned>::Flags & (HereditaryBits|LinearAccessMask) & ~RowMajorBit) | (traits<XprType>::Flags & RowMajorBit),
+    
+    Alignment = evaluator<ArgTypeNestedCleaned>::Alignment
+  };
+
+  EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& replicate)
+    : m_arg(replicate.nestedExpression()),
+      m_argImpl(m_arg),
+      m_rows(replicate.nestedExpression().rows()),
+      m_cols(replicate.nestedExpression().cols())
+  {}
+ 
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    // try to avoid using modulo; this is a pure optimization strategy
+    const Index actual_row = internal::traits<XprType>::RowsAtCompileTime==1 ? 0
+                           : RowFactor==1 ? row
+                           : row % m_rows.value();
+    const Index actual_col = internal::traits<XprType>::ColsAtCompileTime==1 ? 0
+                           : ColFactor==1 ? col
+                           : col % m_cols.value();
+    
+    return m_argImpl.coeff(actual_row, actual_col);
+  }
+  
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    // try to avoid using modulo; this is a pure optimization strategy
+    const Index actual_index = internal::traits<XprType>::RowsAtCompileTime==1
+                                  ? (ColFactor==1 ?  index : index%m_cols.value())
+                                  : (RowFactor==1 ?  index : index%m_rows.value());
+    
+    return m_argImpl.coeff(actual_index);
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index row, Index col) const
+  {
+    const Index actual_row = internal::traits<XprType>::RowsAtCompileTime==1 ? 0
+                           : RowFactor==1 ? row
+                           : row % m_rows.value();
+    const Index actual_col = internal::traits<XprType>::ColsAtCompileTime==1 ? 0
+                           : ColFactor==1 ? col
+                           : col % m_cols.value();
+
+    return m_argImpl.template packet<LoadMode,PacketType>(actual_row, actual_col);
+  }
+  
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index index) const
+  {
+    const Index actual_index = internal::traits<XprType>::RowsAtCompileTime==1
+                                  ? (ColFactor==1 ?  index : index%m_cols.value())
+                                  : (RowFactor==1 ?  index : index%m_rows.value());
+
+    return m_argImpl.template packet<LoadMode,PacketType>(actual_index);
+  }
+ 
+protected:
+  const ArgTypeNested m_arg;
+  evaluator<ArgTypeNestedCleaned> m_argImpl;
+  const variable_if_dynamic<Index, ArgType::RowsAtCompileTime> m_rows;
+  const variable_if_dynamic<Index, ArgType::ColsAtCompileTime> m_cols;
+};
+
+
+// -------------------- PartialReduxExpr --------------------
+
+template< typename ArgType, typename MemberOp, int Direction>
+struct evaluator<PartialReduxExpr<ArgType, MemberOp, Direction> >
+  : evaluator_base<PartialReduxExpr<ArgType, MemberOp, Direction> >
+{
+  typedef PartialReduxExpr<ArgType, MemberOp, Direction> XprType;
+  typedef typename internal::nested_eval<ArgType,1>::type ArgTypeNested;
+  typedef typename internal::remove_all<ArgTypeNested>::type ArgTypeNestedCleaned;
+  typedef typename ArgType::Scalar InputScalar;
+  typedef typename XprType::Scalar Scalar;
+  enum {
+    TraversalSize = Direction==int(Vertical) ? int(ArgType::RowsAtCompileTime) :  int(ArgType::ColsAtCompileTime)
+  };
+  typedef typename MemberOp::template Cost<InputScalar,int(TraversalSize)> CostOpType;
+  enum {
+    CoeffReadCost = TraversalSize==Dynamic ? HugeCost
+                  : TraversalSize * evaluator<ArgType>::CoeffReadCost + int(CostOpType::value),
+    
+    Flags = (traits<XprType>::Flags&RowMajorBit) | (evaluator<ArgType>::Flags&(HereditaryBits&(~RowMajorBit))) | LinearAccessBit,
+    
+    Alignment = 0 // FIXME this will need to be improved once PartialReduxExpr is vectorized
+  };
+
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType xpr)
+    : m_arg(xpr.nestedExpression()), m_functor(xpr.functor())
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(TraversalSize==Dynamic ? HugeCost : int(CostOpType::value));
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  const Scalar coeff(Index i, Index j) const
+  {
+    if (Direction==Vertical)
+      return m_functor(m_arg.col(j));
+    else
+      return m_functor(m_arg.row(i));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  const Scalar coeff(Index index) const
+  {
+    if (Direction==Vertical)
+      return m_functor(m_arg.col(index));
+    else
+      return m_functor(m_arg.row(index));
+  }
+
+protected:
+  typename internal::add_const_on_value_type<ArgTypeNested>::type m_arg;
+  const MemberOp m_functor;
+};
+
+
+// -------------------- MatrixWrapper and ArrayWrapper --------------------
+//
+// evaluator_wrapper_base<T> is a common base class for the
+// MatrixWrapper and ArrayWrapper evaluators.
+
+template<typename XprType>
+struct evaluator_wrapper_base
+  : evaluator_base<XprType>
+{
+  typedef typename remove_all<typename XprType::NestedExpressionType>::type ArgType;
+  enum {
+    CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+    Flags = evaluator<ArgType>::Flags,
+    Alignment = evaluator<ArgType>::Alignment
+  };
+
+  EIGEN_DEVICE_FUNC explicit evaluator_wrapper_base(const ArgType& arg) : m_argImpl(arg) {}
+
+  typedef typename ArgType::Scalar Scalar;
+  typedef typename ArgType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    return m_argImpl.coeff(row, col);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return m_argImpl.coeff(index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index row, Index col)
+  {
+    return m_argImpl.coeffRef(row, col);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index index)
+  {
+    return m_argImpl.coeffRef(index);
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index row, Index col) const
+  {
+    return m_argImpl.template packet<LoadMode,PacketType>(row, col);
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index index) const
+  {
+    return m_argImpl.template packet<LoadMode,PacketType>(index);
+  }
+
+  template<int StoreMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index row, Index col, const PacketType& x)
+  {
+    m_argImpl.template writePacket<StoreMode>(row, col, x);
+  }
+
+  template<int StoreMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index index, const PacketType& x)
+  {
+    m_argImpl.template writePacket<StoreMode>(index, x);
+  }
+
+protected:
+  evaluator<ArgType> m_argImpl;
+};
+
+template<typename TArgType>
+struct unary_evaluator<MatrixWrapper<TArgType> >
+  : evaluator_wrapper_base<MatrixWrapper<TArgType> >
+{
+  typedef MatrixWrapper<TArgType> XprType;
+
+  EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& wrapper)
+    : evaluator_wrapper_base<MatrixWrapper<TArgType> >(wrapper.nestedExpression())
+  { }
+};
+
+template<typename TArgType>
+struct unary_evaluator<ArrayWrapper<TArgType> >
+  : evaluator_wrapper_base<ArrayWrapper<TArgType> >
+{
+  typedef ArrayWrapper<TArgType> XprType;
+
+  EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& wrapper)
+    : evaluator_wrapper_base<ArrayWrapper<TArgType> >(wrapper.nestedExpression())
+  { }
+};
+
+
+// -------------------- Reverse --------------------
+
+// defined in Reverse.h:
+template<typename PacketType, bool ReversePacket> struct reverse_packet_cond;
+
+template<typename ArgType, int Direction>
+struct unary_evaluator<Reverse<ArgType, Direction> >
+  : evaluator_base<Reverse<ArgType, Direction> >
+{
+  typedef Reverse<ArgType, Direction> XprType;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  enum {
+    IsRowMajor = XprType::IsRowMajor,
+    IsColMajor = !IsRowMajor,
+    ReverseRow = (Direction == Vertical)   || (Direction == BothDirections),
+    ReverseCol = (Direction == Horizontal) || (Direction == BothDirections),
+    ReversePacket = (Direction == BothDirections)
+                    || ((Direction == Vertical)   && IsColMajor)
+                    || ((Direction == Horizontal) && IsRowMajor),
+                    
+    CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+    
+    // let's enable LinearAccess only with vectorization because of the product overhead
+    // FIXME enable DirectAccess with negative strides?
+    Flags0 = evaluator<ArgType>::Flags,
+    LinearAccess = ( (Direction==BothDirections) && (int(Flags0)&PacketAccessBit) )
+                  || ((ReverseRow && XprType::ColsAtCompileTime==1) || (ReverseCol && XprType::RowsAtCompileTime==1))
+                 ? LinearAccessBit : 0,
+
+    Flags = int(Flags0) & (HereditaryBits | PacketAccessBit | LinearAccess),
+    
+    Alignment = 0 // FIXME in some rare cases, Alignment could be preserved, like a Vector4f.
+  };
+
+  EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& reverse)
+    : m_argImpl(reverse.nestedExpression()),
+      m_rows(ReverseRow ? reverse.nestedExpression().rows() : 1),
+      m_cols(ReverseCol ? reverse.nestedExpression().cols() : 1)
+  { }
+ 
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    return m_argImpl.coeff(ReverseRow ? m_rows.value() - row - 1 : row,
+                           ReverseCol ? m_cols.value() - col - 1 : col);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return m_argImpl.coeff(m_rows.value() * m_cols.value() - index - 1);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index row, Index col)
+  {
+    return m_argImpl.coeffRef(ReverseRow ? m_rows.value() - row - 1 : row,
+                              ReverseCol ? m_cols.value() - col - 1 : col);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index index)
+  {
+    return m_argImpl.coeffRef(m_rows.value() * m_cols.value() - index - 1);
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index row, Index col) const
+  {
+    enum {
+      PacketSize = unpacket_traits<PacketType>::size,
+      OffsetRow  = ReverseRow && IsColMajor ? PacketSize : 1,
+      OffsetCol  = ReverseCol && IsRowMajor ? PacketSize : 1
+    };
+    typedef internal::reverse_packet_cond<PacketType,ReversePacket> reverse_packet;
+    return reverse_packet::run(m_argImpl.template packet<LoadMode,PacketType>(
+                                  ReverseRow ? m_rows.value() - row - OffsetRow : row,
+                                  ReverseCol ? m_cols.value() - col - OffsetCol : col));
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index index) const
+  {
+    enum { PacketSize = unpacket_traits<PacketType>::size };
+    return preverse(m_argImpl.template packet<LoadMode,PacketType>(m_rows.value() * m_cols.value() - index - PacketSize));
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index row, Index col, const PacketType& x)
+  {
+    // FIXME we could factorize some code with packet(i,j)
+    enum {
+      PacketSize = unpacket_traits<PacketType>::size,
+      OffsetRow  = ReverseRow && IsColMajor ? PacketSize : 1,
+      OffsetCol  = ReverseCol && IsRowMajor ? PacketSize : 1
+    };
+    typedef internal::reverse_packet_cond<PacketType,ReversePacket> reverse_packet;
+    m_argImpl.template writePacket<LoadMode>(
+                                  ReverseRow ? m_rows.value() - row - OffsetRow : row,
+                                  ReverseCol ? m_cols.value() - col - OffsetCol : col,
+                                  reverse_packet::run(x));
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index index, const PacketType& x)
+  {
+    enum { PacketSize = unpacket_traits<PacketType>::size };
+    m_argImpl.template writePacket<LoadMode>
+      (m_rows.value() * m_cols.value() - index - PacketSize, preverse(x));
+  }
+ 
+protected:
+  evaluator<ArgType> m_argImpl;
+
+  // If we do not reverse rows, then we do not need to know the number of rows; same for columns
+  // Nonetheless, in this case it is important to set to 1 such that the coeff(index) method works fine for vectors.
+  const variable_if_dynamic<Index, ReverseRow ? ArgType::RowsAtCompileTime : 1> m_rows;
+  const variable_if_dynamic<Index, ReverseCol ? ArgType::ColsAtCompileTime : 1> m_cols;
+};
+
+
+// -------------------- Diagonal --------------------
+
+template<typename ArgType, int DiagIndex>
+struct evaluator<Diagonal<ArgType, DiagIndex> >
+  : evaluator_base<Diagonal<ArgType, DiagIndex> >
+{
+  typedef Diagonal<ArgType, DiagIndex> XprType;
+  
+  enum {
+    CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+    
+    Flags = (unsigned int)(evaluator<ArgType>::Flags & (HereditaryBits | DirectAccessBit) & ~RowMajorBit) | LinearAccessBit,
+    
+    Alignment = 0
+  };
+
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType& diagonal)
+    : m_argImpl(diagonal.nestedExpression()),
+      m_index(diagonal.index())
+  { }
+ 
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index) const
+  {
+    return m_argImpl.coeff(row + rowOffset(), row + colOffset());
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return m_argImpl.coeff(index + rowOffset(), index + colOffset());
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index row, Index)
+  {
+    return m_argImpl.coeffRef(row + rowOffset(), row + colOffset());
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index index)
+  {
+    return m_argImpl.coeffRef(index + rowOffset(), index + colOffset());
+  }
+
+protected:
+  evaluator<ArgType> m_argImpl;
+  const internal::variable_if_dynamicindex<Index, XprType::DiagIndex> m_index;
+
+private:
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rowOffset() const { return m_index.value() > 0 ? 0 : -m_index.value(); }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index colOffset() const { return m_index.value() > 0 ? m_index.value() : 0; }
+};
+
+
+//----------------------------------------------------------------------
+// deprecated code
+//----------------------------------------------------------------------
+
+// -------------------- EvalToTemp --------------------
+
+// expression class for evaluating nested expression to a temporary
+
+template<typename ArgType> class EvalToTemp;
+
+template<typename ArgType>
+struct traits<EvalToTemp<ArgType> >
+  : public traits<ArgType>
+{ };
+
+template<typename ArgType>
+class EvalToTemp
+  : public dense_xpr_base<EvalToTemp<ArgType> >::type
+{
+ public:
+ 
+  typedef typename dense_xpr_base<EvalToTemp>::type Base;
+  EIGEN_GENERIC_PUBLIC_INTERFACE(EvalToTemp)
+ 
+  explicit EvalToTemp(const ArgType& arg)
+    : m_arg(arg)
+  { }
+ 
+  const ArgType& arg() const
+  {
+    return m_arg;
+  }
+
+  Index rows() const 
+  {
+    return m_arg.rows();
+  }
+
+  Index cols() const 
+  {
+    return m_arg.cols();
+  }
+
+ private:
+  const ArgType& m_arg;
+};
+ 
+template<typename ArgType>
+struct evaluator<EvalToTemp<ArgType> >
+  : public evaluator<typename ArgType::PlainObject>
+{
+  typedef EvalToTemp<ArgType>                   XprType;
+  typedef typename ArgType::PlainObject         PlainObject;
+  typedef evaluator<PlainObject> Base;
+  
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr)
+    : m_result(xpr.arg())
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+  }
+
+  // This constructor is used when nesting an EvalTo evaluator in another evaluator
+  EIGEN_DEVICE_FUNC evaluator(const ArgType& arg)
+    : m_result(arg)
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+  }
+
+protected:
+  PlainObject m_result;
+};
+
+} // namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_COREEVALUATORS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/CoreIterators.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/CoreIterators.h
new file mode 100644
index 00000000..b9671968
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/CoreIterators.h
@@ -0,0 +1,132 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COREITERATORS_H
+#define EIGEN_COREITERATORS_H
+
+namespace Eigen { 
+
+/* This file contains the respective InnerIterator definition of the expressions defined in Eigen/Core
+ */
+
+namespace internal {
+
+template<typename XprType, typename EvaluatorKind>
+class inner_iterator_selector;
+
+}
+
+/** \class InnerIterator
+  * \brief An InnerIterator allows to loop over the element of any matrix expression.
+  * 
+  * \warning To be used with care because an evaluator is constructed every time an InnerIterator iterator is constructed.
+  * 
+  * TODO: add a usage example
+  */
+template<typename XprType>
+class InnerIterator
+{
+protected:
+  typedef internal::inner_iterator_selector<XprType, typename internal::evaluator_traits<XprType>::Kind> IteratorType;
+  typedef internal::evaluator<XprType> EvaluatorType;
+  typedef typename internal::traits<XprType>::Scalar Scalar;
+public:
+  /** Construct an iterator over the \a outerId -th row or column of \a xpr */
+  InnerIterator(const XprType &xpr, const Index &outerId)
+    : m_eval(xpr), m_iter(m_eval, outerId, xpr.innerSize())
+  {}
+  
+  /// \returns the value of the current coefficient.
+  EIGEN_STRONG_INLINE Scalar value() const          { return m_iter.value(); }
+  /** Increment the iterator \c *this to the next non-zero coefficient.
+    * Explicit zeros are not skipped over. To skip explicit zeros, see class SparseView
+    */
+  EIGEN_STRONG_INLINE InnerIterator& operator++()   { m_iter.operator++(); return *this; }
+  EIGEN_STRONG_INLINE InnerIterator& operator+=(Index i) { m_iter.operator+=(i); return *this; }
+  EIGEN_STRONG_INLINE InnerIterator operator+(Index i) 
+  { InnerIterator result(*this); result+=i; return result; }
+    
+
+  /// \returns the column or row index of the current coefficient.
+  EIGEN_STRONG_INLINE Index index() const           { return m_iter.index(); }
+  /// \returns the row index of the current coefficient.
+  EIGEN_STRONG_INLINE Index row() const             { return m_iter.row(); }
+  /// \returns the column index of the current coefficient.
+  EIGEN_STRONG_INLINE Index col() const             { return m_iter.col(); }
+  /// \returns \c true if the iterator \c *this still references a valid coefficient.
+  EIGEN_STRONG_INLINE operator bool() const         { return m_iter; }
+  
+protected:
+  EvaluatorType m_eval;
+  IteratorType m_iter;
+private:
+  // If you get here, then you're not using the right InnerIterator type, e.g.:
+  //   SparseMatrix<double,RowMajor> A;
+  //   SparseMatrix<double>::InnerIterator it(A,0);
+  template<typename T> InnerIterator(const EigenBase<T>&,Index outer);
+};
+
+namespace internal {
+
+// Generic inner iterator implementation for dense objects
+template<typename XprType>
+class inner_iterator_selector<XprType, IndexBased>
+{
+protected:
+  typedef evaluator<XprType> EvaluatorType;
+  typedef typename traits<XprType>::Scalar Scalar;
+  enum { IsRowMajor = (XprType::Flags&RowMajorBit)==RowMajorBit };
+  
+public:
+  EIGEN_STRONG_INLINE inner_iterator_selector(const EvaluatorType &eval, const Index &outerId, const Index &innerSize)
+    : m_eval(eval), m_inner(0), m_outer(outerId), m_end(innerSize)
+  {}
+
+  EIGEN_STRONG_INLINE Scalar value() const
+  {
+    return (IsRowMajor) ? m_eval.coeff(m_outer, m_inner)
+                        : m_eval.coeff(m_inner, m_outer);
+  }
+
+  EIGEN_STRONG_INLINE inner_iterator_selector& operator++() { m_inner++; return *this; }
+
+  EIGEN_STRONG_INLINE Index index() const { return m_inner; }
+  inline Index row() const { return IsRowMajor ? m_outer : index(); }
+  inline Index col() const { return IsRowMajor ? index() : m_outer; }
+
+  EIGEN_STRONG_INLINE operator bool() const { return m_inner < m_end && m_inner>=0; }
+
+protected:
+  const EvaluatorType& m_eval;
+  Index m_inner;
+  const Index m_outer;
+  const Index m_end;
+};
+
+// For iterator-based evaluator, inner-iterator is already implemented as
+// evaluator<>::InnerIterator
+template<typename XprType>
+class inner_iterator_selector<XprType, IteratorBased>
+ : public evaluator<XprType>::InnerIterator
+{
+protected:
+  typedef typename evaluator<XprType>::InnerIterator Base;
+  typedef evaluator<XprType> EvaluatorType;
+  
+public:
+  EIGEN_STRONG_INLINE inner_iterator_selector(const EvaluatorType &eval, const Index &outerId, const Index &/*innerSize*/)
+    : Base(eval, outerId)
+  {}  
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_COREITERATORS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/CwiseBinaryOp.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/CwiseBinaryOp.h
new file mode 100644
index 00000000..bf2632d9
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/CwiseBinaryOp.h
@@ -0,0 +1,183 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CWISE_BINARY_OP_H
+#define EIGEN_CWISE_BINARY_OP_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename BinaryOp, typename Lhs, typename Rhs>
+struct traits<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
+{
+  // we must not inherit from traits<Lhs> since it has
+  // the potential to cause problems with MSVC
+  typedef typename remove_all<Lhs>::type Ancestor;
+  typedef typename traits<Ancestor>::XprKind XprKind;
+  enum {
+    RowsAtCompileTime = traits<Ancestor>::RowsAtCompileTime,
+    ColsAtCompileTime = traits<Ancestor>::ColsAtCompileTime,
+    MaxRowsAtCompileTime = traits<Ancestor>::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = traits<Ancestor>::MaxColsAtCompileTime
+  };
+
+  // even though we require Lhs and Rhs to have the same scalar type (see CwiseBinaryOp constructor),
+  // we still want to handle the case when the result type is different.
+  typedef typename result_of<
+                     BinaryOp(
+                       const typename Lhs::Scalar&,
+                       const typename Rhs::Scalar&
+                     )
+                   >::type Scalar;
+  typedef typename cwise_promote_storage_type<typename traits<Lhs>::StorageKind,
+                                              typename traits<Rhs>::StorageKind,
+                                              BinaryOp>::ret StorageKind;
+  typedef typename promote_index_type<typename traits<Lhs>::StorageIndex,
+                                      typename traits<Rhs>::StorageIndex>::type StorageIndex;
+  typedef typename Lhs::Nested LhsNested;
+  typedef typename Rhs::Nested RhsNested;
+  typedef typename remove_reference<LhsNested>::type _LhsNested;
+  typedef typename remove_reference<RhsNested>::type _RhsNested;
+  enum {
+    Flags = cwise_promote_storage_order<typename traits<Lhs>::StorageKind,typename traits<Rhs>::StorageKind,_LhsNested::Flags & RowMajorBit,_RhsNested::Flags & RowMajorBit>::value
+  };
+};
+} // end namespace internal
+
+template<typename BinaryOp, typename Lhs, typename Rhs, typename StorageKind>
+class CwiseBinaryOpImpl;
+
+/** \class CwiseBinaryOp
+  * \ingroup Core_Module
+  *
+  * \brief Generic expression where a coefficient-wise binary operator is applied to two expressions
+  *
+  * \tparam BinaryOp template functor implementing the operator
+  * \tparam LhsType the type of the left-hand side
+  * \tparam RhsType the type of the right-hand side
+  *
+  * This class represents an expression  where a coefficient-wise binary operator is applied to two expressions.
+  * It is the return type of binary operators, by which we mean only those binary operators where
+  * both the left-hand side and the right-hand side are Eigen expressions.
+  * For example, the return type of matrix1+matrix2 is a CwiseBinaryOp.
+  *
+  * Most of the time, this is the only way that it is used, so you typically don't have to name
+  * CwiseBinaryOp types explicitly.
+  *
+  * \sa MatrixBase::binaryExpr(const MatrixBase<OtherDerived> &,const CustomBinaryOp &) const, class CwiseUnaryOp, class CwiseNullaryOp
+  */
+template<typename BinaryOp, typename LhsType, typename RhsType>
+class CwiseBinaryOp : 
+  public CwiseBinaryOpImpl<
+          BinaryOp, LhsType, RhsType,
+          typename internal::cwise_promote_storage_type<typename internal::traits<LhsType>::StorageKind,
+                                                        typename internal::traits<RhsType>::StorageKind,
+                                                        BinaryOp>::ret>,
+  internal::no_assignment_operator
+{
+  public:
+    
+    typedef typename internal::remove_all<BinaryOp>::type Functor;
+    typedef typename internal::remove_all<LhsType>::type Lhs;
+    typedef typename internal::remove_all<RhsType>::type Rhs;
+
+    typedef typename CwiseBinaryOpImpl<
+        BinaryOp, LhsType, RhsType,
+        typename internal::cwise_promote_storage_type<typename internal::traits<LhsType>::StorageKind,
+                                                      typename internal::traits<Rhs>::StorageKind,
+                                                      BinaryOp>::ret>::Base Base;
+    EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseBinaryOp)
+
+    typedef typename internal::ref_selector<LhsType>::type LhsNested;
+    typedef typename internal::ref_selector<RhsType>::type RhsNested;
+    typedef typename internal::remove_reference<LhsNested>::type _LhsNested;
+    typedef typename internal::remove_reference<RhsNested>::type _RhsNested;
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CwiseBinaryOp(const Lhs& aLhs, const Rhs& aRhs, const BinaryOp& func = BinaryOp())
+      : m_lhs(aLhs), m_rhs(aRhs), m_functor(func)
+    {
+      EIGEN_CHECK_BINARY_COMPATIBILIY(BinaryOp,typename Lhs::Scalar,typename Rhs::Scalar);
+      // require the sizes to match
+      EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Lhs, Rhs)
+      eigen_assert(aLhs.rows() == aRhs.rows() && aLhs.cols() == aRhs.cols());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Index rows() const {
+      // return the fixed size type if available to enable compile time optimizations
+      if (internal::traits<typename internal::remove_all<LhsNested>::type>::RowsAtCompileTime==Dynamic)
+        return m_rhs.rows();
+      else
+        return m_lhs.rows();
+    }
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Index cols() const {
+      // return the fixed size type if available to enable compile time optimizations
+      if (internal::traits<typename internal::remove_all<LhsNested>::type>::ColsAtCompileTime==Dynamic)
+        return m_rhs.cols();
+      else
+        return m_lhs.cols();
+    }
+
+    /** \returns the left hand side nested expression */
+    EIGEN_DEVICE_FUNC
+    const _LhsNested& lhs() const { return m_lhs; }
+    /** \returns the right hand side nested expression */
+    EIGEN_DEVICE_FUNC
+    const _RhsNested& rhs() const { return m_rhs; }
+    /** \returns the functor representing the binary operation */
+    EIGEN_DEVICE_FUNC
+    const BinaryOp& functor() const { return m_functor; }
+
+  protected:
+    LhsNested m_lhs;
+    RhsNested m_rhs;
+    const BinaryOp m_functor;
+};
+
+// Generic API dispatcher
+template<typename BinaryOp, typename Lhs, typename Rhs, typename StorageKind>
+class CwiseBinaryOpImpl
+  : public internal::generic_xpr_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >::type
+{
+public:
+  typedef typename internal::generic_xpr_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >::type Base;
+};
+
+/** replaces \c *this by \c *this - \a other.
+  *
+  * \returns a reference to \c *this
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived &
+MatrixBase<Derived>::operator-=(const MatrixBase<OtherDerived> &other)
+{
+  call_assignment(derived(), other.derived(), internal::sub_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+/** replaces \c *this by \c *this + \a other.
+  *
+  * \returns a reference to \c *this
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived &
+MatrixBase<Derived>::operator+=(const MatrixBase<OtherDerived>& other)
+{
+  call_assignment(derived(), other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_CWISE_BINARY_OP_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/CwiseNullaryOp.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/CwiseNullaryOp.h
new file mode 100644
index 00000000..b1923da0
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/CwiseNullaryOp.h
@@ -0,0 +1,902 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CWISE_NULLARY_OP_H
+#define EIGEN_CWISE_NULLARY_OP_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename NullaryOp, typename PlainObjectType>
+struct traits<CwiseNullaryOp<NullaryOp, PlainObjectType> > : traits<PlainObjectType>
+{
+  enum {
+    Flags = traits<PlainObjectType>::Flags & RowMajorBit
+  };
+};
+
+} // namespace internal
+
+/** \class CwiseNullaryOp
+  * \ingroup Core_Module
+  *
+  * \brief Generic expression of a matrix where all coefficients are defined by a functor
+  *
+  * \tparam NullaryOp template functor implementing the operator
+  * \tparam PlainObjectType the underlying plain matrix/array type
+  *
+  * This class represents an expression of a generic nullary operator.
+  * It is the return type of the Ones(), Zero(), Constant(), Identity() and Random() methods,
+  * and most of the time this is the only way it is used.
+  *
+  * However, if you want to write a function returning such an expression, you
+  * will need to use this class.
+  *
+  * The functor NullaryOp must expose one of the following method:
+    <table class="manual">
+    <tr            ><td>\c operator()() </td><td>if the procedural generation does not depend on the coefficient entries (e.g., random numbers)</td></tr>
+    <tr class="alt"><td>\c operator()(Index i)</td><td>if the procedural generation makes sense for vectors only and that it depends on the coefficient index \c i (e.g., linspace) </td></tr>
+    <tr            ><td>\c operator()(Index i,Index j)</td><td>if the procedural generation depends on the matrix coordinates \c i, \c j (e.g., to generate a checkerboard with 0 and 1)</td></tr>
+    </table>
+  * It is also possible to expose the last two operators if the generation makes sense for matrices but can be optimized for vectors.
+  *
+  * See DenseBase::NullaryExpr(Index,const CustomNullaryOp&) for an example binding
+  * C++11 random number generators.
+  *
+  * A nullary expression can also be used to implement custom sophisticated matrix manipulations
+  * that cannot be covered by the existing set of natively supported matrix manipulations.
+  * See this \ref TopicCustomizing_NullaryExpr "page" for some examples and additional explanations
+  * on the behavior of CwiseNullaryOp.
+  *
+  * \sa class CwiseUnaryOp, class CwiseBinaryOp, DenseBase::NullaryExpr
+  */
+template<typename NullaryOp, typename PlainObjectType>
+class CwiseNullaryOp : public internal::dense_xpr_base< CwiseNullaryOp<NullaryOp, PlainObjectType> >::type, internal::no_assignment_operator
+{
+  public:
+
+    typedef typename internal::dense_xpr_base<CwiseNullaryOp>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(CwiseNullaryOp)
+
+    EIGEN_DEVICE_FUNC
+    CwiseNullaryOp(Index rows, Index cols, const NullaryOp& func = NullaryOp())
+      : m_rows(rows), m_cols(cols), m_functor(func)
+    {
+      eigen_assert(rows >= 0
+            && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == rows)
+            &&  cols >= 0
+            && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == cols));
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Index rows() const { return m_rows.value(); }
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Index cols() const { return m_cols.value(); }
+
+    /** \returns the functor representing the nullary operation */
+    EIGEN_DEVICE_FUNC
+    const NullaryOp& functor() const { return m_functor; }
+
+  protected:
+    const internal::variable_if_dynamic<Index, RowsAtCompileTime> m_rows;
+    const internal::variable_if_dynamic<Index, ColsAtCompileTime> m_cols;
+    const NullaryOp m_functor;
+};
+
+
+/** \returns an expression of a matrix defined by a custom functor \a func
+  *
+  * The parameters \a rows and \a cols are the number of rows and of columns of
+  * the returned matrix. Must be compatible with this MatrixBase type.
+  *
+  * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
+  * it is redundant to pass \a rows and \a cols as arguments, so Zero() should be used
+  * instead.
+  *
+  * The template parameter \a CustomNullaryOp is the type of the functor.
+  *
+  * \sa class CwiseNullaryOp
+  */
+template<typename Derived>
+template<typename CustomNullaryOp>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const CwiseNullaryOp<CustomNullaryOp, typename DenseBase<Derived>::PlainObject>
+DenseBase<Derived>::NullaryExpr(Index rows, Index cols, const CustomNullaryOp& func)
+{
+  return CwiseNullaryOp<CustomNullaryOp, PlainObject>(rows, cols, func);
+}
+
+/** \returns an expression of a matrix defined by a custom functor \a func
+  *
+  * The parameter \a size is the size of the returned vector.
+  * Must be compatible with this MatrixBase type.
+  *
+  * \only_for_vectors
+  *
+  * This variant is meant to be used for dynamic-size vector types. For fixed-size types,
+  * it is redundant to pass \a size as argument, so Zero() should be used
+  * instead.
+  *
+  * The template parameter \a CustomNullaryOp is the type of the functor.
+  *
+  * Here is an example with C++11 random generators: \include random_cpp11.cpp
+  * Output: \verbinclude random_cpp11.out
+  * 
+  * \sa class CwiseNullaryOp
+  */
+template<typename Derived>
+template<typename CustomNullaryOp>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const CwiseNullaryOp<CustomNullaryOp, typename DenseBase<Derived>::PlainObject>
+DenseBase<Derived>::NullaryExpr(Index size, const CustomNullaryOp& func)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  if(RowsAtCompileTime == 1) return CwiseNullaryOp<CustomNullaryOp, PlainObject>(1, size, func);
+  else return CwiseNullaryOp<CustomNullaryOp, PlainObject>(size, 1, func);
+}
+
+/** \returns an expression of a matrix defined by a custom functor \a func
+  *
+  * This variant is only for fixed-size DenseBase types. For dynamic-size types, you
+  * need to use the variants taking size arguments.
+  *
+  * The template parameter \a CustomNullaryOp is the type of the functor.
+  *
+  * \sa class CwiseNullaryOp
+  */
+template<typename Derived>
+template<typename CustomNullaryOp>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const CwiseNullaryOp<CustomNullaryOp, typename DenseBase<Derived>::PlainObject>
+DenseBase<Derived>::NullaryExpr(const CustomNullaryOp& func)
+{
+  return CwiseNullaryOp<CustomNullaryOp, PlainObject>(RowsAtCompileTime, ColsAtCompileTime, func);
+}
+
+/** \returns an expression of a constant matrix of value \a value
+  *
+  * The parameters \a rows and \a cols are the number of rows and of columns of
+  * the returned matrix. Must be compatible with this DenseBase type.
+  *
+  * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
+  * it is redundant to pass \a rows and \a cols as arguments, so Zero() should be used
+  * instead.
+  *
+  * The template parameter \a CustomNullaryOp is the type of the functor.
+  *
+  * \sa class CwiseNullaryOp
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
+DenseBase<Derived>::Constant(Index rows, Index cols, const Scalar& value)
+{
+  return DenseBase<Derived>::NullaryExpr(rows, cols, internal::scalar_constant_op<Scalar>(value));
+}
+
+/** \returns an expression of a constant matrix of value \a value
+  *
+  * The parameter \a size is the size of the returned vector.
+  * Must be compatible with this DenseBase type.
+  *
+  * \only_for_vectors
+  *
+  * This variant is meant to be used for dynamic-size vector types. For fixed-size types,
+  * it is redundant to pass \a size as argument, so Zero() should be used
+  * instead.
+  *
+  * The template parameter \a CustomNullaryOp is the type of the functor.
+  *
+  * \sa class CwiseNullaryOp
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
+DenseBase<Derived>::Constant(Index size, const Scalar& value)
+{
+  return DenseBase<Derived>::NullaryExpr(size, internal::scalar_constant_op<Scalar>(value));
+}
+
+/** \returns an expression of a constant matrix of value \a value
+  *
+  * This variant is only for fixed-size DenseBase types. For dynamic-size types, you
+  * need to use the variants taking size arguments.
+  *
+  * The template parameter \a CustomNullaryOp is the type of the functor.
+  *
+  * \sa class CwiseNullaryOp
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
+DenseBase<Derived>::Constant(const Scalar& value)
+{
+  EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived)
+  return DenseBase<Derived>::NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, internal::scalar_constant_op<Scalar>(value));
+}
+
+/** \deprecated because of accuracy loss. In Eigen 3.3, it is an alias for LinSpaced(Index,const Scalar&,const Scalar&)
+  *
+  * \sa LinSpaced(Index,Scalar,Scalar), setLinSpaced(Index,const Scalar&,const Scalar&)
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::RandomAccessLinSpacedReturnType
+DenseBase<Derived>::LinSpaced(Sequential_t, Index size, const Scalar& low, const Scalar& high)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return DenseBase<Derived>::NullaryExpr(size, internal::linspaced_op<Scalar,PacketScalar>(low,high,size));
+}
+
+/** \deprecated because of accuracy loss. In Eigen 3.3, it is an alias for LinSpaced(const Scalar&,const Scalar&)
+  *
+  * \sa LinSpaced(Scalar,Scalar)
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::RandomAccessLinSpacedReturnType
+DenseBase<Derived>::LinSpaced(Sequential_t, const Scalar& low, const Scalar& high)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived)
+  return DenseBase<Derived>::NullaryExpr(Derived::SizeAtCompileTime, internal::linspaced_op<Scalar,PacketScalar>(low,high,Derived::SizeAtCompileTime));
+}
+
+/**
+  * \brief Sets a linearly spaced vector.
+  *
+  * The function generates 'size' equally spaced values in the closed interval [low,high].
+  * When size is set to 1, a vector of length 1 containing 'high' is returned.
+  *
+  * \only_for_vectors
+  *
+  * Example: \include DenseBase_LinSpaced.cpp
+  * Output: \verbinclude DenseBase_LinSpaced.out
+  *
+  * For integer scalar types, an even spacing is possible if and only if the length of the range,
+  * i.e., \c high-low is a scalar multiple of \c size-1, or if \c size is a scalar multiple of the
+  * number of values \c high-low+1 (meaning each value can be repeated the same number of time).
+  * If one of these two considions is not satisfied, then \c high is lowered to the largest value
+  * satisfying one of this constraint.
+  * Here are some examples:
+  *
+  * Example: \include DenseBase_LinSpacedInt.cpp
+  * Output: \verbinclude DenseBase_LinSpacedInt.out
+  *
+  * \sa setLinSpaced(Index,const Scalar&,const Scalar&), CwiseNullaryOp
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::RandomAccessLinSpacedReturnType
+DenseBase<Derived>::LinSpaced(Index size, const Scalar& low, const Scalar& high)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return DenseBase<Derived>::NullaryExpr(size, internal::linspaced_op<Scalar,PacketScalar>(low,high,size));
+}
+
+/**
+  * \copydoc DenseBase::LinSpaced(Index, const Scalar&, const Scalar&)
+  * Special version for fixed size types which does not require the size parameter.
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::RandomAccessLinSpacedReturnType
+DenseBase<Derived>::LinSpaced(const Scalar& low, const Scalar& high)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived)
+  return DenseBase<Derived>::NullaryExpr(Derived::SizeAtCompileTime, internal::linspaced_op<Scalar,PacketScalar>(low,high,Derived::SizeAtCompileTime));
+}
+
+/** \returns true if all coefficients in this matrix are approximately equal to \a val, to within precision \a prec */
+template<typename Derived>
+EIGEN_DEVICE_FUNC bool DenseBase<Derived>::isApproxToConstant
+(const Scalar& val, const RealScalar& prec) const
+{
+  typename internal::nested_eval<Derived,1>::type self(derived());
+  for(Index j = 0; j < cols(); ++j)
+    for(Index i = 0; i < rows(); ++i)
+      if(!internal::isApprox(self.coeff(i, j), val, prec))
+        return false;
+  return true;
+}
+
+/** This is just an alias for isApproxToConstant().
+  *
+  * \returns true if all coefficients in this matrix are approximately equal to \a value, to within precision \a prec */
+template<typename Derived>
+EIGEN_DEVICE_FUNC bool DenseBase<Derived>::isConstant
+(const Scalar& val, const RealScalar& prec) const
+{
+  return isApproxToConstant(val, prec);
+}
+
+/** Alias for setConstant(): sets all coefficients in this expression to \a val.
+  *
+  * \sa setConstant(), Constant(), class CwiseNullaryOp
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void DenseBase<Derived>::fill(const Scalar& val)
+{
+  setConstant(val);
+}
+
+/** Sets all coefficients in this expression to value \a val.
+  *
+  * \sa fill(), setConstant(Index,const Scalar&), setConstant(Index,Index,const Scalar&), setZero(), setOnes(), Constant(), class CwiseNullaryOp, setZero(), setOnes()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setConstant(const Scalar& val)
+{
+  return derived() = Constant(rows(), cols(), val);
+}
+
+/** Resizes to the given \a size, and sets all coefficients in this expression to the given value \a val.
+  *
+  * \only_for_vectors
+  *
+  * Example: \include Matrix_setConstant_int.cpp
+  * Output: \verbinclude Matrix_setConstant_int.out
+  *
+  * \sa MatrixBase::setConstant(const Scalar&), setConstant(Index,Index,const Scalar&), class CwiseNullaryOp, MatrixBase::Constant(const Scalar&)
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setConstant(Index size, const Scalar& val)
+{
+  resize(size);
+  return setConstant(val);
+}
+
+/** Resizes to the given size, and sets all coefficients in this expression to the given value \a val.
+  *
+  * \param rows the new number of rows
+  * \param cols the new number of columns
+  * \param val the value to which all coefficients are set
+  *
+  * Example: \include Matrix_setConstant_int_int.cpp
+  * Output: \verbinclude Matrix_setConstant_int_int.out
+  *
+  * \sa MatrixBase::setConstant(const Scalar&), setConstant(Index,const Scalar&), class CwiseNullaryOp, MatrixBase::Constant(const Scalar&)
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setConstant(Index rows, Index cols, const Scalar& val)
+{
+  resize(rows, cols);
+  return setConstant(val);
+}
+
+/**
+  * \brief Sets a linearly spaced vector.
+  *
+  * The function generates 'size' equally spaced values in the closed interval [low,high].
+  * When size is set to 1, a vector of length 1 containing 'high' is returned.
+  *
+  * \only_for_vectors
+  *
+  * Example: \include DenseBase_setLinSpaced.cpp
+  * Output: \verbinclude DenseBase_setLinSpaced.out
+  *
+  * For integer scalar types, do not miss the explanations on the definition
+  * of \link LinSpaced(Index,const Scalar&,const Scalar&) even spacing \endlink.
+  *
+  * \sa LinSpaced(Index,const Scalar&,const Scalar&), CwiseNullaryOp
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setLinSpaced(Index newSize, const Scalar& low, const Scalar& high)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return derived() = Derived::NullaryExpr(newSize, internal::linspaced_op<Scalar,PacketScalar>(low,high,newSize));
+}
+
+/**
+  * \brief Sets a linearly spaced vector.
+  *
+  * The function fills \c *this with equally spaced values in the closed interval [low,high].
+  * When size is set to 1, a vector of length 1 containing 'high' is returned.
+  *
+  * \only_for_vectors
+  *
+  * For integer scalar types, do not miss the explanations on the definition
+  * of \link LinSpaced(Index,const Scalar&,const Scalar&) even spacing \endlink.
+  *
+  * \sa LinSpaced(Index,const Scalar&,const Scalar&), setLinSpaced(Index, const Scalar&, const Scalar&), CwiseNullaryOp
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setLinSpaced(const Scalar& low, const Scalar& high)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return setLinSpaced(size(), low, high);
+}
+
+// zero:
+
+/** \returns an expression of a zero matrix.
+  *
+  * The parameters \a rows and \a cols are the number of rows and of columns of
+  * the returned matrix. Must be compatible with this MatrixBase type.
+  *
+  * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
+  * it is redundant to pass \a rows and \a cols as arguments, so Zero() should be used
+  * instead.
+  *
+  * Example: \include MatrixBase_zero_int_int.cpp
+  * Output: \verbinclude MatrixBase_zero_int_int.out
+  *
+  * \sa Zero(), Zero(Index)
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
+DenseBase<Derived>::Zero(Index rows, Index cols)
+{
+  return Constant(rows, cols, Scalar(0));
+}
+
+/** \returns an expression of a zero vector.
+  *
+  * The parameter \a size is the size of the returned vector.
+  * Must be compatible with this MatrixBase type.
+  *
+  * \only_for_vectors
+  *
+  * This variant is meant to be used for dynamic-size vector types. For fixed-size types,
+  * it is redundant to pass \a size as argument, so Zero() should be used
+  * instead.
+  *
+  * Example: \include MatrixBase_zero_int.cpp
+  * Output: \verbinclude MatrixBase_zero_int.out
+  *
+  * \sa Zero(), Zero(Index,Index)
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
+DenseBase<Derived>::Zero(Index size)
+{
+  return Constant(size, Scalar(0));
+}
+
+/** \returns an expression of a fixed-size zero matrix or vector.
+  *
+  * This variant is only for fixed-size MatrixBase types. For dynamic-size types, you
+  * need to use the variants taking size arguments.
+  *
+  * Example: \include MatrixBase_zero.cpp
+  * Output: \verbinclude MatrixBase_zero.out
+  *
+  * \sa Zero(Index), Zero(Index,Index)
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
+DenseBase<Derived>::Zero()
+{
+  return Constant(Scalar(0));
+}
+
+/** \returns true if *this is approximately equal to the zero matrix,
+  *          within the precision given by \a prec.
+  *
+  * Example: \include MatrixBase_isZero.cpp
+  * Output: \verbinclude MatrixBase_isZero.out
+  *
+  * \sa class CwiseNullaryOp, Zero()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC bool DenseBase<Derived>::isZero(const RealScalar& prec) const
+{
+  typename internal::nested_eval<Derived,1>::type self(derived());
+  for(Index j = 0; j < cols(); ++j)
+    for(Index i = 0; i < rows(); ++i)
+      if(!internal::isMuchSmallerThan(self.coeff(i, j), static_cast<Scalar>(1), prec))
+        return false;
+  return true;
+}
+
+/** Sets all coefficients in this expression to zero.
+  *
+  * Example: \include MatrixBase_setZero.cpp
+  * Output: \verbinclude MatrixBase_setZero.out
+  *
+  * \sa class CwiseNullaryOp, Zero()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setZero()
+{
+  return setConstant(Scalar(0));
+}
+
+/** Resizes to the given \a size, and sets all coefficients in this expression to zero.
+  *
+  * \only_for_vectors
+  *
+  * Example: \include Matrix_setZero_int.cpp
+  * Output: \verbinclude Matrix_setZero_int.out
+  *
+  * \sa DenseBase::setZero(), setZero(Index,Index), class CwiseNullaryOp, DenseBase::Zero()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setZero(Index newSize)
+{
+  resize(newSize);
+  return setConstant(Scalar(0));
+}
+
+/** Resizes to the given size, and sets all coefficients in this expression to zero.
+  *
+  * \param rows the new number of rows
+  * \param cols the new number of columns
+  *
+  * Example: \include Matrix_setZero_int_int.cpp
+  * Output: \verbinclude Matrix_setZero_int_int.out
+  *
+  * \sa DenseBase::setZero(), setZero(Index), class CwiseNullaryOp, DenseBase::Zero()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setZero(Index rows, Index cols)
+{
+  resize(rows, cols);
+  return setConstant(Scalar(0));
+}
+
+// ones:
+
+/** \returns an expression of a matrix where all coefficients equal one.
+  *
+  * The parameters \a rows and \a cols are the number of rows and of columns of
+  * the returned matrix. Must be compatible with this MatrixBase type.
+  *
+  * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
+  * it is redundant to pass \a rows and \a cols as arguments, so Ones() should be used
+  * instead.
+  *
+  * Example: \include MatrixBase_ones_int_int.cpp
+  * Output: \verbinclude MatrixBase_ones_int_int.out
+  *
+  * \sa Ones(), Ones(Index), isOnes(), class Ones
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
+DenseBase<Derived>::Ones(Index rows, Index cols)
+{
+  return Constant(rows, cols, Scalar(1));
+}
+
+/** \returns an expression of a vector where all coefficients equal one.
+  *
+  * The parameter \a newSize is the size of the returned vector.
+  * Must be compatible with this MatrixBase type.
+  *
+  * \only_for_vectors
+  *
+  * This variant is meant to be used for dynamic-size vector types. For fixed-size types,
+  * it is redundant to pass \a size as argument, so Ones() should be used
+  * instead.
+  *
+  * Example: \include MatrixBase_ones_int.cpp
+  * Output: \verbinclude MatrixBase_ones_int.out
+  *
+  * \sa Ones(), Ones(Index,Index), isOnes(), class Ones
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
+DenseBase<Derived>::Ones(Index newSize)
+{
+  return Constant(newSize, Scalar(1));
+}
+
+/** \returns an expression of a fixed-size matrix or vector where all coefficients equal one.
+  *
+  * This variant is only for fixed-size MatrixBase types. For dynamic-size types, you
+  * need to use the variants taking size arguments.
+  *
+  * Example: \include MatrixBase_ones.cpp
+  * Output: \verbinclude MatrixBase_ones.out
+  *
+  * \sa Ones(Index), Ones(Index,Index), isOnes(), class Ones
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
+DenseBase<Derived>::Ones()
+{
+  return Constant(Scalar(1));
+}
+
+/** \returns true if *this is approximately equal to the matrix where all coefficients
+  *          are equal to 1, within the precision given by \a prec.
+  *
+  * Example: \include MatrixBase_isOnes.cpp
+  * Output: \verbinclude MatrixBase_isOnes.out
+  *
+  * \sa class CwiseNullaryOp, Ones()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC bool DenseBase<Derived>::isOnes
+(const RealScalar& prec) const
+{
+  return isApproxToConstant(Scalar(1), prec);
+}
+
+/** Sets all coefficients in this expression to one.
+  *
+  * Example: \include MatrixBase_setOnes.cpp
+  * Output: \verbinclude MatrixBase_setOnes.out
+  *
+  * \sa class CwiseNullaryOp, Ones()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setOnes()
+{
+  return setConstant(Scalar(1));
+}
+
+/** Resizes to the given \a newSize, and sets all coefficients in this expression to one.
+  *
+  * \only_for_vectors
+  *
+  * Example: \include Matrix_setOnes_int.cpp
+  * Output: \verbinclude Matrix_setOnes_int.out
+  *
+  * \sa MatrixBase::setOnes(), setOnes(Index,Index), class CwiseNullaryOp, MatrixBase::Ones()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setOnes(Index newSize)
+{
+  resize(newSize);
+  return setConstant(Scalar(1));
+}
+
+/** Resizes to the given size, and sets all coefficients in this expression to one.
+  *
+  * \param rows the new number of rows
+  * \param cols the new number of columns
+  *
+  * Example: \include Matrix_setOnes_int_int.cpp
+  * Output: \verbinclude Matrix_setOnes_int_int.out
+  *
+  * \sa MatrixBase::setOnes(), setOnes(Index), class CwiseNullaryOp, MatrixBase::Ones()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setOnes(Index rows, Index cols)
+{
+  resize(rows, cols);
+  return setConstant(Scalar(1));
+}
+
+// Identity:
+
+/** \returns an expression of the identity matrix (not necessarily square).
+  *
+  * The parameters \a rows and \a cols are the number of rows and of columns of
+  * the returned matrix. Must be compatible with this MatrixBase type.
+  *
+  * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
+  * it is redundant to pass \a rows and \a cols as arguments, so Identity() should be used
+  * instead.
+  *
+  * Example: \include MatrixBase_identity_int_int.cpp
+  * Output: \verbinclude MatrixBase_identity_int_int.out
+  *
+  * \sa Identity(), setIdentity(), isIdentity()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::IdentityReturnType
+MatrixBase<Derived>::Identity(Index rows, Index cols)
+{
+  return DenseBase<Derived>::NullaryExpr(rows, cols, internal::scalar_identity_op<Scalar>());
+}
+
+/** \returns an expression of the identity matrix (not necessarily square).
+  *
+  * This variant is only for fixed-size MatrixBase types. For dynamic-size types, you
+  * need to use the variant taking size arguments.
+  *
+  * Example: \include MatrixBase_identity.cpp
+  * Output: \verbinclude MatrixBase_identity.out
+  *
+  * \sa Identity(Index,Index), setIdentity(), isIdentity()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::IdentityReturnType
+MatrixBase<Derived>::Identity()
+{
+  EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived)
+  return MatrixBase<Derived>::NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, internal::scalar_identity_op<Scalar>());
+}
+
+/** \returns true if *this is approximately equal to the identity matrix
+  *          (not necessarily square),
+  *          within the precision given by \a prec.
+  *
+  * Example: \include MatrixBase_isIdentity.cpp
+  * Output: \verbinclude MatrixBase_isIdentity.out
+  *
+  * \sa class CwiseNullaryOp, Identity(), Identity(Index,Index), setIdentity()
+  */
+template<typename Derived>
+bool MatrixBase<Derived>::isIdentity
+(const RealScalar& prec) const
+{
+  typename internal::nested_eval<Derived,1>::type self(derived());
+  for(Index j = 0; j < cols(); ++j)
+  {
+    for(Index i = 0; i < rows(); ++i)
+    {
+      if(i == j)
+      {
+        if(!internal::isApprox(self.coeff(i, j), static_cast<Scalar>(1), prec))
+          return false;
+      }
+      else
+      {
+        if(!internal::isMuchSmallerThan(self.coeff(i, j), static_cast<RealScalar>(1), prec))
+          return false;
+      }
+    }
+  }
+  return true;
+}
+
+namespace internal {
+
+template<typename Derived, bool Big = (Derived::SizeAtCompileTime>=16)>
+struct setIdentity_impl
+{
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE Derived& run(Derived& m)
+  {
+    return m = Derived::Identity(m.rows(), m.cols());
+  }
+};
+
+template<typename Derived>
+struct setIdentity_impl<Derived, true>
+{
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE Derived& run(Derived& m)
+  {
+    m.setZero();
+    const Index size = numext::mini(m.rows(), m.cols());
+    for(Index i = 0; i < size; ++i) m.coeffRef(i,i) = typename Derived::Scalar(1);
+    return m;
+  }
+};
+
+} // end namespace internal
+
+/** Writes the identity expression (not necessarily square) into *this.
+  *
+  * Example: \include MatrixBase_setIdentity.cpp
+  * Output: \verbinclude MatrixBase_setIdentity.out
+  *
+  * \sa class CwiseNullaryOp, Identity(), Identity(Index,Index), isIdentity()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setIdentity()
+{
+  return internal::setIdentity_impl<Derived>::run(derived());
+}
+
+/** \brief Resizes to the given size, and writes the identity expression (not necessarily square) into *this.
+  *
+  * \param rows the new number of rows
+  * \param cols the new number of columns
+  *
+  * Example: \include Matrix_setIdentity_int_int.cpp
+  * Output: \verbinclude Matrix_setIdentity_int_int.out
+  *
+  * \sa MatrixBase::setIdentity(), class CwiseNullaryOp, MatrixBase::Identity()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setIdentity(Index rows, Index cols)
+{
+  derived().resize(rows, cols);
+  return setIdentity();
+}
+
+/** \returns an expression of the i-th unit (basis) vector.
+  *
+  * \only_for_vectors
+  *
+  * \sa MatrixBase::Unit(Index), MatrixBase::UnitX(), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::BasisReturnType MatrixBase<Derived>::Unit(Index newSize, Index i)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return BasisReturnType(SquareMatrixType::Identity(newSize,newSize), i);
+}
+
+/** \returns an expression of the i-th unit (basis) vector.
+  *
+  * \only_for_vectors
+  *
+  * This variant is for fixed-size vector only.
+  *
+  * \sa MatrixBase::Unit(Index,Index), MatrixBase::UnitX(), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::BasisReturnType MatrixBase<Derived>::Unit(Index i)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return BasisReturnType(SquareMatrixType::Identity(),i);
+}
+
+/** \returns an expression of the X axis unit vector (1{,0}^*)
+  *
+  * \only_for_vectors
+  *
+  * \sa MatrixBase::Unit(Index,Index), MatrixBase::Unit(Index), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::BasisReturnType MatrixBase<Derived>::UnitX()
+{ return Derived::Unit(0); }
+
+/** \returns an expression of the Y axis unit vector (0,1{,0}^*)
+  *
+  * \only_for_vectors
+  *
+  * \sa MatrixBase::Unit(Index,Index), MatrixBase::Unit(Index), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::BasisReturnType MatrixBase<Derived>::UnitY()
+{ return Derived::Unit(1); }
+
+/** \returns an expression of the Z axis unit vector (0,0,1{,0}^*)
+  *
+  * \only_for_vectors
+  *
+  * \sa MatrixBase::Unit(Index,Index), MatrixBase::Unit(Index), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::BasisReturnType MatrixBase<Derived>::UnitZ()
+{ return Derived::Unit(2); }
+
+/** \returns an expression of the W axis unit vector (0,0,0,1)
+  *
+  * \only_for_vectors
+  *
+  * \sa MatrixBase::Unit(Index,Index), MatrixBase::Unit(Index), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::BasisReturnType MatrixBase<Derived>::UnitW()
+{ return Derived::Unit(3); }
+
+/** \brief Set the coefficients of \c *this to the i-th unit (basis) vector
+  *
+  * \param i index of the unique coefficient to be set to 1
+  *
+  * \only_for_vectors
+  *
+  * \sa MatrixBase::setIdentity(), class CwiseNullaryOp, MatrixBase::Unit(Index,Index)
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setUnit(Index i)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+  eigen_assert(i<size());
+  derived().setZero();
+  derived().coeffRef(i) = Scalar(1);
+  return derived();
+}
+
+/** \brief Resizes to the given \a newSize, and writes the i-th unit (basis) vector into *this.
+  *
+  * \param newSize the new size of the vector
+  * \param i index of the unique coefficient to be set to 1
+  *
+  * \only_for_vectors
+  *
+  * \sa MatrixBase::setIdentity(), class CwiseNullaryOp, MatrixBase::Unit(Index,Index)
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setUnit(Index newSize, Index i)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+  eigen_assert(i<newSize);
+  derived().resize(newSize);
+  return setUnit(i);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_CWISE_NULLARY_OP_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/CwiseTernaryOp.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/CwiseTernaryOp.h
new file mode 100644
index 00000000..9f3576fe
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/CwiseTernaryOp.h
@@ -0,0 +1,197 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2016 Eugene Brevdo <ebrevdo@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CWISE_TERNARY_OP_H
+#define EIGEN_CWISE_TERNARY_OP_H
+
+namespace Eigen {
+
+namespace internal {
+template <typename TernaryOp, typename Arg1, typename Arg2, typename Arg3>
+struct traits<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> > {
+  // we must not inherit from traits<Arg1> since it has
+  // the potential to cause problems with MSVC
+  typedef typename remove_all<Arg1>::type Ancestor;
+  typedef typename traits<Ancestor>::XprKind XprKind;
+  enum {
+    RowsAtCompileTime = traits<Ancestor>::RowsAtCompileTime,
+    ColsAtCompileTime = traits<Ancestor>::ColsAtCompileTime,
+    MaxRowsAtCompileTime = traits<Ancestor>::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = traits<Ancestor>::MaxColsAtCompileTime
+  };
+
+  // even though we require Arg1, Arg2, and Arg3 to have the same scalar type
+  // (see CwiseTernaryOp constructor),
+  // we still want to handle the case when the result type is different.
+  typedef typename result_of<TernaryOp(
+      const typename Arg1::Scalar&, const typename Arg2::Scalar&,
+      const typename Arg3::Scalar&)>::type Scalar;
+
+  typedef typename internal::traits<Arg1>::StorageKind StorageKind;
+  typedef typename internal::traits<Arg1>::StorageIndex StorageIndex;
+
+  typedef typename Arg1::Nested Arg1Nested;
+  typedef typename Arg2::Nested Arg2Nested;
+  typedef typename Arg3::Nested Arg3Nested;
+  typedef typename remove_reference<Arg1Nested>::type _Arg1Nested;
+  typedef typename remove_reference<Arg2Nested>::type _Arg2Nested;
+  typedef typename remove_reference<Arg3Nested>::type _Arg3Nested;
+  enum { Flags = _Arg1Nested::Flags & RowMajorBit };
+};
+}  // end namespace internal
+
+template <typename TernaryOp, typename Arg1, typename Arg2, typename Arg3,
+          typename StorageKind>
+class CwiseTernaryOpImpl;
+
+/** \class CwiseTernaryOp
+  * \ingroup Core_Module
+  *
+  * \brief Generic expression where a coefficient-wise ternary operator is
+ * applied to two expressions
+  *
+  * \tparam TernaryOp template functor implementing the operator
+  * \tparam Arg1Type the type of the first argument
+  * \tparam Arg2Type the type of the second argument
+  * \tparam Arg3Type the type of the third argument
+  *
+  * This class represents an expression where a coefficient-wise ternary
+ * operator is applied to three expressions.
+  * It is the return type of ternary operators, by which we mean only those
+ * ternary operators where
+  * all three arguments are Eigen expressions.
+  * For example, the return type of betainc(matrix1, matrix2, matrix3) is a
+ * CwiseTernaryOp.
+  *
+  * Most of the time, this is the only way that it is used, so you typically
+ * don't have to name
+  * CwiseTernaryOp types explicitly.
+  *
+  * \sa MatrixBase::ternaryExpr(const MatrixBase<Argument2> &, const
+ * MatrixBase<Argument3> &, const CustomTernaryOp &) const, class CwiseBinaryOp,
+ * class CwiseUnaryOp, class CwiseNullaryOp
+  */
+template <typename TernaryOp, typename Arg1Type, typename Arg2Type,
+          typename Arg3Type>
+class CwiseTernaryOp : public CwiseTernaryOpImpl<
+                           TernaryOp, Arg1Type, Arg2Type, Arg3Type,
+                           typename internal::traits<Arg1Type>::StorageKind>,
+                       internal::no_assignment_operator
+{
+ public:
+  typedef typename internal::remove_all<Arg1Type>::type Arg1;
+  typedef typename internal::remove_all<Arg2Type>::type Arg2;
+  typedef typename internal::remove_all<Arg3Type>::type Arg3;
+
+  typedef typename CwiseTernaryOpImpl<
+      TernaryOp, Arg1Type, Arg2Type, Arg3Type,
+      typename internal::traits<Arg1Type>::StorageKind>::Base Base;
+  EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseTernaryOp)
+
+  typedef typename internal::ref_selector<Arg1Type>::type Arg1Nested;
+  typedef typename internal::ref_selector<Arg2Type>::type Arg2Nested;
+  typedef typename internal::ref_selector<Arg3Type>::type Arg3Nested;
+  typedef typename internal::remove_reference<Arg1Nested>::type _Arg1Nested;
+  typedef typename internal::remove_reference<Arg2Nested>::type _Arg2Nested;
+  typedef typename internal::remove_reference<Arg3Nested>::type _Arg3Nested;
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE CwiseTernaryOp(const Arg1& a1, const Arg2& a2,
+                                     const Arg3& a3,
+                                     const TernaryOp& func = TernaryOp())
+      : m_arg1(a1), m_arg2(a2), m_arg3(a3), m_functor(func) {
+    // require the sizes to match
+    EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Arg1, Arg2)
+    EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Arg1, Arg3)
+
+    // The index types should match
+    EIGEN_STATIC_ASSERT((internal::is_same<
+                         typename internal::traits<Arg1Type>::StorageKind,
+                         typename internal::traits<Arg2Type>::StorageKind>::value),
+                        STORAGE_KIND_MUST_MATCH)
+    EIGEN_STATIC_ASSERT((internal::is_same<
+                         typename internal::traits<Arg1Type>::StorageKind,
+                         typename internal::traits<Arg3Type>::StorageKind>::value),
+                        STORAGE_KIND_MUST_MATCH)
+
+    eigen_assert(a1.rows() == a2.rows() && a1.cols() == a2.cols() &&
+                 a1.rows() == a3.rows() && a1.cols() == a3.cols());
+  }
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE Index rows() const {
+    // return the fixed size type if available to enable compile time
+    // optimizations
+    if (internal::traits<typename internal::remove_all<Arg1Nested>::type>::
+                RowsAtCompileTime == Dynamic &&
+        internal::traits<typename internal::remove_all<Arg2Nested>::type>::
+                RowsAtCompileTime == Dynamic)
+      return m_arg3.rows();
+    else if (internal::traits<typename internal::remove_all<Arg1Nested>::type>::
+                     RowsAtCompileTime == Dynamic &&
+             internal::traits<typename internal::remove_all<Arg3Nested>::type>::
+                     RowsAtCompileTime == Dynamic)
+      return m_arg2.rows();
+    else
+      return m_arg1.rows();
+  }
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE Index cols() const {
+    // return the fixed size type if available to enable compile time
+    // optimizations
+    if (internal::traits<typename internal::remove_all<Arg1Nested>::type>::
+                ColsAtCompileTime == Dynamic &&
+        internal::traits<typename internal::remove_all<Arg2Nested>::type>::
+                ColsAtCompileTime == Dynamic)
+      return m_arg3.cols();
+    else if (internal::traits<typename internal::remove_all<Arg1Nested>::type>::
+                     ColsAtCompileTime == Dynamic &&
+             internal::traits<typename internal::remove_all<Arg3Nested>::type>::
+                     ColsAtCompileTime == Dynamic)
+      return m_arg2.cols();
+    else
+      return m_arg1.cols();
+  }
+
+  /** \returns the first argument nested expression */
+  EIGEN_DEVICE_FUNC
+  const _Arg1Nested& arg1() const { return m_arg1; }
+  /** \returns the first argument nested expression */
+  EIGEN_DEVICE_FUNC
+  const _Arg2Nested& arg2() const { return m_arg2; }
+  /** \returns the third argument nested expression */
+  EIGEN_DEVICE_FUNC
+  const _Arg3Nested& arg3() const { return m_arg3; }
+  /** \returns the functor representing the ternary operation */
+  EIGEN_DEVICE_FUNC
+  const TernaryOp& functor() const { return m_functor; }
+
+ protected:
+  Arg1Nested m_arg1;
+  Arg2Nested m_arg2;
+  Arg3Nested m_arg3;
+  const TernaryOp m_functor;
+};
+
+// Generic API dispatcher
+template <typename TernaryOp, typename Arg1, typename Arg2, typename Arg3,
+          typename StorageKind>
+class CwiseTernaryOpImpl
+    : public internal::generic_xpr_base<
+          CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> >::type {
+ public:
+  typedef typename internal::generic_xpr_base<
+      CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> >::type Base;
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_CWISE_TERNARY_OP_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/CwiseUnaryOp.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/CwiseUnaryOp.h
new file mode 100644
index 00000000..1d2dd19f
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/CwiseUnaryOp.h
@@ -0,0 +1,103 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CWISE_UNARY_OP_H
+#define EIGEN_CWISE_UNARY_OP_H
+
+namespace Eigen { 
+
+namespace internal {
+template<typename UnaryOp, typename XprType>
+struct traits<CwiseUnaryOp<UnaryOp, XprType> >
+ : traits<XprType>
+{
+  typedef typename result_of<
+                     UnaryOp(const typename XprType::Scalar&)
+                   >::type Scalar;
+  typedef typename XprType::Nested XprTypeNested;
+  typedef typename remove_reference<XprTypeNested>::type _XprTypeNested;
+  enum {
+    Flags = _XprTypeNested::Flags & RowMajorBit 
+  };
+};
+}
+
+template<typename UnaryOp, typename XprType, typename StorageKind>
+class CwiseUnaryOpImpl;
+
+/** \class CwiseUnaryOp
+  * \ingroup Core_Module
+  *
+  * \brief Generic expression where a coefficient-wise unary operator is applied to an expression
+  *
+  * \tparam UnaryOp template functor implementing the operator
+  * \tparam XprType the type of the expression to which we are applying the unary operator
+  *
+  * This class represents an expression where a unary operator is applied to an expression.
+  * It is the return type of all operations taking exactly 1 input expression, regardless of the
+  * presence of other inputs such as scalars. For example, the operator* in the expression 3*matrix
+  * is considered unary, because only the right-hand side is an expression, and its
+  * return type is a specialization of CwiseUnaryOp.
+  *
+  * Most of the time, this is the only way that it is used, so you typically don't have to name
+  * CwiseUnaryOp types explicitly.
+  *
+  * \sa MatrixBase::unaryExpr(const CustomUnaryOp &) const, class CwiseBinaryOp, class CwiseNullaryOp
+  */
+template<typename UnaryOp, typename XprType>
+class CwiseUnaryOp : public CwiseUnaryOpImpl<UnaryOp, XprType, typename internal::traits<XprType>::StorageKind>, internal::no_assignment_operator
+{
+  public:
+
+    typedef typename CwiseUnaryOpImpl<UnaryOp, XprType,typename internal::traits<XprType>::StorageKind>::Base Base;
+    EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseUnaryOp)
+    typedef typename internal::ref_selector<XprType>::type XprTypeNested;
+    typedef typename internal::remove_all<XprType>::type NestedExpression;
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    explicit CwiseUnaryOp(const XprType& xpr, const UnaryOp& func = UnaryOp())
+      : m_xpr(xpr), m_functor(func) {}
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Index rows() const { return m_xpr.rows(); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Index cols() const { return m_xpr.cols(); }
+
+    /** \returns the functor representing the unary operation */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const UnaryOp& functor() const { return m_functor; }
+
+    /** \returns the nested expression */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const typename internal::remove_all<XprTypeNested>::type&
+    nestedExpression() const { return m_xpr; }
+
+    /** \returns the nested expression */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    typename internal::remove_all<XprTypeNested>::type&
+    nestedExpression() { return m_xpr; }
+
+  protected:
+    XprTypeNested m_xpr;
+    const UnaryOp m_functor;
+};
+
+// Generic API dispatcher
+template<typename UnaryOp, typename XprType, typename StorageKind>
+class CwiseUnaryOpImpl
+  : public internal::generic_xpr_base<CwiseUnaryOp<UnaryOp, XprType> >::type
+{
+public:
+  typedef typename internal::generic_xpr_base<CwiseUnaryOp<UnaryOp, XprType> >::type Base;
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_CWISE_UNARY_OP_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/CwiseUnaryView.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/CwiseUnaryView.h
new file mode 100644
index 00000000..27103305
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/CwiseUnaryView.h
@@ -0,0 +1,128 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CWISE_UNARY_VIEW_H
+#define EIGEN_CWISE_UNARY_VIEW_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename ViewOp, typename MatrixType>
+struct traits<CwiseUnaryView<ViewOp, MatrixType> >
+ : traits<MatrixType>
+{
+  typedef typename result_of<
+                     ViewOp(const typename traits<MatrixType>::Scalar&)
+                   >::type Scalar;
+  typedef typename MatrixType::Nested MatrixTypeNested;
+  typedef typename remove_all<MatrixTypeNested>::type _MatrixTypeNested;
+  enum {
+    FlagsLvalueBit = is_lvalue<MatrixType>::value ? LvalueBit : 0,
+    Flags = traits<_MatrixTypeNested>::Flags & (RowMajorBit | FlagsLvalueBit | DirectAccessBit), // FIXME DirectAccessBit should not be handled by expressions
+    MatrixTypeInnerStride =  inner_stride_at_compile_time<MatrixType>::ret,
+    // need to cast the sizeof's from size_t to int explicitly, otherwise:
+    // "error: no integral type can represent all of the enumerator values
+    InnerStrideAtCompileTime = MatrixTypeInnerStride == Dynamic
+                             ? int(Dynamic)
+                             : int(MatrixTypeInnerStride) * int(sizeof(typename traits<MatrixType>::Scalar) / sizeof(Scalar)),
+    OuterStrideAtCompileTime = outer_stride_at_compile_time<MatrixType>::ret == Dynamic
+                             ? int(Dynamic)
+                             : outer_stride_at_compile_time<MatrixType>::ret * int(sizeof(typename traits<MatrixType>::Scalar) / sizeof(Scalar))
+  };
+};
+}
+
+template<typename ViewOp, typename MatrixType, typename StorageKind>
+class CwiseUnaryViewImpl;
+
+/** \class CwiseUnaryView
+  * \ingroup Core_Module
+  *
+  * \brief Generic lvalue expression of a coefficient-wise unary operator of a matrix or a vector
+  *
+  * \tparam ViewOp template functor implementing the view
+  * \tparam MatrixType the type of the matrix we are applying the unary operator
+  *
+  * This class represents a lvalue expression of a generic unary view operator of a matrix or a vector.
+  * It is the return type of real() and imag(), and most of the time this is the only way it is used.
+  *
+  * \sa MatrixBase::unaryViewExpr(const CustomUnaryOp &) const, class CwiseUnaryOp
+  */
+template<typename ViewOp, typename MatrixType>
+class CwiseUnaryView : public CwiseUnaryViewImpl<ViewOp, MatrixType, typename internal::traits<MatrixType>::StorageKind>
+{
+  public:
+
+    typedef typename CwiseUnaryViewImpl<ViewOp, MatrixType,typename internal::traits<MatrixType>::StorageKind>::Base Base;
+    EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseUnaryView)
+    typedef typename internal::ref_selector<MatrixType>::non_const_type MatrixTypeNested;
+    typedef typename internal::remove_all<MatrixType>::type NestedExpression;
+
+    explicit inline CwiseUnaryView(MatrixType& mat, const ViewOp& func = ViewOp())
+      : m_matrix(mat), m_functor(func) {}
+
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(CwiseUnaryView)
+
+    EIGEN_STRONG_INLINE Index rows() const { return m_matrix.rows(); }
+    EIGEN_STRONG_INLINE Index cols() const { return m_matrix.cols(); }
+
+    /** \returns the functor representing unary operation */
+    const ViewOp& functor() const { return m_functor; }
+
+    /** \returns the nested expression */
+    const typename internal::remove_all<MatrixTypeNested>::type&
+    nestedExpression() const { return m_matrix; }
+
+    /** \returns the nested expression */
+    typename internal::remove_reference<MatrixTypeNested>::type&
+    nestedExpression() { return m_matrix.const_cast_derived(); }
+
+  protected:
+    MatrixTypeNested m_matrix;
+    ViewOp m_functor;
+};
+
+// Generic API dispatcher
+template<typename ViewOp, typename XprType, typename StorageKind>
+class CwiseUnaryViewImpl
+  : public internal::generic_xpr_base<CwiseUnaryView<ViewOp, XprType> >::type
+{
+public:
+  typedef typename internal::generic_xpr_base<CwiseUnaryView<ViewOp, XprType> >::type Base;
+};
+
+template<typename ViewOp, typename MatrixType>
+class CwiseUnaryViewImpl<ViewOp,MatrixType,Dense>
+  : public internal::dense_xpr_base< CwiseUnaryView<ViewOp, MatrixType> >::type
+{
+  public:
+
+    typedef CwiseUnaryView<ViewOp, MatrixType> Derived;
+    typedef typename internal::dense_xpr_base< CwiseUnaryView<ViewOp, MatrixType> >::type Base;
+
+    EIGEN_DENSE_PUBLIC_INTERFACE(Derived)
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(CwiseUnaryViewImpl)
+    
+    EIGEN_DEVICE_FUNC inline Scalar* data() { return &(this->coeffRef(0)); }
+    EIGEN_DEVICE_FUNC inline const Scalar* data() const { return &(this->coeff(0)); }
+
+    EIGEN_DEVICE_FUNC inline Index innerStride() const
+    {
+      return derived().nestedExpression().innerStride() * sizeof(typename internal::traits<MatrixType>::Scalar) / sizeof(Scalar);
+    }
+
+    EIGEN_DEVICE_FUNC inline Index outerStride() const
+    {
+      return derived().nestedExpression().outerStride() * sizeof(typename internal::traits<MatrixType>::Scalar) / sizeof(Scalar);
+    }
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_CWISE_UNARY_VIEW_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/DenseBase.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/DenseBase.h
new file mode 100644
index 00000000..fd933eed
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/DenseBase.h
@@ -0,0 +1,615 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_DENSEBASE_H
+#define EIGEN_DENSEBASE_H
+
+namespace Eigen {
+
+namespace internal {
+  
+// The index type defined by EIGEN_DEFAULT_DENSE_INDEX_TYPE must be a signed type.
+// This dummy function simply aims at checking that at compile time.
+static inline void check_DenseIndex_is_signed() {
+  EIGEN_STATIC_ASSERT(NumTraits<DenseIndex>::IsSigned,THE_INDEX_TYPE_MUST_BE_A_SIGNED_TYPE); 
+}
+
+} // end namespace internal
+  
+/** \class DenseBase
+  * \ingroup Core_Module
+  *
+  * \brief Base class for all dense matrices, vectors, and arrays
+  *
+  * This class is the base that is inherited by all dense objects (matrix, vector, arrays,
+  * and related expression types). The common Eigen API for dense objects is contained in this class.
+  *
+  * \tparam Derived is the derived type, e.g., a matrix type or an expression.
+  *
+  * This class can be extended with the help of the plugin mechanism described on the page
+  * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_DENSEBASE_PLUGIN.
+  *
+  * \sa \blank \ref TopicClassHierarchy
+  */
+template<typename Derived> class DenseBase
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+  : public DenseCoeffsBase<Derived>
+#else
+  : public DenseCoeffsBase<Derived,DirectWriteAccessors>
+#endif // not EIGEN_PARSED_BY_DOXYGEN
+{
+  public:
+
+    /** Inner iterator type to iterate over the coefficients of a row or column.
+      * \sa class InnerIterator
+      */
+    typedef Eigen::InnerIterator<Derived> InnerIterator;
+
+    typedef typename internal::traits<Derived>::StorageKind StorageKind;
+
+    /**
+      * \brief The type used to store indices
+      * \details This typedef is relevant for types that store multiple indices such as
+      *          PermutationMatrix or Transpositions, otherwise it defaults to Eigen::Index
+      * \sa \blank \ref TopicPreprocessorDirectives, Eigen::Index, SparseMatrixBase.
+     */
+    typedef typename internal::traits<Derived>::StorageIndex StorageIndex;
+
+    /** The numeric type of the expression' coefficients, e.g. float, double, int or std::complex<float>, etc. */
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    
+    /** The numeric type of the expression' coefficients, e.g. float, double, int or std::complex<float>, etc.
+      *
+      * It is an alias for the Scalar type */
+    typedef Scalar value_type;
+    
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef DenseCoeffsBase<Derived> Base;
+
+    using Base::derived;
+    using Base::const_cast_derived;
+    using Base::rows;
+    using Base::cols;
+    using Base::size;
+    using Base::rowIndexByOuterInner;
+    using Base::colIndexByOuterInner;
+    using Base::coeff;
+    using Base::coeffByOuterInner;
+    using Base::operator();
+    using Base::operator[];
+    using Base::x;
+    using Base::y;
+    using Base::z;
+    using Base::w;
+    using Base::stride;
+    using Base::innerStride;
+    using Base::outerStride;
+    using Base::rowStride;
+    using Base::colStride;
+    typedef typename Base::CoeffReturnType CoeffReturnType;
+
+    enum {
+
+      RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
+        /**< The number of rows at compile-time. This is just a copy of the value provided
+          * by the \a Derived type. If a value is not known at compile-time,
+          * it is set to the \a Dynamic constant.
+          * \sa MatrixBase::rows(), MatrixBase::cols(), ColsAtCompileTime, SizeAtCompileTime */
+
+      ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
+        /**< The number of columns at compile-time. This is just a copy of the value provided
+          * by the \a Derived type. If a value is not known at compile-time,
+          * it is set to the \a Dynamic constant.
+          * \sa MatrixBase::rows(), MatrixBase::cols(), RowsAtCompileTime, SizeAtCompileTime */
+
+
+      SizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::RowsAtCompileTime,
+                                                   internal::traits<Derived>::ColsAtCompileTime>::ret),
+        /**< This is equal to the number of coefficients, i.e. the number of
+          * rows times the number of columns, or to \a Dynamic if this is not
+          * known at compile-time. \sa RowsAtCompileTime, ColsAtCompileTime */
+
+      MaxRowsAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime,
+        /**< This value is equal to the maximum possible number of rows that this expression
+          * might have. If this expression might have an arbitrarily high number of rows,
+          * this value is set to \a Dynamic.
+          *
+          * This value is useful to know when evaluating an expression, in order to determine
+          * whether it is possible to avoid doing a dynamic memory allocation.
+          *
+          * \sa RowsAtCompileTime, MaxColsAtCompileTime, MaxSizeAtCompileTime
+          */
+
+      MaxColsAtCompileTime = internal::traits<Derived>::MaxColsAtCompileTime,
+        /**< This value is equal to the maximum possible number of columns that this expression
+          * might have. If this expression might have an arbitrarily high number of columns,
+          * this value is set to \a Dynamic.
+          *
+          * This value is useful to know when evaluating an expression, in order to determine
+          * whether it is possible to avoid doing a dynamic memory allocation.
+          *
+          * \sa ColsAtCompileTime, MaxRowsAtCompileTime, MaxSizeAtCompileTime
+          */
+
+      MaxSizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::MaxRowsAtCompileTime,
+                                                      internal::traits<Derived>::MaxColsAtCompileTime>::ret),
+        /**< This value is equal to the maximum possible number of coefficients that this expression
+          * might have. If this expression might have an arbitrarily high number of coefficients,
+          * this value is set to \a Dynamic.
+          *
+          * This value is useful to know when evaluating an expression, in order to determine
+          * whether it is possible to avoid doing a dynamic memory allocation.
+          *
+          * \sa SizeAtCompileTime, MaxRowsAtCompileTime, MaxColsAtCompileTime
+          */
+
+      IsVectorAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime == 1
+                           || internal::traits<Derived>::MaxColsAtCompileTime == 1,
+        /**< This is set to true if either the number of rows or the number of
+          * columns is known at compile-time to be equal to 1. Indeed, in that case,
+          * we are dealing with a column-vector (if there is only one column) or with
+          * a row-vector (if there is only one row). */
+
+      Flags = internal::traits<Derived>::Flags,
+        /**< This stores expression \ref flags flags which may or may not be inherited by new expressions
+          * constructed from this one. See the \ref flags "list of flags".
+          */
+
+      IsRowMajor = int(Flags) & RowMajorBit, /**< True if this expression has row-major storage order. */
+
+      InnerSizeAtCompileTime = int(IsVectorAtCompileTime) ? int(SizeAtCompileTime)
+                             : int(IsRowMajor) ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
+
+      InnerStrideAtCompileTime = internal::inner_stride_at_compile_time<Derived>::ret,
+      OuterStrideAtCompileTime = internal::outer_stride_at_compile_time<Derived>::ret
+    };
+    
+    typedef typename internal::find_best_packet<Scalar,SizeAtCompileTime>::type PacketScalar;
+
+    enum { IsPlainObjectBase = 0 };
+    
+    /** The plain matrix type corresponding to this expression.
+      * \sa PlainObject */
+    typedef Matrix<typename internal::traits<Derived>::Scalar,
+                internal::traits<Derived>::RowsAtCompileTime,
+                internal::traits<Derived>::ColsAtCompileTime,
+                AutoAlign | (internal::traits<Derived>::Flags&RowMajorBit ? RowMajor : ColMajor),
+                internal::traits<Derived>::MaxRowsAtCompileTime,
+                internal::traits<Derived>::MaxColsAtCompileTime
+          > PlainMatrix;
+    
+    /** The plain array type corresponding to this expression.
+      * \sa PlainObject */
+    typedef Array<typename internal::traits<Derived>::Scalar,
+                internal::traits<Derived>::RowsAtCompileTime,
+                internal::traits<Derived>::ColsAtCompileTime,
+                AutoAlign | (internal::traits<Derived>::Flags&RowMajorBit ? RowMajor : ColMajor),
+                internal::traits<Derived>::MaxRowsAtCompileTime,
+                internal::traits<Derived>::MaxColsAtCompileTime
+          > PlainArray;
+
+    /** \brief The plain matrix or array type corresponding to this expression.
+      *
+      * This is not necessarily exactly the return type of eval(). In the case of plain matrices,
+      * the return type of eval() is a const reference to a matrix, not a matrix! It is however guaranteed
+      * that the return type of eval() is either PlainObject or const PlainObject&.
+      */
+    typedef typename internal::conditional<internal::is_same<typename internal::traits<Derived>::XprKind,MatrixXpr >::value,
+                                 PlainMatrix, PlainArray>::type PlainObject;
+
+    /** \returns the number of nonzero coefficients which is in practice the number
+      * of stored coefficients. */
+    EIGEN_DEVICE_FUNC
+    inline Index nonZeros() const { return size(); }
+
+    /** \returns the outer size.
+      *
+      * \note For a vector, this returns just 1. For a matrix (non-vector), this is the major dimension
+      * with respect to the \ref TopicStorageOrders "storage order", i.e., the number of columns for a
+      * column-major matrix, and the number of rows for a row-major matrix. */
+    EIGEN_DEVICE_FUNC
+    Index outerSize() const
+    {
+      return IsVectorAtCompileTime ? 1
+           : int(IsRowMajor) ? this->rows() : this->cols();
+    }
+
+    /** \returns the inner size.
+      *
+      * \note For a vector, this is just the size. For a matrix (non-vector), this is the minor dimension
+      * with respect to the \ref TopicStorageOrders "storage order", i.e., the number of rows for a 
+      * column-major matrix, and the number of columns for a row-major matrix. */
+    EIGEN_DEVICE_FUNC
+    Index innerSize() const
+    {
+      return IsVectorAtCompileTime ? this->size()
+           : int(IsRowMajor) ? this->cols() : this->rows();
+    }
+
+    /** Only plain matrices/arrays, not expressions, may be resized; therefore the only useful resize methods are
+      * Matrix::resize() and Array::resize(). The present method only asserts that the new size equals the old size, and does
+      * nothing else.
+      */
+    EIGEN_DEVICE_FUNC
+    void resize(Index newSize)
+    {
+      EIGEN_ONLY_USED_FOR_DEBUG(newSize);
+      eigen_assert(newSize == this->size()
+                && "DenseBase::resize() does not actually allow to resize.");
+    }
+    /** Only plain matrices/arrays, not expressions, may be resized; therefore the only useful resize methods are
+      * Matrix::resize() and Array::resize(). The present method only asserts that the new size equals the old size, and does
+      * nothing else.
+      */
+    EIGEN_DEVICE_FUNC
+    void resize(Index rows, Index cols)
+    {
+      EIGEN_ONLY_USED_FOR_DEBUG(rows);
+      EIGEN_ONLY_USED_FOR_DEBUG(cols);
+      eigen_assert(rows == this->rows() && cols == this->cols()
+                && "DenseBase::resize() does not actually allow to resize.");
+    }
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** \internal Represents a matrix with all coefficients equal to one another*/
+    typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,PlainObject> ConstantReturnType;
+    /** \internal \deprecated Represents a vector with linearly spaced coefficients that allows sequential access only. */
+    typedef CwiseNullaryOp<internal::linspaced_op<Scalar,PacketScalar>,PlainObject> SequentialLinSpacedReturnType;
+    /** \internal Represents a vector with linearly spaced coefficients that allows random access. */
+    typedef CwiseNullaryOp<internal::linspaced_op<Scalar,PacketScalar>,PlainObject> RandomAccessLinSpacedReturnType;
+    /** \internal the return type of MatrixBase::eigenvalues() */
+    typedef Matrix<typename NumTraits<typename internal::traits<Derived>::Scalar>::Real, internal::traits<Derived>::ColsAtCompileTime, 1> EigenvaluesReturnType;
+
+#endif // not EIGEN_PARSED_BY_DOXYGEN
+
+    /** Copies \a other into *this. \returns a reference to *this. */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator=(const DenseBase<OtherDerived>& other);
+
+    /** Special case of the template operator=, in order to prevent the compiler
+      * from generating a default operator= (issue hit with g++ 4.1)
+      */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator=(const DenseBase& other);
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    Derived& operator=(const EigenBase<OtherDerived> &other);
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    Derived& operator+=(const EigenBase<OtherDerived> &other);
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    Derived& operator-=(const EigenBase<OtherDerived> &other);
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    Derived& operator=(const ReturnByValue<OtherDerived>& func);
+
+    /** \internal
+      * Copies \a other into *this without evaluating other. \returns a reference to *this.
+      * \deprecated */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    Derived& lazyAssign(const DenseBase<OtherDerived>& other);
+
+    EIGEN_DEVICE_FUNC
+    CommaInitializer<Derived> operator<< (const Scalar& s);
+
+    /** \deprecated it now returns \c *this */
+    template<unsigned int Added,unsigned int Removed>
+    EIGEN_DEPRECATED
+    const Derived& flagged() const
+    { return derived(); }
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    CommaInitializer<Derived> operator<< (const DenseBase<OtherDerived>& other);
+
+    typedef Transpose<Derived> TransposeReturnType;
+    EIGEN_DEVICE_FUNC
+    TransposeReturnType transpose();
+    typedef typename internal::add_const<Transpose<const Derived> >::type ConstTransposeReturnType;
+    EIGEN_DEVICE_FUNC
+    ConstTransposeReturnType transpose() const;
+    EIGEN_DEVICE_FUNC
+    void transposeInPlace();
+
+    EIGEN_DEVICE_FUNC static const ConstantReturnType
+    Constant(Index rows, Index cols, const Scalar& value);
+    EIGEN_DEVICE_FUNC static const ConstantReturnType
+    Constant(Index size, const Scalar& value);
+    EIGEN_DEVICE_FUNC static const ConstantReturnType
+    Constant(const Scalar& value);
+
+    EIGEN_DEVICE_FUNC static const SequentialLinSpacedReturnType
+    LinSpaced(Sequential_t, Index size, const Scalar& low, const Scalar& high);
+    EIGEN_DEVICE_FUNC static const RandomAccessLinSpacedReturnType
+    LinSpaced(Index size, const Scalar& low, const Scalar& high);
+    EIGEN_DEVICE_FUNC static const SequentialLinSpacedReturnType
+    LinSpaced(Sequential_t, const Scalar& low, const Scalar& high);
+    EIGEN_DEVICE_FUNC static const RandomAccessLinSpacedReturnType
+    LinSpaced(const Scalar& low, const Scalar& high);
+
+    template<typename CustomNullaryOp> EIGEN_DEVICE_FUNC
+    static const CwiseNullaryOp<CustomNullaryOp, PlainObject>
+    NullaryExpr(Index rows, Index cols, const CustomNullaryOp& func);
+    template<typename CustomNullaryOp> EIGEN_DEVICE_FUNC
+    static const CwiseNullaryOp<CustomNullaryOp, PlainObject>
+    NullaryExpr(Index size, const CustomNullaryOp& func);
+    template<typename CustomNullaryOp> EIGEN_DEVICE_FUNC
+    static const CwiseNullaryOp<CustomNullaryOp, PlainObject>
+    NullaryExpr(const CustomNullaryOp& func);
+
+    EIGEN_DEVICE_FUNC static const ConstantReturnType Zero(Index rows, Index cols);
+    EIGEN_DEVICE_FUNC static const ConstantReturnType Zero(Index size);
+    EIGEN_DEVICE_FUNC static const ConstantReturnType Zero();
+    EIGEN_DEVICE_FUNC static const ConstantReturnType Ones(Index rows, Index cols);
+    EIGEN_DEVICE_FUNC static const ConstantReturnType Ones(Index size);
+    EIGEN_DEVICE_FUNC static const ConstantReturnType Ones();
+
+    EIGEN_DEVICE_FUNC void fill(const Scalar& value);
+    EIGEN_DEVICE_FUNC Derived& setConstant(const Scalar& value);
+    EIGEN_DEVICE_FUNC Derived& setLinSpaced(Index size, const Scalar& low, const Scalar& high);
+    EIGEN_DEVICE_FUNC Derived& setLinSpaced(const Scalar& low, const Scalar& high);
+    EIGEN_DEVICE_FUNC Derived& setZero();
+    EIGEN_DEVICE_FUNC Derived& setOnes();
+    EIGEN_DEVICE_FUNC Derived& setRandom();
+
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC
+    bool isApprox(const DenseBase<OtherDerived>& other,
+                  const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+    EIGEN_DEVICE_FUNC 
+    bool isMuchSmallerThan(const RealScalar& other,
+                           const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC
+    bool isMuchSmallerThan(const DenseBase<OtherDerived>& other,
+                           const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+
+    EIGEN_DEVICE_FUNC bool isApproxToConstant(const Scalar& value, const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+    EIGEN_DEVICE_FUNC bool isConstant(const Scalar& value, const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+    EIGEN_DEVICE_FUNC bool isZero(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+    EIGEN_DEVICE_FUNC bool isOnes(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+    
+    inline bool hasNaN() const;
+    inline bool allFinite() const;
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator*=(const Scalar& other);
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator/=(const Scalar& other);
+
+    typedef typename internal::add_const_on_value_type<typename internal::eval<Derived>::type>::type EvalReturnType;
+    /** \returns the matrix or vector obtained by evaluating this expression.
+      *
+      * Notice that in the case of a plain matrix or vector (not an expression) this function just returns
+      * a const reference, in order to avoid a useless copy.
+      * 
+      * \warning Be carefull with eval() and the auto C++ keyword, as detailed in this \link TopicPitfalls_auto_keyword page \endlink.
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE EvalReturnType eval() const
+    {
+      // Even though MSVC does not honor strong inlining when the return type
+      // is a dynamic matrix, we desperately need strong inlining for fixed
+      // size types on MSVC.
+      return typename internal::eval<Derived>::type(derived());
+    }
+    
+    /** swaps *this with the expression \a other.
+      *
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    void swap(const DenseBase<OtherDerived>& other)
+    {
+      EIGEN_STATIC_ASSERT(!OtherDerived::IsPlainObjectBase,THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY);
+      eigen_assert(rows()==other.rows() && cols()==other.cols());
+      call_assignment(derived(), other.const_cast_derived(), internal::swap_assign_op<Scalar>());
+    }
+
+    /** swaps *this with the matrix or array \a other.
+      *
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    void swap(PlainObjectBase<OtherDerived>& other)
+    {
+      eigen_assert(rows()==other.rows() && cols()==other.cols());
+      call_assignment(derived(), other.derived(), internal::swap_assign_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC inline const NestByValue<Derived> nestByValue() const;
+    EIGEN_DEVICE_FUNC inline const ForceAlignedAccess<Derived> forceAlignedAccess() const;
+    EIGEN_DEVICE_FUNC inline ForceAlignedAccess<Derived> forceAlignedAccess();
+    template<bool Enable> EIGEN_DEVICE_FUNC
+    inline const typename internal::conditional<Enable,ForceAlignedAccess<Derived>,Derived&>::type forceAlignedAccessIf() const;
+    template<bool Enable> EIGEN_DEVICE_FUNC
+    inline typename internal::conditional<Enable,ForceAlignedAccess<Derived>,Derived&>::type forceAlignedAccessIf();
+
+    EIGEN_DEVICE_FUNC Scalar sum() const;
+    EIGEN_DEVICE_FUNC Scalar mean() const;
+    EIGEN_DEVICE_FUNC Scalar trace() const;
+
+    EIGEN_DEVICE_FUNC Scalar prod() const;
+
+    EIGEN_DEVICE_FUNC typename internal::traits<Derived>::Scalar minCoeff() const;
+    EIGEN_DEVICE_FUNC typename internal::traits<Derived>::Scalar maxCoeff() const;
+
+    template<typename IndexType> EIGEN_DEVICE_FUNC
+    typename internal::traits<Derived>::Scalar minCoeff(IndexType* row, IndexType* col) const;
+    template<typename IndexType> EIGEN_DEVICE_FUNC
+    typename internal::traits<Derived>::Scalar maxCoeff(IndexType* row, IndexType* col) const;
+    template<typename IndexType> EIGEN_DEVICE_FUNC
+    typename internal::traits<Derived>::Scalar minCoeff(IndexType* index) const;
+    template<typename IndexType> EIGEN_DEVICE_FUNC
+    typename internal::traits<Derived>::Scalar maxCoeff(IndexType* index) const;
+
+    template<typename BinaryOp>
+    EIGEN_DEVICE_FUNC
+    Scalar redux(const BinaryOp& func) const;
+
+    template<typename Visitor>
+    EIGEN_DEVICE_FUNC
+    void visit(Visitor& func) const;
+
+    /** \returns a WithFormat proxy object allowing to print a matrix the with given
+      * format \a fmt.
+      *
+      * See class IOFormat for some examples.
+      *
+      * \sa class IOFormat, class WithFormat
+      */
+    inline const WithFormat<Derived> format(const IOFormat& fmt) const
+    {
+      return WithFormat<Derived>(derived(), fmt);
+    }
+
+    /** \returns the unique coefficient of a 1x1 expression */
+    EIGEN_DEVICE_FUNC
+    CoeffReturnType value() const
+    {
+      EIGEN_STATIC_ASSERT_SIZE_1x1(Derived)
+      eigen_assert(this->rows() == 1 && this->cols() == 1);
+      return derived().coeff(0,0);
+    }
+
+    EIGEN_DEVICE_FUNC bool all() const;
+    EIGEN_DEVICE_FUNC bool any() const;
+    EIGEN_DEVICE_FUNC Index count() const;
+
+    typedef VectorwiseOp<Derived, Horizontal> RowwiseReturnType;
+    typedef const VectorwiseOp<const Derived, Horizontal> ConstRowwiseReturnType;
+    typedef VectorwiseOp<Derived, Vertical> ColwiseReturnType;
+    typedef const VectorwiseOp<const Derived, Vertical> ConstColwiseReturnType;
+
+    /** \returns a VectorwiseOp wrapper of *this providing additional partial reduction operations
+    *
+    * Example: \include MatrixBase_rowwise.cpp
+    * Output: \verbinclude MatrixBase_rowwise.out
+    *
+    * \sa colwise(), class VectorwiseOp, \ref TutorialReductionsVisitorsBroadcasting
+    */
+    //Code moved here due to a CUDA compiler bug
+    EIGEN_DEVICE_FUNC inline ConstRowwiseReturnType rowwise() const {
+      return ConstRowwiseReturnType(derived());
+    }
+    EIGEN_DEVICE_FUNC RowwiseReturnType rowwise();
+
+    /** \returns a VectorwiseOp wrapper of *this providing additional partial reduction operations
+    *
+    * Example: \include MatrixBase_colwise.cpp
+    * Output: \verbinclude MatrixBase_colwise.out
+    *
+    * \sa rowwise(), class VectorwiseOp, \ref TutorialReductionsVisitorsBroadcasting
+    */
+    EIGEN_DEVICE_FUNC inline ConstColwiseReturnType colwise() const {
+      return ConstColwiseReturnType(derived());
+    }
+    EIGEN_DEVICE_FUNC ColwiseReturnType colwise();
+
+    typedef CwiseNullaryOp<internal::scalar_random_op<Scalar>,PlainObject> RandomReturnType;
+    static const RandomReturnType Random(Index rows, Index cols);
+    static const RandomReturnType Random(Index size);
+    static const RandomReturnType Random();
+
+    template<typename ThenDerived,typename ElseDerived>
+    const Select<Derived,ThenDerived,ElseDerived>
+    select(const DenseBase<ThenDerived>& thenMatrix,
+           const DenseBase<ElseDerived>& elseMatrix) const;
+
+    template<typename ThenDerived>
+    inline const Select<Derived,ThenDerived, typename ThenDerived::ConstantReturnType>
+    select(const DenseBase<ThenDerived>& thenMatrix, const typename ThenDerived::Scalar& elseScalar) const;
+
+    template<typename ElseDerived>
+    inline const Select<Derived, typename ElseDerived::ConstantReturnType, ElseDerived >
+    select(const typename ElseDerived::Scalar& thenScalar, const DenseBase<ElseDerived>& elseMatrix) const;
+
+    template<int p> RealScalar lpNorm() const;
+
+    template<int RowFactor, int ColFactor>
+    EIGEN_DEVICE_FUNC
+    const Replicate<Derived,RowFactor,ColFactor> replicate() const;
+    /**
+    * \return an expression of the replication of \c *this
+    *
+    * Example: \include MatrixBase_replicate_int_int.cpp
+    * Output: \verbinclude MatrixBase_replicate_int_int.out
+    *
+    * \sa VectorwiseOp::replicate(), DenseBase::replicate<int,int>(), class Replicate
+    */
+    //Code moved here due to a CUDA compiler bug
+    EIGEN_DEVICE_FUNC
+    const Replicate<Derived, Dynamic, Dynamic> replicate(Index rowFactor, Index colFactor) const
+    {
+      return Replicate<Derived, Dynamic, Dynamic>(derived(), rowFactor, colFactor);
+    }
+
+    typedef Reverse<Derived, BothDirections> ReverseReturnType;
+    typedef const Reverse<const Derived, BothDirections> ConstReverseReturnType;
+    EIGEN_DEVICE_FUNC ReverseReturnType reverse();
+    /** This is the const version of reverse(). */
+    //Code moved here due to a CUDA compiler bug
+    EIGEN_DEVICE_FUNC ConstReverseReturnType reverse() const
+    {
+      return ConstReverseReturnType(derived());
+    }
+    EIGEN_DEVICE_FUNC void reverseInPlace();
+
+#define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::DenseBase
+#define EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+#define EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(COND)
+#define EIGEN_DOC_UNARY_ADDONS(X,Y)
+#   include "../plugins/CommonCwiseUnaryOps.h"
+#   include "../plugins/BlockMethods.h"
+#   include "../plugins/IndexedViewMethods.h"
+#   ifdef EIGEN_DENSEBASE_PLUGIN
+#     include EIGEN_DENSEBASE_PLUGIN
+#   endif
+#undef EIGEN_CURRENT_STORAGE_BASE_CLASS
+#undef EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+#undef EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF
+#undef EIGEN_DOC_UNARY_ADDONS
+
+    // disable the use of evalTo for dense objects with a nice compilation error
+    template<typename Dest>
+    EIGEN_DEVICE_FUNC
+    inline void evalTo(Dest& ) const
+    {
+      EIGEN_STATIC_ASSERT((internal::is_same<Dest,void>::value),THE_EVAL_EVALTO_FUNCTION_SHOULD_NEVER_BE_CALLED_FOR_DENSE_OBJECTS);
+    }
+
+  protected:
+    /** Default constructor. Do nothing. */
+    EIGEN_DEVICE_FUNC DenseBase()
+    {
+      /* Just checks for self-consistency of the flags.
+       * Only do it when debugging Eigen, as this borders on paranoiac and could slow compilation down
+       */
+#ifdef EIGEN_INTERNAL_DEBUGGING
+      EIGEN_STATIC_ASSERT((EIGEN_IMPLIES(MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1, int(IsRowMajor))
+                        && EIGEN_IMPLIES(MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1, int(!IsRowMajor))),
+                          INVALID_STORAGE_ORDER_FOR_THIS_VECTOR_EXPRESSION)
+#endif
+    }
+
+  private:
+    EIGEN_DEVICE_FUNC explicit DenseBase(int);
+    EIGEN_DEVICE_FUNC DenseBase(int,int);
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC explicit DenseBase(const DenseBase<OtherDerived>&);
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_DENSEBASE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/DenseCoeffsBase.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/DenseCoeffsBase.h
new file mode 100644
index 00000000..c4af48ab
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/DenseCoeffsBase.h
@@ -0,0 +1,681 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_DENSECOEFFSBASE_H
+#define EIGEN_DENSECOEFFSBASE_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename T> struct add_const_on_value_type_if_arithmetic
+{
+  typedef typename conditional<is_arithmetic<T>::value, T, typename add_const_on_value_type<T>::type>::type type;
+};
+}
+
+/** \brief Base class providing read-only coefficient access to matrices and arrays.
+  * \ingroup Core_Module
+  * \tparam Derived Type of the derived class
+  * \tparam #ReadOnlyAccessors Constant indicating read-only access
+  *
+  * This class defines the \c operator() \c const function and friends, which can be used to read specific
+  * entries of a matrix or array.
+  * 
+  * \sa DenseCoeffsBase<Derived, WriteAccessors>, DenseCoeffsBase<Derived, DirectAccessors>,
+  *     \ref TopicClassHierarchy
+  */
+template<typename Derived>
+class DenseCoeffsBase<Derived,ReadOnlyAccessors> : public EigenBase<Derived>
+{
+  public:
+    typedef typename internal::traits<Derived>::StorageKind StorageKind;
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    typedef typename internal::packet_traits<Scalar>::type PacketScalar;
+
+    // Explanation for this CoeffReturnType typedef.
+    // - This is the return type of the coeff() method.
+    // - The LvalueBit means exactly that we can offer a coeffRef() method, which means exactly that we can get references
+    // to coeffs, which means exactly that we can have coeff() return a const reference (as opposed to returning a value).
+    // - The is_artihmetic check is required since "const int", "const double", etc. will cause warnings on some systems
+    // while the declaration of "const T", where T is a non arithmetic type does not. Always returning "const Scalar&" is
+    // not possible, since the underlying expressions might not offer a valid address the reference could be referring to.
+    typedef typename internal::conditional<bool(internal::traits<Derived>::Flags&LvalueBit),
+                         const Scalar&,
+                         typename internal::conditional<internal::is_arithmetic<Scalar>::value, Scalar, const Scalar>::type
+                     >::type CoeffReturnType;
+
+    typedef typename internal::add_const_on_value_type_if_arithmetic<
+                         typename internal::packet_traits<Scalar>::type
+                     >::type PacketReturnType;
+
+    typedef EigenBase<Derived> Base;
+    using Base::rows;
+    using Base::cols;
+    using Base::size;
+    using Base::derived;
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Index rowIndexByOuterInner(Index outer, Index inner) const
+    {
+      return int(Derived::RowsAtCompileTime) == 1 ? 0
+          : int(Derived::ColsAtCompileTime) == 1 ? inner
+          : int(Derived::Flags)&RowMajorBit ? outer
+          : inner;
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Index colIndexByOuterInner(Index outer, Index inner) const
+    {
+      return int(Derived::ColsAtCompileTime) == 1 ? 0
+          : int(Derived::RowsAtCompileTime) == 1 ? inner
+          : int(Derived::Flags)&RowMajorBit ? inner
+          : outer;
+    }
+
+    /** Short version: don't use this function, use
+      * \link operator()(Index,Index) const \endlink instead.
+      *
+      * Long version: this function is similar to
+      * \link operator()(Index,Index) const \endlink, but without the assertion.
+      * Use this for limiting the performance cost of debugging code when doing
+      * repeated coefficient access. Only use this when it is guaranteed that the
+      * parameters \a row and \a col are in range.
+      *
+      * If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this
+      * function equivalent to \link operator()(Index,Index) const \endlink.
+      *
+      * \sa operator()(Index,Index) const, coeffRef(Index,Index), coeff(Index) const
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const
+    {
+      eigen_internal_assert(row >= 0 && row < rows()
+                         && col >= 0 && col < cols());
+      return internal::evaluator<Derived>(derived()).coeff(row,col);
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CoeffReturnType coeffByOuterInner(Index outer, Index inner) const
+    {
+      return coeff(rowIndexByOuterInner(outer, inner),
+                   colIndexByOuterInner(outer, inner));
+    }
+
+    /** \returns the coefficient at given the given row and column.
+      *
+      * \sa operator()(Index,Index), operator[](Index)
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CoeffReturnType operator()(Index row, Index col) const
+    {
+      eigen_assert(row >= 0 && row < rows()
+          && col >= 0 && col < cols());
+      return coeff(row, col);
+    }
+
+    /** Short version: don't use this function, use
+      * \link operator[](Index) const \endlink instead.
+      *
+      * Long version: this function is similar to
+      * \link operator[](Index) const \endlink, but without the assertion.
+      * Use this for limiting the performance cost of debugging code when doing
+      * repeated coefficient access. Only use this when it is guaranteed that the
+      * parameter \a index is in range.
+      *
+      * If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this
+      * function equivalent to \link operator[](Index) const \endlink.
+      *
+      * \sa operator[](Index) const, coeffRef(Index), coeff(Index,Index) const
+      */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CoeffReturnType
+    coeff(Index index) const
+    {
+      EIGEN_STATIC_ASSERT(internal::evaluator<Derived>::Flags & LinearAccessBit,
+                          THIS_COEFFICIENT_ACCESSOR_TAKING_ONE_ACCESS_IS_ONLY_FOR_EXPRESSIONS_ALLOWING_LINEAR_ACCESS)
+      eigen_internal_assert(index >= 0 && index < size());
+      return internal::evaluator<Derived>(derived()).coeff(index);
+    }
+
+
+    /** \returns the coefficient at given index.
+      *
+      * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit.
+      *
+      * \sa operator[](Index), operator()(Index,Index) const, x() const, y() const,
+      * z() const, w() const
+      */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CoeffReturnType
+    operator[](Index index) const
+    {
+      EIGEN_STATIC_ASSERT(Derived::IsVectorAtCompileTime,
+                          THE_BRACKET_OPERATOR_IS_ONLY_FOR_VECTORS__USE_THE_PARENTHESIS_OPERATOR_INSTEAD)
+      eigen_assert(index >= 0 && index < size());
+      return coeff(index);
+    }
+
+    /** \returns the coefficient at given index.
+      *
+      * This is synonymous to operator[](Index) const.
+      *
+      * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit.
+      *
+      * \sa operator[](Index), operator()(Index,Index) const, x() const, y() const,
+      * z() const, w() const
+      */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CoeffReturnType
+    operator()(Index index) const
+    {
+      eigen_assert(index >= 0 && index < size());
+      return coeff(index);
+    }
+
+    /** equivalent to operator[](0).  */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CoeffReturnType
+    x() const { return (*this)[0]; }
+
+    /** equivalent to operator[](1).  */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CoeffReturnType
+    y() const
+    {
+      EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=2, OUT_OF_RANGE_ACCESS);
+      return (*this)[1];
+    }
+
+    /** equivalent to operator[](2).  */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CoeffReturnType
+    z() const
+    {
+      EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=3, OUT_OF_RANGE_ACCESS);
+      return (*this)[2];
+    }
+
+    /** equivalent to operator[](3).  */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CoeffReturnType
+    w() const
+    {
+      EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=4, OUT_OF_RANGE_ACCESS);
+      return (*this)[3];
+    }
+
+    /** \internal
+      * \returns the packet of coefficients starting at the given row and column. It is your responsibility
+      * to ensure that a packet really starts there. This method is only available on expressions having the
+      * PacketAccessBit.
+      *
+      * The \a LoadMode parameter may have the value \a #Aligned or \a #Unaligned. Its effect is to select
+      * the appropriate vectorization instruction. Aligned access is faster, but is only possible for packets
+      * starting at an address which is a multiple of the packet size.
+      */
+
+    template<int LoadMode>
+    EIGEN_STRONG_INLINE PacketReturnType packet(Index row, Index col) const
+    {
+      typedef typename internal::packet_traits<Scalar>::type DefaultPacketType;
+      eigen_internal_assert(row >= 0 && row < rows() && col >= 0 && col < cols());
+      return internal::evaluator<Derived>(derived()).template packet<LoadMode,DefaultPacketType>(row,col);
+    }
+
+
+    /** \internal */
+    template<int LoadMode>
+    EIGEN_STRONG_INLINE PacketReturnType packetByOuterInner(Index outer, Index inner) const
+    {
+      return packet<LoadMode>(rowIndexByOuterInner(outer, inner),
+                              colIndexByOuterInner(outer, inner));
+    }
+
+    /** \internal
+      * \returns the packet of coefficients starting at the given index. It is your responsibility
+      * to ensure that a packet really starts there. This method is only available on expressions having the
+      * PacketAccessBit and the LinearAccessBit.
+      *
+      * The \a LoadMode parameter may have the value \a #Aligned or \a #Unaligned. Its effect is to select
+      * the appropriate vectorization instruction. Aligned access is faster, but is only possible for packets
+      * starting at an address which is a multiple of the packet size.
+      */
+
+    template<int LoadMode>
+    EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const
+    {
+      EIGEN_STATIC_ASSERT(internal::evaluator<Derived>::Flags & LinearAccessBit,
+                          THIS_COEFFICIENT_ACCESSOR_TAKING_ONE_ACCESS_IS_ONLY_FOR_EXPRESSIONS_ALLOWING_LINEAR_ACCESS)
+      typedef typename internal::packet_traits<Scalar>::type DefaultPacketType;
+      eigen_internal_assert(index >= 0 && index < size());
+      return internal::evaluator<Derived>(derived()).template packet<LoadMode,DefaultPacketType>(index);
+    }
+
+  protected:
+    // explanation: DenseBase is doing "using ..." on the methods from DenseCoeffsBase.
+    // But some methods are only available in the DirectAccess case.
+    // So we add dummy methods here with these names, so that "using... " doesn't fail.
+    // It's not private so that the child class DenseBase can access them, and it's not public
+    // either since it's an implementation detail, so has to be protected.
+    void coeffRef();
+    void coeffRefByOuterInner();
+    void writePacket();
+    void writePacketByOuterInner();
+    void copyCoeff();
+    void copyCoeffByOuterInner();
+    void copyPacket();
+    void copyPacketByOuterInner();
+    void stride();
+    void innerStride();
+    void outerStride();
+    void rowStride();
+    void colStride();
+};
+
+/** \brief Base class providing read/write coefficient access to matrices and arrays.
+  * \ingroup Core_Module
+  * \tparam Derived Type of the derived class
+  * \tparam #WriteAccessors Constant indicating read/write access
+  *
+  * This class defines the non-const \c operator() function and friends, which can be used to write specific
+  * entries of a matrix or array. This class inherits DenseCoeffsBase<Derived, ReadOnlyAccessors> which
+  * defines the const variant for reading specific entries.
+  * 
+  * \sa DenseCoeffsBase<Derived, DirectAccessors>, \ref TopicClassHierarchy
+  */
+template<typename Derived>
+class DenseCoeffsBase<Derived, WriteAccessors> : public DenseCoeffsBase<Derived, ReadOnlyAccessors>
+{
+  public:
+
+    typedef DenseCoeffsBase<Derived, ReadOnlyAccessors> Base;
+
+    typedef typename internal::traits<Derived>::StorageKind StorageKind;
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    typedef typename internal::packet_traits<Scalar>::type PacketScalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    using Base::coeff;
+    using Base::rows;
+    using Base::cols;
+    using Base::size;
+    using Base::derived;
+    using Base::rowIndexByOuterInner;
+    using Base::colIndexByOuterInner;
+    using Base::operator[];
+    using Base::operator();
+    using Base::x;
+    using Base::y;
+    using Base::z;
+    using Base::w;
+
+    /** Short version: don't use this function, use
+      * \link operator()(Index,Index) \endlink instead.
+      *
+      * Long version: this function is similar to
+      * \link operator()(Index,Index) \endlink, but without the assertion.
+      * Use this for limiting the performance cost of debugging code when doing
+      * repeated coefficient access. Only use this when it is guaranteed that the
+      * parameters \a row and \a col are in range.
+      *
+      * If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this
+      * function equivalent to \link operator()(Index,Index) \endlink.
+      *
+      * \sa operator()(Index,Index), coeff(Index, Index) const, coeffRef(Index)
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar& coeffRef(Index row, Index col)
+    {
+      eigen_internal_assert(row >= 0 && row < rows()
+                         && col >= 0 && col < cols());
+      return internal::evaluator<Derived>(derived()).coeffRef(row,col);
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar&
+    coeffRefByOuterInner(Index outer, Index inner)
+    {
+      return coeffRef(rowIndexByOuterInner(outer, inner),
+                      colIndexByOuterInner(outer, inner));
+    }
+
+    /** \returns a reference to the coefficient at given the given row and column.
+      *
+      * \sa operator[](Index)
+      */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar&
+    operator()(Index row, Index col)
+    {
+      eigen_assert(row >= 0 && row < rows()
+          && col >= 0 && col < cols());
+      return coeffRef(row, col);
+    }
+
+
+    /** Short version: don't use this function, use
+      * \link operator[](Index) \endlink instead.
+      *
+      * Long version: this function is similar to
+      * \link operator[](Index) \endlink, but without the assertion.
+      * Use this for limiting the performance cost of debugging code when doing
+      * repeated coefficient access. Only use this when it is guaranteed that the
+      * parameters \a row and \a col are in range.
+      *
+      * If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this
+      * function equivalent to \link operator[](Index) \endlink.
+      *
+      * \sa operator[](Index), coeff(Index) const, coeffRef(Index,Index)
+      */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar&
+    coeffRef(Index index)
+    {
+      EIGEN_STATIC_ASSERT(internal::evaluator<Derived>::Flags & LinearAccessBit,
+                          THIS_COEFFICIENT_ACCESSOR_TAKING_ONE_ACCESS_IS_ONLY_FOR_EXPRESSIONS_ALLOWING_LINEAR_ACCESS)
+      eigen_internal_assert(index >= 0 && index < size());
+      return internal::evaluator<Derived>(derived()).coeffRef(index);
+    }
+
+    /** \returns a reference to the coefficient at given index.
+      *
+      * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit.
+      *
+      * \sa operator[](Index) const, operator()(Index,Index), x(), y(), z(), w()
+      */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar&
+    operator[](Index index)
+    {
+      EIGEN_STATIC_ASSERT(Derived::IsVectorAtCompileTime,
+                          THE_BRACKET_OPERATOR_IS_ONLY_FOR_VECTORS__USE_THE_PARENTHESIS_OPERATOR_INSTEAD)
+      eigen_assert(index >= 0 && index < size());
+      return coeffRef(index);
+    }
+
+    /** \returns a reference to the coefficient at given index.
+      *
+      * This is synonymous to operator[](Index).
+      *
+      * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit.
+      *
+      * \sa operator[](Index) const, operator()(Index,Index), x(), y(), z(), w()
+      */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar&
+    operator()(Index index)
+    {
+      eigen_assert(index >= 0 && index < size());
+      return coeffRef(index);
+    }
+
+    /** equivalent to operator[](0).  */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar&
+    x() { return (*this)[0]; }
+
+    /** equivalent to operator[](1).  */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar&
+    y()
+    {
+      EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=2, OUT_OF_RANGE_ACCESS);
+      return (*this)[1];
+    }
+
+    /** equivalent to operator[](2).  */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar&
+    z()
+    {
+      EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=3, OUT_OF_RANGE_ACCESS);
+      return (*this)[2];
+    }
+
+    /** equivalent to operator[](3).  */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar&
+    w()
+    {
+      EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=4, OUT_OF_RANGE_ACCESS);
+      return (*this)[3];
+    }
+};
+
+/** \brief Base class providing direct read-only coefficient access to matrices and arrays.
+  * \ingroup Core_Module
+  * \tparam Derived Type of the derived class
+  * \tparam #DirectAccessors Constant indicating direct access
+  *
+  * This class defines functions to work with strides which can be used to access entries directly. This class
+  * inherits DenseCoeffsBase<Derived, ReadOnlyAccessors> which defines functions to access entries read-only using
+  * \c operator() .
+  *
+  * \sa \blank \ref TopicClassHierarchy
+  */
+template<typename Derived>
+class DenseCoeffsBase<Derived, DirectAccessors> : public DenseCoeffsBase<Derived, ReadOnlyAccessors>
+{
+  public:
+
+    typedef DenseCoeffsBase<Derived, ReadOnlyAccessors> Base;
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    using Base::rows;
+    using Base::cols;
+    using Base::size;
+    using Base::derived;
+
+    /** \returns the pointer increment between two consecutive elements within a slice in the inner direction.
+      *
+      * \sa outerStride(), rowStride(), colStride()
+      */
+    EIGEN_DEVICE_FUNC
+    inline Index innerStride() const
+    {
+      return derived().innerStride();
+    }
+
+    /** \returns the pointer increment between two consecutive inner slices (for example, between two consecutive columns
+      *          in a column-major matrix).
+      *
+      * \sa innerStride(), rowStride(), colStride()
+      */
+    EIGEN_DEVICE_FUNC
+    inline Index outerStride() const
+    {
+      return derived().outerStride();
+    }
+
+    // FIXME shall we remove it ?
+    inline Index stride() const
+    {
+      return Derived::IsVectorAtCompileTime ? innerStride() : outerStride();
+    }
+
+    /** \returns the pointer increment between two consecutive rows.
+      *
+      * \sa innerStride(), outerStride(), colStride()
+      */
+    EIGEN_DEVICE_FUNC
+    inline Index rowStride() const
+    {
+      return Derived::IsRowMajor ? outerStride() : innerStride();
+    }
+
+    /** \returns the pointer increment between two consecutive columns.
+      *
+      * \sa innerStride(), outerStride(), rowStride()
+      */
+    EIGEN_DEVICE_FUNC
+    inline Index colStride() const
+    {
+      return Derived::IsRowMajor ? innerStride() : outerStride();
+    }
+};
+
+/** \brief Base class providing direct read/write coefficient access to matrices and arrays.
+  * \ingroup Core_Module
+  * \tparam Derived Type of the derived class
+  * \tparam #DirectWriteAccessors Constant indicating direct access
+  *
+  * This class defines functions to work with strides which can be used to access entries directly. This class
+  * inherits DenseCoeffsBase<Derived, WriteAccessors> which defines functions to access entries read/write using
+  * \c operator().
+  *
+  * \sa \blank \ref TopicClassHierarchy
+  */
+template<typename Derived>
+class DenseCoeffsBase<Derived, DirectWriteAccessors>
+  : public DenseCoeffsBase<Derived, WriteAccessors>
+{
+  public:
+
+    typedef DenseCoeffsBase<Derived, WriteAccessors> Base;
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    using Base::rows;
+    using Base::cols;
+    using Base::size;
+    using Base::derived;
+
+    /** \returns the pointer increment between two consecutive elements within a slice in the inner direction.
+      *
+      * \sa outerStride(), rowStride(), colStride()
+      */
+    EIGEN_DEVICE_FUNC
+    inline Index innerStride() const
+    {
+      return derived().innerStride();
+    }
+
+    /** \returns the pointer increment between two consecutive inner slices (for example, between two consecutive columns
+      *          in a column-major matrix).
+      *
+      * \sa innerStride(), rowStride(), colStride()
+      */
+    EIGEN_DEVICE_FUNC
+    inline Index outerStride() const
+    {
+      return derived().outerStride();
+    }
+
+    // FIXME shall we remove it ?
+    inline Index stride() const
+    {
+      return Derived::IsVectorAtCompileTime ? innerStride() : outerStride();
+    }
+
+    /** \returns the pointer increment between two consecutive rows.
+      *
+      * \sa innerStride(), outerStride(), colStride()
+      */
+    EIGEN_DEVICE_FUNC
+    inline Index rowStride() const
+    {
+      return Derived::IsRowMajor ? outerStride() : innerStride();
+    }
+
+    /** \returns the pointer increment between two consecutive columns.
+      *
+      * \sa innerStride(), outerStride(), rowStride()
+      */
+    EIGEN_DEVICE_FUNC
+    inline Index colStride() const
+    {
+      return Derived::IsRowMajor ? innerStride() : outerStride();
+    }
+};
+
+namespace internal {
+
+template<int Alignment, typename Derived, bool JustReturnZero>
+struct first_aligned_impl
+{
+  static inline Index run(const Derived&)
+  { return 0; }
+};
+
+template<int Alignment, typename Derived>
+struct first_aligned_impl<Alignment, Derived, false>
+{
+  static inline Index run(const Derived& m)
+  {
+    return internal::first_aligned<Alignment>(m.data(), m.size());
+  }
+};
+
+/** \internal \returns the index of the first element of the array stored by \a m that is properly aligned with respect to \a Alignment for vectorization.
+  *
+  * \tparam Alignment requested alignment in Bytes.
+  *
+  * There is also the variant first_aligned(const Scalar*, Integer) defined in Memory.h. See it for more
+  * documentation.
+  */
+template<int Alignment, typename Derived>
+static inline Index first_aligned(const DenseBase<Derived>& m)
+{
+  enum { ReturnZero = (int(evaluator<Derived>::Alignment) >= Alignment) || !(Derived::Flags & DirectAccessBit) };
+  return first_aligned_impl<Alignment, Derived, ReturnZero>::run(m.derived());
+}
+
+template<typename Derived>
+static inline Index first_default_aligned(const DenseBase<Derived>& m)
+{
+  typedef typename Derived::Scalar Scalar;
+  typedef typename packet_traits<Scalar>::type DefaultPacketType;
+  return internal::first_aligned<int(unpacket_traits<DefaultPacketType>::alignment),Derived>(m);
+}
+
+template<typename Derived, bool HasDirectAccess = has_direct_access<Derived>::ret>
+struct inner_stride_at_compile_time
+{
+  enum { ret = traits<Derived>::InnerStrideAtCompileTime };
+};
+
+template<typename Derived>
+struct inner_stride_at_compile_time<Derived, false>
+{
+  enum { ret = 0 };
+};
+
+template<typename Derived, bool HasDirectAccess = has_direct_access<Derived>::ret>
+struct outer_stride_at_compile_time
+{
+  enum { ret = traits<Derived>::OuterStrideAtCompileTime };
+};
+
+template<typename Derived>
+struct outer_stride_at_compile_time<Derived, false>
+{
+  enum { ret = 0 };
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_DENSECOEFFSBASE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/DenseStorage.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/DenseStorage.h
new file mode 100644
index 00000000..7958feeb
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/DenseStorage.h
@@ -0,0 +1,570 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2010-2013 Hauke Heibel <hauke.heibel@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATRIXSTORAGE_H
+#define EIGEN_MATRIXSTORAGE_H
+
+#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+  #define EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(X) X; EIGEN_DENSE_STORAGE_CTOR_PLUGIN;
+#else
+  #define EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(X)
+#endif
+
+namespace Eigen {
+
+namespace internal {
+
+struct constructor_without_unaligned_array_assert {};
+
+template<typename T, int Size>
+EIGEN_DEVICE_FUNC
+void check_static_allocation_size()
+{
+  // if EIGEN_STACK_ALLOCATION_LIMIT is defined to 0, then no limit
+  #if EIGEN_STACK_ALLOCATION_LIMIT
+  EIGEN_STATIC_ASSERT(Size * sizeof(T) <= EIGEN_STACK_ALLOCATION_LIMIT, OBJECT_ALLOCATED_ON_STACK_IS_TOO_BIG);
+  #endif
+}
+
+/** \internal
+  * Static array. If the MatrixOrArrayOptions require auto-alignment, the array will be automatically aligned:
+  * to 16 bytes boundary if the total size is a multiple of 16 bytes.
+  */
+template <typename T, int Size, int MatrixOrArrayOptions,
+          int Alignment = (MatrixOrArrayOptions&DontAlign) ? 0
+                        : compute_default_alignment<T,Size>::value >
+struct plain_array
+{
+  T array[Size];
+
+  EIGEN_DEVICE_FUNC
+  plain_array()
+  { 
+    check_static_allocation_size<T,Size>();
+  }
+
+  EIGEN_DEVICE_FUNC
+  plain_array(constructor_without_unaligned_array_assert)
+  { 
+    check_static_allocation_size<T,Size>();
+  }
+};
+
+#if defined(EIGEN_DISABLE_UNALIGNED_ARRAY_ASSERT)
+  #define EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(sizemask)
+#elif EIGEN_GNUC_AT_LEAST(4,7) 
+  // GCC 4.7 is too aggressive in its optimizations and remove the alignement test based on the fact the array is declared to be aligned.
+  // See this bug report: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=53900
+  // Hiding the origin of the array pointer behind a function argument seems to do the trick even if the function is inlined:
+  template<typename PtrType>
+  EIGEN_ALWAYS_INLINE PtrType eigen_unaligned_array_assert_workaround_gcc47(PtrType array) { return array; }
+  #define EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(sizemask) \
+    eigen_assert((internal::UIntPtr(eigen_unaligned_array_assert_workaround_gcc47(array)) & (sizemask)) == 0 \
+              && "this assertion is explained here: " \
+              "http://eigen.tuxfamily.org/dox-devel/group__TopicUnalignedArrayAssert.html" \
+              " **** READ THIS WEB PAGE !!! ****");
+#else
+  #define EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(sizemask) \
+    eigen_assert((internal::UIntPtr(array) & (sizemask)) == 0 \
+              && "this assertion is explained here: " \
+              "http://eigen.tuxfamily.org/dox-devel/group__TopicUnalignedArrayAssert.html" \
+              " **** READ THIS WEB PAGE !!! ****");
+#endif
+
+template <typename T, int Size, int MatrixOrArrayOptions>
+struct plain_array<T, Size, MatrixOrArrayOptions, 8>
+{
+  EIGEN_ALIGN_TO_BOUNDARY(8) T array[Size];
+
+  EIGEN_DEVICE_FUNC
+  plain_array() 
+  {
+    EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(7);
+    check_static_allocation_size<T,Size>();
+  }
+
+  EIGEN_DEVICE_FUNC
+  plain_array(constructor_without_unaligned_array_assert) 
+  { 
+    check_static_allocation_size<T,Size>();
+  }
+};
+
+template <typename T, int Size, int MatrixOrArrayOptions>
+struct plain_array<T, Size, MatrixOrArrayOptions, 16>
+{
+  EIGEN_ALIGN_TO_BOUNDARY(16) T array[Size];
+
+  EIGEN_DEVICE_FUNC
+  plain_array() 
+  { 
+    EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(15);
+    check_static_allocation_size<T,Size>();
+  }
+
+  EIGEN_DEVICE_FUNC
+  plain_array(constructor_without_unaligned_array_assert) 
+  { 
+    check_static_allocation_size<T,Size>();
+  }
+};
+
+template <typename T, int Size, int MatrixOrArrayOptions>
+struct plain_array<T, Size, MatrixOrArrayOptions, 32>
+{
+  EIGEN_ALIGN_TO_BOUNDARY(32) T array[Size];
+
+  EIGEN_DEVICE_FUNC
+  plain_array() 
+  {
+    EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(31);
+    check_static_allocation_size<T,Size>();
+  }
+
+  EIGEN_DEVICE_FUNC
+  plain_array(constructor_without_unaligned_array_assert) 
+  { 
+    check_static_allocation_size<T,Size>();
+  }
+};
+
+template <typename T, int Size, int MatrixOrArrayOptions>
+struct plain_array<T, Size, MatrixOrArrayOptions, 64>
+{
+  EIGEN_ALIGN_TO_BOUNDARY(64) T array[Size];
+
+  EIGEN_DEVICE_FUNC
+  plain_array() 
+  { 
+    EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(63);
+    check_static_allocation_size<T,Size>();
+  }
+
+  EIGEN_DEVICE_FUNC
+  plain_array(constructor_without_unaligned_array_assert) 
+  { 
+    check_static_allocation_size<T,Size>();
+  }
+};
+
+template <typename T, int MatrixOrArrayOptions, int Alignment>
+struct plain_array<T, 0, MatrixOrArrayOptions, Alignment>
+{
+  T array[1];
+  EIGEN_DEVICE_FUNC plain_array() {}
+  EIGEN_DEVICE_FUNC plain_array(constructor_without_unaligned_array_assert) {}
+};
+
+} // end namespace internal
+
+/** \internal
+  *
+  * \class DenseStorage
+  * \ingroup Core_Module
+  *
+  * \brief Stores the data of a matrix
+  *
+  * This class stores the data of fixed-size, dynamic-size or mixed matrices
+  * in a way as compact as possible.
+  *
+  * \sa Matrix
+  */
+template<typename T, int Size, int _Rows, int _Cols, int _Options> class DenseStorage;
+
+// purely fixed-size matrix
+template<typename T, int Size, int _Rows, int _Cols, int _Options> class DenseStorage
+{
+    internal::plain_array<T,Size,_Options> m_data;
+  public:
+    EIGEN_DEVICE_FUNC DenseStorage() {
+      EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(Index size = Size)
+    }
+    EIGEN_DEVICE_FUNC
+    explicit DenseStorage(internal::constructor_without_unaligned_array_assert)
+      : m_data(internal::constructor_without_unaligned_array_assert()) {}
+    EIGEN_DEVICE_FUNC 
+    DenseStorage(const DenseStorage& other) : m_data(other.m_data) {
+      EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(Index size = Size)
+    }
+    EIGEN_DEVICE_FUNC 
+    DenseStorage& operator=(const DenseStorage& other)
+    { 
+      if (this != &other) m_data = other.m_data;
+      return *this; 
+    }
+    EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) {
+      EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
+      eigen_internal_assert(size==rows*cols && rows==_Rows && cols==_Cols);
+      EIGEN_UNUSED_VARIABLE(size);
+      EIGEN_UNUSED_VARIABLE(rows);
+      EIGEN_UNUSED_VARIABLE(cols);
+    }
+    EIGEN_DEVICE_FUNC void swap(DenseStorage& other) { std::swap(m_data,other.m_data); }
+    EIGEN_DEVICE_FUNC static Index rows(void) {return _Rows;}
+    EIGEN_DEVICE_FUNC static Index cols(void) {return _Cols;}
+    EIGEN_DEVICE_FUNC void conservativeResize(Index,Index,Index) {}
+    EIGEN_DEVICE_FUNC void resize(Index,Index,Index) {}
+    EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
+    EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
+};
+
+// null matrix
+template<typename T, int _Rows, int _Cols, int _Options> class DenseStorage<T, 0, _Rows, _Cols, _Options>
+{
+  public:
+    EIGEN_DEVICE_FUNC DenseStorage() {}
+    EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_unaligned_array_assert) {}
+    EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage&) {}
+    EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage&) { return *this; }
+    EIGEN_DEVICE_FUNC DenseStorage(Index,Index,Index) {}
+    EIGEN_DEVICE_FUNC void swap(DenseStorage& ) {}
+    EIGEN_DEVICE_FUNC static Index rows(void) {return _Rows;}
+    EIGEN_DEVICE_FUNC static Index cols(void) {return _Cols;}
+    EIGEN_DEVICE_FUNC void conservativeResize(Index,Index,Index) {}
+    EIGEN_DEVICE_FUNC void resize(Index,Index,Index) {}
+    EIGEN_DEVICE_FUNC const T *data() const { return 0; }
+    EIGEN_DEVICE_FUNC T *data() { return 0; }
+};
+
+// more specializations for null matrices; these are necessary to resolve ambiguities
+template<typename T, int _Options> class DenseStorage<T, 0, Dynamic, Dynamic, _Options>
+: public DenseStorage<T, 0, 0, 0, _Options> { };
+
+template<typename T, int _Rows, int _Options> class DenseStorage<T, 0, _Rows, Dynamic, _Options>
+: public DenseStorage<T, 0, 0, 0, _Options> { };
+
+template<typename T, int _Cols, int _Options> class DenseStorage<T, 0, Dynamic, _Cols, _Options>
+: public DenseStorage<T, 0, 0, 0, _Options> { };
+
+// dynamic-size matrix with fixed-size storage
+template<typename T, int Size, int _Options> class DenseStorage<T, Size, Dynamic, Dynamic, _Options>
+{
+    internal::plain_array<T,Size,_Options> m_data;
+    Index m_rows;
+    Index m_cols;
+  public:
+    EIGEN_DEVICE_FUNC DenseStorage() : m_rows(0), m_cols(0) {}
+    EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_unaligned_array_assert)
+      : m_data(internal::constructor_without_unaligned_array_assert()), m_rows(0), m_cols(0) {}
+    EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other) : m_data(other.m_data), m_rows(other.m_rows), m_cols(other.m_cols) {}
+    EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other) 
+    { 
+      if (this != &other)
+      {
+        m_data = other.m_data;
+        m_rows = other.m_rows;
+        m_cols = other.m_cols;
+      }
+      return *this; 
+    }
+    EIGEN_DEVICE_FUNC DenseStorage(Index, Index rows, Index cols) : m_rows(rows), m_cols(cols) {}
+    EIGEN_DEVICE_FUNC void swap(DenseStorage& other)
+    { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); std::swap(m_cols,other.m_cols); }
+    EIGEN_DEVICE_FUNC Index rows() const {return m_rows;}
+    EIGEN_DEVICE_FUNC Index cols() const {return m_cols;}
+    EIGEN_DEVICE_FUNC void conservativeResize(Index, Index rows, Index cols) { m_rows = rows; m_cols = cols; }
+    EIGEN_DEVICE_FUNC void resize(Index, Index rows, Index cols) { m_rows = rows; m_cols = cols; }
+    EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
+    EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
+};
+
+// dynamic-size matrix with fixed-size storage and fixed width
+template<typename T, int Size, int _Cols, int _Options> class DenseStorage<T, Size, Dynamic, _Cols, _Options>
+{
+    internal::plain_array<T,Size,_Options> m_data;
+    Index m_rows;
+  public:
+    EIGEN_DEVICE_FUNC DenseStorage() : m_rows(0) {}
+    EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_unaligned_array_assert)
+      : m_data(internal::constructor_without_unaligned_array_assert()), m_rows(0) {}
+    EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other) : m_data(other.m_data), m_rows(other.m_rows) {}
+    EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other) 
+    {
+      if (this != &other)
+      {
+        m_data = other.m_data;
+        m_rows = other.m_rows;
+      }
+      return *this; 
+    }
+    EIGEN_DEVICE_FUNC DenseStorage(Index, Index rows, Index) : m_rows(rows) {}
+    EIGEN_DEVICE_FUNC void swap(DenseStorage& other) { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); }
+    EIGEN_DEVICE_FUNC Index rows(void) const {return m_rows;}
+    EIGEN_DEVICE_FUNC Index cols(void) const {return _Cols;}
+    EIGEN_DEVICE_FUNC void conservativeResize(Index, Index rows, Index) { m_rows = rows; }
+    EIGEN_DEVICE_FUNC void resize(Index, Index rows, Index) { m_rows = rows; }
+    EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
+    EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
+};
+
+// dynamic-size matrix with fixed-size storage and fixed height
+template<typename T, int Size, int _Rows, int _Options> class DenseStorage<T, Size, _Rows, Dynamic, _Options>
+{
+    internal::plain_array<T,Size,_Options> m_data;
+    Index m_cols;
+  public:
+    EIGEN_DEVICE_FUNC DenseStorage() : m_cols(0) {}
+    EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_unaligned_array_assert)
+      : m_data(internal::constructor_without_unaligned_array_assert()), m_cols(0) {}
+    EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other) : m_data(other.m_data), m_cols(other.m_cols) {}
+    EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other)
+    {
+      if (this != &other)
+      {
+        m_data = other.m_data;
+        m_cols = other.m_cols;
+      }
+      return *this;
+    }
+    EIGEN_DEVICE_FUNC DenseStorage(Index, Index, Index cols) : m_cols(cols) {}
+    EIGEN_DEVICE_FUNC void swap(DenseStorage& other) { std::swap(m_data,other.m_data); std::swap(m_cols,other.m_cols); }
+    EIGEN_DEVICE_FUNC Index rows(void) const {return _Rows;}
+    EIGEN_DEVICE_FUNC Index cols(void) const {return m_cols;}
+    void conservativeResize(Index, Index, Index cols) { m_cols = cols; }
+    void resize(Index, Index, Index cols) { m_cols = cols; }
+    EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
+    EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
+};
+
+// purely dynamic matrix.
+template<typename T, int _Options> class DenseStorage<T, Dynamic, Dynamic, Dynamic, _Options>
+{
+    T *m_data;
+    Index m_rows;
+    Index m_cols;
+  public:
+    EIGEN_DEVICE_FUNC DenseStorage() : m_data(0), m_rows(0), m_cols(0) {}
+    EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_unaligned_array_assert)
+       : m_data(0), m_rows(0), m_cols(0) {}
+    EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols)
+      : m_data(internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size)), m_rows(rows), m_cols(cols)
+    {
+      EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
+      eigen_internal_assert(size==rows*cols && rows>=0 && cols >=0);
+    }
+    EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other)
+      : m_data(internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(other.m_rows*other.m_cols))
+      , m_rows(other.m_rows)
+      , m_cols(other.m_cols)
+    {
+      EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(Index size = m_rows*m_cols)
+      internal::smart_copy(other.m_data, other.m_data+other.m_rows*other.m_cols, m_data);
+    }
+    EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other)
+    {
+      if (this != &other)
+      {
+        DenseStorage tmp(other);
+        this->swap(tmp);
+      }
+      return *this;
+    }
+#if EIGEN_HAS_RVALUE_REFERENCES
+    EIGEN_DEVICE_FUNC
+    DenseStorage(DenseStorage&& other) EIGEN_NOEXCEPT
+      : m_data(std::move(other.m_data))
+      , m_rows(std::move(other.m_rows))
+      , m_cols(std::move(other.m_cols))
+    {
+      other.m_data = nullptr;
+      other.m_rows = 0;
+      other.m_cols = 0;
+    }
+    EIGEN_DEVICE_FUNC
+    DenseStorage& operator=(DenseStorage&& other) EIGEN_NOEXCEPT
+    {
+      using std::swap;
+      swap(m_data, other.m_data);
+      swap(m_rows, other.m_rows);
+      swap(m_cols, other.m_cols);
+      return *this;
+    }
+#endif
+    EIGEN_DEVICE_FUNC ~DenseStorage() { internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, m_rows*m_cols); }
+    EIGEN_DEVICE_FUNC void swap(DenseStorage& other)
+    { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); std::swap(m_cols,other.m_cols); }
+    EIGEN_DEVICE_FUNC Index rows(void) const {return m_rows;}
+    EIGEN_DEVICE_FUNC Index cols(void) const {return m_cols;}
+    void conservativeResize(Index size, Index rows, Index cols)
+    {
+      m_data = internal::conditional_aligned_realloc_new_auto<T,(_Options&DontAlign)==0>(m_data, size, m_rows*m_cols);
+      m_rows = rows;
+      m_cols = cols;
+    }
+    EIGEN_DEVICE_FUNC void resize(Index size, Index rows, Index cols)
+    {
+      if(size != m_rows*m_cols)
+      {
+        internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, m_rows*m_cols);
+        if (size)
+          m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
+        else
+          m_data = 0;
+        EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
+      }
+      m_rows = rows;
+      m_cols = cols;
+    }
+    EIGEN_DEVICE_FUNC const T *data() const { return m_data; }
+    EIGEN_DEVICE_FUNC T *data() { return m_data; }
+};
+
+// matrix with dynamic width and fixed height (so that matrix has dynamic size).
+template<typename T, int _Rows, int _Options> class DenseStorage<T, Dynamic, _Rows, Dynamic, _Options>
+{
+    T *m_data;
+    Index m_cols;
+  public:
+    EIGEN_DEVICE_FUNC DenseStorage() : m_data(0), m_cols(0) {}
+    explicit DenseStorage(internal::constructor_without_unaligned_array_assert) : m_data(0), m_cols(0) {}
+    EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) : m_data(internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size)), m_cols(cols)
+    {
+      EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
+      eigen_internal_assert(size==rows*cols && rows==_Rows && cols >=0);
+      EIGEN_UNUSED_VARIABLE(rows);
+    }
+    EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other)
+      : m_data(internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(_Rows*other.m_cols))
+      , m_cols(other.m_cols)
+    {
+      EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(Index size = m_cols*_Rows)
+      internal::smart_copy(other.m_data, other.m_data+_Rows*m_cols, m_data);
+    }
+    EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other)
+    {
+      if (this != &other)
+      {
+        DenseStorage tmp(other);
+        this->swap(tmp);
+      }
+      return *this;
+    }    
+#if EIGEN_HAS_RVALUE_REFERENCES
+    EIGEN_DEVICE_FUNC
+    DenseStorage(DenseStorage&& other) EIGEN_NOEXCEPT
+      : m_data(std::move(other.m_data))
+      , m_cols(std::move(other.m_cols))
+    {
+      other.m_data = nullptr;
+      other.m_cols = 0;
+    }
+    EIGEN_DEVICE_FUNC
+    DenseStorage& operator=(DenseStorage&& other) EIGEN_NOEXCEPT
+    {
+      using std::swap;
+      swap(m_data, other.m_data);
+      swap(m_cols, other.m_cols);
+      return *this;
+    }
+#endif
+    EIGEN_DEVICE_FUNC ~DenseStorage() { internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _Rows*m_cols); }
+    EIGEN_DEVICE_FUNC void swap(DenseStorage& other) { std::swap(m_data,other.m_data); std::swap(m_cols,other.m_cols); }
+    EIGEN_DEVICE_FUNC static Index rows(void) {return _Rows;}
+    EIGEN_DEVICE_FUNC Index cols(void) const {return m_cols;}
+    EIGEN_DEVICE_FUNC void conservativeResize(Index size, Index, Index cols)
+    {
+      m_data = internal::conditional_aligned_realloc_new_auto<T,(_Options&DontAlign)==0>(m_data, size, _Rows*m_cols);
+      m_cols = cols;
+    }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void resize(Index size, Index, Index cols)
+    {
+      if(size != _Rows*m_cols)
+      {
+        internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _Rows*m_cols);
+        if (size)
+          m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
+        else
+          m_data = 0;
+        EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
+      }
+      m_cols = cols;
+    }
+    EIGEN_DEVICE_FUNC const T *data() const { return m_data; }
+    EIGEN_DEVICE_FUNC T *data() { return m_data; }
+};
+
+// matrix with dynamic height and fixed width (so that matrix has dynamic size).
+template<typename T, int _Cols, int _Options> class DenseStorage<T, Dynamic, Dynamic, _Cols, _Options>
+{
+    T *m_data;
+    Index m_rows;
+  public:
+    EIGEN_DEVICE_FUNC DenseStorage() : m_data(0), m_rows(0) {}
+    explicit DenseStorage(internal::constructor_without_unaligned_array_assert) : m_data(0), m_rows(0) {}
+    EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) : m_data(internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size)), m_rows(rows)
+    {
+      EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
+      eigen_internal_assert(size==rows*cols && rows>=0 && cols == _Cols);
+      EIGEN_UNUSED_VARIABLE(cols);
+    }
+    EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other)
+      : m_data(internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(other.m_rows*_Cols))
+      , m_rows(other.m_rows)
+    {
+      EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(Index size = m_rows*_Cols)
+      internal::smart_copy(other.m_data, other.m_data+other.m_rows*_Cols, m_data);
+    }
+    EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other)
+    {
+      if (this != &other)
+      {
+        DenseStorage tmp(other);
+        this->swap(tmp);
+      }
+      return *this;
+    }    
+#if EIGEN_HAS_RVALUE_REFERENCES
+    EIGEN_DEVICE_FUNC
+    DenseStorage(DenseStorage&& other) EIGEN_NOEXCEPT
+      : m_data(std::move(other.m_data))
+      , m_rows(std::move(other.m_rows))
+    {
+      other.m_data = nullptr;
+      other.m_rows = 0;
+    }
+    EIGEN_DEVICE_FUNC
+    DenseStorage& operator=(DenseStorage&& other) EIGEN_NOEXCEPT
+    {
+      using std::swap;
+      swap(m_data, other.m_data);
+      swap(m_rows, other.m_rows);
+      return *this;
+    }
+#endif
+    EIGEN_DEVICE_FUNC ~DenseStorage() { internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _Cols*m_rows); }
+    EIGEN_DEVICE_FUNC void swap(DenseStorage& other) { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); }
+    EIGEN_DEVICE_FUNC Index rows(void) const {return m_rows;}
+    EIGEN_DEVICE_FUNC static Index cols(void) {return _Cols;}
+    void conservativeResize(Index size, Index rows, Index)
+    {
+      m_data = internal::conditional_aligned_realloc_new_auto<T,(_Options&DontAlign)==0>(m_data, size, m_rows*_Cols);
+      m_rows = rows;
+    }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void resize(Index size, Index rows, Index)
+    {
+      if(size != m_rows*_Cols)
+      {
+        internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _Cols*m_rows);
+        if (size)
+          m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
+        else
+          m_data = 0;
+        EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
+      }
+      m_rows = rows;
+    }
+    EIGEN_DEVICE_FUNC const T *data() const { return m_data; }
+    EIGEN_DEVICE_FUNC T *data() { return m_data; }
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_MATRIX_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Diagonal.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Diagonal.h
new file mode 100644
index 00000000..c62f5ff2
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Diagonal.h
@@ -0,0 +1,259 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_DIAGONAL_H
+#define EIGEN_DIAGONAL_H
+
+namespace Eigen { 
+
+/** \class Diagonal
+  * \ingroup Core_Module
+  *
+  * \brief Expression of a diagonal/subdiagonal/superdiagonal in a matrix
+  *
+  * \param MatrixType the type of the object in which we are taking a sub/main/super diagonal
+  * \param DiagIndex the index of the sub/super diagonal. The default is 0 and it means the main diagonal.
+  *              A positive value means a superdiagonal, a negative value means a subdiagonal.
+  *              You can also use DynamicIndex so the index can be set at runtime.
+  *
+  * The matrix is not required to be square.
+  *
+  * This class represents an expression of the main diagonal, or any sub/super diagonal
+  * of a square matrix. It is the return type of MatrixBase::diagonal() and MatrixBase::diagonal(Index) and most of the
+  * time this is the only way it is used.
+  *
+  * \sa MatrixBase::diagonal(), MatrixBase::diagonal(Index)
+  */
+
+namespace internal {
+template<typename MatrixType, int DiagIndex>
+struct traits<Diagonal<MatrixType,DiagIndex> >
+ : traits<MatrixType>
+{
+  typedef typename ref_selector<MatrixType>::type MatrixTypeNested;
+  typedef typename remove_reference<MatrixTypeNested>::type _MatrixTypeNested;
+  typedef typename MatrixType::StorageKind StorageKind;
+  enum {
+    RowsAtCompileTime = (int(DiagIndex) == DynamicIndex || int(MatrixType::SizeAtCompileTime) == Dynamic) ? Dynamic
+                      : (EIGEN_PLAIN_ENUM_MIN(MatrixType::RowsAtCompileTime - EIGEN_PLAIN_ENUM_MAX(-DiagIndex, 0),
+                                              MatrixType::ColsAtCompileTime - EIGEN_PLAIN_ENUM_MAX( DiagIndex, 0))),
+    ColsAtCompileTime = 1,
+    MaxRowsAtCompileTime = int(MatrixType::MaxSizeAtCompileTime) == Dynamic ? Dynamic
+                         : DiagIndex == DynamicIndex ? EIGEN_SIZE_MIN_PREFER_FIXED(MatrixType::MaxRowsAtCompileTime,
+                                                                              MatrixType::MaxColsAtCompileTime)
+                         : (EIGEN_PLAIN_ENUM_MIN(MatrixType::MaxRowsAtCompileTime - EIGEN_PLAIN_ENUM_MAX(-DiagIndex, 0),
+                                                 MatrixType::MaxColsAtCompileTime - EIGEN_PLAIN_ENUM_MAX( DiagIndex, 0))),
+    MaxColsAtCompileTime = 1,
+    MaskLvalueBit = is_lvalue<MatrixType>::value ? LvalueBit : 0,
+    Flags = (unsigned int)_MatrixTypeNested::Flags & (RowMajorBit | MaskLvalueBit | DirectAccessBit) & ~RowMajorBit, // FIXME DirectAccessBit should not be handled by expressions
+    MatrixTypeOuterStride = outer_stride_at_compile_time<MatrixType>::ret,
+    InnerStrideAtCompileTime = MatrixTypeOuterStride == Dynamic ? Dynamic : MatrixTypeOuterStride+1,
+    OuterStrideAtCompileTime = 0
+  };
+};
+}
+
+template<typename MatrixType, int _DiagIndex> class Diagonal
+   : public internal::dense_xpr_base< Diagonal<MatrixType,_DiagIndex> >::type
+{
+  public:
+
+    enum { DiagIndex = _DiagIndex };
+    typedef typename internal::dense_xpr_base<Diagonal>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Diagonal)
+
+    EIGEN_DEVICE_FUNC
+    explicit inline Diagonal(MatrixType& matrix, Index a_index = DiagIndex) : m_matrix(matrix), m_index(a_index) {}
+
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Diagonal)
+
+    EIGEN_DEVICE_FUNC
+    inline Index rows() const
+    {
+      return m_index.value()<0 ? numext::mini<Index>(m_matrix.cols(),m_matrix.rows()+m_index.value())
+                               : numext::mini<Index>(m_matrix.rows(),m_matrix.cols()-m_index.value());
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline Index cols() const { return 1; }
+
+    EIGEN_DEVICE_FUNC
+    inline Index innerStride() const
+    {
+      return m_matrix.outerStride() + 1;
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline Index outerStride() const
+    {
+      return 0;
+    }
+
+    typedef typename internal::conditional<
+                       internal::is_lvalue<MatrixType>::value,
+                       Scalar,
+                       const Scalar
+                     >::type ScalarWithConstIfNotLvalue;
+
+    EIGEN_DEVICE_FUNC
+    inline ScalarWithConstIfNotLvalue* data() { return &(m_matrix.coeffRef(rowOffset(), colOffset())); }
+    EIGEN_DEVICE_FUNC
+    inline const Scalar* data() const { return &(m_matrix.coeffRef(rowOffset(), colOffset())); }
+
+    EIGEN_DEVICE_FUNC
+    inline Scalar& coeffRef(Index row, Index)
+    {
+      EIGEN_STATIC_ASSERT_LVALUE(MatrixType)
+      return m_matrix.coeffRef(row+rowOffset(), row+colOffset());
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index row, Index) const
+    {
+      return m_matrix.coeffRef(row+rowOffset(), row+colOffset());
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline CoeffReturnType coeff(Index row, Index) const
+    {
+      return m_matrix.coeff(row+rowOffset(), row+colOffset());
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline Scalar& coeffRef(Index idx)
+    {
+      EIGEN_STATIC_ASSERT_LVALUE(MatrixType)
+      return m_matrix.coeffRef(idx+rowOffset(), idx+colOffset());
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index idx) const
+    {
+      return m_matrix.coeffRef(idx+rowOffset(), idx+colOffset());
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline CoeffReturnType coeff(Index idx) const
+    {
+      return m_matrix.coeff(idx+rowOffset(), idx+colOffset());
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline const typename internal::remove_all<typename MatrixType::Nested>::type& 
+    nestedExpression() const 
+    {
+      return m_matrix;
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline Index index() const
+    {
+      return m_index.value();
+    }
+
+  protected:
+    typename internal::ref_selector<MatrixType>::non_const_type m_matrix;
+    const internal::variable_if_dynamicindex<Index, DiagIndex> m_index;
+
+  private:
+    // some compilers may fail to optimize std::max etc in case of compile-time constants...
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Index absDiagIndex() const { return m_index.value()>0 ? m_index.value() : -m_index.value(); }
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Index rowOffset() const { return m_index.value()>0 ? 0 : -m_index.value(); }
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Index colOffset() const { return m_index.value()>0 ? m_index.value() : 0; }
+    // trigger a compile-time error if someone try to call packet
+    template<int LoadMode> typename MatrixType::PacketReturnType packet(Index) const;
+    template<int LoadMode> typename MatrixType::PacketReturnType packet(Index,Index) const;
+};
+
+/** \returns an expression of the main diagonal of the matrix \c *this
+  *
+  * \c *this is not required to be square.
+  *
+  * Example: \include MatrixBase_diagonal.cpp
+  * Output: \verbinclude MatrixBase_diagonal.out
+  *
+  * \sa class Diagonal */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline typename MatrixBase<Derived>::DiagonalReturnType
+MatrixBase<Derived>::diagonal()
+{
+  return DiagonalReturnType(derived());
+}
+
+/** This is the const version of diagonal(). */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline typename MatrixBase<Derived>::ConstDiagonalReturnType
+MatrixBase<Derived>::diagonal() const
+{
+  return ConstDiagonalReturnType(derived());
+}
+
+/** \returns an expression of the \a DiagIndex-th sub or super diagonal of the matrix \c *this
+  *
+  * \c *this is not required to be square.
+  *
+  * The template parameter \a DiagIndex represent a super diagonal if \a DiagIndex > 0
+  * and a sub diagonal otherwise. \a DiagIndex == 0 is equivalent to the main diagonal.
+  *
+  * Example: \include MatrixBase_diagonal_int.cpp
+  * Output: \verbinclude MatrixBase_diagonal_int.out
+  *
+  * \sa MatrixBase::diagonal(), class Diagonal */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline typename MatrixBase<Derived>::DiagonalDynamicIndexReturnType
+MatrixBase<Derived>::diagonal(Index index)
+{
+  return DiagonalDynamicIndexReturnType(derived(), index);
+}
+
+/** This is the const version of diagonal(Index). */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline typename MatrixBase<Derived>::ConstDiagonalDynamicIndexReturnType
+MatrixBase<Derived>::diagonal(Index index) const
+{
+  return ConstDiagonalDynamicIndexReturnType(derived(), index);
+}
+
+/** \returns an expression of the \a DiagIndex-th sub or super diagonal of the matrix \c *this
+  *
+  * \c *this is not required to be square.
+  *
+  * The template parameter \a DiagIndex represent a super diagonal if \a DiagIndex > 0
+  * and a sub diagonal otherwise. \a DiagIndex == 0 is equivalent to the main diagonal.
+  *
+  * Example: \include MatrixBase_diagonal_template_int.cpp
+  * Output: \verbinclude MatrixBase_diagonal_template_int.out
+  *
+  * \sa MatrixBase::diagonal(), class Diagonal */
+template<typename Derived>
+template<int Index_>
+EIGEN_DEVICE_FUNC
+inline typename MatrixBase<Derived>::template DiagonalIndexReturnType<Index_>::Type
+MatrixBase<Derived>::diagonal()
+{
+  return typename DiagonalIndexReturnType<Index_>::Type(derived());
+}
+
+/** This is the const version of diagonal<int>(). */
+template<typename Derived>
+template<int Index_>
+EIGEN_DEVICE_FUNC
+inline typename MatrixBase<Derived>::template ConstDiagonalIndexReturnType<Index_>::Type
+MatrixBase<Derived>::diagonal() const
+{
+  return typename ConstDiagonalIndexReturnType<Index_>::Type(derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_DIAGONAL_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/DiagonalMatrix.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/DiagonalMatrix.h
new file mode 100644
index 00000000..4e8297ee
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/DiagonalMatrix.h
@@ -0,0 +1,343 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2007-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_DIAGONALMATRIX_H
+#define EIGEN_DIAGONALMATRIX_H
+
+namespace Eigen { 
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename Derived>
+class DiagonalBase : public EigenBase<Derived>
+{
+  public:
+    typedef typename internal::traits<Derived>::DiagonalVectorType DiagonalVectorType;
+    typedef typename DiagonalVectorType::Scalar Scalar;
+    typedef typename DiagonalVectorType::RealScalar RealScalar;
+    typedef typename internal::traits<Derived>::StorageKind StorageKind;
+    typedef typename internal::traits<Derived>::StorageIndex StorageIndex;
+
+    enum {
+      RowsAtCompileTime = DiagonalVectorType::SizeAtCompileTime,
+      ColsAtCompileTime = DiagonalVectorType::SizeAtCompileTime,
+      MaxRowsAtCompileTime = DiagonalVectorType::MaxSizeAtCompileTime,
+      MaxColsAtCompileTime = DiagonalVectorType::MaxSizeAtCompileTime,
+      IsVectorAtCompileTime = 0,
+      Flags = NoPreferredStorageOrderBit
+    };
+
+    typedef Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, 0, MaxRowsAtCompileTime, MaxColsAtCompileTime> DenseMatrixType;
+    typedef DenseMatrixType DenseType;
+    typedef DiagonalMatrix<Scalar,DiagonalVectorType::SizeAtCompileTime,DiagonalVectorType::MaxSizeAtCompileTime> PlainObject;
+
+    EIGEN_DEVICE_FUNC
+    inline const Derived& derived() const { return *static_cast<const Derived*>(this); }
+    EIGEN_DEVICE_FUNC
+    inline Derived& derived() { return *static_cast<Derived*>(this); }
+
+    EIGEN_DEVICE_FUNC
+    DenseMatrixType toDenseMatrix() const { return derived(); }
+
+    EIGEN_DEVICE_FUNC
+    inline const DiagonalVectorType& diagonal() const { return derived().diagonal(); }
+    EIGEN_DEVICE_FUNC
+    inline DiagonalVectorType& diagonal() { return derived().diagonal(); }
+
+    EIGEN_DEVICE_FUNC
+    inline Index rows() const { return diagonal().size(); }
+    EIGEN_DEVICE_FUNC
+    inline Index cols() const { return diagonal().size(); }
+
+    template<typename MatrixDerived>
+    EIGEN_DEVICE_FUNC
+    const Product<Derived,MatrixDerived,LazyProduct>
+    operator*(const MatrixBase<MatrixDerived> &matrix) const
+    {
+      return Product<Derived, MatrixDerived, LazyProduct>(derived(),matrix.derived());
+    }
+
+    typedef DiagonalWrapper<const CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, const DiagonalVectorType> > InverseReturnType;
+    EIGEN_DEVICE_FUNC
+    inline const InverseReturnType
+    inverse() const
+    {
+      return InverseReturnType(diagonal().cwiseInverse());
+    }
+    
+    EIGEN_DEVICE_FUNC
+    inline const DiagonalWrapper<const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(DiagonalVectorType,Scalar,product) >
+    operator*(const Scalar& scalar) const
+    {
+      return DiagonalWrapper<const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(DiagonalVectorType,Scalar,product) >(diagonal() * scalar);
+    }
+    EIGEN_DEVICE_FUNC
+    friend inline const DiagonalWrapper<const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar,DiagonalVectorType,product) >
+    operator*(const Scalar& scalar, const DiagonalBase& other)
+    {
+      return DiagonalWrapper<const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar,DiagonalVectorType,product) >(scalar * other.diagonal());
+    }
+};
+
+#endif
+
+/** \class DiagonalMatrix
+  * \ingroup Core_Module
+  *
+  * \brief Represents a diagonal matrix with its storage
+  *
+  * \param _Scalar the type of coefficients
+  * \param SizeAtCompileTime the dimension of the matrix, or Dynamic
+  * \param MaxSizeAtCompileTime the dimension of the matrix, or Dynamic. This parameter is optional and defaults
+  *        to SizeAtCompileTime. Most of the time, you do not need to specify it.
+  *
+  * \sa class DiagonalWrapper
+  */
+
+namespace internal {
+template<typename _Scalar, int SizeAtCompileTime, int MaxSizeAtCompileTime>
+struct traits<DiagonalMatrix<_Scalar,SizeAtCompileTime,MaxSizeAtCompileTime> >
+ : traits<Matrix<_Scalar,SizeAtCompileTime,SizeAtCompileTime,0,MaxSizeAtCompileTime,MaxSizeAtCompileTime> >
+{
+  typedef Matrix<_Scalar,SizeAtCompileTime,1,0,MaxSizeAtCompileTime,1> DiagonalVectorType;
+  typedef DiagonalShape StorageKind;
+  enum {
+    Flags = LvalueBit | NoPreferredStorageOrderBit
+  };
+};
+}
+template<typename _Scalar, int SizeAtCompileTime, int MaxSizeAtCompileTime>
+class DiagonalMatrix
+  : public DiagonalBase<DiagonalMatrix<_Scalar,SizeAtCompileTime,MaxSizeAtCompileTime> >
+{
+  public:
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    typedef typename internal::traits<DiagonalMatrix>::DiagonalVectorType DiagonalVectorType;
+    typedef const DiagonalMatrix& Nested;
+    typedef _Scalar Scalar;
+    typedef typename internal::traits<DiagonalMatrix>::StorageKind StorageKind;
+    typedef typename internal::traits<DiagonalMatrix>::StorageIndex StorageIndex;
+    #endif
+
+  protected:
+
+    DiagonalVectorType m_diagonal;
+
+  public:
+
+    /** const version of diagonal(). */
+    EIGEN_DEVICE_FUNC
+    inline const DiagonalVectorType& diagonal() const { return m_diagonal; }
+    /** \returns a reference to the stored vector of diagonal coefficients. */
+    EIGEN_DEVICE_FUNC
+    inline DiagonalVectorType& diagonal() { return m_diagonal; }
+
+    /** Default constructor without initialization */
+    EIGEN_DEVICE_FUNC
+    inline DiagonalMatrix() {}
+
+    /** Constructs a diagonal matrix with given dimension  */
+    EIGEN_DEVICE_FUNC
+    explicit inline DiagonalMatrix(Index dim) : m_diagonal(dim) {}
+
+    /** 2D constructor. */
+    EIGEN_DEVICE_FUNC
+    inline DiagonalMatrix(const Scalar& x, const Scalar& y) : m_diagonal(x,y) {}
+
+    /** 3D constructor. */
+    EIGEN_DEVICE_FUNC
+    inline DiagonalMatrix(const Scalar& x, const Scalar& y, const Scalar& z) : m_diagonal(x,y,z) {}
+
+    /** Copy constructor. */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    inline DiagonalMatrix(const DiagonalBase<OtherDerived>& other) : m_diagonal(other.diagonal()) {}
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** copy constructor. prevent a default copy constructor from hiding the other templated constructor */
+    inline DiagonalMatrix(const DiagonalMatrix& other) : m_diagonal(other.diagonal()) {}
+    #endif
+
+    /** generic constructor from expression of the diagonal coefficients */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    explicit inline DiagonalMatrix(const MatrixBase<OtherDerived>& other) : m_diagonal(other)
+    {}
+
+    /** Copy operator. */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    DiagonalMatrix& operator=(const DiagonalBase<OtherDerived>& other)
+    {
+      m_diagonal = other.diagonal();
+      return *this;
+    }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** This is a special case of the templated operator=. Its purpose is to
+      * prevent a default operator= from hiding the templated operator=.
+      */
+    EIGEN_DEVICE_FUNC
+    DiagonalMatrix& operator=(const DiagonalMatrix& other)
+    {
+      m_diagonal = other.diagonal();
+      return *this;
+    }
+    #endif
+
+    /** Resizes to given size. */
+    EIGEN_DEVICE_FUNC
+    inline void resize(Index size) { m_diagonal.resize(size); }
+    /** Sets all coefficients to zero. */
+    EIGEN_DEVICE_FUNC
+    inline void setZero() { m_diagonal.setZero(); }
+    /** Resizes and sets all coefficients to zero. */
+    EIGEN_DEVICE_FUNC
+    inline void setZero(Index size) { m_diagonal.setZero(size); }
+    /** Sets this matrix to be the identity matrix of the current size. */
+    EIGEN_DEVICE_FUNC
+    inline void setIdentity() { m_diagonal.setOnes(); }
+    /** Sets this matrix to be the identity matrix of the given size. */
+    EIGEN_DEVICE_FUNC
+    inline void setIdentity(Index size) { m_diagonal.setOnes(size); }
+};
+
+/** \class DiagonalWrapper
+  * \ingroup Core_Module
+  *
+  * \brief Expression of a diagonal matrix
+  *
+  * \param _DiagonalVectorType the type of the vector of diagonal coefficients
+  *
+  * This class is an expression of a diagonal matrix, but not storing its own vector of diagonal coefficients,
+  * instead wrapping an existing vector expression. It is the return type of MatrixBase::asDiagonal()
+  * and most of the time this is the only way that it is used.
+  *
+  * \sa class DiagonalMatrix, class DiagonalBase, MatrixBase::asDiagonal()
+  */
+
+namespace internal {
+template<typename _DiagonalVectorType>
+struct traits<DiagonalWrapper<_DiagonalVectorType> >
+{
+  typedef _DiagonalVectorType DiagonalVectorType;
+  typedef typename DiagonalVectorType::Scalar Scalar;
+  typedef typename DiagonalVectorType::StorageIndex StorageIndex;
+  typedef DiagonalShape StorageKind;
+  typedef typename traits<DiagonalVectorType>::XprKind XprKind;
+  enum {
+    RowsAtCompileTime = DiagonalVectorType::SizeAtCompileTime,
+    ColsAtCompileTime = DiagonalVectorType::SizeAtCompileTime,
+    MaxRowsAtCompileTime = DiagonalVectorType::MaxSizeAtCompileTime,
+    MaxColsAtCompileTime = DiagonalVectorType::MaxSizeAtCompileTime,
+    Flags =  (traits<DiagonalVectorType>::Flags & LvalueBit) | NoPreferredStorageOrderBit
+  };
+};
+}
+
+template<typename _DiagonalVectorType>
+class DiagonalWrapper
+  : public DiagonalBase<DiagonalWrapper<_DiagonalVectorType> >, internal::no_assignment_operator
+{
+  public:
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    typedef _DiagonalVectorType DiagonalVectorType;
+    typedef DiagonalWrapper Nested;
+    #endif
+
+    /** Constructor from expression of diagonal coefficients to wrap. */
+    EIGEN_DEVICE_FUNC
+    explicit inline DiagonalWrapper(DiagonalVectorType& a_diagonal) : m_diagonal(a_diagonal) {}
+
+    /** \returns a const reference to the wrapped expression of diagonal coefficients. */
+    EIGEN_DEVICE_FUNC
+    const DiagonalVectorType& diagonal() const { return m_diagonal; }
+
+  protected:
+    typename DiagonalVectorType::Nested m_diagonal;
+};
+
+/** \returns a pseudo-expression of a diagonal matrix with *this as vector of diagonal coefficients
+  *
+  * \only_for_vectors
+  *
+  * Example: \include MatrixBase_asDiagonal.cpp
+  * Output: \verbinclude MatrixBase_asDiagonal.out
+  *
+  * \sa class DiagonalWrapper, class DiagonalMatrix, diagonal(), isDiagonal()
+  **/
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline const DiagonalWrapper<const Derived>
+MatrixBase<Derived>::asDiagonal() const
+{
+  return DiagonalWrapper<const Derived>(derived());
+}
+
+/** \returns true if *this is approximately equal to a diagonal matrix,
+  *          within the precision given by \a prec.
+  *
+  * Example: \include MatrixBase_isDiagonal.cpp
+  * Output: \verbinclude MatrixBase_isDiagonal.out
+  *
+  * \sa asDiagonal()
+  */
+template<typename Derived>
+bool MatrixBase<Derived>::isDiagonal(const RealScalar& prec) const
+{
+  if(cols() != rows()) return false;
+  RealScalar maxAbsOnDiagonal = static_cast<RealScalar>(-1);
+  for(Index j = 0; j < cols(); ++j)
+  {
+    RealScalar absOnDiagonal = numext::abs(coeff(j,j));
+    if(absOnDiagonal > maxAbsOnDiagonal) maxAbsOnDiagonal = absOnDiagonal;
+  }
+  for(Index j = 0; j < cols(); ++j)
+    for(Index i = 0; i < j; ++i)
+    {
+      if(!internal::isMuchSmallerThan(coeff(i, j), maxAbsOnDiagonal, prec)) return false;
+      if(!internal::isMuchSmallerThan(coeff(j, i), maxAbsOnDiagonal, prec)) return false;
+    }
+  return true;
+}
+
+namespace internal {
+
+template<> struct storage_kind_to_shape<DiagonalShape> { typedef DiagonalShape Shape; };
+
+struct Diagonal2Dense {};
+
+template<> struct AssignmentKind<DenseShape,DiagonalShape> { typedef Diagonal2Dense Kind; };
+
+// Diagonal matrix to Dense assignment
+template< typename DstXprType, typename SrcXprType, typename Functor>
+struct Assignment<DstXprType, SrcXprType, Functor, Diagonal2Dense>
+{
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+    
+    dst.setZero();
+    dst.diagonal() = src.diagonal();
+  }
+  
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
+  { dst.diagonal() += src.diagonal(); }
+  
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
+  { dst.diagonal() -= src.diagonal(); }
+};
+
+} // namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_DIAGONALMATRIX_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/DiagonalProduct.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/DiagonalProduct.h
new file mode 100644
index 00000000..7911d1cd
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/DiagonalProduct.h
@@ -0,0 +1,28 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2007-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_DIAGONALPRODUCT_H
+#define EIGEN_DIAGONALPRODUCT_H
+
+namespace Eigen { 
+
+/** \returns the diagonal matrix product of \c *this by the diagonal matrix \a diagonal.
+  */
+template<typename Derived>
+template<typename DiagonalDerived>
+EIGEN_DEVICE_FUNC inline const Product<Derived, DiagonalDerived, LazyProduct>
+MatrixBase<Derived>::operator*(const DiagonalBase<DiagonalDerived> &a_diagonal) const
+{
+  return Product<Derived, DiagonalDerived, LazyProduct>(derived(),a_diagonal.derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_DIAGONALPRODUCT_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Dot.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Dot.h
new file mode 100644
index 00000000..bb8e3fec
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Dot.h
@@ -0,0 +1,315 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2008, 2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_DOT_H
+#define EIGEN_DOT_H
+
+namespace Eigen { 
+
+namespace internal {
+
+// helper function for dot(). The problem is that if we put that in the body of dot(), then upon calling dot
+// with mismatched types, the compiler emits errors about failing to instantiate cwiseProduct BEFORE
+// looking at the static assertions. Thus this is a trick to get better compile errors.
+template<typename T, typename U,
+// the NeedToTranspose condition here is taken straight from Assign.h
+         bool NeedToTranspose = T::IsVectorAtCompileTime
+                && U::IsVectorAtCompileTime
+                && ((int(T::RowsAtCompileTime) == 1 && int(U::ColsAtCompileTime) == 1)
+                      |  // FIXME | instead of || to please GCC 4.4.0 stupid warning "suggest parentheses around &&".
+                         // revert to || as soon as not needed anymore.
+                    (int(T::ColsAtCompileTime) == 1 && int(U::RowsAtCompileTime) == 1))
+>
+struct dot_nocheck
+{
+  typedef scalar_conj_product_op<typename traits<T>::Scalar,typename traits<U>::Scalar> conj_prod;
+  typedef typename conj_prod::result_type ResScalar;
+  EIGEN_DEVICE_FUNC
+  static inline ResScalar run(const MatrixBase<T>& a, const MatrixBase<U>& b)
+  {
+    return a.template binaryExpr<conj_prod>(b).sum();
+  }
+};
+
+template<typename T, typename U>
+struct dot_nocheck<T, U, true>
+{
+  typedef scalar_conj_product_op<typename traits<T>::Scalar,typename traits<U>::Scalar> conj_prod;
+  typedef typename conj_prod::result_type ResScalar;
+  EIGEN_DEVICE_FUNC
+  static inline ResScalar run(const MatrixBase<T>& a, const MatrixBase<U>& b)
+  {
+    return a.transpose().template binaryExpr<conj_prod>(b).sum();
+  }
+};
+
+} // end namespace internal
+
+/** \fn MatrixBase::dot
+  * \returns the dot product of *this with other.
+  *
+  * \only_for_vectors
+  *
+  * \note If the scalar type is complex numbers, then this function returns the hermitian
+  * (sesquilinear) dot product, conjugate-linear in the first variable and linear in the
+  * second variable.
+  *
+  * \sa squaredNorm(), norm()
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+typename ScalarBinaryOpTraits<typename internal::traits<Derived>::Scalar,typename internal::traits<OtherDerived>::Scalar>::ReturnType
+MatrixBase<Derived>::dot(const MatrixBase<OtherDerived>& other) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+  EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived,OtherDerived)
+#if !(defined(EIGEN_NO_STATIC_ASSERT) && defined(EIGEN_NO_DEBUG))
+  typedef internal::scalar_conj_product_op<Scalar,typename OtherDerived::Scalar> func;
+  EIGEN_CHECK_BINARY_COMPATIBILIY(func,Scalar,typename OtherDerived::Scalar);
+#endif
+  
+  eigen_assert(size() == other.size());
+
+  return internal::dot_nocheck<Derived,OtherDerived>::run(*this, other);
+}
+
+//---------- implementation of L2 norm and related functions ----------
+
+/** \returns, for vectors, the squared \em l2 norm of \c *this, and for matrices the Frobenius norm.
+  * In both cases, it consists in the sum of the square of all the matrix entries.
+  * For vectors, this is also equals to the dot product of \c *this with itself.
+  *
+  * \sa dot(), norm(), lpNorm()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename NumTraits<typename internal::traits<Derived>::Scalar>::Real MatrixBase<Derived>::squaredNorm() const
+{
+  return numext::real((*this).cwiseAbs2().sum());
+}
+
+/** \returns, for vectors, the \em l2 norm of \c *this, and for matrices the Frobenius norm.
+  * In both cases, it consists in the square root of the sum of the square of all the matrix entries.
+  * For vectors, this is also equals to the square root of the dot product of \c *this with itself.
+  *
+  * \sa lpNorm(), dot(), squaredNorm()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real MatrixBase<Derived>::norm() const
+{
+  return numext::sqrt(squaredNorm());
+}
+
+/** \returns an expression of the quotient of \c *this by its own norm.
+  *
+  * \warning If the input vector is too small (i.e., this->norm()==0),
+  *          then this function returns a copy of the input.
+  *
+  * \only_for_vectors
+  *
+  * \sa norm(), normalize()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline const typename MatrixBase<Derived>::PlainObject
+MatrixBase<Derived>::normalized() const
+{
+  typedef typename internal::nested_eval<Derived,2>::type _Nested;
+  _Nested n(derived());
+  RealScalar z = n.squaredNorm();
+  // NOTE: after extensive benchmarking, this conditional does not impact performance, at least on recent x86 CPU
+  if(z>RealScalar(0))
+    return n / numext::sqrt(z);
+  else
+    return n;
+}
+
+/** Normalizes the vector, i.e. divides it by its own norm.
+  *
+  * \only_for_vectors
+  *
+  * \warning If the input vector is too small (i.e., this->norm()==0), then \c *this is left unchanged.
+  *
+  * \sa norm(), normalized()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline void MatrixBase<Derived>::normalize()
+{
+  RealScalar z = squaredNorm();
+  // NOTE: after extensive benchmarking, this conditional does not impact performance, at least on recent x86 CPU
+  if(z>RealScalar(0))
+    derived() /= numext::sqrt(z);
+}
+
+/** \returns an expression of the quotient of \c *this by its own norm while avoiding underflow and overflow.
+  *
+  * \only_for_vectors
+  *
+  * This method is analogue to the normalized() method, but it reduces the risk of
+  * underflow and overflow when computing the norm.
+  *
+  * \warning If the input vector is too small (i.e., this->norm()==0),
+  *          then this function returns a copy of the input.
+  *
+  * \sa stableNorm(), stableNormalize(), normalized()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline const typename MatrixBase<Derived>::PlainObject
+MatrixBase<Derived>::stableNormalized() const
+{
+  typedef typename internal::nested_eval<Derived,3>::type _Nested;
+  _Nested n(derived());
+  RealScalar w = n.cwiseAbs().maxCoeff();
+  RealScalar z = (n/w).squaredNorm();
+  if(z>RealScalar(0))
+    return n / (numext::sqrt(z)*w);
+  else
+    return n;
+}
+
+/** Normalizes the vector while avoid underflow and overflow
+  *
+  * \only_for_vectors
+  *
+  * This method is analogue to the normalize() method, but it reduces the risk of
+  * underflow and overflow when computing the norm.
+  *
+  * \warning If the input vector is too small (i.e., this->norm()==0), then \c *this is left unchanged.
+  *
+  * \sa stableNorm(), stableNormalized(), normalize()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline void MatrixBase<Derived>::stableNormalize()
+{
+  RealScalar w = cwiseAbs().maxCoeff();
+  RealScalar z = (derived()/w).squaredNorm();
+  if(z>RealScalar(0))
+    derived() /= numext::sqrt(z)*w;
+}
+
+//---------- implementation of other norms ----------
+
+namespace internal {
+
+template<typename Derived, int p>
+struct lpNorm_selector
+{
+  typedef typename NumTraits<typename traits<Derived>::Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const MatrixBase<Derived>& m)
+  {
+    EIGEN_USING_STD_MATH(pow)
+    return pow(m.cwiseAbs().array().pow(p).sum(), RealScalar(1)/p);
+  }
+};
+
+template<typename Derived>
+struct lpNorm_selector<Derived, 1>
+{
+  EIGEN_DEVICE_FUNC
+  static inline typename NumTraits<typename traits<Derived>::Scalar>::Real run(const MatrixBase<Derived>& m)
+  {
+    return m.cwiseAbs().sum();
+  }
+};
+
+template<typename Derived>
+struct lpNorm_selector<Derived, 2>
+{
+  EIGEN_DEVICE_FUNC
+  static inline typename NumTraits<typename traits<Derived>::Scalar>::Real run(const MatrixBase<Derived>& m)
+  {
+    return m.norm();
+  }
+};
+
+template<typename Derived>
+struct lpNorm_selector<Derived, Infinity>
+{
+  typedef typename NumTraits<typename traits<Derived>::Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const MatrixBase<Derived>& m)
+  {
+    if(Derived::SizeAtCompileTime==0 || (Derived::SizeAtCompileTime==Dynamic && m.size()==0))
+      return RealScalar(0);
+    return m.cwiseAbs().maxCoeff();
+  }
+};
+
+} // end namespace internal
+
+/** \returns the \b coefficient-wise \f$ \ell^p \f$ norm of \c *this, that is, returns the p-th root of the sum of the p-th powers of the absolute values
+  *          of the coefficients of \c *this. If \a p is the special value \a Eigen::Infinity, this function returns the \f$ \ell^\infty \f$
+  *          norm, that is the maximum of the absolute values of the coefficients of \c *this.
+  *
+  * In all cases, if \c *this is empty, then the value 0 is returned.
+  *
+  * \note For matrices, this function does not compute the <a href="https://en.wikipedia.org/wiki/Operator_norm">operator-norm</a>. That is, if \c *this is a matrix, then its coefficients are interpreted as a 1D vector. Nonetheless, you can easily compute the 1-norm and \f$\infty\f$-norm matrix operator norms using \link TutorialReductionsVisitorsBroadcastingReductionsNorm partial reductions \endlink.
+  *
+  * \sa norm()
+  */
+template<typename Derived>
+template<int p>
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+EIGEN_DEVICE_FUNC inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
+#else
+EIGEN_DEVICE_FUNC MatrixBase<Derived>::RealScalar
+#endif
+MatrixBase<Derived>::lpNorm() const
+{
+  return internal::lpNorm_selector<Derived, p>::run(*this);
+}
+
+//---------- implementation of isOrthogonal / isUnitary ----------
+
+/** \returns true if *this is approximately orthogonal to \a other,
+  *          within the precision given by \a prec.
+  *
+  * Example: \include MatrixBase_isOrthogonal.cpp
+  * Output: \verbinclude MatrixBase_isOrthogonal.out
+  */
+template<typename Derived>
+template<typename OtherDerived>
+bool MatrixBase<Derived>::isOrthogonal
+(const MatrixBase<OtherDerived>& other, const RealScalar& prec) const
+{
+  typename internal::nested_eval<Derived,2>::type nested(derived());
+  typename internal::nested_eval<OtherDerived,2>::type otherNested(other.derived());
+  return numext::abs2(nested.dot(otherNested)) <= prec * prec * nested.squaredNorm() * otherNested.squaredNorm();
+}
+
+/** \returns true if *this is approximately an unitary matrix,
+  *          within the precision given by \a prec. In the case where the \a Scalar
+  *          type is real numbers, a unitary matrix is an orthogonal matrix, whence the name.
+  *
+  * \note This can be used to check whether a family of vectors forms an orthonormal basis.
+  *       Indeed, \c m.isUnitary() returns true if and only if the columns (equivalently, the rows) of m form an
+  *       orthonormal basis.
+  *
+  * Example: \include MatrixBase_isUnitary.cpp
+  * Output: \verbinclude MatrixBase_isUnitary.out
+  */
+template<typename Derived>
+bool MatrixBase<Derived>::isUnitary(const RealScalar& prec) const
+{
+  typename internal::nested_eval<Derived,1>::type self(derived());
+  for(Index i = 0; i < cols(); ++i)
+  {
+    if(!internal::isApprox(self.col(i).squaredNorm(), static_cast<RealScalar>(1), prec))
+      return false;
+    for(Index j = 0; j < i; ++j)
+      if(!internal::isMuchSmallerThan(self.col(i).dot(self.col(j)), static_cast<Scalar>(1), prec))
+        return false;
+  }
+  return true;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_DOT_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/EigenBase.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/EigenBase.h
new file mode 100644
index 00000000..b195506a
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/EigenBase.h
@@ -0,0 +1,159 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_EIGENBASE_H
+#define EIGEN_EIGENBASE_H
+
+namespace Eigen {
+
+/** \class EigenBase
+  * \ingroup Core_Module
+  * 
+  * Common base class for all classes T such that MatrixBase has an operator=(T) and a constructor MatrixBase(T).
+  *
+  * In other words, an EigenBase object is an object that can be copied into a MatrixBase.
+  *
+  * Besides MatrixBase-derived classes, this also includes special matrix classes such as diagonal matrices, etc.
+  *
+  * Notice that this class is trivial, it is only used to disambiguate overloaded functions.
+  *
+  * \sa \blank \ref TopicClassHierarchy
+  */
+template<typename Derived> struct EigenBase
+{
+//   typedef typename internal::plain_matrix_type<Derived>::type PlainObject;
+  
+  /** \brief The interface type of indices
+    * \details To change this, \c \#define the preprocessor symbol \c EIGEN_DEFAULT_DENSE_INDEX_TYPE.
+    * \deprecated Since Eigen 3.3, its usage is deprecated. Use Eigen::Index instead.
+    * \sa StorageIndex, \ref TopicPreprocessorDirectives.
+    */
+  typedef Eigen::Index Index;
+
+  // FIXME is it needed?
+  typedef typename internal::traits<Derived>::StorageKind StorageKind;
+
+  /** \returns a reference to the derived object */
+  EIGEN_DEVICE_FUNC
+  Derived& derived() { return *static_cast<Derived*>(this); }
+  /** \returns a const reference to the derived object */
+  EIGEN_DEVICE_FUNC
+  const Derived& derived() const { return *static_cast<const Derived*>(this); }
+
+  EIGEN_DEVICE_FUNC
+  inline Derived& const_cast_derived() const
+  { return *static_cast<Derived*>(const_cast<EigenBase*>(this)); }
+  EIGEN_DEVICE_FUNC
+  inline const Derived& const_derived() const
+  { return *static_cast<const Derived*>(this); }
+
+  /** \returns the number of rows. \sa cols(), RowsAtCompileTime */
+  EIGEN_DEVICE_FUNC
+  inline Index rows() const { return derived().rows(); }
+  /** \returns the number of columns. \sa rows(), ColsAtCompileTime*/
+  EIGEN_DEVICE_FUNC
+  inline Index cols() const { return derived().cols(); }
+  /** \returns the number of coefficients, which is rows()*cols().
+    * \sa rows(), cols(), SizeAtCompileTime. */
+  EIGEN_DEVICE_FUNC
+  inline Index size() const { return rows() * cols(); }
+
+  /** \internal Don't use it, but do the equivalent: \code dst = *this; \endcode */
+  template<typename Dest>
+  EIGEN_DEVICE_FUNC
+  inline void evalTo(Dest& dst) const
+  { derived().evalTo(dst); }
+
+  /** \internal Don't use it, but do the equivalent: \code dst += *this; \endcode */
+  template<typename Dest>
+  EIGEN_DEVICE_FUNC
+  inline void addTo(Dest& dst) const
+  {
+    // This is the default implementation,
+    // derived class can reimplement it in a more optimized way.
+    typename Dest::PlainObject res(rows(),cols());
+    evalTo(res);
+    dst += res;
+  }
+
+  /** \internal Don't use it, but do the equivalent: \code dst -= *this; \endcode */
+  template<typename Dest>
+  EIGEN_DEVICE_FUNC
+  inline void subTo(Dest& dst) const
+  {
+    // This is the default implementation,
+    // derived class can reimplement it in a more optimized way.
+    typename Dest::PlainObject res(rows(),cols());
+    evalTo(res);
+    dst -= res;
+  }
+
+  /** \internal Don't use it, but do the equivalent: \code dst.applyOnTheRight(*this); \endcode */
+  template<typename Dest>
+  EIGEN_DEVICE_FUNC inline void applyThisOnTheRight(Dest& dst) const
+  {
+    // This is the default implementation,
+    // derived class can reimplement it in a more optimized way.
+    dst = dst * this->derived();
+  }
+
+  /** \internal Don't use it, but do the equivalent: \code dst.applyOnTheLeft(*this); \endcode */
+  template<typename Dest>
+  EIGEN_DEVICE_FUNC inline void applyThisOnTheLeft(Dest& dst) const
+  {
+    // This is the default implementation,
+    // derived class can reimplement it in a more optimized way.
+    dst = this->derived() * dst;
+  }
+
+};
+
+/***************************************************************************
+* Implementation of matrix base methods
+***************************************************************************/
+
+/** \brief Copies the generic expression \a other into *this.
+  *
+  * \details The expression must provide a (templated) evalTo(Derived& dst) const
+  * function which does the actual job. In practice, this allows any user to write
+  * its own special matrix without having to modify MatrixBase
+  *
+  * \returns a reference to *this.
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+Derived& DenseBase<Derived>::operator=(const EigenBase<OtherDerived> &other)
+{
+  call_assignment(derived(), other.derived());
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+Derived& DenseBase<Derived>::operator+=(const EigenBase<OtherDerived> &other)
+{
+  call_assignment(derived(), other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+Derived& DenseBase<Derived>::operator-=(const EigenBase<OtherDerived> &other)
+{
+  call_assignment(derived(), other.derived(), internal::sub_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_EIGENBASE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/ForceAlignedAccess.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/ForceAlignedAccess.h
new file mode 100644
index 00000000..7b08b45e
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/ForceAlignedAccess.h
@@ -0,0 +1,146 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_FORCEALIGNEDACCESS_H
+#define EIGEN_FORCEALIGNEDACCESS_H
+
+namespace Eigen {
+
+/** \class ForceAlignedAccess
+  * \ingroup Core_Module
+  *
+  * \brief Enforce aligned packet loads and stores regardless of what is requested
+  *
+  * \param ExpressionType the type of the object of which we are forcing aligned packet access
+  *
+  * This class is the return type of MatrixBase::forceAlignedAccess()
+  * and most of the time this is the only way it is used.
+  *
+  * \sa MatrixBase::forceAlignedAccess()
+  */
+
+namespace internal {
+template<typename ExpressionType>
+struct traits<ForceAlignedAccess<ExpressionType> > : public traits<ExpressionType>
+{};
+}
+
+template<typename ExpressionType> class ForceAlignedAccess
+  : public internal::dense_xpr_base< ForceAlignedAccess<ExpressionType> >::type
+{
+  public:
+
+    typedef typename internal::dense_xpr_base<ForceAlignedAccess>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(ForceAlignedAccess)
+
+    EIGEN_DEVICE_FUNC explicit inline ForceAlignedAccess(const ExpressionType& matrix) : m_expression(matrix) {}
+
+    EIGEN_DEVICE_FUNC inline Index rows() const { return m_expression.rows(); }
+    EIGEN_DEVICE_FUNC inline Index cols() const { return m_expression.cols(); }
+    EIGEN_DEVICE_FUNC inline Index outerStride() const { return m_expression.outerStride(); }
+    EIGEN_DEVICE_FUNC inline Index innerStride() const { return m_expression.innerStride(); }
+
+    EIGEN_DEVICE_FUNC inline const CoeffReturnType coeff(Index row, Index col) const
+    {
+      return m_expression.coeff(row, col);
+    }
+
+    EIGEN_DEVICE_FUNC inline Scalar& coeffRef(Index row, Index col)
+    {
+      return m_expression.const_cast_derived().coeffRef(row, col);
+    }
+
+    EIGEN_DEVICE_FUNC inline const CoeffReturnType coeff(Index index) const
+    {
+      return m_expression.coeff(index);
+    }
+
+    EIGEN_DEVICE_FUNC inline Scalar& coeffRef(Index index)
+    {
+      return m_expression.const_cast_derived().coeffRef(index);
+    }
+
+    template<int LoadMode>
+    inline const PacketScalar packet(Index row, Index col) const
+    {
+      return m_expression.template packet<Aligned>(row, col);
+    }
+
+    template<int LoadMode>
+    inline void writePacket(Index row, Index col, const PacketScalar& x)
+    {
+      m_expression.const_cast_derived().template writePacket<Aligned>(row, col, x);
+    }
+
+    template<int LoadMode>
+    inline const PacketScalar packet(Index index) const
+    {
+      return m_expression.template packet<Aligned>(index);
+    }
+
+    template<int LoadMode>
+    inline void writePacket(Index index, const PacketScalar& x)
+    {
+      m_expression.const_cast_derived().template writePacket<Aligned>(index, x);
+    }
+
+    EIGEN_DEVICE_FUNC operator const ExpressionType&() const { return m_expression; }
+
+  protected:
+    const ExpressionType& m_expression;
+
+  private:
+    ForceAlignedAccess& operator=(const ForceAlignedAccess&);
+};
+
+/** \returns an expression of *this with forced aligned access
+  * \sa forceAlignedAccessIf(),class ForceAlignedAccess
+  */
+template<typename Derived>
+inline const ForceAlignedAccess<Derived>
+MatrixBase<Derived>::forceAlignedAccess() const
+{
+  return ForceAlignedAccess<Derived>(derived());
+}
+
+/** \returns an expression of *this with forced aligned access
+  * \sa forceAlignedAccessIf(), class ForceAlignedAccess
+  */
+template<typename Derived>
+inline ForceAlignedAccess<Derived>
+MatrixBase<Derived>::forceAlignedAccess()
+{
+  return ForceAlignedAccess<Derived>(derived());
+}
+
+/** \returns an expression of *this with forced aligned access if \a Enable is true.
+  * \sa forceAlignedAccess(), class ForceAlignedAccess
+  */
+template<typename Derived>
+template<bool Enable>
+inline typename internal::add_const_on_value_type<typename internal::conditional<Enable,ForceAlignedAccess<Derived>,Derived&>::type>::type
+MatrixBase<Derived>::forceAlignedAccessIf() const
+{
+  return derived();  // FIXME This should not work but apparently is never used
+}
+
+/** \returns an expression of *this with forced aligned access if \a Enable is true.
+  * \sa forceAlignedAccess(), class ForceAlignedAccess
+  */
+template<typename Derived>
+template<bool Enable>
+inline typename internal::conditional<Enable,ForceAlignedAccess<Derived>,Derived&>::type
+MatrixBase<Derived>::forceAlignedAccessIf()
+{
+  return derived();  // FIXME This should not work but apparently is never used
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_FORCEALIGNEDACCESS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Fuzzy.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Fuzzy.h
new file mode 100644
index 00000000..43aa49b2
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Fuzzy.h
@@ -0,0 +1,155 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_FUZZY_H
+#define EIGEN_FUZZY_H
+
+namespace Eigen { 
+
+namespace internal
+{
+
+template<typename Derived, typename OtherDerived, bool is_integer = NumTraits<typename Derived::Scalar>::IsInteger>
+struct isApprox_selector
+{
+  EIGEN_DEVICE_FUNC
+  static bool run(const Derived& x, const OtherDerived& y, const typename Derived::RealScalar& prec)
+  {
+    typename internal::nested_eval<Derived,2>::type nested(x);
+    typename internal::nested_eval<OtherDerived,2>::type otherNested(y);
+    return (nested - otherNested).cwiseAbs2().sum() <= prec * prec * numext::mini(nested.cwiseAbs2().sum(), otherNested.cwiseAbs2().sum());
+  }
+};
+
+template<typename Derived, typename OtherDerived>
+struct isApprox_selector<Derived, OtherDerived, true>
+{
+  EIGEN_DEVICE_FUNC
+  static bool run(const Derived& x, const OtherDerived& y, const typename Derived::RealScalar&)
+  {
+    return x.matrix() == y.matrix();
+  }
+};
+
+template<typename Derived, typename OtherDerived, bool is_integer = NumTraits<typename Derived::Scalar>::IsInteger>
+struct isMuchSmallerThan_object_selector
+{
+  EIGEN_DEVICE_FUNC
+  static bool run(const Derived& x, const OtherDerived& y, const typename Derived::RealScalar& prec)
+  {
+    return x.cwiseAbs2().sum() <= numext::abs2(prec) * y.cwiseAbs2().sum();
+  }
+};
+
+template<typename Derived, typename OtherDerived>
+struct isMuchSmallerThan_object_selector<Derived, OtherDerived, true>
+{
+  EIGEN_DEVICE_FUNC
+  static bool run(const Derived& x, const OtherDerived&, const typename Derived::RealScalar&)
+  {
+    return x.matrix() == Derived::Zero(x.rows(), x.cols()).matrix();
+  }
+};
+
+template<typename Derived, bool is_integer = NumTraits<typename Derived::Scalar>::IsInteger>
+struct isMuchSmallerThan_scalar_selector
+{
+  EIGEN_DEVICE_FUNC
+  static bool run(const Derived& x, const typename Derived::RealScalar& y, const typename Derived::RealScalar& prec)
+  {
+    return x.cwiseAbs2().sum() <= numext::abs2(prec * y);
+  }
+};
+
+template<typename Derived>
+struct isMuchSmallerThan_scalar_selector<Derived, true>
+{
+  EIGEN_DEVICE_FUNC
+  static bool run(const Derived& x, const typename Derived::RealScalar&, const typename Derived::RealScalar&)
+  {
+    return x.matrix() == Derived::Zero(x.rows(), x.cols()).matrix();
+  }
+};
+
+} // end namespace internal
+
+
+/** \returns \c true if \c *this is approximately equal to \a other, within the precision
+  * determined by \a prec.
+  *
+  * \note The fuzzy compares are done multiplicatively. Two vectors \f$ v \f$ and \f$ w \f$
+  * are considered to be approximately equal within precision \f$ p \f$ if
+  * \f[ \Vert v - w \Vert \leqslant p\,\min(\Vert v\Vert, \Vert w\Vert). \f]
+  * For matrices, the comparison is done using the Hilbert-Schmidt norm (aka Frobenius norm
+  * L2 norm).
+  *
+  * \note Because of the multiplicativeness of this comparison, one can't use this function
+  * to check whether \c *this is approximately equal to the zero matrix or vector.
+  * Indeed, \c isApprox(zero) returns false unless \c *this itself is exactly the zero matrix
+  * or vector. If you want to test whether \c *this is zero, use internal::isMuchSmallerThan(const
+  * RealScalar&, RealScalar) instead.
+  *
+  * \sa internal::isMuchSmallerThan(const RealScalar&, RealScalar) const
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC bool DenseBase<Derived>::isApprox(
+  const DenseBase<OtherDerived>& other,
+  const RealScalar& prec
+) const
+{
+  return internal::isApprox_selector<Derived, OtherDerived>::run(derived(), other.derived(), prec);
+}
+
+/** \returns \c true if the norm of \c *this is much smaller than \a other,
+  * within the precision determined by \a prec.
+  *
+  * \note The fuzzy compares are done multiplicatively. A vector \f$ v \f$ is
+  * considered to be much smaller than \f$ x \f$ within precision \f$ p \f$ if
+  * \f[ \Vert v \Vert \leqslant p\,\vert x\vert. \f]
+  *
+  * For matrices, the comparison is done using the Hilbert-Schmidt norm. For this reason,
+  * the value of the reference scalar \a other should come from the Hilbert-Schmidt norm
+  * of a reference matrix of same dimensions.
+  *
+  * \sa isApprox(), isMuchSmallerThan(const DenseBase<OtherDerived>&, RealScalar) const
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC bool DenseBase<Derived>::isMuchSmallerThan(
+  const typename NumTraits<Scalar>::Real& other,
+  const RealScalar& prec
+) const
+{
+  return internal::isMuchSmallerThan_scalar_selector<Derived>::run(derived(), other, prec);
+}
+
+/** \returns \c true if the norm of \c *this is much smaller than the norm of \a other,
+  * within the precision determined by \a prec.
+  *
+  * \note The fuzzy compares are done multiplicatively. A vector \f$ v \f$ is
+  * considered to be much smaller than a vector \f$ w \f$ within precision \f$ p \f$ if
+  * \f[ \Vert v \Vert \leqslant p\,\Vert w\Vert. \f]
+  * For matrices, the comparison is done using the Hilbert-Schmidt norm.
+  *
+  * \sa isApprox(), isMuchSmallerThan(const RealScalar&, RealScalar) const
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC bool DenseBase<Derived>::isMuchSmallerThan(
+  const DenseBase<OtherDerived>& other,
+  const RealScalar& prec
+) const
+{
+  return internal::isMuchSmallerThan_object_selector<Derived, OtherDerived>::run(derived(), other.derived(), prec);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_FUZZY_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/GeneralProduct.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/GeneralProduct.h
new file mode 100644
index 00000000..694f7cbd
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/GeneralProduct.h
@@ -0,0 +1,466 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008-2011 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GENERAL_PRODUCT_H
+#define EIGEN_GENERAL_PRODUCT_H
+
+namespace Eigen {
+
+enum {
+  Large = 2,
+  Small = 3
+};
+
+// Define the threshold value to fallback from the generic matrix-matrix product
+// implementation (heavy) to the lightweight coeff-based product one.
+// See generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,GemmProduct>
+// in products/GeneralMatrixMatrix.h for more details.
+// TODO This threshold should also be used in the compile-time selector below.
+#ifndef EIGEN_GEMM_TO_COEFFBASED_THRESHOLD
+// This default value has been obtained on a Haswell architecture.
+#define EIGEN_GEMM_TO_COEFFBASED_THRESHOLD 20
+#endif
+
+namespace internal {
+
+template<int Rows, int Cols, int Depth> struct product_type_selector;
+
+template<int Size, int MaxSize> struct product_size_category
+{
+  enum {
+    #ifndef EIGEN_CUDA_ARCH
+    is_large = MaxSize == Dynamic ||
+               Size >= EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD ||
+               (Size==Dynamic && MaxSize>=EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD),
+    #else
+    is_large = 0,
+    #endif
+    value = is_large  ? Large
+          : Size == 1 ? 1
+                      : Small
+  };
+};
+
+template<typename Lhs, typename Rhs> struct product_type
+{
+  typedef typename remove_all<Lhs>::type _Lhs;
+  typedef typename remove_all<Rhs>::type _Rhs;
+  enum {
+    MaxRows = traits<_Lhs>::MaxRowsAtCompileTime,
+    Rows    = traits<_Lhs>::RowsAtCompileTime,
+    MaxCols = traits<_Rhs>::MaxColsAtCompileTime,
+    Cols    = traits<_Rhs>::ColsAtCompileTime,
+    MaxDepth = EIGEN_SIZE_MIN_PREFER_FIXED(traits<_Lhs>::MaxColsAtCompileTime,
+                                           traits<_Rhs>::MaxRowsAtCompileTime),
+    Depth = EIGEN_SIZE_MIN_PREFER_FIXED(traits<_Lhs>::ColsAtCompileTime,
+                                        traits<_Rhs>::RowsAtCompileTime)
+  };
+
+  // the splitting into different lines of code here, introducing the _select enums and the typedef below,
+  // is to work around an internal compiler error with gcc 4.1 and 4.2.
+private:
+  enum {
+    rows_select = product_size_category<Rows,MaxRows>::value,
+    cols_select = product_size_category<Cols,MaxCols>::value,
+    depth_select = product_size_category<Depth,MaxDepth>::value
+  };
+  typedef product_type_selector<rows_select, cols_select, depth_select> selector;
+
+public:
+  enum {
+    value = selector::ret,
+    ret = selector::ret
+  };
+#ifdef EIGEN_DEBUG_PRODUCT
+  static void debug()
+  {
+      EIGEN_DEBUG_VAR(Rows);
+      EIGEN_DEBUG_VAR(Cols);
+      EIGEN_DEBUG_VAR(Depth);
+      EIGEN_DEBUG_VAR(rows_select);
+      EIGEN_DEBUG_VAR(cols_select);
+      EIGEN_DEBUG_VAR(depth_select);
+      EIGEN_DEBUG_VAR(value);
+  }
+#endif
+};
+
+/* The following allows to select the kind of product at compile time
+ * based on the three dimensions of the product.
+ * This is a compile time mapping from {1,Small,Large}^3 -> {product types} */
+// FIXME I'm not sure the current mapping is the ideal one.
+template<int M, int N>  struct product_type_selector<M,N,1>              { enum { ret = OuterProduct }; };
+template<int M>         struct product_type_selector<M, 1, 1>            { enum { ret = LazyCoeffBasedProductMode }; };
+template<int N>         struct product_type_selector<1, N, 1>            { enum { ret = LazyCoeffBasedProductMode }; };
+template<int Depth>     struct product_type_selector<1,    1,    Depth>  { enum { ret = InnerProduct }; };
+template<>              struct product_type_selector<1,    1,    1>      { enum { ret = InnerProduct }; };
+template<>              struct product_type_selector<Small,1,    Small>  { enum { ret = CoeffBasedProductMode }; };
+template<>              struct product_type_selector<1,    Small,Small>  { enum { ret = CoeffBasedProductMode }; };
+template<>              struct product_type_selector<Small,Small,Small>  { enum { ret = CoeffBasedProductMode }; };
+template<>              struct product_type_selector<Small, Small, 1>    { enum { ret = LazyCoeffBasedProductMode }; };
+template<>              struct product_type_selector<Small, Large, 1>    { enum { ret = LazyCoeffBasedProductMode }; };
+template<>              struct product_type_selector<Large, Small, 1>    { enum { ret = LazyCoeffBasedProductMode }; };
+template<>              struct product_type_selector<1,    Large,Small>  { enum { ret = CoeffBasedProductMode }; };
+template<>              struct product_type_selector<1,    Large,Large>  { enum { ret = GemvProduct }; };
+template<>              struct product_type_selector<1,    Small,Large>  { enum { ret = CoeffBasedProductMode }; };
+template<>              struct product_type_selector<Large,1,    Small>  { enum { ret = CoeffBasedProductMode }; };
+template<>              struct product_type_selector<Large,1,    Large>  { enum { ret = GemvProduct }; };
+template<>              struct product_type_selector<Small,1,    Large>  { enum { ret = CoeffBasedProductMode }; };
+template<>              struct product_type_selector<Small,Small,Large>  { enum { ret = GemmProduct }; };
+template<>              struct product_type_selector<Large,Small,Large>  { enum { ret = GemmProduct }; };
+template<>              struct product_type_selector<Small,Large,Large>  { enum { ret = GemmProduct }; };
+template<>              struct product_type_selector<Large,Large,Large>  { enum { ret = GemmProduct }; };
+template<>              struct product_type_selector<Large,Small,Small>  { enum { ret = CoeffBasedProductMode }; };
+template<>              struct product_type_selector<Small,Large,Small>  { enum { ret = CoeffBasedProductMode }; };
+template<>              struct product_type_selector<Large,Large,Small>  { enum { ret = GemmProduct }; };
+
+} // end namespace internal
+
+/***********************************************************************
+*  Implementation of Inner Vector Vector Product
+***********************************************************************/
+
+// FIXME : maybe the "inner product" could return a Scalar
+// instead of a 1x1 matrix ??
+// Pro: more natural for the user
+// Cons: this could be a problem if in a meta unrolled algorithm a matrix-matrix
+// product ends up to a row-vector times col-vector product... To tackle this use
+// case, we could have a specialization for Block<MatrixType,1,1> with: operator=(Scalar x);
+
+/***********************************************************************
+*  Implementation of Outer Vector Vector Product
+***********************************************************************/
+
+/***********************************************************************
+*  Implementation of General Matrix Vector Product
+***********************************************************************/
+
+/*  According to the shape/flags of the matrix we have to distinghish 3 different cases:
+ *   1 - the matrix is col-major, BLAS compatible and M is large => call fast BLAS-like colmajor routine
+ *   2 - the matrix is row-major, BLAS compatible and N is large => call fast BLAS-like rowmajor routine
+ *   3 - all other cases are handled using a simple loop along the outer-storage direction.
+ *  Therefore we need a lower level meta selector.
+ *  Furthermore, if the matrix is the rhs, then the product has to be transposed.
+ */
+namespace internal {
+
+template<int Side, int StorageOrder, bool BlasCompatible>
+struct gemv_dense_selector;
+
+} // end namespace internal
+
+namespace internal {
+
+template<typename Scalar,int Size,int MaxSize,bool Cond> struct gemv_static_vector_if;
+
+template<typename Scalar,int Size,int MaxSize>
+struct gemv_static_vector_if<Scalar,Size,MaxSize,false>
+{
+  EIGEN_STRONG_INLINE  Scalar* data() { eigen_internal_assert(false && "should never be called"); return 0; }
+};
+
+template<typename Scalar,int Size>
+struct gemv_static_vector_if<Scalar,Size,Dynamic,true>
+{
+  EIGEN_STRONG_INLINE Scalar* data() { return 0; }
+};
+
+template<typename Scalar,int Size,int MaxSize>
+struct gemv_static_vector_if<Scalar,Size,MaxSize,true>
+{
+  enum {
+    ForceAlignment  = internal::packet_traits<Scalar>::Vectorizable,
+    PacketSize      = internal::packet_traits<Scalar>::size
+  };
+  #if EIGEN_MAX_STATIC_ALIGN_BYTES!=0
+  internal::plain_array<Scalar,EIGEN_SIZE_MIN_PREFER_FIXED(Size,MaxSize),0,EIGEN_PLAIN_ENUM_MIN(AlignedMax,PacketSize)> m_data;
+  EIGEN_STRONG_INLINE Scalar* data() { return m_data.array; }
+  #else
+  // Some architectures cannot align on the stack,
+  // => let's manually enforce alignment by allocating more data and return the address of the first aligned element.
+  internal::plain_array<Scalar,EIGEN_SIZE_MIN_PREFER_FIXED(Size,MaxSize)+(ForceAlignment?EIGEN_MAX_ALIGN_BYTES:0),0> m_data;
+  EIGEN_STRONG_INLINE Scalar* data() {
+    return ForceAlignment
+            ? reinterpret_cast<Scalar*>((internal::UIntPtr(m_data.array) & ~(std::size_t(EIGEN_MAX_ALIGN_BYTES-1))) + EIGEN_MAX_ALIGN_BYTES)
+            : m_data.array;
+  }
+  #endif
+};
+
+// The vector is on the left => transposition
+template<int StorageOrder, bool BlasCompatible>
+struct gemv_dense_selector<OnTheLeft,StorageOrder,BlasCompatible>
+{
+  template<typename Lhs, typename Rhs, typename Dest>
+  static void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha)
+  {
+    Transpose<Dest> destT(dest);
+    enum { OtherStorageOrder = StorageOrder == RowMajor ? ColMajor : RowMajor };
+    gemv_dense_selector<OnTheRight,OtherStorageOrder,BlasCompatible>
+      ::run(rhs.transpose(), lhs.transpose(), destT, alpha);
+  }
+};
+
+template<> struct gemv_dense_selector<OnTheRight,ColMajor,true>
+{
+  template<typename Lhs, typename Rhs, typename Dest>
+  static inline void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha)
+  {
+    typedef typename Lhs::Scalar   LhsScalar;
+    typedef typename Rhs::Scalar   RhsScalar;
+    typedef typename Dest::Scalar  ResScalar;
+    typedef typename Dest::RealScalar  RealScalar;
+    
+    typedef internal::blas_traits<Lhs> LhsBlasTraits;
+    typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
+    typedef internal::blas_traits<Rhs> RhsBlasTraits;
+    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
+  
+    typedef Map<Matrix<ResScalar,Dynamic,1>, EIGEN_PLAIN_ENUM_MIN(AlignedMax,internal::packet_traits<ResScalar>::size)> MappedDest;
+
+    ActualLhsType actualLhs = LhsBlasTraits::extract(lhs);
+    ActualRhsType actualRhs = RhsBlasTraits::extract(rhs);
+
+    ResScalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(lhs)
+                                  * RhsBlasTraits::extractScalarFactor(rhs);
+
+    // make sure Dest is a compile-time vector type (bug 1166)
+    typedef typename conditional<Dest::IsVectorAtCompileTime, Dest, typename Dest::ColXpr>::type ActualDest;
+
+    enum {
+      // FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
+      // on, the other hand it is good for the cache to pack the vector anyways...
+      EvalToDestAtCompileTime = (ActualDest::InnerStrideAtCompileTime==1),
+      ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex),
+      MightCannotUseDest = (!EvalToDestAtCompileTime) || ComplexByReal
+    };
+
+    typedef const_blas_data_mapper<LhsScalar,Index,ColMajor> LhsMapper;
+    typedef const_blas_data_mapper<RhsScalar,Index,RowMajor> RhsMapper;
+    RhsScalar compatibleAlpha = get_factor<ResScalar,RhsScalar>::run(actualAlpha);
+
+    if(!MightCannotUseDest)
+    {
+      // shortcut if we are sure to be able to use dest directly,
+      // this ease the compiler to generate cleaner and more optimzized code for most common cases
+      general_matrix_vector_product
+          <Index,LhsScalar,LhsMapper,ColMajor,LhsBlasTraits::NeedToConjugate,RhsScalar,RhsMapper,RhsBlasTraits::NeedToConjugate>::run(
+          actualLhs.rows(), actualLhs.cols(),
+          LhsMapper(actualLhs.data(), actualLhs.outerStride()),
+          RhsMapper(actualRhs.data(), actualRhs.innerStride()),
+          dest.data(), 1,
+          compatibleAlpha);
+    }
+    else
+    {
+      gemv_static_vector_if<ResScalar,ActualDest::SizeAtCompileTime,ActualDest::MaxSizeAtCompileTime,MightCannotUseDest> static_dest;
+
+      const bool alphaIsCompatible = (!ComplexByReal) || (numext::imag(actualAlpha)==RealScalar(0));
+      const bool evalToDest = EvalToDestAtCompileTime && alphaIsCompatible;
+
+      ei_declare_aligned_stack_constructed_variable(ResScalar,actualDestPtr,dest.size(),
+                                                    evalToDest ? dest.data() : static_dest.data());
+
+      if(!evalToDest)
+      {
+        #ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+        Index size = dest.size();
+        EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+        #endif
+        if(!alphaIsCompatible)
+        {
+          MappedDest(actualDestPtr, dest.size()).setZero();
+          compatibleAlpha = RhsScalar(1);
+        }
+        else
+          MappedDest(actualDestPtr, dest.size()) = dest;
+      }
+
+      general_matrix_vector_product
+          <Index,LhsScalar,LhsMapper,ColMajor,LhsBlasTraits::NeedToConjugate,RhsScalar,RhsMapper,RhsBlasTraits::NeedToConjugate>::run(
+          actualLhs.rows(), actualLhs.cols(),
+          LhsMapper(actualLhs.data(), actualLhs.outerStride()),
+          RhsMapper(actualRhs.data(), actualRhs.innerStride()),
+          actualDestPtr, 1,
+          compatibleAlpha);
+
+      if (!evalToDest)
+      {
+        if(!alphaIsCompatible)
+          dest.matrix() += actualAlpha * MappedDest(actualDestPtr, dest.size());
+        else
+          dest = MappedDest(actualDestPtr, dest.size());
+      }
+    }
+  }
+};
+
+template<> struct gemv_dense_selector<OnTheRight,RowMajor,true>
+{
+  template<typename Lhs, typename Rhs, typename Dest>
+  static void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha)
+  {
+    typedef typename Lhs::Scalar   LhsScalar;
+    typedef typename Rhs::Scalar   RhsScalar;
+    typedef typename Dest::Scalar  ResScalar;
+    
+    typedef internal::blas_traits<Lhs> LhsBlasTraits;
+    typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
+    typedef internal::blas_traits<Rhs> RhsBlasTraits;
+    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
+    typedef typename internal::remove_all<ActualRhsType>::type ActualRhsTypeCleaned;
+
+    typename add_const<ActualLhsType>::type actualLhs = LhsBlasTraits::extract(lhs);
+    typename add_const<ActualRhsType>::type actualRhs = RhsBlasTraits::extract(rhs);
+
+    ResScalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(lhs)
+                                  * RhsBlasTraits::extractScalarFactor(rhs);
+
+    enum {
+      // FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
+      // on, the other hand it is good for the cache to pack the vector anyways...
+      DirectlyUseRhs = ActualRhsTypeCleaned::InnerStrideAtCompileTime==1
+    };
+
+    gemv_static_vector_if<RhsScalar,ActualRhsTypeCleaned::SizeAtCompileTime,ActualRhsTypeCleaned::MaxSizeAtCompileTime,!DirectlyUseRhs> static_rhs;
+
+    ei_declare_aligned_stack_constructed_variable(RhsScalar,actualRhsPtr,actualRhs.size(),
+        DirectlyUseRhs ? const_cast<RhsScalar*>(actualRhs.data()) : static_rhs.data());
+
+    if(!DirectlyUseRhs)
+    {
+      #ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+      Index size = actualRhs.size();
+      EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+      #endif
+      Map<typename ActualRhsTypeCleaned::PlainObject>(actualRhsPtr, actualRhs.size()) = actualRhs;
+    }
+
+    typedef const_blas_data_mapper<LhsScalar,Index,RowMajor> LhsMapper;
+    typedef const_blas_data_mapper<RhsScalar,Index,ColMajor> RhsMapper;
+    general_matrix_vector_product
+        <Index,LhsScalar,LhsMapper,RowMajor,LhsBlasTraits::NeedToConjugate,RhsScalar,RhsMapper,RhsBlasTraits::NeedToConjugate>::run(
+        actualLhs.rows(), actualLhs.cols(),
+        LhsMapper(actualLhs.data(), actualLhs.outerStride()),
+        RhsMapper(actualRhsPtr, 1),
+        dest.data(), dest.col(0).innerStride(), //NOTE  if dest is not a vector at compile-time, then dest.innerStride() might be wrong. (bug 1166)
+        actualAlpha);
+  }
+};
+
+template<> struct gemv_dense_selector<OnTheRight,ColMajor,false>
+{
+  template<typename Lhs, typename Rhs, typename Dest>
+  static void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha)
+  {
+    EIGEN_STATIC_ASSERT((!nested_eval<Lhs,1>::Evaluate),EIGEN_INTERNAL_COMPILATION_ERROR_OR_YOU_MADE_A_PROGRAMMING_MISTAKE);
+    // TODO if rhs is large enough it might be beneficial to make sure that dest is sequentially stored in memory, otherwise use a temp
+    typename nested_eval<Rhs,1>::type actual_rhs(rhs);
+    const Index size = rhs.rows();
+    for(Index k=0; k<size; ++k)
+      dest += (alpha*actual_rhs.coeff(k)) * lhs.col(k);
+  }
+};
+
+template<> struct gemv_dense_selector<OnTheRight,RowMajor,false>
+{
+  template<typename Lhs, typename Rhs, typename Dest>
+  static void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha)
+  {
+    EIGEN_STATIC_ASSERT((!nested_eval<Lhs,1>::Evaluate),EIGEN_INTERNAL_COMPILATION_ERROR_OR_YOU_MADE_A_PROGRAMMING_MISTAKE);
+    typename nested_eval<Rhs,Lhs::RowsAtCompileTime>::type actual_rhs(rhs);
+    const Index rows = dest.rows();
+    for(Index i=0; i<rows; ++i)
+      dest.coeffRef(i) += alpha * (lhs.row(i).cwiseProduct(actual_rhs.transpose())).sum();
+  }
+};
+
+} // end namespace internal
+
+/***************************************************************************
+* Implementation of matrix base methods
+***************************************************************************/
+
+/** \returns the matrix product of \c *this and \a other.
+  *
+  * \note If instead of the matrix product you want the coefficient-wise product, see Cwise::operator*().
+  *
+  * \sa lazyProduct(), operator*=(const MatrixBase&), Cwise::operator*()
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+inline const Product<Derived, OtherDerived>
+MatrixBase<Derived>::operator*(const MatrixBase<OtherDerived> &other) const
+{
+  // A note regarding the function declaration: In MSVC, this function will sometimes
+  // not be inlined since DenseStorage is an unwindable object for dynamic
+  // matrices and product types are holding a member to store the result.
+  // Thus it does not help tagging this function with EIGEN_STRONG_INLINE.
+  enum {
+    ProductIsValid =  Derived::ColsAtCompileTime==Dynamic
+                   || OtherDerived::RowsAtCompileTime==Dynamic
+                   || int(Derived::ColsAtCompileTime)==int(OtherDerived::RowsAtCompileTime),
+    AreVectors = Derived::IsVectorAtCompileTime && OtherDerived::IsVectorAtCompileTime,
+    SameSizes = EIGEN_PREDICATE_SAME_MATRIX_SIZE(Derived,OtherDerived)
+  };
+  // note to the lost user:
+  //    * for a dot product use: v1.dot(v2)
+  //    * for a coeff-wise product use: v1.cwiseProduct(v2)
+  EIGEN_STATIC_ASSERT(ProductIsValid || !(AreVectors && SameSizes),
+    INVALID_VECTOR_VECTOR_PRODUCT__IF_YOU_WANTED_A_DOT_OR_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTIONS)
+  EIGEN_STATIC_ASSERT(ProductIsValid || !(SameSizes && !AreVectors),
+    INVALID_MATRIX_PRODUCT__IF_YOU_WANTED_A_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTION)
+  EIGEN_STATIC_ASSERT(ProductIsValid || SameSizes, INVALID_MATRIX_PRODUCT)
+#ifdef EIGEN_DEBUG_PRODUCT
+  internal::product_type<Derived,OtherDerived>::debug();
+#endif
+
+  return Product<Derived, OtherDerived>(derived(), other.derived());
+}
+
+/** \returns an expression of the matrix product of \c *this and \a other without implicit evaluation.
+  *
+  * The returned product will behave like any other expressions: the coefficients of the product will be
+  * computed once at a time as requested. This might be useful in some extremely rare cases when only
+  * a small and no coherent fraction of the result's coefficients have to be computed.
+  *
+  * \warning This version of the matrix product can be much much slower. So use it only if you know
+  * what you are doing and that you measured a true speed improvement.
+  *
+  * \sa operator*(const MatrixBase&)
+  */
+template<typename Derived>
+template<typename OtherDerived>
+const Product<Derived,OtherDerived,LazyProduct>
+EIGEN_DEVICE_FUNC MatrixBase<Derived>::lazyProduct(const MatrixBase<OtherDerived> &other) const
+{
+  enum {
+    ProductIsValid =  Derived::ColsAtCompileTime==Dynamic
+                   || OtherDerived::RowsAtCompileTime==Dynamic
+                   || int(Derived::ColsAtCompileTime)==int(OtherDerived::RowsAtCompileTime),
+    AreVectors = Derived::IsVectorAtCompileTime && OtherDerived::IsVectorAtCompileTime,
+    SameSizes = EIGEN_PREDICATE_SAME_MATRIX_SIZE(Derived,OtherDerived)
+  };
+  // note to the lost user:
+  //    * for a dot product use: v1.dot(v2)
+  //    * for a coeff-wise product use: v1.cwiseProduct(v2)
+  EIGEN_STATIC_ASSERT(ProductIsValid || !(AreVectors && SameSizes),
+    INVALID_VECTOR_VECTOR_PRODUCT__IF_YOU_WANTED_A_DOT_OR_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTIONS)
+  EIGEN_STATIC_ASSERT(ProductIsValid || !(SameSizes && !AreVectors),
+    INVALID_MATRIX_PRODUCT__IF_YOU_WANTED_A_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTION)
+  EIGEN_STATIC_ASSERT(ProductIsValid || SameSizes, INVALID_MATRIX_PRODUCT)
+
+  return Product<Derived,OtherDerived,LazyProduct>(derived(), other.derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_PRODUCT_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/GenericPacketMath.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/GenericPacketMath.h
new file mode 100644
index 00000000..30878eda
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/GenericPacketMath.h
@@ -0,0 +1,598 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GENERIC_PACKET_MATH_H
+#define EIGEN_GENERIC_PACKET_MATH_H
+
+namespace Eigen {
+
+namespace internal {
+
+/** \internal
+  * \file GenericPacketMath.h
+  *
+  * Default implementation for types not supported by the vectorization.
+  * In practice these functions are provided to make easier the writing
+  * of generic vectorized code.
+  */
+
+#ifndef EIGEN_DEBUG_ALIGNED_LOAD
+#define EIGEN_DEBUG_ALIGNED_LOAD
+#endif
+
+#ifndef EIGEN_DEBUG_UNALIGNED_LOAD
+#define EIGEN_DEBUG_UNALIGNED_LOAD
+#endif
+
+#ifndef EIGEN_DEBUG_ALIGNED_STORE
+#define EIGEN_DEBUG_ALIGNED_STORE
+#endif
+
+#ifndef EIGEN_DEBUG_UNALIGNED_STORE
+#define EIGEN_DEBUG_UNALIGNED_STORE
+#endif
+
+struct default_packet_traits
+{
+  enum {
+    HasHalfPacket = 0,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasNegate = 1,
+    HasAbs    = 1,
+    HasArg    = 0,
+    HasAbs2   = 1,
+    HasMin    = 1,
+    HasMax    = 1,
+    HasConj   = 1,
+    HasSetLinear = 1,
+    HasBlend  = 0,
+
+    HasDiv    = 0,
+    HasSqrt   = 0,
+    HasRsqrt  = 0,
+    HasExp    = 0,
+    HasExpm1  = 0,
+    HasLog    = 0,
+    HasLog1p  = 0,
+    HasLog10  = 0,
+    HasPow    = 0,
+
+    HasSin    = 0,
+    HasCos    = 0,
+    HasTan    = 0,
+    HasASin   = 0,
+    HasACos   = 0,
+    HasATan   = 0,
+    HasSinh   = 0,
+    HasCosh   = 0,
+    HasTanh   = 0,
+    HasLGamma = 0,
+    HasDiGamma = 0,
+    HasZeta = 0,
+    HasPolygamma = 0,
+    HasErf = 0,
+    HasErfc = 0,
+    HasIGamma = 0,
+    HasIGammac = 0,
+    HasBetaInc = 0,
+
+    HasRound  = 0,
+    HasFloor  = 0,
+    HasCeil   = 0,
+
+    HasSign   = 0
+  };
+};
+
+template<typename T> struct packet_traits : default_packet_traits
+{
+  typedef T type;
+  typedef T half;
+  enum {
+    Vectorizable = 0,
+    size = 1,
+    AlignedOnScalar = 0,
+    HasHalfPacket = 0
+  };
+  enum {
+    HasAdd    = 0,
+    HasSub    = 0,
+    HasMul    = 0,
+    HasNegate = 0,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasConj   = 0,
+    HasSetLinear = 0
+  };
+};
+
+template<typename T> struct packet_traits<const T> : packet_traits<T> { };
+
+template <typename Src, typename Tgt> struct type_casting_traits {
+  enum {
+    VectorizedCast = 0,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+
+/** \internal \returns static_cast<TgtType>(a) (coeff-wise) */
+template <typename SrcPacket, typename TgtPacket>
+EIGEN_DEVICE_FUNC inline TgtPacket
+pcast(const SrcPacket& a) {
+  return static_cast<TgtPacket>(a);
+}
+template <typename SrcPacket, typename TgtPacket>
+EIGEN_DEVICE_FUNC inline TgtPacket
+pcast(const SrcPacket& a, const SrcPacket& /*b*/) {
+  return static_cast<TgtPacket>(a);
+}
+
+template <typename SrcPacket, typename TgtPacket>
+EIGEN_DEVICE_FUNC inline TgtPacket
+pcast(const SrcPacket& a, const SrcPacket& /*b*/, const SrcPacket& /*c*/, const SrcPacket& /*d*/) {
+  return static_cast<TgtPacket>(a);
+}
+
+/** \internal \returns a + b (coeff-wise) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+padd(const Packet& a,
+        const Packet& b) { return a+b; }
+
+/** \internal \returns a - b (coeff-wise) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+psub(const Packet& a,
+        const Packet& b) { return a-b; }
+
+/** \internal \returns -a (coeff-wise) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pnegate(const Packet& a) { return -a; }
+
+/** \internal \returns conj(a) (coeff-wise) */
+
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pconj(const Packet& a) { return numext::conj(a); }
+
+/** \internal \returns a * b (coeff-wise) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pmul(const Packet& a,
+        const Packet& b) { return a*b; }
+
+/** \internal \returns a / b (coeff-wise) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pdiv(const Packet& a,
+        const Packet& b) { return a/b; }
+
+/** \internal \returns the min of \a a and \a b  (coeff-wise) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pmin(const Packet& a,
+        const Packet& b) { return numext::mini(a, b); }
+
+/** \internal \returns the max of \a a and \a b  (coeff-wise) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pmax(const Packet& a,
+        const Packet& b) { return numext::maxi(a, b); }
+
+/** \internal \returns the absolute value of \a a */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pabs(const Packet& a) { using std::abs; return abs(a); }
+
+/** \internal \returns the phase angle of \a a */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+parg(const Packet& a) { using numext::arg; return arg(a); }
+
+/** \internal \returns the bitwise and of \a a and \a b */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pand(const Packet& a, const Packet& b) { return a & b; }
+
+/** \internal \returns the bitwise or of \a a and \a b */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+por(const Packet& a, const Packet& b) { return a | b; }
+
+/** \internal \returns the bitwise xor of \a a and \a b */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pxor(const Packet& a, const Packet& b) { return a ^ b; }
+
+/** \internal \returns the bitwise andnot of \a a and \a b */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pandnot(const Packet& a, const Packet& b) { return a & (!b); }
+
+/** \internal \returns a packet version of \a *from, from must be 16 bytes aligned */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pload(const typename unpacket_traits<Packet>::type* from) { return *from; }
+
+/** \internal \returns a packet version of \a *from, (un-aligned load) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+ploadu(const typename unpacket_traits<Packet>::type* from) { return *from; }
+
+/** \internal \returns a packet with constant coefficients \a a, e.g.: (a,a,a,a) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pset1(const typename unpacket_traits<Packet>::type& a) { return a; }
+
+/** \internal \returns a packet with constant coefficients \a a[0], e.g.: (a[0],a[0],a[0],a[0]) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pload1(const typename unpacket_traits<Packet>::type  *a) { return pset1<Packet>(*a); }
+
+/** \internal \returns a packet with elements of \a *from duplicated.
+  * For instance, for a packet of 8 elements, 4 scalars will be read from \a *from and
+  * duplicated to form: {from[0],from[0],from[1],from[1],from[2],from[2],from[3],from[3]}
+  * Currently, this function is only used for scalar * complex products.
+  */
+template<typename Packet> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet
+ploaddup(const typename unpacket_traits<Packet>::type* from) { return *from; }
+
+/** \internal \returns a packet with elements of \a *from quadrupled.
+  * For instance, for a packet of 8 elements, 2 scalars will be read from \a *from and
+  * replicated to form: {from[0],from[0],from[0],from[0],from[1],from[1],from[1],from[1]}
+  * Currently, this function is only used in matrix products.
+  * For packet-size smaller or equal to 4, this function is equivalent to pload1 
+  */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+ploadquad(const typename unpacket_traits<Packet>::type* from)
+{ return pload1<Packet>(from); }
+
+/** \internal equivalent to
+  * \code
+  * a0 = pload1(a+0);
+  * a1 = pload1(a+1);
+  * a2 = pload1(a+2);
+  * a3 = pload1(a+3);
+  * \endcode
+  * \sa pset1, pload1, ploaddup, pbroadcast2
+  */
+template<typename Packet> EIGEN_DEVICE_FUNC
+inline void pbroadcast4(const typename unpacket_traits<Packet>::type *a,
+                        Packet& a0, Packet& a1, Packet& a2, Packet& a3)
+{
+  a0 = pload1<Packet>(a+0);
+  a1 = pload1<Packet>(a+1);
+  a2 = pload1<Packet>(a+2);
+  a3 = pload1<Packet>(a+3);
+}
+
+/** \internal equivalent to
+  * \code
+  * a0 = pload1(a+0);
+  * a1 = pload1(a+1);
+  * \endcode
+  * \sa pset1, pload1, ploaddup, pbroadcast4
+  */
+template<typename Packet> EIGEN_DEVICE_FUNC
+inline void pbroadcast2(const typename unpacket_traits<Packet>::type *a,
+                        Packet& a0, Packet& a1)
+{
+  a0 = pload1<Packet>(a+0);
+  a1 = pload1<Packet>(a+1);
+}
+
+/** \internal \brief Returns a packet with coefficients (a,a+1,...,a+packet_size-1). */
+template<typename Packet> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet
+plset(const typename unpacket_traits<Packet>::type& a) { return a; }
+
+/** \internal copy the packet \a from to \a *to, \a to must be 16 bytes aligned */
+template<typename Scalar, typename Packet> EIGEN_DEVICE_FUNC inline void pstore(Scalar* to, const Packet& from)
+{ (*to) = from; }
+
+/** \internal copy the packet \a from to \a *to, (un-aligned store) */
+template<typename Scalar, typename Packet> EIGEN_DEVICE_FUNC inline void pstoreu(Scalar* to, const Packet& from)
+{  (*to) = from; }
+
+ template<typename Scalar, typename Packet> EIGEN_DEVICE_FUNC inline Packet pgather(const Scalar* from, Index /*stride*/)
+ { return ploadu<Packet>(from); }
+
+ template<typename Scalar, typename Packet> EIGEN_DEVICE_FUNC inline void pscatter(Scalar* to, const Packet& from, Index /*stride*/)
+ { pstore(to, from); }
+
+/** \internal tries to do cache prefetching of \a addr */
+template<typename Scalar> EIGEN_DEVICE_FUNC inline void prefetch(const Scalar* addr)
+{
+#ifdef EIGEN_CUDA_ARCH
+#if defined(__LP64__)
+  // 64-bit pointer operand constraint for inlined asm
+  asm(" prefetch.L1 [ %1 ];" : "=l"(addr) : "l"(addr));
+#else
+  // 32-bit pointer operand constraint for inlined asm
+  asm(" prefetch.L1 [ %1 ];" : "=r"(addr) : "r"(addr));
+#endif
+#elif (!EIGEN_COMP_MSVC) && (EIGEN_COMP_GNUC || EIGEN_COMP_CLANG || EIGEN_COMP_ICC)
+  __builtin_prefetch(addr);
+#endif
+}
+
+/** \internal \returns the first element of a packet */
+template<typename Packet> EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type pfirst(const Packet& a)
+{ return a; }
+
+/** \internal \returns a packet where the element i contains the sum of the packet of \a vec[i] */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+preduxp(const Packet* vecs) { return vecs[0]; }
+
+/** \internal \returns the sum of the elements of \a a*/
+template<typename Packet> EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux(const Packet& a)
+{ return a; }
+
+/** \internal \returns the sum of the elements of \a a by block of 4 elements.
+  * For a packet {a0, a1, a2, a3, a4, a5, a6, a7}, it returns a half packet {a0+a4, a1+a5, a2+a6, a3+a7}
+  * For packet-size smaller or equal to 4, this boils down to a noop.
+  */
+template<typename Packet> EIGEN_DEVICE_FUNC inline
+typename conditional<(unpacket_traits<Packet>::size%8)==0,typename unpacket_traits<Packet>::half,Packet>::type
+predux_downto4(const Packet& a)
+{ return a; }
+
+/** \internal \returns the product of the elements of \a a*/
+template<typename Packet> EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux_mul(const Packet& a)
+{ return a; }
+
+/** \internal \returns the min of the elements of \a a*/
+template<typename Packet> EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux_min(const Packet& a)
+{ return a; }
+
+/** \internal \returns the max of the elements of \a a*/
+template<typename Packet> EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux_max(const Packet& a)
+{ return a; }
+
+/** \internal \returns the reversed elements of \a a*/
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet preverse(const Packet& a)
+{ return a; }
+
+/** \internal \returns \a a with real and imaginary part flipped (for complex type only) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet pcplxflip(const Packet& a)
+{
+  // FIXME: uncomment the following in case we drop the internal imag and real functions.
+//   using std::imag;
+//   using std::real;
+  return Packet(imag(a),real(a));
+}
+
+/**************************
+* Special math functions
+***************************/
+
+/** \internal \returns the sine of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet psin(const Packet& a) { using std::sin; return sin(a); }
+
+/** \internal \returns the cosine of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet pcos(const Packet& a) { using std::cos; return cos(a); }
+
+/** \internal \returns the tan of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet ptan(const Packet& a) { using std::tan; return tan(a); }
+
+/** \internal \returns the arc sine of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet pasin(const Packet& a) { using std::asin; return asin(a); }
+
+/** \internal \returns the arc cosine of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet pacos(const Packet& a) { using std::acos; return acos(a); }
+
+/** \internal \returns the arc tangent of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet patan(const Packet& a) { using std::atan; return atan(a); }
+
+/** \internal \returns the hyperbolic sine of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet psinh(const Packet& a) { using std::sinh; return sinh(a); }
+
+/** \internal \returns the hyperbolic cosine of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet pcosh(const Packet& a) { using std::cosh; return cosh(a); }
+
+/** \internal \returns the hyperbolic tan of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet ptanh(const Packet& a) { using std::tanh; return tanh(a); }
+
+/** \internal \returns the exp of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet pexp(const Packet& a) { using std::exp; return exp(a); }
+
+/** \internal \returns the expm1 of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet pexpm1(const Packet& a) { return numext::expm1(a); }
+
+/** \internal \returns the log of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet plog(const Packet& a) { using std::log; return log(a); }
+
+/** \internal \returns the log1p of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet plog1p(const Packet& a) { return numext::log1p(a); }
+
+/** \internal \returns the log10 of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet plog10(const Packet& a) { using std::log10; return log10(a); }
+
+/** \internal \returns the square-root of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet psqrt(const Packet& a) { using std::sqrt; return sqrt(a); }
+
+/** \internal \returns the reciprocal square-root of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet prsqrt(const Packet& a) {
+  return pdiv(pset1<Packet>(1), psqrt(a));
+}
+
+/** \internal \returns the rounded value of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet pround(const Packet& a) { using numext::round; return round(a); }
+
+/** \internal \returns the floor of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet pfloor(const Packet& a) { using numext::floor; return floor(a); }
+
+/** \internal \returns the ceil of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet pceil(const Packet& a) { using numext::ceil; return ceil(a); }
+
+/***************************************************************************
+* The following functions might not have to be overwritten for vectorized types
+***************************************************************************/
+
+/** \internal copy a packet with constant coeficient \a a (e.g., [a,a,a,a]) to \a *to. \a to must be 16 bytes aligned */
+// NOTE: this function must really be templated on the packet type (think about different packet types for the same scalar type)
+template<typename Packet>
+inline void pstore1(typename unpacket_traits<Packet>::type* to, const typename unpacket_traits<Packet>::type& a)
+{
+  pstore(to, pset1<Packet>(a));
+}
+
+/** \internal \returns a * b + c (coeff-wise) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pmadd(const Packet&  a,
+         const Packet&  b,
+         const Packet&  c)
+{ return padd(pmul(a, b),c); }
+
+/** \internal \returns a packet version of \a *from.
+  * The pointer \a from must be aligned on a \a Alignment bytes boundary. */
+template<typename Packet, int Alignment>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet ploadt(const typename unpacket_traits<Packet>::type* from)
+{
+  if(Alignment >= unpacket_traits<Packet>::alignment)
+    return pload<Packet>(from);
+  else
+    return ploadu<Packet>(from);
+}
+
+/** \internal copy the packet \a from to \a *to.
+  * The pointer \a from must be aligned on a \a Alignment bytes boundary. */
+template<typename Scalar, typename Packet, int Alignment>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void pstoret(Scalar* to, const Packet& from)
+{
+  if(Alignment >= unpacket_traits<Packet>::alignment)
+    pstore(to, from);
+  else
+    pstoreu(to, from);
+}
+
+/** \internal \returns a packet version of \a *from.
+  * Unlike ploadt, ploadt_ro takes advantage of the read-only memory path on the
+  * hardware if available to speedup the loading of data that won't be modified
+  * by the current computation.
+  */
+template<typename Packet, int LoadMode>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet ploadt_ro(const typename unpacket_traits<Packet>::type* from)
+{
+  return ploadt<Packet, LoadMode>(from);
+}
+
+/** \internal default implementation of palign() allowing partial specialization */
+template<int Offset,typename PacketType>
+struct palign_impl
+{
+  // by default data are aligned, so there is nothing to be done :)
+  static inline void run(PacketType&, const PacketType&) {}
+};
+
+/** \internal update \a first using the concatenation of the packet_size minus \a Offset last elements
+  * of \a first and \a Offset first elements of \a second.
+  * 
+  * This function is currently only used to optimize matrix-vector products on unligned matrices.
+  * It takes 2 packets that represent a contiguous memory array, and returns a packet starting
+  * at the position \a Offset. For instance, for packets of 4 elements, we have:
+  *  Input:
+  *  - first = {f0,f1,f2,f3}
+  *  - second = {s0,s1,s2,s3}
+  * Output: 
+  *   - if Offset==0 then {f0,f1,f2,f3}
+  *   - if Offset==1 then {f1,f2,f3,s0}
+  *   - if Offset==2 then {f2,f3,s0,s1}
+  *   - if Offset==3 then {f3,s0,s1,s3}
+  */
+template<int Offset,typename PacketType>
+inline void palign(PacketType& first, const PacketType& second)
+{
+  palign_impl<Offset,PacketType>::run(first,second);
+}
+
+/***************************************************************************
+* Fast complex products (GCC generates a function call which is very slow)
+***************************************************************************/
+
+// Eigen+CUDA does not support complexes.
+#ifndef EIGEN_CUDACC
+
+template<> inline std::complex<float> pmul(const std::complex<float>& a, const std::complex<float>& b)
+{ return std::complex<float>(real(a)*real(b) - imag(a)*imag(b), imag(a)*real(b) + real(a)*imag(b)); }
+
+template<> inline std::complex<double> pmul(const std::complex<double>& a, const std::complex<double>& b)
+{ return std::complex<double>(real(a)*real(b) - imag(a)*imag(b), imag(a)*real(b) + real(a)*imag(b)); }
+
+#endif
+
+
+/***************************************************************************
+ * PacketBlock, that is a collection of N packets where the number of words
+ * in the packet is a multiple of N.
+***************************************************************************/
+template <typename Packet,int N=unpacket_traits<Packet>::size> struct PacketBlock {
+  Packet packet[N];
+};
+
+template<typename Packet> EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet,1>& /*kernel*/) {
+  // Nothing to do in the scalar case, i.e. a 1x1 matrix.
+}
+
+/***************************************************************************
+ * Selector, i.e. vector of N boolean values used to select (i.e. blend)
+ * words from 2 packets.
+***************************************************************************/
+template <size_t N> struct Selector {
+  bool select[N];
+};
+
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pblend(const Selector<unpacket_traits<Packet>::size>& ifPacket, const Packet& thenPacket, const Packet& elsePacket) {
+  return ifPacket.select[0] ? thenPacket : elsePacket;
+}
+
+/** \internal \returns \a a with the first coefficient replaced by the scalar b */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pinsertfirst(const Packet& a, typename unpacket_traits<Packet>::type b)
+{
+  // Default implementation based on pblend.
+  // It must be specialized for higher performance.
+  Selector<unpacket_traits<Packet>::size> mask;
+  mask.select[0] = true;
+  // This for loop should be optimized away by the compiler.
+  for(Index i=1; i<unpacket_traits<Packet>::size; ++i)
+    mask.select[i] = false;
+  return pblend(mask, pset1<Packet>(b), a);
+}
+
+/** \internal \returns \a a with the last coefficient replaced by the scalar b */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pinsertlast(const Packet& a, typename unpacket_traits<Packet>::type b)
+{
+  // Default implementation based on pblend.
+  // It must be specialized for higher performance.
+  Selector<unpacket_traits<Packet>::size> mask;
+  // This for loop should be optimized away by the compiler.
+  for(Index i=0; i<unpacket_traits<Packet>::size-1; ++i)
+    mask.select[i] = false;
+  mask.select[unpacket_traits<Packet>::size-1] = true;
+  return pblend(mask, pset1<Packet>(b), a);
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_GENERIC_PACKET_MATH_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/GlobalFunctions.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/GlobalFunctions.h
new file mode 100644
index 00000000..50406400
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/GlobalFunctions.h
@@ -0,0 +1,185 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010-2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GLOBAL_FUNCTIONS_H
+#define EIGEN_GLOBAL_FUNCTIONS_H
+
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+
+#define EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(NAME,FUNCTOR,DOC_OP,DOC_DETAILS) \
+  /** \returns an expression of the coefficient-wise DOC_OP of \a x
+
+    DOC_DETAILS
+
+    \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_##NAME">Math functions</a>, class CwiseUnaryOp
+    */ \
+  template<typename Derived> \
+  inline const Eigen::CwiseUnaryOp<Eigen::internal::FUNCTOR<typename Derived::Scalar>, const Derived> \
+  NAME(const Eigen::ArrayBase<Derived>& x);
+
+#else
+
+#define EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(NAME,FUNCTOR,DOC_OP,DOC_DETAILS) \
+  template<typename Derived> \
+  inline const Eigen::CwiseUnaryOp<Eigen::internal::FUNCTOR<typename Derived::Scalar>, const Derived> \
+  (NAME)(const Eigen::ArrayBase<Derived>& x) { \
+    return Eigen::CwiseUnaryOp<Eigen::internal::FUNCTOR<typename Derived::Scalar>, const Derived>(x.derived()); \
+  }
+
+#endif // EIGEN_PARSED_BY_DOXYGEN
+
+#define EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(NAME,FUNCTOR) \
+  \
+  template<typename Derived> \
+  struct NAME##_retval<ArrayBase<Derived> > \
+  { \
+    typedef const Eigen::CwiseUnaryOp<Eigen::internal::FUNCTOR<typename Derived::Scalar>, const Derived> type; \
+  }; \
+  template<typename Derived> \
+  struct NAME##_impl<ArrayBase<Derived> > \
+  { \
+    static inline typename NAME##_retval<ArrayBase<Derived> >::type run(const Eigen::ArrayBase<Derived>& x) \
+    { \
+      return typename NAME##_retval<ArrayBase<Derived> >::type(x.derived()); \
+    } \
+  };
+
+namespace Eigen
+{
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(real,scalar_real_op,real part,\sa ArrayBase::real)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(imag,scalar_imag_op,imaginary part,\sa ArrayBase::imag)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(conj,scalar_conjugate_op,complex conjugate,\sa ArrayBase::conjugate)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(inverse,scalar_inverse_op,inverse,\sa ArrayBase::inverse)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(sin,scalar_sin_op,sine,\sa ArrayBase::sin)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(cos,scalar_cos_op,cosine,\sa ArrayBase::cos)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(tan,scalar_tan_op,tangent,\sa ArrayBase::tan)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(atan,scalar_atan_op,arc-tangent,\sa ArrayBase::atan)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(asin,scalar_asin_op,arc-sine,\sa ArrayBase::asin)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(acos,scalar_acos_op,arc-consine,\sa ArrayBase::acos)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(sinh,scalar_sinh_op,hyperbolic sine,\sa ArrayBase::sinh)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(cosh,scalar_cosh_op,hyperbolic cosine,\sa ArrayBase::cosh)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(tanh,scalar_tanh_op,hyperbolic tangent,\sa ArrayBase::tanh)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(lgamma,scalar_lgamma_op,natural logarithm of the gamma function,\sa ArrayBase::lgamma)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(digamma,scalar_digamma_op,derivative of lgamma,\sa ArrayBase::digamma)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(erf,scalar_erf_op,error function,\sa ArrayBase::erf)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(erfc,scalar_erfc_op,complement error function,\sa ArrayBase::erfc)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(exp,scalar_exp_op,exponential,\sa ArrayBase::exp)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(expm1,scalar_expm1_op,exponential of a value minus 1,\sa ArrayBase::expm1)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(log,scalar_log_op,natural logarithm,\sa Eigen::log10 DOXCOMMA ArrayBase::log)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(log1p,scalar_log1p_op,natural logarithm of 1 plus the value,\sa ArrayBase::log1p)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(log10,scalar_log10_op,base 10 logarithm,\sa Eigen::log DOXCOMMA ArrayBase::log)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(abs,scalar_abs_op,absolute value,\sa ArrayBase::abs DOXCOMMA MatrixBase::cwiseAbs)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(abs2,scalar_abs2_op,squared absolute value,\sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(arg,scalar_arg_op,complex argument,\sa ArrayBase::arg)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(sqrt,scalar_sqrt_op,square root,\sa ArrayBase::sqrt DOXCOMMA MatrixBase::cwiseSqrt)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(rsqrt,scalar_rsqrt_op,reciprocal square root,\sa ArrayBase::rsqrt)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(square,scalar_square_op,square (power 2),\sa Eigen::abs2 DOXCOMMA Eigen::pow DOXCOMMA ArrayBase::square)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(cube,scalar_cube_op,cube (power 3),\sa Eigen::pow DOXCOMMA ArrayBase::cube)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(round,scalar_round_op,nearest integer,\sa Eigen::floor DOXCOMMA Eigen::ceil DOXCOMMA ArrayBase::round)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(floor,scalar_floor_op,nearest integer not greater than the giben value,\sa Eigen::ceil DOXCOMMA ArrayBase::floor)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(ceil,scalar_ceil_op,nearest integer not less than the giben value,\sa Eigen::floor DOXCOMMA ArrayBase::ceil)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(isnan,scalar_isnan_op,not-a-number test,\sa Eigen::isinf DOXCOMMA Eigen::isfinite DOXCOMMA ArrayBase::isnan)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(isinf,scalar_isinf_op,infinite value test,\sa Eigen::isnan DOXCOMMA Eigen::isfinite DOXCOMMA ArrayBase::isinf)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(isfinite,scalar_isfinite_op,finite value test,\sa Eigen::isinf DOXCOMMA Eigen::isnan DOXCOMMA ArrayBase::isfinite)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(sign,scalar_sign_op,sign (or 0),\sa ArrayBase::sign)
+  
+  /** \returns an expression of the coefficient-wise power of \a x to the given constant \a exponent.
+    *
+    * \tparam ScalarExponent is the scalar type of \a exponent. It must be compatible with the scalar type of the given expression (\c Derived::Scalar).
+    *
+    * \sa ArrayBase::pow()
+    *
+    * \relates ArrayBase
+    */
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+  template<typename Derived,typename ScalarExponent>
+  inline const CwiseBinaryOp<internal::scalar_pow_op<Derived::Scalar,ScalarExponent>,Derived,Constant<ScalarExponent> >
+  pow(const Eigen::ArrayBase<Derived>& x, const ScalarExponent& exponent);
+#else
+  template <typename Derived,typename ScalarExponent>
+  EIGEN_DEVICE_FUNC inline
+  EIGEN_MSVC10_WORKAROUND_BINARYOP_RETURN_TYPE(
+    const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Derived,typename internal::promote_scalar_arg<typename Derived::Scalar
+                                                 EIGEN_COMMA ScalarExponent EIGEN_COMMA
+                                                 EIGEN_SCALAR_BINARY_SUPPORTED(pow,typename Derived::Scalar,ScalarExponent)>::type,pow))
+  pow(const Eigen::ArrayBase<Derived>& x, const ScalarExponent& exponent)
+  {
+    typedef typename internal::promote_scalar_arg<typename Derived::Scalar,ScalarExponent,
+                                                  EIGEN_SCALAR_BINARY_SUPPORTED(pow,typename Derived::Scalar,ScalarExponent)>::type PromotedExponent;
+    return EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Derived,PromotedExponent,pow)(x.derived(),
+           typename internal::plain_constant_type<Derived,PromotedExponent>::type(x.derived().rows(), x.derived().cols(), internal::scalar_constant_op<PromotedExponent>(exponent)));
+  }
+#endif
+
+  /** \returns an expression of the coefficient-wise power of \a x to the given array of \a exponents.
+    *
+    * This function computes the coefficient-wise power.
+    *
+    * Example: \include Cwise_array_power_array.cpp
+    * Output: \verbinclude Cwise_array_power_array.out
+    * 
+    * \sa ArrayBase::pow()
+    *
+    * \relates ArrayBase
+    */
+  template<typename Derived,typename ExponentDerived>
+  inline const Eigen::CwiseBinaryOp<Eigen::internal::scalar_pow_op<typename Derived::Scalar, typename ExponentDerived::Scalar>, const Derived, const ExponentDerived>
+  pow(const Eigen::ArrayBase<Derived>& x, const Eigen::ArrayBase<ExponentDerived>& exponents) 
+  {
+    return Eigen::CwiseBinaryOp<Eigen::internal::scalar_pow_op<typename Derived::Scalar, typename ExponentDerived::Scalar>, const Derived, const ExponentDerived>(
+      x.derived(),
+      exponents.derived()
+    );
+  }
+  
+  /** \returns an expression of the coefficient-wise power of the scalar \a x to the given array of \a exponents.
+    *
+    * This function computes the coefficient-wise power between a scalar and an array of exponents.
+    *
+    * \tparam Scalar is the scalar type of \a x. It must be compatible with the scalar type of the given array expression (\c Derived::Scalar).
+    *
+    * Example: \include Cwise_scalar_power_array.cpp
+    * Output: \verbinclude Cwise_scalar_power_array.out
+    * 
+    * \sa ArrayBase::pow()
+    *
+    * \relates ArrayBase
+    */
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+  template<typename Scalar,typename Derived>
+  inline const CwiseBinaryOp<internal::scalar_pow_op<Scalar,Derived::Scalar>,Constant<Scalar>,Derived>
+  pow(const Scalar& x,const Eigen::ArrayBase<Derived>& x);
+#else
+  template <typename Scalar, typename Derived>
+  EIGEN_DEVICE_FUNC inline
+  EIGEN_MSVC10_WORKAROUND_BINARYOP_RETURN_TYPE(
+    const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(typename internal::promote_scalar_arg<typename Derived::Scalar
+                                                 EIGEN_COMMA Scalar EIGEN_COMMA
+                                                 EIGEN_SCALAR_BINARY_SUPPORTED(pow,Scalar,typename Derived::Scalar)>::type,Derived,pow))
+  pow(const Scalar& x, const Eigen::ArrayBase<Derived>& exponents) {
+    typedef typename internal::promote_scalar_arg<typename Derived::Scalar,Scalar,
+                                                  EIGEN_SCALAR_BINARY_SUPPORTED(pow,Scalar,typename Derived::Scalar)>::type PromotedScalar;
+    return EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(PromotedScalar,Derived,pow)(
+           typename internal::plain_constant_type<Derived,PromotedScalar>::type(exponents.derived().rows(), exponents.derived().cols(), internal::scalar_constant_op<PromotedScalar>(x)), exponents.derived());
+  }
+#endif
+
+
+  namespace internal
+  {
+    EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(real,scalar_real_op)
+    EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(imag,scalar_imag_op)
+    EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(abs2,scalar_abs2_op)
+  }
+}
+
+// TODO: cleanly disable those functions that are not supported on Array (numext::real_ref, internal::random, internal::isApprox...)
+
+#endif // EIGEN_GLOBAL_FUNCTIONS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/IO.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/IO.h
new file mode 100644
index 00000000..da7fd6cc
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/IO.h
@@ -0,0 +1,225 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_IO_H
+#define EIGEN_IO_H
+
+namespace Eigen { 
+
+enum { DontAlignCols = 1 };
+enum { StreamPrecision = -1,
+       FullPrecision = -2 };
+
+namespace internal {
+template<typename Derived>
+std::ostream & print_matrix(std::ostream & s, const Derived& _m, const IOFormat& fmt);
+}
+
+/** \class IOFormat
+  * \ingroup Core_Module
+  *
+  * \brief Stores a set of parameters controlling the way matrices are printed
+  *
+  * List of available parameters:
+  *  - \b precision number of digits for floating point values, or one of the special constants \c StreamPrecision and \c FullPrecision.
+  *                 The default is the special value \c StreamPrecision which means to use the
+  *                 stream's own precision setting, as set for instance using \c cout.precision(3). The other special value
+  *                 \c FullPrecision means that the number of digits will be computed to match the full precision of each floating-point
+  *                 type.
+  *  - \b flags an OR-ed combination of flags, the default value is 0, the only currently available flag is \c DontAlignCols which
+  *             allows to disable the alignment of columns, resulting in faster code.
+  *  - \b coeffSeparator string printed between two coefficients of the same row
+  *  - \b rowSeparator string printed between two rows
+  *  - \b rowPrefix string printed at the beginning of each row
+  *  - \b rowSuffix string printed at the end of each row
+  *  - \b matPrefix string printed at the beginning of the matrix
+  *  - \b matSuffix string printed at the end of the matrix
+  *
+  * Example: \include IOFormat.cpp
+  * Output: \verbinclude IOFormat.out
+  *
+  * \sa DenseBase::format(), class WithFormat
+  */
+struct IOFormat
+{
+  /** Default constructor, see class IOFormat for the meaning of the parameters */
+  IOFormat(int _precision = StreamPrecision, int _flags = 0,
+    const std::string& _coeffSeparator = " ",
+    const std::string& _rowSeparator = "\n", const std::string& _rowPrefix="", const std::string& _rowSuffix="",
+    const std::string& _matPrefix="", const std::string& _matSuffix="")
+  : matPrefix(_matPrefix), matSuffix(_matSuffix), rowPrefix(_rowPrefix), rowSuffix(_rowSuffix), rowSeparator(_rowSeparator),
+    rowSpacer(""), coeffSeparator(_coeffSeparator), precision(_precision), flags(_flags)
+  {
+    // TODO check if rowPrefix, rowSuffix or rowSeparator contains a newline
+    // don't add rowSpacer if columns are not to be aligned
+    if((flags & DontAlignCols))
+      return;
+    int i = int(matSuffix.length())-1;
+    while (i>=0 && matSuffix[i]!='\n')
+    {
+      rowSpacer += ' ';
+      i--;
+    }
+  }
+  std::string matPrefix, matSuffix;
+  std::string rowPrefix, rowSuffix, rowSeparator, rowSpacer;
+  std::string coeffSeparator;
+  int precision;
+  int flags;
+};
+
+/** \class WithFormat
+  * \ingroup Core_Module
+  *
+  * \brief Pseudo expression providing matrix output with given format
+  *
+  * \tparam ExpressionType the type of the object on which IO stream operations are performed
+  *
+  * This class represents an expression with stream operators controlled by a given IOFormat.
+  * It is the return type of DenseBase::format()
+  * and most of the time this is the only way it is used.
+  *
+  * See class IOFormat for some examples.
+  *
+  * \sa DenseBase::format(), class IOFormat
+  */
+template<typename ExpressionType>
+class WithFormat
+{
+  public:
+
+    WithFormat(const ExpressionType& matrix, const IOFormat& format)
+      : m_matrix(matrix), m_format(format)
+    {}
+
+    friend std::ostream & operator << (std::ostream & s, const WithFormat& wf)
+    {
+      return internal::print_matrix(s, wf.m_matrix.eval(), wf.m_format);
+    }
+
+  protected:
+    typename ExpressionType::Nested m_matrix;
+    IOFormat m_format;
+};
+
+namespace internal {
+
+// NOTE: This helper is kept for backward compatibility with previous code specializing
+//       this internal::significant_decimals_impl structure. In the future we should directly
+//       call digits10() which has been introduced in July 2016 in 3.3.
+template<typename Scalar>
+struct significant_decimals_impl
+{
+  static inline int run()
+  {
+    return NumTraits<Scalar>::digits10();
+  }
+};
+
+/** \internal
+  * print the matrix \a _m to the output stream \a s using the output format \a fmt */
+template<typename Derived>
+std::ostream & print_matrix(std::ostream & s, const Derived& _m, const IOFormat& fmt)
+{
+  if(_m.size() == 0)
+  {
+    s << fmt.matPrefix << fmt.matSuffix;
+    return s;
+  }
+  
+  typename Derived::Nested m = _m;
+  typedef typename Derived::Scalar Scalar;
+
+  Index width = 0;
+
+  std::streamsize explicit_precision;
+  if(fmt.precision == StreamPrecision)
+  {
+    explicit_precision = 0;
+  }
+  else if(fmt.precision == FullPrecision)
+  {
+    if (NumTraits<Scalar>::IsInteger)
+    {
+      explicit_precision = 0;
+    }
+    else
+    {
+      explicit_precision = significant_decimals_impl<Scalar>::run();
+    }
+  }
+  else
+  {
+    explicit_precision = fmt.precision;
+  }
+
+  std::streamsize old_precision = 0;
+  if(explicit_precision) old_precision = s.precision(explicit_precision);
+
+  bool align_cols = !(fmt.flags & DontAlignCols);
+  if(align_cols)
+  {
+    // compute the largest width
+    for(Index j = 0; j < m.cols(); ++j)
+      for(Index i = 0; i < m.rows(); ++i)
+      {
+        std::stringstream sstr;
+        sstr.copyfmt(s);
+        sstr << m.coeff(i,j);
+        width = std::max<Index>(width, Index(sstr.str().length()));
+      }
+  }
+  s << fmt.matPrefix;
+  for(Index i = 0; i < m.rows(); ++i)
+  {
+    if (i)
+      s << fmt.rowSpacer;
+    s << fmt.rowPrefix;
+    if(width) s.width(width);
+    s << m.coeff(i, 0);
+    for(Index j = 1; j < m.cols(); ++j)
+    {
+      s << fmt.coeffSeparator;
+      if (width) s.width(width);
+      s << m.coeff(i, j);
+    }
+    s << fmt.rowSuffix;
+    if( i < m.rows() - 1)
+      s << fmt.rowSeparator;
+  }
+  s << fmt.matSuffix;
+  if(explicit_precision) s.precision(old_precision);
+  return s;
+}
+
+} // end namespace internal
+
+/** \relates DenseBase
+  *
+  * Outputs the matrix, to the given stream.
+  *
+  * If you wish to print the matrix with a format different than the default, use DenseBase::format().
+  *
+  * It is also possible to change the default format by defining EIGEN_DEFAULT_IO_FORMAT before including Eigen headers.
+  * If not defined, this will automatically be defined to Eigen::IOFormat(), that is the Eigen::IOFormat with default parameters.
+  *
+  * \sa DenseBase::format()
+  */
+template<typename Derived>
+std::ostream & operator <<
+(std::ostream & s,
+ const DenseBase<Derived> & m)
+{
+  return internal::print_matrix(s, m.eval(), EIGEN_DEFAULT_IO_FORMAT);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_IO_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/IndexedView.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/IndexedView.h
new file mode 100644
index 00000000..8c57a277
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/IndexedView.h
@@ -0,0 +1,207 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2017 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_INDEXED_VIEW_H
+#define EIGEN_INDEXED_VIEW_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename XprType, typename RowIndices, typename ColIndices>
+struct traits<IndexedView<XprType, RowIndices, ColIndices> >
+ : traits<XprType>
+{
+  enum {
+    RowsAtCompileTime = int(array_size<RowIndices>::value),
+    ColsAtCompileTime = int(array_size<ColIndices>::value),
+    MaxRowsAtCompileTime = RowsAtCompileTime != Dynamic ? int(RowsAtCompileTime) : int(traits<XprType>::MaxRowsAtCompileTime),
+    MaxColsAtCompileTime = ColsAtCompileTime != Dynamic ? int(ColsAtCompileTime) : int(traits<XprType>::MaxColsAtCompileTime),
+
+    XprTypeIsRowMajor = (int(traits<XprType>::Flags)&RowMajorBit) != 0,
+    IsRowMajor = (MaxRowsAtCompileTime==1&&MaxColsAtCompileTime!=1) ? 1
+               : (MaxColsAtCompileTime==1&&MaxRowsAtCompileTime!=1) ? 0
+               : XprTypeIsRowMajor,
+
+    RowIncr = int(get_compile_time_incr<RowIndices>::value),
+    ColIncr = int(get_compile_time_incr<ColIndices>::value),
+    InnerIncr = IsRowMajor ? ColIncr : RowIncr,
+    OuterIncr = IsRowMajor ? RowIncr : ColIncr,
+
+    HasSameStorageOrderAsXprType = (IsRowMajor == XprTypeIsRowMajor),
+    XprInnerStride = HasSameStorageOrderAsXprType ? int(inner_stride_at_compile_time<XprType>::ret) : int(outer_stride_at_compile_time<XprType>::ret),
+    XprOuterstride = HasSameStorageOrderAsXprType ? int(outer_stride_at_compile_time<XprType>::ret) : int(inner_stride_at_compile_time<XprType>::ret),
+
+    InnerSize = XprTypeIsRowMajor ? ColsAtCompileTime : RowsAtCompileTime,
+    IsBlockAlike = InnerIncr==1 && OuterIncr==1,
+    IsInnerPannel = HasSameStorageOrderAsXprType && is_same<AllRange<InnerSize>,typename conditional<XprTypeIsRowMajor,ColIndices,RowIndices>::type>::value,
+
+    InnerStrideAtCompileTime = InnerIncr<0 || InnerIncr==DynamicIndex || XprInnerStride==Dynamic ? Dynamic : XprInnerStride * InnerIncr,
+    OuterStrideAtCompileTime = OuterIncr<0 || OuterIncr==DynamicIndex || XprOuterstride==Dynamic ? Dynamic : XprOuterstride * OuterIncr,
+
+    ReturnAsScalar = is_same<RowIndices,SingleRange>::value && is_same<ColIndices,SingleRange>::value,
+    ReturnAsBlock = (!ReturnAsScalar) && IsBlockAlike,
+    ReturnAsIndexedView = (!ReturnAsScalar) && (!ReturnAsBlock),
+
+    // FIXME we deal with compile-time strides if and only if we have DirectAccessBit flag,
+    // but this is too strict regarding negative strides...
+    DirectAccessMask = (int(InnerIncr)!=UndefinedIncr && int(OuterIncr)!=UndefinedIncr && InnerIncr>=0 && OuterIncr>=0) ? DirectAccessBit : 0,
+    FlagsRowMajorBit = IsRowMajor ? RowMajorBit : 0,
+    FlagsLvalueBit = is_lvalue<XprType>::value ? LvalueBit : 0,
+    Flags = (traits<XprType>::Flags & (HereditaryBits | DirectAccessMask)) | FlagsLvalueBit | FlagsRowMajorBit
+  };
+
+  typedef Block<XprType,RowsAtCompileTime,ColsAtCompileTime,IsInnerPannel> BlockType;
+};
+
+}
+
+template<typename XprType, typename RowIndices, typename ColIndices, typename StorageKind>
+class IndexedViewImpl;
+
+
+/** \class IndexedView
+  * \ingroup Core_Module
+  *
+  * \brief Expression of a non-sequential sub-matrix defined by arbitrary sequences of row and column indices
+  *
+  * \tparam XprType the type of the expression in which we are taking the intersections of sub-rows and sub-columns
+  * \tparam RowIndices the type of the object defining the sequence of row indices
+  * \tparam ColIndices the type of the object defining the sequence of column indices
+  *
+  * This class represents an expression of a sub-matrix (or sub-vector) defined as the intersection
+  * of sub-sets of rows and columns, that are themself defined by generic sequences of row indices \f$ \{r_0,r_1,..r_{m-1}\} \f$
+  * and column indices \f$ \{c_0,c_1,..c_{n-1} \}\f$. Let \f$ A \f$  be the nested matrix, then the resulting matrix \f$ B \f$ has \c m
+  * rows and \c n columns, and its entries are given by: \f$ B(i,j) = A(r_i,c_j) \f$.
+  *
+  * The \c RowIndices and \c ColIndices types must be compatible with the following API:
+  * \code
+  * <integral type> operator[](Index) const;
+  * Index size() const;
+  * \endcode
+  *
+  * Typical supported types thus include:
+  *  - std::vector<int>
+  *  - std::valarray<int>
+  *  - std::array<int>
+  *  - Plain C arrays: int[N]
+  *  - Eigen::ArrayXi
+  *  - decltype(ArrayXi::LinSpaced(...))
+  *  - Any view/expressions of the previous types
+  *  - Eigen::ArithmeticSequence
+  *  - Eigen::internal::AllRange      (helper for Eigen::all)
+  *  - Eigen::internal::SingleRange  (helper for single index)
+  *  - etc.
+  *
+  * In typical usages of %Eigen, this class should never be used directly. It is the return type of
+  * DenseBase::operator()(const RowIndices&, const ColIndices&).
+  *
+  * \sa class Block
+  */
+template<typename XprType, typename RowIndices, typename ColIndices>
+class IndexedView : public IndexedViewImpl<XprType, RowIndices, ColIndices, typename internal::traits<XprType>::StorageKind>
+{
+public:
+  typedef typename IndexedViewImpl<XprType, RowIndices, ColIndices, typename internal::traits<XprType>::StorageKind>::Base Base;
+  EIGEN_GENERIC_PUBLIC_INTERFACE(IndexedView)
+  EIGEN_INHERIT_ASSIGNMENT_OPERATORS(IndexedView)
+
+  typedef typename internal::ref_selector<XprType>::non_const_type MatrixTypeNested;
+  typedef typename internal::remove_all<XprType>::type NestedExpression;
+
+  template<typename T0, typename T1>
+  IndexedView(XprType& xpr, const T0& rowIndices, const T1& colIndices)
+    : m_xpr(xpr), m_rowIndices(rowIndices), m_colIndices(colIndices)
+  {}
+
+  /** \returns number of rows */
+  Index rows() const { return internal::size(m_rowIndices); }
+
+  /** \returns number of columns */
+  Index cols() const { return internal::size(m_colIndices); }
+
+  /** \returns the nested expression */
+  const typename internal::remove_all<XprType>::type&
+  nestedExpression() const { return m_xpr; }
+
+  /** \returns the nested expression */
+  typename internal::remove_reference<XprType>::type&
+  nestedExpression() { return m_xpr.const_cast_derived(); }
+
+  /** \returns a const reference to the object storing/generating the row indices */
+  const RowIndices& rowIndices() const { return m_rowIndices; }
+
+  /** \returns a const reference to the object storing/generating the column indices */
+  const ColIndices& colIndices() const { return m_colIndices; }
+
+protected:
+  MatrixTypeNested m_xpr;
+  RowIndices m_rowIndices;
+  ColIndices m_colIndices;
+};
+
+
+// Generic API dispatcher
+template<typename XprType, typename RowIndices, typename ColIndices, typename StorageKind>
+class IndexedViewImpl
+  : public internal::generic_xpr_base<IndexedView<XprType, RowIndices, ColIndices> >::type
+{
+public:
+  typedef typename internal::generic_xpr_base<IndexedView<XprType, RowIndices, ColIndices> >::type Base;
+};
+
+namespace internal {
+
+
+template<typename ArgType, typename RowIndices, typename ColIndices>
+struct unary_evaluator<IndexedView<ArgType, RowIndices, ColIndices>, IndexBased>
+  : evaluator_base<IndexedView<ArgType, RowIndices, ColIndices> >
+{
+  typedef IndexedView<ArgType, RowIndices, ColIndices> XprType;
+
+  enum {
+    CoeffReadCost = evaluator<ArgType>::CoeffReadCost /* TODO + cost of row/col index */,
+
+    Flags = (evaluator<ArgType>::Flags & (HereditaryBits /*| LinearAccessBit | DirectAccessBit*/)),
+
+    Alignment = 0
+  };
+
+  EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& xpr) : m_argImpl(xpr.nestedExpression()), m_xpr(xpr)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    return m_argImpl.coeff(m_xpr.rowIndices()[row], m_xpr.colIndices()[col]);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index row, Index col)
+  {
+    return m_argImpl.coeffRef(m_xpr.rowIndices()[row], m_xpr.colIndices()[col]);
+  }
+
+protected:
+
+  evaluator<ArgType> m_argImpl;
+  const XprType& m_xpr;
+
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_INDEXED_VIEW_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Inverse.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Inverse.h
new file mode 100644
index 00000000..b76f0439
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Inverse.h
@@ -0,0 +1,118 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_INVERSE_H
+#define EIGEN_INVERSE_H
+
+namespace Eigen { 
+
+template<typename XprType,typename StorageKind> class InverseImpl;
+
+namespace internal {
+
+template<typename XprType>
+struct traits<Inverse<XprType> >
+  : traits<typename XprType::PlainObject>
+{
+  typedef typename XprType::PlainObject PlainObject;
+  typedef traits<PlainObject> BaseTraits;
+  enum {
+    Flags = BaseTraits::Flags & RowMajorBit
+  };
+};
+
+} // end namespace internal
+
+/** \class Inverse
+  *
+  * \brief Expression of the inverse of another expression
+  *
+  * \tparam XprType the type of the expression we are taking the inverse
+  *
+  * This class represents an abstract expression of A.inverse()
+  * and most of the time this is the only way it is used.
+  *
+  */
+template<typename XprType>
+class Inverse : public InverseImpl<XprType,typename internal::traits<XprType>::StorageKind>
+{
+public:
+  typedef typename XprType::StorageIndex StorageIndex;
+  typedef typename XprType::PlainObject                       PlainObject;
+  typedef typename XprType::Scalar                            Scalar;
+  typedef typename internal::ref_selector<XprType>::type      XprTypeNested;
+  typedef typename internal::remove_all<XprTypeNested>::type  XprTypeNestedCleaned;
+  typedef typename internal::ref_selector<Inverse>::type Nested;
+  typedef typename internal::remove_all<XprType>::type NestedExpression;
+  
+  explicit EIGEN_DEVICE_FUNC Inverse(const XprType &xpr)
+    : m_xpr(xpr)
+  {}
+
+  EIGEN_DEVICE_FUNC Index rows() const { return m_xpr.rows(); }
+  EIGEN_DEVICE_FUNC Index cols() const { return m_xpr.cols(); }
+
+  EIGEN_DEVICE_FUNC const XprTypeNestedCleaned& nestedExpression() const { return m_xpr; }
+
+protected:
+  XprTypeNested m_xpr;
+};
+
+// Generic API dispatcher
+template<typename XprType, typename StorageKind>
+class InverseImpl
+  : public internal::generic_xpr_base<Inverse<XprType> >::type
+{
+public:
+  typedef typename internal::generic_xpr_base<Inverse<XprType> >::type Base;
+  typedef typename XprType::Scalar Scalar;
+private:
+
+  Scalar coeff(Index row, Index col) const;
+  Scalar coeff(Index i) const;
+};
+
+namespace internal {
+
+/** \internal
+  * \brief Default evaluator for Inverse expression.
+  * 
+  * This default evaluator for Inverse expression simply evaluate the inverse into a temporary
+  * by a call to internal::call_assignment_no_alias.
+  * Therefore, inverse implementers only have to specialize Assignment<Dst,Inverse<...>, ...> for
+  * there own nested expression.
+  *
+  * \sa class Inverse
+  */
+template<typename ArgType>
+struct unary_evaluator<Inverse<ArgType> >
+  : public evaluator<typename Inverse<ArgType>::PlainObject>
+{
+  typedef Inverse<ArgType> InverseType;
+  typedef typename InverseType::PlainObject PlainObject;
+  typedef evaluator<PlainObject> Base;
+  
+  enum { Flags = Base::Flags | EvalBeforeNestingBit };
+
+  unary_evaluator(const InverseType& inv_xpr)
+    : m_result(inv_xpr.rows(), inv_xpr.cols())
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+    internal::call_assignment_no_alias(m_result, inv_xpr);
+  }
+  
+protected:
+  PlainObject m_result;
+};
+  
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_INVERSE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Map.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Map.h
new file mode 100644
index 00000000..c437f1a9
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Map.h
@@ -0,0 +1,171 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MAP_H
+#define EIGEN_MAP_H
+
+namespace Eigen { 
+
+namespace internal {
+template<typename PlainObjectType, int MapOptions, typename StrideType>
+struct traits<Map<PlainObjectType, MapOptions, StrideType> >
+  : public traits<PlainObjectType>
+{
+  typedef traits<PlainObjectType> TraitsBase;
+  enum {
+    PlainObjectTypeInnerSize = ((traits<PlainObjectType>::Flags&RowMajorBit)==RowMajorBit)
+                             ? PlainObjectType::ColsAtCompileTime
+                             : PlainObjectType::RowsAtCompileTime,
+
+    InnerStrideAtCompileTime = StrideType::InnerStrideAtCompileTime == 0
+                             ? int(PlainObjectType::InnerStrideAtCompileTime)
+                             : int(StrideType::InnerStrideAtCompileTime),
+    OuterStrideAtCompileTime = StrideType::OuterStrideAtCompileTime == 0
+                             ? (InnerStrideAtCompileTime==Dynamic || PlainObjectTypeInnerSize==Dynamic
+                                ? Dynamic
+                                : int(InnerStrideAtCompileTime) * int(PlainObjectTypeInnerSize))
+                             : int(StrideType::OuterStrideAtCompileTime),
+    Alignment = int(MapOptions)&int(AlignedMask),
+    Flags0 = TraitsBase::Flags & (~NestByRefBit),
+    Flags = is_lvalue<PlainObjectType>::value ? int(Flags0) : (int(Flags0) & ~LvalueBit)
+  };
+private:
+  enum { Options }; // Expressions don't have Options
+};
+}
+
+/** \class Map
+  * \ingroup Core_Module
+  *
+  * \brief A matrix or vector expression mapping an existing array of data.
+  *
+  * \tparam PlainObjectType the equivalent matrix type of the mapped data
+  * \tparam MapOptions specifies the pointer alignment in bytes. It can be: \c #Aligned128, , \c #Aligned64, \c #Aligned32, \c #Aligned16, \c #Aligned8 or \c #Unaligned.
+  *                The default is \c #Unaligned.
+  * \tparam StrideType optionally specifies strides. By default, Map assumes the memory layout
+  *                   of an ordinary, contiguous array. This can be overridden by specifying strides.
+  *                   The type passed here must be a specialization of the Stride template, see examples below.
+  *
+  * This class represents a matrix or vector expression mapping an existing array of data.
+  * It can be used to let Eigen interface without any overhead with non-Eigen data structures,
+  * such as plain C arrays or structures from other libraries. By default, it assumes that the
+  * data is laid out contiguously in memory. You can however override this by explicitly specifying
+  * inner and outer strides.
+  *
+  * Here's an example of simply mapping a contiguous array as a \ref TopicStorageOrders "column-major" matrix:
+  * \include Map_simple.cpp
+  * Output: \verbinclude Map_simple.out
+  *
+  * If you need to map non-contiguous arrays, you can do so by specifying strides:
+  *
+  * Here's an example of mapping an array as a vector, specifying an inner stride, that is, the pointer
+  * increment between two consecutive coefficients. Here, we're specifying the inner stride as a compile-time
+  * fixed value.
+  * \include Map_inner_stride.cpp
+  * Output: \verbinclude Map_inner_stride.out
+  *
+  * Here's an example of mapping an array while specifying an outer stride. Here, since we're mapping
+  * as a column-major matrix, 'outer stride' means the pointer increment between two consecutive columns.
+  * Here, we're specifying the outer stride as a runtime parameter. Note that here \c OuterStride<> is
+  * a short version of \c OuterStride<Dynamic> because the default template parameter of OuterStride
+  * is  \c Dynamic
+  * \include Map_outer_stride.cpp
+  * Output: \verbinclude Map_outer_stride.out
+  *
+  * For more details and for an example of specifying both an inner and an outer stride, see class Stride.
+  *
+  * \b Tip: to change the array of data mapped by a Map object, you can use the C++
+  * placement new syntax:
+  *
+  * Example: \include Map_placement_new.cpp
+  * Output: \verbinclude Map_placement_new.out
+  *
+  * This class is the return type of PlainObjectBase::Map() but can also be used directly.
+  *
+  * \sa PlainObjectBase::Map(), \ref TopicStorageOrders
+  */
+template<typename PlainObjectType, int MapOptions, typename StrideType> class Map
+  : public MapBase<Map<PlainObjectType, MapOptions, StrideType> >
+{
+  public:
+
+    typedef MapBase<Map> Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Map)
+
+    typedef typename Base::PointerType PointerType;
+    typedef PointerType PointerArgType;
+    EIGEN_DEVICE_FUNC
+    inline PointerType cast_to_pointer_type(PointerArgType ptr) { return ptr; }
+
+    EIGEN_DEVICE_FUNC
+    inline Index innerStride() const
+    {
+      return StrideType::InnerStrideAtCompileTime != 0 ? m_stride.inner() : 1;
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline Index outerStride() const
+    {
+      return StrideType::OuterStrideAtCompileTime != 0 ? m_stride.outer()
+           : internal::traits<Map>::OuterStrideAtCompileTime != Dynamic ? Index(internal::traits<Map>::OuterStrideAtCompileTime)
+           : IsVectorAtCompileTime ? (this->size() * innerStride())
+           : int(Flags)&RowMajorBit ? (this->cols() * innerStride())
+           : (this->rows() * innerStride());
+    }
+
+    /** Constructor in the fixed-size case.
+      *
+      * \param dataPtr pointer to the array to map
+      * \param stride optional Stride object, passing the strides.
+      */
+    EIGEN_DEVICE_FUNC
+    explicit inline Map(PointerArgType dataPtr, const StrideType& stride = StrideType())
+      : Base(cast_to_pointer_type(dataPtr)), m_stride(stride)
+    {
+      PlainObjectType::Base::_check_template_params();
+    }
+
+    /** Constructor in the dynamic-size vector case.
+      *
+      * \param dataPtr pointer to the array to map
+      * \param size the size of the vector expression
+      * \param stride optional Stride object, passing the strides.
+      */
+    EIGEN_DEVICE_FUNC
+    inline Map(PointerArgType dataPtr, Index size, const StrideType& stride = StrideType())
+      : Base(cast_to_pointer_type(dataPtr), size), m_stride(stride)
+    {
+      PlainObjectType::Base::_check_template_params();
+    }
+
+    /** Constructor in the dynamic-size matrix case.
+      *
+      * \param dataPtr pointer to the array to map
+      * \param rows the number of rows of the matrix expression
+      * \param cols the number of columns of the matrix expression
+      * \param stride optional Stride object, passing the strides.
+      */
+    EIGEN_DEVICE_FUNC
+    inline Map(PointerArgType dataPtr, Index rows, Index cols, const StrideType& stride = StrideType())
+      : Base(cast_to_pointer_type(dataPtr), rows, cols), m_stride(stride)
+    {
+      PlainObjectType::Base::_check_template_params();
+    }
+
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Map)
+
+  protected:
+    StrideType m_stride;
+};
+
+
+} // end namespace Eigen
+
+#endif // EIGEN_MAP_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/MapBase.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/MapBase.h
new file mode 100644
index 00000000..020f939a
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/MapBase.h
@@ -0,0 +1,299 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MAPBASE_H
+#define EIGEN_MAPBASE_H
+
+#define EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived) \
+      EIGEN_STATIC_ASSERT((int(internal::evaluator<Derived>::Flags) & LinearAccessBit) || Derived::IsVectorAtCompileTime, \
+                          YOU_ARE_TRYING_TO_USE_AN_INDEX_BASED_ACCESSOR_ON_AN_EXPRESSION_THAT_DOES_NOT_SUPPORT_THAT)
+
+namespace Eigen { 
+
+/** \ingroup Core_Module
+  *
+  * \brief Base class for dense Map and Block expression with direct access
+  *
+  * This base class provides the const low-level accessors (e.g. coeff, coeffRef) of dense
+  * Map and Block objects with direct access.
+  * Typical users do not have to directly deal with this class.
+  *
+  * This class can be extended by through the macro plugin \c EIGEN_MAPBASE_PLUGIN.
+  * See \link TopicCustomizing_Plugins customizing Eigen \endlink for details.
+  *
+  * The \c Derived class has to provide the following two methods describing the memory layout:
+  *  \code Index innerStride() const; \endcode
+  *  \code Index outerStride() const; \endcode
+  *
+  * \sa class Map, class Block
+  */
+template<typename Derived> class MapBase<Derived, ReadOnlyAccessors>
+  : public internal::dense_xpr_base<Derived>::type
+{
+  public:
+
+    typedef typename internal::dense_xpr_base<Derived>::type Base;
+    enum {
+      RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
+      ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
+      SizeAtCompileTime = Base::SizeAtCompileTime
+    };
+
+    typedef typename internal::traits<Derived>::StorageKind StorageKind;
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    typedef typename internal::packet_traits<Scalar>::type PacketScalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef typename internal::conditional<
+                         bool(internal::is_lvalue<Derived>::value),
+                         Scalar *,
+                         const Scalar *>::type
+                     PointerType;
+
+    using Base::derived;
+//    using Base::RowsAtCompileTime;
+//    using Base::ColsAtCompileTime;
+//    using Base::SizeAtCompileTime;
+    using Base::MaxRowsAtCompileTime;
+    using Base::MaxColsAtCompileTime;
+    using Base::MaxSizeAtCompileTime;
+    using Base::IsVectorAtCompileTime;
+    using Base::Flags;
+    using Base::IsRowMajor;
+
+    using Base::rows;
+    using Base::cols;
+    using Base::size;
+    using Base::coeff;
+    using Base::coeffRef;
+    using Base::lazyAssign;
+    using Base::eval;
+
+    using Base::innerStride;
+    using Base::outerStride;
+    using Base::rowStride;
+    using Base::colStride;
+
+    // bug 217 - compile error on ICC 11.1
+    using Base::operator=;
+
+    typedef typename Base::CoeffReturnType CoeffReturnType;
+
+    /** \copydoc DenseBase::rows() */
+    EIGEN_DEVICE_FUNC inline Index rows() const { return m_rows.value(); }
+    /** \copydoc DenseBase::cols() */
+    EIGEN_DEVICE_FUNC inline Index cols() const { return m_cols.value(); }
+
+    /** Returns a pointer to the first coefficient of the matrix or vector.
+      *
+      * \note When addressing this data, make sure to honor the strides returned by innerStride() and outerStride().
+      *
+      * \sa innerStride(), outerStride()
+      */
+    EIGEN_DEVICE_FUNC inline const Scalar* data() const { return m_data; }
+
+    /** \copydoc PlainObjectBase::coeff(Index,Index) const */
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeff(Index rowId, Index colId) const
+    {
+      return m_data[colId * colStride() + rowId * rowStride()];
+    }
+
+    /** \copydoc PlainObjectBase::coeff(Index) const */
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeff(Index index) const
+    {
+      EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
+      return m_data[index * innerStride()];
+    }
+
+    /** \copydoc PlainObjectBase::coeffRef(Index,Index) const */
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index rowId, Index colId) const
+    {
+      return this->m_data[colId * colStride() + rowId * rowStride()];
+    }
+
+    /** \copydoc PlainObjectBase::coeffRef(Index) const */
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index index) const
+    {
+      EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
+      return this->m_data[index * innerStride()];
+    }
+
+    /** \internal */
+    template<int LoadMode>
+    inline PacketScalar packet(Index rowId, Index colId) const
+    {
+      return internal::ploadt<PacketScalar, LoadMode>
+               (m_data + (colId * colStride() + rowId * rowStride()));
+    }
+
+    /** \internal */
+    template<int LoadMode>
+    inline PacketScalar packet(Index index) const
+    {
+      EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
+      return internal::ploadt<PacketScalar, LoadMode>(m_data + index * innerStride());
+    }
+
+    /** \internal Constructor for fixed size matrices or vectors */
+    EIGEN_DEVICE_FUNC
+    explicit inline MapBase(PointerType dataPtr) : m_data(dataPtr), m_rows(RowsAtCompileTime), m_cols(ColsAtCompileTime)
+    {
+      EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived)
+      checkSanity<Derived>();
+    }
+
+    /** \internal Constructor for dynamically sized vectors */
+    EIGEN_DEVICE_FUNC
+    inline MapBase(PointerType dataPtr, Index vecSize)
+            : m_data(dataPtr),
+              m_rows(RowsAtCompileTime == Dynamic ? vecSize : Index(RowsAtCompileTime)),
+              m_cols(ColsAtCompileTime == Dynamic ? vecSize : Index(ColsAtCompileTime))
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+      eigen_assert(vecSize >= 0);
+      eigen_assert(dataPtr == 0 || SizeAtCompileTime == Dynamic || SizeAtCompileTime == vecSize);
+      checkSanity<Derived>();
+    }
+
+    /** \internal Constructor for dynamically sized matrices */
+    EIGEN_DEVICE_FUNC
+    inline MapBase(PointerType dataPtr, Index rows, Index cols)
+            : m_data(dataPtr), m_rows(rows), m_cols(cols)
+    {
+      eigen_assert( (dataPtr == 0)
+              || (   rows >= 0 && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == rows)
+                  && cols >= 0 && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == cols)));
+      checkSanity<Derived>();
+    }
+
+    #ifdef EIGEN_MAPBASE_PLUGIN
+    #include EIGEN_MAPBASE_PLUGIN
+    #endif
+
+  protected:
+
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    void checkSanity(typename internal::enable_if<(internal::traits<T>::Alignment>0),void*>::type = 0) const
+    {
+#if EIGEN_MAX_ALIGN_BYTES>0
+      eigen_assert((   ((internal::UIntPtr(m_data) % internal::traits<Derived>::Alignment) == 0)
+                    || (cols() * rows() * innerStride() * sizeof(Scalar)) < internal::traits<Derived>::Alignment ) && "data is not aligned");
+#endif
+    }
+
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    void checkSanity(typename internal::enable_if<internal::traits<T>::Alignment==0,void*>::type = 0) const
+    {}
+
+    PointerType m_data;
+    const internal::variable_if_dynamic<Index, RowsAtCompileTime> m_rows;
+    const internal::variable_if_dynamic<Index, ColsAtCompileTime> m_cols;
+};
+
+/** \ingroup Core_Module
+  *
+  * \brief Base class for non-const dense Map and Block expression with direct access
+  *
+  * This base class provides the non-const low-level accessors (e.g. coeff and coeffRef) of
+  * dense Map and Block objects with direct access.
+  * It inherits MapBase<Derived, ReadOnlyAccessors> which defines the const variant for reading specific entries.
+  *
+  * \sa class Map, class Block
+  */
+template<typename Derived> class MapBase<Derived, WriteAccessors>
+  : public MapBase<Derived, ReadOnlyAccessors>
+{
+    typedef MapBase<Derived, ReadOnlyAccessors> ReadOnlyMapBase;
+  public:
+
+    typedef MapBase<Derived, ReadOnlyAccessors> Base;
+
+    typedef typename Base::Scalar Scalar;
+    typedef typename Base::PacketScalar PacketScalar;
+    typedef typename Base::StorageIndex StorageIndex;
+    typedef typename Base::PointerType PointerType;
+
+    using Base::derived;
+    using Base::rows;
+    using Base::cols;
+    using Base::size;
+    using Base::coeff;
+    using Base::coeffRef;
+
+    using Base::innerStride;
+    using Base::outerStride;
+    using Base::rowStride;
+    using Base::colStride;
+
+    typedef typename internal::conditional<
+                    internal::is_lvalue<Derived>::value,
+                    Scalar,
+                    const Scalar
+                  >::type ScalarWithConstIfNotLvalue;
+
+    EIGEN_DEVICE_FUNC
+    inline const Scalar* data() const { return this->m_data; }
+    EIGEN_DEVICE_FUNC
+    inline ScalarWithConstIfNotLvalue* data() { return this->m_data; } // no const-cast here so non-const-correct code will give a compile error
+
+    EIGEN_DEVICE_FUNC
+    inline ScalarWithConstIfNotLvalue& coeffRef(Index row, Index col)
+    {
+      return this->m_data[col * colStride() + row * rowStride()];
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline ScalarWithConstIfNotLvalue& coeffRef(Index index)
+    {
+      EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
+      return this->m_data[index * innerStride()];
+    }
+
+    template<int StoreMode>
+    inline void writePacket(Index row, Index col, const PacketScalar& val)
+    {
+      internal::pstoret<Scalar, PacketScalar, StoreMode>
+               (this->m_data + (col * colStride() + row * rowStride()), val);
+    }
+
+    template<int StoreMode>
+    inline void writePacket(Index index, const PacketScalar& val)
+    {
+      EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
+      internal::pstoret<Scalar, PacketScalar, StoreMode>
+                (this->m_data + index * innerStride(), val);
+    }
+
+    EIGEN_DEVICE_FUNC explicit inline MapBase(PointerType dataPtr) : Base(dataPtr) {}
+    EIGEN_DEVICE_FUNC inline MapBase(PointerType dataPtr, Index vecSize) : Base(dataPtr, vecSize) {}
+    EIGEN_DEVICE_FUNC inline MapBase(PointerType dataPtr, Index rows, Index cols) : Base(dataPtr, rows, cols) {}
+
+    EIGEN_DEVICE_FUNC
+    Derived& operator=(const MapBase& other)
+    {
+      ReadOnlyMapBase::Base::operator=(other);
+      return derived();
+    }
+
+    // In theory we could simply refer to Base:Base::operator=, but MSVC does not like Base::Base,
+    // see bugs 821 and 920.
+    using ReadOnlyMapBase::Base::operator=;
+};
+
+#undef EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS
+
+} // end namespace Eigen
+
+#endif // EIGEN_MAPBASE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/MathFunctions.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/MathFunctions.h
new file mode 100644
index 00000000..5ba5293a
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/MathFunctions.h
@@ -0,0 +1,1711 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATHFUNCTIONS_H
+#define EIGEN_MATHFUNCTIONS_H
+
+// source: http://www.geom.uiuc.edu/~huberty/math5337/groupe/digits.html
+// TODO this should better be moved to NumTraits
+#define EIGEN_PI 3.141592653589793238462643383279502884197169399375105820974944592307816406L
+
+namespace Eigen {
+
+// On WINCE, std::abs is defined for int only, so let's defined our own overloads:
+// This issue has been confirmed with MSVC 2008 only, but the issue might exist for more recent versions too.
+#if EIGEN_OS_WINCE && EIGEN_COMP_MSVC && EIGEN_COMP_MSVC<=1500
+long        abs(long        x) { return (labs(x));  }
+double      abs(double      x) { return (fabs(x));  }
+float       abs(float       x) { return (fabsf(x)); }
+long double abs(long double x) { return (fabsl(x)); }
+#endif
+
+namespace internal {
+
+/** \internal \class global_math_functions_filtering_base
+  *
+  * What it does:
+  * Defines a typedef 'type' as follows:
+  * - if type T has a member typedef Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl, then
+  *   global_math_functions_filtering_base<T>::type is a typedef for it.
+  * - otherwise, global_math_functions_filtering_base<T>::type is a typedef for T.
+  *
+  * How it's used:
+  * To allow to defined the global math functions (like sin...) in certain cases, like the Array expressions.
+  * When you do sin(array1+array2), the object array1+array2 has a complicated expression type, all what you want to know
+  * is that it inherits ArrayBase. So we implement a partial specialization of sin_impl for ArrayBase<Derived>.
+  * So we must make sure to use sin_impl<ArrayBase<Derived> > and not sin_impl<Derived>, otherwise our partial specialization
+  * won't be used. How does sin know that? That's exactly what global_math_functions_filtering_base tells it.
+  *
+  * How it's implemented:
+  * SFINAE in the style of enable_if. Highly susceptible of breaking compilers. With GCC, it sure does work, but if you replace
+  * the typename dummy by an integer template parameter, it doesn't work anymore!
+  */
+
+template<typename T, typename dummy = void>
+struct global_math_functions_filtering_base
+{
+  typedef T type;
+};
+
+template<typename T> struct always_void { typedef void type; };
+
+template<typename T>
+struct global_math_functions_filtering_base
+  <T,
+   typename always_void<typename T::Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl>::type
+  >
+{
+  typedef typename T::Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl type;
+};
+
+#define EIGEN_MATHFUNC_IMPL(func, scalar) Eigen::internal::func##_impl<typename Eigen::internal::global_math_functions_filtering_base<scalar>::type>
+#define EIGEN_MATHFUNC_RETVAL(func, scalar) typename Eigen::internal::func##_retval<typename Eigen::internal::global_math_functions_filtering_base<scalar>::type>::type
+
+/****************************************************************************
+* Implementation of real                                                 *
+****************************************************************************/
+
+template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
+struct real_default_impl
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar& x)
+  {
+    return x;
+  }
+};
+
+template<typename Scalar>
+struct real_default_impl<Scalar,true>
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar& x)
+  {
+    using std::real;
+    return real(x);
+  }
+};
+
+template<typename Scalar> struct real_impl : real_default_impl<Scalar> {};
+
+#ifdef EIGEN_CUDA_ARCH
+template<typename T>
+struct real_impl<std::complex<T> >
+{
+  typedef T RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline T run(const std::complex<T>& x)
+  {
+    return x.real();
+  }
+};
+#endif
+
+template<typename Scalar>
+struct real_retval
+{
+  typedef typename NumTraits<Scalar>::Real type;
+};
+
+/****************************************************************************
+* Implementation of imag                                                 *
+****************************************************************************/
+
+template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
+struct imag_default_impl
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar&)
+  {
+    return RealScalar(0);
+  }
+};
+
+template<typename Scalar>
+struct imag_default_impl<Scalar,true>
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar& x)
+  {
+    using std::imag;
+    return imag(x);
+  }
+};
+
+template<typename Scalar> struct imag_impl : imag_default_impl<Scalar> {};
+
+#ifdef EIGEN_CUDA_ARCH
+template<typename T>
+struct imag_impl<std::complex<T> >
+{
+  typedef T RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline T run(const std::complex<T>& x)
+  {
+    return x.imag();
+  }
+};
+#endif
+
+template<typename Scalar>
+struct imag_retval
+{
+  typedef typename NumTraits<Scalar>::Real type;
+};
+
+/****************************************************************************
+* Implementation of real_ref                                             *
+****************************************************************************/
+
+template<typename Scalar>
+struct real_ref_impl
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar& run(Scalar& x)
+  {
+    return reinterpret_cast<RealScalar*>(&x)[0];
+  }
+  EIGEN_DEVICE_FUNC
+  static inline const RealScalar& run(const Scalar& x)
+  {
+    return reinterpret_cast<const RealScalar*>(&x)[0];
+  }
+};
+
+template<typename Scalar>
+struct real_ref_retval
+{
+  typedef typename NumTraits<Scalar>::Real & type;
+};
+
+/****************************************************************************
+* Implementation of imag_ref                                             *
+****************************************************************************/
+
+template<typename Scalar, bool IsComplex>
+struct imag_ref_default_impl
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar& run(Scalar& x)
+  {
+    return reinterpret_cast<RealScalar*>(&x)[1];
+  }
+  EIGEN_DEVICE_FUNC
+  static inline const RealScalar& run(const Scalar& x)
+  {
+    return reinterpret_cast<RealScalar*>(&x)[1];
+  }
+};
+
+template<typename Scalar>
+struct imag_ref_default_impl<Scalar, false>
+{
+  EIGEN_DEVICE_FUNC
+  static inline Scalar run(Scalar&)
+  {
+    return Scalar(0);
+  }
+  EIGEN_DEVICE_FUNC
+  static inline const Scalar run(const Scalar&)
+  {
+    return Scalar(0);
+  }
+};
+
+template<typename Scalar>
+struct imag_ref_impl : imag_ref_default_impl<Scalar, NumTraits<Scalar>::IsComplex> {};
+
+template<typename Scalar>
+struct imag_ref_retval
+{
+  typedef typename NumTraits<Scalar>::Real & type;
+};
+
+/****************************************************************************
+* Implementation of conj                                                 *
+****************************************************************************/
+
+template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
+struct conj_impl
+{
+  EIGEN_DEVICE_FUNC
+  static inline Scalar run(const Scalar& x)
+  {
+    return x;
+  }
+};
+
+template<typename Scalar>
+struct conj_impl<Scalar,true>
+{
+  EIGEN_DEVICE_FUNC
+  static inline Scalar run(const Scalar& x)
+  {
+    using std::conj;
+    return conj(x);
+  }
+};
+
+template<typename Scalar>
+struct conj_retval
+{
+  typedef Scalar type;
+};
+
+/****************************************************************************
+* Implementation of abs2                                                 *
+****************************************************************************/
+
+template<typename Scalar,bool IsComplex>
+struct abs2_impl_default
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar& x)
+  {
+    return x*x;
+  }
+};
+
+template<typename Scalar>
+struct abs2_impl_default<Scalar, true> // IsComplex
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar& x)
+  {
+    return real(x)*real(x) + imag(x)*imag(x);
+  }
+};
+
+template<typename Scalar>
+struct abs2_impl
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar& x)
+  {
+    return abs2_impl_default<Scalar,NumTraits<Scalar>::IsComplex>::run(x);
+  }
+};
+
+template<typename Scalar>
+struct abs2_retval
+{
+  typedef typename NumTraits<Scalar>::Real type;
+};
+
+/****************************************************************************
+* Implementation of norm1                                                *
+****************************************************************************/
+
+template<typename Scalar, bool IsComplex>
+struct norm1_default_impl
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar& x)
+  {
+    EIGEN_USING_STD_MATH(abs);
+    return abs(real(x)) + abs(imag(x));
+  }
+};
+
+template<typename Scalar>
+struct norm1_default_impl<Scalar, false>
+{
+  EIGEN_DEVICE_FUNC
+  static inline Scalar run(const Scalar& x)
+  {
+    EIGEN_USING_STD_MATH(abs);
+    return abs(x);
+  }
+};
+
+template<typename Scalar>
+struct norm1_impl : norm1_default_impl<Scalar, NumTraits<Scalar>::IsComplex> {};
+
+template<typename Scalar>
+struct norm1_retval
+{
+  typedef typename NumTraits<Scalar>::Real type;
+};
+
+/****************************************************************************
+* Implementation of hypot                                                *
+****************************************************************************/
+
+template<typename Scalar>
+struct hypot_impl
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  static inline RealScalar run(const Scalar& x, const Scalar& y)
+  {
+    EIGEN_USING_STD_MATH(abs);
+    EIGEN_USING_STD_MATH(sqrt);
+    RealScalar _x = abs(x);
+    RealScalar _y = abs(y);
+    Scalar p, qp;
+    if(_x>_y)
+    {
+      p = _x;
+      qp = _y / p;
+    }
+    else
+    {
+      p = _y;
+      qp = _x / p;
+    }
+    if(p==RealScalar(0)) return RealScalar(0);
+    return p * sqrt(RealScalar(1) + qp*qp);
+  }
+};
+
+template<typename Scalar>
+struct hypot_retval
+{
+  typedef typename NumTraits<Scalar>::Real type;
+};
+
+/****************************************************************************
+* Implementation of cast                                                 *
+****************************************************************************/
+
+template<typename OldType, typename NewType>
+struct cast_impl
+{
+  EIGEN_DEVICE_FUNC
+  static inline NewType run(const OldType& x)
+  {
+    return static_cast<NewType>(x);
+  }
+};
+
+// here, for once, we're plainly returning NewType: we don't want cast to do weird things.
+
+template<typename OldType, typename NewType>
+EIGEN_DEVICE_FUNC
+inline NewType cast(const OldType& x)
+{
+  return cast_impl<OldType, NewType>::run(x);
+}
+
+/****************************************************************************
+* Implementation of round                                                   *
+****************************************************************************/
+
+#if EIGEN_HAS_CXX11_MATH
+  template<typename Scalar>
+  struct round_impl {
+    static inline Scalar run(const Scalar& x)
+    {
+      EIGEN_STATIC_ASSERT((!NumTraits<Scalar>::IsComplex), NUMERIC_TYPE_MUST_BE_REAL)
+      EIGEN_USING_STD_MATH(round);
+      return round(x);
+    }
+  };
+#else
+  template<typename Scalar>
+  struct round_impl
+  {
+    static inline Scalar run(const Scalar& x)
+    {
+      EIGEN_STATIC_ASSERT((!NumTraits<Scalar>::IsComplex), NUMERIC_TYPE_MUST_BE_REAL)
+      EIGEN_USING_STD_MATH(floor);
+      EIGEN_USING_STD_MATH(ceil);
+      return (x > Scalar(0)) ? floor(x + Scalar(0.5)) : ceil(x - Scalar(0.5));
+    }
+  };
+#endif
+
+template<typename Scalar>
+struct round_retval
+{
+  typedef Scalar type;
+};
+
+/****************************************************************************
+* Implementation of arg                                                     *
+****************************************************************************/
+
+#if EIGEN_HAS_CXX11_MATH
+  template<typename Scalar>
+  struct arg_impl {
+    static inline Scalar run(const Scalar& x)
+    {
+      EIGEN_USING_STD_MATH(arg);
+      return arg(x);
+    }
+  };
+#else
+  template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
+  struct arg_default_impl
+  {
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    EIGEN_DEVICE_FUNC
+    static inline RealScalar run(const Scalar& x)
+    {
+      return (x < Scalar(0)) ? Scalar(EIGEN_PI) : Scalar(0); }
+  };
+
+  template<typename Scalar>
+  struct arg_default_impl<Scalar,true>
+  {
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    EIGEN_DEVICE_FUNC
+    static inline RealScalar run(const Scalar& x)
+    {
+      EIGEN_USING_STD_MATH(arg);
+      return arg(x);
+    }
+  };
+
+  template<typename Scalar> struct arg_impl : arg_default_impl<Scalar> {};
+#endif
+
+template<typename Scalar>
+struct arg_retval
+{
+  typedef typename NumTraits<Scalar>::Real type;
+};
+
+/****************************************************************************
+* Implementation of expm1                                                   *
+****************************************************************************/
+
+// This implementation is based on GSL Math's expm1.
+namespace std_fallback {
+  // fallback expm1 implementation in case there is no expm1(Scalar) function in namespace of Scalar,
+  // or that there is no suitable std::expm1 function available. Implementation
+  // attributed to Kahan. See: http://www.plunk.org/~hatch/rightway.php.
+  template<typename Scalar>
+  EIGEN_DEVICE_FUNC inline Scalar expm1(const Scalar& x) {
+    EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    EIGEN_USING_STD_MATH(exp);
+    Scalar u = exp(x);
+    if (u == Scalar(1)) {
+      return x;
+    }
+    Scalar um1 = u - RealScalar(1);
+    if (um1 == Scalar(-1)) {
+      return RealScalar(-1);
+    }
+
+    EIGEN_USING_STD_MATH(log);
+    return (u - RealScalar(1)) * x / log(u);
+  }
+}
+
+template<typename Scalar>
+struct expm1_impl {
+  EIGEN_DEVICE_FUNC static inline Scalar run(const Scalar& x)
+  {
+    EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
+    #if EIGEN_HAS_CXX11_MATH
+    using std::expm1;
+    #endif
+    using std_fallback::expm1;
+    return expm1(x);
+  }
+};
+
+
+template<typename Scalar>
+struct expm1_retval
+{
+  typedef Scalar type;
+};
+
+/****************************************************************************
+* Implementation of log1p                                                   *
+****************************************************************************/
+
+namespace std_fallback {
+  // fallback log1p implementation in case there is no log1p(Scalar) function in namespace of Scalar,
+  // or that there is no suitable std::log1p function available
+  template<typename Scalar>
+  EIGEN_DEVICE_FUNC inline Scalar log1p(const Scalar& x) {
+    EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    EIGEN_USING_STD_MATH(log);
+    Scalar x1p = RealScalar(1) + x;
+    return ( x1p == Scalar(1) ) ? x : x * ( log(x1p) / (x1p - RealScalar(1)) );
+  }
+}
+
+template<typename Scalar>
+struct log1p_impl {
+  EIGEN_DEVICE_FUNC static inline Scalar run(const Scalar& x)
+  {
+    EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
+    #if EIGEN_HAS_CXX11_MATH
+    using std::log1p;
+    #endif
+    using std_fallback::log1p;
+    return log1p(x);
+  }
+};
+
+
+template<typename Scalar>
+struct log1p_retval
+{
+  typedef Scalar type;
+};
+
+/****************************************************************************
+* Implementation of pow                                                  *
+****************************************************************************/
+
+template<typename ScalarX,typename ScalarY, bool IsInteger = NumTraits<ScalarX>::IsInteger&&NumTraits<ScalarY>::IsInteger>
+struct pow_impl
+{
+  //typedef Scalar retval;
+  typedef typename ScalarBinaryOpTraits<ScalarX,ScalarY,internal::scalar_pow_op<ScalarX,ScalarY> >::ReturnType result_type;
+  static EIGEN_DEVICE_FUNC inline result_type run(const ScalarX& x, const ScalarY& y)
+  {
+    EIGEN_USING_STD_MATH(pow);
+    return pow(x, y);
+  }
+};
+
+template<typename ScalarX,typename ScalarY>
+struct pow_impl<ScalarX,ScalarY, true>
+{
+  typedef ScalarX result_type;
+  static EIGEN_DEVICE_FUNC inline ScalarX run(ScalarX x, ScalarY y)
+  {
+    ScalarX res(1);
+    eigen_assert(!NumTraits<ScalarY>::IsSigned || y >= 0);
+    if(y & 1) res *= x;
+    y >>= 1;
+    while(y)
+    {
+      x *= x;
+      if(y&1) res *= x;
+      y >>= 1;
+    }
+    return res;
+  }
+};
+
+/****************************************************************************
+* Implementation of random                                               *
+****************************************************************************/
+
+template<typename Scalar,
+         bool IsComplex,
+         bool IsInteger>
+struct random_default_impl {};
+
+template<typename Scalar>
+struct random_impl : random_default_impl<Scalar, NumTraits<Scalar>::IsComplex, NumTraits<Scalar>::IsInteger> {};
+
+template<typename Scalar>
+struct random_retval
+{
+  typedef Scalar type;
+};
+
+template<typename Scalar> inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random(const Scalar& x, const Scalar& y);
+template<typename Scalar> inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random();
+
+template<typename Scalar>
+struct random_default_impl<Scalar, false, false>
+{
+  static inline Scalar run(const Scalar& x, const Scalar& y)
+  {
+    return x + (y-x) * Scalar(std::rand()) / Scalar(RAND_MAX);
+  }
+  static inline Scalar run()
+  {
+    return run(Scalar(NumTraits<Scalar>::IsSigned ? -1 : 0), Scalar(1));
+  }
+};
+
+enum {
+  meta_floor_log2_terminate,
+  meta_floor_log2_move_up,
+  meta_floor_log2_move_down,
+  meta_floor_log2_bogus
+};
+
+template<unsigned int n, int lower, int upper> struct meta_floor_log2_selector
+{
+  enum { middle = (lower + upper) / 2,
+         value = (upper <= lower + 1) ? int(meta_floor_log2_terminate)
+               : (n < (1 << middle)) ? int(meta_floor_log2_move_down)
+               : (n==0) ? int(meta_floor_log2_bogus)
+               : int(meta_floor_log2_move_up)
+  };
+};
+
+template<unsigned int n,
+         int lower = 0,
+         int upper = sizeof(unsigned int) * CHAR_BIT - 1,
+         int selector = meta_floor_log2_selector<n, lower, upper>::value>
+struct meta_floor_log2 {};
+
+template<unsigned int n, int lower, int upper>
+struct meta_floor_log2<n, lower, upper, meta_floor_log2_move_down>
+{
+  enum { value = meta_floor_log2<n, lower, meta_floor_log2_selector<n, lower, upper>::middle>::value };
+};
+
+template<unsigned int n, int lower, int upper>
+struct meta_floor_log2<n, lower, upper, meta_floor_log2_move_up>
+{
+  enum { value = meta_floor_log2<n, meta_floor_log2_selector<n, lower, upper>::middle, upper>::value };
+};
+
+template<unsigned int n, int lower, int upper>
+struct meta_floor_log2<n, lower, upper, meta_floor_log2_terminate>
+{
+  enum { value = (n >= ((unsigned int)(1) << (lower+1))) ? lower+1 : lower };
+};
+
+template<unsigned int n, int lower, int upper>
+struct meta_floor_log2<n, lower, upper, meta_floor_log2_bogus>
+{
+  // no value, error at compile time
+};
+
+template<typename Scalar>
+struct random_default_impl<Scalar, false, true>
+{
+  static inline Scalar run(const Scalar& x, const Scalar& y)
+  {
+    typedef typename conditional<NumTraits<Scalar>::IsSigned,std::ptrdiff_t,std::size_t>::type ScalarX;
+    if(y<x)
+      return x;
+    // the following difference might overflow on a 32 bits system,
+    // but since y>=x the result converted to an unsigned long is still correct.
+    std::size_t range = ScalarX(y)-ScalarX(x);
+    std::size_t offset = 0;
+    // rejection sampling
+    std::size_t divisor = 1;
+    std::size_t multiplier = 1;
+    if(range<RAND_MAX) divisor = (std::size_t(RAND_MAX)+1)/(range+1);
+    else               multiplier = 1 + range/(std::size_t(RAND_MAX)+1);
+    do {
+      offset = (std::size_t(std::rand()) * multiplier) / divisor;
+    } while (offset > range);
+    return Scalar(ScalarX(x) + offset);
+  }
+
+  static inline Scalar run()
+  {
+#ifdef EIGEN_MAKING_DOCS
+    return run(Scalar(NumTraits<Scalar>::IsSigned ? -10 : 0), Scalar(10));
+#else
+    enum { rand_bits = meta_floor_log2<(unsigned int)(RAND_MAX)+1>::value,
+           scalar_bits = sizeof(Scalar) * CHAR_BIT,
+           shift = EIGEN_PLAIN_ENUM_MAX(0, int(rand_bits) - int(scalar_bits)),
+           offset = NumTraits<Scalar>::IsSigned ? (1 << (EIGEN_PLAIN_ENUM_MIN(rand_bits,scalar_bits)-1)) : 0
+    };
+    return Scalar((std::rand() >> shift) - offset);
+#endif
+  }
+};
+
+template<typename Scalar>
+struct random_default_impl<Scalar, true, false>
+{
+  static inline Scalar run(const Scalar& x, const Scalar& y)
+  {
+    return Scalar(random(real(x), real(y)),
+                  random(imag(x), imag(y)));
+  }
+  static inline Scalar run()
+  {
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    return Scalar(random<RealScalar>(), random<RealScalar>());
+  }
+};
+
+template<typename Scalar>
+inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random(const Scalar& x, const Scalar& y)
+{
+  return EIGEN_MATHFUNC_IMPL(random, Scalar)::run(x, y);
+}
+
+template<typename Scalar>
+inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random()
+{
+  return EIGEN_MATHFUNC_IMPL(random, Scalar)::run();
+}
+
+// Implementatin of is* functions
+
+// std::is* do not work with fast-math and gcc, std::is* are available on MSVC 2013 and newer, as well as in clang.
+#if (EIGEN_HAS_CXX11_MATH && !(EIGEN_COMP_GNUC_STRICT && __FINITE_MATH_ONLY__)) || (EIGEN_COMP_MSVC>=1800) || (EIGEN_COMP_CLANG)
+#define EIGEN_USE_STD_FPCLASSIFY 1
+#else
+#define EIGEN_USE_STD_FPCLASSIFY 0
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+typename internal::enable_if<internal::is_integral<T>::value,bool>::type
+isnan_impl(const T&) { return false; }
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+typename internal::enable_if<internal::is_integral<T>::value,bool>::type
+isinf_impl(const T&) { return false; }
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+typename internal::enable_if<internal::is_integral<T>::value,bool>::type
+isfinite_impl(const T&) { return true; }
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+typename internal::enable_if<(!internal::is_integral<T>::value)&&(!NumTraits<T>::IsComplex),bool>::type
+isfinite_impl(const T& x)
+{
+  #ifdef EIGEN_CUDA_ARCH
+    return (::isfinite)(x);
+  #elif EIGEN_USE_STD_FPCLASSIFY
+    using std::isfinite;
+    return isfinite EIGEN_NOT_A_MACRO (x);
+  #else
+    return x<=NumTraits<T>::highest() && x>=NumTraits<T>::lowest();
+  #endif
+}
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+typename internal::enable_if<(!internal::is_integral<T>::value)&&(!NumTraits<T>::IsComplex),bool>::type
+isinf_impl(const T& x)
+{
+  #ifdef EIGEN_CUDA_ARCH
+    return (::isinf)(x);
+  #elif EIGEN_USE_STD_FPCLASSIFY
+    using std::isinf;
+    return isinf EIGEN_NOT_A_MACRO (x);
+  #else
+    return x>NumTraits<T>::highest() || x<NumTraits<T>::lowest();
+  #endif
+}
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+typename internal::enable_if<(!internal::is_integral<T>::value)&&(!NumTraits<T>::IsComplex),bool>::type
+isnan_impl(const T& x)
+{
+  #ifdef EIGEN_CUDA_ARCH
+    return (::isnan)(x);
+  #elif EIGEN_USE_STD_FPCLASSIFY
+    using std::isnan;
+    return isnan EIGEN_NOT_A_MACRO (x);
+  #else
+    return x != x;
+  #endif
+}
+
+#if (!EIGEN_USE_STD_FPCLASSIFY)
+
+#if EIGEN_COMP_MSVC
+
+template<typename T> EIGEN_DEVICE_FUNC bool isinf_msvc_helper(T x)
+{
+  return _fpclass(x)==_FPCLASS_NINF || _fpclass(x)==_FPCLASS_PINF;
+}
+
+//MSVC defines a _isnan builtin function, but for double only
+EIGEN_DEVICE_FUNC inline bool isnan_impl(const long double& x) { return _isnan(x)!=0; }
+EIGEN_DEVICE_FUNC inline bool isnan_impl(const double& x)      { return _isnan(x)!=0; }
+EIGEN_DEVICE_FUNC inline bool isnan_impl(const float& x)       { return _isnan(x)!=0; }
+
+EIGEN_DEVICE_FUNC inline bool isinf_impl(const long double& x) { return isinf_msvc_helper(x); }
+EIGEN_DEVICE_FUNC inline bool isinf_impl(const double& x)      { return isinf_msvc_helper(x); }
+EIGEN_DEVICE_FUNC inline bool isinf_impl(const float& x)       { return isinf_msvc_helper(x); }
+
+#elif (defined __FINITE_MATH_ONLY__ && __FINITE_MATH_ONLY__ && EIGEN_COMP_GNUC)
+
+#if EIGEN_GNUC_AT_LEAST(5,0)
+  #define EIGEN_TMP_NOOPT_ATTRIB EIGEN_DEVICE_FUNC inline __attribute__((optimize("no-finite-math-only")))
+#else
+  // NOTE the inline qualifier and noinline attribute are both needed: the former is to avoid linking issue (duplicate symbol),
+  //      while the second prevent too aggressive optimizations in fast-math mode:
+  #define EIGEN_TMP_NOOPT_ATTRIB EIGEN_DEVICE_FUNC inline __attribute__((noinline,optimize("no-finite-math-only")))
+#endif
+
+template<> EIGEN_TMP_NOOPT_ATTRIB bool isnan_impl(const long double& x) { return __builtin_isnan(x); }
+template<> EIGEN_TMP_NOOPT_ATTRIB bool isnan_impl(const double& x)      { return __builtin_isnan(x); }
+template<> EIGEN_TMP_NOOPT_ATTRIB bool isnan_impl(const float& x)       { return __builtin_isnan(x); }
+template<> EIGEN_TMP_NOOPT_ATTRIB bool isinf_impl(const double& x)      { return __builtin_isinf(x); }
+template<> EIGEN_TMP_NOOPT_ATTRIB bool isinf_impl(const float& x)       { return __builtin_isinf(x); }
+template<> EIGEN_TMP_NOOPT_ATTRIB bool isinf_impl(const long double& x) { return __builtin_isinf(x); }
+
+#undef EIGEN_TMP_NOOPT_ATTRIB
+
+#endif
+
+#endif
+
+// The following overload are defined at the end of this file
+template<typename T> EIGEN_DEVICE_FUNC bool isfinite_impl(const std::complex<T>& x);
+template<typename T> EIGEN_DEVICE_FUNC bool isnan_impl(const std::complex<T>& x);
+template<typename T> EIGEN_DEVICE_FUNC bool isinf_impl(const std::complex<T>& x);
+
+template<typename T> T generic_fast_tanh_float(const T& a_x);
+
+} // end namespace internal
+
+/****************************************************************************
+* Generic math functions                                                    *
+****************************************************************************/
+
+namespace numext {
+
+#if !defined(EIGEN_CUDA_ARCH) && !defined(__SYCL_DEVICE_ONLY__)
+template<typename T>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE T mini(const T& x, const T& y)
+{
+  EIGEN_USING_STD_MATH(min);
+  return min EIGEN_NOT_A_MACRO (x,y);
+}
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE T maxi(const T& x, const T& y)
+{
+  EIGEN_USING_STD_MATH(max);
+  return max EIGEN_NOT_A_MACRO (x,y);
+}
+
+
+#elif defined(__SYCL_DEVICE_ONLY__)
+template<typename T>
+EIGEN_ALWAYS_INLINE T mini(const T& x, const T& y)
+{
+
+  return y < x ? y : x;
+}
+
+template<typename T>
+EIGEN_ALWAYS_INLINE T maxi(const T& x, const T& y)
+{
+
+  return x < y ? y : x;
+}
+
+EIGEN_ALWAYS_INLINE int mini(const int& x, const int& y)
+{
+  return cl::sycl::min(x,y);
+}
+
+EIGEN_ALWAYS_INLINE int maxi(const int& x, const int& y)
+{
+  return cl::sycl::max(x,y);
+}
+
+EIGEN_ALWAYS_INLINE unsigned int mini(const unsigned int& x, const unsigned int& y)
+{
+  return cl::sycl::min(x,y);
+}
+
+EIGEN_ALWAYS_INLINE unsigned int maxi(const unsigned int& x, const unsigned int& y)
+{
+  return cl::sycl::max(x,y);
+}
+
+EIGEN_ALWAYS_INLINE  long mini(const long & x, const long & y)
+{
+  return cl::sycl::min(x,y);
+}
+
+EIGEN_ALWAYS_INLINE  long maxi(const long & x, const long & y)
+{
+  return cl::sycl::max(x,y);
+}
+
+EIGEN_ALWAYS_INLINE unsigned long mini(const unsigned long& x, const unsigned long& y)
+{
+  return cl::sycl::min(x,y);
+}
+
+EIGEN_ALWAYS_INLINE unsigned long maxi(const unsigned long& x, const unsigned long& y)
+{
+  return cl::sycl::max(x,y);
+}
+
+
+EIGEN_ALWAYS_INLINE float mini(const float& x, const float& y)
+{
+  return cl::sycl::fmin(x,y);
+}
+
+EIGEN_ALWAYS_INLINE float maxi(const float& x, const float& y)
+{
+  return cl::sycl::fmax(x,y);
+}
+
+EIGEN_ALWAYS_INLINE double mini(const double& x, const double& y)
+{
+  return cl::sycl::fmin(x,y);
+}
+
+EIGEN_ALWAYS_INLINE double maxi(const double& x, const double& y)
+{
+  return cl::sycl::fmax(x,y);
+}
+
+#else
+template<typename T>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE T mini(const T& x, const T& y)
+{
+  return y < x ? y : x;
+}
+template<>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE float mini(const float& x, const float& y)
+{
+  return fminf(x, y);
+}
+template<typename T>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE T maxi(const T& x, const T& y)
+{
+  return x < y ? y : x;
+}
+template<>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE float maxi(const float& x, const float& y)
+{
+  return fmaxf(x, y);
+}
+#endif
+
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(real, Scalar) real(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(real, Scalar)::run(x);
+}
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline typename internal::add_const_on_value_type< EIGEN_MATHFUNC_RETVAL(real_ref, Scalar) >::type real_ref(const Scalar& x)
+{
+  return internal::real_ref_impl<Scalar>::run(x);
+}
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(real_ref, Scalar) real_ref(Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(real_ref, Scalar)::run(x);
+}
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(imag, Scalar) imag(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(imag, Scalar)::run(x);
+}
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(arg, Scalar) arg(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(arg, Scalar)::run(x);
+}
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline typename internal::add_const_on_value_type< EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar) >::type imag_ref(const Scalar& x)
+{
+  return internal::imag_ref_impl<Scalar>::run(x);
+}
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar) imag_ref(Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(imag_ref, Scalar)::run(x);
+}
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(conj, Scalar) conj(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(conj, Scalar)::run(x);
+}
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(abs2, Scalar) abs2(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(abs2, Scalar)::run(x);
+}
+
+EIGEN_DEVICE_FUNC
+inline bool abs2(bool x) { return x; }
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(norm1, Scalar) norm1(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(norm1, Scalar)::run(x);
+}
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(hypot, Scalar) hypot(const Scalar& x, const Scalar& y)
+{
+  return EIGEN_MATHFUNC_IMPL(hypot, Scalar)::run(x, y);
+}
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(log1p, Scalar) log1p(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(log1p, Scalar)::run(x);
+}
+
+#if defined(__SYCL_DEVICE_ONLY__)
+EIGEN_ALWAYS_INLINE float   log1p(float x) { return cl::sycl::log1p(x); }
+EIGEN_ALWAYS_INLINE double  log1p(double x) { return cl::sycl::log1p(x); }
+#endif // defined(__SYCL_DEVICE_ONLY__)
+
+#ifdef EIGEN_CUDACC
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float log1p(const float &x) { return ::log1pf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double log1p(const double &x) { return ::log1p(x); }
+#endif
+
+template<typename ScalarX,typename ScalarY>
+EIGEN_DEVICE_FUNC
+inline typename internal::pow_impl<ScalarX,ScalarY>::result_type pow(const ScalarX& x, const ScalarY& y)
+{
+  return internal::pow_impl<ScalarX,ScalarY>::run(x, y);
+}
+
+#if defined(__SYCL_DEVICE_ONLY__)
+EIGEN_ALWAYS_INLINE float   pow(float x, float y) { return cl::sycl::pow(x, y); }
+EIGEN_ALWAYS_INLINE double  pow(double x, double y) { return cl::sycl::pow(x, y); }
+#endif // defined(__SYCL_DEVICE_ONLY__)
+
+template<typename T> EIGEN_DEVICE_FUNC bool (isnan)   (const T &x) { return internal::isnan_impl(x); }
+template<typename T> EIGEN_DEVICE_FUNC bool (isinf)   (const T &x) { return internal::isinf_impl(x); }
+template<typename T> EIGEN_DEVICE_FUNC bool (isfinite)(const T &x) { return internal::isfinite_impl(x); }
+
+#if defined(__SYCL_DEVICE_ONLY__)
+EIGEN_ALWAYS_INLINE float   isnan(float x) { return cl::sycl::isnan(x); }
+EIGEN_ALWAYS_INLINE double  isnan(double x) { return cl::sycl::isnan(x); }
+EIGEN_ALWAYS_INLINE float   isinf(float x) { return cl::sycl::isinf(x); }
+EIGEN_ALWAYS_INLINE double  isinf(double x) { return cl::sycl::isinf(x); }
+EIGEN_ALWAYS_INLINE float   isfinite(float x) { return cl::sycl::isfinite(x); }
+EIGEN_ALWAYS_INLINE double  isfinite(double x) { return cl::sycl::isfinite(x); }
+#endif // defined(__SYCL_DEVICE_ONLY__)
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(round, Scalar) round(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(round, Scalar)::run(x);
+}
+
+#if defined(__SYCL_DEVICE_ONLY__)
+EIGEN_ALWAYS_INLINE float   round(float x) { return cl::sycl::round(x); }
+EIGEN_ALWAYS_INLINE double  round(double x) { return cl::sycl::round(x); }
+#endif // defined(__SYCL_DEVICE_ONLY__)
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+T (floor)(const T& x)
+{
+  EIGEN_USING_STD_MATH(floor);
+  return floor(x);
+}
+
+#if defined(__SYCL_DEVICE_ONLY__)
+EIGEN_ALWAYS_INLINE float   floor(float x) { return cl::sycl::floor(x); }
+EIGEN_ALWAYS_INLINE double  floor(double x) { return cl::sycl::floor(x); }
+#endif // defined(__SYCL_DEVICE_ONLY__)
+
+#ifdef EIGEN_CUDACC
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float floor(const float &x) { return ::floorf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double floor(const double &x) { return ::floor(x); }
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+T (ceil)(const T& x)
+{
+  EIGEN_USING_STD_MATH(ceil);
+  return ceil(x);
+}
+
+#if defined(__SYCL_DEVICE_ONLY__)
+EIGEN_ALWAYS_INLINE float   ceil(float x) { return cl::sycl::ceil(x); }
+EIGEN_ALWAYS_INLINE double  ceil(double x) { return cl::sycl::ceil(x); }
+#endif // defined(__SYCL_DEVICE_ONLY__)
+
+#ifdef EIGEN_CUDACC
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float ceil(const float &x) { return ::ceilf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double ceil(const double &x) { return ::ceil(x); }
+#endif
+
+
+/** Log base 2 for 32 bits positive integers.
+  * Conveniently returns 0 for x==0. */
+inline int log2(int x)
+{
+  eigen_assert(x>=0);
+  unsigned int v(x);
+  static const int table[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };
+  v |= v >> 1;
+  v |= v >> 2;
+  v |= v >> 4;
+  v |= v >> 8;
+  v |= v >> 16;
+  return table[(v * 0x07C4ACDDU) >> 27];
+}
+
+/** \returns the square root of \a x.
+  *
+  * It is essentially equivalent to \code using std::sqrt; return sqrt(x); \endcode,
+  * but slightly faster for float/double and some compilers (e.g., gcc), thanks to
+  * specializations when SSE is enabled.
+  *
+  * It's usage is justified in performance critical functions, like norm/normalize.
+  */
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T sqrt(const T &x)
+{
+  EIGEN_USING_STD_MATH(sqrt);
+  return sqrt(x);
+}
+
+#if defined(__SYCL_DEVICE_ONLY__)
+EIGEN_ALWAYS_INLINE float   sqrt(float x) { return cl::sycl::sqrt(x); }
+EIGEN_ALWAYS_INLINE double  sqrt(double x) { return cl::sycl::sqrt(x); }
+#endif // defined(__SYCL_DEVICE_ONLY__)
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T log(const T &x) {
+  EIGEN_USING_STD_MATH(log);
+  return log(x);
+}
+
+#if defined(__SYCL_DEVICE_ONLY__)
+EIGEN_ALWAYS_INLINE float   log(float x) { return cl::sycl::log(x); }
+EIGEN_ALWAYS_INLINE double  log(double x) { return cl::sycl::log(x); }
+#endif // defined(__SYCL_DEVICE_ONLY__)
+
+
+#ifdef EIGEN_CUDACC
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float log(const float &x) { return ::logf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double log(const double &x) { return ::log(x); }
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+typename internal::enable_if<NumTraits<T>::IsSigned || NumTraits<T>::IsComplex,typename NumTraits<T>::Real>::type
+abs(const T &x) {
+  EIGEN_USING_STD_MATH(abs);
+  return abs(x);
+}
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+typename internal::enable_if<!(NumTraits<T>::IsSigned || NumTraits<T>::IsComplex),typename NumTraits<T>::Real>::type
+abs(const T &x) {
+  return x;
+}
+
+#if defined(__SYCL_DEVICE_ONLY__)
+EIGEN_ALWAYS_INLINE float   abs(float x) { return cl::sycl::fabs(x); }
+EIGEN_ALWAYS_INLINE double  abs(double x) { return cl::sycl::fabs(x); }
+#endif // defined(__SYCL_DEVICE_ONLY__)
+
+#ifdef EIGEN_CUDACC
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float abs(const float &x) { return ::fabsf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double abs(const double &x) { return ::fabs(x); }
+
+template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float abs(const std::complex<float>& x) {
+  return ::hypotf(x.real(), x.imag());
+}
+
+template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double abs(const std::complex<double>& x) {
+  return ::hypot(x.real(), x.imag());
+}
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T exp(const T &x) {
+  EIGEN_USING_STD_MATH(exp);
+  return exp(x);
+}
+
+#if defined(__SYCL_DEVICE_ONLY__)
+EIGEN_ALWAYS_INLINE float   exp(float x) { return cl::sycl::exp(x); }
+EIGEN_ALWAYS_INLINE double  exp(double x) { return cl::sycl::exp(x); }
+#endif // defined(__SYCL_DEVICE_ONLY__)
+
+#ifdef EIGEN_CUDACC
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float exp(const float &x) { return ::expf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double exp(const double &x) { return ::exp(x); }
+#endif
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(expm1, Scalar) expm1(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(expm1, Scalar)::run(x);
+}
+
+#if defined(__SYCL_DEVICE_ONLY__)
+EIGEN_ALWAYS_INLINE float   expm1(float x) { return cl::sycl::expm1(x); }
+EIGEN_ALWAYS_INLINE double  expm1(double x) { return cl::sycl::expm1(x); }
+#endif // defined(__SYCL_DEVICE_ONLY__)
+
+#ifdef EIGEN_CUDACC
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float expm1(const float &x) { return ::expm1f(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double expm1(const double &x) { return ::expm1(x); }
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T cos(const T &x) {
+  EIGEN_USING_STD_MATH(cos);
+  return cos(x);
+}
+
+#if defined(__SYCL_DEVICE_ONLY__)
+EIGEN_ALWAYS_INLINE float   cos(float x) { return cl::sycl::cos(x); }
+EIGEN_ALWAYS_INLINE double  cos(double x) { return cl::sycl::cos(x); }
+#endif // defined(__SYCL_DEVICE_ONLY__)
+
+#ifdef EIGEN_CUDACC
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float cos(const float &x) { return ::cosf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double cos(const double &x) { return ::cos(x); }
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T sin(const T &x) {
+  EIGEN_USING_STD_MATH(sin);
+  return sin(x);
+}
+
+#if defined(__SYCL_DEVICE_ONLY__)
+EIGEN_ALWAYS_INLINE float   sin(float x) { return cl::sycl::sin(x); }
+EIGEN_ALWAYS_INLINE double  sin(double x) { return cl::sycl::sin(x); }
+#endif // defined(__SYCL_DEVICE_ONLY__)
+
+#ifdef EIGEN_CUDACC
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float sin(const float &x) { return ::sinf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double sin(const double &x) { return ::sin(x); }
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T tan(const T &x) {
+  EIGEN_USING_STD_MATH(tan);
+  return tan(x);
+}
+
+#if defined(__SYCL_DEVICE_ONLY__)
+EIGEN_ALWAYS_INLINE float   tan(float x) { return cl::sycl::tan(x); }
+EIGEN_ALWAYS_INLINE double  tan(double x) { return cl::sycl::tan(x); }
+#endif // defined(__SYCL_DEVICE_ONLY__)
+
+#ifdef EIGEN_CUDACC
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float tan(const float &x) { return ::tanf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double tan(const double &x) { return ::tan(x); }
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T acos(const T &x) {
+  EIGEN_USING_STD_MATH(acos);
+  return acos(x);
+}
+
+#if EIGEN_HAS_CXX11_MATH
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T acosh(const T &x) {
+  EIGEN_USING_STD_MATH(acosh);
+  return acosh(x);
+}
+#endif
+
+#if defined(__SYCL_DEVICE_ONLY__)
+EIGEN_ALWAYS_INLINE float   acos(float x) { return cl::sycl::acos(x); }
+EIGEN_ALWAYS_INLINE double  acos(double x) { return cl::sycl::acos(x); }
+EIGEN_ALWAYS_INLINE float   acosh(float x) { return cl::sycl::acosh(x); }
+EIGEN_ALWAYS_INLINE double  acosh(double x) { return cl::sycl::acosh(x); }
+#endif // defined(__SYCL_DEVICE_ONLY__)
+
+#ifdef EIGEN_CUDACC
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float acos(const float &x) { return ::acosf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double acos(const double &x) { return ::acos(x); }
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T asin(const T &x) {
+  EIGEN_USING_STD_MATH(asin);
+  return asin(x);
+}
+
+#if EIGEN_HAS_CXX11_MATH
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T asinh(const T &x) {
+  EIGEN_USING_STD_MATH(asinh);
+  return asinh(x);
+}
+#endif
+
+#if defined(__SYCL_DEVICE_ONLY__)
+EIGEN_ALWAYS_INLINE float   asin(float x) { return cl::sycl::asin(x); }
+EIGEN_ALWAYS_INLINE double  asin(double x) { return cl::sycl::asin(x); }
+EIGEN_ALWAYS_INLINE float   asinh(float x) { return cl::sycl::asinh(x); }
+EIGEN_ALWAYS_INLINE double  asinh(double x) { return cl::sycl::asinh(x); }
+#endif // defined(__SYCL_DEVICE_ONLY__)
+
+#ifdef EIGEN_CUDACC
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float asin(const float &x) { return ::asinf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double asin(const double &x) { return ::asin(x); }
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T atan(const T &x) {
+  EIGEN_USING_STD_MATH(atan);
+  return atan(x);
+}
+
+#if EIGEN_HAS_CXX11_MATH
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T atanh(const T &x) {
+  EIGEN_USING_STD_MATH(atanh);
+  return atanh(x);
+}
+#endif
+
+#if defined(__SYCL_DEVICE_ONLY__)
+EIGEN_ALWAYS_INLINE float   atan(float x) { return cl::sycl::atan(x); }
+EIGEN_ALWAYS_INLINE double  atan(double x) { return cl::sycl::atan(x); }
+EIGEN_ALWAYS_INLINE float   atanh(float x) { return cl::sycl::atanh(x); }
+EIGEN_ALWAYS_INLINE double  atanh(double x) { return cl::sycl::atanh(x); }
+#endif // defined(__SYCL_DEVICE_ONLY__)
+
+#ifdef EIGEN_CUDACC
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float atan(const float &x) { return ::atanf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double atan(const double &x) { return ::atan(x); }
+#endif
+
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T cosh(const T &x) {
+  EIGEN_USING_STD_MATH(cosh);
+  return cosh(x);
+}
+
+#if defined(__SYCL_DEVICE_ONLY__)
+EIGEN_ALWAYS_INLINE float   cosh(float x) { return cl::sycl::cosh(x); }
+EIGEN_ALWAYS_INLINE double  cosh(double x) { return cl::sycl::cosh(x); }
+#endif // defined(__SYCL_DEVICE_ONLY__)
+
+#ifdef EIGEN_CUDACC
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float cosh(const float &x) { return ::coshf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double cosh(const double &x) { return ::cosh(x); }
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T sinh(const T &x) {
+  EIGEN_USING_STD_MATH(sinh);
+  return sinh(x);
+}
+
+#if defined(__SYCL_DEVICE_ONLY__)
+EIGEN_ALWAYS_INLINE float   sinh(float x) { return cl::sycl::sinh(x); }
+EIGEN_ALWAYS_INLINE double  sinh(double x) { return cl::sycl::sinh(x); }
+#endif // defined(__SYCL_DEVICE_ONLY__)
+
+#ifdef EIGEN_CUDACC
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float sinh(const float &x) { return ::sinhf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double sinh(const double &x) { return ::sinh(x); }
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T tanh(const T &x) {
+  EIGEN_USING_STD_MATH(tanh);
+  return tanh(x);
+}
+
+#if defined(__SYCL_DEVICE_ONLY__)
+EIGEN_ALWAYS_INLINE float   tanh(float x) { return cl::sycl::tanh(x); }
+EIGEN_ALWAYS_INLINE double  tanh(double x) { return cl::sycl::tanh(x); }
+#elif (!defined(EIGEN_CUDACC)) && EIGEN_FAST_MATH
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float tanh(float x) { return internal::generic_fast_tanh_float(x); }
+#endif
+
+#ifdef EIGEN_CUDACC
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float tanh(const float &x) { return ::tanhf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double tanh(const double &x) { return ::tanh(x); }
+#endif
+
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T fmod(const T& a, const T& b) {
+  EIGEN_USING_STD_MATH(fmod);
+  return fmod(a, b);
+}
+
+#if defined(__SYCL_DEVICE_ONLY__)
+EIGEN_ALWAYS_INLINE float   fmod(float x, float y) { return cl::sycl::fmod(x, y); }
+EIGEN_ALWAYS_INLINE double  fmod(double x, double y) { return cl::sycl::fmod(x, y); }
+#endif // defined(__SYCL_DEVICE_ONLY__)
+
+#ifdef EIGEN_CUDACC
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float fmod(const float& a, const float& b) {
+  return ::fmodf(a, b);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double fmod(const double& a, const double& b) {
+  return ::fmod(a, b);
+}
+#endif
+
+} // end namespace numext
+
+namespace internal {
+
+template<typename T>
+EIGEN_DEVICE_FUNC bool isfinite_impl(const std::complex<T>& x)
+{
+  return (numext::isfinite)(numext::real(x)) && (numext::isfinite)(numext::imag(x));
+}
+
+template<typename T>
+EIGEN_DEVICE_FUNC bool isnan_impl(const std::complex<T>& x)
+{
+  return (numext::isnan)(numext::real(x)) || (numext::isnan)(numext::imag(x));
+}
+
+template<typename T>
+EIGEN_DEVICE_FUNC bool isinf_impl(const std::complex<T>& x)
+{
+  return ((numext::isinf)(numext::real(x)) || (numext::isinf)(numext::imag(x))) && (!(numext::isnan)(x));
+}
+
+/****************************************************************************
+* Implementation of fuzzy comparisons                                       *
+****************************************************************************/
+
+template<typename Scalar,
+         bool IsComplex,
+         bool IsInteger>
+struct scalar_fuzzy_default_impl {};
+
+template<typename Scalar>
+struct scalar_fuzzy_default_impl<Scalar, false, false>
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  template<typename OtherScalar> EIGEN_DEVICE_FUNC
+  static inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y, const RealScalar& prec)
+  {
+    return numext::abs(x) <= numext::abs(y) * prec;
+  }
+  EIGEN_DEVICE_FUNC
+  static inline bool isApprox(const Scalar& x, const Scalar& y, const RealScalar& prec)
+  {
+    return numext::abs(x - y) <= numext::mini(numext::abs(x), numext::abs(y)) * prec;
+  }
+  EIGEN_DEVICE_FUNC
+  static inline bool isApproxOrLessThan(const Scalar& x, const Scalar& y, const RealScalar& prec)
+  {
+    return x <= y || isApprox(x, y, prec);
+  }
+};
+
+template<typename Scalar>
+struct scalar_fuzzy_default_impl<Scalar, false, true>
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  template<typename OtherScalar> EIGEN_DEVICE_FUNC
+  static inline bool isMuchSmallerThan(const Scalar& x, const Scalar&, const RealScalar&)
+  {
+    return x == Scalar(0);
+  }
+  EIGEN_DEVICE_FUNC
+  static inline bool isApprox(const Scalar& x, const Scalar& y, const RealScalar&)
+  {
+    return x == y;
+  }
+  EIGEN_DEVICE_FUNC
+  static inline bool isApproxOrLessThan(const Scalar& x, const Scalar& y, const RealScalar&)
+  {
+    return x <= y;
+  }
+};
+
+template<typename Scalar>
+struct scalar_fuzzy_default_impl<Scalar, true, false>
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  template<typename OtherScalar> EIGEN_DEVICE_FUNC
+  static inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y, const RealScalar& prec)
+  {
+    return numext::abs2(x) <= numext::abs2(y) * prec * prec;
+  }
+  EIGEN_DEVICE_FUNC
+  static inline bool isApprox(const Scalar& x, const Scalar& y, const RealScalar& prec)
+  {
+    return numext::abs2(x - y) <= numext::mini(numext::abs2(x), numext::abs2(y)) * prec * prec;
+  }
+};
+
+template<typename Scalar>
+struct scalar_fuzzy_impl : scalar_fuzzy_default_impl<Scalar, NumTraits<Scalar>::IsComplex, NumTraits<Scalar>::IsInteger> {};
+
+template<typename Scalar, typename OtherScalar> EIGEN_DEVICE_FUNC
+inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y,
+                              const typename NumTraits<Scalar>::Real &precision = NumTraits<Scalar>::dummy_precision())
+{
+  return scalar_fuzzy_impl<Scalar>::template isMuchSmallerThan<OtherScalar>(x, y, precision);
+}
+
+template<typename Scalar> EIGEN_DEVICE_FUNC
+inline bool isApprox(const Scalar& x, const Scalar& y,
+                     const typename NumTraits<Scalar>::Real &precision = NumTraits<Scalar>::dummy_precision())
+{
+  return scalar_fuzzy_impl<Scalar>::isApprox(x, y, precision);
+}
+
+template<typename Scalar> EIGEN_DEVICE_FUNC
+inline bool isApproxOrLessThan(const Scalar& x, const Scalar& y,
+                               const typename NumTraits<Scalar>::Real &precision = NumTraits<Scalar>::dummy_precision())
+{
+  return scalar_fuzzy_impl<Scalar>::isApproxOrLessThan(x, y, precision);
+}
+
+/******************************************
+***  The special case of the  bool type ***
+******************************************/
+
+template<> struct random_impl<bool>
+{
+  static inline bool run()
+  {
+    return random<int>(0,1)==0 ? false : true;
+  }
+};
+
+template<> struct scalar_fuzzy_impl<bool>
+{
+  typedef bool RealScalar;
+
+  template<typename OtherScalar> EIGEN_DEVICE_FUNC
+  static inline bool isMuchSmallerThan(const bool& x, const bool&, const bool&)
+  {
+    return !x;
+  }
+
+  EIGEN_DEVICE_FUNC
+  static inline bool isApprox(bool x, bool y, bool)
+  {
+    return x == y;
+  }
+
+  EIGEN_DEVICE_FUNC
+  static inline bool isApproxOrLessThan(const bool& x, const bool& y, const bool&)
+  {
+    return (!x) || y;
+  }
+
+};
+
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_MATHFUNCTIONS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/MathFunctionsImpl.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/MathFunctionsImpl.h
new file mode 100644
index 00000000..ae1386b4
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/MathFunctionsImpl.h
@@ -0,0 +1,73 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Pedro Gonnet (pedro.gonnet@gmail.com)
+// Copyright (C) 2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATHFUNCTIONSIMPL_H
+#define EIGEN_MATHFUNCTIONSIMPL_H
+
+namespace Eigen {
+
+namespace internal {
+
+/** \internal \returns the hyperbolic tan of \a a (coeff-wise)
+    Doesn't do anything fancy, just a 13/6-degree rational interpolant which
+    is accurate up to a couple of ulp in the range [-9, 9], outside of which
+    the tanh(x) = +/-1.
+
+    This implementation works on both scalars and packets.
+*/
+template<typename T>
+T generic_fast_tanh_float(const T& a_x)
+{
+  // Clamp the inputs to the range [-9, 9] since anything outside
+  // this range is +/-1.0f in single-precision.
+  const T plus_9 = pset1<T>(9.f);
+  const T minus_9 = pset1<T>(-9.f);
+  const T x = pmax(pmin(a_x, plus_9), minus_9);
+  // The monomial coefficients of the numerator polynomial (odd).
+  const T alpha_1 = pset1<T>(4.89352455891786e-03f);
+  const T alpha_3 = pset1<T>(6.37261928875436e-04f);
+  const T alpha_5 = pset1<T>(1.48572235717979e-05f);
+  const T alpha_7 = pset1<T>(5.12229709037114e-08f);
+  const T alpha_9 = pset1<T>(-8.60467152213735e-11f);
+  const T alpha_11 = pset1<T>(2.00018790482477e-13f);
+  const T alpha_13 = pset1<T>(-2.76076847742355e-16f);
+
+  // The monomial coefficients of the denominator polynomial (even).
+  const T beta_0 = pset1<T>(4.89352518554385e-03f);
+  const T beta_2 = pset1<T>(2.26843463243900e-03f);
+  const T beta_4 = pset1<T>(1.18534705686654e-04f);
+  const T beta_6 = pset1<T>(1.19825839466702e-06f);
+
+  // Since the polynomials are odd/even, we need x^2.
+  const T x2 = pmul(x, x);
+
+  // Evaluate the numerator polynomial p.
+  T p = pmadd(x2, alpha_13, alpha_11);
+  p = pmadd(x2, p, alpha_9);
+  p = pmadd(x2, p, alpha_7);
+  p = pmadd(x2, p, alpha_5);
+  p = pmadd(x2, p, alpha_3);
+  p = pmadd(x2, p, alpha_1);
+  p = pmul(x, p);
+
+  // Evaluate the denominator polynomial p.
+  T q = pmadd(x2, beta_6, beta_4);
+  q = pmadd(x2, q, beta_2);
+  q = pmadd(x2, q, beta_0);
+
+  // Divide the numerator by the denominator.
+  return pdiv(p, q);
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_MATHFUNCTIONSIMPL_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Matrix.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Matrix.h
new file mode 100644
index 00000000..90c336d8
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Matrix.h
@@ -0,0 +1,461 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATRIX_H
+#define EIGEN_MATRIX_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+struct traits<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
+{
+private:
+  enum { size = internal::size_at_compile_time<_Rows,_Cols>::ret };
+  typedef typename find_best_packet<_Scalar,size>::type PacketScalar;
+  enum {
+      row_major_bit = _Options&RowMajor ? RowMajorBit : 0,
+      is_dynamic_size_storage = _MaxRows==Dynamic || _MaxCols==Dynamic,
+      max_size = is_dynamic_size_storage ? Dynamic : _MaxRows*_MaxCols,
+      default_alignment = compute_default_alignment<_Scalar,max_size>::value,
+      actual_alignment = ((_Options&DontAlign)==0) ? default_alignment : 0,
+      required_alignment = unpacket_traits<PacketScalar>::alignment,
+      packet_access_bit = (packet_traits<_Scalar>::Vectorizable && (EIGEN_UNALIGNED_VECTORIZE || (actual_alignment>=required_alignment))) ? PacketAccessBit : 0
+    };
+    
+public:
+  typedef _Scalar Scalar;
+  typedef Dense StorageKind;
+  typedef Eigen::Index StorageIndex;
+  typedef MatrixXpr XprKind;
+  enum {
+    RowsAtCompileTime = _Rows,
+    ColsAtCompileTime = _Cols,
+    MaxRowsAtCompileTime = _MaxRows,
+    MaxColsAtCompileTime = _MaxCols,
+    Flags = compute_matrix_flags<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>::ret,
+    Options = _Options,
+    InnerStrideAtCompileTime = 1,
+    OuterStrideAtCompileTime = (Options&RowMajor) ? ColsAtCompileTime : RowsAtCompileTime,
+    
+    // FIXME, the following flag in only used to define NeedsToAlign in PlainObjectBase
+    EvaluatorFlags = LinearAccessBit | DirectAccessBit | packet_access_bit | row_major_bit,
+    Alignment = actual_alignment
+  };
+};
+}
+
+/** \class Matrix
+  * \ingroup Core_Module
+  *
+  * \brief The matrix class, also used for vectors and row-vectors
+  *
+  * The %Matrix class is the work-horse for all \em dense (\ref dense "note") matrices and vectors within Eigen.
+  * Vectors are matrices with one column, and row-vectors are matrices with one row.
+  *
+  * The %Matrix class encompasses \em both fixed-size and dynamic-size objects (\ref fixedsize "note").
+  *
+  * The first three template parameters are required:
+  * \tparam _Scalar Numeric type, e.g. float, double, int or std::complex<float>.
+  *                 User defined scalar types are supported as well (see \ref user_defined_scalars "here").
+  * \tparam _Rows Number of rows, or \b Dynamic
+  * \tparam _Cols Number of columns, or \b Dynamic
+  *
+  * The remaining template parameters are optional -- in most cases you don't have to worry about them.
+  * \tparam _Options A combination of either \b #RowMajor or \b #ColMajor, and of either
+  *                 \b #AutoAlign or \b #DontAlign.
+  *                 The former controls \ref TopicStorageOrders "storage order", and defaults to column-major. The latter controls alignment, which is required
+  *                 for vectorization. It defaults to aligning matrices except for fixed sizes that aren't a multiple of the packet size.
+  * \tparam _MaxRows Maximum number of rows. Defaults to \a _Rows (\ref maxrows "note").
+  * \tparam _MaxCols Maximum number of columns. Defaults to \a _Cols (\ref maxrows "note").
+  *
+  * Eigen provides a number of typedefs covering the usual cases. Here are some examples:
+  *
+  * \li \c Matrix2d is a 2x2 square matrix of doubles (\c Matrix<double, 2, 2>)
+  * \li \c Vector4f is a vector of 4 floats (\c Matrix<float, 4, 1>)
+  * \li \c RowVector3i is a row-vector of 3 ints (\c Matrix<int, 1, 3>)
+  *
+  * \li \c MatrixXf is a dynamic-size matrix of floats (\c Matrix<float, Dynamic, Dynamic>)
+  * \li \c VectorXf is a dynamic-size vector of floats (\c Matrix<float, Dynamic, 1>)
+  *
+  * \li \c Matrix2Xf is a partially fixed-size (dynamic-size) matrix of floats (\c Matrix<float, 2, Dynamic>)
+  * \li \c MatrixX3d is a partially dynamic-size (fixed-size) matrix of double (\c Matrix<double, Dynamic, 3>)
+  *
+  * See \link matrixtypedefs this page \endlink for a complete list of predefined \em %Matrix and \em Vector typedefs.
+  *
+  * You can access elements of vectors and matrices using normal subscripting:
+  *
+  * \code
+  * Eigen::VectorXd v(10);
+  * v[0] = 0.1;
+  * v[1] = 0.2;
+  * v(0) = 0.3;
+  * v(1) = 0.4;
+  *
+  * Eigen::MatrixXi m(10, 10);
+  * m(0, 1) = 1;
+  * m(0, 2) = 2;
+  * m(0, 3) = 3;
+  * \endcode
+  *
+  * This class can be extended with the help of the plugin mechanism described on the page
+  * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_MATRIX_PLUGIN.
+  *
+  * <i><b>Some notes:</b></i>
+  *
+  * <dl>
+  * <dt><b>\anchor dense Dense versus sparse:</b></dt>
+  * <dd>This %Matrix class handles dense, not sparse matrices and vectors. For sparse matrices and vectors, see the Sparse module.
+  *
+  * Dense matrices and vectors are plain usual arrays of coefficients. All the coefficients are stored, in an ordinary contiguous array.
+  * This is unlike Sparse matrices and vectors where the coefficients are stored as a list of nonzero coefficients.</dd>
+  *
+  * <dt><b>\anchor fixedsize Fixed-size versus dynamic-size:</b></dt>
+  * <dd>Fixed-size means that the numbers of rows and columns are known are compile-time. In this case, Eigen allocates the array
+  * of coefficients as a fixed-size array, as a class member. This makes sense for very small matrices, typically up to 4x4, sometimes up
+  * to 16x16. Larger matrices should be declared as dynamic-size even if one happens to know their size at compile-time.
+  *
+  * Dynamic-size means that the numbers of rows or columns are not necessarily known at compile-time. In this case they are runtime
+  * variables, and the array of coefficients is allocated dynamically on the heap.
+  *
+  * Note that \em dense matrices, be they Fixed-size or Dynamic-size, <em>do not</em> expand dynamically in the sense of a std::map.
+  * If you want this behavior, see the Sparse module.</dd>
+  *
+  * <dt><b>\anchor maxrows _MaxRows and _MaxCols:</b></dt>
+  * <dd>In most cases, one just leaves these parameters to the default values.
+  * These parameters mean the maximum size of rows and columns that the matrix may have. They are useful in cases
+  * when the exact numbers of rows and columns are not known are compile-time, but it is known at compile-time that they cannot
+  * exceed a certain value. This happens when taking dynamic-size blocks inside fixed-size matrices: in this case _MaxRows and _MaxCols
+  * are the dimensions of the original matrix, while _Rows and _Cols are Dynamic.</dd>
+  * </dl>
+  *
+  * <i><b>ABI and storage layout</b></i>
+  *
+  * The table below summarizes the ABI of some possible Matrix instances which is fixed thorough the lifetime of Eigen 3.
+  * <table  class="manual">
+  * <tr><th>Matrix type</th><th>Equivalent C structure</th></tr>
+  * <tr><td>\code Matrix<T,Dynamic,Dynamic> \endcode</td><td>\code
+  * struct {
+  *   T *data;                  // with (size_t(data)%EIGEN_MAX_ALIGN_BYTES)==0
+  *   Eigen::Index rows, cols;
+  *  };
+  * \endcode</td></tr>
+  * <tr class="alt"><td>\code
+  * Matrix<T,Dynamic,1>
+  * Matrix<T,1,Dynamic> \endcode</td><td>\code
+  * struct {
+  *   T *data;                  // with (size_t(data)%EIGEN_MAX_ALIGN_BYTES)==0
+  *   Eigen::Index size;
+  *  };
+  * \endcode</td></tr>
+  * <tr><td>\code Matrix<T,Rows,Cols> \endcode</td><td>\code
+  * struct {
+  *   T data[Rows*Cols];        // with (size_t(data)%A(Rows*Cols*sizeof(T)))==0
+  *  };
+  * \endcode</td></tr>
+  * <tr class="alt"><td>\code Matrix<T,Dynamic,Dynamic,0,MaxRows,MaxCols> \endcode</td><td>\code
+  * struct {
+  *   T data[MaxRows*MaxCols];  // with (size_t(data)%A(MaxRows*MaxCols*sizeof(T)))==0
+  *   Eigen::Index rows, cols;
+  *  };
+  * \endcode</td></tr>
+  * </table>
+  * Note that in this table Rows, Cols, MaxRows and MaxCols are all positive integers. A(S) is defined to the largest possible power-of-two
+  * smaller to EIGEN_MAX_STATIC_ALIGN_BYTES.
+  *
+  * \see MatrixBase for the majority of the API methods for matrices, \ref TopicClassHierarchy,
+  * \ref TopicStorageOrders
+  */
+
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+class Matrix
+  : public PlainObjectBase<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
+{
+  public:
+
+    /** \brief Base class typedef.
+      * \sa PlainObjectBase
+      */
+    typedef PlainObjectBase<Matrix> Base;
+
+    enum { Options = _Options };
+
+    EIGEN_DENSE_PUBLIC_INTERFACE(Matrix)
+
+    typedef typename Base::PlainObject PlainObject;
+
+    using Base::base;
+    using Base::coeffRef;
+
+    /**
+      * \brief Assigns matrices to each other.
+      *
+      * \note This is a special case of the templated operator=. Its purpose is
+      * to prevent a default operator= from hiding the templated operator=.
+      *
+      * \callgraph
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Matrix& operator=(const Matrix& other)
+    {
+      return Base::_set(other);
+    }
+
+    /** \internal
+      * \brief Copies the value of the expression \a other into \c *this with automatic resizing.
+      *
+      * *this might be resized to match the dimensions of \a other. If *this was a null matrix (not already initialized),
+      * it will be initialized.
+      *
+      * Note that copying a row-vector into a vector (and conversely) is allowed.
+      * The resizing, if any, is then done in the appropriate way so that row-vectors
+      * remain row-vectors and vectors remain vectors.
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Matrix& operator=(const DenseBase<OtherDerived>& other)
+    {
+      return Base::_set(other);
+    }
+
+    /* Here, doxygen failed to copy the brief information when using \copydoc */
+
+    /**
+      * \brief Copies the generic expression \a other into *this.
+      * \copydetails DenseBase::operator=(const EigenBase<OtherDerived> &other)
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Matrix& operator=(const EigenBase<OtherDerived> &other)
+    {
+      return Base::operator=(other);
+    }
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Matrix& operator=(const ReturnByValue<OtherDerived>& func)
+    {
+      return Base::operator=(func);
+    }
+
+    /** \brief Default constructor.
+      *
+      * For fixed-size matrices, does nothing.
+      *
+      * For dynamic-size matrices, creates an empty matrix of size 0. Does not allocate any array. Such a matrix
+      * is called a null matrix. This constructor is the unique way to create null matrices: resizing
+      * a matrix to 0 is not supported.
+      *
+      * \sa resize(Index,Index)
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Matrix() : Base()
+    {
+      Base::_check_template_params();
+      EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+    }
+
+    // FIXME is it still needed
+    EIGEN_DEVICE_FUNC
+    explicit Matrix(internal::constructor_without_unaligned_array_assert)
+      : Base(internal::constructor_without_unaligned_array_assert())
+    { Base::_check_template_params(); EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED }
+
+#if EIGEN_HAS_RVALUE_REFERENCES
+    EIGEN_DEVICE_FUNC
+    Matrix(Matrix&& other) EIGEN_NOEXCEPT_IF(std::is_nothrow_move_constructible<Scalar>::value)
+      : Base(std::move(other))
+    {
+      Base::_check_template_params();
+      if (RowsAtCompileTime!=Dynamic && ColsAtCompileTime!=Dynamic)
+        Base::_set_noalias(other);
+    }
+    EIGEN_DEVICE_FUNC
+    Matrix& operator=(Matrix&& other) EIGEN_NOEXCEPT_IF(std::is_nothrow_move_assignable<Scalar>::value)
+    {
+      other.swap(*this);
+      return *this;
+    }
+#endif
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+
+    // This constructor is for both 1x1 matrices and dynamic vectors
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE explicit Matrix(const T& x)
+    {
+      Base::_check_template_params();
+      Base::template _init1<T>(x);
+    }
+
+    template<typename T0, typename T1>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Matrix(const T0& x, const T1& y)
+    {
+      Base::_check_template_params();
+      Base::template _init2<T0,T1>(x, y);
+    }
+    #else
+    /** \brief Constructs a fixed-sized matrix initialized with coefficients starting at \a data */
+    EIGEN_DEVICE_FUNC
+    explicit Matrix(const Scalar *data);
+
+    /** \brief Constructs a vector or row-vector with given dimension. \only_for_vectors
+      *
+      * This is useful for dynamic-size vectors. For fixed-size vectors,
+      * it is redundant to pass these parameters, so one should use the default constructor
+      * Matrix() instead.
+      * 
+      * \warning This constructor is disabled for fixed-size \c 1x1 matrices. For instance,
+      * calling Matrix<double,1,1>(1) will call the initialization constructor: Matrix(const Scalar&).
+      * For fixed-size \c 1x1 matrices it is therefore recommended to use the default
+      * constructor Matrix() instead, especially when using one of the non standard
+      * \c EIGEN_INITIALIZE_MATRICES_BY_{ZERO,\c NAN} macros (see \ref TopicPreprocessorDirectives).
+      */
+    EIGEN_STRONG_INLINE explicit Matrix(Index dim);
+    /** \brief Constructs an initialized 1x1 matrix with the given coefficient */
+    Matrix(const Scalar& x);
+    /** \brief Constructs an uninitialized matrix with \a rows rows and \a cols columns.
+      *
+      * This is useful for dynamic-size matrices. For fixed-size matrices,
+      * it is redundant to pass these parameters, so one should use the default constructor
+      * Matrix() instead.
+      * 
+      * \warning This constructor is disabled for fixed-size \c 1x2 and \c 2x1 vectors. For instance,
+      * calling Matrix2f(2,1) will call the initialization constructor: Matrix(const Scalar& x, const Scalar& y).
+      * For fixed-size \c 1x2 or \c 2x1 vectors it is therefore recommended to use the default
+      * constructor Matrix() instead, especially when using one of the non standard
+      * \c EIGEN_INITIALIZE_MATRICES_BY_{ZERO,\c NAN} macros (see \ref TopicPreprocessorDirectives).
+      */
+    EIGEN_DEVICE_FUNC
+    Matrix(Index rows, Index cols);
+    
+    /** \brief Constructs an initialized 2D vector with given coefficients */
+    Matrix(const Scalar& x, const Scalar& y);
+    #endif
+
+    /** \brief Constructs an initialized 3D vector with given coefficients */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Matrix(const Scalar& x, const Scalar& y, const Scalar& z)
+    {
+      Base::_check_template_params();
+      EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Matrix, 3)
+      m_storage.data()[0] = x;
+      m_storage.data()[1] = y;
+      m_storage.data()[2] = z;
+    }
+    /** \brief Constructs an initialized 4D vector with given coefficients */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Matrix(const Scalar& x, const Scalar& y, const Scalar& z, const Scalar& w)
+    {
+      Base::_check_template_params();
+      EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Matrix, 4)
+      m_storage.data()[0] = x;
+      m_storage.data()[1] = y;
+      m_storage.data()[2] = z;
+      m_storage.data()[3] = w;
+    }
+
+
+    /** \brief Copy constructor */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Matrix(const Matrix& other) : Base(other)
+    { }
+
+    /** \brief Copy constructor for generic expressions.
+      * \sa MatrixBase::operator=(const EigenBase<OtherDerived>&)
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Matrix(const EigenBase<OtherDerived> &other)
+      : Base(other.derived())
+    { }
+
+    EIGEN_DEVICE_FUNC inline Index innerStride() const { return 1; }
+    EIGEN_DEVICE_FUNC inline Index outerStride() const { return this->innerSize(); }
+
+    /////////// Geometry module ///////////
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    explicit Matrix(const RotationBase<OtherDerived,ColsAtCompileTime>& r);
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    Matrix& operator=(const RotationBase<OtherDerived,ColsAtCompileTime>& r);
+
+    // allow to extend Matrix outside Eigen
+    #ifdef EIGEN_MATRIX_PLUGIN
+    #include EIGEN_MATRIX_PLUGIN
+    #endif
+
+  protected:
+    template <typename Derived, typename OtherDerived, bool IsVector>
+    friend struct internal::conservative_resize_like_impl;
+
+    using Base::m_storage;
+};
+
+/** \defgroup matrixtypedefs Global matrix typedefs
+  *
+  * \ingroup Core_Module
+  *
+  * Eigen defines several typedef shortcuts for most common matrix and vector types.
+  *
+  * The general patterns are the following:
+  *
+  * \c MatrixSizeType where \c Size can be \c 2,\c 3,\c 4 for fixed size square matrices or \c X for dynamic size,
+  * and where \c Type can be \c i for integer, \c f for float, \c d for double, \c cf for complex float, \c cd
+  * for complex double.
+  *
+  * For example, \c Matrix3d is a fixed-size 3x3 matrix type of doubles, and \c MatrixXf is a dynamic-size matrix of floats.
+  *
+  * There are also \c VectorSizeType and \c RowVectorSizeType which are self-explanatory. For example, \c Vector4cf is
+  * a fixed-size vector of 4 complex floats.
+  *
+  * \sa class Matrix
+  */
+
+#define EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, Size, SizeSuffix)   \
+/** \ingroup matrixtypedefs */                                    \
+typedef Matrix<Type, Size, Size> Matrix##SizeSuffix##TypeSuffix;  \
+/** \ingroup matrixtypedefs */                                    \
+typedef Matrix<Type, Size, 1>    Vector##SizeSuffix##TypeSuffix;  \
+/** \ingroup matrixtypedefs */                                    \
+typedef Matrix<Type, 1, Size>    RowVector##SizeSuffix##TypeSuffix;
+
+#define EIGEN_MAKE_FIXED_TYPEDEFS(Type, TypeSuffix, Size)         \
+/** \ingroup matrixtypedefs */                                    \
+typedef Matrix<Type, Size, Dynamic> Matrix##Size##X##TypeSuffix;  \
+/** \ingroup matrixtypedefs */                                    \
+typedef Matrix<Type, Dynamic, Size> Matrix##X##Size##TypeSuffix;
+
+#define EIGEN_MAKE_TYPEDEFS_ALL_SIZES(Type, TypeSuffix) \
+EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 2, 2) \
+EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 3, 3) \
+EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 4, 4) \
+EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, Dynamic, X) \
+EIGEN_MAKE_FIXED_TYPEDEFS(Type, TypeSuffix, 2) \
+EIGEN_MAKE_FIXED_TYPEDEFS(Type, TypeSuffix, 3) \
+EIGEN_MAKE_FIXED_TYPEDEFS(Type, TypeSuffix, 4)
+
+EIGEN_MAKE_TYPEDEFS_ALL_SIZES(int,                  i)
+EIGEN_MAKE_TYPEDEFS_ALL_SIZES(float,                f)
+EIGEN_MAKE_TYPEDEFS_ALL_SIZES(double,               d)
+EIGEN_MAKE_TYPEDEFS_ALL_SIZES(std::complex<float>,  cf)
+EIGEN_MAKE_TYPEDEFS_ALL_SIZES(std::complex<double>, cd)
+
+#undef EIGEN_MAKE_TYPEDEFS_ALL_SIZES
+#undef EIGEN_MAKE_TYPEDEFS
+#undef EIGEN_MAKE_FIXED_TYPEDEFS
+
+} // end namespace Eigen
+
+#endif // EIGEN_MATRIX_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/MatrixBase.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/MatrixBase.h
new file mode 100644
index 00000000..11435903
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/MatrixBase.h
@@ -0,0 +1,525 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATRIXBASE_H
+#define EIGEN_MATRIXBASE_H
+
+namespace Eigen {
+
+/** \class MatrixBase
+  * \ingroup Core_Module
+  *
+  * \brief Base class for all dense matrices, vectors, and expressions
+  *
+  * This class is the base that is inherited by all matrix, vector, and related expression
+  * types. Most of the Eigen API is contained in this class, and its base classes. Other important
+  * classes for the Eigen API are Matrix, and VectorwiseOp.
+  *
+  * Note that some methods are defined in other modules such as the \ref LU_Module LU module
+  * for all functions related to matrix inversions.
+  *
+  * \tparam Derived is the derived type, e.g. a matrix type, or an expression, etc.
+  *
+  * When writing a function taking Eigen objects as argument, if you want your function
+  * to take as argument any matrix, vector, or expression, just let it take a
+  * MatrixBase argument. As an example, here is a function printFirstRow which, given
+  * a matrix, vector, or expression \a x, prints the first row of \a x.
+  *
+  * \code
+    template<typename Derived>
+    void printFirstRow(const Eigen::MatrixBase<Derived>& x)
+    {
+      cout << x.row(0) << endl;
+    }
+  * \endcode
+  *
+  * This class can be extended with the help of the plugin mechanism described on the page
+  * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_MATRIXBASE_PLUGIN.
+  *
+  * \sa \blank \ref TopicClassHierarchy
+  */
+template<typename Derived> class MatrixBase
+  : public DenseBase<Derived>
+{
+  public:
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    typedef MatrixBase StorageBaseType;
+    typedef typename internal::traits<Derived>::StorageKind StorageKind;
+    typedef typename internal::traits<Derived>::StorageIndex StorageIndex;
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    typedef typename internal::packet_traits<Scalar>::type PacketScalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    typedef DenseBase<Derived> Base;
+    using Base::RowsAtCompileTime;
+    using Base::ColsAtCompileTime;
+    using Base::SizeAtCompileTime;
+    using Base::MaxRowsAtCompileTime;
+    using Base::MaxColsAtCompileTime;
+    using Base::MaxSizeAtCompileTime;
+    using Base::IsVectorAtCompileTime;
+    using Base::Flags;
+
+    using Base::derived;
+    using Base::const_cast_derived;
+    using Base::rows;
+    using Base::cols;
+    using Base::size;
+    using Base::coeff;
+    using Base::coeffRef;
+    using Base::lazyAssign;
+    using Base::eval;
+    using Base::operator-;
+    using Base::operator+=;
+    using Base::operator-=;
+    using Base::operator*=;
+    using Base::operator/=;
+
+    typedef typename Base::CoeffReturnType CoeffReturnType;
+    typedef typename Base::ConstTransposeReturnType ConstTransposeReturnType;
+    typedef typename Base::RowXpr RowXpr;
+    typedef typename Base::ColXpr ColXpr;
+#endif // not EIGEN_PARSED_BY_DOXYGEN
+
+
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** type of the equivalent square matrix */
+    typedef Matrix<Scalar,EIGEN_SIZE_MAX(RowsAtCompileTime,ColsAtCompileTime),
+                          EIGEN_SIZE_MAX(RowsAtCompileTime,ColsAtCompileTime)> SquareMatrixType;
+#endif // not EIGEN_PARSED_BY_DOXYGEN
+
+    /** \returns the size of the main diagonal, which is min(rows(),cols()).
+      * \sa rows(), cols(), SizeAtCompileTime. */
+    EIGEN_DEVICE_FUNC
+    inline Index diagonalSize() const { return (numext::mini)(rows(),cols()); }
+
+    typedef typename Base::PlainObject PlainObject;
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** \internal Represents a matrix with all coefficients equal to one another*/
+    typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,PlainObject> ConstantReturnType;
+    /** \internal the return type of MatrixBase::adjoint() */
+    typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
+                        CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, ConstTransposeReturnType>,
+                        ConstTransposeReturnType
+                     >::type AdjointReturnType;
+    /** \internal Return type of eigenvalues() */
+    typedef Matrix<std::complex<RealScalar>, internal::traits<Derived>::ColsAtCompileTime, 1, ColMajor> EigenvaluesReturnType;
+    /** \internal the return type of identity */
+    typedef CwiseNullaryOp<internal::scalar_identity_op<Scalar>,PlainObject> IdentityReturnType;
+    /** \internal the return type of unit vectors */
+    typedef Block<const CwiseNullaryOp<internal::scalar_identity_op<Scalar>, SquareMatrixType>,
+                  internal::traits<Derived>::RowsAtCompileTime,
+                  internal::traits<Derived>::ColsAtCompileTime> BasisReturnType;
+#endif // not EIGEN_PARSED_BY_DOXYGEN
+
+#define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::MatrixBase
+#define EIGEN_DOC_UNARY_ADDONS(X,Y)
+#   include "../plugins/CommonCwiseBinaryOps.h"
+#   include "../plugins/MatrixCwiseUnaryOps.h"
+#   include "../plugins/MatrixCwiseBinaryOps.h"
+#   ifdef EIGEN_MATRIXBASE_PLUGIN
+#     include EIGEN_MATRIXBASE_PLUGIN
+#   endif
+#undef EIGEN_CURRENT_STORAGE_BASE_CLASS
+#undef EIGEN_DOC_UNARY_ADDONS
+
+    /** Special case of the template operator=, in order to prevent the compiler
+      * from generating a default operator= (issue hit with g++ 4.1)
+      */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator=(const MatrixBase& other);
+
+    // We cannot inherit here via Base::operator= since it is causing
+    // trouble with MSVC.
+
+    template <typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator=(const DenseBase<OtherDerived>& other);
+
+    template <typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    Derived& operator=(const EigenBase<OtherDerived>& other);
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    Derived& operator=(const ReturnByValue<OtherDerived>& other);
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator+=(const MatrixBase<OtherDerived>& other);
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator-=(const MatrixBase<OtherDerived>& other);
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    const Product<Derived,OtherDerived>
+    operator*(const MatrixBase<OtherDerived> &other) const;
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    const Product<Derived,OtherDerived,LazyProduct>
+    lazyProduct(const MatrixBase<OtherDerived> &other) const;
+
+    template<typename OtherDerived>
+    Derived& operator*=(const EigenBase<OtherDerived>& other);
+
+    template<typename OtherDerived>
+    void applyOnTheLeft(const EigenBase<OtherDerived>& other);
+
+    template<typename OtherDerived>
+    void applyOnTheRight(const EigenBase<OtherDerived>& other);
+
+    template<typename DiagonalDerived>
+    EIGEN_DEVICE_FUNC
+    const Product<Derived, DiagonalDerived, LazyProduct>
+    operator*(const DiagonalBase<DiagonalDerived> &diagonal) const;
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    typename ScalarBinaryOpTraits<typename internal::traits<Derived>::Scalar,typename internal::traits<OtherDerived>::Scalar>::ReturnType
+    dot(const MatrixBase<OtherDerived>& other) const;
+
+    EIGEN_DEVICE_FUNC RealScalar squaredNorm() const;
+    EIGEN_DEVICE_FUNC RealScalar norm() const;
+    RealScalar stableNorm() const;
+    RealScalar blueNorm() const;
+    RealScalar hypotNorm() const;
+    EIGEN_DEVICE_FUNC const PlainObject normalized() const;
+    EIGEN_DEVICE_FUNC const PlainObject stableNormalized() const;
+    EIGEN_DEVICE_FUNC void normalize();
+    EIGEN_DEVICE_FUNC void stableNormalize();
+
+    EIGEN_DEVICE_FUNC const AdjointReturnType adjoint() const;
+    EIGEN_DEVICE_FUNC void adjointInPlace();
+
+    typedef Diagonal<Derived> DiagonalReturnType;
+    EIGEN_DEVICE_FUNC
+    DiagonalReturnType diagonal();
+
+    typedef typename internal::add_const<Diagonal<const Derived> >::type ConstDiagonalReturnType;
+    EIGEN_DEVICE_FUNC
+    ConstDiagonalReturnType diagonal() const;
+
+    template<int Index> struct DiagonalIndexReturnType { typedef Diagonal<Derived,Index> Type; };
+    template<int Index> struct ConstDiagonalIndexReturnType { typedef const Diagonal<const Derived,Index> Type; };
+
+    template<int Index>
+    EIGEN_DEVICE_FUNC
+    typename DiagonalIndexReturnType<Index>::Type diagonal();
+
+    template<int Index>
+    EIGEN_DEVICE_FUNC
+    typename ConstDiagonalIndexReturnType<Index>::Type diagonal() const;
+
+    typedef Diagonal<Derived,DynamicIndex> DiagonalDynamicIndexReturnType;
+    typedef typename internal::add_const<Diagonal<const Derived,DynamicIndex> >::type ConstDiagonalDynamicIndexReturnType;
+
+    EIGEN_DEVICE_FUNC
+    DiagonalDynamicIndexReturnType diagonal(Index index);
+    EIGEN_DEVICE_FUNC
+    ConstDiagonalDynamicIndexReturnType diagonal(Index index) const;
+
+    template<unsigned int Mode> struct TriangularViewReturnType { typedef TriangularView<Derived, Mode> Type; };
+    template<unsigned int Mode> struct ConstTriangularViewReturnType { typedef const TriangularView<const Derived, Mode> Type; };
+
+    template<unsigned int Mode>
+    EIGEN_DEVICE_FUNC
+    typename TriangularViewReturnType<Mode>::Type triangularView();
+    template<unsigned int Mode>
+    EIGEN_DEVICE_FUNC
+    typename ConstTriangularViewReturnType<Mode>::Type triangularView() const;
+
+    template<unsigned int UpLo> struct SelfAdjointViewReturnType { typedef SelfAdjointView<Derived, UpLo> Type; };
+    template<unsigned int UpLo> struct ConstSelfAdjointViewReturnType { typedef const SelfAdjointView<const Derived, UpLo> Type; };
+
+    template<unsigned int UpLo>
+    EIGEN_DEVICE_FUNC
+    typename SelfAdjointViewReturnType<UpLo>::Type selfadjointView();
+    template<unsigned int UpLo>
+    EIGEN_DEVICE_FUNC
+    typename ConstSelfAdjointViewReturnType<UpLo>::Type selfadjointView() const;
+
+    const SparseView<Derived> sparseView(const Scalar& m_reference = Scalar(0),
+                                         const typename NumTraits<Scalar>::Real& m_epsilon = NumTraits<Scalar>::dummy_precision()) const;
+    EIGEN_DEVICE_FUNC static const IdentityReturnType Identity();
+    EIGEN_DEVICE_FUNC static const IdentityReturnType Identity(Index rows, Index cols);
+    EIGEN_DEVICE_FUNC static const BasisReturnType Unit(Index size, Index i);
+    EIGEN_DEVICE_FUNC static const BasisReturnType Unit(Index i);
+    EIGEN_DEVICE_FUNC static const BasisReturnType UnitX();
+    EIGEN_DEVICE_FUNC static const BasisReturnType UnitY();
+    EIGEN_DEVICE_FUNC static const BasisReturnType UnitZ();
+    EIGEN_DEVICE_FUNC static const BasisReturnType UnitW();
+
+    EIGEN_DEVICE_FUNC
+    const DiagonalWrapper<const Derived> asDiagonal() const;
+    const PermutationWrapper<const Derived> asPermutation() const;
+
+    EIGEN_DEVICE_FUNC
+    Derived& setIdentity();
+    EIGEN_DEVICE_FUNC
+    Derived& setIdentity(Index rows, Index cols);
+    EIGEN_DEVICE_FUNC Derived& setUnit(Index i);
+    EIGEN_DEVICE_FUNC Derived& setUnit(Index newSize, Index i);
+
+    bool isIdentity(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+    bool isDiagonal(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+
+    bool isUpperTriangular(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+    bool isLowerTriangular(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+
+    template<typename OtherDerived>
+    bool isOrthogonal(const MatrixBase<OtherDerived>& other,
+                      const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+    bool isUnitary(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+
+    /** \returns true if each coefficients of \c *this and \a other are all exactly equal.
+      * \warning When using floating point scalar values you probably should rather use a
+      *          fuzzy comparison such as isApprox()
+      * \sa isApprox(), operator!= */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC inline bool operator==(const MatrixBase<OtherDerived>& other) const
+    { return cwiseEqual(other).all(); }
+
+    /** \returns true if at least one pair of coefficients of \c *this and \a other are not exactly equal to each other.
+      * \warning When using floating point scalar values you probably should rather use a
+      *          fuzzy comparison such as isApprox()
+      * \sa isApprox(), operator== */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC inline bool operator!=(const MatrixBase<OtherDerived>& other) const
+    { return cwiseNotEqual(other).any(); }
+
+    NoAlias<Derived,Eigen::MatrixBase > EIGEN_DEVICE_FUNC noalias();
+
+    // TODO forceAlignedAccess is temporarily disabled
+    // Need to find a nicer workaround.
+    inline const Derived& forceAlignedAccess() const { return derived(); }
+    inline Derived& forceAlignedAccess() { return derived(); }
+    template<bool Enable> inline const Derived& forceAlignedAccessIf() const { return derived(); }
+    template<bool Enable> inline Derived& forceAlignedAccessIf() { return derived(); }
+
+    EIGEN_DEVICE_FUNC Scalar trace() const;
+
+    template<int p> EIGEN_DEVICE_FUNC RealScalar lpNorm() const;
+
+    EIGEN_DEVICE_FUNC MatrixBase<Derived>& matrix() { return *this; }
+    EIGEN_DEVICE_FUNC const MatrixBase<Derived>& matrix() const { return *this; }
+
+    /** \returns an \link Eigen::ArrayBase Array \endlink expression of this matrix
+      * \sa ArrayBase::matrix() */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ArrayWrapper<Derived> array() { return ArrayWrapper<Derived>(derived()); }
+    /** \returns a const \link Eigen::ArrayBase Array \endlink expression of this matrix
+      * \sa ArrayBase::matrix() */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const ArrayWrapper<const Derived> array() const { return ArrayWrapper<const Derived>(derived()); }
+
+/////////// LU module ///////////
+
+    inline const FullPivLU<PlainObject> fullPivLu() const;
+    inline const PartialPivLU<PlainObject> partialPivLu() const;
+
+    inline const PartialPivLU<PlainObject> lu() const;
+
+    inline const Inverse<Derived> inverse() const;
+
+    template<typename ResultType>
+    inline void computeInverseAndDetWithCheck(
+      ResultType& inverse,
+      typename ResultType::Scalar& determinant,
+      bool& invertible,
+      const RealScalar& absDeterminantThreshold = NumTraits<Scalar>::dummy_precision()
+    ) const;
+    template<typename ResultType>
+    inline void computeInverseWithCheck(
+      ResultType& inverse,
+      bool& invertible,
+      const RealScalar& absDeterminantThreshold = NumTraits<Scalar>::dummy_precision()
+    ) const;
+    Scalar determinant() const;
+
+/////////// Cholesky module ///////////
+
+    inline const LLT<PlainObject>  llt() const;
+    inline const LDLT<PlainObject> ldlt() const;
+
+/////////// QR module ///////////
+
+    inline const HouseholderQR<PlainObject> householderQr() const;
+    inline const ColPivHouseholderQR<PlainObject> colPivHouseholderQr() const;
+    inline const FullPivHouseholderQR<PlainObject> fullPivHouseholderQr() const;
+    inline const CompleteOrthogonalDecomposition<PlainObject> completeOrthogonalDecomposition() const;
+
+/////////// Eigenvalues module ///////////
+
+    inline EigenvaluesReturnType eigenvalues() const;
+    inline RealScalar operatorNorm() const;
+
+/////////// SVD module ///////////
+
+    inline JacobiSVD<PlainObject> jacobiSvd(unsigned int computationOptions = 0) const;
+    inline BDCSVD<PlainObject>    bdcSvd(unsigned int computationOptions = 0) const;
+
+/////////// Geometry module ///////////
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /// \internal helper struct to form the return type of the cross product
+    template<typename OtherDerived> struct cross_product_return_type {
+      typedef typename ScalarBinaryOpTraits<typename internal::traits<Derived>::Scalar,typename internal::traits<OtherDerived>::Scalar>::ReturnType Scalar;
+      typedef Matrix<Scalar,MatrixBase::RowsAtCompileTime,MatrixBase::ColsAtCompileTime> type;
+    };
+    #endif // EIGEN_PARSED_BY_DOXYGEN
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    inline typename cross_product_return_type<OtherDerived>::type
+#else
+    inline PlainObject
+#endif
+    cross(const MatrixBase<OtherDerived>& other) const;
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    inline PlainObject cross3(const MatrixBase<OtherDerived>& other) const;
+
+    EIGEN_DEVICE_FUNC
+    inline PlainObject unitOrthogonal(void) const;
+
+    EIGEN_DEVICE_FUNC
+    inline Matrix<Scalar,3,1> eulerAngles(Index a0, Index a1, Index a2) const;
+
+    // put this as separate enum value to work around possible GCC 4.3 bug (?)
+    enum { HomogeneousReturnTypeDirection = ColsAtCompileTime==1&&RowsAtCompileTime==1 ? ((internal::traits<Derived>::Flags&RowMajorBit)==RowMajorBit ? Horizontal : Vertical)
+                                          : ColsAtCompileTime==1 ? Vertical : Horizontal };
+    typedef Homogeneous<Derived, HomogeneousReturnTypeDirection> HomogeneousReturnType;
+    EIGEN_DEVICE_FUNC
+    inline HomogeneousReturnType homogeneous() const;
+
+    enum {
+      SizeMinusOne = SizeAtCompileTime==Dynamic ? Dynamic : SizeAtCompileTime-1
+    };
+    typedef Block<const Derived,
+                  internal::traits<Derived>::ColsAtCompileTime==1 ? SizeMinusOne : 1,
+                  internal::traits<Derived>::ColsAtCompileTime==1 ? 1 : SizeMinusOne> ConstStartMinusOne;
+    typedef EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(ConstStartMinusOne,Scalar,quotient) HNormalizedReturnType;
+    EIGEN_DEVICE_FUNC
+    inline const HNormalizedReturnType hnormalized() const;
+
+////////// Householder module ///////////
+
+    void makeHouseholderInPlace(Scalar& tau, RealScalar& beta);
+    template<typename EssentialPart>
+    void makeHouseholder(EssentialPart& essential,
+                         Scalar& tau, RealScalar& beta) const;
+    template<typename EssentialPart>
+    void applyHouseholderOnTheLeft(const EssentialPart& essential,
+                                   const Scalar& tau,
+                                   Scalar* workspace);
+    template<typename EssentialPart>
+    void applyHouseholderOnTheRight(const EssentialPart& essential,
+                                    const Scalar& tau,
+                                    Scalar* workspace);
+
+///////// Jacobi module /////////
+
+    template<typename OtherScalar>
+    EIGEN_DEVICE_FUNC
+    void applyOnTheLeft(Index p, Index q, const JacobiRotation<OtherScalar>& j);
+    template<typename OtherScalar>
+    EIGEN_DEVICE_FUNC
+    void applyOnTheRight(Index p, Index q, const JacobiRotation<OtherScalar>& j);
+
+///////// SparseCore module /////////
+
+    template<typename OtherDerived>
+    EIGEN_STRONG_INLINE const typename SparseMatrixBase<OtherDerived>::template CwiseProductDenseReturnType<Derived>::Type
+    cwiseProduct(const SparseMatrixBase<OtherDerived> &other) const
+    {
+      return other.cwiseProduct(derived());
+    }
+
+///////// MatrixFunctions module /////////
+
+    typedef typename internal::stem_function<Scalar>::type StemFunction;
+    const MatrixExponentialReturnValue<Derived> exp() const;
+    const MatrixFunctionReturnValue<Derived> matrixFunction(StemFunction f) const;
+    const MatrixFunctionReturnValue<Derived> cosh() const;
+    const MatrixFunctionReturnValue<Derived> sinh() const;
+    const MatrixFunctionReturnValue<Derived> cos() const;
+    const MatrixFunctionReturnValue<Derived> sin() const;
+    const MatrixSquareRootReturnValue<Derived> sqrt() const;
+    const MatrixLogarithmReturnValue<Derived> log() const;
+    const MatrixPowerReturnValue<Derived> pow(const RealScalar& p) const;
+    const MatrixComplexPowerReturnValue<Derived> pow(const std::complex<RealScalar>& p) const;
+
+  protected:
+    EIGEN_DEVICE_FUNC MatrixBase() : Base() {}
+
+  private:
+    EIGEN_DEVICE_FUNC explicit MatrixBase(int);
+    EIGEN_DEVICE_FUNC MatrixBase(int,int);
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC explicit MatrixBase(const MatrixBase<OtherDerived>&);
+  protected:
+    // mixing arrays and matrices is not legal
+    template<typename OtherDerived> Derived& operator+=(const ArrayBase<OtherDerived>& )
+    {EIGEN_STATIC_ASSERT(std::ptrdiff_t(sizeof(typename OtherDerived::Scalar))==-1,YOU_CANNOT_MIX_ARRAYS_AND_MATRICES); return *this;}
+    // mixing arrays and matrices is not legal
+    template<typename OtherDerived> Derived& operator-=(const ArrayBase<OtherDerived>& )
+    {EIGEN_STATIC_ASSERT(std::ptrdiff_t(sizeof(typename OtherDerived::Scalar))==-1,YOU_CANNOT_MIX_ARRAYS_AND_MATRICES); return *this;}
+};
+
+
+/***************************************************************************
+* Implementation of matrix base methods
+***************************************************************************/
+
+/** replaces \c *this by \c *this * \a other.
+  *
+  * \returns a reference to \c *this
+  *
+  * Example: \include MatrixBase_applyOnTheRight.cpp
+  * Output: \verbinclude MatrixBase_applyOnTheRight.out
+  */
+template<typename Derived>
+template<typename OtherDerived>
+inline Derived&
+MatrixBase<Derived>::operator*=(const EigenBase<OtherDerived> &other)
+{
+  other.derived().applyThisOnTheRight(derived());
+  return derived();
+}
+
+/** replaces \c *this by \c *this * \a other. It is equivalent to MatrixBase::operator*=().
+  *
+  * Example: \include MatrixBase_applyOnTheRight.cpp
+  * Output: \verbinclude MatrixBase_applyOnTheRight.out
+  */
+template<typename Derived>
+template<typename OtherDerived>
+inline void MatrixBase<Derived>::applyOnTheRight(const EigenBase<OtherDerived> &other)
+{
+  other.derived().applyThisOnTheRight(derived());
+}
+
+/** replaces \c *this by \a other * \c *this.
+  *
+  * Example: \include MatrixBase_applyOnTheLeft.cpp
+  * Output: \verbinclude MatrixBase_applyOnTheLeft.out
+  */
+template<typename Derived>
+template<typename OtherDerived>
+inline void MatrixBase<Derived>::applyOnTheLeft(const EigenBase<OtherDerived> &other)
+{
+  other.derived().applyThisOnTheLeft(derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_MATRIXBASE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/NestByValue.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/NestByValue.h
new file mode 100644
index 00000000..01cf192e
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/NestByValue.h
@@ -0,0 +1,110 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_NESTBYVALUE_H
+#define EIGEN_NESTBYVALUE_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename ExpressionType>
+struct traits<NestByValue<ExpressionType> > : public traits<ExpressionType>
+{};
+}
+
+/** \class NestByValue
+  * \ingroup Core_Module
+  *
+  * \brief Expression which must be nested by value
+  *
+  * \tparam ExpressionType the type of the object of which we are requiring nesting-by-value
+  *
+  * This class is the return type of MatrixBase::nestByValue()
+  * and most of the time this is the only way it is used.
+  *
+  * \sa MatrixBase::nestByValue()
+  */
+template<typename ExpressionType> class NestByValue
+  : public internal::dense_xpr_base< NestByValue<ExpressionType> >::type
+{
+  public:
+
+    typedef typename internal::dense_xpr_base<NestByValue>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(NestByValue)
+
+    EIGEN_DEVICE_FUNC explicit inline NestByValue(const ExpressionType& matrix) : m_expression(matrix) {}
+
+    EIGEN_DEVICE_FUNC inline Index rows() const { return m_expression.rows(); }
+    EIGEN_DEVICE_FUNC inline Index cols() const { return m_expression.cols(); }
+    EIGEN_DEVICE_FUNC inline Index outerStride() const { return m_expression.outerStride(); }
+    EIGEN_DEVICE_FUNC inline Index innerStride() const { return m_expression.innerStride(); }
+
+    EIGEN_DEVICE_FUNC inline const CoeffReturnType coeff(Index row, Index col) const
+    {
+      return m_expression.coeff(row, col);
+    }
+
+    EIGEN_DEVICE_FUNC inline Scalar& coeffRef(Index row, Index col)
+    {
+      return m_expression.const_cast_derived().coeffRef(row, col);
+    }
+
+    EIGEN_DEVICE_FUNC inline const CoeffReturnType coeff(Index index) const
+    {
+      return m_expression.coeff(index);
+    }
+
+    EIGEN_DEVICE_FUNC inline Scalar& coeffRef(Index index)
+    {
+      return m_expression.const_cast_derived().coeffRef(index);
+    }
+
+    template<int LoadMode>
+    EIGEN_DEVICE_FUNC inline const PacketScalar packet(Index row, Index col) const
+    {
+      return m_expression.template packet<LoadMode>(row, col);
+    }
+
+    template<int LoadMode>
+    EIGEN_DEVICE_FUNC inline void writePacket(Index row, Index col, const PacketScalar& x)
+    {
+      m_expression.const_cast_derived().template writePacket<LoadMode>(row, col, x);
+    }
+
+    template<int LoadMode>
+    EIGEN_DEVICE_FUNC inline const PacketScalar packet(Index index) const
+    {
+      return m_expression.template packet<LoadMode>(index);
+    }
+
+    template<int LoadMode>
+    EIGEN_DEVICE_FUNC inline void writePacket(Index index, const PacketScalar& x)
+    {
+      m_expression.const_cast_derived().template writePacket<LoadMode>(index, x);
+    }
+
+    EIGEN_DEVICE_FUNC operator const ExpressionType&() const { return m_expression; }
+
+  protected:
+    const ExpressionType m_expression;
+};
+
+/** \returns an expression of the temporary version of *this.
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline const NestByValue<Derived>
+DenseBase<Derived>::nestByValue() const
+{
+  return NestByValue<Derived>(derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_NESTBYVALUE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/NoAlias.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/NoAlias.h
new file mode 100644
index 00000000..e94c8ee9
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/NoAlias.h
@@ -0,0 +1,109 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_NOALIAS_H
+#define EIGEN_NOALIAS_H
+
+namespace Eigen {
+
+/** \class NoAlias
+  * \ingroup Core_Module
+  *
+  * \brief Pseudo expression providing an operator = assuming no aliasing
+  *
+  * \tparam ExpressionType the type of the object on which to do the lazy assignment
+  *
+  * This class represents an expression with special assignment operators
+  * assuming no aliasing between the target expression and the source expression.
+  * More precisely it alloas to bypass the EvalBeforeAssignBit flag of the source expression.
+  * It is the return type of MatrixBase::noalias()
+  * and most of the time this is the only way it is used.
+  *
+  * \sa MatrixBase::noalias()
+  */
+template<typename ExpressionType, template <typename> class StorageBase>
+class NoAlias
+{
+  public:
+    typedef typename ExpressionType::Scalar Scalar;
+    
+    EIGEN_DEVICE_FUNC
+    explicit NoAlias(ExpressionType& expression) : m_expression(expression) {}
+    
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE ExpressionType& operator=(const StorageBase<OtherDerived>& other)
+    {
+      call_assignment_no_alias(m_expression, other.derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
+      return m_expression;
+    }
+    
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE ExpressionType& operator+=(const StorageBase<OtherDerived>& other)
+    {
+      call_assignment_no_alias(m_expression, other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
+      return m_expression;
+    }
+    
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE ExpressionType& operator-=(const StorageBase<OtherDerived>& other)
+    {
+      call_assignment_no_alias(m_expression, other.derived(), internal::sub_assign_op<Scalar,typename OtherDerived::Scalar>());
+      return m_expression;
+    }
+
+    EIGEN_DEVICE_FUNC
+    ExpressionType& expression() const
+    {
+      return m_expression;
+    }
+
+  protected:
+    ExpressionType& m_expression;
+};
+
+/** \returns a pseudo expression of \c *this with an operator= assuming
+  * no aliasing between \c *this and the source expression.
+  *
+  * More precisely, noalias() allows to bypass the EvalBeforeAssignBit flag.
+  * Currently, even though several expressions may alias, only product
+  * expressions have this flag. Therefore, noalias() is only usefull when
+  * the source expression contains a matrix product.
+  *
+  * Here are some examples where noalias is usefull:
+  * \code
+  * D.noalias()  = A * B;
+  * D.noalias() += A.transpose() * B;
+  * D.noalias() -= 2 * A * B.adjoint();
+  * \endcode
+  *
+  * On the other hand the following example will lead to a \b wrong result:
+  * \code
+  * A.noalias() = A * B;
+  * \endcode
+  * because the result matrix A is also an operand of the matrix product. Therefore,
+  * there is no alternative than evaluating A * B in a temporary, that is the default
+  * behavior when you write:
+  * \code
+  * A = A * B;
+  * \endcode
+  *
+  * \sa class NoAlias
+  */
+template<typename Derived>
+NoAlias<Derived,MatrixBase> EIGEN_DEVICE_FUNC MatrixBase<Derived>::noalias()
+{
+  return NoAlias<Derived, Eigen::MatrixBase >(derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_NOALIAS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/NumTraits.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/NumTraits.h
new file mode 100644
index 00000000..92a9ae1e
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/NumTraits.h
@@ -0,0 +1,248 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_NUMTRAITS_H
+#define EIGEN_NUMTRAITS_H
+
+namespace Eigen {
+
+namespace internal {
+
+// default implementation of digits10(), based on numeric_limits if specialized,
+// 0 for integer types, and log10(epsilon()) otherwise.
+template< typename T,
+          bool use_numeric_limits = std::numeric_limits<T>::is_specialized,
+          bool is_integer = NumTraits<T>::IsInteger>
+struct default_digits10_impl
+{
+  static int run() { return std::numeric_limits<T>::digits10; }
+};
+
+template<typename T>
+struct default_digits10_impl<T,false,false> // Floating point
+{
+  static int run() {
+    using std::log10;
+    using std::ceil;
+    typedef typename NumTraits<T>::Real Real;
+    return int(ceil(-log10(NumTraits<Real>::epsilon())));
+  }
+};
+
+template<typename T>
+struct default_digits10_impl<T,false,true> // Integer
+{
+  static int run() { return 0; }
+};
+
+} // end namespace internal
+
+/** \class NumTraits
+  * \ingroup Core_Module
+  *
+  * \brief Holds information about the various numeric (i.e. scalar) types allowed by Eigen.
+  *
+  * \tparam T the numeric type at hand
+  *
+  * This class stores enums, typedefs and static methods giving information about a numeric type.
+  *
+  * The provided data consists of:
+  * \li A typedef \c Real, giving the "real part" type of \a T. If \a T is already real,
+  *     then \c Real is just a typedef to \a T. If \a T is \c std::complex<U> then \c Real
+  *     is a typedef to \a U.
+  * \li A typedef \c NonInteger, giving the type that should be used for operations producing non-integral values,
+  *     such as quotients, square roots, etc. If \a T is a floating-point type, then this typedef just gives
+  *     \a T again. Note however that many Eigen functions such as internal::sqrt simply refuse to
+  *     take integers. Outside of a few cases, Eigen doesn't do automatic type promotion. Thus, this typedef is
+  *     only intended as a helper for code that needs to explicitly promote types.
+  * \li A typedef \c Literal giving the type to use for numeric literals such as "2" or "0.5". For instance, for \c std::complex<U>, Literal is defined as \c U.
+  *     Of course, this type must be fully compatible with \a T. In doubt, just use \a T here.
+  * \li A typedef \a Nested giving the type to use to nest a value inside of the expression tree. If you don't know what
+  *     this means, just use \a T here.
+  * \li An enum value \a IsComplex. It is equal to 1 if \a T is a \c std::complex
+  *     type, and to 0 otherwise.
+  * \li An enum value \a IsInteger. It is equal to \c 1 if \a T is an integer type such as \c int,
+  *     and to \c 0 otherwise.
+  * \li Enum values ReadCost, AddCost and MulCost representing a rough estimate of the number of CPU cycles needed
+  *     to by move / add / mul instructions respectively, assuming the data is already stored in CPU registers.
+  *     Stay vague here. No need to do architecture-specific stuff. If you don't know what this means, just use \c Eigen::HugeCost.
+  * \li An enum value \a IsSigned. It is equal to \c 1 if \a T is a signed type and to 0 if \a T is unsigned.
+  * \li An enum value \a RequireInitialization. It is equal to \c 1 if the constructor of the numeric type \a T must
+  *     be called, and to 0 if it is safe not to call it. Default is 0 if \a T is an arithmetic type, and 1 otherwise.
+  * \li An epsilon() function which, unlike <a href="http://en.cppreference.com/w/cpp/types/numeric_limits/epsilon">std::numeric_limits::epsilon()</a>,
+  *     it returns a \a Real instead of a \a T.
+  * \li A dummy_precision() function returning a weak epsilon value. It is mainly used as a default
+  *     value by the fuzzy comparison operators.
+  * \li highest() and lowest() functions returning the highest and lowest possible values respectively.
+  * \li digits10() function returning the number of decimal digits that can be represented without change. This is
+  *     the analogue of <a href="http://en.cppreference.com/w/cpp/types/numeric_limits/digits10">std::numeric_limits<T>::digits10</a>
+  *     which is used as the default implementation if specialized.
+  */
+
+template<typename T> struct GenericNumTraits
+{
+  enum {
+    IsInteger = std::numeric_limits<T>::is_integer,
+    IsSigned = std::numeric_limits<T>::is_signed,
+    IsComplex = 0,
+    RequireInitialization = internal::is_arithmetic<T>::value ? 0 : 1,
+    ReadCost = 1,
+    AddCost = 1,
+    MulCost = 1
+  };
+
+  typedef T Real;
+  typedef typename internal::conditional<
+                     IsInteger,
+                     typename internal::conditional<sizeof(T)<=2, float, double>::type,
+                     T
+                   >::type NonInteger;
+  typedef T Nested;
+  typedef T Literal;
+
+  EIGEN_DEVICE_FUNC
+  static inline Real epsilon()
+  {
+    return numext::numeric_limits<T>::epsilon();
+  }
+
+  EIGEN_DEVICE_FUNC
+  static inline int digits10()
+  {
+    return internal::default_digits10_impl<T>::run();
+  }
+
+  EIGEN_DEVICE_FUNC
+  static inline Real dummy_precision()
+  {
+    // make sure to override this for floating-point types
+    return Real(0);
+  }
+
+
+  EIGEN_DEVICE_FUNC
+  static inline T highest() {
+    return (numext::numeric_limits<T>::max)();
+  }
+
+  EIGEN_DEVICE_FUNC
+  static inline T lowest()  {
+    return IsInteger ? (numext::numeric_limits<T>::min)() : (-(numext::numeric_limits<T>::max)());
+  }
+
+  EIGEN_DEVICE_FUNC
+  static inline T infinity() {
+    return numext::numeric_limits<T>::infinity();
+  }
+
+  EIGEN_DEVICE_FUNC
+  static inline T quiet_NaN() {
+    return numext::numeric_limits<T>::quiet_NaN();
+  }
+};
+
+template<typename T> struct NumTraits : GenericNumTraits<T>
+{};
+
+template<> struct NumTraits<float>
+  : GenericNumTraits<float>
+{
+  EIGEN_DEVICE_FUNC
+  static inline float dummy_precision() { return 1e-5f; }
+};
+
+template<> struct NumTraits<double> : GenericNumTraits<double>
+{
+  EIGEN_DEVICE_FUNC
+  static inline double dummy_precision() { return 1e-12; }
+};
+
+template<> struct NumTraits<long double>
+  : GenericNumTraits<long double>
+{
+  static inline long double dummy_precision() { return 1e-15l; }
+};
+
+template<typename _Real> struct NumTraits<std::complex<_Real> >
+  : GenericNumTraits<std::complex<_Real> >
+{
+  typedef _Real Real;
+  typedef typename NumTraits<_Real>::Literal Literal;
+  enum {
+    IsComplex = 1,
+    RequireInitialization = NumTraits<_Real>::RequireInitialization,
+    ReadCost = 2 * NumTraits<_Real>::ReadCost,
+    AddCost = 2 * NumTraits<Real>::AddCost,
+    MulCost = 4 * NumTraits<Real>::MulCost + 2 * NumTraits<Real>::AddCost
+  };
+
+  EIGEN_DEVICE_FUNC
+  static inline Real epsilon() { return NumTraits<Real>::epsilon(); }
+  EIGEN_DEVICE_FUNC
+  static inline Real dummy_precision() { return NumTraits<Real>::dummy_precision(); }
+  EIGEN_DEVICE_FUNC
+  static inline int digits10() { return NumTraits<Real>::digits10(); }
+};
+
+template<typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
+struct NumTraits<Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols> >
+{
+  typedef Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols> ArrayType;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Array<RealScalar, Rows, Cols, Options, MaxRows, MaxCols> Real;
+  typedef typename NumTraits<Scalar>::NonInteger NonIntegerScalar;
+  typedef Array<NonIntegerScalar, Rows, Cols, Options, MaxRows, MaxCols> NonInteger;
+  typedef ArrayType & Nested;
+  typedef typename NumTraits<Scalar>::Literal Literal;
+
+  enum {
+    IsComplex = NumTraits<Scalar>::IsComplex,
+    IsInteger = NumTraits<Scalar>::IsInteger,
+    IsSigned  = NumTraits<Scalar>::IsSigned,
+    RequireInitialization = 1,
+    ReadCost = ArrayType::SizeAtCompileTime==Dynamic ? HugeCost : ArrayType::SizeAtCompileTime * NumTraits<Scalar>::ReadCost,
+    AddCost  = ArrayType::SizeAtCompileTime==Dynamic ? HugeCost : ArrayType::SizeAtCompileTime * NumTraits<Scalar>::AddCost,
+    MulCost  = ArrayType::SizeAtCompileTime==Dynamic ? HugeCost : ArrayType::SizeAtCompileTime * NumTraits<Scalar>::MulCost
+  };
+
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar epsilon() { return NumTraits<RealScalar>::epsilon(); }
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar dummy_precision() { return NumTraits<RealScalar>::dummy_precision(); }
+
+  static inline int digits10() { return NumTraits<Scalar>::digits10(); }
+};
+
+template<> struct NumTraits<std::string>
+  : GenericNumTraits<std::string>
+{
+  enum {
+    RequireInitialization = 1,
+    ReadCost = HugeCost,
+    AddCost  = HugeCost,
+    MulCost  = HugeCost
+  };
+
+  static inline int digits10() { return 0; }
+
+private:
+  static inline std::string epsilon();
+  static inline std::string dummy_precision();
+  static inline std::string lowest();
+  static inline std::string highest();
+  static inline std::string infinity();
+  static inline std::string quiet_NaN();
+};
+
+// Empty specialization for void to allow template specialization based on NumTraits<T>::Real with T==void and SFINAE.
+template<> struct NumTraits<void> {};
+
+} // end namespace Eigen
+
+#endif // EIGEN_NUMTRAITS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/PermutationMatrix.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/PermutationMatrix.h
new file mode 100644
index 00000000..b1fb455b
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/PermutationMatrix.h
@@ -0,0 +1,633 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2009-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PERMUTATIONMATRIX_H
+#define EIGEN_PERMUTATIONMATRIX_H
+
+namespace Eigen { 
+
+namespace internal {
+
+enum PermPermProduct_t {PermPermProduct};
+
+} // end namespace internal
+
+/** \class PermutationBase
+  * \ingroup Core_Module
+  *
+  * \brief Base class for permutations
+  *
+  * \tparam Derived the derived class
+  *
+  * This class is the base class for all expressions representing a permutation matrix,
+  * internally stored as a vector of integers.
+  * The convention followed here is that if \f$ \sigma \f$ is a permutation, the corresponding permutation matrix
+  * \f$ P_\sigma \f$ is such that if \f$ (e_1,\ldots,e_p) \f$ is the canonical basis, we have:
+  *  \f[ P_\sigma(e_i) = e_{\sigma(i)}. \f]
+  * This convention ensures that for any two permutations \f$ \sigma, \tau \f$, we have:
+  *  \f[ P_{\sigma\circ\tau} = P_\sigma P_\tau. \f]
+  *
+  * Permutation matrices are square and invertible.
+  *
+  * Notice that in addition to the member functions and operators listed here, there also are non-member
+  * operator* to multiply any kind of permutation object with any kind of matrix expression (MatrixBase)
+  * on either side.
+  *
+  * \sa class PermutationMatrix, class PermutationWrapper
+  */
+template<typename Derived>
+class PermutationBase : public EigenBase<Derived>
+{
+    typedef internal::traits<Derived> Traits;
+    typedef EigenBase<Derived> Base;
+  public:
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    typedef typename Traits::IndicesType IndicesType;
+    enum {
+      Flags = Traits::Flags,
+      RowsAtCompileTime = Traits::RowsAtCompileTime,
+      ColsAtCompileTime = Traits::ColsAtCompileTime,
+      MaxRowsAtCompileTime = Traits::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = Traits::MaxColsAtCompileTime
+    };
+    typedef typename Traits::StorageIndex StorageIndex;
+    typedef Matrix<StorageIndex,RowsAtCompileTime,ColsAtCompileTime,0,MaxRowsAtCompileTime,MaxColsAtCompileTime>
+            DenseMatrixType;
+    typedef PermutationMatrix<IndicesType::SizeAtCompileTime,IndicesType::MaxSizeAtCompileTime,StorageIndex>
+            PlainPermutationType;
+    typedef PlainPermutationType PlainObject;
+    using Base::derived;
+    typedef Inverse<Derived> InverseReturnType;
+    typedef void Scalar;
+    #endif
+
+    /** Copies the other permutation into *this */
+    template<typename OtherDerived>
+    Derived& operator=(const PermutationBase<OtherDerived>& other)
+    {
+      indices() = other.indices();
+      return derived();
+    }
+
+    /** Assignment from the Transpositions \a tr */
+    template<typename OtherDerived>
+    Derived& operator=(const TranspositionsBase<OtherDerived>& tr)
+    {
+      setIdentity(tr.size());
+      for(Index k=size()-1; k>=0; --k)
+        applyTranspositionOnTheRight(k,tr.coeff(k));
+      return derived();
+    }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** This is a special case of the templated operator=. Its purpose is to
+      * prevent a default operator= from hiding the templated operator=.
+      */
+    Derived& operator=(const PermutationBase& other)
+    {
+      indices() = other.indices();
+      return derived();
+    }
+    #endif
+
+    /** \returns the number of rows */
+    inline Index rows() const { return Index(indices().size()); }
+
+    /** \returns the number of columns */
+    inline Index cols() const { return Index(indices().size()); }
+
+    /** \returns the size of a side of the respective square matrix, i.e., the number of indices */
+    inline Index size() const { return Index(indices().size()); }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename DenseDerived>
+    void evalTo(MatrixBase<DenseDerived>& other) const
+    {
+      other.setZero();
+      for (Index i=0; i<rows(); ++i)
+        other.coeffRef(indices().coeff(i),i) = typename DenseDerived::Scalar(1);
+    }
+    #endif
+
+    /** \returns a Matrix object initialized from this permutation matrix. Notice that it
+      * is inefficient to return this Matrix object by value. For efficiency, favor using
+      * the Matrix constructor taking EigenBase objects.
+      */
+    DenseMatrixType toDenseMatrix() const
+    {
+      return derived();
+    }
+
+    /** const version of indices(). */
+    const IndicesType& indices() const { return derived().indices(); }
+    /** \returns a reference to the stored array representing the permutation. */
+    IndicesType& indices() { return derived().indices(); }
+
+    /** Resizes to given size.
+      */
+    inline void resize(Index newSize)
+    {
+      indices().resize(newSize);
+    }
+
+    /** Sets *this to be the identity permutation matrix */
+    void setIdentity()
+    {
+      StorageIndex n = StorageIndex(size());
+      for(StorageIndex i = 0; i < n; ++i)
+        indices().coeffRef(i) = i;
+    }
+
+    /** Sets *this to be the identity permutation matrix of given size.
+      */
+    void setIdentity(Index newSize)
+    {
+      resize(newSize);
+      setIdentity();
+    }
+
+    /** Multiplies *this by the transposition \f$(ij)\f$ on the left.
+      *
+      * \returns a reference to *this.
+      *
+      * \warning This is much slower than applyTranspositionOnTheRight(Index,Index):
+      * this has linear complexity and requires a lot of branching.
+      *
+      * \sa applyTranspositionOnTheRight(Index,Index)
+      */
+    Derived& applyTranspositionOnTheLeft(Index i, Index j)
+    {
+      eigen_assert(i>=0 && j>=0 && i<size() && j<size());
+      for(Index k = 0; k < size(); ++k)
+      {
+        if(indices().coeff(k) == i) indices().coeffRef(k) = StorageIndex(j);
+        else if(indices().coeff(k) == j) indices().coeffRef(k) = StorageIndex(i);
+      }
+      return derived();
+    }
+
+    /** Multiplies *this by the transposition \f$(ij)\f$ on the right.
+      *
+      * \returns a reference to *this.
+      *
+      * This is a fast operation, it only consists in swapping two indices.
+      *
+      * \sa applyTranspositionOnTheLeft(Index,Index)
+      */
+    Derived& applyTranspositionOnTheRight(Index i, Index j)
+    {
+      eigen_assert(i>=0 && j>=0 && i<size() && j<size());
+      std::swap(indices().coeffRef(i), indices().coeffRef(j));
+      return derived();
+    }
+
+    /** \returns the inverse permutation matrix.
+      *
+      * \note \blank \note_try_to_help_rvo
+      */
+    inline InverseReturnType inverse() const
+    { return InverseReturnType(derived()); }
+    /** \returns the tranpose permutation matrix.
+      *
+      * \note \blank \note_try_to_help_rvo
+      */
+    inline InverseReturnType transpose() const
+    { return InverseReturnType(derived()); }
+
+    /**** multiplication helpers to hopefully get RVO ****/
+
+  
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+  protected:
+    template<typename OtherDerived>
+    void assignTranspose(const PermutationBase<OtherDerived>& other)
+    {
+      for (Index i=0; i<rows();++i) indices().coeffRef(other.indices().coeff(i)) = i;
+    }
+    template<typename Lhs,typename Rhs>
+    void assignProduct(const Lhs& lhs, const Rhs& rhs)
+    {
+      eigen_assert(lhs.cols() == rhs.rows());
+      for (Index i=0; i<rows();++i) indices().coeffRef(i) = lhs.indices().coeff(rhs.indices().coeff(i));
+    }
+#endif
+
+  public:
+
+    /** \returns the product permutation matrix.
+      *
+      * \note \blank \note_try_to_help_rvo
+      */
+    template<typename Other>
+    inline PlainPermutationType operator*(const PermutationBase<Other>& other) const
+    { return PlainPermutationType(internal::PermPermProduct, derived(), other.derived()); }
+
+    /** \returns the product of a permutation with another inverse permutation.
+      *
+      * \note \blank \note_try_to_help_rvo
+      */
+    template<typename Other>
+    inline PlainPermutationType operator*(const InverseImpl<Other,PermutationStorage>& other) const
+    { return PlainPermutationType(internal::PermPermProduct, *this, other.eval()); }
+
+    /** \returns the product of an inverse permutation with another permutation.
+      *
+      * \note \blank \note_try_to_help_rvo
+      */
+    template<typename Other> friend
+    inline PlainPermutationType operator*(const InverseImpl<Other, PermutationStorage>& other, const PermutationBase& perm)
+    { return PlainPermutationType(internal::PermPermProduct, other.eval(), perm); }
+    
+    /** \returns the determinant of the permutation matrix, which is either 1 or -1 depending on the parity of the permutation.
+      *
+      * This function is O(\c n) procedure allocating a buffer of \c n booleans.
+      */
+    Index determinant() const
+    {
+      Index res = 1;
+      Index n = size();
+      Matrix<bool,RowsAtCompileTime,1,0,MaxRowsAtCompileTime> mask(n);
+      mask.fill(false);
+      Index r = 0;
+      while(r < n)
+      {
+        // search for the next seed
+        while(r<n && mask[r]) r++;
+        if(r>=n)
+          break;
+        // we got one, let's follow it until we are back to the seed
+        Index k0 = r++;
+        mask.coeffRef(k0) = true;
+        for(Index k=indices().coeff(k0); k!=k0; k=indices().coeff(k))
+        {
+          mask.coeffRef(k) = true;
+          res = -res;
+        }
+      }
+      return res;
+    }
+
+  protected:
+
+};
+
+namespace internal {
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime, typename _StorageIndex>
+struct traits<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex> >
+ : traits<Matrix<_StorageIndex,SizeAtCompileTime,SizeAtCompileTime,0,MaxSizeAtCompileTime,MaxSizeAtCompileTime> >
+{
+  typedef PermutationStorage StorageKind;
+  typedef Matrix<_StorageIndex, SizeAtCompileTime, 1, 0, MaxSizeAtCompileTime, 1> IndicesType;
+  typedef _StorageIndex StorageIndex;
+  typedef void Scalar;
+};
+}
+
+/** \class PermutationMatrix
+  * \ingroup Core_Module
+  *
+  * \brief Permutation matrix
+  *
+  * \tparam SizeAtCompileTime the number of rows/cols, or Dynamic
+  * \tparam MaxSizeAtCompileTime the maximum number of rows/cols, or Dynamic. This optional parameter defaults to SizeAtCompileTime. Most of the time, you should not have to specify it.
+  * \tparam _StorageIndex the integer type of the indices
+  *
+  * This class represents a permutation matrix, internally stored as a vector of integers.
+  *
+  * \sa class PermutationBase, class PermutationWrapper, class DiagonalMatrix
+  */
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime, typename _StorageIndex>
+class PermutationMatrix : public PermutationBase<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex> >
+{
+    typedef PermutationBase<PermutationMatrix> Base;
+    typedef internal::traits<PermutationMatrix> Traits;
+  public:
+
+    typedef const PermutationMatrix& Nested;
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    typedef typename Traits::IndicesType IndicesType;
+    typedef typename Traits::StorageIndex StorageIndex;
+    #endif
+
+    inline PermutationMatrix()
+    {}
+
+    /** Constructs an uninitialized permutation matrix of given size.
+      */
+    explicit inline PermutationMatrix(Index size) : m_indices(size)
+    {
+      eigen_internal_assert(size <= NumTraits<StorageIndex>::highest());
+    }
+
+    /** Copy constructor. */
+    template<typename OtherDerived>
+    inline PermutationMatrix(const PermutationBase<OtherDerived>& other)
+      : m_indices(other.indices()) {}
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** Standard copy constructor. Defined only to prevent a default copy constructor
+      * from hiding the other templated constructor */
+    inline PermutationMatrix(const PermutationMatrix& other) : m_indices(other.indices()) {}
+    #endif
+
+    /** Generic constructor from expression of the indices. The indices
+      * array has the meaning that the permutations sends each integer i to indices[i].
+      *
+      * \warning It is your responsibility to check that the indices array that you passes actually
+      * describes a permutation, i.e., each value between 0 and n-1 occurs exactly once, where n is the
+      * array's size.
+      */
+    template<typename Other>
+    explicit inline PermutationMatrix(const MatrixBase<Other>& indices) : m_indices(indices)
+    {}
+
+    /** Convert the Transpositions \a tr to a permutation matrix */
+    template<typename Other>
+    explicit PermutationMatrix(const TranspositionsBase<Other>& tr)
+      : m_indices(tr.size())
+    {
+      *this = tr;
+    }
+
+    /** Copies the other permutation into *this */
+    template<typename Other>
+    PermutationMatrix& operator=(const PermutationBase<Other>& other)
+    {
+      m_indices = other.indices();
+      return *this;
+    }
+
+    /** Assignment from the Transpositions \a tr */
+    template<typename Other>
+    PermutationMatrix& operator=(const TranspositionsBase<Other>& tr)
+    {
+      return Base::operator=(tr.derived());
+    }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** This is a special case of the templated operator=. Its purpose is to
+      * prevent a default operator= from hiding the templated operator=.
+      */
+    PermutationMatrix& operator=(const PermutationMatrix& other)
+    {
+      m_indices = other.m_indices;
+      return *this;
+    }
+    #endif
+
+    /** const version of indices(). */
+    const IndicesType& indices() const { return m_indices; }
+    /** \returns a reference to the stored array representing the permutation. */
+    IndicesType& indices() { return m_indices; }
+
+
+    /**** multiplication helpers to hopefully get RVO ****/
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename Other>
+    PermutationMatrix(const InverseImpl<Other,PermutationStorage>& other)
+      : m_indices(other.derived().nestedExpression().size())
+    {
+      eigen_internal_assert(m_indices.size() <= NumTraits<StorageIndex>::highest());
+      StorageIndex end = StorageIndex(m_indices.size());
+      for (StorageIndex i=0; i<end;++i)
+        m_indices.coeffRef(other.derived().nestedExpression().indices().coeff(i)) = i;
+    }
+    template<typename Lhs,typename Rhs>
+    PermutationMatrix(internal::PermPermProduct_t, const Lhs& lhs, const Rhs& rhs)
+      : m_indices(lhs.indices().size())
+    {
+      Base::assignProduct(lhs,rhs);
+    }
+#endif
+
+  protected:
+
+    IndicesType m_indices;
+};
+
+
+namespace internal {
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime, typename _StorageIndex, int _PacketAccess>
+struct traits<Map<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex>,_PacketAccess> >
+ : traits<Matrix<_StorageIndex,SizeAtCompileTime,SizeAtCompileTime,0,MaxSizeAtCompileTime,MaxSizeAtCompileTime> >
+{
+  typedef PermutationStorage StorageKind;
+  typedef Map<const Matrix<_StorageIndex, SizeAtCompileTime, 1, 0, MaxSizeAtCompileTime, 1>, _PacketAccess> IndicesType;
+  typedef _StorageIndex StorageIndex;
+  typedef void Scalar;
+};
+}
+
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime, typename _StorageIndex, int _PacketAccess>
+class Map<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex>,_PacketAccess>
+  : public PermutationBase<Map<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex>,_PacketAccess> >
+{
+    typedef PermutationBase<Map> Base;
+    typedef internal::traits<Map> Traits;
+  public:
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    typedef typename Traits::IndicesType IndicesType;
+    typedef typename IndicesType::Scalar StorageIndex;
+    #endif
+
+    inline Map(const StorageIndex* indicesPtr)
+      : m_indices(indicesPtr)
+    {}
+
+    inline Map(const StorageIndex* indicesPtr, Index size)
+      : m_indices(indicesPtr,size)
+    {}
+
+    /** Copies the other permutation into *this */
+    template<typename Other>
+    Map& operator=(const PermutationBase<Other>& other)
+    { return Base::operator=(other.derived()); }
+
+    /** Assignment from the Transpositions \a tr */
+    template<typename Other>
+    Map& operator=(const TranspositionsBase<Other>& tr)
+    { return Base::operator=(tr.derived()); }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** This is a special case of the templated operator=. Its purpose is to
+      * prevent a default operator= from hiding the templated operator=.
+      */
+    Map& operator=(const Map& other)
+    {
+      m_indices = other.m_indices;
+      return *this;
+    }
+    #endif
+
+    /** const version of indices(). */
+    const IndicesType& indices() const { return m_indices; }
+    /** \returns a reference to the stored array representing the permutation. */
+    IndicesType& indices() { return m_indices; }
+
+  protected:
+
+    IndicesType m_indices;
+};
+
+template<typename _IndicesType> class TranspositionsWrapper;
+namespace internal {
+template<typename _IndicesType>
+struct traits<PermutationWrapper<_IndicesType> >
+{
+  typedef PermutationStorage StorageKind;
+  typedef void Scalar;
+  typedef typename _IndicesType::Scalar StorageIndex;
+  typedef _IndicesType IndicesType;
+  enum {
+    RowsAtCompileTime = _IndicesType::SizeAtCompileTime,
+    ColsAtCompileTime = _IndicesType::SizeAtCompileTime,
+    MaxRowsAtCompileTime = IndicesType::MaxSizeAtCompileTime,
+    MaxColsAtCompileTime = IndicesType::MaxSizeAtCompileTime,
+    Flags = 0
+  };
+};
+}
+
+/** \class PermutationWrapper
+  * \ingroup Core_Module
+  *
+  * \brief Class to view a vector of integers as a permutation matrix
+  *
+  * \tparam _IndicesType the type of the vector of integer (can be any compatible expression)
+  *
+  * This class allows to view any vector expression of integers as a permutation matrix.
+  *
+  * \sa class PermutationBase, class PermutationMatrix
+  */
+template<typename _IndicesType>
+class PermutationWrapper : public PermutationBase<PermutationWrapper<_IndicesType> >
+{
+    typedef PermutationBase<PermutationWrapper> Base;
+    typedef internal::traits<PermutationWrapper> Traits;
+  public:
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    typedef typename Traits::IndicesType IndicesType;
+    #endif
+
+    inline PermutationWrapper(const IndicesType& indices)
+      : m_indices(indices)
+    {}
+
+    /** const version of indices(). */
+    const typename internal::remove_all<typename IndicesType::Nested>::type&
+    indices() const { return m_indices; }
+
+  protected:
+
+    typename IndicesType::Nested m_indices;
+};
+
+
+/** \returns the matrix with the permutation applied to the columns.
+  */
+template<typename MatrixDerived, typename PermutationDerived>
+EIGEN_DEVICE_FUNC
+const Product<MatrixDerived, PermutationDerived, AliasFreeProduct>
+operator*(const MatrixBase<MatrixDerived> &matrix,
+          const PermutationBase<PermutationDerived>& permutation)
+{
+  return Product<MatrixDerived, PermutationDerived, AliasFreeProduct>
+            (matrix.derived(), permutation.derived());
+}
+
+/** \returns the matrix with the permutation applied to the rows.
+  */
+template<typename PermutationDerived, typename MatrixDerived>
+EIGEN_DEVICE_FUNC
+const Product<PermutationDerived, MatrixDerived, AliasFreeProduct>
+operator*(const PermutationBase<PermutationDerived> &permutation,
+          const MatrixBase<MatrixDerived>& matrix)
+{
+  return Product<PermutationDerived, MatrixDerived, AliasFreeProduct>
+            (permutation.derived(), matrix.derived());
+}
+
+
+template<typename PermutationType>
+class InverseImpl<PermutationType, PermutationStorage>
+  : public EigenBase<Inverse<PermutationType> >
+{
+    typedef typename PermutationType::PlainPermutationType PlainPermutationType;
+    typedef internal::traits<PermutationType> PermTraits;
+  protected:
+    InverseImpl() {}
+  public:
+    typedef Inverse<PermutationType> InverseType;
+    using EigenBase<Inverse<PermutationType> >::derived;
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    typedef typename PermutationType::DenseMatrixType DenseMatrixType;
+    enum {
+      RowsAtCompileTime = PermTraits::RowsAtCompileTime,
+      ColsAtCompileTime = PermTraits::ColsAtCompileTime,
+      MaxRowsAtCompileTime = PermTraits::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = PermTraits::MaxColsAtCompileTime
+    };
+    #endif
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename DenseDerived>
+    void evalTo(MatrixBase<DenseDerived>& other) const
+    {
+      other.setZero();
+      for (Index i=0; i<derived().rows();++i)
+        other.coeffRef(i, derived().nestedExpression().indices().coeff(i)) = typename DenseDerived::Scalar(1);
+    }
+    #endif
+
+    /** \return the equivalent permutation matrix */
+    PlainPermutationType eval() const { return derived(); }
+
+    DenseMatrixType toDenseMatrix() const { return derived(); }
+
+    /** \returns the matrix with the inverse permutation applied to the columns.
+      */
+    template<typename OtherDerived> friend
+    const Product<OtherDerived, InverseType, AliasFreeProduct>
+    operator*(const MatrixBase<OtherDerived>& matrix, const InverseType& trPerm)
+    {
+      return Product<OtherDerived, InverseType, AliasFreeProduct>(matrix.derived(), trPerm.derived());
+    }
+
+    /** \returns the matrix with the inverse permutation applied to the rows.
+      */
+    template<typename OtherDerived>
+    const Product<InverseType, OtherDerived, AliasFreeProduct>
+    operator*(const MatrixBase<OtherDerived>& matrix) const
+    {
+      return Product<InverseType, OtherDerived, AliasFreeProduct>(derived(), matrix.derived());
+    }
+};
+
+template<typename Derived>
+const PermutationWrapper<const Derived> MatrixBase<Derived>::asPermutation() const
+{
+  return derived();
+}
+
+namespace internal {
+
+template<> struct AssignmentKind<DenseShape,PermutationShape> { typedef EigenBase2EigenBase Kind; };
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_PERMUTATIONMATRIX_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/PlainObjectBase.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/PlainObjectBase.h
new file mode 100644
index 00000000..1dc7e223
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/PlainObjectBase.h
@@ -0,0 +1,1035 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_DENSESTORAGEBASE_H
+#define EIGEN_DENSESTORAGEBASE_H
+
+#if defined(EIGEN_INITIALIZE_MATRICES_BY_ZERO)
+# define EIGEN_INITIALIZE_COEFFS
+# define EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED for(int i=0;i<base().size();++i) coeffRef(i)=Scalar(0);
+#elif defined(EIGEN_INITIALIZE_MATRICES_BY_NAN)
+# define EIGEN_INITIALIZE_COEFFS
+# define EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED for(int i=0;i<base().size();++i) coeffRef(i)=std::numeric_limits<Scalar>::quiet_NaN();
+#else
+# undef EIGEN_INITIALIZE_COEFFS
+# define EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+#endif
+
+namespace Eigen {
+
+namespace internal {
+
+template<int MaxSizeAtCompileTime> struct check_rows_cols_for_overflow {
+  template<typename Index>
+  EIGEN_DEVICE_FUNC
+  static EIGEN_ALWAYS_INLINE void run(Index, Index)
+  {
+  }
+};
+
+template<> struct check_rows_cols_for_overflow<Dynamic> {
+  template<typename Index>
+  EIGEN_DEVICE_FUNC
+  static EIGEN_ALWAYS_INLINE void run(Index rows, Index cols)
+  {
+    // http://hg.mozilla.org/mozilla-central/file/6c8a909977d3/xpcom/ds/CheckedInt.h#l242
+    // we assume Index is signed
+    Index max_index = (std::size_t(1) << (8 * sizeof(Index) - 1)) - 1; // assume Index is signed
+    bool error = (rows == 0 || cols == 0) ? false
+               : (rows > max_index / cols);
+    if (error)
+      throw_std_bad_alloc();
+  }
+};
+
+template <typename Derived,
+          typename OtherDerived = Derived,
+          bool IsVector = bool(Derived::IsVectorAtCompileTime) && bool(OtherDerived::IsVectorAtCompileTime)>
+struct conservative_resize_like_impl;
+
+template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers> struct matrix_swap_impl;
+
+} // end namespace internal
+
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+namespace doxygen {
+
+// This is a workaround to doxygen not being able to understand the inheritance logic
+// when it is hidden by the dense_xpr_base helper struct.
+// Moreover, doxygen fails to include members that are not documented in the declaration body of
+// MatrixBase if we inherits MatrixBase<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >,
+// this is why we simply inherits MatrixBase, though this does not make sense.
+
+/** This class is just a workaround for Doxygen and it does not not actually exist. */
+template<typename Derived> struct dense_xpr_base_dispatcher;
+/** This class is just a workaround for Doxygen and it does not not actually exist. */
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+struct dense_xpr_base_dispatcher<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
+    : public MatrixBase {};
+/** This class is just a workaround for Doxygen and it does not not actually exist. */
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+struct dense_xpr_base_dispatcher<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
+    : public ArrayBase {};
+
+} // namespace doxygen
+
+/** \class PlainObjectBase
+  * \ingroup Core_Module
+  * \brief %Dense storage base class for matrices and arrays.
+  *
+  * This class can be extended with the help of the plugin mechanism described on the page
+  * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_PLAINOBJECTBASE_PLUGIN.
+  *
+  * \tparam Derived is the derived type, e.g., a Matrix or Array
+  *
+  * \sa \ref TopicClassHierarchy
+  */
+template<typename Derived>
+class PlainObjectBase : public doxygen::dense_xpr_base_dispatcher<Derived>
+#else
+template<typename Derived>
+class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
+#endif
+{
+  public:
+    enum { Options = internal::traits<Derived>::Options };
+    typedef typename internal::dense_xpr_base<Derived>::type Base;
+
+    typedef typename internal::traits<Derived>::StorageKind StorageKind;
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    
+    typedef typename internal::packet_traits<Scalar>::type PacketScalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef Derived DenseType;
+
+    using Base::RowsAtCompileTime;
+    using Base::ColsAtCompileTime;
+    using Base::SizeAtCompileTime;
+    using Base::MaxRowsAtCompileTime;
+    using Base::MaxColsAtCompileTime;
+    using Base::MaxSizeAtCompileTime;
+    using Base::IsVectorAtCompileTime;
+    using Base::Flags;
+
+    template<typename PlainObjectType, int MapOptions, typename StrideType> friend class Eigen::Map;
+    friend  class Eigen::Map<Derived, Unaligned>;
+    typedef Eigen::Map<Derived, Unaligned>  MapType;
+    friend  class Eigen::Map<const Derived, Unaligned>;
+    typedef const Eigen::Map<const Derived, Unaligned> ConstMapType;
+#if EIGEN_MAX_ALIGN_BYTES>0
+    // for EIGEN_MAX_ALIGN_BYTES==0, AlignedMax==Unaligned, and many compilers generate warnings for friend-ing a class twice.
+    friend  class Eigen::Map<Derived, AlignedMax>;
+    friend  class Eigen::Map<const Derived, AlignedMax>;
+#endif
+    typedef Eigen::Map<Derived, AlignedMax> AlignedMapType;
+    typedef const Eigen::Map<const Derived, AlignedMax> ConstAlignedMapType;
+    template<typename StrideType> struct StridedMapType { typedef Eigen::Map<Derived, Unaligned, StrideType> type; };
+    template<typename StrideType> struct StridedConstMapType { typedef Eigen::Map<const Derived, Unaligned, StrideType> type; };
+    template<typename StrideType> struct StridedAlignedMapType { typedef Eigen::Map<Derived, AlignedMax, StrideType> type; };
+    template<typename StrideType> struct StridedConstAlignedMapType { typedef Eigen::Map<const Derived, AlignedMax, StrideType> type; };
+
+  protected:
+    DenseStorage<Scalar, Base::MaxSizeAtCompileTime, Base::RowsAtCompileTime, Base::ColsAtCompileTime, Options> m_storage;
+
+  public:
+    enum { NeedsToAlign = (SizeAtCompileTime != Dynamic) && (internal::traits<Derived>::Alignment>0) };
+    EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign)
+
+    EIGEN_DEVICE_FUNC
+    Base& base() { return *static_cast<Base*>(this); }
+    EIGEN_DEVICE_FUNC
+    const Base& base() const { return *static_cast<const Base*>(this); }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Index rows() const { return m_storage.rows(); }
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Index cols() const { return m_storage.cols(); }
+
+    /** This is an overloaded version of DenseCoeffsBase<Derived,ReadOnlyAccessors>::coeff(Index,Index) const
+      * provided to by-pass the creation of an evaluator of the expression, thus saving compilation efforts.
+      *
+      * See DenseCoeffsBase<Derived,ReadOnlyAccessors>::coeff(Index) const for details. */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const Scalar& coeff(Index rowId, Index colId) const
+    {
+      if(Flags & RowMajorBit)
+        return m_storage.data()[colId + rowId * m_storage.cols()];
+      else // column-major
+        return m_storage.data()[rowId + colId * m_storage.rows()];
+    }
+
+    /** This is an overloaded version of DenseCoeffsBase<Derived,ReadOnlyAccessors>::coeff(Index) const
+      * provided to by-pass the creation of an evaluator of the expression, thus saving compilation efforts.
+      *
+      * See DenseCoeffsBase<Derived,ReadOnlyAccessors>::coeff(Index) const for details. */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const Scalar& coeff(Index index) const
+    {
+      return m_storage.data()[index];
+    }
+
+    /** This is an overloaded version of DenseCoeffsBase<Derived,WriteAccessors>::coeffRef(Index,Index) const
+      * provided to by-pass the creation of an evaluator of the expression, thus saving compilation efforts.
+      *
+      * See DenseCoeffsBase<Derived,WriteAccessors>::coeffRef(Index,Index) const for details. */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar& coeffRef(Index rowId, Index colId)
+    {
+      if(Flags & RowMajorBit)
+        return m_storage.data()[colId + rowId * m_storage.cols()];
+      else // column-major
+        return m_storage.data()[rowId + colId * m_storage.rows()];
+    }
+
+    /** This is an overloaded version of DenseCoeffsBase<Derived,WriteAccessors>::coeffRef(Index) const
+      * provided to by-pass the creation of an evaluator of the expression, thus saving compilation efforts.
+      *
+      * See DenseCoeffsBase<Derived,WriteAccessors>::coeffRef(Index) const for details. */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar& coeffRef(Index index)
+    {
+      return m_storage.data()[index];
+    }
+
+    /** This is the const version of coeffRef(Index,Index) which is thus synonym of coeff(Index,Index).
+      * It is provided for convenience. */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const Scalar& coeffRef(Index rowId, Index colId) const
+    {
+      if(Flags & RowMajorBit)
+        return m_storage.data()[colId + rowId * m_storage.cols()];
+      else // column-major
+        return m_storage.data()[rowId + colId * m_storage.rows()];
+    }
+
+    /** This is the const version of coeffRef(Index) which is thus synonym of coeff(Index).
+      * It is provided for convenience. */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const Scalar& coeffRef(Index index) const
+    {
+      return m_storage.data()[index];
+    }
+
+    /** \internal */
+    template<int LoadMode>
+    EIGEN_STRONG_INLINE PacketScalar packet(Index rowId, Index colId) const
+    {
+      return internal::ploadt<PacketScalar, LoadMode>
+               (m_storage.data() + (Flags & RowMajorBit
+                                   ? colId + rowId * m_storage.cols()
+                                   : rowId + colId * m_storage.rows()));
+    }
+
+    /** \internal */
+    template<int LoadMode>
+    EIGEN_STRONG_INLINE PacketScalar packet(Index index) const
+    {
+      return internal::ploadt<PacketScalar, LoadMode>(m_storage.data() + index);
+    }
+
+    /** \internal */
+    template<int StoreMode>
+    EIGEN_STRONG_INLINE void writePacket(Index rowId, Index colId, const PacketScalar& val)
+    {
+      internal::pstoret<Scalar, PacketScalar, StoreMode>
+              (m_storage.data() + (Flags & RowMajorBit
+                                   ? colId + rowId * m_storage.cols()
+                                   : rowId + colId * m_storage.rows()), val);
+    }
+
+    /** \internal */
+    template<int StoreMode>
+    EIGEN_STRONG_INLINE void writePacket(Index index, const PacketScalar& val)
+    {
+      internal::pstoret<Scalar, PacketScalar, StoreMode>(m_storage.data() + index, val);
+    }
+
+    /** \returns a const pointer to the data array of this matrix */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar *data() const
+    { return m_storage.data(); }
+
+    /** \returns a pointer to the data array of this matrix */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar *data()
+    { return m_storage.data(); }
+
+    /** Resizes \c *this to a \a rows x \a cols matrix.
+      *
+      * This method is intended for dynamic-size matrices, although it is legal to call it on any
+      * matrix as long as fixed dimensions are left unchanged. If you only want to change the number
+      * of rows and/or of columns, you can use resize(NoChange_t, Index), resize(Index, NoChange_t).
+      *
+      * If the current number of coefficients of \c *this exactly matches the
+      * product \a rows * \a cols, then no memory allocation is performed and
+      * the current values are left unchanged. In all other cases, including
+      * shrinking, the data is reallocated and all previous values are lost.
+      *
+      * Example: \include Matrix_resize_int_int.cpp
+      * Output: \verbinclude Matrix_resize_int_int.out
+      *
+      * \sa resize(Index) for vectors, resize(NoChange_t, Index), resize(Index, NoChange_t)
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void resize(Index rows, Index cols)
+    {
+      eigen_assert(   EIGEN_IMPLIES(RowsAtCompileTime!=Dynamic,rows==RowsAtCompileTime)
+                   && EIGEN_IMPLIES(ColsAtCompileTime!=Dynamic,cols==ColsAtCompileTime)
+                   && EIGEN_IMPLIES(RowsAtCompileTime==Dynamic && MaxRowsAtCompileTime!=Dynamic,rows<=MaxRowsAtCompileTime)
+                   && EIGEN_IMPLIES(ColsAtCompileTime==Dynamic && MaxColsAtCompileTime!=Dynamic,cols<=MaxColsAtCompileTime)
+                   && rows>=0 && cols>=0 && "Invalid sizes when resizing a matrix or array.");
+      internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(rows, cols);
+      #ifdef EIGEN_INITIALIZE_COEFFS
+        Index size = rows*cols;
+        bool size_changed = size != this->size();
+        m_storage.resize(size, rows, cols);
+        if(size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+      #else
+        m_storage.resize(rows*cols, rows, cols);
+      #endif
+    }
+
+    /** Resizes \c *this to a vector of length \a size
+      *
+      * \only_for_vectors. This method does not work for
+      * partially dynamic matrices when the static dimension is anything other
+      * than 1. For example it will not work with Matrix<double, 2, Dynamic>.
+      *
+      * Example: \include Matrix_resize_int.cpp
+      * Output: \verbinclude Matrix_resize_int.out
+      *
+      * \sa resize(Index,Index), resize(NoChange_t, Index), resize(Index, NoChange_t)
+      */
+    EIGEN_DEVICE_FUNC
+    inline void resize(Index size)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(PlainObjectBase)
+      eigen_assert(((SizeAtCompileTime == Dynamic && (MaxSizeAtCompileTime==Dynamic || size<=MaxSizeAtCompileTime)) || SizeAtCompileTime == size) && size>=0);
+      #ifdef EIGEN_INITIALIZE_COEFFS
+        bool size_changed = size != this->size();
+      #endif
+      if(RowsAtCompileTime == 1)
+        m_storage.resize(size, 1, size);
+      else
+        m_storage.resize(size, size, 1);
+      #ifdef EIGEN_INITIALIZE_COEFFS
+        if(size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+      #endif
+    }
+
+    /** Resizes the matrix, changing only the number of columns. For the parameter of type NoChange_t, just pass the special value \c NoChange
+      * as in the example below.
+      *
+      * Example: \include Matrix_resize_NoChange_int.cpp
+      * Output: \verbinclude Matrix_resize_NoChange_int.out
+      *
+      * \sa resize(Index,Index)
+      */
+    EIGEN_DEVICE_FUNC
+    inline void resize(NoChange_t, Index cols)
+    {
+      resize(rows(), cols);
+    }
+
+    /** Resizes the matrix, changing only the number of rows. For the parameter of type NoChange_t, just pass the special value \c NoChange
+      * as in the example below.
+      *
+      * Example: \include Matrix_resize_int_NoChange.cpp
+      * Output: \verbinclude Matrix_resize_int_NoChange.out
+      *
+      * \sa resize(Index,Index)
+      */
+    EIGEN_DEVICE_FUNC
+    inline void resize(Index rows, NoChange_t)
+    {
+      resize(rows, cols());
+    }
+
+    /** Resizes \c *this to have the same dimensions as \a other.
+      * Takes care of doing all the checking that's needed.
+      *
+      * Note that copying a row-vector into a vector (and conversely) is allowed.
+      * The resizing, if any, is then done in the appropriate way so that row-vectors
+      * remain row-vectors and vectors remain vectors.
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC 
+    EIGEN_STRONG_INLINE void resizeLike(const EigenBase<OtherDerived>& _other)
+    {
+      const OtherDerived& other = _other.derived();
+      internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(other.rows(), other.cols());
+      const Index othersize = other.rows()*other.cols();
+      if(RowsAtCompileTime == 1)
+      {
+        eigen_assert(other.rows() == 1 || other.cols() == 1);
+        resize(1, othersize);
+      }
+      else if(ColsAtCompileTime == 1)
+      {
+        eigen_assert(other.rows() == 1 || other.cols() == 1);
+        resize(othersize, 1);
+      }
+      else resize(other.rows(), other.cols());
+    }
+
+    /** Resizes the matrix to \a rows x \a cols while leaving old values untouched.
+      *
+      * The method is intended for matrices of dynamic size. If you only want to change the number
+      * of rows and/or of columns, you can use conservativeResize(NoChange_t, Index) or
+      * conservativeResize(Index, NoChange_t).
+      *
+      * Matrices are resized relative to the top-left element. In case values need to be 
+      * appended to the matrix they will be uninitialized.
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void conservativeResize(Index rows, Index cols)
+    {
+      internal::conservative_resize_like_impl<Derived>::run(*this, rows, cols);
+    }
+
+    /** Resizes the matrix to \a rows x \a cols while leaving old values untouched.
+      *
+      * As opposed to conservativeResize(Index rows, Index cols), this version leaves
+      * the number of columns unchanged.
+      *
+      * In case the matrix is growing, new rows will be uninitialized.
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void conservativeResize(Index rows, NoChange_t)
+    {
+      // Note: see the comment in conservativeResize(Index,Index)
+      conservativeResize(rows, cols());
+    }
+
+    /** Resizes the matrix to \a rows x \a cols while leaving old values untouched.
+      *
+      * As opposed to conservativeResize(Index rows, Index cols), this version leaves
+      * the number of rows unchanged.
+      *
+      * In case the matrix is growing, new columns will be uninitialized.
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void conservativeResize(NoChange_t, Index cols)
+    {
+      // Note: see the comment in conservativeResize(Index,Index)
+      conservativeResize(rows(), cols);
+    }
+
+    /** Resizes the vector to \a size while retaining old values.
+      *
+      * \only_for_vectors. This method does not work for
+      * partially dynamic matrices when the static dimension is anything other
+      * than 1. For example it will not work with Matrix<double, 2, Dynamic>.
+      *
+      * When values are appended, they will be uninitialized.
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void conservativeResize(Index size)
+    {
+      internal::conservative_resize_like_impl<Derived>::run(*this, size);
+    }
+
+    /** Resizes the matrix to \a rows x \a cols of \c other, while leaving old values untouched.
+      *
+      * The method is intended for matrices of dynamic size. If you only want to change the number
+      * of rows and/or of columns, you can use conservativeResize(NoChange_t, Index) or
+      * conservativeResize(Index, NoChange_t).
+      *
+      * Matrices are resized relative to the top-left element. In case values need to be 
+      * appended to the matrix they will copied from \c other.
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void conservativeResizeLike(const DenseBase<OtherDerived>& other)
+    {
+      internal::conservative_resize_like_impl<Derived,OtherDerived>::run(*this, other);
+    }
+
+    /** This is a special case of the templated operator=. Its purpose is to
+      * prevent a default operator= from hiding the templated operator=.
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Derived& operator=(const PlainObjectBase& other)
+    {
+      return _set(other);
+    }
+
+    /** \sa MatrixBase::lazyAssign() */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Derived& lazyAssign(const DenseBase<OtherDerived>& other)
+    {
+      _resize_to_match(other);
+      return Base::lazyAssign(other.derived());
+    }
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Derived& operator=(const ReturnByValue<OtherDerived>& func)
+    {
+      resize(func.rows(), func.cols());
+      return Base::operator=(func);
+    }
+
+    // Prevent user from trying to instantiate PlainObjectBase objects
+    // by making all its constructor protected. See bug 1074.
+  protected:
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE PlainObjectBase() : m_storage()
+    {
+//       _check_template_params();
+//       EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+    }
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    // FIXME is it still needed ?
+    /** \internal */
+    EIGEN_DEVICE_FUNC
+    explicit PlainObjectBase(internal::constructor_without_unaligned_array_assert)
+      : m_storage(internal::constructor_without_unaligned_array_assert())
+    {
+//       _check_template_params(); EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+    }
+#endif
+
+#if EIGEN_HAS_RVALUE_REFERENCES
+    EIGEN_DEVICE_FUNC
+    PlainObjectBase(PlainObjectBase&& other) EIGEN_NOEXCEPT
+      : m_storage( std::move(other.m_storage) )
+    {
+    }
+
+    EIGEN_DEVICE_FUNC
+    PlainObjectBase& operator=(PlainObjectBase&& other) EIGEN_NOEXCEPT
+    {
+      using std::swap;
+      swap(m_storage, other.m_storage);
+      return *this;
+    }
+#endif
+
+    /** Copy constructor */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE PlainObjectBase(const PlainObjectBase& other)
+      : Base(), m_storage(other.m_storage) { }
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE PlainObjectBase(Index size, Index rows, Index cols)
+      : m_storage(size, rows, cols)
+    {
+//       _check_template_params();
+//       EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+    }
+
+    /** \sa PlainObjectBase::operator=(const EigenBase<OtherDerived>&) */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE PlainObjectBase(const DenseBase<OtherDerived> &other)
+      : m_storage()
+    {
+      _check_template_params();
+      resizeLike(other);
+      _set_noalias(other);
+    }
+
+    /** \sa PlainObjectBase::operator=(const EigenBase<OtherDerived>&) */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE PlainObjectBase(const EigenBase<OtherDerived> &other)
+      : m_storage()
+    {
+      _check_template_params();
+      resizeLike(other);
+      *this = other.derived();
+    }
+    /** \brief Copy constructor with in-place evaluation */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE PlainObjectBase(const ReturnByValue<OtherDerived>& other)
+    {
+      _check_template_params();
+      // FIXME this does not automatically transpose vectors if necessary
+      resize(other.rows(), other.cols());
+      other.evalTo(this->derived());
+    }
+
+  public:
+
+    /** \brief Copies the generic expression \a other into *this.
+      * \copydetails DenseBase::operator=(const EigenBase<OtherDerived> &other)
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC 
+    EIGEN_STRONG_INLINE Derived& operator=(const EigenBase<OtherDerived> &other)
+    {
+      _resize_to_match(other);
+      Base::operator=(other.derived());
+      return this->derived();
+    }
+
+    /** \name Map
+      * These are convenience functions returning Map objects. The Map() static functions return unaligned Map objects,
+      * while the AlignedMap() functions return aligned Map objects and thus should be called only with 16-byte-aligned
+      * \a data pointers.
+      *
+      * Here is an example using strides:
+      * \include Matrix_Map_stride.cpp
+      * Output: \verbinclude Matrix_Map_stride.out
+      *
+      * \see class Map
+      */
+    //@{
+    static inline ConstMapType Map(const Scalar* data)
+    { return ConstMapType(data); }
+    static inline MapType Map(Scalar* data)
+    { return MapType(data); }
+    static inline ConstMapType Map(const Scalar* data, Index size)
+    { return ConstMapType(data, size); }
+    static inline MapType Map(Scalar* data, Index size)
+    { return MapType(data, size); }
+    static inline ConstMapType Map(const Scalar* data, Index rows, Index cols)
+    { return ConstMapType(data, rows, cols); }
+    static inline MapType Map(Scalar* data, Index rows, Index cols)
+    { return MapType(data, rows, cols); }
+
+    static inline ConstAlignedMapType MapAligned(const Scalar* data)
+    { return ConstAlignedMapType(data); }
+    static inline AlignedMapType MapAligned(Scalar* data)
+    { return AlignedMapType(data); }
+    static inline ConstAlignedMapType MapAligned(const Scalar* data, Index size)
+    { return ConstAlignedMapType(data, size); }
+    static inline AlignedMapType MapAligned(Scalar* data, Index size)
+    { return AlignedMapType(data, size); }
+    static inline ConstAlignedMapType MapAligned(const Scalar* data, Index rows, Index cols)
+    { return ConstAlignedMapType(data, rows, cols); }
+    static inline AlignedMapType MapAligned(Scalar* data, Index rows, Index cols)
+    { return AlignedMapType(data, rows, cols); }
+
+    template<int Outer, int Inner>
+    static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(const Scalar* data, const Stride<Outer, Inner>& stride)
+    { return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, stride); }
+    template<int Outer, int Inner>
+    static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar* data, const Stride<Outer, Inner>& stride)
+    { return typename StridedMapType<Stride<Outer, Inner> >::type(data, stride); }
+    template<int Outer, int Inner>
+    static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(const Scalar* data, Index size, const Stride<Outer, Inner>& stride)
+    { return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, size, stride); }
+    template<int Outer, int Inner>
+    static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar* data, Index size, const Stride<Outer, Inner>& stride)
+    { return typename StridedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
+    template<int Outer, int Inner>
+    static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(const Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
+    { return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
+    template<int Outer, int Inner>
+    static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
+    { return typename StridedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
+
+    template<int Outer, int Inner>
+    static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(const Scalar* data, const Stride<Outer, Inner>& stride)
+    { return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, stride); }
+    template<int Outer, int Inner>
+    static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data, const Stride<Outer, Inner>& stride)
+    { return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, stride); }
+    template<int Outer, int Inner>
+    static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(const Scalar* data, Index size, const Stride<Outer, Inner>& stride)
+    { return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
+    template<int Outer, int Inner>
+    static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data, Index size, const Stride<Outer, Inner>& stride)
+    { return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
+    template<int Outer, int Inner>
+    static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(const Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
+    { return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
+    template<int Outer, int Inner>
+    static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
+    { return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
+    //@}
+
+    using Base::setConstant;
+    EIGEN_DEVICE_FUNC Derived& setConstant(Index size, const Scalar& val);
+    EIGEN_DEVICE_FUNC Derived& setConstant(Index rows, Index cols, const Scalar& val);
+
+    using Base::setZero;
+    EIGEN_DEVICE_FUNC Derived& setZero(Index size);
+    EIGEN_DEVICE_FUNC Derived& setZero(Index rows, Index cols);
+
+    using Base::setOnes;
+    EIGEN_DEVICE_FUNC Derived& setOnes(Index size);
+    EIGEN_DEVICE_FUNC Derived& setOnes(Index rows, Index cols);
+
+    using Base::setRandom;
+    Derived& setRandom(Index size);
+    Derived& setRandom(Index rows, Index cols);
+
+    #ifdef EIGEN_PLAINOBJECTBASE_PLUGIN
+    #include EIGEN_PLAINOBJECTBASE_PLUGIN
+    #endif
+
+  protected:
+    /** \internal Resizes *this in preparation for assigning \a other to it.
+      * Takes care of doing all the checking that's needed.
+      *
+      * Note that copying a row-vector into a vector (and conversely) is allowed.
+      * The resizing, if any, is then done in the appropriate way so that row-vectors
+      * remain row-vectors and vectors remain vectors.
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC 
+    EIGEN_STRONG_INLINE void _resize_to_match(const EigenBase<OtherDerived>& other)
+    {
+      #ifdef EIGEN_NO_AUTOMATIC_RESIZING
+      eigen_assert((this->size()==0 || (IsVectorAtCompileTime ? (this->size() == other.size())
+                 : (rows() == other.rows() && cols() == other.cols())))
+        && "Size mismatch. Automatic resizing is disabled because EIGEN_NO_AUTOMATIC_RESIZING is defined");
+      EIGEN_ONLY_USED_FOR_DEBUG(other);
+      #else
+      resizeLike(other);
+      #endif
+    }
+
+    /**
+      * \brief Copies the value of the expression \a other into \c *this with automatic resizing.
+      *
+      * *this might be resized to match the dimensions of \a other. If *this was a null matrix (not already initialized),
+      * it will be initialized.
+      *
+      * Note that copying a row-vector into a vector (and conversely) is allowed.
+      * The resizing, if any, is then done in the appropriate way so that row-vectors
+      * remain row-vectors and vectors remain vectors.
+      *
+      * \sa operator=(const MatrixBase<OtherDerived>&), _set_noalias()
+      *
+      * \internal
+      */
+    // aliasing is dealt once in internall::call_assignment
+    // so at this stage we have to assume aliasing... and resising has to be done later.
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC 
+    EIGEN_STRONG_INLINE Derived& _set(const DenseBase<OtherDerived>& other)
+    {
+      internal::call_assignment(this->derived(), other.derived());
+      return this->derived();
+    }
+
+    /** \internal Like _set() but additionally makes the assumption that no aliasing effect can happen (which
+      * is the case when creating a new matrix) so one can enforce lazy evaluation.
+      *
+      * \sa operator=(const MatrixBase<OtherDerived>&), _set()
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC 
+    EIGEN_STRONG_INLINE Derived& _set_noalias(const DenseBase<OtherDerived>& other)
+    {
+      // I don't think we need this resize call since the lazyAssign will anyways resize
+      // and lazyAssign will be called by the assign selector.
+      //_resize_to_match(other);
+      // the 'false' below means to enforce lazy evaluation. We don't use lazyAssign() because
+      // it wouldn't allow to copy a row-vector into a column-vector.
+      internal::call_assignment_no_alias(this->derived(), other.derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
+      return this->derived();
+    }
+
+    template<typename T0, typename T1>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init2(Index rows, Index cols, typename internal::enable_if<Base::SizeAtCompileTime!=2,T0>::type* = 0)
+    {
+      EIGEN_STATIC_ASSERT(bool(NumTraits<T0>::IsInteger) &&
+                          bool(NumTraits<T1>::IsInteger),
+                          FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
+      resize(rows,cols);
+    }
+    
+    template<typename T0, typename T1>
+    EIGEN_DEVICE_FUNC 
+    EIGEN_STRONG_INLINE void _init2(const T0& val0, const T1& val1, typename internal::enable_if<Base::SizeAtCompileTime==2,T0>::type* = 0)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2)
+      m_storage.data()[0] = Scalar(val0);
+      m_storage.data()[1] = Scalar(val1);
+    }
+    
+    template<typename T0, typename T1>
+    EIGEN_DEVICE_FUNC 
+    EIGEN_STRONG_INLINE void _init2(const Index& val0, const Index& val1,
+                                    typename internal::enable_if<    (!internal::is_same<Index,Scalar>::value)
+                                                                  && (internal::is_same<T0,Index>::value)
+                                                                  && (internal::is_same<T1,Index>::value)
+                                                                  && Base::SizeAtCompileTime==2,T1>::type* = 0)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2)
+      m_storage.data()[0] = Scalar(val0);
+      m_storage.data()[1] = Scalar(val1);
+    }
+
+    // The argument is convertible to the Index type and we either have a non 1x1 Matrix, or a dynamic-sized Array,
+    // then the argument is meant to be the size of the object.
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(Index size, typename internal::enable_if<    (Base::SizeAtCompileTime!=1 || !internal::is_convertible<T, Scalar>::value)
+                                                                              && ((!internal::is_same<typename internal::traits<Derived>::XprKind,ArrayXpr>::value || Base::SizeAtCompileTime==Dynamic)),T>::type* = 0)
+    {
+      // NOTE MSVC 2008 complains if we directly put bool(NumTraits<T>::IsInteger) as the EIGEN_STATIC_ASSERT argument.
+      const bool is_integer = NumTraits<T>::IsInteger;
+      EIGEN_UNUSED_VARIABLE(is_integer);
+      EIGEN_STATIC_ASSERT(is_integer,
+                          FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
+      resize(size);
+    }
+    
+    // We have a 1x1 matrix/array => the argument is interpreted as the value of the unique coefficient (case where scalar type can be implicitely converted)
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(const Scalar& val0, typename internal::enable_if<Base::SizeAtCompileTime==1 && internal::is_convertible<T, Scalar>::value,T>::type* = 0)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 1)
+      m_storage.data()[0] = val0;
+    }
+    
+    // We have a 1x1 matrix/array => the argument is interpreted as the value of the unique coefficient (case where scalar type match the index type)
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(const Index& val0,
+                                    typename internal::enable_if<    (!internal::is_same<Index,Scalar>::value)
+                                                                  && (internal::is_same<Index,T>::value)
+                                                                  && Base::SizeAtCompileTime==1
+                                                                  && internal::is_convertible<T, Scalar>::value,T*>::type* = 0)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 1)
+      m_storage.data()[0] = Scalar(val0);
+    }
+
+    // Initialize a fixed size matrix from a pointer to raw data
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(const Scalar* data){
+      this->_set_noalias(ConstMapType(data));
+    }
+
+    // Initialize an arbitrary matrix from a dense expression
+    template<typename T, typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(const DenseBase<OtherDerived>& other){
+      this->_set_noalias(other);
+    }
+
+    // Initialize an arbitrary matrix from an object convertible to the Derived type.
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(const Derived& other){
+      this->_set_noalias(other);
+    }
+
+    // Initialize an arbitrary matrix from a generic Eigen expression
+    template<typename T, typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(const EigenBase<OtherDerived>& other){
+      this->derived() = other;
+    }
+
+    template<typename T, typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(const ReturnByValue<OtherDerived>& other)
+    {
+      resize(other.rows(), other.cols());
+      other.evalTo(this->derived());
+    }
+
+    template<typename T, typename OtherDerived, int ColsAtCompileTime>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(const RotationBase<OtherDerived,ColsAtCompileTime>& r)
+    {
+      this->derived() = r;
+    }
+    
+    // For fixed-size Array<Scalar,...>
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(const Scalar& val0,
+                                    typename internal::enable_if<    Base::SizeAtCompileTime!=Dynamic
+                                                                  && Base::SizeAtCompileTime!=1
+                                                                  && internal::is_convertible<T, Scalar>::value
+                                                                  && internal::is_same<typename internal::traits<Derived>::XprKind,ArrayXpr>::value,T>::type* = 0)
+    {
+      Base::setConstant(val0);
+    }
+    
+    // For fixed-size Array<Index,...>
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(const Index& val0,
+                                    typename internal::enable_if<    (!internal::is_same<Index,Scalar>::value)
+                                                                  && (internal::is_same<Index,T>::value)
+                                                                  && Base::SizeAtCompileTime!=Dynamic
+                                                                  && Base::SizeAtCompileTime!=1
+                                                                  && internal::is_convertible<T, Scalar>::value
+                                                                  && internal::is_same<typename internal::traits<Derived>::XprKind,ArrayXpr>::value,T*>::type* = 0)
+    {
+      Base::setConstant(val0);
+    }
+    
+    template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers>
+    friend struct internal::matrix_swap_impl;
+
+  public:
+    
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** \internal
+      * \brief Override DenseBase::swap() since for dynamic-sized matrices
+      * of same type it is enough to swap the data pointers.
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    void swap(DenseBase<OtherDerived> & other)
+    {
+      enum { SwapPointers = internal::is_same<Derived, OtherDerived>::value && Base::SizeAtCompileTime==Dynamic };
+      internal::matrix_swap_impl<Derived, OtherDerived, bool(SwapPointers)>::run(this->derived(), other.derived());
+    }
+    
+    /** \internal
+      * \brief const version forwarded to DenseBase::swap
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    void swap(DenseBase<OtherDerived> const & other)
+    { Base::swap(other.derived()); }
+    
+    EIGEN_DEVICE_FUNC 
+    static EIGEN_STRONG_INLINE void _check_template_params()
+    {
+      EIGEN_STATIC_ASSERT((EIGEN_IMPLIES(MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1, (Options&RowMajor)==RowMajor)
+                        && EIGEN_IMPLIES(MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1, (Options&RowMajor)==0)
+                        && ((RowsAtCompileTime == Dynamic) || (RowsAtCompileTime >= 0))
+                        && ((ColsAtCompileTime == Dynamic) || (ColsAtCompileTime >= 0))
+                        && ((MaxRowsAtCompileTime == Dynamic) || (MaxRowsAtCompileTime >= 0))
+                        && ((MaxColsAtCompileTime == Dynamic) || (MaxColsAtCompileTime >= 0))
+                        && (MaxRowsAtCompileTime == RowsAtCompileTime || RowsAtCompileTime==Dynamic)
+                        && (MaxColsAtCompileTime == ColsAtCompileTime || ColsAtCompileTime==Dynamic)
+                        && (Options & (DontAlign|RowMajor)) == Options),
+        INVALID_MATRIX_TEMPLATE_PARAMETERS)
+    }
+
+    enum { IsPlainObjectBase = 1 };
+#endif
+};
+
+namespace internal {
+
+template <typename Derived, typename OtherDerived, bool IsVector>
+struct conservative_resize_like_impl
+{
+  static void run(DenseBase<Derived>& _this, Index rows, Index cols)
+  {
+    if (_this.rows() == rows && _this.cols() == cols) return;
+    EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)
+
+    if ( ( Derived::IsRowMajor && _this.cols() == cols) || // row-major and we change only the number of rows
+         (!Derived::IsRowMajor && _this.rows() == rows) )  // column-major and we change only the number of columns
+    {
+      internal::check_rows_cols_for_overflow<Derived::MaxSizeAtCompileTime>::run(rows, cols);
+      _this.derived().m_storage.conservativeResize(rows*cols,rows,cols);
+    }
+    else
+    {
+      // The storage order does not allow us to use reallocation.
+      typename Derived::PlainObject tmp(rows,cols);
+      const Index common_rows = numext::mini(rows, _this.rows());
+      const Index common_cols = numext::mini(cols, _this.cols());
+      tmp.block(0,0,common_rows,common_cols) = _this.block(0,0,common_rows,common_cols);
+      _this.derived().swap(tmp);
+    }
+  }
+
+  static void run(DenseBase<Derived>& _this, const DenseBase<OtherDerived>& other)
+  {
+    if (_this.rows() == other.rows() && _this.cols() == other.cols()) return;
+
+    // Note: Here is space for improvement. Basically, for conservativeResize(Index,Index),
+    // neither RowsAtCompileTime or ColsAtCompileTime must be Dynamic. If only one of the
+    // dimensions is dynamic, one could use either conservativeResize(Index rows, NoChange_t) or
+    // conservativeResize(NoChange_t, Index cols). For these methods new static asserts like
+    // EIGEN_STATIC_ASSERT_DYNAMIC_ROWS and EIGEN_STATIC_ASSERT_DYNAMIC_COLS would be good.
+    EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)
+    EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(OtherDerived)
+
+    if ( ( Derived::IsRowMajor && _this.cols() == other.cols()) || // row-major and we change only the number of rows
+         (!Derived::IsRowMajor && _this.rows() == other.rows()) )  // column-major and we change only the number of columns
+    {
+      const Index new_rows = other.rows() - _this.rows();
+      const Index new_cols = other.cols() - _this.cols();
+      _this.derived().m_storage.conservativeResize(other.size(),other.rows(),other.cols());
+      if (new_rows>0)
+        _this.bottomRightCorner(new_rows, other.cols()) = other.bottomRows(new_rows);
+      else if (new_cols>0)
+        _this.bottomRightCorner(other.rows(), new_cols) = other.rightCols(new_cols);
+    }
+    else
+    {
+      // The storage order does not allow us to use reallocation.
+      typename Derived::PlainObject tmp(other);
+      const Index common_rows = numext::mini(tmp.rows(), _this.rows());
+      const Index common_cols = numext::mini(tmp.cols(), _this.cols());
+      tmp.block(0,0,common_rows,common_cols) = _this.block(0,0,common_rows,common_cols);
+      _this.derived().swap(tmp);
+    }
+  }
+};
+
+// Here, the specialization for vectors inherits from the general matrix case
+// to allow calling .conservativeResize(rows,cols) on vectors.
+template <typename Derived, typename OtherDerived>
+struct conservative_resize_like_impl<Derived,OtherDerived,true>
+  : conservative_resize_like_impl<Derived,OtherDerived,false>
+{
+  using conservative_resize_like_impl<Derived,OtherDerived,false>::run;
+  
+  static void run(DenseBase<Derived>& _this, Index size)
+  {
+    const Index new_rows = Derived::RowsAtCompileTime==1 ? 1 : size;
+    const Index new_cols = Derived::RowsAtCompileTime==1 ? size : 1;
+    _this.derived().m_storage.conservativeResize(size,new_rows,new_cols);
+  }
+
+  static void run(DenseBase<Derived>& _this, const DenseBase<OtherDerived>& other)
+  {
+    if (_this.rows() == other.rows() && _this.cols() == other.cols()) return;
+
+    const Index num_new_elements = other.size() - _this.size();
+
+    const Index new_rows = Derived::RowsAtCompileTime==1 ? 1 : other.rows();
+    const Index new_cols = Derived::RowsAtCompileTime==1 ? other.cols() : 1;
+    _this.derived().m_storage.conservativeResize(other.size(),new_rows,new_cols);
+
+    if (num_new_elements > 0)
+      _this.tail(num_new_elements) = other.tail(num_new_elements);
+  }
+};
+
+template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers>
+struct matrix_swap_impl
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(MatrixTypeA& a, MatrixTypeB& b)
+  {
+    a.base().swap(b);
+  }
+};
+
+template<typename MatrixTypeA, typename MatrixTypeB>
+struct matrix_swap_impl<MatrixTypeA, MatrixTypeB, true>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(MatrixTypeA& a, MatrixTypeB& b)
+  {
+    static_cast<typename MatrixTypeA::Base&>(a).m_storage.swap(static_cast<typename MatrixTypeB::Base&>(b).m_storage);
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_DENSESTORAGEBASE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Product.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Product.h
new file mode 100644
index 00000000..ae0c94b3
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Product.h
@@ -0,0 +1,186 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2011 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PRODUCT_H
+#define EIGEN_PRODUCT_H
+
+namespace Eigen {
+
+template<typename Lhs, typename Rhs, int Option, typename StorageKind> class ProductImpl;
+
+namespace internal {
+
+template<typename Lhs, typename Rhs, int Option>
+struct traits<Product<Lhs, Rhs, Option> >
+{
+  typedef typename remove_all<Lhs>::type LhsCleaned;
+  typedef typename remove_all<Rhs>::type RhsCleaned;
+  typedef traits<LhsCleaned> LhsTraits;
+  typedef traits<RhsCleaned> RhsTraits;
+  
+  typedef MatrixXpr XprKind;
+  
+  typedef typename ScalarBinaryOpTraits<typename traits<LhsCleaned>::Scalar, typename traits<RhsCleaned>::Scalar>::ReturnType Scalar;
+  typedef typename product_promote_storage_type<typename LhsTraits::StorageKind,
+                                                typename RhsTraits::StorageKind,
+                                                internal::product_type<Lhs,Rhs>::ret>::ret StorageKind;
+  typedef typename promote_index_type<typename LhsTraits::StorageIndex,
+                                      typename RhsTraits::StorageIndex>::type StorageIndex;
+  
+  enum {
+    RowsAtCompileTime    = LhsTraits::RowsAtCompileTime,
+    ColsAtCompileTime    = RhsTraits::ColsAtCompileTime,
+    MaxRowsAtCompileTime = LhsTraits::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = RhsTraits::MaxColsAtCompileTime,
+    
+    // FIXME: only needed by GeneralMatrixMatrixTriangular
+    InnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(LhsTraits::ColsAtCompileTime, RhsTraits::RowsAtCompileTime),
+    
+    // The storage order is somewhat arbitrary here. The correct one will be determined through the evaluator.
+    Flags = (MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1) ? RowMajorBit
+          : (MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1) ? 0
+          : (   ((LhsTraits::Flags&NoPreferredStorageOrderBit) && (RhsTraits::Flags&RowMajorBit))
+             || ((RhsTraits::Flags&NoPreferredStorageOrderBit) && (LhsTraits::Flags&RowMajorBit)) ) ? RowMajorBit
+          : NoPreferredStorageOrderBit
+  };
+};
+
+} // end namespace internal
+
+/** \class Product
+  * \ingroup Core_Module
+  *
+  * \brief Expression of the product of two arbitrary matrices or vectors
+  *
+  * \tparam _Lhs the type of the left-hand side expression
+  * \tparam _Rhs the type of the right-hand side expression
+  *
+  * This class represents an expression of the product of two arbitrary matrices.
+  *
+  * The other template parameters are:
+  * \tparam Option     can be DefaultProduct, AliasFreeProduct, or LazyProduct
+  *
+  */
+template<typename _Lhs, typename _Rhs, int Option>
+class Product : public ProductImpl<_Lhs,_Rhs,Option,
+                                   typename internal::product_promote_storage_type<typename internal::traits<_Lhs>::StorageKind,
+                                                                                   typename internal::traits<_Rhs>::StorageKind,
+                                                                                   internal::product_type<_Lhs,_Rhs>::ret>::ret>
+{
+  public:
+    
+    typedef _Lhs Lhs;
+    typedef _Rhs Rhs;
+    
+    typedef typename ProductImpl<
+        Lhs, Rhs, Option,
+        typename internal::product_promote_storage_type<typename internal::traits<Lhs>::StorageKind,
+                                                        typename internal::traits<Rhs>::StorageKind,
+                                                        internal::product_type<Lhs,Rhs>::ret>::ret>::Base Base;
+    EIGEN_GENERIC_PUBLIC_INTERFACE(Product)
+
+    typedef typename internal::ref_selector<Lhs>::type LhsNested;
+    typedef typename internal::ref_selector<Rhs>::type RhsNested;
+    typedef typename internal::remove_all<LhsNested>::type LhsNestedCleaned;
+    typedef typename internal::remove_all<RhsNested>::type RhsNestedCleaned;
+
+    EIGEN_DEVICE_FUNC Product(const Lhs& lhs, const Rhs& rhs) : m_lhs(lhs), m_rhs(rhs)
+    {
+      eigen_assert(lhs.cols() == rhs.rows()
+        && "invalid matrix product"
+        && "if you wanted a coeff-wise or a dot product use the respective explicit functions");
+    }
+
+    EIGEN_DEVICE_FUNC inline Index rows() const { return m_lhs.rows(); }
+    EIGEN_DEVICE_FUNC inline Index cols() const { return m_rhs.cols(); }
+
+    EIGEN_DEVICE_FUNC const LhsNestedCleaned& lhs() const { return m_lhs; }
+    EIGEN_DEVICE_FUNC const RhsNestedCleaned& rhs() const { return m_rhs; }
+
+  protected:
+
+    LhsNested m_lhs;
+    RhsNested m_rhs;
+};
+
+namespace internal {
+  
+template<typename Lhs, typename Rhs, int Option, int ProductTag = internal::product_type<Lhs,Rhs>::ret>
+class dense_product_base
+ : public internal::dense_xpr_base<Product<Lhs,Rhs,Option> >::type
+{};
+
+/** Convertion to scalar for inner-products */
+template<typename Lhs, typename Rhs, int Option>
+class dense_product_base<Lhs, Rhs, Option, InnerProduct>
+ : public internal::dense_xpr_base<Product<Lhs,Rhs,Option> >::type
+{
+  typedef Product<Lhs,Rhs,Option> ProductXpr;
+  typedef typename internal::dense_xpr_base<ProductXpr>::type Base;
+public:
+  using Base::derived;
+  typedef typename Base::Scalar Scalar;
+  
+  operator const Scalar() const
+  {
+    return internal::evaluator<ProductXpr>(derived()).coeff(0,0);
+  }
+};
+
+} // namespace internal
+
+// Generic API dispatcher
+template<typename Lhs, typename Rhs, int Option, typename StorageKind>
+class ProductImpl : public internal::generic_xpr_base<Product<Lhs,Rhs,Option>, MatrixXpr, StorageKind>::type
+{
+  public:
+    typedef typename internal::generic_xpr_base<Product<Lhs,Rhs,Option>, MatrixXpr, StorageKind>::type Base;
+};
+
+template<typename Lhs, typename Rhs, int Option>
+class ProductImpl<Lhs,Rhs,Option,Dense>
+  : public internal::dense_product_base<Lhs,Rhs,Option>
+{
+    typedef Product<Lhs, Rhs, Option> Derived;
+    
+  public:
+    
+    typedef typename internal::dense_product_base<Lhs, Rhs, Option> Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Derived)
+  protected:
+    enum {
+      IsOneByOne = (RowsAtCompileTime == 1 || RowsAtCompileTime == Dynamic) && 
+                   (ColsAtCompileTime == 1 || ColsAtCompileTime == Dynamic),
+      EnableCoeff = IsOneByOne || Option==LazyProduct
+    };
+    
+  public:
+  
+    EIGEN_DEVICE_FUNC Scalar coeff(Index row, Index col) const
+    {
+      EIGEN_STATIC_ASSERT(EnableCoeff, THIS_METHOD_IS_ONLY_FOR_INNER_OR_LAZY_PRODUCTS);
+      eigen_assert( (Option==LazyProduct) || (this->rows() == 1 && this->cols() == 1) );
+      
+      return internal::evaluator<Derived>(derived()).coeff(row,col);
+    }
+
+    EIGEN_DEVICE_FUNC Scalar coeff(Index i) const
+    {
+      EIGEN_STATIC_ASSERT(EnableCoeff, THIS_METHOD_IS_ONLY_FOR_INNER_OR_LAZY_PRODUCTS);
+      eigen_assert( (Option==LazyProduct) || (this->rows() == 1 && this->cols() == 1) );
+      
+      return internal::evaluator<Derived>(derived()).coeff(i);
+    }
+    
+  
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_PRODUCT_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/ProductEvaluators.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/ProductEvaluators.h
new file mode 100644
index 00000000..86966abd
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/ProductEvaluators.h
@@ -0,0 +1,1105 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2011 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+#ifndef EIGEN_PRODUCTEVALUATORS_H
+#define EIGEN_PRODUCTEVALUATORS_H
+
+namespace Eigen {
+  
+namespace internal {
+
+/** \internal
+  * Evaluator of a product expression.
+  * Since products require special treatments to handle all possible cases,
+  * we simply deffer the evaluation logic to a product_evaluator class
+  * which offers more partial specialization possibilities.
+  * 
+  * \sa class product_evaluator
+  */
+template<typename Lhs, typename Rhs, int Options>
+struct evaluator<Product<Lhs, Rhs, Options> > 
+ : public product_evaluator<Product<Lhs, Rhs, Options> >
+{
+  typedef Product<Lhs, Rhs, Options> XprType;
+  typedef product_evaluator<XprType> Base;
+  
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr) : Base(xpr) {}
+};
+ 
+// Catch "scalar * ( A * B )" and transform it to "(A*scalar) * B"
+// TODO we should apply that rule only if that's really helpful
+template<typename Lhs, typename Rhs, typename Scalar1, typename Scalar2, typename Plain1>
+struct evaluator_assume_aliasing<CwiseBinaryOp<internal::scalar_product_op<Scalar1,Scalar2>,
+                                               const CwiseNullaryOp<internal::scalar_constant_op<Scalar1>, Plain1>,
+                                               const Product<Lhs, Rhs, DefaultProduct> > >
+{
+  static const bool value = true;
+};
+template<typename Lhs, typename Rhs, typename Scalar1, typename Scalar2, typename Plain1>
+struct evaluator<CwiseBinaryOp<internal::scalar_product_op<Scalar1,Scalar2>,
+                               const CwiseNullaryOp<internal::scalar_constant_op<Scalar1>, Plain1>,
+                               const Product<Lhs, Rhs, DefaultProduct> > >
+ : public evaluator<Product<EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar1,Lhs,product), Rhs, DefaultProduct> >
+{
+  typedef CwiseBinaryOp<internal::scalar_product_op<Scalar1,Scalar2>,
+                               const CwiseNullaryOp<internal::scalar_constant_op<Scalar1>, Plain1>,
+                               const Product<Lhs, Rhs, DefaultProduct> > XprType;
+  typedef evaluator<Product<EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar1,Lhs,product), Rhs, DefaultProduct> > Base;
+
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr)
+    : Base(xpr.lhs().functor().m_other * xpr.rhs().lhs() * xpr.rhs().rhs())
+  {}
+};
+
+
+template<typename Lhs, typename Rhs, int DiagIndex>
+struct evaluator<Diagonal<const Product<Lhs, Rhs, DefaultProduct>, DiagIndex> > 
+ : public evaluator<Diagonal<const Product<Lhs, Rhs, LazyProduct>, DiagIndex> >
+{
+  typedef Diagonal<const Product<Lhs, Rhs, DefaultProduct>, DiagIndex> XprType;
+  typedef evaluator<Diagonal<const Product<Lhs, Rhs, LazyProduct>, DiagIndex> > Base;
+  
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr)
+    : Base(Diagonal<const Product<Lhs, Rhs, LazyProduct>, DiagIndex>(
+        Product<Lhs, Rhs, LazyProduct>(xpr.nestedExpression().lhs(), xpr.nestedExpression().rhs()),
+        xpr.index() ))
+  {}
+};
+
+
+// Helper class to perform a matrix product with the destination at hand.
+// Depending on the sizes of the factors, there are different evaluation strategies
+// as controlled by internal::product_type.
+template< typename Lhs, typename Rhs,
+          typename LhsShape = typename evaluator_traits<Lhs>::Shape,
+          typename RhsShape = typename evaluator_traits<Rhs>::Shape,
+          int ProductType = internal::product_type<Lhs,Rhs>::value>
+struct generic_product_impl;
+
+template<typename Lhs, typename Rhs>
+struct evaluator_assume_aliasing<Product<Lhs, Rhs, DefaultProduct> > {
+  static const bool value = true;
+};
+
+// This is the default evaluator implementation for products:
+// It creates a temporary and call generic_product_impl
+template<typename Lhs, typename Rhs, int Options, int ProductTag, typename LhsShape, typename RhsShape>
+struct product_evaluator<Product<Lhs, Rhs, Options>, ProductTag, LhsShape, RhsShape>
+  : public evaluator<typename Product<Lhs, Rhs, Options>::PlainObject>
+{
+  typedef Product<Lhs, Rhs, Options> XprType;
+  typedef typename XprType::PlainObject PlainObject;
+  typedef evaluator<PlainObject> Base;
+  enum {
+    Flags = Base::Flags | EvalBeforeNestingBit
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit product_evaluator(const XprType& xpr)
+    : m_result(xpr.rows(), xpr.cols())
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+    
+// FIXME shall we handle nested_eval here?,
+// if so, then we must take care at removing the call to nested_eval in the specializations (e.g., in permutation_matrix_product, transposition_matrix_product, etc.)
+//     typedef typename internal::nested_eval<Lhs,Rhs::ColsAtCompileTime>::type LhsNested;
+//     typedef typename internal::nested_eval<Rhs,Lhs::RowsAtCompileTime>::type RhsNested;
+//     typedef typename internal::remove_all<LhsNested>::type LhsNestedCleaned;
+//     typedef typename internal::remove_all<RhsNested>::type RhsNestedCleaned;
+//     
+//     const LhsNested lhs(xpr.lhs());
+//     const RhsNested rhs(xpr.rhs());
+//   
+//     generic_product_impl<LhsNestedCleaned, RhsNestedCleaned>::evalTo(m_result, lhs, rhs);
+
+    generic_product_impl<Lhs, Rhs, LhsShape, RhsShape, ProductTag>::evalTo(m_result, xpr.lhs(), xpr.rhs());
+  }
+  
+protected:  
+  PlainObject m_result;
+};
+
+// The following three shortcuts are enabled only if the scalar types match excatly.
+// TODO: we could enable them for different scalar types when the product is not vectorized.
+
+// Dense = Product
+template< typename DstXprType, typename Lhs, typename Rhs, int Options, typename Scalar>
+struct Assignment<DstXprType, Product<Lhs,Rhs,Options>, internal::assign_op<Scalar,Scalar>, Dense2Dense,
+  typename enable_if<(Options==DefaultProduct || Options==AliasFreeProduct)>::type>
+{
+  typedef Product<Lhs,Rhs,Options> SrcXprType;
+  static EIGEN_STRONG_INLINE
+  void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+    // FIXME shall we handle nested_eval here?
+    generic_product_impl<Lhs, Rhs>::evalTo(dst, src.lhs(), src.rhs());
+  }
+};
+
+// Dense += Product
+template< typename DstXprType, typename Lhs, typename Rhs, int Options, typename Scalar>
+struct Assignment<DstXprType, Product<Lhs,Rhs,Options>, internal::add_assign_op<Scalar,Scalar>, Dense2Dense,
+  typename enable_if<(Options==DefaultProduct || Options==AliasFreeProduct)>::type>
+{
+  typedef Product<Lhs,Rhs,Options> SrcXprType;
+  static EIGEN_STRONG_INLINE
+  void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<Scalar,Scalar> &)
+  {
+    eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
+    // FIXME shall we handle nested_eval here?
+    generic_product_impl<Lhs, Rhs>::addTo(dst, src.lhs(), src.rhs());
+  }
+};
+
+// Dense -= Product
+template< typename DstXprType, typename Lhs, typename Rhs, int Options, typename Scalar>
+struct Assignment<DstXprType, Product<Lhs,Rhs,Options>, internal::sub_assign_op<Scalar,Scalar>, Dense2Dense,
+  typename enable_if<(Options==DefaultProduct || Options==AliasFreeProduct)>::type>
+{
+  typedef Product<Lhs,Rhs,Options> SrcXprType;
+  static EIGEN_STRONG_INLINE
+  void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<Scalar,Scalar> &)
+  {
+    eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
+    // FIXME shall we handle nested_eval here?
+    generic_product_impl<Lhs, Rhs>::subTo(dst, src.lhs(), src.rhs());
+  }
+};
+
+
+// Dense ?= scalar * Product
+// TODO we should apply that rule if that's really helpful
+// for instance, this is not good for inner products
+template< typename DstXprType, typename Lhs, typename Rhs, typename AssignFunc, typename Scalar, typename ScalarBis, typename Plain>
+struct Assignment<DstXprType, CwiseBinaryOp<internal::scalar_product_op<ScalarBis,Scalar>, const CwiseNullaryOp<internal::scalar_constant_op<ScalarBis>,Plain>,
+                                           const Product<Lhs,Rhs,DefaultProduct> >, AssignFunc, Dense2Dense>
+{
+  typedef CwiseBinaryOp<internal::scalar_product_op<ScalarBis,Scalar>,
+                        const CwiseNullaryOp<internal::scalar_constant_op<ScalarBis>,Plain>,
+                        const Product<Lhs,Rhs,DefaultProduct> > SrcXprType;
+  static EIGEN_STRONG_INLINE
+  void run(DstXprType &dst, const SrcXprType &src, const AssignFunc& func)
+  {
+    call_assignment_no_alias(dst, (src.lhs().functor().m_other * src.rhs().lhs())*src.rhs().rhs(), func);
+  }
+};
+
+//----------------------------------------
+// Catch "Dense ?= xpr + Product<>" expression to save one temporary
+// FIXME we could probably enable these rules for any product, i.e., not only Dense and DefaultProduct
+
+template<typename OtherXpr, typename Lhs, typename Rhs>
+struct evaluator_assume_aliasing<CwiseBinaryOp<internal::scalar_sum_op<typename OtherXpr::Scalar,typename Product<Lhs,Rhs,DefaultProduct>::Scalar>, const OtherXpr,
+                                               const Product<Lhs,Rhs,DefaultProduct> >, DenseShape > {
+  static const bool value = true;
+};
+
+template<typename OtherXpr, typename Lhs, typename Rhs>
+struct evaluator_assume_aliasing<CwiseBinaryOp<internal::scalar_difference_op<typename OtherXpr::Scalar,typename Product<Lhs,Rhs,DefaultProduct>::Scalar>, const OtherXpr,
+                                               const Product<Lhs,Rhs,DefaultProduct> >, DenseShape > {
+  static const bool value = true;
+};
+
+template<typename DstXprType, typename OtherXpr, typename ProductType, typename Func1, typename Func2>
+struct assignment_from_xpr_op_product
+{
+  template<typename SrcXprType, typename InitialFunc>
+  static EIGEN_STRONG_INLINE
+  void run(DstXprType &dst, const SrcXprType &src, const InitialFunc& /*func*/)
+  {
+    call_assignment_no_alias(dst, src.lhs(), Func1());
+    call_assignment_no_alias(dst, src.rhs(), Func2());
+  }
+};
+
+#define EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT(ASSIGN_OP,BINOP,ASSIGN_OP2) \
+  template< typename DstXprType, typename OtherXpr, typename Lhs, typename Rhs, typename DstScalar, typename SrcScalar, typename OtherScalar,typename ProdScalar> \
+  struct Assignment<DstXprType, CwiseBinaryOp<internal::BINOP<OtherScalar,ProdScalar>, const OtherXpr, \
+                                            const Product<Lhs,Rhs,DefaultProduct> >, internal::ASSIGN_OP<DstScalar,SrcScalar>, Dense2Dense> \
+    : assignment_from_xpr_op_product<DstXprType, OtherXpr, Product<Lhs,Rhs,DefaultProduct>, internal::ASSIGN_OP<DstScalar,OtherScalar>, internal::ASSIGN_OP2<DstScalar,ProdScalar> > \
+  {}
+
+EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT(assign_op,    scalar_sum_op,add_assign_op);
+EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT(add_assign_op,scalar_sum_op,add_assign_op);
+EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT(sub_assign_op,scalar_sum_op,sub_assign_op);
+
+EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT(assign_op,    scalar_difference_op,sub_assign_op);
+EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT(add_assign_op,scalar_difference_op,sub_assign_op);
+EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT(sub_assign_op,scalar_difference_op,add_assign_op);
+
+//----------------------------------------
+
+template<typename Lhs, typename Rhs>
+struct generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,InnerProduct>
+{
+  template<typename Dst>
+  static inline void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    dst.coeffRef(0,0) = (lhs.transpose().cwiseProduct(rhs)).sum();
+  }
+  
+  template<typename Dst>
+  static inline void addTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    dst.coeffRef(0,0) += (lhs.transpose().cwiseProduct(rhs)).sum();
+  }
+  
+  template<typename Dst>
+  static void subTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  { dst.coeffRef(0,0) -= (lhs.transpose().cwiseProduct(rhs)).sum(); }
+};
+
+
+/***********************************************************************
+*  Implementation of outer dense * dense vector product
+***********************************************************************/
+
+// Column major result
+template<typename Dst, typename Lhs, typename Rhs, typename Func>
+void outer_product_selector_run(Dst& dst, const Lhs &lhs, const Rhs &rhs, const Func& func, const false_type&)
+{
+  evaluator<Rhs> rhsEval(rhs);
+  typename nested_eval<Lhs,Rhs::SizeAtCompileTime>::type actual_lhs(lhs);
+  // FIXME if cols is large enough, then it might be useful to make sure that lhs is sequentially stored
+  // FIXME not very good if rhs is real and lhs complex while alpha is real too
+  const Index cols = dst.cols();
+  for (Index j=0; j<cols; ++j)
+    func(dst.col(j), rhsEval.coeff(Index(0),j) * actual_lhs);
+}
+
+// Row major result
+template<typename Dst, typename Lhs, typename Rhs, typename Func>
+void outer_product_selector_run(Dst& dst, const Lhs &lhs, const Rhs &rhs, const Func& func, const true_type&)
+{
+  evaluator<Lhs> lhsEval(lhs);
+  typename nested_eval<Rhs,Lhs::SizeAtCompileTime>::type actual_rhs(rhs);
+  // FIXME if rows is large enough, then it might be useful to make sure that rhs is sequentially stored
+  // FIXME not very good if lhs is real and rhs complex while alpha is real too
+  const Index rows = dst.rows();
+  for (Index i=0; i<rows; ++i)
+    func(dst.row(i), lhsEval.coeff(i,Index(0)) * actual_rhs);
+}
+
+template<typename Lhs, typename Rhs>
+struct generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,OuterProduct>
+{
+  template<typename T> struct is_row_major : internal::conditional<(int(T::Flags)&RowMajorBit), internal::true_type, internal::false_type>::type {};
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+  
+  // TODO it would be nice to be able to exploit our *_assign_op functors for that purpose
+  struct set  { template<typename Dst, typename Src> void operator()(const Dst& dst, const Src& src) const { dst.const_cast_derived()  = src; } };
+  struct add  { template<typename Dst, typename Src> void operator()(const Dst& dst, const Src& src) const { dst.const_cast_derived() += src; } };
+  struct sub  { template<typename Dst, typename Src> void operator()(const Dst& dst, const Src& src) const { dst.const_cast_derived() -= src; } };
+  struct adds {
+    Scalar m_scale;
+    explicit adds(const Scalar& s) : m_scale(s) {}
+    template<typename Dst, typename Src> void operator()(const Dst& dst, const Src& src) const {
+      dst.const_cast_derived() += m_scale * src;
+    }
+  };
+  
+  template<typename Dst>
+  static inline void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    internal::outer_product_selector_run(dst, lhs, rhs, set(), is_row_major<Dst>());
+  }
+  
+  template<typename Dst>
+  static inline void addTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    internal::outer_product_selector_run(dst, lhs, rhs, add(), is_row_major<Dst>());
+  }
+  
+  template<typename Dst>
+  static inline void subTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    internal::outer_product_selector_run(dst, lhs, rhs, sub(), is_row_major<Dst>());
+  }
+  
+  template<typename Dst>
+  static inline void scaleAndAddTo(Dst& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
+  {
+    internal::outer_product_selector_run(dst, lhs, rhs, adds(alpha), is_row_major<Dst>());
+  }
+  
+};
+
+
+// This base class provides default implementations for evalTo, addTo, subTo, in terms of scaleAndAddTo
+template<typename Lhs, typename Rhs, typename Derived>
+struct generic_product_impl_base
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+  
+  template<typename Dst>
+  static EIGEN_STRONG_INLINE void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  { dst.setZero(); scaleAndAddTo(dst, lhs, rhs, Scalar(1)); }
+
+  template<typename Dst>
+  static EIGEN_STRONG_INLINE void addTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  { scaleAndAddTo(dst,lhs, rhs, Scalar(1)); }
+
+  template<typename Dst>
+  static EIGEN_STRONG_INLINE void subTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  { scaleAndAddTo(dst, lhs, rhs, Scalar(-1)); }
+  
+  template<typename Dst>
+  static EIGEN_STRONG_INLINE void scaleAndAddTo(Dst& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
+  { Derived::scaleAndAddTo(dst,lhs,rhs,alpha); }
+
+};
+
+template<typename Lhs, typename Rhs>
+struct generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,GemvProduct>
+  : generic_product_impl_base<Lhs,Rhs,generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,GemvProduct> >
+{
+  typedef typename nested_eval<Lhs,1>::type LhsNested;
+  typedef typename nested_eval<Rhs,1>::type RhsNested;
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+  enum { Side = Lhs::IsVectorAtCompileTime ? OnTheLeft : OnTheRight };
+  typedef typename internal::remove_all<typename internal::conditional<int(Side)==OnTheRight,LhsNested,RhsNested>::type>::type MatrixType;
+
+  template<typename Dest>
+  static EIGEN_STRONG_INLINE void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
+  {
+    LhsNested actual_lhs(lhs);
+    RhsNested actual_rhs(rhs);
+    internal::gemv_dense_selector<Side,
+                            (int(MatrixType::Flags)&RowMajorBit) ? RowMajor : ColMajor,
+                            bool(internal::blas_traits<MatrixType>::HasUsableDirectAccess)
+                           >::run(actual_lhs, actual_rhs, dst, alpha);
+  }
+};
+
+template<typename Lhs, typename Rhs>
+struct generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,CoeffBasedProductMode> 
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+  
+  template<typename Dst>
+  static EIGEN_STRONG_INLINE void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    // Same as: dst.noalias() = lhs.lazyProduct(rhs);
+    // but easier on the compiler side
+    call_assignment_no_alias(dst, lhs.lazyProduct(rhs), internal::assign_op<typename Dst::Scalar,Scalar>());
+  }
+  
+  template<typename Dst>
+  static EIGEN_STRONG_INLINE void addTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    // dst.noalias() += lhs.lazyProduct(rhs);
+    call_assignment_no_alias(dst, lhs.lazyProduct(rhs), internal::add_assign_op<typename Dst::Scalar,Scalar>());
+  }
+  
+  template<typename Dst>
+  static EIGEN_STRONG_INLINE void subTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    // dst.noalias() -= lhs.lazyProduct(rhs);
+    call_assignment_no_alias(dst, lhs.lazyProduct(rhs), internal::sub_assign_op<typename Dst::Scalar,Scalar>());
+  }
+  
+//   template<typename Dst>
+//   static inline void scaleAndAddTo(Dst& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
+//   { dst.noalias() += alpha * lhs.lazyProduct(rhs); }
+};
+
+// This specialization enforces the use of a coefficient-based evaluation strategy
+template<typename Lhs, typename Rhs>
+struct generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,LazyCoeffBasedProductMode>
+  : generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,CoeffBasedProductMode> {};
+
+// Case 2: Evaluate coeff by coeff
+//
+// This is mostly taken from CoeffBasedProduct.h
+// The main difference is that we add an extra argument to the etor_product_*_impl::run() function
+// for the inner dimension of the product, because evaluator object do not know their size.
+
+template<int Traversal, int UnrollingIndex, typename Lhs, typename Rhs, typename RetScalar>
+struct etor_product_coeff_impl;
+
+template<int StorageOrder, int UnrollingIndex, typename Lhs, typename Rhs, typename Packet, int LoadMode>
+struct etor_product_packet_impl;
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, LazyProduct>, ProductTag, DenseShape, DenseShape>
+    : evaluator_base<Product<Lhs, Rhs, LazyProduct> >
+{
+  typedef Product<Lhs, Rhs, LazyProduct> XprType;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit product_evaluator(const XprType& xpr)
+    : m_lhs(xpr.lhs()),
+      m_rhs(xpr.rhs()),
+      m_lhsImpl(m_lhs),     // FIXME the creation of the evaluator objects should result in a no-op, but check that!
+      m_rhsImpl(m_rhs),     //       Moreover, they are only useful for the packet path, so we could completely disable them when not needed,
+                            //       or perhaps declare them on the fly on the packet method... We have experiment to check what's best.
+      m_innerDim(xpr.lhs().cols())
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(NumTraits<Scalar>::MulCost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(NumTraits<Scalar>::AddCost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+#if 0
+    std::cerr << "LhsOuterStrideBytes=  " << LhsOuterStrideBytes << "\n";
+    std::cerr << "RhsOuterStrideBytes=  " << RhsOuterStrideBytes << "\n";
+    std::cerr << "LhsAlignment=         " << LhsAlignment << "\n";
+    std::cerr << "RhsAlignment=         " << RhsAlignment << "\n";
+    std::cerr << "CanVectorizeLhs=      " << CanVectorizeLhs << "\n";
+    std::cerr << "CanVectorizeRhs=      " << CanVectorizeRhs << "\n";
+    std::cerr << "CanVectorizeInner=    " << CanVectorizeInner << "\n";
+    std::cerr << "EvalToRowMajor=       " << EvalToRowMajor << "\n";
+    std::cerr << "Alignment=            " << Alignment << "\n";
+    std::cerr << "Flags=                " << Flags << "\n";
+#endif
+  }
+
+  // Everything below here is taken from CoeffBasedProduct.h
+
+  typedef typename internal::nested_eval<Lhs,Rhs::ColsAtCompileTime>::type LhsNested;
+  typedef typename internal::nested_eval<Rhs,Lhs::RowsAtCompileTime>::type RhsNested;
+  
+  typedef typename internal::remove_all<LhsNested>::type LhsNestedCleaned;
+  typedef typename internal::remove_all<RhsNested>::type RhsNestedCleaned;
+
+  typedef evaluator<LhsNestedCleaned> LhsEtorType;
+  typedef evaluator<RhsNestedCleaned> RhsEtorType;
+
+  enum {
+    RowsAtCompileTime = LhsNestedCleaned::RowsAtCompileTime,
+    ColsAtCompileTime = RhsNestedCleaned::ColsAtCompileTime,
+    InnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(LhsNestedCleaned::ColsAtCompileTime, RhsNestedCleaned::RowsAtCompileTime),
+    MaxRowsAtCompileTime = LhsNestedCleaned::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = RhsNestedCleaned::MaxColsAtCompileTime
+  };
+
+  typedef typename find_best_packet<Scalar,RowsAtCompileTime>::type LhsVecPacketType;
+  typedef typename find_best_packet<Scalar,ColsAtCompileTime>::type RhsVecPacketType;
+
+  enum {
+      
+    LhsCoeffReadCost = LhsEtorType::CoeffReadCost,
+    RhsCoeffReadCost = RhsEtorType::CoeffReadCost,
+    CoeffReadCost = InnerSize==0 ? NumTraits<Scalar>::ReadCost
+                  : InnerSize == Dynamic ? HugeCost
+                  : InnerSize * (NumTraits<Scalar>::MulCost + LhsCoeffReadCost + RhsCoeffReadCost)
+                    + (InnerSize - 1) * NumTraits<Scalar>::AddCost,
+
+    Unroll = CoeffReadCost <= EIGEN_UNROLLING_LIMIT,
+    
+    LhsFlags = LhsEtorType::Flags,
+    RhsFlags = RhsEtorType::Flags,
+    
+    LhsRowMajor = LhsFlags & RowMajorBit,
+    RhsRowMajor = RhsFlags & RowMajorBit,
+
+    LhsVecPacketSize = unpacket_traits<LhsVecPacketType>::size,
+    RhsVecPacketSize = unpacket_traits<RhsVecPacketType>::size,
+
+    // Here, we don't care about alignment larger than the usable packet size.
+    LhsAlignment = EIGEN_PLAIN_ENUM_MIN(LhsEtorType::Alignment,LhsVecPacketSize*int(sizeof(typename LhsNestedCleaned::Scalar))),
+    RhsAlignment = EIGEN_PLAIN_ENUM_MIN(RhsEtorType::Alignment,RhsVecPacketSize*int(sizeof(typename RhsNestedCleaned::Scalar))),
+      
+    SameType = is_same<typename LhsNestedCleaned::Scalar,typename RhsNestedCleaned::Scalar>::value,
+
+    CanVectorizeRhs = bool(RhsRowMajor) && (RhsFlags & PacketAccessBit) && (ColsAtCompileTime!=1),
+    CanVectorizeLhs = (!LhsRowMajor) && (LhsFlags & PacketAccessBit) && (RowsAtCompileTime!=1),
+
+    EvalToRowMajor = (MaxRowsAtCompileTime==1&&MaxColsAtCompileTime!=1) ? 1
+                    : (MaxColsAtCompileTime==1&&MaxRowsAtCompileTime!=1) ? 0
+                    : (bool(RhsRowMajor) && !CanVectorizeLhs),
+
+    Flags = ((unsigned int)(LhsFlags | RhsFlags) & HereditaryBits & ~RowMajorBit)
+          | (EvalToRowMajor ? RowMajorBit : 0)
+          // TODO enable vectorization for mixed types
+          | (SameType && (CanVectorizeLhs || CanVectorizeRhs) ? PacketAccessBit : 0)
+          | (XprType::IsVectorAtCompileTime ? LinearAccessBit : 0),
+          
+    LhsOuterStrideBytes = int(LhsNestedCleaned::OuterStrideAtCompileTime) * int(sizeof(typename LhsNestedCleaned::Scalar)),
+    RhsOuterStrideBytes = int(RhsNestedCleaned::OuterStrideAtCompileTime) * int(sizeof(typename RhsNestedCleaned::Scalar)),
+
+    Alignment = bool(CanVectorizeLhs) ? (LhsOuterStrideBytes<=0 || (int(LhsOuterStrideBytes) % EIGEN_PLAIN_ENUM_MAX(1,LhsAlignment))!=0 ? 0 : LhsAlignment)
+              : bool(CanVectorizeRhs) ? (RhsOuterStrideBytes<=0 || (int(RhsOuterStrideBytes) % EIGEN_PLAIN_ENUM_MAX(1,RhsAlignment))!=0 ? 0 : RhsAlignment)
+              : 0,
+
+    /* CanVectorizeInner deserves special explanation. It does not affect the product flags. It is not used outside
+     * of Product. If the Product itself is not a packet-access expression, there is still a chance that the inner
+     * loop of the product might be vectorized. This is the meaning of CanVectorizeInner. Since it doesn't affect
+     * the Flags, it is safe to make this value depend on ActualPacketAccessBit, that doesn't affect the ABI.
+     */
+    CanVectorizeInner =    SameType
+                        && LhsRowMajor
+                        && (!RhsRowMajor)
+                        && (LhsFlags & RhsFlags & ActualPacketAccessBit)
+                        && (InnerSize % packet_traits<Scalar>::size == 0)
+  };
+  
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const CoeffReturnType coeff(Index row, Index col) const
+  {
+    return (m_lhs.row(row).transpose().cwiseProduct( m_rhs.col(col) )).sum();
+  }
+
+  /* Allow index-based non-packet access. It is impossible though to allow index-based packed access,
+   * which is why we don't set the LinearAccessBit.
+   * TODO: this seems possible when the result is a vector
+   */
+  EIGEN_DEVICE_FUNC const CoeffReturnType coeff(Index index) const
+  {
+    const Index row = (RowsAtCompileTime == 1 || MaxRowsAtCompileTime==1) ? 0 : index;
+    const Index col = (RowsAtCompileTime == 1 || MaxRowsAtCompileTime==1) ? index : 0;
+    return (m_lhs.row(row).transpose().cwiseProduct( m_rhs.col(col) )).sum();
+  }
+
+  template<int LoadMode, typename PacketType>
+  const PacketType packet(Index row, Index col) const
+  {
+    PacketType res;
+    typedef etor_product_packet_impl<bool(int(Flags)&RowMajorBit) ? RowMajor : ColMajor,
+                                     Unroll ? int(InnerSize) : Dynamic,
+                                     LhsEtorType, RhsEtorType, PacketType, LoadMode> PacketImpl;
+    PacketImpl::run(row, col, m_lhsImpl, m_rhsImpl, m_innerDim, res);
+    return res;
+  }
+
+  template<int LoadMode, typename PacketType>
+  const PacketType packet(Index index) const
+  {
+    const Index row = (RowsAtCompileTime == 1 || MaxRowsAtCompileTime==1) ? 0 : index;
+    const Index col = (RowsAtCompileTime == 1 || MaxRowsAtCompileTime==1) ? index : 0;
+    return packet<LoadMode,PacketType>(row,col);
+  }
+
+protected:
+  typename internal::add_const_on_value_type<LhsNested>::type m_lhs;
+  typename internal::add_const_on_value_type<RhsNested>::type m_rhs;
+  
+  LhsEtorType m_lhsImpl;
+  RhsEtorType m_rhsImpl;
+
+  // TODO: Get rid of m_innerDim if known at compile time
+  Index m_innerDim;
+};
+
+template<typename Lhs, typename Rhs>
+struct product_evaluator<Product<Lhs, Rhs, DefaultProduct>, LazyCoeffBasedProductMode, DenseShape, DenseShape>
+  : product_evaluator<Product<Lhs, Rhs, LazyProduct>, CoeffBasedProductMode, DenseShape, DenseShape>
+{
+  typedef Product<Lhs, Rhs, DefaultProduct> XprType;
+  typedef Product<Lhs, Rhs, LazyProduct> BaseProduct;
+  typedef product_evaluator<BaseProduct, CoeffBasedProductMode, DenseShape, DenseShape> Base;
+  enum {
+    Flags = Base::Flags | EvalBeforeNestingBit
+  };
+  EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
+    : Base(BaseProduct(xpr.lhs(),xpr.rhs()))
+  {}
+};
+
+/****************************************
+*** Coeff based product, Packet path  ***
+****************************************/
+
+template<int UnrollingIndex, typename Lhs, typename Rhs, typename Packet, int LoadMode>
+struct etor_product_packet_impl<RowMajor, UnrollingIndex, Lhs, Rhs, Packet, LoadMode>
+{
+  static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Index innerDim, Packet &res)
+  {
+    etor_product_packet_impl<RowMajor, UnrollingIndex-1, Lhs, Rhs, Packet, LoadMode>::run(row, col, lhs, rhs, innerDim, res);
+    res =  pmadd(pset1<Packet>(lhs.coeff(row, Index(UnrollingIndex-1))), rhs.template packet<LoadMode,Packet>(Index(UnrollingIndex-1), col), res);
+  }
+};
+
+template<int UnrollingIndex, typename Lhs, typename Rhs, typename Packet, int LoadMode>
+struct etor_product_packet_impl<ColMajor, UnrollingIndex, Lhs, Rhs, Packet, LoadMode>
+{
+  static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Index innerDim, Packet &res)
+  {
+    etor_product_packet_impl<ColMajor, UnrollingIndex-1, Lhs, Rhs, Packet, LoadMode>::run(row, col, lhs, rhs, innerDim, res);
+    res =  pmadd(lhs.template packet<LoadMode,Packet>(row, Index(UnrollingIndex-1)), pset1<Packet>(rhs.coeff(Index(UnrollingIndex-1), col)), res);
+  }
+};
+
+template<typename Lhs, typename Rhs, typename Packet, int LoadMode>
+struct etor_product_packet_impl<RowMajor, 1, Lhs, Rhs, Packet, LoadMode>
+{
+  static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Index /*innerDim*/, Packet &res)
+  {
+    res = pmul(pset1<Packet>(lhs.coeff(row, Index(0))),rhs.template packet<LoadMode,Packet>(Index(0), col));
+  }
+};
+
+template<typename Lhs, typename Rhs, typename Packet, int LoadMode>
+struct etor_product_packet_impl<ColMajor, 1, Lhs, Rhs, Packet, LoadMode>
+{
+  static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Index /*innerDim*/, Packet &res)
+  {
+    res = pmul(lhs.template packet<LoadMode,Packet>(row, Index(0)), pset1<Packet>(rhs.coeff(Index(0), col)));
+  }
+};
+
+template<typename Lhs, typename Rhs, typename Packet, int LoadMode>
+struct etor_product_packet_impl<RowMajor, 0, Lhs, Rhs, Packet, LoadMode>
+{
+  static EIGEN_STRONG_INLINE void run(Index /*row*/, Index /*col*/, const Lhs& /*lhs*/, const Rhs& /*rhs*/, Index /*innerDim*/, Packet &res)
+  {
+    res = pset1<Packet>(typename unpacket_traits<Packet>::type(0));
+  }
+};
+
+template<typename Lhs, typename Rhs, typename Packet, int LoadMode>
+struct etor_product_packet_impl<ColMajor, 0, Lhs, Rhs, Packet, LoadMode>
+{
+  static EIGEN_STRONG_INLINE void run(Index /*row*/, Index /*col*/, const Lhs& /*lhs*/, const Rhs& /*rhs*/, Index /*innerDim*/, Packet &res)
+  {
+    res = pset1<Packet>(typename unpacket_traits<Packet>::type(0));
+  }
+};
+
+template<typename Lhs, typename Rhs, typename Packet, int LoadMode>
+struct etor_product_packet_impl<RowMajor, Dynamic, Lhs, Rhs, Packet, LoadMode>
+{
+  static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Index innerDim, Packet& res)
+  {
+    res = pset1<Packet>(typename unpacket_traits<Packet>::type(0));
+    for(Index i = 0; i < innerDim; ++i)
+      res =  pmadd(pset1<Packet>(lhs.coeff(row, i)), rhs.template packet<LoadMode,Packet>(i, col), res);
+  }
+};
+
+template<typename Lhs, typename Rhs, typename Packet, int LoadMode>
+struct etor_product_packet_impl<ColMajor, Dynamic, Lhs, Rhs, Packet, LoadMode>
+{
+  static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Index innerDim, Packet& res)
+  {
+    res = pset1<Packet>(typename unpacket_traits<Packet>::type(0));
+    for(Index i = 0; i < innerDim; ++i)
+      res =  pmadd(lhs.template packet<LoadMode,Packet>(row, i), pset1<Packet>(rhs.coeff(i, col)), res);
+  }
+};
+
+
+/***************************************************************************
+* Triangular products
+***************************************************************************/
+template<int Mode, bool LhsIsTriangular,
+         typename Lhs, bool LhsIsVector,
+         typename Rhs, bool RhsIsVector>
+struct triangular_product_impl;
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct generic_product_impl<Lhs,Rhs,TriangularShape,DenseShape,ProductTag>
+  : generic_product_impl_base<Lhs,Rhs,generic_product_impl<Lhs,Rhs,TriangularShape,DenseShape,ProductTag> >
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+  
+  template<typename Dest>
+  static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
+  {
+    triangular_product_impl<Lhs::Mode,true,typename Lhs::MatrixType,false,Rhs, Rhs::ColsAtCompileTime==1>
+        ::run(dst, lhs.nestedExpression(), rhs, alpha);
+  }
+};
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct generic_product_impl<Lhs,Rhs,DenseShape,TriangularShape,ProductTag>
+: generic_product_impl_base<Lhs,Rhs,generic_product_impl<Lhs,Rhs,DenseShape,TriangularShape,ProductTag> >
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+  
+  template<typename Dest>
+  static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
+  {
+    triangular_product_impl<Rhs::Mode,false,Lhs,Lhs::RowsAtCompileTime==1, typename Rhs::MatrixType, false>::run(dst, lhs, rhs.nestedExpression(), alpha);
+  }
+};
+
+
+/***************************************************************************
+* SelfAdjoint products
+***************************************************************************/
+template <typename Lhs, int LhsMode, bool LhsIsVector,
+          typename Rhs, int RhsMode, bool RhsIsVector>
+struct selfadjoint_product_impl;
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct generic_product_impl<Lhs,Rhs,SelfAdjointShape,DenseShape,ProductTag>
+  : generic_product_impl_base<Lhs,Rhs,generic_product_impl<Lhs,Rhs,SelfAdjointShape,DenseShape,ProductTag> >
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+  
+  template<typename Dest>
+  static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
+  {
+    selfadjoint_product_impl<typename Lhs::MatrixType,Lhs::Mode,false,Rhs,0,Rhs::IsVectorAtCompileTime>::run(dst, lhs.nestedExpression(), rhs, alpha);
+  }
+};
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct generic_product_impl<Lhs,Rhs,DenseShape,SelfAdjointShape,ProductTag>
+: generic_product_impl_base<Lhs,Rhs,generic_product_impl<Lhs,Rhs,DenseShape,SelfAdjointShape,ProductTag> >
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+  
+  template<typename Dest>
+  static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
+  {
+    selfadjoint_product_impl<Lhs,0,Lhs::IsVectorAtCompileTime,typename Rhs::MatrixType,Rhs::Mode,false>::run(dst, lhs, rhs.nestedExpression(), alpha);
+  }
+};
+
+
+/***************************************************************************
+* Diagonal products
+***************************************************************************/
+  
+template<typename MatrixType, typename DiagonalType, typename Derived, int ProductOrder>
+struct diagonal_product_evaluator_base
+  : evaluator_base<Derived>
+{
+   typedef typename ScalarBinaryOpTraits<typename MatrixType::Scalar, typename DiagonalType::Scalar>::ReturnType Scalar;
+public:
+  enum {
+    CoeffReadCost = NumTraits<Scalar>::MulCost + evaluator<MatrixType>::CoeffReadCost + evaluator<DiagonalType>::CoeffReadCost,
+    
+    MatrixFlags = evaluator<MatrixType>::Flags,
+    DiagFlags = evaluator<DiagonalType>::Flags,
+    _StorageOrder = MatrixFlags & RowMajorBit ? RowMajor : ColMajor,
+    _ScalarAccessOnDiag =  !((int(_StorageOrder) == ColMajor && int(ProductOrder) == OnTheLeft)
+                           ||(int(_StorageOrder) == RowMajor && int(ProductOrder) == OnTheRight)),
+    _SameTypes = is_same<typename MatrixType::Scalar, typename DiagonalType::Scalar>::value,
+    // FIXME currently we need same types, but in the future the next rule should be the one
+    //_Vectorizable = bool(int(MatrixFlags)&PacketAccessBit) && ((!_PacketOnDiag) || (_SameTypes && bool(int(DiagFlags)&PacketAccessBit))),
+    _Vectorizable = bool(int(MatrixFlags)&PacketAccessBit) && _SameTypes && (_ScalarAccessOnDiag || (bool(int(DiagFlags)&PacketAccessBit))),
+    _LinearAccessMask = (MatrixType::RowsAtCompileTime==1 || MatrixType::ColsAtCompileTime==1) ? LinearAccessBit : 0,
+    Flags = ((HereditaryBits|_LinearAccessMask) & (unsigned int)(MatrixFlags)) | (_Vectorizable ? PacketAccessBit : 0),
+    Alignment = evaluator<MatrixType>::Alignment
+  };
+  
+  diagonal_product_evaluator_base(const MatrixType &mat, const DiagonalType &diag)
+    : m_diagImpl(diag), m_matImpl(mat)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(NumTraits<Scalar>::MulCost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+  
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar coeff(Index idx) const
+  {
+    return m_diagImpl.coeff(idx) * m_matImpl.coeff(idx);
+  }
+  
+protected:
+  template<int LoadMode,typename PacketType>
+  EIGEN_STRONG_INLINE PacketType packet_impl(Index row, Index col, Index id, internal::true_type) const
+  {
+    return internal::pmul(m_matImpl.template packet<LoadMode,PacketType>(row, col),
+                          internal::pset1<PacketType>(m_diagImpl.coeff(id)));
+  }
+  
+  template<int LoadMode,typename PacketType>
+  EIGEN_STRONG_INLINE PacketType packet_impl(Index row, Index col, Index id, internal::false_type) const
+  {
+    enum {
+      InnerSize = (MatrixType::Flags & RowMajorBit) ? MatrixType::ColsAtCompileTime : MatrixType::RowsAtCompileTime,
+      DiagonalPacketLoadMode = EIGEN_PLAIN_ENUM_MIN(LoadMode,((InnerSize%16) == 0) ? int(Aligned16) : int(evaluator<DiagonalType>::Alignment)) // FIXME hardcoded 16!!
+    };
+    return internal::pmul(m_matImpl.template packet<LoadMode,PacketType>(row, col),
+                          m_diagImpl.template packet<DiagonalPacketLoadMode,PacketType>(id));
+  }
+  
+  evaluator<DiagonalType> m_diagImpl;
+  evaluator<MatrixType>   m_matImpl;
+};
+
+// diagonal * dense
+template<typename Lhs, typename Rhs, int ProductKind, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, ProductKind>, ProductTag, DiagonalShape, DenseShape>
+  : diagonal_product_evaluator_base<Rhs, typename Lhs::DiagonalVectorType, Product<Lhs, Rhs, LazyProduct>, OnTheLeft>
+{
+  typedef diagonal_product_evaluator_base<Rhs, typename Lhs::DiagonalVectorType, Product<Lhs, Rhs, LazyProduct>, OnTheLeft> Base;
+  using Base::m_diagImpl;
+  using Base::m_matImpl;
+  using Base::coeff;
+  typedef typename Base::Scalar Scalar;
+  
+  typedef Product<Lhs, Rhs, ProductKind> XprType;
+  typedef typename XprType::PlainObject PlainObject;
+  
+  enum {
+    StorageOrder = int(Rhs::Flags) & RowMajorBit ? RowMajor : ColMajor
+  };
+
+  EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
+    : Base(xpr.rhs(), xpr.lhs().diagonal())
+  {
+  }
+  
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar coeff(Index row, Index col) const
+  {
+    return m_diagImpl.coeff(row) * m_matImpl.coeff(row, col);
+  }
+  
+#ifndef EIGEN_CUDACC
+  template<int LoadMode,typename PacketType>
+  EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const
+  {
+    // FIXME: NVCC used to complain about the template keyword, but we have to check whether this is still the case.
+    // See also similar calls below.
+    return this->template packet_impl<LoadMode,PacketType>(row,col, row,
+                                 typename internal::conditional<int(StorageOrder)==RowMajor, internal::true_type, internal::false_type>::type());
+  }
+  
+  template<int LoadMode,typename PacketType>
+  EIGEN_STRONG_INLINE PacketType packet(Index idx) const
+  {
+    return packet<LoadMode,PacketType>(int(StorageOrder)==ColMajor?idx:0,int(StorageOrder)==ColMajor?0:idx);
+  }
+#endif
+};
+
+// dense * diagonal
+template<typename Lhs, typename Rhs, int ProductKind, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, ProductKind>, ProductTag, DenseShape, DiagonalShape>
+  : diagonal_product_evaluator_base<Lhs, typename Rhs::DiagonalVectorType, Product<Lhs, Rhs, LazyProduct>, OnTheRight>
+{
+  typedef diagonal_product_evaluator_base<Lhs, typename Rhs::DiagonalVectorType, Product<Lhs, Rhs, LazyProduct>, OnTheRight> Base;
+  using Base::m_diagImpl;
+  using Base::m_matImpl;
+  using Base::coeff;
+  typedef typename Base::Scalar Scalar;
+  
+  typedef Product<Lhs, Rhs, ProductKind> XprType;
+  typedef typename XprType::PlainObject PlainObject;
+  
+  enum { StorageOrder = int(Lhs::Flags) & RowMajorBit ? RowMajor : ColMajor };
+
+  EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
+    : Base(xpr.lhs(), xpr.rhs().diagonal())
+  {
+  }
+  
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar coeff(Index row, Index col) const
+  {
+    return m_matImpl.coeff(row, col) * m_diagImpl.coeff(col);
+  }
+  
+#ifndef EIGEN_CUDACC
+  template<int LoadMode,typename PacketType>
+  EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const
+  {
+    return this->template packet_impl<LoadMode,PacketType>(row,col, col,
+                                 typename internal::conditional<int(StorageOrder)==ColMajor, internal::true_type, internal::false_type>::type());
+  }
+  
+  template<int LoadMode,typename PacketType>
+  EIGEN_STRONG_INLINE PacketType packet(Index idx) const
+  {
+    return packet<LoadMode,PacketType>(int(StorageOrder)==ColMajor?idx:0,int(StorageOrder)==ColMajor?0:idx);
+  }
+#endif
+};
+
+/***************************************************************************
+* Products with permutation matrices
+***************************************************************************/
+
+/** \internal
+  * \class permutation_matrix_product
+  * Internal helper class implementing the product between a permutation matrix and a matrix.
+  * This class is specialized for DenseShape below and for SparseShape in SparseCore/SparsePermutation.h
+  */
+template<typename ExpressionType, int Side, bool Transposed, typename ExpressionShape>
+struct permutation_matrix_product;
+
+template<typename ExpressionType, int Side, bool Transposed>
+struct permutation_matrix_product<ExpressionType, Side, Transposed, DenseShape>
+{
+    typedef typename nested_eval<ExpressionType, 1>::type MatrixType;
+    typedef typename remove_all<MatrixType>::type MatrixTypeCleaned;
+
+    template<typename Dest, typename PermutationType>
+    static inline void run(Dest& dst, const PermutationType& perm, const ExpressionType& xpr)
+    {
+      MatrixType mat(xpr);
+      const Index n = Side==OnTheLeft ? mat.rows() : mat.cols();
+      // FIXME we need an is_same for expression that is not sensitive to constness. For instance
+      // is_same_xpr<Block<const Matrix>, Block<Matrix> >::value should be true.
+      //if(is_same<MatrixTypeCleaned,Dest>::value && extract_data(dst) == extract_data(mat))
+      if(is_same_dense(dst, mat))
+      {
+        // apply the permutation inplace
+        Matrix<bool,PermutationType::RowsAtCompileTime,1,0,PermutationType::MaxRowsAtCompileTime> mask(perm.size());
+        mask.fill(false);
+        Index r = 0;
+        while(r < perm.size())
+        {
+          // search for the next seed
+          while(r<perm.size() && mask[r]) r++;
+          if(r>=perm.size())
+            break;
+          // we got one, let's follow it until we are back to the seed
+          Index k0 = r++;
+          Index kPrev = k0;
+          mask.coeffRef(k0) = true;
+          for(Index k=perm.indices().coeff(k0); k!=k0; k=perm.indices().coeff(k))
+          {
+                  Block<Dest, Side==OnTheLeft ? 1 : Dest::RowsAtCompileTime, Side==OnTheRight ? 1 : Dest::ColsAtCompileTime>(dst, k)
+            .swap(Block<Dest, Side==OnTheLeft ? 1 : Dest::RowsAtCompileTime, Side==OnTheRight ? 1 : Dest::ColsAtCompileTime>
+                       (dst,((Side==OnTheLeft) ^ Transposed) ? k0 : kPrev));
+
+            mask.coeffRef(k) = true;
+            kPrev = k;
+          }
+        }
+      }
+      else
+      {
+        for(Index i = 0; i < n; ++i)
+        {
+          Block<Dest, Side==OnTheLeft ? 1 : Dest::RowsAtCompileTime, Side==OnTheRight ? 1 : Dest::ColsAtCompileTime>
+               (dst, ((Side==OnTheLeft) ^ Transposed) ? perm.indices().coeff(i) : i)
+
+          =
+
+          Block<const MatrixTypeCleaned,Side==OnTheLeft ? 1 : MatrixTypeCleaned::RowsAtCompileTime,Side==OnTheRight ? 1 : MatrixTypeCleaned::ColsAtCompileTime>
+               (mat, ((Side==OnTheRight) ^ Transposed) ? perm.indices().coeff(i) : i);
+        }
+      }
+    }
+};
+
+template<typename Lhs, typename Rhs, int ProductTag, typename MatrixShape>
+struct generic_product_impl<Lhs, Rhs, PermutationShape, MatrixShape, ProductTag>
+{
+  template<typename Dest>
+  static void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    permutation_matrix_product<Rhs, OnTheLeft, false, MatrixShape>::run(dst, lhs, rhs);
+  }
+};
+
+template<typename Lhs, typename Rhs, int ProductTag, typename MatrixShape>
+struct generic_product_impl<Lhs, Rhs, MatrixShape, PermutationShape, ProductTag>
+{
+  template<typename Dest>
+  static void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    permutation_matrix_product<Lhs, OnTheRight, false, MatrixShape>::run(dst, rhs, lhs);
+  }
+};
+
+template<typename Lhs, typename Rhs, int ProductTag, typename MatrixShape>
+struct generic_product_impl<Inverse<Lhs>, Rhs, PermutationShape, MatrixShape, ProductTag>
+{
+  template<typename Dest>
+  static void evalTo(Dest& dst, const Inverse<Lhs>& lhs, const Rhs& rhs)
+  {
+    permutation_matrix_product<Rhs, OnTheLeft, true, MatrixShape>::run(dst, lhs.nestedExpression(), rhs);
+  }
+};
+
+template<typename Lhs, typename Rhs, int ProductTag, typename MatrixShape>
+struct generic_product_impl<Lhs, Inverse<Rhs>, MatrixShape, PermutationShape, ProductTag>
+{
+  template<typename Dest>
+  static void evalTo(Dest& dst, const Lhs& lhs, const Inverse<Rhs>& rhs)
+  {
+    permutation_matrix_product<Lhs, OnTheRight, true, MatrixShape>::run(dst, rhs.nestedExpression(), lhs);
+  }
+};
+
+
+/***************************************************************************
+* Products with transpositions matrices
+***************************************************************************/
+
+// FIXME could we unify Transpositions and Permutation into a single "shape"??
+
+/** \internal
+  * \class transposition_matrix_product
+  * Internal helper class implementing the product between a permutation matrix and a matrix.
+  */
+template<typename ExpressionType, int Side, bool Transposed, typename ExpressionShape>
+struct transposition_matrix_product
+{
+  typedef typename nested_eval<ExpressionType, 1>::type MatrixType;
+  typedef typename remove_all<MatrixType>::type MatrixTypeCleaned;
+  
+  template<typename Dest, typename TranspositionType>
+  static inline void run(Dest& dst, const TranspositionType& tr, const ExpressionType& xpr)
+  {
+    MatrixType mat(xpr);
+    typedef typename TranspositionType::StorageIndex StorageIndex;
+    const Index size = tr.size();
+    StorageIndex j = 0;
+
+    if(!is_same_dense(dst,mat))
+      dst = mat;
+
+    for(Index k=(Transposed?size-1:0) ; Transposed?k>=0:k<size ; Transposed?--k:++k)
+      if(Index(j=tr.coeff(k))!=k)
+      {
+        if(Side==OnTheLeft)        dst.row(k).swap(dst.row(j));
+        else if(Side==OnTheRight)  dst.col(k).swap(dst.col(j));
+      }
+  }
+};
+
+template<typename Lhs, typename Rhs, int ProductTag, typename MatrixShape>
+struct generic_product_impl<Lhs, Rhs, TranspositionsShape, MatrixShape, ProductTag>
+{
+  template<typename Dest>
+  static void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    transposition_matrix_product<Rhs, OnTheLeft, false, MatrixShape>::run(dst, lhs, rhs);
+  }
+};
+
+template<typename Lhs, typename Rhs, int ProductTag, typename MatrixShape>
+struct generic_product_impl<Lhs, Rhs, MatrixShape, TranspositionsShape, ProductTag>
+{
+  template<typename Dest>
+  static void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    transposition_matrix_product<Lhs, OnTheRight, false, MatrixShape>::run(dst, rhs, lhs);
+  }
+};
+
+
+template<typename Lhs, typename Rhs, int ProductTag, typename MatrixShape>
+struct generic_product_impl<Transpose<Lhs>, Rhs, TranspositionsShape, MatrixShape, ProductTag>
+{
+  template<typename Dest>
+  static void evalTo(Dest& dst, const Transpose<Lhs>& lhs, const Rhs& rhs)
+  {
+    transposition_matrix_product<Rhs, OnTheLeft, true, MatrixShape>::run(dst, lhs.nestedExpression(), rhs);
+  }
+};
+
+template<typename Lhs, typename Rhs, int ProductTag, typename MatrixShape>
+struct generic_product_impl<Lhs, Transpose<Rhs>, MatrixShape, TranspositionsShape, ProductTag>
+{
+  template<typename Dest>
+  static void evalTo(Dest& dst, const Lhs& lhs, const Transpose<Rhs>& rhs)
+  {
+    transposition_matrix_product<Lhs, OnTheRight, true, MatrixShape>::run(dst, rhs.nestedExpression(), lhs);
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_PRODUCT_EVALUATORS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Random.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Random.h
new file mode 100644
index 00000000..486e9ed5
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Random.h
@@ -0,0 +1,182 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_RANDOM_H
+#define EIGEN_RANDOM_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename Scalar> struct scalar_random_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_random_op)
+  inline const Scalar operator() () const { return random<Scalar>(); }
+};
+
+template<typename Scalar>
+struct functor_traits<scalar_random_op<Scalar> >
+{ enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false, IsRepeatable = false }; };
+
+} // end namespace internal
+
+/** \returns a random matrix expression
+  *
+  * Numbers are uniformly spread through their whole definition range for integer types,
+  * and in the [-1:1] range for floating point scalar types.
+  * 
+  * The parameters \a rows and \a cols are the number of rows and of columns of
+  * the returned matrix. Must be compatible with this MatrixBase type.
+  *
+  * \not_reentrant
+  * 
+  * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
+  * it is redundant to pass \a rows and \a cols as arguments, so Random() should be used
+  * instead.
+  * 
+  *
+  * Example: \include MatrixBase_random_int_int.cpp
+  * Output: \verbinclude MatrixBase_random_int_int.out
+  *
+  * This expression has the "evaluate before nesting" flag so that it will be evaluated into
+  * a temporary matrix whenever it is nested in a larger expression. This prevents unexpected
+  * behavior with expressions involving random matrices.
+  * 
+  * See DenseBase::NullaryExpr(Index, const CustomNullaryOp&) for an example using C++11 random generators.
+  *
+  * \sa DenseBase::setRandom(), DenseBase::Random(Index), DenseBase::Random()
+  */
+template<typename Derived>
+inline const typename DenseBase<Derived>::RandomReturnType
+DenseBase<Derived>::Random(Index rows, Index cols)
+{
+  return NullaryExpr(rows, cols, internal::scalar_random_op<Scalar>());
+}
+
+/** \returns a random vector expression
+  *
+  * Numbers are uniformly spread through their whole definition range for integer types,
+  * and in the [-1:1] range for floating point scalar types.
+  *
+  * The parameter \a size is the size of the returned vector.
+  * Must be compatible with this MatrixBase type.
+  *
+  * \only_for_vectors
+  * \not_reentrant
+  *
+  * This variant is meant to be used for dynamic-size vector types. For fixed-size types,
+  * it is redundant to pass \a size as argument, so Random() should be used
+  * instead.
+  *
+  * Example: \include MatrixBase_random_int.cpp
+  * Output: \verbinclude MatrixBase_random_int.out
+  *
+  * This expression has the "evaluate before nesting" flag so that it will be evaluated into
+  * a temporary vector whenever it is nested in a larger expression. This prevents unexpected
+  * behavior with expressions involving random matrices.
+  *
+  * \sa DenseBase::setRandom(), DenseBase::Random(Index,Index), DenseBase::Random()
+  */
+template<typename Derived>
+inline const typename DenseBase<Derived>::RandomReturnType
+DenseBase<Derived>::Random(Index size)
+{
+  return NullaryExpr(size, internal::scalar_random_op<Scalar>());
+}
+
+/** \returns a fixed-size random matrix or vector expression
+  *
+  * Numbers are uniformly spread through their whole definition range for integer types,
+  * and in the [-1:1] range for floating point scalar types.
+  * 
+  * This variant is only for fixed-size MatrixBase types. For dynamic-size types, you
+  * need to use the variants taking size arguments.
+  *
+  * Example: \include MatrixBase_random.cpp
+  * Output: \verbinclude MatrixBase_random.out
+  *
+  * This expression has the "evaluate before nesting" flag so that it will be evaluated into
+  * a temporary matrix whenever it is nested in a larger expression. This prevents unexpected
+  * behavior with expressions involving random matrices.
+  * 
+  * \not_reentrant
+  *
+  * \sa DenseBase::setRandom(), DenseBase::Random(Index,Index), DenseBase::Random(Index)
+  */
+template<typename Derived>
+inline const typename DenseBase<Derived>::RandomReturnType
+DenseBase<Derived>::Random()
+{
+  return NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, internal::scalar_random_op<Scalar>());
+}
+
+/** Sets all coefficients in this expression to random values.
+  *
+  * Numbers are uniformly spread through their whole definition range for integer types,
+  * and in the [-1:1] range for floating point scalar types.
+  * 
+  * \not_reentrant
+  * 
+  * Example: \include MatrixBase_setRandom.cpp
+  * Output: \verbinclude MatrixBase_setRandom.out
+  *
+  * \sa class CwiseNullaryOp, setRandom(Index), setRandom(Index,Index)
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline Derived& DenseBase<Derived>::setRandom()
+{
+  return *this = Random(rows(), cols());
+}
+
+/** Resizes to the given \a newSize, and sets all coefficients in this expression to random values.
+  *
+  * Numbers are uniformly spread through their whole definition range for integer types,
+  * and in the [-1:1] range for floating point scalar types.
+  * 
+  * \only_for_vectors
+  * \not_reentrant
+  *
+  * Example: \include Matrix_setRandom_int.cpp
+  * Output: \verbinclude Matrix_setRandom_int.out
+  *
+  * \sa DenseBase::setRandom(), setRandom(Index,Index), class CwiseNullaryOp, DenseBase::Random()
+  */
+template<typename Derived>
+EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setRandom(Index newSize)
+{
+  resize(newSize);
+  return setRandom();
+}
+
+/** Resizes to the given size, and sets all coefficients in this expression to random values.
+  *
+  * Numbers are uniformly spread through their whole definition range for integer types,
+  * and in the [-1:1] range for floating point scalar types.
+  *
+  * \not_reentrant
+  * 
+  * \param rows the new number of rows
+  * \param cols the new number of columns
+  *
+  * Example: \include Matrix_setRandom_int_int.cpp
+  * Output: \verbinclude Matrix_setRandom_int_int.out
+  *
+  * \sa DenseBase::setRandom(), setRandom(Index), class CwiseNullaryOp, DenseBase::Random()
+  */
+template<typename Derived>
+EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setRandom(Index rows, Index cols)
+{
+  resize(rows, cols);
+  return setRandom();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_RANDOM_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Redux.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Redux.h
new file mode 100644
index 00000000..2b5b73bf
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Redux.h
@@ -0,0 +1,505 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_REDUX_H
+#define EIGEN_REDUX_H
+
+namespace Eigen { 
+
+namespace internal {
+
+// TODO
+//  * implement other kind of vectorization
+//  * factorize code
+
+/***************************************************************************
+* Part 1 : the logic deciding a strategy for vectorization and unrolling
+***************************************************************************/
+
+template<typename Func, typename Derived>
+struct redux_traits
+{
+public:
+    typedef typename find_best_packet<typename Derived::Scalar,Derived::SizeAtCompileTime>::type PacketType;
+  enum {
+    PacketSize = unpacket_traits<PacketType>::size,
+    InnerMaxSize = int(Derived::IsRowMajor)
+                 ? Derived::MaxColsAtCompileTime
+                 : Derived::MaxRowsAtCompileTime
+  };
+
+  enum {
+    MightVectorize = (int(Derived::Flags)&ActualPacketAccessBit)
+                  && (functor_traits<Func>::PacketAccess),
+    MayLinearVectorize = bool(MightVectorize) && (int(Derived::Flags)&LinearAccessBit),
+    MaySliceVectorize  = bool(MightVectorize) && int(InnerMaxSize)>=3*PacketSize
+  };
+
+public:
+  enum {
+    Traversal = int(MayLinearVectorize) ? int(LinearVectorizedTraversal)
+              : int(MaySliceVectorize)  ? int(SliceVectorizedTraversal)
+                                        : int(DefaultTraversal)
+  };
+
+public:
+  enum {
+    Cost = Derived::SizeAtCompileTime == Dynamic ? HugeCost
+         : Derived::SizeAtCompileTime * Derived::CoeffReadCost + (Derived::SizeAtCompileTime-1) * functor_traits<Func>::Cost,
+    UnrollingLimit = EIGEN_UNROLLING_LIMIT * (int(Traversal) == int(DefaultTraversal) ? 1 : int(PacketSize))
+  };
+
+public:
+  enum {
+    Unrolling = Cost <= UnrollingLimit ? CompleteUnrolling : NoUnrolling
+  };
+  
+#ifdef EIGEN_DEBUG_ASSIGN
+  static void debug()
+  {
+    std::cerr << "Xpr: " << typeid(typename Derived::XprType).name() << std::endl;
+    std::cerr.setf(std::ios::hex, std::ios::basefield);
+    EIGEN_DEBUG_VAR(Derived::Flags)
+    std::cerr.unsetf(std::ios::hex);
+    EIGEN_DEBUG_VAR(InnerMaxSize)
+    EIGEN_DEBUG_VAR(PacketSize)
+    EIGEN_DEBUG_VAR(MightVectorize)
+    EIGEN_DEBUG_VAR(MayLinearVectorize)
+    EIGEN_DEBUG_VAR(MaySliceVectorize)
+    EIGEN_DEBUG_VAR(Traversal)
+    EIGEN_DEBUG_VAR(UnrollingLimit)
+    EIGEN_DEBUG_VAR(Unrolling)
+    std::cerr << std::endl;
+  }
+#endif
+};
+
+/***************************************************************************
+* Part 2 : unrollers
+***************************************************************************/
+
+/*** no vectorization ***/
+
+template<typename Func, typename Derived, int Start, int Length>
+struct redux_novec_unroller
+{
+  enum {
+    HalfLength = Length/2
+  };
+
+  typedef typename Derived::Scalar Scalar;
+
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE Scalar run(const Derived &mat, const Func& func)
+  {
+    return func(redux_novec_unroller<Func, Derived, Start, HalfLength>::run(mat,func),
+                redux_novec_unroller<Func, Derived, Start+HalfLength, Length-HalfLength>::run(mat,func));
+  }
+};
+
+template<typename Func, typename Derived, int Start>
+struct redux_novec_unroller<Func, Derived, Start, 1>
+{
+  enum {
+    outer = Start / Derived::InnerSizeAtCompileTime,
+    inner = Start % Derived::InnerSizeAtCompileTime
+  };
+
+  typedef typename Derived::Scalar Scalar;
+
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE Scalar run(const Derived &mat, const Func&)
+  {
+    return mat.coeffByOuterInner(outer, inner);
+  }
+};
+
+// This is actually dead code and will never be called. It is required
+// to prevent false warnings regarding failed inlining though
+// for 0 length run() will never be called at all.
+template<typename Func, typename Derived, int Start>
+struct redux_novec_unroller<Func, Derived, Start, 0>
+{
+  typedef typename Derived::Scalar Scalar;
+  EIGEN_DEVICE_FUNC 
+  static EIGEN_STRONG_INLINE Scalar run(const Derived&, const Func&) { return Scalar(); }
+};
+
+/*** vectorization ***/
+
+template<typename Func, typename Derived, int Start, int Length>
+struct redux_vec_unroller
+{
+  enum {
+    PacketSize = redux_traits<Func, Derived>::PacketSize,
+    HalfLength = Length/2
+  };
+
+  typedef typename Derived::Scalar Scalar;
+  typedef typename redux_traits<Func, Derived>::PacketType PacketScalar;
+
+  static EIGEN_STRONG_INLINE PacketScalar run(const Derived &mat, const Func& func)
+  {
+    return func.packetOp(
+            redux_vec_unroller<Func, Derived, Start, HalfLength>::run(mat,func),
+            redux_vec_unroller<Func, Derived, Start+HalfLength, Length-HalfLength>::run(mat,func) );
+  }
+};
+
+template<typename Func, typename Derived, int Start>
+struct redux_vec_unroller<Func, Derived, Start, 1>
+{
+  enum {
+    index = Start * redux_traits<Func, Derived>::PacketSize,
+    outer = index / int(Derived::InnerSizeAtCompileTime),
+    inner = index % int(Derived::InnerSizeAtCompileTime),
+    alignment = Derived::Alignment
+  };
+
+  typedef typename Derived::Scalar Scalar;
+  typedef typename redux_traits<Func, Derived>::PacketType PacketScalar;
+
+  static EIGEN_STRONG_INLINE PacketScalar run(const Derived &mat, const Func&)
+  {
+    return mat.template packetByOuterInner<alignment,PacketScalar>(outer, inner);
+  }
+};
+
+/***************************************************************************
+* Part 3 : implementation of all cases
+***************************************************************************/
+
+template<typename Func, typename Derived,
+         int Traversal = redux_traits<Func, Derived>::Traversal,
+         int Unrolling = redux_traits<Func, Derived>::Unrolling
+>
+struct redux_impl;
+
+template<typename Func, typename Derived>
+struct redux_impl<Func, Derived, DefaultTraversal, NoUnrolling>
+{
+  typedef typename Derived::Scalar Scalar;
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE Scalar run(const Derived &mat, const Func& func)
+  {
+    eigen_assert(mat.rows()>0 && mat.cols()>0 && "you are using an empty matrix");
+    Scalar res;
+    res = mat.coeffByOuterInner(0, 0);
+    for(Index i = 1; i < mat.innerSize(); ++i)
+      res = func(res, mat.coeffByOuterInner(0, i));
+    for(Index i = 1; i < mat.outerSize(); ++i)
+      for(Index j = 0; j < mat.innerSize(); ++j)
+        res = func(res, mat.coeffByOuterInner(i, j));
+    return res;
+  }
+};
+
+template<typename Func, typename Derived>
+struct redux_impl<Func,Derived, DefaultTraversal, CompleteUnrolling>
+  : public redux_novec_unroller<Func,Derived, 0, Derived::SizeAtCompileTime>
+{};
+
+template<typename Func, typename Derived>
+struct redux_impl<Func, Derived, LinearVectorizedTraversal, NoUnrolling>
+{
+  typedef typename Derived::Scalar Scalar;
+  typedef typename redux_traits<Func, Derived>::PacketType PacketScalar;
+
+  static Scalar run(const Derived &mat, const Func& func)
+  {
+    const Index size = mat.size();
+    
+    const Index packetSize = redux_traits<Func, Derived>::PacketSize;
+    const int packetAlignment = unpacket_traits<PacketScalar>::alignment;
+    enum {
+      alignment0 = (bool(Derived::Flags & DirectAccessBit) && bool(packet_traits<Scalar>::AlignedOnScalar)) ? int(packetAlignment) : int(Unaligned),
+      alignment = EIGEN_PLAIN_ENUM_MAX(alignment0, Derived::Alignment)
+    };
+    const Index alignedStart = internal::first_default_aligned(mat.nestedExpression());
+    const Index alignedSize2 = ((size-alignedStart)/(2*packetSize))*(2*packetSize);
+    const Index alignedSize = ((size-alignedStart)/(packetSize))*(packetSize);
+    const Index alignedEnd2 = alignedStart + alignedSize2;
+    const Index alignedEnd  = alignedStart + alignedSize;
+    Scalar res;
+    if(alignedSize)
+    {
+      PacketScalar packet_res0 = mat.template packet<alignment,PacketScalar>(alignedStart);
+      if(alignedSize>packetSize) // we have at least two packets to partly unroll the loop
+      {
+        PacketScalar packet_res1 = mat.template packet<alignment,PacketScalar>(alignedStart+packetSize);
+        for(Index index = alignedStart + 2*packetSize; index < alignedEnd2; index += 2*packetSize)
+        {
+          packet_res0 = func.packetOp(packet_res0, mat.template packet<alignment,PacketScalar>(index));
+          packet_res1 = func.packetOp(packet_res1, mat.template packet<alignment,PacketScalar>(index+packetSize));
+        }
+
+        packet_res0 = func.packetOp(packet_res0,packet_res1);
+        if(alignedEnd>alignedEnd2)
+          packet_res0 = func.packetOp(packet_res0, mat.template packet<alignment,PacketScalar>(alignedEnd2));
+      }
+      res = func.predux(packet_res0);
+
+      for(Index index = 0; index < alignedStart; ++index)
+        res = func(res,mat.coeff(index));
+
+      for(Index index = alignedEnd; index < size; ++index)
+        res = func(res,mat.coeff(index));
+    }
+    else // too small to vectorize anything.
+         // since this is dynamic-size hence inefficient anyway for such small sizes, don't try to optimize.
+    {
+      res = mat.coeff(0);
+      for(Index index = 1; index < size; ++index)
+        res = func(res,mat.coeff(index));
+    }
+
+    return res;
+  }
+};
+
+// NOTE: for SliceVectorizedTraversal we simply bypass unrolling
+template<typename Func, typename Derived, int Unrolling>
+struct redux_impl<Func, Derived, SliceVectorizedTraversal, Unrolling>
+{
+  typedef typename Derived::Scalar Scalar;
+  typedef typename redux_traits<Func, Derived>::PacketType PacketType;
+
+  EIGEN_DEVICE_FUNC static Scalar run(const Derived &mat, const Func& func)
+  {
+    eigen_assert(mat.rows()>0 && mat.cols()>0 && "you are using an empty matrix");
+    const Index innerSize = mat.innerSize();
+    const Index outerSize = mat.outerSize();
+    enum {
+      packetSize = redux_traits<Func, Derived>::PacketSize
+    };
+    const Index packetedInnerSize = ((innerSize)/packetSize)*packetSize;
+    Scalar res;
+    if(packetedInnerSize)
+    {
+      PacketType packet_res = mat.template packet<Unaligned,PacketType>(0,0);
+      for(Index j=0; j<outerSize; ++j)
+        for(Index i=(j==0?packetSize:0); i<packetedInnerSize; i+=Index(packetSize))
+          packet_res = func.packetOp(packet_res, mat.template packetByOuterInner<Unaligned,PacketType>(j,i));
+
+      res = func.predux(packet_res);
+      for(Index j=0; j<outerSize; ++j)
+        for(Index i=packetedInnerSize; i<innerSize; ++i)
+          res = func(res, mat.coeffByOuterInner(j,i));
+    }
+    else // too small to vectorize anything.
+         // since this is dynamic-size hence inefficient anyway for such small sizes, don't try to optimize.
+    {
+      res = redux_impl<Func, Derived, DefaultTraversal, NoUnrolling>::run(mat, func);
+    }
+
+    return res;
+  }
+};
+
+template<typename Func, typename Derived>
+struct redux_impl<Func, Derived, LinearVectorizedTraversal, CompleteUnrolling>
+{
+  typedef typename Derived::Scalar Scalar;
+
+  typedef typename redux_traits<Func, Derived>::PacketType PacketScalar;
+  enum {
+    PacketSize = redux_traits<Func, Derived>::PacketSize,
+    Size = Derived::SizeAtCompileTime,
+    VectorizedSize = (Size / PacketSize) * PacketSize
+  };
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar run(const Derived &mat, const Func& func)
+  {
+    eigen_assert(mat.rows()>0 && mat.cols()>0 && "you are using an empty matrix");
+    if (VectorizedSize > 0) {
+      Scalar res = func.predux(redux_vec_unroller<Func, Derived, 0, Size / PacketSize>::run(mat,func));
+      if (VectorizedSize != Size)
+        res = func(res,redux_novec_unroller<Func, Derived, VectorizedSize, Size-VectorizedSize>::run(mat,func));
+      return res;
+    }
+    else {
+      return redux_novec_unroller<Func, Derived, 0, Size>::run(mat,func);
+    }
+  }
+};
+
+// evaluator adaptor
+template<typename _XprType>
+class redux_evaluator
+{
+public:
+  typedef _XprType XprType;
+  EIGEN_DEVICE_FUNC explicit redux_evaluator(const XprType &xpr) : m_evaluator(xpr), m_xpr(xpr) {}
+  
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename XprType::PacketScalar PacketScalar;
+  typedef typename XprType::PacketReturnType PacketReturnType;
+  
+  enum {
+    MaxRowsAtCompileTime = XprType::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = XprType::MaxColsAtCompileTime,
+    // TODO we should not remove DirectAccessBit and rather find an elegant way to query the alignment offset at runtime from the evaluator
+    Flags = evaluator<XprType>::Flags & ~DirectAccessBit,
+    IsRowMajor = XprType::IsRowMajor,
+    SizeAtCompileTime = XprType::SizeAtCompileTime,
+    InnerSizeAtCompileTime = XprType::InnerSizeAtCompileTime,
+    CoeffReadCost = evaluator<XprType>::CoeffReadCost,
+    Alignment = evaluator<XprType>::Alignment
+  };
+  
+  EIGEN_DEVICE_FUNC Index rows() const { return m_xpr.rows(); }
+  EIGEN_DEVICE_FUNC Index cols() const { return m_xpr.cols(); }
+  EIGEN_DEVICE_FUNC Index size() const { return m_xpr.size(); }
+  EIGEN_DEVICE_FUNC Index innerSize() const { return m_xpr.innerSize(); }
+  EIGEN_DEVICE_FUNC Index outerSize() const { return m_xpr.outerSize(); }
+
+  EIGEN_DEVICE_FUNC
+  CoeffReturnType coeff(Index row, Index col) const
+  { return m_evaluator.coeff(row, col); }
+
+  EIGEN_DEVICE_FUNC
+  CoeffReturnType coeff(Index index) const
+  { return m_evaluator.coeff(index); }
+
+  template<int LoadMode, typename PacketType>
+  PacketType packet(Index row, Index col) const
+  { return m_evaluator.template packet<LoadMode,PacketType>(row, col); }
+
+  template<int LoadMode, typename PacketType>
+  PacketType packet(Index index) const
+  { return m_evaluator.template packet<LoadMode,PacketType>(index); }
+  
+  EIGEN_DEVICE_FUNC
+  CoeffReturnType coeffByOuterInner(Index outer, Index inner) const
+  { return m_evaluator.coeff(IsRowMajor ? outer : inner, IsRowMajor ? inner : outer); }
+  
+  template<int LoadMode, typename PacketType>
+  PacketType packetByOuterInner(Index outer, Index inner) const
+  { return m_evaluator.template packet<LoadMode,PacketType>(IsRowMajor ? outer : inner, IsRowMajor ? inner : outer); }
+  
+  const XprType & nestedExpression() const { return m_xpr; }
+  
+protected:
+  internal::evaluator<XprType> m_evaluator;
+  const XprType &m_xpr;
+};
+
+} // end namespace internal
+
+/***************************************************************************
+* Part 4 : public API
+***************************************************************************/
+
+
+/** \returns the result of a full redux operation on the whole matrix or vector using \a func
+  *
+  * The template parameter \a BinaryOp is the type of the functor \a func which must be
+  * an associative operator. Both current C++98 and C++11 functor styles are handled.
+  *
+  * \sa DenseBase::sum(), DenseBase::minCoeff(), DenseBase::maxCoeff(), MatrixBase::colwise(), MatrixBase::rowwise()
+  */
+template<typename Derived>
+template<typename Func>
+EIGEN_DEVICE_FUNC typename internal::traits<Derived>::Scalar
+DenseBase<Derived>::redux(const Func& func) const
+{
+  eigen_assert(this->rows()>0 && this->cols()>0 && "you are using an empty matrix");
+
+  typedef typename internal::redux_evaluator<Derived> ThisEvaluator;
+  ThisEvaluator thisEval(derived());
+  
+  return internal::redux_impl<Func, ThisEvaluator>::run(thisEval, func);
+}
+
+/** \returns the minimum of all coefficients of \c *this.
+  * \warning the result is undefined if \c *this contains NaN.
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar
+DenseBase<Derived>::minCoeff() const
+{
+  return derived().redux(Eigen::internal::scalar_min_op<Scalar,Scalar>());
+}
+
+/** \returns the maximum of all coefficients of \c *this.
+  * \warning the result is undefined if \c *this contains NaN.
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar
+DenseBase<Derived>::maxCoeff() const
+{
+  return derived().redux(Eigen::internal::scalar_max_op<Scalar,Scalar>());
+}
+
+/** \returns the sum of all coefficients of \c *this
+  *
+  * If \c *this is empty, then the value 0 is returned.
+  *
+  * \sa trace(), prod(), mean()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar
+DenseBase<Derived>::sum() const
+{
+  if(SizeAtCompileTime==0 || (SizeAtCompileTime==Dynamic && size()==0))
+    return Scalar(0);
+  return derived().redux(Eigen::internal::scalar_sum_op<Scalar,Scalar>());
+}
+
+/** \returns the mean of all coefficients of *this
+*
+* \sa trace(), prod(), sum()
+*/
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar
+DenseBase<Derived>::mean() const
+{
+#ifdef __INTEL_COMPILER
+  #pragma warning push
+  #pragma warning ( disable : 2259 )
+#endif
+  return Scalar(derived().redux(Eigen::internal::scalar_sum_op<Scalar,Scalar>())) / Scalar(this->size());
+#ifdef __INTEL_COMPILER
+  #pragma warning pop
+#endif
+}
+
+/** \returns the product of all coefficients of *this
+  *
+  * Example: \include MatrixBase_prod.cpp
+  * Output: \verbinclude MatrixBase_prod.out
+  *
+  * \sa sum(), mean(), trace()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar
+DenseBase<Derived>::prod() const
+{
+  if(SizeAtCompileTime==0 || (SizeAtCompileTime==Dynamic && size()==0))
+    return Scalar(1);
+  return derived().redux(Eigen::internal::scalar_product_op<Scalar>());
+}
+
+/** \returns the trace of \c *this, i.e. the sum of the coefficients on the main diagonal.
+  *
+  * \c *this can be any matrix, not necessarily square.
+  *
+  * \sa diagonal(), sum()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar
+MatrixBase<Derived>::trace() const
+{
+  return derived().diagonal().sum();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_REDUX_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Ref.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Ref.h
new file mode 100644
index 00000000..abb1e512
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Ref.h
@@ -0,0 +1,283 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_REF_H
+#define EIGEN_REF_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename _PlainObjectType, int _Options, typename _StrideType>
+struct traits<Ref<_PlainObjectType, _Options, _StrideType> >
+  : public traits<Map<_PlainObjectType, _Options, _StrideType> >
+{
+  typedef _PlainObjectType PlainObjectType;
+  typedef _StrideType StrideType;
+  enum {
+    Options = _Options,
+    Flags = traits<Map<_PlainObjectType, _Options, _StrideType> >::Flags | NestByRefBit,
+    Alignment = traits<Map<_PlainObjectType, _Options, _StrideType> >::Alignment
+  };
+
+  template<typename Derived> struct match {
+    enum {
+      HasDirectAccess = internal::has_direct_access<Derived>::ret,
+      StorageOrderMatch = PlainObjectType::IsVectorAtCompileTime || Derived::IsVectorAtCompileTime || ((PlainObjectType::Flags&RowMajorBit)==(Derived::Flags&RowMajorBit)),
+      InnerStrideMatch = int(StrideType::InnerStrideAtCompileTime)==int(Dynamic)
+                      || int(StrideType::InnerStrideAtCompileTime)==int(Derived::InnerStrideAtCompileTime)
+                      || (int(StrideType::InnerStrideAtCompileTime)==0 && int(Derived::InnerStrideAtCompileTime)==1),
+      OuterStrideMatch = Derived::IsVectorAtCompileTime
+                      || int(StrideType::OuterStrideAtCompileTime)==int(Dynamic) || int(StrideType::OuterStrideAtCompileTime)==int(Derived::OuterStrideAtCompileTime),
+      // NOTE, this indirection of evaluator<Derived>::Alignment is needed
+      // to workaround a very strange bug in MSVC related to the instantiation
+      // of has_*ary_operator in evaluator<CwiseNullaryOp>.
+      // This line is surprisingly very sensitive. For instance, simply adding parenthesis
+      // as "DerivedAlignment = (int(evaluator<Derived>::Alignment))," will make MSVC fail...
+      DerivedAlignment = int(evaluator<Derived>::Alignment),
+      AlignmentMatch = (int(traits<PlainObjectType>::Alignment)==int(Unaligned)) || (DerivedAlignment >= int(Alignment)), // FIXME the first condition is not very clear, it should be replaced by the required alignment
+      ScalarTypeMatch = internal::is_same<typename PlainObjectType::Scalar, typename Derived::Scalar>::value,
+      MatchAtCompileTime = HasDirectAccess && StorageOrderMatch && InnerStrideMatch && OuterStrideMatch && AlignmentMatch && ScalarTypeMatch
+    };
+    typedef typename internal::conditional<MatchAtCompileTime,internal::true_type,internal::false_type>::type type;
+  };
+  
+};
+
+template<typename Derived>
+struct traits<RefBase<Derived> > : public traits<Derived> {};
+
+}
+
+template<typename Derived> class RefBase
+ : public MapBase<Derived>
+{
+  typedef typename internal::traits<Derived>::PlainObjectType PlainObjectType;
+  typedef typename internal::traits<Derived>::StrideType StrideType;
+
+public:
+
+  typedef MapBase<Derived> Base;
+  EIGEN_DENSE_PUBLIC_INTERFACE(RefBase)
+
+  EIGEN_DEVICE_FUNC inline Index innerStride() const
+  {
+    return StrideType::InnerStrideAtCompileTime != 0 ? m_stride.inner() : 1;
+  }
+
+  EIGEN_DEVICE_FUNC inline Index outerStride() const
+  {
+    return StrideType::OuterStrideAtCompileTime != 0 ? m_stride.outer()
+         : IsVectorAtCompileTime ? this->size()
+         : int(Flags)&RowMajorBit ? this->cols()
+         : this->rows();
+  }
+
+  EIGEN_DEVICE_FUNC RefBase()
+    : Base(0,RowsAtCompileTime==Dynamic?0:RowsAtCompileTime,ColsAtCompileTime==Dynamic?0:ColsAtCompileTime),
+      // Stride<> does not allow default ctor for Dynamic strides, so let' initialize it with dummy values:
+      m_stride(StrideType::OuterStrideAtCompileTime==Dynamic?0:StrideType::OuterStrideAtCompileTime,
+               StrideType::InnerStrideAtCompileTime==Dynamic?0:StrideType::InnerStrideAtCompileTime)
+  {}
+  
+  EIGEN_INHERIT_ASSIGNMENT_OPERATORS(RefBase)
+
+protected:
+
+  typedef Stride<StrideType::OuterStrideAtCompileTime,StrideType::InnerStrideAtCompileTime> StrideBase;
+
+  template<typename Expression>
+  EIGEN_DEVICE_FUNC void construct(Expression& expr)
+  {
+    if(PlainObjectType::RowsAtCompileTime==1)
+    {
+      eigen_assert(expr.rows()==1 || expr.cols()==1);
+      ::new (static_cast<Base*>(this)) Base(expr.data(), 1, expr.size());
+    }
+    else if(PlainObjectType::ColsAtCompileTime==1)
+    {
+      eigen_assert(expr.rows()==1 || expr.cols()==1);
+      ::new (static_cast<Base*>(this)) Base(expr.data(), expr.size(), 1);
+    }
+    else
+      ::new (static_cast<Base*>(this)) Base(expr.data(), expr.rows(), expr.cols());
+    
+    if(Expression::IsVectorAtCompileTime && (!PlainObjectType::IsVectorAtCompileTime) && ((Expression::Flags&RowMajorBit)!=(PlainObjectType::Flags&RowMajorBit)))
+      ::new (&m_stride) StrideBase(expr.innerStride(), StrideType::InnerStrideAtCompileTime==0?0:1);
+    else
+      ::new (&m_stride) StrideBase(StrideType::OuterStrideAtCompileTime==0?0:expr.outerStride(),
+                                   StrideType::InnerStrideAtCompileTime==0?0:expr.innerStride());    
+  }
+
+  StrideBase m_stride;
+};
+
+/** \class Ref
+  * \ingroup Core_Module
+  *
+  * \brief A matrix or vector expression mapping an existing expression
+  *
+  * \tparam PlainObjectType the equivalent matrix type of the mapped data
+  * \tparam Options specifies the pointer alignment in bytes. It can be: \c #Aligned128, , \c #Aligned64, \c #Aligned32, \c #Aligned16, \c #Aligned8 or \c #Unaligned.
+  *                 The default is \c #Unaligned.
+  * \tparam StrideType optionally specifies strides. By default, Ref implies a contiguous storage along the inner dimension (inner stride==1),
+  *                   but accepts a variable outer stride (leading dimension).
+  *                   This can be overridden by specifying strides.
+  *                   The type passed here must be a specialization of the Stride template, see examples below.
+  *
+  * This class provides a way to write non-template functions taking Eigen objects as parameters while limiting the number of copies.
+  * A Ref<> object can represent either a const expression or a l-value:
+  * \code
+  * // in-out argument:
+  * void foo1(Ref<VectorXf> x);
+  *
+  * // read-only const argument:
+  * void foo2(const Ref<const VectorXf>& x);
+  * \endcode
+  *
+  * In the in-out case, the input argument must satisfy the constraints of the actual Ref<> type, otherwise a compilation issue will be triggered.
+  * By default, a Ref<VectorXf> can reference any dense vector expression of float having a contiguous memory layout.
+  * Likewise, a Ref<MatrixXf> can reference any column-major dense matrix expression of float whose column's elements are contiguously stored with
+  * the possibility to have a constant space in-between each column, i.e. the inner stride must be equal to 1, but the outer stride (or leading dimension)
+  * can be greater than the number of rows.
+  *
+  * In the const case, if the input expression does not match the above requirement, then it is evaluated into a temporary before being passed to the function.
+  * Here are some examples:
+  * \code
+  * MatrixXf A;
+  * VectorXf a;
+  * foo1(a.head());             // OK
+  * foo1(A.col());              // OK
+  * foo1(A.row());              // Compilation error because here innerstride!=1
+  * foo2(A.row());              // Compilation error because A.row() is a 1xN object while foo2 is expecting a Nx1 object
+  * foo2(A.row().transpose());  // The row is copied into a contiguous temporary
+  * foo2(2*a);                  // The expression is evaluated into a temporary
+  * foo2(A.col().segment(2,4)); // No temporary
+  * \endcode
+  *
+  * The range of inputs that can be referenced without temporary can be enlarged using the last two template parameters.
+  * Here is an example accepting an innerstride!=1:
+  * \code
+  * // in-out argument:
+  * void foo3(Ref<VectorXf,0,InnerStride<> > x);
+  * foo3(A.row());              // OK
+  * \endcode
+  * The downside here is that the function foo3 might be significantly slower than foo1 because it won't be able to exploit vectorization, and will involve more
+  * expensive address computations even if the input is contiguously stored in memory. To overcome this issue, one might propose to overload internally calling a
+  * template function, e.g.:
+  * \code
+  * // in the .h:
+  * void foo(const Ref<MatrixXf>& A);
+  * void foo(const Ref<MatrixXf,0,Stride<> >& A);
+  *
+  * // in the .cpp:
+  * template<typename TypeOfA> void foo_impl(const TypeOfA& A) {
+  *     ... // crazy code goes here
+  * }
+  * void foo(const Ref<MatrixXf>& A) { foo_impl(A); }
+  * void foo(const Ref<MatrixXf,0,Stride<> >& A) { foo_impl(A); }
+  * \endcode
+  *
+  * See also the following stackoverflow questions for further references:
+  *  - <a href="http://stackoverflow.com/questions/21132538/correct-usage-of-the-eigenref-class">Correct usage of the Eigen::Ref<> class</a>
+  *
+  * \sa PlainObjectBase::Map(), \ref TopicStorageOrders
+  */
+template<typename PlainObjectType, int Options, typename StrideType> class Ref
+  : public RefBase<Ref<PlainObjectType, Options, StrideType> >
+{
+  private:
+    typedef internal::traits<Ref> Traits;
+    template<typename Derived>
+    EIGEN_DEVICE_FUNC inline Ref(const PlainObjectBase<Derived>& expr,
+                                 typename internal::enable_if<bool(Traits::template match<Derived>::MatchAtCompileTime),Derived>::type* = 0);
+  public:
+
+    typedef RefBase<Ref> Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Ref)
+
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename Derived>
+    EIGEN_DEVICE_FUNC inline Ref(PlainObjectBase<Derived>& expr,
+                                 typename internal::enable_if<bool(Traits::template match<Derived>::MatchAtCompileTime),Derived>::type* = 0)
+    {
+      EIGEN_STATIC_ASSERT(bool(Traits::template match<Derived>::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
+      Base::construct(expr.derived());
+    }
+    template<typename Derived>
+    EIGEN_DEVICE_FUNC inline Ref(const DenseBase<Derived>& expr,
+                                 typename internal::enable_if<bool(Traits::template match<Derived>::MatchAtCompileTime),Derived>::type* = 0)
+    #else
+    /** Implicit constructor from any dense expression */
+    template<typename Derived>
+    inline Ref(DenseBase<Derived>& expr)
+    #endif
+    {
+      EIGEN_STATIC_ASSERT(bool(internal::is_lvalue<Derived>::value), THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY);
+      EIGEN_STATIC_ASSERT(bool(Traits::template match<Derived>::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
+      EIGEN_STATIC_ASSERT(!Derived::IsPlainObjectBase,THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY);
+      Base::construct(expr.const_cast_derived());
+    }
+
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Ref)
+
+};
+
+// this is the const ref version
+template<typename TPlainObjectType, int Options, typename StrideType> class Ref<const TPlainObjectType, Options, StrideType>
+  : public RefBase<Ref<const TPlainObjectType, Options, StrideType> >
+{
+    typedef internal::traits<Ref> Traits;
+  public:
+
+    typedef RefBase<Ref> Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Ref)
+
+    template<typename Derived>
+    EIGEN_DEVICE_FUNC inline Ref(const DenseBase<Derived>& expr,
+                                 typename internal::enable_if<bool(Traits::template match<Derived>::ScalarTypeMatch),Derived>::type* = 0)
+    {
+//      std::cout << match_helper<Derived>::HasDirectAccess << "," << match_helper<Derived>::OuterStrideMatch << "," << match_helper<Derived>::InnerStrideMatch << "\n";
+//      std::cout << int(StrideType::OuterStrideAtCompileTime) << " - " << int(Derived::OuterStrideAtCompileTime) << "\n";
+//      std::cout << int(StrideType::InnerStrideAtCompileTime) << " - " << int(Derived::InnerStrideAtCompileTime) << "\n";
+      construct(expr.derived(), typename Traits::template match<Derived>::type());
+    }
+
+    EIGEN_DEVICE_FUNC inline Ref(const Ref& other) : Base(other) {
+      // copy constructor shall not copy the m_object, to avoid unnecessary malloc and copy
+    }
+
+    template<typename OtherRef>
+    EIGEN_DEVICE_FUNC inline Ref(const RefBase<OtherRef>& other) {
+      construct(other.derived(), typename Traits::template match<OtherRef>::type());
+    }
+
+  protected:
+
+    template<typename Expression>
+    EIGEN_DEVICE_FUNC void construct(const Expression& expr,internal::true_type)
+    {
+      Base::construct(expr);
+    }
+
+    template<typename Expression>
+    EIGEN_DEVICE_FUNC void construct(const Expression& expr, internal::false_type)
+    {
+      internal::call_assignment_no_alias(m_object,expr,internal::assign_op<Scalar,Scalar>());
+      Base::construct(m_object);
+    }
+
+  protected:
+    TPlainObjectType m_object;
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_REF_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Replicate.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Replicate.h
new file mode 100644
index 00000000..0b2d6d74
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Replicate.h
@@ -0,0 +1,142 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_REPLICATE_H
+#define EIGEN_REPLICATE_H
+
+namespace Eigen { 
+
+namespace internal {
+template<typename MatrixType,int RowFactor,int ColFactor>
+struct traits<Replicate<MatrixType,RowFactor,ColFactor> >
+ : traits<MatrixType>
+{
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename traits<MatrixType>::StorageKind StorageKind;
+  typedef typename traits<MatrixType>::XprKind XprKind;
+  typedef typename ref_selector<MatrixType>::type MatrixTypeNested;
+  typedef typename remove_reference<MatrixTypeNested>::type _MatrixTypeNested;
+  enum {
+    RowsAtCompileTime = RowFactor==Dynamic || int(MatrixType::RowsAtCompileTime)==Dynamic
+                      ? Dynamic
+                      : RowFactor * MatrixType::RowsAtCompileTime,
+    ColsAtCompileTime = ColFactor==Dynamic || int(MatrixType::ColsAtCompileTime)==Dynamic
+                      ? Dynamic
+                      : ColFactor * MatrixType::ColsAtCompileTime,
+   //FIXME we don't propagate the max sizes !!!
+    MaxRowsAtCompileTime = RowsAtCompileTime,
+    MaxColsAtCompileTime = ColsAtCompileTime,
+    IsRowMajor = MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1 ? 1
+               : MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1 ? 0
+               : (MatrixType::Flags & RowMajorBit) ? 1 : 0,
+    
+    // FIXME enable DirectAccess with negative strides?
+    Flags = IsRowMajor ? RowMajorBit : 0
+  };
+};
+}
+
+/**
+  * \class Replicate
+  * \ingroup Core_Module
+  *
+  * \brief Expression of the multiple replication of a matrix or vector
+  *
+  * \tparam MatrixType the type of the object we are replicating
+  * \tparam RowFactor number of repetitions at compile time along the vertical direction, can be Dynamic.
+  * \tparam ColFactor number of repetitions at compile time along the horizontal direction, can be Dynamic.
+  *
+  * This class represents an expression of the multiple replication of a matrix or vector.
+  * It is the return type of DenseBase::replicate() and most of the time
+  * this is the only way it is used.
+  *
+  * \sa DenseBase::replicate()
+  */
+template<typename MatrixType,int RowFactor,int ColFactor> class Replicate
+  : public internal::dense_xpr_base< Replicate<MatrixType,RowFactor,ColFactor> >::type
+{
+    typedef typename internal::traits<Replicate>::MatrixTypeNested MatrixTypeNested;
+    typedef typename internal::traits<Replicate>::_MatrixTypeNested _MatrixTypeNested;
+  public:
+
+    typedef typename internal::dense_xpr_base<Replicate>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Replicate)
+    typedef typename internal::remove_all<MatrixType>::type NestedExpression;
+
+    template<typename OriginalMatrixType>
+    EIGEN_DEVICE_FUNC
+    inline explicit Replicate(const OriginalMatrixType& matrix)
+      : m_matrix(matrix), m_rowFactor(RowFactor), m_colFactor(ColFactor)
+    {
+      EIGEN_STATIC_ASSERT((internal::is_same<typename internal::remove_const<MatrixType>::type,OriginalMatrixType>::value),
+                          THE_MATRIX_OR_EXPRESSION_THAT_YOU_PASSED_DOES_NOT_HAVE_THE_EXPECTED_TYPE)
+      eigen_assert(RowFactor!=Dynamic && ColFactor!=Dynamic);
+    }
+
+    template<typename OriginalMatrixType>
+    EIGEN_DEVICE_FUNC
+    inline Replicate(const OriginalMatrixType& matrix, Index rowFactor, Index colFactor)
+      : m_matrix(matrix), m_rowFactor(rowFactor), m_colFactor(colFactor)
+    {
+      EIGEN_STATIC_ASSERT((internal::is_same<typename internal::remove_const<MatrixType>::type,OriginalMatrixType>::value),
+                          THE_MATRIX_OR_EXPRESSION_THAT_YOU_PASSED_DOES_NOT_HAVE_THE_EXPECTED_TYPE)
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline Index rows() const { return m_matrix.rows() * m_rowFactor.value(); }
+    EIGEN_DEVICE_FUNC
+    inline Index cols() const { return m_matrix.cols() * m_colFactor.value(); }
+
+    EIGEN_DEVICE_FUNC
+    const _MatrixTypeNested& nestedExpression() const
+    { 
+      return m_matrix; 
+    }
+
+  protected:
+    MatrixTypeNested m_matrix;
+    const internal::variable_if_dynamic<Index, RowFactor> m_rowFactor;
+    const internal::variable_if_dynamic<Index, ColFactor> m_colFactor;
+};
+
+/**
+  * \return an expression of the replication of \c *this
+  *
+  * Example: \include MatrixBase_replicate.cpp
+  * Output: \verbinclude MatrixBase_replicate.out
+  *
+  * \sa VectorwiseOp::replicate(), DenseBase::replicate(Index,Index), class Replicate
+  */
+template<typename Derived>
+template<int RowFactor, int ColFactor>
+EIGEN_DEVICE_FUNC const Replicate<Derived,RowFactor,ColFactor>
+DenseBase<Derived>::replicate() const
+{
+  return Replicate<Derived,RowFactor,ColFactor>(derived());
+}
+
+/**
+  * \return an expression of the replication of each column (or row) of \c *this
+  *
+  * Example: \include DirectionWise_replicate_int.cpp
+  * Output: \verbinclude DirectionWise_replicate_int.out
+  *
+  * \sa VectorwiseOp::replicate(), DenseBase::replicate(), class Replicate
+  */
+template<typename ExpressionType, int Direction>
+EIGEN_DEVICE_FUNC const typename VectorwiseOp<ExpressionType,Direction>::ReplicateReturnType
+VectorwiseOp<ExpressionType,Direction>::replicate(Index factor) const
+{
+  return typename VectorwiseOp<ExpressionType,Direction>::ReplicateReturnType
+          (_expression(),Direction==Vertical?factor:1,Direction==Horizontal?factor:1);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_REPLICATE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/ReturnByValue.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/ReturnByValue.h
new file mode 100644
index 00000000..11dc86d0
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/ReturnByValue.h
@@ -0,0 +1,117 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_RETURNBYVALUE_H
+#define EIGEN_RETURNBYVALUE_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename Derived>
+struct traits<ReturnByValue<Derived> >
+  : public traits<typename traits<Derived>::ReturnType>
+{
+  enum {
+    // We're disabling the DirectAccess because e.g. the constructor of
+    // the Block-with-DirectAccess expression requires to have a coeffRef method.
+    // Also, we don't want to have to implement the stride stuff.
+    Flags = (traits<typename traits<Derived>::ReturnType>::Flags
+             | EvalBeforeNestingBit) & ~DirectAccessBit
+  };
+};
+
+/* The ReturnByValue object doesn't even have a coeff() method.
+ * So the only way that nesting it in an expression can work, is by evaluating it into a plain matrix.
+ * So internal::nested always gives the plain return matrix type.
+ *
+ * FIXME: I don't understand why we need this specialization: isn't this taken care of by the EvalBeforeNestingBit ??
+ * Answer: EvalBeforeNestingBit should be deprecated since we have the evaluators
+ */
+template<typename Derived,int n,typename PlainObject>
+struct nested_eval<ReturnByValue<Derived>, n, PlainObject>
+{
+  typedef typename traits<Derived>::ReturnType type;
+};
+
+} // end namespace internal
+
+/** \class ReturnByValue
+  * \ingroup Core_Module
+  *
+  */
+template<typename Derived> class ReturnByValue
+  : public internal::dense_xpr_base< ReturnByValue<Derived> >::type, internal::no_assignment_operator
+{
+  public:
+    typedef typename internal::traits<Derived>::ReturnType ReturnType;
+
+    typedef typename internal::dense_xpr_base<ReturnByValue>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(ReturnByValue)
+
+    template<typename Dest>
+    EIGEN_DEVICE_FUNC
+    inline void evalTo(Dest& dst) const
+    { static_cast<const Derived*>(this)->evalTo(dst); }
+    EIGEN_DEVICE_FUNC inline Index rows() const { return static_cast<const Derived*>(this)->rows(); }
+    EIGEN_DEVICE_FUNC inline Index cols() const { return static_cast<const Derived*>(this)->cols(); }
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+#define Unusable YOU_ARE_TRYING_TO_ACCESS_A_SINGLE_COEFFICIENT_IN_A_SPECIAL_EXPRESSION_WHERE_THAT_IS_NOT_ALLOWED_BECAUSE_THAT_WOULD_BE_INEFFICIENT
+    class Unusable{
+      Unusable(const Unusable&) {}
+      Unusable& operator=(const Unusable&) {return *this;}
+    };
+    const Unusable& coeff(Index) const { return *reinterpret_cast<const Unusable*>(this); }
+    const Unusable& coeff(Index,Index) const { return *reinterpret_cast<const Unusable*>(this); }
+    Unusable& coeffRef(Index) { return *reinterpret_cast<Unusable*>(this); }
+    Unusable& coeffRef(Index,Index) { return *reinterpret_cast<Unusable*>(this); }
+#undef Unusable
+#endif
+};
+
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC Derived& DenseBase<Derived>::operator=(const ReturnByValue<OtherDerived>& other)
+{
+  other.evalTo(derived());
+  return derived();
+}
+
+namespace internal {
+
+// Expression is evaluated in a temporary; default implementation of Assignment is bypassed so that
+// when a ReturnByValue expression is assigned, the evaluator is not constructed.
+// TODO: Finalize port to new regime; ReturnByValue should not exist in the expression world
+  
+template<typename Derived>
+struct evaluator<ReturnByValue<Derived> >
+  : public evaluator<typename internal::traits<Derived>::ReturnType>
+{
+  typedef ReturnByValue<Derived> XprType;
+  typedef typename internal::traits<Derived>::ReturnType PlainObject;
+  typedef evaluator<PlainObject> Base;
+  
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr)
+    : m_result(xpr.rows(), xpr.cols())
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+    xpr.evalTo(m_result);
+  }
+
+protected:
+  PlainObject m_result;
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_RETURNBYVALUE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Reverse.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Reverse.h
new file mode 100644
index 00000000..8b6b3ab0
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Reverse.h
@@ -0,0 +1,211 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2009 Ricard Marxer <email@ricardmarxer.com>
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_REVERSE_H
+#define EIGEN_REVERSE_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename MatrixType, int Direction>
+struct traits<Reverse<MatrixType, Direction> >
+ : traits<MatrixType>
+{
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename traits<MatrixType>::StorageKind StorageKind;
+  typedef typename traits<MatrixType>::XprKind XprKind;
+  typedef typename ref_selector<MatrixType>::type MatrixTypeNested;
+  typedef typename remove_reference<MatrixTypeNested>::type _MatrixTypeNested;
+  enum {
+    RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+    ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+    MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
+    Flags = _MatrixTypeNested::Flags & (RowMajorBit | LvalueBit)
+  };
+};
+
+template<typename PacketType, bool ReversePacket> struct reverse_packet_cond
+{
+  static inline PacketType run(const PacketType& x) { return preverse(x); }
+};
+
+template<typename PacketType> struct reverse_packet_cond<PacketType,false>
+{
+  static inline PacketType run(const PacketType& x) { return x; }
+};
+
+} // end namespace internal 
+
+/** \class Reverse
+  * \ingroup Core_Module
+  *
+  * \brief Expression of the reverse of a vector or matrix
+  *
+  * \tparam MatrixType the type of the object of which we are taking the reverse
+  * \tparam Direction defines the direction of the reverse operation, can be Vertical, Horizontal, or BothDirections
+  *
+  * This class represents an expression of the reverse of a vector.
+  * It is the return type of MatrixBase::reverse() and VectorwiseOp::reverse()
+  * and most of the time this is the only way it is used.
+  *
+  * \sa MatrixBase::reverse(), VectorwiseOp::reverse()
+  */
+template<typename MatrixType, int Direction> class Reverse
+  : public internal::dense_xpr_base< Reverse<MatrixType, Direction> >::type
+{
+  public:
+
+    typedef typename internal::dense_xpr_base<Reverse>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Reverse)
+    typedef typename internal::remove_all<MatrixType>::type NestedExpression;
+    using Base::IsRowMajor;
+
+  protected:
+    enum {
+      PacketSize = internal::packet_traits<Scalar>::size,
+      IsColMajor = !IsRowMajor,
+      ReverseRow = (Direction == Vertical)   || (Direction == BothDirections),
+      ReverseCol = (Direction == Horizontal) || (Direction == BothDirections),
+      OffsetRow  = ReverseRow && IsColMajor ? PacketSize : 1,
+      OffsetCol  = ReverseCol && IsRowMajor ? PacketSize : 1,
+      ReversePacket = (Direction == BothDirections)
+                    || ((Direction == Vertical)   && IsColMajor)
+                    || ((Direction == Horizontal) && IsRowMajor)
+    };
+    typedef internal::reverse_packet_cond<PacketScalar,ReversePacket> reverse_packet;
+  public:
+
+    EIGEN_DEVICE_FUNC explicit inline Reverse(const MatrixType& matrix) : m_matrix(matrix) { }
+
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Reverse)
+
+    EIGEN_DEVICE_FUNC inline Index rows() const { return m_matrix.rows(); }
+    EIGEN_DEVICE_FUNC inline Index cols() const { return m_matrix.cols(); }
+
+    EIGEN_DEVICE_FUNC inline Index innerStride() const
+    {
+      return -m_matrix.innerStride();
+    }
+
+    EIGEN_DEVICE_FUNC const typename internal::remove_all<typename MatrixType::Nested>::type&
+    nestedExpression() const 
+    {
+      return m_matrix;
+    }
+
+  protected:
+    typename MatrixType::Nested m_matrix;
+};
+
+/** \returns an expression of the reverse of *this.
+  *
+  * Example: \include MatrixBase_reverse.cpp
+  * Output: \verbinclude MatrixBase_reverse.out
+  *
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline typename DenseBase<Derived>::ReverseReturnType
+DenseBase<Derived>::reverse()
+{
+  return ReverseReturnType(derived());
+}
+
+
+//reverse const overload moved DenseBase.h due to a CUDA compiler bug
+
+/** This is the "in place" version of reverse: it reverses \c *this.
+  *
+  * In most cases it is probably better to simply use the reversed expression
+  * of a matrix. However, when reversing the matrix data itself is really needed,
+  * then this "in-place" version is probably the right choice because it provides
+  * the following additional benefits:
+  *  - less error prone: doing the same operation with .reverse() requires special care:
+  *    \code m = m.reverse().eval(); \endcode
+  *  - this API enables reverse operations without the need for a temporary
+  *  - it allows future optimizations (cache friendliness, etc.)
+  *
+  * \sa VectorwiseOp::reverseInPlace(), reverse() */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline void DenseBase<Derived>::reverseInPlace()
+{
+  if(cols()>rows())
+  {
+    Index half = cols()/2;
+    leftCols(half).swap(rightCols(half).reverse());
+    if((cols()%2)==1)
+    {
+      Index half2 = rows()/2;
+      col(half).head(half2).swap(col(half).tail(half2).reverse());
+    }
+  }
+  else
+  {
+    Index half = rows()/2;
+    topRows(half).swap(bottomRows(half).reverse());
+    if((rows()%2)==1)
+    {
+      Index half2 = cols()/2;
+      row(half).head(half2).swap(row(half).tail(half2).reverse());
+    }
+  }
+}
+
+namespace internal {
+  
+template<int Direction>
+struct vectorwise_reverse_inplace_impl;
+
+template<>
+struct vectorwise_reverse_inplace_impl<Vertical>
+{
+  template<typename ExpressionType>
+  static void run(ExpressionType &xpr)
+  {
+    Index half = xpr.rows()/2;
+    xpr.topRows(half).swap(xpr.bottomRows(half).colwise().reverse());
+  }
+};
+
+template<>
+struct vectorwise_reverse_inplace_impl<Horizontal>
+{
+  template<typename ExpressionType>
+  static void run(ExpressionType &xpr)
+  {
+    Index half = xpr.cols()/2;
+    xpr.leftCols(half).swap(xpr.rightCols(half).rowwise().reverse());
+  }
+};
+
+} // end namespace internal
+
+/** This is the "in place" version of VectorwiseOp::reverse: it reverses each column or row of \c *this.
+  *
+  * In most cases it is probably better to simply use the reversed expression
+  * of a matrix. However, when reversing the matrix data itself is really needed,
+  * then this "in-place" version is probably the right choice because it provides
+  * the following additional benefits:
+  *  - less error prone: doing the same operation with .reverse() requires special care:
+  *    \code m = m.reverse().eval(); \endcode
+  *  - this API enables reverse operations without the need for a temporary
+  *
+  * \sa DenseBase::reverseInPlace(), reverse() */
+template<typename ExpressionType, int Direction>
+EIGEN_DEVICE_FUNC void VectorwiseOp<ExpressionType,Direction>::reverseInPlace()
+{
+  internal::vectorwise_reverse_inplace_impl<Direction>::run(_expression().const_cast_derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_REVERSE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Select.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Select.h
new file mode 100644
index 00000000..79eec1b5
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Select.h
@@ -0,0 +1,162 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SELECT_H
+#define EIGEN_SELECT_H
+
+namespace Eigen { 
+
+/** \class Select
+  * \ingroup Core_Module
+  *
+  * \brief Expression of a coefficient wise version of the C++ ternary operator ?:
+  *
+  * \param ConditionMatrixType the type of the \em condition expression which must be a boolean matrix
+  * \param ThenMatrixType the type of the \em then expression
+  * \param ElseMatrixType the type of the \em else expression
+  *
+  * This class represents an expression of a coefficient wise version of the C++ ternary operator ?:.
+  * It is the return type of DenseBase::select() and most of the time this is the only way it is used.
+  *
+  * \sa DenseBase::select(const DenseBase<ThenDerived>&, const DenseBase<ElseDerived>&) const
+  */
+
+namespace internal {
+template<typename ConditionMatrixType, typename ThenMatrixType, typename ElseMatrixType>
+struct traits<Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> >
+ : traits<ThenMatrixType>
+{
+  typedef typename traits<ThenMatrixType>::Scalar Scalar;
+  typedef Dense StorageKind;
+  typedef typename traits<ThenMatrixType>::XprKind XprKind;
+  typedef typename ConditionMatrixType::Nested ConditionMatrixNested;
+  typedef typename ThenMatrixType::Nested ThenMatrixNested;
+  typedef typename ElseMatrixType::Nested ElseMatrixNested;
+  enum {
+    RowsAtCompileTime = ConditionMatrixType::RowsAtCompileTime,
+    ColsAtCompileTime = ConditionMatrixType::ColsAtCompileTime,
+    MaxRowsAtCompileTime = ConditionMatrixType::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = ConditionMatrixType::MaxColsAtCompileTime,
+    Flags = (unsigned int)ThenMatrixType::Flags & ElseMatrixType::Flags & RowMajorBit
+  };
+};
+}
+
+template<typename ConditionMatrixType, typename ThenMatrixType, typename ElseMatrixType>
+class Select : public internal::dense_xpr_base< Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> >::type,
+               internal::no_assignment_operator
+{
+  public:
+
+    typedef typename internal::dense_xpr_base<Select>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Select)
+
+    inline EIGEN_DEVICE_FUNC
+    Select(const ConditionMatrixType& a_conditionMatrix,
+           const ThenMatrixType& a_thenMatrix,
+           const ElseMatrixType& a_elseMatrix)
+      : m_condition(a_conditionMatrix), m_then(a_thenMatrix), m_else(a_elseMatrix)
+    {
+      eigen_assert(m_condition.rows() == m_then.rows() && m_condition.rows() == m_else.rows());
+      eigen_assert(m_condition.cols() == m_then.cols() && m_condition.cols() == m_else.cols());
+    }
+
+    inline EIGEN_DEVICE_FUNC Index rows() const { return m_condition.rows(); }
+    inline EIGEN_DEVICE_FUNC Index cols() const { return m_condition.cols(); }
+
+    inline EIGEN_DEVICE_FUNC
+    const Scalar coeff(Index i, Index j) const
+    {
+      if (m_condition.coeff(i,j))
+        return m_then.coeff(i,j);
+      else
+        return m_else.coeff(i,j);
+    }
+
+    inline EIGEN_DEVICE_FUNC
+    const Scalar coeff(Index i) const
+    {
+      if (m_condition.coeff(i))
+        return m_then.coeff(i);
+      else
+        return m_else.coeff(i);
+    }
+
+    inline EIGEN_DEVICE_FUNC const ConditionMatrixType& conditionMatrix() const
+    {
+      return m_condition;
+    }
+
+    inline EIGEN_DEVICE_FUNC const ThenMatrixType& thenMatrix() const
+    {
+      return m_then;
+    }
+
+    inline EIGEN_DEVICE_FUNC const ElseMatrixType& elseMatrix() const
+    {
+      return m_else;
+    }
+
+  protected:
+    typename ConditionMatrixType::Nested m_condition;
+    typename ThenMatrixType::Nested m_then;
+    typename ElseMatrixType::Nested m_else;
+};
+
+
+/** \returns a matrix where each coefficient (i,j) is equal to \a thenMatrix(i,j)
+  * if \c *this(i,j), and \a elseMatrix(i,j) otherwise.
+  *
+  * Example: \include MatrixBase_select.cpp
+  * Output: \verbinclude MatrixBase_select.out
+  *
+  * \sa class Select
+  */
+template<typename Derived>
+template<typename ThenDerived,typename ElseDerived>
+inline const Select<Derived,ThenDerived,ElseDerived>
+DenseBase<Derived>::select(const DenseBase<ThenDerived>& thenMatrix,
+                            const DenseBase<ElseDerived>& elseMatrix) const
+{
+  return Select<Derived,ThenDerived,ElseDerived>(derived(), thenMatrix.derived(), elseMatrix.derived());
+}
+
+/** Version of DenseBase::select(const DenseBase&, const DenseBase&) with
+  * the \em else expression being a scalar value.
+  *
+  * \sa DenseBase::select(const DenseBase<ThenDerived>&, const DenseBase<ElseDerived>&) const, class Select
+  */
+template<typename Derived>
+template<typename ThenDerived>
+inline const Select<Derived,ThenDerived, typename ThenDerived::ConstantReturnType>
+DenseBase<Derived>::select(const DenseBase<ThenDerived>& thenMatrix,
+                           const typename ThenDerived::Scalar& elseScalar) const
+{
+  return Select<Derived,ThenDerived,typename ThenDerived::ConstantReturnType>(
+    derived(), thenMatrix.derived(), ThenDerived::Constant(rows(),cols(),elseScalar));
+}
+
+/** Version of DenseBase::select(const DenseBase&, const DenseBase&) with
+  * the \em then expression being a scalar value.
+  *
+  * \sa DenseBase::select(const DenseBase<ThenDerived>&, const DenseBase<ElseDerived>&) const, class Select
+  */
+template<typename Derived>
+template<typename ElseDerived>
+inline const Select<Derived, typename ElseDerived::ConstantReturnType, ElseDerived >
+DenseBase<Derived>::select(const typename ElseDerived::Scalar& thenScalar,
+                           const DenseBase<ElseDerived>& elseMatrix) const
+{
+  return Select<Derived,typename ElseDerived::ConstantReturnType,ElseDerived>(
+    derived(), ElseDerived::Constant(rows(),cols(),thenScalar), elseMatrix.derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SELECT_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/SelfAdjointView.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/SelfAdjointView.h
new file mode 100644
index 00000000..7e71fe3c
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/SelfAdjointView.h
@@ -0,0 +1,350 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SELFADJOINTMATRIX_H
+#define EIGEN_SELFADJOINTMATRIX_H
+
+namespace Eigen { 
+
+/** \class SelfAdjointView
+  * \ingroup Core_Module
+  *
+  *
+  * \brief Expression of a selfadjoint matrix from a triangular part of a dense matrix
+  *
+  * \param MatrixType the type of the dense matrix storing the coefficients
+  * \param TriangularPart can be either \c #Lower or \c #Upper
+  *
+  * This class is an expression of a sefladjoint matrix from a triangular part of a matrix
+  * with given dense storage of the coefficients. It is the return type of MatrixBase::selfadjointView()
+  * and most of the time this is the only way that it is used.
+  *
+  * \sa class TriangularBase, MatrixBase::selfadjointView()
+  */
+
+namespace internal {
+template<typename MatrixType, unsigned int UpLo>
+struct traits<SelfAdjointView<MatrixType, UpLo> > : traits<MatrixType>
+{
+  typedef typename ref_selector<MatrixType>::non_const_type MatrixTypeNested;
+  typedef typename remove_all<MatrixTypeNested>::type MatrixTypeNestedCleaned;
+  typedef MatrixType ExpressionType;
+  typedef typename MatrixType::PlainObject FullMatrixType;
+  enum {
+    Mode = UpLo | SelfAdjoint,
+    FlagsLvalueBit = is_lvalue<MatrixType>::value ? LvalueBit : 0,
+    Flags =  MatrixTypeNestedCleaned::Flags & (HereditaryBits|FlagsLvalueBit)
+           & (~(PacketAccessBit | DirectAccessBit | LinearAccessBit)) // FIXME these flags should be preserved
+  };
+};
+}
+
+
+template<typename _MatrixType, unsigned int UpLo> class SelfAdjointView
+  : public TriangularBase<SelfAdjointView<_MatrixType, UpLo> >
+{
+  public:
+
+    typedef _MatrixType MatrixType;
+    typedef TriangularBase<SelfAdjointView> Base;
+    typedef typename internal::traits<SelfAdjointView>::MatrixTypeNested MatrixTypeNested;
+    typedef typename internal::traits<SelfAdjointView>::MatrixTypeNestedCleaned MatrixTypeNestedCleaned;
+    typedef MatrixTypeNestedCleaned NestedExpression;
+
+    /** \brief The type of coefficients in this matrix */
+    typedef typename internal::traits<SelfAdjointView>::Scalar Scalar; 
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef typename internal::remove_all<typename MatrixType::ConjugateReturnType>::type MatrixConjugateReturnType;
+
+    enum {
+      Mode = internal::traits<SelfAdjointView>::Mode,
+      Flags = internal::traits<SelfAdjointView>::Flags,
+      TransposeMode = ((Mode & Upper) ? Lower : 0) | ((Mode & Lower) ? Upper : 0)
+    };
+    typedef typename MatrixType::PlainObject PlainObject;
+
+    EIGEN_DEVICE_FUNC
+    explicit inline SelfAdjointView(MatrixType& matrix) : m_matrix(matrix)
+    {}
+
+    EIGEN_DEVICE_FUNC
+    inline Index rows() const { return m_matrix.rows(); }
+    EIGEN_DEVICE_FUNC
+    inline Index cols() const { return m_matrix.cols(); }
+    EIGEN_DEVICE_FUNC
+    inline Index outerStride() const { return m_matrix.outerStride(); }
+    EIGEN_DEVICE_FUNC
+    inline Index innerStride() const { return m_matrix.innerStride(); }
+
+    /** \sa MatrixBase::coeff()
+      * \warning the coordinates must fit into the referenced triangular part
+      */
+    EIGEN_DEVICE_FUNC
+    inline Scalar coeff(Index row, Index col) const
+    {
+      Base::check_coordinates_internal(row, col);
+      return m_matrix.coeff(row, col);
+    }
+
+    /** \sa MatrixBase::coeffRef()
+      * \warning the coordinates must fit into the referenced triangular part
+      */
+    EIGEN_DEVICE_FUNC
+    inline Scalar& coeffRef(Index row, Index col)
+    {
+      EIGEN_STATIC_ASSERT_LVALUE(SelfAdjointView);
+      Base::check_coordinates_internal(row, col);
+      return m_matrix.coeffRef(row, col);
+    }
+
+    /** \internal */
+    EIGEN_DEVICE_FUNC
+    const MatrixTypeNestedCleaned& _expression() const { return m_matrix; }
+
+    EIGEN_DEVICE_FUNC
+    const MatrixTypeNestedCleaned& nestedExpression() const { return m_matrix; }
+    EIGEN_DEVICE_FUNC
+    MatrixTypeNestedCleaned& nestedExpression() { return m_matrix; }
+
+    /** Efficient triangular matrix times vector/matrix product */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    const Product<SelfAdjointView,OtherDerived>
+    operator*(const MatrixBase<OtherDerived>& rhs) const
+    {
+      return Product<SelfAdjointView,OtherDerived>(*this, rhs.derived());
+    }
+
+    /** Efficient vector/matrix times triangular matrix product */
+    template<typename OtherDerived> friend
+    EIGEN_DEVICE_FUNC
+    const Product<OtherDerived,SelfAdjointView>
+    operator*(const MatrixBase<OtherDerived>& lhs, const SelfAdjointView& rhs)
+    {
+      return Product<OtherDerived,SelfAdjointView>(lhs.derived(),rhs);
+    }
+    
+    friend EIGEN_DEVICE_FUNC
+    const SelfAdjointView<const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar,MatrixType,product),UpLo>
+    operator*(const Scalar& s, const SelfAdjointView& mat)
+    {
+      return (s*mat.nestedExpression()).template selfadjointView<UpLo>();
+    }
+
+    /** Perform a symmetric rank 2 update of the selfadjoint matrix \c *this:
+      * \f$ this = this + \alpha u v^* + conj(\alpha) v u^* \f$
+      * \returns a reference to \c *this
+      *
+      * The vectors \a u and \c v \b must be column vectors, however they can be
+      * a adjoint expression without any overhead. Only the meaningful triangular
+      * part of the matrix is updated, the rest is left unchanged.
+      *
+      * \sa rankUpdate(const MatrixBase<DerivedU>&, Scalar)
+      */
+    template<typename DerivedU, typename DerivedV>
+    EIGEN_DEVICE_FUNC
+    SelfAdjointView& rankUpdate(const MatrixBase<DerivedU>& u, const MatrixBase<DerivedV>& v, const Scalar& alpha = Scalar(1));
+
+    /** Perform a symmetric rank K update of the selfadjoint matrix \c *this:
+      * \f$ this = this + \alpha ( u u^* ) \f$ where \a u is a vector or matrix.
+      *
+      * \returns a reference to \c *this
+      *
+      * Note that to perform \f$ this = this + \alpha ( u^* u ) \f$ you can simply
+      * call this function with u.adjoint().
+      *
+      * \sa rankUpdate(const MatrixBase<DerivedU>&, const MatrixBase<DerivedV>&, Scalar)
+      */
+    template<typename DerivedU>
+    EIGEN_DEVICE_FUNC
+    SelfAdjointView& rankUpdate(const MatrixBase<DerivedU>& u, const Scalar& alpha = Scalar(1));
+
+    /** \returns an expression of a triangular view extracted from the current selfadjoint view of a given triangular part
+      *
+      * The parameter \a TriMode can have the following values: \c #Upper, \c #StrictlyUpper, \c #UnitUpper,
+      * \c #Lower, \c #StrictlyLower, \c #UnitLower.
+      *
+      * If \c TriMode references the same triangular part than \c *this, then this method simply return a \c TriangularView of the nested expression,
+      * otherwise, the nested expression is first transposed, thus returning a \c TriangularView<Transpose<MatrixType>> object.
+      *
+      * \sa MatrixBase::triangularView(), class TriangularView
+      */
+    template<unsigned int TriMode>
+    EIGEN_DEVICE_FUNC
+    typename internal::conditional<(TriMode&(Upper|Lower))==(UpLo&(Upper|Lower)),
+                                   TriangularView<MatrixType,TriMode>,
+                                   TriangularView<typename MatrixType::AdjointReturnType,TriMode> >::type
+    triangularView() const
+    {
+      typename internal::conditional<(TriMode&(Upper|Lower))==(UpLo&(Upper|Lower)), MatrixType&, typename MatrixType::ConstTransposeReturnType>::type tmp1(m_matrix);
+      typename internal::conditional<(TriMode&(Upper|Lower))==(UpLo&(Upper|Lower)), MatrixType&, typename MatrixType::AdjointReturnType>::type tmp2(tmp1);
+      return typename internal::conditional<(TriMode&(Upper|Lower))==(UpLo&(Upper|Lower)),
+                                   TriangularView<MatrixType,TriMode>,
+                                   TriangularView<typename MatrixType::AdjointReturnType,TriMode> >::type(tmp2);
+    }
+
+    typedef SelfAdjointView<const MatrixConjugateReturnType,Mode> ConjugateReturnType;
+    /** \sa MatrixBase::conjugate() const */
+    EIGEN_DEVICE_FUNC
+    inline const ConjugateReturnType conjugate() const
+    { return ConjugateReturnType(m_matrix.conjugate()); }
+
+    typedef SelfAdjointView<const typename MatrixType::AdjointReturnType,TransposeMode> AdjointReturnType;
+    /** \sa MatrixBase::adjoint() const */
+    EIGEN_DEVICE_FUNC
+    inline const AdjointReturnType adjoint() const
+    { return AdjointReturnType(m_matrix.adjoint()); }
+
+    typedef SelfAdjointView<typename MatrixType::TransposeReturnType,TransposeMode> TransposeReturnType;
+     /** \sa MatrixBase::transpose() */
+    EIGEN_DEVICE_FUNC
+    inline TransposeReturnType transpose()
+    {
+      EIGEN_STATIC_ASSERT_LVALUE(MatrixType)
+      typename MatrixType::TransposeReturnType tmp(m_matrix);
+      return TransposeReturnType(tmp);
+    }
+
+    typedef SelfAdjointView<const typename MatrixType::ConstTransposeReturnType,TransposeMode> ConstTransposeReturnType;
+    /** \sa MatrixBase::transpose() const */
+    EIGEN_DEVICE_FUNC
+    inline const ConstTransposeReturnType transpose() const
+    {
+      return ConstTransposeReturnType(m_matrix.transpose());
+    }
+
+    /** \returns a const expression of the main diagonal of the matrix \c *this
+      *
+      * This method simply returns the diagonal of the nested expression, thus by-passing the SelfAdjointView decorator.
+      *
+      * \sa MatrixBase::diagonal(), class Diagonal */
+    EIGEN_DEVICE_FUNC
+    typename MatrixType::ConstDiagonalReturnType diagonal() const
+    {
+      return typename MatrixType::ConstDiagonalReturnType(m_matrix);
+    }
+
+/////////// Cholesky module ///////////
+
+    const LLT<PlainObject, UpLo> llt() const;
+    const LDLT<PlainObject, UpLo> ldlt() const;
+
+/////////// Eigenvalue module ///////////
+
+    /** Real part of #Scalar */
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    /** Return type of eigenvalues() */
+    typedef Matrix<RealScalar, internal::traits<MatrixType>::ColsAtCompileTime, 1> EigenvaluesReturnType;
+
+    EIGEN_DEVICE_FUNC
+    EigenvaluesReturnType eigenvalues() const;
+    EIGEN_DEVICE_FUNC
+    RealScalar operatorNorm() const;
+
+  protected:
+    MatrixTypeNested m_matrix;
+};
+
+
+// template<typename OtherDerived, typename MatrixType, unsigned int UpLo>
+// internal::selfadjoint_matrix_product_returntype<OtherDerived,SelfAdjointView<MatrixType,UpLo> >
+// operator*(const MatrixBase<OtherDerived>& lhs, const SelfAdjointView<MatrixType,UpLo>& rhs)
+// {
+//   return internal::matrix_selfadjoint_product_returntype<OtherDerived,SelfAdjointView<MatrixType,UpLo> >(lhs.derived(),rhs);
+// }
+
+// selfadjoint to dense matrix
+
+namespace internal {
+
+// TODO currently a selfadjoint expression has the form SelfAdjointView<.,.>
+//      in the future selfadjoint-ness should be defined by the expression traits
+//      such that Transpose<SelfAdjointView<.,.> > is valid. (currently TriangularBase::transpose() is overloaded to make it work)
+template<typename MatrixType, unsigned int Mode>
+struct evaluator_traits<SelfAdjointView<MatrixType,Mode> >
+{
+  typedef typename storage_kind_to_evaluator_kind<typename MatrixType::StorageKind>::Kind Kind;
+  typedef SelfAdjointShape Shape;
+};
+
+template<int UpLo, int SetOpposite, typename DstEvaluatorTypeT, typename SrcEvaluatorTypeT, typename Functor, int Version>
+class triangular_dense_assignment_kernel<UpLo,SelfAdjoint,SetOpposite,DstEvaluatorTypeT,SrcEvaluatorTypeT,Functor,Version>
+  : public generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, Version>
+{
+protected:
+  typedef generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, Version> Base;
+  typedef typename Base::DstXprType DstXprType;
+  typedef typename Base::SrcXprType SrcXprType;
+  using Base::m_dst;
+  using Base::m_src;
+  using Base::m_functor;
+public:
+  
+  typedef typename Base::DstEvaluatorType DstEvaluatorType;
+  typedef typename Base::SrcEvaluatorType SrcEvaluatorType;
+  typedef typename Base::Scalar Scalar;
+  typedef typename Base::AssignmentTraits AssignmentTraits;
+  
+  
+  EIGEN_DEVICE_FUNC triangular_dense_assignment_kernel(DstEvaluatorType &dst, const SrcEvaluatorType &src, const Functor &func, DstXprType& dstExpr)
+    : Base(dst, src, func, dstExpr)
+  {}
+  
+  EIGEN_DEVICE_FUNC void assignCoeff(Index row, Index col)
+  {
+    eigen_internal_assert(row!=col);
+    Scalar tmp = m_src.coeff(row,col);
+    m_functor.assignCoeff(m_dst.coeffRef(row,col), tmp);
+    m_functor.assignCoeff(m_dst.coeffRef(col,row), numext::conj(tmp));
+  }
+  
+  EIGEN_DEVICE_FUNC void assignDiagonalCoeff(Index id)
+  {
+    Base::assignCoeff(id,id);
+  }
+  
+  EIGEN_DEVICE_FUNC void assignOppositeCoeff(Index, Index)
+  { eigen_internal_assert(false && "should never be called"); }
+};
+
+} // end namespace internal
+
+/***************************************************************************
+* Implementation of MatrixBase methods
+***************************************************************************/
+
+/** This is the const version of MatrixBase::selfadjointView() */
+template<typename Derived>
+template<unsigned int UpLo>
+EIGEN_DEVICE_FUNC typename MatrixBase<Derived>::template ConstSelfAdjointViewReturnType<UpLo>::Type
+MatrixBase<Derived>::selfadjointView() const
+{
+  return typename ConstSelfAdjointViewReturnType<UpLo>::Type(derived());
+}
+
+/** \returns an expression of a symmetric/self-adjoint view extracted from the upper or lower triangular part of the current matrix
+  *
+  * The parameter \a UpLo can be either \c #Upper or \c #Lower
+  *
+  * Example: \include MatrixBase_selfadjointView.cpp
+  * Output: \verbinclude MatrixBase_selfadjointView.out
+  *
+  * \sa class SelfAdjointView
+  */
+template<typename Derived>
+template<unsigned int UpLo>
+EIGEN_DEVICE_FUNC typename MatrixBase<Derived>::template SelfAdjointViewReturnType<UpLo>::Type
+MatrixBase<Derived>::selfadjointView()
+{
+  return typename SelfAdjointViewReturnType<UpLo>::Type(derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SELFADJOINTMATRIX_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/SelfCwiseBinaryOp.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/SelfCwiseBinaryOp.h
new file mode 100644
index 00000000..50099df8
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/SelfCwiseBinaryOp.h
@@ -0,0 +1,51 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SELFCWISEBINARYOP_H
+#define EIGEN_SELFCWISEBINARYOP_H
+
+namespace Eigen { 
+
+// TODO generalize the scalar type of 'other'
+
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::operator*=(const Scalar& other)
+{
+  typedef typename Derived::PlainObject PlainObject;
+  internal::call_assignment(this->derived(), PlainObject::Constant(rows(),cols(),other), internal::mul_assign_op<Scalar,Scalar>());
+  return derived();
+}
+
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& ArrayBase<Derived>::operator+=(const Scalar& other)
+{
+  typedef typename Derived::PlainObject PlainObject;
+  internal::call_assignment(this->derived(), PlainObject::Constant(rows(),cols(),other), internal::add_assign_op<Scalar,Scalar>());
+  return derived();
+}
+
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& ArrayBase<Derived>::operator-=(const Scalar& other)
+{
+  typedef typename Derived::PlainObject PlainObject;
+  internal::call_assignment(this->derived(), PlainObject::Constant(rows(),cols(),other), internal::sub_assign_op<Scalar,Scalar>());
+  return derived();
+}
+
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::operator/=(const Scalar& other)
+{
+  typedef typename Derived::PlainObject PlainObject;
+  internal::call_assignment(this->derived(), PlainObject::Constant(rows(),cols(),other), internal::div_assign_op<Scalar,Scalar>());
+  return derived();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SELFCWISEBINARYOP_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Solve.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Solve.h
new file mode 100644
index 00000000..a8daea51
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Solve.h
@@ -0,0 +1,188 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SOLVE_H
+#define EIGEN_SOLVE_H
+
+namespace Eigen {
+
+template<typename Decomposition, typename RhsType, typename StorageKind> class SolveImpl;
+  
+/** \class Solve
+  * \ingroup Core_Module
+  *
+  * \brief Pseudo expression representing a solving operation
+  *
+  * \tparam Decomposition the type of the matrix or decomposion object
+  * \tparam Rhstype the type of the right-hand side
+  *
+  * This class represents an expression of A.solve(B)
+  * and most of the time this is the only way it is used.
+  *
+  */
+namespace internal {
+
+// this solve_traits class permits to determine the evaluation type with respect to storage kind (Dense vs Sparse)
+template<typename Decomposition, typename RhsType,typename StorageKind> struct solve_traits;
+
+template<typename Decomposition, typename RhsType>
+struct solve_traits<Decomposition,RhsType,Dense>
+{
+  typedef typename make_proper_matrix_type<typename RhsType::Scalar,
+                 Decomposition::ColsAtCompileTime,
+                 RhsType::ColsAtCompileTime,
+                 RhsType::PlainObject::Options,
+                 Decomposition::MaxColsAtCompileTime,
+                 RhsType::MaxColsAtCompileTime>::type PlainObject;
+};
+
+template<typename Decomposition, typename RhsType>
+struct traits<Solve<Decomposition, RhsType> >
+  : traits<typename solve_traits<Decomposition,RhsType,typename internal::traits<RhsType>::StorageKind>::PlainObject>
+{
+  typedef typename solve_traits<Decomposition,RhsType,typename internal::traits<RhsType>::StorageKind>::PlainObject PlainObject;
+  typedef typename promote_index_type<typename Decomposition::StorageIndex, typename RhsType::StorageIndex>::type StorageIndex;
+  typedef traits<PlainObject> BaseTraits;
+  enum {
+    Flags = BaseTraits::Flags & RowMajorBit,
+    CoeffReadCost = HugeCost
+  };
+};
+
+}
+
+
+template<typename Decomposition, typename RhsType>
+class Solve : public SolveImpl<Decomposition,RhsType,typename internal::traits<RhsType>::StorageKind>
+{
+public:
+  typedef typename internal::traits<Solve>::PlainObject PlainObject;
+  typedef typename internal::traits<Solve>::StorageIndex StorageIndex;
+  
+  Solve(const Decomposition &dec, const RhsType &rhs)
+    : m_dec(dec), m_rhs(rhs)
+  {}
+  
+  EIGEN_DEVICE_FUNC Index rows() const { return m_dec.cols(); }
+  EIGEN_DEVICE_FUNC Index cols() const { return m_rhs.cols(); }
+
+  EIGEN_DEVICE_FUNC const Decomposition& dec() const { return m_dec; }
+  EIGEN_DEVICE_FUNC const RhsType&       rhs() const { return m_rhs; }
+
+protected:
+  const Decomposition &m_dec;
+  const RhsType       &m_rhs;
+};
+
+
+// Specialization of the Solve expression for dense results
+template<typename Decomposition, typename RhsType>
+class SolveImpl<Decomposition,RhsType,Dense>
+  : public MatrixBase<Solve<Decomposition,RhsType> >
+{
+  typedef Solve<Decomposition,RhsType> Derived;
+  
+public:
+  
+  typedef MatrixBase<Solve<Decomposition,RhsType> > Base;
+  EIGEN_DENSE_PUBLIC_INTERFACE(Derived)
+
+private:
+  
+  Scalar coeff(Index row, Index col) const;
+  Scalar coeff(Index i) const;
+};
+
+// Generic API dispatcher
+template<typename Decomposition, typename RhsType, typename StorageKind>
+class SolveImpl : public internal::generic_xpr_base<Solve<Decomposition,RhsType>, MatrixXpr, StorageKind>::type
+{
+  public:
+    typedef typename internal::generic_xpr_base<Solve<Decomposition,RhsType>, MatrixXpr, StorageKind>::type Base;
+};
+
+namespace internal {
+
+// Evaluator of Solve -> eval into a temporary
+template<typename Decomposition, typename RhsType>
+struct evaluator<Solve<Decomposition,RhsType> >
+  : public evaluator<typename Solve<Decomposition,RhsType>::PlainObject>
+{
+  typedef Solve<Decomposition,RhsType> SolveType;
+  typedef typename SolveType::PlainObject PlainObject;
+  typedef evaluator<PlainObject> Base;
+
+  enum { Flags = Base::Flags | EvalBeforeNestingBit };
+  
+  EIGEN_DEVICE_FUNC explicit evaluator(const SolveType& solve)
+    : m_result(solve.rows(), solve.cols())
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+    solve.dec()._solve_impl(solve.rhs(), m_result);
+  }
+  
+protected:  
+  PlainObject m_result;
+};
+
+// Specialization for "dst = dec.solve(rhs)"
+// NOTE we need to specialize it for Dense2Dense to avoid ambiguous specialization error and a Sparse2Sparse specialization must exist somewhere
+template<typename DstXprType, typename DecType, typename RhsType, typename Scalar>
+struct Assignment<DstXprType, Solve<DecType,RhsType>, internal::assign_op<Scalar,Scalar>, Dense2Dense>
+{
+  typedef Solve<DecType,RhsType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    src.dec()._solve_impl(src.rhs(), dst);
+  }
+};
+
+// Specialization for "dst = dec.transpose().solve(rhs)"
+template<typename DstXprType, typename DecType, typename RhsType, typename Scalar>
+struct Assignment<DstXprType, Solve<Transpose<const DecType>,RhsType>, internal::assign_op<Scalar,Scalar>, Dense2Dense>
+{
+  typedef Solve<Transpose<const DecType>,RhsType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    src.dec().nestedExpression().template _solve_impl_transposed<false>(src.rhs(), dst);
+  }
+};
+
+// Specialization for "dst = dec.adjoint().solve(rhs)"
+template<typename DstXprType, typename DecType, typename RhsType, typename Scalar>
+struct Assignment<DstXprType, Solve<CwiseUnaryOp<internal::scalar_conjugate_op<typename DecType::Scalar>, const Transpose<const DecType> >,RhsType>,
+                  internal::assign_op<Scalar,Scalar>, Dense2Dense>
+{
+  typedef Solve<CwiseUnaryOp<internal::scalar_conjugate_op<typename DecType::Scalar>, const Transpose<const DecType> >,RhsType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+    
+    src.dec().nestedExpression().nestedExpression().template _solve_impl_transposed<true>(src.rhs(), dst);
+  }
+};
+
+} // end namepsace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SOLVE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/SolveTriangular.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/SolveTriangular.h
new file mode 100644
index 00000000..a0011d4f
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/SolveTriangular.h
@@ -0,0 +1,232 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SOLVETRIANGULAR_H
+#define EIGEN_SOLVETRIANGULAR_H
+
+namespace Eigen { 
+
+namespace internal {
+
+// Forward declarations:
+// The following two routines are implemented in the products/TriangularSolver*.h files
+template<typename LhsScalar, typename RhsScalar, typename Index, int Side, int Mode, bool Conjugate, int StorageOrder>
+struct triangular_solve_vector;
+
+template <typename Scalar, typename Index, int Side, int Mode, bool Conjugate, int TriStorageOrder, int OtherStorageOrder>
+struct triangular_solve_matrix;
+
+// small helper struct extracting some traits on the underlying solver operation
+template<typename Lhs, typename Rhs, int Side>
+class trsolve_traits
+{
+  private:
+    enum {
+      RhsIsVectorAtCompileTime = (Side==OnTheLeft ? Rhs::ColsAtCompileTime : Rhs::RowsAtCompileTime)==1
+    };
+  public:
+    enum {
+      Unrolling   = (RhsIsVectorAtCompileTime && Rhs::SizeAtCompileTime != Dynamic && Rhs::SizeAtCompileTime <= 8)
+                  ? CompleteUnrolling : NoUnrolling,
+      RhsVectors  = RhsIsVectorAtCompileTime ? 1 : Dynamic
+    };
+};
+
+template<typename Lhs, typename Rhs,
+  int Side, // can be OnTheLeft/OnTheRight
+  int Mode, // can be Upper/Lower | UnitDiag
+  int Unrolling = trsolve_traits<Lhs,Rhs,Side>::Unrolling,
+  int RhsVectors = trsolve_traits<Lhs,Rhs,Side>::RhsVectors
+  >
+struct triangular_solver_selector;
+
+template<typename Lhs, typename Rhs, int Side, int Mode>
+struct triangular_solver_selector<Lhs,Rhs,Side,Mode,NoUnrolling,1>
+{
+  typedef typename Lhs::Scalar LhsScalar;
+  typedef typename Rhs::Scalar RhsScalar;
+  typedef blas_traits<Lhs> LhsProductTraits;
+  typedef typename LhsProductTraits::ExtractType ActualLhsType;
+  typedef Map<Matrix<RhsScalar,Dynamic,1>, Aligned> MappedRhs;
+  static void run(const Lhs& lhs, Rhs& rhs)
+  {
+    ActualLhsType actualLhs = LhsProductTraits::extract(lhs);
+
+    // FIXME find a way to allow an inner stride if packet_traits<Scalar>::size==1
+
+    bool useRhsDirectly = Rhs::InnerStrideAtCompileTime==1 || rhs.innerStride()==1;
+
+    ei_declare_aligned_stack_constructed_variable(RhsScalar,actualRhs,rhs.size(),
+                                                  (useRhsDirectly ? rhs.data() : 0));
+                                                  
+    if(!useRhsDirectly)
+      MappedRhs(actualRhs,rhs.size()) = rhs;
+
+    triangular_solve_vector<LhsScalar, RhsScalar, Index, Side, Mode, LhsProductTraits::NeedToConjugate,
+                            (int(Lhs::Flags) & RowMajorBit) ? RowMajor : ColMajor>
+      ::run(actualLhs.cols(), actualLhs.data(), actualLhs.outerStride(), actualRhs);
+
+    if(!useRhsDirectly)
+      rhs = MappedRhs(actualRhs, rhs.size());
+  }
+};
+
+// the rhs is a matrix
+template<typename Lhs, typename Rhs, int Side, int Mode>
+struct triangular_solver_selector<Lhs,Rhs,Side,Mode,NoUnrolling,Dynamic>
+{
+  typedef typename Rhs::Scalar Scalar;
+  typedef blas_traits<Lhs> LhsProductTraits;
+  typedef typename LhsProductTraits::DirectLinearAccessType ActualLhsType;
+
+  static void run(const Lhs& lhs, Rhs& rhs)
+  {
+    typename internal::add_const_on_value_type<ActualLhsType>::type actualLhs = LhsProductTraits::extract(lhs);
+
+    const Index size = lhs.rows();
+    const Index othersize = Side==OnTheLeft? rhs.cols() : rhs.rows();
+
+    typedef internal::gemm_blocking_space<(Rhs::Flags&RowMajorBit) ? RowMajor : ColMajor,Scalar,Scalar,
+              Rhs::MaxRowsAtCompileTime, Rhs::MaxColsAtCompileTime, Lhs::MaxRowsAtCompileTime,4> BlockingType;
+
+    BlockingType blocking(rhs.rows(), rhs.cols(), size, 1, false);
+
+    triangular_solve_matrix<Scalar,Index,Side,Mode,LhsProductTraits::NeedToConjugate,(int(Lhs::Flags) & RowMajorBit) ? RowMajor : ColMajor,
+                               (Rhs::Flags&RowMajorBit) ? RowMajor : ColMajor>
+      ::run(size, othersize, &actualLhs.coeffRef(0,0), actualLhs.outerStride(), &rhs.coeffRef(0,0), rhs.outerStride(), blocking);
+  }
+};
+
+/***************************************************************************
+* meta-unrolling implementation
+***************************************************************************/
+
+template<typename Lhs, typename Rhs, int Mode, int LoopIndex, int Size,
+         bool Stop = LoopIndex==Size>
+struct triangular_solver_unroller;
+
+template<typename Lhs, typename Rhs, int Mode, int LoopIndex, int Size>
+struct triangular_solver_unroller<Lhs,Rhs,Mode,LoopIndex,Size,false> {
+  enum {
+    IsLower = ((Mode&Lower)==Lower),
+    DiagIndex  = IsLower ? LoopIndex : Size - LoopIndex - 1,
+    StartIndex = IsLower ? 0         : DiagIndex+1
+  };
+  static void run(const Lhs& lhs, Rhs& rhs)
+  {
+    if (LoopIndex>0)
+      rhs.coeffRef(DiagIndex) -= lhs.row(DiagIndex).template segment<LoopIndex>(StartIndex).transpose()
+                                .cwiseProduct(rhs.template segment<LoopIndex>(StartIndex)).sum();
+
+    if(!(Mode & UnitDiag))
+      rhs.coeffRef(DiagIndex) /= lhs.coeff(DiagIndex,DiagIndex);
+
+    triangular_solver_unroller<Lhs,Rhs,Mode,LoopIndex+1,Size>::run(lhs,rhs);
+  }
+};
+
+template<typename Lhs, typename Rhs, int Mode, int LoopIndex, int Size>
+struct triangular_solver_unroller<Lhs,Rhs,Mode,LoopIndex,Size,true> {
+  static void run(const Lhs&, Rhs&) {}
+};
+
+template<typename Lhs, typename Rhs, int Mode>
+struct triangular_solver_selector<Lhs,Rhs,OnTheLeft,Mode,CompleteUnrolling,1> {
+  static void run(const Lhs& lhs, Rhs& rhs)
+  { triangular_solver_unroller<Lhs,Rhs,Mode,0,Rhs::SizeAtCompileTime>::run(lhs,rhs); }
+};
+
+template<typename Lhs, typename Rhs, int Mode>
+struct triangular_solver_selector<Lhs,Rhs,OnTheRight,Mode,CompleteUnrolling,1> {
+  static void run(const Lhs& lhs, Rhs& rhs)
+  {
+    Transpose<const Lhs> trLhs(lhs);
+    Transpose<Rhs> trRhs(rhs);
+    
+    triangular_solver_unroller<Transpose<const Lhs>,Transpose<Rhs>,
+                              ((Mode&Upper)==Upper ? Lower : Upper) | (Mode&UnitDiag),
+                              0,Rhs::SizeAtCompileTime>::run(trLhs,trRhs);
+  }
+};
+
+} // end namespace internal
+
+/***************************************************************************
+* TriangularView methods
+***************************************************************************/
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename MatrixType, unsigned int Mode>
+template<int Side, typename OtherDerived>
+EIGEN_DEVICE_FUNC void TriangularViewImpl<MatrixType,Mode,Dense>::solveInPlace(const MatrixBase<OtherDerived>& _other) const
+{
+  OtherDerived& other = _other.const_cast_derived();
+  eigen_assert( derived().cols() == derived().rows() && ((Side==OnTheLeft && derived().cols() == other.rows()) || (Side==OnTheRight && derived().cols() == other.cols())) );
+  eigen_assert((!(Mode & ZeroDiag)) && bool(Mode & (Upper|Lower)));
+
+  enum { copy = (internal::traits<OtherDerived>::Flags & RowMajorBit)  && OtherDerived::IsVectorAtCompileTime && OtherDerived::SizeAtCompileTime!=1};
+  typedef typename internal::conditional<copy,
+    typename internal::plain_matrix_type_column_major<OtherDerived>::type, OtherDerived&>::type OtherCopy;
+  OtherCopy otherCopy(other);
+
+  internal::triangular_solver_selector<MatrixType, typename internal::remove_reference<OtherCopy>::type,
+    Side, Mode>::run(derived().nestedExpression(), otherCopy);
+
+  if (copy)
+    other = otherCopy;
+}
+
+template<typename Derived, unsigned int Mode>
+template<int Side, typename Other>
+const internal::triangular_solve_retval<Side,TriangularView<Derived,Mode>,Other>
+TriangularViewImpl<Derived,Mode,Dense>::solve(const MatrixBase<Other>& other) const
+{
+  return internal::triangular_solve_retval<Side,TriangularViewType,Other>(derived(), other.derived());
+}
+#endif
+
+namespace internal {
+
+
+template<int Side, typename TriangularType, typename Rhs>
+struct traits<triangular_solve_retval<Side, TriangularType, Rhs> >
+{
+  typedef typename internal::plain_matrix_type_column_major<Rhs>::type ReturnType;
+};
+
+template<int Side, typename TriangularType, typename Rhs> struct triangular_solve_retval
+ : public ReturnByValue<triangular_solve_retval<Side, TriangularType, Rhs> >
+{
+  typedef typename remove_all<typename Rhs::Nested>::type RhsNestedCleaned;
+  typedef ReturnByValue<triangular_solve_retval> Base;
+
+  triangular_solve_retval(const TriangularType& tri, const Rhs& rhs)
+    : m_triangularMatrix(tri), m_rhs(rhs)
+  {}
+
+  inline Index rows() const { return m_rhs.rows(); }
+  inline Index cols() const { return m_rhs.cols(); }
+
+  template<typename Dest> inline void evalTo(Dest& dst) const
+  {
+    if(!is_same_dense(dst,m_rhs))
+      dst = m_rhs;
+    m_triangularMatrix.template solveInPlace<Side>(dst);
+  }
+
+  protected:
+    const TriangularType& m_triangularMatrix;
+    typename Rhs::Nested m_rhs;
+};
+
+} // namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SOLVETRIANGULAR_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/SolverBase.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/SolverBase.h
new file mode 100644
index 00000000..8a4adc22
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/SolverBase.h
@@ -0,0 +1,130 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SOLVERBASE_H
+#define EIGEN_SOLVERBASE_H
+
+namespace Eigen {
+
+namespace internal {
+
+
+
+} // end namespace internal
+
+/** \class SolverBase
+  * \brief A base class for matrix decomposition and solvers
+  *
+  * \tparam Derived the actual type of the decomposition/solver.
+  *
+  * Any matrix decomposition inheriting this base class provide the following API:
+  *
+  * \code
+  * MatrixType A, b, x;
+  * DecompositionType dec(A);
+  * x = dec.solve(b);             // solve A   * x = b
+  * x = dec.transpose().solve(b); // solve A^T * x = b
+  * x = dec.adjoint().solve(b);   // solve A'  * x = b
+  * \endcode
+  *
+  * \warning Currently, any other usage of transpose() and adjoint() are not supported and will produce compilation errors.
+  *
+  * \sa class PartialPivLU, class FullPivLU
+  */
+template<typename Derived>
+class SolverBase : public EigenBase<Derived>
+{
+  public:
+
+    typedef EigenBase<Derived> Base;
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    typedef Scalar CoeffReturnType;
+
+    enum {
+      RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
+      ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
+      SizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::RowsAtCompileTime,
+                                                          internal::traits<Derived>::ColsAtCompileTime>::ret),
+      MaxRowsAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = internal::traits<Derived>::MaxColsAtCompileTime,
+      MaxSizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::MaxRowsAtCompileTime,
+                                                             internal::traits<Derived>::MaxColsAtCompileTime>::ret),
+      IsVectorAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime == 1
+                           || internal::traits<Derived>::MaxColsAtCompileTime == 1
+    };
+
+    /** Default constructor */
+    SolverBase()
+    {}
+
+    ~SolverBase()
+    {}
+
+    using Base::derived;
+
+    /** \returns an expression of the solution x of \f$ A x = b \f$ using the current decomposition of A.
+      */
+    template<typename Rhs>
+    inline const Solve<Derived, Rhs>
+    solve(const MatrixBase<Rhs>& b) const
+    {
+      eigen_assert(derived().rows()==b.rows() && "solve(): invalid number of rows of the right hand side matrix b");
+      return Solve<Derived, Rhs>(derived(), b.derived());
+    }
+
+    /** \internal the return type of transpose() */
+    typedef typename internal::add_const<Transpose<const Derived> >::type ConstTransposeReturnType;
+    /** \returns an expression of the transposed of the factored matrix.
+      *
+      * A typical usage is to solve for the transposed problem A^T x = b:
+      * \code x = dec.transpose().solve(b); \endcode
+      *
+      * \sa adjoint(), solve()
+      */
+    inline ConstTransposeReturnType transpose() const
+    {
+      return ConstTransposeReturnType(derived());
+    }
+
+    /** \internal the return type of adjoint() */
+    typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
+                        CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, ConstTransposeReturnType>,
+                        ConstTransposeReturnType
+                     >::type AdjointReturnType;
+    /** \returns an expression of the adjoint of the factored matrix
+      *
+      * A typical usage is to solve for the adjoint problem A' x = b:
+      * \code x = dec.adjoint().solve(b); \endcode
+      *
+      * For real scalar types, this function is equivalent to transpose().
+      *
+      * \sa transpose(), solve()
+      */
+    inline AdjointReturnType adjoint() const
+    {
+      return AdjointReturnType(derived().transpose());
+    }
+
+  protected:
+};
+
+namespace internal {
+
+template<typename Derived>
+struct generic_xpr_base<Derived, MatrixXpr, SolverStorage>
+{
+  typedef SolverBase<Derived> type;
+
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SOLVERBASE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/StableNorm.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/StableNorm.h
new file mode 100644
index 00000000..be04ed44
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/StableNorm.h
@@ -0,0 +1,221 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STABLENORM_H
+#define EIGEN_STABLENORM_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename ExpressionType, typename Scalar>
+inline void stable_norm_kernel(const ExpressionType& bl, Scalar& ssq, Scalar& scale, Scalar& invScale)
+{
+  Scalar maxCoeff = bl.cwiseAbs().maxCoeff();
+  
+  if(maxCoeff>scale)
+  {
+    ssq = ssq * numext::abs2(scale/maxCoeff);
+    Scalar tmp = Scalar(1)/maxCoeff;
+    if(tmp > NumTraits<Scalar>::highest())
+    {
+      invScale = NumTraits<Scalar>::highest();
+      scale = Scalar(1)/invScale;
+    }
+    else if(maxCoeff>NumTraits<Scalar>::highest()) // we got a INF
+    {
+      invScale = Scalar(1);
+      scale = maxCoeff;
+    }
+    else
+    {
+      scale = maxCoeff;
+      invScale = tmp;
+    }
+  }
+  else if(maxCoeff!=maxCoeff) // we got a NaN
+  {
+    scale = maxCoeff;
+  }
+  
+  // TODO if the maxCoeff is much much smaller than the current scale,
+  // then we can neglect this sub vector
+  if(scale>Scalar(0)) // if scale==0, then bl is 0 
+    ssq += (bl*invScale).squaredNorm();
+}
+
+template<typename Derived>
+inline typename NumTraits<typename traits<Derived>::Scalar>::Real
+blueNorm_impl(const EigenBase<Derived>& _vec)
+{
+  typedef typename Derived::RealScalar RealScalar;  
+  using std::pow;
+  using std::sqrt;
+  using std::abs;
+  const Derived& vec(_vec.derived());
+  static bool initialized = false;
+  static RealScalar b1, b2, s1m, s2m, rbig, relerr;
+  if(!initialized)
+  {
+    int ibeta, it, iemin, iemax, iexp;
+    RealScalar eps;
+    // This program calculates the machine-dependent constants
+    // bl, b2, slm, s2m, relerr overfl
+    // from the "basic" machine-dependent numbers
+    // nbig, ibeta, it, iemin, iemax, rbig.
+    // The following define the basic machine-dependent constants.
+    // For portability, the PORT subprograms "ilmaeh" and "rlmach"
+    // are used. For any specific computer, each of the assignment
+    // statements can be replaced
+    ibeta = std::numeric_limits<RealScalar>::radix;                 // base for floating-point numbers
+    it    = std::numeric_limits<RealScalar>::digits;                // number of base-beta digits in mantissa
+    iemin = std::numeric_limits<RealScalar>::min_exponent;          // minimum exponent
+    iemax = std::numeric_limits<RealScalar>::max_exponent;          // maximum exponent
+    rbig  = (std::numeric_limits<RealScalar>::max)();               // largest floating-point number
+
+    iexp  = -((1-iemin)/2);
+    b1    = RealScalar(pow(RealScalar(ibeta),RealScalar(iexp)));    // lower boundary of midrange
+    iexp  = (iemax + 1 - it)/2;
+    b2    = RealScalar(pow(RealScalar(ibeta),RealScalar(iexp)));    // upper boundary of midrange
+
+    iexp  = (2-iemin)/2;
+    s1m   = RealScalar(pow(RealScalar(ibeta),RealScalar(iexp)));    // scaling factor for lower range
+    iexp  = - ((iemax+it)/2);
+    s2m   = RealScalar(pow(RealScalar(ibeta),RealScalar(iexp)));    // scaling factor for upper range
+
+    eps     = RealScalar(pow(double(ibeta), 1-it));
+    relerr  = sqrt(eps);                                            // tolerance for neglecting asml
+    initialized = true;
+  }
+  Index n = vec.size();
+  RealScalar ab2 = b2 / RealScalar(n);
+  RealScalar asml = RealScalar(0);
+  RealScalar amed = RealScalar(0);
+  RealScalar abig = RealScalar(0);
+  for(typename Derived::InnerIterator it(vec, 0); it; ++it)
+  {
+    RealScalar ax = abs(it.value());
+    if(ax > ab2)     abig += numext::abs2(ax*s2m);
+    else if(ax < b1) asml += numext::abs2(ax*s1m);
+    else             amed += numext::abs2(ax);
+  }
+  if(amed!=amed)
+    return amed;  // we got a NaN
+  if(abig > RealScalar(0))
+  {
+    abig = sqrt(abig);
+    if(abig > rbig) // overflow, or *this contains INF values
+      return abig;  // return INF
+    if(amed > RealScalar(0))
+    {
+      abig = abig/s2m;
+      amed = sqrt(amed);
+    }
+    else
+      return abig/s2m;
+  }
+  else if(asml > RealScalar(0))
+  {
+    if (amed > RealScalar(0))
+    {
+      abig = sqrt(amed);
+      amed = sqrt(asml) / s1m;
+    }
+    else
+      return sqrt(asml)/s1m;
+  }
+  else
+    return sqrt(amed);
+  asml = numext::mini(abig, amed);
+  abig = numext::maxi(abig, amed);
+  if(asml <= abig*relerr)
+    return abig;
+  else
+    return abig * sqrt(RealScalar(1) + numext::abs2(asml/abig));
+}
+
+} // end namespace internal
+
+/** \returns the \em l2 norm of \c *this avoiding underflow and overflow.
+  * This version use a blockwise two passes algorithm:
+  *  1 - find the absolute largest coefficient \c s
+  *  2 - compute \f$ s \Vert \frac{*this}{s} \Vert \f$ in a standard way
+  *
+  * For architecture/scalar types supporting vectorization, this version
+  * is faster than blueNorm(). Otherwise the blueNorm() is much faster.
+  *
+  * \sa norm(), blueNorm(), hypotNorm()
+  */
+template<typename Derived>
+inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
+MatrixBase<Derived>::stableNorm() const
+{
+  using std::sqrt;
+  using std::abs;
+  const Index blockSize = 4096;
+  RealScalar scale(0);
+  RealScalar invScale(1);
+  RealScalar ssq(0); // sum of square
+  
+  typedef typename internal::nested_eval<Derived,2>::type DerivedCopy;
+  typedef typename internal::remove_all<DerivedCopy>::type DerivedCopyClean;
+  DerivedCopy copy(derived());
+  
+  enum {
+    CanAlign = (   (int(DerivedCopyClean::Flags)&DirectAccessBit)
+                || (int(internal::evaluator<DerivedCopyClean>::Alignment)>0) // FIXME Alignment)>0 might not be enough
+               ) && (blockSize*sizeof(Scalar)*2<EIGEN_STACK_ALLOCATION_LIMIT)
+                 && (EIGEN_MAX_STATIC_ALIGN_BYTES>0) // if we cannot allocate on the stack, then let's not bother about this optimization
+  };
+  typedef typename internal::conditional<CanAlign, Ref<const Matrix<Scalar,Dynamic,1,0,blockSize,1>, internal::evaluator<DerivedCopyClean>::Alignment>,
+                                                   typename DerivedCopyClean::ConstSegmentReturnType>::type SegmentWrapper;
+  Index n = size();
+  
+  if(n==1)
+    return abs(this->coeff(0));
+  
+  Index bi = internal::first_default_aligned(copy);
+  if (bi>0)
+    internal::stable_norm_kernel(copy.head(bi), ssq, scale, invScale);
+  for (; bi<n; bi+=blockSize)
+    internal::stable_norm_kernel(SegmentWrapper(copy.segment(bi,numext::mini(blockSize, n - bi))), ssq, scale, invScale);
+  return scale * sqrt(ssq);
+}
+
+/** \returns the \em l2 norm of \c *this using the Blue's algorithm.
+  * A Portable Fortran Program to Find the Euclidean Norm of a Vector,
+  * ACM TOMS, Vol 4, Issue 1, 1978.
+  *
+  * For architecture/scalar types without vectorization, this version
+  * is much faster than stableNorm(). Otherwise the stableNorm() is faster.
+  *
+  * \sa norm(), stableNorm(), hypotNorm()
+  */
+template<typename Derived>
+inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
+MatrixBase<Derived>::blueNorm() const
+{
+  return internal::blueNorm_impl(*this);
+}
+
+/** \returns the \em l2 norm of \c *this avoiding undeflow and overflow.
+  * This version use a concatenation of hypot() calls, and it is very slow.
+  *
+  * \sa norm(), stableNorm()
+  */
+template<typename Derived>
+inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
+MatrixBase<Derived>::hypotNorm() const
+{
+  return this->cwiseAbs().redux(internal::scalar_hypot_op<RealScalar>());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_STABLENORM_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Stride.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Stride.h
new file mode 100644
index 00000000..513742f3
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Stride.h
@@ -0,0 +1,111 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STRIDE_H
+#define EIGEN_STRIDE_H
+
+namespace Eigen { 
+
+/** \class Stride
+  * \ingroup Core_Module
+  *
+  * \brief Holds strides information for Map
+  *
+  * This class holds the strides information for mapping arrays with strides with class Map.
+  *
+  * It holds two values: the inner stride and the outer stride.
+  *
+  * The inner stride is the pointer increment between two consecutive entries within a given row of a
+  * row-major matrix or within a given column of a column-major matrix.
+  *
+  * The outer stride is the pointer increment between two consecutive rows of a row-major matrix or
+  * between two consecutive columns of a column-major matrix.
+  *
+  * These two values can be passed either at compile-time as template parameters, or at runtime as
+  * arguments to the constructor.
+  *
+  * Indeed, this class takes two template parameters:
+  *  \tparam _OuterStrideAtCompileTime the outer stride, or Dynamic if you want to specify it at runtime.
+  *  \tparam _InnerStrideAtCompileTime the inner stride, or Dynamic if you want to specify it at runtime.
+  *
+  * Here is an example:
+  * \include Map_general_stride.cpp
+  * Output: \verbinclude Map_general_stride.out
+  *
+  * \sa class InnerStride, class OuterStride, \ref TopicStorageOrders
+  */
+template<int _OuterStrideAtCompileTime, int _InnerStrideAtCompileTime>
+class Stride
+{
+  public:
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+    enum {
+      InnerStrideAtCompileTime = _InnerStrideAtCompileTime,
+      OuterStrideAtCompileTime = _OuterStrideAtCompileTime
+    };
+
+    /** Default constructor, for use when strides are fixed at compile time */
+    EIGEN_DEVICE_FUNC
+    Stride()
+      : m_outer(OuterStrideAtCompileTime), m_inner(InnerStrideAtCompileTime)
+    {
+      eigen_assert(InnerStrideAtCompileTime != Dynamic && OuterStrideAtCompileTime != Dynamic);
+    }
+
+    /** Constructor allowing to pass the strides at runtime */
+    EIGEN_DEVICE_FUNC
+    Stride(Index outerStride, Index innerStride)
+      : m_outer(outerStride), m_inner(innerStride)
+    {
+      eigen_assert(innerStride>=0 && outerStride>=0);
+    }
+
+    /** Copy constructor */
+    EIGEN_DEVICE_FUNC
+    Stride(const Stride& other)
+      : m_outer(other.outer()), m_inner(other.inner())
+    {}
+
+    /** \returns the outer stride */
+    EIGEN_DEVICE_FUNC
+    inline Index outer() const { return m_outer.value(); }
+    /** \returns the inner stride */
+    EIGEN_DEVICE_FUNC
+    inline Index inner() const { return m_inner.value(); }
+
+  protected:
+    internal::variable_if_dynamic<Index, OuterStrideAtCompileTime> m_outer;
+    internal::variable_if_dynamic<Index, InnerStrideAtCompileTime> m_inner;
+};
+
+/** \brief Convenience specialization of Stride to specify only an inner stride
+  * See class Map for some examples */
+template<int Value>
+class InnerStride : public Stride<0, Value>
+{
+    typedef Stride<0, Value> Base;
+  public:
+    EIGEN_DEVICE_FUNC InnerStride() : Base() {}
+    EIGEN_DEVICE_FUNC InnerStride(Index v) : Base(0, v) {} // FIXME making this explicit could break valid code
+};
+
+/** \brief Convenience specialization of Stride to specify only an outer stride
+  * See class Map for some examples */
+template<int Value>
+class OuterStride : public Stride<Value, 0>
+{
+    typedef Stride<Value, 0> Base;
+  public:
+    EIGEN_DEVICE_FUNC OuterStride() : Base() {}
+    EIGEN_DEVICE_FUNC OuterStride(Index v) : Base(v,0) {} // FIXME making this explicit could break valid code
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_STRIDE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Swap.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Swap.h
new file mode 100644
index 00000000..d7020091
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Swap.h
@@ -0,0 +1,67 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SWAP_H
+#define EIGEN_SWAP_H
+
+namespace Eigen { 
+
+namespace internal {
+
+// Overload default assignPacket behavior for swapping them
+template<typename DstEvaluatorTypeT, typename SrcEvaluatorTypeT>
+class generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, swap_assign_op<typename DstEvaluatorTypeT::Scalar>, Specialized>
+ : public generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, swap_assign_op<typename DstEvaluatorTypeT::Scalar>, BuiltIn>
+{
+protected:
+  typedef generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, swap_assign_op<typename DstEvaluatorTypeT::Scalar>, BuiltIn> Base;
+  using Base::m_dst;
+  using Base::m_src;
+  using Base::m_functor;
+  
+public:
+  typedef typename Base::Scalar Scalar;
+  typedef typename Base::DstXprType DstXprType;
+  typedef swap_assign_op<Scalar> Functor;
+  
+  EIGEN_DEVICE_FUNC generic_dense_assignment_kernel(DstEvaluatorTypeT &dst, const SrcEvaluatorTypeT &src, const Functor &func, DstXprType& dstExpr)
+    : Base(dst, src, func, dstExpr)
+  {}
+  
+  template<int StoreMode, int LoadMode, typename PacketType>
+  void assignPacket(Index row, Index col)
+  {
+    PacketType tmp = m_src.template packet<LoadMode,PacketType>(row,col);
+    const_cast<SrcEvaluatorTypeT&>(m_src).template writePacket<LoadMode>(row,col, m_dst.template packet<StoreMode,PacketType>(row,col));
+    m_dst.template writePacket<StoreMode>(row,col,tmp);
+  }
+  
+  template<int StoreMode, int LoadMode, typename PacketType>
+  void assignPacket(Index index)
+  {
+    PacketType tmp = m_src.template packet<LoadMode,PacketType>(index);
+    const_cast<SrcEvaluatorTypeT&>(m_src).template writePacket<LoadMode>(index, m_dst.template packet<StoreMode,PacketType>(index));
+    m_dst.template writePacket<StoreMode>(index,tmp);
+  }
+  
+  // TODO find a simple way not to have to copy/paste this function from generic_dense_assignment_kernel, by simple I mean no CRTP (Gael)
+  template<int StoreMode, int LoadMode, typename PacketType>
+  void assignPacketByOuterInner(Index outer, Index inner)
+  {
+    Index row = Base::rowIndexByOuterInner(outer, inner); 
+    Index col = Base::colIndexByOuterInner(outer, inner);
+    assignPacket<StoreMode,LoadMode,PacketType>(row, col);
+  }
+};
+
+} // namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SWAP_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Transpose.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Transpose.h
new file mode 100644
index 00000000..ba7d6e62
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Transpose.h
@@ -0,0 +1,403 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2009-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TRANSPOSE_H
+#define EIGEN_TRANSPOSE_H
+
+namespace Eigen { 
+
+namespace internal {
+template<typename MatrixType>
+struct traits<Transpose<MatrixType> > : public traits<MatrixType>
+{
+  typedef typename ref_selector<MatrixType>::type MatrixTypeNested;
+  typedef typename remove_reference<MatrixTypeNested>::type MatrixTypeNestedPlain;
+  enum {
+    RowsAtCompileTime = MatrixType::ColsAtCompileTime,
+    ColsAtCompileTime = MatrixType::RowsAtCompileTime,
+    MaxRowsAtCompileTime = MatrixType::MaxColsAtCompileTime,
+    MaxColsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+    FlagsLvalueBit = is_lvalue<MatrixType>::value ? LvalueBit : 0,
+    Flags0 = traits<MatrixTypeNestedPlain>::Flags & ~(LvalueBit | NestByRefBit),
+    Flags1 = Flags0 | FlagsLvalueBit,
+    Flags = Flags1 ^ RowMajorBit,
+    InnerStrideAtCompileTime = inner_stride_at_compile_time<MatrixType>::ret,
+    OuterStrideAtCompileTime = outer_stride_at_compile_time<MatrixType>::ret
+  };
+};
+}
+
+template<typename MatrixType, typename StorageKind> class TransposeImpl;
+
+/** \class Transpose
+  * \ingroup Core_Module
+  *
+  * \brief Expression of the transpose of a matrix
+  *
+  * \tparam MatrixType the type of the object of which we are taking the transpose
+  *
+  * This class represents an expression of the transpose of a matrix.
+  * It is the return type of MatrixBase::transpose() and MatrixBase::adjoint()
+  * and most of the time this is the only way it is used.
+  *
+  * \sa MatrixBase::transpose(), MatrixBase::adjoint()
+  */
+template<typename MatrixType> class Transpose
+  : public TransposeImpl<MatrixType,typename internal::traits<MatrixType>::StorageKind>
+{
+  public:
+
+    typedef typename internal::ref_selector<MatrixType>::non_const_type MatrixTypeNested;
+
+    typedef typename TransposeImpl<MatrixType,typename internal::traits<MatrixType>::StorageKind>::Base Base;
+    EIGEN_GENERIC_PUBLIC_INTERFACE(Transpose)
+    typedef typename internal::remove_all<MatrixType>::type NestedExpression;
+
+    EIGEN_DEVICE_FUNC
+    explicit inline Transpose(MatrixType& matrix) : m_matrix(matrix) {}
+
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Transpose)
+
+    EIGEN_DEVICE_FUNC inline Index rows() const { return m_matrix.cols(); }
+    EIGEN_DEVICE_FUNC inline Index cols() const { return m_matrix.rows(); }
+
+    /** \returns the nested expression */
+    EIGEN_DEVICE_FUNC
+    const typename internal::remove_all<MatrixTypeNested>::type&
+    nestedExpression() const { return m_matrix; }
+
+    /** \returns the nested expression */
+    EIGEN_DEVICE_FUNC
+    typename internal::remove_reference<MatrixTypeNested>::type&
+    nestedExpression() { return m_matrix; }
+
+    /** \internal */
+    void resize(Index nrows, Index ncols) {
+      m_matrix.resize(ncols,nrows);
+    }
+
+  protected:
+    typename internal::ref_selector<MatrixType>::non_const_type m_matrix;
+};
+
+namespace internal {
+
+template<typename MatrixType, bool HasDirectAccess = has_direct_access<MatrixType>::ret>
+struct TransposeImpl_base
+{
+  typedef typename dense_xpr_base<Transpose<MatrixType> >::type type;
+};
+
+template<typename MatrixType>
+struct TransposeImpl_base<MatrixType, false>
+{
+  typedef typename dense_xpr_base<Transpose<MatrixType> >::type type;
+};
+
+} // end namespace internal
+
+// Generic API dispatcher
+template<typename XprType, typename StorageKind>
+class TransposeImpl
+  : public internal::generic_xpr_base<Transpose<XprType> >::type
+{
+public:
+  typedef typename internal::generic_xpr_base<Transpose<XprType> >::type Base;
+};
+
+template<typename MatrixType> class TransposeImpl<MatrixType,Dense>
+  : public internal::TransposeImpl_base<MatrixType>::type
+{
+  public:
+
+    typedef typename internal::TransposeImpl_base<MatrixType>::type Base;
+    using Base::coeffRef;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Transpose<MatrixType>)
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(TransposeImpl)
+
+    EIGEN_DEVICE_FUNC inline Index innerStride() const { return derived().nestedExpression().innerStride(); }
+    EIGEN_DEVICE_FUNC inline Index outerStride() const { return derived().nestedExpression().outerStride(); }
+
+    typedef typename internal::conditional<
+                       internal::is_lvalue<MatrixType>::value,
+                       Scalar,
+                       const Scalar
+                     >::type ScalarWithConstIfNotLvalue;
+
+    EIGEN_DEVICE_FUNC inline ScalarWithConstIfNotLvalue* data() { return derived().nestedExpression().data(); }
+    EIGEN_DEVICE_FUNC inline const Scalar* data() const { return derived().nestedExpression().data(); }
+
+    // FIXME: shall we keep the const version of coeffRef?
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index rowId, Index colId) const
+    {
+      return derived().nestedExpression().coeffRef(colId, rowId);
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index index) const
+    {
+      return derived().nestedExpression().coeffRef(index);
+    }
+};
+
+/** \returns an expression of the transpose of *this.
+  *
+  * Example: \include MatrixBase_transpose.cpp
+  * Output: \verbinclude MatrixBase_transpose.out
+  *
+  * \warning If you want to replace a matrix by its own transpose, do \b NOT do this:
+  * \code
+  * m = m.transpose(); // bug!!! caused by aliasing effect
+  * \endcode
+  * Instead, use the transposeInPlace() method:
+  * \code
+  * m.transposeInPlace();
+  * \endcode
+  * which gives Eigen good opportunities for optimization, or alternatively you can also do:
+  * \code
+  * m = m.transpose().eval();
+  * \endcode
+  *
+  * \sa transposeInPlace(), adjoint() */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline Transpose<Derived>
+DenseBase<Derived>::transpose()
+{
+  return TransposeReturnType(derived());
+}
+
+/** This is the const version of transpose().
+  *
+  * Make sure you read the warning for transpose() !
+  *
+  * \sa transposeInPlace(), adjoint() */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline typename DenseBase<Derived>::ConstTransposeReturnType
+DenseBase<Derived>::transpose() const
+{
+  return ConstTransposeReturnType(derived());
+}
+
+/** \returns an expression of the adjoint (i.e. conjugate transpose) of *this.
+  *
+  * Example: \include MatrixBase_adjoint.cpp
+  * Output: \verbinclude MatrixBase_adjoint.out
+  *
+  * \warning If you want to replace a matrix by its own adjoint, do \b NOT do this:
+  * \code
+  * m = m.adjoint(); // bug!!! caused by aliasing effect
+  * \endcode
+  * Instead, use the adjointInPlace() method:
+  * \code
+  * m.adjointInPlace();
+  * \endcode
+  * which gives Eigen good opportunities for optimization, or alternatively you can also do:
+  * \code
+  * m = m.adjoint().eval();
+  * \endcode
+  *
+  * \sa adjointInPlace(), transpose(), conjugate(), class Transpose, class internal::scalar_conjugate_op */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline const typename MatrixBase<Derived>::AdjointReturnType
+MatrixBase<Derived>::adjoint() const
+{
+  return AdjointReturnType(this->transpose());
+}
+
+/***************************************************************************
+* "in place" transpose implementation
+***************************************************************************/
+
+namespace internal {
+
+template<typename MatrixType,
+  bool IsSquare = (MatrixType::RowsAtCompileTime == MatrixType::ColsAtCompileTime) && MatrixType::RowsAtCompileTime!=Dynamic,
+  bool MatchPacketSize =
+        (int(MatrixType::RowsAtCompileTime) == int(internal::packet_traits<typename MatrixType::Scalar>::size))
+    &&  (internal::evaluator<MatrixType>::Flags&PacketAccessBit) >
+struct inplace_transpose_selector;
+
+template<typename MatrixType>
+struct inplace_transpose_selector<MatrixType,true,false> { // square matrix
+  static void run(MatrixType& m) {
+    m.matrix().template triangularView<StrictlyUpper>().swap(m.matrix().transpose());
+  }
+};
+
+// TODO: vectorized path is currently limited to LargestPacketSize x LargestPacketSize cases only.
+template<typename MatrixType>
+struct inplace_transpose_selector<MatrixType,true,true> { // PacketSize x PacketSize
+  static void run(MatrixType& m) {
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename internal::packet_traits<typename MatrixType::Scalar>::type Packet;
+    const Index PacketSize = internal::packet_traits<Scalar>::size;
+    const Index Alignment = internal::evaluator<MatrixType>::Alignment;
+    PacketBlock<Packet> A;
+    for (Index i=0; i<PacketSize; ++i)
+      A.packet[i] = m.template packetByOuterInner<Alignment>(i,0);
+    internal::ptranspose(A);
+    for (Index i=0; i<PacketSize; ++i)
+      m.template writePacket<Alignment>(m.rowIndexByOuterInner(i,0), m.colIndexByOuterInner(i,0), A.packet[i]);
+  }
+};
+
+template<typename MatrixType,bool MatchPacketSize>
+struct inplace_transpose_selector<MatrixType,false,MatchPacketSize> { // non square matrix
+  static void run(MatrixType& m) {
+    if (m.rows()==m.cols())
+      m.matrix().template triangularView<StrictlyUpper>().swap(m.matrix().transpose());
+    else
+      m = m.transpose().eval();
+  }
+};
+
+} // end namespace internal
+
+/** This is the "in place" version of transpose(): it replaces \c *this by its own transpose.
+  * Thus, doing
+  * \code
+  * m.transposeInPlace();
+  * \endcode
+  * has the same effect on m as doing
+  * \code
+  * m = m.transpose().eval();
+  * \endcode
+  * and is faster and also safer because in the latter line of code, forgetting the eval() results
+  * in a bug caused by \ref TopicAliasing "aliasing".
+  *
+  * Notice however that this method is only useful if you want to replace a matrix by its own transpose.
+  * If you just need the transpose of a matrix, use transpose().
+  *
+  * \note if the matrix is not square, then \c *this must be a resizable matrix. 
+  * This excludes (non-square) fixed-size matrices, block-expressions and maps.
+  *
+  * \sa transpose(), adjoint(), adjointInPlace() */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline void DenseBase<Derived>::transposeInPlace()
+{
+  eigen_assert((rows() == cols() || (RowsAtCompileTime == Dynamic && ColsAtCompileTime == Dynamic))
+               && "transposeInPlace() called on a non-square non-resizable matrix");
+  internal::inplace_transpose_selector<Derived>::run(derived());
+}
+
+/***************************************************************************
+* "in place" adjoint implementation
+***************************************************************************/
+
+/** This is the "in place" version of adjoint(): it replaces \c *this by its own transpose.
+  * Thus, doing
+  * \code
+  * m.adjointInPlace();
+  * \endcode
+  * has the same effect on m as doing
+  * \code
+  * m = m.adjoint().eval();
+  * \endcode
+  * and is faster and also safer because in the latter line of code, forgetting the eval() results
+  * in a bug caused by aliasing.
+  *
+  * Notice however that this method is only useful if you want to replace a matrix by its own adjoint.
+  * If you just need the adjoint of a matrix, use adjoint().
+  *
+  * \note if the matrix is not square, then \c *this must be a resizable matrix.
+  * This excludes (non-square) fixed-size matrices, block-expressions and maps.
+  *
+  * \sa transpose(), adjoint(), transposeInPlace() */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline void MatrixBase<Derived>::adjointInPlace()
+{
+  derived() = adjoint().eval();
+}
+
+#ifndef EIGEN_NO_DEBUG
+
+// The following is to detect aliasing problems in most common cases.
+
+namespace internal {
+
+template<bool DestIsTransposed, typename OtherDerived>
+struct check_transpose_aliasing_compile_time_selector
+{
+  enum { ret = bool(blas_traits<OtherDerived>::IsTransposed) != DestIsTransposed };
+};
+
+template<bool DestIsTransposed, typename BinOp, typename DerivedA, typename DerivedB>
+struct check_transpose_aliasing_compile_time_selector<DestIsTransposed,CwiseBinaryOp<BinOp,DerivedA,DerivedB> >
+{
+  enum { ret =    bool(blas_traits<DerivedA>::IsTransposed) != DestIsTransposed
+               || bool(blas_traits<DerivedB>::IsTransposed) != DestIsTransposed
+  };
+};
+
+template<typename Scalar, bool DestIsTransposed, typename OtherDerived>
+struct check_transpose_aliasing_run_time_selector
+{
+  static bool run(const Scalar* dest, const OtherDerived& src)
+  {
+    return (bool(blas_traits<OtherDerived>::IsTransposed) != DestIsTransposed) && (dest!=0 && dest==(const Scalar*)extract_data(src));
+  }
+};
+
+template<typename Scalar, bool DestIsTransposed, typename BinOp, typename DerivedA, typename DerivedB>
+struct check_transpose_aliasing_run_time_selector<Scalar,DestIsTransposed,CwiseBinaryOp<BinOp,DerivedA,DerivedB> >
+{
+  static bool run(const Scalar* dest, const CwiseBinaryOp<BinOp,DerivedA,DerivedB>& src)
+  {
+    return ((blas_traits<DerivedA>::IsTransposed != DestIsTransposed) && (dest!=0 && dest==(const Scalar*)extract_data(src.lhs())))
+        || ((blas_traits<DerivedB>::IsTransposed != DestIsTransposed) && (dest!=0 && dest==(const Scalar*)extract_data(src.rhs())));
+  }
+};
+
+// the following selector, checkTransposeAliasing_impl, based on MightHaveTransposeAliasing,
+// is because when the condition controlling the assert is known at compile time, ICC emits a warning.
+// This is actually a good warning: in expressions that don't have any transposing, the condition is
+// known at compile time to be false, and using that, we can avoid generating the code of the assert again
+// and again for all these expressions that don't need it.
+
+template<typename Derived, typename OtherDerived,
+         bool MightHaveTransposeAliasing
+                 = check_transpose_aliasing_compile_time_selector
+                     <blas_traits<Derived>::IsTransposed,OtherDerived>::ret
+        >
+struct checkTransposeAliasing_impl
+{
+    static void run(const Derived& dst, const OtherDerived& other)
+    {
+        eigen_assert((!check_transpose_aliasing_run_time_selector
+                      <typename Derived::Scalar,blas_traits<Derived>::IsTransposed,OtherDerived>
+                      ::run(extract_data(dst), other))
+          && "aliasing detected during transposition, use transposeInPlace() "
+             "or evaluate the rhs into a temporary using .eval()");
+
+    }
+};
+
+template<typename Derived, typename OtherDerived>
+struct checkTransposeAliasing_impl<Derived, OtherDerived, false>
+{
+    static void run(const Derived&, const OtherDerived&)
+    {
+    }
+};
+
+template<typename Dst, typename Src>
+void check_for_aliasing(const Dst &dst, const Src &src)
+{
+  internal::checkTransposeAliasing_impl<Dst, Src>::run(dst, src);
+}
+
+} // end namespace internal
+
+#endif // EIGEN_NO_DEBUG
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRANSPOSE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Transpositions.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Transpositions.h
new file mode 100644
index 00000000..19c17bb4
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Transpositions.h
@@ -0,0 +1,407 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010-2011 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TRANSPOSITIONS_H
+#define EIGEN_TRANSPOSITIONS_H
+
+namespace Eigen { 
+
+template<typename Derived>
+class TranspositionsBase
+{
+    typedef internal::traits<Derived> Traits;
+    
+  public:
+
+    typedef typename Traits::IndicesType IndicesType;
+    typedef typename IndicesType::Scalar StorageIndex;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+
+    Derived& derived() { return *static_cast<Derived*>(this); }
+    const Derived& derived() const { return *static_cast<const Derived*>(this); }
+
+    /** Copies the \a other transpositions into \c *this */
+    template<typename OtherDerived>
+    Derived& operator=(const TranspositionsBase<OtherDerived>& other)
+    {
+      indices() = other.indices();
+      return derived();
+    }
+    
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** This is a special case of the templated operator=. Its purpose is to
+      * prevent a default operator= from hiding the templated operator=.
+      */
+    Derived& operator=(const TranspositionsBase& other)
+    {
+      indices() = other.indices();
+      return derived();
+    }
+    #endif
+
+    /** \returns the number of transpositions */
+    Index size() const { return indices().size(); }
+    /** \returns the number of rows of the equivalent permutation matrix */
+    Index rows() const { return indices().size(); }
+    /** \returns the number of columns of the equivalent permutation matrix */
+    Index cols() const { return indices().size(); }
+
+    /** Direct access to the underlying index vector */
+    inline const StorageIndex& coeff(Index i) const { return indices().coeff(i); }
+    /** Direct access to the underlying index vector */
+    inline StorageIndex& coeffRef(Index i) { return indices().coeffRef(i); }
+    /** Direct access to the underlying index vector */
+    inline const StorageIndex& operator()(Index i) const { return indices()(i); }
+    /** Direct access to the underlying index vector */
+    inline StorageIndex& operator()(Index i) { return indices()(i); }
+    /** Direct access to the underlying index vector */
+    inline const StorageIndex& operator[](Index i) const { return indices()(i); }
+    /** Direct access to the underlying index vector */
+    inline StorageIndex& operator[](Index i) { return indices()(i); }
+
+    /** const version of indices(). */
+    const IndicesType& indices() const { return derived().indices(); }
+    /** \returns a reference to the stored array representing the transpositions. */
+    IndicesType& indices() { return derived().indices(); }
+
+    /** Resizes to given size. */
+    inline void resize(Index newSize)
+    {
+      indices().resize(newSize);
+    }
+
+    /** Sets \c *this to represents an identity transformation */
+    void setIdentity()
+    {
+      for(StorageIndex i = 0; i < indices().size(); ++i)
+        coeffRef(i) = i;
+    }
+
+    // FIXME: do we want such methods ?
+    // might be usefull when the target matrix expression is complex, e.g.:
+    // object.matrix().block(..,..,..,..) = trans * object.matrix().block(..,..,..,..);
+    /*
+    template<typename MatrixType>
+    void applyForwardToRows(MatrixType& mat) const
+    {
+      for(Index k=0 ; k<size() ; ++k)
+        if(m_indices(k)!=k)
+          mat.row(k).swap(mat.row(m_indices(k)));
+    }
+
+    template<typename MatrixType>
+    void applyBackwardToRows(MatrixType& mat) const
+    {
+      for(Index k=size()-1 ; k>=0 ; --k)
+        if(m_indices(k)!=k)
+          mat.row(k).swap(mat.row(m_indices(k)));
+    }
+    */
+
+    /** \returns the inverse transformation */
+    inline Transpose<TranspositionsBase> inverse() const
+    { return Transpose<TranspositionsBase>(derived()); }
+
+    /** \returns the tranpose transformation */
+    inline Transpose<TranspositionsBase> transpose() const
+    { return Transpose<TranspositionsBase>(derived()); }
+
+  protected:
+};
+
+namespace internal {
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime, typename _StorageIndex>
+struct traits<Transpositions<SizeAtCompileTime,MaxSizeAtCompileTime,_StorageIndex> >
+ : traits<PermutationMatrix<SizeAtCompileTime,MaxSizeAtCompileTime,_StorageIndex> >
+{
+  typedef Matrix<_StorageIndex, SizeAtCompileTime, 1, 0, MaxSizeAtCompileTime, 1> IndicesType;
+  typedef TranspositionsStorage StorageKind;
+};
+}
+
+/** \class Transpositions
+  * \ingroup Core_Module
+  *
+  * \brief Represents a sequence of transpositions (row/column interchange)
+  *
+  * \tparam SizeAtCompileTime the number of transpositions, or Dynamic
+  * \tparam MaxSizeAtCompileTime the maximum number of transpositions, or Dynamic. This optional parameter defaults to SizeAtCompileTime. Most of the time, you should not have to specify it.
+  *
+  * This class represents a permutation transformation as a sequence of \em n transpositions
+  * \f$[T_{n-1} \ldots T_{i} \ldots T_{0}]\f$. It is internally stored as a vector of integers \c indices.
+  * Each transposition \f$ T_{i} \f$ applied on the left of a matrix (\f$ T_{i} M\f$) interchanges
+  * the rows \c i and \c indices[i] of the matrix \c M.
+  * A transposition applied on the right (e.g., \f$ M T_{i}\f$) yields a column interchange.
+  *
+  * Compared to the class PermutationMatrix, such a sequence of transpositions is what is
+  * computed during a decomposition with pivoting, and it is faster when applying the permutation in-place.
+  *
+  * To apply a sequence of transpositions to a matrix, simply use the operator * as in the following example:
+  * \code
+  * Transpositions tr;
+  * MatrixXf mat;
+  * mat = tr * mat;
+  * \endcode
+  * In this example, we detect that the matrix appears on both side, and so the transpositions
+  * are applied in-place without any temporary or extra copy.
+  *
+  * \sa class PermutationMatrix
+  */
+
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime, typename _StorageIndex>
+class Transpositions : public TranspositionsBase<Transpositions<SizeAtCompileTime,MaxSizeAtCompileTime,_StorageIndex> >
+{
+    typedef internal::traits<Transpositions> Traits;
+  public:
+
+    typedef TranspositionsBase<Transpositions> Base;
+    typedef typename Traits::IndicesType IndicesType;
+    typedef typename IndicesType::Scalar StorageIndex;
+
+    inline Transpositions() {}
+
+    /** Copy constructor. */
+    template<typename OtherDerived>
+    inline Transpositions(const TranspositionsBase<OtherDerived>& other)
+      : m_indices(other.indices()) {}
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** Standard copy constructor. Defined only to prevent a default copy constructor
+      * from hiding the other templated constructor */
+    inline Transpositions(const Transpositions& other) : m_indices(other.indices()) {}
+    #endif
+
+    /** Generic constructor from expression of the transposition indices. */
+    template<typename Other>
+    explicit inline Transpositions(const MatrixBase<Other>& indices) : m_indices(indices)
+    {}
+
+    /** Copies the \a other transpositions into \c *this */
+    template<typename OtherDerived>
+    Transpositions& operator=(const TranspositionsBase<OtherDerived>& other)
+    {
+      return Base::operator=(other);
+    }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** This is a special case of the templated operator=. Its purpose is to
+      * prevent a default operator= from hiding the templated operator=.
+      */
+    Transpositions& operator=(const Transpositions& other)
+    {
+      m_indices = other.m_indices;
+      return *this;
+    }
+    #endif
+
+    /** Constructs an uninitialized permutation matrix of given size.
+      */
+    inline Transpositions(Index size) : m_indices(size)
+    {}
+
+    /** const version of indices(). */
+    const IndicesType& indices() const { return m_indices; }
+    /** \returns a reference to the stored array representing the transpositions. */
+    IndicesType& indices() { return m_indices; }
+
+  protected:
+
+    IndicesType m_indices;
+};
+
+
+namespace internal {
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime, typename _StorageIndex, int _PacketAccess>
+struct traits<Map<Transpositions<SizeAtCompileTime,MaxSizeAtCompileTime,_StorageIndex>,_PacketAccess> >
+ : traits<PermutationMatrix<SizeAtCompileTime,MaxSizeAtCompileTime,_StorageIndex> >
+{
+  typedef Map<const Matrix<_StorageIndex,SizeAtCompileTime,1,0,MaxSizeAtCompileTime,1>, _PacketAccess> IndicesType;
+  typedef _StorageIndex StorageIndex;
+  typedef TranspositionsStorage StorageKind;
+};
+}
+
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime, typename _StorageIndex, int PacketAccess>
+class Map<Transpositions<SizeAtCompileTime,MaxSizeAtCompileTime,_StorageIndex>,PacketAccess>
+ : public TranspositionsBase<Map<Transpositions<SizeAtCompileTime,MaxSizeAtCompileTime,_StorageIndex>,PacketAccess> >
+{
+    typedef internal::traits<Map> Traits;
+  public:
+
+    typedef TranspositionsBase<Map> Base;
+    typedef typename Traits::IndicesType IndicesType;
+    typedef typename IndicesType::Scalar StorageIndex;
+
+    explicit inline Map(const StorageIndex* indicesPtr)
+      : m_indices(indicesPtr)
+    {}
+
+    inline Map(const StorageIndex* indicesPtr, Index size)
+      : m_indices(indicesPtr,size)
+    {}
+
+    /** Copies the \a other transpositions into \c *this */
+    template<typename OtherDerived>
+    Map& operator=(const TranspositionsBase<OtherDerived>& other)
+    {
+      return Base::operator=(other);
+    }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** This is a special case of the templated operator=. Its purpose is to
+      * prevent a default operator= from hiding the templated operator=.
+      */
+    Map& operator=(const Map& other)
+    {
+      m_indices = other.m_indices;
+      return *this;
+    }
+    #endif
+
+    /** const version of indices(). */
+    const IndicesType& indices() const { return m_indices; }
+    
+    /** \returns a reference to the stored array representing the transpositions. */
+    IndicesType& indices() { return m_indices; }
+
+  protected:
+
+    IndicesType m_indices;
+};
+
+namespace internal {
+template<typename _IndicesType>
+struct traits<TranspositionsWrapper<_IndicesType> >
+ : traits<PermutationWrapper<_IndicesType> >
+{
+  typedef TranspositionsStorage StorageKind;
+};
+}
+
+template<typename _IndicesType>
+class TranspositionsWrapper
+ : public TranspositionsBase<TranspositionsWrapper<_IndicesType> >
+{
+    typedef internal::traits<TranspositionsWrapper> Traits;
+  public:
+
+    typedef TranspositionsBase<TranspositionsWrapper> Base;
+    typedef typename Traits::IndicesType IndicesType;
+    typedef typename IndicesType::Scalar StorageIndex;
+
+    explicit inline TranspositionsWrapper(IndicesType& indices)
+      : m_indices(indices)
+    {}
+
+    /** Copies the \a other transpositions into \c *this */
+    template<typename OtherDerived>
+    TranspositionsWrapper& operator=(const TranspositionsBase<OtherDerived>& other)
+    {
+      return Base::operator=(other);
+    }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** This is a special case of the templated operator=. Its purpose is to
+      * prevent a default operator= from hiding the templated operator=.
+      */
+    TranspositionsWrapper& operator=(const TranspositionsWrapper& other)
+    {
+      m_indices = other.m_indices;
+      return *this;
+    }
+    #endif
+
+    /** const version of indices(). */
+    const IndicesType& indices() const { return m_indices; }
+
+    /** \returns a reference to the stored array representing the transpositions. */
+    IndicesType& indices() { return m_indices; }
+
+  protected:
+
+    typename IndicesType::Nested m_indices;
+};
+
+
+
+/** \returns the \a matrix with the \a transpositions applied to the columns.
+  */
+template<typename MatrixDerived, typename TranspositionsDerived>
+EIGEN_DEVICE_FUNC
+const Product<MatrixDerived, TranspositionsDerived, AliasFreeProduct>
+operator*(const MatrixBase<MatrixDerived> &matrix,
+          const TranspositionsBase<TranspositionsDerived>& transpositions)
+{
+  return Product<MatrixDerived, TranspositionsDerived, AliasFreeProduct>
+            (matrix.derived(), transpositions.derived());
+}
+
+/** \returns the \a matrix with the \a transpositions applied to the rows.
+  */
+template<typename TranspositionsDerived, typename MatrixDerived>
+EIGEN_DEVICE_FUNC
+const Product<TranspositionsDerived, MatrixDerived, AliasFreeProduct>
+operator*(const TranspositionsBase<TranspositionsDerived> &transpositions,
+          const MatrixBase<MatrixDerived>& matrix)
+{
+  return Product<TranspositionsDerived, MatrixDerived, AliasFreeProduct>
+            (transpositions.derived(), matrix.derived());
+}
+
+// Template partial specialization for transposed/inverse transpositions
+
+namespace internal {
+
+template<typename Derived>
+struct traits<Transpose<TranspositionsBase<Derived> > >
+ : traits<Derived>
+{};
+
+} // end namespace internal
+
+template<typename TranspositionsDerived>
+class Transpose<TranspositionsBase<TranspositionsDerived> >
+{
+    typedef TranspositionsDerived TranspositionType;
+    typedef typename TranspositionType::IndicesType IndicesType;
+  public:
+
+    explicit Transpose(const TranspositionType& t) : m_transpositions(t) {}
+
+    Index size() const { return m_transpositions.size(); }
+    Index rows() const { return m_transpositions.size(); }
+    Index cols() const { return m_transpositions.size(); }
+
+    /** \returns the \a matrix with the inverse transpositions applied to the columns.
+      */
+    template<typename OtherDerived> friend
+    const Product<OtherDerived, Transpose, AliasFreeProduct>
+    operator*(const MatrixBase<OtherDerived>& matrix, const Transpose& trt)
+    {
+      return Product<OtherDerived, Transpose, AliasFreeProduct>(matrix.derived(), trt.derived());
+    }
+
+    /** \returns the \a matrix with the inverse transpositions applied to the rows.
+      */
+    template<typename OtherDerived>
+    const Product<Transpose, OtherDerived, AliasFreeProduct>
+    operator*(const MatrixBase<OtherDerived>& matrix) const
+    {
+      return Product<Transpose, OtherDerived, AliasFreeProduct>(*this, matrix.derived());
+    }
+    
+    const TranspositionType& nestedExpression() const { return m_transpositions; }
+
+  protected:
+    const TranspositionType& m_transpositions;
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRANSPOSITIONS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/TriangularMatrix.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/TriangularMatrix.h
new file mode 100644
index 00000000..ed80da36
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/TriangularMatrix.h
@@ -0,0 +1,984 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TRIANGULARMATRIX_H
+#define EIGEN_TRIANGULARMATRIX_H
+
+namespace Eigen { 
+
+namespace internal {
+  
+template<int Side, typename TriangularType, typename Rhs> struct triangular_solve_retval;
+  
+}
+
+/** \class TriangularBase
+  * \ingroup Core_Module
+  *
+  * \brief Base class for triangular part in a matrix
+  */
+template<typename Derived> class TriangularBase : public EigenBase<Derived>
+{
+  public:
+
+    enum {
+      Mode = internal::traits<Derived>::Mode,
+      RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
+      ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
+      MaxRowsAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = internal::traits<Derived>::MaxColsAtCompileTime,
+      
+      SizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::RowsAtCompileTime,
+                                                   internal::traits<Derived>::ColsAtCompileTime>::ret),
+      /**< This is equal to the number of coefficients, i.e. the number of
+          * rows times the number of columns, or to \a Dynamic if this is not
+          * known at compile-time. \sa RowsAtCompileTime, ColsAtCompileTime */
+      
+      MaxSizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::MaxRowsAtCompileTime,
+                                                   internal::traits<Derived>::MaxColsAtCompileTime>::ret)
+        
+    };
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    typedef typename internal::traits<Derived>::StorageKind StorageKind;
+    typedef typename internal::traits<Derived>::StorageIndex StorageIndex;
+    typedef typename internal::traits<Derived>::FullMatrixType DenseMatrixType;
+    typedef DenseMatrixType DenseType;
+    typedef Derived const& Nested;
+
+    EIGEN_DEVICE_FUNC
+    inline TriangularBase() { eigen_assert(!((Mode&UnitDiag) && (Mode&ZeroDiag))); }
+
+    EIGEN_DEVICE_FUNC
+    inline Index rows() const { return derived().rows(); }
+    EIGEN_DEVICE_FUNC
+    inline Index cols() const { return derived().cols(); }
+    EIGEN_DEVICE_FUNC
+    inline Index outerStride() const { return derived().outerStride(); }
+    EIGEN_DEVICE_FUNC
+    inline Index innerStride() const { return derived().innerStride(); }
+    
+    // dummy resize function
+    void resize(Index rows, Index cols)
+    {
+      EIGEN_UNUSED_VARIABLE(rows);
+      EIGEN_UNUSED_VARIABLE(cols);
+      eigen_assert(rows==this->rows() && cols==this->cols());
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline Scalar coeff(Index row, Index col) const  { return derived().coeff(row,col); }
+    EIGEN_DEVICE_FUNC
+    inline Scalar& coeffRef(Index row, Index col) { return derived().coeffRef(row,col); }
+
+    /** \see MatrixBase::copyCoeff(row,col)
+      */
+    template<typename Other>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void copyCoeff(Index row, Index col, Other& other)
+    {
+      derived().coeffRef(row, col) = other.coeff(row, col);
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline Scalar operator()(Index row, Index col) const
+    {
+      check_coordinates(row, col);
+      return coeff(row,col);
+    }
+    EIGEN_DEVICE_FUNC
+    inline Scalar& operator()(Index row, Index col)
+    {
+      check_coordinates(row, col);
+      return coeffRef(row,col);
+    }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    EIGEN_DEVICE_FUNC
+    inline const Derived& derived() const { return *static_cast<const Derived*>(this); }
+    EIGEN_DEVICE_FUNC
+    inline Derived& derived() { return *static_cast<Derived*>(this); }
+    #endif // not EIGEN_PARSED_BY_DOXYGEN
+
+    template<typename DenseDerived>
+    EIGEN_DEVICE_FUNC
+    void evalTo(MatrixBase<DenseDerived> &other) const;
+    template<typename DenseDerived>
+    EIGEN_DEVICE_FUNC
+    void evalToLazy(MatrixBase<DenseDerived> &other) const;
+
+    EIGEN_DEVICE_FUNC
+    DenseMatrixType toDenseMatrix() const
+    {
+      DenseMatrixType res(rows(), cols());
+      evalToLazy(res);
+      return res;
+    }
+
+  protected:
+
+    void check_coordinates(Index row, Index col) const
+    {
+      EIGEN_ONLY_USED_FOR_DEBUG(row);
+      EIGEN_ONLY_USED_FOR_DEBUG(col);
+      eigen_assert(col>=0 && col<cols() && row>=0 && row<rows());
+      const int mode = int(Mode) & ~SelfAdjoint;
+      EIGEN_ONLY_USED_FOR_DEBUG(mode);
+      eigen_assert((mode==Upper && col>=row)
+                || (mode==Lower && col<=row)
+                || ((mode==StrictlyUpper || mode==UnitUpper) && col>row)
+                || ((mode==StrictlyLower || mode==UnitLower) && col<row));
+    }
+
+    #ifdef EIGEN_INTERNAL_DEBUGGING
+    void check_coordinates_internal(Index row, Index col) const
+    {
+      check_coordinates(row, col);
+    }
+    #else
+    void check_coordinates_internal(Index , Index ) const {}
+    #endif
+
+};
+
+/** \class TriangularView
+  * \ingroup Core_Module
+  *
+  * \brief Expression of a triangular part in a matrix
+  *
+  * \param MatrixType the type of the object in which we are taking the triangular part
+  * \param Mode the kind of triangular matrix expression to construct. Can be #Upper,
+  *             #Lower, #UnitUpper, #UnitLower, #StrictlyUpper, or #StrictlyLower.
+  *             This is in fact a bit field; it must have either #Upper or #Lower, 
+  *             and additionally it may have #UnitDiag or #ZeroDiag or neither.
+  *
+  * This class represents a triangular part of a matrix, not necessarily square. Strictly speaking, for rectangular
+  * matrices one should speak of "trapezoid" parts. This class is the return type
+  * of MatrixBase::triangularView() and SparseMatrixBase::triangularView(), and most of the time this is the only way it is used.
+  *
+  * \sa MatrixBase::triangularView()
+  */
+namespace internal {
+template<typename MatrixType, unsigned int _Mode>
+struct traits<TriangularView<MatrixType, _Mode> > : traits<MatrixType>
+{
+  typedef typename ref_selector<MatrixType>::non_const_type MatrixTypeNested;
+  typedef typename remove_reference<MatrixTypeNested>::type MatrixTypeNestedNonRef;
+  typedef typename remove_all<MatrixTypeNested>::type MatrixTypeNestedCleaned;
+  typedef typename MatrixType::PlainObject FullMatrixType;
+  typedef MatrixType ExpressionType;
+  enum {
+    Mode = _Mode,
+    FlagsLvalueBit = is_lvalue<MatrixType>::value ? LvalueBit : 0,
+    Flags = (MatrixTypeNestedCleaned::Flags & (HereditaryBits | FlagsLvalueBit) & (~(PacketAccessBit | DirectAccessBit | LinearAccessBit)))
+  };
+};
+}
+
+template<typename _MatrixType, unsigned int _Mode, typename StorageKind> class TriangularViewImpl;
+
+template<typename _MatrixType, unsigned int _Mode> class TriangularView
+  : public TriangularViewImpl<_MatrixType, _Mode, typename internal::traits<_MatrixType>::StorageKind >
+{
+  public:
+
+    typedef TriangularViewImpl<_MatrixType, _Mode, typename internal::traits<_MatrixType>::StorageKind > Base;
+    typedef typename internal::traits<TriangularView>::Scalar Scalar;
+    typedef _MatrixType MatrixType;
+
+  protected:
+    typedef typename internal::traits<TriangularView>::MatrixTypeNested MatrixTypeNested;
+    typedef typename internal::traits<TriangularView>::MatrixTypeNestedNonRef MatrixTypeNestedNonRef;
+
+    typedef typename internal::remove_all<typename MatrixType::ConjugateReturnType>::type MatrixConjugateReturnType;
+    
+  public:
+
+    typedef typename internal::traits<TriangularView>::StorageKind StorageKind;
+    typedef typename internal::traits<TriangularView>::MatrixTypeNestedCleaned NestedExpression;
+
+    enum {
+      Mode = _Mode,
+      Flags = internal::traits<TriangularView>::Flags,
+      TransposeMode = (Mode & Upper ? Lower : 0)
+                    | (Mode & Lower ? Upper : 0)
+                    | (Mode & (UnitDiag))
+                    | (Mode & (ZeroDiag)),
+      IsVectorAtCompileTime = false
+    };
+
+    EIGEN_DEVICE_FUNC
+    explicit inline TriangularView(MatrixType& matrix) : m_matrix(matrix)
+    {}
+    
+    using Base::operator=;
+    TriangularView& operator=(const TriangularView &other)
+    { return Base::operator=(other); }
+
+    /** \copydoc EigenBase::rows() */
+    EIGEN_DEVICE_FUNC
+    inline Index rows() const { return m_matrix.rows(); }
+    /** \copydoc EigenBase::cols() */
+    EIGEN_DEVICE_FUNC
+    inline Index cols() const { return m_matrix.cols(); }
+
+    /** \returns a const reference to the nested expression */
+    EIGEN_DEVICE_FUNC
+    const NestedExpression& nestedExpression() const { return m_matrix; }
+
+    /** \returns a reference to the nested expression */
+    EIGEN_DEVICE_FUNC
+    NestedExpression& nestedExpression() { return m_matrix; }
+    
+    typedef TriangularView<const MatrixConjugateReturnType,Mode> ConjugateReturnType;
+    /** \sa MatrixBase::conjugate() const */
+    EIGEN_DEVICE_FUNC
+    inline const ConjugateReturnType conjugate() const
+    { return ConjugateReturnType(m_matrix.conjugate()); }
+
+    typedef TriangularView<const typename MatrixType::AdjointReturnType,TransposeMode> AdjointReturnType;
+    /** \sa MatrixBase::adjoint() const */
+    EIGEN_DEVICE_FUNC
+    inline const AdjointReturnType adjoint() const
+    { return AdjointReturnType(m_matrix.adjoint()); }
+
+    typedef TriangularView<typename MatrixType::TransposeReturnType,TransposeMode> TransposeReturnType;
+     /** \sa MatrixBase::transpose() */
+    EIGEN_DEVICE_FUNC
+    inline TransposeReturnType transpose()
+    {
+      EIGEN_STATIC_ASSERT_LVALUE(MatrixType)
+      typename MatrixType::TransposeReturnType tmp(m_matrix);
+      return TransposeReturnType(tmp);
+    }
+    
+    typedef TriangularView<const typename MatrixType::ConstTransposeReturnType,TransposeMode> ConstTransposeReturnType;
+    /** \sa MatrixBase::transpose() const */
+    EIGEN_DEVICE_FUNC
+    inline const ConstTransposeReturnType transpose() const
+    {
+      return ConstTransposeReturnType(m_matrix.transpose());
+    }
+
+    template<typename Other>
+    EIGEN_DEVICE_FUNC
+    inline const Solve<TriangularView, Other> 
+    solve(const MatrixBase<Other>& other) const
+    { return Solve<TriangularView, Other>(*this, other.derived()); }
+    
+  // workaround MSVC ICE
+  #if EIGEN_COMP_MSVC
+    template<int Side, typename Other>
+    EIGEN_DEVICE_FUNC
+    inline const internal::triangular_solve_retval<Side,TriangularView, Other>
+    solve(const MatrixBase<Other>& other) const
+    { return Base::template solve<Side>(other); }
+  #else
+    using Base::solve;
+  #endif
+
+    /** \returns a selfadjoint view of the referenced triangular part which must be either \c #Upper or \c #Lower.
+      *
+      * This is a shortcut for \code this->nestedExpression().selfadjointView<(*this)::Mode>() \endcode
+      * \sa MatrixBase::selfadjointView() */
+    EIGEN_DEVICE_FUNC
+    SelfAdjointView<MatrixTypeNestedNonRef,Mode> selfadjointView()
+    {
+      EIGEN_STATIC_ASSERT((Mode&(UnitDiag|ZeroDiag))==0,PROGRAMMING_ERROR);
+      return SelfAdjointView<MatrixTypeNestedNonRef,Mode>(m_matrix);
+    }
+
+    /** This is the const version of selfadjointView() */
+    EIGEN_DEVICE_FUNC
+    const SelfAdjointView<MatrixTypeNestedNonRef,Mode> selfadjointView() const
+    {
+      EIGEN_STATIC_ASSERT((Mode&(UnitDiag|ZeroDiag))==0,PROGRAMMING_ERROR);
+      return SelfAdjointView<MatrixTypeNestedNonRef,Mode>(m_matrix);
+    }
+
+
+    /** \returns the determinant of the triangular matrix
+      * \sa MatrixBase::determinant() */
+    EIGEN_DEVICE_FUNC
+    Scalar determinant() const
+    {
+      if (Mode & UnitDiag)
+        return 1;
+      else if (Mode & ZeroDiag)
+        return 0;
+      else
+        return m_matrix.diagonal().prod();
+    }
+      
+  protected:
+
+    MatrixTypeNested m_matrix;
+};
+
+/** \ingroup Core_Module
+  *
+  * \brief Base class for a triangular part in a \b dense matrix
+  *
+  * This class is an abstract base class of class TriangularView, and objects of type TriangularViewImpl cannot be instantiated.
+  * It extends class TriangularView with additional methods which available for dense expressions only.
+  *
+  * \sa class TriangularView, MatrixBase::triangularView()
+  */
+template<typename _MatrixType, unsigned int _Mode> class TriangularViewImpl<_MatrixType,_Mode,Dense>
+  : public TriangularBase<TriangularView<_MatrixType, _Mode> >
+{
+  public:
+
+    typedef TriangularView<_MatrixType, _Mode> TriangularViewType;
+    typedef TriangularBase<TriangularViewType> Base;
+    typedef typename internal::traits<TriangularViewType>::Scalar Scalar;
+
+    typedef _MatrixType MatrixType;
+    typedef typename MatrixType::PlainObject DenseMatrixType;
+    typedef DenseMatrixType PlainObject;
+
+  public:
+    using Base::evalToLazy;
+    using Base::derived;
+
+    typedef typename internal::traits<TriangularViewType>::StorageKind StorageKind;
+
+    enum {
+      Mode = _Mode,
+      Flags = internal::traits<TriangularViewType>::Flags
+    };
+
+    /** \returns the outer-stride of the underlying dense matrix
+      * \sa DenseCoeffsBase::outerStride() */
+    EIGEN_DEVICE_FUNC
+    inline Index outerStride() const { return derived().nestedExpression().outerStride(); }
+    /** \returns the inner-stride of the underlying dense matrix
+      * \sa DenseCoeffsBase::innerStride() */
+    EIGEN_DEVICE_FUNC
+    inline Index innerStride() const { return derived().nestedExpression().innerStride(); }
+
+    /** \sa MatrixBase::operator+=() */
+    template<typename Other>
+    EIGEN_DEVICE_FUNC
+    TriangularViewType&  operator+=(const DenseBase<Other>& other) {
+      internal::call_assignment_no_alias(derived(), other.derived(), internal::add_assign_op<Scalar,typename Other::Scalar>());
+      return derived();
+    }
+    /** \sa MatrixBase::operator-=() */
+    template<typename Other>
+    EIGEN_DEVICE_FUNC
+    TriangularViewType&  operator-=(const DenseBase<Other>& other) {
+      internal::call_assignment_no_alias(derived(), other.derived(), internal::sub_assign_op<Scalar,typename Other::Scalar>());
+      return derived();
+    }
+    
+    /** \sa MatrixBase::operator*=() */
+    EIGEN_DEVICE_FUNC
+    TriangularViewType&  operator*=(const typename internal::traits<MatrixType>::Scalar& other) { return *this = derived().nestedExpression() * other; }
+    /** \sa DenseBase::operator/=() */
+    EIGEN_DEVICE_FUNC
+    TriangularViewType&  operator/=(const typename internal::traits<MatrixType>::Scalar& other) { return *this = derived().nestedExpression() / other; }
+
+    /** \sa MatrixBase::fill() */
+    EIGEN_DEVICE_FUNC
+    void fill(const Scalar& value) { setConstant(value); }
+    /** \sa MatrixBase::setConstant() */
+    EIGEN_DEVICE_FUNC
+    TriangularViewType& setConstant(const Scalar& value)
+    { return *this = MatrixType::Constant(derived().rows(), derived().cols(), value); }
+    /** \sa MatrixBase::setZero() */
+    EIGEN_DEVICE_FUNC
+    TriangularViewType& setZero() { return setConstant(Scalar(0)); }
+    /** \sa MatrixBase::setOnes() */
+    EIGEN_DEVICE_FUNC
+    TriangularViewType& setOnes() { return setConstant(Scalar(1)); }
+
+    /** \sa MatrixBase::coeff()
+      * \warning the coordinates must fit into the referenced triangular part
+      */
+    EIGEN_DEVICE_FUNC
+    inline Scalar coeff(Index row, Index col) const
+    {
+      Base::check_coordinates_internal(row, col);
+      return derived().nestedExpression().coeff(row, col);
+    }
+
+    /** \sa MatrixBase::coeffRef()
+      * \warning the coordinates must fit into the referenced triangular part
+      */
+    EIGEN_DEVICE_FUNC
+    inline Scalar& coeffRef(Index row, Index col)
+    {
+      EIGEN_STATIC_ASSERT_LVALUE(TriangularViewType);
+      Base::check_coordinates_internal(row, col);
+      return derived().nestedExpression().coeffRef(row, col);
+    }
+
+    /** Assigns a triangular matrix to a triangular part of a dense matrix */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    TriangularViewType& operator=(const TriangularBase<OtherDerived>& other);
+
+    /** Shortcut for\code *this = other.other.triangularView<(*this)::Mode>() \endcode */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    TriangularViewType& operator=(const MatrixBase<OtherDerived>& other);
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    EIGEN_DEVICE_FUNC
+    TriangularViewType& operator=(const TriangularViewImpl& other)
+    { return *this = other.derived().nestedExpression(); }
+
+    /** \deprecated */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    void lazyAssign(const TriangularBase<OtherDerived>& other);
+
+    /** \deprecated */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    void lazyAssign(const MatrixBase<OtherDerived>& other);
+#endif
+
+    /** Efficient triangular matrix times vector/matrix product */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    const Product<TriangularViewType,OtherDerived>
+    operator*(const MatrixBase<OtherDerived>& rhs) const
+    {
+      return Product<TriangularViewType,OtherDerived>(derived(), rhs.derived());
+    }
+
+    /** Efficient vector/matrix times triangular matrix product */
+    template<typename OtherDerived> friend
+    EIGEN_DEVICE_FUNC
+    const Product<OtherDerived,TriangularViewType>
+    operator*(const MatrixBase<OtherDerived>& lhs, const TriangularViewImpl& rhs)
+    {
+      return Product<OtherDerived,TriangularViewType>(lhs.derived(),rhs.derived());
+    }
+
+    /** \returns the product of the inverse of \c *this with \a other, \a *this being triangular.
+      *
+      * This function computes the inverse-matrix matrix product inverse(\c *this) * \a other if
+      * \a Side==OnTheLeft (the default), or the right-inverse-multiply  \a other * inverse(\c *this) if
+      * \a Side==OnTheRight.
+      *
+      * Note that the template parameter \c Side can be ommitted, in which case \c Side==OnTheLeft
+      *
+      * The matrix \c *this must be triangular and invertible (i.e., all the coefficients of the
+      * diagonal must be non zero). It works as a forward (resp. backward) substitution if \c *this
+      * is an upper (resp. lower) triangular matrix.
+      *
+      * Example: \include Triangular_solve.cpp
+      * Output: \verbinclude Triangular_solve.out
+      *
+      * This function returns an expression of the inverse-multiply and can works in-place if it is assigned
+      * to the same matrix or vector \a other.
+      *
+      * For users coming from BLAS, this function (and more specifically solveInPlace()) offer
+      * all the operations supported by the \c *TRSV and \c *TRSM BLAS routines.
+      *
+      * \sa TriangularView::solveInPlace()
+      */
+    template<int Side, typename Other>
+    inline const internal::triangular_solve_retval<Side,TriangularViewType, Other>
+    solve(const MatrixBase<Other>& other) const;
+
+    /** "in-place" version of TriangularView::solve() where the result is written in \a other
+      *
+      * \warning The parameter is only marked 'const' to make the C++ compiler accept a temporary expression here.
+      * This function will const_cast it, so constness isn't honored here.
+      *
+      * Note that the template parameter \c Side can be ommitted, in which case \c Side==OnTheLeft
+      *
+      * See TriangularView:solve() for the details.
+      */
+    template<int Side, typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    void solveInPlace(const MatrixBase<OtherDerived>& other) const;
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    void solveInPlace(const MatrixBase<OtherDerived>& other) const
+    { return solveInPlace<OnTheLeft>(other); }
+
+    /** Swaps the coefficients of the common triangular parts of two matrices */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+    void swap(TriangularBase<OtherDerived> &other)
+#else
+    void swap(TriangularBase<OtherDerived> const & other)
+#endif
+    {
+      EIGEN_STATIC_ASSERT_LVALUE(OtherDerived);
+      call_assignment(derived(), other.const_cast_derived(), internal::swap_assign_op<Scalar>());
+    }
+
+    /** \deprecated
+      * Shortcut for \code (*this).swap(other.triangularView<(*this)::Mode>()) \endcode */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    void swap(MatrixBase<OtherDerived> const & other)
+    {
+      EIGEN_STATIC_ASSERT_LVALUE(OtherDerived);
+      call_assignment(derived(), other.const_cast_derived(), internal::swap_assign_op<Scalar>());
+    }
+
+    template<typename RhsType, typename DstType>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _solve_impl(const RhsType &rhs, DstType &dst) const {
+      if(!internal::is_same_dense(dst,rhs))
+        dst = rhs;
+      this->solveInPlace(dst);
+    }
+
+    template<typename ProductType>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE TriangularViewType& _assignProduct(const ProductType& prod, const Scalar& alpha, bool beta);
+};
+
+/***************************************************************************
+* Implementation of triangular evaluation/assignment
+***************************************************************************/
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+// FIXME should we keep that possibility
+template<typename MatrixType, unsigned int Mode>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC inline TriangularView<MatrixType, Mode>&
+TriangularViewImpl<MatrixType, Mode, Dense>::operator=(const MatrixBase<OtherDerived>& other)
+{
+  internal::call_assignment_no_alias(derived(), other.derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+// FIXME should we keep that possibility
+template<typename MatrixType, unsigned int Mode>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC void TriangularViewImpl<MatrixType, Mode, Dense>::lazyAssign(const MatrixBase<OtherDerived>& other)
+{
+  internal::call_assignment_no_alias(derived(), other.template triangularView<Mode>());
+}
+
+
+
+template<typename MatrixType, unsigned int Mode>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC inline TriangularView<MatrixType, Mode>&
+TriangularViewImpl<MatrixType, Mode, Dense>::operator=(const TriangularBase<OtherDerived>& other)
+{
+  eigen_assert(Mode == int(OtherDerived::Mode));
+  internal::call_assignment(derived(), other.derived());
+  return derived();
+}
+
+template<typename MatrixType, unsigned int Mode>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC void TriangularViewImpl<MatrixType, Mode, Dense>::lazyAssign(const TriangularBase<OtherDerived>& other)
+{
+  eigen_assert(Mode == int(OtherDerived::Mode));
+  internal::call_assignment_no_alias(derived(), other.derived());
+}
+#endif
+
+/***************************************************************************
+* Implementation of TriangularBase methods
+***************************************************************************/
+
+/** Assigns a triangular or selfadjoint matrix to a dense matrix.
+  * If the matrix is triangular, the opposite part is set to zero. */
+template<typename Derived>
+template<typename DenseDerived>
+EIGEN_DEVICE_FUNC void TriangularBase<Derived>::evalTo(MatrixBase<DenseDerived> &other) const
+{
+  evalToLazy(other.derived());
+}
+
+/***************************************************************************
+* Implementation of TriangularView methods
+***************************************************************************/
+
+/***************************************************************************
+* Implementation of MatrixBase methods
+***************************************************************************/
+
+/**
+  * \returns an expression of a triangular view extracted from the current matrix
+  *
+  * The parameter \a Mode can have the following values: \c #Upper, \c #StrictlyUpper, \c #UnitUpper,
+  * \c #Lower, \c #StrictlyLower, \c #UnitLower.
+  *
+  * Example: \include MatrixBase_triangularView.cpp
+  * Output: \verbinclude MatrixBase_triangularView.out
+  *
+  * \sa class TriangularView
+  */
+template<typename Derived>
+template<unsigned int Mode>
+EIGEN_DEVICE_FUNC
+typename MatrixBase<Derived>::template TriangularViewReturnType<Mode>::Type
+MatrixBase<Derived>::triangularView()
+{
+  return typename TriangularViewReturnType<Mode>::Type(derived());
+}
+
+/** This is the const version of MatrixBase::triangularView() */
+template<typename Derived>
+template<unsigned int Mode>
+EIGEN_DEVICE_FUNC
+typename MatrixBase<Derived>::template ConstTriangularViewReturnType<Mode>::Type
+MatrixBase<Derived>::triangularView() const
+{
+  return typename ConstTriangularViewReturnType<Mode>::Type(derived());
+}
+
+/** \returns true if *this is approximately equal to an upper triangular matrix,
+  *          within the precision given by \a prec.
+  *
+  * \sa isLowerTriangular()
+  */
+template<typename Derived>
+bool MatrixBase<Derived>::isUpperTriangular(const RealScalar& prec) const
+{
+  RealScalar maxAbsOnUpperPart = static_cast<RealScalar>(-1);
+  for(Index j = 0; j < cols(); ++j)
+  {
+    Index maxi = numext::mini(j, rows()-1);
+    for(Index i = 0; i <= maxi; ++i)
+    {
+      RealScalar absValue = numext::abs(coeff(i,j));
+      if(absValue > maxAbsOnUpperPart) maxAbsOnUpperPart = absValue;
+    }
+  }
+  RealScalar threshold = maxAbsOnUpperPart * prec;
+  for(Index j = 0; j < cols(); ++j)
+    for(Index i = j+1; i < rows(); ++i)
+      if(numext::abs(coeff(i, j)) > threshold) return false;
+  return true;
+}
+
+/** \returns true if *this is approximately equal to a lower triangular matrix,
+  *          within the precision given by \a prec.
+  *
+  * \sa isUpperTriangular()
+  */
+template<typename Derived>
+bool MatrixBase<Derived>::isLowerTriangular(const RealScalar& prec) const
+{
+  RealScalar maxAbsOnLowerPart = static_cast<RealScalar>(-1);
+  for(Index j = 0; j < cols(); ++j)
+    for(Index i = j; i < rows(); ++i)
+    {
+      RealScalar absValue = numext::abs(coeff(i,j));
+      if(absValue > maxAbsOnLowerPart) maxAbsOnLowerPart = absValue;
+    }
+  RealScalar threshold = maxAbsOnLowerPart * prec;
+  for(Index j = 1; j < cols(); ++j)
+  {
+    Index maxi = numext::mini(j, rows()-1);
+    for(Index i = 0; i < maxi; ++i)
+      if(numext::abs(coeff(i, j)) > threshold) return false;
+  }
+  return true;
+}
+
+
+/***************************************************************************
+****************************************************************************
+* Evaluators and Assignment of triangular expressions
+***************************************************************************
+***************************************************************************/
+
+namespace internal {
+
+  
+// TODO currently a triangular expression has the form TriangularView<.,.>
+//      in the future triangular-ness should be defined by the expression traits
+//      such that Transpose<TriangularView<.,.> > is valid. (currently TriangularBase::transpose() is overloaded to make it work)
+template<typename MatrixType, unsigned int Mode>
+struct evaluator_traits<TriangularView<MatrixType,Mode> >
+{
+  typedef typename storage_kind_to_evaluator_kind<typename MatrixType::StorageKind>::Kind Kind;
+  typedef typename glue_shapes<typename evaluator_traits<MatrixType>::Shape, TriangularShape>::type Shape;
+};
+
+template<typename MatrixType, unsigned int Mode>
+struct unary_evaluator<TriangularView<MatrixType,Mode>, IndexBased>
+ : evaluator<typename internal::remove_all<MatrixType>::type>
+{
+  typedef TriangularView<MatrixType,Mode> XprType;
+  typedef evaluator<typename internal::remove_all<MatrixType>::type> Base;
+  unary_evaluator(const XprType &xpr) : Base(xpr.nestedExpression()) {}
+};
+
+// Additional assignment kinds:
+struct Triangular2Triangular    {};
+struct Triangular2Dense         {};
+struct Dense2Triangular         {};
+
+
+template<typename Kernel, unsigned int Mode, int UnrollCount, bool ClearOpposite> struct triangular_assignment_loop;
+
+ 
+/** \internal Specialization of the dense assignment kernel for triangular matrices.
+  * The main difference is that the triangular, diagonal, and opposite parts are processed through three different functions.
+  * \tparam UpLo must be either Lower or Upper
+  * \tparam Mode must be either 0, UnitDiag, ZeroDiag, or SelfAdjoint
+  */
+template<int UpLo, int Mode, int SetOpposite, typename DstEvaluatorTypeT, typename SrcEvaluatorTypeT, typename Functor, int Version = Specialized>
+class triangular_dense_assignment_kernel : public generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, Version>
+{
+protected:
+  typedef generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, Version> Base;
+  typedef typename Base::DstXprType DstXprType;
+  typedef typename Base::SrcXprType SrcXprType;
+  using Base::m_dst;
+  using Base::m_src;
+  using Base::m_functor;
+public:
+  
+  typedef typename Base::DstEvaluatorType DstEvaluatorType;
+  typedef typename Base::SrcEvaluatorType SrcEvaluatorType;
+  typedef typename Base::Scalar Scalar;
+  typedef typename Base::AssignmentTraits AssignmentTraits;
+  
+  
+  EIGEN_DEVICE_FUNC triangular_dense_assignment_kernel(DstEvaluatorType &dst, const SrcEvaluatorType &src, const Functor &func, DstXprType& dstExpr)
+    : Base(dst, src, func, dstExpr)
+  {}
+  
+#ifdef EIGEN_INTERNAL_DEBUGGING
+  EIGEN_DEVICE_FUNC void assignCoeff(Index row, Index col)
+  {
+    eigen_internal_assert(row!=col);
+    Base::assignCoeff(row,col);
+  }
+#else
+  using Base::assignCoeff;
+#endif
+  
+  EIGEN_DEVICE_FUNC void assignDiagonalCoeff(Index id)
+  {
+         if(Mode==UnitDiag && SetOpposite) m_functor.assignCoeff(m_dst.coeffRef(id,id), Scalar(1));
+    else if(Mode==ZeroDiag && SetOpposite) m_functor.assignCoeff(m_dst.coeffRef(id,id), Scalar(0));
+    else if(Mode==0)                       Base::assignCoeff(id,id);
+  }
+  
+  EIGEN_DEVICE_FUNC void assignOppositeCoeff(Index row, Index col)
+  { 
+    eigen_internal_assert(row!=col);
+    if(SetOpposite)
+      m_functor.assignCoeff(m_dst.coeffRef(row,col), Scalar(0));
+  }
+};
+
+template<int Mode, bool SetOpposite, typename DstXprType, typename SrcXprType, typename Functor>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_triangular_assignment_loop(DstXprType& dst, const SrcXprType& src, const Functor &func)
+{
+  typedef evaluator<DstXprType> DstEvaluatorType;
+  typedef evaluator<SrcXprType> SrcEvaluatorType;
+
+  SrcEvaluatorType srcEvaluator(src);
+
+  Index dstRows = src.rows();
+  Index dstCols = src.cols();
+  if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+    dst.resize(dstRows, dstCols);
+  DstEvaluatorType dstEvaluator(dst);
+    
+  typedef triangular_dense_assignment_kernel< Mode&(Lower|Upper),Mode&(UnitDiag|ZeroDiag|SelfAdjoint),SetOpposite,
+                                              DstEvaluatorType,SrcEvaluatorType,Functor> Kernel;
+  Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
+  
+  enum {
+      unroll = DstXprType::SizeAtCompileTime != Dynamic
+            && SrcEvaluatorType::CoeffReadCost < HugeCost
+            && DstXprType::SizeAtCompileTime * (DstEvaluatorType::CoeffReadCost+SrcEvaluatorType::CoeffReadCost) / 2 <= EIGEN_UNROLLING_LIMIT
+    };
+  
+  triangular_assignment_loop<Kernel, Mode, unroll ? int(DstXprType::SizeAtCompileTime) : Dynamic, SetOpposite>::run(kernel);
+}
+
+template<int Mode, bool SetOpposite, typename DstXprType, typename SrcXprType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_triangular_assignment_loop(DstXprType& dst, const SrcXprType& src)
+{
+  call_triangular_assignment_loop<Mode,SetOpposite>(dst, src, internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar>());
+}
+
+template<> struct AssignmentKind<TriangularShape,TriangularShape> { typedef Triangular2Triangular Kind; };
+template<> struct AssignmentKind<DenseShape,TriangularShape>      { typedef Triangular2Dense      Kind; };
+template<> struct AssignmentKind<TriangularShape,DenseShape>      { typedef Dense2Triangular      Kind; };
+
+
+template< typename DstXprType, typename SrcXprType, typename Functor>
+struct Assignment<DstXprType, SrcXprType, Functor, Triangular2Triangular>
+{
+  EIGEN_DEVICE_FUNC static void run(DstXprType &dst, const SrcXprType &src, const Functor &func)
+  {
+    eigen_assert(int(DstXprType::Mode) == int(SrcXprType::Mode));
+    
+    call_triangular_assignment_loop<DstXprType::Mode, false>(dst, src, func);  
+  }
+};
+
+template< typename DstXprType, typename SrcXprType, typename Functor>
+struct Assignment<DstXprType, SrcXprType, Functor, Triangular2Dense>
+{
+  EIGEN_DEVICE_FUNC static void run(DstXprType &dst, const SrcXprType &src, const Functor &func)
+  {
+    call_triangular_assignment_loop<SrcXprType::Mode, (SrcXprType::Mode&SelfAdjoint)==0>(dst, src, func);  
+  }
+};
+
+template< typename DstXprType, typename SrcXprType, typename Functor>
+struct Assignment<DstXprType, SrcXprType, Functor, Dense2Triangular>
+{
+  EIGEN_DEVICE_FUNC static void run(DstXprType &dst, const SrcXprType &src, const Functor &func)
+  {
+    call_triangular_assignment_loop<DstXprType::Mode, false>(dst, src, func);  
+  }
+};
+
+
+template<typename Kernel, unsigned int Mode, int UnrollCount, bool SetOpposite>
+struct triangular_assignment_loop
+{
+  // FIXME: this is not very clean, perhaps this information should be provided by the kernel?
+  typedef typename Kernel::DstEvaluatorType DstEvaluatorType;
+  typedef typename DstEvaluatorType::XprType DstXprType;
+  
+  enum {
+    col = (UnrollCount-1) / DstXprType::RowsAtCompileTime,
+    row = (UnrollCount-1) % DstXprType::RowsAtCompileTime
+  };
+  
+  typedef typename Kernel::Scalar Scalar;
+
+  EIGEN_DEVICE_FUNC
+  static inline void run(Kernel &kernel)
+  {
+    triangular_assignment_loop<Kernel, Mode, UnrollCount-1, SetOpposite>::run(kernel);
+    
+    if(row==col)
+      kernel.assignDiagonalCoeff(row);
+    else if( ((Mode&Lower) && row>col) || ((Mode&Upper) && row<col) )
+      kernel.assignCoeff(row,col);
+    else if(SetOpposite)
+      kernel.assignOppositeCoeff(row,col);
+  }
+};
+
+// prevent buggy user code from causing an infinite recursion
+template<typename Kernel, unsigned int Mode, bool SetOpposite>
+struct triangular_assignment_loop<Kernel, Mode, 0, SetOpposite>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(Kernel &) {}
+};
+
+
+
+// TODO: experiment with a recursive assignment procedure splitting the current
+//       triangular part into one rectangular and two triangular parts.
+
+
+template<typename Kernel, unsigned int Mode, bool SetOpposite>
+struct triangular_assignment_loop<Kernel, Mode, Dynamic, SetOpposite>
+{
+  typedef typename Kernel::Scalar Scalar;
+  EIGEN_DEVICE_FUNC
+  static inline void run(Kernel &kernel)
+  {
+    for(Index j = 0; j < kernel.cols(); ++j)
+    {
+      Index maxi = numext::mini(j, kernel.rows());
+      Index i = 0;
+      if (((Mode&Lower) && SetOpposite) || (Mode&Upper))
+      {
+        for(; i < maxi; ++i)
+          if(Mode&Upper) kernel.assignCoeff(i, j);
+          else           kernel.assignOppositeCoeff(i, j);
+      }
+      else
+        i = maxi;
+      
+      if(i<kernel.rows()) // then i==j
+        kernel.assignDiagonalCoeff(i++);
+      
+      if (((Mode&Upper) && SetOpposite) || (Mode&Lower))
+      {
+        for(; i < kernel.rows(); ++i)
+          if(Mode&Lower) kernel.assignCoeff(i, j);
+          else           kernel.assignOppositeCoeff(i, j);
+      }
+    }
+  }
+};
+
+} // end namespace internal
+
+/** Assigns a triangular or selfadjoint matrix to a dense matrix.
+  * If the matrix is triangular, the opposite part is set to zero. */
+template<typename Derived>
+template<typename DenseDerived>
+EIGEN_DEVICE_FUNC void TriangularBase<Derived>::evalToLazy(MatrixBase<DenseDerived> &other) const
+{
+  other.derived().resize(this->rows(), this->cols());
+  internal::call_triangular_assignment_loop<Derived::Mode,(Derived::Mode&SelfAdjoint)==0 /* SetOpposite */>(other.derived(), derived().nestedExpression());
+}
+
+namespace internal {
+  
+// Triangular = Product
+template< typename DstXprType, typename Lhs, typename Rhs, typename Scalar>
+struct Assignment<DstXprType, Product<Lhs,Rhs,DefaultProduct>, internal::assign_op<Scalar,typename Product<Lhs,Rhs,DefaultProduct>::Scalar>, Dense2Triangular>
+{
+  typedef Product<Lhs,Rhs,DefaultProduct> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,typename SrcXprType::Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    dst._assignProduct(src, 1, 0);
+  }
+};
+
+// Triangular += Product
+template< typename DstXprType, typename Lhs, typename Rhs, typename Scalar>
+struct Assignment<DstXprType, Product<Lhs,Rhs,DefaultProduct>, internal::add_assign_op<Scalar,typename Product<Lhs,Rhs,DefaultProduct>::Scalar>, Dense2Triangular>
+{
+  typedef Product<Lhs,Rhs,DefaultProduct> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<Scalar,typename SrcXprType::Scalar> &)
+  {
+    dst._assignProduct(src, 1, 1);
+  }
+};
+
+// Triangular -= Product
+template< typename DstXprType, typename Lhs, typename Rhs, typename Scalar>
+struct Assignment<DstXprType, Product<Lhs,Rhs,DefaultProduct>, internal::sub_assign_op<Scalar,typename Product<Lhs,Rhs,DefaultProduct>::Scalar>, Dense2Triangular>
+{
+  typedef Product<Lhs,Rhs,DefaultProduct> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<Scalar,typename SrcXprType::Scalar> &)
+  {
+    dst._assignProduct(src, -1, 1);
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRIANGULARMATRIX_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/VectorBlock.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/VectorBlock.h
new file mode 100644
index 00000000..d72fbf7e
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/VectorBlock.h
@@ -0,0 +1,96 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_VECTORBLOCK_H
+#define EIGEN_VECTORBLOCK_H
+
+namespace Eigen { 
+
+namespace internal {
+template<typename VectorType, int Size>
+struct traits<VectorBlock<VectorType, Size> >
+  : public traits<Block<VectorType,
+                     traits<VectorType>::Flags & RowMajorBit ? 1 : Size,
+                     traits<VectorType>::Flags & RowMajorBit ? Size : 1> >
+{
+};
+}
+
+/** \class VectorBlock
+  * \ingroup Core_Module
+  *
+  * \brief Expression of a fixed-size or dynamic-size sub-vector
+  *
+  * \tparam VectorType the type of the object in which we are taking a sub-vector
+  * \tparam Size size of the sub-vector we are taking at compile time (optional)
+  *
+  * This class represents an expression of either a fixed-size or dynamic-size sub-vector.
+  * It is the return type of DenseBase::segment(Index,Index) and DenseBase::segment<int>(Index) and
+  * most of the time this is the only way it is used.
+  *
+  * However, if you want to directly maniputate sub-vector expressions,
+  * for instance if you want to write a function returning such an expression, you
+  * will need to use this class.
+  *
+  * Here is an example illustrating the dynamic case:
+  * \include class_VectorBlock.cpp
+  * Output: \verbinclude class_VectorBlock.out
+  *
+  * \note Even though this expression has dynamic size, in the case where \a VectorType
+  * has fixed size, this expression inherits a fixed maximal size which means that evaluating
+  * it does not cause a dynamic memory allocation.
+  *
+  * Here is an example illustrating the fixed-size case:
+  * \include class_FixedVectorBlock.cpp
+  * Output: \verbinclude class_FixedVectorBlock.out
+  *
+  * \sa class Block, DenseBase::segment(Index,Index,Index,Index), DenseBase::segment(Index,Index)
+  */
+template<typename VectorType, int Size> class VectorBlock
+  : public Block<VectorType,
+                     internal::traits<VectorType>::Flags & RowMajorBit ? 1 : Size,
+                     internal::traits<VectorType>::Flags & RowMajorBit ? Size : 1>
+{
+    typedef Block<VectorType,
+                     internal::traits<VectorType>::Flags & RowMajorBit ? 1 : Size,
+                     internal::traits<VectorType>::Flags & RowMajorBit ? Size : 1> Base;
+    enum {
+      IsColVector = !(internal::traits<VectorType>::Flags & RowMajorBit)
+    };
+  public:
+    EIGEN_DENSE_PUBLIC_INTERFACE(VectorBlock)
+
+    using Base::operator=;
+
+    /** Dynamic-size constructor
+      */
+    EIGEN_DEVICE_FUNC
+    inline VectorBlock(VectorType& vector, Index start, Index size)
+      : Base(vector,
+             IsColVector ? start : 0, IsColVector ? 0 : start,
+             IsColVector ? size  : 1, IsColVector ? 1 : size)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(VectorBlock);
+    }
+
+    /** Fixed-size constructor
+      */
+    EIGEN_DEVICE_FUNC
+    inline VectorBlock(VectorType& vector, Index start)
+      : Base(vector, IsColVector ? start : 0, IsColVector ? 0 : start)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(VectorBlock);
+    }
+};
+
+
+} // end namespace Eigen
+
+#endif // EIGEN_VECTORBLOCK_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/VectorwiseOp.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/VectorwiseOp.h
new file mode 100644
index 00000000..893bc796
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/VectorwiseOp.h
@@ -0,0 +1,695 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PARTIAL_REDUX_H
+#define EIGEN_PARTIAL_REDUX_H
+
+namespace Eigen {
+
+/** \class PartialReduxExpr
+  * \ingroup Core_Module
+  *
+  * \brief Generic expression of a partially reduxed matrix
+  *
+  * \tparam MatrixType the type of the matrix we are applying the redux operation
+  * \tparam MemberOp type of the member functor
+  * \tparam Direction indicates the direction of the redux (#Vertical or #Horizontal)
+  *
+  * This class represents an expression of a partial redux operator of a matrix.
+  * It is the return type of some VectorwiseOp functions,
+  * and most of the time this is the only way it is used.
+  *
+  * \sa class VectorwiseOp
+  */
+
+template< typename MatrixType, typename MemberOp, int Direction>
+class PartialReduxExpr;
+
+namespace internal {
+template<typename MatrixType, typename MemberOp, int Direction>
+struct traits<PartialReduxExpr<MatrixType, MemberOp, Direction> >
+ : traits<MatrixType>
+{
+  typedef typename MemberOp::result_type Scalar;
+  typedef typename traits<MatrixType>::StorageKind StorageKind;
+  typedef typename traits<MatrixType>::XprKind XprKind;
+  typedef typename MatrixType::Scalar InputScalar;
+  enum {
+    RowsAtCompileTime = Direction==Vertical   ? 1 : MatrixType::RowsAtCompileTime,
+    ColsAtCompileTime = Direction==Horizontal ? 1 : MatrixType::ColsAtCompileTime,
+    MaxRowsAtCompileTime = Direction==Vertical   ? 1 : MatrixType::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = Direction==Horizontal ? 1 : MatrixType::MaxColsAtCompileTime,
+    Flags = RowsAtCompileTime == 1 ? RowMajorBit : 0,
+    TraversalSize = Direction==Vertical ? MatrixType::RowsAtCompileTime :  MatrixType::ColsAtCompileTime
+  };
+};
+}
+
+template< typename MatrixType, typename MemberOp, int Direction>
+class PartialReduxExpr : public internal::dense_xpr_base< PartialReduxExpr<MatrixType, MemberOp, Direction> >::type,
+                         internal::no_assignment_operator
+{
+  public:
+
+    typedef typename internal::dense_xpr_base<PartialReduxExpr>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(PartialReduxExpr)
+
+    EIGEN_DEVICE_FUNC
+    explicit PartialReduxExpr(const MatrixType& mat, const MemberOp& func = MemberOp())
+      : m_matrix(mat), m_functor(func) {}
+
+    EIGEN_DEVICE_FUNC
+    Index rows() const { return (Direction==Vertical   ? 1 : m_matrix.rows()); }
+    EIGEN_DEVICE_FUNC
+    Index cols() const { return (Direction==Horizontal ? 1 : m_matrix.cols()); }
+
+    EIGEN_DEVICE_FUNC
+    typename MatrixType::Nested nestedExpression() const { return m_matrix; }
+
+    EIGEN_DEVICE_FUNC
+    const MemberOp& functor() const { return m_functor; }
+
+  protected:
+    typename MatrixType::Nested m_matrix;
+    const MemberOp m_functor;
+};
+
+#define EIGEN_MEMBER_FUNCTOR(MEMBER,COST)                               \
+  template <typename ResultType>                                        \
+  struct member_##MEMBER {                                              \
+    EIGEN_EMPTY_STRUCT_CTOR(member_##MEMBER)                            \
+    typedef ResultType result_type;                                     \
+    template<typename Scalar, int Size> struct Cost                     \
+    { enum { value = COST }; };                                         \
+    template<typename XprType>                                          \
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                               \
+    ResultType operator()(const XprType& mat) const                     \
+    { return mat.MEMBER(); } \
+  }
+
+namespace internal {
+
+EIGEN_MEMBER_FUNCTOR(squaredNorm, Size * NumTraits<Scalar>::MulCost + (Size-1)*NumTraits<Scalar>::AddCost);
+EIGEN_MEMBER_FUNCTOR(norm, (Size+5) * NumTraits<Scalar>::MulCost + (Size-1)*NumTraits<Scalar>::AddCost);
+EIGEN_MEMBER_FUNCTOR(stableNorm, (Size+5) * NumTraits<Scalar>::MulCost + (Size-1)*NumTraits<Scalar>::AddCost);
+EIGEN_MEMBER_FUNCTOR(blueNorm, (Size+5) * NumTraits<Scalar>::MulCost + (Size-1)*NumTraits<Scalar>::AddCost);
+EIGEN_MEMBER_FUNCTOR(hypotNorm, (Size-1) * functor_traits<scalar_hypot_op<Scalar> >::Cost );
+EIGEN_MEMBER_FUNCTOR(sum, (Size-1)*NumTraits<Scalar>::AddCost);
+EIGEN_MEMBER_FUNCTOR(mean, (Size-1)*NumTraits<Scalar>::AddCost + NumTraits<Scalar>::MulCost);
+EIGEN_MEMBER_FUNCTOR(minCoeff, (Size-1)*NumTraits<Scalar>::AddCost);
+EIGEN_MEMBER_FUNCTOR(maxCoeff, (Size-1)*NumTraits<Scalar>::AddCost);
+EIGEN_MEMBER_FUNCTOR(all, (Size-1)*NumTraits<Scalar>::AddCost);
+EIGEN_MEMBER_FUNCTOR(any, (Size-1)*NumTraits<Scalar>::AddCost);
+EIGEN_MEMBER_FUNCTOR(count, (Size-1)*NumTraits<Scalar>::AddCost);
+EIGEN_MEMBER_FUNCTOR(prod, (Size-1)*NumTraits<Scalar>::MulCost);
+
+template <int p, typename ResultType>
+struct member_lpnorm {
+  typedef ResultType result_type;
+  template<typename Scalar, int Size> struct Cost
+  { enum { value = (Size+5) * NumTraits<Scalar>::MulCost + (Size-1)*NumTraits<Scalar>::AddCost }; };
+  EIGEN_DEVICE_FUNC member_lpnorm() {}
+  template<typename XprType>
+  EIGEN_DEVICE_FUNC inline ResultType operator()(const XprType& mat) const
+  { return mat.template lpNorm<p>(); }
+};
+
+template <typename BinaryOp, typename Scalar>
+struct member_redux {
+  typedef typename result_of<
+                     BinaryOp(const Scalar&,const Scalar&)
+                   >::type  result_type;
+  template<typename _Scalar, int Size> struct Cost
+  { enum { value = (Size-1) * functor_traits<BinaryOp>::Cost }; };
+  EIGEN_DEVICE_FUNC explicit member_redux(const BinaryOp func) : m_functor(func) {}
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline result_type operator()(const DenseBase<Derived>& mat) const
+  { return mat.redux(m_functor); }
+  const BinaryOp m_functor;
+};
+}
+
+/** \class VectorwiseOp
+  * \ingroup Core_Module
+  *
+  * \brief Pseudo expression providing partial reduction operations
+  *
+  * \tparam ExpressionType the type of the object on which to do partial reductions
+  * \tparam Direction indicates the direction of the redux (#Vertical or #Horizontal)
+  *
+  * This class represents a pseudo expression with partial reduction features.
+  * It is the return type of DenseBase::colwise() and DenseBase::rowwise()
+  * and most of the time this is the only way it is used.
+  *
+  * Example: \include MatrixBase_colwise.cpp
+  * Output: \verbinclude MatrixBase_colwise.out
+  *
+  * \sa DenseBase::colwise(), DenseBase::rowwise(), class PartialReduxExpr
+  */
+template<typename ExpressionType, int Direction> class VectorwiseOp
+{
+  public:
+
+    typedef typename ExpressionType::Scalar Scalar;
+    typedef typename ExpressionType::RealScalar RealScalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+    typedef typename internal::ref_selector<ExpressionType>::non_const_type ExpressionTypeNested;
+    typedef typename internal::remove_all<ExpressionTypeNested>::type ExpressionTypeNestedCleaned;
+
+    template<template<typename _Scalar> class Functor,
+                      typename Scalar_=Scalar> struct ReturnType
+    {
+      typedef PartialReduxExpr<ExpressionType,
+                               Functor<Scalar_>,
+                               Direction
+                              > Type;
+    };
+
+    template<typename BinaryOp> struct ReduxReturnType
+    {
+      typedef PartialReduxExpr<ExpressionType,
+                               internal::member_redux<BinaryOp,Scalar>,
+                               Direction
+                              > Type;
+    };
+
+    enum {
+      isVertical   = (Direction==Vertical) ? 1 : 0,
+      isHorizontal = (Direction==Horizontal) ? 1 : 0
+    };
+
+  protected:
+
+    typedef typename internal::conditional<isVertical,
+                               typename ExpressionType::ColXpr,
+                               typename ExpressionType::RowXpr>::type SubVector;
+    /** \internal
+      * \returns the i-th subvector according to the \c Direction */
+    EIGEN_DEVICE_FUNC
+    SubVector subVector(Index i)
+    {
+      return SubVector(m_matrix.derived(),i);
+    }
+
+    /** \internal
+      * \returns the number of subvectors in the direction \c Direction */
+    EIGEN_DEVICE_FUNC
+    Index subVectors() const
+    { return isVertical?m_matrix.cols():m_matrix.rows(); }
+
+    template<typename OtherDerived> struct ExtendedType {
+      typedef Replicate<OtherDerived,
+                        isVertical   ? 1 : ExpressionType::RowsAtCompileTime,
+                        isHorizontal ? 1 : ExpressionType::ColsAtCompileTime> Type;
+    };
+
+    /** \internal
+      * Replicates a vector to match the size of \c *this */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    typename ExtendedType<OtherDerived>::Type
+    extendedTo(const DenseBase<OtherDerived>& other) const
+    {
+      EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(isVertical, OtherDerived::MaxColsAtCompileTime==1),
+                          YOU_PASSED_A_ROW_VECTOR_BUT_A_COLUMN_VECTOR_WAS_EXPECTED)
+      EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(isHorizontal, OtherDerived::MaxRowsAtCompileTime==1),
+                          YOU_PASSED_A_COLUMN_VECTOR_BUT_A_ROW_VECTOR_WAS_EXPECTED)
+      return typename ExtendedType<OtherDerived>::Type
+                      (other.derived(),
+                       isVertical   ? 1 : m_matrix.rows(),
+                       isHorizontal ? 1 : m_matrix.cols());
+    }
+
+    template<typename OtherDerived> struct OppositeExtendedType {
+      typedef Replicate<OtherDerived,
+                        isHorizontal ? 1 : ExpressionType::RowsAtCompileTime,
+                        isVertical   ? 1 : ExpressionType::ColsAtCompileTime> Type;
+    };
+
+    /** \internal
+      * Replicates a vector in the opposite direction to match the size of \c *this */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    typename OppositeExtendedType<OtherDerived>::Type
+    extendedToOpposite(const DenseBase<OtherDerived>& other) const
+    {
+      EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(isHorizontal, OtherDerived::MaxColsAtCompileTime==1),
+                          YOU_PASSED_A_ROW_VECTOR_BUT_A_COLUMN_VECTOR_WAS_EXPECTED)
+      EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(isVertical, OtherDerived::MaxRowsAtCompileTime==1),
+                          YOU_PASSED_A_COLUMN_VECTOR_BUT_A_ROW_VECTOR_WAS_EXPECTED)
+      return typename OppositeExtendedType<OtherDerived>::Type
+                      (other.derived(),
+                       isHorizontal  ? 1 : m_matrix.rows(),
+                       isVertical    ? 1 : m_matrix.cols());
+    }
+
+  public:
+    EIGEN_DEVICE_FUNC
+    explicit inline VectorwiseOp(ExpressionType& matrix) : m_matrix(matrix) {}
+
+    /** \internal */
+    EIGEN_DEVICE_FUNC
+    inline const ExpressionType& _expression() const { return m_matrix; }
+
+    /** \returns a row or column vector expression of \c *this reduxed by \a func
+      *
+      * The template parameter \a BinaryOp is the type of the functor
+      * of the custom redux operator. Note that func must be an associative operator.
+      *
+      * \sa class VectorwiseOp, DenseBase::colwise(), DenseBase::rowwise()
+      */
+    template<typename BinaryOp>
+    EIGEN_DEVICE_FUNC
+    const typename ReduxReturnType<BinaryOp>::Type
+    redux(const BinaryOp& func = BinaryOp()) const
+    { return typename ReduxReturnType<BinaryOp>::Type(_expression(), internal::member_redux<BinaryOp,Scalar>(func)); }
+
+    typedef typename ReturnType<internal::member_minCoeff>::Type MinCoeffReturnType;
+    typedef typename ReturnType<internal::member_maxCoeff>::Type MaxCoeffReturnType;
+    typedef typename ReturnType<internal::member_squaredNorm,RealScalar>::Type SquaredNormReturnType;
+    typedef typename ReturnType<internal::member_norm,RealScalar>::Type NormReturnType;
+    typedef typename ReturnType<internal::member_blueNorm,RealScalar>::Type BlueNormReturnType;
+    typedef typename ReturnType<internal::member_stableNorm,RealScalar>::Type StableNormReturnType;
+    typedef typename ReturnType<internal::member_hypotNorm,RealScalar>::Type HypotNormReturnType;
+    typedef typename ReturnType<internal::member_sum>::Type SumReturnType;
+    typedef typename ReturnType<internal::member_mean>::Type MeanReturnType;
+    typedef typename ReturnType<internal::member_all>::Type AllReturnType;
+    typedef typename ReturnType<internal::member_any>::Type AnyReturnType;
+    typedef PartialReduxExpr<ExpressionType, internal::member_count<Index>, Direction> CountReturnType;
+    typedef typename ReturnType<internal::member_prod>::Type ProdReturnType;
+    typedef Reverse<const ExpressionType, Direction> ConstReverseReturnType;
+    typedef Reverse<ExpressionType, Direction> ReverseReturnType;
+
+    template<int p> struct LpNormReturnType {
+      typedef PartialReduxExpr<ExpressionType, internal::member_lpnorm<p,RealScalar>,Direction> Type;
+    };
+
+    /** \returns a row (or column) vector expression of the smallest coefficient
+      * of each column (or row) of the referenced expression.
+      *
+      * \warning the result is undefined if \c *this contains NaN.
+      *
+      * Example: \include PartialRedux_minCoeff.cpp
+      * Output: \verbinclude PartialRedux_minCoeff.out
+      *
+      * \sa DenseBase::minCoeff() */
+    EIGEN_DEVICE_FUNC
+    const MinCoeffReturnType minCoeff() const
+    { return MinCoeffReturnType(_expression()); }
+
+    /** \returns a row (or column) vector expression of the largest coefficient
+      * of each column (or row) of the referenced expression.
+      *
+      * \warning the result is undefined if \c *this contains NaN.
+      *
+      * Example: \include PartialRedux_maxCoeff.cpp
+      * Output: \verbinclude PartialRedux_maxCoeff.out
+      *
+      * \sa DenseBase::maxCoeff() */
+    EIGEN_DEVICE_FUNC
+    const MaxCoeffReturnType maxCoeff() const
+    { return MaxCoeffReturnType(_expression()); }
+
+    /** \returns a row (or column) vector expression of the squared norm
+      * of each column (or row) of the referenced expression.
+      * This is a vector with real entries, even if the original matrix has complex entries.
+      *
+      * Example: \include PartialRedux_squaredNorm.cpp
+      * Output: \verbinclude PartialRedux_squaredNorm.out
+      *
+      * \sa DenseBase::squaredNorm() */
+    EIGEN_DEVICE_FUNC
+    const SquaredNormReturnType squaredNorm() const
+    { return SquaredNormReturnType(_expression()); }
+
+    /** \returns a row (or column) vector expression of the norm
+      * of each column (or row) of the referenced expression.
+      * This is a vector with real entries, even if the original matrix has complex entries.
+      *
+      * Example: \include PartialRedux_norm.cpp
+      * Output: \verbinclude PartialRedux_norm.out
+      *
+      * \sa DenseBase::norm() */
+    EIGEN_DEVICE_FUNC
+    const NormReturnType norm() const
+    { return NormReturnType(_expression()); }
+
+    /** \returns a row (or column) vector expression of the norm
+      * of each column (or row) of the referenced expression.
+      * This is a vector with real entries, even if the original matrix has complex entries.
+      *
+      * Example: \include PartialRedux_norm.cpp
+      * Output: \verbinclude PartialRedux_norm.out
+      *
+      * \sa DenseBase::norm() */
+    template<int p>
+    EIGEN_DEVICE_FUNC
+    const typename LpNormReturnType<p>::Type lpNorm() const
+    { return typename LpNormReturnType<p>::Type(_expression()); }
+
+
+    /** \returns a row (or column) vector expression of the norm
+      * of each column (or row) of the referenced expression, using
+      * Blue's algorithm.
+      * This is a vector with real entries, even if the original matrix has complex entries.
+      *
+      * \sa DenseBase::blueNorm() */
+    EIGEN_DEVICE_FUNC
+    const BlueNormReturnType blueNorm() const
+    { return BlueNormReturnType(_expression()); }
+
+
+    /** \returns a row (or column) vector expression of the norm
+      * of each column (or row) of the referenced expression, avoiding
+      * underflow and overflow.
+      * This is a vector with real entries, even if the original matrix has complex entries.
+      *
+      * \sa DenseBase::stableNorm() */
+    EIGEN_DEVICE_FUNC
+    const StableNormReturnType stableNorm() const
+    { return StableNormReturnType(_expression()); }
+
+
+    /** \returns a row (or column) vector expression of the norm
+      * of each column (or row) of the referenced expression, avoiding
+      * underflow and overflow using a concatenation of hypot() calls.
+      * This is a vector with real entries, even if the original matrix has complex entries.
+      *
+      * \sa DenseBase::hypotNorm() */
+    EIGEN_DEVICE_FUNC
+    const HypotNormReturnType hypotNorm() const
+    { return HypotNormReturnType(_expression()); }
+
+    /** \returns a row (or column) vector expression of the sum
+      * of each column (or row) of the referenced expression.
+      *
+      * Example: \include PartialRedux_sum.cpp
+      * Output: \verbinclude PartialRedux_sum.out
+      *
+      * \sa DenseBase::sum() */
+    EIGEN_DEVICE_FUNC
+    const SumReturnType sum() const
+    { return SumReturnType(_expression()); }
+
+    /** \returns a row (or column) vector expression of the mean
+    * of each column (or row) of the referenced expression.
+    *
+    * \sa DenseBase::mean() */
+    EIGEN_DEVICE_FUNC
+    const MeanReturnType mean() const
+    { return MeanReturnType(_expression()); }
+
+    /** \returns a row (or column) vector expression representing
+      * whether \b all coefficients of each respective column (or row) are \c true.
+      * This expression can be assigned to a vector with entries of type \c bool.
+      *
+      * \sa DenseBase::all() */
+    EIGEN_DEVICE_FUNC
+    const AllReturnType all() const
+    { return AllReturnType(_expression()); }
+
+    /** \returns a row (or column) vector expression representing
+      * whether \b at \b least one coefficient of each respective column (or row) is \c true.
+      * This expression can be assigned to a vector with entries of type \c bool.
+      *
+      * \sa DenseBase::any() */
+    EIGEN_DEVICE_FUNC
+    const AnyReturnType any() const
+    { return AnyReturnType(_expression()); }
+
+    /** \returns a row (or column) vector expression representing
+      * the number of \c true coefficients of each respective column (or row).
+      * This expression can be assigned to a vector whose entries have the same type as is used to
+      * index entries of the original matrix; for dense matrices, this is \c std::ptrdiff_t .
+      *
+      * Example: \include PartialRedux_count.cpp
+      * Output: \verbinclude PartialRedux_count.out
+      *
+      * \sa DenseBase::count() */
+    EIGEN_DEVICE_FUNC
+    const CountReturnType count() const
+    { return CountReturnType(_expression()); }
+
+    /** \returns a row (or column) vector expression of the product
+      * of each column (or row) of the referenced expression.
+      *
+      * Example: \include PartialRedux_prod.cpp
+      * Output: \verbinclude PartialRedux_prod.out
+      *
+      * \sa DenseBase::prod() */
+    EIGEN_DEVICE_FUNC
+    const ProdReturnType prod() const
+    { return ProdReturnType(_expression()); }
+
+
+    /** \returns a matrix expression
+      * where each column (or row) are reversed.
+      *
+      * Example: \include Vectorwise_reverse.cpp
+      * Output: \verbinclude Vectorwise_reverse.out
+      *
+      * \sa DenseBase::reverse() */
+    EIGEN_DEVICE_FUNC
+    const ConstReverseReturnType reverse() const
+    { return ConstReverseReturnType( _expression() ); }
+
+    /** \returns a writable matrix expression
+      * where each column (or row) are reversed.
+      *
+      * \sa reverse() const */
+    EIGEN_DEVICE_FUNC
+    ReverseReturnType reverse()
+    { return ReverseReturnType( _expression() ); }
+
+    typedef Replicate<ExpressionType,(isVertical?Dynamic:1),(isHorizontal?Dynamic:1)> ReplicateReturnType;
+    EIGEN_DEVICE_FUNC
+    const ReplicateReturnType replicate(Index factor) const;
+
+    /**
+      * \return an expression of the replication of each column (or row) of \c *this
+      *
+      * Example: \include DirectionWise_replicate.cpp
+      * Output: \verbinclude DirectionWise_replicate.out
+      *
+      * \sa VectorwiseOp::replicate(Index), DenseBase::replicate(), class Replicate
+      */
+    // NOTE implemented here because of sunstudio's compilation errors
+    // isVertical*Factor+isHorizontal instead of (isVertical?Factor:1) to handle CUDA bug with ternary operator
+    template<int Factor> const Replicate<ExpressionType,isVertical*Factor+isHorizontal,isHorizontal*Factor+isVertical>
+    EIGEN_DEVICE_FUNC
+    replicate(Index factor = Factor) const
+    {
+      return Replicate<ExpressionType,(isVertical?Factor:1),(isHorizontal?Factor:1)>
+          (_expression(),isVertical?factor:1,isHorizontal?factor:1);
+    }
+
+/////////// Artithmetic operators ///////////
+
+    /** Copies the vector \a other to each subvector of \c *this */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    ExpressionType& operator=(const DenseBase<OtherDerived>& other)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+      EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+      //eigen_assert((m_matrix.isNull()) == (other.isNull())); FIXME
+      return const_cast<ExpressionType&>(m_matrix = extendedTo(other.derived()));
+    }
+
+    /** Adds the vector \a other to each subvector of \c *this */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    ExpressionType& operator+=(const DenseBase<OtherDerived>& other)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+      EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+      return const_cast<ExpressionType&>(m_matrix += extendedTo(other.derived()));
+    }
+
+    /** Substracts the vector \a other to each subvector of \c *this */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    ExpressionType& operator-=(const DenseBase<OtherDerived>& other)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+      EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+      return const_cast<ExpressionType&>(m_matrix -= extendedTo(other.derived()));
+    }
+
+    /** Multiples each subvector of \c *this by the vector \a other */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    ExpressionType& operator*=(const DenseBase<OtherDerived>& other)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+      EIGEN_STATIC_ASSERT_ARRAYXPR(ExpressionType)
+      EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+      m_matrix *= extendedTo(other.derived());
+      return const_cast<ExpressionType&>(m_matrix);
+    }
+
+    /** Divides each subvector of \c *this by the vector \a other */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    ExpressionType& operator/=(const DenseBase<OtherDerived>& other)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+      EIGEN_STATIC_ASSERT_ARRAYXPR(ExpressionType)
+      EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+      m_matrix /= extendedTo(other.derived());
+      return const_cast<ExpressionType&>(m_matrix);
+    }
+
+    /** Returns the expression of the sum of the vector \a other to each subvector of \c *this */
+    template<typename OtherDerived> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+    CwiseBinaryOp<internal::scalar_sum_op<Scalar,typename OtherDerived::Scalar>,
+                  const ExpressionTypeNestedCleaned,
+                  const typename ExtendedType<OtherDerived>::Type>
+    operator+(const DenseBase<OtherDerived>& other) const
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+      EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+      return m_matrix + extendedTo(other.derived());
+    }
+
+    /** Returns the expression of the difference between each subvector of \c *this and the vector \a other */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    CwiseBinaryOp<internal::scalar_difference_op<Scalar,typename OtherDerived::Scalar>,
+                  const ExpressionTypeNestedCleaned,
+                  const typename ExtendedType<OtherDerived>::Type>
+    operator-(const DenseBase<OtherDerived>& other) const
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+      EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+      return m_matrix - extendedTo(other.derived());
+    }
+
+    /** Returns the expression where each subvector is the product of the vector \a other
+      * by the corresponding subvector of \c *this */
+    template<typename OtherDerived> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+    CwiseBinaryOp<internal::scalar_product_op<Scalar>,
+                  const ExpressionTypeNestedCleaned,
+                  const typename ExtendedType<OtherDerived>::Type>
+    EIGEN_DEVICE_FUNC
+    operator*(const DenseBase<OtherDerived>& other) const
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+      EIGEN_STATIC_ASSERT_ARRAYXPR(ExpressionType)
+      EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+      return m_matrix * extendedTo(other.derived());
+    }
+
+    /** Returns the expression where each subvector is the quotient of the corresponding
+      * subvector of \c *this by the vector \a other */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    CwiseBinaryOp<internal::scalar_quotient_op<Scalar>,
+                  const ExpressionTypeNestedCleaned,
+                  const typename ExtendedType<OtherDerived>::Type>
+    operator/(const DenseBase<OtherDerived>& other) const
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+      EIGEN_STATIC_ASSERT_ARRAYXPR(ExpressionType)
+      EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+      return m_matrix / extendedTo(other.derived());
+    }
+
+    /** \returns an expression where each column (or row) of the referenced matrix are normalized.
+      * The referenced matrix is \b not modified.
+      * \sa MatrixBase::normalized(), normalize()
+      */
+    EIGEN_DEVICE_FUNC
+    CwiseBinaryOp<internal::scalar_quotient_op<Scalar>,
+                  const ExpressionTypeNestedCleaned,
+                  const typename OppositeExtendedType<typename ReturnType<internal::member_norm,RealScalar>::Type>::Type>
+    normalized() const { return m_matrix.cwiseQuotient(extendedToOpposite(this->norm())); }
+
+
+    /** Normalize in-place each row or columns of the referenced matrix.
+      * \sa MatrixBase::normalize(), normalized()
+      */
+    EIGEN_DEVICE_FUNC void normalize() {
+      m_matrix = this->normalized();
+    }
+
+    EIGEN_DEVICE_FUNC inline void reverseInPlace();
+
+/////////// Geometry module ///////////
+
+    typedef Homogeneous<ExpressionType,Direction> HomogeneousReturnType;
+    EIGEN_DEVICE_FUNC
+    HomogeneousReturnType homogeneous() const;
+
+    typedef typename ExpressionType::PlainObject CrossReturnType;
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    const CrossReturnType cross(const MatrixBase<OtherDerived>& other) const;
+
+    enum {
+      HNormalized_Size = Direction==Vertical ? internal::traits<ExpressionType>::RowsAtCompileTime
+                                             : internal::traits<ExpressionType>::ColsAtCompileTime,
+      HNormalized_SizeMinusOne = HNormalized_Size==Dynamic ? Dynamic : HNormalized_Size-1
+    };
+    typedef Block<const ExpressionType,
+                  Direction==Vertical   ? int(HNormalized_SizeMinusOne)
+                                        : int(internal::traits<ExpressionType>::RowsAtCompileTime),
+                  Direction==Horizontal ? int(HNormalized_SizeMinusOne)
+                                        : int(internal::traits<ExpressionType>::ColsAtCompileTime)>
+            HNormalized_Block;
+    typedef Block<const ExpressionType,
+                  Direction==Vertical   ? 1 : int(internal::traits<ExpressionType>::RowsAtCompileTime),
+                  Direction==Horizontal ? 1 : int(internal::traits<ExpressionType>::ColsAtCompileTime)>
+            HNormalized_Factors;
+    typedef CwiseBinaryOp<internal::scalar_quotient_op<typename internal::traits<ExpressionType>::Scalar>,
+                const HNormalized_Block,
+                const Replicate<HNormalized_Factors,
+                  Direction==Vertical   ? HNormalized_SizeMinusOne : 1,
+                  Direction==Horizontal ? HNormalized_SizeMinusOne : 1> >
+            HNormalizedReturnType;
+
+    EIGEN_DEVICE_FUNC
+    const HNormalizedReturnType hnormalized() const;
+
+  protected:
+    ExpressionTypeNested m_matrix;
+};
+
+//const colwise moved to DenseBase.h due to CUDA compiler bug
+
+
+/** \returns a writable VectorwiseOp wrapper of *this providing additional partial reduction operations
+  *
+  * \sa rowwise(), class VectorwiseOp, \ref TutorialReductionsVisitorsBroadcasting
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline typename DenseBase<Derived>::ColwiseReturnType
+DenseBase<Derived>::colwise()
+{
+  return ColwiseReturnType(derived());
+}
+
+//const rowwise moved to DenseBase.h due to CUDA compiler bug
+
+
+/** \returns a writable VectorwiseOp wrapper of *this providing additional partial reduction operations
+  *
+  * \sa colwise(), class VectorwiseOp, \ref TutorialReductionsVisitorsBroadcasting
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline typename DenseBase<Derived>::RowwiseReturnType
+DenseBase<Derived>::rowwise()
+{
+  return RowwiseReturnType(derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_PARTIAL_REDUX_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Visitor.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Visitor.h
new file mode 100644
index 00000000..54c1883d
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/Visitor.h
@@ -0,0 +1,273 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_VISITOR_H
+#define EIGEN_VISITOR_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename Visitor, typename Derived, int UnrollCount>
+struct visitor_impl
+{
+  enum {
+    col = (UnrollCount-1) / Derived::RowsAtCompileTime,
+    row = (UnrollCount-1) % Derived::RowsAtCompileTime
+  };
+
+  EIGEN_DEVICE_FUNC
+  static inline void run(const Derived &mat, Visitor& visitor)
+  {
+    visitor_impl<Visitor, Derived, UnrollCount-1>::run(mat, visitor);
+    visitor(mat.coeff(row, col), row, col);
+  }
+};
+
+template<typename Visitor, typename Derived>
+struct visitor_impl<Visitor, Derived, 1>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(const Derived &mat, Visitor& visitor)
+  {
+    return visitor.init(mat.coeff(0, 0), 0, 0);
+  }
+};
+
+template<typename Visitor, typename Derived>
+struct visitor_impl<Visitor, Derived, Dynamic>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(const Derived& mat, Visitor& visitor)
+  {
+    visitor.init(mat.coeff(0,0), 0, 0);
+    for(Index i = 1; i < mat.rows(); ++i)
+      visitor(mat.coeff(i, 0), i, 0);
+    for(Index j = 1; j < mat.cols(); ++j)
+      for(Index i = 0; i < mat.rows(); ++i)
+        visitor(mat.coeff(i, j), i, j);
+  }
+};
+
+// evaluator adaptor
+template<typename XprType>
+class visitor_evaluator
+{
+public:
+  EIGEN_DEVICE_FUNC
+  explicit visitor_evaluator(const XprType &xpr) : m_evaluator(xpr), m_xpr(xpr) {}
+  
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  
+  enum {
+    RowsAtCompileTime = XprType::RowsAtCompileTime,
+    CoeffReadCost = internal::evaluator<XprType>::CoeffReadCost
+  };
+  
+  EIGEN_DEVICE_FUNC Index rows() const { return m_xpr.rows(); }
+  EIGEN_DEVICE_FUNC Index cols() const { return m_xpr.cols(); }
+  EIGEN_DEVICE_FUNC Index size() const { return m_xpr.size(); }
+
+  EIGEN_DEVICE_FUNC CoeffReturnType coeff(Index row, Index col) const
+  { return m_evaluator.coeff(row, col); }
+  
+protected:
+  internal::evaluator<XprType> m_evaluator;
+  const XprType &m_xpr;
+};
+} // end namespace internal
+
+/** Applies the visitor \a visitor to the whole coefficients of the matrix or vector.
+  *
+  * The template parameter \a Visitor is the type of the visitor and provides the following interface:
+  * \code
+  * struct MyVisitor {
+  *   // called for the first coefficient
+  *   void init(const Scalar& value, Index i, Index j);
+  *   // called for all other coefficients
+  *   void operator() (const Scalar& value, Index i, Index j);
+  * };
+  * \endcode
+  *
+  * \note compared to one or two \em for \em loops, visitors offer automatic
+  * unrolling for small fixed size matrix.
+  *
+  * \sa minCoeff(Index*,Index*), maxCoeff(Index*,Index*), DenseBase::redux()
+  */
+template<typename Derived>
+template<typename Visitor>
+EIGEN_DEVICE_FUNC
+void DenseBase<Derived>::visit(Visitor& visitor) const
+{
+  typedef typename internal::visitor_evaluator<Derived> ThisEvaluator;
+  ThisEvaluator thisEval(derived());
+  
+  enum {
+    unroll =  SizeAtCompileTime != Dynamic
+           && SizeAtCompileTime * ThisEvaluator::CoeffReadCost + (SizeAtCompileTime-1) * internal::functor_traits<Visitor>::Cost <= EIGEN_UNROLLING_LIMIT
+  };
+  return internal::visitor_impl<Visitor, ThisEvaluator, unroll ? int(SizeAtCompileTime) : Dynamic>::run(thisEval, visitor);
+}
+
+namespace internal {
+
+/** \internal
+  * \brief Base class to implement min and max visitors
+  */
+template <typename Derived>
+struct coeff_visitor
+{
+  typedef typename Derived::Scalar Scalar;
+  Index row, col;
+  Scalar res;
+  EIGEN_DEVICE_FUNC
+  inline void init(const Scalar& value, Index i, Index j)
+  {
+    res = value;
+    row = i;
+    col = j;
+  }
+};
+
+/** \internal
+  * \brief Visitor computing the min coefficient with its value and coordinates
+  *
+  * \sa DenseBase::minCoeff(Index*, Index*)
+  */
+template <typename Derived>
+struct min_coeff_visitor : coeff_visitor<Derived>
+{
+  typedef typename Derived::Scalar Scalar;
+  EIGEN_DEVICE_FUNC
+  void operator() (const Scalar& value, Index i, Index j)
+  {
+    if(value < this->res)
+    {
+      this->res = value;
+      this->row = i;
+      this->col = j;
+    }
+  }
+};
+
+template<typename Scalar>
+struct functor_traits<min_coeff_visitor<Scalar> > {
+  enum {
+    Cost = NumTraits<Scalar>::AddCost
+  };
+};
+
+/** \internal
+  * \brief Visitor computing the max coefficient with its value and coordinates
+  *
+  * \sa DenseBase::maxCoeff(Index*, Index*)
+  */
+template <typename Derived>
+struct max_coeff_visitor : coeff_visitor<Derived>
+{
+  typedef typename Derived::Scalar Scalar; 
+  EIGEN_DEVICE_FUNC
+  void operator() (const Scalar& value, Index i, Index j)
+  {
+    if(value > this->res)
+    {
+      this->res = value;
+      this->row = i;
+      this->col = j;
+    }
+  }
+};
+
+template<typename Scalar>
+struct functor_traits<max_coeff_visitor<Scalar> > {
+  enum {
+    Cost = NumTraits<Scalar>::AddCost
+  };
+};
+
+} // end namespace internal
+
+/** \fn DenseBase<Derived>::minCoeff(IndexType* rowId, IndexType* colId) const
+  * \returns the minimum of all coefficients of *this and puts in *row and *col its location.
+  * \warning the result is undefined if \c *this contains NaN.
+  *
+  * \sa DenseBase::minCoeff(Index*), DenseBase::maxCoeff(Index*,Index*), DenseBase::visit(), DenseBase::minCoeff()
+  */
+template<typename Derived>
+template<typename IndexType>
+EIGEN_DEVICE_FUNC
+typename internal::traits<Derived>::Scalar
+DenseBase<Derived>::minCoeff(IndexType* rowId, IndexType* colId) const
+{
+  internal::min_coeff_visitor<Derived> minVisitor;
+  this->visit(minVisitor);
+  *rowId = minVisitor.row;
+  if (colId) *colId = minVisitor.col;
+  return minVisitor.res;
+}
+
+/** \returns the minimum of all coefficients of *this and puts in *index its location.
+  * \warning the result is undefined if \c *this contains NaN. 
+  *
+  * \sa DenseBase::minCoeff(IndexType*,IndexType*), DenseBase::maxCoeff(IndexType*,IndexType*), DenseBase::visit(), DenseBase::minCoeff()
+  */
+template<typename Derived>
+template<typename IndexType>
+EIGEN_DEVICE_FUNC
+typename internal::traits<Derived>::Scalar
+DenseBase<Derived>::minCoeff(IndexType* index) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  internal::min_coeff_visitor<Derived> minVisitor;
+  this->visit(minVisitor);
+  *index = IndexType((RowsAtCompileTime==1) ? minVisitor.col : minVisitor.row);
+  return minVisitor.res;
+}
+
+/** \fn DenseBase<Derived>::maxCoeff(IndexType* rowId, IndexType* colId) const
+  * \returns the maximum of all coefficients of *this and puts in *row and *col its location.
+  * \warning the result is undefined if \c *this contains NaN. 
+  *
+  * \sa DenseBase::minCoeff(IndexType*,IndexType*), DenseBase::visit(), DenseBase::maxCoeff()
+  */
+template<typename Derived>
+template<typename IndexType>
+EIGEN_DEVICE_FUNC
+typename internal::traits<Derived>::Scalar
+DenseBase<Derived>::maxCoeff(IndexType* rowPtr, IndexType* colPtr) const
+{
+  internal::max_coeff_visitor<Derived> maxVisitor;
+  this->visit(maxVisitor);
+  *rowPtr = maxVisitor.row;
+  if (colPtr) *colPtr = maxVisitor.col;
+  return maxVisitor.res;
+}
+
+/** \returns the maximum of all coefficients of *this and puts in *index its location.
+  * \warning the result is undefined if \c *this contains NaN.
+  *
+  * \sa DenseBase::maxCoeff(IndexType*,IndexType*), DenseBase::minCoeff(IndexType*,IndexType*), DenseBase::visitor(), DenseBase::maxCoeff()
+  */
+template<typename Derived>
+template<typename IndexType>
+EIGEN_DEVICE_FUNC
+typename internal::traits<Derived>::Scalar
+DenseBase<Derived>::maxCoeff(IndexType* index) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  internal::max_coeff_visitor<Derived> maxVisitor;
+  this->visit(maxVisitor);
+  *index = (RowsAtCompileTime==1) ? maxVisitor.col : maxVisitor.row;
+  return maxVisitor.res;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_VISITOR_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/AVX/Complex.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/AVX/Complex.h
new file mode 100644
index 00000000..7fa61969
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/AVX/Complex.h
@@ -0,0 +1,451 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner (benoit.steiner.goog@gmail.com)
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLEX_AVX_H
+#define EIGEN_COMPLEX_AVX_H
+
+namespace Eigen {
+
+namespace internal {
+
+//---------- float ----------
+struct Packet4cf
+{
+  EIGEN_STRONG_INLINE Packet4cf() {}
+  EIGEN_STRONG_INLINE explicit Packet4cf(const __m256& a) : v(a) {}
+  __m256  v;
+};
+
+template<> struct packet_traits<std::complex<float> >  : default_packet_traits
+{
+  typedef Packet4cf type;
+  typedef Packet2cf half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket = 1,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasSetLinear = 0
+  };
+};
+
+template<> struct unpacket_traits<Packet4cf> { typedef std::complex<float> type; enum {size=4, alignment=Aligned32}; typedef Packet2cf half; };
+
+template<> EIGEN_STRONG_INLINE Packet4cf padd<Packet4cf>(const Packet4cf& a, const Packet4cf& b) { return Packet4cf(_mm256_add_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet4cf psub<Packet4cf>(const Packet4cf& a, const Packet4cf& b) { return Packet4cf(_mm256_sub_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet4cf pnegate(const Packet4cf& a)
+{
+  return Packet4cf(pnegate(a.v));
+}
+template<> EIGEN_STRONG_INLINE Packet4cf pconj(const Packet4cf& a)
+{
+  const __m256 mask = _mm256_castsi256_ps(_mm256_setr_epi32(0x00000000,0x80000000,0x00000000,0x80000000,0x00000000,0x80000000,0x00000000,0x80000000));
+  return Packet4cf(_mm256_xor_ps(a.v,mask));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cf pmul<Packet4cf>(const Packet4cf& a, const Packet4cf& b)
+{
+  __m256 tmp1 = _mm256_mul_ps(_mm256_moveldup_ps(a.v), b.v);
+  __m256 tmp2 = _mm256_mul_ps(_mm256_movehdup_ps(a.v), _mm256_permute_ps(b.v, _MM_SHUFFLE(2,3,0,1)));
+  __m256 result = _mm256_addsub_ps(tmp1, tmp2);
+  return Packet4cf(result);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cf pand   <Packet4cf>(const Packet4cf& a, const Packet4cf& b) { return Packet4cf(_mm256_and_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet4cf por    <Packet4cf>(const Packet4cf& a, const Packet4cf& b) { return Packet4cf(_mm256_or_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet4cf pxor   <Packet4cf>(const Packet4cf& a, const Packet4cf& b) { return Packet4cf(_mm256_xor_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet4cf pandnot<Packet4cf>(const Packet4cf& a, const Packet4cf& b) { return Packet4cf(_mm256_andnot_ps(a.v,b.v)); }
+
+template<> EIGEN_STRONG_INLINE Packet4cf pload <Packet4cf>(const std::complex<float>* from) { EIGEN_DEBUG_ALIGNED_LOAD return Packet4cf(pload<Packet8f>(&numext::real_ref(*from))); }
+template<> EIGEN_STRONG_INLINE Packet4cf ploadu<Packet4cf>(const std::complex<float>* from) { EIGEN_DEBUG_UNALIGNED_LOAD return Packet4cf(ploadu<Packet8f>(&numext::real_ref(*from))); }
+
+
+template<> EIGEN_STRONG_INLINE Packet4cf pset1<Packet4cf>(const std::complex<float>& from)
+{
+  return Packet4cf(_mm256_castpd_ps(_mm256_broadcast_sd((const double*)(const void*)&from)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cf ploaddup<Packet4cf>(const std::complex<float>* from)
+{
+  // FIXME The following might be optimized using _mm256_movedup_pd
+  Packet2cf a = ploaddup<Packet2cf>(from);
+  Packet2cf b = ploaddup<Packet2cf>(from+1);
+  return  Packet4cf(_mm256_insertf128_ps(_mm256_castps128_ps256(a.v), b.v, 1));
+}
+
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<float> >(std::complex<float>* to, const Packet4cf& from) { EIGEN_DEBUG_ALIGNED_STORE pstore(&numext::real_ref(*to), from.v); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<float> >(std::complex<float>* to, const Packet4cf& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu(&numext::real_ref(*to), from.v); }
+
+template<> EIGEN_DEVICE_FUNC inline Packet4cf pgather<std::complex<float>, Packet4cf>(const std::complex<float>* from, Index stride)
+{
+  return Packet4cf(_mm256_set_ps(std::imag(from[3*stride]), std::real(from[3*stride]),
+                                 std::imag(from[2*stride]), std::real(from[2*stride]),
+                                 std::imag(from[1*stride]), std::real(from[1*stride]),
+                                 std::imag(from[0*stride]), std::real(from[0*stride])));
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<float>, Packet4cf>(std::complex<float>* to, const Packet4cf& from, Index stride)
+{
+  __m128 low = _mm256_extractf128_ps(from.v, 0);
+  to[stride*0] = std::complex<float>(_mm_cvtss_f32(_mm_shuffle_ps(low, low, 0)),
+                                     _mm_cvtss_f32(_mm_shuffle_ps(low, low, 1)));
+  to[stride*1] = std::complex<float>(_mm_cvtss_f32(_mm_shuffle_ps(low, low, 2)),
+                                     _mm_cvtss_f32(_mm_shuffle_ps(low, low, 3)));
+
+  __m128 high = _mm256_extractf128_ps(from.v, 1);
+  to[stride*2] = std::complex<float>(_mm_cvtss_f32(_mm_shuffle_ps(high, high, 0)),
+                                     _mm_cvtss_f32(_mm_shuffle_ps(high, high, 1)));
+  to[stride*3] = std::complex<float>(_mm_cvtss_f32(_mm_shuffle_ps(high, high, 2)),
+                                     _mm_cvtss_f32(_mm_shuffle_ps(high, high, 3)));
+
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float>  pfirst<Packet4cf>(const Packet4cf& a)
+{
+  return pfirst(Packet2cf(_mm256_castps256_ps128(a.v)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cf preverse(const Packet4cf& a) {
+  __m128 low  = _mm256_extractf128_ps(a.v, 0);
+  __m128 high = _mm256_extractf128_ps(a.v, 1);
+  __m128d lowd  = _mm_castps_pd(low);
+  __m128d highd = _mm_castps_pd(high);
+  low  = _mm_castpd_ps(_mm_shuffle_pd(lowd,lowd,0x1));
+  high = _mm_castpd_ps(_mm_shuffle_pd(highd,highd,0x1));
+  __m256 result = _mm256_setzero_ps();
+  result = _mm256_insertf128_ps(result, low, 1);
+  result = _mm256_insertf128_ps(result, high, 0);
+  return Packet4cf(result);
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux<Packet4cf>(const Packet4cf& a)
+{
+  return predux(padd(Packet2cf(_mm256_extractf128_ps(a.v,0)),
+                     Packet2cf(_mm256_extractf128_ps(a.v,1))));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cf preduxp<Packet4cf>(const Packet4cf* vecs)
+{
+  Packet8f t0 = _mm256_shuffle_ps(vecs[0].v, vecs[0].v, _MM_SHUFFLE(3, 1, 2 ,0));
+  Packet8f t1 = _mm256_shuffle_ps(vecs[1].v, vecs[1].v, _MM_SHUFFLE(3, 1, 2 ,0));
+  t0 = _mm256_hadd_ps(t0,t1);
+  Packet8f t2 = _mm256_shuffle_ps(vecs[2].v, vecs[2].v, _MM_SHUFFLE(3, 1, 2 ,0));
+  Packet8f t3 = _mm256_shuffle_ps(vecs[3].v, vecs[3].v, _MM_SHUFFLE(3, 1, 2 ,0));
+  t2 = _mm256_hadd_ps(t2,t3);
+  
+  t1 = _mm256_permute2f128_ps(t0,t2, 0 + (2<<4));
+  t3 = _mm256_permute2f128_ps(t0,t2, 1 + (3<<4));
+
+  return Packet4cf(_mm256_add_ps(t1,t3));
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet4cf>(const Packet4cf& a)
+{
+  return predux_mul(pmul(Packet2cf(_mm256_extractf128_ps(a.v, 0)),
+                         Packet2cf(_mm256_extractf128_ps(a.v, 1))));
+}
+
+template<int Offset>
+struct palign_impl<Offset,Packet4cf>
+{
+  static EIGEN_STRONG_INLINE void run(Packet4cf& first, const Packet4cf& second)
+  {
+    if (Offset==0) return;
+    palign_impl<Offset*2,Packet8f>::run(first.v, second.v);
+  }
+};
+
+template<> struct conj_helper<Packet4cf, Packet4cf, false,true>
+{
+  EIGEN_STRONG_INLINE Packet4cf pmadd(const Packet4cf& x, const Packet4cf& y, const Packet4cf& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet4cf pmul(const Packet4cf& a, const Packet4cf& b) const
+  {
+    return internal::pmul(a, pconj(b));
+  }
+};
+
+template<> struct conj_helper<Packet4cf, Packet4cf, true,false>
+{
+  EIGEN_STRONG_INLINE Packet4cf pmadd(const Packet4cf& x, const Packet4cf& y, const Packet4cf& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet4cf pmul(const Packet4cf& a, const Packet4cf& b) const
+  {
+    return internal::pmul(pconj(a), b);
+  }
+};
+
+template<> struct conj_helper<Packet4cf, Packet4cf, true,true>
+{
+  EIGEN_STRONG_INLINE Packet4cf pmadd(const Packet4cf& x, const Packet4cf& y, const Packet4cf& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet4cf pmul(const Packet4cf& a, const Packet4cf& b) const
+  {
+    return pconj(internal::pmul(a, b));
+  }
+};
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet4cf,Packet8f)
+
+template<> EIGEN_STRONG_INLINE Packet4cf pdiv<Packet4cf>(const Packet4cf& a, const Packet4cf& b)
+{
+  Packet4cf num = pmul(a, pconj(b));
+  __m256 tmp = _mm256_mul_ps(b.v, b.v);
+  __m256 tmp2    = _mm256_shuffle_ps(tmp,tmp,0xB1);
+  __m256 denom = _mm256_add_ps(tmp, tmp2);
+  return Packet4cf(_mm256_div_ps(num.v, denom));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cf pcplxflip<Packet4cf>(const Packet4cf& x)
+{
+  return Packet4cf(_mm256_shuffle_ps(x.v, x.v, _MM_SHUFFLE(2, 3, 0 ,1)));
+}
+
+//---------- double ----------
+struct Packet2cd
+{
+  EIGEN_STRONG_INLINE Packet2cd() {}
+  EIGEN_STRONG_INLINE explicit Packet2cd(const __m256d& a) : v(a) {}
+  __m256d  v;
+};
+
+template<> struct packet_traits<std::complex<double> >  : default_packet_traits
+{
+  typedef Packet2cd type;
+  typedef Packet1cd half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 0,
+    size = 2,
+    HasHalfPacket = 1,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasSetLinear = 0
+  };
+};
+
+template<> struct unpacket_traits<Packet2cd> { typedef std::complex<double> type; enum {size=2, alignment=Aligned32}; typedef Packet1cd half; };
+
+template<> EIGEN_STRONG_INLINE Packet2cd padd<Packet2cd>(const Packet2cd& a, const Packet2cd& b) { return Packet2cd(_mm256_add_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cd psub<Packet2cd>(const Packet2cd& a, const Packet2cd& b) { return Packet2cd(_mm256_sub_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cd pnegate(const Packet2cd& a) { return Packet2cd(pnegate(a.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cd pconj(const Packet2cd& a)
+{
+  const __m256d mask = _mm256_castsi256_pd(_mm256_set_epi32(0x80000000,0x0,0x0,0x0,0x80000000,0x0,0x0,0x0));
+  return Packet2cd(_mm256_xor_pd(a.v,mask));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cd pmul<Packet2cd>(const Packet2cd& a, const Packet2cd& b)
+{
+  __m256d tmp1 = _mm256_shuffle_pd(a.v,a.v,0x0);
+  __m256d even = _mm256_mul_pd(tmp1, b.v);
+  __m256d tmp2 = _mm256_shuffle_pd(a.v,a.v,0xF);
+  __m256d tmp3 = _mm256_shuffle_pd(b.v,b.v,0x5);
+  __m256d odd  = _mm256_mul_pd(tmp2, tmp3);
+  return Packet2cd(_mm256_addsub_pd(even, odd));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cd pand   <Packet2cd>(const Packet2cd& a, const Packet2cd& b) { return Packet2cd(_mm256_and_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cd por    <Packet2cd>(const Packet2cd& a, const Packet2cd& b) { return Packet2cd(_mm256_or_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cd pxor   <Packet2cd>(const Packet2cd& a, const Packet2cd& b) { return Packet2cd(_mm256_xor_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cd pandnot<Packet2cd>(const Packet2cd& a, const Packet2cd& b) { return Packet2cd(_mm256_andnot_pd(a.v,b.v)); }
+
+template<> EIGEN_STRONG_INLINE Packet2cd pload <Packet2cd>(const std::complex<double>* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return Packet2cd(pload<Packet4d>((const double*)from)); }
+template<> EIGEN_STRONG_INLINE Packet2cd ploadu<Packet2cd>(const std::complex<double>* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cd(ploadu<Packet4d>((const double*)from)); }
+
+template<> EIGEN_STRONG_INLINE Packet2cd pset1<Packet2cd>(const std::complex<double>& from)
+{
+  // in case casting to a __m128d* is really not safe, then we can still fallback to this version: (much slower though)
+//   return Packet2cd(_mm256_loadu2_m128d((const double*)&from,(const double*)&from));
+    return Packet2cd(_mm256_broadcast_pd((const __m128d*)(const void*)&from));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cd ploaddup<Packet2cd>(const std::complex<double>* from) { return pset1<Packet2cd>(*from); }
+
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<double> >(std::complex<double> *   to, const Packet2cd& from) { EIGEN_DEBUG_ALIGNED_STORE pstore((double*)to, from.v); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<double> >(std::complex<double> *   to, const Packet2cd& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu((double*)to, from.v); }
+
+template<> EIGEN_DEVICE_FUNC inline Packet2cd pgather<std::complex<double>, Packet2cd>(const std::complex<double>* from, Index stride)
+{
+  return Packet2cd(_mm256_set_pd(std::imag(from[1*stride]), std::real(from[1*stride]),
+				 std::imag(from[0*stride]), std::real(from[0*stride])));
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<double>, Packet2cd>(std::complex<double>* to, const Packet2cd& from, Index stride)
+{
+  __m128d low = _mm256_extractf128_pd(from.v, 0);
+  to[stride*0] = std::complex<double>(_mm_cvtsd_f64(low), _mm_cvtsd_f64(_mm_shuffle_pd(low, low, 1)));
+  __m128d high = _mm256_extractf128_pd(from.v, 1);
+  to[stride*1] = std::complex<double>(_mm_cvtsd_f64(high), _mm_cvtsd_f64(_mm_shuffle_pd(high, high, 1)));
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<double> pfirst<Packet2cd>(const Packet2cd& a)
+{
+  __m128d low = _mm256_extractf128_pd(a.v, 0);
+  EIGEN_ALIGN16 double res[2];
+  _mm_store_pd(res, low);
+  return std::complex<double>(res[0],res[1]);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cd preverse(const Packet2cd& a) {
+  __m256d result = _mm256_permute2f128_pd(a.v, a.v, 1);
+  return Packet2cd(result);
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<double> predux<Packet2cd>(const Packet2cd& a)
+{
+  return predux(padd(Packet1cd(_mm256_extractf128_pd(a.v,0)),
+                     Packet1cd(_mm256_extractf128_pd(a.v,1))));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cd preduxp<Packet2cd>(const Packet2cd* vecs)
+{
+  Packet4d t0 = _mm256_permute2f128_pd(vecs[0].v,vecs[1].v, 0 + (2<<4));
+  Packet4d t1 = _mm256_permute2f128_pd(vecs[0].v,vecs[1].v, 1 + (3<<4));
+
+  return Packet2cd(_mm256_add_pd(t0,t1));
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet2cd>(const Packet2cd& a)
+{
+  return predux(pmul(Packet1cd(_mm256_extractf128_pd(a.v,0)),
+                     Packet1cd(_mm256_extractf128_pd(a.v,1))));
+}
+
+template<int Offset>
+struct palign_impl<Offset,Packet2cd>
+{
+  static EIGEN_STRONG_INLINE void run(Packet2cd& first, const Packet2cd& second)
+  {
+    if (Offset==0) return;
+    palign_impl<Offset*2,Packet4d>::run(first.v, second.v);
+  }
+};
+
+template<> struct conj_helper<Packet2cd, Packet2cd, false,true>
+{
+  EIGEN_STRONG_INLINE Packet2cd pmadd(const Packet2cd& x, const Packet2cd& y, const Packet2cd& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet2cd pmul(const Packet2cd& a, const Packet2cd& b) const
+  {
+    return internal::pmul(a, pconj(b));
+  }
+};
+
+template<> struct conj_helper<Packet2cd, Packet2cd, true,false>
+{
+  EIGEN_STRONG_INLINE Packet2cd pmadd(const Packet2cd& x, const Packet2cd& y, const Packet2cd& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet2cd pmul(const Packet2cd& a, const Packet2cd& b) const
+  {
+    return internal::pmul(pconj(a), b);
+  }
+};
+
+template<> struct conj_helper<Packet2cd, Packet2cd, true,true>
+{
+  EIGEN_STRONG_INLINE Packet2cd pmadd(const Packet2cd& x, const Packet2cd& y, const Packet2cd& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet2cd pmul(const Packet2cd& a, const Packet2cd& b) const
+  {
+    return pconj(internal::pmul(a, b));
+  }
+};
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet2cd,Packet4d)
+
+template<> EIGEN_STRONG_INLINE Packet2cd pdiv<Packet2cd>(const Packet2cd& a, const Packet2cd& b)
+{
+  Packet2cd num = pmul(a, pconj(b));
+  __m256d tmp = _mm256_mul_pd(b.v, b.v);
+  __m256d denom = _mm256_hadd_pd(tmp, tmp);
+  return Packet2cd(_mm256_div_pd(num.v, denom));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cd pcplxflip<Packet2cd>(const Packet2cd& x)
+{
+  return Packet2cd(_mm256_shuffle_pd(x.v, x.v, 0x5));
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet4cf,4>& kernel) {
+  __m256d P0 = _mm256_castps_pd(kernel.packet[0].v);
+  __m256d P1 = _mm256_castps_pd(kernel.packet[1].v);
+  __m256d P2 = _mm256_castps_pd(kernel.packet[2].v);
+  __m256d P3 = _mm256_castps_pd(kernel.packet[3].v);
+
+  __m256d T0 = _mm256_shuffle_pd(P0, P1, 15);
+  __m256d T1 = _mm256_shuffle_pd(P0, P1, 0);
+  __m256d T2 = _mm256_shuffle_pd(P2, P3, 15);
+  __m256d T3 = _mm256_shuffle_pd(P2, P3, 0);
+
+  kernel.packet[1].v = _mm256_castpd_ps(_mm256_permute2f128_pd(T0, T2, 32));
+  kernel.packet[3].v = _mm256_castpd_ps(_mm256_permute2f128_pd(T0, T2, 49));
+  kernel.packet[0].v = _mm256_castpd_ps(_mm256_permute2f128_pd(T1, T3, 32));
+  kernel.packet[2].v = _mm256_castpd_ps(_mm256_permute2f128_pd(T1, T3, 49));
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet2cd,2>& kernel) {
+  __m256d tmp = _mm256_permute2f128_pd(kernel.packet[0].v, kernel.packet[1].v, 0+(2<<4));
+  kernel.packet[1].v = _mm256_permute2f128_pd(kernel.packet[0].v, kernel.packet[1].v, 1+(3<<4));
+ kernel.packet[0].v = tmp;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cf pinsertfirst(const Packet4cf& a, std::complex<float> b)
+{
+  return Packet4cf(_mm256_blend_ps(a.v,pset1<Packet4cf>(b).v,1|2));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cd pinsertfirst(const Packet2cd& a, std::complex<double> b)
+{
+  return Packet2cd(_mm256_blend_pd(a.v,pset1<Packet2cd>(b).v,1|2));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cf pinsertlast(const Packet4cf& a, std::complex<float> b)
+{
+  return Packet4cf(_mm256_blend_ps(a.v,pset1<Packet4cf>(b).v,(1<<7)|(1<<6)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cd pinsertlast(const Packet2cd& a, std::complex<double> b)
+{
+  return Packet2cd(_mm256_blend_pd(a.v,pset1<Packet2cd>(b).v,(1<<3)|(1<<2)));
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_COMPLEX_AVX_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/AVX/MathFunctions.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/AVX/MathFunctions.h
new file mode 100644
index 00000000..6af67ce2
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/AVX/MathFunctions.h
@@ -0,0 +1,439 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Pedro Gonnet (pedro.gonnet@gmail.com)
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATH_FUNCTIONS_AVX_H
+#define EIGEN_MATH_FUNCTIONS_AVX_H
+
+/* The sin, cos, exp, and log functions of this file are loosely derived from
+ * Julien Pommier's sse math library: http://gruntthepeon.free.fr/ssemath/
+ */
+
+namespace Eigen {
+
+namespace internal {
+
+inline Packet8i pshiftleft(Packet8i v, int n)
+{
+#ifdef EIGEN_VECTORIZE_AVX2
+  return _mm256_slli_epi32(v, n);
+#else
+  __m128i lo = _mm_slli_epi32(_mm256_extractf128_si256(v, 0), n);
+  __m128i hi = _mm_slli_epi32(_mm256_extractf128_si256(v, 1), n);
+  return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
+#endif
+}
+
+inline Packet8f pshiftright(Packet8f v, int n)
+{
+#ifdef EIGEN_VECTORIZE_AVX2
+  return _mm256_cvtepi32_ps(_mm256_srli_epi32(_mm256_castps_si256(v), n));
+#else
+  __m128i lo = _mm_srli_epi32(_mm256_extractf128_si256(_mm256_castps_si256(v), 0), n);
+  __m128i hi = _mm_srli_epi32(_mm256_extractf128_si256(_mm256_castps_si256(v), 1), n);
+  return _mm256_cvtepi32_ps(_mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1));
+#endif
+}
+
+// Sine function
+// Computes sin(x) by wrapping x to the interval [-Pi/4,3*Pi/4] and
+// evaluating interpolants in [-Pi/4,Pi/4] or [Pi/4,3*Pi/4]. The interpolants
+// are (anti-)symmetric and thus have only odd/even coefficients
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f
+psin<Packet8f>(const Packet8f& _x) {
+  Packet8f x = _x;
+
+  // Some useful values.
+  _EIGEN_DECLARE_CONST_Packet8i(one, 1);
+  _EIGEN_DECLARE_CONST_Packet8f(one, 1.0f);
+  _EIGEN_DECLARE_CONST_Packet8f(two, 2.0f);
+  _EIGEN_DECLARE_CONST_Packet8f(one_over_four, 0.25f);
+  _EIGEN_DECLARE_CONST_Packet8f(one_over_pi, 3.183098861837907e-01f);
+  _EIGEN_DECLARE_CONST_Packet8f(neg_pi_first, -3.140625000000000e+00f);
+  _EIGEN_DECLARE_CONST_Packet8f(neg_pi_second, -9.670257568359375e-04f);
+  _EIGEN_DECLARE_CONST_Packet8f(neg_pi_third, -6.278329571784980e-07f);
+  _EIGEN_DECLARE_CONST_Packet8f(four_over_pi, 1.273239544735163e+00f);
+
+  // Map x from [-Pi/4,3*Pi/4] to z in [-1,3] and subtract the shifted period.
+  Packet8f z = pmul(x, p8f_one_over_pi);
+  Packet8f shift = _mm256_floor_ps(padd(z, p8f_one_over_four));
+  x = pmadd(shift, p8f_neg_pi_first, x);
+  x = pmadd(shift, p8f_neg_pi_second, x);
+  x = pmadd(shift, p8f_neg_pi_third, x);
+  z = pmul(x, p8f_four_over_pi);
+
+  // Make a mask for the entries that need flipping, i.e. wherever the shift
+  // is odd.
+  Packet8i shift_ints = _mm256_cvtps_epi32(shift);
+  Packet8i shift_isodd = _mm256_castps_si256(_mm256_and_ps(_mm256_castsi256_ps(shift_ints), _mm256_castsi256_ps(p8i_one)));
+  Packet8i sign_flip_mask = pshiftleft(shift_isodd, 31);
+
+  // Create a mask for which interpolant to use, i.e. if z > 1, then the mask
+  // is set to ones for that entry.
+  Packet8f ival_mask = _mm256_cmp_ps(z, p8f_one, _CMP_GT_OQ);
+
+  // Evaluate the polynomial for the interval [1,3] in z.
+  _EIGEN_DECLARE_CONST_Packet8f(coeff_right_0, 9.999999724233232e-01f);
+  _EIGEN_DECLARE_CONST_Packet8f(coeff_right_2, -3.084242535619928e-01f);
+  _EIGEN_DECLARE_CONST_Packet8f(coeff_right_4, 1.584991525700324e-02f);
+  _EIGEN_DECLARE_CONST_Packet8f(coeff_right_6, -3.188805084631342e-04f);
+  Packet8f z_minus_two = psub(z, p8f_two);
+  Packet8f z_minus_two2 = pmul(z_minus_two, z_minus_two);
+  Packet8f right = pmadd(p8f_coeff_right_6, z_minus_two2, p8f_coeff_right_4);
+  right = pmadd(right, z_minus_two2, p8f_coeff_right_2);
+  right = pmadd(right, z_minus_two2, p8f_coeff_right_0);
+
+  // Evaluate the polynomial for the interval [-1,1] in z.
+  _EIGEN_DECLARE_CONST_Packet8f(coeff_left_1, 7.853981525427295e-01f);
+  _EIGEN_DECLARE_CONST_Packet8f(coeff_left_3, -8.074536727092352e-02f);
+  _EIGEN_DECLARE_CONST_Packet8f(coeff_left_5, 2.489871967827018e-03f);
+  _EIGEN_DECLARE_CONST_Packet8f(coeff_left_7, -3.587725841214251e-05f);
+  Packet8f z2 = pmul(z, z);
+  Packet8f left = pmadd(p8f_coeff_left_7, z2, p8f_coeff_left_5);
+  left = pmadd(left, z2, p8f_coeff_left_3);
+  left = pmadd(left, z2, p8f_coeff_left_1);
+  left = pmul(left, z);
+
+  // Assemble the results, i.e. select the left and right polynomials.
+  left = _mm256_andnot_ps(ival_mask, left);
+  right = _mm256_and_ps(ival_mask, right);
+  Packet8f res = _mm256_or_ps(left, right);
+
+  // Flip the sign on the odd intervals and return the result.
+  res = _mm256_xor_ps(res, _mm256_castsi256_ps(sign_flip_mask));
+  return res;
+}
+
+// Natural logarithm
+// Computes log(x) as log(2^e * m) = C*e + log(m), where the constant C =log(2)
+// and m is in the range [sqrt(1/2),sqrt(2)). In this range, the logarithm can
+// be easily approximated by a polynomial centered on m=1 for stability.
+// TODO(gonnet): Further reduce the interval allowing for lower-degree
+//               polynomial interpolants -> ... -> profit!
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f
+plog<Packet8f>(const Packet8f& _x) {
+  Packet8f x = _x;
+  _EIGEN_DECLARE_CONST_Packet8f(1, 1.0f);
+  _EIGEN_DECLARE_CONST_Packet8f(half, 0.5f);
+  _EIGEN_DECLARE_CONST_Packet8f(126f, 126.0f);
+
+  _EIGEN_DECLARE_CONST_Packet8f_FROM_INT(inv_mant_mask, ~0x7f800000);
+
+  // The smallest non denormalized float number.
+  _EIGEN_DECLARE_CONST_Packet8f_FROM_INT(min_norm_pos, 0x00800000);
+  _EIGEN_DECLARE_CONST_Packet8f_FROM_INT(minus_inf, 0xff800000);
+
+  // Polynomial coefficients.
+  _EIGEN_DECLARE_CONST_Packet8f(cephes_SQRTHF, 0.707106781186547524f);
+  _EIGEN_DECLARE_CONST_Packet8f(cephes_log_p0, 7.0376836292E-2f);
+  _EIGEN_DECLARE_CONST_Packet8f(cephes_log_p1, -1.1514610310E-1f);
+  _EIGEN_DECLARE_CONST_Packet8f(cephes_log_p2, 1.1676998740E-1f);
+  _EIGEN_DECLARE_CONST_Packet8f(cephes_log_p3, -1.2420140846E-1f);
+  _EIGEN_DECLARE_CONST_Packet8f(cephes_log_p4, +1.4249322787E-1f);
+  _EIGEN_DECLARE_CONST_Packet8f(cephes_log_p5, -1.6668057665E-1f);
+  _EIGEN_DECLARE_CONST_Packet8f(cephes_log_p6, +2.0000714765E-1f);
+  _EIGEN_DECLARE_CONST_Packet8f(cephes_log_p7, -2.4999993993E-1f);
+  _EIGEN_DECLARE_CONST_Packet8f(cephes_log_p8, +3.3333331174E-1f);
+  _EIGEN_DECLARE_CONST_Packet8f(cephes_log_q1, -2.12194440e-4f);
+  _EIGEN_DECLARE_CONST_Packet8f(cephes_log_q2, 0.693359375f);
+
+  Packet8f invalid_mask = _mm256_cmp_ps(x, _mm256_setzero_ps(), _CMP_NGE_UQ); // not greater equal is true if x is NaN
+  Packet8f iszero_mask = _mm256_cmp_ps(x, _mm256_setzero_ps(), _CMP_EQ_OQ);
+
+  // Truncate input values to the minimum positive normal.
+  x = pmax(x, p8f_min_norm_pos);
+
+  Packet8f emm0 = pshiftright(x,23);
+  Packet8f e = _mm256_sub_ps(emm0, p8f_126f);
+
+  // Set the exponents to -1, i.e. x are in the range [0.5,1).
+  x = _mm256_and_ps(x, p8f_inv_mant_mask);
+  x = _mm256_or_ps(x, p8f_half);
+
+  // part2: Shift the inputs from the range [0.5,1) to [sqrt(1/2),sqrt(2))
+  // and shift by -1. The values are then centered around 0, which improves
+  // the stability of the polynomial evaluation.
+  //   if( x < SQRTHF ) {
+  //     e -= 1;
+  //     x = x + x - 1.0;
+  //   } else { x = x - 1.0; }
+  Packet8f mask = _mm256_cmp_ps(x, p8f_cephes_SQRTHF, _CMP_LT_OQ);
+  Packet8f tmp = _mm256_and_ps(x, mask);
+  x = psub(x, p8f_1);
+  e = psub(e, _mm256_and_ps(p8f_1, mask));
+  x = padd(x, tmp);
+
+  Packet8f x2 = pmul(x, x);
+  Packet8f x3 = pmul(x2, x);
+
+  // Evaluate the polynomial approximant of degree 8 in three parts, probably
+  // to improve instruction-level parallelism.
+  Packet8f y, y1, y2;
+  y = pmadd(p8f_cephes_log_p0, x, p8f_cephes_log_p1);
+  y1 = pmadd(p8f_cephes_log_p3, x, p8f_cephes_log_p4);
+  y2 = pmadd(p8f_cephes_log_p6, x, p8f_cephes_log_p7);
+  y = pmadd(y, x, p8f_cephes_log_p2);
+  y1 = pmadd(y1, x, p8f_cephes_log_p5);
+  y2 = pmadd(y2, x, p8f_cephes_log_p8);
+  y = pmadd(y, x3, y1);
+  y = pmadd(y, x3, y2);
+  y = pmul(y, x3);
+
+  // Add the logarithm of the exponent back to the result of the interpolation.
+  y1 = pmul(e, p8f_cephes_log_q1);
+  tmp = pmul(x2, p8f_half);
+  y = padd(y, y1);
+  x = psub(x, tmp);
+  y2 = pmul(e, p8f_cephes_log_q2);
+  x = padd(x, y);
+  x = padd(x, y2);
+
+  // Filter out invalid inputs, i.e. negative arg will be NAN, 0 will be -INF.
+  return _mm256_or_ps(
+      _mm256_andnot_ps(iszero_mask, _mm256_or_ps(x, invalid_mask)),
+      _mm256_and_ps(iszero_mask, p8f_minus_inf));
+}
+
+// Exponential function. Works by writing "x = m*log(2) + r" where
+// "m = floor(x/log(2)+1/2)" and "r" is the remainder. The result is then
+// "exp(x) = 2^m*exp(r)" where exp(r) is in the range [-1,1).
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f
+pexp<Packet8f>(const Packet8f& _x) {
+  _EIGEN_DECLARE_CONST_Packet8f(1, 1.0f);
+  _EIGEN_DECLARE_CONST_Packet8f(half, 0.5f);
+  _EIGEN_DECLARE_CONST_Packet8f(127, 127.0f);
+
+  _EIGEN_DECLARE_CONST_Packet8f(exp_hi, 88.3762626647950f);
+  _EIGEN_DECLARE_CONST_Packet8f(exp_lo, -88.3762626647949f);
+
+  _EIGEN_DECLARE_CONST_Packet8f(cephes_LOG2EF, 1.44269504088896341f);
+
+  _EIGEN_DECLARE_CONST_Packet8f(cephes_exp_p0, 1.9875691500E-4f);
+  _EIGEN_DECLARE_CONST_Packet8f(cephes_exp_p1, 1.3981999507E-3f);
+  _EIGEN_DECLARE_CONST_Packet8f(cephes_exp_p2, 8.3334519073E-3f);
+  _EIGEN_DECLARE_CONST_Packet8f(cephes_exp_p3, 4.1665795894E-2f);
+  _EIGEN_DECLARE_CONST_Packet8f(cephes_exp_p4, 1.6666665459E-1f);
+  _EIGEN_DECLARE_CONST_Packet8f(cephes_exp_p5, 5.0000001201E-1f);
+
+  // Clamp x.
+  Packet8f x = pmax(pmin(_x, p8f_exp_hi), p8f_exp_lo);
+
+  // Express exp(x) as exp(m*ln(2) + r), start by extracting
+  // m = floor(x/ln(2) + 0.5).
+  Packet8f m = _mm256_floor_ps(pmadd(x, p8f_cephes_LOG2EF, p8f_half));
+
+// Get r = x - m*ln(2). If no FMA instructions are available, m*ln(2) is
+// subtracted out in two parts, m*C1+m*C2 = m*ln(2), to avoid accumulating
+// truncation errors. Note that we don't use the "pmadd" function here to
+// ensure that a precision-preserving FMA instruction is used.
+#ifdef EIGEN_VECTORIZE_FMA
+  _EIGEN_DECLARE_CONST_Packet8f(nln2, -0.6931471805599453f);
+  Packet8f r = _mm256_fmadd_ps(m, p8f_nln2, x);
+#else
+  _EIGEN_DECLARE_CONST_Packet8f(cephes_exp_C1, 0.693359375f);
+  _EIGEN_DECLARE_CONST_Packet8f(cephes_exp_C2, -2.12194440e-4f);
+  Packet8f r = psub(x, pmul(m, p8f_cephes_exp_C1));
+  r = psub(r, pmul(m, p8f_cephes_exp_C2));
+#endif
+
+  Packet8f r2 = pmul(r, r);
+
+  // TODO(gonnet): Split into odd/even polynomials and try to exploit
+  //               instruction-level parallelism.
+  Packet8f y = p8f_cephes_exp_p0;
+  y = pmadd(y, r, p8f_cephes_exp_p1);
+  y = pmadd(y, r, p8f_cephes_exp_p2);
+  y = pmadd(y, r, p8f_cephes_exp_p3);
+  y = pmadd(y, r, p8f_cephes_exp_p4);
+  y = pmadd(y, r, p8f_cephes_exp_p5);
+  y = pmadd(y, r2, r);
+  y = padd(y, p8f_1);
+
+  // Build emm0 = 2^m.
+  Packet8i emm0 = _mm256_cvttps_epi32(padd(m, p8f_127));
+  emm0 = pshiftleft(emm0, 23);
+
+  // Return 2^m * exp(r).
+  return pmax(pmul(y, _mm256_castsi256_ps(emm0)), _x);
+}
+
+// Hyperbolic Tangent function.
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f
+ptanh<Packet8f>(const Packet8f& x) {
+  return internal::generic_fast_tanh_float(x);
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4d
+pexp<Packet4d>(const Packet4d& _x) {
+  Packet4d x = _x;
+
+  _EIGEN_DECLARE_CONST_Packet4d(1, 1.0);
+  _EIGEN_DECLARE_CONST_Packet4d(2, 2.0);
+  _EIGEN_DECLARE_CONST_Packet4d(half, 0.5);
+
+  _EIGEN_DECLARE_CONST_Packet4d(exp_hi, 709.437);
+  _EIGEN_DECLARE_CONST_Packet4d(exp_lo, -709.436139303);
+
+  _EIGEN_DECLARE_CONST_Packet4d(cephes_LOG2EF, 1.4426950408889634073599);
+
+  _EIGEN_DECLARE_CONST_Packet4d(cephes_exp_p0, 1.26177193074810590878e-4);
+  _EIGEN_DECLARE_CONST_Packet4d(cephes_exp_p1, 3.02994407707441961300e-2);
+  _EIGEN_DECLARE_CONST_Packet4d(cephes_exp_p2, 9.99999999999999999910e-1);
+
+  _EIGEN_DECLARE_CONST_Packet4d(cephes_exp_q0, 3.00198505138664455042e-6);
+  _EIGEN_DECLARE_CONST_Packet4d(cephes_exp_q1, 2.52448340349684104192e-3);
+  _EIGEN_DECLARE_CONST_Packet4d(cephes_exp_q2, 2.27265548208155028766e-1);
+  _EIGEN_DECLARE_CONST_Packet4d(cephes_exp_q3, 2.00000000000000000009e0);
+
+  _EIGEN_DECLARE_CONST_Packet4d(cephes_exp_C1, 0.693145751953125);
+  _EIGEN_DECLARE_CONST_Packet4d(cephes_exp_C2, 1.42860682030941723212e-6);
+  _EIGEN_DECLARE_CONST_Packet4i(1023, 1023);
+
+  Packet4d tmp, fx;
+
+  // clamp x
+  x = pmax(pmin(x, p4d_exp_hi), p4d_exp_lo);
+  // Express exp(x) as exp(g + n*log(2)).
+  fx = pmadd(p4d_cephes_LOG2EF, x, p4d_half);
+
+  // Get the integer modulus of log(2), i.e. the "n" described above.
+  fx = _mm256_floor_pd(fx);
+
+  // Get the remainder modulo log(2), i.e. the "g" described above. Subtract
+  // n*log(2) out in two steps, i.e. n*C1 + n*C2, C1+C2=log2 to get the last
+  // digits right.
+  tmp = pmul(fx, p4d_cephes_exp_C1);
+  Packet4d z = pmul(fx, p4d_cephes_exp_C2);
+  x = psub(x, tmp);
+  x = psub(x, z);
+
+  Packet4d x2 = pmul(x, x);
+
+  // Evaluate the numerator polynomial of the rational interpolant.
+  Packet4d px = p4d_cephes_exp_p0;
+  px = pmadd(px, x2, p4d_cephes_exp_p1);
+  px = pmadd(px, x2, p4d_cephes_exp_p2);
+  px = pmul(px, x);
+
+  // Evaluate the denominator polynomial of the rational interpolant.
+  Packet4d qx = p4d_cephes_exp_q0;
+  qx = pmadd(qx, x2, p4d_cephes_exp_q1);
+  qx = pmadd(qx, x2, p4d_cephes_exp_q2);
+  qx = pmadd(qx, x2, p4d_cephes_exp_q3);
+
+  // I don't really get this bit, copied from the SSE2 routines, so...
+  // TODO(gonnet): Figure out what is going on here, perhaps find a better
+  // rational interpolant?
+  x = _mm256_div_pd(px, psub(qx, px));
+  x = pmadd(p4d_2, x, p4d_1);
+
+  // Build e=2^n by constructing the exponents in a 128-bit vector and
+  // shifting them to where they belong in double-precision values.
+  __m128i emm0 = _mm256_cvtpd_epi32(fx);
+  emm0 = _mm_add_epi32(emm0, p4i_1023);
+  emm0 = _mm_shuffle_epi32(emm0, _MM_SHUFFLE(3, 1, 2, 0));
+  __m128i lo = _mm_slli_epi64(emm0, 52);
+  __m128i hi = _mm_slli_epi64(_mm_srli_epi64(emm0, 32), 52);
+  __m256i e = _mm256_insertf128_si256(_mm256_setzero_si256(), lo, 0);
+  e = _mm256_insertf128_si256(e, hi, 1);
+
+  // Construct the result 2^n * exp(g) = e * x. The max is used to catch
+  // non-finite values in the input.
+  return pmax(pmul(x, _mm256_castsi256_pd(e)), _x);
+}
+
+// Functions for sqrt.
+// The EIGEN_FAST_MATH version uses the _mm_rsqrt_ps approximation and one step
+// of Newton's method, at a cost of 1-2 bits of precision as opposed to the
+// exact solution. It does not handle +inf, or denormalized numbers correctly.
+// The main advantage of this approach is not just speed, but also the fact that
+// it can be inlined and pipelined with other computations, further reducing its
+// effective latency. This is similar to Quake3's fast inverse square root.
+// For detail see here: http://www.beyond3d.com/content/articles/8/
+#if EIGEN_FAST_MATH
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f
+psqrt<Packet8f>(const Packet8f& _x) {
+  Packet8f half = pmul(_x, pset1<Packet8f>(.5f));
+  Packet8f denormal_mask = _mm256_and_ps(
+      _mm256_cmp_ps(_x, pset1<Packet8f>((std::numeric_limits<float>::min)()),
+                    _CMP_LT_OQ),
+      _mm256_cmp_ps(_x, _mm256_setzero_ps(), _CMP_GE_OQ));
+
+  // Compute approximate reciprocal sqrt.
+  Packet8f x = _mm256_rsqrt_ps(_x);
+  // Do a single step of Newton's iteration.
+  x = pmul(x, psub(pset1<Packet8f>(1.5f), pmul(half, pmul(x,x))));
+  // Flush results for denormals to zero.
+  return _mm256_andnot_ps(denormal_mask, pmul(_x,x));
+}
+#else
+template <> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet8f psqrt<Packet8f>(const Packet8f& x) {
+  return _mm256_sqrt_ps(x);
+}
+#endif
+template <> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4d psqrt<Packet4d>(const Packet4d& x) {
+  return _mm256_sqrt_pd(x);
+}
+#if EIGEN_FAST_MATH
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet8f prsqrt<Packet8f>(const Packet8f& _x) {
+  _EIGEN_DECLARE_CONST_Packet8f_FROM_INT(inf, 0x7f800000);
+  _EIGEN_DECLARE_CONST_Packet8f_FROM_INT(nan, 0x7fc00000);
+  _EIGEN_DECLARE_CONST_Packet8f(one_point_five, 1.5f);
+  _EIGEN_DECLARE_CONST_Packet8f(minus_half, -0.5f);
+  _EIGEN_DECLARE_CONST_Packet8f_FROM_INT(flt_min, 0x00800000);
+
+  Packet8f neg_half = pmul(_x, p8f_minus_half);
+
+  // select only the inverse sqrt of positive normal inputs (denormals are
+  // flushed to zero and cause infs as well).
+  Packet8f le_zero_mask = _mm256_cmp_ps(_x, p8f_flt_min, _CMP_LT_OQ);
+  Packet8f x = _mm256_andnot_ps(le_zero_mask, _mm256_rsqrt_ps(_x));
+
+  // Fill in NaNs and Infs for the negative/zero entries.
+  Packet8f neg_mask = _mm256_cmp_ps(_x, _mm256_setzero_ps(), _CMP_LT_OQ);
+  Packet8f zero_mask = _mm256_andnot_ps(neg_mask, le_zero_mask);
+  Packet8f infs_and_nans = _mm256_or_ps(_mm256_and_ps(neg_mask, p8f_nan),
+                                        _mm256_and_ps(zero_mask, p8f_inf));
+
+  // Do a single step of Newton's iteration.
+  x = pmul(x, pmadd(neg_half, pmul(x, x), p8f_one_point_five));
+
+  // Insert NaNs and Infs in all the right places.
+  return _mm256_or_ps(x, infs_and_nans);
+}
+
+#else
+template <> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet8f prsqrt<Packet8f>(const Packet8f& x) {
+  _EIGEN_DECLARE_CONST_Packet8f(one, 1.0f);
+  return _mm256_div_ps(p8f_one, _mm256_sqrt_ps(x));
+}
+#endif
+
+template <> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4d prsqrt<Packet4d>(const Packet4d& x) {
+  _EIGEN_DECLARE_CONST_Packet4d(one, 1.0);
+  return _mm256_div_pd(p4d_one, _mm256_sqrt_pd(x));
+}
+
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_MATH_FUNCTIONS_AVX_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/AVX/PacketMath.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/AVX/PacketMath.h
new file mode 100644
index 00000000..63623094
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/AVX/PacketMath.h
@@ -0,0 +1,643 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner (benoit.steiner.goog@gmail.com)
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PACKET_MATH_AVX_H
+#define EIGEN_PACKET_MATH_AVX_H
+
+namespace Eigen {
+
+namespace internal {
+
+#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
+#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8
+#endif
+
+#ifndef EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS
+#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS (2*sizeof(void*))
+#endif
+
+#ifdef __FMA__
+#ifndef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#define EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#endif
+#endif
+
+typedef __m256  Packet8f;
+typedef __m256i Packet8i;
+typedef __m256d Packet4d;
+
+template<> struct is_arithmetic<__m256>  { enum { value = true }; };
+template<> struct is_arithmetic<__m256i> { enum { value = true }; };
+template<> struct is_arithmetic<__m256d> { enum { value = true }; };
+
+#define _EIGEN_DECLARE_CONST_Packet8f(NAME,X) \
+  const Packet8f p8f_##NAME = pset1<Packet8f>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet4d(NAME,X) \
+  const Packet4d p4d_##NAME = pset1<Packet4d>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet8f_FROM_INT(NAME,X) \
+  const Packet8f p8f_##NAME = _mm256_castsi256_ps(pset1<Packet8i>(X))
+
+#define _EIGEN_DECLARE_CONST_Packet8i(NAME,X) \
+  const Packet8i p8i_##NAME = pset1<Packet8i>(X)
+
+// Use the packet_traits defined in AVX512/PacketMath.h instead if we're going
+// to leverage AVX512 instructions.
+#ifndef EIGEN_VECTORIZE_AVX512
+template<> struct packet_traits<float>  : default_packet_traits
+{
+  typedef Packet8f type;
+  typedef Packet4f half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=8,
+    HasHalfPacket = 1,
+
+    HasDiv  = 1,
+    HasSin  = EIGEN_FAST_MATH,
+    HasCos  = 0,
+    HasLog  = 1,
+    HasExp  = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasTanh  = EIGEN_FAST_MATH,
+    HasBlend = 1,
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1
+  };
+};
+template<> struct packet_traits<double> : default_packet_traits
+{
+  typedef Packet4d type;
+  typedef Packet2d half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=4,
+    HasHalfPacket = 1,
+
+    HasDiv  = 1,
+    HasExp  = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasBlend = 1,
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1
+  };
+};
+#endif
+
+template<> struct scalar_div_cost<float,true> { enum { value = 14 }; };
+template<> struct scalar_div_cost<double,true> { enum { value = 16 }; };
+
+/* Proper support for integers is only provided by AVX2. In the meantime, we'll
+   use SSE instructions and packets to deal with integers.
+template<> struct packet_traits<int>    : default_packet_traits
+{
+  typedef Packet8i type;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=8
+  };
+};
+*/
+
+template<> struct unpacket_traits<Packet8f> { typedef float  type; typedef Packet4f half; enum {size=8, alignment=Aligned32}; };
+template<> struct unpacket_traits<Packet4d> { typedef double type; typedef Packet2d half; enum {size=4, alignment=Aligned32}; };
+template<> struct unpacket_traits<Packet8i> { typedef int    type; typedef Packet4i half; enum {size=8, alignment=Aligned32}; };
+
+template<> EIGEN_STRONG_INLINE Packet8f pset1<Packet8f>(const float&  from) { return _mm256_set1_ps(from); }
+template<> EIGEN_STRONG_INLINE Packet4d pset1<Packet4d>(const double& from) { return _mm256_set1_pd(from); }
+template<> EIGEN_STRONG_INLINE Packet8i pset1<Packet8i>(const int&    from) { return _mm256_set1_epi32(from); }
+
+template<> EIGEN_STRONG_INLINE Packet8f pload1<Packet8f>(const float*  from) { return _mm256_broadcast_ss(from); }
+template<> EIGEN_STRONG_INLINE Packet4d pload1<Packet4d>(const double* from) { return _mm256_broadcast_sd(from); }
+
+template<> EIGEN_STRONG_INLINE Packet8f plset<Packet8f>(const float& a) { return _mm256_add_ps(_mm256_set1_ps(a), _mm256_set_ps(7.0,6.0,5.0,4.0,3.0,2.0,1.0,0.0)); }
+template<> EIGEN_STRONG_INLINE Packet4d plset<Packet4d>(const double& a) { return _mm256_add_pd(_mm256_set1_pd(a), _mm256_set_pd(3.0,2.0,1.0,0.0)); }
+
+template<> EIGEN_STRONG_INLINE Packet8f padd<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_add_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4d padd<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_add_pd(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet8f psub<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_sub_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4d psub<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_sub_pd(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet8f pnegate(const Packet8f& a)
+{
+  return _mm256_sub_ps(_mm256_set1_ps(0.0),a);
+}
+template<> EIGEN_STRONG_INLINE Packet4d pnegate(const Packet4d& a)
+{
+  return _mm256_sub_pd(_mm256_set1_pd(0.0),a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pconj(const Packet8f& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4d pconj(const Packet4d& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet8i pconj(const Packet8i& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet8f pmul<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_mul_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4d pmul<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_mul_pd(a,b); }
+
+
+template<> EIGEN_STRONG_INLINE Packet8f pdiv<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_div_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4d pdiv<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_div_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8i pdiv<Packet8i>(const Packet8i& /*a*/, const Packet8i& /*b*/)
+{ eigen_assert(false && "packet integer division are not supported by AVX");
+  return pset1<Packet8i>(0);
+}
+
+#ifdef __FMA__
+template<> EIGEN_STRONG_INLINE Packet8f pmadd(const Packet8f& a, const Packet8f& b, const Packet8f& c) {
+#if ( EIGEN_COMP_GNUC_STRICT || (EIGEN_COMP_CLANG && (EIGEN_COMP_CLANG<308)) )
+  // clang stupidly generates a vfmadd213ps instruction plus some vmovaps on registers,
+  // and gcc stupidly generates a vfmadd132ps instruction,
+  // so let's enforce it to generate a vfmadd231ps instruction since the most common use case is to accumulate
+  // the result of the product.
+  Packet8f res = c;
+  __asm__("vfmadd231ps %[a], %[b], %[c]" : [c] "+x" (res) : [a] "x" (a), [b] "x" (b));
+  return res;
+#else
+  return _mm256_fmadd_ps(a,b,c);
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet4d pmadd(const Packet4d& a, const Packet4d& b, const Packet4d& c) {
+#if ( EIGEN_COMP_GNUC_STRICT || (EIGEN_COMP_CLANG && (EIGEN_COMP_CLANG<308)) )
+  // see above
+  Packet4d res = c;
+  __asm__("vfmadd231pd %[a], %[b], %[c]" : [c] "+x" (res) : [a] "x" (a), [b] "x" (b));
+  return res;
+#else
+  return _mm256_fmadd_pd(a,b,c);
+#endif
+}
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet8f pmin<Packet8f>(const Packet8f& a, const Packet8f& b) {
+  // Arguments are swapped to match NaN propagation behavior of std::min.
+  return _mm256_min_ps(b,a);
+}
+template<> EIGEN_STRONG_INLINE Packet4d pmin<Packet4d>(const Packet4d& a, const Packet4d& b) {
+  // Arguments are swapped to match NaN propagation behavior of std::min.
+  return _mm256_min_pd(b,a);
+}
+template<> EIGEN_STRONG_INLINE Packet8f pmax<Packet8f>(const Packet8f& a, const Packet8f& b) {
+  // Arguments are swapped to match NaN propagation behavior of std::max.
+  return _mm256_max_ps(b,a);
+}
+template<> EIGEN_STRONG_INLINE Packet4d pmax<Packet4d>(const Packet4d& a, const Packet4d& b) {
+  // Arguments are swapped to match NaN propagation behavior of std::max.
+  return _mm256_max_pd(b,a);
+}
+template<> EIGEN_STRONG_INLINE Packet8f pround<Packet8f>(const Packet8f& a) { return _mm256_round_ps(a, _MM_FROUND_CUR_DIRECTION); }
+template<> EIGEN_STRONG_INLINE Packet4d pround<Packet4d>(const Packet4d& a) { return _mm256_round_pd(a, _MM_FROUND_CUR_DIRECTION); }
+
+template<> EIGEN_STRONG_INLINE Packet8f pceil<Packet8f>(const Packet8f& a) { return _mm256_ceil_ps(a); }
+template<> EIGEN_STRONG_INLINE Packet4d pceil<Packet4d>(const Packet4d& a) { return _mm256_ceil_pd(a); }
+
+template<> EIGEN_STRONG_INLINE Packet8f pfloor<Packet8f>(const Packet8f& a) { return _mm256_floor_ps(a); }
+template<> EIGEN_STRONG_INLINE Packet4d pfloor<Packet4d>(const Packet4d& a) { return _mm256_floor_pd(a); }
+
+template<> EIGEN_STRONG_INLINE Packet8f pand<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_and_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4d pand<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_and_pd(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet8f por<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_or_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4d por<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_or_pd(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet8f pxor<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_xor_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4d pxor<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_xor_pd(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet8f pandnot<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_andnot_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4d pandnot<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_andnot_pd(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet8f pload<Packet8f>(const float*   from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm256_load_ps(from); }
+template<> EIGEN_STRONG_INLINE Packet4d pload<Packet4d>(const double*  from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm256_load_pd(from); }
+template<> EIGEN_STRONG_INLINE Packet8i pload<Packet8i>(const int*     from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm256_load_si256(reinterpret_cast<const __m256i*>(from)); }
+
+template<> EIGEN_STRONG_INLINE Packet8f ploadu<Packet8f>(const float* from) { EIGEN_DEBUG_UNALIGNED_LOAD return _mm256_loadu_ps(from); }
+template<> EIGEN_STRONG_INLINE Packet4d ploadu<Packet4d>(const double* from) { EIGEN_DEBUG_UNALIGNED_LOAD return _mm256_loadu_pd(from); }
+template<> EIGEN_STRONG_INLINE Packet8i ploadu<Packet8i>(const int* from) { EIGEN_DEBUG_UNALIGNED_LOAD return _mm256_loadu_si256(reinterpret_cast<const __m256i*>(from)); }
+
+// Loads 4 floats from memory a returns the packet {a0, a0  a1, a1, a2, a2, a3, a3}
+template<> EIGEN_STRONG_INLINE Packet8f ploaddup<Packet8f>(const float* from)
+{
+  // TODO try to find a way to avoid the need of a temporary register
+//   Packet8f tmp  = _mm256_castps128_ps256(_mm_loadu_ps(from));
+//   tmp = _mm256_insertf128_ps(tmp, _mm_movehl_ps(_mm256_castps256_ps128(tmp),_mm256_castps256_ps128(tmp)), 1);
+//   return _mm256_unpacklo_ps(tmp,tmp);
+
+  // _mm256_insertf128_ps is very slow on Haswell, thus:
+  Packet8f tmp = _mm256_broadcast_ps((const __m128*)(const void*)from);
+  // mimic an "inplace" permutation of the lower 128bits using a blend
+  tmp = _mm256_blend_ps(tmp,_mm256_castps128_ps256(_mm_permute_ps( _mm256_castps256_ps128(tmp), _MM_SHUFFLE(1,0,1,0))), 15);
+  // then we can perform a consistent permutation on the global register to get everything in shape:
+  return  _mm256_permute_ps(tmp, _MM_SHUFFLE(3,3,2,2));
+}
+// Loads 2 doubles from memory a returns the packet {a0, a0  a1, a1}
+template<> EIGEN_STRONG_INLINE Packet4d ploaddup<Packet4d>(const double* from)
+{
+  Packet4d tmp = _mm256_broadcast_pd((const __m128d*)(const void*)from);
+  return  _mm256_permute_pd(tmp, 3<<2);
+}
+
+// Loads 2 floats from memory a returns the packet {a0, a0  a0, a0, a1, a1, a1, a1}
+template<> EIGEN_STRONG_INLINE Packet8f ploadquad<Packet8f>(const float* from)
+{
+  Packet8f tmp = _mm256_castps128_ps256(_mm_broadcast_ss(from));
+  return _mm256_insertf128_ps(tmp, _mm_broadcast_ss(from+1), 1);
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<float>(float*   to, const Packet8f& from) { EIGEN_DEBUG_ALIGNED_STORE _mm256_store_ps(to, from); }
+template<> EIGEN_STRONG_INLINE void pstore<double>(double* to, const Packet4d& from) { EIGEN_DEBUG_ALIGNED_STORE _mm256_store_pd(to, from); }
+template<> EIGEN_STRONG_INLINE void pstore<int>(int*       to, const Packet8i& from) { EIGEN_DEBUG_ALIGNED_STORE _mm256_storeu_si256(reinterpret_cast<__m256i*>(to), from); }
+
+template<> EIGEN_STRONG_INLINE void pstoreu<float>(float*   to, const Packet8f& from) { EIGEN_DEBUG_UNALIGNED_STORE _mm256_storeu_ps(to, from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<double>(double* to, const Packet4d& from) { EIGEN_DEBUG_UNALIGNED_STORE _mm256_storeu_pd(to, from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<int>(int*       to, const Packet8i& from) { EIGEN_DEBUG_UNALIGNED_STORE _mm256_storeu_si256(reinterpret_cast<__m256i*>(to), from); }
+
+// NOTE: leverage _mm256_i32gather_ps and _mm256_i32gather_pd if AVX2 instructions are available
+// NOTE: for the record the following seems to be slower: return _mm256_i32gather_ps(from, _mm256_set1_epi32(stride), 4);
+template<> EIGEN_DEVICE_FUNC inline Packet8f pgather<float, Packet8f>(const float* from, Index stride)
+{
+  return _mm256_set_ps(from[7*stride], from[6*stride], from[5*stride], from[4*stride],
+                       from[3*stride], from[2*stride], from[1*stride], from[0*stride]);
+}
+template<> EIGEN_DEVICE_FUNC inline Packet4d pgather<double, Packet4d>(const double* from, Index stride)
+{
+  return _mm256_set_pd(from[3*stride], from[2*stride], from[1*stride], from[0*stride]);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<float, Packet8f>(float* to, const Packet8f& from, Index stride)
+{
+  __m128 low = _mm256_extractf128_ps(from, 0);
+  to[stride*0] = _mm_cvtss_f32(low);
+  to[stride*1] = _mm_cvtss_f32(_mm_shuffle_ps(low, low, 1));
+  to[stride*2] = _mm_cvtss_f32(_mm_shuffle_ps(low, low, 2));
+  to[stride*3] = _mm_cvtss_f32(_mm_shuffle_ps(low, low, 3));
+
+  __m128 high = _mm256_extractf128_ps(from, 1);
+  to[stride*4] = _mm_cvtss_f32(high);
+  to[stride*5] = _mm_cvtss_f32(_mm_shuffle_ps(high, high, 1));
+  to[stride*6] = _mm_cvtss_f32(_mm_shuffle_ps(high, high, 2));
+  to[stride*7] = _mm_cvtss_f32(_mm_shuffle_ps(high, high, 3));
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<double, Packet4d>(double* to, const Packet4d& from, Index stride)
+{
+  __m128d low = _mm256_extractf128_pd(from, 0);
+  to[stride*0] = _mm_cvtsd_f64(low);
+  to[stride*1] = _mm_cvtsd_f64(_mm_shuffle_pd(low, low, 1));
+  __m128d high = _mm256_extractf128_pd(from, 1);
+  to[stride*2] = _mm_cvtsd_f64(high);
+  to[stride*3] = _mm_cvtsd_f64(_mm_shuffle_pd(high, high, 1));
+}
+
+template<> EIGEN_STRONG_INLINE void pstore1<Packet8f>(float* to, const float& a)
+{
+  Packet8f pa = pset1<Packet8f>(a);
+  pstore(to, pa);
+}
+template<> EIGEN_STRONG_INLINE void pstore1<Packet4d>(double* to, const double& a)
+{
+  Packet4d pa = pset1<Packet4d>(a);
+  pstore(to, pa);
+}
+template<> EIGEN_STRONG_INLINE void pstore1<Packet8i>(int* to, const int& a)
+{
+  Packet8i pa = pset1<Packet8i>(a);
+  pstore(to, pa);
+}
+
+#ifndef EIGEN_VECTORIZE_AVX512
+template<> EIGEN_STRONG_INLINE void prefetch<float>(const float*   addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); }
+template<> EIGEN_STRONG_INLINE void prefetch<double>(const double* addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); }
+template<> EIGEN_STRONG_INLINE void prefetch<int>(const int*       addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); }
+#endif
+
+template<> EIGEN_STRONG_INLINE float  pfirst<Packet8f>(const Packet8f& a) {
+  return _mm_cvtss_f32(_mm256_castps256_ps128(a));
+}
+template<> EIGEN_STRONG_INLINE double pfirst<Packet4d>(const Packet4d& a) {
+  return _mm_cvtsd_f64(_mm256_castpd256_pd128(a));
+}
+template<> EIGEN_STRONG_INLINE int    pfirst<Packet8i>(const Packet8i& a) {
+  return _mm_cvtsi128_si32(_mm256_castsi256_si128(a));
+}
+
+
+template<> EIGEN_STRONG_INLINE Packet8f preverse(const Packet8f& a)
+{
+  __m256 tmp = _mm256_shuffle_ps(a,a,0x1b);
+  return _mm256_permute2f128_ps(tmp, tmp, 1);
+}
+template<> EIGEN_STRONG_INLINE Packet4d preverse(const Packet4d& a)
+{
+   __m256d tmp = _mm256_shuffle_pd(a,a,5);
+  return _mm256_permute2f128_pd(tmp, tmp, 1);
+
+  __m256d swap_halves = _mm256_permute2f128_pd(a,a,1);
+    return _mm256_permute_pd(swap_halves,5);
+}
+
+// pabs should be ok
+template<> EIGEN_STRONG_INLINE Packet8f pabs(const Packet8f& a)
+{
+  const Packet8f mask = _mm256_castsi256_ps(_mm256_setr_epi32(0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF));
+  return _mm256_and_ps(a,mask);
+}
+template<> EIGEN_STRONG_INLINE Packet4d pabs(const Packet4d& a)
+{
+  const Packet4d mask = _mm256_castsi256_pd(_mm256_setr_epi32(0xFFFFFFFF,0x7FFFFFFF,0xFFFFFFFF,0x7FFFFFFF,0xFFFFFFFF,0x7FFFFFFF,0xFFFFFFFF,0x7FFFFFFF));
+  return _mm256_and_pd(a,mask);
+}
+
+// preduxp should be ok
+// FIXME: why is this ok? why isn't the simply implementation working as expected?
+template<> EIGEN_STRONG_INLINE Packet8f preduxp<Packet8f>(const Packet8f* vecs)
+{
+    __m256 hsum1 = _mm256_hadd_ps(vecs[0], vecs[1]);
+    __m256 hsum2 = _mm256_hadd_ps(vecs[2], vecs[3]);
+    __m256 hsum3 = _mm256_hadd_ps(vecs[4], vecs[5]);
+    __m256 hsum4 = _mm256_hadd_ps(vecs[6], vecs[7]);
+
+    __m256 hsum5 = _mm256_hadd_ps(hsum1, hsum1);
+    __m256 hsum6 = _mm256_hadd_ps(hsum2, hsum2);
+    __m256 hsum7 = _mm256_hadd_ps(hsum3, hsum3);
+    __m256 hsum8 = _mm256_hadd_ps(hsum4, hsum4);
+
+    __m256 perm1 =  _mm256_permute2f128_ps(hsum5, hsum5, 0x23);
+    __m256 perm2 =  _mm256_permute2f128_ps(hsum6, hsum6, 0x23);
+    __m256 perm3 =  _mm256_permute2f128_ps(hsum7, hsum7, 0x23);
+    __m256 perm4 =  _mm256_permute2f128_ps(hsum8, hsum8, 0x23);
+
+    __m256 sum1 = _mm256_add_ps(perm1, hsum5);
+    __m256 sum2 = _mm256_add_ps(perm2, hsum6);
+    __m256 sum3 = _mm256_add_ps(perm3, hsum7);
+    __m256 sum4 = _mm256_add_ps(perm4, hsum8);
+
+    __m256 blend1 = _mm256_blend_ps(sum1, sum2, 0xcc);
+    __m256 blend2 = _mm256_blend_ps(sum3, sum4, 0xcc);
+
+    __m256 final = _mm256_blend_ps(blend1, blend2, 0xf0);
+    return final;
+}
+template<> EIGEN_STRONG_INLINE Packet4d preduxp<Packet4d>(const Packet4d* vecs)
+{
+ Packet4d tmp0, tmp1;
+
+  tmp0 = _mm256_hadd_pd(vecs[0], vecs[1]);
+  tmp0 = _mm256_add_pd(tmp0, _mm256_permute2f128_pd(tmp0, tmp0, 1));
+
+  tmp1 = _mm256_hadd_pd(vecs[2], vecs[3]);
+  tmp1 = _mm256_add_pd(tmp1, _mm256_permute2f128_pd(tmp1, tmp1, 1));
+
+  return _mm256_blend_pd(tmp0, tmp1, 0xC);
+}
+
+template<> EIGEN_STRONG_INLINE float predux<Packet8f>(const Packet8f& a)
+{
+  return predux(Packet4f(_mm_add_ps(_mm256_castps256_ps128(a),_mm256_extractf128_ps(a,1))));
+}
+template<> EIGEN_STRONG_INLINE double predux<Packet4d>(const Packet4d& a)
+{
+  return predux(Packet2d(_mm_add_pd(_mm256_castpd256_pd128(a),_mm256_extractf128_pd(a,1))));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f predux_downto4<Packet8f>(const Packet8f& a)
+{
+  return _mm_add_ps(_mm256_castps256_ps128(a),_mm256_extractf128_ps(a,1));
+}
+
+template<> EIGEN_STRONG_INLINE float predux_mul<Packet8f>(const Packet8f& a)
+{
+  Packet8f tmp;
+  tmp = _mm256_mul_ps(a, _mm256_permute2f128_ps(a,a,1));
+  tmp = _mm256_mul_ps(tmp, _mm256_shuffle_ps(tmp,tmp,_MM_SHUFFLE(1,0,3,2)));
+  return pfirst(_mm256_mul_ps(tmp, _mm256_shuffle_ps(tmp,tmp,1)));
+}
+template<> EIGEN_STRONG_INLINE double predux_mul<Packet4d>(const Packet4d& a)
+{
+  Packet4d tmp;
+  tmp = _mm256_mul_pd(a, _mm256_permute2f128_pd(a,a,1));
+  return pfirst(_mm256_mul_pd(tmp, _mm256_shuffle_pd(tmp,tmp,1)));
+}
+
+template<> EIGEN_STRONG_INLINE float predux_min<Packet8f>(const Packet8f& a)
+{
+  Packet8f tmp = _mm256_min_ps(a, _mm256_permute2f128_ps(a,a,1));
+  tmp = _mm256_min_ps(tmp, _mm256_shuffle_ps(tmp,tmp,_MM_SHUFFLE(1,0,3,2)));
+  return pfirst(_mm256_min_ps(tmp, _mm256_shuffle_ps(tmp,tmp,1)));
+}
+template<> EIGEN_STRONG_INLINE double predux_min<Packet4d>(const Packet4d& a)
+{
+  Packet4d tmp = _mm256_min_pd(a, _mm256_permute2f128_pd(a,a,1));
+  return pfirst(_mm256_min_pd(tmp, _mm256_shuffle_pd(tmp, tmp, 1)));
+}
+
+template<> EIGEN_STRONG_INLINE float predux_max<Packet8f>(const Packet8f& a)
+{
+  Packet8f tmp = _mm256_max_ps(a, _mm256_permute2f128_ps(a,a,1));
+  tmp = _mm256_max_ps(tmp, _mm256_shuffle_ps(tmp,tmp,_MM_SHUFFLE(1,0,3,2)));
+  return pfirst(_mm256_max_ps(tmp, _mm256_shuffle_ps(tmp,tmp,1)));
+}
+
+template<> EIGEN_STRONG_INLINE double predux_max<Packet4d>(const Packet4d& a)
+{
+  Packet4d tmp = _mm256_max_pd(a, _mm256_permute2f128_pd(a,a,1));
+  return pfirst(_mm256_max_pd(tmp, _mm256_shuffle_pd(tmp, tmp, 1)));
+}
+
+
+template<int Offset>
+struct palign_impl<Offset,Packet8f>
+{
+  static EIGEN_STRONG_INLINE void run(Packet8f& first, const Packet8f& second)
+  {
+    if (Offset==1)
+    {
+      first = _mm256_blend_ps(first, second, 1);
+      Packet8f tmp1 = _mm256_permute_ps (first, _MM_SHUFFLE(0,3,2,1));
+      Packet8f tmp2 = _mm256_permute2f128_ps (tmp1, tmp1, 1);
+      first = _mm256_blend_ps(tmp1, tmp2, 0x88);
+    }
+    else if (Offset==2)
+    {
+      first = _mm256_blend_ps(first, second, 3);
+      Packet8f tmp1 = _mm256_permute_ps (first, _MM_SHUFFLE(1,0,3,2));
+      Packet8f tmp2 = _mm256_permute2f128_ps (tmp1, tmp1, 1);
+      first = _mm256_blend_ps(tmp1, tmp2, 0xcc);
+    }
+    else if (Offset==3)
+    {
+      first = _mm256_blend_ps(first, second, 7);
+      Packet8f tmp1 = _mm256_permute_ps (first, _MM_SHUFFLE(2,1,0,3));
+      Packet8f tmp2 = _mm256_permute2f128_ps (tmp1, tmp1, 1);
+      first = _mm256_blend_ps(tmp1, tmp2, 0xee);
+    }
+    else if (Offset==4)
+    {
+      first = _mm256_blend_ps(first, second, 15);
+      Packet8f tmp1 = _mm256_permute_ps (first, _MM_SHUFFLE(3,2,1,0));
+      Packet8f tmp2 = _mm256_permute2f128_ps (tmp1, tmp1, 1);
+      first = _mm256_permute_ps(tmp2, _MM_SHUFFLE(3,2,1,0));
+    }
+    else if (Offset==5)
+    {
+      first = _mm256_blend_ps(first, second, 31);
+      first = _mm256_permute2f128_ps(first, first, 1);
+      Packet8f tmp = _mm256_permute_ps (first, _MM_SHUFFLE(0,3,2,1));
+      first = _mm256_permute2f128_ps(tmp, tmp, 1);
+      first = _mm256_blend_ps(tmp, first, 0x88);
+    }
+    else if (Offset==6)
+    {
+      first = _mm256_blend_ps(first, second, 63);
+      first = _mm256_permute2f128_ps(first, first, 1);
+      Packet8f tmp = _mm256_permute_ps (first, _MM_SHUFFLE(1,0,3,2));
+      first = _mm256_permute2f128_ps(tmp, tmp, 1);
+      first = _mm256_blend_ps(tmp, first, 0xcc);
+    }
+    else if (Offset==7)
+    {
+      first = _mm256_blend_ps(first, second, 127);
+      first = _mm256_permute2f128_ps(first, first, 1);
+      Packet8f tmp = _mm256_permute_ps (first, _MM_SHUFFLE(2,1,0,3));
+      first = _mm256_permute2f128_ps(tmp, tmp, 1);
+      first = _mm256_blend_ps(tmp, first, 0xee);
+    }
+  }
+};
+
+template<int Offset>
+struct palign_impl<Offset,Packet4d>
+{
+  static EIGEN_STRONG_INLINE void run(Packet4d& first, const Packet4d& second)
+  {
+    if (Offset==1)
+    {
+      first = _mm256_blend_pd(first, second, 1);
+      __m256d tmp = _mm256_permute_pd(first, 5);
+      first = _mm256_permute2f128_pd(tmp, tmp, 1);
+      first = _mm256_blend_pd(tmp, first, 0xA);
+    }
+    else if (Offset==2)
+    {
+      first = _mm256_blend_pd(first, second, 3);
+      first = _mm256_permute2f128_pd(first, first, 1);
+    }
+    else if (Offset==3)
+    {
+      first = _mm256_blend_pd(first, second, 7);
+      __m256d tmp = _mm256_permute_pd(first, 5);
+      first = _mm256_permute2f128_pd(tmp, tmp, 1);
+      first = _mm256_blend_pd(tmp, first, 5);
+    }
+  }
+};
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet8f,8>& kernel) {
+  __m256 T0 = _mm256_unpacklo_ps(kernel.packet[0], kernel.packet[1]);
+  __m256 T1 = _mm256_unpackhi_ps(kernel.packet[0], kernel.packet[1]);
+  __m256 T2 = _mm256_unpacklo_ps(kernel.packet[2], kernel.packet[3]);
+  __m256 T3 = _mm256_unpackhi_ps(kernel.packet[2], kernel.packet[3]);
+  __m256 T4 = _mm256_unpacklo_ps(kernel.packet[4], kernel.packet[5]);
+  __m256 T5 = _mm256_unpackhi_ps(kernel.packet[4], kernel.packet[5]);
+  __m256 T6 = _mm256_unpacklo_ps(kernel.packet[6], kernel.packet[7]);
+  __m256 T7 = _mm256_unpackhi_ps(kernel.packet[6], kernel.packet[7]);
+  __m256 S0 = _mm256_shuffle_ps(T0,T2,_MM_SHUFFLE(1,0,1,0));
+  __m256 S1 = _mm256_shuffle_ps(T0,T2,_MM_SHUFFLE(3,2,3,2));
+  __m256 S2 = _mm256_shuffle_ps(T1,T3,_MM_SHUFFLE(1,0,1,0));
+  __m256 S3 = _mm256_shuffle_ps(T1,T3,_MM_SHUFFLE(3,2,3,2));
+  __m256 S4 = _mm256_shuffle_ps(T4,T6,_MM_SHUFFLE(1,0,1,0));
+  __m256 S5 = _mm256_shuffle_ps(T4,T6,_MM_SHUFFLE(3,2,3,2));
+  __m256 S6 = _mm256_shuffle_ps(T5,T7,_MM_SHUFFLE(1,0,1,0));
+  __m256 S7 = _mm256_shuffle_ps(T5,T7,_MM_SHUFFLE(3,2,3,2));
+  kernel.packet[0] = _mm256_permute2f128_ps(S0, S4, 0x20);
+  kernel.packet[1] = _mm256_permute2f128_ps(S1, S5, 0x20);
+  kernel.packet[2] = _mm256_permute2f128_ps(S2, S6, 0x20);
+  kernel.packet[3] = _mm256_permute2f128_ps(S3, S7, 0x20);
+  kernel.packet[4] = _mm256_permute2f128_ps(S0, S4, 0x31);
+  kernel.packet[5] = _mm256_permute2f128_ps(S1, S5, 0x31);
+  kernel.packet[6] = _mm256_permute2f128_ps(S2, S6, 0x31);
+  kernel.packet[7] = _mm256_permute2f128_ps(S3, S7, 0x31);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet8f,4>& kernel) {
+  __m256 T0 = _mm256_unpacklo_ps(kernel.packet[0], kernel.packet[1]);
+  __m256 T1 = _mm256_unpackhi_ps(kernel.packet[0], kernel.packet[1]);
+  __m256 T2 = _mm256_unpacklo_ps(kernel.packet[2], kernel.packet[3]);
+  __m256 T3 = _mm256_unpackhi_ps(kernel.packet[2], kernel.packet[3]);
+
+  __m256 S0 = _mm256_shuffle_ps(T0,T2,_MM_SHUFFLE(1,0,1,0));
+  __m256 S1 = _mm256_shuffle_ps(T0,T2,_MM_SHUFFLE(3,2,3,2));
+  __m256 S2 = _mm256_shuffle_ps(T1,T3,_MM_SHUFFLE(1,0,1,0));
+  __m256 S3 = _mm256_shuffle_ps(T1,T3,_MM_SHUFFLE(3,2,3,2));
+
+  kernel.packet[0] = _mm256_permute2f128_ps(S0, S1, 0x20);
+  kernel.packet[1] = _mm256_permute2f128_ps(S2, S3, 0x20);
+  kernel.packet[2] = _mm256_permute2f128_ps(S0, S1, 0x31);
+  kernel.packet[3] = _mm256_permute2f128_ps(S2, S3, 0x31);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet4d,4>& kernel) {
+  __m256d T0 = _mm256_shuffle_pd(kernel.packet[0], kernel.packet[1], 15);
+  __m256d T1 = _mm256_shuffle_pd(kernel.packet[0], kernel.packet[1], 0);
+  __m256d T2 = _mm256_shuffle_pd(kernel.packet[2], kernel.packet[3], 15);
+  __m256d T3 = _mm256_shuffle_pd(kernel.packet[2], kernel.packet[3], 0);
+
+  kernel.packet[1] = _mm256_permute2f128_pd(T0, T2, 32);
+  kernel.packet[3] = _mm256_permute2f128_pd(T0, T2, 49);
+  kernel.packet[0] = _mm256_permute2f128_pd(T1, T3, 32);
+  kernel.packet[2] = _mm256_permute2f128_pd(T1, T3, 49);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pblend(const Selector<8>& ifPacket, const Packet8f& thenPacket, const Packet8f& elsePacket) {
+  const __m256 zero = _mm256_setzero_ps();
+  const __m256 select = _mm256_set_ps(ifPacket.select[7], ifPacket.select[6], ifPacket.select[5], ifPacket.select[4], ifPacket.select[3], ifPacket.select[2], ifPacket.select[1], ifPacket.select[0]);
+  __m256 false_mask = _mm256_cmp_ps(select, zero, _CMP_EQ_UQ);
+  return _mm256_blendv_ps(thenPacket, elsePacket, false_mask);
+}
+template<> EIGEN_STRONG_INLINE Packet4d pblend(const Selector<4>& ifPacket, const Packet4d& thenPacket, const Packet4d& elsePacket) {
+  const __m256d zero = _mm256_setzero_pd();
+  const __m256d select = _mm256_set_pd(ifPacket.select[3], ifPacket.select[2], ifPacket.select[1], ifPacket.select[0]);
+  __m256d false_mask = _mm256_cmp_pd(select, zero, _CMP_EQ_UQ);
+  return _mm256_blendv_pd(thenPacket, elsePacket, false_mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pinsertfirst(const Packet8f& a, float b)
+{
+  return _mm256_blend_ps(a,pset1<Packet8f>(b),1);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4d pinsertfirst(const Packet4d& a, double b)
+{
+  return _mm256_blend_pd(a,pset1<Packet4d>(b),1);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pinsertlast(const Packet8f& a, float b)
+{
+  return _mm256_blend_ps(a,pset1<Packet8f>(b),(1<<7));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4d pinsertlast(const Packet4d& a, double b)
+{
+  return _mm256_blend_pd(a,pset1<Packet4d>(b),(1<<3));
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_PACKET_MATH_AVX_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/AVX/TypeCasting.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/AVX/TypeCasting.h
new file mode 100644
index 00000000..83bfdc60
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/AVX/TypeCasting.h
@@ -0,0 +1,51 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TYPE_CASTING_AVX_H
+#define EIGEN_TYPE_CASTING_AVX_H
+
+namespace Eigen {
+
+namespace internal {
+
+// For now we use SSE to handle integers, so we can't use AVX instructions to cast
+// from int to float
+template <>
+struct type_casting_traits<float, int> {
+  enum {
+    VectorizedCast = 0,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template <>
+struct type_casting_traits<int, float> {
+  enum {
+    VectorizedCast = 0,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+
+
+template<> EIGEN_STRONG_INLINE Packet8i pcast<Packet8f, Packet8i>(const Packet8f& a) {
+  return _mm256_cvtps_epi32(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pcast<Packet8i, Packet8f>(const Packet8i& a) {
+  return _mm256_cvtepi32_ps(a);
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TYPE_CASTING_AVX_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/AVX512/MathFunctions.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/AVX512/MathFunctions.h
new file mode 100644
index 00000000..399be0ee
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/AVX512/MathFunctions.h
@@ -0,0 +1,396 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Pedro Gonnet (pedro.gonnet@gmail.com)
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef THIRD_PARTY_EIGEN3_EIGEN_SRC_CORE_ARCH_AVX512_MATHFUNCTIONS_H_
+#define THIRD_PARTY_EIGEN3_EIGEN_SRC_CORE_ARCH_AVX512_MATHFUNCTIONS_H_
+
+namespace Eigen {
+
+namespace internal {
+
+// Disable the code for older versions of gcc that don't support many of the required avx512 instrinsics.
+#if EIGEN_GNUC_AT_LEAST(5, 3)
+
+#define _EIGEN_DECLARE_CONST_Packet16f(NAME, X) \
+  const Packet16f p16f_##NAME = pset1<Packet16f>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet16f_FROM_INT(NAME, X) \
+  const Packet16f p16f_##NAME = (__m512)pset1<Packet16i>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet8d(NAME, X) \
+  const Packet8d p8d_##NAME = pset1<Packet8d>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet8d_FROM_INT64(NAME, X) \
+  const Packet8d p8d_##NAME = _mm512_castsi512_pd(_mm512_set1_epi64(X))
+
+// Natural logarithm
+// Computes log(x) as log(2^e * m) = C*e + log(m), where the constant C =log(2)
+// and m is in the range [sqrt(1/2),sqrt(2)). In this range, the logarithm can
+// be easily approximated by a polynomial centered on m=1 for stability.
+#if defined(EIGEN_VECTORIZE_AVX512DQ)
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16f
+plog<Packet16f>(const Packet16f& _x) {
+  Packet16f x = _x;
+  _EIGEN_DECLARE_CONST_Packet16f(1, 1.0f);
+  _EIGEN_DECLARE_CONST_Packet16f(half, 0.5f);
+  _EIGEN_DECLARE_CONST_Packet16f(126f, 126.0f);
+
+  _EIGEN_DECLARE_CONST_Packet16f_FROM_INT(inv_mant_mask, ~0x7f800000);
+
+  // The smallest non denormalized float number.
+  _EIGEN_DECLARE_CONST_Packet16f_FROM_INT(min_norm_pos, 0x00800000);
+  _EIGEN_DECLARE_CONST_Packet16f_FROM_INT(minus_inf, 0xff800000);
+  _EIGEN_DECLARE_CONST_Packet16f_FROM_INT(nan, 0x7fc00000);
+
+  // Polynomial coefficients.
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_SQRTHF, 0.707106781186547524f);
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_log_p0, 7.0376836292E-2f);
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_log_p1, -1.1514610310E-1f);
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_log_p2, 1.1676998740E-1f);
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_log_p3, -1.2420140846E-1f);
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_log_p4, +1.4249322787E-1f);
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_log_p5, -1.6668057665E-1f);
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_log_p6, +2.0000714765E-1f);
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_log_p7, -2.4999993993E-1f);
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_log_p8, +3.3333331174E-1f);
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_log_q1, -2.12194440e-4f);
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_log_q2, 0.693359375f);
+
+  // invalid_mask is set to true when x is NaN
+  __mmask16 invalid_mask =
+      _mm512_cmp_ps_mask(x, _mm512_setzero_ps(), _CMP_NGE_UQ);
+  __mmask16 iszero_mask =
+      _mm512_cmp_ps_mask(x, _mm512_setzero_ps(), _CMP_EQ_UQ);
+
+  // Truncate input values to the minimum positive normal.
+  x = pmax(x, p16f_min_norm_pos);
+
+  // Extract the shifted exponents.
+  Packet16f emm0 = _mm512_cvtepi32_ps(_mm512_srli_epi32((__m512i)x, 23));
+  Packet16f e = _mm512_sub_ps(emm0, p16f_126f);
+
+  // Set the exponents to -1, i.e. x are in the range [0.5,1).
+  x = _mm512_and_ps(x, p16f_inv_mant_mask);
+  x = _mm512_or_ps(x, p16f_half);
+
+  // part2: Shift the inputs from the range [0.5,1) to [sqrt(1/2),sqrt(2))
+  // and shift by -1. The values are then centered around 0, which improves
+  // the stability of the polynomial evaluation.
+  //   if( x < SQRTHF ) {
+  //     e -= 1;
+  //     x = x + x - 1.0;
+  //   } else { x = x - 1.0; }
+  __mmask16 mask = _mm512_cmp_ps_mask(x, p16f_cephes_SQRTHF, _CMP_LT_OQ);
+  Packet16f tmp = _mm512_mask_blend_ps(mask, x, _mm512_setzero_ps());
+  x = psub(x, p16f_1);
+  e = psub(e, _mm512_mask_blend_ps(mask, p16f_1, _mm512_setzero_ps()));
+  x = padd(x, tmp);
+
+  Packet16f x2 = pmul(x, x);
+  Packet16f x3 = pmul(x2, x);
+
+  // Evaluate the polynomial approximant of degree 8 in three parts, probably
+  // to improve instruction-level parallelism.
+  Packet16f y, y1, y2;
+  y = pmadd(p16f_cephes_log_p0, x, p16f_cephes_log_p1);
+  y1 = pmadd(p16f_cephes_log_p3, x, p16f_cephes_log_p4);
+  y2 = pmadd(p16f_cephes_log_p6, x, p16f_cephes_log_p7);
+  y = pmadd(y, x, p16f_cephes_log_p2);
+  y1 = pmadd(y1, x, p16f_cephes_log_p5);
+  y2 = pmadd(y2, x, p16f_cephes_log_p8);
+  y = pmadd(y, x3, y1);
+  y = pmadd(y, x3, y2);
+  y = pmul(y, x3);
+
+  // Add the logarithm of the exponent back to the result of the interpolation.
+  y1 = pmul(e, p16f_cephes_log_q1);
+  tmp = pmul(x2, p16f_half);
+  y = padd(y, y1);
+  x = psub(x, tmp);
+  y2 = pmul(e, p16f_cephes_log_q2);
+  x = padd(x, y);
+  x = padd(x, y2);
+
+  // Filter out invalid inputs, i.e. negative arg will be NAN, 0 will be -INF.
+  return _mm512_mask_blend_ps(iszero_mask, p16f_minus_inf,
+                              _mm512_mask_blend_ps(invalid_mask, p16f_nan, x));
+}
+#endif
+
+// Exponential function. Works by writing "x = m*log(2) + r" where
+// "m = floor(x/log(2)+1/2)" and "r" is the remainder. The result is then
+// "exp(x) = 2^m*exp(r)" where exp(r) is in the range [-1,1).
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16f
+pexp<Packet16f>(const Packet16f& _x) {
+  _EIGEN_DECLARE_CONST_Packet16f(1, 1.0f);
+  _EIGEN_DECLARE_CONST_Packet16f(half, 0.5f);
+  _EIGEN_DECLARE_CONST_Packet16f(127, 127.0f);
+
+  _EIGEN_DECLARE_CONST_Packet16f(exp_hi, 88.3762626647950f);
+  _EIGEN_DECLARE_CONST_Packet16f(exp_lo, -88.3762626647949f);
+
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_LOG2EF, 1.44269504088896341f);
+
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_exp_p0, 1.9875691500E-4f);
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_exp_p1, 1.3981999507E-3f);
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_exp_p2, 8.3334519073E-3f);
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_exp_p3, 4.1665795894E-2f);
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_exp_p4, 1.6666665459E-1f);
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_exp_p5, 5.0000001201E-1f);
+
+  // Clamp x.
+  Packet16f x = pmax(pmin(_x, p16f_exp_hi), p16f_exp_lo);
+
+  // Express exp(x) as exp(m*ln(2) + r), start by extracting
+  // m = floor(x/ln(2) + 0.5).
+  Packet16f m = _mm512_floor_ps(pmadd(x, p16f_cephes_LOG2EF, p16f_half));
+
+  // Get r = x - m*ln(2). Note that we can do this without losing more than one
+  // ulp precision due to the FMA instruction.
+  _EIGEN_DECLARE_CONST_Packet16f(nln2, -0.6931471805599453f);
+  Packet16f r = _mm512_fmadd_ps(m, p16f_nln2, x);
+  Packet16f r2 = pmul(r, r);
+
+  // TODO(gonnet): Split into odd/even polynomials and try to exploit
+  //               instruction-level parallelism.
+  Packet16f y = p16f_cephes_exp_p0;
+  y = pmadd(y, r, p16f_cephes_exp_p1);
+  y = pmadd(y, r, p16f_cephes_exp_p2);
+  y = pmadd(y, r, p16f_cephes_exp_p3);
+  y = pmadd(y, r, p16f_cephes_exp_p4);
+  y = pmadd(y, r, p16f_cephes_exp_p5);
+  y = pmadd(y, r2, r);
+  y = padd(y, p16f_1);
+
+  // Build emm0 = 2^m.
+  Packet16i emm0 = _mm512_cvttps_epi32(padd(m, p16f_127));
+  emm0 = _mm512_slli_epi32(emm0, 23);
+
+  // Return 2^m * exp(r).
+  return pmax(pmul(y, _mm512_castsi512_ps(emm0)), _x);
+}
+
+/*template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8d
+pexp<Packet8d>(const Packet8d& _x) {
+  Packet8d x = _x;
+
+  _EIGEN_DECLARE_CONST_Packet8d(1, 1.0);
+  _EIGEN_DECLARE_CONST_Packet8d(2, 2.0);
+
+  _EIGEN_DECLARE_CONST_Packet8d(exp_hi, 709.437);
+  _EIGEN_DECLARE_CONST_Packet8d(exp_lo, -709.436139303);
+
+  _EIGEN_DECLARE_CONST_Packet8d(cephes_LOG2EF, 1.4426950408889634073599);
+
+  _EIGEN_DECLARE_CONST_Packet8d(cephes_exp_p0, 1.26177193074810590878e-4);
+  _EIGEN_DECLARE_CONST_Packet8d(cephes_exp_p1, 3.02994407707441961300e-2);
+  _EIGEN_DECLARE_CONST_Packet8d(cephes_exp_p2, 9.99999999999999999910e-1);
+
+  _EIGEN_DECLARE_CONST_Packet8d(cephes_exp_q0, 3.00198505138664455042e-6);
+  _EIGEN_DECLARE_CONST_Packet8d(cephes_exp_q1, 2.52448340349684104192e-3);
+  _EIGEN_DECLARE_CONST_Packet8d(cephes_exp_q2, 2.27265548208155028766e-1);
+  _EIGEN_DECLARE_CONST_Packet8d(cephes_exp_q3, 2.00000000000000000009e0);
+
+  _EIGEN_DECLARE_CONST_Packet8d(cephes_exp_C1, 0.693145751953125);
+  _EIGEN_DECLARE_CONST_Packet8d(cephes_exp_C2, 1.42860682030941723212e-6);
+
+  // clamp x
+  x = pmax(pmin(x, p8d_exp_hi), p8d_exp_lo);
+
+  // Express exp(x) as exp(g + n*log(2)).
+  const Packet8d n =
+      _mm512_mul_round_pd(p8d_cephes_LOG2EF, x, _MM_FROUND_TO_NEAREST_INT);
+
+  // Get the remainder modulo log(2), i.e. the "g" described above. Subtract
+  // n*log(2) out in two steps, i.e. n*C1 + n*C2, C1+C2=log2 to get the last
+  // digits right.
+  const Packet8d nC1 = pmul(n, p8d_cephes_exp_C1);
+  const Packet8d nC2 = pmul(n, p8d_cephes_exp_C2);
+  x = psub(x, nC1);
+  x = psub(x, nC2);
+
+  const Packet8d x2 = pmul(x, x);
+
+  // Evaluate the numerator polynomial of the rational interpolant.
+  Packet8d px = p8d_cephes_exp_p0;
+  px = pmadd(px, x2, p8d_cephes_exp_p1);
+  px = pmadd(px, x2, p8d_cephes_exp_p2);
+  px = pmul(px, x);
+
+  // Evaluate the denominator polynomial of the rational interpolant.
+  Packet8d qx = p8d_cephes_exp_q0;
+  qx = pmadd(qx, x2, p8d_cephes_exp_q1);
+  qx = pmadd(qx, x2, p8d_cephes_exp_q2);
+  qx = pmadd(qx, x2, p8d_cephes_exp_q3);
+
+  // I don't really get this bit, copied from the SSE2 routines, so...
+  // TODO(gonnet): Figure out what is going on here, perhaps find a better
+  // rational interpolant?
+  x = _mm512_div_pd(px, psub(qx, px));
+  x = pmadd(p8d_2, x, p8d_1);
+
+  // Build e=2^n.
+  const Packet8d e = _mm512_castsi512_pd(_mm512_slli_epi64(
+      _mm512_add_epi64(_mm512_cvtpd_epi64(n), _mm512_set1_epi64(1023)), 52));
+
+  // Construct the result 2^n * exp(g) = e * x. The max is used to catch
+  // non-finite values in the input.
+  return pmax(pmul(x, e), _x);
+  }*/
+
+// Functions for sqrt.
+// The EIGEN_FAST_MATH version uses the _mm_rsqrt_ps approximation and one step
+// of Newton's method, at a cost of 1-2 bits of precision as opposed to the
+// exact solution. The main advantage of this approach is not just speed, but
+// also the fact that it can be inlined and pipelined with other computations,
+// further reducing its effective latency.
+#if EIGEN_FAST_MATH
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16f
+psqrt<Packet16f>(const Packet16f& _x) {
+  _EIGEN_DECLARE_CONST_Packet16f(one_point_five, 1.5f);
+  _EIGEN_DECLARE_CONST_Packet16f(minus_half, -0.5f);
+  _EIGEN_DECLARE_CONST_Packet16f_FROM_INT(flt_min, 0x00800000);
+
+  Packet16f neg_half = pmul(_x, p16f_minus_half);
+
+  // select only the inverse sqrt of positive normal inputs (denormals are
+  // flushed to zero and cause infs as well).
+  __mmask16 non_zero_mask = _mm512_cmp_ps_mask(_x, p16f_flt_min, _CMP_GE_OQ);
+  Packet16f x = _mm512_mask_blend_ps(non_zero_mask, _mm512_rsqrt14_ps(_x),
+                                     _mm512_setzero_ps());
+
+  // Do a single step of Newton's iteration.
+  x = pmul(x, pmadd(neg_half, pmul(x, x), p16f_one_point_five));
+
+  // Multiply the original _x by it's reciprocal square root to extract the
+  // square root.
+  return pmul(_x, x);
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8d
+psqrt<Packet8d>(const Packet8d& _x) {
+  _EIGEN_DECLARE_CONST_Packet8d(one_point_five, 1.5);
+  _EIGEN_DECLARE_CONST_Packet8d(minus_half, -0.5);
+  _EIGEN_DECLARE_CONST_Packet8d_FROM_INT64(dbl_min, 0x0010000000000000LL);
+
+  Packet8d neg_half = pmul(_x, p8d_minus_half);
+
+  // select only the inverse sqrt of positive normal inputs (denormals are
+  // flushed to zero and cause infs as well).
+  __mmask8 non_zero_mask = _mm512_cmp_pd_mask(_x, p8d_dbl_min, _CMP_GE_OQ);
+  Packet8d x = _mm512_mask_blend_pd(non_zero_mask, _mm512_rsqrt14_pd(_x),
+                                    _mm512_setzero_pd());
+
+  // Do a first step of Newton's iteration.
+  x = pmul(x, pmadd(neg_half, pmul(x, x), p8d_one_point_five));
+
+  // Do a second step of Newton's iteration.
+  x = pmul(x, pmadd(neg_half, pmul(x, x), p8d_one_point_five));
+
+  // Multiply the original _x by it's reciprocal square root to extract the
+  // square root.
+  return pmul(_x, x);
+}
+#else
+template <>
+EIGEN_STRONG_INLINE Packet16f psqrt<Packet16f>(const Packet16f& x) {
+  return _mm512_sqrt_ps(x);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d psqrt<Packet8d>(const Packet8d& x) {
+  return _mm512_sqrt_pd(x);
+}
+#endif
+
+// Functions for rsqrt.
+// Almost identical to the sqrt routine, just leave out the last multiplication
+// and fill in NaN/Inf where needed. Note that this function only exists as an
+// iterative version for doubles since there is no instruction for diretly
+// computing the reciprocal square root in AVX-512.
+#ifdef EIGEN_FAST_MATH
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16f
+prsqrt<Packet16f>(const Packet16f& _x) {
+  _EIGEN_DECLARE_CONST_Packet16f_FROM_INT(inf, 0x7f800000);
+  _EIGEN_DECLARE_CONST_Packet16f_FROM_INT(nan, 0x7fc00000);
+  _EIGEN_DECLARE_CONST_Packet16f(one_point_five, 1.5f);
+  _EIGEN_DECLARE_CONST_Packet16f(minus_half, -0.5f);
+  _EIGEN_DECLARE_CONST_Packet16f_FROM_INT(flt_min, 0x00800000);
+
+  Packet16f neg_half = pmul(_x, p16f_minus_half);
+
+  // select only the inverse sqrt of positive normal inputs (denormals are
+  // flushed to zero and cause infs as well).
+  __mmask16 le_zero_mask = _mm512_cmp_ps_mask(_x, p16f_flt_min, _CMP_LT_OQ);
+  Packet16f x = _mm512_mask_blend_ps(le_zero_mask, _mm512_setzero_ps(),
+                                     _mm512_rsqrt14_ps(_x));
+
+  // Fill in NaNs and Infs for the negative/zero entries.
+  __mmask16 neg_mask = _mm512_cmp_ps_mask(_x, _mm512_setzero_ps(), _CMP_LT_OQ);
+  Packet16f infs_and_nans = _mm512_mask_blend_ps(
+      neg_mask, p16f_nan,
+      _mm512_mask_blend_ps(le_zero_mask, p16f_inf, _mm512_setzero_ps()));
+
+  // Do a single step of Newton's iteration.
+  x = pmul(x, pmadd(neg_half, pmul(x, x), p16f_one_point_five));
+
+  // Insert NaNs and Infs in all the right places.
+  return _mm512_mask_blend_ps(le_zero_mask, infs_and_nans, x);
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8d
+prsqrt<Packet8d>(const Packet8d& _x) {
+  _EIGEN_DECLARE_CONST_Packet8d_FROM_INT64(inf, 0x7ff0000000000000LL);
+  _EIGEN_DECLARE_CONST_Packet8d_FROM_INT64(nan, 0x7ff1000000000000LL);
+  _EIGEN_DECLARE_CONST_Packet8d(one_point_five, 1.5);
+  _EIGEN_DECLARE_CONST_Packet8d(minus_half, -0.5);
+  _EIGEN_DECLARE_CONST_Packet8d_FROM_INT64(dbl_min, 0x0010000000000000LL);
+
+  Packet8d neg_half = pmul(_x, p8d_minus_half);
+
+  // select only the inverse sqrt of positive normal inputs (denormals are
+  // flushed to zero and cause infs as well).
+  __mmask8 le_zero_mask = _mm512_cmp_pd_mask(_x, p8d_dbl_min, _CMP_LT_OQ);
+  Packet8d x = _mm512_mask_blend_pd(le_zero_mask, _mm512_setzero_pd(),
+                                    _mm512_rsqrt14_pd(_x));
+
+  // Fill in NaNs and Infs for the negative/zero entries.
+  __mmask8 neg_mask = _mm512_cmp_pd_mask(_x, _mm512_setzero_pd(), _CMP_LT_OQ);
+  Packet8d infs_and_nans = _mm512_mask_blend_pd(
+      neg_mask, p8d_nan,
+      _mm512_mask_blend_pd(le_zero_mask, p8d_inf, _mm512_setzero_pd()));
+
+  // Do a first step of Newton's iteration.
+  x = pmul(x, pmadd(neg_half, pmul(x, x), p8d_one_point_five));
+
+  // Do a second step of Newton's iteration.
+  x = pmul(x, pmadd(neg_half, pmul(x, x), p8d_one_point_five));
+
+  // Insert NaNs and Infs in all the right places.
+  return _mm512_mask_blend_pd(le_zero_mask, infs_and_nans, x);
+}
+#else
+template <>
+EIGEN_STRONG_INLINE Packet16f prsqrt<Packet16f>(const Packet16f& x) {
+  return _mm512_rsqrt28_ps(x);
+}
+#endif
+#endif
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // THIRD_PARTY_EIGEN3_EIGEN_SRC_CORE_ARCH_AVX512_MATHFUNCTIONS_H_
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/AVX512/PacketMath.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/AVX512/PacketMath.h
new file mode 100644
index 00000000..12b89757
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/AVX512/PacketMath.h
@@ -0,0 +1,1286 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Benoit Steiner (benoit.steiner.goog@gmail.com)
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PACKET_MATH_AVX512_H
+#define EIGEN_PACKET_MATH_AVX512_H
+
+namespace Eigen {
+
+namespace internal {
+
+#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
+#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8
+#endif
+
+#ifndef EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS
+#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS (2*sizeof(void*))
+#endif
+
+#ifdef __FMA__
+#ifndef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#define EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#endif
+#endif
+
+typedef __m512 Packet16f;
+typedef __m512i Packet16i;
+typedef __m512d Packet8d;
+
+template <>
+struct is_arithmetic<__m512> {
+  enum { value = true };
+};
+template <>
+struct is_arithmetic<__m512i> {
+  enum { value = true };
+};
+template <>
+struct is_arithmetic<__m512d> {
+  enum { value = true };
+};
+
+template<> struct packet_traits<float>  : default_packet_traits
+{
+  typedef Packet16f type;
+  typedef Packet8f half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 16,
+    HasHalfPacket = 1,
+#if EIGEN_GNUC_AT_LEAST(5, 3)
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+    HasLog = 1,
+#endif
+    HasExp = 1,
+    HasSqrt = EIGEN_FAST_MATH,
+    HasRsqrt = EIGEN_FAST_MATH,
+#endif
+    HasDiv = 1
+  };
+ };
+template<> struct packet_traits<double> : default_packet_traits
+{
+  typedef Packet8d type;
+  typedef Packet4d half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 8,
+    HasHalfPacket = 1,
+#if EIGEN_GNUC_AT_LEAST(5, 3)
+    HasSqrt = EIGEN_FAST_MATH,
+    HasRsqrt = EIGEN_FAST_MATH,
+#endif
+    HasDiv = 1
+  };
+};
+
+/* TODO Implement AVX512 for integers
+template<> struct packet_traits<int>    : default_packet_traits
+{
+  typedef Packet16i type;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=8
+  };
+};
+*/
+
+template <>
+struct unpacket_traits<Packet16f> {
+  typedef float type;
+  typedef Packet8f half;
+  enum { size = 16, alignment=Aligned64 };
+};
+template <>
+struct unpacket_traits<Packet8d> {
+  typedef double type;
+  typedef Packet4d half;
+  enum { size = 8, alignment=Aligned64 };
+};
+template <>
+struct unpacket_traits<Packet16i> {
+  typedef int type;
+  typedef Packet8i half;
+  enum { size = 16, alignment=Aligned64 };
+};
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pset1<Packet16f>(const float& from) {
+  return _mm512_set1_ps(from);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pset1<Packet8d>(const double& from) {
+  return _mm512_set1_pd(from);
+}
+template <>
+EIGEN_STRONG_INLINE Packet16i pset1<Packet16i>(const int& from) {
+  return _mm512_set1_epi32(from);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pload1<Packet16f>(const float* from) {
+  return _mm512_broadcastss_ps(_mm_load_ps1(from));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pload1<Packet8d>(const double* from) {
+  return _mm512_broadcastsd_pd(_mm_load_pd1(from));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f plset<Packet16f>(const float& a) {
+  return _mm512_add_ps(
+      _mm512_set1_ps(a),
+      _mm512_set_ps(15.0f, 14.0f, 13.0f, 12.0f, 11.0f, 10.0f, 9.0f, 8.0f, 7.0f, 6.0f, 5.0f,
+                    4.0f, 3.0f, 2.0f, 1.0f, 0.0f));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d plset<Packet8d>(const double& a) {
+  return _mm512_add_pd(_mm512_set1_pd(a),
+                       _mm512_set_pd(7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0, 0.0));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f padd<Packet16f>(const Packet16f& a,
+                                              const Packet16f& b) {
+  return _mm512_add_ps(a, b);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d padd<Packet8d>(const Packet8d& a,
+                                            const Packet8d& b) {
+  return _mm512_add_pd(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f psub<Packet16f>(const Packet16f& a,
+                                              const Packet16f& b) {
+  return _mm512_sub_ps(a, b);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d psub<Packet8d>(const Packet8d& a,
+                                            const Packet8d& b) {
+  return _mm512_sub_pd(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pnegate(const Packet16f& a) {
+  return _mm512_sub_ps(_mm512_set1_ps(0.0), a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pnegate(const Packet8d& a) {
+  return _mm512_sub_pd(_mm512_set1_pd(0.0), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pconj(const Packet16f& a) {
+  return a;
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pconj(const Packet8d& a) {
+  return a;
+}
+template <>
+EIGEN_STRONG_INLINE Packet16i pconj(const Packet16i& a) {
+  return a;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pmul<Packet16f>(const Packet16f& a,
+                                              const Packet16f& b) {
+  return _mm512_mul_ps(a, b);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pmul<Packet8d>(const Packet8d& a,
+                                            const Packet8d& b) {
+  return _mm512_mul_pd(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pdiv<Packet16f>(const Packet16f& a,
+                                              const Packet16f& b) {
+  return _mm512_div_ps(a, b);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pdiv<Packet8d>(const Packet8d& a,
+                                            const Packet8d& b) {
+  return _mm512_div_pd(a, b);
+}
+
+#ifdef __FMA__
+template <>
+EIGEN_STRONG_INLINE Packet16f pmadd(const Packet16f& a, const Packet16f& b,
+                                    const Packet16f& c) {
+  return _mm512_fmadd_ps(a, b, c);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pmadd(const Packet8d& a, const Packet8d& b,
+                                   const Packet8d& c) {
+  return _mm512_fmadd_pd(a, b, c);
+}
+#endif
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pmin<Packet16f>(const Packet16f& a,
+                                              const Packet16f& b) {
+  // Arguments are reversed to match NaN propagation behavior of std::min.
+  return _mm512_min_ps(b, a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pmin<Packet8d>(const Packet8d& a,
+                                            const Packet8d& b) {
+  // Arguments are reversed to match NaN propagation behavior of std::min.
+  return _mm512_min_pd(b, a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pmax<Packet16f>(const Packet16f& a,
+                                              const Packet16f& b) {
+  // Arguments are reversed to match NaN propagation behavior of std::max.
+  return _mm512_max_ps(b, a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pmax<Packet8d>(const Packet8d& a,
+                                            const Packet8d& b) {
+  // Arguments are reversed to match NaN propagation behavior of std::max.
+  return _mm512_max_pd(b, a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pand<Packet16f>(const Packet16f& a,
+                                              const Packet16f& b) {
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+  return _mm512_and_ps(a, b);
+#else
+  Packet16f res = _mm512_undefined_ps();
+  Packet4f lane0_a = _mm512_extractf32x4_ps(a, 0);
+  Packet4f lane0_b = _mm512_extractf32x4_ps(b, 0);
+  res = _mm512_insertf32x4(res, _mm_and_ps(lane0_a, lane0_b), 0);
+
+  Packet4f lane1_a = _mm512_extractf32x4_ps(a, 1);
+  Packet4f lane1_b = _mm512_extractf32x4_ps(b, 1);
+  res = _mm512_insertf32x4(res, _mm_and_ps(lane1_a, lane1_b), 1);
+
+  Packet4f lane2_a = _mm512_extractf32x4_ps(a, 2);
+  Packet4f lane2_b = _mm512_extractf32x4_ps(b, 2);
+  res = _mm512_insertf32x4(res, _mm_and_ps(lane2_a, lane2_b), 2);
+
+  Packet4f lane3_a = _mm512_extractf32x4_ps(a, 3);
+  Packet4f lane3_b = _mm512_extractf32x4_ps(b, 3);
+  res = _mm512_insertf32x4(res, _mm_and_ps(lane3_a, lane3_b), 3);
+
+  return res;
+#endif
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pand<Packet8d>(const Packet8d& a,
+                                            const Packet8d& b) {
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+  return _mm512_and_pd(a, b);
+#else
+  Packet8d res = _mm512_undefined_pd();
+  Packet4d lane0_a = _mm512_extractf64x4_pd(a, 0);
+  Packet4d lane0_b = _mm512_extractf64x4_pd(b, 0);
+  res = _mm512_insertf64x4(res, _mm256_and_pd(lane0_a, lane0_b), 0);
+
+  Packet4d lane1_a = _mm512_extractf64x4_pd(a, 1);
+  Packet4d lane1_b = _mm512_extractf64x4_pd(b, 1);
+  res = _mm512_insertf64x4(res, _mm256_and_pd(lane1_a, lane1_b), 1);
+
+  return res;
+#endif
+}
+template <>
+EIGEN_STRONG_INLINE Packet16f por<Packet16f>(const Packet16f& a,
+                                             const Packet16f& b) {
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+  return _mm512_or_ps(a, b);
+#else
+  Packet16f res = _mm512_undefined_ps();
+  Packet4f lane0_a = _mm512_extractf32x4_ps(a, 0);
+  Packet4f lane0_b = _mm512_extractf32x4_ps(b, 0);
+  res = _mm512_insertf32x4(res, _mm_or_ps(lane0_a, lane0_b), 0);
+
+  Packet4f lane1_a = _mm512_extractf32x4_ps(a, 1);
+  Packet4f lane1_b = _mm512_extractf32x4_ps(b, 1);
+  res = _mm512_insertf32x4(res, _mm_or_ps(lane1_a, lane1_b), 1);
+
+  Packet4f lane2_a = _mm512_extractf32x4_ps(a, 2);
+  Packet4f lane2_b = _mm512_extractf32x4_ps(b, 2);
+  res = _mm512_insertf32x4(res, _mm_or_ps(lane2_a, lane2_b), 2);
+
+  Packet4f lane3_a = _mm512_extractf32x4_ps(a, 3);
+  Packet4f lane3_b = _mm512_extractf32x4_ps(b, 3);
+  res = _mm512_insertf32x4(res, _mm_or_ps(lane3_a, lane3_b), 3);
+
+  return res;
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8d por<Packet8d>(const Packet8d& a,
+                                           const Packet8d& b) {
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+  return _mm512_or_pd(a, b);
+#else
+  Packet8d res = _mm512_undefined_pd();
+  Packet4d lane0_a = _mm512_extractf64x4_pd(a, 0);
+  Packet4d lane0_b = _mm512_extractf64x4_pd(b, 0);
+  res = _mm512_insertf64x4(res, _mm256_or_pd(lane0_a, lane0_b), 0);
+
+  Packet4d lane1_a = _mm512_extractf64x4_pd(a, 1);
+  Packet4d lane1_b = _mm512_extractf64x4_pd(b, 1);
+  res = _mm512_insertf64x4(res, _mm256_or_pd(lane1_a, lane1_b), 1);
+
+  return res;
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pxor<Packet16f>(const Packet16f& a,
+                                              const Packet16f& b) {
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+  return _mm512_xor_ps(a, b);
+#else
+  Packet16f res = _mm512_undefined_ps();
+  Packet4f lane0_a = _mm512_extractf32x4_ps(a, 0);
+  Packet4f lane0_b = _mm512_extractf32x4_ps(b, 0);
+  res = _mm512_insertf32x4(res, _mm_xor_ps(lane0_a, lane0_b), 0);
+
+  Packet4f lane1_a = _mm512_extractf32x4_ps(a, 1);
+  Packet4f lane1_b = _mm512_extractf32x4_ps(b, 1);
+  res = _mm512_insertf32x4(res, _mm_xor_ps(lane1_a, lane1_b), 1);
+
+  Packet4f lane2_a = _mm512_extractf32x4_ps(a, 2);
+  Packet4f lane2_b = _mm512_extractf32x4_ps(b, 2);
+  res = _mm512_insertf32x4(res, _mm_xor_ps(lane2_a, lane2_b), 2);
+
+  Packet4f lane3_a = _mm512_extractf32x4_ps(a, 3);
+  Packet4f lane3_b = _mm512_extractf32x4_ps(b, 3);
+  res = _mm512_insertf32x4(res, _mm_xor_ps(lane3_a, lane3_b), 3);
+
+  return res;
+#endif
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pxor<Packet8d>(const Packet8d& a,
+                                            const Packet8d& b) {
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+  return _mm512_xor_pd(a, b);
+#else
+  Packet8d res = _mm512_undefined_pd();
+  Packet4d lane0_a = _mm512_extractf64x4_pd(a, 0);
+  Packet4d lane0_b = _mm512_extractf64x4_pd(b, 0);
+  res = _mm512_insertf64x4(res, _mm256_xor_pd(lane0_a, lane0_b), 0);
+
+  Packet4d lane1_a = _mm512_extractf64x4_pd(a, 1);
+  Packet4d lane1_b = _mm512_extractf64x4_pd(b, 1);
+  res = _mm512_insertf64x4(res, _mm256_xor_pd(lane1_a, lane1_b), 1);
+
+  return res;
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pandnot<Packet16f>(const Packet16f& a,
+                                                 const Packet16f& b) {
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+  return _mm512_andnot_ps(a, b);
+#else
+  Packet16f res = _mm512_undefined_ps();
+  Packet4f lane0_a = _mm512_extractf32x4_ps(a, 0);
+  Packet4f lane0_b = _mm512_extractf32x4_ps(b, 0);
+  res = _mm512_insertf32x4(res, _mm_andnot_ps(lane0_a, lane0_b), 0);
+
+  Packet4f lane1_a = _mm512_extractf32x4_ps(a, 1);
+  Packet4f lane1_b = _mm512_extractf32x4_ps(b, 1);
+  res = _mm512_insertf32x4(res, _mm_andnot_ps(lane1_a, lane1_b), 1);
+
+  Packet4f lane2_a = _mm512_extractf32x4_ps(a, 2);
+  Packet4f lane2_b = _mm512_extractf32x4_ps(b, 2);
+  res = _mm512_insertf32x4(res, _mm_andnot_ps(lane2_a, lane2_b), 2);
+
+  Packet4f lane3_a = _mm512_extractf32x4_ps(a, 3);
+  Packet4f lane3_b = _mm512_extractf32x4_ps(b, 3);
+  res = _mm512_insertf32x4(res, _mm_andnot_ps(lane3_a, lane3_b), 3);
+
+  return res;
+#endif
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pandnot<Packet8d>(const Packet8d& a,
+                                               const Packet8d& b) {
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+  return _mm512_andnot_pd(a, b);
+#else
+  Packet8d res = _mm512_undefined_pd();
+  Packet4d lane0_a = _mm512_extractf64x4_pd(a, 0);
+  Packet4d lane0_b = _mm512_extractf64x4_pd(b, 0);
+  res = _mm512_insertf64x4(res, _mm256_andnot_pd(lane0_a, lane0_b), 0);
+
+  Packet4d lane1_a = _mm512_extractf64x4_pd(a, 1);
+  Packet4d lane1_b = _mm512_extractf64x4_pd(b, 1);
+  res = _mm512_insertf64x4(res, _mm256_andnot_pd(lane1_a, lane1_b), 1);
+
+  return res;
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pload<Packet16f>(const float* from) {
+  EIGEN_DEBUG_ALIGNED_LOAD return _mm512_load_ps(from);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pload<Packet8d>(const double* from) {
+  EIGEN_DEBUG_ALIGNED_LOAD return _mm512_load_pd(from);
+}
+template <>
+EIGEN_STRONG_INLINE Packet16i pload<Packet16i>(const int* from) {
+  EIGEN_DEBUG_ALIGNED_LOAD return _mm512_load_si512(
+      reinterpret_cast<const __m512i*>(from));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f ploadu<Packet16f>(const float* from) {
+  EIGEN_DEBUG_UNALIGNED_LOAD return _mm512_loadu_ps(from);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d ploadu<Packet8d>(const double* from) {
+  EIGEN_DEBUG_UNALIGNED_LOAD return _mm512_loadu_pd(from);
+}
+template <>
+EIGEN_STRONG_INLINE Packet16i ploadu<Packet16i>(const int* from) {
+  EIGEN_DEBUG_UNALIGNED_LOAD return _mm512_loadu_si512(
+      reinterpret_cast<const __m512i*>(from));
+}
+
+// Loads 8 floats from memory a returns the packet
+// {a0, a0  a1, a1, a2, a2, a3, a3, a4, a4, a5, a5, a6, a6, a7, a7}
+template <>
+EIGEN_STRONG_INLINE Packet16f ploaddup<Packet16f>(const float* from) {
+  __m256i low_half = _mm256_load_si256(reinterpret_cast<const __m256i*>(from));
+  __m512 even_elements = _mm512_castsi512_ps(_mm512_cvtepu32_epi64(low_half));
+  __m512 pairs = _mm512_permute_ps(even_elements, _MM_SHUFFLE(2, 2, 0, 0));
+  return pairs;
+}
+// Loads 4 doubles from memory a returns the packet {a0, a0  a1, a1, a2, a2, a3,
+// a3}
+template <>
+EIGEN_STRONG_INLINE Packet8d ploaddup<Packet8d>(const double* from) {
+ __m512d x = _mm512_setzero_pd();
+  x = _mm512_insertf64x2(x, _mm_loaddup_pd(&from[0]), 0);
+  x = _mm512_insertf64x2(x, _mm_loaddup_pd(&from[1]), 1);
+  x = _mm512_insertf64x2(x, _mm_loaddup_pd(&from[2]), 2);
+  x = _mm512_insertf64x2(x, _mm_loaddup_pd(&from[3]), 3);
+  return x;
+}
+
+// Loads 4 floats from memory a returns the packet
+// {a0, a0  a0, a0, a1, a1, a1, a1, a2, a2, a2, a2, a3, a3, a3, a3}
+template <>
+EIGEN_STRONG_INLINE Packet16f ploadquad<Packet16f>(const float* from) {
+  Packet16f tmp = _mm512_undefined_ps();
+  tmp = _mm512_insertf32x4(tmp, _mm_load_ps1(from), 0);
+  tmp = _mm512_insertf32x4(tmp, _mm_load_ps1(from + 1), 1);
+  tmp = _mm512_insertf32x4(tmp, _mm_load_ps1(from + 2), 2);
+  tmp = _mm512_insertf32x4(tmp, _mm_load_ps1(from + 3), 3);
+  return tmp;
+}
+// Loads 2 doubles from memory a returns the packet
+// {a0, a0  a0, a0, a1, a1, a1, a1}
+template <>
+EIGEN_STRONG_INLINE Packet8d ploadquad<Packet8d>(const double* from) {
+  __m128d tmp0 = _mm_load_pd1(from);
+  __m256d lane0 = _mm256_broadcastsd_pd(tmp0);
+  __m128d tmp1 = _mm_load_pd1(from + 1);
+  __m256d lane1 = _mm256_broadcastsd_pd(tmp1);
+  __m512d tmp = _mm512_undefined_pd();
+  tmp = _mm512_insertf64x4(tmp, lane0, 0);
+  return _mm512_insertf64x4(tmp, lane1, 1);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<float>(float* to, const Packet16f& from) {
+  EIGEN_DEBUG_ALIGNED_STORE _mm512_store_ps(to, from);
+}
+template <>
+EIGEN_STRONG_INLINE void pstore<double>(double* to, const Packet8d& from) {
+  EIGEN_DEBUG_ALIGNED_STORE _mm512_store_pd(to, from);
+}
+template <>
+EIGEN_STRONG_INLINE void pstore<int>(int* to, const Packet16i& from) {
+  EIGEN_DEBUG_ALIGNED_STORE _mm512_storeu_si512(reinterpret_cast<__m512i*>(to),
+                                                from);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<float>(float* to, const Packet16f& from) {
+  EIGEN_DEBUG_UNALIGNED_STORE _mm512_storeu_ps(to, from);
+}
+template <>
+EIGEN_STRONG_INLINE void pstoreu<double>(double* to, const Packet8d& from) {
+  EIGEN_DEBUG_UNALIGNED_STORE _mm512_storeu_pd(to, from);
+}
+template <>
+EIGEN_STRONG_INLINE void pstoreu<int>(int* to, const Packet16i& from) {
+  EIGEN_DEBUG_UNALIGNED_STORE _mm512_storeu_si512(
+      reinterpret_cast<__m512i*>(to), from);
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline Packet16f pgather<float, Packet16f>(const float* from,
+                                                             Index stride) {
+  Packet16i stride_vector = _mm512_set1_epi32(stride);
+  Packet16i stride_multiplier =
+      _mm512_set_epi32(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  Packet16i indices = _mm512_mullo_epi32(stride_vector, stride_multiplier);
+
+  return _mm512_i32gather_ps(indices, from, 4);
+}
+template <>
+EIGEN_DEVICE_FUNC inline Packet8d pgather<double, Packet8d>(const double* from,
+                                                            Index stride) {
+  Packet8i stride_vector = _mm256_set1_epi32(stride);
+  Packet8i stride_multiplier = _mm256_set_epi32(7, 6, 5, 4, 3, 2, 1, 0);
+  Packet8i indices = _mm256_mullo_epi32(stride_vector, stride_multiplier);
+
+  return _mm512_i32gather_pd(indices, from, 8);
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline void pscatter<float, Packet16f>(float* to,
+                                                         const Packet16f& from,
+                                                         Index stride) {
+  Packet16i stride_vector = _mm512_set1_epi32(stride);
+  Packet16i stride_multiplier =
+      _mm512_set_epi32(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  Packet16i indices = _mm512_mullo_epi32(stride_vector, stride_multiplier);
+  _mm512_i32scatter_ps(to, indices, from, 4);
+}
+template <>
+EIGEN_DEVICE_FUNC inline void pscatter<double, Packet8d>(double* to,
+                                                         const Packet8d& from,
+                                                         Index stride) {
+  Packet8i stride_vector = _mm256_set1_epi32(stride);
+  Packet8i stride_multiplier = _mm256_set_epi32(7, 6, 5, 4, 3, 2, 1, 0);
+  Packet8i indices = _mm256_mullo_epi32(stride_vector, stride_multiplier);
+  _mm512_i32scatter_pd(to, indices, from, 8);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore1<Packet16f>(float* to, const float& a) {
+  Packet16f pa = pset1<Packet16f>(a);
+  pstore(to, pa);
+}
+template <>
+EIGEN_STRONG_INLINE void pstore1<Packet8d>(double* to, const double& a) {
+  Packet8d pa = pset1<Packet8d>(a);
+  pstore(to, pa);
+}
+template <>
+EIGEN_STRONG_INLINE void pstore1<Packet16i>(int* to, const int& a) {
+  Packet16i pa = pset1<Packet16i>(a);
+  pstore(to, pa);
+}
+
+template<> EIGEN_STRONG_INLINE void prefetch<float>(const float*   addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); }
+template<> EIGEN_STRONG_INLINE void prefetch<double>(const double* addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); }
+template<> EIGEN_STRONG_INLINE void prefetch<int>(const int*       addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); }
+
+template <>
+EIGEN_STRONG_INLINE float pfirst<Packet16f>(const Packet16f& a) {
+  return _mm_cvtss_f32(_mm512_extractf32x4_ps(a, 0));
+}
+template <>
+EIGEN_STRONG_INLINE double pfirst<Packet8d>(const Packet8d& a) {
+  return _mm_cvtsd_f64(_mm256_extractf128_pd(_mm512_extractf64x4_pd(a, 0), 0));
+}
+template <>
+EIGEN_STRONG_INLINE int pfirst<Packet16i>(const Packet16i& a) {
+  return _mm_extract_epi32(_mm512_extracti32x4_epi32(a, 0), 0);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16f preverse(const Packet16f& a)
+{
+  return _mm512_permutexvar_ps(_mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15), a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8d preverse(const Packet8d& a)
+{
+  return _mm512_permutexvar_pd(_mm512_set_epi32(0, 0, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7), a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16f pabs(const Packet16f& a)
+{
+  // _mm512_abs_ps intrinsic not found, so hack around it
+  return (__m512)_mm512_and_si512((__m512i)a, _mm512_set1_epi32(0x7fffffff));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pabs(const Packet8d& a) {
+  // _mm512_abs_ps intrinsic not found, so hack around it
+  return (__m512d)_mm512_and_si512((__m512i)a,
+                                   _mm512_set1_epi64(0x7fffffffffffffff));
+}
+
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+// AVX512F does not define _mm512_extractf32x8_ps to extract _m256 from _m512
+#define EIGEN_EXTRACT_8f_FROM_16f(INPUT, OUTPUT)                           \
+  __m256 OUTPUT##_0 = _mm512_extractf32x8_ps(INPUT, 0);                    \
+  __m256 OUTPUT##_1 = _mm512_extractf32x8_ps(INPUT, 1)
+#else
+#define EIGEN_EXTRACT_8f_FROM_16f(INPUT, OUTPUT)                \
+  __m256 OUTPUT##_0 = _mm256_insertf128_ps(                     \
+      _mm256_castps128_ps256(_mm512_extractf32x4_ps(INPUT, 0)), \
+      _mm512_extractf32x4_ps(INPUT, 1), 1);                     \
+  __m256 OUTPUT##_1 = _mm256_insertf128_ps(                     \
+      _mm256_castps128_ps256(_mm512_extractf32x4_ps(INPUT, 2)), \
+      _mm512_extractf32x4_ps(INPUT, 3), 1);
+#endif
+
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+#define EIGEN_INSERT_8f_INTO_16f(OUTPUT, INPUTA, INPUTB) \
+  OUTPUT = _mm512_insertf32x8(OUTPUT, INPUTA, 0);        \
+  OUTPUT = _mm512_insertf32x8(OUTPUT, INPUTB, 1);
+#else
+#define EIGEN_INSERT_8f_INTO_16f(OUTPUT, INPUTA, INPUTB)                    \
+  OUTPUT = _mm512_insertf32x4(OUTPUT, _mm256_extractf128_ps(INPUTA, 0), 0); \
+  OUTPUT = _mm512_insertf32x4(OUTPUT, _mm256_extractf128_ps(INPUTA, 1), 1); \
+  OUTPUT = _mm512_insertf32x4(OUTPUT, _mm256_extractf128_ps(INPUTB, 0), 2); \
+  OUTPUT = _mm512_insertf32x4(OUTPUT, _mm256_extractf128_ps(INPUTB, 1), 3);
+#endif
+template<> EIGEN_STRONG_INLINE Packet16f preduxp<Packet16f>(const Packet16f*
+vecs)
+{
+  EIGEN_EXTRACT_8f_FROM_16f(vecs[0], vecs0);
+  EIGEN_EXTRACT_8f_FROM_16f(vecs[1], vecs1);
+  EIGEN_EXTRACT_8f_FROM_16f(vecs[2], vecs2);
+  EIGEN_EXTRACT_8f_FROM_16f(vecs[3], vecs3);
+  EIGEN_EXTRACT_8f_FROM_16f(vecs[4], vecs4);
+  EIGEN_EXTRACT_8f_FROM_16f(vecs[5], vecs5);
+  EIGEN_EXTRACT_8f_FROM_16f(vecs[6], vecs6);
+  EIGEN_EXTRACT_8f_FROM_16f(vecs[7], vecs7);
+  EIGEN_EXTRACT_8f_FROM_16f(vecs[8], vecs8);
+  EIGEN_EXTRACT_8f_FROM_16f(vecs[9], vecs9);
+  EIGEN_EXTRACT_8f_FROM_16f(vecs[10], vecs10);
+  EIGEN_EXTRACT_8f_FROM_16f(vecs[11], vecs11);
+  EIGEN_EXTRACT_8f_FROM_16f(vecs[12], vecs12);
+  EIGEN_EXTRACT_8f_FROM_16f(vecs[13], vecs13);
+  EIGEN_EXTRACT_8f_FROM_16f(vecs[14], vecs14);
+  EIGEN_EXTRACT_8f_FROM_16f(vecs[15], vecs15);
+
+  __m256 hsum1 = _mm256_hadd_ps(vecs0_0, vecs1_0);
+  __m256 hsum2 = _mm256_hadd_ps(vecs2_0, vecs3_0);
+  __m256 hsum3 = _mm256_hadd_ps(vecs4_0, vecs5_0);
+  __m256 hsum4 = _mm256_hadd_ps(vecs6_0, vecs7_0);
+
+  __m256 hsum5 = _mm256_hadd_ps(hsum1, hsum1);
+  __m256 hsum6 = _mm256_hadd_ps(hsum2, hsum2);
+  __m256 hsum7 = _mm256_hadd_ps(hsum3, hsum3);
+  __m256 hsum8 = _mm256_hadd_ps(hsum4, hsum4);
+
+  __m256 perm1 = _mm256_permute2f128_ps(hsum5, hsum5, 0x23);
+  __m256 perm2 = _mm256_permute2f128_ps(hsum6, hsum6, 0x23);
+  __m256 perm3 = _mm256_permute2f128_ps(hsum7, hsum7, 0x23);
+  __m256 perm4 = _mm256_permute2f128_ps(hsum8, hsum8, 0x23);
+
+  __m256 sum1 = _mm256_add_ps(perm1, hsum5);
+  __m256 sum2 = _mm256_add_ps(perm2, hsum6);
+  __m256 sum3 = _mm256_add_ps(perm3, hsum7);
+  __m256 sum4 = _mm256_add_ps(perm4, hsum8);
+
+  __m256 blend1 = _mm256_blend_ps(sum1, sum2, 0xcc);
+  __m256 blend2 = _mm256_blend_ps(sum3, sum4, 0xcc);
+
+  __m256 final = _mm256_blend_ps(blend1, blend2, 0xf0);
+
+  hsum1 = _mm256_hadd_ps(vecs0_1, vecs1_1);
+  hsum2 = _mm256_hadd_ps(vecs2_1, vecs3_1);
+  hsum3 = _mm256_hadd_ps(vecs4_1, vecs5_1);
+  hsum4 = _mm256_hadd_ps(vecs6_1, vecs7_1);
+
+  hsum5 = _mm256_hadd_ps(hsum1, hsum1);
+  hsum6 = _mm256_hadd_ps(hsum2, hsum2);
+  hsum7 = _mm256_hadd_ps(hsum3, hsum3);
+  hsum8 = _mm256_hadd_ps(hsum4, hsum4);
+
+  perm1 = _mm256_permute2f128_ps(hsum5, hsum5, 0x23);
+  perm2 = _mm256_permute2f128_ps(hsum6, hsum6, 0x23);
+  perm3 = _mm256_permute2f128_ps(hsum7, hsum7, 0x23);
+  perm4 = _mm256_permute2f128_ps(hsum8, hsum8, 0x23);
+
+  sum1 = _mm256_add_ps(perm1, hsum5);
+  sum2 = _mm256_add_ps(perm2, hsum6);
+  sum3 = _mm256_add_ps(perm3, hsum7);
+  sum4 = _mm256_add_ps(perm4, hsum8);
+
+  blend1 = _mm256_blend_ps(sum1, sum2, 0xcc);
+  blend2 = _mm256_blend_ps(sum3, sum4, 0xcc);
+
+  final = _mm256_add_ps(final, _mm256_blend_ps(blend1, blend2, 0xf0));
+
+  hsum1 = _mm256_hadd_ps(vecs8_0, vecs9_0);
+  hsum2 = _mm256_hadd_ps(vecs10_0, vecs11_0);
+  hsum3 = _mm256_hadd_ps(vecs12_0, vecs13_0);
+  hsum4 = _mm256_hadd_ps(vecs14_0, vecs15_0);
+
+  hsum5 = _mm256_hadd_ps(hsum1, hsum1);
+  hsum6 = _mm256_hadd_ps(hsum2, hsum2);
+  hsum7 = _mm256_hadd_ps(hsum3, hsum3);
+  hsum8 = _mm256_hadd_ps(hsum4, hsum4);
+
+  perm1 = _mm256_permute2f128_ps(hsum5, hsum5, 0x23);
+  perm2 = _mm256_permute2f128_ps(hsum6, hsum6, 0x23);
+  perm3 = _mm256_permute2f128_ps(hsum7, hsum7, 0x23);
+  perm4 = _mm256_permute2f128_ps(hsum8, hsum8, 0x23);
+
+  sum1 = _mm256_add_ps(perm1, hsum5);
+  sum2 = _mm256_add_ps(perm2, hsum6);
+  sum3 = _mm256_add_ps(perm3, hsum7);
+  sum4 = _mm256_add_ps(perm4, hsum8);
+
+  blend1 = _mm256_blend_ps(sum1, sum2, 0xcc);
+  blend2 = _mm256_blend_ps(sum3, sum4, 0xcc);
+
+  __m256 final_1 = _mm256_blend_ps(blend1, blend2, 0xf0);
+
+  hsum1 = _mm256_hadd_ps(vecs8_1, vecs9_1);
+  hsum2 = _mm256_hadd_ps(vecs10_1, vecs11_1);
+  hsum3 = _mm256_hadd_ps(vecs12_1, vecs13_1);
+  hsum4 = _mm256_hadd_ps(vecs14_1, vecs15_1);
+
+  hsum5 = _mm256_hadd_ps(hsum1, hsum1);
+  hsum6 = _mm256_hadd_ps(hsum2, hsum2);
+  hsum7 = _mm256_hadd_ps(hsum3, hsum3);
+  hsum8 = _mm256_hadd_ps(hsum4, hsum4);
+
+  perm1 = _mm256_permute2f128_ps(hsum5, hsum5, 0x23);
+  perm2 = _mm256_permute2f128_ps(hsum6, hsum6, 0x23);
+  perm3 = _mm256_permute2f128_ps(hsum7, hsum7, 0x23);
+  perm4 = _mm256_permute2f128_ps(hsum8, hsum8, 0x23);
+
+  sum1 = _mm256_add_ps(perm1, hsum5);
+  sum2 = _mm256_add_ps(perm2, hsum6);
+  sum3 = _mm256_add_ps(perm3, hsum7);
+  sum4 = _mm256_add_ps(perm4, hsum8);
+
+  blend1 = _mm256_blend_ps(sum1, sum2, 0xcc);
+  blend2 = _mm256_blend_ps(sum3, sum4, 0xcc);
+
+  final_1 = _mm256_add_ps(final_1, _mm256_blend_ps(blend1, blend2, 0xf0));
+
+  __m512 final_output;
+
+  EIGEN_INSERT_8f_INTO_16f(final_output, final, final_1);
+  return final_output;
+}
+
+template<> EIGEN_STRONG_INLINE Packet8d preduxp<Packet8d>(const Packet8d* vecs)
+{
+  Packet4d vecs0_0 = _mm512_extractf64x4_pd(vecs[0], 0);
+  Packet4d vecs0_1 = _mm512_extractf64x4_pd(vecs[0], 1);
+
+  Packet4d vecs1_0 = _mm512_extractf64x4_pd(vecs[1], 0);
+  Packet4d vecs1_1 = _mm512_extractf64x4_pd(vecs[1], 1);
+
+  Packet4d vecs2_0 = _mm512_extractf64x4_pd(vecs[2], 0);
+  Packet4d vecs2_1 = _mm512_extractf64x4_pd(vecs[2], 1);
+
+  Packet4d vecs3_0 = _mm512_extractf64x4_pd(vecs[3], 0);
+  Packet4d vecs3_1 = _mm512_extractf64x4_pd(vecs[3], 1);
+
+  Packet4d vecs4_0 = _mm512_extractf64x4_pd(vecs[4], 0);
+  Packet4d vecs4_1 = _mm512_extractf64x4_pd(vecs[4], 1);
+
+  Packet4d vecs5_0 = _mm512_extractf64x4_pd(vecs[5], 0);
+  Packet4d vecs5_1 = _mm512_extractf64x4_pd(vecs[5], 1);
+
+  Packet4d vecs6_0 = _mm512_extractf64x4_pd(vecs[6], 0);
+  Packet4d vecs6_1 = _mm512_extractf64x4_pd(vecs[6], 1);
+
+  Packet4d vecs7_0 = _mm512_extractf64x4_pd(vecs[7], 0);
+  Packet4d vecs7_1 = _mm512_extractf64x4_pd(vecs[7], 1);
+
+  Packet4d tmp0, tmp1;
+
+  tmp0 = _mm256_hadd_pd(vecs0_0, vecs1_0);
+  tmp0 = _mm256_add_pd(tmp0, _mm256_permute2f128_pd(tmp0, tmp0, 1));
+
+  tmp1 = _mm256_hadd_pd(vecs2_0, vecs3_0);
+  tmp1 = _mm256_add_pd(tmp1, _mm256_permute2f128_pd(tmp1, tmp1, 1));
+
+  __m256d final_0 = _mm256_blend_pd(tmp0, tmp1, 0xC);
+
+  tmp0 = _mm256_hadd_pd(vecs0_1, vecs1_1);
+  tmp0 = _mm256_add_pd(tmp0, _mm256_permute2f128_pd(tmp0, tmp0, 1));
+
+  tmp1 = _mm256_hadd_pd(vecs2_1, vecs3_1);
+  tmp1 = _mm256_add_pd(tmp1, _mm256_permute2f128_pd(tmp1, tmp1, 1));
+
+  final_0 = _mm256_add_pd(final_0, _mm256_blend_pd(tmp0, tmp1, 0xC));
+
+  tmp0 = _mm256_hadd_pd(vecs4_0, vecs5_0);
+  tmp0 = _mm256_add_pd(tmp0, _mm256_permute2f128_pd(tmp0, tmp0, 1));
+
+  tmp1 = _mm256_hadd_pd(vecs6_0, vecs7_0);
+  tmp1 = _mm256_add_pd(tmp1, _mm256_permute2f128_pd(tmp1, tmp1, 1));
+
+  __m256d final_1 = _mm256_blend_pd(tmp0, tmp1, 0xC);
+
+  tmp0 = _mm256_hadd_pd(vecs4_1, vecs5_1);
+  tmp0 = _mm256_add_pd(tmp0, _mm256_permute2f128_pd(tmp0, tmp0, 1));
+
+  tmp1 = _mm256_hadd_pd(vecs6_1, vecs7_1);
+  tmp1 = _mm256_add_pd(tmp1, _mm256_permute2f128_pd(tmp1, tmp1, 1));
+
+  final_1 = _mm256_add_pd(final_1, _mm256_blend_pd(tmp0, tmp1, 0xC));
+
+  __m512d final_output = _mm512_insertf64x4(final_output, final_0, 0);
+
+  return _mm512_insertf64x4(final_output, final_1, 1);
+}
+
+template <>
+EIGEN_STRONG_INLINE float predux<Packet16f>(const Packet16f& a) {
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+  __m256 lane0 = _mm512_extractf32x8_ps(a, 0);
+  __m256 lane1 = _mm512_extractf32x8_ps(a, 1);
+  Packet8f x = _mm256_add_ps(lane0, lane1);
+  return predux<Packet8f>(x);
+#else
+  __m128 lane0 = _mm512_extractf32x4_ps(a, 0);
+  __m128 lane1 = _mm512_extractf32x4_ps(a, 1);
+  __m128 lane2 = _mm512_extractf32x4_ps(a, 2);
+  __m128 lane3 = _mm512_extractf32x4_ps(a, 3);
+  __m128 sum = _mm_add_ps(_mm_add_ps(lane0, lane1), _mm_add_ps(lane2, lane3));
+  sum = _mm_hadd_ps(sum, sum);
+  sum = _mm_hadd_ps(sum, _mm_permute_ps(sum, 1));
+  return _mm_cvtss_f32(sum);
+#endif
+}
+template <>
+EIGEN_STRONG_INLINE double predux<Packet8d>(const Packet8d& a) {
+  __m256d lane0 = _mm512_extractf64x4_pd(a, 0);
+  __m256d lane1 = _mm512_extractf64x4_pd(a, 1);
+  __m256d sum = _mm256_add_pd(lane0, lane1);
+  __m256d tmp0 = _mm256_hadd_pd(sum, _mm256_permute2f128_pd(sum, sum, 1));
+  return _mm_cvtsd_f64(_mm256_castpd256_pd128(_mm256_hadd_pd(tmp0, tmp0)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8f predux_downto4<Packet16f>(const Packet16f& a) {
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+  __m256 lane0 = _mm512_extractf32x8_ps(a, 0);
+  __m256 lane1 = _mm512_extractf32x8_ps(a, 1);
+  return _mm256_add_ps(lane0, lane1);
+#else
+  __m128 lane0 = _mm512_extractf32x4_ps(a, 0);
+  __m128 lane1 = _mm512_extractf32x4_ps(a, 1);
+  __m128 lane2 = _mm512_extractf32x4_ps(a, 2);
+  __m128 lane3 = _mm512_extractf32x4_ps(a, 3);
+  __m128 sum0 = _mm_add_ps(lane0, lane2);
+  __m128 sum1 = _mm_add_ps(lane1, lane3);
+  return _mm256_insertf128_ps(_mm256_castps128_ps256(sum0), sum1, 1);
+#endif
+}
+template <>
+EIGEN_STRONG_INLINE Packet4d predux_downto4<Packet8d>(const Packet8d& a) {
+  __m256d lane0 = _mm512_extractf64x4_pd(a, 0);
+  __m256d lane1 = _mm512_extractf64x4_pd(a, 1);
+  __m256d res = _mm256_add_pd(lane0, lane1);
+  return res;
+}
+
+template <>
+EIGEN_STRONG_INLINE float predux_mul<Packet16f>(const Packet16f& a) {
+//#ifdef EIGEN_VECTORIZE_AVX512DQ
+#if 0
+  Packet8f lane0 = _mm512_extractf32x8_ps(a, 0);
+  Packet8f lane1 = _mm512_extractf32x8_ps(a, 1);
+  Packet8f res = pmul(lane0, lane1);
+  res = pmul(res, _mm256_permute2f128_ps(res, res, 1));
+  res = pmul(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 3, 2)));
+  return pfirst(pmul(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 0, 1))));
+#else
+  __m128 lane0 = _mm512_extractf32x4_ps(a, 0);
+  __m128 lane1 = _mm512_extractf32x4_ps(a, 1);
+  __m128 lane2 = _mm512_extractf32x4_ps(a, 2);
+  __m128 lane3 = _mm512_extractf32x4_ps(a, 3);
+  __m128 res = pmul(pmul(lane0, lane1), pmul(lane2, lane3));
+  res = pmul(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 3, 2)));
+  return pfirst(pmul(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 0, 1))));
+#endif
+}
+template <>
+EIGEN_STRONG_INLINE double predux_mul<Packet8d>(const Packet8d& a) {
+  __m256d lane0 = _mm512_extractf64x4_pd(a, 0);
+  __m256d lane1 = _mm512_extractf64x4_pd(a, 1);
+  __m256d res = pmul(lane0, lane1);
+  res = pmul(res, _mm256_permute2f128_pd(res, res, 1));
+  return pfirst(pmul(res, _mm256_shuffle_pd(res, res, 1)));
+}
+
+template <>
+EIGEN_STRONG_INLINE float predux_min<Packet16f>(const Packet16f& a) {
+  __m128 lane0 = _mm512_extractf32x4_ps(a, 0);
+  __m128 lane1 = _mm512_extractf32x4_ps(a, 1);
+  __m128 lane2 = _mm512_extractf32x4_ps(a, 2);
+  __m128 lane3 = _mm512_extractf32x4_ps(a, 3);
+  __m128 res = _mm_min_ps(_mm_min_ps(lane0, lane1), _mm_min_ps(lane2, lane3));
+  res = _mm_min_ps(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 3, 2)));
+  return pfirst(_mm_min_ps(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 0, 1))));
+}
+template <>
+EIGEN_STRONG_INLINE double predux_min<Packet8d>(const Packet8d& a) {
+  __m256d lane0 = _mm512_extractf64x4_pd(a, 0);
+  __m256d lane1 = _mm512_extractf64x4_pd(a, 1);
+  __m256d res = _mm256_min_pd(lane0, lane1);
+  res = _mm256_min_pd(res, _mm256_permute2f128_pd(res, res, 1));
+  return pfirst(_mm256_min_pd(res, _mm256_shuffle_pd(res, res, 1)));
+}
+
+template <>
+EIGEN_STRONG_INLINE float predux_max<Packet16f>(const Packet16f& a) {
+  __m128 lane0 = _mm512_extractf32x4_ps(a, 0);
+  __m128 lane1 = _mm512_extractf32x4_ps(a, 1);
+  __m128 lane2 = _mm512_extractf32x4_ps(a, 2);
+  __m128 lane3 = _mm512_extractf32x4_ps(a, 3);
+  __m128 res = _mm_max_ps(_mm_max_ps(lane0, lane1), _mm_max_ps(lane2, lane3));
+  res = _mm_max_ps(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 3, 2)));
+  return pfirst(_mm_max_ps(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 0, 1))));
+}
+
+template <>
+EIGEN_STRONG_INLINE double predux_max<Packet8d>(const Packet8d& a) {
+  __m256d lane0 = _mm512_extractf64x4_pd(a, 0);
+  __m256d lane1 = _mm512_extractf64x4_pd(a, 1);
+  __m256d res = _mm256_max_pd(lane0, lane1);
+  res = _mm256_max_pd(res, _mm256_permute2f128_pd(res, res, 1));
+  return pfirst(_mm256_max_pd(res, _mm256_shuffle_pd(res, res, 1)));
+}
+
+template <int Offset>
+struct palign_impl<Offset, Packet16f> {
+  static EIGEN_STRONG_INLINE void run(Packet16f& first,
+                                      const Packet16f& second) {
+    if (Offset != 0) {
+      __m512i first_idx = _mm512_set_epi32(
+          Offset + 15, Offset + 14, Offset + 13, Offset + 12, Offset + 11,
+          Offset + 10, Offset + 9, Offset + 8, Offset + 7, Offset + 6,
+          Offset + 5, Offset + 4, Offset + 3, Offset + 2, Offset + 1, Offset);
+
+      __m512i second_idx =
+          _mm512_set_epi32(Offset - 1, Offset - 2, Offset - 3, Offset - 4,
+                           Offset - 5, Offset - 6, Offset - 7, Offset - 8,
+                           Offset - 9, Offset - 10, Offset - 11, Offset - 12,
+                           Offset - 13, Offset - 14, Offset - 15, Offset - 16);
+
+      unsigned short mask = 0xFFFF;
+      mask <<= (16 - Offset);
+
+      first = _mm512_permutexvar_ps(first_idx, first);
+      Packet16f tmp = _mm512_permutexvar_ps(second_idx, second);
+      first = _mm512_mask_blend_ps(mask, first, tmp);
+    }
+  }
+};
+template <int Offset>
+struct palign_impl<Offset, Packet8d> {
+  static EIGEN_STRONG_INLINE void run(Packet8d& first, const Packet8d& second) {
+    if (Offset != 0) {
+      __m512i first_idx = _mm512_set_epi32(
+          0, Offset + 7, 0, Offset + 6, 0, Offset + 5, 0, Offset + 4, 0,
+          Offset + 3, 0, Offset + 2, 0, Offset + 1, 0, Offset);
+
+      __m512i second_idx = _mm512_set_epi32(
+          0, Offset - 1, 0, Offset - 2, 0, Offset - 3, 0, Offset - 4, 0,
+          Offset - 5, 0, Offset - 6, 0, Offset - 7, 0, Offset - 8);
+
+      unsigned char mask = 0xFF;
+      mask <<= (8 - Offset);
+
+      first = _mm512_permutexvar_pd(first_idx, first);
+      Packet8d tmp = _mm512_permutexvar_pd(second_idx, second);
+      first = _mm512_mask_blend_pd(mask, first, tmp);
+    }
+  }
+};
+
+
+#define PACK_OUTPUT(OUTPUT, INPUT, INDEX, STRIDE) \
+  EIGEN_INSERT_8f_INTO_16f(OUTPUT[INDEX], INPUT[INDEX], INPUT[INDEX + STRIDE]);
+
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet16f, 16>& kernel) {
+  __m512 T0 = _mm512_unpacklo_ps(kernel.packet[0], kernel.packet[1]);
+  __m512 T1 = _mm512_unpackhi_ps(kernel.packet[0], kernel.packet[1]);
+  __m512 T2 = _mm512_unpacklo_ps(kernel.packet[2], kernel.packet[3]);
+  __m512 T3 = _mm512_unpackhi_ps(kernel.packet[2], kernel.packet[3]);
+  __m512 T4 = _mm512_unpacklo_ps(kernel.packet[4], kernel.packet[5]);
+  __m512 T5 = _mm512_unpackhi_ps(kernel.packet[4], kernel.packet[5]);
+  __m512 T6 = _mm512_unpacklo_ps(kernel.packet[6], kernel.packet[7]);
+  __m512 T7 = _mm512_unpackhi_ps(kernel.packet[6], kernel.packet[7]);
+  __m512 T8 = _mm512_unpacklo_ps(kernel.packet[8], kernel.packet[9]);
+  __m512 T9 = _mm512_unpackhi_ps(kernel.packet[8], kernel.packet[9]);
+  __m512 T10 = _mm512_unpacklo_ps(kernel.packet[10], kernel.packet[11]);
+  __m512 T11 = _mm512_unpackhi_ps(kernel.packet[10], kernel.packet[11]);
+  __m512 T12 = _mm512_unpacklo_ps(kernel.packet[12], kernel.packet[13]);
+  __m512 T13 = _mm512_unpackhi_ps(kernel.packet[12], kernel.packet[13]);
+  __m512 T14 = _mm512_unpacklo_ps(kernel.packet[14], kernel.packet[15]);
+  __m512 T15 = _mm512_unpackhi_ps(kernel.packet[14], kernel.packet[15]);
+  __m512 S0 = _mm512_shuffle_ps(T0, T2, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S1 = _mm512_shuffle_ps(T0, T2, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S2 = _mm512_shuffle_ps(T1, T3, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S3 = _mm512_shuffle_ps(T1, T3, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S4 = _mm512_shuffle_ps(T4, T6, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S5 = _mm512_shuffle_ps(T4, T6, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S6 = _mm512_shuffle_ps(T5, T7, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S7 = _mm512_shuffle_ps(T5, T7, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S8 = _mm512_shuffle_ps(T8, T10, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S9 = _mm512_shuffle_ps(T8, T10, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S10 = _mm512_shuffle_ps(T9, T11, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S11 = _mm512_shuffle_ps(T9, T11, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S12 = _mm512_shuffle_ps(T12, T14, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S13 = _mm512_shuffle_ps(T12, T14, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S14 = _mm512_shuffle_ps(T13, T15, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S15 = _mm512_shuffle_ps(T13, T15, _MM_SHUFFLE(3, 2, 3, 2));
+
+  EIGEN_EXTRACT_8f_FROM_16f(S0, S0);
+  EIGEN_EXTRACT_8f_FROM_16f(S1, S1);
+  EIGEN_EXTRACT_8f_FROM_16f(S2, S2);
+  EIGEN_EXTRACT_8f_FROM_16f(S3, S3);
+  EIGEN_EXTRACT_8f_FROM_16f(S4, S4);
+  EIGEN_EXTRACT_8f_FROM_16f(S5, S5);
+  EIGEN_EXTRACT_8f_FROM_16f(S6, S6);
+  EIGEN_EXTRACT_8f_FROM_16f(S7, S7);
+  EIGEN_EXTRACT_8f_FROM_16f(S8, S8);
+  EIGEN_EXTRACT_8f_FROM_16f(S9, S9);
+  EIGEN_EXTRACT_8f_FROM_16f(S10, S10);
+  EIGEN_EXTRACT_8f_FROM_16f(S11, S11);
+  EIGEN_EXTRACT_8f_FROM_16f(S12, S12);
+  EIGEN_EXTRACT_8f_FROM_16f(S13, S13);
+  EIGEN_EXTRACT_8f_FROM_16f(S14, S14);
+  EIGEN_EXTRACT_8f_FROM_16f(S15, S15);
+
+  PacketBlock<Packet8f, 32> tmp;
+
+  tmp.packet[0] = _mm256_permute2f128_ps(S0_0, S4_0, 0x20);
+  tmp.packet[1] = _mm256_permute2f128_ps(S1_0, S5_0, 0x20);
+  tmp.packet[2] = _mm256_permute2f128_ps(S2_0, S6_0, 0x20);
+  tmp.packet[3] = _mm256_permute2f128_ps(S3_0, S7_0, 0x20);
+  tmp.packet[4] = _mm256_permute2f128_ps(S0_0, S4_0, 0x31);
+  tmp.packet[5] = _mm256_permute2f128_ps(S1_0, S5_0, 0x31);
+  tmp.packet[6] = _mm256_permute2f128_ps(S2_0, S6_0, 0x31);
+  tmp.packet[7] = _mm256_permute2f128_ps(S3_0, S7_0, 0x31);
+
+  tmp.packet[8] = _mm256_permute2f128_ps(S0_1, S4_1, 0x20);
+  tmp.packet[9] = _mm256_permute2f128_ps(S1_1, S5_1, 0x20);
+  tmp.packet[10] = _mm256_permute2f128_ps(S2_1, S6_1, 0x20);
+  tmp.packet[11] = _mm256_permute2f128_ps(S3_1, S7_1, 0x20);
+  tmp.packet[12] = _mm256_permute2f128_ps(S0_1, S4_1, 0x31);
+  tmp.packet[13] = _mm256_permute2f128_ps(S1_1, S5_1, 0x31);
+  tmp.packet[14] = _mm256_permute2f128_ps(S2_1, S6_1, 0x31);
+  tmp.packet[15] = _mm256_permute2f128_ps(S3_1, S7_1, 0x31);
+
+  // Second set of _m256 outputs
+  tmp.packet[16] = _mm256_permute2f128_ps(S8_0, S12_0, 0x20);
+  tmp.packet[17] = _mm256_permute2f128_ps(S9_0, S13_0, 0x20);
+  tmp.packet[18] = _mm256_permute2f128_ps(S10_0, S14_0, 0x20);
+  tmp.packet[19] = _mm256_permute2f128_ps(S11_0, S15_0, 0x20);
+  tmp.packet[20] = _mm256_permute2f128_ps(S8_0, S12_0, 0x31);
+  tmp.packet[21] = _mm256_permute2f128_ps(S9_0, S13_0, 0x31);
+  tmp.packet[22] = _mm256_permute2f128_ps(S10_0, S14_0, 0x31);
+  tmp.packet[23] = _mm256_permute2f128_ps(S11_0, S15_0, 0x31);
+
+  tmp.packet[24] = _mm256_permute2f128_ps(S8_1, S12_1, 0x20);
+  tmp.packet[25] = _mm256_permute2f128_ps(S9_1, S13_1, 0x20);
+  tmp.packet[26] = _mm256_permute2f128_ps(S10_1, S14_1, 0x20);
+  tmp.packet[27] = _mm256_permute2f128_ps(S11_1, S15_1, 0x20);
+  tmp.packet[28] = _mm256_permute2f128_ps(S8_1, S12_1, 0x31);
+  tmp.packet[29] = _mm256_permute2f128_ps(S9_1, S13_1, 0x31);
+  tmp.packet[30] = _mm256_permute2f128_ps(S10_1, S14_1, 0x31);
+  tmp.packet[31] = _mm256_permute2f128_ps(S11_1, S15_1, 0x31);
+
+  // Pack them into the output
+  PACK_OUTPUT(kernel.packet, tmp.packet, 0, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 1, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 2, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 3, 16);
+
+  PACK_OUTPUT(kernel.packet, tmp.packet, 4, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 5, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 6, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 7, 16);
+
+  PACK_OUTPUT(kernel.packet, tmp.packet, 8, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 9, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 10, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 11, 16);
+
+  PACK_OUTPUT(kernel.packet, tmp.packet, 12, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 13, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 14, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 15, 16);
+}
+#define PACK_OUTPUT_2(OUTPUT, INPUT, INDEX, STRIDE)         \
+  EIGEN_INSERT_8f_INTO_16f(OUTPUT[INDEX], INPUT[2 * INDEX], \
+                           INPUT[2 * INDEX + STRIDE]);
+
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet16f, 4>& kernel) {
+  __m512 T0 = _mm512_unpacklo_ps(kernel.packet[0], kernel.packet[1]);
+  __m512 T1 = _mm512_unpackhi_ps(kernel.packet[0], kernel.packet[1]);
+  __m512 T2 = _mm512_unpacklo_ps(kernel.packet[2], kernel.packet[3]);
+  __m512 T3 = _mm512_unpackhi_ps(kernel.packet[2], kernel.packet[3]);
+
+  __m512 S0 = _mm512_shuffle_ps(T0, T2, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S1 = _mm512_shuffle_ps(T0, T2, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S2 = _mm512_shuffle_ps(T1, T3, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S3 = _mm512_shuffle_ps(T1, T3, _MM_SHUFFLE(3, 2, 3, 2));
+
+  EIGEN_EXTRACT_8f_FROM_16f(S0, S0);
+  EIGEN_EXTRACT_8f_FROM_16f(S1, S1);
+  EIGEN_EXTRACT_8f_FROM_16f(S2, S2);
+  EIGEN_EXTRACT_8f_FROM_16f(S3, S3);
+
+  PacketBlock<Packet8f, 8> tmp;
+
+  tmp.packet[0] = _mm256_permute2f128_ps(S0_0, S1_0, 0x20);
+  tmp.packet[1] = _mm256_permute2f128_ps(S2_0, S3_0, 0x20);
+  tmp.packet[2] = _mm256_permute2f128_ps(S0_0, S1_0, 0x31);
+  tmp.packet[3] = _mm256_permute2f128_ps(S2_0, S3_0, 0x31);
+
+  tmp.packet[4] = _mm256_permute2f128_ps(S0_1, S1_1, 0x20);
+  tmp.packet[5] = _mm256_permute2f128_ps(S2_1, S3_1, 0x20);
+  tmp.packet[6] = _mm256_permute2f128_ps(S0_1, S1_1, 0x31);
+  tmp.packet[7] = _mm256_permute2f128_ps(S2_1, S3_1, 0x31);
+
+  PACK_OUTPUT_2(kernel.packet, tmp.packet, 0, 1);
+  PACK_OUTPUT_2(kernel.packet, tmp.packet, 1, 1);
+  PACK_OUTPUT_2(kernel.packet, tmp.packet, 2, 1);
+  PACK_OUTPUT_2(kernel.packet, tmp.packet, 3, 1);
+}
+
+#define PACK_OUTPUT_SQ_D(OUTPUT, INPUT, INDEX, STRIDE)                \
+  OUTPUT[INDEX] = _mm512_insertf64x4(OUTPUT[INDEX], INPUT[INDEX], 0); \
+  OUTPUT[INDEX] = _mm512_insertf64x4(OUTPUT[INDEX], INPUT[INDEX + STRIDE], 1);
+
+#define PACK_OUTPUT_D(OUTPUT, INPUT, INDEX, STRIDE)                         \
+  OUTPUT[INDEX] = _mm512_insertf64x4(OUTPUT[INDEX], INPUT[(2 * INDEX)], 0); \
+  OUTPUT[INDEX] =                                                           \
+      _mm512_insertf64x4(OUTPUT[INDEX], INPUT[(2 * INDEX) + STRIDE], 1);
+
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet8d, 4>& kernel) {
+  __m512d T0 = _mm512_shuffle_pd(kernel.packet[0], kernel.packet[1], 0);
+  __m512d T1 = _mm512_shuffle_pd(kernel.packet[0], kernel.packet[1], 0xff);
+  __m512d T2 = _mm512_shuffle_pd(kernel.packet[2], kernel.packet[3], 0);
+  __m512d T3 = _mm512_shuffle_pd(kernel.packet[2], kernel.packet[3], 0xff);
+
+  PacketBlock<Packet4d, 8> tmp;
+
+  tmp.packet[0] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 0),
+                                         _mm512_extractf64x4_pd(T2, 0), 0x20);
+  tmp.packet[1] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 0),
+                                         _mm512_extractf64x4_pd(T3, 0), 0x20);
+  tmp.packet[2] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 0),
+                                         _mm512_extractf64x4_pd(T2, 0), 0x31);
+  tmp.packet[3] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 0),
+                                         _mm512_extractf64x4_pd(T3, 0), 0x31);
+
+  tmp.packet[4] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 1),
+                                         _mm512_extractf64x4_pd(T2, 1), 0x20);
+  tmp.packet[5] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 1),
+                                         _mm512_extractf64x4_pd(T3, 1), 0x20);
+  tmp.packet[6] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 1),
+                                         _mm512_extractf64x4_pd(T2, 1), 0x31);
+  tmp.packet[7] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 1),
+                                         _mm512_extractf64x4_pd(T3, 1), 0x31);
+
+  PACK_OUTPUT_D(kernel.packet, tmp.packet, 0, 1);
+  PACK_OUTPUT_D(kernel.packet, tmp.packet, 1, 1);
+  PACK_OUTPUT_D(kernel.packet, tmp.packet, 2, 1);
+  PACK_OUTPUT_D(kernel.packet, tmp.packet, 3, 1);
+}
+
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet8d, 8>& kernel) {
+  __m512d T0 = _mm512_unpacklo_pd(kernel.packet[0], kernel.packet[1]);
+  __m512d T1 = _mm512_unpackhi_pd(kernel.packet[0], kernel.packet[1]);
+  __m512d T2 = _mm512_unpacklo_pd(kernel.packet[2], kernel.packet[3]);
+  __m512d T3 = _mm512_unpackhi_pd(kernel.packet[2], kernel.packet[3]);
+  __m512d T4 = _mm512_unpacklo_pd(kernel.packet[4], kernel.packet[5]);
+  __m512d T5 = _mm512_unpackhi_pd(kernel.packet[4], kernel.packet[5]);
+  __m512d T6 = _mm512_unpacklo_pd(kernel.packet[6], kernel.packet[7]);
+  __m512d T7 = _mm512_unpackhi_pd(kernel.packet[6], kernel.packet[7]);
+
+  PacketBlock<Packet4d, 16> tmp;
+
+  tmp.packet[0] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 0),
+                                         _mm512_extractf64x4_pd(T2, 0), 0x20);
+  tmp.packet[1] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 0),
+                                         _mm512_extractf64x4_pd(T3, 0), 0x20);
+  tmp.packet[2] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 0),
+                                         _mm512_extractf64x4_pd(T2, 0), 0x31);
+  tmp.packet[3] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 0),
+                                         _mm512_extractf64x4_pd(T3, 0), 0x31);
+
+  tmp.packet[4] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 1),
+                                         _mm512_extractf64x4_pd(T2, 1), 0x20);
+  tmp.packet[5] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 1),
+                                         _mm512_extractf64x4_pd(T3, 1), 0x20);
+  tmp.packet[6] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 1),
+                                         _mm512_extractf64x4_pd(T2, 1), 0x31);
+  tmp.packet[7] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 1),
+                                         _mm512_extractf64x4_pd(T3, 1), 0x31);
+
+  tmp.packet[8] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T4, 0),
+                                         _mm512_extractf64x4_pd(T6, 0), 0x20);
+  tmp.packet[9] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T5, 0),
+                                         _mm512_extractf64x4_pd(T7, 0), 0x20);
+  tmp.packet[10] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T4, 0),
+                                          _mm512_extractf64x4_pd(T6, 0), 0x31);
+  tmp.packet[11] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T5, 0),
+                                          _mm512_extractf64x4_pd(T7, 0), 0x31);
+
+  tmp.packet[12] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T4, 1),
+                                          _mm512_extractf64x4_pd(T6, 1), 0x20);
+  tmp.packet[13] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T5, 1),
+                                          _mm512_extractf64x4_pd(T7, 1), 0x20);
+  tmp.packet[14] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T4, 1),
+                                          _mm512_extractf64x4_pd(T6, 1), 0x31);
+  tmp.packet[15] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T5, 1),
+                                          _mm512_extractf64x4_pd(T7, 1), 0x31);
+
+  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 0, 8);
+  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 1, 8);
+  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 2, 8);
+  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 3, 8);
+
+  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 4, 8);
+  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 5, 8);
+  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 6, 8);
+  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 7, 8);
+}
+template <>
+EIGEN_STRONG_INLINE Packet16f pblend(const Selector<16>& /*ifPacket*/,
+                                     const Packet16f& /*thenPacket*/,
+                                     const Packet16f& /*elsePacket*/) {
+  assert(false && "To be implemented");
+  return Packet16f();
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pblend(const Selector<8>& /*ifPacket*/,
+                                    const Packet8d& /*thenPacket*/,
+                                    const Packet8d& /*elsePacket*/) {
+  assert(false && "To be implemented");
+  return Packet8d();
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_PACKET_MATH_AVX512_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/AltiVec/Complex.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/AltiVec/Complex.h
new file mode 100644
index 00000000..3e665730
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/AltiVec/Complex.h
@@ -0,0 +1,430 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010-2016 Konstantinos Margaritis <markos@freevec.org>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLEX32_ALTIVEC_H
+#define EIGEN_COMPLEX32_ALTIVEC_H
+
+namespace Eigen {
+
+namespace internal {
+
+static Packet4ui  p4ui_CONJ_XOR = vec_mergeh((Packet4ui)p4i_ZERO, (Packet4ui)p4f_MZERO);//{ 0x00000000, 0x80000000, 0x00000000, 0x80000000 };
+#ifdef __VSX__
+#if defined(_BIG_ENDIAN)
+static Packet2ul  p2ul_CONJ_XOR1 = (Packet2ul) vec_sld((Packet4ui) p2d_MZERO, (Packet4ui) p2l_ZERO, 8);//{ 0x8000000000000000, 0x0000000000000000 };
+static Packet2ul  p2ul_CONJ_XOR2 = (Packet2ul) vec_sld((Packet4ui) p2l_ZERO,  (Packet4ui) p2d_MZERO, 8);//{ 0x8000000000000000, 0x0000000000000000 };
+#else
+static Packet2ul  p2ul_CONJ_XOR1 = (Packet2ul) vec_sld((Packet4ui) p2l_ZERO,  (Packet4ui) p2d_MZERO, 8);//{ 0x8000000000000000, 0x0000000000000000 };
+static Packet2ul  p2ul_CONJ_XOR2 = (Packet2ul) vec_sld((Packet4ui) p2d_MZERO, (Packet4ui) p2l_ZERO, 8);//{ 0x8000000000000000, 0x0000000000000000 };
+#endif
+#endif
+
+//---------- float ----------
+struct Packet2cf
+{
+  EIGEN_STRONG_INLINE explicit Packet2cf() : v(p4f_ZERO) {}
+  EIGEN_STRONG_INLINE explicit Packet2cf(const Packet4f& a) : v(a) {}
+  Packet4f  v;
+};
+
+template<> struct packet_traits<std::complex<float> >  : default_packet_traits
+{
+  typedef Packet2cf type;
+  typedef Packet2cf half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 2,
+    HasHalfPacket = 0,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+#ifdef __VSX__
+    HasBlend  = 1,
+#endif
+    HasSetLinear = 0
+  };
+};
+
+template<> struct unpacket_traits<Packet2cf> { typedef std::complex<float> type; enum {size=2, alignment=Aligned16}; typedef Packet2cf half; };
+
+template<> EIGEN_STRONG_INLINE Packet2cf pset1<Packet2cf>(const std::complex<float>&  from)
+{
+  Packet2cf res;
+  if((std::ptrdiff_t(&from) % 16) == 0)
+    res.v = pload<Packet4f>((const float *)&from);
+  else
+    res.v = ploadu<Packet4f>((const float *)&from);
+  res.v = vec_perm(res.v, res.v, p16uc_PSET64_HI);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pload<Packet2cf>(const std::complex<float>*        from) { return Packet2cf(pload<Packet4f>((const float *) from)); }
+template<> EIGEN_STRONG_INLINE Packet2cf ploadu<Packet2cf>(const std::complex<float>*       from) { return Packet2cf(ploadu<Packet4f>((const float*) from)); }
+template<> EIGEN_STRONG_INLINE Packet2cf ploaddup<Packet2cf>(const std::complex<float>*     from) { return pset1<Packet2cf>(*from); }
+
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<float> >(std::complex<float> *   to, const Packet2cf& from) { pstore((float*)to, from.v); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<float> >(std::complex<float> *   to, const Packet2cf& from) { pstoreu((float*)to, from.v); }
+
+template<> EIGEN_DEVICE_FUNC inline Packet2cf pgather<std::complex<float>, Packet2cf>(const std::complex<float>* from, Index stride)
+{
+  std::complex<float> EIGEN_ALIGN16 af[2];
+  af[0] = from[0*stride];
+  af[1] = from[1*stride];
+  return pload<Packet2cf>(af);
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<float>, Packet2cf>(std::complex<float>* to, const Packet2cf& from, Index stride)
+{
+  std::complex<float> EIGEN_ALIGN16 af[2];
+  pstore<std::complex<float> >((std::complex<float> *) af, from);
+  to[0*stride] = af[0];
+  to[1*stride] = af[1];
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf padd<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(a.v + b.v); }
+template<> EIGEN_STRONG_INLINE Packet2cf psub<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(a.v - b.v); }
+template<> EIGEN_STRONG_INLINE Packet2cf pnegate(const Packet2cf& a) { return Packet2cf(pnegate(a.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pconj(const Packet2cf& a) { return Packet2cf(pxor<Packet4f>(a.v, reinterpret_cast<Packet4f>(p4ui_CONJ_XOR))); }
+
+template<> EIGEN_STRONG_INLINE Packet2cf pmul<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{
+  Packet4f v1, v2;
+
+  // Permute and multiply the real parts of a and b
+  v1 = vec_perm(a.v, a.v, p16uc_PSET32_WODD);
+  // Get the imaginary parts of a
+  v2 = vec_perm(a.v, a.v, p16uc_PSET32_WEVEN);
+  // multiply a_re * b 
+  v1 = vec_madd(v1, b.v, p4f_ZERO);
+  // multiply a_im * b and get the conjugate result
+  v2 = vec_madd(v2, b.v, p4f_ZERO);
+  v2 = reinterpret_cast<Packet4f>(pxor(v2, reinterpret_cast<Packet4f>(p4ui_CONJ_XOR)));
+  // permute back to a proper order
+  v2 = vec_perm(v2, v2, p16uc_COMPLEX32_REV);
+  
+  return Packet2cf(padd<Packet4f>(v1, v2));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pand   <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(pand<Packet4f>(a.v, b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf por    <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(por<Packet4f>(a.v, b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pxor   <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(pxor<Packet4f>(a.v, b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pandnot<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(pandnot<Packet4f>(a.v, b.v)); }
+
+template<> EIGEN_STRONG_INLINE void prefetch<std::complex<float> >(const std::complex<float> * addr)    { EIGEN_PPC_PREFETCH(addr); }
+
+template<> EIGEN_STRONG_INLINE std::complex<float>  pfirst<Packet2cf>(const Packet2cf& a)
+{
+  std::complex<float> EIGEN_ALIGN16 res[2];
+  pstore((float *)&res, a.v);
+
+  return res[0];
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf preverse(const Packet2cf& a)
+{
+  Packet4f rev_a;
+  rev_a = vec_perm(a.v, a.v, p16uc_COMPLEX32_REV2);
+  return Packet2cf(rev_a);
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux<Packet2cf>(const Packet2cf& a)
+{
+  Packet4f b;
+  b = vec_sld(a.v, a.v, 8);
+  b = padd<Packet4f>(a.v, b);
+  return pfirst<Packet2cf>(Packet2cf(b));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf preduxp<Packet2cf>(const Packet2cf* vecs)
+{
+  Packet4f b1, b2;
+#ifdef _BIG_ENDIAN  
+  b1 = vec_sld(vecs[0].v, vecs[1].v, 8);
+  b2 = vec_sld(vecs[1].v, vecs[0].v, 8);
+#else
+  b1 = vec_sld(vecs[1].v, vecs[0].v, 8);
+  b2 = vec_sld(vecs[0].v, vecs[1].v, 8);
+#endif
+  b2 = vec_sld(b2, b2, 8);
+  b2 = padd<Packet4f>(b1, b2);
+
+  return Packet2cf(b2);
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet2cf>(const Packet2cf& a)
+{
+  Packet4f b;
+  Packet2cf prod;
+  b = vec_sld(a.v, a.v, 8);
+  prod = pmul<Packet2cf>(a, Packet2cf(b));
+
+  return pfirst<Packet2cf>(prod);
+}
+
+template<int Offset>
+struct palign_impl<Offset,Packet2cf>
+{
+  static EIGEN_STRONG_INLINE void run(Packet2cf& first, const Packet2cf& second)
+  {
+    if (Offset==1)
+    {
+#ifdef _BIG_ENDIAN
+      first.v = vec_sld(first.v, second.v, 8);
+#else
+      first.v = vec_sld(second.v, first.v, 8);
+#endif
+    }
+  }
+};
+
+template<> struct conj_helper<Packet2cf, Packet2cf, false,true>
+{
+  EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf& y, const Packet2cf& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& b) const
+  {
+    return internal::pmul(a, pconj(b));
+  }
+};
+
+template<> struct conj_helper<Packet2cf, Packet2cf, true,false>
+{
+  EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf& y, const Packet2cf& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& b) const
+  {
+    return internal::pmul(pconj(a), b);
+  }
+};
+
+template<> struct conj_helper<Packet2cf, Packet2cf, true,true>
+{
+  EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf& y, const Packet2cf& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& b) const
+  {
+    return pconj(internal::pmul(a, b));
+  }
+};
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet2cf,Packet4f)
+
+template<> EIGEN_STRONG_INLINE Packet2cf pdiv<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{
+  // TODO optimize it for AltiVec
+  Packet2cf res = conj_helper<Packet2cf,Packet2cf,false,true>().pmul(a, b);
+  Packet4f s = pmul<Packet4f>(b.v, b.v);
+  return Packet2cf(pdiv(res.v, padd<Packet4f>(s, vec_perm(s, s, p16uc_COMPLEX32_REV))));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pcplxflip<Packet2cf>(const Packet2cf& x)
+{
+  return Packet2cf(vec_perm(x.v, x.v, p16uc_COMPLEX32_REV));
+}
+
+EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet2cf,2>& kernel)
+{
+  Packet4f tmp = vec_perm(kernel.packet[0].v, kernel.packet[1].v, p16uc_TRANSPOSE64_HI);
+  kernel.packet[1].v = vec_perm(kernel.packet[0].v, kernel.packet[1].v, p16uc_TRANSPOSE64_LO);
+  kernel.packet[0].v = tmp;
+}
+
+#ifdef __VSX__
+template<> EIGEN_STRONG_INLINE Packet2cf pblend(const Selector<2>& ifPacket, const Packet2cf& thenPacket, const Packet2cf& elsePacket) {
+  Packet2cf result;
+  result.v = reinterpret_cast<Packet4f>(pblend<Packet2d>(ifPacket, reinterpret_cast<Packet2d>(thenPacket.v), reinterpret_cast<Packet2d>(elsePacket.v)));
+  return result;
+}
+#endif
+
+//---------- double ----------
+#ifdef __VSX__
+struct Packet1cd
+{
+  EIGEN_STRONG_INLINE Packet1cd() {}
+  EIGEN_STRONG_INLINE explicit Packet1cd(const Packet2d& a) : v(a) {}
+  Packet2d v;
+};
+
+template<> struct packet_traits<std::complex<double> >  : default_packet_traits
+{
+  typedef Packet1cd type;
+  typedef Packet1cd half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 0,
+    size = 1,
+    HasHalfPacket = 0,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasSetLinear = 0
+  };
+};
+
+template<> struct unpacket_traits<Packet1cd> { typedef std::complex<double> type; enum {size=1, alignment=Aligned16}; typedef Packet1cd half; };
+
+template<> EIGEN_STRONG_INLINE Packet1cd pload <Packet1cd>(const std::complex<double>* from) { return Packet1cd(pload<Packet2d>((const double*)from)); }
+template<> EIGEN_STRONG_INLINE Packet1cd ploadu<Packet1cd>(const std::complex<double>* from) { return Packet1cd(ploadu<Packet2d>((const double*)from)); }
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<double> >(std::complex<double> *   to, const Packet1cd& from) { pstore((double*)to, from.v); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<double> >(std::complex<double> *   to, const Packet1cd& from) { pstoreu((double*)to, from.v); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd pset1<Packet1cd>(const std::complex<double>&  from)
+{ /* here we really have to use unaligned loads :( */ return ploadu<Packet1cd>(&from); }
+
+template<> EIGEN_DEVICE_FUNC inline Packet1cd pgather<std::complex<double>, Packet1cd>(const std::complex<double>* from, Index stride)
+{
+  std::complex<double> EIGEN_ALIGN16 af[2];
+  af[0] = from[0*stride];
+  af[1] = from[1*stride];
+  return pload<Packet1cd>(af);
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<double>, Packet1cd>(std::complex<double>* to, const Packet1cd& from, Index stride)
+{
+  std::complex<double> EIGEN_ALIGN16 af[2];
+  pstore<std::complex<double> >(af, from);
+  to[0*stride] = af[0];
+  to[1*stride] = af[1];
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd padd<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(a.v + b.v); }
+template<> EIGEN_STRONG_INLINE Packet1cd psub<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(a.v - b.v); }
+template<> EIGEN_STRONG_INLINE Packet1cd pnegate(const Packet1cd& a) { return Packet1cd(pnegate(Packet2d(a.v))); }
+template<> EIGEN_STRONG_INLINE Packet1cd pconj(const Packet1cd& a) { return Packet1cd(pxor(a.v, reinterpret_cast<Packet2d>(p2ul_CONJ_XOR2))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd pmul<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{
+  Packet2d a_re, a_im, v1, v2;
+
+  // Permute and multiply the real parts of a and b
+  a_re = vec_perm(a.v, a.v, p16uc_PSET64_HI);
+  // Get the imaginary parts of a
+  a_im = vec_perm(a.v, a.v, p16uc_PSET64_LO);
+  // multiply a_re * b
+  v1 = vec_madd(a_re, b.v, p2d_ZERO);
+  // multiply a_im * b and get the conjugate result
+  v2 = vec_madd(a_im, b.v, p2d_ZERO);
+  v2 = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4ui>(v2), reinterpret_cast<Packet4ui>(v2), 8));
+  v2 = pxor(v2, reinterpret_cast<Packet2d>(p2ul_CONJ_XOR1));
+
+  return Packet1cd(padd<Packet2d>(v1, v2));
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd pand   <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(pand(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd por    <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(por(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd pxor   <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(pxor(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd pandnot<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(pandnot(a.v, b.v)); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd ploaddup<Packet1cd>(const std::complex<double>*     from)  { return pset1<Packet1cd>(*from); }
+
+template<> EIGEN_STRONG_INLINE void prefetch<std::complex<double> >(const std::complex<double> * addr)    { EIGEN_PPC_PREFETCH(addr); }
+
+template<> EIGEN_STRONG_INLINE std::complex<double>  pfirst<Packet1cd>(const Packet1cd& a)
+{
+  std::complex<double> EIGEN_ALIGN16 res[2];
+  pstore<std::complex<double> >(res, a);
+
+  return res[0];
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd preverse(const Packet1cd& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE std::complex<double> predux<Packet1cd>(const Packet1cd& a) { return pfirst(a); }
+template<> EIGEN_STRONG_INLINE Packet1cd preduxp<Packet1cd>(const Packet1cd* vecs)        { return vecs[0]; }
+
+template<> EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet1cd>(const Packet1cd& a) { return pfirst(a); }
+
+template<int Offset>
+struct palign_impl<Offset,Packet1cd>
+{
+  static EIGEN_STRONG_INLINE void run(Packet1cd& /*first*/, const Packet1cd& /*second*/)
+  {
+    // FIXME is it sure we never have to align a Packet1cd?
+    // Even though a std::complex<double> has 16 bytes, it is not necessarily aligned on a 16 bytes boundary...
+  }
+};
+
+template<> struct conj_helper<Packet1cd, Packet1cd, false,true>
+{
+  EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd& y, const Packet1cd& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& b) const
+  {
+    return internal::pmul(a, pconj(b));
+  }
+};
+
+template<> struct conj_helper<Packet1cd, Packet1cd, true,false>
+{
+  EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd& y, const Packet1cd& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& b) const
+  {
+    return internal::pmul(pconj(a), b);
+  }
+};
+
+template<> struct conj_helper<Packet1cd, Packet1cd, true,true>
+{
+  EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd& y, const Packet1cd& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& b) const
+  {
+    return pconj(internal::pmul(a, b));
+  }
+};
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet1cd,Packet2d)
+
+template<> EIGEN_STRONG_INLINE Packet1cd pdiv<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{
+  // TODO optimize it for AltiVec
+  Packet1cd res = conj_helper<Packet1cd,Packet1cd,false,true>().pmul(a,b);
+  Packet2d s = pmul<Packet2d>(b.v, b.v);
+  return Packet1cd(pdiv(res.v, padd<Packet2d>(s, vec_perm(s, s, p16uc_REVERSE64))));
+}
+
+EIGEN_STRONG_INLINE Packet1cd pcplxflip/*<Packet1cd>*/(const Packet1cd& x)
+{
+  return Packet1cd(preverse(Packet2d(x.v)));
+}
+
+EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet1cd,2>& kernel)
+{
+  Packet2d tmp = vec_perm(kernel.packet[0].v, kernel.packet[1].v, p16uc_TRANSPOSE64_HI);
+  kernel.packet[1].v = vec_perm(kernel.packet[0].v, kernel.packet[1].v, p16uc_TRANSPOSE64_LO);
+  kernel.packet[0].v = tmp;
+}
+#endif // __VSX__
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_COMPLEX32_ALTIVEC_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/AltiVec/MathFunctions.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/AltiVec/MathFunctions.h
new file mode 100644
index 00000000..c5e4bede
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/AltiVec/MathFunctions.h
@@ -0,0 +1,322 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007 Julien Pommier
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2016 Konstantinos Margaritis <markos@freevec.org>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* The sin, cos, exp, and log functions of this file come from
+ * Julien Pommier's sse math library: http://gruntthepeon.free.fr/ssemath/
+ */
+
+#ifndef EIGEN_MATH_FUNCTIONS_ALTIVEC_H
+#define EIGEN_MATH_FUNCTIONS_ALTIVEC_H
+
+namespace Eigen {
+
+namespace internal {
+
+static _EIGEN_DECLARE_CONST_Packet4f(1 , 1.0f);
+static _EIGEN_DECLARE_CONST_Packet4f(half, 0.5f);
+static _EIGEN_DECLARE_CONST_Packet4i(0x7f, 0x7f);
+static _EIGEN_DECLARE_CONST_Packet4i(23, 23);
+
+static _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(inv_mant_mask, ~0x7f800000);
+
+/* the smallest non denormalized float number */
+static _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(min_norm_pos,  0x00800000);
+static _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(minus_inf,     0xff800000); // -1.f/0.f
+static _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(minus_nan,     0xffffffff);
+  
+/* natural logarithm computed for 4 simultaneous float
+  return NaN for x <= 0
+*/
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_SQRTHF, 0.707106781186547524f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p0, 7.0376836292E-2f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p1, - 1.1514610310E-1f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p2, 1.1676998740E-1f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p3, - 1.2420140846E-1f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p4, + 1.4249322787E-1f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p5, - 1.6668057665E-1f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p6, + 2.0000714765E-1f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p7, - 2.4999993993E-1f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p8, + 3.3333331174E-1f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_q1, -2.12194440e-4f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_q2, 0.693359375f);
+
+static _EIGEN_DECLARE_CONST_Packet4f(exp_hi,  88.3762626647950f);
+static _EIGEN_DECLARE_CONST_Packet4f(exp_lo, -88.3762626647949f);
+
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_LOG2EF, 1.44269504088896341f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_C1, 0.693359375f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_C2, -2.12194440e-4f);
+
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p0, 1.9875691500E-4f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p1, 1.3981999507E-3f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p2, 8.3334519073E-3f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p3, 4.1665795894E-2f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p4, 1.6666665459E-1f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p5, 5.0000001201E-1f);
+
+#ifdef __VSX__
+static _EIGEN_DECLARE_CONST_Packet2d(1 , 1.0);
+static _EIGEN_DECLARE_CONST_Packet2d(2 , 2.0);
+static _EIGEN_DECLARE_CONST_Packet2d(half, 0.5);
+
+static _EIGEN_DECLARE_CONST_Packet2d(exp_hi,  709.437);
+static _EIGEN_DECLARE_CONST_Packet2d(exp_lo, -709.436139303);
+
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_LOG2EF, 1.4426950408889634073599);
+
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_p0, 1.26177193074810590878e-4);
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_p1, 3.02994407707441961300e-2);
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_p2, 9.99999999999999999910e-1);
+
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q0, 3.00198505138664455042e-6);
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q1, 2.52448340349684104192e-3);
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q2, 2.27265548208155028766e-1);
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q3, 2.00000000000000000009e0);
+
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_C1, 0.693145751953125);
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_C2, 1.42860682030941723212e-6);
+
+#ifdef __POWER8_VECTOR__
+static Packet2l p2l_1023 = { 1023, 1023 };
+static Packet2ul p2ul_52 = { 52, 52 };
+#endif
+
+#endif
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f plog<Packet4f>(const Packet4f& _x)
+{
+  Packet4f x = _x;
+
+  Packet4i emm0;
+
+  /* isvalid_mask is 0 if x < 0 or x is NaN. */
+  Packet4ui isvalid_mask = reinterpret_cast<Packet4ui>(vec_cmpge(x, p4f_ZERO));
+  Packet4ui iszero_mask = reinterpret_cast<Packet4ui>(vec_cmpeq(x, p4f_ZERO));
+
+  x = pmax(x, p4f_min_norm_pos);  /* cut off denormalized stuff */
+  emm0 = vec_sr(reinterpret_cast<Packet4i>(x),
+                reinterpret_cast<Packet4ui>(p4i_23));
+
+  /* keep only the fractional part */
+  x = pand(x, p4f_inv_mant_mask);
+  x = por(x, p4f_half);
+
+  emm0 = psub(emm0, p4i_0x7f);
+  Packet4f e = padd(vec_ctf(emm0, 0), p4f_1);
+
+  /* part2:
+     if( x < SQRTHF ) {
+       e -= 1;
+       x = x + x - 1.0;
+     } else { x = x - 1.0; }
+  */
+  Packet4f mask = reinterpret_cast<Packet4f>(vec_cmplt(x, p4f_cephes_SQRTHF));
+  Packet4f tmp = pand(x, mask);
+  x = psub(x, p4f_1);
+  e = psub(e, pand(p4f_1, mask));
+  x = padd(x, tmp);
+
+  Packet4f x2 = pmul(x,x);
+  Packet4f x3 = pmul(x2,x);
+
+  Packet4f y, y1, y2;
+  y  = pmadd(p4f_cephes_log_p0, x, p4f_cephes_log_p1);
+  y1 = pmadd(p4f_cephes_log_p3, x, p4f_cephes_log_p4);
+  y2 = pmadd(p4f_cephes_log_p6, x, p4f_cephes_log_p7);
+  y  = pmadd(y , x, p4f_cephes_log_p2);
+  y1 = pmadd(y1, x, p4f_cephes_log_p5);
+  y2 = pmadd(y2, x, p4f_cephes_log_p8);
+  y = pmadd(y, x3, y1);
+  y = pmadd(y, x3, y2);
+  y = pmul(y, x3);
+
+  y1 = pmul(e, p4f_cephes_log_q1);
+  tmp = pmul(x2, p4f_half);
+  y = padd(y, y1);
+  x = psub(x, tmp);
+  y2 = pmul(e, p4f_cephes_log_q2);
+  x = padd(x, y);
+  x = padd(x, y2);
+  // negative arg will be NAN, 0 will be -INF
+  x = vec_sel(x, p4f_minus_inf, iszero_mask);
+  x = vec_sel(p4f_minus_nan, x, isvalid_mask);
+  return x;
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f pexp<Packet4f>(const Packet4f& _x)
+{
+  Packet4f x = _x;
+
+  Packet4f tmp, fx;
+  Packet4i emm0;
+
+  // clamp x
+  x = pmax(pmin(x, p4f_exp_hi), p4f_exp_lo);
+
+  // express exp(x) as exp(g + n*log(2))
+  fx = pmadd(x, p4f_cephes_LOG2EF, p4f_half);
+
+  fx = pfloor(fx);
+
+  tmp = pmul(fx, p4f_cephes_exp_C1);
+  Packet4f z = pmul(fx, p4f_cephes_exp_C2);
+  x = psub(x, tmp);
+  x = psub(x, z);
+
+  z = pmul(x,x);
+
+  Packet4f y = p4f_cephes_exp_p0;
+  y = pmadd(y, x, p4f_cephes_exp_p1);
+  y = pmadd(y, x, p4f_cephes_exp_p2);
+  y = pmadd(y, x, p4f_cephes_exp_p3);
+  y = pmadd(y, x, p4f_cephes_exp_p4);
+  y = pmadd(y, x, p4f_cephes_exp_p5);
+  y = pmadd(y, z, x);
+  y = padd(y, p4f_1);
+
+  // build 2^n
+  emm0 = vec_cts(fx, 0);
+  emm0 = vec_add(emm0, p4i_0x7f);
+  emm0 = vec_sl(emm0, reinterpret_cast<Packet4ui>(p4i_23));
+
+  // Altivec's max & min operators just drop silent NaNs. Check NaNs in 
+  // inputs and return them unmodified.
+  Packet4ui isnumber_mask = reinterpret_cast<Packet4ui>(vec_cmpeq(_x, _x));
+  return vec_sel(_x, pmax(pmul(y, reinterpret_cast<Packet4f>(emm0)), _x),
+                 isnumber_mask);
+}
+
+#ifndef EIGEN_COMP_CLANG
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f prsqrt<Packet4f>(const Packet4f& x)
+{
+  return  vec_rsqrt(x);
+}
+#endif
+
+#ifdef __VSX__
+#ifndef EIGEN_COMP_CLANG
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d prsqrt<Packet2d>(const Packet2d& x)
+{
+  return  vec_rsqrt(x);
+}
+#endif
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f psqrt<Packet4f>(const Packet4f& x)
+{
+  return  vec_sqrt(x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d psqrt<Packet2d>(const Packet2d& x)
+{
+  return  vec_sqrt(x);
+}
+
+// VSX support varies between different compilers and even different
+// versions of the same compiler.  For gcc version >= 4.9.3, we can use
+// vec_cts to efficiently convert Packet2d to Packet2l.  Otherwise, use
+// a slow version that works with older compilers. 
+// Update: apparently vec_cts/vec_ctf intrinsics for 64-bit doubles
+// are buggy, https://gcc.gnu.org/bugzilla/show_bug.cgi?id=70963
+static inline Packet2l ConvertToPacket2l(const Packet2d& x) {
+#if EIGEN_GNUC_AT_LEAST(5, 4) || \
+    (EIGEN_GNUC_AT(6, 1) && __GNUC_PATCHLEVEL__ >= 1)
+  return vec_cts(x, 0);    // TODO: check clang version.
+#else
+  double tmp[2];
+  memcpy(tmp, &x, sizeof(tmp));
+  Packet2l l = { static_cast<long long>(tmp[0]),
+                 static_cast<long long>(tmp[1]) };
+  return l;
+#endif
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d pexp<Packet2d>(const Packet2d& _x)
+{
+  Packet2d x = _x;
+
+  Packet2d tmp, fx;
+  Packet2l emm0;
+
+  // clamp x
+  x = pmax(pmin(x, p2d_exp_hi), p2d_exp_lo);
+
+  /* express exp(x) as exp(g + n*log(2)) */
+  fx = pmadd(x, p2d_cephes_LOG2EF, p2d_half);
+
+  fx = pfloor(fx);
+
+  tmp = pmul(fx, p2d_cephes_exp_C1);
+  Packet2d z = pmul(fx, p2d_cephes_exp_C2);
+  x = psub(x, tmp);
+  x = psub(x, z);
+
+  Packet2d x2 = pmul(x,x);
+
+  Packet2d px = p2d_cephes_exp_p0;
+  px = pmadd(px, x2, p2d_cephes_exp_p1);
+  px = pmadd(px, x2, p2d_cephes_exp_p2);
+  px = pmul (px, x);
+
+  Packet2d qx = p2d_cephes_exp_q0;
+  qx = pmadd(qx, x2, p2d_cephes_exp_q1);
+  qx = pmadd(qx, x2, p2d_cephes_exp_q2);
+  qx = pmadd(qx, x2, p2d_cephes_exp_q3);
+
+  x = pdiv(px,psub(qx,px));
+  x = pmadd(p2d_2,x,p2d_1);
+
+  // build 2^n
+  emm0 = ConvertToPacket2l(fx);
+
+#ifdef __POWER8_VECTOR__ 
+  emm0 = vec_add(emm0, p2l_1023);
+  emm0 = vec_sl(emm0, p2ul_52);
+#else
+  // Code is a bit complex for POWER7.  There is actually a
+  // vec_xxsldi intrinsic but it is not supported by some gcc versions.
+  // So we shift (52-32) bits and do a word swap with zeros.
+  _EIGEN_DECLARE_CONST_Packet4i(1023, 1023);
+  _EIGEN_DECLARE_CONST_Packet4i(20, 20);    // 52 - 32
+
+  Packet4i emm04i = reinterpret_cast<Packet4i>(emm0);
+  emm04i = vec_add(emm04i, p4i_1023);
+  emm04i = vec_sl(emm04i, reinterpret_cast<Packet4ui>(p4i_20));
+  static const Packet16uc perm = {
+    0x14, 0x15, 0x16, 0x17, 0x00, 0x01, 0x02, 0x03, 
+    0x1c, 0x1d, 0x1e, 0x1f, 0x08, 0x09, 0x0a, 0x0b };
+#ifdef  _BIG_ENDIAN
+  emm0 = reinterpret_cast<Packet2l>(vec_perm(p4i_ZERO, emm04i, perm));
+#else
+  emm0 = reinterpret_cast<Packet2l>(vec_perm(emm04i, p4i_ZERO, perm));
+#endif
+
+#endif
+
+  // Altivec's max & min operators just drop silent NaNs. Check NaNs in 
+  // inputs and return them unmodified.
+  Packet2ul isnumber_mask = reinterpret_cast<Packet2ul>(vec_cmpeq(_x, _x));
+  return vec_sel(_x, pmax(pmul(x, reinterpret_cast<Packet2d>(emm0)), _x),
+                 isnumber_mask);
+}
+#endif
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_MATH_FUNCTIONS_ALTIVEC_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/AltiVec/PacketMath.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/AltiVec/PacketMath.h
new file mode 100644
index 00000000..b3f1ea19
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/AltiVec/PacketMath.h
@@ -0,0 +1,1033 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2016 Konstantinos Margaritis <markos@freevec.org>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PACKET_MATH_ALTIVEC_H
+#define EIGEN_PACKET_MATH_ALTIVEC_H
+
+namespace Eigen {
+
+namespace internal {
+
+#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
+#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 4
+#endif
+
+#ifndef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#define EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#endif
+
+#ifndef EIGEN_HAS_SINGLE_INSTRUCTION_CJMADD
+#define EIGEN_HAS_SINGLE_INSTRUCTION_CJMADD
+#endif
+
+// NOTE Altivec has 32 registers, but Eigen only accepts a value of 8 or 16
+#ifndef EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS
+#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS  32
+#endif
+
+typedef __vector float          Packet4f;
+typedef __vector int            Packet4i;
+typedef __vector unsigned int   Packet4ui;
+typedef __vector __bool int     Packet4bi;
+typedef __vector short int      Packet8i;
+typedef __vector unsigned char  Packet16uc;
+
+// We don't want to write the same code all the time, but we need to reuse the constants
+// and it doesn't really work to declare them global, so we define macros instead
+
+#define _EIGEN_DECLARE_CONST_FAST_Packet4f(NAME,X) \
+  Packet4f p4f_##NAME = reinterpret_cast<Packet4f>(vec_splat_s32(X))
+
+#define _EIGEN_DECLARE_CONST_FAST_Packet4i(NAME,X) \
+  Packet4i p4i_##NAME = vec_splat_s32(X)
+
+#define _EIGEN_DECLARE_CONST_Packet4f(NAME,X) \
+  Packet4f p4f_##NAME = pset1<Packet4f>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet4i(NAME,X) \
+  Packet4i p4i_##NAME = pset1<Packet4i>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet2d(NAME,X) \
+  Packet2d p2d_##NAME = pset1<Packet2d>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet2l(NAME,X) \
+  Packet2l p2l_##NAME = pset1<Packet2l>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(NAME,X) \
+  const Packet4f p4f_##NAME = reinterpret_cast<Packet4f>(pset1<Packet4i>(X))
+
+#define DST_CHAN 1
+#define DST_CTRL(size, count, stride) (((size) << 24) | ((count) << 16) | (stride))
+
+
+// These constants are endian-agnostic
+static _EIGEN_DECLARE_CONST_FAST_Packet4f(ZERO, 0); //{ 0.0, 0.0, 0.0, 0.0}
+static _EIGEN_DECLARE_CONST_FAST_Packet4i(ZERO, 0); //{ 0, 0, 0, 0,}
+static _EIGEN_DECLARE_CONST_FAST_Packet4i(ONE,1); //{ 1, 1, 1, 1}
+static _EIGEN_DECLARE_CONST_FAST_Packet4i(MINUS16,-16); //{ -16, -16, -16, -16}
+static _EIGEN_DECLARE_CONST_FAST_Packet4i(MINUS1,-1); //{ -1, -1, -1, -1}
+static Packet4f p4f_MZERO = (Packet4f) vec_sl((Packet4ui)p4i_MINUS1, (Packet4ui)p4i_MINUS1); //{ 0x80000000, 0x80000000, 0x80000000, 0x80000000}
+#ifndef __VSX__
+static Packet4f p4f_ONE = vec_ctf(p4i_ONE, 0); //{ 1.0, 1.0, 1.0, 1.0}
+#endif
+
+static Packet4f p4f_COUNTDOWN = { 0.0, 1.0, 2.0, 3.0 };
+static Packet4i p4i_COUNTDOWN = { 0, 1, 2, 3 };
+
+static Packet16uc p16uc_REVERSE32 = { 12,13,14,15, 8,9,10,11, 4,5,6,7, 0,1,2,3 };
+static Packet16uc p16uc_DUPLICATE32_HI = { 0,1,2,3, 0,1,2,3, 4,5,6,7, 4,5,6,7 };
+
+// Mask alignment
+#ifdef __PPC64__
+#define _EIGEN_MASK_ALIGNMENT	0xfffffffffffffff0
+#else
+#define _EIGEN_MASK_ALIGNMENT	0xfffffff0
+#endif
+
+#define _EIGEN_ALIGNED_PTR(x)	((std::ptrdiff_t)(x) & _EIGEN_MASK_ALIGNMENT)
+
+// Handle endianness properly while loading constants
+// Define global static constants:
+#ifdef _BIG_ENDIAN
+static Packet16uc p16uc_FORWARD = vec_lvsl(0, (float*)0);
+#ifdef __VSX__
+static Packet16uc p16uc_REVERSE64 = { 8,9,10,11, 12,13,14,15, 0,1,2,3, 4,5,6,7 };
+#endif
+static Packet16uc p16uc_PSET32_WODD   = vec_sld((Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 0), (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 2), 8);//{ 0,1,2,3, 0,1,2,3, 8,9,10,11, 8,9,10,11 };
+static Packet16uc p16uc_PSET32_WEVEN  = vec_sld(p16uc_DUPLICATE32_HI, (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 3), 8);//{ 4,5,6,7, 4,5,6,7, 12,13,14,15, 12,13,14,15 };
+static Packet16uc p16uc_HALF64_0_16 = vec_sld((Packet16uc)p4i_ZERO, vec_splat((Packet16uc) vec_abs(p4i_MINUS16), 3), 8);      //{ 0,0,0,0, 0,0,0,0, 16,16,16,16, 16,16,16,16};
+#else
+static Packet16uc p16uc_FORWARD = p16uc_REVERSE32; 
+static Packet16uc p16uc_REVERSE64 = { 8,9,10,11, 12,13,14,15, 0,1,2,3, 4,5,6,7 };
+static Packet16uc p16uc_PSET32_WODD = vec_sld((Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 1), (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 3), 8);//{ 0,1,2,3, 0,1,2,3, 8,9,10,11, 8,9,10,11 };
+static Packet16uc p16uc_PSET32_WEVEN = vec_sld((Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 0), (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 2), 8);//{ 4,5,6,7, 4,5,6,7, 12,13,14,15, 12,13,14,15 };
+static Packet16uc p16uc_HALF64_0_16 = vec_sld(vec_splat((Packet16uc) vec_abs(p4i_MINUS16), 0), (Packet16uc)p4i_ZERO, 8);      //{ 0,0,0,0, 0,0,0,0, 16,16,16,16, 16,16,16,16};
+#endif // _BIG_ENDIAN
+
+static Packet16uc p16uc_PSET64_HI = (Packet16uc) vec_mergeh((Packet4ui)p16uc_PSET32_WODD, (Packet4ui)p16uc_PSET32_WEVEN);     //{ 0,1,2,3, 4,5,6,7, 0,1,2,3, 4,5,6,7 };
+static Packet16uc p16uc_PSET64_LO = (Packet16uc) vec_mergel((Packet4ui)p16uc_PSET32_WODD, (Packet4ui)p16uc_PSET32_WEVEN);     //{ 8,9,10,11, 12,13,14,15, 8,9,10,11, 12,13,14,15 };
+static Packet16uc p16uc_TRANSPOSE64_HI = p16uc_PSET64_HI + p16uc_HALF64_0_16;                                         //{ 0,1,2,3, 4,5,6,7, 16,17,18,19, 20,21,22,23};
+static Packet16uc p16uc_TRANSPOSE64_LO = p16uc_PSET64_LO + p16uc_HALF64_0_16;                                         //{ 8,9,10,11, 12,13,14,15, 24,25,26,27, 28,29,30,31};
+
+static Packet16uc p16uc_COMPLEX32_REV = vec_sld(p16uc_REVERSE32, p16uc_REVERSE32, 8);                                         //{ 4,5,6,7, 0,1,2,3, 12,13,14,15, 8,9,10,11 };
+
+#ifdef _BIG_ENDIAN
+static Packet16uc p16uc_COMPLEX32_REV2 = vec_sld(p16uc_FORWARD, p16uc_FORWARD, 8);                                            //{ 8,9,10,11, 12,13,14,15, 0,1,2,3, 4,5,6,7 };
+#else
+static Packet16uc p16uc_COMPLEX32_REV2 = vec_sld(p16uc_PSET64_HI, p16uc_PSET64_LO, 8);                                            //{ 8,9,10,11, 12,13,14,15, 0,1,2,3, 4,5,6,7 };
+#endif // _BIG_ENDIAN
+
+#if EIGEN_HAS_BUILTIN(__builtin_prefetch) || EIGEN_COMP_GNUC
+  #define EIGEN_PPC_PREFETCH(ADDR) __builtin_prefetch(ADDR);
+#else
+  #define EIGEN_PPC_PREFETCH(ADDR) asm( "   dcbt [%[addr]]\n" :: [addr] "r" (ADDR) : "cc" );
+#endif
+
+template<> struct packet_traits<float>  : default_packet_traits
+{
+  typedef Packet4f type;
+  typedef Packet4f half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=4,
+    HasHalfPacket = 1,
+
+    HasAdd  = 1,
+    HasSub  = 1,
+    HasMul  = 1,
+    HasDiv  = 1,
+    HasMin  = 1,
+    HasMax  = 1,
+    HasAbs  = 1,
+    HasSin  = 0,
+    HasCos  = 0,
+    HasLog  = 0,
+    HasExp  = 1,
+#ifdef __VSX__
+    HasSqrt = 1,
+#if !EIGEN_COMP_CLANG
+    HasRsqrt = 1,
+#else
+    HasRsqrt = 0,
+#endif
+#else
+    HasSqrt = 0,
+    HasRsqrt = 0,
+#endif
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasNegate = 1,
+    HasBlend = 1
+  };
+};
+template<> struct packet_traits<int>    : default_packet_traits
+{
+  typedef Packet4i type;
+  typedef Packet4i half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket = 0,
+
+    HasAdd  = 1,
+    HasSub  = 1,
+    HasMul  = 1,
+    HasDiv  = 0,
+    HasBlend = 1
+  };
+};
+
+
+template<> struct unpacket_traits<Packet4f> { typedef float  type; enum {size=4, alignment=Aligned16}; typedef Packet4f half; };
+template<> struct unpacket_traits<Packet4i> { typedef int    type; enum {size=4, alignment=Aligned16}; typedef Packet4i half; };
+
+inline std::ostream & operator <<(std::ostream & s, const Packet16uc & v)
+{
+  union {
+    Packet16uc   v;
+    unsigned char n[16];
+  } vt;
+  vt.v = v;
+  for (int i=0; i< 16; i++)
+    s << (int)vt.n[i] << ", ";
+  return s;
+}
+
+inline std::ostream & operator <<(std::ostream & s, const Packet4f & v)
+{
+  union {
+    Packet4f   v;
+    float n[4];
+  } vt;
+  vt.v = v;
+  s << vt.n[0] << ", " << vt.n[1] << ", " << vt.n[2] << ", " << vt.n[3];
+  return s;
+}
+
+inline std::ostream & operator <<(std::ostream & s, const Packet4i & v)
+{
+  union {
+    Packet4i   v;
+    int n[4];
+  } vt;
+  vt.v = v;
+  s << vt.n[0] << ", " << vt.n[1] << ", " << vt.n[2] << ", " << vt.n[3];
+  return s;
+}
+
+inline std::ostream & operator <<(std::ostream & s, const Packet4ui & v)
+{
+  union {
+    Packet4ui   v;
+    unsigned int n[4];
+  } vt;
+  vt.v = v;
+  s << vt.n[0] << ", " << vt.n[1] << ", " << vt.n[2] << ", " << vt.n[3];
+  return s;
+}
+
+// Need to define them first or we get specialization after instantiation errors
+template<> EIGEN_STRONG_INLINE Packet4f pload<Packet4f>(const float* from)
+{
+  EIGEN_DEBUG_ALIGNED_LOAD
+#ifdef __VSX__
+  return vec_vsx_ld(0, from);
+#else
+  return vec_ld(0, from);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pload<Packet4i>(const int*     from)
+{
+  EIGEN_DEBUG_ALIGNED_LOAD
+#ifdef __VSX__
+  return vec_vsx_ld(0, from);
+#else
+  return vec_ld(0, from);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<float>(float*   to, const Packet4f& from)
+{
+  EIGEN_DEBUG_ALIGNED_STORE
+#ifdef __VSX__
+  vec_vsx_st(from, 0, to);
+#else
+  vec_st(from, 0, to);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<int>(int*       to, const Packet4i& from)
+{
+  EIGEN_DEBUG_ALIGNED_STORE
+#ifdef __VSX__
+  vec_vsx_st(from, 0, to);
+#else
+  vec_st(from, 0, to);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(const float&  from) {
+  Packet4f v = {from, from, from, from};
+  return v;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pset1<Packet4i>(const int&    from)   {
+  Packet4i v = {from, from, from, from};
+  return v;
+}
+template<> EIGEN_STRONG_INLINE void
+pbroadcast4<Packet4f>(const float *a,
+                      Packet4f& a0, Packet4f& a1, Packet4f& a2, Packet4f& a3)
+{
+  a3 = pload<Packet4f>(a);
+  a0 = vec_splat(a3, 0);
+  a1 = vec_splat(a3, 1);
+  a2 = vec_splat(a3, 2);
+  a3 = vec_splat(a3, 3);
+}
+template<> EIGEN_STRONG_INLINE void
+pbroadcast4<Packet4i>(const int *a,
+                      Packet4i& a0, Packet4i& a1, Packet4i& a2, Packet4i& a3)
+{
+  a3 = pload<Packet4i>(a);
+  a0 = vec_splat(a3, 0);
+  a1 = vec_splat(a3, 1);
+  a2 = vec_splat(a3, 2);
+  a3 = vec_splat(a3, 3);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet4f pgather<float, Packet4f>(const float* from, Index stride)
+{
+  float EIGEN_ALIGN16 af[4];
+  af[0] = from[0*stride];
+  af[1] = from[1*stride];
+  af[2] = from[2*stride];
+  af[3] = from[3*stride];
+ return pload<Packet4f>(af);
+}
+template<> EIGEN_DEVICE_FUNC inline Packet4i pgather<int, Packet4i>(const int* from, Index stride)
+{
+  int EIGEN_ALIGN16 ai[4];
+  ai[0] = from[0*stride];
+  ai[1] = from[1*stride];
+  ai[2] = from[2*stride];
+  ai[3] = from[3*stride];
+ return pload<Packet4i>(ai);
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<float, Packet4f>(float* to, const Packet4f& from, Index stride)
+{
+  float EIGEN_ALIGN16 af[4];
+  pstore<float>(af, from);
+  to[0*stride] = af[0];
+  to[1*stride] = af[1];
+  to[2*stride] = af[2];
+  to[3*stride] = af[3];
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<int, Packet4i>(int* to, const Packet4i& from, Index stride)
+{
+  int EIGEN_ALIGN16 ai[4];
+  pstore<int>((int *)ai, from);
+  to[0*stride] = ai[0];
+  to[1*stride] = ai[1];
+  to[2*stride] = ai[2];
+  to[3*stride] = ai[3];
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f plset<Packet4f>(const float& a) { return pset1<Packet4f>(a) + p4f_COUNTDOWN; }
+template<> EIGEN_STRONG_INLINE Packet4i plset<Packet4i>(const int& a)   { return pset1<Packet4i>(a) + p4i_COUNTDOWN; }
+
+template<> EIGEN_STRONG_INLINE Packet4f padd<Packet4f>(const Packet4f& a, const Packet4f& b) { return a + b; }
+template<> EIGEN_STRONG_INLINE Packet4i padd<Packet4i>(const Packet4i& a, const Packet4i& b) { return a + b; }
+
+template<> EIGEN_STRONG_INLINE Packet4f psub<Packet4f>(const Packet4f& a, const Packet4f& b) { return a - b; }
+template<> EIGEN_STRONG_INLINE Packet4i psub<Packet4i>(const Packet4i& a, const Packet4i& b) { return a - b; }
+
+template<> EIGEN_STRONG_INLINE Packet4f pnegate(const Packet4f& a) { return p4f_ZERO - a; }
+template<> EIGEN_STRONG_INLINE Packet4i pnegate(const Packet4i& a) { return p4i_ZERO - a; }
+
+template<> EIGEN_STRONG_INLINE Packet4f pconj(const Packet4f& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4i pconj(const Packet4i& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet4f pmul<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_madd(a,b, p4f_MZERO); }
+template<> EIGEN_STRONG_INLINE Packet4i pmul<Packet4i>(const Packet4i& a, const Packet4i& b) { return a * b; }
+
+template<> EIGEN_STRONG_INLINE Packet4f pdiv<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+#ifndef __VSX__  // VSX actually provides a div instruction
+  Packet4f t, y_0, y_1;
+
+  // Altivec does not offer a divide instruction, we have to do a reciprocal approximation
+  y_0 = vec_re(b);
+
+  // Do one Newton-Raphson iteration to get the needed accuracy
+  t   = vec_nmsub(y_0, b, p4f_ONE);
+  y_1 = vec_madd(y_0, t, y_0);
+
+  return vec_madd(a, y_1, p4f_MZERO);
+#else
+  return vec_div(a, b);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pdiv<Packet4i>(const Packet4i& /*a*/, const Packet4i& /*b*/)
+{ eigen_assert(false && "packet integer division are not supported by AltiVec");
+  return pset1<Packet4i>(0);
+}
+
+// for some weird raisons, it has to be overloaded for packet of integers
+template<> EIGEN_STRONG_INLINE Packet4f pmadd(const Packet4f& a, const Packet4f& b, const Packet4f& c) { return vec_madd(a,b,c); }
+template<> EIGEN_STRONG_INLINE Packet4i pmadd(const Packet4i& a, const Packet4i& b, const Packet4i& c) { return a*b + c; }
+
+template<> EIGEN_STRONG_INLINE Packet4f pmin<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_min(a, b); }
+template<> EIGEN_STRONG_INLINE Packet4i pmin<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_min(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pmax<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_max(a, b); }
+template<> EIGEN_STRONG_INLINE Packet4i pmax<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_max(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pand<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_and(a, b); }
+template<> EIGEN_STRONG_INLINE Packet4i pand<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_and(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f por<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_or(a, b); }
+template<> EIGEN_STRONG_INLINE Packet4i por<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_or(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_xor(a, b); }
+template<> EIGEN_STRONG_INLINE Packet4i pxor<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_xor(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pandnot<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_and(a, vec_nor(b, b)); }
+template<> EIGEN_STRONG_INLINE Packet4i pandnot<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_and(a, vec_nor(b, b)); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pround<Packet4f>(const Packet4f& a) { return vec_round(a); }
+template<> EIGEN_STRONG_INLINE Packet4f pceil<Packet4f>(const  Packet4f& a) { return vec_ceil(a); }
+template<> EIGEN_STRONG_INLINE Packet4f pfloor<Packet4f>(const Packet4f& a) { return vec_floor(a); }
+
+#ifdef _BIG_ENDIAN
+template<> EIGEN_STRONG_INLINE Packet4f ploadu<Packet4f>(const float* from)
+{
+  EIGEN_DEBUG_ALIGNED_LOAD
+  Packet16uc MSQ, LSQ;
+  Packet16uc mask;
+  MSQ = vec_ld(0, (unsigned char *)from);          // most significant quadword
+  LSQ = vec_ld(15, (unsigned char *)from);         // least significant quadword
+  mask = vec_lvsl(0, from);                        // create the permute mask
+  return (Packet4f) vec_perm(MSQ, LSQ, mask);           // align the data
+
+}
+template<> EIGEN_STRONG_INLINE Packet4i ploadu<Packet4i>(const int* from)
+{
+  EIGEN_DEBUG_ALIGNED_LOAD
+  // Taken from http://developer.apple.com/hardwaredrivers/ve/alignment.html
+  Packet16uc MSQ, LSQ;
+  Packet16uc mask;
+  MSQ = vec_ld(0, (unsigned char *)from);          // most significant quadword
+  LSQ = vec_ld(15, (unsigned char *)from);         // least significant quadword
+  mask = vec_lvsl(0, from);                        // create the permute mask
+  return (Packet4i) vec_perm(MSQ, LSQ, mask);    // align the data
+}
+#else
+// We also need ot redefine little endian loading of Packet4i/Packet4f using VSX
+template<> EIGEN_STRONG_INLINE Packet4i ploadu<Packet4i>(const int* from)
+{
+  EIGEN_DEBUG_UNALIGNED_LOAD
+  return (Packet4i) vec_vsx_ld((long)from & 15, (const int*) _EIGEN_ALIGNED_PTR(from));
+}
+template<> EIGEN_STRONG_INLINE Packet4f ploadu<Packet4f>(const float* from)
+{
+  EIGEN_DEBUG_UNALIGNED_LOAD
+  return (Packet4f) vec_vsx_ld((long)from & 15, (const float*) _EIGEN_ALIGNED_PTR(from));
+}
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet4f ploaddup<Packet4f>(const float*   from)
+{
+  Packet4f p;
+  if((std::ptrdiff_t(from) % 16) == 0)  p = pload<Packet4f>(from);
+  else                                  p = ploadu<Packet4f>(from);
+  return vec_perm(p, p, p16uc_DUPLICATE32_HI);
+}
+template<> EIGEN_STRONG_INLINE Packet4i ploaddup<Packet4i>(const int*     from)
+{
+  Packet4i p;
+  if((std::ptrdiff_t(from) % 16) == 0)  p = pload<Packet4i>(from);
+  else                                  p = ploadu<Packet4i>(from);
+  return vec_perm(p, p, p16uc_DUPLICATE32_HI);
+}
+
+#ifdef _BIG_ENDIAN
+template<> EIGEN_STRONG_INLINE void pstoreu<float>(float*  to, const Packet4f& from)
+{
+  EIGEN_DEBUG_UNALIGNED_STORE
+  // Taken from http://developer.apple.com/hardwaredrivers/ve/alignment.html
+  // Warning: not thread safe!
+  Packet16uc MSQ, LSQ, edges;
+  Packet16uc edgeAlign, align;
+
+  MSQ = vec_ld(0, (unsigned char *)to);                     // most significant quadword
+  LSQ = vec_ld(15, (unsigned char *)to);                    // least significant quadword
+  edgeAlign = vec_lvsl(0, to);                              // permute map to extract edges
+  edges=vec_perm(LSQ,MSQ,edgeAlign);                        // extract the edges
+  align = vec_lvsr( 0, to );                                // permute map to misalign data
+  MSQ = vec_perm(edges,(Packet16uc)from,align);             // misalign the data (MSQ)
+  LSQ = vec_perm((Packet16uc)from,edges,align);             // misalign the data (LSQ)
+  vec_st( LSQ, 15, (unsigned char *)to );                   // Store the LSQ part first
+  vec_st( MSQ, 0, (unsigned char *)to );                    // Store the MSQ part
+}
+template<> EIGEN_STRONG_INLINE void pstoreu<int>(int*      to, const Packet4i& from)
+{
+  EIGEN_DEBUG_UNALIGNED_STORE
+  // Taken from http://developer.apple.com/hardwaredrivers/ve/alignment.html
+  // Warning: not thread safe!
+  Packet16uc MSQ, LSQ, edges;
+  Packet16uc edgeAlign, align;
+
+  MSQ = vec_ld(0, (unsigned char *)to);                     // most significant quadword
+  LSQ = vec_ld(15, (unsigned char *)to);                    // least significant quadword
+  edgeAlign = vec_lvsl(0, to);                              // permute map to extract edges
+  edges=vec_perm(LSQ, MSQ, edgeAlign);                      // extract the edges
+  align = vec_lvsr( 0, to );                                // permute map to misalign data
+  MSQ = vec_perm(edges, (Packet16uc) from, align);          // misalign the data (MSQ)
+  LSQ = vec_perm((Packet16uc) from, edges, align);          // misalign the data (LSQ)
+  vec_st( LSQ, 15, (unsigned char *)to );                   // Store the LSQ part first
+  vec_st( MSQ, 0, (unsigned char *)to );                    // Store the MSQ part
+}
+#else
+// We also need ot redefine little endian loading of Packet4i/Packet4f using VSX
+template<> EIGEN_STRONG_INLINE void pstoreu<int>(int*       to, const Packet4i& from)
+{
+  EIGEN_DEBUG_ALIGNED_STORE
+  vec_vsx_st(from, (long)to & 15, (int*) _EIGEN_ALIGNED_PTR(to));
+}
+template<> EIGEN_STRONG_INLINE void pstoreu<float>(float*   to, const Packet4f& from)
+{
+  EIGEN_DEBUG_ALIGNED_STORE
+  vec_vsx_st(from, (long)to & 15, (float*) _EIGEN_ALIGNED_PTR(to));
+}
+#endif
+
+template<> EIGEN_STRONG_INLINE void prefetch<float>(const float* addr)    { EIGEN_PPC_PREFETCH(addr); }
+template<> EIGEN_STRONG_INLINE void prefetch<int>(const int*     addr)    { EIGEN_PPC_PREFETCH(addr); }
+
+template<> EIGEN_STRONG_INLINE float  pfirst<Packet4f>(const Packet4f& a) { float EIGEN_ALIGN16 x; vec_ste(a, 0, &x); return x; }
+template<> EIGEN_STRONG_INLINE int    pfirst<Packet4i>(const Packet4i& a) { int   EIGEN_ALIGN16 x; vec_ste(a, 0, &x); return x; }
+
+template<> EIGEN_STRONG_INLINE Packet4f preverse(const Packet4f& a)
+{
+  return reinterpret_cast<Packet4f>(vec_perm(reinterpret_cast<Packet16uc>(a), reinterpret_cast<Packet16uc>(a), p16uc_REVERSE32));
+}
+template<> EIGEN_STRONG_INLINE Packet4i preverse(const Packet4i& a)
+{
+  return reinterpret_cast<Packet4i>(vec_perm(reinterpret_cast<Packet16uc>(a), reinterpret_cast<Packet16uc>(a), p16uc_REVERSE32)); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pabs(const Packet4f& a) { return vec_abs(a); }
+template<> EIGEN_STRONG_INLINE Packet4i pabs(const Packet4i& a) { return vec_abs(a); }
+
+template<> EIGEN_STRONG_INLINE float predux<Packet4f>(const Packet4f& a)
+{
+  Packet4f b, sum;
+  b   = vec_sld(a, a, 8);
+  sum = a + b;
+  b   = vec_sld(sum, sum, 4);
+  sum += b;
+  return pfirst(sum);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f preduxp<Packet4f>(const Packet4f* vecs)
+{
+  Packet4f v[4], sum[4];
+
+  // It's easier and faster to transpose then add as columns
+  // Check: http://www.freevec.org/function/matrix_4x4_transpose_floats for explanation
+  // Do the transpose, first set of moves
+  v[0] = vec_mergeh(vecs[0], vecs[2]);
+  v[1] = vec_mergel(vecs[0], vecs[2]);
+  v[2] = vec_mergeh(vecs[1], vecs[3]);
+  v[3] = vec_mergel(vecs[1], vecs[3]);
+  // Get the resulting vectors
+  sum[0] = vec_mergeh(v[0], v[2]);
+  sum[1] = vec_mergel(v[0], v[2]);
+  sum[2] = vec_mergeh(v[1], v[3]);
+  sum[3] = vec_mergel(v[1], v[3]);
+
+  // Now do the summation:
+  // Lines 0+1
+  sum[0] = sum[0] + sum[1];
+  // Lines 2+3
+  sum[1] = sum[2] + sum[3];
+  // Add the results
+  sum[0] = sum[0] + sum[1];
+
+  return sum[0];
+}
+
+template<> EIGEN_STRONG_INLINE int predux<Packet4i>(const Packet4i& a)
+{
+  Packet4i sum;
+  sum = vec_sums(a, p4i_ZERO);
+#ifdef _BIG_ENDIAN
+  sum = vec_sld(sum, p4i_ZERO, 12);
+#else
+  sum = vec_sld(p4i_ZERO, sum, 4);
+#endif
+  return pfirst(sum);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i preduxp<Packet4i>(const Packet4i* vecs)
+{
+  Packet4i v[4], sum[4];
+
+  // It's easier and faster to transpose then add as columns
+  // Check: http://www.freevec.org/function/matrix_4x4_transpose_floats for explanation
+  // Do the transpose, first set of moves
+  v[0] = vec_mergeh(vecs[0], vecs[2]);
+  v[1] = vec_mergel(vecs[0], vecs[2]);
+  v[2] = vec_mergeh(vecs[1], vecs[3]);
+  v[3] = vec_mergel(vecs[1], vecs[3]);
+  // Get the resulting vectors
+  sum[0] = vec_mergeh(v[0], v[2]);
+  sum[1] = vec_mergel(v[0], v[2]);
+  sum[2] = vec_mergeh(v[1], v[3]);
+  sum[3] = vec_mergel(v[1], v[3]);
+
+  // Now do the summation:
+  // Lines 0+1
+  sum[0] = sum[0] + sum[1];
+  // Lines 2+3
+  sum[1] = sum[2] + sum[3];
+  // Add the results
+  sum[0] = sum[0] + sum[1];
+
+  return sum[0];
+}
+
+// Other reduction functions:
+// mul
+template<> EIGEN_STRONG_INLINE float predux_mul<Packet4f>(const Packet4f& a)
+{
+  Packet4f prod;
+  prod = pmul(a, vec_sld(a, a, 8));
+  return pfirst(pmul(prod, vec_sld(prod, prod, 4)));
+}
+
+template<> EIGEN_STRONG_INLINE int predux_mul<Packet4i>(const Packet4i& a)
+{
+  EIGEN_ALIGN16 int aux[4];
+  pstore(aux, a);
+  return aux[0] * aux[1] * aux[2] * aux[3];
+}
+
+// min
+template<> EIGEN_STRONG_INLINE float predux_min<Packet4f>(const Packet4f& a)
+{
+  Packet4f b, res;
+  b = vec_min(a, vec_sld(a, a, 8));
+  res = vec_min(b, vec_sld(b, b, 4));
+  return pfirst(res);
+}
+
+template<> EIGEN_STRONG_INLINE int predux_min<Packet4i>(const Packet4i& a)
+{
+  Packet4i b, res;
+  b = vec_min(a, vec_sld(a, a, 8));
+  res = vec_min(b, vec_sld(b, b, 4));
+  return pfirst(res);
+}
+
+// max
+template<> EIGEN_STRONG_INLINE float predux_max<Packet4f>(const Packet4f& a)
+{
+  Packet4f b, res;
+  b = vec_max(a, vec_sld(a, a, 8));
+  res = vec_max(b, vec_sld(b, b, 4));
+  return pfirst(res);
+}
+
+template<> EIGEN_STRONG_INLINE int predux_max<Packet4i>(const Packet4i& a)
+{
+  Packet4i b, res;
+  b = vec_max(a, vec_sld(a, a, 8));
+  res = vec_max(b, vec_sld(b, b, 4));
+  return pfirst(res);
+}
+
+template<int Offset>
+struct palign_impl<Offset,Packet4f>
+{
+  static EIGEN_STRONG_INLINE void run(Packet4f& first, const Packet4f& second)
+  {
+#ifdef _BIG_ENDIAN
+    switch (Offset % 4) {
+    case 1:
+      first = vec_sld(first, second, 4); break;
+    case 2:
+      first = vec_sld(first, second, 8); break;
+    case 3:
+      first = vec_sld(first, second, 12); break;
+    }
+#else
+    switch (Offset % 4) {
+    case 1:
+      first = vec_sld(second, first, 12); break;
+    case 2:
+      first = vec_sld(second, first, 8); break;
+    case 3:
+      first = vec_sld(second, first, 4); break;
+    }
+#endif
+  }
+};
+
+template<int Offset>
+struct palign_impl<Offset,Packet4i>
+{
+  static EIGEN_STRONG_INLINE void run(Packet4i& first, const Packet4i& second)
+  {
+#ifdef _BIG_ENDIAN
+    switch (Offset % 4) {
+    case 1:
+      first = vec_sld(first, second, 4); break;
+    case 2:
+      first = vec_sld(first, second, 8); break;
+    case 3:
+      first = vec_sld(first, second, 12); break;
+    }
+#else
+    switch (Offset % 4) {
+    case 1:
+      first = vec_sld(second, first, 12); break;
+    case 2:
+      first = vec_sld(second, first, 8); break;
+    case 3:
+      first = vec_sld(second, first, 4); break;
+    }
+#endif
+  }
+};
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet4f,4>& kernel) {
+  Packet4f t0, t1, t2, t3;
+  t0 = vec_mergeh(kernel.packet[0], kernel.packet[2]);
+  t1 = vec_mergel(kernel.packet[0], kernel.packet[2]);
+  t2 = vec_mergeh(kernel.packet[1], kernel.packet[3]);
+  t3 = vec_mergel(kernel.packet[1], kernel.packet[3]);
+  kernel.packet[0] = vec_mergeh(t0, t2);
+  kernel.packet[1] = vec_mergel(t0, t2);
+  kernel.packet[2] = vec_mergeh(t1, t3);
+  kernel.packet[3] = vec_mergel(t1, t3);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet4i,4>& kernel) {
+  Packet4i t0, t1, t2, t3;
+  t0 = vec_mergeh(kernel.packet[0], kernel.packet[2]);
+  t1 = vec_mergel(kernel.packet[0], kernel.packet[2]);
+  t2 = vec_mergeh(kernel.packet[1], kernel.packet[3]);
+  t3 = vec_mergel(kernel.packet[1], kernel.packet[3]);
+  kernel.packet[0] = vec_mergeh(t0, t2);
+  kernel.packet[1] = vec_mergel(t0, t2);
+  kernel.packet[2] = vec_mergeh(t1, t3);
+  kernel.packet[3] = vec_mergel(t1, t3);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pblend(const Selector<4>& ifPacket, const Packet4i& thenPacket, const Packet4i& elsePacket) {
+  Packet4ui select = { ifPacket.select[0], ifPacket.select[1], ifPacket.select[2], ifPacket.select[3] };
+  Packet4ui mask = reinterpret_cast<Packet4ui>(vec_cmpeq(reinterpret_cast<Packet4ui>(select), reinterpret_cast<Packet4ui>(p4i_ONE)));
+  return vec_sel(elsePacket, thenPacket, mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pblend(const Selector<4>& ifPacket, const Packet4f& thenPacket, const Packet4f& elsePacket) {
+  Packet4ui select = { ifPacket.select[0], ifPacket.select[1], ifPacket.select[2], ifPacket.select[3] };
+  Packet4ui mask = reinterpret_cast<Packet4ui>(vec_cmpeq(reinterpret_cast<Packet4ui>(select), reinterpret_cast<Packet4ui>(p4i_ONE)));
+  return vec_sel(elsePacket, thenPacket, mask);
+}
+
+
+//---------- double ----------
+#ifdef __VSX__
+typedef __vector double              Packet2d;
+typedef __vector unsigned long long  Packet2ul;
+typedef __vector long long           Packet2l;
+#if EIGEN_COMP_CLANG
+typedef Packet2ul                    Packet2bl;
+#else
+typedef __vector __bool long         Packet2bl;
+#endif
+
+static Packet2l  p2l_ONE  = { 1, 1 };
+static Packet2l  p2l_ZERO = reinterpret_cast<Packet2l>(p4i_ZERO);
+static Packet2d  p2d_ONE  = { 1.0, 1.0 }; 
+static Packet2d  p2d_ZERO = reinterpret_cast<Packet2d>(p4f_ZERO);
+static Packet2d  p2d_MZERO = { -0.0, -0.0 };
+
+#ifdef _BIG_ENDIAN
+static Packet2d p2d_COUNTDOWN = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4f>(p2d_ZERO), reinterpret_cast<Packet4f>(p2d_ONE), 8));
+#else
+static Packet2d p2d_COUNTDOWN = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4f>(p2d_ONE), reinterpret_cast<Packet4f>(p2d_ZERO), 8));
+#endif
+
+template<int index> Packet2d vec_splat_dbl(Packet2d& a);
+
+template<> EIGEN_STRONG_INLINE Packet2d vec_splat_dbl<0>(Packet2d& a)
+{
+  return reinterpret_cast<Packet2d>(vec_perm(a, a, p16uc_PSET64_HI));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d vec_splat_dbl<1>(Packet2d& a)
+{
+  return reinterpret_cast<Packet2d>(vec_perm(a, a, p16uc_PSET64_LO));
+}
+
+template<> struct packet_traits<double> : default_packet_traits
+{
+  typedef Packet2d type;
+  typedef Packet2d half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=2,
+    HasHalfPacket = 1,
+
+    HasAdd  = 1,
+    HasSub  = 1,
+    HasMul  = 1,
+    HasDiv  = 1,
+    HasMin  = 1,
+    HasMax  = 1,
+    HasAbs  = 1,
+    HasSin  = 0,
+    HasCos  = 0,
+    HasLog  = 0,
+    HasExp  = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasNegate = 1,
+    HasBlend = 1
+  };
+};
+
+template<> struct unpacket_traits<Packet2d> { typedef double type; enum {size=2, alignment=Aligned16}; typedef Packet2d half; };
+
+inline std::ostream & operator <<(std::ostream & s, const Packet2l & v)
+{
+  union {
+    Packet2l   v;
+    int64_t n[2];
+  } vt;
+  vt.v = v;
+  s << vt.n[0] << ", " << vt.n[1];
+  return s;
+}
+
+inline std::ostream & operator <<(std::ostream & s, const Packet2d & v)
+{
+  union {
+    Packet2d   v;
+    double n[2];
+  } vt;
+  vt.v = v;
+  s << vt.n[0] << ", " << vt.n[1];
+  return s;
+}
+
+// Need to define them first or we get specialization after instantiation errors
+template<> EIGEN_STRONG_INLINE Packet2d pload<Packet2d>(const double* from)
+{
+  EIGEN_DEBUG_ALIGNED_LOAD
+#ifdef __VSX__
+  return vec_vsx_ld(0, from);
+#else
+  return vec_ld(0, from);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<double>(double*   to, const Packet2d& from)
+{
+  EIGEN_DEBUG_ALIGNED_STORE
+#ifdef __VSX__
+  vec_vsx_st(from, 0, to);
+#else
+  vec_st(from, 0, to);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pset1<Packet2d>(const double&  from) {
+  Packet2d v = {from, from};
+  return v;
+}
+
+template<> EIGEN_STRONG_INLINE void
+pbroadcast4<Packet2d>(const double *a,
+                      Packet2d& a0, Packet2d& a1, Packet2d& a2, Packet2d& a3)
+{
+  a1 = pload<Packet2d>(a);
+  a0 = vec_splat_dbl<0>(a1);
+  a1 = vec_splat_dbl<1>(a1);
+  a3 = pload<Packet2d>(a+2);
+  a2 = vec_splat_dbl<0>(a3);
+  a3 = vec_splat_dbl<1>(a3);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet2d pgather<double, Packet2d>(const double* from, Index stride)
+{
+  double EIGEN_ALIGN16 af[2];
+  af[0] = from[0*stride];
+  af[1] = from[1*stride];
+ return pload<Packet2d>(af);
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<double, Packet2d>(double* to, const Packet2d& from, Index stride)
+{
+  double EIGEN_ALIGN16 af[2];
+  pstore<double>(af, from);
+  to[0*stride] = af[0];
+  to[1*stride] = af[1];
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d plset<Packet2d>(const double& a) { return pset1<Packet2d>(a) + p2d_COUNTDOWN; }
+
+template<> EIGEN_STRONG_INLINE Packet2d padd<Packet2d>(const Packet2d& a, const Packet2d& b) { return a + b; }
+
+template<> EIGEN_STRONG_INLINE Packet2d psub<Packet2d>(const Packet2d& a, const Packet2d& b) { return a - b; }
+
+template<> EIGEN_STRONG_INLINE Packet2d pnegate(const Packet2d& a) { return p2d_ZERO - a; }
+
+template<> EIGEN_STRONG_INLINE Packet2d pconj(const Packet2d& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet2d pmul<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_madd(a,b,p2d_MZERO); }
+template<> EIGEN_STRONG_INLINE Packet2d pdiv<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_div(a,b); }
+
+// for some weird raisons, it has to be overloaded for packet of integers
+template<> EIGEN_STRONG_INLINE Packet2d pmadd(const Packet2d& a, const Packet2d& b, const Packet2d& c) { return vec_madd(a, b, c); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pmin<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_min(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pmax<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_max(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pand<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_and(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet2d por<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_or(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pxor<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_xor(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pandnot<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_and(a, vec_nor(b, b)); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pround<Packet2d>(const Packet2d& a) { return vec_round(a); }
+template<> EIGEN_STRONG_INLINE Packet2d pceil<Packet2d>(const  Packet2d& a) { return vec_ceil(a); }
+template<> EIGEN_STRONG_INLINE Packet2d pfloor<Packet2d>(const Packet2d& a) { return vec_floor(a); }
+
+template<> EIGEN_STRONG_INLINE Packet2d ploadu<Packet2d>(const double* from)
+{
+  EIGEN_DEBUG_ALIGNED_LOAD
+  return (Packet2d) vec_vsx_ld((long)from & 15, (const double*) _EIGEN_ALIGNED_PTR(from));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d ploaddup<Packet2d>(const double*   from)
+{
+  Packet2d p;
+  if((std::ptrdiff_t(from) % 16) == 0)  p = pload<Packet2d>(from);
+  else                                  p = ploadu<Packet2d>(from);
+  return vec_splat_dbl<0>(p);
+}
+
+template<> EIGEN_STRONG_INLINE void pstoreu<double>(double*  to, const Packet2d& from)
+{
+  EIGEN_DEBUG_ALIGNED_STORE
+  vec_vsx_st((Packet4f)from, (long)to & 15, (float*) _EIGEN_ALIGNED_PTR(to));
+}
+
+template<> EIGEN_STRONG_INLINE void prefetch<double>(const double* addr) { EIGEN_PPC_PREFETCH(addr); }
+
+template<> EIGEN_STRONG_INLINE double  pfirst<Packet2d>(const Packet2d& a) { double EIGEN_ALIGN16 x[2]; pstore<double>(x, a); return x[0]; }
+
+template<> EIGEN_STRONG_INLINE Packet2d preverse(const Packet2d& a)
+{
+  return reinterpret_cast<Packet2d>(vec_perm(reinterpret_cast<Packet16uc>(a), reinterpret_cast<Packet16uc>(a), p16uc_REVERSE64));
+}
+template<> EIGEN_STRONG_INLINE Packet2d pabs(const Packet2d& a) { return vec_abs(a); }
+
+template<> EIGEN_STRONG_INLINE double predux<Packet2d>(const Packet2d& a)
+{
+  Packet2d b, sum;
+  b   = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4f>(a), reinterpret_cast<Packet4f>(a), 8));
+  sum = a + b;
+  return pfirst<Packet2d>(sum);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d preduxp<Packet2d>(const Packet2d* vecs)
+{
+  Packet2d v[2], sum;
+  v[0] = vecs[0] + reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4f>(vecs[0]), reinterpret_cast<Packet4f>(vecs[0]), 8));
+  v[1] = vecs[1] + reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4f>(vecs[1]), reinterpret_cast<Packet4f>(vecs[1]), 8));
+ 
+#ifdef _BIG_ENDIAN
+  sum = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4f>(v[0]), reinterpret_cast<Packet4f>(v[1]), 8));
+#else
+  sum = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4f>(v[1]), reinterpret_cast<Packet4f>(v[0]), 8));
+#endif
+
+  return sum;
+}
+// Other reduction functions:
+// mul
+template<> EIGEN_STRONG_INLINE double predux_mul<Packet2d>(const Packet2d& a)
+{
+  return pfirst(pmul(a, reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4ui>(a), reinterpret_cast<Packet4ui>(a), 8))));
+}
+
+// min
+template<> EIGEN_STRONG_INLINE double predux_min<Packet2d>(const Packet2d& a)
+{
+  return pfirst(pmin(a, reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4ui>(a), reinterpret_cast<Packet4ui>(a), 8))));
+}
+
+// max
+template<> EIGEN_STRONG_INLINE double predux_max<Packet2d>(const Packet2d& a)
+{
+  return pfirst(pmax(a, reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4ui>(a), reinterpret_cast<Packet4ui>(a), 8))));
+}
+
+template<int Offset>
+struct palign_impl<Offset,Packet2d>
+{
+  static EIGEN_STRONG_INLINE void run(Packet2d& first, const Packet2d& second)
+  {
+    if (Offset == 1)
+#ifdef _BIG_ENDIAN
+      first = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4ui>(first), reinterpret_cast<Packet4ui>(second), 8));
+#else
+      first = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4ui>(second), reinterpret_cast<Packet4ui>(first), 8));
+#endif
+  }
+};
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet2d,2>& kernel) {
+  Packet2d t0, t1;
+  t0 = vec_perm(kernel.packet[0], kernel.packet[1], p16uc_TRANSPOSE64_HI);
+  t1 = vec_perm(kernel.packet[0], kernel.packet[1], p16uc_TRANSPOSE64_LO);
+  kernel.packet[0] = t0;
+  kernel.packet[1] = t1;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pblend(const Selector<2>& ifPacket, const Packet2d& thenPacket, const Packet2d& elsePacket) {
+  Packet2l select = { ifPacket.select[0], ifPacket.select[1] };
+  Packet2bl mask = vec_cmpeq(reinterpret_cast<Packet2d>(select), reinterpret_cast<Packet2d>(p2l_ONE));
+  return vec_sel(elsePacket, thenPacket, mask);
+}
+#endif // __VSX__
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_PACKET_MATH_ALTIVEC_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/CUDA/Complex.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/CUDA/Complex.h
new file mode 100644
index 00000000..57d1201f
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/CUDA/Complex.h
@@ -0,0 +1,103 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLEX_CUDA_H
+#define EIGEN_COMPLEX_CUDA_H
+
+// clang-format off
+
+namespace Eigen {
+
+namespace internal {
+
+#if defined(EIGEN_CUDACC) && defined(EIGEN_USE_GPU)
+
+// Many std::complex methods such as operator+, operator-, operator* and
+// operator/ are not constexpr. Due to this, clang does not treat them as device
+// functions and thus Eigen functors making use of these operators fail to
+// compile. Here, we manually specialize these functors for complex types when
+// building for CUDA to avoid non-constexpr methods.
+
+// Sum
+template<typename T> struct scalar_sum_op<const std::complex<T>, const std::complex<T> > : binary_op_base<const std::complex<T>, const std::complex<T> > {
+  typedef typename std::complex<T> result_type;
+
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_sum_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<T> operator() (const std::complex<T>& a, const std::complex<T>& b) const {
+    return std::complex<T>(numext::real(a) + numext::real(b),
+                           numext::imag(a) + numext::imag(b));
+  }
+};
+
+template<typename T> struct scalar_sum_op<std::complex<T>, std::complex<T> > : scalar_sum_op<const std::complex<T>, const std::complex<T> > {};
+
+
+// Difference
+template<typename T> struct scalar_difference_op<const std::complex<T>, const std::complex<T> >  : binary_op_base<const std::complex<T>, const std::complex<T> > {
+  typedef typename std::complex<T> result_type;
+
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_difference_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<T> operator() (const std::complex<T>& a, const std::complex<T>& b) const {
+    return std::complex<T>(numext::real(a) - numext::real(b),
+                           numext::imag(a) - numext::imag(b));
+  }
+};
+
+template<typename T> struct scalar_difference_op<std::complex<T>, std::complex<T> > : scalar_difference_op<const std::complex<T>, const std::complex<T> > {};
+
+
+// Product
+template<typename T> struct scalar_product_op<const std::complex<T>, const std::complex<T> >  : binary_op_base<const std::complex<T>, const std::complex<T> > {
+  enum {
+    Vectorizable = packet_traits<std::complex<T> >::HasMul
+  };
+  typedef typename std::complex<T> result_type;
+
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_product_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<T> operator() (const std::complex<T>& a, const std::complex<T>& b) const {
+    const T a_real = numext::real(a);
+    const T a_imag = numext::imag(a);
+    const T b_real = numext::real(b);
+    const T b_imag = numext::imag(b);
+    return std::complex<T>(a_real * b_real - a_imag * b_imag,
+                           a_real * b_imag + a_imag * b_real);
+  }
+};
+
+template<typename T> struct scalar_product_op<std::complex<T>, std::complex<T> > : scalar_product_op<const std::complex<T>, const std::complex<T> > {};
+
+
+// Quotient
+template<typename T> struct scalar_quotient_op<const std::complex<T>, const std::complex<T> > : binary_op_base<const std::complex<T>, const std::complex<T> > {
+  enum {
+    Vectorizable = packet_traits<std::complex<T> >::HasDiv
+  };
+  typedef typename std::complex<T> result_type;
+
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_quotient_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<T> operator() (const std::complex<T>& a, const std::complex<T>& b) const {
+    const T a_real = numext::real(a);
+    const T a_imag = numext::imag(a);
+    const T b_real = numext::real(b);
+    const T b_imag = numext::imag(b);
+    const T norm = T(1) / (b_real * b_real + b_imag * b_imag);
+    return std::complex<T>((a_real * b_real + a_imag * b_imag) * norm,
+                           (a_imag * b_real - a_real * b_imag) * norm);
+  }
+};
+
+template<typename T> struct scalar_quotient_op<std::complex<T>, std::complex<T> > : scalar_quotient_op<const std::complex<T>, const std::complex<T> > {};
+
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_COMPLEX_CUDA_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/CUDA/Half.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/CUDA/Half.h
new file mode 100644
index 00000000..ee24e615
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/CUDA/Half.h
@@ -0,0 +1,666 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+//
+// The conversion routines are Copyright (c) Fabian Giesen, 2016.
+// The original license follows:
+//
+// Copyright (c) Fabian Giesen, 2016
+// All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted.
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+// Standard 16-bit float type, mostly useful for GPUs. Defines a new
+// type Eigen::half (inheriting from CUDA's __half struct) with
+// operator overloads such that it behaves basically as an arithmetic
+// type. It will be quite slow on CPUs (so it is recommended to stay
+// in fp32 for CPUs, except for simple parameter conversions, I/O
+// to disk and the likes), but fast on GPUs.
+
+
+#ifndef EIGEN_HALF_CUDA_H
+#define EIGEN_HALF_CUDA_H
+
+#if __cplusplus > 199711L
+#define EIGEN_EXPLICIT_CAST(tgt_type) explicit operator tgt_type()
+#else
+#define EIGEN_EXPLICIT_CAST(tgt_type) operator tgt_type()
+#endif
+
+
+namespace Eigen {
+
+struct half;
+
+namespace half_impl {
+
+#if !defined(EIGEN_HAS_CUDA_FP16)
+// Make our own __half_raw definition that is similar to CUDA's.
+struct __half_raw {
+  EIGEN_DEVICE_FUNC __half_raw() : x(0) {}
+  explicit EIGEN_DEVICE_FUNC __half_raw(unsigned short raw) : x(raw) {}
+  unsigned short x;
+};
+#elif defined(EIGEN_CUDACC_VER) && EIGEN_CUDACC_VER < 90000
+// In CUDA < 9.0, __half is the equivalent of CUDA 9's __half_raw
+typedef __half __half_raw;
+#endif
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC __half_raw raw_uint16_to_half(unsigned short x);
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC __half_raw float_to_half_rtne(float ff);
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC float half_to_float(__half_raw h);
+
+struct half_base : public __half_raw {
+  EIGEN_DEVICE_FUNC half_base() {}
+  EIGEN_DEVICE_FUNC half_base(const half_base& h) : __half_raw(h) {}
+  EIGEN_DEVICE_FUNC half_base(const __half_raw& h) : __half_raw(h) {}
+#if defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDACC_VER) && EIGEN_CUDACC_VER >= 90000
+  EIGEN_DEVICE_FUNC half_base(const __half& h) : __half_raw(*(__half_raw*)&h) {}
+#endif
+};
+
+} // namespace half_impl
+
+// Class definition.
+struct half : public half_impl::half_base {
+  #if !defined(EIGEN_HAS_CUDA_FP16) || (defined(EIGEN_CUDACC_VER) && EIGEN_CUDACC_VER < 90000)
+    typedef half_impl::__half_raw __half_raw;
+  #endif
+
+  EIGEN_DEVICE_FUNC half() {}
+
+  EIGEN_DEVICE_FUNC half(const __half_raw& h) : half_impl::half_base(h) {}
+  EIGEN_DEVICE_FUNC half(const half& h) : half_impl::half_base(h) {}
+#if defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDACC_VER) && EIGEN_CUDACC_VER >= 90000
+  EIGEN_DEVICE_FUNC half(const __half& h) : half_impl::half_base(h) {}
+#endif
+
+  explicit EIGEN_DEVICE_FUNC half(bool b)
+      : half_impl::half_base(half_impl::raw_uint16_to_half(b ? 0x3c00 : 0)) {}
+  template<class T>
+  explicit EIGEN_DEVICE_FUNC half(const T& val)
+      : half_impl::half_base(half_impl::float_to_half_rtne(static_cast<float>(val))) {}
+  explicit EIGEN_DEVICE_FUNC half(float f)
+      : half_impl::half_base(half_impl::float_to_half_rtne(f)) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_EXPLICIT_CAST(bool) const {
+    // +0.0 and -0.0 become false, everything else becomes true.
+    return (x & 0x7fff) != 0;
+  }
+  EIGEN_DEVICE_FUNC EIGEN_EXPLICIT_CAST(signed char) const {
+    return static_cast<signed char>(half_impl::half_to_float(*this));
+  }
+  EIGEN_DEVICE_FUNC EIGEN_EXPLICIT_CAST(unsigned char) const {
+    return static_cast<unsigned char>(half_impl::half_to_float(*this));
+  }
+  EIGEN_DEVICE_FUNC EIGEN_EXPLICIT_CAST(short) const {
+    return static_cast<short>(half_impl::half_to_float(*this));
+  }
+  EIGEN_DEVICE_FUNC EIGEN_EXPLICIT_CAST(unsigned short) const {
+    return static_cast<unsigned short>(half_impl::half_to_float(*this));
+  }
+  EIGEN_DEVICE_FUNC EIGEN_EXPLICIT_CAST(int) const {
+    return static_cast<int>(half_impl::half_to_float(*this));
+  }
+  EIGEN_DEVICE_FUNC EIGEN_EXPLICIT_CAST(unsigned int) const {
+    return static_cast<unsigned int>(half_impl::half_to_float(*this));
+  }
+  EIGEN_DEVICE_FUNC EIGEN_EXPLICIT_CAST(long) const {
+    return static_cast<long>(half_impl::half_to_float(*this));
+  }
+  EIGEN_DEVICE_FUNC EIGEN_EXPLICIT_CAST(unsigned long) const {
+    return static_cast<unsigned long>(half_impl::half_to_float(*this));
+  }
+  EIGEN_DEVICE_FUNC EIGEN_EXPLICIT_CAST(long long) const {
+    return static_cast<long long>(half_impl::half_to_float(*this));
+  }
+  EIGEN_DEVICE_FUNC EIGEN_EXPLICIT_CAST(unsigned long long) const {
+    return static_cast<unsigned long long>(half_to_float(*this));
+  }
+  EIGEN_DEVICE_FUNC EIGEN_EXPLICIT_CAST(float) const {
+    return half_impl::half_to_float(*this);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_EXPLICIT_CAST(double) const {
+    return static_cast<double>(half_impl::half_to_float(*this));
+  }
+
+  EIGEN_DEVICE_FUNC half& operator=(const half& other) {
+    x = other.x;
+    return *this;
+  }
+};
+
+namespace half_impl {
+
+#if defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 530
+
+// Intrinsics for native fp16 support. Note that on current hardware,
+// these are no faster than fp32 arithmetic (you need to use the half2
+// versions to get the ALU speed increased), but you do save the
+// conversion steps back and forth.
+
+__device__ half operator + (const half& a, const half& b) {
+  return __hadd(a, b);
+}
+__device__ half operator * (const half& a, const half& b) {
+  return __hmul(a, b);
+}
+__device__ half operator - (const half& a, const half& b) {
+  return __hsub(a, b);
+}
+__device__ half operator / (const half& a, const half& b) {
+  float num = __half2float(a);
+  float denom = __half2float(b);
+  return __float2half(num / denom);
+}
+__device__ half operator - (const half& a) {
+  return __hneg(a);
+}
+__device__ half& operator += (half& a, const half& b) {
+  a = a + b;
+  return a;
+}
+__device__ half& operator *= (half& a, const half& b) {
+  a = a * b;
+  return a;
+}
+__device__ half& operator -= (half& a, const half& b) {
+  a = a - b;
+  return a;
+}
+__device__ half& operator /= (half& a, const half& b) {
+  a = a / b;
+  return a;
+}
+__device__ bool operator == (const half& a, const half& b) {
+  return __heq(a, b);
+}
+__device__ bool operator != (const half& a, const half& b) {
+  return __hne(a, b);
+}
+__device__ bool operator < (const half& a, const half& b) {
+  return __hlt(a, b);
+}
+__device__ bool operator <= (const half& a, const half& b) {
+  return __hle(a, b);
+}
+__device__ bool operator > (const half& a, const half& b) {
+  return __hgt(a, b);
+}
+__device__ bool operator >= (const half& a, const half& b) {
+  return __hge(a, b);
+}
+
+#else  // Emulate support for half floats
+
+// Definitions for CPUs and older CUDA, mostly working through conversion
+// to/from fp32.
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator + (const half& a, const half& b) {
+  return half(float(a) + float(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator * (const half& a, const half& b) {
+  return half(float(a) * float(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator - (const half& a, const half& b) {
+  return half(float(a) - float(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator / (const half& a, const half& b) {
+  return half(float(a) / float(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator - (const half& a) {
+  half result;
+  result.x = a.x ^ 0x8000;
+  return result;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half& operator += (half& a, const half& b) {
+  a = half(float(a) + float(b));
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half& operator *= (half& a, const half& b) {
+  a = half(float(a) * float(b));
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half& operator -= (half& a, const half& b) {
+  a = half(float(a) - float(b));
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half& operator /= (half& a, const half& b) {
+  a = half(float(a) / float(b));
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator == (const half& a, const half& b) {
+  return float(a) == float(b);
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator != (const half& a, const half& b) {
+  return float(a) != float(b);
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator < (const half& a, const half& b) {
+  return float(a) < float(b);
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator <= (const half& a, const half& b) {
+  return float(a) <= float(b);
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator > (const half& a, const half& b) {
+  return float(a) > float(b);
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator >= (const half& a, const half& b) {
+  return float(a) >= float(b);
+}
+
+#endif  // Emulate support for half floats
+
+// Division by an index. Do it in full float precision to avoid accuracy
+// issues in converting the denominator to half.
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator / (const half& a, Index b) {
+  return half(static_cast<float>(a) / static_cast<float>(b));
+}
+
+// Conversion routines, including fallbacks for the host or older CUDA.
+// Note that newer Intel CPUs (Haswell or newer) have vectorized versions of
+// these in hardware. If we need more performance on older/other CPUs, they are
+// also possible to vectorize directly.
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC __half_raw raw_uint16_to_half(unsigned short x) {
+  __half_raw h;
+  h.x = x;
+  return h;
+}
+
+union FP32 {
+  unsigned int u;
+  float f;
+};
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC __half_raw float_to_half_rtne(float ff) {
+#if defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300
+  __half tmp_ff = __float2half(ff);
+  return *(__half_raw*)&tmp_ff;
+
+#elif defined(EIGEN_HAS_FP16_C)
+  __half_raw h;
+  h.x = _cvtss_sh(ff, 0);
+  return h;
+
+#else
+  FP32 f; f.f = ff;
+
+  const FP32 f32infty = { 255 << 23 };
+  const FP32 f16max = { (127 + 16) << 23 };
+  const FP32 denorm_magic = { ((127 - 15) + (23 - 10) + 1) << 23 };
+  unsigned int sign_mask = 0x80000000u;
+  __half_raw o;
+  o.x = static_cast<unsigned short>(0x0u);
+
+  unsigned int sign = f.u & sign_mask;
+  f.u ^= sign;
+
+  // NOTE all the integer compares in this function can be safely
+  // compiled into signed compares since all operands are below
+  // 0x80000000. Important if you want fast straight SSE2 code
+  // (since there's no unsigned PCMPGTD).
+
+  if (f.u >= f16max.u) {  // result is Inf or NaN (all exponent bits set)
+    o.x = (f.u > f32infty.u) ? 0x7e00 : 0x7c00; // NaN->qNaN and Inf->Inf
+  } else {  // (De)normalized number or zero
+    if (f.u < (113 << 23)) {  // resulting FP16 is subnormal or zero
+      // use a magic value to align our 10 mantissa bits at the bottom of
+      // the float. as long as FP addition is round-to-nearest-even this
+      // just works.
+      f.f += denorm_magic.f;
+
+      // and one integer subtract of the bias later, we have our final float!
+      o.x = static_cast<unsigned short>(f.u - denorm_magic.u);
+    } else {
+      unsigned int mant_odd = (f.u >> 13) & 1; // resulting mantissa is odd
+
+      // update exponent, rounding bias part 1
+      f.u += ((unsigned int)(15 - 127) << 23) + 0xfff;
+      // rounding bias part 2
+      f.u += mant_odd;
+      // take the bits!
+      o.x = static_cast<unsigned short>(f.u >> 13);
+    }
+  }
+
+  o.x |= static_cast<unsigned short>(sign >> 16);
+  return o;
+#endif
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC float half_to_float(__half_raw h) {
+#if defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300
+  return __half2float(h);
+
+#elif defined(EIGEN_HAS_FP16_C)
+  return _cvtsh_ss(h.x);
+
+#else
+  const FP32 magic = { 113 << 23 };
+  const unsigned int shifted_exp = 0x7c00 << 13; // exponent mask after shift
+  FP32 o;
+
+  o.u = (h.x & 0x7fff) << 13;             // exponent/mantissa bits
+  unsigned int exp = shifted_exp & o.u;   // just the exponent
+  o.u += (127 - 15) << 23;                // exponent adjust
+
+  // handle exponent special cases
+  if (exp == shifted_exp) {     // Inf/NaN?
+    o.u += (128 - 16) << 23;    // extra exp adjust
+  } else if (exp == 0) {        // Zero/Denormal?
+    o.u += 1 << 23;             // extra exp adjust
+    o.f -= magic.f;             // renormalize
+  }
+
+  o.u |= (h.x & 0x8000) << 16;    // sign bit
+  return o.f;
+#endif
+}
+
+// --- standard functions ---
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool (isinf)(const half& a) {
+  return (a.x & 0x7fff) == 0x7c00;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool (isnan)(const half& a) {
+#if defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 530
+  return __hisnan(a);
+#else
+  return (a.x & 0x7fff) > 0x7c00;
+#endif
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool (isfinite)(const half& a) {
+  return !(isinf EIGEN_NOT_A_MACRO (a)) && !(isnan EIGEN_NOT_A_MACRO (a));
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half abs(const half& a) {
+  half result;
+  result.x = a.x & 0x7FFF;
+  return result;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half exp(const half& a) {
+#if EIGEN_CUDACC_VER >= 80000 && defined EIGEN_CUDA_ARCH && EIGEN_CUDA_ARCH >= 530
+  return half(hexp(a));
+#else
+   return half(::expf(float(a)));
+#endif
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half expm1(const half& a) {
+  return half(numext::expm1(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half log(const half& a) {
+#if defined(EIGEN_HAS_CUDA_FP16) && EIGEN_CUDACC_VER >= 80000 && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 530
+  return half(::hlog(a));
+#else
+  return half(::logf(float(a)));
+#endif
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half log1p(const half& a) {
+  return half(numext::log1p(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half log10(const half& a) {
+  return half(::log10f(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half sqrt(const half& a) {
+#if EIGEN_CUDACC_VER >= 80000 && defined EIGEN_CUDA_ARCH && EIGEN_CUDA_ARCH >= 530
+  return half(hsqrt(a));
+#else
+    return half(::sqrtf(float(a)));
+#endif
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half pow(const half& a, const half& b) {
+  return half(::powf(float(a), float(b)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half sin(const half& a) {
+  return half(::sinf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half cos(const half& a) {
+  return half(::cosf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half tan(const half& a) {
+  return half(::tanf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half tanh(const half& a) {
+  return half(::tanhf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half floor(const half& a) {
+#if EIGEN_CUDACC_VER >= 80000 && defined EIGEN_CUDA_ARCH && EIGEN_CUDA_ARCH >= 300
+  return half(hfloor(a));
+#else
+  return half(::floorf(float(a)));
+#endif
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half ceil(const half& a) {
+#if EIGEN_CUDACC_VER >= 80000 && defined EIGEN_CUDA_ARCH && EIGEN_CUDA_ARCH >= 300
+  return half(hceil(a));
+#else
+  return half(::ceilf(float(a)));
+#endif
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half (min)(const half& a, const half& b) {
+#if defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 530
+  return __hlt(b, a) ? b : a;
+#else
+  const float f1 = static_cast<float>(a);
+  const float f2 = static_cast<float>(b);
+  return f2 < f1 ? b : a;
+#endif
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half (max)(const half& a, const half& b) {
+#if defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 530
+  return __hlt(a, b) ? b : a;
+#else
+  const float f1 = static_cast<float>(a);
+  const float f2 = static_cast<float>(b);
+  return f1 < f2 ? b : a;
+#endif
+}
+
+EIGEN_ALWAYS_INLINE std::ostream& operator << (std::ostream& os, const half& v) {
+  os << static_cast<float>(v);
+  return os;
+}
+
+} // end namespace half_impl
+
+// import Eigen::half_impl::half into Eigen namespace
+// using half_impl::half;
+
+namespace internal {
+
+template<>
+struct random_default_impl<half, false, false>
+{
+  static inline half run(const half& x, const half& y)
+  {
+    return x + (y-x) * half(float(std::rand()) / float(RAND_MAX));
+  }
+  static inline half run()
+  {
+    return run(half(-1.f), half(1.f));
+  }
+};
+
+template<> struct is_arithmetic<half> { enum { value = true }; };
+
+} // end namespace internal
+
+}  // end namespace Eigen
+
+namespace std {
+template<>
+struct numeric_limits<Eigen::half> {
+  static const bool is_specialized = true;
+  static const bool is_signed = true;
+  static const bool is_integer = false;
+  static const bool is_exact = false;
+  static const bool has_infinity = true;
+  static const bool has_quiet_NaN = true;
+  static const bool has_signaling_NaN = true;
+  static const float_denorm_style has_denorm = denorm_present;
+  static const bool has_denorm_loss = false;
+  static const std::float_round_style round_style = std::round_to_nearest;
+  static const bool is_iec559 = false;
+  static const bool is_bounded = false;
+  static const bool is_modulo = false;
+  static const int digits = 11;
+  static const int digits10 = 3;      // according to http://half.sourceforge.net/structstd_1_1numeric__limits_3_01half__float_1_1half_01_4.html
+  static const int max_digits10 = 5;  // according to http://half.sourceforge.net/structstd_1_1numeric__limits_3_01half__float_1_1half_01_4.html
+  static const int radix = 2;
+  static const int min_exponent = -13;
+  static const int min_exponent10 = -4;
+  static const int max_exponent = 16;
+  static const int max_exponent10 = 4;
+  static const bool traps = true;
+  static const bool tinyness_before = false;
+
+  static Eigen::half (min)() { return Eigen::half_impl::raw_uint16_to_half(0x400); }
+  static Eigen::half lowest() { return Eigen::half_impl::raw_uint16_to_half(0xfbff); }
+  static Eigen::half (max)() { return Eigen::half_impl::raw_uint16_to_half(0x7bff); }
+  static Eigen::half epsilon() { return Eigen::half_impl::raw_uint16_to_half(0x0800); }
+  static Eigen::half round_error() { return Eigen::half(0.5); }
+  static Eigen::half infinity() { return Eigen::half_impl::raw_uint16_to_half(0x7c00); }
+  static Eigen::half quiet_NaN() { return Eigen::half_impl::raw_uint16_to_half(0x7e00); }
+  static Eigen::half signaling_NaN() { return Eigen::half_impl::raw_uint16_to_half(0x7e00); }
+  static Eigen::half denorm_min() { return Eigen::half_impl::raw_uint16_to_half(0x1); }
+};
+}
+
+namespace Eigen {
+
+template<> struct NumTraits<Eigen::half>
+    : GenericNumTraits<Eigen::half>
+{
+  enum {
+    IsSigned = true,
+    IsInteger = false,
+    IsComplex = false,
+    RequireInitialization = false
+  };
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Eigen::half epsilon() {
+    return half_impl::raw_uint16_to_half(0x0800);
+  }
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Eigen::half dummy_precision() { return Eigen::half(1e-2f); }
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Eigen::half highest() {
+    return half_impl::raw_uint16_to_half(0x7bff);
+  }
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Eigen::half lowest() {
+    return half_impl::raw_uint16_to_half(0xfbff);
+  }
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Eigen::half infinity() {
+    return half_impl::raw_uint16_to_half(0x7c00);
+  }
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Eigen::half quiet_NaN() {
+    return half_impl::raw_uint16_to_half(0x7c01);
+  }
+};
+
+} // end namespace Eigen
+
+// C-like standard mathematical functions and trancendentals.
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half fabsh(const Eigen::half& a) {
+  Eigen::half result;
+  result.x = a.x & 0x7FFF;
+  return result;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half exph(const Eigen::half& a) {
+  return Eigen::half(::expf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half logh(const Eigen::half& a) {
+#if EIGEN_CUDACC_VER >= 80000 && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 530
+  return Eigen::half(::hlog(a));
+#else
+  return Eigen::half(::logf(float(a)));
+#endif
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half sqrth(const Eigen::half& a) {
+  return Eigen::half(::sqrtf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half powh(const Eigen::half& a, const Eigen::half& b) {
+  return Eigen::half(::powf(float(a), float(b)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half floorh(const Eigen::half& a) {
+  return Eigen::half(::floorf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half ceilh(const Eigen::half& a) {
+  return Eigen::half(::ceilf(float(a)));
+}
+
+namespace std {
+
+#if __cplusplus > 199711L
+template <>
+struct hash<Eigen::half> {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::size_t operator()(const Eigen::half& a) const {
+    return static_cast<std::size_t>(a.x);
+  }
+};
+#endif
+
+} // end namespace std
+
+
+// Add the missing shfl_xor intrinsic
+#if defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300
+__device__ EIGEN_STRONG_INLINE Eigen::half __shfl_xor(Eigen::half var, int laneMask, int width=warpSize) {
+  #if EIGEN_CUDACC_VER < 90000
+  return static_cast<Eigen::half>(__shfl_xor(static_cast<float>(var), laneMask, width));
+  #else
+  return static_cast<Eigen::half>(__shfl_xor_sync(0xFFFFFFFF, static_cast<float>(var), laneMask, width));
+  #endif
+}
+#endif
+
+// ldg() has an overload for __half_raw, but we also need one for Eigen::half.
+#if defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 350
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half __ldg(const Eigen::half* ptr) {
+  return Eigen::half_impl::raw_uint16_to_half(
+      __ldg(reinterpret_cast<const unsigned short*>(ptr)));
+}
+#endif
+
+
+#if defined(EIGEN_CUDA_ARCH)
+namespace Eigen {
+namespace numext {
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+bool (isnan)(const Eigen::half& h) {
+  return (half_impl::isnan)(h);
+}
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+bool (isinf)(const Eigen::half& h) {
+  return (half_impl::isinf)(h);
+}
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+bool (isfinite)(const Eigen::half& h) {
+  return (half_impl::isfinite)(h);
+}
+
+} // namespace Eigen
+}  // namespace numext
+#endif
+
+#endif // EIGEN_HALF_CUDA_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/CUDA/MathFunctions.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/CUDA/MathFunctions.h
new file mode 100644
index 00000000..ff6256ce
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/CUDA/MathFunctions.h
@@ -0,0 +1,103 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATH_FUNCTIONS_CUDA_H
+#define EIGEN_MATH_FUNCTIONS_CUDA_H
+
+namespace Eigen {
+
+namespace internal {
+
+// Make sure this is only available when targeting a GPU: we don't want to
+// introduce conflicts between these packet_traits definitions and the ones
+// we'll use on the host side (SSE, AVX, ...)
+#if defined(EIGEN_CUDACC) && defined(EIGEN_USE_GPU)
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+float4 plog<float4>(const float4& a)
+{
+  return make_float4(logf(a.x), logf(a.y), logf(a.z), logf(a.w));
+}
+
+template<>  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+double2 plog<double2>(const double2& a)
+{
+  using ::log;
+  return make_double2(log(a.x), log(a.y));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+float4 plog1p<float4>(const float4& a)
+{
+  return make_float4(log1pf(a.x), log1pf(a.y), log1pf(a.z), log1pf(a.w));
+}
+
+template<>  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+double2 plog1p<double2>(const double2& a)
+{
+  return make_double2(log1p(a.x), log1p(a.y));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+float4 pexp<float4>(const float4& a)
+{
+  return make_float4(expf(a.x), expf(a.y), expf(a.z), expf(a.w));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+double2 pexp<double2>(const double2& a)
+{
+  using ::exp;
+  return make_double2(exp(a.x), exp(a.y));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+float4 pexpm1<float4>(const float4& a)
+{
+  return make_float4(expm1f(a.x), expm1f(a.y), expm1f(a.z), expm1f(a.w));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+double2 pexpm1<double2>(const double2& a)
+{
+  return make_double2(expm1(a.x), expm1(a.y));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+float4 psqrt<float4>(const float4& a)
+{
+  return make_float4(sqrtf(a.x), sqrtf(a.y), sqrtf(a.z), sqrtf(a.w));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+double2 psqrt<double2>(const double2& a)
+{
+  using ::sqrt;
+  return make_double2(sqrt(a.x), sqrt(a.y));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+float4 prsqrt<float4>(const float4& a)
+{
+  return make_float4(rsqrtf(a.x), rsqrtf(a.y), rsqrtf(a.z), rsqrtf(a.w));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+double2 prsqrt<double2>(const double2& a)
+{
+  return make_double2(rsqrt(a.x), rsqrt(a.y));
+}
+
+
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_MATH_FUNCTIONS_CUDA_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/CUDA/PacketMath.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/CUDA/PacketMath.h
new file mode 100644
index 00000000..97a8abe5
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/CUDA/PacketMath.h
@@ -0,0 +1,333 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PACKET_MATH_CUDA_H
+#define EIGEN_PACKET_MATH_CUDA_H
+
+namespace Eigen {
+
+namespace internal {
+
+// Make sure this is only available when targeting a GPU: we don't want to
+// introduce conflicts between these packet_traits definitions and the ones
+// we'll use on the host side (SSE, AVX, ...)
+#if defined(EIGEN_CUDACC) && defined(EIGEN_USE_GPU)
+template<> struct is_arithmetic<float4>  { enum { value = true }; };
+template<> struct is_arithmetic<double2> { enum { value = true }; };
+
+template<> struct packet_traits<float> : default_packet_traits
+{
+  typedef float4 type;
+  typedef float4 half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=4,
+    HasHalfPacket = 0,
+
+    HasDiv  = 1,
+    HasSin  = 0,
+    HasCos  = 0,
+    HasLog  = 1,
+    HasExp  = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasLGamma = 1,
+    HasDiGamma = 1,
+    HasZeta = 1,
+    HasPolygamma = 1,
+    HasErf = 1,
+    HasErfc = 1,
+    HasIGamma = 1,
+    HasIGammac = 1,
+    HasBetaInc = 1,
+
+    HasBlend = 0,
+  };
+};
+
+template<> struct packet_traits<double> : default_packet_traits
+{
+  typedef double2 type;
+  typedef double2 half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=2,
+    HasHalfPacket = 0,
+
+    HasDiv  = 1,
+    HasLog  = 1,
+    HasExp  = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasLGamma = 1,
+    HasDiGamma = 1,
+    HasZeta = 1,
+    HasPolygamma = 1,
+    HasErf = 1,
+    HasErfc = 1,
+    HasIGamma = 1,
+    HasIGammac = 1,
+    HasBetaInc = 1,
+
+    HasBlend = 0,
+  };
+};
+
+
+template<> struct unpacket_traits<float4>  { typedef float  type; enum {size=4, alignment=Aligned16}; typedef float4 half; };
+template<> struct unpacket_traits<double2> { typedef double type; enum {size=2, alignment=Aligned16}; typedef double2 half; };
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pset1<float4>(const float&  from) {
+  return make_float4(from, from, from, from);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pset1<double2>(const double& from) {
+  return make_double2(from, from);
+}
+
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 plset<float4>(const float& a) {
+  return make_float4(a, a+1, a+2, a+3);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 plset<double2>(const double& a) {
+  return make_double2(a, a+1);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 padd<float4>(const float4& a, const float4& b) {
+  return make_float4(a.x+b.x, a.y+b.y, a.z+b.z, a.w+b.w);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 padd<double2>(const double2& a, const double2& b) {
+  return make_double2(a.x+b.x, a.y+b.y);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 psub<float4>(const float4& a, const float4& b) {
+  return make_float4(a.x-b.x, a.y-b.y, a.z-b.z, a.w-b.w);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 psub<double2>(const double2& a, const double2& b) {
+  return make_double2(a.x-b.x, a.y-b.y);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pnegate(const float4& a) {
+  return make_float4(-a.x, -a.y, -a.z, -a.w);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pnegate(const double2& a) {
+  return make_double2(-a.x, -a.y);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pconj(const float4& a) { return a; }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pconj(const double2& a) { return a; }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pmul<float4>(const float4& a, const float4& b) {
+  return make_float4(a.x*b.x, a.y*b.y, a.z*b.z, a.w*b.w);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pmul<double2>(const double2& a, const double2& b) {
+  return make_double2(a.x*b.x, a.y*b.y);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pdiv<float4>(const float4& a, const float4& b) {
+  return make_float4(a.x/b.x, a.y/b.y, a.z/b.z, a.w/b.w);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pdiv<double2>(const double2& a, const double2& b) {
+  return make_double2(a.x/b.x, a.y/b.y);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pmin<float4>(const float4& a, const float4& b) {
+  return make_float4(fminf(a.x, b.x), fminf(a.y, b.y), fminf(a.z, b.z), fminf(a.w, b.w));
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pmin<double2>(const double2& a, const double2& b) {
+  return make_double2(fmin(a.x, b.x), fmin(a.y, b.y));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pmax<float4>(const float4& a, const float4& b) {
+  return make_float4(fmaxf(a.x, b.x), fmaxf(a.y, b.y), fmaxf(a.z, b.z), fmaxf(a.w, b.w));
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pmax<double2>(const double2& a, const double2& b) {
+  return make_double2(fmax(a.x, b.x), fmax(a.y, b.y));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pload<float4>(const float* from) {
+  return *reinterpret_cast<const float4*>(from);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pload<double2>(const double* from) {
+  return *reinterpret_cast<const double2*>(from);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 ploadu<float4>(const float* from) {
+  return make_float4(from[0], from[1], from[2], from[3]);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 ploadu<double2>(const double* from) {
+  return make_double2(from[0], from[1]);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 ploaddup<float4>(const float*   from) {
+  return make_float4(from[0], from[0], from[1], from[1]);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 ploaddup<double2>(const double*  from) {
+  return make_double2(from[0], from[0]);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pstore<float>(float*   to, const float4& from) {
+  *reinterpret_cast<float4*>(to) = from;
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pstore<double>(double* to, const double2& from) {
+  *reinterpret_cast<double2*>(to) = from;
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pstoreu<float>(float*  to, const float4& from) {
+  to[0] = from.x;
+  to[1] = from.y;
+  to[2] = from.z;
+  to[3] = from.w;
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pstoreu<double>(double* to, const double2& from) {
+  to[0] = from.x;
+  to[1] = from.y;
+}
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float4 ploadt_ro<float4, Aligned>(const float* from) {
+#if defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 350
+  return __ldg((const float4*)from);
+#else
+  return make_float4(from[0], from[1], from[2], from[3]);
+#endif
+}
+template<>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double2 ploadt_ro<double2, Aligned>(const double* from) {
+#if defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 350
+  return __ldg((const double2*)from);
+#else
+  return make_double2(from[0], from[1]);
+#endif
+}
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float4 ploadt_ro<float4, Unaligned>(const float* from) {
+#if defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 350
+  return make_float4(__ldg(from+0), __ldg(from+1), __ldg(from+2), __ldg(from+3));
+#else
+  return make_float4(from[0], from[1], from[2], from[3]);
+#endif
+}
+template<>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double2 ploadt_ro<double2, Unaligned>(const double* from) {
+#if defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 350
+  return make_double2(__ldg(from+0), __ldg(from+1));
+#else
+  return make_double2(from[0], from[1]);
+#endif
+}
+
+template<> EIGEN_DEVICE_FUNC inline float4 pgather<float, float4>(const float* from, Index stride) {
+  return make_float4(from[0*stride], from[1*stride], from[2*stride], from[3*stride]);
+}
+
+template<> EIGEN_DEVICE_FUNC inline double2 pgather<double, double2>(const double* from, Index stride) {
+  return make_double2(from[0*stride], from[1*stride]);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<float, float4>(float* to, const float4& from, Index stride) {
+  to[stride*0] = from.x;
+  to[stride*1] = from.y;
+  to[stride*2] = from.z;
+  to[stride*3] = from.w;
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<double, double2>(double* to, const double2& from, Index stride) {
+  to[stride*0] = from.x;
+  to[stride*1] = from.y;
+}
+
+template<> EIGEN_DEVICE_FUNC inline float  pfirst<float4>(const float4& a) {
+  return a.x;
+}
+template<> EIGEN_DEVICE_FUNC inline double pfirst<double2>(const double2& a) {
+  return a.x;
+}
+
+template<> EIGEN_DEVICE_FUNC inline float  predux<float4>(const float4& a) {
+  return a.x + a.y + a.z + a.w;
+}
+template<> EIGEN_DEVICE_FUNC inline double predux<double2>(const double2& a) {
+  return a.x + a.y;
+}
+
+template<> EIGEN_DEVICE_FUNC inline float  predux_max<float4>(const float4& a) {
+  return fmaxf(fmaxf(a.x, a.y), fmaxf(a.z, a.w));
+}
+template<> EIGEN_DEVICE_FUNC inline double predux_max<double2>(const double2& a) {
+  return fmax(a.x, a.y);
+}
+
+template<> EIGEN_DEVICE_FUNC inline float  predux_min<float4>(const float4& a) {
+  return fminf(fminf(a.x, a.y), fminf(a.z, a.w));
+}
+template<> EIGEN_DEVICE_FUNC inline double predux_min<double2>(const double2& a) {
+  return fmin(a.x, a.y);
+}
+
+template<> EIGEN_DEVICE_FUNC inline float  predux_mul<float4>(const float4& a) {
+  return a.x * a.y * a.z * a.w;
+}
+template<> EIGEN_DEVICE_FUNC inline double predux_mul<double2>(const double2& a) {
+  return a.x * a.y;
+}
+
+template<> EIGEN_DEVICE_FUNC inline float4  pabs<float4>(const float4& a) {
+  return make_float4(fabsf(a.x), fabsf(a.y), fabsf(a.z), fabsf(a.w));
+}
+template<> EIGEN_DEVICE_FUNC inline double2 pabs<double2>(const double2& a) {
+  return make_double2(fabs(a.x), fabs(a.y));
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<float4,4>& kernel) {
+  float tmp = kernel.packet[0].y;
+  kernel.packet[0].y = kernel.packet[1].x;
+  kernel.packet[1].x = tmp;
+
+  tmp = kernel.packet[0].z;
+  kernel.packet[0].z = kernel.packet[2].x;
+  kernel.packet[2].x = tmp;
+
+  tmp = kernel.packet[0].w;
+  kernel.packet[0].w = kernel.packet[3].x;
+  kernel.packet[3].x = tmp;
+
+  tmp = kernel.packet[1].z;
+  kernel.packet[1].z = kernel.packet[2].y;
+  kernel.packet[2].y = tmp;
+
+  tmp = kernel.packet[1].w;
+  kernel.packet[1].w = kernel.packet[3].y;
+  kernel.packet[3].y = tmp;
+
+  tmp = kernel.packet[2].w;
+  kernel.packet[2].w = kernel.packet[3].z;
+  kernel.packet[3].z = tmp;
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<double2,2>& kernel) {
+  double tmp = kernel.packet[0].y;
+  kernel.packet[0].y = kernel.packet[1].x;
+  kernel.packet[1].x = tmp;
+}
+
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+
+#endif // EIGEN_PACKET_MATH_CUDA_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/CUDA/PacketMathHalf.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/CUDA/PacketMathHalf.h
new file mode 100644
index 00000000..ce48e4b3
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/CUDA/PacketMathHalf.h
@@ -0,0 +1,1133 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PACKET_MATH_HALF_CUDA_H
+#define EIGEN_PACKET_MATH_HALF_CUDA_H
+
+
+namespace Eigen {
+namespace internal {
+
+// Most of the following operations require arch >= 3.0
+#if defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDACC) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300
+
+template<> struct is_arithmetic<half2> { enum { value = true }; };
+
+template<> struct packet_traits<Eigen::half> : default_packet_traits
+{
+  typedef half2 type;
+  typedef half2 half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=2,
+    HasHalfPacket = 0,
+    HasAdd    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasSqrt   = 1,
+    HasRsqrt  = 1,
+    HasExp    = 1,
+    HasExpm1  = 1,
+    HasLog    = 1,
+    HasLog1p  = 1
+  };
+};
+
+template<> struct unpacket_traits<half2> { typedef Eigen::half type; enum {size=2, alignment=Aligned16}; typedef half2 half; };
+
+template<> __device__ EIGEN_STRONG_INLINE half2 pset1<half2>(const Eigen::half& from) {
+  return __half2half2(from);
+}
+
+template<> __device__ EIGEN_STRONG_INLINE half2 pload<half2>(const Eigen::half* from) {
+  return *reinterpret_cast<const half2*>(from);
+}
+
+template<> __device__ EIGEN_STRONG_INLINE half2 ploadu<half2>(const Eigen::half* from) {
+  return __halves2half2(from[0], from[1]);
+}
+
+template<> __device__ EIGEN_STRONG_INLINE half2 ploaddup<half2>(const Eigen::half*  from) {
+  return __halves2half2(from[0], from[0]);
+}
+
+template<> __device__ EIGEN_STRONG_INLINE void pstore<Eigen::half>(Eigen::half* to, const half2& from) {
+  *reinterpret_cast<half2*>(to) = from;
+}
+
+template<> __device__ EIGEN_STRONG_INLINE void pstoreu<Eigen::half>(Eigen::half* to, const half2& from) {
+  to[0] = __low2half(from);
+  to[1] = __high2half(from);
+}
+
+template<>
+ __device__ EIGEN_ALWAYS_INLINE half2 ploadt_ro<half2, Aligned>(const Eigen::half* from) {
+#if EIGEN_CUDA_ARCH >= 350
+   return __ldg((const half2*)from);
+#else
+  return __halves2half2(*(from+0), *(from+1));
+#endif
+}
+
+template<>
+__device__ EIGEN_ALWAYS_INLINE half2 ploadt_ro<half2, Unaligned>(const Eigen::half* from) {
+#if EIGEN_CUDA_ARCH >= 350
+   return __halves2half2(__ldg(from+0), __ldg(from+1));
+#else
+  return __halves2half2(*(from+0), *(from+1));
+#endif
+}
+
+template<> __device__ EIGEN_STRONG_INLINE half2 pgather<Eigen::half, half2>(const Eigen::half* from, Index stride) {
+  return __halves2half2(from[0*stride], from[1*stride]);
+}
+
+template<> __device__ EIGEN_STRONG_INLINE void pscatter<Eigen::half, half2>(Eigen::half* to, const half2& from, Index stride) {
+  to[stride*0] = __low2half(from);
+  to[stride*1] = __high2half(from);
+}
+
+template<> __device__ EIGEN_STRONG_INLINE Eigen::half pfirst<half2>(const half2& a) {
+  return __low2half(a);
+}
+
+template<> __device__ EIGEN_STRONG_INLINE half2 pabs<half2>(const half2& a) {
+  half2 result;
+  unsigned temp = *(reinterpret_cast<const unsigned*>(&(a)));
+  *(reinterpret_cast<unsigned*>(&(result))) = temp & 0x7FFF7FFF;
+  return result;
+}
+
+
+__device__ EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<half2,2>& kernel) {
+  __half a1 = __low2half(kernel.packet[0]);
+  __half a2 = __high2half(kernel.packet[0]);
+  __half b1 = __low2half(kernel.packet[1]);
+  __half b2 = __high2half(kernel.packet[1]);
+  kernel.packet[0] = __halves2half2(a1, b1);
+  kernel.packet[1] = __halves2half2(a2, b2);
+}
+
+template<> __device__ EIGEN_STRONG_INLINE half2 plset<half2>(const Eigen::half& a) {
+#if EIGEN_CUDA_ARCH >= 530
+  return __halves2half2(a, __hadd(a, __float2half(1.0f)));
+#else
+  float f = __half2float(a) + 1.0f;
+  return __halves2half2(a, __float2half(f));
+#endif
+}
+
+template<> __device__ EIGEN_STRONG_INLINE half2 padd<half2>(const half2& a, const half2& b) {
+#if EIGEN_CUDA_ARCH >= 530
+  return __hadd2(a, b);
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  float r1 = a1 + b1;
+  float r2 = a2 + b2;
+  return __floats2half2_rn(r1, r2);
+#endif
+}
+
+template<> __device__ EIGEN_STRONG_INLINE half2 psub<half2>(const half2& a, const half2& b) {
+#if EIGEN_CUDA_ARCH >= 530
+  return __hsub2(a, b);
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  float r1 = a1 - b1;
+  float r2 = a2 - b2;
+  return __floats2half2_rn(r1, r2);
+#endif
+}
+
+template<> __device__ EIGEN_STRONG_INLINE half2 pnegate(const half2& a) {
+#if EIGEN_CUDA_ARCH >= 530
+  return __hneg2(a);
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  return __floats2half2_rn(-a1, -a2);
+#endif
+}
+
+template<> __device__ EIGEN_STRONG_INLINE half2 pconj(const half2& a) { return a; }
+
+template<> __device__ EIGEN_STRONG_INLINE half2 pmul<half2>(const half2& a, const half2& b) {
+#if EIGEN_CUDA_ARCH >= 530
+  return __hmul2(a, b);
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  float r1 = a1 * b1;
+  float r2 = a2 * b2;
+  return __floats2half2_rn(r1, r2);
+#endif
+}
+
+template<> __device__ EIGEN_STRONG_INLINE half2 pmadd<half2>(const half2& a, const half2& b, const half2& c) {
+#if EIGEN_CUDA_ARCH >= 530
+   return __hfma2(a, b, c);
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  float c1 = __low2float(c);
+  float c2 = __high2float(c);
+  float r1 = a1 * b1 + c1;
+  float r2 = a2 * b2 + c2;
+  return __floats2half2_rn(r1, r2);
+#endif
+}
+
+template<> __device__ EIGEN_STRONG_INLINE half2 pdiv<half2>(const half2& a, const half2& b) {
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  float r1 = a1 / b1;
+  float r2 = a2 / b2;
+  return __floats2half2_rn(r1, r2);
+}
+
+template<> __device__ EIGEN_STRONG_INLINE half2 pmin<half2>(const half2& a, const half2& b) {
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  __half r1 = a1 < b1 ? __low2half(a) : __low2half(b);
+  __half r2 = a2 < b2 ? __high2half(a) : __high2half(b);
+  return __halves2half2(r1, r2);
+}
+
+template<> __device__ EIGEN_STRONG_INLINE half2 pmax<half2>(const half2& a, const half2& b) {
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  __half r1 = a1 > b1 ? __low2half(a) : __low2half(b);
+  __half r2 = a2 > b2 ? __high2half(a) : __high2half(b);
+  return __halves2half2(r1, r2);
+}
+
+template<> __device__ EIGEN_STRONG_INLINE Eigen::half predux<half2>(const half2& a) {
+#if EIGEN_CUDA_ARCH >= 530
+  return __hadd(__low2half(a), __high2half(a));
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  return Eigen::half(half_impl::raw_uint16_to_half(__float2half_rn(a1 + a2)));
+#endif
+}
+
+template<> __device__ EIGEN_STRONG_INLINE Eigen::half predux_max<half2>(const half2& a) {
+#if EIGEN_CUDA_ARCH >= 530
+  __half first = __low2half(a);
+  __half second = __high2half(a);
+  return __hgt(first, second) ? first : second;
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  return a1 > a2 ? __low2half(a) : __high2half(a);
+#endif
+}
+
+template<> __device__ EIGEN_STRONG_INLINE Eigen::half predux_min<half2>(const half2& a) {
+#if EIGEN_CUDA_ARCH >= 530
+  __half first = __low2half(a);
+  __half second = __high2half(a);
+  return __hlt(first, second) ? first : second;
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  return a1 < a2 ? __low2half(a) : __high2half(a);
+#endif
+}
+
+template<> __device__ EIGEN_STRONG_INLINE Eigen::half predux_mul<half2>(const half2& a) {
+#if EIGEN_CUDA_ARCH >= 530
+  return __hmul(__low2half(a), __high2half(a));
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  return Eigen::half(half_impl::raw_uint16_to_half(__float2half_rn(a1 * a2)));
+#endif
+}
+
+template<> __device__ EIGEN_STRONG_INLINE half2 plog1p<half2>(const half2& a) {
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float r1 = log1pf(a1);
+  float r2 = log1pf(a2);
+  return __floats2half2_rn(r1, r2);
+}
+
+template<> __device__ EIGEN_STRONG_INLINE half2 pexpm1<half2>(const half2& a) {
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float r1 = expm1f(a1);
+  float r2 = expm1f(a2);
+  return __floats2half2_rn(r1, r2);
+}
+
+#if EIGEN_CUDACC_VER >= 80000 && defined EIGEN_CUDA_ARCH && EIGEN_CUDA_ARCH >= 530
+
+template<>  __device__ EIGEN_STRONG_INLINE
+half2 plog<half2>(const half2& a) {
+  return h2log(a);
+}
+
+template<> __device__ EIGEN_STRONG_INLINE
+half2 pexp<half2>(const half2& a) {
+  return h2exp(a);
+}
+
+template<> __device__ EIGEN_STRONG_INLINE
+half2 psqrt<half2>(const half2& a) {
+  return h2sqrt(a);
+}
+
+template<> __device__ EIGEN_STRONG_INLINE
+half2 prsqrt<half2>(const half2& a) {
+  return h2rsqrt(a);
+}
+
+#else
+
+template<> __device__ EIGEN_STRONG_INLINE half2 plog<half2>(const half2& a) {
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float r1 = logf(a1);
+  float r2 = logf(a2);
+  return __floats2half2_rn(r1, r2);
+}
+
+template<> __device__ EIGEN_STRONG_INLINE half2 pexp<half2>(const half2& a) {
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float r1 = expf(a1);
+  float r2 = expf(a2);
+  return __floats2half2_rn(r1, r2);
+}
+
+template<> __device__ EIGEN_STRONG_INLINE half2 psqrt<half2>(const half2& a) {
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float r1 = sqrtf(a1);
+  float r2 = sqrtf(a2);
+  return __floats2half2_rn(r1, r2);
+}
+
+template<> __device__ EIGEN_STRONG_INLINE half2 prsqrt<half2>(const half2& a) {
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float r1 = rsqrtf(a1);
+  float r2 = rsqrtf(a2);
+  return __floats2half2_rn(r1, r2);
+}
+
+#endif
+
+#elif defined EIGEN_VECTORIZE_AVX512
+
+typedef struct {
+  __m256i x;
+} Packet16h;
+
+
+template<> struct is_arithmetic<Packet16h> { enum { value = true }; };
+
+template <>
+struct packet_traits<half> : default_packet_traits {
+  typedef Packet16h type;
+  // There is no half-size packet for Packet16h.
+  typedef Packet16h half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 16,
+    HasHalfPacket = 0,
+    HasAdd    = 0,
+    HasSub    = 0,
+    HasMul    = 0,
+    HasNegate = 0,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasConj   = 0,
+    HasSetLinear = 0,
+    HasDiv = 0,
+    HasSqrt = 0,
+    HasRsqrt = 0,
+    HasExp = 0,
+    HasLog = 0,
+    HasBlend = 0
+  };
+};
+
+
+template<> struct unpacket_traits<Packet16h> { typedef Eigen::half type; enum {size=16, alignment=Aligned32}; typedef Packet16h half; };
+
+template<> EIGEN_STRONG_INLINE Packet16h pset1<Packet16h>(const Eigen::half& from) {
+  Packet16h result;
+  result.x = _mm256_set1_epi16(from.x);
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE Eigen::half pfirst<Packet16h>(const Packet16h& from) {
+  return half_impl::raw_uint16_to_half(static_cast<unsigned short>(_mm256_extract_epi16(from.x, 0)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h pload<Packet16h>(const Eigen::half* from) {
+  Packet16h result;
+  result.x = _mm256_load_si256(reinterpret_cast<const __m256i*>(from));
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h ploadu<Packet16h>(const Eigen::half* from) {
+  Packet16h result;
+  result.x = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(from));
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<half>(Eigen::half* to, const Packet16h& from) {
+  _mm256_store_si256((__m256i*)to, from.x);
+}
+
+template<> EIGEN_STRONG_INLINE void pstoreu<half>(Eigen::half* to, const Packet16h& from) {
+  _mm256_storeu_si256((__m256i*)to, from.x);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h
+ploadquad(const Eigen::half* from) {
+  Packet16h result;
+  unsigned short a = from[0].x;
+  unsigned short b = from[1].x;
+  unsigned short c = from[2].x;
+  unsigned short d = from[3].x;
+  result.x = _mm256_set_epi16(d, d, d, d, c, c, c, c, b, b, b, b, a, a, a, a);
+  return result;
+}
+
+EIGEN_STRONG_INLINE Packet16f half2float(const Packet16h& a) {
+#ifdef EIGEN_HAS_FP16_C
+  return _mm512_cvtph_ps(a.x);
+#else
+  EIGEN_ALIGN64 half aux[16];
+  pstore(aux, a);
+  float f0(aux[0]);
+  float f1(aux[1]);
+  float f2(aux[2]);
+  float f3(aux[3]);
+  float f4(aux[4]);
+  float f5(aux[5]);
+  float f6(aux[6]);
+  float f7(aux[7]);
+  float f8(aux[8]);
+  float f9(aux[9]);
+  float fa(aux[10]);
+  float fb(aux[11]);
+  float fc(aux[12]);
+  float fd(aux[13]);
+  float fe(aux[14]);
+  float ff(aux[15]);
+
+  return _mm512_set_ps(
+      ff, fe, fd, fc, fb, fa, f9, f8, f7, f6, f5, f4, f3, f2, f1, f0);
+#endif
+}
+
+EIGEN_STRONG_INLINE Packet16h float2half(const Packet16f& a) {
+#ifdef EIGEN_HAS_FP16_C
+  Packet16h result;
+  result.x = _mm512_cvtps_ph(a, _MM_FROUND_TO_NEAREST_INT|_MM_FROUND_NO_EXC);
+  return result;
+#else
+  EIGEN_ALIGN64 float aux[16];
+  pstore(aux, a);
+  half h0(aux[0]);
+  half h1(aux[1]);
+  half h2(aux[2]);
+  half h3(aux[3]);
+  half h4(aux[4]);
+  half h5(aux[5]);
+  half h6(aux[6]);
+  half h7(aux[7]);
+  half h8(aux[8]);
+  half h9(aux[9]);
+  half ha(aux[10]);
+  half hb(aux[11]);
+  half hc(aux[12]);
+  half hd(aux[13]);
+  half he(aux[14]);
+  half hf(aux[15]);
+
+  Packet16h result;
+  result.x = _mm256_set_epi16(
+      hf.x, he.x, hd.x, hc.x, hb.x, ha.x, h9.x, h8.x,
+      h7.x, h6.x, h5.x, h4.x, h3.x, h2.x, h1.x, h0.x);
+  return result;
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h padd<Packet16h>(const Packet16h& a, const Packet16h& b) {
+  Packet16f af = half2float(a);
+  Packet16f bf = half2float(b);
+  Packet16f rf = padd(af, bf);
+  return float2half(rf);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h pmul<Packet16h>(const Packet16h& a, const Packet16h& b) {
+  Packet16f af = half2float(a);
+  Packet16f bf = half2float(b);
+  Packet16f rf = pmul(af, bf);
+  return float2half(rf);
+}
+
+template<> EIGEN_STRONG_INLINE half predux<Packet16h>(const Packet16h& from) {
+  Packet16f from_float = half2float(from);
+  return half(predux(from_float));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h pgather<Eigen::half, Packet16h>(const Eigen::half* from, Index stride)
+{
+  Packet16h result;
+  result.x = _mm256_set_epi16(
+      from[15*stride].x, from[14*stride].x, from[13*stride].x, from[12*stride].x,
+      from[11*stride].x, from[10*stride].x, from[9*stride].x, from[8*stride].x,
+      from[7*stride].x, from[6*stride].x, from[5*stride].x, from[4*stride].x,
+      from[3*stride].x, from[2*stride].x, from[1*stride].x, from[0*stride].x);
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE void pscatter<half, Packet16h>(half* to, const Packet16h& from, Index stride)
+{
+  EIGEN_ALIGN64 half aux[16];
+  pstore(aux, from);
+  to[stride*0].x = aux[0].x;
+  to[stride*1].x = aux[1].x;
+  to[stride*2].x = aux[2].x;
+  to[stride*3].x = aux[3].x;
+  to[stride*4].x = aux[4].x;
+  to[stride*5].x = aux[5].x;
+  to[stride*6].x = aux[6].x;
+  to[stride*7].x = aux[7].x;
+  to[stride*8].x = aux[8].x;
+  to[stride*9].x = aux[9].x;
+  to[stride*10].x = aux[10].x;
+  to[stride*11].x = aux[11].x;
+  to[stride*12].x = aux[12].x;
+  to[stride*13].x = aux[13].x;
+  to[stride*14].x = aux[14].x;
+  to[stride*15].x = aux[15].x;
+}
+
+EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<Packet16h,16>& kernel) {
+  __m256i a = kernel.packet[0].x;
+  __m256i b = kernel.packet[1].x;
+  __m256i c = kernel.packet[2].x;
+  __m256i d = kernel.packet[3].x;
+  __m256i e = kernel.packet[4].x;
+  __m256i f = kernel.packet[5].x;
+  __m256i g = kernel.packet[6].x;
+  __m256i h = kernel.packet[7].x;
+  __m256i i = kernel.packet[8].x;
+  __m256i j = kernel.packet[9].x;
+  __m256i k = kernel.packet[10].x;
+  __m256i l = kernel.packet[11].x;
+  __m256i m = kernel.packet[12].x;
+  __m256i n = kernel.packet[13].x;
+  __m256i o = kernel.packet[14].x;
+  __m256i p = kernel.packet[15].x;
+
+  __m256i ab_07 = _mm256_unpacklo_epi16(a, b);
+  __m256i cd_07 = _mm256_unpacklo_epi16(c, d);
+  __m256i ef_07 = _mm256_unpacklo_epi16(e, f);
+  __m256i gh_07 = _mm256_unpacklo_epi16(g, h);
+  __m256i ij_07 = _mm256_unpacklo_epi16(i, j);
+  __m256i kl_07 = _mm256_unpacklo_epi16(k, l);
+  __m256i mn_07 = _mm256_unpacklo_epi16(m, n);
+  __m256i op_07 = _mm256_unpacklo_epi16(o, p);
+
+  __m256i ab_8f = _mm256_unpackhi_epi16(a, b);
+  __m256i cd_8f = _mm256_unpackhi_epi16(c, d);
+  __m256i ef_8f = _mm256_unpackhi_epi16(e, f);
+  __m256i gh_8f = _mm256_unpackhi_epi16(g, h);
+  __m256i ij_8f = _mm256_unpackhi_epi16(i, j);
+  __m256i kl_8f = _mm256_unpackhi_epi16(k, l);
+  __m256i mn_8f = _mm256_unpackhi_epi16(m, n);
+  __m256i op_8f = _mm256_unpackhi_epi16(o, p);
+
+  __m256i abcd_03 = _mm256_unpacklo_epi32(ab_07, cd_07);
+  __m256i abcd_47 = _mm256_unpackhi_epi32(ab_07, cd_07);
+  __m256i efgh_03 = _mm256_unpacklo_epi32(ef_07, gh_07);
+  __m256i efgh_47 = _mm256_unpackhi_epi32(ef_07, gh_07);
+  __m256i ijkl_03 = _mm256_unpacklo_epi32(ij_07, kl_07);
+  __m256i ijkl_47 = _mm256_unpackhi_epi32(ij_07, kl_07);
+  __m256i mnop_03 = _mm256_unpacklo_epi32(mn_07, op_07);
+  __m256i mnop_47 = _mm256_unpackhi_epi32(mn_07, op_07);
+
+  __m256i abcd_8b = _mm256_unpacklo_epi32(ab_8f, cd_8f);
+  __m256i abcd_cf = _mm256_unpackhi_epi32(ab_8f, cd_8f);
+  __m256i efgh_8b = _mm256_unpacklo_epi32(ef_8f, gh_8f);
+  __m256i efgh_cf = _mm256_unpackhi_epi32(ef_8f, gh_8f);
+  __m256i ijkl_8b = _mm256_unpacklo_epi32(ij_8f, kl_8f);
+  __m256i ijkl_cf = _mm256_unpackhi_epi32(ij_8f, kl_8f);
+  __m256i mnop_8b = _mm256_unpacklo_epi32(mn_8f, op_8f);
+  __m256i mnop_cf = _mm256_unpackhi_epi32(mn_8f, op_8f);
+
+  __m256i abcdefgh_01 = _mm256_unpacklo_epi64(abcd_03, efgh_03);
+  __m256i abcdefgh_23 = _mm256_unpackhi_epi64(abcd_03, efgh_03);
+  __m256i ijklmnop_01 = _mm256_unpacklo_epi64(ijkl_03, mnop_03);
+  __m256i ijklmnop_23 = _mm256_unpackhi_epi64(ijkl_03, mnop_03);
+  __m256i abcdefgh_45 = _mm256_unpacklo_epi64(abcd_47, efgh_47);
+  __m256i abcdefgh_67 = _mm256_unpackhi_epi64(abcd_47, efgh_47);
+  __m256i ijklmnop_45 = _mm256_unpacklo_epi64(ijkl_47, mnop_47);
+  __m256i ijklmnop_67 = _mm256_unpackhi_epi64(ijkl_47, mnop_47);
+  __m256i abcdefgh_89 = _mm256_unpacklo_epi64(abcd_8b, efgh_8b);
+  __m256i abcdefgh_ab = _mm256_unpackhi_epi64(abcd_8b, efgh_8b);
+  __m256i ijklmnop_89 = _mm256_unpacklo_epi64(ijkl_8b, mnop_8b);
+  __m256i ijklmnop_ab = _mm256_unpackhi_epi64(ijkl_8b, mnop_8b);
+  __m256i abcdefgh_cd = _mm256_unpacklo_epi64(abcd_cf, efgh_cf);
+  __m256i abcdefgh_ef = _mm256_unpackhi_epi64(abcd_cf, efgh_cf);
+  __m256i ijklmnop_cd = _mm256_unpacklo_epi64(ijkl_cf, mnop_cf);
+  __m256i ijklmnop_ef = _mm256_unpackhi_epi64(ijkl_cf, mnop_cf);
+
+  // NOTE: no unpacklo/hi instr in this case, so using permute instr.
+  __m256i a_p_0 = _mm256_permute2x128_si256(abcdefgh_01, ijklmnop_01, 0x20);
+  __m256i a_p_1 = _mm256_permute2x128_si256(abcdefgh_01, ijklmnop_01, 0x31);
+  __m256i a_p_2 = _mm256_permute2x128_si256(abcdefgh_23, ijklmnop_23, 0x20);
+  __m256i a_p_3 = _mm256_permute2x128_si256(abcdefgh_23, ijklmnop_23, 0x31);
+  __m256i a_p_4 = _mm256_permute2x128_si256(abcdefgh_45, ijklmnop_45, 0x20);
+  __m256i a_p_5 = _mm256_permute2x128_si256(abcdefgh_45, ijklmnop_45, 0x31);
+  __m256i a_p_6 = _mm256_permute2x128_si256(abcdefgh_67, ijklmnop_67, 0x20);
+  __m256i a_p_7 = _mm256_permute2x128_si256(abcdefgh_67, ijklmnop_67, 0x31);
+  __m256i a_p_8 = _mm256_permute2x128_si256(abcdefgh_89, ijklmnop_89, 0x20);
+  __m256i a_p_9 = _mm256_permute2x128_si256(abcdefgh_89, ijklmnop_89, 0x31);
+  __m256i a_p_a = _mm256_permute2x128_si256(abcdefgh_ab, ijklmnop_ab, 0x20);
+  __m256i a_p_b = _mm256_permute2x128_si256(abcdefgh_ab, ijklmnop_ab, 0x31);
+  __m256i a_p_c = _mm256_permute2x128_si256(abcdefgh_cd, ijklmnop_cd, 0x20);
+  __m256i a_p_d = _mm256_permute2x128_si256(abcdefgh_cd, ijklmnop_cd, 0x31);
+  __m256i a_p_e = _mm256_permute2x128_si256(abcdefgh_ef, ijklmnop_ef, 0x20);
+  __m256i a_p_f = _mm256_permute2x128_si256(abcdefgh_ef, ijklmnop_ef, 0x31);
+
+  kernel.packet[0].x = a_p_0;
+  kernel.packet[1].x = a_p_1;
+  kernel.packet[2].x = a_p_2;
+  kernel.packet[3].x = a_p_3;
+  kernel.packet[4].x = a_p_4;
+  kernel.packet[5].x = a_p_5;
+  kernel.packet[6].x = a_p_6;
+  kernel.packet[7].x = a_p_7;
+  kernel.packet[8].x = a_p_8;
+  kernel.packet[9].x = a_p_9;
+  kernel.packet[10].x = a_p_a;
+  kernel.packet[11].x = a_p_b;
+  kernel.packet[12].x = a_p_c;
+  kernel.packet[13].x = a_p_d;
+  kernel.packet[14].x = a_p_e;
+  kernel.packet[15].x = a_p_f;
+}
+
+EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<Packet16h,8>& kernel) {
+  EIGEN_ALIGN64 half in[8][16];
+  pstore<half>(in[0], kernel.packet[0]);
+  pstore<half>(in[1], kernel.packet[1]);
+  pstore<half>(in[2], kernel.packet[2]);
+  pstore<half>(in[3], kernel.packet[3]);
+  pstore<half>(in[4], kernel.packet[4]);
+  pstore<half>(in[5], kernel.packet[5]);
+  pstore<half>(in[6], kernel.packet[6]);
+  pstore<half>(in[7], kernel.packet[7]);
+
+  EIGEN_ALIGN64 half out[8][16];
+
+  for (int i = 0; i < 8; ++i) {
+    for (int j = 0; j < 8; ++j) {
+      out[i][j] = in[j][2*i];
+    }
+    for (int j = 0; j < 8; ++j) {
+      out[i][j+8] = in[j][2*i+1];
+    }
+  }
+
+  kernel.packet[0] = pload<Packet16h>(out[0]);
+  kernel.packet[1] = pload<Packet16h>(out[1]);
+  kernel.packet[2] = pload<Packet16h>(out[2]);
+  kernel.packet[3] = pload<Packet16h>(out[3]);
+  kernel.packet[4] = pload<Packet16h>(out[4]);
+  kernel.packet[5] = pload<Packet16h>(out[5]);
+  kernel.packet[6] = pload<Packet16h>(out[6]);
+  kernel.packet[7] = pload<Packet16h>(out[7]);
+}
+
+EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<Packet16h,4>& kernel) {
+  EIGEN_ALIGN64 half in[4][16];
+  pstore<half>(in[0], kernel.packet[0]);
+  pstore<half>(in[1], kernel.packet[1]);
+  pstore<half>(in[2], kernel.packet[2]);
+  pstore<half>(in[3], kernel.packet[3]);
+
+  EIGEN_ALIGN64 half out[4][16];
+
+  for (int i = 0; i < 4; ++i) {
+    for (int j = 0; j < 4; ++j) {
+      out[i][j] = in[j][4*i];
+    }
+    for (int j = 0; j < 4; ++j) {
+      out[i][j+4] = in[j][4*i+1];
+    }
+    for (int j = 0; j < 4; ++j) {
+      out[i][j+8] = in[j][4*i+2];
+    }
+    for (int j = 0; j < 4; ++j) {
+      out[i][j+12] = in[j][4*i+3];
+    }
+  }
+
+  kernel.packet[0] = pload<Packet16h>(out[0]);
+  kernel.packet[1] = pload<Packet16h>(out[1]);
+  kernel.packet[2] = pload<Packet16h>(out[2]);
+  kernel.packet[3] = pload<Packet16h>(out[3]);
+}
+
+
+#elif defined EIGEN_VECTORIZE_AVX
+
+typedef struct {
+  __m128i x;
+} Packet8h;
+
+
+template<> struct is_arithmetic<Packet8h> { enum { value = true }; };
+
+template <>
+struct packet_traits<Eigen::half> : default_packet_traits {
+  typedef Packet8h type;
+  // There is no half-size packet for Packet8h.
+  typedef Packet8h half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 8,
+    HasHalfPacket = 0,
+    HasAdd    = 0,
+    HasSub    = 0,
+    HasMul    = 0,
+    HasNegate = 0,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasConj   = 0,
+    HasSetLinear = 0,
+    HasDiv = 0,
+    HasSqrt = 0,
+    HasRsqrt = 0,
+    HasExp = 0,
+    HasLog = 0,
+    HasBlend = 0
+  };
+};
+
+
+template<> struct unpacket_traits<Packet8h> { typedef Eigen::half type; enum {size=8, alignment=Aligned16}; typedef Packet8h half; };
+
+template<> EIGEN_STRONG_INLINE Packet8h pset1<Packet8h>(const Eigen::half& from) {
+  Packet8h result;
+  result.x = _mm_set1_epi16(from.x);
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE Eigen::half pfirst<Packet8h>(const Packet8h& from) {
+  return half_impl::raw_uint16_to_half(static_cast<unsigned short>(_mm_extract_epi16(from.x, 0)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pload<Packet8h>(const Eigen::half* from) {
+  Packet8h result;
+  result.x = _mm_load_si128(reinterpret_cast<const __m128i*>(from));
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h ploadu<Packet8h>(const Eigen::half* from) {
+  Packet8h result;
+  result.x = _mm_loadu_si128(reinterpret_cast<const __m128i*>(from));
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<Eigen::half>(Eigen::half* to, const Packet8h& from) {
+  _mm_store_si128(reinterpret_cast<__m128i*>(to), from.x);
+}
+
+template<> EIGEN_STRONG_INLINE void pstoreu<Eigen::half>(Eigen::half* to, const Packet8h& from) {
+  _mm_storeu_si128(reinterpret_cast<__m128i*>(to), from.x);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h
+ploadquad<Packet8h>(const Eigen::half* from) {
+  Packet8h result;
+  unsigned short a = from[0].x;
+  unsigned short b = from[1].x;
+  result.x = _mm_set_epi16(b, b, b, b, a, a, a, a);
+  return result;
+}
+
+EIGEN_STRONG_INLINE Packet8f half2float(const Packet8h& a) {
+#ifdef EIGEN_HAS_FP16_C
+  return _mm256_cvtph_ps(a.x);
+#else
+  EIGEN_ALIGN32 Eigen::half aux[8];
+  pstore(aux, a);
+  float f0(aux[0]);
+  float f1(aux[1]);
+  float f2(aux[2]);
+  float f3(aux[3]);
+  float f4(aux[4]);
+  float f5(aux[5]);
+  float f6(aux[6]);
+  float f7(aux[7]);
+
+  return _mm256_set_ps(f7, f6, f5, f4, f3, f2, f1, f0);
+#endif
+}
+
+EIGEN_STRONG_INLINE Packet8h float2half(const Packet8f& a) {
+#ifdef EIGEN_HAS_FP16_C
+  Packet8h result;
+  result.x = _mm256_cvtps_ph(a, _MM_FROUND_TO_NEAREST_INT|_MM_FROUND_NO_EXC);
+  return result;
+#else
+  EIGEN_ALIGN32 float aux[8];
+  pstore(aux, a);
+  Eigen::half h0(aux[0]);
+  Eigen::half h1(aux[1]);
+  Eigen::half h2(aux[2]);
+  Eigen::half h3(aux[3]);
+  Eigen::half h4(aux[4]);
+  Eigen::half h5(aux[5]);
+  Eigen::half h6(aux[6]);
+  Eigen::half h7(aux[7]);
+
+  Packet8h result;
+  result.x = _mm_set_epi16(h7.x, h6.x, h5.x, h4.x, h3.x, h2.x, h1.x, h0.x);
+  return result;
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pconj(const Packet8h& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet8h padd<Packet8h>(const Packet8h& a, const Packet8h& b) {
+  Packet8f af = half2float(a);
+  Packet8f bf = half2float(b);
+  Packet8f rf = padd(af, bf);
+  return float2half(rf);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pmul<Packet8h>(const Packet8h& a, const Packet8h& b) {
+  Packet8f af = half2float(a);
+  Packet8f bf = half2float(b);
+  Packet8f rf = pmul(af, bf);
+  return float2half(rf);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pgather<Eigen::half, Packet8h>(const Eigen::half* from, Index stride)
+{
+  Packet8h result;
+  result.x = _mm_set_epi16(from[7*stride].x, from[6*stride].x, from[5*stride].x, from[4*stride].x, from[3*stride].x, from[2*stride].x, from[1*stride].x, from[0*stride].x);
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE void pscatter<Eigen::half, Packet8h>(Eigen::half* to, const Packet8h& from, Index stride)
+{
+  EIGEN_ALIGN32 Eigen::half aux[8];
+  pstore(aux, from);
+  to[stride*0].x = aux[0].x;
+  to[stride*1].x = aux[1].x;
+  to[stride*2].x = aux[2].x;
+  to[stride*3].x = aux[3].x;
+  to[stride*4].x = aux[4].x;
+  to[stride*5].x = aux[5].x;
+  to[stride*6].x = aux[6].x;
+  to[stride*7].x = aux[7].x;
+}
+
+template<> EIGEN_STRONG_INLINE Eigen::half predux<Packet8h>(const Packet8h& a) {
+  Packet8f af = half2float(a);
+  float reduced = predux<Packet8f>(af);
+  return Eigen::half(reduced);
+}
+
+template<> EIGEN_STRONG_INLINE Eigen::half predux_max<Packet8h>(const Packet8h& a) {
+  Packet8f af = half2float(a);
+  float reduced = predux_max<Packet8f>(af);
+  return Eigen::half(reduced);
+}
+
+template<> EIGEN_STRONG_INLINE Eigen::half predux_min<Packet8h>(const Packet8h& a) {
+  Packet8f af = half2float(a);
+  float reduced = predux_min<Packet8f>(af);
+  return Eigen::half(reduced);
+}
+
+template<> EIGEN_STRONG_INLINE Eigen::half predux_mul<Packet8h>(const Packet8h& a) {
+  Packet8f af = half2float(a);
+  float reduced = predux_mul<Packet8f>(af);
+  return Eigen::half(reduced);
+}
+
+EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<Packet8h,8>& kernel) {
+  __m128i a = kernel.packet[0].x;
+  __m128i b = kernel.packet[1].x;
+  __m128i c = kernel.packet[2].x;
+  __m128i d = kernel.packet[3].x;
+  __m128i e = kernel.packet[4].x;
+  __m128i f = kernel.packet[5].x;
+  __m128i g = kernel.packet[6].x;
+  __m128i h = kernel.packet[7].x;
+
+  __m128i a03b03 = _mm_unpacklo_epi16(a, b);
+  __m128i c03d03 = _mm_unpacklo_epi16(c, d);
+  __m128i e03f03 = _mm_unpacklo_epi16(e, f);
+  __m128i g03h03 = _mm_unpacklo_epi16(g, h);
+  __m128i a47b47 = _mm_unpackhi_epi16(a, b);
+  __m128i c47d47 = _mm_unpackhi_epi16(c, d);
+  __m128i e47f47 = _mm_unpackhi_epi16(e, f);
+  __m128i g47h47 = _mm_unpackhi_epi16(g, h);
+
+  __m128i a01b01c01d01 = _mm_unpacklo_epi32(a03b03, c03d03);
+  __m128i a23b23c23d23 = _mm_unpackhi_epi32(a03b03, c03d03);
+  __m128i e01f01g01h01 = _mm_unpacklo_epi32(e03f03, g03h03);
+  __m128i e23f23g23h23 = _mm_unpackhi_epi32(e03f03, g03h03);
+  __m128i a45b45c45d45 = _mm_unpacklo_epi32(a47b47, c47d47);
+  __m128i a67b67c67d67 = _mm_unpackhi_epi32(a47b47, c47d47);
+  __m128i e45f45g45h45 = _mm_unpacklo_epi32(e47f47, g47h47);
+  __m128i e67f67g67h67 = _mm_unpackhi_epi32(e47f47, g47h47);
+
+  __m128i a0b0c0d0e0f0g0h0 = _mm_unpacklo_epi64(a01b01c01d01, e01f01g01h01);
+  __m128i a1b1c1d1e1f1g1h1 = _mm_unpackhi_epi64(a01b01c01d01, e01f01g01h01);
+  __m128i a2b2c2d2e2f2g2h2 = _mm_unpacklo_epi64(a23b23c23d23, e23f23g23h23);
+  __m128i a3b3c3d3e3f3g3h3 = _mm_unpackhi_epi64(a23b23c23d23, e23f23g23h23);
+  __m128i a4b4c4d4e4f4g4h4 = _mm_unpacklo_epi64(a45b45c45d45, e45f45g45h45);
+  __m128i a5b5c5d5e5f5g5h5 = _mm_unpackhi_epi64(a45b45c45d45, e45f45g45h45);
+  __m128i a6b6c6d6e6f6g6h6 = _mm_unpacklo_epi64(a67b67c67d67, e67f67g67h67);
+  __m128i a7b7c7d7e7f7g7h7 = _mm_unpackhi_epi64(a67b67c67d67, e67f67g67h67);
+
+  kernel.packet[0].x = a0b0c0d0e0f0g0h0;
+  kernel.packet[1].x = a1b1c1d1e1f1g1h1;
+  kernel.packet[2].x = a2b2c2d2e2f2g2h2;
+  kernel.packet[3].x = a3b3c3d3e3f3g3h3;
+  kernel.packet[4].x = a4b4c4d4e4f4g4h4;
+  kernel.packet[5].x = a5b5c5d5e5f5g5h5;
+  kernel.packet[6].x = a6b6c6d6e6f6g6h6;
+  kernel.packet[7].x = a7b7c7d7e7f7g7h7;
+}
+
+EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<Packet8h,4>& kernel) {
+  EIGEN_ALIGN32 Eigen::half in[4][8];
+  pstore<Eigen::half>(in[0], kernel.packet[0]);
+  pstore<Eigen::half>(in[1], kernel.packet[1]);
+  pstore<Eigen::half>(in[2], kernel.packet[2]);
+  pstore<Eigen::half>(in[3], kernel.packet[3]);
+
+  EIGEN_ALIGN32 Eigen::half out[4][8];
+
+  for (int i = 0; i < 4; ++i) {
+    for (int j = 0; j < 4; ++j) {
+      out[i][j] = in[j][2*i];
+    }
+    for (int j = 0; j < 4; ++j) {
+      out[i][j+4] = in[j][2*i+1];
+    }
+  }
+
+  kernel.packet[0] = pload<Packet8h>(out[0]);
+  kernel.packet[1] = pload<Packet8h>(out[1]);
+  kernel.packet[2] = pload<Packet8h>(out[2]);
+  kernel.packet[3] = pload<Packet8h>(out[3]);
+}
+
+
+// Disable the following code since it's broken on too many platforms / compilers.
+//#elif defined(EIGEN_VECTORIZE_SSE) && (!EIGEN_ARCH_x86_64) && (!EIGEN_COMP_MSVC)
+#elif 0
+
+typedef struct {
+  __m64 x;
+} Packet4h;
+
+
+template<> struct is_arithmetic<Packet4h> { enum { value = true }; };
+
+template <>
+struct packet_traits<Eigen::half> : default_packet_traits {
+  typedef Packet4h type;
+  // There is no half-size packet for Packet4h.
+  typedef Packet4h half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket = 0,
+    HasAdd    = 0,
+    HasSub    = 0,
+    HasMul    = 0,
+    HasNegate = 0,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasConj   = 0,
+    HasSetLinear = 0,
+    HasDiv = 0,
+    HasSqrt = 0,
+    HasRsqrt = 0,
+    HasExp = 0,
+    HasLog = 0,
+    HasBlend = 0
+  };
+};
+
+
+template<> struct unpacket_traits<Packet4h> { typedef Eigen::half type; enum {size=4, alignment=Aligned16}; typedef Packet4h half; };
+
+template<> EIGEN_STRONG_INLINE Packet4h pset1<Packet4h>(const Eigen::half& from) {
+  Packet4h result;
+  result.x = _mm_set1_pi16(from.x);
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE Eigen::half pfirst<Packet4h>(const Packet4h& from) {
+  return half_impl::raw_uint16_to_half(static_cast<unsigned short>(_mm_cvtsi64_si32(from.x)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4h pconj(const Packet4h& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet4h padd<Packet4h>(const Packet4h& a, const Packet4h& b) {
+  __int64_t a64 = _mm_cvtm64_si64(a.x);
+  __int64_t b64 = _mm_cvtm64_si64(b.x);
+
+  Eigen::half h[4];
+
+  Eigen::half ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64));
+  Eigen::half hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64));
+  h[0] = ha + hb;
+  ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 16));
+  hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 16));
+  h[1] = ha + hb;
+  ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 32));
+  hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 32));
+  h[2] = ha + hb;
+  ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 48));
+  hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 48));
+  h[3] = ha + hb;
+  Packet4h result;
+  result.x = _mm_set_pi16(h[3].x, h[2].x, h[1].x, h[0].x);
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4h pmul<Packet4h>(const Packet4h& a, const Packet4h& b) {
+  __int64_t a64 = _mm_cvtm64_si64(a.x);
+  __int64_t b64 = _mm_cvtm64_si64(b.x);
+
+  Eigen::half h[4];
+
+  Eigen::half ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64));
+  Eigen::half hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64));
+  h[0] = ha * hb;
+  ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 16));
+  hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 16));
+  h[1] = ha * hb;
+  ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 32));
+  hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 32));
+  h[2] = ha * hb;
+  ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 48));
+  hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 48));
+  h[3] = ha * hb;
+  Packet4h result;
+  result.x = _mm_set_pi16(h[3].x, h[2].x, h[1].x, h[0].x);
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4h pload<Packet4h>(const Eigen::half* from) {
+  Packet4h result;
+  result.x = _mm_cvtsi64_m64(*reinterpret_cast<const __int64_t*>(from));
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4h ploadu<Packet4h>(const Eigen::half* from) {
+  Packet4h result;
+  result.x = _mm_cvtsi64_m64(*reinterpret_cast<const __int64_t*>(from));
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<Eigen::half>(Eigen::half* to, const Packet4h& from) {
+  __int64_t r = _mm_cvtm64_si64(from.x);
+  *(reinterpret_cast<__int64_t*>(to)) = r;
+}
+
+template<> EIGEN_STRONG_INLINE void pstoreu<Eigen::half>(Eigen::half* to, const Packet4h& from) {
+  __int64_t r = _mm_cvtm64_si64(from.x);
+  *(reinterpret_cast<__int64_t*>(to)) = r;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4h
+ploadquad<Packet4h>(const Eigen::half* from) {
+  return pset1<Packet4h>(*from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4h pgather<Eigen::half, Packet4h>(const Eigen::half* from, Index stride)
+{
+  Packet4h result;
+  result.x = _mm_set_pi16(from[3*stride].x, from[2*stride].x, from[1*stride].x, from[0*stride].x);
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE void pscatter<Eigen::half, Packet4h>(Eigen::half* to, const Packet4h& from, Index stride)
+{
+  __int64_t a = _mm_cvtm64_si64(from.x);
+  to[stride*0].x = static_cast<unsigned short>(a);
+  to[stride*1].x = static_cast<unsigned short>(a >> 16);
+  to[stride*2].x = static_cast<unsigned short>(a >> 32);
+  to[stride*3].x = static_cast<unsigned short>(a >> 48);
+}
+
+EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<Packet4h,4>& kernel) {
+  __m64 T0 = _mm_unpacklo_pi16(kernel.packet[0].x, kernel.packet[1].x);
+  __m64 T1 = _mm_unpacklo_pi16(kernel.packet[2].x, kernel.packet[3].x);
+  __m64 T2 = _mm_unpackhi_pi16(kernel.packet[0].x, kernel.packet[1].x);
+  __m64 T3 = _mm_unpackhi_pi16(kernel.packet[2].x, kernel.packet[3].x);
+
+  kernel.packet[0].x = _mm_unpacklo_pi32(T0, T1);
+  kernel.packet[1].x = _mm_unpackhi_pi32(T0, T1);
+  kernel.packet[2].x = _mm_unpacklo_pi32(T2, T3);
+  kernel.packet[3].x = _mm_unpackhi_pi32(T2, T3);
+}
+
+#endif
+
+}
+}
+
+#endif // EIGEN_PACKET_MATH_HALF_CUDA_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/CUDA/TypeCasting.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/CUDA/TypeCasting.h
new file mode 100644
index 00000000..30f870c3
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/CUDA/TypeCasting.h
@@ -0,0 +1,212 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TYPE_CASTING_CUDA_H
+#define EIGEN_TYPE_CASTING_CUDA_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<>
+struct scalar_cast_op<float, Eigen::half> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cast_op)
+  typedef Eigen::half result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half operator() (const float& a) const {
+    #if defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300
+      return __float2half(a);
+    #else
+      return Eigen::half(a);
+    #endif
+  }
+};
+
+template<>
+struct functor_traits<scalar_cast_op<float, Eigen::half> >
+{ enum { Cost = NumTraits<float>::AddCost, PacketAccess = false }; };
+
+
+template<>
+struct scalar_cast_op<int, Eigen::half> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cast_op)
+  typedef Eigen::half result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half operator() (const int& a) const {
+    #if defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300
+      return __float2half(static_cast<float>(a));
+    #else
+      return Eigen::half(static_cast<float>(a));
+    #endif
+  }
+};
+
+template<>
+struct functor_traits<scalar_cast_op<int, Eigen::half> >
+{ enum { Cost = NumTraits<float>::AddCost, PacketAccess = false }; };
+
+
+template<>
+struct scalar_cast_op<Eigen::half, float> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cast_op)
+  typedef float result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float operator() (const Eigen::half& a) const {
+    #if defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300
+      return __half2float(a);
+    #else
+      return static_cast<float>(a);
+    #endif
+  }
+};
+
+template<>
+struct functor_traits<scalar_cast_op<Eigen::half, float> >
+{ enum { Cost = NumTraits<float>::AddCost, PacketAccess = false }; };
+
+
+
+#if defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300
+
+template <>
+struct type_casting_traits<Eigen::half, float> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 2,
+    TgtCoeffRatio = 1
+  };
+};
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pcast<half2, float4>(const half2& a, const half2& b) {
+  float2 r1 = __half22float2(a);
+  float2 r2 = __half22float2(b);
+  return make_float4(r1.x, r1.y, r2.x, r2.y);
+}
+
+template <>
+struct type_casting_traits<float, Eigen::half> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 2
+  };
+};
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pcast<float4, half2>(const float4& a) {
+  // Simply discard the second half of the input
+  return __floats2half2_rn(a.x, a.y);
+}
+
+#elif defined EIGEN_VECTORIZE_AVX512
+template <>
+struct type_casting_traits<half, float> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet16f pcast<Packet16h, Packet16f>(const Packet16h& a) {
+  return half2float(a);
+}
+
+template <>
+struct type_casting_traits<float, half> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet16h pcast<Packet16f, Packet16h>(const Packet16f& a) {
+  return float2half(a);
+}
+
+#elif defined EIGEN_VECTORIZE_AVX
+
+template <>
+struct type_casting_traits<Eigen::half, float> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet8f pcast<Packet8h, Packet8f>(const Packet8h& a) {
+  return half2float(a);
+}
+
+template <>
+struct type_casting_traits<float, Eigen::half> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet8h pcast<Packet8f, Packet8h>(const Packet8f& a) {
+  return float2half(a);
+}
+
+// Disable the following code since it's broken on too many platforms / compilers.
+//#elif defined(EIGEN_VECTORIZE_SSE) && (!EIGEN_ARCH_x86_64) && (!EIGEN_COMP_MSVC)
+#elif 0
+
+template <>
+struct type_casting_traits<Eigen::half, float> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet4f pcast<Packet4h, Packet4f>(const Packet4h& a) {
+  __int64_t a64 = _mm_cvtm64_si64(a.x);
+  Eigen::half h = raw_uint16_to_half(static_cast<unsigned short>(a64));
+  float f1 = static_cast<float>(h);
+  h = raw_uint16_to_half(static_cast<unsigned short>(a64 >> 16));
+  float f2 = static_cast<float>(h);
+  h = raw_uint16_to_half(static_cast<unsigned short>(a64 >> 32));
+  float f3 = static_cast<float>(h);
+  h = raw_uint16_to_half(static_cast<unsigned short>(a64 >> 48));
+  float f4 = static_cast<float>(h);
+  return _mm_set_ps(f4, f3, f2, f1);
+}
+
+template <>
+struct type_casting_traits<float, Eigen::half> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet4h pcast<Packet4f, Packet4h>(const Packet4f& a) {
+  EIGEN_ALIGN16 float aux[4];
+  pstore(aux, a);
+  Eigen::half h0(aux[0]);
+  Eigen::half h1(aux[1]);
+  Eigen::half h2(aux[2]);
+  Eigen::half h3(aux[3]);
+
+  Packet4h result;
+  result.x = _mm_set_pi16(h3.x, h2.x, h1.x, h0.x);
+  return result;
+}
+
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TYPE_CASTING_CUDA_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/Default/ConjHelper.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/Default/ConjHelper.h
new file mode 100644
index 00000000..4cfe34e0
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/Default/ConjHelper.h
@@ -0,0 +1,29 @@
+
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2017 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ARCH_CONJ_HELPER_H
+#define EIGEN_ARCH_CONJ_HELPER_H
+
+#define EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(PACKET_CPLX, PACKET_REAL)                                                          \
+  template<> struct conj_helper<PACKET_REAL, PACKET_CPLX, false,false> {                                          \
+    EIGEN_STRONG_INLINE PACKET_CPLX pmadd(const PACKET_REAL& x, const PACKET_CPLX& y, const PACKET_CPLX& c) const \
+    { return padd(c, pmul(x,y)); }                                                                                \
+    EIGEN_STRONG_INLINE PACKET_CPLX pmul(const PACKET_REAL& x, const PACKET_CPLX& y) const                        \
+    { return PACKET_CPLX(Eigen::internal::pmul<PACKET_REAL>(x, y.v)); }                                           \
+  };                                                                                                              \
+                                                                                                                  \
+  template<> struct conj_helper<PACKET_CPLX, PACKET_REAL, false,false> {                                          \
+    EIGEN_STRONG_INLINE PACKET_CPLX pmadd(const PACKET_CPLX& x, const PACKET_REAL& y, const PACKET_CPLX& c) const \
+    { return padd(c, pmul(x,y)); }                                                                                \
+    EIGEN_STRONG_INLINE PACKET_CPLX pmul(const PACKET_CPLX& x, const PACKET_REAL& y) const                        \
+    { return PACKET_CPLX(Eigen::internal::pmul<PACKET_REAL>(x.v, y)); }                                           \
+  };
+
+#endif // EIGEN_ARCH_CONJ_HELPER_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/Default/Settings.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/Default/Settings.h
new file mode 100644
index 00000000..097373c8
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/Default/Settings.h
@@ -0,0 +1,49 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+/* All the parameters defined in this file can be specialized in the
+ * architecture specific files, and/or by the user.
+ * More to come... */
+
+#ifndef EIGEN_DEFAULT_SETTINGS_H
+#define EIGEN_DEFAULT_SETTINGS_H
+
+/** Defines the maximal loop size to enable meta unrolling of loops.
+  * Note that the value here is expressed in Eigen's own notion of "number of FLOPS",
+  * it does not correspond to the number of iterations or the number of instructions
+  */
+#ifndef EIGEN_UNROLLING_LIMIT
+#define EIGEN_UNROLLING_LIMIT 100
+#endif
+
+/** Defines the threshold between a "small" and a "large" matrix.
+  * This threshold is mainly used to select the proper product implementation.
+  */
+#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
+#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8
+#endif
+
+/** Defines the maximal width of the blocks used in the triangular product and solver
+  * for vectors (level 2 blas xTRMV and xTRSV). The default is 8.
+  */
+#ifndef EIGEN_TUNE_TRIANGULAR_PANEL_WIDTH
+#define EIGEN_TUNE_TRIANGULAR_PANEL_WIDTH 8
+#endif
+
+
+/** Defines the default number of registers available for that architecture.
+  * Currently it must be 8 or 16. Other values will fail.
+  */
+#ifndef EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS
+#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 8
+#endif
+
+#endif // EIGEN_DEFAULT_SETTINGS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/NEON/Complex.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/NEON/Complex.h
new file mode 100644
index 00000000..ef50ba30
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/NEON/Complex.h
@@ -0,0 +1,490 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Konstantinos Margaritis <markos@freevec.org>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLEX_NEON_H
+#define EIGEN_COMPLEX_NEON_H
+
+namespace Eigen {
+
+namespace internal {
+
+inline uint32x4_t p4ui_CONJ_XOR() {
+// See bug 1325, clang fails to call vld1q_u64.
+#if EIGEN_COMP_CLANG
+  uint32x4_t ret = { 0x00000000, 0x80000000, 0x00000000, 0x80000000 };
+  return ret;
+#else
+  static const uint32_t conj_XOR_DATA[] = { 0x00000000, 0x80000000, 0x00000000, 0x80000000 };
+  return vld1q_u32( conj_XOR_DATA );
+#endif
+}
+
+inline uint32x2_t p2ui_CONJ_XOR() {
+  static const uint32_t conj_XOR_DATA[] = { 0x00000000, 0x80000000 };
+  return vld1_u32( conj_XOR_DATA );
+}
+
+//---------- float ----------
+struct Packet2cf
+{
+  EIGEN_STRONG_INLINE Packet2cf() {}
+  EIGEN_STRONG_INLINE explicit Packet2cf(const Packet4f& a) : v(a) {}
+  Packet4f  v;
+};
+
+template<> struct packet_traits<std::complex<float> >  : default_packet_traits
+{
+  typedef Packet2cf type;
+  typedef Packet2cf half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 2,
+    HasHalfPacket = 0,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasSetLinear = 0
+  };
+};
+
+template<> struct unpacket_traits<Packet2cf> { typedef std::complex<float> type; enum {size=2, alignment=Aligned16}; typedef Packet2cf half; };
+
+template<> EIGEN_STRONG_INLINE Packet2cf pset1<Packet2cf>(const std::complex<float>&  from)
+{
+  float32x2_t r64;
+  r64 = vld1_f32((float *)&from);
+
+  return Packet2cf(vcombine_f32(r64, r64));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf padd<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(padd<Packet4f>(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf psub<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(psub<Packet4f>(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pnegate(const Packet2cf& a) { return Packet2cf(pnegate<Packet4f>(a.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pconj(const Packet2cf& a)
+{
+  Packet4ui b = vreinterpretq_u32_f32(a.v);
+  return Packet2cf(vreinterpretq_f32_u32(veorq_u32(b, p4ui_CONJ_XOR())));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pmul<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{
+  Packet4f v1, v2;
+
+  // Get the real values of a | a1_re | a1_re | a2_re | a2_re |
+  v1 = vcombine_f32(vdup_lane_f32(vget_low_f32(a.v), 0), vdup_lane_f32(vget_high_f32(a.v), 0));
+  // Get the imag values of a | a1_im | a1_im | a2_im | a2_im |
+  v2 = vcombine_f32(vdup_lane_f32(vget_low_f32(a.v), 1), vdup_lane_f32(vget_high_f32(a.v), 1));
+  // Multiply the real a with b
+  v1 = vmulq_f32(v1, b.v);
+  // Multiply the imag a with b
+  v2 = vmulq_f32(v2, b.v);
+  // Conjugate v2 
+  v2 = vreinterpretq_f32_u32(veorq_u32(vreinterpretq_u32_f32(v2), p4ui_CONJ_XOR()));
+  // Swap real/imag elements in v2.
+  v2 = vrev64q_f32(v2);
+  // Add and return the result
+  return Packet2cf(vaddq_f32(v1, v2));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pand   <Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{
+  return Packet2cf(vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(a.v),vreinterpretq_u32_f32(b.v))));
+}
+template<> EIGEN_STRONG_INLINE Packet2cf por    <Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{
+  return Packet2cf(vreinterpretq_f32_u32(vorrq_u32(vreinterpretq_u32_f32(a.v),vreinterpretq_u32_f32(b.v))));
+}
+template<> EIGEN_STRONG_INLINE Packet2cf pxor   <Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{
+  return Packet2cf(vreinterpretq_f32_u32(veorq_u32(vreinterpretq_u32_f32(a.v),vreinterpretq_u32_f32(b.v))));
+}
+template<> EIGEN_STRONG_INLINE Packet2cf pandnot<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{
+  return Packet2cf(vreinterpretq_f32_u32(vbicq_u32(vreinterpretq_u32_f32(a.v),vreinterpretq_u32_f32(b.v))));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pload<Packet2cf>(const std::complex<float>* from) { EIGEN_DEBUG_ALIGNED_LOAD return Packet2cf(pload<Packet4f>((const float*)from)); }
+template<> EIGEN_STRONG_INLINE Packet2cf ploadu<Packet2cf>(const std::complex<float>* from) { EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cf(ploadu<Packet4f>((const float*)from)); }
+
+template<> EIGEN_STRONG_INLINE Packet2cf ploaddup<Packet2cf>(const std::complex<float>* from) { return pset1<Packet2cf>(*from); }
+
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<float> >(std::complex<float> *   to, const Packet2cf& from) { EIGEN_DEBUG_ALIGNED_STORE pstore((float*)to, from.v); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<float> >(std::complex<float> *   to, const Packet2cf& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu((float*)to, from.v); }
+
+template<> EIGEN_DEVICE_FUNC inline Packet2cf pgather<std::complex<float>, Packet2cf>(const std::complex<float>* from, Index stride)
+{
+  Packet4f res = pset1<Packet4f>(0.f);
+  res = vsetq_lane_f32(std::real(from[0*stride]), res, 0);
+  res = vsetq_lane_f32(std::imag(from[0*stride]), res, 1);
+  res = vsetq_lane_f32(std::real(from[1*stride]), res, 2);
+  res = vsetq_lane_f32(std::imag(from[1*stride]), res, 3);
+  return Packet2cf(res);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<float>, Packet2cf>(std::complex<float>* to, const Packet2cf& from, Index stride)
+{
+  to[stride*0] = std::complex<float>(vgetq_lane_f32(from.v, 0), vgetq_lane_f32(from.v, 1));
+  to[stride*1] = std::complex<float>(vgetq_lane_f32(from.v, 2), vgetq_lane_f32(from.v, 3));
+}
+
+template<> EIGEN_STRONG_INLINE void prefetch<std::complex<float> >(const std::complex<float> *   addr) { EIGEN_ARM_PREFETCH((float *)addr); }
+
+template<> EIGEN_STRONG_INLINE std::complex<float>  pfirst<Packet2cf>(const Packet2cf& a)
+{
+  std::complex<float> EIGEN_ALIGN16 x[2];
+  vst1q_f32((float *)x, a.v);
+  return x[0];
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf preverse(const Packet2cf& a)
+{
+  float32x2_t a_lo, a_hi;
+  Packet4f a_r128;
+
+  a_lo = vget_low_f32(a.v);
+  a_hi = vget_high_f32(a.v);
+  a_r128 = vcombine_f32(a_hi, a_lo);
+
+  return Packet2cf(a_r128);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pcplxflip<Packet2cf>(const Packet2cf& a)
+{
+  return Packet2cf(vrev64q_f32(a.v));
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux<Packet2cf>(const Packet2cf& a)
+{
+  float32x2_t a1, a2;
+  std::complex<float> s;
+
+  a1 = vget_low_f32(a.v);
+  a2 = vget_high_f32(a.v);
+  a2 = vadd_f32(a1, a2);
+  vst1_f32((float *)&s, a2);
+
+  return s;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf preduxp<Packet2cf>(const Packet2cf* vecs)
+{
+  Packet4f sum1, sum2, sum;
+
+  // Add the first two 64-bit float32x2_t of vecs[0]
+  sum1 = vcombine_f32(vget_low_f32(vecs[0].v), vget_low_f32(vecs[1].v));
+  sum2 = vcombine_f32(vget_high_f32(vecs[0].v), vget_high_f32(vecs[1].v));
+  sum = vaddq_f32(sum1, sum2);
+
+  return Packet2cf(sum);
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet2cf>(const Packet2cf& a)
+{
+  float32x2_t a1, a2, v1, v2, prod;
+  std::complex<float> s;
+
+  a1 = vget_low_f32(a.v);
+  a2 = vget_high_f32(a.v);
+   // Get the real values of a | a1_re | a1_re | a2_re | a2_re |
+  v1 = vdup_lane_f32(a1, 0);
+  // Get the real values of a | a1_im | a1_im | a2_im | a2_im |
+  v2 = vdup_lane_f32(a1, 1);
+  // Multiply the real a with b
+  v1 = vmul_f32(v1, a2);
+  // Multiply the imag a with b
+  v2 = vmul_f32(v2, a2);
+  // Conjugate v2 
+  v2 = vreinterpret_f32_u32(veor_u32(vreinterpret_u32_f32(v2), p2ui_CONJ_XOR()));
+  // Swap real/imag elements in v2.
+  v2 = vrev64_f32(v2);
+  // Add v1, v2
+  prod = vadd_f32(v1, v2);
+
+  vst1_f32((float *)&s, prod);
+
+  return s;
+}
+
+template<int Offset>
+struct palign_impl<Offset,Packet2cf>
+{
+  EIGEN_STRONG_INLINE static void run(Packet2cf& first, const Packet2cf& second)
+  {
+    if (Offset==1)
+    {
+      first.v = vextq_f32(first.v, second.v, 2);
+    }
+  }
+};
+
+template<> struct conj_helper<Packet2cf, Packet2cf, false,true>
+{
+  EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf& y, const Packet2cf& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& b) const
+  {
+    return internal::pmul(a, pconj(b));
+  }
+};
+
+template<> struct conj_helper<Packet2cf, Packet2cf, true,false>
+{
+  EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf& y, const Packet2cf& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& b) const
+  {
+    return internal::pmul(pconj(a), b);
+  }
+};
+
+template<> struct conj_helper<Packet2cf, Packet2cf, true,true>
+{
+  EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf& y, const Packet2cf& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& b) const
+  {
+    return pconj(internal::pmul(a, b));
+  }
+};
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet2cf,Packet4f)
+
+template<> EIGEN_STRONG_INLINE Packet2cf pdiv<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{
+  // TODO optimize it for NEON
+  Packet2cf res = conj_helper<Packet2cf,Packet2cf,false,true>().pmul(a,b);
+  Packet4f s, rev_s;
+
+  // this computes the norm
+  s = vmulq_f32(b.v, b.v);
+  rev_s = vrev64q_f32(s);
+
+  return Packet2cf(pdiv(res.v, vaddq_f32(s,rev_s)));
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet2cf,2>& kernel) {
+  Packet4f tmp = vcombine_f32(vget_high_f32(kernel.packet[0].v), vget_high_f32(kernel.packet[1].v));
+  kernel.packet[0].v = vcombine_f32(vget_low_f32(kernel.packet[0].v), vget_low_f32(kernel.packet[1].v));
+  kernel.packet[1].v = tmp;
+}
+
+//---------- double ----------
+#if EIGEN_ARCH_ARM64 && !EIGEN_APPLE_DOUBLE_NEON_BUG
+
+// See bug 1325, clang fails to call vld1q_u64.
+#if EIGEN_COMP_CLANG
+  static uint64x2_t p2ul_CONJ_XOR = {0x0, 0x8000000000000000};
+#else
+  const uint64_t  p2ul_conj_XOR_DATA[] = { 0x0, 0x8000000000000000 };
+  static uint64x2_t p2ul_CONJ_XOR = vld1q_u64( p2ul_conj_XOR_DATA );
+#endif
+
+struct Packet1cd
+{
+  EIGEN_STRONG_INLINE Packet1cd() {}
+  EIGEN_STRONG_INLINE explicit Packet1cd(const Packet2d& a) : v(a) {}
+  Packet2d v;
+};
+
+template<> struct packet_traits<std::complex<double> >  : default_packet_traits
+{
+  typedef Packet1cd type;
+  typedef Packet1cd half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 0,
+    size = 1,
+    HasHalfPacket = 0,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasSetLinear = 0
+  };
+};
+
+template<> struct unpacket_traits<Packet1cd> { typedef std::complex<double> type; enum {size=1, alignment=Aligned16}; typedef Packet1cd half; };
+
+template<> EIGEN_STRONG_INLINE Packet1cd pload<Packet1cd>(const std::complex<double>* from) { EIGEN_DEBUG_ALIGNED_LOAD return Packet1cd(pload<Packet2d>((const double*)from)); }
+template<> EIGEN_STRONG_INLINE Packet1cd ploadu<Packet1cd>(const std::complex<double>* from) { EIGEN_DEBUG_UNALIGNED_LOAD return Packet1cd(ploadu<Packet2d>((const double*)from)); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd pset1<Packet1cd>(const std::complex<double>&  from)
+{ /* here we really have to use unaligned loads :( */ return ploadu<Packet1cd>(&from); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd padd<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(padd<Packet2d>(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd psub<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(psub<Packet2d>(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd pnegate(const Packet1cd& a) { return Packet1cd(pnegate<Packet2d>(a.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd pconj(const Packet1cd& a) { return Packet1cd(vreinterpretq_f64_u64(veorq_u64(vreinterpretq_u64_f64(a.v), p2ul_CONJ_XOR))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd pmul<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{
+  Packet2d v1, v2;
+
+  // Get the real values of a 
+  v1 = vdupq_lane_f64(vget_low_f64(a.v), 0);
+  // Get the imag values of a
+  v2 = vdupq_lane_f64(vget_high_f64(a.v), 0);
+  // Multiply the real a with b
+  v1 = vmulq_f64(v1, b.v);
+  // Multiply the imag a with b
+  v2 = vmulq_f64(v2, b.v);
+  // Conjugate v2 
+  v2 = vreinterpretq_f64_u64(veorq_u64(vreinterpretq_u64_f64(v2), p2ul_CONJ_XOR));
+  // Swap real/imag elements in v2.
+  v2 = preverse<Packet2d>(v2);
+  // Add and return the result
+  return Packet1cd(vaddq_f64(v1, v2));
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd pand   <Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{
+  return Packet1cd(vreinterpretq_f64_u64(vandq_u64(vreinterpretq_u64_f64(a.v),vreinterpretq_u64_f64(b.v))));
+}
+template<> EIGEN_STRONG_INLINE Packet1cd por    <Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{
+  return Packet1cd(vreinterpretq_f64_u64(vorrq_u64(vreinterpretq_u64_f64(a.v),vreinterpretq_u64_f64(b.v))));
+}
+template<> EIGEN_STRONG_INLINE Packet1cd pxor   <Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{
+  return Packet1cd(vreinterpretq_f64_u64(veorq_u64(vreinterpretq_u64_f64(a.v),vreinterpretq_u64_f64(b.v))));
+}
+template<> EIGEN_STRONG_INLINE Packet1cd pandnot<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{
+  return Packet1cd(vreinterpretq_f64_u64(vbicq_u64(vreinterpretq_u64_f64(a.v),vreinterpretq_u64_f64(b.v))));
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd ploaddup<Packet1cd>(const std::complex<double>* from) { return pset1<Packet1cd>(*from); }
+
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<double> >(std::complex<double> *   to, const Packet1cd& from) { EIGEN_DEBUG_ALIGNED_STORE pstore((double*)to, from.v); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<double> >(std::complex<double> *   to, const Packet1cd& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu((double*)to, from.v); }
+
+template<> EIGEN_STRONG_INLINE void prefetch<std::complex<double> >(const std::complex<double> *   addr) { EIGEN_ARM_PREFETCH((double *)addr); }
+
+template<> EIGEN_DEVICE_FUNC inline Packet1cd pgather<std::complex<double>, Packet1cd>(const std::complex<double>* from, Index stride)
+{
+  Packet2d res = pset1<Packet2d>(0.0);
+  res = vsetq_lane_f64(std::real(from[0*stride]), res, 0);
+  res = vsetq_lane_f64(std::imag(from[0*stride]), res, 1);
+  return Packet1cd(res);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<double>, Packet1cd>(std::complex<double>* to, const Packet1cd& from, Index stride)
+{
+  to[stride*0] = std::complex<double>(vgetq_lane_f64(from.v, 0), vgetq_lane_f64(from.v, 1));
+}
+
+
+template<> EIGEN_STRONG_INLINE std::complex<double>  pfirst<Packet1cd>(const Packet1cd& a)
+{
+  std::complex<double> EIGEN_ALIGN16 res;
+  pstore<std::complex<double> >(&res, a);
+
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd preverse(const Packet1cd& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE std::complex<double> predux<Packet1cd>(const Packet1cd& a) { return pfirst(a); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd preduxp<Packet1cd>(const Packet1cd* vecs) { return vecs[0]; }
+
+template<> EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet1cd>(const Packet1cd& a) { return pfirst(a); }
+
+template<int Offset>
+struct palign_impl<Offset,Packet1cd>
+{
+  static EIGEN_STRONG_INLINE void run(Packet1cd& /*first*/, const Packet1cd& /*second*/)
+  {
+    // FIXME is it sure we never have to align a Packet1cd?
+    // Even though a std::complex<double> has 16 bytes, it is not necessarily aligned on a 16 bytes boundary...
+  }
+};
+
+template<> struct conj_helper<Packet1cd, Packet1cd, false,true>
+{
+  EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd& y, const Packet1cd& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& b) const
+  {
+    return internal::pmul(a, pconj(b));
+  }
+};
+
+template<> struct conj_helper<Packet1cd, Packet1cd, true,false>
+{
+  EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd& y, const Packet1cd& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& b) const
+  {
+    return internal::pmul(pconj(a), b);
+  }
+};
+
+template<> struct conj_helper<Packet1cd, Packet1cd, true,true>
+{
+  EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd& y, const Packet1cd& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& b) const
+  {
+    return pconj(internal::pmul(a, b));
+  }
+};
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet1cd,Packet2d)
+
+template<> EIGEN_STRONG_INLINE Packet1cd pdiv<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{
+  // TODO optimize it for NEON
+  Packet1cd res = conj_helper<Packet1cd,Packet1cd,false,true>().pmul(a,b);
+  Packet2d s = pmul<Packet2d>(b.v, b.v);
+  Packet2d rev_s = preverse<Packet2d>(s);
+
+  return Packet1cd(pdiv(res.v, padd<Packet2d>(s,rev_s)));
+}
+
+EIGEN_STRONG_INLINE Packet1cd pcplxflip/*<Packet1cd>*/(const Packet1cd& x)
+{
+  return Packet1cd(preverse(Packet2d(x.v)));
+}
+
+EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet1cd,2>& kernel)
+{
+  Packet2d tmp = vcombine_f64(vget_high_f64(kernel.packet[0].v), vget_high_f64(kernel.packet[1].v));
+  kernel.packet[0].v = vcombine_f64(vget_low_f64(kernel.packet[0].v), vget_low_f64(kernel.packet[1].v));
+  kernel.packet[1].v = tmp;
+}
+#endif // EIGEN_ARCH_ARM64
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_COMPLEX_NEON_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/NEON/MathFunctions.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/NEON/MathFunctions.h
new file mode 100644
index 00000000..6bb05bb9
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/NEON/MathFunctions.h
@@ -0,0 +1,91 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* The sin, cos, exp, and log functions of this file come from
+ * Julien Pommier's sse math library: http://gruntthepeon.free.fr/ssemath/
+ */
+
+#ifndef EIGEN_MATH_FUNCTIONS_NEON_H
+#define EIGEN_MATH_FUNCTIONS_NEON_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f pexp<Packet4f>(const Packet4f& _x)
+{
+  Packet4f x = _x;
+  Packet4f tmp, fx;
+
+  _EIGEN_DECLARE_CONST_Packet4f(1 , 1.0f);
+  _EIGEN_DECLARE_CONST_Packet4f(half, 0.5f);
+  _EIGEN_DECLARE_CONST_Packet4i(0x7f, 0x7f);
+  _EIGEN_DECLARE_CONST_Packet4f(exp_hi,  88.3762626647950f);
+  _EIGEN_DECLARE_CONST_Packet4f(exp_lo, -88.3762626647949f);
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_LOG2EF, 1.44269504088896341f);
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_C1, 0.693359375f);
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_C2, -2.12194440e-4f);
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p0, 1.9875691500E-4f);
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p1, 1.3981999507E-3f);
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p2, 8.3334519073E-3f);
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p3, 4.1665795894E-2f);
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p4, 1.6666665459E-1f);
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p5, 5.0000001201E-1f);
+
+  x = vminq_f32(x, p4f_exp_hi);
+  x = vmaxq_f32(x, p4f_exp_lo);
+
+  /* express exp(x) as exp(g + n*log(2)) */
+  fx = vmlaq_f32(p4f_half, x, p4f_cephes_LOG2EF);
+
+  /* perform a floorf */
+  tmp = vcvtq_f32_s32(vcvtq_s32_f32(fx));
+
+  /* if greater, substract 1 */
+  Packet4ui mask = vcgtq_f32(tmp, fx);
+  mask = vandq_u32(mask, vreinterpretq_u32_f32(p4f_1));
+
+  fx = vsubq_f32(tmp, vreinterpretq_f32_u32(mask));
+
+  tmp = vmulq_f32(fx, p4f_cephes_exp_C1);
+  Packet4f z = vmulq_f32(fx, p4f_cephes_exp_C2);
+  x = vsubq_f32(x, tmp);
+  x = vsubq_f32(x, z);
+
+  Packet4f y = vmulq_f32(p4f_cephes_exp_p0, x);
+  z = vmulq_f32(x, x);
+  y = vaddq_f32(y, p4f_cephes_exp_p1);
+  y = vmulq_f32(y, x);
+  y = vaddq_f32(y, p4f_cephes_exp_p2);
+  y = vmulq_f32(y, x);
+  y = vaddq_f32(y, p4f_cephes_exp_p3);
+  y = vmulq_f32(y, x);
+  y = vaddq_f32(y, p4f_cephes_exp_p4);
+  y = vmulq_f32(y, x);
+  y = vaddq_f32(y, p4f_cephes_exp_p5);
+
+  y = vmulq_f32(y, z);
+  y = vaddq_f32(y, x);
+  y = vaddq_f32(y, p4f_1);
+
+  /* build 2^n */
+  int32x4_t mm;
+  mm = vcvtq_s32_f32(fx);
+  mm = vaddq_s32(mm, p4i_0x7f);
+  mm = vshlq_n_s32(mm, 23);
+  Packet4f pow2n = vreinterpretq_f32_s32(mm);
+
+  y = vmulq_f32(y, pow2n);
+  return y;
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_MATH_FUNCTIONS_NEON_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/NEON/PacketMath.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/NEON/PacketMath.h
new file mode 100644
index 00000000..836fbc0d
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/NEON/PacketMath.h
@@ -0,0 +1,729 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Konstantinos Margaritis <markos@freevec.org>
+// Heavily based on Gael's SSE version.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PACKET_MATH_NEON_H
+#define EIGEN_PACKET_MATH_NEON_H
+
+namespace Eigen {
+
+namespace internal {
+
+#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
+#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8
+#endif
+
+#ifndef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#define EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#endif
+
+#ifndef EIGEN_HAS_SINGLE_INSTRUCTION_CJMADD
+#define EIGEN_HAS_SINGLE_INSTRUCTION_CJMADD
+#endif
+
+#ifndef EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS
+#if EIGEN_ARCH_ARM64
+#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 32
+#else
+#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 16 
+#endif
+#endif
+
+typedef float32x2_t Packet2f;
+typedef float32x4_t Packet4f;
+typedef int32x4_t   Packet4i;
+typedef int32x2_t   Packet2i;
+typedef uint32x4_t  Packet4ui;
+
+#define _EIGEN_DECLARE_CONST_Packet4f(NAME,X) \
+  const Packet4f p4f_##NAME = pset1<Packet4f>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(NAME,X) \
+  const Packet4f p4f_##NAME = vreinterpretq_f32_u32(pset1<int32_t>(X))
+
+#define _EIGEN_DECLARE_CONST_Packet4i(NAME,X) \
+  const Packet4i p4i_##NAME = pset1<Packet4i>(X)
+
+#if EIGEN_ARCH_ARM64
+  // __builtin_prefetch tends to do nothing on ARM64 compilers because the
+  // prefetch instructions there are too detailed for __builtin_prefetch to map
+  // meaningfully to them.
+  #define EIGEN_ARM_PREFETCH(ADDR)  __asm__ __volatile__("prfm pldl1keep, [%[addr]]\n" ::[addr] "r"(ADDR) : );
+#elif EIGEN_HAS_BUILTIN(__builtin_prefetch) || EIGEN_COMP_GNUC
+  #define EIGEN_ARM_PREFETCH(ADDR) __builtin_prefetch(ADDR);
+#elif defined __pld
+  #define EIGEN_ARM_PREFETCH(ADDR) __pld(ADDR)
+#elif EIGEN_ARCH_ARM32
+  #define EIGEN_ARM_PREFETCH(ADDR) __asm__ __volatile__ ("pld [%[addr]]\n" :: [addr] "r" (ADDR) : );
+#else
+  // by default no explicit prefetching
+  #define EIGEN_ARM_PREFETCH(ADDR)
+#endif
+
+template<> struct packet_traits<float>  : default_packet_traits
+{
+  typedef Packet4f type;
+  typedef Packet4f half; // Packet2f intrinsics not implemented yet
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket=0, // Packet2f intrinsics not implemented yet
+   
+    HasDiv  = 1,
+    // FIXME check the Has*
+    HasSin  = 0,
+    HasCos  = 0,
+    HasLog  = 0,
+    HasExp  = 1,
+    HasSqrt = 0
+  };
+};
+template<> struct packet_traits<int32_t>    : default_packet_traits
+{
+  typedef Packet4i type;
+  typedef Packet4i half; // Packet2i intrinsics not implemented yet
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=4,
+    HasHalfPacket=0 // Packet2i intrinsics not implemented yet
+    // FIXME check the Has*
+  };
+};
+
+#if EIGEN_GNUC_AT_MOST(4,4) && !EIGEN_COMP_LLVM
+// workaround gcc 4.2, 4.3 and 4.4 compilatin issue
+EIGEN_STRONG_INLINE float32x4_t vld1q_f32(const float* x) { return ::vld1q_f32((const float32_t*)x); }
+EIGEN_STRONG_INLINE float32x2_t vld1_f32 (const float* x) { return ::vld1_f32 ((const float32_t*)x); }
+EIGEN_STRONG_INLINE float32x2_t vld1_dup_f32 (const float* x) { return ::vld1_dup_f32 ((const float32_t*)x); }
+EIGEN_STRONG_INLINE void        vst1q_f32(float* to, float32x4_t from) { ::vst1q_f32((float32_t*)to,from); }
+EIGEN_STRONG_INLINE void        vst1_f32 (float* to, float32x2_t from) { ::vst1_f32 ((float32_t*)to,from); }
+#endif
+
+template<> struct unpacket_traits<Packet4f> { typedef float   type; enum {size=4, alignment=Aligned16}; typedef Packet4f half; };
+template<> struct unpacket_traits<Packet4i> { typedef int32_t type; enum {size=4, alignment=Aligned16}; typedef Packet4i half; };
+
+template<> EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(const float&  from) { return vdupq_n_f32(from); }
+template<> EIGEN_STRONG_INLINE Packet4i pset1<Packet4i>(const int32_t&    from)   { return vdupq_n_s32(from); }
+
+template<> EIGEN_STRONG_INLINE Packet4f plset<Packet4f>(const float& a)
+{
+  const float f[] = {0, 1, 2, 3};
+  Packet4f countdown = vld1q_f32(f);
+  return vaddq_f32(pset1<Packet4f>(a), countdown);
+}
+template<> EIGEN_STRONG_INLINE Packet4i plset<Packet4i>(const int32_t& a)
+{
+  const int32_t i[] = {0, 1, 2, 3};
+  Packet4i countdown = vld1q_s32(i);
+  return vaddq_s32(pset1<Packet4i>(a), countdown);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f padd<Packet4f>(const Packet4f& a, const Packet4f& b) { return vaddq_f32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i padd<Packet4i>(const Packet4i& a, const Packet4i& b) { return vaddq_s32(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f psub<Packet4f>(const Packet4f& a, const Packet4f& b) { return vsubq_f32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i psub<Packet4i>(const Packet4i& a, const Packet4i& b) { return vsubq_s32(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pnegate(const Packet4f& a) { return vnegq_f32(a); }
+template<> EIGEN_STRONG_INLINE Packet4i pnegate(const Packet4i& a) { return vnegq_s32(a); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pconj(const Packet4f& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4i pconj(const Packet4i& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet4f pmul<Packet4f>(const Packet4f& a, const Packet4f& b) { return vmulq_f32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pmul<Packet4i>(const Packet4i& a, const Packet4i& b) { return vmulq_s32(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pdiv<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+#if EIGEN_ARCH_ARM64
+  return vdivq_f32(a,b);
+#else
+  Packet4f inv, restep, div;
+
+  // NEON does not offer a divide instruction, we have to do a reciprocal approximation
+  // However NEON in contrast to other SIMD engines (AltiVec/SSE), offers
+  // a reciprocal estimate AND a reciprocal step -which saves a few instructions
+  // vrecpeq_f32() returns an estimate to 1/b, which we will finetune with
+  // Newton-Raphson and vrecpsq_f32()
+  inv = vrecpeq_f32(b);
+
+  // This returns a differential, by which we will have to multiply inv to get a better
+  // approximation of 1/b.
+  restep = vrecpsq_f32(b, inv);
+  inv = vmulq_f32(restep, inv);
+
+  // Finally, multiply a by 1/b and get the wanted result of the division.
+  div = vmulq_f32(a, inv);
+
+  return div;
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pdiv<Packet4i>(const Packet4i& /*a*/, const Packet4i& /*b*/)
+{ eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet4i>(0);
+}
+
+// Clang/ARM wrongly advertises __ARM_FEATURE_FMA even when it's not available,
+// then implements a slow software scalar fallback calling fmaf()!
+// Filed LLVM bug:
+//     https://llvm.org/bugs/show_bug.cgi?id=27216
+#if (defined __ARM_FEATURE_FMA) && !(EIGEN_COMP_CLANG && EIGEN_ARCH_ARM)
+// See bug 936.
+// FMA is available on VFPv4 i.e. when compiling with -mfpu=neon-vfpv4.
+// FMA is a true fused multiply-add i.e. only 1 rounding at the end, no intermediate rounding.
+// MLA is not fused i.e. does 2 roundings.
+// In addition to giving better accuracy, FMA also gives better performance here on a Krait (Nexus 4):
+// MLA: 10 GFlop/s ; FMA: 12 GFlops/s.
+template<> EIGEN_STRONG_INLINE Packet4f pmadd(const Packet4f& a, const Packet4f& b, const Packet4f& c) { return vfmaq_f32(c,a,b); }
+#else
+template<> EIGEN_STRONG_INLINE Packet4f pmadd(const Packet4f& a, const Packet4f& b, const Packet4f& c) {
+#if EIGEN_COMP_CLANG && EIGEN_ARCH_ARM
+  // Clang/ARM will replace VMLA by VMUL+VADD at least for some values of -mcpu,
+  // at least -mcpu=cortex-a8 and -mcpu=cortex-a7. Since the former is the default on
+  // -march=armv7-a, that is a very common case.
+  // See e.g. this thread:
+  //     http://lists.llvm.org/pipermail/llvm-dev/2013-December/068806.html
+  // Filed LLVM bug:
+  //     https://llvm.org/bugs/show_bug.cgi?id=27219
+  Packet4f r = c;
+  asm volatile(
+    "vmla.f32 %q[r], %q[a], %q[b]"
+    : [r] "+w" (r)
+    : [a] "w" (a),
+      [b] "w" (b)
+    : );
+  return r;
+#else
+  return vmlaq_f32(c,a,b);
+#endif
+}
+#endif
+
+// No FMA instruction for int, so use MLA unconditionally.
+template<> EIGEN_STRONG_INLINE Packet4i pmadd(const Packet4i& a, const Packet4i& b, const Packet4i& c) { return vmlaq_s32(c,a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pmin<Packet4f>(const Packet4f& a, const Packet4f& b) { return vminq_f32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pmin<Packet4i>(const Packet4i& a, const Packet4i& b) { return vminq_s32(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pmax<Packet4f>(const Packet4f& a, const Packet4f& b) { return vmaxq_f32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pmax<Packet4i>(const Packet4i& a, const Packet4i& b) { return vmaxq_s32(a,b); }
+
+// Logical Operations are not supported for float, so we have to reinterpret casts using NEON intrinsics
+template<> EIGEN_STRONG_INLINE Packet4f pand<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  return vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b)));
+}
+template<> EIGEN_STRONG_INLINE Packet4i pand<Packet4i>(const Packet4i& a, const Packet4i& b) { return vandq_s32(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f por<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  return vreinterpretq_f32_u32(vorrq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b)));
+}
+template<> EIGEN_STRONG_INLINE Packet4i por<Packet4i>(const Packet4i& a, const Packet4i& b) { return vorrq_s32(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  return vreinterpretq_f32_u32(veorq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b)));
+}
+template<> EIGEN_STRONG_INLINE Packet4i pxor<Packet4i>(const Packet4i& a, const Packet4i& b) { return veorq_s32(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pandnot<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  return vreinterpretq_f32_u32(vbicq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b)));
+}
+template<> EIGEN_STRONG_INLINE Packet4i pandnot<Packet4i>(const Packet4i& a, const Packet4i& b) { return vbicq_s32(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pload<Packet4f>(const float*    from) { EIGEN_DEBUG_ALIGNED_LOAD return vld1q_f32(from); }
+template<> EIGEN_STRONG_INLINE Packet4i pload<Packet4i>(const int32_t*  from) { EIGEN_DEBUG_ALIGNED_LOAD return vld1q_s32(from); }
+
+template<> EIGEN_STRONG_INLINE Packet4f ploadu<Packet4f>(const float*   from) { EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_f32(from); }
+template<> EIGEN_STRONG_INLINE Packet4i ploadu<Packet4i>(const int32_t* from) { EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_s32(from); }
+
+template<> EIGEN_STRONG_INLINE Packet4f ploaddup<Packet4f>(const float* from)
+{
+  float32x2_t lo, hi;
+  lo = vld1_dup_f32(from);
+  hi = vld1_dup_f32(from+1);
+  return vcombine_f32(lo, hi);
+}
+template<> EIGEN_STRONG_INLINE Packet4i ploaddup<Packet4i>(const int32_t* from)
+{
+  int32x2_t lo, hi;
+  lo = vld1_dup_s32(from);
+  hi = vld1_dup_s32(from+1);
+  return vcombine_s32(lo, hi);
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<float>  (float*    to, const Packet4f& from) { EIGEN_DEBUG_ALIGNED_STORE vst1q_f32(to, from); }
+template<> EIGEN_STRONG_INLINE void pstore<int32_t>(int32_t*  to, const Packet4i& from) { EIGEN_DEBUG_ALIGNED_STORE vst1q_s32(to, from); }
+
+template<> EIGEN_STRONG_INLINE void pstoreu<float>  (float*   to, const Packet4f& from) { EIGEN_DEBUG_UNALIGNED_STORE vst1q_f32(to, from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<int32_t>(int32_t* to, const Packet4i& from) { EIGEN_DEBUG_UNALIGNED_STORE vst1q_s32(to, from); }
+
+template<> EIGEN_DEVICE_FUNC inline Packet4f pgather<float, Packet4f>(const float* from, Index stride)
+{
+  Packet4f res = pset1<Packet4f>(0.f);
+  res = vsetq_lane_f32(from[0*stride], res, 0);
+  res = vsetq_lane_f32(from[1*stride], res, 1);
+  res = vsetq_lane_f32(from[2*stride], res, 2);
+  res = vsetq_lane_f32(from[3*stride], res, 3);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC inline Packet4i pgather<int32_t, Packet4i>(const int32_t* from, Index stride)
+{
+  Packet4i res = pset1<Packet4i>(0);
+  res = vsetq_lane_s32(from[0*stride], res, 0);
+  res = vsetq_lane_s32(from[1*stride], res, 1);
+  res = vsetq_lane_s32(from[2*stride], res, 2);
+  res = vsetq_lane_s32(from[3*stride], res, 3);
+  return res;
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<float, Packet4f>(float* to, const Packet4f& from, Index stride)
+{
+  to[stride*0] = vgetq_lane_f32(from, 0);
+  to[stride*1] = vgetq_lane_f32(from, 1);
+  to[stride*2] = vgetq_lane_f32(from, 2);
+  to[stride*3] = vgetq_lane_f32(from, 3);
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<int32_t, Packet4i>(int32_t* to, const Packet4i& from, Index stride)
+{
+  to[stride*0] = vgetq_lane_s32(from, 0);
+  to[stride*1] = vgetq_lane_s32(from, 1);
+  to[stride*2] = vgetq_lane_s32(from, 2);
+  to[stride*3] = vgetq_lane_s32(from, 3);
+}
+
+template<> EIGEN_STRONG_INLINE void prefetch<float>  (const float*    addr) { EIGEN_ARM_PREFETCH(addr); }
+template<> EIGEN_STRONG_INLINE void prefetch<int32_t>(const int32_t*  addr) { EIGEN_ARM_PREFETCH(addr); }
+
+// FIXME only store the 2 first elements ?
+template<> EIGEN_STRONG_INLINE float   pfirst<Packet4f>(const Packet4f& a) { float   EIGEN_ALIGN16 x[4]; vst1q_f32(x, a); return x[0]; }
+template<> EIGEN_STRONG_INLINE int32_t pfirst<Packet4i>(const Packet4i& a) { int32_t EIGEN_ALIGN16 x[4]; vst1q_s32(x, a); return x[0]; }
+
+template<> EIGEN_STRONG_INLINE Packet4f preverse(const Packet4f& a) {
+  float32x2_t a_lo, a_hi;
+  Packet4f a_r64;
+
+  a_r64 = vrev64q_f32(a);
+  a_lo = vget_low_f32(a_r64);
+  a_hi = vget_high_f32(a_r64);
+  return vcombine_f32(a_hi, a_lo);
+}
+template<> EIGEN_STRONG_INLINE Packet4i preverse(const Packet4i& a) {
+  int32x2_t a_lo, a_hi;
+  Packet4i a_r64;
+
+  a_r64 = vrev64q_s32(a);
+  a_lo = vget_low_s32(a_r64);
+  a_hi = vget_high_s32(a_r64);
+  return vcombine_s32(a_hi, a_lo);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pabs(const Packet4f& a) { return vabsq_f32(a); }
+template<> EIGEN_STRONG_INLINE Packet4i pabs(const Packet4i& a) { return vabsq_s32(a); }
+
+template<> EIGEN_STRONG_INLINE float predux<Packet4f>(const Packet4f& a)
+{
+  float32x2_t a_lo, a_hi, sum;
+
+  a_lo = vget_low_f32(a);
+  a_hi = vget_high_f32(a);
+  sum = vpadd_f32(a_lo, a_hi);
+  sum = vpadd_f32(sum, sum);
+  return vget_lane_f32(sum, 0);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f preduxp<Packet4f>(const Packet4f* vecs)
+{
+  float32x4x2_t vtrn1, vtrn2, res1, res2;
+  Packet4f sum1, sum2, sum;
+
+  // NEON zip performs interleaving of the supplied vectors.
+  // We perform two interleaves in a row to acquire the transposed vector
+  vtrn1 = vzipq_f32(vecs[0], vecs[2]);
+  vtrn2 = vzipq_f32(vecs[1], vecs[3]);
+  res1 = vzipq_f32(vtrn1.val[0], vtrn2.val[0]);
+  res2 = vzipq_f32(vtrn1.val[1], vtrn2.val[1]);
+
+  // Do the addition of the resulting vectors
+  sum1 = vaddq_f32(res1.val[0], res1.val[1]);
+  sum2 = vaddq_f32(res2.val[0], res2.val[1]);
+  sum = vaddq_f32(sum1, sum2);
+
+  return sum;
+}
+
+template<> EIGEN_STRONG_INLINE int32_t predux<Packet4i>(const Packet4i& a)
+{
+  int32x2_t a_lo, a_hi, sum;
+
+  a_lo = vget_low_s32(a);
+  a_hi = vget_high_s32(a);
+  sum = vpadd_s32(a_lo, a_hi);
+  sum = vpadd_s32(sum, sum);
+  return vget_lane_s32(sum, 0);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i preduxp<Packet4i>(const Packet4i* vecs)
+{
+  int32x4x2_t vtrn1, vtrn2, res1, res2;
+  Packet4i sum1, sum2, sum;
+
+  // NEON zip performs interleaving of the supplied vectors.
+  // We perform two interleaves in a row to acquire the transposed vector
+  vtrn1 = vzipq_s32(vecs[0], vecs[2]);
+  vtrn2 = vzipq_s32(vecs[1], vecs[3]);
+  res1 = vzipq_s32(vtrn1.val[0], vtrn2.val[0]);
+  res2 = vzipq_s32(vtrn1.val[1], vtrn2.val[1]);
+
+  // Do the addition of the resulting vectors
+  sum1 = vaddq_s32(res1.val[0], res1.val[1]);
+  sum2 = vaddq_s32(res2.val[0], res2.val[1]);
+  sum = vaddq_s32(sum1, sum2);
+
+  return sum;
+}
+
+// Other reduction functions:
+// mul
+template<> EIGEN_STRONG_INLINE float predux_mul<Packet4f>(const Packet4f& a)
+{
+  float32x2_t a_lo, a_hi, prod;
+
+  // Get a_lo = |a1|a2| and a_hi = |a3|a4|
+  a_lo = vget_low_f32(a);
+  a_hi = vget_high_f32(a);
+  // Get the product of a_lo * a_hi -> |a1*a3|a2*a4|
+  prod = vmul_f32(a_lo, a_hi);
+  // Multiply prod with its swapped value |a2*a4|a1*a3|
+  prod = vmul_f32(prod, vrev64_f32(prod));
+
+  return vget_lane_f32(prod, 0);
+}
+template<> EIGEN_STRONG_INLINE int32_t predux_mul<Packet4i>(const Packet4i& a)
+{
+  int32x2_t a_lo, a_hi, prod;
+
+  // Get a_lo = |a1|a2| and a_hi = |a3|a4|
+  a_lo = vget_low_s32(a);
+  a_hi = vget_high_s32(a);
+  // Get the product of a_lo * a_hi -> |a1*a3|a2*a4|
+  prod = vmul_s32(a_lo, a_hi);
+  // Multiply prod with its swapped value |a2*a4|a1*a3|
+  prod = vmul_s32(prod, vrev64_s32(prod));
+
+  return vget_lane_s32(prod, 0);
+}
+
+// min
+template<> EIGEN_STRONG_INLINE float predux_min<Packet4f>(const Packet4f& a)
+{
+  float32x2_t a_lo, a_hi, min;
+
+  a_lo = vget_low_f32(a);
+  a_hi = vget_high_f32(a);
+  min = vpmin_f32(a_lo, a_hi);
+  min = vpmin_f32(min, min);
+
+  return vget_lane_f32(min, 0);
+}
+
+template<> EIGEN_STRONG_INLINE int32_t predux_min<Packet4i>(const Packet4i& a)
+{
+  int32x2_t a_lo, a_hi, min;
+
+  a_lo = vget_low_s32(a);
+  a_hi = vget_high_s32(a);
+  min = vpmin_s32(a_lo, a_hi);
+  min = vpmin_s32(min, min);
+  
+  return vget_lane_s32(min, 0);
+}
+
+// max
+template<> EIGEN_STRONG_INLINE float predux_max<Packet4f>(const Packet4f& a)
+{
+  float32x2_t a_lo, a_hi, max;
+
+  a_lo = vget_low_f32(a);
+  a_hi = vget_high_f32(a);
+  max = vpmax_f32(a_lo, a_hi);
+  max = vpmax_f32(max, max);
+
+  return vget_lane_f32(max, 0);
+}
+
+template<> EIGEN_STRONG_INLINE int32_t predux_max<Packet4i>(const Packet4i& a)
+{
+  int32x2_t a_lo, a_hi, max;
+
+  a_lo = vget_low_s32(a);
+  a_hi = vget_high_s32(a);
+  max = vpmax_s32(a_lo, a_hi);
+  max = vpmax_s32(max, max);
+
+  return vget_lane_s32(max, 0);
+}
+
+// this PALIGN_NEON business is to work around a bug in LLVM Clang 3.0 causing incorrect compilation errors,
+// see bug 347 and this LLVM bug: http://llvm.org/bugs/show_bug.cgi?id=11074
+#define PALIGN_NEON(Offset,Type,Command) \
+template<>\
+struct palign_impl<Offset,Type>\
+{\
+    EIGEN_STRONG_INLINE static void run(Type& first, const Type& second)\
+    {\
+        if (Offset!=0)\
+            first = Command(first, second, Offset);\
+    }\
+};\
+
+PALIGN_NEON(0,Packet4f,vextq_f32)
+PALIGN_NEON(1,Packet4f,vextq_f32)
+PALIGN_NEON(2,Packet4f,vextq_f32)
+PALIGN_NEON(3,Packet4f,vextq_f32)
+PALIGN_NEON(0,Packet4i,vextq_s32)
+PALIGN_NEON(1,Packet4i,vextq_s32)
+PALIGN_NEON(2,Packet4i,vextq_s32)
+PALIGN_NEON(3,Packet4i,vextq_s32)
+
+#undef PALIGN_NEON
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet4f,4>& kernel) {
+  float32x4x2_t tmp1 = vzipq_f32(kernel.packet[0], kernel.packet[1]);
+  float32x4x2_t tmp2 = vzipq_f32(kernel.packet[2], kernel.packet[3]);
+
+  kernel.packet[0] = vcombine_f32(vget_low_f32(tmp1.val[0]), vget_low_f32(tmp2.val[0]));
+  kernel.packet[1] = vcombine_f32(vget_high_f32(tmp1.val[0]), vget_high_f32(tmp2.val[0]));
+  kernel.packet[2] = vcombine_f32(vget_low_f32(tmp1.val[1]), vget_low_f32(tmp2.val[1]));
+  kernel.packet[3] = vcombine_f32(vget_high_f32(tmp1.val[1]), vget_high_f32(tmp2.val[1]));
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet4i,4>& kernel) {
+  int32x4x2_t tmp1 = vzipq_s32(kernel.packet[0], kernel.packet[1]);
+  int32x4x2_t tmp2 = vzipq_s32(kernel.packet[2], kernel.packet[3]);
+  kernel.packet[0] = vcombine_s32(vget_low_s32(tmp1.val[0]), vget_low_s32(tmp2.val[0]));
+  kernel.packet[1] = vcombine_s32(vget_high_s32(tmp1.val[0]), vget_high_s32(tmp2.val[0]));
+  kernel.packet[2] = vcombine_s32(vget_low_s32(tmp1.val[1]), vget_low_s32(tmp2.val[1]));
+  kernel.packet[3] = vcombine_s32(vget_high_s32(tmp1.val[1]), vget_high_s32(tmp2.val[1]));
+}
+
+//---------- double ----------
+
+// Clang 3.5 in the iOS toolchain has an ICE triggered by NEON intrisics for double.
+// Confirmed at least with __apple_build_version__ = 6000054.
+#ifdef __apple_build_version__
+// Let's hope that by the time __apple_build_version__ hits the 601* range, the bug will be fixed.
+// https://gist.github.com/yamaya/2924292 suggests that the 3 first digits are only updated with
+// major toolchain updates.
+#define EIGEN_APPLE_DOUBLE_NEON_BUG (__apple_build_version__ < 6010000)
+#else
+#define EIGEN_APPLE_DOUBLE_NEON_BUG 0
+#endif
+
+#if EIGEN_ARCH_ARM64 && !EIGEN_APPLE_DOUBLE_NEON_BUG
+
+// Bug 907: workaround missing declarations of the following two functions in the ADK
+// Defining these functions as templates ensures that if these intrinsics are
+// already defined in arm_neon.h, then our workaround doesn't cause a conflict
+// and has lower priority in overload resolution.
+template <typename T>
+uint64x2_t vreinterpretq_u64_f64(T a)
+{
+  return (uint64x2_t) a;
+}
+
+template <typename T>
+float64x2_t vreinterpretq_f64_u64(T a)
+{
+  return (float64x2_t) a;
+}
+
+typedef float64x2_t Packet2d;
+typedef float64x1_t Packet1d;
+
+template<> struct packet_traits<double>  : default_packet_traits
+{
+  typedef Packet2d type;
+  typedef Packet2d half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 2,
+    HasHalfPacket=0,
+   
+    HasDiv  = 1,
+    // FIXME check the Has*
+    HasSin  = 0,
+    HasCos  = 0,
+    HasLog  = 0,
+    HasExp  = 0,
+    HasSqrt = 0
+  };
+};
+
+template<> struct unpacket_traits<Packet2d> { typedef double  type; enum {size=2, alignment=Aligned16}; typedef Packet2d half; };
+
+template<> EIGEN_STRONG_INLINE Packet2d pset1<Packet2d>(const double&  from) { return vdupq_n_f64(from); }
+
+template<> EIGEN_STRONG_INLINE Packet2d plset<Packet2d>(const double& a)
+{
+  const double countdown_raw[] = {0.0,1.0};
+  const Packet2d countdown = vld1q_f64(countdown_raw);
+  return vaddq_f64(pset1<Packet2d>(a), countdown);
+}
+template<> EIGEN_STRONG_INLINE Packet2d padd<Packet2d>(const Packet2d& a, const Packet2d& b) { return vaddq_f64(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet2d psub<Packet2d>(const Packet2d& a, const Packet2d& b) { return vsubq_f64(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pnegate(const Packet2d& a) { return vnegq_f64(a); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pconj(const Packet2d& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet2d pmul<Packet2d>(const Packet2d& a, const Packet2d& b) { return vmulq_f64(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pdiv<Packet2d>(const Packet2d& a, const Packet2d& b) { return vdivq_f64(a,b); }
+
+#ifdef __ARM_FEATURE_FMA
+// See bug 936. See above comment about FMA for float.
+template<> EIGEN_STRONG_INLINE Packet2d pmadd(const Packet2d& a, const Packet2d& b, const Packet2d& c) { return vfmaq_f64(c,a,b); }
+#else
+template<> EIGEN_STRONG_INLINE Packet2d pmadd(const Packet2d& a, const Packet2d& b, const Packet2d& c) { return vmlaq_f64(c,a,b); }
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet2d pmin<Packet2d>(const Packet2d& a, const Packet2d& b) { return vminq_f64(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pmax<Packet2d>(const Packet2d& a, const Packet2d& b) { return vmaxq_f64(a,b); }
+
+// Logical Operations are not supported for float, so we have to reinterpret casts using NEON intrinsics
+template<> EIGEN_STRONG_INLINE Packet2d pand<Packet2d>(const Packet2d& a, const Packet2d& b)
+{
+  return vreinterpretq_f64_u64(vandq_u64(vreinterpretq_u64_f64(a),vreinterpretq_u64_f64(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d por<Packet2d>(const Packet2d& a, const Packet2d& b)
+{
+  return vreinterpretq_f64_u64(vorrq_u64(vreinterpretq_u64_f64(a),vreinterpretq_u64_f64(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pxor<Packet2d>(const Packet2d& a, const Packet2d& b)
+{
+  return vreinterpretq_f64_u64(veorq_u64(vreinterpretq_u64_f64(a),vreinterpretq_u64_f64(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pandnot<Packet2d>(const Packet2d& a, const Packet2d& b)
+{
+  return vreinterpretq_f64_u64(vbicq_u64(vreinterpretq_u64_f64(a),vreinterpretq_u64_f64(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pload<Packet2d>(const double* from) { EIGEN_DEBUG_ALIGNED_LOAD return vld1q_f64(from); }
+
+template<> EIGEN_STRONG_INLINE Packet2d ploadu<Packet2d>(const double* from) { EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_f64(from); }
+
+template<> EIGEN_STRONG_INLINE Packet2d ploaddup<Packet2d>(const double*   from)
+{
+  return vld1q_dup_f64(from);
+}
+template<> EIGEN_STRONG_INLINE void pstore<double>(double*   to, const Packet2d& from) { EIGEN_DEBUG_ALIGNED_STORE vst1q_f64(to, from); }
+
+template<> EIGEN_STRONG_INLINE void pstoreu<double>(double*  to, const Packet2d& from) { EIGEN_DEBUG_UNALIGNED_STORE vst1q_f64(to, from); }
+
+template<> EIGEN_DEVICE_FUNC inline Packet2d pgather<double, Packet2d>(const double* from, Index stride)
+{
+  Packet2d res = pset1<Packet2d>(0.0);
+  res = vsetq_lane_f64(from[0*stride], res, 0);
+  res = vsetq_lane_f64(from[1*stride], res, 1);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<double, Packet2d>(double* to, const Packet2d& from, Index stride)
+{
+  to[stride*0] = vgetq_lane_f64(from, 0);
+  to[stride*1] = vgetq_lane_f64(from, 1);
+}
+template<> EIGEN_STRONG_INLINE void prefetch<double>(const double* addr) { EIGEN_ARM_PREFETCH(addr); }
+
+// FIXME only store the 2 first elements ?
+template<> EIGEN_STRONG_INLINE double pfirst<Packet2d>(const Packet2d& a) { return vgetq_lane_f64(a, 0); }
+
+template<> EIGEN_STRONG_INLINE Packet2d preverse(const Packet2d& a) { return vcombine_f64(vget_high_f64(a), vget_low_f64(a)); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pabs(const Packet2d& a) { return vabsq_f64(a); }
+
+#if EIGEN_COMP_CLANG && defined(__apple_build_version__)
+// workaround ICE, see bug 907
+template<> EIGEN_STRONG_INLINE double predux<Packet2d>(const Packet2d& a) { return (vget_low_f64(a) + vget_high_f64(a))[0]; }
+#else
+template<> EIGEN_STRONG_INLINE double predux<Packet2d>(const Packet2d& a) { return vget_lane_f64(vget_low_f64(a) + vget_high_f64(a), 0); }
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet2d preduxp<Packet2d>(const Packet2d* vecs)
+{
+  float64x2_t trn1, trn2;
+
+  // NEON zip performs interleaving of the supplied vectors.
+  // We perform two interleaves in a row to acquire the transposed vector
+  trn1 = vzip1q_f64(vecs[0], vecs[1]);
+  trn2 = vzip2q_f64(vecs[0], vecs[1]);
+
+  // Do the addition of the resulting vectors
+  return vaddq_f64(trn1, trn2);
+}
+// Other reduction functions:
+// mul
+#if EIGEN_COMP_CLANG && defined(__apple_build_version__)
+template<> EIGEN_STRONG_INLINE double predux_mul<Packet2d>(const Packet2d& a) { return (vget_low_f64(a) * vget_high_f64(a))[0]; }
+#else
+template<> EIGEN_STRONG_INLINE double predux_mul<Packet2d>(const Packet2d& a) { return vget_lane_f64(vget_low_f64(a) * vget_high_f64(a), 0); }
+#endif
+
+// min
+template<> EIGEN_STRONG_INLINE double predux_min<Packet2d>(const Packet2d& a) { return vgetq_lane_f64(vpminq_f64(a, a), 0); }
+
+// max
+template<> EIGEN_STRONG_INLINE double predux_max<Packet2d>(const Packet2d& a) { return vgetq_lane_f64(vpmaxq_f64(a, a), 0); }
+
+// this PALIGN_NEON business is to work around a bug in LLVM Clang 3.0 causing incorrect compilation errors,
+// see bug 347 and this LLVM bug: http://llvm.org/bugs/show_bug.cgi?id=11074
+#define PALIGN_NEON(Offset,Type,Command) \
+template<>\
+struct palign_impl<Offset,Type>\
+{\
+    EIGEN_STRONG_INLINE static void run(Type& first, const Type& second)\
+    {\
+        if (Offset!=0)\
+            first = Command(first, second, Offset);\
+    }\
+};\
+
+PALIGN_NEON(0,Packet2d,vextq_f64)
+PALIGN_NEON(1,Packet2d,vextq_f64)
+#undef PALIGN_NEON
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet2d,2>& kernel) {
+  float64x2_t trn1 = vzip1q_f64(kernel.packet[0], kernel.packet[1]);
+  float64x2_t trn2 = vzip2q_f64(kernel.packet[0], kernel.packet[1]);
+
+  kernel.packet[0] = trn1;
+  kernel.packet[1] = trn2;
+}
+#endif // EIGEN_ARCH_ARM64 
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_PACKET_MATH_NEON_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/SSE/Complex.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/SSE/Complex.h
new file mode 100644
index 00000000..23e717f2
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/SSE/Complex.h
@@ -0,0 +1,471 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLEX_SSE_H
+#define EIGEN_COMPLEX_SSE_H
+
+namespace Eigen {
+
+namespace internal {
+
+//---------- float ----------
+struct Packet2cf
+{
+  EIGEN_STRONG_INLINE Packet2cf() {}
+  EIGEN_STRONG_INLINE explicit Packet2cf(const __m128& a) : v(a) {}
+  __m128  v;
+};
+
+// Use the packet_traits defined in AVX/PacketMath.h instead if we're going
+// to leverage AVX instructions.
+#ifndef EIGEN_VECTORIZE_AVX
+template<> struct packet_traits<std::complex<float> >  : default_packet_traits
+{
+  typedef Packet2cf type;
+  typedef Packet2cf half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 2,
+    HasHalfPacket = 0,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasSetLinear = 0,
+    HasBlend = 1
+  };
+};
+#endif
+
+template<> struct unpacket_traits<Packet2cf> { typedef std::complex<float> type; enum {size=2, alignment=Aligned16}; typedef Packet2cf half; };
+
+template<> EIGEN_STRONG_INLINE Packet2cf padd<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_add_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf psub<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_sub_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pnegate(const Packet2cf& a)
+{
+  const __m128 mask = _mm_castsi128_ps(_mm_setr_epi32(0x80000000,0x80000000,0x80000000,0x80000000));
+  return Packet2cf(_mm_xor_ps(a.v,mask));
+}
+template<> EIGEN_STRONG_INLINE Packet2cf pconj(const Packet2cf& a)
+{
+  const __m128 mask = _mm_castsi128_ps(_mm_setr_epi32(0x00000000,0x80000000,0x00000000,0x80000000));
+  return Packet2cf(_mm_xor_ps(a.v,mask));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pmul<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{
+  #ifdef EIGEN_VECTORIZE_SSE3
+  return Packet2cf(_mm_addsub_ps(_mm_mul_ps(_mm_moveldup_ps(a.v), b.v),
+                                 _mm_mul_ps(_mm_movehdup_ps(a.v),
+                                            vec4f_swizzle1(b.v, 1, 0, 3, 2))));
+//   return Packet2cf(_mm_addsub_ps(_mm_mul_ps(vec4f_swizzle1(a.v, 0, 0, 2, 2), b.v),
+//                                  _mm_mul_ps(vec4f_swizzle1(a.v, 1, 1, 3, 3),
+//                                             vec4f_swizzle1(b.v, 1, 0, 3, 2))));
+  #else
+  const __m128 mask = _mm_castsi128_ps(_mm_setr_epi32(0x80000000,0x00000000,0x80000000,0x00000000));
+  return Packet2cf(_mm_add_ps(_mm_mul_ps(vec4f_swizzle1(a.v, 0, 0, 2, 2), b.v),
+                              _mm_xor_ps(_mm_mul_ps(vec4f_swizzle1(a.v, 1, 1, 3, 3),
+                                                    vec4f_swizzle1(b.v, 1, 0, 3, 2)), mask)));
+  #endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pand   <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_and_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf por    <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_or_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pxor   <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_xor_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pandnot<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_andnot_ps(a.v,b.v)); }
+
+template<> EIGEN_STRONG_INLINE Packet2cf pload <Packet2cf>(const std::complex<float>* from) { EIGEN_DEBUG_ALIGNED_LOAD return Packet2cf(pload<Packet4f>(&numext::real_ref(*from))); }
+template<> EIGEN_STRONG_INLINE Packet2cf ploadu<Packet2cf>(const std::complex<float>* from) { EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cf(ploadu<Packet4f>(&numext::real_ref(*from))); }
+
+template<> EIGEN_STRONG_INLINE Packet2cf pset1<Packet2cf>(const std::complex<float>&  from)
+{
+  Packet2cf res;
+#if EIGEN_GNUC_AT_MOST(4,2)
+  // Workaround annoying "may be used uninitialized in this function" warning with gcc 4.2
+  res.v = _mm_loadl_pi(_mm_set1_ps(0.0f), reinterpret_cast<const __m64*>(&from));
+#elif EIGEN_GNUC_AT_LEAST(4,6)
+  // Suppress annoying "may be used uninitialized in this function" warning with gcc >= 4.6
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wuninitialized"
+  res.v = _mm_loadl_pi(res.v, (const __m64*)&from);
+  #pragma GCC diagnostic pop
+#else
+  res.v = _mm_loadl_pi(res.v, (const __m64*)&from);
+#endif
+  return Packet2cf(_mm_movelh_ps(res.v,res.v));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf ploaddup<Packet2cf>(const std::complex<float>* from) { return pset1<Packet2cf>(*from); }
+
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<float> >(std::complex<float> *   to, const Packet2cf& from) { EIGEN_DEBUG_ALIGNED_STORE pstore(&numext::real_ref(*to), Packet4f(from.v)); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<float> >(std::complex<float> *   to, const Packet2cf& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu(&numext::real_ref(*to), Packet4f(from.v)); }
+
+
+template<> EIGEN_DEVICE_FUNC inline Packet2cf pgather<std::complex<float>, Packet2cf>(const std::complex<float>* from, Index stride)
+{
+  return Packet2cf(_mm_set_ps(std::imag(from[1*stride]), std::real(from[1*stride]),
+                              std::imag(from[0*stride]), std::real(from[0*stride])));
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<float>, Packet2cf>(std::complex<float>* to, const Packet2cf& from, Index stride)
+{
+  to[stride*0] = std::complex<float>(_mm_cvtss_f32(_mm_shuffle_ps(from.v, from.v, 0)),
+                                     _mm_cvtss_f32(_mm_shuffle_ps(from.v, from.v, 1)));
+  to[stride*1] = std::complex<float>(_mm_cvtss_f32(_mm_shuffle_ps(from.v, from.v, 2)),
+                                     _mm_cvtss_f32(_mm_shuffle_ps(from.v, from.v, 3)));
+}
+
+template<> EIGEN_STRONG_INLINE void prefetch<std::complex<float> >(const std::complex<float> *   addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); }
+
+template<> EIGEN_STRONG_INLINE std::complex<float>  pfirst<Packet2cf>(const Packet2cf& a)
+{
+  #if EIGEN_GNUC_AT_MOST(4,3)
+  // Workaround gcc 4.2 ICE - this is not performance wise ideal, but who cares...
+  // This workaround also fix invalid code generation with gcc 4.3
+  EIGEN_ALIGN16 std::complex<float> res[2];
+  _mm_store_ps((float*)res, a.v);
+  return res[0];
+  #else
+  std::complex<float> res;
+  _mm_storel_pi((__m64*)&res, a.v);
+  return res;
+  #endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf preverse(const Packet2cf& a) { return Packet2cf(_mm_castpd_ps(preverse(Packet2d(_mm_castps_pd(a.v))))); }
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux<Packet2cf>(const Packet2cf& a)
+{
+  return pfirst(Packet2cf(_mm_add_ps(a.v, _mm_movehl_ps(a.v,a.v))));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf preduxp<Packet2cf>(const Packet2cf* vecs)
+{
+  return Packet2cf(_mm_add_ps(_mm_movelh_ps(vecs[0].v,vecs[1].v), _mm_movehl_ps(vecs[1].v,vecs[0].v)));
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet2cf>(const Packet2cf& a)
+{
+  return pfirst(pmul(a, Packet2cf(_mm_movehl_ps(a.v,a.v))));
+}
+
+template<int Offset>
+struct palign_impl<Offset,Packet2cf>
+{
+  static EIGEN_STRONG_INLINE void run(Packet2cf& first, const Packet2cf& second)
+  {
+    if (Offset==1)
+    {
+      first.v = _mm_movehl_ps(first.v, first.v);
+      first.v = _mm_movelh_ps(first.v, second.v);
+    }
+  }
+};
+
+template<> struct conj_helper<Packet2cf, Packet2cf, false,true>
+{
+  EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf& y, const Packet2cf& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& b) const
+  {
+    #ifdef EIGEN_VECTORIZE_SSE3
+    return internal::pmul(a, pconj(b));
+    #else
+    const __m128 mask = _mm_castsi128_ps(_mm_setr_epi32(0x00000000,0x80000000,0x00000000,0x80000000));
+    return Packet2cf(_mm_add_ps(_mm_xor_ps(_mm_mul_ps(vec4f_swizzle1(a.v, 0, 0, 2, 2), b.v), mask),
+                                _mm_mul_ps(vec4f_swizzle1(a.v, 1, 1, 3, 3),
+                                           vec4f_swizzle1(b.v, 1, 0, 3, 2))));
+    #endif
+  }
+};
+
+template<> struct conj_helper<Packet2cf, Packet2cf, true,false>
+{
+  EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf& y, const Packet2cf& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& b) const
+  {
+    #ifdef EIGEN_VECTORIZE_SSE3
+    return internal::pmul(pconj(a), b);
+    #else
+    const __m128 mask = _mm_castsi128_ps(_mm_setr_epi32(0x00000000,0x80000000,0x00000000,0x80000000));
+    return Packet2cf(_mm_add_ps(_mm_mul_ps(vec4f_swizzle1(a.v, 0, 0, 2, 2), b.v),
+                                _mm_xor_ps(_mm_mul_ps(vec4f_swizzle1(a.v, 1, 1, 3, 3),
+                                                      vec4f_swizzle1(b.v, 1, 0, 3, 2)), mask)));
+    #endif
+  }
+};
+
+template<> struct conj_helper<Packet2cf, Packet2cf, true,true>
+{
+  EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf& y, const Packet2cf& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& b) const
+  {
+    #ifdef EIGEN_VECTORIZE_SSE3
+    return pconj(internal::pmul(a, b));
+    #else
+    const __m128 mask = _mm_castsi128_ps(_mm_setr_epi32(0x00000000,0x80000000,0x00000000,0x80000000));
+    return Packet2cf(_mm_sub_ps(_mm_xor_ps(_mm_mul_ps(vec4f_swizzle1(a.v, 0, 0, 2, 2), b.v), mask),
+                                _mm_mul_ps(vec4f_swizzle1(a.v, 1, 1, 3, 3),
+                                           vec4f_swizzle1(b.v, 1, 0, 3, 2))));
+    #endif
+  }
+};
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet2cf,Packet4f)
+
+template<> EIGEN_STRONG_INLINE Packet2cf pdiv<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{
+  // TODO optimize it for SSE3 and 4
+  Packet2cf res = conj_helper<Packet2cf,Packet2cf,false,true>().pmul(a,b);
+  __m128 s = _mm_mul_ps(b.v,b.v);
+  return Packet2cf(_mm_div_ps(res.v,_mm_add_ps(s,_mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(s), 0xb1)))));
+}
+
+EIGEN_STRONG_INLINE Packet2cf pcplxflip/* <Packet2cf> */(const Packet2cf& x)
+{
+  return Packet2cf(vec4f_swizzle1(x.v, 1, 0, 3, 2));
+}
+
+
+//---------- double ----------
+struct Packet1cd
+{
+  EIGEN_STRONG_INLINE Packet1cd() {}
+  EIGEN_STRONG_INLINE explicit Packet1cd(const __m128d& a) : v(a) {}
+  __m128d  v;
+};
+
+// Use the packet_traits defined in AVX/PacketMath.h instead if we're going
+// to leverage AVX instructions.
+#ifndef EIGEN_VECTORIZE_AVX
+template<> struct packet_traits<std::complex<double> >  : default_packet_traits
+{
+  typedef Packet1cd type;
+  typedef Packet1cd half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 0,
+    size = 1,
+    HasHalfPacket = 0,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasSetLinear = 0
+  };
+};
+#endif
+
+template<> struct unpacket_traits<Packet1cd> { typedef std::complex<double> type; enum {size=1, alignment=Aligned16}; typedef Packet1cd half; };
+
+template<> EIGEN_STRONG_INLINE Packet1cd padd<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_add_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd psub<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_sub_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd pnegate(const Packet1cd& a) { return Packet1cd(pnegate(Packet2d(a.v))); }
+template<> EIGEN_STRONG_INLINE Packet1cd pconj(const Packet1cd& a)
+{
+  const __m128d mask = _mm_castsi128_pd(_mm_set_epi32(0x80000000,0x0,0x0,0x0));
+  return Packet1cd(_mm_xor_pd(a.v,mask));
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd pmul<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{
+  #ifdef EIGEN_VECTORIZE_SSE3
+  return Packet1cd(_mm_addsub_pd(_mm_mul_pd(_mm_movedup_pd(a.v), b.v),
+                                 _mm_mul_pd(vec2d_swizzle1(a.v, 1, 1),
+                                            vec2d_swizzle1(b.v, 1, 0))));
+  #else
+  const __m128d mask = _mm_castsi128_pd(_mm_set_epi32(0x0,0x0,0x80000000,0x0));
+  return Packet1cd(_mm_add_pd(_mm_mul_pd(vec2d_swizzle1(a.v, 0, 0), b.v),
+                              _mm_xor_pd(_mm_mul_pd(vec2d_swizzle1(a.v, 1, 1),
+                                                    vec2d_swizzle1(b.v, 1, 0)), mask)));
+  #endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd pand   <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_and_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd por    <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_or_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd pxor   <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_xor_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd pandnot<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_andnot_pd(a.v,b.v)); }
+
+// FIXME force unaligned load, this is a temporary fix
+template<> EIGEN_STRONG_INLINE Packet1cd pload <Packet1cd>(const std::complex<double>* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return Packet1cd(pload<Packet2d>((const double*)from)); }
+template<> EIGEN_STRONG_INLINE Packet1cd ploadu<Packet1cd>(const std::complex<double>* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return Packet1cd(ploadu<Packet2d>((const double*)from)); }
+template<> EIGEN_STRONG_INLINE Packet1cd pset1<Packet1cd>(const std::complex<double>&  from)
+{ /* here we really have to use unaligned loads :( */ return ploadu<Packet1cd>(&from); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd ploaddup<Packet1cd>(const std::complex<double>* from) { return pset1<Packet1cd>(*from); }
+
+// FIXME force unaligned store, this is a temporary fix
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<double> >(std::complex<double> *   to, const Packet1cd& from) { EIGEN_DEBUG_ALIGNED_STORE pstore((double*)to, Packet2d(from.v)); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<double> >(std::complex<double> *   to, const Packet1cd& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu((double*)to, Packet2d(from.v)); }
+
+template<> EIGEN_STRONG_INLINE void prefetch<std::complex<double> >(const std::complex<double> *   addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); }
+
+template<> EIGEN_STRONG_INLINE std::complex<double>  pfirst<Packet1cd>(const Packet1cd& a)
+{
+  EIGEN_ALIGN16 double res[2];
+  _mm_store_pd(res, a.v);
+  return std::complex<double>(res[0],res[1]);
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd preverse(const Packet1cd& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE std::complex<double> predux<Packet1cd>(const Packet1cd& a)
+{
+  return pfirst(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd preduxp<Packet1cd>(const Packet1cd* vecs)
+{
+  return vecs[0];
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet1cd>(const Packet1cd& a)
+{
+  return pfirst(a);
+}
+
+template<int Offset>
+struct palign_impl<Offset,Packet1cd>
+{
+  static EIGEN_STRONG_INLINE void run(Packet1cd& /*first*/, const Packet1cd& /*second*/)
+  {
+    // FIXME is it sure we never have to align a Packet1cd?
+    // Even though a std::complex<double> has 16 bytes, it is not necessarily aligned on a 16 bytes boundary...
+  }
+};
+
+template<> struct conj_helper<Packet1cd, Packet1cd, false,true>
+{
+  EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd& y, const Packet1cd& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& b) const
+  {
+    #ifdef EIGEN_VECTORIZE_SSE3
+    return internal::pmul(a, pconj(b));
+    #else
+    const __m128d mask = _mm_castsi128_pd(_mm_set_epi32(0x80000000,0x0,0x0,0x0));
+    return Packet1cd(_mm_add_pd(_mm_xor_pd(_mm_mul_pd(vec2d_swizzle1(a.v, 0, 0), b.v), mask),
+                                _mm_mul_pd(vec2d_swizzle1(a.v, 1, 1),
+                                           vec2d_swizzle1(b.v, 1, 0))));
+    #endif
+  }
+};
+
+template<> struct conj_helper<Packet1cd, Packet1cd, true,false>
+{
+  EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd& y, const Packet1cd& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& b) const
+  {
+    #ifdef EIGEN_VECTORIZE_SSE3
+    return internal::pmul(pconj(a), b);
+    #else
+    const __m128d mask = _mm_castsi128_pd(_mm_set_epi32(0x80000000,0x0,0x0,0x0));
+    return Packet1cd(_mm_add_pd(_mm_mul_pd(vec2d_swizzle1(a.v, 0, 0), b.v),
+                                _mm_xor_pd(_mm_mul_pd(vec2d_swizzle1(a.v, 1, 1),
+                                                      vec2d_swizzle1(b.v, 1, 0)), mask)));
+    #endif
+  }
+};
+
+template<> struct conj_helper<Packet1cd, Packet1cd, true,true>
+{
+  EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd& y, const Packet1cd& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& b) const
+  {
+    #ifdef EIGEN_VECTORIZE_SSE3
+    return pconj(internal::pmul(a, b));
+    #else
+    const __m128d mask = _mm_castsi128_pd(_mm_set_epi32(0x80000000,0x0,0x0,0x0));
+    return Packet1cd(_mm_sub_pd(_mm_xor_pd(_mm_mul_pd(vec2d_swizzle1(a.v, 0, 0), b.v), mask),
+                                _mm_mul_pd(vec2d_swizzle1(a.v, 1, 1),
+                                           vec2d_swizzle1(b.v, 1, 0))));
+    #endif
+  }
+};
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet1cd,Packet2d)
+
+template<> EIGEN_STRONG_INLINE Packet1cd pdiv<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{
+  // TODO optimize it for SSE3 and 4
+  Packet1cd res = conj_helper<Packet1cd,Packet1cd,false,true>().pmul(a,b);
+  __m128d s = _mm_mul_pd(b.v,b.v);
+  return Packet1cd(_mm_div_pd(res.v, _mm_add_pd(s,_mm_shuffle_pd(s, s, 0x1))));
+}
+
+EIGEN_STRONG_INLINE Packet1cd pcplxflip/* <Packet1cd> */(const Packet1cd& x)
+{
+  return Packet1cd(preverse(Packet2d(x.v)));
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet2cf,2>& kernel) {
+  __m128d w1 = _mm_castps_pd(kernel.packet[0].v);
+  __m128d w2 = _mm_castps_pd(kernel.packet[1].v);
+
+  __m128 tmp = _mm_castpd_ps(_mm_unpackhi_pd(w1, w2));
+  kernel.packet[0].v = _mm_castpd_ps(_mm_unpacklo_pd(w1, w2));
+  kernel.packet[1].v = tmp;
+}
+
+template<>  EIGEN_STRONG_INLINE Packet2cf pblend(const Selector<2>& ifPacket, const Packet2cf& thenPacket, const Packet2cf& elsePacket) {
+  __m128d result = pblend<Packet2d>(ifPacket, _mm_castps_pd(thenPacket.v), _mm_castps_pd(elsePacket.v));
+  return Packet2cf(_mm_castpd_ps(result));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pinsertfirst(const Packet2cf& a, std::complex<float> b)
+{
+  return Packet2cf(_mm_loadl_pi(a.v, reinterpret_cast<const __m64*>(&b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd pinsertfirst(const Packet1cd&, std::complex<double> b)
+{
+  return pset1<Packet1cd>(b);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pinsertlast(const Packet2cf& a, std::complex<float> b)
+{
+  return Packet2cf(_mm_loadh_pi(a.v, reinterpret_cast<const __m64*>(&b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd pinsertlast(const Packet1cd&, std::complex<double> b)
+{
+  return pset1<Packet1cd>(b);
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_COMPLEX_SSE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/SSE/MathFunctions.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/SSE/MathFunctions.h
new file mode 100644
index 00000000..7b5f948e
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/SSE/MathFunctions.h
@@ -0,0 +1,562 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007 Julien Pommier
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* The sin, cos, exp, and log functions of this file come from
+ * Julien Pommier's sse math library: http://gruntthepeon.free.fr/ssemath/
+ */
+
+#ifndef EIGEN_MATH_FUNCTIONS_SSE_H
+#define EIGEN_MATH_FUNCTIONS_SSE_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f plog<Packet4f>(const Packet4f& _x)
+{
+  Packet4f x = _x;
+  _EIGEN_DECLARE_CONST_Packet4f(1 , 1.0f);
+  _EIGEN_DECLARE_CONST_Packet4f(half, 0.5f);
+  _EIGEN_DECLARE_CONST_Packet4i(0x7f, 0x7f);
+
+  _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(inv_mant_mask, ~0x7f800000);
+
+  /* the smallest non denormalized float number */
+  _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(min_norm_pos,  0x00800000);
+  _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(minus_inf,     0xff800000);//-1.f/0.f);
+
+  /* natural logarithm computed for 4 simultaneous float
+    return NaN for x <= 0
+  */
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_SQRTHF, 0.707106781186547524f);
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p0, 7.0376836292E-2f);
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p1, - 1.1514610310E-1f);
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p2, 1.1676998740E-1f);
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p3, - 1.2420140846E-1f);
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p4, + 1.4249322787E-1f);
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p5, - 1.6668057665E-1f);
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p6, + 2.0000714765E-1f);
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p7, - 2.4999993993E-1f);
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p8, + 3.3333331174E-1f);
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_q1, -2.12194440e-4f);
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_q2, 0.693359375f);
+
+
+  Packet4i emm0;
+
+  Packet4f invalid_mask = _mm_cmpnge_ps(x, _mm_setzero_ps()); // not greater equal is true if x is NaN
+  Packet4f iszero_mask = _mm_cmpeq_ps(x, _mm_setzero_ps());
+
+  x = pmax(x, p4f_min_norm_pos);  /* cut off denormalized stuff */
+  emm0 = _mm_srli_epi32(_mm_castps_si128(x), 23);
+
+  /* keep only the fractional part */
+  x = _mm_and_ps(x, p4f_inv_mant_mask);
+  x = _mm_or_ps(x, p4f_half);
+
+  emm0 = _mm_sub_epi32(emm0, p4i_0x7f);
+  Packet4f e = padd(Packet4f(_mm_cvtepi32_ps(emm0)), p4f_1);
+
+  /* part2:
+     if( x < SQRTHF ) {
+       e -= 1;
+       x = x + x - 1.0;
+     } else { x = x - 1.0; }
+  */
+  Packet4f mask = _mm_cmplt_ps(x, p4f_cephes_SQRTHF);
+  Packet4f tmp = pand(x, mask);
+  x = psub(x, p4f_1);
+  e = psub(e, pand(p4f_1, mask));
+  x = padd(x, tmp);
+
+  Packet4f x2 = pmul(x,x);
+  Packet4f x3 = pmul(x2,x);
+
+  Packet4f y, y1, y2;
+  y  = pmadd(p4f_cephes_log_p0, x, p4f_cephes_log_p1);
+  y1 = pmadd(p4f_cephes_log_p3, x, p4f_cephes_log_p4);
+  y2 = pmadd(p4f_cephes_log_p6, x, p4f_cephes_log_p7);
+  y  = pmadd(y , x, p4f_cephes_log_p2);
+  y1 = pmadd(y1, x, p4f_cephes_log_p5);
+  y2 = pmadd(y2, x, p4f_cephes_log_p8);
+  y = pmadd(y, x3, y1);
+  y = pmadd(y, x3, y2);
+  y = pmul(y, x3);
+
+  y1 = pmul(e, p4f_cephes_log_q1);
+  tmp = pmul(x2, p4f_half);
+  y = padd(y, y1);
+  x = psub(x, tmp);
+  y2 = pmul(e, p4f_cephes_log_q2);
+  x = padd(x, y);
+  x = padd(x, y2);
+  // negative arg will be NAN, 0 will be -INF
+  return _mm_or_ps(_mm_andnot_ps(iszero_mask, _mm_or_ps(x, invalid_mask)),
+                   _mm_and_ps(iszero_mask, p4f_minus_inf));
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f pexp<Packet4f>(const Packet4f& _x)
+{
+  Packet4f x = _x;
+  _EIGEN_DECLARE_CONST_Packet4f(1 , 1.0f);
+  _EIGEN_DECLARE_CONST_Packet4f(half, 0.5f);
+  _EIGEN_DECLARE_CONST_Packet4i(0x7f, 0x7f);
+
+
+  _EIGEN_DECLARE_CONST_Packet4f(exp_hi,  88.3762626647950f);
+  _EIGEN_DECLARE_CONST_Packet4f(exp_lo, -88.3762626647949f);
+
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_LOG2EF, 1.44269504088896341f);
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_C1, 0.693359375f);
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_C2, -2.12194440e-4f);
+
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p0, 1.9875691500E-4f);
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p1, 1.3981999507E-3f);
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p2, 8.3334519073E-3f);
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p3, 4.1665795894E-2f);
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p4, 1.6666665459E-1f);
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p5, 5.0000001201E-1f);
+
+  Packet4f tmp, fx;
+  Packet4i emm0;
+
+  // clamp x
+  x = pmax(pmin(x, p4f_exp_hi), p4f_exp_lo);
+
+  /* express exp(x) as exp(g + n*log(2)) */
+  fx = pmadd(x, p4f_cephes_LOG2EF, p4f_half);
+
+#ifdef EIGEN_VECTORIZE_SSE4_1
+  fx = _mm_floor_ps(fx);
+#else
+  emm0 = _mm_cvttps_epi32(fx);
+  tmp  = _mm_cvtepi32_ps(emm0);
+  /* if greater, substract 1 */
+  Packet4f mask = _mm_cmpgt_ps(tmp, fx);
+  mask = _mm_and_ps(mask, p4f_1);
+  fx = psub(tmp, mask);
+#endif
+
+  tmp = pmul(fx, p4f_cephes_exp_C1);
+  Packet4f z = pmul(fx, p4f_cephes_exp_C2);
+  x = psub(x, tmp);
+  x = psub(x, z);
+
+  z = pmul(x,x);
+
+  Packet4f y = p4f_cephes_exp_p0;
+  y = pmadd(y, x, p4f_cephes_exp_p1);
+  y = pmadd(y, x, p4f_cephes_exp_p2);
+  y = pmadd(y, x, p4f_cephes_exp_p3);
+  y = pmadd(y, x, p4f_cephes_exp_p4);
+  y = pmadd(y, x, p4f_cephes_exp_p5);
+  y = pmadd(y, z, x);
+  y = padd(y, p4f_1);
+
+  // build 2^n
+  emm0 = _mm_cvttps_epi32(fx);
+  emm0 = _mm_add_epi32(emm0, p4i_0x7f);
+  emm0 = _mm_slli_epi32(emm0, 23);
+  return pmax(pmul(y, Packet4f(_mm_castsi128_ps(emm0))), _x);
+}
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d pexp<Packet2d>(const Packet2d& _x)
+{
+  Packet2d x = _x;
+
+  _EIGEN_DECLARE_CONST_Packet2d(1 , 1.0);
+  _EIGEN_DECLARE_CONST_Packet2d(2 , 2.0);
+  _EIGEN_DECLARE_CONST_Packet2d(half, 0.5);
+
+  _EIGEN_DECLARE_CONST_Packet2d(exp_hi,  709.437);
+  _EIGEN_DECLARE_CONST_Packet2d(exp_lo, -709.436139303);
+
+  _EIGEN_DECLARE_CONST_Packet2d(cephes_LOG2EF, 1.4426950408889634073599);
+
+  _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_p0, 1.26177193074810590878e-4);
+  _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_p1, 3.02994407707441961300e-2);
+  _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_p2, 9.99999999999999999910e-1);
+
+  _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q0, 3.00198505138664455042e-6);
+  _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q1, 2.52448340349684104192e-3);
+  _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q2, 2.27265548208155028766e-1);
+  _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q3, 2.00000000000000000009e0);
+
+  _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_C1, 0.693145751953125);
+  _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_C2, 1.42860682030941723212e-6);
+  static const __m128i p4i_1023_0 = _mm_setr_epi32(1023, 1023, 0, 0);
+
+  Packet2d tmp, fx;
+  Packet4i emm0;
+
+  // clamp x
+  x = pmax(pmin(x, p2d_exp_hi), p2d_exp_lo);
+  /* express exp(x) as exp(g + n*log(2)) */
+  fx = pmadd(p2d_cephes_LOG2EF, x, p2d_half);
+
+#ifdef EIGEN_VECTORIZE_SSE4_1
+  fx = _mm_floor_pd(fx);
+#else
+  emm0 = _mm_cvttpd_epi32(fx);
+  tmp  = _mm_cvtepi32_pd(emm0);
+  /* if greater, substract 1 */
+  Packet2d mask = _mm_cmpgt_pd(tmp, fx);
+  mask = _mm_and_pd(mask, p2d_1);
+  fx = psub(tmp, mask);
+#endif
+
+  tmp = pmul(fx, p2d_cephes_exp_C1);
+  Packet2d z = pmul(fx, p2d_cephes_exp_C2);
+  x = psub(x, tmp);
+  x = psub(x, z);
+
+  Packet2d x2 = pmul(x,x);
+
+  Packet2d px = p2d_cephes_exp_p0;
+  px = pmadd(px, x2, p2d_cephes_exp_p1);
+  px = pmadd(px, x2, p2d_cephes_exp_p2);
+  px = pmul (px, x);
+
+  Packet2d qx = p2d_cephes_exp_q0;
+  qx = pmadd(qx, x2, p2d_cephes_exp_q1);
+  qx = pmadd(qx, x2, p2d_cephes_exp_q2);
+  qx = pmadd(qx, x2, p2d_cephes_exp_q3);
+
+  x = pdiv(px,psub(qx,px));
+  x = pmadd(p2d_2,x,p2d_1);
+
+  // build 2^n
+  emm0 = _mm_cvttpd_epi32(fx);
+  emm0 = _mm_add_epi32(emm0, p4i_1023_0);
+  emm0 = _mm_slli_epi32(emm0, 20);
+  emm0 = _mm_shuffle_epi32(emm0, _MM_SHUFFLE(1,2,0,3));
+  return pmax(pmul(x, Packet2d(_mm_castsi128_pd(emm0))), _x);
+}
+
+/* evaluation of 4 sines at onces, using SSE2 intrinsics.
+
+   The code is the exact rewriting of the cephes sinf function.
+   Precision is excellent as long as x < 8192 (I did not bother to
+   take into account the special handling they have for greater values
+   -- it does not return garbage for arguments over 8192, though, but
+   the extra precision is missing).
+
+   Note that it is such that sinf((float)M_PI) = 8.74e-8, which is the
+   surprising but correct result.
+*/
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f psin<Packet4f>(const Packet4f& _x)
+{
+  Packet4f x = _x;
+  _EIGEN_DECLARE_CONST_Packet4f(1 , 1.0f);
+  _EIGEN_DECLARE_CONST_Packet4f(half, 0.5f);
+
+  _EIGEN_DECLARE_CONST_Packet4i(1, 1);
+  _EIGEN_DECLARE_CONST_Packet4i(not1, ~1);
+  _EIGEN_DECLARE_CONST_Packet4i(2, 2);
+  _EIGEN_DECLARE_CONST_Packet4i(4, 4);
+
+  _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(sign_mask, 0x80000000);
+
+  _EIGEN_DECLARE_CONST_Packet4f(minus_cephes_DP1,-0.78515625f);
+  _EIGEN_DECLARE_CONST_Packet4f(minus_cephes_DP2, -2.4187564849853515625e-4f);
+  _EIGEN_DECLARE_CONST_Packet4f(minus_cephes_DP3, -3.77489497744594108e-8f);
+  _EIGEN_DECLARE_CONST_Packet4f(sincof_p0, -1.9515295891E-4f);
+  _EIGEN_DECLARE_CONST_Packet4f(sincof_p1,  8.3321608736E-3f);
+  _EIGEN_DECLARE_CONST_Packet4f(sincof_p2, -1.6666654611E-1f);
+  _EIGEN_DECLARE_CONST_Packet4f(coscof_p0,  2.443315711809948E-005f);
+  _EIGEN_DECLARE_CONST_Packet4f(coscof_p1, -1.388731625493765E-003f);
+  _EIGEN_DECLARE_CONST_Packet4f(coscof_p2,  4.166664568298827E-002f);
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_FOPI, 1.27323954473516f); // 4 / M_PI
+
+  Packet4f xmm1, xmm2, xmm3, sign_bit, y;
+
+  Packet4i emm0, emm2;
+  sign_bit = x;
+  /* take the absolute value */
+  x = pabs(x);
+
+  /* take the modulo */
+
+  /* extract the sign bit (upper one) */
+  sign_bit = _mm_and_ps(sign_bit, p4f_sign_mask);
+
+  /* scale by 4/Pi */
+  y = pmul(x, p4f_cephes_FOPI);
+
+  /* store the integer part of y in mm0 */
+  emm2 = _mm_cvttps_epi32(y);
+  /* j=(j+1) & (~1) (see the cephes sources) */
+  emm2 = _mm_add_epi32(emm2, p4i_1);
+  emm2 = _mm_and_si128(emm2, p4i_not1);
+  y = _mm_cvtepi32_ps(emm2);
+  /* get the swap sign flag */
+  emm0 = _mm_and_si128(emm2, p4i_4);
+  emm0 = _mm_slli_epi32(emm0, 29);
+  /* get the polynom selection mask
+     there is one polynom for 0 <= x <= Pi/4
+     and another one for Pi/4<x<=Pi/2
+
+     Both branches will be computed.
+  */
+  emm2 = _mm_and_si128(emm2, p4i_2);
+  emm2 = _mm_cmpeq_epi32(emm2, _mm_setzero_si128());
+
+  Packet4f swap_sign_bit = _mm_castsi128_ps(emm0);
+  Packet4f poly_mask = _mm_castsi128_ps(emm2);
+  sign_bit = _mm_xor_ps(sign_bit, swap_sign_bit);
+
+  /* The magic pass: "Extended precision modular arithmetic"
+     x = ((x - y * DP1) - y * DP2) - y * DP3; */
+  xmm1 = pmul(y, p4f_minus_cephes_DP1);
+  xmm2 = pmul(y, p4f_minus_cephes_DP2);
+  xmm3 = pmul(y, p4f_minus_cephes_DP3);
+  x = padd(x, xmm1);
+  x = padd(x, xmm2);
+  x = padd(x, xmm3);
+
+  /* Evaluate the first polynom  (0 <= x <= Pi/4) */
+  y = p4f_coscof_p0;
+  Packet4f z = _mm_mul_ps(x,x);
+
+  y = pmadd(y, z, p4f_coscof_p1);
+  y = pmadd(y, z, p4f_coscof_p2);
+  y = pmul(y, z);
+  y = pmul(y, z);
+  Packet4f tmp = pmul(z, p4f_half);
+  y = psub(y, tmp);
+  y = padd(y, p4f_1);
+
+  /* Evaluate the second polynom  (Pi/4 <= x <= 0) */
+
+  Packet4f y2 = p4f_sincof_p0;
+  y2 = pmadd(y2, z, p4f_sincof_p1);
+  y2 = pmadd(y2, z, p4f_sincof_p2);
+  y2 = pmul(y2, z);
+  y2 = pmul(y2, x);
+  y2 = padd(y2, x);
+
+  /* select the correct result from the two polynoms */
+  y2 = _mm_and_ps(poly_mask, y2);
+  y = _mm_andnot_ps(poly_mask, y);
+  y = _mm_or_ps(y,y2);
+  /* update the sign */
+  return _mm_xor_ps(y, sign_bit);
+}
+
+/* almost the same as psin */
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f pcos<Packet4f>(const Packet4f& _x)
+{
+  Packet4f x = _x;
+  _EIGEN_DECLARE_CONST_Packet4f(1 , 1.0f);
+  _EIGEN_DECLARE_CONST_Packet4f(half, 0.5f);
+
+  _EIGEN_DECLARE_CONST_Packet4i(1, 1);
+  _EIGEN_DECLARE_CONST_Packet4i(not1, ~1);
+  _EIGEN_DECLARE_CONST_Packet4i(2, 2);
+  _EIGEN_DECLARE_CONST_Packet4i(4, 4);
+
+  _EIGEN_DECLARE_CONST_Packet4f(minus_cephes_DP1,-0.78515625f);
+  _EIGEN_DECLARE_CONST_Packet4f(minus_cephes_DP2, -2.4187564849853515625e-4f);
+  _EIGEN_DECLARE_CONST_Packet4f(minus_cephes_DP3, -3.77489497744594108e-8f);
+  _EIGEN_DECLARE_CONST_Packet4f(sincof_p0, -1.9515295891E-4f);
+  _EIGEN_DECLARE_CONST_Packet4f(sincof_p1,  8.3321608736E-3f);
+  _EIGEN_DECLARE_CONST_Packet4f(sincof_p2, -1.6666654611E-1f);
+  _EIGEN_DECLARE_CONST_Packet4f(coscof_p0,  2.443315711809948E-005f);
+  _EIGEN_DECLARE_CONST_Packet4f(coscof_p1, -1.388731625493765E-003f);
+  _EIGEN_DECLARE_CONST_Packet4f(coscof_p2,  4.166664568298827E-002f);
+  _EIGEN_DECLARE_CONST_Packet4f(cephes_FOPI, 1.27323954473516f); // 4 / M_PI
+
+  Packet4f xmm1, xmm2, xmm3, y;
+  Packet4i emm0, emm2;
+
+  x = pabs(x);
+
+  /* scale by 4/Pi */
+  y = pmul(x, p4f_cephes_FOPI);
+
+  /* get the integer part of y */
+  emm2 = _mm_cvttps_epi32(y);
+  /* j=(j+1) & (~1) (see the cephes sources) */
+  emm2 = _mm_add_epi32(emm2, p4i_1);
+  emm2 = _mm_and_si128(emm2, p4i_not1);
+  y = _mm_cvtepi32_ps(emm2);
+
+  emm2 = _mm_sub_epi32(emm2, p4i_2);
+
+  /* get the swap sign flag */
+  emm0 = _mm_andnot_si128(emm2, p4i_4);
+  emm0 = _mm_slli_epi32(emm0, 29);
+  /* get the polynom selection mask */
+  emm2 = _mm_and_si128(emm2, p4i_2);
+  emm2 = _mm_cmpeq_epi32(emm2, _mm_setzero_si128());
+
+  Packet4f sign_bit = _mm_castsi128_ps(emm0);
+  Packet4f poly_mask = _mm_castsi128_ps(emm2);
+
+  /* The magic pass: "Extended precision modular arithmetic"
+     x = ((x - y * DP1) - y * DP2) - y * DP3; */
+  xmm1 = pmul(y, p4f_minus_cephes_DP1);
+  xmm2 = pmul(y, p4f_minus_cephes_DP2);
+  xmm3 = pmul(y, p4f_minus_cephes_DP3);
+  x = padd(x, xmm1);
+  x = padd(x, xmm2);
+  x = padd(x, xmm3);
+
+  /* Evaluate the first polynom  (0 <= x <= Pi/4) */
+  y = p4f_coscof_p0;
+  Packet4f z = pmul(x,x);
+
+  y = pmadd(y,z,p4f_coscof_p1);
+  y = pmadd(y,z,p4f_coscof_p2);
+  y = pmul(y, z);
+  y = pmul(y, z);
+  Packet4f tmp = _mm_mul_ps(z, p4f_half);
+  y = psub(y, tmp);
+  y = padd(y, p4f_1);
+
+  /* Evaluate the second polynom  (Pi/4 <= x <= 0) */
+  Packet4f y2 = p4f_sincof_p0;
+  y2 = pmadd(y2, z, p4f_sincof_p1);
+  y2 = pmadd(y2, z, p4f_sincof_p2);
+  y2 = pmul(y2, z);
+  y2 = pmadd(y2, x, x);
+
+  /* select the correct result from the two polynoms */
+  y2 = _mm_and_ps(poly_mask, y2);
+  y  = _mm_andnot_ps(poly_mask, y);
+  y  = _mm_or_ps(y,y2);
+
+  /* update the sign */
+  return _mm_xor_ps(y, sign_bit);
+}
+
+#if EIGEN_FAST_MATH
+
+// Functions for sqrt.
+// The EIGEN_FAST_MATH version uses the _mm_rsqrt_ps approximation and one step
+// of Newton's method, at a cost of 1-2 bits of precision as opposed to the
+// exact solution. It does not handle +inf, or denormalized numbers correctly.
+// The main advantage of this approach is not just speed, but also the fact that
+// it can be inlined and pipelined with other computations, further reducing its
+// effective latency. This is similar to Quake3's fast inverse square root.
+// For detail see here: http://www.beyond3d.com/content/articles/8/
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f psqrt<Packet4f>(const Packet4f& _x)
+{
+  Packet4f half = pmul(_x, pset1<Packet4f>(.5f));
+  Packet4f denormal_mask = _mm_and_ps(
+      _mm_cmpge_ps(_x, _mm_setzero_ps()),
+      _mm_cmplt_ps(_x, pset1<Packet4f>((std::numeric_limits<float>::min)())));
+
+  // Compute approximate reciprocal sqrt.
+  Packet4f x = _mm_rsqrt_ps(_x);
+  // Do a single step of Newton's iteration.
+  x = pmul(x, psub(pset1<Packet4f>(1.5f), pmul(half, pmul(x,x))));
+  // Flush results for denormals to zero.
+  return _mm_andnot_ps(denormal_mask, pmul(_x,x));
+}
+
+#else
+
+template<>EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f psqrt<Packet4f>(const Packet4f& x) { return _mm_sqrt_ps(x); }
+
+#endif
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d psqrt<Packet2d>(const Packet2d& x) { return _mm_sqrt_pd(x); }
+
+#if EIGEN_FAST_MATH
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f prsqrt<Packet4f>(const Packet4f& _x) {
+  _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(inf, 0x7f800000);
+  _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(nan, 0x7fc00000);
+  _EIGEN_DECLARE_CONST_Packet4f(one_point_five, 1.5f);
+  _EIGEN_DECLARE_CONST_Packet4f(minus_half, -0.5f);
+  _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(flt_min, 0x00800000);
+
+  Packet4f neg_half = pmul(_x, p4f_minus_half);
+
+  // select only the inverse sqrt of positive normal inputs (denormals are
+  // flushed to zero and cause infs as well).
+  Packet4f le_zero_mask = _mm_cmple_ps(_x, p4f_flt_min);
+  Packet4f x = _mm_andnot_ps(le_zero_mask, _mm_rsqrt_ps(_x));
+
+  // Fill in NaNs and Infs for the negative/zero entries.
+  Packet4f neg_mask = _mm_cmplt_ps(_x, _mm_setzero_ps());
+  Packet4f zero_mask = _mm_andnot_ps(neg_mask, le_zero_mask);
+  Packet4f infs_and_nans = _mm_or_ps(_mm_and_ps(neg_mask, p4f_nan),
+                                     _mm_and_ps(zero_mask, p4f_inf));
+
+  // Do a single step of Newton's iteration.
+  x = pmul(x, pmadd(neg_half, pmul(x, x), p4f_one_point_five));
+
+  // Insert NaNs and Infs in all the right places.
+  return _mm_or_ps(x, infs_and_nans);
+}
+
+#else
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f prsqrt<Packet4f>(const Packet4f& x) {
+  // Unfortunately we can't use the much faster mm_rqsrt_ps since it only provides an approximation.
+  return _mm_div_ps(pset1<Packet4f>(1.0f), _mm_sqrt_ps(x));
+}
+
+#endif
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d prsqrt<Packet2d>(const Packet2d& x) {
+  // Unfortunately we can't use the much faster mm_rqsrt_pd since it only provides an approximation.
+  return _mm_div_pd(pset1<Packet2d>(1.0), _mm_sqrt_pd(x));
+}
+
+// Hyperbolic Tangent function.
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f
+ptanh<Packet4f>(const Packet4f& x) {
+  return internal::generic_fast_tanh_float(x);
+}
+
+} // end namespace internal
+
+namespace numext {
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float sqrt(const float &x)
+{
+  return internal::pfirst(internal::Packet4f(_mm_sqrt_ss(_mm_set_ss(x))));
+}
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double sqrt(const double &x)
+{
+#if EIGEN_COMP_GNUC_STRICT
+  // This works around a GCC bug generating poor code for _mm_sqrt_pd
+  // See https://bitbucket.org/eigen/eigen/commits/14f468dba4d350d7c19c9b93072e19f7b3df563b
+  return internal::pfirst(internal::Packet2d(__builtin_ia32_sqrtsd(_mm_set_sd(x))));
+#else
+  return internal::pfirst(internal::Packet2d(_mm_sqrt_pd(_mm_set_sd(x))));
+#endif
+}
+
+} // end namespace numex
+
+} // end namespace Eigen
+
+#endif // EIGEN_MATH_FUNCTIONS_SSE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/SSE/PacketMath.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/SSE/PacketMath.h
new file mode 100644
index 00000000..d3b74aca
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/SSE/PacketMath.h
@@ -0,0 +1,931 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PACKET_MATH_SSE_H
+#define EIGEN_PACKET_MATH_SSE_H
+
+namespace Eigen {
+
+namespace internal {
+
+#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
+#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8
+#endif
+
+#ifndef EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS
+#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS (2*sizeof(void*))
+#endif
+
+#ifdef __FMA__
+#ifndef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#define EIGEN_HAS_SINGLE_INSTRUCTION_MADD 1
+#endif
+#endif
+
+#if (defined EIGEN_VECTORIZE_AVX) && (EIGEN_COMP_GNUC_STRICT || EIGEN_COMP_MINGW || EIGEN_COMP_LCC_E2K) && (__GXX_ABI_VERSION < 1004)
+// With GCC's default ABI version, a __m128 or __m256 are the same types and therefore we cannot
+// have overloads for both types without linking error.
+// One solution is to increase ABI version using -fabi-version=4 (or greater).
+// Otherwise, we workaround this inconvenience by wrapping 128bit types into the following helper
+// structure:
+template<typename T>
+struct eigen_packet_wrapper
+{
+  EIGEN_ALWAYS_INLINE operator T&() { return m_val; }
+  EIGEN_ALWAYS_INLINE operator const T&() const { return m_val; }
+  EIGEN_ALWAYS_INLINE eigen_packet_wrapper() {}
+  EIGEN_ALWAYS_INLINE eigen_packet_wrapper(const T &v) : m_val(v) {}
+  EIGEN_ALWAYS_INLINE eigen_packet_wrapper& operator=(const T &v) {
+    m_val = v;
+    return *this;
+  }
+
+  T m_val;
+};
+typedef eigen_packet_wrapper<__m128>  Packet4f;
+typedef eigen_packet_wrapper<__m128i> Packet4i;
+typedef eigen_packet_wrapper<__m128d> Packet2d;
+#else
+typedef __m128  Packet4f;
+typedef __m128i Packet4i;
+typedef __m128d Packet2d;
+#endif
+
+template<> struct is_arithmetic<__m128>  { enum { value = true }; };
+template<> struct is_arithmetic<__m128i> { enum { value = true }; };
+template<> struct is_arithmetic<__m128d> { enum { value = true }; };
+
+#define vec4f_swizzle1(v,p,q,r,s) \
+  (_mm_castsi128_ps(_mm_shuffle_epi32( _mm_castps_si128(v), ((s)<<6|(r)<<4|(q)<<2|(p)))))
+
+#define vec4i_swizzle1(v,p,q,r,s) \
+  (_mm_shuffle_epi32( v, ((s)<<6|(r)<<4|(q)<<2|(p))))
+
+#define vec2d_swizzle1(v,p,q) \
+  (_mm_castsi128_pd(_mm_shuffle_epi32( _mm_castpd_si128(v), ((q*2+1)<<6|(q*2)<<4|(p*2+1)<<2|(p*2)))))
+
+#define vec4f_swizzle2(a,b,p,q,r,s) \
+  (_mm_shuffle_ps( (a), (b), ((s)<<6|(r)<<4|(q)<<2|(p))))
+
+#define vec4i_swizzle2(a,b,p,q,r,s) \
+  (_mm_castps_si128( (_mm_shuffle_ps( _mm_castsi128_ps(a), _mm_castsi128_ps(b), ((s)<<6|(r)<<4|(q)<<2|(p))))))
+
+#define _EIGEN_DECLARE_CONST_Packet4f(NAME,X) \
+  const Packet4f p4f_##NAME = pset1<Packet4f>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet2d(NAME,X) \
+  const Packet2d p2d_##NAME = pset1<Packet2d>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(NAME,X) \
+  const Packet4f p4f_##NAME = _mm_castsi128_ps(pset1<Packet4i>(X))
+
+#define _EIGEN_DECLARE_CONST_Packet4i(NAME,X) \
+  const Packet4i p4i_##NAME = pset1<Packet4i>(X)
+
+
+// Use the packet_traits defined in AVX/PacketMath.h instead if we're going
+// to leverage AVX instructions.
+#ifndef EIGEN_VECTORIZE_AVX
+template<> struct packet_traits<float>  : default_packet_traits
+{
+  typedef Packet4f type;
+  typedef Packet4f half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=4,
+    HasHalfPacket = 0,
+
+    HasDiv  = 1,
+    HasSin  = EIGEN_FAST_MATH,
+    HasCos  = EIGEN_FAST_MATH,
+    HasLog  = 1,
+    HasExp  = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasTanh  = EIGEN_FAST_MATH,
+    HasBlend = 1
+
+#ifdef EIGEN_VECTORIZE_SSE4_1
+    ,
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1
+#endif
+  };
+};
+template<> struct packet_traits<double> : default_packet_traits
+{
+  typedef Packet2d type;
+  typedef Packet2d half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=2,
+    HasHalfPacket = 0,
+
+    HasDiv  = 1,
+    HasExp  = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasBlend = 1
+
+#ifdef EIGEN_VECTORIZE_SSE4_1
+    ,
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1
+#endif
+  };
+};
+#endif
+template<> struct packet_traits<int>    : default_packet_traits
+{
+  typedef Packet4i type;
+  typedef Packet4i half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=4,
+
+    HasBlend = 1
+  };
+};
+
+template<> struct unpacket_traits<Packet4f> { typedef float  type; enum {size=4, alignment=Aligned16}; typedef Packet4f half; };
+template<> struct unpacket_traits<Packet2d> { typedef double type; enum {size=2, alignment=Aligned16}; typedef Packet2d half; };
+template<> struct unpacket_traits<Packet4i> { typedef int    type; enum {size=4, alignment=Aligned16}; typedef Packet4i half; };
+
+#ifndef EIGEN_VECTORIZE_AVX
+template<> struct scalar_div_cost<float,true> { enum { value = 7 }; };
+template<> struct scalar_div_cost<double,true> { enum { value = 8 }; };
+#endif
+
+#if EIGEN_COMP_MSVC==1500
+// Workaround MSVC 9 internal compiler error.
+// TODO: It has been detected with win64 builds (amd64), so let's check whether it also happens in 32bits+SSE mode
+// TODO: let's check whether there does not exist a better fix, like adding a pset0() function. (it crashed on pset1(0)).
+template<> EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(const float&  from) { return _mm_set_ps(from,from,from,from); }
+template<> EIGEN_STRONG_INLINE Packet2d pset1<Packet2d>(const double& from) { return _mm_set_pd(from,from); }
+template<> EIGEN_STRONG_INLINE Packet4i pset1<Packet4i>(const int&    from) { return _mm_set_epi32(from,from,from,from); }
+#else
+template<> EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(const float&  from) { return _mm_set_ps1(from); }
+template<> EIGEN_STRONG_INLINE Packet2d pset1<Packet2d>(const double& from) { return _mm_set1_pd(from); }
+template<> EIGEN_STRONG_INLINE Packet4i pset1<Packet4i>(const int&    from) { return _mm_set1_epi32(from); }
+#endif
+
+// GCC generates a shufps instruction for _mm_set1_ps/_mm_load1_ps instead of the more efficient pshufd instruction.
+// However, using inrinsics for pset1 makes gcc to generate crappy code in some cases (see bug 203)
+// Using inline assembly is also not an option because then gcc fails to reorder properly the instructions.
+// Therefore, we introduced the pload1 functions to be used in product kernels for which bug 203 does not apply.
+// Also note that with AVX, we want it to generate a vbroadcastss.
+#if EIGEN_COMP_GNUC_STRICT && (!defined __AVX__)
+template<> EIGEN_STRONG_INLINE Packet4f pload1<Packet4f>(const float *from) {
+  return vec4f_swizzle1(_mm_load_ss(from),0,0,0,0);
+}
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet4f plset<Packet4f>(const float& a) { return _mm_add_ps(pset1<Packet4f>(a), _mm_set_ps(3,2,1,0)); }
+template<> EIGEN_STRONG_INLINE Packet2d plset<Packet2d>(const double& a) { return _mm_add_pd(pset1<Packet2d>(a),_mm_set_pd(1,0)); }
+template<> EIGEN_STRONG_INLINE Packet4i plset<Packet4i>(const int& a) { return _mm_add_epi32(pset1<Packet4i>(a),_mm_set_epi32(3,2,1,0)); }
+
+template<> EIGEN_STRONG_INLINE Packet4f padd<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_add_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2d padd<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_add_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i padd<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_add_epi32(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f psub<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_sub_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2d psub<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_sub_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i psub<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_sub_epi32(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pnegate(const Packet4f& a)
+{
+  const Packet4f mask = _mm_castsi128_ps(_mm_setr_epi32(0x80000000,0x80000000,0x80000000,0x80000000));
+  return _mm_xor_ps(a,mask);
+}
+template<> EIGEN_STRONG_INLINE Packet2d pnegate(const Packet2d& a)
+{
+  const Packet2d mask = _mm_castsi128_pd(_mm_setr_epi32(0x0,0x80000000,0x0,0x80000000));
+  return _mm_xor_pd(a,mask);
+}
+template<> EIGEN_STRONG_INLINE Packet4i pnegate(const Packet4i& a)
+{
+  return psub(Packet4i(_mm_setr_epi32(0,0,0,0)), a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pconj(const Packet4f& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet2d pconj(const Packet2d& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4i pconj(const Packet4i& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet4f pmul<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_mul_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2d pmul<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_mul_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pmul<Packet4i>(const Packet4i& a, const Packet4i& b)
+{
+#ifdef EIGEN_VECTORIZE_SSE4_1
+  return _mm_mullo_epi32(a,b);
+#else
+  // this version is slightly faster than 4 scalar products
+  return vec4i_swizzle1(
+            vec4i_swizzle2(
+              _mm_mul_epu32(a,b),
+              _mm_mul_epu32(vec4i_swizzle1(a,1,0,3,2),
+                            vec4i_swizzle1(b,1,0,3,2)),
+              0,2,0,2),
+            0,2,1,3);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pdiv<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_div_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2d pdiv<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_div_pd(a,b); }
+
+// for some weird raisons, it has to be overloaded for packet of integers
+template<> EIGEN_STRONG_INLINE Packet4i pmadd(const Packet4i& a, const Packet4i& b, const Packet4i& c) { return padd(pmul(a,b), c); }
+#ifdef __FMA__
+template<> EIGEN_STRONG_INLINE Packet4f pmadd(const Packet4f& a, const Packet4f& b, const Packet4f& c) { return _mm_fmadd_ps(a,b,c); }
+template<> EIGEN_STRONG_INLINE Packet2d pmadd(const Packet2d& a, const Packet2d& b, const Packet2d& c) { return _mm_fmadd_pd(a,b,c); }
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet4f pmin<Packet4f>(const Packet4f& a, const Packet4f& b) {
+#if EIGEN_COMP_GNUC && !(EIGEN_COMP_LCC_E2K)
+  // There appears to be a bug in GCC, by which the optimizer may
+  // flip the argument order in calls to _mm_min_ps, so we have to
+  // resort to inline ASM here. This is supposed to be fixed in gcc6.3,
+  // see also: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=72867
+  Packet4f res = b;
+  asm("minps %[a], %[res]" : [res] "+x" (res) : [a] "x" (a));
+  return res;
+#else
+  // Arguments are reversed to match NaN propagation behavior of std::min.
+  return _mm_min_ps(b, a);
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet2d pmin<Packet2d>(const Packet2d& a, const Packet2d& b) {
+#if EIGEN_COMP_GNUC && !(EIGEN_COMP_LCC_E2K)
+  // There appears to be a bug in GCC, by which the optimizer may
+  // flip the argument order in calls to _mm_min_pd, so we have to
+  // resort to inline ASM here. This is supposed to be fixed in gcc6.3,
+  // see also: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=72867
+  Packet2d res = b;
+  asm("minpd %[a], %[res]" : [res] "+x" (res) : [a] "x" (a));
+  return res;
+#else
+  // Arguments are reversed to match NaN propagation behavior of std::min.
+  return _mm_min_pd(b, a);
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet4i pmin<Packet4i>(const Packet4i& a, const Packet4i& b)
+{
+#ifdef EIGEN_VECTORIZE_SSE4_1
+  return _mm_min_epi32(a,b);
+#else
+  // after some bench, this version *is* faster than a scalar implementation
+  Packet4i mask = _mm_cmplt_epi32(a,b);
+  return _mm_or_si128(_mm_and_si128(mask,a),_mm_andnot_si128(mask,b));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pmax<Packet4f>(const Packet4f& a, const Packet4f& b) {
+#if EIGEN_COMP_GNUC && !(EIGEN_COMP_LCC_E2K)
+  // There appears to be a bug in GCC, by which the optimizer may
+  // flip the argument order in calls to _mm_max_ps, so we have to
+  // resort to inline ASM here. This is supposed to be fixed in gcc6.3,
+  // see also: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=72867
+  Packet4f res = b;
+  asm("maxps %[a], %[res]" : [res] "+x" (res) : [a] "x" (a));
+  return res;
+#else
+  // Arguments are reversed to match NaN propagation behavior of std::max.
+  return _mm_max_ps(b, a);
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet2d pmax<Packet2d>(const Packet2d& a, const Packet2d& b) {
+#if EIGEN_COMP_GNUC && !(EIGEN_COMP_LCC_E2K)
+  // There appears to be a bug in GCC, by which the optimizer may
+  // flip the argument order in calls to _mm_max_pd, so we have to
+  // resort to inline ASM here. This is supposed to be fixed in gcc6.3,
+  // see also: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=72867
+  Packet2d res = b;
+  asm("maxpd %[a], %[res]" : [res] "+x" (res) : [a] "x" (a));
+  return res;
+#else
+  // Arguments are reversed to match NaN propagation behavior of std::max.
+  return _mm_max_pd(b, a);
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet4i pmax<Packet4i>(const Packet4i& a, const Packet4i& b)
+{
+#ifdef EIGEN_VECTORIZE_SSE4_1
+  return _mm_max_epi32(a,b);
+#else
+  // after some bench, this version *is* faster than a scalar implementation
+  Packet4i mask = _mm_cmpgt_epi32(a,b);
+  return _mm_or_si128(_mm_and_si128(mask,a),_mm_andnot_si128(mask,b));
+#endif
+}
+
+#ifdef EIGEN_VECTORIZE_SSE4_1
+template<> EIGEN_STRONG_INLINE Packet4f pround<Packet4f>(const Packet4f& a) { return _mm_round_ps(a, 0); }
+template<> EIGEN_STRONG_INLINE Packet2d pround<Packet2d>(const Packet2d& a) { return _mm_round_pd(a, 0); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pceil<Packet4f>(const Packet4f& a) { return _mm_ceil_ps(a); }
+template<> EIGEN_STRONG_INLINE Packet2d pceil<Packet2d>(const Packet2d& a) { return _mm_ceil_pd(a); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pfloor<Packet4f>(const Packet4f& a) { return _mm_floor_ps(a); }
+template<> EIGEN_STRONG_INLINE Packet2d pfloor<Packet2d>(const Packet2d& a) { return _mm_floor_pd(a); }
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet4f pand<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_and_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2d pand<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_and_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pand<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_and_si128(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f por<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_or_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2d por<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_or_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i por<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_or_si128(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_xor_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2d pxor<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_xor_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pxor<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_xor_si128(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pandnot<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_andnot_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2d pandnot<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_andnot_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pandnot<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_andnot_si128(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pload<Packet4f>(const float*   from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm_load_ps(from); }
+template<> EIGEN_STRONG_INLINE Packet2d pload<Packet2d>(const double*  from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm_load_pd(from); }
+template<> EIGEN_STRONG_INLINE Packet4i pload<Packet4i>(const int*     from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm_load_si128(reinterpret_cast<const __m128i*>(from)); }
+
+#if EIGEN_COMP_MSVC
+  template<> EIGEN_STRONG_INLINE Packet4f ploadu<Packet4f>(const float*  from) {
+    EIGEN_DEBUG_UNALIGNED_LOAD
+    #if (EIGEN_COMP_MSVC==1600)
+    // NOTE Some version of MSVC10 generates bad code when using _mm_loadu_ps
+    // (i.e., it does not generate an unaligned load!!
+    __m128 res = _mm_loadl_pi(_mm_set1_ps(0.0f), (const __m64*)(from));
+    res = _mm_loadh_pi(res, (const __m64*)(from+2));
+    return res;
+    #else
+    return _mm_loadu_ps(from);
+    #endif
+  }
+#else
+// NOTE: with the code below, MSVC's compiler crashes!
+
+template<> EIGEN_STRONG_INLINE Packet4f ploadu<Packet4f>(const float* from)
+{
+  EIGEN_DEBUG_UNALIGNED_LOAD
+  return _mm_loadu_ps(from);
+}
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet2d ploadu<Packet2d>(const double* from)
+{
+  EIGEN_DEBUG_UNALIGNED_LOAD
+  return _mm_loadu_pd(from);
+}
+template<> EIGEN_STRONG_INLINE Packet4i ploadu<Packet4i>(const int* from)
+{
+  EIGEN_DEBUG_UNALIGNED_LOAD
+  return _mm_loadu_si128(reinterpret_cast<const __m128i*>(from));
+}
+
+
+template<> EIGEN_STRONG_INLINE Packet4f ploaddup<Packet4f>(const float*   from)
+{
+  return vec4f_swizzle1(_mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double*>(from))), 0, 0, 1, 1);
+}
+template<> EIGEN_STRONG_INLINE Packet2d ploaddup<Packet2d>(const double*  from)
+{ return pset1<Packet2d>(from[0]); }
+template<> EIGEN_STRONG_INLINE Packet4i ploaddup<Packet4i>(const int*     from)
+{
+  Packet4i tmp;
+  tmp = _mm_loadl_epi64(reinterpret_cast<const __m128i*>(from));
+  return vec4i_swizzle1(tmp, 0, 0, 1, 1);
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<float>(float*   to, const Packet4f& from) { EIGEN_DEBUG_ALIGNED_STORE _mm_store_ps(to, from); }
+template<> EIGEN_STRONG_INLINE void pstore<double>(double* to, const Packet2d& from) { EIGEN_DEBUG_ALIGNED_STORE _mm_store_pd(to, from); }
+template<> EIGEN_STRONG_INLINE void pstore<int>(int*       to, const Packet4i& from) { EIGEN_DEBUG_ALIGNED_STORE _mm_store_si128(reinterpret_cast<__m128i*>(to), from); }
+
+template<> EIGEN_STRONG_INLINE void pstoreu<double>(double* to, const Packet2d& from) { EIGEN_DEBUG_UNALIGNED_STORE _mm_storeu_pd(to, from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<float>(float*   to, const Packet4f& from) { EIGEN_DEBUG_UNALIGNED_STORE _mm_storeu_ps(to, from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<int>(int*       to, const Packet4i& from) { EIGEN_DEBUG_UNALIGNED_STORE _mm_storeu_si128(reinterpret_cast<__m128i*>(to), from); }
+
+template<> EIGEN_DEVICE_FUNC inline Packet4f pgather<float, Packet4f>(const float* from, Index stride)
+{
+ return _mm_set_ps(from[3*stride], from[2*stride], from[1*stride], from[0*stride]);
+}
+template<> EIGEN_DEVICE_FUNC inline Packet2d pgather<double, Packet2d>(const double* from, Index stride)
+{
+ return _mm_set_pd(from[1*stride], from[0*stride]);
+}
+template<> EIGEN_DEVICE_FUNC inline Packet4i pgather<int, Packet4i>(const int* from, Index stride)
+{
+ return _mm_set_epi32(from[3*stride], from[2*stride], from[1*stride], from[0*stride]);
+ }
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<float, Packet4f>(float* to, const Packet4f& from, Index stride)
+{
+  to[stride*0] = _mm_cvtss_f32(from);
+  to[stride*1] = _mm_cvtss_f32(_mm_shuffle_ps(from, from, 1));
+  to[stride*2] = _mm_cvtss_f32(_mm_shuffle_ps(from, from, 2));
+  to[stride*3] = _mm_cvtss_f32(_mm_shuffle_ps(from, from, 3));
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<double, Packet2d>(double* to, const Packet2d& from, Index stride)
+{
+  to[stride*0] = _mm_cvtsd_f64(from);
+  to[stride*1] = _mm_cvtsd_f64(_mm_shuffle_pd(from, from, 1));
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<int, Packet4i>(int* to, const Packet4i& from, Index stride)
+{
+  to[stride*0] = _mm_cvtsi128_si32(from);
+  to[stride*1] = _mm_cvtsi128_si32(_mm_shuffle_epi32(from, 1));
+  to[stride*2] = _mm_cvtsi128_si32(_mm_shuffle_epi32(from, 2));
+  to[stride*3] = _mm_cvtsi128_si32(_mm_shuffle_epi32(from, 3));
+}
+
+// some compilers might be tempted to perform multiple moves instead of using a vector path.
+template<> EIGEN_STRONG_INLINE void pstore1<Packet4f>(float* to, const float& a)
+{
+  Packet4f pa = _mm_set_ss(a);
+  pstore(to, Packet4f(vec4f_swizzle1(pa,0,0,0,0)));
+}
+// some compilers might be tempted to perform multiple moves instead of using a vector path.
+template<> EIGEN_STRONG_INLINE void pstore1<Packet2d>(double* to, const double& a)
+{
+  Packet2d pa = _mm_set_sd(a);
+  pstore(to, Packet2d(vec2d_swizzle1(pa,0,0)));
+}
+
+#ifndef EIGEN_VECTORIZE_AVX
+template<> EIGEN_STRONG_INLINE void prefetch<float>(const float*   addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); }
+template<> EIGEN_STRONG_INLINE void prefetch<double>(const double* addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); }
+template<> EIGEN_STRONG_INLINE void prefetch<int>(const int*       addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); }
+#endif
+
+#if EIGEN_COMP_MSVC_STRICT && EIGEN_OS_WIN64
+// The temporary variable fixes an internal compilation error in vs <= 2008 and a wrong-result bug in vs 2010
+// Direct of the struct members fixed bug #62.
+template<> EIGEN_STRONG_INLINE float  pfirst<Packet4f>(const Packet4f& a) { return a.m128_f32[0]; }
+template<> EIGEN_STRONG_INLINE double pfirst<Packet2d>(const Packet2d& a) { return a.m128d_f64[0]; }
+template<> EIGEN_STRONG_INLINE int    pfirst<Packet4i>(const Packet4i& a) { int x = _mm_cvtsi128_si32(a); return x; }
+#elif EIGEN_COMP_MSVC_STRICT
+// The temporary variable fixes an internal compilation error in vs <= 2008 and a wrong-result bug in vs 2010
+template<> EIGEN_STRONG_INLINE float  pfirst<Packet4f>(const Packet4f& a) { float x = _mm_cvtss_f32(a); return x; }
+template<> EIGEN_STRONG_INLINE double pfirst<Packet2d>(const Packet2d& a) { double x = _mm_cvtsd_f64(a); return x; }
+template<> EIGEN_STRONG_INLINE int    pfirst<Packet4i>(const Packet4i& a) { int x = _mm_cvtsi128_si32(a); return x; }
+#else
+template<> EIGEN_STRONG_INLINE float  pfirst<Packet4f>(const Packet4f& a) { return _mm_cvtss_f32(a); }
+template<> EIGEN_STRONG_INLINE double pfirst<Packet2d>(const Packet2d& a) { return _mm_cvtsd_f64(a); }
+template<> EIGEN_STRONG_INLINE int    pfirst<Packet4i>(const Packet4i& a) { return _mm_cvtsi128_si32(a); }
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet4f preverse(const Packet4f& a)
+{ return _mm_shuffle_ps(a,a,0x1B); }
+template<> EIGEN_STRONG_INLINE Packet2d preverse(const Packet2d& a)
+{ return _mm_shuffle_pd(a,a,0x1); }
+template<> EIGEN_STRONG_INLINE Packet4i preverse(const Packet4i& a)
+{ return _mm_shuffle_epi32(a,0x1B); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pabs(const Packet4f& a)
+{
+  const Packet4f mask = _mm_castsi128_ps(_mm_setr_epi32(0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF));
+  return _mm_and_ps(a,mask);
+}
+template<> EIGEN_STRONG_INLINE Packet2d pabs(const Packet2d& a)
+{
+  const Packet2d mask = _mm_castsi128_pd(_mm_setr_epi32(0xFFFFFFFF,0x7FFFFFFF,0xFFFFFFFF,0x7FFFFFFF));
+  return _mm_and_pd(a,mask);
+}
+template<> EIGEN_STRONG_INLINE Packet4i pabs(const Packet4i& a)
+{
+  #ifdef EIGEN_VECTORIZE_SSSE3
+  return _mm_abs_epi32(a);
+  #else
+  Packet4i aux = _mm_srai_epi32(a,31);
+  return _mm_sub_epi32(_mm_xor_si128(a,aux),aux);
+  #endif
+}
+
+// with AVX, the default implementations based on pload1 are faster
+#ifndef __AVX__
+template<> EIGEN_STRONG_INLINE void
+pbroadcast4<Packet4f>(const float *a,
+                      Packet4f& a0, Packet4f& a1, Packet4f& a2, Packet4f& a3)
+{
+  a3 = pload<Packet4f>(a);
+  a0 = vec4f_swizzle1(a3, 0,0,0,0);
+  a1 = vec4f_swizzle1(a3, 1,1,1,1);
+  a2 = vec4f_swizzle1(a3, 2,2,2,2);
+  a3 = vec4f_swizzle1(a3, 3,3,3,3);
+}
+template<> EIGEN_STRONG_INLINE void
+pbroadcast4<Packet2d>(const double *a,
+                      Packet2d& a0, Packet2d& a1, Packet2d& a2, Packet2d& a3)
+{
+#ifdef EIGEN_VECTORIZE_SSE3
+  a0 = _mm_loaddup_pd(a+0);
+  a1 = _mm_loaddup_pd(a+1);
+  a2 = _mm_loaddup_pd(a+2);
+  a3 = _mm_loaddup_pd(a+3);
+#else
+  a1 = pload<Packet2d>(a);
+  a0 = vec2d_swizzle1(a1, 0,0);
+  a1 = vec2d_swizzle1(a1, 1,1);
+  a3 = pload<Packet2d>(a+2);
+  a2 = vec2d_swizzle1(a3, 0,0);
+  a3 = vec2d_swizzle1(a3, 1,1);
+#endif
+}
+#endif
+
+EIGEN_STRONG_INLINE void punpackp(Packet4f* vecs)
+{
+  vecs[1] = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(vecs[0]), 0x55));
+  vecs[2] = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(vecs[0]), 0xAA));
+  vecs[3] = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(vecs[0]), 0xFF));
+  vecs[0] = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(vecs[0]), 0x00));
+}
+
+#ifdef EIGEN_VECTORIZE_SSE3
+template<> EIGEN_STRONG_INLINE Packet4f preduxp<Packet4f>(const Packet4f* vecs)
+{
+  return _mm_hadd_ps(_mm_hadd_ps(vecs[0], vecs[1]),_mm_hadd_ps(vecs[2], vecs[3]));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d preduxp<Packet2d>(const Packet2d* vecs)
+{
+  return _mm_hadd_pd(vecs[0], vecs[1]);
+}
+
+#else
+template<> EIGEN_STRONG_INLINE Packet4f preduxp<Packet4f>(const Packet4f* vecs)
+{
+  Packet4f tmp0, tmp1, tmp2;
+  tmp0 = _mm_unpacklo_ps(vecs[0], vecs[1]);
+  tmp1 = _mm_unpackhi_ps(vecs[0], vecs[1]);
+  tmp2 = _mm_unpackhi_ps(vecs[2], vecs[3]);
+  tmp0 = _mm_add_ps(tmp0, tmp1);
+  tmp1 = _mm_unpacklo_ps(vecs[2], vecs[3]);
+  tmp1 = _mm_add_ps(tmp1, tmp2);
+  tmp2 = _mm_movehl_ps(tmp1, tmp0);
+  tmp0 = _mm_movelh_ps(tmp0, tmp1);
+  return _mm_add_ps(tmp0, tmp2);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d preduxp<Packet2d>(const Packet2d* vecs)
+{
+  return _mm_add_pd(_mm_unpacklo_pd(vecs[0], vecs[1]), _mm_unpackhi_pd(vecs[0], vecs[1]));
+}
+#endif  // SSE3
+
+template<> EIGEN_STRONG_INLINE float predux<Packet4f>(const Packet4f& a)
+{
+  // Disable SSE3 _mm_hadd_pd that is extremely slow on all existing Intel's architectures
+  // (from Nehalem to Haswell)
+// #ifdef EIGEN_VECTORIZE_SSE3
+//   Packet4f tmp = _mm_add_ps(a, vec4f_swizzle1(a,2,3,2,3));
+//   return pfirst<Packet4f>(_mm_hadd_ps(tmp, tmp));
+// #else
+  Packet4f tmp = _mm_add_ps(a, _mm_movehl_ps(a,a));
+  return pfirst<Packet4f>(_mm_add_ss(tmp, _mm_shuffle_ps(tmp,tmp, 1)));
+// #endif
+}
+
+template<> EIGEN_STRONG_INLINE double predux<Packet2d>(const Packet2d& a)
+{
+  // Disable SSE3 _mm_hadd_pd that is extremely slow on all existing Intel's architectures
+  // (from Nehalem to Haswell)
+// #ifdef EIGEN_VECTORIZE_SSE3
+//   return pfirst<Packet2d>(_mm_hadd_pd(a, a));
+// #else
+  return pfirst<Packet2d>(_mm_add_sd(a, _mm_unpackhi_pd(a,a)));
+// #endif
+}
+
+#ifdef EIGEN_VECTORIZE_SSSE3
+template<> EIGEN_STRONG_INLINE Packet4i preduxp<Packet4i>(const Packet4i* vecs)
+{
+  return _mm_hadd_epi32(_mm_hadd_epi32(vecs[0], vecs[1]),_mm_hadd_epi32(vecs[2], vecs[3]));
+}
+template<> EIGEN_STRONG_INLINE int predux<Packet4i>(const Packet4i& a)
+{
+  Packet4i tmp0 = _mm_hadd_epi32(a,a);
+  return pfirst<Packet4i>(_mm_hadd_epi32(tmp0,tmp0));
+}
+#else
+template<> EIGEN_STRONG_INLINE int predux<Packet4i>(const Packet4i& a)
+{
+  Packet4i tmp = _mm_add_epi32(a, _mm_unpackhi_epi64(a,a));
+  return pfirst(tmp) + pfirst<Packet4i>(_mm_shuffle_epi32(tmp, 1));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i preduxp<Packet4i>(const Packet4i* vecs)
+{
+  Packet4i tmp0, tmp1, tmp2;
+  tmp0 = _mm_unpacklo_epi32(vecs[0], vecs[1]);
+  tmp1 = _mm_unpackhi_epi32(vecs[0], vecs[1]);
+  tmp2 = _mm_unpackhi_epi32(vecs[2], vecs[3]);
+  tmp0 = _mm_add_epi32(tmp0, tmp1);
+  tmp1 = _mm_unpacklo_epi32(vecs[2], vecs[3]);
+  tmp1 = _mm_add_epi32(tmp1, tmp2);
+  tmp2 = _mm_unpacklo_epi64(tmp0, tmp1);
+  tmp0 = _mm_unpackhi_epi64(tmp0, tmp1);
+  return _mm_add_epi32(tmp0, tmp2);
+}
+#endif
+// Other reduction functions:
+
+// mul
+template<> EIGEN_STRONG_INLINE float predux_mul<Packet4f>(const Packet4f& a)
+{
+  Packet4f tmp = _mm_mul_ps(a, _mm_movehl_ps(a,a));
+  return pfirst<Packet4f>(_mm_mul_ss(tmp, _mm_shuffle_ps(tmp,tmp, 1)));
+}
+template<> EIGEN_STRONG_INLINE double predux_mul<Packet2d>(const Packet2d& a)
+{
+  return pfirst<Packet2d>(_mm_mul_sd(a, _mm_unpackhi_pd(a,a)));
+}
+template<> EIGEN_STRONG_INLINE int predux_mul<Packet4i>(const Packet4i& a)
+{
+  // after some experiments, it is seems this is the fastest way to implement it
+  // for GCC (eg., reusing pmul is very slow !)
+  // TODO try to call _mm_mul_epu32 directly
+  EIGEN_ALIGN16 int aux[4];
+  pstore(aux, a);
+  return  (aux[0] * aux[1]) * (aux[2] * aux[3]);;
+}
+
+// min
+template<> EIGEN_STRONG_INLINE float predux_min<Packet4f>(const Packet4f& a)
+{
+  Packet4f tmp = _mm_min_ps(a, _mm_movehl_ps(a,a));
+  return pfirst<Packet4f>(_mm_min_ss(tmp, _mm_shuffle_ps(tmp,tmp, 1)));
+}
+template<> EIGEN_STRONG_INLINE double predux_min<Packet2d>(const Packet2d& a)
+{
+  return pfirst<Packet2d>(_mm_min_sd(a, _mm_unpackhi_pd(a,a)));
+}
+template<> EIGEN_STRONG_INLINE int predux_min<Packet4i>(const Packet4i& a)
+{
+#ifdef EIGEN_VECTORIZE_SSE4_1
+  Packet4i tmp = _mm_min_epi32(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(0,0,3,2)));
+  return pfirst<Packet4i>(_mm_min_epi32(tmp,_mm_shuffle_epi32(tmp, 1)));
+#else
+  // after some experiments, it is seems this is the fastest way to implement it
+  // for GCC (eg., it does not like using std::min after the pstore !!)
+  EIGEN_ALIGN16 int aux[4];
+  pstore(aux, a);
+  int aux0 = aux[0]<aux[1] ? aux[0] : aux[1];
+  int aux2 = aux[2]<aux[3] ? aux[2] : aux[3];
+  return aux0<aux2 ? aux0 : aux2;
+#endif // EIGEN_VECTORIZE_SSE4_1
+}
+
+// max
+template<> EIGEN_STRONG_INLINE float predux_max<Packet4f>(const Packet4f& a)
+{
+  Packet4f tmp = _mm_max_ps(a, _mm_movehl_ps(a,a));
+  return pfirst<Packet4f>(_mm_max_ss(tmp, _mm_shuffle_ps(tmp,tmp, 1)));
+}
+template<> EIGEN_STRONG_INLINE double predux_max<Packet2d>(const Packet2d& a)
+{
+  return pfirst<Packet2d>(_mm_max_sd(a, _mm_unpackhi_pd(a,a)));
+}
+template<> EIGEN_STRONG_INLINE int predux_max<Packet4i>(const Packet4i& a)
+{
+#ifdef EIGEN_VECTORIZE_SSE4_1
+  Packet4i tmp = _mm_max_epi32(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(0,0,3,2)));
+  return pfirst<Packet4i>(_mm_max_epi32(tmp,_mm_shuffle_epi32(tmp, 1)));
+#else
+  // after some experiments, it is seems this is the fastest way to implement it
+  // for GCC (eg., it does not like using std::min after the pstore !!)
+  EIGEN_ALIGN16 int aux[4];
+  pstore(aux, a);
+  int aux0 = aux[0]>aux[1] ? aux[0] : aux[1];
+  int aux2 = aux[2]>aux[3] ? aux[2] : aux[3];
+  return aux0>aux2 ? aux0 : aux2;
+#endif // EIGEN_VECTORIZE_SSE4_1
+}
+
+#if EIGEN_COMP_GNUC && !(EIGEN_COMP_LCC_E2K)
+// template <> EIGEN_STRONG_INLINE Packet4f pmadd(const Packet4f&  a, const Packet4f&  b, const Packet4f&  c)
+// {
+//   Packet4f res = b;
+//   asm("mulps %[a], %[b] \n\taddps %[c], %[b]" : [b] "+x" (res) : [a] "x" (a), [c] "x" (c));
+//   return res;
+// }
+// EIGEN_STRONG_INLINE Packet4i _mm_alignr_epi8(const Packet4i&  a, const Packet4i&  b, const int i)
+// {
+//   Packet4i res = a;
+//   asm("palignr %[i], %[a], %[b] " : [b] "+x" (res) : [a] "x" (a), [i] "i" (i));
+//   return res;
+// }
+#endif
+
+#ifdef EIGEN_VECTORIZE_SSSE3
+// SSSE3 versions
+template<int Offset>
+struct palign_impl<Offset,Packet4f>
+{
+  static EIGEN_STRONG_INLINE void run(Packet4f& first, const Packet4f& second)
+  {
+    if (Offset!=0)
+      first = _mm_castsi128_ps(_mm_alignr_epi8(_mm_castps_si128(second), _mm_castps_si128(first), Offset*4));
+  }
+};
+
+template<int Offset>
+struct palign_impl<Offset,Packet4i>
+{
+  static EIGEN_STRONG_INLINE void run(Packet4i& first, const Packet4i& second)
+  {
+    if (Offset!=0)
+      first = _mm_alignr_epi8(second,first, Offset*4);
+  }
+};
+
+template<int Offset>
+struct palign_impl<Offset,Packet2d>
+{
+  static EIGEN_STRONG_INLINE void run(Packet2d& first, const Packet2d& second)
+  {
+    if (Offset==1)
+      first = _mm_castsi128_pd(_mm_alignr_epi8(_mm_castpd_si128(second), _mm_castpd_si128(first), 8));
+  }
+};
+#else
+// SSE2 versions
+template<int Offset>
+struct palign_impl<Offset,Packet4f>
+{
+  static EIGEN_STRONG_INLINE void run(Packet4f& first, const Packet4f& second)
+  {
+    if (Offset==1)
+    {
+      first = _mm_move_ss(first,second);
+      first = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(first),0x39));
+    }
+    else if (Offset==2)
+    {
+      first = _mm_movehl_ps(first,first);
+      first = _mm_movelh_ps(first,second);
+    }
+    else if (Offset==3)
+    {
+      first = _mm_move_ss(first,second);
+      first = _mm_shuffle_ps(first,second,0x93);
+    }
+  }
+};
+
+template<int Offset>
+struct palign_impl<Offset,Packet4i>
+{
+  static EIGEN_STRONG_INLINE void run(Packet4i& first, const Packet4i& second)
+  {
+    if (Offset==1)
+    {
+      first = _mm_castps_si128(_mm_move_ss(_mm_castsi128_ps(first),_mm_castsi128_ps(second)));
+      first = _mm_shuffle_epi32(first,0x39);
+    }
+    else if (Offset==2)
+    {
+      first = _mm_castps_si128(_mm_movehl_ps(_mm_castsi128_ps(first),_mm_castsi128_ps(first)));
+      first = _mm_castps_si128(_mm_movelh_ps(_mm_castsi128_ps(first),_mm_castsi128_ps(second)));
+    }
+    else if (Offset==3)
+    {
+      first = _mm_castps_si128(_mm_move_ss(_mm_castsi128_ps(first),_mm_castsi128_ps(second)));
+      first = _mm_castps_si128(_mm_shuffle_ps(_mm_castsi128_ps(first),_mm_castsi128_ps(second),0x93));
+    }
+  }
+};
+
+template<int Offset>
+struct palign_impl<Offset,Packet2d>
+{
+  static EIGEN_STRONG_INLINE void run(Packet2d& first, const Packet2d& second)
+  {
+    if (Offset==1)
+    {
+      first = _mm_castps_pd(_mm_movehl_ps(_mm_castpd_ps(first),_mm_castpd_ps(first)));
+      first = _mm_castps_pd(_mm_movelh_ps(_mm_castpd_ps(first),_mm_castpd_ps(second)));
+    }
+  }
+};
+#endif
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet4f,4>& kernel) {
+  _MM_TRANSPOSE4_PS(kernel.packet[0], kernel.packet[1], kernel.packet[2], kernel.packet[3]);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet2d,2>& kernel) {
+  __m128d tmp = _mm_unpackhi_pd(kernel.packet[0], kernel.packet[1]);
+  kernel.packet[0] = _mm_unpacklo_pd(kernel.packet[0], kernel.packet[1]);
+  kernel.packet[1] = tmp;
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet4i,4>& kernel) {
+  __m128i T0 = _mm_unpacklo_epi32(kernel.packet[0], kernel.packet[1]);
+  __m128i T1 = _mm_unpacklo_epi32(kernel.packet[2], kernel.packet[3]);
+  __m128i T2 = _mm_unpackhi_epi32(kernel.packet[0], kernel.packet[1]);
+  __m128i T3 = _mm_unpackhi_epi32(kernel.packet[2], kernel.packet[3]);
+
+  kernel.packet[0] = _mm_unpacklo_epi64(T0, T1);
+  kernel.packet[1] = _mm_unpackhi_epi64(T0, T1);
+  kernel.packet[2] = _mm_unpacklo_epi64(T2, T3);
+  kernel.packet[3] = _mm_unpackhi_epi64(T2, T3);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pblend(const Selector<4>& ifPacket, const Packet4i& thenPacket, const Packet4i& elsePacket) {
+  const __m128i zero = _mm_setzero_si128();
+  const __m128i select = _mm_set_epi32(ifPacket.select[3], ifPacket.select[2], ifPacket.select[1], ifPacket.select[0]);
+  __m128i false_mask = _mm_cmpeq_epi32(select, zero);
+#ifdef EIGEN_VECTORIZE_SSE4_1
+  return _mm_blendv_epi8(thenPacket, elsePacket, false_mask);
+#else
+  return _mm_or_si128(_mm_andnot_si128(false_mask, thenPacket), _mm_and_si128(false_mask, elsePacket));
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet4f pblend(const Selector<4>& ifPacket, const Packet4f& thenPacket, const Packet4f& elsePacket) {
+  const __m128 zero = _mm_setzero_ps();
+  const __m128 select = _mm_set_ps(ifPacket.select[3], ifPacket.select[2], ifPacket.select[1], ifPacket.select[0]);
+  __m128 false_mask = _mm_cmpeq_ps(select, zero);
+#ifdef EIGEN_VECTORIZE_SSE4_1
+  return _mm_blendv_ps(thenPacket, elsePacket, false_mask);
+#else
+  return _mm_or_ps(_mm_andnot_ps(false_mask, thenPacket), _mm_and_ps(false_mask, elsePacket));
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet2d pblend(const Selector<2>& ifPacket, const Packet2d& thenPacket, const Packet2d& elsePacket) {
+  const __m128d zero = _mm_setzero_pd();
+  const __m128d select = _mm_set_pd(ifPacket.select[1], ifPacket.select[0]);
+  __m128d false_mask = _mm_cmpeq_pd(select, zero);
+#ifdef EIGEN_VECTORIZE_SSE4_1
+  return _mm_blendv_pd(thenPacket, elsePacket, false_mask);
+#else
+  return _mm_or_pd(_mm_andnot_pd(false_mask, thenPacket), _mm_and_pd(false_mask, elsePacket));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pinsertfirst(const Packet4f& a, float b)
+{
+#ifdef EIGEN_VECTORIZE_SSE4_1
+  return _mm_blend_ps(a,pset1<Packet4f>(b),1);
+#else
+  return _mm_move_ss(a, _mm_load_ss(&b));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pinsertfirst(const Packet2d& a, double b)
+{
+#ifdef EIGEN_VECTORIZE_SSE4_1
+  return _mm_blend_pd(a,pset1<Packet2d>(b),1);
+#else
+  return _mm_move_sd(a, _mm_load_sd(&b));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pinsertlast(const Packet4f& a, float b)
+{
+#ifdef EIGEN_VECTORIZE_SSE4_1
+  return _mm_blend_ps(a,pset1<Packet4f>(b),(1<<3));
+#else
+  const Packet4f mask = _mm_castsi128_ps(_mm_setr_epi32(0x0,0x0,0x0,0xFFFFFFFF));
+  return _mm_or_ps(_mm_andnot_ps(mask, a), _mm_and_ps(mask, pset1<Packet4f>(b)));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pinsertlast(const Packet2d& a, double b)
+{
+#ifdef EIGEN_VECTORIZE_SSE4_1
+  return _mm_blend_pd(a,pset1<Packet2d>(b),(1<<1));
+#else
+  const Packet2d mask = _mm_castsi128_pd(_mm_setr_epi32(0x0,0x0,0xFFFFFFFF,0xFFFFFFFF));
+  return _mm_or_pd(_mm_andnot_pd(mask, a), _mm_and_pd(mask, pset1<Packet2d>(b)));
+#endif
+}
+
+// Scalar path for pmadd with FMA to ensure consistency with vectorized path.
+#ifdef __FMA__
+template<> EIGEN_STRONG_INLINE float pmadd(const float& a, const float& b, const float& c) {
+  return ::fmaf(a,b,c);
+}
+template<> EIGEN_STRONG_INLINE double pmadd(const double& a, const double& b, const double& c) {
+  return ::fma(a,b,c);
+}
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_PACKET_MATH_SSE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/SSE/TypeCasting.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/SSE/TypeCasting.h
new file mode 100644
index 00000000..c8489323
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/SSE/TypeCasting.h
@@ -0,0 +1,77 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TYPE_CASTING_SSE_H
+#define EIGEN_TYPE_CASTING_SSE_H
+
+namespace Eigen {
+
+namespace internal {
+
+template <>
+struct type_casting_traits<float, int> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet4i pcast<Packet4f, Packet4i>(const Packet4f& a) {
+  return _mm_cvttps_epi32(a);
+}
+
+
+template <>
+struct type_casting_traits<int, float> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet4f pcast<Packet4i, Packet4f>(const Packet4i& a) {
+  return _mm_cvtepi32_ps(a);
+}
+
+
+template <>
+struct type_casting_traits<double, float> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 2,
+    TgtCoeffRatio = 1
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet4f pcast<Packet2d, Packet4f>(const Packet2d& a, const Packet2d& b) {
+  return _mm_shuffle_ps(_mm_cvtpd_ps(a), _mm_cvtpd_ps(b), (1 << 2) | (1 << 6));
+}
+
+template <>
+struct type_casting_traits<float, double> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 2
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet2d pcast<Packet4f, Packet2d>(const Packet4f& a) {
+  // Simply discard the second half of the input
+  return _mm_cvtps_pd(a);
+}
+
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TYPE_CASTING_SSE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/ZVector/Complex.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/ZVector/Complex.h
new file mode 100644
index 00000000..1bfb7339
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/ZVector/Complex.h
@@ -0,0 +1,397 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2016 Konstantinos Margaritis <markos@freevec.org>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLEX32_ALTIVEC_H
+#define EIGEN_COMPLEX32_ALTIVEC_H
+
+namespace Eigen {
+
+namespace internal {
+
+static Packet2ul  p2ul_CONJ_XOR1 = (Packet2ul) vec_sld((Packet4ui) p2d_ZERO_, (Packet4ui) p2l_ZERO, 8);//{ 0x8000000000000000, 0x0000000000000000 };
+static Packet2ul  p2ul_CONJ_XOR2 = (Packet2ul) vec_sld((Packet4ui) p2l_ZERO,  (Packet4ui) p2d_ZERO_, 8);//{ 0x8000000000000000, 0x0000000000000000 };
+
+struct Packet1cd
+{
+  EIGEN_STRONG_INLINE Packet1cd() {}
+  EIGEN_STRONG_INLINE explicit Packet1cd(const Packet2d& a) : v(a) {}
+  Packet2d v;
+};
+
+struct Packet2cf
+{
+  EIGEN_STRONG_INLINE Packet2cf() {}
+  EIGEN_STRONG_INLINE explicit Packet2cf(const Packet4f& a) : v(a) {}
+  union {
+    Packet4f v;
+    Packet1cd cd[2];
+  };
+};
+
+template<> struct packet_traits<std::complex<float> >  : default_packet_traits
+{
+  typedef Packet2cf type;
+  typedef Packet2cf half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 2,
+    HasHalfPacket = 0,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasBlend  = 1,
+    HasSetLinear = 0
+  };
+};
+
+
+template<> struct packet_traits<std::complex<double> >  : default_packet_traits
+{
+  typedef Packet1cd type;
+  typedef Packet1cd half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 1,
+    HasHalfPacket = 0,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasSetLinear = 0
+  };
+};
+
+template<> struct unpacket_traits<Packet2cf> { typedef std::complex<float>  type; enum {size=2, alignment=Aligned16}; typedef Packet2cf half; };
+template<> struct unpacket_traits<Packet1cd> { typedef std::complex<double> type; enum {size=1, alignment=Aligned16}; typedef Packet1cd half; };
+
+/* Forward declaration */
+EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet2cf,2>& kernel);
+
+template<> EIGEN_STRONG_INLINE Packet2cf pload <Packet2cf>(const std::complex<float>* from)  { EIGEN_DEBUG_ALIGNED_LOAD return Packet2cf(pload<Packet4f>((const float*)from)); }
+template<> EIGEN_STRONG_INLINE Packet1cd pload <Packet1cd>(const std::complex<double>* from) { EIGEN_DEBUG_ALIGNED_LOAD return Packet1cd(pload<Packet2d>((const double*)from)); }
+template<> EIGEN_STRONG_INLINE Packet2cf ploadu<Packet2cf>(const std::complex<float>* from)  { EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cf(ploadu<Packet4f>((const float*)from)); }
+template<> EIGEN_STRONG_INLINE Packet1cd ploadu<Packet1cd>(const std::complex<double>* from) { EIGEN_DEBUG_UNALIGNED_LOAD return Packet1cd(ploadu<Packet2d>((const double*)from)); }
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<float> >(std::complex<float> *     to, const Packet2cf& from) { EIGEN_DEBUG_ALIGNED_STORE pstore((float*)to, from.v); }
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<double> >(std::complex<double> *   to, const Packet1cd& from) { EIGEN_DEBUG_ALIGNED_STORE pstore((double*)to, from.v); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<float> >(std::complex<float> *     to, const Packet2cf& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu((float*)to, from.v); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<double> >(std::complex<double> *   to, const Packet1cd& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu((double*)to, from.v); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd pset1<Packet1cd>(const std::complex<double>&  from)
+{ /* here we really have to use unaligned loads :( */ return ploadu<Packet1cd>(&from); }
+
+template<> EIGEN_STRONG_INLINE Packet2cf pset1<Packet2cf>(const std::complex<float>&  from)
+{
+  Packet2cf res;
+  res.cd[0] = Packet1cd(vec_ld2f((const float *)&from));
+  res.cd[1] = res.cd[0];
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC inline Packet2cf pgather<std::complex<float>, Packet2cf>(const std::complex<float>* from, Index stride)
+{
+  std::complex<float> EIGEN_ALIGN16 af[2];
+  af[0] = from[0*stride];
+  af[1] = from[1*stride];
+  return pload<Packet2cf>(af);
+}
+template<> EIGEN_DEVICE_FUNC inline Packet1cd pgather<std::complex<double>, Packet1cd>(const std::complex<double>* from, Index stride EIGEN_UNUSED)
+{
+  return pload<Packet1cd>(from);
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<float>, Packet2cf>(std::complex<float>* to, const Packet2cf& from, Index stride)
+{
+  std::complex<float> EIGEN_ALIGN16 af[2];
+  pstore<std::complex<float> >((std::complex<float> *) af, from);
+  to[0*stride] = af[0];
+  to[1*stride] = af[1];
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<double>, Packet1cd>(std::complex<double>* to, const Packet1cd& from, Index stride EIGEN_UNUSED)
+{
+  pstore<std::complex<double> >(to, from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf padd<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(padd<Packet4f>(a.v, b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd padd<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(a.v + b.v); }
+template<> EIGEN_STRONG_INLINE Packet2cf psub<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(psub<Packet4f>(a.v, b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd psub<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(a.v - b.v); }
+template<> EIGEN_STRONG_INLINE Packet1cd pnegate(const Packet1cd& a) { return Packet1cd(pnegate(Packet2d(a.v))); }
+template<> EIGEN_STRONG_INLINE Packet2cf pnegate(const Packet2cf& a) { return Packet2cf(pnegate(Packet4f(a.v))); }
+template<> EIGEN_STRONG_INLINE Packet1cd pconj(const Packet1cd& a) { return Packet1cd((Packet2d)vec_xor((Packet2d)a.v, (Packet2d)p2ul_CONJ_XOR2)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pconj(const Packet2cf& a)
+{
+  Packet2cf res;
+  res.v.v4f[0] = pconj(Packet1cd(reinterpret_cast<Packet2d>(a.v.v4f[0]))).v;
+  res.v.v4f[1] = pconj(Packet1cd(reinterpret_cast<Packet2d>(a.v.v4f[1]))).v;
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd pmul<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{
+  Packet2d a_re, a_im, v1, v2;
+
+  // Permute and multiply the real parts of a and b
+  a_re = vec_perm(a.v, a.v, p16uc_PSET64_HI);
+  // Get the imaginary parts of a
+  a_im = vec_perm(a.v, a.v, p16uc_PSET64_LO);
+  // multiply a_re * b
+  v1 = vec_madd(a_re, b.v, p2d_ZERO);
+  // multiply a_im * b and get the conjugate result
+  v2 = vec_madd(a_im, b.v, p2d_ZERO);
+  v2 = (Packet2d) vec_sld((Packet4ui)v2, (Packet4ui)v2, 8);
+  v2 = (Packet2d) vec_xor((Packet2d)v2, (Packet2d) p2ul_CONJ_XOR1);
+
+  return Packet1cd(v1 + v2);
+}
+template<> EIGEN_STRONG_INLINE Packet2cf pmul<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{
+  Packet2cf res;
+  res.v.v4f[0] = pmul(Packet1cd(reinterpret_cast<Packet2d>(a.v.v4f[0])), Packet1cd(reinterpret_cast<Packet2d>(b.v.v4f[0]))).v;
+  res.v.v4f[1] = pmul(Packet1cd(reinterpret_cast<Packet2d>(a.v.v4f[1])), Packet1cd(reinterpret_cast<Packet2d>(b.v.v4f[1]))).v;
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd pand   <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(vec_and(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pand   <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(pand<Packet4f>(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd por    <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(vec_or(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf por    <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(por<Packet4f>(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd pxor   <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(vec_xor(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pxor   <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(pxor<Packet4f>(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd pandnot<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(vec_and(a.v, vec_nor(b.v,b.v))); }
+template<> EIGEN_STRONG_INLINE Packet2cf pandnot<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(pandnot<Packet4f>(a.v,b.v)); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd ploaddup<Packet1cd>(const std::complex<double>*     from) {  return pset1<Packet1cd>(*from); }
+template<> EIGEN_STRONG_INLINE Packet2cf ploaddup<Packet2cf>(const std::complex<float>*      from) {  return pset1<Packet2cf>(*from); }
+
+template<> EIGEN_STRONG_INLINE void prefetch<std::complex<float> >(const std::complex<float> *     addr) { EIGEN_ZVECTOR_PREFETCH(addr); }
+template<> EIGEN_STRONG_INLINE void prefetch<std::complex<double> >(const std::complex<double> *   addr) { EIGEN_ZVECTOR_PREFETCH(addr); }
+
+template<> EIGEN_STRONG_INLINE std::complex<double>  pfirst<Packet1cd>(const Packet1cd& a)
+{
+  std::complex<double> EIGEN_ALIGN16 res;
+  pstore<std::complex<double> >(&res, a);
+
+  return res;
+}
+template<> EIGEN_STRONG_INLINE std::complex<float>  pfirst<Packet2cf>(const Packet2cf& a)
+{
+  std::complex<float> EIGEN_ALIGN16 res[2];
+  pstore<std::complex<float> >(res, a);
+
+  return res[0];
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd preverse(const Packet1cd& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet2cf preverse(const Packet2cf& a)
+{
+  Packet2cf res;
+  res.cd[0] = a.cd[1];
+  res.cd[1] = a.cd[0];
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<double> predux<Packet1cd>(const Packet1cd& a)
+{
+  return pfirst(a);
+}
+template<> EIGEN_STRONG_INLINE std::complex<float> predux<Packet2cf>(const Packet2cf& a)
+{
+  std::complex<float> res;
+  Packet1cd b = padd<Packet1cd>(a.cd[0], a.cd[1]);
+  vec_st2f(b.v, (float*)&res);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd preduxp<Packet1cd>(const Packet1cd* vecs)
+{
+  return vecs[0];
+}
+template<> EIGEN_STRONG_INLINE Packet2cf preduxp<Packet2cf>(const Packet2cf* vecs)
+{
+  PacketBlock<Packet2cf,2> transpose;
+  transpose.packet[0] = vecs[0];
+  transpose.packet[1] = vecs[1];
+  ptranspose(transpose);
+
+  return padd<Packet2cf>(transpose.packet[0], transpose.packet[1]);
+} 
+
+template<> EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet1cd>(const Packet1cd& a)
+{
+  return pfirst(a);
+}
+template<> EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet2cf>(const Packet2cf& a)
+{
+  std::complex<float> res;
+  Packet1cd b = pmul<Packet1cd>(a.cd[0], a.cd[1]);
+  vec_st2f(b.v, (float*)&res);
+  return res;
+}
+
+template<int Offset>
+struct palign_impl<Offset,Packet1cd>
+{
+  static EIGEN_STRONG_INLINE void run(Packet1cd& /*first*/, const Packet1cd& /*second*/)
+  {
+    // FIXME is it sure we never have to align a Packet1cd?
+    // Even though a std::complex<double> has 16 bytes, it is not necessarily aligned on a 16 bytes boundary...
+  }
+};
+
+template<int Offset>
+struct palign_impl<Offset,Packet2cf>
+{
+  static EIGEN_STRONG_INLINE void run(Packet2cf& first, const Packet2cf& second)
+  {
+    if (Offset == 1) {
+      first.cd[0] = first.cd[1];
+      first.cd[1] = second.cd[0];
+    }
+  }
+};
+
+template<> struct conj_helper<Packet1cd, Packet1cd, false,true>
+{
+  EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd& y, const Packet1cd& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& b) const
+  {
+    return internal::pmul(a, pconj(b));
+  }
+};
+
+template<> struct conj_helper<Packet1cd, Packet1cd, true,false>
+{
+  EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd& y, const Packet1cd& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& b) const
+  {
+    return internal::pmul(pconj(a), b);
+  }
+};
+
+template<> struct conj_helper<Packet1cd, Packet1cd, true,true>
+{
+  EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd& y, const Packet1cd& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& b) const
+  {
+    return pconj(internal::pmul(a, b));
+  }
+};
+
+template<> struct conj_helper<Packet2cf, Packet2cf, false,true>
+{
+  EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf& y, const Packet2cf& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& b) const
+  {
+    return internal::pmul(a, pconj(b));
+  }
+};
+
+template<> struct conj_helper<Packet2cf, Packet2cf, true,false>
+{
+  EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf& y, const Packet2cf& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& b) const
+  {
+    return internal::pmul(pconj(a), b);
+  }
+};
+
+template<> struct conj_helper<Packet2cf, Packet2cf, true,true>
+{
+  EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf& y, const Packet2cf& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& b) const
+  {
+    return pconj(internal::pmul(a, b));
+  }
+};
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet2cf,Packet4f)
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet1cd,Packet2d)
+
+template<> EIGEN_STRONG_INLINE Packet1cd pdiv<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{
+  // TODO optimize it for AltiVec
+  Packet1cd res = conj_helper<Packet1cd,Packet1cd,false,true>().pmul(a,b);
+  Packet2d s = vec_madd(b.v, b.v, p2d_ZERO_);
+  return Packet1cd(pdiv(res.v, s + vec_perm(s, s, p16uc_REVERSE64)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pdiv<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{
+  // TODO optimize it for AltiVec
+  Packet2cf res;
+  res.cd[0] = pdiv<Packet1cd>(a.cd[0], b.cd[0]);
+  res.cd[1] = pdiv<Packet1cd>(a.cd[1], b.cd[1]);
+  return res;
+}
+
+EIGEN_STRONG_INLINE Packet1cd pcplxflip/*<Packet1cd>*/(const Packet1cd& x)
+{
+  return Packet1cd(preverse(Packet2d(x.v)));
+}
+
+EIGEN_STRONG_INLINE Packet2cf pcplxflip/*<Packet2cf>*/(const Packet2cf& x)
+{
+  Packet2cf res;
+  res.cd[0] = pcplxflip(x.cd[0]);
+  res.cd[1] = pcplxflip(x.cd[1]);
+  return res;
+}
+
+EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet1cd,2>& kernel)
+{
+  Packet2d tmp = vec_perm(kernel.packet[0].v, kernel.packet[1].v, p16uc_TRANSPOSE64_HI);
+  kernel.packet[1].v = vec_perm(kernel.packet[0].v, kernel.packet[1].v, p16uc_TRANSPOSE64_LO);
+  kernel.packet[0].v = tmp;
+}
+
+EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet2cf,2>& kernel)
+{
+  Packet1cd tmp = kernel.packet[0].cd[1];
+  kernel.packet[0].cd[1] = kernel.packet[1].cd[0];
+  kernel.packet[1].cd[0] = tmp;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pblend(const Selector<2>& ifPacket, const Packet2cf& thenPacket, const Packet2cf& elsePacket) {
+  Packet2cf result;
+  const Selector<4> ifPacket4 = { ifPacket.select[0], ifPacket.select[0], ifPacket.select[1], ifPacket.select[1] };
+  result.v = pblend<Packet4f>(ifPacket4, thenPacket.v, elsePacket.v);
+  return result;
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_COMPLEX32_ALTIVEC_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/ZVector/MathFunctions.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/ZVector/MathFunctions.h
new file mode 100644
index 00000000..5c7aa725
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/ZVector/MathFunctions.h
@@ -0,0 +1,137 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007 Julien Pommier
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2016 Konstantinos Margaritis <markos@freevec.org>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* The sin, cos, exp, and log functions of this file come from
+ * Julien Pommier's sse math library: http://gruntthepeon.free.fr/ssemath/
+ */
+
+#ifndef EIGEN_MATH_FUNCTIONS_ALTIVEC_H
+#define EIGEN_MATH_FUNCTIONS_ALTIVEC_H
+
+namespace Eigen {
+
+namespace internal {
+
+static _EIGEN_DECLARE_CONST_Packet2d(1 , 1.0);
+static _EIGEN_DECLARE_CONST_Packet2d(2 , 2.0);
+static _EIGEN_DECLARE_CONST_Packet2d(half, 0.5);
+
+static _EIGEN_DECLARE_CONST_Packet2d(exp_hi,  709.437);
+static _EIGEN_DECLARE_CONST_Packet2d(exp_lo, -709.436139303);
+
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_LOG2EF, 1.4426950408889634073599);
+
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_p0, 1.26177193074810590878e-4);
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_p1, 3.02994407707441961300e-2);
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_p2, 9.99999999999999999910e-1);
+
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q0, 3.00198505138664455042e-6);
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q1, 2.52448340349684104192e-3);
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q2, 2.27265548208155028766e-1);
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q3, 2.00000000000000000009e0);
+
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_C1, 0.693145751953125);
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_C2, 1.42860682030941723212e-6);
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d pexp<Packet2d>(const Packet2d& _x)
+{
+  Packet2d x = _x;
+
+  Packet2d tmp, fx;
+  Packet2l emm0;
+
+  // clamp x
+  x = pmax(pmin(x, p2d_exp_hi), p2d_exp_lo);
+  /* express exp(x) as exp(g + n*log(2)) */
+  fx = pmadd(p2d_cephes_LOG2EF, x, p2d_half);
+
+  fx = vec_floor(fx);
+
+  tmp = pmul(fx, p2d_cephes_exp_C1);
+  Packet2d z = pmul(fx, p2d_cephes_exp_C2);
+  x = psub(x, tmp);
+  x = psub(x, z);
+
+  Packet2d x2 = pmul(x,x);
+
+  Packet2d px = p2d_cephes_exp_p0;
+  px = pmadd(px, x2, p2d_cephes_exp_p1);
+  px = pmadd(px, x2, p2d_cephes_exp_p2);
+  px = pmul (px, x);
+
+  Packet2d qx = p2d_cephes_exp_q0;
+  qx = pmadd(qx, x2, p2d_cephes_exp_q1);
+  qx = pmadd(qx, x2, p2d_cephes_exp_q2);
+  qx = pmadd(qx, x2, p2d_cephes_exp_q3);
+
+  x = pdiv(px,psub(qx,px));
+  x = pmadd(p2d_2,x,p2d_1);
+
+  // build 2^n
+  emm0 = vec_ctsl(fx, 0);
+
+  static const Packet2l p2l_1023 = { 1023, 1023 };
+  static const Packet2ul p2ul_52 = { 52, 52 };
+
+  emm0 = emm0 + p2l_1023;
+  emm0 = emm0 << reinterpret_cast<Packet2l>(p2ul_52);
+
+  // Altivec's max & min operators just drop silent NaNs. Check NaNs in 
+  // inputs and return them unmodified.
+  Packet2ul isnumber_mask = reinterpret_cast<Packet2ul>(vec_cmpeq(_x, _x));
+  return vec_sel(_x, pmax(pmul(x, reinterpret_cast<Packet2d>(emm0)), _x),
+                 isnumber_mask);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f pexp<Packet4f>(const Packet4f& x)
+{
+  Packet4f res;
+  res.v4f[0] = pexp<Packet2d>(x.v4f[0]);
+  res.v4f[1] = pexp<Packet2d>(x.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d psqrt<Packet2d>(const Packet2d& x)
+{
+  return  __builtin_s390_vfsqdb(x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f psqrt<Packet4f>(const Packet4f& x)
+{
+  Packet4f res;
+  res.v4f[0] = psqrt<Packet2d>(x.v4f[0]);
+  res.v4f[1] = psqrt<Packet2d>(x.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d prsqrt<Packet2d>(const Packet2d& x) {
+  // Unfortunately we can't use the much faster mm_rqsrt_pd since it only provides an approximation.
+  return pset1<Packet2d>(1.0) / psqrt<Packet2d>(x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f prsqrt<Packet4f>(const Packet4f& x) {
+  Packet4f res;
+  res.v4f[0] = prsqrt<Packet2d>(x.v4f[0]);
+  res.v4f[1] = prsqrt<Packet2d>(x.v4f[1]);
+  return res;
+}
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_MATH_FUNCTIONS_ALTIVEC_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/ZVector/PacketMath.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/ZVector/PacketMath.h
new file mode 100644
index 00000000..57b01fc6
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/arch/ZVector/PacketMath.h
@@ -0,0 +1,945 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Konstantinos Margaritis <markos@freevec.org>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PACKET_MATH_ZVECTOR_H
+#define EIGEN_PACKET_MATH_ZVECTOR_H
+
+#include <stdint.h>
+
+namespace Eigen {
+
+namespace internal {
+
+#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
+#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 4
+#endif
+
+#ifndef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#define EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#endif
+
+#ifndef EIGEN_HAS_SINGLE_INSTRUCTION_CJMADD
+#define EIGEN_HAS_SINGLE_INSTRUCTION_CJMADD
+#endif
+
+#ifndef EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS
+#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS  16
+#endif
+
+typedef __vector int                 Packet4i;
+typedef __vector unsigned int        Packet4ui;
+typedef __vector __bool int          Packet4bi;
+typedef __vector short int           Packet8i;
+typedef __vector unsigned char       Packet16uc;
+typedef __vector double              Packet2d;
+typedef __vector unsigned long long  Packet2ul;
+typedef __vector long long           Packet2l;
+
+typedef struct {
+	Packet2d  v4f[2];
+} Packet4f;
+
+typedef union {
+  int32_t   i[4];
+  uint32_t ui[4];
+  int64_t   l[2];
+  uint64_t ul[2];
+  double    d[2];
+  Packet4i  v4i;
+  Packet4ui v4ui;
+  Packet2l  v2l;
+  Packet2ul v2ul;
+  Packet2d  v2d;
+} Packet;
+
+// We don't want to write the same code all the time, but we need to reuse the constants
+// and it doesn't really work to declare them global, so we define macros instead
+
+#define _EIGEN_DECLARE_CONST_FAST_Packet4i(NAME,X) \
+  Packet4i p4i_##NAME = reinterpret_cast<Packet4i>(vec_splat_s32(X))
+
+#define _EIGEN_DECLARE_CONST_FAST_Packet2d(NAME,X) \
+  Packet2d p2d_##NAME = reinterpret_cast<Packet2d>(vec_splat_s64(X))
+
+#define _EIGEN_DECLARE_CONST_FAST_Packet2l(NAME,X) \
+  Packet2l p2l_##NAME = reinterpret_cast<Packet2l>(vec_splat_s64(X))
+
+#define _EIGEN_DECLARE_CONST_Packet4i(NAME,X) \
+  Packet4i p4i_##NAME = pset1<Packet4i>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet2d(NAME,X) \
+  Packet2d p2d_##NAME = pset1<Packet2d>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet2l(NAME,X) \
+  Packet2l p2l_##NAME = pset1<Packet2l>(X)
+
+// These constants are endian-agnostic
+//static _EIGEN_DECLARE_CONST_FAST_Packet4i(ZERO, 0); //{ 0, 0, 0, 0,}
+static _EIGEN_DECLARE_CONST_FAST_Packet4i(ONE, 1); //{ 1, 1, 1, 1}
+
+static _EIGEN_DECLARE_CONST_FAST_Packet2d(ZERO, 0);
+static _EIGEN_DECLARE_CONST_FAST_Packet2l(ZERO, 0);
+static _EIGEN_DECLARE_CONST_FAST_Packet2l(ONE, 1);
+
+static Packet2d p2d_ONE = { 1.0, 1.0 }; 
+static Packet2d p2d_ZERO_ = { -0.0, -0.0 };
+
+static Packet4i p4i_COUNTDOWN = { 0, 1, 2, 3 };
+static Packet4f p4f_COUNTDOWN = { 0.0, 1.0, 2.0, 3.0 };
+static Packet2d p2d_COUNTDOWN = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet16uc>(p2d_ZERO), reinterpret_cast<Packet16uc>(p2d_ONE), 8));
+
+static Packet16uc p16uc_PSET64_HI = { 0,1,2,3, 4,5,6,7, 0,1,2,3, 4,5,6,7 };
+static Packet16uc p16uc_DUPLICATE32_HI = { 0,1,2,3, 0,1,2,3, 4,5,6,7, 4,5,6,7 };
+
+// Mask alignment
+#define _EIGEN_MASK_ALIGNMENT	0xfffffffffffffff0
+
+#define _EIGEN_ALIGNED_PTR(x)	((std::ptrdiff_t)(x) & _EIGEN_MASK_ALIGNMENT)
+
+// Handle endianness properly while loading constants
+// Define global static constants:
+
+static Packet16uc p16uc_FORWARD =   { 0,1,2,3, 4,5,6,7, 8,9,10,11, 12,13,14,15 };
+static Packet16uc p16uc_REVERSE32 = { 12,13,14,15, 8,9,10,11, 4,5,6,7, 0,1,2,3 };
+static Packet16uc p16uc_REVERSE64 = { 8,9,10,11, 12,13,14,15, 0,1,2,3, 4,5,6,7 };
+
+static Packet16uc p16uc_PSET32_WODD   = vec_sld((Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 0), (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 2), 8);//{ 0,1,2,3, 0,1,2,3, 8,9,10,11, 8,9,10,11 };
+static Packet16uc p16uc_PSET32_WEVEN  = vec_sld(p16uc_DUPLICATE32_HI, (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 3), 8);//{ 4,5,6,7, 4,5,6,7, 12,13,14,15, 12,13,14,15 };
+/*static Packet16uc p16uc_HALF64_0_16 = vec_sld((Packet16uc)p4i_ZERO, vec_splat((Packet16uc) vec_abs(p4i_MINUS16), 3), 8);      //{ 0,0,0,0, 0,0,0,0, 16,16,16,16, 16,16,16,16};
+
+static Packet16uc p16uc_PSET64_HI = (Packet16uc) vec_mergeh((Packet4ui)p16uc_PSET32_WODD, (Packet4ui)p16uc_PSET32_WEVEN);     //{ 0,1,2,3, 4,5,6,7, 0,1,2,3, 4,5,6,7 };*/
+static Packet16uc p16uc_PSET64_LO = (Packet16uc) vec_mergel((Packet4ui)p16uc_PSET32_WODD, (Packet4ui)p16uc_PSET32_WEVEN);     //{ 8,9,10,11, 12,13,14,15, 8,9,10,11, 12,13,14,15 };
+/*static Packet16uc p16uc_TRANSPOSE64_HI = vec_add(p16uc_PSET64_HI, p16uc_HALF64_0_16);                                         //{ 0,1,2,3, 4,5,6,7, 16,17,18,19, 20,21,22,23};
+static Packet16uc p16uc_TRANSPOSE64_LO = vec_add(p16uc_PSET64_LO, p16uc_HALF64_0_16);                                         //{ 8,9,10,11, 12,13,14,15, 24,25,26,27, 28,29,30,31};*/
+static Packet16uc p16uc_TRANSPOSE64_HI = { 0,1,2,3, 4,5,6,7, 16,17,18,19, 20,21,22,23};
+static Packet16uc p16uc_TRANSPOSE64_LO = { 8,9,10,11, 12,13,14,15, 24,25,26,27, 28,29,30,31};
+
+//static Packet16uc p16uc_COMPLEX32_REV = vec_sld(p16uc_REVERSE32, p16uc_REVERSE32, 8);                                         //{ 4,5,6,7, 0,1,2,3, 12,13,14,15, 8,9,10,11 };
+
+//static Packet16uc p16uc_COMPLEX32_REV2 = vec_sld(p16uc_FORWARD, p16uc_FORWARD, 8);                                            //{ 8,9,10,11, 12,13,14,15, 0,1,2,3, 4,5,6,7 };
+
+
+#if EIGEN_HAS_BUILTIN(__builtin_prefetch) || EIGEN_COMP_GNUC
+  #define EIGEN_ZVECTOR_PREFETCH(ADDR) __builtin_prefetch(ADDR);
+#else
+  #define EIGEN_ZVECTOR_PREFETCH(ADDR) asm( "   pfd [%[addr]]\n" :: [addr] "r" (ADDR) : "cc" );
+#endif
+
+template<> struct packet_traits<int>    : default_packet_traits
+{
+  typedef Packet4i type;
+  typedef Packet4i half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket = 0,
+
+    HasAdd  = 1,
+    HasSub  = 1,
+    HasMul  = 1,
+    HasDiv  = 1,
+    HasBlend = 1
+  };
+};
+
+template<> struct packet_traits<float> : default_packet_traits
+{
+  typedef Packet4f type;
+  typedef Packet4f half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=4,
+    HasHalfPacket = 0,
+
+    HasAdd  = 1,
+    HasSub  = 1,
+    HasMul  = 1,
+    HasDiv  = 1,
+    HasMin  = 1,
+    HasMax  = 1,
+    HasAbs  = 1,
+    HasSin  = 0,
+    HasCos  = 0,
+    HasLog  = 0,
+    HasExp  = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasNegate = 1,
+    HasBlend = 1
+  };
+};
+
+template<> struct packet_traits<double> : default_packet_traits
+{
+  typedef Packet2d type;
+  typedef Packet2d half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=2,
+    HasHalfPacket = 1,
+
+    HasAdd  = 1,
+    HasSub  = 1,
+    HasMul  = 1,
+    HasDiv  = 1,
+    HasMin  = 1,
+    HasMax  = 1,
+    HasAbs  = 1,
+    HasSin  = 0,
+    HasCos  = 0,
+    HasLog  = 0,
+    HasExp  = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasNegate = 1,
+    HasBlend = 1
+  };
+};
+
+template<> struct unpacket_traits<Packet4i> { typedef int    type; enum {size=4, alignment=Aligned16}; typedef Packet4i half; };
+template<> struct unpacket_traits<Packet4f> { typedef float  type; enum {size=4, alignment=Aligned16}; typedef Packet4f half; };
+template<> struct unpacket_traits<Packet2d> { typedef double type; enum {size=2, alignment=Aligned16}; typedef Packet2d half; };
+
+/* Forward declaration */
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet4f,4>& kernel);
+ 
+inline std::ostream & operator <<(std::ostream & s, const Packet4i & v)
+{
+  Packet vt;
+  vt.v4i = v;
+  s << vt.i[0] << ", " << vt.i[1] << ", " << vt.i[2] << ", " << vt.i[3];
+  return s;
+}
+
+inline std::ostream & operator <<(std::ostream & s, const Packet4ui & v)
+{
+  Packet vt;
+  vt.v4ui = v;
+  s << vt.ui[0] << ", " << vt.ui[1] << ", " << vt.ui[2] << ", " << vt.ui[3];
+  return s;
+}
+
+inline std::ostream & operator <<(std::ostream & s, const Packet2l & v)
+{
+  Packet vt;
+  vt.v2l = v;
+  s << vt.l[0] << ", " << vt.l[1];
+  return s;
+}
+
+inline std::ostream & operator <<(std::ostream & s, const Packet2ul & v)
+{
+  Packet vt;
+  vt.v2ul = v;
+  s << vt.ul[0] << ", " << vt.ul[1] ;
+  return s;
+}
+
+inline std::ostream & operator <<(std::ostream & s, const Packet2d & v)
+{
+  Packet vt;
+  vt.v2d = v;
+  s << vt.d[0] << ", " << vt.d[1];
+  return s;
+}
+
+/* Helper function to simulate a vec_splat_packet4f
+ */
+template<int element> EIGEN_STRONG_INLINE Packet4f vec_splat_packet4f(const Packet4f&   from)
+{
+  Packet4f splat;
+  switch (element) {
+  case 0:
+    splat.v4f[0] = vec_splat(from.v4f[0], 0);
+    splat.v4f[1] = splat.v4f[0];
+    break;
+  case 1:
+    splat.v4f[0] = vec_splat(from.v4f[0], 1);
+    splat.v4f[1] = splat.v4f[0];
+    break;
+  case 2:
+    splat.v4f[0] = vec_splat(from.v4f[1], 0);
+    splat.v4f[1] = splat.v4f[0];
+    break;
+  case 3:
+    splat.v4f[0] = vec_splat(from.v4f[1], 1);
+    splat.v4f[1] = splat.v4f[0];
+    break;
+  }
+  return splat;
+}
+
+template<int Offset>
+struct palign_impl<Offset,Packet4i>
+{
+  static EIGEN_STRONG_INLINE void run(Packet4i& first, const Packet4i& second)
+  {
+    switch (Offset % 4) {
+    case 1:
+      first = vec_sld(first, second, 4); break;
+    case 2:
+      first = vec_sld(first, second, 8); break;
+    case 3:
+      first = vec_sld(first, second, 12); break;
+    }
+  }
+};
+
+/* This is a tricky one, we have to translate float alignment to vector elements of sizeof double
+ */
+template<int Offset>
+struct palign_impl<Offset,Packet4f>
+{
+  static EIGEN_STRONG_INLINE void run(Packet4f& first, const Packet4f& second)
+  {
+    switch (Offset % 4) {
+    case 1:
+      first.v4f[0] = vec_sld(first.v4f[0], first.v4f[1], 8);
+      first.v4f[1] = vec_sld(first.v4f[1], second.v4f[0], 8);
+      break;
+    case 2:
+      first.v4f[0] = first.v4f[1];
+      first.v4f[1] = second.v4f[0];
+      break;
+    case 3:
+      first.v4f[0] = vec_sld(first.v4f[1],  second.v4f[0], 8);
+      first.v4f[1] = vec_sld(second.v4f[0], second.v4f[1], 8);
+      break;
+    }
+  }
+};
+
+
+template<int Offset>
+struct palign_impl<Offset,Packet2d>
+{
+  static EIGEN_STRONG_INLINE void run(Packet2d& first, const Packet2d& second)
+  {
+    if (Offset == 1)
+      first = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4i>(first), reinterpret_cast<Packet4i>(second), 8));
+  }
+};
+
+template<> EIGEN_STRONG_INLINE Packet4i pload<Packet4i>(const int*     from)
+{
+  // FIXME: No intrinsic yet
+  EIGEN_DEBUG_ALIGNED_LOAD
+  Packet *vfrom;
+  vfrom = (Packet *) from;
+  return vfrom->v4i;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pload<Packet4f>(const float*   from)
+{
+  // FIXME: No intrinsic yet
+  EIGEN_DEBUG_ALIGNED_LOAD
+  Packet4f vfrom;
+  vfrom.v4f[0] = vec_ld2f(&from[0]);
+  vfrom.v4f[1] = vec_ld2f(&from[2]);
+  return vfrom;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pload<Packet2d>(const double* from)
+{
+  // FIXME: No intrinsic yet
+  EIGEN_DEBUG_ALIGNED_LOAD
+  Packet *vfrom;
+  vfrom = (Packet *) from;
+  return vfrom->v2d;
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<int>(int*       to, const Packet4i& from)
+{
+  // FIXME: No intrinsic yet
+  EIGEN_DEBUG_ALIGNED_STORE
+  Packet *vto;
+  vto = (Packet *) to;
+  vto->v4i = from;
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<float>(float*   to, const Packet4f& from)
+{
+  // FIXME: No intrinsic yet
+  EIGEN_DEBUG_ALIGNED_STORE
+  vec_st2f(from.v4f[0], &to[0]);
+  vec_st2f(from.v4f[1], &to[2]);
+}
+
+
+template<> EIGEN_STRONG_INLINE void pstore<double>(double*   to, const Packet2d& from)
+{
+  // FIXME: No intrinsic yet
+  EIGEN_DEBUG_ALIGNED_STORE
+  Packet *vto;
+  vto = (Packet *) to;
+  vto->v2d = from;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pset1<Packet4i>(const int&    from)
+{
+  return vec_splats(from);
+}
+template<> EIGEN_STRONG_INLINE Packet2d pset1<Packet2d>(const double& from) {
+  return vec_splats(from);
+}
+template<> EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(const float&    from)
+{
+  Packet4f to;
+  to.v4f[0] = pset1<Packet2d>(static_cast<const double&>(from));
+  to.v4f[1] = to.v4f[0];
+  return to;
+}
+
+template<> EIGEN_STRONG_INLINE void
+pbroadcast4<Packet4i>(const int *a,
+                      Packet4i& a0, Packet4i& a1, Packet4i& a2, Packet4i& a3)
+{
+  a3 = pload<Packet4i>(a);
+  a0 = vec_splat(a3, 0);
+  a1 = vec_splat(a3, 1);
+  a2 = vec_splat(a3, 2);
+  a3 = vec_splat(a3, 3);
+}
+
+template<> EIGEN_STRONG_INLINE void
+pbroadcast4<Packet4f>(const float *a,
+                      Packet4f& a0, Packet4f& a1, Packet4f& a2, Packet4f& a3)
+{
+  a3 = pload<Packet4f>(a);
+  a0 = vec_splat_packet4f<0>(a3);
+  a1 = vec_splat_packet4f<1>(a3);
+  a2 = vec_splat_packet4f<2>(a3);
+  a3 = vec_splat_packet4f<3>(a3);
+}
+
+template<> EIGEN_STRONG_INLINE void
+pbroadcast4<Packet2d>(const double *a,
+                      Packet2d& a0, Packet2d& a1, Packet2d& a2, Packet2d& a3)
+{
+  a1 = pload<Packet2d>(a);
+  a0 = vec_splat(a1, 0);
+  a1 = vec_splat(a1, 1);
+  a3 = pload<Packet2d>(a+2);
+  a2 = vec_splat(a3, 0);
+  a3 = vec_splat(a3, 1);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet4i pgather<int, Packet4i>(const int* from, Index stride)
+{
+  int EIGEN_ALIGN16 ai[4];
+  ai[0] = from[0*stride];
+  ai[1] = from[1*stride];
+  ai[2] = from[2*stride];
+  ai[3] = from[3*stride];
+ return pload<Packet4i>(ai);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet4f pgather<float, Packet4f>(const float* from, Index stride)
+{
+  float EIGEN_ALIGN16 ai[4];
+  ai[0] = from[0*stride];
+  ai[1] = from[1*stride];
+  ai[2] = from[2*stride];
+  ai[3] = from[3*stride];
+ return pload<Packet4f>(ai);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet2d pgather<double, Packet2d>(const double* from, Index stride)
+{
+  double EIGEN_ALIGN16 af[2];
+  af[0] = from[0*stride];
+  af[1] = from[1*stride];
+ return pload<Packet2d>(af);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<int, Packet4i>(int* to, const Packet4i& from, Index stride)
+{
+  int EIGEN_ALIGN16 ai[4];
+  pstore<int>((int *)ai, from);
+  to[0*stride] = ai[0];
+  to[1*stride] = ai[1];
+  to[2*stride] = ai[2];
+  to[3*stride] = ai[3];
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<float, Packet4f>(float* to, const Packet4f& from, Index stride)
+{
+  float EIGEN_ALIGN16 ai[4];
+  pstore<float>((float *)ai, from);
+  to[0*stride] = ai[0];
+  to[1*stride] = ai[1];
+  to[2*stride] = ai[2];
+  to[3*stride] = ai[3];
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<double, Packet2d>(double* to, const Packet2d& from, Index stride)
+{
+  double EIGEN_ALIGN16 af[2];
+  pstore<double>(af, from);
+  to[0*stride] = af[0];
+  to[1*stride] = af[1];
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i padd<Packet4i>(const Packet4i& a, const Packet4i& b) { return (a + b); }
+template<> EIGEN_STRONG_INLINE Packet4f padd<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f c;
+  c.v4f[0] = a.v4f[0] + b.v4f[0];
+  c.v4f[1] = a.v4f[1] + b.v4f[1];
+  return c;
+}
+template<> EIGEN_STRONG_INLINE Packet2d padd<Packet2d>(const Packet2d& a, const Packet2d& b) { return (a + b); }
+
+template<> EIGEN_STRONG_INLINE Packet4i psub<Packet4i>(const Packet4i& a, const Packet4i& b) { return (a - b); }
+template<> EIGEN_STRONG_INLINE Packet4f psub<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f c;
+  c.v4f[0] = a.v4f[0] - b.v4f[0];
+  c.v4f[1] = a.v4f[1] - b.v4f[1];
+  return c;
+}
+template<> EIGEN_STRONG_INLINE Packet2d psub<Packet2d>(const Packet2d& a, const Packet2d& b) { return (a - b); }
+
+template<> EIGEN_STRONG_INLINE Packet4i pmul<Packet4i>(const Packet4i& a, const Packet4i& b) { return (a * b); }
+template<> EIGEN_STRONG_INLINE Packet4f pmul<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f c;
+  c.v4f[0] = a.v4f[0] * b.v4f[0];
+  c.v4f[1] = a.v4f[1] * b.v4f[1];
+  return c;
+}
+template<> EIGEN_STRONG_INLINE Packet2d pmul<Packet2d>(const Packet2d& a, const Packet2d& b) { return (a * b); }
+
+template<> EIGEN_STRONG_INLINE Packet4i pdiv<Packet4i>(const Packet4i& a, const Packet4i& b) { return (a / b); }
+template<> EIGEN_STRONG_INLINE Packet4f pdiv<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f c;
+  c.v4f[0] = a.v4f[0] / b.v4f[0];
+  c.v4f[1] = a.v4f[1] / b.v4f[1];
+  return c;
+}
+template<> EIGEN_STRONG_INLINE Packet2d pdiv<Packet2d>(const Packet2d& a, const Packet2d& b) { return (a / b); }
+
+template<> EIGEN_STRONG_INLINE Packet4i pnegate(const Packet4i& a) { return (-a); }
+template<> EIGEN_STRONG_INLINE Packet4f pnegate(const Packet4f& a)
+{
+  Packet4f c;
+  c.v4f[0] = -a.v4f[0];
+  c.v4f[1] = -a.v4f[1];
+  return c;
+}
+template<> EIGEN_STRONG_INLINE Packet2d pnegate(const Packet2d& a) { return (-a); }
+
+template<> EIGEN_STRONG_INLINE Packet4i pconj(const Packet4i& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4f pconj(const Packet4f& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet2d pconj(const Packet2d& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet4i pmadd(const Packet4i& a, const Packet4i& b, const Packet4i& c) { return padd<Packet4i>(pmul<Packet4i>(a, b), c); }
+template<> EIGEN_STRONG_INLINE Packet4f pmadd(const Packet4f& a, const Packet4f& b, const Packet4f& c)
+{
+  Packet4f res;
+  res.v4f[0] = vec_madd(a.v4f[0], b.v4f[0], c.v4f[0]);
+  res.v4f[1] = vec_madd(a.v4f[1], b.v4f[1], c.v4f[1]);
+  return res;
+}
+template<> EIGEN_STRONG_INLINE Packet2d pmadd(const Packet2d& a, const Packet2d& b, const Packet2d& c) { return vec_madd(a, b, c); }
+
+template<> EIGEN_STRONG_INLINE Packet4i plset<Packet4i>(const int& a)    { return padd<Packet4i>(pset1<Packet4i>(a), p4i_COUNTDOWN); }
+template<> EIGEN_STRONG_INLINE Packet4f plset<Packet4f>(const float& a)  { return padd<Packet4f>(pset1<Packet4f>(a), p4f_COUNTDOWN); }
+template<> EIGEN_STRONG_INLINE Packet2d plset<Packet2d>(const double& a) { return padd<Packet2d>(pset1<Packet2d>(a), p2d_COUNTDOWN); }
+
+template<> EIGEN_STRONG_INLINE Packet4i pmin<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_min(a, b); }
+template<> EIGEN_STRONG_INLINE Packet2d pmin<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_min(a, b); }
+template<> EIGEN_STRONG_INLINE Packet4f pmin<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f res;
+  res.v4f[0] = pmin(a.v4f[0], b.v4f[0]);
+  res.v4f[1] = pmin(a.v4f[1], b.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pmax<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_max(a, b); }
+template<> EIGEN_STRONG_INLINE Packet2d pmax<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_max(a, b); }
+template<> EIGEN_STRONG_INLINE Packet4f pmax<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f res;
+  res.v4f[0] = pmax(a.v4f[0], b.v4f[0]);
+  res.v4f[1] = pmax(a.v4f[1], b.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pand<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_and(a, b); }
+template<> EIGEN_STRONG_INLINE Packet2d pand<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_and(a, b); }
+template<> EIGEN_STRONG_INLINE Packet4f pand<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f res;
+  res.v4f[0] = pand(a.v4f[0], b.v4f[0]);
+  res.v4f[1] = pand(a.v4f[1], b.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i por<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_or(a, b); }
+template<> EIGEN_STRONG_INLINE Packet2d por<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_or(a, b); }
+template<> EIGEN_STRONG_INLINE Packet4f por<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f res;
+  res.v4f[0] = pand(a.v4f[0], b.v4f[0]);
+  res.v4f[1] = pand(a.v4f[1], b.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pxor<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_xor(a, b); }
+template<> EIGEN_STRONG_INLINE Packet2d pxor<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_xor(a, b); }
+template<> EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f res;
+  res.v4f[0] = pand(a.v4f[0], b.v4f[0]);
+  res.v4f[1] = pand(a.v4f[1], b.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pandnot<Packet4i>(const Packet4i& a, const Packet4i& b) { return pand<Packet4i>(a, vec_nor(b, b)); }
+template<> EIGEN_STRONG_INLINE Packet2d pandnot<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_and(a, vec_nor(b, b)); }
+template<> EIGEN_STRONG_INLINE Packet4f pandnot<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f res;
+  res.v4f[0] = pandnot(a.v4f[0], b.v4f[0]);
+  res.v4f[1] = pandnot(a.v4f[1], b.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pround<Packet4f>(const Packet4f& a)
+{
+  Packet4f res;
+  res.v4f[0] = vec_round(a.v4f[0]);
+  res.v4f[1] = vec_round(a.v4f[1]);
+  return res;
+}
+template<> EIGEN_STRONG_INLINE Packet2d pround<Packet2d>(const Packet2d& a) { return vec_round(a); }
+template<> EIGEN_STRONG_INLINE Packet4f pceil<Packet4f>(const  Packet4f& a)
+{
+  Packet4f res;
+  res.v4f[0] = vec_ceil(a.v4f[0]);
+  res.v4f[1] = vec_ceil(a.v4f[1]);
+  return res;
+}
+template<> EIGEN_STRONG_INLINE Packet2d pceil<Packet2d>(const  Packet2d& a) { return vec_ceil(a); }
+template<> EIGEN_STRONG_INLINE Packet4f pfloor<Packet4f>(const Packet4f& a)
+{
+  Packet4f res;
+  res.v4f[0] = vec_floor(a.v4f[0]);
+  res.v4f[1] = vec_floor(a.v4f[1]);
+  return res;
+}
+template<> EIGEN_STRONG_INLINE Packet2d pfloor<Packet2d>(const Packet2d& a) { return vec_floor(a); }
+
+template<> EIGEN_STRONG_INLINE Packet4i ploadu<Packet4i>(const int*       from) { return pload<Packet4i>(from); }
+template<> EIGEN_STRONG_INLINE Packet4f ploadu<Packet4f>(const float*     from) { return pload<Packet4f>(from); }
+template<> EIGEN_STRONG_INLINE Packet2d ploadu<Packet2d>(const double*    from) { return pload<Packet2d>(from); }
+
+
+template<> EIGEN_STRONG_INLINE Packet4i ploaddup<Packet4i>(const int*     from)
+{
+  Packet4i p = pload<Packet4i>(from);
+  return vec_perm(p, p, p16uc_DUPLICATE32_HI);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f ploaddup<Packet4f>(const float*    from)
+{
+  Packet4f p = pload<Packet4f>(from);
+  p.v4f[1] = vec_splat(p.v4f[0], 1);
+  p.v4f[0] = vec_splat(p.v4f[0], 0);
+  return p;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d ploaddup<Packet2d>(const double*   from)
+{
+  Packet2d p = pload<Packet2d>(from);
+  return vec_perm(p, p, p16uc_PSET64_HI);
+}
+
+template<> EIGEN_STRONG_INLINE void pstoreu<int>(int*        to, const Packet4i& from) { pstore<int>(to, from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<float>(float*    to, const Packet4f& from) { pstore<float>(to, from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<double>(double*  to, const Packet2d& from) { pstore<double>(to, from); }
+
+template<> EIGEN_STRONG_INLINE void prefetch<int>(const int*       addr) { EIGEN_ZVECTOR_PREFETCH(addr); }
+template<> EIGEN_STRONG_INLINE void prefetch<float>(const float*   addr) { EIGEN_ZVECTOR_PREFETCH(addr); }
+template<> EIGEN_STRONG_INLINE void prefetch<double>(const double* addr) { EIGEN_ZVECTOR_PREFETCH(addr); }
+
+template<> EIGEN_STRONG_INLINE int    pfirst<Packet4i>(const Packet4i& a) { int    EIGEN_ALIGN16 x[4]; pstore(x, a); return x[0]; }
+template<> EIGEN_STRONG_INLINE float  pfirst<Packet4f>(const Packet4f& a) { float  EIGEN_ALIGN16 x[2]; vec_st2f(a.v4f[0], &x[0]); return x[0]; }
+template<> EIGEN_STRONG_INLINE double pfirst<Packet2d>(const Packet2d& a) { double EIGEN_ALIGN16 x[2]; pstore(x, a); return x[0]; }
+
+template<> EIGEN_STRONG_INLINE Packet4i preverse(const Packet4i& a)
+{
+  return reinterpret_cast<Packet4i>(vec_perm(reinterpret_cast<Packet16uc>(a), reinterpret_cast<Packet16uc>(a), p16uc_REVERSE32));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d preverse(const Packet2d& a)
+{
+  return reinterpret_cast<Packet2d>(vec_perm(reinterpret_cast<Packet16uc>(a), reinterpret_cast<Packet16uc>(a), p16uc_REVERSE64));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f preverse(const Packet4f& a)
+{
+  Packet4f rev;
+  rev.v4f[0] = preverse<Packet2d>(a.v4f[1]);
+  rev.v4f[1] = preverse<Packet2d>(a.v4f[0]);
+  return rev;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pabs<Packet4i>(const Packet4i& a) { return vec_abs(a); }
+template<> EIGEN_STRONG_INLINE Packet2d pabs<Packet2d>(const Packet2d& a) { return vec_abs(a); }
+template<> EIGEN_STRONG_INLINE Packet4f pabs<Packet4f>(const Packet4f& a)
+{
+  Packet4f res;
+  res.v4f[0] = pabs(a.v4f[0]);
+  res.v4f[1] = pabs(a.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE int predux<Packet4i>(const Packet4i& a)
+{
+  Packet4i b, sum;
+  b   = vec_sld(a, a, 8);
+  sum = padd<Packet4i>(a, b);
+  b   = vec_sld(sum, sum, 4);
+  sum = padd<Packet4i>(sum, b);
+  return pfirst(sum);
+}
+
+template<> EIGEN_STRONG_INLINE double predux<Packet2d>(const Packet2d& a)
+{
+  Packet2d b, sum;
+  b   = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4i>(a), reinterpret_cast<Packet4i>(a), 8));
+  sum = padd<Packet2d>(a, b);
+  return pfirst(sum);
+}
+template<> EIGEN_STRONG_INLINE float predux<Packet4f>(const Packet4f& a)
+{
+  Packet2d sum;
+  sum = padd<Packet2d>(a.v4f[0], a.v4f[1]);
+  double first = predux<Packet2d>(sum);
+  return static_cast<float>(first);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i preduxp<Packet4i>(const Packet4i* vecs)
+{
+  Packet4i v[4], sum[4];
+
+  // It's easier and faster to transpose then add as columns
+  // Check: http://www.freevec.org/function/matrix_4x4_transpose_floats for explanation
+  // Do the transpose, first set of moves
+  v[0] = vec_mergeh(vecs[0], vecs[2]);
+  v[1] = vec_mergel(vecs[0], vecs[2]);
+  v[2] = vec_mergeh(vecs[1], vecs[3]);
+  v[3] = vec_mergel(vecs[1], vecs[3]);
+  // Get the resulting vectors
+  sum[0] = vec_mergeh(v[0], v[2]);
+  sum[1] = vec_mergel(v[0], v[2]);
+  sum[2] = vec_mergeh(v[1], v[3]);
+  sum[3] = vec_mergel(v[1], v[3]);
+
+  // Now do the summation:
+  // Lines 0+1
+  sum[0] = padd<Packet4i>(sum[0], sum[1]);
+  // Lines 2+3
+  sum[1] = padd<Packet4i>(sum[2], sum[3]);
+  // Add the results
+  sum[0] = padd<Packet4i>(sum[0], sum[1]);
+
+  return sum[0];
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d preduxp<Packet2d>(const Packet2d* vecs)
+{
+  Packet2d v[2], sum;
+  v[0] = padd<Packet2d>(vecs[0], reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4ui>(vecs[0]), reinterpret_cast<Packet4ui>(vecs[0]), 8)));
+  v[1] = padd<Packet2d>(vecs[1], reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4ui>(vecs[1]), reinterpret_cast<Packet4ui>(vecs[1]), 8)));
+ 
+  sum = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4ui>(v[0]), reinterpret_cast<Packet4ui>(v[1]), 8));
+
+  return sum;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f preduxp<Packet4f>(const Packet4f* vecs)
+{
+  PacketBlock<Packet4f,4> transpose;
+  transpose.packet[0] = vecs[0];
+  transpose.packet[1] = vecs[1];
+  transpose.packet[2] = vecs[2];
+  transpose.packet[3] = vecs[3];
+  ptranspose(transpose);
+
+  Packet4f sum = padd(transpose.packet[0], transpose.packet[1]);
+  sum = padd(sum, transpose.packet[2]);
+  sum = padd(sum, transpose.packet[3]);
+  return sum;
+}
+
+// Other reduction functions:
+// mul
+template<> EIGEN_STRONG_INLINE int predux_mul<Packet4i>(const Packet4i& a)
+{
+  EIGEN_ALIGN16 int aux[4];
+  pstore(aux, a);
+  return aux[0] * aux[1] * aux[2] * aux[3];
+}
+
+template<> EIGEN_STRONG_INLINE double predux_mul<Packet2d>(const Packet2d& a)
+{
+  return pfirst(pmul(a, reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4i>(a), reinterpret_cast<Packet4i>(a), 8))));
+}
+
+template<> EIGEN_STRONG_INLINE float predux_mul<Packet4f>(const Packet4f& a)
+{
+  // Return predux_mul<Packet2d> of the subvectors product
+  return static_cast<float>(pfirst(predux_mul(pmul(a.v4f[0], a.v4f[1]))));
+}
+
+// min
+template<> EIGEN_STRONG_INLINE int predux_min<Packet4i>(const Packet4i& a)
+{
+  Packet4i b, res;
+  b   = pmin<Packet4i>(a, vec_sld(a, a, 8));
+  res = pmin<Packet4i>(b, vec_sld(b, b, 4));
+  return pfirst(res);
+}
+
+template<> EIGEN_STRONG_INLINE double predux_min<Packet2d>(const Packet2d& a)
+{
+  return pfirst(pmin<Packet2d>(a, reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4i>(a), reinterpret_cast<Packet4i>(a), 8))));
+}
+
+template<> EIGEN_STRONG_INLINE float predux_min<Packet4f>(const Packet4f& a)
+{
+  Packet2d b, res;
+  b   = pmin<Packet2d>(a.v4f[0], a.v4f[1]);
+  res = pmin<Packet2d>(b, reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4i>(b), reinterpret_cast<Packet4i>(b), 8)));
+  return static_cast<float>(pfirst(res));
+}
+
+// max
+template<> EIGEN_STRONG_INLINE int predux_max<Packet4i>(const Packet4i& a)
+{
+  Packet4i b, res;
+  b = pmax<Packet4i>(a, vec_sld(a, a, 8));
+  res = pmax<Packet4i>(b, vec_sld(b, b, 4));
+  return pfirst(res);
+}
+
+// max
+template<> EIGEN_STRONG_INLINE double predux_max<Packet2d>(const Packet2d& a)
+{
+  return pfirst(pmax<Packet2d>(a, reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4i>(a), reinterpret_cast<Packet4i>(a), 8))));
+}
+
+template<> EIGEN_STRONG_INLINE float predux_max<Packet4f>(const Packet4f& a)
+{
+  Packet2d b, res;
+  b   = pmax<Packet2d>(a.v4f[0], a.v4f[1]);
+  res = pmax<Packet2d>(b, reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4i>(b), reinterpret_cast<Packet4i>(b), 8)));
+  return static_cast<float>(pfirst(res));
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet4i,4>& kernel) {
+  Packet4i t0 = vec_mergeh(kernel.packet[0], kernel.packet[2]);
+  Packet4i t1 = vec_mergel(kernel.packet[0], kernel.packet[2]);
+  Packet4i t2 = vec_mergeh(kernel.packet[1], kernel.packet[3]);
+  Packet4i t3 = vec_mergel(kernel.packet[1], kernel.packet[3]);
+  kernel.packet[0] = vec_mergeh(t0, t2);
+  kernel.packet[1] = vec_mergel(t0, t2);
+  kernel.packet[2] = vec_mergeh(t1, t3);
+  kernel.packet[3] = vec_mergel(t1, t3);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet2d,2>& kernel) {
+  Packet2d t0 = vec_perm(kernel.packet[0], kernel.packet[1], p16uc_TRANSPOSE64_HI);
+  Packet2d t1 = vec_perm(kernel.packet[0], kernel.packet[1], p16uc_TRANSPOSE64_LO);
+  kernel.packet[0] = t0;
+  kernel.packet[1] = t1;
+}
+
+/* Split the Packet4f PacketBlock into 4 Packet2d PacketBlocks and transpose each one
+ */
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet4f,4>& kernel) {
+  PacketBlock<Packet2d,2> t0,t1,t2,t3;
+  // copy top-left 2x2 Packet2d block
+  t0.packet[0] = kernel.packet[0].v4f[0];
+  t0.packet[1] = kernel.packet[1].v4f[0];
+
+  // copy top-right 2x2 Packet2d block
+  t1.packet[0] = kernel.packet[0].v4f[1];
+  t1.packet[1] = kernel.packet[1].v4f[1];
+
+  // copy bottom-left 2x2 Packet2d block
+  t2.packet[0] = kernel.packet[2].v4f[0];
+  t2.packet[1] = kernel.packet[3].v4f[0];
+
+  // copy bottom-right 2x2 Packet2d block
+  t3.packet[0] = kernel.packet[2].v4f[1];
+  t3.packet[1] = kernel.packet[3].v4f[1];
+
+  // Transpose all 2x2 blocks
+  ptranspose(t0);
+  ptranspose(t1);
+  ptranspose(t2);
+  ptranspose(t3);
+
+  // Copy back transposed blocks, but exchange t1 and t2 due to transposition
+  kernel.packet[0].v4f[0] = t0.packet[0];
+  kernel.packet[0].v4f[1] = t2.packet[0];
+  kernel.packet[1].v4f[0] = t0.packet[1];
+  kernel.packet[1].v4f[1] = t2.packet[1];
+  kernel.packet[2].v4f[0] = t1.packet[0];
+  kernel.packet[2].v4f[1] = t3.packet[0];
+  kernel.packet[3].v4f[0] = t1.packet[1];
+  kernel.packet[3].v4f[1] = t3.packet[1];
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pblend(const Selector<4>& ifPacket, const Packet4i& thenPacket, const Packet4i& elsePacket) {
+  Packet4ui select = { ifPacket.select[0], ifPacket.select[1], ifPacket.select[2], ifPacket.select[3] };
+  Packet4ui mask = vec_cmpeq(select, reinterpret_cast<Packet4ui>(p4i_ONE));
+  return vec_sel(elsePacket, thenPacket, mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pblend(const Selector<4>& ifPacket, const Packet4f& thenPacket, const Packet4f& elsePacket) {
+  Packet2ul select_hi = { ifPacket.select[0], ifPacket.select[1] };
+  Packet2ul select_lo = { ifPacket.select[2], ifPacket.select[3] };
+  Packet2ul mask_hi = vec_cmpeq(select_hi, reinterpret_cast<Packet2ul>(p2l_ONE));
+  Packet2ul mask_lo = vec_cmpeq(select_lo, reinterpret_cast<Packet2ul>(p2l_ONE));
+  Packet4f result;
+  result.v4f[0] = vec_sel(elsePacket.v4f[0], thenPacket.v4f[0], mask_hi);
+  result.v4f[1] = vec_sel(elsePacket.v4f[1], thenPacket.v4f[1], mask_lo);
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pblend(const Selector<2>& ifPacket, const Packet2d& thenPacket, const Packet2d& elsePacket) {
+  Packet2ul select = { ifPacket.select[0], ifPacket.select[1] };
+  Packet2ul mask = vec_cmpeq(select, reinterpret_cast<Packet2ul>(p2l_ONE));
+  return vec_sel(elsePacket, thenPacket, mask);
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_PACKET_MATH_ZVECTOR_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/functors/AssignmentFunctors.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/functors/AssignmentFunctors.h
new file mode 100644
index 00000000..1077d8eb
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/functors/AssignmentFunctors.h
@@ -0,0 +1,168 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ASSIGNMENT_FUNCTORS_H
+#define EIGEN_ASSIGNMENT_FUNCTORS_H
+
+namespace Eigen {
+
+namespace internal {
+  
+/** \internal
+  * \brief Template functor for scalar/packet assignment
+  *
+  */
+template<typename DstScalar,typename SrcScalar> struct assign_op {
+
+  EIGEN_EMPTY_STRUCT_CTOR(assign_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(DstScalar& a, const SrcScalar& b) const { a = b; }
+  
+  template<int Alignment, typename Packet>
+  EIGEN_STRONG_INLINE void assignPacket(DstScalar* a, const Packet& b) const
+  { internal::pstoret<DstScalar,Packet,Alignment>(a,b); }
+};
+
+// Empty overload for void type (used by PermutationMatrix)
+template<typename DstScalar> struct assign_op<DstScalar,void> {};
+
+template<typename DstScalar,typename SrcScalar>
+struct functor_traits<assign_op<DstScalar,SrcScalar> > {
+  enum {
+    Cost = NumTraits<DstScalar>::ReadCost,
+    PacketAccess = is_same<DstScalar,SrcScalar>::value && packet_traits<DstScalar>::Vectorizable && packet_traits<SrcScalar>::Vectorizable
+  };
+};
+
+/** \internal
+  * \brief Template functor for scalar/packet assignment with addition
+  *
+  */
+template<typename DstScalar,typename SrcScalar> struct add_assign_op {
+
+  EIGEN_EMPTY_STRUCT_CTOR(add_assign_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(DstScalar& a, const SrcScalar& b) const { a += b; }
+  
+  template<int Alignment, typename Packet>
+  EIGEN_STRONG_INLINE void assignPacket(DstScalar* a, const Packet& b) const
+  { internal::pstoret<DstScalar,Packet,Alignment>(a,internal::padd(internal::ploadt<Packet,Alignment>(a),b)); }
+};
+template<typename DstScalar,typename SrcScalar>
+struct functor_traits<add_assign_op<DstScalar,SrcScalar> > {
+  enum {
+    Cost = NumTraits<DstScalar>::ReadCost + NumTraits<DstScalar>::AddCost,
+    PacketAccess = is_same<DstScalar,SrcScalar>::value && packet_traits<DstScalar>::HasAdd
+  };
+};
+
+/** \internal
+  * \brief Template functor for scalar/packet assignment with subtraction
+  *
+  */
+template<typename DstScalar,typename SrcScalar> struct sub_assign_op {
+
+  EIGEN_EMPTY_STRUCT_CTOR(sub_assign_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(DstScalar& a, const SrcScalar& b) const { a -= b; }
+  
+  template<int Alignment, typename Packet>
+  EIGEN_STRONG_INLINE void assignPacket(DstScalar* a, const Packet& b) const
+  { internal::pstoret<DstScalar,Packet,Alignment>(a,internal::psub(internal::ploadt<Packet,Alignment>(a),b)); }
+};
+template<typename DstScalar,typename SrcScalar>
+struct functor_traits<sub_assign_op<DstScalar,SrcScalar> > {
+  enum {
+    Cost = NumTraits<DstScalar>::ReadCost + NumTraits<DstScalar>::AddCost,
+    PacketAccess = is_same<DstScalar,SrcScalar>::value && packet_traits<DstScalar>::HasSub
+  };
+};
+
+/** \internal
+  * \brief Template functor for scalar/packet assignment with multiplication
+  *
+  */
+template<typename DstScalar, typename SrcScalar=DstScalar>
+struct mul_assign_op {
+
+  EIGEN_EMPTY_STRUCT_CTOR(mul_assign_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(DstScalar& a, const SrcScalar& b) const { a *= b; }
+  
+  template<int Alignment, typename Packet>
+  EIGEN_STRONG_INLINE void assignPacket(DstScalar* a, const Packet& b) const
+  { internal::pstoret<DstScalar,Packet,Alignment>(a,internal::pmul(internal::ploadt<Packet,Alignment>(a),b)); }
+};
+template<typename DstScalar, typename SrcScalar>
+struct functor_traits<mul_assign_op<DstScalar,SrcScalar> > {
+  enum {
+    Cost = NumTraits<DstScalar>::ReadCost + NumTraits<DstScalar>::MulCost,
+    PacketAccess = is_same<DstScalar,SrcScalar>::value && packet_traits<DstScalar>::HasMul
+  };
+};
+
+/** \internal
+  * \brief Template functor for scalar/packet assignment with diviving
+  *
+  */
+template<typename DstScalar, typename SrcScalar=DstScalar> struct div_assign_op {
+
+  EIGEN_EMPTY_STRUCT_CTOR(div_assign_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(DstScalar& a, const SrcScalar& b) const { a /= b; }
+  
+  template<int Alignment, typename Packet>
+  EIGEN_STRONG_INLINE void assignPacket(DstScalar* a, const Packet& b) const
+  { internal::pstoret<DstScalar,Packet,Alignment>(a,internal::pdiv(internal::ploadt<Packet,Alignment>(a),b)); }
+};
+template<typename DstScalar, typename SrcScalar>
+struct functor_traits<div_assign_op<DstScalar,SrcScalar> > {
+  enum {
+    Cost = NumTraits<DstScalar>::ReadCost + NumTraits<DstScalar>::MulCost,
+    PacketAccess = is_same<DstScalar,SrcScalar>::value && packet_traits<DstScalar>::HasDiv
+  };
+};
+
+/** \internal
+  * \brief Template functor for scalar/packet assignment with swapping
+  *
+  * It works as follow. For a non-vectorized evaluation loop, we have:
+  *   for(i) func(A.coeffRef(i), B.coeff(i));
+  * where B is a SwapWrapper expression. The trick is to make SwapWrapper::coeff behaves like a non-const coeffRef.
+  * Actually, SwapWrapper might not even be needed since even if B is a plain expression, since it has to be writable
+  * B.coeff already returns a const reference to the underlying scalar value.
+  * 
+  * The case of a vectorized loop is more tricky:
+  *   for(i,j) func.assignPacket<A_Align>(&A.coeffRef(i,j), B.packet<B_Align>(i,j));
+  * Here, B must be a SwapWrapper whose packet function actually returns a proxy object holding a Scalar*,
+  * the actual alignment and Packet type.
+  *
+  */
+template<typename Scalar> struct swap_assign_op {
+
+  EIGEN_EMPTY_STRUCT_CTOR(swap_assign_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(Scalar& a, const Scalar& b) const
+  {
+#ifdef EIGEN_CUDACC
+    // FIXME is there some kind of cuda::swap?
+    Scalar t=b; const_cast<Scalar&>(b)=a; a=t;
+#else
+    using std::swap;
+    swap(a,const_cast<Scalar&>(b));
+#endif
+  }
+};
+template<typename Scalar>
+struct functor_traits<swap_assign_op<Scalar> > {
+  enum {
+    Cost = 3 * NumTraits<Scalar>::ReadCost,
+    PacketAccess = packet_traits<Scalar>::Vectorizable
+  };
+};
+
+} // namespace internal
+
+} // namespace Eigen
+
+#endif // EIGEN_ASSIGNMENT_FUNCTORS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/functors/BinaryFunctors.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/functors/BinaryFunctors.h
new file mode 100644
index 00000000..96747bac
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/functors/BinaryFunctors.h
@@ -0,0 +1,482 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_BINARY_FUNCTORS_H
+#define EIGEN_BINARY_FUNCTORS_H
+
+namespace Eigen {
+
+namespace internal {
+
+//---------- associative binary functors ----------
+
+template<typename Arg1, typename Arg2>
+struct binary_op_base
+{
+  typedef Arg1 first_argument_type;
+  typedef Arg2 second_argument_type;
+};
+
+/** \internal
+  * \brief Template functor to compute the sum of two scalars
+  *
+  * \sa class CwiseBinaryOp, MatrixBase::operator+, class VectorwiseOp, DenseBase::sum()
+  */
+template<typename LhsScalar,typename RhsScalar>
+struct scalar_sum_op : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_sum_op>::ReturnType result_type;
+#ifndef EIGEN_SCALAR_BINARY_OP_PLUGIN
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_sum_op)
+#else
+  scalar_sum_op() {
+    EIGEN_SCALAR_BINARY_OP_PLUGIN
+  }
+#endif
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return a + b; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
+  { return internal::padd(a,b); }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type predux(const Packet& a) const
+  { return internal::predux(a); }
+};
+template<typename LhsScalar,typename RhsScalar>
+struct functor_traits<scalar_sum_op<LhsScalar,RhsScalar> > {
+  enum {
+    Cost = (NumTraits<LhsScalar>::AddCost+NumTraits<RhsScalar>::AddCost)/2, // rough estimate!
+    PacketAccess = is_same<LhsScalar,RhsScalar>::value && packet_traits<LhsScalar>::HasAdd && packet_traits<RhsScalar>::HasAdd
+    // TODO vectorize mixed sum
+  };
+};
+
+/** \internal
+  * \brief Template specialization to deprecate the summation of boolean expressions.
+  * This is required to solve Bug 426.
+  * \sa DenseBase::count(), DenseBase::any(), ArrayBase::cast(), MatrixBase::cast()
+  */
+template<> struct scalar_sum_op<bool,bool> : scalar_sum_op<int,int> {
+  EIGEN_DEPRECATED
+  scalar_sum_op() {}
+};
+
+
+/** \internal
+  * \brief Template functor to compute the product of two scalars
+  *
+  * \sa class CwiseBinaryOp, Cwise::operator*(), class VectorwiseOp, MatrixBase::redux()
+  */
+template<typename LhsScalar,typename RhsScalar>
+struct scalar_product_op  : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_product_op>::ReturnType result_type;
+#ifndef EIGEN_SCALAR_BINARY_OP_PLUGIN
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_product_op)
+#else
+  scalar_product_op() {
+    EIGEN_SCALAR_BINARY_OP_PLUGIN
+  }
+#endif
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return a * b; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
+  { return internal::pmul(a,b); }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type predux(const Packet& a) const
+  { return internal::predux_mul(a); }
+};
+template<typename LhsScalar,typename RhsScalar>
+struct functor_traits<scalar_product_op<LhsScalar,RhsScalar> > {
+  enum {
+    Cost = (NumTraits<LhsScalar>::MulCost + NumTraits<RhsScalar>::MulCost)/2, // rough estimate!
+    PacketAccess = is_same<LhsScalar,RhsScalar>::value && packet_traits<LhsScalar>::HasMul && packet_traits<RhsScalar>::HasMul
+    // TODO vectorize mixed product
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the conjugate product of two scalars
+  *
+  * This is a short cut for conj(x) * y which is needed for optimization purpose; in Eigen2 support mode, this becomes x * conj(y)
+  */
+template<typename LhsScalar,typename RhsScalar>
+struct scalar_conj_product_op  : binary_op_base<LhsScalar,RhsScalar>
+{
+
+  enum {
+    Conj = NumTraits<LhsScalar>::IsComplex
+  };
+  
+  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_conj_product_op>::ReturnType result_type;
+  
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_conj_product_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const
+  { return conj_helper<LhsScalar,RhsScalar,Conj,false>().pmul(a,b); }
+  
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
+  { return conj_helper<Packet,Packet,Conj,false>().pmul(a,b); }
+};
+template<typename LhsScalar,typename RhsScalar>
+struct functor_traits<scalar_conj_product_op<LhsScalar,RhsScalar> > {
+  enum {
+    Cost = NumTraits<LhsScalar>::MulCost,
+    PacketAccess = internal::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasMul
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the min of two scalars
+  *
+  * \sa class CwiseBinaryOp, MatrixBase::cwiseMin, class VectorwiseOp, MatrixBase::minCoeff()
+  */
+template<typename LhsScalar,typename RhsScalar>
+struct scalar_min_op : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_min_op>::ReturnType result_type;
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_min_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return numext::mini(a, b); }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
+  { return internal::pmin(a,b); }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type predux(const Packet& a) const
+  { return internal::predux_min(a); }
+};
+template<typename LhsScalar,typename RhsScalar>
+struct functor_traits<scalar_min_op<LhsScalar,RhsScalar> > {
+  enum {
+    Cost = (NumTraits<LhsScalar>::AddCost+NumTraits<RhsScalar>::AddCost)/2,
+    PacketAccess = internal::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasMin
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the max of two scalars
+  *
+  * \sa class CwiseBinaryOp, MatrixBase::cwiseMax, class VectorwiseOp, MatrixBase::maxCoeff()
+  */
+template<typename LhsScalar,typename RhsScalar>
+struct scalar_max_op  : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_max_op>::ReturnType result_type;
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_max_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return numext::maxi(a, b); }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
+  { return internal::pmax(a,b); }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type predux(const Packet& a) const
+  { return internal::predux_max(a); }
+};
+template<typename LhsScalar,typename RhsScalar>
+struct functor_traits<scalar_max_op<LhsScalar,RhsScalar> > {
+  enum {
+    Cost = (NumTraits<LhsScalar>::AddCost+NumTraits<RhsScalar>::AddCost)/2,
+    PacketAccess = internal::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasMax
+  };
+};
+
+/** \internal
+  * \brief Template functors for comparison of two scalars
+  * \todo Implement packet-comparisons
+  */
+template<typename LhsScalar, typename RhsScalar, ComparisonName cmp> struct scalar_cmp_op;
+
+template<typename LhsScalar, typename RhsScalar, ComparisonName cmp>
+struct functor_traits<scalar_cmp_op<LhsScalar,RhsScalar, cmp> > {
+  enum {
+    Cost = (NumTraits<LhsScalar>::AddCost+NumTraits<RhsScalar>::AddCost)/2,
+    PacketAccess = false
+  };
+};
+
+template<ComparisonName Cmp, typename LhsScalar, typename RhsScalar>
+struct result_of<scalar_cmp_op<LhsScalar, RhsScalar, Cmp>(LhsScalar,RhsScalar)> {
+  typedef bool type;
+};
+
+
+template<typename LhsScalar, typename RhsScalar>
+struct scalar_cmp_op<LhsScalar,RhsScalar, cmp_EQ> : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef bool result_type;
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cmp_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a==b;}
+};
+template<typename LhsScalar, typename RhsScalar>
+struct scalar_cmp_op<LhsScalar,RhsScalar, cmp_LT> : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef bool result_type;
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cmp_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a<b;}
+};
+template<typename LhsScalar, typename RhsScalar>
+struct scalar_cmp_op<LhsScalar,RhsScalar, cmp_LE> : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef bool result_type;
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cmp_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a<=b;}
+};
+template<typename LhsScalar, typename RhsScalar>
+struct scalar_cmp_op<LhsScalar,RhsScalar, cmp_GT> : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef bool result_type;
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cmp_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a>b;}
+};
+template<typename LhsScalar, typename RhsScalar>
+struct scalar_cmp_op<LhsScalar,RhsScalar, cmp_GE> : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef bool result_type;
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cmp_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a>=b;}
+};
+template<typename LhsScalar, typename RhsScalar>
+struct scalar_cmp_op<LhsScalar,RhsScalar, cmp_UNORD> : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef bool result_type;
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cmp_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(const LhsScalar& a, const RhsScalar& b) const {return !(a<=b || b<=a);}
+};
+template<typename LhsScalar, typename RhsScalar>
+struct scalar_cmp_op<LhsScalar,RhsScalar, cmp_NEQ> : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef bool result_type;
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cmp_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a!=b;}
+};
+
+
+/** \internal
+  * \brief Template functor to compute the hypot of two scalars
+  *
+  * \sa MatrixBase::stableNorm(), class Redux
+  */
+template<typename Scalar>
+struct scalar_hypot_op<Scalar,Scalar> : binary_op_base<Scalar,Scalar>
+{
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_hypot_op)
+//   typedef typename NumTraits<Scalar>::Real result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& _x, const Scalar& _y) const
+  {
+    EIGEN_USING_STD_MATH(sqrt)
+    Scalar p, qp;
+    if(_x>_y)
+    {
+      p = _x;
+      qp = _y / p;
+    }
+    else
+    {
+      p = _y;
+      qp = _x / p;
+    }
+    return p * sqrt(Scalar(1) + qp*qp);
+  }
+};
+template<typename Scalar>
+struct functor_traits<scalar_hypot_op<Scalar,Scalar> > {
+  enum
+  {
+    Cost = 3 * NumTraits<Scalar>::AddCost +
+           2 * NumTraits<Scalar>::MulCost +
+           2 * scalar_div_cost<Scalar,false>::value,
+    PacketAccess = false
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the pow of two scalars
+  */
+template<typename Scalar, typename Exponent>
+struct scalar_pow_op  : binary_op_base<Scalar,Exponent>
+{
+  typedef typename ScalarBinaryOpTraits<Scalar,Exponent,scalar_pow_op>::ReturnType result_type;
+#ifndef EIGEN_SCALAR_BINARY_OP_PLUGIN
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_pow_op)
+#else
+  scalar_pow_op() {
+    typedef Scalar LhsScalar;
+    typedef Exponent RhsScalar;
+    EIGEN_SCALAR_BINARY_OP_PLUGIN
+  }
+#endif
+  EIGEN_DEVICE_FUNC
+  inline result_type operator() (const Scalar& a, const Exponent& b) const { return numext::pow(a, b); }
+};
+template<typename Scalar, typename Exponent>
+struct functor_traits<scalar_pow_op<Scalar,Exponent> > {
+  enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false };
+};
+
+
+
+//---------- non associative binary functors ----------
+
+/** \internal
+  * \brief Template functor to compute the difference of two scalars
+  *
+  * \sa class CwiseBinaryOp, MatrixBase::operator-
+  */
+template<typename LhsScalar,typename RhsScalar>
+struct scalar_difference_op : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_difference_op>::ReturnType result_type;
+#ifndef EIGEN_SCALAR_BINARY_OP_PLUGIN
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_difference_op)
+#else
+  scalar_difference_op() {
+    EIGEN_SCALAR_BINARY_OP_PLUGIN
+  }
+#endif
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return a - b; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
+  { return internal::psub(a,b); }
+};
+template<typename LhsScalar,typename RhsScalar>
+struct functor_traits<scalar_difference_op<LhsScalar,RhsScalar> > {
+  enum {
+    Cost = (NumTraits<LhsScalar>::AddCost+NumTraits<RhsScalar>::AddCost)/2,
+    PacketAccess = is_same<LhsScalar,RhsScalar>::value && packet_traits<LhsScalar>::HasSub && packet_traits<RhsScalar>::HasSub
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the quotient of two scalars
+  *
+  * \sa class CwiseBinaryOp, Cwise::operator/()
+  */
+template<typename LhsScalar,typename RhsScalar>
+struct scalar_quotient_op  : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_quotient_op>::ReturnType result_type;
+#ifndef EIGEN_SCALAR_BINARY_OP_PLUGIN
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_quotient_op)
+#else
+  scalar_quotient_op() {
+    EIGEN_SCALAR_BINARY_OP_PLUGIN
+  }
+#endif
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return a / b; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
+  { return internal::pdiv(a,b); }
+};
+template<typename LhsScalar,typename RhsScalar>
+struct functor_traits<scalar_quotient_op<LhsScalar,RhsScalar> > {
+  typedef typename scalar_quotient_op<LhsScalar,RhsScalar>::result_type result_type;
+  enum {
+    PacketAccess = is_same<LhsScalar,RhsScalar>::value && packet_traits<LhsScalar>::HasDiv && packet_traits<RhsScalar>::HasDiv,
+    Cost = scalar_div_cost<result_type,PacketAccess>::value
+  };
+};
+
+
+
+/** \internal
+  * \brief Template functor to compute the and of two booleans
+  *
+  * \sa class CwiseBinaryOp, ArrayBase::operator&&
+  */
+struct scalar_boolean_and_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_boolean_and_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator() (const bool& a, const bool& b) const { return a && b; }
+};
+template<> struct functor_traits<scalar_boolean_and_op> {
+  enum {
+    Cost = NumTraits<bool>::AddCost,
+    PacketAccess = false
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the or of two booleans
+  *
+  * \sa class CwiseBinaryOp, ArrayBase::operator||
+  */
+struct scalar_boolean_or_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_boolean_or_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator() (const bool& a, const bool& b) const { return a || b; }
+};
+template<> struct functor_traits<scalar_boolean_or_op> {
+  enum {
+    Cost = NumTraits<bool>::AddCost,
+    PacketAccess = false
+  };
+};
+
+/** \internal
+ * \brief Template functor to compute the xor of two booleans
+ *
+ * \sa class CwiseBinaryOp, ArrayBase::operator^
+ */
+struct scalar_boolean_xor_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_boolean_xor_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator() (const bool& a, const bool& b) const { return a ^ b; }
+};
+template<> struct functor_traits<scalar_boolean_xor_op> {
+  enum {
+    Cost = NumTraits<bool>::AddCost,
+    PacketAccess = false
+  };
+};
+
+
+
+//---------- binary functors bound to a constant, thus appearing as a unary functor ----------
+
+// The following two classes permits to turn any binary functor into a unary one with one argument bound to a constant value.
+// They are analogues to std::binder1st/binder2nd but with the following differences:
+//  - they are compatible with packetOp
+//  - they are portable across C++ versions (the std::binder* are deprecated in C++11)
+template<typename BinaryOp> struct bind1st_op : BinaryOp {
+
+  typedef typename BinaryOp::first_argument_type  first_argument_type;
+  typedef typename BinaryOp::second_argument_type second_argument_type;
+  typedef typename BinaryOp::result_type          result_type;
+
+  bind1st_op(const first_argument_type &val) : m_value(val) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const second_argument_type& b) const { return BinaryOp::operator()(m_value,b); }
+
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& b) const
+  { return BinaryOp::packetOp(internal::pset1<Packet>(m_value), b); }
+
+  first_argument_type m_value;
+};
+template<typename BinaryOp> struct functor_traits<bind1st_op<BinaryOp> > : functor_traits<BinaryOp> {};
+
+
+template<typename BinaryOp> struct bind2nd_op : BinaryOp {
+
+  typedef typename BinaryOp::first_argument_type  first_argument_type;
+  typedef typename BinaryOp::second_argument_type second_argument_type;
+  typedef typename BinaryOp::result_type          result_type;
+
+  bind2nd_op(const second_argument_type &val) : m_value(val) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const first_argument_type& a) const { return BinaryOp::operator()(a,m_value); }
+
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
+  { return BinaryOp::packetOp(a,internal::pset1<Packet>(m_value)); }
+
+  second_argument_type m_value;
+};
+template<typename BinaryOp> struct functor_traits<bind2nd_op<BinaryOp> > : functor_traits<BinaryOp> {};
+
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_BINARY_FUNCTORS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/functors/NullaryFunctors.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/functors/NullaryFunctors.h
new file mode 100644
index 00000000..b03be026
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/functors/NullaryFunctors.h
@@ -0,0 +1,188 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_NULLARY_FUNCTORS_H
+#define EIGEN_NULLARY_FUNCTORS_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename Scalar>
+struct scalar_constant_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE scalar_constant_op(const scalar_constant_op& other) : m_other(other.m_other) { }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE scalar_constant_op(const Scalar& other) : m_other(other) { }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() () const { return m_other; }
+  template<typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const PacketType packetOp() const { return internal::pset1<PacketType>(m_other); }
+  const Scalar m_other;
+};
+template<typename Scalar>
+struct functor_traits<scalar_constant_op<Scalar> >
+{ enum { Cost = 0 /* as the constant value should be loaded in register only once for the whole expression */,
+         PacketAccess = packet_traits<Scalar>::Vectorizable, IsRepeatable = true }; };
+
+template<typename Scalar> struct scalar_identity_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_identity_op)
+  template<typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (IndexType row, IndexType col) const { return row==col ? Scalar(1) : Scalar(0); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_identity_op<Scalar> >
+{ enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = false, IsRepeatable = true }; };
+
+template <typename Scalar, typename Packet, bool IsInteger> struct linspaced_op_impl;
+
+template <typename Scalar, typename Packet>
+struct linspaced_op_impl<Scalar,Packet,/*IsInteger*/false>
+{
+  linspaced_op_impl(const Scalar& low, const Scalar& high, Index num_steps) :
+    m_low(low), m_high(high), m_size1(num_steps==1 ? 1 : num_steps-1), m_step(num_steps==1 ? Scalar() : (high-low)/Scalar(num_steps-1)),
+    m_flip(numext::abs(high)<numext::abs(low))
+  {}
+
+  template<typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (IndexType i) const {
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    if(m_flip)
+      return (i==0)? m_low : (m_high - RealScalar(m_size1-i)*m_step);
+    else
+      return (i==m_size1)? m_high : (m_low + RealScalar(i)*m_step);
+  }
+
+  template<typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(IndexType i) const
+  {
+    // Principle:
+    // [low, ..., low] + ( [step, ..., step] * ( [i, ..., i] + [0, ..., size] ) )
+    if(m_flip)
+    {
+      Packet pi = plset<Packet>(Scalar(i-m_size1));
+      Packet res = padd(pset1<Packet>(m_high), pmul(pset1<Packet>(m_step), pi));
+      if(i==0)
+        res = pinsertfirst(res, m_low);
+      return res;
+    }
+    else
+    {
+      Packet pi = plset<Packet>(Scalar(i));
+      Packet res = padd(pset1<Packet>(m_low), pmul(pset1<Packet>(m_step), pi));
+      if(i==m_size1-unpacket_traits<Packet>::size+1)
+        res = pinsertlast(res, m_high);
+      return res;
+    }
+  }
+
+  const Scalar m_low;
+  const Scalar m_high;
+  const Index m_size1;
+  const Scalar m_step;
+  const bool m_flip;
+};
+
+template <typename Scalar, typename Packet>
+struct linspaced_op_impl<Scalar,Packet,/*IsInteger*/true>
+{
+  linspaced_op_impl(const Scalar& low, const Scalar& high, Index num_steps) :
+    m_low(low),
+    m_multiplier((high-low)/convert_index<Scalar>(num_steps<=1 ? 1 : num_steps-1)),
+    m_divisor(convert_index<Scalar>((high>=low?num_steps:-num_steps)+(high-low))/((numext::abs(high-low)+1)==0?1:(numext::abs(high-low)+1))),
+    m_use_divisor(num_steps>1 && (numext::abs(high-low)+1)<num_steps)
+  {}
+
+  template<typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  const Scalar operator() (IndexType i) const
+  {
+    if(m_use_divisor) return m_low + convert_index<Scalar>(i)/m_divisor;
+    else              return m_low + convert_index<Scalar>(i)*m_multiplier;
+  }
+
+  const Scalar m_low;
+  const Scalar m_multiplier;
+  const Scalar m_divisor;
+  const bool m_use_divisor;
+};
+
+// ----- Linspace functor ----------------------------------------------------------------
+
+// Forward declaration (we default to random access which does not really give
+// us a speed gain when using packet access but it allows to use the functor in
+// nested expressions).
+template <typename Scalar, typename PacketType> struct linspaced_op;
+template <typename Scalar, typename PacketType> struct functor_traits< linspaced_op<Scalar,PacketType> >
+{
+  enum
+  {
+    Cost = 1,
+    PacketAccess =   (!NumTraits<Scalar>::IsInteger) && packet_traits<Scalar>::HasSetLinear && packet_traits<Scalar>::HasBlend,
+                  /*&& ((!NumTraits<Scalar>::IsInteger) || packet_traits<Scalar>::HasDiv),*/ // <- vectorization for integer is currently disabled
+    IsRepeatable = true
+  };
+};
+template <typename Scalar, typename PacketType> struct linspaced_op
+{
+  linspaced_op(const Scalar& low, const Scalar& high, Index num_steps)
+    : impl((num_steps==1 ? high : low),high,num_steps)
+  {}
+
+  template<typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (IndexType i) const { return impl(i); }
+
+  template<typename Packet,typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(IndexType i) const { return impl.packetOp(i); }
+
+  // This proxy object handles the actual required temporaries and the different
+  // implementations (integer vs. floating point).
+  const linspaced_op_impl<Scalar,PacketType,NumTraits<Scalar>::IsInteger> impl;
+};
+
+// Linear access is automatically determined from the operator() prototypes available for the given functor.
+// If it exposes an operator()(i,j), then we assume the i and j coefficients are required independently
+// and linear access is not possible. In all other cases, linear access is enabled.
+// Users should not have to deal with this structure.
+template<typename Functor> struct functor_has_linear_access { enum { ret = !has_binary_operator<Functor>::value }; };
+
+// For unreliable compilers, let's specialize the has_*ary_operator
+// helpers so that at least built-in nullary functors work fine.
+#if !( (EIGEN_COMP_MSVC>1600) || (EIGEN_GNUC_AT_LEAST(4,8)) || (EIGEN_COMP_ICC>=1600))
+template<typename Scalar,typename IndexType>
+struct has_nullary_operator<scalar_constant_op<Scalar>,IndexType> { enum { value = 1}; };
+template<typename Scalar,typename IndexType>
+struct has_unary_operator<scalar_constant_op<Scalar>,IndexType> { enum { value = 0}; };
+template<typename Scalar,typename IndexType>
+struct has_binary_operator<scalar_constant_op<Scalar>,IndexType> { enum { value = 0}; };
+
+template<typename Scalar,typename IndexType>
+struct has_nullary_operator<scalar_identity_op<Scalar>,IndexType> { enum { value = 0}; };
+template<typename Scalar,typename IndexType>
+struct has_unary_operator<scalar_identity_op<Scalar>,IndexType> { enum { value = 0}; };
+template<typename Scalar,typename IndexType>
+struct has_binary_operator<scalar_identity_op<Scalar>,IndexType> { enum { value = 1}; };
+
+template<typename Scalar, typename PacketType,typename IndexType>
+struct has_nullary_operator<linspaced_op<Scalar,PacketType>,IndexType> { enum { value = 0}; };
+template<typename Scalar, typename PacketType,typename IndexType>
+struct has_unary_operator<linspaced_op<Scalar,PacketType>,IndexType> { enum { value = 1}; };
+template<typename Scalar, typename PacketType,typename IndexType>
+struct has_binary_operator<linspaced_op<Scalar,PacketType>,IndexType> { enum { value = 0}; };
+
+template<typename Scalar,typename IndexType>
+struct has_nullary_operator<scalar_random_op<Scalar>,IndexType> { enum { value = 1}; };
+template<typename Scalar,typename IndexType>
+struct has_unary_operator<scalar_random_op<Scalar>,IndexType> { enum { value = 0}; };
+template<typename Scalar,typename IndexType>
+struct has_binary_operator<scalar_random_op<Scalar>,IndexType> { enum { value = 0}; };
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_NULLARY_FUNCTORS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/functors/StlFunctors.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/functors/StlFunctors.h
new file mode 100644
index 00000000..6df3fa50
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/functors/StlFunctors.h
@@ -0,0 +1,132 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STL_FUNCTORS_H
+#define EIGEN_STL_FUNCTORS_H
+
+namespace Eigen {
+
+namespace internal {
+
+// default functor traits for STL functors:
+
+template<typename T>
+struct functor_traits<std::multiplies<T> >
+{ enum { Cost = NumTraits<T>::MulCost, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::divides<T> >
+{ enum { Cost = NumTraits<T>::MulCost, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::plus<T> >
+{ enum { Cost = NumTraits<T>::AddCost, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::minus<T> >
+{ enum { Cost = NumTraits<T>::AddCost, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::negate<T> >
+{ enum { Cost = NumTraits<T>::AddCost, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::logical_or<T> >
+{ enum { Cost = 1, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::logical_and<T> >
+{ enum { Cost = 1, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::logical_not<T> >
+{ enum { Cost = 1, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::greater<T> >
+{ enum { Cost = 1, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::less<T> >
+{ enum { Cost = 1, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::greater_equal<T> >
+{ enum { Cost = 1, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::less_equal<T> >
+{ enum { Cost = 1, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::equal_to<T> >
+{ enum { Cost = 1, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::not_equal_to<T> >
+{ enum { Cost = 1, PacketAccess = false }; };
+
+#if (__cplusplus < 201103L) && (EIGEN_COMP_MSVC <= 1900)
+// std::binder* are deprecated since c++11 and will be removed in c++17
+template<typename T>
+struct functor_traits<std::binder2nd<T> >
+{ enum { Cost = functor_traits<T>::Cost, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::binder1st<T> >
+{ enum { Cost = functor_traits<T>::Cost, PacketAccess = false }; };
+#endif
+
+template<typename T>
+struct functor_traits<std::unary_negate<T> >
+{ enum { Cost = 1 + functor_traits<T>::Cost, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::binary_negate<T> >
+{ enum { Cost = 1 + functor_traits<T>::Cost, PacketAccess = false }; };
+
+#ifdef EIGEN_STDEXT_SUPPORT
+
+template<typename T0,typename T1>
+struct functor_traits<std::project1st<T0,T1> >
+{ enum { Cost = 0, PacketAccess = false }; };
+
+template<typename T0,typename T1>
+struct functor_traits<std::project2nd<T0,T1> >
+{ enum { Cost = 0, PacketAccess = false }; };
+
+template<typename T0,typename T1>
+struct functor_traits<std::select2nd<std::pair<T0,T1> > >
+{ enum { Cost = 0, PacketAccess = false }; };
+
+template<typename T0,typename T1>
+struct functor_traits<std::select1st<std::pair<T0,T1> > >
+{ enum { Cost = 0, PacketAccess = false }; };
+
+template<typename T0,typename T1>
+struct functor_traits<std::unary_compose<T0,T1> >
+{ enum { Cost = functor_traits<T0>::Cost + functor_traits<T1>::Cost, PacketAccess = false }; };
+
+template<typename T0,typename T1,typename T2>
+struct functor_traits<std::binary_compose<T0,T1,T2> >
+{ enum { Cost = functor_traits<T0>::Cost + functor_traits<T1>::Cost + functor_traits<T2>::Cost, PacketAccess = false }; };
+
+#endif // EIGEN_STDEXT_SUPPORT
+
+// allow to add new functors and specializations of functor_traits from outside Eigen.
+// this macro is really needed because functor_traits must be specialized after it is declared but before it is used...
+#ifdef EIGEN_FUNCTORS_PLUGIN
+#include EIGEN_FUNCTORS_PLUGIN
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_STL_FUNCTORS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/functors/TernaryFunctors.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/functors/TernaryFunctors.h
new file mode 100644
index 00000000..b254e96c
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/functors/TernaryFunctors.h
@@ -0,0 +1,25 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Eugene Brevdo <ebrevdo@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TERNARY_FUNCTORS_H
+#define EIGEN_TERNARY_FUNCTORS_H
+
+namespace Eigen {
+
+namespace internal {
+
+//---------- associative ternary functors ----------
+
+
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TERNARY_FUNCTORS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/functors/UnaryFunctors.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/functors/UnaryFunctors.h
new file mode 100644
index 00000000..bfc04655
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/functors/UnaryFunctors.h
@@ -0,0 +1,830 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_UNARY_FUNCTORS_H
+#define EIGEN_UNARY_FUNCTORS_H
+
+namespace Eigen {
+
+namespace internal {
+
+/** \internal
+  * \brief Template functor to compute the opposite of a scalar
+  *
+  * \sa class CwiseUnaryOp, MatrixBase::operator-
+  */
+template<typename Scalar> struct scalar_opposite_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_opposite_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { return -a; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
+  { return internal::pnegate(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_opposite_op<Scalar> >
+{ enum {
+    Cost = NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasNegate };
+};
+
+/** \internal
+  * \brief Template functor to compute the absolute value of a scalar
+  *
+  * \sa class CwiseUnaryOp, Cwise::abs
+  */
+template<typename Scalar> struct scalar_abs_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_abs_op)
+  typedef typename NumTraits<Scalar>::Real result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a) const { return numext::abs(a); }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
+  { return internal::pabs(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_abs_op<Scalar> >
+{
+  enum {
+    Cost = NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasAbs
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the score of a scalar, to chose a pivot
+  *
+  * \sa class CwiseUnaryOp
+  */
+template<typename Scalar> struct scalar_score_coeff_op : scalar_abs_op<Scalar>
+{
+  typedef void Score_is_abs;
+};
+template<typename Scalar>
+struct functor_traits<scalar_score_coeff_op<Scalar> > : functor_traits<scalar_abs_op<Scalar> > {};
+
+/* Avoid recomputing abs when we know the score and they are the same. Not a true Eigen functor.  */
+template<typename Scalar, typename=void> struct abs_knowing_score
+{
+  EIGEN_EMPTY_STRUCT_CTOR(abs_knowing_score)
+  typedef typename NumTraits<Scalar>::Real result_type;
+  template<typename Score>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a, const Score&) const { return numext::abs(a); }
+};
+template<typename Scalar> struct abs_knowing_score<Scalar, typename scalar_score_coeff_op<Scalar>::Score_is_abs>
+{
+  EIGEN_EMPTY_STRUCT_CTOR(abs_knowing_score)
+  typedef typename NumTraits<Scalar>::Real result_type;
+  template<typename Scal>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const Scal&, const result_type& a) const { return a; }
+};
+
+/** \internal
+  * \brief Template functor to compute the squared absolute value of a scalar
+  *
+  * \sa class CwiseUnaryOp, Cwise::abs2
+  */
+template<typename Scalar> struct scalar_abs2_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_abs2_op)
+  typedef typename NumTraits<Scalar>::Real result_type;
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a) const { return numext::abs2(a); }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
+  { return internal::pmul(a,a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_abs2_op<Scalar> >
+{ enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasAbs2 }; };
+
+/** \internal
+  * \brief Template functor to compute the conjugate of a complex value
+  *
+  * \sa class CwiseUnaryOp, MatrixBase::conjugate()
+  */
+template<typename Scalar> struct scalar_conjugate_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_conjugate_op)
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { using numext::conj; return conj(a); }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const { return internal::pconj(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_conjugate_op<Scalar> >
+{
+  enum {
+    Cost = NumTraits<Scalar>::IsComplex ? NumTraits<Scalar>::AddCost : 0,
+    PacketAccess = packet_traits<Scalar>::HasConj
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the phase angle of a complex
+  *
+  * \sa class CwiseUnaryOp, Cwise::arg
+  */
+template<typename Scalar> struct scalar_arg_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_arg_op)
+  typedef typename NumTraits<Scalar>::Real result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a) const { using numext::arg; return arg(a); }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
+  { return internal::parg(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_arg_op<Scalar> >
+{
+  enum {
+    Cost = NumTraits<Scalar>::IsComplex ? 5 * NumTraits<Scalar>::MulCost : NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasArg
+  };
+};
+/** \internal
+  * \brief Template functor to cast a scalar to another type
+  *
+  * \sa class CwiseUnaryOp, MatrixBase::cast()
+  */
+template<typename Scalar, typename NewType>
+struct scalar_cast_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cast_op)
+  typedef NewType result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const NewType operator() (const Scalar& a) const { return cast<Scalar, NewType>(a); }
+};
+template<typename Scalar, typename NewType>
+struct functor_traits<scalar_cast_op<Scalar,NewType> >
+{ enum { Cost = is_same<Scalar, NewType>::value ? 0 : NumTraits<NewType>::AddCost, PacketAccess = false }; };
+
+/** \internal
+  * \brief Template functor to extract the real part of a complex
+  *
+  * \sa class CwiseUnaryOp, MatrixBase::real()
+  */
+template<typename Scalar>
+struct scalar_real_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_real_op)
+  typedef typename NumTraits<Scalar>::Real result_type;
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const { return numext::real(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_real_op<Scalar> >
+{ enum { Cost = 0, PacketAccess = false }; };
+
+/** \internal
+  * \brief Template functor to extract the imaginary part of a complex
+  *
+  * \sa class CwiseUnaryOp, MatrixBase::imag()
+  */
+template<typename Scalar>
+struct scalar_imag_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_imag_op)
+  typedef typename NumTraits<Scalar>::Real result_type;
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const { return numext::imag(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_imag_op<Scalar> >
+{ enum { Cost = 0, PacketAccess = false }; };
+
+/** \internal
+  * \brief Template functor to extract the real part of a complex as a reference
+  *
+  * \sa class CwiseUnaryOp, MatrixBase::real()
+  */
+template<typename Scalar>
+struct scalar_real_ref_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_real_ref_op)
+  typedef typename NumTraits<Scalar>::Real result_type;
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE result_type& operator() (const Scalar& a) const { return numext::real_ref(*const_cast<Scalar*>(&a)); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_real_ref_op<Scalar> >
+{ enum { Cost = 0, PacketAccess = false }; };
+
+/** \internal
+  * \brief Template functor to extract the imaginary part of a complex as a reference
+  *
+  * \sa class CwiseUnaryOp, MatrixBase::imag()
+  */
+template<typename Scalar>
+struct scalar_imag_ref_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_imag_ref_op)
+  typedef typename NumTraits<Scalar>::Real result_type;
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE result_type& operator() (const Scalar& a) const { return numext::imag_ref(*const_cast<Scalar*>(&a)); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_imag_ref_op<Scalar> >
+{ enum { Cost = 0, PacketAccess = false }; };
+
+/** \internal
+  *
+  * \brief Template functor to compute the exponential of a scalar
+  *
+  * \sa class CwiseUnaryOp, Cwise::exp()
+  */
+template<typename Scalar> struct scalar_exp_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_exp_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::exp(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::pexp(a); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_exp_op<Scalar> > {
+  enum {
+    PacketAccess = packet_traits<Scalar>::HasExp,
+    // The following numbers are based on the AVX implementation.
+#ifdef EIGEN_VECTORIZE_FMA
+    // Haswell can issue 2 add/mul/madd per cycle.
+    Cost =
+    (sizeof(Scalar) == 4
+     // float: 8 pmadd, 4 pmul, 2 padd/psub, 6 other
+     ? (8 * NumTraits<Scalar>::AddCost + 6 * NumTraits<Scalar>::MulCost)
+     // double: 7 pmadd, 5 pmul, 3 padd/psub, 1 div,  13 other
+     : (14 * NumTraits<Scalar>::AddCost +
+        6 * NumTraits<Scalar>::MulCost +
+        scalar_div_cost<Scalar,packet_traits<Scalar>::HasDiv>::value))
+#else
+    Cost =
+    (sizeof(Scalar) == 4
+     // float: 7 pmadd, 6 pmul, 4 padd/psub, 10 other
+     ? (21 * NumTraits<Scalar>::AddCost + 13 * NumTraits<Scalar>::MulCost)
+     // double: 7 pmadd, 5 pmul, 3 padd/psub, 1 div,  13 other
+     : (23 * NumTraits<Scalar>::AddCost +
+        12 * NumTraits<Scalar>::MulCost +
+        scalar_div_cost<Scalar,packet_traits<Scalar>::HasDiv>::value))
+#endif
+  };
+};
+
+/** \internal
+  *
+  * \brief Template functor to compute the exponential of a scalar - 1.
+  *
+  * \sa class CwiseUnaryOp, ArrayBase::expm1()
+  */
+template<typename Scalar> struct scalar_expm1_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_expm1_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::expm1(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::pexpm1(a); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_expm1_op<Scalar> > {
+  enum {
+    PacketAccess = packet_traits<Scalar>::HasExpm1,
+    Cost = functor_traits<scalar_exp_op<Scalar> >::Cost // TODO measure cost of expm1
+  };
+};
+
+/** \internal
+  *
+  * \brief Template functor to compute the logarithm of a scalar
+  *
+  * \sa class CwiseUnaryOp, ArrayBase::log()
+  */
+template<typename Scalar> struct scalar_log_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_log_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::log(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::plog(a); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_log_op<Scalar> > {
+  enum {
+    PacketAccess = packet_traits<Scalar>::HasLog,
+    Cost =
+    (PacketAccess
+     // The following numbers are based on the AVX implementation.
+#ifdef EIGEN_VECTORIZE_FMA
+     // 8 pmadd, 6 pmul, 8 padd/psub, 16 other, can issue 2 add/mul/madd per cycle.
+     ? (20 * NumTraits<Scalar>::AddCost + 7 * NumTraits<Scalar>::MulCost)
+#else
+     // 8 pmadd, 6 pmul, 8 padd/psub, 20 other
+     ? (36 * NumTraits<Scalar>::AddCost + 14 * NumTraits<Scalar>::MulCost)
+#endif
+     // Measured cost of std::log.
+     : sizeof(Scalar)==4 ? 40 : 85)
+  };
+};
+
+/** \internal
+  *
+  * \brief Template functor to compute the logarithm of 1 plus a scalar value
+  *
+  * \sa class CwiseUnaryOp, ArrayBase::log1p()
+  */
+template<typename Scalar> struct scalar_log1p_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_log1p_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::log1p(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::plog1p(a); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_log1p_op<Scalar> > {
+  enum {
+    PacketAccess = packet_traits<Scalar>::HasLog1p,
+    Cost = functor_traits<scalar_log_op<Scalar> >::Cost // TODO measure cost of log1p
+  };
+};
+
+/** \internal
+  *
+  * \brief Template functor to compute the base-10 logarithm of a scalar
+  *
+  * \sa class CwiseUnaryOp, Cwise::log10()
+  */
+template<typename Scalar> struct scalar_log10_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_log10_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { EIGEN_USING_STD_MATH(log10) return log10(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::plog10(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_log10_op<Scalar> >
+{ enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasLog10 }; };
+
+/** \internal
+  * \brief Template functor to compute the square root of a scalar
+  * \sa class CwiseUnaryOp, Cwise::sqrt()
+  */
+template<typename Scalar> struct scalar_sqrt_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_sqrt_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::sqrt(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::psqrt(a); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_sqrt_op<Scalar> > {
+  enum {
+#if EIGEN_FAST_MATH
+    // The following numbers are based on the AVX implementation.
+    Cost = (sizeof(Scalar) == 8 ? 28
+                                // 4 pmul, 1 pmadd, 3 other
+                                : (3 * NumTraits<Scalar>::AddCost +
+                                   5 * NumTraits<Scalar>::MulCost)),
+#else
+    // The following numbers are based on min VSQRT throughput on Haswell.
+    Cost = (sizeof(Scalar) == 8 ? 28 : 14),
+#endif
+    PacketAccess = packet_traits<Scalar>::HasSqrt
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the reciprocal square root of a scalar
+  * \sa class CwiseUnaryOp, Cwise::rsqrt()
+  */
+template<typename Scalar> struct scalar_rsqrt_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_rsqrt_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return Scalar(1)/numext::sqrt(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::prsqrt(a); }
+};
+
+template<typename Scalar>
+struct functor_traits<scalar_rsqrt_op<Scalar> >
+{ enum {
+    Cost = 5 * NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasRsqrt
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the cosine of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::cos()
+  */
+template<typename Scalar> struct scalar_cos_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cos_op)
+  EIGEN_DEVICE_FUNC inline Scalar operator() (const Scalar& a) const { return numext::cos(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::pcos(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_cos_op<Scalar> >
+{
+  enum {
+    Cost = 5 * NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasCos
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the sine of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::sin()
+  */
+template<typename Scalar> struct scalar_sin_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_sin_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::sin(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::psin(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_sin_op<Scalar> >
+{
+  enum {
+    Cost = 5 * NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasSin
+  };
+};
+
+
+/** \internal
+  * \brief Template functor to compute the tan of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::tan()
+  */
+template<typename Scalar> struct scalar_tan_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_tan_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::tan(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::ptan(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_tan_op<Scalar> >
+{
+  enum {
+    Cost = 5 * NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasTan
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the arc cosine of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::acos()
+  */
+template<typename Scalar> struct scalar_acos_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_acos_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::acos(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::pacos(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_acos_op<Scalar> >
+{
+  enum {
+    Cost = 5 * NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasACos
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the arc sine of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::asin()
+  */
+template<typename Scalar> struct scalar_asin_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_asin_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::asin(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::pasin(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_asin_op<Scalar> >
+{
+  enum {
+    Cost = 5 * NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasASin
+  };
+};
+
+
+/** \internal
+  * \brief Template functor to compute the atan of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::atan()
+  */
+template<typename Scalar> struct scalar_atan_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_atan_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::atan(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::patan(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_atan_op<Scalar> >
+{
+  enum {
+    Cost = 5 * NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasATan
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the tanh of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::tanh()
+  */
+template <typename Scalar>
+struct scalar_tanh_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_tanh_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator()(const Scalar& a) const { return numext::tanh(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& x) const { return ptanh(x); }
+};
+
+template <typename Scalar>
+struct functor_traits<scalar_tanh_op<Scalar> > {
+  enum {
+    PacketAccess = packet_traits<Scalar>::HasTanh,
+    Cost = ( (EIGEN_FAST_MATH && is_same<Scalar,float>::value)
+// The following numbers are based on the AVX implementation,
+#ifdef EIGEN_VECTORIZE_FMA
+                // Haswell can issue 2 add/mul/madd per cycle.
+                // 9 pmadd, 2 pmul, 1 div, 2 other
+                ? (2 * NumTraits<Scalar>::AddCost +
+                   6 * NumTraits<Scalar>::MulCost +
+                   scalar_div_cost<Scalar,packet_traits<Scalar>::HasDiv>::value)
+#else
+                ? (11 * NumTraits<Scalar>::AddCost +
+                   11 * NumTraits<Scalar>::MulCost +
+                   scalar_div_cost<Scalar,packet_traits<Scalar>::HasDiv>::value)
+#endif
+                // This number assumes a naive implementation of tanh
+                : (6 * NumTraits<Scalar>::AddCost +
+                   3 * NumTraits<Scalar>::MulCost +
+                   2 * scalar_div_cost<Scalar,packet_traits<Scalar>::HasDiv>::value +
+                   functor_traits<scalar_exp_op<Scalar> >::Cost))
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the sinh of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::sinh()
+  */
+template<typename Scalar> struct scalar_sinh_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_sinh_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::sinh(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::psinh(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_sinh_op<Scalar> >
+{
+  enum {
+    Cost = 5 * NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasSinh
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the cosh of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::cosh()
+  */
+template<typename Scalar> struct scalar_cosh_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cosh_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::cosh(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::pcosh(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_cosh_op<Scalar> >
+{
+  enum {
+    Cost = 5 * NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasCosh
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the inverse of a scalar
+  * \sa class CwiseUnaryOp, Cwise::inverse()
+  */
+template<typename Scalar>
+struct scalar_inverse_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_inverse_op)
+  EIGEN_DEVICE_FUNC inline Scalar operator() (const Scalar& a) const { return Scalar(1)/a; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC inline const Packet packetOp(const Packet& a) const
+  { return internal::pdiv(pset1<Packet>(Scalar(1)),a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_inverse_op<Scalar> >
+{ enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasDiv }; };
+
+/** \internal
+  * \brief Template functor to compute the square of a scalar
+  * \sa class CwiseUnaryOp, Cwise::square()
+  */
+template<typename Scalar>
+struct scalar_square_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_square_op)
+  EIGEN_DEVICE_FUNC inline Scalar operator() (const Scalar& a) const { return a*a; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC inline const Packet packetOp(const Packet& a) const
+  { return internal::pmul(a,a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_square_op<Scalar> >
+{ enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasMul }; };
+
+/** \internal
+  * \brief Template functor to compute the cube of a scalar
+  * \sa class CwiseUnaryOp, Cwise::cube()
+  */
+template<typename Scalar>
+struct scalar_cube_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cube_op)
+  EIGEN_DEVICE_FUNC inline Scalar operator() (const Scalar& a) const { return a*a*a; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC inline const Packet packetOp(const Packet& a) const
+  { return internal::pmul(a,pmul(a,a)); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_cube_op<Scalar> >
+{ enum { Cost = 2*NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasMul }; };
+
+/** \internal
+  * \brief Template functor to compute the rounded value of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::round()
+  */
+template<typename Scalar> struct scalar_round_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_round_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { return numext::round(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::pround(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_round_op<Scalar> >
+{
+  enum {
+    Cost = NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasRound
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the floor of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::floor()
+  */
+template<typename Scalar> struct scalar_floor_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_floor_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { return numext::floor(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::pfloor(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_floor_op<Scalar> >
+{
+  enum {
+    Cost = NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasFloor
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the ceil of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::ceil()
+  */
+template<typename Scalar> struct scalar_ceil_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_ceil_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { return numext::ceil(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::pceil(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_ceil_op<Scalar> >
+{
+  enum {
+    Cost = NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasCeil
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute whether a scalar is NaN
+  * \sa class CwiseUnaryOp, ArrayBase::isnan()
+  */
+template<typename Scalar> struct scalar_isnan_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_isnan_op)
+  typedef bool result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const {
+#if defined(__SYCL_DEVICE_ONLY__)
+    return numext::isnan(a);
+#else  
+    return (numext::isnan)(a);
+#endif
+  }
+};
+template<typename Scalar>
+struct functor_traits<scalar_isnan_op<Scalar> >
+{
+  enum {
+    Cost = NumTraits<Scalar>::MulCost,
+    PacketAccess = false
+  };
+};
+
+/** \internal
+  * \brief Template functor to check whether a scalar is +/-inf
+  * \sa class CwiseUnaryOp, ArrayBase::isinf()
+  */
+template<typename Scalar> struct scalar_isinf_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_isinf_op)
+  typedef bool result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const {
+#if defined(__SYCL_DEVICE_ONLY__)
+    return numext::isinf(a);
+#else
+    return (numext::isinf)(a);
+#endif
+  }
+};
+template<typename Scalar>
+struct functor_traits<scalar_isinf_op<Scalar> >
+{
+  enum {
+    Cost = NumTraits<Scalar>::MulCost,
+    PacketAccess = false
+  };
+};
+
+/** \internal
+  * \brief Template functor to check whether a scalar has a finite value
+  * \sa class CwiseUnaryOp, ArrayBase::isfinite()
+  */
+template<typename Scalar> struct scalar_isfinite_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_isfinite_op)
+  typedef bool result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const {
+#if defined(__SYCL_DEVICE_ONLY__)
+    return numext::isfinite(a);
+#else
+    return (numext::isfinite)(a);
+#endif
+  }
+};
+template<typename Scalar>
+struct functor_traits<scalar_isfinite_op<Scalar> >
+{
+  enum {
+    Cost = NumTraits<Scalar>::MulCost,
+    PacketAccess = false
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the logical not of a boolean
+  *
+  * \sa class CwiseUnaryOp, ArrayBase::operator!
+  */
+template<typename Scalar> struct scalar_boolean_not_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_boolean_not_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator() (const bool& a) const { return !a; }
+};
+template<typename Scalar>
+struct functor_traits<scalar_boolean_not_op<Scalar> > {
+  enum {
+    Cost = NumTraits<bool>::AddCost,
+    PacketAccess = false
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the signum of a scalar
+  * \sa class CwiseUnaryOp, Cwise::sign()
+  */
+template<typename Scalar,bool iscpx=(NumTraits<Scalar>::IsComplex!=0) > struct scalar_sign_op;
+template<typename Scalar>
+struct scalar_sign_op<Scalar,false> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_sign_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const
+  {
+      return Scalar( (a>Scalar(0)) - (a<Scalar(0)) );
+  }
+  //TODO
+  //template <typename Packet>
+  //EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::psign(a); }
+};
+template<typename Scalar>
+struct scalar_sign_op<Scalar,true> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_sign_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const
+  {
+    typedef typename NumTraits<Scalar>::Real real_type;
+    real_type aa = numext::abs(a);
+    if (aa==real_type(0))
+      return Scalar(0);
+    aa = real_type(1)/aa;
+    return Scalar(real(a)*aa, imag(a)*aa );
+  }
+  //TODO
+  //template <typename Packet>
+  //EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::psign(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_sign_op<Scalar> >
+{ enum {
+    Cost = 
+        NumTraits<Scalar>::IsComplex
+        ? ( 8*NumTraits<Scalar>::MulCost  ) // roughly
+        : ( 3*NumTraits<Scalar>::AddCost),
+    PacketAccess = packet_traits<Scalar>::HasSign
+  };
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_FUNCTORS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/GeneralBlockPanelKernel.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/GeneralBlockPanelKernel.h
new file mode 100644
index 00000000..45230bce
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/GeneralBlockPanelKernel.h
@@ -0,0 +1,2149 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GENERAL_BLOCK_PANEL_H
+#define EIGEN_GENERAL_BLOCK_PANEL_H
+
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename _LhsScalar, typename _RhsScalar, bool _ConjLhs=false, bool _ConjRhs=false>
+class gebp_traits;
+
+
+/** \internal \returns b if a<=0, and returns a otherwise. */
+inline std::ptrdiff_t manage_caching_sizes_helper(std::ptrdiff_t a, std::ptrdiff_t b)
+{
+  return a<=0 ? b : a;
+}
+
+#if EIGEN_ARCH_i386_OR_x86_64
+const std::ptrdiff_t defaultL1CacheSize = 32*1024;
+const std::ptrdiff_t defaultL2CacheSize = 256*1024;
+const std::ptrdiff_t defaultL3CacheSize = 2*1024*1024;
+#else
+const std::ptrdiff_t defaultL1CacheSize = 16*1024;
+const std::ptrdiff_t defaultL2CacheSize = 512*1024;
+const std::ptrdiff_t defaultL3CacheSize = 512*1024;
+#endif
+
+/** \internal */
+struct CacheSizes {
+  CacheSizes(): m_l1(-1),m_l2(-1),m_l3(-1) {
+    int l1CacheSize, l2CacheSize, l3CacheSize;
+    queryCacheSizes(l1CacheSize, l2CacheSize, l3CacheSize);
+    m_l1 = manage_caching_sizes_helper(l1CacheSize, defaultL1CacheSize);
+    m_l2 = manage_caching_sizes_helper(l2CacheSize, defaultL2CacheSize);
+    m_l3 = manage_caching_sizes_helper(l3CacheSize, defaultL3CacheSize);
+  }
+
+  std::ptrdiff_t m_l1;
+  std::ptrdiff_t m_l2;
+  std::ptrdiff_t m_l3;
+};
+
+
+/** \internal */
+inline void manage_caching_sizes(Action action, std::ptrdiff_t* l1, std::ptrdiff_t* l2, std::ptrdiff_t* l3)
+{
+  static CacheSizes m_cacheSizes;
+
+  if(action==SetAction)
+  {
+    // set the cpu cache size and cache all block sizes from a global cache size in byte
+    eigen_internal_assert(l1!=0 && l2!=0);
+    m_cacheSizes.m_l1 = *l1;
+    m_cacheSizes.m_l2 = *l2;
+    m_cacheSizes.m_l3 = *l3;
+  }
+  else if(action==GetAction)
+  {
+    eigen_internal_assert(l1!=0 && l2!=0);
+    *l1 = m_cacheSizes.m_l1;
+    *l2 = m_cacheSizes.m_l2;
+    *l3 = m_cacheSizes.m_l3;
+  }
+  else
+  {
+    eigen_internal_assert(false);
+  }
+}
+
+/* Helper for computeProductBlockingSizes.
+ *
+ * Given a m x k times k x n matrix product of scalar types \c LhsScalar and \c RhsScalar,
+ * this function computes the blocking size parameters along the respective dimensions
+ * for matrix products and related algorithms. The blocking sizes depends on various
+ * parameters:
+ * - the L1 and L2 cache sizes,
+ * - the register level blocking sizes defined by gebp_traits,
+ * - the number of scalars that fit into a packet (when vectorization is enabled).
+ *
+ * \sa setCpuCacheSizes */
+
+template<typename LhsScalar, typename RhsScalar, int KcFactor, typename Index>
+void evaluateProductBlockingSizesHeuristic(Index& k, Index& m, Index& n, Index num_threads = 1)
+{
+  typedef gebp_traits<LhsScalar,RhsScalar> Traits;
+
+  // Explanations:
+  // Let's recall that the product algorithms form mc x kc vertical panels A' on the lhs and
+  // kc x nc blocks B' on the rhs. B' has to fit into L2/L3 cache. Moreover, A' is processed
+  // per mr x kc horizontal small panels where mr is the blocking size along the m dimension
+  // at the register level. This small horizontal panel has to stay within L1 cache.
+  std::ptrdiff_t l1, l2, l3;
+  manage_caching_sizes(GetAction, &l1, &l2, &l3);
+
+  if (num_threads > 1) {
+    typedef typename Traits::ResScalar ResScalar;
+    enum {
+      kdiv = KcFactor * (Traits::mr * sizeof(LhsScalar) + Traits::nr * sizeof(RhsScalar)),
+      ksub = Traits::mr * Traits::nr * sizeof(ResScalar),
+      kr = 8,
+      mr = Traits::mr,
+      nr = Traits::nr
+    };
+    // Increasing k gives us more time to prefetch the content of the "C"
+    // registers. However once the latency is hidden there is no point in
+    // increasing the value of k, so we'll cap it at 320 (value determined
+    // experimentally).
+    const Index k_cache = (numext::mini<Index>)((l1-ksub)/kdiv, 320);
+    if (k_cache < k) {
+      k = k_cache - (k_cache % kr);
+      eigen_internal_assert(k > 0);
+    }
+
+    const Index n_cache = (l2-l1) / (nr * sizeof(RhsScalar) * k);
+    const Index n_per_thread = numext::div_ceil(n, num_threads);
+    if (n_cache <= n_per_thread) {
+      // Don't exceed the capacity of the l2 cache.
+      eigen_internal_assert(n_cache >= static_cast<Index>(nr));
+      n = n_cache - (n_cache % nr);
+      eigen_internal_assert(n > 0);
+    } else {
+      n = (numext::mini<Index>)(n, (n_per_thread + nr - 1) - ((n_per_thread + nr - 1) % nr));
+    }
+
+    if (l3 > l2) {
+      // l3 is shared between all cores, so we'll give each thread its own chunk of l3.
+      const Index m_cache = (l3-l2) / (sizeof(LhsScalar) * k * num_threads);
+      const Index m_per_thread = numext::div_ceil(m, num_threads);
+      if(m_cache < m_per_thread && m_cache >= static_cast<Index>(mr)) {
+        m = m_cache - (m_cache % mr);
+        eigen_internal_assert(m > 0);
+      } else {
+        m = (numext::mini<Index>)(m, (m_per_thread + mr - 1) - ((m_per_thread + mr - 1) % mr));
+      }
+    }
+  }
+  else {
+    // In unit tests we do not want to use extra large matrices,
+    // so we reduce the cache size to check the blocking strategy is not flawed
+#ifdef EIGEN_DEBUG_SMALL_PRODUCT_BLOCKS
+    l1 = 9*1024;
+    l2 = 32*1024;
+    l3 = 512*1024;
+#endif
+
+    // Early return for small problems because the computation below are time consuming for small problems.
+    // Perhaps it would make more sense to consider k*n*m??
+    // Note that for very tiny problem, this function should be bypassed anyway
+    // because we use the coefficient-based implementation for them.
+    if((numext::maxi)(k,(numext::maxi)(m,n))<48)
+      return;
+
+    typedef typename Traits::ResScalar ResScalar;
+    enum {
+      k_peeling = 8,
+      k_div = KcFactor * (Traits::mr * sizeof(LhsScalar) + Traits::nr * sizeof(RhsScalar)),
+      k_sub = Traits::mr * Traits::nr * sizeof(ResScalar)
+    };
+
+    // ---- 1st level of blocking on L1, yields kc ----
+
+    // Blocking on the third dimension (i.e., k) is chosen so that an horizontal panel
+    // of size mr x kc of the lhs plus a vertical panel of kc x nr of the rhs both fits within L1 cache.
+    // We also include a register-level block of the result (mx x nr).
+    // (In an ideal world only the lhs panel would stay in L1)
+    // Moreover, kc has to be a multiple of 8 to be compatible with loop peeling, leading to a maximum blocking size of:
+    const Index max_kc = numext::maxi<Index>(((l1-k_sub)/k_div) & (~(k_peeling-1)),1);
+    const Index old_k = k;
+    if(k>max_kc)
+    {
+      // We are really blocking on the third dimension:
+      // -> reduce blocking size to make sure the last block is as large as possible
+      //    while keeping the same number of sweeps over the result.
+      k = (k%max_kc)==0 ? max_kc
+                        : max_kc - k_peeling * ((max_kc-1-(k%max_kc))/(k_peeling*(k/max_kc+1)));
+
+      eigen_internal_assert(((old_k/k) == (old_k/max_kc)) && "the number of sweeps has to remain the same");
+    }
+
+    // ---- 2nd level of blocking on max(L2,L3), yields nc ----
+
+    // TODO find a reliable way to get the actual amount of cache per core to use for 2nd level blocking, that is:
+    //      actual_l2 = max(l2, l3/nb_core_sharing_l3)
+    // The number below is quite conservative: it is better to underestimate the cache size rather than overestimating it)
+    // For instance, it corresponds to 6MB of L3 shared among 4 cores.
+    #ifdef EIGEN_DEBUG_SMALL_PRODUCT_BLOCKS
+    const Index actual_l2 = l3;
+    #else
+    const Index actual_l2 = 1572864; // == 1.5 MB
+    #endif
+
+    // Here, nc is chosen such that a block of kc x nc of the rhs fit within half of L2.
+    // The second half is implicitly reserved to access the result and lhs coefficients.
+    // When k<max_kc, then nc can arbitrarily growth. In practice, it seems to be fruitful
+    // to limit this growth: we bound nc to growth by a factor x1.5.
+    // However, if the entire lhs block fit within L1, then we are not going to block on the rows at all,
+    // and it becomes fruitful to keep the packed rhs blocks in L1 if there is enough remaining space.
+    Index max_nc;
+    const Index lhs_bytes = m * k * sizeof(LhsScalar);
+    const Index remaining_l1 = l1- k_sub - lhs_bytes;
+    if(remaining_l1 >= Index(Traits::nr*sizeof(RhsScalar))*k)
+    {
+      // L1 blocking
+      max_nc = remaining_l1 / (k*sizeof(RhsScalar));
+    }
+    else
+    {
+      // L2 blocking
+      max_nc = (3*actual_l2)/(2*2*max_kc*sizeof(RhsScalar));
+    }
+    // WARNING Below, we assume that Traits::nr is a power of two.
+    Index nc = numext::mini<Index>(actual_l2/(2*k*sizeof(RhsScalar)), max_nc) & (~(Traits::nr-1));
+    if(n>nc)
+    {
+      // We are really blocking over the columns:
+      // -> reduce blocking size to make sure the last block is as large as possible
+      //    while keeping the same number of sweeps over the packed lhs.
+      //    Here we allow one more sweep if this gives us a perfect match, thus the commented "-1"
+      n = (n%nc)==0 ? nc
+                    : (nc - Traits::nr * ((nc/*-1*/-(n%nc))/(Traits::nr*(n/nc+1))));
+    }
+    else if(old_k==k)
+    {
+      // So far, no blocking at all, i.e., kc==k, and nc==n.
+      // In this case, let's perform a blocking over the rows such that the packed lhs data is kept in cache L1/L2
+      // TODO: part of this blocking strategy is now implemented within the kernel itself, so the L1-based heuristic here should be obsolete.
+      Index problem_size = k*n*sizeof(LhsScalar);
+      Index actual_lm = actual_l2;
+      Index max_mc = m;
+      if(problem_size<=1024)
+      {
+        // problem is small enough to keep in L1
+        // Let's choose m such that lhs's block fit in 1/3 of L1
+        actual_lm = l1;
+      }
+      else if(l3!=0 && problem_size<=32768)
+      {
+        // we have both L2 and L3, and problem is small enough to be kept in L2
+        // Let's choose m such that lhs's block fit in 1/3 of L2
+        actual_lm = l2;
+        max_mc = (numext::mini<Index>)(576,max_mc);
+      }
+      Index mc = (numext::mini<Index>)(actual_lm/(3*k*sizeof(LhsScalar)), max_mc);
+      if (mc > Traits::mr) mc -= mc % Traits::mr;
+      else if (mc==0) return;
+      m = (m%mc)==0 ? mc
+                    : (mc - Traits::mr * ((mc/*-1*/-(m%mc))/(Traits::mr*(m/mc+1))));
+    }
+  }
+}
+
+template <typename Index>
+inline bool useSpecificBlockingSizes(Index& k, Index& m, Index& n)
+{
+#ifdef EIGEN_TEST_SPECIFIC_BLOCKING_SIZES
+  if (EIGEN_TEST_SPECIFIC_BLOCKING_SIZES) {
+    k = numext::mini<Index>(k, EIGEN_TEST_SPECIFIC_BLOCKING_SIZE_K);
+    m = numext::mini<Index>(m, EIGEN_TEST_SPECIFIC_BLOCKING_SIZE_M);
+    n = numext::mini<Index>(n, EIGEN_TEST_SPECIFIC_BLOCKING_SIZE_N);
+    return true;
+  }
+#else
+  EIGEN_UNUSED_VARIABLE(k)
+  EIGEN_UNUSED_VARIABLE(m)
+  EIGEN_UNUSED_VARIABLE(n)
+#endif
+  return false;
+}
+
+/** \brief Computes the blocking parameters for a m x k times k x n matrix product
+  *
+  * \param[in,out] k Input: the third dimension of the product. Output: the blocking size along the same dimension.
+  * \param[in,out] m Input: the number of rows of the left hand side. Output: the blocking size along the same dimension.
+  * \param[in,out] n Input: the number of columns of the right hand side. Output: the blocking size along the same dimension.
+  *
+  * Given a m x k times k x n matrix product of scalar types \c LhsScalar and \c RhsScalar,
+  * this function computes the blocking size parameters along the respective dimensions
+  * for matrix products and related algorithms.
+  *
+  * The blocking size parameters may be evaluated:
+  *   - either by a heuristic based on cache sizes;
+  *   - or using fixed prescribed values (for testing purposes).
+  *
+  * \sa setCpuCacheSizes */
+
+template<typename LhsScalar, typename RhsScalar, int KcFactor, typename Index>
+void computeProductBlockingSizes(Index& k, Index& m, Index& n, Index num_threads = 1)
+{
+  if (!useSpecificBlockingSizes(k, m, n)) {
+    evaluateProductBlockingSizesHeuristic<LhsScalar, RhsScalar, KcFactor, Index>(k, m, n, num_threads);
+  }
+}
+
+template<typename LhsScalar, typename RhsScalar, typename Index>
+inline void computeProductBlockingSizes(Index& k, Index& m, Index& n, Index num_threads = 1)
+{
+  computeProductBlockingSizes<LhsScalar,RhsScalar,1,Index>(k, m, n, num_threads);
+}
+
+#ifdef EIGEN_HAS_SINGLE_INSTRUCTION_CJMADD
+  #define CJMADD(CJ,A,B,C,T)  C = CJ.pmadd(A,B,C);
+#else
+
+  // FIXME (a bit overkill maybe ?)
+
+  template<typename CJ, typename A, typename B, typename C, typename T> struct gebp_madd_selector {
+    EIGEN_ALWAYS_INLINE static void run(const CJ& cj, A& a, B& b, C& c, T& /*t*/)
+    {
+      c = cj.pmadd(a,b,c);
+    }
+  };
+
+  template<typename CJ, typename T> struct gebp_madd_selector<CJ,T,T,T,T> {
+    EIGEN_ALWAYS_INLINE static void run(const CJ& cj, T& a, T& b, T& c, T& t)
+    {
+      t = b; t = cj.pmul(a,t); c = padd(c,t);
+    }
+  };
+
+  template<typename CJ, typename A, typename B, typename C, typename T>
+  EIGEN_STRONG_INLINE void gebp_madd(const CJ& cj, A& a, B& b, C& c, T& t)
+  {
+    gebp_madd_selector<CJ,A,B,C,T>::run(cj,a,b,c,t);
+  }
+
+  #define CJMADD(CJ,A,B,C,T)  gebp_madd(CJ,A,B,C,T);
+//   #define CJMADD(CJ,A,B,C,T)  T = B; T = CJ.pmul(A,T); C = padd(C,T);
+#endif
+
+/* Vectorization logic
+ *  real*real: unpack rhs to constant packets, ...
+ * 
+ *  cd*cd : unpack rhs to (b_r,b_r), (b_i,b_i), mul to get (a_r b_r,a_i b_r) (a_r b_i,a_i b_i),
+ *          storing each res packet into two packets (2x2),
+ *          at the end combine them: swap the second and addsub them 
+ *  cf*cf : same but with 2x4 blocks
+ *  cplx*real : unpack rhs to constant packets, ...
+ *  real*cplx : load lhs as (a0,a0,a1,a1), and mul as usual
+ */
+template<typename _LhsScalar, typename _RhsScalar, bool _ConjLhs, bool _ConjRhs>
+class gebp_traits
+{
+public:
+  typedef _LhsScalar LhsScalar;
+  typedef _RhsScalar RhsScalar;
+  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+
+  enum {
+    ConjLhs = _ConjLhs,
+    ConjRhs = _ConjRhs,
+    Vectorizable = packet_traits<LhsScalar>::Vectorizable && packet_traits<RhsScalar>::Vectorizable,
+    LhsPacketSize = Vectorizable ? packet_traits<LhsScalar>::size : 1,
+    RhsPacketSize = Vectorizable ? packet_traits<RhsScalar>::size : 1,
+    ResPacketSize = Vectorizable ? packet_traits<ResScalar>::size : 1,
+    
+    NumberOfRegisters = EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS,
+
+    // register block size along the N direction must be 1 or 4
+    nr = 4,
+
+    // register block size along the M direction (currently, this one cannot be modified)
+    default_mr = (EIGEN_PLAIN_ENUM_MIN(16,NumberOfRegisters)/2/nr)*LhsPacketSize,
+#if defined(EIGEN_HAS_SINGLE_INSTRUCTION_MADD) && !defined(EIGEN_VECTORIZE_ALTIVEC) && !defined(EIGEN_VECTORIZE_VSX)
+    // we assume 16 registers
+    // See bug 992, if the scalar type is not vectorizable but that EIGEN_HAS_SINGLE_INSTRUCTION_MADD is defined,
+    // then using 3*LhsPacketSize triggers non-implemented paths in syrk.
+    mr = Vectorizable ? 3*LhsPacketSize : default_mr,
+#else
+    mr = default_mr,
+#endif
+    
+    LhsProgress = LhsPacketSize,
+    RhsProgress = 1
+  };
+
+  typedef typename packet_traits<LhsScalar>::type  _LhsPacket;
+  typedef typename packet_traits<RhsScalar>::type  _RhsPacket;
+  typedef typename packet_traits<ResScalar>::type  _ResPacket;
+
+  typedef typename conditional<Vectorizable,_LhsPacket,LhsScalar>::type LhsPacket;
+  typedef typename conditional<Vectorizable,_RhsPacket,RhsScalar>::type RhsPacket;
+  typedef typename conditional<Vectorizable,_ResPacket,ResScalar>::type ResPacket;
+
+  typedef ResPacket AccPacket;
+  
+  EIGEN_STRONG_INLINE void initAcc(AccPacket& p)
+  {
+    p = pset1<ResPacket>(ResScalar(0));
+  }
+  
+  EIGEN_STRONG_INLINE void broadcastRhs(const RhsScalar* b, RhsPacket& b0, RhsPacket& b1, RhsPacket& b2, RhsPacket& b3)
+  {
+    pbroadcast4(b, b0, b1, b2, b3);
+  }
+  
+//   EIGEN_STRONG_INLINE void broadcastRhs(const RhsScalar* b, RhsPacket& b0, RhsPacket& b1)
+//   {
+//     pbroadcast2(b, b0, b1);
+//   }
+  
+  template<typename RhsPacketType>
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacketType& dest) const
+  {
+    dest = pset1<RhsPacketType>(*b);
+  }
+  
+  EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, RhsPacket& dest) const
+  {
+    dest = ploadquad<RhsPacket>(b);
+  }
+
+  template<typename LhsPacketType>
+  EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacketType& dest) const
+  {
+    dest = pload<LhsPacketType>(a);
+  }
+
+  template<typename LhsPacketType>
+  EIGEN_STRONG_INLINE void loadLhsUnaligned(const LhsScalar* a, LhsPacketType& dest) const
+  {
+    dest = ploadu<LhsPacketType>(a);
+  }
+
+  template<typename LhsPacketType, typename RhsPacketType, typename AccPacketType>
+  EIGEN_STRONG_INLINE void madd(const LhsPacketType& a, const RhsPacketType& b, AccPacketType& c, AccPacketType& tmp) const
+  {
+    conj_helper<LhsPacketType,RhsPacketType,ConjLhs,ConjRhs> cj;
+    // It would be a lot cleaner to call pmadd all the time. Unfortunately if we
+    // let gcc allocate the register in which to store the result of the pmul
+    // (in the case where there is no FMA) gcc fails to figure out how to avoid
+    // spilling register.
+#ifdef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+    EIGEN_UNUSED_VARIABLE(tmp);
+    c = cj.pmadd(a,b,c);
+#else
+    tmp = b; tmp = cj.pmul(a,tmp); c = padd(c,tmp);
+#endif
+  }
+
+  EIGEN_STRONG_INLINE void acc(const AccPacket& c, const ResPacket& alpha, ResPacket& r) const
+  {
+    r = pmadd(c,alpha,r);
+  }
+  
+  template<typename ResPacketHalf>
+  EIGEN_STRONG_INLINE void acc(const ResPacketHalf& c, const ResPacketHalf& alpha, ResPacketHalf& r) const
+  {
+    r = pmadd(c,alpha,r);
+  }
+
+};
+
+template<typename RealScalar, bool _ConjLhs>
+class gebp_traits<std::complex<RealScalar>, RealScalar, _ConjLhs, false>
+{
+public:
+  typedef std::complex<RealScalar> LhsScalar;
+  typedef RealScalar RhsScalar;
+  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+
+  enum {
+    ConjLhs = _ConjLhs,
+    ConjRhs = false,
+    Vectorizable = packet_traits<LhsScalar>::Vectorizable && packet_traits<RhsScalar>::Vectorizable,
+    LhsPacketSize = Vectorizable ? packet_traits<LhsScalar>::size : 1,
+    RhsPacketSize = Vectorizable ? packet_traits<RhsScalar>::size : 1,
+    ResPacketSize = Vectorizable ? packet_traits<ResScalar>::size : 1,
+    
+    NumberOfRegisters = EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS,
+    nr = 4,
+#if defined(EIGEN_HAS_SINGLE_INSTRUCTION_MADD) && !defined(EIGEN_VECTORIZE_ALTIVEC) && !defined(EIGEN_VECTORIZE_VSX)
+    // we assume 16 registers
+    mr = 3*LhsPacketSize,
+#else
+    mr = (EIGEN_PLAIN_ENUM_MIN(16,NumberOfRegisters)/2/nr)*LhsPacketSize,
+#endif
+
+    LhsProgress = LhsPacketSize,
+    RhsProgress = 1
+  };
+
+  typedef typename packet_traits<LhsScalar>::type  _LhsPacket;
+  typedef typename packet_traits<RhsScalar>::type  _RhsPacket;
+  typedef typename packet_traits<ResScalar>::type  _ResPacket;
+
+  typedef typename conditional<Vectorizable,_LhsPacket,LhsScalar>::type LhsPacket;
+  typedef typename conditional<Vectorizable,_RhsPacket,RhsScalar>::type RhsPacket;
+  typedef typename conditional<Vectorizable,_ResPacket,ResScalar>::type ResPacket;
+
+  typedef ResPacket AccPacket;
+
+  EIGEN_STRONG_INLINE void initAcc(AccPacket& p)
+  {
+    p = pset1<ResPacket>(ResScalar(0));
+  }
+
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacket& dest) const
+  {
+    dest = pset1<RhsPacket>(*b);
+  }
+  
+  EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, RhsPacket& dest) const
+  {
+    dest = pset1<RhsPacket>(*b);
+  }
+
+  EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const
+  {
+    dest = pload<LhsPacket>(a);
+  }
+
+  EIGEN_STRONG_INLINE void loadLhsUnaligned(const LhsScalar* a, LhsPacket& dest) const
+  {
+    dest = ploadu<LhsPacket>(a);
+  }
+
+  EIGEN_STRONG_INLINE void broadcastRhs(const RhsScalar* b, RhsPacket& b0, RhsPacket& b1, RhsPacket& b2, RhsPacket& b3)
+  {
+    pbroadcast4(b, b0, b1, b2, b3);
+  }
+  
+//   EIGEN_STRONG_INLINE void broadcastRhs(const RhsScalar* b, RhsPacket& b0, RhsPacket& b1)
+//   {
+//     pbroadcast2(b, b0, b1);
+//   }
+
+  EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacket& b, AccPacket& c, RhsPacket& tmp) const
+  {
+    madd_impl(a, b, c, tmp, typename conditional<Vectorizable,true_type,false_type>::type());
+  }
+
+  EIGEN_STRONG_INLINE void madd_impl(const LhsPacket& a, const RhsPacket& b, AccPacket& c, RhsPacket& tmp, const true_type&) const
+  {
+#ifdef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+    EIGEN_UNUSED_VARIABLE(tmp);
+    c.v = pmadd(a.v,b,c.v);
+#else
+    tmp = b; tmp = pmul(a.v,tmp); c.v = padd(c.v,tmp);
+#endif
+  }
+
+  EIGEN_STRONG_INLINE void madd_impl(const LhsScalar& a, const RhsScalar& b, ResScalar& c, RhsScalar& /*tmp*/, const false_type&) const
+  {
+    c += a * b;
+  }
+
+  EIGEN_STRONG_INLINE void acc(const AccPacket& c, const ResPacket& alpha, ResPacket& r) const
+  {
+    r = cj.pmadd(c,alpha,r);
+  }
+
+protected:
+  conj_helper<ResPacket,ResPacket,ConjLhs,false> cj;
+};
+
+template<typename Packet>
+struct DoublePacket
+{
+  Packet first;
+  Packet second;
+};
+
+template<typename Packet>
+DoublePacket<Packet> padd(const DoublePacket<Packet> &a, const DoublePacket<Packet> &b)
+{
+  DoublePacket<Packet> res;
+  res.first  = padd(a.first, b.first);
+  res.second = padd(a.second,b.second);
+  return res;
+}
+
+template<typename Packet>
+const DoublePacket<Packet>& predux_downto4(const DoublePacket<Packet> &a)
+{
+  return a;
+}
+
+template<typename Packet> struct unpacket_traits<DoublePacket<Packet> > { typedef DoublePacket<Packet> half; };
+// template<typename Packet>
+// DoublePacket<Packet> pmadd(const DoublePacket<Packet> &a, const DoublePacket<Packet> &b)
+// {
+//   DoublePacket<Packet> res;
+//   res.first  = padd(a.first, b.first);
+//   res.second = padd(a.second,b.second);
+//   return res;
+// }
+
+template<typename RealScalar, bool _ConjLhs, bool _ConjRhs>
+class gebp_traits<std::complex<RealScalar>, std::complex<RealScalar>, _ConjLhs, _ConjRhs >
+{
+public:
+  typedef std::complex<RealScalar>  Scalar;
+  typedef std::complex<RealScalar>  LhsScalar;
+  typedef std::complex<RealScalar>  RhsScalar;
+  typedef std::complex<RealScalar>  ResScalar;
+  
+  enum {
+    ConjLhs = _ConjLhs,
+    ConjRhs = _ConjRhs,
+    Vectorizable = packet_traits<RealScalar>::Vectorizable
+                && packet_traits<Scalar>::Vectorizable,
+    RealPacketSize  = Vectorizable ? packet_traits<RealScalar>::size : 1,
+    ResPacketSize   = Vectorizable ? packet_traits<ResScalar>::size : 1,
+    LhsPacketSize = Vectorizable ? packet_traits<LhsScalar>::size : 1,
+    RhsPacketSize = Vectorizable ? packet_traits<RhsScalar>::size : 1,
+
+    // FIXME: should depend on NumberOfRegisters
+    nr = 4,
+    mr = ResPacketSize,
+
+    LhsProgress = ResPacketSize,
+    RhsProgress = 1
+  };
+  
+  typedef typename packet_traits<RealScalar>::type RealPacket;
+  typedef typename packet_traits<Scalar>::type     ScalarPacket;
+  typedef DoublePacket<RealPacket> DoublePacketType;
+
+  typedef typename conditional<Vectorizable,RealPacket,  Scalar>::type LhsPacket;
+  typedef typename conditional<Vectorizable,DoublePacketType,Scalar>::type RhsPacket;
+  typedef typename conditional<Vectorizable,ScalarPacket,Scalar>::type ResPacket;
+  typedef typename conditional<Vectorizable,DoublePacketType,Scalar>::type AccPacket;
+  
+  EIGEN_STRONG_INLINE void initAcc(Scalar& p) { p = Scalar(0); }
+
+  EIGEN_STRONG_INLINE void initAcc(DoublePacketType& p)
+  {
+    p.first   = pset1<RealPacket>(RealScalar(0));
+    p.second  = pset1<RealPacket>(RealScalar(0));
+  }
+
+  // Scalar path
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, ResPacket& dest) const
+  {
+    dest = pset1<ResPacket>(*b);
+  }
+
+  // Vectorized path
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, DoublePacketType& dest) const
+  {
+    dest.first  = pset1<RealPacket>(real(*b));
+    dest.second = pset1<RealPacket>(imag(*b));
+  }
+  
+  EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, ResPacket& dest) const
+  {
+    loadRhs(b,dest);
+  }
+  EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, DoublePacketType& dest) const
+  {
+    eigen_internal_assert(unpacket_traits<ScalarPacket>::size<=4);
+    loadRhs(b,dest);
+  }
+  
+  EIGEN_STRONG_INLINE void broadcastRhs(const RhsScalar* b, RhsPacket& b0, RhsPacket& b1, RhsPacket& b2, RhsPacket& b3)
+  {
+    // FIXME not sure that's the best way to implement it!
+    loadRhs(b+0, b0);
+    loadRhs(b+1, b1);
+    loadRhs(b+2, b2);
+    loadRhs(b+3, b3);
+  }
+  
+  // Vectorized path
+  EIGEN_STRONG_INLINE void broadcastRhs(const RhsScalar* b, DoublePacketType& b0, DoublePacketType& b1)
+  {
+    // FIXME not sure that's the best way to implement it!
+    loadRhs(b+0, b0);
+    loadRhs(b+1, b1);
+  }
+  
+  // Scalar path
+  EIGEN_STRONG_INLINE void broadcastRhs(const RhsScalar* b, RhsScalar& b0, RhsScalar& b1)
+  {
+    // FIXME not sure that's the best way to implement it!
+    loadRhs(b+0, b0);
+    loadRhs(b+1, b1);
+  }
+
+  // nothing special here
+  EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const
+  {
+    dest = pload<LhsPacket>((const typename unpacket_traits<LhsPacket>::type*)(a));
+  }
+
+  EIGEN_STRONG_INLINE void loadLhsUnaligned(const LhsScalar* a, LhsPacket& dest) const
+  {
+    dest = ploadu<LhsPacket>((const typename unpacket_traits<LhsPacket>::type*)(a));
+  }
+
+  EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacket& b, DoublePacketType& c, RhsPacket& /*tmp*/) const
+  {
+    c.first   = padd(pmul(a,b.first), c.first);
+    c.second  = padd(pmul(a,b.second),c.second);
+  }
+
+  EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacket& b, ResPacket& c, RhsPacket& /*tmp*/) const
+  {
+    c = cj.pmadd(a,b,c);
+  }
+  
+  EIGEN_STRONG_INLINE void acc(const Scalar& c, const Scalar& alpha, Scalar& r) const { r += alpha * c; }
+  
+  EIGEN_STRONG_INLINE void acc(const DoublePacketType& c, const ResPacket& alpha, ResPacket& r) const
+  {
+    // assemble c
+    ResPacket tmp;
+    if((!ConjLhs)&&(!ConjRhs))
+    {
+      tmp = pcplxflip(pconj(ResPacket(c.second)));
+      tmp = padd(ResPacket(c.first),tmp);
+    }
+    else if((!ConjLhs)&&(ConjRhs))
+    {
+      tmp = pconj(pcplxflip(ResPacket(c.second)));
+      tmp = padd(ResPacket(c.first),tmp);
+    }
+    else if((ConjLhs)&&(!ConjRhs))
+    {
+      tmp = pcplxflip(ResPacket(c.second));
+      tmp = padd(pconj(ResPacket(c.first)),tmp);
+    }
+    else if((ConjLhs)&&(ConjRhs))
+    {
+      tmp = pcplxflip(ResPacket(c.second));
+      tmp = psub(pconj(ResPacket(c.first)),tmp);
+    }
+    
+    r = pmadd(tmp,alpha,r);
+  }
+
+protected:
+  conj_helper<LhsScalar,RhsScalar,ConjLhs,ConjRhs> cj;
+};
+
+template<typename RealScalar, bool _ConjRhs>
+class gebp_traits<RealScalar, std::complex<RealScalar>, false, _ConjRhs >
+{
+public:
+  typedef std::complex<RealScalar>  Scalar;
+  typedef RealScalar  LhsScalar;
+  typedef Scalar      RhsScalar;
+  typedef Scalar      ResScalar;
+
+  enum {
+    ConjLhs = false,
+    ConjRhs = _ConjRhs,
+    Vectorizable = packet_traits<RealScalar>::Vectorizable
+                && packet_traits<Scalar>::Vectorizable,
+    LhsPacketSize = Vectorizable ? packet_traits<LhsScalar>::size : 1,
+    RhsPacketSize = Vectorizable ? packet_traits<RhsScalar>::size : 1,
+    ResPacketSize = Vectorizable ? packet_traits<ResScalar>::size : 1,
+    
+    NumberOfRegisters = EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS,
+    // FIXME: should depend on NumberOfRegisters
+    nr = 4,
+    mr = (EIGEN_PLAIN_ENUM_MIN(16,NumberOfRegisters)/2/nr)*ResPacketSize,
+
+    LhsProgress = ResPacketSize,
+    RhsProgress = 1
+  };
+
+  typedef typename packet_traits<LhsScalar>::type  _LhsPacket;
+  typedef typename packet_traits<RhsScalar>::type  _RhsPacket;
+  typedef typename packet_traits<ResScalar>::type  _ResPacket;
+
+  typedef typename conditional<Vectorizable,_LhsPacket,LhsScalar>::type LhsPacket;
+  typedef typename conditional<Vectorizable,_RhsPacket,RhsScalar>::type RhsPacket;
+  typedef typename conditional<Vectorizable,_ResPacket,ResScalar>::type ResPacket;
+
+  typedef ResPacket AccPacket;
+
+  EIGEN_STRONG_INLINE void initAcc(AccPacket& p)
+  {
+    p = pset1<ResPacket>(ResScalar(0));
+  }
+
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacket& dest) const
+  {
+    dest = pset1<RhsPacket>(*b);
+  }
+  
+  void broadcastRhs(const RhsScalar* b, RhsPacket& b0, RhsPacket& b1, RhsPacket& b2, RhsPacket& b3)
+  {
+    pbroadcast4(b, b0, b1, b2, b3);
+  }
+  
+//   EIGEN_STRONG_INLINE void broadcastRhs(const RhsScalar* b, RhsPacket& b0, RhsPacket& b1)
+//   {
+//     // FIXME not sure that's the best way to implement it!
+//     b0 = pload1<RhsPacket>(b+0);
+//     b1 = pload1<RhsPacket>(b+1);
+//   }
+
+  EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const
+  {
+    dest = ploaddup<LhsPacket>(a);
+  }
+  
+  EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, RhsPacket& dest) const
+  {
+    eigen_internal_assert(unpacket_traits<RhsPacket>::size<=4);
+    loadRhs(b,dest);
+  }
+
+  EIGEN_STRONG_INLINE void loadLhsUnaligned(const LhsScalar* a, LhsPacket& dest) const
+  {
+    dest = ploaddup<LhsPacket>(a);
+  }
+
+  EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacket& b, AccPacket& c, RhsPacket& tmp) const
+  {
+    madd_impl(a, b, c, tmp, typename conditional<Vectorizable,true_type,false_type>::type());
+  }
+
+  EIGEN_STRONG_INLINE void madd_impl(const LhsPacket& a, const RhsPacket& b, AccPacket& c, RhsPacket& tmp, const true_type&) const
+  {
+#ifdef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+    EIGEN_UNUSED_VARIABLE(tmp);
+    c.v = pmadd(a,b.v,c.v);
+#else
+    tmp = b; tmp.v = pmul(a,tmp.v); c = padd(c,tmp);
+#endif
+    
+  }
+
+  EIGEN_STRONG_INLINE void madd_impl(const LhsScalar& a, const RhsScalar& b, ResScalar& c, RhsScalar& /*tmp*/, const false_type&) const
+  {
+    c += a * b;
+  }
+
+  EIGEN_STRONG_INLINE void acc(const AccPacket& c, const ResPacket& alpha, ResPacket& r) const
+  {
+    r = cj.pmadd(alpha,c,r);
+  }
+
+protected:
+  conj_helper<ResPacket,ResPacket,false,ConjRhs> cj;
+};
+
+/* optimized GEneral packed Block * packed Panel product kernel
+ *
+ * Mixing type logic: C += A * B
+ *  |  A  |  B  | comments
+ *  |real |cplx | no vectorization yet, would require to pack A with duplication
+ *  |cplx |real | easy vectorization
+ */
+template<typename LhsScalar, typename RhsScalar, typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+struct gebp_kernel
+{
+  typedef gebp_traits<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs> Traits;
+  typedef typename Traits::ResScalar ResScalar;
+  typedef typename Traits::LhsPacket LhsPacket;
+  typedef typename Traits::RhsPacket RhsPacket;
+  typedef typename Traits::ResPacket ResPacket;
+  typedef typename Traits::AccPacket AccPacket;
+
+  typedef gebp_traits<RhsScalar,LhsScalar,ConjugateRhs,ConjugateLhs> SwappedTraits;
+  typedef typename SwappedTraits::ResScalar SResScalar;
+  typedef typename SwappedTraits::LhsPacket SLhsPacket;
+  typedef typename SwappedTraits::RhsPacket SRhsPacket;
+  typedef typename SwappedTraits::ResPacket SResPacket;
+  typedef typename SwappedTraits::AccPacket SAccPacket;
+
+  typedef typename DataMapper::LinearMapper LinearMapper;
+
+  enum {
+    Vectorizable  = Traits::Vectorizable,
+    LhsProgress   = Traits::LhsProgress,
+    RhsProgress   = Traits::RhsProgress,
+    ResPacketSize = Traits::ResPacketSize
+  };
+
+  EIGEN_DONT_INLINE
+  void operator()(const DataMapper& res, const LhsScalar* blockA, const RhsScalar* blockB,
+                  Index rows, Index depth, Index cols, ResScalar alpha,
+                  Index strideA=-1, Index strideB=-1, Index offsetA=0, Index offsetB=0);
+};
+
+template<typename LhsScalar, typename RhsScalar, typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+EIGEN_DONT_INLINE
+void gebp_kernel<LhsScalar,RhsScalar,Index,DataMapper,mr,nr,ConjugateLhs,ConjugateRhs>
+  ::operator()(const DataMapper& res, const LhsScalar* blockA, const RhsScalar* blockB,
+               Index rows, Index depth, Index cols, ResScalar alpha,
+               Index strideA, Index strideB, Index offsetA, Index offsetB)
+  {
+    Traits traits;
+    SwappedTraits straits;
+    
+    if(strideA==-1) strideA = depth;
+    if(strideB==-1) strideB = depth;
+    conj_helper<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs> cj;
+    Index packet_cols4 = nr>=4 ? (cols/4) * 4 : 0;
+    const Index peeled_mc3 = mr>=3*Traits::LhsProgress ? (rows/(3*LhsProgress))*(3*LhsProgress) : 0;
+    const Index peeled_mc2 = mr>=2*Traits::LhsProgress ? peeled_mc3+((rows-peeled_mc3)/(2*LhsProgress))*(2*LhsProgress) : 0;
+    const Index peeled_mc1 = mr>=1*Traits::LhsProgress ? (rows/(1*LhsProgress))*(1*LhsProgress) : 0;
+    enum { pk = 8 }; // NOTE Such a large peeling factor is important for large matrices (~ +5% when >1000 on Haswell)
+    const Index peeled_kc  = depth & ~(pk-1);
+    const Index prefetch_res_offset = 32/sizeof(ResScalar);    
+//     const Index depth2     = depth & ~1;
+
+    //---------- Process 3 * LhsProgress rows at once ----------
+    // This corresponds to 3*LhsProgress x nr register blocks.
+    // Usually, make sense only with FMA
+    if(mr>=3*Traits::LhsProgress)
+    {
+      // Here, the general idea is to loop on each largest micro horizontal panel of the lhs (3*Traits::LhsProgress x depth)
+      // and on each largest micro vertical panel of the rhs (depth * nr).
+      // Blocking sizes, i.e., 'depth' has been computed so that the micro horizontal panel of the lhs fit in L1.
+      // However, if depth is too small, we can extend the number of rows of these horizontal panels.
+      // This actual number of rows is computed as follow:
+      const Index l1 = defaultL1CacheSize; // in Bytes, TODO, l1 should be passed to this function.
+      // The max(1, ...) here is needed because we may be using blocking params larger than what our known l1 cache size
+      // suggests we should be using: either because our known l1 cache size is inaccurate (e.g. on Android, we can only guess),
+      // or because we are testing specific blocking sizes.
+      const Index actual_panel_rows = (3*LhsProgress) * std::max<Index>(1,( (l1 - sizeof(ResScalar)*mr*nr - depth*nr*sizeof(RhsScalar)) / (depth * sizeof(LhsScalar) * 3*LhsProgress) ));
+      for(Index i1=0; i1<peeled_mc3; i1+=actual_panel_rows)
+      {
+        const Index actual_panel_end = (std::min)(i1+actual_panel_rows, peeled_mc3);
+        for(Index j2=0; j2<packet_cols4; j2+=nr)
+        {
+          for(Index i=i1; i<actual_panel_end; i+=3*LhsProgress)
+          {
+          
+          // We selected a 3*Traits::LhsProgress x nr micro block of res which is entirely
+          // stored into 3 x nr registers.
+          
+          const LhsScalar* blA = &blockA[i*strideA+offsetA*(3*LhsProgress)];
+          prefetch(&blA[0]);
+
+          // gets res block as register
+          AccPacket C0, C1, C2,  C3,
+                    C4, C5, C6,  C7,
+                    C8, C9, C10, C11;
+          traits.initAcc(C0);  traits.initAcc(C1);  traits.initAcc(C2);  traits.initAcc(C3);
+          traits.initAcc(C4);  traits.initAcc(C5);  traits.initAcc(C6);  traits.initAcc(C7);
+          traits.initAcc(C8);  traits.initAcc(C9);  traits.initAcc(C10); traits.initAcc(C11);
+
+          LinearMapper r0 = res.getLinearMapper(i, j2 + 0);
+          LinearMapper r1 = res.getLinearMapper(i, j2 + 1);
+          LinearMapper r2 = res.getLinearMapper(i, j2 + 2);
+          LinearMapper r3 = res.getLinearMapper(i, j2 + 3);
+
+          r0.prefetch(0);
+          r1.prefetch(0);
+          r2.prefetch(0);
+          r3.prefetch(0);
+
+          // performs "inner" products
+          const RhsScalar* blB = &blockB[j2*strideB+offsetB*nr];
+          prefetch(&blB[0]);
+          LhsPacket A0, A1;
+
+          for(Index k=0; k<peeled_kc; k+=pk)
+          {
+            EIGEN_ASM_COMMENT("begin gebp micro kernel 3pX4");
+            RhsPacket B_0, T0;
+            LhsPacket A2;
+
+#define EIGEN_GEBP_ONESTEP(K) \
+            do { \
+              EIGEN_ASM_COMMENT("begin step of gebp micro kernel 3pX4"); \
+              EIGEN_ASM_COMMENT("Note: these asm comments work around bug 935!"); \
+              internal::prefetch(blA+(3*K+16)*LhsProgress); \
+              if (EIGEN_ARCH_ARM) { internal::prefetch(blB+(4*K+16)*RhsProgress); } /* Bug 953 */ \
+              traits.loadLhs(&blA[(0+3*K)*LhsProgress], A0);  \
+              traits.loadLhs(&blA[(1+3*K)*LhsProgress], A1);  \
+              traits.loadLhs(&blA[(2+3*K)*LhsProgress], A2);  \
+              traits.loadRhs(blB + (0+4*K)*Traits::RhsProgress, B_0); \
+              traits.madd(A0, B_0, C0, T0); \
+              traits.madd(A1, B_0, C4, T0); \
+              traits.madd(A2, B_0, C8, B_0); \
+              traits.loadRhs(blB + (1+4*K)*Traits::RhsProgress, B_0); \
+              traits.madd(A0, B_0, C1, T0); \
+              traits.madd(A1, B_0, C5, T0); \
+              traits.madd(A2, B_0, C9, B_0); \
+              traits.loadRhs(blB + (2+4*K)*Traits::RhsProgress, B_0); \
+              traits.madd(A0, B_0, C2,  T0); \
+              traits.madd(A1, B_0, C6,  T0); \
+              traits.madd(A2, B_0, C10, B_0); \
+              traits.loadRhs(blB + (3+4*K)*Traits::RhsProgress, B_0); \
+              traits.madd(A0, B_0, C3 , T0); \
+              traits.madd(A1, B_0, C7,  T0); \
+              traits.madd(A2, B_0, C11, B_0); \
+              EIGEN_ASM_COMMENT("end step of gebp micro kernel 3pX4"); \
+            } while(false)
+
+            internal::prefetch(blB);
+            EIGEN_GEBP_ONESTEP(0);
+            EIGEN_GEBP_ONESTEP(1);
+            EIGEN_GEBP_ONESTEP(2);
+            EIGEN_GEBP_ONESTEP(3);
+            EIGEN_GEBP_ONESTEP(4);
+            EIGEN_GEBP_ONESTEP(5);
+            EIGEN_GEBP_ONESTEP(6);
+            EIGEN_GEBP_ONESTEP(7);
+
+            blB += pk*4*RhsProgress;
+            blA += pk*3*Traits::LhsProgress;
+
+            EIGEN_ASM_COMMENT("end gebp micro kernel 3pX4");
+          }
+          // process remaining peeled loop
+          for(Index k=peeled_kc; k<depth; k++)
+          {
+            RhsPacket B_0, T0;
+            LhsPacket A2;
+            EIGEN_GEBP_ONESTEP(0);
+            blB += 4*RhsProgress;
+            blA += 3*Traits::LhsProgress;
+          }
+
+#undef EIGEN_GEBP_ONESTEP
+
+          ResPacket R0, R1, R2;
+          ResPacket alphav = pset1<ResPacket>(alpha);
+
+          R0 = r0.loadPacket(0 * Traits::ResPacketSize);
+          R1 = r0.loadPacket(1 * Traits::ResPacketSize);
+          R2 = r0.loadPacket(2 * Traits::ResPacketSize);
+          traits.acc(C0, alphav, R0);
+          traits.acc(C4, alphav, R1);
+          traits.acc(C8, alphav, R2);
+          r0.storePacket(0 * Traits::ResPacketSize, R0);
+          r0.storePacket(1 * Traits::ResPacketSize, R1);
+          r0.storePacket(2 * Traits::ResPacketSize, R2);
+
+          R0 = r1.loadPacket(0 * Traits::ResPacketSize);
+          R1 = r1.loadPacket(1 * Traits::ResPacketSize);
+          R2 = r1.loadPacket(2 * Traits::ResPacketSize);
+          traits.acc(C1, alphav, R0);
+          traits.acc(C5, alphav, R1);
+          traits.acc(C9, alphav, R2);
+          r1.storePacket(0 * Traits::ResPacketSize, R0);
+          r1.storePacket(1 * Traits::ResPacketSize, R1);
+          r1.storePacket(2 * Traits::ResPacketSize, R2);
+
+          R0 = r2.loadPacket(0 * Traits::ResPacketSize);
+          R1 = r2.loadPacket(1 * Traits::ResPacketSize);
+          R2 = r2.loadPacket(2 * Traits::ResPacketSize);
+          traits.acc(C2, alphav, R0);
+          traits.acc(C6, alphav, R1);
+          traits.acc(C10, alphav, R2);
+          r2.storePacket(0 * Traits::ResPacketSize, R0);
+          r2.storePacket(1 * Traits::ResPacketSize, R1);
+          r2.storePacket(2 * Traits::ResPacketSize, R2);
+
+          R0 = r3.loadPacket(0 * Traits::ResPacketSize);
+          R1 = r3.loadPacket(1 * Traits::ResPacketSize);
+          R2 = r3.loadPacket(2 * Traits::ResPacketSize);
+          traits.acc(C3, alphav, R0);
+          traits.acc(C7, alphav, R1);
+          traits.acc(C11, alphav, R2);
+          r3.storePacket(0 * Traits::ResPacketSize, R0);
+          r3.storePacket(1 * Traits::ResPacketSize, R1);
+          r3.storePacket(2 * Traits::ResPacketSize, R2);          
+          }
+        }
+
+        // Deal with remaining columns of the rhs
+        for(Index j2=packet_cols4; j2<cols; j2++)
+        {
+          for(Index i=i1; i<actual_panel_end; i+=3*LhsProgress)
+          {
+          // One column at a time
+          const LhsScalar* blA = &blockA[i*strideA+offsetA*(3*Traits::LhsProgress)];
+          prefetch(&blA[0]);
+
+          // gets res block as register
+          AccPacket C0, C4, C8;
+          traits.initAcc(C0);
+          traits.initAcc(C4);
+          traits.initAcc(C8);
+
+          LinearMapper r0 = res.getLinearMapper(i, j2);
+          r0.prefetch(0);
+
+          // performs "inner" products
+          const RhsScalar* blB = &blockB[j2*strideB+offsetB];
+          LhsPacket A0, A1, A2;
+          
+          for(Index k=0; k<peeled_kc; k+=pk)
+          {
+            EIGEN_ASM_COMMENT("begin gebp micro kernel 3pX1");
+            RhsPacket B_0;
+#define EIGEN_GEBGP_ONESTEP(K) \
+            do { \
+              EIGEN_ASM_COMMENT("begin step of gebp micro kernel 3pX1"); \
+              EIGEN_ASM_COMMENT("Note: these asm comments work around bug 935!"); \
+              traits.loadLhs(&blA[(0+3*K)*LhsProgress], A0);  \
+              traits.loadLhs(&blA[(1+3*K)*LhsProgress], A1);  \
+              traits.loadLhs(&blA[(2+3*K)*LhsProgress], A2);  \
+              traits.loadRhs(&blB[(0+K)*RhsProgress], B_0);   \
+              traits.madd(A0, B_0, C0, B_0); \
+              traits.madd(A1, B_0, C4, B_0); \
+              traits.madd(A2, B_0, C8, B_0); \
+              EIGEN_ASM_COMMENT("end step of gebp micro kernel 3pX1"); \
+            } while(false)
+        
+            EIGEN_GEBGP_ONESTEP(0);
+            EIGEN_GEBGP_ONESTEP(1);
+            EIGEN_GEBGP_ONESTEP(2);
+            EIGEN_GEBGP_ONESTEP(3);
+            EIGEN_GEBGP_ONESTEP(4);
+            EIGEN_GEBGP_ONESTEP(5);
+            EIGEN_GEBGP_ONESTEP(6);
+            EIGEN_GEBGP_ONESTEP(7);
+
+            blB += pk*RhsProgress;
+            blA += pk*3*Traits::LhsProgress;
+
+            EIGEN_ASM_COMMENT("end gebp micro kernel 3pX1");
+          }
+
+          // process remaining peeled loop
+          for(Index k=peeled_kc; k<depth; k++)
+          {
+            RhsPacket B_0;
+            EIGEN_GEBGP_ONESTEP(0);
+            blB += RhsProgress;
+            blA += 3*Traits::LhsProgress;
+          }
+#undef EIGEN_GEBGP_ONESTEP
+          ResPacket R0, R1, R2;
+          ResPacket alphav = pset1<ResPacket>(alpha);
+
+          R0 = r0.loadPacket(0 * Traits::ResPacketSize);
+          R1 = r0.loadPacket(1 * Traits::ResPacketSize);
+          R2 = r0.loadPacket(2 * Traits::ResPacketSize);
+          traits.acc(C0, alphav, R0);
+          traits.acc(C4, alphav, R1);
+          traits.acc(C8, alphav, R2);
+          r0.storePacket(0 * Traits::ResPacketSize, R0);
+          r0.storePacket(1 * Traits::ResPacketSize, R1);
+          r0.storePacket(2 * Traits::ResPacketSize, R2);          
+          }
+        }
+      }
+    }
+
+    //---------- Process 2 * LhsProgress rows at once ----------
+    if(mr>=2*Traits::LhsProgress)
+    {
+      const Index l1 = defaultL1CacheSize; // in Bytes, TODO, l1 should be passed to this function.
+      // The max(1, ...) here is needed because we may be using blocking params larger than what our known l1 cache size
+      // suggests we should be using: either because our known l1 cache size is inaccurate (e.g. on Android, we can only guess),
+      // or because we are testing specific blocking sizes.
+      Index actual_panel_rows = (2*LhsProgress) * std::max<Index>(1,( (l1 - sizeof(ResScalar)*mr*nr - depth*nr*sizeof(RhsScalar)) / (depth * sizeof(LhsScalar) * 2*LhsProgress) ));
+
+      for(Index i1=peeled_mc3; i1<peeled_mc2; i1+=actual_panel_rows)
+      {
+        Index actual_panel_end = (std::min)(i1+actual_panel_rows, peeled_mc2);
+        for(Index j2=0; j2<packet_cols4; j2+=nr)
+        {
+          for(Index i=i1; i<actual_panel_end; i+=2*LhsProgress)
+          {
+          
+          // We selected a 2*Traits::LhsProgress x nr micro block of res which is entirely
+          // stored into 2 x nr registers.
+          
+          const LhsScalar* blA = &blockA[i*strideA+offsetA*(2*Traits::LhsProgress)];
+          prefetch(&blA[0]);
+
+          // gets res block as register
+          AccPacket C0, C1, C2, C3,
+                    C4, C5, C6, C7;
+          traits.initAcc(C0); traits.initAcc(C1); traits.initAcc(C2); traits.initAcc(C3);
+          traits.initAcc(C4); traits.initAcc(C5); traits.initAcc(C6); traits.initAcc(C7);
+
+          LinearMapper r0 = res.getLinearMapper(i, j2 + 0);
+          LinearMapper r1 = res.getLinearMapper(i, j2 + 1);
+          LinearMapper r2 = res.getLinearMapper(i, j2 + 2);
+          LinearMapper r3 = res.getLinearMapper(i, j2 + 3);
+
+          r0.prefetch(prefetch_res_offset);
+          r1.prefetch(prefetch_res_offset);
+          r2.prefetch(prefetch_res_offset);
+          r3.prefetch(prefetch_res_offset);
+
+          // performs "inner" products
+          const RhsScalar* blB = &blockB[j2*strideB+offsetB*nr];
+          prefetch(&blB[0]);
+          LhsPacket A0, A1;
+
+          for(Index k=0; k<peeled_kc; k+=pk)
+          {
+            EIGEN_ASM_COMMENT("begin gebp micro kernel 2pX4");
+            RhsPacket B_0, B1, B2, B3, T0;
+
+   #define EIGEN_GEBGP_ONESTEP(K) \
+            do {                                                                \
+              EIGEN_ASM_COMMENT("begin step of gebp micro kernel 2pX4");        \
+              EIGEN_ASM_COMMENT("Note: these asm comments work around bug 935!"); \
+              traits.loadLhs(&blA[(0+2*K)*LhsProgress], A0);                    \
+              traits.loadLhs(&blA[(1+2*K)*LhsProgress], A1);                    \
+              traits.broadcastRhs(&blB[(0+4*K)*RhsProgress], B_0, B1, B2, B3);  \
+              traits.madd(A0, B_0, C0, T0);                                     \
+              traits.madd(A1, B_0, C4, B_0);                                    \
+              traits.madd(A0, B1,  C1, T0);                                     \
+              traits.madd(A1, B1,  C5, B1);                                     \
+              traits.madd(A0, B2,  C2, T0);                                     \
+              traits.madd(A1, B2,  C6, B2);                                     \
+              traits.madd(A0, B3,  C3, T0);                                     \
+              traits.madd(A1, B3,  C7, B3);                                     \
+              EIGEN_ASM_COMMENT("end step of gebp micro kernel 2pX4");          \
+            } while(false)
+            
+            internal::prefetch(blB+(48+0));
+            EIGEN_GEBGP_ONESTEP(0);
+            EIGEN_GEBGP_ONESTEP(1);
+            EIGEN_GEBGP_ONESTEP(2);
+            EIGEN_GEBGP_ONESTEP(3);
+            internal::prefetch(blB+(48+16));
+            EIGEN_GEBGP_ONESTEP(4);
+            EIGEN_GEBGP_ONESTEP(5);
+            EIGEN_GEBGP_ONESTEP(6);
+            EIGEN_GEBGP_ONESTEP(7);
+
+            blB += pk*4*RhsProgress;
+            blA += pk*(2*Traits::LhsProgress);
+
+            EIGEN_ASM_COMMENT("end gebp micro kernel 2pX4");
+          }
+          // process remaining peeled loop
+          for(Index k=peeled_kc; k<depth; k++)
+          {
+            RhsPacket B_0, B1, B2, B3, T0;
+            EIGEN_GEBGP_ONESTEP(0);
+            blB += 4*RhsProgress;
+            blA += 2*Traits::LhsProgress;
+          }
+#undef EIGEN_GEBGP_ONESTEP
+
+          ResPacket R0, R1, R2, R3;
+          ResPacket alphav = pset1<ResPacket>(alpha);
+
+          R0 = r0.loadPacket(0 * Traits::ResPacketSize);
+          R1 = r0.loadPacket(1 * Traits::ResPacketSize);
+          R2 = r1.loadPacket(0 * Traits::ResPacketSize);
+          R3 = r1.loadPacket(1 * Traits::ResPacketSize);
+          traits.acc(C0, alphav, R0);
+          traits.acc(C4, alphav, R1);
+          traits.acc(C1, alphav, R2);
+          traits.acc(C5, alphav, R3);
+          r0.storePacket(0 * Traits::ResPacketSize, R0);
+          r0.storePacket(1 * Traits::ResPacketSize, R1);
+          r1.storePacket(0 * Traits::ResPacketSize, R2);
+          r1.storePacket(1 * Traits::ResPacketSize, R3);
+
+          R0 = r2.loadPacket(0 * Traits::ResPacketSize);
+          R1 = r2.loadPacket(1 * Traits::ResPacketSize);
+          R2 = r3.loadPacket(0 * Traits::ResPacketSize);
+          R3 = r3.loadPacket(1 * Traits::ResPacketSize);
+          traits.acc(C2,  alphav, R0);
+          traits.acc(C6,  alphav, R1);
+          traits.acc(C3,  alphav, R2);
+          traits.acc(C7,  alphav, R3);
+          r2.storePacket(0 * Traits::ResPacketSize, R0);
+          r2.storePacket(1 * Traits::ResPacketSize, R1);
+          r3.storePacket(0 * Traits::ResPacketSize, R2);
+          r3.storePacket(1 * Traits::ResPacketSize, R3);
+          }
+        }
+      
+        // Deal with remaining columns of the rhs
+        for(Index j2=packet_cols4; j2<cols; j2++)
+        {
+          for(Index i=i1; i<actual_panel_end; i+=2*LhsProgress)
+          {
+          // One column at a time
+          const LhsScalar* blA = &blockA[i*strideA+offsetA*(2*Traits::LhsProgress)];
+          prefetch(&blA[0]);
+
+          // gets res block as register
+          AccPacket C0, C4;
+          traits.initAcc(C0);
+          traits.initAcc(C4);
+
+          LinearMapper r0 = res.getLinearMapper(i, j2);
+          r0.prefetch(prefetch_res_offset);
+
+          // performs "inner" products
+          const RhsScalar* blB = &blockB[j2*strideB+offsetB];
+          LhsPacket A0, A1;
+
+          for(Index k=0; k<peeled_kc; k+=pk)
+          {
+            EIGEN_ASM_COMMENT("begin gebp micro kernel 2pX1");
+            RhsPacket B_0, B1;
+        
+#define EIGEN_GEBGP_ONESTEP(K) \
+            do {                                                                  \
+              EIGEN_ASM_COMMENT("begin step of gebp micro kernel 2pX1");          \
+              EIGEN_ASM_COMMENT("Note: these asm comments work around bug 935!"); \
+              traits.loadLhs(&blA[(0+2*K)*LhsProgress], A0);                      \
+              traits.loadLhs(&blA[(1+2*K)*LhsProgress], A1);                      \
+              traits.loadRhs(&blB[(0+K)*RhsProgress], B_0);                       \
+              traits.madd(A0, B_0, C0, B1);                                       \
+              traits.madd(A1, B_0, C4, B_0);                                      \
+              EIGEN_ASM_COMMENT("end step of gebp micro kernel 2pX1");            \
+            } while(false)
+        
+            EIGEN_GEBGP_ONESTEP(0);
+            EIGEN_GEBGP_ONESTEP(1);
+            EIGEN_GEBGP_ONESTEP(2);
+            EIGEN_GEBGP_ONESTEP(3);
+            EIGEN_GEBGP_ONESTEP(4);
+            EIGEN_GEBGP_ONESTEP(5);
+            EIGEN_GEBGP_ONESTEP(6);
+            EIGEN_GEBGP_ONESTEP(7);
+
+            blB += pk*RhsProgress;
+            blA += pk*2*Traits::LhsProgress;
+
+            EIGEN_ASM_COMMENT("end gebp micro kernel 2pX1");
+          }
+
+          // process remaining peeled loop
+          for(Index k=peeled_kc; k<depth; k++)
+          {
+            RhsPacket B_0, B1;
+            EIGEN_GEBGP_ONESTEP(0);
+            blB += RhsProgress;
+            blA += 2*Traits::LhsProgress;
+          }
+#undef EIGEN_GEBGP_ONESTEP
+          ResPacket R0, R1;
+          ResPacket alphav = pset1<ResPacket>(alpha);
+
+          R0 = r0.loadPacket(0 * Traits::ResPacketSize);
+          R1 = r0.loadPacket(1 * Traits::ResPacketSize);
+          traits.acc(C0, alphav, R0);
+          traits.acc(C4, alphav, R1);
+          r0.storePacket(0 * Traits::ResPacketSize, R0);
+          r0.storePacket(1 * Traits::ResPacketSize, R1);
+          }
+        }
+      }
+    }
+    //---------- Process 1 * LhsProgress rows at once ----------
+    if(mr>=1*Traits::LhsProgress)
+    {
+      // loops on each largest micro horizontal panel of lhs (1*LhsProgress x depth)
+      for(Index i=peeled_mc2; i<peeled_mc1; i+=1*LhsProgress)
+      {
+        // loops on each largest micro vertical panel of rhs (depth * nr)
+        for(Index j2=0; j2<packet_cols4; j2+=nr)
+        {
+          // We select a 1*Traits::LhsProgress x nr micro block of res which is entirely
+          // stored into 1 x nr registers.
+          
+          const LhsScalar* blA = &blockA[i*strideA+offsetA*(1*Traits::LhsProgress)];
+          prefetch(&blA[0]);
+
+          // gets res block as register
+          AccPacket C0, C1, C2, C3;
+          traits.initAcc(C0);
+          traits.initAcc(C1);
+          traits.initAcc(C2);
+          traits.initAcc(C3);
+
+          LinearMapper r0 = res.getLinearMapper(i, j2 + 0);
+          LinearMapper r1 = res.getLinearMapper(i, j2 + 1);
+          LinearMapper r2 = res.getLinearMapper(i, j2 + 2);
+          LinearMapper r3 = res.getLinearMapper(i, j2 + 3);
+
+          r0.prefetch(prefetch_res_offset);
+          r1.prefetch(prefetch_res_offset);
+          r2.prefetch(prefetch_res_offset);
+          r3.prefetch(prefetch_res_offset);
+
+          // performs "inner" products
+          const RhsScalar* blB = &blockB[j2*strideB+offsetB*nr];
+          prefetch(&blB[0]);
+          LhsPacket A0;
+
+          for(Index k=0; k<peeled_kc; k+=pk)
+          {
+            EIGEN_ASM_COMMENT("begin gebp micro kernel 1pX4");
+            RhsPacket B_0, B1, B2, B3;
+               
+#define EIGEN_GEBGP_ONESTEP(K) \
+            do {                                                                \
+              EIGEN_ASM_COMMENT("begin step of gebp micro kernel 1pX4");        \
+              EIGEN_ASM_COMMENT("Note: these asm comments work around bug 935!"); \
+              traits.loadLhs(&blA[(0+1*K)*LhsProgress], A0);                    \
+              traits.broadcastRhs(&blB[(0+4*K)*RhsProgress], B_0, B1, B2, B3);  \
+              traits.madd(A0, B_0, C0, B_0);                                    \
+              traits.madd(A0, B1,  C1, B1);                                     \
+              traits.madd(A0, B2,  C2, B2);                                     \
+              traits.madd(A0, B3,  C3, B3);                                     \
+              EIGEN_ASM_COMMENT("end step of gebp micro kernel 1pX4");          \
+            } while(false)
+            
+            internal::prefetch(blB+(48+0));
+            EIGEN_GEBGP_ONESTEP(0);
+            EIGEN_GEBGP_ONESTEP(1);
+            EIGEN_GEBGP_ONESTEP(2);
+            EIGEN_GEBGP_ONESTEP(3);
+            internal::prefetch(blB+(48+16));
+            EIGEN_GEBGP_ONESTEP(4);
+            EIGEN_GEBGP_ONESTEP(5);
+            EIGEN_GEBGP_ONESTEP(6);
+            EIGEN_GEBGP_ONESTEP(7);
+
+            blB += pk*4*RhsProgress;
+            blA += pk*1*LhsProgress;
+
+            EIGEN_ASM_COMMENT("end gebp micro kernel 1pX4");
+          }
+          // process remaining peeled loop
+          for(Index k=peeled_kc; k<depth; k++)
+          {
+            RhsPacket B_0, B1, B2, B3;
+            EIGEN_GEBGP_ONESTEP(0);
+            blB += 4*RhsProgress;
+            blA += 1*LhsProgress;
+          }
+#undef EIGEN_GEBGP_ONESTEP
+
+          ResPacket R0, R1;
+          ResPacket alphav = pset1<ResPacket>(alpha);
+
+          R0 = r0.loadPacket(0 * Traits::ResPacketSize);
+          R1 = r1.loadPacket(0 * Traits::ResPacketSize);
+          traits.acc(C0, alphav, R0);
+          traits.acc(C1,  alphav, R1);
+          r0.storePacket(0 * Traits::ResPacketSize, R0);
+          r1.storePacket(0 * Traits::ResPacketSize, R1);
+
+          R0 = r2.loadPacket(0 * Traits::ResPacketSize);
+          R1 = r3.loadPacket(0 * Traits::ResPacketSize);
+          traits.acc(C2,  alphav, R0);
+          traits.acc(C3,  alphav, R1);
+          r2.storePacket(0 * Traits::ResPacketSize, R0);
+          r3.storePacket(0 * Traits::ResPacketSize, R1);
+        }
+
+        // Deal with remaining columns of the rhs
+        for(Index j2=packet_cols4; j2<cols; j2++)
+        {
+          // One column at a time
+          const LhsScalar* blA = &blockA[i*strideA+offsetA*(1*Traits::LhsProgress)];
+          prefetch(&blA[0]);
+
+          // gets res block as register
+          AccPacket C0;
+          traits.initAcc(C0);
+
+          LinearMapper r0 = res.getLinearMapper(i, j2);
+
+          // performs "inner" products
+          const RhsScalar* blB = &blockB[j2*strideB+offsetB];
+          LhsPacket A0;
+
+          for(Index k=0; k<peeled_kc; k+=pk)
+          {
+            EIGEN_ASM_COMMENT("begin gebp micro kernel 1pX1");
+            RhsPacket B_0;
+        
+#define EIGEN_GEBGP_ONESTEP(K) \
+            do {                                                                \
+              EIGEN_ASM_COMMENT("begin step of gebp micro kernel 1pX1");        \
+              EIGEN_ASM_COMMENT("Note: these asm comments work around bug 935!"); \
+              traits.loadLhs(&blA[(0+1*K)*LhsProgress], A0);                    \
+              traits.loadRhs(&blB[(0+K)*RhsProgress], B_0);                     \
+              traits.madd(A0, B_0, C0, B_0);                                    \
+              EIGEN_ASM_COMMENT("end step of gebp micro kernel 1pX1");          \
+            } while(false);
+
+            EIGEN_GEBGP_ONESTEP(0);
+            EIGEN_GEBGP_ONESTEP(1);
+            EIGEN_GEBGP_ONESTEP(2);
+            EIGEN_GEBGP_ONESTEP(3);
+            EIGEN_GEBGP_ONESTEP(4);
+            EIGEN_GEBGP_ONESTEP(5);
+            EIGEN_GEBGP_ONESTEP(6);
+            EIGEN_GEBGP_ONESTEP(7);
+
+            blB += pk*RhsProgress;
+            blA += pk*1*Traits::LhsProgress;
+
+            EIGEN_ASM_COMMENT("end gebp micro kernel 1pX1");
+          }
+
+          // process remaining peeled loop
+          for(Index k=peeled_kc; k<depth; k++)
+          {
+            RhsPacket B_0;
+            EIGEN_GEBGP_ONESTEP(0);
+            blB += RhsProgress;
+            blA += 1*Traits::LhsProgress;
+          }
+#undef EIGEN_GEBGP_ONESTEP
+          ResPacket R0;
+          ResPacket alphav = pset1<ResPacket>(alpha);
+          R0 = r0.loadPacket(0 * Traits::ResPacketSize);
+          traits.acc(C0, alphav, R0);
+          r0.storePacket(0 * Traits::ResPacketSize, R0);
+        }
+      }
+    }
+    //---------- Process remaining rows, 1 at once ----------
+    if(peeled_mc1<rows)
+    {
+      // loop on each panel of the rhs
+      for(Index j2=0; j2<packet_cols4; j2+=nr)
+      {
+        // loop on each row of the lhs (1*LhsProgress x depth)
+        for(Index i=peeled_mc1; i<rows; i+=1)
+        {
+          const LhsScalar* blA = &blockA[i*strideA+offsetA];
+          prefetch(&blA[0]);
+          const RhsScalar* blB = &blockB[j2*strideB+offsetB*nr];
+
+          // The following piece of code wont work for 512 bit registers
+          // Moreover, if LhsProgress==8 it assumes that there is a half packet of the same size
+          // as nr (which is currently 4) for the return type.
+          typedef typename unpacket_traits<SResPacket>::half SResPacketHalf;
+          if ((SwappedTraits::LhsProgress % 4) == 0 &&
+              (SwappedTraits::LhsProgress <= 8) &&
+              (SwappedTraits::LhsProgress!=8 || unpacket_traits<SResPacketHalf>::size==nr))
+          {
+            SAccPacket C0, C1, C2, C3;
+            straits.initAcc(C0);
+            straits.initAcc(C1);
+            straits.initAcc(C2);
+            straits.initAcc(C3);
+
+            const Index spk   = (std::max)(1,SwappedTraits::LhsProgress/4);
+            const Index endk  = (depth/spk)*spk;
+            const Index endk4 = (depth/(spk*4))*(spk*4);
+
+            Index k=0;
+            for(; k<endk4; k+=4*spk)
+            {
+              SLhsPacket A0,A1;
+              SRhsPacket B_0,B_1;
+
+              straits.loadLhsUnaligned(blB+0*SwappedTraits::LhsProgress, A0);
+              straits.loadLhsUnaligned(blB+1*SwappedTraits::LhsProgress, A1);
+
+              straits.loadRhsQuad(blA+0*spk, B_0);
+              straits.loadRhsQuad(blA+1*spk, B_1);
+              straits.madd(A0,B_0,C0,B_0);
+              straits.madd(A1,B_1,C1,B_1);
+
+              straits.loadLhsUnaligned(blB+2*SwappedTraits::LhsProgress, A0);
+              straits.loadLhsUnaligned(blB+3*SwappedTraits::LhsProgress, A1);
+              straits.loadRhsQuad(blA+2*spk, B_0);
+              straits.loadRhsQuad(blA+3*spk, B_1);
+              straits.madd(A0,B_0,C2,B_0);
+              straits.madd(A1,B_1,C3,B_1);
+
+              blB += 4*SwappedTraits::LhsProgress;
+              blA += 4*spk;
+            }
+            C0 = padd(padd(C0,C1),padd(C2,C3));
+            for(; k<endk; k+=spk)
+            {
+              SLhsPacket A0;
+              SRhsPacket B_0;
+
+              straits.loadLhsUnaligned(blB, A0);
+              straits.loadRhsQuad(blA, B_0);
+              straits.madd(A0,B_0,C0,B_0);
+
+              blB += SwappedTraits::LhsProgress;
+              blA += spk;
+            }
+            if(SwappedTraits::LhsProgress==8)
+            {
+              // Special case where we have to first reduce the accumulation register C0
+              typedef typename conditional<SwappedTraits::LhsProgress>=8,typename unpacket_traits<SResPacket>::half,SResPacket>::type SResPacketHalf;
+              typedef typename conditional<SwappedTraits::LhsProgress>=8,typename unpacket_traits<SLhsPacket>::half,SLhsPacket>::type SLhsPacketHalf;
+              typedef typename conditional<SwappedTraits::LhsProgress>=8,typename unpacket_traits<SLhsPacket>::half,SRhsPacket>::type SRhsPacketHalf;
+              typedef typename conditional<SwappedTraits::LhsProgress>=8,typename unpacket_traits<SAccPacket>::half,SAccPacket>::type SAccPacketHalf;
+
+              SResPacketHalf R = res.template gatherPacket<SResPacketHalf>(i, j2);
+              SResPacketHalf alphav = pset1<SResPacketHalf>(alpha);
+
+              if(depth-endk>0)
+              {
+                // We have to handle the last row of the rhs which corresponds to a half-packet
+                SLhsPacketHalf a0;
+                SRhsPacketHalf b0;
+                straits.loadLhsUnaligned(blB, a0);
+                straits.loadRhs(blA, b0);
+                SAccPacketHalf c0 = predux_downto4(C0);
+                straits.madd(a0,b0,c0,b0);
+                straits.acc(c0, alphav, R);
+              }
+              else
+              {
+                straits.acc(predux_downto4(C0), alphav, R);
+              }
+              res.scatterPacket(i, j2, R);
+            }
+            else
+            {
+              SResPacket R = res.template gatherPacket<SResPacket>(i, j2);
+              SResPacket alphav = pset1<SResPacket>(alpha);
+              straits.acc(C0, alphav, R);
+              res.scatterPacket(i, j2, R);
+            }
+          }
+          else // scalar path
+          {
+            // get a 1 x 4 res block as registers
+            ResScalar C0(0), C1(0), C2(0), C3(0);
+
+            for(Index k=0; k<depth; k++)
+            {
+              LhsScalar A0;
+              RhsScalar B_0, B_1;
+
+              A0 = blA[k];
+
+              B_0 = blB[0];
+              B_1 = blB[1];
+              CJMADD(cj,A0,B_0,C0,  B_0);
+              CJMADD(cj,A0,B_1,C1,  B_1);
+              
+              B_0 = blB[2];
+              B_1 = blB[3];
+              CJMADD(cj,A0,B_0,C2,  B_0);
+              CJMADD(cj,A0,B_1,C3,  B_1);
+              
+              blB += 4;
+            }
+            res(i, j2 + 0) += alpha * C0;
+            res(i, j2 + 1) += alpha * C1;
+            res(i, j2 + 2) += alpha * C2;
+            res(i, j2 + 3) += alpha * C3;
+          }
+        }
+      }
+      // remaining columns
+      for(Index j2=packet_cols4; j2<cols; j2++)
+      {
+        // loop on each row of the lhs (1*LhsProgress x depth)
+        for(Index i=peeled_mc1; i<rows; i+=1)
+        {
+          const LhsScalar* blA = &blockA[i*strideA+offsetA];
+          prefetch(&blA[0]);
+          // gets a 1 x 1 res block as registers
+          ResScalar C0(0);
+          const RhsScalar* blB = &blockB[j2*strideB+offsetB];
+          for(Index k=0; k<depth; k++)
+          {
+            LhsScalar A0 = blA[k];
+            RhsScalar B_0 = blB[k];
+            CJMADD(cj, A0, B_0, C0, B_0);
+          }
+          res(i, j2) += alpha * C0;
+        }
+      }
+    }
+  }
+
+
+#undef CJMADD
+
+// pack a block of the lhs
+// The traversal is as follow (mr==4):
+//   0  4  8 12 ...
+//   1  5  9 13 ...
+//   2  6 10 14 ...
+//   3  7 11 15 ...
+//
+//  16 20 24 28 ...
+//  17 21 25 29 ...
+//  18 22 26 30 ...
+//  19 23 27 31 ...
+//
+//  32 33 34 35 ...
+//  36 36 38 39 ...
+template<typename Scalar, typename Index, typename DataMapper, int Pack1, int Pack2, bool Conjugate, bool PanelMode>
+struct gemm_pack_lhs<Scalar, Index, DataMapper, Pack1, Pack2, ColMajor, Conjugate, PanelMode>
+{
+  typedef typename DataMapper::LinearMapper LinearMapper;
+  EIGEN_DONT_INLINE void operator()(Scalar* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride=0, Index offset=0);
+};
+
+template<typename Scalar, typename Index, typename DataMapper, int Pack1, int Pack2, bool Conjugate, bool PanelMode>
+EIGEN_DONT_INLINE void gemm_pack_lhs<Scalar, Index, DataMapper, Pack1, Pack2, ColMajor, Conjugate, PanelMode>
+  ::operator()(Scalar* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
+{
+  typedef typename packet_traits<Scalar>::type Packet;
+  enum { PacketSize = packet_traits<Scalar>::size };
+
+  EIGEN_ASM_COMMENT("EIGEN PRODUCT PACK LHS");
+  EIGEN_UNUSED_VARIABLE(stride);
+  EIGEN_UNUSED_VARIABLE(offset);
+  eigen_assert(((!PanelMode) && stride==0 && offset==0) || (PanelMode && stride>=depth && offset<=stride));
+  eigen_assert( ((Pack1%PacketSize)==0 && Pack1<=4*PacketSize) || (Pack1<=4) );
+  conj_if<NumTraits<Scalar>::IsComplex && Conjugate> cj;
+  Index count = 0;
+
+  const Index peeled_mc3 = Pack1>=3*PacketSize ? (rows/(3*PacketSize))*(3*PacketSize) : 0;
+  const Index peeled_mc2 = Pack1>=2*PacketSize ? peeled_mc3+((rows-peeled_mc3)/(2*PacketSize))*(2*PacketSize) : 0;
+  const Index peeled_mc1 = Pack1>=1*PacketSize ? (rows/(1*PacketSize))*(1*PacketSize) : 0;
+  const Index peeled_mc0 = Pack2>=1*PacketSize ? peeled_mc1
+                         : Pack2>1             ? (rows/Pack2)*Pack2 : 0;
+
+  Index i=0;
+
+  // Pack 3 packets
+  if(Pack1>=3*PacketSize)
+  {
+    for(; i<peeled_mc3; i+=3*PacketSize)
+    {
+      if(PanelMode) count += (3*PacketSize) * offset;
+
+      for(Index k=0; k<depth; k++)
+      {
+        Packet A, B, C;
+        A = lhs.loadPacket(i+0*PacketSize, k);
+        B = lhs.loadPacket(i+1*PacketSize, k);
+        C = lhs.loadPacket(i+2*PacketSize, k);
+        pstore(blockA+count, cj.pconj(A)); count+=PacketSize;
+        pstore(blockA+count, cj.pconj(B)); count+=PacketSize;
+        pstore(blockA+count, cj.pconj(C)); count+=PacketSize;
+      }
+      if(PanelMode) count += (3*PacketSize) * (stride-offset-depth);
+    }
+  }
+  // Pack 2 packets
+  if(Pack1>=2*PacketSize)
+  {
+    for(; i<peeled_mc2; i+=2*PacketSize)
+    {
+      if(PanelMode) count += (2*PacketSize) * offset;
+
+      for(Index k=0; k<depth; k++)
+      {
+        Packet A, B;
+        A = lhs.loadPacket(i+0*PacketSize, k);
+        B = lhs.loadPacket(i+1*PacketSize, k);
+        pstore(blockA+count, cj.pconj(A)); count+=PacketSize;
+        pstore(blockA+count, cj.pconj(B)); count+=PacketSize;
+      }
+      if(PanelMode) count += (2*PacketSize) * (stride-offset-depth);
+    }
+  }
+  // Pack 1 packets
+  if(Pack1>=1*PacketSize)
+  {
+    for(; i<peeled_mc1; i+=1*PacketSize)
+    {
+      if(PanelMode) count += (1*PacketSize) * offset;
+
+      for(Index k=0; k<depth; k++)
+      {
+        Packet A;
+        A = lhs.loadPacket(i+0*PacketSize, k);
+        pstore(blockA+count, cj.pconj(A));
+        count+=PacketSize;
+      }
+      if(PanelMode) count += (1*PacketSize) * (stride-offset-depth);
+    }
+  }
+  // Pack scalars
+  if(Pack2<PacketSize && Pack2>1)
+  {
+    for(; i<peeled_mc0; i+=Pack2)
+    {
+      if(PanelMode) count += Pack2 * offset;
+
+      for(Index k=0; k<depth; k++)
+        for(Index w=0; w<Pack2; w++)
+          blockA[count++] = cj(lhs(i+w, k));
+
+      if(PanelMode) count += Pack2 * (stride-offset-depth);
+    }
+  }
+  for(; i<rows; i++)
+  {
+    if(PanelMode) count += offset;
+    for(Index k=0; k<depth; k++)
+      blockA[count++] = cj(lhs(i, k));
+    if(PanelMode) count += (stride-offset-depth);
+  }
+}
+
+template<typename Scalar, typename Index, typename DataMapper, int Pack1, int Pack2, bool Conjugate, bool PanelMode>
+struct gemm_pack_lhs<Scalar, Index, DataMapper, Pack1, Pack2, RowMajor, Conjugate, PanelMode>
+{
+  typedef typename DataMapper::LinearMapper LinearMapper;
+  EIGEN_DONT_INLINE void operator()(Scalar* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride=0, Index offset=0);
+};
+
+template<typename Scalar, typename Index, typename DataMapper, int Pack1, int Pack2, bool Conjugate, bool PanelMode>
+EIGEN_DONT_INLINE void gemm_pack_lhs<Scalar, Index, DataMapper, Pack1, Pack2, RowMajor, Conjugate, PanelMode>
+  ::operator()(Scalar* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
+{
+  typedef typename packet_traits<Scalar>::type Packet;
+  enum { PacketSize = packet_traits<Scalar>::size };
+
+  EIGEN_ASM_COMMENT("EIGEN PRODUCT PACK LHS");
+  EIGEN_UNUSED_VARIABLE(stride);
+  EIGEN_UNUSED_VARIABLE(offset);
+  eigen_assert(((!PanelMode) && stride==0 && offset==0) || (PanelMode && stride>=depth && offset<=stride));
+  conj_if<NumTraits<Scalar>::IsComplex && Conjugate> cj;
+  Index count = 0;
+
+//   const Index peeled_mc3 = Pack1>=3*PacketSize ? (rows/(3*PacketSize))*(3*PacketSize) : 0;
+//   const Index peeled_mc2 = Pack1>=2*PacketSize ? peeled_mc3+((rows-peeled_mc3)/(2*PacketSize))*(2*PacketSize) : 0;
+//   const Index peeled_mc1 = Pack1>=1*PacketSize ? (rows/(1*PacketSize))*(1*PacketSize) : 0;
+
+  int pack = Pack1;
+  Index i = 0;
+  while(pack>0)
+  {
+    Index remaining_rows = rows-i;
+    Index peeled_mc = i+(remaining_rows/pack)*pack;
+    for(; i<peeled_mc; i+=pack)
+    {
+      if(PanelMode) count += pack * offset;
+
+      const Index peeled_k = (depth/PacketSize)*PacketSize;
+      Index k=0;
+      if(pack>=PacketSize)
+      {
+        for(; k<peeled_k; k+=PacketSize)
+        {
+          for (Index m = 0; m < pack; m += PacketSize)
+          {
+            PacketBlock<Packet> kernel;
+            for (int p = 0; p < PacketSize; ++p) kernel.packet[p] = lhs.loadPacket(i+p+m, k);
+            ptranspose(kernel);
+            for (int p = 0; p < PacketSize; ++p) pstore(blockA+count+m+(pack)*p, cj.pconj(kernel.packet[p]));
+          }
+          count += PacketSize*pack;
+        }
+      }
+      for(; k<depth; k++)
+      {
+        Index w=0;
+        for(; w<pack-3; w+=4)
+        {
+          Scalar a(cj(lhs(i+w+0, k))),
+                 b(cj(lhs(i+w+1, k))),
+                 c(cj(lhs(i+w+2, k))),
+                 d(cj(lhs(i+w+3, k)));
+          blockA[count++] = a;
+          blockA[count++] = b;
+          blockA[count++] = c;
+          blockA[count++] = d;
+        }
+        if(pack%4)
+          for(;w<pack;++w)
+            blockA[count++] = cj(lhs(i+w, k));
+      }
+
+      if(PanelMode) count += pack * (stride-offset-depth);
+    }
+
+    pack -= PacketSize;
+    if(pack<Pack2 && (pack+PacketSize)!=Pack2)
+      pack = Pack2;
+  }
+
+  for(; i<rows; i++)
+  {
+    if(PanelMode) count += offset;
+    for(Index k=0; k<depth; k++)
+      blockA[count++] = cj(lhs(i, k));
+    if(PanelMode) count += (stride-offset-depth);
+  }
+}
+
+// copy a complete panel of the rhs
+// this version is optimized for column major matrices
+// The traversal order is as follow: (nr==4):
+//  0  1  2  3   12 13 14 15   24 27
+//  4  5  6  7   16 17 18 19   25 28
+//  8  9 10 11   20 21 22 23   26 29
+//  .  .  .  .    .  .  .  .    .  .
+template<typename Scalar, typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+struct gemm_pack_rhs<Scalar, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode>
+{
+  typedef typename packet_traits<Scalar>::type Packet;
+  typedef typename DataMapper::LinearMapper LinearMapper;
+  enum { PacketSize = packet_traits<Scalar>::size };
+  EIGEN_DONT_INLINE void operator()(Scalar* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride=0, Index offset=0);
+};
+
+template<typename Scalar, typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+EIGEN_DONT_INLINE void gemm_pack_rhs<Scalar, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode>
+  ::operator()(Scalar* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride, Index offset)
+{
+  EIGEN_ASM_COMMENT("EIGEN PRODUCT PACK RHS COLMAJOR");
+  EIGEN_UNUSED_VARIABLE(stride);
+  EIGEN_UNUSED_VARIABLE(offset);
+  eigen_assert(((!PanelMode) && stride==0 && offset==0) || (PanelMode && stride>=depth && offset<=stride));
+  conj_if<NumTraits<Scalar>::IsComplex && Conjugate> cj;
+  Index packet_cols8 = nr>=8 ? (cols/8) * 8 : 0;
+  Index packet_cols4 = nr>=4 ? (cols/4) * 4 : 0;
+  Index count = 0;
+  const Index peeled_k = (depth/PacketSize)*PacketSize;
+//   if(nr>=8)
+//   {
+//     for(Index j2=0; j2<packet_cols8; j2+=8)
+//     {
+//       // skip what we have before
+//       if(PanelMode) count += 8 * offset;
+//       const Scalar* b0 = &rhs[(j2+0)*rhsStride];
+//       const Scalar* b1 = &rhs[(j2+1)*rhsStride];
+//       const Scalar* b2 = &rhs[(j2+2)*rhsStride];
+//       const Scalar* b3 = &rhs[(j2+3)*rhsStride];
+//       const Scalar* b4 = &rhs[(j2+4)*rhsStride];
+//       const Scalar* b5 = &rhs[(j2+5)*rhsStride];
+//       const Scalar* b6 = &rhs[(j2+6)*rhsStride];
+//       const Scalar* b7 = &rhs[(j2+7)*rhsStride];
+//       Index k=0;
+//       if(PacketSize==8) // TODO enbale vectorized transposition for PacketSize==4
+//       {
+//         for(; k<peeled_k; k+=PacketSize) {
+//           PacketBlock<Packet> kernel;
+//           for (int p = 0; p < PacketSize; ++p) {
+//             kernel.packet[p] = ploadu<Packet>(&rhs[(j2+p)*rhsStride+k]);
+//           }
+//           ptranspose(kernel);
+//           for (int p = 0; p < PacketSize; ++p) {
+//             pstoreu(blockB+count, cj.pconj(kernel.packet[p]));
+//             count+=PacketSize;
+//           }
+//         }
+//       }
+//       for(; k<depth; k++)
+//       {
+//         blockB[count+0] = cj(b0[k]);
+//         blockB[count+1] = cj(b1[k]);
+//         blockB[count+2] = cj(b2[k]);
+//         blockB[count+3] = cj(b3[k]);
+//         blockB[count+4] = cj(b4[k]);
+//         blockB[count+5] = cj(b5[k]);
+//         blockB[count+6] = cj(b6[k]);
+//         blockB[count+7] = cj(b7[k]);
+//         count += 8;
+//       }
+//       // skip what we have after
+//       if(PanelMode) count += 8 * (stride-offset-depth);
+//     }
+//   }
+
+  if(nr>=4)
+  {
+    for(Index j2=packet_cols8; j2<packet_cols4; j2+=4)
+    {
+      // skip what we have before
+      if(PanelMode) count += 4 * offset;
+      const LinearMapper dm0 = rhs.getLinearMapper(0, j2 + 0);
+      const LinearMapper dm1 = rhs.getLinearMapper(0, j2 + 1);
+      const LinearMapper dm2 = rhs.getLinearMapper(0, j2 + 2);
+      const LinearMapper dm3 = rhs.getLinearMapper(0, j2 + 3);
+
+      Index k=0;
+      if((PacketSize%4)==0) // TODO enable vectorized transposition for PacketSize==2 ??
+      {
+        for(; k<peeled_k; k+=PacketSize) {
+          PacketBlock<Packet,(PacketSize%4)==0?4:PacketSize> kernel;
+          kernel.packet[0] = dm0.loadPacket(k);
+          kernel.packet[1%PacketSize] = dm1.loadPacket(k);
+          kernel.packet[2%PacketSize] = dm2.loadPacket(k);
+          kernel.packet[3%PacketSize] = dm3.loadPacket(k);
+          ptranspose(kernel);
+          pstoreu(blockB+count+0*PacketSize, cj.pconj(kernel.packet[0]));
+          pstoreu(blockB+count+1*PacketSize, cj.pconj(kernel.packet[1%PacketSize]));
+          pstoreu(blockB+count+2*PacketSize, cj.pconj(kernel.packet[2%PacketSize]));
+          pstoreu(blockB+count+3*PacketSize, cj.pconj(kernel.packet[3%PacketSize]));
+          count+=4*PacketSize;
+        }
+      }
+      for(; k<depth; k++)
+      {
+        blockB[count+0] = cj(dm0(k));
+        blockB[count+1] = cj(dm1(k));
+        blockB[count+2] = cj(dm2(k));
+        blockB[count+3] = cj(dm3(k));
+        count += 4;
+      }
+      // skip what we have after
+      if(PanelMode) count += 4 * (stride-offset-depth);
+    }
+  }
+
+  // copy the remaining columns one at a time (nr==1)
+  for(Index j2=packet_cols4; j2<cols; ++j2)
+  {
+    if(PanelMode) count += offset;
+    const LinearMapper dm0 = rhs.getLinearMapper(0, j2);
+    for(Index k=0; k<depth; k++)
+    {
+      blockB[count] = cj(dm0(k));
+      count += 1;
+    }
+    if(PanelMode) count += (stride-offset-depth);
+  }
+}
+
+// this version is optimized for row major matrices
+template<typename Scalar, typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+struct gemm_pack_rhs<Scalar, Index, DataMapper, nr, RowMajor, Conjugate, PanelMode>
+{
+  typedef typename packet_traits<Scalar>::type Packet;
+  typedef typename DataMapper::LinearMapper LinearMapper;
+  enum { PacketSize = packet_traits<Scalar>::size };
+  EIGEN_DONT_INLINE void operator()(Scalar* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride=0, Index offset=0);
+};
+
+template<typename Scalar, typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+EIGEN_DONT_INLINE void gemm_pack_rhs<Scalar, Index, DataMapper, nr, RowMajor, Conjugate, PanelMode>
+  ::operator()(Scalar* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride, Index offset)
+{
+  EIGEN_ASM_COMMENT("EIGEN PRODUCT PACK RHS ROWMAJOR");
+  EIGEN_UNUSED_VARIABLE(stride);
+  EIGEN_UNUSED_VARIABLE(offset);
+  eigen_assert(((!PanelMode) && stride==0 && offset==0) || (PanelMode && stride>=depth && offset<=stride));
+  conj_if<NumTraits<Scalar>::IsComplex && Conjugate> cj;
+  Index packet_cols8 = nr>=8 ? (cols/8) * 8 : 0;
+  Index packet_cols4 = nr>=4 ? (cols/4) * 4 : 0;
+  Index count = 0;
+
+//   if(nr>=8)
+//   {
+//     for(Index j2=0; j2<packet_cols8; j2+=8)
+//     {
+//       // skip what we have before
+//       if(PanelMode) count += 8 * offset;
+//       for(Index k=0; k<depth; k++)
+//       {
+//         if (PacketSize==8) {
+//           Packet A = ploadu<Packet>(&rhs[k*rhsStride + j2]);
+//           pstoreu(blockB+count, cj.pconj(A));
+//         } else if (PacketSize==4) {
+//           Packet A = ploadu<Packet>(&rhs[k*rhsStride + j2]);
+//           Packet B = ploadu<Packet>(&rhs[k*rhsStride + j2 + PacketSize]);
+//           pstoreu(blockB+count, cj.pconj(A));
+//           pstoreu(blockB+count+PacketSize, cj.pconj(B));
+//         } else {
+//           const Scalar* b0 = &rhs[k*rhsStride + j2];
+//           blockB[count+0] = cj(b0[0]);
+//           blockB[count+1] = cj(b0[1]);
+//           blockB[count+2] = cj(b0[2]);
+//           blockB[count+3] = cj(b0[3]);
+//           blockB[count+4] = cj(b0[4]);
+//           blockB[count+5] = cj(b0[5]);
+//           blockB[count+6] = cj(b0[6]);
+//           blockB[count+7] = cj(b0[7]);
+//         }
+//         count += 8;
+//       }
+//       // skip what we have after
+//       if(PanelMode) count += 8 * (stride-offset-depth);
+//     }
+//   }
+  if(nr>=4)
+  {
+    for(Index j2=packet_cols8; j2<packet_cols4; j2+=4)
+    {
+      // skip what we have before
+      if(PanelMode) count += 4 * offset;
+      for(Index k=0; k<depth; k++)
+      {
+        if (PacketSize==4) {
+          Packet A = rhs.loadPacket(k, j2);
+          pstoreu(blockB+count, cj.pconj(A));
+          count += PacketSize;
+        } else {
+          const LinearMapper dm0 = rhs.getLinearMapper(k, j2);
+          blockB[count+0] = cj(dm0(0));
+          blockB[count+1] = cj(dm0(1));
+          blockB[count+2] = cj(dm0(2));
+          blockB[count+3] = cj(dm0(3));
+          count += 4;
+        }
+      }
+      // skip what we have after
+      if(PanelMode) count += 4 * (stride-offset-depth);
+    }
+  }
+  // copy the remaining columns one at a time (nr==1)
+  for(Index j2=packet_cols4; j2<cols; ++j2)
+  {
+    if(PanelMode) count += offset;
+    for(Index k=0; k<depth; k++)
+    {
+      blockB[count] = cj(rhs(k, j2));
+      count += 1;
+    }
+    if(PanelMode) count += stride-offset-depth;
+  }
+}
+
+} // end namespace internal
+
+/** \returns the currently set level 1 cpu cache size (in bytes) used to estimate the ideal blocking size parameters.
+  * \sa setCpuCacheSize */
+inline std::ptrdiff_t l1CacheSize()
+{
+  std::ptrdiff_t l1, l2, l3;
+  internal::manage_caching_sizes(GetAction, &l1, &l2, &l3);
+  return l1;
+}
+
+/** \returns the currently set level 2 cpu cache size (in bytes) used to estimate the ideal blocking size parameters.
+  * \sa setCpuCacheSize */
+inline std::ptrdiff_t l2CacheSize()
+{
+  std::ptrdiff_t l1, l2, l3;
+  internal::manage_caching_sizes(GetAction, &l1, &l2, &l3);
+  return l2;
+}
+
+/** \returns the currently set level 3 cpu cache size (in bytes) used to estimate the ideal blocking size paramete\
+rs.                                                                                                                
+* \sa setCpuCacheSize */
+inline std::ptrdiff_t l3CacheSize()
+{
+  std::ptrdiff_t l1, l2, l3;
+  internal::manage_caching_sizes(GetAction, &l1, &l2, &l3);
+  return l3;
+}
+
+/** Set the cpu L1 and L2 cache sizes (in bytes).
+  * These values are use to adjust the size of the blocks
+  * for the algorithms working per blocks.
+  *
+  * \sa computeProductBlockingSizes */
+inline void setCpuCacheSizes(std::ptrdiff_t l1, std::ptrdiff_t l2, std::ptrdiff_t l3)
+{
+  internal::manage_caching_sizes(SetAction, &l1, &l2, &l3);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_GENERAL_BLOCK_PANEL_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/GeneralMatrixMatrix.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/GeneralMatrixMatrix.h
new file mode 100644
index 00000000..ed4d3182
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/GeneralMatrixMatrix.h
@@ -0,0 +1,498 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GENERAL_MATRIX_MATRIX_H
+#define EIGEN_GENERAL_MATRIX_MATRIX_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename _LhsScalar, typename _RhsScalar> class level3_blocking;
+
+/* Specialization for a row-major destination matrix => simple transposition of the product */
+template<
+  typename Index,
+  typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs,
+  typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs>
+struct general_matrix_matrix_product<Index,LhsScalar,LhsStorageOrder,ConjugateLhs,RhsScalar,RhsStorageOrder,ConjugateRhs,RowMajor>
+{
+  typedef gebp_traits<RhsScalar,LhsScalar> Traits;
+
+  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+  static EIGEN_STRONG_INLINE void run(
+    Index rows, Index cols, Index depth,
+    const LhsScalar* lhs, Index lhsStride,
+    const RhsScalar* rhs, Index rhsStride,
+    ResScalar* res, Index resStride,
+    ResScalar alpha,
+    level3_blocking<RhsScalar,LhsScalar>& blocking,
+    GemmParallelInfo<Index>* info = 0)
+  {
+    // transpose the product such that the result is column major
+    general_matrix_matrix_product<Index,
+      RhsScalar, RhsStorageOrder==RowMajor ? ColMajor : RowMajor, ConjugateRhs,
+      LhsScalar, LhsStorageOrder==RowMajor ? ColMajor : RowMajor, ConjugateLhs,
+      ColMajor>
+    ::run(cols,rows,depth,rhs,rhsStride,lhs,lhsStride,res,resStride,alpha,blocking,info);
+  }
+};
+
+/*  Specialization for a col-major destination matrix
+ *    => Blocking algorithm following Goto's paper */
+template<
+  typename Index,
+  typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs,
+  typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs>
+struct general_matrix_matrix_product<Index,LhsScalar,LhsStorageOrder,ConjugateLhs,RhsScalar,RhsStorageOrder,ConjugateRhs,ColMajor>
+{
+
+typedef gebp_traits<LhsScalar,RhsScalar> Traits;
+
+typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+static void run(Index rows, Index cols, Index depth,
+  const LhsScalar* _lhs, Index lhsStride,
+  const RhsScalar* _rhs, Index rhsStride,
+  ResScalar* _res, Index resStride,
+  ResScalar alpha,
+  level3_blocking<LhsScalar,RhsScalar>& blocking,
+  GemmParallelInfo<Index>* info = 0)
+{
+  typedef const_blas_data_mapper<LhsScalar, Index, LhsStorageOrder> LhsMapper;
+  typedef const_blas_data_mapper<RhsScalar, Index, RhsStorageOrder> RhsMapper;
+  typedef blas_data_mapper<typename Traits::ResScalar, Index, ColMajor> ResMapper;
+  LhsMapper lhs(_lhs,lhsStride);
+  RhsMapper rhs(_rhs,rhsStride);
+  ResMapper res(_res, resStride);
+
+  Index kc = blocking.kc();                   // cache block size along the K direction
+  Index mc = (std::min)(rows,blocking.mc());  // cache block size along the M direction
+  Index nc = (std::min)(cols,blocking.nc());  // cache block size along the N direction
+
+  gemm_pack_lhs<LhsScalar, Index, LhsMapper, Traits::mr, Traits::LhsProgress, LhsStorageOrder> pack_lhs;
+  gemm_pack_rhs<RhsScalar, Index, RhsMapper, Traits::nr, RhsStorageOrder> pack_rhs;
+  gebp_kernel<LhsScalar, RhsScalar, Index, ResMapper, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp;
+
+#ifdef EIGEN_HAS_OPENMP
+  if(info)
+  {
+    // this is the parallel version!
+    int tid = omp_get_thread_num();
+    int threads = omp_get_num_threads();
+
+    LhsScalar* blockA = blocking.blockA();
+    eigen_internal_assert(blockA!=0);
+
+    std::size_t sizeB = kc*nc;
+    ei_declare_aligned_stack_constructed_variable(RhsScalar, blockB, sizeB, 0);
+
+    // For each horizontal panel of the rhs, and corresponding vertical panel of the lhs...
+    for(Index k=0; k<depth; k+=kc)
+    {
+      const Index actual_kc = (std::min)(k+kc,depth)-k; // => rows of B', and cols of the A'
+
+      // In order to reduce the chance that a thread has to wait for the other,
+      // let's start by packing B'.
+      pack_rhs(blockB, rhs.getSubMapper(k,0), actual_kc, nc);
+
+      // Pack A_k to A' in a parallel fashion:
+      // each thread packs the sub block A_k,i to A'_i where i is the thread id.
+
+      // However, before copying to A'_i, we have to make sure that no other thread is still using it,
+      // i.e., we test that info[tid].users equals 0.
+      // Then, we set info[tid].users to the number of threads to mark that all other threads are going to use it.
+      while(info[tid].users!=0) {}
+      info[tid].users += threads;
+
+      pack_lhs(blockA+info[tid].lhs_start*actual_kc, lhs.getSubMapper(info[tid].lhs_start,k), actual_kc, info[tid].lhs_length);
+
+      // Notify the other threads that the part A'_i is ready to go.
+      info[tid].sync = k;
+
+      // Computes C_i += A' * B' per A'_i
+      for(int shift=0; shift<threads; ++shift)
+      {
+        int i = (tid+shift)%threads;
+
+        // At this point we have to make sure that A'_i has been updated by the thread i,
+        // we use testAndSetOrdered to mimic a volatile access.
+        // However, no need to wait for the B' part which has been updated by the current thread!
+        if (shift>0) {
+          while(info[i].sync!=k) {
+          }
+        }
+
+        gebp(res.getSubMapper(info[i].lhs_start, 0), blockA+info[i].lhs_start*actual_kc, blockB, info[i].lhs_length, actual_kc, nc, alpha);
+      }
+
+      // Then keep going as usual with the remaining B'
+      for(Index j=nc; j<cols; j+=nc)
+      {
+        const Index actual_nc = (std::min)(j+nc,cols)-j;
+
+        // pack B_k,j to B'
+        pack_rhs(blockB, rhs.getSubMapper(k,j), actual_kc, actual_nc);
+
+        // C_j += A' * B'
+        gebp(res.getSubMapper(0, j), blockA, blockB, rows, actual_kc, actual_nc, alpha);
+      }
+
+      // Release all the sub blocks A'_i of A' for the current thread,
+      // i.e., we simply decrement the number of users by 1
+      for(Index i=0; i<threads; ++i)
+        #pragma omp atomic
+        info[i].users -= 1;
+    }
+  }
+  else
+#endif // EIGEN_HAS_OPENMP
+  {
+    EIGEN_UNUSED_VARIABLE(info);
+
+    // this is the sequential version!
+    std::size_t sizeA = kc*mc;
+    std::size_t sizeB = kc*nc;
+
+    ei_declare_aligned_stack_constructed_variable(LhsScalar, blockA, sizeA, blocking.blockA());
+    ei_declare_aligned_stack_constructed_variable(RhsScalar, blockB, sizeB, blocking.blockB());
+
+    const bool pack_rhs_once = mc!=rows && kc==depth && nc==cols;
+
+    // For each horizontal panel of the rhs, and corresponding panel of the lhs...
+    for(Index i2=0; i2<rows; i2+=mc)
+    {
+      const Index actual_mc = (std::min)(i2+mc,rows)-i2;
+
+      for(Index k2=0; k2<depth; k2+=kc)
+      {
+        const Index actual_kc = (std::min)(k2+kc,depth)-k2;
+
+        // OK, here we have selected one horizontal panel of rhs and one vertical panel of lhs.
+        // => Pack lhs's panel into a sequential chunk of memory (L2/L3 caching)
+        // Note that this panel will be read as many times as the number of blocks in the rhs's
+        // horizontal panel which is, in practice, a very low number.
+        pack_lhs(blockA, lhs.getSubMapper(i2,k2), actual_kc, actual_mc);
+
+        // For each kc x nc block of the rhs's horizontal panel...
+        for(Index j2=0; j2<cols; j2+=nc)
+        {
+          const Index actual_nc = (std::min)(j2+nc,cols)-j2;
+
+          // We pack the rhs's block into a sequential chunk of memory (L2 caching)
+          // Note that this block will be read a very high number of times, which is equal to the number of
+          // micro horizontal panel of the large rhs's panel (e.g., rows/12 times).
+          if((!pack_rhs_once) || i2==0)
+            pack_rhs(blockB, rhs.getSubMapper(k2,j2), actual_kc, actual_nc);
+
+          // Everything is packed, we can now call the panel * block kernel:
+          gebp(res.getSubMapper(i2, j2), blockA, blockB, actual_mc, actual_kc, actual_nc, alpha);
+        }
+      }
+    }
+  }
+}
+
+};
+
+/*********************************************************************************
+*  Specialization of generic_product_impl for "large" GEMM, i.e.,
+*  implementation of the high level wrapper to general_matrix_matrix_product
+**********************************************************************************/
+
+template<typename Scalar, typename Index, typename Gemm, typename Lhs, typename Rhs, typename Dest, typename BlockingType>
+struct gemm_functor
+{
+  gemm_functor(const Lhs& lhs, const Rhs& rhs, Dest& dest, const Scalar& actualAlpha, BlockingType& blocking)
+    : m_lhs(lhs), m_rhs(rhs), m_dest(dest), m_actualAlpha(actualAlpha), m_blocking(blocking)
+  {}
+
+  void initParallelSession(Index num_threads) const
+  {
+    m_blocking.initParallel(m_lhs.rows(), m_rhs.cols(), m_lhs.cols(), num_threads);
+    m_blocking.allocateA();
+  }
+
+  void operator() (Index row, Index rows, Index col=0, Index cols=-1, GemmParallelInfo<Index>* info=0) const
+  {
+    if(cols==-1)
+      cols = m_rhs.cols();
+
+    Gemm::run(rows, cols, m_lhs.cols(),
+              &m_lhs.coeffRef(row,0), m_lhs.outerStride(),
+              &m_rhs.coeffRef(0,col), m_rhs.outerStride(),
+              (Scalar*)&(m_dest.coeffRef(row,col)), m_dest.outerStride(),
+              m_actualAlpha, m_blocking, info);
+  }
+
+  typedef typename Gemm::Traits Traits;
+
+  protected:
+    const Lhs& m_lhs;
+    const Rhs& m_rhs;
+    Dest& m_dest;
+    Scalar m_actualAlpha;
+    BlockingType& m_blocking;
+};
+
+template<int StorageOrder, typename LhsScalar, typename RhsScalar, int MaxRows, int MaxCols, int MaxDepth, int KcFactor=1,
+bool FiniteAtCompileTime = MaxRows!=Dynamic && MaxCols!=Dynamic && MaxDepth != Dynamic> class gemm_blocking_space;
+
+template<typename _LhsScalar, typename _RhsScalar>
+class level3_blocking
+{
+    typedef _LhsScalar LhsScalar;
+    typedef _RhsScalar RhsScalar;
+
+  protected:
+    LhsScalar* m_blockA;
+    RhsScalar* m_blockB;
+
+    Index m_mc;
+    Index m_nc;
+    Index m_kc;
+
+  public:
+
+    level3_blocking()
+      : m_blockA(0), m_blockB(0), m_mc(0), m_nc(0), m_kc(0)
+    {}
+
+    inline Index mc() const { return m_mc; }
+    inline Index nc() const { return m_nc; }
+    inline Index kc() const { return m_kc; }
+
+    inline LhsScalar* blockA() { return m_blockA; }
+    inline RhsScalar* blockB() { return m_blockB; }
+};
+
+template<int StorageOrder, typename _LhsScalar, typename _RhsScalar, int MaxRows, int MaxCols, int MaxDepth, int KcFactor>
+class gemm_blocking_space<StorageOrder,_LhsScalar,_RhsScalar,MaxRows, MaxCols, MaxDepth, KcFactor, true /* == FiniteAtCompileTime */>
+  : public level3_blocking<
+      typename conditional<StorageOrder==RowMajor,_RhsScalar,_LhsScalar>::type,
+      typename conditional<StorageOrder==RowMajor,_LhsScalar,_RhsScalar>::type>
+{
+    enum {
+      Transpose = StorageOrder==RowMajor,
+      ActualRows = Transpose ? MaxCols : MaxRows,
+      ActualCols = Transpose ? MaxRows : MaxCols
+    };
+    typedef typename conditional<Transpose,_RhsScalar,_LhsScalar>::type LhsScalar;
+    typedef typename conditional<Transpose,_LhsScalar,_RhsScalar>::type RhsScalar;
+    typedef gebp_traits<LhsScalar,RhsScalar> Traits;
+    enum {
+      SizeA = ActualRows * MaxDepth,
+      SizeB = ActualCols * MaxDepth
+    };
+
+#if EIGEN_MAX_STATIC_ALIGN_BYTES >= EIGEN_DEFAULT_ALIGN_BYTES
+    EIGEN_ALIGN_MAX LhsScalar m_staticA[SizeA];
+    EIGEN_ALIGN_MAX RhsScalar m_staticB[SizeB];
+#else
+    EIGEN_ALIGN_MAX char m_staticA[SizeA * sizeof(LhsScalar) + EIGEN_DEFAULT_ALIGN_BYTES-1];
+    EIGEN_ALIGN_MAX char m_staticB[SizeB * sizeof(RhsScalar) + EIGEN_DEFAULT_ALIGN_BYTES-1];
+#endif
+
+  public:
+
+    gemm_blocking_space(Index /*rows*/, Index /*cols*/, Index /*depth*/, Index /*num_threads*/, bool /*full_rows = false*/)
+    {
+      this->m_mc = ActualRows;
+      this->m_nc = ActualCols;
+      this->m_kc = MaxDepth;
+#if EIGEN_MAX_STATIC_ALIGN_BYTES >= EIGEN_DEFAULT_ALIGN_BYTES
+      this->m_blockA = m_staticA;
+      this->m_blockB = m_staticB;
+#else
+      this->m_blockA = reinterpret_cast<LhsScalar*>((internal::UIntPtr(m_staticA) + (EIGEN_DEFAULT_ALIGN_BYTES-1)) & ~std::size_t(EIGEN_DEFAULT_ALIGN_BYTES-1));
+      this->m_blockB = reinterpret_cast<RhsScalar*>((internal::UIntPtr(m_staticB) + (EIGEN_DEFAULT_ALIGN_BYTES-1)) & ~std::size_t(EIGEN_DEFAULT_ALIGN_BYTES-1));
+#endif
+    }
+
+    void initParallel(Index, Index, Index, Index)
+    {}
+
+    inline void allocateA() {}
+    inline void allocateB() {}
+    inline void allocateAll() {}
+};
+
+template<int StorageOrder, typename _LhsScalar, typename _RhsScalar, int MaxRows, int MaxCols, int MaxDepth, int KcFactor>
+class gemm_blocking_space<StorageOrder,_LhsScalar,_RhsScalar,MaxRows, MaxCols, MaxDepth, KcFactor, false>
+  : public level3_blocking<
+      typename conditional<StorageOrder==RowMajor,_RhsScalar,_LhsScalar>::type,
+      typename conditional<StorageOrder==RowMajor,_LhsScalar,_RhsScalar>::type>
+{
+    enum {
+      Transpose = StorageOrder==RowMajor
+    };
+    typedef typename conditional<Transpose,_RhsScalar,_LhsScalar>::type LhsScalar;
+    typedef typename conditional<Transpose,_LhsScalar,_RhsScalar>::type RhsScalar;
+    typedef gebp_traits<LhsScalar,RhsScalar> Traits;
+
+    Index m_sizeA;
+    Index m_sizeB;
+
+  public:
+
+    gemm_blocking_space(Index rows, Index cols, Index depth, Index num_threads, bool l3_blocking)
+    {
+      this->m_mc = Transpose ? cols : rows;
+      this->m_nc = Transpose ? rows : cols;
+      this->m_kc = depth;
+
+      if(l3_blocking)
+      {
+        computeProductBlockingSizes<LhsScalar,RhsScalar,KcFactor>(this->m_kc, this->m_mc, this->m_nc, num_threads);
+      }
+      else  // no l3 blocking
+      {
+        Index n = this->m_nc;
+        computeProductBlockingSizes<LhsScalar,RhsScalar,KcFactor>(this->m_kc, this->m_mc, n, num_threads);
+      }
+
+      m_sizeA = this->m_mc * this->m_kc;
+      m_sizeB = this->m_kc * this->m_nc;
+    }
+
+    void initParallel(Index rows, Index cols, Index depth, Index num_threads)
+    {
+      this->m_mc = Transpose ? cols : rows;
+      this->m_nc = Transpose ? rows : cols;
+      this->m_kc = depth;
+
+      eigen_internal_assert(this->m_blockA==0 && this->m_blockB==0);
+      Index m = this->m_mc;
+      computeProductBlockingSizes<LhsScalar,RhsScalar,KcFactor>(this->m_kc, m, this->m_nc, num_threads);
+      m_sizeA = this->m_mc * this->m_kc;
+      m_sizeB = this->m_kc * this->m_nc;
+    }
+
+    void allocateA()
+    {
+      if(this->m_blockA==0)
+        this->m_blockA = aligned_new<LhsScalar>(m_sizeA);
+    }
+
+    void allocateB()
+    {
+      if(this->m_blockB==0)
+        this->m_blockB = aligned_new<RhsScalar>(m_sizeB);
+    }
+
+    void allocateAll()
+    {
+      allocateA();
+      allocateB();
+    }
+
+    ~gemm_blocking_space()
+    {
+      aligned_delete(this->m_blockA, m_sizeA);
+      aligned_delete(this->m_blockB, m_sizeB);
+    }
+};
+
+} // end namespace internal
+
+namespace internal {
+
+template<typename Lhs, typename Rhs>
+struct generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,GemmProduct>
+  : generic_product_impl_base<Lhs,Rhs,generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,GemmProduct> >
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+  typedef typename Lhs::Scalar LhsScalar;
+  typedef typename Rhs::Scalar RhsScalar;
+
+  typedef internal::blas_traits<Lhs> LhsBlasTraits;
+  typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
+  typedef typename internal::remove_all<ActualLhsType>::type ActualLhsTypeCleaned;
+
+  typedef internal::blas_traits<Rhs> RhsBlasTraits;
+  typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
+  typedef typename internal::remove_all<ActualRhsType>::type ActualRhsTypeCleaned;
+
+  enum {
+    MaxDepthAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED(Lhs::MaxColsAtCompileTime,Rhs::MaxRowsAtCompileTime)
+  };
+
+  typedef generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,CoeffBasedProductMode> lazyproduct;
+
+  template<typename Dst>
+  static void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    // See http://eigen.tuxfamily.org/bz/show_bug.cgi?id=404 for a discussion and helper program
+    // to determine the following heuristic.
+    // EIGEN_GEMM_TO_COEFFBASED_THRESHOLD is typically defined to 20 in GeneralProduct.h,
+    // unless it has been specialized by the user or for a given architecture.
+    // Note that the condition rhs.rows()>0 was required because lazy produc is (was?) not happy with empty inputs.
+    // I'm not sure it is still required.
+    if((rhs.rows()+dst.rows()+dst.cols())<EIGEN_GEMM_TO_COEFFBASED_THRESHOLD && rhs.rows()>0)
+      lazyproduct::evalTo(dst, lhs, rhs);
+    else
+    {
+      dst.setZero();
+      scaleAndAddTo(dst, lhs, rhs, Scalar(1));
+    }
+  }
+
+  template<typename Dst>
+  static void addTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    if((rhs.rows()+dst.rows()+dst.cols())<EIGEN_GEMM_TO_COEFFBASED_THRESHOLD && rhs.rows()>0)
+      lazyproduct::addTo(dst, lhs, rhs);
+    else
+      scaleAndAddTo(dst,lhs, rhs, Scalar(1));
+  }
+
+  template<typename Dst>
+  static void subTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    if((rhs.rows()+dst.rows()+dst.cols())<EIGEN_GEMM_TO_COEFFBASED_THRESHOLD && rhs.rows()>0)
+      lazyproduct::subTo(dst, lhs, rhs);
+    else
+      scaleAndAddTo(dst, lhs, rhs, Scalar(-1));
+  }
+
+  template<typename Dest>
+  static void scaleAndAddTo(Dest& dst, const Lhs& a_lhs, const Rhs& a_rhs, const Scalar& alpha)
+  {
+    eigen_assert(dst.rows()==a_lhs.rows() && dst.cols()==a_rhs.cols());
+    if(a_lhs.cols()==0 || a_lhs.rows()==0 || a_rhs.cols()==0)
+      return;
+
+    typename internal::add_const_on_value_type<ActualLhsType>::type lhs = LhsBlasTraits::extract(a_lhs);
+    typename internal::add_const_on_value_type<ActualRhsType>::type rhs = RhsBlasTraits::extract(a_rhs);
+
+    Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(a_lhs)
+                               * RhsBlasTraits::extractScalarFactor(a_rhs);
+
+    typedef internal::gemm_blocking_space<(Dest::Flags&RowMajorBit) ? RowMajor : ColMajor,LhsScalar,RhsScalar,
+            Dest::MaxRowsAtCompileTime,Dest::MaxColsAtCompileTime,MaxDepthAtCompileTime> BlockingType;
+
+    typedef internal::gemm_functor<
+      Scalar, Index,
+      internal::general_matrix_matrix_product<
+        Index,
+        LhsScalar, (ActualLhsTypeCleaned::Flags&RowMajorBit) ? RowMajor : ColMajor, bool(LhsBlasTraits::NeedToConjugate),
+        RhsScalar, (ActualRhsTypeCleaned::Flags&RowMajorBit) ? RowMajor : ColMajor, bool(RhsBlasTraits::NeedToConjugate),
+        (Dest::Flags&RowMajorBit) ? RowMajor : ColMajor>,
+      ActualLhsTypeCleaned, ActualRhsTypeCleaned, Dest, BlockingType> GemmFunctor;
+
+    BlockingType blocking(dst.rows(), dst.cols(), lhs.cols(), 1, true);
+    internal::parallelize_gemm<(Dest::MaxRowsAtCompileTime>32 || Dest::MaxRowsAtCompileTime==Dynamic)>
+        (GemmFunctor(lhs, rhs, dst, actualAlpha, blocking), a_lhs.rows(), a_rhs.cols(), a_lhs.cols(), Dest::Flags&RowMajorBit);
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_GENERAL_MATRIX_MATRIX_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
new file mode 100644
index 00000000..e436c50a
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
@@ -0,0 +1,311 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GENERAL_MATRIX_MATRIX_TRIANGULAR_H
+#define EIGEN_GENERAL_MATRIX_MATRIX_TRIANGULAR_H
+
+namespace Eigen { 
+
+template<typename Scalar, typename Index, int StorageOrder, int UpLo, bool ConjLhs, bool ConjRhs>
+struct selfadjoint_rank1_update;
+
+namespace internal {
+
+/**********************************************************************
+* This file implements a general A * B product while
+* evaluating only one triangular part of the product.
+* This is a more general version of self adjoint product (C += A A^T)
+* as the level 3 SYRK Blas routine.
+**********************************************************************/
+
+// forward declarations (defined at the end of this file)
+template<typename LhsScalar, typename RhsScalar, typename Index, int mr, int nr, bool ConjLhs, bool ConjRhs, int UpLo>
+struct tribb_kernel;
+  
+/* Optimized matrix-matrix product evaluating only one triangular half */
+template <typename Index,
+          typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs,
+          typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs,
+                              int ResStorageOrder, int  UpLo, int Version = Specialized>
+struct general_matrix_matrix_triangular_product;
+
+// as usual if the result is row major => we transpose the product
+template <typename Index, typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs,
+                          typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs, int  UpLo, int Version>
+struct general_matrix_matrix_triangular_product<Index,LhsScalar,LhsStorageOrder,ConjugateLhs,RhsScalar,RhsStorageOrder,ConjugateRhs,RowMajor,UpLo,Version>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+  static EIGEN_STRONG_INLINE void run(Index size, Index depth,const LhsScalar* lhs, Index lhsStride,
+                                      const RhsScalar* rhs, Index rhsStride, ResScalar* res, Index resStride,
+                                      const ResScalar& alpha, level3_blocking<RhsScalar,LhsScalar>& blocking)
+  {
+    general_matrix_matrix_triangular_product<Index,
+        RhsScalar, RhsStorageOrder==RowMajor ? ColMajor : RowMajor, ConjugateRhs,
+        LhsScalar, LhsStorageOrder==RowMajor ? ColMajor : RowMajor, ConjugateLhs,
+        ColMajor, UpLo==Lower?Upper:Lower>
+      ::run(size,depth,rhs,rhsStride,lhs,lhsStride,res,resStride,alpha,blocking);
+  }
+};
+
+template <typename Index, typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs,
+                          typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs, int  UpLo, int Version>
+struct general_matrix_matrix_triangular_product<Index,LhsScalar,LhsStorageOrder,ConjugateLhs,RhsScalar,RhsStorageOrder,ConjugateRhs,ColMajor,UpLo,Version>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+  static EIGEN_STRONG_INLINE void run(Index size, Index depth,const LhsScalar* _lhs, Index lhsStride,
+                                      const RhsScalar* _rhs, Index rhsStride, ResScalar* _res, Index resStride,
+                                      const ResScalar& alpha, level3_blocking<LhsScalar,RhsScalar>& blocking)
+  {
+    typedef gebp_traits<LhsScalar,RhsScalar> Traits;
+
+    typedef const_blas_data_mapper<LhsScalar, Index, LhsStorageOrder> LhsMapper;
+    typedef const_blas_data_mapper<RhsScalar, Index, RhsStorageOrder> RhsMapper;
+    typedef blas_data_mapper<typename Traits::ResScalar, Index, ColMajor> ResMapper;
+    LhsMapper lhs(_lhs,lhsStride);
+    RhsMapper rhs(_rhs,rhsStride);
+    ResMapper res(_res, resStride);
+
+    Index kc = blocking.kc();
+    Index mc = (std::min)(size,blocking.mc());
+
+    // !!! mc must be a multiple of nr:
+    if(mc > Traits::nr)
+      mc = (mc/Traits::nr)*Traits::nr;
+
+    std::size_t sizeA = kc*mc;
+    std::size_t sizeB = kc*size;
+
+    ei_declare_aligned_stack_constructed_variable(LhsScalar, blockA, sizeA, blocking.blockA());
+    ei_declare_aligned_stack_constructed_variable(RhsScalar, blockB, sizeB, blocking.blockB());
+
+    gemm_pack_lhs<LhsScalar, Index, LhsMapper, Traits::mr, Traits::LhsProgress, LhsStorageOrder> pack_lhs;
+    gemm_pack_rhs<RhsScalar, Index, RhsMapper, Traits::nr, RhsStorageOrder> pack_rhs;
+    gebp_kernel<LhsScalar, RhsScalar, Index, ResMapper, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp;
+    tribb_kernel<LhsScalar, RhsScalar, Index, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs, UpLo> sybb;
+
+    for(Index k2=0; k2<depth; k2+=kc)
+    {
+      const Index actual_kc = (std::min)(k2+kc,depth)-k2;
+
+      // note that the actual rhs is the transpose/adjoint of mat
+      pack_rhs(blockB, rhs.getSubMapper(k2,0), actual_kc, size);
+
+      for(Index i2=0; i2<size; i2+=mc)
+      {
+        const Index actual_mc = (std::min)(i2+mc,size)-i2;
+
+        pack_lhs(blockA, lhs.getSubMapper(i2, k2), actual_kc, actual_mc);
+
+        // the selected actual_mc * size panel of res is split into three different part:
+        //  1 - before the diagonal => processed with gebp or skipped
+        //  2 - the actual_mc x actual_mc symmetric block => processed with a special kernel
+        //  3 - after the diagonal => processed with gebp or skipped
+        if (UpLo==Lower)
+          gebp(res.getSubMapper(i2, 0), blockA, blockB, actual_mc, actual_kc,
+               (std::min)(size,i2), alpha, -1, -1, 0, 0);
+
+
+        sybb(_res+resStride*i2 + i2, resStride, blockA, blockB + actual_kc*i2, actual_mc, actual_kc, alpha);
+
+        if (UpLo==Upper)
+        {
+          Index j2 = i2+actual_mc;
+          gebp(res.getSubMapper(i2, j2), blockA, blockB+actual_kc*j2, actual_mc,
+               actual_kc, (std::max)(Index(0), size-j2), alpha, -1, -1, 0, 0);
+        }
+      }
+    }
+  }
+};
+
+// Optimized packed Block * packed Block product kernel evaluating only one given triangular part
+// This kernel is built on top of the gebp kernel:
+// - the current destination block is processed per panel of actual_mc x BlockSize
+//   where BlockSize is set to the minimal value allowing gebp to be as fast as possible
+// - then, as usual, each panel is split into three parts along the diagonal,
+//   the sub blocks above and below the diagonal are processed as usual,
+//   while the triangular block overlapping the diagonal is evaluated into a
+//   small temporary buffer which is then accumulated into the result using a
+//   triangular traversal.
+template<typename LhsScalar, typename RhsScalar, typename Index, int mr, int nr, bool ConjLhs, bool ConjRhs, int UpLo>
+struct tribb_kernel
+{
+  typedef gebp_traits<LhsScalar,RhsScalar,ConjLhs,ConjRhs> Traits;
+  typedef typename Traits::ResScalar ResScalar;
+
+  enum {
+    BlockSize  = meta_least_common_multiple<EIGEN_PLAIN_ENUM_MAX(mr,nr),EIGEN_PLAIN_ENUM_MIN(mr,nr)>::ret
+  };
+  void operator()(ResScalar* _res, Index resStride, const LhsScalar* blockA, const RhsScalar* blockB, Index size, Index depth, const ResScalar& alpha)
+  {
+    typedef blas_data_mapper<ResScalar, Index, ColMajor> ResMapper;
+    ResMapper res(_res, resStride);
+    gebp_kernel<LhsScalar, RhsScalar, Index, ResMapper, mr, nr, ConjLhs, ConjRhs> gebp_kernel;
+
+    Matrix<ResScalar,BlockSize,BlockSize,ColMajor> buffer((internal::constructor_without_unaligned_array_assert()));
+
+    // let's process the block per panel of actual_mc x BlockSize,
+    // again, each is split into three parts, etc.
+    for (Index j=0; j<size; j+=BlockSize)
+    {
+      Index actualBlockSize = std::min<Index>(BlockSize,size - j);
+      const RhsScalar* actual_b = blockB+j*depth;
+
+      if(UpLo==Upper)
+        gebp_kernel(res.getSubMapper(0, j), blockA, actual_b, j, depth, actualBlockSize, alpha,
+                    -1, -1, 0, 0);
+
+      // selfadjoint micro block
+      {
+        Index i = j;
+        buffer.setZero();
+        // 1 - apply the kernel on the temporary buffer
+        gebp_kernel(ResMapper(buffer.data(), BlockSize), blockA+depth*i, actual_b, actualBlockSize, depth, actualBlockSize, alpha,
+                    -1, -1, 0, 0);
+        // 2 - triangular accumulation
+        for(Index j1=0; j1<actualBlockSize; ++j1)
+        {
+          ResScalar* r = &res(i, j + j1);
+          for(Index i1=UpLo==Lower ? j1 : 0;
+              UpLo==Lower ? i1<actualBlockSize : i1<=j1; ++i1)
+            r[i1] += buffer(i1,j1);
+        }
+      }
+
+      if(UpLo==Lower)
+      {
+        Index i = j+actualBlockSize;
+        gebp_kernel(res.getSubMapper(i, j), blockA+depth*i, actual_b, size-i, 
+                    depth, actualBlockSize, alpha, -1, -1, 0, 0);
+      }
+    }
+  }
+};
+
+} // end namespace internal
+
+// high level API
+
+template<typename MatrixType, typename ProductType, int UpLo, bool IsOuterProduct>
+struct general_product_to_triangular_selector;
+
+
+template<typename MatrixType, typename ProductType, int UpLo>
+struct general_product_to_triangular_selector<MatrixType,ProductType,UpLo,true>
+{
+  static void run(MatrixType& mat, const ProductType& prod, const typename MatrixType::Scalar& alpha, bool beta)
+  {
+    typedef typename MatrixType::Scalar Scalar;
+    
+    typedef typename internal::remove_all<typename ProductType::LhsNested>::type Lhs;
+    typedef internal::blas_traits<Lhs> LhsBlasTraits;
+    typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhs;
+    typedef typename internal::remove_all<ActualLhs>::type _ActualLhs;
+    typename internal::add_const_on_value_type<ActualLhs>::type actualLhs = LhsBlasTraits::extract(prod.lhs());
+    
+    typedef typename internal::remove_all<typename ProductType::RhsNested>::type Rhs;
+    typedef internal::blas_traits<Rhs> RhsBlasTraits;
+    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhs;
+    typedef typename internal::remove_all<ActualRhs>::type _ActualRhs;
+    typename internal::add_const_on_value_type<ActualRhs>::type actualRhs = RhsBlasTraits::extract(prod.rhs());
+
+    Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(prod.lhs().derived()) * RhsBlasTraits::extractScalarFactor(prod.rhs().derived());
+
+    if(!beta)
+      mat.template triangularView<UpLo>().setZero();
+
+    enum {
+      StorageOrder = (internal::traits<MatrixType>::Flags&RowMajorBit) ? RowMajor : ColMajor,
+      UseLhsDirectly = _ActualLhs::InnerStrideAtCompileTime==1,
+      UseRhsDirectly = _ActualRhs::InnerStrideAtCompileTime==1
+    };
+    
+    internal::gemv_static_vector_if<Scalar,Lhs::SizeAtCompileTime,Lhs::MaxSizeAtCompileTime,!UseLhsDirectly> static_lhs;
+    ei_declare_aligned_stack_constructed_variable(Scalar, actualLhsPtr, actualLhs.size(),
+      (UseLhsDirectly ? const_cast<Scalar*>(actualLhs.data()) : static_lhs.data()));
+    if(!UseLhsDirectly) Map<typename _ActualLhs::PlainObject>(actualLhsPtr, actualLhs.size()) = actualLhs;
+    
+    internal::gemv_static_vector_if<Scalar,Rhs::SizeAtCompileTime,Rhs::MaxSizeAtCompileTime,!UseRhsDirectly> static_rhs;
+    ei_declare_aligned_stack_constructed_variable(Scalar, actualRhsPtr, actualRhs.size(),
+      (UseRhsDirectly ? const_cast<Scalar*>(actualRhs.data()) : static_rhs.data()));
+    if(!UseRhsDirectly) Map<typename _ActualRhs::PlainObject>(actualRhsPtr, actualRhs.size()) = actualRhs;
+    
+    
+    selfadjoint_rank1_update<Scalar,Index,StorageOrder,UpLo,
+                              LhsBlasTraits::NeedToConjugate && NumTraits<Scalar>::IsComplex,
+                              RhsBlasTraits::NeedToConjugate && NumTraits<Scalar>::IsComplex>
+          ::run(actualLhs.size(), mat.data(), mat.outerStride(), actualLhsPtr, actualRhsPtr, actualAlpha);
+  }
+};
+
+template<typename MatrixType, typename ProductType, int UpLo>
+struct general_product_to_triangular_selector<MatrixType,ProductType,UpLo,false>
+{
+  static void run(MatrixType& mat, const ProductType& prod, const typename MatrixType::Scalar& alpha, bool beta)
+  {
+    typedef typename internal::remove_all<typename ProductType::LhsNested>::type Lhs;
+    typedef internal::blas_traits<Lhs> LhsBlasTraits;
+    typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhs;
+    typedef typename internal::remove_all<ActualLhs>::type _ActualLhs;
+    typename internal::add_const_on_value_type<ActualLhs>::type actualLhs = LhsBlasTraits::extract(prod.lhs());
+    
+    typedef typename internal::remove_all<typename ProductType::RhsNested>::type Rhs;
+    typedef internal::blas_traits<Rhs> RhsBlasTraits;
+    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhs;
+    typedef typename internal::remove_all<ActualRhs>::type _ActualRhs;
+    typename internal::add_const_on_value_type<ActualRhs>::type actualRhs = RhsBlasTraits::extract(prod.rhs());
+
+    typename ProductType::Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(prod.lhs().derived()) * RhsBlasTraits::extractScalarFactor(prod.rhs().derived());
+
+    if(!beta)
+      mat.template triangularView<UpLo>().setZero();
+
+    enum {
+      IsRowMajor = (internal::traits<MatrixType>::Flags&RowMajorBit) ? 1 : 0,
+      LhsIsRowMajor = _ActualLhs::Flags&RowMajorBit ? 1 : 0,
+      RhsIsRowMajor = _ActualRhs::Flags&RowMajorBit ? 1 : 0,
+      SkipDiag = (UpLo&(UnitDiag|ZeroDiag))!=0
+    };
+
+    Index size = mat.cols();
+    if(SkipDiag)
+      size--;
+    Index depth = actualLhs.cols();
+
+    typedef internal::gemm_blocking_space<IsRowMajor ? RowMajor : ColMajor,typename Lhs::Scalar,typename Rhs::Scalar,
+          MatrixType::MaxColsAtCompileTime, MatrixType::MaxColsAtCompileTime, _ActualRhs::MaxColsAtCompileTime> BlockingType;
+
+    BlockingType blocking(size, size, depth, 1, false);
+
+    internal::general_matrix_matrix_triangular_product<Index,
+      typename Lhs::Scalar, LhsIsRowMajor ? RowMajor : ColMajor, LhsBlasTraits::NeedToConjugate,
+      typename Rhs::Scalar, RhsIsRowMajor ? RowMajor : ColMajor, RhsBlasTraits::NeedToConjugate,
+      IsRowMajor ? RowMajor : ColMajor, UpLo&(Lower|Upper)>
+      ::run(size, depth,
+            &actualLhs.coeffRef(SkipDiag&&(UpLo&Lower)==Lower ? 1 : 0,0), actualLhs.outerStride(),
+            &actualRhs.coeffRef(0,SkipDiag&&(UpLo&Upper)==Upper ? 1 : 0), actualRhs.outerStride(),
+            mat.data() + (SkipDiag ? (bool(IsRowMajor) != ((UpLo&Lower)==Lower) ? 1 : mat.outerStride() ) : 0), mat.outerStride(), actualAlpha, blocking);
+  }
+};
+
+template<typename MatrixType, unsigned int UpLo>
+template<typename ProductType>
+EIGEN_DEVICE_FUNC TriangularView<MatrixType,UpLo>& TriangularViewImpl<MatrixType,UpLo,Dense>::_assignProduct(const ProductType& prod, const Scalar& alpha, bool beta)
+{
+  EIGEN_STATIC_ASSERT((UpLo&UnitDiag)==0, WRITING_TO_TRIANGULAR_PART_WITH_UNIT_DIAGONAL_IS_NOT_SUPPORTED);
+  eigen_assert(derived().nestedExpression().rows() == prod.rows() && derived().cols() == prod.cols());
+
+  general_product_to_triangular_selector<MatrixType, ProductType, UpLo, internal::traits<ProductType>::InnerSize==1>::run(derived().nestedExpression().const_cast_derived(), prod, alpha, beta);
+
+  return derived();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_GENERAL_MATRIX_MATRIX_TRIANGULAR_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
new file mode 100644
index 00000000..9176a138
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
@@ -0,0 +1,145 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to BLAS F77
+ *   Level 3 BLAS SYRK/HERK implementation.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_GENERAL_MATRIX_MATRIX_TRIANGULAR_BLAS_H
+#define EIGEN_GENERAL_MATRIX_MATRIX_TRIANGULAR_BLAS_H
+
+namespace Eigen {
+
+namespace internal {
+
+template <typename Index, typename Scalar, int AStorageOrder, bool ConjugateA, int ResStorageOrder, int  UpLo>
+struct general_matrix_matrix_rankupdate :
+       general_matrix_matrix_triangular_product<
+         Index,Scalar,AStorageOrder,ConjugateA,Scalar,AStorageOrder,ConjugateA,ResStorageOrder,UpLo,BuiltIn> {};
+
+
+// try to go to BLAS specialization
+#define EIGEN_BLAS_RANKUPDATE_SPECIALIZE(Scalar) \
+template <typename Index, int LhsStorageOrder, bool ConjugateLhs, \
+                          int RhsStorageOrder, bool ConjugateRhs, int  UpLo> \
+struct general_matrix_matrix_triangular_product<Index,Scalar,LhsStorageOrder,ConjugateLhs, \
+               Scalar,RhsStorageOrder,ConjugateRhs,ColMajor,UpLo,Specialized> { \
+  static EIGEN_STRONG_INLINE void run(Index size, Index depth,const Scalar* lhs, Index lhsStride, \
+                          const Scalar* rhs, Index rhsStride, Scalar* res, Index resStride, Scalar alpha, level3_blocking<Scalar, Scalar>& blocking) \
+  { \
+    if ( lhs==rhs && ((UpLo&(Lower|Upper)==UpLo)) ) { \
+      general_matrix_matrix_rankupdate<Index,Scalar,LhsStorageOrder,ConjugateLhs,ColMajor,UpLo> \
+      ::run(size,depth,lhs,lhsStride,rhs,rhsStride,res,resStride,alpha,blocking); \
+    } else { \
+      general_matrix_matrix_triangular_product<Index, \
+        Scalar, LhsStorageOrder, ConjugateLhs, \
+        Scalar, RhsStorageOrder, ConjugateRhs, \
+        ColMajor, UpLo, BuiltIn> \
+      ::run(size,depth,lhs,lhsStride,rhs,rhsStride,res,resStride,alpha,blocking); \
+    } \
+  } \
+};
+
+EIGEN_BLAS_RANKUPDATE_SPECIALIZE(double)
+EIGEN_BLAS_RANKUPDATE_SPECIALIZE(float)
+// TODO handle complex cases
+// EIGEN_BLAS_RANKUPDATE_SPECIALIZE(dcomplex)
+// EIGEN_BLAS_RANKUPDATE_SPECIALIZE(scomplex)
+
+// SYRK for float/double
+#define EIGEN_BLAS_RANKUPDATE_R(EIGTYPE, BLASTYPE, BLASFUNC) \
+template <typename Index, int AStorageOrder, bool ConjugateA, int  UpLo> \
+struct general_matrix_matrix_rankupdate<Index,EIGTYPE,AStorageOrder,ConjugateA,ColMajor,UpLo> { \
+  enum { \
+    IsLower = (UpLo&Lower) == Lower, \
+    LowUp = IsLower ? Lower : Upper, \
+    conjA = ((AStorageOrder==ColMajor) && ConjugateA) ? 1 : 0 \
+  }; \
+  static EIGEN_STRONG_INLINE void run(Index size, Index depth,const EIGTYPE* lhs, Index lhsStride, \
+                          const EIGTYPE* /*rhs*/, Index /*rhsStride*/, EIGTYPE* res, Index resStride, EIGTYPE alpha, level3_blocking<EIGTYPE, EIGTYPE>& /*blocking*/) \
+  { \
+  /* typedef Matrix<EIGTYPE, Dynamic, Dynamic, RhsStorageOrder> MatrixRhs;*/ \
+\
+   BlasIndex lda=convert_index<BlasIndex>(lhsStride), ldc=convert_index<BlasIndex>(resStride), n=convert_index<BlasIndex>(size), k=convert_index<BlasIndex>(depth); \
+   char uplo=((IsLower) ? 'L' : 'U'), trans=((AStorageOrder==RowMajor) ? 'T':'N'); \
+   EIGTYPE beta(1); \
+   BLASFUNC(&uplo, &trans, &n, &k, (const BLASTYPE*)&numext::real_ref(alpha), lhs, &lda, (const BLASTYPE*)&numext::real_ref(beta), res, &ldc); \
+  } \
+};
+
+// HERK for complex data
+#define EIGEN_BLAS_RANKUPDATE_C(EIGTYPE, BLASTYPE, RTYPE, BLASFUNC) \
+template <typename Index, int AStorageOrder, bool ConjugateA, int  UpLo> \
+struct general_matrix_matrix_rankupdate<Index,EIGTYPE,AStorageOrder,ConjugateA,ColMajor,UpLo> { \
+  enum { \
+    IsLower = (UpLo&Lower) == Lower, \
+    LowUp = IsLower ? Lower : Upper, \
+    conjA = (((AStorageOrder==ColMajor) && ConjugateA) || ((AStorageOrder==RowMajor) && !ConjugateA)) ? 1 : 0 \
+  }; \
+  static EIGEN_STRONG_INLINE void run(Index size, Index depth,const EIGTYPE* lhs, Index lhsStride, \
+                          const EIGTYPE* /*rhs*/, Index /*rhsStride*/, EIGTYPE* res, Index resStride, EIGTYPE alpha, level3_blocking<EIGTYPE, EIGTYPE>& /*blocking*/) \
+  { \
+   typedef Matrix<EIGTYPE, Dynamic, Dynamic, AStorageOrder> MatrixType; \
+\
+   BlasIndex lda=convert_index<BlasIndex>(lhsStride), ldc=convert_index<BlasIndex>(resStride), n=convert_index<BlasIndex>(size), k=convert_index<BlasIndex>(depth); \
+   char uplo=((IsLower) ? 'L' : 'U'), trans=((AStorageOrder==RowMajor) ? 'C':'N'); \
+   RTYPE alpha_, beta_; \
+   const EIGTYPE* a_ptr; \
+\
+   alpha_ = alpha.real(); \
+   beta_ = 1.0; \
+/* Copy with conjugation in some cases*/ \
+   MatrixType a; \
+   if (conjA) { \
+     Map<const MatrixType, 0, OuterStride<> > mapA(lhs,n,k,OuterStride<>(lhsStride)); \
+     a = mapA.conjugate(); \
+     lda = a.outerStride(); \
+     a_ptr = a.data(); \
+   } else a_ptr=lhs; \
+   BLASFUNC(&uplo, &trans, &n, &k, &alpha_, (BLASTYPE*)a_ptr, &lda, &beta_, (BLASTYPE*)res, &ldc); \
+  } \
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_RANKUPDATE_R(double, double, dsyrk)
+EIGEN_BLAS_RANKUPDATE_R(float,  float,  ssyrk)
+#else
+EIGEN_BLAS_RANKUPDATE_R(double, double, dsyrk_)
+EIGEN_BLAS_RANKUPDATE_R(float,  float,  ssyrk_)
+#endif
+
+// TODO hanlde complex cases
+// EIGEN_BLAS_RANKUPDATE_C(dcomplex, double, double, zherk_)
+// EIGEN_BLAS_RANKUPDATE_C(scomplex, float,  float, cherk_)
+
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_GENERAL_MATRIX_MATRIX_TRIANGULAR_BLAS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
new file mode 100644
index 00000000..b0f6b0d5
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
@@ -0,0 +1,122 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to BLAS F77
+ *   General matrix-matrix product functionality based on ?GEMM.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_GENERAL_MATRIX_MATRIX_BLAS_H
+#define EIGEN_GENERAL_MATRIX_MATRIX_BLAS_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/**********************************************************************
+* This file implements general matrix-matrix multiplication using BLAS
+* gemm function via partial specialization of
+* general_matrix_matrix_product::run(..) method for float, double,
+* std::complex<float> and std::complex<double> types
+**********************************************************************/
+
+// gemm specialization
+
+#define GEMM_SPECIALIZATION(EIGTYPE, EIGPREFIX, BLASTYPE, BLASFUNC) \
+template< \
+  typename Index, \
+  int LhsStorageOrder, bool ConjugateLhs, \
+  int RhsStorageOrder, bool ConjugateRhs> \
+struct general_matrix_matrix_product<Index,EIGTYPE,LhsStorageOrder,ConjugateLhs,EIGTYPE,RhsStorageOrder,ConjugateRhs,ColMajor> \
+{ \
+typedef gebp_traits<EIGTYPE,EIGTYPE> Traits; \
+\
+static void run(Index rows, Index cols, Index depth, \
+  const EIGTYPE* _lhs, Index lhsStride, \
+  const EIGTYPE* _rhs, Index rhsStride, \
+  EIGTYPE* res, Index resStride, \
+  EIGTYPE alpha, \
+  level3_blocking<EIGTYPE, EIGTYPE>& /*blocking*/, \
+  GemmParallelInfo<Index>* /*info = 0*/) \
+{ \
+  using std::conj; \
+\
+  char transa, transb; \
+  BlasIndex m, n, k, lda, ldb, ldc; \
+  const EIGTYPE *a, *b; \
+  EIGTYPE beta(1); \
+  MatrixX##EIGPREFIX a_tmp, b_tmp; \
+\
+/* Set transpose options */ \
+  transa = (LhsStorageOrder==RowMajor) ? ((ConjugateLhs) ? 'C' : 'T') : 'N'; \
+  transb = (RhsStorageOrder==RowMajor) ? ((ConjugateRhs) ? 'C' : 'T') : 'N'; \
+\
+/* Set m, n, k */ \
+  m = convert_index<BlasIndex>(rows);  \
+  n = convert_index<BlasIndex>(cols);  \
+  k = convert_index<BlasIndex>(depth); \
+\
+/* Set lda, ldb, ldc */ \
+  lda = convert_index<BlasIndex>(lhsStride); \
+  ldb = convert_index<BlasIndex>(rhsStride); \
+  ldc = convert_index<BlasIndex>(resStride); \
+\
+/* Set a, b, c */ \
+  if ((LhsStorageOrder==ColMajor) && (ConjugateLhs)) { \
+    Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > lhs(_lhs,m,k,OuterStride<>(lhsStride)); \
+    a_tmp = lhs.conjugate(); \
+    a = a_tmp.data(); \
+    lda = convert_index<BlasIndex>(a_tmp.outerStride()); \
+  } else a = _lhs; \
+\
+  if ((RhsStorageOrder==ColMajor) && (ConjugateRhs)) { \
+    Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > rhs(_rhs,k,n,OuterStride<>(rhsStride)); \
+    b_tmp = rhs.conjugate(); \
+    b = b_tmp.data(); \
+    ldb = convert_index<BlasIndex>(b_tmp.outerStride()); \
+  } else b = _rhs; \
+\
+  BLASFUNC(&transa, &transb, &m, &n, &k, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (const BLASTYPE*)b, &ldb, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)res, &ldc); \
+}};
+
+#ifdef EIGEN_USE_MKL
+GEMM_SPECIALIZATION(double,   d,  double, dgemm)
+GEMM_SPECIALIZATION(float,    f,  float,  sgemm)
+GEMM_SPECIALIZATION(dcomplex, cd, MKL_Complex16, zgemm)
+GEMM_SPECIALIZATION(scomplex, cf, MKL_Complex8,  cgemm)
+#else
+GEMM_SPECIALIZATION(double,   d,  double, dgemm_)
+GEMM_SPECIALIZATION(float,    f,  float,  sgemm_)
+GEMM_SPECIALIZATION(dcomplex, cd, double, zgemm_)
+GEMM_SPECIALIZATION(scomplex, cf, float,  cgemm_)
+#endif
+
+} // end namespase internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_GENERAL_MATRIX_MATRIX_BLAS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/GeneralMatrixVector.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/GeneralMatrixVector.h
new file mode 100644
index 00000000..41d8242e
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/GeneralMatrixVector.h
@@ -0,0 +1,405 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GENERAL_MATRIX_VECTOR_H
+#define EIGEN_GENERAL_MATRIX_VECTOR_H
+
+namespace Eigen {
+
+namespace internal {
+
+/* Optimized col-major matrix * vector product:
+ * This algorithm processes the matrix per vertical panels,
+ * which are then processed horizontaly per chunck of 8*PacketSize x 1 vertical segments.
+ *
+ * Mixing type logic: C += alpha * A * B
+ *  |  A  |  B  |alpha| comments
+ *  |real |cplx |cplx | no vectorization
+ *  |real |cplx |real | alpha is converted to a cplx when calling the run function, no vectorization
+ *  |cplx |real |cplx | invalid, the caller has to do tmp: = A * B; C += alpha*tmp
+ *  |cplx |real |real | optimal case, vectorization possible via real-cplx mul
+ *
+ * The same reasoning apply for the transposed case.
+ */
+template<typename Index, typename LhsScalar, typename LhsMapper, bool ConjugateLhs, typename RhsScalar, typename RhsMapper, bool ConjugateRhs, int Version>
+struct general_matrix_vector_product<Index,LhsScalar,LhsMapper,ColMajor,ConjugateLhs,RhsScalar,RhsMapper,ConjugateRhs,Version>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+
+enum {
+  Vectorizable = packet_traits<LhsScalar>::Vectorizable && packet_traits<RhsScalar>::Vectorizable
+              && int(packet_traits<LhsScalar>::size)==int(packet_traits<RhsScalar>::size),
+  LhsPacketSize = Vectorizable ? packet_traits<LhsScalar>::size : 1,
+  RhsPacketSize = Vectorizable ? packet_traits<RhsScalar>::size : 1,
+  ResPacketSize = Vectorizable ? packet_traits<ResScalar>::size : 1
+};
+
+typedef typename packet_traits<LhsScalar>::type  _LhsPacket;
+typedef typename packet_traits<RhsScalar>::type  _RhsPacket;
+typedef typename packet_traits<ResScalar>::type  _ResPacket;
+
+typedef typename conditional<Vectorizable,_LhsPacket,LhsScalar>::type LhsPacket;
+typedef typename conditional<Vectorizable,_RhsPacket,RhsScalar>::type RhsPacket;
+typedef typename conditional<Vectorizable,_ResPacket,ResScalar>::type ResPacket;
+
+EIGEN_DONT_INLINE static void run(
+  Index rows, Index cols,
+  const LhsMapper& lhs,
+  const RhsMapper& rhs,
+        ResScalar* res, Index resIncr,
+  RhsScalar alpha);
+};
+
+template<typename Index, typename LhsScalar, typename LhsMapper, bool ConjugateLhs, typename RhsScalar, typename RhsMapper, bool ConjugateRhs, int Version>
+EIGEN_DONT_INLINE void general_matrix_vector_product<Index,LhsScalar,LhsMapper,ColMajor,ConjugateLhs,RhsScalar,RhsMapper,ConjugateRhs,Version>::run(
+  Index rows, Index cols,
+  const LhsMapper& alhs,
+  const RhsMapper& rhs,
+        ResScalar* res, Index resIncr,
+  RhsScalar alpha)
+{
+  EIGEN_UNUSED_VARIABLE(resIncr);
+  eigen_internal_assert(resIncr==1);
+
+  // The following copy tells the compiler that lhs's attributes are not modified outside this function
+  // This helps GCC to generate propoer code.
+  LhsMapper lhs(alhs);
+
+  conj_helper<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs> cj;
+  conj_helper<LhsPacket,RhsPacket,ConjugateLhs,ConjugateRhs> pcj;
+  const Index lhsStride = lhs.stride();
+  // TODO: for padded aligned inputs, we could enable aligned reads
+  enum { LhsAlignment = Unaligned };
+
+  const Index n8 = rows-8*ResPacketSize+1;
+  const Index n4 = rows-4*ResPacketSize+1;
+  const Index n3 = rows-3*ResPacketSize+1;
+  const Index n2 = rows-2*ResPacketSize+1;
+  const Index n1 = rows-1*ResPacketSize+1;
+
+  // TODO: improve the following heuristic:
+  const Index block_cols = cols<128 ? cols : (lhsStride*sizeof(LhsScalar)<32000?16:4);
+  ResPacket palpha = pset1<ResPacket>(alpha);
+
+  for(Index j2=0; j2<cols; j2+=block_cols)
+  {
+    Index jend = numext::mini(j2+block_cols,cols);
+    Index i=0;
+    for(; i<n8; i+=ResPacketSize*8)
+    {
+      ResPacket c0 = pset1<ResPacket>(ResScalar(0)),
+                c1 = pset1<ResPacket>(ResScalar(0)),
+                c2 = pset1<ResPacket>(ResScalar(0)),
+                c3 = pset1<ResPacket>(ResScalar(0)),
+                c4 = pset1<ResPacket>(ResScalar(0)),
+                c5 = pset1<ResPacket>(ResScalar(0)),
+                c6 = pset1<ResPacket>(ResScalar(0)),
+                c7 = pset1<ResPacket>(ResScalar(0));
+
+      for(Index j=j2; j<jend; j+=1)
+      {
+        RhsPacket b0 = pset1<RhsPacket>(rhs(j,0));
+        c0 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*0,j),b0,c0);
+        c1 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*1,j),b0,c1);
+        c2 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*2,j),b0,c2);
+        c3 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*3,j),b0,c3);
+        c4 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*4,j),b0,c4);
+        c5 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*5,j),b0,c5);
+        c6 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*6,j),b0,c6);
+        c7 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*7,j),b0,c7);
+      }
+      pstoreu(res+i+ResPacketSize*0, pmadd(c0,palpha,ploadu<ResPacket>(res+i+ResPacketSize*0)));
+      pstoreu(res+i+ResPacketSize*1, pmadd(c1,palpha,ploadu<ResPacket>(res+i+ResPacketSize*1)));
+      pstoreu(res+i+ResPacketSize*2, pmadd(c2,palpha,ploadu<ResPacket>(res+i+ResPacketSize*2)));
+      pstoreu(res+i+ResPacketSize*3, pmadd(c3,palpha,ploadu<ResPacket>(res+i+ResPacketSize*3)));
+      pstoreu(res+i+ResPacketSize*4, pmadd(c4,palpha,ploadu<ResPacket>(res+i+ResPacketSize*4)));
+      pstoreu(res+i+ResPacketSize*5, pmadd(c5,palpha,ploadu<ResPacket>(res+i+ResPacketSize*5)));
+      pstoreu(res+i+ResPacketSize*6, pmadd(c6,palpha,ploadu<ResPacket>(res+i+ResPacketSize*6)));
+      pstoreu(res+i+ResPacketSize*7, pmadd(c7,palpha,ploadu<ResPacket>(res+i+ResPacketSize*7)));
+    }
+    if(i<n4)
+    {
+      ResPacket c0 = pset1<ResPacket>(ResScalar(0)),
+                c1 = pset1<ResPacket>(ResScalar(0)),
+                c2 = pset1<ResPacket>(ResScalar(0)),
+                c3 = pset1<ResPacket>(ResScalar(0));
+
+      for(Index j=j2; j<jend; j+=1)
+      {
+        RhsPacket b0 = pset1<RhsPacket>(rhs(j,0));
+        c0 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*0,j),b0,c0);
+        c1 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*1,j),b0,c1);
+        c2 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*2,j),b0,c2);
+        c3 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*3,j),b0,c3);
+      }
+      pstoreu(res+i+ResPacketSize*0, pmadd(c0,palpha,ploadu<ResPacket>(res+i+ResPacketSize*0)));
+      pstoreu(res+i+ResPacketSize*1, pmadd(c1,palpha,ploadu<ResPacket>(res+i+ResPacketSize*1)));
+      pstoreu(res+i+ResPacketSize*2, pmadd(c2,palpha,ploadu<ResPacket>(res+i+ResPacketSize*2)));
+      pstoreu(res+i+ResPacketSize*3, pmadd(c3,palpha,ploadu<ResPacket>(res+i+ResPacketSize*3)));
+
+      i+=ResPacketSize*4;
+    }
+    if(i<n3)
+    {
+      ResPacket c0 = pset1<ResPacket>(ResScalar(0)),
+                c1 = pset1<ResPacket>(ResScalar(0)),
+                c2 = pset1<ResPacket>(ResScalar(0));
+
+      for(Index j=j2; j<jend; j+=1)
+      {
+        RhsPacket b0 = pset1<RhsPacket>(rhs(j,0));
+        c0 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*0,j),b0,c0);
+        c1 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*1,j),b0,c1);
+        c2 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*2,j),b0,c2);
+      }
+      pstoreu(res+i+ResPacketSize*0, pmadd(c0,palpha,ploadu<ResPacket>(res+i+ResPacketSize*0)));
+      pstoreu(res+i+ResPacketSize*1, pmadd(c1,palpha,ploadu<ResPacket>(res+i+ResPacketSize*1)));
+      pstoreu(res+i+ResPacketSize*2, pmadd(c2,palpha,ploadu<ResPacket>(res+i+ResPacketSize*2)));
+
+      i+=ResPacketSize*3;
+    }
+    if(i<n2)
+    {
+      ResPacket c0 = pset1<ResPacket>(ResScalar(0)),
+                c1 = pset1<ResPacket>(ResScalar(0));
+
+      for(Index j=j2; j<jend; j+=1)
+      {
+        RhsPacket b0 = pset1<RhsPacket>(rhs(j,0));
+        c0 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*0,j),b0,c0);
+        c1 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*1,j),b0,c1);
+      }
+      pstoreu(res+i+ResPacketSize*0, pmadd(c0,palpha,ploadu<ResPacket>(res+i+ResPacketSize*0)));
+      pstoreu(res+i+ResPacketSize*1, pmadd(c1,palpha,ploadu<ResPacket>(res+i+ResPacketSize*1)));
+      i+=ResPacketSize*2;
+    }
+    if(i<n1)
+    {
+      ResPacket c0 = pset1<ResPacket>(ResScalar(0));
+      for(Index j=j2; j<jend; j+=1)
+      {
+        RhsPacket b0 = pset1<RhsPacket>(rhs(j,0));
+        c0 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+0,j),b0,c0);
+      }
+      pstoreu(res+i+ResPacketSize*0, pmadd(c0,palpha,ploadu<ResPacket>(res+i+ResPacketSize*0)));
+      i+=ResPacketSize;
+    }
+    for(;i<rows;++i)
+    {
+      ResScalar c0(0);
+      for(Index j=j2; j<jend; j+=1)
+        c0 += cj.pmul(lhs(i,j), rhs(j,0));
+      res[i] += alpha*c0;
+    }
+  }
+}
+
+/* Optimized row-major matrix * vector product:
+ * This algorithm processes 4 rows at onces that allows to both reduce
+ * the number of load/stores of the result by a factor 4 and to reduce
+ * the instruction dependency. Moreover, we know that all bands have the
+ * same alignment pattern.
+ *
+ * Mixing type logic:
+ *  - alpha is always a complex (or converted to a complex)
+ *  - no vectorization
+ */
+template<typename Index, typename LhsScalar, typename LhsMapper, bool ConjugateLhs, typename RhsScalar, typename RhsMapper, bool ConjugateRhs, int Version>
+struct general_matrix_vector_product<Index,LhsScalar,LhsMapper,RowMajor,ConjugateLhs,RhsScalar,RhsMapper,ConjugateRhs,Version>
+{
+typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+
+enum {
+  Vectorizable = packet_traits<LhsScalar>::Vectorizable && packet_traits<RhsScalar>::Vectorizable
+              && int(packet_traits<LhsScalar>::size)==int(packet_traits<RhsScalar>::size),
+  LhsPacketSize = Vectorizable ? packet_traits<LhsScalar>::size : 1,
+  RhsPacketSize = Vectorizable ? packet_traits<RhsScalar>::size : 1,
+  ResPacketSize = Vectorizable ? packet_traits<ResScalar>::size : 1
+};
+
+typedef typename packet_traits<LhsScalar>::type  _LhsPacket;
+typedef typename packet_traits<RhsScalar>::type  _RhsPacket;
+typedef typename packet_traits<ResScalar>::type  _ResPacket;
+
+typedef typename conditional<Vectorizable,_LhsPacket,LhsScalar>::type LhsPacket;
+typedef typename conditional<Vectorizable,_RhsPacket,RhsScalar>::type RhsPacket;
+typedef typename conditional<Vectorizable,_ResPacket,ResScalar>::type ResPacket;
+
+EIGEN_DONT_INLINE static void run(
+  Index rows, Index cols,
+  const LhsMapper& lhs,
+  const RhsMapper& rhs,
+        ResScalar* res, Index resIncr,
+  ResScalar alpha);
+};
+
+template<typename Index, typename LhsScalar, typename LhsMapper, bool ConjugateLhs, typename RhsScalar, typename RhsMapper, bool ConjugateRhs, int Version>
+EIGEN_DONT_INLINE void general_matrix_vector_product<Index,LhsScalar,LhsMapper,RowMajor,ConjugateLhs,RhsScalar,RhsMapper,ConjugateRhs,Version>::run(
+  Index rows, Index cols,
+  const LhsMapper& alhs,
+  const RhsMapper& rhs,
+  ResScalar* res, Index resIncr,
+  ResScalar alpha)
+{
+  // The following copy tells the compiler that lhs's attributes are not modified outside this function
+  // This helps GCC to generate propoer code.
+  LhsMapper lhs(alhs);
+
+  eigen_internal_assert(rhs.stride()==1);
+  conj_helper<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs> cj;
+  conj_helper<LhsPacket,RhsPacket,ConjugateLhs,ConjugateRhs> pcj;
+
+  // TODO: fine tune the following heuristic. The rationale is that if the matrix is very large,
+  //       processing 8 rows at once might be counter productive wrt cache.
+  const Index n8 = lhs.stride()*sizeof(LhsScalar)>32000 ? 0 : rows-7;
+  const Index n4 = rows-3;
+  const Index n2 = rows-1;
+
+  // TODO: for padded aligned inputs, we could enable aligned reads
+  enum { LhsAlignment = Unaligned };
+
+  Index i=0;
+  for(; i<n8; i+=8)
+  {
+    ResPacket c0 = pset1<ResPacket>(ResScalar(0)),
+              c1 = pset1<ResPacket>(ResScalar(0)),
+              c2 = pset1<ResPacket>(ResScalar(0)),
+              c3 = pset1<ResPacket>(ResScalar(0)),
+              c4 = pset1<ResPacket>(ResScalar(0)),
+              c5 = pset1<ResPacket>(ResScalar(0)),
+              c6 = pset1<ResPacket>(ResScalar(0)),
+              c7 = pset1<ResPacket>(ResScalar(0));
+
+    Index j=0;
+    for(; j+LhsPacketSize<=cols; j+=LhsPacketSize)
+    {
+      RhsPacket b0 = rhs.template load<RhsPacket, Unaligned>(j,0);
+
+      c0 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+0,j),b0,c0);
+      c1 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+1,j),b0,c1);
+      c2 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+2,j),b0,c2);
+      c3 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+3,j),b0,c3);
+      c4 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+4,j),b0,c4);
+      c5 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+5,j),b0,c5);
+      c6 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+6,j),b0,c6);
+      c7 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+7,j),b0,c7);
+    }
+    ResScalar cc0 = predux(c0);
+    ResScalar cc1 = predux(c1);
+    ResScalar cc2 = predux(c2);
+    ResScalar cc3 = predux(c3);
+    ResScalar cc4 = predux(c4);
+    ResScalar cc5 = predux(c5);
+    ResScalar cc6 = predux(c6);
+    ResScalar cc7 = predux(c7);
+    for(; j<cols; ++j)
+    {
+      RhsScalar b0 = rhs(j,0);
+
+      cc0 += cj.pmul(lhs(i+0,j), b0);
+      cc1 += cj.pmul(lhs(i+1,j), b0);
+      cc2 += cj.pmul(lhs(i+2,j), b0);
+      cc3 += cj.pmul(lhs(i+3,j), b0);
+      cc4 += cj.pmul(lhs(i+4,j), b0);
+      cc5 += cj.pmul(lhs(i+5,j), b0);
+      cc6 += cj.pmul(lhs(i+6,j), b0);
+      cc7 += cj.pmul(lhs(i+7,j), b0);
+    }
+    res[(i+0)*resIncr] += alpha*cc0;
+    res[(i+1)*resIncr] += alpha*cc1;
+    res[(i+2)*resIncr] += alpha*cc2;
+    res[(i+3)*resIncr] += alpha*cc3;
+    res[(i+4)*resIncr] += alpha*cc4;
+    res[(i+5)*resIncr] += alpha*cc5;
+    res[(i+6)*resIncr] += alpha*cc6;
+    res[(i+7)*resIncr] += alpha*cc7;
+  }
+  for(; i<n4; i+=4)
+  {
+    ResPacket c0 = pset1<ResPacket>(ResScalar(0)),
+              c1 = pset1<ResPacket>(ResScalar(0)),
+              c2 = pset1<ResPacket>(ResScalar(0)),
+              c3 = pset1<ResPacket>(ResScalar(0));
+
+    Index j=0;
+    for(; j+LhsPacketSize<=cols; j+=LhsPacketSize)
+    {
+      RhsPacket b0 = rhs.template load<RhsPacket, Unaligned>(j,0);
+
+      c0 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+0,j),b0,c0);
+      c1 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+1,j),b0,c1);
+      c2 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+2,j),b0,c2);
+      c3 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+3,j),b0,c3);
+    }
+    ResScalar cc0 = predux(c0);
+    ResScalar cc1 = predux(c1);
+    ResScalar cc2 = predux(c2);
+    ResScalar cc3 = predux(c3);
+    for(; j<cols; ++j)
+    {
+      RhsScalar b0 = rhs(j,0);
+
+      cc0 += cj.pmul(lhs(i+0,j), b0);
+      cc1 += cj.pmul(lhs(i+1,j), b0);
+      cc2 += cj.pmul(lhs(i+2,j), b0);
+      cc3 += cj.pmul(lhs(i+3,j), b0);
+    }
+    res[(i+0)*resIncr] += alpha*cc0;
+    res[(i+1)*resIncr] += alpha*cc1;
+    res[(i+2)*resIncr] += alpha*cc2;
+    res[(i+3)*resIncr] += alpha*cc3;
+  }
+  for(; i<n2; i+=2)
+  {
+    ResPacket c0 = pset1<ResPacket>(ResScalar(0)),
+              c1 = pset1<ResPacket>(ResScalar(0));
+
+    Index j=0;
+    for(; j+LhsPacketSize<=cols; j+=LhsPacketSize)
+    {
+      RhsPacket b0 = rhs.template load<RhsPacket, Unaligned>(j,0);
+
+      c0 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+0,j),b0,c0);
+      c1 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+1,j),b0,c1);
+    }
+    ResScalar cc0 = predux(c0);
+    ResScalar cc1 = predux(c1);
+    for(; j<cols; ++j)
+    {
+      RhsScalar b0 = rhs(j,0);
+
+      cc0 += cj.pmul(lhs(i+0,j), b0);
+      cc1 += cj.pmul(lhs(i+1,j), b0);
+    }
+    res[(i+0)*resIncr] += alpha*cc0;
+    res[(i+1)*resIncr] += alpha*cc1;
+  }
+  for(; i<rows; ++i)
+  {
+    ResPacket c0 = pset1<ResPacket>(ResScalar(0));
+    Index j=0;
+    for(; j+LhsPacketSize<=cols; j+=LhsPacketSize)
+    {
+      RhsPacket b0 = rhs.template load<RhsPacket,Unaligned>(j,0);
+      c0 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i,j),b0,c0);
+    }
+    ResScalar cc0 = predux(c0);
+    for(; j<cols; ++j)
+    {
+      cc0 += cj.pmul(lhs(i,j), rhs(j,0));
+    }
+    res[i*resIncr] += alpha*cc0;
+  }
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_GENERAL_MATRIX_VECTOR_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
new file mode 100644
index 00000000..6e36c2b3
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
@@ -0,0 +1,136 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to BLAS F77
+ *   General matrix-vector product functionality based on ?GEMV.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_GENERAL_MATRIX_VECTOR_BLAS_H
+#define EIGEN_GENERAL_MATRIX_VECTOR_BLAS_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/**********************************************************************
+* This file implements general matrix-vector multiplication using BLAS
+* gemv function via partial specialization of
+* general_matrix_vector_product::run(..) method for float, double,
+* std::complex<float> and std::complex<double> types
+**********************************************************************/
+
+// gemv specialization
+
+template<typename Index, typename LhsScalar, int StorageOrder, bool ConjugateLhs, typename RhsScalar, bool ConjugateRhs>
+struct general_matrix_vector_product_gemv;
+
+#define EIGEN_BLAS_GEMV_SPECIALIZE(Scalar) \
+template<typename Index, bool ConjugateLhs, bool ConjugateRhs> \
+struct general_matrix_vector_product<Index,Scalar,const_blas_data_mapper<Scalar,Index,ColMajor>,ColMajor,ConjugateLhs,Scalar,const_blas_data_mapper<Scalar,Index,RowMajor>,ConjugateRhs,Specialized> { \
+static void run( \
+  Index rows, Index cols, \
+  const const_blas_data_mapper<Scalar,Index,ColMajor> &lhs, \
+  const const_blas_data_mapper<Scalar,Index,RowMajor> &rhs, \
+  Scalar* res, Index resIncr, Scalar alpha) \
+{ \
+  if (ConjugateLhs) { \
+    general_matrix_vector_product<Index,Scalar,const_blas_data_mapper<Scalar,Index,ColMajor>,ColMajor,ConjugateLhs,Scalar,const_blas_data_mapper<Scalar,Index,RowMajor>,ConjugateRhs,BuiltIn>::run( \
+      rows, cols, lhs, rhs, res, resIncr, alpha); \
+  } else { \
+    general_matrix_vector_product_gemv<Index,Scalar,ColMajor,ConjugateLhs,Scalar,ConjugateRhs>::run( \
+      rows, cols, lhs.data(), lhs.stride(), rhs.data(), rhs.stride(), res, resIncr, alpha); \
+  } \
+} \
+}; \
+template<typename Index, bool ConjugateLhs, bool ConjugateRhs> \
+struct general_matrix_vector_product<Index,Scalar,const_blas_data_mapper<Scalar,Index,RowMajor>,RowMajor,ConjugateLhs,Scalar,const_blas_data_mapper<Scalar,Index,ColMajor>,ConjugateRhs,Specialized> { \
+static void run( \
+  Index rows, Index cols, \
+  const const_blas_data_mapper<Scalar,Index,RowMajor> &lhs, \
+  const const_blas_data_mapper<Scalar,Index,ColMajor> &rhs, \
+  Scalar* res, Index resIncr, Scalar alpha) \
+{ \
+    general_matrix_vector_product_gemv<Index,Scalar,RowMajor,ConjugateLhs,Scalar,ConjugateRhs>::run( \
+      rows, cols, lhs.data(), lhs.stride(), rhs.data(), rhs.stride(), res, resIncr, alpha); \
+} \
+}; \
+
+EIGEN_BLAS_GEMV_SPECIALIZE(double)
+EIGEN_BLAS_GEMV_SPECIALIZE(float)
+EIGEN_BLAS_GEMV_SPECIALIZE(dcomplex)
+EIGEN_BLAS_GEMV_SPECIALIZE(scomplex)
+
+#define EIGEN_BLAS_GEMV_SPECIALIZATION(EIGTYPE,BLASTYPE,BLASFUNC) \
+template<typename Index, int LhsStorageOrder, bool ConjugateLhs, bool ConjugateRhs> \
+struct general_matrix_vector_product_gemv<Index,EIGTYPE,LhsStorageOrder,ConjugateLhs,EIGTYPE,ConjugateRhs> \
+{ \
+typedef Matrix<EIGTYPE,Dynamic,1,ColMajor> GEMVVector;\
+\
+static void run( \
+  Index rows, Index cols, \
+  const EIGTYPE* lhs, Index lhsStride, \
+  const EIGTYPE* rhs, Index rhsIncr, \
+  EIGTYPE* res, Index resIncr, EIGTYPE alpha) \
+{ \
+  BlasIndex m=convert_index<BlasIndex>(rows), n=convert_index<BlasIndex>(cols), \
+            lda=convert_index<BlasIndex>(lhsStride), incx=convert_index<BlasIndex>(rhsIncr), incy=convert_index<BlasIndex>(resIncr); \
+  const EIGTYPE beta(1); \
+  const EIGTYPE *x_ptr; \
+  char trans=(LhsStorageOrder==ColMajor) ? 'N' : (ConjugateLhs) ? 'C' : 'T'; \
+  if (LhsStorageOrder==RowMajor) { \
+    m = convert_index<BlasIndex>(cols); \
+    n = convert_index<BlasIndex>(rows); \
+  }\
+  GEMVVector x_tmp; \
+  if (ConjugateRhs) { \
+    Map<const GEMVVector, 0, InnerStride<> > map_x(rhs,cols,1,InnerStride<>(incx)); \
+    x_tmp=map_x.conjugate(); \
+    x_ptr=x_tmp.data(); \
+    incx=1; \
+  } else x_ptr=rhs; \
+  BLASFUNC(&trans, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)lhs, &lda, (const BLASTYPE*)x_ptr, &incx, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)res, &incy); \
+}\
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_GEMV_SPECIALIZATION(double,   double, dgemv)
+EIGEN_BLAS_GEMV_SPECIALIZATION(float,    float,  sgemv)
+EIGEN_BLAS_GEMV_SPECIALIZATION(dcomplex, MKL_Complex16, zgemv)
+EIGEN_BLAS_GEMV_SPECIALIZATION(scomplex, MKL_Complex8 , cgemv)
+#else
+EIGEN_BLAS_GEMV_SPECIALIZATION(double,   double, dgemv_)
+EIGEN_BLAS_GEMV_SPECIALIZATION(float,    float,  sgemv_)
+EIGEN_BLAS_GEMV_SPECIALIZATION(dcomplex, double, zgemv_)
+EIGEN_BLAS_GEMV_SPECIALIZATION(scomplex, float,  cgemv_)
+#endif
+
+} // end namespase internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_GENERAL_MATRIX_VECTOR_BLAS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/Parallelizer.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/Parallelizer.h
new file mode 100644
index 00000000..c2f084c8
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/Parallelizer.h
@@ -0,0 +1,163 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PARALLELIZER_H
+#define EIGEN_PARALLELIZER_H
+
+namespace Eigen {
+
+namespace internal {
+
+/** \internal */
+inline void manage_multi_threading(Action action, int* v)
+{
+  static EIGEN_UNUSED int m_maxThreads = -1;
+
+  if(action==SetAction)
+  {
+    eigen_internal_assert(v!=0);
+    m_maxThreads = *v;
+  }
+  else if(action==GetAction)
+  {
+    eigen_internal_assert(v!=0);
+    #ifdef EIGEN_HAS_OPENMP
+    if(m_maxThreads>0)
+      *v = m_maxThreads;
+    else
+      *v = omp_get_max_threads();
+    #else
+    *v = 1;
+    #endif
+  }
+  else
+  {
+    eigen_internal_assert(false);
+  }
+}
+
+}
+
+/** Must be call first when calling Eigen from multiple threads */
+inline void initParallel()
+{
+  int nbt;
+  internal::manage_multi_threading(GetAction, &nbt);
+  std::ptrdiff_t l1, l2, l3;
+  internal::manage_caching_sizes(GetAction, &l1, &l2, &l3);
+}
+
+/** \returns the max number of threads reserved for Eigen
+  * \sa setNbThreads */
+inline int nbThreads()
+{
+  int ret;
+  internal::manage_multi_threading(GetAction, &ret);
+  return ret;
+}
+
+/** Sets the max number of threads reserved for Eigen
+  * \sa nbThreads */
+inline void setNbThreads(int v)
+{
+  internal::manage_multi_threading(SetAction, &v);
+}
+
+namespace internal {
+
+template<typename Index> struct GemmParallelInfo
+{
+  GemmParallelInfo() : sync(-1), users(0), lhs_start(0), lhs_length(0) {}
+
+  Index volatile sync;
+  int volatile users;
+
+  Index lhs_start;
+  Index lhs_length;
+};
+
+template<bool Condition, typename Functor, typename Index>
+void parallelize_gemm(const Functor& func, Index rows, Index cols, Index depth, bool transpose)
+{
+  // TODO when EIGEN_USE_BLAS is defined,
+  // we should still enable OMP for other scalar types
+#if !(defined (EIGEN_HAS_OPENMP)) || defined (EIGEN_USE_BLAS)
+  // FIXME the transpose variable is only needed to properly split
+  // the matrix product when multithreading is enabled. This is a temporary
+  // fix to support row-major destination matrices. This whole
+  // parallelizer mechanism has to be redisigned anyway.
+  EIGEN_UNUSED_VARIABLE(depth);
+  EIGEN_UNUSED_VARIABLE(transpose);
+  func(0,rows, 0,cols);
+#else
+
+  // Dynamically check whether we should enable or disable OpenMP.
+  // The conditions are:
+  // - the max number of threads we can create is greater than 1
+  // - we are not already in a parallel code
+  // - the sizes are large enough
+
+  // compute the maximal number of threads from the size of the product:
+  // This first heuristic takes into account that the product kernel is fully optimized when working with nr columns at once.
+  Index size = transpose ? rows : cols;
+  Index pb_max_threads = std::max<Index>(1,size / Functor::Traits::nr);
+
+  // compute the maximal number of threads from the total amount of work:
+  double work = static_cast<double>(rows) * static_cast<double>(cols) *
+      static_cast<double>(depth);
+  double kMinTaskSize = 50000;  // FIXME improve this heuristic.
+  pb_max_threads = std::max<Index>(1, std::min<Index>(pb_max_threads, work / kMinTaskSize));
+
+  // compute the number of threads we are going to use
+  Index threads = std::min<Index>(nbThreads(), pb_max_threads);
+
+  // if multi-threading is explicitely disabled, not useful, or if we already are in a parallel session,
+  // then abort multi-threading
+  // FIXME omp_get_num_threads()>1 only works for openmp, what if the user does not use openmp?
+  if((!Condition) || (threads==1) || (omp_get_num_threads()>1))
+    return func(0,rows, 0,cols);
+
+  Eigen::initParallel();
+  func.initParallelSession(threads);
+
+  if(transpose)
+    std::swap(rows,cols);
+
+  ei_declare_aligned_stack_constructed_variable(GemmParallelInfo<Index>,info,threads,0);
+
+  #pragma omp parallel num_threads(threads)
+  {
+    Index i = omp_get_thread_num();
+    // Note that the actual number of threads might be lower than the number of request ones.
+    Index actual_threads = omp_get_num_threads();
+
+    Index blockCols = (cols / actual_threads) & ~Index(0x3);
+    Index blockRows = (rows / actual_threads);
+    blockRows = (blockRows/Functor::Traits::mr)*Functor::Traits::mr;
+
+    Index r0 = i*blockRows;
+    Index actualBlockRows = (i+1==actual_threads) ? rows-r0 : blockRows;
+
+    Index c0 = i*blockCols;
+    Index actualBlockCols = (i+1==actual_threads) ? cols-c0 : blockCols;
+
+    info[i].lhs_start = r0;
+    info[i].lhs_length = actualBlockRows;
+
+    if(transpose) func(c0, actualBlockCols, 0, rows, info);
+    else          func(0, rows, c0, actualBlockCols, info);
+  }
+#endif
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_PARALLELIZER_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/SelfadjointMatrixMatrix.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
new file mode 100644
index 00000000..da6f82ab
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
@@ -0,0 +1,521 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SELFADJOINT_MATRIX_MATRIX_H
+#define EIGEN_SELFADJOINT_MATRIX_MATRIX_H
+
+namespace Eigen { 
+
+namespace internal {
+
+// pack a selfadjoint block diagonal for use with the gebp_kernel
+template<typename Scalar, typename Index, int Pack1, int Pack2_dummy, int StorageOrder>
+struct symm_pack_lhs
+{
+  template<int BlockRows> inline
+  void pack(Scalar* blockA, const const_blas_data_mapper<Scalar,Index,StorageOrder>& lhs, Index cols, Index i, Index& count)
+  {
+    // normal copy
+    for(Index k=0; k<i; k++)
+      for(Index w=0; w<BlockRows; w++)
+        blockA[count++] = lhs(i+w,k);           // normal
+    // symmetric copy
+    Index h = 0;
+    for(Index k=i; k<i+BlockRows; k++)
+    {
+      for(Index w=0; w<h; w++)
+        blockA[count++] = numext::conj(lhs(k, i+w)); // transposed
+
+      blockA[count++] = numext::real(lhs(k,k));   // real (diagonal)
+
+      for(Index w=h+1; w<BlockRows; w++)
+        blockA[count++] = lhs(i+w, k);          // normal
+      ++h;
+    }
+    // transposed copy
+    for(Index k=i+BlockRows; k<cols; k++)
+      for(Index w=0; w<BlockRows; w++)
+        blockA[count++] = numext::conj(lhs(k, i+w)); // transposed
+  }
+  void operator()(Scalar* blockA, const Scalar* _lhs, Index lhsStride, Index cols, Index rows)
+  {
+    enum { PacketSize = packet_traits<Scalar>::size };
+    const_blas_data_mapper<Scalar,Index,StorageOrder> lhs(_lhs,lhsStride);
+    Index count = 0;
+    //Index peeled_mc3 = (rows/Pack1)*Pack1;
+    
+    const Index peeled_mc3 = Pack1>=3*PacketSize ? (rows/(3*PacketSize))*(3*PacketSize) : 0;
+    const Index peeled_mc2 = Pack1>=2*PacketSize ? peeled_mc3+((rows-peeled_mc3)/(2*PacketSize))*(2*PacketSize) : 0;
+    const Index peeled_mc1 = Pack1>=1*PacketSize ? (rows/(1*PacketSize))*(1*PacketSize) : 0;
+    
+    if(Pack1>=3*PacketSize)
+      for(Index i=0; i<peeled_mc3; i+=3*PacketSize)
+        pack<3*PacketSize>(blockA, lhs, cols, i, count);
+    
+    if(Pack1>=2*PacketSize)
+      for(Index i=peeled_mc3; i<peeled_mc2; i+=2*PacketSize)
+        pack<2*PacketSize>(blockA, lhs, cols, i, count);
+    
+    if(Pack1>=1*PacketSize)
+      for(Index i=peeled_mc2; i<peeled_mc1; i+=1*PacketSize)
+        pack<1*PacketSize>(blockA, lhs, cols, i, count);
+
+    // do the same with mr==1
+    for(Index i=peeled_mc1; i<rows; i++)
+    {
+      for(Index k=0; k<i; k++)
+        blockA[count++] = lhs(i, k);                   // normal
+
+      blockA[count++] = numext::real(lhs(i, i));       // real (diagonal)
+
+      for(Index k=i+1; k<cols; k++)
+        blockA[count++] = numext::conj(lhs(k, i));     // transposed
+    }
+  }
+};
+
+template<typename Scalar, typename Index, int nr, int StorageOrder>
+struct symm_pack_rhs
+{
+  enum { PacketSize = packet_traits<Scalar>::size };
+  void operator()(Scalar* blockB, const Scalar* _rhs, Index rhsStride, Index rows, Index cols, Index k2)
+  {
+    Index end_k = k2 + rows;
+    Index count = 0;
+    const_blas_data_mapper<Scalar,Index,StorageOrder> rhs(_rhs,rhsStride);
+    Index packet_cols8 = nr>=8 ? (cols/8) * 8 : 0;
+    Index packet_cols4 = nr>=4 ? (cols/4) * 4 : 0;
+
+    // first part: normal case
+    for(Index j2=0; j2<k2; j2+=nr)
+    {
+      for(Index k=k2; k<end_k; k++)
+      {
+        blockB[count+0] = rhs(k,j2+0);
+        blockB[count+1] = rhs(k,j2+1);
+        if (nr>=4)
+        {
+          blockB[count+2] = rhs(k,j2+2);
+          blockB[count+3] = rhs(k,j2+3);
+        }
+        if (nr>=8)
+        {
+          blockB[count+4] = rhs(k,j2+4);
+          blockB[count+5] = rhs(k,j2+5);
+          blockB[count+6] = rhs(k,j2+6);
+          blockB[count+7] = rhs(k,j2+7);
+        }
+        count += nr;
+      }
+    }
+
+    // second part: diagonal block
+    Index end8 = nr>=8 ? (std::min)(k2+rows,packet_cols8) : k2;
+    if(nr>=8)
+    {
+      for(Index j2=k2; j2<end8; j2+=8)
+      {
+        // again we can split vertically in three different parts (transpose, symmetric, normal)
+        // transpose
+        for(Index k=k2; k<j2; k++)
+        {
+          blockB[count+0] = numext::conj(rhs(j2+0,k));
+          blockB[count+1] = numext::conj(rhs(j2+1,k));
+          blockB[count+2] = numext::conj(rhs(j2+2,k));
+          blockB[count+3] = numext::conj(rhs(j2+3,k));
+          blockB[count+4] = numext::conj(rhs(j2+4,k));
+          blockB[count+5] = numext::conj(rhs(j2+5,k));
+          blockB[count+6] = numext::conj(rhs(j2+6,k));
+          blockB[count+7] = numext::conj(rhs(j2+7,k));
+          count += 8;
+        }
+        // symmetric
+        Index h = 0;
+        for(Index k=j2; k<j2+8; k++)
+        {
+          // normal
+          for (Index w=0 ; w<h; ++w)
+            blockB[count+w] = rhs(k,j2+w);
+
+          blockB[count+h] = numext::real(rhs(k,k));
+
+          // transpose
+          for (Index w=h+1 ; w<8; ++w)
+            blockB[count+w] = numext::conj(rhs(j2+w,k));
+          count += 8;
+          ++h;
+        }
+        // normal
+        for(Index k=j2+8; k<end_k; k++)
+        {
+          blockB[count+0] = rhs(k,j2+0);
+          blockB[count+1] = rhs(k,j2+1);
+          blockB[count+2] = rhs(k,j2+2);
+          blockB[count+3] = rhs(k,j2+3);
+          blockB[count+4] = rhs(k,j2+4);
+          blockB[count+5] = rhs(k,j2+5);
+          blockB[count+6] = rhs(k,j2+6);
+          blockB[count+7] = rhs(k,j2+7);
+          count += 8;
+        }
+      }
+    }
+    if(nr>=4)
+    {
+      for(Index j2=end8; j2<(std::min)(k2+rows,packet_cols4); j2+=4)
+      {
+        // again we can split vertically in three different parts (transpose, symmetric, normal)
+        // transpose
+        for(Index k=k2; k<j2; k++)
+        {
+          blockB[count+0] = numext::conj(rhs(j2+0,k));
+          blockB[count+1] = numext::conj(rhs(j2+1,k));
+          blockB[count+2] = numext::conj(rhs(j2+2,k));
+          blockB[count+3] = numext::conj(rhs(j2+3,k));
+          count += 4;
+        }
+        // symmetric
+        Index h = 0;
+        for(Index k=j2; k<j2+4; k++)
+        {
+          // normal
+          for (Index w=0 ; w<h; ++w)
+            blockB[count+w] = rhs(k,j2+w);
+
+          blockB[count+h] = numext::real(rhs(k,k));
+
+          // transpose
+          for (Index w=h+1 ; w<4; ++w)
+            blockB[count+w] = numext::conj(rhs(j2+w,k));
+          count += 4;
+          ++h;
+        }
+        // normal
+        for(Index k=j2+4; k<end_k; k++)
+        {
+          blockB[count+0] = rhs(k,j2+0);
+          blockB[count+1] = rhs(k,j2+1);
+          blockB[count+2] = rhs(k,j2+2);
+          blockB[count+3] = rhs(k,j2+3);
+          count += 4;
+        }
+      }
+    }
+
+    // third part: transposed
+    if(nr>=8)
+    {
+      for(Index j2=k2+rows; j2<packet_cols8; j2+=8)
+      {
+        for(Index k=k2; k<end_k; k++)
+        {
+          blockB[count+0] = numext::conj(rhs(j2+0,k));
+          blockB[count+1] = numext::conj(rhs(j2+1,k));
+          blockB[count+2] = numext::conj(rhs(j2+2,k));
+          blockB[count+3] = numext::conj(rhs(j2+3,k));
+          blockB[count+4] = numext::conj(rhs(j2+4,k));
+          blockB[count+5] = numext::conj(rhs(j2+5,k));
+          blockB[count+6] = numext::conj(rhs(j2+6,k));
+          blockB[count+7] = numext::conj(rhs(j2+7,k));
+          count += 8;
+        }
+      }
+    }
+    if(nr>=4)
+    {
+      for(Index j2=(std::max)(packet_cols8,k2+rows); j2<packet_cols4; j2+=4)
+      {
+        for(Index k=k2; k<end_k; k++)
+        {
+          blockB[count+0] = numext::conj(rhs(j2+0,k));
+          blockB[count+1] = numext::conj(rhs(j2+1,k));
+          blockB[count+2] = numext::conj(rhs(j2+2,k));
+          blockB[count+3] = numext::conj(rhs(j2+3,k));
+          count += 4;
+        }
+      }
+    }
+
+    // copy the remaining columns one at a time (=> the same with nr==1)
+    for(Index j2=packet_cols4; j2<cols; ++j2)
+    {
+      // transpose
+      Index half = (std::min)(end_k,j2);
+      for(Index k=k2; k<half; k++)
+      {
+        blockB[count] = numext::conj(rhs(j2,k));
+        count += 1;
+      }
+
+      if(half==j2 && half<k2+rows)
+      {
+        blockB[count] = numext::real(rhs(j2,j2));
+        count += 1;
+      }
+      else
+        half--;
+
+      // normal
+      for(Index k=half+1; k<k2+rows; k++)
+      {
+        blockB[count] = rhs(k,j2);
+        count += 1;
+      }
+    }
+  }
+};
+
+/* Optimized selfadjoint matrix * matrix (_SYMM) product built on top of
+ * the general matrix matrix product.
+ */
+template <typename Scalar, typename Index,
+          int LhsStorageOrder, bool LhsSelfAdjoint, bool ConjugateLhs,
+          int RhsStorageOrder, bool RhsSelfAdjoint, bool ConjugateRhs,
+          int ResStorageOrder>
+struct product_selfadjoint_matrix;
+
+template <typename Scalar, typename Index,
+          int LhsStorageOrder, bool LhsSelfAdjoint, bool ConjugateLhs,
+          int RhsStorageOrder, bool RhsSelfAdjoint, bool ConjugateRhs>
+struct product_selfadjoint_matrix<Scalar,Index,LhsStorageOrder,LhsSelfAdjoint,ConjugateLhs, RhsStorageOrder,RhsSelfAdjoint,ConjugateRhs,RowMajor>
+{
+
+  static EIGEN_STRONG_INLINE void run(
+    Index rows, Index cols,
+    const Scalar* lhs, Index lhsStride,
+    const Scalar* rhs, Index rhsStride,
+    Scalar* res,       Index resStride,
+    const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking)
+  {
+    product_selfadjoint_matrix<Scalar, Index,
+      EIGEN_LOGICAL_XOR(RhsSelfAdjoint,RhsStorageOrder==RowMajor) ? ColMajor : RowMajor,
+      RhsSelfAdjoint, NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(RhsSelfAdjoint,ConjugateRhs),
+      EIGEN_LOGICAL_XOR(LhsSelfAdjoint,LhsStorageOrder==RowMajor) ? ColMajor : RowMajor,
+      LhsSelfAdjoint, NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(LhsSelfAdjoint,ConjugateLhs),
+      ColMajor>
+      ::run(cols, rows,  rhs, rhsStride,  lhs, lhsStride,  res, resStride,  alpha, blocking);
+  }
+};
+
+template <typename Scalar, typename Index,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs>
+struct product_selfadjoint_matrix<Scalar,Index,LhsStorageOrder,true,ConjugateLhs, RhsStorageOrder,false,ConjugateRhs,ColMajor>
+{
+
+  static EIGEN_DONT_INLINE void run(
+    Index rows, Index cols,
+    const Scalar* _lhs, Index lhsStride,
+    const Scalar* _rhs, Index rhsStride,
+    Scalar* res,        Index resStride,
+    const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking);
+};
+
+template <typename Scalar, typename Index,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs>
+EIGEN_DONT_INLINE void product_selfadjoint_matrix<Scalar,Index,LhsStorageOrder,true,ConjugateLhs, RhsStorageOrder,false,ConjugateRhs,ColMajor>::run(
+    Index rows, Index cols,
+    const Scalar* _lhs, Index lhsStride,
+    const Scalar* _rhs, Index rhsStride,
+    Scalar* _res,        Index resStride,
+    const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking)
+  {
+    Index size = rows;
+
+    typedef gebp_traits<Scalar,Scalar> Traits;
+
+    typedef const_blas_data_mapper<Scalar, Index, LhsStorageOrder> LhsMapper;
+    typedef const_blas_data_mapper<Scalar, Index, (LhsStorageOrder == RowMajor) ? ColMajor : RowMajor> LhsTransposeMapper;
+    typedef const_blas_data_mapper<Scalar, Index, RhsStorageOrder> RhsMapper;
+    typedef blas_data_mapper<typename Traits::ResScalar, Index, ColMajor> ResMapper;
+    LhsMapper lhs(_lhs,lhsStride);
+    LhsTransposeMapper lhs_transpose(_lhs,lhsStride);
+    RhsMapper rhs(_rhs,rhsStride);
+    ResMapper res(_res, resStride);
+
+    Index kc = blocking.kc();                   // cache block size along the K direction
+    Index mc = (std::min)(rows,blocking.mc());  // cache block size along the M direction
+    // kc must be smaller than mc
+    kc = (std::min)(kc,mc);
+    std::size_t sizeA = kc*mc;
+    std::size_t sizeB = kc*cols;
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA());
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB());
+
+    gebp_kernel<Scalar, Scalar, Index, ResMapper, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp_kernel;
+    symm_pack_lhs<Scalar, Index, Traits::mr, Traits::LhsProgress, LhsStorageOrder> pack_lhs;
+    gemm_pack_rhs<Scalar, Index, RhsMapper, Traits::nr,RhsStorageOrder> pack_rhs;
+    gemm_pack_lhs<Scalar, Index, LhsTransposeMapper, Traits::mr, Traits::LhsProgress, LhsStorageOrder==RowMajor?ColMajor:RowMajor, true> pack_lhs_transposed;
+
+    for(Index k2=0; k2<size; k2+=kc)
+    {
+      const Index actual_kc = (std::min)(k2+kc,size)-k2;
+
+      // we have selected one row panel of rhs and one column panel of lhs
+      // pack rhs's panel into a sequential chunk of memory
+      // and expand each coeff to a constant packet for further reuse
+      pack_rhs(blockB, rhs.getSubMapper(k2,0), actual_kc, cols);
+
+      // the select lhs's panel has to be split in three different parts:
+      //  1 - the transposed panel above the diagonal block => transposed packed copy
+      //  2 - the diagonal block => special packed copy
+      //  3 - the panel below the diagonal block => generic packed copy
+      for(Index i2=0; i2<k2; i2+=mc)
+      {
+        const Index actual_mc = (std::min)(i2+mc,k2)-i2;
+        // transposed packed copy
+        pack_lhs_transposed(blockA, lhs_transpose.getSubMapper(i2, k2), actual_kc, actual_mc);
+
+        gebp_kernel(res.getSubMapper(i2, 0), blockA, blockB, actual_mc, actual_kc, cols, alpha);
+      }
+      // the block diagonal
+      {
+        const Index actual_mc = (std::min)(k2+kc,size)-k2;
+        // symmetric packed copy
+        pack_lhs(blockA, &lhs(k2,k2), lhsStride, actual_kc, actual_mc);
+
+        gebp_kernel(res.getSubMapper(k2, 0), blockA, blockB, actual_mc, actual_kc, cols, alpha);
+      }
+
+      for(Index i2=k2+kc; i2<size; i2+=mc)
+      {
+        const Index actual_mc = (std::min)(i2+mc,size)-i2;
+        gemm_pack_lhs<Scalar, Index, LhsMapper, Traits::mr, Traits::LhsProgress, LhsStorageOrder,false>()
+          (blockA, lhs.getSubMapper(i2, k2), actual_kc, actual_mc);
+
+        gebp_kernel(res.getSubMapper(i2, 0), blockA, blockB, actual_mc, actual_kc, cols, alpha);
+      }
+    }
+  }
+
+// matrix * selfadjoint product
+template <typename Scalar, typename Index,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs>
+struct product_selfadjoint_matrix<Scalar,Index,LhsStorageOrder,false,ConjugateLhs, RhsStorageOrder,true,ConjugateRhs,ColMajor>
+{
+
+  static EIGEN_DONT_INLINE void run(
+    Index rows, Index cols,
+    const Scalar* _lhs, Index lhsStride,
+    const Scalar* _rhs, Index rhsStride,
+    Scalar* res,        Index resStride,
+    const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking);
+};
+
+template <typename Scalar, typename Index,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs>
+EIGEN_DONT_INLINE void product_selfadjoint_matrix<Scalar,Index,LhsStorageOrder,false,ConjugateLhs, RhsStorageOrder,true,ConjugateRhs,ColMajor>::run(
+    Index rows, Index cols,
+    const Scalar* _lhs, Index lhsStride,
+    const Scalar* _rhs, Index rhsStride,
+    Scalar* _res,        Index resStride,
+    const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking)
+  {
+    Index size = cols;
+
+    typedef gebp_traits<Scalar,Scalar> Traits;
+
+    typedef const_blas_data_mapper<Scalar, Index, LhsStorageOrder> LhsMapper;
+    typedef blas_data_mapper<typename Traits::ResScalar, Index, ColMajor> ResMapper;
+    LhsMapper lhs(_lhs,lhsStride);
+    ResMapper res(_res,resStride);
+
+    Index kc = blocking.kc();                   // cache block size along the K direction
+    Index mc = (std::min)(rows,blocking.mc());  // cache block size along the M direction
+    std::size_t sizeA = kc*mc;
+    std::size_t sizeB = kc*cols;
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA());
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB());
+
+    gebp_kernel<Scalar, Scalar, Index, ResMapper, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp_kernel;
+    gemm_pack_lhs<Scalar, Index, LhsMapper, Traits::mr, Traits::LhsProgress, LhsStorageOrder> pack_lhs;
+    symm_pack_rhs<Scalar, Index, Traits::nr,RhsStorageOrder> pack_rhs;
+
+    for(Index k2=0; k2<size; k2+=kc)
+    {
+      const Index actual_kc = (std::min)(k2+kc,size)-k2;
+
+      pack_rhs(blockB, _rhs, rhsStride, actual_kc, cols, k2);
+
+      // => GEPP
+      for(Index i2=0; i2<rows; i2+=mc)
+      {
+        const Index actual_mc = (std::min)(i2+mc,rows)-i2;
+        pack_lhs(blockA, lhs.getSubMapper(i2, k2), actual_kc, actual_mc);
+
+        gebp_kernel(res.getSubMapper(i2, 0), blockA, blockB, actual_mc, actual_kc, cols, alpha);
+      }
+    }
+  }
+
+} // end namespace internal
+
+/***************************************************************************
+* Wrapper to product_selfadjoint_matrix
+***************************************************************************/
+
+namespace internal {
+  
+template<typename Lhs, int LhsMode, typename Rhs, int RhsMode>
+struct selfadjoint_product_impl<Lhs,LhsMode,false,Rhs,RhsMode,false>
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+  
+  typedef internal::blas_traits<Lhs> LhsBlasTraits;
+  typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
+  typedef internal::blas_traits<Rhs> RhsBlasTraits;
+  typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
+  
+  enum {
+    LhsIsUpper = (LhsMode&(Upper|Lower))==Upper,
+    LhsIsSelfAdjoint = (LhsMode&SelfAdjoint)==SelfAdjoint,
+    RhsIsUpper = (RhsMode&(Upper|Lower))==Upper,
+    RhsIsSelfAdjoint = (RhsMode&SelfAdjoint)==SelfAdjoint
+  };
+  
+  template<typename Dest>
+  static void run(Dest &dst, const Lhs &a_lhs, const Rhs &a_rhs, const Scalar& alpha)
+  {
+    eigen_assert(dst.rows()==a_lhs.rows() && dst.cols()==a_rhs.cols());
+
+    typename internal::add_const_on_value_type<ActualLhsType>::type lhs = LhsBlasTraits::extract(a_lhs);
+    typename internal::add_const_on_value_type<ActualRhsType>::type rhs = RhsBlasTraits::extract(a_rhs);
+
+    Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(a_lhs)
+                               * RhsBlasTraits::extractScalarFactor(a_rhs);
+
+    typedef internal::gemm_blocking_space<(Dest::Flags&RowMajorBit) ? RowMajor : ColMajor,Scalar,Scalar,
+              Lhs::MaxRowsAtCompileTime, Rhs::MaxColsAtCompileTime, Lhs::MaxColsAtCompileTime,1> BlockingType;
+
+    BlockingType blocking(lhs.rows(), rhs.cols(), lhs.cols(), 1, false);
+
+    internal::product_selfadjoint_matrix<Scalar, Index,
+      EIGEN_LOGICAL_XOR(LhsIsUpper,internal::traits<Lhs>::Flags &RowMajorBit) ? RowMajor : ColMajor, LhsIsSelfAdjoint,
+      NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(LhsIsUpper,bool(LhsBlasTraits::NeedToConjugate)),
+      EIGEN_LOGICAL_XOR(RhsIsUpper,internal::traits<Rhs>::Flags &RowMajorBit) ? RowMajor : ColMajor, RhsIsSelfAdjoint,
+      NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(RhsIsUpper,bool(RhsBlasTraits::NeedToConjugate)),
+      internal::traits<Dest>::Flags&RowMajorBit  ? RowMajor : ColMajor>
+      ::run(
+        lhs.rows(), rhs.cols(),                 // sizes
+        &lhs.coeffRef(0,0), lhs.outerStride(),  // lhs info
+        &rhs.coeffRef(0,0), rhs.outerStride(),  // rhs info
+        &dst.coeffRef(0,0), dst.outerStride(),  // result info
+        actualAlpha, blocking                   // alpha
+      );
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SELFADJOINT_MATRIX_MATRIX_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
new file mode 100644
index 00000000..9a531850
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
@@ -0,0 +1,287 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+ ********************************************************************************
+ *   Content : Eigen bindings to BLAS F77
+ *   Self adjoint matrix * matrix product functionality based on ?SYMM/?HEMM.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_SELFADJOINT_MATRIX_MATRIX_BLAS_H
+#define EIGEN_SELFADJOINT_MATRIX_MATRIX_BLAS_H
+
+namespace Eigen { 
+
+namespace internal {
+
+
+/* Optimized selfadjoint matrix * matrix (?SYMM/?HEMM) product */
+
+#define EIGEN_BLAS_SYMM_L(EIGTYPE, BLASTYPE, EIGPREFIX, BLASFUNC) \
+template <typename Index, \
+          int LhsStorageOrder, bool ConjugateLhs, \
+          int RhsStorageOrder, bool ConjugateRhs> \
+struct product_selfadjoint_matrix<EIGTYPE,Index,LhsStorageOrder,true,ConjugateLhs,RhsStorageOrder,false,ConjugateRhs,ColMajor> \
+{\
+\
+  static void run( \
+    Index rows, Index cols, \
+    const EIGTYPE* _lhs, Index lhsStride, \
+    const EIGTYPE* _rhs, Index rhsStride, \
+    EIGTYPE* res,        Index resStride, \
+    EIGTYPE alpha, level3_blocking<EIGTYPE, EIGTYPE>& /*blocking*/) \
+  { \
+    char side='L', uplo='L'; \
+    BlasIndex m, n, lda, ldb, ldc; \
+    const EIGTYPE *a, *b; \
+    EIGTYPE beta(1); \
+    MatrixX##EIGPREFIX b_tmp; \
+\
+/* Set transpose options */ \
+/* Set m, n, k */ \
+    m = convert_index<BlasIndex>(rows);  \
+    n = convert_index<BlasIndex>(cols);  \
+\
+/* Set lda, ldb, ldc */ \
+    lda = convert_index<BlasIndex>(lhsStride); \
+    ldb = convert_index<BlasIndex>(rhsStride); \
+    ldc = convert_index<BlasIndex>(resStride); \
+\
+/* Set a, b, c */ \
+    if (LhsStorageOrder==RowMajor) uplo='U'; \
+    a = _lhs; \
+\
+    if (RhsStorageOrder==RowMajor) { \
+      Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > rhs(_rhs,n,m,OuterStride<>(rhsStride)); \
+      b_tmp = rhs.adjoint(); \
+      b = b_tmp.data(); \
+      ldb = convert_index<BlasIndex>(b_tmp.outerStride()); \
+    } else b = _rhs; \
+\
+    BLASFUNC(&side, &uplo, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (const BLASTYPE*)b, &ldb, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)res, &ldc); \
+\
+  } \
+};
+
+
+#define EIGEN_BLAS_HEMM_L(EIGTYPE, BLASTYPE, EIGPREFIX, BLASFUNC) \
+template <typename Index, \
+          int LhsStorageOrder, bool ConjugateLhs, \
+          int RhsStorageOrder, bool ConjugateRhs> \
+struct product_selfadjoint_matrix<EIGTYPE,Index,LhsStorageOrder,true,ConjugateLhs,RhsStorageOrder,false,ConjugateRhs,ColMajor> \
+{\
+  static void run( \
+    Index rows, Index cols, \
+    const EIGTYPE* _lhs, Index lhsStride, \
+    const EIGTYPE* _rhs, Index rhsStride, \
+    EIGTYPE* res,        Index resStride, \
+    EIGTYPE alpha, level3_blocking<EIGTYPE, EIGTYPE>& /*blocking*/) \
+  { \
+    char side='L', uplo='L'; \
+    BlasIndex m, n, lda, ldb, ldc; \
+    const EIGTYPE *a, *b; \
+    EIGTYPE beta(1); \
+    MatrixX##EIGPREFIX b_tmp; \
+    Matrix<EIGTYPE, Dynamic, Dynamic, LhsStorageOrder> a_tmp; \
+\
+/* Set transpose options */ \
+/* Set m, n, k */ \
+    m = convert_index<BlasIndex>(rows); \
+    n = convert_index<BlasIndex>(cols); \
+\
+/* Set lda, ldb, ldc */ \
+    lda = convert_index<BlasIndex>(lhsStride); \
+    ldb = convert_index<BlasIndex>(rhsStride); \
+    ldc = convert_index<BlasIndex>(resStride); \
+\
+/* Set a, b, c */ \
+    if (((LhsStorageOrder==ColMajor) && ConjugateLhs) || ((LhsStorageOrder==RowMajor) && (!ConjugateLhs))) { \
+      Map<const Matrix<EIGTYPE, Dynamic, Dynamic, LhsStorageOrder>, 0, OuterStride<> > lhs(_lhs,m,m,OuterStride<>(lhsStride)); \
+      a_tmp = lhs.conjugate(); \
+      a = a_tmp.data(); \
+      lda = convert_index<BlasIndex>(a_tmp.outerStride()); \
+    } else a = _lhs; \
+    if (LhsStorageOrder==RowMajor) uplo='U'; \
+\
+    if (RhsStorageOrder==ColMajor && (!ConjugateRhs)) { \
+       b = _rhs; } \
+    else { \
+      if (RhsStorageOrder==ColMajor && ConjugateRhs) { \
+        Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > rhs(_rhs,m,n,OuterStride<>(rhsStride)); \
+        b_tmp = rhs.conjugate(); \
+      } else \
+      if (ConjugateRhs) { \
+        Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > rhs(_rhs,n,m,OuterStride<>(rhsStride)); \
+        b_tmp = rhs.adjoint(); \
+      } else { \
+        Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > rhs(_rhs,n,m,OuterStride<>(rhsStride)); \
+        b_tmp = rhs.transpose(); \
+      } \
+      b = b_tmp.data(); \
+      ldb = convert_index<BlasIndex>(b_tmp.outerStride()); \
+    } \
+\
+    BLASFUNC(&side, &uplo, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (const BLASTYPE*)b, &ldb, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)res, &ldc); \
+\
+  } \
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_SYMM_L(double, double, d, dsymm)
+EIGEN_BLAS_SYMM_L(float, float, f, ssymm)
+EIGEN_BLAS_HEMM_L(dcomplex, MKL_Complex16, cd, zhemm)
+EIGEN_BLAS_HEMM_L(scomplex, MKL_Complex8, cf, chemm)
+#else
+EIGEN_BLAS_SYMM_L(double, double, d, dsymm_)
+EIGEN_BLAS_SYMM_L(float, float, f, ssymm_)
+EIGEN_BLAS_HEMM_L(dcomplex, double, cd, zhemm_)
+EIGEN_BLAS_HEMM_L(scomplex, float, cf, chemm_)
+#endif
+
+/* Optimized matrix * selfadjoint matrix (?SYMM/?HEMM) product */
+
+#define EIGEN_BLAS_SYMM_R(EIGTYPE, BLASTYPE, EIGPREFIX, BLASFUNC) \
+template <typename Index, \
+          int LhsStorageOrder, bool ConjugateLhs, \
+          int RhsStorageOrder, bool ConjugateRhs> \
+struct product_selfadjoint_matrix<EIGTYPE,Index,LhsStorageOrder,false,ConjugateLhs,RhsStorageOrder,true,ConjugateRhs,ColMajor> \
+{\
+\
+  static void run( \
+    Index rows, Index cols, \
+    const EIGTYPE* _lhs, Index lhsStride, \
+    const EIGTYPE* _rhs, Index rhsStride, \
+    EIGTYPE* res,        Index resStride, \
+    EIGTYPE alpha, level3_blocking<EIGTYPE, EIGTYPE>& /*blocking*/) \
+  { \
+    char side='R', uplo='L'; \
+    BlasIndex m, n, lda, ldb, ldc; \
+    const EIGTYPE *a, *b; \
+    EIGTYPE beta(1); \
+    MatrixX##EIGPREFIX b_tmp; \
+\
+/* Set m, n, k */ \
+    m = convert_index<BlasIndex>(rows);  \
+    n = convert_index<BlasIndex>(cols);  \
+\
+/* Set lda, ldb, ldc */ \
+    lda = convert_index<BlasIndex>(rhsStride); \
+    ldb = convert_index<BlasIndex>(lhsStride); \
+    ldc = convert_index<BlasIndex>(resStride); \
+\
+/* Set a, b, c */ \
+    if (RhsStorageOrder==RowMajor) uplo='U'; \
+    a = _rhs; \
+\
+    if (LhsStorageOrder==RowMajor) { \
+      Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > lhs(_lhs,n,m,OuterStride<>(rhsStride)); \
+      b_tmp = lhs.adjoint(); \
+      b = b_tmp.data(); \
+      ldb = convert_index<BlasIndex>(b_tmp.outerStride()); \
+    } else b = _lhs; \
+\
+    BLASFUNC(&side, &uplo, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (const BLASTYPE*)b, &ldb, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)res, &ldc); \
+\
+  } \
+};
+
+
+#define EIGEN_BLAS_HEMM_R(EIGTYPE, BLASTYPE, EIGPREFIX, BLASFUNC) \
+template <typename Index, \
+          int LhsStorageOrder, bool ConjugateLhs, \
+          int RhsStorageOrder, bool ConjugateRhs> \
+struct product_selfadjoint_matrix<EIGTYPE,Index,LhsStorageOrder,false,ConjugateLhs,RhsStorageOrder,true,ConjugateRhs,ColMajor> \
+{\
+  static void run( \
+    Index rows, Index cols, \
+    const EIGTYPE* _lhs, Index lhsStride, \
+    const EIGTYPE* _rhs, Index rhsStride, \
+    EIGTYPE* res,        Index resStride, \
+    EIGTYPE alpha, level3_blocking<EIGTYPE, EIGTYPE>& /*blocking*/) \
+  { \
+    char side='R', uplo='L'; \
+    BlasIndex m, n, lda, ldb, ldc; \
+    const EIGTYPE *a, *b; \
+    EIGTYPE beta(1); \
+    MatrixX##EIGPREFIX b_tmp; \
+    Matrix<EIGTYPE, Dynamic, Dynamic, RhsStorageOrder> a_tmp; \
+\
+/* Set m, n, k */ \
+    m = convert_index<BlasIndex>(rows); \
+    n = convert_index<BlasIndex>(cols); \
+\
+/* Set lda, ldb, ldc */ \
+    lda = convert_index<BlasIndex>(rhsStride); \
+    ldb = convert_index<BlasIndex>(lhsStride); \
+    ldc = convert_index<BlasIndex>(resStride); \
+\
+/* Set a, b, c */ \
+    if (((RhsStorageOrder==ColMajor) && ConjugateRhs) || ((RhsStorageOrder==RowMajor) && (!ConjugateRhs))) { \
+      Map<const Matrix<EIGTYPE, Dynamic, Dynamic, RhsStorageOrder>, 0, OuterStride<> > rhs(_rhs,n,n,OuterStride<>(rhsStride)); \
+      a_tmp = rhs.conjugate(); \
+      a = a_tmp.data(); \
+      lda = convert_index<BlasIndex>(a_tmp.outerStride()); \
+    } else a = _rhs; \
+    if (RhsStorageOrder==RowMajor) uplo='U'; \
+\
+    if (LhsStorageOrder==ColMajor && (!ConjugateLhs)) { \
+       b = _lhs; } \
+    else { \
+      if (LhsStorageOrder==ColMajor && ConjugateLhs) { \
+        Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > lhs(_lhs,m,n,OuterStride<>(lhsStride)); \
+        b_tmp = lhs.conjugate(); \
+      } else \
+      if (ConjugateLhs) { \
+        Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > lhs(_lhs,n,m,OuterStride<>(lhsStride)); \
+        b_tmp = lhs.adjoint(); \
+      } else { \
+        Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > lhs(_lhs,n,m,OuterStride<>(lhsStride)); \
+        b_tmp = lhs.transpose(); \
+      } \
+      b = b_tmp.data(); \
+      ldb = convert_index<BlasIndex>(b_tmp.outerStride()); \
+    } \
+\
+    BLASFUNC(&side, &uplo, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (const BLASTYPE*)b, &ldb, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)res, &ldc); \
+  } \
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_SYMM_R(double, double, d, dsymm)
+EIGEN_BLAS_SYMM_R(float, float, f, ssymm)
+EIGEN_BLAS_HEMM_R(dcomplex, MKL_Complex16, cd, zhemm)
+EIGEN_BLAS_HEMM_R(scomplex, MKL_Complex8, cf, chemm)
+#else
+EIGEN_BLAS_SYMM_R(double, double, d, dsymm_)
+EIGEN_BLAS_SYMM_R(float, float, f, ssymm_)
+EIGEN_BLAS_HEMM_R(dcomplex, double, cd, zhemm_)
+EIGEN_BLAS_HEMM_R(scomplex, float, cf, chemm_)
+#endif
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SELFADJOINT_MATRIX_MATRIX_BLAS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/SelfadjointMatrixVector.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/SelfadjointMatrixVector.h
new file mode 100644
index 00000000..3fd180e6
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/SelfadjointMatrixVector.h
@@ -0,0 +1,260 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SELFADJOINT_MATRIX_VECTOR_H
+#define EIGEN_SELFADJOINT_MATRIX_VECTOR_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/* Optimized selfadjoint matrix * vector product:
+ * This algorithm processes 2 columns at onces that allows to both reduce
+ * the number of load/stores of the result by a factor 2 and to reduce
+ * the instruction dependency.
+ */
+
+template<typename Scalar, typename Index, int StorageOrder, int UpLo, bool ConjugateLhs, bool ConjugateRhs, int Version=Specialized>
+struct selfadjoint_matrix_vector_product;
+
+template<typename Scalar, typename Index, int StorageOrder, int UpLo, bool ConjugateLhs, bool ConjugateRhs, int Version>
+struct selfadjoint_matrix_vector_product
+
+{
+static EIGEN_DONT_INLINE void run(
+  Index size,
+  const Scalar*  lhs, Index lhsStride,
+  const Scalar*  rhs,
+  Scalar* res,
+  Scalar alpha);
+};
+
+template<typename Scalar, typename Index, int StorageOrder, int UpLo, bool ConjugateLhs, bool ConjugateRhs, int Version>
+EIGEN_DONT_INLINE void selfadjoint_matrix_vector_product<Scalar,Index,StorageOrder,UpLo,ConjugateLhs,ConjugateRhs,Version>::run(
+  Index size,
+  const Scalar*  lhs, Index lhsStride,
+  const Scalar*  rhs,
+  Scalar* res,
+  Scalar alpha)
+{
+  typedef typename packet_traits<Scalar>::type Packet;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  const Index PacketSize = sizeof(Packet)/sizeof(Scalar);
+
+  enum {
+    IsRowMajor = StorageOrder==RowMajor ? 1 : 0,
+    IsLower = UpLo == Lower ? 1 : 0,
+    FirstTriangular = IsRowMajor == IsLower
+  };
+
+  conj_helper<Scalar,Scalar,NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs,  IsRowMajor), ConjugateRhs> cj0;
+  conj_helper<Scalar,Scalar,NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs, !IsRowMajor), ConjugateRhs> cj1;
+  conj_helper<RealScalar,Scalar,false, ConjugateRhs> cjd;
+
+  conj_helper<Packet,Packet,NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs,  IsRowMajor), ConjugateRhs> pcj0;
+  conj_helper<Packet,Packet,NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs, !IsRowMajor), ConjugateRhs> pcj1;
+
+  Scalar cjAlpha = ConjugateRhs ? numext::conj(alpha) : alpha;
+
+
+  Index bound = (std::max)(Index(0),size-8) & 0xfffffffe;
+  if (FirstTriangular)
+    bound = size - bound;
+
+  for (Index j=FirstTriangular ? bound : 0;
+       j<(FirstTriangular ? size : bound);j+=2)
+  {
+    const Scalar* EIGEN_RESTRICT A0 = lhs + j*lhsStride;
+    const Scalar* EIGEN_RESTRICT A1 = lhs + (j+1)*lhsStride;
+
+    Scalar t0 = cjAlpha * rhs[j];
+    Packet ptmp0 = pset1<Packet>(t0);
+    Scalar t1 = cjAlpha * rhs[j+1];
+    Packet ptmp1 = pset1<Packet>(t1);
+
+    Scalar t2(0);
+    Packet ptmp2 = pset1<Packet>(t2);
+    Scalar t3(0);
+    Packet ptmp3 = pset1<Packet>(t3);
+
+    Index starti = FirstTriangular ? 0 : j+2;
+    Index endi   = FirstTriangular ? j : size;
+    Index alignedStart = (starti) + internal::first_default_aligned(&res[starti], endi-starti);
+    Index alignedEnd = alignedStart + ((endi-alignedStart)/(PacketSize))*(PacketSize);
+
+    res[j]   += cjd.pmul(numext::real(A0[j]), t0);
+    res[j+1] += cjd.pmul(numext::real(A1[j+1]), t1);
+    if(FirstTriangular)
+    {
+      res[j]   += cj0.pmul(A1[j],   t1);
+      t3       += cj1.pmul(A1[j],   rhs[j]);
+    }
+    else
+    {
+      res[j+1] += cj0.pmul(A0[j+1],t0);
+      t2 += cj1.pmul(A0[j+1], rhs[j+1]);
+    }
+
+    for (Index i=starti; i<alignedStart; ++i)
+    {
+      res[i] += cj0.pmul(A0[i], t0) + cj0.pmul(A1[i],t1);
+      t2 += cj1.pmul(A0[i], rhs[i]);
+      t3 += cj1.pmul(A1[i], rhs[i]);
+    }
+    // Yes this an optimization for gcc 4.3 and 4.4 (=> huge speed up)
+    // gcc 4.2 does this optimization automatically.
+    const Scalar* EIGEN_RESTRICT a0It  = A0  + alignedStart;
+    const Scalar* EIGEN_RESTRICT a1It  = A1  + alignedStart;
+    const Scalar* EIGEN_RESTRICT rhsIt = rhs + alignedStart;
+          Scalar* EIGEN_RESTRICT resIt = res + alignedStart;
+    for (Index i=alignedStart; i<alignedEnd; i+=PacketSize)
+    {
+      Packet A0i = ploadu<Packet>(a0It);  a0It  += PacketSize;
+      Packet A1i = ploadu<Packet>(a1It);  a1It  += PacketSize;
+      Packet Bi  = ploadu<Packet>(rhsIt); rhsIt += PacketSize; // FIXME should be aligned in most cases
+      Packet Xi  = pload <Packet>(resIt);
+
+      Xi    = pcj0.pmadd(A0i,ptmp0, pcj0.pmadd(A1i,ptmp1,Xi));
+      ptmp2 = pcj1.pmadd(A0i,  Bi, ptmp2);
+      ptmp3 = pcj1.pmadd(A1i,  Bi, ptmp3);
+      pstore(resIt,Xi); resIt += PacketSize;
+    }
+    for (Index i=alignedEnd; i<endi; i++)
+    {
+      res[i] += cj0.pmul(A0[i], t0) + cj0.pmul(A1[i],t1);
+      t2 += cj1.pmul(A0[i], rhs[i]);
+      t3 += cj1.pmul(A1[i], rhs[i]);
+    }
+
+    res[j]   += alpha * (t2 + predux(ptmp2));
+    res[j+1] += alpha * (t3 + predux(ptmp3));
+  }
+  for (Index j=FirstTriangular ? 0 : bound;j<(FirstTriangular ? bound : size);j++)
+  {
+    const Scalar* EIGEN_RESTRICT A0 = lhs + j*lhsStride;
+
+    Scalar t1 = cjAlpha * rhs[j];
+    Scalar t2(0);
+    res[j] += cjd.pmul(numext::real(A0[j]), t1);
+    for (Index i=FirstTriangular ? 0 : j+1; i<(FirstTriangular ? j : size); i++)
+    {
+      res[i] += cj0.pmul(A0[i], t1);
+      t2 += cj1.pmul(A0[i], rhs[i]);
+    }
+    res[j] += alpha * t2;
+  }
+}
+
+} // end namespace internal 
+
+/***************************************************************************
+* Wrapper to product_selfadjoint_vector
+***************************************************************************/
+
+namespace internal {
+
+template<typename Lhs, int LhsMode, typename Rhs>
+struct selfadjoint_product_impl<Lhs,LhsMode,false,Rhs,0,true>
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+  
+  typedef internal::blas_traits<Lhs> LhsBlasTraits;
+  typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
+  typedef typename internal::remove_all<ActualLhsType>::type ActualLhsTypeCleaned;
+  
+  typedef internal::blas_traits<Rhs> RhsBlasTraits;
+  typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
+  typedef typename internal::remove_all<ActualRhsType>::type ActualRhsTypeCleaned;
+
+  enum { LhsUpLo = LhsMode&(Upper|Lower) };
+
+  template<typename Dest>
+  static void run(Dest& dest, const Lhs &a_lhs, const Rhs &a_rhs, const Scalar& alpha)
+  {
+    typedef typename Dest::Scalar ResScalar;
+    typedef typename Rhs::Scalar RhsScalar;
+    typedef Map<Matrix<ResScalar,Dynamic,1>, EIGEN_PLAIN_ENUM_MIN(AlignedMax,internal::packet_traits<ResScalar>::size)> MappedDest;
+    
+    eigen_assert(dest.rows()==a_lhs.rows() && dest.cols()==a_rhs.cols());
+
+    typename internal::add_const_on_value_type<ActualLhsType>::type lhs = LhsBlasTraits::extract(a_lhs);
+    typename internal::add_const_on_value_type<ActualRhsType>::type rhs = RhsBlasTraits::extract(a_rhs);
+
+    Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(a_lhs)
+                               * RhsBlasTraits::extractScalarFactor(a_rhs);
+
+    enum {
+      EvalToDest = (Dest::InnerStrideAtCompileTime==1),
+      UseRhs = (ActualRhsTypeCleaned::InnerStrideAtCompileTime==1)
+    };
+    
+    internal::gemv_static_vector_if<ResScalar,Dest::SizeAtCompileTime,Dest::MaxSizeAtCompileTime,!EvalToDest> static_dest;
+    internal::gemv_static_vector_if<RhsScalar,ActualRhsTypeCleaned::SizeAtCompileTime,ActualRhsTypeCleaned::MaxSizeAtCompileTime,!UseRhs> static_rhs;
+
+    ei_declare_aligned_stack_constructed_variable(ResScalar,actualDestPtr,dest.size(),
+                                                  EvalToDest ? dest.data() : static_dest.data());
+                                                  
+    ei_declare_aligned_stack_constructed_variable(RhsScalar,actualRhsPtr,rhs.size(),
+        UseRhs ? const_cast<RhsScalar*>(rhs.data()) : static_rhs.data());
+    
+    if(!EvalToDest)
+    {
+      #ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+      Index size = dest.size();
+      EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+      #endif
+      MappedDest(actualDestPtr, dest.size()) = dest;
+    }
+      
+    if(!UseRhs)
+    {
+      #ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+      Index size = rhs.size();
+      EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+      #endif
+      Map<typename ActualRhsTypeCleaned::PlainObject>(actualRhsPtr, rhs.size()) = rhs;
+    }
+      
+      
+    internal::selfadjoint_matrix_vector_product<Scalar, Index, (internal::traits<ActualLhsTypeCleaned>::Flags&RowMajorBit) ? RowMajor : ColMajor,
+                                                int(LhsUpLo), bool(LhsBlasTraits::NeedToConjugate), bool(RhsBlasTraits::NeedToConjugate)>::run
+      (
+        lhs.rows(),                             // size
+        &lhs.coeffRef(0,0),  lhs.outerStride(), // lhs info
+        actualRhsPtr,                           // rhs info
+        actualDestPtr,                          // result info
+        actualAlpha                             // scale factor
+      );
+    
+    if(!EvalToDest)
+      dest = MappedDest(actualDestPtr, dest.size());
+  }
+};
+
+template<typename Lhs, typename Rhs, int RhsMode>
+struct selfadjoint_product_impl<Lhs,0,true,Rhs,RhsMode,false>
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+  enum { RhsUpLo = RhsMode&(Upper|Lower)  };
+
+  template<typename Dest>
+  static void run(Dest& dest, const Lhs &a_lhs, const Rhs &a_rhs, const Scalar& alpha)
+  {
+    // let's simply transpose the product
+    Transpose<Dest> destT(dest);
+    selfadjoint_product_impl<Transpose<const Rhs>, int(RhsUpLo)==Upper ? Lower : Upper, false,
+                             Transpose<const Lhs>, 0, true>::run(destT, a_rhs.transpose(), a_lhs.transpose(), alpha);
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SELFADJOINT_MATRIX_VECTOR_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
new file mode 100644
index 00000000..1238345e
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
@@ -0,0 +1,118 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to BLAS F77
+ *   Selfadjoint matrix-vector product functionality based on ?SYMV/HEMV.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_SELFADJOINT_MATRIX_VECTOR_BLAS_H
+#define EIGEN_SELFADJOINT_MATRIX_VECTOR_BLAS_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/**********************************************************************
+* This file implements selfadjoint matrix-vector multiplication using BLAS
+**********************************************************************/
+
+// symv/hemv specialization
+
+template<typename Scalar, typename Index, int StorageOrder, int UpLo, bool ConjugateLhs, bool ConjugateRhs>
+struct selfadjoint_matrix_vector_product_symv :
+  selfadjoint_matrix_vector_product<Scalar,Index,StorageOrder,UpLo,ConjugateLhs,ConjugateRhs,BuiltIn> {};
+
+#define EIGEN_BLAS_SYMV_SPECIALIZE(Scalar) \
+template<typename Index, int StorageOrder, int UpLo, bool ConjugateLhs, bool ConjugateRhs> \
+struct selfadjoint_matrix_vector_product<Scalar,Index,StorageOrder,UpLo,ConjugateLhs,ConjugateRhs,Specialized> { \
+static void run( \
+  Index size, const Scalar*  lhs, Index lhsStride, \
+  const Scalar* _rhs, Scalar* res, Scalar alpha) { \
+    enum {\
+      IsColMajor = StorageOrder==ColMajor \
+    }; \
+    if (IsColMajor == ConjugateLhs) {\
+      selfadjoint_matrix_vector_product<Scalar,Index,StorageOrder,UpLo,ConjugateLhs,ConjugateRhs,BuiltIn>::run( \
+        size, lhs, lhsStride, _rhs, res, alpha);  \
+    } else {\
+      selfadjoint_matrix_vector_product_symv<Scalar,Index,StorageOrder,UpLo,ConjugateLhs,ConjugateRhs>::run( \
+        size, lhs, lhsStride, _rhs, res, alpha);  \
+    }\
+  } \
+}; \
+
+EIGEN_BLAS_SYMV_SPECIALIZE(double)
+EIGEN_BLAS_SYMV_SPECIALIZE(float)
+EIGEN_BLAS_SYMV_SPECIALIZE(dcomplex)
+EIGEN_BLAS_SYMV_SPECIALIZE(scomplex)
+
+#define EIGEN_BLAS_SYMV_SPECIALIZATION(EIGTYPE,BLASTYPE,BLASFUNC) \
+template<typename Index, int StorageOrder, int UpLo, bool ConjugateLhs, bool ConjugateRhs> \
+struct selfadjoint_matrix_vector_product_symv<EIGTYPE,Index,StorageOrder,UpLo,ConjugateLhs,ConjugateRhs> \
+{ \
+typedef Matrix<EIGTYPE,Dynamic,1,ColMajor> SYMVVector;\
+\
+static void run( \
+Index size, const EIGTYPE*  lhs, Index lhsStride, \
+const EIGTYPE* _rhs, EIGTYPE* res, EIGTYPE alpha) \
+{ \
+  enum {\
+    IsRowMajor = StorageOrder==RowMajor ? 1 : 0, \
+    IsLower = UpLo == Lower ? 1 : 0 \
+  }; \
+  BlasIndex n=convert_index<BlasIndex>(size), lda=convert_index<BlasIndex>(lhsStride), incx=1, incy=1; \
+  EIGTYPE beta(1); \
+  const EIGTYPE *x_ptr; \
+  char uplo=(IsRowMajor) ? (IsLower ? 'U' : 'L') : (IsLower ? 'L' : 'U'); \
+  SYMVVector x_tmp; \
+  if (ConjugateRhs) { \
+    Map<const SYMVVector, 0 > map_x(_rhs,size,1); \
+    x_tmp=map_x.conjugate(); \
+    x_ptr=x_tmp.data(); \
+  } else x_ptr=_rhs; \
+  BLASFUNC(&uplo, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)lhs, &lda, (const BLASTYPE*)x_ptr, &incx, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)res, &incy); \
+}\
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_SYMV_SPECIALIZATION(double,   double, dsymv)
+EIGEN_BLAS_SYMV_SPECIALIZATION(float,    float,  ssymv)
+EIGEN_BLAS_SYMV_SPECIALIZATION(dcomplex, MKL_Complex16, zhemv)
+EIGEN_BLAS_SYMV_SPECIALIZATION(scomplex, MKL_Complex8,  chemv)
+#else
+EIGEN_BLAS_SYMV_SPECIALIZATION(double,   double, dsymv_)
+EIGEN_BLAS_SYMV_SPECIALIZATION(float,    float,  ssymv_)
+EIGEN_BLAS_SYMV_SPECIALIZATION(dcomplex, double, zhemv_)
+EIGEN_BLAS_SYMV_SPECIALIZATION(scomplex, float,  chemv_)
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SELFADJOINT_MATRIX_VECTOR_BLAS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/SelfadjointProduct.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/SelfadjointProduct.h
new file mode 100644
index 00000000..39c5b59f
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/SelfadjointProduct.h
@@ -0,0 +1,133 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SELFADJOINT_PRODUCT_H
+#define EIGEN_SELFADJOINT_PRODUCT_H
+
+/**********************************************************************
+* This file implements a self adjoint product: C += A A^T updating only
+* half of the selfadjoint matrix C.
+* It corresponds to the level 3 SYRK and level 2 SYR Blas routines.
+**********************************************************************/
+
+namespace Eigen { 
+
+
+template<typename Scalar, typename Index, int UpLo, bool ConjLhs, bool ConjRhs>
+struct selfadjoint_rank1_update<Scalar,Index,ColMajor,UpLo,ConjLhs,ConjRhs>
+{
+  static void run(Index size, Scalar* mat, Index stride, const Scalar* vecX, const Scalar* vecY, const Scalar& alpha)
+  {
+    internal::conj_if<ConjRhs> cj;
+    typedef Map<const Matrix<Scalar,Dynamic,1> > OtherMap;
+    typedef typename internal::conditional<ConjLhs,typename OtherMap::ConjugateReturnType,const OtherMap&>::type ConjLhsType;
+    for (Index i=0; i<size; ++i)
+    {
+      Map<Matrix<Scalar,Dynamic,1> >(mat+stride*i+(UpLo==Lower ? i : 0), (UpLo==Lower ? size-i : (i+1)))
+          += (alpha * cj(vecY[i])) * ConjLhsType(OtherMap(vecX+(UpLo==Lower ? i : 0),UpLo==Lower ? size-i : (i+1)));
+    }
+  }
+};
+
+template<typename Scalar, typename Index, int UpLo, bool ConjLhs, bool ConjRhs>
+struct selfadjoint_rank1_update<Scalar,Index,RowMajor,UpLo,ConjLhs,ConjRhs>
+{
+  static void run(Index size, Scalar* mat, Index stride, const Scalar* vecX, const Scalar* vecY, const Scalar& alpha)
+  {
+    selfadjoint_rank1_update<Scalar,Index,ColMajor,UpLo==Lower?Upper:Lower,ConjRhs,ConjLhs>::run(size,mat,stride,vecY,vecX,alpha);
+  }
+};
+
+template<typename MatrixType, typename OtherType, int UpLo, bool OtherIsVector = OtherType::IsVectorAtCompileTime>
+struct selfadjoint_product_selector;
+
+template<typename MatrixType, typename OtherType, int UpLo>
+struct selfadjoint_product_selector<MatrixType,OtherType,UpLo,true>
+{
+  static void run(MatrixType& mat, const OtherType& other, const typename MatrixType::Scalar& alpha)
+  {
+    typedef typename MatrixType::Scalar Scalar;
+    typedef internal::blas_traits<OtherType> OtherBlasTraits;
+    typedef typename OtherBlasTraits::DirectLinearAccessType ActualOtherType;
+    typedef typename internal::remove_all<ActualOtherType>::type _ActualOtherType;
+    typename internal::add_const_on_value_type<ActualOtherType>::type actualOther = OtherBlasTraits::extract(other.derived());
+
+    Scalar actualAlpha = alpha * OtherBlasTraits::extractScalarFactor(other.derived());
+
+    enum {
+      StorageOrder = (internal::traits<MatrixType>::Flags&RowMajorBit) ? RowMajor : ColMajor,
+      UseOtherDirectly = _ActualOtherType::InnerStrideAtCompileTime==1
+    };
+    internal::gemv_static_vector_if<Scalar,OtherType::SizeAtCompileTime,OtherType::MaxSizeAtCompileTime,!UseOtherDirectly> static_other;
+
+    ei_declare_aligned_stack_constructed_variable(Scalar, actualOtherPtr, other.size(),
+      (UseOtherDirectly ? const_cast<Scalar*>(actualOther.data()) : static_other.data()));
+      
+    if(!UseOtherDirectly)
+      Map<typename _ActualOtherType::PlainObject>(actualOtherPtr, actualOther.size()) = actualOther;
+    
+    selfadjoint_rank1_update<Scalar,Index,StorageOrder,UpLo,
+                              OtherBlasTraits::NeedToConjugate  && NumTraits<Scalar>::IsComplex,
+                            (!OtherBlasTraits::NeedToConjugate) && NumTraits<Scalar>::IsComplex>
+          ::run(other.size(), mat.data(), mat.outerStride(), actualOtherPtr, actualOtherPtr, actualAlpha);
+  }
+};
+
+template<typename MatrixType, typename OtherType, int UpLo>
+struct selfadjoint_product_selector<MatrixType,OtherType,UpLo,false>
+{
+  static void run(MatrixType& mat, const OtherType& other, const typename MatrixType::Scalar& alpha)
+  {
+    typedef typename MatrixType::Scalar Scalar;
+    typedef internal::blas_traits<OtherType> OtherBlasTraits;
+    typedef typename OtherBlasTraits::DirectLinearAccessType ActualOtherType;
+    typedef typename internal::remove_all<ActualOtherType>::type _ActualOtherType;
+    typename internal::add_const_on_value_type<ActualOtherType>::type actualOther = OtherBlasTraits::extract(other.derived());
+
+    Scalar actualAlpha = alpha * OtherBlasTraits::extractScalarFactor(other.derived());
+
+    enum {
+      IsRowMajor = (internal::traits<MatrixType>::Flags&RowMajorBit) ? 1 : 0,
+      OtherIsRowMajor = _ActualOtherType::Flags&RowMajorBit ? 1 : 0
+    };
+
+    Index size = mat.cols();
+    Index depth = actualOther.cols();
+
+    typedef internal::gemm_blocking_space<IsRowMajor ? RowMajor : ColMajor,Scalar,Scalar,
+              MatrixType::MaxColsAtCompileTime, MatrixType::MaxColsAtCompileTime, _ActualOtherType::MaxColsAtCompileTime> BlockingType;
+
+    BlockingType blocking(size, size, depth, 1, false);
+
+
+    internal::general_matrix_matrix_triangular_product<Index,
+      Scalar, OtherIsRowMajor ? RowMajor : ColMajor,   OtherBlasTraits::NeedToConjugate  && NumTraits<Scalar>::IsComplex,
+      Scalar, OtherIsRowMajor ? ColMajor : RowMajor, (!OtherBlasTraits::NeedToConjugate) && NumTraits<Scalar>::IsComplex,
+      IsRowMajor ? RowMajor : ColMajor, UpLo>
+      ::run(size, depth,
+            &actualOther.coeffRef(0,0), actualOther.outerStride(), &actualOther.coeffRef(0,0), actualOther.outerStride(),
+            mat.data(), mat.outerStride(), actualAlpha, blocking);
+  }
+};
+
+// high level API
+
+template<typename MatrixType, unsigned int UpLo>
+template<typename DerivedU>
+EIGEN_DEVICE_FUNC SelfAdjointView<MatrixType,UpLo>& SelfAdjointView<MatrixType,UpLo>
+::rankUpdate(const MatrixBase<DerivedU>& u, const Scalar& alpha)
+{
+  selfadjoint_product_selector<MatrixType,DerivedU,UpLo>::run(_expression().const_cast_derived(), u.derived(), alpha);
+
+  return *this;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SELFADJOINT_PRODUCT_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/SelfadjointRank2Update.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/SelfadjointRank2Update.h
new file mode 100644
index 00000000..d395888e
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/SelfadjointRank2Update.h
@@ -0,0 +1,93 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SELFADJOINTRANK2UPTADE_H
+#define EIGEN_SELFADJOINTRANK2UPTADE_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/* Optimized selfadjoint matrix += alpha * uv' + conj(alpha)*vu'
+ * It corresponds to the Level2 syr2 BLAS routine
+ */
+
+template<typename Scalar, typename Index, typename UType, typename VType, int UpLo>
+struct selfadjoint_rank2_update_selector;
+
+template<typename Scalar, typename Index, typename UType, typename VType>
+struct selfadjoint_rank2_update_selector<Scalar,Index,UType,VType,Lower>
+{
+  static void run(Scalar* mat, Index stride, const UType& u, const VType& v, const Scalar& alpha)
+  {
+    const Index size = u.size();
+    for (Index i=0; i<size; ++i)
+    {
+      Map<Matrix<Scalar,Dynamic,1> >(mat+stride*i+i, size-i) +=
+                        (numext::conj(alpha) * numext::conj(u.coeff(i))) * v.tail(size-i)
+                      + (alpha * numext::conj(v.coeff(i))) * u.tail(size-i);
+    }
+  }
+};
+
+template<typename Scalar, typename Index, typename UType, typename VType>
+struct selfadjoint_rank2_update_selector<Scalar,Index,UType,VType,Upper>
+{
+  static void run(Scalar* mat, Index stride, const UType& u, const VType& v, const Scalar& alpha)
+  {
+    const Index size = u.size();
+    for (Index i=0; i<size; ++i)
+      Map<Matrix<Scalar,Dynamic,1> >(mat+stride*i, i+1) +=
+                        (numext::conj(alpha)  * numext::conj(u.coeff(i))) * v.head(i+1)
+                      + (alpha * numext::conj(v.coeff(i))) * u.head(i+1);
+  }
+};
+
+template<bool Cond, typename T> struct conj_expr_if
+  : conditional<!Cond, const T&,
+      CwiseUnaryOp<scalar_conjugate_op<typename traits<T>::Scalar>,T> > {};
+
+} // end namespace internal
+
+template<typename MatrixType, unsigned int UpLo>
+template<typename DerivedU, typename DerivedV>
+EIGEN_DEVICE_FUNC SelfAdjointView<MatrixType,UpLo>& SelfAdjointView<MatrixType,UpLo>
+::rankUpdate(const MatrixBase<DerivedU>& u, const MatrixBase<DerivedV>& v, const Scalar& alpha)
+{
+  typedef internal::blas_traits<DerivedU> UBlasTraits;
+  typedef typename UBlasTraits::DirectLinearAccessType ActualUType;
+  typedef typename internal::remove_all<ActualUType>::type _ActualUType;
+  typename internal::add_const_on_value_type<ActualUType>::type actualU = UBlasTraits::extract(u.derived());
+
+  typedef internal::blas_traits<DerivedV> VBlasTraits;
+  typedef typename VBlasTraits::DirectLinearAccessType ActualVType;
+  typedef typename internal::remove_all<ActualVType>::type _ActualVType;
+  typename internal::add_const_on_value_type<ActualVType>::type actualV = VBlasTraits::extract(v.derived());
+
+  // If MatrixType is row major, then we use the routine for lower triangular in the upper triangular case and
+  // vice versa, and take the complex conjugate of all coefficients and vector entries.
+
+  enum { IsRowMajor = (internal::traits<MatrixType>::Flags&RowMajorBit) ? 1 : 0 };
+  Scalar actualAlpha = alpha * UBlasTraits::extractScalarFactor(u.derived())
+                             * numext::conj(VBlasTraits::extractScalarFactor(v.derived()));
+  if (IsRowMajor)
+    actualAlpha = numext::conj(actualAlpha);
+
+  typedef typename internal::remove_all<typename internal::conj_expr_if<IsRowMajor ^ UBlasTraits::NeedToConjugate,_ActualUType>::type>::type UType;
+  typedef typename internal::remove_all<typename internal::conj_expr_if<IsRowMajor ^ VBlasTraits::NeedToConjugate,_ActualVType>::type>::type VType;
+  internal::selfadjoint_rank2_update_selector<Scalar, Index, UType, VType,
+    (IsRowMajor ? int(UpLo==Upper ? Lower : Upper) : UpLo)>
+    ::run(_expression().const_cast_derived().data(),_expression().outerStride(),UType(actualU),VType(actualV),actualAlpha);
+
+  return *this;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SELFADJOINTRANK2UPTADE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/TriangularMatrixMatrix.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/TriangularMatrixMatrix.h
new file mode 100644
index 00000000..539b6c0c
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/TriangularMatrixMatrix.h
@@ -0,0 +1,448 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TRIANGULAR_MATRIX_MATRIX_H
+#define EIGEN_TRIANGULAR_MATRIX_MATRIX_H
+
+namespace Eigen { 
+
+namespace internal {
+
+// template<typename Scalar, int mr, int StorageOrder, bool Conjugate, int Mode>
+// struct gemm_pack_lhs_triangular
+// {
+//   Matrix<Scalar,mr,mr,
+//   void operator()(Scalar* blockA, const EIGEN_RESTRICT Scalar* _lhs, int lhsStride, int depth, int rows)
+//   {
+//     conj_if<NumTraits<Scalar>::IsComplex && Conjugate> cj;
+//     const_blas_data_mapper<Scalar, StorageOrder> lhs(_lhs,lhsStride);
+//     int count = 0;
+//     const int peeled_mc = (rows/mr)*mr;
+//     for(int i=0; i<peeled_mc; i+=mr)
+//     {
+//       for(int k=0; k<depth; k++)
+//         for(int w=0; w<mr; w++)
+//           blockA[count++] = cj(lhs(i+w, k));
+//     }
+//     for(int i=peeled_mc; i<rows; i++)
+//     {
+//       for(int k=0; k<depth; k++)
+//         blockA[count++] = cj(lhs(i, k));
+//     }
+//   }
+// };
+
+/* Optimized triangular matrix * matrix (_TRMM++) product built on top of
+ * the general matrix matrix product.
+ */
+template <typename Scalar, typename Index,
+          int Mode, bool LhsIsTriangular,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs,
+          int ResStorageOrder, int Version = Specialized>
+struct product_triangular_matrix_matrix;
+
+template <typename Scalar, typename Index,
+          int Mode, bool LhsIsTriangular,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs, int Version>
+struct product_triangular_matrix_matrix<Scalar,Index,Mode,LhsIsTriangular,
+                                           LhsStorageOrder,ConjugateLhs,
+                                           RhsStorageOrder,ConjugateRhs,RowMajor,Version>
+{
+  static EIGEN_STRONG_INLINE void run(
+    Index rows, Index cols, Index depth,
+    const Scalar* lhs, Index lhsStride,
+    const Scalar* rhs, Index rhsStride,
+    Scalar* res,       Index resStride,
+    const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking)
+  {
+    product_triangular_matrix_matrix<Scalar, Index,
+      (Mode&(UnitDiag|ZeroDiag)) | ((Mode&Upper) ? Lower : Upper),
+      (!LhsIsTriangular),
+      RhsStorageOrder==RowMajor ? ColMajor : RowMajor,
+      ConjugateRhs,
+      LhsStorageOrder==RowMajor ? ColMajor : RowMajor,
+      ConjugateLhs,
+      ColMajor>
+      ::run(cols, rows, depth, rhs, rhsStride, lhs, lhsStride, res, resStride, alpha, blocking);
+  }
+};
+
+// implements col-major += alpha * op(triangular) * op(general)
+template <typename Scalar, typename Index, int Mode,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs, int Version>
+struct product_triangular_matrix_matrix<Scalar,Index,Mode,true,
+                                           LhsStorageOrder,ConjugateLhs,
+                                           RhsStorageOrder,ConjugateRhs,ColMajor,Version>
+{
+  
+  typedef gebp_traits<Scalar,Scalar> Traits;
+  enum {
+    SmallPanelWidth   = 2 * EIGEN_PLAIN_ENUM_MAX(Traits::mr,Traits::nr),
+    IsLower = (Mode&Lower) == Lower,
+    SetDiag = (Mode&(ZeroDiag|UnitDiag)) ? 0 : 1
+  };
+
+  static EIGEN_DONT_INLINE void run(
+    Index _rows, Index _cols, Index _depth,
+    const Scalar* _lhs, Index lhsStride,
+    const Scalar* _rhs, Index rhsStride,
+    Scalar* res,        Index resStride,
+    const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking);
+};
+
+template <typename Scalar, typename Index, int Mode,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs, int Version>
+EIGEN_DONT_INLINE void product_triangular_matrix_matrix<Scalar,Index,Mode,true,
+                                                        LhsStorageOrder,ConjugateLhs,
+                                                        RhsStorageOrder,ConjugateRhs,ColMajor,Version>::run(
+    Index _rows, Index _cols, Index _depth,
+    const Scalar* _lhs, Index lhsStride,
+    const Scalar* _rhs, Index rhsStride,
+    Scalar* _res,        Index resStride,
+    const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking)
+  {
+    // strip zeros
+    Index diagSize  = (std::min)(_rows,_depth);
+    Index rows      = IsLower ? _rows : diagSize;
+    Index depth     = IsLower ? diagSize : _depth;
+    Index cols      = _cols;
+    
+    typedef const_blas_data_mapper<Scalar, Index, LhsStorageOrder> LhsMapper;
+    typedef const_blas_data_mapper<Scalar, Index, RhsStorageOrder> RhsMapper;
+    typedef blas_data_mapper<typename Traits::ResScalar, Index, ColMajor> ResMapper;
+    LhsMapper lhs(_lhs,lhsStride);
+    RhsMapper rhs(_rhs,rhsStride);
+    ResMapper res(_res, resStride);
+
+    Index kc = blocking.kc();                   // cache block size along the K direction
+    Index mc = (std::min)(rows,blocking.mc());  // cache block size along the M direction
+    // The small panel size must not be larger than blocking size.
+    // Usually this should never be the case because SmallPanelWidth^2 is very small
+    // compared to L2 cache size, but let's be safe:
+    Index panelWidth = (std::min)(Index(SmallPanelWidth),(std::min)(kc,mc));
+
+    std::size_t sizeA = kc*mc;
+    std::size_t sizeB = kc*cols;
+
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA());
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB());
+
+    // To work around an "error: member reference base type 'Matrix<...>
+    // (Eigen::internal::constructor_without_unaligned_array_assert (*)())' is
+    // not a structure or union" compilation error in nvcc (tested V8.0.61),
+    // create a dummy internal::constructor_without_unaligned_array_assert
+    // object to pass to the Matrix constructor.
+    internal::constructor_without_unaligned_array_assert a;
+    Matrix<Scalar,SmallPanelWidth,SmallPanelWidth,LhsStorageOrder> triangularBuffer(a);
+    triangularBuffer.setZero();
+    if((Mode&ZeroDiag)==ZeroDiag)
+      triangularBuffer.diagonal().setZero();
+    else
+      triangularBuffer.diagonal().setOnes();
+
+    gebp_kernel<Scalar, Scalar, Index, ResMapper, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp_kernel;
+    gemm_pack_lhs<Scalar, Index, LhsMapper, Traits::mr, Traits::LhsProgress, LhsStorageOrder> pack_lhs;
+    gemm_pack_rhs<Scalar, Index, RhsMapper, Traits::nr,RhsStorageOrder> pack_rhs;
+
+    for(Index k2=IsLower ? depth : 0;
+        IsLower ? k2>0 : k2<depth;
+        IsLower ? k2-=kc : k2+=kc)
+    {
+      Index actual_kc = (std::min)(IsLower ? k2 : depth-k2, kc);
+      Index actual_k2 = IsLower ? k2-actual_kc : k2;
+
+      // align blocks with the end of the triangular part for trapezoidal lhs
+      if((!IsLower)&&(k2<rows)&&(k2+actual_kc>rows))
+      {
+        actual_kc = rows-k2;
+        k2 = k2+actual_kc-kc;
+      }
+
+      pack_rhs(blockB, rhs.getSubMapper(actual_k2,0), actual_kc, cols);
+
+      // the selected lhs's panel has to be split in three different parts:
+      //  1 - the part which is zero => skip it
+      //  2 - the diagonal block => special kernel
+      //  3 - the dense panel below (lower case) or above (upper case) the diagonal block => GEPP
+
+      // the block diagonal, if any:
+      if(IsLower || actual_k2<rows)
+      {
+        // for each small vertical panels of lhs
+        for (Index k1=0; k1<actual_kc; k1+=panelWidth)
+        {
+          Index actualPanelWidth = std::min<Index>(actual_kc-k1, panelWidth);
+          Index lengthTarget = IsLower ? actual_kc-k1-actualPanelWidth : k1;
+          Index startBlock   = actual_k2+k1;
+          Index blockBOffset = k1;
+
+          // => GEBP with the micro triangular block
+          // The trick is to pack this micro block while filling the opposite triangular part with zeros.
+          // To this end we do an extra triangular copy to a small temporary buffer
+          for (Index k=0;k<actualPanelWidth;++k)
+          {
+            if (SetDiag)
+              triangularBuffer.coeffRef(k,k) = lhs(startBlock+k,startBlock+k);
+            for (Index i=IsLower ? k+1 : 0; IsLower ? i<actualPanelWidth : i<k; ++i)
+              triangularBuffer.coeffRef(i,k) = lhs(startBlock+i,startBlock+k);
+          }
+          pack_lhs(blockA, LhsMapper(triangularBuffer.data(), triangularBuffer.outerStride()), actualPanelWidth, actualPanelWidth);
+
+          gebp_kernel(res.getSubMapper(startBlock, 0), blockA, blockB,
+                      actualPanelWidth, actualPanelWidth, cols, alpha,
+                      actualPanelWidth, actual_kc, 0, blockBOffset);
+
+          // GEBP with remaining micro panel
+          if (lengthTarget>0)
+          {
+            Index startTarget  = IsLower ? actual_k2+k1+actualPanelWidth : actual_k2;
+
+            pack_lhs(blockA, lhs.getSubMapper(startTarget,startBlock), actualPanelWidth, lengthTarget);
+
+            gebp_kernel(res.getSubMapper(startTarget, 0), blockA, blockB,
+                        lengthTarget, actualPanelWidth, cols, alpha,
+                        actualPanelWidth, actual_kc, 0, blockBOffset);
+          }
+        }
+      }
+      // the part below (lower case) or above (upper case) the diagonal => GEPP
+      {
+        Index start = IsLower ? k2 : 0;
+        Index end   = IsLower ? rows : (std::min)(actual_k2,rows);
+        for(Index i2=start; i2<end; i2+=mc)
+        {
+          const Index actual_mc = (std::min)(i2+mc,end)-i2;
+          gemm_pack_lhs<Scalar, Index, LhsMapper, Traits::mr,Traits::LhsProgress, LhsStorageOrder,false>()
+            (blockA, lhs.getSubMapper(i2, actual_k2), actual_kc, actual_mc);
+
+          gebp_kernel(res.getSubMapper(i2, 0), blockA, blockB, actual_mc,
+                      actual_kc, cols, alpha, -1, -1, 0, 0);
+        }
+      }
+    }
+  }
+
+// implements col-major += alpha * op(general) * op(triangular)
+template <typename Scalar, typename Index, int Mode,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs, int Version>
+struct product_triangular_matrix_matrix<Scalar,Index,Mode,false,
+                                        LhsStorageOrder,ConjugateLhs,
+                                        RhsStorageOrder,ConjugateRhs,ColMajor,Version>
+{
+  typedef gebp_traits<Scalar,Scalar> Traits;
+  enum {
+    SmallPanelWidth   = EIGEN_PLAIN_ENUM_MAX(Traits::mr,Traits::nr),
+    IsLower = (Mode&Lower) == Lower,
+    SetDiag = (Mode&(ZeroDiag|UnitDiag)) ? 0 : 1
+  };
+
+  static EIGEN_DONT_INLINE void run(
+    Index _rows, Index _cols, Index _depth,
+    const Scalar* _lhs, Index lhsStride,
+    const Scalar* _rhs, Index rhsStride,
+    Scalar* res,        Index resStride,
+    const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking);
+};
+
+template <typename Scalar, typename Index, int Mode,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs, int Version>
+EIGEN_DONT_INLINE void product_triangular_matrix_matrix<Scalar,Index,Mode,false,
+                                                        LhsStorageOrder,ConjugateLhs,
+                                                        RhsStorageOrder,ConjugateRhs,ColMajor,Version>::run(
+    Index _rows, Index _cols, Index _depth,
+    const Scalar* _lhs, Index lhsStride,
+    const Scalar* _rhs, Index rhsStride,
+    Scalar* _res,        Index resStride,
+    const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking)
+  {
+    const Index PacketBytes = packet_traits<Scalar>::size*sizeof(Scalar);
+    // strip zeros
+    Index diagSize  = (std::min)(_cols,_depth);
+    Index rows      = _rows;
+    Index depth     = IsLower ? _depth : diagSize;
+    Index cols      = IsLower ? diagSize : _cols;
+    
+    typedef const_blas_data_mapper<Scalar, Index, LhsStorageOrder> LhsMapper;
+    typedef const_blas_data_mapper<Scalar, Index, RhsStorageOrder> RhsMapper;
+    typedef blas_data_mapper<typename Traits::ResScalar, Index, ColMajor> ResMapper;
+    LhsMapper lhs(_lhs,lhsStride);
+    RhsMapper rhs(_rhs,rhsStride);
+    ResMapper res(_res, resStride);
+
+    Index kc = blocking.kc();                   // cache block size along the K direction
+    Index mc = (std::min)(rows,blocking.mc());  // cache block size along the M direction
+
+    std::size_t sizeA = kc*mc;
+    std::size_t sizeB = kc*cols+EIGEN_MAX_ALIGN_BYTES/sizeof(Scalar);
+
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA());
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB());
+
+    internal::constructor_without_unaligned_array_assert a;
+    Matrix<Scalar,SmallPanelWidth,SmallPanelWidth,RhsStorageOrder> triangularBuffer(a);
+    triangularBuffer.setZero();
+    if((Mode&ZeroDiag)==ZeroDiag)
+      triangularBuffer.diagonal().setZero();
+    else
+      triangularBuffer.diagonal().setOnes();
+
+    gebp_kernel<Scalar, Scalar, Index, ResMapper, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp_kernel;
+    gemm_pack_lhs<Scalar, Index, LhsMapper, Traits::mr, Traits::LhsProgress, LhsStorageOrder> pack_lhs;
+    gemm_pack_rhs<Scalar, Index, RhsMapper, Traits::nr,RhsStorageOrder> pack_rhs;
+    gemm_pack_rhs<Scalar, Index, RhsMapper, Traits::nr,RhsStorageOrder,false,true> pack_rhs_panel;
+
+    for(Index k2=IsLower ? 0 : depth;
+        IsLower ? k2<depth  : k2>0;
+        IsLower ? k2+=kc   : k2-=kc)
+    {
+      Index actual_kc = (std::min)(IsLower ? depth-k2 : k2, kc);
+      Index actual_k2 = IsLower ? k2 : k2-actual_kc;
+
+      // align blocks with the end of the triangular part for trapezoidal rhs
+      if(IsLower && (k2<cols) && (actual_k2+actual_kc>cols))
+      {
+        actual_kc = cols-k2;
+        k2 = actual_k2 + actual_kc - kc;
+      }
+
+      // remaining size
+      Index rs = IsLower ? (std::min)(cols,actual_k2) : cols - k2;
+      // size of the triangular part
+      Index ts = (IsLower && actual_k2>=cols) ? 0 : actual_kc;
+
+      Scalar* geb = blockB+ts*ts;
+      geb = geb + internal::first_aligned<PacketBytes>(geb,PacketBytes/sizeof(Scalar));
+
+      pack_rhs(geb, rhs.getSubMapper(actual_k2,IsLower ? 0 : k2), actual_kc, rs);
+
+      // pack the triangular part of the rhs padding the unrolled blocks with zeros
+      if(ts>0)
+      {
+        for (Index j2=0; j2<actual_kc; j2+=SmallPanelWidth)
+        {
+          Index actualPanelWidth = std::min<Index>(actual_kc-j2, SmallPanelWidth);
+          Index actual_j2 = actual_k2 + j2;
+          Index panelOffset = IsLower ? j2+actualPanelWidth : 0;
+          Index panelLength = IsLower ? actual_kc-j2-actualPanelWidth : j2;
+          // general part
+          pack_rhs_panel(blockB+j2*actual_kc,
+                         rhs.getSubMapper(actual_k2+panelOffset, actual_j2),
+                         panelLength, actualPanelWidth,
+                         actual_kc, panelOffset);
+
+          // append the triangular part via a temporary buffer
+          for (Index j=0;j<actualPanelWidth;++j)
+          {
+            if (SetDiag)
+              triangularBuffer.coeffRef(j,j) = rhs(actual_j2+j,actual_j2+j);
+            for (Index k=IsLower ? j+1 : 0; IsLower ? k<actualPanelWidth : k<j; ++k)
+              triangularBuffer.coeffRef(k,j) = rhs(actual_j2+k,actual_j2+j);
+          }
+
+          pack_rhs_panel(blockB+j2*actual_kc,
+                         RhsMapper(triangularBuffer.data(), triangularBuffer.outerStride()),
+                         actualPanelWidth, actualPanelWidth,
+                         actual_kc, j2);
+        }
+      }
+
+      for (Index i2=0; i2<rows; i2+=mc)
+      {
+        const Index actual_mc = (std::min)(mc,rows-i2);
+        pack_lhs(blockA, lhs.getSubMapper(i2, actual_k2), actual_kc, actual_mc);
+
+        // triangular kernel
+        if(ts>0)
+        {
+          for (Index j2=0; j2<actual_kc; j2+=SmallPanelWidth)
+          {
+            Index actualPanelWidth = std::min<Index>(actual_kc-j2, SmallPanelWidth);
+            Index panelLength = IsLower ? actual_kc-j2 : j2+actualPanelWidth;
+            Index blockOffset = IsLower ? j2 : 0;
+
+            gebp_kernel(res.getSubMapper(i2, actual_k2 + j2),
+                        blockA, blockB+j2*actual_kc,
+                        actual_mc, panelLength, actualPanelWidth,
+                        alpha,
+                        actual_kc, actual_kc,  // strides
+                        blockOffset, blockOffset);// offsets
+          }
+        }
+        gebp_kernel(res.getSubMapper(i2, IsLower ? 0 : k2),
+                    blockA, geb, actual_mc, actual_kc, rs,
+                    alpha,
+                    -1, -1, 0, 0);
+      }
+    }
+  }
+
+/***************************************************************************
+* Wrapper to product_triangular_matrix_matrix
+***************************************************************************/
+
+} // end namespace internal
+
+namespace internal {
+template<int Mode, bool LhsIsTriangular, typename Lhs, typename Rhs>
+struct triangular_product_impl<Mode,LhsIsTriangular,Lhs,false,Rhs,false>
+{
+  template<typename Dest> static void run(Dest& dst, const Lhs &a_lhs, const Rhs &a_rhs, const typename Dest::Scalar& alpha)
+  {
+    typedef typename Dest::Scalar     Scalar;
+    
+    typedef internal::blas_traits<Lhs> LhsBlasTraits;
+    typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
+    typedef typename internal::remove_all<ActualLhsType>::type ActualLhsTypeCleaned;
+    typedef internal::blas_traits<Rhs> RhsBlasTraits;
+    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
+    typedef typename internal::remove_all<ActualRhsType>::type ActualRhsTypeCleaned;
+    
+    typename internal::add_const_on_value_type<ActualLhsType>::type lhs = LhsBlasTraits::extract(a_lhs);
+    typename internal::add_const_on_value_type<ActualRhsType>::type rhs = RhsBlasTraits::extract(a_rhs);
+
+    Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(a_lhs)
+                               * RhsBlasTraits::extractScalarFactor(a_rhs);
+
+    typedef internal::gemm_blocking_space<(Dest::Flags&RowMajorBit) ? RowMajor : ColMajor,Scalar,Scalar,
+              Lhs::MaxRowsAtCompileTime, Rhs::MaxColsAtCompileTime, Lhs::MaxColsAtCompileTime,4> BlockingType;
+
+    enum { IsLower = (Mode&Lower) == Lower };
+    Index stripedRows  = ((!LhsIsTriangular) || (IsLower))  ? lhs.rows() : (std::min)(lhs.rows(),lhs.cols());
+    Index stripedCols  = ((LhsIsTriangular)  || (!IsLower)) ? rhs.cols() : (std::min)(rhs.cols(),rhs.rows());
+    Index stripedDepth = LhsIsTriangular ? ((!IsLower) ? lhs.cols() : (std::min)(lhs.cols(),lhs.rows()))
+                                         : ((IsLower)  ? rhs.rows() : (std::min)(rhs.rows(),rhs.cols()));
+
+    BlockingType blocking(stripedRows, stripedCols, stripedDepth, 1, false);
+
+    internal::product_triangular_matrix_matrix<Scalar, Index,
+      Mode, LhsIsTriangular,
+      (internal::traits<ActualLhsTypeCleaned>::Flags&RowMajorBit) ? RowMajor : ColMajor, LhsBlasTraits::NeedToConjugate,
+      (internal::traits<ActualRhsTypeCleaned>::Flags&RowMajorBit) ? RowMajor : ColMajor, RhsBlasTraits::NeedToConjugate,
+      (internal::traits<Dest          >::Flags&RowMajorBit) ? RowMajor : ColMajor>
+      ::run(
+        stripedRows, stripedCols, stripedDepth,   // sizes
+        &lhs.coeffRef(0,0), lhs.outerStride(),    // lhs info
+        &rhs.coeffRef(0,0), rhs.outerStride(),    // rhs info
+        &dst.coeffRef(0,0), dst.outerStride(),    // result info
+        actualAlpha, blocking
+      );
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRIANGULAR_MATRIX_MATRIX_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
new file mode 100644
index 00000000..a25197ab
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
@@ -0,0 +1,315 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to BLAS F77
+ *   Triangular matrix * matrix product functionality based on ?TRMM.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_TRIANGULAR_MATRIX_MATRIX_BLAS_H
+#define EIGEN_TRIANGULAR_MATRIX_MATRIX_BLAS_H
+
+namespace Eigen { 
+
+namespace internal {
+
+
+template <typename Scalar, typename Index,
+          int Mode, bool LhsIsTriangular,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs,
+          int ResStorageOrder>
+struct product_triangular_matrix_matrix_trmm :
+       product_triangular_matrix_matrix<Scalar,Index,Mode,
+          LhsIsTriangular,LhsStorageOrder,ConjugateLhs,
+          RhsStorageOrder, ConjugateRhs, ResStorageOrder, BuiltIn> {};
+
+
+// try to go to BLAS specialization
+#define EIGEN_BLAS_TRMM_SPECIALIZE(Scalar, LhsIsTriangular) \
+template <typename Index, int Mode, \
+          int LhsStorageOrder, bool ConjugateLhs, \
+          int RhsStorageOrder, bool ConjugateRhs> \
+struct product_triangular_matrix_matrix<Scalar,Index, Mode, LhsIsTriangular, \
+           LhsStorageOrder,ConjugateLhs, RhsStorageOrder,ConjugateRhs,ColMajor,Specialized> { \
+  static inline void run(Index _rows, Index _cols, Index _depth, const Scalar* _lhs, Index lhsStride,\
+    const Scalar* _rhs, Index rhsStride, Scalar* res, Index resStride, Scalar alpha, level3_blocking<Scalar,Scalar>& blocking) { \
+      product_triangular_matrix_matrix_trmm<Scalar,Index,Mode, \
+        LhsIsTriangular,LhsStorageOrder,ConjugateLhs, \
+        RhsStorageOrder, ConjugateRhs, ColMajor>::run( \
+        _rows, _cols, _depth, _lhs, lhsStride, _rhs, rhsStride, res, resStride, alpha, blocking); \
+  } \
+};
+
+EIGEN_BLAS_TRMM_SPECIALIZE(double, true)
+EIGEN_BLAS_TRMM_SPECIALIZE(double, false)
+EIGEN_BLAS_TRMM_SPECIALIZE(dcomplex, true)
+EIGEN_BLAS_TRMM_SPECIALIZE(dcomplex, false)
+EIGEN_BLAS_TRMM_SPECIALIZE(float, true)
+EIGEN_BLAS_TRMM_SPECIALIZE(float, false)
+EIGEN_BLAS_TRMM_SPECIALIZE(scomplex, true)
+EIGEN_BLAS_TRMM_SPECIALIZE(scomplex, false)
+
+// implements col-major += alpha * op(triangular) * op(general)
+#define EIGEN_BLAS_TRMM_L(EIGTYPE, BLASTYPE, EIGPREFIX, BLASFUNC) \
+template <typename Index, int Mode, \
+          int LhsStorageOrder, bool ConjugateLhs, \
+          int RhsStorageOrder, bool ConjugateRhs> \
+struct product_triangular_matrix_matrix_trmm<EIGTYPE,Index,Mode,true, \
+         LhsStorageOrder,ConjugateLhs,RhsStorageOrder,ConjugateRhs,ColMajor> \
+{ \
+  enum { \
+    IsLower = (Mode&Lower) == Lower, \
+    SetDiag = (Mode&(ZeroDiag|UnitDiag)) ? 0 : 1, \
+    IsUnitDiag  = (Mode&UnitDiag) ? 1 : 0, \
+    IsZeroDiag  = (Mode&ZeroDiag) ? 1 : 0, \
+    LowUp = IsLower ? Lower : Upper, \
+    conjA = ((LhsStorageOrder==ColMajor) && ConjugateLhs) ? 1 : 0 \
+  }; \
+\
+  static void run( \
+    Index _rows, Index _cols, Index _depth, \
+    const EIGTYPE* _lhs, Index lhsStride, \
+    const EIGTYPE* _rhs, Index rhsStride, \
+    EIGTYPE* res,        Index resStride, \
+    EIGTYPE alpha, level3_blocking<EIGTYPE,EIGTYPE>& blocking) \
+  { \
+   Index diagSize  = (std::min)(_rows,_depth); \
+   Index rows      = IsLower ? _rows : diagSize; \
+   Index depth     = IsLower ? diagSize : _depth; \
+   Index cols      = _cols; \
+\
+   typedef Matrix<EIGTYPE, Dynamic, Dynamic, LhsStorageOrder> MatrixLhs; \
+   typedef Matrix<EIGTYPE, Dynamic, Dynamic, RhsStorageOrder> MatrixRhs; \
+\
+/* Non-square case - doesn't fit to BLAS ?TRMM. Fall to default triangular product or call BLAS ?GEMM*/ \
+   if (rows != depth) { \
+\
+     /* FIXME handle mkl_domain_get_max_threads */ \
+     /*int nthr = mkl_domain_get_max_threads(EIGEN_BLAS_DOMAIN_BLAS);*/ int nthr = 1;\
+\
+     if (((nthr==1) && (((std::max)(rows,depth)-diagSize)/(double)diagSize < 0.5))) { \
+     /* Most likely no benefit to call TRMM or GEMM from BLAS */ \
+       product_triangular_matrix_matrix<EIGTYPE,Index,Mode,true, \
+       LhsStorageOrder,ConjugateLhs, RhsStorageOrder, ConjugateRhs, ColMajor, BuiltIn>::run( \
+           _rows, _cols, _depth, _lhs, lhsStride, _rhs, rhsStride, res, resStride, alpha, blocking); \
+     /*std::cout << "TRMM_L: A is not square! Go to Eigen TRMM implementation!\n";*/ \
+     } else { \
+     /* Make sense to call GEMM */ \
+       Map<const MatrixLhs, 0, OuterStride<> > lhsMap(_lhs,rows,depth,OuterStride<>(lhsStride)); \
+       MatrixLhs aa_tmp=lhsMap.template triangularView<Mode>(); \
+       BlasIndex aStride = convert_index<BlasIndex>(aa_tmp.outerStride()); \
+       gemm_blocking_space<ColMajor,EIGTYPE,EIGTYPE,Dynamic,Dynamic,Dynamic> gemm_blocking(_rows,_cols,_depth, 1, true); \
+       general_matrix_matrix_product<Index,EIGTYPE,LhsStorageOrder,ConjugateLhs,EIGTYPE,RhsStorageOrder,ConjugateRhs,ColMajor>::run( \
+       rows, cols, depth, aa_tmp.data(), aStride, _rhs, rhsStride, res, resStride, alpha, gemm_blocking, 0); \
+\
+     /*std::cout << "TRMM_L: A is not square! Go to BLAS GEMM implementation! " << nthr<<" \n";*/ \
+     } \
+     return; \
+   } \
+   char side = 'L', transa, uplo, diag = 'N'; \
+   EIGTYPE *b; \
+   const EIGTYPE *a; \
+   BlasIndex m, n, lda, ldb; \
+\
+/* Set m, n */ \
+   m = convert_index<BlasIndex>(diagSize); \
+   n = convert_index<BlasIndex>(cols); \
+\
+/* Set trans */ \
+   transa = (LhsStorageOrder==RowMajor) ? ((ConjugateLhs) ? 'C' : 'T') : 'N'; \
+\
+/* Set b, ldb */ \
+   Map<const MatrixRhs, 0, OuterStride<> > rhs(_rhs,depth,cols,OuterStride<>(rhsStride)); \
+   MatrixX##EIGPREFIX b_tmp; \
+\
+   if (ConjugateRhs) b_tmp = rhs.conjugate(); else b_tmp = rhs; \
+   b = b_tmp.data(); \
+   ldb = convert_index<BlasIndex>(b_tmp.outerStride()); \
+\
+/* Set uplo */ \
+   uplo = IsLower ? 'L' : 'U'; \
+   if (LhsStorageOrder==RowMajor) uplo = (uplo == 'L') ? 'U' : 'L'; \
+/* Set a, lda */ \
+   Map<const MatrixLhs, 0, OuterStride<> > lhs(_lhs,rows,depth,OuterStride<>(lhsStride)); \
+   MatrixLhs a_tmp; \
+\
+   if ((conjA!=0) || (SetDiag==0)) { \
+     if (conjA) a_tmp = lhs.conjugate(); else a_tmp = lhs; \
+     if (IsZeroDiag) \
+       a_tmp.diagonal().setZero(); \
+     else if (IsUnitDiag) \
+       a_tmp.diagonal().setOnes();\
+     a = a_tmp.data(); \
+     lda = convert_index<BlasIndex>(a_tmp.outerStride()); \
+   } else { \
+     a = _lhs; \
+     lda = convert_index<BlasIndex>(lhsStride); \
+   } \
+   /*std::cout << "TRMM_L: A is square! Go to BLAS TRMM implementation! \n";*/ \
+/* call ?trmm*/ \
+   BLASFUNC(&side, &uplo, &transa, &diag, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (BLASTYPE*)b, &ldb); \
+\
+/* Add op(a_triangular)*b into res*/ \
+   Map<MatrixX##EIGPREFIX, 0, OuterStride<> > res_tmp(res,rows,cols,OuterStride<>(resStride)); \
+   res_tmp=res_tmp+b_tmp; \
+  } \
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_TRMM_L(double, double, d, dtrmm)
+EIGEN_BLAS_TRMM_L(dcomplex, MKL_Complex16, cd, ztrmm)
+EIGEN_BLAS_TRMM_L(float, float, f, strmm)
+EIGEN_BLAS_TRMM_L(scomplex, MKL_Complex8, cf, ctrmm)
+#else
+EIGEN_BLAS_TRMM_L(double, double, d, dtrmm_)
+EIGEN_BLAS_TRMM_L(dcomplex, double, cd, ztrmm_)
+EIGEN_BLAS_TRMM_L(float, float, f, strmm_)
+EIGEN_BLAS_TRMM_L(scomplex, float, cf, ctrmm_)
+#endif
+
+// implements col-major += alpha * op(general) * op(triangular)
+#define EIGEN_BLAS_TRMM_R(EIGTYPE, BLASTYPE, EIGPREFIX, BLASFUNC) \
+template <typename Index, int Mode, \
+          int LhsStorageOrder, bool ConjugateLhs, \
+          int RhsStorageOrder, bool ConjugateRhs> \
+struct product_triangular_matrix_matrix_trmm<EIGTYPE,Index,Mode,false, \
+         LhsStorageOrder,ConjugateLhs,RhsStorageOrder,ConjugateRhs,ColMajor> \
+{ \
+  enum { \
+    IsLower = (Mode&Lower) == Lower, \
+    SetDiag = (Mode&(ZeroDiag|UnitDiag)) ? 0 : 1, \
+    IsUnitDiag  = (Mode&UnitDiag) ? 1 : 0, \
+    IsZeroDiag  = (Mode&ZeroDiag) ? 1 : 0, \
+    LowUp = IsLower ? Lower : Upper, \
+    conjA = ((RhsStorageOrder==ColMajor) && ConjugateRhs) ? 1 : 0 \
+  }; \
+\
+  static void run( \
+    Index _rows, Index _cols, Index _depth, \
+    const EIGTYPE* _lhs, Index lhsStride, \
+    const EIGTYPE* _rhs, Index rhsStride, \
+    EIGTYPE* res,        Index resStride, \
+    EIGTYPE alpha, level3_blocking<EIGTYPE,EIGTYPE>& blocking) \
+  { \
+   Index diagSize  = (std::min)(_cols,_depth); \
+   Index rows      = _rows; \
+   Index depth     = IsLower ? _depth : diagSize; \
+   Index cols      = IsLower ? diagSize : _cols; \
+\
+   typedef Matrix<EIGTYPE, Dynamic, Dynamic, LhsStorageOrder> MatrixLhs; \
+   typedef Matrix<EIGTYPE, Dynamic, Dynamic, RhsStorageOrder> MatrixRhs; \
+\
+/* Non-square case - doesn't fit to BLAS ?TRMM. Fall to default triangular product or call BLAS ?GEMM*/ \
+   if (cols != depth) { \
+\
+     int nthr = 1 /*mkl_domain_get_max_threads(EIGEN_BLAS_DOMAIN_BLAS)*/; \
+\
+     if ((nthr==1) && (((std::max)(cols,depth)-diagSize)/(double)diagSize < 0.5)) { \
+     /* Most likely no benefit to call TRMM or GEMM from BLAS*/ \
+       product_triangular_matrix_matrix<EIGTYPE,Index,Mode,false, \
+       LhsStorageOrder,ConjugateLhs, RhsStorageOrder, ConjugateRhs, ColMajor, BuiltIn>::run( \
+           _rows, _cols, _depth, _lhs, lhsStride, _rhs, rhsStride, res, resStride, alpha, blocking); \
+       /*std::cout << "TRMM_R: A is not square! Go to Eigen TRMM implementation!\n";*/ \
+     } else { \
+     /* Make sense to call GEMM */ \
+       Map<const MatrixRhs, 0, OuterStride<> > rhsMap(_rhs,depth,cols, OuterStride<>(rhsStride)); \
+       MatrixRhs aa_tmp=rhsMap.template triangularView<Mode>(); \
+       BlasIndex aStride = convert_index<BlasIndex>(aa_tmp.outerStride()); \
+       gemm_blocking_space<ColMajor,EIGTYPE,EIGTYPE,Dynamic,Dynamic,Dynamic> gemm_blocking(_rows,_cols,_depth, 1, true); \
+       general_matrix_matrix_product<Index,EIGTYPE,LhsStorageOrder,ConjugateLhs,EIGTYPE,RhsStorageOrder,ConjugateRhs,ColMajor>::run( \
+       rows, cols, depth, _lhs, lhsStride, aa_tmp.data(), aStride, res, resStride, alpha, gemm_blocking, 0); \
+\
+     /*std::cout << "TRMM_R: A is not square! Go to BLAS GEMM implementation! " << nthr<<" \n";*/ \
+     } \
+     return; \
+   } \
+   char side = 'R', transa, uplo, diag = 'N'; \
+   EIGTYPE *b; \
+   const EIGTYPE *a; \
+   BlasIndex m, n, lda, ldb; \
+\
+/* Set m, n */ \
+   m = convert_index<BlasIndex>(rows); \
+   n = convert_index<BlasIndex>(diagSize); \
+\
+/* Set trans */ \
+   transa = (RhsStorageOrder==RowMajor) ? ((ConjugateRhs) ? 'C' : 'T') : 'N'; \
+\
+/* Set b, ldb */ \
+   Map<const MatrixLhs, 0, OuterStride<> > lhs(_lhs,rows,depth,OuterStride<>(lhsStride)); \
+   MatrixX##EIGPREFIX b_tmp; \
+\
+   if (ConjugateLhs) b_tmp = lhs.conjugate(); else b_tmp = lhs; \
+   b = b_tmp.data(); \
+   ldb = convert_index<BlasIndex>(b_tmp.outerStride()); \
+\
+/* Set uplo */ \
+   uplo = IsLower ? 'L' : 'U'; \
+   if (RhsStorageOrder==RowMajor) uplo = (uplo == 'L') ? 'U' : 'L'; \
+/* Set a, lda */ \
+   Map<const MatrixRhs, 0, OuterStride<> > rhs(_rhs,depth,cols, OuterStride<>(rhsStride)); \
+   MatrixRhs a_tmp; \
+\
+   if ((conjA!=0) || (SetDiag==0)) { \
+     if (conjA) a_tmp = rhs.conjugate(); else a_tmp = rhs; \
+     if (IsZeroDiag) \
+       a_tmp.diagonal().setZero(); \
+     else if (IsUnitDiag) \
+       a_tmp.diagonal().setOnes();\
+     a = a_tmp.data(); \
+     lda = convert_index<BlasIndex>(a_tmp.outerStride()); \
+   } else { \
+     a = _rhs; \
+     lda = convert_index<BlasIndex>(rhsStride); \
+   } \
+   /*std::cout << "TRMM_R: A is square! Go to BLAS TRMM implementation! \n";*/ \
+/* call ?trmm*/ \
+   BLASFUNC(&side, &uplo, &transa, &diag, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (BLASTYPE*)b, &ldb); \
+\
+/* Add op(a_triangular)*b into res*/ \
+   Map<MatrixX##EIGPREFIX, 0, OuterStride<> > res_tmp(res,rows,cols,OuterStride<>(resStride)); \
+   res_tmp=res_tmp+b_tmp; \
+  } \
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_TRMM_R(double, double, d, dtrmm)
+EIGEN_BLAS_TRMM_R(dcomplex, MKL_Complex16, cd, ztrmm)
+EIGEN_BLAS_TRMM_R(float, float, f, strmm)
+EIGEN_BLAS_TRMM_R(scomplex, MKL_Complex8, cf, ctrmm)
+#else
+EIGEN_BLAS_TRMM_R(double, double, d, dtrmm_)
+EIGEN_BLAS_TRMM_R(dcomplex, double, cd, ztrmm_)
+EIGEN_BLAS_TRMM_R(float, float, f, strmm_)
+EIGEN_BLAS_TRMM_R(scomplex, float, cf, ctrmm_)
+#endif
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRIANGULAR_MATRIX_MATRIX_BLAS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/TriangularMatrixVector.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/TriangularMatrixVector.h
new file mode 100644
index 00000000..4b292e74
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -0,0 +1,336 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TRIANGULARMATRIXVECTOR_H
+#define EIGEN_TRIANGULARMATRIXVECTOR_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs, int StorageOrder, int Version=Specialized>
+struct triangular_matrix_vector_product;
+
+template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs, int Version>
+struct triangular_matrix_vector_product<Index,Mode,LhsScalar,ConjLhs,RhsScalar,ConjRhs,ColMajor,Version>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+  enum {
+    IsLower = ((Mode&Lower)==Lower),
+    HasUnitDiag = (Mode & UnitDiag)==UnitDiag,
+    HasZeroDiag = (Mode & ZeroDiag)==ZeroDiag
+  };
+  static EIGEN_DONT_INLINE  void run(Index _rows, Index _cols, const LhsScalar* _lhs, Index lhsStride,
+                                     const RhsScalar* _rhs, Index rhsIncr, ResScalar* _res, Index resIncr, const RhsScalar& alpha);
+};
+
+template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs, int Version>
+EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index,Mode,LhsScalar,ConjLhs,RhsScalar,ConjRhs,ColMajor,Version>
+  ::run(Index _rows, Index _cols, const LhsScalar* _lhs, Index lhsStride,
+        const RhsScalar* _rhs, Index rhsIncr, ResScalar* _res, Index resIncr, const RhsScalar& alpha)
+  {
+    static const Index PanelWidth = EIGEN_TUNE_TRIANGULAR_PANEL_WIDTH;
+    Index size = (std::min)(_rows,_cols);
+    Index rows = IsLower ? _rows : (std::min)(_rows,_cols);
+    Index cols = IsLower ? (std::min)(_rows,_cols) : _cols;
+
+    typedef Map<const Matrix<LhsScalar,Dynamic,Dynamic,ColMajor>, 0, OuterStride<> > LhsMap;
+    const LhsMap lhs(_lhs,rows,cols,OuterStride<>(lhsStride));
+    typename conj_expr_if<ConjLhs,LhsMap>::type cjLhs(lhs);
+
+    typedef Map<const Matrix<RhsScalar,Dynamic,1>, 0, InnerStride<> > RhsMap;
+    const RhsMap rhs(_rhs,cols,InnerStride<>(rhsIncr));
+    typename conj_expr_if<ConjRhs,RhsMap>::type cjRhs(rhs);
+
+    typedef Map<Matrix<ResScalar,Dynamic,1> > ResMap;
+    ResMap res(_res,rows);
+
+    typedef const_blas_data_mapper<LhsScalar,Index,ColMajor> LhsMapper;
+    typedef const_blas_data_mapper<RhsScalar,Index,RowMajor> RhsMapper;
+
+    for (Index pi=0; pi<size; pi+=PanelWidth)
+    {
+      Index actualPanelWidth = (std::min)(PanelWidth, size-pi);
+      for (Index k=0; k<actualPanelWidth; ++k)
+      {
+        Index i = pi + k;
+        Index s = IsLower ? ((HasUnitDiag||HasZeroDiag) ? i+1 : i ) : pi;
+        Index r = IsLower ? actualPanelWidth-k : k+1;
+        if ((!(HasUnitDiag||HasZeroDiag)) || (--r)>0)
+          res.segment(s,r) += (alpha * cjRhs.coeff(i)) * cjLhs.col(i).segment(s,r);
+        if (HasUnitDiag)
+          res.coeffRef(i) += alpha * cjRhs.coeff(i);
+      }
+      Index r = IsLower ? rows - pi - actualPanelWidth : pi;
+      if (r>0)
+      {
+        Index s = IsLower ? pi+actualPanelWidth : 0;
+        general_matrix_vector_product<Index,LhsScalar,LhsMapper,ColMajor,ConjLhs,RhsScalar,RhsMapper,ConjRhs,BuiltIn>::run(
+            r, actualPanelWidth,
+            LhsMapper(&lhs.coeffRef(s,pi), lhsStride),
+            RhsMapper(&rhs.coeffRef(pi), rhsIncr),
+            &res.coeffRef(s), resIncr, alpha);
+      }
+    }
+    if((!IsLower) && cols>size)
+    {
+      general_matrix_vector_product<Index,LhsScalar,LhsMapper,ColMajor,ConjLhs,RhsScalar,RhsMapper,ConjRhs>::run(
+          rows, cols-size,
+          LhsMapper(&lhs.coeffRef(0,size), lhsStride),
+          RhsMapper(&rhs.coeffRef(size), rhsIncr),
+          _res, resIncr, alpha);
+    }
+  }
+
+template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs,int Version>
+struct triangular_matrix_vector_product<Index,Mode,LhsScalar,ConjLhs,RhsScalar,ConjRhs,RowMajor,Version>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+  enum {
+    IsLower = ((Mode&Lower)==Lower),
+    HasUnitDiag = (Mode & UnitDiag)==UnitDiag,
+    HasZeroDiag = (Mode & ZeroDiag)==ZeroDiag
+  };
+  static EIGEN_DONT_INLINE void run(Index _rows, Index _cols, const LhsScalar* _lhs, Index lhsStride,
+                                    const RhsScalar* _rhs, Index rhsIncr, ResScalar* _res, Index resIncr, const ResScalar& alpha);
+};
+
+template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs,int Version>
+EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index,Mode,LhsScalar,ConjLhs,RhsScalar,ConjRhs,RowMajor,Version>
+  ::run(Index _rows, Index _cols, const LhsScalar* _lhs, Index lhsStride,
+        const RhsScalar* _rhs, Index rhsIncr, ResScalar* _res, Index resIncr, const ResScalar& alpha)
+  {
+    static const Index PanelWidth = EIGEN_TUNE_TRIANGULAR_PANEL_WIDTH;
+    Index diagSize = (std::min)(_rows,_cols);
+    Index rows = IsLower ? _rows : diagSize;
+    Index cols = IsLower ? diagSize : _cols;
+
+    typedef Map<const Matrix<LhsScalar,Dynamic,Dynamic,RowMajor>, 0, OuterStride<> > LhsMap;
+    const LhsMap lhs(_lhs,rows,cols,OuterStride<>(lhsStride));
+    typename conj_expr_if<ConjLhs,LhsMap>::type cjLhs(lhs);
+
+    typedef Map<const Matrix<RhsScalar,Dynamic,1> > RhsMap;
+    const RhsMap rhs(_rhs,cols);
+    typename conj_expr_if<ConjRhs,RhsMap>::type cjRhs(rhs);
+
+    typedef Map<Matrix<ResScalar,Dynamic,1>, 0, InnerStride<> > ResMap;
+    ResMap res(_res,rows,InnerStride<>(resIncr));
+
+    typedef const_blas_data_mapper<LhsScalar,Index,RowMajor> LhsMapper;
+    typedef const_blas_data_mapper<RhsScalar,Index,RowMajor> RhsMapper;
+
+    for (Index pi=0; pi<diagSize; pi+=PanelWidth)
+    {
+      Index actualPanelWidth = (std::min)(PanelWidth, diagSize-pi);
+      for (Index k=0; k<actualPanelWidth; ++k)
+      {
+        Index i = pi + k;
+        Index s = IsLower ? pi  : ((HasUnitDiag||HasZeroDiag) ? i+1 : i);
+        Index r = IsLower ? k+1 : actualPanelWidth-k;
+        if ((!(HasUnitDiag||HasZeroDiag)) || (--r)>0)
+          res.coeffRef(i) += alpha * (cjLhs.row(i).segment(s,r).cwiseProduct(cjRhs.segment(s,r).transpose())).sum();
+        if (HasUnitDiag)
+          res.coeffRef(i) += alpha * cjRhs.coeff(i);
+      }
+      Index r = IsLower ? pi : cols - pi - actualPanelWidth;
+      if (r>0)
+      {
+        Index s = IsLower ? 0 : pi + actualPanelWidth;
+        general_matrix_vector_product<Index,LhsScalar,LhsMapper,RowMajor,ConjLhs,RhsScalar,RhsMapper,ConjRhs,BuiltIn>::run(
+            actualPanelWidth, r,
+            LhsMapper(&lhs.coeffRef(pi,s), lhsStride),
+            RhsMapper(&rhs.coeffRef(s), rhsIncr),
+            &res.coeffRef(pi), resIncr, alpha);
+      }
+    }
+    if(IsLower && rows>diagSize)
+    {
+      general_matrix_vector_product<Index,LhsScalar,LhsMapper,RowMajor,ConjLhs,RhsScalar,RhsMapper,ConjRhs>::run(
+            rows-diagSize, cols,
+            LhsMapper(&lhs.coeffRef(diagSize,0), lhsStride),
+            RhsMapper(&rhs.coeffRef(0), rhsIncr),
+            &res.coeffRef(diagSize), resIncr, alpha);
+    }
+  }
+
+/***************************************************************************
+* Wrapper to product_triangular_vector
+***************************************************************************/
+
+template<int Mode,int StorageOrder>
+struct trmv_selector;
+
+} // end namespace internal
+
+namespace internal {
+
+template<int Mode, typename Lhs, typename Rhs>
+struct triangular_product_impl<Mode,true,Lhs,false,Rhs,true>
+{
+  template<typename Dest> static void run(Dest& dst, const Lhs &lhs, const Rhs &rhs, const typename Dest::Scalar& alpha)
+  {
+    eigen_assert(dst.rows()==lhs.rows() && dst.cols()==rhs.cols());
+  
+    internal::trmv_selector<Mode,(int(internal::traits<Lhs>::Flags)&RowMajorBit) ? RowMajor : ColMajor>::run(lhs, rhs, dst, alpha);
+  }
+};
+
+template<int Mode, typename Lhs, typename Rhs>
+struct triangular_product_impl<Mode,false,Lhs,true,Rhs,false>
+{
+  template<typename Dest> static void run(Dest& dst, const Lhs &lhs, const Rhs &rhs, const typename Dest::Scalar& alpha)
+  {
+    eigen_assert(dst.rows()==lhs.rows() && dst.cols()==rhs.cols());
+
+    Transpose<Dest> dstT(dst);
+    internal::trmv_selector<(Mode & (UnitDiag|ZeroDiag)) | ((Mode & Lower) ? Upper : Lower),
+                            (int(internal::traits<Rhs>::Flags)&RowMajorBit) ? ColMajor : RowMajor>
+            ::run(rhs.transpose(),lhs.transpose(), dstT, alpha);
+  }
+};
+
+} // end namespace internal
+
+namespace internal {
+
+// TODO: find a way to factorize this piece of code with gemv_selector since the logic is exactly the same.
+  
+template<int Mode> struct trmv_selector<Mode,ColMajor>
+{
+  template<typename Lhs, typename Rhs, typename Dest>
+  static void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha)
+  {
+    typedef typename Lhs::Scalar      LhsScalar;
+    typedef typename Rhs::Scalar      RhsScalar;
+    typedef typename Dest::Scalar     ResScalar;
+    typedef typename Dest::RealScalar RealScalar;
+    
+    typedef internal::blas_traits<Lhs> LhsBlasTraits;
+    typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
+    typedef internal::blas_traits<Rhs> RhsBlasTraits;
+    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
+    
+    typedef Map<Matrix<ResScalar,Dynamic,1>, EIGEN_PLAIN_ENUM_MIN(AlignedMax,internal::packet_traits<ResScalar>::size)> MappedDest;
+
+    typename internal::add_const_on_value_type<ActualLhsType>::type actualLhs = LhsBlasTraits::extract(lhs);
+    typename internal::add_const_on_value_type<ActualRhsType>::type actualRhs = RhsBlasTraits::extract(rhs);
+
+    ResScalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(lhs)
+                                  * RhsBlasTraits::extractScalarFactor(rhs);
+
+    enum {
+      // FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
+      // on, the other hand it is good for the cache to pack the vector anyways...
+      EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime==1,
+      ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex),
+      MightCannotUseDest = (Dest::InnerStrideAtCompileTime!=1) || ComplexByReal
+    };
+
+    gemv_static_vector_if<ResScalar,Dest::SizeAtCompileTime,Dest::MaxSizeAtCompileTime,MightCannotUseDest> static_dest;
+
+    bool alphaIsCompatible = (!ComplexByReal) || (numext::imag(actualAlpha)==RealScalar(0));
+    bool evalToDest = EvalToDestAtCompileTime && alphaIsCompatible;
+
+    RhsScalar compatibleAlpha = get_factor<ResScalar,RhsScalar>::run(actualAlpha);
+
+    ei_declare_aligned_stack_constructed_variable(ResScalar,actualDestPtr,dest.size(),
+                                                  evalToDest ? dest.data() : static_dest.data());
+
+    if(!evalToDest)
+    {
+      #ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+      Index size = dest.size();
+      EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+      #endif
+      if(!alphaIsCompatible)
+      {
+        MappedDest(actualDestPtr, dest.size()).setZero();
+        compatibleAlpha = RhsScalar(1);
+      }
+      else
+        MappedDest(actualDestPtr, dest.size()) = dest;
+    }
+
+    internal::triangular_matrix_vector_product
+      <Index,Mode,
+       LhsScalar, LhsBlasTraits::NeedToConjugate,
+       RhsScalar, RhsBlasTraits::NeedToConjugate,
+       ColMajor>
+      ::run(actualLhs.rows(),actualLhs.cols(),
+            actualLhs.data(),actualLhs.outerStride(),
+            actualRhs.data(),actualRhs.innerStride(),
+            actualDestPtr,1,compatibleAlpha);
+
+    if (!evalToDest)
+    {
+      if(!alphaIsCompatible)
+        dest += actualAlpha * MappedDest(actualDestPtr, dest.size());
+      else
+        dest = MappedDest(actualDestPtr, dest.size());
+    }
+  }
+};
+
+template<int Mode> struct trmv_selector<Mode,RowMajor>
+{
+  template<typename Lhs, typename Rhs, typename Dest>
+  static void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha)
+  {
+    typedef typename Lhs::Scalar      LhsScalar;
+    typedef typename Rhs::Scalar      RhsScalar;
+    typedef typename Dest::Scalar     ResScalar;
+    
+    typedef internal::blas_traits<Lhs> LhsBlasTraits;
+    typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
+    typedef internal::blas_traits<Rhs> RhsBlasTraits;
+    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
+    typedef typename internal::remove_all<ActualRhsType>::type ActualRhsTypeCleaned;
+
+    typename add_const<ActualLhsType>::type actualLhs = LhsBlasTraits::extract(lhs);
+    typename add_const<ActualRhsType>::type actualRhs = RhsBlasTraits::extract(rhs);
+
+    ResScalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(lhs)
+                                  * RhsBlasTraits::extractScalarFactor(rhs);
+
+    enum {
+      DirectlyUseRhs = ActualRhsTypeCleaned::InnerStrideAtCompileTime==1
+    };
+
+    gemv_static_vector_if<RhsScalar,ActualRhsTypeCleaned::SizeAtCompileTime,ActualRhsTypeCleaned::MaxSizeAtCompileTime,!DirectlyUseRhs> static_rhs;
+
+    ei_declare_aligned_stack_constructed_variable(RhsScalar,actualRhsPtr,actualRhs.size(),
+        DirectlyUseRhs ? const_cast<RhsScalar*>(actualRhs.data()) : static_rhs.data());
+
+    if(!DirectlyUseRhs)
+    {
+      #ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+      Index size = actualRhs.size();
+      EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+      #endif
+      Map<typename ActualRhsTypeCleaned::PlainObject>(actualRhsPtr, actualRhs.size()) = actualRhs;
+    }
+
+    internal::triangular_matrix_vector_product
+      <Index,Mode,
+       LhsScalar, LhsBlasTraits::NeedToConjugate,
+       RhsScalar, RhsBlasTraits::NeedToConjugate,
+       RowMajor>
+      ::run(actualLhs.rows(),actualLhs.cols(),
+            actualLhs.data(),actualLhs.outerStride(),
+            actualRhsPtr,1,
+            dest.data(),dest.innerStride(),
+            actualAlpha);
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRIANGULARMATRIXVECTOR_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
new file mode 100644
index 00000000..3d47a2b9
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
@@ -0,0 +1,255 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to BLAS F77
+ *   Triangular matrix-vector product functionality based on ?TRMV.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_TRIANGULAR_MATRIX_VECTOR_BLAS_H
+#define EIGEN_TRIANGULAR_MATRIX_VECTOR_BLAS_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/**********************************************************************
+* This file implements triangular matrix-vector multiplication using BLAS
+**********************************************************************/
+
+// trmv/hemv specialization
+
+template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs, int StorageOrder>
+struct triangular_matrix_vector_product_trmv :
+  triangular_matrix_vector_product<Index,Mode,LhsScalar,ConjLhs,RhsScalar,ConjRhs,StorageOrder,BuiltIn> {};
+
+#define EIGEN_BLAS_TRMV_SPECIALIZE(Scalar) \
+template<typename Index, int Mode, bool ConjLhs, bool ConjRhs> \
+struct triangular_matrix_vector_product<Index,Mode,Scalar,ConjLhs,Scalar,ConjRhs,ColMajor,Specialized> { \
+ static void run(Index _rows, Index _cols, const Scalar* _lhs, Index lhsStride, \
+                                     const Scalar* _rhs, Index rhsIncr, Scalar* _res, Index resIncr, Scalar alpha) { \
+      triangular_matrix_vector_product_trmv<Index,Mode,Scalar,ConjLhs,Scalar,ConjRhs,ColMajor>::run( \
+        _rows, _cols, _lhs, lhsStride, _rhs, rhsIncr, _res, resIncr, alpha); \
+  } \
+}; \
+template<typename Index, int Mode, bool ConjLhs, bool ConjRhs> \
+struct triangular_matrix_vector_product<Index,Mode,Scalar,ConjLhs,Scalar,ConjRhs,RowMajor,Specialized> { \
+ static void run(Index _rows, Index _cols, const Scalar* _lhs, Index lhsStride, \
+                                     const Scalar* _rhs, Index rhsIncr, Scalar* _res, Index resIncr, Scalar alpha) { \
+      triangular_matrix_vector_product_trmv<Index,Mode,Scalar,ConjLhs,Scalar,ConjRhs,RowMajor>::run( \
+        _rows, _cols, _lhs, lhsStride, _rhs, rhsIncr, _res, resIncr, alpha); \
+  } \
+};
+
+EIGEN_BLAS_TRMV_SPECIALIZE(double)
+EIGEN_BLAS_TRMV_SPECIALIZE(float)
+EIGEN_BLAS_TRMV_SPECIALIZE(dcomplex)
+EIGEN_BLAS_TRMV_SPECIALIZE(scomplex)
+
+// implements col-major: res += alpha * op(triangular) * vector
+#define EIGEN_BLAS_TRMV_CM(EIGTYPE, BLASTYPE, EIGPREFIX, BLASPREFIX, BLASPOSTFIX) \
+template<typename Index, int Mode, bool ConjLhs, bool ConjRhs> \
+struct triangular_matrix_vector_product_trmv<Index,Mode,EIGTYPE,ConjLhs,EIGTYPE,ConjRhs,ColMajor> { \
+  enum { \
+    IsLower = (Mode&Lower) == Lower, \
+    SetDiag = (Mode&(ZeroDiag|UnitDiag)) ? 0 : 1, \
+    IsUnitDiag  = (Mode&UnitDiag) ? 1 : 0, \
+    IsZeroDiag  = (Mode&ZeroDiag) ? 1 : 0, \
+    LowUp = IsLower ? Lower : Upper \
+  }; \
+ static void run(Index _rows, Index _cols, const EIGTYPE* _lhs, Index lhsStride, \
+                 const EIGTYPE* _rhs, Index rhsIncr, EIGTYPE* _res, Index resIncr, EIGTYPE alpha) \
+ { \
+   if (ConjLhs || IsZeroDiag) { \
+     triangular_matrix_vector_product<Index,Mode,EIGTYPE,ConjLhs,EIGTYPE,ConjRhs,ColMajor,BuiltIn>::run( \
+       _rows, _cols, _lhs, lhsStride, _rhs, rhsIncr, _res, resIncr, alpha); \
+     return; \
+   }\
+   Index size = (std::min)(_rows,_cols); \
+   Index rows = IsLower ? _rows : size; \
+   Index cols = IsLower ? size : _cols; \
+\
+   typedef VectorX##EIGPREFIX VectorRhs; \
+   EIGTYPE *x, *y;\
+\
+/* Set x*/ \
+   Map<const VectorRhs, 0, InnerStride<> > rhs(_rhs,cols,InnerStride<>(rhsIncr)); \
+   VectorRhs x_tmp; \
+   if (ConjRhs) x_tmp = rhs.conjugate(); else x_tmp = rhs; \
+   x = x_tmp.data(); \
+\
+/* Square part handling */\
+\
+   char trans, uplo, diag; \
+   BlasIndex m, n, lda, incx, incy; \
+   EIGTYPE const *a; \
+   EIGTYPE beta(1); \
+\
+/* Set m, n */ \
+   n = convert_index<BlasIndex>(size); \
+   lda = convert_index<BlasIndex>(lhsStride); \
+   incx = 1; \
+   incy = convert_index<BlasIndex>(resIncr); \
+\
+/* Set uplo, trans and diag*/ \
+   trans = 'N'; \
+   uplo = IsLower ? 'L' : 'U'; \
+   diag = IsUnitDiag ? 'U' : 'N'; \
+\
+/* call ?TRMV*/ \
+   BLASPREFIX##trmv##BLASPOSTFIX(&uplo, &trans, &diag, &n, (const BLASTYPE*)_lhs, &lda, (BLASTYPE*)x, &incx); \
+\
+/* Add op(a_tr)rhs into res*/ \
+   BLASPREFIX##axpy##BLASPOSTFIX(&n, (const BLASTYPE*)&numext::real_ref(alpha),(const BLASTYPE*)x, &incx, (BLASTYPE*)_res, &incy); \
+/* Non-square case - doesn't fit to BLAS ?TRMV. Fall to default triangular product*/ \
+   if (size<(std::max)(rows,cols)) { \
+     if (ConjRhs) x_tmp = rhs.conjugate(); else x_tmp = rhs; \
+     x = x_tmp.data(); \
+     if (size<rows) { \
+       y = _res + size*resIncr; \
+       a = _lhs + size; \
+       m = convert_index<BlasIndex>(rows-size); \
+       n = convert_index<BlasIndex>(size); \
+     } \
+     else { \
+       x += size; \
+       y = _res; \
+       a = _lhs + size*lda; \
+       m = convert_index<BlasIndex>(size); \
+       n = convert_index<BlasIndex>(cols-size); \
+     } \
+     BLASPREFIX##gemv##BLASPOSTFIX(&trans, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (const BLASTYPE*)x, &incx, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)y, &incy); \
+   } \
+  } \
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_TRMV_CM(double,   double, d,  d,)
+EIGEN_BLAS_TRMV_CM(dcomplex, MKL_Complex16, cd, z,)
+EIGEN_BLAS_TRMV_CM(float,    float,  f,  s,)
+EIGEN_BLAS_TRMV_CM(scomplex, MKL_Complex8,  cf, c,)
+#else
+EIGEN_BLAS_TRMV_CM(double,   double, d,  d, _)
+EIGEN_BLAS_TRMV_CM(dcomplex, double, cd, z, _)
+EIGEN_BLAS_TRMV_CM(float,    float,  f,  s, _)
+EIGEN_BLAS_TRMV_CM(scomplex, float,  cf, c, _)
+#endif
+
+// implements row-major: res += alpha * op(triangular) * vector
+#define EIGEN_BLAS_TRMV_RM(EIGTYPE, BLASTYPE, EIGPREFIX, BLASPREFIX, BLASPOSTFIX) \
+template<typename Index, int Mode, bool ConjLhs, bool ConjRhs> \
+struct triangular_matrix_vector_product_trmv<Index,Mode,EIGTYPE,ConjLhs,EIGTYPE,ConjRhs,RowMajor> { \
+  enum { \
+    IsLower = (Mode&Lower) == Lower, \
+    SetDiag = (Mode&(ZeroDiag|UnitDiag)) ? 0 : 1, \
+    IsUnitDiag  = (Mode&UnitDiag) ? 1 : 0, \
+    IsZeroDiag  = (Mode&ZeroDiag) ? 1 : 0, \
+    LowUp = IsLower ? Lower : Upper \
+  }; \
+ static void run(Index _rows, Index _cols, const EIGTYPE* _lhs, Index lhsStride, \
+                 const EIGTYPE* _rhs, Index rhsIncr, EIGTYPE* _res, Index resIncr, EIGTYPE alpha) \
+ { \
+   if (IsZeroDiag) { \
+     triangular_matrix_vector_product<Index,Mode,EIGTYPE,ConjLhs,EIGTYPE,ConjRhs,RowMajor,BuiltIn>::run( \
+       _rows, _cols, _lhs, lhsStride, _rhs, rhsIncr, _res, resIncr, alpha); \
+     return; \
+   }\
+   Index size = (std::min)(_rows,_cols); \
+   Index rows = IsLower ? _rows : size; \
+   Index cols = IsLower ? size : _cols; \
+\
+   typedef VectorX##EIGPREFIX VectorRhs; \
+   EIGTYPE *x, *y;\
+\
+/* Set x*/ \
+   Map<const VectorRhs, 0, InnerStride<> > rhs(_rhs,cols,InnerStride<>(rhsIncr)); \
+   VectorRhs x_tmp; \
+   if (ConjRhs) x_tmp = rhs.conjugate(); else x_tmp = rhs; \
+   x = x_tmp.data(); \
+\
+/* Square part handling */\
+\
+   char trans, uplo, diag; \
+   BlasIndex m, n, lda, incx, incy; \
+   EIGTYPE const *a; \
+   EIGTYPE beta(1); \
+\
+/* Set m, n */ \
+   n = convert_index<BlasIndex>(size); \
+   lda = convert_index<BlasIndex>(lhsStride); \
+   incx = 1; \
+   incy = convert_index<BlasIndex>(resIncr); \
+\
+/* Set uplo, trans and diag*/ \
+   trans = ConjLhs ? 'C' : 'T'; \
+   uplo = IsLower ? 'U' : 'L'; \
+   diag = IsUnitDiag ? 'U' : 'N'; \
+\
+/* call ?TRMV*/ \
+   BLASPREFIX##trmv##BLASPOSTFIX(&uplo, &trans, &diag, &n, (const BLASTYPE*)_lhs, &lda, (BLASTYPE*)x, &incx); \
+\
+/* Add op(a_tr)rhs into res*/ \
+   BLASPREFIX##axpy##BLASPOSTFIX(&n, (const BLASTYPE*)&numext::real_ref(alpha),(const BLASTYPE*)x, &incx, (BLASTYPE*)_res, &incy); \
+/* Non-square case - doesn't fit to BLAS ?TRMV. Fall to default triangular product*/ \
+   if (size<(std::max)(rows,cols)) { \
+     if (ConjRhs) x_tmp = rhs.conjugate(); else x_tmp = rhs; \
+     x = x_tmp.data(); \
+     if (size<rows) { \
+       y = _res + size*resIncr; \
+       a = _lhs + size*lda; \
+       m = convert_index<BlasIndex>(rows-size); \
+       n = convert_index<BlasIndex>(size); \
+     } \
+     else { \
+       x += size; \
+       y = _res; \
+       a = _lhs + size; \
+       m = convert_index<BlasIndex>(size); \
+       n = convert_index<BlasIndex>(cols-size); \
+     } \
+     BLASPREFIX##gemv##BLASPOSTFIX(&trans, &n, &m, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (const BLASTYPE*)x, &incx, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)y, &incy); \
+   } \
+  } \
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_TRMV_RM(double,   double, d,  d,)
+EIGEN_BLAS_TRMV_RM(dcomplex, MKL_Complex16, cd, z,)
+EIGEN_BLAS_TRMV_RM(float,    float,  f,  s,)
+EIGEN_BLAS_TRMV_RM(scomplex, MKL_Complex8,  cf, c,)
+#else
+EIGEN_BLAS_TRMV_RM(double,   double, d,  d,_)
+EIGEN_BLAS_TRMV_RM(dcomplex, double, cd, z,_)
+EIGEN_BLAS_TRMV_RM(float,    float,  f,  s,_)
+EIGEN_BLAS_TRMV_RM(scomplex, float,  cf, c,_)
+#endif
+
+} // end namespase internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRIANGULAR_MATRIX_VECTOR_BLAS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/TriangularSolverMatrix.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/TriangularSolverMatrix.h
new file mode 100644
index 00000000..223c38b8
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/TriangularSolverMatrix.h
@@ -0,0 +1,335 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TRIANGULAR_SOLVER_MATRIX_H
+#define EIGEN_TRIANGULAR_SOLVER_MATRIX_H
+
+namespace Eigen { 
+
+namespace internal {
+
+// if the rhs is row major, let's transpose the product
+template <typename Scalar, typename Index, int Side, int Mode, bool Conjugate, int TriStorageOrder>
+struct triangular_solve_matrix<Scalar,Index,Side,Mode,Conjugate,TriStorageOrder,RowMajor>
+{
+  static void run(
+    Index size, Index cols,
+    const Scalar*  tri, Index triStride,
+    Scalar* _other, Index otherStride,
+    level3_blocking<Scalar,Scalar>& blocking)
+  {
+    triangular_solve_matrix<
+      Scalar, Index, Side==OnTheLeft?OnTheRight:OnTheLeft,
+      (Mode&UnitDiag) | ((Mode&Upper) ? Lower : Upper),
+      NumTraits<Scalar>::IsComplex && Conjugate,
+      TriStorageOrder==RowMajor ? ColMajor : RowMajor, ColMajor>
+      ::run(size, cols, tri, triStride, _other, otherStride, blocking);
+  }
+};
+
+/* Optimized triangular solver with multiple right hand side and the triangular matrix on the left
+ */
+template <typename Scalar, typename Index, int Mode, bool Conjugate, int TriStorageOrder>
+struct triangular_solve_matrix<Scalar,Index,OnTheLeft,Mode,Conjugate,TriStorageOrder,ColMajor>
+{
+  static EIGEN_DONT_INLINE void run(
+    Index size, Index otherSize,
+    const Scalar* _tri, Index triStride,
+    Scalar* _other, Index otherStride,
+    level3_blocking<Scalar,Scalar>& blocking);
+};
+template <typename Scalar, typename Index, int Mode, bool Conjugate, int TriStorageOrder>
+EIGEN_DONT_INLINE void triangular_solve_matrix<Scalar,Index,OnTheLeft,Mode,Conjugate,TriStorageOrder,ColMajor>::run(
+    Index size, Index otherSize,
+    const Scalar* _tri, Index triStride,
+    Scalar* _other, Index otherStride,
+    level3_blocking<Scalar,Scalar>& blocking)
+  {
+    Index cols = otherSize;
+
+    typedef const_blas_data_mapper<Scalar, Index, TriStorageOrder> TriMapper;
+    typedef blas_data_mapper<Scalar, Index, ColMajor> OtherMapper;
+    TriMapper tri(_tri, triStride);
+    OtherMapper other(_other, otherStride);
+
+    typedef gebp_traits<Scalar,Scalar> Traits;
+
+    enum {
+      SmallPanelWidth   = EIGEN_PLAIN_ENUM_MAX(Traits::mr,Traits::nr),
+      IsLower = (Mode&Lower) == Lower
+    };
+
+    Index kc = blocking.kc();                   // cache block size along the K direction
+    Index mc = (std::min)(size,blocking.mc());  // cache block size along the M direction
+
+    std::size_t sizeA = kc*mc;
+    std::size_t sizeB = kc*cols;
+
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA());
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB());
+
+    conj_if<Conjugate> conj;
+    gebp_kernel<Scalar, Scalar, Index, OtherMapper, Traits::mr, Traits::nr, Conjugate, false> gebp_kernel;
+    gemm_pack_lhs<Scalar, Index, TriMapper, Traits::mr, Traits::LhsProgress, TriStorageOrder> pack_lhs;
+    gemm_pack_rhs<Scalar, Index, OtherMapper, Traits::nr, ColMajor, false, true> pack_rhs;
+
+    // the goal here is to subdivise the Rhs panels such that we keep some cache
+    // coherence when accessing the rhs elements
+    std::ptrdiff_t l1, l2, l3;
+    manage_caching_sizes(GetAction, &l1, &l2, &l3);
+    Index subcols = cols>0 ? l2/(4 * sizeof(Scalar) * std::max<Index>(otherStride,size)) : 0;
+    subcols = std::max<Index>((subcols/Traits::nr)*Traits::nr, Traits::nr);
+
+    for(Index k2=IsLower ? 0 : size;
+        IsLower ? k2<size : k2>0;
+        IsLower ? k2+=kc : k2-=kc)
+    {
+      const Index actual_kc = (std::min)(IsLower ? size-k2 : k2, kc);
+
+      // We have selected and packed a big horizontal panel R1 of rhs. Let B be the packed copy of this panel,
+      // and R2 the remaining part of rhs. The corresponding vertical panel of lhs is split into
+      // A11 (the triangular part) and A21 the remaining rectangular part.
+      // Then the high level algorithm is:
+      //  - B = R1                    => general block copy (done during the next step)
+      //  - R1 = A11^-1 B             => tricky part
+      //  - update B from the new R1  => actually this has to be performed continuously during the above step
+      //  - R2 -= A21 * B             => GEPP
+
+      // The tricky part: compute R1 = A11^-1 B while updating B from R1
+      // The idea is to split A11 into multiple small vertical panels.
+      // Each panel can be split into a small triangular part T1k which is processed without optimization,
+      // and the remaining small part T2k which is processed using gebp with appropriate block strides
+      for(Index j2=0; j2<cols; j2+=subcols)
+      {
+        Index actual_cols = (std::min)(cols-j2,subcols);
+        // for each small vertical panels [T1k^T, T2k^T]^T of lhs
+        for (Index k1=0; k1<actual_kc; k1+=SmallPanelWidth)
+        {
+          Index actualPanelWidth = std::min<Index>(actual_kc-k1, SmallPanelWidth);
+          // tr solve
+          for (Index k=0; k<actualPanelWidth; ++k)
+          {
+            // TODO write a small kernel handling this (can be shared with trsv)
+            Index i  = IsLower ? k2+k1+k : k2-k1-k-1;
+            Index rs = actualPanelWidth - k - 1; // remaining size
+            Index s  = TriStorageOrder==RowMajor ? (IsLower ? k2+k1 : i+1)
+                                                 :  IsLower ? i+1 : i-rs;
+
+            Scalar a = (Mode & UnitDiag) ? Scalar(1) : Scalar(1)/conj(tri(i,i));
+            for (Index j=j2; j<j2+actual_cols; ++j)
+            {
+              if (TriStorageOrder==RowMajor)
+              {
+                Scalar b(0);
+                const Scalar* l = &tri(i,s);
+                Scalar* r = &other(s,j);
+                for (Index i3=0; i3<k; ++i3)
+                  b += conj(l[i3]) * r[i3];
+
+                other(i,j) = (other(i,j) - b)*a;
+              }
+              else
+              {
+                Scalar b = (other(i,j) *= a);
+                Scalar* r = &other(s,j);
+                const Scalar* l = &tri(s,i);
+                for (Index i3=0;i3<rs;++i3)
+                  r[i3] -= b * conj(l[i3]);
+              }
+            }
+          }
+
+          Index lengthTarget = actual_kc-k1-actualPanelWidth;
+          Index startBlock   = IsLower ? k2+k1 : k2-k1-actualPanelWidth;
+          Index blockBOffset = IsLower ? k1 : lengthTarget;
+
+          // update the respective rows of B from other
+          pack_rhs(blockB+actual_kc*j2, other.getSubMapper(startBlock,j2), actualPanelWidth, actual_cols, actual_kc, blockBOffset);
+
+          // GEBP
+          if (lengthTarget>0)
+          {
+            Index startTarget  = IsLower ? k2+k1+actualPanelWidth : k2-actual_kc;
+
+            pack_lhs(blockA, tri.getSubMapper(startTarget,startBlock), actualPanelWidth, lengthTarget);
+
+            gebp_kernel(other.getSubMapper(startTarget,j2), blockA, blockB+actual_kc*j2, lengthTarget, actualPanelWidth, actual_cols, Scalar(-1),
+                        actualPanelWidth, actual_kc, 0, blockBOffset);
+          }
+        }
+      }
+      
+      // R2 -= A21 * B => GEPP
+      {
+        Index start = IsLower ? k2+kc : 0;
+        Index end   = IsLower ? size : k2-kc;
+        for(Index i2=start; i2<end; i2+=mc)
+        {
+          const Index actual_mc = (std::min)(mc,end-i2);
+          if (actual_mc>0)
+          {
+            pack_lhs(blockA, tri.getSubMapper(i2, IsLower ? k2 : k2-kc), actual_kc, actual_mc);
+
+            gebp_kernel(other.getSubMapper(i2, 0), blockA, blockB, actual_mc, actual_kc, cols, Scalar(-1), -1, -1, 0, 0);
+          }
+        }
+      }
+    }
+  }
+
+/* Optimized triangular solver with multiple left hand sides and the triangular matrix on the right
+ */
+template <typename Scalar, typename Index, int Mode, bool Conjugate, int TriStorageOrder>
+struct triangular_solve_matrix<Scalar,Index,OnTheRight,Mode,Conjugate,TriStorageOrder,ColMajor>
+{
+  static EIGEN_DONT_INLINE void run(
+    Index size, Index otherSize,
+    const Scalar* _tri, Index triStride,
+    Scalar* _other, Index otherStride,
+    level3_blocking<Scalar,Scalar>& blocking);
+};
+template <typename Scalar, typename Index, int Mode, bool Conjugate, int TriStorageOrder>
+EIGEN_DONT_INLINE void triangular_solve_matrix<Scalar,Index,OnTheRight,Mode,Conjugate,TriStorageOrder,ColMajor>::run(
+    Index size, Index otherSize,
+    const Scalar* _tri, Index triStride,
+    Scalar* _other, Index otherStride,
+    level3_blocking<Scalar,Scalar>& blocking)
+  {
+    Index rows = otherSize;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    typedef blas_data_mapper<Scalar, Index, ColMajor> LhsMapper;
+    typedef const_blas_data_mapper<Scalar, Index, TriStorageOrder> RhsMapper;
+    LhsMapper lhs(_other, otherStride);
+    RhsMapper rhs(_tri, triStride);
+
+    typedef gebp_traits<Scalar,Scalar> Traits;
+    enum {
+      RhsStorageOrder   = TriStorageOrder,
+      SmallPanelWidth   = EIGEN_PLAIN_ENUM_MAX(Traits::mr,Traits::nr),
+      IsLower = (Mode&Lower) == Lower
+    };
+
+    Index kc = blocking.kc();                   // cache block size along the K direction
+    Index mc = (std::min)(rows,blocking.mc());  // cache block size along the M direction
+
+    std::size_t sizeA = kc*mc;
+    std::size_t sizeB = kc*size;
+
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA());
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB());
+
+    conj_if<Conjugate> conj;
+    gebp_kernel<Scalar, Scalar, Index, LhsMapper, Traits::mr, Traits::nr, false, Conjugate> gebp_kernel;
+    gemm_pack_rhs<Scalar, Index, RhsMapper, Traits::nr, RhsStorageOrder> pack_rhs;
+    gemm_pack_rhs<Scalar, Index, RhsMapper, Traits::nr, RhsStorageOrder,false,true> pack_rhs_panel;
+    gemm_pack_lhs<Scalar, Index, LhsMapper, Traits::mr, Traits::LhsProgress, ColMajor, false, true> pack_lhs_panel;
+
+    for(Index k2=IsLower ? size : 0;
+        IsLower ? k2>0 : k2<size;
+        IsLower ? k2-=kc : k2+=kc)
+    {
+      const Index actual_kc = (std::min)(IsLower ? k2 : size-k2, kc);
+      Index actual_k2 = IsLower ? k2-actual_kc : k2 ;
+
+      Index startPanel = IsLower ? 0 : k2+actual_kc;
+      Index rs = IsLower ? actual_k2 : size - actual_k2 - actual_kc;
+      Scalar* geb = blockB+actual_kc*actual_kc;
+
+      if (rs>0) pack_rhs(geb, rhs.getSubMapper(actual_k2,startPanel), actual_kc, rs);
+
+      // triangular packing (we only pack the panels off the diagonal,
+      // neglecting the blocks overlapping the diagonal
+      {
+        for (Index j2=0; j2<actual_kc; j2+=SmallPanelWidth)
+        {
+          Index actualPanelWidth = std::min<Index>(actual_kc-j2, SmallPanelWidth);
+          Index actual_j2 = actual_k2 + j2;
+          Index panelOffset = IsLower ? j2+actualPanelWidth : 0;
+          Index panelLength = IsLower ? actual_kc-j2-actualPanelWidth : j2;
+
+          if (panelLength>0)
+          pack_rhs_panel(blockB+j2*actual_kc,
+                         rhs.getSubMapper(actual_k2+panelOffset, actual_j2),
+                         panelLength, actualPanelWidth,
+                         actual_kc, panelOffset);
+        }
+      }
+
+      for(Index i2=0; i2<rows; i2+=mc)
+      {
+        const Index actual_mc = (std::min)(mc,rows-i2);
+
+        // triangular solver kernel
+        {
+          // for each small block of the diagonal (=> vertical panels of rhs)
+          for (Index j2 = IsLower
+                      ? (actual_kc - ((actual_kc%SmallPanelWidth) ? Index(actual_kc%SmallPanelWidth)
+                                                                  : Index(SmallPanelWidth)))
+                      : 0;
+               IsLower ? j2>=0 : j2<actual_kc;
+               IsLower ? j2-=SmallPanelWidth : j2+=SmallPanelWidth)
+          {
+            Index actualPanelWidth = std::min<Index>(actual_kc-j2, SmallPanelWidth);
+            Index absolute_j2 = actual_k2 + j2;
+            Index panelOffset = IsLower ? j2+actualPanelWidth : 0;
+            Index panelLength = IsLower ? actual_kc - j2 - actualPanelWidth : j2;
+
+            // GEBP
+            if(panelLength>0)
+            {
+              gebp_kernel(lhs.getSubMapper(i2,absolute_j2),
+                          blockA, blockB+j2*actual_kc,
+                          actual_mc, panelLength, actualPanelWidth,
+                          Scalar(-1),
+                          actual_kc, actual_kc, // strides
+                          panelOffset, panelOffset); // offsets
+            }
+
+            // unblocked triangular solve
+            for (Index k=0; k<actualPanelWidth; ++k)
+            {
+              Index j = IsLower ? absolute_j2+actualPanelWidth-k-1 : absolute_j2+k;
+
+              Scalar* r = &lhs(i2,j);
+              for (Index k3=0; k3<k; ++k3)
+              {
+                Scalar b = conj(rhs(IsLower ? j+1+k3 : absolute_j2+k3,j));
+                Scalar* a = &lhs(i2,IsLower ? j+1+k3 : absolute_j2+k3);
+                for (Index i=0; i<actual_mc; ++i)
+                  r[i] -= a[i] * b;
+              }
+              if((Mode & UnitDiag)==0)
+              {
+                Scalar inv_rjj = RealScalar(1)/conj(rhs(j,j));
+                for (Index i=0; i<actual_mc; ++i)
+                  r[i] *= inv_rjj;
+              }
+            }
+
+            // pack the just computed part of lhs to A
+            pack_lhs_panel(blockA, LhsMapper(_other+absolute_j2*otherStride+i2, otherStride),
+                           actualPanelWidth, actual_mc,
+                           actual_kc, j2);
+          }
+        }
+
+        if (rs>0)
+          gebp_kernel(lhs.getSubMapper(i2, startPanel), blockA, geb,
+                      actual_mc, actual_kc, rs, Scalar(-1),
+                      -1, -1, 0, 0);
+      }
+    }
+  }
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRIANGULAR_SOLVER_MATRIX_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
new file mode 100644
index 00000000..f0775116
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
@@ -0,0 +1,163 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to BLAS F77
+ *   Triangular matrix * matrix product functionality based on ?TRMM.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_TRIANGULAR_SOLVER_MATRIX_BLAS_H
+#define EIGEN_TRIANGULAR_SOLVER_MATRIX_BLAS_H
+
+namespace Eigen {
+
+namespace internal {
+
+// implements LeftSide op(triangular)^-1 * general
+#define EIGEN_BLAS_TRSM_L(EIGTYPE, BLASTYPE, BLASFUNC) \
+template <typename Index, int Mode, bool Conjugate, int TriStorageOrder> \
+struct triangular_solve_matrix<EIGTYPE,Index,OnTheLeft,Mode,Conjugate,TriStorageOrder,ColMajor> \
+{ \
+  enum { \
+    IsLower = (Mode&Lower) == Lower, \
+    IsUnitDiag  = (Mode&UnitDiag) ? 1 : 0, \
+    IsZeroDiag  = (Mode&ZeroDiag) ? 1 : 0, \
+    conjA = ((TriStorageOrder==ColMajor) && Conjugate) ? 1 : 0 \
+  }; \
+  static void run( \
+      Index size, Index otherSize, \
+      const EIGTYPE* _tri, Index triStride, \
+      EIGTYPE* _other, Index otherStride, level3_blocking<EIGTYPE,EIGTYPE>& /*blocking*/) \
+  { \
+   BlasIndex m = convert_index<BlasIndex>(size), n = convert_index<BlasIndex>(otherSize), lda, ldb; \
+   char side = 'L', uplo, diag='N', transa; \
+   /* Set alpha_ */ \
+   EIGTYPE alpha(1); \
+   ldb = convert_index<BlasIndex>(otherStride);\
+\
+   const EIGTYPE *a; \
+/* Set trans */ \
+   transa = (TriStorageOrder==RowMajor) ? ((Conjugate) ? 'C' : 'T') : 'N'; \
+/* Set uplo */ \
+   uplo = IsLower ? 'L' : 'U'; \
+   if (TriStorageOrder==RowMajor) uplo = (uplo == 'L') ? 'U' : 'L'; \
+/* Set a, lda */ \
+   typedef Matrix<EIGTYPE, Dynamic, Dynamic, TriStorageOrder> MatrixTri; \
+   Map<const MatrixTri, 0, OuterStride<> > tri(_tri,size,size,OuterStride<>(triStride)); \
+   MatrixTri a_tmp; \
+\
+   if (conjA) { \
+     a_tmp = tri.conjugate(); \
+     a = a_tmp.data(); \
+     lda = convert_index<BlasIndex>(a_tmp.outerStride()); \
+   } else { \
+     a = _tri; \
+     lda = convert_index<BlasIndex>(triStride); \
+   } \
+   if (IsUnitDiag) diag='U'; \
+/* call ?trsm*/ \
+   BLASFUNC(&side, &uplo, &transa, &diag, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (BLASTYPE*)_other, &ldb); \
+ } \
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_TRSM_L(double,   double, dtrsm)
+EIGEN_BLAS_TRSM_L(dcomplex, MKL_Complex16, ztrsm)
+EIGEN_BLAS_TRSM_L(float,    float,  strsm)
+EIGEN_BLAS_TRSM_L(scomplex, MKL_Complex8, ctrsm)
+#else
+EIGEN_BLAS_TRSM_L(double,   double, dtrsm_)
+EIGEN_BLAS_TRSM_L(dcomplex, double, ztrsm_)
+EIGEN_BLAS_TRSM_L(float,    float,  strsm_)
+EIGEN_BLAS_TRSM_L(scomplex, float,  ctrsm_)
+#endif
+
+// implements RightSide general * op(triangular)^-1
+#define EIGEN_BLAS_TRSM_R(EIGTYPE, BLASTYPE, BLASFUNC) \
+template <typename Index, int Mode, bool Conjugate, int TriStorageOrder> \
+struct triangular_solve_matrix<EIGTYPE,Index,OnTheRight,Mode,Conjugate,TriStorageOrder,ColMajor> \
+{ \
+  enum { \
+    IsLower = (Mode&Lower) == Lower, \
+    IsUnitDiag  = (Mode&UnitDiag) ? 1 : 0, \
+    IsZeroDiag  = (Mode&ZeroDiag) ? 1 : 0, \
+    conjA = ((TriStorageOrder==ColMajor) && Conjugate) ? 1 : 0 \
+  }; \
+  static void run( \
+      Index size, Index otherSize, \
+      const EIGTYPE* _tri, Index triStride, \
+      EIGTYPE* _other, Index otherStride, level3_blocking<EIGTYPE,EIGTYPE>& /*blocking*/) \
+  { \
+   BlasIndex m = convert_index<BlasIndex>(otherSize), n = convert_index<BlasIndex>(size), lda, ldb; \
+   char side = 'R', uplo, diag='N', transa; \
+   /* Set alpha_ */ \
+   EIGTYPE alpha(1); \
+   ldb = convert_index<BlasIndex>(otherStride);\
+\
+   const EIGTYPE *a; \
+/* Set trans */ \
+   transa = (TriStorageOrder==RowMajor) ? ((Conjugate) ? 'C' : 'T') : 'N'; \
+/* Set uplo */ \
+   uplo = IsLower ? 'L' : 'U'; \
+   if (TriStorageOrder==RowMajor) uplo = (uplo == 'L') ? 'U' : 'L'; \
+/* Set a, lda */ \
+   typedef Matrix<EIGTYPE, Dynamic, Dynamic, TriStorageOrder> MatrixTri; \
+   Map<const MatrixTri, 0, OuterStride<> > tri(_tri,size,size,OuterStride<>(triStride)); \
+   MatrixTri a_tmp; \
+\
+   if (conjA) { \
+     a_tmp = tri.conjugate(); \
+     a = a_tmp.data(); \
+     lda = convert_index<BlasIndex>(a_tmp.outerStride()); \
+   } else { \
+     a = _tri; \
+     lda = convert_index<BlasIndex>(triStride); \
+   } \
+   if (IsUnitDiag) diag='U'; \
+/* call ?trsm*/ \
+   BLASFUNC(&side, &uplo, &transa, &diag, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (BLASTYPE*)_other, &ldb); \
+   /*std::cout << "TRMS_L specialization!\n";*/ \
+ } \
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_TRSM_R(double,   double, dtrsm)
+EIGEN_BLAS_TRSM_R(dcomplex, MKL_Complex16, ztrsm)
+EIGEN_BLAS_TRSM_R(float,    float,  strsm)
+EIGEN_BLAS_TRSM_R(scomplex, MKL_Complex8,  ctrsm)
+#else
+EIGEN_BLAS_TRSM_R(double,   double, dtrsm_)
+EIGEN_BLAS_TRSM_R(dcomplex, double, ztrsm_)
+EIGEN_BLAS_TRSM_R(float,    float,  strsm_)
+EIGEN_BLAS_TRSM_R(scomplex, float,  ctrsm_)
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRIANGULAR_SOLVER_MATRIX_BLAS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/TriangularSolverVector.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/TriangularSolverVector.h
new file mode 100644
index 00000000..b994759b
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/products/TriangularSolverVector.h
@@ -0,0 +1,145 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TRIANGULAR_SOLVER_VECTOR_H
+#define EIGEN_TRIANGULAR_SOLVER_VECTOR_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename LhsScalar, typename RhsScalar, typename Index, int Mode, bool Conjugate, int StorageOrder>
+struct triangular_solve_vector<LhsScalar, RhsScalar, Index, OnTheRight, Mode, Conjugate, StorageOrder>
+{
+  static void run(Index size, const LhsScalar* _lhs, Index lhsStride, RhsScalar* rhs)
+  {
+    triangular_solve_vector<LhsScalar,RhsScalar,Index,OnTheLeft,
+        ((Mode&Upper)==Upper ? Lower : Upper) | (Mode&UnitDiag),
+        Conjugate,StorageOrder==RowMajor?ColMajor:RowMajor
+      >::run(size, _lhs, lhsStride, rhs);
+  }
+};
+
+// forward and backward substitution, row-major, rhs is a vector
+template<typename LhsScalar, typename RhsScalar, typename Index, int Mode, bool Conjugate>
+struct triangular_solve_vector<LhsScalar, RhsScalar, Index, OnTheLeft, Mode, Conjugate, RowMajor>
+{
+  enum {
+    IsLower = ((Mode&Lower)==Lower)
+  };
+  static void run(Index size, const LhsScalar* _lhs, Index lhsStride, RhsScalar* rhs)
+  {
+    typedef Map<const Matrix<LhsScalar,Dynamic,Dynamic,RowMajor>, 0, OuterStride<> > LhsMap;
+    const LhsMap lhs(_lhs,size,size,OuterStride<>(lhsStride));
+
+    typedef const_blas_data_mapper<LhsScalar,Index,RowMajor> LhsMapper;
+    typedef const_blas_data_mapper<RhsScalar,Index,ColMajor> RhsMapper;
+
+    typename internal::conditional<
+                          Conjugate,
+                          const CwiseUnaryOp<typename internal::scalar_conjugate_op<LhsScalar>,LhsMap>,
+                          const LhsMap&>
+                        ::type cjLhs(lhs);
+    static const Index PanelWidth = EIGEN_TUNE_TRIANGULAR_PANEL_WIDTH;
+    for(Index pi=IsLower ? 0 : size;
+        IsLower ? pi<size : pi>0;
+        IsLower ? pi+=PanelWidth : pi-=PanelWidth)
+    {
+      Index actualPanelWidth = (std::min)(IsLower ? size - pi : pi, PanelWidth);
+
+      Index r = IsLower ? pi : size - pi; // remaining size
+      if (r > 0)
+      {
+        // let's directly call the low level product function because:
+        // 1 - it is faster to compile
+        // 2 - it is slighlty faster at runtime
+        Index startRow = IsLower ? pi : pi-actualPanelWidth;
+        Index startCol = IsLower ? 0 : pi;
+
+        general_matrix_vector_product<Index,LhsScalar,LhsMapper,RowMajor,Conjugate,RhsScalar,RhsMapper,false>::run(
+          actualPanelWidth, r,
+          LhsMapper(&lhs.coeffRef(startRow,startCol), lhsStride),
+          RhsMapper(rhs + startCol, 1),
+          rhs + startRow, 1,
+          RhsScalar(-1));
+      }
+
+      for(Index k=0; k<actualPanelWidth; ++k)
+      {
+        Index i = IsLower ? pi+k : pi-k-1;
+        Index s = IsLower ? pi   : i+1;
+        if (k>0)
+          rhs[i] -= (cjLhs.row(i).segment(s,k).transpose().cwiseProduct(Map<const Matrix<RhsScalar,Dynamic,1> >(rhs+s,k))).sum();
+
+        if(!(Mode & UnitDiag))
+          rhs[i] /= cjLhs(i,i);
+      }
+    }
+  }
+};
+
+// forward and backward substitution, column-major, rhs is a vector
+template<typename LhsScalar, typename RhsScalar, typename Index, int Mode, bool Conjugate>
+struct triangular_solve_vector<LhsScalar, RhsScalar, Index, OnTheLeft, Mode, Conjugate, ColMajor>
+{
+  enum {
+    IsLower = ((Mode&Lower)==Lower)
+  };
+  static void run(Index size, const LhsScalar* _lhs, Index lhsStride, RhsScalar* rhs)
+  {
+    typedef Map<const Matrix<LhsScalar,Dynamic,Dynamic,ColMajor>, 0, OuterStride<> > LhsMap;
+    const LhsMap lhs(_lhs,size,size,OuterStride<>(lhsStride));
+    typedef const_blas_data_mapper<LhsScalar,Index,ColMajor> LhsMapper;
+    typedef const_blas_data_mapper<RhsScalar,Index,ColMajor> RhsMapper;
+    typename internal::conditional<Conjugate,
+                                   const CwiseUnaryOp<typename internal::scalar_conjugate_op<LhsScalar>,LhsMap>,
+                                   const LhsMap&
+                                  >::type cjLhs(lhs);
+    static const Index PanelWidth = EIGEN_TUNE_TRIANGULAR_PANEL_WIDTH;
+
+    for(Index pi=IsLower ? 0 : size;
+        IsLower ? pi<size : pi>0;
+        IsLower ? pi+=PanelWidth : pi-=PanelWidth)
+    {
+      Index actualPanelWidth = (std::min)(IsLower ? size - pi : pi, PanelWidth);
+      Index startBlock = IsLower ? pi : pi-actualPanelWidth;
+      Index endBlock = IsLower ? pi + actualPanelWidth : 0;
+
+      for(Index k=0; k<actualPanelWidth; ++k)
+      {
+        Index i = IsLower ? pi+k : pi-k-1;
+        if(!(Mode & UnitDiag))
+          rhs[i] /= cjLhs.coeff(i,i);
+
+        Index r = actualPanelWidth - k - 1; // remaining size
+        Index s = IsLower ? i+1 : i-r;
+        if (r>0)
+          Map<Matrix<RhsScalar,Dynamic,1> >(rhs+s,r) -= rhs[i] * cjLhs.col(i).segment(s,r);
+      }
+      Index r = IsLower ? size - endBlock : startBlock; // remaining size
+      if (r > 0)
+      {
+        // let's directly call the low level product function because:
+        // 1 - it is faster to compile
+        // 2 - it is slighlty faster at runtime
+        general_matrix_vector_product<Index,LhsScalar,LhsMapper,ColMajor,Conjugate,RhsScalar,RhsMapper,false>::run(
+            r, actualPanelWidth,
+            LhsMapper(&lhs.coeffRef(endBlock,startBlock), lhsStride),
+            RhsMapper(rhs+startBlock, 1),
+            rhs+endBlock, 1, RhsScalar(-1));
+      }
+    }
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRIANGULAR_SOLVER_VECTOR_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/BlasUtil.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/BlasUtil.h
new file mode 100644
index 00000000..b1791fb3
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/BlasUtil.h
@@ -0,0 +1,403 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_BLASUTIL_H
+#define EIGEN_BLASUTIL_H
+
+// This file contains many lightweight helper classes used to
+// implement and control fast level 2 and level 3 BLAS-like routines.
+
+namespace Eigen {
+
+namespace internal {
+
+// forward declarations
+template<typename LhsScalar, typename RhsScalar, typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs=false, bool ConjugateRhs=false>
+struct gebp_kernel;
+
+template<typename Scalar, typename Index, typename DataMapper, int nr, int StorageOrder, bool Conjugate = false, bool PanelMode=false>
+struct gemm_pack_rhs;
+
+template<typename Scalar, typename Index, typename DataMapper, int Pack1, int Pack2, int StorageOrder, bool Conjugate = false, bool PanelMode = false>
+struct gemm_pack_lhs;
+
+template<
+  typename Index,
+  typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs,
+  typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs,
+  int ResStorageOrder>
+struct general_matrix_matrix_product;
+
+template<typename Index,
+         typename LhsScalar, typename LhsMapper, int LhsStorageOrder, bool ConjugateLhs,
+         typename RhsScalar, typename RhsMapper, bool ConjugateRhs, int Version=Specialized>
+struct general_matrix_vector_product;
+
+
+template<bool Conjugate> struct conj_if;
+
+template<> struct conj_if<true> {
+  template<typename T>
+  inline T operator()(const T& x) const { return numext::conj(x); }
+  template<typename T>
+  inline T pconj(const T& x) const { return internal::pconj(x); }
+};
+
+template<> struct conj_if<false> {
+  template<typename T>
+  inline const T& operator()(const T& x) const { return x; }
+  template<typename T>
+  inline const T& pconj(const T& x) const { return x; }
+};
+
+// Generic implementation for custom complex types.
+template<typename LhsScalar, typename RhsScalar, bool ConjLhs, bool ConjRhs>
+struct conj_helper
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar>::ReturnType Scalar;
+
+  EIGEN_STRONG_INLINE Scalar pmadd(const LhsScalar& x, const RhsScalar& y, const Scalar& c) const
+  { return padd(c, pmul(x,y)); }
+
+  EIGEN_STRONG_INLINE Scalar pmul(const LhsScalar& x, const RhsScalar& y) const
+  { return conj_if<ConjLhs>()(x) *  conj_if<ConjRhs>()(y); }
+};
+
+template<typename Scalar> struct conj_helper<Scalar,Scalar,false,false>
+{
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar pmadd(const Scalar& x, const Scalar& y, const Scalar& c) const { return internal::pmadd(x,y,c); }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar pmul(const Scalar& x, const Scalar& y) const { return internal::pmul(x,y); }
+};
+
+template<typename RealScalar> struct conj_helper<std::complex<RealScalar>, std::complex<RealScalar>, false,true>
+{
+  typedef std::complex<RealScalar> Scalar;
+  EIGEN_STRONG_INLINE Scalar pmadd(const Scalar& x, const Scalar& y, const Scalar& c) const
+  { return c + pmul(x,y); }
+
+  EIGEN_STRONG_INLINE Scalar pmul(const Scalar& x, const Scalar& y) const
+  { return Scalar(numext::real(x)*numext::real(y) + numext::imag(x)*numext::imag(y), numext::imag(x)*numext::real(y) - numext::real(x)*numext::imag(y)); }
+};
+
+template<typename RealScalar> struct conj_helper<std::complex<RealScalar>, std::complex<RealScalar>, true,false>
+{
+  typedef std::complex<RealScalar> Scalar;
+  EIGEN_STRONG_INLINE Scalar pmadd(const Scalar& x, const Scalar& y, const Scalar& c) const
+  { return c + pmul(x,y); }
+
+  EIGEN_STRONG_INLINE Scalar pmul(const Scalar& x, const Scalar& y) const
+  { return Scalar(numext::real(x)*numext::real(y) + numext::imag(x)*numext::imag(y), numext::real(x)*numext::imag(y) - numext::imag(x)*numext::real(y)); }
+};
+
+template<typename RealScalar> struct conj_helper<std::complex<RealScalar>, std::complex<RealScalar>, true,true>
+{
+  typedef std::complex<RealScalar> Scalar;
+  EIGEN_STRONG_INLINE Scalar pmadd(const Scalar& x, const Scalar& y, const Scalar& c) const
+  { return c + pmul(x,y); }
+
+  EIGEN_STRONG_INLINE Scalar pmul(const Scalar& x, const Scalar& y) const
+  { return Scalar(numext::real(x)*numext::real(y) - numext::imag(x)*numext::imag(y), - numext::real(x)*numext::imag(y) - numext::imag(x)*numext::real(y)); }
+};
+
+template<typename RealScalar,bool Conj> struct conj_helper<std::complex<RealScalar>, RealScalar, Conj,false>
+{
+  typedef std::complex<RealScalar> Scalar;
+  EIGEN_STRONG_INLINE Scalar pmadd(const Scalar& x, const RealScalar& y, const Scalar& c) const
+  { return padd(c, pmul(x,y)); }
+  EIGEN_STRONG_INLINE Scalar pmul(const Scalar& x, const RealScalar& y) const
+  { return conj_if<Conj>()(x)*y; }
+};
+
+template<typename RealScalar,bool Conj> struct conj_helper<RealScalar, std::complex<RealScalar>, false,Conj>
+{
+  typedef std::complex<RealScalar> Scalar;
+  EIGEN_STRONG_INLINE Scalar pmadd(const RealScalar& x, const Scalar& y, const Scalar& c) const
+  { return padd(c, pmul(x,y)); }
+  EIGEN_STRONG_INLINE Scalar pmul(const RealScalar& x, const Scalar& y) const
+  { return x*conj_if<Conj>()(y); }
+};
+
+template<typename From,typename To> struct get_factor {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE To run(const From& x) { return To(x); }
+};
+
+template<typename Scalar> struct get_factor<Scalar,typename NumTraits<Scalar>::Real> {
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE typename NumTraits<Scalar>::Real run(const Scalar& x) { return numext::real(x); }
+};
+
+
+template<typename Scalar, typename Index>
+class BlasVectorMapper {
+  public:
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE BlasVectorMapper(Scalar *data) : m_data(data) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar operator()(Index i) const {
+    return m_data[i];
+  }
+  template <typename Packet, int AlignmentType>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet load(Index i) const {
+    return ploadt<Packet, AlignmentType>(m_data + i);
+  }
+
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC bool aligned(Index i) const {
+    return (UIntPtr(m_data+i)%sizeof(Packet))==0;
+  }
+
+  protected:
+  Scalar* m_data;
+};
+
+template<typename Scalar, typename Index, int AlignmentType>
+class BlasLinearMapper {
+  public:
+  typedef typename packet_traits<Scalar>::type Packet;
+  typedef typename packet_traits<Scalar>::half HalfPacket;
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE BlasLinearMapper(Scalar *data) : m_data(data) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void prefetch(int i) const {
+    internal::prefetch(&operator()(i));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar& operator()(Index i) const {
+    return m_data[i];
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet loadPacket(Index i) const {
+    return ploadt<Packet, AlignmentType>(m_data + i);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE HalfPacket loadHalfPacket(Index i) const {
+    return ploadt<HalfPacket, AlignmentType>(m_data + i);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void storePacket(Index i, const Packet &p) const {
+    pstoret<Scalar, Packet, AlignmentType>(m_data + i, p);
+  }
+
+  protected:
+  Scalar *m_data;
+};
+
+// Lightweight helper class to access matrix coefficients.
+template<typename Scalar, typename Index, int StorageOrder, int AlignmentType = Unaligned>
+class blas_data_mapper {
+  public:
+  typedef typename packet_traits<Scalar>::type Packet;
+  typedef typename packet_traits<Scalar>::half HalfPacket;
+
+  typedef BlasLinearMapper<Scalar, Index, AlignmentType> LinearMapper;
+  typedef BlasVectorMapper<Scalar, Index> VectorMapper;
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE blas_data_mapper(Scalar* data, Index stride) : m_data(data), m_stride(stride) {}
+
+  EIGEN_DEVICE_FUNC  EIGEN_ALWAYS_INLINE blas_data_mapper<Scalar, Index, StorageOrder, AlignmentType>
+  getSubMapper(Index i, Index j) const {
+    return blas_data_mapper<Scalar, Index, StorageOrder, AlignmentType>(&operator()(i, j), m_stride);
+  }
+
+  EIGEN_DEVICE_FUNC  EIGEN_ALWAYS_INLINE LinearMapper getLinearMapper(Index i, Index j) const {
+    return LinearMapper(&operator()(i, j));
+  }
+
+  EIGEN_DEVICE_FUNC  EIGEN_ALWAYS_INLINE VectorMapper getVectorMapper(Index i, Index j) const {
+    return VectorMapper(&operator()(i, j));
+  }
+
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Scalar& operator()(Index i, Index j) const {
+    return m_data[StorageOrder==RowMajor ? j + i*m_stride : i + j*m_stride];
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet loadPacket(Index i, Index j) const {
+    return ploadt<Packet, AlignmentType>(&operator()(i, j));
+  }
+
+  template <typename PacketT, int AlignmentT>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE PacketT load(Index i, Index j) const {
+    return ploadt<PacketT, AlignmentT>(&operator()(i, j));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE HalfPacket loadHalfPacket(Index i, Index j) const {
+    return ploadt<HalfPacket, AlignmentType>(&operator()(i, j));
+  }
+
+  template<typename SubPacket>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void scatterPacket(Index i, Index j, const SubPacket &p) const {
+    pscatter<Scalar, SubPacket>(&operator()(i, j), p, m_stride);
+  }
+
+  template<typename SubPacket>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE SubPacket gatherPacket(Index i, Index j) const {
+    return pgather<Scalar, SubPacket>(&operator()(i, j), m_stride);
+  }
+
+  EIGEN_DEVICE_FUNC const Index stride() const { return m_stride; }
+  EIGEN_DEVICE_FUNC const Scalar* data() const { return m_data; }
+
+  EIGEN_DEVICE_FUNC Index firstAligned(Index size) const {
+    if (UIntPtr(m_data)%sizeof(Scalar)) {
+      return -1;
+    }
+    return internal::first_default_aligned(m_data, size);
+  }
+
+  protected:
+  Scalar* EIGEN_RESTRICT m_data;
+  const Index m_stride;
+};
+
+// lightweight helper class to access matrix coefficients (const version)
+template<typename Scalar, typename Index, int StorageOrder>
+class const_blas_data_mapper : public blas_data_mapper<const Scalar, Index, StorageOrder> {
+  public:
+  EIGEN_ALWAYS_INLINE const_blas_data_mapper(const Scalar *data, Index stride) : blas_data_mapper<const Scalar, Index, StorageOrder>(data, stride) {}
+
+  EIGEN_ALWAYS_INLINE const_blas_data_mapper<Scalar, Index, StorageOrder> getSubMapper(Index i, Index j) const {
+    return const_blas_data_mapper<Scalar, Index, StorageOrder>(&(this->operator()(i, j)), this->m_stride);
+  }
+};
+
+
+/* Helper class to analyze the factors of a Product expression.
+ * In particular it allows to pop out operator-, scalar multiples,
+ * and conjugate */
+template<typename XprType> struct blas_traits
+{
+  typedef typename traits<XprType>::Scalar Scalar;
+  typedef const XprType& ExtractType;
+  typedef XprType _ExtractType;
+  enum {
+    IsComplex = NumTraits<Scalar>::IsComplex,
+    IsTransposed = false,
+    NeedToConjugate = false,
+    HasUsableDirectAccess = (    (int(XprType::Flags)&DirectAccessBit)
+                              && (   bool(XprType::IsVectorAtCompileTime)
+                                  || int(inner_stride_at_compile_time<XprType>::ret) == 1)
+                             ) ?  1 : 0
+  };
+  typedef typename conditional<bool(HasUsableDirectAccess),
+    ExtractType,
+    typename _ExtractType::PlainObject
+    >::type DirectLinearAccessType;
+  static inline ExtractType extract(const XprType& x) { return x; }
+  static inline const Scalar extractScalarFactor(const XprType&) { return Scalar(1); }
+};
+
+// pop conjugate
+template<typename Scalar, typename NestedXpr>
+struct blas_traits<CwiseUnaryOp<scalar_conjugate_op<Scalar>, NestedXpr> >
+ : blas_traits<NestedXpr>
+{
+  typedef blas_traits<NestedXpr> Base;
+  typedef CwiseUnaryOp<scalar_conjugate_op<Scalar>, NestedXpr> XprType;
+  typedef typename Base::ExtractType ExtractType;
+
+  enum {
+    IsComplex = NumTraits<Scalar>::IsComplex,
+    NeedToConjugate = Base::NeedToConjugate ? 0 : IsComplex
+  };
+  static inline ExtractType extract(const XprType& x) { return Base::extract(x.nestedExpression()); }
+  static inline Scalar extractScalarFactor(const XprType& x) { return conj(Base::extractScalarFactor(x.nestedExpression())); }
+};
+
+// pop scalar multiple
+template<typename Scalar, typename NestedXpr, typename Plain>
+struct blas_traits<CwiseBinaryOp<scalar_product_op<Scalar>, const CwiseNullaryOp<scalar_constant_op<Scalar>,Plain>, NestedXpr> >
+ : blas_traits<NestedXpr>
+{
+  typedef blas_traits<NestedXpr> Base;
+  typedef CwiseBinaryOp<scalar_product_op<Scalar>, const CwiseNullaryOp<scalar_constant_op<Scalar>,Plain>, NestedXpr> XprType;
+  typedef typename Base::ExtractType ExtractType;
+  static inline ExtractType extract(const XprType& x) { return Base::extract(x.rhs()); }
+  static inline Scalar extractScalarFactor(const XprType& x)
+  { return x.lhs().functor().m_other * Base::extractScalarFactor(x.rhs()); }
+};
+template<typename Scalar, typename NestedXpr, typename Plain>
+struct blas_traits<CwiseBinaryOp<scalar_product_op<Scalar>, NestedXpr, const CwiseNullaryOp<scalar_constant_op<Scalar>,Plain> > >
+ : blas_traits<NestedXpr>
+{
+  typedef blas_traits<NestedXpr> Base;
+  typedef CwiseBinaryOp<scalar_product_op<Scalar>, NestedXpr, const CwiseNullaryOp<scalar_constant_op<Scalar>,Plain> > XprType;
+  typedef typename Base::ExtractType ExtractType;
+  static inline ExtractType extract(const XprType& x) { return Base::extract(x.lhs()); }
+  static inline Scalar extractScalarFactor(const XprType& x)
+  { return Base::extractScalarFactor(x.lhs()) * x.rhs().functor().m_other; }
+};
+template<typename Scalar, typename Plain1, typename Plain2>
+struct blas_traits<CwiseBinaryOp<scalar_product_op<Scalar>, const CwiseNullaryOp<scalar_constant_op<Scalar>,Plain1>,
+                                                            const CwiseNullaryOp<scalar_constant_op<Scalar>,Plain2> > >
+ : blas_traits<CwiseNullaryOp<scalar_constant_op<Scalar>,Plain1> >
+{};
+
+// pop opposite
+template<typename Scalar, typename NestedXpr>
+struct blas_traits<CwiseUnaryOp<scalar_opposite_op<Scalar>, NestedXpr> >
+ : blas_traits<NestedXpr>
+{
+  typedef blas_traits<NestedXpr> Base;
+  typedef CwiseUnaryOp<scalar_opposite_op<Scalar>, NestedXpr> XprType;
+  typedef typename Base::ExtractType ExtractType;
+  static inline ExtractType extract(const XprType& x) { return Base::extract(x.nestedExpression()); }
+  static inline Scalar extractScalarFactor(const XprType& x)
+  { return - Base::extractScalarFactor(x.nestedExpression()); }
+};
+
+// pop/push transpose
+template<typename NestedXpr>
+struct blas_traits<Transpose<NestedXpr> >
+ : blas_traits<NestedXpr>
+{
+  typedef typename NestedXpr::Scalar Scalar;
+  typedef blas_traits<NestedXpr> Base;
+  typedef Transpose<NestedXpr> XprType;
+  typedef Transpose<const typename Base::_ExtractType>  ExtractType; // const to get rid of a compile error; anyway blas traits are only used on the RHS
+  typedef Transpose<const typename Base::_ExtractType> _ExtractType;
+  typedef typename conditional<bool(Base::HasUsableDirectAccess),
+    ExtractType,
+    typename ExtractType::PlainObject
+    >::type DirectLinearAccessType;
+  enum {
+    IsTransposed = Base::IsTransposed ? 0 : 1
+  };
+  static inline ExtractType extract(const XprType& x) { return ExtractType(Base::extract(x.nestedExpression())); }
+  static inline Scalar extractScalarFactor(const XprType& x) { return Base::extractScalarFactor(x.nestedExpression()); }
+};
+
+template<typename T>
+struct blas_traits<const T>
+     : blas_traits<T>
+{};
+
+template<typename T, bool HasUsableDirectAccess=blas_traits<T>::HasUsableDirectAccess>
+struct extract_data_selector {
+  static const typename T::Scalar* run(const T& m)
+  {
+    return blas_traits<T>::extract(m).data();
+  }
+};
+
+template<typename T>
+struct extract_data_selector<T,false> {
+  static typename T::Scalar* run(const T&) { return 0; }
+};
+
+template<typename T> const typename T::Scalar* extract_data(const T& m)
+{
+  return extract_data_selector<T>::run(m);
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_BLASUTIL_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/Constants.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/Constants.h
new file mode 100644
index 00000000..5d37e5d0
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/Constants.h
@@ -0,0 +1,551 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2007-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CONSTANTS_H
+#define EIGEN_CONSTANTS_H
+
+namespace Eigen {
+
+/** This value means that a positive quantity (e.g., a size) is not known at compile-time, and that instead the value is
+  * stored in some runtime variable.
+  *
+  * Changing the value of Dynamic breaks the ABI, as Dynamic is often used as a template parameter for Matrix.
+  */
+const int Dynamic = -1;
+
+/** This value means that a signed quantity (e.g., a signed index) is not known at compile-time, and that instead its value
+  * has to be specified at runtime.
+  */
+const int DynamicIndex = 0xffffff;
+
+/** This value means that the increment to go from one value to another in a sequence is not constant for each step.
+  */
+const int UndefinedIncr = 0xfffffe;
+
+/** This value means +Infinity; it is currently used only as the p parameter to MatrixBase::lpNorm<int>().
+  * The value Infinity there means the L-infinity norm.
+  */
+const int Infinity = -1;
+
+/** This value means that the cost to evaluate an expression coefficient is either very expensive or
+  * cannot be known at compile time.
+  *
+  * This value has to be positive to (1) simplify cost computation, and (2) allow to distinguish between a very expensive and very very expensive expressions.
+  * It thus must also be large enough to make sure unrolling won't happen and that sub expressions will be evaluated, but not too large to avoid overflow.
+  */
+const int HugeCost = 10000;
+
+/** \defgroup flags Flags
+  * \ingroup Core_Module
+  *
+  * These are the possible bits which can be OR'ed to constitute the flags of a matrix or
+  * expression.
+  *
+  * It is important to note that these flags are a purely compile-time notion. They are a compile-time property of
+  * an expression type, implemented as enum's. They are not stored in memory at runtime, and they do not incur any
+  * runtime overhead.
+  *
+  * \sa MatrixBase::Flags
+  */
+
+/** \ingroup flags
+  *
+  * for a matrix, this means that the storage order is row-major.
+  * If this bit is not set, the storage order is column-major.
+  * For an expression, this determines the storage order of
+  * the matrix created by evaluation of that expression.
+  * \sa \blank  \ref TopicStorageOrders */
+const unsigned int RowMajorBit = 0x1;
+
+/** \ingroup flags
+  * means the expression should be evaluated by the calling expression */
+const unsigned int EvalBeforeNestingBit = 0x2;
+
+/** \ingroup flags
+  * \deprecated
+  * means the expression should be evaluated before any assignment */
+EIGEN_DEPRECATED
+const unsigned int EvalBeforeAssigningBit = 0x4; // FIXME deprecated
+
+/** \ingroup flags
+  *
+  * Short version: means the expression might be vectorized
+  *
+  * Long version: means that the coefficients can be handled by packets
+  * and start at a memory location whose alignment meets the requirements
+  * of the present CPU architecture for optimized packet access. In the fixed-size
+  * case, there is the additional condition that it be possible to access all the
+  * coefficients by packets (this implies the requirement that the size be a multiple of 16 bytes,
+  * and that any nontrivial strides don't break the alignment). In the dynamic-size case,
+  * there is no such condition on the total size and strides, so it might not be possible to access
+  * all coeffs by packets.
+  *
+  * \note This bit can be set regardless of whether vectorization is actually enabled.
+  *       To check for actual vectorizability, see \a ActualPacketAccessBit.
+  */
+const unsigned int PacketAccessBit = 0x8;
+
+#ifdef EIGEN_VECTORIZE
+/** \ingroup flags
+  *
+  * If vectorization is enabled (EIGEN_VECTORIZE is defined) this constant
+  * is set to the value \a PacketAccessBit.
+  *
+  * If vectorization is not enabled (EIGEN_VECTORIZE is not defined) this constant
+  * is set to the value 0.
+  */
+const unsigned int ActualPacketAccessBit = PacketAccessBit;
+#else
+const unsigned int ActualPacketAccessBit = 0x0;
+#endif
+
+/** \ingroup flags
+  *
+  * Short version: means the expression can be seen as 1D vector.
+  *
+  * Long version: means that one can access the coefficients
+  * of this expression by coeff(int), and coeffRef(int) in the case of a lvalue expression. These
+  * index-based access methods are guaranteed
+  * to not have to do any runtime computation of a (row, col)-pair from the index, so that it
+  * is guaranteed that whenever it is available, index-based access is at least as fast as
+  * (row,col)-based access. Expressions for which that isn't possible don't have the LinearAccessBit.
+  *
+  * If both PacketAccessBit and LinearAccessBit are set, then the
+  * packets of this expression can be accessed by packet(int), and writePacket(int) in the case of a
+  * lvalue expression.
+  *
+  * Typically, all vector expressions have the LinearAccessBit, but there is one exception:
+  * Product expressions don't have it, because it would be troublesome for vectorization, even when the
+  * Product is a vector expression. Thus, vector Product expressions allow index-based coefficient access but
+  * not index-based packet access, so they don't have the LinearAccessBit.
+  */
+const unsigned int LinearAccessBit = 0x10;
+
+/** \ingroup flags
+  *
+  * Means the expression has a coeffRef() method, i.e. is writable as its individual coefficients are directly addressable.
+  * This rules out read-only expressions.
+  *
+  * Note that DirectAccessBit and LvalueBit are mutually orthogonal, as there are examples of expression having one but note
+  * the other:
+  *   \li writable expressions that don't have a very simple memory layout as a strided array, have LvalueBit but not DirectAccessBit
+  *   \li Map-to-const expressions, for example Map<const Matrix>, have DirectAccessBit but not LvalueBit
+  *
+  * Expressions having LvalueBit also have their coeff() method returning a const reference instead of returning a new value.
+  */
+const unsigned int LvalueBit = 0x20;
+
+/** \ingroup flags
+  *
+  * Means that the underlying array of coefficients can be directly accessed as a plain strided array. The memory layout
+  * of the array of coefficients must be exactly the natural one suggested by rows(), cols(),
+  * outerStride(), innerStride(), and the RowMajorBit. This rules out expressions such as Diagonal, whose coefficients,
+  * though referencable, do not have such a regular memory layout.
+  *
+  * See the comment on LvalueBit for an explanation of how LvalueBit and DirectAccessBit are mutually orthogonal.
+  */
+const unsigned int DirectAccessBit = 0x40;
+
+/** \deprecated \ingroup flags
+  *
+  * means the first coefficient packet is guaranteed to be aligned.
+  * An expression cannot has the AlignedBit without the PacketAccessBit flag.
+  * In other words, this means we are allow to perform an aligned packet access to the first element regardless
+  * of the expression kind:
+  * \code
+  * expression.packet<Aligned>(0);
+  * \endcode
+  */
+EIGEN_DEPRECATED const unsigned int AlignedBit = 0x80;
+
+const unsigned int NestByRefBit = 0x100;
+
+/** \ingroup flags
+  *
+  * for an expression, this means that the storage order
+  * can be either row-major or column-major.
+  * The precise choice will be decided at evaluation time or when
+  * combined with other expressions.
+  * \sa \blank  \ref RowMajorBit, \ref TopicStorageOrders */
+const unsigned int NoPreferredStorageOrderBit = 0x200;
+
+/** \ingroup flags
+  *
+  * Means that the underlying coefficients can be accessed through pointers to the sparse (un)compressed storage format,
+  * that is, the expression provides:
+  * \code
+    inline const Scalar* valuePtr() const;
+    inline const Index* innerIndexPtr() const;
+    inline const Index* outerIndexPtr() const;
+    inline const Index* innerNonZeroPtr() const;
+    \endcode
+  */
+const unsigned int CompressedAccessBit = 0x400;
+
+
+// list of flags that are inherited by default
+const unsigned int HereditaryBits = RowMajorBit
+                                  | EvalBeforeNestingBit;
+
+/** \defgroup enums Enumerations
+  * \ingroup Core_Module
+  *
+  * Various enumerations used in %Eigen. Many of these are used as template parameters.
+  */
+
+/** \ingroup enums
+  * Enum containing possible values for the \c Mode or \c UpLo parameter of
+  * MatrixBase::selfadjointView() and MatrixBase::triangularView(), and selfadjoint solvers. */
+enum UpLoType {
+  /** View matrix as a lower triangular matrix. */
+  Lower=0x1,                      
+  /** View matrix as an upper triangular matrix. */
+  Upper=0x2,                      
+  /** %Matrix has ones on the diagonal; to be used in combination with #Lower or #Upper. */
+  UnitDiag=0x4, 
+  /** %Matrix has zeros on the diagonal; to be used in combination with #Lower or #Upper. */
+  ZeroDiag=0x8,
+  /** View matrix as a lower triangular matrix with ones on the diagonal. */
+  UnitLower=UnitDiag|Lower, 
+  /** View matrix as an upper triangular matrix with ones on the diagonal. */
+  UnitUpper=UnitDiag|Upper,
+  /** View matrix as a lower triangular matrix with zeros on the diagonal. */
+  StrictlyLower=ZeroDiag|Lower, 
+  /** View matrix as an upper triangular matrix with zeros on the diagonal. */
+  StrictlyUpper=ZeroDiag|Upper,
+  /** Used in BandMatrix and SelfAdjointView to indicate that the matrix is self-adjoint. */
+  SelfAdjoint=0x10,
+  /** Used to support symmetric, non-selfadjoint, complex matrices. */
+  Symmetric=0x20
+};
+
+/** \ingroup enums
+  * Enum for indicating whether a buffer is aligned or not. */
+enum AlignmentType {
+  Unaligned=0,        /**< Data pointer has no specific alignment. */
+  Aligned8=8,         /**< Data pointer is aligned on a 8 bytes boundary. */
+  Aligned16=16,       /**< Data pointer is aligned on a 16 bytes boundary. */
+  Aligned32=32,       /**< Data pointer is aligned on a 32 bytes boundary. */
+  Aligned64=64,       /**< Data pointer is aligned on a 64 bytes boundary. */
+  Aligned128=128,     /**< Data pointer is aligned on a 128 bytes boundary. */
+  AlignedMask=255,
+  Aligned=16,         /**< \deprecated Synonym for Aligned16. */
+#if EIGEN_MAX_ALIGN_BYTES==128
+  AlignedMax = Aligned128
+#elif EIGEN_MAX_ALIGN_BYTES==64
+  AlignedMax = Aligned64
+#elif EIGEN_MAX_ALIGN_BYTES==32
+  AlignedMax = Aligned32
+#elif EIGEN_MAX_ALIGN_BYTES==16
+  AlignedMax = Aligned16
+#elif EIGEN_MAX_ALIGN_BYTES==8
+  AlignedMax = Aligned8
+#elif EIGEN_MAX_ALIGN_BYTES==0
+  AlignedMax = Unaligned
+#else
+#error Invalid value for EIGEN_MAX_ALIGN_BYTES
+#endif
+};
+
+/** \ingroup enums
+ * Enum used by DenseBase::corner() in Eigen2 compatibility mode. */
+// FIXME after the corner() API change, this was not needed anymore, except by AlignedBox
+// TODO: find out what to do with that. Adapt the AlignedBox API ?
+enum CornerType { TopLeft, TopRight, BottomLeft, BottomRight };
+
+/** \ingroup enums
+  * Enum containing possible values for the \p Direction parameter of
+  * Reverse, PartialReduxExpr and VectorwiseOp. */
+enum DirectionType { 
+  /** For Reverse, all columns are reversed; 
+    * for PartialReduxExpr and VectorwiseOp, act on columns. */
+  Vertical, 
+  /** For Reverse, all rows are reversed; 
+    * for PartialReduxExpr and VectorwiseOp, act on rows. */
+  Horizontal, 
+  /** For Reverse, both rows and columns are reversed; 
+    * not used for PartialReduxExpr and VectorwiseOp. */
+  BothDirections 
+};
+
+/** \internal \ingroup enums
+  * Enum to specify how to traverse the entries of a matrix. */
+enum TraversalType {
+  /** \internal Default traversal, no vectorization, no index-based access */
+  DefaultTraversal,
+  /** \internal No vectorization, use index-based access to have only one for loop instead of 2 nested loops */
+  LinearTraversal,
+  /** \internal Equivalent to a slice vectorization for fixed-size matrices having good alignment
+    * and good size */
+  InnerVectorizedTraversal,
+  /** \internal Vectorization path using a single loop plus scalar loops for the
+    * unaligned boundaries */
+  LinearVectorizedTraversal,
+  /** \internal Generic vectorization path using one vectorized loop per row/column with some
+    * scalar loops to handle the unaligned boundaries */
+  SliceVectorizedTraversal,
+  /** \internal Special case to properly handle incompatible scalar types or other defecting cases*/
+  InvalidTraversal,
+  /** \internal Evaluate all entries at once */
+  AllAtOnceTraversal
+};
+
+/** \internal \ingroup enums
+  * Enum to specify whether to unroll loops when traversing over the entries of a matrix. */
+enum UnrollingType {
+  /** \internal Do not unroll loops. */
+  NoUnrolling,
+  /** \internal Unroll only the inner loop, but not the outer loop. */
+  InnerUnrolling,
+  /** \internal Unroll both the inner and the outer loop. If there is only one loop, 
+    * because linear traversal is used, then unroll that loop. */
+  CompleteUnrolling
+};
+
+/** \internal \ingroup enums
+  * Enum to specify whether to use the default (built-in) implementation or the specialization. */
+enum SpecializedType {
+  Specialized,
+  BuiltIn
+};
+
+/** \ingroup enums
+  * Enum containing possible values for the \p _Options template parameter of
+  * Matrix, Array and BandMatrix. */
+enum StorageOptions {
+  /** Storage order is column major (see \ref TopicStorageOrders). */
+  ColMajor = 0,
+  /** Storage order is row major (see \ref TopicStorageOrders). */
+  RowMajor = 0x1,  // it is only a coincidence that this is equal to RowMajorBit -- don't rely on that
+  /** Align the matrix itself if it is vectorizable fixed-size */
+  AutoAlign = 0,
+  /** Don't require alignment for the matrix itself (the array of coefficients, if dynamically allocated, may still be requested to be aligned) */ // FIXME --- clarify the situation
+  DontAlign = 0x2
+};
+
+/** \ingroup enums
+  * Enum for specifying whether to apply or solve on the left or right. */
+enum SideType {
+  /** Apply transformation on the left. */
+  OnTheLeft = 1,  
+  /** Apply transformation on the right. */
+  OnTheRight = 2  
+};
+
+/* the following used to be written as:
+ *
+ *   struct NoChange_t {};
+ *   namespace {
+ *     EIGEN_UNUSED NoChange_t NoChange;
+ *   }
+ *
+ * on the ground that it feels dangerous to disambiguate overloaded functions on enum/integer types.  
+ * However, this leads to "variable declared but never referenced" warnings on Intel Composer XE,
+ * and we do not know how to get rid of them (bug 450).
+ */
+
+enum NoChange_t   { NoChange };
+enum Sequential_t { Sequential };
+enum Default_t    { Default };
+
+/** \internal \ingroup enums
+  * Used in AmbiVector. */
+enum AmbiVectorMode {
+  IsDense         = 0,
+  IsSparse
+};
+
+/** \ingroup enums
+  * Used as template parameter in DenseCoeffBase and MapBase to indicate 
+  * which accessors should be provided. */
+enum AccessorLevels {
+  /** Read-only access via a member function. */
+  ReadOnlyAccessors, 
+  /** Read/write access via member functions. */
+  WriteAccessors, 
+  /** Direct read-only access to the coefficients. */
+  DirectAccessors, 
+  /** Direct read/write access to the coefficients. */
+  DirectWriteAccessors
+};
+
+/** \ingroup enums
+  * Enum with options to give to various decompositions. */
+enum DecompositionOptions {
+  /** \internal Not used (meant for LDLT?). */
+  Pivoting            = 0x01, 
+  /** \internal Not used (meant for LDLT?). */
+  NoPivoting          = 0x02, 
+  /** Used in JacobiSVD to indicate that the square matrix U is to be computed. */
+  ComputeFullU        = 0x04,
+  /** Used in JacobiSVD to indicate that the thin matrix U is to be computed. */
+  ComputeThinU        = 0x08,
+  /** Used in JacobiSVD to indicate that the square matrix V is to be computed. */
+  ComputeFullV        = 0x10,
+  /** Used in JacobiSVD to indicate that the thin matrix V is to be computed. */
+  ComputeThinV        = 0x20,
+  /** Used in SelfAdjointEigenSolver and GeneralizedSelfAdjointEigenSolver to specify
+    * that only the eigenvalues are to be computed and not the eigenvectors. */
+  EigenvaluesOnly     = 0x40,
+  /** Used in SelfAdjointEigenSolver and GeneralizedSelfAdjointEigenSolver to specify
+    * that both the eigenvalues and the eigenvectors are to be computed. */
+  ComputeEigenvectors = 0x80,
+  /** \internal */
+  EigVecMask = EigenvaluesOnly | ComputeEigenvectors,
+  /** Used in GeneralizedSelfAdjointEigenSolver to indicate that it should
+    * solve the generalized eigenproblem \f$ Ax = \lambda B x \f$. */
+  Ax_lBx              = 0x100,
+  /** Used in GeneralizedSelfAdjointEigenSolver to indicate that it should
+    * solve the generalized eigenproblem \f$ ABx = \lambda x \f$. */
+  ABx_lx              = 0x200,
+  /** Used in GeneralizedSelfAdjointEigenSolver to indicate that it should
+    * solve the generalized eigenproblem \f$ BAx = \lambda x \f$. */
+  BAx_lx              = 0x400,
+  /** \internal */
+  GenEigMask = Ax_lBx | ABx_lx | BAx_lx
+};
+
+/** \ingroup enums
+  * Possible values for the \p QRPreconditioner template parameter of JacobiSVD. */
+enum QRPreconditioners {
+  /** Do not specify what is to be done if the SVD of a non-square matrix is asked for. */
+  NoQRPreconditioner,
+  /** Use a QR decomposition without pivoting as the first step. */
+  HouseholderQRPreconditioner,
+  /** Use a QR decomposition with column pivoting as the first step. */
+  ColPivHouseholderQRPreconditioner,
+  /** Use a QR decomposition with full pivoting as the first step. */
+  FullPivHouseholderQRPreconditioner
+};
+
+#ifdef Success
+#error The preprocessor symbol 'Success' is defined, possibly by the X11 header file X.h
+#endif
+
+/** \ingroup enums
+  * Enum for reporting the status of a computation. */
+enum ComputationInfo {
+  /** Computation was successful. */
+  Success = 0,        
+  /** The provided data did not satisfy the prerequisites. */
+  NumericalIssue = 1, 
+  /** Iterative procedure did not converge. */
+  NoConvergence = 2,
+  /** The inputs are invalid, or the algorithm has been improperly called.
+    * When assertions are enabled, such errors trigger an assert. */
+  InvalidInput = 3
+};
+
+/** \ingroup enums
+  * Enum used to specify how a particular transformation is stored in a matrix.
+  * \sa Transform, Hyperplane::transform(). */
+enum TransformTraits {
+  /** Transformation is an isometry. */
+  Isometry      = 0x1,
+  /** Transformation is an affine transformation stored as a (Dim+1)^2 matrix whose last row is 
+    * assumed to be [0 ... 0 1]. */
+  Affine        = 0x2,
+  /** Transformation is an affine transformation stored as a (Dim) x (Dim+1) matrix. */
+  AffineCompact = 0x10 | Affine,
+  /** Transformation is a general projective transformation stored as a (Dim+1)^2 matrix. */
+  Projective    = 0x20
+};
+
+/** \internal \ingroup enums
+  * Enum used to choose between implementation depending on the computer architecture. */
+namespace Architecture
+{
+  enum Type {
+    Generic = 0x0,
+    SSE = 0x1,
+    AltiVec = 0x2,
+    VSX = 0x3,
+    NEON = 0x4,
+#if defined EIGEN_VECTORIZE_SSE
+    Target = SSE
+#elif defined EIGEN_VECTORIZE_ALTIVEC
+    Target = AltiVec
+#elif defined EIGEN_VECTORIZE_VSX
+    Target = VSX
+#elif defined EIGEN_VECTORIZE_NEON
+    Target = NEON
+#else
+    Target = Generic
+#endif
+  };
+}
+
+/** \internal \ingroup enums
+  * Enum used as template parameter in Product and product evaluators. */
+enum ProductImplType
+{ DefaultProduct=0, LazyProduct, AliasFreeProduct, CoeffBasedProductMode, LazyCoeffBasedProductMode, OuterProduct, InnerProduct, GemvProduct, GemmProduct };
+
+/** \internal \ingroup enums
+  * Enum used in experimental parallel implementation. */
+enum Action {GetAction, SetAction};
+
+/** The type used to identify a dense storage. */
+struct Dense {};
+
+/** The type used to identify a general sparse storage. */
+struct Sparse {};
+
+/** The type used to identify a general solver (factored) storage. */
+struct SolverStorage {};
+
+/** The type used to identify a permutation storage. */
+struct PermutationStorage {};
+
+/** The type used to identify a permutation storage. */
+struct TranspositionsStorage {};
+
+/** The type used to identify a matrix expression */
+struct MatrixXpr {};
+
+/** The type used to identify an array expression */
+struct ArrayXpr {};
+
+// An evaluator must define its shape. By default, it can be one of the following:
+struct DenseShape             { static std::string debugName() { return "DenseShape"; } };
+struct SolverShape            { static std::string debugName() { return "SolverShape"; } };
+struct HomogeneousShape       { static std::string debugName() { return "HomogeneousShape"; } };
+struct DiagonalShape          { static std::string debugName() { return "DiagonalShape"; } };
+struct BandShape              { static std::string debugName() { return "BandShape"; } };
+struct TriangularShape        { static std::string debugName() { return "TriangularShape"; } };
+struct SelfAdjointShape       { static std::string debugName() { return "SelfAdjointShape"; } };
+struct PermutationShape       { static std::string debugName() { return "PermutationShape"; } };
+struct TranspositionsShape    { static std::string debugName() { return "TranspositionsShape"; } };
+struct SparseShape            { static std::string debugName() { return "SparseShape"; } };
+
+namespace internal {
+
+  // random access iterators based on coeff*() accessors.
+struct IndexBased {};
+
+// evaluator based on iterators to access coefficients. 
+struct IteratorBased {};
+
+/** \internal
+ * Constants for comparison functors
+ */
+enum ComparisonName {
+  cmp_EQ = 0,
+  cmp_LT = 1,
+  cmp_LE = 2,
+  cmp_UNORD = 3,
+  cmp_NEQ = 4,
+  cmp_GT = 5,
+  cmp_GE = 6
+};
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_CONSTANTS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/DisableStupidWarnings.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/DisableStupidWarnings.h
new file mode 100644
index 00000000..8ef0f359
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/DisableStupidWarnings.h
@@ -0,0 +1,79 @@
+#ifndef EIGEN_WARNINGS_DISABLED
+#define EIGEN_WARNINGS_DISABLED
+
+#ifdef _MSC_VER
+  // 4100 - unreferenced formal parameter (occurred e.g. in aligned_allocator::destroy(pointer p))
+  // 4101 - unreferenced local variable
+  // 4181 - qualifier applied to reference type ignored
+  // 4211 - nonstandard extension used : redefined extern to static
+  // 4244 - 'argument' : conversion from 'type1' to 'type2', possible loss of data
+  // 4273 - QtAlignedMalloc, inconsistent DLL linkage
+  // 4324 - structure was padded due to declspec(align())
+  // 4503 - decorated name length exceeded, name was truncated
+  // 4512 - assignment operator could not be generated
+  // 4522 - 'class' : multiple assignment operators specified
+  // 4700 - uninitialized local variable 'xyz' used
+  // 4714 - function marked as __forceinline not inlined
+  // 4717 - 'function' : recursive on all control paths, function will cause runtime stack overflow
+  // 4800 - 'type' : forcing value to bool 'true' or 'false' (performance warning)
+  #ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS
+    #pragma warning( push )
+  #endif
+  #pragma warning( disable : 4100 4101 4181 4211 4244 4273 4324 4503 4512 4522 4700 4714 4717 4800)
+
+#elif defined __INTEL_COMPILER
+  // 2196 - routine is both "inline" and "noinline" ("noinline" assumed)
+  //        ICC 12 generates this warning even without any inline keyword, when defining class methods 'inline' i.e. inside of class body
+  //        typedef that may be a reference type.
+  // 279  - controlling expression is constant
+  //        ICC 12 generates this warning on assert(constant_expression_depending_on_template_params) and frankly this is a legitimate use case.
+  // 1684 - conversion from pointer to same-sized integral type (potential portability problem)
+  // 2259 - non-pointer conversion from "Eigen::Index={ptrdiff_t={long}}" to "int" may lose significant bits
+  #ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS
+    #pragma warning push
+  #endif
+  #pragma warning disable 2196 279 1684 2259
+
+#elif defined __clang__
+  // -Wconstant-logical-operand - warning: use of logical && with constant operand; switch to bitwise & or remove constant
+  //     this is really a stupid warning as it warns on compile-time expressions involving enums
+  #ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS
+    #pragma clang diagnostic push
+  #endif
+  #pragma clang diagnostic ignored "-Wconstant-logical-operand"
+  #if __clang_major__ >= 3 && __clang_minor__ >= 5
+    #pragma clang diagnostic ignored "-Wabsolute-value"
+  #endif
+
+#elif defined __GNUC__ && __GNUC__>=6
+
+  #ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS
+    #pragma GCC diagnostic push
+  #endif
+  #pragma GCC diagnostic ignored "-Wignored-attributes"
+
+#endif
+
+#if defined __NVCC__
+  #pragma diag_suppress boolean_controlling_expr_is_constant
+  // Disable the "statement is unreachable" message
+  #pragma diag_suppress code_is_unreachable
+  // Disable the "dynamic initialization in unreachable code" message
+  #pragma diag_suppress initialization_not_reachable
+  // Disable the "invalid error number" message that we get with older versions of nvcc
+  #pragma diag_suppress 1222
+  // Disable the "calling a __host__ function from a __host__ __device__ function is not allowed" messages (yes, there are many of them and they seem to change with every version of the compiler)
+  #pragma diag_suppress 2527
+  #pragma diag_suppress 2529
+  #pragma diag_suppress 2651
+  #pragma diag_suppress 2653
+  #pragma diag_suppress 2668
+  #pragma diag_suppress 2669
+  #pragma diag_suppress 2670
+  #pragma diag_suppress 2671
+  #pragma diag_suppress 2735
+  #pragma diag_suppress 2737
+  #pragma diag_suppress 2739
+#endif
+
+#endif // not EIGEN_WARNINGS_DISABLED
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/ForwardDeclarations.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/ForwardDeclarations.h
new file mode 100644
index 00000000..1a48cff0
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/ForwardDeclarations.h
@@ -0,0 +1,303 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_FORWARDDECLARATIONS_H
+#define EIGEN_FORWARDDECLARATIONS_H
+
+namespace Eigen {
+namespace internal {
+
+template<typename T> struct traits;
+
+// here we say once and for all that traits<const T> == traits<T>
+// When constness must affect traits, it has to be constness on template parameters on which T itself depends.
+// For example, traits<Map<const T> > != traits<Map<T> >, but
+//              traits<const Map<T> > == traits<Map<T> >
+template<typename T> struct traits<const T> : traits<T> {};
+
+template<typename Derived> struct has_direct_access
+{
+  enum { ret = (traits<Derived>::Flags & DirectAccessBit) ? 1 : 0 };
+};
+
+template<typename Derived> struct accessors_level
+{
+  enum { has_direct_access = (traits<Derived>::Flags & DirectAccessBit) ? 1 : 0,
+         has_write_access = (traits<Derived>::Flags & LvalueBit) ? 1 : 0,
+         value = has_direct_access ? (has_write_access ? DirectWriteAccessors : DirectAccessors)
+                                   : (has_write_access ? WriteAccessors       : ReadOnlyAccessors)
+  };
+};
+
+template<typename T> struct evaluator_traits;
+
+template< typename T> struct evaluator;
+
+} // end namespace internal
+
+template<typename T> struct NumTraits;
+
+template<typename Derived> struct EigenBase;
+template<typename Derived> class DenseBase;
+template<typename Derived> class PlainObjectBase;
+
+
+template<typename Derived,
+         int Level = internal::accessors_level<Derived>::value >
+class DenseCoeffsBase;
+
+template<typename _Scalar, int _Rows, int _Cols,
+         int _Options = AutoAlign |
+#if EIGEN_GNUC_AT(3,4)
+    // workaround a bug in at least gcc 3.4.6
+    // the innermost ?: ternary operator is misparsed. We write it slightly
+    // differently and this makes gcc 3.4.6 happy, but it's ugly.
+    // The error would only show up with EIGEN_DEFAULT_TO_ROW_MAJOR is defined
+    // (when EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION is RowMajor)
+                          ( (_Rows==1 && _Cols!=1) ? Eigen::RowMajor
+                          : !(_Cols==1 && _Rows!=1) ?  EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION
+                          : Eigen::ColMajor ),
+#else
+                          ( (_Rows==1 && _Cols!=1) ? Eigen::RowMajor
+                          : (_Cols==1 && _Rows!=1) ? Eigen::ColMajor
+                          : EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION ),
+#endif
+         int _MaxRows = _Rows,
+         int _MaxCols = _Cols
+> class Matrix;
+
+template<typename Derived> class MatrixBase;
+template<typename Derived> class ArrayBase;
+
+template<typename ExpressionType, unsigned int Added, unsigned int Removed> class Flagged;
+template<typename ExpressionType, template <typename> class StorageBase > class NoAlias;
+template<typename ExpressionType> class NestByValue;
+template<typename ExpressionType> class ForceAlignedAccess;
+template<typename ExpressionType> class SwapWrapper;
+
+template<typename XprType, int BlockRows=Dynamic, int BlockCols=Dynamic, bool InnerPanel = false> class Block;
+template<typename XprType, typename RowIndices, typename ColIndices> class IndexedView;
+
+template<typename MatrixType, int Size=Dynamic> class VectorBlock;
+template<typename MatrixType> class Transpose;
+template<typename MatrixType> class Conjugate;
+template<typename NullaryOp, typename MatrixType>         class CwiseNullaryOp;
+template<typename UnaryOp,   typename MatrixType>         class CwiseUnaryOp;
+template<typename ViewOp,    typename MatrixType>         class CwiseUnaryView;
+template<typename BinaryOp,  typename Lhs, typename Rhs>  class CwiseBinaryOp;
+template<typename TernaryOp, typename Arg1, typename Arg2, typename Arg3>  class CwiseTernaryOp;
+template<typename Decomposition, typename Rhstype>        class Solve;
+template<typename XprType>                                class Inverse;
+
+template<typename Lhs, typename Rhs, int Option = DefaultProduct> class Product;
+
+template<typename Derived> class DiagonalBase;
+template<typename _DiagonalVectorType> class DiagonalWrapper;
+template<typename _Scalar, int SizeAtCompileTime, int MaxSizeAtCompileTime=SizeAtCompileTime> class DiagonalMatrix;
+template<typename MatrixType, typename DiagonalType, int ProductOrder> class DiagonalProduct;
+template<typename MatrixType, int Index = 0> class Diagonal;
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime, typename IndexType=int> class PermutationMatrix;
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime, typename IndexType=int> class Transpositions;
+template<typename Derived> class PermutationBase;
+template<typename Derived> class TranspositionsBase;
+template<typename _IndicesType> class PermutationWrapper;
+template<typename _IndicesType> class TranspositionsWrapper;
+
+template<typename Derived,
+         int Level = internal::accessors_level<Derived>::has_write_access ? WriteAccessors : ReadOnlyAccessors
+> class MapBase;
+template<int InnerStrideAtCompileTime, int OuterStrideAtCompileTime> class Stride;
+template<int Value = Dynamic> class InnerStride;
+template<int Value = Dynamic> class OuterStride;
+template<typename MatrixType, int MapOptions=Unaligned, typename StrideType = Stride<0,0> > class Map;
+template<typename Derived> class RefBase;
+template<typename PlainObjectType, int Options = 0,
+         typename StrideType = typename internal::conditional<PlainObjectType::IsVectorAtCompileTime,InnerStride<1>,OuterStride<> >::type > class Ref;
+
+template<typename Derived> class TriangularBase;
+template<typename MatrixType, unsigned int Mode> class TriangularView;
+template<typename MatrixType, unsigned int Mode> class SelfAdjointView;
+template<typename MatrixType> class SparseView;
+template<typename ExpressionType> class WithFormat;
+template<typename MatrixType> struct CommaInitializer;
+template<typename Derived> class ReturnByValue;
+template<typename ExpressionType> class ArrayWrapper;
+template<typename ExpressionType> class MatrixWrapper;
+template<typename Derived> class SolverBase;
+template<typename XprType> class InnerIterator;
+
+namespace internal {
+template<typename DecompositionType> struct kernel_retval_base;
+template<typename DecompositionType> struct kernel_retval;
+template<typename DecompositionType> struct image_retval_base;
+template<typename DecompositionType> struct image_retval;
+} // end namespace internal
+
+namespace internal {
+template<typename _Scalar, int Rows=Dynamic, int Cols=Dynamic, int Supers=Dynamic, int Subs=Dynamic, int Options=0> class BandMatrix;
+}
+
+namespace internal {
+template<typename Lhs, typename Rhs> struct product_type;
+
+template<bool> struct EnableIf;
+
+/** \internal
+  * \class product_evaluator
+  * Products need their own evaluator with more template arguments allowing for
+  * easier partial template specializations.
+  */
+template< typename T,
+          int ProductTag = internal::product_type<typename T::Lhs,typename T::Rhs>::ret,
+          typename LhsShape = typename evaluator_traits<typename T::Lhs>::Shape,
+          typename RhsShape = typename evaluator_traits<typename T::Rhs>::Shape,
+          typename LhsScalar = typename traits<typename T::Lhs>::Scalar,
+          typename RhsScalar = typename traits<typename T::Rhs>::Scalar
+        > struct product_evaluator;
+}
+
+template<typename Lhs, typename Rhs,
+         int ProductType = internal::product_type<Lhs,Rhs>::value>
+struct ProductReturnType;
+
+// this is a workaround for sun CC
+template<typename Lhs, typename Rhs> struct LazyProductReturnType;
+
+namespace internal {
+
+// Provides scalar/packet-wise product and product with accumulation
+// with optional conjugation of the arguments.
+template<typename LhsScalar, typename RhsScalar, bool ConjLhs=false, bool ConjRhs=false> struct conj_helper;
+
+template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_sum_op;
+template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_difference_op;
+template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_conj_product_op;
+template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_min_op;
+template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_max_op;
+template<typename Scalar> struct scalar_opposite_op;
+template<typename Scalar> struct scalar_conjugate_op;
+template<typename Scalar> struct scalar_real_op;
+template<typename Scalar> struct scalar_imag_op;
+template<typename Scalar> struct scalar_abs_op;
+template<typename Scalar> struct scalar_abs2_op;
+template<typename Scalar> struct scalar_sqrt_op;
+template<typename Scalar> struct scalar_rsqrt_op;
+template<typename Scalar> struct scalar_exp_op;
+template<typename Scalar> struct scalar_log_op;
+template<typename Scalar> struct scalar_cos_op;
+template<typename Scalar> struct scalar_sin_op;
+template<typename Scalar> struct scalar_acos_op;
+template<typename Scalar> struct scalar_asin_op;
+template<typename Scalar> struct scalar_tan_op;
+template<typename Scalar> struct scalar_inverse_op;
+template<typename Scalar> struct scalar_square_op;
+template<typename Scalar> struct scalar_cube_op;
+template<typename Scalar, typename NewType> struct scalar_cast_op;
+template<typename Scalar> struct scalar_random_op;
+template<typename Scalar> struct scalar_constant_op;
+template<typename Scalar> struct scalar_identity_op;
+template<typename Scalar,bool iscpx> struct scalar_sign_op;
+template<typename Scalar,typename ScalarExponent> struct scalar_pow_op;
+template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_hypot_op;
+template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_product_op;
+template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_quotient_op;
+
+// SpecialFunctions module
+template<typename Scalar> struct scalar_lgamma_op;
+template<typename Scalar> struct scalar_digamma_op;
+template<typename Scalar> struct scalar_erf_op;
+template<typename Scalar> struct scalar_erfc_op;
+template<typename Scalar> struct scalar_igamma_op;
+template<typename Scalar> struct scalar_igammac_op;
+template<typename Scalar> struct scalar_zeta_op;
+template<typename Scalar> struct scalar_betainc_op;
+
+} // end namespace internal
+
+struct IOFormat;
+
+// Array module
+template<typename _Scalar, int _Rows, int _Cols,
+         int _Options = AutoAlign |
+#if EIGEN_GNUC_AT(3,4)
+    // workaround a bug in at least gcc 3.4.6
+    // the innermost ?: ternary operator is misparsed. We write it slightly
+    // differently and this makes gcc 3.4.6 happy, but it's ugly.
+    // The error would only show up with EIGEN_DEFAULT_TO_ROW_MAJOR is defined
+    // (when EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION is RowMajor)
+                          ( (_Rows==1 && _Cols!=1) ? Eigen::RowMajor
+                          : !(_Cols==1 && _Rows!=1) ?  EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION
+                          : Eigen::ColMajor ),
+#else
+                          ( (_Rows==1 && _Cols!=1) ? Eigen::RowMajor
+                          : (_Cols==1 && _Rows!=1) ? Eigen::ColMajor
+                          : EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION ),
+#endif
+         int _MaxRows = _Rows, int _MaxCols = _Cols> class Array;
+template<typename ConditionMatrixType, typename ThenMatrixType, typename ElseMatrixType> class Select;
+template<typename MatrixType, typename BinaryOp, int Direction> class PartialReduxExpr;
+template<typename ExpressionType, int Direction> class VectorwiseOp;
+template<typename MatrixType,int RowFactor,int ColFactor> class Replicate;
+template<typename MatrixType, int Direction = BothDirections> class Reverse;
+
+template<typename MatrixType> class FullPivLU;
+template<typename MatrixType> class PartialPivLU;
+namespace internal {
+template<typename MatrixType> struct inverse_impl;
+}
+template<typename MatrixType> class HouseholderQR;
+template<typename MatrixType> class ColPivHouseholderQR;
+template<typename MatrixType> class FullPivHouseholderQR;
+template<typename MatrixType> class CompleteOrthogonalDecomposition;
+template<typename MatrixType, int QRPreconditioner = ColPivHouseholderQRPreconditioner> class JacobiSVD;
+template<typename MatrixType> class BDCSVD;
+template<typename MatrixType, int UpLo = Lower> class LLT;
+template<typename MatrixType, int UpLo = Lower> class LDLT;
+template<typename VectorsType, typename CoeffsType, int Side=OnTheLeft> class HouseholderSequence;
+template<typename Scalar>     class JacobiRotation;
+
+// Geometry module:
+template<typename Derived, int _Dim> class RotationBase;
+template<typename Lhs, typename Rhs> class Cross;
+template<typename Derived> class QuaternionBase;
+template<typename Scalar> class Rotation2D;
+template<typename Scalar> class AngleAxis;
+template<typename Scalar,int Dim> class Translation;
+template<typename Scalar,int Dim> class AlignedBox;
+template<typename Scalar, int Options = AutoAlign> class Quaternion;
+template<typename Scalar,int Dim,int Mode,int _Options=AutoAlign> class Transform;
+template <typename _Scalar, int _AmbientDim, int Options=AutoAlign> class ParametrizedLine;
+template <typename _Scalar, int _AmbientDim, int Options=AutoAlign> class Hyperplane;
+template<typename Scalar> class UniformScaling;
+template<typename MatrixType,int Direction> class Homogeneous;
+
+// Sparse module:
+template<typename Derived> class SparseMatrixBase;
+
+// MatrixFunctions module
+template<typename Derived> struct MatrixExponentialReturnValue;
+template<typename Derived> class MatrixFunctionReturnValue;
+template<typename Derived> class MatrixSquareRootReturnValue;
+template<typename Derived> class MatrixLogarithmReturnValue;
+template<typename Derived> class MatrixPowerReturnValue;
+template<typename Derived> class MatrixComplexPowerReturnValue;
+
+namespace internal {
+template <typename Scalar>
+struct stem_function
+{
+  typedef std::complex<typename NumTraits<Scalar>::Real> ComplexScalar;
+  typedef ComplexScalar type(ComplexScalar, int);
+};
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_FORWARDDECLARATIONS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/IndexedViewHelper.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/IndexedViewHelper.h
new file mode 100644
index 00000000..ab01c857
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/IndexedViewHelper.h
@@ -0,0 +1,187 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2017 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+#ifndef EIGEN_INDEXED_VIEW_HELPER_H
+#define EIGEN_INDEXED_VIEW_HELPER_H
+
+namespace Eigen {
+
+/** \namespace Eigen::placeholders
+  * \ingroup Core_Module
+  *
+  * Namespace containing symbolic placeholder and identifiers
+  */
+namespace placeholders {
+
+namespace internal {
+struct symbolic_last_tag {};
+}
+
+/** \var last
+  * \ingroup Core_Module
+  *
+  * Can be used as a parameter to Eigen::seq and Eigen::seqN functions to symbolically reference the last element/row/columns
+  * of the underlying vector or matrix once passed to DenseBase::operator()(const RowIndices&, const ColIndices&).
+  *
+  * This symbolic placeholder support standard arithmetic operation.
+  *
+  * A typical usage example would be:
+  * \code
+  * using namespace Eigen;
+  * using Eigen::placeholders::last;
+  * VectorXd v(n);
+  * v(seq(2,last-2)).setOnes();
+  * \endcode
+  *
+  * \sa end
+  */
+static const Symbolic::SymbolExpr<internal::symbolic_last_tag> last;
+
+/** \var end
+  * \ingroup Core_Module
+  *
+  * Can be used as a parameter to Eigen::seq and Eigen::seqN functions to symbolically reference the last+1 element/row/columns
+  * of the underlying vector or matrix once passed to DenseBase::operator()(const RowIndices&, const ColIndices&).
+  *
+  * This symbolic placeholder support standard arithmetic operation.
+  * It is essentially an alias to last+1
+  *
+  * \sa last
+  */
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+static const auto end = last+1;
+#else
+// Using a FixedExpr<1> expression is important here to make sure the compiler
+// can fully optimize the computation starting indices with zero overhead.
+static const Symbolic::AddExpr<Symbolic::SymbolExpr<internal::symbolic_last_tag>,Symbolic::ValueExpr<Eigen::internal::FixedInt<1> > > end(last+fix<1>());
+#endif
+
+} // end namespace placeholders
+
+namespace internal {
+
+ // Replace symbolic last/end "keywords" by their true runtime value
+inline Index eval_expr_given_size(Index x, Index /* size */)   { return x; }
+
+template<int N>
+FixedInt<N> eval_expr_given_size(FixedInt<N> x, Index /*size*/)   { return x; }
+
+template<typename Derived>
+Index eval_expr_given_size(const Symbolic::BaseExpr<Derived> &x, Index size)
+{
+  return x.derived().eval(placeholders::last=size-1);
+}
+
+// Extract increment/step at compile time
+template<typename T, typename EnableIf = void> struct get_compile_time_incr {
+  enum { value = UndefinedIncr };
+};
+
+// Analogue of std::get<0>(x), but tailored for our needs.
+template<typename T>
+Index first(const T& x) { return x.first(); }
+
+// IndexedViewCompatibleType/makeIndexedViewCompatible turn an arbitrary object of type T into something usable by MatrixSlice
+// The generic implementation is a no-op
+template<typename T,int XprSize,typename EnableIf=void>
+struct IndexedViewCompatibleType {
+  typedef T type;
+};
+
+template<typename T,typename Q>
+const T& makeIndexedViewCompatible(const T& x, Index /*size*/, Q) { return x; }
+
+//--------------------------------------------------------------------------------
+// Handling of a single Index
+//--------------------------------------------------------------------------------
+
+struct SingleRange {
+  enum {
+    SizeAtCompileTime = 1
+  };
+  SingleRange(Index val) : m_value(val) {}
+  Index operator[](Index) const { return m_value; }
+  Index size() const { return 1; }
+  Index first() const { return m_value; }
+  Index m_value;
+};
+
+template<> struct get_compile_time_incr<SingleRange> {
+  enum { value = 1 }; // 1 or 0 ??
+};
+
+// Turn a single index into something that looks like an array (i.e., that exposes a .size(), and operatro[](int) methods)
+template<typename T, int XprSize>
+struct IndexedViewCompatibleType<T,XprSize,typename internal::enable_if<internal::is_integral<T>::value>::type> {
+  // Here we could simply use Array, but maybe it's less work for the compiler to use
+  // a simpler wrapper as SingleRange
+  //typedef Eigen::Array<Index,1,1> type;
+  typedef SingleRange type;
+};
+
+template<typename T, int XprSize>
+struct IndexedViewCompatibleType<T, XprSize, typename enable_if<Symbolic::is_symbolic<T>::value>::type> {
+  typedef SingleRange type;
+};
+
+
+template<typename T>
+typename enable_if<Symbolic::is_symbolic<T>::value,SingleRange>::type
+makeIndexedViewCompatible(const T& id, Index size, SpecializedType) {
+  return eval_expr_given_size(id,size);
+}
+
+//--------------------------------------------------------------------------------
+// Handling of all
+//--------------------------------------------------------------------------------
+
+struct all_t { all_t() {} };
+
+// Convert a symbolic 'all' into a usable range type
+template<int XprSize>
+struct AllRange {
+  enum { SizeAtCompileTime = XprSize };
+  AllRange(Index size = XprSize) : m_size(size) {}
+  Index operator[](Index i) const { return i; }
+  Index size() const { return m_size.value(); }
+  Index first() const { return 0; }
+  variable_if_dynamic<Index,XprSize> m_size;
+};
+
+template<int XprSize>
+struct IndexedViewCompatibleType<all_t,XprSize> {
+  typedef AllRange<XprSize> type;
+};
+
+template<typename XprSizeType>
+inline AllRange<get_fixed_value<XprSizeType>::value> makeIndexedViewCompatible(all_t , XprSizeType size, SpecializedType) {
+  return AllRange<get_fixed_value<XprSizeType>::value>(size);
+}
+
+template<int Size> struct get_compile_time_incr<AllRange<Size> > {
+  enum { value = 1 };
+};
+
+} // end namespace internal
+
+
+namespace placeholders {
+
+/** \var all
+  * \ingroup Core_Module
+  * Can be used as a parameter to DenseBase::operator()(const RowIndices&, const ColIndices&) to index all rows or columns
+  */
+static const Eigen::internal::all_t all;
+
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_INDEXED_VIEW_HELPER_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/IntegralConstant.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/IntegralConstant.h
new file mode 100644
index 00000000..78a4705c
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/IntegralConstant.h
@@ -0,0 +1,270 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2017 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+#ifndef EIGEN_INTEGRAL_CONSTANT_H
+#define EIGEN_INTEGRAL_CONSTANT_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<int N> class FixedInt;
+template<int N> class VariableAndFixedInt;
+
+/** \internal
+  * \class FixedInt
+  *
+  * This class embeds a compile-time integer \c N.
+  *
+  * It is similar to c++11 std::integral_constant<int,N> but with some additional features
+  * such as:
+  *  - implicit conversion to int
+  *  - arithmetic and some bitwise operators: -, +, *, /, %, &, |
+  *  - c++98/14 compatibility with fix<N> and fix<N>() syntax to define integral constants.
+  *
+  * It is strongly discouraged to directly deal with this class FixedInt. Instances are expcected to
+  * be created by the user using Eigen::fix<N> or Eigen::fix<N>(). In C++98-11, the former syntax does
+  * not create a FixedInt<N> instance but rather a point to function that needs to be \em cleaned-up
+  * using the generic helper:
+  * \code
+  * internal::cleanup_index_type<T>::type
+  * internal::cleanup_index_type<T,DynamicKey>::type
+  * \endcode
+  * where T can a FixedInt<N>, a pointer to function FixedInt<N> (*)(), or numerous other integer-like representations.
+  * \c DynamicKey is either Dynamic (default) or DynamicIndex and used to identify true compile-time values.
+  *
+  * For convenience, you can extract the compile-time value \c N in a generic way using the following helper:
+  * \code
+  * internal::get_fixed_value<T,DefaultVal>::value
+  * \endcode
+  * that will give you \c N if T equals FixedInt<N> or FixedInt<N> (*)(), and \c DefaultVal if T does not embed any compile-time value (e.g., T==int).
+  *
+  * \sa fix<N>, class VariableAndFixedInt
+  */
+template<int N> class FixedInt
+{
+public:
+  static const int value = N;
+  operator int() const { return value; }
+  FixedInt() {}
+  FixedInt( VariableAndFixedInt<N> other) {
+    EIGEN_ONLY_USED_FOR_DEBUG(other);
+    eigen_internal_assert(int(other)==N);
+  }
+
+  FixedInt<-N> operator-() const { return FixedInt<-N>(); }
+  template<int M>
+  FixedInt<N+M> operator+( FixedInt<M>) const { return FixedInt<N+M>(); }
+  template<int M>
+  FixedInt<N-M> operator-( FixedInt<M>) const { return FixedInt<N-M>(); }
+  template<int M>
+  FixedInt<N*M> operator*( FixedInt<M>) const { return FixedInt<N*M>(); }
+  template<int M>
+  FixedInt<N/M> operator/( FixedInt<M>) const { return FixedInt<N/M>(); }
+  template<int M>
+  FixedInt<N%M> operator%( FixedInt<M>) const { return FixedInt<N%M>(); }
+  template<int M>
+  FixedInt<N|M> operator|( FixedInt<M>) const { return FixedInt<N|M>(); }
+  template<int M>
+  FixedInt<N&M> operator&( FixedInt<M>) const { return FixedInt<N&M>(); }
+
+#if EIGEN_HAS_CXX14
+  // Needed in C++14 to allow fix<N>():
+  FixedInt operator() () const { return *this; }
+
+  VariableAndFixedInt<N> operator() (int val) const { return VariableAndFixedInt<N>(val); }
+#else
+  FixedInt ( FixedInt<N> (*)() ) {}
+#endif
+
+#if EIGEN_HAS_CXX11
+  FixedInt(std::integral_constant<int,N>) {}
+#endif
+};
+
+/** \internal
+  * \class VariableAndFixedInt
+  *
+  * This class embeds both a compile-time integer \c N and a runtime integer.
+  * Both values are supposed to be equal unless the compile-time value \c N has a special
+  * value meaning that the runtime-value should be used. Depending on the context, this special
+  * value can be either Eigen::Dynamic (for positive quantities) or Eigen::DynamicIndex (for
+  * quantities that can be negative).
+  *
+  * It is the return-type of the function Eigen::fix<N>(int), and most of the time this is the only
+  * way it is used. It is strongly discouraged to directly deal with instances of VariableAndFixedInt.
+  * Indeed, in order to write generic code, it is the responsibility of the callee to properly convert
+  * it to either a true compile-time quantity (i.e. a FixedInt<N>), or to a runtime quantity (e.g., an Index)
+  * using the following generic helper:
+  * \code
+  * internal::cleanup_index_type<T>::type
+  * internal::cleanup_index_type<T,DynamicKey>::type
+  * \endcode
+  * where T can be a template instantiation of VariableAndFixedInt or numerous other integer-like representations.
+  * \c DynamicKey is either Dynamic (default) or DynamicIndex and used to identify true compile-time values.
+  *
+  * For convenience, you can also extract the compile-time value \c N using the following helper:
+  * \code
+  * internal::get_fixed_value<T,DefaultVal>::value
+  * \endcode
+  * that will give you \c N if T equals VariableAndFixedInt<N>, and \c DefaultVal if T does not embed any compile-time value (e.g., T==int).
+  *
+  * \sa fix<N>(int), class FixedInt
+  */
+template<int N> class VariableAndFixedInt
+{
+public:
+  static const int value = N;
+  operator int() const { return m_value; }
+  VariableAndFixedInt(int val) { m_value = val; }
+protected:
+  int m_value;
+};
+
+template<typename T, int Default=Dynamic> struct get_fixed_value {
+  static const int value = Default;
+};
+
+template<int N,int Default> struct get_fixed_value<FixedInt<N>,Default> {
+  static const int value = N;
+};
+
+#if !EIGEN_HAS_CXX14
+template<int N,int Default> struct get_fixed_value<FixedInt<N> (*)(),Default> {
+  static const int value = N;
+};
+#endif
+
+template<int N,int Default> struct get_fixed_value<VariableAndFixedInt<N>,Default> {
+  static const int value = N ;
+};
+
+template<typename T, int N, int Default>
+struct get_fixed_value<variable_if_dynamic<T,N>,Default> {
+  static const int value = N;
+};
+
+template<typename T> EIGEN_DEVICE_FUNC Index get_runtime_value(const T &x) { return x; }
+#if !EIGEN_HAS_CXX14
+template<int N> EIGEN_DEVICE_FUNC Index get_runtime_value(FixedInt<N> (*)()) { return N; }
+#endif
+
+// Cleanup integer/FixedInt/VariableAndFixedInt/etc types:
+
+// By default, no cleanup:
+template<typename T, int DynamicKey=Dynamic, typename EnableIf=void> struct cleanup_index_type { typedef T type; };
+
+// Convert any integral type (e.g., short, int, unsigned int, etc.) to Eigen::Index
+template<typename T, int DynamicKey> struct cleanup_index_type<T,DynamicKey,typename internal::enable_if<internal::is_integral<T>::value>::type> { typedef Index type; };
+
+#if !EIGEN_HAS_CXX14
+// In c++98/c++11, fix<N> is a pointer to function that we better cleanup to a true FixedInt<N>:
+template<int N, int DynamicKey> struct cleanup_index_type<FixedInt<N> (*)(), DynamicKey> { typedef FixedInt<N> type; };
+#endif
+
+// If VariableAndFixedInt does not match DynamicKey, then we turn it to a pure compile-time value:
+template<int N, int DynamicKey> struct cleanup_index_type<VariableAndFixedInt<N>, DynamicKey> { typedef FixedInt<N> type; };
+// If VariableAndFixedInt matches DynamicKey, then we turn it to a pure runtime-value (aka Index):
+template<int DynamicKey> struct cleanup_index_type<VariableAndFixedInt<DynamicKey>, DynamicKey> { typedef Index type; };
+
+#if EIGEN_HAS_CXX11
+template<int N, int DynamicKey> struct cleanup_index_type<std::integral_constant<int,N>, DynamicKey> { typedef FixedInt<N> type; };
+#endif
+
+} // end namespace internal
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+
+#if EIGEN_HAS_CXX14
+template<int N>
+static const internal::FixedInt<N> fix{};
+#else
+template<int N>
+inline internal::FixedInt<N> fix() { return internal::FixedInt<N>(); }
+
+// The generic typename T is mandatory. Otherwise, a code like fix<N> could refer to either the function above or this next overload.
+// This way a code like fix<N> can only refer to the previous function.
+template<int N,typename T>
+inline internal::VariableAndFixedInt<N> fix(T val) { return internal::VariableAndFixedInt<N>(val); }
+#endif
+
+#else // EIGEN_PARSED_BY_DOXYGEN
+
+/** \var fix<N>()
+  * \ingroup Core_Module
+  *
+  * This \em identifier permits to construct an object embedding a compile-time integer \c N.
+  *
+  * \tparam N the compile-time integer value
+  *
+  * It is typically used in conjunction with the Eigen::seq and Eigen::seqN functions to pass compile-time values to them:
+  * \code
+  * seqN(10,fix<4>,fix<-3>)   // <=> [10 7 4 1]
+  * \endcode
+  *
+  * See also the function fix(int) to pass both a compile-time and runtime value.
+  *
+  * In c++14, it is implemented as:
+  * \code
+  * template<int N> static const internal::FixedInt<N> fix{};
+  * \endcode
+  * where internal::FixedInt<N> is an internal template class similar to
+  * <a href="http://en.cppreference.com/w/cpp/types/integral_constant">\c std::integral_constant </a><tt> <int,N> </tt>
+  * Here, \c fix<N> is thus an object of type \c internal::FixedInt<N>.
+  *
+  * In c++98/11, it is implemented as a function:
+  * \code
+  * template<int N> inline internal::FixedInt<N> fix();
+  * \endcode
+  * Here internal::FixedInt<N> is thus a pointer to function.
+  *
+  * If for some reason you want a true object in c++98 then you can write: \code fix<N>() \endcode which is also valid in c++14.
+  *
+  * \sa fix<N>(int), seq, seqN
+  */
+template<int N>
+static const auto fix();
+
+/** \fn fix<N>(int)
+  * \ingroup Core_Module
+  *
+  * This function returns an object embedding both a compile-time integer \c N, and a fallback runtime value \a val.
+  *
+  * \tparam N the compile-time integer value
+  * \param  val the fallback runtime integer value
+  *
+  * This function is a more general version of the \ref fix identifier/function that can be used in template code
+  * where the compile-time value could turn out to actually mean "undefined at compile-time". For positive integers
+  * such as a size or a dimension, this case is identified by Eigen::Dynamic, whereas runtime signed integers
+  * (e.g., an increment/stride) are identified as Eigen::DynamicIndex. In such a case, the runtime value \a val
+  * will be used as a fallback.
+  *
+  * A typical use case would be:
+  * \code
+  * template<typename Derived> void foo(const MatrixBase<Derived> &mat) {
+  *   const int N = Derived::RowsAtCompileTime==Dynamic ? Dynamic : Derived::RowsAtCompileTime/2;
+  *   const int n = mat.rows()/2;
+  *   ... mat( seqN(0,fix<N>(n) ) ...;
+  * }
+  * \endcode
+  * In this example, the function Eigen::seqN knows that the second argument is expected to be a size.
+  * If the passed compile-time value N equals Eigen::Dynamic, then the proxy object returned by fix will be dissmissed, and converted to an Eigen::Index of value \c n.
+  * Otherwise, the runtime-value \c n will be dissmissed, and the returned ArithmeticSequence will be of the exact same type as <tt> seqN(0,fix<N>) </tt>.
+  *
+  * \sa fix, seqN, class ArithmeticSequence
+  */
+template<int N>
+static const auto fix(int val);
+
+#endif // EIGEN_PARSED_BY_DOXYGEN
+
+} // end namespace Eigen
+
+#endif // EIGEN_INTEGRAL_CONSTANT_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/MKL_support.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/MKL_support.h
new file mode 100644
index 00000000..b7d6ecc7
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/MKL_support.h
@@ -0,0 +1,130 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to Intel(R) MKL
+ *   Include file with common MKL declarations
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_MKL_SUPPORT_H
+#define EIGEN_MKL_SUPPORT_H
+
+#ifdef EIGEN_USE_MKL_ALL
+  #ifndef EIGEN_USE_BLAS
+    #define EIGEN_USE_BLAS
+  #endif
+  #ifndef EIGEN_USE_LAPACKE
+    #define EIGEN_USE_LAPACKE
+  #endif
+  #ifndef EIGEN_USE_MKL_VML
+    #define EIGEN_USE_MKL_VML
+  #endif
+#endif
+
+#ifdef EIGEN_USE_LAPACKE_STRICT
+  #define EIGEN_USE_LAPACKE
+#endif
+
+#if defined(EIGEN_USE_MKL_VML) && !defined(EIGEN_USE_MKL)
+  #define EIGEN_USE_MKL
+#endif
+
+
+#if defined EIGEN_USE_MKL
+#   include <mkl.h> 
+/*Check IMKL version for compatibility: < 10.3 is not usable with Eigen*/
+#   ifndef INTEL_MKL_VERSION
+#       undef EIGEN_USE_MKL /* INTEL_MKL_VERSION is not even defined on older versions */
+#   elif INTEL_MKL_VERSION < 100305    /* the intel-mkl-103-release-notes say this was when the lapacke.h interface was added*/
+#       undef EIGEN_USE_MKL
+#   endif
+#   ifndef EIGEN_USE_MKL
+    /*If the MKL version is too old, undef everything*/
+#       undef   EIGEN_USE_MKL_ALL
+#       undef   EIGEN_USE_LAPACKE
+#       undef   EIGEN_USE_MKL_VML
+#       undef   EIGEN_USE_LAPACKE_STRICT
+#       undef   EIGEN_USE_LAPACKE
+#   endif
+#endif
+
+#if defined EIGEN_USE_MKL
+
+#define EIGEN_MKL_VML_THRESHOLD 128
+
+/* MKL_DOMAIN_BLAS, etc are defined only in 10.3 update 7 */
+/* MKL_BLAS, etc are not defined in 11.2 */
+#ifdef MKL_DOMAIN_ALL
+#define EIGEN_MKL_DOMAIN_ALL MKL_DOMAIN_ALL
+#else
+#define EIGEN_MKL_DOMAIN_ALL MKL_ALL
+#endif
+
+#ifdef MKL_DOMAIN_BLAS
+#define EIGEN_MKL_DOMAIN_BLAS MKL_DOMAIN_BLAS
+#else
+#define EIGEN_MKL_DOMAIN_BLAS MKL_BLAS
+#endif
+
+#ifdef MKL_DOMAIN_FFT
+#define EIGEN_MKL_DOMAIN_FFT MKL_DOMAIN_FFT
+#else
+#define EIGEN_MKL_DOMAIN_FFT MKL_FFT
+#endif
+
+#ifdef MKL_DOMAIN_VML
+#define EIGEN_MKL_DOMAIN_VML MKL_DOMAIN_VML
+#else
+#define EIGEN_MKL_DOMAIN_VML MKL_VML
+#endif
+
+#ifdef MKL_DOMAIN_PARDISO
+#define EIGEN_MKL_DOMAIN_PARDISO MKL_DOMAIN_PARDISO
+#else
+#define EIGEN_MKL_DOMAIN_PARDISO MKL_PARDISO
+#endif
+#endif
+
+#if defined(EIGEN_USE_BLAS) && !defined(EIGEN_USE_MKL)
+#include "../../misc/blas.h"
+#endif
+
+namespace Eigen {
+
+typedef std::complex<double> dcomplex;
+typedef std::complex<float>  scomplex;
+
+#if defined(EIGEN_USE_MKL)
+typedef MKL_INT BlasIndex;
+#else
+typedef int BlasIndex;
+#endif
+
+} // end namespace Eigen
+
+
+#endif // EIGEN_MKL_SUPPORT_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/Macros.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/Macros.h
new file mode 100644
index 00000000..46b2659b
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/Macros.h
@@ -0,0 +1,1046 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MACROS_H
+#define EIGEN_MACROS_H
+
+#define EIGEN_WORLD_VERSION 3
+#define EIGEN_MAJOR_VERSION 3
+#define EIGEN_MINOR_VERSION 90
+
+#define EIGEN_VERSION_AT_LEAST(x,y,z) (EIGEN_WORLD_VERSION>x || (EIGEN_WORLD_VERSION>=x && \
+                                      (EIGEN_MAJOR_VERSION>y || (EIGEN_MAJOR_VERSION>=y && \
+                                                                 EIGEN_MINOR_VERSION>=z))))
+
+// Compiler identification, EIGEN_COMP_*
+
+/// \internal EIGEN_COMP_GNUC set to 1 for all compilers compatible with GCC
+#ifdef __GNUC__
+  #define EIGEN_COMP_GNUC (__GNUC__*10+__GNUC_MINOR__)
+#else
+  #define EIGEN_COMP_GNUC 0
+#endif
+
+/// \internal EIGEN_COMP_CLANG set to major+minor version (e.g., 307 for clang 3.7) if the compiler is clang
+#if defined(__clang__)
+  #define EIGEN_COMP_CLANG (__clang_major__*100+__clang_minor__)
+#else
+  #define EIGEN_COMP_CLANG 0
+#endif
+
+/// \internal EIGEN_COMP_LLVM set to 1 if the compiler backend is llvm
+#if defined(__llvm__)
+  #define EIGEN_COMP_LLVM 1
+#else
+  #define EIGEN_COMP_LLVM 0
+#endif
+
+/// \internal EIGEN_COMP_ICC set to __INTEL_COMPILER if the compiler is Intel compiler, 0 otherwise
+#if defined(__INTEL_COMPILER)
+  #define EIGEN_COMP_ICC __INTEL_COMPILER
+#else
+  #define EIGEN_COMP_ICC 0
+#endif
+
+/// \internal EIGEN_COMP_MINGW set to 1 if the compiler is mingw
+#if defined(__MINGW32__)
+  #define EIGEN_COMP_MINGW 1
+#else
+  #define EIGEN_COMP_MINGW 0
+#endif
+
+/// \internal EIGEN_COMP_SUNCC set to 1 if the compiler is Solaris Studio
+#if defined(__SUNPRO_CC)
+  #define EIGEN_COMP_SUNCC 1
+#else
+  #define EIGEN_COMP_SUNCC 0
+#endif
+
+/// \internal EIGEN_COMP_MSVC set to _MSC_VER if the compiler is Microsoft Visual C++, 0 otherwise.
+#if defined(_MSC_VER)
+  #define EIGEN_COMP_MSVC _MSC_VER
+#else
+  #define EIGEN_COMP_MSVC 0
+#endif
+
+// For the record, here is a table summarizing the possible values for EIGEN_COMP_MSVC:
+//  name  ver   MSC_VER
+//  2008    9      1500
+//  2010   10      1600
+//  2012   11      1700
+//  2013   12      1800
+//  2015   14      1900
+//  "15"   15      1900
+
+/// \internal EIGEN_COMP_MSVC_STRICT set to 1 if the compiler is really Microsoft Visual C++ and not ,e.g., ICC or clang-cl
+#if EIGEN_COMP_MSVC && !(EIGEN_COMP_ICC || EIGEN_COMP_LLVM || EIGEN_COMP_CLANG)
+  #define EIGEN_COMP_MSVC_STRICT _MSC_VER
+#else
+  #define EIGEN_COMP_MSVC_STRICT 0
+#endif
+
+/// \internal EIGEN_COMP_IBM set to 1 if the compiler is IBM XL C++
+#if defined(__IBMCPP__) || defined(__xlc__)
+  #define EIGEN_COMP_IBM 1
+#else
+  #define EIGEN_COMP_IBM 0
+#endif
+
+/// \internal EIGEN_COMP_PGI set to 1 if the compiler is Portland Group Compiler
+#if defined(__PGI)
+  #define EIGEN_COMP_PGI 1
+#else
+  #define EIGEN_COMP_PGI 0
+#endif
+
+/// \internal EIGEN_COMP_ARM set to 1 if the compiler is ARM Compiler
+#if defined(__CC_ARM) || defined(__ARMCC_VERSION)
+  #define EIGEN_COMP_ARM 1
+#else
+  #define EIGEN_COMP_ARM 0
+#endif
+
+/// \internal EIGEN_COMP_EMSCRIPTEN set to 1 if the compiler is Emscripten Compiler
+#if defined(__EMSCRIPTEN__)
+  #define EIGEN_COMP_EMSCRIPTEN 1
+#else
+  #define EIGEN_COMP_EMSCRIPTEN 0
+#endif
+
+/// \internal EIGEN_COMP_LCC set to 1 if the compiler is LCC (Local (or Little) C Compiler)
+#if defined(__LCC__) && !(defined(__e2k__))
+  #define EIGEN_COMP_LCC 1
+#else
+  #define EIGEN_COMP_LCC 0
+#endif
+
+/// \internal EIGEN_COMP_LCC_E2K set to 1 if the compiler is LCC (MCST eLbrus C Compiler)
+#if defined(__LCC__) && defined(__e2k__)
+  #define EIGEN_COMP_LCC_E2K 1
+#else
+  #define EIGEN_COMP_LCC_E2K 0
+#endif
+
+/// \internal EIGEN_GNUC_STRICT set to 1 if the compiler is really GCC and not a compatible compiler (e.g., ICC, clang, mingw, etc.)
+#if EIGEN_COMP_GNUC && !(EIGEN_COMP_CLANG || EIGEN_COMP_ICC || EIGEN_COMP_MINGW || EIGEN_COMP_PGI || EIGEN_COMP_IBM || EIGEN_COMP_ARM || EIGEN_COMP_EMSCRIPTEN || EIGEN_COMP_LCC || EIGEN_COMP_LCC_E2K)
+  #define EIGEN_COMP_GNUC_STRICT 1
+#else
+  #define EIGEN_COMP_GNUC_STRICT 0
+#endif
+
+
+#if EIGEN_COMP_GNUC
+  #define EIGEN_GNUC_AT_LEAST(x,y) ((__GNUC__==x && __GNUC_MINOR__>=y) || __GNUC__>x)
+  #define EIGEN_GNUC_AT_MOST(x,y)  ((__GNUC__==x && __GNUC_MINOR__<=y) || __GNUC__<x)
+  #define EIGEN_GNUC_AT(x,y)       ( __GNUC__==x && __GNUC_MINOR__==y )
+#else
+  #define EIGEN_GNUC_AT_LEAST(x,y) 0
+  #define EIGEN_GNUC_AT_MOST(x,y)  0
+  #define EIGEN_GNUC_AT(x,y)       0
+#endif
+
+// FIXME: could probably be removed as we do not support gcc 3.x anymore
+#if EIGEN_COMP_GNUC && (__GNUC__ <= 3)
+#define EIGEN_GCC3_OR_OLDER 1
+#else
+#define EIGEN_GCC3_OR_OLDER 0
+#endif
+
+
+// Architecture identification, EIGEN_ARCH_*
+
+#if defined(__x86_64__) || defined(_M_X64) || defined(__amd64)
+  #define EIGEN_ARCH_x86_64 1
+#else
+  #define EIGEN_ARCH_x86_64 0
+#endif
+
+#if defined(__i386__) || defined(_M_IX86) || defined(_X86_) || defined(__i386)
+  #define EIGEN_ARCH_i386 1
+#else
+  #define EIGEN_ARCH_i386 0
+#endif
+
+#if EIGEN_ARCH_x86_64 || EIGEN_ARCH_i386
+  #define EIGEN_ARCH_i386_OR_x86_64 1
+#else
+  #define EIGEN_ARCH_i386_OR_x86_64 0
+#endif
+
+/// \internal EIGEN_ARCH_ARM set to 1 if the architecture is ARM
+#if defined(__arm__)
+  #define EIGEN_ARCH_ARM 1
+#else
+  #define EIGEN_ARCH_ARM 0
+#endif
+
+/// \internal EIGEN_ARCH_ARM64 set to 1 if the architecture is ARM64
+#if defined(__aarch64__)
+  #define EIGEN_ARCH_ARM64 1
+#else
+  #define EIGEN_ARCH_ARM64 0
+#endif
+
+#if EIGEN_ARCH_ARM || EIGEN_ARCH_ARM64
+  #define EIGEN_ARCH_ARM_OR_ARM64 1
+#else
+  #define EIGEN_ARCH_ARM_OR_ARM64 0
+#endif
+
+/// \internal EIGEN_ARCH_MIPS set to 1 if the architecture is MIPS
+#if defined(__mips__) || defined(__mips)
+  #define EIGEN_ARCH_MIPS 1
+#else
+  #define EIGEN_ARCH_MIPS 0
+#endif
+
+/// \internal EIGEN_ARCH_SPARC set to 1 if the architecture is SPARC
+#if defined(__sparc__) || defined(__sparc)
+  #define EIGEN_ARCH_SPARC 1
+#else
+  #define EIGEN_ARCH_SPARC 0
+#endif
+
+/// \internal EIGEN_ARCH_IA64 set to 1 if the architecture is Intel Itanium
+#if defined(__ia64__)
+  #define EIGEN_ARCH_IA64 1
+#else
+  #define EIGEN_ARCH_IA64 0
+#endif
+
+/// \internal EIGEN_ARCH_PPC set to 1 if the architecture is PowerPC
+#if defined(__powerpc__) || defined(__ppc__) || defined(_M_PPC)
+  #define EIGEN_ARCH_PPC 1
+#else
+  #define EIGEN_ARCH_PPC 0
+#endif
+
+/// \internal EIGEN_ARCH_E2K set to 1 if the architecture is E2K (MCST Elbrus 2000)
+#if defined(__e2k__)
+  #define EIGEN_ARCH_E2K 1
+#else
+  #define EIGEN_ARCH_E2K 0
+#endif
+
+
+// Operating system identification, EIGEN_OS_*
+
+/// \internal EIGEN_OS_UNIX set to 1 if the OS is a unix variant
+#if defined(__unix__) || defined(__unix)
+  #define EIGEN_OS_UNIX 1
+#else
+  #define EIGEN_OS_UNIX 0
+#endif
+
+/// \internal EIGEN_OS_LINUX set to 1 if the OS is based on Linux kernel
+#if defined(__linux__)
+  #define EIGEN_OS_LINUX 1
+#else
+  #define EIGEN_OS_LINUX 0
+#endif
+
+/// \internal EIGEN_OS_ANDROID set to 1 if the OS is Android
+// note: ANDROID is defined when using ndk_build, __ANDROID__ is defined when using a standalone toolchain.
+#if defined(__ANDROID__) || defined(ANDROID)
+  #define EIGEN_OS_ANDROID 1
+#else
+  #define EIGEN_OS_ANDROID 0
+#endif
+
+/// \internal EIGEN_OS_GNULINUX set to 1 if the OS is GNU Linux and not Linux-based OS (e.g., not android)
+#if defined(__gnu_linux__) && !(EIGEN_OS_ANDROID)
+  #define EIGEN_OS_GNULINUX 1
+#else
+  #define EIGEN_OS_GNULINUX 0
+#endif
+
+/// \internal EIGEN_OS_BSD set to 1 if the OS is a BSD variant
+#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__bsdi__) || defined(__DragonFly__)
+  #define EIGEN_OS_BSD 1
+#else
+  #define EIGEN_OS_BSD 0
+#endif
+
+/// \internal EIGEN_OS_MAC set to 1 if the OS is MacOS
+#if defined(__APPLE__)
+  #define EIGEN_OS_MAC 1
+#else
+  #define EIGEN_OS_MAC 0
+#endif
+
+/// \internal EIGEN_OS_QNX set to 1 if the OS is QNX
+#if defined(__QNX__)
+  #define EIGEN_OS_QNX 1
+#else
+  #define EIGEN_OS_QNX 0
+#endif
+
+/// \internal EIGEN_OS_WIN set to 1 if the OS is Windows based
+#if defined(_WIN32)
+  #define EIGEN_OS_WIN 1
+#else
+  #define EIGEN_OS_WIN 0
+#endif
+
+/// \internal EIGEN_OS_WIN64 set to 1 if the OS is Windows 64bits
+#if defined(_WIN64)
+  #define EIGEN_OS_WIN64 1
+#else
+  #define EIGEN_OS_WIN64 0
+#endif
+
+/// \internal EIGEN_OS_WINCE set to 1 if the OS is Windows CE
+#if defined(_WIN32_WCE)
+  #define EIGEN_OS_WINCE 1
+#else
+  #define EIGEN_OS_WINCE 0
+#endif
+
+/// \internal EIGEN_OS_CYGWIN set to 1 if the OS is Windows/Cygwin
+#if defined(__CYGWIN__)
+  #define EIGEN_OS_CYGWIN 1
+#else
+  #define EIGEN_OS_CYGWIN 0
+#endif
+
+/// \internal EIGEN_OS_WIN_STRICT set to 1 if the OS is really Windows and not some variants
+#if EIGEN_OS_WIN && !( EIGEN_OS_WINCE || EIGEN_OS_CYGWIN )
+  #define EIGEN_OS_WIN_STRICT 1
+#else
+  #define EIGEN_OS_WIN_STRICT 0
+#endif
+
+/// \internal EIGEN_OS_SUN set to 1 if the OS is SUN
+#if (defined(sun) || defined(__sun)) && !(defined(__SVR4) || defined(__svr4__))
+  #define EIGEN_OS_SUN 1
+#else
+  #define EIGEN_OS_SUN 0
+#endif
+
+/// \internal EIGEN_OS_SOLARIS set to 1 if the OS is Solaris
+#if (defined(sun) || defined(__sun)) && (defined(__SVR4) || defined(__svr4__))
+  #define EIGEN_OS_SOLARIS 1
+#else
+  #define EIGEN_OS_SOLARIS 0
+#endif
+
+
+#if EIGEN_GNUC_AT_MOST(4,3) && !EIGEN_COMP_CLANG
+  // see bug 89
+  #define EIGEN_SAFE_TO_USE_STANDARD_ASSERT_MACRO 0
+#else
+  #define EIGEN_SAFE_TO_USE_STANDARD_ASSERT_MACRO 1
+#endif
+
+// This macro can be used to prevent from macro expansion, e.g.:
+//   std::max EIGEN_NOT_A_MACRO(a,b)
+#define EIGEN_NOT_A_MACRO
+
+#ifdef EIGEN_DEFAULT_TO_ROW_MAJOR
+#define EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION Eigen::RowMajor
+#else
+#define EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION Eigen::ColMajor
+#endif
+
+#ifndef EIGEN_DEFAULT_DENSE_INDEX_TYPE
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE std::ptrdiff_t
+#endif
+
+// Cross compiler wrapper around LLVM's __has_builtin
+#ifdef __has_builtin
+#  define EIGEN_HAS_BUILTIN(x) __has_builtin(x)
+#else
+#  define EIGEN_HAS_BUILTIN(x) 0
+#endif
+
+// A Clang feature extension to determine compiler features.
+// We use it to determine 'cxx_rvalue_references'
+#ifndef __has_feature
+# define __has_feature(x) 0
+#endif
+
+// Some old compilers do not support template specializations like:
+// template<typename T,int N> void foo(const T x[N]);
+#if !( EIGEN_COMP_CLANG && ((EIGEN_COMP_CLANG<309) || defined(__apple_build_version__)) || EIGEN_COMP_GNUC_STRICT && EIGEN_COMP_GNUC<49)
+#define EIGEN_HAS_STATIC_ARRAY_TEMPLATE 1
+#else
+#define EIGEN_HAS_STATIC_ARRAY_TEMPLATE 0
+#endif
+
+// Upperbound on the C++ version to use.
+// Expected values are 03, 11, 14, 17, etc.
+// By default, let's use an arbitrarily large C++ version.
+#ifndef EIGEN_MAX_CPP_VER
+#define EIGEN_MAX_CPP_VER 99
+#endif
+
+#if EIGEN_MAX_CPP_VER>=11 && (defined(__cplusplus) && (__cplusplus >= 201103L) || EIGEN_COMP_MSVC >= 1900)
+#define EIGEN_HAS_CXX11 1
+#else
+#define EIGEN_HAS_CXX11 0
+#endif
+
+#if EIGEN_MAX_CPP_VER>=14 && (defined(__cplusplus) && (__cplusplus > 201103L) || EIGEN_COMP_MSVC >= 1910)
+#define EIGEN_HAS_CXX14 1
+#else
+#define EIGEN_HAS_CXX14 0
+#endif
+
+// Do we support r-value references?
+#ifndef EIGEN_HAS_RVALUE_REFERENCES
+#if EIGEN_MAX_CPP_VER>=11 && \
+    (__has_feature(cxx_rvalue_references) || \
+    (defined(__cplusplus) && __cplusplus >= 201103L) || \
+    (EIGEN_COMP_MSVC >= 1600))
+  #define EIGEN_HAS_RVALUE_REFERENCES 1
+#else
+  #define EIGEN_HAS_RVALUE_REFERENCES 0
+#endif
+#endif
+
+// Does the compiler support C99?
+#ifndef EIGEN_HAS_C99_MATH
+#if EIGEN_MAX_CPP_VER>=11 && \
+    ((defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901))       \
+  || (defined(__GNUC__) && defined(_GLIBCXX_USE_C99)) \
+  || (defined(_LIBCPP_VERSION) && !defined(_MSC_VER)) \
+  || (EIGEN_COMP_MSVC >= 1900) || defined(__SYCL_DEVICE_ONLY__))
+  #define EIGEN_HAS_C99_MATH 1
+#else
+  #define EIGEN_HAS_C99_MATH 0
+#endif
+#endif
+
+// Does the compiler support result_of?
+#ifndef EIGEN_HAS_STD_RESULT_OF
+#if EIGEN_MAX_CPP_VER>=11 && ((__has_feature(cxx_lambdas) || (defined(__cplusplus) && __cplusplus >= 201103L)))
+#define EIGEN_HAS_STD_RESULT_OF 1
+#else
+#define EIGEN_HAS_STD_RESULT_OF 0
+#endif
+#endif
+
+// Does the compiler support type_trais?
+#ifndef EIGEN_HAS_TYPE_TRAITS
+#if EIGEN_MAX_CPP_VER>=11 && (EIGEN_HAS_CXX11 || EIGEN_COMP_MSVC >= 1700)
+#define EIGEN_HAS_TYPE_TRAITS 1
+#define EIGEN_INCLUDE_TYPE_TRAITS
+#else
+#define EIGEN_HAS_TYPE_TRAITS 0
+#endif
+#endif
+
+// Does the compiler support variadic templates?
+#ifndef EIGEN_HAS_VARIADIC_TEMPLATES
+#if EIGEN_MAX_CPP_VER>=11 && (__cplusplus > 199711L || EIGEN_COMP_MSVC >= 1900) \
+  && (!defined(__NVCC__) || !EIGEN_ARCH_ARM_OR_ARM64 || (EIGEN_CUDACC_VER >= 80000) )
+    // ^^ Disable the use of variadic templates when compiling with versions of nvcc older than 8.0 on ARM devices:
+    //    this prevents nvcc from crashing when compiling Eigen on Tegra X1
+#define EIGEN_HAS_VARIADIC_TEMPLATES 1
+#elif  EIGEN_MAX_CPP_VER>=11 && (__cplusplus > 199711L || EIGEN_COMP_MSVC >= 1900) && defined(__SYCL_DEVICE_ONLY__)
+#define EIGEN_HAS_VARIADIC_TEMPLATES 1
+#else
+#define EIGEN_HAS_VARIADIC_TEMPLATES 0
+#endif
+#endif
+
+// Does the compiler fully support const expressions? (as in c++14)
+#ifndef EIGEN_HAS_CONSTEXPR
+
+#if defined(EIGEN_CUDACC)
+// Const expressions are supported provided that c++11 is enabled and we're using either clang or nvcc 7.5 or above
+#if EIGEN_MAX_CPP_VER>=14 && (__cplusplus > 199711L && (EIGEN_COMP_CLANG || EIGEN_CUDACC_VER >= 70500))
+  #define EIGEN_HAS_CONSTEXPR 1
+#endif
+#elif EIGEN_MAX_CPP_VER>=14 && (__has_feature(cxx_relaxed_constexpr) || (defined(__cplusplus) && __cplusplus >= 201402L) || \
+  (EIGEN_GNUC_AT_LEAST(4,8) && (__cplusplus > 199711L)) || \
+  (EIGEN_COMP_CLANG >= 306 && (__cplusplus > 199711L)))
+#define EIGEN_HAS_CONSTEXPR 1
+#endif
+
+#ifndef EIGEN_HAS_CONSTEXPR
+#define EIGEN_HAS_CONSTEXPR 0
+#endif
+
+#endif
+
+// Does the compiler support C++11 math?
+// Let's be conservative and enable the default C++11 implementation only if we are sure it exists
+#ifndef EIGEN_HAS_CXX11_MATH
+  #if EIGEN_MAX_CPP_VER>=11 && ((__cplusplus > 201103L) || (__cplusplus >= 201103L) && (EIGEN_COMP_GNUC_STRICT || EIGEN_COMP_CLANG || EIGEN_COMP_MSVC || EIGEN_COMP_ICC)  \
+      && (EIGEN_ARCH_i386_OR_x86_64) && (EIGEN_OS_GNULINUX || EIGEN_OS_WIN_STRICT || EIGEN_OS_MAC))
+    #define EIGEN_HAS_CXX11_MATH 1
+  #else
+    #define EIGEN_HAS_CXX11_MATH 0
+  #endif
+#endif
+
+// Does the compiler support proper C++11 containers?
+#ifndef EIGEN_HAS_CXX11_CONTAINERS
+  #if    EIGEN_MAX_CPP_VER>=11 && \
+         ((__cplusplus > 201103L) \
+      || ((__cplusplus >= 201103L) && (EIGEN_COMP_GNUC_STRICT || EIGEN_COMP_CLANG || EIGEN_COMP_ICC>=1400)) \
+      || EIGEN_COMP_MSVC >= 1900)
+    #define EIGEN_HAS_CXX11_CONTAINERS 1
+  #else
+    #define EIGEN_HAS_CXX11_CONTAINERS 0
+  #endif
+#endif
+
+// Does the compiler support C++11 noexcept?
+#ifndef EIGEN_HAS_CXX11_NOEXCEPT
+  #if    EIGEN_MAX_CPP_VER>=11 && \
+         (__has_feature(cxx_noexcept) \
+      || (__cplusplus > 201103L) \
+      || ((__cplusplus >= 201103L) && (EIGEN_COMP_GNUC_STRICT || EIGEN_COMP_CLANG || EIGEN_COMP_ICC>=1400)) \
+      || EIGEN_COMP_MSVC >= 1900)
+    #define EIGEN_HAS_CXX11_NOEXCEPT 1
+  #else
+    #define EIGEN_HAS_CXX11_NOEXCEPT 0
+  #endif
+#endif
+
+/** Allows to disable some optimizations which might affect the accuracy of the result.
+  * Such optimization are enabled by default, and set EIGEN_FAST_MATH to 0 to disable them.
+  * They currently include:
+  *   - single precision ArrayBase::sin() and ArrayBase::cos() for SSE and AVX vectorization.
+  */
+#ifndef EIGEN_FAST_MATH
+#define EIGEN_FAST_MATH 1
+#endif
+
+#define EIGEN_DEBUG_VAR(x) std::cerr << #x << " = " << x << std::endl;
+
+// concatenate two tokens
+#define EIGEN_CAT2(a,b) a ## b
+#define EIGEN_CAT(a,b) EIGEN_CAT2(a,b)
+
+#define EIGEN_COMMA ,
+
+// convert a token to a string
+#define EIGEN_MAKESTRING2(a) #a
+#define EIGEN_MAKESTRING(a) EIGEN_MAKESTRING2(a)
+
+// EIGEN_STRONG_INLINE is a stronger version of the inline, using __forceinline on MSVC,
+// but it still doesn't use GCC's always_inline. This is useful in (common) situations where MSVC needs forceinline
+// but GCC is still doing fine with just inline.
+#if EIGEN_COMP_MSVC || EIGEN_COMP_ICC
+#define EIGEN_STRONG_INLINE __forceinline
+#else
+#define EIGEN_STRONG_INLINE inline
+#endif
+
+// EIGEN_ALWAYS_INLINE is the stronget, it has the effect of making the function inline and adding every possible
+// attribute to maximize inlining. This should only be used when really necessary: in particular,
+// it uses __attribute__((always_inline)) on GCC, which most of the time is useless and can severely harm compile times.
+// FIXME with the always_inline attribute,
+// gcc 3.4.x and 4.1 reports the following compilation error:
+//   Eval.h:91: sorry, unimplemented: inlining failed in call to 'const Eigen::Eval<Derived> Eigen::MatrixBase<Scalar, Derived>::eval() const'
+//    : function body not available
+//   See also bug 1367
+#if EIGEN_GNUC_AT_LEAST(4,2)
+#define EIGEN_ALWAYS_INLINE __attribute__((always_inline)) inline
+#else
+#define EIGEN_ALWAYS_INLINE EIGEN_STRONG_INLINE
+#endif
+
+#if EIGEN_COMP_GNUC
+#define EIGEN_DONT_INLINE __attribute__((noinline))
+#elif EIGEN_COMP_MSVC
+#define EIGEN_DONT_INLINE __declspec(noinline)
+#else
+#define EIGEN_DONT_INLINE
+#endif
+
+#if EIGEN_COMP_GNUC
+#define EIGEN_PERMISSIVE_EXPR __extension__
+#else
+#define EIGEN_PERMISSIVE_EXPR
+#endif
+
+// this macro allows to get rid of linking errors about multiply defined functions.
+//  - static is not very good because it prevents definitions from different object files to be merged.
+//           So static causes the resulting linked executable to be bloated with multiple copies of the same function.
+//  - inline is not perfect either as it unwantedly hints the compiler toward inlining the function.
+#define EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_DEVICE_FUNC
+#define EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_DEVICE_FUNC inline
+
+#ifdef NDEBUG
+# ifndef EIGEN_NO_DEBUG
+#  define EIGEN_NO_DEBUG
+# endif
+#endif
+
+// eigen_plain_assert is where we implement the workaround for the assert() bug in GCC <= 4.3, see bug 89
+#ifdef EIGEN_NO_DEBUG
+  #define eigen_plain_assert(x)
+#else
+  #if EIGEN_SAFE_TO_USE_STANDARD_ASSERT_MACRO
+    namespace Eigen {
+    namespace internal {
+    inline bool copy_bool(bool b) { return b; }
+    }
+    }
+    #define eigen_plain_assert(x) assert(x)
+  #else
+    // work around bug 89
+    #include <cstdlib>   // for abort
+    #include <iostream>  // for std::cerr
+
+    namespace Eigen {
+    namespace internal {
+    // trivial function copying a bool. Must be EIGEN_DONT_INLINE, so we implement it after including Eigen headers.
+    // see bug 89.
+    namespace {
+    EIGEN_DONT_INLINE bool copy_bool(bool b) { return b; }
+    }
+    inline void assert_fail(const char *condition, const char *function, const char *file, int line)
+    {
+      std::cerr << "assertion failed: " << condition << " in function " << function << " at " << file << ":" << line << std::endl;
+      abort();
+    }
+    }
+    }
+    #define eigen_plain_assert(x) \
+      do { \
+        if(!Eigen::internal::copy_bool(x)) \
+          Eigen::internal::assert_fail(EIGEN_MAKESTRING(x), __PRETTY_FUNCTION__, __FILE__, __LINE__); \
+      } while(false)
+  #endif
+#endif
+
+// eigen_assert can be overridden
+#ifndef eigen_assert
+#define eigen_assert(x) eigen_plain_assert(x)
+#endif
+
+#ifdef EIGEN_INTERNAL_DEBUGGING
+#define eigen_internal_assert(x) eigen_assert(x)
+#else
+#define eigen_internal_assert(x)
+#endif
+
+#ifdef EIGEN_NO_DEBUG
+#define EIGEN_ONLY_USED_FOR_DEBUG(x) EIGEN_UNUSED_VARIABLE(x)
+#else
+#define EIGEN_ONLY_USED_FOR_DEBUG(x)
+#endif
+
+#ifndef EIGEN_NO_DEPRECATED_WARNING
+  #if EIGEN_COMP_GNUC
+    #define EIGEN_DEPRECATED __attribute__((deprecated))
+  #elif EIGEN_COMP_MSVC
+    #define EIGEN_DEPRECATED __declspec(deprecated)
+  #else
+    #define EIGEN_DEPRECATED
+  #endif
+#else
+  #define EIGEN_DEPRECATED
+#endif
+
+#if EIGEN_COMP_GNUC
+#define EIGEN_UNUSED __attribute__((unused))
+#else
+#define EIGEN_UNUSED
+#endif
+
+// Suppresses 'unused variable' warnings.
+namespace Eigen {
+  namespace internal {
+    template<typename T> EIGEN_DEVICE_FUNC void ignore_unused_variable(const T&) {}
+  }
+}
+#define EIGEN_UNUSED_VARIABLE(var) Eigen::internal::ignore_unused_variable(var);
+
+#if !defined(EIGEN_ASM_COMMENT)
+  #if EIGEN_COMP_GNUC && (EIGEN_ARCH_i386_OR_x86_64 || EIGEN_ARCH_ARM_OR_ARM64)
+    #define EIGEN_ASM_COMMENT(X)  __asm__("#" X)
+  #else
+    #define EIGEN_ASM_COMMENT(X)
+  #endif
+#endif
+
+
+#if EIGEN_COMP_MSVC
+  // NOTE MSVC often gives C4127 warnings with compiletime if statements. See bug 1362.
+  // This workaround is ugly, but it does the job.
+#  define EIGEN_CONST_CONDITIONAL(cond)  (void)0, cond
+#else
+#  define EIGEN_CONST_CONDITIONAL(cond)  cond
+#endif
+
+//------------------------------------------------------------------------------------------
+// Static and dynamic alignment control
+//
+// The main purpose of this section is to define EIGEN_MAX_ALIGN_BYTES and EIGEN_MAX_STATIC_ALIGN_BYTES
+// as the maximal boundary in bytes on which dynamically and statically allocated data may be alignment respectively.
+// The values of EIGEN_MAX_ALIGN_BYTES and EIGEN_MAX_STATIC_ALIGN_BYTES can be specified by the user. If not,
+// a default value is automatically computed based on architecture, compiler, and OS.
+//
+// This section also defines macros EIGEN_ALIGN_TO_BOUNDARY(N) and the shortcuts EIGEN_ALIGN{8,16,32,_MAX}
+// to be used to declare statically aligned buffers.
+//------------------------------------------------------------------------------------------
+
+
+/* EIGEN_ALIGN_TO_BOUNDARY(n) forces data to be n-byte aligned. This is used to satisfy SIMD requirements.
+ * However, we do that EVEN if vectorization (EIGEN_VECTORIZE) is disabled,
+ * so that vectorization doesn't affect binary compatibility.
+ *
+ * If we made alignment depend on whether or not EIGEN_VECTORIZE is defined, it would be impossible to link
+ * vectorized and non-vectorized code.
+ */
+#if (defined EIGEN_CUDACC)
+  #define EIGEN_ALIGN_TO_BOUNDARY(n) __align__(n)
+#elif EIGEN_COMP_GNUC || EIGEN_COMP_PGI || EIGEN_COMP_IBM || EIGEN_COMP_ARM
+  #define EIGEN_ALIGN_TO_BOUNDARY(n) __attribute__((aligned(n)))
+#elif EIGEN_COMP_MSVC
+  #define EIGEN_ALIGN_TO_BOUNDARY(n) __declspec(align(n))
+#elif EIGEN_COMP_SUNCC
+  // FIXME not sure about this one:
+  #define EIGEN_ALIGN_TO_BOUNDARY(n) __attribute__((aligned(n)))
+#else
+  #error Please tell me what is the equivalent of __attribute__((aligned(n))) for your compiler
+#endif
+
+// If the user explicitly disable vectorization, then we also disable alignment
+#if defined(EIGEN_DONT_VECTORIZE)
+  #define EIGEN_IDEAL_MAX_ALIGN_BYTES 0
+#elif defined(EIGEN_VECTORIZE_AVX512)
+  // 64 bytes static alignmeent is preferred only if really required
+  #define EIGEN_IDEAL_MAX_ALIGN_BYTES 64
+#elif defined(__AVX__)
+  // 32 bytes static alignmeent is preferred only if really required
+  #define EIGEN_IDEAL_MAX_ALIGN_BYTES 32
+#else
+  #define EIGEN_IDEAL_MAX_ALIGN_BYTES 16
+#endif
+
+
+// EIGEN_MIN_ALIGN_BYTES defines the minimal value for which the notion of explicit alignment makes sense
+#define EIGEN_MIN_ALIGN_BYTES 16
+
+// Defined the boundary (in bytes) on which the data needs to be aligned. Note
+// that unless EIGEN_ALIGN is defined and not equal to 0, the data may not be
+// aligned at all regardless of the value of this #define.
+
+#if (defined(EIGEN_DONT_ALIGN_STATICALLY) || defined(EIGEN_DONT_ALIGN))  && defined(EIGEN_MAX_STATIC_ALIGN_BYTES) && EIGEN_MAX_STATIC_ALIGN_BYTES>0
+#error EIGEN_MAX_STATIC_ALIGN_BYTES and EIGEN_DONT_ALIGN[_STATICALLY] are both defined with EIGEN_MAX_STATIC_ALIGN_BYTES!=0. Use EIGEN_MAX_STATIC_ALIGN_BYTES=0 as a synonym of EIGEN_DONT_ALIGN_STATICALLY.
+#endif
+
+// EIGEN_DONT_ALIGN_STATICALLY and EIGEN_DONT_ALIGN are deprectated
+// They imply EIGEN_MAX_STATIC_ALIGN_BYTES=0
+#if defined(EIGEN_DONT_ALIGN_STATICALLY) || defined(EIGEN_DONT_ALIGN)
+  #ifdef EIGEN_MAX_STATIC_ALIGN_BYTES
+    #undef EIGEN_MAX_STATIC_ALIGN_BYTES
+  #endif
+  #define EIGEN_MAX_STATIC_ALIGN_BYTES 0
+#endif
+
+#ifndef EIGEN_MAX_STATIC_ALIGN_BYTES
+
+  // Try to automatically guess what is the best default value for EIGEN_MAX_STATIC_ALIGN_BYTES
+
+  // 16 byte alignment is only useful for vectorization. Since it affects the ABI, we need to enable
+  // 16 byte alignment on all platforms where vectorization might be enabled. In theory we could always
+  // enable alignment, but it can be a cause of problems on some platforms, so we just disable it in
+  // certain common platform (compiler+architecture combinations) to avoid these problems.
+  // Only static alignment is really problematic (relies on nonstandard compiler extensions),
+  // try to keep heap alignment even when we have to disable static alignment.
+  #if EIGEN_COMP_GNUC && !(EIGEN_ARCH_i386_OR_x86_64 || EIGEN_ARCH_ARM_OR_ARM64 || EIGEN_ARCH_PPC || EIGEN_ARCH_IA64 || EIGEN_ARCH_E2K)
+  #define EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT 1
+  #elif EIGEN_ARCH_ARM_OR_ARM64 && EIGEN_COMP_GNUC_STRICT && EIGEN_GNUC_AT_MOST(4, 6)
+  // Old versions of GCC on ARM, at least 4.4, were once seen to have buggy static alignment support.
+  // Not sure which version fixed it, hopefully it doesn't affect 4.7, which is still somewhat in use.
+  // 4.8 and newer seem definitely unaffected.
+  #define EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT 1
+  #else
+  #define EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT 0
+  #endif
+
+  // static alignment is completely disabled with GCC 3, Sun Studio, and QCC/QNX
+  #if !EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT \
+  && !EIGEN_GCC3_OR_OLDER \
+  && !EIGEN_COMP_SUNCC \
+  && !EIGEN_OS_QNX
+    #define EIGEN_ARCH_WANTS_STACK_ALIGNMENT 1
+  #else
+    #define EIGEN_ARCH_WANTS_STACK_ALIGNMENT 0
+  #endif
+
+  #if EIGEN_ARCH_WANTS_STACK_ALIGNMENT
+    #define EIGEN_MAX_STATIC_ALIGN_BYTES EIGEN_IDEAL_MAX_ALIGN_BYTES
+  #else
+    #define EIGEN_MAX_STATIC_ALIGN_BYTES 0
+  #endif
+
+#endif
+
+// If EIGEN_MAX_ALIGN_BYTES is defined, then it is considered as an upper bound for EIGEN_MAX_ALIGN_BYTES
+#if defined(EIGEN_MAX_ALIGN_BYTES) && EIGEN_MAX_ALIGN_BYTES<EIGEN_MAX_STATIC_ALIGN_BYTES
+#undef EIGEN_MAX_STATIC_ALIGN_BYTES
+#define EIGEN_MAX_STATIC_ALIGN_BYTES EIGEN_MAX_ALIGN_BYTES
+#endif
+
+#if EIGEN_MAX_STATIC_ALIGN_BYTES==0 && !defined(EIGEN_DISABLE_UNALIGNED_ARRAY_ASSERT)
+  #define EIGEN_DISABLE_UNALIGNED_ARRAY_ASSERT
+#endif
+
+// At this stage, EIGEN_MAX_STATIC_ALIGN_BYTES>0 is the true test whether we want to align arrays on the stack or not.
+// It takes into account both the user choice to explicitly enable/disable alignment (by settting EIGEN_MAX_STATIC_ALIGN_BYTES)
+// and the architecture config (EIGEN_ARCH_WANTS_STACK_ALIGNMENT).
+// Henceforth, only EIGEN_MAX_STATIC_ALIGN_BYTES should be used.
+
+
+// Shortcuts to EIGEN_ALIGN_TO_BOUNDARY
+#define EIGEN_ALIGN8  EIGEN_ALIGN_TO_BOUNDARY(8)
+#define EIGEN_ALIGN16 EIGEN_ALIGN_TO_BOUNDARY(16)
+#define EIGEN_ALIGN32 EIGEN_ALIGN_TO_BOUNDARY(32)
+#define EIGEN_ALIGN64 EIGEN_ALIGN_TO_BOUNDARY(64)
+#if EIGEN_MAX_STATIC_ALIGN_BYTES>0
+#define EIGEN_ALIGN_MAX EIGEN_ALIGN_TO_BOUNDARY(EIGEN_MAX_STATIC_ALIGN_BYTES)
+#else
+#define EIGEN_ALIGN_MAX
+#endif
+
+
+// Dynamic alignment control
+
+#if defined(EIGEN_DONT_ALIGN) && defined(EIGEN_MAX_ALIGN_BYTES) && EIGEN_MAX_ALIGN_BYTES>0
+#error EIGEN_MAX_ALIGN_BYTES and EIGEN_DONT_ALIGN are both defined with EIGEN_MAX_ALIGN_BYTES!=0. Use EIGEN_MAX_ALIGN_BYTES=0 as a synonym of EIGEN_DONT_ALIGN.
+#endif
+
+#ifdef EIGEN_DONT_ALIGN
+  #ifdef EIGEN_MAX_ALIGN_BYTES
+    #undef EIGEN_MAX_ALIGN_BYTES
+  #endif
+  #define EIGEN_MAX_ALIGN_BYTES 0
+#elif !defined(EIGEN_MAX_ALIGN_BYTES)
+  #define EIGEN_MAX_ALIGN_BYTES EIGEN_IDEAL_MAX_ALIGN_BYTES
+#endif
+
+#if EIGEN_IDEAL_MAX_ALIGN_BYTES > EIGEN_MAX_ALIGN_BYTES
+#define EIGEN_DEFAULT_ALIGN_BYTES EIGEN_IDEAL_MAX_ALIGN_BYTES
+#else
+#define EIGEN_DEFAULT_ALIGN_BYTES EIGEN_MAX_ALIGN_BYTES
+#endif
+
+
+#ifndef EIGEN_UNALIGNED_VECTORIZE
+#define EIGEN_UNALIGNED_VECTORIZE 1
+#endif
+
+//----------------------------------------------------------------------
+
+
+#ifdef EIGEN_DONT_USE_RESTRICT_KEYWORD
+  #define EIGEN_RESTRICT
+#endif
+#ifndef EIGEN_RESTRICT
+  #define EIGEN_RESTRICT __restrict
+#endif
+
+#ifndef EIGEN_STACK_ALLOCATION_LIMIT
+// 131072 == 128 KB
+#define EIGEN_STACK_ALLOCATION_LIMIT 131072
+#endif
+
+#ifndef EIGEN_DEFAULT_IO_FORMAT
+#ifdef EIGEN_MAKING_DOCS
+// format used in Eigen's documentation
+// needed to define it here as escaping characters in CMake add_definition's argument seems very problematic.
+#define EIGEN_DEFAULT_IO_FORMAT Eigen::IOFormat(3, 0, " ", "\n", "", "")
+#else
+#define EIGEN_DEFAULT_IO_FORMAT Eigen::IOFormat()
+#endif
+#endif
+
+// just an empty macro !
+#define EIGEN_EMPTY
+
+#if EIGEN_COMP_MSVC_STRICT && (EIGEN_COMP_MSVC < 1900 || EIGEN_CUDACC_VER>0)
+  // for older MSVC versions, as well as 1900 && CUDA 8, using the base operator is sufficient (cf Bugs 1000, 1324)
+  #define EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Derived) \
+    using Base::operator =;
+#elif EIGEN_COMP_CLANG // workaround clang bug (see http://forum.kde.org/viewtopic.php?f=74&t=102653)
+  #define EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Derived) \
+    using Base::operator =; \
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator=(const Derived& other) { Base::operator=(other); return *this; } \
+    template <typename OtherDerived> \
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator=(const DenseBase<OtherDerived>& other) { Base::operator=(other.derived()); return *this; }
+#else
+  #define EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Derived) \
+    using Base::operator =; \
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator=(const Derived& other) \
+    { \
+      Base::operator=(other); \
+      return *this; \
+    }
+#endif
+
+
+/** \internal
+ * \brief Macro to manually inherit assignment operators.
+ * This is necessary, because the implicitly defined assignment operator gets deleted when a custom operator= is defined.
+ */
+#define EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Derived) EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Derived)
+
+/**
+* Just a side note. Commenting within defines works only by documenting
+* behind the object (via '!<'). Comments cannot be multi-line and thus
+* we have these extra long lines. What is confusing doxygen over here is
+* that we use '\' and basically have a bunch of typedefs with their
+* documentation in a single line.
+**/
+
+#define EIGEN_GENERIC_PUBLIC_INTERFACE(Derived) \
+  typedef typename Eigen::internal::traits<Derived>::Scalar Scalar; /*!< \brief Numeric type, e.g. float, double, int or std::complex<float>. */ \
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar; /*!< \brief The underlying numeric type for composed scalar types. \details In cases where Scalar is e.g. std::complex<T>, T were corresponding to RealScalar. */ \
+  typedef typename Base::CoeffReturnType CoeffReturnType; /*!< \brief The return type for coefficient access. \details Depending on whether the object allows direct coefficient access (e.g. for a MatrixXd), this type is either 'const Scalar&' or simply 'Scalar' for objects that do not allow direct coefficient access. */ \
+  typedef typename Eigen::internal::ref_selector<Derived>::type Nested; \
+  typedef typename Eigen::internal::traits<Derived>::StorageKind StorageKind; \
+  typedef typename Eigen::internal::traits<Derived>::StorageIndex StorageIndex; \
+  enum CompileTimeTraits \
+      { RowsAtCompileTime = Eigen::internal::traits<Derived>::RowsAtCompileTime, \
+        ColsAtCompileTime = Eigen::internal::traits<Derived>::ColsAtCompileTime, \
+        Flags = Eigen::internal::traits<Derived>::Flags, \
+        SizeAtCompileTime = Base::SizeAtCompileTime, \
+        MaxSizeAtCompileTime = Base::MaxSizeAtCompileTime, \
+        IsVectorAtCompileTime = Base::IsVectorAtCompileTime }; \
+  using Base::derived; \
+  using Base::const_cast_derived;
+
+
+// FIXME Maybe the EIGEN_DENSE_PUBLIC_INTERFACE could be removed as importing PacketScalar is rarely needed
+#define EIGEN_DENSE_PUBLIC_INTERFACE(Derived) \
+  EIGEN_GENERIC_PUBLIC_INTERFACE(Derived) \
+  typedef typename Base::PacketScalar PacketScalar;
+
+
+#define EIGEN_PLAIN_ENUM_MIN(a,b) (((int)a <= (int)b) ? (int)a : (int)b)
+#define EIGEN_PLAIN_ENUM_MAX(a,b) (((int)a >= (int)b) ? (int)a : (int)b)
+
+// EIGEN_SIZE_MIN_PREFER_DYNAMIC gives the min between compile-time sizes. 0 has absolute priority, followed by 1,
+// followed by Dynamic, followed by other finite values. The reason for giving Dynamic the priority over
+// finite values is that min(3, Dynamic) should be Dynamic, since that could be anything between 0 and 3.
+#define EIGEN_SIZE_MIN_PREFER_DYNAMIC(a,b) (((int)a == 0 || (int)b == 0) ? 0 \
+                           : ((int)a == 1 || (int)b == 1) ? 1 \
+                           : ((int)a == Dynamic || (int)b == Dynamic) ? Dynamic \
+                           : ((int)a <= (int)b) ? (int)a : (int)b)
+
+// EIGEN_SIZE_MIN_PREFER_FIXED is a variant of EIGEN_SIZE_MIN_PREFER_DYNAMIC comparing MaxSizes. The difference is that finite values
+// now have priority over Dynamic, so that min(3, Dynamic) gives 3. Indeed, whatever the actual value is
+// (between 0 and 3), it is not more than 3.
+#define EIGEN_SIZE_MIN_PREFER_FIXED(a,b)  (((int)a == 0 || (int)b == 0) ? 0 \
+                           : ((int)a == 1 || (int)b == 1) ? 1 \
+                           : ((int)a == Dynamic && (int)b == Dynamic) ? Dynamic \
+                           : ((int)a == Dynamic) ? (int)b \
+                           : ((int)b == Dynamic) ? (int)a \
+                           : ((int)a <= (int)b) ? (int)a : (int)b)
+
+// see EIGEN_SIZE_MIN_PREFER_DYNAMIC. No need for a separate variant for MaxSizes here.
+#define EIGEN_SIZE_MAX(a,b) (((int)a == Dynamic || (int)b == Dynamic) ? Dynamic \
+                           : ((int)a >= (int)b) ? (int)a : (int)b)
+
+#define EIGEN_LOGICAL_XOR(a,b) (((a) || (b)) && !((a) && (b)))
+
+#define EIGEN_IMPLIES(a,b) (!(a) || (b))
+
+// the expression type of a standard coefficient wise binary operation
+#define EIGEN_CWISE_BINARY_RETURN_TYPE(LHS,RHS,OPNAME) \
+    CwiseBinaryOp< \
+      EIGEN_CAT(EIGEN_CAT(internal::scalar_,OPNAME),_op)< \
+          typename internal::traits<LHS>::Scalar, \
+          typename internal::traits<RHS>::Scalar \
+      >, \
+      const LHS, \
+      const RHS \
+    >
+
+#define EIGEN_MAKE_CWISE_BINARY_OP(METHOD,OPNAME) \
+  template<typename OtherDerived> \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const EIGEN_CWISE_BINARY_RETURN_TYPE(Derived,OtherDerived,OPNAME) \
+  (METHOD)(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const \
+  { \
+    return EIGEN_CWISE_BINARY_RETURN_TYPE(Derived,OtherDerived,OPNAME)(derived(), other.derived()); \
+  }
+
+#define EIGEN_SCALAR_BINARY_SUPPORTED(OPNAME,TYPEA,TYPEB) \
+  (Eigen::internal::has_ReturnType<Eigen::ScalarBinaryOpTraits<TYPEA,TYPEB,EIGEN_CAT(EIGEN_CAT(Eigen::internal::scalar_,OPNAME),_op)<TYPEA,TYPEB>  > >::value)
+
+#define EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(EXPR,SCALAR,OPNAME) \
+  CwiseBinaryOp<EIGEN_CAT(EIGEN_CAT(internal::scalar_,OPNAME),_op)<typename internal::traits<EXPR>::Scalar,SCALAR>, const EXPR, \
+                const typename internal::plain_constant_type<EXPR,SCALAR>::type>
+
+#define EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(SCALAR,EXPR,OPNAME) \
+  CwiseBinaryOp<EIGEN_CAT(EIGEN_CAT(internal::scalar_,OPNAME),_op)<SCALAR,typename internal::traits<EXPR>::Scalar>, \
+                const typename internal::plain_constant_type<EXPR,SCALAR>::type, const EXPR>
+
+// Workaround for MSVC 2010 (see ML thread "patch with compile for for MSVC 2010")
+#if EIGEN_COMP_MSVC_STRICT && (EIGEN_COMP_MSVC_STRICT<=1600)
+#define EIGEN_MSVC10_WORKAROUND_BINARYOP_RETURN_TYPE(X) typename internal::enable_if<true,X>::type
+#else
+#define EIGEN_MSVC10_WORKAROUND_BINARYOP_RETURN_TYPE(X) X
+#endif
+
+#define EIGEN_MAKE_SCALAR_BINARY_OP_ONTHERIGHT(METHOD,OPNAME) \
+  template <typename T> EIGEN_DEVICE_FUNC inline \
+  EIGEN_MSVC10_WORKAROUND_BINARYOP_RETURN_TYPE(const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Derived,typename internal::promote_scalar_arg<Scalar EIGEN_COMMA T EIGEN_COMMA EIGEN_SCALAR_BINARY_SUPPORTED(OPNAME,Scalar,T)>::type,OPNAME))\
+  (METHOD)(const T& scalar) const { \
+    typedef typename internal::promote_scalar_arg<Scalar,T,EIGEN_SCALAR_BINARY_SUPPORTED(OPNAME,Scalar,T)>::type PromotedT; \
+    return EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Derived,PromotedT,OPNAME)(derived(), \
+           typename internal::plain_constant_type<Derived,PromotedT>::type(derived().rows(), derived().cols(), internal::scalar_constant_op<PromotedT>(scalar))); \
+  }
+
+#define EIGEN_MAKE_SCALAR_BINARY_OP_ONTHELEFT(METHOD,OPNAME) \
+  template <typename T> EIGEN_DEVICE_FUNC inline friend \
+  EIGEN_MSVC10_WORKAROUND_BINARYOP_RETURN_TYPE(const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(typename internal::promote_scalar_arg<Scalar EIGEN_COMMA T EIGEN_COMMA EIGEN_SCALAR_BINARY_SUPPORTED(OPNAME,T,Scalar)>::type,Derived,OPNAME)) \
+  (METHOD)(const T& scalar, const StorageBaseType& matrix) { \
+    typedef typename internal::promote_scalar_arg<Scalar,T,EIGEN_SCALAR_BINARY_SUPPORTED(OPNAME,T,Scalar)>::type PromotedT; \
+    return EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(PromotedT,Derived,OPNAME)( \
+           typename internal::plain_constant_type<Derived,PromotedT>::type(matrix.derived().rows(), matrix.derived().cols(), internal::scalar_constant_op<PromotedT>(scalar)), matrix.derived()); \
+  }
+
+#define EIGEN_MAKE_SCALAR_BINARY_OP(METHOD,OPNAME) \
+  EIGEN_MAKE_SCALAR_BINARY_OP_ONTHELEFT(METHOD,OPNAME) \
+  EIGEN_MAKE_SCALAR_BINARY_OP_ONTHERIGHT(METHOD,OPNAME)
+
+
+#ifdef EIGEN_EXCEPTIONS
+#  define EIGEN_THROW_X(X) throw X
+#  define EIGEN_THROW throw
+#  define EIGEN_TRY try
+#  define EIGEN_CATCH(X) catch (X)
+#else
+#  ifdef EIGEN_CUDA_ARCH
+#    define EIGEN_THROW_X(X) asm("trap;")
+#    define EIGEN_THROW asm("trap;")
+#  else
+#    define EIGEN_THROW_X(X) std::abort()
+#    define EIGEN_THROW std::abort()
+#  endif
+#  define EIGEN_TRY if (true)
+#  define EIGEN_CATCH(X) else
+#endif
+
+
+#if EIGEN_HAS_CXX11_NOEXCEPT
+#   define EIGEN_INCLUDE_TYPE_TRAITS
+#   define EIGEN_NOEXCEPT noexcept
+#   define EIGEN_NOEXCEPT_IF(x) noexcept(x)
+#   define EIGEN_NO_THROW noexcept(true)
+#   define EIGEN_EXCEPTION_SPEC(X) noexcept(false)
+#else
+#   define EIGEN_NOEXCEPT
+#   define EIGEN_NOEXCEPT_IF(x)
+#   define EIGEN_NO_THROW throw()
+#   define EIGEN_EXCEPTION_SPEC(X) throw(X)
+#endif
+
+#endif // EIGEN_MACROS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/Memory.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/Memory.h
new file mode 100644
index 00000000..c455f92a
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/Memory.h
@@ -0,0 +1,985 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2008-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2009 Kenneth Riddile <kfriddile@yahoo.com>
+// Copyright (C) 2010 Hauke Heibel <hauke.heibel@gmail.com>
+// Copyright (C) 2010 Thomas Capricelli <orzel@freehackers.org>
+// Copyright (C) 2013 Pavel Holoborodko <pavel@holoborodko.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+/*****************************************************************************
+*** Platform checks for aligned malloc functions                           ***
+*****************************************************************************/
+
+#ifndef EIGEN_MEMORY_H
+#define EIGEN_MEMORY_H
+
+#ifndef EIGEN_MALLOC_ALREADY_ALIGNED
+
+// Try to determine automatically if malloc is already aligned.
+
+// On 64-bit systems, glibc's malloc returns 16-byte-aligned pointers, see:
+//   http://www.gnu.org/s/libc/manual/html_node/Aligned-Memory-Blocks.html
+// This is true at least since glibc 2.8.
+// This leaves the question how to detect 64-bit. According to this document,
+//   http://gcc.fyxm.net/summit/2003/Porting%20to%2064%20bit.pdf
+// page 114, "[The] LP64 model [...] is used by all 64-bit UNIX ports" so it's indeed
+// quite safe, at least within the context of glibc, to equate 64-bit with LP64.
+#if defined(__GLIBC__) && ((__GLIBC__>=2 && __GLIBC_MINOR__ >= 8) || __GLIBC__>2) \
+ && defined(__LP64__) && ! defined( __SANITIZE_ADDRESS__ ) && (EIGEN_DEFAULT_ALIGN_BYTES == 16)
+  #define EIGEN_GLIBC_MALLOC_ALREADY_ALIGNED 1
+#else
+  #define EIGEN_GLIBC_MALLOC_ALREADY_ALIGNED 0
+#endif
+
+// FreeBSD 6 seems to have 16-byte aligned malloc
+//   See http://svn.freebsd.org/viewvc/base/stable/6/lib/libc/stdlib/malloc.c?view=markup
+// FreeBSD 7 seems to have 16-byte aligned malloc except on ARM and MIPS architectures
+//   See http://svn.freebsd.org/viewvc/base/stable/7/lib/libc/stdlib/malloc.c?view=markup
+#if defined(__FreeBSD__) && !(EIGEN_ARCH_ARM || EIGEN_ARCH_MIPS) && (EIGEN_DEFAULT_ALIGN_BYTES == 16)
+  #define EIGEN_FREEBSD_MALLOC_ALREADY_ALIGNED 1
+#else
+  #define EIGEN_FREEBSD_MALLOC_ALREADY_ALIGNED 0
+#endif
+
+#if (EIGEN_OS_MAC && (EIGEN_DEFAULT_ALIGN_BYTES == 16))     \
+ || (EIGEN_OS_WIN64 && (EIGEN_DEFAULT_ALIGN_BYTES == 16))   \
+ || EIGEN_GLIBC_MALLOC_ALREADY_ALIGNED              \
+ || EIGEN_FREEBSD_MALLOC_ALREADY_ALIGNED
+  #define EIGEN_MALLOC_ALREADY_ALIGNED 1
+#else
+  #define EIGEN_MALLOC_ALREADY_ALIGNED 0
+#endif
+
+#endif
+
+namespace Eigen {
+
+namespace internal {
+
+EIGEN_DEVICE_FUNC
+inline void throw_std_bad_alloc()
+{
+  #ifdef EIGEN_EXCEPTIONS
+    throw std::bad_alloc();
+  #else
+    std::size_t huge = static_cast<std::size_t>(-1);
+    new int[huge];
+  #endif
+}
+
+/*****************************************************************************
+*** Implementation of handmade aligned functions                           ***
+*****************************************************************************/
+
+/* ----- Hand made implementations of aligned malloc/free and realloc ----- */
+
+/** \internal Like malloc, but the returned pointer is guaranteed to be 16-byte aligned.
+  * Fast, but wastes 16 additional bytes of memory. Does not throw any exception.
+  */
+inline void* handmade_aligned_malloc(std::size_t size)
+{
+  void *original = std::malloc(size+EIGEN_DEFAULT_ALIGN_BYTES);
+  if (original == 0) return 0;
+  void *aligned = reinterpret_cast<void*>((reinterpret_cast<std::size_t>(original) & ~(std::size_t(EIGEN_DEFAULT_ALIGN_BYTES-1))) + EIGEN_DEFAULT_ALIGN_BYTES);
+  *(reinterpret_cast<void**>(aligned) - 1) = original;
+  return aligned;
+}
+
+/** \internal Frees memory allocated with handmade_aligned_malloc */
+inline void handmade_aligned_free(void *ptr)
+{
+  if (ptr) std::free(*(reinterpret_cast<void**>(ptr) - 1));
+}
+
+/** \internal
+  * \brief Reallocates aligned memory.
+  * Since we know that our handmade version is based on std::malloc
+  * we can use std::realloc to implement efficient reallocation.
+  */
+inline void* handmade_aligned_realloc(void* ptr, std::size_t size, std::size_t = 0)
+{
+  if (ptr == 0) return handmade_aligned_malloc(size);
+  void *original = *(reinterpret_cast<void**>(ptr) - 1);
+  std::ptrdiff_t previous_offset = static_cast<char *>(ptr)-static_cast<char *>(original);
+  original = std::realloc(original,size+EIGEN_DEFAULT_ALIGN_BYTES);
+  if (original == 0) return 0;
+  void *aligned = reinterpret_cast<void*>((reinterpret_cast<std::size_t>(original) & ~(std::size_t(EIGEN_DEFAULT_ALIGN_BYTES-1))) + EIGEN_DEFAULT_ALIGN_BYTES);
+  void *previous_aligned = static_cast<char *>(original)+previous_offset;
+  if(aligned!=previous_aligned)
+    std::memmove(aligned, previous_aligned, size);
+
+  *(reinterpret_cast<void**>(aligned) - 1) = original;
+  return aligned;
+}
+
+/*****************************************************************************
+*** Implementation of portable aligned versions of malloc/free/realloc     ***
+*****************************************************************************/
+
+#ifdef EIGEN_NO_MALLOC
+EIGEN_DEVICE_FUNC inline void check_that_malloc_is_allowed()
+{
+  eigen_assert(false && "heap allocation is forbidden (EIGEN_NO_MALLOC is defined)");
+}
+#elif defined EIGEN_RUNTIME_NO_MALLOC
+EIGEN_DEVICE_FUNC inline bool is_malloc_allowed_impl(bool update, bool new_value = false)
+{
+  static bool value = true;
+  if (update == 1)
+    value = new_value;
+  return value;
+}
+EIGEN_DEVICE_FUNC inline bool is_malloc_allowed() { return is_malloc_allowed_impl(false); }
+EIGEN_DEVICE_FUNC inline bool set_is_malloc_allowed(bool new_value) { return is_malloc_allowed_impl(true, new_value); }
+EIGEN_DEVICE_FUNC inline void check_that_malloc_is_allowed()
+{
+  eigen_assert(is_malloc_allowed() && "heap allocation is forbidden (EIGEN_RUNTIME_NO_MALLOC is defined and g_is_malloc_allowed is false)");
+}
+#else
+EIGEN_DEVICE_FUNC inline void check_that_malloc_is_allowed()
+{}
+#endif
+
+/** \internal Allocates \a size bytes. The returned pointer is guaranteed to have 16 or 32 bytes alignment depending on the requirements.
+  * On allocation error, the returned pointer is null, and std::bad_alloc is thrown.
+  */
+EIGEN_DEVICE_FUNC inline void* aligned_malloc(std::size_t size)
+{
+  check_that_malloc_is_allowed();
+
+  void *result;
+  #if (EIGEN_DEFAULT_ALIGN_BYTES==0) || EIGEN_MALLOC_ALREADY_ALIGNED
+    result = std::malloc(size);
+    #if EIGEN_DEFAULT_ALIGN_BYTES==16
+    eigen_assert((size<16 || (std::size_t(result)%16)==0) && "System's malloc returned an unaligned pointer. Compile with EIGEN_MALLOC_ALREADY_ALIGNED=0 to fallback to handmade alignd memory allocator.");
+    #endif
+  #else
+    result = handmade_aligned_malloc(size);
+  #endif
+
+  if(!result && size)
+    throw_std_bad_alloc();
+
+  return result;
+}
+
+/** \internal Frees memory allocated with aligned_malloc. */
+EIGEN_DEVICE_FUNC inline void aligned_free(void *ptr)
+{
+  #if (EIGEN_DEFAULT_ALIGN_BYTES==0) || EIGEN_MALLOC_ALREADY_ALIGNED
+    std::free(ptr);
+  #else
+    handmade_aligned_free(ptr);
+  #endif
+}
+
+/**
+  * \internal
+  * \brief Reallocates an aligned block of memory.
+  * \throws std::bad_alloc on allocation failure
+  */
+inline void* aligned_realloc(void *ptr, std::size_t new_size, std::size_t old_size)
+{
+  EIGEN_UNUSED_VARIABLE(old_size);
+
+  void *result;
+#if (EIGEN_DEFAULT_ALIGN_BYTES==0) || EIGEN_MALLOC_ALREADY_ALIGNED
+  result = std::realloc(ptr,new_size);
+#else
+  result = handmade_aligned_realloc(ptr,new_size,old_size);
+#endif
+
+  if (!result && new_size)
+    throw_std_bad_alloc();
+
+  return result;
+}
+
+/*****************************************************************************
+*** Implementation of conditionally aligned functions                      ***
+*****************************************************************************/
+
+/** \internal Allocates \a size bytes. If Align is true, then the returned ptr is 16-byte-aligned.
+  * On allocation error, the returned pointer is null, and a std::bad_alloc is thrown.
+  */
+template<bool Align> EIGEN_DEVICE_FUNC inline void* conditional_aligned_malloc(std::size_t size)
+{
+  return aligned_malloc(size);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void* conditional_aligned_malloc<false>(std::size_t size)
+{
+  check_that_malloc_is_allowed();
+
+  void *result = std::malloc(size);
+  if(!result && size)
+    throw_std_bad_alloc();
+  return result;
+}
+
+/** \internal Frees memory allocated with conditional_aligned_malloc */
+template<bool Align> EIGEN_DEVICE_FUNC inline void conditional_aligned_free(void *ptr)
+{
+  aligned_free(ptr);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void conditional_aligned_free<false>(void *ptr)
+{
+  std::free(ptr);
+}
+
+template<bool Align> inline void* conditional_aligned_realloc(void* ptr, std::size_t new_size, std::size_t old_size)
+{
+  return aligned_realloc(ptr, new_size, old_size);
+}
+
+template<> inline void* conditional_aligned_realloc<false>(void* ptr, std::size_t new_size, std::size_t)
+{
+  return std::realloc(ptr, new_size);
+}
+
+/*****************************************************************************
+*** Construction/destruction of array elements                             ***
+*****************************************************************************/
+
+/** \internal Destructs the elements of an array.
+  * The \a size parameters tells on how many objects to call the destructor of T.
+  */
+template<typename T> EIGEN_DEVICE_FUNC inline void destruct_elements_of_array(T *ptr, std::size_t size)
+{
+  // always destruct an array starting from the end.
+  if(ptr)
+    while(size) ptr[--size].~T();
+}
+
+/** \internal Constructs the elements of an array.
+  * The \a size parameter tells on how many objects to call the constructor of T.
+  */
+template<typename T> EIGEN_DEVICE_FUNC inline T* construct_elements_of_array(T *ptr, std::size_t size)
+{
+  std::size_t i;
+  EIGEN_TRY
+  {
+      for (i = 0; i < size; ++i) ::new (ptr + i) T;
+      return ptr;
+  }
+  EIGEN_CATCH(...)
+  {
+    destruct_elements_of_array(ptr, i);
+    EIGEN_THROW;
+  }
+  return NULL;
+}
+
+/*****************************************************************************
+*** Implementation of aligned new/delete-like functions                    ***
+*****************************************************************************/
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void check_size_for_overflow(std::size_t size)
+{
+  if(size > std::size_t(-1) / sizeof(T))
+    throw_std_bad_alloc();
+}
+
+/** \internal Allocates \a size objects of type T. The returned pointer is guaranteed to have 16 bytes alignment.
+  * On allocation error, the returned pointer is undefined, but a std::bad_alloc is thrown.
+  * The default constructor of T is called.
+  */
+template<typename T> EIGEN_DEVICE_FUNC inline T* aligned_new(std::size_t size)
+{
+  check_size_for_overflow<T>(size);
+  T *result = reinterpret_cast<T*>(aligned_malloc(sizeof(T)*size));
+  EIGEN_TRY
+  {
+    return construct_elements_of_array(result, size);
+  }
+  EIGEN_CATCH(...)
+  {
+    aligned_free(result);
+    EIGEN_THROW;
+  }
+  return result;
+}
+
+template<typename T, bool Align> EIGEN_DEVICE_FUNC inline T* conditional_aligned_new(std::size_t size)
+{
+  check_size_for_overflow<T>(size);
+  T *result = reinterpret_cast<T*>(conditional_aligned_malloc<Align>(sizeof(T)*size));
+  EIGEN_TRY
+  {
+    return construct_elements_of_array(result, size);
+  }
+  EIGEN_CATCH(...)
+  {
+    conditional_aligned_free<Align>(result);
+    EIGEN_THROW;
+  }
+  return result;
+}
+
+/** \internal Deletes objects constructed with aligned_new
+  * The \a size parameters tells on how many objects to call the destructor of T.
+  */
+template<typename T> EIGEN_DEVICE_FUNC inline void aligned_delete(T *ptr, std::size_t size)
+{
+  destruct_elements_of_array<T>(ptr, size);
+  aligned_free(ptr);
+}
+
+/** \internal Deletes objects constructed with conditional_aligned_new
+  * The \a size parameters tells on how many objects to call the destructor of T.
+  */
+template<typename T, bool Align> EIGEN_DEVICE_FUNC inline void conditional_aligned_delete(T *ptr, std::size_t size)
+{
+  destruct_elements_of_array<T>(ptr, size);
+  conditional_aligned_free<Align>(ptr);
+}
+
+template<typename T, bool Align> EIGEN_DEVICE_FUNC inline T* conditional_aligned_realloc_new(T* pts, std::size_t new_size, std::size_t old_size)
+{
+  check_size_for_overflow<T>(new_size);
+  check_size_for_overflow<T>(old_size);
+  if(new_size < old_size)
+    destruct_elements_of_array(pts+new_size, old_size-new_size);
+  T *result = reinterpret_cast<T*>(conditional_aligned_realloc<Align>(reinterpret_cast<void*>(pts), sizeof(T)*new_size, sizeof(T)*old_size));
+  if(new_size > old_size)
+  {
+    EIGEN_TRY
+    {
+      construct_elements_of_array(result+old_size, new_size-old_size);
+    }
+    EIGEN_CATCH(...)
+    {
+      conditional_aligned_free<Align>(result);
+      EIGEN_THROW;
+    }
+  }
+  return result;
+}
+
+
+template<typename T, bool Align> EIGEN_DEVICE_FUNC inline T* conditional_aligned_new_auto(std::size_t size)
+{
+  if(size==0)
+    return 0; // short-cut. Also fixes Bug 884
+  check_size_for_overflow<T>(size);
+  T *result = reinterpret_cast<T*>(conditional_aligned_malloc<Align>(sizeof(T)*size));
+  if(NumTraits<T>::RequireInitialization)
+  {
+    EIGEN_TRY
+    {
+      construct_elements_of_array(result, size);
+    }
+    EIGEN_CATCH(...)
+    {
+      conditional_aligned_free<Align>(result);
+      EIGEN_THROW;
+    }
+  }
+  return result;
+}
+
+template<typename T, bool Align> inline T* conditional_aligned_realloc_new_auto(T* pts, std::size_t new_size, std::size_t old_size)
+{
+  check_size_for_overflow<T>(new_size);
+  check_size_for_overflow<T>(old_size);
+  if(NumTraits<T>::RequireInitialization && (new_size < old_size))
+    destruct_elements_of_array(pts+new_size, old_size-new_size);
+  T *result = reinterpret_cast<T*>(conditional_aligned_realloc<Align>(reinterpret_cast<void*>(pts), sizeof(T)*new_size, sizeof(T)*old_size));
+  if(NumTraits<T>::RequireInitialization && (new_size > old_size))
+  {
+    EIGEN_TRY
+    {
+      construct_elements_of_array(result+old_size, new_size-old_size);
+    }
+    EIGEN_CATCH(...)
+    {
+      conditional_aligned_free<Align>(result);
+      EIGEN_THROW;
+    }
+  }
+  return result;
+}
+
+template<typename T, bool Align> EIGEN_DEVICE_FUNC inline void conditional_aligned_delete_auto(T *ptr, std::size_t size)
+{
+  if(NumTraits<T>::RequireInitialization)
+    destruct_elements_of_array<T>(ptr, size);
+  conditional_aligned_free<Align>(ptr);
+}
+
+/****************************************************************************/
+
+/** \internal Returns the index of the first element of the array that is well aligned with respect to the requested \a Alignment.
+  *
+  * \tparam Alignment requested alignment in Bytes.
+  * \param array the address of the start of the array
+  * \param size the size of the array
+  *
+  * \note If no element of the array is well aligned or the requested alignment is not a multiple of a scalar,
+  * the size of the array is returned. For example with SSE, the requested alignment is typically 16-bytes. If
+  * packet size for the given scalar type is 1, then everything is considered well-aligned.
+  *
+  * \note Otherwise, if the Alignment is larger that the scalar size, we rely on the assumptions that sizeof(Scalar) is a
+  * power of 2. On the other hand, we do not assume that the array address is a multiple of sizeof(Scalar), as that fails for
+  * example with Scalar=double on certain 32-bit platforms, see bug #79.
+  *
+  * There is also the variant first_aligned(const MatrixBase&) defined in DenseCoeffsBase.h.
+  * \sa first_default_aligned()
+  */
+template<int Alignment, typename Scalar, typename Index>
+EIGEN_DEVICE_FUNC inline Index first_aligned(const Scalar* array, Index size)
+{
+  const Index ScalarSize = sizeof(Scalar);
+  const Index AlignmentSize = Alignment / ScalarSize;
+  const Index AlignmentMask = AlignmentSize-1;
+
+  if(AlignmentSize<=1)
+  {
+    // Either the requested alignment if smaller than a scalar, or it exactly match a 1 scalar
+    // so that all elements of the array have the same alignment.
+    return 0;
+  }
+  else if( (UIntPtr(array) & (sizeof(Scalar)-1)) || (Alignment%ScalarSize)!=0)
+  {
+    // The array is not aligned to the size of a single scalar, or the requested alignment is not a multiple of the scalar size.
+    // Consequently, no element of the array is well aligned.
+    return size;
+  }
+  else
+  {
+    Index first = (AlignmentSize - (Index((UIntPtr(array)/sizeof(Scalar))) & AlignmentMask)) & AlignmentMask;
+    return (first < size) ? first : size;
+  }
+}
+
+/** \internal Returns the index of the first element of the array that is well aligned with respect the largest packet requirement.
+   * \sa first_aligned(Scalar*,Index) and first_default_aligned(DenseBase<Derived>) */
+template<typename Scalar, typename Index>
+EIGEN_DEVICE_FUNC inline Index first_default_aligned(const Scalar* array, Index size)
+{
+  typedef typename packet_traits<Scalar>::type DefaultPacketType;
+  return first_aligned<unpacket_traits<DefaultPacketType>::alignment>(array, size);
+}
+
+/** \internal Returns the smallest integer multiple of \a base and greater or equal to \a size
+  */
+template<typename Index>
+inline Index first_multiple(Index size, Index base)
+{
+  return ((size+base-1)/base)*base;
+}
+
+// std::copy is much slower than memcpy, so let's introduce a smart_copy which
+// use memcpy on trivial types, i.e., on types that does not require an initialization ctor.
+template<typename T, bool UseMemcpy> struct smart_copy_helper;
+
+template<typename T> EIGEN_DEVICE_FUNC void smart_copy(const T* start, const T* end, T* target)
+{
+  smart_copy_helper<T,!NumTraits<T>::RequireInitialization>::run(start, end, target);
+}
+
+template<typename T> struct smart_copy_helper<T,true> {
+  EIGEN_DEVICE_FUNC static inline void run(const T* start, const T* end, T* target)
+  {
+    IntPtr size = IntPtr(end)-IntPtr(start);
+    if(size==0) return;
+    eigen_internal_assert(start!=0 && end!=0 && target!=0);
+    std::memcpy(target, start, size);
+  }
+};
+
+template<typename T> struct smart_copy_helper<T,false> {
+  EIGEN_DEVICE_FUNC static inline void run(const T* start, const T* end, T* target)
+  { std::copy(start, end, target); }
+};
+
+// intelligent memmove. falls back to std::memmove for POD types, uses std::copy otherwise.
+template<typename T, bool UseMemmove> struct smart_memmove_helper;
+
+template<typename T> void smart_memmove(const T* start, const T* end, T* target)
+{
+  smart_memmove_helper<T,!NumTraits<T>::RequireInitialization>::run(start, end, target);
+}
+
+template<typename T> struct smart_memmove_helper<T,true> {
+  static inline void run(const T* start, const T* end, T* target)
+  {
+    IntPtr size = IntPtr(end)-IntPtr(start);
+    if(size==0) return;
+    eigen_internal_assert(start!=0 && end!=0 && target!=0);
+    std::memmove(target, start, size);
+  }
+};
+
+template<typename T> struct smart_memmove_helper<T,false> {
+  static inline void run(const T* start, const T* end, T* target)
+  {
+    if (UIntPtr(target) < UIntPtr(start))
+    {
+      std::copy(start, end, target);
+    }
+    else
+    {
+      std::ptrdiff_t count = (std::ptrdiff_t(end)-std::ptrdiff_t(start)) / sizeof(T);
+      std::copy_backward(start, end, target + count);
+    }
+  }
+};
+
+
+/*****************************************************************************
+*** Implementation of runtime stack allocation (falling back to malloc)    ***
+*****************************************************************************/
+
+// you can overwrite Eigen's default behavior regarding alloca by defining EIGEN_ALLOCA
+// to the appropriate stack allocation function
+#ifndef EIGEN_ALLOCA
+  #if EIGEN_OS_LINUX || EIGEN_OS_MAC || (defined alloca)
+    #define EIGEN_ALLOCA alloca
+  #elif EIGEN_COMP_MSVC
+    #define EIGEN_ALLOCA _alloca
+  #endif
+#endif
+
+// This helper class construct the allocated memory, and takes care of destructing and freeing the handled data
+// at destruction time. In practice this helper class is mainly useful to avoid memory leak in case of exceptions.
+template<typename T> class aligned_stack_memory_handler : noncopyable
+{
+  public:
+    /* Creates a stack_memory_handler responsible for the buffer \a ptr of size \a size.
+     * Note that \a ptr can be 0 regardless of the other parameters.
+     * This constructor takes care of constructing/initializing the elements of the buffer if required by the scalar type T (see NumTraits<T>::RequireInitialization).
+     * In this case, the buffer elements will also be destructed when this handler will be destructed.
+     * Finally, if \a dealloc is true, then the pointer \a ptr is freed.
+     **/
+    aligned_stack_memory_handler(T* ptr, std::size_t size, bool dealloc)
+      : m_ptr(ptr), m_size(size), m_deallocate(dealloc)
+    {
+      if(NumTraits<T>::RequireInitialization && m_ptr)
+        Eigen::internal::construct_elements_of_array(m_ptr, size);
+    }
+    ~aligned_stack_memory_handler()
+    {
+      if(NumTraits<T>::RequireInitialization && m_ptr)
+        Eigen::internal::destruct_elements_of_array<T>(m_ptr, m_size);
+      if(m_deallocate)
+        Eigen::internal::aligned_free(m_ptr);
+    }
+  protected:
+    T* m_ptr;
+    std::size_t m_size;
+    bool m_deallocate;
+};
+
+template<typename T> class scoped_array : noncopyable
+{
+  T* m_ptr;
+public:
+  explicit scoped_array(std::ptrdiff_t size)
+  {
+    m_ptr = new T[size];
+  }
+  ~scoped_array()
+  {
+    delete[] m_ptr;
+  }
+  T& operator[](std::ptrdiff_t i) { return m_ptr[i]; }
+  const T& operator[](std::ptrdiff_t i) const { return m_ptr[i]; }
+  T* &ptr() { return m_ptr; }
+  const T* ptr() const { return m_ptr; }
+  operator const T*() const { return m_ptr; }
+};
+
+template<typename T> void swap(scoped_array<T> &a,scoped_array<T> &b)
+{
+  std::swap(a.ptr(),b.ptr());
+}
+
+} // end namespace internal
+
+/** \internal
+  * Declares, allocates and construct an aligned buffer named NAME of SIZE elements of type TYPE on the stack
+  * if SIZE is smaller than EIGEN_STACK_ALLOCATION_LIMIT, and if stack allocation is supported by the platform
+  * (currently, this is Linux and Visual Studio only). Otherwise the memory is allocated on the heap.
+  * The allocated buffer is automatically deleted when exiting the scope of this declaration.
+  * If BUFFER is non null, then the declared variable is simply an alias for BUFFER, and no allocation/deletion occurs.
+  * Here is an example:
+  * \code
+  * {
+  *   ei_declare_aligned_stack_constructed_variable(float,data,size,0);
+  *   // use data[0] to data[size-1]
+  * }
+  * \endcode
+  * The underlying stack allocation function can controlled with the EIGEN_ALLOCA preprocessor token.
+  */
+#ifdef EIGEN_ALLOCA
+
+  #if EIGEN_DEFAULT_ALIGN_BYTES>0
+    // We always manually re-align the result of EIGEN_ALLOCA.
+    // If alloca is already aligned, the compiler should be smart enough to optimize away the re-alignment.
+    #define EIGEN_ALIGNED_ALLOCA(SIZE) reinterpret_cast<void*>((internal::UIntPtr(EIGEN_ALLOCA(SIZE+EIGEN_DEFAULT_ALIGN_BYTES-1)) + EIGEN_DEFAULT_ALIGN_BYTES-1) & ~(std::size_t(EIGEN_DEFAULT_ALIGN_BYTES-1)))
+  #else
+    #define EIGEN_ALIGNED_ALLOCA(SIZE) EIGEN_ALLOCA(SIZE)
+  #endif
+
+  #define ei_declare_aligned_stack_constructed_variable(TYPE,NAME,SIZE,BUFFER) \
+    Eigen::internal::check_size_for_overflow<TYPE>(SIZE); \
+    TYPE* NAME = (BUFFER)!=0 ? (BUFFER) \
+               : reinterpret_cast<TYPE*>( \
+                      (sizeof(TYPE)*SIZE<=EIGEN_STACK_ALLOCATION_LIMIT) ? EIGEN_ALIGNED_ALLOCA(sizeof(TYPE)*SIZE) \
+                    : Eigen::internal::aligned_malloc(sizeof(TYPE)*SIZE) );  \
+    Eigen::internal::aligned_stack_memory_handler<TYPE> EIGEN_CAT(NAME,_stack_memory_destructor)((BUFFER)==0 ? NAME : 0,SIZE,sizeof(TYPE)*SIZE>EIGEN_STACK_ALLOCATION_LIMIT)
+
+#else
+
+  #define ei_declare_aligned_stack_constructed_variable(TYPE,NAME,SIZE,BUFFER) \
+    Eigen::internal::check_size_for_overflow<TYPE>(SIZE); \
+    TYPE* NAME = (BUFFER)!=0 ? BUFFER : reinterpret_cast<TYPE*>(Eigen::internal::aligned_malloc(sizeof(TYPE)*SIZE));    \
+    Eigen::internal::aligned_stack_memory_handler<TYPE> EIGEN_CAT(NAME,_stack_memory_destructor)((BUFFER)==0 ? NAME : 0,SIZE,true)
+
+#endif
+
+
+/*****************************************************************************
+*** Implementation of EIGEN_MAKE_ALIGNED_OPERATOR_NEW [_IF]                ***
+*****************************************************************************/
+
+#if EIGEN_MAX_ALIGN_BYTES!=0
+  #define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_NOTHROW(NeedsToAlign) \
+      void* operator new(std::size_t size, const std::nothrow_t&) EIGEN_NO_THROW { \
+        EIGEN_TRY { return Eigen::internal::conditional_aligned_malloc<NeedsToAlign>(size); } \
+        EIGEN_CATCH (...) { return 0; } \
+      }
+  #define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign) \
+      void *operator new(std::size_t size) { \
+        return Eigen::internal::conditional_aligned_malloc<NeedsToAlign>(size); \
+      } \
+      void *operator new[](std::size_t size) { \
+        return Eigen::internal::conditional_aligned_malloc<NeedsToAlign>(size); \
+      } \
+      void operator delete(void * ptr) EIGEN_NO_THROW { Eigen::internal::conditional_aligned_free<NeedsToAlign>(ptr); } \
+      void operator delete[](void * ptr) EIGEN_NO_THROW { Eigen::internal::conditional_aligned_free<NeedsToAlign>(ptr); } \
+      void operator delete(void * ptr, std::size_t /* sz */) EIGEN_NO_THROW { Eigen::internal::conditional_aligned_free<NeedsToAlign>(ptr); } \
+      void operator delete[](void * ptr, std::size_t /* sz */) EIGEN_NO_THROW { Eigen::internal::conditional_aligned_free<NeedsToAlign>(ptr); } \
+      /* in-place new and delete. since (at least afaik) there is no actual   */ \
+      /* memory allocated we can safely let the default implementation handle */ \
+      /* this particular case. */ \
+      static void *operator new(std::size_t size, void *ptr) { return ::operator new(size,ptr); } \
+      static void *operator new[](std::size_t size, void* ptr) { return ::operator new[](size,ptr); } \
+      void operator delete(void * memory, void *ptr) EIGEN_NO_THROW { return ::operator delete(memory,ptr); } \
+      void operator delete[](void * memory, void *ptr) EIGEN_NO_THROW { return ::operator delete[](memory,ptr); } \
+      /* nothrow-new (returns zero instead of std::bad_alloc) */ \
+      EIGEN_MAKE_ALIGNED_OPERATOR_NEW_NOTHROW(NeedsToAlign) \
+      void operator delete(void *ptr, const std::nothrow_t&) EIGEN_NO_THROW { \
+        Eigen::internal::conditional_aligned_free<NeedsToAlign>(ptr); \
+      } \
+      typedef void eigen_aligned_operator_new_marker_type;
+#else
+  #define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign)
+#endif
+
+#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(true)
+#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar,Size) \
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(bool(((Size)!=Eigen::Dynamic) && ((sizeof(Scalar)*(Size))%EIGEN_MAX_ALIGN_BYTES==0)))
+
+/****************************************************************************/
+
+/** \class aligned_allocator
+* \ingroup Core_Module
+*
+* \brief STL compatible allocator to use with types requiring a non standrad alignment.
+*
+* The memory is aligned as for dynamically aligned matrix/array types such as MatrixXd.
+* By default, it will thus provide at least 16 bytes alignment and more in following cases:
+*  - 32 bytes alignment if AVX is enabled.
+*  - 64 bytes alignment if AVX512 is enabled.
+*
+* This can be controled using the \c EIGEN_MAX_ALIGN_BYTES macro as documented
+* \link TopicPreprocessorDirectivesPerformance there \endlink.
+*
+* Example:
+* \code
+* // Matrix4f requires 16 bytes alignment:
+* std::map< int, Matrix4f, std::less<int>,
+*           aligned_allocator<std::pair<const int, Matrix4f> > > my_map_mat4;
+* // Vector3f does not require 16 bytes alignment, no need to use Eigen's allocator:
+* std::map< int, Vector3f > my_map_vec3;
+* \endcode
+*
+* \sa \blank \ref TopicStlContainers.
+*/
+template<class T>
+class aligned_allocator : public std::allocator<T>
+{
+public:
+  typedef std::size_t     size_type;
+  typedef std::ptrdiff_t  difference_type;
+  typedef T*              pointer;
+  typedef const T*        const_pointer;
+  typedef T&              reference;
+  typedef const T&        const_reference;
+  typedef T               value_type;
+
+  template<class U>
+  struct rebind
+  {
+    typedef aligned_allocator<U> other;
+  };
+
+  aligned_allocator() : std::allocator<T>() {}
+
+  aligned_allocator(const aligned_allocator& other) : std::allocator<T>(other) {}
+
+  template<class U>
+  aligned_allocator(const aligned_allocator<U>& other) : std::allocator<T>(other) {}
+
+  ~aligned_allocator() {}
+
+  pointer allocate(size_type num, const void* /*hint*/ = 0)
+  {
+    internal::check_size_for_overflow<T>(num);
+    return static_cast<pointer>( internal::aligned_malloc(num * sizeof(T)) );
+  }
+
+  void deallocate(pointer p, size_type /*num*/)
+  {
+    internal::aligned_free(p);
+  }
+};
+
+//---------- Cache sizes ----------
+
+#if !defined(EIGEN_NO_CPUID)
+#  if EIGEN_COMP_GNUC && EIGEN_ARCH_i386_OR_x86_64
+#    if defined(__PIC__) && EIGEN_ARCH_i386
+       // Case for x86 with PIC
+#      define EIGEN_CPUID(abcd,func,id) \
+         __asm__ __volatile__ ("xchgl %%ebx, %k1;cpuid; xchgl %%ebx,%k1": "=a" (abcd[0]), "=&r" (abcd[1]), "=c" (abcd[2]), "=d" (abcd[3]) : "a" (func), "c" (id));
+#    elif defined(__PIC__) && EIGEN_ARCH_x86_64
+       // Case for x64 with PIC. In theory this is only a problem with recent gcc and with medium or large code model, not with the default small code model.
+       // However, we cannot detect which code model is used, and the xchg overhead is negligible anyway.
+#      define EIGEN_CPUID(abcd,func,id) \
+        __asm__ __volatile__ ("xchg{q}\t{%%}rbx, %q1; cpuid; xchg{q}\t{%%}rbx, %q1": "=a" (abcd[0]), "=&r" (abcd[1]), "=c" (abcd[2]), "=d" (abcd[3]) : "0" (func), "2" (id));
+#    else
+       // Case for x86_64 or x86 w/o PIC
+#      define EIGEN_CPUID(abcd,func,id) \
+         __asm__ __volatile__ ("cpuid": "=a" (abcd[0]), "=b" (abcd[1]), "=c" (abcd[2]), "=d" (abcd[3]) : "0" (func), "2" (id) );
+#    endif
+#  elif EIGEN_COMP_MSVC
+#    if (EIGEN_COMP_MSVC > 1500) && EIGEN_ARCH_i386_OR_x86_64
+#      define EIGEN_CPUID(abcd,func,id) __cpuidex((int*)abcd,func,id)
+#    endif
+#  endif
+#endif
+
+namespace internal {
+
+#ifdef EIGEN_CPUID
+
+inline bool cpuid_is_vendor(int abcd[4], const int vendor[3])
+{
+  return abcd[1]==vendor[0] && abcd[3]==vendor[1] && abcd[2]==vendor[2];
+}
+
+inline void queryCacheSizes_intel_direct(int& l1, int& l2, int& l3)
+{
+  int abcd[4];
+  l1 = l2 = l3 = 0;
+  int cache_id = 0;
+  int cache_type = 0;
+  do {
+    abcd[0] = abcd[1] = abcd[2] = abcd[3] = 0;
+    EIGEN_CPUID(abcd,0x4,cache_id);
+    cache_type  = (abcd[0] & 0x0F) >> 0;
+    if(cache_type==1||cache_type==3) // data or unified cache
+    {
+      int cache_level = (abcd[0] & 0xE0) >> 5;  // A[7:5]
+      int ways        = (abcd[1] & 0xFFC00000) >> 22; // B[31:22]
+      int partitions  = (abcd[1] & 0x003FF000) >> 12; // B[21:12]
+      int line_size   = (abcd[1] & 0x00000FFF) >>  0; // B[11:0]
+      int sets        = (abcd[2]);                    // C[31:0]
+
+      int cache_size = (ways+1) * (partitions+1) * (line_size+1) * (sets+1);
+
+      switch(cache_level)
+      {
+        case 1: l1 = cache_size; break;
+        case 2: l2 = cache_size; break;
+        case 3: l3 = cache_size; break;
+        default: break;
+      }
+    }
+    cache_id++;
+  } while(cache_type>0 && cache_id<16);
+}
+
+inline void queryCacheSizes_intel_codes(int& l1, int& l2, int& l3)
+{
+  int abcd[4];
+  abcd[0] = abcd[1] = abcd[2] = abcd[3] = 0;
+  l1 = l2 = l3 = 0;
+  EIGEN_CPUID(abcd,0x00000002,0);
+  unsigned char * bytes = reinterpret_cast<unsigned char *>(abcd)+2;
+  bool check_for_p2_core2 = false;
+  for(int i=0; i<14; ++i)
+  {
+    switch(bytes[i])
+    {
+      case 0x0A: l1 = 8; break;   // 0Ah   data L1 cache, 8 KB, 2 ways, 32 byte lines
+      case 0x0C: l1 = 16; break;  // 0Ch   data L1 cache, 16 KB, 4 ways, 32 byte lines
+      case 0x0E: l1 = 24; break;  // 0Eh   data L1 cache, 24 KB, 6 ways, 64 byte lines
+      case 0x10: l1 = 16; break;  // 10h   data L1 cache, 16 KB, 4 ways, 32 byte lines (IA-64)
+      case 0x15: l1 = 16; break;  // 15h   code L1 cache, 16 KB, 4 ways, 32 byte lines (IA-64)
+      case 0x2C: l1 = 32; break;  // 2Ch   data L1 cache, 32 KB, 8 ways, 64 byte lines
+      case 0x30: l1 = 32; break;  // 30h   code L1 cache, 32 KB, 8 ways, 64 byte lines
+      case 0x60: l1 = 16; break;  // 60h   data L1 cache, 16 KB, 8 ways, 64 byte lines, sectored
+      case 0x66: l1 = 8; break;   // 66h   data L1 cache, 8 KB, 4 ways, 64 byte lines, sectored
+      case 0x67: l1 = 16; break;  // 67h   data L1 cache, 16 KB, 4 ways, 64 byte lines, sectored
+      case 0x68: l1 = 32; break;  // 68h   data L1 cache, 32 KB, 4 ways, 64 byte lines, sectored
+      case 0x1A: l2 = 96; break;   // code and data L2 cache, 96 KB, 6 ways, 64 byte lines (IA-64)
+      case 0x22: l3 = 512; break;   // code and data L3 cache, 512 KB, 4 ways (!), 64 byte lines, dual-sectored
+      case 0x23: l3 = 1024; break;   // code and data L3 cache, 1024 KB, 8 ways, 64 byte lines, dual-sectored
+      case 0x25: l3 = 2048; break;   // code and data L3 cache, 2048 KB, 8 ways, 64 byte lines, dual-sectored
+      case 0x29: l3 = 4096; break;   // code and data L3 cache, 4096 KB, 8 ways, 64 byte lines, dual-sectored
+      case 0x39: l2 = 128; break;   // code and data L2 cache, 128 KB, 4 ways, 64 byte lines, sectored
+      case 0x3A: l2 = 192; break;   // code and data L2 cache, 192 KB, 6 ways, 64 byte lines, sectored
+      case 0x3B: l2 = 128; break;   // code and data L2 cache, 128 KB, 2 ways, 64 byte lines, sectored
+      case 0x3C: l2 = 256; break;   // code and data L2 cache, 256 KB, 4 ways, 64 byte lines, sectored
+      case 0x3D: l2 = 384; break;   // code and data L2 cache, 384 KB, 6 ways, 64 byte lines, sectored
+      case 0x3E: l2 = 512; break;   // code and data L2 cache, 512 KB, 4 ways, 64 byte lines, sectored
+      case 0x40: l2 = 0; break;   // no integrated L2 cache (P6 core) or L3 cache (P4 core)
+      case 0x41: l2 = 128; break;   // code and data L2 cache, 128 KB, 4 ways, 32 byte lines
+      case 0x42: l2 = 256; break;   // code and data L2 cache, 256 KB, 4 ways, 32 byte lines
+      case 0x43: l2 = 512; break;   // code and data L2 cache, 512 KB, 4 ways, 32 byte lines
+      case 0x44: l2 = 1024; break;   // code and data L2 cache, 1024 KB, 4 ways, 32 byte lines
+      case 0x45: l2 = 2048; break;   // code and data L2 cache, 2048 KB, 4 ways, 32 byte lines
+      case 0x46: l3 = 4096; break;   // code and data L3 cache, 4096 KB, 4 ways, 64 byte lines
+      case 0x47: l3 = 8192; break;   // code and data L3 cache, 8192 KB, 8 ways, 64 byte lines
+      case 0x48: l2 = 3072; break;   // code and data L2 cache, 3072 KB, 12 ways, 64 byte lines
+      case 0x49: if(l2!=0) l3 = 4096; else {check_for_p2_core2=true; l3 = l2 = 4096;} break;// code and data L3 cache, 4096 KB, 16 ways, 64 byte lines (P4) or L2 for core2
+      case 0x4A: l3 = 6144; break;   // code and data L3 cache, 6144 KB, 12 ways, 64 byte lines
+      case 0x4B: l3 = 8192; break;   // code and data L3 cache, 8192 KB, 16 ways, 64 byte lines
+      case 0x4C: l3 = 12288; break;   // code and data L3 cache, 12288 KB, 12 ways, 64 byte lines
+      case 0x4D: l3 = 16384; break;   // code and data L3 cache, 16384 KB, 16 ways, 64 byte lines
+      case 0x4E: l2 = 6144; break;   // code and data L2 cache, 6144 KB, 24 ways, 64 byte lines
+      case 0x78: l2 = 1024; break;   // code and data L2 cache, 1024 KB, 4 ways, 64 byte lines
+      case 0x79: l2 = 128; break;   // code and data L2 cache, 128 KB, 8 ways, 64 byte lines, dual-sectored
+      case 0x7A: l2 = 256; break;   // code and data L2 cache, 256 KB, 8 ways, 64 byte lines, dual-sectored
+      case 0x7B: l2 = 512; break;   // code and data L2 cache, 512 KB, 8 ways, 64 byte lines, dual-sectored
+      case 0x7C: l2 = 1024; break;   // code and data L2 cache, 1024 KB, 8 ways, 64 byte lines, dual-sectored
+      case 0x7D: l2 = 2048; break;   // code and data L2 cache, 2048 KB, 8 ways, 64 byte lines
+      case 0x7E: l2 = 256; break;   // code and data L2 cache, 256 KB, 8 ways, 128 byte lines, sect. (IA-64)
+      case 0x7F: l2 = 512; break;   // code and data L2 cache, 512 KB, 2 ways, 64 byte lines
+      case 0x80: l2 = 512; break;   // code and data L2 cache, 512 KB, 8 ways, 64 byte lines
+      case 0x81: l2 = 128; break;   // code and data L2 cache, 128 KB, 8 ways, 32 byte lines
+      case 0x82: l2 = 256; break;   // code and data L2 cache, 256 KB, 8 ways, 32 byte lines
+      case 0x83: l2 = 512; break;   // code and data L2 cache, 512 KB, 8 ways, 32 byte lines
+      case 0x84: l2 = 1024; break;   // code and data L2 cache, 1024 KB, 8 ways, 32 byte lines
+      case 0x85: l2 = 2048; break;   // code and data L2 cache, 2048 KB, 8 ways, 32 byte lines
+      case 0x86: l2 = 512; break;   // code and data L2 cache, 512 KB, 4 ways, 64 byte lines
+      case 0x87: l2 = 1024; break;   // code and data L2 cache, 1024 KB, 8 ways, 64 byte lines
+      case 0x88: l3 = 2048; break;   // code and data L3 cache, 2048 KB, 4 ways, 64 byte lines (IA-64)
+      case 0x89: l3 = 4096; break;   // code and data L3 cache, 4096 KB, 4 ways, 64 byte lines (IA-64)
+      case 0x8A: l3 = 8192; break;   // code and data L3 cache, 8192 KB, 4 ways, 64 byte lines (IA-64)
+      case 0x8D: l3 = 3072; break;   // code and data L3 cache, 3072 KB, 12 ways, 128 byte lines (IA-64)
+
+      default: break;
+    }
+  }
+  if(check_for_p2_core2 && l2 == l3)
+    l3 = 0;
+  l1 *= 1024;
+  l2 *= 1024;
+  l3 *= 1024;
+}
+
+inline void queryCacheSizes_intel(int& l1, int& l2, int& l3, int max_std_funcs)
+{
+  if(max_std_funcs>=4)
+    queryCacheSizes_intel_direct(l1,l2,l3);
+  else
+    queryCacheSizes_intel_codes(l1,l2,l3);
+}
+
+inline void queryCacheSizes_amd(int& l1, int& l2, int& l3)
+{
+  int abcd[4];
+  abcd[0] = abcd[1] = abcd[2] = abcd[3] = 0;
+  EIGEN_CPUID(abcd,0x80000005,0);
+  l1 = (abcd[2] >> 24) * 1024; // C[31:24] = L1 size in KB
+  abcd[0] = abcd[1] = abcd[2] = abcd[3] = 0;
+  EIGEN_CPUID(abcd,0x80000006,0);
+  l2 = (abcd[2] >> 16) * 1024; // C[31;16] = l2 cache size in KB
+  l3 = ((abcd[3] & 0xFFFC000) >> 18) * 512 * 1024; // D[31;18] = l3 cache size in 512KB
+}
+#endif
+
+/** \internal
+ * Queries and returns the cache sizes in Bytes of the L1, L2, and L3 data caches respectively */
+inline void queryCacheSizes(int& l1, int& l2, int& l3)
+{
+  #ifdef EIGEN_CPUID
+  int abcd[4];
+  const int GenuineIntel[] = {0x756e6547, 0x49656e69, 0x6c65746e};
+  const int AuthenticAMD[] = {0x68747541, 0x69746e65, 0x444d4163};
+  const int AMDisbetter_[] = {0x69444d41, 0x74656273, 0x21726574}; // "AMDisbetter!"
+
+  // identify the CPU vendor
+  EIGEN_CPUID(abcd,0x0,0);
+  int max_std_funcs = abcd[1];
+  if(cpuid_is_vendor(abcd,GenuineIntel))
+    queryCacheSizes_intel(l1,l2,l3,max_std_funcs);
+  else if(cpuid_is_vendor(abcd,AuthenticAMD) || cpuid_is_vendor(abcd,AMDisbetter_))
+    queryCacheSizes_amd(l1,l2,l3);
+  else
+    // by default let's use Intel's API
+    queryCacheSizes_intel(l1,l2,l3,max_std_funcs);
+
+  // here is the list of other vendors:
+//   ||cpuid_is_vendor(abcd,"VIA VIA VIA ")
+//   ||cpuid_is_vendor(abcd,"CyrixInstead")
+//   ||cpuid_is_vendor(abcd,"CentaurHauls")
+//   ||cpuid_is_vendor(abcd,"GenuineTMx86")
+//   ||cpuid_is_vendor(abcd,"TransmetaCPU")
+//   ||cpuid_is_vendor(abcd,"RiseRiseRise")
+//   ||cpuid_is_vendor(abcd,"Geode by NSC")
+//   ||cpuid_is_vendor(abcd,"SiS SiS SiS ")
+//   ||cpuid_is_vendor(abcd,"UMC UMC UMC ")
+//   ||cpuid_is_vendor(abcd,"NexGenDriven")
+  #else
+  l1 = l2 = l3 = -1;
+  #endif
+}
+
+/** \internal
+ * \returns the size in Bytes of the L1 data cache */
+inline int queryL1CacheSize()
+{
+  int l1(-1), l2, l3;
+  queryCacheSizes(l1,l2,l3);
+  return l1;
+}
+
+/** \internal
+ * \returns the size in Bytes of the L2 or L3 cache if this later is present */
+inline int queryTopLevelCacheSize()
+{
+  int l1, l2(-1), l3(-1);
+  queryCacheSizes(l1,l2,l3);
+  return (std::max)(l2,l3);
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_MEMORY_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/Meta.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/Meta.h
new file mode 100644
index 00000000..0fa81800
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/Meta.h
@@ -0,0 +1,550 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_META_H
+#define EIGEN_META_H
+
+#if defined(EIGEN_CUDA_ARCH)
+#include <cfloat>
+#include <math_constants.h>
+#endif
+
+#if EIGEN_COMP_ICC>=1600 &&  __cplusplus >= 201103L
+#include <cstdint>
+#endif
+
+namespace Eigen {
+
+typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE DenseIndex;
+
+/**
+ * \brief The Index type as used for the API.
+ * \details To change this, \c \#define the preprocessor symbol \c EIGEN_DEFAULT_DENSE_INDEX_TYPE.
+ * \sa \blank \ref TopicPreprocessorDirectives, StorageIndex.
+ */
+
+typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE Index;
+
+namespace internal {
+
+/** \internal
+  * \file Meta.h
+  * This file contains generic metaprogramming classes which are not specifically related to Eigen.
+  * \note In case you wonder, yes we're aware that Boost already provides all these features,
+  * we however don't want to add a dependency to Boost.
+  */
+
+// Only recent versions of ICC complain about using ptrdiff_t to hold pointers,
+// and older versions do not provide *intptr_t types.
+#if EIGEN_COMP_ICC>=1600 &&  __cplusplus >= 201103L
+typedef std::intptr_t  IntPtr;
+typedef std::uintptr_t UIntPtr;
+#else
+typedef std::ptrdiff_t IntPtr;
+typedef std::size_t UIntPtr;
+#endif
+
+struct true_type {  enum { value = 1 }; };
+struct false_type { enum { value = 0 }; };
+
+template<bool Condition, typename Then, typename Else>
+struct conditional { typedef Then type; };
+
+template<typename Then, typename Else>
+struct conditional <false, Then, Else> { typedef Else type; };
+
+template<typename T, typename U> struct is_same { enum { value = 0 }; };
+template<typename T> struct is_same<T,T> { enum { value = 1 }; };
+
+template<typename T> struct remove_reference { typedef T type; };
+template<typename T> struct remove_reference<T&> { typedef T type; };
+
+template<typename T> struct remove_pointer { typedef T type; };
+template<typename T> struct remove_pointer<T*> { typedef T type; };
+template<typename T> struct remove_pointer<T*const> { typedef T type; };
+
+template <class T> struct remove_const { typedef T type; };
+template <class T> struct remove_const<const T> { typedef T type; };
+template <class T> struct remove_const<const T[]> { typedef T type[]; };
+template <class T, unsigned int Size> struct remove_const<const T[Size]> { typedef T type[Size]; };
+
+template<typename T> struct remove_all { typedef T type; };
+template<typename T> struct remove_all<const T>   { typedef typename remove_all<T>::type type; };
+template<typename T> struct remove_all<T const&>  { typedef typename remove_all<T>::type type; };
+template<typename T> struct remove_all<T&>        { typedef typename remove_all<T>::type type; };
+template<typename T> struct remove_all<T const*>  { typedef typename remove_all<T>::type type; };
+template<typename T> struct remove_all<T*>        { typedef typename remove_all<T>::type type; };
+
+template<typename T> struct is_arithmetic      { enum { value = false }; };
+template<> struct is_arithmetic<float>         { enum { value = true }; };
+template<> struct is_arithmetic<double>        { enum { value = true }; };
+template<> struct is_arithmetic<long double>   { enum { value = true }; };
+template<> struct is_arithmetic<bool>          { enum { value = true }; };
+template<> struct is_arithmetic<char>          { enum { value = true }; };
+template<> struct is_arithmetic<signed char>   { enum { value = true }; };
+template<> struct is_arithmetic<unsigned char> { enum { value = true }; };
+template<> struct is_arithmetic<signed short>  { enum { value = true }; };
+template<> struct is_arithmetic<unsigned short>{ enum { value = true }; };
+template<> struct is_arithmetic<signed int>    { enum { value = true }; };
+template<> struct is_arithmetic<unsigned int>  { enum { value = true }; };
+template<> struct is_arithmetic<signed long>   { enum { value = true }; };
+template<> struct is_arithmetic<unsigned long> { enum { value = true }; };
+
+#if EIGEN_HAS_CXX11
+using std::is_integral;
+#else
+template<typename T> struct is_integral               { enum { value = false }; };
+template<> struct is_integral<bool>                   { enum { value = true }; };
+template<> struct is_integral<char>                   { enum { value = true }; };
+template<> struct is_integral<signed char>            { enum { value = true }; };
+template<> struct is_integral<unsigned char>          { enum { value = true }; };
+template<> struct is_integral<signed short>           { enum { value = true }; };
+template<> struct is_integral<unsigned short>         { enum { value = true }; };
+template<> struct is_integral<signed int>             { enum { value = true }; };
+template<> struct is_integral<unsigned int>           { enum { value = true }; };
+template<> struct is_integral<signed long>            { enum { value = true }; };
+template<> struct is_integral<unsigned long>          { enum { value = true }; };
+#endif
+
+
+template <typename T> struct add_const { typedef const T type; };
+template <typename T> struct add_const<T&> { typedef T& type; };
+
+template <typename T> struct is_const { enum { value = 0 }; };
+template <typename T> struct is_const<T const> { enum { value = 1 }; };
+
+template<typename T> struct add_const_on_value_type            { typedef const T type;  };
+template<typename T> struct add_const_on_value_type<T&>        { typedef T const& type; };
+template<typename T> struct add_const_on_value_type<T*>        { typedef T const* type; };
+template<typename T> struct add_const_on_value_type<T* const>  { typedef T const* const type; };
+template<typename T> struct add_const_on_value_type<T const* const>  { typedef T const* const type; };
+
+
+template<typename From, typename To>
+struct is_convertible_impl
+{
+private:
+  struct any_conversion
+  {
+    template <typename T> any_conversion(const volatile T&);
+    template <typename T> any_conversion(T&);
+  };
+  struct yes {int a[1];};
+  struct no  {int a[2];};
+
+  static yes test(const To&, int);
+  static no  test(any_conversion, ...);
+
+public:
+  static From ms_from;
+#ifdef __INTEL_COMPILER
+  #pragma warning push
+  #pragma warning ( disable : 2259 )
+#endif
+  enum { value = sizeof(test(ms_from, 0))==sizeof(yes) };
+#ifdef __INTEL_COMPILER
+  #pragma warning pop
+#endif
+};
+
+template<typename From, typename To>
+struct is_convertible
+{
+  enum { value = is_convertible_impl<typename remove_all<From>::type,
+                                     typename remove_all<To  >::type>::value };
+};
+
+/** \internal Allows to enable/disable an overload
+  * according to a compile time condition.
+  */
+template<bool Condition, typename T=void> struct enable_if;
+
+template<typename T> struct enable_if<true,T>
+{ typedef T type; };
+
+#if defined(EIGEN_CUDA_ARCH)
+#if !defined(__FLT_EPSILON__)
+#define __FLT_EPSILON__ FLT_EPSILON
+#define __DBL_EPSILON__ DBL_EPSILON
+#endif
+
+namespace device {
+
+template<typename T> struct numeric_limits
+{
+  EIGEN_DEVICE_FUNC
+  static T epsilon() { return 0; }
+  static T (max)() { assert(false && "Highest not supported for this type"); }
+  static T (min)() { assert(false && "Lowest not supported for this type"); }
+  static T infinity() { assert(false && "Infinity not supported for this type"); }
+  static T quiet_NaN() { assert(false && "quiet_NaN not supported for this type"); }
+};
+template<> struct numeric_limits<float>
+{
+  EIGEN_DEVICE_FUNC
+  static float epsilon() { return __FLT_EPSILON__; }
+  EIGEN_DEVICE_FUNC
+  static float (max)() { return CUDART_MAX_NORMAL_F; }
+  EIGEN_DEVICE_FUNC
+  static float (min)() { return FLT_MIN; }
+  EIGEN_DEVICE_FUNC
+  static float infinity() { return CUDART_INF_F; }
+  EIGEN_DEVICE_FUNC
+  static float quiet_NaN() { return CUDART_NAN_F; }
+};
+template<> struct numeric_limits<double>
+{
+  EIGEN_DEVICE_FUNC
+  static double epsilon() { return __DBL_EPSILON__; }
+  EIGEN_DEVICE_FUNC
+  static double (max)() { return DBL_MAX; }
+  EIGEN_DEVICE_FUNC
+  static double (min)() { return DBL_MIN; }
+  EIGEN_DEVICE_FUNC
+  static double infinity() { return CUDART_INF; }
+  EIGEN_DEVICE_FUNC
+  static double quiet_NaN() { return CUDART_NAN; }
+};
+template<> struct numeric_limits<int>
+{
+  EIGEN_DEVICE_FUNC
+  static int epsilon() { return 0; }
+  EIGEN_DEVICE_FUNC
+  static int (max)() { return INT_MAX; }
+  EIGEN_DEVICE_FUNC
+  static int (min)() { return INT_MIN; }
+};
+template<> struct numeric_limits<unsigned int>
+{
+  EIGEN_DEVICE_FUNC
+  static unsigned int epsilon() { return 0; }
+  EIGEN_DEVICE_FUNC
+  static unsigned int (max)() { return UINT_MAX; }
+  EIGEN_DEVICE_FUNC
+  static unsigned int (min)() { return 0; }
+};
+template<> struct numeric_limits<long>
+{
+  EIGEN_DEVICE_FUNC
+  static long epsilon() { return 0; }
+  EIGEN_DEVICE_FUNC
+  static long (max)() { return LONG_MAX; }
+  EIGEN_DEVICE_FUNC
+  static long (min)() { return LONG_MIN; }
+};
+template<> struct numeric_limits<unsigned long>
+{
+  EIGEN_DEVICE_FUNC
+  static unsigned long epsilon() { return 0; }
+  EIGEN_DEVICE_FUNC
+  static unsigned long (max)() { return ULONG_MAX; }
+  EIGEN_DEVICE_FUNC
+  static unsigned long (min)() { return 0; }
+};
+template<> struct numeric_limits<long long>
+{
+  EIGEN_DEVICE_FUNC
+  static long long epsilon() { return 0; }
+  EIGEN_DEVICE_FUNC
+  static long long (max)() { return LLONG_MAX; }
+  EIGEN_DEVICE_FUNC
+  static long long (min)() { return LLONG_MIN; }
+};
+template<> struct numeric_limits<unsigned long long>
+{
+  EIGEN_DEVICE_FUNC
+  static unsigned long long epsilon() { return 0; }
+  EIGEN_DEVICE_FUNC
+  static unsigned long long (max)() { return ULLONG_MAX; }
+  EIGEN_DEVICE_FUNC
+  static unsigned long long (min)() { return 0; }
+};
+
+}
+
+#endif
+
+/** \internal
+  * A base class do disable default copy ctor and copy assignement operator.
+  */
+class noncopyable
+{
+  EIGEN_DEVICE_FUNC noncopyable(const noncopyable&);
+  EIGEN_DEVICE_FUNC const noncopyable& operator=(const noncopyable&);
+protected:
+  EIGEN_DEVICE_FUNC noncopyable() {}
+  EIGEN_DEVICE_FUNC ~noncopyable() {}
+};
+
+/** \internal
+  * Provides access to the number of elements in the object of as a compile-time constant expression.
+  * It "returns" Eigen::Dynamic if the size cannot be resolved at compile-time (default).
+  *
+  * Similar to std::tuple_size, but more general.
+  *
+  * It currently supports:
+  *  - any types T defining T::SizeAtCompileTime
+  *  - plain C arrays as T[N]
+  *  - std::array (c++11)
+  *  - some internal types such as SingleRange and AllRange
+  *
+  * The second template parameter eases SFINAE-based specializations.
+  */
+template<typename T, typename EnableIf = void> struct array_size {
+  enum { value = Dynamic };
+};
+
+template<typename T> struct array_size<T,typename internal::enable_if<((T::SizeAtCompileTime&0)==0)>::type> {
+  enum { value = T::SizeAtCompileTime };
+};
+
+template<typename T, int N> struct array_size<const T (&)[N]> {
+  enum { value = N };
+};
+template<typename T, int N> struct array_size<T (&)[N]> {
+  enum { value = N };
+};
+
+#if EIGEN_HAS_CXX11
+template<typename T, std::size_t N> struct array_size<const std::array<T,N> > {
+  enum { value = N };
+};
+template<typename T, std::size_t N> struct array_size<std::array<T,N> > {
+  enum { value = N };
+};
+#endif
+
+/** \internal
+  * Analogue of the std::size free function.
+  * It returns the size of the container or view \a x of type \c T
+  *
+  * It currently supports:
+  *  - any types T defining a member T::size() const
+  *  - plain C arrays as T[N]
+  *
+  */
+template<typename T>
+Index size(const T& x) { return x.size(); }
+
+template<typename T,std::size_t N>
+Index size(const T (&) [N]) { return N; }
+
+/** \internal
+  * Convenient struct to get the result type of a unary or binary functor.
+  *
+  * It supports both the current STL mechanism (using the result_type member) as well as
+  * upcoming next STL generation (using a templated result member).
+  * If none of these members is provided, then the type of the first argument is returned. FIXME, that behavior is a pretty bad hack.
+  */
+#if EIGEN_HAS_STD_RESULT_OF
+template<typename T> struct result_of {
+  typedef typename std::result_of<T>::type type1;
+  typedef typename remove_all<type1>::type type;
+};
+#else
+template<typename T> struct result_of { };
+
+struct has_none {int a[1];};
+struct has_std_result_type {int a[2];};
+struct has_tr1_result {int a[3];};
+
+template<typename Func, typename ArgType, int SizeOf=sizeof(has_none)>
+struct unary_result_of_select {typedef typename internal::remove_all<ArgType>::type type;};
+
+template<typename Func, typename ArgType>
+struct unary_result_of_select<Func, ArgType, sizeof(has_std_result_type)> {typedef typename Func::result_type type;};
+
+template<typename Func, typename ArgType>
+struct unary_result_of_select<Func, ArgType, sizeof(has_tr1_result)> {typedef typename Func::template result<Func(ArgType)>::type type;};
+
+template<typename Func, typename ArgType>
+struct result_of<Func(ArgType)> {
+    template<typename T>
+    static has_std_result_type    testFunctor(T const *, typename T::result_type const * = 0);
+    template<typename T>
+    static has_tr1_result         testFunctor(T const *, typename T::template result<T(ArgType)>::type const * = 0);
+    static has_none               testFunctor(...);
+
+    // note that the following indirection is needed for gcc-3.3
+    enum {FunctorType = sizeof(testFunctor(static_cast<Func*>(0)))};
+    typedef typename unary_result_of_select<Func, ArgType, FunctorType>::type type;
+};
+
+template<typename Func, typename ArgType0, typename ArgType1, int SizeOf=sizeof(has_none)>
+struct binary_result_of_select {typedef typename internal::remove_all<ArgType0>::type type;};
+
+template<typename Func, typename ArgType0, typename ArgType1>
+struct binary_result_of_select<Func, ArgType0, ArgType1, sizeof(has_std_result_type)>
+{typedef typename Func::result_type type;};
+
+template<typename Func, typename ArgType0, typename ArgType1>
+struct binary_result_of_select<Func, ArgType0, ArgType1, sizeof(has_tr1_result)>
+{typedef typename Func::template result<Func(ArgType0,ArgType1)>::type type;};
+
+template<typename Func, typename ArgType0, typename ArgType1>
+struct result_of<Func(ArgType0,ArgType1)> {
+    template<typename T>
+    static has_std_result_type    testFunctor(T const *, typename T::result_type const * = 0);
+    template<typename T>
+    static has_tr1_result         testFunctor(T const *, typename T::template result<T(ArgType0,ArgType1)>::type const * = 0);
+    static has_none               testFunctor(...);
+
+    // note that the following indirection is needed for gcc-3.3
+    enum {FunctorType = sizeof(testFunctor(static_cast<Func*>(0)))};
+    typedef typename binary_result_of_select<Func, ArgType0, ArgType1, FunctorType>::type type;
+};
+
+template<typename Func, typename ArgType0, typename ArgType1, typename ArgType2, int SizeOf=sizeof(has_none)>
+struct ternary_result_of_select {typedef typename internal::remove_all<ArgType0>::type type;};
+
+template<typename Func, typename ArgType0, typename ArgType1, typename ArgType2>
+struct ternary_result_of_select<Func, ArgType0, ArgType1, ArgType2, sizeof(has_std_result_type)>
+{typedef typename Func::result_type type;};
+
+template<typename Func, typename ArgType0, typename ArgType1, typename ArgType2>
+struct ternary_result_of_select<Func, ArgType0, ArgType1, ArgType2, sizeof(has_tr1_result)>
+{typedef typename Func::template result<Func(ArgType0,ArgType1,ArgType2)>::type type;};
+
+template<typename Func, typename ArgType0, typename ArgType1, typename ArgType2>
+struct result_of<Func(ArgType0,ArgType1,ArgType2)> {
+    template<typename T>
+    static has_std_result_type    testFunctor(T const *, typename T::result_type const * = 0);
+    template<typename T>
+    static has_tr1_result         testFunctor(T const *, typename T::template result<T(ArgType0,ArgType1,ArgType2)>::type const * = 0);
+    static has_none               testFunctor(...);
+
+    // note that the following indirection is needed for gcc-3.3
+    enum {FunctorType = sizeof(testFunctor(static_cast<Func*>(0)))};
+    typedef typename ternary_result_of_select<Func, ArgType0, ArgType1, ArgType2, FunctorType>::type type;
+};
+#endif
+
+struct meta_yes { char a[1]; };
+struct meta_no  { char a[2]; };
+
+// Check whether T::ReturnType does exist
+template <typename T>
+struct has_ReturnType
+{
+  template <typename C> static meta_yes testFunctor(C const *, typename C::ReturnType const * = 0);
+  template <typename C> static meta_no  testFunctor(...);
+
+  enum { value = sizeof(testFunctor<T>(static_cast<T*>(0))) == sizeof(meta_yes) };
+};
+
+template<typename T> const T* return_ptr();
+
+template <typename T, typename IndexType=Index>
+struct has_nullary_operator
+{
+  template <typename C> static meta_yes testFunctor(C const *,typename enable_if<(sizeof(return_ptr<C>()->operator()())>0)>::type * = 0);
+  static meta_no testFunctor(...);
+
+  enum { value = sizeof(testFunctor(static_cast<T*>(0))) == sizeof(meta_yes) };
+};
+
+template <typename T, typename IndexType=Index>
+struct has_unary_operator
+{
+  template <typename C> static meta_yes testFunctor(C const *,typename enable_if<(sizeof(return_ptr<C>()->operator()(IndexType(0)))>0)>::type * = 0);
+  static meta_no testFunctor(...);
+
+  enum { value = sizeof(testFunctor(static_cast<T*>(0))) == sizeof(meta_yes) };
+};
+
+template <typename T, typename IndexType=Index>
+struct has_binary_operator
+{
+  template <typename C> static meta_yes testFunctor(C const *,typename enable_if<(sizeof(return_ptr<C>()->operator()(IndexType(0),IndexType(0)))>0)>::type * = 0);
+  static meta_no testFunctor(...);
+
+  enum { value = sizeof(testFunctor(static_cast<T*>(0))) == sizeof(meta_yes) };
+};
+
+/** \internal In short, it computes int(sqrt(\a Y)) with \a Y an integer.
+  * Usage example: \code meta_sqrt<1023>::ret \endcode
+  */
+template<int Y,
+         int InfX = 0,
+         int SupX = ((Y==1) ? 1 : Y/2),
+         bool Done = ((SupX-InfX)<=1 ? true : ((SupX*SupX <= Y) && ((SupX+1)*(SupX+1) > Y))) >
+                                // use ?: instead of || just to shut up a stupid gcc 4.3 warning
+class meta_sqrt
+{
+    enum {
+      MidX = (InfX+SupX)/2,
+      TakeInf = MidX*MidX > Y ? 1 : 0,
+      NewInf = int(TakeInf) ? InfX : int(MidX),
+      NewSup = int(TakeInf) ? int(MidX) : SupX
+    };
+  public:
+    enum { ret = meta_sqrt<Y,NewInf,NewSup>::ret };
+};
+
+template<int Y, int InfX, int SupX>
+class meta_sqrt<Y, InfX, SupX, true> { public:  enum { ret = (SupX*SupX <= Y) ? SupX : InfX }; };
+
+
+/** \internal Computes the least common multiple of two positive integer A and B
+  * at compile-time. It implements a naive algorithm testing all multiples of A.
+  * It thus works better if A>=B.
+  */
+template<int A, int B, int K=1, bool Done = ((A*K)%B)==0>
+struct meta_least_common_multiple
+{
+  enum { ret = meta_least_common_multiple<A,B,K+1>::ret };
+};
+template<int A, int B, int K>
+struct meta_least_common_multiple<A,B,K,true>
+{
+  enum { ret = A*K };
+};
+
+/** \internal determines whether the product of two numeric types is allowed and what the return type is */
+template<typename T, typename U> struct scalar_product_traits
+{
+  enum { Defined = 0 };
+};
+
+// FIXME quick workaround around current limitation of result_of
+// template<typename Scalar, typename ArgType0, typename ArgType1>
+// struct result_of<scalar_product_op<Scalar>(ArgType0,ArgType1)> {
+// typedef typename scalar_product_traits<typename remove_all<ArgType0>::type, typename remove_all<ArgType1>::type>::ReturnType type;
+// };
+
+} // end namespace internal
+
+namespace numext {
+  
+#if defined(EIGEN_CUDA_ARCH)
+template<typename T> EIGEN_DEVICE_FUNC   void swap(T &a, T &b) { T tmp = b; b = a; a = tmp; }
+#else
+template<typename T> EIGEN_STRONG_INLINE void swap(T &a, T &b) { std::swap(a,b); }
+#endif
+
+#if defined(EIGEN_CUDA_ARCH)
+using internal::device::numeric_limits;
+#else
+using std::numeric_limits;
+#endif
+
+// Integer division with rounding up.
+// T is assumed to be an integer type with a>=0, and b>0
+template<typename T>
+T div_ceil(const T &a, const T &b)
+{
+  return (a+b-1) / b;
+}
+
+} // end namespace numext
+
+} // end namespace Eigen
+
+#endif // EIGEN_META_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/NonMPL2.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/NonMPL2.h
new file mode 100644
index 00000000..1af67cf1
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/NonMPL2.h
@@ -0,0 +1,3 @@
+#ifdef EIGEN_MPL2_ONLY
+#error Including non-MPL2 code in EIGEN_MPL2_ONLY mode
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/ReenableStupidWarnings.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/ReenableStupidWarnings.h
new file mode 100644
index 00000000..86b60f52
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/ReenableStupidWarnings.h
@@ -0,0 +1,27 @@
+#ifdef EIGEN_WARNINGS_DISABLED
+#undef EIGEN_WARNINGS_DISABLED
+
+#ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS
+  #ifdef _MSC_VER
+    #pragma warning( pop )
+  #elif defined __INTEL_COMPILER
+    #pragma warning pop
+  #elif defined __clang__
+    #pragma clang diagnostic pop
+  #elif defined __GNUC__ && __GNUC__>=6
+    #pragma GCC diagnostic pop
+  #endif
+
+  #if defined __NVCC__
+//    Don't reenable the diagnostic messages, as it turns out these messages need
+//    to be disabled at the point of the template instantiation (i.e the user code)
+//    otherwise they'll be triggered by nvcc.
+//    #pragma diag_default code_is_unreachable
+//    #pragma diag_default initialization_not_reachable
+//    #pragma diag_default 2651
+//    #pragma diag_default 2653
+  #endif
+
+#endif
+
+#endif // EIGEN_WARNINGS_DISABLED
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/StaticAssert.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/StaticAssert.h
new file mode 100644
index 00000000..cb167890
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/StaticAssert.h
@@ -0,0 +1,216 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STATIC_ASSERT_H
+#define EIGEN_STATIC_ASSERT_H
+
+/* Some notes on Eigen's static assertion mechanism:
+ *
+ *  - in EIGEN_STATIC_ASSERT(CONDITION,MSG) the parameter CONDITION must be a compile time boolean
+ *    expression, and MSG an enum listed in struct internal::static_assertion<true>
+ *
+ *  - define EIGEN_NO_STATIC_ASSERT to disable them (and save compilation time)
+ *    in that case, the static assertion is converted to the following runtime assert:
+ *      eigen_assert(CONDITION && "MSG")
+ *
+ *  - currently EIGEN_STATIC_ASSERT can only be used in function scope
+ *
+ */
+
+#ifndef EIGEN_NO_STATIC_ASSERT
+
+  #if EIGEN_MAX_CPP_VER>=11 && (__has_feature(cxx_static_assert) || (defined(__cplusplus) && __cplusplus >= 201103L) || (EIGEN_COMP_MSVC >= 1600))
+
+    // if native static_assert is enabled, let's use it
+    #define EIGEN_STATIC_ASSERT(X,MSG) static_assert(X,#MSG);
+
+  #else // not CXX0X
+
+    namespace Eigen {
+
+    namespace internal {
+
+    template<bool condition>
+    struct static_assertion {};
+
+    template<>
+    struct static_assertion<true>
+    {
+      enum {
+        YOU_TRIED_CALLING_A_VECTOR_METHOD_ON_A_MATRIX=1,
+        YOU_MIXED_VECTORS_OF_DIFFERENT_SIZES=1,
+        YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES=1,
+        THIS_METHOD_IS_ONLY_FOR_VECTORS_OF_A_SPECIFIC_SIZE=1,
+        THIS_METHOD_IS_ONLY_FOR_MATRICES_OF_A_SPECIFIC_SIZE=1,
+        THIS_METHOD_IS_ONLY_FOR_OBJECTS_OF_A_SPECIFIC_SIZE=1,
+        OUT_OF_RANGE_ACCESS=1,
+        YOU_MADE_A_PROGRAMMING_MISTAKE=1,
+        EIGEN_INTERNAL_ERROR_PLEASE_FILE_A_BUG_REPORT=1,
+        EIGEN_INTERNAL_COMPILATION_ERROR_OR_YOU_MADE_A_PROGRAMMING_MISTAKE=1,
+        YOU_CALLED_A_FIXED_SIZE_METHOD_ON_A_DYNAMIC_SIZE_MATRIX_OR_VECTOR=1,
+        YOU_CALLED_A_DYNAMIC_SIZE_METHOD_ON_A_FIXED_SIZE_MATRIX_OR_VECTOR=1,
+        UNALIGNED_LOAD_AND_STORE_OPERATIONS_UNIMPLEMENTED_ON_ALTIVEC=1,
+        THIS_FUNCTION_IS_NOT_FOR_INTEGER_NUMERIC_TYPES=1,
+        FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED=1,
+        NUMERIC_TYPE_MUST_BE_REAL=1,
+        COEFFICIENT_WRITE_ACCESS_TO_SELFADJOINT_NOT_SUPPORTED=1,
+        WRITING_TO_TRIANGULAR_PART_WITH_UNIT_DIAGONAL_IS_NOT_SUPPORTED=1,
+        THIS_METHOD_IS_ONLY_FOR_FIXED_SIZE=1,
+        INVALID_MATRIX_PRODUCT=1,
+        INVALID_VECTOR_VECTOR_PRODUCT__IF_YOU_WANTED_A_DOT_OR_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTIONS=1,
+        INVALID_MATRIX_PRODUCT__IF_YOU_WANTED_A_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTION=1,
+        YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY=1,
+        THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES=1,
+        THIS_METHOD_IS_ONLY_FOR_ROW_MAJOR_MATRICES=1,
+        INVALID_MATRIX_TEMPLATE_PARAMETERS=1,
+        INVALID_MATRIXBASE_TEMPLATE_PARAMETERS=1,
+        BOTH_MATRICES_MUST_HAVE_THE_SAME_STORAGE_ORDER=1,
+        THIS_METHOD_IS_ONLY_FOR_DIAGONAL_MATRIX=1,
+        THE_MATRIX_OR_EXPRESSION_THAT_YOU_PASSED_DOES_NOT_HAVE_THE_EXPECTED_TYPE=1,
+        THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_WITH_DIRECT_MEMORY_ACCESS_SUCH_AS_MAP_OR_PLAIN_MATRICES=1,
+        YOU_ALREADY_SPECIFIED_THIS_STRIDE=1,
+        INVALID_STORAGE_ORDER_FOR_THIS_VECTOR_EXPRESSION=1,
+        THE_BRACKET_OPERATOR_IS_ONLY_FOR_VECTORS__USE_THE_PARENTHESIS_OPERATOR_INSTEAD=1,
+        PACKET_ACCESS_REQUIRES_TO_HAVE_INNER_STRIDE_FIXED_TO_1=1,
+        THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS=1,
+        YOU_CANNOT_MIX_ARRAYS_AND_MATRICES=1,
+        YOU_PERFORMED_AN_INVALID_TRANSFORMATION_CONVERSION=1,
+        THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY=1,
+        YOU_ARE_TRYING_TO_USE_AN_INDEX_BASED_ACCESSOR_ON_AN_EXPRESSION_THAT_DOES_NOT_SUPPORT_THAT=1,
+        THIS_METHOD_IS_ONLY_FOR_1x1_EXPRESSIONS=1,
+        THIS_METHOD_IS_ONLY_FOR_INNER_OR_LAZY_PRODUCTS=1,
+        THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_OF_BOOL=1,
+        THIS_METHOD_IS_ONLY_FOR_ARRAYS_NOT_MATRICES=1,
+        YOU_PASSED_A_ROW_VECTOR_BUT_A_COLUMN_VECTOR_WAS_EXPECTED=1,
+        YOU_PASSED_A_COLUMN_VECTOR_BUT_A_ROW_VECTOR_WAS_EXPECTED=1,
+        THE_INDEX_TYPE_MUST_BE_A_SIGNED_TYPE=1,
+        THE_STORAGE_ORDER_OF_BOTH_SIDES_MUST_MATCH=1,
+        OBJECT_ALLOCATED_ON_STACK_IS_TOO_BIG=1,
+        IMPLICIT_CONVERSION_TO_SCALAR_IS_FOR_INNER_PRODUCT_ONLY=1,
+        STORAGE_LAYOUT_DOES_NOT_MATCH=1,
+        EIGEN_INTERNAL_ERROR_PLEASE_FILE_A_BUG_REPORT__INVALID_COST_VALUE=1,
+        THIS_COEFFICIENT_ACCESSOR_TAKING_ONE_ACCESS_IS_ONLY_FOR_EXPRESSIONS_ALLOWING_LINEAR_ACCESS=1,
+        MATRIX_FREE_CONJUGATE_GRADIENT_IS_COMPATIBLE_WITH_UPPER_UNION_LOWER_MODE_ONLY=1,
+        THIS_TYPE_IS_NOT_SUPPORTED=1,
+        STORAGE_KIND_MUST_MATCH=1,
+        STORAGE_INDEX_MUST_MATCH=1,
+        CHOLMOD_SUPPORTS_DOUBLE_PRECISION_ONLY=1
+      };
+    };
+
+    } // end namespace internal
+
+    } // end namespace Eigen
+
+    // Specialized implementation for MSVC to avoid "conditional
+    // expression is constant" warnings.  This implementation doesn't
+    // appear to work under GCC, hence the multiple implementations.
+    #if EIGEN_COMP_MSVC
+
+      #define EIGEN_STATIC_ASSERT(CONDITION,MSG) \
+        {Eigen::internal::static_assertion<bool(CONDITION)>::MSG;}
+
+    #else
+      // In some cases clang interprets bool(CONDITION) as function declaration
+      #define EIGEN_STATIC_ASSERT(CONDITION,MSG) \
+        if (Eigen::internal::static_assertion<static_cast<bool>(CONDITION)>::MSG) {}
+
+    #endif
+
+  #endif // not CXX0X
+
+#else // EIGEN_NO_STATIC_ASSERT
+
+  #define EIGEN_STATIC_ASSERT(CONDITION,MSG) eigen_assert((CONDITION) && #MSG);
+
+#endif // EIGEN_NO_STATIC_ASSERT
+
+
+// static assertion failing if the type \a TYPE is not a vector type
+#define EIGEN_STATIC_ASSERT_VECTOR_ONLY(TYPE) \
+  EIGEN_STATIC_ASSERT(TYPE::IsVectorAtCompileTime, \
+                      YOU_TRIED_CALLING_A_VECTOR_METHOD_ON_A_MATRIX)
+
+// static assertion failing if the type \a TYPE is not fixed-size
+#define EIGEN_STATIC_ASSERT_FIXED_SIZE(TYPE) \
+  EIGEN_STATIC_ASSERT(TYPE::SizeAtCompileTime!=Eigen::Dynamic, \
+                      YOU_CALLED_A_FIXED_SIZE_METHOD_ON_A_DYNAMIC_SIZE_MATRIX_OR_VECTOR)
+
+// static assertion failing if the type \a TYPE is not dynamic-size
+#define EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(TYPE) \
+  EIGEN_STATIC_ASSERT(TYPE::SizeAtCompileTime==Eigen::Dynamic, \
+                      YOU_CALLED_A_DYNAMIC_SIZE_METHOD_ON_A_FIXED_SIZE_MATRIX_OR_VECTOR)
+
+// static assertion failing if the type \a TYPE is not a vector type of the given size
+#define EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(TYPE, SIZE) \
+  EIGEN_STATIC_ASSERT(TYPE::IsVectorAtCompileTime && TYPE::SizeAtCompileTime==SIZE, \
+                      THIS_METHOD_IS_ONLY_FOR_VECTORS_OF_A_SPECIFIC_SIZE)
+
+// static assertion failing if the type \a TYPE is not a vector type of the given size
+#define EIGEN_STATIC_ASSERT_MATRIX_SPECIFIC_SIZE(TYPE, ROWS, COLS) \
+  EIGEN_STATIC_ASSERT(TYPE::RowsAtCompileTime==ROWS && TYPE::ColsAtCompileTime==COLS, \
+                      THIS_METHOD_IS_ONLY_FOR_MATRICES_OF_A_SPECIFIC_SIZE)
+
+// static assertion failing if the two vector expression types are not compatible (same fixed-size or dynamic size)
+#define EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(TYPE0,TYPE1) \
+  EIGEN_STATIC_ASSERT( \
+      (int(TYPE0::SizeAtCompileTime)==Eigen::Dynamic \
+    || int(TYPE1::SizeAtCompileTime)==Eigen::Dynamic \
+    || int(TYPE0::SizeAtCompileTime)==int(TYPE1::SizeAtCompileTime)),\
+    YOU_MIXED_VECTORS_OF_DIFFERENT_SIZES)
+
+#define EIGEN_PREDICATE_SAME_MATRIX_SIZE(TYPE0,TYPE1) \
+     ( \
+        (int(Eigen::internal::size_of_xpr_at_compile_time<TYPE0>::ret)==0 && int(Eigen::internal::size_of_xpr_at_compile_time<TYPE1>::ret)==0) \
+    || (\
+          (int(TYPE0::RowsAtCompileTime)==Eigen::Dynamic \
+        || int(TYPE1::RowsAtCompileTime)==Eigen::Dynamic \
+        || int(TYPE0::RowsAtCompileTime)==int(TYPE1::RowsAtCompileTime)) \
+      &&  (int(TYPE0::ColsAtCompileTime)==Eigen::Dynamic \
+        || int(TYPE1::ColsAtCompileTime)==Eigen::Dynamic \
+        || int(TYPE0::ColsAtCompileTime)==int(TYPE1::ColsAtCompileTime))\
+       ) \
+     )
+
+#define EIGEN_STATIC_ASSERT_NON_INTEGER(TYPE) \
+    EIGEN_STATIC_ASSERT(!NumTraits<TYPE>::IsInteger, THIS_FUNCTION_IS_NOT_FOR_INTEGER_NUMERIC_TYPES)
+
+
+// static assertion failing if it is guaranteed at compile-time that the two matrix expression types have different sizes
+#define EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(TYPE0,TYPE1) \
+  EIGEN_STATIC_ASSERT( \
+     EIGEN_PREDICATE_SAME_MATRIX_SIZE(TYPE0,TYPE1),\
+    YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES)
+
+#define EIGEN_STATIC_ASSERT_SIZE_1x1(TYPE) \
+      EIGEN_STATIC_ASSERT((TYPE::RowsAtCompileTime == 1 || TYPE::RowsAtCompileTime == Dynamic) && \
+                          (TYPE::ColsAtCompileTime == 1 || TYPE::ColsAtCompileTime == Dynamic), \
+                          THIS_METHOD_IS_ONLY_FOR_1x1_EXPRESSIONS)
+
+#define EIGEN_STATIC_ASSERT_LVALUE(Derived) \
+      EIGEN_STATIC_ASSERT(Eigen::internal::is_lvalue<Derived>::value, \
+                          THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY)
+
+#define EIGEN_STATIC_ASSERT_ARRAYXPR(Derived) \
+      EIGEN_STATIC_ASSERT((Eigen::internal::is_same<typename Eigen::internal::traits<Derived>::XprKind, ArrayXpr>::value), \
+                          THIS_METHOD_IS_ONLY_FOR_ARRAYS_NOT_MATRICES)
+
+#define EIGEN_STATIC_ASSERT_SAME_XPR_KIND(Derived1, Derived2) \
+      EIGEN_STATIC_ASSERT((Eigen::internal::is_same<typename Eigen::internal::traits<Derived1>::XprKind, \
+                                             typename Eigen::internal::traits<Derived2>::XprKind \
+                                            >::value), \
+                          YOU_CANNOT_MIX_ARRAYS_AND_MATRICES)
+
+// Check that a cost value is positive, and that is stay within a reasonable range
+// TODO this check could be enabled for internal debugging only
+#define EIGEN_INTERNAL_CHECK_COST_VALUE(C) \
+      EIGEN_STATIC_ASSERT((C)>=0 && (C)<=HugeCost*HugeCost, EIGEN_INTERNAL_ERROR_PLEASE_FILE_A_BUG_REPORT__INVALID_COST_VALUE);
+
+#endif // EIGEN_STATIC_ASSERT_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/SymbolicIndex.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/SymbolicIndex.h
new file mode 100644
index 00000000..bb6349eb
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/SymbolicIndex.h
@@ -0,0 +1,300 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2017 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SYMBOLIC_INDEX_H
+#define EIGEN_SYMBOLIC_INDEX_H
+
+namespace Eigen {
+
+/** \namespace Eigen::Symbolic
+  * \ingroup Core_Module
+  *
+  * This namespace defines a set of classes and functions to build and evaluate symbolic expressions of scalar type Index.
+  * Here is a simple example:
+  *
+  * \code
+  * // First step, defines symbols:
+  * struct x_tag {};  static const Symbolic::SymbolExpr<x_tag> x;
+  * struct y_tag {};  static const Symbolic::SymbolExpr<y_tag> y;
+  * struct z_tag {};  static const Symbolic::SymbolExpr<z_tag> z;
+  *
+  * // Defines an expression:
+  * auto expr = (x+3)/y+z;
+  *
+  * // And evaluate it: (c++14)
+  * std::cout << expr.eval(x=6,y=3,z=-13) << "\n";
+  *
+  * // In c++98/11, only one symbol per expression is supported for now:
+  * auto expr98 = (3-x)/2;
+  * std::cout << expr98.eval(x=6) << "\n";
+  * \endcode
+  *
+  * It is currently only used internally to define and minipulate the placeholders::last and placeholders::end symbols in Eigen::seq and Eigen::seqN.
+  *
+  */
+namespace Symbolic {
+
+template<typename Tag> class Symbol;
+template<typename Arg0> class NegateExpr;
+template<typename Arg1,typename Arg2> class AddExpr;
+template<typename Arg1,typename Arg2> class ProductExpr;
+template<typename Arg1,typename Arg2> class QuotientExpr;
+
+// A simple wrapper around an integral value to provide the eval method.
+// We could also use a free-function symbolic_eval...
+template<typename IndexType=Index>
+class ValueExpr {
+public:
+  ValueExpr(IndexType val) : m_value(val) {}
+  template<typename T>
+  IndexType eval_impl(const T&) const { return m_value; }
+protected:
+  IndexType m_value;
+};
+
+// Specialization for compile-time value,
+// It is similar to ValueExpr(N) but this version helps the compiler to generate better code.
+template<int N>
+class ValueExpr<internal::FixedInt<N> > {
+public:
+  ValueExpr() {}
+  template<typename T>
+  Index eval_impl(const T&) const { return N; }
+};
+
+
+/** \class BaseExpr
+  * \ingroup Core_Module
+  * Common base class of any symbolic expressions
+  */
+template<typename Derived>
+class BaseExpr
+{
+public:
+  const Derived& derived() const { return *static_cast<const Derived*>(this); }
+
+  /** Evaluate the expression given the \a values of the symbols.
+    *
+    * \param values defines the values of the symbols, it can either be a SymbolValue or a std::tuple of SymbolValue
+    *               as constructed by SymbolExpr::operator= operator.
+    *
+    */
+  template<typename T>
+  Index eval(const T& values) const { return derived().eval_impl(values); }
+
+#if EIGEN_HAS_CXX14
+  template<typename... Types>
+  Index eval(Types&&... values) const { return derived().eval_impl(std::make_tuple(values...)); }
+#endif
+
+  NegateExpr<Derived> operator-() const { return NegateExpr<Derived>(derived()); }
+
+  AddExpr<Derived,ValueExpr<> > operator+(Index b) const
+  { return AddExpr<Derived,ValueExpr<> >(derived(),  b); }
+  AddExpr<Derived,ValueExpr<> > operator-(Index a) const
+  { return AddExpr<Derived,ValueExpr<> >(derived(), -a); }
+  ProductExpr<Derived,ValueExpr<> > operator*(Index a) const
+  { return ProductExpr<Derived,ValueExpr<> >(derived(),a); }
+  QuotientExpr<Derived,ValueExpr<> > operator/(Index a) const
+  { return QuotientExpr<Derived,ValueExpr<> >(derived(),a); }
+
+  friend AddExpr<Derived,ValueExpr<> > operator+(Index a, const BaseExpr& b)
+  { return AddExpr<Derived,ValueExpr<> >(b.derived(), a); }
+  friend AddExpr<NegateExpr<Derived>,ValueExpr<> > operator-(Index a, const BaseExpr& b)
+  { return AddExpr<NegateExpr<Derived>,ValueExpr<> >(-b.derived(), a); }
+  friend ProductExpr<ValueExpr<>,Derived> operator*(Index a, const BaseExpr& b)
+  { return ProductExpr<ValueExpr<>,Derived>(a,b.derived()); }
+  friend QuotientExpr<ValueExpr<>,Derived> operator/(Index a, const BaseExpr& b)
+  { return QuotientExpr<ValueExpr<>,Derived>(a,b.derived()); }
+
+  template<int N>
+  AddExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator+(internal::FixedInt<N>) const
+  { return AddExpr<Derived,ValueExpr<internal::FixedInt<N> > >(derived(), ValueExpr<internal::FixedInt<N> >()); }
+  template<int N>
+  AddExpr<Derived,ValueExpr<internal::FixedInt<-N> > > operator-(internal::FixedInt<N>) const
+  { return AddExpr<Derived,ValueExpr<internal::FixedInt<-N> > >(derived(), ValueExpr<internal::FixedInt<-N> >()); }
+  template<int N>
+  ProductExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator*(internal::FixedInt<N>) const
+  { return ProductExpr<Derived,ValueExpr<internal::FixedInt<N> > >(derived(),ValueExpr<internal::FixedInt<N> >()); }
+  template<int N>
+  QuotientExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator/(internal::FixedInt<N>) const
+  { return QuotientExpr<Derived,ValueExpr<internal::FixedInt<N> > >(derived(),ValueExpr<internal::FixedInt<N> >()); }
+
+  template<int N>
+  friend AddExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator+(internal::FixedInt<N>, const BaseExpr& b)
+  { return AddExpr<Derived,ValueExpr<internal::FixedInt<N> > >(b.derived(), ValueExpr<internal::FixedInt<N> >()); }
+  template<int N>
+  friend AddExpr<NegateExpr<Derived>,ValueExpr<internal::FixedInt<N> > > operator-(internal::FixedInt<N>, const BaseExpr& b)
+  { return AddExpr<NegateExpr<Derived>,ValueExpr<internal::FixedInt<N> > >(-b.derived(), ValueExpr<internal::FixedInt<N> >()); }
+  template<int N>
+  friend ProductExpr<ValueExpr<internal::FixedInt<N> >,Derived> operator*(internal::FixedInt<N>, const BaseExpr& b)
+  { return ProductExpr<ValueExpr<internal::FixedInt<N> >,Derived>(ValueExpr<internal::FixedInt<N> >(),b.derived()); }
+  template<int N>
+  friend QuotientExpr<ValueExpr<internal::FixedInt<N> >,Derived> operator/(internal::FixedInt<N>, const BaseExpr& b)
+  { return QuotientExpr<ValueExpr<internal::FixedInt<N> > ,Derived>(ValueExpr<internal::FixedInt<N> >(),b.derived()); }
+
+#if (!EIGEN_HAS_CXX14)
+  template<int N>
+  AddExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator+(internal::FixedInt<N> (*)()) const
+  { return AddExpr<Derived,ValueExpr<internal::FixedInt<N> > >(derived(), ValueExpr<internal::FixedInt<N> >()); }
+  template<int N>
+  AddExpr<Derived,ValueExpr<internal::FixedInt<-N> > > operator-(internal::FixedInt<N> (*)()) const
+  { return AddExpr<Derived,ValueExpr<internal::FixedInt<-N> > >(derived(), ValueExpr<internal::FixedInt<-N> >()); }
+  template<int N>
+  ProductExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator*(internal::FixedInt<N> (*)()) const
+  { return ProductExpr<Derived,ValueExpr<internal::FixedInt<N> > >(derived(),ValueExpr<internal::FixedInt<N> >()); }
+  template<int N>
+  QuotientExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator/(internal::FixedInt<N> (*)()) const
+  { return QuotientExpr<Derived,ValueExpr<internal::FixedInt<N> > >(derived(),ValueExpr<internal::FixedInt<N> >()); }
+
+  template<int N>
+  friend AddExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator+(internal::FixedInt<N> (*)(), const BaseExpr& b)
+  { return AddExpr<Derived,ValueExpr<internal::FixedInt<N> > >(b.derived(), ValueExpr<internal::FixedInt<N> >()); }
+  template<int N>
+  friend AddExpr<NegateExpr<Derived>,ValueExpr<internal::FixedInt<N> > > operator-(internal::FixedInt<N> (*)(), const BaseExpr& b)
+  { return AddExpr<NegateExpr<Derived>,ValueExpr<internal::FixedInt<N> > >(-b.derived(), ValueExpr<internal::FixedInt<N> >()); }
+  template<int N>
+  friend ProductExpr<ValueExpr<internal::FixedInt<N> >,Derived> operator*(internal::FixedInt<N> (*)(), const BaseExpr& b)
+  { return ProductExpr<ValueExpr<internal::FixedInt<N> >,Derived>(ValueExpr<internal::FixedInt<N> >(),b.derived()); }
+  template<int N>
+  friend QuotientExpr<ValueExpr<internal::FixedInt<N> >,Derived> operator/(internal::FixedInt<N> (*)(), const BaseExpr& b)
+  { return QuotientExpr<ValueExpr<internal::FixedInt<N> > ,Derived>(ValueExpr<internal::FixedInt<N> >(),b.derived()); }
+#endif
+
+
+  template<typename OtherDerived>
+  AddExpr<Derived,OtherDerived> operator+(const BaseExpr<OtherDerived> &b) const
+  { return AddExpr<Derived,OtherDerived>(derived(),  b.derived()); }
+
+  template<typename OtherDerived>
+  AddExpr<Derived,NegateExpr<OtherDerived> > operator-(const BaseExpr<OtherDerived> &b) const
+  { return AddExpr<Derived,NegateExpr<OtherDerived> >(derived(), -b.derived()); }
+
+  template<typename OtherDerived>
+  ProductExpr<Derived,OtherDerived> operator*(const BaseExpr<OtherDerived> &b) const
+  { return ProductExpr<Derived,OtherDerived>(derived(), b.derived()); }
+
+  template<typename OtherDerived>
+  QuotientExpr<Derived,OtherDerived> operator/(const BaseExpr<OtherDerived> &b) const
+  { return QuotientExpr<Derived,OtherDerived>(derived(), b.derived()); }
+};
+
+template<typename T>
+struct is_symbolic {
+  // BaseExpr has no conversion ctor, so we only have to check whether T can be staticaly cast to its base class BaseExpr<T>.
+  enum { value = internal::is_convertible<T,BaseExpr<T> >::value };
+};
+
+// Specialization for functions, because is_convertible fails in this case.
+// Useful in c++98/11 mode when testing is_symbolic<decltype(fix<N>)>
+template<typename T>
+struct is_symbolic<T (*)()> {
+  enum { value = false };
+};
+
+/** Represents the actual value of a symbol identified by its tag
+  *
+  * It is the return type of SymbolValue::operator=, and most of the time this is only way it is used.
+  */
+template<typename Tag>
+class SymbolValue
+{
+public:
+  /** Default constructor from the value \a val */
+  SymbolValue(Index val) : m_value(val) {}
+
+  /** \returns the stored value of the symbol */
+  Index value() const { return m_value; }
+protected:
+  Index m_value;
+};
+
+/** Expression of a symbol uniquely identified by the template parameter type \c tag */
+template<typename tag>
+class SymbolExpr : public BaseExpr<SymbolExpr<tag> >
+{
+public:
+  /** Alias to the template parameter \c tag */
+  typedef tag Tag;
+
+  SymbolExpr() {}
+
+  /** Associate the value \a val to the given symbol \c *this, uniquely identified by its \c Tag.
+    *
+    * The returned object should be passed to ExprBase::eval() to evaluate a given expression with this specified runtime-time value.
+    */
+  SymbolValue<Tag> operator=(Index val) const {
+    return SymbolValue<Tag>(val);
+  }
+
+  Index eval_impl(const SymbolValue<Tag> &values) const { return values.value(); }
+
+#if EIGEN_HAS_CXX14
+  // C++14 versions suitable for multiple symbols
+  template<typename... Types>
+  Index eval_impl(const std::tuple<Types...>& values) const { return std::get<SymbolValue<Tag> >(values).value(); }
+#endif
+};
+
+template<typename Arg0>
+class NegateExpr : public BaseExpr<NegateExpr<Arg0> >
+{
+public:
+  NegateExpr(const Arg0& arg0) : m_arg0(arg0) {}
+
+  template<typename T>
+  Index eval_impl(const T& values) const { return -m_arg0.eval_impl(values); }
+protected:
+  Arg0 m_arg0;
+};
+
+template<typename Arg0, typename Arg1>
+class AddExpr : public BaseExpr<AddExpr<Arg0,Arg1> >
+{
+public:
+  AddExpr(const Arg0& arg0, const Arg1& arg1) : m_arg0(arg0), m_arg1(arg1) {}
+
+  template<typename T>
+  Index eval_impl(const T& values) const { return m_arg0.eval_impl(values) + m_arg1.eval_impl(values); }
+protected:
+  Arg0 m_arg0;
+  Arg1 m_arg1;
+};
+
+template<typename Arg0, typename Arg1>
+class ProductExpr : public BaseExpr<ProductExpr<Arg0,Arg1> >
+{
+public:
+  ProductExpr(const Arg0& arg0, const Arg1& arg1) : m_arg0(arg0), m_arg1(arg1) {}
+
+  template<typename T>
+  Index eval_impl(const T& values) const { return m_arg0.eval_impl(values) * m_arg1.eval_impl(values); }
+protected:
+  Arg0 m_arg0;
+  Arg1 m_arg1;
+};
+
+template<typename Arg0, typename Arg1>
+class QuotientExpr : public BaseExpr<QuotientExpr<Arg0,Arg1> >
+{
+public:
+  QuotientExpr(const Arg0& arg0, const Arg1& arg1) : m_arg0(arg0), m_arg1(arg1) {}
+
+  template<typename T>
+  Index eval_impl(const T& values) const { return m_arg0.eval_impl(values) / m_arg1.eval_impl(values); }
+protected:
+  Arg0 m_arg0;
+  Arg1 m_arg1;
+};
+
+} // end namespace Symbolic
+
+} // end namespace Eigen
+
+#endif // EIGEN_SYMBOLIC_INDEX_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/XprHelper.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/XprHelper.h
new file mode 100644
index 00000000..10328be0
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Core/util/XprHelper.h
@@ -0,0 +1,835 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_XPRHELPER_H
+#define EIGEN_XPRHELPER_H
+
+// just a workaround because GCC seems to not really like empty structs
+// FIXME: gcc 4.3 generates bad code when strict-aliasing is enabled
+// so currently we simply disable this optimization for gcc 4.3
+#if EIGEN_COMP_GNUC && !EIGEN_GNUC_AT(4,3)
+  #define EIGEN_EMPTY_STRUCT_CTOR(X) \
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE X() {} \
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE X(const X& ) {}
+#else
+  #define EIGEN_EMPTY_STRUCT_CTOR(X)
+#endif
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename IndexDest, typename IndexSrc>
+EIGEN_DEVICE_FUNC
+inline IndexDest convert_index(const IndexSrc& idx) {
+  // for sizeof(IndexDest)>=sizeof(IndexSrc) compilers should be able to optimize this away:
+  eigen_internal_assert(idx <= NumTraits<IndexDest>::highest() && "Index value to big for target type");
+  return IndexDest(idx);
+}
+
+// true if T can be considered as an integral index (i.e., and integral type or enum)
+template<typename T> struct is_valid_index_type
+{
+  enum { value =
+#if EIGEN_HAS_TYPE_TRAITS
+   internal::is_integral<T>::value || std::is_enum<T>::value
+#else
+  // without C++11, we use is_convertible to Index instead of is_integral in order to treat enums as Index.
+  internal::is_convertible<T,Index>::value
+#endif
+  };
+};
+
+// promote_scalar_arg is an helper used in operation between an expression and a scalar, like:
+//    expression * scalar
+// Its role is to determine how the type T of the scalar operand should be promoted given the scalar type ExprScalar of the given expression.
+// The IsSupported template parameter must be provided by the caller as: internal::has_ReturnType<ScalarBinaryOpTraits<ExprScalar,T,op> >::value using the proper order for ExprScalar and T.
+// Then the logic is as follows:
+//  - if the operation is natively supported as defined by IsSupported, then the scalar type is not promoted, and T is returned.
+//  - otherwise, NumTraits<ExprScalar>::Literal is returned if T is implicitly convertible to NumTraits<ExprScalar>::Literal AND that this does not imply a float to integer conversion.
+//  - otherwise, ExprScalar is returned if T is implicitly convertible to ExprScalar AND that this does not imply a float to integer conversion.
+//  - In all other cases, the promoted type is not defined, and the respective operation is thus invalid and not available (SFINAE).
+template<typename ExprScalar,typename T, bool IsSupported>
+struct promote_scalar_arg;
+
+template<typename S,typename T>
+struct promote_scalar_arg<S,T,true>
+{
+  typedef T type;
+};
+
+// Recursively check safe conversion to PromotedType, and then ExprScalar if they are different.
+template<typename ExprScalar,typename T,typename PromotedType,
+  bool ConvertibleToLiteral = internal::is_convertible<T,PromotedType>::value,
+  bool IsSafe = NumTraits<T>::IsInteger || !NumTraits<PromotedType>::IsInteger>
+struct promote_scalar_arg_unsupported;
+
+// Start recursion with NumTraits<ExprScalar>::Literal
+template<typename S,typename T>
+struct promote_scalar_arg<S,T,false> : promote_scalar_arg_unsupported<S,T,typename NumTraits<S>::Literal> {};
+
+// We found a match!
+template<typename S,typename T, typename PromotedType>
+struct promote_scalar_arg_unsupported<S,T,PromotedType,true,true>
+{
+  typedef PromotedType type;
+};
+
+// No match, but no real-to-integer issues, and ExprScalar and current PromotedType are different,
+// so let's try to promote to ExprScalar
+template<typename ExprScalar,typename T, typename PromotedType>
+struct promote_scalar_arg_unsupported<ExprScalar,T,PromotedType,false,true>
+   : promote_scalar_arg_unsupported<ExprScalar,T,ExprScalar>
+{};
+
+// Unsafe real-to-integer, let's stop.
+template<typename S,typename T, typename PromotedType, bool ConvertibleToLiteral>
+struct promote_scalar_arg_unsupported<S,T,PromotedType,ConvertibleToLiteral,false> {};
+
+// T is not even convertible to ExprScalar, let's stop.
+template<typename S,typename T>
+struct promote_scalar_arg_unsupported<S,T,S,false,true> {};
+
+//classes inheriting no_assignment_operator don't generate a default operator=.
+class no_assignment_operator
+{
+  private:
+    no_assignment_operator& operator=(const no_assignment_operator&);
+};
+
+/** \internal return the index type with the largest number of bits */
+template<typename I1, typename I2>
+struct promote_index_type
+{
+  typedef typename conditional<(sizeof(I1)<sizeof(I2)), I2, I1>::type type;
+};
+
+/** \internal If the template parameter Value is Dynamic, this class is just a wrapper around a T variable that
+  * can be accessed using value() and setValue().
+  * Otherwise, this class is an empty structure and value() just returns the template parameter Value.
+  */
+template<typename T, int Value> class variable_if_dynamic
+{
+  public:
+    EIGEN_EMPTY_STRUCT_CTOR(variable_if_dynamic)
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit variable_if_dynamic(T v) { EIGEN_ONLY_USED_FOR_DEBUG(v); eigen_assert(v == T(Value)); }
+    EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T value() { return T(Value); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE operator T() const { return T(Value); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void setValue(T) {}
+};
+
+template<typename T> class variable_if_dynamic<T, Dynamic>
+{
+    T m_value;
+    EIGEN_DEVICE_FUNC variable_if_dynamic() { eigen_assert(false); }
+  public:
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit variable_if_dynamic(T value) : m_value(value) {}
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T value() const { return m_value; }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE operator T() const { return m_value; }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void setValue(T value) { m_value = value; }
+};
+
+/** \internal like variable_if_dynamic but for DynamicIndex
+  */
+template<typename T, int Value> class variable_if_dynamicindex
+{
+  public:
+    EIGEN_EMPTY_STRUCT_CTOR(variable_if_dynamicindex)
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit variable_if_dynamicindex(T v) { EIGEN_ONLY_USED_FOR_DEBUG(v); eigen_assert(v == T(Value)); }
+    EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T value() { return T(Value); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void setValue(T) {}
+};
+
+template<typename T> class variable_if_dynamicindex<T, DynamicIndex>
+{
+    T m_value;
+    EIGEN_DEVICE_FUNC variable_if_dynamicindex() { eigen_assert(false); }
+  public:
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit variable_if_dynamicindex(T value) : m_value(value) {}
+    EIGEN_DEVICE_FUNC T EIGEN_STRONG_INLINE value() const { return m_value; }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void setValue(T value) { m_value = value; }
+};
+
+template<typename T> struct functor_traits
+{
+  enum
+  {
+    Cost = 10,
+    PacketAccess = false,
+    IsRepeatable = false
+  };
+};
+
+template<typename T> struct packet_traits;
+
+template<typename T> struct unpacket_traits
+{
+  typedef T type;
+  typedef T half;
+  enum
+  {
+    size = 1,
+    alignment = 1
+  };
+};
+
+template<int Size, typename PacketType,
+         bool Stop = Size==Dynamic || (Size%unpacket_traits<PacketType>::size)==0 || is_same<PacketType,typename unpacket_traits<PacketType>::half>::value>
+struct find_best_packet_helper;
+
+template< int Size, typename PacketType>
+struct find_best_packet_helper<Size,PacketType,true>
+{
+  typedef PacketType type;
+};
+
+template<int Size, typename PacketType>
+struct find_best_packet_helper<Size,PacketType,false>
+{
+  typedef typename find_best_packet_helper<Size,typename unpacket_traits<PacketType>::half>::type type;
+};
+
+template<typename T, int Size>
+struct find_best_packet
+{
+  typedef typename find_best_packet_helper<Size,typename packet_traits<T>::type>::type type;
+};
+
+#if EIGEN_MAX_STATIC_ALIGN_BYTES>0
+template<int ArrayBytes, int AlignmentBytes,
+         bool Match     =  bool((ArrayBytes%AlignmentBytes)==0),
+         bool TryHalf   =  bool(EIGEN_MIN_ALIGN_BYTES<AlignmentBytes) >
+struct compute_default_alignment_helper
+{
+  enum { value = 0 };
+};
+
+template<int ArrayBytes, int AlignmentBytes, bool TryHalf>
+struct compute_default_alignment_helper<ArrayBytes, AlignmentBytes, true, TryHalf> // Match
+{
+  enum { value = AlignmentBytes };
+};
+
+template<int ArrayBytes, int AlignmentBytes>
+struct compute_default_alignment_helper<ArrayBytes, AlignmentBytes, false, true> // Try-half
+{
+  // current packet too large, try with an half-packet
+  enum { value = compute_default_alignment_helper<ArrayBytes, AlignmentBytes/2>::value };
+};
+#else
+// If static alignment is disabled, no need to bother.
+// This also avoids a division by zero in "bool Match =  bool((ArrayBytes%AlignmentBytes)==0)"
+template<int ArrayBytes, int AlignmentBytes>
+struct compute_default_alignment_helper
+{
+  enum { value = 0 };
+};
+#endif
+
+template<typename T, int Size> struct compute_default_alignment {
+  enum { value = compute_default_alignment_helper<Size*sizeof(T),EIGEN_MAX_STATIC_ALIGN_BYTES>::value };
+};
+
+template<typename T> struct compute_default_alignment<T,Dynamic> {
+  enum { value = EIGEN_MAX_ALIGN_BYTES };
+};
+
+template<typename _Scalar, int _Rows, int _Cols,
+         int _Options = AutoAlign |
+                          ( (_Rows==1 && _Cols!=1) ? RowMajor
+                          : (_Cols==1 && _Rows!=1) ? ColMajor
+                          : EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION ),
+         int _MaxRows = _Rows,
+         int _MaxCols = _Cols
+> class make_proper_matrix_type
+{
+    enum {
+      IsColVector = _Cols==1 && _Rows!=1,
+      IsRowVector = _Rows==1 && _Cols!=1,
+      Options = IsColVector ? (_Options | ColMajor) & ~RowMajor
+              : IsRowVector ? (_Options | RowMajor) & ~ColMajor
+              : _Options
+    };
+  public:
+    typedef Matrix<_Scalar, _Rows, _Cols, Options, _MaxRows, _MaxCols> type;
+};
+
+template<typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
+class compute_matrix_flags
+{
+    enum { row_major_bit = Options&RowMajor ? RowMajorBit : 0 };
+  public:
+    // FIXME currently we still have to handle DirectAccessBit at the expression level to handle DenseCoeffsBase<>
+    // and then propagate this information to the evaluator's flags.
+    // However, I (Gael) think that DirectAccessBit should only matter at the evaluation stage.
+    enum { ret = DirectAccessBit | LvalueBit | NestByRefBit | row_major_bit };
+};
+
+template<int _Rows, int _Cols> struct size_at_compile_time
+{
+  enum { ret = (_Rows==Dynamic || _Cols==Dynamic) ? Dynamic : _Rows * _Cols };
+};
+
+template<typename XprType> struct size_of_xpr_at_compile_time
+{
+  enum { ret = size_at_compile_time<traits<XprType>::RowsAtCompileTime,traits<XprType>::ColsAtCompileTime>::ret };
+};
+
+/* plain_matrix_type : the difference from eval is that plain_matrix_type is always a plain matrix type,
+ * whereas eval is a const reference in the case of a matrix
+ */
+
+template<typename T, typename StorageKind = typename traits<T>::StorageKind> struct plain_matrix_type;
+template<typename T, typename BaseClassType, int Flags> struct plain_matrix_type_dense;
+template<typename T> struct plain_matrix_type<T,Dense>
+{
+  typedef typename plain_matrix_type_dense<T,typename traits<T>::XprKind, traits<T>::Flags>::type type;
+};
+template<typename T> struct plain_matrix_type<T,DiagonalShape>
+{
+  typedef typename T::PlainObject type;
+};
+
+template<typename T, int Flags> struct plain_matrix_type_dense<T,MatrixXpr,Flags>
+{
+  typedef Matrix<typename traits<T>::Scalar,
+                traits<T>::RowsAtCompileTime,
+                traits<T>::ColsAtCompileTime,
+                AutoAlign | (Flags&RowMajorBit ? RowMajor : ColMajor),
+                traits<T>::MaxRowsAtCompileTime,
+                traits<T>::MaxColsAtCompileTime
+          > type;
+};
+
+template<typename T, int Flags> struct plain_matrix_type_dense<T,ArrayXpr,Flags>
+{
+  typedef Array<typename traits<T>::Scalar,
+                traits<T>::RowsAtCompileTime,
+                traits<T>::ColsAtCompileTime,
+                AutoAlign | (Flags&RowMajorBit ? RowMajor : ColMajor),
+                traits<T>::MaxRowsAtCompileTime,
+                traits<T>::MaxColsAtCompileTime
+          > type;
+};
+
+/* eval : the return type of eval(). For matrices, this is just a const reference
+ * in order to avoid a useless copy
+ */
+
+template<typename T, typename StorageKind = typename traits<T>::StorageKind> struct eval;
+
+template<typename T> struct eval<T,Dense>
+{
+  typedef typename plain_matrix_type<T>::type type;
+//   typedef typename T::PlainObject type;
+//   typedef T::Matrix<typename traits<T>::Scalar,
+//                 traits<T>::RowsAtCompileTime,
+//                 traits<T>::ColsAtCompileTime,
+//                 AutoAlign | (traits<T>::Flags&RowMajorBit ? RowMajor : ColMajor),
+//                 traits<T>::MaxRowsAtCompileTime,
+//                 traits<T>::MaxColsAtCompileTime
+//           > type;
+};
+
+template<typename T> struct eval<T,DiagonalShape>
+{
+  typedef typename plain_matrix_type<T>::type type;
+};
+
+// for matrices, no need to evaluate, just use a const reference to avoid a useless copy
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+struct eval<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>, Dense>
+{
+  typedef const Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>& type;
+};
+
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+struct eval<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>, Dense>
+{
+  typedef const Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>& type;
+};
+
+
+/* similar to plain_matrix_type, but using the evaluator's Flags */
+template<typename T, typename StorageKind = typename traits<T>::StorageKind> struct plain_object_eval;
+
+template<typename T>
+struct plain_object_eval<T,Dense>
+{
+  typedef typename plain_matrix_type_dense<T,typename traits<T>::XprKind, evaluator<T>::Flags>::type type;
+};
+
+
+/* plain_matrix_type_column_major : same as plain_matrix_type but guaranteed to be column-major
+ */
+template<typename T> struct plain_matrix_type_column_major
+{
+  enum { Rows = traits<T>::RowsAtCompileTime,
+         Cols = traits<T>::ColsAtCompileTime,
+         MaxRows = traits<T>::MaxRowsAtCompileTime,
+         MaxCols = traits<T>::MaxColsAtCompileTime
+  };
+  typedef Matrix<typename traits<T>::Scalar,
+                Rows,
+                Cols,
+                (MaxRows==1&&MaxCols!=1) ? RowMajor : ColMajor,
+                MaxRows,
+                MaxCols
+          > type;
+};
+
+/* plain_matrix_type_row_major : same as plain_matrix_type but guaranteed to be row-major
+ */
+template<typename T> struct plain_matrix_type_row_major
+{
+  enum { Rows = traits<T>::RowsAtCompileTime,
+         Cols = traits<T>::ColsAtCompileTime,
+         MaxRows = traits<T>::MaxRowsAtCompileTime,
+         MaxCols = traits<T>::MaxColsAtCompileTime
+  };
+  typedef Matrix<typename traits<T>::Scalar,
+                Rows,
+                Cols,
+                (MaxCols==1&&MaxRows!=1) ? RowMajor : ColMajor,
+                MaxRows,
+                MaxCols
+          > type;
+};
+
+/** \internal The reference selector for template expressions. The idea is that we don't
+  * need to use references for expressions since they are light weight proxy
+  * objects which should generate no copying overhead. */
+template <typename T>
+struct ref_selector
+{
+  typedef typename conditional<
+    bool(traits<T>::Flags & NestByRefBit),
+    T const&,
+    const T
+  >::type type;
+  
+  typedef typename conditional<
+    bool(traits<T>::Flags & NestByRefBit),
+    T &,
+    T
+  >::type non_const_type;
+};
+
+/** \internal Adds the const qualifier on the value-type of T2 if and only if T1 is a const type */
+template<typename T1, typename T2>
+struct transfer_constness
+{
+  typedef typename conditional<
+    bool(internal::is_const<T1>::value),
+    typename internal::add_const_on_value_type<T2>::type,
+    T2
+  >::type type;
+};
+
+
+// However, we still need a mechanism to detect whether an expression which is evaluated multiple time
+// has to be evaluated into a temporary.
+// That's the purpose of this new nested_eval helper:
+/** \internal Determines how a given expression should be nested when evaluated multiple times.
+  * For example, when you do a * (b+c), Eigen will determine how the expression b+c should be
+  * evaluated into the bigger product expression. The choice is between nesting the expression b+c as-is, or
+  * evaluating that expression b+c into a temporary variable d, and nest d so that the resulting expression is
+  * a*d. Evaluating can be beneficial for example if every coefficient access in the resulting expression causes
+  * many coefficient accesses in the nested expressions -- as is the case with matrix product for example.
+  *
+  * \tparam T the type of the expression being nested.
+  * \tparam n the number of coefficient accesses in the nested expression for each coefficient access in the bigger expression.
+  * \tparam PlainObject the type of the temporary if needed.
+  */
+template<typename T, int n, typename PlainObject = typename plain_object_eval<T>::type> struct nested_eval
+{
+  enum {
+    ScalarReadCost = NumTraits<typename traits<T>::Scalar>::ReadCost,
+    CoeffReadCost = evaluator<T>::CoeffReadCost,  // NOTE What if an evaluator evaluate itself into a tempory?
+                                                  //      Then CoeffReadCost will be small (e.g., 1) but we still have to evaluate, especially if n>1.
+                                                  //      This situation is already taken care by the EvalBeforeNestingBit flag, which is turned ON
+                                                  //      for all evaluator creating a temporary. This flag is then propagated by the parent evaluators.
+                                                  //      Another solution could be to count the number of temps?
+    NAsInteger = n == Dynamic ? HugeCost : n,
+    CostEval   = (NAsInteger+1) * ScalarReadCost + CoeffReadCost,
+    CostNoEval = NAsInteger * CoeffReadCost,
+    Evaluate = (int(evaluator<T>::Flags) & EvalBeforeNestingBit) || (int(CostEval) < int(CostNoEval))
+  };
+
+  typedef typename conditional<Evaluate, PlainObject, typename ref_selector<T>::type>::type type;
+};
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+inline T* const_cast_ptr(const T* ptr)
+{
+  return const_cast<T*>(ptr);
+}
+
+template<typename Derived, typename XprKind = typename traits<Derived>::XprKind>
+struct dense_xpr_base
+{
+  /* dense_xpr_base should only ever be used on dense expressions, thus falling either into the MatrixXpr or into the ArrayXpr cases */
+};
+
+template<typename Derived>
+struct dense_xpr_base<Derived, MatrixXpr>
+{
+  typedef MatrixBase<Derived> type;
+};
+
+template<typename Derived>
+struct dense_xpr_base<Derived, ArrayXpr>
+{
+  typedef ArrayBase<Derived> type;
+};
+
+template<typename Derived, typename XprKind = typename traits<Derived>::XprKind, typename StorageKind = typename traits<Derived>::StorageKind>
+struct generic_xpr_base;
+
+template<typename Derived, typename XprKind>
+struct generic_xpr_base<Derived, XprKind, Dense>
+{
+  typedef typename dense_xpr_base<Derived,XprKind>::type type;
+};
+
+template<typename XprType, typename CastType> struct cast_return_type
+{
+  typedef typename XprType::Scalar CurrentScalarType;
+  typedef typename remove_all<CastType>::type _CastType;
+  typedef typename _CastType::Scalar NewScalarType;
+  typedef typename conditional<is_same<CurrentScalarType,NewScalarType>::value,
+                              const XprType&,CastType>::type type;
+};
+
+template <typename A, typename B> struct promote_storage_type;
+
+template <typename A> struct promote_storage_type<A,A>
+{
+  typedef A ret;
+};
+template <typename A> struct promote_storage_type<A, const A>
+{
+  typedef A ret;
+};
+template <typename A> struct promote_storage_type<const A, A>
+{
+  typedef A ret;
+};
+
+/** \internal Specify the "storage kind" of applying a coefficient-wise
+  * binary operations between two expressions of kinds A and B respectively.
+  * The template parameter Functor permits to specialize the resulting storage kind wrt to
+  * the functor.
+  * The default rules are as follows:
+  * \code
+  * A      op A      -> A
+  * A      op dense  -> dense
+  * dense  op B      -> dense
+  * sparse op dense  -> sparse
+  * dense  op sparse -> sparse
+  * \endcode
+  */
+template <typename A, typename B, typename Functor> struct cwise_promote_storage_type;
+
+template <typename A, typename Functor>                   struct cwise_promote_storage_type<A,A,Functor>                                      { typedef A      ret; };
+template <typename Functor>                               struct cwise_promote_storage_type<Dense,Dense,Functor>                              { typedef Dense  ret; };
+template <typename A, typename Functor>                   struct cwise_promote_storage_type<A,Dense,Functor>                                  { typedef Dense  ret; };
+template <typename B, typename Functor>                   struct cwise_promote_storage_type<Dense,B,Functor>                                  { typedef Dense  ret; };
+template <typename Functor>                               struct cwise_promote_storage_type<Sparse,Dense,Functor>                             { typedef Sparse ret; };
+template <typename Functor>                               struct cwise_promote_storage_type<Dense,Sparse,Functor>                             { typedef Sparse ret; };
+
+template <typename LhsKind, typename RhsKind, int LhsOrder, int RhsOrder> struct cwise_promote_storage_order {
+  enum { value = LhsOrder };
+};
+
+template <typename LhsKind, int LhsOrder, int RhsOrder>   struct cwise_promote_storage_order<LhsKind,Sparse,LhsOrder,RhsOrder>                { enum { value = RhsOrder }; };
+template <typename RhsKind, int LhsOrder, int RhsOrder>   struct cwise_promote_storage_order<Sparse,RhsKind,LhsOrder,RhsOrder>                { enum { value = LhsOrder }; };
+template <int Order>                                      struct cwise_promote_storage_order<Sparse,Sparse,Order,Order>                       { enum { value = Order }; };
+
+
+/** \internal Specify the "storage kind" of multiplying an expression of kind A with kind B.
+  * The template parameter ProductTag permits to specialize the resulting storage kind wrt to
+  * some compile-time properties of the product: GemmProduct, GemvProduct, OuterProduct, InnerProduct.
+  * The default rules are as follows:
+  * \code
+  *  K * K            -> K
+  *  dense * K        -> dense
+  *  K * dense        -> dense
+  *  diag * K         -> K
+  *  K * diag         -> K
+  *  Perm * K         -> K
+  * K * Perm          -> K
+  * \endcode
+  */
+template <typename A, typename B, int ProductTag> struct product_promote_storage_type;
+
+template <typename A, int ProductTag> struct product_promote_storage_type<A,                  A,                  ProductTag> { typedef A     ret;};
+template <int ProductTag>             struct product_promote_storage_type<Dense,              Dense,              ProductTag> { typedef Dense ret;};
+template <typename A, int ProductTag> struct product_promote_storage_type<A,                  Dense,              ProductTag> { typedef Dense ret; };
+template <typename B, int ProductTag> struct product_promote_storage_type<Dense,              B,                  ProductTag> { typedef Dense ret; };
+
+template <typename A, int ProductTag> struct product_promote_storage_type<A,                  DiagonalShape,      ProductTag> { typedef A ret; };
+template <typename B, int ProductTag> struct product_promote_storage_type<DiagonalShape,      B,                  ProductTag> { typedef B ret; };
+template <int ProductTag>             struct product_promote_storage_type<Dense,              DiagonalShape,      ProductTag> { typedef Dense ret; };
+template <int ProductTag>             struct product_promote_storage_type<DiagonalShape,      Dense,              ProductTag> { typedef Dense ret; };
+
+template <typename A, int ProductTag> struct product_promote_storage_type<A,                  PermutationStorage, ProductTag> { typedef A ret; };
+template <typename B, int ProductTag> struct product_promote_storage_type<PermutationStorage, B,                  ProductTag> { typedef B ret; };
+template <int ProductTag>             struct product_promote_storage_type<Dense,              PermutationStorage, ProductTag> { typedef Dense ret; };
+template <int ProductTag>             struct product_promote_storage_type<PermutationStorage, Dense,              ProductTag> { typedef Dense ret; };
+
+/** \internal gives the plain matrix or array type to store a row/column/diagonal of a matrix type.
+  * \tparam Scalar optional parameter allowing to pass a different scalar type than the one of the MatrixType.
+  */
+template<typename ExpressionType, typename Scalar = typename ExpressionType::Scalar>
+struct plain_row_type
+{
+  typedef Matrix<Scalar, 1, ExpressionType::ColsAtCompileTime,
+                 ExpressionType::PlainObject::Options | RowMajor, 1, ExpressionType::MaxColsAtCompileTime> MatrixRowType;
+  typedef Array<Scalar, 1, ExpressionType::ColsAtCompileTime,
+                 ExpressionType::PlainObject::Options | RowMajor, 1, ExpressionType::MaxColsAtCompileTime> ArrayRowType;
+
+  typedef typename conditional<
+    is_same< typename traits<ExpressionType>::XprKind, MatrixXpr >::value,
+    MatrixRowType,
+    ArrayRowType 
+  >::type type;
+};
+
+template<typename ExpressionType, typename Scalar = typename ExpressionType::Scalar>
+struct plain_col_type
+{
+  typedef Matrix<Scalar, ExpressionType::RowsAtCompileTime, 1,
+                 ExpressionType::PlainObject::Options & ~RowMajor, ExpressionType::MaxRowsAtCompileTime, 1> MatrixColType;
+  typedef Array<Scalar, ExpressionType::RowsAtCompileTime, 1,
+                 ExpressionType::PlainObject::Options & ~RowMajor, ExpressionType::MaxRowsAtCompileTime, 1> ArrayColType;
+
+  typedef typename conditional<
+    is_same< typename traits<ExpressionType>::XprKind, MatrixXpr >::value,
+    MatrixColType,
+    ArrayColType 
+  >::type type;
+};
+
+template<typename ExpressionType, typename Scalar = typename ExpressionType::Scalar>
+struct plain_diag_type
+{
+  enum { diag_size = EIGEN_SIZE_MIN_PREFER_DYNAMIC(ExpressionType::RowsAtCompileTime, ExpressionType::ColsAtCompileTime),
+         max_diag_size = EIGEN_SIZE_MIN_PREFER_FIXED(ExpressionType::MaxRowsAtCompileTime, ExpressionType::MaxColsAtCompileTime)
+  };
+  typedef Matrix<Scalar, diag_size, 1, ExpressionType::PlainObject::Options & ~RowMajor, max_diag_size, 1> MatrixDiagType;
+  typedef Array<Scalar, diag_size, 1, ExpressionType::PlainObject::Options & ~RowMajor, max_diag_size, 1> ArrayDiagType;
+
+  typedef typename conditional<
+    is_same< typename traits<ExpressionType>::XprKind, MatrixXpr >::value,
+    MatrixDiagType,
+    ArrayDiagType 
+  >::type type;
+};
+
+template<typename Expr,typename Scalar = typename Expr::Scalar>
+struct plain_constant_type
+{
+  enum { Options = (traits<Expr>::Flags&RowMajorBit)?RowMajor:0 };
+
+  typedef Array<Scalar,  traits<Expr>::RowsAtCompileTime,   traits<Expr>::ColsAtCompileTime,
+                Options, traits<Expr>::MaxRowsAtCompileTime,traits<Expr>::MaxColsAtCompileTime> array_type;
+
+  typedef Matrix<Scalar,  traits<Expr>::RowsAtCompileTime,   traits<Expr>::ColsAtCompileTime,
+                 Options, traits<Expr>::MaxRowsAtCompileTime,traits<Expr>::MaxColsAtCompileTime> matrix_type;
+
+  typedef CwiseNullaryOp<scalar_constant_op<Scalar>, const typename conditional<is_same< typename traits<Expr>::XprKind, MatrixXpr >::value, matrix_type, array_type>::type > type;
+};
+
+template<typename ExpressionType>
+struct is_lvalue
+{
+  enum { value = (!bool(is_const<ExpressionType>::value)) &&
+                 bool(traits<ExpressionType>::Flags & LvalueBit) };
+};
+
+template<typename T> struct is_diagonal
+{ enum { ret = false }; };
+
+template<typename T> struct is_diagonal<DiagonalBase<T> >
+{ enum { ret = true }; };
+
+template<typename T> struct is_diagonal<DiagonalWrapper<T> >
+{ enum { ret = true }; };
+
+template<typename T, int S> struct is_diagonal<DiagonalMatrix<T,S> >
+{ enum { ret = true }; };
+
+template<typename S1, typename S2> struct glue_shapes;
+template<> struct glue_shapes<DenseShape,TriangularShape> { typedef TriangularShape type;  };
+
+template<typename T1, typename T2>
+bool is_same_dense(const T1 &mat1, const T2 &mat2, typename enable_if<has_direct_access<T1>::ret&&has_direct_access<T2>::ret, T1>::type * = 0)
+{
+  return (mat1.data()==mat2.data()) && (mat1.innerStride()==mat2.innerStride()) && (mat1.outerStride()==mat2.outerStride());
+}
+
+template<typename T1, typename T2>
+bool is_same_dense(const T1 &, const T2 &, typename enable_if<!(has_direct_access<T1>::ret&&has_direct_access<T2>::ret), T1>::type * = 0)
+{
+  return false;
+}
+
+// Internal helper defining the cost of a scalar division for the type T.
+// The default heuristic can be specialized for each scalar type and architecture.
+template<typename T,bool Vectorized=false,typename EnableIf = void>
+struct scalar_div_cost {
+  enum { value = 8*NumTraits<T>::MulCost };
+};
+
+template<typename T,bool Vectorized>
+struct scalar_div_cost<std::complex<T>, Vectorized> {
+  enum { value = 2*scalar_div_cost<T>::value
+               + 6*NumTraits<T>::MulCost
+               + 3*NumTraits<T>::AddCost
+  };
+};
+
+
+template<bool Vectorized>
+struct scalar_div_cost<signed long,Vectorized,typename conditional<sizeof(long)==8,void,false_type>::type> { enum { value = 24 }; };
+template<bool Vectorized>
+struct scalar_div_cost<unsigned long,Vectorized,typename conditional<sizeof(long)==8,void,false_type>::type> { enum { value = 21 }; };
+
+
+#ifdef EIGEN_DEBUG_ASSIGN
+std::string demangle_traversal(int t)
+{
+  if(t==DefaultTraversal) return "DefaultTraversal";
+  if(t==LinearTraversal) return "LinearTraversal";
+  if(t==InnerVectorizedTraversal) return "InnerVectorizedTraversal";
+  if(t==LinearVectorizedTraversal) return "LinearVectorizedTraversal";
+  if(t==SliceVectorizedTraversal) return "SliceVectorizedTraversal";
+  return "?";
+}
+std::string demangle_unrolling(int t)
+{
+  if(t==NoUnrolling) return "NoUnrolling";
+  if(t==InnerUnrolling) return "InnerUnrolling";
+  if(t==CompleteUnrolling) return "CompleteUnrolling";
+  return "?";
+}
+std::string demangle_flags(int f)
+{
+  std::string res;
+  if(f&RowMajorBit)                 res += " | RowMajor";
+  if(f&PacketAccessBit)             res += " | Packet";
+  if(f&LinearAccessBit)             res += " | Linear";
+  if(f&LvalueBit)                   res += " | Lvalue";
+  if(f&DirectAccessBit)             res += " | Direct";
+  if(f&NestByRefBit)                res += " | NestByRef";
+  if(f&NoPreferredStorageOrderBit)  res += " | NoPreferredStorageOrderBit";
+  
+  return res;
+}
+#endif
+
+} // end namespace internal
+
+
+/** \class ScalarBinaryOpTraits
+  * \ingroup Core_Module
+  *
+  * \brief Determines whether the given binary operation of two numeric types is allowed and what the scalar return type is.
+  *
+  * This class permits to control the scalar return type of any binary operation performed on two different scalar types through (partial) template specializations.
+  *
+  * For instance, let \c U1, \c U2 and \c U3 be three user defined scalar types for which most operations between instances of \c U1 and \c U2 returns an \c U3.
+  * You can let %Eigen knows that by defining:
+    \code
+    template<typename BinaryOp>
+    struct ScalarBinaryOpTraits<U1,U2,BinaryOp> { typedef U3 ReturnType;  };
+    template<typename BinaryOp>
+    struct ScalarBinaryOpTraits<U2,U1,BinaryOp> { typedef U3 ReturnType;  };
+    \endcode
+  * You can then explicitly disable some particular operations to get more explicit error messages:
+    \code
+    template<>
+    struct ScalarBinaryOpTraits<U1,U2,internal::scalar_max_op<U1,U2> > {};
+    \endcode
+  * Or customize the return type for individual operation:
+    \code
+    template<>
+    struct ScalarBinaryOpTraits<U1,U2,internal::scalar_sum_op<U1,U2> > { typedef U1 ReturnType; };
+    \endcode
+  *
+  * By default, the following generic combinations are supported:
+  <table class="manual">
+  <tr><th>ScalarA</th><th>ScalarB</th><th>BinaryOp</th><th>ReturnType</th><th>Note</th></tr>
+  <tr            ><td>\c T </td><td>\c T </td><td>\c * </td><td>\c T </td><td></td></tr>
+  <tr class="alt"><td>\c NumTraits<T>::Real </td><td>\c T </td><td>\c * </td><td>\c T </td><td>Only if \c NumTraits<T>::IsComplex </td></tr>
+  <tr            ><td>\c T </td><td>\c NumTraits<T>::Real </td><td>\c * </td><td>\c T </td><td>Only if \c NumTraits<T>::IsComplex </td></tr>
+  </table>
+  *
+  * \sa CwiseBinaryOp
+  */
+template<typename ScalarA, typename ScalarB, typename BinaryOp=internal::scalar_product_op<ScalarA,ScalarB> >
+struct ScalarBinaryOpTraits
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+  // for backward compatibility, use the hints given by the (deprecated) internal::scalar_product_traits class.
+  : internal::scalar_product_traits<ScalarA,ScalarB>
+#endif // EIGEN_PARSED_BY_DOXYGEN
+{};
+
+template<typename T, typename BinaryOp>
+struct ScalarBinaryOpTraits<T,T,BinaryOp>
+{
+  typedef T ReturnType;
+};
+
+template <typename T, typename BinaryOp>
+struct ScalarBinaryOpTraits<T, typename NumTraits<typename internal::enable_if<NumTraits<T>::IsComplex,T>::type>::Real, BinaryOp>
+{
+  typedef T ReturnType;
+};
+template <typename T, typename BinaryOp>
+struct ScalarBinaryOpTraits<typename NumTraits<typename internal::enable_if<NumTraits<T>::IsComplex,T>::type>::Real, T, BinaryOp>
+{
+  typedef T ReturnType;
+};
+
+// For Matrix * Permutation
+template<typename T, typename BinaryOp>
+struct ScalarBinaryOpTraits<T,void,BinaryOp>
+{
+  typedef T ReturnType;
+};
+
+// For Permutation * Matrix
+template<typename T, typename BinaryOp>
+struct ScalarBinaryOpTraits<void,T,BinaryOp>
+{
+  typedef T ReturnType;
+};
+
+// for Permutation*Permutation
+template<typename BinaryOp>
+struct ScalarBinaryOpTraits<void,void,BinaryOp>
+{
+  typedef void ReturnType;
+};
+
+// We require Lhs and Rhs to have "compatible" scalar types.
+// It is tempting to always allow mixing different types but remember that this is often impossible in the vectorized paths.
+// So allowing mixing different types gives very unexpected errors when enabling vectorization, when the user tries to
+// add together a float matrix and a double matrix.
+#define EIGEN_CHECK_BINARY_COMPATIBILIY(BINOP,LHS,RHS) \
+  EIGEN_STATIC_ASSERT((Eigen::internal::has_ReturnType<ScalarBinaryOpTraits<LHS, RHS,BINOP> >::value), \
+    YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+    
+} // end namespace Eigen
+
+#endif // EIGEN_XPRHELPER_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/ComplexEigenSolver.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/ComplexEigenSolver.h
new file mode 100644
index 00000000..dc5fae06
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/ComplexEigenSolver.h
@@ -0,0 +1,346 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Claire Maurice
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010,2012 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLEX_EIGEN_SOLVER_H
+#define EIGEN_COMPLEX_EIGEN_SOLVER_H
+
+#include "./ComplexSchur.h"
+
+namespace Eigen { 
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  *
+  * \class ComplexEigenSolver
+  *
+  * \brief Computes eigenvalues and eigenvectors of general complex matrices
+  *
+  * \tparam _MatrixType the type of the matrix of which we are
+  * computing the eigendecomposition; this is expected to be an
+  * instantiation of the Matrix class template.
+  *
+  * The eigenvalues and eigenvectors of a matrix \f$ A \f$ are scalars
+  * \f$ \lambda \f$ and vectors \f$ v \f$ such that \f$ Av = \lambda v
+  * \f$.  If \f$ D \f$ is a diagonal matrix with the eigenvalues on
+  * the diagonal, and \f$ V \f$ is a matrix with the eigenvectors as
+  * its columns, then \f$ A V = V D \f$. The matrix \f$ V \f$ is
+  * almost always invertible, in which case we have \f$ A = V D V^{-1}
+  * \f$. This is called the eigendecomposition.
+  *
+  * The main function in this class is compute(), which computes the
+  * eigenvalues and eigenvectors of a given function. The
+  * documentation for that function contains an example showing the
+  * main features of the class.
+  *
+  * \sa class EigenSolver, class SelfAdjointEigenSolver
+  */
+template<typename _MatrixType> class ComplexEigenSolver
+{
+  public:
+
+    /** \brief Synonym for the template parameter \p _MatrixType. */
+    typedef _MatrixType MatrixType;
+
+    enum {
+      RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      Options = MatrixType::Options,
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+
+    /** \brief Scalar type for matrices of type #MatrixType. */
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+
+    /** \brief Complex scalar type for #MatrixType.
+      *
+      * This is \c std::complex<Scalar> if #Scalar is real (e.g.,
+      * \c float or \c double) and just \c Scalar if #Scalar is
+      * complex.
+      */
+    typedef std::complex<RealScalar> ComplexScalar;
+
+    /** \brief Type for vector of eigenvalues as returned by eigenvalues().
+      *
+      * This is a column vector with entries of type #ComplexScalar.
+      * The length of the vector is the size of #MatrixType.
+      */
+    typedef Matrix<ComplexScalar, ColsAtCompileTime, 1, Options&(~RowMajor), MaxColsAtCompileTime, 1> EigenvalueType;
+
+    /** \brief Type for matrix of eigenvectors as returned by eigenvectors().
+      *
+      * This is a square matrix with entries of type #ComplexScalar.
+      * The size is the same as the size of #MatrixType.
+      */
+    typedef Matrix<ComplexScalar, RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime, MaxColsAtCompileTime> EigenvectorType;
+
+    /** \brief Default constructor.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via compute().
+      */
+    ComplexEigenSolver()
+            : m_eivec(),
+              m_eivalues(),
+              m_schur(),
+              m_isInitialized(false),
+              m_eigenvectorsOk(false),
+              m_matX()
+    {}
+
+    /** \brief Default Constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem \a size.
+      * \sa ComplexEigenSolver()
+      */
+    explicit ComplexEigenSolver(Index size)
+            : m_eivec(size, size),
+              m_eivalues(size),
+              m_schur(size),
+              m_isInitialized(false),
+              m_eigenvectorsOk(false),
+              m_matX(size, size)
+    {}
+
+    /** \brief Constructor; computes eigendecomposition of given matrix.
+      *
+      * \param[in]  matrix  Square matrix whose eigendecomposition is to be computed.
+      * \param[in]  computeEigenvectors  If true, both the eigenvectors and the
+      *    eigenvalues are computed; if false, only the eigenvalues are
+      *    computed.
+      *
+      * This constructor calls compute() to compute the eigendecomposition.
+      */
+    template<typename InputType>
+    explicit ComplexEigenSolver(const EigenBase<InputType>& matrix, bool computeEigenvectors = true)
+            : m_eivec(matrix.rows(),matrix.cols()),
+              m_eivalues(matrix.cols()),
+              m_schur(matrix.rows()),
+              m_isInitialized(false),
+              m_eigenvectorsOk(false),
+              m_matX(matrix.rows(),matrix.cols())
+    {
+      compute(matrix.derived(), computeEigenvectors);
+    }
+
+    /** \brief Returns the eigenvectors of given matrix.
+      *
+      * \returns  A const reference to the matrix whose columns are the eigenvectors.
+      *
+      * \pre Either the constructor
+      * ComplexEigenSolver(const MatrixType& matrix, bool) or the member
+      * function compute(const MatrixType& matrix, bool) has been called before
+      * to compute the eigendecomposition of a matrix, and
+      * \p computeEigenvectors was set to true (the default).
+      *
+      * This function returns a matrix whose columns are the eigenvectors. Column
+      * \f$ k \f$ is an eigenvector corresponding to eigenvalue number \f$ k
+      * \f$ as returned by eigenvalues().  The eigenvectors are normalized to
+      * have (Euclidean) norm equal to one. The matrix returned by this
+      * function is the matrix \f$ V \f$ in the eigendecomposition \f$ A = V D
+      * V^{-1} \f$, if it exists.
+      *
+      * Example: \include ComplexEigenSolver_eigenvectors.cpp
+      * Output: \verbinclude ComplexEigenSolver_eigenvectors.out
+      */
+    const EigenvectorType& eigenvectors() const
+    {
+      eigen_assert(m_isInitialized && "ComplexEigenSolver is not initialized.");
+      eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
+      return m_eivec;
+    }
+
+    /** \brief Returns the eigenvalues of given matrix.
+      *
+      * \returns A const reference to the column vector containing the eigenvalues.
+      *
+      * \pre Either the constructor
+      * ComplexEigenSolver(const MatrixType& matrix, bool) or the member
+      * function compute(const MatrixType& matrix, bool) has been called before
+      * to compute the eigendecomposition of a matrix.
+      *
+      * This function returns a column vector containing the
+      * eigenvalues. Eigenvalues are repeated according to their
+      * algebraic multiplicity, so there are as many eigenvalues as
+      * rows in the matrix. The eigenvalues are not sorted in any particular
+      * order.
+      *
+      * Example: \include ComplexEigenSolver_eigenvalues.cpp
+      * Output: \verbinclude ComplexEigenSolver_eigenvalues.out
+      */
+    const EigenvalueType& eigenvalues() const
+    {
+      eigen_assert(m_isInitialized && "ComplexEigenSolver is not initialized.");
+      return m_eivalues;
+    }
+
+    /** \brief Computes eigendecomposition of given matrix.
+      *
+      * \param[in]  matrix  Square matrix whose eigendecomposition is to be computed.
+      * \param[in]  computeEigenvectors  If true, both the eigenvectors and the
+      *    eigenvalues are computed; if false, only the eigenvalues are
+      *    computed.
+      * \returns    Reference to \c *this
+      *
+      * This function computes the eigenvalues of the complex matrix \p matrix.
+      * The eigenvalues() function can be used to retrieve them.  If
+      * \p computeEigenvectors is true, then the eigenvectors are also computed
+      * and can be retrieved by calling eigenvectors().
+      *
+      * The matrix is first reduced to Schur form using the
+      * ComplexSchur class. The Schur decomposition is then used to
+      * compute the eigenvalues and eigenvectors.
+      *
+      * The cost of the computation is dominated by the cost of the
+      * Schur decomposition, which is \f$ O(n^3) \f$ where \f$ n \f$
+      * is the size of the matrix.
+      *
+      * Example: \include ComplexEigenSolver_compute.cpp
+      * Output: \verbinclude ComplexEigenSolver_compute.out
+      */
+    template<typename InputType>
+    ComplexEigenSolver& compute(const EigenBase<InputType>& matrix, bool computeEigenvectors = true);
+
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was succesful, \c NoConvergence otherwise.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "ComplexEigenSolver is not initialized.");
+      return m_schur.info();
+    }
+
+    /** \brief Sets the maximum number of iterations allowed. */
+    ComplexEigenSolver& setMaxIterations(Index maxIters)
+    {
+      m_schur.setMaxIterations(maxIters);
+      return *this;
+    }
+
+    /** \brief Returns the maximum number of iterations. */
+    Index getMaxIterations()
+    {
+      return m_schur.getMaxIterations();
+    }
+
+  protected:
+    
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+    }
+    
+    EigenvectorType m_eivec;
+    EigenvalueType m_eivalues;
+    ComplexSchur<MatrixType> m_schur;
+    bool m_isInitialized;
+    bool m_eigenvectorsOk;
+    EigenvectorType m_matX;
+
+  private:
+    void doComputeEigenvectors(RealScalar matrixnorm);
+    void sortEigenvalues(bool computeEigenvectors);
+};
+
+
+template<typename MatrixType>
+template<typename InputType>
+ComplexEigenSolver<MatrixType>& 
+ComplexEigenSolver<MatrixType>::compute(const EigenBase<InputType>& matrix, bool computeEigenvectors)
+{
+  check_template_parameters();
+  
+  // this code is inspired from Jampack
+  eigen_assert(matrix.cols() == matrix.rows());
+
+  // Do a complex Schur decomposition, A = U T U^*
+  // The eigenvalues are on the diagonal of T.
+  m_schur.compute(matrix.derived(), computeEigenvectors);
+
+  if(m_schur.info() == Success)
+  {
+    m_eivalues = m_schur.matrixT().diagonal();
+    if(computeEigenvectors)
+      doComputeEigenvectors(m_schur.matrixT().norm());
+    sortEigenvalues(computeEigenvectors);
+  }
+
+  m_isInitialized = true;
+  m_eigenvectorsOk = computeEigenvectors;
+  return *this;
+}
+
+
+template<typename MatrixType>
+void ComplexEigenSolver<MatrixType>::doComputeEigenvectors(RealScalar matrixnorm)
+{
+  const Index n = m_eivalues.size();
+
+  matrixnorm = numext::maxi(matrixnorm,(std::numeric_limits<RealScalar>::min)());
+
+  // Compute X such that T = X D X^(-1), where D is the diagonal of T.
+  // The matrix X is unit triangular.
+  m_matX = EigenvectorType::Zero(n, n);
+  for(Index k=n-1 ; k>=0 ; k--)
+  {
+    m_matX.coeffRef(k,k) = ComplexScalar(1.0,0.0);
+    // Compute X(i,k) using the (i,k) entry of the equation X T = D X
+    for(Index i=k-1 ; i>=0 ; i--)
+    {
+      m_matX.coeffRef(i,k) = -m_schur.matrixT().coeff(i,k);
+      if(k-i-1>0)
+        m_matX.coeffRef(i,k) -= (m_schur.matrixT().row(i).segment(i+1,k-i-1) * m_matX.col(k).segment(i+1,k-i-1)).value();
+      ComplexScalar z = m_schur.matrixT().coeff(i,i) - m_schur.matrixT().coeff(k,k);
+      if(z==ComplexScalar(0))
+      {
+        // If the i-th and k-th eigenvalue are equal, then z equals 0.
+        // Use a small value instead, to prevent division by zero.
+        numext::real_ref(z) = NumTraits<RealScalar>::epsilon() * matrixnorm;
+      }
+      m_matX.coeffRef(i,k) = m_matX.coeff(i,k) / z;
+    }
+  }
+
+  // Compute V as V = U X; now A = U T U^* = U X D X^(-1) U^* = V D V^(-1)
+  m_eivec.noalias() = m_schur.matrixU() * m_matX;
+  // .. and normalize the eigenvectors
+  for(Index k=0 ; k<n ; k++)
+  {
+    m_eivec.col(k).normalize();
+  }
+}
+
+
+template<typename MatrixType>
+void ComplexEigenSolver<MatrixType>::sortEigenvalues(bool computeEigenvectors)
+{
+  const Index n =  m_eivalues.size();
+  for (Index i=0; i<n; i++)
+  {
+    Index k;
+    m_eivalues.cwiseAbs().tail(n-i).minCoeff(&k);
+    if (k != 0)
+    {
+      k += i;
+      std::swap(m_eivalues[k],m_eivalues[i]);
+      if(computeEigenvectors)
+	m_eivec.col(i).swap(m_eivec.col(k));
+    }
+  }
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_COMPLEX_EIGEN_SOLVER_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/ComplexSchur.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/ComplexSchur.h
new file mode 100644
index 00000000..7f38919f
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/ComplexSchur.h
@@ -0,0 +1,459 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Claire Maurice
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010,2012 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLEX_SCHUR_H
+#define EIGEN_COMPLEX_SCHUR_H
+
+#include "./HessenbergDecomposition.h"
+
+namespace Eigen { 
+
+namespace internal {
+template<typename MatrixType, bool IsComplex> struct complex_schur_reduce_to_hessenberg;
+}
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  *
+  * \class ComplexSchur
+  *
+  * \brief Performs a complex Schur decomposition of a real or complex square matrix
+  *
+  * \tparam _MatrixType the type of the matrix of which we are
+  * computing the Schur decomposition; this is expected to be an
+  * instantiation of the Matrix class template.
+  *
+  * Given a real or complex square matrix A, this class computes the
+  * Schur decomposition: \f$ A = U T U^*\f$ where U is a unitary
+  * complex matrix, and T is a complex upper triangular matrix.  The
+  * diagonal of the matrix T corresponds to the eigenvalues of the
+  * matrix A.
+  *
+  * Call the function compute() to compute the Schur decomposition of
+  * a given matrix. Alternatively, you can use the 
+  * ComplexSchur(const MatrixType&, bool) constructor which computes
+  * the Schur decomposition at construction time. Once the
+  * decomposition is computed, you can use the matrixU() and matrixT()
+  * functions to retrieve the matrices U and V in the decomposition.
+  *
+  * \note This code is inspired from Jampack
+  *
+  * \sa class RealSchur, class EigenSolver, class ComplexEigenSolver
+  */
+template<typename _MatrixType> class ComplexSchur
+{
+  public:
+    typedef _MatrixType MatrixType;
+    enum {
+      RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      Options = MatrixType::Options,
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+
+    /** \brief Scalar type for matrices of type \p _MatrixType. */
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+
+    /** \brief Complex scalar type for \p _MatrixType. 
+      *
+      * This is \c std::complex<Scalar> if #Scalar is real (e.g.,
+      * \c float or \c double) and just \c Scalar if #Scalar is
+      * complex.
+      */
+    typedef std::complex<RealScalar> ComplexScalar;
+
+    /** \brief Type for the matrices in the Schur decomposition.
+      *
+      * This is a square matrix with entries of type #ComplexScalar. 
+      * The size is the same as the size of \p _MatrixType.
+      */
+    typedef Matrix<ComplexScalar, RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime, MaxColsAtCompileTime> ComplexMatrixType;
+
+    /** \brief Default constructor.
+      *
+      * \param [in] size  Positive integer, size of the matrix whose Schur decomposition will be computed.
+      *
+      * The default constructor is useful in cases in which the user
+      * intends to perform decompositions via compute().  The \p size
+      * parameter is only used as a hint. It is not an error to give a
+      * wrong \p size, but it may impair performance.
+      *
+      * \sa compute() for an example.
+      */
+    explicit ComplexSchur(Index size = RowsAtCompileTime==Dynamic ? 1 : RowsAtCompileTime)
+      : m_matT(size,size),
+        m_matU(size,size),
+        m_hess(size),
+        m_isInitialized(false),
+        m_matUisUptodate(false),
+        m_maxIters(-1)
+    {}
+
+    /** \brief Constructor; computes Schur decomposition of given matrix. 
+      * 
+      * \param[in]  matrix    Square matrix whose Schur decomposition is to be computed.
+      * \param[in]  computeU  If true, both T and U are computed; if false, only T is computed.
+      *
+      * This constructor calls compute() to compute the Schur decomposition.
+      *
+      * \sa matrixT() and matrixU() for examples.
+      */
+    template<typename InputType>
+    explicit ComplexSchur(const EigenBase<InputType>& matrix, bool computeU = true)
+      : m_matT(matrix.rows(),matrix.cols()),
+        m_matU(matrix.rows(),matrix.cols()),
+        m_hess(matrix.rows()),
+        m_isInitialized(false),
+        m_matUisUptodate(false),
+        m_maxIters(-1)
+    {
+      compute(matrix.derived(), computeU);
+    }
+
+    /** \brief Returns the unitary matrix in the Schur decomposition. 
+      *
+      * \returns A const reference to the matrix U.
+      *
+      * It is assumed that either the constructor
+      * ComplexSchur(const MatrixType& matrix, bool computeU) or the
+      * member function compute(const MatrixType& matrix, bool computeU)
+      * has been called before to compute the Schur decomposition of a
+      * matrix, and that \p computeU was set to true (the default
+      * value).
+      *
+      * Example: \include ComplexSchur_matrixU.cpp
+      * Output: \verbinclude ComplexSchur_matrixU.out
+      */
+    const ComplexMatrixType& matrixU() const
+    {
+      eigen_assert(m_isInitialized && "ComplexSchur is not initialized.");
+      eigen_assert(m_matUisUptodate && "The matrix U has not been computed during the ComplexSchur decomposition.");
+      return m_matU;
+    }
+
+    /** \brief Returns the triangular matrix in the Schur decomposition. 
+      *
+      * \returns A const reference to the matrix T.
+      *
+      * It is assumed that either the constructor
+      * ComplexSchur(const MatrixType& matrix, bool computeU) or the
+      * member function compute(const MatrixType& matrix, bool computeU)
+      * has been called before to compute the Schur decomposition of a
+      * matrix.
+      *
+      * Note that this function returns a plain square matrix. If you want to reference
+      * only the upper triangular part, use:
+      * \code schur.matrixT().triangularView<Upper>() \endcode 
+      *
+      * Example: \include ComplexSchur_matrixT.cpp
+      * Output: \verbinclude ComplexSchur_matrixT.out
+      */
+    const ComplexMatrixType& matrixT() const
+    {
+      eigen_assert(m_isInitialized && "ComplexSchur is not initialized.");
+      return m_matT;
+    }
+
+    /** \brief Computes Schur decomposition of given matrix. 
+      * 
+      * \param[in]  matrix  Square matrix whose Schur decomposition is to be computed.
+      * \param[in]  computeU  If true, both T and U are computed; if false, only T is computed.
+
+      * \returns    Reference to \c *this
+      *
+      * The Schur decomposition is computed by first reducing the
+      * matrix to Hessenberg form using the class
+      * HessenbergDecomposition. The Hessenberg matrix is then reduced
+      * to triangular form by performing QR iterations with a single
+      * shift. The cost of computing the Schur decomposition depends
+      * on the number of iterations; as a rough guide, it may be taken
+      * on the number of iterations; as a rough guide, it may be taken
+      * to be \f$25n^3\f$ complex flops, or \f$10n^3\f$ complex flops
+      * if \a computeU is false.
+      *
+      * Example: \include ComplexSchur_compute.cpp
+      * Output: \verbinclude ComplexSchur_compute.out
+      *
+      * \sa compute(const MatrixType&, bool, Index)
+      */
+    template<typename InputType>
+    ComplexSchur& compute(const EigenBase<InputType>& matrix, bool computeU = true);
+    
+    /** \brief Compute Schur decomposition from a given Hessenberg matrix
+     *  \param[in] matrixH Matrix in Hessenberg form H
+     *  \param[in] matrixQ orthogonal matrix Q that transform a matrix A to H : A = Q H Q^T
+     *  \param computeU Computes the matriX U of the Schur vectors
+     * \return Reference to \c *this
+     * 
+     *  This routine assumes that the matrix is already reduced in Hessenberg form matrixH
+     *  using either the class HessenbergDecomposition or another mean. 
+     *  It computes the upper quasi-triangular matrix T of the Schur decomposition of H
+     *  When computeU is true, this routine computes the matrix U such that 
+     *  A = U T U^T =  (QZ) T (QZ)^T = Q H Q^T where A is the initial matrix
+     * 
+     * NOTE Q is referenced if computeU is true; so, if the initial orthogonal matrix
+     * is not available, the user should give an identity matrix (Q.setIdentity())
+     * 
+     * \sa compute(const MatrixType&, bool)
+     */
+    template<typename HessMatrixType, typename OrthMatrixType>
+    ComplexSchur& computeFromHessenberg(const HessMatrixType& matrixH, const OrthMatrixType& matrixQ,  bool computeU=true);
+
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was succesful, \c NoConvergence otherwise.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "ComplexSchur is not initialized.");
+      return m_info;
+    }
+
+    /** \brief Sets the maximum number of iterations allowed. 
+      *
+      * If not specified by the user, the maximum number of iterations is m_maxIterationsPerRow times the size
+      * of the matrix.
+      */
+    ComplexSchur& setMaxIterations(Index maxIters)
+    {
+      m_maxIters = maxIters;
+      return *this;
+    }
+
+    /** \brief Returns the maximum number of iterations. */
+    Index getMaxIterations()
+    {
+      return m_maxIters;
+    }
+
+    /** \brief Maximum number of iterations per row.
+      *
+      * If not otherwise specified, the maximum number of iterations is this number times the size of the
+      * matrix. It is currently set to 30.
+      */
+    static const int m_maxIterationsPerRow = 30;
+
+  protected:
+    ComplexMatrixType m_matT, m_matU;
+    HessenbergDecomposition<MatrixType> m_hess;
+    ComputationInfo m_info;
+    bool m_isInitialized;
+    bool m_matUisUptodate;
+    Index m_maxIters;
+
+  private:  
+    bool subdiagonalEntryIsNeglegible(Index i);
+    ComplexScalar computeShift(Index iu, Index iter);
+    void reduceToTriangularForm(bool computeU);
+    friend struct internal::complex_schur_reduce_to_hessenberg<MatrixType, NumTraits<Scalar>::IsComplex>;
+};
+
+/** If m_matT(i+1,i) is neglegible in floating point arithmetic
+  * compared to m_matT(i,i) and m_matT(j,j), then set it to zero and
+  * return true, else return false. */
+template<typename MatrixType>
+inline bool ComplexSchur<MatrixType>::subdiagonalEntryIsNeglegible(Index i)
+{
+  RealScalar d = numext::norm1(m_matT.coeff(i,i)) + numext::norm1(m_matT.coeff(i+1,i+1));
+  RealScalar sd = numext::norm1(m_matT.coeff(i+1,i));
+  if (internal::isMuchSmallerThan(sd, d, NumTraits<RealScalar>::epsilon()))
+  {
+    m_matT.coeffRef(i+1,i) = ComplexScalar(0);
+    return true;
+  }
+  return false;
+}
+
+
+/** Compute the shift in the current QR iteration. */
+template<typename MatrixType>
+typename ComplexSchur<MatrixType>::ComplexScalar ComplexSchur<MatrixType>::computeShift(Index iu, Index iter)
+{
+  using std::abs;
+  if (iter == 10 || iter == 20) 
+  {
+    // exceptional shift, taken from http://www.netlib.org/eispack/comqr.f
+    return abs(numext::real(m_matT.coeff(iu,iu-1))) + abs(numext::real(m_matT.coeff(iu-1,iu-2)));
+  }
+
+  // compute the shift as one of the eigenvalues of t, the 2x2
+  // diagonal block on the bottom of the active submatrix
+  Matrix<ComplexScalar,2,2> t = m_matT.template block<2,2>(iu-1,iu-1);
+  RealScalar normt = t.cwiseAbs().sum();
+  t /= normt;     // the normalization by sf is to avoid under/overflow
+
+  ComplexScalar b = t.coeff(0,1) * t.coeff(1,0);
+  ComplexScalar c = t.coeff(0,0) - t.coeff(1,1);
+  ComplexScalar disc = sqrt(c*c + RealScalar(4)*b);
+  ComplexScalar det = t.coeff(0,0) * t.coeff(1,1) - b;
+  ComplexScalar trace = t.coeff(0,0) + t.coeff(1,1);
+  ComplexScalar eival1 = (trace + disc) / RealScalar(2);
+  ComplexScalar eival2 = (trace - disc) / RealScalar(2);
+
+  if(numext::norm1(eival1) > numext::norm1(eival2))
+    eival2 = det / eival1;
+  else
+    eival1 = det / eival2;
+
+  // choose the eigenvalue closest to the bottom entry of the diagonal
+  if(numext::norm1(eival1-t.coeff(1,1)) < numext::norm1(eival2-t.coeff(1,1)))
+    return normt * eival1;
+  else
+    return normt * eival2;
+}
+
+
+template<typename MatrixType>
+template<typename InputType>
+ComplexSchur<MatrixType>& ComplexSchur<MatrixType>::compute(const EigenBase<InputType>& matrix, bool computeU)
+{
+  m_matUisUptodate = false;
+  eigen_assert(matrix.cols() == matrix.rows());
+
+  if(matrix.cols() == 1)
+  {
+    m_matT = matrix.derived().template cast<ComplexScalar>();
+    if(computeU)  m_matU = ComplexMatrixType::Identity(1,1);
+    m_info = Success;
+    m_isInitialized = true;
+    m_matUisUptodate = computeU;
+    return *this;
+  }
+
+  internal::complex_schur_reduce_to_hessenberg<MatrixType, NumTraits<Scalar>::IsComplex>::run(*this, matrix.derived(), computeU);
+  computeFromHessenberg(m_matT, m_matU, computeU);
+  return *this;
+}
+
+template<typename MatrixType>
+template<typename HessMatrixType, typename OrthMatrixType>
+ComplexSchur<MatrixType>& ComplexSchur<MatrixType>::computeFromHessenberg(const HessMatrixType& matrixH, const OrthMatrixType& matrixQ, bool computeU)
+{
+  m_matT = matrixH;
+  if(computeU)
+    m_matU = matrixQ;
+  reduceToTriangularForm(computeU);
+  return *this;
+}
+namespace internal {
+
+/* Reduce given matrix to Hessenberg form */
+template<typename MatrixType, bool IsComplex>
+struct complex_schur_reduce_to_hessenberg
+{
+  // this is the implementation for the case IsComplex = true
+  static void run(ComplexSchur<MatrixType>& _this, const MatrixType& matrix, bool computeU)
+  {
+    _this.m_hess.compute(matrix);
+    _this.m_matT = _this.m_hess.matrixH();
+    if(computeU)  _this.m_matU = _this.m_hess.matrixQ();
+  }
+};
+
+template<typename MatrixType>
+struct complex_schur_reduce_to_hessenberg<MatrixType, false>
+{
+  static void run(ComplexSchur<MatrixType>& _this, const MatrixType& matrix, bool computeU)
+  {
+    typedef typename ComplexSchur<MatrixType>::ComplexScalar ComplexScalar;
+
+    // Note: m_hess is over RealScalar; m_matT and m_matU is over ComplexScalar
+    _this.m_hess.compute(matrix);
+    _this.m_matT = _this.m_hess.matrixH().template cast<ComplexScalar>();
+    if(computeU)  
+    {
+      // This may cause an allocation which seems to be avoidable
+      MatrixType Q = _this.m_hess.matrixQ(); 
+      _this.m_matU = Q.template cast<ComplexScalar>();
+    }
+  }
+};
+
+} // end namespace internal
+
+// Reduce the Hessenberg matrix m_matT to triangular form by QR iteration.
+template<typename MatrixType>
+void ComplexSchur<MatrixType>::reduceToTriangularForm(bool computeU)
+{  
+  Index maxIters = m_maxIters;
+  if (maxIters == -1)
+    maxIters = m_maxIterationsPerRow * m_matT.rows();
+
+  // The matrix m_matT is divided in three parts. 
+  // Rows 0,...,il-1 are decoupled from the rest because m_matT(il,il-1) is zero. 
+  // Rows il,...,iu is the part we are working on (the active submatrix).
+  // Rows iu+1,...,end are already brought in triangular form.
+  Index iu = m_matT.cols() - 1;
+  Index il;
+  Index iter = 0; // number of iterations we are working on the (iu,iu) element
+  Index totalIter = 0; // number of iterations for whole matrix
+
+  while(true)
+  {
+    // find iu, the bottom row of the active submatrix
+    while(iu > 0)
+    {
+      if(!subdiagonalEntryIsNeglegible(iu-1)) break;
+      iter = 0;
+      --iu;
+    }
+
+    // if iu is zero then we are done; the whole matrix is triangularized
+    if(iu==0) break;
+
+    // if we spent too many iterations, we give up
+    iter++;
+    totalIter++;
+    if(totalIter > maxIters) break;
+
+    // find il, the top row of the active submatrix
+    il = iu-1;
+    while(il > 0 && !subdiagonalEntryIsNeglegible(il-1))
+    {
+      --il;
+    }
+
+    /* perform the QR step using Givens rotations. The first rotation
+       creates a bulge; the (il+2,il) element becomes nonzero. This
+       bulge is chased down to the bottom of the active submatrix. */
+
+    ComplexScalar shift = computeShift(iu, iter);
+    JacobiRotation<ComplexScalar> rot;
+    rot.makeGivens(m_matT.coeff(il,il) - shift, m_matT.coeff(il+1,il));
+    m_matT.rightCols(m_matT.cols()-il).applyOnTheLeft(il, il+1, rot.adjoint());
+    m_matT.topRows((std::min)(il+2,iu)+1).applyOnTheRight(il, il+1, rot);
+    if(computeU) m_matU.applyOnTheRight(il, il+1, rot);
+
+    for(Index i=il+1 ; i<iu ; i++)
+    {
+      rot.makeGivens(m_matT.coeffRef(i,i-1), m_matT.coeffRef(i+1,i-1), &m_matT.coeffRef(i,i-1));
+      m_matT.coeffRef(i+1,i-1) = ComplexScalar(0);
+      m_matT.rightCols(m_matT.cols()-i).applyOnTheLeft(i, i+1, rot.adjoint());
+      m_matT.topRows((std::min)(i+2,iu)+1).applyOnTheRight(i, i+1, rot);
+      if(computeU) m_matU.applyOnTheRight(i, i+1, rot);
+    }
+  }
+
+  if(totalIter <= maxIters)
+    m_info = Success;
+  else
+    m_info = NoConvergence;
+
+  m_isInitialized = true;
+  m_matUisUptodate = computeU;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_COMPLEX_SCHUR_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
new file mode 100644
index 00000000..4980a3ed
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
@@ -0,0 +1,91 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to LAPACKe
+ *    Complex Schur needed to complex unsymmetrical eigenvalues/eigenvectors.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_COMPLEX_SCHUR_LAPACKE_H
+#define EIGEN_COMPLEX_SCHUR_LAPACKE_H
+
+namespace Eigen { 
+
+/** \internal Specialization for the data types supported by LAPACKe */
+
+#define EIGEN_LAPACKE_SCHUR_COMPLEX(EIGTYPE, LAPACKE_TYPE, LAPACKE_PREFIX, LAPACKE_PREFIX_U, EIGCOLROW, LAPACKE_COLROW) \
+template<> template<typename InputType> inline \
+ComplexSchur<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW> >& \
+ComplexSchur<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW> >::compute(const EigenBase<InputType>& matrix, bool computeU) \
+{ \
+  typedef Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW> MatrixType; \
+  typedef MatrixType::RealScalar RealScalar; \
+  typedef std::complex<RealScalar> ComplexScalar; \
+\
+  eigen_assert(matrix.cols() == matrix.rows()); \
+\
+  m_matUisUptodate = false; \
+  if(matrix.cols() == 1) \
+  { \
+    m_matT = matrix.derived().template cast<ComplexScalar>(); \
+    if(computeU)  m_matU = ComplexMatrixType::Identity(1,1); \
+      m_info = Success; \
+      m_isInitialized = true; \
+      m_matUisUptodate = computeU; \
+      return *this; \
+  } \
+  lapack_int n = internal::convert_index<lapack_int>(matrix.cols()), sdim, info; \
+  lapack_int matrix_order = LAPACKE_COLROW; \
+  char jobvs, sort='N'; \
+  LAPACK_##LAPACKE_PREFIX_U##_SELECT1 select = 0; \
+  jobvs = (computeU) ? 'V' : 'N'; \
+  m_matU.resize(n, n); \
+  lapack_int ldvs  = internal::convert_index<lapack_int>(m_matU.outerStride()); \
+  m_matT = matrix; \
+  lapack_int lda = internal::convert_index<lapack_int>(m_matT.outerStride()); \
+  Matrix<EIGTYPE, Dynamic, Dynamic> w; \
+  w.resize(n, 1);\
+  info = LAPACKE_##LAPACKE_PREFIX##gees( matrix_order, jobvs, sort, select, n, (LAPACKE_TYPE*)m_matT.data(), lda, &sdim, (LAPACKE_TYPE*)w.data(), (LAPACKE_TYPE*)m_matU.data(), ldvs ); \
+  if(info == 0) \
+    m_info = Success; \
+  else \
+    m_info = NoConvergence; \
+\
+  m_isInitialized = true; \
+  m_matUisUptodate = computeU; \
+  return *this; \
+\
+}
+
+EIGEN_LAPACKE_SCHUR_COMPLEX(dcomplex, lapack_complex_double, z, Z, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_SCHUR_COMPLEX(scomplex, lapack_complex_float,  c, C, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_SCHUR_COMPLEX(dcomplex, lapack_complex_double, z, Z, RowMajor, LAPACK_ROW_MAJOR)
+EIGEN_LAPACKE_SCHUR_COMPLEX(scomplex, lapack_complex_float,  c, C, RowMajor, LAPACK_ROW_MAJOR)
+
+} // end namespace Eigen
+
+#endif // EIGEN_COMPLEX_SCHUR_LAPACKE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/EigenSolver.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/EigenSolver.h
new file mode 100644
index 00000000..f205b185
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/EigenSolver.h
@@ -0,0 +1,622 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010,2012 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_EIGENSOLVER_H
+#define EIGEN_EIGENSOLVER_H
+
+#include "./RealSchur.h"
+
+namespace Eigen { 
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  *
+  * \class EigenSolver
+  *
+  * \brief Computes eigenvalues and eigenvectors of general matrices
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the
+  * eigendecomposition; this is expected to be an instantiation of the Matrix
+  * class template. Currently, only real matrices are supported.
+  *
+  * The eigenvalues and eigenvectors of a matrix \f$ A \f$ are scalars
+  * \f$ \lambda \f$ and vectors \f$ v \f$ such that \f$ Av = \lambda v \f$.  If
+  * \f$ D \f$ is a diagonal matrix with the eigenvalues on the diagonal, and
+  * \f$ V \f$ is a matrix with the eigenvectors as its columns, then \f$ A V =
+  * V D \f$. The matrix \f$ V \f$ is almost always invertible, in which case we
+  * have \f$ A = V D V^{-1} \f$. This is called the eigendecomposition.
+  *
+  * The eigenvalues and eigenvectors of a matrix may be complex, even when the
+  * matrix is real. However, we can choose real matrices \f$ V \f$ and \f$ D
+  * \f$ satisfying \f$ A V = V D \f$, just like the eigendecomposition, if the
+  * matrix \f$ D \f$ is not required to be diagonal, but if it is allowed to
+  * have blocks of the form
+  * \f[ \begin{bmatrix} u & v \\ -v & u \end{bmatrix} \f]
+  * (where \f$ u \f$ and \f$ v \f$ are real numbers) on the diagonal.  These
+  * blocks correspond to complex eigenvalue pairs \f$ u \pm iv \f$. We call
+  * this variant of the eigendecomposition the pseudo-eigendecomposition.
+  *
+  * Call the function compute() to compute the eigenvalues and eigenvectors of
+  * a given matrix. Alternatively, you can use the 
+  * EigenSolver(const MatrixType&, bool) constructor which computes the
+  * eigenvalues and eigenvectors at construction time. Once the eigenvalue and
+  * eigenvectors are computed, they can be retrieved with the eigenvalues() and
+  * eigenvectors() functions. The pseudoEigenvalueMatrix() and
+  * pseudoEigenvectors() methods allow the construction of the
+  * pseudo-eigendecomposition.
+  *
+  * The documentation for EigenSolver(const MatrixType&, bool) contains an
+  * example of the typical use of this class.
+  *
+  * \note The implementation is adapted from
+  * <a href="http://math.nist.gov/javanumerics/jama/">JAMA</a> (public domain).
+  * Their code is based on EISPACK.
+  *
+  * \sa MatrixBase::eigenvalues(), class ComplexEigenSolver, class SelfAdjointEigenSolver
+  */
+template<typename _MatrixType> class EigenSolver
+{
+  public:
+
+    /** \brief Synonym for the template parameter \p _MatrixType. */
+    typedef _MatrixType MatrixType;
+
+    enum {
+      RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      Options = MatrixType::Options,
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+
+    /** \brief Scalar type for matrices of type #MatrixType. */
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+
+    /** \brief Complex scalar type for #MatrixType. 
+      *
+      * This is \c std::complex<Scalar> if #Scalar is real (e.g.,
+      * \c float or \c double) and just \c Scalar if #Scalar is
+      * complex.
+      */
+    typedef std::complex<RealScalar> ComplexScalar;
+
+    /** \brief Type for vector of eigenvalues as returned by eigenvalues(). 
+      *
+      * This is a column vector with entries of type #ComplexScalar.
+      * The length of the vector is the size of #MatrixType.
+      */
+    typedef Matrix<ComplexScalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> EigenvalueType;
+
+    /** \brief Type for matrix of eigenvectors as returned by eigenvectors(). 
+      *
+      * This is a square matrix with entries of type #ComplexScalar. 
+      * The size is the same as the size of #MatrixType.
+      */
+    typedef Matrix<ComplexScalar, RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime, MaxColsAtCompileTime> EigenvectorsType;
+
+    /** \brief Default constructor.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via EigenSolver::compute(const MatrixType&, bool).
+      *
+      * \sa compute() for an example.
+      */
+    EigenSolver() : m_eivec(), m_eivalues(), m_isInitialized(false), m_realSchur(), m_matT(), m_tmp() {}
+
+    /** \brief Default constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem \a size.
+      * \sa EigenSolver()
+      */
+    explicit EigenSolver(Index size)
+      : m_eivec(size, size),
+        m_eivalues(size),
+        m_isInitialized(false),
+        m_eigenvectorsOk(false),
+        m_realSchur(size),
+        m_matT(size, size), 
+        m_tmp(size)
+    {}
+
+    /** \brief Constructor; computes eigendecomposition of given matrix. 
+      * 
+      * \param[in]  matrix  Square matrix whose eigendecomposition is to be computed.
+      * \param[in]  computeEigenvectors  If true, both the eigenvectors and the
+      *    eigenvalues are computed; if false, only the eigenvalues are
+      *    computed. 
+      *
+      * This constructor calls compute() to compute the eigenvalues
+      * and eigenvectors.
+      *
+      * Example: \include EigenSolver_EigenSolver_MatrixType.cpp
+      * Output: \verbinclude EigenSolver_EigenSolver_MatrixType.out
+      *
+      * \sa compute()
+      */
+    template<typename InputType>
+    explicit EigenSolver(const EigenBase<InputType>& matrix, bool computeEigenvectors = true)
+      : m_eivec(matrix.rows(), matrix.cols()),
+        m_eivalues(matrix.cols()),
+        m_isInitialized(false),
+        m_eigenvectorsOk(false),
+        m_realSchur(matrix.cols()),
+        m_matT(matrix.rows(), matrix.cols()), 
+        m_tmp(matrix.cols())
+    {
+      compute(matrix.derived(), computeEigenvectors);
+    }
+
+    /** \brief Returns the eigenvectors of given matrix. 
+      *
+      * \returns  %Matrix whose columns are the (possibly complex) eigenvectors.
+      *
+      * \pre Either the constructor 
+      * EigenSolver(const MatrixType&,bool) or the member function
+      * compute(const MatrixType&, bool) has been called before, and
+      * \p computeEigenvectors was set to true (the default).
+      *
+      * Column \f$ k \f$ of the returned matrix is an eigenvector corresponding
+      * to eigenvalue number \f$ k \f$ as returned by eigenvalues().  The
+      * eigenvectors are normalized to have (Euclidean) norm equal to one. The
+      * matrix returned by this function is the matrix \f$ V \f$ in the
+      * eigendecomposition \f$ A = V D V^{-1} \f$, if it exists.
+      *
+      * Example: \include EigenSolver_eigenvectors.cpp
+      * Output: \verbinclude EigenSolver_eigenvectors.out
+      *
+      * \sa eigenvalues(), pseudoEigenvectors()
+      */
+    EigenvectorsType eigenvectors() const;
+
+    /** \brief Returns the pseudo-eigenvectors of given matrix. 
+      *
+      * \returns  Const reference to matrix whose columns are the pseudo-eigenvectors.
+      *
+      * \pre Either the constructor 
+      * EigenSolver(const MatrixType&,bool) or the member function
+      * compute(const MatrixType&, bool) has been called before, and
+      * \p computeEigenvectors was set to true (the default).
+      *
+      * The real matrix \f$ V \f$ returned by this function and the
+      * block-diagonal matrix \f$ D \f$ returned by pseudoEigenvalueMatrix()
+      * satisfy \f$ AV = VD \f$.
+      *
+      * Example: \include EigenSolver_pseudoEigenvectors.cpp
+      * Output: \verbinclude EigenSolver_pseudoEigenvectors.out
+      *
+      * \sa pseudoEigenvalueMatrix(), eigenvectors()
+      */
+    const MatrixType& pseudoEigenvectors() const
+    {
+      eigen_assert(m_isInitialized && "EigenSolver is not initialized.");
+      eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
+      return m_eivec;
+    }
+
+    /** \brief Returns the block-diagonal matrix in the pseudo-eigendecomposition.
+      *
+      * \returns  A block-diagonal matrix.
+      *
+      * \pre Either the constructor 
+      * EigenSolver(const MatrixType&,bool) or the member function
+      * compute(const MatrixType&, bool) has been called before.
+      *
+      * The matrix \f$ D \f$ returned by this function is real and
+      * block-diagonal. The blocks on the diagonal are either 1-by-1 or 2-by-2
+      * blocks of the form
+      * \f$ \begin{bmatrix} u & v \\ -v & u \end{bmatrix} \f$.
+      * These blocks are not sorted in any particular order.
+      * The matrix \f$ D \f$ and the matrix \f$ V \f$ returned by
+      * pseudoEigenvectors() satisfy \f$ AV = VD \f$.
+      *
+      * \sa pseudoEigenvectors() for an example, eigenvalues()
+      */
+    MatrixType pseudoEigenvalueMatrix() const;
+
+    /** \brief Returns the eigenvalues of given matrix. 
+      *
+      * \returns A const reference to the column vector containing the eigenvalues.
+      *
+      * \pre Either the constructor 
+      * EigenSolver(const MatrixType&,bool) or the member function
+      * compute(const MatrixType&, bool) has been called before.
+      *
+      * The eigenvalues are repeated according to their algebraic multiplicity,
+      * so there are as many eigenvalues as rows in the matrix. The eigenvalues 
+      * are not sorted in any particular order.
+      *
+      * Example: \include EigenSolver_eigenvalues.cpp
+      * Output: \verbinclude EigenSolver_eigenvalues.out
+      *
+      * \sa eigenvectors(), pseudoEigenvalueMatrix(),
+      *     MatrixBase::eigenvalues()
+      */
+    const EigenvalueType& eigenvalues() const
+    {
+      eigen_assert(m_isInitialized && "EigenSolver is not initialized.");
+      return m_eivalues;
+    }
+
+    /** \brief Computes eigendecomposition of given matrix. 
+      * 
+      * \param[in]  matrix  Square matrix whose eigendecomposition is to be computed.
+      * \param[in]  computeEigenvectors  If true, both the eigenvectors and the
+      *    eigenvalues are computed; if false, only the eigenvalues are
+      *    computed. 
+      * \returns    Reference to \c *this
+      *
+      * This function computes the eigenvalues of the real matrix \p matrix.
+      * The eigenvalues() function can be used to retrieve them.  If 
+      * \p computeEigenvectors is true, then the eigenvectors are also computed
+      * and can be retrieved by calling eigenvectors().
+      *
+      * The matrix is first reduced to real Schur form using the RealSchur
+      * class. The Schur decomposition is then used to compute the eigenvalues
+      * and eigenvectors.
+      *
+      * The cost of the computation is dominated by the cost of the
+      * Schur decomposition, which is very approximately \f$ 25n^3 \f$
+      * (where \f$ n \f$ is the size of the matrix) if \p computeEigenvectors 
+      * is true, and \f$ 10n^3 \f$ if \p computeEigenvectors is false.
+      *
+      * This method reuses of the allocated data in the EigenSolver object.
+      *
+      * Example: \include EigenSolver_compute.cpp
+      * Output: \verbinclude EigenSolver_compute.out
+      */
+    template<typename InputType>
+    EigenSolver& compute(const EigenBase<InputType>& matrix, bool computeEigenvectors = true);
+
+    /** \returns NumericalIssue if the input contains INF or NaN values or overflow occured. Returns Success otherwise. */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "EigenSolver is not initialized.");
+      return m_info;
+    }
+
+    /** \brief Sets the maximum number of iterations allowed. */
+    EigenSolver& setMaxIterations(Index maxIters)
+    {
+      m_realSchur.setMaxIterations(maxIters);
+      return *this;
+    }
+
+    /** \brief Returns the maximum number of iterations. */
+    Index getMaxIterations()
+    {
+      return m_realSchur.getMaxIterations();
+    }
+
+  private:
+    void doComputeEigenvectors();
+
+  protected:
+    
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+      EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::IsComplex, NUMERIC_TYPE_MUST_BE_REAL);
+    }
+    
+    MatrixType m_eivec;
+    EigenvalueType m_eivalues;
+    bool m_isInitialized;
+    bool m_eigenvectorsOk;
+    ComputationInfo m_info;
+    RealSchur<MatrixType> m_realSchur;
+    MatrixType m_matT;
+
+    typedef Matrix<Scalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> ColumnVectorType;
+    ColumnVectorType m_tmp;
+};
+
+template<typename MatrixType>
+MatrixType EigenSolver<MatrixType>::pseudoEigenvalueMatrix() const
+{
+  eigen_assert(m_isInitialized && "EigenSolver is not initialized.");
+  const RealScalar precision = RealScalar(2)*NumTraits<RealScalar>::epsilon();
+  Index n = m_eivalues.rows();
+  MatrixType matD = MatrixType::Zero(n,n);
+  for (Index i=0; i<n; ++i)
+  {
+    if (internal::isMuchSmallerThan(numext::imag(m_eivalues.coeff(i)), numext::real(m_eivalues.coeff(i)), precision))
+      matD.coeffRef(i,i) = numext::real(m_eivalues.coeff(i));
+    else
+    {
+      matD.template block<2,2>(i,i) <<  numext::real(m_eivalues.coeff(i)), numext::imag(m_eivalues.coeff(i)),
+                                       -numext::imag(m_eivalues.coeff(i)), numext::real(m_eivalues.coeff(i));
+      ++i;
+    }
+  }
+  return matD;
+}
+
+template<typename MatrixType>
+typename EigenSolver<MatrixType>::EigenvectorsType EigenSolver<MatrixType>::eigenvectors() const
+{
+  eigen_assert(m_isInitialized && "EigenSolver is not initialized.");
+  eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
+  const RealScalar precision = RealScalar(2)*NumTraits<RealScalar>::epsilon();
+  Index n = m_eivec.cols();
+  EigenvectorsType matV(n,n);
+  for (Index j=0; j<n; ++j)
+  {
+    if (internal::isMuchSmallerThan(numext::imag(m_eivalues.coeff(j)), numext::real(m_eivalues.coeff(j)), precision) || j+1==n)
+    {
+      // we have a real eigen value
+      matV.col(j) = m_eivec.col(j).template cast<ComplexScalar>();
+      matV.col(j).normalize();
+    }
+    else
+    {
+      // we have a pair of complex eigen values
+      for (Index i=0; i<n; ++i)
+      {
+        matV.coeffRef(i,j)   = ComplexScalar(m_eivec.coeff(i,j),  m_eivec.coeff(i,j+1));
+        matV.coeffRef(i,j+1) = ComplexScalar(m_eivec.coeff(i,j), -m_eivec.coeff(i,j+1));
+      }
+      matV.col(j).normalize();
+      matV.col(j+1).normalize();
+      ++j;
+    }
+  }
+  return matV;
+}
+
+template<typename MatrixType>
+template<typename InputType>
+EigenSolver<MatrixType>& 
+EigenSolver<MatrixType>::compute(const EigenBase<InputType>& matrix, bool computeEigenvectors)
+{
+  check_template_parameters();
+  
+  using std::sqrt;
+  using std::abs;
+  using numext::isfinite;
+  eigen_assert(matrix.cols() == matrix.rows());
+
+  // Reduce to real Schur form.
+  m_realSchur.compute(matrix.derived(), computeEigenvectors);
+  
+  m_info = m_realSchur.info();
+
+  if (m_info == Success)
+  {
+    m_matT = m_realSchur.matrixT();
+    if (computeEigenvectors)
+      m_eivec = m_realSchur.matrixU();
+  
+    // Compute eigenvalues from matT
+    m_eivalues.resize(matrix.cols());
+    Index i = 0;
+    while (i < matrix.cols()) 
+    {
+      if (i == matrix.cols() - 1 || m_matT.coeff(i+1, i) == Scalar(0)) 
+      {
+        m_eivalues.coeffRef(i) = m_matT.coeff(i, i);
+        if(!(isfinite)(m_eivalues.coeffRef(i)))
+        {
+          m_isInitialized = true;
+          m_eigenvectorsOk = false;
+          m_info = NumericalIssue;
+          return *this;
+        }
+        ++i;
+      }
+      else
+      {
+        Scalar p = Scalar(0.5) * (m_matT.coeff(i, i) - m_matT.coeff(i+1, i+1));
+        Scalar z;
+        // Compute z = sqrt(abs(p * p + m_matT.coeff(i+1, i) * m_matT.coeff(i, i+1)));
+        // without overflow
+        {
+          Scalar t0 = m_matT.coeff(i+1, i);
+          Scalar t1 = m_matT.coeff(i, i+1);
+          Scalar maxval = numext::maxi<Scalar>(abs(p),numext::maxi<Scalar>(abs(t0),abs(t1)));
+          t0 /= maxval;
+          t1 /= maxval;
+          Scalar p0 = p/maxval;
+          z = maxval * sqrt(abs(p0 * p0 + t0 * t1));
+        }
+        
+        m_eivalues.coeffRef(i)   = ComplexScalar(m_matT.coeff(i+1, i+1) + p, z);
+        m_eivalues.coeffRef(i+1) = ComplexScalar(m_matT.coeff(i+1, i+1) + p, -z);
+        if(!((isfinite)(m_eivalues.coeffRef(i)) && (isfinite)(m_eivalues.coeffRef(i+1))))
+        {
+          m_isInitialized = true;
+          m_eigenvectorsOk = false;
+          m_info = NumericalIssue;
+          return *this;
+        }
+        i += 2;
+      }
+    }
+    
+    // Compute eigenvectors.
+    if (computeEigenvectors)
+      doComputeEigenvectors();
+  }
+
+  m_isInitialized = true;
+  m_eigenvectorsOk = computeEigenvectors;
+
+  return *this;
+}
+
+
+template<typename MatrixType>
+void EigenSolver<MatrixType>::doComputeEigenvectors()
+{
+  using std::abs;
+  const Index size = m_eivec.cols();
+  const Scalar eps = NumTraits<Scalar>::epsilon();
+
+  // inefficient! this is already computed in RealSchur
+  Scalar norm(0);
+  for (Index j = 0; j < size; ++j)
+  {
+    norm += m_matT.row(j).segment((std::max)(j-1,Index(0)), size-(std::max)(j-1,Index(0))).cwiseAbs().sum();
+  }
+  
+  // Backsubstitute to find vectors of upper triangular form
+  if (norm == Scalar(0))
+  {
+    return;
+  }
+
+  for (Index n = size-1; n >= 0; n--)
+  {
+    Scalar p = m_eivalues.coeff(n).real();
+    Scalar q = m_eivalues.coeff(n).imag();
+
+    // Scalar vector
+    if (q == Scalar(0))
+    {
+      Scalar lastr(0), lastw(0);
+      Index l = n;
+
+      m_matT.coeffRef(n,n) = Scalar(1);
+      for (Index i = n-1; i >= 0; i--)
+      {
+        Scalar w = m_matT.coeff(i,i) - p;
+        Scalar r = m_matT.row(i).segment(l,n-l+1).dot(m_matT.col(n).segment(l, n-l+1));
+
+        if (m_eivalues.coeff(i).imag() < Scalar(0))
+        {
+          lastw = w;
+          lastr = r;
+        }
+        else
+        {
+          l = i;
+          if (m_eivalues.coeff(i).imag() == Scalar(0))
+          {
+            if (w != Scalar(0))
+              m_matT.coeffRef(i,n) = -r / w;
+            else
+              m_matT.coeffRef(i,n) = -r / (eps * norm);
+          }
+          else // Solve real equations
+          {
+            Scalar x = m_matT.coeff(i,i+1);
+            Scalar y = m_matT.coeff(i+1,i);
+            Scalar denom = (m_eivalues.coeff(i).real() - p) * (m_eivalues.coeff(i).real() - p) + m_eivalues.coeff(i).imag() * m_eivalues.coeff(i).imag();
+            Scalar t = (x * lastr - lastw * r) / denom;
+            m_matT.coeffRef(i,n) = t;
+            if (abs(x) > abs(lastw))
+              m_matT.coeffRef(i+1,n) = (-r - w * t) / x;
+            else
+              m_matT.coeffRef(i+1,n) = (-lastr - y * t) / lastw;
+          }
+
+          // Overflow control
+          Scalar t = abs(m_matT.coeff(i,n));
+          if ((eps * t) * t > Scalar(1))
+            m_matT.col(n).tail(size-i) /= t;
+        }
+      }
+    }
+    else if (q < Scalar(0) && n > 0) // Complex vector
+    {
+      Scalar lastra(0), lastsa(0), lastw(0);
+      Index l = n-1;
+
+      // Last vector component imaginary so matrix is triangular
+      if (abs(m_matT.coeff(n,n-1)) > abs(m_matT.coeff(n-1,n)))
+      {
+        m_matT.coeffRef(n-1,n-1) = q / m_matT.coeff(n,n-1);
+        m_matT.coeffRef(n-1,n) = -(m_matT.coeff(n,n) - p) / m_matT.coeff(n,n-1);
+      }
+      else
+      {
+        ComplexScalar cc = ComplexScalar(Scalar(0),-m_matT.coeff(n-1,n)) / ComplexScalar(m_matT.coeff(n-1,n-1)-p,q);
+        m_matT.coeffRef(n-1,n-1) = numext::real(cc);
+        m_matT.coeffRef(n-1,n) = numext::imag(cc);
+      }
+      m_matT.coeffRef(n,n-1) = Scalar(0);
+      m_matT.coeffRef(n,n) = Scalar(1);
+      for (Index i = n-2; i >= 0; i--)
+      {
+        Scalar ra = m_matT.row(i).segment(l, n-l+1).dot(m_matT.col(n-1).segment(l, n-l+1));
+        Scalar sa = m_matT.row(i).segment(l, n-l+1).dot(m_matT.col(n).segment(l, n-l+1));
+        Scalar w = m_matT.coeff(i,i) - p;
+
+        if (m_eivalues.coeff(i).imag() < Scalar(0))
+        {
+          lastw = w;
+          lastra = ra;
+          lastsa = sa;
+        }
+        else
+        {
+          l = i;
+          if (m_eivalues.coeff(i).imag() == RealScalar(0))
+          {
+            ComplexScalar cc = ComplexScalar(-ra,-sa) / ComplexScalar(w,q);
+            m_matT.coeffRef(i,n-1) = numext::real(cc);
+            m_matT.coeffRef(i,n) = numext::imag(cc);
+          }
+          else
+          {
+            // Solve complex equations
+            Scalar x = m_matT.coeff(i,i+1);
+            Scalar y = m_matT.coeff(i+1,i);
+            Scalar vr = (m_eivalues.coeff(i).real() - p) * (m_eivalues.coeff(i).real() - p) + m_eivalues.coeff(i).imag() * m_eivalues.coeff(i).imag() - q * q;
+            Scalar vi = (m_eivalues.coeff(i).real() - p) * Scalar(2) * q;
+            if ((vr == Scalar(0)) && (vi == Scalar(0)))
+              vr = eps * norm * (abs(w) + abs(q) + abs(x) + abs(y) + abs(lastw));
+
+            ComplexScalar cc = ComplexScalar(x*lastra-lastw*ra+q*sa,x*lastsa-lastw*sa-q*ra) / ComplexScalar(vr,vi);
+            m_matT.coeffRef(i,n-1) = numext::real(cc);
+            m_matT.coeffRef(i,n) = numext::imag(cc);
+            if (abs(x) > (abs(lastw) + abs(q)))
+            {
+              m_matT.coeffRef(i+1,n-1) = (-ra - w * m_matT.coeff(i,n-1) + q * m_matT.coeff(i,n)) / x;
+              m_matT.coeffRef(i+1,n) = (-sa - w * m_matT.coeff(i,n) - q * m_matT.coeff(i,n-1)) / x;
+            }
+            else
+            {
+              cc = ComplexScalar(-lastra-y*m_matT.coeff(i,n-1),-lastsa-y*m_matT.coeff(i,n)) / ComplexScalar(lastw,q);
+              m_matT.coeffRef(i+1,n-1) = numext::real(cc);
+              m_matT.coeffRef(i+1,n) = numext::imag(cc);
+            }
+          }
+
+          // Overflow control
+          Scalar t = numext::maxi<Scalar>(abs(m_matT.coeff(i,n-1)),abs(m_matT.coeff(i,n)));
+          if ((eps * t) * t > Scalar(1))
+            m_matT.block(i, n-1, size-i, 2) /= t;
+
+        }
+      }
+      
+      // We handled a pair of complex conjugate eigenvalues, so need to skip them both
+      n--;
+    }
+    else
+    {
+      eigen_assert(0 && "Internal bug in EigenSolver (INF or NaN has not been detected)"); // this should not happen
+    }
+  }
+
+  // Back transformation to get eigenvectors of original matrix
+  for (Index j = size-1; j >= 0; j--)
+  {
+    m_tmp.noalias() = m_eivec.leftCols(j+1) * m_matT.col(j).segment(0, j+1);
+    m_eivec.col(j) = m_tmp;
+  }
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_EIGENSOLVER_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
new file mode 100644
index 00000000..36a91dff
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
@@ -0,0 +1,419 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012-2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010,2012 Jitse Niesen <jitse@maths.leeds.ac.uk>
+// Copyright (C) 2016 Tobias Wood <tobias@spinicist.org.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GENERALIZEDEIGENSOLVER_H
+#define EIGEN_GENERALIZEDEIGENSOLVER_H
+
+#include "./RealQZ.h"
+
+namespace Eigen { 
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  *
+  * \class GeneralizedEigenSolver
+  *
+  * \brief Computes the generalized eigenvalues and eigenvectors of a pair of general matrices
+  *
+  * \tparam _MatrixType the type of the matrices of which we are computing the
+  * eigen-decomposition; this is expected to be an instantiation of the Matrix
+  * class template. Currently, only real matrices are supported.
+  *
+  * The generalized eigenvalues and eigenvectors of a matrix pair \f$ A \f$ and \f$ B \f$ are scalars
+  * \f$ \lambda \f$ and vectors \f$ v \f$ such that \f$ Av = \lambda Bv \f$.  If
+  * \f$ D \f$ is a diagonal matrix with the eigenvalues on the diagonal, and
+  * \f$ V \f$ is a matrix with the eigenvectors as its columns, then \f$ A V =
+  * B V D \f$. The matrix \f$ V \f$ is almost always invertible, in which case we
+  * have \f$ A = B V D V^{-1} \f$. This is called the generalized eigen-decomposition.
+  *
+  * The generalized eigenvalues and eigenvectors of a matrix pair may be complex, even when the
+  * matrices are real. Moreover, the generalized eigenvalue might be infinite if the matrix B is
+  * singular. To workaround this difficulty, the eigenvalues are provided as a pair of complex \f$ \alpha \f$
+  * and real \f$ \beta \f$ such that: \f$ \lambda_i = \alpha_i / \beta_i \f$. If \f$ \beta_i \f$ is (nearly) zero,
+  * then one can consider the well defined left eigenvalue \f$ \mu = \beta_i / \alpha_i\f$ such that:
+  * \f$ \mu_i A v_i = B v_i \f$, or even \f$ \mu_i u_i^T A  = u_i^T B \f$ where \f$ u_i \f$ is
+  * called the left eigenvector.
+  *
+  * Call the function compute() to compute the generalized eigenvalues and eigenvectors of
+  * a given matrix pair. Alternatively, you can use the
+  * GeneralizedEigenSolver(const MatrixType&, const MatrixType&, bool) constructor which computes the
+  * eigenvalues and eigenvectors at construction time. Once the eigenvalue and
+  * eigenvectors are computed, they can be retrieved with the eigenvalues() and
+  * eigenvectors() functions.
+  *
+  * Here is an usage example of this class:
+  * Example: \include GeneralizedEigenSolver.cpp
+  * Output: \verbinclude GeneralizedEigenSolver.out
+  *
+  * \sa MatrixBase::eigenvalues(), class ComplexEigenSolver, class SelfAdjointEigenSolver
+  */
+template<typename _MatrixType> class GeneralizedEigenSolver
+{
+  public:
+
+    /** \brief Synonym for the template parameter \p _MatrixType. */
+    typedef _MatrixType MatrixType;
+
+    enum {
+      RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      Options = MatrixType::Options,
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+
+    /** \brief Scalar type for matrices of type #MatrixType. */
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+
+    /** \brief Complex scalar type for #MatrixType. 
+      *
+      * This is \c std::complex<Scalar> if #Scalar is real (e.g.,
+      * \c float or \c double) and just \c Scalar if #Scalar is
+      * complex.
+      */
+    typedef std::complex<RealScalar> ComplexScalar;
+
+    /** \brief Type for vector of real scalar values eigenvalues as returned by betas().
+      *
+      * This is a column vector with entries of type #Scalar.
+      * The length of the vector is the size of #MatrixType.
+      */
+    typedef Matrix<Scalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> VectorType;
+
+    /** \brief Type for vector of complex scalar values eigenvalues as returned by alphas().
+      *
+      * This is a column vector with entries of type #ComplexScalar.
+      * The length of the vector is the size of #MatrixType.
+      */
+    typedef Matrix<ComplexScalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> ComplexVectorType;
+
+    /** \brief Expression type for the eigenvalues as returned by eigenvalues().
+      */
+    typedef CwiseBinaryOp<internal::scalar_quotient_op<ComplexScalar,Scalar>,ComplexVectorType,VectorType> EigenvalueType;
+
+    /** \brief Type for matrix of eigenvectors as returned by eigenvectors(). 
+      *
+      * This is a square matrix with entries of type #ComplexScalar. 
+      * The size is the same as the size of #MatrixType.
+      */
+    typedef Matrix<ComplexScalar, RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime, MaxColsAtCompileTime> EigenvectorsType;
+
+    /** \brief Default constructor.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via EigenSolver::compute(const MatrixType&, bool).
+      *
+      * \sa compute() for an example.
+      */
+    GeneralizedEigenSolver()
+      : m_eivec(),
+        m_alphas(),
+        m_betas(),
+        m_valuesOkay(false),
+        m_vectorsOkay(false),
+        m_realQZ()
+    {}
+
+    /** \brief Default constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem \a size.
+      * \sa GeneralizedEigenSolver()
+      */
+    explicit GeneralizedEigenSolver(Index size)
+      : m_eivec(size, size),
+        m_alphas(size),
+        m_betas(size),
+        m_valuesOkay(false),
+        m_vectorsOkay(false),
+        m_realQZ(size),
+        m_tmp(size)
+    {}
+
+    /** \brief Constructor; computes the generalized eigendecomposition of given matrix pair.
+      * 
+      * \param[in]  A  Square matrix whose eigendecomposition is to be computed.
+      * \param[in]  B  Square matrix whose eigendecomposition is to be computed.
+      * \param[in]  computeEigenvectors  If true, both the eigenvectors and the
+      *    eigenvalues are computed; if false, only the eigenvalues are computed.
+      *
+      * This constructor calls compute() to compute the generalized eigenvalues
+      * and eigenvectors.
+      *
+      * \sa compute()
+      */
+    GeneralizedEigenSolver(const MatrixType& A, const MatrixType& B, bool computeEigenvectors = true)
+      : m_eivec(A.rows(), A.cols()),
+        m_alphas(A.cols()),
+        m_betas(A.cols()),
+        m_valuesOkay(false),
+        m_vectorsOkay(false),
+        m_realQZ(A.cols()),
+        m_tmp(A.cols())
+    {
+      compute(A, B, computeEigenvectors);
+    }
+
+    /* \brief Returns the computed generalized eigenvectors.
+      *
+      * \returns  %Matrix whose columns are the (possibly complex) right eigenvectors.
+      * i.e. the eigenvectors that solve (A - l*B)x = 0. The ordering matches the eigenvalues.
+      *
+      * \pre Either the constructor 
+      * GeneralizedEigenSolver(const MatrixType&,const MatrixType&, bool) or the member function
+      * compute(const MatrixType&, const MatrixType& bool) has been called before, and
+      * \p computeEigenvectors was set to true (the default).
+      *
+      * \sa eigenvalues()
+      */
+    EigenvectorsType eigenvectors() const {
+      eigen_assert(m_vectorsOkay && "Eigenvectors for GeneralizedEigenSolver were not calculated.");
+      return m_eivec;
+    }
+
+    /** \brief Returns an expression of the computed generalized eigenvalues.
+      *
+      * \returns An expression of the column vector containing the eigenvalues.
+      *
+      * It is a shortcut for \code this->alphas().cwiseQuotient(this->betas()); \endcode
+      * Not that betas might contain zeros. It is therefore not recommended to use this function,
+      * but rather directly deal with the alphas and betas vectors.
+      *
+      * \pre Either the constructor 
+      * GeneralizedEigenSolver(const MatrixType&,const MatrixType&,bool) or the member function
+      * compute(const MatrixType&,const MatrixType&,bool) has been called before.
+      *
+      * The eigenvalues are repeated according to their algebraic multiplicity,
+      * so there are as many eigenvalues as rows in the matrix. The eigenvalues 
+      * are not sorted in any particular order.
+      *
+      * \sa alphas(), betas(), eigenvectors()
+      */
+    EigenvalueType eigenvalues() const
+    {
+      eigen_assert(m_valuesOkay && "GeneralizedEigenSolver is not initialized.");
+      return EigenvalueType(m_alphas,m_betas);
+    }
+
+    /** \returns A const reference to the vectors containing the alpha values
+      *
+      * This vector permits to reconstruct the j-th eigenvalues as alphas(i)/betas(j).
+      *
+      * \sa betas(), eigenvalues() */
+    ComplexVectorType alphas() const
+    {
+      eigen_assert(m_valuesOkay && "GeneralizedEigenSolver is not initialized.");
+      return m_alphas;
+    }
+
+    /** \returns A const reference to the vectors containing the beta values
+      *
+      * This vector permits to reconstruct the j-th eigenvalues as alphas(i)/betas(j).
+      *
+      * \sa alphas(), eigenvalues() */
+    VectorType betas() const
+    {
+      eigen_assert(m_valuesOkay && "GeneralizedEigenSolver is not initialized.");
+      return m_betas;
+    }
+
+    /** \brief Computes generalized eigendecomposition of given matrix.
+      * 
+      * \param[in]  A  Square matrix whose eigendecomposition is to be computed.
+      * \param[in]  B  Square matrix whose eigendecomposition is to be computed.
+      * \param[in]  computeEigenvectors  If true, both the eigenvectors and the
+      *    eigenvalues are computed; if false, only the eigenvalues are
+      *    computed. 
+      * \returns    Reference to \c *this
+      *
+      * This function computes the eigenvalues of the real matrix \p matrix.
+      * The eigenvalues() function can be used to retrieve them.  If 
+      * \p computeEigenvectors is true, then the eigenvectors are also computed
+      * and can be retrieved by calling eigenvectors().
+      *
+      * The matrix is first reduced to real generalized Schur form using the RealQZ
+      * class. The generalized Schur decomposition is then used to compute the eigenvalues
+      * and eigenvectors.
+      *
+      * The cost of the computation is dominated by the cost of the
+      * generalized Schur decomposition.
+      *
+      * This method reuses of the allocated data in the GeneralizedEigenSolver object.
+      */
+    GeneralizedEigenSolver& compute(const MatrixType& A, const MatrixType& B, bool computeEigenvectors = true);
+
+    ComputationInfo info() const
+    {
+      eigen_assert(m_valuesOkay && "EigenSolver is not initialized.");
+      return m_realQZ.info();
+    }
+
+    /** Sets the maximal number of iterations allowed.
+    */
+    GeneralizedEigenSolver& setMaxIterations(Index maxIters)
+    {
+      m_realQZ.setMaxIterations(maxIters);
+      return *this;
+    }
+
+  protected:
+    
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+      EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::IsComplex, NUMERIC_TYPE_MUST_BE_REAL);
+    }
+    
+    EigenvectorsType m_eivec;
+    ComplexVectorType m_alphas;
+    VectorType m_betas;
+    bool m_valuesOkay, m_vectorsOkay;
+    RealQZ<MatrixType> m_realQZ;
+    ComplexVectorType m_tmp;
+};
+
+template<typename MatrixType>
+GeneralizedEigenSolver<MatrixType>&
+GeneralizedEigenSolver<MatrixType>::compute(const MatrixType& A, const MatrixType& B, bool computeEigenvectors)
+{
+  check_template_parameters();
+  
+  using std::sqrt;
+  using std::abs;
+  eigen_assert(A.cols() == A.rows() && B.cols() == A.rows() && B.cols() == B.rows());
+  Index size = A.cols();
+  m_valuesOkay = false;
+  m_vectorsOkay = false;
+  // Reduce to generalized real Schur form:
+  // A = Q S Z and B = Q T Z
+  m_realQZ.compute(A, B, computeEigenvectors);
+  if (m_realQZ.info() == Success)
+  {
+    // Resize storage
+    m_alphas.resize(size);
+    m_betas.resize(size);
+    if (computeEigenvectors)
+    {
+      m_eivec.resize(size,size);
+      m_tmp.resize(size);
+    }
+
+    // Aliases:
+    Map<VectorType> v(reinterpret_cast<Scalar*>(m_tmp.data()), size);
+    ComplexVectorType &cv = m_tmp;
+    const MatrixType &mZ = m_realQZ.matrixZ();
+    const MatrixType &mS = m_realQZ.matrixS();
+    const MatrixType &mT = m_realQZ.matrixT();
+
+    Index i = 0;
+    while (i < size)
+    {
+      if (i == size - 1 || mS.coeff(i+1, i) == Scalar(0))
+      {
+        // Real eigenvalue
+        m_alphas.coeffRef(i) = mS.diagonal().coeff(i);
+        m_betas.coeffRef(i)  = mT.diagonal().coeff(i);
+        if (computeEigenvectors)
+        {
+          v.setConstant(Scalar(0.0));
+          v.coeffRef(i) = Scalar(1.0);
+          // For singular eigenvalues do nothing more
+          if(abs(m_betas.coeffRef(i)) >= (std::numeric_limits<RealScalar>::min)())
+          {
+            // Non-singular eigenvalue
+            const Scalar alpha = real(m_alphas.coeffRef(i));
+            const Scalar beta = m_betas.coeffRef(i);
+            for (Index j = i-1; j >= 0; j--)
+            {
+              const Index st = j+1;
+              const Index sz = i-j;
+              if (j > 0 && mS.coeff(j, j-1) != Scalar(0))
+              {
+                // 2x2 block
+                Matrix<Scalar, 2, 1> rhs = (alpha*mT.template block<2,Dynamic>(j-1,st,2,sz) - beta*mS.template block<2,Dynamic>(j-1,st,2,sz)) .lazyProduct( v.segment(st,sz) );
+                Matrix<Scalar, 2, 2> lhs = beta * mS.template block<2,2>(j-1,j-1) - alpha * mT.template block<2,2>(j-1,j-1);
+                v.template segment<2>(j-1) = lhs.partialPivLu().solve(rhs);
+                j--;
+              }
+              else
+              {
+                v.coeffRef(j) = -v.segment(st,sz).transpose().cwiseProduct(beta*mS.block(j,st,1,sz) - alpha*mT.block(j,st,1,sz)).sum() / (beta*mS.coeffRef(j,j) - alpha*mT.coeffRef(j,j));
+              }
+            }
+          }
+          m_eivec.col(i).real().noalias() = mZ.transpose() * v;
+          m_eivec.col(i).real().normalize();
+          m_eivec.col(i).imag().setConstant(0);
+        }
+        ++i;
+      }
+      else
+      {
+        // We need to extract the generalized eigenvalues of the pair of a general 2x2 block S and a positive diagonal 2x2 block T
+        // Then taking beta=T_00*T_11, we can avoid any division, and alpha is the eigenvalues of A = (U^-1 * S * U) * diag(T_11,T_00):
+
+        // T =  [a 0]
+        //      [0 b]
+        RealScalar a = mT.diagonal().coeff(i),
+                   b = mT.diagonal().coeff(i+1);
+        const RealScalar beta = m_betas.coeffRef(i) = m_betas.coeffRef(i+1) = a*b;
+
+        // ^^ NOTE: using diagonal()(i) instead of coeff(i,i) workarounds a MSVC bug.
+        Matrix<RealScalar,2,2> S2 = mS.template block<2,2>(i,i) * Matrix<Scalar,2,1>(b,a).asDiagonal();
+
+        Scalar p = Scalar(0.5) * (S2.coeff(0,0) - S2.coeff(1,1));
+        Scalar z = sqrt(abs(p * p + S2.coeff(1,0) * S2.coeff(0,1)));
+        const ComplexScalar alpha = ComplexScalar(S2.coeff(1,1) + p, (beta > 0) ? z : -z);
+        m_alphas.coeffRef(i)   = conj(alpha);
+        m_alphas.coeffRef(i+1) = alpha;
+
+        if (computeEigenvectors) {
+          // Compute eigenvector in position (i+1) and then position (i) is just the conjugate
+          cv.setZero();
+          cv.coeffRef(i+1) = Scalar(1.0);
+          // here, the "static_cast" workaound expression template issues.
+          cv.coeffRef(i) = -(static_cast<Scalar>(beta*mS.coeffRef(i,i+1)) - alpha*mT.coeffRef(i,i+1))
+                          / (static_cast<Scalar>(beta*mS.coeffRef(i,i))   - alpha*mT.coeffRef(i,i));
+          for (Index j = i-1; j >= 0; j--)
+          {
+            const Index st = j+1;
+            const Index sz = i+1-j;
+            if (j > 0 && mS.coeff(j, j-1) != Scalar(0))
+            {
+              // 2x2 block
+              Matrix<ComplexScalar, 2, 1> rhs = (alpha*mT.template block<2,Dynamic>(j-1,st,2,sz) - beta*mS.template block<2,Dynamic>(j-1,st,2,sz)) .lazyProduct( cv.segment(st,sz) );
+              Matrix<ComplexScalar, 2, 2> lhs = beta * mS.template block<2,2>(j-1,j-1) - alpha * mT.template block<2,2>(j-1,j-1);
+              cv.template segment<2>(j-1) = lhs.partialPivLu().solve(rhs);
+              j--;
+            } else {
+              cv.coeffRef(j) =  cv.segment(st,sz).transpose().cwiseProduct(beta*mS.block(j,st,1,sz) - alpha*mT.block(j,st,1,sz)).sum()
+                              / (alpha*mT.coeffRef(j,j) - static_cast<Scalar>(beta*mS.coeffRef(j,j)));
+            }
+          }
+          m_eivec.col(i+1).noalias() = (mZ.transpose() * cv);
+          m_eivec.col(i+1).normalize();
+          m_eivec.col(i) = m_eivec.col(i+1).conjugate();
+        }
+        i += 2;
+      }
+    }
+
+    m_valuesOkay = true;
+    m_vectorsOkay = computeEigenvectors;
+  }
+  return *this;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_GENERALIZEDEIGENSOLVER_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
new file mode 100644
index 00000000..5f6bb828
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
@@ -0,0 +1,226 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GENERALIZEDSELFADJOINTEIGENSOLVER_H
+#define EIGEN_GENERALIZEDSELFADJOINTEIGENSOLVER_H
+
+#include "./Tridiagonalization.h"
+
+namespace Eigen { 
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  *
+  * \class GeneralizedSelfAdjointEigenSolver
+  *
+  * \brief Computes eigenvalues and eigenvectors of the generalized selfadjoint eigen problem
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the
+  * eigendecomposition; this is expected to be an instantiation of the Matrix
+  * class template.
+  *
+  * This class solves the generalized eigenvalue problem
+  * \f$ Av = \lambda Bv \f$. In this case, the matrix \f$ A \f$ should be
+  * selfadjoint and the matrix \f$ B \f$ should be positive definite.
+  *
+  * Only the \b lower \b triangular \b part of the input matrix is referenced.
+  *
+  * Call the function compute() to compute the eigenvalues and eigenvectors of
+  * a given matrix. Alternatively, you can use the
+  * GeneralizedSelfAdjointEigenSolver(const MatrixType&, const MatrixType&, int)
+  * constructor which computes the eigenvalues and eigenvectors at construction time.
+  * Once the eigenvalue and eigenvectors are computed, they can be retrieved with the eigenvalues()
+  * and eigenvectors() functions.
+  *
+  * The documentation for GeneralizedSelfAdjointEigenSolver(const MatrixType&, const MatrixType&, int)
+  * contains an example of the typical use of this class.
+  *
+  * \sa class SelfAdjointEigenSolver, class EigenSolver, class ComplexEigenSolver
+  */
+template<typename _MatrixType>
+class GeneralizedSelfAdjointEigenSolver : public SelfAdjointEigenSolver<_MatrixType>
+{
+    typedef SelfAdjointEigenSolver<_MatrixType> Base;
+  public:
+
+    typedef _MatrixType MatrixType;
+
+    /** \brief Default constructor for fixed-size matrices.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via compute(). This constructor
+      * can only be used if \p _MatrixType is a fixed-size matrix; use
+      * GeneralizedSelfAdjointEigenSolver(Index) for dynamic-size matrices.
+      */
+    GeneralizedSelfAdjointEigenSolver() : Base() {}
+
+    /** \brief Constructor, pre-allocates memory for dynamic-size matrices.
+      *
+      * \param [in]  size  Positive integer, size of the matrix whose
+      * eigenvalues and eigenvectors will be computed.
+      *
+      * This constructor is useful for dynamic-size matrices, when the user
+      * intends to perform decompositions via compute(). The \p size
+      * parameter is only used as a hint. It is not an error to give a wrong
+      * \p size, but it may impair performance.
+      *
+      * \sa compute() for an example
+      */
+    explicit GeneralizedSelfAdjointEigenSolver(Index size)
+        : Base(size)
+    {}
+
+    /** \brief Constructor; computes generalized eigendecomposition of given matrix pencil.
+      *
+      * \param[in]  matA  Selfadjoint matrix in matrix pencil.
+      *                   Only the lower triangular part of the matrix is referenced.
+      * \param[in]  matB  Positive-definite matrix in matrix pencil.
+      *                   Only the lower triangular part of the matrix is referenced.
+      * \param[in]  options A or-ed set of flags {#ComputeEigenvectors,#EigenvaluesOnly} | {#Ax_lBx,#ABx_lx,#BAx_lx}.
+      *                     Default is #ComputeEigenvectors|#Ax_lBx.
+      *
+      * This constructor calls compute(const MatrixType&, const MatrixType&, int)
+      * to compute the eigenvalues and (if requested) the eigenvectors of the
+      * generalized eigenproblem \f$ Ax = \lambda B x \f$ with \a matA the
+      * selfadjoint matrix \f$ A \f$ and \a matB the positive definite matrix
+      * \f$ B \f$. Each eigenvector \f$ x \f$ satisfies the property
+      * \f$ x^* B x = 1 \f$. The eigenvectors are computed if
+      * \a options contains ComputeEigenvectors.
+      *
+      * In addition, the two following variants can be solved via \p options:
+      * - \c ABx_lx: \f$ ABx = \lambda x \f$
+      * - \c BAx_lx: \f$ BAx = \lambda x \f$
+      *
+      * Example: \include SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType2.cpp
+      * Output: \verbinclude SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType2.out
+      *
+      * \sa compute(const MatrixType&, const MatrixType&, int)
+      */
+    GeneralizedSelfAdjointEigenSolver(const MatrixType& matA, const MatrixType& matB,
+                                      int options = ComputeEigenvectors|Ax_lBx)
+      : Base(matA.cols())
+    {
+      compute(matA, matB, options);
+    }
+
+    /** \brief Computes generalized eigendecomposition of given matrix pencil.
+      *
+      * \param[in]  matA  Selfadjoint matrix in matrix pencil.
+      *                   Only the lower triangular part of the matrix is referenced.
+      * \param[in]  matB  Positive-definite matrix in matrix pencil.
+      *                   Only the lower triangular part of the matrix is referenced.
+      * \param[in]  options A or-ed set of flags {#ComputeEigenvectors,#EigenvaluesOnly} | {#Ax_lBx,#ABx_lx,#BAx_lx}.
+      *                     Default is #ComputeEigenvectors|#Ax_lBx.
+      *
+      * \returns    Reference to \c *this
+      *
+      * Accoring to \p options, this function computes eigenvalues and (if requested)
+      * the eigenvectors of one of the following three generalized eigenproblems:
+      * - \c Ax_lBx: \f$ Ax = \lambda B x \f$
+      * - \c ABx_lx: \f$ ABx = \lambda x \f$
+      * - \c BAx_lx: \f$ BAx = \lambda x \f$
+      * with \a matA the selfadjoint matrix \f$ A \f$ and \a matB the positive definite
+      * matrix \f$ B \f$.
+      * In addition, each eigenvector \f$ x \f$ satisfies the property \f$ x^* B x = 1 \f$.
+      *
+      * The eigenvalues() function can be used to retrieve
+      * the eigenvalues. If \p options contains ComputeEigenvectors, then the
+      * eigenvectors are also computed and can be retrieved by calling
+      * eigenvectors().
+      *
+      * The implementation uses LLT to compute the Cholesky decomposition
+      * \f$ B = LL^* \f$ and computes the classical eigendecomposition
+      * of the selfadjoint matrix \f$ L^{-1} A (L^*)^{-1} \f$ if \p options contains Ax_lBx
+      * and of \f$ L^{*} A L \f$ otherwise. This solves the
+      * generalized eigenproblem, because any solution of the generalized
+      * eigenproblem \f$ Ax = \lambda B x \f$ corresponds to a solution
+      * \f$ L^{-1} A (L^*)^{-1} (L^* x) = \lambda (L^* x) \f$ of the
+      * eigenproblem for \f$ L^{-1} A (L^*)^{-1} \f$. Similar statements
+      * can be made for the two other variants.
+      *
+      * Example: \include SelfAdjointEigenSolver_compute_MatrixType2.cpp
+      * Output: \verbinclude SelfAdjointEigenSolver_compute_MatrixType2.out
+      *
+      * \sa GeneralizedSelfAdjointEigenSolver(const MatrixType&, const MatrixType&, int)
+      */
+    GeneralizedSelfAdjointEigenSolver& compute(const MatrixType& matA, const MatrixType& matB,
+                                               int options = ComputeEigenvectors|Ax_lBx);
+
+  protected:
+
+};
+
+
+template<typename MatrixType>
+GeneralizedSelfAdjointEigenSolver<MatrixType>& GeneralizedSelfAdjointEigenSolver<MatrixType>::
+compute(const MatrixType& matA, const MatrixType& matB, int options)
+{
+  eigen_assert(matA.cols()==matA.rows() && matB.rows()==matA.rows() && matB.cols()==matB.rows());
+  eigen_assert((options&~(EigVecMask|GenEigMask))==0
+          && (options&EigVecMask)!=EigVecMask
+          && ((options&GenEigMask)==0 || (options&GenEigMask)==Ax_lBx
+           || (options&GenEigMask)==ABx_lx || (options&GenEigMask)==BAx_lx)
+          && "invalid option parameter");
+
+  bool computeEigVecs = ((options&EigVecMask)==0) || ((options&EigVecMask)==ComputeEigenvectors);
+
+  // Compute the cholesky decomposition of matB = L L' = U'U
+  LLT<MatrixType> cholB(matB);
+
+  int type = (options&GenEigMask);
+  if(type==0)
+    type = Ax_lBx;
+
+  if(type==Ax_lBx)
+  {
+    // compute C = inv(L) A inv(L')
+    MatrixType matC = matA.template selfadjointView<Lower>();
+    cholB.matrixL().template solveInPlace<OnTheLeft>(matC);
+    cholB.matrixU().template solveInPlace<OnTheRight>(matC);
+
+    Base::compute(matC, computeEigVecs ? ComputeEigenvectors : EigenvaluesOnly );
+
+    // transform back the eigen vectors: evecs = inv(U) * evecs
+    if(computeEigVecs)
+      cholB.matrixU().solveInPlace(Base::m_eivec);
+  }
+  else if(type==ABx_lx)
+  {
+    // compute C = L' A L
+    MatrixType matC = matA.template selfadjointView<Lower>();
+    matC = matC * cholB.matrixL();
+    matC = cholB.matrixU() * matC;
+
+    Base::compute(matC, computeEigVecs ? ComputeEigenvectors : EigenvaluesOnly);
+
+    // transform back the eigen vectors: evecs = inv(U) * evecs
+    if(computeEigVecs)
+      cholB.matrixU().solveInPlace(Base::m_eivec);
+  }
+  else if(type==BAx_lx)
+  {
+    // compute C = L' A L
+    MatrixType matC = matA.template selfadjointView<Lower>();
+    matC = matC * cholB.matrixL();
+    matC = cholB.matrixU() * matC;
+
+    Base::compute(matC, computeEigVecs ? ComputeEigenvectors : EigenvaluesOnly);
+
+    // transform back the eigen vectors: evecs = L * evecs
+    if(computeEigVecs)
+      Base::m_eivec = cholB.matrixL() * Base::m_eivec;
+  }
+
+  return *this;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_GENERALIZEDSELFADJOINTEIGENSOLVER_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/HessenbergDecomposition.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/HessenbergDecomposition.h
new file mode 100644
index 00000000..f647f69b
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/HessenbergDecomposition.h
@@ -0,0 +1,374 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_HESSENBERGDECOMPOSITION_H
+#define EIGEN_HESSENBERGDECOMPOSITION_H
+
+namespace Eigen { 
+
+namespace internal {
+  
+template<typename MatrixType> struct HessenbergDecompositionMatrixHReturnType;
+template<typename MatrixType>
+struct traits<HessenbergDecompositionMatrixHReturnType<MatrixType> >
+{
+  typedef MatrixType ReturnType;
+};
+
+}
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  *
+  * \class HessenbergDecomposition
+  *
+  * \brief Reduces a square matrix to Hessenberg form by an orthogonal similarity transformation
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the Hessenberg decomposition
+  *
+  * This class performs an Hessenberg decomposition of a matrix \f$ A \f$. In
+  * the real case, the Hessenberg decomposition consists of an orthogonal
+  * matrix \f$ Q \f$ and a Hessenberg matrix \f$ H \f$ such that \f$ A = Q H
+  * Q^T \f$. An orthogonal matrix is a matrix whose inverse equals its
+  * transpose (\f$ Q^{-1} = Q^T \f$). A Hessenberg matrix has zeros below the
+  * subdiagonal, so it is almost upper triangular. The Hessenberg decomposition
+  * of a complex matrix is \f$ A = Q H Q^* \f$ with \f$ Q \f$ unitary (that is,
+  * \f$ Q^{-1} = Q^* \f$).
+  *
+  * Call the function compute() to compute the Hessenberg decomposition of a
+  * given matrix. Alternatively, you can use the
+  * HessenbergDecomposition(const MatrixType&) constructor which computes the
+  * Hessenberg decomposition at construction time. Once the decomposition is
+  * computed, you can use the matrixH() and matrixQ() functions to construct
+  * the matrices H and Q in the decomposition.
+  *
+  * The documentation for matrixH() contains an example of the typical use of
+  * this class.
+  *
+  * \sa class ComplexSchur, class Tridiagonalization, \ref QR_Module "QR Module"
+  */
+template<typename _MatrixType> class HessenbergDecomposition
+{
+  public:
+
+    /** \brief Synonym for the template parameter \p _MatrixType. */
+    typedef _MatrixType MatrixType;
+
+    enum {
+      Size = MatrixType::RowsAtCompileTime,
+      SizeMinusOne = Size == Dynamic ? Dynamic : Size - 1,
+      Options = MatrixType::Options,
+      MaxSize = MatrixType::MaxRowsAtCompileTime,
+      MaxSizeMinusOne = MaxSize == Dynamic ? Dynamic : MaxSize - 1
+    };
+
+    /** \brief Scalar type for matrices of type #MatrixType. */
+    typedef typename MatrixType::Scalar Scalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+
+    /** \brief Type for vector of Householder coefficients.
+      *
+      * This is column vector with entries of type #Scalar. The length of the
+      * vector is one less than the size of #MatrixType, if it is a fixed-side
+      * type.
+      */
+    typedef Matrix<Scalar, SizeMinusOne, 1, Options & ~RowMajor, MaxSizeMinusOne, 1> CoeffVectorType;
+
+    /** \brief Return type of matrixQ() */
+    typedef HouseholderSequence<MatrixType,typename internal::remove_all<typename CoeffVectorType::ConjugateReturnType>::type> HouseholderSequenceType;
+    
+    typedef internal::HessenbergDecompositionMatrixHReturnType<MatrixType> MatrixHReturnType;
+
+    /** \brief Default constructor; the decomposition will be computed later.
+      *
+      * \param [in] size  The size of the matrix whose Hessenberg decomposition will be computed.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via compute().  The \p size parameter is only
+      * used as a hint. It is not an error to give a wrong \p size, but it may
+      * impair performance.
+      *
+      * \sa compute() for an example.
+      */
+    explicit HessenbergDecomposition(Index size = Size==Dynamic ? 2 : Size)
+      : m_matrix(size,size),
+        m_temp(size),
+        m_isInitialized(false)
+    {
+      if(size>1)
+        m_hCoeffs.resize(size-1);
+    }
+
+    /** \brief Constructor; computes Hessenberg decomposition of given matrix.
+      *
+      * \param[in]  matrix  Square matrix whose Hessenberg decomposition is to be computed.
+      *
+      * This constructor calls compute() to compute the Hessenberg
+      * decomposition.
+      *
+      * \sa matrixH() for an example.
+      */
+    template<typename InputType>
+    explicit HessenbergDecomposition(const EigenBase<InputType>& matrix)
+      : m_matrix(matrix.derived()),
+        m_temp(matrix.rows()),
+        m_isInitialized(false)
+    {
+      if(matrix.rows()<2)
+      {
+        m_isInitialized = true;
+        return;
+      }
+      m_hCoeffs.resize(matrix.rows()-1,1);
+      _compute(m_matrix, m_hCoeffs, m_temp);
+      m_isInitialized = true;
+    }
+
+    /** \brief Computes Hessenberg decomposition of given matrix.
+      *
+      * \param[in]  matrix  Square matrix whose Hessenberg decomposition is to be computed.
+      * \returns    Reference to \c *this
+      *
+      * The Hessenberg decomposition is computed by bringing the columns of the
+      * matrix successively in the required form using Householder reflections
+      * (see, e.g., Algorithm 7.4.2 in Golub \& Van Loan, <i>%Matrix
+      * Computations</i>). The cost is \f$ 10n^3/3 \f$ flops, where \f$ n \f$
+      * denotes the size of the given matrix.
+      *
+      * This method reuses of the allocated data in the HessenbergDecomposition
+      * object.
+      *
+      * Example: \include HessenbergDecomposition_compute.cpp
+      * Output: \verbinclude HessenbergDecomposition_compute.out
+      */
+    template<typename InputType>
+    HessenbergDecomposition& compute(const EigenBase<InputType>& matrix)
+    {
+      m_matrix = matrix.derived();
+      if(matrix.rows()<2)
+      {
+        m_isInitialized = true;
+        return *this;
+      }
+      m_hCoeffs.resize(matrix.rows()-1,1);
+      _compute(m_matrix, m_hCoeffs, m_temp);
+      m_isInitialized = true;
+      return *this;
+    }
+
+    /** \brief Returns the Householder coefficients.
+      *
+      * \returns a const reference to the vector of Householder coefficients
+      *
+      * \pre Either the constructor HessenbergDecomposition(const MatrixType&)
+      * or the member function compute(const MatrixType&) has been called
+      * before to compute the Hessenberg decomposition of a matrix.
+      *
+      * The Householder coefficients allow the reconstruction of the matrix
+      * \f$ Q \f$ in the Hessenberg decomposition from the packed data.
+      *
+      * \sa packedMatrix(), \ref Householder_Module "Householder module"
+      */
+    const CoeffVectorType& householderCoefficients() const
+    {
+      eigen_assert(m_isInitialized && "HessenbergDecomposition is not initialized.");
+      return m_hCoeffs;
+    }
+
+    /** \brief Returns the internal representation of the decomposition
+      *
+      *	\returns a const reference to a matrix with the internal representation
+      *	         of the decomposition.
+      *
+      * \pre Either the constructor HessenbergDecomposition(const MatrixType&)
+      * or the member function compute(const MatrixType&) has been called
+      * before to compute the Hessenberg decomposition of a matrix.
+      *
+      * The returned matrix contains the following information:
+      *  - the upper part and lower sub-diagonal represent the Hessenberg matrix H
+      *  - the rest of the lower part contains the Householder vectors that, combined with
+      *    Householder coefficients returned by householderCoefficients(),
+      *    allows to reconstruct the matrix Q as
+      *       \f$ Q = H_{N-1} \ldots H_1 H_0 \f$.
+      *    Here, the matrices \f$ H_i \f$ are the Householder transformations
+      *       \f$ H_i = (I - h_i v_i v_i^T) \f$
+      *    where \f$ h_i \f$ is the \f$ i \f$th Householder coefficient and
+      *    \f$ v_i \f$ is the Householder vector defined by
+      *       \f$ v_i = [ 0, \ldots, 0, 1, M(i+2,i), \ldots, M(N-1,i) ]^T \f$
+      *    with M the matrix returned by this function.
+      *
+      * See LAPACK for further details on this packed storage.
+      *
+      * Example: \include HessenbergDecomposition_packedMatrix.cpp
+      * Output: \verbinclude HessenbergDecomposition_packedMatrix.out
+      *
+      * \sa householderCoefficients()
+      */
+    const MatrixType& packedMatrix() const
+    {
+      eigen_assert(m_isInitialized && "HessenbergDecomposition is not initialized.");
+      return m_matrix;
+    }
+
+    /** \brief Reconstructs the orthogonal matrix Q in the decomposition
+      *
+      * \returns object representing the matrix Q
+      *
+      * \pre Either the constructor HessenbergDecomposition(const MatrixType&)
+      * or the member function compute(const MatrixType&) has been called
+      * before to compute the Hessenberg decomposition of a matrix.
+      *
+      * This function returns a light-weight object of template class
+      * HouseholderSequence. You can either apply it directly to a matrix or
+      * you can convert it to a matrix of type #MatrixType.
+      *
+      * \sa matrixH() for an example, class HouseholderSequence
+      */
+    HouseholderSequenceType matrixQ() const
+    {
+      eigen_assert(m_isInitialized && "HessenbergDecomposition is not initialized.");
+      return HouseholderSequenceType(m_matrix, m_hCoeffs.conjugate())
+             .setLength(m_matrix.rows() - 1)
+             .setShift(1);
+    }
+
+    /** \brief Constructs the Hessenberg matrix H in the decomposition
+      *
+      * \returns expression object representing the matrix H
+      *
+      * \pre Either the constructor HessenbergDecomposition(const MatrixType&)
+      * or the member function compute(const MatrixType&) has been called
+      * before to compute the Hessenberg decomposition of a matrix.
+      *
+      * The object returned by this function constructs the Hessenberg matrix H
+      * when it is assigned to a matrix or otherwise evaluated. The matrix H is
+      * constructed from the packed matrix as returned by packedMatrix(): The
+      * upper part (including the subdiagonal) of the packed matrix contains
+      * the matrix H. It may sometimes be better to directly use the packed
+      * matrix instead of constructing the matrix H.
+      *
+      * Example: \include HessenbergDecomposition_matrixH.cpp
+      * Output: \verbinclude HessenbergDecomposition_matrixH.out
+      *
+      * \sa matrixQ(), packedMatrix()
+      */
+    MatrixHReturnType matrixH() const
+    {
+      eigen_assert(m_isInitialized && "HessenbergDecomposition is not initialized.");
+      return MatrixHReturnType(*this);
+    }
+
+  private:
+
+    typedef Matrix<Scalar, 1, Size, Options | RowMajor, 1, MaxSize> VectorType;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    static void _compute(MatrixType& matA, CoeffVectorType& hCoeffs, VectorType& temp);
+
+  protected:
+    MatrixType m_matrix;
+    CoeffVectorType m_hCoeffs;
+    VectorType m_temp;
+    bool m_isInitialized;
+};
+
+/** \internal
+  * Performs a tridiagonal decomposition of \a matA in place.
+  *
+  * \param matA the input selfadjoint matrix
+  * \param hCoeffs returned Householder coefficients
+  *
+  * The result is written in the lower triangular part of \a matA.
+  *
+  * Implemented from Golub's "%Matrix Computations", algorithm 8.3.1.
+  *
+  * \sa packedMatrix()
+  */
+template<typename MatrixType>
+void HessenbergDecomposition<MatrixType>::_compute(MatrixType& matA, CoeffVectorType& hCoeffs, VectorType& temp)
+{
+  eigen_assert(matA.rows()==matA.cols());
+  Index n = matA.rows();
+  temp.resize(n);
+  for (Index i = 0; i<n-1; ++i)
+  {
+    // let's consider the vector v = i-th column starting at position i+1
+    Index remainingSize = n-i-1;
+    RealScalar beta;
+    Scalar h;
+    matA.col(i).tail(remainingSize).makeHouseholderInPlace(h, beta);
+    matA.col(i).coeffRef(i+1) = beta;
+    hCoeffs.coeffRef(i) = h;
+
+    // Apply similarity transformation to remaining columns,
+    // i.e., compute A = H A H'
+
+    // A = H A
+    matA.bottomRightCorner(remainingSize, remainingSize)
+        .applyHouseholderOnTheLeft(matA.col(i).tail(remainingSize-1), h, &temp.coeffRef(0));
+
+    // A = A H'
+    matA.rightCols(remainingSize)
+        .applyHouseholderOnTheRight(matA.col(i).tail(remainingSize-1).conjugate(), numext::conj(h), &temp.coeffRef(0));
+  }
+}
+
+namespace internal {
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  *
+  * \brief Expression type for return value of HessenbergDecomposition::matrixH()
+  *
+  * \tparam MatrixType type of matrix in the Hessenberg decomposition
+  *
+  * Objects of this type represent the Hessenberg matrix in the Hessenberg
+  * decomposition of some matrix. The object holds a reference to the
+  * HessenbergDecomposition class until the it is assigned or evaluated for
+  * some other reason (the reference should remain valid during the life time
+  * of this object). This class is the return type of
+  * HessenbergDecomposition::matrixH(); there is probably no other use for this
+  * class.
+  */
+template<typename MatrixType> struct HessenbergDecompositionMatrixHReturnType
+: public ReturnByValue<HessenbergDecompositionMatrixHReturnType<MatrixType> >
+{
+  public:
+    /** \brief Constructor.
+      *
+      * \param[in] hess  Hessenberg decomposition
+      */
+    HessenbergDecompositionMatrixHReturnType(const HessenbergDecomposition<MatrixType>& hess) : m_hess(hess) { }
+
+    /** \brief Hessenberg matrix in decomposition.
+      *
+      * \param[out] result  Hessenberg matrix in decomposition \p hess which
+      *                     was passed to the constructor
+      */
+    template <typename ResultType>
+    inline void evalTo(ResultType& result) const
+    {
+      result = m_hess.packedMatrix();
+      Index n = result.rows();
+      if (n>2)
+        result.bottomLeftCorner(n-2, n-2).template triangularView<Lower>().setZero();
+    }
+
+    Index rows() const { return m_hess.packedMatrix().rows(); }
+    Index cols() const { return m_hess.packedMatrix().cols(); }
+
+  protected:
+    const HessenbergDecomposition<MatrixType>& m_hess;
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_HESSENBERGDECOMPOSITION_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
new file mode 100644
index 00000000..dbbd4806
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
@@ -0,0 +1,160 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATRIXBASEEIGENVALUES_H
+#define EIGEN_MATRIXBASEEIGENVALUES_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename Derived, bool IsComplex>
+struct eigenvalues_selector
+{
+  // this is the implementation for the case IsComplex = true
+  static inline typename MatrixBase<Derived>::EigenvaluesReturnType const
+  run(const MatrixBase<Derived>& m)
+  {
+    typedef typename Derived::PlainObject PlainObject;
+    PlainObject m_eval(m);
+    return ComplexEigenSolver<PlainObject>(m_eval, false).eigenvalues();
+  }
+};
+
+template<typename Derived>
+struct eigenvalues_selector<Derived, false>
+{
+  static inline typename MatrixBase<Derived>::EigenvaluesReturnType const
+  run(const MatrixBase<Derived>& m)
+  {
+    typedef typename Derived::PlainObject PlainObject;
+    PlainObject m_eval(m);
+    return EigenSolver<PlainObject>(m_eval, false).eigenvalues();
+  }
+};
+
+} // end namespace internal
+
+/** \brief Computes the eigenvalues of a matrix 
+  * \returns Column vector containing the eigenvalues.
+  *
+  * \eigenvalues_module
+  * This function computes the eigenvalues with the help of the EigenSolver
+  * class (for real matrices) or the ComplexEigenSolver class (for complex
+  * matrices). 
+  *
+  * The eigenvalues are repeated according to their algebraic multiplicity,
+  * so there are as many eigenvalues as rows in the matrix.
+  *
+  * The SelfAdjointView class provides a better algorithm for selfadjoint
+  * matrices.
+  *
+  * Example: \include MatrixBase_eigenvalues.cpp
+  * Output: \verbinclude MatrixBase_eigenvalues.out
+  *
+  * \sa EigenSolver::eigenvalues(), ComplexEigenSolver::eigenvalues(),
+  *     SelfAdjointView::eigenvalues()
+  */
+template<typename Derived>
+inline typename MatrixBase<Derived>::EigenvaluesReturnType
+MatrixBase<Derived>::eigenvalues() const
+{
+  typedef typename internal::traits<Derived>::Scalar Scalar;
+  return internal::eigenvalues_selector<Derived, NumTraits<Scalar>::IsComplex>::run(derived());
+}
+
+/** \brief Computes the eigenvalues of a matrix
+  * \returns Column vector containing the eigenvalues.
+  *
+  * \eigenvalues_module
+  * This function computes the eigenvalues with the help of the
+  * SelfAdjointEigenSolver class.  The eigenvalues are repeated according to
+  * their algebraic multiplicity, so there are as many eigenvalues as rows in
+  * the matrix.
+  *
+  * Example: \include SelfAdjointView_eigenvalues.cpp
+  * Output: \verbinclude SelfAdjointView_eigenvalues.out
+  *
+  * \sa SelfAdjointEigenSolver::eigenvalues(), MatrixBase::eigenvalues()
+  */
+template<typename MatrixType, unsigned int UpLo> 
+EIGEN_DEVICE_FUNC inline typename SelfAdjointView<MatrixType, UpLo>::EigenvaluesReturnType
+SelfAdjointView<MatrixType, UpLo>::eigenvalues() const
+{
+  typedef typename SelfAdjointView<MatrixType, UpLo>::PlainObject PlainObject;
+  PlainObject thisAsMatrix(*this);
+  return SelfAdjointEigenSolver<PlainObject>(thisAsMatrix, false).eigenvalues();
+}
+
+
+
+/** \brief Computes the L2 operator norm
+  * \returns Operator norm of the matrix.
+  *
+  * \eigenvalues_module
+  * This function computes the L2 operator norm of a matrix, which is also
+  * known as the spectral norm. The norm of a matrix \f$ A \f$ is defined to be
+  * \f[ \|A\|_2 = \max_x \frac{\|Ax\|_2}{\|x\|_2} \f]
+  * where the maximum is over all vectors and the norm on the right is the
+  * Euclidean vector norm. The norm equals the largest singular value, which is
+  * the square root of the largest eigenvalue of the positive semi-definite
+  * matrix \f$ A^*A \f$.
+  *
+  * The current implementation uses the eigenvalues of \f$ A^*A \f$, as computed
+  * by SelfAdjointView::eigenvalues(), to compute the operator norm of a
+  * matrix.  The SelfAdjointView class provides a better algorithm for
+  * selfadjoint matrices.
+  *
+  * Example: \include MatrixBase_operatorNorm.cpp
+  * Output: \verbinclude MatrixBase_operatorNorm.out
+  *
+  * \sa SelfAdjointView::eigenvalues(), SelfAdjointView::operatorNorm()
+  */
+template<typename Derived>
+inline typename MatrixBase<Derived>::RealScalar
+MatrixBase<Derived>::operatorNorm() const
+{
+  using std::sqrt;
+  typename Derived::PlainObject m_eval(derived());
+  // FIXME if it is really guaranteed that the eigenvalues are already sorted,
+  // then we don't need to compute a maxCoeff() here, comparing the 1st and last ones is enough.
+  return sqrt((m_eval*m_eval.adjoint())
+                 .eval()
+		 .template selfadjointView<Lower>()
+		 .eigenvalues()
+		 .maxCoeff()
+		 );
+}
+
+/** \brief Computes the L2 operator norm
+  * \returns Operator norm of the matrix.
+  *
+  * \eigenvalues_module
+  * This function computes the L2 operator norm of a self-adjoint matrix. For a
+  * self-adjoint matrix, the operator norm is the largest eigenvalue.
+  *
+  * The current implementation uses the eigenvalues of the matrix, as computed
+  * by eigenvalues(), to compute the operator norm of the matrix.
+  *
+  * Example: \include SelfAdjointView_operatorNorm.cpp
+  * Output: \verbinclude SelfAdjointView_operatorNorm.out
+  *
+  * \sa eigenvalues(), MatrixBase::operatorNorm()
+  */
+template<typename MatrixType, unsigned int UpLo>
+EIGEN_DEVICE_FUNC inline typename SelfAdjointView<MatrixType, UpLo>::RealScalar
+SelfAdjointView<MatrixType, UpLo>::operatorNorm() const
+{
+  return eigenvalues().cwiseAbs().maxCoeff();
+}
+
+} // end namespace Eigen
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/RealQZ.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/RealQZ.h
new file mode 100644
index 00000000..b3a910dd
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/RealQZ.h
@@ -0,0 +1,654 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Alexey Korepanov <kaikaikai@yandex.ru>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_REAL_QZ_H
+#define EIGEN_REAL_QZ_H
+
+namespace Eigen {
+
+  /** \eigenvalues_module \ingroup Eigenvalues_Module
+   *
+   *
+   * \class RealQZ
+   *
+   * \brief Performs a real QZ decomposition of a pair of square matrices
+   *
+   * \tparam _MatrixType the type of the matrix of which we are computing the
+   * real QZ decomposition; this is expected to be an instantiation of the
+   * Matrix class template.
+   *
+   * Given a real square matrices A and B, this class computes the real QZ
+   * decomposition: \f$ A = Q S Z \f$, \f$ B = Q T Z \f$ where Q and Z are
+   * real orthogonal matrixes, T is upper-triangular matrix, and S is upper
+   * quasi-triangular matrix. An orthogonal matrix is a matrix whose
+   * inverse is equal to its transpose, \f$ U^{-1} = U^T \f$. A quasi-triangular
+   * matrix is a block-triangular matrix whose diagonal consists of 1-by-1
+   * blocks and 2-by-2 blocks where further reduction is impossible due to
+   * complex eigenvalues. 
+   *
+   * The eigenvalues of the pencil \f$ A - z B \f$ can be obtained from
+   * 1x1 and 2x2 blocks on the diagonals of S and T.
+   *
+   * Call the function compute() to compute the real QZ decomposition of a
+   * given pair of matrices. Alternatively, you can use the 
+   * RealQZ(const MatrixType& B, const MatrixType& B, bool computeQZ)
+   * constructor which computes the real QZ decomposition at construction
+   * time. Once the decomposition is computed, you can use the matrixS(),
+   * matrixT(), matrixQ() and matrixZ() functions to retrieve the matrices
+   * S, T, Q and Z in the decomposition. If computeQZ==false, some time
+   * is saved by not computing matrices Q and Z.
+   *
+   * Example: \include RealQZ_compute.cpp
+   * Output: \include RealQZ_compute.out
+   *
+   * \note The implementation is based on the algorithm in "Matrix Computations"
+   * by Gene H. Golub and Charles F. Van Loan, and a paper "An algorithm for
+   * generalized eigenvalue problems" by C.B.Moler and G.W.Stewart.
+   *
+   * \sa class RealSchur, class ComplexSchur, class EigenSolver, class ComplexEigenSolver
+   */
+
+  template<typename _MatrixType> class RealQZ
+  {
+    public:
+      typedef _MatrixType MatrixType;
+      enum {
+        RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+        ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+        Options = MatrixType::Options,
+        MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+        MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+      };
+      typedef typename MatrixType::Scalar Scalar;
+      typedef std::complex<typename NumTraits<Scalar>::Real> ComplexScalar;
+      typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+
+      typedef Matrix<ComplexScalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> EigenvalueType;
+      typedef Matrix<Scalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> ColumnVectorType;
+
+      /** \brief Default constructor.
+       *
+       * \param [in] size  Positive integer, size of the matrix whose QZ decomposition will be computed.
+       *
+       * The default constructor is useful in cases in which the user intends to
+       * perform decompositions via compute().  The \p size parameter is only
+       * used as a hint. It is not an error to give a wrong \p size, but it may
+       * impair performance.
+       *
+       * \sa compute() for an example.
+       */
+      explicit RealQZ(Index size = RowsAtCompileTime==Dynamic ? 1 : RowsAtCompileTime) :
+        m_S(size, size),
+        m_T(size, size),
+        m_Q(size, size),
+        m_Z(size, size),
+        m_workspace(size*2),
+        m_maxIters(400),
+        m_isInitialized(false)
+        { }
+
+      /** \brief Constructor; computes real QZ decomposition of given matrices
+       * 
+       * \param[in]  A          Matrix A.
+       * \param[in]  B          Matrix B.
+       * \param[in]  computeQZ  If false, A and Z are not computed.
+       *
+       * This constructor calls compute() to compute the QZ decomposition.
+       */
+      RealQZ(const MatrixType& A, const MatrixType& B, bool computeQZ = true) :
+        m_S(A.rows(),A.cols()),
+        m_T(A.rows(),A.cols()),
+        m_Q(A.rows(),A.cols()),
+        m_Z(A.rows(),A.cols()),
+        m_workspace(A.rows()*2),
+        m_maxIters(400),
+        m_isInitialized(false) {
+          compute(A, B, computeQZ);
+        }
+
+      /** \brief Returns matrix Q in the QZ decomposition. 
+       *
+       * \returns A const reference to the matrix Q.
+       */
+      const MatrixType& matrixQ() const {
+        eigen_assert(m_isInitialized && "RealQZ is not initialized.");
+        eigen_assert(m_computeQZ && "The matrices Q and Z have not been computed during the QZ decomposition.");
+        return m_Q;
+      }
+
+      /** \brief Returns matrix Z in the QZ decomposition. 
+       *
+       * \returns A const reference to the matrix Z.
+       */
+      const MatrixType& matrixZ() const {
+        eigen_assert(m_isInitialized && "RealQZ is not initialized.");
+        eigen_assert(m_computeQZ && "The matrices Q and Z have not been computed during the QZ decomposition.");
+        return m_Z;
+      }
+
+      /** \brief Returns matrix S in the QZ decomposition. 
+       *
+       * \returns A const reference to the matrix S.
+       */
+      const MatrixType& matrixS() const {
+        eigen_assert(m_isInitialized && "RealQZ is not initialized.");
+        return m_S;
+      }
+
+      /** \brief Returns matrix S in the QZ decomposition. 
+       *
+       * \returns A const reference to the matrix S.
+       */
+      const MatrixType& matrixT() const {
+        eigen_assert(m_isInitialized && "RealQZ is not initialized.");
+        return m_T;
+      }
+
+      /** \brief Computes QZ decomposition of given matrix. 
+       * 
+       * \param[in]  A          Matrix A.
+       * \param[in]  B          Matrix B.
+       * \param[in]  computeQZ  If false, A and Z are not computed.
+       * \returns    Reference to \c *this
+       */
+      RealQZ& compute(const MatrixType& A, const MatrixType& B, bool computeQZ = true);
+
+      /** \brief Reports whether previous computation was successful.
+       *
+       * \returns \c Success if computation was succesful, \c NoConvergence otherwise.
+       */
+      ComputationInfo info() const
+      {
+        eigen_assert(m_isInitialized && "RealQZ is not initialized.");
+        return m_info;
+      }
+
+      /** \brief Returns number of performed QR-like iterations.
+      */
+      Index iterations() const
+      {
+        eigen_assert(m_isInitialized && "RealQZ is not initialized.");
+        return m_global_iter;
+      }
+
+      /** Sets the maximal number of iterations allowed to converge to one eigenvalue
+       * or decouple the problem.
+      */
+      RealQZ& setMaxIterations(Index maxIters)
+      {
+        m_maxIters = maxIters;
+        return *this;
+      }
+
+    private:
+
+      MatrixType m_S, m_T, m_Q, m_Z;
+      Matrix<Scalar,Dynamic,1> m_workspace;
+      ComputationInfo m_info;
+      Index m_maxIters;
+      bool m_isInitialized;
+      bool m_computeQZ;
+      Scalar m_normOfT, m_normOfS;
+      Index m_global_iter;
+
+      typedef Matrix<Scalar,3,1> Vector3s;
+      typedef Matrix<Scalar,2,1> Vector2s;
+      typedef Matrix<Scalar,2,2> Matrix2s;
+      typedef JacobiRotation<Scalar> JRs;
+
+      void hessenbergTriangular();
+      void computeNorms();
+      Index findSmallSubdiagEntry(Index iu);
+      Index findSmallDiagEntry(Index f, Index l);
+      void splitOffTwoRows(Index i);
+      void pushDownZero(Index z, Index f, Index l);
+      void step(Index f, Index l, Index iter);
+
+  }; // RealQZ
+
+  /** \internal Reduces S and T to upper Hessenberg - triangular form */
+  template<typename MatrixType>
+    void RealQZ<MatrixType>::hessenbergTriangular()
+    {
+
+      const Index dim = m_S.cols();
+
+      // perform QR decomposition of T, overwrite T with R, save Q
+      HouseholderQR<MatrixType> qrT(m_T);
+      m_T = qrT.matrixQR();
+      m_T.template triangularView<StrictlyLower>().setZero();
+      m_Q = qrT.householderQ();
+      // overwrite S with Q* S
+      m_S.applyOnTheLeft(m_Q.adjoint());
+      // init Z as Identity
+      if (m_computeQZ)
+        m_Z = MatrixType::Identity(dim,dim);
+      // reduce S to upper Hessenberg with Givens rotations
+      for (Index j=0; j<=dim-3; j++) {
+        for (Index i=dim-1; i>=j+2; i--) {
+          JRs G;
+          // kill S(i,j)
+          if(m_S.coeff(i,j) != 0)
+          {
+            G.makeGivens(m_S.coeff(i-1,j), m_S.coeff(i,j), &m_S.coeffRef(i-1, j));
+            m_S.coeffRef(i,j) = Scalar(0.0);
+            m_S.rightCols(dim-j-1).applyOnTheLeft(i-1,i,G.adjoint());
+            m_T.rightCols(dim-i+1).applyOnTheLeft(i-1,i,G.adjoint());
+            // update Q
+            if (m_computeQZ)
+              m_Q.applyOnTheRight(i-1,i,G);
+          }
+          // kill T(i,i-1)
+          if(m_T.coeff(i,i-1)!=Scalar(0))
+          {
+            G.makeGivens(m_T.coeff(i,i), m_T.coeff(i,i-1), &m_T.coeffRef(i,i));
+            m_T.coeffRef(i,i-1) = Scalar(0.0);
+            m_S.applyOnTheRight(i,i-1,G);
+            m_T.topRows(i).applyOnTheRight(i,i-1,G);
+            // update Z
+            if (m_computeQZ)
+              m_Z.applyOnTheLeft(i,i-1,G.adjoint());
+          }
+        }
+      }
+    }
+
+  /** \internal Computes vector L1 norms of S and T when in Hessenberg-Triangular form already */
+  template<typename MatrixType>
+    inline void RealQZ<MatrixType>::computeNorms()
+    {
+      const Index size = m_S.cols();
+      m_normOfS = Scalar(0.0);
+      m_normOfT = Scalar(0.0);
+      for (Index j = 0; j < size; ++j)
+      {
+        m_normOfS += m_S.col(j).segment(0, (std::min)(size,j+2)).cwiseAbs().sum();
+        m_normOfT += m_T.row(j).segment(j, size - j).cwiseAbs().sum();
+      }
+    }
+
+
+  /** \internal Look for single small sub-diagonal element S(res, res-1) and return res (or 0) */
+  template<typename MatrixType>
+    inline Index RealQZ<MatrixType>::findSmallSubdiagEntry(Index iu)
+    {
+      using std::abs;
+      Index res = iu;
+      while (res > 0)
+      {
+        Scalar s = abs(m_S.coeff(res-1,res-1)) + abs(m_S.coeff(res,res));
+        if (s == Scalar(0.0))
+          s = m_normOfS;
+        if (abs(m_S.coeff(res,res-1)) < NumTraits<Scalar>::epsilon() * s)
+          break;
+        res--;
+      }
+      return res;
+    }
+
+  /** \internal Look for single small diagonal element T(res, res) for res between f and l, and return res (or f-1)  */
+  template<typename MatrixType>
+    inline Index RealQZ<MatrixType>::findSmallDiagEntry(Index f, Index l)
+    {
+      using std::abs;
+      Index res = l;
+      while (res >= f) {
+        if (abs(m_T.coeff(res,res)) <= NumTraits<Scalar>::epsilon() * m_normOfT)
+          break;
+        res--;
+      }
+      return res;
+    }
+
+  /** \internal decouple 2x2 diagonal block in rows i, i+1 if eigenvalues are real */
+  template<typename MatrixType>
+    inline void RealQZ<MatrixType>::splitOffTwoRows(Index i)
+    {
+      using std::abs;
+      using std::sqrt;
+      const Index dim=m_S.cols();
+      if (abs(m_S.coeff(i+1,i))==Scalar(0))
+        return;
+      Index j = findSmallDiagEntry(i,i+1);
+      if (j==i-1)
+      {
+        // block of (S T^{-1})
+        Matrix2s STi = m_T.template block<2,2>(i,i).template triangularView<Upper>().
+          template solve<OnTheRight>(m_S.template block<2,2>(i,i));
+        Scalar p = Scalar(0.5)*(STi(0,0)-STi(1,1));
+        Scalar q = p*p + STi(1,0)*STi(0,1);
+        if (q>=0) {
+          Scalar z = sqrt(q);
+          // one QR-like iteration for ABi - lambda I
+          // is enough - when we know exact eigenvalue in advance,
+          // convergence is immediate
+          JRs G;
+          if (p>=0)
+            G.makeGivens(p + z, STi(1,0));
+          else
+            G.makeGivens(p - z, STi(1,0));
+          m_S.rightCols(dim-i).applyOnTheLeft(i,i+1,G.adjoint());
+          m_T.rightCols(dim-i).applyOnTheLeft(i,i+1,G.adjoint());
+          // update Q
+          if (m_computeQZ)
+            m_Q.applyOnTheRight(i,i+1,G);
+
+          G.makeGivens(m_T.coeff(i+1,i+1), m_T.coeff(i+1,i));
+          m_S.topRows(i+2).applyOnTheRight(i+1,i,G);
+          m_T.topRows(i+2).applyOnTheRight(i+1,i,G);
+          // update Z
+          if (m_computeQZ)
+            m_Z.applyOnTheLeft(i+1,i,G.adjoint());
+
+          m_S.coeffRef(i+1,i) = Scalar(0.0);
+          m_T.coeffRef(i+1,i) = Scalar(0.0);
+        }
+      }
+      else
+      {
+        pushDownZero(j,i,i+1);
+      }
+    }
+
+  /** \internal use zero in T(z,z) to zero S(l,l-1), working in block f..l */
+  template<typename MatrixType>
+    inline void RealQZ<MatrixType>::pushDownZero(Index z, Index f, Index l)
+    {
+      JRs G;
+      const Index dim = m_S.cols();
+      for (Index zz=z; zz<l; zz++)
+      {
+        // push 0 down
+        Index firstColS = zz>f ? (zz-1) : zz;
+        G.makeGivens(m_T.coeff(zz, zz+1), m_T.coeff(zz+1, zz+1));
+        m_S.rightCols(dim-firstColS).applyOnTheLeft(zz,zz+1,G.adjoint());
+        m_T.rightCols(dim-zz).applyOnTheLeft(zz,zz+1,G.adjoint());
+        m_T.coeffRef(zz+1,zz+1) = Scalar(0.0);
+        // update Q
+        if (m_computeQZ)
+          m_Q.applyOnTheRight(zz,zz+1,G);
+        // kill S(zz+1, zz-1)
+        if (zz>f)
+        {
+          G.makeGivens(m_S.coeff(zz+1, zz), m_S.coeff(zz+1,zz-1));
+          m_S.topRows(zz+2).applyOnTheRight(zz, zz-1,G);
+          m_T.topRows(zz+1).applyOnTheRight(zz, zz-1,G);
+          m_S.coeffRef(zz+1,zz-1) = Scalar(0.0);
+          // update Z
+          if (m_computeQZ)
+            m_Z.applyOnTheLeft(zz,zz-1,G.adjoint());
+        }
+      }
+      // finally kill S(l,l-1)
+      G.makeGivens(m_S.coeff(l,l), m_S.coeff(l,l-1));
+      m_S.applyOnTheRight(l,l-1,G);
+      m_T.applyOnTheRight(l,l-1,G);
+      m_S.coeffRef(l,l-1)=Scalar(0.0);
+      // update Z
+      if (m_computeQZ)
+        m_Z.applyOnTheLeft(l,l-1,G.adjoint());
+    }
+
+  /** \internal QR-like iterative step for block f..l */
+  template<typename MatrixType>
+    inline void RealQZ<MatrixType>::step(Index f, Index l, Index iter)
+    {
+      using std::abs;
+      const Index dim = m_S.cols();
+
+      // x, y, z
+      Scalar x, y, z;
+      if (iter==10)
+      {
+        // Wilkinson ad hoc shift
+        const Scalar
+          a11=m_S.coeff(f+0,f+0), a12=m_S.coeff(f+0,f+1),
+          a21=m_S.coeff(f+1,f+0), a22=m_S.coeff(f+1,f+1), a32=m_S.coeff(f+2,f+1),
+          b12=m_T.coeff(f+0,f+1),
+          b11i=Scalar(1.0)/m_T.coeff(f+0,f+0),
+          b22i=Scalar(1.0)/m_T.coeff(f+1,f+1),
+          a87=m_S.coeff(l-1,l-2),
+          a98=m_S.coeff(l-0,l-1),
+          b77i=Scalar(1.0)/m_T.coeff(l-2,l-2),
+          b88i=Scalar(1.0)/m_T.coeff(l-1,l-1);
+        Scalar ss = abs(a87*b77i) + abs(a98*b88i),
+               lpl = Scalar(1.5)*ss,
+               ll = ss*ss;
+        x = ll + a11*a11*b11i*b11i - lpl*a11*b11i + a12*a21*b11i*b22i
+          - a11*a21*b12*b11i*b11i*b22i;
+        y = a11*a21*b11i*b11i - lpl*a21*b11i + a21*a22*b11i*b22i 
+          - a21*a21*b12*b11i*b11i*b22i;
+        z = a21*a32*b11i*b22i;
+      }
+      else if (iter==16)
+      {
+        // another exceptional shift
+        x = m_S.coeff(f,f)/m_T.coeff(f,f)-m_S.coeff(l,l)/m_T.coeff(l,l) + m_S.coeff(l,l-1)*m_T.coeff(l-1,l) /
+          (m_T.coeff(l-1,l-1)*m_T.coeff(l,l));
+        y = m_S.coeff(f+1,f)/m_T.coeff(f,f);
+        z = 0;
+      }
+      else if (iter>23 && !(iter%8))
+      {
+        // extremely exceptional shift
+        x = internal::random<Scalar>(-1.0,1.0);
+        y = internal::random<Scalar>(-1.0,1.0);
+        z = internal::random<Scalar>(-1.0,1.0);
+      }
+      else
+      {
+        // Compute the shifts: (x,y,z,0...) = (AB^-1 - l1 I) (AB^-1 - l2 I) e1
+        // where l1 and l2 are the eigenvalues of the 2x2 matrix C = U V^-1 where
+        // U and V are 2x2 bottom right sub matrices of A and B. Thus:
+        //  = AB^-1AB^-1 + l1 l2 I - (l1+l2)(AB^-1)
+        //  = AB^-1AB^-1 + det(M) - tr(M)(AB^-1)
+        // Since we are only interested in having x, y, z with a correct ratio, we have:
+        const Scalar
+          a11 = m_S.coeff(f,f),     a12 = m_S.coeff(f,f+1),
+          a21 = m_S.coeff(f+1,f),   a22 = m_S.coeff(f+1,f+1),
+                                    a32 = m_S.coeff(f+2,f+1),
+
+          a88 = m_S.coeff(l-1,l-1), a89 = m_S.coeff(l-1,l),
+          a98 = m_S.coeff(l,l-1),   a99 = m_S.coeff(l,l),
+
+          b11 = m_T.coeff(f,f),     b12 = m_T.coeff(f,f+1),
+                                    b22 = m_T.coeff(f+1,f+1),
+
+          b88 = m_T.coeff(l-1,l-1), b89 = m_T.coeff(l-1,l),
+                                    b99 = m_T.coeff(l,l);
+
+        x = ( (a88/b88 - a11/b11)*(a99/b99 - a11/b11) - (a89/b99)*(a98/b88) + (a98/b88)*(b89/b99)*(a11/b11) ) * (b11/a21)
+          + a12/b22 - (a11/b11)*(b12/b22);
+        y = (a22/b22-a11/b11) - (a21/b11)*(b12/b22) - (a88/b88-a11/b11) - (a99/b99-a11/b11) + (a98/b88)*(b89/b99);
+        z = a32/b22;
+      }
+
+      JRs G;
+
+      for (Index k=f; k<=l-2; k++)
+      {
+        // variables for Householder reflections
+        Vector2s essential2;
+        Scalar tau, beta;
+
+        Vector3s hr(x,y,z);
+
+        // Q_k to annihilate S(k+1,k-1) and S(k+2,k-1)
+        hr.makeHouseholderInPlace(tau, beta);
+        essential2 = hr.template bottomRows<2>();
+        Index fc=(std::max)(k-1,Index(0));  // first col to update
+        m_S.template middleRows<3>(k).rightCols(dim-fc).applyHouseholderOnTheLeft(essential2, tau, m_workspace.data());
+        m_T.template middleRows<3>(k).rightCols(dim-fc).applyHouseholderOnTheLeft(essential2, tau, m_workspace.data());
+        if (m_computeQZ)
+          m_Q.template middleCols<3>(k).applyHouseholderOnTheRight(essential2, tau, m_workspace.data());
+        if (k>f)
+          m_S.coeffRef(k+2,k-1) = m_S.coeffRef(k+1,k-1) = Scalar(0.0);
+
+        // Z_{k1} to annihilate T(k+2,k+1) and T(k+2,k)
+        hr << m_T.coeff(k+2,k+2),m_T.coeff(k+2,k),m_T.coeff(k+2,k+1);
+        hr.makeHouseholderInPlace(tau, beta);
+        essential2 = hr.template bottomRows<2>();
+        {
+          Index lr = (std::min)(k+4,dim); // last row to update
+          Map<Matrix<Scalar,Dynamic,1> > tmp(m_workspace.data(),lr);
+          // S
+          tmp = m_S.template middleCols<2>(k).topRows(lr) * essential2;
+          tmp += m_S.col(k+2).head(lr);
+          m_S.col(k+2).head(lr) -= tau*tmp;
+          m_S.template middleCols<2>(k).topRows(lr) -= (tau*tmp) * essential2.adjoint();
+          // T
+          tmp = m_T.template middleCols<2>(k).topRows(lr) * essential2;
+          tmp += m_T.col(k+2).head(lr);
+          m_T.col(k+2).head(lr) -= tau*tmp;
+          m_T.template middleCols<2>(k).topRows(lr) -= (tau*tmp) * essential2.adjoint();
+        }
+        if (m_computeQZ)
+        {
+          // Z
+          Map<Matrix<Scalar,1,Dynamic> > tmp(m_workspace.data(),dim);
+          tmp = essential2.adjoint()*(m_Z.template middleRows<2>(k));
+          tmp += m_Z.row(k+2);
+          m_Z.row(k+2) -= tau*tmp;
+          m_Z.template middleRows<2>(k) -= essential2 * (tau*tmp);
+        }
+        m_T.coeffRef(k+2,k) = m_T.coeffRef(k+2,k+1) = Scalar(0.0);
+
+        // Z_{k2} to annihilate T(k+1,k)
+        G.makeGivens(m_T.coeff(k+1,k+1), m_T.coeff(k+1,k));
+        m_S.applyOnTheRight(k+1,k,G);
+        m_T.applyOnTheRight(k+1,k,G);
+        // update Z
+        if (m_computeQZ)
+          m_Z.applyOnTheLeft(k+1,k,G.adjoint());
+        m_T.coeffRef(k+1,k) = Scalar(0.0);
+
+        // update x,y,z
+        x = m_S.coeff(k+1,k);
+        y = m_S.coeff(k+2,k);
+        if (k < l-2)
+          z = m_S.coeff(k+3,k);
+      } // loop over k
+
+      // Q_{n-1} to annihilate y = S(l,l-2)
+      G.makeGivens(x,y);
+      m_S.applyOnTheLeft(l-1,l,G.adjoint());
+      m_T.applyOnTheLeft(l-1,l,G.adjoint());
+      if (m_computeQZ)
+        m_Q.applyOnTheRight(l-1,l,G);
+      m_S.coeffRef(l,l-2) = Scalar(0.0);
+
+      // Z_{n-1} to annihilate T(l,l-1)
+      G.makeGivens(m_T.coeff(l,l),m_T.coeff(l,l-1));
+      m_S.applyOnTheRight(l,l-1,G);
+      m_T.applyOnTheRight(l,l-1,G);
+      if (m_computeQZ)
+        m_Z.applyOnTheLeft(l,l-1,G.adjoint());
+      m_T.coeffRef(l,l-1) = Scalar(0.0);
+    }
+
+  template<typename MatrixType>
+    RealQZ<MatrixType>& RealQZ<MatrixType>::compute(const MatrixType& A_in, const MatrixType& B_in, bool computeQZ)
+    {
+
+      const Index dim = A_in.cols();
+
+      eigen_assert (A_in.rows()==dim && A_in.cols()==dim 
+          && B_in.rows()==dim && B_in.cols()==dim 
+          && "Need square matrices of the same dimension");
+
+      m_isInitialized = true;
+      m_computeQZ = computeQZ;
+      m_S = A_in; m_T = B_in;
+      m_workspace.resize(dim*2);
+      m_global_iter = 0;
+
+      // entrance point: hessenberg triangular decomposition
+      hessenbergTriangular();
+      // compute L1 vector norms of T, S into m_normOfS, m_normOfT
+      computeNorms();
+
+      Index l = dim-1, 
+            f, 
+            local_iter = 0;
+
+      while (l>0 && local_iter<m_maxIters)
+      {
+        f = findSmallSubdiagEntry(l);
+        // now rows and columns f..l (including) decouple from the rest of the problem
+        if (f>0) m_S.coeffRef(f,f-1) = Scalar(0.0);
+        if (f == l) // One root found
+        {
+          l--;
+          local_iter = 0;
+        }
+        else if (f == l-1) // Two roots found
+        {
+          splitOffTwoRows(f);
+          l -= 2;
+          local_iter = 0;
+        }
+        else // No convergence yet
+        {
+          // if there's zero on diagonal of T, we can isolate an eigenvalue with Givens rotations
+          Index z = findSmallDiagEntry(f,l);
+          if (z>=f)
+          {
+            // zero found
+            pushDownZero(z,f,l);
+          }
+          else
+          {
+            // We are sure now that S.block(f,f, l-f+1,l-f+1) is underuced upper-Hessenberg 
+            // and T.block(f,f, l-f+1,l-f+1) is invertible uper-triangular, which allows to
+            // apply a QR-like iteration to rows and columns f..l.
+            step(f,l, local_iter);
+            local_iter++;
+            m_global_iter++;
+          }
+        }
+      }
+      // check if we converged before reaching iterations limit
+      m_info = (local_iter<m_maxIters) ? Success : NoConvergence;
+
+      // For each non triangular 2x2 diagonal block of S,
+      //    reduce the respective 2x2 diagonal block of T to positive diagonal form using 2x2 SVD.
+      // This step is not mandatory for QZ, but it does help further extraction of eigenvalues/eigenvectors,
+      // and is in par with Lapack/Matlab QZ.
+      if(m_info==Success)
+      {
+        for(Index i=0; i<dim-1; ++i)
+        {
+          if(m_S.coeff(i+1, i) != Scalar(0))
+          {
+            JacobiRotation<Scalar> j_left, j_right;
+            internal::real_2x2_jacobi_svd(m_T, i, i+1, &j_left, &j_right);
+
+            // Apply resulting Jacobi rotations
+            m_S.applyOnTheLeft(i,i+1,j_left);
+            m_S.applyOnTheRight(i,i+1,j_right);
+            m_T.applyOnTheLeft(i,i+1,j_left);
+            m_T.applyOnTheRight(i,i+1,j_right);
+            m_T(i+1,i) = m_T(i,i+1) = Scalar(0);
+
+            if(m_computeQZ) {
+              m_Q.applyOnTheRight(i,i+1,j_left.transpose());
+              m_Z.applyOnTheLeft(i,i+1,j_right.transpose());
+            }
+
+            i++;
+          }
+        }
+      }
+
+      return *this;
+    } // end compute
+
+} // end namespace Eigen
+
+#endif //EIGEN_REAL_QZ
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/RealSchur.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/RealSchur.h
new file mode 100644
index 00000000..f5c86041
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/RealSchur.h
@@ -0,0 +1,546 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010,2012 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_REAL_SCHUR_H
+#define EIGEN_REAL_SCHUR_H
+
+#include "./HessenbergDecomposition.h"
+
+namespace Eigen { 
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  *
+  * \class RealSchur
+  *
+  * \brief Performs a real Schur decomposition of a square matrix
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the
+  * real Schur decomposition; this is expected to be an instantiation of the
+  * Matrix class template.
+  *
+  * Given a real square matrix A, this class computes the real Schur
+  * decomposition: \f$ A = U T U^T \f$ where U is a real orthogonal matrix and
+  * T is a real quasi-triangular matrix. An orthogonal matrix is a matrix whose
+  * inverse is equal to its transpose, \f$ U^{-1} = U^T \f$. A quasi-triangular
+  * matrix is a block-triangular matrix whose diagonal consists of 1-by-1
+  * blocks and 2-by-2 blocks with complex eigenvalues. The eigenvalues of the
+  * blocks on the diagonal of T are the same as the eigenvalues of the matrix
+  * A, and thus the real Schur decomposition is used in EigenSolver to compute
+  * the eigendecomposition of a matrix.
+  *
+  * Call the function compute() to compute the real Schur decomposition of a
+  * given matrix. Alternatively, you can use the RealSchur(const MatrixType&, bool)
+  * constructor which computes the real Schur decomposition at construction
+  * time. Once the decomposition is computed, you can use the matrixU() and
+  * matrixT() functions to retrieve the matrices U and T in the decomposition.
+  *
+  * The documentation of RealSchur(const MatrixType&, bool) contains an example
+  * of the typical use of this class.
+  *
+  * \note The implementation is adapted from
+  * <a href="http://math.nist.gov/javanumerics/jama/">JAMA</a> (public domain).
+  * Their code is based on EISPACK.
+  *
+  * \sa class ComplexSchur, class EigenSolver, class ComplexEigenSolver
+  */
+template<typename _MatrixType> class RealSchur
+{
+  public:
+    typedef _MatrixType MatrixType;
+    enum {
+      RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      Options = MatrixType::Options,
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    typedef typename MatrixType::Scalar Scalar;
+    typedef std::complex<typename NumTraits<Scalar>::Real> ComplexScalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+
+    typedef Matrix<ComplexScalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> EigenvalueType;
+    typedef Matrix<Scalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> ColumnVectorType;
+
+    /** \brief Default constructor.
+      *
+      * \param [in] size  Positive integer, size of the matrix whose Schur decomposition will be computed.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via compute().  The \p size parameter is only
+      * used as a hint. It is not an error to give a wrong \p size, but it may
+      * impair performance.
+      *
+      * \sa compute() for an example.
+      */
+    explicit RealSchur(Index size = RowsAtCompileTime==Dynamic ? 1 : RowsAtCompileTime)
+            : m_matT(size, size),
+              m_matU(size, size),
+              m_workspaceVector(size),
+              m_hess(size),
+              m_isInitialized(false),
+              m_matUisUptodate(false),
+              m_maxIters(-1)
+    { }
+
+    /** \brief Constructor; computes real Schur decomposition of given matrix. 
+      * 
+      * \param[in]  matrix    Square matrix whose Schur decomposition is to be computed.
+      * \param[in]  computeU  If true, both T and U are computed; if false, only T is computed.
+      *
+      * This constructor calls compute() to compute the Schur decomposition.
+      *
+      * Example: \include RealSchur_RealSchur_MatrixType.cpp
+      * Output: \verbinclude RealSchur_RealSchur_MatrixType.out
+      */
+    template<typename InputType>
+    explicit RealSchur(const EigenBase<InputType>& matrix, bool computeU = true)
+            : m_matT(matrix.rows(),matrix.cols()),
+              m_matU(matrix.rows(),matrix.cols()),
+              m_workspaceVector(matrix.rows()),
+              m_hess(matrix.rows()),
+              m_isInitialized(false),
+              m_matUisUptodate(false),
+              m_maxIters(-1)
+    {
+      compute(matrix.derived(), computeU);
+    }
+
+    /** \brief Returns the orthogonal matrix in the Schur decomposition. 
+      *
+      * \returns A const reference to the matrix U.
+      *
+      * \pre Either the constructor RealSchur(const MatrixType&, bool) or the
+      * member function compute(const MatrixType&, bool) has been called before
+      * to compute the Schur decomposition of a matrix, and \p computeU was set
+      * to true (the default value).
+      *
+      * \sa RealSchur(const MatrixType&, bool) for an example
+      */
+    const MatrixType& matrixU() const
+    {
+      eigen_assert(m_isInitialized && "RealSchur is not initialized.");
+      eigen_assert(m_matUisUptodate && "The matrix U has not been computed during the RealSchur decomposition.");
+      return m_matU;
+    }
+
+    /** \brief Returns the quasi-triangular matrix in the Schur decomposition. 
+      *
+      * \returns A const reference to the matrix T.
+      *
+      * \pre Either the constructor RealSchur(const MatrixType&, bool) or the
+      * member function compute(const MatrixType&, bool) has been called before
+      * to compute the Schur decomposition of a matrix.
+      *
+      * \sa RealSchur(const MatrixType&, bool) for an example
+      */
+    const MatrixType& matrixT() const
+    {
+      eigen_assert(m_isInitialized && "RealSchur is not initialized.");
+      return m_matT;
+    }
+  
+    /** \brief Computes Schur decomposition of given matrix. 
+      * 
+      * \param[in]  matrix    Square matrix whose Schur decomposition is to be computed.
+      * \param[in]  computeU  If true, both T and U are computed; if false, only T is computed.
+      * \returns    Reference to \c *this
+      *
+      * The Schur decomposition is computed by first reducing the matrix to
+      * Hessenberg form using the class HessenbergDecomposition. The Hessenberg
+      * matrix is then reduced to triangular form by performing Francis QR
+      * iterations with implicit double shift. The cost of computing the Schur
+      * decomposition depends on the number of iterations; as a rough guide, it
+      * may be taken to be \f$25n^3\f$ flops if \a computeU is true and
+      * \f$10n^3\f$ flops if \a computeU is false.
+      *
+      * Example: \include RealSchur_compute.cpp
+      * Output: \verbinclude RealSchur_compute.out
+      *
+      * \sa compute(const MatrixType&, bool, Index)
+      */
+    template<typename InputType>
+    RealSchur& compute(const EigenBase<InputType>& matrix, bool computeU = true);
+
+    /** \brief Computes Schur decomposition of a Hessenberg matrix H = Z T Z^T
+     *  \param[in] matrixH Matrix in Hessenberg form H
+     *  \param[in] matrixQ orthogonal matrix Q that transform a matrix A to H : A = Q H Q^T
+     *  \param computeU Computes the matriX U of the Schur vectors
+     * \return Reference to \c *this
+     * 
+     *  This routine assumes that the matrix is already reduced in Hessenberg form matrixH
+     *  using either the class HessenbergDecomposition or another mean. 
+     *  It computes the upper quasi-triangular matrix T of the Schur decomposition of H
+     *  When computeU is true, this routine computes the matrix U such that 
+     *  A = U T U^T =  (QZ) T (QZ)^T = Q H Q^T where A is the initial matrix
+     * 
+     * NOTE Q is referenced if computeU is true; so, if the initial orthogonal matrix
+     * is not available, the user should give an identity matrix (Q.setIdentity())
+     * 
+     * \sa compute(const MatrixType&, bool)
+     */
+    template<typename HessMatrixType, typename OrthMatrixType>
+    RealSchur& computeFromHessenberg(const HessMatrixType& matrixH, const OrthMatrixType& matrixQ,  bool computeU);
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was succesful, \c NoConvergence otherwise.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "RealSchur is not initialized.");
+      return m_info;
+    }
+
+    /** \brief Sets the maximum number of iterations allowed. 
+      *
+      * If not specified by the user, the maximum number of iterations is m_maxIterationsPerRow times the size
+      * of the matrix.
+      */
+    RealSchur& setMaxIterations(Index maxIters)
+    {
+      m_maxIters = maxIters;
+      return *this;
+    }
+
+    /** \brief Returns the maximum number of iterations. */
+    Index getMaxIterations()
+    {
+      return m_maxIters;
+    }
+
+    /** \brief Maximum number of iterations per row.
+      *
+      * If not otherwise specified, the maximum number of iterations is this number times the size of the
+      * matrix. It is currently set to 40.
+      */
+    static const int m_maxIterationsPerRow = 40;
+
+  private:
+    
+    MatrixType m_matT;
+    MatrixType m_matU;
+    ColumnVectorType m_workspaceVector;
+    HessenbergDecomposition<MatrixType> m_hess;
+    ComputationInfo m_info;
+    bool m_isInitialized;
+    bool m_matUisUptodate;
+    Index m_maxIters;
+
+    typedef Matrix<Scalar,3,1> Vector3s;
+
+    Scalar computeNormOfT();
+    Index findSmallSubdiagEntry(Index iu);
+    void splitOffTwoRows(Index iu, bool computeU, const Scalar& exshift);
+    void computeShift(Index iu, Index iter, Scalar& exshift, Vector3s& shiftInfo);
+    void initFrancisQRStep(Index il, Index iu, const Vector3s& shiftInfo, Index& im, Vector3s& firstHouseholderVector);
+    void performFrancisQRStep(Index il, Index im, Index iu, bool computeU, const Vector3s& firstHouseholderVector, Scalar* workspace);
+};
+
+
+template<typename MatrixType>
+template<typename InputType>
+RealSchur<MatrixType>& RealSchur<MatrixType>::compute(const EigenBase<InputType>& matrix, bool computeU)
+{
+  const Scalar considerAsZero = (std::numeric_limits<Scalar>::min)();
+
+  eigen_assert(matrix.cols() == matrix.rows());
+  Index maxIters = m_maxIters;
+  if (maxIters == -1)
+    maxIters = m_maxIterationsPerRow * matrix.rows();
+
+  Scalar scale = matrix.derived().cwiseAbs().maxCoeff();
+  if(scale<considerAsZero)
+  {
+    m_matT.setZero(matrix.rows(),matrix.cols());
+    if(computeU)
+      m_matU.setIdentity(matrix.rows(),matrix.cols());
+    m_info = Success;
+    m_isInitialized = true;
+    m_matUisUptodate = computeU;
+    return *this;
+  }
+
+  // Step 1. Reduce to Hessenberg form
+  m_hess.compute(matrix.derived()/scale);
+
+  // Step 2. Reduce to real Schur form  
+  computeFromHessenberg(m_hess.matrixH(), m_hess.matrixQ(), computeU);
+
+  m_matT *= scale;
+  
+  return *this;
+}
+template<typename MatrixType>
+template<typename HessMatrixType, typename OrthMatrixType>
+RealSchur<MatrixType>& RealSchur<MatrixType>::computeFromHessenberg(const HessMatrixType& matrixH, const OrthMatrixType& matrixQ,  bool computeU)
+{
+  using std::abs;
+
+  m_matT = matrixH;
+  if(computeU)
+    m_matU = matrixQ;
+  
+  Index maxIters = m_maxIters;
+  if (maxIters == -1)
+    maxIters = m_maxIterationsPerRow * matrixH.rows();
+  m_workspaceVector.resize(m_matT.cols());
+  Scalar* workspace = &m_workspaceVector.coeffRef(0);
+
+  // The matrix m_matT is divided in three parts. 
+  // Rows 0,...,il-1 are decoupled from the rest because m_matT(il,il-1) is zero. 
+  // Rows il,...,iu is the part we are working on (the active window).
+  // Rows iu+1,...,end are already brought in triangular form.
+  Index iu = m_matT.cols() - 1;
+  Index iter = 0;      // iteration count for current eigenvalue
+  Index totalIter = 0; // iteration count for whole matrix
+  Scalar exshift(0);   // sum of exceptional shifts
+  Scalar norm = computeNormOfT();
+
+  if(norm!=0)
+  {
+    while (iu >= 0)
+    {
+      Index il = findSmallSubdiagEntry(iu);
+
+      // Check for convergence
+      if (il == iu) // One root found
+      {
+        m_matT.coeffRef(iu,iu) = m_matT.coeff(iu,iu) + exshift;
+        if (iu > 0)
+          m_matT.coeffRef(iu, iu-1) = Scalar(0);
+        iu--;
+        iter = 0;
+      }
+      else if (il == iu-1) // Two roots found
+      {
+        splitOffTwoRows(iu, computeU, exshift);
+        iu -= 2;
+        iter = 0;
+      }
+      else // No convergence yet
+      {
+        // The firstHouseholderVector vector has to be initialized to something to get rid of a silly GCC warning (-O1 -Wall -DNDEBUG )
+        Vector3s firstHouseholderVector(0,0,0), shiftInfo;
+        computeShift(iu, iter, exshift, shiftInfo);
+        iter = iter + 1;
+        totalIter = totalIter + 1;
+        if (totalIter > maxIters) break;
+        Index im;
+        initFrancisQRStep(il, iu, shiftInfo, im, firstHouseholderVector);
+        performFrancisQRStep(il, im, iu, computeU, firstHouseholderVector, workspace);
+      }
+    }
+  }
+  if(totalIter <= maxIters)
+    m_info = Success;
+  else
+    m_info = NoConvergence;
+
+  m_isInitialized = true;
+  m_matUisUptodate = computeU;
+  return *this;
+}
+
+/** \internal Computes and returns vector L1 norm of T */
+template<typename MatrixType>
+inline typename MatrixType::Scalar RealSchur<MatrixType>::computeNormOfT()
+{
+  const Index size = m_matT.cols();
+  // FIXME to be efficient the following would requires a triangular reduxion code
+  // Scalar norm = m_matT.upper().cwiseAbs().sum() 
+  //               + m_matT.bottomLeftCorner(size-1,size-1).diagonal().cwiseAbs().sum();
+  Scalar norm(0);
+  for (Index j = 0; j < size; ++j)
+    norm += m_matT.col(j).segment(0, (std::min)(size,j+2)).cwiseAbs().sum();
+  return norm;
+}
+
+/** \internal Look for single small sub-diagonal element and returns its index */
+template<typename MatrixType>
+inline Index RealSchur<MatrixType>::findSmallSubdiagEntry(Index iu)
+{
+  using std::abs;
+  Index res = iu;
+  while (res > 0)
+  {
+    Scalar s = abs(m_matT.coeff(res-1,res-1)) + abs(m_matT.coeff(res,res));
+    if (abs(m_matT.coeff(res,res-1)) <= NumTraits<Scalar>::epsilon() * s)
+      break;
+    res--;
+  }
+  return res;
+}
+
+/** \internal Update T given that rows iu-1 and iu decouple from the rest. */
+template<typename MatrixType>
+inline void RealSchur<MatrixType>::splitOffTwoRows(Index iu, bool computeU, const Scalar& exshift)
+{
+  using std::sqrt;
+  using std::abs;
+  const Index size = m_matT.cols();
+
+  // The eigenvalues of the 2x2 matrix [a b; c d] are 
+  // trace +/- sqrt(discr/4) where discr = tr^2 - 4*det, tr = a + d, det = ad - bc
+  Scalar p = Scalar(0.5) * (m_matT.coeff(iu-1,iu-1) - m_matT.coeff(iu,iu));
+  Scalar q = p * p + m_matT.coeff(iu,iu-1) * m_matT.coeff(iu-1,iu);   // q = tr^2 / 4 - det = discr/4
+  m_matT.coeffRef(iu,iu) += exshift;
+  m_matT.coeffRef(iu-1,iu-1) += exshift;
+
+  if (q >= Scalar(0)) // Two real eigenvalues
+  {
+    Scalar z = sqrt(abs(q));
+    JacobiRotation<Scalar> rot;
+    if (p >= Scalar(0))
+      rot.makeGivens(p + z, m_matT.coeff(iu, iu-1));
+    else
+      rot.makeGivens(p - z, m_matT.coeff(iu, iu-1));
+
+    m_matT.rightCols(size-iu+1).applyOnTheLeft(iu-1, iu, rot.adjoint());
+    m_matT.topRows(iu+1).applyOnTheRight(iu-1, iu, rot);
+    m_matT.coeffRef(iu, iu-1) = Scalar(0); 
+    if (computeU)
+      m_matU.applyOnTheRight(iu-1, iu, rot);
+  }
+
+  if (iu > 1) 
+    m_matT.coeffRef(iu-1, iu-2) = Scalar(0);
+}
+
+/** \internal Form shift in shiftInfo, and update exshift if an exceptional shift is performed. */
+template<typename MatrixType>
+inline void RealSchur<MatrixType>::computeShift(Index iu, Index iter, Scalar& exshift, Vector3s& shiftInfo)
+{
+  using std::sqrt;
+  using std::abs;
+  shiftInfo.coeffRef(0) = m_matT.coeff(iu,iu);
+  shiftInfo.coeffRef(1) = m_matT.coeff(iu-1,iu-1);
+  shiftInfo.coeffRef(2) = m_matT.coeff(iu,iu-1) * m_matT.coeff(iu-1,iu);
+
+  // Wilkinson's original ad hoc shift
+  if (iter == 10)
+  {
+    exshift += shiftInfo.coeff(0);
+    for (Index i = 0; i <= iu; ++i)
+      m_matT.coeffRef(i,i) -= shiftInfo.coeff(0);
+    Scalar s = abs(m_matT.coeff(iu,iu-1)) + abs(m_matT.coeff(iu-1,iu-2));
+    shiftInfo.coeffRef(0) = Scalar(0.75) * s;
+    shiftInfo.coeffRef(1) = Scalar(0.75) * s;
+    shiftInfo.coeffRef(2) = Scalar(-0.4375) * s * s;
+  }
+
+  // MATLAB's new ad hoc shift
+  if (iter == 30)
+  {
+    Scalar s = (shiftInfo.coeff(1) - shiftInfo.coeff(0)) / Scalar(2.0);
+    s = s * s + shiftInfo.coeff(2);
+    if (s > Scalar(0))
+    {
+      s = sqrt(s);
+      if (shiftInfo.coeff(1) < shiftInfo.coeff(0))
+        s = -s;
+      s = s + (shiftInfo.coeff(1) - shiftInfo.coeff(0)) / Scalar(2.0);
+      s = shiftInfo.coeff(0) - shiftInfo.coeff(2) / s;
+      exshift += s;
+      for (Index i = 0; i <= iu; ++i)
+        m_matT.coeffRef(i,i) -= s;
+      shiftInfo.setConstant(Scalar(0.964));
+    }
+  }
+}
+
+/** \internal Compute index im at which Francis QR step starts and the first Householder vector. */
+template<typename MatrixType>
+inline void RealSchur<MatrixType>::initFrancisQRStep(Index il, Index iu, const Vector3s& shiftInfo, Index& im, Vector3s& firstHouseholderVector)
+{
+  using std::abs;
+  Vector3s& v = firstHouseholderVector; // alias to save typing
+
+  for (im = iu-2; im >= il; --im)
+  {
+    const Scalar Tmm = m_matT.coeff(im,im);
+    const Scalar r = shiftInfo.coeff(0) - Tmm;
+    const Scalar s = shiftInfo.coeff(1) - Tmm;
+    v.coeffRef(0) = (r * s - shiftInfo.coeff(2)) / m_matT.coeff(im+1,im) + m_matT.coeff(im,im+1);
+    v.coeffRef(1) = m_matT.coeff(im+1,im+1) - Tmm - r - s;
+    v.coeffRef(2) = m_matT.coeff(im+2,im+1);
+    if (im == il) {
+      break;
+    }
+    const Scalar lhs = m_matT.coeff(im,im-1) * (abs(v.coeff(1)) + abs(v.coeff(2)));
+    const Scalar rhs = v.coeff(0) * (abs(m_matT.coeff(im-1,im-1)) + abs(Tmm) + abs(m_matT.coeff(im+1,im+1)));
+    if (abs(lhs) < NumTraits<Scalar>::epsilon() * rhs)
+      break;
+  }
+}
+
+/** \internal Perform a Francis QR step involving rows il:iu and columns im:iu. */
+template<typename MatrixType>
+inline void RealSchur<MatrixType>::performFrancisQRStep(Index il, Index im, Index iu, bool computeU, const Vector3s& firstHouseholderVector, Scalar* workspace)
+{
+  eigen_assert(im >= il);
+  eigen_assert(im <= iu-2);
+
+  const Index size = m_matT.cols();
+
+  for (Index k = im; k <= iu-2; ++k)
+  {
+    bool firstIteration = (k == im);
+
+    Vector3s v;
+    if (firstIteration)
+      v = firstHouseholderVector;
+    else
+      v = m_matT.template block<3,1>(k,k-1);
+
+    Scalar tau, beta;
+    Matrix<Scalar, 2, 1> ess;
+    v.makeHouseholder(ess, tau, beta);
+    
+    if (beta != Scalar(0)) // if v is not zero
+    {
+      if (firstIteration && k > il)
+        m_matT.coeffRef(k,k-1) = -m_matT.coeff(k,k-1);
+      else if (!firstIteration)
+        m_matT.coeffRef(k,k-1) = beta;
+
+      // These Householder transformations form the O(n^3) part of the algorithm
+      m_matT.block(k, k, 3, size-k).applyHouseholderOnTheLeft(ess, tau, workspace);
+      m_matT.block(0, k, (std::min)(iu,k+3) + 1, 3).applyHouseholderOnTheRight(ess, tau, workspace);
+      if (computeU)
+        m_matU.block(0, k, size, 3).applyHouseholderOnTheRight(ess, tau, workspace);
+    }
+  }
+
+  Matrix<Scalar, 2, 1> v = m_matT.template block<2,1>(iu-1, iu-2);
+  Scalar tau, beta;
+  Matrix<Scalar, 1, 1> ess;
+  v.makeHouseholder(ess, tau, beta);
+
+  if (beta != Scalar(0)) // if v is not zero
+  {
+    m_matT.coeffRef(iu-1, iu-2) = beta;
+    m_matT.block(iu-1, iu-1, 2, size-iu+1).applyHouseholderOnTheLeft(ess, tau, workspace);
+    m_matT.block(0, iu-1, iu+1, 2).applyHouseholderOnTheRight(ess, tau, workspace);
+    if (computeU)
+      m_matU.block(0, iu-1, size, 2).applyHouseholderOnTheRight(ess, tau, workspace);
+  }
+
+  // clean up pollution due to round-off errors
+  for (Index i = im+2; i <= iu; ++i)
+  {
+    m_matT.coeffRef(i,i-2) = Scalar(0);
+    if (i > im+2)
+      m_matT.coeffRef(i,i-3) = Scalar(0);
+  }
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_REAL_SCHUR_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
new file mode 100644
index 00000000..2c225171
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
@@ -0,0 +1,77 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to LAPACKe
+ *    Real Schur needed to real unsymmetrical eigenvalues/eigenvectors.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_REAL_SCHUR_LAPACKE_H
+#define EIGEN_REAL_SCHUR_LAPACKE_H
+
+namespace Eigen { 
+
+/** \internal Specialization for the data types supported by LAPACKe */
+
+#define EIGEN_LAPACKE_SCHUR_REAL(EIGTYPE, LAPACKE_TYPE, LAPACKE_PREFIX, LAPACKE_PREFIX_U, EIGCOLROW, LAPACKE_COLROW) \
+template<> template<typename InputType> inline \
+RealSchur<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW> >& \
+RealSchur<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW> >::compute(const EigenBase<InputType>& matrix, bool computeU) \
+{ \
+  eigen_assert(matrix.cols() == matrix.rows()); \
+\
+  lapack_int n = internal::convert_index<lapack_int>(matrix.cols()), sdim, info; \
+  lapack_int matrix_order = LAPACKE_COLROW; \
+  char jobvs, sort='N'; \
+  LAPACK_##LAPACKE_PREFIX_U##_SELECT2 select = 0; \
+  jobvs = (computeU) ? 'V' : 'N'; \
+  m_matU.resize(n, n); \
+  lapack_int ldvs  = internal::convert_index<lapack_int>(m_matU.outerStride()); \
+  m_matT = matrix; \
+  lapack_int lda = internal::convert_index<lapack_int>(m_matT.outerStride()); \
+  Matrix<EIGTYPE, Dynamic, Dynamic> wr, wi; \
+  wr.resize(n, 1); wi.resize(n, 1); \
+  info = LAPACKE_##LAPACKE_PREFIX##gees( matrix_order, jobvs, sort, select, n, (LAPACKE_TYPE*)m_matT.data(), lda, &sdim, (LAPACKE_TYPE*)wr.data(), (LAPACKE_TYPE*)wi.data(), (LAPACKE_TYPE*)m_matU.data(), ldvs ); \
+  if(info == 0) \
+    m_info = Success; \
+  else \
+    m_info = NoConvergence; \
+\
+  m_isInitialized = true; \
+  m_matUisUptodate = computeU; \
+  return *this; \
+\
+}
+
+EIGEN_LAPACKE_SCHUR_REAL(double,   double, d, D, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_SCHUR_REAL(float,    float,  s, S, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_SCHUR_REAL(double,   double, d, D, RowMajor, LAPACK_ROW_MAJOR)
+EIGEN_LAPACKE_SCHUR_REAL(float,    float,  s, S, RowMajor, LAPACK_ROW_MAJOR)
+
+} // end namespace Eigen
+
+#endif // EIGEN_REAL_SCHUR_LAPACKE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
new file mode 100644
index 00000000..9ddd553f
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
@@ -0,0 +1,870 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SELFADJOINTEIGENSOLVER_H
+#define EIGEN_SELFADJOINTEIGENSOLVER_H
+
+#include "./Tridiagonalization.h"
+
+namespace Eigen { 
+
+template<typename _MatrixType>
+class GeneralizedSelfAdjointEigenSolver;
+
+namespace internal {
+template<typename SolverType,int Size,bool IsComplex> struct direct_selfadjoint_eigenvalues;
+template<typename MatrixType, typename DiagType, typename SubDiagType>
+ComputationInfo computeFromTridiagonal_impl(DiagType& diag, SubDiagType& subdiag, const Index maxIterations, bool computeEigenvectors, MatrixType& eivec);
+}
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  *
+  * \class SelfAdjointEigenSolver
+  *
+  * \brief Computes eigenvalues and eigenvectors of selfadjoint matrices
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the
+  * eigendecomposition; this is expected to be an instantiation of the Matrix
+  * class template.
+  *
+  * A matrix \f$ A \f$ is selfadjoint if it equals its adjoint. For real
+  * matrices, this means that the matrix is symmetric: it equals its
+  * transpose. This class computes the eigenvalues and eigenvectors of a
+  * selfadjoint matrix. These are the scalars \f$ \lambda \f$ and vectors
+  * \f$ v \f$ such that \f$ Av = \lambda v \f$.  The eigenvalues of a
+  * selfadjoint matrix are always real. If \f$ D \f$ is a diagonal matrix with
+  * the eigenvalues on the diagonal, and \f$ V \f$ is a matrix with the
+  * eigenvectors as its columns, then \f$ A = V D V^{-1} \f$ (for selfadjoint
+  * matrices, the matrix \f$ V \f$ is always invertible). This is called the
+  * eigendecomposition.
+  *
+  * The algorithm exploits the fact that the matrix is selfadjoint, making it
+  * faster and more accurate than the general purpose eigenvalue algorithms
+  * implemented in EigenSolver and ComplexEigenSolver.
+  *
+  * Only the \b lower \b triangular \b part of the input matrix is referenced.
+  *
+  * Call the function compute() to compute the eigenvalues and eigenvectors of
+  * a given matrix. Alternatively, you can use the
+  * SelfAdjointEigenSolver(const MatrixType&, int) constructor which computes
+  * the eigenvalues and eigenvectors at construction time. Once the eigenvalue
+  * and eigenvectors are computed, they can be retrieved with the eigenvalues()
+  * and eigenvectors() functions.
+  *
+  * The documentation for SelfAdjointEigenSolver(const MatrixType&, int)
+  * contains an example of the typical use of this class.
+  *
+  * To solve the \em generalized eigenvalue problem \f$ Av = \lambda Bv \f$ and
+  * the likes, see the class GeneralizedSelfAdjointEigenSolver.
+  *
+  * \sa MatrixBase::eigenvalues(), class EigenSolver, class ComplexEigenSolver
+  */
+template<typename _MatrixType> class SelfAdjointEigenSolver
+{
+  public:
+
+    typedef _MatrixType MatrixType;
+    enum {
+      Size = MatrixType::RowsAtCompileTime,
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      Options = MatrixType::Options,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    
+    /** \brief Scalar type for matrices of type \p _MatrixType. */
+    typedef typename MatrixType::Scalar Scalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+    
+    typedef Matrix<Scalar,Size,Size,ColMajor,MaxColsAtCompileTime,MaxColsAtCompileTime> EigenvectorsType;
+
+    /** \brief Real scalar type for \p _MatrixType.
+      *
+      * This is just \c Scalar if #Scalar is real (e.g., \c float or
+      * \c double), and the type of the real part of \c Scalar if #Scalar is
+      * complex.
+      */
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    
+    friend struct internal::direct_selfadjoint_eigenvalues<SelfAdjointEigenSolver,Size,NumTraits<Scalar>::IsComplex>;
+
+    /** \brief Type for vector of eigenvalues as returned by eigenvalues().
+      *
+      * This is a column vector with entries of type #RealScalar.
+      * The length of the vector is the size of \p _MatrixType.
+      */
+    typedef typename internal::plain_col_type<MatrixType, RealScalar>::type RealVectorType;
+    typedef Tridiagonalization<MatrixType> TridiagonalizationType;
+    typedef typename TridiagonalizationType::SubDiagonalType SubDiagonalType;
+
+    /** \brief Default constructor for fixed-size matrices.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via compute(). This constructor
+      * can only be used if \p _MatrixType is a fixed-size matrix; use
+      * SelfAdjointEigenSolver(Index) for dynamic-size matrices.
+      *
+      * Example: \include SelfAdjointEigenSolver_SelfAdjointEigenSolver.cpp
+      * Output: \verbinclude SelfAdjointEigenSolver_SelfAdjointEigenSolver.out
+      */
+    EIGEN_DEVICE_FUNC
+    SelfAdjointEigenSolver()
+        : m_eivec(),
+          m_eivalues(),
+          m_subdiag(),
+          m_isInitialized(false)
+    { }
+
+    /** \brief Constructor, pre-allocates memory for dynamic-size matrices.
+      *
+      * \param [in]  size  Positive integer, size of the matrix whose
+      * eigenvalues and eigenvectors will be computed.
+      *
+      * This constructor is useful for dynamic-size matrices, when the user
+      * intends to perform decompositions via compute(). The \p size
+      * parameter is only used as a hint. It is not an error to give a wrong
+      * \p size, but it may impair performance.
+      *
+      * \sa compute() for an example
+      */
+    EIGEN_DEVICE_FUNC
+    explicit SelfAdjointEigenSolver(Index size)
+        : m_eivec(size, size),
+          m_eivalues(size),
+          m_subdiag(size > 1 ? size - 1 : 1),
+          m_isInitialized(false)
+    {}
+
+    /** \brief Constructor; computes eigendecomposition of given matrix.
+      *
+      * \param[in]  matrix  Selfadjoint matrix whose eigendecomposition is to
+      *    be computed. Only the lower triangular part of the matrix is referenced.
+      * \param[in]  options Can be #ComputeEigenvectors (default) or #EigenvaluesOnly.
+      *
+      * This constructor calls compute(const MatrixType&, int) to compute the
+      * eigenvalues of the matrix \p matrix. The eigenvectors are computed if
+      * \p options equals #ComputeEigenvectors.
+      *
+      * Example: \include SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType.cpp
+      * Output: \verbinclude SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType.out
+      *
+      * \sa compute(const MatrixType&, int)
+      */
+    template<typename InputType>
+    EIGEN_DEVICE_FUNC
+    explicit SelfAdjointEigenSolver(const EigenBase<InputType>& matrix, int options = ComputeEigenvectors)
+      : m_eivec(matrix.rows(), matrix.cols()),
+        m_eivalues(matrix.cols()),
+        m_subdiag(matrix.rows() > 1 ? matrix.rows() - 1 : 1),
+        m_isInitialized(false)
+    {
+      compute(matrix.derived(), options);
+    }
+
+    /** \brief Computes eigendecomposition of given matrix.
+      *
+      * \param[in]  matrix  Selfadjoint matrix whose eigendecomposition is to
+      *    be computed. Only the lower triangular part of the matrix is referenced.
+      * \param[in]  options Can be #ComputeEigenvectors (default) or #EigenvaluesOnly.
+      * \returns    Reference to \c *this
+      *
+      * This function computes the eigenvalues of \p matrix.  The eigenvalues()
+      * function can be used to retrieve them.  If \p options equals #ComputeEigenvectors,
+      * then the eigenvectors are also computed and can be retrieved by
+      * calling eigenvectors().
+      *
+      * This implementation uses a symmetric QR algorithm. The matrix is first
+      * reduced to tridiagonal form using the Tridiagonalization class. The
+      * tridiagonal matrix is then brought to diagonal form with implicit
+      * symmetric QR steps with Wilkinson shift. Details can be found in
+      * Section 8.3 of Golub \& Van Loan, <i>%Matrix Computations</i>.
+      *
+      * The cost of the computation is about \f$ 9n^3 \f$ if the eigenvectors
+      * are required and \f$ 4n^3/3 \f$ if they are not required.
+      *
+      * This method reuses the memory in the SelfAdjointEigenSolver object that
+      * was allocated when the object was constructed, if the size of the
+      * matrix does not change.
+      *
+      * Example: \include SelfAdjointEigenSolver_compute_MatrixType.cpp
+      * Output: \verbinclude SelfAdjointEigenSolver_compute_MatrixType.out
+      *
+      * \sa SelfAdjointEigenSolver(const MatrixType&, int)
+      */
+    template<typename InputType>
+    EIGEN_DEVICE_FUNC
+    SelfAdjointEigenSolver& compute(const EigenBase<InputType>& matrix, int options = ComputeEigenvectors);
+    
+    /** \brief Computes eigendecomposition of given matrix using a closed-form algorithm
+      *
+      * This is a variant of compute(const MatrixType&, int options) which
+      * directly solves the underlying polynomial equation.
+      * 
+      * Currently only 2x2 and 3x3 matrices for which the sizes are known at compile time are supported (e.g., Matrix3d).
+      * 
+      * This method is usually significantly faster than the QR iterative algorithm
+      * but it might also be less accurate. It is also worth noting that
+      * for 3x3 matrices it involves trigonometric operations which are
+      * not necessarily available for all scalar types.
+      * 
+      * For the 3x3 case, we observed the following worst case relative error regarding the eigenvalues:
+      *   - double: 1e-8
+      *   - float:  1e-3
+      *
+      * \sa compute(const MatrixType&, int options)
+      */
+    EIGEN_DEVICE_FUNC
+    SelfAdjointEigenSolver& computeDirect(const MatrixType& matrix, int options = ComputeEigenvectors);
+
+    /**
+      *\brief Computes the eigen decomposition from a tridiagonal symmetric matrix
+      *
+      * \param[in] diag The vector containing the diagonal of the matrix.
+      * \param[in] subdiag The subdiagonal of the matrix.
+      * \param[in] options Can be #ComputeEigenvectors (default) or #EigenvaluesOnly.
+      * \returns Reference to \c *this
+      *
+      * This function assumes that the matrix has been reduced to tridiagonal form.
+      *
+      * \sa compute(const MatrixType&, int) for more information
+      */
+    SelfAdjointEigenSolver& computeFromTridiagonal(const RealVectorType& diag, const SubDiagonalType& subdiag , int options=ComputeEigenvectors);
+
+    /** \brief Returns the eigenvectors of given matrix.
+      *
+      * \returns  A const reference to the matrix whose columns are the eigenvectors.
+      *
+      * \pre The eigenvectors have been computed before.
+      *
+      * Column \f$ k \f$ of the returned matrix is an eigenvector corresponding
+      * to eigenvalue number \f$ k \f$ as returned by eigenvalues().  The
+      * eigenvectors are normalized to have (Euclidean) norm equal to one. If
+      * this object was used to solve the eigenproblem for the selfadjoint
+      * matrix \f$ A \f$, then the matrix returned by this function is the
+      * matrix \f$ V \f$ in the eigendecomposition \f$ A = V D V^{-1} \f$.
+      *
+      * Example: \include SelfAdjointEigenSolver_eigenvectors.cpp
+      * Output: \verbinclude SelfAdjointEigenSolver_eigenvectors.out
+      *
+      * \sa eigenvalues()
+      */
+    EIGEN_DEVICE_FUNC
+    const EigenvectorsType& eigenvectors() const
+    {
+      eigen_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized.");
+      eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
+      return m_eivec;
+    }
+
+    /** \brief Returns the eigenvalues of given matrix.
+      *
+      * \returns A const reference to the column vector containing the eigenvalues.
+      *
+      * \pre The eigenvalues have been computed before.
+      *
+      * The eigenvalues are repeated according to their algebraic multiplicity,
+      * so there are as many eigenvalues as rows in the matrix. The eigenvalues
+      * are sorted in increasing order.
+      *
+      * Example: \include SelfAdjointEigenSolver_eigenvalues.cpp
+      * Output: \verbinclude SelfAdjointEigenSolver_eigenvalues.out
+      *
+      * \sa eigenvectors(), MatrixBase::eigenvalues()
+      */
+    EIGEN_DEVICE_FUNC
+    const RealVectorType& eigenvalues() const
+    {
+      eigen_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized.");
+      return m_eivalues;
+    }
+
+    /** \brief Computes the positive-definite square root of the matrix.
+      *
+      * \returns the positive-definite square root of the matrix
+      *
+      * \pre The eigenvalues and eigenvectors of a positive-definite matrix
+      * have been computed before.
+      *
+      * The square root of a positive-definite matrix \f$ A \f$ is the
+      * positive-definite matrix whose square equals \f$ A \f$. This function
+      * uses the eigendecomposition \f$ A = V D V^{-1} \f$ to compute the
+      * square root as \f$ A^{1/2} = V D^{1/2} V^{-1} \f$.
+      *
+      * Example: \include SelfAdjointEigenSolver_operatorSqrt.cpp
+      * Output: \verbinclude SelfAdjointEigenSolver_operatorSqrt.out
+      *
+      * \sa operatorInverseSqrt(), <a href="unsupported/group__MatrixFunctions__Module.html">MatrixFunctions Module</a>
+      */
+    EIGEN_DEVICE_FUNC
+    MatrixType operatorSqrt() const
+    {
+      eigen_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized.");
+      eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
+      return m_eivec * m_eivalues.cwiseSqrt().asDiagonal() * m_eivec.adjoint();
+    }
+
+    /** \brief Computes the inverse square root of the matrix.
+      *
+      * \returns the inverse positive-definite square root of the matrix
+      *
+      * \pre The eigenvalues and eigenvectors of a positive-definite matrix
+      * have been computed before.
+      *
+      * This function uses the eigendecomposition \f$ A = V D V^{-1} \f$ to
+      * compute the inverse square root as \f$ V D^{-1/2} V^{-1} \f$. This is
+      * cheaper than first computing the square root with operatorSqrt() and
+      * then its inverse with MatrixBase::inverse().
+      *
+      * Example: \include SelfAdjointEigenSolver_operatorInverseSqrt.cpp
+      * Output: \verbinclude SelfAdjointEigenSolver_operatorInverseSqrt.out
+      *
+      * \sa operatorSqrt(), MatrixBase::inverse(), <a href="unsupported/group__MatrixFunctions__Module.html">MatrixFunctions Module</a>
+      */
+    EIGEN_DEVICE_FUNC
+    MatrixType operatorInverseSqrt() const
+    {
+      eigen_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized.");
+      eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
+      return m_eivec * m_eivalues.cwiseInverse().cwiseSqrt().asDiagonal() * m_eivec.adjoint();
+    }
+
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was succesful, \c NoConvergence otherwise.
+      */
+    EIGEN_DEVICE_FUNC
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized.");
+      return m_info;
+    }
+
+    /** \brief Maximum number of iterations.
+      *
+      * The algorithm terminates if it does not converge within m_maxIterations * n iterations, where n
+      * denotes the size of the matrix. This value is currently set to 30 (copied from LAPACK).
+      */
+    static const int m_maxIterations = 30;
+
+  protected:
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+    }
+    
+    EigenvectorsType m_eivec;
+    RealVectorType m_eivalues;
+    typename TridiagonalizationType::SubDiagonalType m_subdiag;
+    ComputationInfo m_info;
+    bool m_isInitialized;
+    bool m_eigenvectorsOk;
+};
+
+namespace internal {
+/** \internal
+  *
+  * \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  * Performs a QR step on a tridiagonal symmetric matrix represented as a
+  * pair of two vectors \a diag and \a subdiag.
+  *
+  * \param diag the diagonal part of the input selfadjoint tridiagonal matrix
+  * \param subdiag the sub-diagonal part of the input selfadjoint tridiagonal matrix
+  * \param start starting index of the submatrix to work on
+  * \param end last+1 index of the submatrix to work on
+  * \param matrixQ pointer to the column-major matrix holding the eigenvectors, can be 0
+  * \param n size of the input matrix
+  *
+  * For compilation efficiency reasons, this procedure does not use eigen expression
+  * for its arguments.
+  *
+  * Implemented from Golub's "Matrix Computations", algorithm 8.3.2:
+  * "implicit symmetric QR step with Wilkinson shift"
+  */
+template<int StorageOrder,typename RealScalar, typename Scalar, typename Index>
+EIGEN_DEVICE_FUNC
+static void tridiagonal_qr_step(RealScalar* diag, RealScalar* subdiag, Index start, Index end, Scalar* matrixQ, Index n);
+}
+
+template<typename MatrixType>
+template<typename InputType>
+EIGEN_DEVICE_FUNC
+SelfAdjointEigenSolver<MatrixType>& SelfAdjointEigenSolver<MatrixType>
+::compute(const EigenBase<InputType>& a_matrix, int options)
+{
+  check_template_parameters();
+  
+  const InputType &matrix(a_matrix.derived());
+  
+  using std::abs;
+  eigen_assert(matrix.cols() == matrix.rows());
+  eigen_assert((options&~(EigVecMask|GenEigMask))==0
+          && (options&EigVecMask)!=EigVecMask
+          && "invalid option parameter");
+  bool computeEigenvectors = (options&ComputeEigenvectors)==ComputeEigenvectors;
+  Index n = matrix.cols();
+  m_eivalues.resize(n,1);
+
+  if(n==1)
+  {
+    m_eivec = matrix;
+    m_eivalues.coeffRef(0,0) = numext::real(m_eivec.coeff(0,0));
+    if(computeEigenvectors)
+      m_eivec.setOnes(n,n);
+    m_info = Success;
+    m_isInitialized = true;
+    m_eigenvectorsOk = computeEigenvectors;
+    return *this;
+  }
+
+  // declare some aliases
+  RealVectorType& diag = m_eivalues;
+  EigenvectorsType& mat = m_eivec;
+
+  // map the matrix coefficients to [-1:1] to avoid over- and underflow.
+  mat = matrix.template triangularView<Lower>();
+  RealScalar scale = mat.cwiseAbs().maxCoeff();
+  if(scale==RealScalar(0)) scale = RealScalar(1);
+  mat.template triangularView<Lower>() /= scale;
+  m_subdiag.resize(n-1);
+  internal::tridiagonalization_inplace(mat, diag, m_subdiag, computeEigenvectors);
+
+  m_info = internal::computeFromTridiagonal_impl(diag, m_subdiag, m_maxIterations, computeEigenvectors, m_eivec);
+  
+  // scale back the eigen values
+  m_eivalues *= scale;
+
+  m_isInitialized = true;
+  m_eigenvectorsOk = computeEigenvectors;
+  return *this;
+}
+
+template<typename MatrixType>
+SelfAdjointEigenSolver<MatrixType>& SelfAdjointEigenSolver<MatrixType>
+::computeFromTridiagonal(const RealVectorType& diag, const SubDiagonalType& subdiag , int options)
+{
+  //TODO : Add an option to scale the values beforehand
+  bool computeEigenvectors = (options&ComputeEigenvectors)==ComputeEigenvectors;
+
+  m_eivalues = diag;
+  m_subdiag = subdiag;
+  if (computeEigenvectors)
+  {
+    m_eivec.setIdentity(diag.size(), diag.size());
+  }
+  m_info = internal::computeFromTridiagonal_impl(m_eivalues, m_subdiag, m_maxIterations, computeEigenvectors, m_eivec);
+
+  m_isInitialized = true;
+  m_eigenvectorsOk = computeEigenvectors;
+  return *this;
+}
+
+namespace internal {
+/**
+  * \internal
+  * \brief Compute the eigendecomposition from a tridiagonal matrix
+  *
+  * \param[in,out] diag : On input, the diagonal of the matrix, on output the eigenvalues
+  * \param[in,out] subdiag : The subdiagonal part of the matrix (entries are modified during the decomposition)
+  * \param[in] maxIterations : the maximum number of iterations
+  * \param[in] computeEigenvectors : whether the eigenvectors have to be computed or not
+  * \param[out] eivec : The matrix to store the eigenvectors if computeEigenvectors==true. Must be allocated on input.
+  * \returns \c Success or \c NoConvergence
+  */
+template<typename MatrixType, typename DiagType, typename SubDiagType>
+ComputationInfo computeFromTridiagonal_impl(DiagType& diag, SubDiagType& subdiag, const Index maxIterations, bool computeEigenvectors, MatrixType& eivec)
+{
+  using std::abs;
+
+  ComputationInfo info;
+  typedef typename MatrixType::Scalar Scalar;
+
+  Index n = diag.size();
+  Index end = n-1;
+  Index start = 0;
+  Index iter = 0; // total number of iterations
+  
+  typedef typename DiagType::RealScalar RealScalar;
+  const RealScalar considerAsZero = (std::numeric_limits<RealScalar>::min)();
+  const RealScalar precision = RealScalar(2)*NumTraits<RealScalar>::epsilon();
+  
+  while (end>0)
+  {
+    for (Index i = start; i<end; ++i)
+      if (internal::isMuchSmallerThan(abs(subdiag[i]),(abs(diag[i])+abs(diag[i+1])),precision) || abs(subdiag[i]) <= considerAsZero)
+        subdiag[i] = 0;
+
+    // find the largest unreduced block
+    while (end>0 && subdiag[end-1]==RealScalar(0))
+    {
+      end--;
+    }
+    if (end<=0)
+      break;
+
+    // if we spent too many iterations, we give up
+    iter++;
+    if(iter > maxIterations * n) break;
+
+    start = end - 1;
+    while (start>0 && subdiag[start-1]!=0)
+      start--;
+
+    internal::tridiagonal_qr_step<MatrixType::Flags&RowMajorBit ? RowMajor : ColMajor>(diag.data(), subdiag.data(), start, end, computeEigenvectors ? eivec.data() : (Scalar*)0, n);
+  }
+  if (iter <= maxIterations * n)
+    info = Success;
+  else
+    info = NoConvergence;
+
+  // Sort eigenvalues and corresponding vectors.
+  // TODO make the sort optional ?
+  // TODO use a better sort algorithm !!
+  if (info == Success)
+  {
+    for (Index i = 0; i < n-1; ++i)
+    {
+      Index k;
+      diag.segment(i,n-i).minCoeff(&k);
+      if (k > 0)
+      {
+        std::swap(diag[i], diag[k+i]);
+        if(computeEigenvectors)
+          eivec.col(i).swap(eivec.col(k+i));
+      }
+    }
+  }
+  return info;
+}
+  
+template<typename SolverType,int Size,bool IsComplex> struct direct_selfadjoint_eigenvalues
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(SolverType& eig, const typename SolverType::MatrixType& A, int options)
+  { eig.compute(A,options); }
+};
+
+template<typename SolverType> struct direct_selfadjoint_eigenvalues<SolverType,3,false>
+{
+  typedef typename SolverType::MatrixType MatrixType;
+  typedef typename SolverType::RealVectorType VectorType;
+  typedef typename SolverType::Scalar Scalar;
+  typedef typename SolverType::EigenvectorsType EigenvectorsType;
+  
+
+  /** \internal
+   * Computes the roots of the characteristic polynomial of \a m.
+   * For numerical stability m.trace() should be near zero and to avoid over- or underflow m should be normalized.
+   */
+  EIGEN_DEVICE_FUNC
+  static inline void computeRoots(const MatrixType& m, VectorType& roots)
+  {
+    EIGEN_USING_STD_MATH(sqrt)
+    EIGEN_USING_STD_MATH(atan2)
+    EIGEN_USING_STD_MATH(cos)
+    EIGEN_USING_STD_MATH(sin)
+    const Scalar s_inv3 = Scalar(1)/Scalar(3);
+    const Scalar s_sqrt3 = sqrt(Scalar(3));
+
+    // The characteristic equation is x^3 - c2*x^2 + c1*x - c0 = 0.  The
+    // eigenvalues are the roots to this equation, all guaranteed to be
+    // real-valued, because the matrix is symmetric.
+    Scalar c0 = m(0,0)*m(1,1)*m(2,2) + Scalar(2)*m(1,0)*m(2,0)*m(2,1) - m(0,0)*m(2,1)*m(2,1) - m(1,1)*m(2,0)*m(2,0) - m(2,2)*m(1,0)*m(1,0);
+    Scalar c1 = m(0,0)*m(1,1) - m(1,0)*m(1,0) + m(0,0)*m(2,2) - m(2,0)*m(2,0) + m(1,1)*m(2,2) - m(2,1)*m(2,1);
+    Scalar c2 = m(0,0) + m(1,1) + m(2,2);
+
+    // Construct the parameters used in classifying the roots of the equation
+    // and in solving the equation for the roots in closed form.
+    Scalar c2_over_3 = c2*s_inv3;
+    Scalar a_over_3 = (c2*c2_over_3 - c1)*s_inv3;
+    a_over_3 = numext::maxi(a_over_3, Scalar(0));
+
+    Scalar half_b = Scalar(0.5)*(c0 + c2_over_3*(Scalar(2)*c2_over_3*c2_over_3 - c1));
+
+    Scalar q = a_over_3*a_over_3*a_over_3 - half_b*half_b;
+    q = numext::maxi(q, Scalar(0));
+
+    // Compute the eigenvalues by solving for the roots of the polynomial.
+    Scalar rho = sqrt(a_over_3);
+    Scalar theta = atan2(sqrt(q),half_b)*s_inv3;  // since sqrt(q) > 0, atan2 is in [0, pi] and theta is in [0, pi/3]
+    Scalar cos_theta = cos(theta);
+    Scalar sin_theta = sin(theta);
+    // roots are already sorted, since cos is monotonically decreasing on [0, pi]
+    roots(0) = c2_over_3 - rho*(cos_theta + s_sqrt3*sin_theta); // == 2*rho*cos(theta+2pi/3)
+    roots(1) = c2_over_3 - rho*(cos_theta - s_sqrt3*sin_theta); // == 2*rho*cos(theta+ pi/3)
+    roots(2) = c2_over_3 + Scalar(2)*rho*cos_theta;
+  }
+
+  EIGEN_DEVICE_FUNC
+  static inline bool extract_kernel(MatrixType& mat, Ref<VectorType> res, Ref<VectorType> representative)
+  {
+    using std::abs;
+    Index i0;
+    // Find non-zero column i0 (by construction, there must exist a non zero coefficient on the diagonal):
+    mat.diagonal().cwiseAbs().maxCoeff(&i0);
+    // mat.col(i0) is a good candidate for an orthogonal vector to the current eigenvector,
+    // so let's save it:
+    representative = mat.col(i0);
+    Scalar n0, n1;
+    VectorType c0, c1;
+    n0 = (c0 = representative.cross(mat.col((i0+1)%3))).squaredNorm();
+    n1 = (c1 = representative.cross(mat.col((i0+2)%3))).squaredNorm();
+    if(n0>n1) res = c0/std::sqrt(n0);
+    else      res = c1/std::sqrt(n1);
+
+    return true;
+  }
+
+  EIGEN_DEVICE_FUNC
+  static inline void run(SolverType& solver, const MatrixType& mat, int options)
+  {
+    eigen_assert(mat.cols() == 3 && mat.cols() == mat.rows());
+    eigen_assert((options&~(EigVecMask|GenEigMask))==0
+            && (options&EigVecMask)!=EigVecMask
+            && "invalid option parameter");
+    bool computeEigenvectors = (options&ComputeEigenvectors)==ComputeEigenvectors;
+    
+    EigenvectorsType& eivecs = solver.m_eivec;
+    VectorType& eivals = solver.m_eivalues;
+  
+    // Shift the matrix to the mean eigenvalue and map the matrix coefficients to [-1:1] to avoid over- and underflow.
+    Scalar shift = mat.trace() / Scalar(3);
+    // TODO Avoid this copy. Currently it is necessary to suppress bogus values when determining maxCoeff and for computing the eigenvectors later
+    MatrixType scaledMat = mat.template selfadjointView<Lower>();
+    scaledMat.diagonal().array() -= shift;
+    Scalar scale = scaledMat.cwiseAbs().maxCoeff();
+    if(scale > 0) scaledMat /= scale;   // TODO for scale==0 we could save the remaining operations
+
+    // compute the eigenvalues
+    computeRoots(scaledMat,eivals);
+
+    // compute the eigenvectors
+    if(computeEigenvectors)
+    {
+      if((eivals(2)-eivals(0))<=Eigen::NumTraits<Scalar>::epsilon())
+      {
+        // All three eigenvalues are numerically the same
+        eivecs.setIdentity();
+      }
+      else
+      {
+        MatrixType tmp;
+        tmp = scaledMat;
+
+        // Compute the eigenvector of the most distinct eigenvalue
+        Scalar d0 = eivals(2) - eivals(1);
+        Scalar d1 = eivals(1) - eivals(0);
+        Index k(0), l(2);
+        if(d0 > d1)
+        {
+          numext::swap(k,l);
+          d0 = d1;
+        }
+
+        // Compute the eigenvector of index k
+        {
+          tmp.diagonal().array () -= eivals(k);
+          // By construction, 'tmp' is of rank 2, and its kernel corresponds to the respective eigenvector.
+          extract_kernel(tmp, eivecs.col(k), eivecs.col(l));
+        }
+
+        // Compute eigenvector of index l
+        if(d0<=2*Eigen::NumTraits<Scalar>::epsilon()*d1)
+        {
+          // If d0 is too small, then the two other eigenvalues are numerically the same,
+          // and thus we only have to ortho-normalize the near orthogonal vector we saved above.
+          eivecs.col(l) -= eivecs.col(k).dot(eivecs.col(l))*eivecs.col(l);
+          eivecs.col(l).normalize();
+        }
+        else
+        {
+          tmp = scaledMat;
+          tmp.diagonal().array () -= eivals(l);
+
+          VectorType dummy;
+          extract_kernel(tmp, eivecs.col(l), dummy);
+        }
+
+        // Compute last eigenvector from the other two
+        eivecs.col(1) = eivecs.col(2).cross(eivecs.col(0)).normalized();
+      }
+    }
+
+    // Rescale back to the original size.
+    eivals *= scale;
+    eivals.array() += shift;
+    
+    solver.m_info = Success;
+    solver.m_isInitialized = true;
+    solver.m_eigenvectorsOk = computeEigenvectors;
+  }
+};
+
+// 2x2 direct eigenvalues decomposition, code from Hauke Heibel
+template<typename SolverType> 
+struct direct_selfadjoint_eigenvalues<SolverType,2,false>
+{
+  typedef typename SolverType::MatrixType MatrixType;
+  typedef typename SolverType::RealVectorType VectorType;
+  typedef typename SolverType::Scalar Scalar;
+  typedef typename SolverType::EigenvectorsType EigenvectorsType;
+  
+  EIGEN_DEVICE_FUNC
+  static inline void computeRoots(const MatrixType& m, VectorType& roots)
+  {
+    using std::sqrt;
+    const Scalar t0 = Scalar(0.5) * sqrt( numext::abs2(m(0,0)-m(1,1)) + Scalar(4)*numext::abs2(m(1,0)));
+    const Scalar t1 = Scalar(0.5) * (m(0,0) + m(1,1));
+    roots(0) = t1 - t0;
+    roots(1) = t1 + t0;
+  }
+  
+  EIGEN_DEVICE_FUNC
+  static inline void run(SolverType& solver, const MatrixType& mat, int options)
+  {
+    EIGEN_USING_STD_MATH(sqrt);
+    EIGEN_USING_STD_MATH(abs);
+    
+    eigen_assert(mat.cols() == 2 && mat.cols() == mat.rows());
+    eigen_assert((options&~(EigVecMask|GenEigMask))==0
+            && (options&EigVecMask)!=EigVecMask
+            && "invalid option parameter");
+    bool computeEigenvectors = (options&ComputeEigenvectors)==ComputeEigenvectors;
+    
+    EigenvectorsType& eivecs = solver.m_eivec;
+    VectorType& eivals = solver.m_eivalues;
+  
+    // Shift the matrix to the mean eigenvalue and map the matrix coefficients to [-1:1] to avoid over- and underflow.
+    Scalar shift = mat.trace() / Scalar(2);
+    MatrixType scaledMat = mat;
+    scaledMat.coeffRef(0,1) = mat.coeff(1,0);
+    scaledMat.diagonal().array() -= shift;
+    Scalar scale = scaledMat.cwiseAbs().maxCoeff();
+    if(scale > Scalar(0))
+      scaledMat /= scale;
+
+    // Compute the eigenvalues
+    computeRoots(scaledMat,eivals);
+
+    // compute the eigen vectors
+    if(computeEigenvectors)
+    {
+      if((eivals(1)-eivals(0))<=abs(eivals(1))*Eigen::NumTraits<Scalar>::epsilon())
+      {
+        eivecs.setIdentity();
+      }
+      else
+      {
+        scaledMat.diagonal().array () -= eivals(1);
+        Scalar a2 = numext::abs2(scaledMat(0,0));
+        Scalar c2 = numext::abs2(scaledMat(1,1));
+        Scalar b2 = numext::abs2(scaledMat(1,0));
+        if(a2>c2)
+        {
+          eivecs.col(1) << -scaledMat(1,0), scaledMat(0,0);
+          eivecs.col(1) /= sqrt(a2+b2);
+        }
+        else
+        {
+          eivecs.col(1) << -scaledMat(1,1), scaledMat(1,0);
+          eivecs.col(1) /= sqrt(c2+b2);
+        }
+
+        eivecs.col(0) << eivecs.col(1).unitOrthogonal();
+      }
+    }
+
+    // Rescale back to the original size.
+    eivals *= scale;
+    eivals.array() += shift;
+
+    solver.m_info = Success;
+    solver.m_isInitialized = true;
+    solver.m_eigenvectorsOk = computeEigenvectors;
+  }
+};
+
+}
+
+template<typename MatrixType>
+EIGEN_DEVICE_FUNC
+SelfAdjointEigenSolver<MatrixType>& SelfAdjointEigenSolver<MatrixType>
+::computeDirect(const MatrixType& matrix, int options)
+{
+  internal::direct_selfadjoint_eigenvalues<SelfAdjointEigenSolver,Size,NumTraits<Scalar>::IsComplex>::run(*this,matrix,options);
+  return *this;
+}
+
+namespace internal {
+template<int StorageOrder,typename RealScalar, typename Scalar, typename Index>
+EIGEN_DEVICE_FUNC
+static void tridiagonal_qr_step(RealScalar* diag, RealScalar* subdiag, Index start, Index end, Scalar* matrixQ, Index n)
+{
+  using std::abs;
+  RealScalar td = (diag[end-1] - diag[end])*RealScalar(0.5);
+  RealScalar e = subdiag[end-1];
+  // Note that thanks to scaling, e^2 or td^2 cannot overflow, however they can still
+  // underflow thus leading to inf/NaN values when using the following commented code:
+//   RealScalar e2 = numext::abs2(subdiag[end-1]);
+//   RealScalar mu = diag[end] - e2 / (td + (td>0 ? 1 : -1) * sqrt(td*td + e2));
+  // This explain the following, somewhat more complicated, version:
+  RealScalar mu = diag[end];
+  if(td==RealScalar(0))
+    mu -= abs(e);
+  else
+  {
+    RealScalar e2 = numext::abs2(subdiag[end-1]);
+    RealScalar h = numext::hypot(td,e);
+    if(e2==RealScalar(0)) mu -= (e / (td + (td>RealScalar(0) ? RealScalar(1) : RealScalar(-1)))) * (e / h);
+    else                  mu -= e2 / (td + (td>RealScalar(0) ? h : -h));
+  }
+  
+  RealScalar x = diag[start] - mu;
+  RealScalar z = subdiag[start];
+  for (Index k = start; k < end; ++k)
+  {
+    JacobiRotation<RealScalar> rot;
+    rot.makeGivens(x, z);
+
+    // do T = G' T G
+    RealScalar sdk = rot.s() * diag[k] + rot.c() * subdiag[k];
+    RealScalar dkp1 = rot.s() * subdiag[k] + rot.c() * diag[k+1];
+
+    diag[k] = rot.c() * (rot.c() * diag[k] - rot.s() * subdiag[k]) - rot.s() * (rot.c() * subdiag[k] - rot.s() * diag[k+1]);
+    diag[k+1] = rot.s() * sdk + rot.c() * dkp1;
+    subdiag[k] = rot.c() * sdk - rot.s() * dkp1;
+    
+
+    if (k > start)
+      subdiag[k - 1] = rot.c() * subdiag[k-1] - rot.s() * z;
+
+    x = subdiag[k];
+
+    if (k < end - 1)
+    {
+      z = -rot.s() * subdiag[k+1];
+      subdiag[k + 1] = rot.c() * subdiag[k+1];
+    }
+    
+    // apply the givens rotation to the unit matrix Q = Q * G
+    if (matrixQ)
+    {
+      // FIXME if StorageOrder == RowMajor this operation is not very efficient
+      Map<Matrix<Scalar,Dynamic,Dynamic,StorageOrder> > q(matrixQ,n,n);
+      q.applyOnTheRight(k,k+1,rot);
+    }
+  }
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SELFADJOINTEIGENSOLVER_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
new file mode 100644
index 00000000..3891cf88
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
@@ -0,0 +1,90 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to LAPACKe
+ *    Self-adjoint eigenvalues/eigenvectors.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_SAEIGENSOLVER_LAPACKE_H
+#define EIGEN_SAEIGENSOLVER_LAPACKE_H
+
+namespace Eigen { 
+
+/** \internal Specialization for the data types supported by LAPACKe */
+
+#define EIGEN_LAPACKE_EIG_SELFADJ(EIGTYPE, LAPACKE_TYPE, LAPACKE_RTYPE, LAPACKE_NAME, EIGCOLROW, LAPACKE_COLROW ) \
+template<> template<typename InputType> inline \
+SelfAdjointEigenSolver<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW> >& \
+SelfAdjointEigenSolver<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW> >::compute(const EigenBase<InputType>& matrix, int options) \
+{ \
+  eigen_assert(matrix.cols() == matrix.rows()); \
+  eigen_assert((options&~(EigVecMask|GenEigMask))==0 \
+          && (options&EigVecMask)!=EigVecMask \
+          && "invalid option parameter"); \
+  bool computeEigenvectors = (options&ComputeEigenvectors)==ComputeEigenvectors; \
+  lapack_int n = internal::convert_index<lapack_int>(matrix.cols()), lda, matrix_order, info; \
+  m_eivalues.resize(n,1); \
+  m_subdiag.resize(n-1); \
+  m_eivec = matrix; \
+\
+  if(n==1) \
+  { \
+    m_eivalues.coeffRef(0,0) = numext::real(m_eivec.coeff(0,0)); \
+    if(computeEigenvectors) m_eivec.setOnes(n,n); \
+    m_info = Success; \
+    m_isInitialized = true; \
+    m_eigenvectorsOk = computeEigenvectors; \
+    return *this; \
+  } \
+\
+  lda = internal::convert_index<lapack_int>(m_eivec.outerStride()); \
+  matrix_order=LAPACKE_COLROW; \
+  char jobz, uplo='L'/*, range='A'*/; \
+  jobz = computeEigenvectors ? 'V' : 'N'; \
+\
+  info = LAPACKE_##LAPACKE_NAME( matrix_order, jobz, uplo, n, (LAPACKE_TYPE*)m_eivec.data(), lda, (LAPACKE_RTYPE*)m_eivalues.data() ); \
+  m_info = (info==0) ? Success : NoConvergence; \
+  m_isInitialized = true; \
+  m_eigenvectorsOk = computeEigenvectors; \
+  return *this; \
+}
+
+
+EIGEN_LAPACKE_EIG_SELFADJ(double,   double,                double, dsyev, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_EIG_SELFADJ(float,    float,                 float,  ssyev, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_EIG_SELFADJ(dcomplex, lapack_complex_double, double, zheev, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_EIG_SELFADJ(scomplex, lapack_complex_float,  float,  cheev, ColMajor, LAPACK_COL_MAJOR)
+
+EIGEN_LAPACKE_EIG_SELFADJ(double,   double,                double, dsyev, RowMajor, LAPACK_ROW_MAJOR)
+EIGEN_LAPACKE_EIG_SELFADJ(float,    float,                 float,  ssyev, RowMajor, LAPACK_ROW_MAJOR)
+EIGEN_LAPACKE_EIG_SELFADJ(dcomplex, lapack_complex_double, double, zheev, RowMajor, LAPACK_ROW_MAJOR)
+EIGEN_LAPACKE_EIG_SELFADJ(scomplex, lapack_complex_float,  float,  cheev, RowMajor, LAPACK_ROW_MAJOR)
+
+} // end namespace Eigen
+
+#endif // EIGEN_SAEIGENSOLVER_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/Tridiagonalization.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/Tridiagonalization.h
new file mode 100644
index 00000000..1d102c17
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Eigenvalues/Tridiagonalization.h
@@ -0,0 +1,556 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TRIDIAGONALIZATION_H
+#define EIGEN_TRIDIAGONALIZATION_H
+
+namespace Eigen { 
+
+namespace internal {
+  
+template<typename MatrixType> struct TridiagonalizationMatrixTReturnType;
+template<typename MatrixType>
+struct traits<TridiagonalizationMatrixTReturnType<MatrixType> >
+  : public traits<typename MatrixType::PlainObject>
+{
+  typedef typename MatrixType::PlainObject ReturnType; // FIXME shall it be a BandMatrix?
+  enum { Flags = 0 };
+};
+
+template<typename MatrixType, typename CoeffVectorType>
+void tridiagonalization_inplace(MatrixType& matA, CoeffVectorType& hCoeffs);
+}
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  *
+  * \class Tridiagonalization
+  *
+  * \brief Tridiagonal decomposition of a selfadjoint matrix
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the
+  * tridiagonal decomposition; this is expected to be an instantiation of the
+  * Matrix class template.
+  *
+  * This class performs a tridiagonal decomposition of a selfadjoint matrix \f$ A \f$ such that:
+  * \f$ A = Q T Q^* \f$ where \f$ Q \f$ is unitary and \f$ T \f$ a real symmetric tridiagonal matrix.
+  *
+  * A tridiagonal matrix is a matrix which has nonzero elements only on the
+  * main diagonal and the first diagonal below and above it. The Hessenberg
+  * decomposition of a selfadjoint matrix is in fact a tridiagonal
+  * decomposition. This class is used in SelfAdjointEigenSolver to compute the
+  * eigenvalues and eigenvectors of a selfadjoint matrix.
+  *
+  * Call the function compute() to compute the tridiagonal decomposition of a
+  * given matrix. Alternatively, you can use the Tridiagonalization(const MatrixType&)
+  * constructor which computes the tridiagonal Schur decomposition at
+  * construction time. Once the decomposition is computed, you can use the
+  * matrixQ() and matrixT() functions to retrieve the matrices Q and T in the
+  * decomposition.
+  *
+  * The documentation of Tridiagonalization(const MatrixType&) contains an
+  * example of the typical use of this class.
+  *
+  * \sa class HessenbergDecomposition, class SelfAdjointEigenSolver
+  */
+template<typename _MatrixType> class Tridiagonalization
+{
+  public:
+
+    /** \brief Synonym for the template parameter \p _MatrixType. */
+    typedef _MatrixType MatrixType;
+
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+
+    enum {
+      Size = MatrixType::RowsAtCompileTime,
+      SizeMinusOne = Size == Dynamic ? Dynamic : (Size > 1 ? Size - 1 : 1),
+      Options = MatrixType::Options,
+      MaxSize = MatrixType::MaxRowsAtCompileTime,
+      MaxSizeMinusOne = MaxSize == Dynamic ? Dynamic : (MaxSize > 1 ? MaxSize - 1 : 1)
+    };
+
+    typedef Matrix<Scalar, SizeMinusOne, 1, Options & ~RowMajor, MaxSizeMinusOne, 1> CoeffVectorType;
+    typedef typename internal::plain_col_type<MatrixType, RealScalar>::type DiagonalType;
+    typedef Matrix<RealScalar, SizeMinusOne, 1, Options & ~RowMajor, MaxSizeMinusOne, 1> SubDiagonalType;
+    typedef typename internal::remove_all<typename MatrixType::RealReturnType>::type MatrixTypeRealView;
+    typedef internal::TridiagonalizationMatrixTReturnType<MatrixTypeRealView> MatrixTReturnType;
+
+    typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
+              typename internal::add_const_on_value_type<typename Diagonal<const MatrixType>::RealReturnType>::type,
+              const Diagonal<const MatrixType>
+            >::type DiagonalReturnType;
+
+    typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
+              typename internal::add_const_on_value_type<typename Diagonal<const MatrixType, -1>::RealReturnType>::type,
+              const Diagonal<const MatrixType, -1>
+            >::type SubDiagonalReturnType;
+
+    /** \brief Return type of matrixQ() */
+    typedef HouseholderSequence<MatrixType,typename internal::remove_all<typename CoeffVectorType::ConjugateReturnType>::type> HouseholderSequenceType;
+
+    /** \brief Default constructor.
+      *
+      * \param [in]  size  Positive integer, size of the matrix whose tridiagonal
+      * decomposition will be computed.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via compute().  The \p size parameter is only
+      * used as a hint. It is not an error to give a wrong \p size, but it may
+      * impair performance.
+      *
+      * \sa compute() for an example.
+      */
+    explicit Tridiagonalization(Index size = Size==Dynamic ? 2 : Size)
+      : m_matrix(size,size),
+        m_hCoeffs(size > 1 ? size-1 : 1),
+        m_isInitialized(false)
+    {}
+
+    /** \brief Constructor; computes tridiagonal decomposition of given matrix.
+      *
+      * \param[in]  matrix  Selfadjoint matrix whose tridiagonal decomposition
+      * is to be computed.
+      *
+      * This constructor calls compute() to compute the tridiagonal decomposition.
+      *
+      * Example: \include Tridiagonalization_Tridiagonalization_MatrixType.cpp
+      * Output: \verbinclude Tridiagonalization_Tridiagonalization_MatrixType.out
+      */
+    template<typename InputType>
+    explicit Tridiagonalization(const EigenBase<InputType>& matrix)
+      : m_matrix(matrix.derived()),
+        m_hCoeffs(matrix.cols() > 1 ? matrix.cols()-1 : 1),
+        m_isInitialized(false)
+    {
+      internal::tridiagonalization_inplace(m_matrix, m_hCoeffs);
+      m_isInitialized = true;
+    }
+
+    /** \brief Computes tridiagonal decomposition of given matrix.
+      *
+      * \param[in]  matrix  Selfadjoint matrix whose tridiagonal decomposition
+      * is to be computed.
+      * \returns    Reference to \c *this
+      *
+      * The tridiagonal decomposition is computed by bringing the columns of
+      * the matrix successively in the required form using Householder
+      * reflections. The cost is \f$ 4n^3/3 \f$ flops, where \f$ n \f$ denotes
+      * the size of the given matrix.
+      *
+      * This method reuses of the allocated data in the Tridiagonalization
+      * object, if the size of the matrix does not change.
+      *
+      * Example: \include Tridiagonalization_compute.cpp
+      * Output: \verbinclude Tridiagonalization_compute.out
+      */
+    template<typename InputType>
+    Tridiagonalization& compute(const EigenBase<InputType>& matrix)
+    {
+      m_matrix = matrix.derived();
+      m_hCoeffs.resize(matrix.rows()-1, 1);
+      internal::tridiagonalization_inplace(m_matrix, m_hCoeffs);
+      m_isInitialized = true;
+      return *this;
+    }
+
+    /** \brief Returns the Householder coefficients.
+      *
+      * \returns a const reference to the vector of Householder coefficients
+      *
+      * \pre Either the constructor Tridiagonalization(const MatrixType&) or
+      * the member function compute(const MatrixType&) has been called before
+      * to compute the tridiagonal decomposition of a matrix.
+      *
+      * The Householder coefficients allow the reconstruction of the matrix
+      * \f$ Q \f$ in the tridiagonal decomposition from the packed data.
+      *
+      * Example: \include Tridiagonalization_householderCoefficients.cpp
+      * Output: \verbinclude Tridiagonalization_householderCoefficients.out
+      *
+      * \sa packedMatrix(), \ref Householder_Module "Householder module"
+      */
+    inline CoeffVectorType householderCoefficients() const
+    {
+      eigen_assert(m_isInitialized && "Tridiagonalization is not initialized.");
+      return m_hCoeffs;
+    }
+
+    /** \brief Returns the internal representation of the decomposition
+      *
+      *	\returns a const reference to a matrix with the internal representation
+      *	         of the decomposition.
+      *
+      * \pre Either the constructor Tridiagonalization(const MatrixType&) or
+      * the member function compute(const MatrixType&) has been called before
+      * to compute the tridiagonal decomposition of a matrix.
+      *
+      * The returned matrix contains the following information:
+      *  - the strict upper triangular part is equal to the input matrix A.
+      *  - the diagonal and lower sub-diagonal represent the real tridiagonal
+      *    symmetric matrix T.
+      *  - the rest of the lower part contains the Householder vectors that,
+      *    combined with Householder coefficients returned by
+      *    householderCoefficients(), allows to reconstruct the matrix Q as
+      *       \f$ Q = H_{N-1} \ldots H_1 H_0 \f$.
+      *    Here, the matrices \f$ H_i \f$ are the Householder transformations
+      *       \f$ H_i = (I - h_i v_i v_i^T) \f$
+      *    where \f$ h_i \f$ is the \f$ i \f$th Householder coefficient and
+      *    \f$ v_i \f$ is the Householder vector defined by
+      *       \f$ v_i = [ 0, \ldots, 0, 1, M(i+2,i), \ldots, M(N-1,i) ]^T \f$
+      *    with M the matrix returned by this function.
+      *
+      * See LAPACK for further details on this packed storage.
+      *
+      * Example: \include Tridiagonalization_packedMatrix.cpp
+      * Output: \verbinclude Tridiagonalization_packedMatrix.out
+      *
+      * \sa householderCoefficients()
+      */
+    inline const MatrixType& packedMatrix() const
+    {
+      eigen_assert(m_isInitialized && "Tridiagonalization is not initialized.");
+      return m_matrix;
+    }
+
+    /** \brief Returns the unitary matrix Q in the decomposition
+      *
+      * \returns object representing the matrix Q
+      *
+      * \pre Either the constructor Tridiagonalization(const MatrixType&) or
+      * the member function compute(const MatrixType&) has been called before
+      * to compute the tridiagonal decomposition of a matrix.
+      *
+      * This function returns a light-weight object of template class
+      * HouseholderSequence. You can either apply it directly to a matrix or
+      * you can convert it to a matrix of type #MatrixType.
+      *
+      * \sa Tridiagonalization(const MatrixType&) for an example,
+      *     matrixT(), class HouseholderSequence
+      */
+    HouseholderSequenceType matrixQ() const
+    {
+      eigen_assert(m_isInitialized && "Tridiagonalization is not initialized.");
+      return HouseholderSequenceType(m_matrix, m_hCoeffs.conjugate())
+             .setLength(m_matrix.rows() - 1)
+             .setShift(1);
+    }
+
+    /** \brief Returns an expression of the tridiagonal matrix T in the decomposition
+      *
+      * \returns expression object representing the matrix T
+      *
+      * \pre Either the constructor Tridiagonalization(const MatrixType&) or
+      * the member function compute(const MatrixType&) has been called before
+      * to compute the tridiagonal decomposition of a matrix.
+      *
+      * Currently, this function can be used to extract the matrix T from internal
+      * data and copy it to a dense matrix object. In most cases, it may be
+      * sufficient to directly use the packed matrix or the vector expressions
+      * returned by diagonal() and subDiagonal() instead of creating a new
+      * dense copy matrix with this function.
+      *
+      * \sa Tridiagonalization(const MatrixType&) for an example,
+      * matrixQ(), packedMatrix(), diagonal(), subDiagonal()
+      */
+    MatrixTReturnType matrixT() const
+    {
+      eigen_assert(m_isInitialized && "Tridiagonalization is not initialized.");
+      return MatrixTReturnType(m_matrix.real());
+    }
+
+    /** \brief Returns the diagonal of the tridiagonal matrix T in the decomposition.
+      *
+      * \returns expression representing the diagonal of T
+      *
+      * \pre Either the constructor Tridiagonalization(const MatrixType&) or
+      * the member function compute(const MatrixType&) has been called before
+      * to compute the tridiagonal decomposition of a matrix.
+      *
+      * Example: \include Tridiagonalization_diagonal.cpp
+      * Output: \verbinclude Tridiagonalization_diagonal.out
+      *
+      * \sa matrixT(), subDiagonal()
+      */
+    DiagonalReturnType diagonal() const;
+
+    /** \brief Returns the subdiagonal of the tridiagonal matrix T in the decomposition.
+      *
+      * \returns expression representing the subdiagonal of T
+      *
+      * \pre Either the constructor Tridiagonalization(const MatrixType&) or
+      * the member function compute(const MatrixType&) has been called before
+      * to compute the tridiagonal decomposition of a matrix.
+      *
+      * \sa diagonal() for an example, matrixT()
+      */
+    SubDiagonalReturnType subDiagonal() const;
+
+  protected:
+
+    MatrixType m_matrix;
+    CoeffVectorType m_hCoeffs;
+    bool m_isInitialized;
+};
+
+template<typename MatrixType>
+typename Tridiagonalization<MatrixType>::DiagonalReturnType
+Tridiagonalization<MatrixType>::diagonal() const
+{
+  eigen_assert(m_isInitialized && "Tridiagonalization is not initialized.");
+  return m_matrix.diagonal().real();
+}
+
+template<typename MatrixType>
+typename Tridiagonalization<MatrixType>::SubDiagonalReturnType
+Tridiagonalization<MatrixType>::subDiagonal() const
+{
+  eigen_assert(m_isInitialized && "Tridiagonalization is not initialized.");
+  return m_matrix.template diagonal<-1>().real();
+}
+
+namespace internal {
+
+/** \internal
+  * Performs a tridiagonal decomposition of the selfadjoint matrix \a matA in-place.
+  *
+  * \param[in,out] matA On input the selfadjoint matrix. Only the \b lower triangular part is referenced.
+  *                     On output, the strict upper part is left unchanged, and the lower triangular part
+  *                     represents the T and Q matrices in packed format has detailed below.
+  * \param[out]    hCoeffs returned Householder coefficients (see below)
+  *
+  * On output, the tridiagonal selfadjoint matrix T is stored in the diagonal
+  * and lower sub-diagonal of the matrix \a matA.
+  * The unitary matrix Q is represented in a compact way as a product of
+  * Householder reflectors \f$ H_i \f$ such that:
+  *       \f$ Q = H_{N-1} \ldots H_1 H_0 \f$.
+  * The Householder reflectors are defined as
+  *       \f$ H_i = (I - h_i v_i v_i^T) \f$
+  * where \f$ h_i = hCoeffs[i]\f$ is the \f$ i \f$th Householder coefficient and
+  * \f$ v_i \f$ is the Householder vector defined by
+  *       \f$ v_i = [ 0, \ldots, 0, 1, matA(i+2,i), \ldots, matA(N-1,i) ]^T \f$.
+  *
+  * Implemented from Golub's "Matrix Computations", algorithm 8.3.1.
+  *
+  * \sa Tridiagonalization::packedMatrix()
+  */
+template<typename MatrixType, typename CoeffVectorType>
+void tridiagonalization_inplace(MatrixType& matA, CoeffVectorType& hCoeffs)
+{
+  using numext::conj;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  Index n = matA.rows();
+  eigen_assert(n==matA.cols());
+  eigen_assert(n==hCoeffs.size()+1 || n==1);
+  
+  for (Index i = 0; i<n-1; ++i)
+  {
+    Index remainingSize = n-i-1;
+    RealScalar beta;
+    Scalar h;
+    matA.col(i).tail(remainingSize).makeHouseholderInPlace(h, beta);
+
+    // Apply similarity transformation to remaining columns,
+    // i.e., A = H A H' where H = I - h v v' and v = matA.col(i).tail(n-i-1)
+    matA.col(i).coeffRef(i+1) = 1;
+
+    hCoeffs.tail(n-i-1).noalias() = (matA.bottomRightCorner(remainingSize,remainingSize).template selfadjointView<Lower>()
+                                  * (conj(h) * matA.col(i).tail(remainingSize)));
+
+    hCoeffs.tail(n-i-1) += (conj(h)*RealScalar(-0.5)*(hCoeffs.tail(remainingSize).dot(matA.col(i).tail(remainingSize)))) * matA.col(i).tail(n-i-1);
+
+    matA.bottomRightCorner(remainingSize, remainingSize).template selfadjointView<Lower>()
+      .rankUpdate(matA.col(i).tail(remainingSize), hCoeffs.tail(remainingSize), Scalar(-1));
+
+    matA.col(i).coeffRef(i+1) = beta;
+    hCoeffs.coeffRef(i) = h;
+  }
+}
+
+// forward declaration, implementation at the end of this file
+template<typename MatrixType,
+         int Size=MatrixType::ColsAtCompileTime,
+         bool IsComplex=NumTraits<typename MatrixType::Scalar>::IsComplex>
+struct tridiagonalization_inplace_selector;
+
+/** \brief Performs a full tridiagonalization in place
+  *
+  * \param[in,out]  mat  On input, the selfadjoint matrix whose tridiagonal
+  *    decomposition is to be computed. Only the lower triangular part referenced.
+  *    The rest is left unchanged. On output, the orthogonal matrix Q
+  *    in the decomposition if \p extractQ is true.
+  * \param[out]  diag  The diagonal of the tridiagonal matrix T in the
+  *    decomposition.
+  * \param[out]  subdiag  The subdiagonal of the tridiagonal matrix T in
+  *    the decomposition.
+  * \param[in]  extractQ  If true, the orthogonal matrix Q in the
+  *    decomposition is computed and stored in \p mat.
+  *
+  * Computes the tridiagonal decomposition of the selfadjoint matrix \p mat in place
+  * such that \f$ mat = Q T Q^* \f$ where \f$ Q \f$ is unitary and \f$ T \f$ a real
+  * symmetric tridiagonal matrix.
+  *
+  * The tridiagonal matrix T is passed to the output parameters \p diag and \p subdiag. If
+  * \p extractQ is true, then the orthogonal matrix Q is passed to \p mat. Otherwise the lower
+  * part of the matrix \p mat is destroyed.
+  *
+  * The vectors \p diag and \p subdiag are not resized. The function
+  * assumes that they are already of the correct size. The length of the
+  * vector \p diag should equal the number of rows in \p mat, and the
+  * length of the vector \p subdiag should be one left.
+  *
+  * This implementation contains an optimized path for 3-by-3 matrices
+  * which is especially useful for plane fitting.
+  *
+  * \note Currently, it requires two temporary vectors to hold the intermediate
+  * Householder coefficients, and to reconstruct the matrix Q from the Householder
+  * reflectors.
+  *
+  * Example (this uses the same matrix as the example in
+  *    Tridiagonalization::Tridiagonalization(const MatrixType&)):
+  *    \include Tridiagonalization_decomposeInPlace.cpp
+  * Output: \verbinclude Tridiagonalization_decomposeInPlace.out
+  *
+  * \sa class Tridiagonalization
+  */
+template<typename MatrixType, typename DiagonalType, typename SubDiagonalType>
+void tridiagonalization_inplace(MatrixType& mat, DiagonalType& diag, SubDiagonalType& subdiag, bool extractQ)
+{
+  eigen_assert(mat.cols()==mat.rows() && diag.size()==mat.rows() && subdiag.size()==mat.rows()-1);
+  tridiagonalization_inplace_selector<MatrixType>::run(mat, diag, subdiag, extractQ);
+}
+
+/** \internal
+  * General full tridiagonalization
+  */
+template<typename MatrixType, int Size, bool IsComplex>
+struct tridiagonalization_inplace_selector
+{
+  typedef typename Tridiagonalization<MatrixType>::CoeffVectorType CoeffVectorType;
+  typedef typename Tridiagonalization<MatrixType>::HouseholderSequenceType HouseholderSequenceType;
+  template<typename DiagonalType, typename SubDiagonalType>
+  static void run(MatrixType& mat, DiagonalType& diag, SubDiagonalType& subdiag, bool extractQ)
+  {
+    CoeffVectorType hCoeffs(mat.cols()-1);
+    tridiagonalization_inplace(mat,hCoeffs);
+    diag = mat.diagonal().real();
+    subdiag = mat.template diagonal<-1>().real();
+    if(extractQ)
+      mat = HouseholderSequenceType(mat, hCoeffs.conjugate())
+            .setLength(mat.rows() - 1)
+            .setShift(1);
+  }
+};
+
+/** \internal
+  * Specialization for 3x3 real matrices.
+  * Especially useful for plane fitting.
+  */
+template<typename MatrixType>
+struct tridiagonalization_inplace_selector<MatrixType,3,false>
+{
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+
+  template<typename DiagonalType, typename SubDiagonalType>
+  static void run(MatrixType& mat, DiagonalType& diag, SubDiagonalType& subdiag, bool extractQ)
+  {
+    using std::sqrt;
+    const RealScalar tol = (std::numeric_limits<RealScalar>::min)();
+    diag[0] = mat(0,0);
+    RealScalar v1norm2 = numext::abs2(mat(2,0));
+    if(v1norm2 <= tol)
+    {
+      diag[1] = mat(1,1);
+      diag[2] = mat(2,2);
+      subdiag[0] = mat(1,0);
+      subdiag[1] = mat(2,1);
+      if (extractQ)
+        mat.setIdentity();
+    }
+    else
+    {
+      RealScalar beta = sqrt(numext::abs2(mat(1,0)) + v1norm2);
+      RealScalar invBeta = RealScalar(1)/beta;
+      Scalar m01 = mat(1,0) * invBeta;
+      Scalar m02 = mat(2,0) * invBeta;
+      Scalar q = RealScalar(2)*m01*mat(2,1) + m02*(mat(2,2) - mat(1,1));
+      diag[1] = mat(1,1) + m02*q;
+      diag[2] = mat(2,2) - m02*q;
+      subdiag[0] = beta;
+      subdiag[1] = mat(2,1) - m01 * q;
+      if (extractQ)
+      {
+        mat << 1,   0,    0,
+               0, m01,  m02,
+               0, m02, -m01;
+      }
+    }
+  }
+};
+
+/** \internal
+  * Trivial specialization for 1x1 matrices
+  */
+template<typename MatrixType, bool IsComplex>
+struct tridiagonalization_inplace_selector<MatrixType,1,IsComplex>
+{
+  typedef typename MatrixType::Scalar Scalar;
+
+  template<typename DiagonalType, typename SubDiagonalType>
+  static void run(MatrixType& mat, DiagonalType& diag, SubDiagonalType&, bool extractQ)
+  {
+    diag(0,0) = numext::real(mat(0,0));
+    if(extractQ)
+      mat(0,0) = Scalar(1);
+  }
+};
+
+/** \internal
+  * \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  * \brief Expression type for return value of Tridiagonalization::matrixT()
+  *
+  * \tparam MatrixType type of underlying dense matrix
+  */
+template<typename MatrixType> struct TridiagonalizationMatrixTReturnType
+: public ReturnByValue<TridiagonalizationMatrixTReturnType<MatrixType> >
+{
+  public:
+    /** \brief Constructor.
+      *
+      * \param[in] mat The underlying dense matrix
+      */
+    TridiagonalizationMatrixTReturnType(const MatrixType& mat) : m_matrix(mat) { }
+
+    template <typename ResultType>
+    inline void evalTo(ResultType& result) const
+    {
+      result.setZero();
+      result.template diagonal<1>() = m_matrix.template diagonal<-1>().conjugate();
+      result.diagonal() = m_matrix.diagonal();
+      result.template diagonal<-1>() = m_matrix.template diagonal<-1>();
+    }
+
+    Index rows() const { return m_matrix.rows(); }
+    Index cols() const { return m_matrix.cols(); }
+
+  protected:
+    typename MatrixType::Nested m_matrix;
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRIDIAGONALIZATION_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/AlignedBox.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/AlignedBox.h
new file mode 100644
index 00000000..c902d8f0
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/AlignedBox.h
@@ -0,0 +1,392 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ALIGNEDBOX_H
+#define EIGEN_ALIGNEDBOX_H
+
+namespace Eigen { 
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  *
+  * \class AlignedBox
+  *
+  * \brief An axis aligned box
+  *
+  * \tparam _Scalar the type of the scalar coefficients
+  * \tparam _AmbientDim the dimension of the ambient space, can be a compile time value or Dynamic.
+  *
+  * This class represents an axis aligned box as a pair of the minimal and maximal corners.
+  * \warning The result of most methods is undefined when applied to an empty box. You can check for empty boxes using isEmpty().
+  * \sa alignedboxtypedefs
+  */
+template <typename _Scalar, int _AmbientDim>
+class AlignedBox
+{
+public:
+EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim)
+  enum { AmbientDimAtCompileTime = _AmbientDim };
+  typedef _Scalar                                   Scalar;
+  typedef NumTraits<Scalar>                         ScalarTraits;
+  typedef Eigen::Index                              Index; ///< \deprecated since Eigen 3.3
+  typedef typename ScalarTraits::Real               RealScalar;
+  typedef typename ScalarTraits::NonInteger         NonInteger;
+  typedef Matrix<Scalar,AmbientDimAtCompileTime,1>  VectorType;
+  typedef CwiseBinaryOp<internal::scalar_sum_op<Scalar>, const VectorType, const VectorType> VectorTypeSum;
+
+  /** Define constants to name the corners of a 1D, 2D or 3D axis aligned bounding box */
+  enum CornerType
+  {
+    /** 1D names @{ */
+    Min=0, Max=1,
+    /** @} */
+
+    /** Identifier for 2D corner @{ */
+    BottomLeft=0, BottomRight=1,
+    TopLeft=2, TopRight=3,
+    /** @} */
+
+    /** Identifier for 3D corner  @{ */
+    BottomLeftFloor=0, BottomRightFloor=1,
+    TopLeftFloor=2, TopRightFloor=3,
+    BottomLeftCeil=4, BottomRightCeil=5,
+    TopLeftCeil=6, TopRightCeil=7
+    /** @} */
+  };
+
+
+  /** Default constructor initializing a null box. */
+  EIGEN_DEVICE_FUNC inline AlignedBox()
+  { if (EIGEN_CONST_CONDITIONAL(AmbientDimAtCompileTime!=Dynamic)) setEmpty(); }
+
+  /** Constructs a null box with \a _dim the dimension of the ambient space. */
+  EIGEN_DEVICE_FUNC inline explicit AlignedBox(Index _dim) : m_min(_dim), m_max(_dim)
+  { setEmpty(); }
+
+  /** Constructs a box with extremities \a _min and \a _max.
+   * \warning If either component of \a _min is larger than the same component of \a _max, the constructed box is empty. */
+  template<typename OtherVectorType1, typename OtherVectorType2>
+  EIGEN_DEVICE_FUNC inline AlignedBox(const OtherVectorType1& _min, const OtherVectorType2& _max) : m_min(_min), m_max(_max) {}
+
+  /** Constructs a box containing a single point \a p. */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline explicit AlignedBox(const MatrixBase<Derived>& p) : m_min(p), m_max(m_min)
+  { }
+
+  EIGEN_DEVICE_FUNC ~AlignedBox() {}
+
+  /** \returns the dimension in which the box holds */
+  EIGEN_DEVICE_FUNC inline Index dim() const { return AmbientDimAtCompileTime==Dynamic ? m_min.size() : Index(AmbientDimAtCompileTime); }
+
+  /** \deprecated use isEmpty() */
+  EIGEN_DEVICE_FUNC inline bool isNull() const { return isEmpty(); }
+
+  /** \deprecated use setEmpty() */
+  EIGEN_DEVICE_FUNC inline void setNull() { setEmpty(); }
+
+  /** \returns true if the box is empty.
+   * \sa setEmpty */
+  EIGEN_DEVICE_FUNC inline bool isEmpty() const { return (m_min.array() > m_max.array()).any(); }
+
+  /** Makes \c *this an empty box.
+   * \sa isEmpty */
+  EIGEN_DEVICE_FUNC inline void setEmpty()
+  {
+    m_min.setConstant( ScalarTraits::highest() );
+    m_max.setConstant( ScalarTraits::lowest() );
+  }
+
+  /** \returns the minimal corner */
+  EIGEN_DEVICE_FUNC inline const VectorType& (min)() const { return m_min; }
+  /** \returns a non const reference to the minimal corner */
+  EIGEN_DEVICE_FUNC inline VectorType& (min)() { return m_min; }
+  /** \returns the maximal corner */
+  EIGEN_DEVICE_FUNC inline const VectorType& (max)() const { return m_max; }
+  /** \returns a non const reference to the maximal corner */
+  EIGEN_DEVICE_FUNC inline VectorType& (max)() { return m_max; }
+
+  /** \returns the center of the box */
+  EIGEN_DEVICE_FUNC inline const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(VectorTypeSum, RealScalar, quotient)
+  center() const
+  { return (m_min+m_max)/RealScalar(2); }
+
+  /** \returns the lengths of the sides of the bounding box.
+    * Note that this function does not get the same
+    * result for integral or floating scalar types: see
+    */
+  EIGEN_DEVICE_FUNC inline const CwiseBinaryOp< internal::scalar_difference_op<Scalar,Scalar>, const VectorType, const VectorType> sizes() const
+  { return m_max - m_min; }
+
+  /** \returns the volume of the bounding box */
+  EIGEN_DEVICE_FUNC inline Scalar volume() const
+  { return sizes().prod(); }
+
+  /** \returns an expression for the bounding box diagonal vector
+    * if the length of the diagonal is needed: diagonal().norm()
+    * will provide it.
+    */
+  EIGEN_DEVICE_FUNC inline CwiseBinaryOp< internal::scalar_difference_op<Scalar,Scalar>, const VectorType, const VectorType> diagonal() const
+  { return sizes(); }
+
+  /** \returns the vertex of the bounding box at the corner defined by
+    * the corner-id corner. It works only for a 1D, 2D or 3D bounding box.
+    * For 1D bounding boxes corners are named by 2 enum constants:
+    * BottomLeft and BottomRight.
+    * For 2D bounding boxes, corners are named by 4 enum constants:
+    * BottomLeft, BottomRight, TopLeft, TopRight.
+    * For 3D bounding boxes, the following names are added:
+    * BottomLeftCeil, BottomRightCeil, TopLeftCeil, TopRightCeil.
+    */
+  EIGEN_DEVICE_FUNC inline VectorType corner(CornerType corner) const
+  {
+    EIGEN_STATIC_ASSERT(_AmbientDim <= 3, THIS_METHOD_IS_ONLY_FOR_VECTORS_OF_A_SPECIFIC_SIZE);
+
+    VectorType res;
+
+    Index mult = 1;
+    for(Index d=0; d<dim(); ++d)
+    {
+      if( mult & corner ) res[d] = m_max[d];
+      else                res[d] = m_min[d];
+      mult *= 2;
+    }
+    return res;
+  }
+
+  /** \returns a random point inside the bounding box sampled with
+   * a uniform distribution */
+  EIGEN_DEVICE_FUNC inline VectorType sample() const
+  {
+    VectorType r(dim());
+    for(Index d=0; d<dim(); ++d)
+    {
+      if(!ScalarTraits::IsInteger)
+      {
+        r[d] = m_min[d] + (m_max[d]-m_min[d])
+             * internal::random<Scalar>(Scalar(0), Scalar(1));
+      }
+      else
+        r[d] = internal::random(m_min[d], m_max[d]);
+    }
+    return r;
+  }
+
+  /** \returns true if the point \a p is inside the box \c *this. */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline bool contains(const MatrixBase<Derived>& p) const
+  {
+    typename internal::nested_eval<Derived,2>::type p_n(p.derived());
+    return (m_min.array()<=p_n.array()).all() && (p_n.array()<=m_max.array()).all();
+  }
+
+  /** \returns true if the box \a b is entirely inside the box \c *this. */
+  EIGEN_DEVICE_FUNC inline bool contains(const AlignedBox& b) const
+  { return (m_min.array()<=(b.min)().array()).all() && ((b.max)().array()<=m_max.array()).all(); }
+
+  /** \returns true if the box \a b is intersecting the box \c *this.
+   * \sa intersection, clamp */
+  EIGEN_DEVICE_FUNC inline bool intersects(const AlignedBox& b) const
+  { return (m_min.array()<=(b.max)().array()).all() && ((b.min)().array()<=m_max.array()).all(); }
+
+  /** Extends \c *this such that it contains the point \a p and returns a reference to \c *this.
+   * \sa extend(const AlignedBox&) */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline AlignedBox& extend(const MatrixBase<Derived>& p)
+  {
+    typename internal::nested_eval<Derived,2>::type p_n(p.derived());
+    m_min = m_min.cwiseMin(p_n);
+    m_max = m_max.cwiseMax(p_n);
+    return *this;
+  }
+
+  /** Extends \c *this such that it contains the box \a b and returns a reference to \c *this.
+   * \sa merged, extend(const MatrixBase&) */
+  EIGEN_DEVICE_FUNC inline AlignedBox& extend(const AlignedBox& b)
+  {
+    m_min = m_min.cwiseMin(b.m_min);
+    m_max = m_max.cwiseMax(b.m_max);
+    return *this;
+  }
+
+  /** Clamps \c *this by the box \a b and returns a reference to \c *this.
+   * \note If the boxes don't intersect, the resulting box is empty.
+   * \sa intersection(), intersects() */
+  EIGEN_DEVICE_FUNC inline AlignedBox& clamp(const AlignedBox& b)
+  {
+    m_min = m_min.cwiseMax(b.m_min);
+    m_max = m_max.cwiseMin(b.m_max);
+    return *this;
+  }
+
+  /** Returns an AlignedBox that is the intersection of \a b and \c *this
+   * \note If the boxes don't intersect, the resulting box is empty.
+   * \sa intersects(), clamp, contains()  */
+  EIGEN_DEVICE_FUNC inline AlignedBox intersection(const AlignedBox& b) const
+  {return AlignedBox(m_min.cwiseMax(b.m_min), m_max.cwiseMin(b.m_max)); }
+
+  /** Returns an AlignedBox that is the union of \a b and \c *this.
+   * \note Merging with an empty box may result in a box bigger than \c *this. 
+   * \sa extend(const AlignedBox&) */
+  EIGEN_DEVICE_FUNC inline AlignedBox merged(const AlignedBox& b) const
+  { return AlignedBox(m_min.cwiseMin(b.m_min), m_max.cwiseMax(b.m_max)); }
+
+  /** Translate \c *this by the vector \a t and returns a reference to \c *this. */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline AlignedBox& translate(const MatrixBase<Derived>& a_t)
+  {
+    const typename internal::nested_eval<Derived,2>::type t(a_t.derived());
+    m_min += t;
+    m_max += t;
+    return *this;
+  }
+
+  /** \returns the squared distance between the point \a p and the box \c *this,
+    * and zero if \a p is inside the box.
+    * \sa exteriorDistance(const MatrixBase&), squaredExteriorDistance(const AlignedBox&)
+    */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline Scalar squaredExteriorDistance(const MatrixBase<Derived>& p) const;
+
+  /** \returns the squared distance between the boxes \a b and \c *this,
+    * and zero if the boxes intersect.
+    * \sa exteriorDistance(const AlignedBox&), squaredExteriorDistance(const MatrixBase&)
+    */
+  EIGEN_DEVICE_FUNC inline Scalar squaredExteriorDistance(const AlignedBox& b) const;
+
+  /** \returns the distance between the point \a p and the box \c *this,
+    * and zero if \a p is inside the box.
+    * \sa squaredExteriorDistance(const MatrixBase&), exteriorDistance(const AlignedBox&)
+    */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline NonInteger exteriorDistance(const MatrixBase<Derived>& p) const
+  { EIGEN_USING_STD_MATH(sqrt) return sqrt(NonInteger(squaredExteriorDistance(p))); }
+
+  /** \returns the distance between the boxes \a b and \c *this,
+    * and zero if the boxes intersect.
+    * \sa squaredExteriorDistance(const AlignedBox&), exteriorDistance(const MatrixBase&)
+    */
+  EIGEN_DEVICE_FUNC inline NonInteger exteriorDistance(const AlignedBox& b) const
+  { EIGEN_USING_STD_MATH(sqrt) return sqrt(NonInteger(squaredExteriorDistance(b))); }
+
+  /** \returns \c *this with scalar type casted to \a NewScalarType
+    *
+    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
+    * then this function smartly returns a const reference to \c *this.
+    */
+  template<typename NewScalarType>
+  EIGEN_DEVICE_FUNC inline typename internal::cast_return_type<AlignedBox,
+           AlignedBox<NewScalarType,AmbientDimAtCompileTime> >::type cast() const
+  {
+    return typename internal::cast_return_type<AlignedBox,
+                    AlignedBox<NewScalarType,AmbientDimAtCompileTime> >::type(*this);
+  }
+
+  /** Copy constructor with scalar type conversion */
+  template<typename OtherScalarType>
+  EIGEN_DEVICE_FUNC inline explicit AlignedBox(const AlignedBox<OtherScalarType,AmbientDimAtCompileTime>& other)
+  {
+    m_min = (other.min)().template cast<Scalar>();
+    m_max = (other.max)().template cast<Scalar>();
+  }
+
+  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
+    * determined by \a prec.
+    *
+    * \sa MatrixBase::isApprox() */
+  EIGEN_DEVICE_FUNC bool isApprox(const AlignedBox& other, const RealScalar& prec = ScalarTraits::dummy_precision()) const
+  { return m_min.isApprox(other.m_min, prec) && m_max.isApprox(other.m_max, prec); }
+
+protected:
+
+  VectorType m_min, m_max;
+};
+
+
+
+template<typename Scalar,int AmbientDim>
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline Scalar AlignedBox<Scalar,AmbientDim>::squaredExteriorDistance(const MatrixBase<Derived>& a_p) const
+{
+  typename internal::nested_eval<Derived,2*AmbientDim>::type p(a_p.derived());
+  Scalar dist2(0);
+  Scalar aux;
+  for (Index k=0; k<dim(); ++k)
+  {
+    if( m_min[k] > p[k] )
+    {
+      aux = m_min[k] - p[k];
+      dist2 += aux*aux;
+    }
+    else if( p[k] > m_max[k] )
+    {
+      aux = p[k] - m_max[k];
+      dist2 += aux*aux;
+    }
+  }
+  return dist2;
+}
+
+template<typename Scalar,int AmbientDim>
+EIGEN_DEVICE_FUNC inline Scalar AlignedBox<Scalar,AmbientDim>::squaredExteriorDistance(const AlignedBox& b) const
+{
+  Scalar dist2(0);
+  Scalar aux;
+  for (Index k=0; k<dim(); ++k)
+  {
+    if( m_min[k] > b.m_max[k] )
+    {
+      aux = m_min[k] - b.m_max[k];
+      dist2 += aux*aux;
+    }
+    else if( b.m_min[k] > m_max[k] )
+    {
+      aux = b.m_min[k] - m_max[k];
+      dist2 += aux*aux;
+    }
+  }
+  return dist2;
+}
+
+/** \defgroup alignedboxtypedefs Global aligned box typedefs
+  *
+  * \ingroup Geometry_Module
+  *
+  * Eigen defines several typedef shortcuts for most common aligned box types.
+  *
+  * The general patterns are the following:
+  *
+  * \c AlignedBoxSizeType where \c Size can be \c 1, \c 2,\c 3,\c 4 for fixed size boxes or \c X for dynamic size,
+  * and where \c Type can be \c i for integer, \c f for float, \c d for double.
+  *
+  * For example, \c AlignedBox3d is a fixed-size 3x3 aligned box type of doubles, and \c AlignedBoxXf is a dynamic-size aligned box of floats.
+  *
+  * \sa class AlignedBox
+  */
+
+#define EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, Size, SizeSuffix)    \
+/** \ingroup alignedboxtypedefs */                                 \
+typedef AlignedBox<Type, Size>   AlignedBox##SizeSuffix##TypeSuffix;
+
+#define EIGEN_MAKE_TYPEDEFS_ALL_SIZES(Type, TypeSuffix) \
+EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 1, 1) \
+EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 2, 2) \
+EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 3, 3) \
+EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 4, 4) \
+EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, Dynamic, X)
+
+EIGEN_MAKE_TYPEDEFS_ALL_SIZES(int,                  i)
+EIGEN_MAKE_TYPEDEFS_ALL_SIZES(float,                f)
+EIGEN_MAKE_TYPEDEFS_ALL_SIZES(double,               d)
+
+#undef EIGEN_MAKE_TYPEDEFS_ALL_SIZES
+#undef EIGEN_MAKE_TYPEDEFS
+
+} // end namespace Eigen
+
+#endif // EIGEN_ALIGNEDBOX_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/AngleAxis.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/AngleAxis.h
new file mode 100644
index 00000000..83ee1be4
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/AngleAxis.h
@@ -0,0 +1,247 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ANGLEAXIS_H
+#define EIGEN_ANGLEAXIS_H
+
+namespace Eigen { 
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \class AngleAxis
+  *
+  * \brief Represents a 3D rotation as a rotation angle around an arbitrary 3D axis
+  *
+  * \param _Scalar the scalar type, i.e., the type of the coefficients.
+  *
+  * \warning When setting up an AngleAxis object, the axis vector \b must \b be \b normalized.
+  *
+  * The following two typedefs are provided for convenience:
+  * \li \c AngleAxisf for \c float
+  * \li \c AngleAxisd for \c double
+  *
+  * Combined with MatrixBase::Unit{X,Y,Z}, AngleAxis can be used to easily
+  * mimic Euler-angles. Here is an example:
+  * \include AngleAxis_mimic_euler.cpp
+  * Output: \verbinclude AngleAxis_mimic_euler.out
+  *
+  * \note This class is not aimed to be used to store a rotation transformation,
+  * but rather to make easier the creation of other rotation (Quaternion, rotation Matrix)
+  * and transformation objects.
+  *
+  * \sa class Quaternion, class Transform, MatrixBase::UnitX()
+  */
+
+namespace internal {
+template<typename _Scalar> struct traits<AngleAxis<_Scalar> >
+{
+  typedef _Scalar Scalar;
+};
+}
+
+template<typename _Scalar>
+class AngleAxis : public RotationBase<AngleAxis<_Scalar>,3>
+{
+  typedef RotationBase<AngleAxis<_Scalar>,3> Base;
+
+public:
+
+  using Base::operator*;
+
+  enum { Dim = 3 };
+  /** the scalar type of the coefficients */
+  typedef _Scalar Scalar;
+  typedef Matrix<Scalar,3,3> Matrix3;
+  typedef Matrix<Scalar,3,1> Vector3;
+  typedef Quaternion<Scalar> QuaternionType;
+
+protected:
+
+  Vector3 m_axis;
+  Scalar m_angle;
+
+public:
+
+  /** Default constructor without initialization. */
+  EIGEN_DEVICE_FUNC AngleAxis() {}
+  /** Constructs and initialize the angle-axis rotation from an \a angle in radian
+    * and an \a axis which \b must \b be \b normalized.
+    *
+    * \warning If the \a axis vector is not normalized, then the angle-axis object
+    *          represents an invalid rotation. */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC 
+  inline AngleAxis(const Scalar& angle, const MatrixBase<Derived>& axis) : m_axis(axis), m_angle(angle) {}
+  /** Constructs and initialize the angle-axis rotation from a quaternion \a q.
+    * This function implicitly normalizes the quaternion \a q.
+    */
+  template<typename QuatDerived> 
+  EIGEN_DEVICE_FUNC inline explicit AngleAxis(const QuaternionBase<QuatDerived>& q) { *this = q; }
+  /** Constructs and initialize the angle-axis rotation from a 3x3 rotation matrix. */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline explicit AngleAxis(const MatrixBase<Derived>& m) { *this = m; }
+
+  /** \returns the value of the rotation angle in radian */
+  EIGEN_DEVICE_FUNC Scalar angle() const { return m_angle; }
+  /** \returns a read-write reference to the stored angle in radian */
+  EIGEN_DEVICE_FUNC Scalar& angle() { return m_angle; }
+
+  /** \returns the rotation axis */
+  EIGEN_DEVICE_FUNC const Vector3& axis() const { return m_axis; }
+  /** \returns a read-write reference to the stored rotation axis.
+    *
+    * \warning The rotation axis must remain a \b unit vector.
+    */
+  EIGEN_DEVICE_FUNC Vector3& axis() { return m_axis; }
+
+  /** Concatenates two rotations */
+  EIGEN_DEVICE_FUNC inline QuaternionType operator* (const AngleAxis& other) const
+  { return QuaternionType(*this) * QuaternionType(other); }
+
+  /** Concatenates two rotations */
+  EIGEN_DEVICE_FUNC inline QuaternionType operator* (const QuaternionType& other) const
+  { return QuaternionType(*this) * other; }
+
+  /** Concatenates two rotations */
+  friend EIGEN_DEVICE_FUNC inline QuaternionType operator* (const QuaternionType& a, const AngleAxis& b)
+  { return a * QuaternionType(b); }
+
+  /** \returns the inverse rotation, i.e., an angle-axis with opposite rotation angle */
+  EIGEN_DEVICE_FUNC AngleAxis inverse() const
+  { return AngleAxis(-m_angle, m_axis); }
+
+  template<class QuatDerived>
+  EIGEN_DEVICE_FUNC AngleAxis& operator=(const QuaternionBase<QuatDerived>& q);
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC AngleAxis& operator=(const MatrixBase<Derived>& m);
+
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC AngleAxis& fromRotationMatrix(const MatrixBase<Derived>& m);
+  EIGEN_DEVICE_FUNC Matrix3 toRotationMatrix(void) const;
+
+  /** \returns \c *this with scalar type casted to \a NewScalarType
+    *
+    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
+    * then this function smartly returns a const reference to \c *this.
+    */
+  template<typename NewScalarType>
+  EIGEN_DEVICE_FUNC inline typename internal::cast_return_type<AngleAxis,AngleAxis<NewScalarType> >::type cast() const
+  { return typename internal::cast_return_type<AngleAxis,AngleAxis<NewScalarType> >::type(*this); }
+
+  /** Copy constructor with scalar type conversion */
+  template<typename OtherScalarType>
+  EIGEN_DEVICE_FUNC inline explicit AngleAxis(const AngleAxis<OtherScalarType>& other)
+  {
+    m_axis = other.axis().template cast<Scalar>();
+    m_angle = Scalar(other.angle());
+  }
+
+  EIGEN_DEVICE_FUNC static inline const AngleAxis Identity() { return AngleAxis(Scalar(0), Vector3::UnitX()); }
+
+  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
+    * determined by \a prec.
+    *
+    * \sa MatrixBase::isApprox() */
+  EIGEN_DEVICE_FUNC bool isApprox(const AngleAxis& other, const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const
+  { return m_axis.isApprox(other.m_axis, prec) && internal::isApprox(m_angle,other.m_angle, prec); }
+};
+
+/** \ingroup Geometry_Module
+  * single precision angle-axis type */
+typedef AngleAxis<float> AngleAxisf;
+/** \ingroup Geometry_Module
+  * double precision angle-axis type */
+typedef AngleAxis<double> AngleAxisd;
+
+/** Set \c *this from a \b unit quaternion.
+  *
+  * The resulting axis is normalized, and the computed angle is in the [0,pi] range.
+  * 
+  * This function implicitly normalizes the quaternion \a q.
+  */
+template<typename Scalar>
+template<typename QuatDerived>
+EIGEN_DEVICE_FUNC AngleAxis<Scalar>& AngleAxis<Scalar>::operator=(const QuaternionBase<QuatDerived>& q)
+{
+  EIGEN_USING_STD_MATH(atan2)
+  EIGEN_USING_STD_MATH(abs)
+  Scalar n = q.vec().norm();
+  if(n<NumTraits<Scalar>::epsilon())
+    n = q.vec().stableNorm();
+
+  if (n != Scalar(0))
+  {
+    m_angle = Scalar(2)*atan2(n, abs(q.w()));
+    if(q.w() < Scalar(0))
+      n = -n;
+    m_axis  = q.vec() / n;
+  }
+  else
+  {
+    m_angle = Scalar(0);
+    m_axis << Scalar(1), Scalar(0), Scalar(0);
+  }
+  return *this;
+}
+
+/** Set \c *this from a 3x3 rotation matrix \a mat.
+  */
+template<typename Scalar>
+template<typename Derived>
+EIGEN_DEVICE_FUNC AngleAxis<Scalar>& AngleAxis<Scalar>::operator=(const MatrixBase<Derived>& mat)
+{
+  // Since a direct conversion would not be really faster,
+  // let's use the robust Quaternion implementation:
+  return *this = QuaternionType(mat);
+}
+
+/**
+* \brief Sets \c *this from a 3x3 rotation matrix.
+**/
+template<typename Scalar>
+template<typename Derived>
+EIGEN_DEVICE_FUNC AngleAxis<Scalar>& AngleAxis<Scalar>::fromRotationMatrix(const MatrixBase<Derived>& mat)
+{
+  return *this = QuaternionType(mat);
+}
+
+/** Constructs and \returns an equivalent 3x3 rotation matrix.
+  */
+template<typename Scalar>
+typename AngleAxis<Scalar>::Matrix3
+EIGEN_DEVICE_FUNC AngleAxis<Scalar>::toRotationMatrix(void) const
+{
+  EIGEN_USING_STD_MATH(sin)
+  EIGEN_USING_STD_MATH(cos)
+  Matrix3 res;
+  Vector3 sin_axis  = sin(m_angle) * m_axis;
+  Scalar c = cos(m_angle);
+  Vector3 cos1_axis = (Scalar(1)-c) * m_axis;
+
+  Scalar tmp;
+  tmp = cos1_axis.x() * m_axis.y();
+  res.coeffRef(0,1) = tmp - sin_axis.z();
+  res.coeffRef(1,0) = tmp + sin_axis.z();
+
+  tmp = cos1_axis.x() * m_axis.z();
+  res.coeffRef(0,2) = tmp + sin_axis.y();
+  res.coeffRef(2,0) = tmp - sin_axis.y();
+
+  tmp = cos1_axis.y() * m_axis.z();
+  res.coeffRef(1,2) = tmp - sin_axis.x();
+  res.coeffRef(2,1) = tmp + sin_axis.x();
+
+  res.diagonal() = (cos1_axis.cwiseProduct(m_axis)).array() + c;
+
+  return res;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_ANGLEAXIS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/EulerAngles.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/EulerAngles.h
new file mode 100644
index 00000000..c633268a
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/EulerAngles.h
@@ -0,0 +1,114 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_EULERANGLES_H
+#define EIGEN_EULERANGLES_H
+
+namespace Eigen { 
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  *
+  * \returns the Euler-angles of the rotation matrix \c *this using the convention defined by the triplet (\a a0,\a a1,\a a2)
+  *
+  * Each of the three parameters \a a0,\a a1,\a a2 represents the respective rotation axis as an integer in {0,1,2}.
+  * For instance, in:
+  * \code Vector3f ea = mat.eulerAngles(2, 0, 2); \endcode
+  * "2" represents the z axis and "0" the x axis, etc. The returned angles are such that
+  * we have the following equality:
+  * \code
+  * mat == AngleAxisf(ea[0], Vector3f::UnitZ())
+  *      * AngleAxisf(ea[1], Vector3f::UnitX())
+  *      * AngleAxisf(ea[2], Vector3f::UnitZ()); \endcode
+  * This corresponds to the right-multiply conventions (with right hand side frames).
+  * 
+  * The returned angles are in the ranges [0:pi]x[-pi:pi]x[-pi:pi].
+  * 
+  * \sa class AngleAxis
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline Matrix<typename MatrixBase<Derived>::Scalar,3,1>
+MatrixBase<Derived>::eulerAngles(Index a0, Index a1, Index a2) const
+{
+  EIGEN_USING_STD_MATH(atan2)
+  EIGEN_USING_STD_MATH(sin)
+  EIGEN_USING_STD_MATH(cos)
+  /* Implemented from Graphics Gems IV */
+  EIGEN_STATIC_ASSERT_MATRIX_SPECIFIC_SIZE(Derived,3,3)
+
+  Matrix<Scalar,3,1> res;
+  typedef Matrix<typename Derived::Scalar,2,1> Vector2;
+
+  const Index odd = ((a0+1)%3 == a1) ? 0 : 1;
+  const Index i = a0;
+  const Index j = (a0 + 1 + odd)%3;
+  const Index k = (a0 + 2 - odd)%3;
+  
+  if (a0==a2)
+  {
+    res[0] = atan2(coeff(j,i), coeff(k,i));
+    if((odd && res[0]<Scalar(0)) || ((!odd) && res[0]>Scalar(0)))
+    {
+      if(res[0] > Scalar(0)) {
+        res[0] -= Scalar(EIGEN_PI);
+      }
+      else {
+        res[0] += Scalar(EIGEN_PI);
+      }
+      Scalar s2 = Vector2(coeff(j,i), coeff(k,i)).norm();
+      res[1] = -atan2(s2, coeff(i,i));
+    }
+    else
+    {
+      Scalar s2 = Vector2(coeff(j,i), coeff(k,i)).norm();
+      res[1] = atan2(s2, coeff(i,i));
+    }
+    
+    // With a=(0,1,0), we have i=0; j=1; k=2, and after computing the first two angles,
+    // we can compute their respective rotation, and apply its inverse to M. Since the result must
+    // be a rotation around x, we have:
+    //
+    //  c2  s1.s2 c1.s2                   1  0   0 
+    //  0   c1    -s1       *    M    =   0  c3  s3
+    //  -s2 s1.c2 c1.c2                   0 -s3  c3
+    //
+    //  Thus:  m11.c1 - m21.s1 = c3  &   m12.c1 - m22.s1 = s3
+    
+    Scalar s1 = sin(res[0]);
+    Scalar c1 = cos(res[0]);
+    res[2] = atan2(c1*coeff(j,k)-s1*coeff(k,k), c1*coeff(j,j) - s1 * coeff(k,j));
+  } 
+  else
+  {
+    res[0] = atan2(coeff(j,k), coeff(k,k));
+    Scalar c2 = Vector2(coeff(i,i), coeff(i,j)).norm();
+    if((odd && res[0]<Scalar(0)) || ((!odd) && res[0]>Scalar(0))) {
+      if(res[0] > Scalar(0)) {
+        res[0] -= Scalar(EIGEN_PI);
+      }
+      else {
+        res[0] += Scalar(EIGEN_PI);
+      }
+      res[1] = atan2(-coeff(i,k), -c2);
+    }
+    else
+      res[1] = atan2(-coeff(i,k), c2);
+    Scalar s1 = sin(res[0]);
+    Scalar c1 = cos(res[0]);
+    res[2] = atan2(s1*coeff(k,i)-c1*coeff(j,i), c1*coeff(j,j) - s1 * coeff(k,j));
+  }
+  if (!odd)
+    res = -res;
+  
+  return res;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_EULERANGLES_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/Homogeneous.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/Homogeneous.h
new file mode 100644
index 00000000..5f0da1a9
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/Homogeneous.h
@@ -0,0 +1,497 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_HOMOGENEOUS_H
+#define EIGEN_HOMOGENEOUS_H
+
+namespace Eigen { 
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \class Homogeneous
+  *
+  * \brief Expression of one (or a set of) homogeneous vector(s)
+  *
+  * \param MatrixType the type of the object in which we are making homogeneous
+  *
+  * This class represents an expression of one (or a set of) homogeneous vector(s).
+  * It is the return type of MatrixBase::homogeneous() and most of the time
+  * this is the only way it is used.
+  *
+  * \sa MatrixBase::homogeneous()
+  */
+
+namespace internal {
+
+template<typename MatrixType,int Direction>
+struct traits<Homogeneous<MatrixType,Direction> >
+ : traits<MatrixType>
+{
+  typedef typename traits<MatrixType>::StorageKind StorageKind;
+  typedef typename ref_selector<MatrixType>::type MatrixTypeNested;
+  typedef typename remove_reference<MatrixTypeNested>::type _MatrixTypeNested;
+  enum {
+    RowsPlusOne = (MatrixType::RowsAtCompileTime != Dynamic) ?
+                  int(MatrixType::RowsAtCompileTime) + 1 : Dynamic,
+    ColsPlusOne = (MatrixType::ColsAtCompileTime != Dynamic) ?
+                  int(MatrixType::ColsAtCompileTime) + 1 : Dynamic,
+    RowsAtCompileTime = Direction==Vertical  ?  RowsPlusOne : MatrixType::RowsAtCompileTime,
+    ColsAtCompileTime = Direction==Horizontal ? ColsPlusOne : MatrixType::ColsAtCompileTime,
+    MaxRowsAtCompileTime = RowsAtCompileTime,
+    MaxColsAtCompileTime = ColsAtCompileTime,
+    TmpFlags = _MatrixTypeNested::Flags & HereditaryBits,
+    Flags = ColsAtCompileTime==1 ? (TmpFlags & ~RowMajorBit)
+          : RowsAtCompileTime==1 ? (TmpFlags | RowMajorBit)
+          : TmpFlags
+  };
+};
+
+template<typename MatrixType,typename Lhs> struct homogeneous_left_product_impl;
+template<typename MatrixType,typename Rhs> struct homogeneous_right_product_impl;
+
+} // end namespace internal
+
+template<typename MatrixType,int _Direction> class Homogeneous
+  : public MatrixBase<Homogeneous<MatrixType,_Direction> >, internal::no_assignment_operator
+{
+  public:
+
+    typedef MatrixType NestedExpression;
+    enum { Direction = _Direction };
+
+    typedef MatrixBase<Homogeneous> Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Homogeneous)
+
+    EIGEN_DEVICE_FUNC explicit inline Homogeneous(const MatrixType& matrix)
+      : m_matrix(matrix)
+    {}
+
+    EIGEN_DEVICE_FUNC inline Index rows() const { return m_matrix.rows() + (int(Direction)==Vertical   ? 1 : 0); }
+    EIGEN_DEVICE_FUNC inline Index cols() const { return m_matrix.cols() + (int(Direction)==Horizontal ? 1 : 0); }
+    
+    EIGEN_DEVICE_FUNC const NestedExpression& nestedExpression() const { return m_matrix; }
+
+    template<typename Rhs>
+    EIGEN_DEVICE_FUNC inline const Product<Homogeneous,Rhs>
+    operator* (const MatrixBase<Rhs>& rhs) const
+    {
+      eigen_assert(int(Direction)==Horizontal);
+      return Product<Homogeneous,Rhs>(*this,rhs.derived());
+    }
+
+    template<typename Lhs> friend
+    EIGEN_DEVICE_FUNC inline const Product<Lhs,Homogeneous>
+    operator* (const MatrixBase<Lhs>& lhs, const Homogeneous& rhs)
+    {
+      eigen_assert(int(Direction)==Vertical);
+      return Product<Lhs,Homogeneous>(lhs.derived(),rhs);
+    }
+
+    template<typename Scalar, int Dim, int Mode, int Options> friend
+    EIGEN_DEVICE_FUNC inline const Product<Transform<Scalar,Dim,Mode,Options>, Homogeneous >
+    operator* (const Transform<Scalar,Dim,Mode,Options>& lhs, const Homogeneous& rhs)
+    {
+      eigen_assert(int(Direction)==Vertical);
+      return Product<Transform<Scalar,Dim,Mode,Options>, Homogeneous>(lhs,rhs);
+    }
+
+    template<typename Func>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::result_of<Func(Scalar,Scalar)>::type
+    redux(const Func& func) const
+    {
+      return func(m_matrix.redux(func), Scalar(1));
+    }
+
+  protected:
+    typename MatrixType::Nested m_matrix;
+};
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \returns a vector expression that is one longer than the vector argument, with the value 1 symbolically appended as the last coefficient.
+  *
+  * This can be used to convert affine coordinates to homogeneous coordinates.
+  *
+  * \only_for_vectors
+  *
+  * Example: \include MatrixBase_homogeneous.cpp
+  * Output: \verbinclude MatrixBase_homogeneous.out
+  *
+  * \sa VectorwiseOp::homogeneous(), class Homogeneous
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline typename MatrixBase<Derived>::HomogeneousReturnType
+MatrixBase<Derived>::homogeneous() const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+  return HomogeneousReturnType(derived());
+}
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \returns an expression where the value 1 is symbolically appended as the final coefficient to each column (or row) of the matrix.
+  *
+  * This can be used to convert affine coordinates to homogeneous coordinates.
+  *
+  * Example: \include VectorwiseOp_homogeneous.cpp
+  * Output: \verbinclude VectorwiseOp_homogeneous.out
+  *
+  * \sa MatrixBase::homogeneous(), class Homogeneous */
+template<typename ExpressionType, int Direction>
+EIGEN_DEVICE_FUNC inline Homogeneous<ExpressionType,Direction>
+VectorwiseOp<ExpressionType,Direction>::homogeneous() const
+{
+  return HomogeneousReturnType(_expression());
+}
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \brief homogeneous normalization
+  *
+  * \returns a vector expression of the N-1 first coefficients of \c *this divided by that last coefficient.
+  *
+  * This can be used to convert homogeneous coordinates to affine coordinates.
+  *
+  * It is essentially a shortcut for:
+  * \code
+    this->head(this->size()-1)/this->coeff(this->size()-1);
+    \endcode
+  *
+  * Example: \include MatrixBase_hnormalized.cpp
+  * Output: \verbinclude MatrixBase_hnormalized.out
+  *
+  * \sa VectorwiseOp::hnormalized() */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline const typename MatrixBase<Derived>::HNormalizedReturnType
+MatrixBase<Derived>::hnormalized() const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+  return ConstStartMinusOne(derived(),0,0,
+    ColsAtCompileTime==1?size()-1:1,
+    ColsAtCompileTime==1?1:size()-1) / coeff(size()-1);
+}
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \brief column or row-wise homogeneous normalization
+  *
+  * \returns an expression of the first N-1 coefficients of each column (or row) of \c *this divided by the last coefficient of each column (or row).
+  *
+  * This can be used to convert homogeneous coordinates to affine coordinates.
+  *
+  * It is conceptually equivalent to calling MatrixBase::hnormalized() to each column (or row) of \c *this.
+  *
+  * Example: \include DirectionWise_hnormalized.cpp
+  * Output: \verbinclude DirectionWise_hnormalized.out
+  *
+  * \sa MatrixBase::hnormalized() */
+template<typename ExpressionType, int Direction>
+EIGEN_DEVICE_FUNC inline const typename VectorwiseOp<ExpressionType,Direction>::HNormalizedReturnType
+VectorwiseOp<ExpressionType,Direction>::hnormalized() const
+{
+  return HNormalized_Block(_expression(),0,0,
+      Direction==Vertical   ? _expression().rows()-1 : _expression().rows(),
+      Direction==Horizontal ? _expression().cols()-1 : _expression().cols()).cwiseQuotient(
+      Replicate<HNormalized_Factors,
+                Direction==Vertical   ? HNormalized_SizeMinusOne : 1,
+                Direction==Horizontal ? HNormalized_SizeMinusOne : 1>
+        (HNormalized_Factors(_expression(),
+          Direction==Vertical    ? _expression().rows()-1:0,
+          Direction==Horizontal  ? _expression().cols()-1:0,
+          Direction==Vertical    ? 1 : _expression().rows(),
+          Direction==Horizontal  ? 1 : _expression().cols()),
+         Direction==Vertical   ? _expression().rows()-1 : 1,
+         Direction==Horizontal ? _expression().cols()-1 : 1));
+}
+
+namespace internal {
+
+template<typename MatrixOrTransformType>
+struct take_matrix_for_product
+{
+  typedef MatrixOrTransformType type;
+  EIGEN_DEVICE_FUNC static const type& run(const type &x) { return x; }
+};
+
+template<typename Scalar, int Dim, int Mode,int Options>
+struct take_matrix_for_product<Transform<Scalar, Dim, Mode, Options> >
+{
+  typedef Transform<Scalar, Dim, Mode, Options> TransformType;
+  typedef typename internal::add_const<typename TransformType::ConstAffinePart>::type type;
+  EIGEN_DEVICE_FUNC static type run (const TransformType& x) { return x.affine(); }
+};
+
+template<typename Scalar, int Dim, int Options>
+struct take_matrix_for_product<Transform<Scalar, Dim, Projective, Options> >
+{
+  typedef Transform<Scalar, Dim, Projective, Options> TransformType;
+  typedef typename TransformType::MatrixType type;
+  EIGEN_DEVICE_FUNC static const type& run (const TransformType& x) { return x.matrix(); }
+};
+
+template<typename MatrixType,typename Lhs>
+struct traits<homogeneous_left_product_impl<Homogeneous<MatrixType,Vertical>,Lhs> >
+{
+  typedef typename take_matrix_for_product<Lhs>::type LhsMatrixType;
+  typedef typename remove_all<MatrixType>::type MatrixTypeCleaned;
+  typedef typename remove_all<LhsMatrixType>::type LhsMatrixTypeCleaned;
+  typedef typename make_proper_matrix_type<
+                 typename traits<MatrixTypeCleaned>::Scalar,
+                 LhsMatrixTypeCleaned::RowsAtCompileTime,
+                 MatrixTypeCleaned::ColsAtCompileTime,
+                 MatrixTypeCleaned::PlainObject::Options,
+                 LhsMatrixTypeCleaned::MaxRowsAtCompileTime,
+                 MatrixTypeCleaned::MaxColsAtCompileTime>::type ReturnType;
+};
+
+template<typename MatrixType,typename Lhs>
+struct homogeneous_left_product_impl<Homogeneous<MatrixType,Vertical>,Lhs>
+  : public ReturnByValue<homogeneous_left_product_impl<Homogeneous<MatrixType,Vertical>,Lhs> >
+{
+  typedef typename traits<homogeneous_left_product_impl>::LhsMatrixType LhsMatrixType;
+  typedef typename remove_all<LhsMatrixType>::type LhsMatrixTypeCleaned;
+  typedef typename remove_all<typename LhsMatrixTypeCleaned::Nested>::type LhsMatrixTypeNested;
+  EIGEN_DEVICE_FUNC homogeneous_left_product_impl(const Lhs& lhs, const MatrixType& rhs)
+    : m_lhs(take_matrix_for_product<Lhs>::run(lhs)),
+      m_rhs(rhs)
+  {}
+
+  EIGEN_DEVICE_FUNC inline Index rows() const { return m_lhs.rows(); }
+  EIGEN_DEVICE_FUNC inline Index cols() const { return m_rhs.cols(); }
+
+  template<typename Dest> EIGEN_DEVICE_FUNC void evalTo(Dest& dst) const
+  {
+    // FIXME investigate how to allow lazy evaluation of this product when possible
+    dst = Block<const LhsMatrixTypeNested,
+              LhsMatrixTypeNested::RowsAtCompileTime,
+              LhsMatrixTypeNested::ColsAtCompileTime==Dynamic?Dynamic:LhsMatrixTypeNested::ColsAtCompileTime-1>
+            (m_lhs,0,0,m_lhs.rows(),m_lhs.cols()-1) * m_rhs;
+    dst += m_lhs.col(m_lhs.cols()-1).rowwise()
+            .template replicate<MatrixType::ColsAtCompileTime>(m_rhs.cols());
+  }
+
+  typename LhsMatrixTypeCleaned::Nested m_lhs;
+  typename MatrixType::Nested m_rhs;
+};
+
+template<typename MatrixType,typename Rhs>
+struct traits<homogeneous_right_product_impl<Homogeneous<MatrixType,Horizontal>,Rhs> >
+{
+  typedef typename make_proper_matrix_type<typename traits<MatrixType>::Scalar,
+                 MatrixType::RowsAtCompileTime,
+                 Rhs::ColsAtCompileTime,
+                 MatrixType::PlainObject::Options,
+                 MatrixType::MaxRowsAtCompileTime,
+                 Rhs::MaxColsAtCompileTime>::type ReturnType;
+};
+
+template<typename MatrixType,typename Rhs>
+struct homogeneous_right_product_impl<Homogeneous<MatrixType,Horizontal>,Rhs>
+  : public ReturnByValue<homogeneous_right_product_impl<Homogeneous<MatrixType,Horizontal>,Rhs> >
+{
+  typedef typename remove_all<typename Rhs::Nested>::type RhsNested;
+  EIGEN_DEVICE_FUNC homogeneous_right_product_impl(const MatrixType& lhs, const Rhs& rhs)
+    : m_lhs(lhs), m_rhs(rhs)
+  {}
+
+  EIGEN_DEVICE_FUNC inline Index rows() const { return m_lhs.rows(); }
+  EIGEN_DEVICE_FUNC inline Index cols() const { return m_rhs.cols(); }
+
+  template<typename Dest> EIGEN_DEVICE_FUNC void evalTo(Dest& dst) const
+  {
+    // FIXME investigate how to allow lazy evaluation of this product when possible
+    dst = m_lhs * Block<const RhsNested,
+                        RhsNested::RowsAtCompileTime==Dynamic?Dynamic:RhsNested::RowsAtCompileTime-1,
+                        RhsNested::ColsAtCompileTime>
+            (m_rhs,0,0,m_rhs.rows()-1,m_rhs.cols());
+    dst += m_rhs.row(m_rhs.rows()-1).colwise()
+            .template replicate<MatrixType::RowsAtCompileTime>(m_lhs.rows());
+  }
+
+  typename MatrixType::Nested m_lhs;
+  typename Rhs::Nested m_rhs;
+};
+
+template<typename ArgType,int Direction>
+struct evaluator_traits<Homogeneous<ArgType,Direction> >
+{
+  typedef typename storage_kind_to_evaluator_kind<typename ArgType::StorageKind>::Kind Kind;
+  typedef HomogeneousShape Shape;  
+};
+
+template<> struct AssignmentKind<DenseShape,HomogeneousShape> { typedef Dense2Dense Kind; };
+
+
+template<typename ArgType,int Direction>
+struct unary_evaluator<Homogeneous<ArgType,Direction>, IndexBased>
+  : evaluator<typename Homogeneous<ArgType,Direction>::PlainObject >
+{
+  typedef Homogeneous<ArgType,Direction> XprType;
+  typedef typename XprType::PlainObject PlainObject;
+  typedef evaluator<PlainObject> Base;
+
+  EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& op)
+    : Base(), m_temp(op)
+  {
+    ::new (static_cast<Base*>(this)) Base(m_temp);
+  }
+
+protected:
+  PlainObject m_temp;
+};
+
+// dense = homogeneous
+template< typename DstXprType, typename ArgType, typename Scalar>
+struct Assignment<DstXprType, Homogeneous<ArgType,Vertical>, internal::assign_op<Scalar,typename ArgType::Scalar>, Dense2Dense>
+{
+  typedef Homogeneous<ArgType,Vertical> SrcXprType;
+  EIGEN_DEVICE_FUNC static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,typename ArgType::Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    dst.template topRows<ArgType::RowsAtCompileTime>(src.nestedExpression().rows()) = src.nestedExpression();
+    dst.row(dst.rows()-1).setOnes();
+  }
+};
+
+// dense = homogeneous
+template< typename DstXprType, typename ArgType, typename Scalar>
+struct Assignment<DstXprType, Homogeneous<ArgType,Horizontal>, internal::assign_op<Scalar,typename ArgType::Scalar>, Dense2Dense>
+{
+  typedef Homogeneous<ArgType,Horizontal> SrcXprType;
+  EIGEN_DEVICE_FUNC static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,typename ArgType::Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    dst.template leftCols<ArgType::ColsAtCompileTime>(src.nestedExpression().cols()) = src.nestedExpression();
+    dst.col(dst.cols()-1).setOnes();
+  }
+};
+
+template<typename LhsArg, typename Rhs, int ProductTag>
+struct generic_product_impl<Homogeneous<LhsArg,Horizontal>, Rhs, HomogeneousShape, DenseShape, ProductTag>
+{
+  template<typename Dest>
+  EIGEN_DEVICE_FUNC static void evalTo(Dest& dst, const Homogeneous<LhsArg,Horizontal>& lhs, const Rhs& rhs)
+  {
+    homogeneous_right_product_impl<Homogeneous<LhsArg,Horizontal>, Rhs>(lhs.nestedExpression(), rhs).evalTo(dst);
+  }
+};
+
+template<typename Lhs,typename Rhs>
+struct homogeneous_right_product_refactoring_helper
+{
+  enum {
+    Dim  = Lhs::ColsAtCompileTime,
+    Rows = Lhs::RowsAtCompileTime
+  };
+  typedef typename Rhs::template ConstNRowsBlockXpr<Dim>::Type          LinearBlockConst;
+  typedef typename remove_const<LinearBlockConst>::type                 LinearBlock;
+  typedef typename Rhs::ConstRowXpr                                     ConstantColumn;
+  typedef Replicate<const ConstantColumn,Rows,1>                        ConstantBlock;
+  typedef Product<Lhs,LinearBlock,LazyProduct>                          LinearProduct;
+  typedef CwiseBinaryOp<internal::scalar_sum_op<typename Lhs::Scalar,typename Rhs::Scalar>, const LinearProduct, const ConstantBlock> Xpr;
+};
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, LazyProduct>, ProductTag, HomogeneousShape, DenseShape>
+ : public evaluator<typename homogeneous_right_product_refactoring_helper<typename Lhs::NestedExpression,Rhs>::Xpr>
+{
+  typedef Product<Lhs, Rhs, LazyProduct> XprType;
+  typedef homogeneous_right_product_refactoring_helper<typename Lhs::NestedExpression,Rhs> helper;
+  typedef typename helper::ConstantBlock ConstantBlock;
+  typedef typename helper::Xpr RefactoredXpr;
+  typedef evaluator<RefactoredXpr> Base;
+  
+  EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
+    : Base(  xpr.lhs().nestedExpression() .lazyProduct(  xpr.rhs().template topRows<helper::Dim>(xpr.lhs().nestedExpression().cols()) )
+            + ConstantBlock(xpr.rhs().row(xpr.rhs().rows()-1),xpr.lhs().rows(), 1) )
+  {}
+};
+
+template<typename Lhs, typename RhsArg, int ProductTag>
+struct generic_product_impl<Lhs, Homogeneous<RhsArg,Vertical>, DenseShape, HomogeneousShape, ProductTag>
+{
+  template<typename Dest>
+  EIGEN_DEVICE_FUNC static void evalTo(Dest& dst, const Lhs& lhs, const Homogeneous<RhsArg,Vertical>& rhs)
+  {
+    homogeneous_left_product_impl<Homogeneous<RhsArg,Vertical>, Lhs>(lhs, rhs.nestedExpression()).evalTo(dst);
+  }
+};
+
+// TODO: the following specialization is to address a regression from 3.2 to 3.3
+// In the future, this path should be optimized.
+template<typename Lhs, typename RhsArg, int ProductTag>
+struct generic_product_impl<Lhs, Homogeneous<RhsArg,Vertical>, TriangularShape, HomogeneousShape, ProductTag>
+{
+  template<typename Dest>
+  static void evalTo(Dest& dst, const Lhs& lhs, const Homogeneous<RhsArg,Vertical>& rhs)
+  {
+    dst.noalias() = lhs * rhs.eval();
+  }
+};
+
+template<typename Lhs,typename Rhs>
+struct homogeneous_left_product_refactoring_helper
+{
+  enum {
+    Dim = Rhs::RowsAtCompileTime,
+    Cols = Rhs::ColsAtCompileTime
+  };
+  typedef typename Lhs::template ConstNColsBlockXpr<Dim>::Type          LinearBlockConst;
+  typedef typename remove_const<LinearBlockConst>::type                 LinearBlock;
+  typedef typename Lhs::ConstColXpr                                     ConstantColumn;
+  typedef Replicate<const ConstantColumn,1,Cols>                        ConstantBlock;
+  typedef Product<LinearBlock,Rhs,LazyProduct>                          LinearProduct;
+  typedef CwiseBinaryOp<internal::scalar_sum_op<typename Lhs::Scalar,typename Rhs::Scalar>, const LinearProduct, const ConstantBlock> Xpr;
+};
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, LazyProduct>, ProductTag, DenseShape, HomogeneousShape>
+ : public evaluator<typename homogeneous_left_product_refactoring_helper<Lhs,typename Rhs::NestedExpression>::Xpr>
+{
+  typedef Product<Lhs, Rhs, LazyProduct> XprType;
+  typedef homogeneous_left_product_refactoring_helper<Lhs,typename Rhs::NestedExpression> helper;
+  typedef typename helper::ConstantBlock ConstantBlock;
+  typedef typename helper::Xpr RefactoredXpr;
+  typedef evaluator<RefactoredXpr> Base;
+  
+  EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
+    : Base(   xpr.lhs().template leftCols<helper::Dim>(xpr.rhs().nestedExpression().rows()) .lazyProduct( xpr.rhs().nestedExpression() )
+            + ConstantBlock(xpr.lhs().col(xpr.lhs().cols()-1),1,xpr.rhs().cols()) )
+  {}
+};
+
+template<typename Scalar, int Dim, int Mode,int Options, typename RhsArg, int ProductTag>
+struct generic_product_impl<Transform<Scalar,Dim,Mode,Options>, Homogeneous<RhsArg,Vertical>, DenseShape, HomogeneousShape, ProductTag>
+{
+  typedef Transform<Scalar,Dim,Mode,Options> TransformType;
+  template<typename Dest>
+  EIGEN_DEVICE_FUNC static void evalTo(Dest& dst, const TransformType& lhs, const Homogeneous<RhsArg,Vertical>& rhs)
+  {
+    homogeneous_left_product_impl<Homogeneous<RhsArg,Vertical>, TransformType>(lhs, rhs.nestedExpression()).evalTo(dst);
+  }
+};
+
+template<typename ExpressionType, int Side, bool Transposed>
+struct permutation_matrix_product<ExpressionType, Side, Transposed, HomogeneousShape>
+  : public permutation_matrix_product<ExpressionType, Side, Transposed, DenseShape>
+{};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_HOMOGENEOUS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/Hyperplane.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/Hyperplane.h
new file mode 100644
index 00000000..05929b29
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/Hyperplane.h
@@ -0,0 +1,282 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_HYPERPLANE_H
+#define EIGEN_HYPERPLANE_H
+
+namespace Eigen { 
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \class Hyperplane
+  *
+  * \brief A hyperplane
+  *
+  * A hyperplane is an affine subspace of dimension n-1 in a space of dimension n.
+  * For example, a hyperplane in a plane is a line; a hyperplane in 3-space is a plane.
+  *
+  * \tparam _Scalar the scalar type, i.e., the type of the coefficients
+  * \tparam _AmbientDim the dimension of the ambient space, can be a compile time value or Dynamic.
+  *             Notice that the dimension of the hyperplane is _AmbientDim-1.
+  *
+  * This class represents an hyperplane as the zero set of the implicit equation
+  * \f$ n \cdot x + d = 0 \f$ where \f$ n \f$ is a unit normal vector of the plane (linear part)
+  * and \f$ d \f$ is the distance (offset) to the origin.
+  */
+template <typename _Scalar, int _AmbientDim, int _Options>
+class Hyperplane
+{
+public:
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim==Dynamic ? Dynamic : _AmbientDim+1)
+  enum {
+    AmbientDimAtCompileTime = _AmbientDim,
+    Options = _Options
+  };
+  typedef _Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+  typedef Matrix<Scalar,AmbientDimAtCompileTime,1> VectorType;
+  typedef Matrix<Scalar,Index(AmbientDimAtCompileTime)==Dynamic
+                        ? Dynamic
+                        : Index(AmbientDimAtCompileTime)+1,1,Options> Coefficients;
+  typedef Block<Coefficients,AmbientDimAtCompileTime,1> NormalReturnType;
+  typedef const Block<const Coefficients,AmbientDimAtCompileTime,1> ConstNormalReturnType;
+
+  /** Default constructor without initialization */
+  EIGEN_DEVICE_FUNC inline Hyperplane() {}
+  
+  template<int OtherOptions>
+  EIGEN_DEVICE_FUNC Hyperplane(const Hyperplane<Scalar,AmbientDimAtCompileTime,OtherOptions>& other)
+   : m_coeffs(other.coeffs())
+  {}
+
+  /** Constructs a dynamic-size hyperplane with \a _dim the dimension
+    * of the ambient space */
+  EIGEN_DEVICE_FUNC inline explicit Hyperplane(Index _dim) : m_coeffs(_dim+1) {}
+
+  /** Construct a plane from its normal \a n and a point \a e onto the plane.
+    * \warning the vector normal is assumed to be normalized.
+    */
+  EIGEN_DEVICE_FUNC inline Hyperplane(const VectorType& n, const VectorType& e)
+    : m_coeffs(n.size()+1)
+  {
+    normal() = n;
+    offset() = -n.dot(e);
+  }
+
+  /** Constructs a plane from its normal \a n and distance to the origin \a d
+    * such that the algebraic equation of the plane is \f$ n \cdot x + d = 0 \f$.
+    * \warning the vector normal is assumed to be normalized.
+    */
+  EIGEN_DEVICE_FUNC inline Hyperplane(const VectorType& n, const Scalar& d)
+    : m_coeffs(n.size()+1)
+  {
+    normal() = n;
+    offset() = d;
+  }
+
+  /** Constructs a hyperplane passing through the two points. If the dimension of the ambient space
+    * is greater than 2, then there isn't uniqueness, so an arbitrary choice is made.
+    */
+  EIGEN_DEVICE_FUNC static inline Hyperplane Through(const VectorType& p0, const VectorType& p1)
+  {
+    Hyperplane result(p0.size());
+    result.normal() = (p1 - p0).unitOrthogonal();
+    result.offset() = -p0.dot(result.normal());
+    return result;
+  }
+
+  /** Constructs a hyperplane passing through the three points. The dimension of the ambient space
+    * is required to be exactly 3.
+    */
+  EIGEN_DEVICE_FUNC static inline Hyperplane Through(const VectorType& p0, const VectorType& p1, const VectorType& p2)
+  {
+    EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(VectorType, 3)
+    Hyperplane result(p0.size());
+    VectorType v0(p2 - p0), v1(p1 - p0);
+    result.normal() = v0.cross(v1);
+    RealScalar norm = result.normal().norm();
+    if(norm <= v0.norm() * v1.norm() * NumTraits<RealScalar>::epsilon())
+    {
+      Matrix<Scalar,2,3> m; m << v0.transpose(), v1.transpose();
+      JacobiSVD<Matrix<Scalar,2,3> > svd(m, ComputeFullV);
+      result.normal() = svd.matrixV().col(2);
+    }
+    else
+      result.normal() /= norm;
+    result.offset() = -p0.dot(result.normal());
+    return result;
+  }
+
+  /** Constructs a hyperplane passing through the parametrized line \a parametrized.
+    * If the dimension of the ambient space is greater than 2, then there isn't uniqueness,
+    * so an arbitrary choice is made.
+    */
+  // FIXME to be consitent with the rest this could be implemented as a static Through function ??
+  EIGEN_DEVICE_FUNC explicit Hyperplane(const ParametrizedLine<Scalar, AmbientDimAtCompileTime>& parametrized)
+  {
+    normal() = parametrized.direction().unitOrthogonal();
+    offset() = -parametrized.origin().dot(normal());
+  }
+
+  EIGEN_DEVICE_FUNC ~Hyperplane() {}
+
+  /** \returns the dimension in which the plane holds */
+  EIGEN_DEVICE_FUNC inline Index dim() const { return AmbientDimAtCompileTime==Dynamic ? m_coeffs.size()-1 : Index(AmbientDimAtCompileTime); }
+
+  /** normalizes \c *this */
+  EIGEN_DEVICE_FUNC void normalize(void)
+  {
+    m_coeffs /= normal().norm();
+  }
+
+  /** \returns the signed distance between the plane \c *this and a point \a p.
+    * \sa absDistance()
+    */
+  EIGEN_DEVICE_FUNC inline Scalar signedDistance(const VectorType& p) const { return normal().dot(p) + offset(); }
+
+  /** \returns the absolute distance between the plane \c *this and a point \a p.
+    * \sa signedDistance()
+    */
+  EIGEN_DEVICE_FUNC inline Scalar absDistance(const VectorType& p) const { return numext::abs(signedDistance(p)); }
+
+  /** \returns the projection of a point \a p onto the plane \c *this.
+    */
+  EIGEN_DEVICE_FUNC inline VectorType projection(const VectorType& p) const { return p - signedDistance(p) * normal(); }
+
+  /** \returns a constant reference to the unit normal vector of the plane, which corresponds
+    * to the linear part of the implicit equation.
+    */
+  EIGEN_DEVICE_FUNC inline ConstNormalReturnType normal() const { return ConstNormalReturnType(m_coeffs,0,0,dim(),1); }
+
+  /** \returns a non-constant reference to the unit normal vector of the plane, which corresponds
+    * to the linear part of the implicit equation.
+    */
+  EIGEN_DEVICE_FUNC inline NormalReturnType normal() { return NormalReturnType(m_coeffs,0,0,dim(),1); }
+
+  /** \returns the distance to the origin, which is also the "constant term" of the implicit equation
+    * \warning the vector normal is assumed to be normalized.
+    */
+  EIGEN_DEVICE_FUNC inline const Scalar& offset() const { return m_coeffs.coeff(dim()); }
+
+  /** \returns a non-constant reference to the distance to the origin, which is also the constant part
+    * of the implicit equation */
+  EIGEN_DEVICE_FUNC inline Scalar& offset() { return m_coeffs(dim()); }
+
+  /** \returns a constant reference to the coefficients c_i of the plane equation:
+    * \f$ c_0*x_0 + ... + c_{d-1}*x_{d-1} + c_d = 0 \f$
+    */
+  EIGEN_DEVICE_FUNC inline const Coefficients& coeffs() const { return m_coeffs; }
+
+  /** \returns a non-constant reference to the coefficients c_i of the plane equation:
+    * \f$ c_0*x_0 + ... + c_{d-1}*x_{d-1} + c_d = 0 \f$
+    */
+  EIGEN_DEVICE_FUNC inline Coefficients& coeffs() { return m_coeffs; }
+
+  /** \returns the intersection of *this with \a other.
+    *
+    * \warning The ambient space must be a plane, i.e. have dimension 2, so that \c *this and \a other are lines.
+    *
+    * \note If \a other is approximately parallel to *this, this method will return any point on *this.
+    */
+  EIGEN_DEVICE_FUNC VectorType intersection(const Hyperplane& other) const
+  {
+    EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(VectorType, 2)
+    Scalar det = coeffs().coeff(0) * other.coeffs().coeff(1) - coeffs().coeff(1) * other.coeffs().coeff(0);
+    // since the line equations ax+by=c are normalized with a^2+b^2=1, the following tests
+    // whether the two lines are approximately parallel.
+    if(internal::isMuchSmallerThan(det, Scalar(1)))
+    {   // special case where the two lines are approximately parallel. Pick any point on the first line.
+        if(numext::abs(coeffs().coeff(1))>numext::abs(coeffs().coeff(0)))
+            return VectorType(coeffs().coeff(1), -coeffs().coeff(2)/coeffs().coeff(1)-coeffs().coeff(0));
+        else
+            return VectorType(-coeffs().coeff(2)/coeffs().coeff(0)-coeffs().coeff(1), coeffs().coeff(0));
+    }
+    else
+    {   // general case
+        Scalar invdet = Scalar(1) / det;
+        return VectorType(invdet*(coeffs().coeff(1)*other.coeffs().coeff(2)-other.coeffs().coeff(1)*coeffs().coeff(2)),
+                          invdet*(other.coeffs().coeff(0)*coeffs().coeff(2)-coeffs().coeff(0)*other.coeffs().coeff(2)));
+    }
+  }
+
+  /** Applies the transformation matrix \a mat to \c *this and returns a reference to \c *this.
+    *
+    * \param mat the Dim x Dim transformation matrix
+    * \param traits specifies whether the matrix \a mat represents an #Isometry
+    *               or a more generic #Affine transformation. The default is #Affine.
+    */
+  template<typename XprType>
+  EIGEN_DEVICE_FUNC inline Hyperplane& transform(const MatrixBase<XprType>& mat, TransformTraits traits = Affine)
+  {
+    if (traits==Affine)
+    {
+      normal() = mat.inverse().transpose() * normal();
+      m_coeffs /= normal().norm();
+    }
+    else if (traits==Isometry)
+      normal() = mat * normal();
+    else
+    {
+      eigen_assert(0 && "invalid traits value in Hyperplane::transform()");
+    }
+    return *this;
+  }
+
+  /** Applies the transformation \a t to \c *this and returns a reference to \c *this.
+    *
+    * \param t the transformation of dimension Dim
+    * \param traits specifies whether the transformation \a t represents an #Isometry
+    *               or a more generic #Affine transformation. The default is #Affine.
+    *               Other kind of transformations are not supported.
+    */
+  template<int TrOptions>
+  EIGEN_DEVICE_FUNC inline Hyperplane& transform(const Transform<Scalar,AmbientDimAtCompileTime,Affine,TrOptions>& t,
+                                TransformTraits traits = Affine)
+  {
+    transform(t.linear(), traits);
+    offset() -= normal().dot(t.translation());
+    return *this;
+  }
+
+  /** \returns \c *this with scalar type casted to \a NewScalarType
+    *
+    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
+    * then this function smartly returns a const reference to \c *this.
+    */
+  template<typename NewScalarType>
+  EIGEN_DEVICE_FUNC inline typename internal::cast_return_type<Hyperplane,
+           Hyperplane<NewScalarType,AmbientDimAtCompileTime,Options> >::type cast() const
+  {
+    return typename internal::cast_return_type<Hyperplane,
+                    Hyperplane<NewScalarType,AmbientDimAtCompileTime,Options> >::type(*this);
+  }
+
+  /** Copy constructor with scalar type conversion */
+  template<typename OtherScalarType,int OtherOptions>
+  EIGEN_DEVICE_FUNC inline explicit Hyperplane(const Hyperplane<OtherScalarType,AmbientDimAtCompileTime,OtherOptions>& other)
+  { m_coeffs = other.coeffs().template cast<Scalar>(); }
+
+  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
+    * determined by \a prec.
+    *
+    * \sa MatrixBase::isApprox() */
+  template<int OtherOptions>
+  EIGEN_DEVICE_FUNC bool isApprox(const Hyperplane<Scalar,AmbientDimAtCompileTime,OtherOptions>& other, const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const
+  { return m_coeffs.isApprox(other.m_coeffs, prec); }
+
+protected:
+
+  Coefficients m_coeffs;
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_HYPERPLANE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/OrthoMethods.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/OrthoMethods.h
new file mode 100644
index 00000000..a035e631
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/OrthoMethods.h
@@ -0,0 +1,234 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ORTHOMETHODS_H
+#define EIGEN_ORTHOMETHODS_H
+
+namespace Eigen { 
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \returns the cross product of \c *this and \a other
+  *
+  * Here is a very good explanation of cross-product: http://xkcd.com/199/
+  * 
+  * With complex numbers, the cross product is implemented as
+  * \f$ (\mathbf{a}+i\mathbf{b}) \times (\mathbf{c}+i\mathbf{d}) = (\mathbf{a} \times \mathbf{c} - \mathbf{b} \times \mathbf{d}) - i(\mathbf{a} \times \mathbf{d} - \mathbf{b} \times \mathbf{c})\f$
+  * 
+  * \sa MatrixBase::cross3()
+  */
+template<typename Derived>
+template<typename OtherDerived>
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+EIGEN_DEVICE_FUNC inline typename MatrixBase<Derived>::template cross_product_return_type<OtherDerived>::type
+#else
+inline typename MatrixBase<Derived>::PlainObject
+#endif
+MatrixBase<Derived>::cross(const MatrixBase<OtherDerived>& other) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Derived,3)
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,3)
+
+  // Note that there is no need for an expression here since the compiler
+  // optimize such a small temporary very well (even within a complex expression)
+  typename internal::nested_eval<Derived,2>::type lhs(derived());
+  typename internal::nested_eval<OtherDerived,2>::type rhs(other.derived());
+  return typename cross_product_return_type<OtherDerived>::type(
+    numext::conj(lhs.coeff(1) * rhs.coeff(2) - lhs.coeff(2) * rhs.coeff(1)),
+    numext::conj(lhs.coeff(2) * rhs.coeff(0) - lhs.coeff(0) * rhs.coeff(2)),
+    numext::conj(lhs.coeff(0) * rhs.coeff(1) - lhs.coeff(1) * rhs.coeff(0))
+  );
+}
+
+namespace internal {
+
+template< int Arch,typename VectorLhs,typename VectorRhs,
+          typename Scalar = typename VectorLhs::Scalar,
+          bool Vectorizable = bool((VectorLhs::Flags&VectorRhs::Flags)&PacketAccessBit)>
+struct cross3_impl {
+  EIGEN_DEVICE_FUNC static inline typename internal::plain_matrix_type<VectorLhs>::type
+  run(const VectorLhs& lhs, const VectorRhs& rhs)
+  {
+    return typename internal::plain_matrix_type<VectorLhs>::type(
+      numext::conj(lhs.coeff(1) * rhs.coeff(2) - lhs.coeff(2) * rhs.coeff(1)),
+      numext::conj(lhs.coeff(2) * rhs.coeff(0) - lhs.coeff(0) * rhs.coeff(2)),
+      numext::conj(lhs.coeff(0) * rhs.coeff(1) - lhs.coeff(1) * rhs.coeff(0)),
+      0
+    );
+  }
+};
+
+}
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \returns the cross product of \c *this and \a other using only the x, y, and z coefficients
+  *
+  * The size of \c *this and \a other must be four. This function is especially useful
+  * when using 4D vectors instead of 3D ones to get advantage of SSE/AltiVec vectorization.
+  *
+  * \sa MatrixBase::cross()
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC inline typename MatrixBase<Derived>::PlainObject
+MatrixBase<Derived>::cross3(const MatrixBase<OtherDerived>& other) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Derived,4)
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,4)
+
+  typedef typename internal::nested_eval<Derived,2>::type DerivedNested;
+  typedef typename internal::nested_eval<OtherDerived,2>::type OtherDerivedNested;
+  DerivedNested lhs(derived());
+  OtherDerivedNested rhs(other.derived());
+
+  return internal::cross3_impl<Architecture::Target,
+                        typename internal::remove_all<DerivedNested>::type,
+                        typename internal::remove_all<OtherDerivedNested>::type>::run(lhs,rhs);
+}
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \returns a matrix expression of the cross product of each column or row
+  * of the referenced expression with the \a other vector.
+  *
+  * The referenced matrix must have one dimension equal to 3.
+  * The result matrix has the same dimensions than the referenced one.
+  *
+  * \sa MatrixBase::cross() */
+template<typename ExpressionType, int Direction>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC 
+const typename VectorwiseOp<ExpressionType,Direction>::CrossReturnType
+VectorwiseOp<ExpressionType,Direction>::cross(const MatrixBase<OtherDerived>& other) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,3)
+  EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename OtherDerived::Scalar>::value),
+    YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+  
+  typename internal::nested_eval<ExpressionType,2>::type mat(_expression());
+  typename internal::nested_eval<OtherDerived,2>::type vec(other.derived());
+
+  CrossReturnType res(_expression().rows(),_expression().cols());
+  if(Direction==Vertical)
+  {
+    eigen_assert(CrossReturnType::RowsAtCompileTime==3 && "the matrix must have exactly 3 rows");
+    res.row(0) = (mat.row(1) * vec.coeff(2) - mat.row(2) * vec.coeff(1)).conjugate();
+    res.row(1) = (mat.row(2) * vec.coeff(0) - mat.row(0) * vec.coeff(2)).conjugate();
+    res.row(2) = (mat.row(0) * vec.coeff(1) - mat.row(1) * vec.coeff(0)).conjugate();
+  }
+  else
+  {
+    eigen_assert(CrossReturnType::ColsAtCompileTime==3 && "the matrix must have exactly 3 columns");
+    res.col(0) = (mat.col(1) * vec.coeff(2) - mat.col(2) * vec.coeff(1)).conjugate();
+    res.col(1) = (mat.col(2) * vec.coeff(0) - mat.col(0) * vec.coeff(2)).conjugate();
+    res.col(2) = (mat.col(0) * vec.coeff(1) - mat.col(1) * vec.coeff(0)).conjugate();
+  }
+  return res;
+}
+
+namespace internal {
+
+template<typename Derived, int Size = Derived::SizeAtCompileTime>
+struct unitOrthogonal_selector
+{
+  typedef typename plain_matrix_type<Derived>::type VectorType;
+  typedef typename traits<Derived>::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar,2,1> Vector2;
+  EIGEN_DEVICE_FUNC
+  static inline VectorType run(const Derived& src)
+  {
+    VectorType perp = VectorType::Zero(src.size());
+    Index maxi = 0;
+    Index sndi = 0;
+    src.cwiseAbs().maxCoeff(&maxi);
+    if (maxi==0)
+      sndi = 1;
+    RealScalar invnm = RealScalar(1)/(Vector2() << src.coeff(sndi),src.coeff(maxi)).finished().norm();
+    perp.coeffRef(maxi) = -numext::conj(src.coeff(sndi)) * invnm;
+    perp.coeffRef(sndi) =  numext::conj(src.coeff(maxi)) * invnm;
+
+    return perp;
+   }
+};
+
+template<typename Derived>
+struct unitOrthogonal_selector<Derived,3>
+{
+  typedef typename plain_matrix_type<Derived>::type VectorType;
+  typedef typename traits<Derived>::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline VectorType run(const Derived& src)
+  {
+    VectorType perp;
+    /* Let us compute the crossed product of *this with a vector
+     * that is not too close to being colinear to *this.
+     */
+
+    /* unless the x and y coords are both close to zero, we can
+     * simply take ( -y, x, 0 ) and normalize it.
+     */
+    if((!isMuchSmallerThan(src.x(), src.z()))
+    || (!isMuchSmallerThan(src.y(), src.z())))
+    {
+      RealScalar invnm = RealScalar(1)/src.template head<2>().norm();
+      perp.coeffRef(0) = -numext::conj(src.y())*invnm;
+      perp.coeffRef(1) = numext::conj(src.x())*invnm;
+      perp.coeffRef(2) = 0;
+    }
+    /* if both x and y are close to zero, then the vector is close
+     * to the z-axis, so it's far from colinear to the x-axis for instance.
+     * So we take the crossed product with (1,0,0) and normalize it.
+     */
+    else
+    {
+      RealScalar invnm = RealScalar(1)/src.template tail<2>().norm();
+      perp.coeffRef(0) = 0;
+      perp.coeffRef(1) = -numext::conj(src.z())*invnm;
+      perp.coeffRef(2) = numext::conj(src.y())*invnm;
+    }
+
+    return perp;
+   }
+};
+
+template<typename Derived>
+struct unitOrthogonal_selector<Derived,2>
+{
+  typedef typename plain_matrix_type<Derived>::type VectorType;
+  EIGEN_DEVICE_FUNC
+  static inline VectorType run(const Derived& src)
+  { return VectorType(-numext::conj(src.y()), numext::conj(src.x())).normalized(); }
+};
+
+} // end namespace internal
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \returns a unit vector which is orthogonal to \c *this
+  *
+  * The size of \c *this must be at least 2. If the size is exactly 2,
+  * then the returned vector is a counter clock wise rotation of \c *this, i.e., (-y,x).normalized().
+  *
+  * \sa cross()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC typename MatrixBase<Derived>::PlainObject
+MatrixBase<Derived>::unitOrthogonal() const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return internal::unitOrthogonal_selector<Derived>::run(derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_ORTHOMETHODS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/ParametrizedLine.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/ParametrizedLine.h
new file mode 100644
index 00000000..3929ca87
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/ParametrizedLine.h
@@ -0,0 +1,232 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PARAMETRIZEDLINE_H
+#define EIGEN_PARAMETRIZEDLINE_H
+
+namespace Eigen { 
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \class ParametrizedLine
+  *
+  * \brief A parametrized line
+  *
+  * A parametrized line is defined by an origin point \f$ \mathbf{o} \f$ and a unit
+  * direction vector \f$ \mathbf{d} \f$ such that the line corresponds to
+  * the set \f$ l(t) = \mathbf{o} + t \mathbf{d} \f$, \f$ t \in \mathbf{R} \f$.
+  *
+  * \tparam _Scalar the scalar type, i.e., the type of the coefficients
+  * \tparam _AmbientDim the dimension of the ambient space, can be a compile time value or Dynamic.
+  */
+template <typename _Scalar, int _AmbientDim, int _Options>
+class ParametrizedLine
+{
+public:
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim)
+  enum {
+    AmbientDimAtCompileTime = _AmbientDim,
+    Options = _Options
+  };
+  typedef _Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+  typedef Matrix<Scalar,AmbientDimAtCompileTime,1,Options> VectorType;
+
+  /** Default constructor without initialization */
+  EIGEN_DEVICE_FUNC inline ParametrizedLine() {}
+  
+  template<int OtherOptions>
+  EIGEN_DEVICE_FUNC ParametrizedLine(const ParametrizedLine<Scalar,AmbientDimAtCompileTime,OtherOptions>& other)
+   : m_origin(other.origin()), m_direction(other.direction())
+  {}
+
+  /** Constructs a dynamic-size line with \a _dim the dimension
+    * of the ambient space */
+  EIGEN_DEVICE_FUNC inline explicit ParametrizedLine(Index _dim) : m_origin(_dim), m_direction(_dim) {}
+
+  /** Initializes a parametrized line of direction \a direction and origin \a origin.
+    * \warning the vector direction is assumed to be normalized.
+    */
+  EIGEN_DEVICE_FUNC ParametrizedLine(const VectorType& origin, const VectorType& direction)
+    : m_origin(origin), m_direction(direction) {}
+
+  template <int OtherOptions>
+  EIGEN_DEVICE_FUNC explicit ParametrizedLine(const Hyperplane<_Scalar, _AmbientDim, OtherOptions>& hyperplane);
+
+  /** Constructs a parametrized line going from \a p0 to \a p1. */
+  EIGEN_DEVICE_FUNC static inline ParametrizedLine Through(const VectorType& p0, const VectorType& p1)
+  { return ParametrizedLine(p0, (p1-p0).normalized()); }
+
+  EIGEN_DEVICE_FUNC ~ParametrizedLine() {}
+
+  /** \returns the dimension in which the line holds */
+  EIGEN_DEVICE_FUNC inline Index dim() const { return m_direction.size(); }
+
+  EIGEN_DEVICE_FUNC const VectorType& origin() const { return m_origin; }
+  EIGEN_DEVICE_FUNC VectorType& origin() { return m_origin; }
+
+  EIGEN_DEVICE_FUNC const VectorType& direction() const { return m_direction; }
+  EIGEN_DEVICE_FUNC VectorType& direction() { return m_direction; }
+
+  /** \returns the squared distance of a point \a p to its projection onto the line \c *this.
+    * \sa distance()
+    */
+  EIGEN_DEVICE_FUNC RealScalar squaredDistance(const VectorType& p) const
+  {
+    VectorType diff = p - origin();
+    return (diff - direction().dot(diff) * direction()).squaredNorm();
+  }
+  /** \returns the distance of a point \a p to its projection onto the line \c *this.
+    * \sa squaredDistance()
+    */
+  EIGEN_DEVICE_FUNC RealScalar distance(const VectorType& p) const { EIGEN_USING_STD_MATH(sqrt) return sqrt(squaredDistance(p)); }
+
+  /** \returns the projection of a point \a p onto the line \c *this. */
+  EIGEN_DEVICE_FUNC VectorType projection(const VectorType& p) const
+  { return origin() + direction().dot(p-origin()) * direction(); }
+
+  EIGEN_DEVICE_FUNC VectorType pointAt(const Scalar& t) const;
+  
+  template <int OtherOptions>
+  EIGEN_DEVICE_FUNC Scalar intersectionParameter(const Hyperplane<_Scalar, _AmbientDim, OtherOptions>& hyperplane) const;
+ 
+  template <int OtherOptions>
+  EIGEN_DEVICE_FUNC Scalar intersection(const Hyperplane<_Scalar, _AmbientDim, OtherOptions>& hyperplane) const;
+  
+  template <int OtherOptions>
+  EIGEN_DEVICE_FUNC VectorType intersectionPoint(const Hyperplane<_Scalar, _AmbientDim, OtherOptions>& hyperplane) const;
+
+  /** Applies the transformation matrix \a mat to \c *this and returns a reference to \c *this.
+    *
+    * \param mat the Dim x Dim transformation matrix
+    * \param traits specifies whether the matrix \a mat represents an #Isometry
+    *               or a more generic #Affine transformation. The default is #Affine.
+    */
+  template<typename XprType>
+  EIGEN_DEVICE_FUNC inline ParametrizedLine& transform(const MatrixBase<XprType>& mat, TransformTraits traits = Affine)
+  {
+    if (traits==Affine)
+      direction() = (mat * direction()).normalized();
+    else if (traits==Isometry)
+      direction() = mat * direction();
+    else
+    {
+      eigen_assert(0 && "invalid traits value in ParametrizedLine::transform()");
+    }
+    origin() = mat * origin();
+    return *this;
+  }
+
+  /** Applies the transformation \a t to \c *this and returns a reference to \c *this.
+    *
+    * \param t the transformation of dimension Dim
+    * \param traits specifies whether the transformation \a t represents an #Isometry
+    *               or a more generic #Affine transformation. The default is #Affine.
+    *               Other kind of transformations are not supported.
+    */
+  template<int TrOptions>
+  EIGEN_DEVICE_FUNC inline ParametrizedLine& transform(const Transform<Scalar,AmbientDimAtCompileTime,Affine,TrOptions>& t,
+                                                       TransformTraits traits = Affine)
+  {
+    transform(t.linear(), traits);
+    origin() += t.translation();
+    return *this;
+  }
+
+/** \returns \c *this with scalar type casted to \a NewScalarType
+    *
+    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
+    * then this function smartly returns a const reference to \c *this.
+    */
+  template<typename NewScalarType>
+  EIGEN_DEVICE_FUNC inline typename internal::cast_return_type<ParametrizedLine,
+           ParametrizedLine<NewScalarType,AmbientDimAtCompileTime,Options> >::type cast() const
+  {
+    return typename internal::cast_return_type<ParametrizedLine,
+                    ParametrizedLine<NewScalarType,AmbientDimAtCompileTime,Options> >::type(*this);
+  }
+
+  /** Copy constructor with scalar type conversion */
+  template<typename OtherScalarType,int OtherOptions>
+  EIGEN_DEVICE_FUNC inline explicit ParametrizedLine(const ParametrizedLine<OtherScalarType,AmbientDimAtCompileTime,OtherOptions>& other)
+  {
+    m_origin = other.origin().template cast<Scalar>();
+    m_direction = other.direction().template cast<Scalar>();
+  }
+
+  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
+    * determined by \a prec.
+    *
+    * \sa MatrixBase::isApprox() */
+  EIGEN_DEVICE_FUNC bool isApprox(const ParametrizedLine& other, const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const
+  { return m_origin.isApprox(other.m_origin, prec) && m_direction.isApprox(other.m_direction, prec); }
+
+protected:
+
+  VectorType m_origin, m_direction;
+};
+
+/** Constructs a parametrized line from a 2D hyperplane
+  *
+  * \warning the ambient space must have dimension 2 such that the hyperplane actually describes a line
+  */
+template <typename _Scalar, int _AmbientDim, int _Options>
+template <int OtherOptions>
+EIGEN_DEVICE_FUNC inline ParametrizedLine<_Scalar, _AmbientDim,_Options>::ParametrizedLine(const Hyperplane<_Scalar, _AmbientDim,OtherOptions>& hyperplane)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(VectorType, 2)
+  direction() = hyperplane.normal().unitOrthogonal();
+  origin() = -hyperplane.normal()*hyperplane.offset();
+}
+
+/** \returns the point at \a t along this line
+  */
+template <typename _Scalar, int _AmbientDim, int _Options>
+EIGEN_DEVICE_FUNC inline typename ParametrizedLine<_Scalar, _AmbientDim,_Options>::VectorType
+ParametrizedLine<_Scalar, _AmbientDim,_Options>::pointAt(const _Scalar& t) const
+{
+  return origin() + (direction()*t); 
+}
+
+/** \returns the parameter value of the intersection between \c *this and the given \a hyperplane
+  */
+template <typename _Scalar, int _AmbientDim, int _Options>
+template <int OtherOptions>
+EIGEN_DEVICE_FUNC inline _Scalar ParametrizedLine<_Scalar, _AmbientDim,_Options>::intersectionParameter(const Hyperplane<_Scalar, _AmbientDim, OtherOptions>& hyperplane) const
+{
+  return -(hyperplane.offset()+hyperplane.normal().dot(origin()))
+          / hyperplane.normal().dot(direction());
+}
+
+
+/** \deprecated use intersectionParameter()
+  * \returns the parameter value of the intersection between \c *this and the given \a hyperplane
+  */
+template <typename _Scalar, int _AmbientDim, int _Options>
+template <int OtherOptions>
+EIGEN_DEVICE_FUNC inline _Scalar ParametrizedLine<_Scalar, _AmbientDim,_Options>::intersection(const Hyperplane<_Scalar, _AmbientDim, OtherOptions>& hyperplane) const
+{
+  return intersectionParameter(hyperplane);
+}
+
+/** \returns the point of the intersection between \c *this and the given hyperplane
+  */
+template <typename _Scalar, int _AmbientDim, int _Options>
+template <int OtherOptions>
+EIGEN_DEVICE_FUNC inline typename ParametrizedLine<_Scalar, _AmbientDim,_Options>::VectorType
+ParametrizedLine<_Scalar, _AmbientDim,_Options>::intersectionPoint(const Hyperplane<_Scalar, _AmbientDim, OtherOptions>& hyperplane) const
+{
+  return pointAt(intersectionParameter(hyperplane));
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_PARAMETRIZEDLINE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/Quaternion.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/Quaternion.h
new file mode 100644
index 00000000..c3fd8c3e
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/Quaternion.h
@@ -0,0 +1,814 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Mathieu Gautier <mathieu.gautier@cea.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_QUATERNION_H
+#define EIGEN_QUATERNION_H
+namespace Eigen { 
+
+
+/***************************************************************************
+* Definition of QuaternionBase<Derived>
+* The implementation is at the end of the file
+***************************************************************************/
+
+namespace internal {
+template<typename Other,
+         int OtherRows=Other::RowsAtCompileTime,
+         int OtherCols=Other::ColsAtCompileTime>
+struct quaternionbase_assign_impl;
+}
+
+/** \geometry_module \ingroup Geometry_Module
+  * \class QuaternionBase
+  * \brief Base class for quaternion expressions
+  * \tparam Derived derived type (CRTP)
+  * \sa class Quaternion
+  */
+template<class Derived>
+class QuaternionBase : public RotationBase<Derived, 3>
+{
+ public:
+  typedef RotationBase<Derived, 3> Base;
+
+  using Base::operator*;
+  using Base::derived;
+
+  typedef typename internal::traits<Derived>::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef typename internal::traits<Derived>::Coefficients Coefficients;
+  typedef typename Coefficients::CoeffReturnType CoeffReturnType;
+  typedef typename internal::conditional<bool(internal::traits<Derived>::Flags&LvalueBit),
+                                        Scalar&, CoeffReturnType>::type NonConstCoeffReturnType;
+
+
+  enum {
+    Flags = Eigen::internal::traits<Derived>::Flags
+  };
+
+ // typedef typename Matrix<Scalar,4,1> Coefficients;
+  /** the type of a 3D vector */
+  typedef Matrix<Scalar,3,1> Vector3;
+  /** the equivalent rotation matrix type */
+  typedef Matrix<Scalar,3,3> Matrix3;
+  /** the equivalent angle-axis type */
+  typedef AngleAxis<Scalar> AngleAxisType;
+
+
+
+  /** \returns the \c x coefficient */
+  EIGEN_DEVICE_FUNC inline CoeffReturnType x() const { return this->derived().coeffs().coeff(0); }
+  /** \returns the \c y coefficient */
+  EIGEN_DEVICE_FUNC inline CoeffReturnType y() const { return this->derived().coeffs().coeff(1); }
+  /** \returns the \c z coefficient */
+  EIGEN_DEVICE_FUNC inline CoeffReturnType z() const { return this->derived().coeffs().coeff(2); }
+  /** \returns the \c w coefficient */
+  EIGEN_DEVICE_FUNC inline CoeffReturnType w() const { return this->derived().coeffs().coeff(3); }
+
+  /** \returns a reference to the \c x coefficient (if Derived is a non-const lvalue) */
+  EIGEN_DEVICE_FUNC inline NonConstCoeffReturnType x() { return this->derived().coeffs().x(); }
+  /** \returns a reference to the \c y coefficient (if Derived is a non-const lvalue) */
+  EIGEN_DEVICE_FUNC inline NonConstCoeffReturnType y() { return this->derived().coeffs().y(); }
+  /** \returns a reference to the \c z coefficient (if Derived is a non-const lvalue) */
+  EIGEN_DEVICE_FUNC inline NonConstCoeffReturnType z() { return this->derived().coeffs().z(); }
+  /** \returns a reference to the \c w coefficient (if Derived is a non-const lvalue) */
+  EIGEN_DEVICE_FUNC inline NonConstCoeffReturnType w() { return this->derived().coeffs().w(); }
+
+  /** \returns a read-only vector expression of the imaginary part (x,y,z) */
+  EIGEN_DEVICE_FUNC inline const VectorBlock<const Coefficients,3> vec() const { return coeffs().template head<3>(); }
+
+  /** \returns a vector expression of the imaginary part (x,y,z) */
+  EIGEN_DEVICE_FUNC inline VectorBlock<Coefficients,3> vec() { return coeffs().template head<3>(); }
+
+  /** \returns a read-only vector expression of the coefficients (x,y,z,w) */
+  EIGEN_DEVICE_FUNC inline const typename internal::traits<Derived>::Coefficients& coeffs() const { return derived().coeffs(); }
+
+  /** \returns a vector expression of the coefficients (x,y,z,w) */
+  EIGEN_DEVICE_FUNC inline typename internal::traits<Derived>::Coefficients& coeffs() { return derived().coeffs(); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE QuaternionBase<Derived>& operator=(const QuaternionBase<Derived>& other);
+  template<class OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator=(const QuaternionBase<OtherDerived>& other);
+
+// disabled this copy operator as it is giving very strange compilation errors when compiling
+// test_stdvector with GCC 4.4.2. This looks like a GCC bug though, so feel free to re-enable it if it's
+// useful; however notice that we already have the templated operator= above and e.g. in MatrixBase
+// we didn't have to add, in addition to templated operator=, such a non-templated copy operator.
+//  Derived& operator=(const QuaternionBase& other)
+//  { return operator=<Derived>(other); }
+
+  EIGEN_DEVICE_FUNC Derived& operator=(const AngleAxisType& aa);
+  template<class OtherDerived> EIGEN_DEVICE_FUNC Derived& operator=(const MatrixBase<OtherDerived>& m);
+
+  /** \returns a quaternion representing an identity rotation
+    * \sa MatrixBase::Identity()
+    */
+  EIGEN_DEVICE_FUNC static inline Quaternion<Scalar> Identity() { return Quaternion<Scalar>(Scalar(1), Scalar(0), Scalar(0), Scalar(0)); }
+
+  /** \sa QuaternionBase::Identity(), MatrixBase::setIdentity()
+    */
+  EIGEN_DEVICE_FUNC inline QuaternionBase& setIdentity() { coeffs() << Scalar(0), Scalar(0), Scalar(0), Scalar(1); return *this; }
+
+  /** \returns the squared norm of the quaternion's coefficients
+    * \sa QuaternionBase::norm(), MatrixBase::squaredNorm()
+    */
+  EIGEN_DEVICE_FUNC inline Scalar squaredNorm() const { return coeffs().squaredNorm(); }
+
+  /** \returns the norm of the quaternion's coefficients
+    * \sa QuaternionBase::squaredNorm(), MatrixBase::norm()
+    */
+  EIGEN_DEVICE_FUNC inline Scalar norm() const { return coeffs().norm(); }
+
+  /** Normalizes the quaternion \c *this
+    * \sa normalized(), MatrixBase::normalize() */
+  EIGEN_DEVICE_FUNC inline void normalize() { coeffs().normalize(); }
+  /** \returns a normalized copy of \c *this
+    * \sa normalize(), MatrixBase::normalized() */
+  EIGEN_DEVICE_FUNC inline Quaternion<Scalar> normalized() const { return Quaternion<Scalar>(coeffs().normalized()); }
+
+    /** \returns the dot product of \c *this and \a other
+    * Geometrically speaking, the dot product of two unit quaternions
+    * corresponds to the cosine of half the angle between the two rotations.
+    * \sa angularDistance()
+    */
+  template<class OtherDerived> EIGEN_DEVICE_FUNC inline Scalar dot(const QuaternionBase<OtherDerived>& other) const { return coeffs().dot(other.coeffs()); }
+
+  template<class OtherDerived> EIGEN_DEVICE_FUNC Scalar angularDistance(const QuaternionBase<OtherDerived>& other) const;
+
+  /** \returns an equivalent 3x3 rotation matrix */
+  EIGEN_DEVICE_FUNC Matrix3 toRotationMatrix() const;
+
+  /** \returns the quaternion which transform \a a into \a b through a rotation */
+  template<typename Derived1, typename Derived2>
+  EIGEN_DEVICE_FUNC Derived& setFromTwoVectors(const MatrixBase<Derived1>& a, const MatrixBase<Derived2>& b);
+
+  template<class OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Quaternion<Scalar> operator* (const QuaternionBase<OtherDerived>& q) const;
+  template<class OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator*= (const QuaternionBase<OtherDerived>& q);
+
+  /** \returns the quaternion describing the inverse rotation */
+  EIGEN_DEVICE_FUNC Quaternion<Scalar> inverse() const;
+
+  /** \returns the conjugated quaternion */
+  EIGEN_DEVICE_FUNC Quaternion<Scalar> conjugate() const;
+
+  template<class OtherDerived> EIGEN_DEVICE_FUNC Quaternion<Scalar> slerp(const Scalar& t, const QuaternionBase<OtherDerived>& other) const;
+
+  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
+    * determined by \a prec.
+    *
+    * \sa MatrixBase::isApprox() */
+  template<class OtherDerived>
+  EIGEN_DEVICE_FUNC bool isApprox(const QuaternionBase<OtherDerived>& other, const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const
+  { return coeffs().isApprox(other.coeffs(), prec); }
+
+  /** return the result vector of \a v through the rotation*/
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Vector3 _transformVector(const Vector3& v) const;
+
+  /** \returns \c *this with scalar type casted to \a NewScalarType
+    *
+    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
+    * then this function smartly returns a const reference to \c *this.
+    */
+  template<typename NewScalarType>
+  EIGEN_DEVICE_FUNC inline typename internal::cast_return_type<Derived,Quaternion<NewScalarType> >::type cast() const
+  {
+    return typename internal::cast_return_type<Derived,Quaternion<NewScalarType> >::type(derived());
+  }
+
+#ifdef EIGEN_QUATERNIONBASE_PLUGIN
+# include EIGEN_QUATERNIONBASE_PLUGIN
+#endif
+};
+
+/***************************************************************************
+* Definition/implementation of Quaternion<Scalar>
+***************************************************************************/
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \class Quaternion
+  *
+  * \brief The quaternion class used to represent 3D orientations and rotations
+  *
+  * \tparam _Scalar the scalar type, i.e., the type of the coefficients
+  * \tparam _Options controls the memory alignment of the coefficients. Can be \# AutoAlign or \# DontAlign. Default is AutoAlign.
+  *
+  * This class represents a quaternion \f$ w+xi+yj+zk \f$ that is a convenient representation of
+  * orientations and rotations of objects in three dimensions. Compared to other representations
+  * like Euler angles or 3x3 matrices, quaternions offer the following advantages:
+  * \li \b compact storage (4 scalars)
+  * \li \b efficient to compose (28 flops),
+  * \li \b stable spherical interpolation
+  *
+  * The following two typedefs are provided for convenience:
+  * \li \c Quaternionf for \c float
+  * \li \c Quaterniond for \c double
+  *
+  * \warning Operations interpreting the quaternion as rotation have undefined behavior if the quaternion is not normalized.
+  *
+  * \sa  class AngleAxis, class Transform
+  */
+
+namespace internal {
+template<typename _Scalar,int _Options>
+struct traits<Quaternion<_Scalar,_Options> >
+{
+  typedef Quaternion<_Scalar,_Options> PlainObject;
+  typedef _Scalar Scalar;
+  typedef Matrix<_Scalar,4,1,_Options> Coefficients;
+  enum{
+    Alignment = internal::traits<Coefficients>::Alignment,
+    Flags = LvalueBit
+  };
+};
+}
+
+template<typename _Scalar, int _Options>
+class Quaternion : public QuaternionBase<Quaternion<_Scalar,_Options> >
+{
+public:
+  typedef QuaternionBase<Quaternion<_Scalar,_Options> > Base;
+  enum { NeedsAlignment = internal::traits<Quaternion>::Alignment>0 };
+
+  typedef _Scalar Scalar;
+
+  EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Quaternion)
+  using Base::operator*=;
+
+  typedef typename internal::traits<Quaternion>::Coefficients Coefficients;
+  typedef typename Base::AngleAxisType AngleAxisType;
+
+  /** Default constructor leaving the quaternion uninitialized. */
+  EIGEN_DEVICE_FUNC inline Quaternion() {}
+
+  /** Constructs and initializes the quaternion \f$ w+xi+yj+zk \f$ from
+    * its four coefficients \a w, \a x, \a y and \a z.
+    *
+    * \warning Note the order of the arguments: the real \a w coefficient first,
+    * while internally the coefficients are stored in the following order:
+    * [\c x, \c y, \c z, \c w]
+    */
+  EIGEN_DEVICE_FUNC inline Quaternion(const Scalar& w, const Scalar& x, const Scalar& y, const Scalar& z) : m_coeffs(x, y, z, w){}
+
+  /** Constructs and initialize a quaternion from the array data */
+  EIGEN_DEVICE_FUNC explicit inline Quaternion(const Scalar* data) : m_coeffs(data) {}
+
+  /** Copy constructor */
+  template<class Derived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Quaternion(const QuaternionBase<Derived>& other) { this->Base::operator=(other); }
+
+  /** Constructs and initializes a quaternion from the angle-axis \a aa */
+  EIGEN_DEVICE_FUNC explicit inline Quaternion(const AngleAxisType& aa) { *this = aa; }
+
+  /** Constructs and initializes a quaternion from either:
+    *  - a rotation matrix expression,
+    *  - a 4D vector expression representing quaternion coefficients.
+    */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC explicit inline Quaternion(const MatrixBase<Derived>& other) { *this = other; }
+
+  /** Explicit copy constructor with scalar conversion */
+  template<typename OtherScalar, int OtherOptions>
+  EIGEN_DEVICE_FUNC explicit inline Quaternion(const Quaternion<OtherScalar, OtherOptions>& other)
+  { m_coeffs = other.coeffs().template cast<Scalar>(); }
+
+  EIGEN_DEVICE_FUNC static Quaternion UnitRandom();
+
+  template<typename Derived1, typename Derived2>
+  EIGEN_DEVICE_FUNC static Quaternion FromTwoVectors(const MatrixBase<Derived1>& a, const MatrixBase<Derived2>& b);
+
+  EIGEN_DEVICE_FUNC inline Coefficients& coeffs() { return m_coeffs;}
+  EIGEN_DEVICE_FUNC inline const Coefficients& coeffs() const { return m_coeffs;}
+
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(bool(NeedsAlignment))
+  
+#ifdef EIGEN_QUATERNION_PLUGIN
+# include EIGEN_QUATERNION_PLUGIN
+#endif
+
+protected:
+  Coefficients m_coeffs;
+  
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    static EIGEN_STRONG_INLINE void _check_template_params()
+    {
+      EIGEN_STATIC_ASSERT( (_Options & DontAlign) == _Options,
+        INVALID_MATRIX_TEMPLATE_PARAMETERS)
+    }
+#endif
+};
+
+/** \ingroup Geometry_Module
+  * single precision quaternion type */
+typedef Quaternion<float> Quaternionf;
+/** \ingroup Geometry_Module
+  * double precision quaternion type */
+typedef Quaternion<double> Quaterniond;
+
+/***************************************************************************
+* Specialization of Map<Quaternion<Scalar>>
+***************************************************************************/
+
+namespace internal {
+  template<typename _Scalar, int _Options>
+  struct traits<Map<Quaternion<_Scalar>, _Options> > : traits<Quaternion<_Scalar, (int(_Options)&Aligned)==Aligned ? AutoAlign : DontAlign> >
+  {
+    typedef Map<Matrix<_Scalar,4,1>, _Options> Coefficients;
+  };
+}
+
+namespace internal {
+  template<typename _Scalar, int _Options>
+  struct traits<Map<const Quaternion<_Scalar>, _Options> > : traits<Quaternion<_Scalar, (int(_Options)&Aligned)==Aligned ? AutoAlign : DontAlign> >
+  {
+    typedef Map<const Matrix<_Scalar,4,1>, _Options> Coefficients;
+    typedef traits<Quaternion<_Scalar, (int(_Options)&Aligned)==Aligned ? AutoAlign : DontAlign> > TraitsBase;
+    enum {
+      Flags = TraitsBase::Flags & ~LvalueBit
+    };
+  };
+}
+
+/** \ingroup Geometry_Module
+  * \brief Quaternion expression mapping a constant memory buffer
+  *
+  * \tparam _Scalar the type of the Quaternion coefficients
+  * \tparam _Options see class Map
+  *
+  * This is a specialization of class Map for Quaternion. This class allows to view
+  * a 4 scalar memory buffer as an Eigen's Quaternion object.
+  *
+  * \sa class Map, class Quaternion, class QuaternionBase
+  */
+template<typename _Scalar, int _Options>
+class Map<const Quaternion<_Scalar>, _Options >
+  : public QuaternionBase<Map<const Quaternion<_Scalar>, _Options> >
+{
+  public:
+    typedef QuaternionBase<Map<const Quaternion<_Scalar>, _Options> > Base;
+
+    typedef _Scalar Scalar;
+    typedef typename internal::traits<Map>::Coefficients Coefficients;
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Map)
+    using Base::operator*=;
+
+    /** Constructs a Mapped Quaternion object from the pointer \a coeffs
+      *
+      * The pointer \a coeffs must reference the four coefficients of Quaternion in the following order:
+      * \code *coeffs == {x, y, z, w} \endcode
+      *
+      * If the template parameter _Options is set to #Aligned, then the pointer coeffs must be aligned. */
+    EIGEN_DEVICE_FUNC explicit EIGEN_STRONG_INLINE Map(const Scalar* coeffs) : m_coeffs(coeffs) {}
+
+    EIGEN_DEVICE_FUNC inline const Coefficients& coeffs() const { return m_coeffs;}
+
+  protected:
+    const Coefficients m_coeffs;
+};
+
+/** \ingroup Geometry_Module
+  * \brief Expression of a quaternion from a memory buffer
+  *
+  * \tparam _Scalar the type of the Quaternion coefficients
+  * \tparam _Options see class Map
+  *
+  * This is a specialization of class Map for Quaternion. This class allows to view
+  * a 4 scalar memory buffer as an Eigen's  Quaternion object.
+  *
+  * \sa class Map, class Quaternion, class QuaternionBase
+  */
+template<typename _Scalar, int _Options>
+class Map<Quaternion<_Scalar>, _Options >
+  : public QuaternionBase<Map<Quaternion<_Scalar>, _Options> >
+{
+  public:
+    typedef QuaternionBase<Map<Quaternion<_Scalar>, _Options> > Base;
+
+    typedef _Scalar Scalar;
+    typedef typename internal::traits<Map>::Coefficients Coefficients;
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Map)
+    using Base::operator*=;
+
+    /** Constructs a Mapped Quaternion object from the pointer \a coeffs
+      *
+      * The pointer \a coeffs must reference the four coefficients of Quaternion in the following order:
+      * \code *coeffs == {x, y, z, w} \endcode
+      *
+      * If the template parameter _Options is set to #Aligned, then the pointer coeffs must be aligned. */
+    EIGEN_DEVICE_FUNC explicit EIGEN_STRONG_INLINE Map(Scalar* coeffs) : m_coeffs(coeffs) {}
+
+    EIGEN_DEVICE_FUNC inline Coefficients& coeffs() { return m_coeffs; }
+    EIGEN_DEVICE_FUNC inline const Coefficients& coeffs() const { return m_coeffs; }
+
+  protected:
+    Coefficients m_coeffs;
+};
+
+/** \ingroup Geometry_Module
+  * Map an unaligned array of single precision scalars as a quaternion */
+typedef Map<Quaternion<float>, 0>         QuaternionMapf;
+/** \ingroup Geometry_Module
+  * Map an unaligned array of double precision scalars as a quaternion */
+typedef Map<Quaternion<double>, 0>        QuaternionMapd;
+/** \ingroup Geometry_Module
+  * Map a 16-byte aligned array of single precision scalars as a quaternion */
+typedef Map<Quaternion<float>, Aligned>   QuaternionMapAlignedf;
+/** \ingroup Geometry_Module
+  * Map a 16-byte aligned array of double precision scalars as a quaternion */
+typedef Map<Quaternion<double>, Aligned>  QuaternionMapAlignedd;
+
+/***************************************************************************
+* Implementation of QuaternionBase methods
+***************************************************************************/
+
+// Generic Quaternion * Quaternion product
+// This product can be specialized for a given architecture via the Arch template argument.
+namespace internal {
+template<int Arch, class Derived1, class Derived2, typename Scalar> struct quat_product
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Quaternion<Scalar> run(const QuaternionBase<Derived1>& a, const QuaternionBase<Derived2>& b){
+    return Quaternion<Scalar>
+    (
+      a.w() * b.w() - a.x() * b.x() - a.y() * b.y() - a.z() * b.z(),
+      a.w() * b.x() + a.x() * b.w() + a.y() * b.z() - a.z() * b.y(),
+      a.w() * b.y() + a.y() * b.w() + a.z() * b.x() - a.x() * b.z(),
+      a.w() * b.z() + a.z() * b.w() + a.x() * b.y() - a.y() * b.x()
+    );
+  }
+};
+}
+
+/** \returns the concatenation of two rotations as a quaternion-quaternion product */
+template <class Derived>
+template <class OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Quaternion<typename internal::traits<Derived>::Scalar>
+QuaternionBase<Derived>::operator* (const QuaternionBase<OtherDerived>& other) const
+{
+  EIGEN_STATIC_ASSERT((internal::is_same<typename Derived::Scalar, typename OtherDerived::Scalar>::value),
+   YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+  return internal::quat_product<Architecture::Target, Derived, OtherDerived,
+                         typename internal::traits<Derived>::Scalar>::run(*this, other);
+}
+
+/** \sa operator*(Quaternion) */
+template <class Derived>
+template <class OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& QuaternionBase<Derived>::operator*= (const QuaternionBase<OtherDerived>& other)
+{
+  derived() = derived() * other.derived();
+  return derived();
+}
+
+/** Rotation of a vector by a quaternion.
+  * \remarks If the quaternion is used to rotate several points (>1)
+  * then it is much more efficient to first convert it to a 3x3 Matrix.
+  * Comparison of the operation cost for n transformations:
+  *   - Quaternion2:    30n
+  *   - Via a Matrix3: 24 + 15n
+  */
+template <class Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename QuaternionBase<Derived>::Vector3
+QuaternionBase<Derived>::_transformVector(const Vector3& v) const
+{
+    // Note that this algorithm comes from the optimization by hand
+    // of the conversion to a Matrix followed by a Matrix/Vector product.
+    // It appears to be much faster than the common algorithm found
+    // in the literature (30 versus 39 flops). It also requires two
+    // Vector3 as temporaries.
+    Vector3 uv = this->vec().cross(v);
+    uv += uv;
+    return v + this->w() * uv + this->vec().cross(uv);
+}
+
+template<class Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE QuaternionBase<Derived>& QuaternionBase<Derived>::operator=(const QuaternionBase<Derived>& other)
+{
+  coeffs() = other.coeffs();
+  return derived();
+}
+
+template<class Derived>
+template<class OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& QuaternionBase<Derived>::operator=(const QuaternionBase<OtherDerived>& other)
+{
+  coeffs() = other.coeffs();
+  return derived();
+}
+
+/** Set \c *this from an angle-axis \a aa and returns a reference to \c *this
+  */
+template<class Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& QuaternionBase<Derived>::operator=(const AngleAxisType& aa)
+{
+  EIGEN_USING_STD_MATH(cos)
+  EIGEN_USING_STD_MATH(sin)
+  Scalar ha = Scalar(0.5)*aa.angle(); // Scalar(0.5) to suppress precision loss warnings
+  this->w() = cos(ha);
+  this->vec() = sin(ha) * aa.axis();
+  return derived();
+}
+
+/** Set \c *this from the expression \a xpr:
+  *   - if \a xpr is a 4x1 vector, then \a xpr is assumed to be a quaternion
+  *   - if \a xpr is a 3x3 matrix, then \a xpr is assumed to be rotation matrix
+  *     and \a xpr is converted to a quaternion
+  */
+
+template<class Derived>
+template<class MatrixDerived>
+EIGEN_DEVICE_FUNC inline Derived& QuaternionBase<Derived>::operator=(const MatrixBase<MatrixDerived>& xpr)
+{
+  EIGEN_STATIC_ASSERT((internal::is_same<typename Derived::Scalar, typename MatrixDerived::Scalar>::value),
+   YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+  internal::quaternionbase_assign_impl<MatrixDerived>::run(*this, xpr.derived());
+  return derived();
+}
+
+/** Convert the quaternion to a 3x3 rotation matrix. The quaternion is required to
+  * be normalized, otherwise the result is undefined.
+  */
+template<class Derived>
+EIGEN_DEVICE_FUNC inline typename QuaternionBase<Derived>::Matrix3
+QuaternionBase<Derived>::toRotationMatrix(void) const
+{
+  // NOTE if inlined, then gcc 4.2 and 4.4 get rid of the temporary (not gcc 4.3 !!)
+  // if not inlined then the cost of the return by value is huge ~ +35%,
+  // however, not inlining this function is an order of magnitude slower, so
+  // it has to be inlined, and so the return by value is not an issue
+  Matrix3 res;
+
+  const Scalar tx  = Scalar(2)*this->x();
+  const Scalar ty  = Scalar(2)*this->y();
+  const Scalar tz  = Scalar(2)*this->z();
+  const Scalar twx = tx*this->w();
+  const Scalar twy = ty*this->w();
+  const Scalar twz = tz*this->w();
+  const Scalar txx = tx*this->x();
+  const Scalar txy = ty*this->x();
+  const Scalar txz = tz*this->x();
+  const Scalar tyy = ty*this->y();
+  const Scalar tyz = tz*this->y();
+  const Scalar tzz = tz*this->z();
+
+  res.coeffRef(0,0) = Scalar(1)-(tyy+tzz);
+  res.coeffRef(0,1) = txy-twz;
+  res.coeffRef(0,2) = txz+twy;
+  res.coeffRef(1,0) = txy+twz;
+  res.coeffRef(1,1) = Scalar(1)-(txx+tzz);
+  res.coeffRef(1,2) = tyz-twx;
+  res.coeffRef(2,0) = txz-twy;
+  res.coeffRef(2,1) = tyz+twx;
+  res.coeffRef(2,2) = Scalar(1)-(txx+tyy);
+
+  return res;
+}
+
+/** Sets \c *this to be a quaternion representing a rotation between
+  * the two arbitrary vectors \a a and \a b. In other words, the built
+  * rotation represent a rotation sending the line of direction \a a
+  * to the line of direction \a b, both lines passing through the origin.
+  *
+  * \returns a reference to \c *this.
+  *
+  * Note that the two input vectors do \b not have to be normalized, and
+  * do not need to have the same norm.
+  */
+template<class Derived>
+template<typename Derived1, typename Derived2>
+EIGEN_DEVICE_FUNC inline Derived& QuaternionBase<Derived>::setFromTwoVectors(const MatrixBase<Derived1>& a, const MatrixBase<Derived2>& b)
+{
+  EIGEN_USING_STD_MATH(sqrt)
+  Vector3 v0 = a.normalized();
+  Vector3 v1 = b.normalized();
+  Scalar c = v1.dot(v0);
+
+  // if dot == -1, vectors are nearly opposites
+  // => accurately compute the rotation axis by computing the
+  //    intersection of the two planes. This is done by solving:
+  //       x^T v0 = 0
+  //       x^T v1 = 0
+  //    under the constraint:
+  //       ||x|| = 1
+  //    which yields a singular value problem
+  if (c < Scalar(-1)+NumTraits<Scalar>::dummy_precision())
+  {
+    c = numext::maxi(c,Scalar(-1));
+    Matrix<Scalar,2,3> m; m << v0.transpose(), v1.transpose();
+    JacobiSVD<Matrix<Scalar,2,3> > svd(m, ComputeFullV);
+    Vector3 axis = svd.matrixV().col(2);
+
+    Scalar w2 = (Scalar(1)+c)*Scalar(0.5);
+    this->w() = sqrt(w2);
+    this->vec() = axis * sqrt(Scalar(1) - w2);
+    return derived();
+  }
+  Vector3 axis = v0.cross(v1);
+  Scalar s = sqrt((Scalar(1)+c)*Scalar(2));
+  Scalar invs = Scalar(1)/s;
+  this->vec() = axis * invs;
+  this->w() = s * Scalar(0.5);
+
+  return derived();
+}
+
+/** \returns a random unit quaternion following a uniform distribution law on SO(3)
+  *
+  * \note The implementation is based on http://planning.cs.uiuc.edu/node198.html
+  */
+template<typename Scalar, int Options>
+EIGEN_DEVICE_FUNC Quaternion<Scalar,Options> Quaternion<Scalar,Options>::UnitRandom()
+{
+  EIGEN_USING_STD_MATH(sqrt)
+  EIGEN_USING_STD_MATH(sin)
+  EIGEN_USING_STD_MATH(cos)
+  const Scalar u1 = internal::random<Scalar>(0, 1),
+               u2 = internal::random<Scalar>(0, 2*EIGEN_PI),
+               u3 = internal::random<Scalar>(0, 2*EIGEN_PI);
+  const Scalar a = sqrt(1 - u1),
+               b = sqrt(u1);
+  return Quaternion (a * sin(u2), a * cos(u2), b * sin(u3), b * cos(u3));
+}
+
+
+/** Returns a quaternion representing a rotation between
+  * the two arbitrary vectors \a a and \a b. In other words, the built
+  * rotation represent a rotation sending the line of direction \a a
+  * to the line of direction \a b, both lines passing through the origin.
+  *
+  * \returns resulting quaternion
+  *
+  * Note that the two input vectors do \b not have to be normalized, and
+  * do not need to have the same norm.
+  */
+template<typename Scalar, int Options>
+template<typename Derived1, typename Derived2>
+EIGEN_DEVICE_FUNC Quaternion<Scalar,Options> Quaternion<Scalar,Options>::FromTwoVectors(const MatrixBase<Derived1>& a, const MatrixBase<Derived2>& b)
+{
+    Quaternion quat;
+    quat.setFromTwoVectors(a, b);
+    return quat;
+}
+
+
+/** \returns the multiplicative inverse of \c *this
+  * Note that in most cases, i.e., if you simply want the opposite rotation,
+  * and/or the quaternion is normalized, then it is enough to use the conjugate.
+  *
+  * \sa QuaternionBase::conjugate()
+  */
+template <class Derived>
+EIGEN_DEVICE_FUNC inline Quaternion<typename internal::traits<Derived>::Scalar> QuaternionBase<Derived>::inverse() const
+{
+  // FIXME should this function be called multiplicativeInverse and conjugate() be called inverse() or opposite()  ??
+  Scalar n2 = this->squaredNorm();
+  if (n2 > Scalar(0))
+    return Quaternion<Scalar>(conjugate().coeffs() / n2);
+  else
+  {
+    // return an invalid result to flag the error
+    return Quaternion<Scalar>(Coefficients::Zero());
+  }
+}
+
+// Generic conjugate of a Quaternion
+namespace internal {
+template<int Arch, class Derived, typename Scalar> struct quat_conj
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Quaternion<Scalar> run(const QuaternionBase<Derived>& q){
+    return Quaternion<Scalar>(q.w(),-q.x(),-q.y(),-q.z());
+  }
+};
+}
+                         
+/** \returns the conjugate of the \c *this which is equal to the multiplicative inverse
+  * if the quaternion is normalized.
+  * The conjugate of a quaternion represents the opposite rotation.
+  *
+  * \sa Quaternion2::inverse()
+  */
+template <class Derived>
+EIGEN_DEVICE_FUNC inline Quaternion<typename internal::traits<Derived>::Scalar>
+QuaternionBase<Derived>::conjugate() const
+{
+  return internal::quat_conj<Architecture::Target, Derived,
+                         typename internal::traits<Derived>::Scalar>::run(*this);
+                         
+}
+
+/** \returns the angle (in radian) between two rotations
+  * \sa dot()
+  */
+template <class Derived>
+template <class OtherDerived>
+EIGEN_DEVICE_FUNC inline typename internal::traits<Derived>::Scalar
+QuaternionBase<Derived>::angularDistance(const QuaternionBase<OtherDerived>& other) const
+{
+  EIGEN_USING_STD_MATH(atan2)
+  Quaternion<Scalar> d = (*this) * other.conjugate();
+  return Scalar(2) * atan2( d.vec().norm(), numext::abs(d.w()) );
+}
+
+ 
+    
+/** \returns the spherical linear interpolation between the two quaternions
+  * \c *this and \a other at the parameter \a t in [0;1].
+  * 
+  * This represents an interpolation for a constant motion between \c *this and \a other,
+  * see also http://en.wikipedia.org/wiki/Slerp.
+  */
+template <class Derived>
+template <class OtherDerived>
+EIGEN_DEVICE_FUNC Quaternion<typename internal::traits<Derived>::Scalar>
+QuaternionBase<Derived>::slerp(const Scalar& t, const QuaternionBase<OtherDerived>& other) const
+{
+  EIGEN_USING_STD_MATH(acos)
+  EIGEN_USING_STD_MATH(sin)
+  const Scalar one = Scalar(1) - NumTraits<Scalar>::epsilon();
+  Scalar d = this->dot(other);
+  Scalar absD = numext::abs(d);
+
+  Scalar scale0;
+  Scalar scale1;
+
+  if(absD>=one)
+  {
+    scale0 = Scalar(1) - t;
+    scale1 = t;
+  }
+  else
+  {
+    // theta is the angle between the 2 quaternions
+    Scalar theta = acos(absD);
+    Scalar sinTheta = sin(theta);
+
+    scale0 = sin( ( Scalar(1) - t ) * theta) / sinTheta;
+    scale1 = sin( ( t * theta) ) / sinTheta;
+  }
+  if(d<Scalar(0)) scale1 = -scale1;
+
+  return Quaternion<Scalar>(scale0 * coeffs() + scale1 * other.coeffs());
+}
+
+namespace internal {
+
+// set from a rotation matrix
+template<typename Other>
+struct quaternionbase_assign_impl<Other,3,3>
+{
+  typedef typename Other::Scalar Scalar;
+  template<class Derived> EIGEN_DEVICE_FUNC static inline void run(QuaternionBase<Derived>& q, const Other& a_mat)
+  {
+    const typename internal::nested_eval<Other,2>::type mat(a_mat);
+    EIGEN_USING_STD_MATH(sqrt)
+    // This algorithm comes from  "Quaternion Calculus and Fast Animation",
+    // Ken Shoemake, 1987 SIGGRAPH course notes
+    Scalar t = mat.trace();
+    if (t > Scalar(0))
+    {
+      t = sqrt(t + Scalar(1.0));
+      q.w() = Scalar(0.5)*t;
+      t = Scalar(0.5)/t;
+      q.x() = (mat.coeff(2,1) - mat.coeff(1,2)) * t;
+      q.y() = (mat.coeff(0,2) - mat.coeff(2,0)) * t;
+      q.z() = (mat.coeff(1,0) - mat.coeff(0,1)) * t;
+    }
+    else
+    {
+      Index i = 0;
+      if (mat.coeff(1,1) > mat.coeff(0,0))
+        i = 1;
+      if (mat.coeff(2,2) > mat.coeff(i,i))
+        i = 2;
+      Index j = (i+1)%3;
+      Index k = (j+1)%3;
+
+      t = sqrt(mat.coeff(i,i)-mat.coeff(j,j)-mat.coeff(k,k) + Scalar(1.0));
+      q.coeffs().coeffRef(i) = Scalar(0.5) * t;
+      t = Scalar(0.5)/t;
+      q.w() = (mat.coeff(k,j)-mat.coeff(j,k))*t;
+      q.coeffs().coeffRef(j) = (mat.coeff(j,i)+mat.coeff(i,j))*t;
+      q.coeffs().coeffRef(k) = (mat.coeff(k,i)+mat.coeff(i,k))*t;
+    }
+  }
+};
+
+// set from a vector of coefficients assumed to be a quaternion
+template<typename Other>
+struct quaternionbase_assign_impl<Other,4,1>
+{
+  typedef typename Other::Scalar Scalar;
+  template<class Derived> EIGEN_DEVICE_FUNC static inline void run(QuaternionBase<Derived>& q, const Other& vec)
+  {
+    q.coeffs() = vec;
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_QUATERNION_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/Rotation2D.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/Rotation2D.h
new file mode 100644
index 00000000..884b7d0e
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/Rotation2D.h
@@ -0,0 +1,199 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ROTATION2D_H
+#define EIGEN_ROTATION2D_H
+
+namespace Eigen { 
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \class Rotation2D
+  *
+  * \brief Represents a rotation/orientation in a 2 dimensional space.
+  *
+  * \tparam _Scalar the scalar type, i.e., the type of the coefficients
+  *
+  * This class is equivalent to a single scalar representing a counter clock wise rotation
+  * as a single angle in radian. It provides some additional features such as the automatic
+  * conversion from/to a 2x2 rotation matrix. Moreover this class aims to provide a similar
+  * interface to Quaternion in order to facilitate the writing of generic algorithms
+  * dealing with rotations.
+  *
+  * \sa class Quaternion, class Transform
+  */
+
+namespace internal {
+
+template<typename _Scalar> struct traits<Rotation2D<_Scalar> >
+{
+  typedef _Scalar Scalar;
+};
+} // end namespace internal
+
+template<typename _Scalar>
+class Rotation2D : public RotationBase<Rotation2D<_Scalar>,2>
+{
+  typedef RotationBase<Rotation2D<_Scalar>,2> Base;
+
+public:
+
+  using Base::operator*;
+
+  enum { Dim = 2 };
+  /** the scalar type of the coefficients */
+  typedef _Scalar Scalar;
+  typedef Matrix<Scalar,2,1> Vector2;
+  typedef Matrix<Scalar,2,2> Matrix2;
+
+protected:
+
+  Scalar m_angle;
+
+public:
+
+  /** Construct a 2D counter clock wise rotation from the angle \a a in radian. */
+  EIGEN_DEVICE_FUNC explicit inline Rotation2D(const Scalar& a) : m_angle(a) {}
+  
+  /** Default constructor wihtout initialization. The represented rotation is undefined. */
+  EIGEN_DEVICE_FUNC Rotation2D() {}
+
+  /** Construct a 2D rotation from a 2x2 rotation matrix \a mat.
+    *
+    * \sa fromRotationMatrix()
+    */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC explicit Rotation2D(const MatrixBase<Derived>& m)
+  {
+    fromRotationMatrix(m.derived());
+  }
+
+  /** \returns the rotation angle */
+  EIGEN_DEVICE_FUNC inline Scalar angle() const { return m_angle; }
+
+  /** \returns a read-write reference to the rotation angle */
+  EIGEN_DEVICE_FUNC inline Scalar& angle() { return m_angle; }
+  
+  /** \returns the rotation angle in [0,2pi] */
+  EIGEN_DEVICE_FUNC inline Scalar smallestPositiveAngle() const {
+    Scalar tmp = numext::fmod(m_angle,Scalar(2*EIGEN_PI));
+    return tmp<Scalar(0) ? tmp + Scalar(2*EIGEN_PI) : tmp;
+  }
+  
+  /** \returns the rotation angle in [-pi,pi] */
+  EIGEN_DEVICE_FUNC inline Scalar smallestAngle() const {
+    Scalar tmp = numext::fmod(m_angle,Scalar(2*EIGEN_PI));
+    if(tmp>Scalar(EIGEN_PI))       tmp -= Scalar(2*EIGEN_PI);
+    else if(tmp<-Scalar(EIGEN_PI)) tmp += Scalar(2*EIGEN_PI);
+    return tmp;
+  }
+
+  /** \returns the inverse rotation */
+  EIGEN_DEVICE_FUNC inline Rotation2D inverse() const { return Rotation2D(-m_angle); }
+
+  /** Concatenates two rotations */
+  EIGEN_DEVICE_FUNC inline Rotation2D operator*(const Rotation2D& other) const
+  { return Rotation2D(m_angle + other.m_angle); }
+
+  /** Concatenates two rotations */
+  EIGEN_DEVICE_FUNC inline Rotation2D& operator*=(const Rotation2D& other)
+  { m_angle += other.m_angle; return *this; }
+
+  /** Applies the rotation to a 2D vector */
+  EIGEN_DEVICE_FUNC Vector2 operator* (const Vector2& vec) const
+  { return toRotationMatrix() * vec; }
+  
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC Rotation2D& fromRotationMatrix(const MatrixBase<Derived>& m);
+  EIGEN_DEVICE_FUNC Matrix2 toRotationMatrix() const;
+
+  /** Set \c *this from a 2x2 rotation matrix \a mat.
+    * In other words, this function extract the rotation angle from the rotation matrix.
+    *
+    * This method is an alias for fromRotationMatrix()
+    *
+    * \sa fromRotationMatrix()
+    */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC Rotation2D& operator=(const  MatrixBase<Derived>& m)
+  { return fromRotationMatrix(m.derived()); }
+
+  /** \returns the spherical interpolation between \c *this and \a other using
+    * parameter \a t. It is in fact equivalent to a linear interpolation.
+    */
+  EIGEN_DEVICE_FUNC inline Rotation2D slerp(const Scalar& t, const Rotation2D& other) const
+  {
+    Scalar dist = Rotation2D(other.m_angle-m_angle).smallestAngle();
+    return Rotation2D(m_angle + dist*t);
+  }
+
+  /** \returns \c *this with scalar type casted to \a NewScalarType
+    *
+    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
+    * then this function smartly returns a const reference to \c *this.
+    */
+  template<typename NewScalarType>
+  EIGEN_DEVICE_FUNC inline typename internal::cast_return_type<Rotation2D,Rotation2D<NewScalarType> >::type cast() const
+  { return typename internal::cast_return_type<Rotation2D,Rotation2D<NewScalarType> >::type(*this); }
+
+  /** Copy constructor with scalar type conversion */
+  template<typename OtherScalarType>
+  EIGEN_DEVICE_FUNC inline explicit Rotation2D(const Rotation2D<OtherScalarType>& other)
+  {
+    m_angle = Scalar(other.angle());
+  }
+
+  EIGEN_DEVICE_FUNC static inline Rotation2D Identity() { return Rotation2D(0); }
+
+  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
+    * determined by \a prec.
+    *
+    * \sa MatrixBase::isApprox() */
+  EIGEN_DEVICE_FUNC bool isApprox(const Rotation2D& other, const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const
+  { return internal::isApprox(m_angle,other.m_angle, prec); }
+  
+};
+
+/** \ingroup Geometry_Module
+  * single precision 2D rotation type */
+typedef Rotation2D<float> Rotation2Df;
+/** \ingroup Geometry_Module
+  * double precision 2D rotation type */
+typedef Rotation2D<double> Rotation2Dd;
+
+/** Set \c *this from a 2x2 rotation matrix \a mat.
+  * In other words, this function extract the rotation angle
+  * from the rotation matrix.
+  */
+template<typename Scalar>
+template<typename Derived>
+EIGEN_DEVICE_FUNC Rotation2D<Scalar>& Rotation2D<Scalar>::fromRotationMatrix(const MatrixBase<Derived>& mat)
+{
+  EIGEN_USING_STD_MATH(atan2)
+  EIGEN_STATIC_ASSERT(Derived::RowsAtCompileTime==2 && Derived::ColsAtCompileTime==2,YOU_MADE_A_PROGRAMMING_MISTAKE)
+  m_angle = atan2(mat.coeff(1,0), mat.coeff(0,0));
+  return *this;
+}
+
+/** Constructs and \returns an equivalent 2x2 rotation matrix.
+  */
+template<typename Scalar>
+typename Rotation2D<Scalar>::Matrix2
+EIGEN_DEVICE_FUNC Rotation2D<Scalar>::toRotationMatrix(void) const
+{
+  EIGEN_USING_STD_MATH(sin)
+  EIGEN_USING_STD_MATH(cos)
+  Scalar sinA = sin(m_angle);
+  Scalar cosA = cos(m_angle);
+  return (Matrix2() << cosA, -sinA, sinA, cosA).finished();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_ROTATION2D_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/RotationBase.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/RotationBase.h
new file mode 100644
index 00000000..f0ee0bd0
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/RotationBase.h
@@ -0,0 +1,206 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ROTATIONBASE_H
+#define EIGEN_ROTATIONBASE_H
+
+namespace Eigen { 
+
+// forward declaration
+namespace internal {
+template<typename RotationDerived, typename MatrixType, bool IsVector=MatrixType::IsVectorAtCompileTime>
+struct rotation_base_generic_product_selector;
+}
+
+/** \class RotationBase
+  *
+  * \brief Common base class for compact rotation representations
+  *
+  * \tparam Derived is the derived type, i.e., a rotation type
+  * \tparam _Dim the dimension of the space
+  */
+template<typename Derived, int _Dim>
+class RotationBase
+{
+  public:
+    enum { Dim = _Dim };
+    /** the scalar type of the coefficients */
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+
+    /** corresponding linear transformation matrix type */
+    typedef Matrix<Scalar,Dim,Dim> RotationMatrixType;
+    typedef Matrix<Scalar,Dim,1> VectorType;
+
+  public:
+    EIGEN_DEVICE_FUNC inline const Derived& derived() const { return *static_cast<const Derived*>(this); }
+    EIGEN_DEVICE_FUNC inline Derived& derived() { return *static_cast<Derived*>(this); }
+
+    /** \returns an equivalent rotation matrix */
+    EIGEN_DEVICE_FUNC inline RotationMatrixType toRotationMatrix() const { return derived().toRotationMatrix(); }
+
+    /** \returns an equivalent rotation matrix 
+      * This function is added to be conform with the Transform class' naming scheme.
+      */
+    EIGEN_DEVICE_FUNC inline RotationMatrixType matrix() const { return derived().toRotationMatrix(); }
+
+    /** \returns the inverse rotation */
+    EIGEN_DEVICE_FUNC inline Derived inverse() const { return derived().inverse(); }
+
+    /** \returns the concatenation of the rotation \c *this with a translation \a t */
+    EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Isometry> operator*(const Translation<Scalar,Dim>& t) const
+    { return Transform<Scalar,Dim,Isometry>(*this) * t; }
+
+    /** \returns the concatenation of the rotation \c *this with a uniform scaling \a s */
+    EIGEN_DEVICE_FUNC inline RotationMatrixType operator*(const UniformScaling<Scalar>& s) const
+    { return toRotationMatrix() * s.factor(); }
+
+    /** \returns the concatenation of the rotation \c *this with a generic expression \a e
+      * \a e can be:
+      *  - a DimxDim linear transformation matrix
+      *  - a DimxDim diagonal matrix (axis aligned scaling)
+      *  - a vector of size Dim
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::rotation_base_generic_product_selector<Derived,OtherDerived,OtherDerived::IsVectorAtCompileTime>::ReturnType
+    operator*(const EigenBase<OtherDerived>& e) const
+    { return internal::rotation_base_generic_product_selector<Derived,OtherDerived>::run(derived(), e.derived()); }
+
+    /** \returns the concatenation of a linear transformation \a l with the rotation \a r */
+    template<typename OtherDerived> friend
+    EIGEN_DEVICE_FUNC inline RotationMatrixType operator*(const EigenBase<OtherDerived>& l, const Derived& r)
+    { return l.derived() * r.toRotationMatrix(); }
+
+    /** \returns the concatenation of a scaling \a l with the rotation \a r */
+    EIGEN_DEVICE_FUNC friend inline Transform<Scalar,Dim,Affine> operator*(const DiagonalMatrix<Scalar,Dim>& l, const Derived& r)
+    { 
+      Transform<Scalar,Dim,Affine> res(r);
+      res.linear().applyOnTheLeft(l);
+      return res;
+    }
+
+    /** \returns the concatenation of the rotation \c *this with a transformation \a t */
+    template<int Mode, int Options>
+    EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode> operator*(const Transform<Scalar,Dim,Mode,Options>& t) const
+    { return toRotationMatrix() * t; }
+
+    template<typename OtherVectorType>
+    EIGEN_DEVICE_FUNC inline VectorType _transformVector(const OtherVectorType& v) const
+    { return toRotationMatrix() * v; }
+};
+
+namespace internal {
+
+// implementation of the generic product rotation * matrix
+template<typename RotationDerived, typename MatrixType>
+struct rotation_base_generic_product_selector<RotationDerived,MatrixType,false>
+{
+  enum { Dim = RotationDerived::Dim };
+  typedef Matrix<typename RotationDerived::Scalar,Dim,Dim> ReturnType;
+  EIGEN_DEVICE_FUNC static inline ReturnType run(const RotationDerived& r, const MatrixType& m)
+  { return r.toRotationMatrix() * m; }
+};
+
+template<typename RotationDerived, typename Scalar, int Dim, int MaxDim>
+struct rotation_base_generic_product_selector< RotationDerived, DiagonalMatrix<Scalar,Dim,MaxDim>, false >
+{
+  typedef Transform<Scalar,Dim,Affine> ReturnType;
+  EIGEN_DEVICE_FUNC static inline ReturnType run(const RotationDerived& r, const DiagonalMatrix<Scalar,Dim,MaxDim>& m)
+  {
+    ReturnType res(r);
+    res.linear() *= m;
+    return res;
+  }
+};
+
+template<typename RotationDerived,typename OtherVectorType>
+struct rotation_base_generic_product_selector<RotationDerived,OtherVectorType,true>
+{
+  enum { Dim = RotationDerived::Dim };
+  typedef Matrix<typename RotationDerived::Scalar,Dim,1> ReturnType;
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE ReturnType run(const RotationDerived& r, const OtherVectorType& v)
+  {
+    return r._transformVector(v);
+  }
+};
+
+} // end namespace internal
+
+/** \geometry_module
+  *
+  * \brief Constructs a Dim x Dim rotation matrix from the rotation \a r
+  */
+template<typename _Scalar, int _Rows, int _Cols, int _Storage, int _MaxRows, int _MaxCols>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC Matrix<_Scalar, _Rows, _Cols, _Storage, _MaxRows, _MaxCols>
+::Matrix(const RotationBase<OtherDerived,ColsAtCompileTime>& r)
+{
+  EIGEN_STATIC_ASSERT_MATRIX_SPECIFIC_SIZE(Matrix,int(OtherDerived::Dim),int(OtherDerived::Dim))
+  *this = r.toRotationMatrix();
+}
+
+/** \geometry_module
+  *
+  * \brief Set a Dim x Dim rotation matrix from the rotation \a r
+  */
+template<typename _Scalar, int _Rows, int _Cols, int _Storage, int _MaxRows, int _MaxCols>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC Matrix<_Scalar, _Rows, _Cols, _Storage, _MaxRows, _MaxCols>&
+Matrix<_Scalar, _Rows, _Cols, _Storage, _MaxRows, _MaxCols>
+::operator=(const RotationBase<OtherDerived,ColsAtCompileTime>& r)
+{
+  EIGEN_STATIC_ASSERT_MATRIX_SPECIFIC_SIZE(Matrix,int(OtherDerived::Dim),int(OtherDerived::Dim))
+  return *this = r.toRotationMatrix();
+}
+
+namespace internal {
+
+/** \internal
+  *
+  * Helper function to return an arbitrary rotation object to a rotation matrix.
+  *
+  * \tparam Scalar the numeric type of the matrix coefficients
+  * \tparam Dim the dimension of the current space
+  *
+  * It returns a Dim x Dim fixed size matrix.
+  *
+  * Default specializations are provided for:
+  *   - any scalar type (2D),
+  *   - any matrix expression,
+  *   - any type based on RotationBase (e.g., Quaternion, AngleAxis, Rotation2D)
+  *
+  * Currently toRotationMatrix is only used by Transform.
+  *
+  * \sa class Transform, class Rotation2D, class Quaternion, class AngleAxis
+  */
+template<typename Scalar, int Dim>
+EIGEN_DEVICE_FUNC static inline Matrix<Scalar,2,2> toRotationMatrix(const Scalar& s)
+{
+  EIGEN_STATIC_ASSERT(Dim==2,YOU_MADE_A_PROGRAMMING_MISTAKE)
+  return Rotation2D<Scalar>(s).toRotationMatrix();
+}
+
+template<typename Scalar, int Dim, typename OtherDerived>
+EIGEN_DEVICE_FUNC static inline Matrix<Scalar,Dim,Dim> toRotationMatrix(const RotationBase<OtherDerived,Dim>& r)
+{
+  return r.toRotationMatrix();
+}
+
+template<typename Scalar, int Dim, typename OtherDerived>
+EIGEN_DEVICE_FUNC static inline const MatrixBase<OtherDerived>& toRotationMatrix(const MatrixBase<OtherDerived>& mat)
+{
+  EIGEN_STATIC_ASSERT(OtherDerived::RowsAtCompileTime==Dim && OtherDerived::ColsAtCompileTime==Dim,
+    YOU_MADE_A_PROGRAMMING_MISTAKE)
+  return mat;
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_ROTATIONBASE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/Scaling.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/Scaling.h
new file mode 100644
index 00000000..f58ca03d
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/Scaling.h
@@ -0,0 +1,170 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SCALING_H
+#define EIGEN_SCALING_H
+
+namespace Eigen { 
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \class Scaling
+  *
+  * \brief Represents a generic uniform scaling transformation
+  *
+  * \tparam _Scalar the scalar type, i.e., the type of the coefficients.
+  *
+  * This class represent a uniform scaling transformation. It is the return
+  * type of Scaling(Scalar), and most of the time this is the only way it
+  * is used. In particular, this class is not aimed to be used to store a scaling transformation,
+  * but rather to make easier the constructions and updates of Transform objects.
+  *
+  * To represent an axis aligned scaling, use the DiagonalMatrix class.
+  *
+  * \sa Scaling(), class DiagonalMatrix, MatrixBase::asDiagonal(), class Translation, class Transform
+  */
+template<typename _Scalar>
+class UniformScaling
+{
+public:
+  /** the scalar type of the coefficients */
+  typedef _Scalar Scalar;
+
+protected:
+
+  Scalar m_factor;
+
+public:
+
+  /** Default constructor without initialization. */
+  UniformScaling() {}
+  /** Constructs and initialize a uniform scaling transformation */
+  explicit inline UniformScaling(const Scalar& s) : m_factor(s) {}
+
+  inline const Scalar& factor() const { return m_factor; }
+  inline Scalar& factor() { return m_factor; }
+
+  /** Concatenates two uniform scaling */
+  inline UniformScaling operator* (const UniformScaling& other) const
+  { return UniformScaling(m_factor * other.factor()); }
+
+  /** Concatenates a uniform scaling and a translation */
+  template<int Dim>
+  inline Transform<Scalar,Dim,Affine> operator* (const Translation<Scalar,Dim>& t) const;
+
+  /** Concatenates a uniform scaling and an affine transformation */
+  template<int Dim, int Mode, int Options>
+  inline Transform<Scalar,Dim,(int(Mode)==int(Isometry)?Affine:Mode)> operator* (const Transform<Scalar,Dim, Mode, Options>& t) const
+  {
+    Transform<Scalar,Dim,(int(Mode)==int(Isometry)?Affine:Mode)> res = t;
+    res.prescale(factor());
+    return res;
+  }
+
+  /** Concatenates a uniform scaling and a linear transformation matrix */
+  // TODO returns an expression
+  template<typename Derived>
+  inline typename internal::plain_matrix_type<Derived>::type operator* (const MatrixBase<Derived>& other) const
+  { return other * m_factor; }
+
+  template<typename Derived,int Dim>
+  inline Matrix<Scalar,Dim,Dim> operator*(const RotationBase<Derived,Dim>& r) const
+  { return r.toRotationMatrix() * m_factor; }
+
+  /** \returns the inverse scaling */
+  inline UniformScaling inverse() const
+  { return UniformScaling(Scalar(1)/m_factor); }
+
+  /** \returns \c *this with scalar type casted to \a NewScalarType
+    *
+    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
+    * then this function smartly returns a const reference to \c *this.
+    */
+  template<typename NewScalarType>
+  inline UniformScaling<NewScalarType> cast() const
+  { return UniformScaling<NewScalarType>(NewScalarType(m_factor)); }
+
+  /** Copy constructor with scalar type conversion */
+  template<typename OtherScalarType>
+  inline explicit UniformScaling(const UniformScaling<OtherScalarType>& other)
+  { m_factor = Scalar(other.factor()); }
+
+  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
+    * determined by \a prec.
+    *
+    * \sa MatrixBase::isApprox() */
+  bool isApprox(const UniformScaling& other, const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const
+  { return internal::isApprox(m_factor, other.factor(), prec); }
+
+};
+
+/** \addtogroup Geometry_Module */
+//@{
+
+/** Concatenates a linear transformation matrix and a uniform scaling
+  * \relates UniformScaling
+  */
+// NOTE this operator is defiend in MatrixBase and not as a friend function
+// of UniformScaling to fix an internal crash of Intel's ICC
+template<typename Derived,typename Scalar>
+EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Derived,Scalar,product)
+operator*(const MatrixBase<Derived>& matrix, const UniformScaling<Scalar>& s)
+{ return matrix.derived() * s.factor(); }
+
+/** Constructs a uniform scaling from scale factor \a s */
+inline UniformScaling<float> Scaling(float s) { return UniformScaling<float>(s); }
+/** Constructs a uniform scaling from scale factor \a s */
+inline UniformScaling<double> Scaling(double s) { return UniformScaling<double>(s); }
+/** Constructs a uniform scaling from scale factor \a s */
+template<typename RealScalar>
+inline UniformScaling<std::complex<RealScalar> > Scaling(const std::complex<RealScalar>& s)
+{ return UniformScaling<std::complex<RealScalar> >(s); }
+
+/** Constructs a 2D axis aligned scaling */
+template<typename Scalar>
+inline DiagonalMatrix<Scalar,2> Scaling(const Scalar& sx, const Scalar& sy)
+{ return DiagonalMatrix<Scalar,2>(sx, sy); }
+/** Constructs a 3D axis aligned scaling */
+template<typename Scalar>
+inline DiagonalMatrix<Scalar,3> Scaling(const Scalar& sx, const Scalar& sy, const Scalar& sz)
+{ return DiagonalMatrix<Scalar,3>(sx, sy, sz); }
+
+/** Constructs an axis aligned scaling expression from vector expression \a coeffs
+  * This is an alias for coeffs.asDiagonal()
+  */
+template<typename Derived>
+inline const DiagonalWrapper<const Derived> Scaling(const MatrixBase<Derived>& coeffs)
+{ return coeffs.asDiagonal(); }
+
+/** \deprecated */
+typedef DiagonalMatrix<float, 2> AlignedScaling2f;
+/** \deprecated */
+typedef DiagonalMatrix<double,2> AlignedScaling2d;
+/** \deprecated */
+typedef DiagonalMatrix<float, 3> AlignedScaling3f;
+/** \deprecated */
+typedef DiagonalMatrix<double,3> AlignedScaling3d;
+//@}
+
+template<typename Scalar>
+template<int Dim>
+inline Transform<Scalar,Dim,Affine>
+UniformScaling<Scalar>::operator* (const Translation<Scalar,Dim>& t) const
+{
+  Transform<Scalar,Dim,Affine> res;
+  res.matrix().setZero();
+  res.linear().diagonal().fill(factor());
+  res.translation() = factor() * t.vector();
+  res(Dim,Dim) = Scalar(1);
+  return res;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SCALING_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/Transform.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/Transform.h
new file mode 100644
index 00000000..2d36dfad
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/Transform.h
@@ -0,0 +1,1542 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2010 Hauke Heibel <hauke.heibel@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TRANSFORM_H
+#define EIGEN_TRANSFORM_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename Transform>
+struct transform_traits
+{
+  enum
+  {
+    Dim = Transform::Dim,
+    HDim = Transform::HDim,
+    Mode = Transform::Mode,
+    IsProjective = (int(Mode)==int(Projective))
+  };
+};
+
+template< typename TransformType,
+          typename MatrixType,
+          int Case = transform_traits<TransformType>::IsProjective ? 0
+                   : int(MatrixType::RowsAtCompileTime) == int(transform_traits<TransformType>::HDim) ? 1
+                   : 2,
+          int RhsCols = MatrixType::ColsAtCompileTime>
+struct transform_right_product_impl;
+
+template< typename Other,
+          int Mode,
+          int Options,
+          int Dim,
+          int HDim,
+          int OtherRows=Other::RowsAtCompileTime,
+          int OtherCols=Other::ColsAtCompileTime>
+struct transform_left_product_impl;
+
+template< typename Lhs,
+          typename Rhs,
+          bool AnyProjective = 
+            transform_traits<Lhs>::IsProjective ||
+            transform_traits<Rhs>::IsProjective>
+struct transform_transform_product_impl;
+
+template< typename Other,
+          int Mode,
+          int Options,
+          int Dim,
+          int HDim,
+          int OtherRows=Other::RowsAtCompileTime,
+          int OtherCols=Other::ColsAtCompileTime>
+struct transform_construct_from_matrix;
+
+template<typename TransformType> struct transform_take_affine_part;
+
+template<typename _Scalar, int _Dim, int _Mode, int _Options>
+struct traits<Transform<_Scalar,_Dim,_Mode,_Options> >
+{
+  typedef _Scalar Scalar;
+  typedef Eigen::Index StorageIndex;
+  typedef Dense StorageKind;
+  enum {
+    Dim1 = _Dim==Dynamic ? _Dim : _Dim + 1,
+    RowsAtCompileTime = _Mode==Projective ? Dim1 : _Dim,
+    ColsAtCompileTime = Dim1,
+    MaxRowsAtCompileTime = RowsAtCompileTime,
+    MaxColsAtCompileTime = ColsAtCompileTime,
+    Flags = 0
+  };
+};
+
+template<int Mode> struct transform_make_affine;
+
+} // end namespace internal
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \class Transform
+  *
+  * \brief Represents an homogeneous transformation in a N dimensional space
+  *
+  * \tparam _Scalar the scalar type, i.e., the type of the coefficients
+  * \tparam _Dim the dimension of the space
+  * \tparam _Mode the type of the transformation. Can be:
+  *              - #Affine: the transformation is stored as a (Dim+1)^2 matrix,
+  *                         where the last row is assumed to be [0 ... 0 1].
+  *              - #AffineCompact: the transformation is stored as a (Dim)x(Dim+1) matrix.
+  *              - #Projective: the transformation is stored as a (Dim+1)^2 matrix
+  *                             without any assumption.
+  * \tparam _Options has the same meaning as in class Matrix. It allows to specify DontAlign and/or RowMajor.
+  *                  These Options are passed directly to the underlying matrix type.
+  *
+  * The homography is internally represented and stored by a matrix which
+  * is available through the matrix() method. To understand the behavior of
+  * this class you have to think a Transform object as its internal
+  * matrix representation. The chosen convention is right multiply:
+  *
+  * \code v' = T * v \endcode
+  *
+  * Therefore, an affine transformation matrix M is shaped like this:
+  *
+  * \f$ \left( \begin{array}{cc}
+  * linear & translation\\
+  * 0 ... 0 & 1
+  * \end{array} \right) \f$
+  *
+  * Note that for a projective transformation the last row can be anything,
+  * and then the interpretation of different parts might be sightly different.
+  *
+  * However, unlike a plain matrix, the Transform class provides many features
+  * simplifying both its assembly and usage. In particular, it can be composed
+  * with any other transformations (Transform,Translation,RotationBase,DiagonalMatrix)
+  * and can be directly used to transform implicit homogeneous vectors. All these
+  * operations are handled via the operator*. For the composition of transformations,
+  * its principle consists to first convert the right/left hand sides of the product
+  * to a compatible (Dim+1)^2 matrix and then perform a pure matrix product.
+  * Of course, internally, operator* tries to perform the minimal number of operations
+  * according to the nature of each terms. Likewise, when applying the transform
+  * to points, the latters are automatically promoted to homogeneous vectors
+  * before doing the matrix product. The conventions to homogeneous representations
+  * are performed as follow:
+  *
+  * \b Translation t (Dim)x(1):
+  * \f$ \left( \begin{array}{cc}
+  * I & t \\
+  * 0\,...\,0 & 1
+  * \end{array} \right) \f$
+  *
+  * \b Rotation R (Dim)x(Dim):
+  * \f$ \left( \begin{array}{cc}
+  * R & 0\\
+  * 0\,...\,0 & 1
+  * \end{array} \right) \f$
+  *<!--
+  * \b Linear \b Matrix L (Dim)x(Dim):
+  * \f$ \left( \begin{array}{cc}
+  * L & 0\\
+  * 0\,...\,0 & 1
+  * \end{array} \right) \f$
+  *
+  * \b Affine \b Matrix A (Dim)x(Dim+1):
+  * \f$ \left( \begin{array}{c}
+  * A\\
+  * 0\,...\,0\,1
+  * \end{array} \right) \f$
+  *-->
+  * \b Scaling \b DiagonalMatrix S (Dim)x(Dim):
+  * \f$ \left( \begin{array}{cc}
+  * S & 0\\
+  * 0\,...\,0 & 1
+  * \end{array} \right) \f$
+  *
+  * \b Column \b point v (Dim)x(1):
+  * \f$ \left( \begin{array}{c}
+  * v\\
+  * 1
+  * \end{array} \right) \f$
+  *
+  * \b Set \b of \b column \b points V1...Vn (Dim)x(n):
+  * \f$ \left( \begin{array}{ccc}
+  * v_1 & ... & v_n\\
+  * 1 & ... & 1
+  * \end{array} \right) \f$
+  *
+  * The concatenation of a Transform object with any kind of other transformation
+  * always returns a Transform object.
+  *
+  * A little exception to the "as pure matrix product" rule is the case of the
+  * transformation of non homogeneous vectors by an affine transformation. In
+  * that case the last matrix row can be ignored, and the product returns non
+  * homogeneous vectors.
+  *
+  * Since, for instance, a Dim x Dim matrix is interpreted as a linear transformation,
+  * it is not possible to directly transform Dim vectors stored in a Dim x Dim matrix.
+  * The solution is either to use a Dim x Dynamic matrix or explicitly request a
+  * vector transformation by making the vector homogeneous:
+  * \code
+  * m' = T * m.colwise().homogeneous();
+  * \endcode
+  * Note that there is zero overhead.
+  *
+  * Conversion methods from/to Qt's QMatrix and QTransform are available if the
+  * preprocessor token EIGEN_QT_SUPPORT is defined.
+  *
+  * This class can be extended with the help of the plugin mechanism described on the page
+  * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_TRANSFORM_PLUGIN.
+  *
+  * \sa class Matrix, class Quaternion
+  */
+template<typename _Scalar, int _Dim, int _Mode, int _Options>
+class Transform
+{
+public:
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_Dim==Dynamic ? Dynamic : (_Dim+1)*(_Dim+1))
+  enum {
+    Mode = _Mode,
+    Options = _Options,
+    Dim = _Dim,     ///< space dimension in which the transformation holds
+    HDim = _Dim+1,  ///< size of a respective homogeneous vector
+    Rows = int(Mode)==(AffineCompact) ? Dim : HDim
+  };
+  /** the scalar type of the coefficients */
+  typedef _Scalar Scalar;
+  typedef Eigen::Index StorageIndex;
+  typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+  /** type of the matrix used to represent the transformation */
+  typedef typename internal::make_proper_matrix_type<Scalar,Rows,HDim,Options>::type MatrixType;
+  /** constified MatrixType */
+  typedef const MatrixType ConstMatrixType;
+  /** type of the matrix used to represent the linear part of the transformation */
+  typedef Matrix<Scalar,Dim,Dim,Options> LinearMatrixType;
+  /** type of read/write reference to the linear part of the transformation */
+  typedef Block<MatrixType,Dim,Dim,int(Mode)==(AffineCompact) && (Options&RowMajor)==0> LinearPart;
+  /** type of read reference to the linear part of the transformation */
+  typedef const Block<ConstMatrixType,Dim,Dim,int(Mode)==(AffineCompact) && (Options&RowMajor)==0> ConstLinearPart;
+  /** type of read/write reference to the affine part of the transformation */
+  typedef typename internal::conditional<int(Mode)==int(AffineCompact),
+                              MatrixType&,
+                              Block<MatrixType,Dim,HDim> >::type AffinePart;
+  /** type of read reference to the affine part of the transformation */
+  typedef typename internal::conditional<int(Mode)==int(AffineCompact),
+                              const MatrixType&,
+                              const Block<const MatrixType,Dim,HDim> >::type ConstAffinePart;
+  /** type of a vector */
+  typedef Matrix<Scalar,Dim,1> VectorType;
+  /** type of a read/write reference to the translation part of the rotation */
+  typedef Block<MatrixType,Dim,1,!(internal::traits<MatrixType>::Flags & RowMajorBit)> TranslationPart;
+  /** type of a read reference to the translation part of the rotation */
+  typedef const Block<ConstMatrixType,Dim,1,!(internal::traits<MatrixType>::Flags & RowMajorBit)> ConstTranslationPart;
+  /** corresponding translation type */
+  typedef Translation<Scalar,Dim> TranslationType;
+  
+  // this intermediate enum is needed to avoid an ICE with gcc 3.4 and 4.0
+  enum { TransformTimeDiagonalMode = ((Mode==int(Isometry))?Affine:int(Mode)) };
+  /** The return type of the product between a diagonal matrix and a transform */
+  typedef Transform<Scalar,Dim,TransformTimeDiagonalMode> TransformTimeDiagonalReturnType;
+
+protected:
+
+  MatrixType m_matrix;
+
+public:
+
+  /** Default constructor without initialization of the meaningful coefficients.
+    * If Mode==Affine, then the last row is set to [0 ... 0 1] */
+  EIGEN_DEVICE_FUNC inline Transform()
+  {
+    check_template_params();
+    internal::transform_make_affine<(int(Mode)==Affine) ? Affine : AffineCompact>::run(m_matrix);
+  }
+
+  EIGEN_DEVICE_FUNC inline Transform(const Transform& other)
+  {
+    check_template_params();
+    m_matrix = other.m_matrix;
+  }
+
+  EIGEN_DEVICE_FUNC inline explicit Transform(const TranslationType& t)
+  {
+    check_template_params();
+    *this = t;
+  }
+  EIGEN_DEVICE_FUNC inline explicit Transform(const UniformScaling<Scalar>& s)
+  {
+    check_template_params();
+    *this = s;
+  }
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline explicit Transform(const RotationBase<Derived, Dim>& r)
+  {
+    check_template_params();
+    *this = r;
+  }
+
+  EIGEN_DEVICE_FUNC inline Transform& operator=(const Transform& other)
+  { m_matrix = other.m_matrix; return *this; }
+
+  typedef internal::transform_take_affine_part<Transform> take_affine_part;
+
+  /** Constructs and initializes a transformation from a Dim^2 or a (Dim+1)^2 matrix. */
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC inline explicit Transform(const EigenBase<OtherDerived>& other)
+  {
+    EIGEN_STATIC_ASSERT((internal::is_same<Scalar,typename OtherDerived::Scalar>::value),
+      YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY);
+
+    check_template_params();
+    internal::transform_construct_from_matrix<OtherDerived,Mode,Options,Dim,HDim>::run(this, other.derived());
+  }
+
+  /** Set \c *this from a Dim^2 or (Dim+1)^2 matrix. */
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC inline Transform& operator=(const EigenBase<OtherDerived>& other)
+  {
+    EIGEN_STATIC_ASSERT((internal::is_same<Scalar,typename OtherDerived::Scalar>::value),
+      YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY);
+
+    internal::transform_construct_from_matrix<OtherDerived,Mode,Options,Dim,HDim>::run(this, other.derived());
+    return *this;
+  }
+  
+  template<int OtherOptions>
+  EIGEN_DEVICE_FUNC inline Transform(const Transform<Scalar,Dim,Mode,OtherOptions>& other)
+  {
+    check_template_params();
+    // only the options change, we can directly copy the matrices
+    m_matrix = other.matrix();
+  }
+
+  template<int OtherMode,int OtherOptions>
+  EIGEN_DEVICE_FUNC inline Transform(const Transform<Scalar,Dim,OtherMode,OtherOptions>& other)
+  {
+    check_template_params();
+    // prevent conversions as:
+    // Affine | AffineCompact | Isometry = Projective
+    EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(OtherMode==int(Projective), Mode==int(Projective)),
+                        YOU_PERFORMED_AN_INVALID_TRANSFORMATION_CONVERSION)
+
+    // prevent conversions as:
+    // Isometry = Affine | AffineCompact
+    EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(OtherMode==int(Affine)||OtherMode==int(AffineCompact), Mode!=int(Isometry)),
+                        YOU_PERFORMED_AN_INVALID_TRANSFORMATION_CONVERSION)
+
+    enum { ModeIsAffineCompact = Mode == int(AffineCompact),
+           OtherModeIsAffineCompact = OtherMode == int(AffineCompact)
+    };
+
+    if(EIGEN_CONST_CONDITIONAL(ModeIsAffineCompact == OtherModeIsAffineCompact))
+    {
+      // We need the block expression because the code is compiled for all
+      // combinations of transformations and will trigger a compile time error
+      // if one tries to assign the matrices directly
+      m_matrix.template block<Dim,Dim+1>(0,0) = other.matrix().template block<Dim,Dim+1>(0,0);
+      makeAffine();
+    }
+    else if(EIGEN_CONST_CONDITIONAL(OtherModeIsAffineCompact))
+    {
+      typedef typename Transform<Scalar,Dim,OtherMode,OtherOptions>::MatrixType OtherMatrixType;
+      internal::transform_construct_from_matrix<OtherMatrixType,Mode,Options,Dim,HDim>::run(this, other.matrix());
+    }
+    else
+    {
+      // here we know that Mode == AffineCompact and OtherMode != AffineCompact.
+      // if OtherMode were Projective, the static assert above would already have caught it.
+      // So the only possibility is that OtherMode == Affine
+      linear() = other.linear();
+      translation() = other.translation();
+    }
+  }
+
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC Transform(const ReturnByValue<OtherDerived>& other)
+  {
+    check_template_params();
+    other.evalTo(*this);
+  }
+
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC Transform& operator=(const ReturnByValue<OtherDerived>& other)
+  {
+    other.evalTo(*this);
+    return *this;
+  }
+
+  #ifdef EIGEN_QT_SUPPORT
+  inline Transform(const QMatrix& other);
+  inline Transform& operator=(const QMatrix& other);
+  inline QMatrix toQMatrix(void) const;
+  inline Transform(const QTransform& other);
+  inline Transform& operator=(const QTransform& other);
+  inline QTransform toQTransform(void) const;
+  #endif
+  
+  EIGEN_DEVICE_FUNC Index rows() const { return int(Mode)==int(Projective) ? m_matrix.cols() : (m_matrix.cols()-1); }
+  EIGEN_DEVICE_FUNC Index cols() const { return m_matrix.cols(); }
+
+  /** shortcut for m_matrix(row,col);
+    * \sa MatrixBase::operator(Index,Index) const */
+  EIGEN_DEVICE_FUNC inline Scalar operator() (Index row, Index col) const { return m_matrix(row,col); }
+  /** shortcut for m_matrix(row,col);
+    * \sa MatrixBase::operator(Index,Index) */
+  EIGEN_DEVICE_FUNC inline Scalar& operator() (Index row, Index col) { return m_matrix(row,col); }
+
+  /** \returns a read-only expression of the transformation matrix */
+  EIGEN_DEVICE_FUNC inline const MatrixType& matrix() const { return m_matrix; }
+  /** \returns a writable expression of the transformation matrix */
+  EIGEN_DEVICE_FUNC inline MatrixType& matrix() { return m_matrix; }
+
+  /** \returns a read-only expression of the linear part of the transformation */
+  EIGEN_DEVICE_FUNC inline ConstLinearPart linear() const { return ConstLinearPart(m_matrix,0,0); }
+  /** \returns a writable expression of the linear part of the transformation */
+  EIGEN_DEVICE_FUNC inline LinearPart linear() { return LinearPart(m_matrix,0,0); }
+
+  /** \returns a read-only expression of the Dim x HDim affine part of the transformation */
+  EIGEN_DEVICE_FUNC inline ConstAffinePart affine() const { return take_affine_part::run(m_matrix); }
+  /** \returns a writable expression of the Dim x HDim affine part of the transformation */
+  EIGEN_DEVICE_FUNC inline AffinePart affine() { return take_affine_part::run(m_matrix); }
+
+  /** \returns a read-only expression of the translation vector of the transformation */
+  EIGEN_DEVICE_FUNC inline ConstTranslationPart translation() const { return ConstTranslationPart(m_matrix,0,Dim); }
+  /** \returns a writable expression of the translation vector of the transformation */
+  EIGEN_DEVICE_FUNC inline TranslationPart translation() { return TranslationPart(m_matrix,0,Dim); }
+
+  /** \returns an expression of the product between the transform \c *this and a matrix expression \a other.
+    *
+    * The right-hand-side \a other can be either:
+    * \li an homogeneous vector of size Dim+1,
+    * \li a set of homogeneous vectors of size Dim+1 x N,
+    * \li a transformation matrix of size Dim+1 x Dim+1.
+    *
+    * Moreover, if \c *this represents an affine transformation (i.e., Mode!=Projective), then \a other can also be:
+    * \li a point of size Dim (computes: \code this->linear() * other + this->translation()\endcode),
+    * \li a set of N points as a Dim x N matrix (computes: \code (this->linear() * other).colwise() + this->translation()\endcode),
+    *
+    * In all cases, the return type is a matrix or vector of same sizes as the right-hand-side \a other.
+    *
+    * If you want to interpret \a other as a linear or affine transformation, then first convert it to a Transform<> type,
+    * or do your own cooking.
+    *
+    * Finally, if you want to apply Affine transformations to vectors, then explicitly apply the linear part only:
+    * \code
+    * Affine3f A;
+    * Vector3f v1, v2;
+    * v2 = A.linear() * v1;
+    * \endcode
+    *
+    */
+  // note: this function is defined here because some compilers cannot find the respective declaration
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename internal::transform_right_product_impl<Transform, OtherDerived>::ResultType
+  operator * (const EigenBase<OtherDerived> &other) const
+  { return internal::transform_right_product_impl<Transform, OtherDerived>::run(*this,other.derived()); }
+
+  /** \returns the product expression of a transformation matrix \a a times a transform \a b
+    *
+    * The left hand side \a other can be either:
+    * \li a linear transformation matrix of size Dim x Dim,
+    * \li an affine transformation matrix of size Dim x Dim+1,
+    * \li a general transformation matrix of size Dim+1 x Dim+1.
+    */
+  template<typename OtherDerived> friend
+  EIGEN_DEVICE_FUNC inline const typename internal::transform_left_product_impl<OtherDerived,Mode,Options,_Dim,_Dim+1>::ResultType
+    operator * (const EigenBase<OtherDerived> &a, const Transform &b)
+  { return internal::transform_left_product_impl<OtherDerived,Mode,Options,Dim,HDim>::run(a.derived(),b); }
+
+  /** \returns The product expression of a transform \a a times a diagonal matrix \a b
+    *
+    * The rhs diagonal matrix is interpreted as an affine scaling transformation. The
+    * product results in a Transform of the same type (mode) as the lhs only if the lhs 
+    * mode is no isometry. In that case, the returned transform is an affinity.
+    */
+  template<typename DiagonalDerived>
+  EIGEN_DEVICE_FUNC inline const TransformTimeDiagonalReturnType
+    operator * (const DiagonalBase<DiagonalDerived> &b) const
+  {
+    TransformTimeDiagonalReturnType res(*this);
+    res.linearExt() *= b;
+    return res;
+  }
+
+  /** \returns The product expression of a diagonal matrix \a a times a transform \a b
+    *
+    * The lhs diagonal matrix is interpreted as an affine scaling transformation. The
+    * product results in a Transform of the same type (mode) as the lhs only if the lhs 
+    * mode is no isometry. In that case, the returned transform is an affinity.
+    */
+  template<typename DiagonalDerived>
+  EIGEN_DEVICE_FUNC friend inline TransformTimeDiagonalReturnType
+    operator * (const DiagonalBase<DiagonalDerived> &a, const Transform &b)
+  {
+    TransformTimeDiagonalReturnType res;
+    res.linear().noalias() = a*b.linear();
+    res.translation().noalias() = a*b.translation();
+    if (EIGEN_CONST_CONDITIONAL(Mode!=int(AffineCompact)))
+      res.matrix().row(Dim) = b.matrix().row(Dim);
+    return res;
+  }
+
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC inline Transform& operator*=(const EigenBase<OtherDerived>& other) { return *this = *this * other; }
+
+  /** Concatenates two transformations */
+  EIGEN_DEVICE_FUNC inline const Transform operator * (const Transform& other) const
+  {
+    return internal::transform_transform_product_impl<Transform,Transform>::run(*this,other);
+  }
+  
+  #if EIGEN_COMP_ICC
+private:
+  // this intermediate structure permits to workaround a bug in ICC 11:
+  //   error: template instantiation resulted in unexpected function type of "Eigen::Transform<double, 3, 32, 0>
+  //             (const Eigen::Transform<double, 3, 2, 0> &) const"
+  //  (the meaning of a name may have changed since the template declaration -- the type of the template is:
+  // "Eigen::internal::transform_transform_product_impl<Eigen::Transform<double, 3, 32, 0>,
+  //     Eigen::Transform<double, 3, Mode, Options>, <expression>>::ResultType (const Eigen::Transform<double, 3, Mode, Options> &) const")
+  // 
+  template<int OtherMode,int OtherOptions> struct icc_11_workaround
+  {
+    typedef internal::transform_transform_product_impl<Transform,Transform<Scalar,Dim,OtherMode,OtherOptions> > ProductType;
+    typedef typename ProductType::ResultType ResultType;
+  };
+  
+public:
+  /** Concatenates two different transformations */
+  template<int OtherMode,int OtherOptions>
+  inline typename icc_11_workaround<OtherMode,OtherOptions>::ResultType
+    operator * (const Transform<Scalar,Dim,OtherMode,OtherOptions>& other) const
+  {
+    typedef typename icc_11_workaround<OtherMode,OtherOptions>::ProductType ProductType;
+    return ProductType::run(*this,other);
+  }
+  #else
+  /** Concatenates two different transformations */
+  template<int OtherMode,int OtherOptions>
+  EIGEN_DEVICE_FUNC inline typename internal::transform_transform_product_impl<Transform,Transform<Scalar,Dim,OtherMode,OtherOptions> >::ResultType
+    operator * (const Transform<Scalar,Dim,OtherMode,OtherOptions>& other) const
+  {
+    return internal::transform_transform_product_impl<Transform,Transform<Scalar,Dim,OtherMode,OtherOptions> >::run(*this,other);
+  }
+  #endif
+
+  /** \sa MatrixBase::setIdentity() */
+  EIGEN_DEVICE_FUNC void setIdentity() { m_matrix.setIdentity(); }
+
+  /**
+   * \brief Returns an identity transformation.
+   * \todo In the future this function should be returning a Transform expression.
+   */
+  EIGEN_DEVICE_FUNC static const Transform Identity()
+  {
+    return Transform(MatrixType::Identity());
+  }
+
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC 
+  inline Transform& scale(const MatrixBase<OtherDerived> &other);
+
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC
+  inline Transform& prescale(const MatrixBase<OtherDerived> &other);
+
+  EIGEN_DEVICE_FUNC inline Transform& scale(const Scalar& s);
+  EIGEN_DEVICE_FUNC inline Transform& prescale(const Scalar& s);
+
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC
+  inline Transform& translate(const MatrixBase<OtherDerived> &other);
+
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC
+  inline Transform& pretranslate(const MatrixBase<OtherDerived> &other);
+
+  template<typename RotationType>
+  EIGEN_DEVICE_FUNC
+  inline Transform& rotate(const RotationType& rotation);
+
+  template<typename RotationType>
+  EIGEN_DEVICE_FUNC
+  inline Transform& prerotate(const RotationType& rotation);
+
+  EIGEN_DEVICE_FUNC Transform& shear(const Scalar& sx, const Scalar& sy);
+  EIGEN_DEVICE_FUNC Transform& preshear(const Scalar& sx, const Scalar& sy);
+
+  EIGEN_DEVICE_FUNC inline Transform& operator=(const TranslationType& t);
+  
+  EIGEN_DEVICE_FUNC
+  inline Transform& operator*=(const TranslationType& t) { return translate(t.vector()); }
+  
+  EIGEN_DEVICE_FUNC inline Transform operator*(const TranslationType& t) const;
+
+  EIGEN_DEVICE_FUNC 
+  inline Transform& operator=(const UniformScaling<Scalar>& t);
+  
+  EIGEN_DEVICE_FUNC
+  inline Transform& operator*=(const UniformScaling<Scalar>& s) { return scale(s.factor()); }
+  
+  EIGEN_DEVICE_FUNC
+  inline TransformTimeDiagonalReturnType operator*(const UniformScaling<Scalar>& s) const
+  {
+    TransformTimeDiagonalReturnType res = *this;
+    res.scale(s.factor());
+    return res;
+  }
+
+  EIGEN_DEVICE_FUNC
+  inline Transform& operator*=(const DiagonalMatrix<Scalar,Dim>& s) { linearExt() *= s; return *this; }
+
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline Transform& operator=(const RotationBase<Derived,Dim>& r);
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline Transform& operator*=(const RotationBase<Derived,Dim>& r) { return rotate(r.toRotationMatrix()); }
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline Transform operator*(const RotationBase<Derived,Dim>& r) const;
+
+  EIGEN_DEVICE_FUNC const LinearMatrixType rotation() const;
+  template<typename RotationMatrixType, typename ScalingMatrixType>
+  EIGEN_DEVICE_FUNC
+  void computeRotationScaling(RotationMatrixType *rotation, ScalingMatrixType *scaling) const;
+  template<typename ScalingMatrixType, typename RotationMatrixType>
+  EIGEN_DEVICE_FUNC
+  void computeScalingRotation(ScalingMatrixType *scaling, RotationMatrixType *rotation) const;
+
+  template<typename PositionDerived, typename OrientationType, typename ScaleDerived>
+  EIGEN_DEVICE_FUNC
+  Transform& fromPositionOrientationScale(const MatrixBase<PositionDerived> &position,
+    const OrientationType& orientation, const MatrixBase<ScaleDerived> &scale);
+
+  EIGEN_DEVICE_FUNC
+  inline Transform inverse(TransformTraits traits = (TransformTraits)Mode) const;
+
+  /** \returns a const pointer to the column major internal matrix */
+  EIGEN_DEVICE_FUNC const Scalar* data() const { return m_matrix.data(); }
+  /** \returns a non-const pointer to the column major internal matrix */
+  EIGEN_DEVICE_FUNC Scalar* data() { return m_matrix.data(); }
+
+  /** \returns \c *this with scalar type casted to \a NewScalarType
+    *
+    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
+    * then this function smartly returns a const reference to \c *this.
+    */
+  template<typename NewScalarType>
+  EIGEN_DEVICE_FUNC inline typename internal::cast_return_type<Transform,Transform<NewScalarType,Dim,Mode,Options> >::type cast() const
+  { return typename internal::cast_return_type<Transform,Transform<NewScalarType,Dim,Mode,Options> >::type(*this); }
+
+  /** Copy constructor with scalar type conversion */
+  template<typename OtherScalarType>
+  EIGEN_DEVICE_FUNC inline explicit Transform(const Transform<OtherScalarType,Dim,Mode,Options>& other)
+  {
+    check_template_params();
+    m_matrix = other.matrix().template cast<Scalar>();
+  }
+
+  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
+    * determined by \a prec.
+    *
+    * \sa MatrixBase::isApprox() */
+  EIGEN_DEVICE_FUNC bool isApprox(const Transform& other, const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const
+  { return m_matrix.isApprox(other.m_matrix, prec); }
+
+  /** Sets the last row to [0 ... 0 1]
+    */
+  EIGEN_DEVICE_FUNC void makeAffine()
+  {
+    internal::transform_make_affine<int(Mode)>::run(m_matrix);
+  }
+
+  /** \internal
+    * \returns the Dim x Dim linear part if the transformation is affine,
+    *          and the HDim x Dim part for projective transformations.
+    */
+  EIGEN_DEVICE_FUNC inline Block<MatrixType,int(Mode)==int(Projective)?HDim:Dim,Dim> linearExt()
+  { return m_matrix.template block<int(Mode)==int(Projective)?HDim:Dim,Dim>(0,0); }
+  /** \internal
+    * \returns the Dim x Dim linear part if the transformation is affine,
+    *          and the HDim x Dim part for projective transformations.
+    */
+  EIGEN_DEVICE_FUNC inline const Block<MatrixType,int(Mode)==int(Projective)?HDim:Dim,Dim> linearExt() const
+  { return m_matrix.template block<int(Mode)==int(Projective)?HDim:Dim,Dim>(0,0); }
+
+  /** \internal
+    * \returns the translation part if the transformation is affine,
+    *          and the last column for projective transformations.
+    */
+  EIGEN_DEVICE_FUNC inline Block<MatrixType,int(Mode)==int(Projective)?HDim:Dim,1> translationExt()
+  { return m_matrix.template block<int(Mode)==int(Projective)?HDim:Dim,1>(0,Dim); }
+  /** \internal
+    * \returns the translation part if the transformation is affine,
+    *          and the last column for projective transformations.
+    */
+  EIGEN_DEVICE_FUNC inline const Block<MatrixType,int(Mode)==int(Projective)?HDim:Dim,1> translationExt() const
+  { return m_matrix.template block<int(Mode)==int(Projective)?HDim:Dim,1>(0,Dim); }
+
+
+  #ifdef EIGEN_TRANSFORM_PLUGIN
+  #include EIGEN_TRANSFORM_PLUGIN
+  #endif
+  
+protected:
+  #ifndef EIGEN_PARSED_BY_DOXYGEN
+    EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void check_template_params()
+    {
+      EIGEN_STATIC_ASSERT((Options & (DontAlign|RowMajor)) == Options, INVALID_MATRIX_TEMPLATE_PARAMETERS)
+    }
+  #endif
+
+};
+
+/** \ingroup Geometry_Module */
+typedef Transform<float,2,Isometry> Isometry2f;
+/** \ingroup Geometry_Module */
+typedef Transform<float,3,Isometry> Isometry3f;
+/** \ingroup Geometry_Module */
+typedef Transform<double,2,Isometry> Isometry2d;
+/** \ingroup Geometry_Module */
+typedef Transform<double,3,Isometry> Isometry3d;
+
+/** \ingroup Geometry_Module */
+typedef Transform<float,2,Affine> Affine2f;
+/** \ingroup Geometry_Module */
+typedef Transform<float,3,Affine> Affine3f;
+/** \ingroup Geometry_Module */
+typedef Transform<double,2,Affine> Affine2d;
+/** \ingroup Geometry_Module */
+typedef Transform<double,3,Affine> Affine3d;
+
+/** \ingroup Geometry_Module */
+typedef Transform<float,2,AffineCompact> AffineCompact2f;
+/** \ingroup Geometry_Module */
+typedef Transform<float,3,AffineCompact> AffineCompact3f;
+/** \ingroup Geometry_Module */
+typedef Transform<double,2,AffineCompact> AffineCompact2d;
+/** \ingroup Geometry_Module */
+typedef Transform<double,3,AffineCompact> AffineCompact3d;
+
+/** \ingroup Geometry_Module */
+typedef Transform<float,2,Projective> Projective2f;
+/** \ingroup Geometry_Module */
+typedef Transform<float,3,Projective> Projective3f;
+/** \ingroup Geometry_Module */
+typedef Transform<double,2,Projective> Projective2d;
+/** \ingroup Geometry_Module */
+typedef Transform<double,3,Projective> Projective3d;
+
+/**************************
+*** Optional QT support ***
+**************************/
+
+#ifdef EIGEN_QT_SUPPORT
+/** Initializes \c *this from a QMatrix assuming the dimension is 2.
+  *
+  * This function is available only if the token EIGEN_QT_SUPPORT is defined.
+  */
+template<typename Scalar, int Dim, int Mode,int Options>
+Transform<Scalar,Dim,Mode,Options>::Transform(const QMatrix& other)
+{
+  check_template_params();
+  *this = other;
+}
+
+/** Set \c *this from a QMatrix assuming the dimension is 2.
+  *
+  * This function is available only if the token EIGEN_QT_SUPPORT is defined.
+  */
+template<typename Scalar, int Dim, int Mode,int Options>
+Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::operator=(const QMatrix& other)
+{
+  EIGEN_STATIC_ASSERT(Dim==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
+  if (EIGEN_CONST_CONDITIONAL(Mode == int(AffineCompact)))
+    m_matrix << other.m11(), other.m21(), other.dx(),
+                other.m12(), other.m22(), other.dy();
+  else
+    m_matrix << other.m11(), other.m21(), other.dx(),
+                other.m12(), other.m22(), other.dy(),
+                0, 0, 1;
+  return *this;
+}
+
+/** \returns a QMatrix from \c *this assuming the dimension is 2.
+  *
+  * \warning this conversion might loss data if \c *this is not affine
+  *
+  * This function is available only if the token EIGEN_QT_SUPPORT is defined.
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+QMatrix Transform<Scalar,Dim,Mode,Options>::toQMatrix(void) const
+{
+  check_template_params();
+  EIGEN_STATIC_ASSERT(Dim==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
+  return QMatrix(m_matrix.coeff(0,0), m_matrix.coeff(1,0),
+                 m_matrix.coeff(0,1), m_matrix.coeff(1,1),
+                 m_matrix.coeff(0,2), m_matrix.coeff(1,2));
+}
+
+/** Initializes \c *this from a QTransform assuming the dimension is 2.
+  *
+  * This function is available only if the token EIGEN_QT_SUPPORT is defined.
+  */
+template<typename Scalar, int Dim, int Mode,int Options>
+Transform<Scalar,Dim,Mode,Options>::Transform(const QTransform& other)
+{
+  check_template_params();
+  *this = other;
+}
+
+/** Set \c *this from a QTransform assuming the dimension is 2.
+  *
+  * This function is available only if the token EIGEN_QT_SUPPORT is defined.
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::operator=(const QTransform& other)
+{
+  check_template_params();
+  EIGEN_STATIC_ASSERT(Dim==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
+  if (EIGEN_CONST_CONDITIONAL(Mode == int(AffineCompact)))
+    m_matrix << other.m11(), other.m21(), other.dx(),
+                other.m12(), other.m22(), other.dy();
+  else
+    m_matrix << other.m11(), other.m21(), other.dx(),
+                other.m12(), other.m22(), other.dy(),
+                other.m13(), other.m23(), other.m33();
+  return *this;
+}
+
+/** \returns a QTransform from \c *this assuming the dimension is 2.
+  *
+  * This function is available only if the token EIGEN_QT_SUPPORT is defined.
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+QTransform Transform<Scalar,Dim,Mode,Options>::toQTransform(void) const
+{
+  EIGEN_STATIC_ASSERT(Dim==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
+  if (EIGEN_CONST_CONDITIONAL(Mode == int(AffineCompact)))
+    return QTransform(m_matrix.coeff(0,0), m_matrix.coeff(1,0),
+                      m_matrix.coeff(0,1), m_matrix.coeff(1,1),
+                      m_matrix.coeff(0,2), m_matrix.coeff(1,2));
+  else
+    return QTransform(m_matrix.coeff(0,0), m_matrix.coeff(1,0), m_matrix.coeff(2,0),
+                      m_matrix.coeff(0,1), m_matrix.coeff(1,1), m_matrix.coeff(2,1),
+                      m_matrix.coeff(0,2), m_matrix.coeff(1,2), m_matrix.coeff(2,2));
+}
+#endif
+
+/*********************
+*** Procedural API ***
+*********************/
+
+/** Applies on the right the non uniform scale transformation represented
+  * by the vector \a other to \c *this and returns a reference to \c *this.
+  * \sa prescale()
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
+Transform<Scalar,Dim,Mode,Options>::scale(const MatrixBase<OtherDerived> &other)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,int(Dim))
+  EIGEN_STATIC_ASSERT(Mode!=int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
+  linearExt().noalias() = (linearExt() * other.asDiagonal());
+  return *this;
+}
+
+/** Applies on the right a uniform scale of a factor \a c to \c *this
+  * and returns a reference to \c *this.
+  * \sa prescale(Scalar)
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::scale(const Scalar& s)
+{
+  EIGEN_STATIC_ASSERT(Mode!=int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
+  linearExt() *= s;
+  return *this;
+}
+
+/** Applies on the left the non uniform scale transformation represented
+  * by the vector \a other to \c *this and returns a reference to \c *this.
+  * \sa scale()
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
+Transform<Scalar,Dim,Mode,Options>::prescale(const MatrixBase<OtherDerived> &other)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,int(Dim))
+  EIGEN_STATIC_ASSERT(Mode!=int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
+  affine().noalias() = (other.asDiagonal() * affine());
+  return *this;
+}
+
+/** Applies on the left a uniform scale of a factor \a c to \c *this
+  * and returns a reference to \c *this.
+  * \sa scale(Scalar)
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::prescale(const Scalar& s)
+{
+  EIGEN_STATIC_ASSERT(Mode!=int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
+  m_matrix.template topRows<Dim>() *= s;
+  return *this;
+}
+
+/** Applies on the right the translation matrix represented by the vector \a other
+  * to \c *this and returns a reference to \c *this.
+  * \sa pretranslate()
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
+Transform<Scalar,Dim,Mode,Options>::translate(const MatrixBase<OtherDerived> &other)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,int(Dim))
+  translationExt() += linearExt() * other;
+  return *this;
+}
+
+/** Applies on the left the translation matrix represented by the vector \a other
+  * to \c *this and returns a reference to \c *this.
+  * \sa translate()
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
+Transform<Scalar,Dim,Mode,Options>::pretranslate(const MatrixBase<OtherDerived> &other)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,int(Dim))
+  if(EIGEN_CONST_CONDITIONAL(int(Mode)==int(Projective)))
+    affine() += other * m_matrix.row(Dim);
+  else
+    translation() += other;
+  return *this;
+}
+
+/** Applies on the right the rotation represented by the rotation \a rotation
+  * to \c *this and returns a reference to \c *this.
+  *
+  * The template parameter \a RotationType is the type of the rotation which
+  * must be known by internal::toRotationMatrix<>.
+  *
+  * Natively supported types includes:
+  *   - any scalar (2D),
+  *   - a Dim x Dim matrix expression,
+  *   - a Quaternion (3D),
+  *   - a AngleAxis (3D)
+  *
+  * This mechanism is easily extendable to support user types such as Euler angles,
+  * or a pair of Quaternion for 4D rotations.
+  *
+  * \sa rotate(Scalar), class Quaternion, class AngleAxis, prerotate(RotationType)
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename RotationType>
+EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
+Transform<Scalar,Dim,Mode,Options>::rotate(const RotationType& rotation)
+{
+  linearExt() *= internal::toRotationMatrix<Scalar,Dim>(rotation);
+  return *this;
+}
+
+/** Applies on the left the rotation represented by the rotation \a rotation
+  * to \c *this and returns a reference to \c *this.
+  *
+  * See rotate() for further details.
+  *
+  * \sa rotate()
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename RotationType>
+EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
+Transform<Scalar,Dim,Mode,Options>::prerotate(const RotationType& rotation)
+{
+  m_matrix.template block<Dim,HDim>(0,0) = internal::toRotationMatrix<Scalar,Dim>(rotation)
+                                         * m_matrix.template block<Dim,HDim>(0,0);
+  return *this;
+}
+
+/** Applies on the right the shear transformation represented
+  * by the vector \a other to \c *this and returns a reference to \c *this.
+  * \warning 2D only.
+  * \sa preshear()
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
+Transform<Scalar,Dim,Mode,Options>::shear(const Scalar& sx, const Scalar& sy)
+{
+  EIGEN_STATIC_ASSERT(int(Dim)==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
+  EIGEN_STATIC_ASSERT(Mode!=int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
+  VectorType tmp = linear().col(0)*sy + linear().col(1);
+  linear() << linear().col(0) + linear().col(1)*sx, tmp;
+  return *this;
+}
+
+/** Applies on the left the shear transformation represented
+  * by the vector \a other to \c *this and returns a reference to \c *this.
+  * \warning 2D only.
+  * \sa shear()
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
+Transform<Scalar,Dim,Mode,Options>::preshear(const Scalar& sx, const Scalar& sy)
+{
+  EIGEN_STATIC_ASSERT(int(Dim)==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
+  EIGEN_STATIC_ASSERT(Mode!=int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
+  m_matrix.template block<Dim,HDim>(0,0) = LinearMatrixType(1, sx, sy, 1) * m_matrix.template block<Dim,HDim>(0,0);
+  return *this;
+}
+
+/******************************************************
+*** Scaling, Translation and Rotation compatibility ***
+******************************************************/
+
+template<typename Scalar, int Dim, int Mode, int Options>
+EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::operator=(const TranslationType& t)
+{
+  linear().setIdentity();
+  translation() = t.vector();
+  makeAffine();
+  return *this;
+}
+
+template<typename Scalar, int Dim, int Mode, int Options>
+EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode,Options> Transform<Scalar,Dim,Mode,Options>::operator*(const TranslationType& t) const
+{
+  Transform res = *this;
+  res.translate(t.vector());
+  return res;
+}
+
+template<typename Scalar, int Dim, int Mode, int Options>
+EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::operator=(const UniformScaling<Scalar>& s)
+{
+  m_matrix.setZero();
+  linear().diagonal().fill(s.factor());
+  makeAffine();
+  return *this;
+}
+
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::operator=(const RotationBase<Derived,Dim>& r)
+{
+  linear() = internal::toRotationMatrix<Scalar,Dim>(r);
+  translation().setZero();
+  makeAffine();
+  return *this;
+}
+
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode,Options> Transform<Scalar,Dim,Mode,Options>::operator*(const RotationBase<Derived,Dim>& r) const
+{
+  Transform res = *this;
+  res.rotate(r.derived());
+  return res;
+}
+
+/************************
+*** Special functions ***
+************************/
+
+/** \returns the rotation part of the transformation
+  *
+  *
+  * \svd_module
+  *
+  * \sa computeRotationScaling(), computeScalingRotation(), class SVD
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+EIGEN_DEVICE_FUNC const typename Transform<Scalar,Dim,Mode,Options>::LinearMatrixType
+Transform<Scalar,Dim,Mode,Options>::rotation() const
+{
+  LinearMatrixType result;
+  computeRotationScaling(&result, (LinearMatrixType*)0);
+  return result;
+}
+
+
+/** decomposes the linear part of the transformation as a product rotation x scaling, the scaling being
+  * not necessarily positive.
+  *
+  * If either pointer is zero, the corresponding computation is skipped.
+  *
+  *
+  *
+  * \svd_module
+  *
+  * \sa computeScalingRotation(), rotation(), class SVD
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename RotationMatrixType, typename ScalingMatrixType>
+EIGEN_DEVICE_FUNC void Transform<Scalar,Dim,Mode,Options>::computeRotationScaling(RotationMatrixType *rotation, ScalingMatrixType *scaling) const
+{
+  JacobiSVD<LinearMatrixType> svd(linear(), ComputeFullU | ComputeFullV);
+
+  Scalar x = (svd.matrixU() * svd.matrixV().adjoint()).determinant(); // so x has absolute value 1
+  VectorType sv(svd.singularValues());
+  sv.coeffRef(0) *= x;
+  if(scaling) scaling->lazyAssign(svd.matrixV() * sv.asDiagonal() * svd.matrixV().adjoint());
+  if(rotation)
+  {
+    LinearMatrixType m(svd.matrixU());
+    m.col(0) /= x;
+    rotation->lazyAssign(m * svd.matrixV().adjoint());
+  }
+}
+
+/** decomposes the linear part of the transformation as a product scaling x rotation, the scaling being
+  * not necessarily positive.
+  *
+  * If either pointer is zero, the corresponding computation is skipped.
+  *
+  *
+  *
+  * \svd_module
+  *
+  * \sa computeRotationScaling(), rotation(), class SVD
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename ScalingMatrixType, typename RotationMatrixType>
+EIGEN_DEVICE_FUNC void Transform<Scalar,Dim,Mode,Options>::computeScalingRotation(ScalingMatrixType *scaling, RotationMatrixType *rotation) const
+{
+  JacobiSVD<LinearMatrixType> svd(linear(), ComputeFullU | ComputeFullV);
+
+  Scalar x = (svd.matrixU() * svd.matrixV().adjoint()).determinant(); // so x has absolute value 1
+  VectorType sv(svd.singularValues());
+  sv.coeffRef(0) *= x;
+  if(scaling) scaling->lazyAssign(svd.matrixU() * sv.asDiagonal() * svd.matrixU().adjoint());
+  if(rotation)
+  {
+    LinearMatrixType m(svd.matrixU());
+    m.col(0) /= x;
+    rotation->lazyAssign(m * svd.matrixV().adjoint());
+  }
+}
+
+/** Convenient method to set \c *this from a position, orientation and scale
+  * of a 3D object.
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename PositionDerived, typename OrientationType, typename ScaleDerived>
+EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
+Transform<Scalar,Dim,Mode,Options>::fromPositionOrientationScale(const MatrixBase<PositionDerived> &position,
+  const OrientationType& orientation, const MatrixBase<ScaleDerived> &scale)
+{
+  linear() = internal::toRotationMatrix<Scalar,Dim>(orientation);
+  linear() *= scale.asDiagonal();
+  translation() = position;
+  makeAffine();
+  return *this;
+}
+
+namespace internal {
+
+template<int Mode>
+struct transform_make_affine
+{
+  template<typename MatrixType>
+  EIGEN_DEVICE_FUNC static void run(MatrixType &mat)
+  {
+    static const int Dim = MatrixType::ColsAtCompileTime-1;
+    mat.template block<1,Dim>(Dim,0).setZero();
+    mat.coeffRef(Dim,Dim) = typename MatrixType::Scalar(1);
+  }
+};
+
+template<>
+struct transform_make_affine<AffineCompact>
+{
+  template<typename MatrixType> EIGEN_DEVICE_FUNC static void run(MatrixType &) { }
+};
+    
+// selector needed to avoid taking the inverse of a 3x4 matrix
+template<typename TransformType, int Mode=TransformType::Mode>
+struct projective_transform_inverse
+{
+  EIGEN_DEVICE_FUNC static inline void run(const TransformType&, TransformType&)
+  {}
+};
+
+template<typename TransformType>
+struct projective_transform_inverse<TransformType, Projective>
+{
+  EIGEN_DEVICE_FUNC static inline void run(const TransformType& m, TransformType& res)
+  {
+    res.matrix() = m.matrix().inverse();
+  }
+};
+
+} // end namespace internal
+
+
+/**
+  *
+  * \returns the inverse transformation according to some given knowledge
+  * on \c *this.
+  *
+  * \param hint allows to optimize the inversion process when the transformation
+  * is known to be not a general transformation (optional). The possible values are:
+  *  - #Projective if the transformation is not necessarily affine, i.e., if the
+  *    last row is not guaranteed to be [0 ... 0 1]
+  *  - #Affine if the last row can be assumed to be [0 ... 0 1]
+  *  - #Isometry if the transformation is only a concatenations of translations
+  *    and rotations.
+  *  The default is the template class parameter \c Mode.
+  *
+  * \warning unless \a traits is always set to NoShear or NoScaling, this function
+  * requires the generic inverse method of MatrixBase defined in the LU module. If
+  * you forget to include this module, then you will get hard to debug linking errors.
+  *
+  * \sa MatrixBase::inverse()
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>
+Transform<Scalar,Dim,Mode,Options>::inverse(TransformTraits hint) const
+{
+  Transform res;
+  if (hint == Projective)
+  {
+    internal::projective_transform_inverse<Transform>::run(*this, res);
+  }
+  else
+  {
+    if (hint == Isometry)
+    {
+      res.matrix().template topLeftCorner<Dim,Dim>() = linear().transpose();
+    }
+    else if(hint&Affine)
+    {
+      res.matrix().template topLeftCorner<Dim,Dim>() = linear().inverse();
+    }
+    else
+    {
+      eigen_assert(false && "Invalid transform traits in Transform::Inverse");
+    }
+    // translation and remaining parts
+    res.matrix().template topRightCorner<Dim,1>()
+      = - res.matrix().template topLeftCorner<Dim,Dim>() * translation();
+    res.makeAffine(); // we do need this, because in the beginning res is uninitialized
+  }
+  return res;
+}
+
+namespace internal {
+
+/*****************************************************
+*** Specializations of take affine part            ***
+*****************************************************/
+
+template<typename TransformType> struct transform_take_affine_part {
+  typedef typename TransformType::MatrixType MatrixType;
+  typedef typename TransformType::AffinePart AffinePart;
+  typedef typename TransformType::ConstAffinePart ConstAffinePart;
+  static inline AffinePart run(MatrixType& m)
+  { return m.template block<TransformType::Dim,TransformType::HDim>(0,0); }
+  static inline ConstAffinePart run(const MatrixType& m)
+  { return m.template block<TransformType::Dim,TransformType::HDim>(0,0); }
+};
+
+template<typename Scalar, int Dim, int Options>
+struct transform_take_affine_part<Transform<Scalar,Dim,AffineCompact, Options> > {
+  typedef typename Transform<Scalar,Dim,AffineCompact,Options>::MatrixType MatrixType;
+  static inline MatrixType& run(MatrixType& m) { return m; }
+  static inline const MatrixType& run(const MatrixType& m) { return m; }
+};
+
+/*****************************************************
+*** Specializations of construct from matrix       ***
+*****************************************************/
+
+template<typename Other, int Mode, int Options, int Dim, int HDim>
+struct transform_construct_from_matrix<Other, Mode,Options,Dim,HDim, Dim,Dim>
+{
+  static inline void run(Transform<typename Other::Scalar,Dim,Mode,Options> *transform, const Other& other)
+  {
+    transform->linear() = other;
+    transform->translation().setZero();
+    transform->makeAffine();
+  }
+};
+
+template<typename Other, int Mode, int Options, int Dim, int HDim>
+struct transform_construct_from_matrix<Other, Mode,Options,Dim,HDim, Dim,HDim>
+{
+  static inline void run(Transform<typename Other::Scalar,Dim,Mode,Options> *transform, const Other& other)
+  {
+    transform->affine() = other;
+    transform->makeAffine();
+  }
+};
+
+template<typename Other, int Mode, int Options, int Dim, int HDim>
+struct transform_construct_from_matrix<Other, Mode,Options,Dim,HDim, HDim,HDim>
+{
+  static inline void run(Transform<typename Other::Scalar,Dim,Mode,Options> *transform, const Other& other)
+  { transform->matrix() = other; }
+};
+
+template<typename Other, int Options, int Dim, int HDim>
+struct transform_construct_from_matrix<Other, AffineCompact,Options,Dim,HDim, HDim,HDim>
+{
+  static inline void run(Transform<typename Other::Scalar,Dim,AffineCompact,Options> *transform, const Other& other)
+  { transform->matrix() = other.template block<Dim,HDim>(0,0); }
+};
+
+/**********************************************************
+***   Specializations of operator* with rhs EigenBase   ***
+**********************************************************/
+
+template<int LhsMode,int RhsMode>
+struct transform_product_result
+{
+  enum 
+  { 
+    Mode =
+      (LhsMode == (int)Projective    || RhsMode == (int)Projective    ) ? Projective :
+      (LhsMode == (int)Affine        || RhsMode == (int)Affine        ) ? Affine :
+      (LhsMode == (int)AffineCompact || RhsMode == (int)AffineCompact ) ? AffineCompact :
+      (LhsMode == (int)Isometry      || RhsMode == (int)Isometry      ) ? Isometry : Projective
+  };
+};
+
+template< typename TransformType, typename MatrixType, int RhsCols>
+struct transform_right_product_impl< TransformType, MatrixType, 0, RhsCols>
+{
+  typedef typename MatrixType::PlainObject ResultType;
+
+  static EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const MatrixType& other)
+  {
+    return T.matrix() * other;
+  }
+};
+
+template< typename TransformType, typename MatrixType, int RhsCols>
+struct transform_right_product_impl< TransformType, MatrixType, 1, RhsCols>
+{
+  enum { 
+    Dim = TransformType::Dim, 
+    HDim = TransformType::HDim,
+    OtherRows = MatrixType::RowsAtCompileTime,
+    OtherCols = MatrixType::ColsAtCompileTime
+  };
+
+  typedef typename MatrixType::PlainObject ResultType;
+
+  static EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const MatrixType& other)
+  {
+    EIGEN_STATIC_ASSERT(OtherRows==HDim, YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES);
+
+    typedef Block<ResultType, Dim, OtherCols, int(MatrixType::RowsAtCompileTime)==Dim> TopLeftLhs;
+
+    ResultType res(other.rows(),other.cols());
+    TopLeftLhs(res, 0, 0, Dim, other.cols()).noalias() = T.affine() * other;
+    res.row(OtherRows-1) = other.row(OtherRows-1);
+    
+    return res;
+  }
+};
+
+template< typename TransformType, typename MatrixType, int RhsCols>
+struct transform_right_product_impl< TransformType, MatrixType, 2, RhsCols>
+{
+  enum { 
+    Dim = TransformType::Dim, 
+    HDim = TransformType::HDim,
+    OtherRows = MatrixType::RowsAtCompileTime,
+    OtherCols = MatrixType::ColsAtCompileTime
+  };
+
+  typedef typename MatrixType::PlainObject ResultType;
+
+  static EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const MatrixType& other)
+  {
+    EIGEN_STATIC_ASSERT(OtherRows==Dim, YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES);
+
+    typedef Block<ResultType, Dim, OtherCols, true> TopLeftLhs;
+    ResultType res(Replicate<typename TransformType::ConstTranslationPart, 1, OtherCols>(T.translation(),1,other.cols()));
+    TopLeftLhs(res, 0, 0, Dim, other.cols()).noalias() += T.linear() * other;
+
+    return res;
+  }
+};
+
+template< typename TransformType, typename MatrixType >
+struct transform_right_product_impl< TransformType, MatrixType, 2, 1> // rhs is a vector of size Dim
+{
+  typedef typename TransformType::MatrixType TransformMatrix;
+  enum {
+    Dim = TransformType::Dim,
+    HDim = TransformType::HDim,
+    OtherRows = MatrixType::RowsAtCompileTime,
+    WorkingRows = EIGEN_PLAIN_ENUM_MIN(TransformMatrix::RowsAtCompileTime,HDim)
+  };
+
+  typedef typename MatrixType::PlainObject ResultType;
+
+  static EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const MatrixType& other)
+  {
+    EIGEN_STATIC_ASSERT(OtherRows==Dim, YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES);
+
+    Matrix<typename ResultType::Scalar, Dim+1, 1> rhs;
+    rhs.template head<Dim>() = other; rhs[Dim] = typename ResultType::Scalar(1);
+    Matrix<typename ResultType::Scalar, WorkingRows, 1> res(T.matrix() * rhs);
+    return res.template head<Dim>();
+  }
+};
+
+/**********************************************************
+***   Specializations of operator* with lhs EigenBase   ***
+**********************************************************/
+
+// generic HDim x HDim matrix * T => Projective
+template<typename Other,int Mode, int Options, int Dim, int HDim>
+struct transform_left_product_impl<Other,Mode,Options,Dim,HDim, HDim,HDim>
+{
+  typedef Transform<typename Other::Scalar,Dim,Mode,Options> TransformType;
+  typedef typename TransformType::MatrixType MatrixType;
+  typedef Transform<typename Other::Scalar,Dim,Projective,Options> ResultType;
+  static ResultType run(const Other& other,const TransformType& tr)
+  { return ResultType(other * tr.matrix()); }
+};
+
+// generic HDim x HDim matrix * AffineCompact => Projective
+template<typename Other, int Options, int Dim, int HDim>
+struct transform_left_product_impl<Other,AffineCompact,Options,Dim,HDim, HDim,HDim>
+{
+  typedef Transform<typename Other::Scalar,Dim,AffineCompact,Options> TransformType;
+  typedef typename TransformType::MatrixType MatrixType;
+  typedef Transform<typename Other::Scalar,Dim,Projective,Options> ResultType;
+  static ResultType run(const Other& other,const TransformType& tr)
+  {
+    ResultType res;
+    res.matrix().noalias() = other.template block<HDim,Dim>(0,0) * tr.matrix();
+    res.matrix().col(Dim) += other.col(Dim);
+    return res;
+  }
+};
+
+// affine matrix * T
+template<typename Other,int Mode, int Options, int Dim, int HDim>
+struct transform_left_product_impl<Other,Mode,Options,Dim,HDim, Dim,HDim>
+{
+  typedef Transform<typename Other::Scalar,Dim,Mode,Options> TransformType;
+  typedef typename TransformType::MatrixType MatrixType;
+  typedef TransformType ResultType;
+  static ResultType run(const Other& other,const TransformType& tr)
+  {
+    ResultType res;
+    res.affine().noalias() = other * tr.matrix();
+    res.matrix().row(Dim) = tr.matrix().row(Dim);
+    return res;
+  }
+};
+
+// affine matrix * AffineCompact
+template<typename Other, int Options, int Dim, int HDim>
+struct transform_left_product_impl<Other,AffineCompact,Options,Dim,HDim, Dim,HDim>
+{
+  typedef Transform<typename Other::Scalar,Dim,AffineCompact,Options> TransformType;
+  typedef typename TransformType::MatrixType MatrixType;
+  typedef TransformType ResultType;
+  static ResultType run(const Other& other,const TransformType& tr)
+  {
+    ResultType res;
+    res.matrix().noalias() = other.template block<Dim,Dim>(0,0) * tr.matrix();
+    res.translation() += other.col(Dim);
+    return res;
+  }
+};
+
+// linear matrix * T
+template<typename Other,int Mode, int Options, int Dim, int HDim>
+struct transform_left_product_impl<Other,Mode,Options,Dim,HDim, Dim,Dim>
+{
+  typedef Transform<typename Other::Scalar,Dim,Mode,Options> TransformType;
+  typedef typename TransformType::MatrixType MatrixType;
+  typedef TransformType ResultType;
+  static ResultType run(const Other& other, const TransformType& tr)
+  {
+    TransformType res;
+    if(Mode!=int(AffineCompact))
+      res.matrix().row(Dim) = tr.matrix().row(Dim);
+    res.matrix().template topRows<Dim>().noalias()
+      = other * tr.matrix().template topRows<Dim>();
+    return res;
+  }
+};
+
+/**********************************************************
+*** Specializations of operator* with another Transform ***
+**********************************************************/
+
+template<typename Scalar, int Dim, int LhsMode, int LhsOptions, int RhsMode, int RhsOptions>
+struct transform_transform_product_impl<Transform<Scalar,Dim,LhsMode,LhsOptions>,Transform<Scalar,Dim,RhsMode,RhsOptions>,false >
+{
+  enum { ResultMode = transform_product_result<LhsMode,RhsMode>::Mode };
+  typedef Transform<Scalar,Dim,LhsMode,LhsOptions> Lhs;
+  typedef Transform<Scalar,Dim,RhsMode,RhsOptions> Rhs;
+  typedef Transform<Scalar,Dim,ResultMode,LhsOptions> ResultType;
+  static ResultType run(const Lhs& lhs, const Rhs& rhs)
+  {
+    ResultType res;
+    res.linear() = lhs.linear() * rhs.linear();
+    res.translation() = lhs.linear() * rhs.translation() + lhs.translation();
+    res.makeAffine();
+    return res;
+  }
+};
+
+template<typename Scalar, int Dim, int LhsMode, int LhsOptions, int RhsMode, int RhsOptions>
+struct transform_transform_product_impl<Transform<Scalar,Dim,LhsMode,LhsOptions>,Transform<Scalar,Dim,RhsMode,RhsOptions>,true >
+{
+  typedef Transform<Scalar,Dim,LhsMode,LhsOptions> Lhs;
+  typedef Transform<Scalar,Dim,RhsMode,RhsOptions> Rhs;
+  typedef Transform<Scalar,Dim,Projective> ResultType;
+  static ResultType run(const Lhs& lhs, const Rhs& rhs)
+  {
+    return ResultType( lhs.matrix() * rhs.matrix() );
+  }
+};
+
+template<typename Scalar, int Dim, int LhsOptions, int RhsOptions>
+struct transform_transform_product_impl<Transform<Scalar,Dim,AffineCompact,LhsOptions>,Transform<Scalar,Dim,Projective,RhsOptions>,true >
+{
+  typedef Transform<Scalar,Dim,AffineCompact,LhsOptions> Lhs;
+  typedef Transform<Scalar,Dim,Projective,RhsOptions> Rhs;
+  typedef Transform<Scalar,Dim,Projective> ResultType;
+  static ResultType run(const Lhs& lhs, const Rhs& rhs)
+  {
+    ResultType res;
+    res.matrix().template topRows<Dim>() = lhs.matrix() * rhs.matrix();
+    res.matrix().row(Dim) = rhs.matrix().row(Dim);
+    return res;
+  }
+};
+
+template<typename Scalar, int Dim, int LhsOptions, int RhsOptions>
+struct transform_transform_product_impl<Transform<Scalar,Dim,Projective,LhsOptions>,Transform<Scalar,Dim,AffineCompact,RhsOptions>,true >
+{
+  typedef Transform<Scalar,Dim,Projective,LhsOptions> Lhs;
+  typedef Transform<Scalar,Dim,AffineCompact,RhsOptions> Rhs;
+  typedef Transform<Scalar,Dim,Projective> ResultType;
+  static ResultType run(const Lhs& lhs, const Rhs& rhs)
+  {
+    ResultType res(lhs.matrix().template leftCols<Dim>() * rhs.matrix());
+    res.matrix().col(Dim) += lhs.matrix().col(Dim);
+    return res;
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRANSFORM_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/Translation.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/Translation.h
new file mode 100644
index 00000000..51d9a82e
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/Translation.h
@@ -0,0 +1,208 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TRANSLATION_H
+#define EIGEN_TRANSLATION_H
+
+namespace Eigen { 
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \class Translation
+  *
+  * \brief Represents a translation transformation
+  *
+  * \tparam _Scalar the scalar type, i.e., the type of the coefficients.
+  * \tparam _Dim the  dimension of the space, can be a compile time value or Dynamic
+  *
+  * \note This class is not aimed to be used to store a translation transformation,
+  * but rather to make easier the constructions and updates of Transform objects.
+  *
+  * \sa class Scaling, class Transform
+  */
+template<typename _Scalar, int _Dim>
+class Translation
+{
+public:
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_Dim)
+  /** dimension of the space */
+  enum { Dim = _Dim };
+  /** the scalar type of the coefficients */
+  typedef _Scalar Scalar;
+  /** corresponding vector type */
+  typedef Matrix<Scalar,Dim,1> VectorType;
+  /** corresponding linear transformation matrix type */
+  typedef Matrix<Scalar,Dim,Dim> LinearMatrixType;
+  /** corresponding affine transformation type */
+  typedef Transform<Scalar,Dim,Affine> AffineTransformType;
+  /** corresponding isometric transformation type */
+  typedef Transform<Scalar,Dim,Isometry> IsometryTransformType;
+
+protected:
+
+  VectorType m_coeffs;
+
+public:
+
+  /** Default constructor without initialization. */
+  EIGEN_DEVICE_FUNC Translation() {}
+  /**  */
+  EIGEN_DEVICE_FUNC inline Translation(const Scalar& sx, const Scalar& sy)
+  {
+    eigen_assert(Dim==2);
+    m_coeffs.x() = sx;
+    m_coeffs.y() = sy;
+  }
+  /**  */
+  EIGEN_DEVICE_FUNC inline Translation(const Scalar& sx, const Scalar& sy, const Scalar& sz)
+  {
+    eigen_assert(Dim==3);
+    m_coeffs.x() = sx;
+    m_coeffs.y() = sy;
+    m_coeffs.z() = sz;
+  }
+  /** Constructs and initialize the translation transformation from a vector of translation coefficients */
+  EIGEN_DEVICE_FUNC explicit inline Translation(const VectorType& vector) : m_coeffs(vector) {}
+
+  /** \brief Retruns the x-translation by value. **/
+  EIGEN_DEVICE_FUNC inline Scalar x() const { return m_coeffs.x(); }
+  /** \brief Retruns the y-translation by value. **/
+  EIGEN_DEVICE_FUNC inline Scalar y() const { return m_coeffs.y(); }
+  /** \brief Retruns the z-translation by value. **/
+  EIGEN_DEVICE_FUNC inline Scalar z() const { return m_coeffs.z(); }
+
+  /** \brief Retruns the x-translation as a reference. **/
+  EIGEN_DEVICE_FUNC inline Scalar& x() { return m_coeffs.x(); }
+  /** \brief Retruns the y-translation as a reference. **/
+  EIGEN_DEVICE_FUNC inline Scalar& y() { return m_coeffs.y(); }
+  /** \brief Retruns the z-translation as a reference. **/
+  EIGEN_DEVICE_FUNC inline Scalar& z() { return m_coeffs.z(); }
+
+  EIGEN_DEVICE_FUNC const VectorType& vector() const { return m_coeffs; }
+  EIGEN_DEVICE_FUNC VectorType& vector() { return m_coeffs; }
+
+  EIGEN_DEVICE_FUNC const VectorType& translation() const { return m_coeffs; }
+  EIGEN_DEVICE_FUNC VectorType& translation() { return m_coeffs; }
+
+  /** Concatenates two translation */
+  EIGEN_DEVICE_FUNC inline Translation operator* (const Translation& other) const
+  { return Translation(m_coeffs + other.m_coeffs); }
+
+  /** Concatenates a translation and a uniform scaling */
+  EIGEN_DEVICE_FUNC inline AffineTransformType operator* (const UniformScaling<Scalar>& other) const;
+
+  /** Concatenates a translation and a linear transformation */
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC inline AffineTransformType operator* (const EigenBase<OtherDerived>& linear) const;
+
+  /** Concatenates a translation and a rotation */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline IsometryTransformType operator*(const RotationBase<Derived,Dim>& r) const
+  { return *this * IsometryTransformType(r); }
+
+  /** \returns the concatenation of a linear transformation \a l with the translation \a t */
+  // its a nightmare to define a templated friend function outside its declaration
+  template<typename OtherDerived> friend
+  EIGEN_DEVICE_FUNC inline AffineTransformType operator*(const EigenBase<OtherDerived>& linear, const Translation& t)
+  {
+    AffineTransformType res;
+    res.matrix().setZero();
+    res.linear() = linear.derived();
+    res.translation() = linear.derived() * t.m_coeffs;
+    res.matrix().row(Dim).setZero();
+    res(Dim,Dim) = Scalar(1);
+    return res;
+  }
+
+  /** Concatenates a translation and a transformation */
+  template<int Mode, int Options>
+  EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode> operator* (const Transform<Scalar,Dim,Mode,Options>& t) const
+  {
+    Transform<Scalar,Dim,Mode> res = t;
+    res.pretranslate(m_coeffs);
+    return res;
+  }
+
+  /** Applies translation to vector */
+  template<typename Derived>
+  inline typename internal::enable_if<Derived::IsVectorAtCompileTime,VectorType>::type
+  operator* (const MatrixBase<Derived>& vec) const
+  { return m_coeffs + vec.derived(); }
+
+  /** \returns the inverse translation (opposite) */
+  Translation inverse() const { return Translation(-m_coeffs); }
+
+  Translation& operator=(const Translation& other)
+  {
+    m_coeffs = other.m_coeffs;
+    return *this;
+  }
+
+  static const Translation Identity() { return Translation(VectorType::Zero()); }
+
+  /** \returns \c *this with scalar type casted to \a NewScalarType
+    *
+    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
+    * then this function smartly returns a const reference to \c *this.
+    */
+  template<typename NewScalarType>
+  EIGEN_DEVICE_FUNC inline typename internal::cast_return_type<Translation,Translation<NewScalarType,Dim> >::type cast() const
+  { return typename internal::cast_return_type<Translation,Translation<NewScalarType,Dim> >::type(*this); }
+
+  /** Copy constructor with scalar type conversion */
+  template<typename OtherScalarType>
+  EIGEN_DEVICE_FUNC inline explicit Translation(const Translation<OtherScalarType,Dim>& other)
+  { m_coeffs = other.vector().template cast<Scalar>(); }
+
+  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
+    * determined by \a prec.
+    *
+    * \sa MatrixBase::isApprox() */
+  EIGEN_DEVICE_FUNC bool isApprox(const Translation& other, const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const
+  { return m_coeffs.isApprox(other.m_coeffs, prec); }
+
+};
+
+/** \addtogroup Geometry_Module */
+//@{
+typedef Translation<float, 2> Translation2f;
+typedef Translation<double,2> Translation2d;
+typedef Translation<float, 3> Translation3f;
+typedef Translation<double,3> Translation3d;
+//@}
+
+template<typename Scalar, int Dim>
+EIGEN_DEVICE_FUNC inline typename Translation<Scalar,Dim>::AffineTransformType
+Translation<Scalar,Dim>::operator* (const UniformScaling<Scalar>& other) const
+{
+  AffineTransformType res;
+  res.matrix().setZero();
+  res.linear().diagonal().fill(other.factor());
+  res.translation() = m_coeffs;
+  res(Dim,Dim) = Scalar(1);
+  return res;
+}
+
+template<typename Scalar, int Dim>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC inline typename Translation<Scalar,Dim>::AffineTransformType
+Translation<Scalar,Dim>::operator* (const EigenBase<OtherDerived>& linear) const
+{
+  AffineTransformType res;
+  res.matrix().setZero();
+  res.linear() = linear.derived();
+  res.translation() = m_coeffs;
+  res.matrix().row(Dim).setZero();
+  res(Dim,Dim) = Scalar(1);
+  return res;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRANSLATION_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/Umeyama.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/Umeyama.h
new file mode 100644
index 00000000..7e933fca
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/Umeyama.h
@@ -0,0 +1,166 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Hauke Heibel <hauke.heibel@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_UMEYAMA_H
+#define EIGEN_UMEYAMA_H
+
+// This file requires the user to include 
+// * Eigen/Core
+// * Eigen/LU 
+// * Eigen/SVD
+// * Eigen/Array
+
+namespace Eigen { 
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+
+// These helpers are required since it allows to use mixed types as parameters
+// for the Umeyama. The problem with mixed parameters is that the return type
+// cannot trivially be deduced when float and double types are mixed.
+namespace internal {
+
+// Compile time return type deduction for different MatrixBase types.
+// Different means here different alignment and parameters but the same underlying
+// real scalar type.
+template<typename MatrixType, typename OtherMatrixType>
+struct umeyama_transform_matrix_type
+{
+  enum {
+    MinRowsAtCompileTime = EIGEN_SIZE_MIN_PREFER_DYNAMIC(MatrixType::RowsAtCompileTime, OtherMatrixType::RowsAtCompileTime),
+
+    // When possible we want to choose some small fixed size value since the result
+    // is likely to fit on the stack. So here, EIGEN_SIZE_MIN_PREFER_DYNAMIC is not what we want.
+    HomogeneousDimension = int(MinRowsAtCompileTime) == Dynamic ? Dynamic : int(MinRowsAtCompileTime)+1
+  };
+
+  typedef Matrix<typename traits<MatrixType>::Scalar,
+    HomogeneousDimension,
+    HomogeneousDimension,
+    AutoAlign | (traits<MatrixType>::Flags & RowMajorBit ? RowMajor : ColMajor),
+    HomogeneousDimension,
+    HomogeneousDimension
+  > type;
+};
+
+}
+
+#endif
+
+/**
+* \geometry_module \ingroup Geometry_Module
+*
+* \brief Returns the transformation between two point sets.
+*
+* The algorithm is based on:
+* "Least-squares estimation of transformation parameters between two point patterns",
+* Shinji Umeyama, PAMI 1991, DOI: 10.1109/34.88573
+*
+* It estimates parameters \f$ c, \mathbf{R}, \f$ and \f$ \mathbf{t} \f$ such that
+* \f{align*}
+*   \frac{1}{n} \sum_{i=1}^n \vert\vert y_i - (c\mathbf{R}x_i + \mathbf{t}) \vert\vert_2^2
+* \f}
+* is minimized.
+*
+* The algorithm is based on the analysis of the covariance matrix
+* \f$ \Sigma_{\mathbf{x}\mathbf{y}} \in \mathbb{R}^{d \times d} \f$
+* of the input point sets \f$ \mathbf{x} \f$ and \f$ \mathbf{y} \f$ where 
+* \f$d\f$ is corresponding to the dimension (which is typically small).
+* The analysis is involving the SVD having a complexity of \f$O(d^3)\f$
+* though the actual computational effort lies in the covariance
+* matrix computation which has an asymptotic lower bound of \f$O(dm)\f$ when 
+* the input point sets have dimension \f$d \times m\f$.
+*
+* Currently the method is working only for floating point matrices.
+*
+* \todo Should the return type of umeyama() become a Transform?
+*
+* \param src Source points \f$ \mathbf{x} = \left( x_1, \hdots, x_n \right) \f$.
+* \param dst Destination points \f$ \mathbf{y} = \left( y_1, \hdots, y_n \right) \f$.
+* \param with_scaling Sets \f$ c=1 \f$ when <code>false</code> is passed.
+* \return The homogeneous transformation 
+* \f{align*}
+*   T = \begin{bmatrix} c\mathbf{R} & \mathbf{t} \\ \mathbf{0} & 1 \end{bmatrix}
+* \f}
+* minimizing the resudiual above. This transformation is always returned as an 
+* Eigen::Matrix.
+*/
+template <typename Derived, typename OtherDerived>
+typename internal::umeyama_transform_matrix_type<Derived, OtherDerived>::type
+umeyama(const MatrixBase<Derived>& src, const MatrixBase<OtherDerived>& dst, bool with_scaling = true)
+{
+  typedef typename internal::umeyama_transform_matrix_type<Derived, OtherDerived>::type TransformationMatrixType;
+  typedef typename internal::traits<TransformationMatrixType>::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::IsComplex, NUMERIC_TYPE_MUST_BE_REAL)
+  EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename internal::traits<OtherDerived>::Scalar>::value),
+    YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+
+  enum { Dimension = EIGEN_SIZE_MIN_PREFER_DYNAMIC(Derived::RowsAtCompileTime, OtherDerived::RowsAtCompileTime) };
+
+  typedef Matrix<Scalar, Dimension, 1> VectorType;
+  typedef Matrix<Scalar, Dimension, Dimension> MatrixType;
+  typedef typename internal::plain_matrix_type_row_major<Derived>::type RowMajorMatrixType;
+
+  const Index m = src.rows(); // dimension
+  const Index n = src.cols(); // number of measurements
+
+  // required for demeaning ...
+  const RealScalar one_over_n = RealScalar(1) / static_cast<RealScalar>(n);
+
+  // computation of mean
+  const VectorType src_mean = src.rowwise().sum() * one_over_n;
+  const VectorType dst_mean = dst.rowwise().sum() * one_over_n;
+
+  // demeaning of src and dst points
+  const RowMajorMatrixType src_demean = src.colwise() - src_mean;
+  const RowMajorMatrixType dst_demean = dst.colwise() - dst_mean;
+
+  // Eq. (36)-(37)
+  const Scalar src_var = src_demean.rowwise().squaredNorm().sum() * one_over_n;
+
+  // Eq. (38)
+  const MatrixType sigma = one_over_n * dst_demean * src_demean.transpose();
+
+  JacobiSVD<MatrixType> svd(sigma, ComputeFullU | ComputeFullV);
+
+  // Initialize the resulting transformation with an identity matrix...
+  TransformationMatrixType Rt = TransformationMatrixType::Identity(m+1,m+1);
+
+  // Eq. (39)
+  VectorType S = VectorType::Ones(m);
+
+  if  ( svd.matrixU().determinant() * svd.matrixV().determinant() < 0 )
+    S(m-1) = -1;
+
+  // Eq. (40) and (43)
+  Rt.block(0,0,m,m).noalias() = svd.matrixU() * S.asDiagonal() * svd.matrixV().transpose();
+
+  if (with_scaling)
+  {
+    // Eq. (42)
+    const Scalar c = Scalar(1)/src_var * svd.singularValues().dot(S);
+
+    // Eq. (41)
+    Rt.col(m).head(m) = dst_mean;
+    Rt.col(m).head(m).noalias() -= c*Rt.topLeftCorner(m,m)*src_mean;
+    Rt.block(0,0,m,m) *= c;
+  }
+  else
+  {
+    Rt.col(m).head(m) = dst_mean;
+    Rt.col(m).head(m).noalias() -= Rt.topLeftCorner(m,m)*src_mean;
+  }
+
+  return Rt;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_UMEYAMA_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/arch/Geometry_SSE.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/arch/Geometry_SSE.h
new file mode 100644
index 00000000..f68cab58
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Geometry/arch/Geometry_SSE.h
@@ -0,0 +1,161 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Rohit Garg <rpg.314@gmail.com>
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GEOMETRY_SSE_H
+#define EIGEN_GEOMETRY_SSE_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<class Derived, class OtherDerived>
+struct quat_product<Architecture::SSE, Derived, OtherDerived, float>
+{
+  enum {
+    AAlignment = traits<Derived>::Alignment,
+    BAlignment = traits<OtherDerived>::Alignment,
+    ResAlignment = traits<Quaternion<float> >::Alignment
+  };
+  static inline Quaternion<float> run(const QuaternionBase<Derived>& _a, const QuaternionBase<OtherDerived>& _b)
+  {
+    Quaternion<float> res;
+    const __m128 mask = _mm_setr_ps(0.f,0.f,0.f,-0.f);
+    __m128 a = _a.coeffs().template packet<AAlignment>(0);
+    __m128 b = _b.coeffs().template packet<BAlignment>(0);
+    __m128 s1 = _mm_mul_ps(vec4f_swizzle1(a,1,2,0,2),vec4f_swizzle1(b,2,0,1,2));
+    __m128 s2 = _mm_mul_ps(vec4f_swizzle1(a,3,3,3,1),vec4f_swizzle1(b,0,1,2,1));
+    pstoret<float,Packet4f,ResAlignment>(
+              &res.x(),
+              _mm_add_ps(_mm_sub_ps(_mm_mul_ps(a,vec4f_swizzle1(b,3,3,3,3)),
+                                    _mm_mul_ps(vec4f_swizzle1(a,2,0,1,0),
+                                               vec4f_swizzle1(b,1,2,0,0))),
+                         _mm_xor_ps(mask,_mm_add_ps(s1,s2))));
+    
+    return res;
+  }
+};
+
+template<class Derived>
+struct quat_conj<Architecture::SSE, Derived, float>
+{
+  enum {
+    ResAlignment = traits<Quaternion<float> >::Alignment
+  };
+  static inline Quaternion<float> run(const QuaternionBase<Derived>& q)
+  {
+    Quaternion<float> res;
+    const __m128 mask = _mm_setr_ps(-0.f,-0.f,-0.f,0.f);
+    pstoret<float,Packet4f,ResAlignment>(&res.x(), _mm_xor_ps(mask, q.coeffs().template packet<traits<Derived>::Alignment>(0)));
+    return res;
+  }
+};
+
+
+template<typename VectorLhs,typename VectorRhs>
+struct cross3_impl<Architecture::SSE,VectorLhs,VectorRhs,float,true>
+{
+  enum {
+    ResAlignment = traits<typename plain_matrix_type<VectorLhs>::type>::Alignment
+  };
+  static inline typename plain_matrix_type<VectorLhs>::type
+  run(const VectorLhs& lhs, const VectorRhs& rhs)
+  {
+    __m128 a = lhs.template packet<traits<VectorLhs>::Alignment>(0);
+    __m128 b = rhs.template packet<traits<VectorRhs>::Alignment>(0);
+    __m128 mul1=_mm_mul_ps(vec4f_swizzle1(a,1,2,0,3),vec4f_swizzle1(b,2,0,1,3));
+    __m128 mul2=_mm_mul_ps(vec4f_swizzle1(a,2,0,1,3),vec4f_swizzle1(b,1,2,0,3));
+    typename plain_matrix_type<VectorLhs>::type res;
+    pstoret<float,Packet4f,ResAlignment>(&res.x(),_mm_sub_ps(mul1,mul2));
+    return res;
+  }
+};
+
+
+
+
+template<class Derived, class OtherDerived>
+struct quat_product<Architecture::SSE, Derived, OtherDerived, double>
+{
+  enum {
+    BAlignment = traits<OtherDerived>::Alignment,
+    ResAlignment = traits<Quaternion<double> >::Alignment
+  };
+
+  static inline Quaternion<double> run(const QuaternionBase<Derived>& _a, const QuaternionBase<OtherDerived>& _b)
+  {
+  const Packet2d mask = _mm_castsi128_pd(_mm_set_epi32(0x0,0x0,0x80000000,0x0));
+
+  Quaternion<double> res;
+
+  const double* a = _a.coeffs().data();
+  Packet2d b_xy = _b.coeffs().template packet<BAlignment>(0);
+  Packet2d b_zw = _b.coeffs().template packet<BAlignment>(2);
+  Packet2d a_xx = pset1<Packet2d>(a[0]);
+  Packet2d a_yy = pset1<Packet2d>(a[1]);
+  Packet2d a_zz = pset1<Packet2d>(a[2]);
+  Packet2d a_ww = pset1<Packet2d>(a[3]);
+
+  // two temporaries:
+  Packet2d t1, t2;
+
+  /*
+   * t1 = ww*xy + yy*zw
+   * t2 = zz*xy - xx*zw
+   * res.xy = t1 +/- swap(t2)
+   */
+  t1 = padd(pmul(a_ww, b_xy), pmul(a_yy, b_zw));
+  t2 = psub(pmul(a_zz, b_xy), pmul(a_xx, b_zw));
+#ifdef EIGEN_VECTORIZE_SSE3
+  EIGEN_UNUSED_VARIABLE(mask)
+  pstoret<double,Packet2d,ResAlignment>(&res.x(), _mm_addsub_pd(t1, preverse(t2)));
+#else
+  pstoret<double,Packet2d,ResAlignment>(&res.x(), padd(t1, pxor(mask,preverse(t2))));
+#endif
+  
+  /*
+   * t1 = ww*zw - yy*xy
+   * t2 = zz*zw + xx*xy
+   * res.zw = t1 -/+ swap(t2) = swap( swap(t1) +/- t2)
+   */
+  t1 = psub(pmul(a_ww, b_zw), pmul(a_yy, b_xy));
+  t2 = padd(pmul(a_zz, b_zw), pmul(a_xx, b_xy));
+#ifdef EIGEN_VECTORIZE_SSE3
+  EIGEN_UNUSED_VARIABLE(mask)
+  pstoret<double,Packet2d,ResAlignment>(&res.z(), preverse(_mm_addsub_pd(preverse(t1), t2)));
+#else
+  pstoret<double,Packet2d,ResAlignment>(&res.z(), psub(t1, pxor(mask,preverse(t2))));
+#endif
+
+  return res;
+}
+};
+
+template<class Derived>
+struct quat_conj<Architecture::SSE, Derived, double>
+{
+  enum {
+    ResAlignment = traits<Quaternion<double> >::Alignment
+  };
+  static inline Quaternion<double> run(const QuaternionBase<Derived>& q)
+  {
+    Quaternion<double> res;
+    const __m128d mask0 = _mm_setr_pd(-0.,-0.);
+    const __m128d mask2 = _mm_setr_pd(-0.,0.);
+    pstoret<double,Packet2d,ResAlignment>(&res.x(), _mm_xor_pd(mask0, q.coeffs().template packet<traits<Derived>::Alignment>(0)));
+    pstoret<double,Packet2d,ResAlignment>(&res.z(), _mm_xor_pd(mask2, q.coeffs().template packet<traits<Derived>::Alignment>(2)));
+    return res;
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_GEOMETRY_SSE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Householder/BlockHouseholder.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Householder/BlockHouseholder.h
new file mode 100644
index 00000000..01a7ed18
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Householder/BlockHouseholder.h
@@ -0,0 +1,103 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Vincent Lejeune
+// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_BLOCK_HOUSEHOLDER_H
+#define EIGEN_BLOCK_HOUSEHOLDER_H
+
+// This file contains some helper function to deal with block householder reflectors
+
+namespace Eigen { 
+
+namespace internal {
+  
+/** \internal */
+// template<typename TriangularFactorType,typename VectorsType,typename CoeffsType>
+// void make_block_householder_triangular_factor(TriangularFactorType& triFactor, const VectorsType& vectors, const CoeffsType& hCoeffs)
+// {
+//   typedef typename VectorsType::Scalar Scalar;
+//   const Index nbVecs = vectors.cols();
+//   eigen_assert(triFactor.rows() == nbVecs && triFactor.cols() == nbVecs && vectors.rows()>=nbVecs);
+// 
+//   for(Index i = 0; i < nbVecs; i++)
+//   {
+//     Index rs = vectors.rows() - i;
+//     // Warning, note that hCoeffs may alias with vectors.
+//     // It is then necessary to copy it before modifying vectors(i,i). 
+//     typename CoeffsType::Scalar h = hCoeffs(i);
+//     // This hack permits to pass trough nested Block<> and Transpose<> expressions.
+//     Scalar *Vii_ptr = const_cast<Scalar*>(vectors.data() + vectors.outerStride()*i + vectors.innerStride()*i);
+//     Scalar Vii = *Vii_ptr;
+//     *Vii_ptr = Scalar(1);
+//     triFactor.col(i).head(i).noalias() = -h * vectors.block(i, 0, rs, i).adjoint()
+//                                        * vectors.col(i).tail(rs);
+//     *Vii_ptr = Vii;
+//     // FIXME add .noalias() once the triangular product can work inplace
+//     triFactor.col(i).head(i) = triFactor.block(0,0,i,i).template triangularView<Upper>()
+//                              * triFactor.col(i).head(i);
+//     triFactor(i,i) = hCoeffs(i);
+//   }
+// }
+
+/** \internal */
+// This variant avoid modifications in vectors
+template<typename TriangularFactorType,typename VectorsType,typename CoeffsType>
+void make_block_householder_triangular_factor(TriangularFactorType& triFactor, const VectorsType& vectors, const CoeffsType& hCoeffs)
+{
+  const Index nbVecs = vectors.cols();
+  eigen_assert(triFactor.rows() == nbVecs && triFactor.cols() == nbVecs && vectors.rows()>=nbVecs);
+
+  for(Index i = nbVecs-1; i >=0 ; --i)
+  {
+    Index rs = vectors.rows() - i - 1;
+    Index rt = nbVecs-i-1;
+
+    if(rt>0)
+    {
+      triFactor.row(i).tail(rt).noalias() = -hCoeffs(i) * vectors.col(i).tail(rs).adjoint()
+                                                        * vectors.bottomRightCorner(rs, rt).template triangularView<UnitLower>();
+            
+      // FIXME add .noalias() once the triangular product can work inplace
+      triFactor.row(i).tail(rt) = triFactor.row(i).tail(rt) * triFactor.bottomRightCorner(rt,rt).template triangularView<Upper>();
+      
+    }
+    triFactor(i,i) = hCoeffs(i);
+  }
+}
+
+/** \internal
+  * if forward then perform   mat = H0 * H1 * H2 * mat
+  * otherwise perform         mat = H2 * H1 * H0 * mat
+  */
+template<typename MatrixType,typename VectorsType,typename CoeffsType>
+void apply_block_householder_on_the_left(MatrixType& mat, const VectorsType& vectors, const CoeffsType& hCoeffs, bool forward)
+{
+  enum { TFactorSize = MatrixType::ColsAtCompileTime };
+  Index nbVecs = vectors.cols();
+  Matrix<typename MatrixType::Scalar, TFactorSize, TFactorSize, RowMajor> T(nbVecs,nbVecs);
+  
+  if(forward) make_block_householder_triangular_factor(T, vectors, hCoeffs);
+  else        make_block_householder_triangular_factor(T, vectors, hCoeffs.conjugate());  
+  const TriangularView<const VectorsType, UnitLower> V(vectors);
+
+  // A -= V T V^* A
+  Matrix<typename MatrixType::Scalar,VectorsType::ColsAtCompileTime,MatrixType::ColsAtCompileTime,
+         (VectorsType::MaxColsAtCompileTime==1 && MatrixType::MaxColsAtCompileTime!=1)?RowMajor:ColMajor,
+         VectorsType::MaxColsAtCompileTime,MatrixType::MaxColsAtCompileTime> tmp = V.adjoint() * mat;
+  // FIXME add .noalias() once the triangular product can work inplace
+  if(forward) tmp = T.template triangularView<Upper>()           * tmp;
+  else        tmp = T.template triangularView<Upper>().adjoint() * tmp;
+  mat.noalias() -= V * tmp;
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_BLOCK_HOUSEHOLDER_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Householder/Householder.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Householder/Householder.h
new file mode 100644
index 00000000..80de2c30
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Householder/Householder.h
@@ -0,0 +1,172 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_HOUSEHOLDER_H
+#define EIGEN_HOUSEHOLDER_H
+
+namespace Eigen { 
+
+namespace internal {
+template<int n> struct decrement_size
+{
+  enum {
+    ret = n==Dynamic ? n : n-1
+  };
+};
+}
+
+/** Computes the elementary reflector H such that:
+  * \f$ H *this = [ beta 0 ... 0]^T \f$
+  * where the transformation H is:
+  * \f$ H = I - tau v v^*\f$
+  * and the vector v is:
+  * \f$ v^T = [1 essential^T] \f$
+  *
+  * The essential part of the vector \c v is stored in *this.
+  * 
+  * On output:
+  * \param tau the scaling factor of the Householder transformation
+  * \param beta the result of H * \c *this
+  *
+  * \sa MatrixBase::makeHouseholder(), MatrixBase::applyHouseholderOnTheLeft(),
+  *     MatrixBase::applyHouseholderOnTheRight()
+  */
+template<typename Derived>
+void MatrixBase<Derived>::makeHouseholderInPlace(Scalar& tau, RealScalar& beta)
+{
+  VectorBlock<Derived, internal::decrement_size<Base::SizeAtCompileTime>::ret> essentialPart(derived(), 1, size()-1);
+  makeHouseholder(essentialPart, tau, beta);
+}
+
+/** Computes the elementary reflector H such that:
+  * \f$ H *this = [ beta 0 ... 0]^T \f$
+  * where the transformation H is:
+  * \f$ H = I - tau v v^*\f$
+  * and the vector v is:
+  * \f$ v^T = [1 essential^T] \f$
+  *
+  * On output:
+  * \param essential the essential part of the vector \c v
+  * \param tau the scaling factor of the Householder transformation
+  * \param beta the result of H * \c *this
+  *
+  * \sa MatrixBase::makeHouseholderInPlace(), MatrixBase::applyHouseholderOnTheLeft(),
+  *     MatrixBase::applyHouseholderOnTheRight()
+  */
+template<typename Derived>
+template<typename EssentialPart>
+void MatrixBase<Derived>::makeHouseholder(
+  EssentialPart& essential,
+  Scalar& tau,
+  RealScalar& beta) const
+{
+  using std::sqrt;
+  using numext::conj;
+  
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(EssentialPart)
+  VectorBlock<const Derived, EssentialPart::SizeAtCompileTime> tail(derived(), 1, size()-1);
+  
+  RealScalar tailSqNorm = size()==1 ? RealScalar(0) : tail.squaredNorm();
+  Scalar c0 = coeff(0);
+  const RealScalar tol = (std::numeric_limits<RealScalar>::min)();
+
+  if(tailSqNorm <= tol && numext::abs2(numext::imag(c0))<=tol)
+  {
+    tau = RealScalar(0);
+    beta = numext::real(c0);
+    essential.setZero();
+  }
+  else
+  {
+    beta = sqrt(numext::abs2(c0) + tailSqNorm);
+    if (numext::real(c0)>=RealScalar(0))
+      beta = -beta;
+    essential = tail / (c0 - beta);
+    tau = conj((beta - c0) / beta);
+  }
+}
+
+/** Apply the elementary reflector H given by
+  * \f$ H = I - tau v v^*\f$
+  * with
+  * \f$ v^T = [1 essential^T] \f$
+  * from the left to a vector or matrix.
+  *
+  * On input:
+  * \param essential the essential part of the vector \c v
+  * \param tau the scaling factor of the Householder transformation
+  * \param workspace a pointer to working space with at least
+  *                  this->cols() * essential.size() entries
+  *
+  * \sa MatrixBase::makeHouseholder(), MatrixBase::makeHouseholderInPlace(), 
+  *     MatrixBase::applyHouseholderOnTheRight()
+  */
+template<typename Derived>
+template<typename EssentialPart>
+void MatrixBase<Derived>::applyHouseholderOnTheLeft(
+  const EssentialPart& essential,
+  const Scalar& tau,
+  Scalar* workspace)
+{
+  if(rows() == 1)
+  {
+    *this *= Scalar(1)-tau;
+  }
+  else if(tau!=Scalar(0))
+  {
+    Map<typename internal::plain_row_type<PlainObject>::type> tmp(workspace,cols());
+    Block<Derived, EssentialPart::SizeAtCompileTime, Derived::ColsAtCompileTime> bottom(derived(), 1, 0, rows()-1, cols());
+    tmp.noalias() = essential.adjoint() * bottom;
+    tmp += this->row(0);
+    this->row(0) -= tau * tmp;
+    bottom.noalias() -= tau * essential * tmp;
+  }
+}
+
+/** Apply the elementary reflector H given by
+  * \f$ H = I - tau v v^*\f$
+  * with
+  * \f$ v^T = [1 essential^T] \f$
+  * from the right to a vector or matrix.
+  *
+  * On input:
+  * \param essential the essential part of the vector \c v
+  * \param tau the scaling factor of the Householder transformation
+  * \param workspace a pointer to working space with at least
+  *                  this->cols() * essential.size() entries
+  *
+  * \sa MatrixBase::makeHouseholder(), MatrixBase::makeHouseholderInPlace(), 
+  *     MatrixBase::applyHouseholderOnTheLeft()
+  */
+template<typename Derived>
+template<typename EssentialPart>
+void MatrixBase<Derived>::applyHouseholderOnTheRight(
+  const EssentialPart& essential,
+  const Scalar& tau,
+  Scalar* workspace)
+{
+  if(cols() == 1)
+  {
+    *this *= Scalar(1)-tau;
+  }
+  else if(tau!=Scalar(0))
+  {
+    Map<typename internal::plain_col_type<PlainObject>::type> tmp(workspace,rows());
+    Block<Derived, Derived::RowsAtCompileTime, EssentialPart::SizeAtCompileTime> right(derived(), 0, 1, rows(), cols()-1);
+    tmp.noalias() = right * essential.conjugate();
+    tmp += this->col(0);
+    this->col(0) -= tau * tmp;
+    right.noalias() -= tau * tmp * essential.transpose();
+  }
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_HOUSEHOLDER_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Householder/HouseholderSequence.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Householder/HouseholderSequence.h
new file mode 100644
index 00000000..3ce0a693
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Householder/HouseholderSequence.h
@@ -0,0 +1,470 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_HOUSEHOLDER_SEQUENCE_H
+#define EIGEN_HOUSEHOLDER_SEQUENCE_H
+
+namespace Eigen { 
+
+/** \ingroup Householder_Module
+  * \householder_module
+  * \class HouseholderSequence
+  * \brief Sequence of Householder reflections acting on subspaces with decreasing size
+  * \tparam VectorsType type of matrix containing the Householder vectors
+  * \tparam CoeffsType  type of vector containing the Householder coefficients
+  * \tparam Side        either OnTheLeft (the default) or OnTheRight
+  *
+  * This class represents a product sequence of Householder reflections where the first Householder reflection
+  * acts on the whole space, the second Householder reflection leaves the one-dimensional subspace spanned by
+  * the first unit vector invariant, the third Householder reflection leaves the two-dimensional subspace
+  * spanned by the first two unit vectors invariant, and so on up to the last reflection which leaves all but
+  * one dimensions invariant and acts only on the last dimension. Such sequences of Householder reflections
+  * are used in several algorithms to zero out certain parts of a matrix. Indeed, the methods
+  * HessenbergDecomposition::matrixQ(), Tridiagonalization::matrixQ(), HouseholderQR::householderQ(),
+  * and ColPivHouseholderQR::householderQ() all return a %HouseholderSequence.
+  *
+  * More precisely, the class %HouseholderSequence represents an \f$ n \times n \f$ matrix \f$ H \f$ of the
+  * form \f$ H = \prod_{i=0}^{n-1} H_i \f$ where the i-th Householder reflection is \f$ H_i = I - h_i v_i
+  * v_i^* \f$. The i-th Householder coefficient \f$ h_i \f$ is a scalar and the i-th Householder vector \f$
+  * v_i \f$ is a vector of the form
+  * \f[ 
+  * v_i = [\underbrace{0, \ldots, 0}_{i-1\mbox{ zeros}}, 1, \underbrace{*, \ldots,*}_{n-i\mbox{ arbitrary entries}} ]. 
+  * \f]
+  * The last \f$ n-i \f$ entries of \f$ v_i \f$ are called the essential part of the Householder vector.
+  *
+  * Typical usages are listed below, where H is a HouseholderSequence:
+  * \code
+  * A.applyOnTheRight(H);             // A = A * H
+  * A.applyOnTheLeft(H);              // A = H * A
+  * A.applyOnTheRight(H.adjoint());   // A = A * H^*
+  * A.applyOnTheLeft(H.adjoint());    // A = H^* * A
+  * MatrixXd Q = H;                   // conversion to a dense matrix
+  * \endcode
+  * In addition to the adjoint, you can also apply the inverse (=adjoint), the transpose, and the conjugate operators.
+  *
+  * See the documentation for HouseholderSequence(const VectorsType&, const CoeffsType&) for an example.
+  *
+  * \sa MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight()
+  */
+
+namespace internal {
+
+template<typename VectorsType, typename CoeffsType, int Side>
+struct traits<HouseholderSequence<VectorsType,CoeffsType,Side> >
+{
+  typedef typename VectorsType::Scalar Scalar;
+  typedef typename VectorsType::StorageIndex StorageIndex;
+  typedef typename VectorsType::StorageKind StorageKind;
+  enum {
+    RowsAtCompileTime = Side==OnTheLeft ? traits<VectorsType>::RowsAtCompileTime
+                                        : traits<VectorsType>::ColsAtCompileTime,
+    ColsAtCompileTime = RowsAtCompileTime,
+    MaxRowsAtCompileTime = Side==OnTheLeft ? traits<VectorsType>::MaxRowsAtCompileTime
+                                           : traits<VectorsType>::MaxColsAtCompileTime,
+    MaxColsAtCompileTime = MaxRowsAtCompileTime,
+    Flags = 0
+  };
+};
+
+struct HouseholderSequenceShape {};
+
+template<typename VectorsType, typename CoeffsType, int Side>
+struct evaluator_traits<HouseholderSequence<VectorsType,CoeffsType,Side> >
+  : public evaluator_traits_base<HouseholderSequence<VectorsType,CoeffsType,Side> >
+{
+  typedef HouseholderSequenceShape Shape;
+};
+
+template<typename VectorsType, typename CoeffsType, int Side>
+struct hseq_side_dependent_impl
+{
+  typedef Block<const VectorsType, Dynamic, 1> EssentialVectorType;
+  typedef HouseholderSequence<VectorsType, CoeffsType, OnTheLeft> HouseholderSequenceType;
+  static inline const EssentialVectorType essentialVector(const HouseholderSequenceType& h, Index k)
+  {
+    Index start = k+1+h.m_shift;
+    return Block<const VectorsType,Dynamic,1>(h.m_vectors, start, k, h.rows()-start, 1);
+  }
+};
+
+template<typename VectorsType, typename CoeffsType>
+struct hseq_side_dependent_impl<VectorsType, CoeffsType, OnTheRight>
+{
+  typedef Transpose<Block<const VectorsType, 1, Dynamic> > EssentialVectorType;
+  typedef HouseholderSequence<VectorsType, CoeffsType, OnTheRight> HouseholderSequenceType;
+  static inline const EssentialVectorType essentialVector(const HouseholderSequenceType& h, Index k)
+  {
+    Index start = k+1+h.m_shift;
+    return Block<const VectorsType,1,Dynamic>(h.m_vectors, k, start, 1, h.rows()-start).transpose();
+  }
+};
+
+template<typename OtherScalarType, typename MatrixType> struct matrix_type_times_scalar_type
+{
+  typedef typename ScalarBinaryOpTraits<OtherScalarType, typename MatrixType::Scalar>::ReturnType
+    ResultScalar;
+  typedef Matrix<ResultScalar, MatrixType::RowsAtCompileTime, MatrixType::ColsAtCompileTime,
+                 0, MatrixType::MaxRowsAtCompileTime, MatrixType::MaxColsAtCompileTime> Type;
+};
+
+} // end namespace internal
+
+template<typename VectorsType, typename CoeffsType, int Side> class HouseholderSequence
+  : public EigenBase<HouseholderSequence<VectorsType,CoeffsType,Side> >
+{
+    typedef typename internal::hseq_side_dependent_impl<VectorsType,CoeffsType,Side>::EssentialVectorType EssentialVectorType;
+  
+  public:
+    enum {
+      RowsAtCompileTime = internal::traits<HouseholderSequence>::RowsAtCompileTime,
+      ColsAtCompileTime = internal::traits<HouseholderSequence>::ColsAtCompileTime,
+      MaxRowsAtCompileTime = internal::traits<HouseholderSequence>::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = internal::traits<HouseholderSequence>::MaxColsAtCompileTime
+    };
+    typedef typename internal::traits<HouseholderSequence>::Scalar Scalar;
+
+    typedef HouseholderSequence<
+      typename internal::conditional<NumTraits<Scalar>::IsComplex,
+        typename internal::remove_all<typename VectorsType::ConjugateReturnType>::type,
+        VectorsType>::type,
+      typename internal::conditional<NumTraits<Scalar>::IsComplex,
+        typename internal::remove_all<typename CoeffsType::ConjugateReturnType>::type,
+        CoeffsType>::type,
+      Side
+    > ConjugateReturnType;
+
+    /** \brief Constructor.
+      * \param[in]  v      %Matrix containing the essential parts of the Householder vectors
+      * \param[in]  h      Vector containing the Householder coefficients
+      *
+      * Constructs the Householder sequence with coefficients given by \p h and vectors given by \p v. The
+      * i-th Householder coefficient \f$ h_i \f$ is given by \p h(i) and the essential part of the i-th
+      * Householder vector \f$ v_i \f$ is given by \p v(k,i) with \p k > \p i (the subdiagonal part of the
+      * i-th column). If \p v has fewer columns than rows, then the Householder sequence contains as many
+      * Householder reflections as there are columns.
+      *
+      * \note The %HouseholderSequence object stores \p v and \p h by reference.
+      *
+      * Example: \include HouseholderSequence_HouseholderSequence.cpp
+      * Output: \verbinclude HouseholderSequence_HouseholderSequence.out
+      *
+      * \sa setLength(), setShift()
+      */
+    HouseholderSequence(const VectorsType& v, const CoeffsType& h)
+      : m_vectors(v), m_coeffs(h), m_trans(false), m_length(v.diagonalSize()),
+        m_shift(0)
+    {
+    }
+
+    /** \brief Copy constructor. */
+    HouseholderSequence(const HouseholderSequence& other)
+      : m_vectors(other.m_vectors),
+        m_coeffs(other.m_coeffs),
+        m_trans(other.m_trans),
+        m_length(other.m_length),
+        m_shift(other.m_shift)
+    {
+    }
+
+    /** \brief Number of rows of transformation viewed as a matrix.
+      * \returns Number of rows 
+      * \details This equals the dimension of the space that the transformation acts on.
+      */
+    Index rows() const { return Side==OnTheLeft ? m_vectors.rows() : m_vectors.cols(); }
+
+    /** \brief Number of columns of transformation viewed as a matrix.
+      * \returns Number of columns
+      * \details This equals the dimension of the space that the transformation acts on.
+      */
+    Index cols() const { return rows(); }
+
+    /** \brief Essential part of a Householder vector.
+      * \param[in]  k  Index of Householder reflection
+      * \returns    Vector containing non-trivial entries of k-th Householder vector
+      *
+      * This function returns the essential part of the Householder vector \f$ v_i \f$. This is a vector of
+      * length \f$ n-i \f$ containing the last \f$ n-i \f$ entries of the vector
+      * \f[ 
+      * v_i = [\underbrace{0, \ldots, 0}_{i-1\mbox{ zeros}}, 1, \underbrace{*, \ldots,*}_{n-i\mbox{ arbitrary entries}} ]. 
+      * \f]
+      * The index \f$ i \f$ equals \p k + shift(), corresponding to the k-th column of the matrix \p v
+      * passed to the constructor.
+      *
+      * \sa setShift(), shift()
+      */
+    const EssentialVectorType essentialVector(Index k) const
+    {
+      eigen_assert(k >= 0 && k < m_length);
+      return internal::hseq_side_dependent_impl<VectorsType,CoeffsType,Side>::essentialVector(*this, k);
+    }
+
+    /** \brief %Transpose of the Householder sequence. */
+    HouseholderSequence transpose() const
+    {
+      return HouseholderSequence(*this).setTrans(!m_trans);
+    }
+
+    /** \brief Complex conjugate of the Householder sequence. */
+    ConjugateReturnType conjugate() const
+    {
+      return ConjugateReturnType(m_vectors.conjugate(), m_coeffs.conjugate())
+             .setTrans(m_trans)
+             .setLength(m_length)
+             .setShift(m_shift);
+    }
+
+    /** \brief Adjoint (conjugate transpose) of the Householder sequence. */
+    ConjugateReturnType adjoint() const
+    {
+      return conjugate().setTrans(!m_trans);
+    }
+
+    /** \brief Inverse of the Householder sequence (equals the adjoint). */
+    ConjugateReturnType inverse() const { return adjoint(); }
+
+    /** \internal */
+    template<typename DestType> inline void evalTo(DestType& dst) const
+    {
+      Matrix<Scalar, DestType::RowsAtCompileTime, 1,
+             AutoAlign|ColMajor, DestType::MaxRowsAtCompileTime, 1> workspace(rows());
+      evalTo(dst, workspace);
+    }
+
+    /** \internal */
+    template<typename Dest, typename Workspace>
+    void evalTo(Dest& dst, Workspace& workspace) const
+    {
+      workspace.resize(rows());
+      Index vecs = m_length;
+      if(internal::is_same_dense(dst,m_vectors))
+      {
+        // in-place
+        dst.diagonal().setOnes();
+        dst.template triangularView<StrictlyUpper>().setZero();
+        for(Index k = vecs-1; k >= 0; --k)
+        {
+          Index cornerSize = rows() - k - m_shift;
+          if(m_trans)
+            dst.bottomRightCorner(cornerSize, cornerSize)
+               .applyHouseholderOnTheRight(essentialVector(k), m_coeffs.coeff(k), workspace.data());
+          else
+            dst.bottomRightCorner(cornerSize, cornerSize)
+               .applyHouseholderOnTheLeft(essentialVector(k), m_coeffs.coeff(k), workspace.data());
+
+          // clear the off diagonal vector
+          dst.col(k).tail(rows()-k-1).setZero();
+        }
+        // clear the remaining columns if needed
+        for(Index k = 0; k<cols()-vecs ; ++k)
+          dst.col(k).tail(rows()-k-1).setZero();
+      }
+      else
+      {
+        dst.setIdentity(rows(), rows());
+        for(Index k = vecs-1; k >= 0; --k)
+        {
+          Index cornerSize = rows() - k - m_shift;
+          if(m_trans)
+            dst.bottomRightCorner(cornerSize, cornerSize)
+               .applyHouseholderOnTheRight(essentialVector(k), m_coeffs.coeff(k), &workspace.coeffRef(0));
+          else
+            dst.bottomRightCorner(cornerSize, cornerSize)
+               .applyHouseholderOnTheLeft(essentialVector(k), m_coeffs.coeff(k), &workspace.coeffRef(0));
+        }
+      }
+    }
+
+    /** \internal */
+    template<typename Dest> inline void applyThisOnTheRight(Dest& dst) const
+    {
+      Matrix<Scalar,1,Dest::RowsAtCompileTime,RowMajor,1,Dest::MaxRowsAtCompileTime> workspace(dst.rows());
+      applyThisOnTheRight(dst, workspace);
+    }
+
+    /** \internal */
+    template<typename Dest, typename Workspace>
+    inline void applyThisOnTheRight(Dest& dst, Workspace& workspace) const
+    {
+      workspace.resize(dst.rows());
+      for(Index k = 0; k < m_length; ++k)
+      {
+        Index actual_k = m_trans ? m_length-k-1 : k;
+        dst.rightCols(rows()-m_shift-actual_k)
+           .applyHouseholderOnTheRight(essentialVector(actual_k), m_coeffs.coeff(actual_k), workspace.data());
+      }
+    }
+
+    /** \internal */
+    template<typename Dest> inline void applyThisOnTheLeft(Dest& dst) const
+    {
+      Matrix<Scalar,1,Dest::ColsAtCompileTime,RowMajor,1,Dest::MaxColsAtCompileTime> workspace;
+      applyThisOnTheLeft(dst, workspace);
+    }
+
+    /** \internal */
+    template<typename Dest, typename Workspace>
+    inline void applyThisOnTheLeft(Dest& dst, Workspace& workspace) const
+    {
+      const Index BlockSize = 48;
+      // if the entries are large enough, then apply the reflectors by block
+      if(m_length>=BlockSize && dst.cols()>1)
+      {
+        for(Index i = 0; i < m_length; i+=BlockSize)
+        {
+          Index end = m_trans ? (std::min)(m_length,i+BlockSize) : m_length-i;
+          Index k = m_trans ? i : (std::max)(Index(0),end-BlockSize);
+          Index bs = end-k;
+          Index start = k + m_shift;
+          
+          typedef Block<typename internal::remove_all<VectorsType>::type,Dynamic,Dynamic> SubVectorsType;
+          SubVectorsType sub_vecs1(m_vectors.const_cast_derived(), Side==OnTheRight ? k : start,
+                                                                   Side==OnTheRight ? start : k,
+                                                                   Side==OnTheRight ? bs : m_vectors.rows()-start,
+                                                                   Side==OnTheRight ? m_vectors.cols()-start : bs);
+          typename internal::conditional<Side==OnTheRight, Transpose<SubVectorsType>, SubVectorsType&>::type sub_vecs(sub_vecs1);
+          Block<Dest,Dynamic,Dynamic> sub_dst(dst,dst.rows()-rows()+m_shift+k,0, rows()-m_shift-k,dst.cols());
+          apply_block_householder_on_the_left(sub_dst, sub_vecs, m_coeffs.segment(k, bs), !m_trans);
+        }
+      }
+      else
+      {
+        workspace.resize(dst.cols());
+        for(Index k = 0; k < m_length; ++k)
+        {
+          Index actual_k = m_trans ? k : m_length-k-1;
+          dst.bottomRows(rows()-m_shift-actual_k)
+            .applyHouseholderOnTheLeft(essentialVector(actual_k), m_coeffs.coeff(actual_k), workspace.data());
+        }
+      }
+    }
+
+    /** \brief Computes the product of a Householder sequence with a matrix.
+      * \param[in]  other  %Matrix being multiplied.
+      * \returns    Expression object representing the product.
+      *
+      * This function computes \f$ HM \f$ where \f$ H \f$ is the Householder sequence represented by \p *this
+      * and \f$ M \f$ is the matrix \p other.
+      */
+    template<typename OtherDerived>
+    typename internal::matrix_type_times_scalar_type<Scalar, OtherDerived>::Type operator*(const MatrixBase<OtherDerived>& other) const
+    {
+      typename internal::matrix_type_times_scalar_type<Scalar, OtherDerived>::Type
+        res(other.template cast<typename internal::matrix_type_times_scalar_type<Scalar,OtherDerived>::ResultScalar>());
+      applyThisOnTheLeft(res);
+      return res;
+    }
+
+    template<typename _VectorsType, typename _CoeffsType, int _Side> friend struct internal::hseq_side_dependent_impl;
+
+    /** \brief Sets the length of the Householder sequence.
+      * \param [in]  length  New value for the length.
+      *
+      * By default, the length \f$ n \f$ of the Householder sequence \f$ H = H_0 H_1 \ldots H_{n-1} \f$ is set
+      * to the number of columns of the matrix \p v passed to the constructor, or the number of rows if that
+      * is smaller. After this function is called, the length equals \p length.
+      *
+      * \sa length()
+      */
+    HouseholderSequence& setLength(Index length)
+    {
+      m_length = length;
+      return *this;
+    }
+
+    /** \brief Sets the shift of the Householder sequence.
+      * \param [in]  shift  New value for the shift.
+      *
+      * By default, a %HouseholderSequence object represents \f$ H = H_0 H_1 \ldots H_{n-1} \f$ and the i-th
+      * column of the matrix \p v passed to the constructor corresponds to the i-th Householder
+      * reflection. After this function is called, the object represents \f$ H = H_{\mathrm{shift}}
+      * H_{\mathrm{shift}+1} \ldots H_{n-1} \f$ and the i-th column of \p v corresponds to the (shift+i)-th
+      * Householder reflection.
+      *
+      * \sa shift()
+      */
+    HouseholderSequence& setShift(Index shift)
+    {
+      m_shift = shift;
+      return *this;
+    }
+
+    Index length() const { return m_length; }  /**< \brief Returns the length of the Householder sequence. */
+    Index shift() const { return m_shift; }    /**< \brief Returns the shift of the Householder sequence. */
+
+    /* Necessary for .adjoint() and .conjugate() */
+    template <typename VectorsType2, typename CoeffsType2, int Side2> friend class HouseholderSequence;
+
+  protected:
+
+    /** \brief Sets the transpose flag.
+      * \param [in]  trans  New value of the transpose flag.
+      *
+      * By default, the transpose flag is not set. If the transpose flag is set, then this object represents 
+      * \f$ H^T = H_{n-1}^T \ldots H_1^T H_0^T \f$ instead of \f$ H = H_0 H_1 \ldots H_{n-1} \f$.
+      *
+      * \sa trans()
+      */
+    HouseholderSequence& setTrans(bool trans)
+    {
+      m_trans = trans;
+      return *this;
+    }
+
+    bool trans() const { return m_trans; }     /**< \brief Returns the transpose flag. */
+
+    typename VectorsType::Nested m_vectors;
+    typename CoeffsType::Nested m_coeffs;
+    bool m_trans;
+    Index m_length;
+    Index m_shift;
+};
+
+/** \brief Computes the product of a matrix with a Householder sequence.
+  * \param[in]  other  %Matrix being multiplied.
+  * \param[in]  h      %HouseholderSequence being multiplied.
+  * \returns    Expression object representing the product.
+  *
+  * This function computes \f$ MH \f$ where \f$ M \f$ is the matrix \p other and \f$ H \f$ is the
+  * Householder sequence represented by \p h.
+  */
+template<typename OtherDerived, typename VectorsType, typename CoeffsType, int Side>
+typename internal::matrix_type_times_scalar_type<typename VectorsType::Scalar,OtherDerived>::Type operator*(const MatrixBase<OtherDerived>& other, const HouseholderSequence<VectorsType,CoeffsType,Side>& h)
+{
+  typename internal::matrix_type_times_scalar_type<typename VectorsType::Scalar,OtherDerived>::Type
+    res(other.template cast<typename internal::matrix_type_times_scalar_type<typename VectorsType::Scalar,OtherDerived>::ResultScalar>());
+  h.applyThisOnTheRight(res);
+  return res;
+}
+
+/** \ingroup Householder_Module \householder_module
+  * \brief Convenience function for constructing a Householder sequence. 
+  * \returns A HouseholderSequence constructed from the specified arguments.
+  */
+template<typename VectorsType, typename CoeffsType>
+HouseholderSequence<VectorsType,CoeffsType> householderSequence(const VectorsType& v, const CoeffsType& h)
+{
+  return HouseholderSequence<VectorsType,CoeffsType,OnTheLeft>(v, h);
+}
+
+/** \ingroup Householder_Module \householder_module
+  * \brief Convenience function for constructing a Householder sequence. 
+  * \returns A HouseholderSequence constructed from the specified arguments.
+  * \details This function differs from householderSequence() in that the template argument \p OnTheSide of
+  * the constructed HouseholderSequence is set to OnTheRight, instead of the default OnTheLeft.
+  */
+template<typename VectorsType, typename CoeffsType>
+HouseholderSequence<VectorsType,CoeffsType,OnTheRight> rightHouseholderSequence(const VectorsType& v, const CoeffsType& h)
+{
+  return HouseholderSequence<VectorsType,CoeffsType,OnTheRight>(v, h);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_HOUSEHOLDER_SEQUENCE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/IterativeLinearSolvers/BasicPreconditioners.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/IterativeLinearSolvers/BasicPreconditioners.h
new file mode 100644
index 00000000..facdaf89
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/IterativeLinearSolvers/BasicPreconditioners.h
@@ -0,0 +1,226 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_BASIC_PRECONDITIONERS_H
+#define EIGEN_BASIC_PRECONDITIONERS_H
+
+namespace Eigen { 
+
+/** \ingroup IterativeLinearSolvers_Module
+  * \brief A preconditioner based on the digonal entries
+  *
+  * This class allows to approximately solve for A.x = b problems assuming A is a diagonal matrix.
+  * In other words, this preconditioner neglects all off diagonal entries and, in Eigen's language, solves for:
+    \code
+    A.diagonal().asDiagonal() . x = b
+    \endcode
+  *
+  * \tparam _Scalar the type of the scalar.
+  *
+  * \implsparsesolverconcept
+  *
+  * This preconditioner is suitable for both selfadjoint and general problems.
+  * The diagonal entries are pre-inverted and stored into a dense vector.
+  *
+  * \note A variant that has yet to be implemented would attempt to preserve the norm of each column.
+  *
+  * \sa class LeastSquareDiagonalPreconditioner, class ConjugateGradient
+  */
+template <typename _Scalar>
+class DiagonalPreconditioner
+{
+    typedef _Scalar Scalar;
+    typedef Matrix<Scalar,Dynamic,1> Vector;
+  public:
+    typedef typename Vector::StorageIndex StorageIndex;
+    enum {
+      ColsAtCompileTime = Dynamic,
+      MaxColsAtCompileTime = Dynamic
+    };
+
+    DiagonalPreconditioner() : m_isInitialized(false) {}
+
+    template<typename MatType>
+    explicit DiagonalPreconditioner(const MatType& mat) : m_invdiag(mat.cols())
+    {
+      compute(mat);
+    }
+
+    Index rows() const { return m_invdiag.size(); }
+    Index cols() const { return m_invdiag.size(); }
+    
+    template<typename MatType>
+    DiagonalPreconditioner& analyzePattern(const MatType& )
+    {
+      return *this;
+    }
+    
+    template<typename MatType>
+    DiagonalPreconditioner& factorize(const MatType& mat)
+    {
+      m_invdiag.resize(mat.cols());
+      for(int j=0; j<mat.outerSize(); ++j)
+      {
+        typename MatType::InnerIterator it(mat,j);
+        while(it && it.index()!=j) ++it;
+        if(it && it.index()==j && it.value()!=Scalar(0))
+          m_invdiag(j) = Scalar(1)/it.value();
+        else
+          m_invdiag(j) = Scalar(1);
+      }
+      m_isInitialized = true;
+      return *this;
+    }
+    
+    template<typename MatType>
+    DiagonalPreconditioner& compute(const MatType& mat)
+    {
+      return factorize(mat);
+    }
+
+    /** \internal */
+    template<typename Rhs, typename Dest>
+    void _solve_impl(const Rhs& b, Dest& x) const
+    {
+      x = m_invdiag.array() * b.array() ;
+    }
+
+    template<typename Rhs> inline const Solve<DiagonalPreconditioner, Rhs>
+    solve(const MatrixBase<Rhs>& b) const
+    {
+      eigen_assert(m_isInitialized && "DiagonalPreconditioner is not initialized.");
+      eigen_assert(m_invdiag.size()==b.rows()
+                && "DiagonalPreconditioner::solve(): invalid number of rows of the right hand side matrix b");
+      return Solve<DiagonalPreconditioner, Rhs>(*this, b.derived());
+    }
+    
+    ComputationInfo info() { return Success; }
+
+  protected:
+    Vector m_invdiag;
+    bool m_isInitialized;
+};
+
+/** \ingroup IterativeLinearSolvers_Module
+  * \brief Jacobi preconditioner for LeastSquaresConjugateGradient
+  *
+  * This class allows to approximately solve for A' A x  = A' b problems assuming A' A is a diagonal matrix.
+  * In other words, this preconditioner neglects all off diagonal entries and, in Eigen's language, solves for:
+    \code
+    (A.adjoint() * A).diagonal().asDiagonal() * x = b
+    \endcode
+  *
+  * \tparam _Scalar the type of the scalar.
+  *
+  * \implsparsesolverconcept
+  *
+  * The diagonal entries are pre-inverted and stored into a dense vector.
+  * 
+  * \sa class LeastSquaresConjugateGradient, class DiagonalPreconditioner
+  */
+template <typename _Scalar>
+class LeastSquareDiagonalPreconditioner : public DiagonalPreconditioner<_Scalar>
+{
+    typedef _Scalar Scalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef DiagonalPreconditioner<_Scalar> Base;
+    using Base::m_invdiag;
+  public:
+
+    LeastSquareDiagonalPreconditioner() : Base() {}
+
+    template<typename MatType>
+    explicit LeastSquareDiagonalPreconditioner(const MatType& mat) : Base()
+    {
+      compute(mat);
+    }
+
+    template<typename MatType>
+    LeastSquareDiagonalPreconditioner& analyzePattern(const MatType& )
+    {
+      return *this;
+    }
+    
+    template<typename MatType>
+    LeastSquareDiagonalPreconditioner& factorize(const MatType& mat)
+    {
+      // Compute the inverse squared-norm of each column of mat
+      m_invdiag.resize(mat.cols());
+      if(MatType::IsRowMajor)
+      {
+        m_invdiag.setZero();
+        for(Index j=0; j<mat.outerSize(); ++j)
+        {
+          for(typename MatType::InnerIterator it(mat,j); it; ++it)
+            m_invdiag(it.index()) += numext::abs2(it.value());
+        }
+        for(Index j=0; j<mat.cols(); ++j)
+          if(numext::real(m_invdiag(j))>RealScalar(0))
+            m_invdiag(j) = RealScalar(1)/numext::real(m_invdiag(j));
+      }
+      else
+      {
+        for(Index j=0; j<mat.outerSize(); ++j)
+        {
+          RealScalar sum = mat.innerVector(j).squaredNorm();
+          if(sum>RealScalar(0))
+            m_invdiag(j) = RealScalar(1)/sum;
+          else
+            m_invdiag(j) = RealScalar(1);
+        }
+      }
+      Base::m_isInitialized = true;
+      return *this;
+    }
+    
+    template<typename MatType>
+    LeastSquareDiagonalPreconditioner& compute(const MatType& mat)
+    {
+      return factorize(mat);
+    }
+    
+    ComputationInfo info() { return Success; }
+
+  protected:
+};
+
+/** \ingroup IterativeLinearSolvers_Module
+  * \brief A naive preconditioner which approximates any matrix as the identity matrix
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa class DiagonalPreconditioner
+  */
+class IdentityPreconditioner
+{
+  public:
+
+    IdentityPreconditioner() {}
+
+    template<typename MatrixType>
+    explicit IdentityPreconditioner(const MatrixType& ) {}
+    
+    template<typename MatrixType>
+    IdentityPreconditioner& analyzePattern(const MatrixType& ) { return *this; }
+    
+    template<typename MatrixType>
+    IdentityPreconditioner& factorize(const MatrixType& ) { return *this; }
+
+    template<typename MatrixType>
+    IdentityPreconditioner& compute(const MatrixType& ) { return *this; }
+    
+    template<typename Rhs>
+    inline const Rhs& solve(const Rhs& b) const { return b; }
+    
+    ComputationInfo info() { return Success; }
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_BASIC_PRECONDITIONERS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/IterativeLinearSolvers/BiCGSTAB.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/IterativeLinearSolvers/BiCGSTAB.h
new file mode 100644
index 00000000..454f4681
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/IterativeLinearSolvers/BiCGSTAB.h
@@ -0,0 +1,228 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_BICGSTAB_H
+#define EIGEN_BICGSTAB_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/** \internal Low-level bi conjugate gradient stabilized algorithm
+  * \param mat The matrix A
+  * \param rhs The right hand side vector b
+  * \param x On input and initial solution, on output the computed solution.
+  * \param precond A preconditioner being able to efficiently solve for an
+  *                approximation of Ax=b (regardless of b)
+  * \param iters On input the max number of iteration, on output the number of performed iterations.
+  * \param tol_error On input the tolerance error, on output an estimation of the relative error.
+  * \return false in the case of numerical issue, for example a break down of BiCGSTAB. 
+  */
+template<typename MatrixType, typename Rhs, typename Dest, typename Preconditioner>
+bool bicgstab(const MatrixType& mat, const Rhs& rhs, Dest& x,
+              const Preconditioner& precond, Index& iters,
+              typename Dest::RealScalar& tol_error)
+{
+  using std::sqrt;
+  using std::abs;
+  typedef typename Dest::RealScalar RealScalar;
+  typedef typename Dest::Scalar Scalar;
+  typedef Matrix<Scalar,Dynamic,1> VectorType;
+  RealScalar tol = tol_error;
+  Index maxIters = iters;
+
+  Index n = mat.cols();
+  VectorType r  = rhs - mat * x;
+  VectorType r0 = r;
+  
+  RealScalar r0_sqnorm = r0.squaredNorm();
+  RealScalar rhs_sqnorm = rhs.squaredNorm();
+  if(rhs_sqnorm == 0)
+  {
+    x.setZero();
+    return true;
+  }
+  Scalar rho    = 1;
+  Scalar alpha  = 1;
+  Scalar w      = 1;
+  
+  VectorType v = VectorType::Zero(n), p = VectorType::Zero(n);
+  VectorType y(n),  z(n);
+  VectorType kt(n), ks(n);
+
+  VectorType s(n), t(n);
+
+  RealScalar tol2 = tol*tol*rhs_sqnorm;
+  RealScalar eps2 = NumTraits<Scalar>::epsilon()*NumTraits<Scalar>::epsilon();
+  Index i = 0;
+  Index restarts = 0;
+
+  while ( r.squaredNorm() > tol2 && i<maxIters )
+  {
+    Scalar rho_old = rho;
+
+    rho = r0.dot(r);
+    if (abs(rho) < eps2*r0_sqnorm)
+    {
+      // The new residual vector became too orthogonal to the arbitrarily chosen direction r0
+      // Let's restart with a new r0:
+      r  = rhs - mat * x;
+      r0 = r;
+      rho = r0_sqnorm = r.squaredNorm();
+      if(restarts++ == 0)
+        i = 0;
+    }
+    Scalar beta = (rho/rho_old) * (alpha / w);
+    p = r + beta * (p - w * v);
+    
+    y = precond.solve(p);
+    
+    v.noalias() = mat * y;
+
+    alpha = rho / r0.dot(v);
+    s = r - alpha * v;
+
+    z = precond.solve(s);
+    t.noalias() = mat * z;
+
+    RealScalar tmp = t.squaredNorm();
+    if(tmp>RealScalar(0))
+      w = t.dot(s) / tmp;
+    else
+      w = Scalar(0);
+    x += alpha * y + w * z;
+    r = s - w * t;
+    ++i;
+  }
+  tol_error = sqrt(r.squaredNorm()/rhs_sqnorm);
+  iters = i;
+  return true; 
+}
+
+}
+
+template< typename _MatrixType,
+          typename _Preconditioner = DiagonalPreconditioner<typename _MatrixType::Scalar> >
+class BiCGSTAB;
+
+namespace internal {
+
+template< typename _MatrixType, typename _Preconditioner>
+struct traits<BiCGSTAB<_MatrixType,_Preconditioner> >
+{
+  typedef _MatrixType MatrixType;
+  typedef _Preconditioner Preconditioner;
+};
+
+}
+
+/** \ingroup IterativeLinearSolvers_Module
+  * \brief A bi conjugate gradient stabilized solver for sparse square problems
+  *
+  * This class allows to solve for A.x = b sparse linear problems using a bi conjugate gradient
+  * stabilized algorithm. The vectors x and b can be either dense or sparse.
+  *
+  * \tparam _MatrixType the type of the sparse matrix A, can be a dense or a sparse matrix.
+  * \tparam _Preconditioner the type of the preconditioner. Default is DiagonalPreconditioner
+  *
+  * \implsparsesolverconcept
+  *
+  * The maximal number of iterations and tolerance value can be controlled via the setMaxIterations()
+  * and setTolerance() methods. The defaults are the size of the problem for the maximal number of iterations
+  * and NumTraits<Scalar>::epsilon() for the tolerance.
+  * 
+  * The tolerance corresponds to the relative residual error: |Ax-b|/|b|
+  * 
+  * \b Performance: when using sparse matrices, best performance is achied for a row-major sparse matrix format.
+  * Moreover, in this case multi-threading can be exploited if the user code is compiled with OpenMP enabled.
+  * See \ref TopicMultiThreading for details.
+  * 
+  * This class can be used as the direct solver classes. Here is a typical usage example:
+  * \include BiCGSTAB_simple.cpp
+  * 
+  * By default the iterations start with x=0 as an initial guess of the solution.
+  * One can control the start using the solveWithGuess() method.
+  * 
+  * BiCGSTAB can also be used in a matrix-free context, see the following \link MatrixfreeSolverExample example \endlink.
+  *
+  * \sa class SimplicialCholesky, DiagonalPreconditioner, IdentityPreconditioner
+  */
+template< typename _MatrixType, typename _Preconditioner>
+class BiCGSTAB : public IterativeSolverBase<BiCGSTAB<_MatrixType,_Preconditioner> >
+{
+  typedef IterativeSolverBase<BiCGSTAB> Base;
+  using Base::matrix;
+  using Base::m_error;
+  using Base::m_iterations;
+  using Base::m_info;
+  using Base::m_isInitialized;
+public:
+  typedef _MatrixType MatrixType;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef _Preconditioner Preconditioner;
+
+public:
+
+  /** Default constructor. */
+  BiCGSTAB() : Base() {}
+
+  /** Initialize the solver with matrix \a A for further \c Ax=b solving.
+    * 
+    * This constructor is a shortcut for the default constructor followed
+    * by a call to compute().
+    * 
+    * \warning this class stores a reference to the matrix A as well as some
+    * precomputed values that depend on it. Therefore, if \a A is changed
+    * this class becomes invalid. Call compute() to update it with the new
+    * matrix A, or modify a copy of A.
+    */
+  template<typename MatrixDerived>
+  explicit BiCGSTAB(const EigenBase<MatrixDerived>& A) : Base(A.derived()) {}
+
+  ~BiCGSTAB() {}
+
+  /** \internal */
+  template<typename Rhs,typename Dest>
+  void _solve_with_guess_impl(const Rhs& b, Dest& x) const
+  {    
+    bool failed = false;
+    for(Index j=0; j<b.cols(); ++j)
+    {
+      m_iterations = Base::maxIterations();
+      m_error = Base::m_tolerance;
+      
+      typename Dest::ColXpr xj(x,j);
+      if(!internal::bicgstab(matrix(), b.col(j), xj, Base::m_preconditioner, m_iterations, m_error))
+        failed = true;
+    }
+    m_info = failed ? NumericalIssue
+           : m_error <= Base::m_tolerance ? Success
+           : NoConvergence;
+    m_isInitialized = true;
+  }
+
+  /** \internal */
+  using Base::_solve_impl;
+  template<typename Rhs,typename Dest>
+  void _solve_impl(const MatrixBase<Rhs>& b, Dest& x) const
+  {
+    x.resize(this->rows(),b.cols());
+    x.setZero();
+    _solve_with_guess_impl(b,x);
+  }
+
+protected:
+
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_BICGSTAB_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/IterativeLinearSolvers/ConjugateGradient.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/IterativeLinearSolvers/ConjugateGradient.h
new file mode 100644
index 00000000..395daa8e
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/IterativeLinearSolvers/ConjugateGradient.h
@@ -0,0 +1,245 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CONJUGATE_GRADIENT_H
+#define EIGEN_CONJUGATE_GRADIENT_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/** \internal Low-level conjugate gradient algorithm
+  * \param mat The matrix A
+  * \param rhs The right hand side vector b
+  * \param x On input and initial solution, on output the computed solution.
+  * \param precond A preconditioner being able to efficiently solve for an
+  *                approximation of Ax=b (regardless of b)
+  * \param iters On input the max number of iteration, on output the number of performed iterations.
+  * \param tol_error On input the tolerance error, on output an estimation of the relative error.
+  */
+template<typename MatrixType, typename Rhs, typename Dest, typename Preconditioner>
+EIGEN_DONT_INLINE
+void conjugate_gradient(const MatrixType& mat, const Rhs& rhs, Dest& x,
+                        const Preconditioner& precond, Index& iters,
+                        typename Dest::RealScalar& tol_error)
+{
+  using std::sqrt;
+  using std::abs;
+  typedef typename Dest::RealScalar RealScalar;
+  typedef typename Dest::Scalar Scalar;
+  typedef Matrix<Scalar,Dynamic,1> VectorType;
+  
+  RealScalar tol = tol_error;
+  Index maxIters = iters;
+  
+  Index n = mat.cols();
+
+  VectorType residual = rhs - mat * x; //initial residual
+
+  RealScalar rhsNorm2 = rhs.squaredNorm();
+  if(rhsNorm2 == 0) 
+  {
+    x.setZero();
+    iters = 0;
+    tol_error = 0;
+    return;
+  }
+  RealScalar threshold = tol*tol*rhsNorm2;
+  RealScalar residualNorm2 = residual.squaredNorm();
+  if (residualNorm2 < threshold)
+  {
+    iters = 0;
+    tol_error = sqrt(residualNorm2 / rhsNorm2);
+    return;
+  }
+  
+  VectorType p(n);
+  p = precond.solve(residual);      // initial search direction
+
+  VectorType z(n), tmp(n);
+  RealScalar absNew = numext::real(residual.dot(p));  // the square of the absolute value of r scaled by invM
+  Index i = 0;
+  while(i < maxIters)
+  {
+    tmp.noalias() = mat * p;                    // the bottleneck of the algorithm
+
+    Scalar alpha = absNew / p.dot(tmp);         // the amount we travel on dir
+    x += alpha * p;                             // update solution
+    residual -= alpha * tmp;                    // update residual
+    
+    residualNorm2 = residual.squaredNorm();
+    if(residualNorm2 < threshold)
+      break;
+    
+    z = precond.solve(residual);                // approximately solve for "A z = residual"
+
+    RealScalar absOld = absNew;
+    absNew = numext::real(residual.dot(z));     // update the absolute value of r
+    RealScalar beta = absNew / absOld;          // calculate the Gram-Schmidt value used to create the new search direction
+    p = z + beta * p;                           // update search direction
+    i++;
+  }
+  tol_error = sqrt(residualNorm2 / rhsNorm2);
+  iters = i;
+}
+
+}
+
+template< typename _MatrixType, int _UpLo=Lower,
+          typename _Preconditioner = DiagonalPreconditioner<typename _MatrixType::Scalar> >
+class ConjugateGradient;
+
+namespace internal {
+
+template< typename _MatrixType, int _UpLo, typename _Preconditioner>
+struct traits<ConjugateGradient<_MatrixType,_UpLo,_Preconditioner> >
+{
+  typedef _MatrixType MatrixType;
+  typedef _Preconditioner Preconditioner;
+};
+
+}
+
+/** \ingroup IterativeLinearSolvers_Module
+  * \brief A conjugate gradient solver for sparse (or dense) self-adjoint problems
+  *
+  * This class allows to solve for A.x = b linear problems using an iterative conjugate gradient algorithm.
+  * The matrix A must be selfadjoint. The matrix A and the vectors x and b can be either dense or sparse.
+  *
+  * \tparam _MatrixType the type of the matrix A, can be a dense or a sparse matrix.
+  * \tparam _UpLo the triangular part that will be used for the computations. It can be Lower,
+  *               \c Upper, or \c Lower|Upper in which the full matrix entries will be considered.
+  *               Default is \c Lower, best performance is \c Lower|Upper.
+  * \tparam _Preconditioner the type of the preconditioner. Default is DiagonalPreconditioner
+  *
+  * \implsparsesolverconcept
+  *
+  * The maximal number of iterations and tolerance value can be controlled via the setMaxIterations()
+  * and setTolerance() methods. The defaults are the size of the problem for the maximal number of iterations
+  * and NumTraits<Scalar>::epsilon() for the tolerance.
+  * 
+  * The tolerance corresponds to the relative residual error: |Ax-b|/|b|
+  * 
+  * \b Performance: Even though the default value of \c _UpLo is \c Lower, significantly higher performance is
+  * achieved when using a complete matrix and \b Lower|Upper as the \a _UpLo template parameter. Moreover, in this
+  * case multi-threading can be exploited if the user code is compiled with OpenMP enabled.
+  * See \ref TopicMultiThreading for details.
+  * 
+  * This class can be used as the direct solver classes. Here is a typical usage example:
+    \code
+    int n = 10000;
+    VectorXd x(n), b(n);
+    SparseMatrix<double> A(n,n);
+    // fill A and b
+    ConjugateGradient<SparseMatrix<double>, Lower|Upper> cg;
+    cg.compute(A);
+    x = cg.solve(b);
+    std::cout << "#iterations:     " << cg.iterations() << std::endl;
+    std::cout << "estimated error: " << cg.error()      << std::endl;
+    // update b, and solve again
+    x = cg.solve(b);
+    \endcode
+  * 
+  * By default the iterations start with x=0 as an initial guess of the solution.
+  * One can control the start using the solveWithGuess() method.
+  * 
+  * ConjugateGradient can also be used in a matrix-free context, see the following \link MatrixfreeSolverExample example \endlink.
+  *
+  * \sa class LeastSquaresConjugateGradient, class SimplicialCholesky, DiagonalPreconditioner, IdentityPreconditioner
+  */
+template< typename _MatrixType, int _UpLo, typename _Preconditioner>
+class ConjugateGradient : public IterativeSolverBase<ConjugateGradient<_MatrixType,_UpLo,_Preconditioner> >
+{
+  typedef IterativeSolverBase<ConjugateGradient> Base;
+  using Base::matrix;
+  using Base::m_error;
+  using Base::m_iterations;
+  using Base::m_info;
+  using Base::m_isInitialized;
+public:
+  typedef _MatrixType MatrixType;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef _Preconditioner Preconditioner;
+
+  enum {
+    UpLo = _UpLo
+  };
+
+public:
+
+  /** Default constructor. */
+  ConjugateGradient() : Base() {}
+
+  /** Initialize the solver with matrix \a A for further \c Ax=b solving.
+    * 
+    * This constructor is a shortcut for the default constructor followed
+    * by a call to compute().
+    * 
+    * \warning this class stores a reference to the matrix A as well as some
+    * precomputed values that depend on it. Therefore, if \a A is changed
+    * this class becomes invalid. Call compute() to update it with the new
+    * matrix A, or modify a copy of A.
+    */
+  template<typename MatrixDerived>
+  explicit ConjugateGradient(const EigenBase<MatrixDerived>& A) : Base(A.derived()) {}
+
+  ~ConjugateGradient() {}
+
+  /** \internal */
+  template<typename Rhs,typename Dest>
+  void _solve_with_guess_impl(const Rhs& b, Dest& x) const
+  {
+    typedef typename Base::MatrixWrapper MatrixWrapper;
+    typedef typename Base::ActualMatrixType ActualMatrixType;
+    enum {
+      TransposeInput  =   (!MatrixWrapper::MatrixFree)
+                      &&  (UpLo==(Lower|Upper))
+                      &&  (!MatrixType::IsRowMajor)
+                      &&  (!NumTraits<Scalar>::IsComplex)
+    };
+    typedef typename internal::conditional<TransposeInput,Transpose<const ActualMatrixType>, ActualMatrixType const&>::type RowMajorWrapper;
+    EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(MatrixWrapper::MatrixFree,UpLo==(Lower|Upper)),MATRIX_FREE_CONJUGATE_GRADIENT_IS_COMPATIBLE_WITH_UPPER_UNION_LOWER_MODE_ONLY);
+    typedef typename internal::conditional<UpLo==(Lower|Upper),
+                                           RowMajorWrapper,
+                                           typename MatrixWrapper::template ConstSelfAdjointViewReturnType<UpLo>::Type
+                                          >::type SelfAdjointWrapper;
+    m_iterations = Base::maxIterations();
+    m_error = Base::m_tolerance;
+
+    for(Index j=0; j<b.cols(); ++j)
+    {
+      m_iterations = Base::maxIterations();
+      m_error = Base::m_tolerance;
+
+      typename Dest::ColXpr xj(x,j);
+      RowMajorWrapper row_mat(matrix());
+      internal::conjugate_gradient(SelfAdjointWrapper(row_mat), b.col(j), xj, Base::m_preconditioner, m_iterations, m_error);
+    }
+
+    m_isInitialized = true;
+    m_info = m_error <= Base::m_tolerance ? Success : NoConvergence;
+  }
+  
+  /** \internal */
+  using Base::_solve_impl;
+  template<typename Rhs,typename Dest>
+  void _solve_impl(const MatrixBase<Rhs>& b, Dest& x) const
+  {
+    x.setZero();
+    _solve_with_guess_impl(b.derived(),x);
+  }
+
+protected:
+
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_CONJUGATE_GRADIENT_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/IterativeLinearSolvers/IncompleteCholesky.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/IterativeLinearSolvers/IncompleteCholesky.h
new file mode 100644
index 00000000..e45c272b
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/IterativeLinearSolvers/IncompleteCholesky.h
@@ -0,0 +1,400 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+// Copyright (C) 2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_INCOMPLETE_CHOlESKY_H
+#define EIGEN_INCOMPLETE_CHOlESKY_H
+
+#include <vector>
+#include <list>
+
+namespace Eigen {  
+/** 
+  * \brief Modified Incomplete Cholesky with dual threshold
+  *
+  * References : C-J. Lin and J. J. Moré, Incomplete Cholesky Factorizations with
+  *              Limited memory, SIAM J. Sci. Comput.  21(1), pp. 24-45, 1999
+  *
+  * \tparam Scalar the scalar type of the input matrices
+  * \tparam _UpLo The triangular part that will be used for the computations. It can be Lower
+    *               or Upper. Default is Lower.
+  * \tparam _OrderingType The ordering method to use, either AMDOrdering<> or NaturalOrdering<>. Default is AMDOrdering<int>,
+  *                       unless EIGEN_MPL2_ONLY is defined, in which case the default is NaturalOrdering<int>.
+  *
+  * \implsparsesolverconcept
+  *
+  * It performs the following incomplete factorization: \f$ S P A P' S \approx L L' \f$
+  * where L is a lower triangular factor, S is a diagonal scaling matrix, and P is a
+  * fill-in reducing permutation as computed by the ordering method.
+  *
+  * \b Shifting \b strategy: Let \f$ B = S P A P' S \f$  be the scaled matrix on which the factorization is carried out,
+  * and \f$ \beta \f$ be the minimum value of the diagonal. If \f$ \beta > 0 \f$ then, the factorization is directly performed
+  * on the matrix B. Otherwise, the factorization is performed on the shifted matrix \f$ B + (\sigma+|\beta| I \f$ where
+  * \f$ \sigma \f$ is the initial shift value as returned and set by setInitialShift() method. The default value is \f$ \sigma = 10^{-3} \f$.
+  * If the factorization fails, then the shift in doubled until it succeed or a maximum of ten attempts. If it still fails, as returned by
+  * the info() method, then you can either increase the initial shift, or better use another preconditioning technique.
+  *
+  */
+template <typename Scalar, int _UpLo = Lower, typename _OrderingType =
+#ifndef EIGEN_MPL2_ONLY
+AMDOrdering<int>
+#else
+NaturalOrdering<int>
+#endif
+>
+class IncompleteCholesky : public SparseSolverBase<IncompleteCholesky<Scalar,_UpLo,_OrderingType> >
+{
+  protected:
+    typedef SparseSolverBase<IncompleteCholesky<Scalar,_UpLo,_OrderingType> > Base;
+    using Base::m_isInitialized;
+  public:
+    typedef typename NumTraits<Scalar>::Real RealScalar; 
+    typedef _OrderingType OrderingType;
+    typedef typename OrderingType::PermutationType PermutationType;
+    typedef typename PermutationType::StorageIndex StorageIndex; 
+    typedef SparseMatrix<Scalar,ColMajor,StorageIndex> FactorType;
+    typedef Matrix<Scalar,Dynamic,1> VectorSx;
+    typedef Matrix<RealScalar,Dynamic,1> VectorRx;
+    typedef Matrix<StorageIndex,Dynamic, 1> VectorIx;
+    typedef std::vector<std::list<StorageIndex> > VectorList; 
+    enum { UpLo = _UpLo };
+    enum {
+      ColsAtCompileTime = Dynamic,
+      MaxColsAtCompileTime = Dynamic
+    };
+  public:
+
+    /** Default constructor leaving the object in a partly non-initialized stage.
+      *
+      * You must call compute() or the pair analyzePattern()/factorize() to make it valid.
+      *
+      * \sa IncompleteCholesky(const MatrixType&)
+      */
+    IncompleteCholesky() : m_initialShift(1e-3),m_factorizationIsOk(false) {}
+    
+    /** Constructor computing the incomplete factorization for the given matrix \a matrix.
+      */
+    template<typename MatrixType>
+    IncompleteCholesky(const MatrixType& matrix) : m_initialShift(1e-3),m_factorizationIsOk(false)
+    {
+      compute(matrix);
+    }
+    
+    /** \returns number of rows of the factored matrix */
+    Index rows() const { return m_L.rows(); }
+    
+    /** \returns number of columns of the factored matrix */
+    Index cols() const { return m_L.cols(); }
+    
+
+    /** \brief Reports whether previous computation was successful.
+      *
+      * It triggers an assertion if \c *this has not been initialized through the respective constructor,
+      * or a call to compute() or analyzePattern().
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the matrix appears to be negative.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "IncompleteCholesky is not initialized.");
+      return m_info;
+    }
+    
+    /** \brief Set the initial shift parameter \f$ \sigma \f$.
+      */
+    void setInitialShift(RealScalar shift) { m_initialShift = shift; }
+    
+    /** \brief Computes the fill reducing permutation vector using the sparsity pattern of \a mat
+      */
+    template<typename MatrixType>
+    void analyzePattern(const MatrixType& mat)
+    {
+      OrderingType ord; 
+      PermutationType pinv;
+      ord(mat.template selfadjointView<UpLo>(), pinv); 
+      if(pinv.size()>0) m_perm = pinv.inverse();
+      else              m_perm.resize(0);
+      m_L.resize(mat.rows(), mat.cols());
+      m_analysisIsOk = true;
+      m_isInitialized = true;
+      m_info = Success;
+    }
+    
+    /** \brief Performs the numerical factorization of the input matrix \a mat
+      *
+      * The method analyzePattern() or compute() must have been called beforehand
+      * with a matrix having the same pattern.
+      *
+      * \sa compute(), analyzePattern()
+      */
+    template<typename MatrixType>
+    void factorize(const MatrixType& mat);
+    
+    /** Computes or re-computes the incomplete Cholesky factorization of the input matrix \a mat
+      *
+      * It is a shortcut for a sequential call to the analyzePattern() and factorize() methods.
+      *
+      * \sa analyzePattern(), factorize()
+      */
+    template<typename MatrixType>
+    void compute(const MatrixType& mat)
+    {
+      analyzePattern(mat);
+      factorize(mat);
+    }
+    
+    // internal
+    template<typename Rhs, typename Dest>
+    void _solve_impl(const Rhs& b, Dest& x) const
+    {
+      eigen_assert(m_factorizationIsOk && "factorize() should be called first");
+      if (m_perm.rows() == b.rows())  x = m_perm * b;
+      else                            x = b;
+      x = m_scale.asDiagonal() * x;
+      x = m_L.template triangularView<Lower>().solve(x);
+      x = m_L.adjoint().template triangularView<Upper>().solve(x);
+      x = m_scale.asDiagonal() * x;
+      if (m_perm.rows() == b.rows())
+        x = m_perm.inverse() * x;
+    }
+
+    /** \returns the sparse lower triangular factor L */
+    const FactorType& matrixL() const { eigen_assert("m_factorizationIsOk"); return m_L; }
+
+    /** \returns a vector representing the scaling factor S */
+    const VectorRx& scalingS() const { eigen_assert("m_factorizationIsOk"); return m_scale; }
+
+    /** \returns the fill-in reducing permutation P (can be empty for a natural ordering) */
+    const PermutationType& permutationP() const { eigen_assert("m_analysisIsOk"); return m_perm; }
+
+  protected:
+    FactorType m_L;              // The lower part stored in CSC
+    VectorRx m_scale;            // The vector for scaling the matrix 
+    RealScalar m_initialShift;   // The initial shift parameter
+    bool m_analysisIsOk; 
+    bool m_factorizationIsOk; 
+    ComputationInfo m_info;
+    PermutationType m_perm; 
+
+  private:
+    inline void updateList(Ref<const VectorIx> colPtr, Ref<VectorIx> rowIdx, Ref<VectorSx> vals, const Index& col, const Index& jk, VectorIx& firstElt, VectorList& listCol); 
+}; 
+
+// Based on the following paper:
+//   C-J. Lin and J. J. Moré, Incomplete Cholesky Factorizations with
+//   Limited memory, SIAM J. Sci. Comput.  21(1), pp. 24-45, 1999
+//   http://ftp.mcs.anl.gov/pub/tech_reports/reports/P682.pdf
+template<typename Scalar, int _UpLo, typename OrderingType>
+template<typename _MatrixType>
+void IncompleteCholesky<Scalar,_UpLo, OrderingType>::factorize(const _MatrixType& mat)
+{
+  using std::sqrt;
+  eigen_assert(m_analysisIsOk && "analyzePattern() should be called first"); 
+    
+  // Dropping strategy : Keep only the p largest elements per column, where p is the number of elements in the column of the original matrix. Other strategies will be added
+  
+  // Apply the fill-reducing permutation computed in analyzePattern()
+  if (m_perm.rows() == mat.rows() ) // To detect the null permutation
+  {
+    // The temporary is needed to make sure that the diagonal entry is properly sorted
+    FactorType tmp(mat.rows(), mat.cols());
+    tmp = mat.template selfadjointView<_UpLo>().twistedBy(m_perm);
+    m_L.template selfadjointView<Lower>() = tmp.template selfadjointView<Lower>();
+  }
+  else
+  {
+    m_L.template selfadjointView<Lower>() = mat.template selfadjointView<_UpLo>();
+  }
+  
+  Index n = m_L.cols(); 
+  Index nnz = m_L.nonZeros();
+  Map<VectorSx> vals(m_L.valuePtr(), nnz);         //values
+  Map<VectorIx> rowIdx(m_L.innerIndexPtr(), nnz);  //Row indices
+  Map<VectorIx> colPtr( m_L.outerIndexPtr(), n+1); // Pointer to the beginning of each row
+  VectorIx firstElt(n-1); // for each j, points to the next entry in vals that will be used in the factorization
+  VectorList listCol(n);  // listCol(j) is a linked list of columns to update column j
+  VectorSx col_vals(n);   // Store a  nonzero values in each column
+  VectorIx col_irow(n);   // Row indices of nonzero elements in each column
+  VectorIx col_pattern(n);
+  col_pattern.fill(-1);
+  StorageIndex col_nnz;
+  
+  
+  // Computes the scaling factors 
+  m_scale.resize(n);
+  m_scale.setZero();
+  for (Index j = 0; j < n; j++)
+    for (Index k = colPtr[j]; k < colPtr[j+1]; k++)
+    {
+      m_scale(j) += numext::abs2(vals(k));
+      if(rowIdx[k]!=j)
+        m_scale(rowIdx[k]) += numext::abs2(vals(k));
+    }
+  
+  m_scale = m_scale.cwiseSqrt().cwiseSqrt();
+
+  for (Index j = 0; j < n; ++j)
+    if(m_scale(j)>(std::numeric_limits<RealScalar>::min)())
+      m_scale(j) = RealScalar(1)/m_scale(j);
+    else
+      m_scale(j) = 1;
+
+  // TODO disable scaling if not needed, i.e., if it is roughly uniform? (this will make solve() faster)
+  
+  // Scale and compute the shift for the matrix 
+  RealScalar mindiag = NumTraits<RealScalar>::highest();
+  for (Index j = 0; j < n; j++)
+  {
+    for (Index k = colPtr[j]; k < colPtr[j+1]; k++)
+      vals[k] *= (m_scale(j)*m_scale(rowIdx[k]));
+    eigen_internal_assert(rowIdx[colPtr[j]]==j && "IncompleteCholesky: only the lower triangular part must be stored");
+    mindiag = numext::mini(numext::real(vals[colPtr[j]]), mindiag);
+  }
+
+  FactorType L_save = m_L;
+  
+  RealScalar shift = 0;
+  if(mindiag <= RealScalar(0.))
+    shift = m_initialShift - mindiag;
+
+  m_info = NumericalIssue;
+
+  // Try to perform the incomplete factorization using the current shift
+  int iter = 0;
+  do
+  {
+    // Apply the shift to the diagonal elements of the matrix
+    for (Index j = 0; j < n; j++)
+      vals[colPtr[j]] += shift;
+
+    // jki version of the Cholesky factorization
+    Index j=0;
+    for (; j < n; ++j)
+    {
+      // Left-looking factorization of the j-th column
+      // First, load the j-th column into col_vals
+      Scalar diag = vals[colPtr[j]];  // It is assumed that only the lower part is stored
+      col_nnz = 0;
+      for (Index i = colPtr[j] + 1; i < colPtr[j+1]; i++)
+      {
+        StorageIndex l = rowIdx[i];
+        col_vals(col_nnz) = vals[i];
+        col_irow(col_nnz) = l;
+        col_pattern(l) = col_nnz;
+        col_nnz++;
+      }
+      {
+        typename std::list<StorageIndex>::iterator k;
+        // Browse all previous columns that will update column j
+        for(k = listCol[j].begin(); k != listCol[j].end(); k++)
+        {
+          Index jk = firstElt(*k); // First element to use in the column
+          eigen_internal_assert(rowIdx[jk]==j);
+          Scalar v_j_jk = numext::conj(vals[jk]);
+
+          jk += 1;
+          for (Index i = jk; i < colPtr[*k+1]; i++)
+          {
+            StorageIndex l = rowIdx[i];
+            if(col_pattern[l]<0)
+            {
+              col_vals(col_nnz) = vals[i] * v_j_jk;
+              col_irow[col_nnz] = l;
+              col_pattern(l) = col_nnz;
+              col_nnz++;
+            }
+            else
+              col_vals(col_pattern[l]) -= vals[i] * v_j_jk;
+          }
+          updateList(colPtr,rowIdx,vals, *k, jk, firstElt, listCol);
+        }
+      }
+
+      // Scale the current column
+      if(numext::real(diag) <= 0)
+      {
+        if(++iter>=10)
+          return;
+
+        // increase shift
+        shift = numext::maxi(m_initialShift,RealScalar(2)*shift);
+        // restore m_L, col_pattern, and listCol
+        vals = Map<const VectorSx>(L_save.valuePtr(), nnz);
+        rowIdx = Map<const VectorIx>(L_save.innerIndexPtr(), nnz);
+        colPtr = Map<const VectorIx>(L_save.outerIndexPtr(), n+1);
+        col_pattern.fill(-1);
+        for(Index i=0; i<n; ++i)
+          listCol[i].clear();
+
+        break;
+      }
+
+      RealScalar rdiag = sqrt(numext::real(diag));
+      vals[colPtr[j]] = rdiag;
+      for (Index k = 0; k<col_nnz; ++k)
+      {
+        Index i = col_irow[k];
+        //Scale
+        col_vals(k) /= rdiag;
+        //Update the remaining diagonals with col_vals
+        vals[colPtr[i]] -= numext::abs2(col_vals(k));
+      }
+      // Select the largest p elements
+      // p is the original number of elements in the column (without the diagonal)
+      Index p = colPtr[j+1] - colPtr[j] - 1 ;
+      Ref<VectorSx> cvals = col_vals.head(col_nnz);
+      Ref<VectorIx> cirow = col_irow.head(col_nnz);
+      internal::QuickSplit(cvals,cirow, p);
+      // Insert the largest p elements in the matrix
+      Index cpt = 0;
+      for (Index i = colPtr[j]+1; i < colPtr[j+1]; i++)
+      {
+        vals[i] = col_vals(cpt);
+        rowIdx[i] = col_irow(cpt);
+        // restore col_pattern:
+        col_pattern(col_irow(cpt)) = -1;
+        cpt++;
+      }
+      // Get the first smallest row index and put it after the diagonal element
+      Index jk = colPtr(j)+1;
+      updateList(colPtr,rowIdx,vals,j,jk,firstElt,listCol);
+    }
+
+    if(j==n)
+    {
+      m_factorizationIsOk = true;
+      m_info = Success;
+    }
+  } while(m_info!=Success);
+}
+
+template<typename Scalar, int _UpLo, typename OrderingType>
+inline void IncompleteCholesky<Scalar,_UpLo, OrderingType>::updateList(Ref<const VectorIx> colPtr, Ref<VectorIx> rowIdx, Ref<VectorSx> vals, const Index& col, const Index& jk, VectorIx& firstElt, VectorList& listCol)
+{
+  if (jk < colPtr(col+1) )
+  {
+    Index p = colPtr(col+1) - jk;
+    Index minpos; 
+    rowIdx.segment(jk,p).minCoeff(&minpos);
+    minpos += jk;
+    if (rowIdx(minpos) != rowIdx(jk))
+    {
+      //Swap
+      std::swap(rowIdx(jk),rowIdx(minpos));
+      std::swap(vals(jk),vals(minpos));
+    }
+    firstElt(col) = internal::convert_index<StorageIndex,Index>(jk);
+    listCol[rowIdx(jk)].push_back(internal::convert_index<StorageIndex,Index>(col));
+  }
+}
+
+} // end namespace Eigen 
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/IterativeLinearSolvers/IncompleteLUT.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/IterativeLinearSolvers/IncompleteLUT.h
new file mode 100644
index 00000000..338e6f10
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/IterativeLinearSolvers/IncompleteLUT.h
@@ -0,0 +1,462 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+// Copyright (C) 2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_INCOMPLETE_LUT_H
+#define EIGEN_INCOMPLETE_LUT_H
+
+
+namespace Eigen { 
+
+namespace internal {
+    
+/** \internal
+  * Compute a quick-sort split of a vector 
+  * On output, the vector row is permuted such that its elements satisfy
+  * abs(row(i)) >= abs(row(ncut)) if i<ncut
+  * abs(row(i)) <= abs(row(ncut)) if i>ncut 
+  * \param row The vector of values
+  * \param ind The array of index for the elements in @p row
+  * \param ncut  The number of largest elements to keep
+  **/ 
+template <typename VectorV, typename VectorI>
+Index QuickSplit(VectorV &row, VectorI &ind, Index ncut)
+{
+  typedef typename VectorV::RealScalar RealScalar;
+  using std::swap;
+  using std::abs;
+  Index mid;
+  Index n = row.size(); /* length of the vector */
+  Index first, last ;
+  
+  ncut--; /* to fit the zero-based indices */
+  first = 0; 
+  last = n-1; 
+  if (ncut < first || ncut > last ) return 0;
+  
+  do {
+    mid = first; 
+    RealScalar abskey = abs(row(mid)); 
+    for (Index j = first + 1; j <= last; j++) {
+      if ( abs(row(j)) > abskey) {
+        ++mid;
+        swap(row(mid), row(j));
+        swap(ind(mid), ind(j));
+      }
+    }
+    /* Interchange for the pivot element */
+    swap(row(mid), row(first));
+    swap(ind(mid), ind(first));
+    
+    if (mid > ncut) last = mid - 1;
+    else if (mid < ncut ) first = mid + 1; 
+  } while (mid != ncut );
+  
+  return 0; /* mid is equal to ncut */ 
+}
+
+}// end namespace internal
+
+/** \ingroup IterativeLinearSolvers_Module
+  * \class IncompleteLUT
+  * \brief Incomplete LU factorization with dual-threshold strategy
+  *
+  * \implsparsesolverconcept
+  *
+  * During the numerical factorization, two dropping rules are used :
+  *  1) any element whose magnitude is less than some tolerance is dropped.
+  *    This tolerance is obtained by multiplying the input tolerance @p droptol 
+  *    by the average magnitude of all the original elements in the current row.
+  *  2) After the elimination of the row, only the @p fill largest elements in 
+  *    the L part and the @p fill largest elements in the U part are kept 
+  *    (in addition to the diagonal element ). Note that @p fill is computed from 
+  *    the input parameter @p fillfactor which is used the ratio to control the fill_in 
+  *    relatively to the initial number of nonzero elements.
+  * 
+  * The two extreme cases are when @p droptol=0 (to keep all the @p fill*2 largest elements)
+  * and when @p fill=n/2 with @p droptol being different to zero. 
+  * 
+  * References : Yousef Saad, ILUT: A dual threshold incomplete LU factorization, 
+  *              Numerical Linear Algebra with Applications, 1(4), pp 387-402, 1994.
+  * 
+  * NOTE : The following implementation is derived from the ILUT implementation
+  * in the SPARSKIT package, Copyright (C) 2005, the Regents of the University of Minnesota 
+  *  released under the terms of the GNU LGPL: 
+  *    http://www-users.cs.umn.edu/~saad/software/SPARSKIT/README
+  * However, Yousef Saad gave us permission to relicense his ILUT code to MPL2.
+  * See the Eigen mailing list archive, thread: ILUT, date: July 8, 2012:
+  *   http://listengine.tuxfamily.org/lists.tuxfamily.org/eigen/2012/07/msg00064.html
+  * alternatively, on GMANE:
+  *   http://comments.gmane.org/gmane.comp.lib.eigen/3302
+  */
+template <typename _Scalar, typename _StorageIndex = int>
+class IncompleteLUT : public SparseSolverBase<IncompleteLUT<_Scalar, _StorageIndex> >
+{
+  protected:
+    typedef SparseSolverBase<IncompleteLUT> Base;
+    using Base::m_isInitialized;
+  public:
+    typedef _Scalar Scalar;
+    typedef _StorageIndex StorageIndex;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef Matrix<Scalar,Dynamic,1> Vector;
+    typedef Matrix<StorageIndex,Dynamic,1> VectorI;
+    typedef SparseMatrix<Scalar,RowMajor,StorageIndex> FactorType;
+
+    enum {
+      ColsAtCompileTime = Dynamic,
+      MaxColsAtCompileTime = Dynamic
+    };
+
+  public:
+    
+    IncompleteLUT()
+      : m_droptol(NumTraits<Scalar>::dummy_precision()), m_fillfactor(10),
+        m_analysisIsOk(false), m_factorizationIsOk(false)
+    {}
+    
+    template<typename MatrixType>
+    explicit IncompleteLUT(const MatrixType& mat, const RealScalar& droptol=NumTraits<Scalar>::dummy_precision(), int fillfactor = 10)
+      : m_droptol(droptol),m_fillfactor(fillfactor),
+        m_analysisIsOk(false),m_factorizationIsOk(false)
+    {
+      eigen_assert(fillfactor != 0);
+      compute(mat); 
+    }
+    
+    Index rows() const { return m_lu.rows(); }
+    
+    Index cols() const { return m_lu.cols(); }
+
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was succesful,
+      *          \c NumericalIssue if the matrix.appears to be negative.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "IncompleteLUT is not initialized.");
+      return m_info;
+    }
+    
+    template<typename MatrixType>
+    void analyzePattern(const MatrixType& amat);
+    
+    template<typename MatrixType>
+    void factorize(const MatrixType& amat);
+    
+    /**
+      * Compute an incomplete LU factorization with dual threshold on the matrix mat
+      * No pivoting is done in this version
+      * 
+      **/
+    template<typename MatrixType>
+    IncompleteLUT& compute(const MatrixType& amat)
+    {
+      analyzePattern(amat); 
+      factorize(amat);
+      return *this;
+    }
+
+    void setDroptol(const RealScalar& droptol); 
+    void setFillfactor(int fillfactor); 
+    
+    template<typename Rhs, typename Dest>
+    void _solve_impl(const Rhs& b, Dest& x) const
+    {
+      x = m_Pinv * b;
+      x = m_lu.template triangularView<UnitLower>().solve(x);
+      x = m_lu.template triangularView<Upper>().solve(x);
+      x = m_P * x; 
+    }
+
+protected:
+
+    /** keeps off-diagonal entries; drops diagonal entries */
+    struct keep_diag {
+      inline bool operator() (const Index& row, const Index& col, const Scalar&) const
+      {
+        return row!=col;
+      }
+    };
+
+protected:
+
+    FactorType m_lu;
+    RealScalar m_droptol;
+    int m_fillfactor;
+    bool m_analysisIsOk;
+    bool m_factorizationIsOk;
+    ComputationInfo m_info;
+    PermutationMatrix<Dynamic,Dynamic,StorageIndex> m_P;     // Fill-reducing permutation
+    PermutationMatrix<Dynamic,Dynamic,StorageIndex> m_Pinv;  // Inverse permutation
+};
+
+/**
+ * Set control parameter droptol
+ *  \param droptol   Drop any element whose magnitude is less than this tolerance 
+ **/ 
+template<typename Scalar, typename StorageIndex>
+void IncompleteLUT<Scalar,StorageIndex>::setDroptol(const RealScalar& droptol)
+{
+  this->m_droptol = droptol;   
+}
+
+/**
+ * Set control parameter fillfactor
+ * \param fillfactor  This is used to compute the  number @p fill_in of largest elements to keep on each row. 
+ **/ 
+template<typename Scalar, typename StorageIndex>
+void IncompleteLUT<Scalar,StorageIndex>::setFillfactor(int fillfactor)
+{
+  this->m_fillfactor = fillfactor;   
+}
+
+template <typename Scalar, typename StorageIndex>
+template<typename _MatrixType>
+void IncompleteLUT<Scalar,StorageIndex>::analyzePattern(const _MatrixType& amat)
+{
+  // Compute the Fill-reducing permutation
+  // Since ILUT does not perform any numerical pivoting,
+  // it is highly preferable to keep the diagonal through symmetric permutations.
+#ifndef EIGEN_MPL2_ONLY
+  // To this end, let's symmetrize the pattern and perform AMD on it.
+  SparseMatrix<Scalar,ColMajor, StorageIndex> mat1 = amat;
+  SparseMatrix<Scalar,ColMajor, StorageIndex> mat2 = amat.transpose();
+  // FIXME for a matrix with nearly symmetric pattern, mat2+mat1 is the appropriate choice.
+  //       on the other hand for a really non-symmetric pattern, mat2*mat1 should be prefered...
+  SparseMatrix<Scalar,ColMajor, StorageIndex> AtA = mat2 + mat1;
+  AMDOrdering<StorageIndex> ordering;
+  ordering(AtA,m_P);
+  m_Pinv  = m_P.inverse(); // cache the inverse permutation
+#else
+  // If AMD is not available, (MPL2-only), then let's use the slower COLAMD routine.
+  SparseMatrix<Scalar,ColMajor, StorageIndex> mat1 = amat;
+  COLAMDOrdering<StorageIndex> ordering;
+  ordering(mat1,m_Pinv);
+  m_P = m_Pinv.inverse();
+#endif
+
+  m_analysisIsOk = true;
+  m_factorizationIsOk = false;
+  m_isInitialized = true;
+}
+
+template <typename Scalar, typename StorageIndex>
+template<typename _MatrixType>
+void IncompleteLUT<Scalar,StorageIndex>::factorize(const _MatrixType& amat)
+{
+  using std::sqrt;
+  using std::swap;
+  using std::abs;
+  using internal::convert_index;
+
+  eigen_assert((amat.rows() == amat.cols()) && "The factorization should be done on a square matrix");
+  Index n = amat.cols();  // Size of the matrix
+  m_lu.resize(n,n);
+  // Declare Working vectors and variables
+  Vector u(n) ;     // real values of the row -- maximum size is n --
+  VectorI ju(n);   // column position of the values in u -- maximum size  is n
+  VectorI jr(n);   // Indicate the position of the nonzero elements in the vector u -- A zero location is indicated by -1
+
+  // Apply the fill-reducing permutation
+  eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
+  SparseMatrix<Scalar,RowMajor, StorageIndex> mat;
+  mat = amat.twistedBy(m_Pinv);
+
+  // Initialization
+  jr.fill(-1);
+  ju.fill(0);
+  u.fill(0);
+
+  // number of largest elements to keep in each row:
+  Index fill_in = (amat.nonZeros()*m_fillfactor)/n + 1;
+  if (fill_in > n) fill_in = n;
+
+  // number of largest nonzero elements to keep in the L and the U part of the current row:
+  Index nnzL = fill_in/2;
+  Index nnzU = nnzL;
+  m_lu.reserve(n * (nnzL + nnzU + 1));
+
+  // global loop over the rows of the sparse matrix
+  for (Index ii = 0; ii < n; ii++)
+  {
+    // 1 - copy the lower and the upper part of the row i of mat in the working vector u
+
+    Index sizeu = 1; // number of nonzero elements in the upper part of the current row
+    Index sizel = 0; // number of nonzero elements in the lower part of the current row
+    ju(ii)    = convert_index<StorageIndex>(ii);
+    u(ii)     = 0;
+    jr(ii)    = convert_index<StorageIndex>(ii);
+    RealScalar rownorm = 0;
+
+    typename FactorType::InnerIterator j_it(mat, ii); // Iterate through the current row ii
+    for (; j_it; ++j_it)
+    {
+      Index k = j_it.index();
+      if (k < ii)
+      {
+        // copy the lower part
+        ju(sizel) = convert_index<StorageIndex>(k);
+        u(sizel) = j_it.value();
+        jr(k) = convert_index<StorageIndex>(sizel);
+        ++sizel;
+      }
+      else if (k == ii)
+      {
+        u(ii) = j_it.value();
+      }
+      else
+      {
+        // copy the upper part
+        Index jpos = ii + sizeu;
+        ju(jpos) = convert_index<StorageIndex>(k);
+        u(jpos) = j_it.value();
+        jr(k) = convert_index<StorageIndex>(jpos);
+        ++sizeu;
+      }
+      rownorm += numext::abs2(j_it.value());
+    }
+
+    // 2 - detect possible zero row
+    if(rownorm==0)
+    {
+      m_info = NumericalIssue;
+      return;
+    }
+    // Take the 2-norm of the current row as a relative tolerance
+    rownorm = sqrt(rownorm);
+
+    // 3 - eliminate the previous nonzero rows
+    Index jj = 0;
+    Index len = 0;
+    while (jj < sizel)
+    {
+      // In order to eliminate in the correct order,
+      // we must select first the smallest column index among  ju(jj:sizel)
+      Index k;
+      Index minrow = ju.segment(jj,sizel-jj).minCoeff(&k); // k is relative to the segment
+      k += jj;
+      if (minrow != ju(jj))
+      {
+        // swap the two locations
+        Index j = ju(jj);
+        swap(ju(jj), ju(k));
+        jr(minrow) = convert_index<StorageIndex>(jj);
+        jr(j) = convert_index<StorageIndex>(k);
+        swap(u(jj), u(k));
+      }
+      // Reset this location
+      jr(minrow) = -1;
+
+      // Start elimination
+      typename FactorType::InnerIterator ki_it(m_lu, minrow);
+      while (ki_it && ki_it.index() < minrow) ++ki_it;
+      eigen_internal_assert(ki_it && ki_it.col()==minrow);
+      Scalar fact = u(jj) / ki_it.value();
+
+      // drop too small elements
+      if(abs(fact) <= m_droptol)
+      {
+        jj++;
+        continue;
+      }
+
+      // linear combination of the current row ii and the row minrow
+      ++ki_it;
+      for (; ki_it; ++ki_it)
+      {
+        Scalar prod = fact * ki_it.value();
+        Index j     = ki_it.index();
+        Index jpos  = jr(j);
+        if (jpos == -1) // fill-in element
+        {
+          Index newpos;
+          if (j >= ii) // dealing with the upper part
+          {
+            newpos = ii + sizeu;
+            sizeu++;
+            eigen_internal_assert(sizeu<=n);
+          }
+          else // dealing with the lower part
+          {
+            newpos = sizel;
+            sizel++;
+            eigen_internal_assert(sizel<=ii);
+          }
+          ju(newpos) = convert_index<StorageIndex>(j);
+          u(newpos) = -prod;
+          jr(j) = convert_index<StorageIndex>(newpos);
+        }
+        else
+          u(jpos) -= prod;
+      }
+      // store the pivot element
+      u(len)  = fact;
+      ju(len) = convert_index<StorageIndex>(minrow);
+      ++len;
+
+      jj++;
+    } // end of the elimination on the row ii
+
+    // reset the upper part of the pointer jr to zero
+    for(Index k = 0; k <sizeu; k++) jr(ju(ii+k)) = -1;
+
+    // 4 - partially sort and insert the elements in the m_lu matrix
+
+    // sort the L-part of the row
+    sizel = len;
+    len = (std::min)(sizel, nnzL);
+    typename Vector::SegmentReturnType ul(u.segment(0, sizel));
+    typename VectorI::SegmentReturnType jul(ju.segment(0, sizel));
+    internal::QuickSplit(ul, jul, len);
+
+    // store the largest m_fill elements of the L part
+    m_lu.startVec(ii);
+    for(Index k = 0; k < len; k++)
+      m_lu.insertBackByOuterInnerUnordered(ii,ju(k)) = u(k);
+
+    // store the diagonal element
+    // apply a shifting rule to avoid zero pivots (we are doing an incomplete factorization)
+    if (u(ii) == Scalar(0))
+      u(ii) = sqrt(m_droptol) * rownorm;
+    m_lu.insertBackByOuterInnerUnordered(ii, ii) = u(ii);
+
+    // sort the U-part of the row
+    // apply the dropping rule first
+    len = 0;
+    for(Index k = 1; k < sizeu; k++)
+    {
+      if(abs(u(ii+k)) > m_droptol * rownorm )
+      {
+        ++len;
+        u(ii + len)  = u(ii + k);
+        ju(ii + len) = ju(ii + k);
+      }
+    }
+    sizeu = len + 1; // +1 to take into account the diagonal element
+    len = (std::min)(sizeu, nnzU);
+    typename Vector::SegmentReturnType uu(u.segment(ii+1, sizeu-1));
+    typename VectorI::SegmentReturnType juu(ju.segment(ii+1, sizeu-1));
+    internal::QuickSplit(uu, juu, len);
+
+    // store the largest elements of the U part
+    for(Index k = ii + 1; k < ii + len; k++)
+      m_lu.insertBackByOuterInnerUnordered(ii,ju(k)) = u(k);
+  }
+  m_lu.finalize();
+  m_lu.makeCompressed();
+
+  m_factorizationIsOk = true;
+  m_info = Success;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_INCOMPLETE_LUT_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/IterativeLinearSolvers/IterativeSolverBase.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/IterativeLinearSolvers/IterativeSolverBase.h
new file mode 100644
index 00000000..7c2326eb
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/IterativeLinearSolvers/IterativeSolverBase.h
@@ -0,0 +1,394 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ITERATIVE_SOLVER_BASE_H
+#define EIGEN_ITERATIVE_SOLVER_BASE_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename MatrixType>
+struct is_ref_compatible_impl
+{
+private:
+  template <typename T0>
+  struct any_conversion
+  {
+    template <typename T> any_conversion(const volatile T&);
+    template <typename T> any_conversion(T&);
+  };
+  struct yes {int a[1];};
+  struct no  {int a[2];};
+
+  template<typename T>
+  static yes test(const Ref<const T>&, int);
+  template<typename T>
+  static no  test(any_conversion<T>, ...);
+
+public:
+  static MatrixType ms_from;
+  enum { value = sizeof(test<MatrixType>(ms_from, 0))==sizeof(yes) };
+};
+
+template<typename MatrixType>
+struct is_ref_compatible
+{
+  enum { value = is_ref_compatible_impl<typename remove_all<MatrixType>::type>::value };
+};
+
+template<typename MatrixType, bool MatrixFree = !internal::is_ref_compatible<MatrixType>::value>
+class generic_matrix_wrapper;
+
+// We have an explicit matrix at hand, compatible with Ref<>
+template<typename MatrixType>
+class generic_matrix_wrapper<MatrixType,false>
+{
+public:
+  typedef Ref<const MatrixType> ActualMatrixType;
+  template<int UpLo> struct ConstSelfAdjointViewReturnType {
+    typedef typename ActualMatrixType::template ConstSelfAdjointViewReturnType<UpLo>::Type Type;
+  };
+
+  enum {
+    MatrixFree = false
+  };
+
+  generic_matrix_wrapper()
+    : m_dummy(0,0), m_matrix(m_dummy)
+  {}
+
+  template<typename InputType>
+  generic_matrix_wrapper(const InputType &mat)
+    : m_matrix(mat)
+  {}
+
+  const ActualMatrixType& matrix() const
+  {
+    return m_matrix;
+  }
+
+  template<typename MatrixDerived>
+  void grab(const EigenBase<MatrixDerived> &mat)
+  {
+    m_matrix.~Ref<const MatrixType>();
+    ::new (&m_matrix) Ref<const MatrixType>(mat.derived());
+  }
+
+  void grab(const Ref<const MatrixType> &mat)
+  {
+    if(&(mat.derived()) != &m_matrix)
+    {
+      m_matrix.~Ref<const MatrixType>();
+      ::new (&m_matrix) Ref<const MatrixType>(mat);
+    }
+  }
+
+protected:
+  MatrixType m_dummy; // used to default initialize the Ref<> object
+  ActualMatrixType m_matrix;
+};
+
+// MatrixType is not compatible with Ref<> -> matrix-free wrapper
+template<typename MatrixType>
+class generic_matrix_wrapper<MatrixType,true>
+{
+public:
+  typedef MatrixType ActualMatrixType;
+  template<int UpLo> struct ConstSelfAdjointViewReturnType
+  {
+    typedef ActualMatrixType Type;
+  };
+
+  enum {
+    MatrixFree = true
+  };
+
+  generic_matrix_wrapper()
+    : mp_matrix(0)
+  {}
+
+  generic_matrix_wrapper(const MatrixType &mat)
+    : mp_matrix(&mat)
+  {}
+
+  const ActualMatrixType& matrix() const
+  {
+    return *mp_matrix;
+  }
+
+  void grab(const MatrixType &mat)
+  {
+    mp_matrix = &mat;
+  }
+
+protected:
+  const ActualMatrixType *mp_matrix;
+};
+
+}
+
+/** \ingroup IterativeLinearSolvers_Module
+  * \brief Base class for linear iterative solvers
+  *
+  * \sa class SimplicialCholesky, DiagonalPreconditioner, IdentityPreconditioner
+  */
+template< typename Derived>
+class IterativeSolverBase : public SparseSolverBase<Derived>
+{
+protected:
+  typedef SparseSolverBase<Derived> Base;
+  using Base::m_isInitialized;
+  
+public:
+  typedef typename internal::traits<Derived>::MatrixType MatrixType;
+  typedef typename internal::traits<Derived>::Preconditioner Preconditioner;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::StorageIndex StorageIndex;
+  typedef typename MatrixType::RealScalar RealScalar;
+
+  enum {
+    ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+  };
+
+public:
+
+  using Base::derived;
+
+  /** Default constructor. */
+  IterativeSolverBase()
+  {
+    init();
+  }
+
+  /** Initialize the solver with matrix \a A for further \c Ax=b solving.
+    * 
+    * This constructor is a shortcut for the default constructor followed
+    * by a call to compute().
+    * 
+    * \warning this class stores a reference to the matrix A as well as some
+    * precomputed values that depend on it. Therefore, if \a A is changed
+    * this class becomes invalid. Call compute() to update it with the new
+    * matrix A, or modify a copy of A.
+    */
+  template<typename MatrixDerived>
+  explicit IterativeSolverBase(const EigenBase<MatrixDerived>& A)
+    : m_matrixWrapper(A.derived())
+  {
+    init();
+    compute(matrix());
+  }
+
+  ~IterativeSolverBase() {}
+  
+  /** Initializes the iterative solver for the sparsity pattern of the matrix \a A for further solving \c Ax=b problems.
+    *
+    * Currently, this function mostly calls analyzePattern on the preconditioner. In the future
+    * we might, for instance, implement column reordering for faster matrix vector products.
+    */
+  template<typename MatrixDerived>
+  Derived& analyzePattern(const EigenBase<MatrixDerived>& A)
+  {
+    grab(A.derived());
+    m_preconditioner.analyzePattern(matrix());
+    m_isInitialized = true;
+    m_analysisIsOk = true;
+    m_info = m_preconditioner.info();
+    return derived();
+  }
+  
+  /** Initializes the iterative solver with the numerical values of the matrix \a A for further solving \c Ax=b problems.
+    *
+    * Currently, this function mostly calls factorize on the preconditioner.
+    *
+    * \warning this class stores a reference to the matrix A as well as some
+    * precomputed values that depend on it. Therefore, if \a A is changed
+    * this class becomes invalid. Call compute() to update it with the new
+    * matrix A, or modify a copy of A.
+    */
+  template<typename MatrixDerived>
+  Derived& factorize(const EigenBase<MatrixDerived>& A)
+  {
+    eigen_assert(m_analysisIsOk && "You must first call analyzePattern()"); 
+    grab(A.derived());
+    m_preconditioner.factorize(matrix());
+    m_factorizationIsOk = true;
+    m_info = m_preconditioner.info();
+    return derived();
+  }
+
+  /** Initializes the iterative solver with the matrix \a A for further solving \c Ax=b problems.
+    *
+    * Currently, this function mostly initializes/computes the preconditioner. In the future
+    * we might, for instance, implement column reordering for faster matrix vector products.
+    *
+    * \warning this class stores a reference to the matrix A as well as some
+    * precomputed values that depend on it. Therefore, if \a A is changed
+    * this class becomes invalid. Call compute() to update it with the new
+    * matrix A, or modify a copy of A.
+    */
+  template<typename MatrixDerived>
+  Derived& compute(const EigenBase<MatrixDerived>& A)
+  {
+    grab(A.derived());
+    m_preconditioner.compute(matrix());
+    m_isInitialized = true;
+    m_analysisIsOk = true;
+    m_factorizationIsOk = true;
+    m_info = m_preconditioner.info();
+    return derived();
+  }
+
+  /** \internal */
+  Index rows() const { return matrix().rows(); }
+
+  /** \internal */
+  Index cols() const { return matrix().cols(); }
+
+  /** \returns the tolerance threshold used by the stopping criteria.
+    * \sa setTolerance()
+    */
+  RealScalar tolerance() const { return m_tolerance; }
+  
+  /** Sets the tolerance threshold used by the stopping criteria.
+    *
+    * This value is used as an upper bound to the relative residual error: |Ax-b|/|b|.
+    * The default value is the machine precision given by NumTraits<Scalar>::epsilon()
+    */
+  Derived& setTolerance(const RealScalar& tolerance)
+  {
+    m_tolerance = tolerance;
+    return derived();
+  }
+
+  /** \returns a read-write reference to the preconditioner for custom configuration. */
+  Preconditioner& preconditioner() { return m_preconditioner; }
+  
+  /** \returns a read-only reference to the preconditioner. */
+  const Preconditioner& preconditioner() const { return m_preconditioner; }
+
+  /** \returns the max number of iterations.
+    * It is either the value setted by setMaxIterations or, by default,
+    * twice the number of columns of the matrix.
+    */
+  Index maxIterations() const
+  {
+    return (m_maxIterations<0) ? 2*matrix().cols() : m_maxIterations;
+  }
+  
+  /** Sets the max number of iterations.
+    * Default is twice the number of columns of the matrix.
+    */
+  Derived& setMaxIterations(Index maxIters)
+  {
+    m_maxIterations = maxIters;
+    return derived();
+  }
+
+  /** \returns the number of iterations performed during the last solve */
+  Index iterations() const
+  {
+    eigen_assert(m_isInitialized && "ConjugateGradient is not initialized.");
+    return m_iterations;
+  }
+
+  /** \returns the tolerance error reached during the last solve.
+    * It is a close approximation of the true relative residual error |Ax-b|/|b|.
+    */
+  RealScalar error() const
+  {
+    eigen_assert(m_isInitialized && "ConjugateGradient is not initialized.");
+    return m_error;
+  }
+
+  /** \returns the solution x of \f$ A x = b \f$ using the current decomposition of A
+    * and \a x0 as an initial solution.
+    *
+    * \sa solve(), compute()
+    */
+  template<typename Rhs,typename Guess>
+  inline const SolveWithGuess<Derived, Rhs, Guess>
+  solveWithGuess(const MatrixBase<Rhs>& b, const Guess& x0) const
+  {
+    eigen_assert(m_isInitialized && "Solver is not initialized.");
+    eigen_assert(derived().rows()==b.rows() && "solve(): invalid number of rows of the right hand side matrix b");
+    return SolveWithGuess<Derived, Rhs, Guess>(derived(), b.derived(), x0);
+  }
+
+  /** \returns Success if the iterations converged, and NoConvergence otherwise. */
+  ComputationInfo info() const
+  {
+    eigen_assert(m_isInitialized && "IterativeSolverBase is not initialized.");
+    return m_info;
+  }
+  
+  /** \internal */
+  template<typename Rhs, typename DestDerived>
+  void _solve_impl(const Rhs& b, SparseMatrixBase<DestDerived> &aDest) const
+  {
+    eigen_assert(rows()==b.rows());
+    
+    Index rhsCols = b.cols();
+    Index size = b.rows();
+    DestDerived& dest(aDest.derived());
+    typedef typename DestDerived::Scalar DestScalar;
+    Eigen::Matrix<DestScalar,Dynamic,1> tb(size);
+    Eigen::Matrix<DestScalar,Dynamic,1> tx(cols());
+    // We do not directly fill dest because sparse expressions have to be free of aliasing issue.
+    // For non square least-square problems, b and dest might not have the same size whereas they might alias each-other.
+    typename DestDerived::PlainObject tmp(cols(),rhsCols);
+    for(Index k=0; k<rhsCols; ++k)
+    {
+      tb = b.col(k);
+      tx = derived().solve(tb);
+      tmp.col(k) = tx.sparseView(0);
+    }
+    dest.swap(tmp);
+  }
+
+protected:
+  void init()
+  {
+    m_isInitialized = false;
+    m_analysisIsOk = false;
+    m_factorizationIsOk = false;
+    m_maxIterations = -1;
+    m_tolerance = NumTraits<Scalar>::epsilon();
+  }
+
+  typedef internal::generic_matrix_wrapper<MatrixType> MatrixWrapper;
+  typedef typename MatrixWrapper::ActualMatrixType ActualMatrixType;
+
+  const ActualMatrixType& matrix() const
+  {
+    return m_matrixWrapper.matrix();
+  }
+  
+  template<typename InputType>
+  void grab(const InputType &A)
+  {
+    m_matrixWrapper.grab(A);
+  }
+  
+  MatrixWrapper m_matrixWrapper;
+  Preconditioner m_preconditioner;
+
+  Index m_maxIterations;
+  RealScalar m_tolerance;
+  
+  mutable RealScalar m_error;
+  mutable Index m_iterations;
+  mutable ComputationInfo m_info;
+  mutable bool m_analysisIsOk, m_factorizationIsOk;
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_ITERATIVE_SOLVER_BASE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/IterativeLinearSolvers/LeastSquareConjugateGradient.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/IterativeLinearSolvers/LeastSquareConjugateGradient.h
new file mode 100644
index 00000000..0aea0e09
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/IterativeLinearSolvers/LeastSquareConjugateGradient.h
@@ -0,0 +1,216 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_LEAST_SQUARE_CONJUGATE_GRADIENT_H
+#define EIGEN_LEAST_SQUARE_CONJUGATE_GRADIENT_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/** \internal Low-level conjugate gradient algorithm for least-square problems
+  * \param mat The matrix A
+  * \param rhs The right hand side vector b
+  * \param x On input and initial solution, on output the computed solution.
+  * \param precond A preconditioner being able to efficiently solve for an
+  *                approximation of A'Ax=b (regardless of b)
+  * \param iters On input the max number of iteration, on output the number of performed iterations.
+  * \param tol_error On input the tolerance error, on output an estimation of the relative error.
+  */
+template<typename MatrixType, typename Rhs, typename Dest, typename Preconditioner>
+EIGEN_DONT_INLINE
+void least_square_conjugate_gradient(const MatrixType& mat, const Rhs& rhs, Dest& x,
+                                     const Preconditioner& precond, Index& iters,
+                                     typename Dest::RealScalar& tol_error)
+{
+  using std::sqrt;
+  using std::abs;
+  typedef typename Dest::RealScalar RealScalar;
+  typedef typename Dest::Scalar Scalar;
+  typedef Matrix<Scalar,Dynamic,1> VectorType;
+  
+  RealScalar tol = tol_error;
+  Index maxIters = iters;
+  
+  Index m = mat.rows(), n = mat.cols();
+
+  VectorType residual        = rhs - mat * x;
+  VectorType normal_residual = mat.adjoint() * residual;
+
+  RealScalar rhsNorm2 = (mat.adjoint()*rhs).squaredNorm();
+  if(rhsNorm2 == 0) 
+  {
+    x.setZero();
+    iters = 0;
+    tol_error = 0;
+    return;
+  }
+  RealScalar threshold = tol*tol*rhsNorm2;
+  RealScalar residualNorm2 = normal_residual.squaredNorm();
+  if (residualNorm2 < threshold)
+  {
+    iters = 0;
+    tol_error = sqrt(residualNorm2 / rhsNorm2);
+    return;
+  }
+  
+  VectorType p(n);
+  p = precond.solve(normal_residual);                         // initial search direction
+
+  VectorType z(n), tmp(m);
+  RealScalar absNew = numext::real(normal_residual.dot(p));  // the square of the absolute value of r scaled by invM
+  Index i = 0;
+  while(i < maxIters)
+  {
+    tmp.noalias() = mat * p;
+
+    Scalar alpha = absNew / tmp.squaredNorm();      // the amount we travel on dir
+    x += alpha * p;                                 // update solution
+    residual -= alpha * tmp;                        // update residual
+    normal_residual = mat.adjoint() * residual;     // update residual of the normal equation
+    
+    residualNorm2 = normal_residual.squaredNorm();
+    if(residualNorm2 < threshold)
+      break;
+    
+    z = precond.solve(normal_residual);             // approximately solve for "A'A z = normal_residual"
+
+    RealScalar absOld = absNew;
+    absNew = numext::real(normal_residual.dot(z));  // update the absolute value of r
+    RealScalar beta = absNew / absOld;              // calculate the Gram-Schmidt value used to create the new search direction
+    p = z + beta * p;                               // update search direction
+    i++;
+  }
+  tol_error = sqrt(residualNorm2 / rhsNorm2);
+  iters = i;
+}
+
+}
+
+template< typename _MatrixType,
+          typename _Preconditioner = LeastSquareDiagonalPreconditioner<typename _MatrixType::Scalar> >
+class LeastSquaresConjugateGradient;
+
+namespace internal {
+
+template< typename _MatrixType, typename _Preconditioner>
+struct traits<LeastSquaresConjugateGradient<_MatrixType,_Preconditioner> >
+{
+  typedef _MatrixType MatrixType;
+  typedef _Preconditioner Preconditioner;
+};
+
+}
+
+/** \ingroup IterativeLinearSolvers_Module
+  * \brief A conjugate gradient solver for sparse (or dense) least-square problems
+  *
+  * This class allows to solve for A x = b linear problems using an iterative conjugate gradient algorithm.
+  * The matrix A can be non symmetric and rectangular, but the matrix A' A should be positive-definite to guaranty stability.
+  * Otherwise, the SparseLU or SparseQR classes might be preferable.
+  * The matrix A and the vectors x and b can be either dense or sparse.
+  *
+  * \tparam _MatrixType the type of the matrix A, can be a dense or a sparse matrix.
+  * \tparam _Preconditioner the type of the preconditioner. Default is LeastSquareDiagonalPreconditioner
+  *
+  * \implsparsesolverconcept
+  * 
+  * The maximal number of iterations and tolerance value can be controlled via the setMaxIterations()
+  * and setTolerance() methods. The defaults are the size of the problem for the maximal number of iterations
+  * and NumTraits<Scalar>::epsilon() for the tolerance.
+  * 
+  * This class can be used as the direct solver classes. Here is a typical usage example:
+    \code
+    int m=1000000, n = 10000;
+    VectorXd x(n), b(m);
+    SparseMatrix<double> A(m,n);
+    // fill A and b
+    LeastSquaresConjugateGradient<SparseMatrix<double> > lscg;
+    lscg.compute(A);
+    x = lscg.solve(b);
+    std::cout << "#iterations:     " << lscg.iterations() << std::endl;
+    std::cout << "estimated error: " << lscg.error()      << std::endl;
+    // update b, and solve again
+    x = lscg.solve(b);
+    \endcode
+  * 
+  * By default the iterations start with x=0 as an initial guess of the solution.
+  * One can control the start using the solveWithGuess() method.
+  * 
+  * \sa class ConjugateGradient, SparseLU, SparseQR
+  */
+template< typename _MatrixType, typename _Preconditioner>
+class LeastSquaresConjugateGradient : public IterativeSolverBase<LeastSquaresConjugateGradient<_MatrixType,_Preconditioner> >
+{
+  typedef IterativeSolverBase<LeastSquaresConjugateGradient> Base;
+  using Base::matrix;
+  using Base::m_error;
+  using Base::m_iterations;
+  using Base::m_info;
+  using Base::m_isInitialized;
+public:
+  typedef _MatrixType MatrixType;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef _Preconditioner Preconditioner;
+
+public:
+
+  /** Default constructor. */
+  LeastSquaresConjugateGradient() : Base() {}
+
+  /** Initialize the solver with matrix \a A for further \c Ax=b solving.
+    * 
+    * This constructor is a shortcut for the default constructor followed
+    * by a call to compute().
+    * 
+    * \warning this class stores a reference to the matrix A as well as some
+    * precomputed values that depend on it. Therefore, if \a A is changed
+    * this class becomes invalid. Call compute() to update it with the new
+    * matrix A, or modify a copy of A.
+    */
+  template<typename MatrixDerived>
+  explicit LeastSquaresConjugateGradient(const EigenBase<MatrixDerived>& A) : Base(A.derived()) {}
+
+  ~LeastSquaresConjugateGradient() {}
+
+  /** \internal */
+  template<typename Rhs,typename Dest>
+  void _solve_with_guess_impl(const Rhs& b, Dest& x) const
+  {
+    m_iterations = Base::maxIterations();
+    m_error = Base::m_tolerance;
+
+    for(Index j=0; j<b.cols(); ++j)
+    {
+      m_iterations = Base::maxIterations();
+      m_error = Base::m_tolerance;
+
+      typename Dest::ColXpr xj(x,j);
+      internal::least_square_conjugate_gradient(matrix(), b.col(j), xj, Base::m_preconditioner, m_iterations, m_error);
+    }
+
+    m_isInitialized = true;
+    m_info = m_error <= Base::m_tolerance ? Success : NoConvergence;
+  }
+  
+  /** \internal */
+  using Base::_solve_impl;
+  template<typename Rhs,typename Dest>
+  void _solve_impl(const MatrixBase<Rhs>& b, Dest& x) const
+  {
+    x.setZero();
+    _solve_with_guess_impl(b.derived(),x);
+  }
+
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_LEAST_SQUARE_CONJUGATE_GRADIENT_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/IterativeLinearSolvers/SolveWithGuess.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/IterativeLinearSolvers/SolveWithGuess.h
new file mode 100644
index 00000000..0ace4517
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/IterativeLinearSolvers/SolveWithGuess.h
@@ -0,0 +1,115 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SOLVEWITHGUESS_H
+#define EIGEN_SOLVEWITHGUESS_H
+
+namespace Eigen {
+
+template<typename Decomposition, typename RhsType, typename GuessType> class SolveWithGuess;
+  
+/** \class SolveWithGuess
+  * \ingroup IterativeLinearSolvers_Module
+  *
+  * \brief Pseudo expression representing a solving operation
+  *
+  * \tparam Decomposition the type of the matrix or decomposion object
+  * \tparam Rhstype the type of the right-hand side
+  *
+  * This class represents an expression of A.solve(B)
+  * and most of the time this is the only way it is used.
+  *
+  */
+namespace internal {
+
+
+template<typename Decomposition, typename RhsType, typename GuessType>
+struct traits<SolveWithGuess<Decomposition, RhsType, GuessType> >
+  : traits<Solve<Decomposition,RhsType> >
+{};
+
+}
+
+
+template<typename Decomposition, typename RhsType, typename GuessType>
+class SolveWithGuess : public internal::generic_xpr_base<SolveWithGuess<Decomposition,RhsType,GuessType>, MatrixXpr, typename internal::traits<RhsType>::StorageKind>::type
+{
+public:
+  typedef typename internal::traits<SolveWithGuess>::Scalar Scalar;
+  typedef typename internal::traits<SolveWithGuess>::PlainObject PlainObject;
+  typedef typename internal::generic_xpr_base<SolveWithGuess<Decomposition,RhsType,GuessType>, MatrixXpr, typename internal::traits<RhsType>::StorageKind>::type Base;
+  typedef typename internal::ref_selector<SolveWithGuess>::type Nested;
+  
+  SolveWithGuess(const Decomposition &dec, const RhsType &rhs, const GuessType &guess)
+    : m_dec(dec), m_rhs(rhs), m_guess(guess)
+  {}
+  
+  EIGEN_DEVICE_FUNC Index rows() const { return m_dec.cols(); }
+  EIGEN_DEVICE_FUNC Index cols() const { return m_rhs.cols(); }
+
+  EIGEN_DEVICE_FUNC const Decomposition& dec()   const { return m_dec; }
+  EIGEN_DEVICE_FUNC const RhsType&       rhs()   const { return m_rhs; }
+  EIGEN_DEVICE_FUNC const GuessType&     guess() const { return m_guess; }
+
+protected:
+  const Decomposition &m_dec;
+  const RhsType       &m_rhs;
+  const GuessType     &m_guess;
+  
+private:
+  Scalar coeff(Index row, Index col) const;
+  Scalar coeff(Index i) const;
+};
+
+namespace internal {
+
+// Evaluator of SolveWithGuess -> eval into a temporary
+template<typename Decomposition, typename RhsType, typename GuessType>
+struct evaluator<SolveWithGuess<Decomposition,RhsType, GuessType> >
+  : public evaluator<typename SolveWithGuess<Decomposition,RhsType,GuessType>::PlainObject>
+{
+  typedef SolveWithGuess<Decomposition,RhsType,GuessType> SolveType;
+  typedef typename SolveType::PlainObject PlainObject;
+  typedef evaluator<PlainObject> Base;
+
+  evaluator(const SolveType& solve)
+    : m_result(solve.rows(), solve.cols())
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+    m_result = solve.guess();
+    solve.dec()._solve_with_guess_impl(solve.rhs(), m_result);
+  }
+  
+protected:  
+  PlainObject m_result;
+};
+
+// Specialization for "dst = dec.solveWithGuess(rhs)"
+// NOTE we need to specialize it for Dense2Dense to avoid ambiguous specialization error and a Sparse2Sparse specialization must exist somewhere
+template<typename DstXprType, typename DecType, typename RhsType, typename GuessType, typename Scalar>
+struct Assignment<DstXprType, SolveWithGuess<DecType,RhsType,GuessType>, internal::assign_op<Scalar,Scalar>, Dense2Dense>
+{
+  typedef SolveWithGuess<DecType,RhsType,GuessType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    dst = src.guess();
+    src.dec()._solve_with_guess_impl(src.rhs(), dst/*, src.guess()*/);
+  }
+};
+
+} // end namepsace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SOLVEWITHGUESS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Jacobi/Jacobi.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Jacobi/Jacobi.h
new file mode 100644
index 00000000..af1228cb
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/Jacobi/Jacobi.h
@@ -0,0 +1,474 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_JACOBI_H
+#define EIGEN_JACOBI_H
+
+namespace Eigen { 
+
+/** \ingroup Jacobi_Module
+  * \jacobi_module
+  * \class JacobiRotation
+  * \brief Rotation given by a cosine-sine pair.
+  *
+  * This class represents a Jacobi or Givens rotation.
+  * This is a 2D rotation in the plane \c J of angle \f$ \theta \f$ defined by
+  * its cosine \c c and sine \c s as follow:
+  * \f$ J = \left ( \begin{array}{cc} c & \overline s \\ -s  & \overline c \end{array} \right ) \f$
+  *
+  * You can apply the respective counter-clockwise rotation to a column vector \c v by
+  * applying its adjoint on the left: \f$ v = J^* v \f$ that translates to the following Eigen code:
+  * \code
+  * v.applyOnTheLeft(J.adjoint());
+  * \endcode
+  *
+  * \sa MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight()
+  */
+template<typename Scalar> class JacobiRotation
+{
+  public:
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    /** Default constructor without any initialization. */
+    EIGEN_DEVICE_FUNC
+    JacobiRotation() {}
+
+    /** Construct a planar rotation from a cosine-sine pair (\a c, \c s). */
+    EIGEN_DEVICE_FUNC
+    JacobiRotation(const Scalar& c, const Scalar& s) : m_c(c), m_s(s) {}
+
+    EIGEN_DEVICE_FUNC Scalar& c() { return m_c; }
+    EIGEN_DEVICE_FUNC Scalar c() const { return m_c; }
+    EIGEN_DEVICE_FUNC Scalar& s() { return m_s; }
+    EIGEN_DEVICE_FUNC Scalar s() const { return m_s; }
+
+    /** Concatenates two planar rotation */
+    EIGEN_DEVICE_FUNC
+    JacobiRotation operator*(const JacobiRotation& other)
+    {
+      using numext::conj;
+      return JacobiRotation(m_c * other.m_c - conj(m_s) * other.m_s,
+                            conj(m_c * conj(other.m_s) + conj(m_s) * conj(other.m_c)));
+    }
+
+    /** Returns the transposed transformation */
+    EIGEN_DEVICE_FUNC
+    JacobiRotation transpose() const { using numext::conj; return JacobiRotation(m_c, -conj(m_s)); }
+
+    /** Returns the adjoint transformation */
+    EIGEN_DEVICE_FUNC
+    JacobiRotation adjoint() const { using numext::conj; return JacobiRotation(conj(m_c), -m_s); }
+
+    template<typename Derived>
+    EIGEN_DEVICE_FUNC
+    bool makeJacobi(const MatrixBase<Derived>&, Index p, Index q);
+    EIGEN_DEVICE_FUNC
+    bool makeJacobi(const RealScalar& x, const Scalar& y, const RealScalar& z);
+
+    EIGEN_DEVICE_FUNC
+    void makeGivens(const Scalar& p, const Scalar& q, Scalar* z=0);
+
+  protected:
+    EIGEN_DEVICE_FUNC
+    void makeGivens(const Scalar& p, const Scalar& q, Scalar* z, internal::true_type);
+    EIGEN_DEVICE_FUNC
+    void makeGivens(const Scalar& p, const Scalar& q, Scalar* z, internal::false_type);
+
+    Scalar m_c, m_s;
+};
+
+/** Makes \c *this as a Jacobi rotation \a J such that applying \a J on both the right and left sides of the selfadjoint 2x2 matrix
+  * \f$ B = \left ( \begin{array}{cc} x & y \\ \overline y & z \end{array} \right )\f$ yields a diagonal matrix \f$ A = J^* B J \f$
+  *
+  * \sa MatrixBase::makeJacobi(const MatrixBase<Derived>&, Index, Index), MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight()
+  */
+template<typename Scalar>
+bool JacobiRotation<Scalar>::makeJacobi(const RealScalar& x, const Scalar& y, const RealScalar& z)
+{
+  using std::sqrt;
+  using std::abs;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  RealScalar deno = RealScalar(2)*abs(y);
+  if(deno < (std::numeric_limits<RealScalar>::min)())
+  {
+    m_c = Scalar(1);
+    m_s = Scalar(0);
+    return false;
+  }
+  else
+  {
+    RealScalar tau = (x-z)/deno;
+    RealScalar w = sqrt(numext::abs2(tau) + RealScalar(1));
+    RealScalar t;
+    if(tau>RealScalar(0))
+    {
+      t = RealScalar(1) / (tau + w);
+    }
+    else
+    {
+      t = RealScalar(1) / (tau - w);
+    }
+    RealScalar sign_t = t > RealScalar(0) ? RealScalar(1) : RealScalar(-1);
+    RealScalar n = RealScalar(1) / sqrt(numext::abs2(t)+RealScalar(1));
+    m_s = - sign_t * (numext::conj(y) / abs(y)) * abs(t) * n;
+    m_c = n;
+    return true;
+  }
+}
+
+/** Makes \c *this as a Jacobi rotation \c J such that applying \a J on both the right and left sides of the 2x2 selfadjoint matrix
+  * \f$ B = \left ( \begin{array}{cc} \text{this}_{pp} & \text{this}_{pq} \\ (\text{this}_{pq})^* & \text{this}_{qq} \end{array} \right )\f$ yields
+  * a diagonal matrix \f$ A = J^* B J \f$
+  *
+  * Example: \include Jacobi_makeJacobi.cpp
+  * Output: \verbinclude Jacobi_makeJacobi.out
+  *
+  * \sa JacobiRotation::makeJacobi(RealScalar, Scalar, RealScalar), MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight()
+  */
+template<typename Scalar>
+template<typename Derived>
+inline bool JacobiRotation<Scalar>::makeJacobi(const MatrixBase<Derived>& m, Index p, Index q)
+{
+  return makeJacobi(numext::real(m.coeff(p,p)), m.coeff(p,q), numext::real(m.coeff(q,q)));
+}
+
+/** Makes \c *this as a Givens rotation \c G such that applying \f$ G^* \f$ to the left of the vector
+  * \f$ V = \left ( \begin{array}{c} p \\ q \end{array} \right )\f$ yields:
+  * \f$ G^* V = \left ( \begin{array}{c} r \\ 0 \end{array} \right )\f$.
+  *
+  * The value of \a z is returned if \a z is not null (the default is null).
+  * Also note that G is built such that the cosine is always real.
+  *
+  * Example: \include Jacobi_makeGivens.cpp
+  * Output: \verbinclude Jacobi_makeGivens.out
+  *
+  * This function implements the continuous Givens rotation generation algorithm
+  * found in Anderson (2000), Discontinuous Plane Rotations and the Symmetric Eigenvalue Problem.
+  * LAPACK Working Note 150, University of Tennessee, UT-CS-00-454, December 4, 2000.
+  *
+  * \sa MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight()
+  */
+template<typename Scalar>
+void JacobiRotation<Scalar>::makeGivens(const Scalar& p, const Scalar& q, Scalar* z)
+{
+  makeGivens(p, q, z, typename internal::conditional<NumTraits<Scalar>::IsComplex, internal::true_type, internal::false_type>::type());
+}
+
+
+// specialization for complexes
+template<typename Scalar>
+void JacobiRotation<Scalar>::makeGivens(const Scalar& p, const Scalar& q, Scalar* r, internal::true_type)
+{
+  using std::sqrt;
+  using std::abs;
+  using numext::conj;
+  
+  if(q==Scalar(0))
+  {
+    m_c = numext::real(p)<0 ? Scalar(-1) : Scalar(1);
+    m_s = 0;
+    if(r) *r = m_c * p;
+  }
+  else if(p==Scalar(0))
+  {
+    m_c = 0;
+    m_s = -q/abs(q);
+    if(r) *r = abs(q);
+  }
+  else
+  {
+    RealScalar p1 = numext::norm1(p);
+    RealScalar q1 = numext::norm1(q);
+    if(p1>=q1)
+    {
+      Scalar ps = p / p1;
+      RealScalar p2 = numext::abs2(ps);
+      Scalar qs = q / p1;
+      RealScalar q2 = numext::abs2(qs);
+
+      RealScalar u = sqrt(RealScalar(1) + q2/p2);
+      if(numext::real(p)<RealScalar(0))
+        u = -u;
+
+      m_c = Scalar(1)/u;
+      m_s = -qs*conj(ps)*(m_c/p2);
+      if(r) *r = p * u;
+    }
+    else
+    {
+      Scalar ps = p / q1;
+      RealScalar p2 = numext::abs2(ps);
+      Scalar qs = q / q1;
+      RealScalar q2 = numext::abs2(qs);
+
+      RealScalar u = q1 * sqrt(p2 + q2);
+      if(numext::real(p)<RealScalar(0))
+        u = -u;
+
+      p1 = abs(p);
+      ps = p/p1;
+      m_c = p1/u;
+      m_s = -conj(ps) * (q/u);
+      if(r) *r = ps * u;
+    }
+  }
+}
+
+// specialization for reals
+template<typename Scalar>
+void JacobiRotation<Scalar>::makeGivens(const Scalar& p, const Scalar& q, Scalar* r, internal::false_type)
+{
+  using std::sqrt;
+  using std::abs;
+  if(q==Scalar(0))
+  {
+    m_c = p<Scalar(0) ? Scalar(-1) : Scalar(1);
+    m_s = Scalar(0);
+    if(r) *r = abs(p);
+  }
+  else if(p==Scalar(0))
+  {
+    m_c = Scalar(0);
+    m_s = q<Scalar(0) ? Scalar(1) : Scalar(-1);
+    if(r) *r = abs(q);
+  }
+  else if(abs(p) > abs(q))
+  {
+    Scalar t = q/p;
+    Scalar u = sqrt(Scalar(1) + numext::abs2(t));
+    if(p<Scalar(0))
+      u = -u;
+    m_c = Scalar(1)/u;
+    m_s = -t * m_c;
+    if(r) *r = p * u;
+  }
+  else
+  {
+    Scalar t = p/q;
+    Scalar u = sqrt(Scalar(1) + numext::abs2(t));
+    if(q<Scalar(0))
+      u = -u;
+    m_s = -Scalar(1)/u;
+    m_c = -t * m_s;
+    if(r) *r = q * u;
+  }
+
+}
+
+/****************************************************************************************
+*   Implementation of MatrixBase methods
+****************************************************************************************/
+
+namespace internal {
+/** \jacobi_module
+  * Applies the clock wise 2D rotation \a j to the set of 2D vectors of cordinates \a x and \a y:
+  * \f$ \left ( \begin{array}{cc} x \\ y \end{array} \right )  =  J \left ( \begin{array}{cc} x \\ y \end{array} \right ) \f$
+  *
+  * \sa MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight()
+  */
+template<typename VectorX, typename VectorY, typename OtherScalar>
+EIGEN_DEVICE_FUNC
+void apply_rotation_in_the_plane(DenseBase<VectorX>& xpr_x, DenseBase<VectorY>& xpr_y, const JacobiRotation<OtherScalar>& j);
+}
+
+/** \jacobi_module
+  * Applies the rotation in the plane \a j to the rows \a p and \a q of \c *this, i.e., it computes B = J * B,
+  * with \f$ B = \left ( \begin{array}{cc} \text{*this.row}(p) \\ \text{*this.row}(q) \end{array} \right ) \f$.
+  *
+  * \sa class JacobiRotation, MatrixBase::applyOnTheRight(), internal::apply_rotation_in_the_plane()
+  */
+template<typename Derived>
+template<typename OtherScalar>
+inline void MatrixBase<Derived>::applyOnTheLeft(Index p, Index q, const JacobiRotation<OtherScalar>& j)
+{
+  RowXpr x(this->row(p));
+  RowXpr y(this->row(q));
+  internal::apply_rotation_in_the_plane(x, y, j);
+}
+
+/** \ingroup Jacobi_Module
+  * Applies the rotation in the plane \a j to the columns \a p and \a q of \c *this, i.e., it computes B = B * J
+  * with \f$ B = \left ( \begin{array}{cc} \text{*this.col}(p) & \text{*this.col}(q) \end{array} \right ) \f$.
+  *
+  * \sa class JacobiRotation, MatrixBase::applyOnTheLeft(), internal::apply_rotation_in_the_plane()
+  */
+template<typename Derived>
+template<typename OtherScalar>
+inline void MatrixBase<Derived>::applyOnTheRight(Index p, Index q, const JacobiRotation<OtherScalar>& j)
+{
+  ColXpr x(this->col(p));
+  ColXpr y(this->col(q));
+  internal::apply_rotation_in_the_plane(x, y, j.transpose());
+}
+
+namespace internal {
+
+template<typename Scalar, typename OtherScalar,
+         int SizeAtCompileTime, int MinAlignment, bool Vectorizable>
+struct apply_rotation_in_the_plane_selector
+{
+  static inline void run(Scalar *x, Index incrx, Scalar *y, Index incry, Index size, OtherScalar c, OtherScalar s)
+  {
+    for(Index i=0; i<size; ++i)
+    {
+      Scalar xi = *x;
+      Scalar yi = *y;
+      *x =  c * xi + numext::conj(s) * yi;
+      *y = -s * xi + numext::conj(c) * yi;
+      x += incrx;
+      y += incry;
+    }
+  }
+};
+
+template<typename Scalar, typename OtherScalar,
+         int SizeAtCompileTime, int MinAlignment>
+struct apply_rotation_in_the_plane_selector<Scalar,OtherScalar,SizeAtCompileTime,MinAlignment,true /* vectorizable */>
+{
+  static inline void run(Scalar *x, Index incrx, Scalar *y, Index incry, Index size, OtherScalar c, OtherScalar s)
+  {
+    enum {
+      PacketSize = packet_traits<Scalar>::size,
+      OtherPacketSize = packet_traits<OtherScalar>::size
+    };
+    typedef typename packet_traits<Scalar>::type Packet;
+    typedef typename packet_traits<OtherScalar>::type OtherPacket;
+
+    /*** dynamic-size vectorized paths ***/
+    if(SizeAtCompileTime == Dynamic && ((incrx==1 && incry==1) || PacketSize == 1))
+    {
+      // both vectors are sequentially stored in memory => vectorization
+      enum { Peeling = 2 };
+
+      Index alignedStart = internal::first_default_aligned(y, size);
+      Index alignedEnd = alignedStart + ((size-alignedStart)/PacketSize)*PacketSize;
+
+      const OtherPacket pc = pset1<OtherPacket>(c);
+      const OtherPacket ps = pset1<OtherPacket>(s);
+      conj_helper<OtherPacket,Packet,NumTraits<OtherScalar>::IsComplex,false> pcj;
+      conj_helper<OtherPacket,Packet,false,false> pm;
+
+      for(Index i=0; i<alignedStart; ++i)
+      {
+        Scalar xi = x[i];
+        Scalar yi = y[i];
+        x[i] =  c * xi + numext::conj(s) * yi;
+        y[i] = -s * xi + numext::conj(c) * yi;
+      }
+
+      Scalar* EIGEN_RESTRICT px = x + alignedStart;
+      Scalar* EIGEN_RESTRICT py = y + alignedStart;
+
+      if(internal::first_default_aligned(x, size)==alignedStart)
+      {
+        for(Index i=alignedStart; i<alignedEnd; i+=PacketSize)
+        {
+          Packet xi = pload<Packet>(px);
+          Packet yi = pload<Packet>(py);
+          pstore(px, padd(pm.pmul(pc,xi),pcj.pmul(ps,yi)));
+          pstore(py, psub(pcj.pmul(pc,yi),pm.pmul(ps,xi)));
+          px += PacketSize;
+          py += PacketSize;
+        }
+      }
+      else
+      {
+        Index peelingEnd = alignedStart + ((size-alignedStart)/(Peeling*PacketSize))*(Peeling*PacketSize);
+        for(Index i=alignedStart; i<peelingEnd; i+=Peeling*PacketSize)
+        {
+          Packet xi   = ploadu<Packet>(px);
+          Packet xi1  = ploadu<Packet>(px+PacketSize);
+          Packet yi   = pload <Packet>(py);
+          Packet yi1  = pload <Packet>(py+PacketSize);
+          pstoreu(px, padd(pm.pmul(pc,xi),pcj.pmul(ps,yi)));
+          pstoreu(px+PacketSize, padd(pm.pmul(pc,xi1),pcj.pmul(ps,yi1)));
+          pstore (py, psub(pcj.pmul(pc,yi),pm.pmul(ps,xi)));
+          pstore (py+PacketSize, psub(pcj.pmul(pc,yi1),pm.pmul(ps,xi1)));
+          px += Peeling*PacketSize;
+          py += Peeling*PacketSize;
+        }
+        if(alignedEnd!=peelingEnd)
+        {
+          Packet xi = ploadu<Packet>(x+peelingEnd);
+          Packet yi = pload <Packet>(y+peelingEnd);
+          pstoreu(x+peelingEnd, padd(pm.pmul(pc,xi),pcj.pmul(ps,yi)));
+          pstore (y+peelingEnd, psub(pcj.pmul(pc,yi),pm.pmul(ps,xi)));
+        }
+      }
+
+      for(Index i=alignedEnd; i<size; ++i)
+      {
+        Scalar xi = x[i];
+        Scalar yi = y[i];
+        x[i] =  c * xi + numext::conj(s) * yi;
+        y[i] = -s * xi + numext::conj(c) * yi;
+      }
+    }
+
+    /*** fixed-size vectorized path ***/
+    else if(SizeAtCompileTime != Dynamic && MinAlignment>0) // FIXME should be compared to the required alignment
+    {
+      const OtherPacket pc = pset1<OtherPacket>(c);
+      const OtherPacket ps = pset1<OtherPacket>(s);
+      conj_helper<OtherPacket,Packet,NumTraits<OtherPacket>::IsComplex,false> pcj;
+      conj_helper<OtherPacket,Packet,false,false> pm;
+      Scalar* EIGEN_RESTRICT px = x;
+      Scalar* EIGEN_RESTRICT py = y;
+      for(Index i=0; i<size; i+=PacketSize)
+      {
+        Packet xi = pload<Packet>(px);
+        Packet yi = pload<Packet>(py);
+        pstore(px, padd(pm.pmul(pc,xi),pcj.pmul(ps,yi)));
+        pstore(py, psub(pcj.pmul(pc,yi),pm.pmul(ps,xi)));
+        px += PacketSize;
+        py += PacketSize;
+      }
+    }
+
+    /*** non-vectorized path ***/
+    else
+    {
+      apply_rotation_in_the_plane_selector<Scalar,OtherScalar,SizeAtCompileTime,MinAlignment,false>::run(x,incrx,y,incry,size,c,s);
+    }
+  }
+};
+
+template<typename VectorX, typename VectorY, typename OtherScalar>
+void /*EIGEN_DONT_INLINE*/ apply_rotation_in_the_plane(DenseBase<VectorX>& xpr_x, DenseBase<VectorY>& xpr_y, const JacobiRotation<OtherScalar>& j)
+{
+  typedef typename VectorX::Scalar Scalar;
+  const bool Vectorizable =    (VectorX::Flags & VectorY::Flags & PacketAccessBit)
+                            && (int(packet_traits<Scalar>::size) == int(packet_traits<OtherScalar>::size));
+
+  eigen_assert(xpr_x.size() == xpr_y.size());
+  Index size = xpr_x.size();
+  Index incrx = xpr_x.derived().innerStride();
+  Index incry = xpr_y.derived().innerStride();
+
+  Scalar* EIGEN_RESTRICT x = &xpr_x.derived().coeffRef(0);
+  Scalar* EIGEN_RESTRICT y = &xpr_y.derived().coeffRef(0);
+  
+  OtherScalar c = j.c();
+  OtherScalar s = j.s();
+  if (c==OtherScalar(1) && s==OtherScalar(0))
+    return;
+
+  apply_rotation_in_the_plane_selector<
+    Scalar,OtherScalar,
+    VectorX::SizeAtCompileTime,
+    EIGEN_PLAIN_ENUM_MIN(evaluator<VectorX>::Alignment, evaluator<VectorY>::Alignment),
+    Vectorizable>::run(x,incrx,y,incry,size,c,s);
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_JACOBI_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/LU/Determinant.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/LU/Determinant.h
new file mode 100644
index 00000000..d6a3c1e5
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/LU/Determinant.h
@@ -0,0 +1,101 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_DETERMINANT_H
+#define EIGEN_DETERMINANT_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename Derived>
+inline const typename Derived::Scalar bruteforce_det3_helper
+(const MatrixBase<Derived>& matrix, int a, int b, int c)
+{
+  return matrix.coeff(0,a)
+         * (matrix.coeff(1,b) * matrix.coeff(2,c) - matrix.coeff(1,c) * matrix.coeff(2,b));
+}
+
+template<typename Derived>
+const typename Derived::Scalar bruteforce_det4_helper
+(const MatrixBase<Derived>& matrix, int j, int k, int m, int n)
+{
+  return (matrix.coeff(j,0) * matrix.coeff(k,1) - matrix.coeff(k,0) * matrix.coeff(j,1))
+       * (matrix.coeff(m,2) * matrix.coeff(n,3) - matrix.coeff(n,2) * matrix.coeff(m,3));
+}
+
+template<typename Derived,
+         int DeterminantType = Derived::RowsAtCompileTime
+> struct determinant_impl
+{
+  static inline typename traits<Derived>::Scalar run(const Derived& m)
+  {
+    if(Derived::ColsAtCompileTime==Dynamic && m.rows()==0)
+      return typename traits<Derived>::Scalar(1);
+    return m.partialPivLu().determinant();
+  }
+};
+
+template<typename Derived> struct determinant_impl<Derived, 1>
+{
+  static inline typename traits<Derived>::Scalar run(const Derived& m)
+  {
+    return m.coeff(0,0);
+  }
+};
+
+template<typename Derived> struct determinant_impl<Derived, 2>
+{
+  static inline typename traits<Derived>::Scalar run(const Derived& m)
+  {
+    return m.coeff(0,0) * m.coeff(1,1) - m.coeff(1,0) * m.coeff(0,1);
+  }
+};
+
+template<typename Derived> struct determinant_impl<Derived, 3>
+{
+  static inline typename traits<Derived>::Scalar run(const Derived& m)
+  {
+    return bruteforce_det3_helper(m,0,1,2)
+          - bruteforce_det3_helper(m,1,0,2)
+          + bruteforce_det3_helper(m,2,0,1);
+  }
+};
+
+template<typename Derived> struct determinant_impl<Derived, 4>
+{
+  static typename traits<Derived>::Scalar run(const Derived& m)
+  {
+    // trick by Martin Costabel to compute 4x4 det with only 30 muls
+    return bruteforce_det4_helper(m,0,1,2,3)
+          - bruteforce_det4_helper(m,0,2,1,3)
+          + bruteforce_det4_helper(m,0,3,1,2)
+          + bruteforce_det4_helper(m,1,2,0,3)
+          - bruteforce_det4_helper(m,1,3,0,2)
+          + bruteforce_det4_helper(m,2,3,0,1);
+  }
+};
+
+} // end namespace internal
+
+/** \lu_module
+  *
+  * \returns the determinant of this matrix
+  */
+template<typename Derived>
+inline typename internal::traits<Derived>::Scalar MatrixBase<Derived>::determinant() const
+{
+  eigen_assert(rows() == cols());
+  typedef typename internal::nested_eval<Derived,Base::RowsAtCompileTime>::type Nested;
+  return internal::determinant_impl<typename internal::remove_all<Nested>::type>::run(derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_DETERMINANT_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/LU/FullPivLU.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/LU/FullPivLU.h
new file mode 100644
index 00000000..ec61086d
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/LU/FullPivLU.h
@@ -0,0 +1,889 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_LU_H
+#define EIGEN_LU_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename _MatrixType> struct traits<FullPivLU<_MatrixType> >
+ : traits<_MatrixType>
+{
+  typedef MatrixXpr XprKind;
+  typedef SolverStorage StorageKind;
+  enum { Flags = 0 };
+};
+
+} // end namespace internal
+
+/** \ingroup LU_Module
+  *
+  * \class FullPivLU
+  *
+  * \brief LU decomposition of a matrix with complete pivoting, and related features
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the LU decomposition
+  *
+  * This class represents a LU decomposition of any matrix, with complete pivoting: the matrix A is
+  * decomposed as \f$ A = P^{-1} L U Q^{-1} \f$ where L is unit-lower-triangular, U is
+  * upper-triangular, and P and Q are permutation matrices. This is a rank-revealing LU
+  * decomposition. The eigenvalues (diagonal coefficients) of U are sorted in such a way that any
+  * zeros are at the end.
+  *
+  * This decomposition provides the generic approach to solving systems of linear equations, computing
+  * the rank, invertibility, inverse, kernel, and determinant.
+  *
+  * This LU decomposition is very stable and well tested with large matrices. However there are use cases where the SVD
+  * decomposition is inherently more stable and/or flexible. For example, when computing the kernel of a matrix,
+  * working with the SVD allows to select the smallest singular values of the matrix, something that
+  * the LU decomposition doesn't see.
+  *
+  * The data of the LU decomposition can be directly accessed through the methods matrixLU(),
+  * permutationP(), permutationQ().
+  *
+  * As an exemple, here is how the original matrix can be retrieved:
+  * \include class_FullPivLU.cpp
+  * Output: \verbinclude class_FullPivLU.out
+  *
+  * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
+  * 
+  * \sa MatrixBase::fullPivLu(), MatrixBase::determinant(), MatrixBase::inverse()
+  */
+template<typename _MatrixType> class FullPivLU
+  : public SolverBase<FullPivLU<_MatrixType> >
+{
+  public:
+    typedef _MatrixType MatrixType;
+    typedef SolverBase<FullPivLU> Base;
+
+    EIGEN_GENERIC_PUBLIC_INTERFACE(FullPivLU)
+    // FIXME StorageIndex defined in EIGEN_GENERIC_PUBLIC_INTERFACE should be int
+    enum {
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    typedef typename internal::plain_row_type<MatrixType, StorageIndex>::type IntRowVectorType;
+    typedef typename internal::plain_col_type<MatrixType, StorageIndex>::type IntColVectorType;
+    typedef PermutationMatrix<ColsAtCompileTime, MaxColsAtCompileTime> PermutationQType;
+    typedef PermutationMatrix<RowsAtCompileTime, MaxRowsAtCompileTime> PermutationPType;
+    typedef typename MatrixType::PlainObject PlainObject;
+
+    /**
+      * \brief Default Constructor.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via LU::compute(const MatrixType&).
+      */
+    FullPivLU();
+
+    /** \brief Default Constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem \a size.
+      * \sa FullPivLU()
+      */
+    FullPivLU(Index rows, Index cols);
+
+    /** Constructor.
+      *
+      * \param matrix the matrix of which to compute the LU decomposition.
+      *               It is required to be nonzero.
+      */
+    template<typename InputType>
+    explicit FullPivLU(const EigenBase<InputType>& matrix);
+
+    /** \brief Constructs a LU factorization from a given matrix
+      *
+      * This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when \c MatrixType is a Eigen::Ref.
+      *
+      * \sa FullPivLU(const EigenBase&)
+      */
+    template<typename InputType>
+    explicit FullPivLU(EigenBase<InputType>& matrix);
+
+    /** Computes the LU decomposition of the given matrix.
+      *
+      * \param matrix the matrix of which to compute the LU decomposition.
+      *               It is required to be nonzero.
+      *
+      * \returns a reference to *this
+      */
+    template<typename InputType>
+    FullPivLU& compute(const EigenBase<InputType>& matrix) {
+      m_lu = matrix.derived();
+      computeInPlace();
+      return *this;
+    }
+
+    /** \returns the LU decomposition matrix: the upper-triangular part is U, the
+      * unit-lower-triangular part is L (at least for square matrices; in the non-square
+      * case, special care is needed, see the documentation of class FullPivLU).
+      *
+      * \sa matrixL(), matrixU()
+      */
+    inline const MatrixType& matrixLU() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return m_lu;
+    }
+
+    /** \returns the number of nonzero pivots in the LU decomposition.
+      * Here nonzero is meant in the exact sense, not in a fuzzy sense.
+      * So that notion isn't really intrinsically interesting, but it is
+      * still useful when implementing algorithms.
+      *
+      * \sa rank()
+      */
+    inline Index nonzeroPivots() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return m_nonzero_pivots;
+    }
+
+    /** \returns the absolute value of the biggest pivot, i.e. the biggest
+      *          diagonal coefficient of U.
+      */
+    RealScalar maxPivot() const { return m_maxpivot; }
+
+    /** \returns the permutation matrix P
+      *
+      * \sa permutationQ()
+      */
+    EIGEN_DEVICE_FUNC inline const PermutationPType& permutationP() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return m_p;
+    }
+
+    /** \returns the permutation matrix Q
+      *
+      * \sa permutationP()
+      */
+    inline const PermutationQType& permutationQ() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return m_q;
+    }
+
+    /** \returns the kernel of the matrix, also called its null-space. The columns of the returned matrix
+      * will form a basis of the kernel.
+      *
+      * \note If the kernel has dimension zero, then the returned matrix is a column-vector filled with zeros.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      *
+      * Example: \include FullPivLU_kernel.cpp
+      * Output: \verbinclude FullPivLU_kernel.out
+      *
+      * \sa image()
+      */
+    inline const internal::kernel_retval<FullPivLU> kernel() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return internal::kernel_retval<FullPivLU>(*this);
+    }
+
+    /** \returns the image of the matrix, also called its column-space. The columns of the returned matrix
+      * will form a basis of the image (column-space).
+      *
+      * \param originalMatrix the original matrix, of which *this is the LU decomposition.
+      *                       The reason why it is needed to pass it here, is that this allows
+      *                       a large optimization, as otherwise this method would need to reconstruct it
+      *                       from the LU decomposition.
+      *
+      * \note If the image has dimension zero, then the returned matrix is a column-vector filled with zeros.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      *
+      * Example: \include FullPivLU_image.cpp
+      * Output: \verbinclude FullPivLU_image.out
+      *
+      * \sa kernel()
+      */
+    inline const internal::image_retval<FullPivLU>
+      image(const MatrixType& originalMatrix) const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return internal::image_retval<FullPivLU>(*this, originalMatrix);
+    }
+
+    /** \return a solution x to the equation Ax=b, where A is the matrix of which
+      * *this is the LU decomposition.
+      *
+      * \param b the right-hand-side of the equation to solve. Can be a vector or a matrix,
+      *          the only requirement in order for the equation to make sense is that
+      *          b.rows()==A.rows(), where A is the matrix of which *this is the LU decomposition.
+      *
+      * \returns a solution.
+      *
+      * \note_about_checking_solutions
+      *
+      * \note_about_arbitrary_choice_of_solution
+      * \note_about_using_kernel_to_study_multiple_solutions
+      *
+      * Example: \include FullPivLU_solve.cpp
+      * Output: \verbinclude FullPivLU_solve.out
+      *
+      * \sa TriangularView::solve(), kernel(), inverse()
+      */
+    // FIXME this is a copy-paste of the base-class member to add the isInitialized assertion.
+    template<typename Rhs>
+    inline const Solve<FullPivLU, Rhs>
+    solve(const MatrixBase<Rhs>& b) const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return Solve<FullPivLU, Rhs>(*this, b.derived());
+    }
+
+    /** \returns an estimate of the reciprocal condition number of the matrix of which \c *this is
+        the LU decomposition.
+      */
+    inline RealScalar rcond() const
+    {
+      eigen_assert(m_isInitialized && "PartialPivLU is not initialized.");
+      return internal::rcond_estimate_helper(m_l1_norm, *this);
+    }
+
+    /** \returns the determinant of the matrix of which
+      * *this is the LU decomposition. It has only linear complexity
+      * (that is, O(n) where n is the dimension of the square matrix)
+      * as the LU decomposition has already been computed.
+      *
+      * \note This is only for square matrices.
+      *
+      * \note For fixed-size matrices of size up to 4, MatrixBase::determinant() offers
+      *       optimized paths.
+      *
+      * \warning a determinant can be very big or small, so for matrices
+      * of large enough dimension, there is a risk of overflow/underflow.
+      *
+      * \sa MatrixBase::determinant()
+      */
+    typename internal::traits<MatrixType>::Scalar determinant() const;
+
+    /** Allows to prescribe a threshold to be used by certain methods, such as rank(),
+      * who need to determine when pivots are to be considered nonzero. This is not used for the
+      * LU decomposition itself.
+      *
+      * When it needs to get the threshold value, Eigen calls threshold(). By default, this
+      * uses a formula to automatically determine a reasonable threshold.
+      * Once you have called the present method setThreshold(const RealScalar&),
+      * your value is used instead.
+      *
+      * \param threshold The new value to use as the threshold.
+      *
+      * A pivot will be considered nonzero if its absolute value is strictly greater than
+      *  \f$ \vert pivot \vert \leqslant threshold \times \vert maxpivot \vert \f$
+      * where maxpivot is the biggest pivot.
+      *
+      * If you want to come back to the default behavior, call setThreshold(Default_t)
+      */
+    FullPivLU& setThreshold(const RealScalar& threshold)
+    {
+      m_usePrescribedThreshold = true;
+      m_prescribedThreshold = threshold;
+      return *this;
+    }
+
+    /** Allows to come back to the default behavior, letting Eigen use its default formula for
+      * determining the threshold.
+      *
+      * You should pass the special object Eigen::Default as parameter here.
+      * \code lu.setThreshold(Eigen::Default); \endcode
+      *
+      * See the documentation of setThreshold(const RealScalar&).
+      */
+    FullPivLU& setThreshold(Default_t)
+    {
+      m_usePrescribedThreshold = false;
+      return *this;
+    }
+
+    /** Returns the threshold that will be used by certain methods such as rank().
+      *
+      * See the documentation of setThreshold(const RealScalar&).
+      */
+    RealScalar threshold() const
+    {
+      eigen_assert(m_isInitialized || m_usePrescribedThreshold);
+      return m_usePrescribedThreshold ? m_prescribedThreshold
+      // this formula comes from experimenting (see "LU precision tuning" thread on the list)
+      // and turns out to be identical to Higham's formula used already in LDLt.
+                                      : NumTraits<Scalar>::epsilon() * m_lu.diagonalSize();
+    }
+
+    /** \returns the rank of the matrix of which *this is the LU decomposition.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline Index rank() const
+    {
+      using std::abs;
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      RealScalar premultiplied_threshold = abs(m_maxpivot) * threshold();
+      Index result = 0;
+      for(Index i = 0; i < m_nonzero_pivots; ++i)
+        result += (abs(m_lu.coeff(i,i)) > premultiplied_threshold);
+      return result;
+    }
+
+    /** \returns the dimension of the kernel of the matrix of which *this is the LU decomposition.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline Index dimensionOfKernel() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return cols() - rank();
+    }
+
+    /** \returns true if the matrix of which *this is the LU decomposition represents an injective
+      *          linear map, i.e. has trivial kernel; false otherwise.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline bool isInjective() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return rank() == cols();
+    }
+
+    /** \returns true if the matrix of which *this is the LU decomposition represents a surjective
+      *          linear map; false otherwise.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline bool isSurjective() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return rank() == rows();
+    }
+
+    /** \returns true if the matrix of which *this is the LU decomposition is invertible.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline bool isInvertible() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return isInjective() && (m_lu.rows() == m_lu.cols());
+    }
+
+    /** \returns the inverse of the matrix of which *this is the LU decomposition.
+      *
+      * \note If this matrix is not invertible, the returned matrix has undefined coefficients.
+      *       Use isInvertible() to first determine whether this matrix is invertible.
+      *
+      * \sa MatrixBase::inverse()
+      */
+    inline const Inverse<FullPivLU> inverse() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      eigen_assert(m_lu.rows() == m_lu.cols() && "You can't take the inverse of a non-square matrix!");
+      return Inverse<FullPivLU>(*this);
+    }
+
+    MatrixType reconstructedMatrix() const;
+
+    EIGEN_DEVICE_FUNC inline Index rows() const { return m_lu.rows(); }
+    EIGEN_DEVICE_FUNC inline Index cols() const { return m_lu.cols(); }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename RhsType, typename DstType>
+    void _solve_impl(const RhsType &rhs, DstType &dst) const;
+
+    template<bool Conjugate, typename RhsType, typename DstType>
+    void _solve_impl_transposed(const RhsType &rhs, DstType &dst) const;
+    #endif
+
+  protected:
+
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+    }
+
+    void computeInPlace();
+
+    MatrixType m_lu;
+    PermutationPType m_p;
+    PermutationQType m_q;
+    IntColVectorType m_rowsTranspositions;
+    IntRowVectorType m_colsTranspositions;
+    Index m_nonzero_pivots;
+    RealScalar m_l1_norm;
+    RealScalar m_maxpivot, m_prescribedThreshold;
+    signed char m_det_pq;
+    bool m_isInitialized, m_usePrescribedThreshold;
+};
+
+template<typename MatrixType>
+FullPivLU<MatrixType>::FullPivLU()
+  : m_isInitialized(false), m_usePrescribedThreshold(false)
+{
+}
+
+template<typename MatrixType>
+FullPivLU<MatrixType>::FullPivLU(Index rows, Index cols)
+  : m_lu(rows, cols),
+    m_p(rows),
+    m_q(cols),
+    m_rowsTranspositions(rows),
+    m_colsTranspositions(cols),
+    m_isInitialized(false),
+    m_usePrescribedThreshold(false)
+{
+}
+
+template<typename MatrixType>
+template<typename InputType>
+FullPivLU<MatrixType>::FullPivLU(const EigenBase<InputType>& matrix)
+  : m_lu(matrix.rows(), matrix.cols()),
+    m_p(matrix.rows()),
+    m_q(matrix.cols()),
+    m_rowsTranspositions(matrix.rows()),
+    m_colsTranspositions(matrix.cols()),
+    m_isInitialized(false),
+    m_usePrescribedThreshold(false)
+{
+  compute(matrix.derived());
+}
+
+template<typename MatrixType>
+template<typename InputType>
+FullPivLU<MatrixType>::FullPivLU(EigenBase<InputType>& matrix)
+  : m_lu(matrix.derived()),
+    m_p(matrix.rows()),
+    m_q(matrix.cols()),
+    m_rowsTranspositions(matrix.rows()),
+    m_colsTranspositions(matrix.cols()),
+    m_isInitialized(false),
+    m_usePrescribedThreshold(false)
+{
+  computeInPlace();
+}
+
+template<typename MatrixType>
+void FullPivLU<MatrixType>::computeInPlace()
+{
+  check_template_parameters();
+
+  // the permutations are stored as int indices, so just to be sure:
+  eigen_assert(m_lu.rows()<=NumTraits<int>::highest() && m_lu.cols()<=NumTraits<int>::highest());
+
+  m_l1_norm = m_lu.cwiseAbs().colwise().sum().maxCoeff();
+
+  const Index size = m_lu.diagonalSize();
+  const Index rows = m_lu.rows();
+  const Index cols = m_lu.cols();
+
+  // will store the transpositions, before we accumulate them at the end.
+  // can't accumulate on-the-fly because that will be done in reverse order for the rows.
+  m_rowsTranspositions.resize(m_lu.rows());
+  m_colsTranspositions.resize(m_lu.cols());
+  Index number_of_transpositions = 0; // number of NONTRIVIAL transpositions, i.e. m_rowsTranspositions[i]!=i
+
+  m_nonzero_pivots = size; // the generic case is that in which all pivots are nonzero (invertible case)
+  m_maxpivot = RealScalar(0);
+
+  for(Index k = 0; k < size; ++k)
+  {
+    // First, we need to find the pivot.
+
+    // biggest coefficient in the remaining bottom-right corner (starting at row k, col k)
+    Index row_of_biggest_in_corner, col_of_biggest_in_corner;
+    typedef internal::scalar_score_coeff_op<Scalar> Scoring;
+    typedef typename Scoring::result_type Score;
+    Score biggest_in_corner;
+    biggest_in_corner = m_lu.bottomRightCorner(rows-k, cols-k)
+                        .unaryExpr(Scoring())
+                        .maxCoeff(&row_of_biggest_in_corner, &col_of_biggest_in_corner);
+    row_of_biggest_in_corner += k; // correct the values! since they were computed in the corner,
+    col_of_biggest_in_corner += k; // need to add k to them.
+
+    if(biggest_in_corner==Score(0))
+    {
+      // before exiting, make sure to initialize the still uninitialized transpositions
+      // in a sane state without destroying what we already have.
+      m_nonzero_pivots = k;
+      for(Index i = k; i < size; ++i)
+      {
+        m_rowsTranspositions.coeffRef(i) = i;
+        m_colsTranspositions.coeffRef(i) = i;
+      }
+      break;
+    }
+
+    RealScalar abs_pivot = internal::abs_knowing_score<Scalar>()(m_lu(row_of_biggest_in_corner, col_of_biggest_in_corner), biggest_in_corner);
+    if(abs_pivot > m_maxpivot) m_maxpivot = abs_pivot;
+
+    // Now that we've found the pivot, we need to apply the row/col swaps to
+    // bring it to the location (k,k).
+
+    m_rowsTranspositions.coeffRef(k) = row_of_biggest_in_corner;
+    m_colsTranspositions.coeffRef(k) = col_of_biggest_in_corner;
+    if(k != row_of_biggest_in_corner) {
+      m_lu.row(k).swap(m_lu.row(row_of_biggest_in_corner));
+      ++number_of_transpositions;
+    }
+    if(k != col_of_biggest_in_corner) {
+      m_lu.col(k).swap(m_lu.col(col_of_biggest_in_corner));
+      ++number_of_transpositions;
+    }
+
+    // Now that the pivot is at the right location, we update the remaining
+    // bottom-right corner by Gaussian elimination.
+
+    if(k<rows-1)
+      m_lu.col(k).tail(rows-k-1) /= m_lu.coeff(k,k);
+    if(k<size-1)
+      m_lu.block(k+1,k+1,rows-k-1,cols-k-1).noalias() -= m_lu.col(k).tail(rows-k-1) * m_lu.row(k).tail(cols-k-1);
+  }
+
+  // the main loop is over, we still have to accumulate the transpositions to find the
+  // permutations P and Q
+
+  m_p.setIdentity(rows);
+  for(Index k = size-1; k >= 0; --k)
+    m_p.applyTranspositionOnTheRight(k, m_rowsTranspositions.coeff(k));
+
+  m_q.setIdentity(cols);
+  for(Index k = 0; k < size; ++k)
+    m_q.applyTranspositionOnTheRight(k, m_colsTranspositions.coeff(k));
+
+  m_det_pq = (number_of_transpositions%2) ? -1 : 1;
+
+  m_isInitialized = true;
+}
+
+template<typename MatrixType>
+typename internal::traits<MatrixType>::Scalar FullPivLU<MatrixType>::determinant() const
+{
+  eigen_assert(m_isInitialized && "LU is not initialized.");
+  eigen_assert(m_lu.rows() == m_lu.cols() && "You can't take the determinant of a non-square matrix!");
+  return Scalar(m_det_pq) * Scalar(m_lu.diagonal().prod());
+}
+
+/** \returns the matrix represented by the decomposition,
+ * i.e., it returns the product: \f$ P^{-1} L U Q^{-1} \f$.
+ * This function is provided for debug purposes. */
+template<typename MatrixType>
+MatrixType FullPivLU<MatrixType>::reconstructedMatrix() const
+{
+  eigen_assert(m_isInitialized && "LU is not initialized.");
+  const Index smalldim = (std::min)(m_lu.rows(), m_lu.cols());
+  // LU
+  MatrixType res(m_lu.rows(),m_lu.cols());
+  // FIXME the .toDenseMatrix() should not be needed...
+  res = m_lu.leftCols(smalldim)
+            .template triangularView<UnitLower>().toDenseMatrix()
+      * m_lu.topRows(smalldim)
+            .template triangularView<Upper>().toDenseMatrix();
+
+  // P^{-1}(LU)
+  res = m_p.inverse() * res;
+
+  // (P^{-1}LU)Q^{-1}
+  res = res * m_q.inverse();
+
+  return res;
+}
+
+/********* Implementation of kernel() **************************************************/
+
+namespace internal {
+template<typename _MatrixType>
+struct kernel_retval<FullPivLU<_MatrixType> >
+  : kernel_retval_base<FullPivLU<_MatrixType> >
+{
+  EIGEN_MAKE_KERNEL_HELPERS(FullPivLU<_MatrixType>)
+
+  enum { MaxSmallDimAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED(
+            MatrixType::MaxColsAtCompileTime,
+            MatrixType::MaxRowsAtCompileTime)
+  };
+
+  template<typename Dest> void evalTo(Dest& dst) const
+  {
+    using std::abs;
+    const Index cols = dec().matrixLU().cols(), dimker = cols - rank();
+    if(dimker == 0)
+    {
+      // The Kernel is just {0}, so it doesn't have a basis properly speaking, but let's
+      // avoid crashing/asserting as that depends on floating point calculations. Let's
+      // just return a single column vector filled with zeros.
+      dst.setZero();
+      return;
+    }
+
+    /* Let us use the following lemma:
+      *
+      * Lemma: If the matrix A has the LU decomposition PAQ = LU,
+      * then Ker A = Q(Ker U).
+      *
+      * Proof: trivial: just keep in mind that P, Q, L are invertible.
+      */
+
+    /* Thus, all we need to do is to compute Ker U, and then apply Q.
+      *
+      * U is upper triangular, with eigenvalues sorted so that any zeros appear at the end.
+      * Thus, the diagonal of U ends with exactly
+      * dimKer zero's. Let us use that to construct dimKer linearly
+      * independent vectors in Ker U.
+      */
+
+    Matrix<Index, Dynamic, 1, 0, MaxSmallDimAtCompileTime, 1> pivots(rank());
+    RealScalar premultiplied_threshold = dec().maxPivot() * dec().threshold();
+    Index p = 0;
+    for(Index i = 0; i < dec().nonzeroPivots(); ++i)
+      if(abs(dec().matrixLU().coeff(i,i)) > premultiplied_threshold)
+        pivots.coeffRef(p++) = i;
+    eigen_internal_assert(p == rank());
+
+    // we construct a temporaty trapezoid matrix m, by taking the U matrix and
+    // permuting the rows and cols to bring the nonnegligible pivots to the top of
+    // the main diagonal. We need that to be able to apply our triangular solvers.
+    // FIXME when we get triangularView-for-rectangular-matrices, this can be simplified
+    Matrix<typename MatrixType::Scalar, Dynamic, Dynamic, MatrixType::Options,
+           MaxSmallDimAtCompileTime, MatrixType::MaxColsAtCompileTime>
+      m(dec().matrixLU().block(0, 0, rank(), cols));
+    for(Index i = 0; i < rank(); ++i)
+    {
+      if(i) m.row(i).head(i).setZero();
+      m.row(i).tail(cols-i) = dec().matrixLU().row(pivots.coeff(i)).tail(cols-i);
+    }
+    m.block(0, 0, rank(), rank());
+    m.block(0, 0, rank(), rank()).template triangularView<StrictlyLower>().setZero();
+    for(Index i = 0; i < rank(); ++i)
+      m.col(i).swap(m.col(pivots.coeff(i)));
+
+    // ok, we have our trapezoid matrix, we can apply the triangular solver.
+    // notice that the math behind this suggests that we should apply this to the
+    // negative of the RHS, but for performance we just put the negative sign elsewhere, see below.
+    m.topLeftCorner(rank(), rank())
+     .template triangularView<Upper>().solveInPlace(
+        m.topRightCorner(rank(), dimker)
+      );
+
+    // now we must undo the column permutation that we had applied!
+    for(Index i = rank()-1; i >= 0; --i)
+      m.col(i).swap(m.col(pivots.coeff(i)));
+
+    // see the negative sign in the next line, that's what we were talking about above.
+    for(Index i = 0; i < rank(); ++i) dst.row(dec().permutationQ().indices().coeff(i)) = -m.row(i).tail(dimker);
+    for(Index i = rank(); i < cols; ++i) dst.row(dec().permutationQ().indices().coeff(i)).setZero();
+    for(Index k = 0; k < dimker; ++k) dst.coeffRef(dec().permutationQ().indices().coeff(rank()+k), k) = Scalar(1);
+  }
+};
+
+/***** Implementation of image() *****************************************************/
+
+template<typename _MatrixType>
+struct image_retval<FullPivLU<_MatrixType> >
+  : image_retval_base<FullPivLU<_MatrixType> >
+{
+  EIGEN_MAKE_IMAGE_HELPERS(FullPivLU<_MatrixType>)
+
+  enum { MaxSmallDimAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED(
+            MatrixType::MaxColsAtCompileTime,
+            MatrixType::MaxRowsAtCompileTime)
+  };
+
+  template<typename Dest> void evalTo(Dest& dst) const
+  {
+    using std::abs;
+    if(rank() == 0)
+    {
+      // The Image is just {0}, so it doesn't have a basis properly speaking, but let's
+      // avoid crashing/asserting as that depends on floating point calculations. Let's
+      // just return a single column vector filled with zeros.
+      dst.setZero();
+      return;
+    }
+
+    Matrix<Index, Dynamic, 1, 0, MaxSmallDimAtCompileTime, 1> pivots(rank());
+    RealScalar premultiplied_threshold = dec().maxPivot() * dec().threshold();
+    Index p = 0;
+    for(Index i = 0; i < dec().nonzeroPivots(); ++i)
+      if(abs(dec().matrixLU().coeff(i,i)) > premultiplied_threshold)
+        pivots.coeffRef(p++) = i;
+    eigen_internal_assert(p == rank());
+
+    for(Index i = 0; i < rank(); ++i)
+      dst.col(i) = originalMatrix().col(dec().permutationQ().indices().coeff(pivots.coeff(i)));
+  }
+};
+
+/***** Implementation of solve() *****************************************************/
+
+} // end namespace internal
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename _MatrixType>
+template<typename RhsType, typename DstType>
+void FullPivLU<_MatrixType>::_solve_impl(const RhsType &rhs, DstType &dst) const
+{
+  /* The decomposition PAQ = LU can be rewritten as A = P^{-1} L U Q^{-1}.
+  * So we proceed as follows:
+  * Step 1: compute c = P * rhs.
+  * Step 2: replace c by the solution x to Lx = c. Exists because L is invertible.
+  * Step 3: replace c by the solution x to Ux = c. May or may not exist.
+  * Step 4: result = Q * c;
+  */
+
+  const Index rows = this->rows(),
+              cols = this->cols(),
+              nonzero_pivots = this->rank();
+  eigen_assert(rhs.rows() == rows);
+  const Index smalldim = (std::min)(rows, cols);
+
+  if(nonzero_pivots == 0)
+  {
+    dst.setZero();
+    return;
+  }
+
+  typename RhsType::PlainObject c(rhs.rows(), rhs.cols());
+
+  // Step 1
+  c = permutationP() * rhs;
+
+  // Step 2
+  m_lu.topLeftCorner(smalldim,smalldim)
+      .template triangularView<UnitLower>()
+      .solveInPlace(c.topRows(smalldim));
+  if(rows>cols)
+    c.bottomRows(rows-cols) -= m_lu.bottomRows(rows-cols) * c.topRows(cols);
+
+  // Step 3
+  m_lu.topLeftCorner(nonzero_pivots, nonzero_pivots)
+      .template triangularView<Upper>()
+      .solveInPlace(c.topRows(nonzero_pivots));
+
+  // Step 4
+  for(Index i = 0; i < nonzero_pivots; ++i)
+    dst.row(permutationQ().indices().coeff(i)) = c.row(i);
+  for(Index i = nonzero_pivots; i < m_lu.cols(); ++i)
+    dst.row(permutationQ().indices().coeff(i)).setZero();
+}
+
+template<typename _MatrixType>
+template<bool Conjugate, typename RhsType, typename DstType>
+void FullPivLU<_MatrixType>::_solve_impl_transposed(const RhsType &rhs, DstType &dst) const
+{
+  /* The decomposition PAQ = LU can be rewritten as A = P^{-1} L U Q^{-1},
+   * and since permutations are real and unitary, we can write this
+   * as   A^T = Q U^T L^T P,
+   * So we proceed as follows:
+   * Step 1: compute c = Q^T rhs.
+   * Step 2: replace c by the solution x to U^T x = c. May or may not exist.
+   * Step 3: replace c by the solution x to L^T x = c.
+   * Step 4: result = P^T c.
+   * If Conjugate is true, replace "^T" by "^*" above.
+   */
+
+  const Index rows = this->rows(), cols = this->cols(),
+    nonzero_pivots = this->rank();
+   eigen_assert(rhs.rows() == cols);
+  const Index smalldim = (std::min)(rows, cols);
+
+  if(nonzero_pivots == 0)
+  {
+    dst.setZero();
+    return;
+  }
+
+  typename RhsType::PlainObject c(rhs.rows(), rhs.cols());
+
+  // Step 1
+  c = permutationQ().inverse() * rhs;
+
+  if (Conjugate) {
+    // Step 2
+    m_lu.topLeftCorner(nonzero_pivots, nonzero_pivots)
+        .template triangularView<Upper>()
+        .adjoint()
+        .solveInPlace(c.topRows(nonzero_pivots));
+    // Step 3
+    m_lu.topLeftCorner(smalldim, smalldim)
+        .template triangularView<UnitLower>()
+        .adjoint()
+        .solveInPlace(c.topRows(smalldim));
+  } else {
+    // Step 2
+    m_lu.topLeftCorner(nonzero_pivots, nonzero_pivots)
+        .template triangularView<Upper>()
+        .transpose()
+        .solveInPlace(c.topRows(nonzero_pivots));
+    // Step 3
+    m_lu.topLeftCorner(smalldim, smalldim)
+        .template triangularView<UnitLower>()
+        .transpose()
+        .solveInPlace(c.topRows(smalldim));
+  }
+
+  // Step 4
+  PermutationPType invp = permutationP().inverse().eval();
+  for(Index i = 0; i < smalldim; ++i)
+    dst.row(invp.indices().coeff(i)) = c.row(i);
+  for(Index i = smalldim; i < rows; ++i)
+    dst.row(invp.indices().coeff(i)).setZero();
+}
+
+#endif
+
+namespace internal {
+
+
+/***** Implementation of inverse() *****************************************************/
+template<typename DstXprType, typename MatrixType>
+struct Assignment<DstXprType, Inverse<FullPivLU<MatrixType> >, internal::assign_op<typename DstXprType::Scalar,typename FullPivLU<MatrixType>::Scalar>, Dense2Dense>
+{
+  typedef FullPivLU<MatrixType> LuType;
+  typedef Inverse<LuType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename MatrixType::Scalar> &)
+  {
+    dst = src.nestedExpression().solve(MatrixType::Identity(src.rows(), src.cols()));
+  }
+};
+} // end namespace internal
+
+/******* MatrixBase methods *****************************************************************/
+
+/** \lu_module
+  *
+  * \return the full-pivoting LU decomposition of \c *this.
+  *
+  * \sa class FullPivLU
+  */
+template<typename Derived>
+inline const FullPivLU<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::fullPivLu() const
+{
+  return FullPivLU<PlainObject>(eval());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_LU_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/LU/InverseImpl.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/LU/InverseImpl.h
new file mode 100644
index 00000000..018f99b5
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/LU/InverseImpl.h
@@ -0,0 +1,415 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_INVERSE_IMPL_H
+#define EIGEN_INVERSE_IMPL_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/**********************************
+*** General case implementation ***
+**********************************/
+
+template<typename MatrixType, typename ResultType, int Size = MatrixType::RowsAtCompileTime>
+struct compute_inverse
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(const MatrixType& matrix, ResultType& result)
+  {
+    result = matrix.partialPivLu().inverse();
+  }
+};
+
+template<typename MatrixType, typename ResultType, int Size = MatrixType::RowsAtCompileTime>
+struct compute_inverse_and_det_with_check { /* nothing! general case not supported. */ };
+
+/****************************
+*** Size 1 implementation ***
+****************************/
+
+template<typename MatrixType, typename ResultType>
+struct compute_inverse<MatrixType, ResultType, 1>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(const MatrixType& matrix, ResultType& result)
+  {
+    typedef typename MatrixType::Scalar Scalar;
+    internal::evaluator<MatrixType> matrixEval(matrix);
+    result.coeffRef(0,0) = Scalar(1) / matrixEval.coeff(0,0);
+  }
+};
+
+template<typename MatrixType, typename ResultType>
+struct compute_inverse_and_det_with_check<MatrixType, ResultType, 1>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(
+    const MatrixType& matrix,
+    const typename MatrixType::RealScalar& absDeterminantThreshold,
+    ResultType& result,
+    typename ResultType::Scalar& determinant,
+    bool& invertible
+  )
+  {
+    using std::abs;
+    determinant = matrix.coeff(0,0);
+    invertible = abs(determinant) > absDeterminantThreshold;
+    if(invertible) result.coeffRef(0,0) = typename ResultType::Scalar(1) / determinant;
+  }
+};
+
+/****************************
+*** Size 2 implementation ***
+****************************/
+
+template<typename MatrixType, typename ResultType>
+EIGEN_DEVICE_FUNC 
+inline void compute_inverse_size2_helper(
+    const MatrixType& matrix, const typename ResultType::Scalar& invdet,
+    ResultType& result)
+{
+  result.coeffRef(0,0) =  matrix.coeff(1,1) * invdet;
+  result.coeffRef(1,0) = -matrix.coeff(1,0) * invdet;
+  result.coeffRef(0,1) = -matrix.coeff(0,1) * invdet;
+  result.coeffRef(1,1) =  matrix.coeff(0,0) * invdet;
+}
+
+template<typename MatrixType, typename ResultType>
+struct compute_inverse<MatrixType, ResultType, 2>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(const MatrixType& matrix, ResultType& result)
+  {
+    typedef typename ResultType::Scalar Scalar;
+    const Scalar invdet = typename MatrixType::Scalar(1) / matrix.determinant();
+    compute_inverse_size2_helper(matrix, invdet, result);
+  }
+};
+
+template<typename MatrixType, typename ResultType>
+struct compute_inverse_and_det_with_check<MatrixType, ResultType, 2>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(
+    const MatrixType& matrix,
+    const typename MatrixType::RealScalar& absDeterminantThreshold,
+    ResultType& inverse,
+    typename ResultType::Scalar& determinant,
+    bool& invertible
+  )
+  {
+    using std::abs;
+    typedef typename ResultType::Scalar Scalar;
+    determinant = matrix.determinant();
+    invertible = abs(determinant) > absDeterminantThreshold;
+    if(!invertible) return;
+    const Scalar invdet = Scalar(1) / determinant;
+    compute_inverse_size2_helper(matrix, invdet, inverse);
+  }
+};
+
+/****************************
+*** Size 3 implementation ***
+****************************/
+
+template<typename MatrixType, int i, int j>
+EIGEN_DEVICE_FUNC 
+inline typename MatrixType::Scalar cofactor_3x3(const MatrixType& m)
+{
+  enum {
+    i1 = (i+1) % 3,
+    i2 = (i+2) % 3,
+    j1 = (j+1) % 3,
+    j2 = (j+2) % 3
+  };
+  return m.coeff(i1, j1) * m.coeff(i2, j2)
+       - m.coeff(i1, j2) * m.coeff(i2, j1);
+}
+
+template<typename MatrixType, typename ResultType>
+EIGEN_DEVICE_FUNC
+inline void compute_inverse_size3_helper(
+    const MatrixType& matrix,
+    const typename ResultType::Scalar& invdet,
+    const Matrix<typename ResultType::Scalar,3,1>& cofactors_col0,
+    ResultType& result)
+{
+  result.row(0) = cofactors_col0 * invdet;
+  result.coeffRef(1,0) =  cofactor_3x3<MatrixType,0,1>(matrix) * invdet;
+  result.coeffRef(1,1) =  cofactor_3x3<MatrixType,1,1>(matrix) * invdet;
+  result.coeffRef(1,2) =  cofactor_3x3<MatrixType,2,1>(matrix) * invdet;
+  result.coeffRef(2,0) =  cofactor_3x3<MatrixType,0,2>(matrix) * invdet;
+  result.coeffRef(2,1) =  cofactor_3x3<MatrixType,1,2>(matrix) * invdet;
+  result.coeffRef(2,2) =  cofactor_3x3<MatrixType,2,2>(matrix) * invdet;
+}
+
+template<typename MatrixType, typename ResultType>
+struct compute_inverse<MatrixType, ResultType, 3>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(const MatrixType& matrix, ResultType& result)
+  {
+    typedef typename ResultType::Scalar Scalar;
+    Matrix<typename MatrixType::Scalar,3,1> cofactors_col0;
+    cofactors_col0.coeffRef(0) =  cofactor_3x3<MatrixType,0,0>(matrix);
+    cofactors_col0.coeffRef(1) =  cofactor_3x3<MatrixType,1,0>(matrix);
+    cofactors_col0.coeffRef(2) =  cofactor_3x3<MatrixType,2,0>(matrix);
+    const Scalar det = (cofactors_col0.cwiseProduct(matrix.col(0))).sum();
+    const Scalar invdet = Scalar(1) / det;
+    compute_inverse_size3_helper(matrix, invdet, cofactors_col0, result);
+  }
+};
+
+template<typename MatrixType, typename ResultType>
+struct compute_inverse_and_det_with_check<MatrixType, ResultType, 3>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(
+    const MatrixType& matrix,
+    const typename MatrixType::RealScalar& absDeterminantThreshold,
+    ResultType& inverse,
+    typename ResultType::Scalar& determinant,
+    bool& invertible
+  )
+  {
+    using std::abs;
+    typedef typename ResultType::Scalar Scalar;
+    Matrix<Scalar,3,1> cofactors_col0;
+    cofactors_col0.coeffRef(0) =  cofactor_3x3<MatrixType,0,0>(matrix);
+    cofactors_col0.coeffRef(1) =  cofactor_3x3<MatrixType,1,0>(matrix);
+    cofactors_col0.coeffRef(2) =  cofactor_3x3<MatrixType,2,0>(matrix);
+    determinant = (cofactors_col0.cwiseProduct(matrix.col(0))).sum();
+    invertible = abs(determinant) > absDeterminantThreshold;
+    if(!invertible) return;
+    const Scalar invdet = Scalar(1) / determinant;
+    compute_inverse_size3_helper(matrix, invdet, cofactors_col0, inverse);
+  }
+};
+
+/****************************
+*** Size 4 implementation ***
+****************************/
+
+template<typename Derived>
+EIGEN_DEVICE_FUNC 
+inline const typename Derived::Scalar general_det3_helper
+(const MatrixBase<Derived>& matrix, int i1, int i2, int i3, int j1, int j2, int j3)
+{
+  return matrix.coeff(i1,j1)
+         * (matrix.coeff(i2,j2) * matrix.coeff(i3,j3) - matrix.coeff(i2,j3) * matrix.coeff(i3,j2));
+}
+
+template<typename MatrixType, int i, int j>
+EIGEN_DEVICE_FUNC 
+inline typename MatrixType::Scalar cofactor_4x4(const MatrixType& matrix)
+{
+  enum {
+    i1 = (i+1) % 4,
+    i2 = (i+2) % 4,
+    i3 = (i+3) % 4,
+    j1 = (j+1) % 4,
+    j2 = (j+2) % 4,
+    j3 = (j+3) % 4
+  };
+  return general_det3_helper(matrix, i1, i2, i3, j1, j2, j3)
+       + general_det3_helper(matrix, i2, i3, i1, j1, j2, j3)
+       + general_det3_helper(matrix, i3, i1, i2, j1, j2, j3);
+}
+
+template<int Arch, typename Scalar, typename MatrixType, typename ResultType>
+struct compute_inverse_size4
+{
+  EIGEN_DEVICE_FUNC
+  static void run(const MatrixType& matrix, ResultType& result)
+  {
+    result.coeffRef(0,0) =  cofactor_4x4<MatrixType,0,0>(matrix);
+    result.coeffRef(1,0) = -cofactor_4x4<MatrixType,0,1>(matrix);
+    result.coeffRef(2,0) =  cofactor_4x4<MatrixType,0,2>(matrix);
+    result.coeffRef(3,0) = -cofactor_4x4<MatrixType,0,3>(matrix);
+    result.coeffRef(0,2) =  cofactor_4x4<MatrixType,2,0>(matrix);
+    result.coeffRef(1,2) = -cofactor_4x4<MatrixType,2,1>(matrix);
+    result.coeffRef(2,2) =  cofactor_4x4<MatrixType,2,2>(matrix);
+    result.coeffRef(3,2) = -cofactor_4x4<MatrixType,2,3>(matrix);
+    result.coeffRef(0,1) = -cofactor_4x4<MatrixType,1,0>(matrix);
+    result.coeffRef(1,1) =  cofactor_4x4<MatrixType,1,1>(matrix);
+    result.coeffRef(2,1) = -cofactor_4x4<MatrixType,1,2>(matrix);
+    result.coeffRef(3,1) =  cofactor_4x4<MatrixType,1,3>(matrix);
+    result.coeffRef(0,3) = -cofactor_4x4<MatrixType,3,0>(matrix);
+    result.coeffRef(1,3) =  cofactor_4x4<MatrixType,3,1>(matrix);
+    result.coeffRef(2,3) = -cofactor_4x4<MatrixType,3,2>(matrix);
+    result.coeffRef(3,3) =  cofactor_4x4<MatrixType,3,3>(matrix);
+    result /= (matrix.col(0).cwiseProduct(result.row(0).transpose())).sum();
+  }
+};
+
+template<typename MatrixType, typename ResultType>
+struct compute_inverse<MatrixType, ResultType, 4>
+ : compute_inverse_size4<Architecture::Target, typename MatrixType::Scalar,
+                            MatrixType, ResultType>
+{
+};
+
+template<typename MatrixType, typename ResultType>
+struct compute_inverse_and_det_with_check<MatrixType, ResultType, 4>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(
+    const MatrixType& matrix,
+    const typename MatrixType::RealScalar& absDeterminantThreshold,
+    ResultType& inverse,
+    typename ResultType::Scalar& determinant,
+    bool& invertible
+  )
+  {
+    using std::abs;
+    determinant = matrix.determinant();
+    invertible = abs(determinant) > absDeterminantThreshold;
+    if(invertible) compute_inverse<MatrixType, ResultType>::run(matrix, inverse);
+  }
+};
+
+/*************************
+*** MatrixBase methods ***
+*************************/
+
+} // end namespace internal
+
+namespace internal {
+
+// Specialization for "dense = dense_xpr.inverse()"
+template<typename DstXprType, typename XprType>
+struct Assignment<DstXprType, Inverse<XprType>, internal::assign_op<typename DstXprType::Scalar,typename XprType::Scalar>, Dense2Dense>
+{
+  typedef Inverse<XprType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename XprType::Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+    
+    const int Size = EIGEN_PLAIN_ENUM_MIN(XprType::ColsAtCompileTime,DstXprType::ColsAtCompileTime);
+    EIGEN_ONLY_USED_FOR_DEBUG(Size);
+    eigen_assert(( (Size<=1) || (Size>4) || (extract_data(src.nestedExpression())!=extract_data(dst)))
+              && "Aliasing problem detected in inverse(), you need to do inverse().eval() here.");
+
+    typedef typename internal::nested_eval<XprType,XprType::ColsAtCompileTime>::type  ActualXprType;
+    typedef typename internal::remove_all<ActualXprType>::type                        ActualXprTypeCleanded;
+    
+    ActualXprType actual_xpr(src.nestedExpression());
+    
+    compute_inverse<ActualXprTypeCleanded, DstXprType>::run(actual_xpr, dst);
+  }
+};
+
+  
+} // end namespace internal
+
+/** \lu_module
+  *
+  * \returns the matrix inverse of this matrix.
+  *
+  * For small fixed sizes up to 4x4, this method uses cofactors.
+  * In the general case, this method uses class PartialPivLU.
+  *
+  * \note This matrix must be invertible, otherwise the result is undefined. If you need an
+  * invertibility check, do the following:
+  * \li for fixed sizes up to 4x4, use computeInverseAndDetWithCheck().
+  * \li for the general case, use class FullPivLU.
+  *
+  * Example: \include MatrixBase_inverse.cpp
+  * Output: \verbinclude MatrixBase_inverse.out
+  *
+  * \sa computeInverseAndDetWithCheck()
+  */
+template<typename Derived>
+inline const Inverse<Derived> MatrixBase<Derived>::inverse() const
+{
+  EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::IsInteger,THIS_FUNCTION_IS_NOT_FOR_INTEGER_NUMERIC_TYPES)
+  eigen_assert(rows() == cols());
+  return Inverse<Derived>(derived());
+}
+
+/** \lu_module
+  *
+  * Computation of matrix inverse and determinant, with invertibility check.
+  *
+  * This is only for fixed-size square matrices of size up to 4x4.
+  *
+  * \param inverse Reference to the matrix in which to store the inverse.
+  * \param determinant Reference to the variable in which to store the determinant.
+  * \param invertible Reference to the bool variable in which to store whether the matrix is invertible.
+  * \param absDeterminantThreshold Optional parameter controlling the invertibility check.
+  *                                The matrix will be declared invertible if the absolute value of its
+  *                                determinant is greater than this threshold.
+  *
+  * Example: \include MatrixBase_computeInverseAndDetWithCheck.cpp
+  * Output: \verbinclude MatrixBase_computeInverseAndDetWithCheck.out
+  *
+  * \sa inverse(), computeInverseWithCheck()
+  */
+template<typename Derived>
+template<typename ResultType>
+inline void MatrixBase<Derived>::computeInverseAndDetWithCheck(
+    ResultType& inverse,
+    typename ResultType::Scalar& determinant,
+    bool& invertible,
+    const RealScalar& absDeterminantThreshold
+  ) const
+{
+  // i'd love to put some static assertions there, but SFINAE means that they have no effect...
+  eigen_assert(rows() == cols());
+  // for 2x2, it's worth giving a chance to avoid evaluating.
+  // for larger sizes, evaluating has negligible cost and limits code size.
+  typedef typename internal::conditional<
+    RowsAtCompileTime == 2,
+    typename internal::remove_all<typename internal::nested_eval<Derived, 2>::type>::type,
+    PlainObject
+  >::type MatrixType;
+  internal::compute_inverse_and_det_with_check<MatrixType, ResultType>::run
+    (derived(), absDeterminantThreshold, inverse, determinant, invertible);
+}
+
+/** \lu_module
+  *
+  * Computation of matrix inverse, with invertibility check.
+  *
+  * This is only for fixed-size square matrices of size up to 4x4.
+  *
+  * \param inverse Reference to the matrix in which to store the inverse.
+  * \param invertible Reference to the bool variable in which to store whether the matrix is invertible.
+  * \param absDeterminantThreshold Optional parameter controlling the invertibility check.
+  *                                The matrix will be declared invertible if the absolute value of its
+  *                                determinant is greater than this threshold.
+  *
+  * Example: \include MatrixBase_computeInverseWithCheck.cpp
+  * Output: \verbinclude MatrixBase_computeInverseWithCheck.out
+  *
+  * \sa inverse(), computeInverseAndDetWithCheck()
+  */
+template<typename Derived>
+template<typename ResultType>
+inline void MatrixBase<Derived>::computeInverseWithCheck(
+    ResultType& inverse,
+    bool& invertible,
+    const RealScalar& absDeterminantThreshold
+  ) const
+{
+  RealScalar determinant;
+  // i'd love to put some static assertions there, but SFINAE means that they have no effect...
+  eigen_assert(rows() == cols());
+  computeInverseAndDetWithCheck(inverse,determinant,invertible,absDeterminantThreshold);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_INVERSE_IMPL_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/LU/PartialPivLU.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/LU/PartialPivLU.h
new file mode 100644
index 00000000..d4396188
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/LU/PartialPivLU.h
@@ -0,0 +1,611 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PARTIALLU_H
+#define EIGEN_PARTIALLU_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename _MatrixType> struct traits<PartialPivLU<_MatrixType> >
+ : traits<_MatrixType>
+{
+  typedef MatrixXpr XprKind;
+  typedef SolverStorage StorageKind;
+  typedef traits<_MatrixType> BaseTraits;
+  enum {
+    Flags = BaseTraits::Flags & RowMajorBit,
+    CoeffReadCost = Dynamic
+  };
+};
+
+template<typename T,typename Derived>
+struct enable_if_ref;
+// {
+//   typedef Derived type;
+// };
+
+template<typename T,typename Derived>
+struct enable_if_ref<Ref<T>,Derived> {
+  typedef Derived type;
+};
+
+} // end namespace internal
+
+/** \ingroup LU_Module
+  *
+  * \class PartialPivLU
+  *
+  * \brief LU decomposition of a matrix with partial pivoting, and related features
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the LU decomposition
+  *
+  * This class represents a LU decomposition of a \b square \b invertible matrix, with partial pivoting: the matrix A
+  * is decomposed as A = PLU where L is unit-lower-triangular, U is upper-triangular, and P
+  * is a permutation matrix.
+  *
+  * Typically, partial pivoting LU decomposition is only considered numerically stable for square invertible
+  * matrices. Thus LAPACK's dgesv and dgesvx require the matrix to be square and invertible. The present class
+  * does the same. It will assert that the matrix is square, but it won't (actually it can't) check that the
+  * matrix is invertible: it is your task to check that you only use this decomposition on invertible matrices.
+  *
+  * The guaranteed safe alternative, working for all matrices, is the full pivoting LU decomposition, provided
+  * by class FullPivLU.
+  *
+  * This is \b not a rank-revealing LU decomposition. Many features are intentionally absent from this class,
+  * such as rank computation. If you need these features, use class FullPivLU.
+  *
+  * This LU decomposition is suitable to invert invertible matrices. It is what MatrixBase::inverse() uses
+  * in the general case.
+  * On the other hand, it is \b not suitable to determine whether a given matrix is invertible.
+  *
+  * The data of the LU decomposition can be directly accessed through the methods matrixLU(), permutationP().
+  *
+  * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
+  * 
+  * \sa MatrixBase::partialPivLu(), MatrixBase::determinant(), MatrixBase::inverse(), MatrixBase::computeInverse(), class FullPivLU
+  */
+template<typename _MatrixType> class PartialPivLU
+  : public SolverBase<PartialPivLU<_MatrixType> >
+{
+  public:
+
+    typedef _MatrixType MatrixType;
+    typedef SolverBase<PartialPivLU> Base;
+    EIGEN_GENERIC_PUBLIC_INTERFACE(PartialPivLU)
+    // FIXME StorageIndex defined in EIGEN_GENERIC_PUBLIC_INTERFACE should be int
+    enum {
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    typedef PermutationMatrix<RowsAtCompileTime, MaxRowsAtCompileTime> PermutationType;
+    typedef Transpositions<RowsAtCompileTime, MaxRowsAtCompileTime> TranspositionType;
+    typedef typename MatrixType::PlainObject PlainObject;
+
+    /**
+      * \brief Default Constructor.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via PartialPivLU::compute(const MatrixType&).
+      */
+    PartialPivLU();
+
+    /** \brief Default Constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem \a size.
+      * \sa PartialPivLU()
+      */
+    explicit PartialPivLU(Index size);
+
+    /** Constructor.
+      *
+      * \param matrix the matrix of which to compute the LU decomposition.
+      *
+      * \warning The matrix should have full rank (e.g. if it's square, it should be invertible).
+      * If you need to deal with non-full rank, use class FullPivLU instead.
+      */
+    template<typename InputType>
+    explicit PartialPivLU(const EigenBase<InputType>& matrix);
+
+    /** Constructor for \link InplaceDecomposition inplace decomposition \endlink
+      *
+      * \param matrix the matrix of which to compute the LU decomposition.
+      *
+      * \warning The matrix should have full rank (e.g. if it's square, it should be invertible).
+      * If you need to deal with non-full rank, use class FullPivLU instead.
+      */
+    template<typename InputType>
+    explicit PartialPivLU(EigenBase<InputType>& matrix);
+
+    template<typename InputType>
+    PartialPivLU& compute(const EigenBase<InputType>& matrix) {
+      m_lu = matrix.derived();
+      compute();
+      return *this;
+    }
+
+    /** \returns the LU decomposition matrix: the upper-triangular part is U, the
+      * unit-lower-triangular part is L (at least for square matrices; in the non-square
+      * case, special care is needed, see the documentation of class FullPivLU).
+      *
+      * \sa matrixL(), matrixU()
+      */
+    inline const MatrixType& matrixLU() const
+    {
+      eigen_assert(m_isInitialized && "PartialPivLU is not initialized.");
+      return m_lu;
+    }
+
+    /** \returns the permutation matrix P.
+      */
+    inline const PermutationType& permutationP() const
+    {
+      eigen_assert(m_isInitialized && "PartialPivLU is not initialized.");
+      return m_p;
+    }
+
+    /** This method returns the solution x to the equation Ax=b, where A is the matrix of which
+      * *this is the LU decomposition.
+      *
+      * \param b the right-hand-side of the equation to solve. Can be a vector or a matrix,
+      *          the only requirement in order for the equation to make sense is that
+      *          b.rows()==A.rows(), where A is the matrix of which *this is the LU decomposition.
+      *
+      * \returns the solution.
+      *
+      * Example: \include PartialPivLU_solve.cpp
+      * Output: \verbinclude PartialPivLU_solve.out
+      *
+      * Since this PartialPivLU class assumes anyway that the matrix A is invertible, the solution
+      * theoretically exists and is unique regardless of b.
+      *
+      * \sa TriangularView::solve(), inverse(), computeInverse()
+      */
+    // FIXME this is a copy-paste of the base-class member to add the isInitialized assertion.
+    template<typename Rhs>
+    inline const Solve<PartialPivLU, Rhs>
+    solve(const MatrixBase<Rhs>& b) const
+    {
+      eigen_assert(m_isInitialized && "PartialPivLU is not initialized.");
+      return Solve<PartialPivLU, Rhs>(*this, b.derived());
+    }
+
+    /** \returns an estimate of the reciprocal condition number of the matrix of which \c *this is
+        the LU decomposition.
+      */
+    inline RealScalar rcond() const
+    {
+      eigen_assert(m_isInitialized && "PartialPivLU is not initialized.");
+      return internal::rcond_estimate_helper(m_l1_norm, *this);
+    }
+
+    /** \returns the inverse of the matrix of which *this is the LU decomposition.
+      *
+      * \warning The matrix being decomposed here is assumed to be invertible. If you need to check for
+      *          invertibility, use class FullPivLU instead.
+      *
+      * \sa MatrixBase::inverse(), LU::inverse()
+      */
+    inline const Inverse<PartialPivLU> inverse() const
+    {
+      eigen_assert(m_isInitialized && "PartialPivLU is not initialized.");
+      return Inverse<PartialPivLU>(*this);
+    }
+
+    /** \returns the determinant of the matrix of which
+      * *this is the LU decomposition. It has only linear complexity
+      * (that is, O(n) where n is the dimension of the square matrix)
+      * as the LU decomposition has already been computed.
+      *
+      * \note For fixed-size matrices of size up to 4, MatrixBase::determinant() offers
+      *       optimized paths.
+      *
+      * \warning a determinant can be very big or small, so for matrices
+      * of large enough dimension, there is a risk of overflow/underflow.
+      *
+      * \sa MatrixBase::determinant()
+      */
+    Scalar determinant() const;
+
+    MatrixType reconstructedMatrix() const;
+
+    inline Index rows() const { return m_lu.rows(); }
+    inline Index cols() const { return m_lu.cols(); }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename RhsType, typename DstType>
+    EIGEN_DEVICE_FUNC
+    void _solve_impl(const RhsType &rhs, DstType &dst) const {
+     /* The decomposition PA = LU can be rewritten as A = P^{-1} L U.
+      * So we proceed as follows:
+      * Step 1: compute c = Pb.
+      * Step 2: replace c by the solution x to Lx = c.
+      * Step 3: replace c by the solution x to Ux = c.
+      */
+
+      eigen_assert(rhs.rows() == m_lu.rows());
+
+      // Step 1
+      dst = permutationP() * rhs;
+
+      // Step 2
+      m_lu.template triangularView<UnitLower>().solveInPlace(dst);
+
+      // Step 3
+      m_lu.template triangularView<Upper>().solveInPlace(dst);
+    }
+
+    template<bool Conjugate, typename RhsType, typename DstType>
+    EIGEN_DEVICE_FUNC
+    void _solve_impl_transposed(const RhsType &rhs, DstType &dst) const {
+     /* The decomposition PA = LU can be rewritten as A = P^{-1} L U.
+      * So we proceed as follows:
+      * Step 1: compute c = Pb.
+      * Step 2: replace c by the solution x to Lx = c.
+      * Step 3: replace c by the solution x to Ux = c.
+      */
+
+      eigen_assert(rhs.rows() == m_lu.cols());
+
+      if (Conjugate) {
+        // Step 1
+        dst = m_lu.template triangularView<Upper>().adjoint().solve(rhs);
+        // Step 2
+        m_lu.template triangularView<UnitLower>().adjoint().solveInPlace(dst);
+      } else {
+        // Step 1
+        dst = m_lu.template triangularView<Upper>().transpose().solve(rhs);
+        // Step 2
+        m_lu.template triangularView<UnitLower>().transpose().solveInPlace(dst);
+      }
+      // Step 3
+      dst = permutationP().transpose() * dst;
+    }
+    #endif
+
+  protected:
+
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+    }
+
+    void compute();
+
+    MatrixType m_lu;
+    PermutationType m_p;
+    TranspositionType m_rowsTranspositions;
+    RealScalar m_l1_norm;
+    signed char m_det_p;
+    bool m_isInitialized;
+};
+
+template<typename MatrixType>
+PartialPivLU<MatrixType>::PartialPivLU()
+  : m_lu(),
+    m_p(),
+    m_rowsTranspositions(),
+    m_l1_norm(0),
+    m_det_p(0),
+    m_isInitialized(false)
+{
+}
+
+template<typename MatrixType>
+PartialPivLU<MatrixType>::PartialPivLU(Index size)
+  : m_lu(size, size),
+    m_p(size),
+    m_rowsTranspositions(size),
+    m_l1_norm(0),
+    m_det_p(0),
+    m_isInitialized(false)
+{
+}
+
+template<typename MatrixType>
+template<typename InputType>
+PartialPivLU<MatrixType>::PartialPivLU(const EigenBase<InputType>& matrix)
+  : m_lu(matrix.rows(),matrix.cols()),
+    m_p(matrix.rows()),
+    m_rowsTranspositions(matrix.rows()),
+    m_l1_norm(0),
+    m_det_p(0),
+    m_isInitialized(false)
+{
+  compute(matrix.derived());
+}
+
+template<typename MatrixType>
+template<typename InputType>
+PartialPivLU<MatrixType>::PartialPivLU(EigenBase<InputType>& matrix)
+  : m_lu(matrix.derived()),
+    m_p(matrix.rows()),
+    m_rowsTranspositions(matrix.rows()),
+    m_l1_norm(0),
+    m_det_p(0),
+    m_isInitialized(false)
+{
+  compute();
+}
+
+namespace internal {
+
+/** \internal This is the blocked version of fullpivlu_unblocked() */
+template<typename Scalar, int StorageOrder, typename PivIndex>
+struct partial_lu_impl
+{
+  // FIXME add a stride to Map, so that the following mapping becomes easier,
+  // another option would be to create an expression being able to automatically
+  // warp any Map, Matrix, and Block expressions as a unique type, but since that's exactly
+  // a Map + stride, why not adding a stride to Map, and convenient ctors from a Matrix,
+  // and Block.
+  typedef Map<Matrix<Scalar, Dynamic, Dynamic, StorageOrder> > MapLU;
+  typedef Block<MapLU, Dynamic, Dynamic> MatrixType;
+  typedef Block<MatrixType,Dynamic,Dynamic> BlockType;
+  typedef typename MatrixType::RealScalar RealScalar;
+
+  /** \internal performs the LU decomposition in-place of the matrix \a lu
+    * using an unblocked algorithm.
+    *
+    * In addition, this function returns the row transpositions in the
+    * vector \a row_transpositions which must have a size equal to the number
+    * of columns of the matrix \a lu, and an integer \a nb_transpositions
+    * which returns the actual number of transpositions.
+    *
+    * \returns The index of the first pivot which is exactly zero if any, or a negative number otherwise.
+    */
+  static Index unblocked_lu(MatrixType& lu, PivIndex* row_transpositions, PivIndex& nb_transpositions)
+  {
+    typedef scalar_score_coeff_op<Scalar> Scoring;
+    typedef typename Scoring::result_type Score;
+    const Index rows = lu.rows();
+    const Index cols = lu.cols();
+    const Index size = (std::min)(rows,cols);
+    nb_transpositions = 0;
+    Index first_zero_pivot = -1;
+    for(Index k = 0; k < size; ++k)
+    {
+      Index rrows = rows-k-1;
+      Index rcols = cols-k-1;
+
+      Index row_of_biggest_in_col;
+      Score biggest_in_corner
+        = lu.col(k).tail(rows-k).unaryExpr(Scoring()).maxCoeff(&row_of_biggest_in_col);
+      row_of_biggest_in_col += k;
+
+      row_transpositions[k] = PivIndex(row_of_biggest_in_col);
+
+      if(biggest_in_corner != Score(0))
+      {
+        if(k != row_of_biggest_in_col)
+        {
+          lu.row(k).swap(lu.row(row_of_biggest_in_col));
+          ++nb_transpositions;
+        }
+
+        // FIXME shall we introduce a safe quotient expression in cas 1/lu.coeff(k,k)
+        // overflow but not the actual quotient?
+        lu.col(k).tail(rrows) /= lu.coeff(k,k);
+      }
+      else if(first_zero_pivot==-1)
+      {
+        // the pivot is exactly zero, we record the index of the first pivot which is exactly 0,
+        // and continue the factorization such we still have A = PLU
+        first_zero_pivot = k;
+      }
+
+      if(k<rows-1)
+        lu.bottomRightCorner(rrows,rcols).noalias() -= lu.col(k).tail(rrows) * lu.row(k).tail(rcols);
+    }
+    return first_zero_pivot;
+  }
+
+  /** \internal performs the LU decomposition in-place of the matrix represented
+    * by the variables \a rows, \a cols, \a lu_data, and \a lu_stride using a
+    * recursive, blocked algorithm.
+    *
+    * In addition, this function returns the row transpositions in the
+    * vector \a row_transpositions which must have a size equal to the number
+    * of columns of the matrix \a lu, and an integer \a nb_transpositions
+    * which returns the actual number of transpositions.
+    *
+    * \returns The index of the first pivot which is exactly zero if any, or a negative number otherwise.
+    *
+    * \note This very low level interface using pointers, etc. is to:
+    *   1 - reduce the number of instanciations to the strict minimum
+    *   2 - avoid infinite recursion of the instanciations with Block<Block<Block<...> > >
+    */
+  static Index blocked_lu(Index rows, Index cols, Scalar* lu_data, Index luStride, PivIndex* row_transpositions, PivIndex& nb_transpositions, Index maxBlockSize=256)
+  {
+    MapLU lu1(lu_data,StorageOrder==RowMajor?rows:luStride,StorageOrder==RowMajor?luStride:cols);
+    MatrixType lu(lu1,0,0,rows,cols);
+
+    const Index size = (std::min)(rows,cols);
+
+    // if the matrix is too small, no blocking:
+    if(size<=16)
+    {
+      return unblocked_lu(lu, row_transpositions, nb_transpositions);
+    }
+
+    // automatically adjust the number of subdivisions to the size
+    // of the matrix so that there is enough sub blocks:
+    Index blockSize;
+    {
+      blockSize = size/8;
+      blockSize = (blockSize/16)*16;
+      blockSize = (std::min)((std::max)(blockSize,Index(8)), maxBlockSize);
+    }
+
+    nb_transpositions = 0;
+    Index first_zero_pivot = -1;
+    for(Index k = 0; k < size; k+=blockSize)
+    {
+      Index bs = (std::min)(size-k,blockSize); // actual size of the block
+      Index trows = rows - k - bs; // trailing rows
+      Index tsize = size - k - bs; // trailing size
+
+      // partition the matrix:
+      //                          A00 | A01 | A02
+      // lu  = A_0 | A_1 | A_2 =  A10 | A11 | A12
+      //                          A20 | A21 | A22
+      BlockType A_0(lu,0,0,rows,k);
+      BlockType A_2(lu,0,k+bs,rows,tsize);
+      BlockType A11(lu,k,k,bs,bs);
+      BlockType A12(lu,k,k+bs,bs,tsize);
+      BlockType A21(lu,k+bs,k,trows,bs);
+      BlockType A22(lu,k+bs,k+bs,trows,tsize);
+
+      PivIndex nb_transpositions_in_panel;
+      // recursively call the blocked LU algorithm on [A11^T A21^T]^T
+      // with a very small blocking size:
+      Index ret = blocked_lu(trows+bs, bs, &lu.coeffRef(k,k), luStride,
+                   row_transpositions+k, nb_transpositions_in_panel, 16);
+      if(ret>=0 && first_zero_pivot==-1)
+        first_zero_pivot = k+ret;
+
+      nb_transpositions += nb_transpositions_in_panel;
+      // update permutations and apply them to A_0
+      for(Index i=k; i<k+bs; ++i)
+      {
+        Index piv = (row_transpositions[i] += internal::convert_index<PivIndex>(k));
+        A_0.row(i).swap(A_0.row(piv));
+      }
+
+      if(trows)
+      {
+        // apply permutations to A_2
+        for(Index i=k;i<k+bs; ++i)
+          A_2.row(i).swap(A_2.row(row_transpositions[i]));
+
+        // A12 = A11^-1 A12
+        A11.template triangularView<UnitLower>().solveInPlace(A12);
+
+        A22.noalias() -= A21 * A12;
+      }
+    }
+    return first_zero_pivot;
+  }
+};
+
+/** \internal performs the LU decomposition with partial pivoting in-place.
+  */
+template<typename MatrixType, typename TranspositionType>
+void partial_lu_inplace(MatrixType& lu, TranspositionType& row_transpositions, typename TranspositionType::StorageIndex& nb_transpositions)
+{
+  eigen_assert(lu.cols() == row_transpositions.size());
+  eigen_assert((&row_transpositions.coeffRef(1)-&row_transpositions.coeffRef(0)) == 1);
+
+  partial_lu_impl
+    <typename MatrixType::Scalar, MatrixType::Flags&RowMajorBit?RowMajor:ColMajor, typename TranspositionType::StorageIndex>
+    ::blocked_lu(lu.rows(), lu.cols(), &lu.coeffRef(0,0), lu.outerStride(), &row_transpositions.coeffRef(0), nb_transpositions);
+}
+
+} // end namespace internal
+
+template<typename MatrixType>
+void PartialPivLU<MatrixType>::compute()
+{
+  check_template_parameters();
+
+  // the row permutation is stored as int indices, so just to be sure:
+  eigen_assert(m_lu.rows()<NumTraits<int>::highest());
+
+  m_l1_norm = m_lu.cwiseAbs().colwise().sum().maxCoeff();
+
+  eigen_assert(m_lu.rows() == m_lu.cols() && "PartialPivLU is only for square (and moreover invertible) matrices");
+  const Index size = m_lu.rows();
+
+  m_rowsTranspositions.resize(size);
+
+  typename TranspositionType::StorageIndex nb_transpositions;
+  internal::partial_lu_inplace(m_lu, m_rowsTranspositions, nb_transpositions);
+  m_det_p = (nb_transpositions%2) ? -1 : 1;
+
+  m_p = m_rowsTranspositions;
+
+  m_isInitialized = true;
+}
+
+template<typename MatrixType>
+typename PartialPivLU<MatrixType>::Scalar PartialPivLU<MatrixType>::determinant() const
+{
+  eigen_assert(m_isInitialized && "PartialPivLU is not initialized.");
+  return Scalar(m_det_p) * m_lu.diagonal().prod();
+}
+
+/** \returns the matrix represented by the decomposition,
+ * i.e., it returns the product: P^{-1} L U.
+ * This function is provided for debug purpose. */
+template<typename MatrixType>
+MatrixType PartialPivLU<MatrixType>::reconstructedMatrix() const
+{
+  eigen_assert(m_isInitialized && "LU is not initialized.");
+  // LU
+  MatrixType res = m_lu.template triangularView<UnitLower>().toDenseMatrix()
+                 * m_lu.template triangularView<Upper>();
+
+  // P^{-1}(LU)
+  res = m_p.inverse() * res;
+
+  return res;
+}
+
+/***** Implementation details *****************************************************/
+
+namespace internal {
+
+/***** Implementation of inverse() *****************************************************/
+template<typename DstXprType, typename MatrixType>
+struct Assignment<DstXprType, Inverse<PartialPivLU<MatrixType> >, internal::assign_op<typename DstXprType::Scalar,typename PartialPivLU<MatrixType>::Scalar>, Dense2Dense>
+{
+  typedef PartialPivLU<MatrixType> LuType;
+  typedef Inverse<LuType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename LuType::Scalar> &)
+  {
+    dst = src.nestedExpression().solve(MatrixType::Identity(src.rows(), src.cols()));
+  }
+};
+} // end namespace internal
+
+/******** MatrixBase methods *******/
+
+/** \lu_module
+  *
+  * \return the partial-pivoting LU decomposition of \c *this.
+  *
+  * \sa class PartialPivLU
+  */
+template<typename Derived>
+inline const PartialPivLU<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::partialPivLu() const
+{
+  return PartialPivLU<PlainObject>(eval());
+}
+
+/** \lu_module
+  *
+  * Synonym of partialPivLu().
+  *
+  * \return the partial-pivoting LU decomposition of \c *this.
+  *
+  * \sa class PartialPivLU
+  */
+template<typename Derived>
+inline const PartialPivLU<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::lu() const
+{
+  return PartialPivLU<PlainObject>(eval());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_PARTIALLU_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/LU/PartialPivLU_LAPACKE.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/LU/PartialPivLU_LAPACKE.h
new file mode 100644
index 00000000..755168a9
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/LU/PartialPivLU_LAPACKE.h
@@ -0,0 +1,83 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to LAPACKe
+ *     LU decomposition with partial pivoting based on LAPACKE_?getrf function.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_PARTIALLU_LAPACK_H
+#define EIGEN_PARTIALLU_LAPACK_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/** \internal Specialization for the data types supported by LAPACKe */
+
+#define EIGEN_LAPACKE_LU_PARTPIV(EIGTYPE, LAPACKE_TYPE, LAPACKE_PREFIX) \
+template<int StorageOrder> \
+struct partial_lu_impl<EIGTYPE, StorageOrder, lapack_int> \
+{ \
+  /* \internal performs the LU decomposition in-place of the matrix represented */ \
+  static lapack_int blocked_lu(Index rows, Index cols, EIGTYPE* lu_data, Index luStride, lapack_int* row_transpositions, lapack_int& nb_transpositions, lapack_int maxBlockSize=256) \
+  { \
+    EIGEN_UNUSED_VARIABLE(maxBlockSize);\
+    lapack_int matrix_order, first_zero_pivot; \
+    lapack_int m, n, lda, *ipiv, info; \
+    EIGTYPE* a; \
+/* Set up parameters for ?getrf */ \
+    matrix_order = StorageOrder==RowMajor ? LAPACK_ROW_MAJOR : LAPACK_COL_MAJOR; \
+    lda = convert_index<lapack_int>(luStride); \
+    a = lu_data; \
+    ipiv = row_transpositions; \
+    m = convert_index<lapack_int>(rows); \
+    n = convert_index<lapack_int>(cols); \
+    nb_transpositions = 0; \
+\
+    info = LAPACKE_##LAPACKE_PREFIX##getrf( matrix_order, m, n, (LAPACKE_TYPE*)a, lda, ipiv ); \
+\
+    for(int i=0;i<m;i++) { ipiv[i]--; if (ipiv[i]!=i) nb_transpositions++; } \
+\
+    eigen_assert(info >= 0); \
+/* something should be done with nb_transpositions */ \
+\
+    first_zero_pivot = info; \
+    return first_zero_pivot; \
+  } \
+};
+
+EIGEN_LAPACKE_LU_PARTPIV(double, double, d)
+EIGEN_LAPACKE_LU_PARTPIV(float, float, s)
+EIGEN_LAPACKE_LU_PARTPIV(dcomplex, lapack_complex_double, z)
+EIGEN_LAPACKE_LU_PARTPIV(scomplex, lapack_complex_float,  c)
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_PARTIALLU_LAPACK_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/LU/arch/Inverse_SSE.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/LU/arch/Inverse_SSE.h
new file mode 100644
index 00000000..ebb64a62
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/LU/arch/Inverse_SSE.h
@@ -0,0 +1,338 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2001 Intel Corporation
+// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+// The SSE code for the 4x4 float and double matrix inverse in this file
+// comes from the following Intel's library:
+// http://software.intel.com/en-us/articles/optimized-matrix-library-for-use-with-the-intel-pentiumr-4-processors-sse2-instructions/
+//
+// Here is the respective copyright and license statement:
+//
+//   Copyright (c) 2001 Intel Corporation.
+//
+// Permition is granted to use, copy, distribute and prepare derivative works
+// of this library for any purpose and without fee, provided, that the above
+// copyright notice and this statement appear in all copies.
+// Intel makes no representations about the suitability of this software for
+// any purpose, and specifically disclaims all warranties.
+// See LEGAL.TXT for all the legal information.
+
+#ifndef EIGEN_INVERSE_SSE_H
+#define EIGEN_INVERSE_SSE_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename MatrixType, typename ResultType>
+struct compute_inverse_size4<Architecture::SSE, float, MatrixType, ResultType>
+{
+  enum {
+    MatrixAlignment     = traits<MatrixType>::Alignment,
+    ResultAlignment     = traits<ResultType>::Alignment,
+    StorageOrdersMatch  = (MatrixType::Flags&RowMajorBit) == (ResultType::Flags&RowMajorBit)
+  };
+  typedef typename conditional<(MatrixType::Flags&LinearAccessBit),MatrixType const &,typename MatrixType::PlainObject>::type ActualMatrixType;
+  
+  static void run(const MatrixType& mat, ResultType& result)
+  {
+    ActualMatrixType matrix(mat);
+    EIGEN_ALIGN16 const unsigned int _Sign_PNNP[4] = { 0x00000000, 0x80000000, 0x80000000, 0x00000000 };
+
+    // Load the full matrix into registers
+    __m128 _L1 = matrix.template packet<MatrixAlignment>( 0);
+    __m128 _L2 = matrix.template packet<MatrixAlignment>( 4);
+    __m128 _L3 = matrix.template packet<MatrixAlignment>( 8);
+    __m128 _L4 = matrix.template packet<MatrixAlignment>(12);
+
+    // The inverse is calculated using "Divide and Conquer" technique. The
+    // original matrix is divide into four 2x2 sub-matrices. Since each
+    // register holds four matrix element, the smaller matrices are
+    // represented as a registers. Hence we get a better locality of the
+    // calculations.
+
+    __m128 A, B, C, D; // the four sub-matrices
+    if(!StorageOrdersMatch)
+    {
+      A = _mm_unpacklo_ps(_L1, _L2);
+      B = _mm_unpacklo_ps(_L3, _L4);
+      C = _mm_unpackhi_ps(_L1, _L2);
+      D = _mm_unpackhi_ps(_L3, _L4);
+    }
+    else
+    {
+      A = _mm_movelh_ps(_L1, _L2);
+      B = _mm_movehl_ps(_L2, _L1);
+      C = _mm_movelh_ps(_L3, _L4);
+      D = _mm_movehl_ps(_L4, _L3);
+    }
+
+    __m128 iA, iB, iC, iD,                 // partial inverse of the sub-matrices
+            DC, AB;
+    __m128 dA, dB, dC, dD;                 // determinant of the sub-matrices
+    __m128 det, d, d1, d2;
+    __m128 rd;                             // reciprocal of the determinant
+
+    //  AB = A# * B
+    AB = _mm_mul_ps(_mm_shuffle_ps(A,A,0x0F), B);
+    AB = _mm_sub_ps(AB,_mm_mul_ps(_mm_shuffle_ps(A,A,0xA5), _mm_shuffle_ps(B,B,0x4E)));
+    //  DC = D# * C
+    DC = _mm_mul_ps(_mm_shuffle_ps(D,D,0x0F), C);
+    DC = _mm_sub_ps(DC,_mm_mul_ps(_mm_shuffle_ps(D,D,0xA5), _mm_shuffle_ps(C,C,0x4E)));
+
+    //  dA = |A|
+    dA = _mm_mul_ps(_mm_shuffle_ps(A, A, 0x5F),A);
+    dA = _mm_sub_ss(dA, _mm_movehl_ps(dA,dA));
+    //  dB = |B|
+    dB = _mm_mul_ps(_mm_shuffle_ps(B, B, 0x5F),B);
+    dB = _mm_sub_ss(dB, _mm_movehl_ps(dB,dB));
+
+    //  dC = |C|
+    dC = _mm_mul_ps(_mm_shuffle_ps(C, C, 0x5F),C);
+    dC = _mm_sub_ss(dC, _mm_movehl_ps(dC,dC));
+    //  dD = |D|
+    dD = _mm_mul_ps(_mm_shuffle_ps(D, D, 0x5F),D);
+    dD = _mm_sub_ss(dD, _mm_movehl_ps(dD,dD));
+
+    //  d = trace(AB*DC) = trace(A#*B*D#*C)
+    d = _mm_mul_ps(_mm_shuffle_ps(DC,DC,0xD8),AB);
+
+    //  iD = C*A#*B
+    iD = _mm_mul_ps(_mm_shuffle_ps(C,C,0xA0), _mm_movelh_ps(AB,AB));
+    iD = _mm_add_ps(iD,_mm_mul_ps(_mm_shuffle_ps(C,C,0xF5), _mm_movehl_ps(AB,AB)));
+    //  iA = B*D#*C
+    iA = _mm_mul_ps(_mm_shuffle_ps(B,B,0xA0), _mm_movelh_ps(DC,DC));
+    iA = _mm_add_ps(iA,_mm_mul_ps(_mm_shuffle_ps(B,B,0xF5), _mm_movehl_ps(DC,DC)));
+
+    //  d = trace(AB*DC) = trace(A#*B*D#*C) [continue]
+    d  = _mm_add_ps(d, _mm_movehl_ps(d, d));
+    d  = _mm_add_ss(d, _mm_shuffle_ps(d, d, 1));
+    d1 = _mm_mul_ss(dA,dD);
+    d2 = _mm_mul_ss(dB,dC);
+
+    //  iD = D*|A| - C*A#*B
+    iD = _mm_sub_ps(_mm_mul_ps(D,_mm_shuffle_ps(dA,dA,0)), iD);
+
+    //  iA = A*|D| - B*D#*C;
+    iA = _mm_sub_ps(_mm_mul_ps(A,_mm_shuffle_ps(dD,dD,0)), iA);
+
+    //  det = |A|*|D| + |B|*|C| - trace(A#*B*D#*C)
+    det = _mm_sub_ss(_mm_add_ss(d1,d2),d);
+    rd  = _mm_div_ss(_mm_set_ss(1.0f), det);
+
+//     #ifdef ZERO_SINGULAR
+//         rd = _mm_and_ps(_mm_cmpneq_ss(det,_mm_setzero_ps()), rd);
+//     #endif
+
+    //  iB = D * (A#B)# = D*B#*A
+    iB = _mm_mul_ps(D, _mm_shuffle_ps(AB,AB,0x33));
+    iB = _mm_sub_ps(iB, _mm_mul_ps(_mm_shuffle_ps(D,D,0xB1), _mm_shuffle_ps(AB,AB,0x66)));
+    //  iC = A * (D#C)# = A*C#*D
+    iC = _mm_mul_ps(A, _mm_shuffle_ps(DC,DC,0x33));
+    iC = _mm_sub_ps(iC, _mm_mul_ps(_mm_shuffle_ps(A,A,0xB1), _mm_shuffle_ps(DC,DC,0x66)));
+
+    rd = _mm_shuffle_ps(rd,rd,0);
+    rd = _mm_xor_ps(rd, _mm_load_ps((float*)_Sign_PNNP));
+
+    //  iB = C*|B| - D*B#*A
+    iB = _mm_sub_ps(_mm_mul_ps(C,_mm_shuffle_ps(dB,dB,0)), iB);
+
+    //  iC = B*|C| - A*C#*D;
+    iC = _mm_sub_ps(_mm_mul_ps(B,_mm_shuffle_ps(dC,dC,0)), iC);
+
+    //  iX = iX / det
+    iA = _mm_mul_ps(rd,iA);
+    iB = _mm_mul_ps(rd,iB);
+    iC = _mm_mul_ps(rd,iC);
+    iD = _mm_mul_ps(rd,iD);
+
+    Index res_stride = result.outerStride();
+    float* res = result.data();
+    pstoret<float, Packet4f, ResultAlignment>(res+0,            _mm_shuffle_ps(iA,iB,0x77));
+    pstoret<float, Packet4f, ResultAlignment>(res+res_stride,   _mm_shuffle_ps(iA,iB,0x22));
+    pstoret<float, Packet4f, ResultAlignment>(res+2*res_stride, _mm_shuffle_ps(iC,iD,0x77));
+    pstoret<float, Packet4f, ResultAlignment>(res+3*res_stride, _mm_shuffle_ps(iC,iD,0x22));
+  }
+
+};
+
+template<typename MatrixType, typename ResultType>
+struct compute_inverse_size4<Architecture::SSE, double, MatrixType, ResultType>
+{
+  enum {
+    MatrixAlignment     = traits<MatrixType>::Alignment,
+    ResultAlignment     = traits<ResultType>::Alignment,
+    StorageOrdersMatch  = (MatrixType::Flags&RowMajorBit) == (ResultType::Flags&RowMajorBit)
+  };
+  typedef typename conditional<(MatrixType::Flags&LinearAccessBit),MatrixType const &,typename MatrixType::PlainObject>::type ActualMatrixType;
+  
+  static void run(const MatrixType& mat, ResultType& result)
+  {
+    ActualMatrixType matrix(mat);
+    const __m128d _Sign_NP = _mm_castsi128_pd(_mm_set_epi32(0x0,0x0,0x80000000,0x0));
+    const __m128d _Sign_PN = _mm_castsi128_pd(_mm_set_epi32(0x80000000,0x0,0x0,0x0));
+
+    // The inverse is calculated using "Divide and Conquer" technique. The
+    // original matrix is divide into four 2x2 sub-matrices. Since each
+    // register of the matrix holds two elements, the smaller matrices are
+    // consisted of two registers. Hence we get a better locality of the
+    // calculations.
+
+    // the four sub-matrices
+    __m128d A1, A2, B1, B2, C1, C2, D1, D2;
+    
+    if(StorageOrdersMatch)
+    {
+      A1 = matrix.template packet<MatrixAlignment>( 0); B1 = matrix.template packet<MatrixAlignment>( 2);
+      A2 = matrix.template packet<MatrixAlignment>( 4); B2 = matrix.template packet<MatrixAlignment>( 6);
+      C1 = matrix.template packet<MatrixAlignment>( 8); D1 = matrix.template packet<MatrixAlignment>(10);
+      C2 = matrix.template packet<MatrixAlignment>(12); D2 = matrix.template packet<MatrixAlignment>(14);
+    }
+    else
+    {
+      __m128d tmp;
+      A1 = matrix.template packet<MatrixAlignment>( 0); C1 = matrix.template packet<MatrixAlignment>( 2);
+      A2 = matrix.template packet<MatrixAlignment>( 4); C2 = matrix.template packet<MatrixAlignment>( 6);
+      tmp = A1;
+      A1 = _mm_unpacklo_pd(A1,A2);
+      A2 = _mm_unpackhi_pd(tmp,A2);
+      tmp = C1;
+      C1 = _mm_unpacklo_pd(C1,C2);
+      C2 = _mm_unpackhi_pd(tmp,C2);
+      
+      B1 = matrix.template packet<MatrixAlignment>( 8); D1 = matrix.template packet<MatrixAlignment>(10);
+      B2 = matrix.template packet<MatrixAlignment>(12); D2 = matrix.template packet<MatrixAlignment>(14);
+      tmp = B1;
+      B1 = _mm_unpacklo_pd(B1,B2);
+      B2 = _mm_unpackhi_pd(tmp,B2);
+      tmp = D1;
+      D1 = _mm_unpacklo_pd(D1,D2);
+      D2 = _mm_unpackhi_pd(tmp,D2);
+    }
+    
+    __m128d iA1, iA2, iB1, iB2, iC1, iC2, iD1, iD2,     // partial invese of the sub-matrices
+            DC1, DC2, AB1, AB2;
+    __m128d dA, dB, dC, dD;     // determinant of the sub-matrices
+    __m128d det, d1, d2, rd;
+
+    //  dA = |A|
+    dA = _mm_shuffle_pd(A2, A2, 1);
+    dA = _mm_mul_pd(A1, dA);
+    dA = _mm_sub_sd(dA, _mm_shuffle_pd(dA,dA,3));
+    //  dB = |B|
+    dB = _mm_shuffle_pd(B2, B2, 1);
+    dB = _mm_mul_pd(B1, dB);
+    dB = _mm_sub_sd(dB, _mm_shuffle_pd(dB,dB,3));
+
+    //  AB = A# * B
+    AB1 = _mm_mul_pd(B1, _mm_shuffle_pd(A2,A2,3));
+    AB2 = _mm_mul_pd(B2, _mm_shuffle_pd(A1,A1,0));
+    AB1 = _mm_sub_pd(AB1, _mm_mul_pd(B2, _mm_shuffle_pd(A1,A1,3)));
+    AB2 = _mm_sub_pd(AB2, _mm_mul_pd(B1, _mm_shuffle_pd(A2,A2,0)));
+
+    //  dC = |C|
+    dC = _mm_shuffle_pd(C2, C2, 1);
+    dC = _mm_mul_pd(C1, dC);
+    dC = _mm_sub_sd(dC, _mm_shuffle_pd(dC,dC,3));
+    //  dD = |D|
+    dD = _mm_shuffle_pd(D2, D2, 1);
+    dD = _mm_mul_pd(D1, dD);
+    dD = _mm_sub_sd(dD, _mm_shuffle_pd(dD,dD,3));
+
+    //  DC = D# * C
+    DC1 = _mm_mul_pd(C1, _mm_shuffle_pd(D2,D2,3));
+    DC2 = _mm_mul_pd(C2, _mm_shuffle_pd(D1,D1,0));
+    DC1 = _mm_sub_pd(DC1, _mm_mul_pd(C2, _mm_shuffle_pd(D1,D1,3)));
+    DC2 = _mm_sub_pd(DC2, _mm_mul_pd(C1, _mm_shuffle_pd(D2,D2,0)));
+
+    //  rd = trace(AB*DC) = trace(A#*B*D#*C)
+    d1 = _mm_mul_pd(AB1, _mm_shuffle_pd(DC1, DC2, 0));
+    d2 = _mm_mul_pd(AB2, _mm_shuffle_pd(DC1, DC2, 3));
+    rd = _mm_add_pd(d1, d2);
+    rd = _mm_add_sd(rd, _mm_shuffle_pd(rd, rd,3));
+
+    //  iD = C*A#*B
+    iD1 = _mm_mul_pd(AB1, _mm_shuffle_pd(C1,C1,0));
+    iD2 = _mm_mul_pd(AB1, _mm_shuffle_pd(C2,C2,0));
+    iD1 = _mm_add_pd(iD1, _mm_mul_pd(AB2, _mm_shuffle_pd(C1,C1,3)));
+    iD2 = _mm_add_pd(iD2, _mm_mul_pd(AB2, _mm_shuffle_pd(C2,C2,3)));
+
+    //  iA = B*D#*C
+    iA1 = _mm_mul_pd(DC1, _mm_shuffle_pd(B1,B1,0));
+    iA2 = _mm_mul_pd(DC1, _mm_shuffle_pd(B2,B2,0));
+    iA1 = _mm_add_pd(iA1, _mm_mul_pd(DC2, _mm_shuffle_pd(B1,B1,3)));
+    iA2 = _mm_add_pd(iA2, _mm_mul_pd(DC2, _mm_shuffle_pd(B2,B2,3)));
+
+    //  iD = D*|A| - C*A#*B
+    dA = _mm_shuffle_pd(dA,dA,0);
+    iD1 = _mm_sub_pd(_mm_mul_pd(D1, dA), iD1);
+    iD2 = _mm_sub_pd(_mm_mul_pd(D2, dA), iD2);
+
+    //  iA = A*|D| - B*D#*C;
+    dD = _mm_shuffle_pd(dD,dD,0);
+    iA1 = _mm_sub_pd(_mm_mul_pd(A1, dD), iA1);
+    iA2 = _mm_sub_pd(_mm_mul_pd(A2, dD), iA2);
+
+    d1 = _mm_mul_sd(dA, dD);
+    d2 = _mm_mul_sd(dB, dC);
+
+    //  iB = D * (A#B)# = D*B#*A
+    iB1 = _mm_mul_pd(D1, _mm_shuffle_pd(AB2,AB1,1));
+    iB2 = _mm_mul_pd(D2, _mm_shuffle_pd(AB2,AB1,1));
+    iB1 = _mm_sub_pd(iB1, _mm_mul_pd(_mm_shuffle_pd(D1,D1,1), _mm_shuffle_pd(AB2,AB1,2)));
+    iB2 = _mm_sub_pd(iB2, _mm_mul_pd(_mm_shuffle_pd(D2,D2,1), _mm_shuffle_pd(AB2,AB1,2)));
+
+    //  det = |A|*|D| + |B|*|C| - trace(A#*B*D#*C)
+    det = _mm_add_sd(d1, d2);
+    det = _mm_sub_sd(det, rd);
+
+    //  iC = A * (D#C)# = A*C#*D
+    iC1 = _mm_mul_pd(A1, _mm_shuffle_pd(DC2,DC1,1));
+    iC2 = _mm_mul_pd(A2, _mm_shuffle_pd(DC2,DC1,1));
+    iC1 = _mm_sub_pd(iC1, _mm_mul_pd(_mm_shuffle_pd(A1,A1,1), _mm_shuffle_pd(DC2,DC1,2)));
+    iC2 = _mm_sub_pd(iC2, _mm_mul_pd(_mm_shuffle_pd(A2,A2,1), _mm_shuffle_pd(DC2,DC1,2)));
+
+    rd = _mm_div_sd(_mm_set_sd(1.0), det);
+//     #ifdef ZERO_SINGULAR
+//         rd = _mm_and_pd(_mm_cmpneq_sd(det,_mm_setzero_pd()), rd);
+//     #endif
+    rd = _mm_shuffle_pd(rd,rd,0);
+
+    //  iB = C*|B| - D*B#*A
+    dB = _mm_shuffle_pd(dB,dB,0);
+    iB1 = _mm_sub_pd(_mm_mul_pd(C1, dB), iB1);
+    iB2 = _mm_sub_pd(_mm_mul_pd(C2, dB), iB2);
+
+    d1 = _mm_xor_pd(rd, _Sign_PN);
+    d2 = _mm_xor_pd(rd, _Sign_NP);
+
+    //  iC = B*|C| - A*C#*D;
+    dC = _mm_shuffle_pd(dC,dC,0);
+    iC1 = _mm_sub_pd(_mm_mul_pd(B1, dC), iC1);
+    iC2 = _mm_sub_pd(_mm_mul_pd(B2, dC), iC2);
+
+    Index res_stride = result.outerStride();
+    double* res = result.data();
+    pstoret<double, Packet2d, ResultAlignment>(res+0,             _mm_mul_pd(_mm_shuffle_pd(iA2, iA1, 3), d1));
+    pstoret<double, Packet2d, ResultAlignment>(res+res_stride,    _mm_mul_pd(_mm_shuffle_pd(iA2, iA1, 0), d2));
+    pstoret<double, Packet2d, ResultAlignment>(res+2,             _mm_mul_pd(_mm_shuffle_pd(iB2, iB1, 3), d1));
+    pstoret<double, Packet2d, ResultAlignment>(res+res_stride+2,  _mm_mul_pd(_mm_shuffle_pd(iB2, iB1, 0), d2));
+    pstoret<double, Packet2d, ResultAlignment>(res+2*res_stride,  _mm_mul_pd(_mm_shuffle_pd(iC2, iC1, 3), d1));
+    pstoret<double, Packet2d, ResultAlignment>(res+3*res_stride,  _mm_mul_pd(_mm_shuffle_pd(iC2, iC1, 0), d2));
+    pstoret<double, Packet2d, ResultAlignment>(res+2*res_stride+2,_mm_mul_pd(_mm_shuffle_pd(iD2, iD1, 3), d1));
+    pstoret<double, Packet2d, ResultAlignment>(res+3*res_stride+2,_mm_mul_pd(_mm_shuffle_pd(iD2, iD1, 0), d2));
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_INVERSE_SSE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/MetisSupport/MetisSupport.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/MetisSupport/MetisSupport.h
new file mode 100644
index 00000000..4c15304a
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/MetisSupport/MetisSupport.h
@@ -0,0 +1,137 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#ifndef METIS_SUPPORT_H
+#define METIS_SUPPORT_H
+
+namespace Eigen {
+/**
+ * Get the fill-reducing ordering from the METIS package
+ * 
+ * If A is the original matrix and Ap is the permuted matrix, 
+ * the fill-reducing permutation is defined as follows :
+ * Row (column) i of A is the matperm(i) row (column) of Ap. 
+ * WARNING: As computed by METIS, this corresponds to the vector iperm (instead of perm)
+ */
+template <typename StorageIndex>
+class MetisOrdering
+{
+public:
+  typedef PermutationMatrix<Dynamic,Dynamic,StorageIndex> PermutationType;
+  typedef Matrix<StorageIndex,Dynamic,1> IndexVector; 
+  
+  template <typename MatrixType>
+  void get_symmetrized_graph(const MatrixType& A)
+  {
+    Index m = A.cols(); 
+    eigen_assert((A.rows() == A.cols()) && "ONLY FOR SQUARED MATRICES");
+    // Get the transpose of the input matrix 
+    MatrixType At = A.transpose(); 
+    // Get the number of nonzeros elements in each row/col of At+A
+    Index TotNz = 0; 
+    IndexVector visited(m); 
+    visited.setConstant(-1); 
+    for (StorageIndex j = 0; j < m; j++)
+    {
+      // Compute the union structure of of A(j,:) and At(j,:)
+      visited(j) = j; // Do not include the diagonal element
+      // Get the nonzeros in row/column j of A
+      for (typename MatrixType::InnerIterator it(A, j); it; ++it)
+      {
+        Index idx = it.index(); // Get the row index (for column major) or column index (for row major)
+        if (visited(idx) != j ) 
+        {
+          visited(idx) = j; 
+          ++TotNz; 
+        }
+      }
+      //Get the nonzeros in row/column j of At
+      for (typename MatrixType::InnerIterator it(At, j); it; ++it)
+      {
+        Index idx = it.index(); 
+        if(visited(idx) != j)
+        {
+          visited(idx) = j; 
+          ++TotNz; 
+        }
+      }
+    }
+    // Reserve place for A + At
+    m_indexPtr.resize(m+1);
+    m_innerIndices.resize(TotNz); 
+
+    // Now compute the real adjacency list of each column/row 
+    visited.setConstant(-1); 
+    StorageIndex CurNz = 0; 
+    for (StorageIndex j = 0; j < m; j++)
+    {
+      m_indexPtr(j) = CurNz; 
+      
+      visited(j) = j; // Do not include the diagonal element
+      // Add the pattern of row/column j of A to A+At
+      for (typename MatrixType::InnerIterator it(A,j); it; ++it)
+      {
+        StorageIndex idx = it.index(); // Get the row index (for column major) or column index (for row major)
+        if (visited(idx) != j ) 
+        {
+          visited(idx) = j; 
+          m_innerIndices(CurNz) = idx; 
+          CurNz++; 
+        }
+      }
+      //Add the pattern of row/column j of At to A+At
+      for (typename MatrixType::InnerIterator it(At, j); it; ++it)
+      {
+        StorageIndex idx = it.index(); 
+        if(visited(idx) != j)
+        {
+          visited(idx) = j; 
+          m_innerIndices(CurNz) = idx; 
+          ++CurNz; 
+        }
+      }
+    }
+    m_indexPtr(m) = CurNz;    
+  }
+  
+  template <typename MatrixType>
+  void operator() (const MatrixType& A, PermutationType& matperm)
+  {
+     StorageIndex m = internal::convert_index<StorageIndex>(A.cols()); // must be StorageIndex, because it is passed by address to METIS
+     IndexVector perm(m),iperm(m); 
+    // First, symmetrize the matrix graph. 
+     get_symmetrized_graph(A); 
+     int output_error;
+     
+     // Call the fill-reducing routine from METIS 
+     output_error = METIS_NodeND(&m, m_indexPtr.data(), m_innerIndices.data(), NULL, NULL, perm.data(), iperm.data());
+     
+    if(output_error != METIS_OK) 
+    {
+      //FIXME The ordering interface should define a class of possible errors 
+     std::cerr << "ERROR WHILE CALLING THE METIS PACKAGE \n"; 
+     return; 
+    }
+    
+    // Get the fill-reducing permutation 
+    //NOTE:  If Ap is the permuted matrix then perm and iperm vectors are defined as follows 
+    // Row (column) i of Ap is the perm(i) row(column) of A, and row (column) i of A is the iperm(i) row(column) of Ap
+    
+     matperm.resize(m);
+     for (int j = 0; j < m; j++)
+       matperm.indices()(iperm(j)) = j;
+   
+  }
+  
+  protected:
+    IndexVector m_indexPtr; // Pointer to the adjacenccy list of each row/column
+    IndexVector m_innerIndices; // Adjacency list 
+};
+
+}// end namespace eigen 
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/OrderingMethods/Amd.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/OrderingMethods/Amd.h
new file mode 100644
index 00000000..f91ecb24
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/OrderingMethods/Amd.h
@@ -0,0 +1,445 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+
+/*
+
+NOTE: this routine has been adapted from the CSparse library:
+
+Copyright (c) 2006, Timothy A. Davis.
+http://www.suitesparse.com
+
+CSparse is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+CSparse is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this Module; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+*/
+
+#include "../Core/util/NonMPL2.h"
+
+#ifndef EIGEN_SPARSE_AMD_H
+#define EIGEN_SPARSE_AMD_H
+
+namespace Eigen { 
+
+namespace internal {
+  
+template<typename T> inline T amd_flip(const T& i) { return -i-2; }
+template<typename T> inline T amd_unflip(const T& i) { return i<0 ? amd_flip(i) : i; }
+template<typename T0, typename T1> inline bool amd_marked(const T0* w, const T1& j) { return w[j]<0; }
+template<typename T0, typename T1> inline void amd_mark(const T0* w, const T1& j) { return w[j] = amd_flip(w[j]); }
+
+/* clear w */
+template<typename StorageIndex>
+static StorageIndex cs_wclear (StorageIndex mark, StorageIndex lemax, StorageIndex *w, StorageIndex n)
+{
+  StorageIndex k;
+  if(mark < 2 || (mark + lemax < 0))
+  {
+    for(k = 0; k < n; k++)
+      if(w[k] != 0)
+        w[k] = 1;
+    mark = 2;
+  }
+  return (mark);     /* at this point, w[0..n-1] < mark holds */
+}
+
+/* depth-first search and postorder of a tree rooted at node j */
+template<typename StorageIndex>
+StorageIndex cs_tdfs(StorageIndex j, StorageIndex k, StorageIndex *head, const StorageIndex *next, StorageIndex *post, StorageIndex *stack)
+{
+  StorageIndex i, p, top = 0;
+  if(!head || !next || !post || !stack) return (-1);    /* check inputs */
+  stack[0] = j;                 /* place j on the stack */
+  while (top >= 0)                /* while (stack is not empty) */
+  {
+    p = stack[top];           /* p = top of stack */
+    i = head[p];              /* i = youngest child of p */
+    if(i == -1)
+    {
+      top--;                 /* p has no unordered children left */
+      post[k++] = p;        /* node p is the kth postordered node */
+    }
+    else
+    {
+      head[p] = next[i];   /* remove i from children of p */
+      stack[++top] = i;     /* start dfs on child node i */
+    }
+  }
+  return k;
+}
+
+
+/** \internal
+  * \ingroup OrderingMethods_Module 
+  * Approximate minimum degree ordering algorithm.
+  *
+  * \param[in] C the input selfadjoint matrix stored in compressed column major format.
+  * \param[out] perm the permutation P reducing the fill-in of the input matrix \a C
+  *
+  * Note that the input matrix \a C must be complete, that is both the upper and lower parts have to be stored, as well as the diagonal entries.
+  * On exit the values of C are destroyed */
+template<typename Scalar, typename StorageIndex>
+void minimum_degree_ordering(SparseMatrix<Scalar,ColMajor,StorageIndex>& C, PermutationMatrix<Dynamic,Dynamic,StorageIndex>& perm)
+{
+  using std::sqrt;
+  
+  StorageIndex d, dk, dext, lemax = 0, e, elenk, eln, i, j, k, k1,
+                k2, k3, jlast, ln, dense, nzmax, mindeg = 0, nvi, nvj, nvk, mark, wnvi,
+                ok, nel = 0, p, p1, p2, p3, p4, pj, pk, pk1, pk2, pn, q, t, h;
+  
+  StorageIndex n = StorageIndex(C.cols());
+  dense = std::max<StorageIndex> (16, StorageIndex(10 * sqrt(double(n))));   /* find dense threshold */
+  dense = (std::min)(n-2, dense);
+  
+  StorageIndex cnz = StorageIndex(C.nonZeros());
+  perm.resize(n+1);
+  t = cnz + cnz/5 + 2*n;                 /* add elbow room to C */
+  C.resizeNonZeros(t);
+  
+  // get workspace
+  ei_declare_aligned_stack_constructed_variable(StorageIndex,W,8*(n+1),0);
+  StorageIndex* len     = W;
+  StorageIndex* nv      = W +   (n+1);
+  StorageIndex* next    = W + 2*(n+1);
+  StorageIndex* head    = W + 3*(n+1);
+  StorageIndex* elen    = W + 4*(n+1);
+  StorageIndex* degree  = W + 5*(n+1);
+  StorageIndex* w       = W + 6*(n+1);
+  StorageIndex* hhead   = W + 7*(n+1);
+  StorageIndex* last    = perm.indices().data();                              /* use P as workspace for last */
+  
+  /* --- Initialize quotient graph ---------------------------------------- */
+  StorageIndex* Cp = C.outerIndexPtr();
+  StorageIndex* Ci = C.innerIndexPtr();
+  for(k = 0; k < n; k++)
+    len[k] = Cp[k+1] - Cp[k];
+  len[n] = 0;
+  nzmax = t;
+  
+  for(i = 0; i <= n; i++)
+  {
+    head[i]   = -1;                     // degree list i is empty
+    last[i]   = -1;
+    next[i]   = -1;
+    hhead[i]  = -1;                     // hash list i is empty 
+    nv[i]     = 1;                      // node i is just one node
+    w[i]      = 1;                      // node i is alive
+    elen[i]   = 0;                      // Ek of node i is empty
+    degree[i] = len[i];                 // degree of node i
+  }
+  mark = internal::cs_wclear<StorageIndex>(0, 0, w, n);         /* clear w */
+  
+  /* --- Initialize degree lists ------------------------------------------ */
+  for(i = 0; i < n; i++)
+  {
+    bool has_diag = false;
+    for(p = Cp[i]; p<Cp[i+1]; ++p)
+      if(Ci[p]==i)
+      {
+        has_diag = true;
+        break;
+      }
+   
+    d = degree[i];
+    if(d == 1 && has_diag)           /* node i is empty */
+    {
+      elen[i] = -2;                 /* element i is dead */
+      nel++;
+      Cp[i] = -1;                   /* i is a root of assembly tree */
+      w[i] = 0;
+    }
+    else if(d > dense || !has_diag)  /* node i is dense or has no structural diagonal element */
+    {
+      nv[i] = 0;                    /* absorb i into element n */
+      elen[i] = -1;                 /* node i is dead */
+      nel++;
+      Cp[i] = amd_flip (n);
+      nv[n]++;
+    }
+    else
+    {
+      if(head[d] != -1) last[head[d]] = i;
+      next[i] = head[d];           /* put node i in degree list d */
+      head[d] = i;
+    }
+  }
+  
+  elen[n] = -2;                         /* n is a dead element */
+  Cp[n] = -1;                           /* n is a root of assembly tree */
+  w[n] = 0;                             /* n is a dead element */
+  
+  while (nel < n)                         /* while (selecting pivots) do */
+  {
+    /* --- Select node of minimum approximate degree -------------------- */
+    for(k = -1; mindeg < n && (k = head[mindeg]) == -1; mindeg++) {}
+    if(next[k] != -1) last[next[k]] = -1;
+    head[mindeg] = next[k];          /* remove k from degree list */
+    elenk = elen[k];                  /* elenk = |Ek| */
+    nvk = nv[k];                      /* # of nodes k represents */
+    nel += nvk;                        /* nv[k] nodes of A eliminated */
+    
+    /* --- Garbage collection ------------------------------------------- */
+    if(elenk > 0 && cnz + mindeg >= nzmax)
+    {
+      for(j = 0; j < n; j++)
+      {
+        if((p = Cp[j]) >= 0)      /* j is a live node or element */
+        {
+          Cp[j] = Ci[p];          /* save first entry of object */
+          Ci[p] = amd_flip (j);    /* first entry is now amd_flip(j) */
+        }
+      }
+      for(q = 0, p = 0; p < cnz; ) /* scan all of memory */
+      {
+        if((j = amd_flip (Ci[p++])) >= 0)  /* found object j */
+        {
+          Ci[q] = Cp[j];       /* restore first entry of object */
+          Cp[j] = q++;          /* new pointer to object j */
+          for(k3 = 0; k3 < len[j]-1; k3++) Ci[q++] = Ci[p++];
+        }
+      }
+      cnz = q;                       /* Ci[cnz...nzmax-1] now free */
+    }
+    
+    /* --- Construct new element ---------------------------------------- */
+    dk = 0;
+    nv[k] = -nvk;                     /* flag k as in Lk */
+    p = Cp[k];
+    pk1 = (elenk == 0) ? p : cnz;      /* do in place if elen[k] == 0 */
+    pk2 = pk1;
+    for(k1 = 1; k1 <= elenk + 1; k1++)
+    {
+      if(k1 > elenk)
+      {
+        e = k;                     /* search the nodes in k */
+        pj = p;                    /* list of nodes starts at Ci[pj]*/
+        ln = len[k] - elenk;      /* length of list of nodes in k */
+      }
+      else
+      {
+        e = Ci[p++];              /* search the nodes in e */
+        pj = Cp[e];
+        ln = len[e];              /* length of list of nodes in e */
+      }
+      for(k2 = 1; k2 <= ln; k2++)
+      {
+        i = Ci[pj++];
+        if((nvi = nv[i]) <= 0) continue; /* node i dead, or seen */
+        dk += nvi;                 /* degree[Lk] += size of node i */
+        nv[i] = -nvi;             /* negate nv[i] to denote i in Lk*/
+        Ci[pk2++] = i;            /* place i in Lk */
+        if(next[i] != -1) last[next[i]] = last[i];
+        if(last[i] != -1)         /* remove i from degree list */
+        {
+          next[last[i]] = next[i];
+        }
+        else
+        {
+          head[degree[i]] = next[i];
+        }
+      }
+      if(e != k)
+      {
+        Cp[e] = amd_flip (k);      /* absorb e into k */
+        w[e] = 0;                 /* e is now a dead element */
+      }
+    }
+    if(elenk != 0) cnz = pk2;         /* Ci[cnz...nzmax] is free */
+    degree[k] = dk;                   /* external degree of k - |Lk\i| */
+    Cp[k] = pk1;                      /* element k is in Ci[pk1..pk2-1] */
+    len[k] = pk2 - pk1;
+    elen[k] = -2;                     /* k is now an element */
+    
+    /* --- Find set differences ----------------------------------------- */
+    mark = internal::cs_wclear<StorageIndex>(mark, lemax, w, n);  /* clear w if necessary */
+    for(pk = pk1; pk < pk2; pk++)    /* scan 1: find |Le\Lk| */
+    {
+      i = Ci[pk];
+      if((eln = elen[i]) <= 0) continue;/* skip if elen[i] empty */
+      nvi = -nv[i];                      /* nv[i] was negated */
+      wnvi = mark - nvi;
+      for(p = Cp[i]; p <= Cp[i] + eln - 1; p++)  /* scan Ei */
+      {
+        e = Ci[p];
+        if(w[e] >= mark)
+        {
+          w[e] -= nvi;          /* decrement |Le\Lk| */
+        }
+        else if(w[e] != 0)        /* ensure e is a live element */
+        {
+          w[e] = degree[e] + wnvi; /* 1st time e seen in scan 1 */
+        }
+      }
+    }
+    
+    /* --- Degree update ------------------------------------------------ */
+    for(pk = pk1; pk < pk2; pk++)    /* scan2: degree update */
+    {
+      i = Ci[pk];                   /* consider node i in Lk */
+      p1 = Cp[i];
+      p2 = p1 + elen[i] - 1;
+      pn = p1;
+      for(h = 0, d = 0, p = p1; p <= p2; p++)    /* scan Ei */
+      {
+        e = Ci[p];
+        if(w[e] != 0)             /* e is an unabsorbed element */
+        {
+          dext = w[e] - mark;   /* dext = |Le\Lk| */
+          if(dext > 0)
+          {
+            d += dext;         /* sum up the set differences */
+            Ci[pn++] = e;     /* keep e in Ei */
+            h += e;            /* compute the hash of node i */
+          }
+          else
+          {
+            Cp[e] = amd_flip (k);  /* aggressive absorb. e->k */
+            w[e] = 0;             /* e is a dead element */
+          }
+        }
+      }
+      elen[i] = pn - p1 + 1;        /* elen[i] = |Ei| */
+      p3 = pn;
+      p4 = p1 + len[i];
+      for(p = p2 + 1; p < p4; p++) /* prune edges in Ai */
+      {
+        j = Ci[p];
+        if((nvj = nv[j]) <= 0) continue; /* node j dead or in Lk */
+        d += nvj;                  /* degree(i) += |j| */
+        Ci[pn++] = j;             /* place j in node list of i */
+        h += j;                    /* compute hash for node i */
+      }
+      if(d == 0)                     /* check for mass elimination */
+      {
+        Cp[i] = amd_flip (k);      /* absorb i into k */
+        nvi = -nv[i];
+        dk -= nvi;                 /* |Lk| -= |i| */
+        nvk += nvi;                /* |k| += nv[i] */
+        nel += nvi;
+        nv[i] = 0;
+        elen[i] = -1;             /* node i is dead */
+      }
+      else
+      {
+        degree[i] = std::min<StorageIndex> (degree[i], d);   /* update degree(i) */
+        Ci[pn] = Ci[p3];         /* move first node to end */
+        Ci[p3] = Ci[p1];         /* move 1st el. to end of Ei */
+        Ci[p1] = k;               /* add k as 1st element in of Ei */
+        len[i] = pn - p1 + 1;     /* new len of adj. list of node i */
+        h %= n;                    /* finalize hash of i */
+        next[i] = hhead[h];      /* place i in hash bucket */
+        hhead[h] = i;
+        last[i] = h;      /* save hash of i in last[i] */
+      }
+    }                                   /* scan2 is done */
+    degree[k] = dk;                   /* finalize |Lk| */
+    lemax = std::max<StorageIndex>(lemax, dk);
+    mark = internal::cs_wclear<StorageIndex>(mark+lemax, lemax, w, n);    /* clear w */
+    
+    /* --- Supernode detection ------------------------------------------ */
+    for(pk = pk1; pk < pk2; pk++)
+    {
+      i = Ci[pk];
+      if(nv[i] >= 0) continue;         /* skip if i is dead */
+      h = last[i];                      /* scan hash bucket of node i */
+      i = hhead[h];
+      hhead[h] = -1;                    /* hash bucket will be empty */
+      for(; i != -1 && next[i] != -1; i = next[i], mark++)
+      {
+        ln = len[i];
+        eln = elen[i];
+        for(p = Cp[i]+1; p <= Cp[i] + ln-1; p++) w[Ci[p]] = mark;
+        jlast = i;
+        for(j = next[i]; j != -1; ) /* compare i with all j */
+        {
+          ok = (len[j] == ln) && (elen[j] == eln);
+          for(p = Cp[j] + 1; ok && p <= Cp[j] + ln - 1; p++)
+          {
+            if(w[Ci[p]] != mark) ok = 0;    /* compare i and j*/
+          }
+          if(ok)                     /* i and j are identical */
+          {
+            Cp[j] = amd_flip (i);  /* absorb j into i */
+            nv[i] += nv[j];
+            nv[j] = 0;
+            elen[j] = -1;         /* node j is dead */
+            j = next[j];          /* delete j from hash bucket */
+            next[jlast] = j;
+          }
+          else
+          {
+            jlast = j;             /* j and i are different */
+            j = next[j];
+          }
+        }
+      }
+    }
+    
+    /* --- Finalize new element------------------------------------------ */
+    for(p = pk1, pk = pk1; pk < pk2; pk++)   /* finalize Lk */
+    {
+      i = Ci[pk];
+      if((nvi = -nv[i]) <= 0) continue;/* skip if i is dead */
+      nv[i] = nvi;                      /* restore nv[i] */
+      d = degree[i] + dk - nvi;         /* compute external degree(i) */
+      d = std::min<StorageIndex> (d, n - nel - nvi);
+      if(head[d] != -1) last[head[d]] = i;
+      next[i] = head[d];               /* put i back in degree list */
+      last[i] = -1;
+      head[d] = i;
+      mindeg = std::min<StorageIndex> (mindeg, d);       /* find new minimum degree */
+      degree[i] = d;
+      Ci[p++] = i;                      /* place i in Lk */
+    }
+    nv[k] = nvk;                      /* # nodes absorbed into k */
+    if((len[k] = p-pk1) == 0)         /* length of adj list of element k*/
+    {
+      Cp[k] = -1;                   /* k is a root of the tree */
+      w[k] = 0;                     /* k is now a dead element */
+    }
+    if(elenk != 0) cnz = p;           /* free unused space in Lk */
+  }
+  
+  /* --- Postordering ----------------------------------------------------- */
+  for(i = 0; i < n; i++) Cp[i] = amd_flip (Cp[i]);/* fix assembly tree */
+  for(j = 0; j <= n; j++) head[j] = -1;
+  for(j = n; j >= 0; j--)              /* place unordered nodes in lists */
+  {
+    if(nv[j] > 0) continue;          /* skip if j is an element */
+    next[j] = head[Cp[j]];          /* place j in list of its parent */
+    head[Cp[j]] = j;
+  }
+  for(e = n; e >= 0; e--)              /* place elements in lists */
+  {
+    if(nv[e] <= 0) continue;         /* skip unless e is an element */
+    if(Cp[e] != -1)
+    {
+      next[e] = head[Cp[e]];      /* place e in list of its parent */
+      head[Cp[e]] = e;
+    }
+  }
+  for(k = 0, i = 0; i <= n; i++)       /* postorder the assembly tree */
+  {
+    if(Cp[i] == -1) k = internal::cs_tdfs<StorageIndex>(i, k, head, next, perm.indices().data(), w);
+  }
+  
+  perm.indices().conservativeResize(n);
+}
+
+} // namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_AMD_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/OrderingMethods/Eigen_Colamd.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/OrderingMethods/Eigen_Colamd.h
new file mode 100644
index 00000000..da85b4d6
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/OrderingMethods/Eigen_Colamd.h
@@ -0,0 +1,1843 @@
+// // This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Desire Nuentsa Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+// This file is modified from the colamd/symamd library. The copyright is below
+
+//   The authors of the code itself are Stefan I. Larimore and Timothy A.
+//   Davis (davis@cise.ufl.edu), University of Florida.  The algorithm was
+//   developed in collaboration with John Gilbert, Xerox PARC, and Esmond
+//   Ng, Oak Ridge National Laboratory.
+// 
+//     Date:
+// 
+//   September 8, 2003.  Version 2.3.
+// 
+//     Acknowledgements:
+// 
+//   This work was supported by the National Science Foundation, under
+//   grants DMS-9504974 and DMS-9803599.
+// 
+//     Notice:
+// 
+//   Copyright (c) 1998-2003 by the University of Florida.
+//   All Rights Reserved.
+// 
+//   THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+//   EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+// 
+//   Permission is hereby granted to use, copy, modify, and/or distribute
+//   this program, provided that the Copyright, this License, and the
+//   Availability of the original version is retained on all copies and made
+//   accessible to the end-user of any code or package that includes COLAMD
+//   or any modified version of COLAMD. 
+// 
+//     Availability:
+// 
+//   The colamd/symamd library is available at
+// 
+//       http://www.suitesparse.com
+
+  
+#ifndef EIGEN_COLAMD_H
+#define EIGEN_COLAMD_H
+
+namespace internal {
+/* Ensure that debugging is turned off: */
+#ifndef COLAMD_NDEBUG
+#define COLAMD_NDEBUG
+#endif /* NDEBUG */
+/* ========================================================================== */
+/* === Knob and statistics definitions ====================================== */
+/* ========================================================================== */
+
+/* size of the knobs [ ] array.  Only knobs [0..1] are currently used. */
+#define COLAMD_KNOBS 20
+
+/* number of output statistics.  Only stats [0..6] are currently used. */
+#define COLAMD_STATS 20 
+
+/* knobs [0] and stats [0]: dense row knob and output statistic. */
+#define COLAMD_DENSE_ROW 0
+
+/* knobs [1] and stats [1]: dense column knob and output statistic. */
+#define COLAMD_DENSE_COL 1
+
+/* stats [2]: memory defragmentation count output statistic */
+#define COLAMD_DEFRAG_COUNT 2
+
+/* stats [3]: colamd status:  zero OK, > 0 warning or notice, < 0 error */
+#define COLAMD_STATUS 3
+
+/* stats [4..6]: error info, or info on jumbled columns */ 
+#define COLAMD_INFO1 4
+#define COLAMD_INFO2 5
+#define COLAMD_INFO3 6
+
+/* error codes returned in stats [3]: */
+#define COLAMD_OK       (0)
+#define COLAMD_OK_BUT_JUMBLED     (1)
+#define COLAMD_ERROR_A_not_present    (-1)
+#define COLAMD_ERROR_p_not_present    (-2)
+#define COLAMD_ERROR_nrow_negative    (-3)
+#define COLAMD_ERROR_ncol_negative    (-4)
+#define COLAMD_ERROR_nnz_negative   (-5)
+#define COLAMD_ERROR_p0_nonzero     (-6)
+#define COLAMD_ERROR_A_too_small    (-7)
+#define COLAMD_ERROR_col_length_negative  (-8)
+#define COLAMD_ERROR_row_index_out_of_bounds  (-9)
+#define COLAMD_ERROR_out_of_memory    (-10)
+#define COLAMD_ERROR_internal_error   (-999)
+
+/* ========================================================================== */
+/* === Definitions ========================================================== */
+/* ========================================================================== */
+
+#define ONES_COMPLEMENT(r) (-(r)-1)
+
+/* -------------------------------------------------------------------------- */
+
+#define COLAMD_EMPTY (-1)
+
+/* Row and column status */
+#define ALIVE (0)
+#define DEAD  (-1)
+
+/* Column status */
+#define DEAD_PRINCIPAL    (-1)
+#define DEAD_NON_PRINCIPAL  (-2)
+
+/* Macros for row and column status update and checking. */
+#define ROW_IS_DEAD(r)      ROW_IS_MARKED_DEAD (Row[r].shared2.mark)
+#define ROW_IS_MARKED_DEAD(row_mark)  (row_mark < ALIVE)
+#define ROW_IS_ALIVE(r)     (Row [r].shared2.mark >= ALIVE)
+#define COL_IS_DEAD(c)      (Col [c].start < ALIVE)
+#define COL_IS_ALIVE(c)     (Col [c].start >= ALIVE)
+#define COL_IS_DEAD_PRINCIPAL(c)  (Col [c].start == DEAD_PRINCIPAL)
+#define KILL_ROW(r)     { Row [r].shared2.mark = DEAD ; }
+#define KILL_PRINCIPAL_COL(c)   { Col [c].start = DEAD_PRINCIPAL ; }
+#define KILL_NON_PRINCIPAL_COL(c) { Col [c].start = DEAD_NON_PRINCIPAL ; }
+
+/* ========================================================================== */
+/* === Colamd reporting mechanism =========================================== */
+/* ========================================================================== */
+
+// == Row and Column structures ==
+template <typename IndexType>
+struct colamd_col
+{
+  IndexType start ;   /* index for A of first row in this column, or DEAD */
+  /* if column is dead */
+  IndexType length ;  /* number of rows in this column */
+  union
+  {
+    IndexType thickness ; /* number of original columns represented by this */
+    /* col, if the column is alive */
+    IndexType parent ;  /* parent in parent tree super-column structure, if */
+    /* the column is dead */
+  } shared1 ;
+  union
+  {
+    IndexType score ; /* the score used to maintain heap, if col is alive */
+    IndexType order ; /* pivot ordering of this column, if col is dead */
+  } shared2 ;
+  union
+  {
+    IndexType headhash ;  /* head of a hash bucket, if col is at the head of */
+    /* a degree list */
+    IndexType hash ;  /* hash value, if col is not in a degree list */
+    IndexType prev ;  /* previous column in degree list, if col is in a */
+    /* degree list (but not at the head of a degree list) */
+  } shared3 ;
+  union
+  {
+    IndexType degree_next ; /* next column, if col is in a degree list */
+    IndexType hash_next ;   /* next column, if col is in a hash list */
+  } shared4 ;
+  
+};
+ 
+template <typename IndexType>
+struct Colamd_Row
+{
+  IndexType start ;   /* index for A of first col in this row */
+  IndexType length ;  /* number of principal columns in this row */
+  union
+  {
+    IndexType degree ;  /* number of principal & non-principal columns in row */
+    IndexType p ;   /* used as a row pointer in init_rows_cols () */
+  } shared1 ;
+  union
+  {
+    IndexType mark ;  /* for computing set differences and marking dead rows*/
+    IndexType first_column ;/* first column in row (used in garbage collection) */
+  } shared2 ;
+  
+};
+ 
+/* ========================================================================== */
+/* === Colamd recommended memory size ======================================= */
+/* ========================================================================== */
+ 
+/*
+  The recommended length Alen of the array A passed to colamd is given by
+  the COLAMD_RECOMMENDED (nnz, n_row, n_col) macro.  It returns -1 if any
+  argument is negative.  2*nnz space is required for the row and column
+  indices of the matrix. colamd_c (n_col) + colamd_r (n_row) space is
+  required for the Col and Row arrays, respectively, which are internal to
+  colamd.  An additional n_col space is the minimal amount of "elbow room",
+  and nnz/5 more space is recommended for run time efficiency.
+  
+  This macro is not needed when using symamd.
+  
+  Explicit typecast to IndexType added Sept. 23, 2002, COLAMD version 2.2, to avoid
+  gcc -pedantic warning messages.
+*/
+template <typename IndexType>
+inline IndexType colamd_c(IndexType n_col) 
+{ return IndexType( ((n_col) + 1) * sizeof (colamd_col<IndexType>) / sizeof (IndexType) ) ; }
+
+template <typename IndexType>
+inline IndexType  colamd_r(IndexType n_row)
+{ return IndexType(((n_row) + 1) * sizeof (Colamd_Row<IndexType>) / sizeof (IndexType)); }
+
+// Prototypes of non-user callable routines
+template <typename IndexType>
+static IndexType init_rows_cols (IndexType n_row, IndexType n_col, Colamd_Row<IndexType> Row [], colamd_col<IndexType> col [], IndexType A [], IndexType p [], IndexType stats[COLAMD_STATS] ); 
+
+template <typename IndexType>
+static void init_scoring (IndexType n_row, IndexType n_col, Colamd_Row<IndexType> Row [], colamd_col<IndexType> Col [], IndexType A [], IndexType head [], double knobs[COLAMD_KNOBS], IndexType *p_n_row2, IndexType *p_n_col2, IndexType *p_max_deg);
+
+template <typename IndexType>
+static IndexType find_ordering (IndexType n_row, IndexType n_col, IndexType Alen, Colamd_Row<IndexType> Row [], colamd_col<IndexType> Col [], IndexType A [], IndexType head [], IndexType n_col2, IndexType max_deg, IndexType pfree);
+
+template <typename IndexType>
+static void order_children (IndexType n_col, colamd_col<IndexType> Col [], IndexType p []);
+
+template <typename IndexType>
+static void detect_super_cols (colamd_col<IndexType> Col [], IndexType A [], IndexType head [], IndexType row_start, IndexType row_length ) ;
+
+template <typename IndexType>
+static IndexType garbage_collection (IndexType n_row, IndexType n_col, Colamd_Row<IndexType> Row [], colamd_col<IndexType> Col [], IndexType A [], IndexType *pfree) ;
+
+template <typename IndexType>
+static inline  IndexType clear_mark (IndexType n_row, Colamd_Row<IndexType> Row [] ) ;
+
+/* === No debugging ========================================================= */
+
+#define COLAMD_DEBUG0(params) ;
+#define COLAMD_DEBUG1(params) ;
+#define COLAMD_DEBUG2(params) ;
+#define COLAMD_DEBUG3(params) ;
+#define COLAMD_DEBUG4(params) ;
+
+#define COLAMD_ASSERT(expression) ((void) 0)
+
+
+/**
+ * \brief Returns the recommended value of Alen 
+ * 
+ * Returns recommended value of Alen for use by colamd.  
+ * Returns -1 if any input argument is negative.  
+ * The use of this routine or macro is optional.  
+ * Note that the macro uses its arguments   more than once, 
+ * so be careful for side effects, if you pass expressions as arguments to COLAMD_RECOMMENDED.  
+ * 
+ * \param nnz nonzeros in A
+ * \param n_row number of rows in A
+ * \param n_col number of columns in A
+ * \return recommended value of Alen for use by colamd
+ */
+template <typename IndexType>
+inline IndexType colamd_recommended ( IndexType nnz, IndexType n_row, IndexType n_col)
+{
+  if ((nnz) < 0 || (n_row) < 0 || (n_col) < 0)
+    return (-1);
+  else
+    return (2 * (nnz) + colamd_c (n_col) + colamd_r (n_row) + (n_col) + ((nnz) / 5)); 
+}
+
+/**
+ * \brief set default parameters  The use of this routine is optional.
+ * 
+ * Colamd: rows with more than (knobs [COLAMD_DENSE_ROW] * n_col)
+ * entries are removed prior to ordering.  Columns with more than
+ * (knobs [COLAMD_DENSE_COL] * n_row) entries are removed prior to
+ * ordering, and placed last in the output column ordering. 
+ *
+ * COLAMD_DENSE_ROW and COLAMD_DENSE_COL are defined as 0 and 1,
+ * respectively, in colamd.h.  Default values of these two knobs
+ * are both 0.5.  Currently, only knobs [0] and knobs [1] are
+ * used, but future versions may use more knobs.  If so, they will
+ * be properly set to their defaults by the future version of
+ * colamd_set_defaults, so that the code that calls colamd will
+ * not need to change, assuming that you either use
+ * colamd_set_defaults, or pass a (double *) NULL pointer as the
+ * knobs array to colamd or symamd.
+ * 
+ * \param knobs parameter settings for colamd
+ */
+
+static inline void colamd_set_defaults(double knobs[COLAMD_KNOBS])
+{
+  /* === Local variables ================================================== */
+  
+  int i ;
+
+  if (!knobs)
+  {
+    return ;      /* no knobs to initialize */
+  }
+  for (i = 0 ; i < COLAMD_KNOBS ; i++)
+  {
+    knobs [i] = 0 ;
+  }
+  knobs [COLAMD_DENSE_ROW] = 0.5 ;  /* ignore rows over 50% dense */
+  knobs [COLAMD_DENSE_COL] = 0.5 ;  /* ignore columns over 50% dense */
+}
+
+/** 
+ * \brief  Computes a column ordering using the column approximate minimum degree ordering
+ * 
+ * Computes a column ordering (Q) of A such that P(AQ)=LU or
+ * (AQ)'AQ=LL' have less fill-in and require fewer floating point
+ * operations than factorizing the unpermuted matrix A or A'A,
+ * respectively.
+ * 
+ * 
+ * \param n_row number of rows in A
+ * \param n_col number of columns in A
+ * \param Alen, size of the array A
+ * \param A row indices of the matrix, of size ALen
+ * \param p column pointers of A, of size n_col+1
+ * \param knobs parameter settings for colamd
+ * \param stats colamd output statistics and error codes
+ */
+template <typename IndexType>
+static bool colamd(IndexType n_row, IndexType n_col, IndexType Alen, IndexType *A, IndexType *p, double knobs[COLAMD_KNOBS], IndexType stats[COLAMD_STATS])
+{
+  /* === Local variables ================================================== */
+  
+  IndexType i ;     /* loop index */
+  IndexType nnz ;     /* nonzeros in A */
+  IndexType Row_size ;    /* size of Row [], in integers */
+  IndexType Col_size ;    /* size of Col [], in integers */
+  IndexType need ;      /* minimum required length of A */
+  Colamd_Row<IndexType> *Row ;   /* pointer into A of Row [0..n_row] array */
+  colamd_col<IndexType> *Col ;   /* pointer into A of Col [0..n_col] array */
+  IndexType n_col2 ;    /* number of non-dense, non-empty columns */
+  IndexType n_row2 ;    /* number of non-dense, non-empty rows */
+  IndexType ngarbage ;    /* number of garbage collections performed */
+  IndexType max_deg ;   /* maximum row degree */
+  double default_knobs [COLAMD_KNOBS] ; /* default knobs array */
+  
+  
+  /* === Check the input arguments ======================================== */
+  
+  if (!stats)
+  {
+    COLAMD_DEBUG0 (("colamd: stats not present\n")) ;
+    return (false) ;
+  }
+  for (i = 0 ; i < COLAMD_STATS ; i++)
+  {
+    stats [i] = 0 ;
+  }
+  stats [COLAMD_STATUS] = COLAMD_OK ;
+  stats [COLAMD_INFO1] = -1 ;
+  stats [COLAMD_INFO2] = -1 ;
+  
+  if (!A)   /* A is not present */
+  {
+    stats [COLAMD_STATUS] = COLAMD_ERROR_A_not_present ;
+    COLAMD_DEBUG0 (("colamd: A not present\n")) ;
+    return (false) ;
+  }
+  
+  if (!p)   /* p is not present */
+  {
+    stats [COLAMD_STATUS] = COLAMD_ERROR_p_not_present ;
+    COLAMD_DEBUG0 (("colamd: p not present\n")) ;
+    return (false) ;
+  }
+  
+  if (n_row < 0)  /* n_row must be >= 0 */
+  {
+    stats [COLAMD_STATUS] = COLAMD_ERROR_nrow_negative ;
+    stats [COLAMD_INFO1] = n_row ;
+    COLAMD_DEBUG0 (("colamd: nrow negative %d\n", n_row)) ;
+    return (false) ;
+  }
+  
+  if (n_col < 0)  /* n_col must be >= 0 */
+  {
+    stats [COLAMD_STATUS] = COLAMD_ERROR_ncol_negative ;
+    stats [COLAMD_INFO1] = n_col ;
+    COLAMD_DEBUG0 (("colamd: ncol negative %d\n", n_col)) ;
+    return (false) ;
+  }
+  
+  nnz = p [n_col] ;
+  if (nnz < 0)  /* nnz must be >= 0 */
+  {
+    stats [COLAMD_STATUS] = COLAMD_ERROR_nnz_negative ;
+    stats [COLAMD_INFO1] = nnz ;
+    COLAMD_DEBUG0 (("colamd: number of entries negative %d\n", nnz)) ;
+    return (false) ;
+  }
+  
+  if (p [0] != 0)
+  {
+    stats [COLAMD_STATUS] = COLAMD_ERROR_p0_nonzero ;
+    stats [COLAMD_INFO1] = p [0] ;
+    COLAMD_DEBUG0 (("colamd: p[0] not zero %d\n", p [0])) ;
+    return (false) ;
+  }
+  
+  /* === If no knobs, set default knobs =================================== */
+  
+  if (!knobs)
+  {
+    colamd_set_defaults (default_knobs) ;
+    knobs = default_knobs ;
+  }
+  
+  /* === Allocate the Row and Col arrays from array A ===================== */
+  
+  Col_size = colamd_c (n_col) ;
+  Row_size = colamd_r (n_row) ;
+  need = 2*nnz + n_col + Col_size + Row_size ;
+  
+  if (need > Alen)
+  {
+    /* not enough space in array A to perform the ordering */
+    stats [COLAMD_STATUS] = COLAMD_ERROR_A_too_small ;
+    stats [COLAMD_INFO1] = need ;
+    stats [COLAMD_INFO2] = Alen ;
+    COLAMD_DEBUG0 (("colamd: Need Alen >= %d, given only Alen = %d\n", need,Alen));
+    return (false) ;
+  }
+  
+  Alen -= Col_size + Row_size ;
+  Col = (colamd_col<IndexType> *) &A [Alen] ;
+  Row = (Colamd_Row<IndexType> *) &A [Alen + Col_size] ;
+
+  /* === Construct the row and column data structures ===================== */
+  
+  if (!Eigen::internal::init_rows_cols (n_row, n_col, Row, Col, A, p, stats))
+  {
+    /* input matrix is invalid */
+    COLAMD_DEBUG0 (("colamd: Matrix invalid\n")) ;
+    return (false) ;
+  }
+  
+  /* === Initialize scores, kill dense rows/columns ======================= */
+
+  Eigen::internal::init_scoring (n_row, n_col, Row, Col, A, p, knobs,
+		&n_row2, &n_col2, &max_deg) ;
+  
+  /* === Order the supercolumns =========================================== */
+  
+  ngarbage = Eigen::internal::find_ordering (n_row, n_col, Alen, Row, Col, A, p,
+			    n_col2, max_deg, 2*nnz) ;
+  
+  /* === Order the non-principal columns ================================== */
+  
+  Eigen::internal::order_children (n_col, Col, p) ;
+  
+  /* === Return statistics in stats ======================================= */
+  
+  stats [COLAMD_DENSE_ROW] = n_row - n_row2 ;
+  stats [COLAMD_DENSE_COL] = n_col - n_col2 ;
+  stats [COLAMD_DEFRAG_COUNT] = ngarbage ;
+  COLAMD_DEBUG0 (("colamd: done.\n")) ; 
+  return (true) ;
+}
+
+/* ========================================================================== */
+/* === NON-USER-CALLABLE ROUTINES: ========================================== */
+/* ========================================================================== */
+
+/* There are no user-callable routines beyond this point in the file */
+
+
+/* ========================================================================== */
+/* === init_rows_cols ======================================================= */
+/* ========================================================================== */
+
+/*
+  Takes the column form of the matrix in A and creates the row form of the
+  matrix.  Also, row and column attributes are stored in the Col and Row
+  structs.  If the columns are un-sorted or contain duplicate row indices,
+  this routine will also sort and remove duplicate row indices from the
+  column form of the matrix.  Returns false if the matrix is invalid,
+  true otherwise.  Not user-callable.
+*/
+template <typename IndexType>
+static IndexType init_rows_cols  /* returns true if OK, or false otherwise */
+  (
+    /* === Parameters ======================================================= */
+
+    IndexType n_row,      /* number of rows of A */
+    IndexType n_col,      /* number of columns of A */
+    Colamd_Row<IndexType> Row [],    /* of size n_row+1 */
+    colamd_col<IndexType> Col [],    /* of size n_col+1 */
+    IndexType A [],     /* row indices of A, of size Alen */
+    IndexType p [],     /* pointers to columns in A, of size n_col+1 */
+    IndexType stats [COLAMD_STATS]  /* colamd statistics */ 
+    )
+{
+  /* === Local variables ================================================== */
+
+  IndexType col ;     /* a column index */
+  IndexType row ;     /* a row index */
+  IndexType *cp ;     /* a column pointer */
+  IndexType *cp_end ;   /* a pointer to the end of a column */
+  IndexType *rp ;     /* a row pointer */
+  IndexType *rp_end ;   /* a pointer to the end of a row */
+  IndexType last_row ;    /* previous row */
+
+  /* === Initialize columns, and check column pointers ==================== */
+
+  for (col = 0 ; col < n_col ; col++)
+  {
+    Col [col].start = p [col] ;
+    Col [col].length = p [col+1] - p [col] ;
+
+    if ((Col [col].length) < 0) // extra parentheses to work-around gcc bug 10200
+    {
+      /* column pointers must be non-decreasing */
+      stats [COLAMD_STATUS] = COLAMD_ERROR_col_length_negative ;
+      stats [COLAMD_INFO1] = col ;
+      stats [COLAMD_INFO2] = Col [col].length ;
+      COLAMD_DEBUG0 (("colamd: col %d length %d < 0\n", col, Col [col].length)) ;
+      return (false) ;
+    }
+
+    Col [col].shared1.thickness = 1 ;
+    Col [col].shared2.score = 0 ;
+    Col [col].shared3.prev = COLAMD_EMPTY ;
+    Col [col].shared4.degree_next = COLAMD_EMPTY ;
+  }
+
+  /* p [0..n_col] no longer needed, used as "head" in subsequent routines */
+
+  /* === Scan columns, compute row degrees, and check row indices ========= */
+
+  stats [COLAMD_INFO3] = 0 ;  /* number of duplicate or unsorted row indices*/
+
+  for (row = 0 ; row < n_row ; row++)
+  {
+    Row [row].length = 0 ;
+    Row [row].shared2.mark = -1 ;
+  }
+
+  for (col = 0 ; col < n_col ; col++)
+  {
+    last_row = -1 ;
+
+    cp = &A [p [col]] ;
+    cp_end = &A [p [col+1]] ;
+
+    while (cp < cp_end)
+    {
+      row = *cp++ ;
+
+      /* make sure row indices within range */
+      if (row < 0 || row >= n_row)
+      {
+	stats [COLAMD_STATUS] = COLAMD_ERROR_row_index_out_of_bounds ;
+	stats [COLAMD_INFO1] = col ;
+	stats [COLAMD_INFO2] = row ;
+	stats [COLAMD_INFO3] = n_row ;
+	COLAMD_DEBUG0 (("colamd: row %d col %d out of bounds\n", row, col)) ;
+	return (false) ;
+      }
+
+      if (row <= last_row || Row [row].shared2.mark == col)
+      {
+	/* row index are unsorted or repeated (or both), thus col */
+	/* is jumbled.  This is a notice, not an error condition. */
+	stats [COLAMD_STATUS] = COLAMD_OK_BUT_JUMBLED ;
+	stats [COLAMD_INFO1] = col ;
+	stats [COLAMD_INFO2] = row ;
+	(stats [COLAMD_INFO3]) ++ ;
+	COLAMD_DEBUG1 (("colamd: row %d col %d unsorted/duplicate\n",row,col));
+      }
+
+      if (Row [row].shared2.mark != col)
+      {
+	Row [row].length++ ;
+      }
+      else
+      {
+	/* this is a repeated entry in the column, */
+	/* it will be removed */
+	Col [col].length-- ;
+      }
+
+      /* mark the row as having been seen in this column */
+      Row [row].shared2.mark = col ;
+
+      last_row = row ;
+    }
+  }
+
+  /* === Compute row pointers ============================================= */
+
+  /* row form of the matrix starts directly after the column */
+  /* form of matrix in A */
+  Row [0].start = p [n_col] ;
+  Row [0].shared1.p = Row [0].start ;
+  Row [0].shared2.mark = -1 ;
+  for (row = 1 ; row < n_row ; row++)
+  {
+    Row [row].start = Row [row-1].start + Row [row-1].length ;
+    Row [row].shared1.p = Row [row].start ;
+    Row [row].shared2.mark = -1 ;
+  }
+
+  /* === Create row form ================================================== */
+
+  if (stats [COLAMD_STATUS] == COLAMD_OK_BUT_JUMBLED)
+  {
+    /* if cols jumbled, watch for repeated row indices */
+    for (col = 0 ; col < n_col ; col++)
+    {
+      cp = &A [p [col]] ;
+      cp_end = &A [p [col+1]] ;
+      while (cp < cp_end)
+      {
+	row = *cp++ ;
+	if (Row [row].shared2.mark != col)
+	{
+	  A [(Row [row].shared1.p)++] = col ;
+	  Row [row].shared2.mark = col ;
+	}
+      }
+    }
+  }
+  else
+  {
+    /* if cols not jumbled, we don't need the mark (this is faster) */
+    for (col = 0 ; col < n_col ; col++)
+    {
+      cp = &A [p [col]] ;
+      cp_end = &A [p [col+1]] ;
+      while (cp < cp_end)
+      {
+	A [(Row [*cp++].shared1.p)++] = col ;
+      }
+    }
+  }
+
+  /* === Clear the row marks and set row degrees ========================== */
+
+  for (row = 0 ; row < n_row ; row++)
+  {
+    Row [row].shared2.mark = 0 ;
+    Row [row].shared1.degree = Row [row].length ;
+  }
+
+  /* === See if we need to re-create columns ============================== */
+
+  if (stats [COLAMD_STATUS] == COLAMD_OK_BUT_JUMBLED)
+  {
+    COLAMD_DEBUG0 (("colamd: reconstructing column form, matrix jumbled\n")) ;
+
+
+    /* === Compute col pointers ========================================= */
+
+    /* col form of the matrix starts at A [0]. */
+    /* Note, we may have a gap between the col form and the row */
+    /* form if there were duplicate entries, if so, it will be */
+    /* removed upon the first garbage collection */
+    Col [0].start = 0 ;
+    p [0] = Col [0].start ;
+    for (col = 1 ; col < n_col ; col++)
+    {
+      /* note that the lengths here are for pruned columns, i.e. */
+      /* no duplicate row indices will exist for these columns */
+      Col [col].start = Col [col-1].start + Col [col-1].length ;
+      p [col] = Col [col].start ;
+    }
+
+    /* === Re-create col form =========================================== */
+
+    for (row = 0 ; row < n_row ; row++)
+    {
+      rp = &A [Row [row].start] ;
+      rp_end = rp + Row [row].length ;
+      while (rp < rp_end)
+      {
+	A [(p [*rp++])++] = row ;
+      }
+    }
+  }
+
+  /* === Done.  Matrix is not (or no longer) jumbled ====================== */
+
+  return (true) ;
+}
+
+
+/* ========================================================================== */
+/* === init_scoring ========================================================= */
+/* ========================================================================== */
+
+/*
+  Kills dense or empty columns and rows, calculates an initial score for
+  each column, and places all columns in the degree lists.  Not user-callable.
+*/
+template <typename IndexType>
+static void init_scoring
+  (
+    /* === Parameters ======================================================= */
+
+    IndexType n_row,      /* number of rows of A */
+    IndexType n_col,      /* number of columns of A */
+    Colamd_Row<IndexType> Row [],    /* of size n_row+1 */
+    colamd_col<IndexType> Col [],    /* of size n_col+1 */
+    IndexType A [],     /* column form and row form of A */
+    IndexType head [],    /* of size n_col+1 */
+    double knobs [COLAMD_KNOBS],/* parameters */
+    IndexType *p_n_row2,    /* number of non-dense, non-empty rows */
+    IndexType *p_n_col2,    /* number of non-dense, non-empty columns */
+    IndexType *p_max_deg    /* maximum row degree */
+    )
+{
+  /* === Local variables ================================================== */
+
+  IndexType c ;     /* a column index */
+  IndexType r, row ;    /* a row index */
+  IndexType *cp ;     /* a column pointer */
+  IndexType deg ;     /* degree of a row or column */
+  IndexType *cp_end ;   /* a pointer to the end of a column */
+  IndexType *new_cp ;   /* new column pointer */
+  IndexType col_length ;    /* length of pruned column */
+  IndexType score ;     /* current column score */
+  IndexType n_col2 ;    /* number of non-dense, non-empty columns */
+  IndexType n_row2 ;    /* number of non-dense, non-empty rows */
+  IndexType dense_row_count ; /* remove rows with more entries than this */
+  IndexType dense_col_count ; /* remove cols with more entries than this */
+  IndexType min_score ;   /* smallest column score */
+  IndexType max_deg ;   /* maximum row degree */
+  IndexType next_col ;    /* Used to add to degree list.*/
+
+
+  /* === Extract knobs ==================================================== */
+
+  dense_row_count = numext::maxi(IndexType(0), numext::mini(IndexType(knobs [COLAMD_DENSE_ROW] * n_col), n_col)) ;
+  dense_col_count = numext::maxi(IndexType(0), numext::mini(IndexType(knobs [COLAMD_DENSE_COL] * n_row), n_row)) ;
+  COLAMD_DEBUG1 (("colamd: densecount: %d %d\n", dense_row_count, dense_col_count)) ;
+  max_deg = 0 ;
+  n_col2 = n_col ;
+  n_row2 = n_row ;
+
+  /* === Kill empty columns =============================================== */
+
+  /* Put the empty columns at the end in their natural order, so that LU */
+  /* factorization can proceed as far as possible. */
+  for (c = n_col-1 ; c >= 0 ; c--)
+  {
+    deg = Col [c].length ;
+    if (deg == 0)
+    {
+      /* this is a empty column, kill and order it last */
+      Col [c].shared2.order = --n_col2 ;
+      KILL_PRINCIPAL_COL (c) ;
+    }
+  }
+  COLAMD_DEBUG1 (("colamd: null columns killed: %d\n", n_col - n_col2)) ;
+
+  /* === Kill dense columns =============================================== */
+
+  /* Put the dense columns at the end, in their natural order */
+  for (c = n_col-1 ; c >= 0 ; c--)
+  {
+    /* skip any dead columns */
+    if (COL_IS_DEAD (c))
+    {
+      continue ;
+    }
+    deg = Col [c].length ;
+    if (deg > dense_col_count)
+    {
+      /* this is a dense column, kill and order it last */
+      Col [c].shared2.order = --n_col2 ;
+      /* decrement the row degrees */
+      cp = &A [Col [c].start] ;
+      cp_end = cp + Col [c].length ;
+      while (cp < cp_end)
+      {
+	Row [*cp++].shared1.degree-- ;
+      }
+      KILL_PRINCIPAL_COL (c) ;
+    }
+  }
+  COLAMD_DEBUG1 (("colamd: Dense and null columns killed: %d\n", n_col - n_col2)) ;
+
+  /* === Kill dense and empty rows ======================================== */
+
+  for (r = 0 ; r < n_row ; r++)
+  {
+    deg = Row [r].shared1.degree ;
+    COLAMD_ASSERT (deg >= 0 && deg <= n_col) ;
+    if (deg > dense_row_count || deg == 0)
+    {
+      /* kill a dense or empty row */
+      KILL_ROW (r) ;
+      --n_row2 ;
+    }
+    else
+    {
+      /* keep track of max degree of remaining rows */
+      max_deg = numext::maxi(max_deg, deg) ;
+    }
+  }
+  COLAMD_DEBUG1 (("colamd: Dense and null rows killed: %d\n", n_row - n_row2)) ;
+
+  /* === Compute initial column scores ==================================== */
+
+  /* At this point the row degrees are accurate.  They reflect the number */
+  /* of "live" (non-dense) columns in each row.  No empty rows exist. */
+  /* Some "live" columns may contain only dead rows, however.  These are */
+  /* pruned in the code below. */
+
+  /* now find the initial matlab score for each column */
+  for (c = n_col-1 ; c >= 0 ; c--)
+  {
+    /* skip dead column */
+    if (COL_IS_DEAD (c))
+    {
+      continue ;
+    }
+    score = 0 ;
+    cp = &A [Col [c].start] ;
+    new_cp = cp ;
+    cp_end = cp + Col [c].length ;
+    while (cp < cp_end)
+    {
+      /* get a row */
+      row = *cp++ ;
+      /* skip if dead */
+      if (ROW_IS_DEAD (row))
+      {
+	continue ;
+      }
+      /* compact the column */
+      *new_cp++ = row ;
+      /* add row's external degree */
+      score += Row [row].shared1.degree - 1 ;
+      /* guard against integer overflow */
+      score = numext::mini(score, n_col) ;
+    }
+    /* determine pruned column length */
+    col_length = (IndexType) (new_cp - &A [Col [c].start]) ;
+    if (col_length == 0)
+    {
+      /* a newly-made null column (all rows in this col are "dense" */
+      /* and have already been killed) */
+      COLAMD_DEBUG2 (("Newly null killed: %d\n", c)) ;
+      Col [c].shared2.order = --n_col2 ;
+      KILL_PRINCIPAL_COL (c) ;
+    }
+    else
+    {
+      /* set column length and set score */
+      COLAMD_ASSERT (score >= 0) ;
+      COLAMD_ASSERT (score <= n_col) ;
+      Col [c].length = col_length ;
+      Col [c].shared2.score = score ;
+    }
+  }
+  COLAMD_DEBUG1 (("colamd: Dense, null, and newly-null columns killed: %d\n",
+		  n_col-n_col2)) ;
+
+  /* At this point, all empty rows and columns are dead.  All live columns */
+  /* are "clean" (containing no dead rows) and simplicial (no supercolumns */
+  /* yet).  Rows may contain dead columns, but all live rows contain at */
+  /* least one live column. */
+
+  /* === Initialize degree lists ========================================== */
+
+
+  /* clear the hash buckets */
+  for (c = 0 ; c <= n_col ; c++)
+  {
+    head [c] = COLAMD_EMPTY ;
+  }
+  min_score = n_col ;
+  /* place in reverse order, so low column indices are at the front */
+  /* of the lists.  This is to encourage natural tie-breaking */
+  for (c = n_col-1 ; c >= 0 ; c--)
+  {
+    /* only add principal columns to degree lists */
+    if (COL_IS_ALIVE (c))
+    {
+      COLAMD_DEBUG4 (("place %d score %d minscore %d ncol %d\n",
+		      c, Col [c].shared2.score, min_score, n_col)) ;
+
+      /* === Add columns score to DList =============================== */
+
+      score = Col [c].shared2.score ;
+
+      COLAMD_ASSERT (min_score >= 0) ;
+      COLAMD_ASSERT (min_score <= n_col) ;
+      COLAMD_ASSERT (score >= 0) ;
+      COLAMD_ASSERT (score <= n_col) ;
+      COLAMD_ASSERT (head [score] >= COLAMD_EMPTY) ;
+
+      /* now add this column to dList at proper score location */
+      next_col = head [score] ;
+      Col [c].shared3.prev = COLAMD_EMPTY ;
+      Col [c].shared4.degree_next = next_col ;
+
+      /* if there already was a column with the same score, set its */
+      /* previous pointer to this new column */
+      if (next_col != COLAMD_EMPTY)
+      {
+	Col [next_col].shared3.prev = c ;
+      }
+      head [score] = c ;
+
+      /* see if this score is less than current min */
+      min_score = numext::mini(min_score, score) ;
+
+
+    }
+  }
+
+
+  /* === Return number of remaining columns, and max row degree =========== */
+
+  *p_n_col2 = n_col2 ;
+  *p_n_row2 = n_row2 ;
+  *p_max_deg = max_deg ;
+}
+
+
+/* ========================================================================== */
+/* === find_ordering ======================================================== */
+/* ========================================================================== */
+
+/*
+  Order the principal columns of the supercolumn form of the matrix
+  (no supercolumns on input).  Uses a minimum approximate column minimum
+  degree ordering method.  Not user-callable.
+*/
+template <typename IndexType>
+static IndexType find_ordering /* return the number of garbage collections */
+  (
+    /* === Parameters ======================================================= */
+
+    IndexType n_row,      /* number of rows of A */
+    IndexType n_col,      /* number of columns of A */
+    IndexType Alen,     /* size of A, 2*nnz + n_col or larger */
+    Colamd_Row<IndexType> Row [],    /* of size n_row+1 */
+    colamd_col<IndexType> Col [],    /* of size n_col+1 */
+    IndexType A [],     /* column form and row form of A */
+    IndexType head [],    /* of size n_col+1 */
+    IndexType n_col2,     /* Remaining columns to order */
+    IndexType max_deg,    /* Maximum row degree */
+    IndexType pfree     /* index of first free slot (2*nnz on entry) */
+    )
+{
+  /* === Local variables ================================================== */
+
+  IndexType k ;     /* current pivot ordering step */
+  IndexType pivot_col ;   /* current pivot column */
+  IndexType *cp ;     /* a column pointer */
+  IndexType *rp ;     /* a row pointer */
+  IndexType pivot_row ;   /* current pivot row */
+  IndexType *new_cp ;   /* modified column pointer */
+  IndexType *new_rp ;   /* modified row pointer */
+  IndexType pivot_row_start ; /* pointer to start of pivot row */
+  IndexType pivot_row_degree ;  /* number of columns in pivot row */
+  IndexType pivot_row_length ;  /* number of supercolumns in pivot row */
+  IndexType pivot_col_score ; /* score of pivot column */
+  IndexType needed_memory ;   /* free space needed for pivot row */
+  IndexType *cp_end ;   /* pointer to the end of a column */
+  IndexType *rp_end ;   /* pointer to the end of a row */
+  IndexType row ;     /* a row index */
+  IndexType col ;     /* a column index */
+  IndexType max_score ;   /* maximum possible score */
+  IndexType cur_score ;   /* score of current column */
+  unsigned int hash ;   /* hash value for supernode detection */
+  IndexType head_column ;   /* head of hash bucket */
+  IndexType first_col ;   /* first column in hash bucket */
+  IndexType tag_mark ;    /* marker value for mark array */
+  IndexType row_mark ;    /* Row [row].shared2.mark */
+  IndexType set_difference ;  /* set difference size of row with pivot row */
+  IndexType min_score ;   /* smallest column score */
+  IndexType col_thickness ;   /* "thickness" (no. of columns in a supercol) */
+  IndexType max_mark ;    /* maximum value of tag_mark */
+  IndexType pivot_col_thickness ; /* number of columns represented by pivot col */
+  IndexType prev_col ;    /* Used by Dlist operations. */
+  IndexType next_col ;    /* Used by Dlist operations. */
+  IndexType ngarbage ;    /* number of garbage collections performed */
+
+
+  /* === Initialization and clear mark ==================================== */
+
+  max_mark = INT_MAX - n_col ;  /* INT_MAX defined in <limits.h> */
+  tag_mark = Eigen::internal::clear_mark (n_row, Row) ;
+  min_score = 0 ;
+  ngarbage = 0 ;
+  COLAMD_DEBUG1 (("colamd: Ordering, n_col2=%d\n", n_col2)) ;
+
+  /* === Order the columns ================================================ */
+
+  for (k = 0 ; k < n_col2 ; /* 'k' is incremented below */)
+  {
+
+    /* === Select pivot column, and order it ============================ */
+
+    /* make sure degree list isn't empty */
+    COLAMD_ASSERT (min_score >= 0) ;
+    COLAMD_ASSERT (min_score <= n_col) ;
+    COLAMD_ASSERT (head [min_score] >= COLAMD_EMPTY) ;
+
+    /* get pivot column from head of minimum degree list */
+    while (min_score < n_col && head [min_score] == COLAMD_EMPTY)
+    {
+      min_score++ ;
+    }
+    pivot_col = head [min_score] ;
+    COLAMD_ASSERT (pivot_col >= 0 && pivot_col <= n_col) ;
+    next_col = Col [pivot_col].shared4.degree_next ;
+    head [min_score] = next_col ;
+    if (next_col != COLAMD_EMPTY)
+    {
+      Col [next_col].shared3.prev = COLAMD_EMPTY ;
+    }
+
+    COLAMD_ASSERT (COL_IS_ALIVE (pivot_col)) ;
+    COLAMD_DEBUG3 (("Pivot col: %d\n", pivot_col)) ;
+
+    /* remember score for defrag check */
+    pivot_col_score = Col [pivot_col].shared2.score ;
+
+    /* the pivot column is the kth column in the pivot order */
+    Col [pivot_col].shared2.order = k ;
+
+    /* increment order count by column thickness */
+    pivot_col_thickness = Col [pivot_col].shared1.thickness ;
+    k += pivot_col_thickness ;
+    COLAMD_ASSERT (pivot_col_thickness > 0) ;
+
+    /* === Garbage_collection, if necessary ============================= */
+
+    needed_memory = numext::mini(pivot_col_score, n_col - k) ;
+    if (pfree + needed_memory >= Alen)
+    {
+      pfree = Eigen::internal::garbage_collection (n_row, n_col, Row, Col, A, &A [pfree]) ;
+      ngarbage++ ;
+      /* after garbage collection we will have enough */
+      COLAMD_ASSERT (pfree + needed_memory < Alen) ;
+      /* garbage collection has wiped out the Row[].shared2.mark array */
+      tag_mark = Eigen::internal::clear_mark (n_row, Row) ;
+
+    }
+
+    /* === Compute pivot row pattern ==================================== */
+
+    /* get starting location for this new merged row */
+    pivot_row_start = pfree ;
+
+    /* initialize new row counts to zero */
+    pivot_row_degree = 0 ;
+
+    /* tag pivot column as having been visited so it isn't included */
+    /* in merged pivot row */
+    Col [pivot_col].shared1.thickness = -pivot_col_thickness ;
+
+    /* pivot row is the union of all rows in the pivot column pattern */
+    cp = &A [Col [pivot_col].start] ;
+    cp_end = cp + Col [pivot_col].length ;
+    while (cp < cp_end)
+    {
+      /* get a row */
+      row = *cp++ ;
+      COLAMD_DEBUG4 (("Pivot col pattern %d %d\n", ROW_IS_ALIVE (row), row)) ;
+      /* skip if row is dead */
+      if (ROW_IS_DEAD (row))
+      {
+	continue ;
+      }
+      rp = &A [Row [row].start] ;
+      rp_end = rp + Row [row].length ;
+      while (rp < rp_end)
+      {
+	/* get a column */
+	col = *rp++ ;
+	/* add the column, if alive and untagged */
+	col_thickness = Col [col].shared1.thickness ;
+	if (col_thickness > 0 && COL_IS_ALIVE (col))
+	{
+	  /* tag column in pivot row */
+	  Col [col].shared1.thickness = -col_thickness ;
+	  COLAMD_ASSERT (pfree < Alen) ;
+	  /* place column in pivot row */
+	  A [pfree++] = col ;
+	  pivot_row_degree += col_thickness ;
+	}
+      }
+    }
+
+    /* clear tag on pivot column */
+    Col [pivot_col].shared1.thickness = pivot_col_thickness ;
+    max_deg = numext::maxi(max_deg, pivot_row_degree) ;
+
+
+    /* === Kill all rows used to construct pivot row ==================== */
+
+    /* also kill pivot row, temporarily */
+    cp = &A [Col [pivot_col].start] ;
+    cp_end = cp + Col [pivot_col].length ;
+    while (cp < cp_end)
+    {
+      /* may be killing an already dead row */
+      row = *cp++ ;
+      COLAMD_DEBUG3 (("Kill row in pivot col: %d\n", row)) ;
+      KILL_ROW (row) ;
+    }
+
+    /* === Select a row index to use as the new pivot row =============== */
+
+    pivot_row_length = pfree - pivot_row_start ;
+    if (pivot_row_length > 0)
+    {
+      /* pick the "pivot" row arbitrarily (first row in col) */
+      pivot_row = A [Col [pivot_col].start] ;
+      COLAMD_DEBUG3 (("Pivotal row is %d\n", pivot_row)) ;
+    }
+    else
+    {
+      /* there is no pivot row, since it is of zero length */
+      pivot_row = COLAMD_EMPTY ;
+      COLAMD_ASSERT (pivot_row_length == 0) ;
+    }
+    COLAMD_ASSERT (Col [pivot_col].length > 0 || pivot_row_length == 0) ;
+
+    /* === Approximate degree computation =============================== */
+
+    /* Here begins the computation of the approximate degree.  The column */
+    /* score is the sum of the pivot row "length", plus the size of the */
+    /* set differences of each row in the column minus the pattern of the */
+    /* pivot row itself.  The column ("thickness") itself is also */
+    /* excluded from the column score (we thus use an approximate */
+    /* external degree). */
+
+    /* The time taken by the following code (compute set differences, and */
+    /* add them up) is proportional to the size of the data structure */
+    /* being scanned - that is, the sum of the sizes of each column in */
+    /* the pivot row.  Thus, the amortized time to compute a column score */
+    /* is proportional to the size of that column (where size, in this */
+    /* context, is the column "length", or the number of row indices */
+    /* in that column).  The number of row indices in a column is */
+    /* monotonically non-decreasing, from the length of the original */
+    /* column on input to colamd. */
+
+    /* === Compute set differences ====================================== */
+
+    COLAMD_DEBUG3 (("** Computing set differences phase. **\n")) ;
+
+    /* pivot row is currently dead - it will be revived later. */
+
+    COLAMD_DEBUG3 (("Pivot row: ")) ;
+    /* for each column in pivot row */
+    rp = &A [pivot_row_start] ;
+    rp_end = rp + pivot_row_length ;
+    while (rp < rp_end)
+    {
+      col = *rp++ ;
+      COLAMD_ASSERT (COL_IS_ALIVE (col) && col != pivot_col) ;
+      COLAMD_DEBUG3 (("Col: %d\n", col)) ;
+
+      /* clear tags used to construct pivot row pattern */
+      col_thickness = -Col [col].shared1.thickness ;
+      COLAMD_ASSERT (col_thickness > 0) ;
+      Col [col].shared1.thickness = col_thickness ;
+
+      /* === Remove column from degree list =========================== */
+
+      cur_score = Col [col].shared2.score ;
+      prev_col = Col [col].shared3.prev ;
+      next_col = Col [col].shared4.degree_next ;
+      COLAMD_ASSERT (cur_score >= 0) ;
+      COLAMD_ASSERT (cur_score <= n_col) ;
+      COLAMD_ASSERT (cur_score >= COLAMD_EMPTY) ;
+      if (prev_col == COLAMD_EMPTY)
+      {
+	head [cur_score] = next_col ;
+      }
+      else
+      {
+	Col [prev_col].shared4.degree_next = next_col ;
+      }
+      if (next_col != COLAMD_EMPTY)
+      {
+	Col [next_col].shared3.prev = prev_col ;
+      }
+
+      /* === Scan the column ========================================== */
+
+      cp = &A [Col [col].start] ;
+      cp_end = cp + Col [col].length ;
+      while (cp < cp_end)
+      {
+	/* get a row */
+	row = *cp++ ;
+	row_mark = Row [row].shared2.mark ;
+	/* skip if dead */
+	if (ROW_IS_MARKED_DEAD (row_mark))
+	{
+	  continue ;
+	}
+	COLAMD_ASSERT (row != pivot_row) ;
+	set_difference = row_mark - tag_mark ;
+	/* check if the row has been seen yet */
+	if (set_difference < 0)
+	{
+	  COLAMD_ASSERT (Row [row].shared1.degree <= max_deg) ;
+	  set_difference = Row [row].shared1.degree ;
+	}
+	/* subtract column thickness from this row's set difference */
+	set_difference -= col_thickness ;
+	COLAMD_ASSERT (set_difference >= 0) ;
+	/* absorb this row if the set difference becomes zero */
+	if (set_difference == 0)
+	{
+	  COLAMD_DEBUG3 (("aggressive absorption. Row: %d\n", row)) ;
+	  KILL_ROW (row) ;
+	}
+	else
+	{
+	  /* save the new mark */
+	  Row [row].shared2.mark = set_difference + tag_mark ;
+	}
+      }
+    }
+
+
+    /* === Add up set differences for each column ======================= */
+
+    COLAMD_DEBUG3 (("** Adding set differences phase. **\n")) ;
+
+    /* for each column in pivot row */
+    rp = &A [pivot_row_start] ;
+    rp_end = rp + pivot_row_length ;
+    while (rp < rp_end)
+    {
+      /* get a column */
+      col = *rp++ ;
+      COLAMD_ASSERT (COL_IS_ALIVE (col) && col != pivot_col) ;
+      hash = 0 ;
+      cur_score = 0 ;
+      cp = &A [Col [col].start] ;
+      /* compact the column */
+      new_cp = cp ;
+      cp_end = cp + Col [col].length ;
+
+      COLAMD_DEBUG4 (("Adding set diffs for Col: %d.\n", col)) ;
+
+      while (cp < cp_end)
+      {
+	/* get a row */
+	row = *cp++ ;
+	COLAMD_ASSERT(row >= 0 && row < n_row) ;
+	row_mark = Row [row].shared2.mark ;
+	/* skip if dead */
+	if (ROW_IS_MARKED_DEAD (row_mark))
+	{
+	  continue ;
+	}
+	COLAMD_ASSERT (row_mark > tag_mark) ;
+	/* compact the column */
+	*new_cp++ = row ;
+	/* compute hash function */
+	hash += row ;
+	/* add set difference */
+	cur_score += row_mark - tag_mark ;
+	/* integer overflow... */
+	cur_score = numext::mini(cur_score, n_col) ;
+      }
+
+      /* recompute the column's length */
+      Col [col].length = (IndexType) (new_cp - &A [Col [col].start]) ;
+
+      /* === Further mass elimination ================================= */
+
+      if (Col [col].length == 0)
+      {
+	COLAMD_DEBUG4 (("further mass elimination. Col: %d\n", col)) ;
+	/* nothing left but the pivot row in this column */
+	KILL_PRINCIPAL_COL (col) ;
+	pivot_row_degree -= Col [col].shared1.thickness ;
+	COLAMD_ASSERT (pivot_row_degree >= 0) ;
+	/* order it */
+	Col [col].shared2.order = k ;
+	/* increment order count by column thickness */
+	k += Col [col].shared1.thickness ;
+      }
+      else
+      {
+	/* === Prepare for supercolumn detection ==================== */
+
+	COLAMD_DEBUG4 (("Preparing supercol detection for Col: %d.\n", col)) ;
+
+	/* save score so far */
+	Col [col].shared2.score = cur_score ;
+
+	/* add column to hash table, for supercolumn detection */
+	hash %= n_col + 1 ;
+
+	COLAMD_DEBUG4 ((" Hash = %d, n_col = %d.\n", hash, n_col)) ;
+	COLAMD_ASSERT (hash <= n_col) ;
+
+	head_column = head [hash] ;
+	if (head_column > COLAMD_EMPTY)
+	{
+	  /* degree list "hash" is non-empty, use prev (shared3) of */
+	  /* first column in degree list as head of hash bucket */
+	  first_col = Col [head_column].shared3.headhash ;
+	  Col [head_column].shared3.headhash = col ;
+	}
+	else
+	{
+	  /* degree list "hash" is empty, use head as hash bucket */
+	  first_col = - (head_column + 2) ;
+	  head [hash] = - (col + 2) ;
+	}
+	Col [col].shared4.hash_next = first_col ;
+
+	/* save hash function in Col [col].shared3.hash */
+	Col [col].shared3.hash = (IndexType) hash ;
+	COLAMD_ASSERT (COL_IS_ALIVE (col)) ;
+      }
+    }
+
+    /* The approximate external column degree is now computed.  */
+
+    /* === Supercolumn detection ======================================== */
+
+    COLAMD_DEBUG3 (("** Supercolumn detection phase. **\n")) ;
+
+    Eigen::internal::detect_super_cols (Col, A, head, pivot_row_start, pivot_row_length) ;
+
+    /* === Kill the pivotal column ====================================== */
+
+    KILL_PRINCIPAL_COL (pivot_col) ;
+
+    /* === Clear mark =================================================== */
+
+    tag_mark += (max_deg + 1) ;
+    if (tag_mark >= max_mark)
+    {
+      COLAMD_DEBUG2 (("clearing tag_mark\n")) ;
+      tag_mark = Eigen::internal::clear_mark (n_row, Row) ;
+    }
+
+    /* === Finalize the new pivot row, and column scores ================ */
+
+    COLAMD_DEBUG3 (("** Finalize scores phase. **\n")) ;
+
+    /* for each column in pivot row */
+    rp = &A [pivot_row_start] ;
+    /* compact the pivot row */
+    new_rp = rp ;
+    rp_end = rp + pivot_row_length ;
+    while (rp < rp_end)
+    {
+      col = *rp++ ;
+      /* skip dead columns */
+      if (COL_IS_DEAD (col))
+      {
+	continue ;
+      }
+      *new_rp++ = col ;
+      /* add new pivot row to column */
+      A [Col [col].start + (Col [col].length++)] = pivot_row ;
+
+      /* retrieve score so far and add on pivot row's degree. */
+      /* (we wait until here for this in case the pivot */
+      /* row's degree was reduced due to mass elimination). */
+      cur_score = Col [col].shared2.score + pivot_row_degree ;
+
+      /* calculate the max possible score as the number of */
+      /* external columns minus the 'k' value minus the */
+      /* columns thickness */
+      max_score = n_col - k - Col [col].shared1.thickness ;
+
+      /* make the score the external degree of the union-of-rows */
+      cur_score -= Col [col].shared1.thickness ;
+
+      /* make sure score is less or equal than the max score */
+      cur_score = numext::mini(cur_score, max_score) ;
+      COLAMD_ASSERT (cur_score >= 0) ;
+
+      /* store updated score */
+      Col [col].shared2.score = cur_score ;
+
+      /* === Place column back in degree list ========================= */
+
+      COLAMD_ASSERT (min_score >= 0) ;
+      COLAMD_ASSERT (min_score <= n_col) ;
+      COLAMD_ASSERT (cur_score >= 0) ;
+      COLAMD_ASSERT (cur_score <= n_col) ;
+      COLAMD_ASSERT (head [cur_score] >= COLAMD_EMPTY) ;
+      next_col = head [cur_score] ;
+      Col [col].shared4.degree_next = next_col ;
+      Col [col].shared3.prev = COLAMD_EMPTY ;
+      if (next_col != COLAMD_EMPTY)
+      {
+	Col [next_col].shared3.prev = col ;
+      }
+      head [cur_score] = col ;
+
+      /* see if this score is less than current min */
+      min_score = numext::mini(min_score, cur_score) ;
+
+    }
+
+    /* === Resurrect the new pivot row ================================== */
+
+    if (pivot_row_degree > 0)
+    {
+      /* update pivot row length to reflect any cols that were killed */
+      /* during super-col detection and mass elimination */
+      Row [pivot_row].start  = pivot_row_start ;
+      Row [pivot_row].length = (IndexType) (new_rp - &A[pivot_row_start]) ;
+      Row [pivot_row].shared1.degree = pivot_row_degree ;
+      Row [pivot_row].shared2.mark = 0 ;
+      /* pivot row is no longer dead */
+    }
+  }
+
+  /* === All principal columns have now been ordered ====================== */
+
+  return (ngarbage) ;
+}
+
+
+/* ========================================================================== */
+/* === order_children ======================================================= */
+/* ========================================================================== */
+
+/*
+  The find_ordering routine has ordered all of the principal columns (the
+  representatives of the supercolumns).  The non-principal columns have not
+  yet been ordered.  This routine orders those columns by walking up the
+  parent tree (a column is a child of the column which absorbed it).  The
+  final permutation vector is then placed in p [0 ... n_col-1], with p [0]
+  being the first column, and p [n_col-1] being the last.  It doesn't look
+  like it at first glance, but be assured that this routine takes time linear
+  in the number of columns.  Although not immediately obvious, the time
+  taken by this routine is O (n_col), that is, linear in the number of
+  columns.  Not user-callable.
+*/
+template <typename IndexType>
+static inline  void order_children
+(
+  /* === Parameters ======================================================= */
+
+  IndexType n_col,      /* number of columns of A */
+  colamd_col<IndexType> Col [],    /* of size n_col+1 */
+  IndexType p []      /* p [0 ... n_col-1] is the column permutation*/
+  )
+{
+  /* === Local variables ================================================== */
+
+  IndexType i ;     /* loop counter for all columns */
+  IndexType c ;     /* column index */
+  IndexType parent ;    /* index of column's parent */
+  IndexType order ;     /* column's order */
+
+  /* === Order each non-principal column ================================== */
+
+  for (i = 0 ; i < n_col ; i++)
+  {
+    /* find an un-ordered non-principal column */
+    COLAMD_ASSERT (COL_IS_DEAD (i)) ;
+    if (!COL_IS_DEAD_PRINCIPAL (i) && Col [i].shared2.order == COLAMD_EMPTY)
+    {
+      parent = i ;
+      /* once found, find its principal parent */
+      do
+      {
+	parent = Col [parent].shared1.parent ;
+      } while (!COL_IS_DEAD_PRINCIPAL (parent)) ;
+
+      /* now, order all un-ordered non-principal columns along path */
+      /* to this parent.  collapse tree at the same time */
+      c = i ;
+      /* get order of parent */
+      order = Col [parent].shared2.order ;
+
+      do
+      {
+	COLAMD_ASSERT (Col [c].shared2.order == COLAMD_EMPTY) ;
+
+	/* order this column */
+	Col [c].shared2.order = order++ ;
+	/* collaps tree */
+	Col [c].shared1.parent = parent ;
+
+	/* get immediate parent of this column */
+	c = Col [c].shared1.parent ;
+
+	/* continue until we hit an ordered column.  There are */
+	/* guarranteed not to be anymore unordered columns */
+	/* above an ordered column */
+      } while (Col [c].shared2.order == COLAMD_EMPTY) ;
+
+      /* re-order the super_col parent to largest order for this group */
+      Col [parent].shared2.order = order ;
+    }
+  }
+
+  /* === Generate the permutation ========================================= */
+
+  for (c = 0 ; c < n_col ; c++)
+  {
+    p [Col [c].shared2.order] = c ;
+  }
+}
+
+
+/* ========================================================================== */
+/* === detect_super_cols ==================================================== */
+/* ========================================================================== */
+
+/*
+  Detects supercolumns by finding matches between columns in the hash buckets.
+  Check amongst columns in the set A [row_start ... row_start + row_length-1].
+  The columns under consideration are currently *not* in the degree lists,
+  and have already been placed in the hash buckets.
+
+  The hash bucket for columns whose hash function is equal to h is stored
+  as follows:
+
+  if head [h] is >= 0, then head [h] contains a degree list, so:
+
+  head [h] is the first column in degree bucket h.
+  Col [head [h]].headhash gives the first column in hash bucket h.
+
+  otherwise, the degree list is empty, and:
+
+  -(head [h] + 2) is the first column in hash bucket h.
+
+  For a column c in a hash bucket, Col [c].shared3.prev is NOT a "previous
+  column" pointer.  Col [c].shared3.hash is used instead as the hash number
+  for that column.  The value of Col [c].shared4.hash_next is the next column
+  in the same hash bucket.
+
+  Assuming no, or "few" hash collisions, the time taken by this routine is
+  linear in the sum of the sizes (lengths) of each column whose score has
+  just been computed in the approximate degree computation.
+  Not user-callable.
+*/
+template <typename IndexType>
+static void detect_super_cols
+(
+  /* === Parameters ======================================================= */
+  
+  colamd_col<IndexType> Col [],    /* of size n_col+1 */
+  IndexType A [],     /* row indices of A */
+  IndexType head [],    /* head of degree lists and hash buckets */
+  IndexType row_start,    /* pointer to set of columns to check */
+  IndexType row_length    /* number of columns to check */
+)
+{
+  /* === Local variables ================================================== */
+
+  IndexType hash ;      /* hash value for a column */
+  IndexType *rp ;     /* pointer to a row */
+  IndexType c ;     /* a column index */
+  IndexType super_c ;   /* column index of the column to absorb into */
+  IndexType *cp1 ;      /* column pointer for column super_c */
+  IndexType *cp2 ;      /* column pointer for column c */
+  IndexType length ;    /* length of column super_c */
+  IndexType prev_c ;    /* column preceding c in hash bucket */
+  IndexType i ;     /* loop counter */
+  IndexType *rp_end ;   /* pointer to the end of the row */
+  IndexType col ;     /* a column index in the row to check */
+  IndexType head_column ;   /* first column in hash bucket or degree list */
+  IndexType first_col ;   /* first column in hash bucket */
+
+  /* === Consider each column in the row ================================== */
+
+  rp = &A [row_start] ;
+  rp_end = rp + row_length ;
+  while (rp < rp_end)
+  {
+    col = *rp++ ;
+    if (COL_IS_DEAD (col))
+    {
+      continue ;
+    }
+
+    /* get hash number for this column */
+    hash = Col [col].shared3.hash ;
+    COLAMD_ASSERT (hash <= n_col) ;
+
+    /* === Get the first column in this hash bucket ===================== */
+
+    head_column = head [hash] ;
+    if (head_column > COLAMD_EMPTY)
+    {
+      first_col = Col [head_column].shared3.headhash ;
+    }
+    else
+    {
+      first_col = - (head_column + 2) ;
+    }
+
+    /* === Consider each column in the hash bucket ====================== */
+
+    for (super_c = first_col ; super_c != COLAMD_EMPTY ;
+	 super_c = Col [super_c].shared4.hash_next)
+    {
+      COLAMD_ASSERT (COL_IS_ALIVE (super_c)) ;
+      COLAMD_ASSERT (Col [super_c].shared3.hash == hash) ;
+      length = Col [super_c].length ;
+
+      /* prev_c is the column preceding column c in the hash bucket */
+      prev_c = super_c ;
+
+      /* === Compare super_c with all columns after it ================ */
+
+      for (c = Col [super_c].shared4.hash_next ;
+	   c != COLAMD_EMPTY ; c = Col [c].shared4.hash_next)
+      {
+	COLAMD_ASSERT (c != super_c) ;
+	COLAMD_ASSERT (COL_IS_ALIVE (c)) ;
+	COLAMD_ASSERT (Col [c].shared3.hash == hash) ;
+
+	/* not identical if lengths or scores are different */
+	if (Col [c].length != length ||
+	    Col [c].shared2.score != Col [super_c].shared2.score)
+	{
+	  prev_c = c ;
+	  continue ;
+	}
+
+	/* compare the two columns */
+	cp1 = &A [Col [super_c].start] ;
+	cp2 = &A [Col [c].start] ;
+
+	for (i = 0 ; i < length ; i++)
+	{
+	  /* the columns are "clean" (no dead rows) */
+	  COLAMD_ASSERT (ROW_IS_ALIVE (*cp1))  ;
+	  COLAMD_ASSERT (ROW_IS_ALIVE (*cp2))  ;
+	  /* row indices will same order for both supercols, */
+	  /* no gather scatter nessasary */
+	  if (*cp1++ != *cp2++)
+	  {
+	    break ;
+	  }
+	}
+
+	/* the two columns are different if the for-loop "broke" */
+	if (i != length)
+	{
+	  prev_c = c ;
+	  continue ;
+	}
+
+	/* === Got it!  two columns are identical =================== */
+
+	COLAMD_ASSERT (Col [c].shared2.score == Col [super_c].shared2.score) ;
+
+	Col [super_c].shared1.thickness += Col [c].shared1.thickness ;
+	Col [c].shared1.parent = super_c ;
+	KILL_NON_PRINCIPAL_COL (c) ;
+	/* order c later, in order_children() */
+	Col [c].shared2.order = COLAMD_EMPTY ;
+	/* remove c from hash bucket */
+	Col [prev_c].shared4.hash_next = Col [c].shared4.hash_next ;
+      }
+    }
+
+    /* === Empty this hash bucket ======================================= */
+
+    if (head_column > COLAMD_EMPTY)
+    {
+      /* corresponding degree list "hash" is not empty */
+      Col [head_column].shared3.headhash = COLAMD_EMPTY ;
+    }
+    else
+    {
+      /* corresponding degree list "hash" is empty */
+      head [hash] = COLAMD_EMPTY ;
+    }
+  }
+}
+
+
+/* ========================================================================== */
+/* === garbage_collection =================================================== */
+/* ========================================================================== */
+
+/*
+  Defragments and compacts columns and rows in the workspace A.  Used when
+  all avaliable memory has been used while performing row merging.  Returns
+  the index of the first free position in A, after garbage collection.  The
+  time taken by this routine is linear is the size of the array A, which is
+  itself linear in the number of nonzeros in the input matrix.
+  Not user-callable.
+*/
+template <typename IndexType>
+static IndexType garbage_collection  /* returns the new value of pfree */
+  (
+    /* === Parameters ======================================================= */
+    
+    IndexType n_row,      /* number of rows */
+    IndexType n_col,      /* number of columns */
+    Colamd_Row<IndexType> Row [],    /* row info */
+    colamd_col<IndexType> Col [],    /* column info */
+    IndexType A [],     /* A [0 ... Alen-1] holds the matrix */
+    IndexType *pfree      /* &A [0] ... pfree is in use */
+    )
+{
+  /* === Local variables ================================================== */
+
+  IndexType *psrc ;     /* source pointer */
+  IndexType *pdest ;    /* destination pointer */
+  IndexType j ;     /* counter */
+  IndexType r ;     /* a row index */
+  IndexType c ;     /* a column index */
+  IndexType length ;    /* length of a row or column */
+
+  /* === Defragment the columns =========================================== */
+
+  pdest = &A[0] ;
+  for (c = 0 ; c < n_col ; c++)
+  {
+    if (COL_IS_ALIVE (c))
+    {
+      psrc = &A [Col [c].start] ;
+
+      /* move and compact the column */
+      COLAMD_ASSERT (pdest <= psrc) ;
+      Col [c].start = (IndexType) (pdest - &A [0]) ;
+      length = Col [c].length ;
+      for (j = 0 ; j < length ; j++)
+      {
+	r = *psrc++ ;
+	if (ROW_IS_ALIVE (r))
+	{
+	  *pdest++ = r ;
+	}
+      }
+      Col [c].length = (IndexType) (pdest - &A [Col [c].start]) ;
+    }
+  }
+
+  /* === Prepare to defragment the rows =================================== */
+
+  for (r = 0 ; r < n_row ; r++)
+  {
+    if (ROW_IS_ALIVE (r))
+    {
+      if (Row [r].length == 0)
+      {
+	/* this row is of zero length.  cannot compact it, so kill it */
+	COLAMD_DEBUG3 (("Defrag row kill\n")) ;
+	KILL_ROW (r) ;
+      }
+      else
+      {
+	/* save first column index in Row [r].shared2.first_column */
+	psrc = &A [Row [r].start] ;
+	Row [r].shared2.first_column = *psrc ;
+	COLAMD_ASSERT (ROW_IS_ALIVE (r)) ;
+	/* flag the start of the row with the one's complement of row */
+	*psrc = ONES_COMPLEMENT (r) ;
+
+      }
+    }
+  }
+
+  /* === Defragment the rows ============================================== */
+
+  psrc = pdest ;
+  while (psrc < pfree)
+  {
+    /* find a negative number ... the start of a row */
+    if (*psrc++ < 0)
+    {
+      psrc-- ;
+      /* get the row index */
+      r = ONES_COMPLEMENT (*psrc) ;
+      COLAMD_ASSERT (r >= 0 && r < n_row) ;
+      /* restore first column index */
+      *psrc = Row [r].shared2.first_column ;
+      COLAMD_ASSERT (ROW_IS_ALIVE (r)) ;
+
+      /* move and compact the row */
+      COLAMD_ASSERT (pdest <= psrc) ;
+      Row [r].start = (IndexType) (pdest - &A [0]) ;
+      length = Row [r].length ;
+      for (j = 0 ; j < length ; j++)
+      {
+	c = *psrc++ ;
+	if (COL_IS_ALIVE (c))
+	{
+	  *pdest++ = c ;
+	}
+      }
+      Row [r].length = (IndexType) (pdest - &A [Row [r].start]) ;
+
+    }
+  }
+  /* ensure we found all the rows */
+  COLAMD_ASSERT (debug_rows == 0) ;
+
+  /* === Return the new value of pfree ==================================== */
+
+  return ((IndexType) (pdest - &A [0])) ;
+}
+
+
+/* ========================================================================== */
+/* === clear_mark =========================================================== */
+/* ========================================================================== */
+
+/*
+  Clears the Row [].shared2.mark array, and returns the new tag_mark.
+  Return value is the new tag_mark.  Not user-callable.
+*/
+template <typename IndexType>
+static inline  IndexType clear_mark  /* return the new value for tag_mark */
+  (
+      /* === Parameters ======================================================= */
+
+    IndexType n_row,    /* number of rows in A */
+    Colamd_Row<IndexType> Row [] /* Row [0 ... n_row-1].shared2.mark is set to zero */
+    )
+{
+  /* === Local variables ================================================== */
+
+  IndexType r ;
+
+  for (r = 0 ; r < n_row ; r++)
+  {
+    if (ROW_IS_ALIVE (r))
+    {
+      Row [r].shared2.mark = 0 ;
+    }
+  }
+  return (1) ;
+}
+
+
+} // namespace internal 
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/OrderingMethods/Ordering.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/OrderingMethods/Ordering.h
new file mode 100644
index 00000000..7ea9b14d
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/OrderingMethods/Ordering.h
@@ -0,0 +1,157 @@
+ 
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012  Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ORDERING_H
+#define EIGEN_ORDERING_H
+
+namespace Eigen {
+  
+#include "Eigen_Colamd.h"
+
+namespace internal {
+    
+/** \internal
+  * \ingroup OrderingMethods_Module
+  * \param[in] A the input non-symmetric matrix
+  * \param[out] symmat the symmetric pattern A^T+A from the input matrix \a A.
+  * FIXME: The values should not be considered here
+  */
+template<typename MatrixType> 
+void ordering_helper_at_plus_a(const MatrixType& A, MatrixType& symmat)
+{
+  MatrixType C;
+  C = A.transpose(); // NOTE: Could be  costly
+  for (int i = 0; i < C.rows(); i++) 
+  {
+      for (typename MatrixType::InnerIterator it(C, i); it; ++it)
+        it.valueRef() = 0.0;
+  }
+  symmat = C + A;
+}
+    
+}
+
+#ifndef EIGEN_MPL2_ONLY
+
+/** \ingroup OrderingMethods_Module
+  * \class AMDOrdering
+  *
+  * Functor computing the \em approximate \em minimum \em degree ordering
+  * If the matrix is not structurally symmetric, an ordering of A^T+A is computed
+  * \tparam  StorageIndex The type of indices of the matrix 
+  * \sa COLAMDOrdering
+  */
+template <typename StorageIndex>
+class AMDOrdering
+{
+  public:
+    typedef PermutationMatrix<Dynamic, Dynamic, StorageIndex> PermutationType;
+    
+    /** Compute the permutation vector from a sparse matrix
+     * This routine is much faster if the input matrix is column-major     
+     */
+    template <typename MatrixType>
+    void operator()(const MatrixType& mat, PermutationType& perm)
+    {
+      // Compute the symmetric pattern
+      SparseMatrix<typename MatrixType::Scalar, ColMajor, StorageIndex> symm;
+      internal::ordering_helper_at_plus_a(mat,symm); 
+    
+      // Call the AMD routine 
+      //m_mat.prune(keep_diag());
+      internal::minimum_degree_ordering(symm, perm);
+    }
+    
+    /** Compute the permutation with a selfadjoint matrix */
+    template <typename SrcType, unsigned int SrcUpLo> 
+    void operator()(const SparseSelfAdjointView<SrcType, SrcUpLo>& mat, PermutationType& perm)
+    { 
+      SparseMatrix<typename SrcType::Scalar, ColMajor, StorageIndex> C; C = mat;
+      
+      // Call the AMD routine 
+      // m_mat.prune(keep_diag()); //Remove the diagonal elements 
+      internal::minimum_degree_ordering(C, perm);
+    }
+};
+
+#endif // EIGEN_MPL2_ONLY
+
+/** \ingroup OrderingMethods_Module
+  * \class NaturalOrdering
+  *
+  * Functor computing the natural ordering (identity)
+  * 
+  * \note Returns an empty permutation matrix
+  * \tparam  StorageIndex The type of indices of the matrix 
+  */
+template <typename StorageIndex>
+class NaturalOrdering
+{
+  public:
+    typedef PermutationMatrix<Dynamic, Dynamic, StorageIndex> PermutationType;
+    
+    /** Compute the permutation vector from a column-major sparse matrix */
+    template <typename MatrixType>
+    void operator()(const MatrixType& /*mat*/, PermutationType& perm)
+    {
+      perm.resize(0); 
+    }
+    
+};
+
+/** \ingroup OrderingMethods_Module
+  * \class COLAMDOrdering
+  *
+  * \tparam  StorageIndex The type of indices of the matrix 
+  * 
+  * Functor computing the \em column \em approximate \em minimum \em degree ordering 
+  * The matrix should be in column-major and \b compressed format (see SparseMatrix::makeCompressed()).
+  */
+template<typename StorageIndex>
+class COLAMDOrdering
+{
+  public:
+    typedef PermutationMatrix<Dynamic, Dynamic, StorageIndex> PermutationType; 
+    typedef Matrix<StorageIndex, Dynamic, 1> IndexVector;
+    
+    /** Compute the permutation vector \a perm form the sparse matrix \a mat
+      * \warning The input sparse matrix \a mat must be in compressed mode (see SparseMatrix::makeCompressed()).
+      */
+    template <typename MatrixType>
+    void operator() (const MatrixType& mat, PermutationType& perm)
+    {
+      eigen_assert(mat.isCompressed() && "COLAMDOrdering requires a sparse matrix in compressed mode. Call .makeCompressed() before passing it to COLAMDOrdering");
+      
+      StorageIndex m = StorageIndex(mat.rows());
+      StorageIndex n = StorageIndex(mat.cols());
+      StorageIndex nnz = StorageIndex(mat.nonZeros());
+      // Get the recommended value of Alen to be used by colamd
+      StorageIndex Alen = internal::colamd_recommended(nnz, m, n); 
+      // Set the default parameters
+      double knobs [COLAMD_KNOBS]; 
+      StorageIndex stats [COLAMD_STATS];
+      internal::colamd_set_defaults(knobs);
+      
+      IndexVector p(n+1), A(Alen); 
+      for(StorageIndex i=0; i <= n; i++)   p(i) = mat.outerIndexPtr()[i];
+      for(StorageIndex i=0; i < nnz; i++)  A(i) = mat.innerIndexPtr()[i];
+      // Call Colamd routine to compute the ordering 
+      StorageIndex info = internal::colamd(m, n, Alen, A.data(), p.data(), knobs, stats); 
+      EIGEN_UNUSED_VARIABLE(info);
+      eigen_assert( info && "COLAMD failed " );
+      
+      perm.resize(n);
+      for (StorageIndex i = 0; i < n; i++) perm.indices()(p(i)) = i;
+    }
+};
+
+} // end namespace Eigen
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/PaStiXSupport/PaStiXSupport.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/PaStiXSupport/PaStiXSupport.h
new file mode 100644
index 00000000..d2ebfd7b
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/PaStiXSupport/PaStiXSupport.h
@@ -0,0 +1,678 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PASTIXSUPPORT_H
+#define EIGEN_PASTIXSUPPORT_H
+
+namespace Eigen { 
+
+#if defined(DCOMPLEX)
+  #define PASTIX_COMPLEX  COMPLEX
+  #define PASTIX_DCOMPLEX DCOMPLEX
+#else
+  #define PASTIX_COMPLEX  std::complex<float>
+  #define PASTIX_DCOMPLEX std::complex<double>
+#endif
+
+/** \ingroup PaStiXSupport_Module
+  * \brief Interface to the PaStix solver
+  * 
+  * This class is used to solve the linear systems A.X = B via the PaStix library. 
+  * The matrix can be either real or complex, symmetric or not.
+  *
+  * \sa TutorialSparseDirectSolvers
+  */
+template<typename _MatrixType, bool IsStrSym = false> class PastixLU;
+template<typename _MatrixType, int Options> class PastixLLT;
+template<typename _MatrixType, int Options> class PastixLDLT;
+
+namespace internal
+{
+    
+  template<class Pastix> struct pastix_traits;
+
+  template<typename _MatrixType>
+  struct pastix_traits< PastixLU<_MatrixType> >
+  {
+    typedef _MatrixType MatrixType;
+    typedef typename _MatrixType::Scalar Scalar;
+    typedef typename _MatrixType::RealScalar RealScalar;
+    typedef typename _MatrixType::StorageIndex StorageIndex;
+  };
+
+  template<typename _MatrixType, int Options>
+  struct pastix_traits< PastixLLT<_MatrixType,Options> >
+  {
+    typedef _MatrixType MatrixType;
+    typedef typename _MatrixType::Scalar Scalar;
+    typedef typename _MatrixType::RealScalar RealScalar;
+    typedef typename _MatrixType::StorageIndex StorageIndex;
+  };
+
+  template<typename _MatrixType, int Options>
+  struct pastix_traits< PastixLDLT<_MatrixType,Options> >
+  {
+    typedef _MatrixType MatrixType;
+    typedef typename _MatrixType::Scalar Scalar;
+    typedef typename _MatrixType::RealScalar RealScalar;
+    typedef typename _MatrixType::StorageIndex StorageIndex;
+  };
+  
+  void eigen_pastix(pastix_data_t **pastix_data, int pastix_comm, int n, int *ptr, int *idx, float *vals, int *perm, int * invp, float *x, int nbrhs, int *iparm, double *dparm)
+  {
+    if (n == 0) { ptr = NULL; idx = NULL; vals = NULL; }
+    if (nbrhs == 0) {x = NULL; nbrhs=1;}
+    s_pastix(pastix_data, pastix_comm, n, ptr, idx, vals, perm, invp, x, nbrhs, iparm, dparm); 
+  }
+  
+  void eigen_pastix(pastix_data_t **pastix_data, int pastix_comm, int n, int *ptr, int *idx, double *vals, int *perm, int * invp, double *x, int nbrhs, int *iparm, double *dparm)
+  {
+    if (n == 0) { ptr = NULL; idx = NULL; vals = NULL; }
+    if (nbrhs == 0) {x = NULL; nbrhs=1;}
+    d_pastix(pastix_data, pastix_comm, n, ptr, idx, vals, perm, invp, x, nbrhs, iparm, dparm); 
+  }
+  
+  void eigen_pastix(pastix_data_t **pastix_data, int pastix_comm, int n, int *ptr, int *idx, std::complex<float> *vals, int *perm, int * invp, std::complex<float> *x, int nbrhs, int *iparm, double *dparm)
+  {
+    if (n == 0) { ptr = NULL; idx = NULL; vals = NULL; }
+    if (nbrhs == 0) {x = NULL; nbrhs=1;}
+    c_pastix(pastix_data, pastix_comm, n, ptr, idx, reinterpret_cast<PASTIX_COMPLEX*>(vals), perm, invp, reinterpret_cast<PASTIX_COMPLEX*>(x), nbrhs, iparm, dparm); 
+  }
+  
+  void eigen_pastix(pastix_data_t **pastix_data, int pastix_comm, int n, int *ptr, int *idx, std::complex<double> *vals, int *perm, int * invp, std::complex<double> *x, int nbrhs, int *iparm, double *dparm)
+  {
+    if (n == 0) { ptr = NULL; idx = NULL; vals = NULL; }
+    if (nbrhs == 0) {x = NULL; nbrhs=1;}
+    z_pastix(pastix_data, pastix_comm, n, ptr, idx, reinterpret_cast<PASTIX_DCOMPLEX*>(vals), perm, invp, reinterpret_cast<PASTIX_DCOMPLEX*>(x), nbrhs, iparm, dparm); 
+  }
+
+  // Convert the matrix  to Fortran-style Numbering
+  template <typename MatrixType>
+  void c_to_fortran_numbering (MatrixType& mat)
+  {
+    if ( !(mat.outerIndexPtr()[0]) ) 
+    { 
+      int i;
+      for(i = 0; i <= mat.rows(); ++i)
+        ++mat.outerIndexPtr()[i];
+      for(i = 0; i < mat.nonZeros(); ++i)
+        ++mat.innerIndexPtr()[i];
+    }
+  }
+  
+  // Convert to C-style Numbering
+  template <typename MatrixType>
+  void fortran_to_c_numbering (MatrixType& mat)
+  {
+    // Check the Numbering
+    if ( mat.outerIndexPtr()[0] == 1 ) 
+    { // Convert to C-style numbering
+      int i;
+      for(i = 0; i <= mat.rows(); ++i)
+        --mat.outerIndexPtr()[i];
+      for(i = 0; i < mat.nonZeros(); ++i)
+        --mat.innerIndexPtr()[i];
+    }
+  }
+}
+
+// This is the base class to interface with PaStiX functions. 
+// Users should not used this class directly. 
+template <class Derived>
+class PastixBase : public SparseSolverBase<Derived>
+{
+  protected:
+    typedef SparseSolverBase<Derived> Base;
+    using Base::derived;
+    using Base::m_isInitialized;
+  public:
+    using Base::_solve_impl;
+    
+    typedef typename internal::pastix_traits<Derived>::MatrixType _MatrixType;
+    typedef _MatrixType MatrixType;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef Matrix<Scalar,Dynamic,1> Vector;
+    typedef SparseMatrix<Scalar, ColMajor> ColSpMatrix;
+    enum {
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    
+  public:
+    
+    PastixBase() : m_initisOk(false), m_analysisIsOk(false), m_factorizationIsOk(false), m_pastixdata(0), m_size(0)
+    {
+      init();
+    }
+    
+    ~PastixBase() 
+    {
+      clean();
+    }
+    
+    template<typename Rhs,typename Dest>
+    bool _solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &x) const;
+    
+    /** Returns a reference to the integer vector IPARM of PaStiX parameters
+      * to modify the default parameters. 
+      * The statistics related to the different phases of factorization and solve are saved here as well
+      * \sa analyzePattern() factorize()
+      */
+    Array<StorageIndex,IPARM_SIZE,1>& iparm()
+    {
+      return m_iparm; 
+    }
+    
+    /** Return a reference to a particular index parameter of the IPARM vector 
+     * \sa iparm()
+     */
+    
+    int& iparm(int idxparam)
+    {
+      return m_iparm(idxparam);
+    }
+    
+     /** Returns a reference to the double vector DPARM of PaStiX parameters 
+      * The statistics related to the different phases of factorization and solve are saved here as well
+      * \sa analyzePattern() factorize()
+      */
+    Array<double,DPARM_SIZE,1>& dparm()
+    {
+      return m_dparm; 
+    }
+    
+    
+    /** Return a reference to a particular index parameter of the DPARM vector 
+     * \sa dparm()
+     */
+    double& dparm(int idxparam)
+    {
+      return m_dparm(idxparam);
+    }
+    
+    inline Index cols() const { return m_size; }
+    inline Index rows() const { return m_size; }
+    
+     /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was succesful,
+      *          \c NumericalIssue if the PaStiX reports a problem
+      *          \c InvalidInput if the input matrix is invalid
+      *
+      * \sa iparm()          
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_info;
+    }
+    
+  protected:
+
+    // Initialize the Pastix data structure, check the matrix
+    void init(); 
+    
+    // Compute the ordering and the symbolic factorization
+    void analyzePattern(ColSpMatrix& mat);
+    
+    // Compute the numerical factorization
+    void factorize(ColSpMatrix& mat);
+    
+    // Free all the data allocated by Pastix
+    void clean()
+    {
+      eigen_assert(m_initisOk && "The Pastix structure should be allocated first"); 
+      m_iparm(IPARM_START_TASK) = API_TASK_CLEAN;
+      m_iparm(IPARM_END_TASK) = API_TASK_CLEAN;
+      internal::eigen_pastix(&m_pastixdata, MPI_COMM_WORLD, 0, 0, 0, (Scalar*)0,
+                             m_perm.data(), m_invp.data(), 0, 0, m_iparm.data(), m_dparm.data());
+    }
+    
+    void compute(ColSpMatrix& mat);
+    
+    int m_initisOk; 
+    int m_analysisIsOk;
+    int m_factorizationIsOk;
+    mutable ComputationInfo m_info; 
+    mutable pastix_data_t *m_pastixdata; // Data structure for pastix
+    mutable int m_comm; // The MPI communicator identifier
+    mutable Array<int,IPARM_SIZE,1> m_iparm; // integer vector for the input parameters
+    mutable Array<double,DPARM_SIZE,1> m_dparm; // Scalar vector for the input parameters
+    mutable Matrix<StorageIndex,Dynamic,1> m_perm;  // Permutation vector
+    mutable Matrix<StorageIndex,Dynamic,1> m_invp;  // Inverse permutation vector
+    mutable int m_size; // Size of the matrix 
+}; 
+
+ /** Initialize the PaStiX data structure. 
+   *A first call to this function fills iparm and dparm with the default PaStiX parameters
+   * \sa iparm() dparm()
+   */
+template <class Derived>
+void PastixBase<Derived>::init()
+{
+  m_size = 0; 
+  m_iparm.setZero(IPARM_SIZE);
+  m_dparm.setZero(DPARM_SIZE);
+  
+  m_iparm(IPARM_MODIFY_PARAMETER) = API_NO;
+  pastix(&m_pastixdata, MPI_COMM_WORLD,
+         0, 0, 0, 0,
+         0, 0, 0, 1, m_iparm.data(), m_dparm.data());
+  
+  m_iparm[IPARM_MATRIX_VERIFICATION] = API_NO;
+  m_iparm[IPARM_VERBOSE]             = API_VERBOSE_NOT;
+  m_iparm[IPARM_ORDERING]            = API_ORDER_SCOTCH;
+  m_iparm[IPARM_INCOMPLETE]          = API_NO;
+  m_iparm[IPARM_OOC_LIMIT]           = 2000;
+  m_iparm[IPARM_RHS_MAKING]          = API_RHS_B;
+  m_iparm(IPARM_MATRIX_VERIFICATION) = API_NO;
+  
+  m_iparm(IPARM_START_TASK) = API_TASK_INIT;
+  m_iparm(IPARM_END_TASK) = API_TASK_INIT;
+  internal::eigen_pastix(&m_pastixdata, MPI_COMM_WORLD, 0, 0, 0, (Scalar*)0,
+                         0, 0, 0, 0, m_iparm.data(), m_dparm.data());
+  
+  // Check the returned error
+  if(m_iparm(IPARM_ERROR_NUMBER)) {
+    m_info = InvalidInput;
+    m_initisOk = false;
+  }
+  else { 
+    m_info = Success;
+    m_initisOk = true;
+  }
+}
+
+template <class Derived>
+void PastixBase<Derived>::compute(ColSpMatrix& mat)
+{
+  eigen_assert(mat.rows() == mat.cols() && "The input matrix should be squared");
+  
+  analyzePattern(mat);  
+  factorize(mat);
+  
+  m_iparm(IPARM_MATRIX_VERIFICATION) = API_NO;
+}
+
+
+template <class Derived>
+void PastixBase<Derived>::analyzePattern(ColSpMatrix& mat)
+{                         
+  eigen_assert(m_initisOk && "The initialization of PaSTiX failed");
+  
+  // clean previous calls
+  if(m_size>0)
+    clean();
+  
+  m_size = internal::convert_index<int>(mat.rows());
+  m_perm.resize(m_size);
+  m_invp.resize(m_size);
+  
+  m_iparm(IPARM_START_TASK) = API_TASK_ORDERING;
+  m_iparm(IPARM_END_TASK) = API_TASK_ANALYSE;
+  internal::eigen_pastix(&m_pastixdata, MPI_COMM_WORLD, m_size, mat.outerIndexPtr(), mat.innerIndexPtr(),
+               mat.valuePtr(), m_perm.data(), m_invp.data(), 0, 0, m_iparm.data(), m_dparm.data());
+  
+  // Check the returned error
+  if(m_iparm(IPARM_ERROR_NUMBER))
+  {
+    m_info = NumericalIssue;
+    m_analysisIsOk = false;
+  }
+  else
+  { 
+    m_info = Success;
+    m_analysisIsOk = true;
+  }
+}
+
+template <class Derived>
+void PastixBase<Derived>::factorize(ColSpMatrix& mat)
+{
+//   if(&m_cpyMat != &mat) m_cpyMat = mat;
+  eigen_assert(m_analysisIsOk && "The analysis phase should be called before the factorization phase");
+  m_iparm(IPARM_START_TASK) = API_TASK_NUMFACT;
+  m_iparm(IPARM_END_TASK) = API_TASK_NUMFACT;
+  m_size = internal::convert_index<int>(mat.rows());
+  
+  internal::eigen_pastix(&m_pastixdata, MPI_COMM_WORLD, m_size, mat.outerIndexPtr(), mat.innerIndexPtr(),
+               mat.valuePtr(), m_perm.data(), m_invp.data(), 0, 0, m_iparm.data(), m_dparm.data());
+  
+  // Check the returned error
+  if(m_iparm(IPARM_ERROR_NUMBER))
+  {
+    m_info = NumericalIssue;
+    m_factorizationIsOk = false;
+    m_isInitialized = false;
+  }
+  else
+  {
+    m_info = Success;
+    m_factorizationIsOk = true;
+    m_isInitialized = true;
+  }
+}
+
+/* Solve the system */
+template<typename Base>
+template<typename Rhs,typename Dest>
+bool PastixBase<Base>::_solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &x) const
+{
+  eigen_assert(m_isInitialized && "The matrix should be factorized first");
+  EIGEN_STATIC_ASSERT((Dest::Flags&RowMajorBit)==0,
+                     THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
+  int rhs = 1;
+  
+  x = b; /* on return, x is overwritten by the computed solution */
+  
+  for (int i = 0; i < b.cols(); i++){
+    m_iparm[IPARM_START_TASK]          = API_TASK_SOLVE;
+    m_iparm[IPARM_END_TASK]            = API_TASK_REFINE;
+  
+    internal::eigen_pastix(&m_pastixdata, MPI_COMM_WORLD, internal::convert_index<int>(x.rows()), 0, 0, 0,
+                           m_perm.data(), m_invp.data(), &x(0, i), rhs, m_iparm.data(), m_dparm.data());
+  }
+  
+  // Check the returned error
+  m_info = m_iparm(IPARM_ERROR_NUMBER)==0 ? Success : NumericalIssue;
+  
+  return m_iparm(IPARM_ERROR_NUMBER)==0;
+}
+
+/** \ingroup PaStiXSupport_Module
+  * \class PastixLU
+  * \brief Sparse direct LU solver based on PaStiX library
+  * 
+  * This class is used to solve the linear systems A.X = B with a supernodal LU 
+  * factorization in the PaStiX library. The matrix A should be squared and nonsingular
+  * PaStiX requires that the matrix A has a symmetric structural pattern. 
+  * This interface can symmetrize the input matrix otherwise. 
+  * The vectors or matrices X and B can be either dense or sparse.
+  * 
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam IsStrSym Indicates if the input matrix has a symmetric pattern, default is false
+  * NOTE : Note that if the analysis and factorization phase are called separately, 
+  * the input matrix will be symmetrized at each call, hence it is advised to 
+  * symmetrize the matrix in a end-user program and set \p IsStrSym to true
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa \ref TutorialSparseSolverConcept, class SparseLU
+  * 
+  */
+template<typename _MatrixType, bool IsStrSym>
+class PastixLU : public PastixBase< PastixLU<_MatrixType> >
+{
+  public:
+    typedef _MatrixType MatrixType;
+    typedef PastixBase<PastixLU<MatrixType> > Base;
+    typedef typename Base::ColSpMatrix ColSpMatrix;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    
+  public:
+    PastixLU() : Base()
+    {
+      init();
+    }
+    
+    explicit PastixLU(const MatrixType& matrix):Base()
+    {
+      init();
+      compute(matrix);
+    }
+    /** Compute the LU supernodal factorization of \p matrix. 
+      * iparm and dparm can be used to tune the PaStiX parameters. 
+      * see the PaStiX user's manual
+      * \sa analyzePattern() factorize()
+      */
+    void compute (const MatrixType& matrix)
+    {
+      m_structureIsUptodate = false;
+      ColSpMatrix temp;
+      grabMatrix(matrix, temp);
+      Base::compute(temp);
+    }
+    /** Compute the LU symbolic factorization of \p matrix using its sparsity pattern. 
+      * Several ordering methods can be used at this step. See the PaStiX user's manual. 
+      * The result of this operation can be used with successive matrices having the same pattern as \p matrix
+      * \sa factorize()
+      */
+    void analyzePattern(const MatrixType& matrix)
+    {
+      m_structureIsUptodate = false;
+      ColSpMatrix temp;
+      grabMatrix(matrix, temp);
+      Base::analyzePattern(temp);
+    }
+
+    /** Compute the LU supernodal factorization of \p matrix
+      * WARNING The matrix \p matrix should have the same structural pattern 
+      * as the same used in the analysis phase.
+      * \sa analyzePattern()
+      */ 
+    void factorize(const MatrixType& matrix)
+    {
+      ColSpMatrix temp;
+      grabMatrix(matrix, temp);
+      Base::factorize(temp);
+    }
+  protected:
+    
+    void init()
+    {
+      m_structureIsUptodate = false;
+      m_iparm(IPARM_SYM) = API_SYM_NO;
+      m_iparm(IPARM_FACTORIZATION) = API_FACT_LU;
+    }
+    
+    void grabMatrix(const MatrixType& matrix, ColSpMatrix& out)
+    {
+      if(IsStrSym)
+        out = matrix;
+      else
+      {
+        if(!m_structureIsUptodate)
+        {
+          // update the transposed structure
+          m_transposedStructure = matrix.transpose();
+          
+          // Set the elements of the matrix to zero 
+          for (Index j=0; j<m_transposedStructure.outerSize(); ++j) 
+            for(typename ColSpMatrix::InnerIterator it(m_transposedStructure, j); it; ++it)
+              it.valueRef() = 0.0;
+
+          m_structureIsUptodate = true;
+        }
+        
+        out = m_transposedStructure + matrix;
+      }
+      internal::c_to_fortran_numbering(out);
+    }
+    
+    using Base::m_iparm;
+    using Base::m_dparm;
+    
+    ColSpMatrix m_transposedStructure;
+    bool m_structureIsUptodate;
+};
+
+/** \ingroup PaStiXSupport_Module
+  * \class PastixLLT
+  * \brief A sparse direct supernodal Cholesky (LLT) factorization and solver based on the PaStiX library
+  * 
+  * This class is used to solve the linear systems A.X = B via a LL^T supernodal Cholesky factorization
+  * available in the PaStiX library. The matrix A should be symmetric and positive definite
+  * WARNING Selfadjoint complex matrices are not supported in the current version of PaStiX
+  * The vectors or matrices X and B can be either dense or sparse
+  * 
+  * \tparam MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam UpLo The part of the matrix to use : Lower or Upper. The default is Lower as required by PaStiX
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa \ref TutorialSparseSolverConcept, class SimplicialLLT
+  */
+template<typename _MatrixType, int _UpLo>
+class PastixLLT : public PastixBase< PastixLLT<_MatrixType, _UpLo> >
+{
+  public:
+    typedef _MatrixType MatrixType;
+    typedef PastixBase<PastixLLT<MatrixType, _UpLo> > Base;
+    typedef typename Base::ColSpMatrix ColSpMatrix;
+    
+  public:
+    enum { UpLo = _UpLo };
+    PastixLLT() : Base()
+    {
+      init();
+    }
+    
+    explicit PastixLLT(const MatrixType& matrix):Base()
+    {
+      init();
+      compute(matrix);
+    }
+
+    /** Compute the L factor of the LL^T supernodal factorization of \p matrix 
+      * \sa analyzePattern() factorize()
+      */
+    void compute (const MatrixType& matrix)
+    {
+      ColSpMatrix temp;
+      grabMatrix(matrix, temp);
+      Base::compute(temp);
+    }
+
+     /** Compute the LL^T symbolic factorization of \p matrix using its sparsity pattern
+      * The result of this operation can be used with successive matrices having the same pattern as \p matrix
+      * \sa factorize()
+      */
+    void analyzePattern(const MatrixType& matrix)
+    {
+      ColSpMatrix temp;
+      grabMatrix(matrix, temp);
+      Base::analyzePattern(temp);
+    }
+      /** Compute the LL^T supernodal numerical factorization of \p matrix 
+        * \sa analyzePattern()
+        */
+    void factorize(const MatrixType& matrix)
+    {
+      ColSpMatrix temp;
+      grabMatrix(matrix, temp);
+      Base::factorize(temp);
+    }
+  protected:
+    using Base::m_iparm;
+    
+    void init()
+    {
+      m_iparm(IPARM_SYM) = API_SYM_YES;
+      m_iparm(IPARM_FACTORIZATION) = API_FACT_LLT;
+    }
+    
+    void grabMatrix(const MatrixType& matrix, ColSpMatrix& out)
+    {
+      out.resize(matrix.rows(), matrix.cols());
+      // Pastix supports only lower, column-major matrices 
+      out.template selfadjointView<Lower>() = matrix.template selfadjointView<UpLo>();
+      internal::c_to_fortran_numbering(out);
+    }
+};
+
+/** \ingroup PaStiXSupport_Module
+  * \class PastixLDLT
+  * \brief A sparse direct supernodal Cholesky (LLT) factorization and solver based on the PaStiX library
+  * 
+  * This class is used to solve the linear systems A.X = B via a LDL^T supernodal Cholesky factorization
+  * available in the PaStiX library. The matrix A should be symmetric and positive definite
+  * WARNING Selfadjoint complex matrices are not supported in the current version of PaStiX
+  * The vectors or matrices X and B can be either dense or sparse
+  * 
+  * \tparam MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam UpLo The part of the matrix to use : Lower or Upper. The default is Lower as required by PaStiX
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa \ref TutorialSparseSolverConcept, class SimplicialLDLT
+  */
+template<typename _MatrixType, int _UpLo>
+class PastixLDLT : public PastixBase< PastixLDLT<_MatrixType, _UpLo> >
+{
+  public:
+    typedef _MatrixType MatrixType;
+    typedef PastixBase<PastixLDLT<MatrixType, _UpLo> > Base; 
+    typedef typename Base::ColSpMatrix ColSpMatrix;
+    
+  public:
+    enum { UpLo = _UpLo };
+    PastixLDLT():Base()
+    {
+      init();
+    }
+    
+    explicit PastixLDLT(const MatrixType& matrix):Base()
+    {
+      init();
+      compute(matrix);
+    }
+
+    /** Compute the L and D factors of the LDL^T factorization of \p matrix 
+      * \sa analyzePattern() factorize()
+      */
+    void compute (const MatrixType& matrix)
+    {
+      ColSpMatrix temp;
+      grabMatrix(matrix, temp);
+      Base::compute(temp);
+    }
+
+    /** Compute the LDL^T symbolic factorization of \p matrix using its sparsity pattern
+      * The result of this operation can be used with successive matrices having the same pattern as \p matrix
+      * \sa factorize()
+      */
+    void analyzePattern(const MatrixType& matrix)
+    { 
+      ColSpMatrix temp;
+      grabMatrix(matrix, temp);
+      Base::analyzePattern(temp);
+    }
+    /** Compute the LDL^T supernodal numerical factorization of \p matrix 
+      * 
+      */
+    void factorize(const MatrixType& matrix)
+    {
+      ColSpMatrix temp;
+      grabMatrix(matrix, temp);
+      Base::factorize(temp);
+    }
+
+  protected:
+    using Base::m_iparm;
+    
+    void init()
+    {
+      m_iparm(IPARM_SYM) = API_SYM_YES;
+      m_iparm(IPARM_FACTORIZATION) = API_FACT_LDLT;
+    }
+    
+    void grabMatrix(const MatrixType& matrix, ColSpMatrix& out)
+    {
+      // Pastix supports only lower, column-major matrices 
+      out.resize(matrix.rows(), matrix.cols());
+      out.template selfadjointView<Lower>() = matrix.template selfadjointView<UpLo>();
+      internal::c_to_fortran_numbering(out);
+    }
+};
+
+} // end namespace Eigen
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/PardisoSupport/PardisoSupport.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/PardisoSupport/PardisoSupport.h
new file mode 100644
index 00000000..091c3970
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/PardisoSupport/PardisoSupport.h
@@ -0,0 +1,543 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to Intel(R) MKL PARDISO
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_PARDISOSUPPORT_H
+#define EIGEN_PARDISOSUPPORT_H
+
+namespace Eigen { 
+
+template<typename _MatrixType> class PardisoLU;
+template<typename _MatrixType, int Options=Upper> class PardisoLLT;
+template<typename _MatrixType, int Options=Upper> class PardisoLDLT;
+
+namespace internal
+{
+  template<typename IndexType>
+  struct pardiso_run_selector
+  {
+    static IndexType run( _MKL_DSS_HANDLE_t pt, IndexType maxfct, IndexType mnum, IndexType type, IndexType phase, IndexType n, void *a,
+                      IndexType *ia, IndexType *ja, IndexType *perm, IndexType nrhs, IndexType *iparm, IndexType msglvl, void *b, void *x)
+    {
+      IndexType error = 0;
+      ::pardiso(pt, &maxfct, &mnum, &type, &phase, &n, a, ia, ja, perm, &nrhs, iparm, &msglvl, b, x, &error);
+      return error;
+    }
+  };
+  template<>
+  struct pardiso_run_selector<long long int>
+  {
+    typedef long long int IndexType;
+    static IndexType run( _MKL_DSS_HANDLE_t pt, IndexType maxfct, IndexType mnum, IndexType type, IndexType phase, IndexType n, void *a,
+                      IndexType *ia, IndexType *ja, IndexType *perm, IndexType nrhs, IndexType *iparm, IndexType msglvl, void *b, void *x)
+    {
+      IndexType error = 0;
+      ::pardiso_64(pt, &maxfct, &mnum, &type, &phase, &n, a, ia, ja, perm, &nrhs, iparm, &msglvl, b, x, &error);
+      return error;
+    }
+  };
+
+  template<class Pardiso> struct pardiso_traits;
+
+  template<typename _MatrixType>
+  struct pardiso_traits< PardisoLU<_MatrixType> >
+  {
+    typedef _MatrixType MatrixType;
+    typedef typename _MatrixType::Scalar Scalar;
+    typedef typename _MatrixType::RealScalar RealScalar;
+    typedef typename _MatrixType::StorageIndex StorageIndex;
+  };
+
+  template<typename _MatrixType, int Options>
+  struct pardiso_traits< PardisoLLT<_MatrixType, Options> >
+  {
+    typedef _MatrixType MatrixType;
+    typedef typename _MatrixType::Scalar Scalar;
+    typedef typename _MatrixType::RealScalar RealScalar;
+    typedef typename _MatrixType::StorageIndex StorageIndex;
+  };
+
+  template<typename _MatrixType, int Options>
+  struct pardiso_traits< PardisoLDLT<_MatrixType, Options> >
+  {
+    typedef _MatrixType MatrixType;
+    typedef typename _MatrixType::Scalar Scalar;
+    typedef typename _MatrixType::RealScalar RealScalar;
+    typedef typename _MatrixType::StorageIndex StorageIndex;    
+  };
+
+} // end namespace internal
+
+template<class Derived>
+class PardisoImpl : public SparseSolverBase<Derived>
+{
+  protected:
+    typedef SparseSolverBase<Derived> Base;
+    using Base::derived;
+    using Base::m_isInitialized;
+    
+    typedef internal::pardiso_traits<Derived> Traits;
+  public:
+    using Base::_solve_impl;
+    
+    typedef typename Traits::MatrixType MatrixType;
+    typedef typename Traits::Scalar Scalar;
+    typedef typename Traits::RealScalar RealScalar;
+    typedef typename Traits::StorageIndex StorageIndex;
+    typedef SparseMatrix<Scalar,RowMajor,StorageIndex> SparseMatrixType;
+    typedef Matrix<Scalar,Dynamic,1> VectorType;
+    typedef Matrix<StorageIndex, 1, MatrixType::ColsAtCompileTime> IntRowVectorType;
+    typedef Matrix<StorageIndex, MatrixType::RowsAtCompileTime, 1> IntColVectorType;
+    typedef Array<StorageIndex,64,1,DontAlign> ParameterType;
+    enum {
+      ScalarIsComplex = NumTraits<Scalar>::IsComplex,
+      ColsAtCompileTime = Dynamic,
+      MaxColsAtCompileTime = Dynamic
+    };
+
+    PardisoImpl()
+    {
+      eigen_assert((sizeof(StorageIndex) >= sizeof(_INTEGER_t) && sizeof(StorageIndex) <= 8) && "Non-supported index type");
+      m_iparm.setZero();
+      m_msglvl = 0; // No output
+      m_isInitialized = false;
+    }
+
+    ~PardisoImpl()
+    {
+      pardisoRelease();
+    }
+
+    inline Index cols() const { return m_size; }
+    inline Index rows() const { return m_size; }
+  
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was succesful,
+      *          \c NumericalIssue if the matrix appears to be negative.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_info;
+    }
+
+    /** \warning for advanced usage only.
+      * \returns a reference to the parameter array controlling PARDISO.
+      * See the PARDISO manual to know how to use it. */
+    ParameterType& pardisoParameterArray()
+    {
+      return m_iparm;
+    }
+    
+    /** Performs a symbolic decomposition on the sparcity of \a matrix.
+      *
+      * This function is particularly useful when solving for several problems having the same structure.
+      * 
+      * \sa factorize()
+      */
+    Derived& analyzePattern(const MatrixType& matrix);
+    
+    /** Performs a numeric decomposition of \a matrix
+      *
+      * The given matrix must has the same sparcity than the matrix on which the symbolic decomposition has been performed.
+      *
+      * \sa analyzePattern()
+      */
+    Derived& factorize(const MatrixType& matrix);
+
+    Derived& compute(const MatrixType& matrix);
+
+    template<typename Rhs,typename Dest>
+    void _solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &dest) const;
+
+  protected:
+    void pardisoRelease()
+    {
+      if(m_isInitialized) // Factorization ran at least once
+      {
+        internal::pardiso_run_selector<StorageIndex>::run(m_pt, 1, 1, m_type, -1, internal::convert_index<StorageIndex>(m_size),0, 0, 0, m_perm.data(), 0,
+                                                          m_iparm.data(), m_msglvl, NULL, NULL);
+        m_isInitialized = false;
+      }
+    }
+
+    void pardisoInit(int type)
+    {
+      m_type = type;
+      bool symmetric = std::abs(m_type) < 10;
+      m_iparm[0] = 1;   // No solver default
+      m_iparm[1] = 2;   // use Metis for the ordering
+      m_iparm[2] = 0;   // Reserved. Set to zero. (??Numbers of processors, value of OMP_NUM_THREADS??)
+      m_iparm[3] = 0;   // No iterative-direct algorithm
+      m_iparm[4] = 0;   // No user fill-in reducing permutation
+      m_iparm[5] = 0;   // Write solution into x, b is left unchanged
+      m_iparm[6] = 0;   // Not in use
+      m_iparm[7] = 2;   // Max numbers of iterative refinement steps
+      m_iparm[8] = 0;   // Not in use
+      m_iparm[9] = 13;  // Perturb the pivot elements with 1E-13
+      m_iparm[10] = symmetric ? 0 : 1; // Use nonsymmetric permutation and scaling MPS
+      m_iparm[11] = 0;  // Not in use
+      m_iparm[12] = symmetric ? 0 : 1;  // Maximum weighted matching algorithm is switched-off (default for symmetric).
+                                        // Try m_iparm[12] = 1 in case of inappropriate accuracy
+      m_iparm[13] = 0;  // Output: Number of perturbed pivots
+      m_iparm[14] = 0;  // Not in use
+      m_iparm[15] = 0;  // Not in use
+      m_iparm[16] = 0;  // Not in use
+      m_iparm[17] = -1; // Output: Number of nonzeros in the factor LU
+      m_iparm[18] = -1; // Output: Mflops for LU factorization
+      m_iparm[19] = 0;  // Output: Numbers of CG Iterations
+      
+      m_iparm[20] = 0;  // 1x1 pivoting
+      m_iparm[26] = 0;  // No matrix checker
+      m_iparm[27] = (sizeof(RealScalar) == 4) ? 1 : 0;
+      m_iparm[34] = 1;  // C indexing
+      m_iparm[36] = 0;  // CSR
+      m_iparm[59] = 0;  // 0 - In-Core ; 1 - Automatic switch between In-Core and Out-of-Core modes ; 2 - Out-of-Core
+      
+      memset(m_pt, 0, sizeof(m_pt));
+    }
+
+  protected:
+    // cached data to reduce reallocation, etc.
+    
+    void manageErrorCode(Index error) const
+    {
+      switch(error)
+      {
+        case 0:
+          m_info = Success;
+          break;
+        case -4:
+        case -7:
+          m_info = NumericalIssue;
+          break;
+        default:
+          m_info = InvalidInput;
+      }
+    }
+
+    mutable SparseMatrixType m_matrix;
+    mutable ComputationInfo m_info;
+    bool m_analysisIsOk, m_factorizationIsOk;
+    StorageIndex m_type, m_msglvl;
+    mutable void *m_pt[64];
+    mutable ParameterType m_iparm;
+    mutable IntColVectorType m_perm;
+    Index m_size;
+    
+};
+
+template<class Derived>
+Derived& PardisoImpl<Derived>::compute(const MatrixType& a)
+{
+  m_size = a.rows();
+  eigen_assert(a.rows() == a.cols());
+
+  pardisoRelease();
+  m_perm.setZero(m_size);
+  derived().getMatrix(a);
+  
+  Index error;
+  error = internal::pardiso_run_selector<StorageIndex>::run(m_pt, 1, 1, m_type, 12, internal::convert_index<StorageIndex>(m_size),
+                                                            m_matrix.valuePtr(), m_matrix.outerIndexPtr(), m_matrix.innerIndexPtr(),
+                                                            m_perm.data(), 0, m_iparm.data(), m_msglvl, NULL, NULL);
+  manageErrorCode(error);
+  m_analysisIsOk = true;
+  m_factorizationIsOk = true;
+  m_isInitialized = true;
+  return derived();
+}
+
+template<class Derived>
+Derived& PardisoImpl<Derived>::analyzePattern(const MatrixType& a)
+{
+  m_size = a.rows();
+  eigen_assert(m_size == a.cols());
+
+  pardisoRelease();
+  m_perm.setZero(m_size);
+  derived().getMatrix(a);
+  
+  Index error;
+  error = internal::pardiso_run_selector<StorageIndex>::run(m_pt, 1, 1, m_type, 11, internal::convert_index<StorageIndex>(m_size),
+                                                            m_matrix.valuePtr(), m_matrix.outerIndexPtr(), m_matrix.innerIndexPtr(),
+                                                            m_perm.data(), 0, m_iparm.data(), m_msglvl, NULL, NULL);
+  
+  manageErrorCode(error);
+  m_analysisIsOk = true;
+  m_factorizationIsOk = false;
+  m_isInitialized = true;
+  return derived();
+}
+
+template<class Derived>
+Derived& PardisoImpl<Derived>::factorize(const MatrixType& a)
+{
+  eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
+  eigen_assert(m_size == a.rows() && m_size == a.cols());
+  
+  derived().getMatrix(a);
+
+  Index error;
+  error = internal::pardiso_run_selector<StorageIndex>::run(m_pt, 1, 1, m_type, 22, internal::convert_index<StorageIndex>(m_size),
+                                                            m_matrix.valuePtr(), m_matrix.outerIndexPtr(), m_matrix.innerIndexPtr(),
+                                                            m_perm.data(), 0, m_iparm.data(), m_msglvl, NULL, NULL);
+  
+  manageErrorCode(error);
+  m_factorizationIsOk = true;
+  return derived();
+}
+
+template<class Derived>
+template<typename BDerived,typename XDerived>
+void PardisoImpl<Derived>::_solve_impl(const MatrixBase<BDerived> &b, MatrixBase<XDerived>& x) const
+{
+  if(m_iparm[0] == 0) // Factorization was not computed
+  {
+    m_info = InvalidInput;
+    return;
+  }
+
+  //Index n = m_matrix.rows();
+  Index nrhs = Index(b.cols());
+  eigen_assert(m_size==b.rows());
+  eigen_assert(((MatrixBase<BDerived>::Flags & RowMajorBit) == 0 || nrhs == 1) && "Row-major right hand sides are not supported");
+  eigen_assert(((MatrixBase<XDerived>::Flags & RowMajorBit) == 0 || nrhs == 1) && "Row-major matrices of unknowns are not supported");
+  eigen_assert(((nrhs == 1) || b.outerStride() == b.rows()));
+
+
+//  switch (transposed) {
+//    case SvNoTrans    : m_iparm[11] = 0 ; break;
+//    case SvTranspose  : m_iparm[11] = 2 ; break;
+//    case SvAdjoint    : m_iparm[11] = 1 ; break;
+//    default:
+//      //std::cerr << "Eigen: transposition  option \"" << transposed << "\" not supported by the PARDISO backend\n";
+//      m_iparm[11] = 0;
+//  }
+
+  Scalar* rhs_ptr = const_cast<Scalar*>(b.derived().data());
+  Matrix<Scalar,Dynamic,Dynamic,ColMajor> tmp;
+  
+  // Pardiso cannot solve in-place
+  if(rhs_ptr == x.derived().data())
+  {
+    tmp = b;
+    rhs_ptr = tmp.data();
+  }
+  
+  Index error;
+  error = internal::pardiso_run_selector<StorageIndex>::run(m_pt, 1, 1, m_type, 33, internal::convert_index<StorageIndex>(m_size),
+                                                            m_matrix.valuePtr(), m_matrix.outerIndexPtr(), m_matrix.innerIndexPtr(),
+                                                            m_perm.data(), internal::convert_index<StorageIndex>(nrhs), m_iparm.data(), m_msglvl,
+                                                            rhs_ptr, x.derived().data());
+
+  manageErrorCode(error);
+}
+
+
+/** \ingroup PardisoSupport_Module
+  * \class PardisoLU
+  * \brief A sparse direct LU factorization and solver based on the PARDISO library
+  *
+  * This class allows to solve for A.X = B sparse linear problems via a direct LU factorization
+  * using the Intel MKL PARDISO library. The sparse matrix A must be squared and invertible.
+  * The vectors or matrices X and B can be either dense or sparse.
+  *
+  * By default, it runs in in-core mode. To enable PARDISO's out-of-core feature, set:
+  * \code solver.pardisoParameterArray()[59] = 1; \endcode
+  *
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa \ref TutorialSparseSolverConcept, class SparseLU
+  */
+template<typename MatrixType>
+class PardisoLU : public PardisoImpl< PardisoLU<MatrixType> >
+{
+  protected:
+    typedef PardisoImpl<PardisoLU> Base;
+    typedef typename Base::Scalar Scalar;
+    typedef typename Base::RealScalar RealScalar;
+    using Base::pardisoInit;
+    using Base::m_matrix;
+    friend class PardisoImpl< PardisoLU<MatrixType> >;
+
+  public:
+
+    using Base::compute;
+    using Base::solve;
+
+    PardisoLU()
+      : Base()
+    {
+      pardisoInit(Base::ScalarIsComplex ? 13 : 11);
+    }
+
+    explicit PardisoLU(const MatrixType& matrix)
+      : Base()
+    {
+      pardisoInit(Base::ScalarIsComplex ? 13 : 11);
+      compute(matrix);
+    }
+  protected:
+    void getMatrix(const MatrixType& matrix)
+    {
+      m_matrix = matrix;
+      m_matrix.makeCompressed();
+    }
+};
+
+/** \ingroup PardisoSupport_Module
+  * \class PardisoLLT
+  * \brief A sparse direct Cholesky (LLT) factorization and solver based on the PARDISO library
+  *
+  * This class allows to solve for A.X = B sparse linear problems via a LL^T Cholesky factorization
+  * using the Intel MKL PARDISO library. The sparse matrix A must be selfajoint and positive definite.
+  * The vectors or matrices X and B can be either dense or sparse.
+  *
+  * By default, it runs in in-core mode. To enable PARDISO's out-of-core feature, set:
+  * \code solver.pardisoParameterArray()[59] = 1; \endcode
+  *
+  * \tparam MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam UpLo can be any bitwise combination of Upper, Lower. The default is Upper, meaning only the upper triangular part has to be used.
+  *         Upper|Lower can be used to tell both triangular parts can be used as input.
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa \ref TutorialSparseSolverConcept, class SimplicialLLT
+  */
+template<typename MatrixType, int _UpLo>
+class PardisoLLT : public PardisoImpl< PardisoLLT<MatrixType,_UpLo> >
+{
+  protected:
+    typedef PardisoImpl< PardisoLLT<MatrixType,_UpLo> > Base;
+    typedef typename Base::Scalar Scalar;
+    typedef typename Base::RealScalar RealScalar;
+    using Base::pardisoInit;
+    using Base::m_matrix;
+    friend class PardisoImpl< PardisoLLT<MatrixType,_UpLo> >;
+
+  public:
+
+    typedef typename Base::StorageIndex StorageIndex;
+    enum { UpLo = _UpLo };
+    using Base::compute;
+
+    PardisoLLT()
+      : Base()
+    {
+      pardisoInit(Base::ScalarIsComplex ? 4 : 2);
+    }
+
+    explicit PardisoLLT(const MatrixType& matrix)
+      : Base()
+    {
+      pardisoInit(Base::ScalarIsComplex ? 4 : 2);
+      compute(matrix);
+    }
+    
+  protected:
+    
+    void getMatrix(const MatrixType& matrix)
+    {
+      // PARDISO supports only upper, row-major matrices
+      PermutationMatrix<Dynamic,Dynamic,StorageIndex> p_null;
+      m_matrix.resize(matrix.rows(), matrix.cols());
+      m_matrix.template selfadjointView<Upper>() = matrix.template selfadjointView<UpLo>().twistedBy(p_null);
+      m_matrix.makeCompressed();
+    }
+};
+
+/** \ingroup PardisoSupport_Module
+  * \class PardisoLDLT
+  * \brief A sparse direct Cholesky (LDLT) factorization and solver based on the PARDISO library
+  *
+  * This class allows to solve for A.X = B sparse linear problems via a LDL^T Cholesky factorization
+  * using the Intel MKL PARDISO library. The sparse matrix A is assumed to be selfajoint and positive definite.
+  * For complex matrices, A can also be symmetric only, see the \a Options template parameter.
+  * The vectors or matrices X and B can be either dense or sparse.
+  *
+  * By default, it runs in in-core mode. To enable PARDISO's out-of-core feature, set:
+  * \code solver.pardisoParameterArray()[59] = 1; \endcode
+  *
+  * \tparam MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam Options can be any bitwise combination of Upper, Lower, and Symmetric. The default is Upper, meaning only the upper triangular part has to be used.
+  *         Symmetric can be used for symmetric, non-selfadjoint complex matrices, the default being to assume a selfadjoint matrix.
+  *         Upper|Lower can be used to tell both triangular parts can be used as input.
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa \ref TutorialSparseSolverConcept, class SimplicialLDLT
+  */
+template<typename MatrixType, int Options>
+class PardisoLDLT : public PardisoImpl< PardisoLDLT<MatrixType,Options> >
+{
+  protected:
+    typedef PardisoImpl< PardisoLDLT<MatrixType,Options> > Base;
+    typedef typename Base::Scalar Scalar;
+    typedef typename Base::RealScalar RealScalar;
+    using Base::pardisoInit;
+    using Base::m_matrix;
+    friend class PardisoImpl< PardisoLDLT<MatrixType,Options> >;
+
+  public:
+
+    typedef typename Base::StorageIndex StorageIndex;
+    using Base::compute;
+    enum { UpLo = Options&(Upper|Lower) };
+
+    PardisoLDLT()
+      : Base()
+    {
+      pardisoInit(Base::ScalarIsComplex ? ( bool(Options&Symmetric) ? 6 : -4 ) : -2);
+    }
+
+    explicit PardisoLDLT(const MatrixType& matrix)
+      : Base()
+    {
+      pardisoInit(Base::ScalarIsComplex ? ( bool(Options&Symmetric) ? 6 : -4 ) : -2);
+      compute(matrix);
+    }
+    
+    void getMatrix(const MatrixType& matrix)
+    {
+      // PARDISO supports only upper, row-major matrices
+      PermutationMatrix<Dynamic,Dynamic,StorageIndex> p_null;
+      m_matrix.resize(matrix.rows(), matrix.cols());
+      m_matrix.template selfadjointView<Upper>() = matrix.template selfadjointView<UpLo>().twistedBy(p_null);
+      m_matrix.makeCompressed();
+    }
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_PARDISOSUPPORT_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/QR/ColPivHouseholderQR.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/QR/ColPivHouseholderQR.h
new file mode 100644
index 00000000..5270eaca
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/QR/ColPivHouseholderQR.h
@@ -0,0 +1,652 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COLPIVOTINGHOUSEHOLDERQR_H
+#define EIGEN_COLPIVOTINGHOUSEHOLDERQR_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename _MatrixType> struct traits<ColPivHouseholderQR<_MatrixType> >
+ : traits<_MatrixType>
+{
+  enum { Flags = 0 };
+};
+
+} // end namespace internal
+
+/** \ingroup QR_Module
+  *
+  * \class ColPivHouseholderQR
+  *
+  * \brief Householder rank-revealing QR decomposition of a matrix with column-pivoting
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the QR decomposition
+  *
+  * This class performs a rank-revealing QR decomposition of a matrix \b A into matrices \b P, \b Q and \b R
+  * such that
+  * \f[
+  *  \mathbf{A} \, \mathbf{P} = \mathbf{Q} \, \mathbf{R}
+  * \f]
+  * by using Householder transformations. Here, \b P is a permutation matrix, \b Q a unitary matrix and \b R an
+  * upper triangular matrix.
+  *
+  * This decomposition performs column pivoting in order to be rank-revealing and improve
+  * numerical stability. It is slower than HouseholderQR, and faster than FullPivHouseholderQR.
+  *
+  * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
+  * 
+  * \sa MatrixBase::colPivHouseholderQr()
+  */
+template<typename _MatrixType> class ColPivHouseholderQR
+{
+  public:
+
+    typedef _MatrixType MatrixType;
+    enum {
+      RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    // FIXME should be int
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef typename internal::plain_diag_type<MatrixType>::type HCoeffsType;
+    typedef PermutationMatrix<ColsAtCompileTime, MaxColsAtCompileTime> PermutationType;
+    typedef typename internal::plain_row_type<MatrixType, Index>::type IntRowVectorType;
+    typedef typename internal::plain_row_type<MatrixType>::type RowVectorType;
+    typedef typename internal::plain_row_type<MatrixType, RealScalar>::type RealRowVectorType;
+    typedef HouseholderSequence<MatrixType,typename internal::remove_all<typename HCoeffsType::ConjugateReturnType>::type> HouseholderSequenceType;
+    typedef typename MatrixType::PlainObject PlainObject;
+
+  private:
+
+    typedef typename PermutationType::StorageIndex PermIndexType;
+
+  public:
+
+    /**
+    * \brief Default Constructor.
+    *
+    * The default constructor is useful in cases in which the user intends to
+    * perform decompositions via ColPivHouseholderQR::compute(const MatrixType&).
+    */
+    ColPivHouseholderQR()
+      : m_qr(),
+        m_hCoeffs(),
+        m_colsPermutation(),
+        m_colsTranspositions(),
+        m_temp(),
+        m_colNormsUpdated(),
+        m_colNormsDirect(),
+        m_isInitialized(false),
+        m_usePrescribedThreshold(false) {}
+
+    /** \brief Default Constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem \a size.
+      * \sa ColPivHouseholderQR()
+      */
+    ColPivHouseholderQR(Index rows, Index cols)
+      : m_qr(rows, cols),
+        m_hCoeffs((std::min)(rows,cols)),
+        m_colsPermutation(PermIndexType(cols)),
+        m_colsTranspositions(cols),
+        m_temp(cols),
+        m_colNormsUpdated(cols),
+        m_colNormsDirect(cols),
+        m_isInitialized(false),
+        m_usePrescribedThreshold(false) {}
+
+    /** \brief Constructs a QR factorization from a given matrix
+      *
+      * This constructor computes the QR factorization of the matrix \a matrix by calling
+      * the method compute(). It is a short cut for:
+      *
+      * \code
+      * ColPivHouseholderQR<MatrixType> qr(matrix.rows(), matrix.cols());
+      * qr.compute(matrix);
+      * \endcode
+      *
+      * \sa compute()
+      */
+    template<typename InputType>
+    explicit ColPivHouseholderQR(const EigenBase<InputType>& matrix)
+      : m_qr(matrix.rows(), matrix.cols()),
+        m_hCoeffs((std::min)(matrix.rows(),matrix.cols())),
+        m_colsPermutation(PermIndexType(matrix.cols())),
+        m_colsTranspositions(matrix.cols()),
+        m_temp(matrix.cols()),
+        m_colNormsUpdated(matrix.cols()),
+        m_colNormsDirect(matrix.cols()),
+        m_isInitialized(false),
+        m_usePrescribedThreshold(false)
+    {
+      compute(matrix.derived());
+    }
+
+    /** \brief Constructs a QR factorization from a given matrix
+      *
+      * This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when \c MatrixType is a Eigen::Ref.
+      *
+      * \sa ColPivHouseholderQR(const EigenBase&)
+      */
+    template<typename InputType>
+    explicit ColPivHouseholderQR(EigenBase<InputType>& matrix)
+      : m_qr(matrix.derived()),
+        m_hCoeffs((std::min)(matrix.rows(),matrix.cols())),
+        m_colsPermutation(PermIndexType(matrix.cols())),
+        m_colsTranspositions(matrix.cols()),
+        m_temp(matrix.cols()),
+        m_colNormsUpdated(matrix.cols()),
+        m_colNormsDirect(matrix.cols()),
+        m_isInitialized(false),
+        m_usePrescribedThreshold(false)
+    {
+      computeInPlace();
+    }
+
+    /** This method finds a solution x to the equation Ax=b, where A is the matrix of which
+      * *this is the QR decomposition, if any exists.
+      *
+      * \param b the right-hand-side of the equation to solve.
+      *
+      * \returns a solution.
+      *
+      * \note_about_checking_solutions
+      *
+      * \note_about_arbitrary_choice_of_solution
+      *
+      * Example: \include ColPivHouseholderQR_solve.cpp
+      * Output: \verbinclude ColPivHouseholderQR_solve.out
+      */
+    template<typename Rhs>
+    inline const Solve<ColPivHouseholderQR, Rhs>
+    solve(const MatrixBase<Rhs>& b) const
+    {
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      return Solve<ColPivHouseholderQR, Rhs>(*this, b.derived());
+    }
+
+    HouseholderSequenceType householderQ() const;
+    HouseholderSequenceType matrixQ() const
+    {
+      return householderQ();
+    }
+
+    /** \returns a reference to the matrix where the Householder QR decomposition is stored
+      */
+    const MatrixType& matrixQR() const
+    {
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      return m_qr;
+    }
+
+    /** \returns a reference to the matrix where the result Householder QR is stored
+     * \warning The strict lower part of this matrix contains internal values.
+     * Only the upper triangular part should be referenced. To get it, use
+     * \code matrixR().template triangularView<Upper>() \endcode
+     * For rank-deficient matrices, use
+     * \code
+     * matrixR().topLeftCorner(rank(), rank()).template triangularView<Upper>()
+     * \endcode
+     */
+    const MatrixType& matrixR() const
+    {
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      return m_qr;
+    }
+
+    template<typename InputType>
+    ColPivHouseholderQR& compute(const EigenBase<InputType>& matrix);
+
+    /** \returns a const reference to the column permutation matrix */
+    const PermutationType& colsPermutation() const
+    {
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      return m_colsPermutation;
+    }
+
+    /** \returns the absolute value of the determinant of the matrix of which
+      * *this is the QR decomposition. It has only linear complexity
+      * (that is, O(n) where n is the dimension of the square matrix)
+      * as the QR decomposition has already been computed.
+      *
+      * \note This is only for square matrices.
+      *
+      * \warning a determinant can be very big or small, so for matrices
+      * of large enough dimension, there is a risk of overflow/underflow.
+      * One way to work around that is to use logAbsDeterminant() instead.
+      *
+      * \sa logAbsDeterminant(), MatrixBase::determinant()
+      */
+    typename MatrixType::RealScalar absDeterminant() const;
+
+    /** \returns the natural log of the absolute value of the determinant of the matrix of which
+      * *this is the QR decomposition. It has only linear complexity
+      * (that is, O(n) where n is the dimension of the square matrix)
+      * as the QR decomposition has already been computed.
+      *
+      * \note This is only for square matrices.
+      *
+      * \note This method is useful to work around the risk of overflow/underflow that's inherent
+      * to determinant computation.
+      *
+      * \sa absDeterminant(), MatrixBase::determinant()
+      */
+    typename MatrixType::RealScalar logAbsDeterminant() const;
+
+    /** \returns the rank of the matrix of which *this is the QR decomposition.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline Index rank() const
+    {
+      using std::abs;
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      RealScalar premultiplied_threshold = abs(m_maxpivot) * threshold();
+      Index result = 0;
+      for(Index i = 0; i < m_nonzero_pivots; ++i)
+        result += (abs(m_qr.coeff(i,i)) > premultiplied_threshold);
+      return result;
+    }
+
+    /** \returns the dimension of the kernel of the matrix of which *this is the QR decomposition.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline Index dimensionOfKernel() const
+    {
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      return cols() - rank();
+    }
+
+    /** \returns true if the matrix of which *this is the QR decomposition represents an injective
+      *          linear map, i.e. has trivial kernel; false otherwise.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline bool isInjective() const
+    {
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      return rank() == cols();
+    }
+
+    /** \returns true if the matrix of which *this is the QR decomposition represents a surjective
+      *          linear map; false otherwise.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline bool isSurjective() const
+    {
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      return rank() == rows();
+    }
+
+    /** \returns true if the matrix of which *this is the QR decomposition is invertible.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline bool isInvertible() const
+    {
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      return isInjective() && isSurjective();
+    }
+
+    /** \returns the inverse of the matrix of which *this is the QR decomposition.
+      *
+      * \note If this matrix is not invertible, the returned matrix has undefined coefficients.
+      *       Use isInvertible() to first determine whether this matrix is invertible.
+      */
+    inline const Inverse<ColPivHouseholderQR> inverse() const
+    {
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      return Inverse<ColPivHouseholderQR>(*this);
+    }
+
+    inline Index rows() const { return m_qr.rows(); }
+    inline Index cols() const { return m_qr.cols(); }
+
+    /** \returns a const reference to the vector of Householder coefficients used to represent the factor \c Q.
+      *
+      * For advanced uses only.
+      */
+    const HCoeffsType& hCoeffs() const { return m_hCoeffs; }
+
+    /** Allows to prescribe a threshold to be used by certain methods, such as rank(),
+      * who need to determine when pivots are to be considered nonzero. This is not used for the
+      * QR decomposition itself.
+      *
+      * When it needs to get the threshold value, Eigen calls threshold(). By default, this
+      * uses a formula to automatically determine a reasonable threshold.
+      * Once you have called the present method setThreshold(const RealScalar&),
+      * your value is used instead.
+      *
+      * \param threshold The new value to use as the threshold.
+      *
+      * A pivot will be considered nonzero if its absolute value is strictly greater than
+      *  \f$ \vert pivot \vert \leqslant threshold \times \vert maxpivot \vert \f$
+      * where maxpivot is the biggest pivot.
+      *
+      * If you want to come back to the default behavior, call setThreshold(Default_t)
+      */
+    ColPivHouseholderQR& setThreshold(const RealScalar& threshold)
+    {
+      m_usePrescribedThreshold = true;
+      m_prescribedThreshold = threshold;
+      return *this;
+    }
+
+    /** Allows to come back to the default behavior, letting Eigen use its default formula for
+      * determining the threshold.
+      *
+      * You should pass the special object Eigen::Default as parameter here.
+      * \code qr.setThreshold(Eigen::Default); \endcode
+      *
+      * See the documentation of setThreshold(const RealScalar&).
+      */
+    ColPivHouseholderQR& setThreshold(Default_t)
+    {
+      m_usePrescribedThreshold = false;
+      return *this;
+    }
+
+    /** Returns the threshold that will be used by certain methods such as rank().
+      *
+      * See the documentation of setThreshold(const RealScalar&).
+      */
+    RealScalar threshold() const
+    {
+      eigen_assert(m_isInitialized || m_usePrescribedThreshold);
+      return m_usePrescribedThreshold ? m_prescribedThreshold
+      // this formula comes from experimenting (see "LU precision tuning" thread on the list)
+      // and turns out to be identical to Higham's formula used already in LDLt.
+                                      : NumTraits<Scalar>::epsilon() * RealScalar(m_qr.diagonalSize());
+    }
+
+    /** \returns the number of nonzero pivots in the QR decomposition.
+      * Here nonzero is meant in the exact sense, not in a fuzzy sense.
+      * So that notion isn't really intrinsically interesting, but it is
+      * still useful when implementing algorithms.
+      *
+      * \sa rank()
+      */
+    inline Index nonzeroPivots() const
+    {
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      return m_nonzero_pivots;
+    }
+
+    /** \returns the absolute value of the biggest pivot, i.e. the biggest
+      *          diagonal coefficient of R.
+      */
+    RealScalar maxPivot() const { return m_maxpivot; }
+
+    /** \brief Reports whether the QR factorization was succesful.
+      *
+      * \note This function always returns \c Success. It is provided for compatibility
+      * with other factorization routines.
+      * \returns \c Success
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return Success;
+    }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename RhsType, typename DstType>
+    void _solve_impl(const RhsType &rhs, DstType &dst) const;
+    #endif
+
+  protected:
+
+    friend class CompleteOrthogonalDecomposition<MatrixType>;
+
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+    }
+
+    void computeInPlace();
+
+    MatrixType m_qr;
+    HCoeffsType m_hCoeffs;
+    PermutationType m_colsPermutation;
+    IntRowVectorType m_colsTranspositions;
+    RowVectorType m_temp;
+    RealRowVectorType m_colNormsUpdated;
+    RealRowVectorType m_colNormsDirect;
+    bool m_isInitialized, m_usePrescribedThreshold;
+    RealScalar m_prescribedThreshold, m_maxpivot;
+    Index m_nonzero_pivots;
+    Index m_det_pq;
+};
+
+template<typename MatrixType>
+typename MatrixType::RealScalar ColPivHouseholderQR<MatrixType>::absDeterminant() const
+{
+  using std::abs;
+  eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+  eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
+  return abs(m_qr.diagonal().prod());
+}
+
+template<typename MatrixType>
+typename MatrixType::RealScalar ColPivHouseholderQR<MatrixType>::logAbsDeterminant() const
+{
+  eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+  eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
+  return m_qr.diagonal().cwiseAbs().array().log().sum();
+}
+
+/** Performs the QR factorization of the given matrix \a matrix. The result of
+  * the factorization is stored into \c *this, and a reference to \c *this
+  * is returned.
+  *
+  * \sa class ColPivHouseholderQR, ColPivHouseholderQR(const MatrixType&)
+  */
+template<typename MatrixType>
+template<typename InputType>
+ColPivHouseholderQR<MatrixType>& ColPivHouseholderQR<MatrixType>::compute(const EigenBase<InputType>& matrix)
+{
+  m_qr = matrix.derived();
+  computeInPlace();
+  return *this;
+}
+
+template<typename MatrixType>
+void ColPivHouseholderQR<MatrixType>::computeInPlace()
+{
+  check_template_parameters();
+
+  // the column permutation is stored as int indices, so just to be sure:
+  eigen_assert(m_qr.cols()<=NumTraits<int>::highest());
+
+  using std::abs;
+
+  Index rows = m_qr.rows();
+  Index cols = m_qr.cols();
+  Index size = m_qr.diagonalSize();
+
+  m_hCoeffs.resize(size);
+
+  m_temp.resize(cols);
+
+  m_colsTranspositions.resize(m_qr.cols());
+  Index number_of_transpositions = 0;
+
+  m_colNormsUpdated.resize(cols);
+  m_colNormsDirect.resize(cols);
+  for (Index k = 0; k < cols; ++k) {
+    // colNormsDirect(k) caches the most recent directly computed norm of
+    // column k.
+    m_colNormsDirect.coeffRef(k) = m_qr.col(k).norm();
+    m_colNormsUpdated.coeffRef(k) = m_colNormsDirect.coeffRef(k);
+  }
+
+  RealScalar threshold_helper =  numext::abs2<RealScalar>(m_colNormsUpdated.maxCoeff() * NumTraits<RealScalar>::epsilon()) / RealScalar(rows);
+  RealScalar norm_downdate_threshold = numext::sqrt(NumTraits<RealScalar>::epsilon());
+
+  m_nonzero_pivots = size; // the generic case is that in which all pivots are nonzero (invertible case)
+  m_maxpivot = RealScalar(0);
+
+  for(Index k = 0; k < size; ++k)
+  {
+    // first, we look up in our table m_colNormsUpdated which column has the biggest norm
+    Index biggest_col_index;
+    RealScalar biggest_col_sq_norm = numext::abs2(m_colNormsUpdated.tail(cols-k).maxCoeff(&biggest_col_index));
+    biggest_col_index += k;
+
+    // Track the number of meaningful pivots but do not stop the decomposition to make
+    // sure that the initial matrix is properly reproduced. See bug 941.
+    if(m_nonzero_pivots==size && biggest_col_sq_norm < threshold_helper * RealScalar(rows-k))
+      m_nonzero_pivots = k;
+
+    // apply the transposition to the columns
+    m_colsTranspositions.coeffRef(k) = biggest_col_index;
+    if(k != biggest_col_index) {
+      m_qr.col(k).swap(m_qr.col(biggest_col_index));
+      std::swap(m_colNormsUpdated.coeffRef(k), m_colNormsUpdated.coeffRef(biggest_col_index));
+      std::swap(m_colNormsDirect.coeffRef(k), m_colNormsDirect.coeffRef(biggest_col_index));
+      ++number_of_transpositions;
+    }
+
+    // generate the householder vector, store it below the diagonal
+    RealScalar beta;
+    m_qr.col(k).tail(rows-k).makeHouseholderInPlace(m_hCoeffs.coeffRef(k), beta);
+
+    // apply the householder transformation to the diagonal coefficient
+    m_qr.coeffRef(k,k) = beta;
+
+    // remember the maximum absolute value of diagonal coefficients
+    if(abs(beta) > m_maxpivot) m_maxpivot = abs(beta);
+
+    // apply the householder transformation
+    m_qr.bottomRightCorner(rows-k, cols-k-1)
+        .applyHouseholderOnTheLeft(m_qr.col(k).tail(rows-k-1), m_hCoeffs.coeffRef(k), &m_temp.coeffRef(k+1));
+
+    // update our table of norms of the columns
+    for (Index j = k + 1; j < cols; ++j) {
+      // The following implements the stable norm downgrade step discussed in
+      // http://www.netlib.org/lapack/lawnspdf/lawn176.pdf
+      // and used in LAPACK routines xGEQPF and xGEQP3.
+      // See lines 278-297 in http://www.netlib.org/lapack/explore-html/dc/df4/sgeqpf_8f_source.html
+      if (m_colNormsUpdated.coeffRef(j) != RealScalar(0)) {
+        RealScalar temp = abs(m_qr.coeffRef(k, j)) / m_colNormsUpdated.coeffRef(j);
+        temp = (RealScalar(1) + temp) * (RealScalar(1) - temp);
+        temp = temp <  RealScalar(0) ? RealScalar(0) : temp;
+        RealScalar temp2 = temp * numext::abs2<RealScalar>(m_colNormsUpdated.coeffRef(j) /
+                                                           m_colNormsDirect.coeffRef(j));
+        if (temp2 <= norm_downdate_threshold) {
+          // The updated norm has become too inaccurate so re-compute the column
+          // norm directly.
+          m_colNormsDirect.coeffRef(j) = m_qr.col(j).tail(rows - k - 1).norm();
+          m_colNormsUpdated.coeffRef(j) = m_colNormsDirect.coeffRef(j);
+        } else {
+          m_colNormsUpdated.coeffRef(j) *= numext::sqrt(temp);
+        }
+      }
+    }
+  }
+
+  m_colsPermutation.setIdentity(PermIndexType(cols));
+  for(PermIndexType k = 0; k < size/*m_nonzero_pivots*/; ++k)
+    m_colsPermutation.applyTranspositionOnTheRight(k, PermIndexType(m_colsTranspositions.coeff(k)));
+
+  m_det_pq = (number_of_transpositions%2) ? -1 : 1;
+  m_isInitialized = true;
+}
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename _MatrixType>
+template<typename RhsType, typename DstType>
+void ColPivHouseholderQR<_MatrixType>::_solve_impl(const RhsType &rhs, DstType &dst) const
+{
+  eigen_assert(rhs.rows() == rows());
+
+  const Index nonzero_pivots = nonzeroPivots();
+
+  if(nonzero_pivots == 0)
+  {
+    dst.setZero();
+    return;
+  }
+
+  typename RhsType::PlainObject c(rhs);
+
+  // Note that the matrix Q = H_0^* H_1^*... so its inverse is Q^* = (H_0 H_1 ...)^T
+  c.applyOnTheLeft(householderSequence(m_qr, m_hCoeffs)
+                    .setLength(nonzero_pivots)
+                    .transpose()
+    );
+
+  m_qr.topLeftCorner(nonzero_pivots, nonzero_pivots)
+      .template triangularView<Upper>()
+      .solveInPlace(c.topRows(nonzero_pivots));
+
+  for(Index i = 0; i < nonzero_pivots; ++i) dst.row(m_colsPermutation.indices().coeff(i)) = c.row(i);
+  for(Index i = nonzero_pivots; i < cols(); ++i) dst.row(m_colsPermutation.indices().coeff(i)).setZero();
+}
+#endif
+
+namespace internal {
+
+template<typename DstXprType, typename MatrixType>
+struct Assignment<DstXprType, Inverse<ColPivHouseholderQR<MatrixType> >, internal::assign_op<typename DstXprType::Scalar,typename ColPivHouseholderQR<MatrixType>::Scalar>, Dense2Dense>
+{
+  typedef ColPivHouseholderQR<MatrixType> QrType;
+  typedef Inverse<QrType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename QrType::Scalar> &)
+  {
+    dst = src.nestedExpression().solve(MatrixType::Identity(src.rows(), src.cols()));
+  }
+};
+
+} // end namespace internal
+
+/** \returns the matrix Q as a sequence of householder transformations.
+  * You can extract the meaningful part only by using:
+  * \code qr.householderQ().setLength(qr.nonzeroPivots()) \endcode*/
+template<typename MatrixType>
+typename ColPivHouseholderQR<MatrixType>::HouseholderSequenceType ColPivHouseholderQR<MatrixType>
+  ::householderQ() const
+{
+  eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+  return HouseholderSequenceType(m_qr, m_hCoeffs.conjugate());
+}
+
+/** \return the column-pivoting Householder QR decomposition of \c *this.
+  *
+  * \sa class ColPivHouseholderQR
+  */
+template<typename Derived>
+const ColPivHouseholderQR<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::colPivHouseholderQr() const
+{
+  return ColPivHouseholderQR<PlainObject>(eval());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_COLPIVOTINGHOUSEHOLDERQR_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
new file mode 100644
index 00000000..4e9651f8
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
@@ -0,0 +1,97 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to LAPACKe
+ *    Householder QR decomposition of a matrix with column pivoting based on
+ *    LAPACKE_?geqp3 function.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_COLPIVOTINGHOUSEHOLDERQR_LAPACKE_H
+#define EIGEN_COLPIVOTINGHOUSEHOLDERQR_LAPACKE_H
+
+namespace Eigen { 
+
+/** \internal Specialization for the data types supported by LAPACKe */
+
+#define EIGEN_LAPACKE_QR_COLPIV(EIGTYPE, LAPACKE_TYPE, LAPACKE_PREFIX, EIGCOLROW, LAPACKE_COLROW) \
+template<> template<typename InputType> inline \
+ColPivHouseholderQR<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic> >& \
+ColPivHouseholderQR<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic> >::compute( \
+              const EigenBase<InputType>& matrix) \
+\
+{ \
+  using std::abs; \
+  typedef Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic> MatrixType; \
+  typedef MatrixType::RealScalar RealScalar; \
+  Index rows = matrix.rows();\
+  Index cols = matrix.cols();\
+\
+  m_qr = matrix;\
+  Index size = m_qr.diagonalSize();\
+  m_hCoeffs.resize(size);\
+\
+  m_colsTranspositions.resize(cols);\
+  /*Index number_of_transpositions = 0;*/ \
+\
+  m_nonzero_pivots = 0; \
+  m_maxpivot = RealScalar(0);\
+  m_colsPermutation.resize(cols); \
+  m_colsPermutation.indices().setZero(); \
+\
+  lapack_int lda = internal::convert_index<lapack_int,Index>(m_qr.outerStride()); \
+  lapack_int matrix_order = LAPACKE_COLROW; \
+  LAPACKE_##LAPACKE_PREFIX##geqp3( matrix_order, internal::convert_index<lapack_int,Index>(rows), internal::convert_index<lapack_int,Index>(cols), \
+                              (LAPACKE_TYPE*)m_qr.data(), lda, (lapack_int*)m_colsPermutation.indices().data(), (LAPACKE_TYPE*)m_hCoeffs.data()); \
+  m_isInitialized = true; \
+  m_maxpivot=m_qr.diagonal().cwiseAbs().maxCoeff(); \
+  m_hCoeffs.adjointInPlace(); \
+  RealScalar premultiplied_threshold = abs(m_maxpivot) * threshold(); \
+  lapack_int *perm = m_colsPermutation.indices().data(); \
+  for(Index i=0;i<size;i++) { \
+    m_nonzero_pivots += (abs(m_qr.coeff(i,i)) > premultiplied_threshold);\
+  } \
+  for(Index i=0;i<cols;i++) perm[i]--;\
+\
+  /*m_det_pq = (number_of_transpositions%2) ? -1 : 1;  // TODO: It's not needed now; fix upon availability in Eigen */ \
+\
+  return *this; \
+}
+
+EIGEN_LAPACKE_QR_COLPIV(double,   double,        d, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_QR_COLPIV(float,    float,         s, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_QR_COLPIV(dcomplex, lapack_complex_double, z, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_QR_COLPIV(scomplex, lapack_complex_float,  c, ColMajor, LAPACK_COL_MAJOR)
+
+EIGEN_LAPACKE_QR_COLPIV(double,   double,        d, RowMajor, LAPACK_ROW_MAJOR)
+EIGEN_LAPACKE_QR_COLPIV(float,    float,         s, RowMajor, LAPACK_ROW_MAJOR)
+EIGEN_LAPACKE_QR_COLPIV(dcomplex, lapack_complex_double, z, RowMajor, LAPACK_ROW_MAJOR)
+EIGEN_LAPACKE_QR_COLPIV(scomplex, lapack_complex_float,  c, RowMajor, LAPACK_ROW_MAJOR)
+
+} // end namespace Eigen
+
+#endif // EIGEN_COLPIVOTINGHOUSEHOLDERQR_LAPACKE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/QR/CompleteOrthogonalDecomposition.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/QR/CompleteOrthogonalDecomposition.h
new file mode 100644
index 00000000..13b61fcd
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/QR/CompleteOrthogonalDecomposition.h
@@ -0,0 +1,562 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Rasmus Munk Larsen <rmlarsen@google.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLETEORTHOGONALDECOMPOSITION_H
+#define EIGEN_COMPLETEORTHOGONALDECOMPOSITION_H
+
+namespace Eigen {
+
+namespace internal {
+template <typename _MatrixType>
+struct traits<CompleteOrthogonalDecomposition<_MatrixType> >
+    : traits<_MatrixType> {
+  enum { Flags = 0 };
+};
+
+}  // end namespace internal
+
+/** \ingroup QR_Module
+  *
+  * \class CompleteOrthogonalDecomposition
+  *
+  * \brief Complete orthogonal decomposition (COD) of a matrix.
+  *
+  * \param MatrixType the type of the matrix of which we are computing the COD.
+  *
+  * This class performs a rank-revealing complete orthogonal decomposition of a
+  * matrix  \b A into matrices \b P, \b Q, \b T, and \b Z such that
+  * \f[
+  *  \mathbf{A} \, \mathbf{P} = \mathbf{Q} \,
+  *                     \begin{bmatrix} \mathbf{T} &  \mathbf{0} \\
+  *                                     \mathbf{0} & \mathbf{0} \end{bmatrix} \, \mathbf{Z}
+  * \f]
+  * by using Householder transformations. Here, \b P is a permutation matrix,
+  * \b Q and \b Z are unitary matrices and \b T an upper triangular matrix of
+  * size rank-by-rank. \b A may be rank deficient.
+  *
+  * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
+  * 
+  * \sa MatrixBase::completeOrthogonalDecomposition()
+  */
+template <typename _MatrixType>
+class CompleteOrthogonalDecomposition {
+ public:
+  typedef _MatrixType MatrixType;
+  enum {
+    RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+    ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+    MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+  };
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef typename MatrixType::StorageIndex StorageIndex;
+  typedef typename internal::plain_diag_type<MatrixType>::type HCoeffsType;
+  typedef PermutationMatrix<ColsAtCompileTime, MaxColsAtCompileTime>
+      PermutationType;
+  typedef typename internal::plain_row_type<MatrixType, Index>::type
+      IntRowVectorType;
+  typedef typename internal::plain_row_type<MatrixType>::type RowVectorType;
+  typedef typename internal::plain_row_type<MatrixType, RealScalar>::type
+      RealRowVectorType;
+  typedef HouseholderSequence<
+      MatrixType, typename internal::remove_all<
+                      typename HCoeffsType::ConjugateReturnType>::type>
+      HouseholderSequenceType;
+  typedef typename MatrixType::PlainObject PlainObject;
+
+ private:
+  typedef typename PermutationType::Index PermIndexType;
+
+ public:
+  /**
+   * \brief Default Constructor.
+   *
+   * The default constructor is useful in cases in which the user intends to
+   * perform decompositions via
+   * \c CompleteOrthogonalDecomposition::compute(const* MatrixType&).
+   */
+  CompleteOrthogonalDecomposition() : m_cpqr(), m_zCoeffs(), m_temp() {}
+
+  /** \brief Default Constructor with memory preallocation
+   *
+   * Like the default constructor but with preallocation of the internal data
+   * according to the specified problem \a size.
+   * \sa CompleteOrthogonalDecomposition()
+   */
+  CompleteOrthogonalDecomposition(Index rows, Index cols)
+      : m_cpqr(rows, cols), m_zCoeffs((std::min)(rows, cols)), m_temp(cols) {}
+
+  /** \brief Constructs a complete orthogonal decomposition from a given
+   * matrix.
+   *
+   * This constructor computes the complete orthogonal decomposition of the
+   * matrix \a matrix by calling the method compute(). The default
+   * threshold for rank determination will be used. It is a short cut for:
+   *
+   * \code
+   * CompleteOrthogonalDecomposition<MatrixType> cod(matrix.rows(),
+   *                                                 matrix.cols());
+   * cod.setThreshold(Default);
+   * cod.compute(matrix);
+   * \endcode
+   *
+   * \sa compute()
+   */
+  template <typename InputType>
+  explicit CompleteOrthogonalDecomposition(const EigenBase<InputType>& matrix)
+      : m_cpqr(matrix.rows(), matrix.cols()),
+        m_zCoeffs((std::min)(matrix.rows(), matrix.cols())),
+        m_temp(matrix.cols())
+  {
+    compute(matrix.derived());
+  }
+
+  /** \brief Constructs a complete orthogonal decomposition from a given matrix
+    *
+    * This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when \c MatrixType is a Eigen::Ref.
+    *
+    * \sa CompleteOrthogonalDecomposition(const EigenBase&)
+    */
+  template<typename InputType>
+  explicit CompleteOrthogonalDecomposition(EigenBase<InputType>& matrix)
+    : m_cpqr(matrix.derived()),
+      m_zCoeffs((std::min)(matrix.rows(), matrix.cols())),
+      m_temp(matrix.cols())
+  {
+    computeInPlace();
+  }
+
+
+  /** This method computes the minimum-norm solution X to a least squares
+   * problem \f[\mathrm{minimize} \|A X - B\|, \f] where \b A is the matrix of
+   * which \c *this is the complete orthogonal decomposition.
+   *
+   * \param b the right-hand sides of the problem to solve.
+   *
+   * \returns a solution.
+   *
+   */
+  template <typename Rhs>
+  inline const Solve<CompleteOrthogonalDecomposition, Rhs> solve(
+      const MatrixBase<Rhs>& b) const {
+    eigen_assert(m_cpqr.m_isInitialized &&
+                 "CompleteOrthogonalDecomposition is not initialized.");
+    return Solve<CompleteOrthogonalDecomposition, Rhs>(*this, b.derived());
+  }
+
+  HouseholderSequenceType householderQ(void) const;
+  HouseholderSequenceType matrixQ(void) const { return m_cpqr.householderQ(); }
+
+  /** \returns the matrix \b Z.
+   */
+  MatrixType matrixZ() const {
+    MatrixType Z = MatrixType::Identity(m_cpqr.cols(), m_cpqr.cols());
+    applyZAdjointOnTheLeftInPlace(Z);
+    return Z.adjoint();
+  }
+
+  /** \returns a reference to the matrix where the complete orthogonal
+   * decomposition is stored
+   */
+  const MatrixType& matrixQTZ() const { return m_cpqr.matrixQR(); }
+
+  /** \returns a reference to the matrix where the complete orthogonal
+   * decomposition is stored.
+   * \warning The strict lower part and \code cols() - rank() \endcode right
+   * columns of this matrix contains internal values.
+   * Only the upper triangular part should be referenced. To get it, use
+   * \code matrixT().template triangularView<Upper>() \endcode
+   * For rank-deficient matrices, use
+   * \code
+   * matrixR().topLeftCorner(rank(), rank()).template triangularView<Upper>()
+   * \endcode
+   */
+  const MatrixType& matrixT() const { return m_cpqr.matrixQR(); }
+
+  template <typename InputType>
+  CompleteOrthogonalDecomposition& compute(const EigenBase<InputType>& matrix) {
+    // Compute the column pivoted QR factorization A P = Q R.
+    m_cpqr.compute(matrix);
+    computeInPlace();
+    return *this;
+  }
+
+  /** \returns a const reference to the column permutation matrix */
+  const PermutationType& colsPermutation() const {
+    return m_cpqr.colsPermutation();
+  }
+
+  /** \returns the absolute value of the determinant of the matrix of which
+   * *this is the complete orthogonal decomposition. It has only linear
+   * complexity (that is, O(n) where n is the dimension of the square matrix)
+   * as the complete orthogonal decomposition has already been computed.
+   *
+   * \note This is only for square matrices.
+   *
+   * \warning a determinant can be very big or small, so for matrices
+   * of large enough dimension, there is a risk of overflow/underflow.
+   * One way to work around that is to use logAbsDeterminant() instead.
+   *
+   * \sa logAbsDeterminant(), MatrixBase::determinant()
+   */
+  typename MatrixType::RealScalar absDeterminant() const;
+
+  /** \returns the natural log of the absolute value of the determinant of the
+   * matrix of which *this is the complete orthogonal decomposition. It has
+   * only linear complexity (that is, O(n) where n is the dimension of the
+   * square matrix) as the complete orthogonal decomposition has already been
+   * computed.
+   *
+   * \note This is only for square matrices.
+   *
+   * \note This method is useful to work around the risk of overflow/underflow
+   * that's inherent to determinant computation.
+   *
+   * \sa absDeterminant(), MatrixBase::determinant()
+   */
+  typename MatrixType::RealScalar logAbsDeterminant() const;
+
+  /** \returns the rank of the matrix of which *this is the complete orthogonal
+   * decomposition.
+   *
+   * \note This method has to determine which pivots should be considered
+   * nonzero. For that, it uses the threshold value that you can control by
+   * calling setThreshold(const RealScalar&).
+   */
+  inline Index rank() const { return m_cpqr.rank(); }
+
+  /** \returns the dimension of the kernel of the matrix of which *this is the
+   * complete orthogonal decomposition.
+   *
+   * \note This method has to determine which pivots should be considered
+   * nonzero. For that, it uses the threshold value that you can control by
+   * calling setThreshold(const RealScalar&).
+   */
+  inline Index dimensionOfKernel() const { return m_cpqr.dimensionOfKernel(); }
+
+  /** \returns true if the matrix of which *this is the decomposition represents
+   * an injective linear map, i.e. has trivial kernel; false otherwise.
+   *
+   * \note This method has to determine which pivots should be considered
+   * nonzero. For that, it uses the threshold value that you can control by
+   * calling setThreshold(const RealScalar&).
+   */
+  inline bool isInjective() const { return m_cpqr.isInjective(); }
+
+  /** \returns true if the matrix of which *this is the decomposition represents
+   * a surjective linear map; false otherwise.
+   *
+   * \note This method has to determine which pivots should be considered
+   * nonzero. For that, it uses the threshold value that you can control by
+   * calling setThreshold(const RealScalar&).
+   */
+  inline bool isSurjective() const { return m_cpqr.isSurjective(); }
+
+  /** \returns true if the matrix of which *this is the complete orthogonal
+   * decomposition is invertible.
+   *
+   * \note This method has to determine which pivots should be considered
+   * nonzero. For that, it uses the threshold value that you can control by
+   * calling setThreshold(const RealScalar&).
+   */
+  inline bool isInvertible() const { return m_cpqr.isInvertible(); }
+
+  /** \returns the pseudo-inverse of the matrix of which *this is the complete
+   * orthogonal decomposition.
+   * \warning: Do not compute \c this->pseudoInverse()*rhs to solve a linear systems.
+   * It is more efficient and numerically stable to call \c this->solve(rhs).
+   */
+  inline const Inverse<CompleteOrthogonalDecomposition> pseudoInverse() const
+  {
+    return Inverse<CompleteOrthogonalDecomposition>(*this);
+  }
+
+  inline Index rows() const { return m_cpqr.rows(); }
+  inline Index cols() const { return m_cpqr.cols(); }
+
+  /** \returns a const reference to the vector of Householder coefficients used
+   * to represent the factor \c Q.
+   *
+   * For advanced uses only.
+   */
+  inline const HCoeffsType& hCoeffs() const { return m_cpqr.hCoeffs(); }
+
+  /** \returns a const reference to the vector of Householder coefficients
+   * used to represent the factor \c Z.
+   *
+   * For advanced uses only.
+   */
+  const HCoeffsType& zCoeffs() const { return m_zCoeffs; }
+
+  /** Allows to prescribe a threshold to be used by certain methods, such as
+   * rank(), who need to determine when pivots are to be considered nonzero.
+   * Most be called before calling compute().
+   *
+   * When it needs to get the threshold value, Eigen calls threshold(). By
+   * default, this uses a formula to automatically determine a reasonable
+   * threshold. Once you have called the present method
+   * setThreshold(const RealScalar&), your value is used instead.
+   *
+   * \param threshold The new value to use as the threshold.
+   *
+   * A pivot will be considered nonzero if its absolute value is strictly
+   * greater than
+   *  \f$ \vert pivot \vert \leqslant threshold \times \vert maxpivot \vert \f$
+   * where maxpivot is the biggest pivot.
+   *
+   * If you want to come back to the default behavior, call
+   * setThreshold(Default_t)
+   */
+  CompleteOrthogonalDecomposition& setThreshold(const RealScalar& threshold) {
+    m_cpqr.setThreshold(threshold);
+    return *this;
+  }
+
+  /** Allows to come back to the default behavior, letting Eigen use its default
+   * formula for determining the threshold.
+   *
+   * You should pass the special object Eigen::Default as parameter here.
+   * \code qr.setThreshold(Eigen::Default); \endcode
+   *
+   * See the documentation of setThreshold(const RealScalar&).
+   */
+  CompleteOrthogonalDecomposition& setThreshold(Default_t) {
+    m_cpqr.setThreshold(Default);
+    return *this;
+  }
+
+  /** Returns the threshold that will be used by certain methods such as rank().
+   *
+   * See the documentation of setThreshold(const RealScalar&).
+   */
+  RealScalar threshold() const { return m_cpqr.threshold(); }
+
+  /** \returns the number of nonzero pivots in the complete orthogonal
+   * decomposition. Here nonzero is meant in the exact sense, not in a
+   * fuzzy sense. So that notion isn't really intrinsically interesting,
+   * but it is still useful when implementing algorithms.
+   *
+   * \sa rank()
+   */
+  inline Index nonzeroPivots() const { return m_cpqr.nonzeroPivots(); }
+
+  /** \returns the absolute value of the biggest pivot, i.e. the biggest
+   *          diagonal coefficient of R.
+   */
+  inline RealScalar maxPivot() const { return m_cpqr.maxPivot(); }
+
+  /** \brief Reports whether the complete orthogonal decomposition was
+   * succesful.
+   *
+   * \note This function always returns \c Success. It is provided for
+   * compatibility
+   * with other factorization routines.
+   * \returns \c Success
+   */
+  ComputationInfo info() const {
+    eigen_assert(m_cpqr.m_isInitialized && "Decomposition is not initialized.");
+    return Success;
+  }
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+  template <typename RhsType, typename DstType>
+  void _solve_impl(const RhsType& rhs, DstType& dst) const;
+#endif
+
+ protected:
+  static void check_template_parameters() {
+    EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+  }
+
+  void computeInPlace();
+
+  /** Overwrites \b rhs with \f$ \mathbf{Z}^* * \mathbf{rhs} \f$.
+   */
+  template <typename Rhs>
+  void applyZAdjointOnTheLeftInPlace(Rhs& rhs) const;
+
+  ColPivHouseholderQR<MatrixType> m_cpqr;
+  HCoeffsType m_zCoeffs;
+  RowVectorType m_temp;
+};
+
+template <typename MatrixType>
+typename MatrixType::RealScalar
+CompleteOrthogonalDecomposition<MatrixType>::absDeterminant() const {
+  return m_cpqr.absDeterminant();
+}
+
+template <typename MatrixType>
+typename MatrixType::RealScalar
+CompleteOrthogonalDecomposition<MatrixType>::logAbsDeterminant() const {
+  return m_cpqr.logAbsDeterminant();
+}
+
+/** Performs the complete orthogonal decomposition of the given matrix \a
+ * matrix. The result of the factorization is stored into \c *this, and a
+ * reference to \c *this is returned.
+ *
+ * \sa class CompleteOrthogonalDecomposition,
+ * CompleteOrthogonalDecomposition(const MatrixType&)
+ */
+template <typename MatrixType>
+void CompleteOrthogonalDecomposition<MatrixType>::computeInPlace()
+{
+  check_template_parameters();
+
+  // the column permutation is stored as int indices, so just to be sure:
+  eigen_assert(m_cpqr.cols() <= NumTraits<int>::highest());
+
+  const Index rank = m_cpqr.rank();
+  const Index cols = m_cpqr.cols();
+  const Index rows = m_cpqr.rows();
+  m_zCoeffs.resize((std::min)(rows, cols));
+  m_temp.resize(cols);
+
+  if (rank < cols) {
+    // We have reduced the (permuted) matrix to the form
+    //   [R11 R12]
+    //   [ 0  R22]
+    // where R11 is r-by-r (r = rank) upper triangular, R12 is
+    // r-by-(n-r), and R22 is empty or the norm of R22 is negligible.
+    // We now compute the complete orthogonal decomposition by applying
+    // Householder transformations from the right to the upper trapezoidal
+    // matrix X = [R11 R12] to zero out R12 and obtain the factorization
+    // [R11 R12] = [T11 0] * Z, where T11 is r-by-r upper triangular and
+    // Z = Z(0) * Z(1) ... Z(r-1) is an n-by-n orthogonal matrix.
+    // We store the data representing Z in R12 and m_zCoeffs.
+    for (Index k = rank - 1; k >= 0; --k) {
+      if (k != rank - 1) {
+        // Given the API for Householder reflectors, it is more convenient if
+        // we swap the leading parts of columns k and r-1 (zero-based) to form
+        // the matrix X_k = [X(0:k, k), X(0:k, r:n)]
+        m_cpqr.m_qr.col(k).head(k + 1).swap(
+            m_cpqr.m_qr.col(rank - 1).head(k + 1));
+      }
+      // Construct Householder reflector Z(k) to zero out the last row of X_k,
+      // i.e. choose Z(k) such that
+      // [X(k, k), X(k, r:n)] * Z(k) = [beta, 0, .., 0].
+      RealScalar beta;
+      m_cpqr.m_qr.row(k)
+          .tail(cols - rank + 1)
+          .makeHouseholderInPlace(m_zCoeffs(k), beta);
+      m_cpqr.m_qr(k, rank - 1) = beta;
+      if (k > 0) {
+        // Apply Z(k) to the first k rows of X_k
+        m_cpqr.m_qr.topRightCorner(k, cols - rank + 1)
+            .applyHouseholderOnTheRight(
+                m_cpqr.m_qr.row(k).tail(cols - rank).transpose(), m_zCoeffs(k),
+                &m_temp(0));
+      }
+      if (k != rank - 1) {
+        // Swap X(0:k,k) back to its proper location.
+        m_cpqr.m_qr.col(k).head(k + 1).swap(
+            m_cpqr.m_qr.col(rank - 1).head(k + 1));
+      }
+    }
+  }
+}
+
+template <typename MatrixType>
+template <typename Rhs>
+void CompleteOrthogonalDecomposition<MatrixType>::applyZAdjointOnTheLeftInPlace(
+    Rhs& rhs) const {
+  const Index cols = this->cols();
+  const Index nrhs = rhs.cols();
+  const Index rank = this->rank();
+  Matrix<typename MatrixType::Scalar, Dynamic, 1> temp((std::max)(cols, nrhs));
+  for (Index k = 0; k < rank; ++k) {
+    if (k != rank - 1) {
+      rhs.row(k).swap(rhs.row(rank - 1));
+    }
+    rhs.middleRows(rank - 1, cols - rank + 1)
+        .applyHouseholderOnTheLeft(
+            matrixQTZ().row(k).tail(cols - rank).adjoint(), zCoeffs()(k),
+            &temp(0));
+    if (k != rank - 1) {
+      rhs.row(k).swap(rhs.row(rank - 1));
+    }
+  }
+}
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template <typename _MatrixType>
+template <typename RhsType, typename DstType>
+void CompleteOrthogonalDecomposition<_MatrixType>::_solve_impl(
+    const RhsType& rhs, DstType& dst) const {
+  eigen_assert(rhs.rows() == this->rows());
+
+  const Index rank = this->rank();
+  if (rank == 0) {
+    dst.setZero();
+    return;
+  }
+
+  // Compute c = Q^* * rhs
+  // Note that the matrix Q = H_0^* H_1^*... so its inverse is
+  // Q^* = (H_0 H_1 ...)^T
+  typename RhsType::PlainObject c(rhs);
+  c.applyOnTheLeft(
+      householderSequence(matrixQTZ(), hCoeffs()).setLength(rank).transpose());
+
+  // Solve T z = c(1:rank, :)
+  dst.topRows(rank) = matrixT()
+                          .topLeftCorner(rank, rank)
+                          .template triangularView<Upper>()
+                          .solve(c.topRows(rank));
+
+  const Index cols = this->cols();
+  if (rank < cols) {
+    // Compute y = Z^* * [ z ]
+    //                   [ 0 ]
+    dst.bottomRows(cols - rank).setZero();
+    applyZAdjointOnTheLeftInPlace(dst);
+  }
+
+  // Undo permutation to get x = P^{-1} * y.
+  dst = colsPermutation() * dst;
+}
+#endif
+
+namespace internal {
+
+template<typename DstXprType, typename MatrixType>
+struct Assignment<DstXprType, Inverse<CompleteOrthogonalDecomposition<MatrixType> >, internal::assign_op<typename DstXprType::Scalar,typename CompleteOrthogonalDecomposition<MatrixType>::Scalar>, Dense2Dense>
+{
+  typedef CompleteOrthogonalDecomposition<MatrixType> CodType;
+  typedef Inverse<CodType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename CodType::Scalar> &)
+  {
+    dst = src.nestedExpression().solve(MatrixType::Identity(src.rows(), src.rows()));
+  }
+};
+
+} // end namespace internal
+
+/** \returns the matrix Q as a sequence of householder transformations */
+template <typename MatrixType>
+typename CompleteOrthogonalDecomposition<MatrixType>::HouseholderSequenceType
+CompleteOrthogonalDecomposition<MatrixType>::householderQ() const {
+  return m_cpqr.householderQ();
+}
+
+/** \return the complete orthogonal decomposition of \c *this.
+  *
+  * \sa class CompleteOrthogonalDecomposition
+  */
+template <typename Derived>
+const CompleteOrthogonalDecomposition<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::completeOrthogonalDecomposition() const {
+  return CompleteOrthogonalDecomposition<PlainObject>(eval());
+}
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_COMPLETEORTHOGONALDECOMPOSITION_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/QR/FullPivHouseholderQR.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/QR/FullPivHouseholderQR.h
new file mode 100644
index 00000000..c31e47cc
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/QR/FullPivHouseholderQR.h
@@ -0,0 +1,675 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_FULLPIVOTINGHOUSEHOLDERQR_H
+#define EIGEN_FULLPIVOTINGHOUSEHOLDERQR_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename _MatrixType> struct traits<FullPivHouseholderQR<_MatrixType> >
+ : traits<_MatrixType>
+{
+  enum { Flags = 0 };
+};
+
+template<typename MatrixType> struct FullPivHouseholderQRMatrixQReturnType;
+
+template<typename MatrixType>
+struct traits<FullPivHouseholderQRMatrixQReturnType<MatrixType> >
+{
+  typedef typename MatrixType::PlainObject ReturnType;
+};
+
+} // end namespace internal
+
+/** \ingroup QR_Module
+  *
+  * \class FullPivHouseholderQR
+  *
+  * \brief Householder rank-revealing QR decomposition of a matrix with full pivoting
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the QR decomposition
+  *
+  * This class performs a rank-revealing QR decomposition of a matrix \b A into matrices \b P, \b P', \b Q and \b R
+  * such that 
+  * \f[
+  *  \mathbf{P} \, \mathbf{A} \, \mathbf{P}' = \mathbf{Q} \, \mathbf{R}
+  * \f]
+  * by using Householder transformations. Here, \b P and \b P' are permutation matrices, \b Q a unitary matrix 
+  * and \b R an upper triangular matrix.
+  *
+  * This decomposition performs a very prudent full pivoting in order to be rank-revealing and achieve optimal
+  * numerical stability. The trade-off is that it is slower than HouseholderQR and ColPivHouseholderQR.
+  *
+  * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
+  * 
+  * \sa MatrixBase::fullPivHouseholderQr()
+  */
+template<typename _MatrixType> class FullPivHouseholderQR
+{
+  public:
+
+    typedef _MatrixType MatrixType;
+    enum {
+      RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    // FIXME should be int
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef internal::FullPivHouseholderQRMatrixQReturnType<MatrixType> MatrixQReturnType;
+    typedef typename internal::plain_diag_type<MatrixType>::type HCoeffsType;
+    typedef Matrix<StorageIndex, 1,
+                   EIGEN_SIZE_MIN_PREFER_DYNAMIC(ColsAtCompileTime,RowsAtCompileTime), RowMajor, 1,
+                   EIGEN_SIZE_MIN_PREFER_FIXED(MaxColsAtCompileTime,MaxRowsAtCompileTime)> IntDiagSizeVectorType;
+    typedef PermutationMatrix<ColsAtCompileTime, MaxColsAtCompileTime> PermutationType;
+    typedef typename internal::plain_row_type<MatrixType>::type RowVectorType;
+    typedef typename internal::plain_col_type<MatrixType>::type ColVectorType;
+    typedef typename MatrixType::PlainObject PlainObject;
+
+    /** \brief Default Constructor.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via FullPivHouseholderQR::compute(const MatrixType&).
+      */
+    FullPivHouseholderQR()
+      : m_qr(),
+        m_hCoeffs(),
+        m_rows_transpositions(),
+        m_cols_transpositions(),
+        m_cols_permutation(),
+        m_temp(),
+        m_isInitialized(false),
+        m_usePrescribedThreshold(false) {}
+
+    /** \brief Default Constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem \a size.
+      * \sa FullPivHouseholderQR()
+      */
+    FullPivHouseholderQR(Index rows, Index cols)
+      : m_qr(rows, cols),
+        m_hCoeffs((std::min)(rows,cols)),
+        m_rows_transpositions((std::min)(rows,cols)),
+        m_cols_transpositions((std::min)(rows,cols)),
+        m_cols_permutation(cols),
+        m_temp(cols),
+        m_isInitialized(false),
+        m_usePrescribedThreshold(false) {}
+
+    /** \brief Constructs a QR factorization from a given matrix
+      *
+      * This constructor computes the QR factorization of the matrix \a matrix by calling
+      * the method compute(). It is a short cut for:
+      * 
+      * \code
+      * FullPivHouseholderQR<MatrixType> qr(matrix.rows(), matrix.cols());
+      * qr.compute(matrix);
+      * \endcode
+      * 
+      * \sa compute()
+      */
+    template<typename InputType>
+    explicit FullPivHouseholderQR(const EigenBase<InputType>& matrix)
+      : m_qr(matrix.rows(), matrix.cols()),
+        m_hCoeffs((std::min)(matrix.rows(), matrix.cols())),
+        m_rows_transpositions((std::min)(matrix.rows(), matrix.cols())),
+        m_cols_transpositions((std::min)(matrix.rows(), matrix.cols())),
+        m_cols_permutation(matrix.cols()),
+        m_temp(matrix.cols()),
+        m_isInitialized(false),
+        m_usePrescribedThreshold(false)
+    {
+      compute(matrix.derived());
+    }
+
+    /** \brief Constructs a QR factorization from a given matrix
+      *
+      * This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when \c MatrixType is a Eigen::Ref.
+      *
+      * \sa FullPivHouseholderQR(const EigenBase&)
+      */
+    template<typename InputType>
+    explicit FullPivHouseholderQR(EigenBase<InputType>& matrix)
+      : m_qr(matrix.derived()),
+        m_hCoeffs((std::min)(matrix.rows(), matrix.cols())),
+        m_rows_transpositions((std::min)(matrix.rows(), matrix.cols())),
+        m_cols_transpositions((std::min)(matrix.rows(), matrix.cols())),
+        m_cols_permutation(matrix.cols()),
+        m_temp(matrix.cols()),
+        m_isInitialized(false),
+        m_usePrescribedThreshold(false)
+    {
+      computeInPlace();
+    }
+
+    /** This method finds a solution x to the equation Ax=b, where A is the matrix of which
+      * \c *this is the QR decomposition.
+      *
+      * \param b the right-hand-side of the equation to solve.
+      *
+      * \returns the exact or least-square solution if the rank is greater or equal to the number of columns of A,
+      * and an arbitrary solution otherwise.
+      *
+      * \note_about_checking_solutions
+      *
+      * \note_about_arbitrary_choice_of_solution
+      *
+      * Example: \include FullPivHouseholderQR_solve.cpp
+      * Output: \verbinclude FullPivHouseholderQR_solve.out
+      */
+    template<typename Rhs>
+    inline const Solve<FullPivHouseholderQR, Rhs>
+    solve(const MatrixBase<Rhs>& b) const
+    {
+      eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+      return Solve<FullPivHouseholderQR, Rhs>(*this, b.derived());
+    }
+
+    /** \returns Expression object representing the matrix Q
+      */
+    MatrixQReturnType matrixQ(void) const;
+
+    /** \returns a reference to the matrix where the Householder QR decomposition is stored
+      */
+    const MatrixType& matrixQR() const
+    {
+      eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+      return m_qr;
+    }
+
+    template<typename InputType>
+    FullPivHouseholderQR& compute(const EigenBase<InputType>& matrix);
+
+    /** \returns a const reference to the column permutation matrix */
+    const PermutationType& colsPermutation() const
+    {
+      eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+      return m_cols_permutation;
+    }
+
+    /** \returns a const reference to the vector of indices representing the rows transpositions */
+    const IntDiagSizeVectorType& rowsTranspositions() const
+    {
+      eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+      return m_rows_transpositions;
+    }
+
+    /** \returns the absolute value of the determinant of the matrix of which
+      * *this is the QR decomposition. It has only linear complexity
+      * (that is, O(n) where n is the dimension of the square matrix)
+      * as the QR decomposition has already been computed.
+      *
+      * \note This is only for square matrices.
+      *
+      * \warning a determinant can be very big or small, so for matrices
+      * of large enough dimension, there is a risk of overflow/underflow.
+      * One way to work around that is to use logAbsDeterminant() instead.
+      *
+      * \sa logAbsDeterminant(), MatrixBase::determinant()
+      */
+    typename MatrixType::RealScalar absDeterminant() const;
+
+    /** \returns the natural log of the absolute value of the determinant of the matrix of which
+      * *this is the QR decomposition. It has only linear complexity
+      * (that is, O(n) where n is the dimension of the square matrix)
+      * as the QR decomposition has already been computed.
+      *
+      * \note This is only for square matrices.
+      *
+      * \note This method is useful to work around the risk of overflow/underflow that's inherent
+      * to determinant computation.
+      *
+      * \sa absDeterminant(), MatrixBase::determinant()
+      */
+    typename MatrixType::RealScalar logAbsDeterminant() const;
+
+    /** \returns the rank of the matrix of which *this is the QR decomposition.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline Index rank() const
+    {
+      using std::abs;
+      eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+      RealScalar premultiplied_threshold = abs(m_maxpivot) * threshold();
+      Index result = 0;
+      for(Index i = 0; i < m_nonzero_pivots; ++i)
+        result += (abs(m_qr.coeff(i,i)) > premultiplied_threshold);
+      return result;
+    }
+
+    /** \returns the dimension of the kernel of the matrix of which *this is the QR decomposition.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline Index dimensionOfKernel() const
+    {
+      eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+      return cols() - rank();
+    }
+
+    /** \returns true if the matrix of which *this is the QR decomposition represents an injective
+      *          linear map, i.e. has trivial kernel; false otherwise.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline bool isInjective() const
+    {
+      eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+      return rank() == cols();
+    }
+
+    /** \returns true if the matrix of which *this is the QR decomposition represents a surjective
+      *          linear map; false otherwise.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline bool isSurjective() const
+    {
+      eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+      return rank() == rows();
+    }
+
+    /** \returns true if the matrix of which *this is the QR decomposition is invertible.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline bool isInvertible() const
+    {
+      eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+      return isInjective() && isSurjective();
+    }
+
+    /** \returns the inverse of the matrix of which *this is the QR decomposition.
+      *
+      * \note If this matrix is not invertible, the returned matrix has undefined coefficients.
+      *       Use isInvertible() to first determine whether this matrix is invertible.
+      */
+    inline const Inverse<FullPivHouseholderQR> inverse() const
+    {
+      eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+      return Inverse<FullPivHouseholderQR>(*this);
+    }
+
+    inline Index rows() const { return m_qr.rows(); }
+    inline Index cols() const { return m_qr.cols(); }
+    
+    /** \returns a const reference to the vector of Householder coefficients used to represent the factor \c Q.
+      * 
+      * For advanced uses only.
+      */
+    const HCoeffsType& hCoeffs() const { return m_hCoeffs; }
+
+    /** Allows to prescribe a threshold to be used by certain methods, such as rank(),
+      * who need to determine when pivots are to be considered nonzero. This is not used for the
+      * QR decomposition itself.
+      *
+      * When it needs to get the threshold value, Eigen calls threshold(). By default, this
+      * uses a formula to automatically determine a reasonable threshold.
+      * Once you have called the present method setThreshold(const RealScalar&),
+      * your value is used instead.
+      *
+      * \param threshold The new value to use as the threshold.
+      *
+      * A pivot will be considered nonzero if its absolute value is strictly greater than
+      *  \f$ \vert pivot \vert \leqslant threshold \times \vert maxpivot \vert \f$
+      * where maxpivot is the biggest pivot.
+      *
+      * If you want to come back to the default behavior, call setThreshold(Default_t)
+      */
+    FullPivHouseholderQR& setThreshold(const RealScalar& threshold)
+    {
+      m_usePrescribedThreshold = true;
+      m_prescribedThreshold = threshold;
+      return *this;
+    }
+
+    /** Allows to come back to the default behavior, letting Eigen use its default formula for
+      * determining the threshold.
+      *
+      * You should pass the special object Eigen::Default as parameter here.
+      * \code qr.setThreshold(Eigen::Default); \endcode
+      *
+      * See the documentation of setThreshold(const RealScalar&).
+      */
+    FullPivHouseholderQR& setThreshold(Default_t)
+    {
+      m_usePrescribedThreshold = false;
+      return *this;
+    }
+
+    /** Returns the threshold that will be used by certain methods such as rank().
+      *
+      * See the documentation of setThreshold(const RealScalar&).
+      */
+    RealScalar threshold() const
+    {
+      eigen_assert(m_isInitialized || m_usePrescribedThreshold);
+      return m_usePrescribedThreshold ? m_prescribedThreshold
+      // this formula comes from experimenting (see "LU precision tuning" thread on the list)
+      // and turns out to be identical to Higham's formula used already in LDLt.
+                                      : NumTraits<Scalar>::epsilon() * RealScalar(m_qr.diagonalSize());
+    }
+
+    /** \returns the number of nonzero pivots in the QR decomposition.
+      * Here nonzero is meant in the exact sense, not in a fuzzy sense.
+      * So that notion isn't really intrinsically interesting, but it is
+      * still useful when implementing algorithms.
+      *
+      * \sa rank()
+      */
+    inline Index nonzeroPivots() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return m_nonzero_pivots;
+    }
+
+    /** \returns the absolute value of the biggest pivot, i.e. the biggest
+      *          diagonal coefficient of U.
+      */
+    RealScalar maxPivot() const { return m_maxpivot; }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename RhsType, typename DstType>
+    void _solve_impl(const RhsType &rhs, DstType &dst) const;
+    #endif
+
+  protected:
+
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+    }
+
+    void computeInPlace();
+
+    MatrixType m_qr;
+    HCoeffsType m_hCoeffs;
+    IntDiagSizeVectorType m_rows_transpositions;
+    IntDiagSizeVectorType m_cols_transpositions;
+    PermutationType m_cols_permutation;
+    RowVectorType m_temp;
+    bool m_isInitialized, m_usePrescribedThreshold;
+    RealScalar m_prescribedThreshold, m_maxpivot;
+    Index m_nonzero_pivots;
+    RealScalar m_precision;
+    Index m_det_pq;
+};
+
+template<typename MatrixType>
+typename MatrixType::RealScalar FullPivHouseholderQR<MatrixType>::absDeterminant() const
+{
+  using std::abs;
+  eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+  eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
+  return abs(m_qr.diagonal().prod());
+}
+
+template<typename MatrixType>
+typename MatrixType::RealScalar FullPivHouseholderQR<MatrixType>::logAbsDeterminant() const
+{
+  eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+  eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
+  return m_qr.diagonal().cwiseAbs().array().log().sum();
+}
+
+/** Performs the QR factorization of the given matrix \a matrix. The result of
+  * the factorization is stored into \c *this, and a reference to \c *this
+  * is returned.
+  *
+  * \sa class FullPivHouseholderQR, FullPivHouseholderQR(const MatrixType&)
+  */
+template<typename MatrixType>
+template<typename InputType>
+FullPivHouseholderQR<MatrixType>& FullPivHouseholderQR<MatrixType>::compute(const EigenBase<InputType>& matrix)
+{
+  m_qr = matrix.derived();
+  computeInPlace();
+  return *this;
+}
+
+template<typename MatrixType>
+void FullPivHouseholderQR<MatrixType>::computeInPlace()
+{
+  check_template_parameters();
+
+  using std::abs;
+  Index rows = m_qr.rows();
+  Index cols = m_qr.cols();
+  Index size = (std::min)(rows,cols);
+
+  
+  m_hCoeffs.resize(size);
+
+  m_temp.resize(cols);
+
+  m_precision = NumTraits<Scalar>::epsilon() * RealScalar(size);
+
+  m_rows_transpositions.resize(size);
+  m_cols_transpositions.resize(size);
+  Index number_of_transpositions = 0;
+
+  RealScalar biggest(0);
+
+  m_nonzero_pivots = size; // the generic case is that in which all pivots are nonzero (invertible case)
+  m_maxpivot = RealScalar(0);
+
+  for (Index k = 0; k < size; ++k)
+  {
+    Index row_of_biggest_in_corner, col_of_biggest_in_corner;
+    typedef internal::scalar_score_coeff_op<Scalar> Scoring;
+    typedef typename Scoring::result_type Score;
+
+    Score score = m_qr.bottomRightCorner(rows-k, cols-k)
+                      .unaryExpr(Scoring())
+                      .maxCoeff(&row_of_biggest_in_corner, &col_of_biggest_in_corner);
+    row_of_biggest_in_corner += k;
+    col_of_biggest_in_corner += k;
+    RealScalar biggest_in_corner = internal::abs_knowing_score<Scalar>()(m_qr(row_of_biggest_in_corner, col_of_biggest_in_corner), score);
+    if(k==0) biggest = biggest_in_corner;
+
+    // if the corner is negligible, then we have less than full rank, and we can finish early
+    if(internal::isMuchSmallerThan(biggest_in_corner, biggest, m_precision))
+    {
+      m_nonzero_pivots = k;
+      for(Index i = k; i < size; i++)
+      {
+        m_rows_transpositions.coeffRef(i) = i;
+        m_cols_transpositions.coeffRef(i) = i;
+        m_hCoeffs.coeffRef(i) = Scalar(0);
+      }
+      break;
+    }
+
+    m_rows_transpositions.coeffRef(k) = row_of_biggest_in_corner;
+    m_cols_transpositions.coeffRef(k) = col_of_biggest_in_corner;
+    if(k != row_of_biggest_in_corner) {
+      m_qr.row(k).tail(cols-k).swap(m_qr.row(row_of_biggest_in_corner).tail(cols-k));
+      ++number_of_transpositions;
+    }
+    if(k != col_of_biggest_in_corner) {
+      m_qr.col(k).swap(m_qr.col(col_of_biggest_in_corner));
+      ++number_of_transpositions;
+    }
+
+    RealScalar beta;
+    m_qr.col(k).tail(rows-k).makeHouseholderInPlace(m_hCoeffs.coeffRef(k), beta);
+    m_qr.coeffRef(k,k) = beta;
+
+    // remember the maximum absolute value of diagonal coefficients
+    if(abs(beta) > m_maxpivot) m_maxpivot = abs(beta);
+
+    m_qr.bottomRightCorner(rows-k, cols-k-1)
+        .applyHouseholderOnTheLeft(m_qr.col(k).tail(rows-k-1), m_hCoeffs.coeffRef(k), &m_temp.coeffRef(k+1));
+  }
+
+  m_cols_permutation.setIdentity(cols);
+  for(Index k = 0; k < size; ++k)
+    m_cols_permutation.applyTranspositionOnTheRight(k, m_cols_transpositions.coeff(k));
+
+  m_det_pq = (number_of_transpositions%2) ? -1 : 1;
+  m_isInitialized = true;
+}
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename _MatrixType>
+template<typename RhsType, typename DstType>
+void FullPivHouseholderQR<_MatrixType>::_solve_impl(const RhsType &rhs, DstType &dst) const
+{
+  eigen_assert(rhs.rows() == rows());
+  const Index l_rank = rank();
+
+  // FIXME introduce nonzeroPivots() and use it here. and more generally,
+  // make the same improvements in this dec as in FullPivLU.
+  if(l_rank==0)
+  {
+    dst.setZero();
+    return;
+  }
+
+  typename RhsType::PlainObject c(rhs);
+
+  Matrix<Scalar,1,RhsType::ColsAtCompileTime> temp(rhs.cols());
+  for (Index k = 0; k < l_rank; ++k)
+  {
+    Index remainingSize = rows()-k;
+    c.row(k).swap(c.row(m_rows_transpositions.coeff(k)));
+    c.bottomRightCorner(remainingSize, rhs.cols())
+      .applyHouseholderOnTheLeft(m_qr.col(k).tail(remainingSize-1),
+                               m_hCoeffs.coeff(k), &temp.coeffRef(0));
+  }
+
+  m_qr.topLeftCorner(l_rank, l_rank)
+      .template triangularView<Upper>()
+      .solveInPlace(c.topRows(l_rank));
+
+  for(Index i = 0; i < l_rank; ++i) dst.row(m_cols_permutation.indices().coeff(i)) = c.row(i);
+  for(Index i = l_rank; i < cols(); ++i) dst.row(m_cols_permutation.indices().coeff(i)).setZero();
+}
+#endif
+
+namespace internal {
+  
+template<typename DstXprType, typename MatrixType>
+struct Assignment<DstXprType, Inverse<FullPivHouseholderQR<MatrixType> >, internal::assign_op<typename DstXprType::Scalar,typename FullPivHouseholderQR<MatrixType>::Scalar>, Dense2Dense>
+{
+  typedef FullPivHouseholderQR<MatrixType> QrType;
+  typedef Inverse<QrType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename QrType::Scalar> &)
+  {    
+    dst = src.nestedExpression().solve(MatrixType::Identity(src.rows(), src.cols()));
+  }
+};
+
+/** \ingroup QR_Module
+  *
+  * \brief Expression type for return value of FullPivHouseholderQR::matrixQ()
+  *
+  * \tparam MatrixType type of underlying dense matrix
+  */
+template<typename MatrixType> struct FullPivHouseholderQRMatrixQReturnType
+  : public ReturnByValue<FullPivHouseholderQRMatrixQReturnType<MatrixType> >
+{
+public:
+  typedef typename FullPivHouseholderQR<MatrixType>::IntDiagSizeVectorType IntDiagSizeVectorType;
+  typedef typename internal::plain_diag_type<MatrixType>::type HCoeffsType;
+  typedef Matrix<typename MatrixType::Scalar, 1, MatrixType::RowsAtCompileTime, RowMajor, 1,
+                 MatrixType::MaxRowsAtCompileTime> WorkVectorType;
+
+  FullPivHouseholderQRMatrixQReturnType(const MatrixType&       qr,
+                                        const HCoeffsType&      hCoeffs,
+                                        const IntDiagSizeVectorType& rowsTranspositions)
+    : m_qr(qr),
+      m_hCoeffs(hCoeffs),
+      m_rowsTranspositions(rowsTranspositions)
+  {}
+
+  template <typename ResultType>
+  void evalTo(ResultType& result) const
+  {
+    const Index rows = m_qr.rows();
+    WorkVectorType workspace(rows);
+    evalTo(result, workspace);
+  }
+
+  template <typename ResultType>
+  void evalTo(ResultType& result, WorkVectorType& workspace) const
+  {
+    using numext::conj;
+    // compute the product H'_0 H'_1 ... H'_n-1,
+    // where H_k is the k-th Householder transformation I - h_k v_k v_k'
+    // and v_k is the k-th Householder vector [1,m_qr(k+1,k), m_qr(k+2,k), ...]
+    const Index rows = m_qr.rows();
+    const Index cols = m_qr.cols();
+    const Index size = (std::min)(rows, cols);
+    workspace.resize(rows);
+    result.setIdentity(rows, rows);
+    for (Index k = size-1; k >= 0; k--)
+    {
+      result.block(k, k, rows-k, rows-k)
+            .applyHouseholderOnTheLeft(m_qr.col(k).tail(rows-k-1), conj(m_hCoeffs.coeff(k)), &workspace.coeffRef(k));
+      result.row(k).swap(result.row(m_rowsTranspositions.coeff(k)));
+    }
+  }
+
+  Index rows() const { return m_qr.rows(); }
+  Index cols() const { return m_qr.rows(); }
+
+protected:
+  typename MatrixType::Nested m_qr;
+  typename HCoeffsType::Nested m_hCoeffs;
+  typename IntDiagSizeVectorType::Nested m_rowsTranspositions;
+};
+
+// template<typename MatrixType>
+// struct evaluator<FullPivHouseholderQRMatrixQReturnType<MatrixType> >
+//  : public evaluator<ReturnByValue<FullPivHouseholderQRMatrixQReturnType<MatrixType> > >
+// {};
+
+} // end namespace internal
+
+template<typename MatrixType>
+inline typename FullPivHouseholderQR<MatrixType>::MatrixQReturnType FullPivHouseholderQR<MatrixType>::matrixQ() const
+{
+  eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+  return MatrixQReturnType(m_qr, m_hCoeffs, m_rows_transpositions);
+}
+
+/** \return the full-pivoting Householder QR decomposition of \c *this.
+  *
+  * \sa class FullPivHouseholderQR
+  */
+template<typename Derived>
+const FullPivHouseholderQR<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::fullPivHouseholderQr() const
+{
+  return FullPivHouseholderQR<PlainObject>(eval());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_FULLPIVOTINGHOUSEHOLDERQR_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/QR/HouseholderQR.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/QR/HouseholderQR.h
new file mode 100644
index 00000000..762b21c3
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/QR/HouseholderQR.h
@@ -0,0 +1,408 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2010 Vincent Lejeune
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_QR_H
+#define EIGEN_QR_H
+
+namespace Eigen { 
+
+/** \ingroup QR_Module
+  *
+  *
+  * \class HouseholderQR
+  *
+  * \brief Householder QR decomposition of a matrix
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the QR decomposition
+  *
+  * This class performs a QR decomposition of a matrix \b A into matrices \b Q and \b R
+  * such that 
+  * \f[
+  *  \mathbf{A} = \mathbf{Q} \, \mathbf{R}
+  * \f]
+  * by using Householder transformations. Here, \b Q a unitary matrix and \b R an upper triangular matrix.
+  * The result is stored in a compact way compatible with LAPACK.
+  *
+  * Note that no pivoting is performed. This is \b not a rank-revealing decomposition.
+  * If you want that feature, use FullPivHouseholderQR or ColPivHouseholderQR instead.
+  *
+  * This Householder QR decomposition is faster, but less numerically stable and less feature-full than
+  * FullPivHouseholderQR or ColPivHouseholderQR.
+  *
+  * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
+  *
+  * \sa MatrixBase::householderQr()
+  */
+template<typename _MatrixType> class HouseholderQR
+{
+  public:
+
+    typedef _MatrixType MatrixType;
+    enum {
+      RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    // FIXME should be int
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef Matrix<Scalar, RowsAtCompileTime, RowsAtCompileTime, (MatrixType::Flags&RowMajorBit) ? RowMajor : ColMajor, MaxRowsAtCompileTime, MaxRowsAtCompileTime> MatrixQType;
+    typedef typename internal::plain_diag_type<MatrixType>::type HCoeffsType;
+    typedef typename internal::plain_row_type<MatrixType>::type RowVectorType;
+    typedef HouseholderSequence<MatrixType,typename internal::remove_all<typename HCoeffsType::ConjugateReturnType>::type> HouseholderSequenceType;
+
+    /**
+      * \brief Default Constructor.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via HouseholderQR::compute(const MatrixType&).
+      */
+    HouseholderQR() : m_qr(), m_hCoeffs(), m_temp(), m_isInitialized(false) {}
+
+    /** \brief Default Constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem \a size.
+      * \sa HouseholderQR()
+      */
+    HouseholderQR(Index rows, Index cols)
+      : m_qr(rows, cols),
+        m_hCoeffs((std::min)(rows,cols)),
+        m_temp(cols),
+        m_isInitialized(false) {}
+
+    /** \brief Constructs a QR factorization from a given matrix
+      *
+      * This constructor computes the QR factorization of the matrix \a matrix by calling
+      * the method compute(). It is a short cut for:
+      * 
+      * \code
+      * HouseholderQR<MatrixType> qr(matrix.rows(), matrix.cols());
+      * qr.compute(matrix);
+      * \endcode
+      * 
+      * \sa compute()
+      */
+    template<typename InputType>
+    explicit HouseholderQR(const EigenBase<InputType>& matrix)
+      : m_qr(matrix.rows(), matrix.cols()),
+        m_hCoeffs((std::min)(matrix.rows(),matrix.cols())),
+        m_temp(matrix.cols()),
+        m_isInitialized(false)
+    {
+      compute(matrix.derived());
+    }
+
+
+    /** \brief Constructs a QR factorization from a given matrix
+      *
+      * This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when
+      * \c MatrixType is a Eigen::Ref.
+      *
+      * \sa HouseholderQR(const EigenBase&)
+      */
+    template<typename InputType>
+    explicit HouseholderQR(EigenBase<InputType>& matrix)
+      : m_qr(matrix.derived()),
+        m_hCoeffs((std::min)(matrix.rows(),matrix.cols())),
+        m_temp(matrix.cols()),
+        m_isInitialized(false)
+    {
+      computeInPlace();
+    }
+
+    /** This method finds a solution x to the equation Ax=b, where A is the matrix of which
+      * *this is the QR decomposition, if any exists.
+      *
+      * \param b the right-hand-side of the equation to solve.
+      *
+      * \returns a solution.
+      *
+      * \note_about_checking_solutions
+      *
+      * \note_about_arbitrary_choice_of_solution
+      *
+      * Example: \include HouseholderQR_solve.cpp
+      * Output: \verbinclude HouseholderQR_solve.out
+      */
+    template<typename Rhs>
+    inline const Solve<HouseholderQR, Rhs>
+    solve(const MatrixBase<Rhs>& b) const
+    {
+      eigen_assert(m_isInitialized && "HouseholderQR is not initialized.");
+      return Solve<HouseholderQR, Rhs>(*this, b.derived());
+    }
+
+    /** This method returns an expression of the unitary matrix Q as a sequence of Householder transformations.
+      *
+      * The returned expression can directly be used to perform matrix products. It can also be assigned to a dense Matrix object.
+      * Here is an example showing how to recover the full or thin matrix Q, as well as how to perform matrix products using operator*:
+      *
+      * Example: \include HouseholderQR_householderQ.cpp
+      * Output: \verbinclude HouseholderQR_householderQ.out
+      */
+    HouseholderSequenceType householderQ() const
+    {
+      eigen_assert(m_isInitialized && "HouseholderQR is not initialized.");
+      return HouseholderSequenceType(m_qr, m_hCoeffs.conjugate());
+    }
+
+    /** \returns a reference to the matrix where the Householder QR decomposition is stored
+      * in a LAPACK-compatible way.
+      */
+    const MatrixType& matrixQR() const
+    {
+        eigen_assert(m_isInitialized && "HouseholderQR is not initialized.");
+        return m_qr;
+    }
+
+    template<typename InputType>
+    HouseholderQR& compute(const EigenBase<InputType>& matrix) {
+      m_qr = matrix.derived();
+      computeInPlace();
+      return *this;
+    }
+
+    /** \returns the absolute value of the determinant of the matrix of which
+      * *this is the QR decomposition. It has only linear complexity
+      * (that is, O(n) where n is the dimension of the square matrix)
+      * as the QR decomposition has already been computed.
+      *
+      * \note This is only for square matrices.
+      *
+      * \warning a determinant can be very big or small, so for matrices
+      * of large enough dimension, there is a risk of overflow/underflow.
+      * One way to work around that is to use logAbsDeterminant() instead.
+      *
+      * \sa logAbsDeterminant(), MatrixBase::determinant()
+      */
+    typename MatrixType::RealScalar absDeterminant() const;
+
+    /** \returns the natural log of the absolute value of the determinant of the matrix of which
+      * *this is the QR decomposition. It has only linear complexity
+      * (that is, O(n) where n is the dimension of the square matrix)
+      * as the QR decomposition has already been computed.
+      *
+      * \note This is only for square matrices.
+      *
+      * \note This method is useful to work around the risk of overflow/underflow that's inherent
+      * to determinant computation.
+      *
+      * \sa absDeterminant(), MatrixBase::determinant()
+      */
+    typename MatrixType::RealScalar logAbsDeterminant() const;
+
+    inline Index rows() const { return m_qr.rows(); }
+    inline Index cols() const { return m_qr.cols(); }
+
+    /** \returns a const reference to the vector of Householder coefficients used to represent the factor \c Q.
+      * 
+      * For advanced uses only.
+      */
+    const HCoeffsType& hCoeffs() const { return m_hCoeffs; }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename RhsType, typename DstType>
+    void _solve_impl(const RhsType &rhs, DstType &dst) const;
+    #endif
+
+  protected:
+
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+    }
+
+    void computeInPlace();
+
+    MatrixType m_qr;
+    HCoeffsType m_hCoeffs;
+    RowVectorType m_temp;
+    bool m_isInitialized;
+};
+
+template<typename MatrixType>
+typename MatrixType::RealScalar HouseholderQR<MatrixType>::absDeterminant() const
+{
+  using std::abs;
+  eigen_assert(m_isInitialized && "HouseholderQR is not initialized.");
+  eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
+  return abs(m_qr.diagonal().prod());
+}
+
+template<typename MatrixType>
+typename MatrixType::RealScalar HouseholderQR<MatrixType>::logAbsDeterminant() const
+{
+  eigen_assert(m_isInitialized && "HouseholderQR is not initialized.");
+  eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
+  return m_qr.diagonal().cwiseAbs().array().log().sum();
+}
+
+namespace internal {
+
+/** \internal */
+template<typename MatrixQR, typename HCoeffs>
+void householder_qr_inplace_unblocked(MatrixQR& mat, HCoeffs& hCoeffs, typename MatrixQR::Scalar* tempData = 0)
+{
+  typedef typename MatrixQR::Scalar Scalar;
+  typedef typename MatrixQR::RealScalar RealScalar;
+  Index rows = mat.rows();
+  Index cols = mat.cols();
+  Index size = (std::min)(rows,cols);
+
+  eigen_assert(hCoeffs.size() == size);
+
+  typedef Matrix<Scalar,MatrixQR::ColsAtCompileTime,1> TempType;
+  TempType tempVector;
+  if(tempData==0)
+  {
+    tempVector.resize(cols);
+    tempData = tempVector.data();
+  }
+
+  for(Index k = 0; k < size; ++k)
+  {
+    Index remainingRows = rows - k;
+    Index remainingCols = cols - k - 1;
+
+    RealScalar beta;
+    mat.col(k).tail(remainingRows).makeHouseholderInPlace(hCoeffs.coeffRef(k), beta);
+    mat.coeffRef(k,k) = beta;
+
+    // apply H to remaining part of m_qr from the left
+    mat.bottomRightCorner(remainingRows, remainingCols)
+        .applyHouseholderOnTheLeft(mat.col(k).tail(remainingRows-1), hCoeffs.coeffRef(k), tempData+k+1);
+  }
+}
+
+/** \internal */
+template<typename MatrixQR, typename HCoeffs,
+  typename MatrixQRScalar = typename MatrixQR::Scalar,
+  bool InnerStrideIsOne = (MatrixQR::InnerStrideAtCompileTime == 1 && HCoeffs::InnerStrideAtCompileTime == 1)>
+struct householder_qr_inplace_blocked
+{
+  // This is specialized for MKL-supported Scalar types in HouseholderQR_MKL.h
+  static void run(MatrixQR& mat, HCoeffs& hCoeffs, Index maxBlockSize=32,
+      typename MatrixQR::Scalar* tempData = 0)
+  {
+    typedef typename MatrixQR::Scalar Scalar;
+    typedef Block<MatrixQR,Dynamic,Dynamic> BlockType;
+
+    Index rows = mat.rows();
+    Index cols = mat.cols();
+    Index size = (std::min)(rows, cols);
+
+    typedef Matrix<Scalar,Dynamic,1,ColMajor,MatrixQR::MaxColsAtCompileTime,1> TempType;
+    TempType tempVector;
+    if(tempData==0)
+    {
+      tempVector.resize(cols);
+      tempData = tempVector.data();
+    }
+
+    Index blockSize = (std::min)(maxBlockSize,size);
+
+    Index k = 0;
+    for (k = 0; k < size; k += blockSize)
+    {
+      Index bs = (std::min)(size-k,blockSize);  // actual size of the block
+      Index tcols = cols - k - bs;              // trailing columns
+      Index brows = rows-k;                     // rows of the block
+
+      // partition the matrix:
+      //        A00 | A01 | A02
+      // mat  = A10 | A11 | A12
+      //        A20 | A21 | A22
+      // and performs the qr dec of [A11^T A12^T]^T
+      // and update [A21^T A22^T]^T using level 3 operations.
+      // Finally, the algorithm continue on A22
+
+      BlockType A11_21 = mat.block(k,k,brows,bs);
+      Block<HCoeffs,Dynamic,1> hCoeffsSegment = hCoeffs.segment(k,bs);
+
+      householder_qr_inplace_unblocked(A11_21, hCoeffsSegment, tempData);
+
+      if(tcols)
+      {
+        BlockType A21_22 = mat.block(k,k+bs,brows,tcols);
+        apply_block_householder_on_the_left(A21_22,A11_21,hCoeffsSegment, false); // false == backward
+      }
+    }
+  }
+};
+
+} // end namespace internal
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename _MatrixType>
+template<typename RhsType, typename DstType>
+void HouseholderQR<_MatrixType>::_solve_impl(const RhsType &rhs, DstType &dst) const
+{
+  const Index rank = (std::min)(rows(), cols());
+  eigen_assert(rhs.rows() == rows());
+
+  typename RhsType::PlainObject c(rhs);
+
+  // Note that the matrix Q = H_0^* H_1^*... so its inverse is Q^* = (H_0 H_1 ...)^T
+  c.applyOnTheLeft(householderSequence(
+    m_qr.leftCols(rank),
+    m_hCoeffs.head(rank)).transpose()
+  );
+
+  m_qr.topLeftCorner(rank, rank)
+      .template triangularView<Upper>()
+      .solveInPlace(c.topRows(rank));
+
+  dst.topRows(rank) = c.topRows(rank);
+  dst.bottomRows(cols()-rank).setZero();
+}
+#endif
+
+/** Performs the QR factorization of the given matrix \a matrix. The result of
+  * the factorization is stored into \c *this, and a reference to \c *this
+  * is returned.
+  *
+  * \sa class HouseholderQR, HouseholderQR(const MatrixType&)
+  */
+template<typename MatrixType>
+void HouseholderQR<MatrixType>::computeInPlace()
+{
+  check_template_parameters();
+  
+  Index rows = m_qr.rows();
+  Index cols = m_qr.cols();
+  Index size = (std::min)(rows,cols);
+
+  m_hCoeffs.resize(size);
+
+  m_temp.resize(cols);
+
+  internal::householder_qr_inplace_blocked<MatrixType, HCoeffsType>::run(m_qr, m_hCoeffs, 48, m_temp.data());
+
+  m_isInitialized = true;
+}
+
+/** \return the Householder QR decomposition of \c *this.
+  *
+  * \sa class HouseholderQR
+  */
+template<typename Derived>
+const HouseholderQR<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::householderQr() const
+{
+  return HouseholderQR<PlainObject>(eval());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_QR_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/QR/HouseholderQR_LAPACKE.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/QR/HouseholderQR_LAPACKE.h
new file mode 100644
index 00000000..1dc7d536
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/QR/HouseholderQR_LAPACKE.h
@@ -0,0 +1,68 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to LAPACKe
+ *    Householder QR decomposition of a matrix w/o pivoting based on
+ *    LAPACKE_?geqrf function.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_QR_LAPACKE_H
+#define EIGEN_QR_LAPACKE_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/** \internal Specialization for the data types supported by LAPACKe */
+
+#define EIGEN_LAPACKE_QR_NOPIV(EIGTYPE, LAPACKE_TYPE, LAPACKE_PREFIX) \
+template<typename MatrixQR, typename HCoeffs> \
+struct householder_qr_inplace_blocked<MatrixQR, HCoeffs, EIGTYPE, true> \
+{ \
+  static void run(MatrixQR& mat, HCoeffs& hCoeffs, Index = 32, \
+      typename MatrixQR::Scalar* = 0) \
+  { \
+    lapack_int m = (lapack_int) mat.rows(); \
+    lapack_int n = (lapack_int) mat.cols(); \
+    lapack_int lda = (lapack_int) mat.outerStride(); \
+    lapack_int matrix_order = (MatrixQR::IsRowMajor) ? LAPACK_ROW_MAJOR : LAPACK_COL_MAJOR; \
+    LAPACKE_##LAPACKE_PREFIX##geqrf( matrix_order, m, n, (LAPACKE_TYPE*)mat.data(), lda, (LAPACKE_TYPE*)hCoeffs.data()); \
+    hCoeffs.adjointInPlace(); \
+  } \
+};
+
+EIGEN_LAPACKE_QR_NOPIV(double, double, d)
+EIGEN_LAPACKE_QR_NOPIV(float, float, s)
+EIGEN_LAPACKE_QR_NOPIV(dcomplex, lapack_complex_double, z)
+EIGEN_LAPACKE_QR_NOPIV(scomplex, lapack_complex_float, c)
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_QR_LAPACKE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SPQRSupport/SuiteSparseQRSupport.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SPQRSupport/SuiteSparseQRSupport.h
new file mode 100644
index 00000000..953d57c9
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SPQRSupport/SuiteSparseQRSupport.h
@@ -0,0 +1,313 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Desire Nuentsa <desire.nuentsa_wakam@inria.fr>
+// Copyright (C) 2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SUITESPARSEQRSUPPORT_H
+#define EIGEN_SUITESPARSEQRSUPPORT_H
+
+namespace Eigen {
+  
+  template<typename MatrixType> class SPQR; 
+  template<typename SPQRType> struct SPQRMatrixQReturnType; 
+  template<typename SPQRType> struct SPQRMatrixQTransposeReturnType; 
+  template <typename SPQRType, typename Derived> struct SPQR_QProduct;
+  namespace internal {
+    template <typename SPQRType> struct traits<SPQRMatrixQReturnType<SPQRType> >
+    {
+      typedef typename SPQRType::MatrixType ReturnType;
+    };
+    template <typename SPQRType> struct traits<SPQRMatrixQTransposeReturnType<SPQRType> >
+    {
+      typedef typename SPQRType::MatrixType ReturnType;
+    };
+    template <typename SPQRType, typename Derived> struct traits<SPQR_QProduct<SPQRType, Derived> >
+    {
+      typedef typename Derived::PlainObject ReturnType;
+    };
+  } // End namespace internal
+  
+/**
+  * \ingroup SPQRSupport_Module
+  * \class SPQR
+  * \brief Sparse QR factorization based on SuiteSparseQR library
+  *
+  * This class is used to perform a multithreaded and multifrontal rank-revealing QR decomposition
+  * of sparse matrices. The result is then used to solve linear leasts_square systems.
+  * Clearly, a QR factorization is returned such that A*P = Q*R where :
+  *
+  * P is the column permutation. Use colsPermutation() to get it.
+  *
+  * Q is the orthogonal matrix represented as Householder reflectors.
+  * Use matrixQ() to get an expression and matrixQ().transpose() to get the transpose.
+  * You can then apply it to a vector.
+  *
+  * R is the sparse triangular factor. Use matrixQR() to get it as SparseMatrix.
+  * NOTE : The Index type of R is always SuiteSparse_long. You can get it with SPQR::Index
+  *
+  * \tparam _MatrixType The type of the sparse matrix A, must be a column-major SparseMatrix<>
+  *
+  * \implsparsesolverconcept
+  *
+  *
+  */
+template<typename _MatrixType>
+class SPQR : public SparseSolverBase<SPQR<_MatrixType> >
+{
+  protected:
+    typedef SparseSolverBase<SPQR<_MatrixType> > Base;
+    using Base::m_isInitialized;
+  public:
+    typedef typename _MatrixType::Scalar Scalar;
+    typedef typename _MatrixType::RealScalar RealScalar;
+    typedef SuiteSparse_long StorageIndex ;
+    typedef SparseMatrix<Scalar, ColMajor, StorageIndex> MatrixType;
+    typedef Map<PermutationMatrix<Dynamic, Dynamic, StorageIndex> > PermutationType;
+    enum {
+      ColsAtCompileTime = Dynamic,
+      MaxColsAtCompileTime = Dynamic
+    };
+  public:
+    SPQR() 
+      : m_ordering(SPQR_ORDERING_DEFAULT), m_allow_tol(SPQR_DEFAULT_TOL), m_tolerance (NumTraits<Scalar>::epsilon()), m_useDefaultThreshold(true)
+    { 
+      cholmod_l_start(&m_cc);
+    }
+    
+    explicit SPQR(const _MatrixType& matrix)
+    : m_ordering(SPQR_ORDERING_DEFAULT), m_allow_tol(SPQR_DEFAULT_TOL), m_tolerance (NumTraits<Scalar>::epsilon()), m_useDefaultThreshold(true)
+    {
+      cholmod_l_start(&m_cc);
+      compute(matrix);
+    }
+    
+    ~SPQR()
+    {
+      SPQR_free();
+      cholmod_l_finish(&m_cc);
+    }
+    void SPQR_free()
+    {
+      cholmod_l_free_sparse(&m_H, &m_cc);
+      cholmod_l_free_sparse(&m_cR, &m_cc);
+      cholmod_l_free_dense(&m_HTau, &m_cc);
+      std::free(m_E);
+      std::free(m_HPinv);
+    }
+
+    void compute(const _MatrixType& matrix)
+    {
+      if(m_isInitialized) SPQR_free();
+
+      MatrixType mat(matrix);
+      
+      /* Compute the default threshold as in MatLab, see:
+       * Tim Davis, "Algorithm 915, SuiteSparseQR: Multifrontal Multithreaded Rank-Revealing
+       * Sparse QR Factorization, ACM Trans. on Math. Soft. 38(1), 2011, Page 8:3 
+       */
+      RealScalar pivotThreshold = m_tolerance;
+      if(m_useDefaultThreshold) 
+      {
+        RealScalar max2Norm = 0.0;
+        for (int j = 0; j < mat.cols(); j++) max2Norm = numext::maxi(max2Norm, mat.col(j).norm());
+        if(max2Norm==RealScalar(0))
+          max2Norm = RealScalar(1);
+        pivotThreshold = 20 * (mat.rows() + mat.cols()) * max2Norm * NumTraits<RealScalar>::epsilon();
+      }
+      cholmod_sparse A; 
+      A = viewAsCholmod(mat);
+      m_rows = matrix.rows();
+      Index col = matrix.cols();
+      m_rank = SuiteSparseQR<Scalar>(m_ordering, pivotThreshold, col, &A, 
+                             &m_cR, &m_E, &m_H, &m_HPinv, &m_HTau, &m_cc);
+
+      if (!m_cR)
+      {
+        m_info = NumericalIssue;
+        m_isInitialized = false;
+        return;
+      }
+      m_info = Success;
+      m_isInitialized = true;
+      m_isRUpToDate = false;
+    }
+    /** 
+     * Get the number of rows of the input matrix and the Q matrix
+     */
+    inline Index rows() const {return m_rows; }
+    
+    /** 
+     * Get the number of columns of the input matrix. 
+     */
+    inline Index cols() const { return m_cR->ncol; }
+    
+    template<typename Rhs, typename Dest>
+    void _solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &dest) const
+    {
+      eigen_assert(m_isInitialized && " The QR factorization should be computed first, call compute()");
+      eigen_assert(b.cols()==1 && "This method is for vectors only");
+
+      //Compute Q^T * b
+      typename Dest::PlainObject y, y2;
+      y = matrixQ().transpose() * b;
+      
+      // Solves with the triangular matrix R
+      Index rk = this->rank();
+      y2 = y;
+      y.resize((std::max)(cols(),Index(y.rows())),y.cols());
+      y.topRows(rk) = this->matrixR().topLeftCorner(rk, rk).template triangularView<Upper>().solve(y2.topRows(rk));
+
+      // Apply the column permutation 
+      // colsPermutation() performs a copy of the permutation,
+      // so let's apply it manually:
+      for(Index i = 0; i < rk; ++i) dest.row(m_E[i]) = y.row(i);
+      for(Index i = rk; i < cols(); ++i) dest.row(m_E[i]).setZero();
+      
+//       y.bottomRows(y.rows()-rk).setZero();
+//       dest = colsPermutation() * y.topRows(cols());
+      
+      m_info = Success;
+    }
+    
+    /** \returns the sparse triangular factor R. It is a sparse matrix
+     */
+    const MatrixType matrixR() const
+    {
+      eigen_assert(m_isInitialized && " The QR factorization should be computed first, call compute()");
+      if(!m_isRUpToDate) {
+        m_R = viewAsEigen<Scalar,ColMajor, typename MatrixType::StorageIndex>(*m_cR);
+        m_isRUpToDate = true;
+      }
+      return m_R;
+    }
+    /// Get an expression of the matrix Q
+    SPQRMatrixQReturnType<SPQR> matrixQ() const
+    {
+      return SPQRMatrixQReturnType<SPQR>(*this);
+    }
+    /// Get the permutation that was applied to columns of A
+    PermutationType colsPermutation() const
+    { 
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return PermutationType(m_E, m_cR->ncol);
+    }
+    /**
+     * Gets the rank of the matrix. 
+     * It should be equal to matrixQR().cols if the matrix is full-rank
+     */
+    Index rank() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_cc.SPQR_istat[4];
+    }
+    /// Set the fill-reducing ordering method to be used
+    void setSPQROrdering(int ord) { m_ordering = ord;}
+    /// Set the tolerance tol to treat columns with 2-norm < =tol as zero
+    void setPivotThreshold(const RealScalar& tol)
+    {
+      m_useDefaultThreshold = false;
+      m_tolerance = tol;
+    }
+    
+    /** \returns a pointer to the SPQR workspace */
+    cholmod_common *cholmodCommon() const { return &m_cc; }
+    
+    
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was succesful,
+      *          \c NumericalIssue if the sparse QR can not be computed
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_info;
+    }
+  protected:
+    bool m_analysisIsOk;
+    bool m_factorizationIsOk;
+    mutable bool m_isRUpToDate;
+    mutable ComputationInfo m_info;
+    int m_ordering; // Ordering method to use, see SPQR's manual
+    int m_allow_tol; // Allow to use some tolerance during numerical factorization.
+    RealScalar m_tolerance; // treat columns with 2-norm below this tolerance as zero
+    mutable cholmod_sparse *m_cR; // The sparse R factor in cholmod format
+    mutable MatrixType m_R; // The sparse matrix R in Eigen format
+    mutable StorageIndex *m_E; // The permutation applied to columns
+    mutable cholmod_sparse *m_H;  //The householder vectors
+    mutable StorageIndex *m_HPinv; // The row permutation of H
+    mutable cholmod_dense *m_HTau; // The Householder coefficients
+    mutable Index m_rank; // The rank of the matrix
+    mutable cholmod_common m_cc; // Workspace and parameters
+    bool m_useDefaultThreshold;     // Use default threshold
+    Index m_rows;
+    template<typename ,typename > friend struct SPQR_QProduct;
+};
+
+template <typename SPQRType, typename Derived>
+struct SPQR_QProduct : ReturnByValue<SPQR_QProduct<SPQRType,Derived> >
+{
+  typedef typename SPQRType::Scalar Scalar;
+  typedef typename SPQRType::StorageIndex StorageIndex;
+  //Define the constructor to get reference to argument types
+  SPQR_QProduct(const SPQRType& spqr, const Derived& other, bool transpose) : m_spqr(spqr),m_other(other),m_transpose(transpose) {}
+  
+  inline Index rows() const { return m_transpose ? m_spqr.rows() : m_spqr.cols(); }
+  inline Index cols() const { return m_other.cols(); }
+  // Assign to a vector
+  template<typename ResType>
+  void evalTo(ResType& res) const
+  {
+    cholmod_dense y_cd;
+    cholmod_dense *x_cd; 
+    int method = m_transpose ? SPQR_QTX : SPQR_QX; 
+    cholmod_common *cc = m_spqr.cholmodCommon();
+    y_cd = viewAsCholmod(m_other.const_cast_derived());
+    x_cd = SuiteSparseQR_qmult<Scalar>(method, m_spqr.m_H, m_spqr.m_HTau, m_spqr.m_HPinv, &y_cd, cc);
+    res = Matrix<Scalar,ResType::RowsAtCompileTime,ResType::ColsAtCompileTime>::Map(reinterpret_cast<Scalar*>(x_cd->x), x_cd->nrow, x_cd->ncol);
+    cholmod_l_free_dense(&x_cd, cc);
+  }
+  const SPQRType& m_spqr; 
+  const Derived& m_other; 
+  bool m_transpose; 
+  
+};
+template<typename SPQRType>
+struct SPQRMatrixQReturnType{
+  
+  SPQRMatrixQReturnType(const SPQRType& spqr) : m_spqr(spqr) {}
+  template<typename Derived>
+  SPQR_QProduct<SPQRType, Derived> operator*(const MatrixBase<Derived>& other)
+  {
+    return SPQR_QProduct<SPQRType,Derived>(m_spqr,other.derived(),false);
+  }
+  SPQRMatrixQTransposeReturnType<SPQRType> adjoint() const
+  {
+    return SPQRMatrixQTransposeReturnType<SPQRType>(m_spqr);
+  }
+  // To use for operations with the transpose of Q
+  SPQRMatrixQTransposeReturnType<SPQRType> transpose() const
+  {
+    return SPQRMatrixQTransposeReturnType<SPQRType>(m_spqr);
+  }
+  const SPQRType& m_spqr;
+};
+
+template<typename SPQRType>
+struct SPQRMatrixQTransposeReturnType{
+  SPQRMatrixQTransposeReturnType(const SPQRType& spqr) : m_spqr(spqr) {}
+  template<typename Derived>
+  SPQR_QProduct<SPQRType,Derived> operator*(const MatrixBase<Derived>& other)
+  {
+    return SPQR_QProduct<SPQRType,Derived>(m_spqr,other.derived(), true);
+  }
+  const SPQRType& m_spqr;
+};
+
+}// End namespace Eigen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SVD/BDCSVD.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SVD/BDCSVD.h
new file mode 100644
index 00000000..b8c41c56
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SVD/BDCSVD.h
@@ -0,0 +1,1231 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+// 
+// We used the "A Divide-And-Conquer Algorithm for the Bidiagonal SVD"
+// research report written by Ming Gu and Stanley C.Eisenstat
+// The code variable names correspond to the names they used in their 
+// report
+//
+// Copyright (C) 2013 Gauthier Brun <brun.gauthier@gmail.com>
+// Copyright (C) 2013 Nicolas Carre <nicolas.carre@ensimag.fr>
+// Copyright (C) 2013 Jean Ceccato <jean.ceccato@ensimag.fr>
+// Copyright (C) 2013 Pierre Zoppitelli <pierre.zoppitelli@ensimag.fr>
+// Copyright (C) 2013 Jitse Niesen <jitse@maths.leeds.ac.uk>
+// Copyright (C) 2014-2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_BDCSVD_H
+#define EIGEN_BDCSVD_H
+// #define EIGEN_BDCSVD_DEBUG_VERBOSE
+// #define EIGEN_BDCSVD_SANITY_CHECKS
+
+namespace Eigen {
+
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+IOFormat bdcsvdfmt(8, 0, ", ", "\n", "  [", "]");
+#endif
+  
+template<typename _MatrixType> class BDCSVD;
+
+namespace internal {
+
+template<typename _MatrixType> 
+struct traits<BDCSVD<_MatrixType> >
+{
+  typedef _MatrixType MatrixType;
+};  
+
+} // end namespace internal
+  
+  
+/** \ingroup SVD_Module
+ *
+ *
+ * \class BDCSVD
+ *
+ * \brief class Bidiagonal Divide and Conquer SVD
+ *
+ * \tparam _MatrixType the type of the matrix of which we are computing the SVD decomposition
+ *
+ * This class first reduces the input matrix to bi-diagonal form using class UpperBidiagonalization,
+ * and then performs a divide-and-conquer diagonalization. Small blocks are diagonalized using class JacobiSVD.
+ * You can control the switching size with the setSwitchSize() method, default is 16.
+ * For small matrice (<16), it is thus preferable to directly use JacobiSVD. For larger ones, BDCSVD is highly
+ * recommended and can several order of magnitude faster.
+ *
+ * \warning this algorithm is unlikely to provide accurate result when compiled with unsafe math optimizations.
+ * For instance, this concerns Intel's compiler (ICC), which perfroms such optimization by default unless
+ * you compile with the \c -fp-model \c precise option. Likewise, the \c -ffast-math option of GCC or clang will
+ * significantly degrade the accuracy.
+ *
+ * \sa class JacobiSVD
+ */
+template<typename _MatrixType> 
+class BDCSVD : public SVDBase<BDCSVD<_MatrixType> >
+{
+  typedef SVDBase<BDCSVD> Base;
+    
+public:
+  using Base::rows;
+  using Base::cols;
+  using Base::computeU;
+  using Base::computeV;
+  
+  typedef _MatrixType MatrixType;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
+  typedef typename NumTraits<RealScalar>::Literal Literal;
+  enum {
+    RowsAtCompileTime = MatrixType::RowsAtCompileTime, 
+    ColsAtCompileTime = MatrixType::ColsAtCompileTime, 
+    DiagSizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_DYNAMIC(RowsAtCompileTime, ColsAtCompileTime), 
+    MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime, 
+    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime, 
+    MaxDiagSizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED(MaxRowsAtCompileTime, MaxColsAtCompileTime), 
+    MatrixOptions = MatrixType::Options
+  };
+
+  typedef typename Base::MatrixUType MatrixUType;
+  typedef typename Base::MatrixVType MatrixVType;
+  typedef typename Base::SingularValuesType SingularValuesType;
+  
+  typedef Matrix<Scalar, Dynamic, Dynamic, ColMajor> MatrixX;
+  typedef Matrix<RealScalar, Dynamic, Dynamic, ColMajor> MatrixXr;
+  typedef Matrix<RealScalar, Dynamic, 1> VectorType;
+  typedef Array<RealScalar, Dynamic, 1> ArrayXr;
+  typedef Array<Index,1,Dynamic> ArrayXi;
+  typedef Ref<ArrayXr> ArrayRef;
+  typedef Ref<ArrayXi> IndicesRef;
+
+  /** \brief Default Constructor.
+   *
+   * The default constructor is useful in cases in which the user intends to
+   * perform decompositions via BDCSVD::compute(const MatrixType&).
+   */
+  BDCSVD() : m_algoswap(16), m_numIters(0)
+  {}
+
+
+  /** \brief Default Constructor with memory preallocation
+   *
+   * Like the default constructor but with preallocation of the internal data
+   * according to the specified problem size.
+   * \sa BDCSVD()
+   */
+  BDCSVD(Index rows, Index cols, unsigned int computationOptions = 0)
+    : m_algoswap(16), m_numIters(0)
+  {
+    allocate(rows, cols, computationOptions);
+  }
+
+  /** \brief Constructor performing the decomposition of given matrix.
+   *
+   * \param matrix the matrix to decompose
+   * \param computationOptions optional parameter allowing to specify if you want full or thin U or V unitaries to be computed.
+   *                           By default, none is computed. This is a bit - field, the possible bits are #ComputeFullU, #ComputeThinU, 
+   *                           #ComputeFullV, #ComputeThinV.
+   *
+   * Thin unitaries are only available if your matrix type has a Dynamic number of columns (for example MatrixXf). They also are not
+   * available with the (non - default) FullPivHouseholderQR preconditioner.
+   */
+  BDCSVD(const MatrixType& matrix, unsigned int computationOptions = 0)
+    : m_algoswap(16), m_numIters(0)
+  {
+    compute(matrix, computationOptions);
+  }
+
+  ~BDCSVD() 
+  {
+  }
+  
+  /** \brief Method performing the decomposition of given matrix using custom options.
+   *
+   * \param matrix the matrix to decompose
+   * \param computationOptions optional parameter allowing to specify if you want full or thin U or V unitaries to be computed.
+   *                           By default, none is computed. This is a bit - field, the possible bits are #ComputeFullU, #ComputeThinU, 
+   *                           #ComputeFullV, #ComputeThinV.
+   *
+   * Thin unitaries are only available if your matrix type has a Dynamic number of columns (for example MatrixXf). They also are not
+   * available with the (non - default) FullPivHouseholderQR preconditioner.
+   */
+  BDCSVD& compute(const MatrixType& matrix, unsigned int computationOptions);
+
+  /** \brief Method performing the decomposition of given matrix using current options.
+   *
+   * \param matrix the matrix to decompose
+   *
+   * This method uses the current \a computationOptions, as already passed to the constructor or to compute(const MatrixType&, unsigned int).
+   */
+  BDCSVD& compute(const MatrixType& matrix)
+  {
+    return compute(matrix, this->m_computationOptions);
+  }
+
+  void setSwitchSize(int s) 
+  {
+    eigen_assert(s>3 && "BDCSVD the size of the algo switch has to be greater than 3");
+    m_algoswap = s;
+  }
+ 
+private:
+  void allocate(Index rows, Index cols, unsigned int computationOptions);
+  void divide(Index firstCol, Index lastCol, Index firstRowW, Index firstColW, Index shift);
+  void computeSVDofM(Index firstCol, Index n, MatrixXr& U, VectorType& singVals, MatrixXr& V);
+  void computeSingVals(const ArrayRef& col0, const ArrayRef& diag, const IndicesRef& perm, VectorType& singVals, ArrayRef shifts, ArrayRef mus);
+  void perturbCol0(const ArrayRef& col0, const ArrayRef& diag, const IndicesRef& perm, const VectorType& singVals, const ArrayRef& shifts, const ArrayRef& mus, ArrayRef zhat);
+  void computeSingVecs(const ArrayRef& zhat, const ArrayRef& diag, const IndicesRef& perm, const VectorType& singVals, const ArrayRef& shifts, const ArrayRef& mus, MatrixXr& U, MatrixXr& V);
+  void deflation43(Index firstCol, Index shift, Index i, Index size);
+  void deflation44(Index firstColu , Index firstColm, Index firstRowW, Index firstColW, Index i, Index j, Index size);
+  void deflation(Index firstCol, Index lastCol, Index k, Index firstRowW, Index firstColW, Index shift);
+  template<typename HouseholderU, typename HouseholderV, typename NaiveU, typename NaiveV>
+  void copyUV(const HouseholderU &householderU, const HouseholderV &householderV, const NaiveU &naiveU, const NaiveV &naivev);
+  void structured_update(Block<MatrixXr,Dynamic,Dynamic> A, const MatrixXr &B, Index n1);
+  static RealScalar secularEq(RealScalar x, const ArrayRef& col0, const ArrayRef& diag, const IndicesRef &perm, const ArrayRef& diagShifted, RealScalar shift);
+
+protected:
+  MatrixXr m_naiveU, m_naiveV;
+  MatrixXr m_computed;
+  Index m_nRec;
+  ArrayXr m_workspace;
+  ArrayXi m_workspaceI;
+  int m_algoswap;
+  bool m_isTranspose, m_compU, m_compV;
+  
+  using Base::m_singularValues;
+  using Base::m_diagSize;
+  using Base::m_computeFullU;
+  using Base::m_computeFullV;
+  using Base::m_computeThinU;
+  using Base::m_computeThinV;
+  using Base::m_matrixU;
+  using Base::m_matrixV;
+  using Base::m_isInitialized;
+  using Base::m_nonzeroSingularValues;
+
+public:  
+  int m_numIters;
+}; //end class BDCSVD
+
+
+// Method to allocate and initialize matrix and attributes
+template<typename MatrixType>
+void BDCSVD<MatrixType>::allocate(Index rows, Index cols, unsigned int computationOptions)
+{
+  m_isTranspose = (cols > rows);
+
+  if (Base::allocate(rows, cols, computationOptions))
+    return;
+  
+  m_computed = MatrixXr::Zero(m_diagSize + 1, m_diagSize );
+  m_compU = computeV();
+  m_compV = computeU();
+  if (m_isTranspose)
+    std::swap(m_compU, m_compV);
+  
+  if (m_compU) m_naiveU = MatrixXr::Zero(m_diagSize + 1, m_diagSize + 1 );
+  else         m_naiveU = MatrixXr::Zero(2, m_diagSize + 1 );
+  
+  if (m_compV) m_naiveV = MatrixXr::Zero(m_diagSize, m_diagSize);
+  
+  m_workspace.resize((m_diagSize+1)*(m_diagSize+1)*3);
+  m_workspaceI.resize(3*m_diagSize);
+}// end allocate
+
+template<typename MatrixType>
+BDCSVD<MatrixType>& BDCSVD<MatrixType>::compute(const MatrixType& matrix, unsigned int computationOptions) 
+{
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+  std::cout << "\n\n\n======================================================================================================================\n\n\n";
+#endif
+  allocate(matrix.rows(), matrix.cols(), computationOptions);
+  using std::abs;
+
+  const RealScalar considerZero = (std::numeric_limits<RealScalar>::min)();
+  
+  //**** step -1 - If the problem is too small, directly falls back to JacobiSVD and return
+  if(matrix.cols() < m_algoswap)
+  {
+    // FIXME this line involves temporaries
+    JacobiSVD<MatrixType> jsvd(matrix,computationOptions);
+    if(computeU()) m_matrixU = jsvd.matrixU();
+    if(computeV()) m_matrixV = jsvd.matrixV();
+    m_singularValues = jsvd.singularValues();
+    m_nonzeroSingularValues = jsvd.nonzeroSingularValues();
+    m_isInitialized = true;
+    return *this;
+  }
+  
+  //**** step 0 - Copy the input matrix and apply scaling to reduce over/under-flows
+  RealScalar scale = matrix.cwiseAbs().maxCoeff();
+  if(scale==Literal(0)) scale = Literal(1);
+  MatrixX copy;
+  if (m_isTranspose) copy = matrix.adjoint()/scale;
+  else               copy = matrix/scale;
+  
+  //**** step 1 - Bidiagonalization
+  // FIXME this line involves temporaries
+  internal::UpperBidiagonalization<MatrixX> bid(copy);
+
+  //**** step 2 - Divide & Conquer
+  m_naiveU.setZero();
+  m_naiveV.setZero();
+  // FIXME this line involves a temporary matrix
+  m_computed.topRows(m_diagSize) = bid.bidiagonal().toDenseMatrix().transpose();
+  m_computed.template bottomRows<1>().setZero();
+  divide(0, m_diagSize - 1, 0, 0, 0);
+
+  //**** step 3 - Copy singular values and vectors
+  for (int i=0; i<m_diagSize; i++)
+  {
+    RealScalar a = abs(m_computed.coeff(i, i));
+    m_singularValues.coeffRef(i) = a * scale;
+    if (a<considerZero)
+    {
+      m_nonzeroSingularValues = i;
+      m_singularValues.tail(m_diagSize - i - 1).setZero();
+      break;
+    }
+    else if (i == m_diagSize - 1)
+    {
+      m_nonzeroSingularValues = i + 1;
+      break;
+    }
+  }
+
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+//   std::cout << "m_naiveU\n" << m_naiveU << "\n\n";
+//   std::cout << "m_naiveV\n" << m_naiveV << "\n\n";
+#endif
+  if(m_isTranspose) copyUV(bid.householderV(), bid.householderU(), m_naiveV, m_naiveU);
+  else              copyUV(bid.householderU(), bid.householderV(), m_naiveU, m_naiveV);
+
+  m_isInitialized = true;
+  return *this;
+}// end compute
+
+
+template<typename MatrixType>
+template<typename HouseholderU, typename HouseholderV, typename NaiveU, typename NaiveV>
+void BDCSVD<MatrixType>::copyUV(const HouseholderU &householderU, const HouseholderV &householderV, const NaiveU &naiveU, const NaiveV &naiveV)
+{
+  // Note exchange of U and V: m_matrixU is set from m_naiveV and vice versa
+  if (computeU())
+  {
+    Index Ucols = m_computeThinU ? m_diagSize : householderU.cols();
+    m_matrixU = MatrixX::Identity(householderU.cols(), Ucols);
+    m_matrixU.topLeftCorner(m_diagSize, m_diagSize) = naiveV.template cast<Scalar>().topLeftCorner(m_diagSize, m_diagSize);
+    householderU.applyThisOnTheLeft(m_matrixU); // FIXME this line involves a temporary buffer
+  }
+  if (computeV())
+  {
+    Index Vcols = m_computeThinV ? m_diagSize : householderV.cols();
+    m_matrixV = MatrixX::Identity(householderV.cols(), Vcols);
+    m_matrixV.topLeftCorner(m_diagSize, m_diagSize) = naiveU.template cast<Scalar>().topLeftCorner(m_diagSize, m_diagSize);
+    householderV.applyThisOnTheLeft(m_matrixV); // FIXME this line involves a temporary buffer
+  }
+}
+
+/** \internal
+  * Performs A = A * B exploiting the special structure of the matrix A. Splitting A as:
+  *  A = [A1]
+  *      [A2]
+  * such that A1.rows()==n1, then we assume that at least half of the columns of A1 and A2 are zeros.
+  * We can thus pack them prior to the the matrix product. However, this is only worth the effort if the matrix is large
+  * enough.
+  */
+template<typename MatrixType>
+void BDCSVD<MatrixType>::structured_update(Block<MatrixXr,Dynamic,Dynamic> A, const MatrixXr &B, Index n1)
+{
+  Index n = A.rows();
+  if(n>100)
+  {
+    // If the matrices are large enough, let's exploit the sparse structure of A by
+    // splitting it in half (wrt n1), and packing the non-zero columns.
+    Index n2 = n - n1;
+    Map<MatrixXr> A1(m_workspace.data()      , n1, n);
+    Map<MatrixXr> A2(m_workspace.data()+ n1*n, n2, n);
+    Map<MatrixXr> B1(m_workspace.data()+  n*n, n,  n);
+    Map<MatrixXr> B2(m_workspace.data()+2*n*n, n,  n);
+    Index k1=0, k2=0;
+    for(Index j=0; j<n; ++j)
+    {
+      if( (A.col(j).head(n1).array()!=Literal(0)).any() )
+      {
+        A1.col(k1) = A.col(j).head(n1);
+        B1.row(k1) = B.row(j);
+        ++k1;
+      }
+      if( (A.col(j).tail(n2).array()!=Literal(0)).any() )
+      {
+        A2.col(k2) = A.col(j).tail(n2);
+        B2.row(k2) = B.row(j);
+        ++k2;
+      }
+    }
+  
+    A.topRows(n1).noalias()    = A1.leftCols(k1) * B1.topRows(k1);
+    A.bottomRows(n2).noalias() = A2.leftCols(k2) * B2.topRows(k2);
+  }
+  else
+  {
+    Map<MatrixXr,Aligned> tmp(m_workspace.data(),n,n);
+    tmp.noalias() = A*B;
+    A = tmp;
+  }
+}
+
+// The divide algorithm is done "in place", we are always working on subsets of the same matrix. The divide methods takes as argument the 
+// place of the submatrix we are currently working on.
+
+//@param firstCol : The Index of the first column of the submatrix of m_computed and for m_naiveU;
+//@param lastCol : The Index of the last column of the submatrix of m_computed and for m_naiveU; 
+// lastCol + 1 - firstCol is the size of the submatrix.
+//@param firstRowW : The Index of the first row of the matrix W that we are to change. (see the reference paper section 1 for more information on W)
+//@param firstRowW : Same as firstRowW with the column.
+//@param shift : Each time one takes the left submatrix, one must add 1 to the shift. Why? Because! We actually want the last column of the U submatrix 
+// to become the first column (*coeff) and to shift all the other columns to the right. There are more details on the reference paper.
+template<typename MatrixType>
+void BDCSVD<MatrixType>::divide (Index firstCol, Index lastCol, Index firstRowW, Index firstColW, Index shift)
+{
+  // requires rows = cols + 1;
+  using std::pow;
+  using std::sqrt;
+  using std::abs;
+  const Index n = lastCol - firstCol + 1;
+  const Index k = n/2;
+  const RealScalar considerZero = (std::numeric_limits<RealScalar>::min)();
+  RealScalar alphaK;
+  RealScalar betaK; 
+  RealScalar r0; 
+  RealScalar lambda, phi, c0, s0;
+  VectorType l, f;
+  // We use the other algorithm which is more efficient for small 
+  // matrices.
+  if (n < m_algoswap)
+  {
+    // FIXME this line involves temporaries
+    JacobiSVD<MatrixXr> b(m_computed.block(firstCol, firstCol, n + 1, n), ComputeFullU | (m_compV ? ComputeFullV : 0));
+    if (m_compU)
+      m_naiveU.block(firstCol, firstCol, n + 1, n + 1).real() = b.matrixU();
+    else 
+    {
+      m_naiveU.row(0).segment(firstCol, n + 1).real() = b.matrixU().row(0);
+      m_naiveU.row(1).segment(firstCol, n + 1).real() = b.matrixU().row(n);
+    }
+    if (m_compV) m_naiveV.block(firstRowW, firstColW, n, n).real() = b.matrixV();
+    m_computed.block(firstCol + shift, firstCol + shift, n + 1, n).setZero();
+    m_computed.diagonal().segment(firstCol + shift, n) = b.singularValues().head(n);
+    return;
+  }
+  // We use the divide and conquer algorithm
+  alphaK =  m_computed(firstCol + k, firstCol + k);
+  betaK = m_computed(firstCol + k + 1, firstCol + k);
+  // The divide must be done in that order in order to have good results. Divide change the data inside the submatrices
+  // and the divide of the right submatrice reads one column of the left submatrice. That's why we need to treat the 
+  // right submatrix before the left one. 
+  divide(k + 1 + firstCol, lastCol, k + 1 + firstRowW, k + 1 + firstColW, shift);
+  divide(firstCol, k - 1 + firstCol, firstRowW, firstColW + 1, shift + 1);
+
+  if (m_compU)
+  {
+    lambda = m_naiveU(firstCol + k, firstCol + k);
+    phi = m_naiveU(firstCol + k + 1, lastCol + 1);
+  } 
+  else 
+  {
+    lambda = m_naiveU(1, firstCol + k);
+    phi = m_naiveU(0, lastCol + 1);
+  }
+  r0 = sqrt((abs(alphaK * lambda) * abs(alphaK * lambda)) + abs(betaK * phi) * abs(betaK * phi));
+  if (m_compU)
+  {
+    l = m_naiveU.row(firstCol + k).segment(firstCol, k);
+    f = m_naiveU.row(firstCol + k + 1).segment(firstCol + k + 1, n - k - 1);
+  } 
+  else 
+  {
+    l = m_naiveU.row(1).segment(firstCol, k);
+    f = m_naiveU.row(0).segment(firstCol + k + 1, n - k - 1);
+  }
+  if (m_compV) m_naiveV(firstRowW+k, firstColW) = Literal(1);
+  if (r0<considerZero)
+  {
+    c0 = Literal(1);
+    s0 = Literal(0);
+  }
+  else
+  {
+    c0 = alphaK * lambda / r0;
+    s0 = betaK * phi / r0;
+  }
+  
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  assert(m_naiveU.allFinite());
+  assert(m_naiveV.allFinite());
+  assert(m_computed.allFinite());
+#endif
+  
+  if (m_compU)
+  {
+    MatrixXr q1 (m_naiveU.col(firstCol + k).segment(firstCol, k + 1));     
+    // we shiftW Q1 to the right
+    for (Index i = firstCol + k - 1; i >= firstCol; i--) 
+      m_naiveU.col(i + 1).segment(firstCol, k + 1) = m_naiveU.col(i).segment(firstCol, k + 1);
+    // we shift q1 at the left with a factor c0
+    m_naiveU.col(firstCol).segment( firstCol, k + 1) = (q1 * c0);
+    // last column = q1 * - s0
+    m_naiveU.col(lastCol + 1).segment(firstCol, k + 1) = (q1 * ( - s0));
+    // first column = q2 * s0
+    m_naiveU.col(firstCol).segment(firstCol + k + 1, n - k) = m_naiveU.col(lastCol + 1).segment(firstCol + k + 1, n - k) * s0; 
+    // q2 *= c0
+    m_naiveU.col(lastCol + 1).segment(firstCol + k + 1, n - k) *= c0;
+  } 
+  else 
+  {
+    RealScalar q1 = m_naiveU(0, firstCol + k);
+    // we shift Q1 to the right
+    for (Index i = firstCol + k - 1; i >= firstCol; i--) 
+      m_naiveU(0, i + 1) = m_naiveU(0, i);
+    // we shift q1 at the left with a factor c0
+    m_naiveU(0, firstCol) = (q1 * c0);
+    // last column = q1 * - s0
+    m_naiveU(0, lastCol + 1) = (q1 * ( - s0));
+    // first column = q2 * s0
+    m_naiveU(1, firstCol) = m_naiveU(1, lastCol + 1) *s0; 
+    // q2 *= c0
+    m_naiveU(1, lastCol + 1) *= c0;
+    m_naiveU.row(1).segment(firstCol + 1, k).setZero();
+    m_naiveU.row(0).segment(firstCol + k + 1, n - k - 1).setZero();
+  }
+  
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  assert(m_naiveU.allFinite());
+  assert(m_naiveV.allFinite());
+  assert(m_computed.allFinite());
+#endif
+  
+  m_computed(firstCol + shift, firstCol + shift) = r0;
+  m_computed.col(firstCol + shift).segment(firstCol + shift + 1, k) = alphaK * l.transpose().real();
+  m_computed.col(firstCol + shift).segment(firstCol + shift + k + 1, n - k - 1) = betaK * f.transpose().real();
+
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+  ArrayXr tmp1 = (m_computed.block(firstCol+shift, firstCol+shift, n, n)).jacobiSvd().singularValues();
+#endif
+  // Second part: try to deflate singular values in combined matrix
+  deflation(firstCol, lastCol, k, firstRowW, firstColW, shift);
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+  ArrayXr tmp2 = (m_computed.block(firstCol+shift, firstCol+shift, n, n)).jacobiSvd().singularValues();
+  std::cout << "\n\nj1 = " << tmp1.transpose().format(bdcsvdfmt) << "\n";
+  std::cout << "j2 = " << tmp2.transpose().format(bdcsvdfmt) << "\n\n";
+  std::cout << "err:      " << ((tmp1-tmp2).abs()>1e-12*tmp2.abs()).transpose() << "\n";
+  static int count = 0;
+  std::cout << "# " << ++count << "\n\n";
+  assert((tmp1-tmp2).matrix().norm() < 1e-14*tmp2.matrix().norm());
+//   assert(count<681);
+//   assert(((tmp1-tmp2).abs()<1e-13*tmp2.abs()).all());
+#endif
+  
+  // Third part: compute SVD of combined matrix
+  MatrixXr UofSVD, VofSVD;
+  VectorType singVals;
+  computeSVDofM(firstCol + shift, n, UofSVD, singVals, VofSVD);
+  
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  assert(UofSVD.allFinite());
+  assert(VofSVD.allFinite());
+#endif
+  
+  if (m_compU)
+    structured_update(m_naiveU.block(firstCol, firstCol, n + 1, n + 1), UofSVD, (n+2)/2);
+  else
+  {
+    Map<Matrix<RealScalar,2,Dynamic>,Aligned> tmp(m_workspace.data(),2,n+1);
+    tmp.noalias() = m_naiveU.middleCols(firstCol, n+1) * UofSVD;
+    m_naiveU.middleCols(firstCol, n + 1) = tmp;
+  }
+  
+  if (m_compV)  structured_update(m_naiveV.block(firstRowW, firstColW, n, n), VofSVD, (n+1)/2);
+  
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  assert(m_naiveU.allFinite());
+  assert(m_naiveV.allFinite());
+  assert(m_computed.allFinite());
+#endif
+  
+  m_computed.block(firstCol + shift, firstCol + shift, n, n).setZero();
+  m_computed.block(firstCol + shift, firstCol + shift, n, n).diagonal() = singVals;
+}// end divide
+
+// Compute SVD of m_computed.block(firstCol, firstCol, n + 1, n); this block only has non-zeros in
+// the first column and on the diagonal and has undergone deflation, so diagonal is in increasing
+// order except for possibly the (0,0) entry. The computed SVD is stored U, singVals and V, except
+// that if m_compV is false, then V is not computed. Singular values are sorted in decreasing order.
+//
+// TODO Opportunities for optimization: better root finding algo, better stopping criterion, better
+// handling of round-off errors, be consistent in ordering
+// For instance, to solve the secular equation using FMM, see http://www.stat.uchicago.edu/~lekheng/courses/302/classics/greengard-rokhlin.pdf
+template <typename MatrixType>
+void BDCSVD<MatrixType>::computeSVDofM(Index firstCol, Index n, MatrixXr& U, VectorType& singVals, MatrixXr& V)
+{
+  const RealScalar considerZero = (std::numeric_limits<RealScalar>::min)();
+  using std::abs;
+  ArrayRef col0 = m_computed.col(firstCol).segment(firstCol, n);
+  m_workspace.head(n) =  m_computed.block(firstCol, firstCol, n, n).diagonal();
+  ArrayRef diag = m_workspace.head(n);
+  diag(0) = Literal(0);
+
+  // Allocate space for singular values and vectors
+  singVals.resize(n);
+  U.resize(n+1, n+1);
+  if (m_compV) V.resize(n, n);
+
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+  if (col0.hasNaN() || diag.hasNaN())
+    std::cout << "\n\nHAS NAN\n\n";
+#endif
+  
+  // Many singular values might have been deflated, the zero ones have been moved to the end,
+  // but others are interleaved and we must ignore them at this stage.
+  // To this end, let's compute a permutation skipping them:
+  Index actual_n = n;
+  while(actual_n>1 && diag(actual_n-1)==Literal(0)) --actual_n;
+  Index m = 0; // size of the deflated problem
+  for(Index k=0;k<actual_n;++k)
+    if(abs(col0(k))>considerZero)
+      m_workspaceI(m++) = k;
+  Map<ArrayXi> perm(m_workspaceI.data(),m);
+  
+  Map<ArrayXr> shifts(m_workspace.data()+1*n, n);
+  Map<ArrayXr> mus(m_workspace.data()+2*n, n);
+  Map<ArrayXr> zhat(m_workspace.data()+3*n, n);
+
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+  std::cout << "computeSVDofM using:\n";
+  std::cout << "  z: " << col0.transpose() << "\n";
+  std::cout << "  d: " << diag.transpose() << "\n";
+#endif
+  
+  // Compute singVals, shifts, and mus
+  computeSingVals(col0, diag, perm, singVals, shifts, mus);
+  
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+  std::cout << "  j:        " << (m_computed.block(firstCol, firstCol, n, n)).jacobiSvd().singularValues().transpose().reverse() << "\n\n";
+  std::cout << "  sing-val: " << singVals.transpose() << "\n";
+  std::cout << "  mu:       " << mus.transpose() << "\n";
+  std::cout << "  shift:    " << shifts.transpose() << "\n";
+  
+  {
+    Index actual_n = n;
+    while(actual_n>1 && abs(col0(actual_n-1))<considerZero) --actual_n;
+    std::cout << "\n\n    mus:    " << mus.head(actual_n).transpose() << "\n\n";
+    std::cout << "    check1 (expect0) : " << ((singVals.array()-(shifts+mus)) / singVals.array()).head(actual_n).transpose() << "\n\n";
+    std::cout << "    check2 (>0)      : " << ((singVals.array()-diag) / singVals.array()).head(actual_n).transpose() << "\n\n";
+    std::cout << "    check3 (>0)      : " << ((diag.segment(1,actual_n-1)-singVals.head(actual_n-1).array()) / singVals.head(actual_n-1).array()).transpose() << "\n\n\n";
+    std::cout << "    check4 (>0)      : " << ((singVals.segment(1,actual_n-1)-singVals.head(actual_n-1))).transpose() << "\n\n\n";
+  }
+#endif
+  
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  assert(singVals.allFinite());
+  assert(mus.allFinite());
+  assert(shifts.allFinite());
+#endif
+  
+  // Compute zhat
+  perturbCol0(col0, diag, perm, singVals, shifts, mus, zhat);
+#ifdef  EIGEN_BDCSVD_DEBUG_VERBOSE
+  std::cout << "  zhat: " << zhat.transpose() << "\n";
+#endif
+  
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  assert(zhat.allFinite());
+#endif
+  
+  computeSingVecs(zhat, diag, perm, singVals, shifts, mus, U, V);
+  
+#ifdef  EIGEN_BDCSVD_DEBUG_VERBOSE
+  std::cout << "U^T U: " << (U.transpose() * U - MatrixXr(MatrixXr::Identity(U.cols(),U.cols()))).norm() << "\n";
+  std::cout << "V^T V: " << (V.transpose() * V - MatrixXr(MatrixXr::Identity(V.cols(),V.cols()))).norm() << "\n";
+#endif
+  
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  assert(U.allFinite());
+  assert(V.allFinite());
+  assert((U.transpose() * U - MatrixXr(MatrixXr::Identity(U.cols(),U.cols()))).norm() < 1e-14 * n);
+  assert((V.transpose() * V - MatrixXr(MatrixXr::Identity(V.cols(),V.cols()))).norm() < 1e-14 * n);
+  assert(m_naiveU.allFinite());
+  assert(m_naiveV.allFinite());
+  assert(m_computed.allFinite());
+#endif
+  
+  // Because of deflation, the singular values might not be completely sorted.
+  // Fortunately, reordering them is a O(n) problem
+  for(Index i=0; i<actual_n-1; ++i)
+  {
+    if(singVals(i)>singVals(i+1))
+    {
+      using std::swap;
+      swap(singVals(i),singVals(i+1));
+      U.col(i).swap(U.col(i+1));
+      if(m_compV) V.col(i).swap(V.col(i+1));
+    }
+  }
+  
+  // Reverse order so that singular values in increased order
+  // Because of deflation, the zeros singular-values are already at the end
+  singVals.head(actual_n).reverseInPlace();
+  U.leftCols(actual_n).rowwise().reverseInPlace();
+  if (m_compV) V.leftCols(actual_n).rowwise().reverseInPlace();
+  
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+  JacobiSVD<MatrixXr> jsvd(m_computed.block(firstCol, firstCol, n, n) );
+  std::cout << "  * j:        " << jsvd.singularValues().transpose() << "\n\n";
+  std::cout << "  * sing-val: " << singVals.transpose() << "\n";
+//   std::cout << "  * err:      " << ((jsvd.singularValues()-singVals)>1e-13*singVals.norm()).transpose() << "\n";
+#endif
+}
+
+template <typename MatrixType>
+typename BDCSVD<MatrixType>::RealScalar BDCSVD<MatrixType>::secularEq(RealScalar mu, const ArrayRef& col0, const ArrayRef& diag, const IndicesRef &perm, const ArrayRef& diagShifted, RealScalar shift)
+{
+  Index m = perm.size();
+  RealScalar res = Literal(1);
+  for(Index i=0; i<m; ++i)
+  {
+    Index j = perm(i);
+    res += numext::abs2(col0(j)) / ((diagShifted(j) - mu) * (diag(j) + shift + mu));
+  }
+  return res;
+
+}
+
+template <typename MatrixType>
+void BDCSVD<MatrixType>::computeSingVals(const ArrayRef& col0, const ArrayRef& diag, const IndicesRef &perm,
+                                         VectorType& singVals, ArrayRef shifts, ArrayRef mus)
+{
+  using std::abs;
+  using std::swap;
+
+  Index n = col0.size();
+  Index actual_n = n;
+  while(actual_n>1 && col0(actual_n-1)==Literal(0)) --actual_n;
+
+  for (Index k = 0; k < n; ++k)
+  {
+    if (col0(k) == Literal(0) || actual_n==1)
+    {
+      // if col0(k) == 0, then entry is deflated, so singular value is on diagonal
+      // if actual_n==1, then the deflated problem is already diagonalized
+      singVals(k) = k==0 ? col0(0) : diag(k);
+      mus(k) = Literal(0);
+      shifts(k) = k==0 ? col0(0) : diag(k);
+      continue;
+    } 
+
+    // otherwise, use secular equation to find singular value
+    RealScalar left = diag(k);
+    RealScalar right; // was: = (k != actual_n-1) ? diag(k+1) : (diag(actual_n-1) + col0.matrix().norm());
+    if(k==actual_n-1)
+      right = (diag(actual_n-1) + col0.matrix().norm());
+    else
+    {
+      // Skip deflated singular values
+      Index l = k+1;
+      while(col0(l)==Literal(0)) { ++l; eigen_internal_assert(l<actual_n); }
+      right = diag(l);
+    }
+
+    // first decide whether it's closer to the left end or the right end
+    RealScalar mid = left + (right-left) / Literal(2);
+    RealScalar fMid = secularEq(mid, col0, diag, perm, diag, Literal(0));
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+    std::cout << right-left << "\n";
+    std::cout << "fMid = " << fMid << " " << secularEq(mid-left, col0, diag, perm, diag-left, left) << " " << secularEq(mid-right, col0, diag, perm, diag-right, right)   << "\n";
+    std::cout << "     = " << secularEq(0.1*(left+right), col0, diag, perm, diag, 0)
+              << " "       << secularEq(0.2*(left+right), col0, diag, perm, diag, 0)
+              << " "       << secularEq(0.3*(left+right), col0, diag, perm, diag, 0)
+              << " "       << secularEq(0.4*(left+right), col0, diag, perm, diag, 0)
+              << " "       << secularEq(0.49*(left+right), col0, diag, perm, diag, 0)
+              << " "       << secularEq(0.5*(left+right), col0, diag, perm, diag, 0)
+              << " "       << secularEq(0.51*(left+right), col0, diag, perm, diag, 0)
+              << " "       << secularEq(0.6*(left+right), col0, diag, perm, diag, 0)
+              << " "       << secularEq(0.7*(left+right), col0, diag, perm, diag, 0)
+              << " "       << secularEq(0.8*(left+right), col0, diag, perm, diag, 0)
+              << " "       << secularEq(0.9*(left+right), col0, diag, perm, diag, 0) << "\n";
+#endif
+    RealScalar shift = (k == actual_n-1 || fMid > Literal(0)) ? left : right;
+    
+    // measure everything relative to shift
+    Map<ArrayXr> diagShifted(m_workspace.data()+4*n, n);
+    diagShifted = diag - shift;
+    
+    // initial guess
+    RealScalar muPrev, muCur;
+    if (shift == left)
+    {
+      muPrev = (right - left) * RealScalar(0.1);
+      if (k == actual_n-1) muCur = right - left;
+      else                 muCur = (right - left) * RealScalar(0.5);
+    }
+    else
+    {
+      muPrev = -(right - left) * RealScalar(0.1);
+      muCur = -(right - left) * RealScalar(0.5);
+    }
+
+    RealScalar fPrev = secularEq(muPrev, col0, diag, perm, diagShifted, shift);
+    RealScalar fCur = secularEq(muCur, col0, diag, perm, diagShifted, shift);
+    if (abs(fPrev) < abs(fCur))
+    {
+      swap(fPrev, fCur);
+      swap(muPrev, muCur);
+    }
+
+    // rational interpolation: fit a function of the form a / mu + b through the two previous
+    // iterates and use its zero to compute the next iterate
+    bool useBisection = fPrev*fCur>Literal(0);
+    while (fCur!=Literal(0) && abs(muCur - muPrev) > Literal(8) * NumTraits<RealScalar>::epsilon() * numext::maxi<RealScalar>(abs(muCur), abs(muPrev)) && abs(fCur - fPrev)>NumTraits<RealScalar>::epsilon() && !useBisection)
+    {
+      ++m_numIters;
+
+      // Find a and b such that the function f(mu) = a / mu + b matches the current and previous samples.
+      RealScalar a = (fCur - fPrev) / (Literal(1)/muCur - Literal(1)/muPrev);
+      RealScalar b = fCur - a / muCur;
+      // And find mu such that f(mu)==0:
+      RealScalar muZero = -a/b;
+      RealScalar fZero = secularEq(muZero, col0, diag, perm, diagShifted, shift);
+      
+      muPrev = muCur;
+      fPrev = fCur;
+      muCur = muZero;
+      fCur = fZero;
+      
+      
+      if (shift == left  && (muCur < Literal(0) || muCur > right - left)) useBisection = true;
+      if (shift == right && (muCur < -(right - left) || muCur > Literal(0))) useBisection = true;
+      if (abs(fCur)>abs(fPrev)) useBisection = true;
+    }
+
+    // fall back on bisection method if rational interpolation did not work
+    if (useBisection)
+    {
+#ifdef  EIGEN_BDCSVD_DEBUG_VERBOSE
+      std::cout << "useBisection for k = " << k << ", actual_n = " << actual_n << "\n";
+#endif
+      RealScalar leftShifted, rightShifted;
+      if (shift == left)
+      {
+        leftShifted = (std::numeric_limits<RealScalar>::min)();
+        // I don't understand why the case k==0 would be special there:
+        // if (k == 0) rightShifted = right - left; else 
+        rightShifted = (k==actual_n-1) ? right : ((right - left) * RealScalar(0.6)); // theoretically we can take 0.5, but let's be safe
+      }
+      else
+      {
+        leftShifted = -(right - left) * RealScalar(0.6);
+        rightShifted = -(std::numeric_limits<RealScalar>::min)();
+      }
+      
+      RealScalar fLeft = secularEq(leftShifted, col0, diag, perm, diagShifted, shift);
+
+#if defined EIGEN_INTERNAL_DEBUGGING || defined EIGEN_BDCSVD_DEBUG_VERBOSE
+      RealScalar fRight = secularEq(rightShifted, col0, diag, perm, diagShifted, shift);
+#endif
+
+#ifdef  EIGEN_BDCSVD_DEBUG_VERBOSE
+      if(!(fLeft * fRight<0))
+      {
+        std::cout << "fLeft: " << leftShifted << " - " << diagShifted.head(10).transpose()  << "\n ; " << bool(left==shift) << " " << (left-shift) << "\n";
+        std::cout << k << " : " <<  fLeft << " * " << fRight << " == " << fLeft * fRight << "  ;  " << left << " - " << right << " -> " <<  leftShifted << " " << rightShifted << "   shift=" << shift << "\n";
+      }
+#endif
+      eigen_internal_assert(fLeft * fRight < Literal(0));
+      
+      while (rightShifted - leftShifted > Literal(2) * NumTraits<RealScalar>::epsilon() * numext::maxi<RealScalar>(abs(leftShifted), abs(rightShifted)))
+      {
+        RealScalar midShifted = (leftShifted + rightShifted) / Literal(2);
+        fMid = secularEq(midShifted, col0, diag, perm, diagShifted, shift);
+        if (fLeft * fMid < Literal(0))
+        {
+          rightShifted = midShifted;
+        }
+        else
+        {
+          leftShifted = midShifted;
+          fLeft = fMid;
+        }
+      }
+
+      muCur = (leftShifted + rightShifted) / Literal(2);
+    }
+      
+    singVals[k] = shift + muCur;
+    shifts[k] = shift;
+    mus[k] = muCur;
+
+    // perturb singular value slightly if it equals diagonal entry to avoid division by zero later
+    // (deflation is supposed to avoid this from happening)
+    // - this does no seem to be necessary anymore -
+//     if (singVals[k] == left) singVals[k] *= 1 + NumTraits<RealScalar>::epsilon();
+//     if (singVals[k] == right) singVals[k] *= 1 - NumTraits<RealScalar>::epsilon();
+  }
+}
+
+
+// zhat is perturbation of col0 for which singular vectors can be computed stably (see Section 3.1)
+template <typename MatrixType>
+void BDCSVD<MatrixType>::perturbCol0
+   (const ArrayRef& col0, const ArrayRef& diag, const IndicesRef &perm, const VectorType& singVals,
+    const ArrayRef& shifts, const ArrayRef& mus, ArrayRef zhat)
+{
+  using std::sqrt;
+  Index n = col0.size();
+  Index m = perm.size();
+  if(m==0)
+  {
+    zhat.setZero();
+    return;
+  }
+  Index last = perm(m-1);
+  // The offset permits to skip deflated entries while computing zhat
+  for (Index k = 0; k < n; ++k)
+  {
+    if (col0(k) == Literal(0)) // deflated
+      zhat(k) = Literal(0);
+    else
+    {
+      // see equation (3.6)
+      RealScalar dk = diag(k);
+      RealScalar prod = (singVals(last) + dk) * (mus(last) + (shifts(last) - dk));
+
+      for(Index l = 0; l<m; ++l)
+      {
+        Index i = perm(l);
+        if(i!=k)
+        {
+          Index j = i<k ? i : perm(l-1);
+          prod *= ((singVals(j)+dk) / ((diag(i)+dk))) * ((mus(j)+(shifts(j)-dk)) / ((diag(i)-dk)));
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+          if(i!=k && std::abs(((singVals(j)+dk)*(mus(j)+(shifts(j)-dk)))/((diag(i)+dk)*(diag(i)-dk)) - 1) > 0.9 )
+            std::cout << "     " << ((singVals(j)+dk)*(mus(j)+(shifts(j)-dk)))/((diag(i)+dk)*(diag(i)-dk)) << " == (" << (singVals(j)+dk) << " * " << (mus(j)+(shifts(j)-dk))
+                       << ") / (" << (diag(i)+dk) << " * " << (diag(i)-dk) << ")\n";
+#endif
+        }
+      }
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+      std::cout << "zhat(" << k << ") =  sqrt( " << prod << ")  ;  " << (singVals(last) + dk) << " * " << mus(last) + shifts(last) << " - " << dk << "\n";
+#endif
+      RealScalar tmp = sqrt(prod);
+      zhat(k) = col0(k) > Literal(0) ? tmp : -tmp;
+    }
+  }
+}
+
+// compute singular vectors
+template <typename MatrixType>
+void BDCSVD<MatrixType>::computeSingVecs
+   (const ArrayRef& zhat, const ArrayRef& diag, const IndicesRef &perm, const VectorType& singVals,
+    const ArrayRef& shifts, const ArrayRef& mus, MatrixXr& U, MatrixXr& V)
+{
+  Index n = zhat.size();
+  Index m = perm.size();
+  
+  for (Index k = 0; k < n; ++k)
+  {
+    if (zhat(k) == Literal(0))
+    {
+      U.col(k) = VectorType::Unit(n+1, k);
+      if (m_compV) V.col(k) = VectorType::Unit(n, k);
+    }
+    else
+    {
+      U.col(k).setZero();
+      for(Index l=0;l<m;++l)
+      {
+        Index i = perm(l);
+        U(i,k) = zhat(i)/(((diag(i) - shifts(k)) - mus(k)) )/( (diag(i) + singVals[k]));
+      }
+      U(n,k) = Literal(0);
+      U.col(k).normalize();
+    
+      if (m_compV)
+      {
+        V.col(k).setZero();
+        for(Index l=1;l<m;++l)
+        {
+          Index i = perm(l);
+          V(i,k) = diag(i) * zhat(i) / (((diag(i) - shifts(k)) - mus(k)) )/( (diag(i) + singVals[k]));
+        }
+        V(0,k) = Literal(-1);
+        V.col(k).normalize();
+      }
+    }
+  }
+  U.col(n) = VectorType::Unit(n+1, n);
+}
+
+
+// page 12_13
+// i >= 1, di almost null and zi non null.
+// We use a rotation to zero out zi applied to the left of M
+template <typename MatrixType>
+void BDCSVD<MatrixType>::deflation43(Index firstCol, Index shift, Index i, Index size)
+{
+  using std::abs;
+  using std::sqrt;
+  using std::pow;
+  Index start = firstCol + shift;
+  RealScalar c = m_computed(start, start);
+  RealScalar s = m_computed(start+i, start);
+  RealScalar r = sqrt(numext::abs2(c) + numext::abs2(s));
+  if (r == Literal(0))
+  {
+    m_computed(start+i, start+i) = Literal(0);
+    return;
+  }
+  m_computed(start,start) = r;  
+  m_computed(start+i, start) = Literal(0);
+  m_computed(start+i, start+i) = Literal(0);
+  
+  JacobiRotation<RealScalar> J(c/r,-s/r);
+  if (m_compU)  m_naiveU.middleRows(firstCol, size+1).applyOnTheRight(firstCol, firstCol+i, J);
+  else          m_naiveU.applyOnTheRight(firstCol, firstCol+i, J);
+}// end deflation 43
+
+
+// page 13
+// i,j >= 1, i!=j and |di - dj| < epsilon * norm2(M)
+// We apply two rotations to have zj = 0;
+// TODO deflation44 is still broken and not properly tested
+template <typename MatrixType>
+void BDCSVD<MatrixType>::deflation44(Index firstColu , Index firstColm, Index firstRowW, Index firstColW, Index i, Index j, Index size)
+{
+  using std::abs;
+  using std::sqrt;
+  using std::conj;
+  using std::pow;
+  RealScalar c = m_computed(firstColm+i, firstColm);
+  RealScalar s = m_computed(firstColm+j, firstColm);
+  RealScalar r = sqrt(numext::abs2(c) + numext::abs2(s));
+#ifdef  EIGEN_BDCSVD_DEBUG_VERBOSE
+  std::cout << "deflation 4.4: " << i << "," << j << " -> " << c << " " << s << " " << r << " ; "
+    << m_computed(firstColm + i-1, firstColm)  << " "
+    << m_computed(firstColm + i, firstColm)  << " "
+    << m_computed(firstColm + i+1, firstColm) << " "
+    << m_computed(firstColm + i+2, firstColm) << "\n";
+  std::cout << m_computed(firstColm + i-1, firstColm + i-1)  << " "
+    << m_computed(firstColm + i, firstColm+i)  << " "
+    << m_computed(firstColm + i+1, firstColm+i+1) << " "
+    << m_computed(firstColm + i+2, firstColm+i+2) << "\n";
+#endif
+  if (r==Literal(0))
+  {
+    m_computed(firstColm + i, firstColm + i) = m_computed(firstColm + j, firstColm + j);
+    return;
+  }
+  c/=r;
+  s/=r;
+  m_computed(firstColm + i, firstColm) = r;  
+  m_computed(firstColm + j, firstColm + j) = m_computed(firstColm + i, firstColm + i);
+  m_computed(firstColm + j, firstColm) = Literal(0);
+
+  JacobiRotation<RealScalar> J(c,-s);
+  if (m_compU)  m_naiveU.middleRows(firstColu, size+1).applyOnTheRight(firstColu + i, firstColu + j, J);
+  else          m_naiveU.applyOnTheRight(firstColu+i, firstColu+j, J);
+  if (m_compV)  m_naiveV.middleRows(firstRowW, size).applyOnTheRight(firstColW + i, firstColW + j, J);
+}// end deflation 44
+
+
+// acts on block from (firstCol+shift, firstCol+shift) to (lastCol+shift, lastCol+shift) [inclusive]
+template <typename MatrixType>
+void BDCSVD<MatrixType>::deflation(Index firstCol, Index lastCol, Index k, Index firstRowW, Index firstColW, Index shift)
+{
+  using std::sqrt;
+  using std::abs;
+  const Index length = lastCol + 1 - firstCol;
+  
+  Block<MatrixXr,Dynamic,1> col0(m_computed, firstCol+shift, firstCol+shift, length, 1);
+  Diagonal<MatrixXr> fulldiag(m_computed);
+  VectorBlock<Diagonal<MatrixXr>,Dynamic> diag(fulldiag, firstCol+shift, length);
+  
+  const RealScalar considerZero = (std::numeric_limits<RealScalar>::min)();
+  RealScalar maxDiag = diag.tail((std::max)(Index(1),length-1)).cwiseAbs().maxCoeff();
+  RealScalar epsilon_strict = numext::maxi<RealScalar>(considerZero,NumTraits<RealScalar>::epsilon() * maxDiag);
+  RealScalar epsilon_coarse = Literal(8) * NumTraits<RealScalar>::epsilon() * numext::maxi<RealScalar>(col0.cwiseAbs().maxCoeff(), maxDiag);
+  
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  assert(m_naiveU.allFinite());
+  assert(m_naiveV.allFinite());
+  assert(m_computed.allFinite());
+#endif
+
+#ifdef  EIGEN_BDCSVD_DEBUG_VERBOSE  
+  std::cout << "\ndeflate:" << diag.head(k+1).transpose() << "  |  " << diag.segment(k+1,length-k-1).transpose() << "\n";
+#endif
+  
+  //condition 4.1
+  if (diag(0) < epsilon_coarse)
+  { 
+#ifdef  EIGEN_BDCSVD_DEBUG_VERBOSE
+    std::cout << "deflation 4.1, because " << diag(0) << " < " << epsilon_coarse << "\n";
+#endif
+    diag(0) = epsilon_coarse;
+  }
+
+  //condition 4.2
+  for (Index i=1;i<length;++i)
+    if (abs(col0(i)) < epsilon_strict)
+    {
+#ifdef  EIGEN_BDCSVD_DEBUG_VERBOSE
+      std::cout << "deflation 4.2, set z(" << i << ") to zero because " << abs(col0(i)) << " < " << epsilon_strict << "  (diag(" << i << ")=" << diag(i) << ")\n";
+#endif
+      col0(i) = Literal(0);
+    }
+
+  //condition 4.3
+  for (Index i=1;i<length; i++)
+    if (diag(i) < epsilon_coarse)
+    {
+#ifdef  EIGEN_BDCSVD_DEBUG_VERBOSE
+      std::cout << "deflation 4.3, cancel z(" << i << ")=" << col0(i) << " because diag(" << i << ")=" << diag(i) << " < " << epsilon_coarse << "\n";
+#endif
+      deflation43(firstCol, shift, i, length);
+    }
+
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  assert(m_naiveU.allFinite());
+  assert(m_naiveV.allFinite());
+  assert(m_computed.allFinite());
+#endif
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+  std::cout << "to be sorted: " << diag.transpose() << "\n\n";
+#endif
+  {
+    // Check for total deflation
+    // If we have a total deflation, then we have to consider col0(0)==diag(0) as a singular value during sorting
+    bool total_deflation = (col0.tail(length-1).array()<considerZero).all();
+    
+    // Sort the diagonal entries, since diag(1:k-1) and diag(k:length) are already sorted, let's do a sorted merge.
+    // First, compute the respective permutation.
+    Index *permutation = m_workspaceI.data();
+    {
+      permutation[0] = 0;
+      Index p = 1;
+      
+      // Move deflated diagonal entries at the end.
+      for(Index i=1; i<length; ++i)
+        if(abs(diag(i))<considerZero)
+          permutation[p++] = i;
+        
+      Index i=1, j=k+1;
+      for( ; p < length; ++p)
+      {
+             if (i > k)             permutation[p] = j++;
+        else if (j >= length)       permutation[p] = i++;
+        else if (diag(i) < diag(j)) permutation[p] = j++;
+        else                        permutation[p] = i++;
+      }
+    }
+    
+    // If we have a total deflation, then we have to insert diag(0) at the right place
+    if(total_deflation)
+    {
+      for(Index i=1; i<length; ++i)
+      {
+        Index pi = permutation[i];
+        if(abs(diag(pi))<considerZero || diag(0)<diag(pi))
+          permutation[i-1] = permutation[i];
+        else
+        {
+          permutation[i-1] = 0;
+          break;
+        }
+      }
+    }
+    
+    // Current index of each col, and current column of each index
+    Index *realInd = m_workspaceI.data()+length;
+    Index *realCol = m_workspaceI.data()+2*length;
+    
+    for(int pos = 0; pos< length; pos++)
+    {
+      realCol[pos] = pos;
+      realInd[pos] = pos;
+    }
+    
+    for(Index i = total_deflation?0:1; i < length; i++)
+    {
+      const Index pi = permutation[length - (total_deflation ? i+1 : i)];
+      const Index J = realCol[pi];
+      
+      using std::swap;
+      // swap diagonal and first column entries:
+      swap(diag(i), diag(J));
+      if(i!=0 && J!=0) swap(col0(i), col0(J));
+
+      // change columns
+      if (m_compU) m_naiveU.col(firstCol+i).segment(firstCol, length + 1).swap(m_naiveU.col(firstCol+J).segment(firstCol, length + 1));
+      else         m_naiveU.col(firstCol+i).segment(0, 2)                .swap(m_naiveU.col(firstCol+J).segment(0, 2));
+      if (m_compV) m_naiveV.col(firstColW + i).segment(firstRowW, length).swap(m_naiveV.col(firstColW + J).segment(firstRowW, length));
+
+      //update real pos
+      const Index realI = realInd[i];
+      realCol[realI] = J;
+      realCol[pi] = i;
+      realInd[J] = realI;
+      realInd[i] = pi;
+    }
+  }
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+  std::cout << "sorted: " << diag.transpose().format(bdcsvdfmt) << "\n";
+  std::cout << "      : " << col0.transpose() << "\n\n";
+#endif
+    
+  //condition 4.4
+  {
+    Index i = length-1;
+    while(i>0 && (abs(diag(i))<considerZero || abs(col0(i))<considerZero)) --i;
+    for(; i>1;--i)
+       if( (diag(i) - diag(i-1)) < NumTraits<RealScalar>::epsilon()*maxDiag )
+      {
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+        std::cout << "deflation 4.4 with i = " << i << " because " << (diag(i) - diag(i-1)) << " < " << NumTraits<RealScalar>::epsilon()*diag(i) << "\n";
+#endif
+        eigen_internal_assert(abs(diag(i) - diag(i-1))<epsilon_coarse && " diagonal entries are not properly sorted");
+        deflation44(firstCol, firstCol + shift, firstRowW, firstColW, i-1, i, length);
+      }
+  }
+  
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  for(Index j=2;j<length;++j)
+    assert(diag(j-1)<=diag(j) || abs(diag(j))<considerZero);
+#endif
+  
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  assert(m_naiveU.allFinite());
+  assert(m_naiveV.allFinite());
+  assert(m_computed.allFinite());
+#endif
+}//end deflation
+
+#ifndef EIGEN_CUDACC
+/** \svd_module
+  *
+  * \return the singular value decomposition of \c *this computed by Divide & Conquer algorithm
+  *
+  * \sa class BDCSVD
+  */
+template<typename Derived>
+BDCSVD<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::bdcSvd(unsigned int computationOptions) const
+{
+  return BDCSVD<PlainObject>(*this, computationOptions);
+}
+#endif
+
+} // end namespace Eigen
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SVD/JacobiSVD.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SVD/JacobiSVD.h
new file mode 100644
index 00000000..43488b1e
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SVD/JacobiSVD.h
@@ -0,0 +1,804 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2013-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_JACOBISVD_H
+#define EIGEN_JACOBISVD_H
+
+namespace Eigen { 
+
+namespace internal {
+// forward declaration (needed by ICC)
+// the empty body is required by MSVC
+template<typename MatrixType, int QRPreconditioner,
+         bool IsComplex = NumTraits<typename MatrixType::Scalar>::IsComplex>
+struct svd_precondition_2x2_block_to_be_real {};
+
+/*** QR preconditioners (R-SVD)
+ ***
+ *** Their role is to reduce the problem of computing the SVD to the case of a square matrix.
+ *** This approach, known as R-SVD, is an optimization for rectangular-enough matrices, and is a requirement for
+ *** JacobiSVD which by itself is only able to work on square matrices.
+ ***/
+
+enum { PreconditionIfMoreColsThanRows, PreconditionIfMoreRowsThanCols };
+
+template<typename MatrixType, int QRPreconditioner, int Case>
+struct qr_preconditioner_should_do_anything
+{
+  enum { a = MatrixType::RowsAtCompileTime != Dynamic &&
+             MatrixType::ColsAtCompileTime != Dynamic &&
+             MatrixType::ColsAtCompileTime <= MatrixType::RowsAtCompileTime,
+         b = MatrixType::RowsAtCompileTime != Dynamic &&
+             MatrixType::ColsAtCompileTime != Dynamic &&
+             MatrixType::RowsAtCompileTime <= MatrixType::ColsAtCompileTime,
+         ret = !( (QRPreconditioner == NoQRPreconditioner) ||
+                  (Case == PreconditionIfMoreColsThanRows && bool(a)) ||
+                  (Case == PreconditionIfMoreRowsThanCols && bool(b)) )
+  };
+};
+
+template<typename MatrixType, int QRPreconditioner, int Case,
+         bool DoAnything = qr_preconditioner_should_do_anything<MatrixType, QRPreconditioner, Case>::ret
+> struct qr_preconditioner_impl {};
+
+template<typename MatrixType, int QRPreconditioner, int Case>
+class qr_preconditioner_impl<MatrixType, QRPreconditioner, Case, false>
+{
+public:
+  void allocate(const JacobiSVD<MatrixType, QRPreconditioner>&) {}
+  bool run(JacobiSVD<MatrixType, QRPreconditioner>&, const MatrixType&)
+  {
+    return false;
+  }
+};
+
+/*** preconditioner using FullPivHouseholderQR ***/
+
+template<typename MatrixType>
+class qr_preconditioner_impl<MatrixType, FullPivHouseholderQRPreconditioner, PreconditionIfMoreRowsThanCols, true>
+{
+public:
+  typedef typename MatrixType::Scalar Scalar;
+  enum
+  {
+    RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+    MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime
+  };
+  typedef Matrix<Scalar, 1, RowsAtCompileTime, RowMajor, 1, MaxRowsAtCompileTime> WorkspaceType;
+
+  void allocate(const JacobiSVD<MatrixType, FullPivHouseholderQRPreconditioner>& svd)
+  {
+    if (svd.rows() != m_qr.rows() || svd.cols() != m_qr.cols())
+    {
+      m_qr.~QRType();
+      ::new (&m_qr) QRType(svd.rows(), svd.cols());
+    }
+    if (svd.m_computeFullU) m_workspace.resize(svd.rows());
+  }
+
+  bool run(JacobiSVD<MatrixType, FullPivHouseholderQRPreconditioner>& svd, const MatrixType& matrix)
+  {
+    if(matrix.rows() > matrix.cols())
+    {
+      m_qr.compute(matrix);
+      svd.m_workMatrix = m_qr.matrixQR().block(0,0,matrix.cols(),matrix.cols()).template triangularView<Upper>();
+      if(svd.m_computeFullU) m_qr.matrixQ().evalTo(svd.m_matrixU, m_workspace);
+      if(svd.computeV()) svd.m_matrixV = m_qr.colsPermutation();
+      return true;
+    }
+    return false;
+  }
+private:
+  typedef FullPivHouseholderQR<MatrixType> QRType;
+  QRType m_qr;
+  WorkspaceType m_workspace;
+};
+
+template<typename MatrixType>
+class qr_preconditioner_impl<MatrixType, FullPivHouseholderQRPreconditioner, PreconditionIfMoreColsThanRows, true>
+{
+public:
+  typedef typename MatrixType::Scalar Scalar;
+  enum
+  {
+    RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+    ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+    MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
+    TrOptions = RowsAtCompileTime==1 ? (MatrixType::Options & ~(RowMajor))
+              : ColsAtCompileTime==1 ? (MatrixType::Options |   RowMajor)
+              : MatrixType::Options
+  };
+  typedef Matrix<Scalar, ColsAtCompileTime, RowsAtCompileTime, TrOptions, MaxColsAtCompileTime, MaxRowsAtCompileTime>
+          TransposeTypeWithSameStorageOrder;
+
+  void allocate(const JacobiSVD<MatrixType, FullPivHouseholderQRPreconditioner>& svd)
+  {
+    if (svd.cols() != m_qr.rows() || svd.rows() != m_qr.cols())
+    {
+      m_qr.~QRType();
+      ::new (&m_qr) QRType(svd.cols(), svd.rows());
+    }
+    m_adjoint.resize(svd.cols(), svd.rows());
+    if (svd.m_computeFullV) m_workspace.resize(svd.cols());
+  }
+
+  bool run(JacobiSVD<MatrixType, FullPivHouseholderQRPreconditioner>& svd, const MatrixType& matrix)
+  {
+    if(matrix.cols() > matrix.rows())
+    {
+      m_adjoint = matrix.adjoint();
+      m_qr.compute(m_adjoint);
+      svd.m_workMatrix = m_qr.matrixQR().block(0,0,matrix.rows(),matrix.rows()).template triangularView<Upper>().adjoint();
+      if(svd.m_computeFullV) m_qr.matrixQ().evalTo(svd.m_matrixV, m_workspace);
+      if(svd.computeU()) svd.m_matrixU = m_qr.colsPermutation();
+      return true;
+    }
+    else return false;
+  }
+private:
+  typedef FullPivHouseholderQR<TransposeTypeWithSameStorageOrder> QRType;
+  QRType m_qr;
+  TransposeTypeWithSameStorageOrder m_adjoint;
+  typename internal::plain_row_type<MatrixType>::type m_workspace;
+};
+
+/*** preconditioner using ColPivHouseholderQR ***/
+
+template<typename MatrixType>
+class qr_preconditioner_impl<MatrixType, ColPivHouseholderQRPreconditioner, PreconditionIfMoreRowsThanCols, true>
+{
+public:
+  void allocate(const JacobiSVD<MatrixType, ColPivHouseholderQRPreconditioner>& svd)
+  {
+    if (svd.rows() != m_qr.rows() || svd.cols() != m_qr.cols())
+    {
+      m_qr.~QRType();
+      ::new (&m_qr) QRType(svd.rows(), svd.cols());
+    }
+    if (svd.m_computeFullU) m_workspace.resize(svd.rows());
+    else if (svd.m_computeThinU) m_workspace.resize(svd.cols());
+  }
+
+  bool run(JacobiSVD<MatrixType, ColPivHouseholderQRPreconditioner>& svd, const MatrixType& matrix)
+  {
+    if(matrix.rows() > matrix.cols())
+    {
+      m_qr.compute(matrix);
+      svd.m_workMatrix = m_qr.matrixQR().block(0,0,matrix.cols(),matrix.cols()).template triangularView<Upper>();
+      if(svd.m_computeFullU) m_qr.householderQ().evalTo(svd.m_matrixU, m_workspace);
+      else if(svd.m_computeThinU)
+      {
+        svd.m_matrixU.setIdentity(matrix.rows(), matrix.cols());
+        m_qr.householderQ().applyThisOnTheLeft(svd.m_matrixU, m_workspace);
+      }
+      if(svd.computeV()) svd.m_matrixV = m_qr.colsPermutation();
+      return true;
+    }
+    return false;
+  }
+
+private:
+  typedef ColPivHouseholderQR<MatrixType> QRType;
+  QRType m_qr;
+  typename internal::plain_col_type<MatrixType>::type m_workspace;
+};
+
+template<typename MatrixType>
+class qr_preconditioner_impl<MatrixType, ColPivHouseholderQRPreconditioner, PreconditionIfMoreColsThanRows, true>
+{
+public:
+  typedef typename MatrixType::Scalar Scalar;
+  enum
+  {
+    RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+    ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+    MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
+    TrOptions = RowsAtCompileTime==1 ? (MatrixType::Options & ~(RowMajor))
+              : ColsAtCompileTime==1 ? (MatrixType::Options |   RowMajor)
+              : MatrixType::Options
+  };
+
+  typedef Matrix<Scalar, ColsAtCompileTime, RowsAtCompileTime, TrOptions, MaxColsAtCompileTime, MaxRowsAtCompileTime>
+          TransposeTypeWithSameStorageOrder;
+
+  void allocate(const JacobiSVD<MatrixType, ColPivHouseholderQRPreconditioner>& svd)
+  {
+    if (svd.cols() != m_qr.rows() || svd.rows() != m_qr.cols())
+    {
+      m_qr.~QRType();
+      ::new (&m_qr) QRType(svd.cols(), svd.rows());
+    }
+    if (svd.m_computeFullV) m_workspace.resize(svd.cols());
+    else if (svd.m_computeThinV) m_workspace.resize(svd.rows());
+    m_adjoint.resize(svd.cols(), svd.rows());
+  }
+
+  bool run(JacobiSVD<MatrixType, ColPivHouseholderQRPreconditioner>& svd, const MatrixType& matrix)
+  {
+    if(matrix.cols() > matrix.rows())
+    {
+      m_adjoint = matrix.adjoint();
+      m_qr.compute(m_adjoint);
+
+      svd.m_workMatrix = m_qr.matrixQR().block(0,0,matrix.rows(),matrix.rows()).template triangularView<Upper>().adjoint();
+      if(svd.m_computeFullV) m_qr.householderQ().evalTo(svd.m_matrixV, m_workspace);
+      else if(svd.m_computeThinV)
+      {
+        svd.m_matrixV.setIdentity(matrix.cols(), matrix.rows());
+        m_qr.householderQ().applyThisOnTheLeft(svd.m_matrixV, m_workspace);
+      }
+      if(svd.computeU()) svd.m_matrixU = m_qr.colsPermutation();
+      return true;
+    }
+    else return false;
+  }
+
+private:
+  typedef ColPivHouseholderQR<TransposeTypeWithSameStorageOrder> QRType;
+  QRType m_qr;
+  TransposeTypeWithSameStorageOrder m_adjoint;
+  typename internal::plain_row_type<MatrixType>::type m_workspace;
+};
+
+/*** preconditioner using HouseholderQR ***/
+
+template<typename MatrixType>
+class qr_preconditioner_impl<MatrixType, HouseholderQRPreconditioner, PreconditionIfMoreRowsThanCols, true>
+{
+public:
+  void allocate(const JacobiSVD<MatrixType, HouseholderQRPreconditioner>& svd)
+  {
+    if (svd.rows() != m_qr.rows() || svd.cols() != m_qr.cols())
+    {
+      m_qr.~QRType();
+      ::new (&m_qr) QRType(svd.rows(), svd.cols());
+    }
+    if (svd.m_computeFullU) m_workspace.resize(svd.rows());
+    else if (svd.m_computeThinU) m_workspace.resize(svd.cols());
+  }
+
+  bool run(JacobiSVD<MatrixType, HouseholderQRPreconditioner>& svd, const MatrixType& matrix)
+  {
+    if(matrix.rows() > matrix.cols())
+    {
+      m_qr.compute(matrix);
+      svd.m_workMatrix = m_qr.matrixQR().block(0,0,matrix.cols(),matrix.cols()).template triangularView<Upper>();
+      if(svd.m_computeFullU) m_qr.householderQ().evalTo(svd.m_matrixU, m_workspace);
+      else if(svd.m_computeThinU)
+      {
+        svd.m_matrixU.setIdentity(matrix.rows(), matrix.cols());
+        m_qr.householderQ().applyThisOnTheLeft(svd.m_matrixU, m_workspace);
+      }
+      if(svd.computeV()) svd.m_matrixV.setIdentity(matrix.cols(), matrix.cols());
+      return true;
+    }
+    return false;
+  }
+private:
+  typedef HouseholderQR<MatrixType> QRType;
+  QRType m_qr;
+  typename internal::plain_col_type<MatrixType>::type m_workspace;
+};
+
+template<typename MatrixType>
+class qr_preconditioner_impl<MatrixType, HouseholderQRPreconditioner, PreconditionIfMoreColsThanRows, true>
+{
+public:
+  typedef typename MatrixType::Scalar Scalar;
+  enum
+  {
+    RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+    ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+    MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
+    Options = MatrixType::Options
+  };
+
+  typedef Matrix<Scalar, ColsAtCompileTime, RowsAtCompileTime, Options, MaxColsAtCompileTime, MaxRowsAtCompileTime>
+          TransposeTypeWithSameStorageOrder;
+
+  void allocate(const JacobiSVD<MatrixType, HouseholderQRPreconditioner>& svd)
+  {
+    if (svd.cols() != m_qr.rows() || svd.rows() != m_qr.cols())
+    {
+      m_qr.~QRType();
+      ::new (&m_qr) QRType(svd.cols(), svd.rows());
+    }
+    if (svd.m_computeFullV) m_workspace.resize(svd.cols());
+    else if (svd.m_computeThinV) m_workspace.resize(svd.rows());
+    m_adjoint.resize(svd.cols(), svd.rows());
+  }
+
+  bool run(JacobiSVD<MatrixType, HouseholderQRPreconditioner>& svd, const MatrixType& matrix)
+  {
+    if(matrix.cols() > matrix.rows())
+    {
+      m_adjoint = matrix.adjoint();
+      m_qr.compute(m_adjoint);
+
+      svd.m_workMatrix = m_qr.matrixQR().block(0,0,matrix.rows(),matrix.rows()).template triangularView<Upper>().adjoint();
+      if(svd.m_computeFullV) m_qr.householderQ().evalTo(svd.m_matrixV, m_workspace);
+      else if(svd.m_computeThinV)
+      {
+        svd.m_matrixV.setIdentity(matrix.cols(), matrix.rows());
+        m_qr.householderQ().applyThisOnTheLeft(svd.m_matrixV, m_workspace);
+      }
+      if(svd.computeU()) svd.m_matrixU.setIdentity(matrix.rows(), matrix.rows());
+      return true;
+    }
+    else return false;
+  }
+
+private:
+  typedef HouseholderQR<TransposeTypeWithSameStorageOrder> QRType;
+  QRType m_qr;
+  TransposeTypeWithSameStorageOrder m_adjoint;
+  typename internal::plain_row_type<MatrixType>::type m_workspace;
+};
+
+/*** 2x2 SVD implementation
+ ***
+ *** JacobiSVD consists in performing a series of 2x2 SVD subproblems
+ ***/
+
+template<typename MatrixType, int QRPreconditioner>
+struct svd_precondition_2x2_block_to_be_real<MatrixType, QRPreconditioner, false>
+{
+  typedef JacobiSVD<MatrixType, QRPreconditioner> SVD;
+  typedef typename MatrixType::RealScalar RealScalar;
+  static bool run(typename SVD::WorkMatrixType&, SVD&, Index, Index, RealScalar&) { return true; }
+};
+
+template<typename MatrixType, int QRPreconditioner>
+struct svd_precondition_2x2_block_to_be_real<MatrixType, QRPreconditioner, true>
+{
+  typedef JacobiSVD<MatrixType, QRPreconditioner> SVD;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  static bool run(typename SVD::WorkMatrixType& work_matrix, SVD& svd, Index p, Index q, RealScalar& maxDiagEntry)
+  {
+    using std::sqrt;
+    using std::abs;
+    Scalar z;
+    JacobiRotation<Scalar> rot;
+    RealScalar n = sqrt(numext::abs2(work_matrix.coeff(p,p)) + numext::abs2(work_matrix.coeff(q,p)));
+
+    const RealScalar considerAsZero = (std::numeric_limits<RealScalar>::min)();
+    const RealScalar precision = NumTraits<Scalar>::epsilon();
+
+    if(n==0)
+    {
+      // make sure first column is zero
+      work_matrix.coeffRef(p,p) = work_matrix.coeffRef(q,p) = Scalar(0);
+
+      if(abs(numext::imag(work_matrix.coeff(p,q)))>considerAsZero)
+      {
+        // work_matrix.coeff(p,q) can be zero if work_matrix.coeff(q,p) is not zero but small enough to underflow when computing n
+        z = abs(work_matrix.coeff(p,q)) / work_matrix.coeff(p,q);
+        work_matrix.row(p) *= z;
+        if(svd.computeU()) svd.m_matrixU.col(p) *= conj(z);
+      }
+      if(abs(numext::imag(work_matrix.coeff(q,q)))>considerAsZero)
+      {
+        z = abs(work_matrix.coeff(q,q)) / work_matrix.coeff(q,q);
+        work_matrix.row(q) *= z;
+        if(svd.computeU()) svd.m_matrixU.col(q) *= conj(z);
+      }
+      // otherwise the second row is already zero, so we have nothing to do.
+    }
+    else
+    {
+      rot.c() = conj(work_matrix.coeff(p,p)) / n;
+      rot.s() = work_matrix.coeff(q,p) / n;
+      work_matrix.applyOnTheLeft(p,q,rot);
+      if(svd.computeU()) svd.m_matrixU.applyOnTheRight(p,q,rot.adjoint());
+      if(abs(numext::imag(work_matrix.coeff(p,q)))>considerAsZero)
+      {
+        z = abs(work_matrix.coeff(p,q)) / work_matrix.coeff(p,q);
+        work_matrix.col(q) *= z;
+        if(svd.computeV()) svd.m_matrixV.col(q) *= z;
+      }
+      if(abs(numext::imag(work_matrix.coeff(q,q)))>considerAsZero)
+      {
+        z = abs(work_matrix.coeff(q,q)) / work_matrix.coeff(q,q);
+        work_matrix.row(q) *= z;
+        if(svd.computeU()) svd.m_matrixU.col(q) *= conj(z);
+      }
+    }
+
+    // update largest diagonal entry
+    maxDiagEntry = numext::maxi<RealScalar>(maxDiagEntry,numext::maxi<RealScalar>(abs(work_matrix.coeff(p,p)), abs(work_matrix.coeff(q,q))));
+    // and check whether the 2x2 block is already diagonal
+    RealScalar threshold = numext::maxi<RealScalar>(considerAsZero, precision * maxDiagEntry);
+    return abs(work_matrix.coeff(p,q))>threshold || abs(work_matrix.coeff(q,p)) > threshold;
+  }
+};
+
+template<typename _MatrixType, int QRPreconditioner> 
+struct traits<JacobiSVD<_MatrixType,QRPreconditioner> >
+{
+  typedef _MatrixType MatrixType;
+};
+
+} // end namespace internal
+
+/** \ingroup SVD_Module
+  *
+  *
+  * \class JacobiSVD
+  *
+  * \brief Two-sided Jacobi SVD decomposition of a rectangular matrix
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the SVD decomposition
+  * \tparam QRPreconditioner this optional parameter allows to specify the type of QR decomposition that will be used internally
+  *                        for the R-SVD step for non-square matrices. See discussion of possible values below.
+  *
+  * SVD decomposition consists in decomposing any n-by-p matrix \a A as a product
+  *   \f[ A = U S V^* \f]
+  * where \a U is a n-by-n unitary, \a V is a p-by-p unitary, and \a S is a n-by-p real positive matrix which is zero outside of its main diagonal;
+  * the diagonal entries of S are known as the \em singular \em values of \a A and the columns of \a U and \a V are known as the left
+  * and right \em singular \em vectors of \a A respectively.
+  *
+  * Singular values are always sorted in decreasing order.
+  *
+  * This JacobiSVD decomposition computes only the singular values by default. If you want \a U or \a V, you need to ask for them explicitly.
+  *
+  * You can ask for only \em thin \a U or \a V to be computed, meaning the following. In case of a rectangular n-by-p matrix, letting \a m be the
+  * smaller value among \a n and \a p, there are only \a m singular vectors; the remaining columns of \a U and \a V do not correspond to actual
+  * singular vectors. Asking for \em thin \a U or \a V means asking for only their \a m first columns to be formed. So \a U is then a n-by-m matrix,
+  * and \a V is then a p-by-m matrix. Notice that thin \a U and \a V are all you need for (least squares) solving.
+  *
+  * Here's an example demonstrating basic usage:
+  * \include JacobiSVD_basic.cpp
+  * Output: \verbinclude JacobiSVD_basic.out
+  *
+  * This JacobiSVD class is a two-sided Jacobi R-SVD decomposition, ensuring optimal reliability and accuracy. The downside is that it's slower than
+  * bidiagonalizing SVD algorithms for large square matrices; however its complexity is still \f$ O(n^2p) \f$ where \a n is the smaller dimension and
+  * \a p is the greater dimension, meaning that it is still of the same order of complexity as the faster bidiagonalizing R-SVD algorithms.
+  * In particular, like any R-SVD, it takes advantage of non-squareness in that its complexity is only linear in the greater dimension.
+  *
+  * If the input matrix has inf or nan coefficients, the result of the computation is undefined, but the computation is guaranteed to
+  * terminate in finite (and reasonable) time.
+  *
+  * The possible values for QRPreconditioner are:
+  * \li ColPivHouseholderQRPreconditioner is the default. In practice it's very safe. It uses column-pivoting QR.
+  * \li FullPivHouseholderQRPreconditioner, is the safest and slowest. It uses full-pivoting QR.
+  *     Contrary to other QRs, it doesn't allow computing thin unitaries.
+  * \li HouseholderQRPreconditioner is the fastest, and less safe and accurate than the pivoting variants. It uses non-pivoting QR.
+  *     This is very similar in safety and accuracy to the bidiagonalization process used by bidiagonalizing SVD algorithms (since bidiagonalization
+  *     is inherently non-pivoting). However the resulting SVD is still more reliable than bidiagonalizing SVDs because the Jacobi-based iterarive
+  *     process is more reliable than the optimized bidiagonal SVD iterations.
+  * \li NoQRPreconditioner allows not to use a QR preconditioner at all. This is useful if you know that you will only be computing
+  *     JacobiSVD decompositions of square matrices. Non-square matrices require a QR preconditioner. Using this option will result in
+  *     faster compilation and smaller executable code. It won't significantly speed up computation, since JacobiSVD is always checking
+  *     if QR preconditioning is needed before applying it anyway.
+  *
+  * \sa MatrixBase::jacobiSvd()
+  */
+template<typename _MatrixType, int QRPreconditioner> class JacobiSVD
+ : public SVDBase<JacobiSVD<_MatrixType,QRPreconditioner> >
+{
+    typedef SVDBase<JacobiSVD> Base;
+  public:
+
+    typedef _MatrixType MatrixType;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
+    enum {
+      RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      DiagSizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_DYNAMIC(RowsAtCompileTime,ColsAtCompileTime),
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
+      MaxDiagSizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED(MaxRowsAtCompileTime,MaxColsAtCompileTime),
+      MatrixOptions = MatrixType::Options
+    };
+
+    typedef typename Base::MatrixUType MatrixUType;
+    typedef typename Base::MatrixVType MatrixVType;
+    typedef typename Base::SingularValuesType SingularValuesType;
+    
+    typedef typename internal::plain_row_type<MatrixType>::type RowType;
+    typedef typename internal::plain_col_type<MatrixType>::type ColType;
+    typedef Matrix<Scalar, DiagSizeAtCompileTime, DiagSizeAtCompileTime,
+                   MatrixOptions, MaxDiagSizeAtCompileTime, MaxDiagSizeAtCompileTime>
+            WorkMatrixType;
+
+    /** \brief Default Constructor.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via JacobiSVD::compute(const MatrixType&).
+      */
+    JacobiSVD()
+    {}
+
+
+    /** \brief Default Constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem size.
+      * \sa JacobiSVD()
+      */
+    JacobiSVD(Index rows, Index cols, unsigned int computationOptions = 0)
+    {
+      allocate(rows, cols, computationOptions);
+    }
+
+    /** \brief Constructor performing the decomposition of given matrix.
+     *
+     * \param matrix the matrix to decompose
+     * \param computationOptions optional parameter allowing to specify if you want full or thin U or V unitaries to be computed.
+     *                           By default, none is computed. This is a bit-field, the possible bits are #ComputeFullU, #ComputeThinU,
+     *                           #ComputeFullV, #ComputeThinV.
+     *
+     * Thin unitaries are only available if your matrix type has a Dynamic number of columns (for example MatrixXf). They also are not
+     * available with the (non-default) FullPivHouseholderQR preconditioner.
+     */
+    explicit JacobiSVD(const MatrixType& matrix, unsigned int computationOptions = 0)
+    {
+      compute(matrix, computationOptions);
+    }
+
+    /** \brief Method performing the decomposition of given matrix using custom options.
+     *
+     * \param matrix the matrix to decompose
+     * \param computationOptions optional parameter allowing to specify if you want full or thin U or V unitaries to be computed.
+     *                           By default, none is computed. This is a bit-field, the possible bits are #ComputeFullU, #ComputeThinU,
+     *                           #ComputeFullV, #ComputeThinV.
+     *
+     * Thin unitaries are only available if your matrix type has a Dynamic number of columns (for example MatrixXf). They also are not
+     * available with the (non-default) FullPivHouseholderQR preconditioner.
+     */
+    JacobiSVD& compute(const MatrixType& matrix, unsigned int computationOptions);
+
+    /** \brief Method performing the decomposition of given matrix using current options.
+     *
+     * \param matrix the matrix to decompose
+     *
+     * This method uses the current \a computationOptions, as already passed to the constructor or to compute(const MatrixType&, unsigned int).
+     */
+    JacobiSVD& compute(const MatrixType& matrix)
+    {
+      return compute(matrix, m_computationOptions);
+    }
+
+    using Base::computeU;
+    using Base::computeV;
+    using Base::rows;
+    using Base::cols;
+    using Base::rank;
+
+  private:
+    void allocate(Index rows, Index cols, unsigned int computationOptions);
+
+  protected:
+    using Base::m_matrixU;
+    using Base::m_matrixV;
+    using Base::m_singularValues;
+    using Base::m_isInitialized;
+    using Base::m_isAllocated;
+    using Base::m_usePrescribedThreshold;
+    using Base::m_computeFullU;
+    using Base::m_computeThinU;
+    using Base::m_computeFullV;
+    using Base::m_computeThinV;
+    using Base::m_computationOptions;
+    using Base::m_nonzeroSingularValues;
+    using Base::m_rows;
+    using Base::m_cols;
+    using Base::m_diagSize;
+    using Base::m_prescribedThreshold;
+    WorkMatrixType m_workMatrix;
+
+    template<typename __MatrixType, int _QRPreconditioner, bool _IsComplex>
+    friend struct internal::svd_precondition_2x2_block_to_be_real;
+    template<typename __MatrixType, int _QRPreconditioner, int _Case, bool _DoAnything>
+    friend struct internal::qr_preconditioner_impl;
+
+    internal::qr_preconditioner_impl<MatrixType, QRPreconditioner, internal::PreconditionIfMoreColsThanRows> m_qr_precond_morecols;
+    internal::qr_preconditioner_impl<MatrixType, QRPreconditioner, internal::PreconditionIfMoreRowsThanCols> m_qr_precond_morerows;
+    MatrixType m_scaledMatrix;
+};
+
+template<typename MatrixType, int QRPreconditioner>
+void JacobiSVD<MatrixType, QRPreconditioner>::allocate(Index rows, Index cols, unsigned int computationOptions)
+{
+  eigen_assert(rows >= 0 && cols >= 0);
+
+  if (m_isAllocated &&
+      rows == m_rows &&
+      cols == m_cols &&
+      computationOptions == m_computationOptions)
+  {
+    return;
+  }
+
+  m_rows = rows;
+  m_cols = cols;
+  m_isInitialized = false;
+  m_isAllocated = true;
+  m_computationOptions = computationOptions;
+  m_computeFullU = (computationOptions & ComputeFullU) != 0;
+  m_computeThinU = (computationOptions & ComputeThinU) != 0;
+  m_computeFullV = (computationOptions & ComputeFullV) != 0;
+  m_computeThinV = (computationOptions & ComputeThinV) != 0;
+  eigen_assert(!(m_computeFullU && m_computeThinU) && "JacobiSVD: you can't ask for both full and thin U");
+  eigen_assert(!(m_computeFullV && m_computeThinV) && "JacobiSVD: you can't ask for both full and thin V");
+  eigen_assert(EIGEN_IMPLIES(m_computeThinU || m_computeThinV, MatrixType::ColsAtCompileTime==Dynamic) &&
+              "JacobiSVD: thin U and V are only available when your matrix has a dynamic number of columns.");
+  if (QRPreconditioner == FullPivHouseholderQRPreconditioner)
+  {
+      eigen_assert(!(m_computeThinU || m_computeThinV) &&
+              "JacobiSVD: can't compute thin U or thin V with the FullPivHouseholderQR preconditioner. "
+              "Use the ColPivHouseholderQR preconditioner instead.");
+  }
+  m_diagSize = (std::min)(m_rows, m_cols);
+  m_singularValues.resize(m_diagSize);
+  if(RowsAtCompileTime==Dynamic)
+    m_matrixU.resize(m_rows, m_computeFullU ? m_rows
+                            : m_computeThinU ? m_diagSize
+                            : 0);
+  if(ColsAtCompileTime==Dynamic)
+    m_matrixV.resize(m_cols, m_computeFullV ? m_cols
+                            : m_computeThinV ? m_diagSize
+                            : 0);
+  m_workMatrix.resize(m_diagSize, m_diagSize);
+  
+  if(m_cols>m_rows)   m_qr_precond_morecols.allocate(*this);
+  if(m_rows>m_cols)   m_qr_precond_morerows.allocate(*this);
+  if(m_rows!=m_cols)  m_scaledMatrix.resize(rows,cols);
+}
+
+template<typename MatrixType, int QRPreconditioner>
+JacobiSVD<MatrixType, QRPreconditioner>&
+JacobiSVD<MatrixType, QRPreconditioner>::compute(const MatrixType& matrix, unsigned int computationOptions)
+{
+  using std::abs;
+  allocate(matrix.rows(), matrix.cols(), computationOptions);
+
+  // currently we stop when we reach precision 2*epsilon as the last bit of precision can require an unreasonable number of iterations,
+  // only worsening the precision of U and V as we accumulate more rotations
+  const RealScalar precision = RealScalar(2) * NumTraits<Scalar>::epsilon();
+
+  // limit for denormal numbers to be considered zero in order to avoid infinite loops (see bug 286)
+  const RealScalar considerAsZero = (std::numeric_limits<RealScalar>::min)();
+
+  // Scaling factor to reduce over/under-flows
+  RealScalar scale = matrix.cwiseAbs().maxCoeff();
+  if(scale==RealScalar(0)) scale = RealScalar(1);
+  
+  /*** step 1. The R-SVD step: we use a QR decomposition to reduce to the case of a square matrix */
+
+  if(m_rows!=m_cols)
+  {
+    m_scaledMatrix = matrix / scale;
+    m_qr_precond_morecols.run(*this, m_scaledMatrix);
+    m_qr_precond_morerows.run(*this, m_scaledMatrix);
+  }
+  else
+  {
+    m_workMatrix = matrix.block(0,0,m_diagSize,m_diagSize) / scale;
+    if(m_computeFullU) m_matrixU.setIdentity(m_rows,m_rows);
+    if(m_computeThinU) m_matrixU.setIdentity(m_rows,m_diagSize);
+    if(m_computeFullV) m_matrixV.setIdentity(m_cols,m_cols);
+    if(m_computeThinV) m_matrixV.setIdentity(m_cols, m_diagSize);
+  }
+
+  /*** step 2. The main Jacobi SVD iteration. ***/
+  RealScalar maxDiagEntry = m_workMatrix.cwiseAbs().diagonal().maxCoeff();
+
+  bool finished = false;
+  while(!finished)
+  {
+    finished = true;
+
+    // do a sweep: for all index pairs (p,q), perform SVD of the corresponding 2x2 sub-matrix
+
+    for(Index p = 1; p < m_diagSize; ++p)
+    {
+      for(Index q = 0; q < p; ++q)
+      {
+        // if this 2x2 sub-matrix is not diagonal already...
+        // notice that this comparison will evaluate to false if any NaN is involved, ensuring that NaN's don't
+        // keep us iterating forever. Similarly, small denormal numbers are considered zero.
+        RealScalar threshold = numext::maxi<RealScalar>(considerAsZero, precision * maxDiagEntry);
+        if(abs(m_workMatrix.coeff(p,q))>threshold || abs(m_workMatrix.coeff(q,p)) > threshold)
+        {
+          finished = false;
+          // perform SVD decomposition of 2x2 sub-matrix corresponding to indices p,q to make it diagonal
+          // the complex to real operation returns true if the updated 2x2 block is not already diagonal
+          if(internal::svd_precondition_2x2_block_to_be_real<MatrixType, QRPreconditioner>::run(m_workMatrix, *this, p, q, maxDiagEntry))
+          {
+            JacobiRotation<RealScalar> j_left, j_right;
+            internal::real_2x2_jacobi_svd(m_workMatrix, p, q, &j_left, &j_right);
+
+            // accumulate resulting Jacobi rotations
+            m_workMatrix.applyOnTheLeft(p,q,j_left);
+            if(computeU()) m_matrixU.applyOnTheRight(p,q,j_left.transpose());
+
+            m_workMatrix.applyOnTheRight(p,q,j_right);
+            if(computeV()) m_matrixV.applyOnTheRight(p,q,j_right);
+
+            // keep track of the largest diagonal coefficient
+            maxDiagEntry = numext::maxi<RealScalar>(maxDiagEntry,numext::maxi<RealScalar>(abs(m_workMatrix.coeff(p,p)), abs(m_workMatrix.coeff(q,q))));
+          }
+        }
+      }
+    }
+  }
+
+  /*** step 3. The work matrix is now diagonal, so ensure it's positive so its diagonal entries are the singular values ***/
+
+  for(Index i = 0; i < m_diagSize; ++i)
+  {
+    // For a complex matrix, some diagonal coefficients might note have been
+    // treated by svd_precondition_2x2_block_to_be_real, and the imaginary part
+    // of some diagonal entry might not be null.
+    if(NumTraits<Scalar>::IsComplex && abs(numext::imag(m_workMatrix.coeff(i,i)))>considerAsZero)
+    {
+      RealScalar a = abs(m_workMatrix.coeff(i,i));
+      m_singularValues.coeffRef(i) = abs(a);
+      if(computeU()) m_matrixU.col(i) *= m_workMatrix.coeff(i,i)/a;
+    }
+    else
+    {
+      // m_workMatrix.coeff(i,i) is already real, no difficulty:
+      RealScalar a = numext::real(m_workMatrix.coeff(i,i));
+      m_singularValues.coeffRef(i) = abs(a);
+      if(computeU() && (a<RealScalar(0))) m_matrixU.col(i) = -m_matrixU.col(i);
+    }
+  }
+  
+  m_singularValues *= scale;
+
+  /*** step 4. Sort singular values in descending order and compute the number of nonzero singular values ***/
+
+  m_nonzeroSingularValues = m_diagSize;
+  for(Index i = 0; i < m_diagSize; i++)
+  {
+    Index pos;
+    RealScalar maxRemainingSingularValue = m_singularValues.tail(m_diagSize-i).maxCoeff(&pos);
+    if(maxRemainingSingularValue == RealScalar(0))
+    {
+      m_nonzeroSingularValues = i;
+      break;
+    }
+    if(pos)
+    {
+      pos += i;
+      std::swap(m_singularValues.coeffRef(i), m_singularValues.coeffRef(pos));
+      if(computeU()) m_matrixU.col(pos).swap(m_matrixU.col(i));
+      if(computeV()) m_matrixV.col(pos).swap(m_matrixV.col(i));
+    }
+  }
+
+  m_isInitialized = true;
+  return *this;
+}
+
+/** \svd_module
+  *
+  * \return the singular value decomposition of \c *this computed by two-sided
+  * Jacobi transformations.
+  *
+  * \sa class JacobiSVD
+  */
+template<typename Derived>
+JacobiSVD<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::jacobiSvd(unsigned int computationOptions) const
+{
+  return JacobiSVD<PlainObject>(*this, computationOptions);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_JACOBISVD_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SVD/JacobiSVD_LAPACKE.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SVD/JacobiSVD_LAPACKE.h
new file mode 100644
index 00000000..50272154
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SVD/JacobiSVD_LAPACKE.h
@@ -0,0 +1,90 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to LAPACKe
+ *    Singular Value Decomposition - SVD.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_JACOBISVD_LAPACKE_H
+#define EIGEN_JACOBISVD_LAPACKE_H
+
+namespace Eigen { 
+
+/** \internal Specialization for the data types supported by LAPACKe */
+
+#define EIGEN_LAPACKE_SVD(EIGTYPE, LAPACKE_TYPE, LAPACKE_RTYPE, LAPACKE_PREFIX, EIGCOLROW, LAPACKE_COLROW) \
+template<> inline \
+JacobiSVD<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic>, ColPivHouseholderQRPreconditioner>& \
+JacobiSVD<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic>, ColPivHouseholderQRPreconditioner>::compute(const Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic>& matrix, unsigned int computationOptions) \
+{ \
+  typedef Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic> MatrixType; \
+  /*typedef MatrixType::Scalar Scalar;*/ \
+  /*typedef MatrixType::RealScalar RealScalar;*/ \
+  allocate(matrix.rows(), matrix.cols(), computationOptions); \
+\
+  /*const RealScalar precision = RealScalar(2) * NumTraits<Scalar>::epsilon();*/ \
+  m_nonzeroSingularValues = m_diagSize; \
+\
+  lapack_int lda = internal::convert_index<lapack_int>(matrix.outerStride()), ldu, ldvt; \
+  lapack_int matrix_order = LAPACKE_COLROW; \
+  char jobu, jobvt; \
+  LAPACKE_TYPE *u, *vt, dummy; \
+  jobu  = (m_computeFullU) ? 'A' : (m_computeThinU) ? 'S' : 'N'; \
+  jobvt = (m_computeFullV) ? 'A' : (m_computeThinV) ? 'S' : 'N'; \
+  if (computeU()) { \
+    ldu  = internal::convert_index<lapack_int>(m_matrixU.outerStride()); \
+    u    = (LAPACKE_TYPE*)m_matrixU.data(); \
+  } else { ldu=1; u=&dummy; }\
+  MatrixType localV; \
+  ldvt = (m_computeFullV) ? internal::convert_index<lapack_int>(m_cols) : (m_computeThinV) ? internal::convert_index<lapack_int>(m_diagSize) : 1; \
+  if (computeV()) { \
+    localV.resize(ldvt, m_cols); \
+    vt   = (LAPACKE_TYPE*)localV.data(); \
+  } else { ldvt=1; vt=&dummy; }\
+  Matrix<LAPACKE_RTYPE, Dynamic, Dynamic> superb; superb.resize(m_diagSize, 1); \
+  MatrixType m_temp; m_temp = matrix; \
+  LAPACKE_##LAPACKE_PREFIX##gesvd( matrix_order, jobu, jobvt, internal::convert_index<lapack_int>(m_rows), internal::convert_index<lapack_int>(m_cols), (LAPACKE_TYPE*)m_temp.data(), lda, (LAPACKE_RTYPE*)m_singularValues.data(), u, ldu, vt, ldvt, superb.data()); \
+  if (computeV()) m_matrixV = localV.adjoint(); \
+ /* for(int i=0;i<m_diagSize;i++) if (m_singularValues.coeffRef(i) < precision) { m_nonzeroSingularValues--; m_singularValues.coeffRef(i)=RealScalar(0);}*/ \
+  m_isInitialized = true; \
+  return *this; \
+}
+
+EIGEN_LAPACKE_SVD(double,   double,                double, d, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_SVD(float,    float,                 float , s, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_SVD(dcomplex, lapack_complex_double, double, z, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_SVD(scomplex, lapack_complex_float,  float , c, ColMajor, LAPACK_COL_MAJOR)
+
+EIGEN_LAPACKE_SVD(double,   double,                double, d, RowMajor, LAPACK_ROW_MAJOR)
+EIGEN_LAPACKE_SVD(float,    float,                 float , s, RowMajor, LAPACK_ROW_MAJOR)
+EIGEN_LAPACKE_SVD(dcomplex, lapack_complex_double, double, z, RowMajor, LAPACK_ROW_MAJOR)
+EIGEN_LAPACKE_SVD(scomplex, lapack_complex_float,  float , c, RowMajor, LAPACK_ROW_MAJOR)
+
+} // end namespace Eigen
+
+#endif // EIGEN_JACOBISVD_LAPACKE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SVD/SVDBase.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SVD/SVDBase.h
new file mode 100644
index 00000000..42941479
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SVD/SVDBase.h
@@ -0,0 +1,312 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// Copyright (C) 2013 Gauthier Brun <brun.gauthier@gmail.com>
+// Copyright (C) 2013 Nicolas Carre <nicolas.carre@ensimag.fr>
+// Copyright (C) 2013 Jean Ceccato <jean.ceccato@ensimag.fr>
+// Copyright (C) 2013 Pierre Zoppitelli <pierre.zoppitelli@ensimag.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SVDBASE_H
+#define EIGEN_SVDBASE_H
+
+namespace Eigen {
+/** \ingroup SVD_Module
+ *
+ *
+ * \class SVDBase
+ *
+ * \brief Base class of SVD algorithms
+ *
+ * \tparam Derived the type of the actual SVD decomposition
+ *
+ * SVD decomposition consists in decomposing any n-by-p matrix \a A as a product
+ *   \f[ A = U S V^* \f]
+ * where \a U is a n-by-n unitary, \a V is a p-by-p unitary, and \a S is a n-by-p real positive matrix which is zero outside of its main diagonal;
+ * the diagonal entries of S are known as the \em singular \em values of \a A and the columns of \a U and \a V are known as the left
+ * and right \em singular \em vectors of \a A respectively.
+ *
+ * Singular values are always sorted in decreasing order.
+ *
+ * 
+ * You can ask for only \em thin \a U or \a V to be computed, meaning the following. In case of a rectangular n-by-p matrix, letting \a m be the
+ * smaller value among \a n and \a p, there are only \a m singular vectors; the remaining columns of \a U and \a V do not correspond to actual
+ * singular vectors. Asking for \em thin \a U or \a V means asking for only their \a m first columns to be formed. So \a U is then a n-by-m matrix,
+ * and \a V is then a p-by-m matrix. Notice that thin \a U and \a V are all you need for (least squares) solving.
+ *  
+ * If the input matrix has inf or nan coefficients, the result of the computation is undefined, but the computation is guaranteed to
+ * terminate in finite (and reasonable) time.
+ * \sa class BDCSVD, class JacobiSVD
+ */
+template<typename Derived>
+class SVDBase
+{
+
+public:
+  typedef typename internal::traits<Derived>::MatrixType MatrixType;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
+  typedef typename MatrixType::StorageIndex StorageIndex;
+  typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+  enum {
+    RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+    ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+    DiagSizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_DYNAMIC(RowsAtCompileTime,ColsAtCompileTime),
+    MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
+    MaxDiagSizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED(MaxRowsAtCompileTime,MaxColsAtCompileTime),
+    MatrixOptions = MatrixType::Options
+  };
+
+  typedef Matrix<Scalar, RowsAtCompileTime, RowsAtCompileTime, MatrixOptions, MaxRowsAtCompileTime, MaxRowsAtCompileTime> MatrixUType;
+  typedef Matrix<Scalar, ColsAtCompileTime, ColsAtCompileTime, MatrixOptions, MaxColsAtCompileTime, MaxColsAtCompileTime> MatrixVType;
+  typedef typename internal::plain_diag_type<MatrixType, RealScalar>::type SingularValuesType;
+  
+  Derived& derived() { return *static_cast<Derived*>(this); }
+  const Derived& derived() const { return *static_cast<const Derived*>(this); }
+
+  /** \returns the \a U matrix.
+   *
+   * For the SVD decomposition of a n-by-p matrix, letting \a m be the minimum of \a n and \a p,
+   * the U matrix is n-by-n if you asked for \link Eigen::ComputeFullU ComputeFullU \endlink, and is n-by-m if you asked for \link Eigen::ComputeThinU ComputeThinU \endlink.
+   *
+   * The \a m first columns of \a U are the left singular vectors of the matrix being decomposed.
+   *
+   * This method asserts that you asked for \a U to be computed.
+   */
+  const MatrixUType& matrixU() const
+  {
+    eigen_assert(m_isInitialized && "SVD is not initialized.");
+    eigen_assert(computeU() && "This SVD decomposition didn't compute U. Did you ask for it?");
+    return m_matrixU;
+  }
+
+  /** \returns the \a V matrix.
+   *
+   * For the SVD decomposition of a n-by-p matrix, letting \a m be the minimum of \a n and \a p,
+   * the V matrix is p-by-p if you asked for \link Eigen::ComputeFullV ComputeFullV \endlink, and is p-by-m if you asked for \link Eigen::ComputeThinV ComputeThinV \endlink.
+   *
+   * The \a m first columns of \a V are the right singular vectors of the matrix being decomposed.
+   *
+   * This method asserts that you asked for \a V to be computed.
+   */
+  const MatrixVType& matrixV() const
+  {
+    eigen_assert(m_isInitialized && "SVD is not initialized.");
+    eigen_assert(computeV() && "This SVD decomposition didn't compute V. Did you ask for it?");
+    return m_matrixV;
+  }
+
+  /** \returns the vector of singular values.
+   *
+   * For the SVD decomposition of a n-by-p matrix, letting \a m be the minimum of \a n and \a p, the
+   * returned vector has size \a m.  Singular values are always sorted in decreasing order.
+   */
+  const SingularValuesType& singularValues() const
+  {
+    eigen_assert(m_isInitialized && "SVD is not initialized.");
+    return m_singularValues;
+  }
+
+  /** \returns the number of singular values that are not exactly 0 */
+  Index nonzeroSingularValues() const
+  {
+    eigen_assert(m_isInitialized && "SVD is not initialized.");
+    return m_nonzeroSingularValues;
+  }
+  
+  /** \returns the rank of the matrix of which \c *this is the SVD.
+    *
+    * \note This method has to determine which singular values should be considered nonzero.
+    *       For that, it uses the threshold value that you can control by calling
+    *       setThreshold(const RealScalar&).
+    */
+  inline Index rank() const
+  {
+    using std::abs;
+    eigen_assert(m_isInitialized && "JacobiSVD is not initialized.");
+    if(m_singularValues.size()==0) return 0;
+    RealScalar premultiplied_threshold = numext::maxi<RealScalar>(m_singularValues.coeff(0) * threshold(), (std::numeric_limits<RealScalar>::min)());
+    Index i = m_nonzeroSingularValues-1;
+    while(i>=0 && m_singularValues.coeff(i) < premultiplied_threshold) --i;
+    return i+1;
+  }
+  
+  /** Allows to prescribe a threshold to be used by certain methods, such as rank() and solve(),
+    * which need to determine when singular values are to be considered nonzero.
+    * This is not used for the SVD decomposition itself.
+    *
+    * When it needs to get the threshold value, Eigen calls threshold().
+    * The default is \c NumTraits<Scalar>::epsilon()
+    *
+    * \param threshold The new value to use as the threshold.
+    *
+    * A singular value will be considered nonzero if its value is strictly greater than
+    *  \f$ \vert singular value \vert \leqslant threshold \times \vert max singular value \vert \f$.
+    *
+    * If you want to come back to the default behavior, call setThreshold(Default_t)
+    */
+  Derived& setThreshold(const RealScalar& threshold)
+  {
+    m_usePrescribedThreshold = true;
+    m_prescribedThreshold = threshold;
+    return derived();
+  }
+
+  /** Allows to come back to the default behavior, letting Eigen use its default formula for
+    * determining the threshold.
+    *
+    * You should pass the special object Eigen::Default as parameter here.
+    * \code svd.setThreshold(Eigen::Default); \endcode
+    *
+    * See the documentation of setThreshold(const RealScalar&).
+    */
+  Derived& setThreshold(Default_t)
+  {
+    m_usePrescribedThreshold = false;
+    return derived();
+  }
+
+  /** Returns the threshold that will be used by certain methods such as rank().
+    *
+    * See the documentation of setThreshold(const RealScalar&).
+    */
+  RealScalar threshold() const
+  {
+    eigen_assert(m_isInitialized || m_usePrescribedThreshold);
+    return m_usePrescribedThreshold ? m_prescribedThreshold
+                                    : (std::max<Index>)(1,m_diagSize)*NumTraits<Scalar>::epsilon();
+  }
+
+  /** \returns true if \a U (full or thin) is asked for in this SVD decomposition */
+  inline bool computeU() const { return m_computeFullU || m_computeThinU; }
+  /** \returns true if \a V (full or thin) is asked for in this SVD decomposition */
+  inline bool computeV() const { return m_computeFullV || m_computeThinV; }
+
+  inline Index rows() const { return m_rows; }
+  inline Index cols() const { return m_cols; }
+  
+  /** \returns a (least squares) solution of \f$ A x = b \f$ using the current SVD decomposition of A.
+    *
+    * \param b the right-hand-side of the equation to solve.
+    *
+    * \note Solving requires both U and V to be computed. Thin U and V are enough, there is no need for full U or V.
+    *
+    * \note SVD solving is implicitly least-squares. Thus, this method serves both purposes of exact solving and least-squares solving.
+    * In other words, the returned solution is guaranteed to minimize the Euclidean norm \f$ \Vert A x - b \Vert \f$.
+    */
+  template<typename Rhs>
+  inline const Solve<Derived, Rhs>
+  solve(const MatrixBase<Rhs>& b) const
+  {
+    eigen_assert(m_isInitialized && "SVD is not initialized.");
+    eigen_assert(computeU() && computeV() && "SVD::solve() requires both unitaries U and V to be computed (thin unitaries suffice).");
+    return Solve<Derived, Rhs>(derived(), b.derived());
+  }
+  
+  #ifndef EIGEN_PARSED_BY_DOXYGEN
+  template<typename RhsType, typename DstType>
+  void _solve_impl(const RhsType &rhs, DstType &dst) const;
+  #endif
+
+protected:
+  
+  static void check_template_parameters()
+  {
+    EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+  }
+  
+  // return true if already allocated
+  bool allocate(Index rows, Index cols, unsigned int computationOptions) ;
+
+  MatrixUType m_matrixU;
+  MatrixVType m_matrixV;
+  SingularValuesType m_singularValues;
+  bool m_isInitialized, m_isAllocated, m_usePrescribedThreshold;
+  bool m_computeFullU, m_computeThinU;
+  bool m_computeFullV, m_computeThinV;
+  unsigned int m_computationOptions;
+  Index m_nonzeroSingularValues, m_rows, m_cols, m_diagSize;
+  RealScalar m_prescribedThreshold;
+
+  /** \brief Default Constructor.
+   *
+   * Default constructor of SVDBase
+   */
+  SVDBase()
+    : m_isInitialized(false),
+      m_isAllocated(false),
+      m_usePrescribedThreshold(false),
+      m_computationOptions(0),
+      m_rows(-1), m_cols(-1), m_diagSize(0)
+  {
+    check_template_parameters();
+  }
+
+
+};
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename Derived>
+template<typename RhsType, typename DstType>
+void SVDBase<Derived>::_solve_impl(const RhsType &rhs, DstType &dst) const
+{
+  eigen_assert(rhs.rows() == rows());
+
+  // A = U S V^*
+  // So A^{-1} = V S^{-1} U^*
+
+  Matrix<Scalar, Dynamic, RhsType::ColsAtCompileTime, 0, MatrixType::MaxRowsAtCompileTime, RhsType::MaxColsAtCompileTime> tmp;
+  Index l_rank = rank();
+  tmp.noalias() =  m_matrixU.leftCols(l_rank).adjoint() * rhs;
+  tmp = m_singularValues.head(l_rank).asDiagonal().inverse() * tmp;
+  dst = m_matrixV.leftCols(l_rank) * tmp;
+}
+#endif
+
+template<typename MatrixType>
+bool SVDBase<MatrixType>::allocate(Index rows, Index cols, unsigned int computationOptions)
+{
+  eigen_assert(rows >= 0 && cols >= 0);
+
+  if (m_isAllocated &&
+      rows == m_rows &&
+      cols == m_cols &&
+      computationOptions == m_computationOptions)
+  {
+    return true;
+  }
+
+  m_rows = rows;
+  m_cols = cols;
+  m_isInitialized = false;
+  m_isAllocated = true;
+  m_computationOptions = computationOptions;
+  m_computeFullU = (computationOptions & ComputeFullU) != 0;
+  m_computeThinU = (computationOptions & ComputeThinU) != 0;
+  m_computeFullV = (computationOptions & ComputeFullV) != 0;
+  m_computeThinV = (computationOptions & ComputeThinV) != 0;
+  eigen_assert(!(m_computeFullU && m_computeThinU) && "SVDBase: you can't ask for both full and thin U");
+  eigen_assert(!(m_computeFullV && m_computeThinV) && "SVDBase: you can't ask for both full and thin V");
+  eigen_assert(EIGEN_IMPLIES(m_computeThinU || m_computeThinV, MatrixType::ColsAtCompileTime==Dynamic) &&
+	       "SVDBase: thin U and V are only available when your matrix has a dynamic number of columns.");
+
+  m_diagSize = (std::min)(m_rows, m_cols);
+  m_singularValues.resize(m_diagSize);
+  if(RowsAtCompileTime==Dynamic)
+    m_matrixU.resize(m_rows, m_computeFullU ? m_rows : m_computeThinU ? m_diagSize : 0);
+  if(ColsAtCompileTime==Dynamic)
+    m_matrixV.resize(m_cols, m_computeFullV ? m_cols : m_computeThinV ? m_diagSize : 0);
+
+  return false;
+}
+
+}// end namespace
+
+#endif // EIGEN_SVDBASE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SVD/UpperBidiagonalization.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SVD/UpperBidiagonalization.h
new file mode 100644
index 00000000..11ac847e
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SVD/UpperBidiagonalization.h
@@ -0,0 +1,414 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2013-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_BIDIAGONALIZATION_H
+#define EIGEN_BIDIAGONALIZATION_H
+
+namespace Eigen { 
+
+namespace internal {
+// UpperBidiagonalization will probably be replaced by a Bidiagonalization class, don't want to make it stable API.
+// At the same time, it's useful to keep for now as it's about the only thing that is testing the BandMatrix class.
+
+template<typename _MatrixType> class UpperBidiagonalization
+{
+  public:
+
+    typedef _MatrixType MatrixType;
+    enum {
+      RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      ColsAtCompileTimeMinusOne = internal::decrement_size<ColsAtCompileTime>::ret
+    };
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+    typedef Matrix<Scalar, 1, ColsAtCompileTime> RowVectorType;
+    typedef Matrix<Scalar, RowsAtCompileTime, 1> ColVectorType;
+    typedef BandMatrix<RealScalar, ColsAtCompileTime, ColsAtCompileTime, 1, 0, RowMajor> BidiagonalType;
+    typedef Matrix<Scalar, ColsAtCompileTime, 1> DiagVectorType;
+    typedef Matrix<Scalar, ColsAtCompileTimeMinusOne, 1> SuperDiagVectorType;
+    typedef HouseholderSequence<
+              const MatrixType,
+              const typename internal::remove_all<typename Diagonal<const MatrixType,0>::ConjugateReturnType>::type
+            > HouseholderUSequenceType;
+    typedef HouseholderSequence<
+              const typename internal::remove_all<typename MatrixType::ConjugateReturnType>::type,
+              Diagonal<const MatrixType,1>,
+              OnTheRight
+            > HouseholderVSequenceType;
+    
+    /**
+    * \brief Default Constructor.
+    *
+    * The default constructor is useful in cases in which the user intends to
+    * perform decompositions via Bidiagonalization::compute(const MatrixType&).
+    */
+    UpperBidiagonalization() : m_householder(), m_bidiagonal(), m_isInitialized(false) {}
+
+    explicit UpperBidiagonalization(const MatrixType& matrix)
+      : m_householder(matrix.rows(), matrix.cols()),
+        m_bidiagonal(matrix.cols(), matrix.cols()),
+        m_isInitialized(false)
+    {
+      compute(matrix);
+    }
+    
+    UpperBidiagonalization& compute(const MatrixType& matrix);
+    UpperBidiagonalization& computeUnblocked(const MatrixType& matrix);
+    
+    const MatrixType& householder() const { return m_householder; }
+    const BidiagonalType& bidiagonal() const { return m_bidiagonal; }
+    
+    const HouseholderUSequenceType householderU() const
+    {
+      eigen_assert(m_isInitialized && "UpperBidiagonalization is not initialized.");
+      return HouseholderUSequenceType(m_householder, m_householder.diagonal().conjugate());
+    }
+
+    const HouseholderVSequenceType householderV() // const here gives nasty errors and i'm lazy
+    {
+      eigen_assert(m_isInitialized && "UpperBidiagonalization is not initialized.");
+      return HouseholderVSequenceType(m_householder.conjugate(), m_householder.const_derived().template diagonal<1>())
+             .setLength(m_householder.cols()-1)
+             .setShift(1);
+    }
+    
+  protected:
+    MatrixType m_householder;
+    BidiagonalType m_bidiagonal;
+    bool m_isInitialized;
+};
+
+// Standard upper bidiagonalization without fancy optimizations
+// This version should be faster for small matrix size
+template<typename MatrixType>
+void upperbidiagonalization_inplace_unblocked(MatrixType& mat,
+                                              typename MatrixType::RealScalar *diagonal,
+                                              typename MatrixType::RealScalar *upper_diagonal,
+                                              typename MatrixType::Scalar* tempData = 0)
+{
+  typedef typename MatrixType::Scalar Scalar;
+
+  Index rows = mat.rows();
+  Index cols = mat.cols();
+
+  typedef Matrix<Scalar,Dynamic,1,ColMajor,MatrixType::MaxRowsAtCompileTime,1> TempType;
+  TempType tempVector;
+  if(tempData==0)
+  {
+    tempVector.resize(rows);
+    tempData = tempVector.data();
+  }
+
+  for (Index k = 0; /* breaks at k==cols-1 below */ ; ++k)
+  {
+    Index remainingRows = rows - k;
+    Index remainingCols = cols - k - 1;
+
+    // construct left householder transform in-place in A
+    mat.col(k).tail(remainingRows)
+       .makeHouseholderInPlace(mat.coeffRef(k,k), diagonal[k]);
+    // apply householder transform to remaining part of A on the left
+    mat.bottomRightCorner(remainingRows, remainingCols)
+       .applyHouseholderOnTheLeft(mat.col(k).tail(remainingRows-1), mat.coeff(k,k), tempData);
+
+    if(k == cols-1) break;
+
+    // construct right householder transform in-place in mat
+    mat.row(k).tail(remainingCols)
+       .makeHouseholderInPlace(mat.coeffRef(k,k+1), upper_diagonal[k]);
+    // apply householder transform to remaining part of mat on the left
+    mat.bottomRightCorner(remainingRows-1, remainingCols)
+       .applyHouseholderOnTheRight(mat.row(k).tail(remainingCols-1).transpose(), mat.coeff(k,k+1), tempData);
+  }
+}
+
+/** \internal
+  * Helper routine for the block reduction to upper bidiagonal form.
+  *
+  * Let's partition the matrix A:
+  * 
+  *      | A00 A01 |
+  *  A = |         |
+  *      | A10 A11 |
+  *
+  * This function reduces to bidiagonal form the left \c rows x \a blockSize vertical panel [A00/A10]
+  * and the \a blockSize x \c cols horizontal panel [A00 A01] of the matrix \a A. The bottom-right block A11
+  * is updated using matrix-matrix products:
+  *   A22 -= V * Y^T - X * U^T
+  * where V and U contains the left and right Householder vectors. U and V are stored in A10, and A01
+  * respectively, and the update matrices X and Y are computed during the reduction.
+  * 
+  */
+template<typename MatrixType>
+void upperbidiagonalization_blocked_helper(MatrixType& A,
+                                           typename MatrixType::RealScalar *diagonal,
+                                           typename MatrixType::RealScalar *upper_diagonal,
+                                           Index bs,
+                                           Ref<Matrix<typename MatrixType::Scalar, Dynamic, Dynamic,
+                                                      traits<MatrixType>::Flags & RowMajorBit> > X,
+                                           Ref<Matrix<typename MatrixType::Scalar, Dynamic, Dynamic,
+                                                      traits<MatrixType>::Flags & RowMajorBit> > Y)
+{
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef typename NumTraits<RealScalar>::Literal Literal;
+  enum { StorageOrder = traits<MatrixType>::Flags & RowMajorBit };
+  typedef InnerStride<int(StorageOrder) == int(ColMajor) ? 1 : Dynamic> ColInnerStride;
+  typedef InnerStride<int(StorageOrder) == int(ColMajor) ? Dynamic : 1> RowInnerStride;
+  typedef Ref<Matrix<Scalar, Dynamic, 1>, 0, ColInnerStride>    SubColumnType;
+  typedef Ref<Matrix<Scalar, 1, Dynamic>, 0, RowInnerStride>    SubRowType;
+  typedef Ref<Matrix<Scalar, Dynamic, Dynamic, StorageOrder > > SubMatType;
+  
+  Index brows = A.rows();
+  Index bcols = A.cols();
+
+  Scalar tau_u, tau_u_prev(0), tau_v;
+
+  for(Index k = 0; k < bs; ++k)
+  {
+    Index remainingRows = brows - k;
+    Index remainingCols = bcols - k - 1;
+
+    SubMatType X_k1( X.block(k,0, remainingRows,k) );
+    SubMatType V_k1( A.block(k,0, remainingRows,k) );
+
+    // 1 - update the k-th column of A
+    SubColumnType v_k = A.col(k).tail(remainingRows);
+          v_k -= V_k1 * Y.row(k).head(k).adjoint();
+    if(k) v_k -= X_k1 * A.col(k).head(k);
+    
+    // 2 - construct left Householder transform in-place
+    v_k.makeHouseholderInPlace(tau_v, diagonal[k]);
+       
+    if(k+1<bcols)
+    {
+      SubMatType Y_k  ( Y.block(k+1,0, remainingCols, k+1) );
+      SubMatType U_k1 ( A.block(0,k+1, k,remainingCols) );
+      
+      // this eases the application of Householder transforAions
+      // A(k,k) will store tau_v later
+      A(k,k) = Scalar(1);
+
+      // 3 - Compute y_k^T = tau_v * ( A^T*v_k - Y_k-1*V_k-1^T*v_k - U_k-1*X_k-1^T*v_k )
+      {
+        SubColumnType y_k( Y.col(k).tail(remainingCols) );
+        
+        // let's use the begining of column k of Y as a temporary vector
+        SubColumnType tmp( Y.col(k).head(k) );
+        y_k.noalias()  = A.block(k,k+1, remainingRows,remainingCols).adjoint() * v_k; // bottleneck
+        tmp.noalias()  = V_k1.adjoint()  * v_k;
+        y_k.noalias() -= Y_k.leftCols(k) * tmp;
+        tmp.noalias()  = X_k1.adjoint()  * v_k;
+        y_k.noalias() -= U_k1.adjoint()  * tmp;
+        y_k *= numext::conj(tau_v);
+      }
+
+      // 4 - update k-th row of A (it will become u_k)
+      SubRowType u_k( A.row(k).tail(remainingCols) );
+      u_k = u_k.conjugate();
+      {
+        u_k -= Y_k * A.row(k).head(k+1).adjoint();
+        if(k) u_k -= U_k1.adjoint() * X.row(k).head(k).adjoint();
+      }
+
+      // 5 - construct right Householder transform in-place
+      u_k.makeHouseholderInPlace(tau_u, upper_diagonal[k]);
+
+      // this eases the application of Householder transformations
+      // A(k,k+1) will store tau_u later
+      A(k,k+1) = Scalar(1);
+
+      // 6 - Compute x_k = tau_u * ( A*u_k - X_k-1*U_k-1^T*u_k - V_k*Y_k^T*u_k )
+      {
+        SubColumnType x_k ( X.col(k).tail(remainingRows-1) );
+        
+        // let's use the begining of column k of X as a temporary vectors
+        // note that tmp0 and tmp1 overlaps
+        SubColumnType tmp0 ( X.col(k).head(k) ),
+                      tmp1 ( X.col(k).head(k+1) );
+                    
+        x_k.noalias()   = A.block(k+1,k+1, remainingRows-1,remainingCols) * u_k.transpose(); // bottleneck
+        tmp0.noalias()  = U_k1 * u_k.transpose();
+        x_k.noalias()  -= X_k1.bottomRows(remainingRows-1) * tmp0;
+        tmp1.noalias()  = Y_k.adjoint() * u_k.transpose();
+        x_k.noalias()  -= A.block(k+1,0, remainingRows-1,k+1) * tmp1;
+        x_k *= numext::conj(tau_u);
+        tau_u = numext::conj(tau_u);
+        u_k = u_k.conjugate();
+      }
+
+      if(k>0) A.coeffRef(k-1,k) = tau_u_prev;
+      tau_u_prev = tau_u;
+    }
+    else
+      A.coeffRef(k-1,k) = tau_u_prev;
+
+    A.coeffRef(k,k) = tau_v;
+  }
+  
+  if(bs<bcols)
+    A.coeffRef(bs-1,bs) = tau_u_prev;
+
+  // update A22
+  if(bcols>bs && brows>bs)
+  {
+    SubMatType A11( A.bottomRightCorner(brows-bs,bcols-bs) );
+    SubMatType A10( A.block(bs,0, brows-bs,bs) );
+    SubMatType A01( A.block(0,bs, bs,bcols-bs) );
+    Scalar tmp = A01(bs-1,0);
+    A01(bs-1,0) = Literal(1);
+    A11.noalias() -= A10 * Y.topLeftCorner(bcols,bs).bottomRows(bcols-bs).adjoint();
+    A11.noalias() -= X.topLeftCorner(brows,bs).bottomRows(brows-bs) * A01;
+    A01(bs-1,0) = tmp;
+  }
+}
+
+/** \internal
+  *
+  * Implementation of a block-bidiagonal reduction.
+  * It is based on the following paper:
+  *   The Design of a Parallel Dense Linear Algebra Software Library: Reduction to Hessenberg, Tridiagonal, and Bidiagonal Form.
+  *   by Jaeyoung Choi, Jack J. Dongarra, David W. Walker. (1995)
+  *   section 3.3
+  */
+template<typename MatrixType, typename BidiagType>
+void upperbidiagonalization_inplace_blocked(MatrixType& A, BidiagType& bidiagonal,
+                                            Index maxBlockSize=32,
+                                            typename MatrixType::Scalar* /*tempData*/ = 0)
+{
+  typedef typename MatrixType::Scalar Scalar;
+  typedef Block<MatrixType,Dynamic,Dynamic> BlockType;
+
+  Index rows = A.rows();
+  Index cols = A.cols();
+  Index size = (std::min)(rows, cols);
+
+  // X and Y are work space
+  enum { StorageOrder = traits<MatrixType>::Flags & RowMajorBit };
+  Matrix<Scalar,
+         MatrixType::RowsAtCompileTime,
+         Dynamic,
+         StorageOrder,
+         MatrixType::MaxRowsAtCompileTime> X(rows,maxBlockSize);
+  Matrix<Scalar,
+         MatrixType::ColsAtCompileTime,
+         Dynamic,
+         StorageOrder,
+         MatrixType::MaxColsAtCompileTime> Y(cols,maxBlockSize);
+  Index blockSize = (std::min)(maxBlockSize,size);
+
+  Index k = 0;
+  for(k = 0; k < size; k += blockSize)
+  {
+    Index bs = (std::min)(size-k,blockSize);  // actual size of the block
+    Index brows = rows - k;                   // rows of the block
+    Index bcols = cols - k;                   // columns of the block
+
+    // partition the matrix A:
+    // 
+    //      | A00 A01 A02 |
+    //      |             |
+    // A  = | A10 A11 A12 |
+    //      |             |
+    //      | A20 A21 A22 |
+    //
+    // where A11 is a bs x bs diagonal block,
+    // and let:
+    //      | A11 A12 |
+    //  B = |         |
+    //      | A21 A22 |
+
+    BlockType B = A.block(k,k,brows,bcols);
+    
+    // This stage performs the bidiagonalization of A11, A21, A12, and updating of A22.
+    // Finally, the algorithm continue on the updated A22.
+    //
+    // However, if B is too small, or A22 empty, then let's use an unblocked strategy
+    if(k+bs==cols || bcols<48) // somewhat arbitrary threshold
+    {
+      upperbidiagonalization_inplace_unblocked(B,
+                                               &(bidiagonal.template diagonal<0>().coeffRef(k)),
+                                               &(bidiagonal.template diagonal<1>().coeffRef(k)),
+                                               X.data()
+                                              );
+      break; // We're done
+    }
+    else
+    {
+      upperbidiagonalization_blocked_helper<BlockType>( B,
+                                                        &(bidiagonal.template diagonal<0>().coeffRef(k)),
+                                                        &(bidiagonal.template diagonal<1>().coeffRef(k)),
+                                                        bs,
+                                                        X.topLeftCorner(brows,bs),
+                                                        Y.topLeftCorner(bcols,bs)
+                                                      );
+    }
+  }
+}
+
+template<typename _MatrixType>
+UpperBidiagonalization<_MatrixType>& UpperBidiagonalization<_MatrixType>::computeUnblocked(const _MatrixType& matrix)
+{
+  Index rows = matrix.rows();
+  Index cols = matrix.cols();
+  EIGEN_ONLY_USED_FOR_DEBUG(cols);
+
+  eigen_assert(rows >= cols && "UpperBidiagonalization is only for Arices satisfying rows>=cols.");
+
+  m_householder = matrix;
+
+  ColVectorType temp(rows);
+
+  upperbidiagonalization_inplace_unblocked(m_householder,
+                                           &(m_bidiagonal.template diagonal<0>().coeffRef(0)),
+                                           &(m_bidiagonal.template diagonal<1>().coeffRef(0)),
+                                           temp.data());
+
+  m_isInitialized = true;
+  return *this;
+}
+
+template<typename _MatrixType>
+UpperBidiagonalization<_MatrixType>& UpperBidiagonalization<_MatrixType>::compute(const _MatrixType& matrix)
+{
+  Index rows = matrix.rows();
+  Index cols = matrix.cols();
+  EIGEN_ONLY_USED_FOR_DEBUG(rows);
+  EIGEN_ONLY_USED_FOR_DEBUG(cols);
+
+  eigen_assert(rows >= cols && "UpperBidiagonalization is only for Arices satisfying rows>=cols.");
+
+  m_householder = matrix;
+  upperbidiagonalization_inplace_blocked(m_householder, m_bidiagonal);
+            
+  m_isInitialized = true;
+  return *this;
+}
+
+#if 0
+/** \return the Householder QR decomposition of \c *this.
+  *
+  * \sa class Bidiagonalization
+  */
+template<typename Derived>
+const UpperBidiagonalization<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::bidiagonalization() const
+{
+  return UpperBidiagonalization<PlainObject>(eval());
+}
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_BIDIAGONALIZATION_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCholesky/SimplicialCholesky.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCholesky/SimplicialCholesky.h
new file mode 100644
index 00000000..2907f652
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCholesky/SimplicialCholesky.h
@@ -0,0 +1,689 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2012 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SIMPLICIAL_CHOLESKY_H
+#define EIGEN_SIMPLICIAL_CHOLESKY_H
+
+namespace Eigen { 
+
+enum SimplicialCholeskyMode {
+  SimplicialCholeskyLLT,
+  SimplicialCholeskyLDLT
+};
+
+namespace internal {
+  template<typename CholMatrixType, typename InputMatrixType>
+  struct simplicial_cholesky_grab_input {
+    typedef CholMatrixType const * ConstCholMatrixPtr;
+    static void run(const InputMatrixType& input, ConstCholMatrixPtr &pmat, CholMatrixType &tmp)
+    {
+      tmp = input;
+      pmat = &tmp;
+    }
+  };
+  
+  template<typename MatrixType>
+  struct simplicial_cholesky_grab_input<MatrixType,MatrixType> {
+    typedef MatrixType const * ConstMatrixPtr;
+    static void run(const MatrixType& input, ConstMatrixPtr &pmat, MatrixType &/*tmp*/)
+    {
+      pmat = &input;
+    }
+  };
+} // end namespace internal
+
+/** \ingroup SparseCholesky_Module
+  * \brief A base class for direct sparse Cholesky factorizations
+  *
+  * This is a base class for LL^T and LDL^T Cholesky factorizations of sparse matrices that are
+  * selfadjoint and positive definite. These factorizations allow for solving A.X = B where
+  * X and B can be either dense or sparse.
+  * 
+  * In order to reduce the fill-in, a symmetric permutation P is applied prior to the factorization
+  * such that the factorized matrix is P A P^-1.
+  *
+  * \tparam Derived the type of the derived class, that is the actual factorization type.
+  *
+  */
+template<typename Derived>
+class SimplicialCholeskyBase : public SparseSolverBase<Derived>
+{
+    typedef SparseSolverBase<Derived> Base;
+    using Base::m_isInitialized;
+    
+  public:
+    typedef typename internal::traits<Derived>::MatrixType MatrixType;
+    typedef typename internal::traits<Derived>::OrderingType OrderingType;
+    enum { UpLo = internal::traits<Derived>::UpLo };
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef SparseMatrix<Scalar,ColMajor,StorageIndex> CholMatrixType;
+    typedef CholMatrixType const * ConstCholMatrixPtr;
+    typedef Matrix<Scalar,Dynamic,1> VectorType;
+    typedef Matrix<StorageIndex,Dynamic,1> VectorI;
+
+    enum {
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+
+  public:
+    
+    using Base::derived;
+
+    /** Default constructor */
+    SimplicialCholeskyBase()
+      : m_info(Success), m_shiftOffset(0), m_shiftScale(1)
+    {}
+
+    explicit SimplicialCholeskyBase(const MatrixType& matrix)
+      : m_info(Success), m_shiftOffset(0), m_shiftScale(1)
+    {
+      derived().compute(matrix);
+    }
+
+    ~SimplicialCholeskyBase()
+    {
+    }
+
+    Derived& derived() { return *static_cast<Derived*>(this); }
+    const Derived& derived() const { return *static_cast<const Derived*>(this); }
+    
+    inline Index cols() const { return m_matrix.cols(); }
+    inline Index rows() const { return m_matrix.rows(); }
+    
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was succesful,
+      *          \c NumericalIssue if the matrix.appears to be negative.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_info;
+    }
+    
+    /** \returns the permutation P
+      * \sa permutationPinv() */
+    const PermutationMatrix<Dynamic,Dynamic,StorageIndex>& permutationP() const
+    { return m_P; }
+    
+    /** \returns the inverse P^-1 of the permutation P
+      * \sa permutationP() */
+    const PermutationMatrix<Dynamic,Dynamic,StorageIndex>& permutationPinv() const
+    { return m_Pinv; }
+
+    /** Sets the shift parameters that will be used to adjust the diagonal coefficients during the numerical factorization.
+      *
+      * During the numerical factorization, the diagonal coefficients are transformed by the following linear model:\n
+      * \c d_ii = \a offset + \a scale * \c d_ii
+      *
+      * The default is the identity transformation with \a offset=0, and \a scale=1.
+      *
+      * \returns a reference to \c *this.
+      */
+    Derived& setShift(const RealScalar& offset, const RealScalar& scale = 1)
+    {
+      m_shiftOffset = offset;
+      m_shiftScale = scale;
+      return derived();
+    }
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** \internal */
+    template<typename Stream>
+    void dumpMemory(Stream& s)
+    {
+      int total = 0;
+      s << "  L:        " << ((total+=(m_matrix.cols()+1) * sizeof(int) + m_matrix.nonZeros()*(sizeof(int)+sizeof(Scalar))) >> 20) << "Mb" << "\n";
+      s << "  diag:     " << ((total+=m_diag.size() * sizeof(Scalar)) >> 20) << "Mb" << "\n";
+      s << "  tree:     " << ((total+=m_parent.size() * sizeof(int)) >> 20) << "Mb" << "\n";
+      s << "  nonzeros: " << ((total+=m_nonZerosPerCol.size() * sizeof(int)) >> 20) << "Mb" << "\n";
+      s << "  perm:     " << ((total+=m_P.size() * sizeof(int)) >> 20) << "Mb" << "\n";
+      s << "  perm^-1:  " << ((total+=m_Pinv.size() * sizeof(int)) >> 20) << "Mb" << "\n";
+      s << "  TOTAL:    " << (total>> 20) << "Mb" << "\n";
+    }
+
+    /** \internal */
+    template<typename Rhs,typename Dest>
+    void _solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &dest) const
+    {
+      eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or symbolic()/numeric()");
+      eigen_assert(m_matrix.rows()==b.rows());
+
+      if(m_info!=Success)
+        return;
+
+      if(m_P.size()>0)
+        dest = m_P * b;
+      else
+        dest = b;
+
+      if(m_matrix.nonZeros()>0) // otherwise L==I
+        derived().matrixL().solveInPlace(dest);
+
+      if(m_diag.size()>0)
+        dest = m_diag.asDiagonal().inverse() * dest;
+
+      if (m_matrix.nonZeros()>0) // otherwise U==I
+        derived().matrixU().solveInPlace(dest);
+
+      if(m_P.size()>0)
+        dest = m_Pinv * dest;
+    }
+    
+    template<typename Rhs,typename Dest>
+    void _solve_impl(const SparseMatrixBase<Rhs> &b, SparseMatrixBase<Dest> &dest) const
+    {
+      internal::solve_sparse_through_dense_panels(derived(), b, dest);
+    }
+
+#endif // EIGEN_PARSED_BY_DOXYGEN
+
+  protected:
+    
+    /** Computes the sparse Cholesky decomposition of \a matrix */
+    template<bool DoLDLT>
+    void compute(const MatrixType& matrix)
+    {
+      eigen_assert(matrix.rows()==matrix.cols());
+      Index size = matrix.cols();
+      CholMatrixType tmp(size,size);
+      ConstCholMatrixPtr pmat;
+      ordering(matrix, pmat, tmp);
+      analyzePattern_preordered(*pmat, DoLDLT);
+      factorize_preordered<DoLDLT>(*pmat);
+    }
+    
+    template<bool DoLDLT>
+    void factorize(const MatrixType& a)
+    {
+      eigen_assert(a.rows()==a.cols());
+      Index size = a.cols();
+      CholMatrixType tmp(size,size);
+      ConstCholMatrixPtr pmat;
+      
+      if(m_P.size()==0 && (UpLo&Upper)==Upper)
+      {
+        // If there is no ordering, try to directly use the input matrix without any copy
+        internal::simplicial_cholesky_grab_input<CholMatrixType,MatrixType>::run(a, pmat, tmp);
+      }
+      else
+      {
+        tmp.template selfadjointView<Upper>() = a.template selfadjointView<UpLo>().twistedBy(m_P);
+        pmat = &tmp;
+      }
+      
+      factorize_preordered<DoLDLT>(*pmat);
+    }
+
+    template<bool DoLDLT>
+    void factorize_preordered(const CholMatrixType& a);
+
+    void analyzePattern(const MatrixType& a, bool doLDLT)
+    {
+      eigen_assert(a.rows()==a.cols());
+      Index size = a.cols();
+      CholMatrixType tmp(size,size);
+      ConstCholMatrixPtr pmat;
+      ordering(a, pmat, tmp);
+      analyzePattern_preordered(*pmat,doLDLT);
+    }
+    void analyzePattern_preordered(const CholMatrixType& a, bool doLDLT);
+    
+    void ordering(const MatrixType& a, ConstCholMatrixPtr &pmat, CholMatrixType& ap);
+
+    /** keeps off-diagonal entries; drops diagonal entries */
+    struct keep_diag {
+      inline bool operator() (const Index& row, const Index& col, const Scalar&) const
+      {
+        return row!=col;
+      }
+    };
+
+    mutable ComputationInfo m_info;
+    bool m_factorizationIsOk;
+    bool m_analysisIsOk;
+    
+    CholMatrixType m_matrix;
+    VectorType m_diag;                                // the diagonal coefficients (LDLT mode)
+    VectorI m_parent;                                 // elimination tree
+    VectorI m_nonZerosPerCol;
+    PermutationMatrix<Dynamic,Dynamic,StorageIndex> m_P;     // the permutation
+    PermutationMatrix<Dynamic,Dynamic,StorageIndex> m_Pinv;  // the inverse permutation
+
+    RealScalar m_shiftOffset;
+    RealScalar m_shiftScale;
+};
+
+template<typename _MatrixType, int _UpLo = Lower, typename _Ordering = AMDOrdering<typename _MatrixType::StorageIndex> > class SimplicialLLT;
+template<typename _MatrixType, int _UpLo = Lower, typename _Ordering = AMDOrdering<typename _MatrixType::StorageIndex> > class SimplicialLDLT;
+template<typename _MatrixType, int _UpLo = Lower, typename _Ordering = AMDOrdering<typename _MatrixType::StorageIndex> > class SimplicialCholesky;
+
+namespace internal {
+
+template<typename _MatrixType, int _UpLo, typename _Ordering> struct traits<SimplicialLLT<_MatrixType,_UpLo,_Ordering> >
+{
+  typedef _MatrixType MatrixType;
+  typedef _Ordering OrderingType;
+  enum { UpLo = _UpLo };
+  typedef typename MatrixType::Scalar                         Scalar;
+  typedef typename MatrixType::StorageIndex                   StorageIndex;
+  typedef SparseMatrix<Scalar, ColMajor, StorageIndex>        CholMatrixType;
+  typedef TriangularView<const CholMatrixType, Eigen::Lower>  MatrixL;
+  typedef TriangularView<const typename CholMatrixType::AdjointReturnType, Eigen::Upper>   MatrixU;
+  static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); }
+  static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoint()); }
+};
+
+template<typename _MatrixType,int _UpLo, typename _Ordering> struct traits<SimplicialLDLT<_MatrixType,_UpLo,_Ordering> >
+{
+  typedef _MatrixType MatrixType;
+  typedef _Ordering OrderingType;
+  enum { UpLo = _UpLo };
+  typedef typename MatrixType::Scalar                             Scalar;
+  typedef typename MatrixType::StorageIndex                       StorageIndex;
+  typedef SparseMatrix<Scalar, ColMajor, StorageIndex>            CholMatrixType;
+  typedef TriangularView<const CholMatrixType, Eigen::UnitLower>  MatrixL;
+  typedef TriangularView<const typename CholMatrixType::AdjointReturnType, Eigen::UnitUpper> MatrixU;
+  static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); }
+  static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoint()); }
+};
+
+template<typename _MatrixType, int _UpLo, typename _Ordering> struct traits<SimplicialCholesky<_MatrixType,_UpLo,_Ordering> >
+{
+  typedef _MatrixType MatrixType;
+  typedef _Ordering OrderingType;
+  enum { UpLo = _UpLo };
+};
+
+}
+
+/** \ingroup SparseCholesky_Module
+  * \class SimplicialLLT
+  * \brief A direct sparse LLT Cholesky factorizations
+  *
+  * This class provides a LL^T Cholesky factorizations of sparse matrices that are
+  * selfadjoint and positive definite. The factorization allows for solving A.X = B where
+  * X and B can be either dense or sparse.
+  * 
+  * In order to reduce the fill-in, a symmetric permutation P is applied prior to the factorization
+  * such that the factorized matrix is P A P^-1.
+  *
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam _UpLo the triangular part that will be used for the computations. It can be Lower
+  *               or Upper. Default is Lower.
+  * \tparam _Ordering The ordering method to use, either AMDOrdering<> or NaturalOrdering<>. Default is AMDOrdering<>
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa class SimplicialLDLT, class AMDOrdering, class NaturalOrdering
+  */
+template<typename _MatrixType, int _UpLo, typename _Ordering>
+    class SimplicialLLT : public SimplicialCholeskyBase<SimplicialLLT<_MatrixType,_UpLo,_Ordering> >
+{
+public:
+    typedef _MatrixType MatrixType;
+    enum { UpLo = _UpLo };
+    typedef SimplicialCholeskyBase<SimplicialLLT> Base;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef SparseMatrix<Scalar,ColMajor,Index> CholMatrixType;
+    typedef Matrix<Scalar,Dynamic,1> VectorType;
+    typedef internal::traits<SimplicialLLT> Traits;
+    typedef typename Traits::MatrixL  MatrixL;
+    typedef typename Traits::MatrixU  MatrixU;
+public:
+    /** Default constructor */
+    SimplicialLLT() : Base() {}
+    /** Constructs and performs the LLT factorization of \a matrix */
+    explicit SimplicialLLT(const MatrixType& matrix)
+        : Base(matrix) {}
+
+    /** \returns an expression of the factor L */
+    inline const MatrixL matrixL() const {
+        eigen_assert(Base::m_factorizationIsOk && "Simplicial LLT not factorized");
+        return Traits::getL(Base::m_matrix);
+    }
+
+    /** \returns an expression of the factor U (= L^*) */
+    inline const MatrixU matrixU() const {
+        eigen_assert(Base::m_factorizationIsOk && "Simplicial LLT not factorized");
+        return Traits::getU(Base::m_matrix);
+    }
+    
+    /** Computes the sparse Cholesky decomposition of \a matrix */
+    SimplicialLLT& compute(const MatrixType& matrix)
+    {
+      Base::template compute<false>(matrix);
+      return *this;
+    }
+
+    /** Performs a symbolic decomposition on the sparcity of \a matrix.
+      *
+      * This function is particularly useful when solving for several problems having the same structure.
+      *
+      * \sa factorize()
+      */
+    void analyzePattern(const MatrixType& a)
+    {
+      Base::analyzePattern(a, false);
+    }
+
+    /** Performs a numeric decomposition of \a matrix
+      *
+      * The given matrix must has the same sparcity than the matrix on which the symbolic decomposition has been performed.
+      *
+      * \sa analyzePattern()
+      */
+    void factorize(const MatrixType& a)
+    {
+      Base::template factorize<false>(a);
+    }
+
+    /** \returns the determinant of the underlying matrix from the current factorization */
+    Scalar determinant() const
+    {
+      Scalar detL = Base::m_matrix.diagonal().prod();
+      return numext::abs2(detL);
+    }
+};
+
+/** \ingroup SparseCholesky_Module
+  * \class SimplicialLDLT
+  * \brief A direct sparse LDLT Cholesky factorizations without square root.
+  *
+  * This class provides a LDL^T Cholesky factorizations without square root of sparse matrices that are
+  * selfadjoint and positive definite. The factorization allows for solving A.X = B where
+  * X and B can be either dense or sparse.
+  * 
+  * In order to reduce the fill-in, a symmetric permutation P is applied prior to the factorization
+  * such that the factorized matrix is P A P^-1.
+  *
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam _UpLo the triangular part that will be used for the computations. It can be Lower
+  *               or Upper. Default is Lower.
+  * \tparam _Ordering The ordering method to use, either AMDOrdering<> or NaturalOrdering<>. Default is AMDOrdering<>
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa class SimplicialLLT, class AMDOrdering, class NaturalOrdering
+  */
+template<typename _MatrixType, int _UpLo, typename _Ordering>
+    class SimplicialLDLT : public SimplicialCholeskyBase<SimplicialLDLT<_MatrixType,_UpLo,_Ordering> >
+{
+public:
+    typedef _MatrixType MatrixType;
+    enum { UpLo = _UpLo };
+    typedef SimplicialCholeskyBase<SimplicialLDLT> Base;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef SparseMatrix<Scalar,ColMajor,StorageIndex> CholMatrixType;
+    typedef Matrix<Scalar,Dynamic,1> VectorType;
+    typedef internal::traits<SimplicialLDLT> Traits;
+    typedef typename Traits::MatrixL  MatrixL;
+    typedef typename Traits::MatrixU  MatrixU;
+public:
+    /** Default constructor */
+    SimplicialLDLT() : Base() {}
+
+    /** Constructs and performs the LLT factorization of \a matrix */
+    explicit SimplicialLDLT(const MatrixType& matrix)
+        : Base(matrix) {}
+
+    /** \returns a vector expression of the diagonal D */
+    inline const VectorType vectorD() const {
+        eigen_assert(Base::m_factorizationIsOk && "Simplicial LDLT not factorized");
+        return Base::m_diag;
+    }
+    /** \returns an expression of the factor L */
+    inline const MatrixL matrixL() const {
+        eigen_assert(Base::m_factorizationIsOk && "Simplicial LDLT not factorized");
+        return Traits::getL(Base::m_matrix);
+    }
+
+    /** \returns an expression of the factor U (= L^*) */
+    inline const MatrixU matrixU() const {
+        eigen_assert(Base::m_factorizationIsOk && "Simplicial LDLT not factorized");
+        return Traits::getU(Base::m_matrix);
+    }
+
+    /** Computes the sparse Cholesky decomposition of \a matrix */
+    SimplicialLDLT& compute(const MatrixType& matrix)
+    {
+      Base::template compute<true>(matrix);
+      return *this;
+    }
+    
+    /** Performs a symbolic decomposition on the sparcity of \a matrix.
+      *
+      * This function is particularly useful when solving for several problems having the same structure.
+      *
+      * \sa factorize()
+      */
+    void analyzePattern(const MatrixType& a)
+    {
+      Base::analyzePattern(a, true);
+    }
+
+    /** Performs a numeric decomposition of \a matrix
+      *
+      * The given matrix must has the same sparcity than the matrix on which the symbolic decomposition has been performed.
+      *
+      * \sa analyzePattern()
+      */
+    void factorize(const MatrixType& a)
+    {
+      Base::template factorize<true>(a);
+    }
+
+    /** \returns the determinant of the underlying matrix from the current factorization */
+    Scalar determinant() const
+    {
+      return Base::m_diag.prod();
+    }
+};
+
+/** \deprecated use SimplicialLDLT or class SimplicialLLT
+  * \ingroup SparseCholesky_Module
+  * \class SimplicialCholesky
+  *
+  * \sa class SimplicialLDLT, class SimplicialLLT
+  */
+template<typename _MatrixType, int _UpLo, typename _Ordering>
+    class SimplicialCholesky : public SimplicialCholeskyBase<SimplicialCholesky<_MatrixType,_UpLo,_Ordering> >
+{
+public:
+    typedef _MatrixType MatrixType;
+    enum { UpLo = _UpLo };
+    typedef SimplicialCholeskyBase<SimplicialCholesky> Base;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef SparseMatrix<Scalar,ColMajor,StorageIndex> CholMatrixType;
+    typedef Matrix<Scalar,Dynamic,1> VectorType;
+    typedef internal::traits<SimplicialCholesky> Traits;
+    typedef internal::traits<SimplicialLDLT<MatrixType,UpLo> > LDLTTraits;
+    typedef internal::traits<SimplicialLLT<MatrixType,UpLo>  > LLTTraits;
+  public:
+    SimplicialCholesky() : Base(), m_LDLT(true) {}
+
+    explicit SimplicialCholesky(const MatrixType& matrix)
+      : Base(), m_LDLT(true)
+    {
+      compute(matrix);
+    }
+
+    SimplicialCholesky& setMode(SimplicialCholeskyMode mode)
+    {
+      switch(mode)
+      {
+      case SimplicialCholeskyLLT:
+        m_LDLT = false;
+        break;
+      case SimplicialCholeskyLDLT:
+        m_LDLT = true;
+        break;
+      default:
+        break;
+      }
+
+      return *this;
+    }
+
+    inline const VectorType vectorD() const {
+        eigen_assert(Base::m_factorizationIsOk && "Simplicial Cholesky not factorized");
+        return Base::m_diag;
+    }
+    inline const CholMatrixType rawMatrix() const {
+        eigen_assert(Base::m_factorizationIsOk && "Simplicial Cholesky not factorized");
+        return Base::m_matrix;
+    }
+    
+    /** Computes the sparse Cholesky decomposition of \a matrix */
+    SimplicialCholesky& compute(const MatrixType& matrix)
+    {
+      if(m_LDLT)
+        Base::template compute<true>(matrix);
+      else
+        Base::template compute<false>(matrix);
+      return *this;
+    }
+
+    /** Performs a symbolic decomposition on the sparcity of \a matrix.
+      *
+      * This function is particularly useful when solving for several problems having the same structure.
+      *
+      * \sa factorize()
+      */
+    void analyzePattern(const MatrixType& a)
+    {
+      Base::analyzePattern(a, m_LDLT);
+    }
+
+    /** Performs a numeric decomposition of \a matrix
+      *
+      * The given matrix must has the same sparcity than the matrix on which the symbolic decomposition has been performed.
+      *
+      * \sa analyzePattern()
+      */
+    void factorize(const MatrixType& a)
+    {
+      if(m_LDLT)
+        Base::template factorize<true>(a);
+      else
+        Base::template factorize<false>(a);
+    }
+
+    /** \internal */
+    template<typename Rhs,typename Dest>
+    void _solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &dest) const
+    {
+      eigen_assert(Base::m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or symbolic()/numeric()");
+      eigen_assert(Base::m_matrix.rows()==b.rows());
+
+      if(Base::m_info!=Success)
+        return;
+
+      if(Base::m_P.size()>0)
+        dest = Base::m_P * b;
+      else
+        dest = b;
+
+      if(Base::m_matrix.nonZeros()>0) // otherwise L==I
+      {
+        if(m_LDLT)
+          LDLTTraits::getL(Base::m_matrix).solveInPlace(dest);
+        else
+          LLTTraits::getL(Base::m_matrix).solveInPlace(dest);
+      }
+
+      if(Base::m_diag.size()>0)
+        dest = Base::m_diag.asDiagonal().inverse() * dest;
+
+      if (Base::m_matrix.nonZeros()>0) // otherwise I==I
+      {
+        if(m_LDLT)
+          LDLTTraits::getU(Base::m_matrix).solveInPlace(dest);
+        else
+          LLTTraits::getU(Base::m_matrix).solveInPlace(dest);
+      }
+
+      if(Base::m_P.size()>0)
+        dest = Base::m_Pinv * dest;
+    }
+    
+    /** \internal */
+    template<typename Rhs,typename Dest>
+    void _solve_impl(const SparseMatrixBase<Rhs> &b, SparseMatrixBase<Dest> &dest) const
+    {
+      internal::solve_sparse_through_dense_panels(*this, b, dest);
+    }
+    
+    Scalar determinant() const
+    {
+      if(m_LDLT)
+      {
+        return Base::m_diag.prod();
+      }
+      else
+      {
+        Scalar detL = Diagonal<const CholMatrixType>(Base::m_matrix).prod();
+        return numext::abs2(detL);
+      }
+    }
+    
+  protected:
+    bool m_LDLT;
+};
+
+template<typename Derived>
+void SimplicialCholeskyBase<Derived>::ordering(const MatrixType& a, ConstCholMatrixPtr &pmat, CholMatrixType& ap)
+{
+  eigen_assert(a.rows()==a.cols());
+  const Index size = a.rows();
+  pmat = &ap;
+  // Note that ordering methods compute the inverse permutation
+  if(!internal::is_same<OrderingType,NaturalOrdering<Index> >::value)
+  {
+    {
+      CholMatrixType C;
+      C = a.template selfadjointView<UpLo>();
+      
+      OrderingType ordering;
+      ordering(C,m_Pinv);
+    }
+
+    if(m_Pinv.size()>0) m_P = m_Pinv.inverse();
+    else                m_P.resize(0);
+    
+    ap.resize(size,size);
+    ap.template selfadjointView<Upper>() = a.template selfadjointView<UpLo>().twistedBy(m_P);
+  }
+  else
+  {
+    m_Pinv.resize(0);
+    m_P.resize(0);
+    if(int(UpLo)==int(Lower) || MatrixType::IsRowMajor)
+    {
+      // we have to transpose the lower part to to the upper one
+      ap.resize(size,size);
+      ap.template selfadjointView<Upper>() = a.template selfadjointView<UpLo>();
+    }
+    else
+      internal::simplicial_cholesky_grab_input<CholMatrixType,MatrixType>::run(a, pmat, ap);
+  }  
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SIMPLICIAL_CHOLESKY_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCholesky/SimplicialCholesky_impl.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCholesky/SimplicialCholesky_impl.h
new file mode 100644
index 00000000..31e06995
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCholesky/SimplicialCholesky_impl.h
@@ -0,0 +1,199 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2012 Gael Guennebaud <gael.guennebaud@inria.fr>
+
+/*
+
+NOTE: thes functions vave been adapted from the LDL library:
+
+LDL Copyright (c) 2005 by Timothy A. Davis.  All Rights Reserved.
+
+LDL License:
+
+    Your use or distribution of LDL or any modified version of
+    LDL implies that you agree to this License.
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
+    USA
+
+    Permission is hereby granted to use or copy this program under the
+    terms of the GNU LGPL, provided that the Copyright, this License,
+    and the Availability of the original version is retained on all copies.
+    User documentation of any code that uses this code or any modified
+    version of this code must cite the Copyright, this License, the
+    Availability note, and "Used by permission." Permission to modify
+    the code and to distribute modified code is granted, provided the
+    Copyright, this License, and the Availability note are retained,
+    and a notice that the code was modified is included.
+ */
+
+#include "../Core/util/NonMPL2.h"
+
+#ifndef EIGEN_SIMPLICIAL_CHOLESKY_IMPL_H
+#define EIGEN_SIMPLICIAL_CHOLESKY_IMPL_H
+
+namespace Eigen {
+
+template<typename Derived>
+void SimplicialCholeskyBase<Derived>::analyzePattern_preordered(const CholMatrixType& ap, bool doLDLT)
+{
+  const StorageIndex size = StorageIndex(ap.rows());
+  m_matrix.resize(size, size);
+  m_parent.resize(size);
+  m_nonZerosPerCol.resize(size);
+
+  ei_declare_aligned_stack_constructed_variable(StorageIndex, tags, size, 0);
+
+  for(StorageIndex k = 0; k < size; ++k)
+  {
+    /* L(k,:) pattern: all nodes reachable in etree from nz in A(0:k-1,k) */
+    m_parent[k] = -1;             /* parent of k is not yet known */
+    tags[k] = k;                  /* mark node k as visited */
+    m_nonZerosPerCol[k] = 0;      /* count of nonzeros in column k of L */
+    for(typename CholMatrixType::InnerIterator it(ap,k); it; ++it)
+    {
+      StorageIndex i = it.index();
+      if(i < k)
+      {
+        /* follow path from i to root of etree, stop at flagged node */
+        for(; tags[i] != k; i = m_parent[i])
+        {
+          /* find parent of i if not yet determined */
+          if (m_parent[i] == -1)
+            m_parent[i] = k;
+          m_nonZerosPerCol[i]++;        /* L (k,i) is nonzero */
+          tags[i] = k;                  /* mark i as visited */
+        }
+      }
+    }
+  }
+
+  /* construct Lp index array from m_nonZerosPerCol column counts */
+  StorageIndex* Lp = m_matrix.outerIndexPtr();
+  Lp[0] = 0;
+  for(StorageIndex k = 0; k < size; ++k)
+    Lp[k+1] = Lp[k] + m_nonZerosPerCol[k] + (doLDLT ? 0 : 1);
+
+  m_matrix.resizeNonZeros(Lp[size]);
+
+  m_isInitialized     = true;
+  m_info              = Success;
+  m_analysisIsOk      = true;
+  m_factorizationIsOk = false;
+}
+
+
+template<typename Derived>
+template<bool DoLDLT>
+void SimplicialCholeskyBase<Derived>::factorize_preordered(const CholMatrixType& ap)
+{
+  using std::sqrt;
+
+  eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
+  eigen_assert(ap.rows()==ap.cols());
+  eigen_assert(m_parent.size()==ap.rows());
+  eigen_assert(m_nonZerosPerCol.size()==ap.rows());
+
+  const StorageIndex size = StorageIndex(ap.rows());
+  const StorageIndex* Lp = m_matrix.outerIndexPtr();
+  StorageIndex* Li = m_matrix.innerIndexPtr();
+  Scalar* Lx = m_matrix.valuePtr();
+
+  ei_declare_aligned_stack_constructed_variable(Scalar, y, size, 0);
+  ei_declare_aligned_stack_constructed_variable(StorageIndex,  pattern, size, 0);
+  ei_declare_aligned_stack_constructed_variable(StorageIndex,  tags, size, 0);
+
+  bool ok = true;
+  m_diag.resize(DoLDLT ? size : 0);
+
+  for(StorageIndex k = 0; k < size; ++k)
+  {
+    // compute nonzero pattern of kth row of L, in topological order
+    y[k] = 0.0;                     // Y(0:k) is now all zero
+    StorageIndex top = size;               // stack for pattern is empty
+    tags[k] = k;                    // mark node k as visited
+    m_nonZerosPerCol[k] = 0;        // count of nonzeros in column k of L
+    for(typename CholMatrixType::InnerIterator it(ap,k); it; ++it)
+    {
+      StorageIndex i = it.index();
+      if(i <= k)
+      {
+        y[i] += numext::conj(it.value());            /* scatter A(i,k) into Y (sum duplicates) */
+        Index len;
+        for(len = 0; tags[i] != k; i = m_parent[i])
+        {
+          pattern[len++] = i;     /* L(k,i) is nonzero */
+          tags[i] = k;            /* mark i as visited */
+        }
+        while(len > 0)
+          pattern[--top] = pattern[--len];
+      }
+    }
+
+    /* compute numerical values kth row of L (a sparse triangular solve) */
+
+    RealScalar d = numext::real(y[k]) * m_shiftScale + m_shiftOffset;    // get D(k,k), apply the shift function, and clear Y(k)
+    y[k] = 0.0;
+    for(; top < size; ++top)
+    {
+      Index i = pattern[top];       /* pattern[top:n-1] is pattern of L(:,k) */
+      Scalar yi = y[i];             /* get and clear Y(i) */
+      y[i] = 0.0;
+
+      /* the nonzero entry L(k,i) */
+      Scalar l_ki;
+      if(DoLDLT)
+        l_ki = yi / m_diag[i];
+      else
+        yi = l_ki = yi / Lx[Lp[i]];
+
+      Index p2 = Lp[i] + m_nonZerosPerCol[i];
+      Index p;
+      for(p = Lp[i] + (DoLDLT ? 0 : 1); p < p2; ++p)
+        y[Li[p]] -= numext::conj(Lx[p]) * yi;
+      d -= numext::real(l_ki * numext::conj(yi));
+      Li[p] = k;                          /* store L(k,i) in column form of L */
+      Lx[p] = l_ki;
+      ++m_nonZerosPerCol[i];              /* increment count of nonzeros in col i */
+    }
+    if(DoLDLT)
+    {
+      m_diag[k] = d;
+      if(d == RealScalar(0))
+      {
+        ok = false;                         /* failure, D(k,k) is zero */
+        break;
+      }
+    }
+    else
+    {
+      Index p = Lp[k] + m_nonZerosPerCol[k]++;
+      Li[p] = k ;                /* store L(k,k) = sqrt (d) in column k */
+      if(d <= RealScalar(0)) {
+        ok = false;              /* failure, matrix is not positive definite */
+        break;
+      }
+      Lx[p] = sqrt(d) ;
+    }
+  }
+
+  m_info = ok ? Success : NumericalIssue;
+  m_factorizationIsOk = true;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SIMPLICIAL_CHOLESKY_IMPL_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/AmbiVector.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/AmbiVector.h
new file mode 100644
index 00000000..e0295f2a
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/AmbiVector.h
@@ -0,0 +1,377 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_AMBIVECTOR_H
+#define EIGEN_AMBIVECTOR_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/** \internal
+  * Hybrid sparse/dense vector class designed for intensive read-write operations.
+  *
+  * See BasicSparseLLT and SparseProduct for usage examples.
+  */
+template<typename _Scalar, typename _StorageIndex>
+class AmbiVector
+{
+  public:
+    typedef _Scalar Scalar;
+    typedef _StorageIndex StorageIndex;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    explicit AmbiVector(Index size)
+      : m_buffer(0), m_zero(0), m_size(0), m_allocatedSize(0), m_allocatedElements(0), m_mode(-1)
+    {
+      resize(size);
+    }
+
+    void init(double estimatedDensity);
+    void init(int mode);
+
+    Index nonZeros() const;
+
+    /** Specifies a sub-vector to work on */
+    void setBounds(Index start, Index end) { m_start = convert_index(start); m_end = convert_index(end); }
+
+    void setZero();
+
+    void restart();
+    Scalar& coeffRef(Index i);
+    Scalar& coeff(Index i);
+
+    class Iterator;
+
+    ~AmbiVector() { delete[] m_buffer; }
+
+    void resize(Index size)
+    {
+      if (m_allocatedSize < size)
+        reallocate(size);
+      m_size = convert_index(size);
+    }
+
+    StorageIndex size() const { return m_size; }
+
+  protected:
+    StorageIndex convert_index(Index idx)
+    {
+      return internal::convert_index<StorageIndex>(idx);
+    }
+
+    void reallocate(Index size)
+    {
+      // if the size of the matrix is not too large, let's allocate a bit more than needed such
+      // that we can handle dense vector even in sparse mode.
+      delete[] m_buffer;
+      if (size<1000)
+      {
+        Index allocSize = (size * sizeof(ListEl) + sizeof(Scalar) - 1)/sizeof(Scalar);
+        m_allocatedElements = convert_index((allocSize*sizeof(Scalar))/sizeof(ListEl));
+        m_buffer = new Scalar[allocSize];
+      }
+      else
+      {
+        m_allocatedElements = convert_index((size*sizeof(Scalar))/sizeof(ListEl));
+        m_buffer = new Scalar[size];
+      }
+      m_size = convert_index(size);
+      m_start = 0;
+      m_end = m_size;
+    }
+
+    void reallocateSparse()
+    {
+      Index copyElements = m_allocatedElements;
+      m_allocatedElements = (std::min)(StorageIndex(m_allocatedElements*1.5),m_size);
+      Index allocSize = m_allocatedElements * sizeof(ListEl);
+      allocSize = (allocSize + sizeof(Scalar) - 1)/sizeof(Scalar);
+      Scalar* newBuffer = new Scalar[allocSize];
+      std::memcpy(newBuffer,  m_buffer,  copyElements * sizeof(ListEl));
+      delete[] m_buffer;
+      m_buffer = newBuffer;
+    }
+
+  protected:
+    // element type of the linked list
+    struct ListEl
+    {
+      StorageIndex next;
+      StorageIndex index;
+      Scalar value;
+    };
+
+    // used to store data in both mode
+    Scalar* m_buffer;
+    Scalar m_zero;
+    StorageIndex m_size;
+    StorageIndex m_start;
+    StorageIndex m_end;
+    StorageIndex m_allocatedSize;
+    StorageIndex m_allocatedElements;
+    StorageIndex m_mode;
+
+    // linked list mode
+    StorageIndex m_llStart;
+    StorageIndex m_llCurrent;
+    StorageIndex m_llSize;
+};
+
+/** \returns the number of non zeros in the current sub vector */
+template<typename _Scalar,typename _StorageIndex>
+Index AmbiVector<_Scalar,_StorageIndex>::nonZeros() const
+{
+  if (m_mode==IsSparse)
+    return m_llSize;
+  else
+    return m_end - m_start;
+}
+
+template<typename _Scalar,typename _StorageIndex>
+void AmbiVector<_Scalar,_StorageIndex>::init(double estimatedDensity)
+{
+  if (estimatedDensity>0.1)
+    init(IsDense);
+  else
+    init(IsSparse);
+}
+
+template<typename _Scalar,typename _StorageIndex>
+void AmbiVector<_Scalar,_StorageIndex>::init(int mode)
+{
+  m_mode = mode;
+  if (m_mode==IsSparse)
+  {
+    m_llSize = 0;
+    m_llStart = -1;
+  }
+}
+
+/** Must be called whenever we might perform a write access
+  * with an index smaller than the previous one.
+  *
+  * Don't worry, this function is extremely cheap.
+  */
+template<typename _Scalar,typename _StorageIndex>
+void AmbiVector<_Scalar,_StorageIndex>::restart()
+{
+  m_llCurrent = m_llStart;
+}
+
+/** Set all coefficients of current subvector to zero */
+template<typename _Scalar,typename _StorageIndex>
+void AmbiVector<_Scalar,_StorageIndex>::setZero()
+{
+  if (m_mode==IsDense)
+  {
+    for (Index i=m_start; i<m_end; ++i)
+      m_buffer[i] = Scalar(0);
+  }
+  else
+  {
+    eigen_assert(m_mode==IsSparse);
+    m_llSize = 0;
+    m_llStart = -1;
+  }
+}
+
+template<typename _Scalar,typename _StorageIndex>
+_Scalar& AmbiVector<_Scalar,_StorageIndex>::coeffRef(Index i)
+{
+  if (m_mode==IsDense)
+    return m_buffer[i];
+  else
+  {
+    ListEl* EIGEN_RESTRICT llElements = reinterpret_cast<ListEl*>(m_buffer);
+    // TODO factorize the following code to reduce code generation
+    eigen_assert(m_mode==IsSparse);
+    if (m_llSize==0)
+    {
+      // this is the first element
+      m_llStart = 0;
+      m_llCurrent = 0;
+      ++m_llSize;
+      llElements[0].value = Scalar(0);
+      llElements[0].index = convert_index(i);
+      llElements[0].next = -1;
+      return llElements[0].value;
+    }
+    else if (i<llElements[m_llStart].index)
+    {
+      // this is going to be the new first element of the list
+      ListEl& el = llElements[m_llSize];
+      el.value = Scalar(0);
+      el.index = convert_index(i);
+      el.next = m_llStart;
+      m_llStart = m_llSize;
+      ++m_llSize;
+      m_llCurrent = m_llStart;
+      return el.value;
+    }
+    else
+    {
+      StorageIndex nextel = llElements[m_llCurrent].next;
+      eigen_assert(i>=llElements[m_llCurrent].index && "you must call restart() before inserting an element with lower or equal index");
+      while (nextel >= 0 && llElements[nextel].index<=i)
+      {
+        m_llCurrent = nextel;
+        nextel = llElements[nextel].next;
+      }
+
+      if (llElements[m_llCurrent].index==i)
+      {
+        // the coefficient already exists and we found it !
+        return llElements[m_llCurrent].value;
+      }
+      else
+      {
+        if (m_llSize>=m_allocatedElements)
+        {
+          reallocateSparse();
+          llElements = reinterpret_cast<ListEl*>(m_buffer);
+        }
+        eigen_internal_assert(m_llSize<m_allocatedElements && "internal error: overflow in sparse mode");
+        // let's insert a new coefficient
+        ListEl& el = llElements[m_llSize];
+        el.value = Scalar(0);
+        el.index = convert_index(i);
+        el.next = llElements[m_llCurrent].next;
+        llElements[m_llCurrent].next = m_llSize;
+        ++m_llSize;
+        return el.value;
+      }
+    }
+  }
+}
+
+template<typename _Scalar,typename _StorageIndex>
+_Scalar& AmbiVector<_Scalar,_StorageIndex>::coeff(Index i)
+{
+  if (m_mode==IsDense)
+    return m_buffer[i];
+  else
+  {
+    ListEl* EIGEN_RESTRICT llElements = reinterpret_cast<ListEl*>(m_buffer);
+    eigen_assert(m_mode==IsSparse);
+    if ((m_llSize==0) || (i<llElements[m_llStart].index))
+    {
+      return m_zero;
+    }
+    else
+    {
+      Index elid = m_llStart;
+      while (elid >= 0 && llElements[elid].index<i)
+        elid = llElements[elid].next;
+
+      if (llElements[elid].index==i)
+        return llElements[m_llCurrent].value;
+      else
+        return m_zero;
+    }
+  }
+}
+
+/** Iterator over the nonzero coefficients */
+template<typename _Scalar,typename _StorageIndex>
+class AmbiVector<_Scalar,_StorageIndex>::Iterator
+{
+  public:
+    typedef _Scalar Scalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    /** Default constructor
+      * \param vec the vector on which we iterate
+      * \param epsilon the minimal value used to prune zero coefficients.
+      * In practice, all coefficients having a magnitude smaller than \a epsilon
+      * are skipped.
+      */
+    explicit Iterator(const AmbiVector& vec, const RealScalar& epsilon = 0)
+      : m_vector(vec)
+    {
+      using std::abs;
+      m_epsilon = epsilon;
+      m_isDense = m_vector.m_mode==IsDense;
+      if (m_isDense)
+      {
+        m_currentEl = 0;   // this is to avoid a compilation warning
+        m_cachedValue = 0; // this is to avoid a compilation warning
+        m_cachedIndex = m_vector.m_start-1;
+        ++(*this);
+      }
+      else
+      {
+        ListEl* EIGEN_RESTRICT llElements = reinterpret_cast<ListEl*>(m_vector.m_buffer);
+        m_currentEl = m_vector.m_llStart;
+        while (m_currentEl>=0 && abs(llElements[m_currentEl].value)<=m_epsilon)
+          m_currentEl = llElements[m_currentEl].next;
+        if (m_currentEl<0)
+        {
+          m_cachedValue = 0; // this is to avoid a compilation warning
+          m_cachedIndex = -1;
+        }
+        else
+        {
+          m_cachedIndex = llElements[m_currentEl].index;
+          m_cachedValue = llElements[m_currentEl].value;
+        }
+      }
+    }
+
+    StorageIndex index() const { return m_cachedIndex; }
+    Scalar value() const { return m_cachedValue; }
+
+    operator bool() const { return m_cachedIndex>=0; }
+
+    Iterator& operator++()
+    {
+      using std::abs;
+      if (m_isDense)
+      {
+        do {
+          ++m_cachedIndex;
+        } while (m_cachedIndex<m_vector.m_end && abs(m_vector.m_buffer[m_cachedIndex])<=m_epsilon);
+        if (m_cachedIndex<m_vector.m_end)
+          m_cachedValue = m_vector.m_buffer[m_cachedIndex];
+        else
+          m_cachedIndex=-1;
+      }
+      else
+      {
+        ListEl* EIGEN_RESTRICT llElements = reinterpret_cast<ListEl*>(m_vector.m_buffer);
+        do {
+          m_currentEl = llElements[m_currentEl].next;
+        } while (m_currentEl>=0 && abs(llElements[m_currentEl].value)<=m_epsilon);
+        if (m_currentEl<0)
+        {
+          m_cachedIndex = -1;
+        }
+        else
+        {
+          m_cachedIndex = llElements[m_currentEl].index;
+          m_cachedValue = llElements[m_currentEl].value;
+        }
+      }
+      return *this;
+    }
+
+  protected:
+    const AmbiVector& m_vector; // the target vector
+    StorageIndex m_currentEl;   // the current element in sparse/linked-list mode
+    RealScalar m_epsilon;       // epsilon used to prune zero coefficients
+    StorageIndex m_cachedIndex; // current coordinate
+    Scalar m_cachedValue;       // current value
+    bool m_isDense;             // mode of the vector
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_AMBIVECTOR_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/CompressedStorage.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/CompressedStorage.h
new file mode 100644
index 00000000..d89fa0da
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/CompressedStorage.h
@@ -0,0 +1,258 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPRESSED_STORAGE_H
+#define EIGEN_COMPRESSED_STORAGE_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/** \internal
+  * Stores a sparse set of values as a list of values and a list of indices.
+  *
+  */
+template<typename _Scalar,typename _StorageIndex>
+class CompressedStorage
+{
+  public:
+
+    typedef _Scalar Scalar;
+    typedef _StorageIndex StorageIndex;
+
+  protected:
+
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  public:
+
+    CompressedStorage()
+      : m_values(0), m_indices(0), m_size(0), m_allocatedSize(0)
+    {}
+
+    explicit CompressedStorage(Index size)
+      : m_values(0), m_indices(0), m_size(0), m_allocatedSize(0)
+    {
+      resize(size);
+    }
+
+    CompressedStorage(const CompressedStorage& other)
+      : m_values(0), m_indices(0), m_size(0), m_allocatedSize(0)
+    {
+      *this = other;
+    }
+
+    CompressedStorage& operator=(const CompressedStorage& other)
+    {
+      resize(other.size());
+      if(other.size()>0)
+      {
+        internal::smart_copy(other.m_values,  other.m_values  + m_size, m_values);
+        internal::smart_copy(other.m_indices, other.m_indices + m_size, m_indices);
+      }
+      return *this;
+    }
+
+    void swap(CompressedStorage& other)
+    {
+      std::swap(m_values, other.m_values);
+      std::swap(m_indices, other.m_indices);
+      std::swap(m_size, other.m_size);
+      std::swap(m_allocatedSize, other.m_allocatedSize);
+    }
+
+    ~CompressedStorage()
+    {
+      delete[] m_values;
+      delete[] m_indices;
+    }
+
+    void reserve(Index size)
+    {
+      Index newAllocatedSize = m_size + size;
+      if (newAllocatedSize > m_allocatedSize)
+        reallocate(newAllocatedSize);
+    }
+
+    void squeeze()
+    {
+      if (m_allocatedSize>m_size)
+        reallocate(m_size);
+    }
+
+    void resize(Index size, double reserveSizeFactor = 0)
+    {
+      if (m_allocatedSize<size)
+      {
+        Index realloc_size = (std::min<Index>)(NumTraits<StorageIndex>::highest(),  size + Index(reserveSizeFactor*double(size)));
+        if(realloc_size<size)
+          internal::throw_std_bad_alloc();
+        reallocate(realloc_size);
+      }
+      m_size = size;
+    }
+
+    void append(const Scalar& v, Index i)
+    {
+      Index id = m_size;
+      resize(m_size+1, 1);
+      m_values[id] = v;
+      m_indices[id] = internal::convert_index<StorageIndex>(i);
+    }
+
+    inline Index size() const { return m_size; }
+    inline Index allocatedSize() const { return m_allocatedSize; }
+    inline void clear() { m_size = 0; }
+
+    const Scalar* valuePtr() const { return m_values; }
+    Scalar* valuePtr() { return m_values; }
+    const StorageIndex* indexPtr() const { return m_indices; }
+    StorageIndex* indexPtr() { return m_indices; }
+
+    inline Scalar& value(Index i) { eigen_internal_assert(m_values!=0); return m_values[i]; }
+    inline const Scalar& value(Index i) const { eigen_internal_assert(m_values!=0); return m_values[i]; }
+
+    inline StorageIndex& index(Index i) { eigen_internal_assert(m_indices!=0); return m_indices[i]; }
+    inline const StorageIndex& index(Index i) const { eigen_internal_assert(m_indices!=0); return m_indices[i]; }
+
+    /** \returns the largest \c k such that for all \c j in [0,k) index[\c j]\<\a key */
+    inline Index searchLowerIndex(Index key) const
+    {
+      return searchLowerIndex(0, m_size, key);
+    }
+
+    /** \returns the largest \c k in [start,end) such that for all \c j in [start,k) index[\c j]\<\a key */
+    inline Index searchLowerIndex(Index start, Index end, Index key) const
+    {
+      while(end>start)
+      {
+        Index mid = (end+start)>>1;
+        if (m_indices[mid]<key)
+          start = mid+1;
+        else
+          end = mid;
+      }
+      return start;
+    }
+
+    /** \returns the stored value at index \a key
+      * If the value does not exist, then the value \a defaultValue is returned without any insertion. */
+    inline Scalar at(Index key, const Scalar& defaultValue = Scalar(0)) const
+    {
+      if (m_size==0)
+        return defaultValue;
+      else if (key==m_indices[m_size-1])
+        return m_values[m_size-1];
+      // ^^  optimization: let's first check if it is the last coefficient
+      // (very common in high level algorithms)
+      const Index id = searchLowerIndex(0,m_size-1,key);
+      return ((id<m_size) && (m_indices[id]==key)) ? m_values[id] : defaultValue;
+    }
+
+    /** Like at(), but the search is performed in the range [start,end) */
+    inline Scalar atInRange(Index start, Index end, Index key, const Scalar &defaultValue = Scalar(0)) const
+    {
+      if (start>=end)
+        return defaultValue;
+      else if (end>start && key==m_indices[end-1])
+        return m_values[end-1];
+      // ^^  optimization: let's first check if it is the last coefficient
+      // (very common in high level algorithms)
+      const Index id = searchLowerIndex(start,end-1,key);
+      return ((id<end) && (m_indices[id]==key)) ? m_values[id] : defaultValue;
+    }
+
+    /** \returns a reference to the value at index \a key
+      * If the value does not exist, then the value \a defaultValue is inserted
+      * such that the keys are sorted. */
+    inline Scalar& atWithInsertion(Index key, const Scalar& defaultValue = Scalar(0))
+    {
+      Index id = searchLowerIndex(0,m_size,key);
+      if (id>=m_size || m_indices[id]!=key)
+      {
+        if (m_allocatedSize<m_size+1)
+        {
+          m_allocatedSize = 2*(m_size+1);
+          internal::scoped_array<Scalar> newValues(m_allocatedSize);
+          internal::scoped_array<StorageIndex> newIndices(m_allocatedSize);
+
+          // copy first chunk
+          internal::smart_copy(m_values,  m_values +id, newValues.ptr());
+          internal::smart_copy(m_indices, m_indices+id, newIndices.ptr());
+
+          // copy the rest
+          if(m_size>id)
+          {
+            internal::smart_copy(m_values +id,  m_values +m_size, newValues.ptr() +id+1);
+            internal::smart_copy(m_indices+id,  m_indices+m_size, newIndices.ptr()+id+1);
+          }
+          std::swap(m_values,newValues.ptr());
+          std::swap(m_indices,newIndices.ptr());
+        }
+        else if(m_size>id)
+        {
+          internal::smart_memmove(m_values +id, m_values +m_size, m_values +id+1);
+          internal::smart_memmove(m_indices+id, m_indices+m_size, m_indices+id+1);
+        }
+        m_size++;
+        m_indices[id] = internal::convert_index<StorageIndex>(key);
+        m_values[id] = defaultValue;
+      }
+      return m_values[id];
+    }
+
+    void prune(const Scalar& reference, const RealScalar& epsilon = NumTraits<RealScalar>::dummy_precision())
+    {
+      Index k = 0;
+      Index n = size();
+      for (Index i=0; i<n; ++i)
+      {
+        if (!internal::isMuchSmallerThan(value(i), reference, epsilon))
+        {
+          value(k) = value(i);
+          index(k) = index(i);
+          ++k;
+        }
+      }
+      resize(k,0);
+    }
+
+  protected:
+
+    inline void reallocate(Index size)
+    {
+      #ifdef EIGEN_SPARSE_COMPRESSED_STORAGE_REALLOCATE_PLUGIN
+        EIGEN_SPARSE_COMPRESSED_STORAGE_REALLOCATE_PLUGIN
+      #endif
+      eigen_internal_assert(size!=m_allocatedSize);
+      internal::scoped_array<Scalar> newValues(size);
+      internal::scoped_array<StorageIndex> newIndices(size);
+      Index copySize = (std::min)(size, m_size);
+      if (copySize>0) {
+        internal::smart_copy(m_values, m_values+copySize, newValues.ptr());
+        internal::smart_copy(m_indices, m_indices+copySize, newIndices.ptr());
+      }
+      std::swap(m_values,newValues.ptr());
+      std::swap(m_indices,newIndices.ptr());
+      m_allocatedSize = size;
+    }
+
+  protected:
+    Scalar* m_values;
+    StorageIndex* m_indices;
+    Index m_size;
+    Index m_allocatedSize;
+
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_COMPRESSED_STORAGE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/ConservativeSparseSparseProduct.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/ConservativeSparseSparseProduct.h
new file mode 100644
index 00000000..9db119b6
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/ConservativeSparseSparseProduct.h
@@ -0,0 +1,352 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CONSERVATIVESPARSESPARSEPRODUCT_H
+#define EIGEN_CONSERVATIVESPARSESPARSEPRODUCT_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename Lhs, typename Rhs, typename ResultType>
+static void conservative_sparse_sparse_product_impl(const Lhs& lhs, const Rhs& rhs, ResultType& res, bool sortedInsertion = false)
+{
+  typedef typename remove_all<Lhs>::type::Scalar LhsScalar;
+  typedef typename remove_all<Rhs>::type::Scalar RhsScalar;
+  typedef typename remove_all<ResultType>::type::Scalar ResScalar;
+
+  // make sure to call innerSize/outerSize since we fake the storage order.
+  Index rows = lhs.innerSize();
+  Index cols = rhs.outerSize();
+  eigen_assert(lhs.outerSize() == rhs.innerSize());
+  
+  ei_declare_aligned_stack_constructed_variable(bool,   mask,     rows, 0);
+  ei_declare_aligned_stack_constructed_variable(ResScalar, values,   rows, 0);
+  ei_declare_aligned_stack_constructed_variable(Index,  indices,  rows, 0);
+  
+  std::memset(mask,0,sizeof(bool)*rows);
+
+  evaluator<Lhs> lhsEval(lhs);
+  evaluator<Rhs> rhsEval(rhs);
+  
+  // estimate the number of non zero entries
+  // given a rhs column containing Y non zeros, we assume that the respective Y columns
+  // of the lhs differs in average of one non zeros, thus the number of non zeros for
+  // the product of a rhs column with the lhs is X+Y where X is the average number of non zero
+  // per column of the lhs.
+  // Therefore, we have nnz(lhs*rhs) = nnz(lhs) + nnz(rhs)
+  Index estimated_nnz_prod = lhsEval.nonZerosEstimate() + rhsEval.nonZerosEstimate();
+
+  res.setZero();
+  res.reserve(Index(estimated_nnz_prod));
+  // we compute each column of the result, one after the other
+  for (Index j=0; j<cols; ++j)
+  {
+
+    res.startVec(j);
+    Index nnz = 0;
+    for (typename evaluator<Rhs>::InnerIterator rhsIt(rhsEval, j); rhsIt; ++rhsIt)
+    {
+      RhsScalar y = rhsIt.value();
+      Index k = rhsIt.index();
+      for (typename evaluator<Lhs>::InnerIterator lhsIt(lhsEval, k); lhsIt; ++lhsIt)
+      {
+        Index i = lhsIt.index();
+        LhsScalar x = lhsIt.value();
+        if(!mask[i])
+        {
+          mask[i] = true;
+          values[i] = x * y;
+          indices[nnz] = i;
+          ++nnz;
+        }
+        else
+          values[i] += x * y;
+      }
+    }
+    if(!sortedInsertion)
+    {
+      // unordered insertion
+      for(Index k=0; k<nnz; ++k)
+      {
+        Index i = indices[k];
+        res.insertBackByOuterInnerUnordered(j,i) = values[i];
+        mask[i] = false;
+      }
+    }
+    else
+    {
+      // alternative ordered insertion code:
+      const Index t200 = rows/11; // 11 == (log2(200)*1.39)
+      const Index t = (rows*100)/139;
+
+      // FIXME reserve nnz non zeros
+      // FIXME implement faster sorting algorithms for very small nnz
+      // if the result is sparse enough => use a quick sort
+      // otherwise => loop through the entire vector
+      // In order to avoid to perform an expensive log2 when the
+      // result is clearly very sparse we use a linear bound up to 200.
+      if((nnz<200 && nnz<t200) || nnz * numext::log2(int(nnz)) < t)
+      {
+        if(nnz>1) std::sort(indices,indices+nnz);
+        for(Index k=0; k<nnz; ++k)
+        {
+          Index i = indices[k];
+          res.insertBackByOuterInner(j,i) = values[i];
+          mask[i] = false;
+        }
+      }
+      else
+      {
+        // dense path
+        for(Index i=0; i<rows; ++i)
+        {
+          if(mask[i])
+          {
+            mask[i] = false;
+            res.insertBackByOuterInner(j,i) = values[i];
+          }
+        }
+      }
+    }
+  }
+  res.finalize();
+}
+
+
+} // end namespace internal
+
+namespace internal {
+
+template<typename Lhs, typename Rhs, typename ResultType,
+  int LhsStorageOrder = (traits<Lhs>::Flags&RowMajorBit) ? RowMajor : ColMajor,
+  int RhsStorageOrder = (traits<Rhs>::Flags&RowMajorBit) ? RowMajor : ColMajor,
+  int ResStorageOrder = (traits<ResultType>::Flags&RowMajorBit) ? RowMajor : ColMajor>
+struct conservative_sparse_sparse_product_selector;
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct conservative_sparse_sparse_product_selector<Lhs,Rhs,ResultType,ColMajor,ColMajor,ColMajor>
+{
+  typedef typename remove_all<Lhs>::type LhsCleaned;
+  typedef typename LhsCleaned::Scalar Scalar;
+
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    typedef SparseMatrix<typename ResultType::Scalar,RowMajor,typename ResultType::StorageIndex> RowMajorMatrix;
+    typedef SparseMatrix<typename ResultType::Scalar,ColMajor,typename ResultType::StorageIndex> ColMajorMatrixAux;
+    typedef typename sparse_eval<ColMajorMatrixAux,ResultType::RowsAtCompileTime,ResultType::ColsAtCompileTime,ColMajorMatrixAux::Flags>::type ColMajorMatrix;
+    
+    // If the result is tall and thin (in the extreme case a column vector)
+    // then it is faster to sort the coefficients inplace instead of transposing twice.
+    // FIXME, the following heuristic is probably not very good.
+    if(lhs.rows()>rhs.cols())
+    {
+      ColMajorMatrix resCol(lhs.rows(),rhs.cols());
+      // perform sorted insertion
+      internal::conservative_sparse_sparse_product_impl<Lhs,Rhs,ColMajorMatrix>(lhs, rhs, resCol, true);
+      res = resCol.markAsRValue();
+    }
+    else
+    {
+      ColMajorMatrixAux resCol(lhs.rows(),rhs.cols());
+      // ressort to transpose to sort the entries
+      internal::conservative_sparse_sparse_product_impl<Lhs,Rhs,ColMajorMatrixAux>(lhs, rhs, resCol, false);
+      RowMajorMatrix resRow(resCol);
+      res = resRow.markAsRValue();
+    }
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct conservative_sparse_sparse_product_selector<Lhs,Rhs,ResultType,RowMajor,ColMajor,ColMajor>
+{
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    typedef SparseMatrix<typename Rhs::Scalar,RowMajor,typename ResultType::StorageIndex> RowMajorRhs;
+    typedef SparseMatrix<typename ResultType::Scalar,RowMajor,typename ResultType::StorageIndex> RowMajorRes;
+    RowMajorRhs rhsRow = rhs;
+    RowMajorRes resRow(lhs.rows(), rhs.cols());
+    internal::conservative_sparse_sparse_product_impl<RowMajorRhs,Lhs,RowMajorRes>(rhsRow, lhs, resRow);
+    res = resRow;
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct conservative_sparse_sparse_product_selector<Lhs,Rhs,ResultType,ColMajor,RowMajor,ColMajor>
+{
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    typedef SparseMatrix<typename Lhs::Scalar,RowMajor,typename ResultType::StorageIndex> RowMajorLhs;
+    typedef SparseMatrix<typename ResultType::Scalar,RowMajor,typename ResultType::StorageIndex> RowMajorRes;
+    RowMajorLhs lhsRow = lhs;
+    RowMajorRes resRow(lhs.rows(), rhs.cols());
+    internal::conservative_sparse_sparse_product_impl<Rhs,RowMajorLhs,RowMajorRes>(rhs, lhsRow, resRow);
+    res = resRow;
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct conservative_sparse_sparse_product_selector<Lhs,Rhs,ResultType,RowMajor,RowMajor,ColMajor>
+{
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    typedef SparseMatrix<typename ResultType::Scalar,RowMajor,typename ResultType::StorageIndex> RowMajorMatrix;
+    RowMajorMatrix resRow(lhs.rows(), rhs.cols());
+    internal::conservative_sparse_sparse_product_impl<Rhs,Lhs,RowMajorMatrix>(rhs, lhs, resRow);
+    res = resRow;
+  }
+};
+
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct conservative_sparse_sparse_product_selector<Lhs,Rhs,ResultType,ColMajor,ColMajor,RowMajor>
+{
+  typedef typename traits<typename remove_all<Lhs>::type>::Scalar Scalar;
+
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    typedef SparseMatrix<typename ResultType::Scalar,ColMajor,typename ResultType::StorageIndex> ColMajorMatrix;
+    ColMajorMatrix resCol(lhs.rows(), rhs.cols());
+    internal::conservative_sparse_sparse_product_impl<Lhs,Rhs,ColMajorMatrix>(lhs, rhs, resCol);
+    res = resCol;
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct conservative_sparse_sparse_product_selector<Lhs,Rhs,ResultType,RowMajor,ColMajor,RowMajor>
+{
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    typedef SparseMatrix<typename Lhs::Scalar,ColMajor,typename ResultType::StorageIndex> ColMajorLhs;
+    typedef SparseMatrix<typename ResultType::Scalar,ColMajor,typename ResultType::StorageIndex> ColMajorRes;
+    ColMajorLhs lhsCol = lhs;
+    ColMajorRes resCol(lhs.rows(), rhs.cols());
+    internal::conservative_sparse_sparse_product_impl<ColMajorLhs,Rhs,ColMajorRes>(lhsCol, rhs, resCol);
+    res = resCol;
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct conservative_sparse_sparse_product_selector<Lhs,Rhs,ResultType,ColMajor,RowMajor,RowMajor>
+{
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    typedef SparseMatrix<typename Rhs::Scalar,ColMajor,typename ResultType::StorageIndex> ColMajorRhs;
+    typedef SparseMatrix<typename ResultType::Scalar,ColMajor,typename ResultType::StorageIndex> ColMajorRes;
+    ColMajorRhs rhsCol = rhs;
+    ColMajorRes resCol(lhs.rows(), rhs.cols());
+    internal::conservative_sparse_sparse_product_impl<Lhs,ColMajorRhs,ColMajorRes>(lhs, rhsCol, resCol);
+    res = resCol;
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct conservative_sparse_sparse_product_selector<Lhs,Rhs,ResultType,RowMajor,RowMajor,RowMajor>
+{
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    typedef SparseMatrix<typename ResultType::Scalar,RowMajor,typename ResultType::StorageIndex> RowMajorMatrix;
+    typedef SparseMatrix<typename ResultType::Scalar,ColMajor,typename ResultType::StorageIndex> ColMajorMatrix;
+    RowMajorMatrix resRow(lhs.rows(),rhs.cols());
+    internal::conservative_sparse_sparse_product_impl<Rhs,Lhs,RowMajorMatrix>(rhs, lhs, resRow);
+    // sort the non zeros:
+    ColMajorMatrix resCol(resRow);
+    res = resCol;
+  }
+};
+
+} // end namespace internal
+
+
+namespace internal {
+
+template<typename Lhs, typename Rhs, typename ResultType>
+static void sparse_sparse_to_dense_product_impl(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+{
+  typedef typename remove_all<Lhs>::type::Scalar LhsScalar;
+  typedef typename remove_all<Rhs>::type::Scalar RhsScalar;
+  Index cols = rhs.outerSize();
+  eigen_assert(lhs.outerSize() == rhs.innerSize());
+
+  evaluator<Lhs> lhsEval(lhs);
+  evaluator<Rhs> rhsEval(rhs);
+
+  for (Index j=0; j<cols; ++j)
+  {
+    for (typename evaluator<Rhs>::InnerIterator rhsIt(rhsEval, j); rhsIt; ++rhsIt)
+    {
+      RhsScalar y = rhsIt.value();
+      Index k = rhsIt.index();
+      for (typename evaluator<Lhs>::InnerIterator lhsIt(lhsEval, k); lhsIt; ++lhsIt)
+      {
+        Index i = lhsIt.index();
+        LhsScalar x = lhsIt.value();
+        res.coeffRef(i,j) += x * y;
+      }
+    }
+  }
+}
+
+
+} // end namespace internal
+
+namespace internal {
+
+template<typename Lhs, typename Rhs, typename ResultType,
+  int LhsStorageOrder = (traits<Lhs>::Flags&RowMajorBit) ? RowMajor : ColMajor,
+  int RhsStorageOrder = (traits<Rhs>::Flags&RowMajorBit) ? RowMajor : ColMajor>
+struct sparse_sparse_to_dense_product_selector;
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_to_dense_product_selector<Lhs,Rhs,ResultType,ColMajor,ColMajor>
+{
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    internal::sparse_sparse_to_dense_product_impl<Lhs,Rhs,ResultType>(lhs, rhs, res);
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_to_dense_product_selector<Lhs,Rhs,ResultType,RowMajor,ColMajor>
+{
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    typedef SparseMatrix<typename Lhs::Scalar,ColMajor,typename ResultType::StorageIndex> ColMajorLhs;
+    ColMajorLhs lhsCol(lhs);
+    internal::sparse_sparse_to_dense_product_impl<ColMajorLhs,Rhs,ResultType>(lhsCol, rhs, res);
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_to_dense_product_selector<Lhs,Rhs,ResultType,ColMajor,RowMajor>
+{
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    typedef SparseMatrix<typename Rhs::Scalar,ColMajor,typename ResultType::StorageIndex> ColMajorRhs;
+    ColMajorRhs rhsCol(rhs);
+    internal::sparse_sparse_to_dense_product_impl<Lhs,ColMajorRhs,ResultType>(lhs, rhsCol, res);
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_to_dense_product_selector<Lhs,Rhs,ResultType,RowMajor,RowMajor>
+{
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    Transpose<ResultType> trRes(res);
+    internal::sparse_sparse_to_dense_product_impl<Rhs,Lhs,Transpose<ResultType> >(rhs, lhs, trRes);
+  }
+};
+
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_CONSERVATIVESPARSESPARSEPRODUCT_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/MappedSparseMatrix.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/MappedSparseMatrix.h
new file mode 100644
index 00000000..67718c85
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/MappedSparseMatrix.h
@@ -0,0 +1,67 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MAPPED_SPARSEMATRIX_H
+#define EIGEN_MAPPED_SPARSEMATRIX_H
+
+namespace Eigen {
+
+/** \deprecated Use Map<SparseMatrix<> >
+  * \class MappedSparseMatrix
+  *
+  * \brief Sparse matrix
+  *
+  * \param _Scalar the scalar type, i.e. the type of the coefficients
+  *
+  * See http://www.netlib.org/linalg/html_templates/node91.html for details on the storage scheme.
+  *
+  */
+namespace internal {
+template<typename _Scalar, int _Flags, typename _StorageIndex>
+struct traits<MappedSparseMatrix<_Scalar, _Flags, _StorageIndex> > : traits<SparseMatrix<_Scalar, _Flags, _StorageIndex> >
+{};
+} // end namespace internal
+
+template<typename _Scalar, int _Flags, typename _StorageIndex>
+class MappedSparseMatrix
+  : public Map<SparseMatrix<_Scalar, _Flags, _StorageIndex> >
+{
+    typedef Map<SparseMatrix<_Scalar, _Flags, _StorageIndex> > Base;
+
+  public:
+    
+    typedef typename Base::StorageIndex StorageIndex;
+    typedef typename Base::Scalar Scalar;
+
+    inline MappedSparseMatrix(Index rows, Index cols, Index nnz, StorageIndex* outerIndexPtr, StorageIndex* innerIndexPtr, Scalar* valuePtr, StorageIndex* innerNonZeroPtr = 0)
+      : Base(rows, cols, nnz, outerIndexPtr, innerIndexPtr, valuePtr, innerNonZeroPtr)
+    {}
+
+    /** Empty destructor */
+    inline ~MappedSparseMatrix() {}
+};
+
+namespace internal {
+
+template<typename _Scalar, int _Options, typename _StorageIndex>
+struct evaluator<MappedSparseMatrix<_Scalar,_Options,_StorageIndex> >
+  : evaluator<SparseCompressedBase<MappedSparseMatrix<_Scalar,_Options,_StorageIndex> > >
+{
+  typedef MappedSparseMatrix<_Scalar,_Options,_StorageIndex> XprType;
+  typedef evaluator<SparseCompressedBase<XprType> > Base;
+  
+  evaluator() : Base() {}
+  explicit evaluator(const XprType &mat) : Base(mat) {}
+};
+
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_MAPPED_SPARSEMATRIX_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseAssign.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseAssign.h
new file mode 100644
index 00000000..11346325
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseAssign.h
@@ -0,0 +1,216 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSEASSIGN_H
+#define EIGEN_SPARSEASSIGN_H
+
+namespace Eigen { 
+
+template<typename Derived>    
+template<typename OtherDerived>
+Derived& SparseMatrixBase<Derived>::operator=(const EigenBase<OtherDerived> &other)
+{
+  internal::call_assignment_no_alias(derived(), other.derived());
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+Derived& SparseMatrixBase<Derived>::operator=(const ReturnByValue<OtherDerived>& other)
+{
+  // TODO use the evaluator mechanism
+  other.evalTo(derived());
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+inline Derived& SparseMatrixBase<Derived>::operator=(const SparseMatrixBase<OtherDerived>& other)
+{
+  // by default sparse evaluation do not alias, so we can safely bypass the generic call_assignment routine
+  internal::Assignment<Derived,OtherDerived,internal::assign_op<Scalar,typename OtherDerived::Scalar> >
+          ::run(derived(), other.derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+template<typename Derived>
+inline Derived& SparseMatrixBase<Derived>::operator=(const Derived& other)
+{
+  internal::call_assignment_no_alias(derived(), other.derived());
+  return derived();
+}
+
+namespace internal {
+
+template<>
+struct storage_kind_to_evaluator_kind<Sparse> {
+  typedef IteratorBased Kind;
+};
+
+template<>
+struct storage_kind_to_shape<Sparse> {
+  typedef SparseShape Shape;
+};
+
+struct Sparse2Sparse {};
+struct Sparse2Dense  {};
+
+template<> struct AssignmentKind<SparseShape, SparseShape>           { typedef Sparse2Sparse Kind; };
+template<> struct AssignmentKind<SparseShape, SparseTriangularShape> { typedef Sparse2Sparse Kind; };
+template<> struct AssignmentKind<DenseShape,  SparseShape>           { typedef Sparse2Dense  Kind; };
+template<> struct AssignmentKind<DenseShape,  SparseTriangularShape> { typedef Sparse2Dense  Kind; };
+
+
+template<typename DstXprType, typename SrcXprType>
+void assign_sparse_to_sparse(DstXprType &dst, const SrcXprType &src)
+{
+  typedef typename DstXprType::Scalar Scalar;
+  typedef internal::evaluator<DstXprType> DstEvaluatorType;
+  typedef internal::evaluator<SrcXprType> SrcEvaluatorType;
+
+  SrcEvaluatorType srcEvaluator(src);
+
+  const bool transpose = (DstEvaluatorType::Flags & RowMajorBit) != (SrcEvaluatorType::Flags & RowMajorBit);
+  const Index outerEvaluationSize = (SrcEvaluatorType::Flags&RowMajorBit) ? src.rows() : src.cols();
+  if ((!transpose) && src.isRValue())
+  {
+    // eval without temporary
+    dst.resize(src.rows(), src.cols());
+    dst.setZero();
+    dst.reserve((std::min)(src.rows()*src.cols(), (std::max)(src.rows(),src.cols())*2));
+    for (Index j=0; j<outerEvaluationSize; ++j)
+    {
+      dst.startVec(j);
+      for (typename SrcEvaluatorType::InnerIterator it(srcEvaluator, j); it; ++it)
+      {
+        Scalar v = it.value();
+        dst.insertBackByOuterInner(j,it.index()) = v;
+      }
+    }
+    dst.finalize();
+  }
+  else
+  {
+    // eval through a temporary
+    eigen_assert(( ((internal::traits<DstXprType>::SupportedAccessPatterns & OuterRandomAccessPattern)==OuterRandomAccessPattern) ||
+              (!((DstEvaluatorType::Flags & RowMajorBit) != (SrcEvaluatorType::Flags & RowMajorBit)))) &&
+              "the transpose operation is supposed to be handled in SparseMatrix::operator=");
+
+    enum { Flip = (DstEvaluatorType::Flags & RowMajorBit) != (SrcEvaluatorType::Flags & RowMajorBit) };
+
+    
+    DstXprType temp(src.rows(), src.cols());
+
+    temp.reserve((std::min)(src.rows()*src.cols(), (std::max)(src.rows(),src.cols())*2));
+    for (Index j=0; j<outerEvaluationSize; ++j)
+    {
+      temp.startVec(j);
+      for (typename SrcEvaluatorType::InnerIterator it(srcEvaluator, j); it; ++it)
+      {
+        Scalar v = it.value();
+        temp.insertBackByOuterInner(Flip?it.index():j,Flip?j:it.index()) = v;
+      }
+    }
+    temp.finalize();
+
+    dst = temp.markAsRValue();
+  }
+}
+
+// Generic Sparse to Sparse assignment
+template< typename DstXprType, typename SrcXprType, typename Functor>
+struct Assignment<DstXprType, SrcXprType, Functor, Sparse2Sparse>
+{
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
+  {
+    assign_sparse_to_sparse(dst.derived(), src.derived());
+  }
+};
+
+// Generic Sparse to Dense assignment
+template< typename DstXprType, typename SrcXprType, typename Functor>
+struct Assignment<DstXprType, SrcXprType, Functor, Sparse2Dense>
+{
+  static void run(DstXprType &dst, const SrcXprType &src, const Functor &func)
+  {
+    if(internal::is_same<Functor,internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> >::value)
+      dst.setZero();
+    
+    internal::evaluator<SrcXprType> srcEval(src);
+    resize_if_allowed(dst, src, func);
+    internal::evaluator<DstXprType> dstEval(dst);
+    
+    const Index outerEvaluationSize = (internal::evaluator<SrcXprType>::Flags&RowMajorBit) ? src.rows() : src.cols();
+    for (Index j=0; j<outerEvaluationSize; ++j)
+      for (typename internal::evaluator<SrcXprType>::InnerIterator i(srcEval,j); i; ++i)
+        func.assignCoeff(dstEval.coeffRef(i.row(),i.col()), i.value());
+  }
+};
+
+// Specialization for "dst = dec.solve(rhs)"
+// NOTE we need to specialize it for Sparse2Sparse to avoid ambiguous specialization error
+template<typename DstXprType, typename DecType, typename RhsType, typename Scalar>
+struct Assignment<DstXprType, Solve<DecType,RhsType>, internal::assign_op<Scalar,Scalar>, Sparse2Sparse>
+{
+  typedef Solve<DecType,RhsType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    src.dec()._solve_impl(src.rhs(), dst);
+  }
+};
+
+struct Diagonal2Sparse {};
+
+template<> struct AssignmentKind<SparseShape,DiagonalShape> { typedef Diagonal2Sparse Kind; };
+
+template< typename DstXprType, typename SrcXprType, typename Functor>
+struct Assignment<DstXprType, SrcXprType, Functor, Diagonal2Sparse>
+{
+  typedef typename DstXprType::StorageIndex StorageIndex;
+  typedef typename DstXprType::Scalar Scalar;
+  typedef Array<StorageIndex,Dynamic,1> ArrayXI;
+  typedef Array<Scalar,Dynamic,1> ArrayXS;
+  template<int Options>
+  static void run(SparseMatrix<Scalar,Options,StorageIndex> &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    Index size = src.diagonal().size();
+    dst.makeCompressed();
+    dst.resizeNonZeros(size);
+    Map<ArrayXI>(dst.innerIndexPtr(), size).setLinSpaced(0,StorageIndex(size)-1);
+    Map<ArrayXI>(dst.outerIndexPtr(), size+1).setLinSpaced(0,StorageIndex(size));
+    Map<ArrayXS>(dst.valuePtr(), size) = src.diagonal();
+  }
+  
+  template<typename DstDerived>
+  static void run(SparseMatrixBase<DstDerived> &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
+  {
+    dst.diagonal() = src.diagonal();
+  }
+  
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
+  { dst.diagonal() += src.diagonal(); }
+  
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
+  { dst.diagonal() -= src.diagonal(); }
+};
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSEASSIGN_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseBlock.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseBlock.h
new file mode 100644
index 00000000..511e92b2
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseBlock.h
@@ -0,0 +1,603 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_BLOCK_H
+#define EIGEN_SPARSE_BLOCK_H
+
+namespace Eigen {
+
+// Subset of columns or rows
+template<typename XprType, int BlockRows, int BlockCols>
+class BlockImpl<XprType,BlockRows,BlockCols,true,Sparse>
+  : public SparseMatrixBase<Block<XprType,BlockRows,BlockCols,true> >
+{
+    typedef typename internal::remove_all<typename XprType::Nested>::type _MatrixTypeNested;
+    typedef Block<XprType, BlockRows, BlockCols, true> BlockType;
+public:
+    enum { IsRowMajor = internal::traits<BlockType>::IsRowMajor };
+protected:
+    enum { OuterSize = IsRowMajor ? BlockRows : BlockCols };
+    typedef SparseMatrixBase<BlockType> Base;
+    using Base::convert_index;
+public:
+    EIGEN_SPARSE_PUBLIC_INTERFACE(BlockType)
+
+    inline BlockImpl(XprType& xpr, Index i)
+      : m_matrix(xpr), m_outerStart(convert_index(i)), m_outerSize(OuterSize)
+    {}
+
+    inline BlockImpl(XprType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
+      : m_matrix(xpr), m_outerStart(convert_index(IsRowMajor ? startRow : startCol)), m_outerSize(convert_index(IsRowMajor ? blockRows : blockCols))
+    {}
+
+    EIGEN_STRONG_INLINE Index rows() const { return IsRowMajor ? m_outerSize.value() : m_matrix.rows(); }
+    EIGEN_STRONG_INLINE Index cols() const { return IsRowMajor ? m_matrix.cols() : m_outerSize.value(); }
+
+    Index nonZeros() const
+    {
+      typedef internal::evaluator<XprType> EvaluatorType;
+      EvaluatorType matEval(m_matrix);
+      Index nnz = 0;
+      Index end = m_outerStart + m_outerSize.value();
+      for(Index j=m_outerStart; j<end; ++j)
+        for(typename EvaluatorType::InnerIterator it(matEval, j); it; ++it)
+          ++nnz;
+      return nnz;
+    }
+
+    inline const Scalar coeff(Index row, Index col) const
+    {
+      return m_matrix.coeff(row + (IsRowMajor ? m_outerStart : 0), col + (IsRowMajor ? 0 :  m_outerStart));
+    }
+
+    inline const Scalar coeff(Index index) const
+    {
+      return m_matrix.coeff(IsRowMajor ? m_outerStart : index, IsRowMajor ? index :  m_outerStart);
+    }
+
+    inline const XprType& nestedExpression() const { return m_matrix; }
+    inline XprType& nestedExpression() { return m_matrix; }
+    Index startRow() const { return IsRowMajor ? m_outerStart : 0; }
+    Index startCol() const { return IsRowMajor ? 0 : m_outerStart; }
+    Index blockRows() const { return IsRowMajor ? m_outerSize.value() : m_matrix.rows(); }
+    Index blockCols() const { return IsRowMajor ? m_matrix.cols() : m_outerSize.value(); }
+
+  protected:
+
+    typename internal::ref_selector<XprType>::non_const_type m_matrix;
+    Index m_outerStart;
+    const internal::variable_if_dynamic<Index, OuterSize> m_outerSize;
+
+  protected:
+    // Disable assignment with clear error message.
+    // Note that simply removing operator= yields compilation errors with ICC+MSVC
+    template<typename T>
+    BlockImpl& operator=(const T&)
+    {
+      EIGEN_STATIC_ASSERT(sizeof(T)==0, THIS_SPARSE_BLOCK_SUBEXPRESSION_IS_READ_ONLY);
+      return *this;
+    }
+};
+
+
+/***************************************************************************
+* specialization for SparseMatrix
+***************************************************************************/
+
+namespace internal {
+
+template<typename SparseMatrixType, int BlockRows, int BlockCols>
+class sparse_matrix_block_impl
+  : public SparseCompressedBase<Block<SparseMatrixType,BlockRows,BlockCols,true> >
+{
+    typedef typename internal::remove_all<typename SparseMatrixType::Nested>::type _MatrixTypeNested;
+    typedef Block<SparseMatrixType, BlockRows, BlockCols, true> BlockType;
+    typedef SparseCompressedBase<Block<SparseMatrixType,BlockRows,BlockCols,true> > Base;
+    using Base::convert_index;
+public:
+    enum { IsRowMajor = internal::traits<BlockType>::IsRowMajor };
+    EIGEN_SPARSE_PUBLIC_INTERFACE(BlockType)
+protected:
+    typedef typename Base::IndexVector IndexVector;
+    enum { OuterSize = IsRowMajor ? BlockRows : BlockCols };
+public:
+
+    inline sparse_matrix_block_impl(SparseMatrixType& xpr, Index i)
+      : m_matrix(xpr), m_outerStart(convert_index(i)), m_outerSize(OuterSize)
+    {}
+
+    inline sparse_matrix_block_impl(SparseMatrixType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
+      : m_matrix(xpr), m_outerStart(convert_index(IsRowMajor ? startRow : startCol)), m_outerSize(convert_index(IsRowMajor ? blockRows : blockCols))
+    {}
+
+    template<typename OtherDerived>
+    inline BlockType& operator=(const SparseMatrixBase<OtherDerived>& other)
+    {
+      typedef typename internal::remove_all<typename SparseMatrixType::Nested>::type _NestedMatrixType;
+      _NestedMatrixType& matrix = m_matrix;
+      // This assignment is slow if this vector set is not empty
+      // and/or it is not at the end of the nonzeros of the underlying matrix.
+
+      // 1 - eval to a temporary to avoid transposition and/or aliasing issues
+      Ref<const SparseMatrix<Scalar, IsRowMajor ? RowMajor : ColMajor, StorageIndex> > tmp(other.derived());
+      eigen_internal_assert(tmp.outerSize()==m_outerSize.value());
+
+      // 2 - let's check whether there is enough allocated memory
+      Index nnz           = tmp.nonZeros();
+      Index start         = m_outerStart==0 ? 0 : m_matrix.outerIndexPtr()[m_outerStart]; // starting position of the current block
+      Index end           = m_matrix.outerIndexPtr()[m_outerStart+m_outerSize.value()]; // ending position of the current block
+      Index block_size    = end - start;                                                // available room in the current block
+      Index tail_size     = m_matrix.outerIndexPtr()[m_matrix.outerSize()] - end;
+
+      Index free_size     = m_matrix.isCompressed()
+                          ? Index(matrix.data().allocatedSize()) + block_size
+                          : block_size;
+
+      Index tmp_start = tmp.outerIndexPtr()[0];
+
+      bool update_trailing_pointers = false;
+      if(nnz>free_size)
+      {
+        // realloc manually to reduce copies
+        typename SparseMatrixType::Storage newdata(m_matrix.data().allocatedSize() - block_size + nnz);
+
+        internal::smart_copy(m_matrix.valuePtr(),       m_matrix.valuePtr() + start,      newdata.valuePtr());
+        internal::smart_copy(m_matrix.innerIndexPtr(),  m_matrix.innerIndexPtr() + start, newdata.indexPtr());
+
+        internal::smart_copy(tmp.valuePtr() + tmp_start,      tmp.valuePtr() + tmp_start + nnz,       newdata.valuePtr() + start);
+        internal::smart_copy(tmp.innerIndexPtr() + tmp_start, tmp.innerIndexPtr() + tmp_start + nnz,  newdata.indexPtr() + start);
+
+        internal::smart_copy(matrix.valuePtr()+end,       matrix.valuePtr()+end + tail_size,      newdata.valuePtr()+start+nnz);
+        internal::smart_copy(matrix.innerIndexPtr()+end,  matrix.innerIndexPtr()+end + tail_size, newdata.indexPtr()+start+nnz);
+
+        newdata.resize(m_matrix.outerIndexPtr()[m_matrix.outerSize()] - block_size + nnz);
+
+        matrix.data().swap(newdata);
+
+        update_trailing_pointers = true;
+      }
+      else
+      {
+        if(m_matrix.isCompressed())
+        {
+          // no need to realloc, simply copy the tail at its respective position and insert tmp
+          matrix.data().resize(start + nnz + tail_size);
+
+          internal::smart_memmove(matrix.valuePtr()+end,      matrix.valuePtr() + end+tail_size,      matrix.valuePtr() + start+nnz);
+          internal::smart_memmove(matrix.innerIndexPtr()+end, matrix.innerIndexPtr() + end+tail_size, matrix.innerIndexPtr() + start+nnz);
+
+          update_trailing_pointers = true;
+        }
+
+        internal::smart_copy(tmp.valuePtr() + tmp_start,      tmp.valuePtr() + tmp_start + nnz,       matrix.valuePtr() + start);
+        internal::smart_copy(tmp.innerIndexPtr() + tmp_start, tmp.innerIndexPtr() + tmp_start + nnz,  matrix.innerIndexPtr() + start);
+      }
+
+      // update outer index pointers and innerNonZeros
+      if(IsVectorAtCompileTime)
+      {
+        if(!m_matrix.isCompressed())
+          matrix.innerNonZeroPtr()[m_outerStart] = StorageIndex(nnz);
+        matrix.outerIndexPtr()[m_outerStart] = StorageIndex(start);
+      }
+      else
+      {
+        StorageIndex p = StorageIndex(start);
+        for(Index k=0; k<m_outerSize.value(); ++k)
+        {
+          StorageIndex nnz_k = internal::convert_index<StorageIndex>(tmp.innerVector(k).nonZeros());
+          if(!m_matrix.isCompressed())
+            matrix.innerNonZeroPtr()[m_outerStart+k] = nnz_k;
+          matrix.outerIndexPtr()[m_outerStart+k] = p;
+          p += nnz_k;
+        }
+      }
+
+      if(update_trailing_pointers)
+      {
+        StorageIndex offset = internal::convert_index<StorageIndex>(nnz - block_size);
+        for(Index k = m_outerStart + m_outerSize.value(); k<=matrix.outerSize(); ++k)
+        {
+          matrix.outerIndexPtr()[k] += offset;
+        }
+      }
+
+      return derived();
+    }
+
+    inline BlockType& operator=(const BlockType& other)
+    {
+      return operator=<BlockType>(other);
+    }
+
+    inline const Scalar* valuePtr() const
+    { return m_matrix.valuePtr(); }
+    inline Scalar* valuePtr()
+    { return m_matrix.valuePtr(); }
+
+    inline const StorageIndex* innerIndexPtr() const
+    { return m_matrix.innerIndexPtr(); }
+    inline StorageIndex* innerIndexPtr()
+    { return m_matrix.innerIndexPtr(); }
+
+    inline const StorageIndex* outerIndexPtr() const
+    { return m_matrix.outerIndexPtr() + m_outerStart; }
+    inline StorageIndex* outerIndexPtr()
+    { return m_matrix.outerIndexPtr() + m_outerStart; }
+
+    inline const StorageIndex* innerNonZeroPtr() const
+    { return isCompressed() ? 0 : (m_matrix.innerNonZeroPtr()+m_outerStart); }
+    inline StorageIndex* innerNonZeroPtr()
+    { return isCompressed() ? 0 : (m_matrix.innerNonZeroPtr()+m_outerStart); }
+
+    bool isCompressed() const { return m_matrix.innerNonZeroPtr()==0; }
+
+    inline Scalar& coeffRef(Index row, Index col)
+    {
+      return m_matrix.coeffRef(row + (IsRowMajor ? m_outerStart : 0), col + (IsRowMajor ? 0 :  m_outerStart));
+    }
+
+    inline const Scalar coeff(Index row, Index col) const
+    {
+      return m_matrix.coeff(row + (IsRowMajor ? m_outerStart : 0), col + (IsRowMajor ? 0 :  m_outerStart));
+    }
+
+    inline const Scalar coeff(Index index) const
+    {
+      return m_matrix.coeff(IsRowMajor ? m_outerStart : index, IsRowMajor ? index :  m_outerStart);
+    }
+
+    const Scalar& lastCoeff() const
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(sparse_matrix_block_impl);
+      eigen_assert(Base::nonZeros()>0);
+      if(m_matrix.isCompressed())
+        return m_matrix.valuePtr()[m_matrix.outerIndexPtr()[m_outerStart+1]-1];
+      else
+        return m_matrix.valuePtr()[m_matrix.outerIndexPtr()[m_outerStart]+m_matrix.innerNonZeroPtr()[m_outerStart]-1];
+    }
+
+    EIGEN_STRONG_INLINE Index rows() const { return IsRowMajor ? m_outerSize.value() : m_matrix.rows(); }
+    EIGEN_STRONG_INLINE Index cols() const { return IsRowMajor ? m_matrix.cols() : m_outerSize.value(); }
+
+    inline const SparseMatrixType& nestedExpression() const { return m_matrix; }
+    inline SparseMatrixType& nestedExpression() { return m_matrix; }
+    Index startRow() const { return IsRowMajor ? m_outerStart : 0; }
+    Index startCol() const { return IsRowMajor ? 0 : m_outerStart; }
+    Index blockRows() const { return IsRowMajor ? m_outerSize.value() : m_matrix.rows(); }
+    Index blockCols() const { return IsRowMajor ? m_matrix.cols() : m_outerSize.value(); }
+
+  protected:
+
+    typename internal::ref_selector<SparseMatrixType>::non_const_type m_matrix;
+    Index m_outerStart;
+    const internal::variable_if_dynamic<Index, OuterSize> m_outerSize;
+
+};
+
+} // namespace internal
+
+template<typename _Scalar, int _Options, typename _StorageIndex, int BlockRows, int BlockCols>
+class BlockImpl<SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true,Sparse>
+  : public internal::sparse_matrix_block_impl<SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols>
+{
+public:
+  typedef _StorageIndex StorageIndex;
+  typedef SparseMatrix<_Scalar, _Options, _StorageIndex> SparseMatrixType;
+  typedef internal::sparse_matrix_block_impl<SparseMatrixType,BlockRows,BlockCols> Base;
+  inline BlockImpl(SparseMatrixType& xpr, Index i)
+    : Base(xpr, i)
+  {}
+
+  inline BlockImpl(SparseMatrixType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
+    : Base(xpr, startRow, startCol, blockRows, blockCols)
+  {}
+
+  using Base::operator=;
+};
+
+template<typename _Scalar, int _Options, typename _StorageIndex, int BlockRows, int BlockCols>
+class BlockImpl<const SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true,Sparse>
+  : public internal::sparse_matrix_block_impl<const SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols>
+{
+public:
+  typedef _StorageIndex StorageIndex;
+  typedef const SparseMatrix<_Scalar, _Options, _StorageIndex> SparseMatrixType;
+  typedef internal::sparse_matrix_block_impl<SparseMatrixType,BlockRows,BlockCols> Base;
+  inline BlockImpl(SparseMatrixType& xpr, Index i)
+    : Base(xpr, i)
+  {}
+
+  inline BlockImpl(SparseMatrixType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
+    : Base(xpr, startRow, startCol, blockRows, blockCols)
+  {}
+
+  using Base::operator=;
+private:
+  template<typename Derived> BlockImpl(const SparseMatrixBase<Derived>& xpr, Index i);
+  template<typename Derived> BlockImpl(const SparseMatrixBase<Derived>& xpr);
+};
+
+//----------
+
+/** \returns the \a outer -th column (resp. row) of the matrix \c *this if \c *this
+  * is col-major (resp. row-major).
+  */
+template<typename Derived>
+typename SparseMatrixBase<Derived>::InnerVectorReturnType SparseMatrixBase<Derived>::innerVector(Index outer)
+{ return InnerVectorReturnType(derived(), outer); }
+
+/** \returns the \a outer -th column (resp. row) of the matrix \c *this if \c *this
+  * is col-major (resp. row-major). Read-only.
+  */
+template<typename Derived>
+const typename SparseMatrixBase<Derived>::ConstInnerVectorReturnType SparseMatrixBase<Derived>::innerVector(Index outer) const
+{ return ConstInnerVectorReturnType(derived(), outer); }
+
+/** \returns the \a outer -th column (resp. row) of the matrix \c *this if \c *this
+  * is col-major (resp. row-major).
+  */
+template<typename Derived>
+typename SparseMatrixBase<Derived>::InnerVectorsReturnType
+SparseMatrixBase<Derived>::innerVectors(Index outerStart, Index outerSize)
+{
+  return Block<Derived,Dynamic,Dynamic,true>(derived(),
+                                             IsRowMajor ? outerStart : 0, IsRowMajor ? 0 : outerStart,
+                                             IsRowMajor ? outerSize : rows(), IsRowMajor ? cols() : outerSize);
+
+}
+
+/** \returns the \a outer -th column (resp. row) of the matrix \c *this if \c *this
+  * is col-major (resp. row-major). Read-only.
+  */
+template<typename Derived>
+const typename SparseMatrixBase<Derived>::ConstInnerVectorsReturnType
+SparseMatrixBase<Derived>::innerVectors(Index outerStart, Index outerSize) const
+{
+  return Block<const Derived,Dynamic,Dynamic,true>(derived(),
+                                                  IsRowMajor ? outerStart : 0, IsRowMajor ? 0 : outerStart,
+                                                  IsRowMajor ? outerSize : rows(), IsRowMajor ? cols() : outerSize);
+
+}
+
+/** Generic implementation of sparse Block expression.
+  * Real-only.
+  */
+template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
+class BlockImpl<XprType,BlockRows,BlockCols,InnerPanel,Sparse>
+  : public SparseMatrixBase<Block<XprType,BlockRows,BlockCols,InnerPanel> >, internal::no_assignment_operator
+{
+    typedef Block<XprType, BlockRows, BlockCols, InnerPanel> BlockType;
+    typedef SparseMatrixBase<BlockType> Base;
+    using Base::convert_index;
+public:
+    enum { IsRowMajor = internal::traits<BlockType>::IsRowMajor };
+    EIGEN_SPARSE_PUBLIC_INTERFACE(BlockType)
+
+    typedef typename internal::remove_all<typename XprType::Nested>::type _MatrixTypeNested;
+
+    /** Column or Row constructor
+      */
+    inline BlockImpl(XprType& xpr, Index i)
+      : m_matrix(xpr),
+        m_startRow( (BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) ? convert_index(i) : 0),
+        m_startCol( (BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) ? convert_index(i) : 0),
+        m_blockRows(BlockRows==1 ? 1 : xpr.rows()),
+        m_blockCols(BlockCols==1 ? 1 : xpr.cols())
+    {}
+
+    /** Dynamic-size constructor
+      */
+    inline BlockImpl(XprType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
+      : m_matrix(xpr), m_startRow(convert_index(startRow)), m_startCol(convert_index(startCol)), m_blockRows(convert_index(blockRows)), m_blockCols(convert_index(blockCols))
+    {}
+
+    inline Index rows() const { return m_blockRows.value(); }
+    inline Index cols() const { return m_blockCols.value(); }
+
+    inline Scalar& coeffRef(Index row, Index col)
+    {
+      return m_matrix.coeffRef(row + m_startRow.value(), col + m_startCol.value());
+    }
+
+    inline const Scalar coeff(Index row, Index col) const
+    {
+      return m_matrix.coeff(row + m_startRow.value(), col + m_startCol.value());
+    }
+
+    inline Scalar& coeffRef(Index index)
+    {
+      return m_matrix.coeffRef(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
+                               m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
+    }
+
+    inline const Scalar coeff(Index index) const
+    {
+      return m_matrix.coeff(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
+                            m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
+    }
+
+    inline const XprType& nestedExpression() const { return m_matrix; }
+    inline XprType& nestedExpression() { return m_matrix; }
+    Index startRow() const { return m_startRow.value(); }
+    Index startCol() const { return m_startCol.value(); }
+    Index blockRows() const { return m_blockRows.value(); }
+    Index blockCols() const { return m_blockCols.value(); }
+
+  protected:
+//     friend class internal::GenericSparseBlockInnerIteratorImpl<XprType,BlockRows,BlockCols,InnerPanel>;
+    friend struct internal::unary_evaluator<Block<XprType,BlockRows,BlockCols,InnerPanel>, internal::IteratorBased, Scalar >;
+
+    Index nonZeros() const { return Dynamic; }
+
+    typename internal::ref_selector<XprType>::non_const_type m_matrix;
+    const internal::variable_if_dynamic<Index, XprType::RowsAtCompileTime == 1 ? 0 : Dynamic> m_startRow;
+    const internal::variable_if_dynamic<Index, XprType::ColsAtCompileTime == 1 ? 0 : Dynamic> m_startCol;
+    const internal::variable_if_dynamic<Index, RowsAtCompileTime> m_blockRows;
+    const internal::variable_if_dynamic<Index, ColsAtCompileTime> m_blockCols;
+
+  protected:
+    // Disable assignment with clear error message.
+    // Note that simply removing operator= yields compilation errors with ICC+MSVC
+    template<typename T>
+    BlockImpl& operator=(const T&)
+    {
+      EIGEN_STATIC_ASSERT(sizeof(T)==0, THIS_SPARSE_BLOCK_SUBEXPRESSION_IS_READ_ONLY);
+      return *this;
+    }
+
+};
+
+namespace internal {
+
+template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
+struct unary_evaluator<Block<ArgType,BlockRows,BlockCols,InnerPanel>, IteratorBased >
+ : public evaluator_base<Block<ArgType,BlockRows,BlockCols,InnerPanel> >
+{
+    class InnerVectorInnerIterator;
+    class OuterVectorInnerIterator;
+  public:
+    typedef Block<ArgType,BlockRows,BlockCols,InnerPanel> XprType;
+    typedef typename XprType::StorageIndex StorageIndex;
+    typedef typename XprType::Scalar Scalar;
+
+    enum {
+      IsRowMajor = XprType::IsRowMajor,
+
+      OuterVector =  (BlockCols==1 && ArgType::IsRowMajor)
+                    | // FIXME | instead of || to please GCC 4.4.0 stupid warning "suggest parentheses around &&".
+                      // revert to || as soon as not needed anymore.
+                     (BlockRows==1 && !ArgType::IsRowMajor),
+
+      CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+      Flags = XprType::Flags
+    };
+
+    typedef typename internal::conditional<OuterVector,OuterVectorInnerIterator,InnerVectorInnerIterator>::type InnerIterator;
+
+    explicit unary_evaluator(const XprType& op)
+      : m_argImpl(op.nestedExpression()), m_block(op)
+    {}
+
+    inline Index nonZerosEstimate() const {
+      Index nnz = m_block.nonZeros();
+      if(nnz<0)
+        return m_argImpl.nonZerosEstimate() * m_block.size() / m_block.nestedExpression().size();
+      return nnz;
+    }
+
+  protected:
+    typedef typename evaluator<ArgType>::InnerIterator EvalIterator;
+
+    evaluator<ArgType> m_argImpl;
+    const XprType &m_block;
+};
+
+template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
+class unary_evaluator<Block<ArgType,BlockRows,BlockCols,InnerPanel>, IteratorBased>::InnerVectorInnerIterator
+ : public EvalIterator
+{
+  enum { IsRowMajor = unary_evaluator::IsRowMajor };
+  const XprType& m_block;
+  Index m_end;
+public:
+
+  EIGEN_STRONG_INLINE InnerVectorInnerIterator(const unary_evaluator& aEval, Index outer)
+    : EvalIterator(aEval.m_argImpl, outer + (IsRowMajor ? aEval.m_block.startRow() : aEval.m_block.startCol())),
+      m_block(aEval.m_block),
+      m_end(IsRowMajor ? aEval.m_block.startCol()+aEval.m_block.blockCols() : aEval.m_block.startRow()+aEval.m_block.blockRows())
+  {
+    while( (EvalIterator::operator bool()) && (EvalIterator::index() < (IsRowMajor ? m_block.startCol() : m_block.startRow())) )
+      EvalIterator::operator++();
+  }
+
+  inline StorageIndex index() const { return EvalIterator::index() - convert_index<StorageIndex>(IsRowMajor ? m_block.startCol() : m_block.startRow()); }
+  inline Index outer()  const { return EvalIterator::outer() - (IsRowMajor ? m_block.startRow() : m_block.startCol()); }
+  inline Index row()    const { return EvalIterator::row()   - m_block.startRow(); }
+  inline Index col()    const { return EvalIterator::col()   - m_block.startCol(); }
+
+  inline operator bool() const { return EvalIterator::operator bool() && EvalIterator::index() < m_end; }
+};
+
+template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
+class unary_evaluator<Block<ArgType,BlockRows,BlockCols,InnerPanel>, IteratorBased>::OuterVectorInnerIterator
+{
+  enum { IsRowMajor = unary_evaluator::IsRowMajor };
+  const unary_evaluator& m_eval;
+  Index m_outerPos;
+  const Index m_innerIndex;
+  Index m_end;
+  EvalIterator m_it;
+public:
+
+  EIGEN_STRONG_INLINE OuterVectorInnerIterator(const unary_evaluator& aEval, Index outer)
+    : m_eval(aEval),
+      m_outerPos( (IsRowMajor ? aEval.m_block.startCol() : aEval.m_block.startRow()) ),
+      m_innerIndex(IsRowMajor ? aEval.m_block.startRow() : aEval.m_block.startCol()),
+      m_end(IsRowMajor ? aEval.m_block.startCol()+aEval.m_block.blockCols() : aEval.m_block.startRow()+aEval.m_block.blockRows()),
+      m_it(m_eval.m_argImpl, m_outerPos)
+  {
+    EIGEN_UNUSED_VARIABLE(outer);
+    eigen_assert(outer==0);
+
+    while(m_it && m_it.index() < m_innerIndex) ++m_it;
+    if((!m_it) || (m_it.index()!=m_innerIndex))
+      ++(*this);
+  }
+
+  inline StorageIndex index() const { return convert_index<StorageIndex>(m_outerPos - (IsRowMajor ? m_eval.m_block.startCol() : m_eval.m_block.startRow())); }
+  inline Index outer()  const { return 0; }
+  inline Index row()    const { return IsRowMajor ? 0 : index(); }
+  inline Index col()    const { return IsRowMajor ? index() : 0; }
+
+  inline Scalar value() const { return m_it.value(); }
+  inline Scalar& valueRef() { return m_it.valueRef(); }
+
+  inline OuterVectorInnerIterator& operator++()
+  {
+    // search next non-zero entry
+    while(++m_outerPos<m_end)
+    {
+      // Restart iterator at the next inner-vector:
+      m_it.~EvalIterator();
+      ::new (&m_it) EvalIterator(m_eval.m_argImpl, m_outerPos);
+      // search for the key m_innerIndex in the current outer-vector
+      while(m_it && m_it.index() < m_innerIndex) ++m_it;
+      if(m_it && m_it.index()==m_innerIndex) break;
+    }
+    return *this;
+  }
+
+  inline operator bool() const { return m_outerPos < m_end; }
+};
+
+template<typename _Scalar, int _Options, typename _StorageIndex, int BlockRows, int BlockCols>
+struct unary_evaluator<Block<SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true>, IteratorBased>
+  : evaluator<SparseCompressedBase<Block<SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true> > >
+{
+  typedef Block<SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true> XprType;
+  typedef evaluator<SparseCompressedBase<XprType> > Base;
+  explicit unary_evaluator(const XprType &xpr) : Base(xpr) {}
+};
+
+template<typename _Scalar, int _Options, typename _StorageIndex, int BlockRows, int BlockCols>
+struct unary_evaluator<Block<const SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true>, IteratorBased>
+  : evaluator<SparseCompressedBase<Block<const SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true> > >
+{
+  typedef Block<const SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true> XprType;
+  typedef evaluator<SparseCompressedBase<XprType> > Base;
+  explicit unary_evaluator(const XprType &xpr) : Base(xpr) {}
+};
+
+} // end namespace internal
+
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_BLOCK_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseColEtree.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseColEtree.h
new file mode 100644
index 00000000..ebe02d1a
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseColEtree.h
@@ -0,0 +1,206 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+/* 
+ 
+ * NOTE: This file is the modified version of sp_coletree.c file in SuperLU 
+ 
+ * -- SuperLU routine (version 3.1) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * August 1, 2008
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+#ifndef SPARSE_COLETREE_H
+#define SPARSE_COLETREE_H
+
+namespace Eigen {
+
+namespace internal {
+
+/** Find the root of the tree/set containing the vertex i : Use Path halving */ 
+template<typename Index, typename IndexVector>
+Index etree_find (Index i, IndexVector& pp)
+{
+  Index p = pp(i); // Parent 
+  Index gp = pp(p); // Grand parent 
+  while (gp != p) 
+  {
+    pp(i) = gp; // Parent pointer on find path is changed to former grand parent
+    i = gp; 
+    p = pp(i);
+    gp = pp(p);
+  }
+  return p; 
+}
+
+/** Compute the column elimination tree of a sparse matrix
+  * \param mat The matrix in column-major format. 
+  * \param parent The elimination tree
+  * \param firstRowElt The column index of the first element in each row
+  * \param perm The permutation to apply to the column of \b mat
+  */
+template <typename MatrixType, typename IndexVector>
+int coletree(const MatrixType& mat, IndexVector& parent, IndexVector& firstRowElt, typename MatrixType::StorageIndex *perm=0)
+{
+  typedef typename MatrixType::StorageIndex StorageIndex;
+  StorageIndex nc = convert_index<StorageIndex>(mat.cols()); // Number of columns
+  StorageIndex m = convert_index<StorageIndex>(mat.rows());
+  StorageIndex diagSize = (std::min)(nc,m);
+  IndexVector root(nc); // root of subtree of etree 
+  root.setZero();
+  IndexVector pp(nc); // disjoint sets 
+  pp.setZero(); // Initialize disjoint sets 
+  parent.resize(mat.cols());
+  //Compute first nonzero column in each row 
+  firstRowElt.resize(m);
+  firstRowElt.setConstant(nc);
+  firstRowElt.segment(0, diagSize).setLinSpaced(diagSize, 0, diagSize-1);
+  bool found_diag;
+  for (StorageIndex col = 0; col < nc; col++)
+  {
+    StorageIndex pcol = col;
+    if(perm) pcol  = perm[col];
+    for (typename MatrixType::InnerIterator it(mat, pcol); it; ++it)
+    { 
+      Index row = it.row();
+      firstRowElt(row) = (std::min)(firstRowElt(row), col);
+    }
+  }
+  /* Compute etree by Liu's algorithm for symmetric matrices,
+          except use (firstRowElt[r],c) in place of an edge (r,c) of A.
+    Thus each row clique in A'*A is replaced by a star
+    centered at its first vertex, which has the same fill. */
+  StorageIndex rset, cset, rroot;
+  for (StorageIndex col = 0; col < nc; col++) 
+  {
+    found_diag = col>=m;
+    pp(col) = col; 
+    cset = col; 
+    root(cset) = col; 
+    parent(col) = nc; 
+    /* The diagonal element is treated here even if it does not exist in the matrix
+     * hence the loop is executed once more */ 
+    StorageIndex pcol = col;
+    if(perm) pcol  = perm[col];
+    for (typename MatrixType::InnerIterator it(mat, pcol); it||!found_diag; ++it)
+    { //  A sequence of interleaved find and union is performed 
+      Index i = col;
+      if(it) i = it.index();
+      if (i == col) found_diag = true;
+      
+      StorageIndex row = firstRowElt(i);
+      if (row >= col) continue; 
+      rset = internal::etree_find(row, pp); // Find the name of the set containing row
+      rroot = root(rset);
+      if (rroot != col) 
+      {
+        parent(rroot) = col; 
+        pp(cset) = rset; 
+        cset = rset; 
+        root(cset) = col; 
+      }
+    }
+  }
+  return 0;  
+}
+
+/** 
+  * Depth-first search from vertex n.  No recursion.
+  * This routine was contributed by Cédric Doucet, CEDRAT Group, Meylan, France.
+*/
+template <typename IndexVector>
+void nr_etdfs (typename IndexVector::Scalar n, IndexVector& parent, IndexVector& first_kid, IndexVector& next_kid, IndexVector& post, typename IndexVector::Scalar postnum)
+{
+  typedef typename IndexVector::Scalar StorageIndex;
+  StorageIndex current = n, first, next;
+  while (postnum != n) 
+  {
+    // No kid for the current node
+    first = first_kid(current);
+    
+    // no kid for the current node
+    if (first == -1) 
+    {
+      // Numbering this node because it has no kid 
+      post(current) = postnum++;
+      
+      // looking for the next kid 
+      next = next_kid(current); 
+      while (next == -1) 
+      {
+        // No more kids : back to the parent node
+        current = parent(current); 
+        // numbering the parent node 
+        post(current) = postnum++;
+        
+        // Get the next kid 
+        next = next_kid(current); 
+      }
+      // stopping criterion 
+      if (postnum == n+1) return; 
+      
+      // Updating current node 
+      current = next; 
+    }
+    else 
+    {
+      current = first; 
+    }
+  }
+}
+
+
+/**
+  * \brief Post order a tree 
+  * \param n the number of nodes
+  * \param parent Input tree
+  * \param post postordered tree
+  */
+template <typename IndexVector>
+void treePostorder(typename IndexVector::Scalar n, IndexVector& parent, IndexVector& post)
+{
+  typedef typename IndexVector::Scalar StorageIndex;
+  IndexVector first_kid, next_kid; // Linked list of children 
+  StorageIndex postnum; 
+  // Allocate storage for working arrays and results 
+  first_kid.resize(n+1); 
+  next_kid.setZero(n+1);
+  post.setZero(n+1);
+  
+  // Set up structure describing children
+  first_kid.setConstant(-1); 
+  for (StorageIndex v = n-1; v >= 0; v--) 
+  {
+    StorageIndex dad = parent(v);
+    next_kid(v) = first_kid(dad); 
+    first_kid(dad) = v; 
+  }
+  
+  // Depth-first search from dummy root vertex #n
+  postnum = 0; 
+  internal::nr_etdfs(n, parent, first_kid, next_kid, post, postnum);
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // SPARSE_COLETREE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseCompressedBase.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseCompressedBase.h
new file mode 100644
index 00000000..e0b3c22b
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseCompressedBase.h
@@ -0,0 +1,357 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_COMPRESSED_BASE_H
+#define EIGEN_SPARSE_COMPRESSED_BASE_H
+
+namespace Eigen { 
+
+template<typename Derived> class SparseCompressedBase;
+  
+namespace internal {
+
+template<typename Derived>
+struct traits<SparseCompressedBase<Derived> > : traits<Derived>
+{};
+
+} // end namespace internal
+
+/** \ingroup SparseCore_Module
+  * \class SparseCompressedBase
+  * \brief Common base class for sparse [compressed]-{row|column}-storage format.
+  *
+  * This class defines the common interface for all derived classes implementing the compressed sparse storage format, such as:
+  *  - SparseMatrix
+  *  - Ref<SparseMatrixType,Options>
+  *  - Map<SparseMatrixType>
+  *
+  */
+template<typename Derived>
+class SparseCompressedBase
+  : public SparseMatrixBase<Derived>
+{
+  public:
+    typedef SparseMatrixBase<Derived> Base;
+    EIGEN_SPARSE_PUBLIC_INTERFACE(SparseCompressedBase)
+    using Base::operator=;
+    using Base::IsRowMajor;
+    
+    class InnerIterator;
+    class ReverseInnerIterator;
+    
+  protected:
+    typedef typename Base::IndexVector IndexVector;
+    Eigen::Map<IndexVector> innerNonZeros() { return Eigen::Map<IndexVector>(innerNonZeroPtr(), isCompressed()?0:derived().outerSize()); }
+    const  Eigen::Map<const IndexVector> innerNonZeros() const { return Eigen::Map<const IndexVector>(innerNonZeroPtr(), isCompressed()?0:derived().outerSize()); }
+        
+  public:
+    
+    /** \returns the number of non zero coefficients */
+    inline Index nonZeros() const
+    {
+      if(Derived::IsVectorAtCompileTime && outerIndexPtr()==0)
+        return derived().nonZeros();
+      else if(isCompressed())
+        return outerIndexPtr()[derived().outerSize()]-outerIndexPtr()[0];
+      else if(derived().outerSize()==0)
+        return 0;
+      else
+        return innerNonZeros().sum();
+    }
+    
+    /** \returns a const pointer to the array of values.
+      * This function is aimed at interoperability with other libraries.
+      * \sa innerIndexPtr(), outerIndexPtr() */
+    inline const Scalar* valuePtr() const { return derived().valuePtr(); }
+    /** \returns a non-const pointer to the array of values.
+      * This function is aimed at interoperability with other libraries.
+      * \sa innerIndexPtr(), outerIndexPtr() */
+    inline Scalar* valuePtr() { return derived().valuePtr(); }
+
+    /** \returns a const pointer to the array of inner indices.
+      * This function is aimed at interoperability with other libraries.
+      * \sa valuePtr(), outerIndexPtr() */
+    inline const StorageIndex* innerIndexPtr() const { return derived().innerIndexPtr(); }
+    /** \returns a non-const pointer to the array of inner indices.
+      * This function is aimed at interoperability with other libraries.
+      * \sa valuePtr(), outerIndexPtr() */
+    inline StorageIndex* innerIndexPtr() { return derived().innerIndexPtr(); }
+
+    /** \returns a const pointer to the array of the starting positions of the inner vectors.
+      * This function is aimed at interoperability with other libraries.
+      * \warning it returns the null pointer 0 for SparseVector
+      * \sa valuePtr(), innerIndexPtr() */
+    inline const StorageIndex* outerIndexPtr() const { return derived().outerIndexPtr(); }
+    /** \returns a non-const pointer to the array of the starting positions of the inner vectors.
+      * This function is aimed at interoperability with other libraries.
+      * \warning it returns the null pointer 0 for SparseVector
+      * \sa valuePtr(), innerIndexPtr() */
+    inline StorageIndex* outerIndexPtr() { return derived().outerIndexPtr(); }
+
+    /** \returns a const pointer to the array of the number of non zeros of the inner vectors.
+      * This function is aimed at interoperability with other libraries.
+      * \warning it returns the null pointer 0 in compressed mode */
+    inline const StorageIndex* innerNonZeroPtr() const { return derived().innerNonZeroPtr(); }
+    /** \returns a non-const pointer to the array of the number of non zeros of the inner vectors.
+      * This function is aimed at interoperability with other libraries.
+      * \warning it returns the null pointer 0 in compressed mode */
+    inline StorageIndex* innerNonZeroPtr() { return derived().innerNonZeroPtr(); }
+    
+    /** \returns whether \c *this is in compressed form. */
+    inline bool isCompressed() const { return innerNonZeroPtr()==0; }
+
+    /** \returns a read-only view of the stored coefficients as a 1D array expression.
+      *
+      * \warning this method is for \b compressed \b storage \b only, and it will trigger an assertion otherwise.
+      *
+      * \sa valuePtr(), isCompressed() */
+    const Map<const Array<Scalar,Dynamic,1> > coeffs() const { eigen_assert(isCompressed()); return Array<Scalar,Dynamic,1>::Map(valuePtr(),nonZeros()); }
+
+    /** \returns a read-write view of the stored coefficients as a 1D array expression
+      *
+      * \warning this method is for \b compressed \b storage \b only, and it will trigger an assertion otherwise.
+      *
+      * Here is an example:
+      * \include SparseMatrix_coeffs.cpp
+      * and the output is:
+      * \include SparseMatrix_coeffs.out
+      *
+      * \sa valuePtr(), isCompressed() */
+    Map<Array<Scalar,Dynamic,1> > coeffs() { eigen_assert(isCompressed()); return Array<Scalar,Dynamic,1>::Map(valuePtr(),nonZeros()); }
+
+  protected:
+    /** Default constructor. Do nothing. */
+    SparseCompressedBase() {}
+  private:
+    template<typename OtherDerived> explicit SparseCompressedBase(const SparseCompressedBase<OtherDerived>&);
+};
+
+template<typename Derived>
+class SparseCompressedBase<Derived>::InnerIterator
+{
+  public:
+    InnerIterator()
+      : m_values(0), m_indices(0), m_outer(0), m_id(0), m_end(0)
+    {}
+
+    InnerIterator(const InnerIterator& other)
+      : m_values(other.m_values), m_indices(other.m_indices), m_outer(other.m_outer), m_id(other.m_id), m_end(other.m_end)
+    {}
+
+    InnerIterator& operator=(const InnerIterator& other)
+    {
+      m_values = other.m_values;
+      m_indices = other.m_indices;
+      const_cast<OuterType&>(m_outer).setValue(other.m_outer.value());
+      m_id = other.m_id;
+      m_end = other.m_end;
+      return *this;
+    }
+
+    InnerIterator(const SparseCompressedBase& mat, Index outer)
+      : m_values(mat.valuePtr()), m_indices(mat.innerIndexPtr()), m_outer(outer)
+    {
+      if(Derived::IsVectorAtCompileTime && mat.outerIndexPtr()==0)
+      {
+        m_id = 0;
+        m_end = mat.nonZeros();
+      }
+      else
+      {
+        m_id = mat.outerIndexPtr()[outer];
+        if(mat.isCompressed())
+          m_end = mat.outerIndexPtr()[outer+1];
+        else
+          m_end = m_id + mat.innerNonZeroPtr()[outer];
+      }
+    }
+
+    explicit InnerIterator(const SparseCompressedBase& mat)
+      : m_values(mat.valuePtr()), m_indices(mat.innerIndexPtr()), m_outer(0), m_id(0), m_end(mat.nonZeros())
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+    }
+
+    explicit InnerIterator(const internal::CompressedStorage<Scalar,StorageIndex>& data)
+      : m_values(data.valuePtr()), m_indices(data.indexPtr()), m_outer(0), m_id(0), m_end(data.size())
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+    }
+
+    inline InnerIterator& operator++() { m_id++; return *this; }
+    inline InnerIterator& operator+=(Index i) { m_id += i ; return *this; }
+
+    inline InnerIterator operator+(Index i) 
+    { 
+        InnerIterator result = *this;
+        result += i;
+        return result;
+    }
+
+    inline const Scalar& value() const { return m_values[m_id]; }
+    inline Scalar& valueRef() { return const_cast<Scalar&>(m_values[m_id]); }
+
+    inline StorageIndex index() const { return m_indices[m_id]; }
+    inline Index outer() const { return m_outer.value(); }
+    inline Index row() const { return IsRowMajor ? m_outer.value() : index(); }
+    inline Index col() const { return IsRowMajor ? index() : m_outer.value(); }
+
+    inline operator bool() const { return (m_id < m_end); }
+
+  protected:
+    const Scalar* m_values;
+    const StorageIndex* m_indices;
+    typedef internal::variable_if_dynamic<Index,Derived::IsVectorAtCompileTime?0:Dynamic> OuterType;
+    const OuterType m_outer;
+    Index m_id;
+    Index m_end;
+  private:
+    // If you get here, then you're not using the right InnerIterator type, e.g.:
+    //   SparseMatrix<double,RowMajor> A;
+    //   SparseMatrix<double>::InnerIterator it(A,0);
+    template<typename T> InnerIterator(const SparseMatrixBase<T>&, Index outer);
+};
+
+template<typename Derived>
+class SparseCompressedBase<Derived>::ReverseInnerIterator
+{
+  public:
+    ReverseInnerIterator(const SparseCompressedBase& mat, Index outer)
+      : m_values(mat.valuePtr()), m_indices(mat.innerIndexPtr()), m_outer(outer)
+    {
+      if(Derived::IsVectorAtCompileTime && mat.outerIndexPtr()==0)
+      {
+        m_start = 0;
+        m_id = mat.nonZeros();
+      }
+      else
+      {
+        m_start = mat.outerIndexPtr()[outer];
+        if(mat.isCompressed())
+          m_id = mat.outerIndexPtr()[outer+1];
+        else
+          m_id = m_start + mat.innerNonZeroPtr()[outer];
+      }
+    }
+
+    explicit ReverseInnerIterator(const SparseCompressedBase& mat)
+      : m_values(mat.valuePtr()), m_indices(mat.innerIndexPtr()), m_outer(0), m_start(0), m_id(mat.nonZeros())
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+    }
+
+    explicit ReverseInnerIterator(const internal::CompressedStorage<Scalar,StorageIndex>& data)
+      : m_values(data.valuePtr()), m_indices(data.indexPtr()), m_outer(0), m_start(0), m_id(data.size())
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+    }
+
+    inline ReverseInnerIterator& operator--() { --m_id; return *this; }
+    inline ReverseInnerIterator& operator-=(Index i) { m_id -= i; return *this; }
+
+    inline ReverseInnerIterator operator-(Index i) 
+    {
+        ReverseInnerIterator result = *this;
+        result -= i;
+        return result;
+    }
+
+    inline const Scalar& value() const { return m_values[m_id-1]; }
+    inline Scalar& valueRef() { return const_cast<Scalar&>(m_values[m_id-1]); }
+
+    inline StorageIndex index() const { return m_indices[m_id-1]; }
+    inline Index outer() const { return m_outer.value(); }
+    inline Index row() const { return IsRowMajor ? m_outer.value() : index(); }
+    inline Index col() const { return IsRowMajor ? index() : m_outer.value(); }
+
+    inline operator bool() const { return (m_id > m_start); }
+
+  protected:
+    const Scalar* m_values;
+    const StorageIndex* m_indices;
+    typedef internal::variable_if_dynamic<Index,Derived::IsVectorAtCompileTime?0:Dynamic> OuterType;
+    const OuterType m_outer;
+    Index m_start;
+    Index m_id;
+};
+
+namespace internal {
+
+template<typename Derived>
+struct evaluator<SparseCompressedBase<Derived> >
+  : evaluator_base<Derived>
+{
+  typedef typename Derived::Scalar Scalar;
+  typedef typename Derived::InnerIterator InnerIterator;
+  
+  enum {
+    CoeffReadCost = NumTraits<Scalar>::ReadCost,
+    Flags = Derived::Flags
+  };
+  
+  evaluator() : m_matrix(0), m_zero(0)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+  explicit evaluator(const Derived &mat) : m_matrix(&mat), m_zero(0)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+  
+  inline Index nonZerosEstimate() const {
+    return m_matrix->nonZeros();
+  }
+  
+  operator Derived&() { return m_matrix->const_cast_derived(); }
+  operator const Derived&() const { return *m_matrix; }
+  
+  typedef typename DenseCoeffsBase<Derived,ReadOnlyAccessors>::CoeffReturnType CoeffReturnType;
+  const Scalar& coeff(Index row, Index col) const
+  {
+    Index p = find(row,col);
+
+    if(p==Dynamic)
+      return m_zero;
+    else
+      return m_matrix->const_cast_derived().valuePtr()[p];
+  }
+
+  Scalar& coeffRef(Index row, Index col)
+  {
+    Index p = find(row,col);
+    eigen_assert(p!=Dynamic && "written coefficient does not exist");
+    return m_matrix->const_cast_derived().valuePtr()[p];
+  }
+
+protected:
+
+  Index find(Index row, Index col) const
+  {
+    eigen_internal_assert(row>=0 && row<m_matrix->rows() && col>=0 && col<m_matrix->cols());
+
+    const Index outer = Derived::IsRowMajor ? row : col;
+    const Index inner = Derived::IsRowMajor ? col : row;
+
+    Index start = m_matrix->outerIndexPtr()[outer];
+    Index end = m_matrix->isCompressed() ? m_matrix->outerIndexPtr()[outer+1] : m_matrix->outerIndexPtr()[outer] + m_matrix->innerNonZeroPtr()[outer];
+    eigen_assert(end>=start && "you are using a non finalized sparse matrix or written coefficient does not exist");
+    const Index p = std::lower_bound(m_matrix->innerIndexPtr()+start, m_matrix->innerIndexPtr()+end,inner) - m_matrix->innerIndexPtr();
+
+    return ((p<end) && (m_matrix->innerIndexPtr()[p]==inner)) ? p : Dynamic;
+  }
+
+  const Derived *m_matrix;
+  const Scalar m_zero;
+};
+
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_COMPRESSED_BASE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseCwiseBinaryOp.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseCwiseBinaryOp.h
new file mode 100644
index 00000000..c41c07af
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseCwiseBinaryOp.h
@@ -0,0 +1,722 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_CWISE_BINARY_OP_H
+#define EIGEN_SPARSE_CWISE_BINARY_OP_H
+
+namespace Eigen { 
+
+// Here we have to handle 3 cases:
+//  1 - sparse op dense
+//  2 - dense op sparse
+//  3 - sparse op sparse
+// We also need to implement a 4th iterator for:
+//  4 - dense op dense
+// Finally, we also need to distinguish between the product and other operations :
+//                configuration      returned mode
+//  1 - sparse op dense    product      sparse
+//                         generic      dense
+//  2 - dense op sparse    product      sparse
+//                         generic      dense
+//  3 - sparse op sparse   product      sparse
+//                         generic      sparse
+//  4 - dense op dense     product      dense
+//                         generic      dense
+//
+// TODO to ease compiler job, we could specialize product/quotient with a scalar
+//      and fallback to cwise-unary evaluator using bind1st_op and bind2nd_op.
+
+template<typename BinaryOp, typename Lhs, typename Rhs>
+class CwiseBinaryOpImpl<BinaryOp, Lhs, Rhs, Sparse>
+  : public SparseMatrixBase<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
+{
+  public:
+    typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> Derived;
+    typedef SparseMatrixBase<Derived> Base;
+    EIGEN_SPARSE_PUBLIC_INTERFACE(Derived)
+    CwiseBinaryOpImpl()
+    {
+      EIGEN_STATIC_ASSERT((
+                (!internal::is_same<typename internal::traits<Lhs>::StorageKind,
+                                    typename internal::traits<Rhs>::StorageKind>::value)
+            ||  ((internal::evaluator<Lhs>::Flags&RowMajorBit) == (internal::evaluator<Rhs>::Flags&RowMajorBit))),
+            THE_STORAGE_ORDER_OF_BOTH_SIDES_MUST_MATCH);
+    }
+};
+
+namespace internal {
+
+  
+// Generic "sparse OP sparse"
+template<typename XprType> struct binary_sparse_evaluator;
+
+template<typename BinaryOp, typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>, IteratorBased, IteratorBased>
+  : evaluator_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
+{
+protected:
+  typedef typename evaluator<Lhs>::InnerIterator  LhsIterator;
+  typedef typename evaluator<Rhs>::InnerIterator  RhsIterator;
+  typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
+  typedef typename traits<XprType>::Scalar Scalar;
+  typedef typename XprType::StorageIndex StorageIndex;
+public:
+
+  class InnerIterator
+  {
+  public:
+    
+    EIGEN_STRONG_INLINE InnerIterator(const binary_evaluator& aEval, Index outer)
+      : m_lhsIter(aEval.m_lhsImpl,outer), m_rhsIter(aEval.m_rhsImpl,outer), m_functor(aEval.m_functor)
+    {
+      this->operator++();
+    }
+
+    EIGEN_STRONG_INLINE InnerIterator& operator++()
+    {
+      if (m_lhsIter && m_rhsIter && (m_lhsIter.index() == m_rhsIter.index()))
+      {
+        m_id = m_lhsIter.index();
+        m_value = m_functor(m_lhsIter.value(), m_rhsIter.value());
+        ++m_lhsIter;
+        ++m_rhsIter;
+      }
+      else if (m_lhsIter && (!m_rhsIter || (m_lhsIter.index() < m_rhsIter.index())))
+      {
+        m_id = m_lhsIter.index();
+        m_value = m_functor(m_lhsIter.value(), Scalar(0));
+        ++m_lhsIter;
+      }
+      else if (m_rhsIter && (!m_lhsIter || (m_lhsIter.index() > m_rhsIter.index())))
+      {
+        m_id = m_rhsIter.index();
+        m_value = m_functor(Scalar(0), m_rhsIter.value());
+        ++m_rhsIter;
+      }
+      else
+      {
+        m_value = 0; // this is to avoid a compilation warning
+        m_id = -1;
+      }
+      return *this;
+    }
+
+    EIGEN_STRONG_INLINE Scalar value() const { return m_value; }
+
+    EIGEN_STRONG_INLINE StorageIndex index() const { return m_id; }
+    EIGEN_STRONG_INLINE Index outer() const { return m_lhsIter.outer(); }
+    EIGEN_STRONG_INLINE Index row() const { return Lhs::IsRowMajor ? m_lhsIter.row() : index(); }
+    EIGEN_STRONG_INLINE Index col() const { return Lhs::IsRowMajor ? index() : m_lhsIter.col(); }
+
+    EIGEN_STRONG_INLINE operator bool() const { return m_id>=0; }
+
+  protected:
+    LhsIterator m_lhsIter;
+    RhsIterator m_rhsIter;
+    const BinaryOp& m_functor;
+    Scalar m_value;
+    StorageIndex m_id;
+  };
+  
+  
+  enum {
+    CoeffReadCost = evaluator<Lhs>::CoeffReadCost + evaluator<Rhs>::CoeffReadCost + functor_traits<BinaryOp>::Cost,
+    Flags = XprType::Flags
+  };
+  
+  explicit binary_evaluator(const XprType& xpr)
+    : m_functor(xpr.functor()),
+      m_lhsImpl(xpr.lhs()), 
+      m_rhsImpl(xpr.rhs())  
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<BinaryOp>::Cost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+  
+  inline Index nonZerosEstimate() const {
+    return m_lhsImpl.nonZerosEstimate() + m_rhsImpl.nonZerosEstimate();
+  }
+
+protected:
+  const BinaryOp m_functor;
+  evaluator<Lhs> m_lhsImpl;
+  evaluator<Rhs> m_rhsImpl;
+};
+
+// dense op sparse
+template<typename BinaryOp, typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>, IndexBased, IteratorBased>
+  : evaluator_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
+{
+protected:
+  typedef typename evaluator<Rhs>::InnerIterator  RhsIterator;
+  typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
+  typedef typename traits<XprType>::Scalar Scalar;
+  typedef typename XprType::StorageIndex StorageIndex;
+public:
+
+  class InnerIterator
+  {
+    enum { IsRowMajor = (int(Rhs::Flags)&RowMajorBit)==RowMajorBit };
+  public:
+
+    EIGEN_STRONG_INLINE InnerIterator(const binary_evaluator& aEval, Index outer)
+      : m_lhsEval(aEval.m_lhsImpl), m_rhsIter(aEval.m_rhsImpl,outer), m_functor(aEval.m_functor), m_value(0), m_id(-1), m_innerSize(aEval.m_expr.rhs().innerSize())
+    {
+      this->operator++();
+    }
+
+    EIGEN_STRONG_INLINE InnerIterator& operator++()
+    {
+      ++m_id;
+      if(m_id<m_innerSize)
+      {
+        Scalar lhsVal = m_lhsEval.coeff(IsRowMajor?m_rhsIter.outer():m_id,
+                                        IsRowMajor?m_id:m_rhsIter.outer());
+        if(m_rhsIter && m_rhsIter.index()==m_id)
+        {
+          m_value = m_functor(lhsVal, m_rhsIter.value());
+          ++m_rhsIter;
+        }
+        else
+          m_value = m_functor(lhsVal, Scalar(0));
+      }
+
+      return *this;
+    }
+
+    EIGEN_STRONG_INLINE Scalar value() const { eigen_internal_assert(m_id<m_innerSize); return m_value; }
+
+    EIGEN_STRONG_INLINE StorageIndex index() const { return m_id; }
+    EIGEN_STRONG_INLINE Index outer() const { return m_rhsIter.outer(); }
+    EIGEN_STRONG_INLINE Index row() const { return IsRowMajor ? m_rhsIter.outer() : m_id; }
+    EIGEN_STRONG_INLINE Index col() const { return IsRowMajor ? m_id : m_rhsIter.outer(); }
+
+    EIGEN_STRONG_INLINE operator bool() const { return m_id<m_innerSize; }
+
+  protected:
+    const evaluator<Lhs> &m_lhsEval;
+    RhsIterator m_rhsIter;
+    const BinaryOp& m_functor;
+    Scalar m_value;
+    StorageIndex m_id;
+    StorageIndex m_innerSize;
+  };
+
+
+  enum {
+    CoeffReadCost = evaluator<Lhs>::CoeffReadCost + evaluator<Rhs>::CoeffReadCost + functor_traits<BinaryOp>::Cost,
+    Flags = XprType::Flags
+  };
+
+  explicit binary_evaluator(const XprType& xpr)
+    : m_functor(xpr.functor()),
+      m_lhsImpl(xpr.lhs()),
+      m_rhsImpl(xpr.rhs()),
+      m_expr(xpr)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<BinaryOp>::Cost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  inline Index nonZerosEstimate() const {
+    return m_expr.size();
+  }
+
+protected:
+  const BinaryOp m_functor;
+  evaluator<Lhs> m_lhsImpl;
+  evaluator<Rhs> m_rhsImpl;
+  const XprType &m_expr;
+};
+
+// sparse op dense
+template<typename BinaryOp, typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>, IteratorBased, IndexBased>
+  : evaluator_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
+{
+protected:
+  typedef typename evaluator<Lhs>::InnerIterator  LhsIterator;
+  typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
+  typedef typename traits<XprType>::Scalar Scalar;
+  typedef typename XprType::StorageIndex StorageIndex;
+public:
+
+  class InnerIterator
+  {
+    enum { IsRowMajor = (int(Lhs::Flags)&RowMajorBit)==RowMajorBit };
+  public:
+
+    EIGEN_STRONG_INLINE InnerIterator(const binary_evaluator& aEval, Index outer)
+      : m_lhsIter(aEval.m_lhsImpl,outer), m_rhsEval(aEval.m_rhsImpl), m_functor(aEval.m_functor), m_value(0), m_id(-1), m_innerSize(aEval.m_expr.lhs().innerSize())
+    {
+      this->operator++();
+    }
+
+    EIGEN_STRONG_INLINE InnerIterator& operator++()
+    {
+      ++m_id;
+      if(m_id<m_innerSize)
+      {
+        Scalar rhsVal = m_rhsEval.coeff(IsRowMajor?m_lhsIter.outer():m_id,
+                                        IsRowMajor?m_id:m_lhsIter.outer());
+        if(m_lhsIter && m_lhsIter.index()==m_id)
+        {
+          m_value = m_functor(m_lhsIter.value(), rhsVal);
+          ++m_lhsIter;
+        }
+        else
+          m_value = m_functor(Scalar(0),rhsVal);
+      }
+
+      return *this;
+    }
+
+    EIGEN_STRONG_INLINE Scalar value() const { eigen_internal_assert(m_id<m_innerSize); return m_value; }
+
+    EIGEN_STRONG_INLINE StorageIndex index() const { return m_id; }
+    EIGEN_STRONG_INLINE Index outer() const { return m_lhsIter.outer(); }
+    EIGEN_STRONG_INLINE Index row() const { return IsRowMajor ? m_lhsIter.outer() : m_id; }
+    EIGEN_STRONG_INLINE Index col() const { return IsRowMajor ? m_id : m_lhsIter.outer(); }
+
+    EIGEN_STRONG_INLINE operator bool() const { return m_id<m_innerSize; }
+
+  protected:
+    LhsIterator m_lhsIter;
+    const evaluator<Rhs> &m_rhsEval;
+    const BinaryOp& m_functor;
+    Scalar m_value;
+    StorageIndex m_id;
+    StorageIndex m_innerSize;
+  };
+
+
+  enum {
+    CoeffReadCost = evaluator<Lhs>::CoeffReadCost + evaluator<Rhs>::CoeffReadCost + functor_traits<BinaryOp>::Cost,
+    Flags = XprType::Flags
+  };
+
+  explicit binary_evaluator(const XprType& xpr)
+    : m_functor(xpr.functor()),
+      m_lhsImpl(xpr.lhs()),
+      m_rhsImpl(xpr.rhs()),
+      m_expr(xpr)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<BinaryOp>::Cost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  inline Index nonZerosEstimate() const {
+    return m_expr.size();
+  }
+
+protected:
+  const BinaryOp m_functor;
+  evaluator<Lhs> m_lhsImpl;
+  evaluator<Rhs> m_rhsImpl;
+  const XprType &m_expr;
+};
+
+template<typename T,
+         typename LhsKind   = typename evaluator_traits<typename T::Lhs>::Kind,
+         typename RhsKind   = typename evaluator_traits<typename T::Rhs>::Kind,
+         typename LhsScalar = typename traits<typename T::Lhs>::Scalar,
+         typename RhsScalar = typename traits<typename T::Rhs>::Scalar> struct sparse_conjunction_evaluator;
+
+// "sparse .* sparse"
+template<typename T1, typename T2, typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs>, IteratorBased, IteratorBased>
+  : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs> >
+{
+  typedef CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs> XprType;
+  typedef sparse_conjunction_evaluator<XprType> Base;
+  explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
+};
+// "dense .* sparse"
+template<typename T1, typename T2, typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs>, IndexBased, IteratorBased>
+  : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs> >
+{
+  typedef CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs> XprType;
+  typedef sparse_conjunction_evaluator<XprType> Base;
+  explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
+};
+// "sparse .* dense"
+template<typename T1, typename T2, typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs>, IteratorBased, IndexBased>
+  : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs> >
+{
+  typedef CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs> XprType;
+  typedef sparse_conjunction_evaluator<XprType> Base;
+  explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
+};
+
+// "sparse ./ dense"
+template<typename T1, typename T2, typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<scalar_quotient_op<T1,T2>, Lhs, Rhs>, IteratorBased, IndexBased>
+  : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_quotient_op<T1,T2>, Lhs, Rhs> >
+{
+  typedef CwiseBinaryOp<scalar_quotient_op<T1,T2>, Lhs, Rhs> XprType;
+  typedef sparse_conjunction_evaluator<XprType> Base;
+  explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
+};
+
+// "sparse && sparse"
+template<typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs>, IteratorBased, IteratorBased>
+  : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs> >
+{
+  typedef CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs> XprType;
+  typedef sparse_conjunction_evaluator<XprType> Base;
+  explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
+};
+// "dense && sparse"
+template<typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs>, IndexBased, IteratorBased>
+  : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs> >
+{
+  typedef CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs> XprType;
+  typedef sparse_conjunction_evaluator<XprType> Base;
+  explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
+};
+// "sparse && dense"
+template<typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs>, IteratorBased, IndexBased>
+  : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs> >
+{
+  typedef CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs> XprType;
+  typedef sparse_conjunction_evaluator<XprType> Base;
+  explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
+};
+
+// "sparse ^ sparse"
+template<typename XprType>
+struct sparse_conjunction_evaluator<XprType, IteratorBased, IteratorBased>
+  : evaluator_base<XprType>
+{
+protected:
+  typedef typename XprType::Functor BinaryOp;
+  typedef typename XprType::Lhs LhsArg;
+  typedef typename XprType::Rhs RhsArg;
+  typedef typename evaluator<LhsArg>::InnerIterator  LhsIterator;
+  typedef typename evaluator<RhsArg>::InnerIterator  RhsIterator;
+  typedef typename XprType::StorageIndex StorageIndex;
+  typedef typename traits<XprType>::Scalar Scalar;
+public:
+
+  class InnerIterator
+  {
+  public:
+    
+    EIGEN_STRONG_INLINE InnerIterator(const sparse_conjunction_evaluator& aEval, Index outer)
+      : m_lhsIter(aEval.m_lhsImpl,outer), m_rhsIter(aEval.m_rhsImpl,outer), m_functor(aEval.m_functor)
+    {
+      while (m_lhsIter && m_rhsIter && (m_lhsIter.index() != m_rhsIter.index()))
+      {
+        if (m_lhsIter.index() < m_rhsIter.index())
+          ++m_lhsIter;
+        else
+          ++m_rhsIter;
+      }
+    }
+
+    EIGEN_STRONG_INLINE InnerIterator& operator++()
+    {
+      ++m_lhsIter;
+      ++m_rhsIter;
+      while (m_lhsIter && m_rhsIter && (m_lhsIter.index() != m_rhsIter.index()))
+      {
+        if (m_lhsIter.index() < m_rhsIter.index())
+          ++m_lhsIter;
+        else
+          ++m_rhsIter;
+      }
+      return *this;
+    }
+    
+    EIGEN_STRONG_INLINE Scalar value() const { return m_functor(m_lhsIter.value(), m_rhsIter.value()); }
+
+    EIGEN_STRONG_INLINE StorageIndex index() const { return m_lhsIter.index(); }
+    EIGEN_STRONG_INLINE Index outer() const { return m_lhsIter.outer(); }
+    EIGEN_STRONG_INLINE Index row() const { return m_lhsIter.row(); }
+    EIGEN_STRONG_INLINE Index col() const { return m_lhsIter.col(); }
+
+    EIGEN_STRONG_INLINE operator bool() const { return (m_lhsIter && m_rhsIter); }
+
+  protected:
+    LhsIterator m_lhsIter;
+    RhsIterator m_rhsIter;
+    const BinaryOp& m_functor;
+  };
+  
+  
+  enum {
+    CoeffReadCost = evaluator<LhsArg>::CoeffReadCost + evaluator<RhsArg>::CoeffReadCost + functor_traits<BinaryOp>::Cost,
+    Flags = XprType::Flags
+  };
+  
+  explicit sparse_conjunction_evaluator(const XprType& xpr)
+    : m_functor(xpr.functor()),
+      m_lhsImpl(xpr.lhs()), 
+      m_rhsImpl(xpr.rhs())  
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<BinaryOp>::Cost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+  
+  inline Index nonZerosEstimate() const {
+    return (std::min)(m_lhsImpl.nonZerosEstimate(), m_rhsImpl.nonZerosEstimate());
+  }
+
+protected:
+  const BinaryOp m_functor;
+  evaluator<LhsArg> m_lhsImpl;
+  evaluator<RhsArg> m_rhsImpl;
+};
+
+// "dense ^ sparse"
+template<typename XprType>
+struct sparse_conjunction_evaluator<XprType, IndexBased, IteratorBased>
+  : evaluator_base<XprType>
+{
+protected:
+  typedef typename XprType::Functor BinaryOp;
+  typedef typename XprType::Lhs LhsArg;
+  typedef typename XprType::Rhs RhsArg;
+  typedef evaluator<LhsArg> LhsEvaluator;
+  typedef typename evaluator<RhsArg>::InnerIterator  RhsIterator;
+  typedef typename XprType::StorageIndex StorageIndex;
+  typedef typename traits<XprType>::Scalar Scalar;
+public:
+
+  class InnerIterator
+  {
+    enum { IsRowMajor = (int(RhsArg::Flags)&RowMajorBit)==RowMajorBit };
+
+  public:
+    
+    EIGEN_STRONG_INLINE InnerIterator(const sparse_conjunction_evaluator& aEval, Index outer)
+      : m_lhsEval(aEval.m_lhsImpl), m_rhsIter(aEval.m_rhsImpl,outer), m_functor(aEval.m_functor), m_outer(outer)
+    {}
+
+    EIGEN_STRONG_INLINE InnerIterator& operator++()
+    {
+      ++m_rhsIter;
+      return *this;
+    }
+
+    EIGEN_STRONG_INLINE Scalar value() const
+    { return m_functor(m_lhsEval.coeff(IsRowMajor?m_outer:m_rhsIter.index(),IsRowMajor?m_rhsIter.index():m_outer), m_rhsIter.value()); }
+
+    EIGEN_STRONG_INLINE StorageIndex index() const { return m_rhsIter.index(); }
+    EIGEN_STRONG_INLINE Index outer() const { return m_rhsIter.outer(); }
+    EIGEN_STRONG_INLINE Index row() const { return m_rhsIter.row(); }
+    EIGEN_STRONG_INLINE Index col() const { return m_rhsIter.col(); }
+
+    EIGEN_STRONG_INLINE operator bool() const { return m_rhsIter; }
+    
+  protected:
+    const LhsEvaluator &m_lhsEval;
+    RhsIterator m_rhsIter;
+    const BinaryOp& m_functor;
+    const Index m_outer;
+  };
+  
+  
+  enum {
+    CoeffReadCost = evaluator<LhsArg>::CoeffReadCost + evaluator<RhsArg>::CoeffReadCost + functor_traits<BinaryOp>::Cost,
+    Flags = XprType::Flags
+  };
+  
+  explicit sparse_conjunction_evaluator(const XprType& xpr)
+    : m_functor(xpr.functor()),
+      m_lhsImpl(xpr.lhs()), 
+      m_rhsImpl(xpr.rhs())  
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<BinaryOp>::Cost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+  
+  inline Index nonZerosEstimate() const {
+    return m_rhsImpl.nonZerosEstimate();
+  }
+
+protected:
+  const BinaryOp m_functor;
+  evaluator<LhsArg> m_lhsImpl;
+  evaluator<RhsArg> m_rhsImpl;
+};
+
+// "sparse ^ dense"
+template<typename XprType>
+struct sparse_conjunction_evaluator<XprType, IteratorBased, IndexBased>
+  : evaluator_base<XprType>
+{
+protected:
+  typedef typename XprType::Functor BinaryOp;
+  typedef typename XprType::Lhs LhsArg;
+  typedef typename XprType::Rhs RhsArg;
+  typedef typename evaluator<LhsArg>::InnerIterator LhsIterator;
+  typedef evaluator<RhsArg> RhsEvaluator;
+  typedef typename XprType::StorageIndex StorageIndex;
+  typedef typename traits<XprType>::Scalar Scalar;
+public:
+
+  class InnerIterator
+  {
+    enum { IsRowMajor = (int(LhsArg::Flags)&RowMajorBit)==RowMajorBit };
+
+  public:
+    
+    EIGEN_STRONG_INLINE InnerIterator(const sparse_conjunction_evaluator& aEval, Index outer)
+      : m_lhsIter(aEval.m_lhsImpl,outer), m_rhsEval(aEval.m_rhsImpl), m_functor(aEval.m_functor), m_outer(outer)
+    {}
+
+    EIGEN_STRONG_INLINE InnerIterator& operator++()
+    {
+      ++m_lhsIter;
+      return *this;
+    }
+
+    EIGEN_STRONG_INLINE Scalar value() const
+    { return m_functor(m_lhsIter.value(),
+                       m_rhsEval.coeff(IsRowMajor?m_outer:m_lhsIter.index(),IsRowMajor?m_lhsIter.index():m_outer)); }
+
+    EIGEN_STRONG_INLINE StorageIndex index() const { return m_lhsIter.index(); }
+    EIGEN_STRONG_INLINE Index outer() const { return m_lhsIter.outer(); }
+    EIGEN_STRONG_INLINE Index row() const { return m_lhsIter.row(); }
+    EIGEN_STRONG_INLINE Index col() const { return m_lhsIter.col(); }
+
+    EIGEN_STRONG_INLINE operator bool() const { return m_lhsIter; }
+    
+  protected:
+    LhsIterator m_lhsIter;
+    const evaluator<RhsArg> &m_rhsEval;
+    const BinaryOp& m_functor;
+    const Index m_outer;
+  };
+  
+  
+  enum {
+    CoeffReadCost = evaluator<LhsArg>::CoeffReadCost + evaluator<RhsArg>::CoeffReadCost + functor_traits<BinaryOp>::Cost,
+    Flags = XprType::Flags
+  };
+  
+  explicit sparse_conjunction_evaluator(const XprType& xpr)
+    : m_functor(xpr.functor()),
+      m_lhsImpl(xpr.lhs()), 
+      m_rhsImpl(xpr.rhs())  
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<BinaryOp>::Cost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+  
+  inline Index nonZerosEstimate() const {
+    return m_lhsImpl.nonZerosEstimate();
+  }
+
+protected:
+  const BinaryOp m_functor;
+  evaluator<LhsArg> m_lhsImpl;
+  evaluator<RhsArg> m_rhsImpl;
+};
+
+}
+
+/***************************************************************************
+* Implementation of SparseMatrixBase and SparseCwise functions/operators
+***************************************************************************/
+
+template<typename Derived>
+template<typename OtherDerived>
+Derived& SparseMatrixBase<Derived>::operator+=(const EigenBase<OtherDerived> &other)
+{
+  call_assignment(derived(), other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+Derived& SparseMatrixBase<Derived>::operator-=(const EigenBase<OtherDerived> &other)
+{
+  call_assignment(derived(), other.derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_STRONG_INLINE Derived &
+SparseMatrixBase<Derived>::operator-=(const SparseMatrixBase<OtherDerived> &other)
+{
+  return derived() = derived() - other.derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_STRONG_INLINE Derived &
+SparseMatrixBase<Derived>::operator+=(const SparseMatrixBase<OtherDerived>& other)
+{
+  return derived() = derived() + other.derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+Derived& SparseMatrixBase<Derived>::operator+=(const DiagonalBase<OtherDerived>& other)
+{
+  call_assignment_no_alias(derived(), other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+Derived& SparseMatrixBase<Derived>::operator-=(const DiagonalBase<OtherDerived>& other)
+{
+  call_assignment_no_alias(derived(), other.derived(), internal::sub_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+    
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_STRONG_INLINE const typename SparseMatrixBase<Derived>::template CwiseProductDenseReturnType<OtherDerived>::Type
+SparseMatrixBase<Derived>::cwiseProduct(const MatrixBase<OtherDerived> &other) const
+{
+  return typename CwiseProductDenseReturnType<OtherDerived>::Type(derived(), other.derived());
+}
+
+template<typename DenseDerived, typename SparseDerived>
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_sum_op<typename DenseDerived::Scalar,typename SparseDerived::Scalar>, const DenseDerived, const SparseDerived>
+operator+(const MatrixBase<DenseDerived> &a, const SparseMatrixBase<SparseDerived> &b)
+{
+  return CwiseBinaryOp<internal::scalar_sum_op<typename DenseDerived::Scalar,typename SparseDerived::Scalar>, const DenseDerived, const SparseDerived>(a.derived(), b.derived());
+}
+
+template<typename SparseDerived, typename DenseDerived>
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_sum_op<typename SparseDerived::Scalar,typename DenseDerived::Scalar>, const SparseDerived, const DenseDerived>
+operator+(const SparseMatrixBase<SparseDerived> &a, const MatrixBase<DenseDerived> &b)
+{
+  return CwiseBinaryOp<internal::scalar_sum_op<typename SparseDerived::Scalar,typename DenseDerived::Scalar>, const SparseDerived, const DenseDerived>(a.derived(), b.derived());
+}
+
+template<typename DenseDerived, typename SparseDerived>
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_difference_op<typename DenseDerived::Scalar,typename SparseDerived::Scalar>, const DenseDerived, const SparseDerived>
+operator-(const MatrixBase<DenseDerived> &a, const SparseMatrixBase<SparseDerived> &b)
+{
+  return CwiseBinaryOp<internal::scalar_difference_op<typename DenseDerived::Scalar,typename SparseDerived::Scalar>, const DenseDerived, const SparseDerived>(a.derived(), b.derived());
+}
+
+template<typename SparseDerived, typename DenseDerived>
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_difference_op<typename SparseDerived::Scalar,typename DenseDerived::Scalar>, const SparseDerived, const DenseDerived>
+operator-(const SparseMatrixBase<SparseDerived> &a, const MatrixBase<DenseDerived> &b)
+{
+  return CwiseBinaryOp<internal::scalar_difference_op<typename SparseDerived::Scalar,typename DenseDerived::Scalar>, const SparseDerived, const DenseDerived>(a.derived(), b.derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_CWISE_BINARY_OP_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseCwiseUnaryOp.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseCwiseUnaryOp.h
new file mode 100644
index 00000000..ea797379
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseCwiseUnaryOp.h
@@ -0,0 +1,148 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_CWISE_UNARY_OP_H
+#define EIGEN_SPARSE_CWISE_UNARY_OP_H
+
+namespace Eigen { 
+
+namespace internal {
+  
+template<typename UnaryOp, typename ArgType>
+struct unary_evaluator<CwiseUnaryOp<UnaryOp,ArgType>, IteratorBased>
+  : public evaluator_base<CwiseUnaryOp<UnaryOp,ArgType> >
+{
+  public:
+    typedef CwiseUnaryOp<UnaryOp, ArgType> XprType;
+
+    class InnerIterator;
+    
+    enum {
+      CoeffReadCost = evaluator<ArgType>::CoeffReadCost + functor_traits<UnaryOp>::Cost,
+      Flags = XprType::Flags
+    };
+    
+    explicit unary_evaluator(const XprType& op) : m_functor(op.functor()), m_argImpl(op.nestedExpression())
+    {
+      EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<UnaryOp>::Cost);
+      EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+    }
+    
+    inline Index nonZerosEstimate() const {
+      return m_argImpl.nonZerosEstimate();
+    }
+
+  protected:
+    typedef typename evaluator<ArgType>::InnerIterator        EvalIterator;
+    
+    const UnaryOp m_functor;
+    evaluator<ArgType> m_argImpl;
+};
+
+template<typename UnaryOp, typename ArgType>
+class unary_evaluator<CwiseUnaryOp<UnaryOp,ArgType>, IteratorBased>::InnerIterator
+    : public unary_evaluator<CwiseUnaryOp<UnaryOp,ArgType>, IteratorBased>::EvalIterator
+{
+    typedef typename XprType::Scalar Scalar;
+    typedef typename unary_evaluator<CwiseUnaryOp<UnaryOp,ArgType>, IteratorBased>::EvalIterator Base;
+  public:
+
+    EIGEN_STRONG_INLINE InnerIterator(const unary_evaluator& unaryOp, Index outer)
+      : Base(unaryOp.m_argImpl,outer), m_functor(unaryOp.m_functor)
+    {}
+
+    EIGEN_STRONG_INLINE InnerIterator& operator++()
+    { Base::operator++(); return *this; }
+
+    EIGEN_STRONG_INLINE Scalar value() const { return m_functor(Base::value()); }
+
+  protected:
+    const UnaryOp m_functor;
+  private:
+    Scalar& valueRef();
+};
+
+template<typename ViewOp, typename ArgType>
+struct unary_evaluator<CwiseUnaryView<ViewOp,ArgType>, IteratorBased>
+  : public evaluator_base<CwiseUnaryView<ViewOp,ArgType> >
+{
+  public:
+    typedef CwiseUnaryView<ViewOp, ArgType> XprType;
+
+    class InnerIterator;
+    
+    enum {
+      CoeffReadCost = evaluator<ArgType>::CoeffReadCost + functor_traits<ViewOp>::Cost,
+      Flags = XprType::Flags
+    };
+    
+    explicit unary_evaluator(const XprType& op) : m_functor(op.functor()), m_argImpl(op.nestedExpression())
+    {
+      EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<ViewOp>::Cost);
+      EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+    }
+
+  protected:
+    typedef typename evaluator<ArgType>::InnerIterator        EvalIterator;
+    
+    const ViewOp m_functor;
+    evaluator<ArgType> m_argImpl;
+};
+
+template<typename ViewOp, typename ArgType>
+class unary_evaluator<CwiseUnaryView<ViewOp,ArgType>, IteratorBased>::InnerIterator
+    : public unary_evaluator<CwiseUnaryView<ViewOp,ArgType>, IteratorBased>::EvalIterator
+{
+    typedef typename XprType::Scalar Scalar;
+    typedef typename unary_evaluator<CwiseUnaryView<ViewOp,ArgType>, IteratorBased>::EvalIterator Base;
+  public:
+
+    EIGEN_STRONG_INLINE InnerIterator(const unary_evaluator& unaryOp, Index outer)
+      : Base(unaryOp.m_argImpl,outer), m_functor(unaryOp.m_functor)
+    {}
+
+    EIGEN_STRONG_INLINE InnerIterator& operator++()
+    { Base::operator++(); return *this; }
+
+    EIGEN_STRONG_INLINE Scalar value() const { return m_functor(Base::value()); }
+    EIGEN_STRONG_INLINE Scalar& valueRef() { return m_functor(Base::valueRef()); }
+
+  protected:
+    const ViewOp m_functor;
+};
+
+} // end namespace internal
+
+template<typename Derived>
+EIGEN_STRONG_INLINE Derived&
+SparseMatrixBase<Derived>::operator*=(const Scalar& other)
+{
+  typedef typename internal::evaluator<Derived>::InnerIterator EvalIterator;
+  internal::evaluator<Derived> thisEval(derived());
+  for (Index j=0; j<outerSize(); ++j)
+    for (EvalIterator i(thisEval,j); i; ++i)
+      i.valueRef() *= other;
+  return derived();
+}
+
+template<typename Derived>
+EIGEN_STRONG_INLINE Derived&
+SparseMatrixBase<Derived>::operator/=(const Scalar& other)
+{
+  typedef typename internal::evaluator<Derived>::InnerIterator EvalIterator;
+  internal::evaluator<Derived> thisEval(derived());
+  for (Index j=0; j<outerSize(); ++j)
+    for (EvalIterator i(thisEval,j); i; ++i)
+      i.valueRef() /= other;
+  return derived();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_CWISE_UNARY_OP_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseDenseProduct.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseDenseProduct.h
new file mode 100644
index 00000000..0547db59
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseDenseProduct.h
@@ -0,0 +1,320 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSEDENSEPRODUCT_H
+#define EIGEN_SPARSEDENSEPRODUCT_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template <> struct product_promote_storage_type<Sparse,Dense, OuterProduct> { typedef Sparse ret; };
+template <> struct product_promote_storage_type<Dense,Sparse, OuterProduct> { typedef Sparse ret; };
+
+template<typename SparseLhsType, typename DenseRhsType, typename DenseResType,
+         typename AlphaType,
+         int LhsStorageOrder = ((SparseLhsType::Flags&RowMajorBit)==RowMajorBit) ? RowMajor : ColMajor,
+         bool ColPerCol = ((DenseRhsType::Flags&RowMajorBit)==0) || DenseRhsType::ColsAtCompileTime==1>
+struct sparse_time_dense_product_impl;
+
+template<typename SparseLhsType, typename DenseRhsType, typename DenseResType>
+struct sparse_time_dense_product_impl<SparseLhsType,DenseRhsType,DenseResType, typename DenseResType::Scalar, RowMajor, true>
+{
+  typedef typename internal::remove_all<SparseLhsType>::type Lhs;
+  typedef typename internal::remove_all<DenseRhsType>::type Rhs;
+  typedef typename internal::remove_all<DenseResType>::type Res;
+  typedef typename evaluator<Lhs>::InnerIterator LhsInnerIterator;
+  typedef evaluator<Lhs> LhsEval;
+  static void run(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res, const typename Res::Scalar& alpha)
+  {
+    LhsEval lhsEval(lhs);
+    
+    Index n = lhs.outerSize();
+#ifdef EIGEN_HAS_OPENMP
+    Eigen::initParallel();
+    Index threads = Eigen::nbThreads();
+#endif
+    
+    for(Index c=0; c<rhs.cols(); ++c)
+    {
+#ifdef EIGEN_HAS_OPENMP
+      // This 20000 threshold has been found experimentally on 2D and 3D Poisson problems.
+      // It basically represents the minimal amount of work to be done to be worth it.
+      if(threads>1 && lhsEval.nonZerosEstimate() > 20000)
+      {
+        #pragma omp parallel for schedule(dynamic,(n+threads*4-1)/(threads*4)) num_threads(threads)
+        for(Index i=0; i<n; ++i)
+          processRow(lhsEval,rhs,res,alpha,i,c);
+      }
+      else
+#endif
+      {
+        for(Index i=0; i<n; ++i)
+          processRow(lhsEval,rhs,res,alpha,i,c);
+      }
+    }
+  }
+  
+  static void processRow(const LhsEval& lhsEval, const DenseRhsType& rhs, DenseResType& res, const typename Res::Scalar& alpha, Index i, Index col)
+  {
+    typename Res::Scalar tmp(0);
+    for(LhsInnerIterator it(lhsEval,i); it ;++it)
+      tmp += it.value() * rhs.coeff(it.index(),col);
+    res.coeffRef(i,col) += alpha * tmp;
+  }
+  
+};
+
+// FIXME: what is the purpose of the following specialization? Is it for the BlockedSparse format?
+// -> let's disable it for now as it is conflicting with generic scalar*matrix and matrix*scalar operators
+// template<typename T1, typename T2/*, int _Options, typename _StrideType*/>
+// struct ScalarBinaryOpTraits<T1, Ref<T2/*, _Options, _StrideType*/> >
+// {
+//   enum {
+//     Defined = 1
+//   };
+//   typedef typename CwiseUnaryOp<scalar_multiple2_op<T1, typename T2::Scalar>, T2>::PlainObject ReturnType;
+// };
+
+template<typename SparseLhsType, typename DenseRhsType, typename DenseResType, typename AlphaType>
+struct sparse_time_dense_product_impl<SparseLhsType,DenseRhsType,DenseResType, AlphaType, ColMajor, true>
+{
+  typedef typename internal::remove_all<SparseLhsType>::type Lhs;
+  typedef typename internal::remove_all<DenseRhsType>::type Rhs;
+  typedef typename internal::remove_all<DenseResType>::type Res;
+  typedef typename evaluator<Lhs>::InnerIterator LhsInnerIterator;
+  static void run(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res, const AlphaType& alpha)
+  {
+    evaluator<Lhs> lhsEval(lhs);
+    for(Index c=0; c<rhs.cols(); ++c)
+    {
+      for(Index j=0; j<lhs.outerSize(); ++j)
+      {
+//        typename Res::Scalar rhs_j = alpha * rhs.coeff(j,c);
+        typename ScalarBinaryOpTraits<AlphaType, typename Rhs::Scalar>::ReturnType rhs_j(alpha * rhs.coeff(j,c));
+        for(LhsInnerIterator it(lhsEval,j); it ;++it)
+          res.coeffRef(it.index(),c) += it.value() * rhs_j;
+      }
+    }
+  }
+};
+
+template<typename SparseLhsType, typename DenseRhsType, typename DenseResType>
+struct sparse_time_dense_product_impl<SparseLhsType,DenseRhsType,DenseResType, typename DenseResType::Scalar, RowMajor, false>
+{
+  typedef typename internal::remove_all<SparseLhsType>::type Lhs;
+  typedef typename internal::remove_all<DenseRhsType>::type Rhs;
+  typedef typename internal::remove_all<DenseResType>::type Res;
+  typedef typename evaluator<Lhs>::InnerIterator LhsInnerIterator;
+  static void run(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res, const typename Res::Scalar& alpha)
+  {
+    evaluator<Lhs> lhsEval(lhs);
+    for(Index j=0; j<lhs.outerSize(); ++j)
+    {
+      typename Res::RowXpr res_j(res.row(j));
+      for(LhsInnerIterator it(lhsEval,j); it ;++it)
+        res_j += (alpha*it.value()) * rhs.row(it.index());
+    }
+  }
+};
+
+template<typename SparseLhsType, typename DenseRhsType, typename DenseResType>
+struct sparse_time_dense_product_impl<SparseLhsType,DenseRhsType,DenseResType, typename DenseResType::Scalar, ColMajor, false>
+{
+  typedef typename internal::remove_all<SparseLhsType>::type Lhs;
+  typedef typename internal::remove_all<DenseRhsType>::type Rhs;
+  typedef typename internal::remove_all<DenseResType>::type Res;
+  typedef typename evaluator<Lhs>::InnerIterator LhsInnerIterator;
+  static void run(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res, const typename Res::Scalar& alpha)
+  {
+    evaluator<Lhs> lhsEval(lhs);
+    for(Index j=0; j<lhs.outerSize(); ++j)
+    {
+      typename Rhs::ConstRowXpr rhs_j(rhs.row(j));
+      for(LhsInnerIterator it(lhsEval,j); it ;++it)
+        res.row(it.index()) += (alpha*it.value()) * rhs_j;
+    }
+  }
+};
+
+template<typename SparseLhsType, typename DenseRhsType, typename DenseResType,typename AlphaType>
+inline void sparse_time_dense_product(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res, const AlphaType& alpha)
+{
+  sparse_time_dense_product_impl<SparseLhsType,DenseRhsType,DenseResType, AlphaType>::run(lhs, rhs, res, alpha);
+}
+
+} // end namespace internal
+
+namespace internal {
+
+template<typename Lhs, typename Rhs, int ProductType>
+struct generic_product_impl<Lhs, Rhs, SparseShape, DenseShape, ProductType>
+ : generic_product_impl_base<Lhs,Rhs,generic_product_impl<Lhs,Rhs,SparseShape,DenseShape,ProductType> >
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+  
+  template<typename Dest>
+  static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
+  {
+    typedef typename nested_eval<Lhs,((Rhs::Flags&RowMajorBit)==0) ? 1 : Rhs::ColsAtCompileTime>::type LhsNested;
+    typedef typename nested_eval<Rhs,((Lhs::Flags&RowMajorBit)==0) ? 1 : Dynamic>::type RhsNested;
+    LhsNested lhsNested(lhs);
+    RhsNested rhsNested(rhs);
+    internal::sparse_time_dense_product(lhsNested, rhsNested, dst, alpha);
+  }
+};
+
+template<typename Lhs, typename Rhs, int ProductType>
+struct generic_product_impl<Lhs, Rhs, SparseTriangularShape, DenseShape, ProductType>
+  : generic_product_impl<Lhs, Rhs, SparseShape, DenseShape, ProductType>
+{};
+
+template<typename Lhs, typename Rhs, int ProductType>
+struct generic_product_impl<Lhs, Rhs, DenseShape, SparseShape, ProductType>
+  : generic_product_impl_base<Lhs,Rhs,generic_product_impl<Lhs,Rhs,DenseShape,SparseShape,ProductType> >
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+  
+  template<typename Dst>
+  static void scaleAndAddTo(Dst& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
+  {
+    typedef typename nested_eval<Lhs,((Rhs::Flags&RowMajorBit)==0) ? Dynamic : 1>::type LhsNested;
+    typedef typename nested_eval<Rhs,((Lhs::Flags&RowMajorBit)==RowMajorBit) ? 1 : Lhs::RowsAtCompileTime>::type RhsNested;
+    LhsNested lhsNested(lhs);
+    RhsNested rhsNested(rhs);
+    
+    // transpose everything
+    Transpose<Dst> dstT(dst);
+    internal::sparse_time_dense_product(rhsNested.transpose(), lhsNested.transpose(), dstT, alpha);
+  }
+};
+
+template<typename Lhs, typename Rhs, int ProductType>
+struct generic_product_impl<Lhs, Rhs, DenseShape, SparseTriangularShape, ProductType>
+  : generic_product_impl<Lhs, Rhs, DenseShape, SparseShape, ProductType>
+{};
+
+template<typename LhsT, typename RhsT, bool NeedToTranspose>
+struct sparse_dense_outer_product_evaluator
+{
+protected:
+  typedef typename conditional<NeedToTranspose,RhsT,LhsT>::type Lhs1;
+  typedef typename conditional<NeedToTranspose,LhsT,RhsT>::type ActualRhs;
+  typedef Product<LhsT,RhsT,DefaultProduct> ProdXprType;
+  
+  // if the actual left-hand side is a dense vector,
+  // then build a sparse-view so that we can seamlessly iterate over it.
+  typedef typename conditional<is_same<typename internal::traits<Lhs1>::StorageKind,Sparse>::value,
+            Lhs1, SparseView<Lhs1> >::type ActualLhs;
+  typedef typename conditional<is_same<typename internal::traits<Lhs1>::StorageKind,Sparse>::value,
+            Lhs1 const&, SparseView<Lhs1> >::type LhsArg;
+            
+  typedef evaluator<ActualLhs> LhsEval;
+  typedef evaluator<ActualRhs> RhsEval;
+  typedef typename evaluator<ActualLhs>::InnerIterator LhsIterator;
+  typedef typename ProdXprType::Scalar Scalar;
+  
+public:
+  enum {
+    Flags = NeedToTranspose ? RowMajorBit : 0,
+    CoeffReadCost = HugeCost
+  };
+  
+  class InnerIterator : public LhsIterator
+  {
+  public:
+    InnerIterator(const sparse_dense_outer_product_evaluator &xprEval, Index outer)
+      : LhsIterator(xprEval.m_lhsXprImpl, 0),
+        m_outer(outer),
+        m_empty(false),
+        m_factor(get(xprEval.m_rhsXprImpl, outer, typename internal::traits<ActualRhs>::StorageKind() ))
+    {}
+    
+    EIGEN_STRONG_INLINE Index outer() const { return m_outer; }
+    EIGEN_STRONG_INLINE Index row()   const { return NeedToTranspose ? m_outer : LhsIterator::index(); }
+    EIGEN_STRONG_INLINE Index col()   const { return NeedToTranspose ? LhsIterator::index() : m_outer; }
+
+    EIGEN_STRONG_INLINE Scalar value() const { return LhsIterator::value() * m_factor; }
+    EIGEN_STRONG_INLINE operator bool() const { return LhsIterator::operator bool() && (!m_empty); }
+    
+  protected:
+    Scalar get(const RhsEval &rhs, Index outer, Dense = Dense()) const
+    {
+      return rhs.coeff(outer);
+    }
+    
+    Scalar get(const RhsEval &rhs, Index outer, Sparse = Sparse())
+    {
+      typename RhsEval::InnerIterator it(rhs, outer);
+      if (it && it.index()==0 && it.value()!=Scalar(0))
+        return it.value();
+      m_empty = true;
+      return Scalar(0);
+    }
+    
+    Index m_outer;
+    bool m_empty;
+    Scalar m_factor;
+  };
+  
+  sparse_dense_outer_product_evaluator(const Lhs1 &lhs, const ActualRhs &rhs)
+     : m_lhs(lhs), m_lhsXprImpl(m_lhs), m_rhsXprImpl(rhs)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+  
+  // transpose case
+  sparse_dense_outer_product_evaluator(const ActualRhs &rhs, const Lhs1 &lhs)
+     : m_lhs(lhs), m_lhsXprImpl(m_lhs), m_rhsXprImpl(rhs)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+    
+protected:
+  const LhsArg m_lhs;
+  evaluator<ActualLhs> m_lhsXprImpl;
+  evaluator<ActualRhs> m_rhsXprImpl;
+};
+
+// sparse * dense outer product
+template<typename Lhs, typename Rhs>
+struct product_evaluator<Product<Lhs, Rhs, DefaultProduct>, OuterProduct, SparseShape, DenseShape>
+  : sparse_dense_outer_product_evaluator<Lhs,Rhs, Lhs::IsRowMajor>
+{
+  typedef sparse_dense_outer_product_evaluator<Lhs,Rhs, Lhs::IsRowMajor> Base;
+  
+  typedef Product<Lhs, Rhs> XprType;
+  typedef typename XprType::PlainObject PlainObject;
+
+  explicit product_evaluator(const XprType& xpr)
+    : Base(xpr.lhs(), xpr.rhs())
+  {}
+  
+};
+
+template<typename Lhs, typename Rhs>
+struct product_evaluator<Product<Lhs, Rhs, DefaultProduct>, OuterProduct, DenseShape, SparseShape>
+  : sparse_dense_outer_product_evaluator<Lhs,Rhs, Rhs::IsRowMajor>
+{
+  typedef sparse_dense_outer_product_evaluator<Lhs,Rhs, Rhs::IsRowMajor> Base;
+  
+  typedef Product<Lhs, Rhs> XprType;
+  typedef typename XprType::PlainObject PlainObject;
+
+  explicit product_evaluator(const XprType& xpr)
+    : Base(xpr.lhs(), xpr.rhs())
+  {}
+  
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSEDENSEPRODUCT_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseDiagonalProduct.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseDiagonalProduct.h
new file mode 100644
index 00000000..941c03be
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseDiagonalProduct.h
@@ -0,0 +1,138 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_DIAGONAL_PRODUCT_H
+#define EIGEN_SPARSE_DIAGONAL_PRODUCT_H
+
+namespace Eigen { 
+
+// The product of a diagonal matrix with a sparse matrix can be easily
+// implemented using expression template.
+// We have two consider very different cases:
+// 1 - diag * row-major sparse
+//     => each inner vector <=> scalar * sparse vector product
+//     => so we can reuse CwiseUnaryOp::InnerIterator
+// 2 - diag * col-major sparse
+//     => each inner vector <=> densevector * sparse vector cwise product
+//     => again, we can reuse specialization of CwiseBinaryOp::InnerIterator
+//        for that particular case
+// The two other cases are symmetric.
+
+namespace internal {
+
+enum {
+  SDP_AsScalarProduct,
+  SDP_AsCwiseProduct
+};
+  
+template<typename SparseXprType, typename DiagonalCoeffType, int SDP_Tag>
+struct sparse_diagonal_product_evaluator;
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, DefaultProduct>, ProductTag, DiagonalShape, SparseShape>
+  : public sparse_diagonal_product_evaluator<Rhs, typename Lhs::DiagonalVectorType, Rhs::Flags&RowMajorBit?SDP_AsScalarProduct:SDP_AsCwiseProduct>
+{
+  typedef Product<Lhs, Rhs, DefaultProduct> XprType;
+  enum { CoeffReadCost = HugeCost, Flags = Rhs::Flags&RowMajorBit, Alignment = 0 }; // FIXME CoeffReadCost & Flags
+  
+  typedef sparse_diagonal_product_evaluator<Rhs, typename Lhs::DiagonalVectorType, Rhs::Flags&RowMajorBit?SDP_AsScalarProduct:SDP_AsCwiseProduct> Base;
+  explicit product_evaluator(const XprType& xpr) : Base(xpr.rhs(), xpr.lhs().diagonal()) {}
+};
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, DefaultProduct>, ProductTag, SparseShape, DiagonalShape>
+  : public sparse_diagonal_product_evaluator<Lhs, Transpose<const typename Rhs::DiagonalVectorType>, Lhs::Flags&RowMajorBit?SDP_AsCwiseProduct:SDP_AsScalarProduct>
+{
+  typedef Product<Lhs, Rhs, DefaultProduct> XprType;
+  enum { CoeffReadCost = HugeCost, Flags = Lhs::Flags&RowMajorBit, Alignment = 0 }; // FIXME CoeffReadCost & Flags
+  
+  typedef sparse_diagonal_product_evaluator<Lhs, Transpose<const typename Rhs::DiagonalVectorType>, Lhs::Flags&RowMajorBit?SDP_AsCwiseProduct:SDP_AsScalarProduct> Base;
+  explicit product_evaluator(const XprType& xpr) : Base(xpr.lhs(), xpr.rhs().diagonal().transpose()) {}
+};
+
+template<typename SparseXprType, typename DiagonalCoeffType>
+struct sparse_diagonal_product_evaluator<SparseXprType, DiagonalCoeffType, SDP_AsScalarProduct>
+{
+protected:
+  typedef typename evaluator<SparseXprType>::InnerIterator SparseXprInnerIterator;
+  typedef typename SparseXprType::Scalar Scalar;
+  
+public:
+  class InnerIterator : public SparseXprInnerIterator
+  {
+  public:
+    InnerIterator(const sparse_diagonal_product_evaluator &xprEval, Index outer)
+      : SparseXprInnerIterator(xprEval.m_sparseXprImpl, outer),
+        m_coeff(xprEval.m_diagCoeffImpl.coeff(outer))
+    {}
+    
+    EIGEN_STRONG_INLINE Scalar value() const { return m_coeff * SparseXprInnerIterator::value(); }
+  protected:
+    typename DiagonalCoeffType::Scalar m_coeff;
+  };
+  
+  sparse_diagonal_product_evaluator(const SparseXprType &sparseXpr, const DiagonalCoeffType &diagCoeff)
+    : m_sparseXprImpl(sparseXpr), m_diagCoeffImpl(diagCoeff)
+  {}
+
+  Index nonZerosEstimate() const { return m_sparseXprImpl.nonZerosEstimate(); }
+    
+protected:
+  evaluator<SparseXprType> m_sparseXprImpl;
+  evaluator<DiagonalCoeffType> m_diagCoeffImpl;
+};
+
+
+template<typename SparseXprType, typename DiagCoeffType>
+struct sparse_diagonal_product_evaluator<SparseXprType, DiagCoeffType, SDP_AsCwiseProduct>
+{
+  typedef typename SparseXprType::Scalar Scalar;
+  typedef typename SparseXprType::StorageIndex StorageIndex;
+  
+  typedef typename nested_eval<DiagCoeffType,SparseXprType::IsRowMajor ? SparseXprType::RowsAtCompileTime
+                                                                       : SparseXprType::ColsAtCompileTime>::type DiagCoeffNested;
+  
+  class InnerIterator
+  {
+    typedef typename evaluator<SparseXprType>::InnerIterator SparseXprIter;
+  public:
+    InnerIterator(const sparse_diagonal_product_evaluator &xprEval, Index outer)
+      : m_sparseIter(xprEval.m_sparseXprEval, outer), m_diagCoeffNested(xprEval.m_diagCoeffNested)
+    {}
+    
+    inline Scalar value() const { return m_sparseIter.value() * m_diagCoeffNested.coeff(index()); }
+    inline StorageIndex index() const  { return m_sparseIter.index(); }
+    inline Index outer() const  { return m_sparseIter.outer(); }
+    inline Index col() const    { return SparseXprType::IsRowMajor ? m_sparseIter.index() : m_sparseIter.outer(); }
+    inline Index row() const    { return SparseXprType::IsRowMajor ? m_sparseIter.outer() : m_sparseIter.index(); }
+    
+    EIGEN_STRONG_INLINE InnerIterator& operator++() { ++m_sparseIter; return *this; }
+    inline operator bool() const  { return m_sparseIter; }
+    
+  protected:
+    SparseXprIter m_sparseIter;
+    DiagCoeffNested m_diagCoeffNested;
+  };
+  
+  sparse_diagonal_product_evaluator(const SparseXprType &sparseXpr, const DiagCoeffType &diagCoeff)
+    : m_sparseXprEval(sparseXpr), m_diagCoeffNested(diagCoeff)
+  {}
+
+  Index nonZerosEstimate() const { return m_sparseXprEval.nonZerosEstimate(); }
+    
+protected:
+  evaluator<SparseXprType> m_sparseXprEval;
+  DiagCoeffNested m_diagCoeffNested;
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_DIAGONAL_PRODUCT_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseDot.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseDot.h
new file mode 100644
index 00000000..38bc4aa9
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseDot.h
@@ -0,0 +1,98 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_DOT_H
+#define EIGEN_SPARSE_DOT_H
+
+namespace Eigen { 
+
+template<typename Derived>
+template<typename OtherDerived>
+typename internal::traits<Derived>::Scalar
+SparseMatrixBase<Derived>::dot(const MatrixBase<OtherDerived>& other) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+  EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived,OtherDerived)
+  EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename OtherDerived::Scalar>::value),
+    YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+
+  eigen_assert(size() == other.size());
+  eigen_assert(other.size()>0 && "you are using a non initialized vector");
+
+  internal::evaluator<Derived> thisEval(derived());
+  typename internal::evaluator<Derived>::InnerIterator i(thisEval, 0);
+  Scalar res(0);
+  while (i)
+  {
+    res += numext::conj(i.value()) * other.coeff(i.index());
+    ++i;
+  }
+  return res;
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+typename internal::traits<Derived>::Scalar
+SparseMatrixBase<Derived>::dot(const SparseMatrixBase<OtherDerived>& other) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+  EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived,OtherDerived)
+  EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename OtherDerived::Scalar>::value),
+    YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+
+  eigen_assert(size() == other.size());
+
+  internal::evaluator<Derived> thisEval(derived());
+  typename internal::evaluator<Derived>::InnerIterator i(thisEval, 0);
+  
+  internal::evaluator<OtherDerived>  otherEval(other.derived());
+  typename internal::evaluator<OtherDerived>::InnerIterator j(otherEval, 0);
+
+  Scalar res(0);
+  while (i && j)
+  {
+    if (i.index()==j.index())
+    {
+      res += numext::conj(i.value()) * j.value();
+      ++i; ++j;
+    }
+    else if (i.index()<j.index())
+      ++i;
+    else
+      ++j;
+  }
+  return res;
+}
+
+template<typename Derived>
+inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
+SparseMatrixBase<Derived>::squaredNorm() const
+{
+  return numext::real((*this).cwiseAbs2().sum());
+}
+
+template<typename Derived>
+inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
+SparseMatrixBase<Derived>::norm() const
+{
+  using std::sqrt;
+  return sqrt(squaredNorm());
+}
+
+template<typename Derived>
+inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
+SparseMatrixBase<Derived>::blueNorm() const
+{
+  return internal::blueNorm_impl(*this);
+}
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_DOT_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseFuzzy.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseFuzzy.h
new file mode 100644
index 00000000..7d47eb94
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseFuzzy.h
@@ -0,0 +1,29 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_FUZZY_H
+#define EIGEN_SPARSE_FUZZY_H
+
+namespace Eigen {
+  
+template<typename Derived>
+template<typename OtherDerived>
+bool SparseMatrixBase<Derived>::isApprox(const SparseMatrixBase<OtherDerived>& other, const RealScalar &prec) const
+{
+  const typename internal::nested_eval<Derived,2,PlainObject>::type actualA(derived());
+  typename internal::conditional<bool(IsRowMajor)==bool(OtherDerived::IsRowMajor),
+    const typename internal::nested_eval<OtherDerived,2,PlainObject>::type,
+    const PlainObject>::type actualB(other.derived());
+
+  return (actualA - actualB).squaredNorm() <= prec * prec * numext::mini(actualA.squaredNorm(), actualB.squaredNorm());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_FUZZY_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseMap.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseMap.h
new file mode 100644
index 00000000..f99be337
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseMap.h
@@ -0,0 +1,305 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_MAP_H
+#define EIGEN_SPARSE_MAP_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+struct traits<Map<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+  : public traits<SparseMatrix<MatScalar,MatOptions,MatIndex> >
+{
+  typedef SparseMatrix<MatScalar,MatOptions,MatIndex> PlainObjectType;
+  typedef traits<PlainObjectType> TraitsBase;
+  enum {
+    Flags = TraitsBase::Flags & (~NestByRefBit)
+  };
+};
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+struct traits<Map<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+  : public traits<SparseMatrix<MatScalar,MatOptions,MatIndex> >
+{
+  typedef SparseMatrix<MatScalar,MatOptions,MatIndex> PlainObjectType;
+  typedef traits<PlainObjectType> TraitsBase;
+  enum {
+    Flags = TraitsBase::Flags & (~ (NestByRefBit | LvalueBit))
+  };
+};
+
+} // end namespace internal
+
+template<typename Derived,
+         int Level = internal::accessors_level<Derived>::has_write_access ? WriteAccessors : ReadOnlyAccessors
+> class SparseMapBase;
+
+/** \ingroup SparseCore_Module
+  * class SparseMapBase
+  * \brief Common base class for Map and Ref instance of sparse matrix and vector.
+  */
+template<typename Derived>
+class SparseMapBase<Derived,ReadOnlyAccessors>
+  : public SparseCompressedBase<Derived>
+{
+  public:
+    typedef SparseCompressedBase<Derived> Base;
+    typedef typename Base::Scalar Scalar;
+    typedef typename Base::StorageIndex StorageIndex;
+    enum { IsRowMajor = Base::IsRowMajor };
+    using Base::operator=;
+  protected:
+    
+    typedef typename internal::conditional<
+                         bool(internal::is_lvalue<Derived>::value),
+                         Scalar *, const Scalar *>::type ScalarPointer;
+    typedef typename internal::conditional<
+                         bool(internal::is_lvalue<Derived>::value),
+                         StorageIndex *, const StorageIndex *>::type IndexPointer;
+
+    Index   m_outerSize;
+    Index   m_innerSize;
+    Array<StorageIndex,2,1>  m_zero_nnz;
+    IndexPointer  m_outerIndex;
+    IndexPointer  m_innerIndices;
+    ScalarPointer m_values;
+    IndexPointer  m_innerNonZeros;
+
+  public:
+
+    /** \copydoc SparseMatrixBase::rows() */
+    inline Index rows() const { return IsRowMajor ? m_outerSize : m_innerSize; }
+    /** \copydoc SparseMatrixBase::cols() */
+    inline Index cols() const { return IsRowMajor ? m_innerSize : m_outerSize; }
+    /** \copydoc SparseMatrixBase::innerSize() */
+    inline Index innerSize() const { return m_innerSize; }
+    /** \copydoc SparseMatrixBase::outerSize() */
+    inline Index outerSize() const { return m_outerSize; }
+    /** \copydoc SparseCompressedBase::nonZeros */
+    inline Index nonZeros() const { return m_zero_nnz[1]; }
+    
+    /** \copydoc SparseCompressedBase::isCompressed */
+    bool isCompressed() const { return m_innerNonZeros==0; }
+
+    //----------------------------------------
+    // direct access interface
+    /** \copydoc SparseMatrix::valuePtr */
+    inline const Scalar* valuePtr() const { return m_values; }
+    /** \copydoc SparseMatrix::innerIndexPtr */
+    inline const StorageIndex* innerIndexPtr() const { return m_innerIndices; }
+    /** \copydoc SparseMatrix::outerIndexPtr */
+    inline const StorageIndex* outerIndexPtr() const { return m_outerIndex; }
+    /** \copydoc SparseMatrix::innerNonZeroPtr */
+    inline const StorageIndex* innerNonZeroPtr() const { return m_innerNonZeros; }
+    //----------------------------------------
+
+    /** \copydoc SparseMatrix::coeff */
+    inline Scalar coeff(Index row, Index col) const
+    {
+      const Index outer = IsRowMajor ? row : col;
+      const Index inner = IsRowMajor ? col : row;
+
+      Index start = m_outerIndex[outer];
+      Index end = isCompressed() ? m_outerIndex[outer+1] : start + m_innerNonZeros[outer];
+      if (start==end)
+        return Scalar(0);
+      else if (end>0 && inner==m_innerIndices[end-1])
+        return m_values[end-1];
+      // ^^  optimization: let's first check if it is the last coefficient
+      // (very common in high level algorithms)
+
+      const StorageIndex* r = std::lower_bound(&m_innerIndices[start],&m_innerIndices[end-1],inner);
+      const Index id = r-&m_innerIndices[0];
+      return ((*r==inner) && (id<end)) ? m_values[id] : Scalar(0);
+    }
+
+    inline SparseMapBase(Index rows, Index cols, Index nnz, IndexPointer outerIndexPtr, IndexPointer innerIndexPtr,
+                              ScalarPointer valuePtr, IndexPointer innerNonZerosPtr = 0)
+      : m_outerSize(IsRowMajor?rows:cols), m_innerSize(IsRowMajor?cols:rows), m_zero_nnz(0,internal::convert_index<StorageIndex>(nnz)), m_outerIndex(outerIndexPtr),
+        m_innerIndices(innerIndexPtr), m_values(valuePtr), m_innerNonZeros(innerNonZerosPtr)
+    {}
+
+    // for vectors
+    inline SparseMapBase(Index size, Index nnz, IndexPointer innerIndexPtr, ScalarPointer valuePtr)
+      : m_outerSize(1), m_innerSize(size), m_zero_nnz(0,internal::convert_index<StorageIndex>(nnz)), m_outerIndex(m_zero_nnz.data()),
+        m_innerIndices(innerIndexPtr), m_values(valuePtr), m_innerNonZeros(0)
+    {}
+
+    /** Empty destructor */
+    inline ~SparseMapBase() {}
+
+  protected:
+    inline SparseMapBase() {}
+};
+
+/** \ingroup SparseCore_Module
+  * class SparseMapBase
+  * \brief Common base class for writable Map and Ref instance of sparse matrix and vector.
+  */
+template<typename Derived>
+class SparseMapBase<Derived,WriteAccessors>
+  : public SparseMapBase<Derived,ReadOnlyAccessors>
+{
+    typedef MapBase<Derived, ReadOnlyAccessors> ReadOnlyMapBase;
+    
+  public:
+    typedef SparseMapBase<Derived, ReadOnlyAccessors> Base;
+    typedef typename Base::Scalar Scalar;
+    typedef typename Base::StorageIndex StorageIndex;
+    enum { IsRowMajor = Base::IsRowMajor };
+    
+    using Base::operator=;
+
+  public:
+    
+    //----------------------------------------
+    // direct access interface
+    using Base::valuePtr;
+    using Base::innerIndexPtr;
+    using Base::outerIndexPtr;
+    using Base::innerNonZeroPtr;
+    /** \copydoc SparseMatrix::valuePtr */
+    inline Scalar* valuePtr()              { return Base::m_values; }
+    /** \copydoc SparseMatrix::innerIndexPtr */
+    inline StorageIndex* innerIndexPtr()   { return Base::m_innerIndices; }
+    /** \copydoc SparseMatrix::outerIndexPtr */
+    inline StorageIndex* outerIndexPtr()   { return Base::m_outerIndex; }
+    /** \copydoc SparseMatrix::innerNonZeroPtr */
+    inline StorageIndex* innerNonZeroPtr() { return Base::m_innerNonZeros; }
+    //----------------------------------------
+
+    /** \copydoc SparseMatrix::coeffRef */
+    inline Scalar& coeffRef(Index row, Index col)
+    {
+      const Index outer = IsRowMajor ? row : col;
+      const Index inner = IsRowMajor ? col : row;
+
+      Index start = Base::m_outerIndex[outer];
+      Index end = Base::isCompressed() ? Base::m_outerIndex[outer+1] : start + Base::m_innerNonZeros[outer];
+      eigen_assert(end>=start && "you probably called coeffRef on a non finalized matrix");
+      eigen_assert(end>start && "coeffRef cannot be called on a zero coefficient");
+      StorageIndex* r = std::lower_bound(&Base::m_innerIndices[start],&Base::m_innerIndices[end],inner);
+      const Index id = r - &Base::m_innerIndices[0];
+      eigen_assert((*r==inner) && (id<end) && "coeffRef cannot be called on a zero coefficient");
+      return const_cast<Scalar*>(Base::m_values)[id];
+    }
+    
+    inline SparseMapBase(Index rows, Index cols, Index nnz, StorageIndex* outerIndexPtr, StorageIndex* innerIndexPtr,
+                         Scalar* valuePtr, StorageIndex* innerNonZerosPtr = 0)
+      : Base(rows, cols, nnz, outerIndexPtr, innerIndexPtr, valuePtr, innerNonZerosPtr)
+    {}
+
+    // for vectors
+    inline SparseMapBase(Index size, Index nnz, StorageIndex* innerIndexPtr, Scalar* valuePtr)
+      : Base(size, nnz, innerIndexPtr, valuePtr)
+    {}
+
+    /** Empty destructor */
+    inline ~SparseMapBase() {}
+
+  protected:
+    inline SparseMapBase() {}
+};
+
+/** \ingroup SparseCore_Module
+  *
+  * \brief Specialization of class Map for SparseMatrix-like storage.
+  *
+  * \tparam SparseMatrixType the equivalent sparse matrix type of the referenced data, it must be a template instance of class SparseMatrix.
+  *
+  * \sa class Map, class SparseMatrix, class Ref<SparseMatrixType,Options>
+  */
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+class Map<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType>
+  : public SparseMapBase<Map<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+#else
+template<typename SparseMatrixType>
+class Map<SparseMatrixType>
+  : public SparseMapBase<Derived,WriteAccessors>
+#endif
+{
+  public:
+    typedef SparseMapBase<Map> Base;
+    EIGEN_SPARSE_PUBLIC_INTERFACE(Map)
+    enum { IsRowMajor = Base::IsRowMajor };
+
+  public:
+
+    /** Constructs a read-write Map to a sparse matrix of size \a rows x \a cols, containing \a nnz non-zero coefficients,
+      * stored as a sparse format as defined by the pointers \a outerIndexPtr, \a innerIndexPtr, and \a valuePtr.
+      * If the optional parameter \a innerNonZerosPtr is the null pointer, then a standard compressed format is assumed.
+      *
+      * This constructor is available only if \c SparseMatrixType is non-const.
+      *
+      * More details on the expected storage schemes are given in the \ref TutorialSparse "manual pages".
+      */
+    inline Map(Index rows, Index cols, Index nnz, StorageIndex* outerIndexPtr,
+               StorageIndex* innerIndexPtr, Scalar* valuePtr, StorageIndex* innerNonZerosPtr = 0)
+      : Base(rows, cols, nnz, outerIndexPtr, innerIndexPtr, valuePtr, innerNonZerosPtr)
+    {}
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** Empty destructor */
+    inline ~Map() {}
+};
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+class Map<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType>
+  : public SparseMapBase<Map<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+{
+  public:
+    typedef SparseMapBase<Map> Base;
+    EIGEN_SPARSE_PUBLIC_INTERFACE(Map)
+    enum { IsRowMajor = Base::IsRowMajor };
+
+  public:
+#endif
+    /** This is the const version of the above constructor.
+      *
+      * This constructor is available only if \c SparseMatrixType is const, e.g.:
+      * \code Map<const SparseMatrix<double> >  \endcode
+      */
+    inline Map(Index rows, Index cols, Index nnz, const StorageIndex* outerIndexPtr,
+               const StorageIndex* innerIndexPtr, const Scalar* valuePtr, const StorageIndex* innerNonZerosPtr = 0)
+      : Base(rows, cols, nnz, outerIndexPtr, innerIndexPtr, valuePtr, innerNonZerosPtr)
+    {}
+
+    /** Empty destructor */
+    inline ~Map() {}
+};
+
+namespace internal {
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+struct evaluator<Map<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+  : evaluator<SparseCompressedBase<Map<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > >
+{
+  typedef evaluator<SparseCompressedBase<Map<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > > Base;
+  typedef Map<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> XprType;  
+  evaluator() : Base() {}
+  explicit evaluator(const XprType &mat) : Base(mat) {}
+};
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+struct evaluator<Map<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+  : evaluator<SparseCompressedBase<Map<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > >
+{
+  typedef evaluator<SparseCompressedBase<Map<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > > Base;
+  typedef Map<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> XprType;  
+  evaluator() : Base() {}
+  explicit evaluator(const XprType &mat) : Base(mat) {}
+};
+
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_MAP_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseMatrix.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseMatrix.h
new file mode 100644
index 00000000..323c2323
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseMatrix.h
@@ -0,0 +1,1403 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSEMATRIX_H
+#define EIGEN_SPARSEMATRIX_H
+
+namespace Eigen { 
+
+/** \ingroup SparseCore_Module
+  *
+  * \class SparseMatrix
+  *
+  * \brief A versatible sparse matrix representation
+  *
+  * This class implements a more versatile variants of the common \em compressed row/column storage format.
+  * Each colmun's (resp. row) non zeros are stored as a pair of value with associated row (resp. colmiun) index.
+  * All the non zeros are stored in a single large buffer. Unlike the \em compressed format, there might be extra
+  * space inbetween the nonzeros of two successive colmuns (resp. rows) such that insertion of new non-zero
+  * can be done with limited memory reallocation and copies.
+  *
+  * A call to the function makeCompressed() turns the matrix into the standard \em compressed format
+  * compatible with many library.
+  *
+  * More details on this storage sceheme are given in the \ref TutorialSparse "manual pages".
+  *
+  * \tparam _Scalar the scalar type, i.e. the type of the coefficients
+  * \tparam _Options Union of bit flags controlling the storage scheme. Currently the only possibility
+  *                 is ColMajor or RowMajor. The default is 0 which means column-major.
+  * \tparam _StorageIndex the type of the indices. It has to be a \b signed type (e.g., short, int, std::ptrdiff_t). Default is \c int.
+  *
+  * \warning In %Eigen 3.2, the undocumented type \c SparseMatrix::Index was improperly defined as the storage index type (e.g., int),
+  *          whereas it is now (starting from %Eigen 3.3) deprecated and always defined as Eigen::Index.
+  *          Codes making use of \c SparseMatrix::Index, might thus likely have to be changed to use \c SparseMatrix::StorageIndex instead.
+  *
+  * This class can be extended with the help of the plugin mechanism described on the page
+  * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_SPARSEMATRIX_PLUGIN.
+  */
+
+namespace internal {
+template<typename _Scalar, int _Options, typename _StorageIndex>
+struct traits<SparseMatrix<_Scalar, _Options, _StorageIndex> >
+{
+  typedef _Scalar Scalar;
+  typedef _StorageIndex StorageIndex;
+  typedef Sparse StorageKind;
+  typedef MatrixXpr XprKind;
+  enum {
+    RowsAtCompileTime = Dynamic,
+    ColsAtCompileTime = Dynamic,
+    MaxRowsAtCompileTime = Dynamic,
+    MaxColsAtCompileTime = Dynamic,
+    Flags = _Options | NestByRefBit | LvalueBit | CompressedAccessBit,
+    SupportedAccessPatterns = InnerRandomAccessPattern
+  };
+};
+
+template<typename _Scalar, int _Options, typename _StorageIndex, int DiagIndex>
+struct traits<Diagonal<SparseMatrix<_Scalar, _Options, _StorageIndex>, DiagIndex> >
+{
+  typedef SparseMatrix<_Scalar, _Options, _StorageIndex> MatrixType;
+  typedef typename ref_selector<MatrixType>::type MatrixTypeNested;
+  typedef typename remove_reference<MatrixTypeNested>::type _MatrixTypeNested;
+
+  typedef _Scalar Scalar;
+  typedef Dense StorageKind;
+  typedef _StorageIndex StorageIndex;
+  typedef MatrixXpr XprKind;
+
+  enum {
+    RowsAtCompileTime = Dynamic,
+    ColsAtCompileTime = 1,
+    MaxRowsAtCompileTime = Dynamic,
+    MaxColsAtCompileTime = 1,
+    Flags = LvalueBit
+  };
+};
+
+template<typename _Scalar, int _Options, typename _StorageIndex, int DiagIndex>
+struct traits<Diagonal<const SparseMatrix<_Scalar, _Options, _StorageIndex>, DiagIndex> >
+ : public traits<Diagonal<SparseMatrix<_Scalar, _Options, _StorageIndex>, DiagIndex> >
+{
+  enum {
+    Flags = 0
+  };
+};
+
+} // end namespace internal
+
+template<typename _Scalar, int _Options, typename _StorageIndex>
+class SparseMatrix
+  : public SparseCompressedBase<SparseMatrix<_Scalar, _Options, _StorageIndex> >
+{
+    typedef SparseCompressedBase<SparseMatrix> Base;
+    using Base::convert_index;
+    friend class SparseVector<_Scalar,0,_StorageIndex>;
+  public:
+    using Base::isCompressed;
+    using Base::nonZeros;
+    EIGEN_SPARSE_PUBLIC_INTERFACE(SparseMatrix)
+    using Base::operator+=;
+    using Base::operator-=;
+
+    typedef MappedSparseMatrix<Scalar,Flags> Map;
+    typedef Diagonal<SparseMatrix> DiagonalReturnType;
+    typedef Diagonal<const SparseMatrix> ConstDiagonalReturnType;
+    typedef typename Base::InnerIterator InnerIterator;
+    typedef typename Base::ReverseInnerIterator ReverseInnerIterator;
+    
+
+    using Base::IsRowMajor;
+    typedef internal::CompressedStorage<Scalar,StorageIndex> Storage;
+    enum {
+      Options = _Options
+    };
+
+    typedef typename Base::IndexVector IndexVector;
+    typedef typename Base::ScalarVector ScalarVector;
+  protected:
+    typedef SparseMatrix<Scalar,(Flags&~RowMajorBit)|(IsRowMajor?RowMajorBit:0)> TransposedSparseMatrix;
+
+    Index m_outerSize;
+    Index m_innerSize;
+    StorageIndex* m_outerIndex;
+    StorageIndex* m_innerNonZeros;     // optional, if null then the data is compressed
+    Storage m_data;
+
+  public:
+    
+    /** \returns the number of rows of the matrix */
+    inline Index rows() const { return IsRowMajor ? m_outerSize : m_innerSize; }
+    /** \returns the number of columns of the matrix */
+    inline Index cols() const { return IsRowMajor ? m_innerSize : m_outerSize; }
+
+    /** \returns the number of rows (resp. columns) of the matrix if the storage order column major (resp. row major) */
+    inline Index innerSize() const { return m_innerSize; }
+    /** \returns the number of columns (resp. rows) of the matrix if the storage order column major (resp. row major) */
+    inline Index outerSize() const { return m_outerSize; }
+    
+    /** \returns a const pointer to the array of values.
+      * This function is aimed at interoperability with other libraries.
+      * \sa innerIndexPtr(), outerIndexPtr() */
+    inline const Scalar* valuePtr() const { return m_data.valuePtr(); }
+    /** \returns a non-const pointer to the array of values.
+      * This function is aimed at interoperability with other libraries.
+      * \sa innerIndexPtr(), outerIndexPtr() */
+    inline Scalar* valuePtr() { return m_data.valuePtr(); }
+
+    /** \returns a const pointer to the array of inner indices.
+      * This function is aimed at interoperability with other libraries.
+      * \sa valuePtr(), outerIndexPtr() */
+    inline const StorageIndex* innerIndexPtr() const { return m_data.indexPtr(); }
+    /** \returns a non-const pointer to the array of inner indices.
+      * This function is aimed at interoperability with other libraries.
+      * \sa valuePtr(), outerIndexPtr() */
+    inline StorageIndex* innerIndexPtr() { return m_data.indexPtr(); }
+
+    /** \returns a const pointer to the array of the starting positions of the inner vectors.
+      * This function is aimed at interoperability with other libraries.
+      * \sa valuePtr(), innerIndexPtr() */
+    inline const StorageIndex* outerIndexPtr() const { return m_outerIndex; }
+    /** \returns a non-const pointer to the array of the starting positions of the inner vectors.
+      * This function is aimed at interoperability with other libraries.
+      * \sa valuePtr(), innerIndexPtr() */
+    inline StorageIndex* outerIndexPtr() { return m_outerIndex; }
+
+    /** \returns a const pointer to the array of the number of non zeros of the inner vectors.
+      * This function is aimed at interoperability with other libraries.
+      * \warning it returns the null pointer 0 in compressed mode */
+    inline const StorageIndex* innerNonZeroPtr() const { return m_innerNonZeros; }
+    /** \returns a non-const pointer to the array of the number of non zeros of the inner vectors.
+      * This function is aimed at interoperability with other libraries.
+      * \warning it returns the null pointer 0 in compressed mode */
+    inline StorageIndex* innerNonZeroPtr() { return m_innerNonZeros; }
+
+    /** \internal */
+    inline Storage& data() { return m_data; }
+    /** \internal */
+    inline const Storage& data() const { return m_data; }
+
+    /** \returns the value of the matrix at position \a i, \a j
+      * This function returns Scalar(0) if the element is an explicit \em zero */
+    inline Scalar coeff(Index row, Index col) const
+    {
+      eigen_assert(row>=0 && row<rows() && col>=0 && col<cols());
+      
+      const Index outer = IsRowMajor ? row : col;
+      const Index inner = IsRowMajor ? col : row;
+      Index end = m_innerNonZeros ? m_outerIndex[outer] + m_innerNonZeros[outer] : m_outerIndex[outer+1];
+      return m_data.atInRange(m_outerIndex[outer], end, StorageIndex(inner));
+    }
+
+    /** \returns a non-const reference to the value of the matrix at position \a i, \a j
+      *
+      * If the element does not exist then it is inserted via the insert(Index,Index) function
+      * which itself turns the matrix into a non compressed form if that was not the case.
+      *
+      * This is a O(log(nnz_j)) operation (binary search) plus the cost of insert(Index,Index)
+      * function if the element does not already exist.
+      */
+    inline Scalar& coeffRef(Index row, Index col)
+    {
+      eigen_assert(row>=0 && row<rows() && col>=0 && col<cols());
+      
+      const Index outer = IsRowMajor ? row : col;
+      const Index inner = IsRowMajor ? col : row;
+
+      Index start = m_outerIndex[outer];
+      Index end = m_innerNonZeros ? m_outerIndex[outer] + m_innerNonZeros[outer] : m_outerIndex[outer+1];
+      eigen_assert(end>=start && "you probably called coeffRef on a non finalized matrix");
+      if(end<=start)
+        return insert(row,col);
+      const Index p = m_data.searchLowerIndex(start,end-1,StorageIndex(inner));
+      if((p<end) && (m_data.index(p)==inner))
+        return m_data.value(p);
+      else
+        return insert(row,col);
+    }
+
+    /** \returns a reference to a novel non zero coefficient with coordinates \a row x \a col.
+      * The non zero coefficient must \b not already exist.
+      *
+      * If the matrix \c *this is in compressed mode, then \c *this is turned into uncompressed
+      * mode while reserving room for 2 x this->innerSize() non zeros if reserve(Index) has not been called earlier.
+      * In this case, the insertion procedure is optimized for a \e sequential insertion mode where elements are assumed to be
+      * inserted by increasing outer-indices.
+      * 
+      * If that's not the case, then it is strongly recommended to either use a triplet-list to assemble the matrix, or to first
+      * call reserve(const SizesType &) to reserve the appropriate number of non-zero elements per inner vector.
+      *
+      * Assuming memory has been appropriately reserved, this function performs a sorted insertion in O(1)
+      * if the elements of each inner vector are inserted in increasing inner index order, and in O(nnz_j) for a random insertion.
+      *
+      */
+    Scalar& insert(Index row, Index col);
+
+  public:
+
+    /** Removes all non zeros but keep allocated memory
+      *
+      * This function does not free the currently allocated memory. To release as much as memory as possible,
+      * call \code mat.data().squeeze(); \endcode after resizing it.
+      * 
+      * \sa resize(Index,Index), data()
+      */
+    inline void setZero()
+    {
+      m_data.clear();
+      memset(m_outerIndex, 0, (m_outerSize+1)*sizeof(StorageIndex));
+      if(m_innerNonZeros)
+        memset(m_innerNonZeros, 0, (m_outerSize)*sizeof(StorageIndex));
+    }
+
+    /** Preallocates \a reserveSize non zeros.
+      *
+      * Precondition: the matrix must be in compressed mode. */
+    inline void reserve(Index reserveSize)
+    {
+      eigen_assert(isCompressed() && "This function does not make sense in non compressed mode.");
+      m_data.reserve(reserveSize);
+    }
+    
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    /** Preallocates \a reserveSize[\c j] non zeros for each column (resp. row) \c j.
+      *
+      * This function turns the matrix in non-compressed mode.
+      * 
+      * The type \c SizesType must expose the following interface:
+        \code
+        typedef value_type;
+        const value_type& operator[](i) const;
+        \endcode
+      * for \c i in the [0,this->outerSize()[ range.
+      * Typical choices include std::vector<int>, Eigen::VectorXi, Eigen::VectorXi::Constant, etc.
+      */
+    template<class SizesType>
+    inline void reserve(const SizesType& reserveSizes);
+    #else
+    template<class SizesType>
+    inline void reserve(const SizesType& reserveSizes, const typename SizesType::value_type& enableif =
+    #if (!EIGEN_COMP_MSVC) || (EIGEN_COMP_MSVC>=1500) // MSVC 2005 fails to compile with this typename
+        typename
+    #endif
+        SizesType::value_type())
+    {
+      EIGEN_UNUSED_VARIABLE(enableif);
+      reserveInnerVectors(reserveSizes);
+    }
+    #endif // EIGEN_PARSED_BY_DOXYGEN
+  protected:
+    template<class SizesType>
+    inline void reserveInnerVectors(const SizesType& reserveSizes)
+    {
+      if(isCompressed())
+      {
+        Index totalReserveSize = 0;
+        // turn the matrix into non-compressed mode
+        m_innerNonZeros = static_cast<StorageIndex*>(std::malloc(m_outerSize * sizeof(StorageIndex)));
+        if (!m_innerNonZeros) internal::throw_std_bad_alloc();
+        
+        // temporarily use m_innerSizes to hold the new starting points.
+        StorageIndex* newOuterIndex = m_innerNonZeros;
+        
+        StorageIndex count = 0;
+        for(Index j=0; j<m_outerSize; ++j)
+        {
+          newOuterIndex[j] = count;
+          count += reserveSizes[j] + (m_outerIndex[j+1]-m_outerIndex[j]);
+          totalReserveSize += reserveSizes[j];
+        }
+        m_data.reserve(totalReserveSize);
+        StorageIndex previousOuterIndex = m_outerIndex[m_outerSize];
+        for(Index j=m_outerSize-1; j>=0; --j)
+        {
+          StorageIndex innerNNZ = previousOuterIndex - m_outerIndex[j];
+          for(Index i=innerNNZ-1; i>=0; --i)
+          {
+            m_data.index(newOuterIndex[j]+i) = m_data.index(m_outerIndex[j]+i);
+            m_data.value(newOuterIndex[j]+i) = m_data.value(m_outerIndex[j]+i);
+          }
+          previousOuterIndex = m_outerIndex[j];
+          m_outerIndex[j] = newOuterIndex[j];
+          m_innerNonZeros[j] = innerNNZ;
+        }
+        m_outerIndex[m_outerSize] = m_outerIndex[m_outerSize-1] + m_innerNonZeros[m_outerSize-1] + reserveSizes[m_outerSize-1];
+        
+        m_data.resize(m_outerIndex[m_outerSize]);
+      }
+      else
+      {
+        StorageIndex* newOuterIndex = static_cast<StorageIndex*>(std::malloc((m_outerSize+1)*sizeof(StorageIndex)));
+        if (!newOuterIndex) internal::throw_std_bad_alloc();
+        
+        StorageIndex count = 0;
+        for(Index j=0; j<m_outerSize; ++j)
+        {
+          newOuterIndex[j] = count;
+          StorageIndex alreadyReserved = (m_outerIndex[j+1]-m_outerIndex[j]) - m_innerNonZeros[j];
+          StorageIndex toReserve = std::max<StorageIndex>(reserveSizes[j], alreadyReserved);
+          count += toReserve + m_innerNonZeros[j];
+        }
+        newOuterIndex[m_outerSize] = count;
+        
+        m_data.resize(count);
+        for(Index j=m_outerSize-1; j>=0; --j)
+        {
+          Index offset = newOuterIndex[j] - m_outerIndex[j];
+          if(offset>0)
+          {
+            StorageIndex innerNNZ = m_innerNonZeros[j];
+            for(Index i=innerNNZ-1; i>=0; --i)
+            {
+              m_data.index(newOuterIndex[j]+i) = m_data.index(m_outerIndex[j]+i);
+              m_data.value(newOuterIndex[j]+i) = m_data.value(m_outerIndex[j]+i);
+            }
+          }
+        }
+        
+        std::swap(m_outerIndex, newOuterIndex);
+        std::free(newOuterIndex);
+      }
+      
+    }
+  public:
+
+    //--- low level purely coherent filling ---
+
+    /** \internal
+      * \returns a reference to the non zero coefficient at position \a row, \a col assuming that:
+      * - the nonzero does not already exist
+      * - the new coefficient is the last one according to the storage order
+      *
+      * Before filling a given inner vector you must call the statVec(Index) function.
+      *
+      * After an insertion session, you should call the finalize() function.
+      *
+      * \sa insert, insertBackByOuterInner, startVec */
+    inline Scalar& insertBack(Index row, Index col)
+    {
+      return insertBackByOuterInner(IsRowMajor?row:col, IsRowMajor?col:row);
+    }
+
+    /** \internal
+      * \sa insertBack, startVec */
+    inline Scalar& insertBackByOuterInner(Index outer, Index inner)
+    {
+      eigen_assert(Index(m_outerIndex[outer+1]) == m_data.size() && "Invalid ordered insertion (invalid outer index)");
+      eigen_assert( (m_outerIndex[outer+1]-m_outerIndex[outer]==0 || m_data.index(m_data.size()-1)<inner) && "Invalid ordered insertion (invalid inner index)");
+      Index p = m_outerIndex[outer+1];
+      ++m_outerIndex[outer+1];
+      m_data.append(Scalar(0), inner);
+      return m_data.value(p);
+    }
+
+    /** \internal
+      * \warning use it only if you know what you are doing */
+    inline Scalar& insertBackByOuterInnerUnordered(Index outer, Index inner)
+    {
+      Index p = m_outerIndex[outer+1];
+      ++m_outerIndex[outer+1];
+      m_data.append(Scalar(0), inner);
+      return m_data.value(p);
+    }
+
+    /** \internal
+      * \sa insertBack, insertBackByOuterInner */
+    inline void startVec(Index outer)
+    {
+      eigen_assert(m_outerIndex[outer]==Index(m_data.size()) && "You must call startVec for each inner vector sequentially");
+      eigen_assert(m_outerIndex[outer+1]==0 && "You must call startVec for each inner vector sequentially");
+      m_outerIndex[outer+1] = m_outerIndex[outer];
+    }
+
+    /** \internal
+      * Must be called after inserting a set of non zero entries using the low level compressed API.
+      */
+    inline void finalize()
+    {
+      if(isCompressed())
+      {
+        StorageIndex size = internal::convert_index<StorageIndex>(m_data.size());
+        Index i = m_outerSize;
+        // find the last filled column
+        while (i>=0 && m_outerIndex[i]==0)
+          --i;
+        ++i;
+        while (i<=m_outerSize)
+        {
+          m_outerIndex[i] = size;
+          ++i;
+        }
+      }
+    }
+
+    //---
+
+    template<typename InputIterators>
+    void setFromTriplets(const InputIterators& begin, const InputIterators& end);
+
+    template<typename InputIterators,typename DupFunctor>
+    void setFromTriplets(const InputIterators& begin, const InputIterators& end, DupFunctor dup_func);
+
+    void sumupDuplicates() { collapseDuplicates(internal::scalar_sum_op<Scalar,Scalar>()); }
+
+    template<typename DupFunctor>
+    void collapseDuplicates(DupFunctor dup_func = DupFunctor());
+
+    //---
+    
+    /** \internal
+      * same as insert(Index,Index) except that the indices are given relative to the storage order */
+    Scalar& insertByOuterInner(Index j, Index i)
+    {
+      return insert(IsRowMajor ? j : i, IsRowMajor ? i : j);
+    }
+
+    /** Turns the matrix into the \em compressed format.
+      */
+    void makeCompressed()
+    {
+      if(isCompressed())
+        return;
+      
+      eigen_internal_assert(m_outerIndex!=0 && m_outerSize>0);
+      
+      Index oldStart = m_outerIndex[1];
+      m_outerIndex[1] = m_innerNonZeros[0];
+      for(Index j=1; j<m_outerSize; ++j)
+      {
+        Index nextOldStart = m_outerIndex[j+1];
+        Index offset = oldStart - m_outerIndex[j];
+        if(offset>0)
+        {
+          for(Index k=0; k<m_innerNonZeros[j]; ++k)
+          {
+            m_data.index(m_outerIndex[j]+k) = m_data.index(oldStart+k);
+            m_data.value(m_outerIndex[j]+k) = m_data.value(oldStart+k);
+          }
+        }
+        m_outerIndex[j+1] = m_outerIndex[j] + m_innerNonZeros[j];
+        oldStart = nextOldStart;
+      }
+      std::free(m_innerNonZeros);
+      m_innerNonZeros = 0;
+      m_data.resize(m_outerIndex[m_outerSize]);
+      m_data.squeeze();
+    }
+
+    /** Turns the matrix into the uncompressed mode */
+    void uncompress()
+    {
+      if(m_innerNonZeros != 0)
+        return; 
+      m_innerNonZeros = static_cast<StorageIndex*>(std::malloc(m_outerSize * sizeof(StorageIndex)));
+      for (Index i = 0; i < m_outerSize; i++)
+      {
+        m_innerNonZeros[i] = m_outerIndex[i+1] - m_outerIndex[i]; 
+      }
+    }
+    
+    /** Suppresses all nonzeros which are \b much \b smaller \b than \a reference under the tolerence \a epsilon */
+    void prune(const Scalar& reference, const RealScalar& epsilon = NumTraits<RealScalar>::dummy_precision())
+    {
+      prune(default_prunning_func(reference,epsilon));
+    }
+    
+    /** Turns the matrix into compressed format, and suppresses all nonzeros which do not satisfy the predicate \a keep.
+      * The functor type \a KeepFunc must implement the following function:
+      * \code
+      * bool operator() (const Index& row, const Index& col, const Scalar& value) const;
+      * \endcode
+      * \sa prune(Scalar,RealScalar)
+      */
+    template<typename KeepFunc>
+    void prune(const KeepFunc& keep = KeepFunc())
+    {
+      // TODO optimize the uncompressed mode to avoid moving and allocating the data twice
+      makeCompressed();
+
+      StorageIndex k = 0;
+      for(Index j=0; j<m_outerSize; ++j)
+      {
+        Index previousStart = m_outerIndex[j];
+        m_outerIndex[j] = k;
+        Index end = m_outerIndex[j+1];
+        for(Index i=previousStart; i<end; ++i)
+        {
+          if(keep(IsRowMajor?j:m_data.index(i), IsRowMajor?m_data.index(i):j, m_data.value(i)))
+          {
+            m_data.value(k) = m_data.value(i);
+            m_data.index(k) = m_data.index(i);
+            ++k;
+          }
+        }
+      }
+      m_outerIndex[m_outerSize] = k;
+      m_data.resize(k,0);
+    }
+
+    /** Resizes the matrix to a \a rows x \a cols matrix leaving old values untouched.
+      *
+      * If the sizes of the matrix are decreased, then the matrix is turned to \b uncompressed-mode
+      * and the storage of the out of bounds coefficients is kept and reserved.
+      * Call makeCompressed() to pack the entries and squeeze extra memory.
+      *
+      * \sa reserve(), setZero(), makeCompressed()
+      */
+    void conservativeResize(Index rows, Index cols) 
+    {
+      // No change
+      if (this->rows() == rows && this->cols() == cols) return;
+      
+      // If one dimension is null, then there is nothing to be preserved
+      if(rows==0 || cols==0) return resize(rows,cols);
+
+      Index innerChange = IsRowMajor ? cols - this->cols() : rows - this->rows();
+      Index outerChange = IsRowMajor ? rows - this->rows() : cols - this->cols();
+      StorageIndex newInnerSize = convert_index(IsRowMajor ? cols : rows);
+
+      // Deals with inner non zeros
+      if (m_innerNonZeros)
+      {
+        // Resize m_innerNonZeros
+        StorageIndex *newInnerNonZeros = static_cast<StorageIndex*>(std::realloc(m_innerNonZeros, (m_outerSize + outerChange) * sizeof(StorageIndex)));
+        if (!newInnerNonZeros) internal::throw_std_bad_alloc();
+        m_innerNonZeros = newInnerNonZeros;
+        
+        for(Index i=m_outerSize; i<m_outerSize+outerChange; i++)          
+          m_innerNonZeros[i] = 0;
+      } 
+      else if (innerChange < 0) 
+      {
+        // Inner size decreased: allocate a new m_innerNonZeros
+        m_innerNonZeros = static_cast<StorageIndex*>(std::malloc((m_outerSize+outerChange+1) * sizeof(StorageIndex)));
+        if (!m_innerNonZeros) internal::throw_std_bad_alloc();
+        for(Index i = 0; i < m_outerSize; i++)
+          m_innerNonZeros[i] = m_outerIndex[i+1] - m_outerIndex[i];
+      }
+      
+      // Change the m_innerNonZeros in case of a decrease of inner size
+      if (m_innerNonZeros && innerChange < 0)
+      {
+        for(Index i = 0; i < m_outerSize + (std::min)(outerChange, Index(0)); i++)
+        {
+          StorageIndex &n = m_innerNonZeros[i];
+          StorageIndex start = m_outerIndex[i];
+          while (n > 0 && m_data.index(start+n-1) >= newInnerSize) --n; 
+        }
+      }
+      
+      m_innerSize = newInnerSize;
+
+      // Re-allocate outer index structure if necessary
+      if (outerChange == 0)
+        return;
+          
+      StorageIndex *newOuterIndex = static_cast<StorageIndex*>(std::realloc(m_outerIndex, (m_outerSize + outerChange + 1) * sizeof(StorageIndex)));
+      if (!newOuterIndex) internal::throw_std_bad_alloc();
+      m_outerIndex = newOuterIndex;
+      if (outerChange > 0)
+      {
+        StorageIndex last = m_outerSize == 0 ? 0 : m_outerIndex[m_outerSize];
+        for(Index i=m_outerSize; i<m_outerSize+outerChange+1; i++)          
+          m_outerIndex[i] = last; 
+      }
+      m_outerSize += outerChange;
+    }
+    
+    /** Resizes the matrix to a \a rows x \a cols matrix and initializes it to zero.
+      * 
+      * This function does not free the currently allocated memory. To release as much as memory as possible,
+      * call \code mat.data().squeeze(); \endcode after resizing it.
+      * 
+      * \sa reserve(), setZero()
+      */
+    void resize(Index rows, Index cols)
+    {
+      const Index outerSize = IsRowMajor ? rows : cols;
+      m_innerSize = IsRowMajor ? cols : rows;
+      m_data.clear();
+      if (m_outerSize != outerSize || m_outerSize==0)
+      {
+        std::free(m_outerIndex);
+        m_outerIndex = static_cast<StorageIndex*>(std::malloc((outerSize + 1) * sizeof(StorageIndex)));
+        if (!m_outerIndex) internal::throw_std_bad_alloc();
+        
+        m_outerSize = outerSize;
+      }
+      if(m_innerNonZeros)
+      {
+        std::free(m_innerNonZeros);
+        m_innerNonZeros = 0;
+      }
+      memset(m_outerIndex, 0, (m_outerSize+1)*sizeof(StorageIndex));
+    }
+
+    /** \internal
+      * Resize the nonzero vector to \a size */
+    void resizeNonZeros(Index size)
+    {
+      m_data.resize(size);
+    }
+
+    /** \returns a const expression of the diagonal coefficients. */
+    const ConstDiagonalReturnType diagonal() const { return ConstDiagonalReturnType(*this); }
+    
+    /** \returns a read-write expression of the diagonal coefficients.
+      * \warning If the diagonal entries are written, then all diagonal
+      * entries \b must already exist, otherwise an assertion will be raised.
+      */
+    DiagonalReturnType diagonal() { return DiagonalReturnType(*this); }
+
+    /** Default constructor yielding an empty \c 0 \c x \c 0 matrix */
+    inline SparseMatrix()
+      : m_outerSize(-1), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
+    {
+      check_template_parameters();
+      resize(0, 0);
+    }
+
+    /** Constructs a \a rows \c x \a cols empty matrix */
+    inline SparseMatrix(Index rows, Index cols)
+      : m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
+    {
+      check_template_parameters();
+      resize(rows, cols);
+    }
+
+    /** Constructs a sparse matrix from the sparse expression \a other */
+    template<typename OtherDerived>
+    inline SparseMatrix(const SparseMatrixBase<OtherDerived>& other)
+      : m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
+    {
+      EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename OtherDerived::Scalar>::value),
+        YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+      check_template_parameters();
+      const bool needToTranspose = (Flags & RowMajorBit) != (internal::evaluator<OtherDerived>::Flags & RowMajorBit);
+      if (needToTranspose)
+        *this = other.derived();
+      else
+      {
+        #ifdef EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
+          EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
+        #endif
+        internal::call_assignment_no_alias(*this, other.derived());
+      }
+    }
+    
+    /** Constructs a sparse matrix from the sparse selfadjoint view \a other */
+    template<typename OtherDerived, unsigned int UpLo>
+    inline SparseMatrix(const SparseSelfAdjointView<OtherDerived, UpLo>& other)
+      : m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
+    {
+      check_template_parameters();
+      Base::operator=(other);
+    }
+
+    /** Copy constructor (it performs a deep copy) */
+    inline SparseMatrix(const SparseMatrix& other)
+      : Base(), m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
+    {
+      check_template_parameters();
+      *this = other.derived();
+    }
+
+    /** \brief Copy constructor with in-place evaluation */
+    template<typename OtherDerived>
+    SparseMatrix(const ReturnByValue<OtherDerived>& other)
+      : Base(), m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
+    {
+      check_template_parameters();
+      initAssignment(other);
+      other.evalTo(*this);
+    }
+    
+    /** \brief Copy constructor with in-place evaluation */
+    template<typename OtherDerived>
+    explicit SparseMatrix(const DiagonalBase<OtherDerived>& other)
+      : Base(), m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
+    {
+      check_template_parameters();
+      *this = other.derived();
+    }
+
+    /** Swaps the content of two sparse matrices of the same type.
+      * This is a fast operation that simply swaps the underlying pointers and parameters. */
+    inline void swap(SparseMatrix& other)
+    {
+      //EIGEN_DBG_SPARSE(std::cout << "SparseMatrix:: swap\n");
+      std::swap(m_outerIndex, other.m_outerIndex);
+      std::swap(m_innerSize, other.m_innerSize);
+      std::swap(m_outerSize, other.m_outerSize);
+      std::swap(m_innerNonZeros, other.m_innerNonZeros);
+      m_data.swap(other.m_data);
+    }
+
+    /** Sets *this to the identity matrix.
+      * This function also turns the matrix into compressed mode, and drop any reserved memory. */
+    inline void setIdentity()
+    {
+      eigen_assert(rows() == cols() && "ONLY FOR SQUARED MATRICES");
+      this->m_data.resize(rows());
+      Eigen::Map<IndexVector>(this->m_data.indexPtr(), rows()).setLinSpaced(0, StorageIndex(rows()-1));
+      Eigen::Map<ScalarVector>(this->m_data.valuePtr(), rows()).setOnes();
+      Eigen::Map<IndexVector>(this->m_outerIndex, rows()+1).setLinSpaced(0, StorageIndex(rows()));
+      std::free(m_innerNonZeros);
+      m_innerNonZeros = 0;
+    }
+    inline SparseMatrix& operator=(const SparseMatrix& other)
+    {
+      if (other.isRValue())
+      {
+        swap(other.const_cast_derived());
+      }
+      else if(this!=&other)
+      {
+        #ifdef EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
+          EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
+        #endif
+        initAssignment(other);
+        if(other.isCompressed())
+        {
+          internal::smart_copy(other.m_outerIndex, other.m_outerIndex + m_outerSize + 1, m_outerIndex);
+          m_data = other.m_data;
+        }
+        else
+        {
+          Base::operator=(other);
+        }
+      }
+      return *this;
+    }
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename OtherDerived>
+    inline SparseMatrix& operator=(const EigenBase<OtherDerived>& other)
+    { return Base::operator=(other.derived()); }
+#endif // EIGEN_PARSED_BY_DOXYGEN
+
+    template<typename OtherDerived>
+    EIGEN_DONT_INLINE SparseMatrix& operator=(const SparseMatrixBase<OtherDerived>& other);
+
+    friend std::ostream & operator << (std::ostream & s, const SparseMatrix& m)
+    {
+      EIGEN_DBG_SPARSE(
+        s << "Nonzero entries:\n";
+        if(m.isCompressed())
+        {
+          for (Index i=0; i<m.nonZeros(); ++i)
+            s << "(" << m.m_data.value(i) << "," << m.m_data.index(i) << ") ";
+        }
+        else
+        {
+          for (Index i=0; i<m.outerSize(); ++i)
+          {
+            Index p = m.m_outerIndex[i];
+            Index pe = m.m_outerIndex[i]+m.m_innerNonZeros[i];
+            Index k=p;
+            for (; k<pe; ++k) {
+              s << "(" << m.m_data.value(k) << "," << m.m_data.index(k) << ") ";
+            }
+            for (; k<m.m_outerIndex[i+1]; ++k) {
+              s << "(_,_) ";
+            }
+          }
+        }
+        s << std::endl;
+        s << std::endl;
+        s << "Outer pointers:\n";
+        for (Index i=0; i<m.outerSize(); ++i) {
+          s << m.m_outerIndex[i] << " ";
+        }
+        s << " $" << std::endl;
+        if(!m.isCompressed())
+        {
+          s << "Inner non zeros:\n";
+          for (Index i=0; i<m.outerSize(); ++i) {
+            s << m.m_innerNonZeros[i] << " ";
+          }
+          s << " $" << std::endl;
+        }
+        s << std::endl;
+      );
+      s << static_cast<const SparseMatrixBase<SparseMatrix>&>(m);
+      return s;
+    }
+
+    /** Destructor */
+    inline ~SparseMatrix()
+    {
+      std::free(m_outerIndex);
+      std::free(m_innerNonZeros);
+    }
+
+    /** Overloaded for performance */
+    Scalar sum() const;
+    
+#   ifdef EIGEN_SPARSEMATRIX_PLUGIN
+#     include EIGEN_SPARSEMATRIX_PLUGIN
+#   endif
+
+protected:
+
+    template<typename Other>
+    void initAssignment(const Other& other)
+    {
+      resize(other.rows(), other.cols());
+      if(m_innerNonZeros)
+      {
+        std::free(m_innerNonZeros);
+        m_innerNonZeros = 0;
+      }
+    }
+
+    /** \internal
+      * \sa insert(Index,Index) */
+    EIGEN_DONT_INLINE Scalar& insertCompressed(Index row, Index col);
+
+    /** \internal
+      * A vector object that is equal to 0 everywhere but v at the position i */
+    class SingletonVector
+    {
+        StorageIndex m_index;
+        StorageIndex m_value;
+      public:
+        typedef StorageIndex value_type;
+        SingletonVector(Index i, Index v)
+          : m_index(convert_index(i)), m_value(convert_index(v))
+        {}
+
+        StorageIndex operator[](Index i) const { return i==m_index ? m_value : 0; }
+    };
+
+    /** \internal
+      * \sa insert(Index,Index) */
+    EIGEN_DONT_INLINE Scalar& insertUncompressed(Index row, Index col);
+
+public:
+    /** \internal
+      * \sa insert(Index,Index) */
+    EIGEN_STRONG_INLINE Scalar& insertBackUncompressed(Index row, Index col)
+    {
+      const Index outer = IsRowMajor ? row : col;
+      const Index inner = IsRowMajor ? col : row;
+
+      eigen_assert(!isCompressed());
+      eigen_assert(m_innerNonZeros[outer]<=(m_outerIndex[outer+1] - m_outerIndex[outer]));
+
+      Index p = m_outerIndex[outer] + m_innerNonZeros[outer]++;
+      m_data.index(p) = convert_index(inner);
+      return (m_data.value(p) = 0);
+    }
+
+private:
+  static void check_template_parameters()
+  {
+    EIGEN_STATIC_ASSERT(NumTraits<StorageIndex>::IsSigned,THE_INDEX_TYPE_MUST_BE_A_SIGNED_TYPE);
+    EIGEN_STATIC_ASSERT((Options&(ColMajor|RowMajor))==Options,INVALID_MATRIX_TEMPLATE_PARAMETERS);
+  }
+
+  struct default_prunning_func {
+    default_prunning_func(const Scalar& ref, const RealScalar& eps) : reference(ref), epsilon(eps) {}
+    inline bool operator() (const Index&, const Index&, const Scalar& value) const
+    {
+      return !internal::isMuchSmallerThan(value, reference, epsilon);
+    }
+    Scalar reference;
+    RealScalar epsilon;
+  };
+};
+
+namespace internal {
+
+template<typename InputIterator, typename SparseMatrixType, typename DupFunctor>
+void set_from_triplets(const InputIterator& begin, const InputIterator& end, SparseMatrixType& mat, DupFunctor dup_func)
+{
+  enum { IsRowMajor = SparseMatrixType::IsRowMajor };
+  typedef typename SparseMatrixType::Scalar Scalar;
+  typedef typename SparseMatrixType::StorageIndex StorageIndex;
+  SparseMatrix<Scalar,IsRowMajor?ColMajor:RowMajor,StorageIndex> trMat(mat.rows(),mat.cols());
+
+  if(begin!=end)
+  {
+    // pass 1: count the nnz per inner-vector
+    typename SparseMatrixType::IndexVector wi(trMat.outerSize());
+    wi.setZero();
+    for(InputIterator it(begin); it!=end; ++it)
+    {
+      eigen_assert(it->row()>=0 && it->row()<mat.rows() && it->col()>=0 && it->col()<mat.cols());
+      wi(IsRowMajor ? it->col() : it->row())++;
+    }
+
+    // pass 2: insert all the elements into trMat
+    trMat.reserve(wi);
+    for(InputIterator it(begin); it!=end; ++it)
+      trMat.insertBackUncompressed(it->row(),it->col()) = it->value();
+
+    // pass 3:
+    trMat.collapseDuplicates(dup_func);
+  }
+
+  // pass 4: transposed copy -> implicit sorting
+  mat = trMat;
+}
+
+}
+
+
+/** Fill the matrix \c *this with the list of \em triplets defined by the iterator range \a begin - \a end.
+  *
+  * A \em triplet is a tuple (i,j,value) defining a non-zero element.
+  * The input list of triplets does not have to be sorted, and can contains duplicated elements.
+  * In any case, the result is a \b sorted and \b compressed sparse matrix where the duplicates have been summed up.
+  * This is a \em O(n) operation, with \em n the number of triplet elements.
+  * The initial contents of \c *this is destroyed.
+  * The matrix \c *this must be properly resized beforehand using the SparseMatrix(Index,Index) constructor,
+  * or the resize(Index,Index) method. The sizes are not extracted from the triplet list.
+  *
+  * The \a InputIterators value_type must provide the following interface:
+  * \code
+  * Scalar value() const; // the value
+  * Scalar row() const;   // the row index i
+  * Scalar col() const;   // the column index j
+  * \endcode
+  * See for instance the Eigen::Triplet template class.
+  *
+  * Here is a typical usage example:
+  * \code
+    typedef Triplet<double> T;
+    std::vector<T> tripletList;
+    triplets.reserve(estimation_of_entries);
+    for(...)
+    {
+      // ...
+      tripletList.push_back(T(i,j,v_ij));
+    }
+    SparseMatrixType m(rows,cols);
+    m.setFromTriplets(tripletList.begin(), tripletList.end());
+    // m is ready to go!
+  * \endcode
+  *
+  * \warning The list of triplets is read multiple times (at least twice). Therefore, it is not recommended to define
+  * an abstract iterator over a complex data-structure that would be expensive to evaluate. The triplets should rather
+  * be explicitely stored into a std::vector for instance.
+  */
+template<typename Scalar, int _Options, typename _StorageIndex>
+template<typename InputIterators>
+void SparseMatrix<Scalar,_Options,_StorageIndex>::setFromTriplets(const InputIterators& begin, const InputIterators& end)
+{
+  internal::set_from_triplets<InputIterators, SparseMatrix<Scalar,_Options,_StorageIndex> >(begin, end, *this, internal::scalar_sum_op<Scalar,Scalar>());
+}
+
+/** The same as setFromTriplets but when duplicates are met the functor \a dup_func is applied:
+  * \code
+  * value = dup_func(OldValue, NewValue)
+  * \endcode 
+  * Here is a C++11 example keeping the latest entry only:
+  * \code
+  * mat.setFromTriplets(triplets.begin(), triplets.end(), [] (const Scalar&,const Scalar &b) { return b; });
+  * \endcode
+  */
+template<typename Scalar, int _Options, typename _StorageIndex>
+template<typename InputIterators,typename DupFunctor>
+void SparseMatrix<Scalar,_Options,_StorageIndex>::setFromTriplets(const InputIterators& begin, const InputIterators& end, DupFunctor dup_func)
+{
+  internal::set_from_triplets<InputIterators, SparseMatrix<Scalar,_Options,_StorageIndex>, DupFunctor>(begin, end, *this, dup_func);
+}
+
+/** \internal */
+template<typename Scalar, int _Options, typename _StorageIndex>
+template<typename DupFunctor>
+void SparseMatrix<Scalar,_Options,_StorageIndex>::collapseDuplicates(DupFunctor dup_func)
+{
+  eigen_assert(!isCompressed());
+  // TODO, in practice we should be able to use m_innerNonZeros for that task
+  IndexVector wi(innerSize());
+  wi.fill(-1);
+  StorageIndex count = 0;
+  // for each inner-vector, wi[inner_index] will hold the position of first element into the index/value buffers
+  for(Index j=0; j<outerSize(); ++j)
+  {
+    StorageIndex start   = count;
+    Index oldEnd  = m_outerIndex[j]+m_innerNonZeros[j];
+    for(Index k=m_outerIndex[j]; k<oldEnd; ++k)
+    {
+      Index i = m_data.index(k);
+      if(wi(i)>=start)
+      {
+        // we already meet this entry => accumulate it
+        m_data.value(wi(i)) = dup_func(m_data.value(wi(i)), m_data.value(k));
+      }
+      else
+      {
+        m_data.value(count) = m_data.value(k);
+        m_data.index(count) = m_data.index(k);
+        wi(i) = count;
+        ++count;
+      }
+    }
+    m_outerIndex[j] = start;
+  }
+  m_outerIndex[m_outerSize] = count;
+
+  // turn the matrix into compressed form
+  std::free(m_innerNonZeros);
+  m_innerNonZeros = 0;
+  m_data.resize(m_outerIndex[m_outerSize]);
+}
+
+template<typename Scalar, int _Options, typename _StorageIndex>
+template<typename OtherDerived>
+EIGEN_DONT_INLINE SparseMatrix<Scalar,_Options,_StorageIndex>& SparseMatrix<Scalar,_Options,_StorageIndex>::operator=(const SparseMatrixBase<OtherDerived>& other)
+{
+  EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename OtherDerived::Scalar>::value),
+        YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+
+  #ifdef EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
+    EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
+  #endif
+      
+  const bool needToTranspose = (Flags & RowMajorBit) != (internal::evaluator<OtherDerived>::Flags & RowMajorBit);
+  if (needToTranspose)
+  {
+    #ifdef EIGEN_SPARSE_TRANSPOSED_COPY_PLUGIN
+      EIGEN_SPARSE_TRANSPOSED_COPY_PLUGIN
+    #endif
+    // two passes algorithm:
+    //  1 - compute the number of coeffs per dest inner vector
+    //  2 - do the actual copy/eval
+    // Since each coeff of the rhs has to be evaluated twice, let's evaluate it if needed
+    typedef typename internal::nested_eval<OtherDerived,2,typename internal::plain_matrix_type<OtherDerived>::type >::type OtherCopy;
+    typedef typename internal::remove_all<OtherCopy>::type _OtherCopy;
+    typedef internal::evaluator<_OtherCopy> OtherCopyEval;
+    OtherCopy otherCopy(other.derived());
+    OtherCopyEval otherCopyEval(otherCopy);
+
+    SparseMatrix dest(other.rows(),other.cols());
+    Eigen::Map<IndexVector> (dest.m_outerIndex,dest.outerSize()).setZero();
+
+    // pass 1
+    // FIXME the above copy could be merged with that pass
+    for (Index j=0; j<otherCopy.outerSize(); ++j)
+      for (typename OtherCopyEval::InnerIterator it(otherCopyEval, j); it; ++it)
+        ++dest.m_outerIndex[it.index()];
+
+    // prefix sum
+    StorageIndex count = 0;
+    IndexVector positions(dest.outerSize());
+    for (Index j=0; j<dest.outerSize(); ++j)
+    {
+      StorageIndex tmp = dest.m_outerIndex[j];
+      dest.m_outerIndex[j] = count;
+      positions[j] = count;
+      count += tmp;
+    }
+    dest.m_outerIndex[dest.outerSize()] = count;
+    // alloc
+    dest.m_data.resize(count);
+    // pass 2
+    for (StorageIndex j=0; j<otherCopy.outerSize(); ++j)
+    {
+      for (typename OtherCopyEval::InnerIterator it(otherCopyEval, j); it; ++it)
+      {
+        Index pos = positions[it.index()]++;
+        dest.m_data.index(pos) = j;
+        dest.m_data.value(pos) = it.value();
+      }
+    }
+    this->swap(dest);
+    return *this;
+  }
+  else
+  {
+    if(other.isRValue())
+    {
+      initAssignment(other.derived());
+    }
+    // there is no special optimization
+    return Base::operator=(other.derived());
+  }
+}
+
+template<typename _Scalar, int _Options, typename _StorageIndex>
+typename SparseMatrix<_Scalar,_Options,_StorageIndex>::Scalar& SparseMatrix<_Scalar,_Options,_StorageIndex>::insert(Index row, Index col)
+{
+  eigen_assert(row>=0 && row<rows() && col>=0 && col<cols());
+  
+  const Index outer = IsRowMajor ? row : col;
+  const Index inner = IsRowMajor ? col : row;
+  
+  if(isCompressed())
+  {
+    if(nonZeros()==0)
+    {
+      // reserve space if not already done
+      if(m_data.allocatedSize()==0)
+        m_data.reserve(2*m_innerSize);
+      
+      // turn the matrix into non-compressed mode
+      m_innerNonZeros = static_cast<StorageIndex*>(std::malloc(m_outerSize * sizeof(StorageIndex)));
+      if(!m_innerNonZeros) internal::throw_std_bad_alloc();
+      
+      memset(m_innerNonZeros, 0, (m_outerSize)*sizeof(StorageIndex));
+      
+      // pack all inner-vectors to the end of the pre-allocated space
+      // and allocate the entire free-space to the first inner-vector
+      StorageIndex end = convert_index(m_data.allocatedSize());
+      for(Index j=1; j<=m_outerSize; ++j)
+        m_outerIndex[j] = end;
+    }
+    else
+    {
+      // turn the matrix into non-compressed mode
+      m_innerNonZeros = static_cast<StorageIndex*>(std::malloc(m_outerSize * sizeof(StorageIndex)));
+      if(!m_innerNonZeros) internal::throw_std_bad_alloc();
+      for(Index j=0; j<m_outerSize; ++j)
+        m_innerNonZeros[j] = m_outerIndex[j+1]-m_outerIndex[j];
+    }
+  }
+  
+  // check whether we can do a fast "push back" insertion
+  Index data_end = m_data.allocatedSize();
+  
+  // First case: we are filling a new inner vector which is packed at the end.
+  // We assume that all remaining inner-vectors are also empty and packed to the end.
+  if(m_outerIndex[outer]==data_end)
+  {
+    eigen_internal_assert(m_innerNonZeros[outer]==0);
+    
+    // pack previous empty inner-vectors to end of the used-space
+    // and allocate the entire free-space to the current inner-vector.
+    StorageIndex p = convert_index(m_data.size());
+    Index j = outer;
+    while(j>=0 && m_innerNonZeros[j]==0)
+      m_outerIndex[j--] = p;
+    
+    // push back the new element
+    ++m_innerNonZeros[outer];
+    m_data.append(Scalar(0), inner);
+    
+    // check for reallocation
+    if(data_end != m_data.allocatedSize())
+    {
+      // m_data has been reallocated
+      //  -> move remaining inner-vectors back to the end of the free-space
+      //     so that the entire free-space is allocated to the current inner-vector.
+      eigen_internal_assert(data_end < m_data.allocatedSize());
+      StorageIndex new_end = convert_index(m_data.allocatedSize());
+      for(Index k=outer+1; k<=m_outerSize; ++k)
+        if(m_outerIndex[k]==data_end)
+          m_outerIndex[k] = new_end;
+    }
+    return m_data.value(p);
+  }
+  
+  // Second case: the next inner-vector is packed to the end
+  // and the current inner-vector end match the used-space.
+  if(m_outerIndex[outer+1]==data_end && m_outerIndex[outer]+m_innerNonZeros[outer]==m_data.size())
+  {
+    eigen_internal_assert(outer+1==m_outerSize || m_innerNonZeros[outer+1]==0);
+    
+    // add space for the new element
+    ++m_innerNonZeros[outer];
+    m_data.resize(m_data.size()+1);
+    
+    // check for reallocation
+    if(data_end != m_data.allocatedSize())
+    {
+      // m_data has been reallocated
+      //  -> move remaining inner-vectors back to the end of the free-space
+      //     so that the entire free-space is allocated to the current inner-vector.
+      eigen_internal_assert(data_end < m_data.allocatedSize());
+      StorageIndex new_end = convert_index(m_data.allocatedSize());
+      for(Index k=outer+1; k<=m_outerSize; ++k)
+        if(m_outerIndex[k]==data_end)
+          m_outerIndex[k] = new_end;
+    }
+    
+    // and insert it at the right position (sorted insertion)
+    Index startId = m_outerIndex[outer];
+    Index p = m_outerIndex[outer]+m_innerNonZeros[outer]-1;
+    while ( (p > startId) && (m_data.index(p-1) > inner) )
+    {
+      m_data.index(p) = m_data.index(p-1);
+      m_data.value(p) = m_data.value(p-1);
+      --p;
+    }
+    
+    m_data.index(p) = convert_index(inner);
+    return (m_data.value(p) = 0);
+  }
+  
+  if(m_data.size() != m_data.allocatedSize())
+  {
+    // make sure the matrix is compatible to random un-compressed insertion:
+    m_data.resize(m_data.allocatedSize());
+    this->reserveInnerVectors(Array<StorageIndex,Dynamic,1>::Constant(m_outerSize, 2));
+  }
+  
+  return insertUncompressed(row,col);
+}
+    
+template<typename _Scalar, int _Options, typename _StorageIndex>
+EIGEN_DONT_INLINE typename SparseMatrix<_Scalar,_Options,_StorageIndex>::Scalar& SparseMatrix<_Scalar,_Options,_StorageIndex>::insertUncompressed(Index row, Index col)
+{
+  eigen_assert(!isCompressed());
+
+  const Index outer = IsRowMajor ? row : col;
+  const StorageIndex inner = convert_index(IsRowMajor ? col : row);
+
+  Index room = m_outerIndex[outer+1] - m_outerIndex[outer];
+  StorageIndex innerNNZ = m_innerNonZeros[outer];
+  if(innerNNZ>=room)
+  {
+    // this inner vector is full, we need to reallocate the whole buffer :(
+    reserve(SingletonVector(outer,std::max<StorageIndex>(2,innerNNZ)));
+  }
+
+  Index startId = m_outerIndex[outer];
+  Index p = startId + m_innerNonZeros[outer];
+  while ( (p > startId) && (m_data.index(p-1) > inner) )
+  {
+    m_data.index(p) = m_data.index(p-1);
+    m_data.value(p) = m_data.value(p-1);
+    --p;
+  }
+  eigen_assert((p<=startId || m_data.index(p-1)!=inner) && "you cannot insert an element that already exists, you must call coeffRef to this end");
+
+  m_innerNonZeros[outer]++;
+
+  m_data.index(p) = inner;
+  return (m_data.value(p) = 0);
+}
+
+template<typename _Scalar, int _Options, typename _StorageIndex>
+EIGEN_DONT_INLINE typename SparseMatrix<_Scalar,_Options,_StorageIndex>::Scalar& SparseMatrix<_Scalar,_Options,_StorageIndex>::insertCompressed(Index row, Index col)
+{
+  eigen_assert(isCompressed());
+
+  const Index outer = IsRowMajor ? row : col;
+  const Index inner = IsRowMajor ? col : row;
+
+  Index previousOuter = outer;
+  if (m_outerIndex[outer+1]==0)
+  {
+    // we start a new inner vector
+    while (previousOuter>=0 && m_outerIndex[previousOuter]==0)
+    {
+      m_outerIndex[previousOuter] = convert_index(m_data.size());
+      --previousOuter;
+    }
+    m_outerIndex[outer+1] = m_outerIndex[outer];
+  }
+
+  // here we have to handle the tricky case where the outerIndex array
+  // starts with: [ 0 0 0 0 0 1 ...] and we are inserted in, e.g.,
+  // the 2nd inner vector...
+  bool isLastVec = (!(previousOuter==-1 && m_data.size()!=0))
+                && (std::size_t(m_outerIndex[outer+1]) == m_data.size());
+
+  std::size_t startId = m_outerIndex[outer];
+  // FIXME let's make sure sizeof(long int) == sizeof(std::size_t)
+  std::size_t p = m_outerIndex[outer+1];
+  ++m_outerIndex[outer+1];
+
+  double reallocRatio = 1;
+  if (m_data.allocatedSize()<=m_data.size())
+  {
+    // if there is no preallocated memory, let's reserve a minimum of 32 elements
+    if (m_data.size()==0)
+    {
+      m_data.reserve(32);
+    }
+    else
+    {
+      // we need to reallocate the data, to reduce multiple reallocations
+      // we use a smart resize algorithm based on the current filling ratio
+      // in addition, we use double to avoid integers overflows
+      double nnzEstimate = double(m_outerIndex[outer])*double(m_outerSize)/double(outer+1);
+      reallocRatio = (nnzEstimate-double(m_data.size()))/double(m_data.size());
+      // furthermore we bound the realloc ratio to:
+      //   1) reduce multiple minor realloc when the matrix is almost filled
+      //   2) avoid to allocate too much memory when the matrix is almost empty
+      reallocRatio = (std::min)((std::max)(reallocRatio,1.5),8.);
+    }
+  }
+  m_data.resize(m_data.size()+1,reallocRatio);
+
+  if (!isLastVec)
+  {
+    if (previousOuter==-1)
+    {
+      // oops wrong guess.
+      // let's correct the outer offsets
+      for (Index k=0; k<=(outer+1); ++k)
+        m_outerIndex[k] = 0;
+      Index k=outer+1;
+      while(m_outerIndex[k]==0)
+        m_outerIndex[k++] = 1;
+      while (k<=m_outerSize && m_outerIndex[k]!=0)
+        m_outerIndex[k++]++;
+      p = 0;
+      --k;
+      k = m_outerIndex[k]-1;
+      while (k>0)
+      {
+        m_data.index(k) = m_data.index(k-1);
+        m_data.value(k) = m_data.value(k-1);
+        k--;
+      }
+    }
+    else
+    {
+      // we are not inserting into the last inner vec
+      // update outer indices:
+      Index j = outer+2;
+      while (j<=m_outerSize && m_outerIndex[j]!=0)
+        m_outerIndex[j++]++;
+      --j;
+      // shift data of last vecs:
+      Index k = m_outerIndex[j]-1;
+      while (k>=Index(p))
+      {
+        m_data.index(k) = m_data.index(k-1);
+        m_data.value(k) = m_data.value(k-1);
+        k--;
+      }
+    }
+  }
+
+  while ( (p > startId) && (m_data.index(p-1) > inner) )
+  {
+    m_data.index(p) = m_data.index(p-1);
+    m_data.value(p) = m_data.value(p-1);
+    --p;
+  }
+
+  m_data.index(p) = inner;
+  return (m_data.value(p) = 0);
+}
+
+namespace internal {
+
+template<typename _Scalar, int _Options, typename _StorageIndex>
+struct evaluator<SparseMatrix<_Scalar,_Options,_StorageIndex> >
+  : evaluator<SparseCompressedBase<SparseMatrix<_Scalar,_Options,_StorageIndex> > >
+{
+  typedef evaluator<SparseCompressedBase<SparseMatrix<_Scalar,_Options,_StorageIndex> > > Base;
+  typedef SparseMatrix<_Scalar,_Options,_StorageIndex> SparseMatrixType;
+  evaluator() : Base() {}
+  explicit evaluator(const SparseMatrixType &mat) : Base(mat) {}
+};
+
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSEMATRIX_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseMatrixBase.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseMatrixBase.h
new file mode 100644
index 00000000..c6b548f1
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseMatrixBase.h
@@ -0,0 +1,405 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSEMATRIXBASE_H
+#define EIGEN_SPARSEMATRIXBASE_H
+
+namespace Eigen { 
+
+/** \ingroup SparseCore_Module
+  *
+  * \class SparseMatrixBase
+  *
+  * \brief Base class of any sparse matrices or sparse expressions
+  *
+  * \tparam Derived is the derived type, e.g. a sparse matrix type, or an expression, etc.
+  *
+  * This class can be extended with the help of the plugin mechanism described on the page
+  * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_SPARSEMATRIXBASE_PLUGIN.
+  */
+template<typename Derived> class SparseMatrixBase
+  : public EigenBase<Derived>
+{
+  public:
+
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    
+    /** The numeric type of the expression' coefficients, e.g. float, double, int or std::complex<float>, etc.
+      *
+      * It is an alias for the Scalar type */
+    typedef Scalar value_type;
+    
+    typedef typename internal::packet_traits<Scalar>::type PacketScalar;
+    typedef typename internal::traits<Derived>::StorageKind StorageKind;
+
+    /** The integer type used to \b store indices within a SparseMatrix.
+      * For a \c SparseMatrix<Scalar,Options,IndexType> it an alias of the third template parameter \c IndexType. */
+    typedef typename internal::traits<Derived>::StorageIndex StorageIndex;
+
+    typedef typename internal::add_const_on_value_type_if_arithmetic<
+                         typename internal::packet_traits<Scalar>::type
+                     >::type PacketReturnType;
+
+    typedef SparseMatrixBase StorageBaseType;
+
+    typedef Matrix<StorageIndex,Dynamic,1> IndexVector;
+    typedef Matrix<Scalar,Dynamic,1> ScalarVector;
+    
+    template<typename OtherDerived>
+    Derived& operator=(const EigenBase<OtherDerived> &other);
+
+    enum {
+
+      RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
+        /**< The number of rows at compile-time. This is just a copy of the value provided
+          * by the \a Derived type. If a value is not known at compile-time,
+          * it is set to the \a Dynamic constant.
+          * \sa MatrixBase::rows(), MatrixBase::cols(), ColsAtCompileTime, SizeAtCompileTime */
+
+      ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
+        /**< The number of columns at compile-time. This is just a copy of the value provided
+          * by the \a Derived type. If a value is not known at compile-time,
+          * it is set to the \a Dynamic constant.
+          * \sa MatrixBase::rows(), MatrixBase::cols(), RowsAtCompileTime, SizeAtCompileTime */
+
+
+      SizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::RowsAtCompileTime,
+                                                   internal::traits<Derived>::ColsAtCompileTime>::ret),
+        /**< This is equal to the number of coefficients, i.e. the number of
+          * rows times the number of columns, or to \a Dynamic if this is not
+          * known at compile-time. \sa RowsAtCompileTime, ColsAtCompileTime */
+
+      MaxRowsAtCompileTime = RowsAtCompileTime,
+      MaxColsAtCompileTime = ColsAtCompileTime,
+
+      MaxSizeAtCompileTime = (internal::size_at_compile_time<MaxRowsAtCompileTime,
+                                                      MaxColsAtCompileTime>::ret),
+
+      IsVectorAtCompileTime = RowsAtCompileTime == 1 || ColsAtCompileTime == 1,
+        /**< This is set to true if either the number of rows or the number of
+          * columns is known at compile-time to be equal to 1. Indeed, in that case,
+          * we are dealing with a column-vector (if there is only one column) or with
+          * a row-vector (if there is only one row). */
+
+      Flags = internal::traits<Derived>::Flags,
+        /**< This stores expression \ref flags flags which may or may not be inherited by new expressions
+          * constructed from this one. See the \ref flags "list of flags".
+          */
+
+      IsRowMajor = Flags&RowMajorBit ? 1 : 0,
+      
+      InnerSizeAtCompileTime = int(IsVectorAtCompileTime) ? int(SizeAtCompileTime)
+                             : int(IsRowMajor) ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
+
+      #ifndef EIGEN_PARSED_BY_DOXYGEN
+      _HasDirectAccess = (int(Flags)&DirectAccessBit) ? 1 : 0 // workaround sunCC
+      #endif
+    };
+
+    /** \internal the return type of MatrixBase::adjoint() */
+    typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
+                        CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, Eigen::Transpose<const Derived> >,
+                        Transpose<const Derived>
+                     >::type AdjointReturnType;
+    typedef Transpose<Derived> TransposeReturnType;
+    typedef typename internal::add_const<Transpose<const Derived> >::type ConstTransposeReturnType;
+
+    // FIXME storage order do not match evaluator storage order
+    typedef SparseMatrix<Scalar, Flags&RowMajorBit ? RowMajor : ColMajor, StorageIndex> PlainObject;
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** This is the "real scalar" type; if the \a Scalar type is already real numbers
+      * (e.g. int, float or double) then \a RealScalar is just the same as \a Scalar. If
+      * \a Scalar is \a std::complex<T> then RealScalar is \a T.
+      *
+      * \sa class NumTraits
+      */
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    /** \internal the return type of coeff()
+      */
+    typedef typename internal::conditional<_HasDirectAccess, const Scalar&, Scalar>::type CoeffReturnType;
+
+    /** \internal Represents a matrix with all coefficients equal to one another*/
+    typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,Matrix<Scalar,Dynamic,Dynamic> > ConstantReturnType;
+
+    /** type of the equivalent dense matrix */
+    typedef Matrix<Scalar,RowsAtCompileTime,ColsAtCompileTime> DenseMatrixType;
+    /** type of the equivalent square matrix */
+    typedef Matrix<Scalar,EIGEN_SIZE_MAX(RowsAtCompileTime,ColsAtCompileTime),
+                          EIGEN_SIZE_MAX(RowsAtCompileTime,ColsAtCompileTime)> SquareMatrixType;
+
+    inline const Derived& derived() const { return *static_cast<const Derived*>(this); }
+    inline Derived& derived() { return *static_cast<Derived*>(this); }
+    inline Derived& const_cast_derived() const
+    { return *static_cast<Derived*>(const_cast<SparseMatrixBase*>(this)); }
+
+    typedef EigenBase<Derived> Base;
+
+#endif // not EIGEN_PARSED_BY_DOXYGEN
+
+#define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::SparseMatrixBase
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+#define EIGEN_DOC_UNARY_ADDONS(METHOD,OP)           /** <p>This method does not change the sparsity of \c *this: the OP is applied to explicitly stored coefficients only. \sa SparseCompressedBase::coeffs() </p> */
+#define EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL      /** <p> \warning This method returns a read-only expression for any sparse matrices. \sa \ref TutorialSparse_SubMatrices "Sparse block operations" </p> */
+#define EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(COND) /** <p> \warning This method returns a read-write expression for COND sparse matrices only. Otherwise, the returned expression is read-only. \sa \ref TutorialSparse_SubMatrices "Sparse block operations" </p> */
+#else
+#define EIGEN_DOC_UNARY_ADDONS(X,Y)
+#define EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+#define EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(COND)
+#endif
+#   include "../plugins/CommonCwiseUnaryOps.h"
+#   include "../plugins/CommonCwiseBinaryOps.h"
+#   include "../plugins/MatrixCwiseUnaryOps.h"
+#   include "../plugins/MatrixCwiseBinaryOps.h"
+#   include "../plugins/BlockMethods.h"
+#   ifdef EIGEN_SPARSEMATRIXBASE_PLUGIN
+#     include EIGEN_SPARSEMATRIXBASE_PLUGIN
+#   endif
+#undef EIGEN_CURRENT_STORAGE_BASE_CLASS
+#undef EIGEN_DOC_UNARY_ADDONS
+#undef EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+#undef EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF
+
+    /** \returns the number of rows. \sa cols() */
+    inline Index rows() const { return derived().rows(); }
+    /** \returns the number of columns. \sa rows() */
+    inline Index cols() const { return derived().cols(); }
+    /** \returns the number of coefficients, which is \a rows()*cols().
+      * \sa rows(), cols(). */
+    inline Index size() const { return rows() * cols(); }
+    /** \returns true if either the number of rows or the number of columns is equal to 1.
+      * In other words, this function returns
+      * \code rows()==1 || cols()==1 \endcode
+      * \sa rows(), cols(), IsVectorAtCompileTime. */
+    inline bool isVector() const { return rows()==1 || cols()==1; }
+    /** \returns the size of the storage major dimension,
+      * i.e., the number of columns for a columns major matrix, and the number of rows otherwise */
+    Index outerSize() const { return (int(Flags)&RowMajorBit) ? this->rows() : this->cols(); }
+    /** \returns the size of the inner dimension according to the storage order,
+      * i.e., the number of rows for a columns major matrix, and the number of cols otherwise */
+    Index innerSize() const { return (int(Flags)&RowMajorBit) ? this->cols() : this->rows(); }
+
+    bool isRValue() const { return m_isRValue; }
+    Derived& markAsRValue() { m_isRValue = true; return derived(); }
+
+    SparseMatrixBase() : m_isRValue(false) { /* TODO check flags */ }
+
+    
+    template<typename OtherDerived>
+    Derived& operator=(const ReturnByValue<OtherDerived>& other);
+
+    template<typename OtherDerived>
+    inline Derived& operator=(const SparseMatrixBase<OtherDerived>& other);
+
+    inline Derived& operator=(const Derived& other);
+
+  protected:
+
+    template<typename OtherDerived>
+    inline Derived& assign(const OtherDerived& other);
+
+    template<typename OtherDerived>
+    inline void assignGeneric(const OtherDerived& other);
+
+  public:
+
+    friend std::ostream & operator << (std::ostream & s, const SparseMatrixBase& m)
+    {
+      typedef typename Derived::Nested Nested;
+      typedef typename internal::remove_all<Nested>::type NestedCleaned;
+
+      if (Flags&RowMajorBit)
+      {
+        Nested nm(m.derived());
+        internal::evaluator<NestedCleaned> thisEval(nm);
+        for (Index row=0; row<nm.outerSize(); ++row)
+        {
+          Index col = 0;
+          for (typename internal::evaluator<NestedCleaned>::InnerIterator it(thisEval, row); it; ++it)
+          {
+            for ( ; col<it.index(); ++col)
+              s << "0 ";
+            s << it.value() << " ";
+            ++col;
+          }
+          for ( ; col<m.cols(); ++col)
+            s << "0 ";
+          s << std::endl;
+        }
+      }
+      else
+      {
+        Nested nm(m.derived());
+        internal::evaluator<NestedCleaned> thisEval(nm);
+        if (m.cols() == 1) {
+          Index row = 0;
+          for (typename internal::evaluator<NestedCleaned>::InnerIterator it(thisEval, 0); it; ++it)
+          {
+            for ( ; row<it.index(); ++row)
+              s << "0" << std::endl;
+            s << it.value() << std::endl;
+            ++row;
+          }
+          for ( ; row<m.rows(); ++row)
+            s << "0" << std::endl;
+        }
+        else
+        {
+          SparseMatrix<Scalar, RowMajorBit, StorageIndex> trans = m;
+          s << static_cast<const SparseMatrixBase<SparseMatrix<Scalar, RowMajorBit, StorageIndex> >&>(trans);
+        }
+      }
+      return s;
+    }
+
+    template<typename OtherDerived>
+    Derived& operator+=(const SparseMatrixBase<OtherDerived>& other);
+    template<typename OtherDerived>
+    Derived& operator-=(const SparseMatrixBase<OtherDerived>& other);
+    
+    template<typename OtherDerived>
+    Derived& operator+=(const DiagonalBase<OtherDerived>& other);
+    template<typename OtherDerived>
+    Derived& operator-=(const DiagonalBase<OtherDerived>& other);
+
+    template<typename OtherDerived>
+    Derived& operator+=(const EigenBase<OtherDerived> &other);
+    template<typename OtherDerived>
+    Derived& operator-=(const EigenBase<OtherDerived> &other);
+
+    Derived& operator*=(const Scalar& other);
+    Derived& operator/=(const Scalar& other);
+
+    template<typename OtherDerived> struct CwiseProductDenseReturnType {
+      typedef CwiseBinaryOp<internal::scalar_product_op<typename ScalarBinaryOpTraits<
+                                                          typename internal::traits<Derived>::Scalar,
+                                                          typename internal::traits<OtherDerived>::Scalar
+                                                        >::ReturnType>,
+                            const Derived,
+                            const OtherDerived
+                          > Type;
+    };
+
+    template<typename OtherDerived>
+    EIGEN_STRONG_INLINE const typename CwiseProductDenseReturnType<OtherDerived>::Type
+    cwiseProduct(const MatrixBase<OtherDerived> &other) const;
+
+    // sparse * diagonal
+    template<typename OtherDerived>
+    const Product<Derived,OtherDerived>
+    operator*(const DiagonalBase<OtherDerived> &other) const
+    { return Product<Derived,OtherDerived>(derived(), other.derived()); }
+
+    // diagonal * sparse
+    template<typename OtherDerived> friend
+    const Product<OtherDerived,Derived>
+    operator*(const DiagonalBase<OtherDerived> &lhs, const SparseMatrixBase& rhs)
+    { return Product<OtherDerived,Derived>(lhs.derived(), rhs.derived()); }
+    
+    // sparse * sparse
+    template<typename OtherDerived>
+    const Product<Derived,OtherDerived,AliasFreeProduct>
+    operator*(const SparseMatrixBase<OtherDerived> &other) const;
+    
+    // sparse * dense
+    template<typename OtherDerived>
+    const Product<Derived,OtherDerived>
+    operator*(const MatrixBase<OtherDerived> &other) const
+    { return Product<Derived,OtherDerived>(derived(), other.derived()); }
+    
+    // dense * sparse
+    template<typename OtherDerived> friend
+    const Product<OtherDerived,Derived>
+    operator*(const MatrixBase<OtherDerived> &lhs, const SparseMatrixBase& rhs)
+    { return Product<OtherDerived,Derived>(lhs.derived(), rhs.derived()); }
+    
+     /** \returns an expression of P H P^-1 where H is the matrix represented by \c *this */
+    SparseSymmetricPermutationProduct<Derived,Upper|Lower> twistedBy(const PermutationMatrix<Dynamic,Dynamic,StorageIndex>& perm) const
+    {
+      return SparseSymmetricPermutationProduct<Derived,Upper|Lower>(derived(), perm);
+    }
+
+    template<typename OtherDerived>
+    Derived& operator*=(const SparseMatrixBase<OtherDerived>& other);
+
+    template<int Mode>
+    inline const TriangularView<const Derived, Mode> triangularView() const;
+    
+    template<unsigned int UpLo> struct SelfAdjointViewReturnType { typedef SparseSelfAdjointView<Derived, UpLo> Type; };
+    template<unsigned int UpLo> struct ConstSelfAdjointViewReturnType { typedef const SparseSelfAdjointView<const Derived, UpLo> Type; };
+
+    template<unsigned int UpLo> inline 
+    typename ConstSelfAdjointViewReturnType<UpLo>::Type selfadjointView() const;
+    template<unsigned int UpLo> inline
+    typename SelfAdjointViewReturnType<UpLo>::Type selfadjointView();
+
+    template<typename OtherDerived> Scalar dot(const MatrixBase<OtherDerived>& other) const;
+    template<typename OtherDerived> Scalar dot(const SparseMatrixBase<OtherDerived>& other) const;
+    RealScalar squaredNorm() const;
+    RealScalar norm()  const;
+    RealScalar blueNorm() const;
+
+    TransposeReturnType transpose() { return TransposeReturnType(derived()); }
+    const ConstTransposeReturnType transpose() const { return ConstTransposeReturnType(derived()); }
+    const AdjointReturnType adjoint() const { return AdjointReturnType(transpose()); }
+
+    // inner-vector
+    typedef Block<Derived,IsRowMajor?1:Dynamic,IsRowMajor?Dynamic:1,true>       InnerVectorReturnType;
+    typedef Block<const Derived,IsRowMajor?1:Dynamic,IsRowMajor?Dynamic:1,true> ConstInnerVectorReturnType;
+    InnerVectorReturnType innerVector(Index outer);
+    const ConstInnerVectorReturnType innerVector(Index outer) const;
+
+    // set of inner-vectors
+    typedef Block<Derived,Dynamic,Dynamic,true> InnerVectorsReturnType;
+    typedef Block<const Derived,Dynamic,Dynamic,true> ConstInnerVectorsReturnType;
+    InnerVectorsReturnType innerVectors(Index outerStart, Index outerSize);
+    const ConstInnerVectorsReturnType innerVectors(Index outerStart, Index outerSize) const;
+
+    DenseMatrixType toDense() const
+    {
+      return DenseMatrixType(derived());
+    }
+
+    template<typename OtherDerived>
+    bool isApprox(const SparseMatrixBase<OtherDerived>& other,
+                  const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+
+    template<typename OtherDerived>
+    bool isApprox(const MatrixBase<OtherDerived>& other,
+                  const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const
+    { return toDense().isApprox(other,prec); }
+
+    /** \returns the matrix or vector obtained by evaluating this expression.
+      *
+      * Notice that in the case of a plain matrix or vector (not an expression) this function just returns
+      * a const reference, in order to avoid a useless copy.
+      */
+    inline const typename internal::eval<Derived>::type eval() const
+    { return typename internal::eval<Derived>::type(derived()); }
+
+    Scalar sum() const;
+    
+    inline const SparseView<Derived>
+    pruned(const Scalar& reference = Scalar(0), const RealScalar& epsilon = NumTraits<Scalar>::dummy_precision()) const;
+
+  protected:
+
+    bool m_isRValue;
+
+    static inline StorageIndex convert_index(const Index idx) {
+      return internal::convert_index<StorageIndex>(idx);
+    }
+  private:
+    template<typename Dest> void evalTo(Dest &) const;
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSEMATRIXBASE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparsePermutation.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparsePermutation.h
new file mode 100644
index 00000000..ef38357a
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparsePermutation.h
@@ -0,0 +1,178 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_PERMUTATION_H
+#define EIGEN_SPARSE_PERMUTATION_H
+
+// This file implements sparse * permutation products
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename ExpressionType, int Side, bool Transposed>
+struct permutation_matrix_product<ExpressionType, Side, Transposed, SparseShape>
+{
+    typedef typename nested_eval<ExpressionType, 1>::type MatrixType;
+    typedef typename remove_all<MatrixType>::type MatrixTypeCleaned;
+
+    typedef typename MatrixTypeCleaned::Scalar Scalar;
+    typedef typename MatrixTypeCleaned::StorageIndex StorageIndex;
+
+    enum {
+      SrcStorageOrder = MatrixTypeCleaned::Flags&RowMajorBit ? RowMajor : ColMajor,
+      MoveOuter = SrcStorageOrder==RowMajor ? Side==OnTheLeft : Side==OnTheRight
+    };
+    
+    typedef typename internal::conditional<MoveOuter,
+        SparseMatrix<Scalar,SrcStorageOrder,StorageIndex>,
+        SparseMatrix<Scalar,int(SrcStorageOrder)==RowMajor?ColMajor:RowMajor,StorageIndex> >::type ReturnType;
+
+    template<typename Dest,typename PermutationType>
+    static inline void run(Dest& dst, const PermutationType& perm, const ExpressionType& xpr)
+    {
+      MatrixType mat(xpr);
+      if(MoveOuter)
+      {
+        SparseMatrix<Scalar,SrcStorageOrder,StorageIndex> tmp(mat.rows(), mat.cols());
+        Matrix<StorageIndex,Dynamic,1> sizes(mat.outerSize());
+        for(Index j=0; j<mat.outerSize(); ++j)
+        {
+          Index jp = perm.indices().coeff(j);
+          sizes[((Side==OnTheLeft) ^ Transposed) ? jp : j] = StorageIndex(mat.innerVector(((Side==OnTheRight) ^ Transposed) ? jp : j).nonZeros());
+        }
+        tmp.reserve(sizes);
+        for(Index j=0; j<mat.outerSize(); ++j)
+        {
+          Index jp = perm.indices().coeff(j);
+          Index jsrc = ((Side==OnTheRight) ^ Transposed) ? jp : j;
+          Index jdst = ((Side==OnTheLeft) ^ Transposed) ? jp : j;
+          for(typename MatrixTypeCleaned::InnerIterator it(mat,jsrc); it; ++it)
+            tmp.insertByOuterInner(jdst,it.index()) = it.value();
+        }
+        dst = tmp;
+      }
+      else
+      {
+        SparseMatrix<Scalar,int(SrcStorageOrder)==RowMajor?ColMajor:RowMajor,StorageIndex> tmp(mat.rows(), mat.cols());
+        Matrix<StorageIndex,Dynamic,1> sizes(tmp.outerSize());
+        sizes.setZero();
+        PermutationMatrix<Dynamic,Dynamic,StorageIndex> perm_cpy;
+        if((Side==OnTheLeft) ^ Transposed)
+          perm_cpy = perm;
+        else
+          perm_cpy = perm.transpose();
+
+        for(Index j=0; j<mat.outerSize(); ++j)
+          for(typename MatrixTypeCleaned::InnerIterator it(mat,j); it; ++it)
+            sizes[perm_cpy.indices().coeff(it.index())]++;
+        tmp.reserve(sizes);
+        for(Index j=0; j<mat.outerSize(); ++j)
+          for(typename MatrixTypeCleaned::InnerIterator it(mat,j); it; ++it)
+            tmp.insertByOuterInner(perm_cpy.indices().coeff(it.index()),j) = it.value();
+        dst = tmp;
+      }
+    }
+};
+
+}
+
+namespace internal {
+
+template <int ProductTag> struct product_promote_storage_type<Sparse,             PermutationStorage, ProductTag> { typedef Sparse ret; };
+template <int ProductTag> struct product_promote_storage_type<PermutationStorage, Sparse,             ProductTag> { typedef Sparse ret; };
+
+// TODO, the following two overloads are only needed to define the right temporary type through 
+// typename traits<permutation_sparse_matrix_product<Rhs,Lhs,OnTheRight,false> >::ReturnType
+// whereas it should be correctly handled by traits<Product<> >::PlainObject
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, AliasFreeProduct>, ProductTag, PermutationShape, SparseShape>
+  : public evaluator<typename permutation_matrix_product<Rhs,OnTheLeft,false,SparseShape>::ReturnType>
+{
+  typedef Product<Lhs, Rhs, AliasFreeProduct> XprType;
+  typedef typename permutation_matrix_product<Rhs,OnTheLeft,false,SparseShape>::ReturnType PlainObject;
+  typedef evaluator<PlainObject> Base;
+
+  enum {
+    Flags = Base::Flags | EvalBeforeNestingBit
+  };
+
+  explicit product_evaluator(const XprType& xpr)
+    : m_result(xpr.rows(), xpr.cols())
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+    generic_product_impl<Lhs, Rhs, PermutationShape, SparseShape, ProductTag>::evalTo(m_result, xpr.lhs(), xpr.rhs());
+  }
+
+protected:
+  PlainObject m_result;
+};
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, AliasFreeProduct>, ProductTag, SparseShape, PermutationShape >
+  : public evaluator<typename permutation_matrix_product<Lhs,OnTheRight,false,SparseShape>::ReturnType>
+{
+  typedef Product<Lhs, Rhs, AliasFreeProduct> XprType;
+  typedef typename permutation_matrix_product<Lhs,OnTheRight,false,SparseShape>::ReturnType PlainObject;
+  typedef evaluator<PlainObject> Base;
+
+  enum {
+    Flags = Base::Flags | EvalBeforeNestingBit
+  };
+
+  explicit product_evaluator(const XprType& xpr)
+    : m_result(xpr.rows(), xpr.cols())
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+    generic_product_impl<Lhs, Rhs, SparseShape, PermutationShape, ProductTag>::evalTo(m_result, xpr.lhs(), xpr.rhs());
+  }
+
+protected:
+  PlainObject m_result;
+};
+
+} // end namespace internal
+
+/** \returns the matrix with the permutation applied to the columns
+  */
+template<typename SparseDerived, typename PermDerived>
+inline const Product<SparseDerived, PermDerived, AliasFreeProduct>
+operator*(const SparseMatrixBase<SparseDerived>& matrix, const PermutationBase<PermDerived>& perm)
+{ return Product<SparseDerived, PermDerived, AliasFreeProduct>(matrix.derived(), perm.derived()); }
+
+/** \returns the matrix with the permutation applied to the rows
+  */
+template<typename SparseDerived, typename PermDerived>
+inline const Product<PermDerived, SparseDerived, AliasFreeProduct>
+operator*( const PermutationBase<PermDerived>& perm, const SparseMatrixBase<SparseDerived>& matrix)
+{ return  Product<PermDerived, SparseDerived, AliasFreeProduct>(perm.derived(), matrix.derived()); }
+
+
+/** \returns the matrix with the inverse permutation applied to the columns.
+  */
+template<typename SparseDerived, typename PermutationType>
+inline const Product<SparseDerived, Inverse<PermutationType>, AliasFreeProduct>
+operator*(const SparseMatrixBase<SparseDerived>& matrix, const InverseImpl<PermutationType, PermutationStorage>& tperm)
+{
+  return Product<SparseDerived, Inverse<PermutationType>, AliasFreeProduct>(matrix.derived(), tperm.derived());
+}
+
+/** \returns the matrix with the inverse permutation applied to the rows.
+  */
+template<typename SparseDerived, typename PermutationType>
+inline const Product<Inverse<PermutationType>, SparseDerived, AliasFreeProduct>
+operator*(const InverseImpl<PermutationType,PermutationStorage>& tperm, const SparseMatrixBase<SparseDerived>& matrix)
+{
+  return Product<Inverse<PermutationType>, SparseDerived, AliasFreeProduct>(tperm.derived(), matrix.derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_SELFADJOINTVIEW_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseProduct.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseProduct.h
new file mode 100644
index 00000000..4cbf6878
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseProduct.h
@@ -0,0 +1,169 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSEPRODUCT_H
+#define EIGEN_SPARSEPRODUCT_H
+
+namespace Eigen { 
+
+/** \returns an expression of the product of two sparse matrices.
+  * By default a conservative product preserving the symbolic non zeros is performed.
+  * The automatic pruning of the small values can be achieved by calling the pruned() function
+  * in which case a totally different product algorithm is employed:
+  * \code
+  * C = (A*B).pruned();             // supress numerical zeros (exact)
+  * C = (A*B).pruned(ref);
+  * C = (A*B).pruned(ref,epsilon);
+  * \endcode
+  * where \c ref is a meaningful non zero reference value.
+  * */
+template<typename Derived>
+template<typename OtherDerived>
+inline const Product<Derived,OtherDerived,AliasFreeProduct>
+SparseMatrixBase<Derived>::operator*(const SparseMatrixBase<OtherDerived> &other) const
+{
+  return Product<Derived,OtherDerived,AliasFreeProduct>(derived(), other.derived());
+}
+
+namespace internal {
+
+// sparse * sparse
+template<typename Lhs, typename Rhs, int ProductType>
+struct generic_product_impl<Lhs, Rhs, SparseShape, SparseShape, ProductType>
+{
+  template<typename Dest>
+  static void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    evalTo(dst, lhs, rhs, typename evaluator_traits<Dest>::Shape());
+  }
+
+  // dense += sparse * sparse
+  template<typename Dest,typename ActualLhs>
+  static void addTo(Dest& dst, const ActualLhs& lhs, const Rhs& rhs, typename enable_if<is_same<typename evaluator_traits<Dest>::Shape,DenseShape>::value,int*>::type* = 0)
+  {
+    typedef typename nested_eval<ActualLhs,Dynamic>::type LhsNested;
+    typedef typename nested_eval<Rhs,Dynamic>::type RhsNested;
+    LhsNested lhsNested(lhs);
+    RhsNested rhsNested(rhs);
+    internal::sparse_sparse_to_dense_product_selector<typename remove_all<LhsNested>::type,
+                                                      typename remove_all<RhsNested>::type, Dest>::run(lhsNested,rhsNested,dst);
+  }
+
+  // dense -= sparse * sparse
+  template<typename Dest>
+  static void subTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, typename enable_if<is_same<typename evaluator_traits<Dest>::Shape,DenseShape>::value,int*>::type* = 0)
+  {
+    addTo(dst, -lhs, rhs);
+  }
+
+protected:
+
+  // sparse = sparse * sparse
+  template<typename Dest>
+  static void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, SparseShape)
+  {
+    typedef typename nested_eval<Lhs,Dynamic>::type LhsNested;
+    typedef typename nested_eval<Rhs,Dynamic>::type RhsNested;
+    LhsNested lhsNested(lhs);
+    RhsNested rhsNested(rhs);
+    internal::conservative_sparse_sparse_product_selector<typename remove_all<LhsNested>::type,
+                                                          typename remove_all<RhsNested>::type, Dest>::run(lhsNested,rhsNested,dst);
+  }
+
+  // dense = sparse * sparse
+  template<typename Dest>
+  static void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, DenseShape)
+  {
+    dst.setZero();
+    addTo(dst, lhs, rhs);
+  }
+};
+
+// sparse * sparse-triangular
+template<typename Lhs, typename Rhs, int ProductType>
+struct generic_product_impl<Lhs, Rhs, SparseShape, SparseTriangularShape, ProductType>
+ : public generic_product_impl<Lhs, Rhs, SparseShape, SparseShape, ProductType>
+{};
+
+// sparse-triangular * sparse
+template<typename Lhs, typename Rhs, int ProductType>
+struct generic_product_impl<Lhs, Rhs, SparseTriangularShape, SparseShape, ProductType>
+ : public generic_product_impl<Lhs, Rhs, SparseShape, SparseShape, ProductType>
+{};
+
+// dense = sparse-product (can be sparse*sparse, sparse*perm, etc.)
+template< typename DstXprType, typename Lhs, typename Rhs>
+struct Assignment<DstXprType, Product<Lhs,Rhs,AliasFreeProduct>, internal::assign_op<typename DstXprType::Scalar,typename Product<Lhs,Rhs,AliasFreeProduct>::Scalar>, Sparse2Dense>
+{
+  typedef Product<Lhs,Rhs,AliasFreeProduct> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+    
+    generic_product_impl<Lhs, Rhs>::evalTo(dst,src.lhs(),src.rhs());
+  }
+};
+
+// dense += sparse-product (can be sparse*sparse, sparse*perm, etc.)
+template< typename DstXprType, typename Lhs, typename Rhs>
+struct Assignment<DstXprType, Product<Lhs,Rhs,AliasFreeProduct>, internal::add_assign_op<typename DstXprType::Scalar,typename Product<Lhs,Rhs,AliasFreeProduct>::Scalar>, Sparse2Dense>
+{
+  typedef Product<Lhs,Rhs,AliasFreeProduct> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &)
+  {
+    generic_product_impl<Lhs, Rhs>::addTo(dst,src.lhs(),src.rhs());
+  }
+};
+
+// dense -= sparse-product (can be sparse*sparse, sparse*perm, etc.)
+template< typename DstXprType, typename Lhs, typename Rhs>
+struct Assignment<DstXprType, Product<Lhs,Rhs,AliasFreeProduct>, internal::sub_assign_op<typename DstXprType::Scalar,typename Product<Lhs,Rhs,AliasFreeProduct>::Scalar>, Sparse2Dense>
+{
+  typedef Product<Lhs,Rhs,AliasFreeProduct> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &)
+  {
+    generic_product_impl<Lhs, Rhs>::subTo(dst,src.lhs(),src.rhs());
+  }
+};
+
+template<typename Lhs, typename Rhs, int Options>
+struct unary_evaluator<SparseView<Product<Lhs, Rhs, Options> >, IteratorBased>
+ : public evaluator<typename Product<Lhs, Rhs, DefaultProduct>::PlainObject>
+{
+  typedef SparseView<Product<Lhs, Rhs, Options> > XprType;
+  typedef typename XprType::PlainObject PlainObject;
+  typedef evaluator<PlainObject> Base;
+
+  explicit unary_evaluator(const XprType& xpr)
+    : m_result(xpr.rows(), xpr.cols())
+  {
+    using std::abs;
+    ::new (static_cast<Base*>(this)) Base(m_result);
+    typedef typename nested_eval<Lhs,Dynamic>::type LhsNested;
+    typedef typename nested_eval<Rhs,Dynamic>::type RhsNested;
+    LhsNested lhsNested(xpr.nestedExpression().lhs());
+    RhsNested rhsNested(xpr.nestedExpression().rhs());
+
+    internal::sparse_sparse_product_with_pruning_selector<typename remove_all<LhsNested>::type,
+                                                          typename remove_all<RhsNested>::type, PlainObject>::run(lhsNested,rhsNested,m_result,
+                                                                                                                  abs(xpr.reference())*xpr.epsilon());
+  }
+
+protected:
+  PlainObject m_result;
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSEPRODUCT_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseRedux.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseRedux.h
new file mode 100644
index 00000000..45877496
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseRedux.h
@@ -0,0 +1,49 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSEREDUX_H
+#define EIGEN_SPARSEREDUX_H
+
+namespace Eigen { 
+
+template<typename Derived>
+typename internal::traits<Derived>::Scalar
+SparseMatrixBase<Derived>::sum() const
+{
+  eigen_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix");
+  Scalar res(0);
+  internal::evaluator<Derived> thisEval(derived());
+  for (Index j=0; j<outerSize(); ++j)
+    for (typename internal::evaluator<Derived>::InnerIterator iter(thisEval,j); iter; ++iter)
+      res += iter.value();
+  return res;
+}
+
+template<typename _Scalar, int _Options, typename _Index>
+typename internal::traits<SparseMatrix<_Scalar,_Options,_Index> >::Scalar
+SparseMatrix<_Scalar,_Options,_Index>::sum() const
+{
+  eigen_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix");
+  if(this->isCompressed())
+    return Matrix<Scalar,1,Dynamic>::Map(m_data.valuePtr(), m_data.size()).sum();
+  else
+    return Base::sum();
+}
+
+template<typename _Scalar, int _Options, typename _Index>
+typename internal::traits<SparseVector<_Scalar,_Options, _Index> >::Scalar
+SparseVector<_Scalar,_Options,_Index>::sum() const
+{
+  eigen_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix");
+  return Matrix<Scalar,1,Dynamic>::Map(m_data.valuePtr(), m_data.size()).sum();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSEREDUX_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseRef.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseRef.h
new file mode 100644
index 00000000..d91f38f9
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseRef.h
@@ -0,0 +1,397 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_REF_H
+#define EIGEN_SPARSE_REF_H
+
+namespace Eigen {
+
+enum {
+  StandardCompressedFormat = 2 /**< used by Ref<SparseMatrix> to specify whether the input storage must be in standard compressed form */
+};
+  
+namespace internal {
+
+template<typename Derived> class SparseRefBase;
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int _Options, typename _StrideType>
+struct traits<Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, _Options, _StrideType> >
+  : public traits<SparseMatrix<MatScalar,MatOptions,MatIndex> >
+{
+  typedef SparseMatrix<MatScalar,MatOptions,MatIndex> PlainObjectType;
+  enum {
+    Options = _Options,
+    Flags = traits<PlainObjectType>::Flags | CompressedAccessBit | NestByRefBit
+  };
+
+  template<typename Derived> struct match {
+    enum {
+      StorageOrderMatch = PlainObjectType::IsVectorAtCompileTime || Derived::IsVectorAtCompileTime || ((PlainObjectType::Flags&RowMajorBit)==(Derived::Flags&RowMajorBit)),
+      MatchAtCompileTime = (Derived::Flags&CompressedAccessBit) && StorageOrderMatch
+    };
+    typedef typename internal::conditional<MatchAtCompileTime,internal::true_type,internal::false_type>::type type;
+  };
+  
+};
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int _Options, typename _StrideType>
+struct traits<Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, _Options, _StrideType> >
+  : public traits<Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, _Options, _StrideType> >
+{
+  enum {
+    Flags = (traits<SparseMatrix<MatScalar,MatOptions,MatIndex> >::Flags | CompressedAccessBit | NestByRefBit) & ~LvalueBit
+  };
+};
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int _Options, typename _StrideType>
+struct traits<Ref<SparseVector<MatScalar,MatOptions,MatIndex>, _Options, _StrideType> >
+  : public traits<SparseVector<MatScalar,MatOptions,MatIndex> >
+{
+  typedef SparseVector<MatScalar,MatOptions,MatIndex> PlainObjectType;
+  enum {
+    Options = _Options,
+    Flags = traits<PlainObjectType>::Flags | CompressedAccessBit | NestByRefBit
+  };
+
+  template<typename Derived> struct match {
+    enum {
+      MatchAtCompileTime = (Derived::Flags&CompressedAccessBit) && Derived::IsVectorAtCompileTime
+    };
+    typedef typename internal::conditional<MatchAtCompileTime,internal::true_type,internal::false_type>::type type;
+  };
+
+};
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int _Options, typename _StrideType>
+struct traits<Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, _Options, _StrideType> >
+  : public traits<Ref<SparseVector<MatScalar,MatOptions,MatIndex>, _Options, _StrideType> >
+{
+  enum {
+    Flags = (traits<SparseVector<MatScalar,MatOptions,MatIndex> >::Flags | CompressedAccessBit | NestByRefBit) & ~LvalueBit
+  };
+};
+
+template<typename Derived>
+struct traits<SparseRefBase<Derived> > : public traits<Derived> {};
+
+template<typename Derived> class SparseRefBase
+  : public SparseMapBase<Derived>
+{
+public:
+
+  typedef SparseMapBase<Derived> Base;
+  EIGEN_SPARSE_PUBLIC_INTERFACE(SparseRefBase)
+
+  SparseRefBase()
+    : Base(RowsAtCompileTime==Dynamic?0:RowsAtCompileTime,ColsAtCompileTime==Dynamic?0:ColsAtCompileTime, 0, 0, 0, 0, 0)
+  {}
+  
+protected:
+
+  template<typename Expression>
+  void construct(Expression& expr)
+  {
+    if(expr.outerIndexPtr()==0)
+      ::new (static_cast<Base*>(this)) Base(expr.size(), expr.nonZeros(), expr.innerIndexPtr(), expr.valuePtr());
+    else
+      ::new (static_cast<Base*>(this)) Base(expr.rows(), expr.cols(), expr.nonZeros(), expr.outerIndexPtr(), expr.innerIndexPtr(), expr.valuePtr(), expr.innerNonZeroPtr());
+  }
+};
+
+} // namespace internal
+
+
+/** 
+  * \ingroup SparseCore_Module
+  *
+  * \brief A sparse matrix expression referencing an existing sparse expression
+  *
+  * \tparam SparseMatrixType the equivalent sparse matrix type of the referenced data, it must be a template instance of class SparseMatrix.
+  * \tparam Options specifies whether the a standard compressed format is required \c Options is  \c #StandardCompressedFormat, or \c 0.
+  *                The default is \c 0.
+  *
+  * \sa class Ref
+  */
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+class Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType >
+  : public internal::SparseRefBase<Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType > >
+#else
+template<typename SparseMatrixType, int Options>
+class Ref<SparseMatrixType, Options>
+  : public SparseMapBase<Derived,WriteAccessors> // yes, that's weird to use Derived here, but that works!
+#endif
+{
+    typedef SparseMatrix<MatScalar,MatOptions,MatIndex> PlainObjectType;
+    typedef internal::traits<Ref> Traits;
+    template<int OtherOptions>
+    inline Ref(const SparseMatrix<MatScalar,OtherOptions,MatIndex>& expr);
+    template<int OtherOptions>
+    inline Ref(const MappedSparseMatrix<MatScalar,OtherOptions,MatIndex>& expr);
+  public:
+
+    typedef internal::SparseRefBase<Ref> Base;
+    EIGEN_SPARSE_PUBLIC_INTERFACE(Ref)
+
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<int OtherOptions>
+    inline Ref(SparseMatrix<MatScalar,OtherOptions,MatIndex>& expr)
+    {
+      EIGEN_STATIC_ASSERT(bool(Traits::template match<SparseMatrix<MatScalar,OtherOptions,MatIndex> >::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
+      eigen_assert( ((Options & int(StandardCompressedFormat))==0) || (expr.isCompressed()) );
+      Base::construct(expr.derived());
+    }
+    
+    template<int OtherOptions>
+    inline Ref(MappedSparseMatrix<MatScalar,OtherOptions,MatIndex>& expr)
+    {
+      EIGEN_STATIC_ASSERT(bool(Traits::template match<SparseMatrix<MatScalar,OtherOptions,MatIndex> >::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
+      eigen_assert( ((Options & int(StandardCompressedFormat))==0) || (expr.isCompressed()) );
+      Base::construct(expr.derived());
+    }
+    
+    template<typename Derived>
+    inline Ref(const SparseCompressedBase<Derived>& expr)
+    #else
+    /** Implicit constructor from any sparse expression (2D matrix or 1D vector) */
+    template<typename Derived>
+    inline Ref(SparseCompressedBase<Derived>& expr)
+    #endif
+    {
+      EIGEN_STATIC_ASSERT(bool(internal::is_lvalue<Derived>::value), THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY);
+      EIGEN_STATIC_ASSERT(bool(Traits::template match<Derived>::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
+      eigen_assert( ((Options & int(StandardCompressedFormat))==0) || (expr.isCompressed()) );
+      Base::construct(expr.const_cast_derived());
+    }
+};
+
+// this is the const ref version
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+class Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType>
+  : public internal::SparseRefBase<Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+{
+    typedef SparseMatrix<MatScalar,MatOptions,MatIndex> TPlainObjectType;
+    typedef internal::traits<Ref> Traits;
+  public:
+
+    typedef internal::SparseRefBase<Ref> Base;
+    EIGEN_SPARSE_PUBLIC_INTERFACE(Ref)
+
+    template<typename Derived>
+    inline Ref(const SparseMatrixBase<Derived>& expr) : m_hasCopy(false)
+    {
+      construct(expr.derived(), typename Traits::template match<Derived>::type());
+    }
+
+    inline Ref(const Ref& other) : Base(other), m_hasCopy(false) {
+      // copy constructor shall not copy the m_object, to avoid unnecessary malloc and copy
+    }
+
+    template<typename OtherRef>
+    inline Ref(const RefBase<OtherRef>& other) : m_hasCopy(false) {
+      construct(other.derived(), typename Traits::template match<OtherRef>::type());
+    }
+
+    ~Ref() {
+      if(m_hasCopy) {
+        TPlainObjectType* obj = reinterpret_cast<TPlainObjectType*>(m_object_bytes);
+        obj->~TPlainObjectType();
+      }
+    }
+
+  protected:
+
+    template<typename Expression>
+    void construct(const Expression& expr,internal::true_type)
+    {
+      if((Options & int(StandardCompressedFormat)) && (!expr.isCompressed()))
+      {
+        TPlainObjectType* obj = reinterpret_cast<TPlainObjectType*>(m_object_bytes);
+        ::new (obj) TPlainObjectType(expr);
+        m_hasCopy = true;
+        Base::construct(*obj);
+      }
+      else
+      {
+        Base::construct(expr);
+      }
+    }
+
+    template<typename Expression>
+    void construct(const Expression& expr, internal::false_type)
+    {
+      TPlainObjectType* obj = reinterpret_cast<TPlainObjectType*>(m_object_bytes);
+      ::new (obj) TPlainObjectType(expr);
+      m_hasCopy = true;
+      Base::construct(*obj);
+    }
+
+  protected:
+    char m_object_bytes[sizeof(TPlainObjectType)];
+    bool m_hasCopy;
+};
+
+
+
+/**
+  * \ingroup SparseCore_Module
+  *
+  * \brief A sparse vector expression referencing an existing sparse vector expression
+  *
+  * \tparam SparseVectorType the equivalent sparse vector type of the referenced data, it must be a template instance of class SparseVector.
+  *
+  * \sa class Ref
+  */
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+class Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType >
+  : public internal::SparseRefBase<Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType > >
+#else
+template<typename SparseVectorType>
+class Ref<SparseVectorType>
+  : public SparseMapBase<Derived,WriteAccessors>
+#endif
+{
+    typedef SparseVector<MatScalar,MatOptions,MatIndex> PlainObjectType;
+    typedef internal::traits<Ref> Traits;
+    template<int OtherOptions>
+    inline Ref(const SparseVector<MatScalar,OtherOptions,MatIndex>& expr);
+  public:
+
+    typedef internal::SparseRefBase<Ref> Base;
+    EIGEN_SPARSE_PUBLIC_INTERFACE(Ref)
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<int OtherOptions>
+    inline Ref(SparseVector<MatScalar,OtherOptions,MatIndex>& expr)
+    {
+      EIGEN_STATIC_ASSERT(bool(Traits::template match<SparseVector<MatScalar,OtherOptions,MatIndex> >::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
+      Base::construct(expr.derived());
+    }
+
+    template<typename Derived>
+    inline Ref(const SparseCompressedBase<Derived>& expr)
+    #else
+    /** Implicit constructor from any 1D sparse vector expression */
+    template<typename Derived>
+    inline Ref(SparseCompressedBase<Derived>& expr)
+    #endif
+    {
+      EIGEN_STATIC_ASSERT(bool(internal::is_lvalue<Derived>::value), THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY);
+      EIGEN_STATIC_ASSERT(bool(Traits::template match<Derived>::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
+      Base::construct(expr.const_cast_derived());
+    }
+};
+
+// this is the const ref version
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+class Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType>
+  : public internal::SparseRefBase<Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+{
+    typedef SparseVector<MatScalar,MatOptions,MatIndex> TPlainObjectType;
+    typedef internal::traits<Ref> Traits;
+  public:
+
+    typedef internal::SparseRefBase<Ref> Base;
+    EIGEN_SPARSE_PUBLIC_INTERFACE(Ref)
+
+    template<typename Derived>
+    inline Ref(const SparseMatrixBase<Derived>& expr) : m_hasCopy(false)
+    {
+      construct(expr.derived(), typename Traits::template match<Derived>::type());
+    }
+
+    inline Ref(const Ref& other) : Base(other), m_hasCopy(false) {
+      // copy constructor shall not copy the m_object, to avoid unnecessary malloc and copy
+    }
+
+    template<typename OtherRef>
+    inline Ref(const RefBase<OtherRef>& other) : m_hasCopy(false) {
+      construct(other.derived(), typename Traits::template match<OtherRef>::type());
+    }
+
+    ~Ref() {
+      if(m_hasCopy) {
+        TPlainObjectType* obj = reinterpret_cast<TPlainObjectType*>(m_object_bytes);
+        obj->~TPlainObjectType();
+      }
+    }
+
+  protected:
+
+    template<typename Expression>
+    void construct(const Expression& expr,internal::true_type)
+    {
+      Base::construct(expr);
+    }
+
+    template<typename Expression>
+    void construct(const Expression& expr, internal::false_type)
+    {
+      TPlainObjectType* obj = reinterpret_cast<TPlainObjectType*>(m_object_bytes);
+      ::new (obj) TPlainObjectType(expr);
+      m_hasCopy = true;
+      Base::construct(*obj);
+    }
+
+  protected:
+    char m_object_bytes[sizeof(TPlainObjectType)];
+    bool m_hasCopy;
+};
+
+namespace internal {
+
+// FIXME shall we introduce a general evaluatior_ref that we can specialize for any sparse object once, and thus remove this copy-pasta thing...
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+struct evaluator<Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+  : evaluator<SparseCompressedBase<Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > >
+{
+  typedef evaluator<SparseCompressedBase<Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > > Base;
+  typedef Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> XprType;  
+  evaluator() : Base() {}
+  explicit evaluator(const XprType &mat) : Base(mat) {}
+};
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+struct evaluator<Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+  : evaluator<SparseCompressedBase<Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > >
+{
+  typedef evaluator<SparseCompressedBase<Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > > Base;
+  typedef Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> XprType;  
+  evaluator() : Base() {}
+  explicit evaluator(const XprType &mat) : Base(mat) {}
+};
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+struct evaluator<Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+  : evaluator<SparseCompressedBase<Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> > >
+{
+  typedef evaluator<SparseCompressedBase<Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> > > Base;
+  typedef Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> XprType;
+  evaluator() : Base() {}
+  explicit evaluator(const XprType &mat) : Base(mat) {}
+};
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+struct evaluator<Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+  : evaluator<SparseCompressedBase<Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> > >
+{
+  typedef evaluator<SparseCompressedBase<Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> > > Base;
+  typedef Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> XprType;
+  evaluator() : Base() {}
+  explicit evaluator(const XprType &mat) : Base(mat) {}
+};
+
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_REF_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseSelfAdjointView.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseSelfAdjointView.h
new file mode 100644
index 00000000..5ab64f1a
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseSelfAdjointView.h
@@ -0,0 +1,656 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_SELFADJOINTVIEW_H
+#define EIGEN_SPARSE_SELFADJOINTVIEW_H
+
+namespace Eigen { 
+  
+/** \ingroup SparseCore_Module
+  * \class SparseSelfAdjointView
+  *
+  * \brief Pseudo expression to manipulate a triangular sparse matrix as a selfadjoint matrix.
+  *
+  * \param MatrixType the type of the dense matrix storing the coefficients
+  * \param Mode can be either \c #Lower or \c #Upper
+  *
+  * This class is an expression of a sefladjoint matrix from a triangular part of a matrix
+  * with given dense storage of the coefficients. It is the return type of MatrixBase::selfadjointView()
+  * and most of the time this is the only way that it is used.
+  *
+  * \sa SparseMatrixBase::selfadjointView()
+  */
+namespace internal {
+  
+template<typename MatrixType, unsigned int Mode>
+struct traits<SparseSelfAdjointView<MatrixType,Mode> > : traits<MatrixType> {
+};
+
+template<int SrcMode,int DstMode,typename MatrixType,int DestOrder>
+void permute_symm_to_symm(const MatrixType& mat, SparseMatrix<typename MatrixType::Scalar,DestOrder,typename MatrixType::StorageIndex>& _dest, const typename MatrixType::StorageIndex* perm = 0);
+
+template<int Mode,typename MatrixType,int DestOrder>
+void permute_symm_to_fullsymm(const MatrixType& mat, SparseMatrix<typename MatrixType::Scalar,DestOrder,typename MatrixType::StorageIndex>& _dest, const typename MatrixType::StorageIndex* perm = 0);
+
+}
+
+template<typename MatrixType, unsigned int _Mode> class SparseSelfAdjointView
+  : public EigenBase<SparseSelfAdjointView<MatrixType,_Mode> >
+{
+  public:
+    
+    enum {
+      Mode = _Mode,
+      TransposeMode = ((Mode & Upper) ? Lower : 0) | ((Mode & Lower) ? Upper : 0),
+      RowsAtCompileTime = internal::traits<SparseSelfAdjointView>::RowsAtCompileTime,
+      ColsAtCompileTime = internal::traits<SparseSelfAdjointView>::ColsAtCompileTime
+    };
+
+    typedef EigenBase<SparseSelfAdjointView> Base;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef Matrix<StorageIndex,Dynamic,1> VectorI;
+    typedef typename internal::ref_selector<MatrixType>::non_const_type MatrixTypeNested;
+    typedef typename internal::remove_all<MatrixTypeNested>::type _MatrixTypeNested;
+    
+    explicit inline SparseSelfAdjointView(MatrixType& matrix) : m_matrix(matrix)
+    {
+      eigen_assert(rows()==cols() && "SelfAdjointView is only for squared matrices");
+    }
+
+    inline Index rows() const { return m_matrix.rows(); }
+    inline Index cols() const { return m_matrix.cols(); }
+
+    /** \internal \returns a reference to the nested matrix */
+    const _MatrixTypeNested& matrix() const { return m_matrix; }
+    typename internal::remove_reference<MatrixTypeNested>::type& matrix() { return m_matrix; }
+
+    /** \returns an expression of the matrix product between a sparse self-adjoint matrix \c *this and a sparse matrix \a rhs.
+      *
+      * Note that there is no algorithmic advantage of performing such a product compared to a general sparse-sparse matrix product.
+      * Indeed, the SparseSelfadjointView operand is first copied into a temporary SparseMatrix before computing the product.
+      */
+    template<typename OtherDerived>
+    Product<SparseSelfAdjointView, OtherDerived>
+    operator*(const SparseMatrixBase<OtherDerived>& rhs) const
+    {
+      return Product<SparseSelfAdjointView, OtherDerived>(*this, rhs.derived());
+    }
+
+    /** \returns an expression of the matrix product between a sparse matrix \a lhs and a sparse self-adjoint matrix \a rhs.
+      *
+      * Note that there is no algorithmic advantage of performing such a product compared to a general sparse-sparse matrix product.
+      * Indeed, the SparseSelfadjointView operand is first copied into a temporary SparseMatrix before computing the product.
+      */
+    template<typename OtherDerived> friend
+    Product<OtherDerived, SparseSelfAdjointView>
+    operator*(const SparseMatrixBase<OtherDerived>& lhs, const SparseSelfAdjointView& rhs)
+    {
+      return Product<OtherDerived, SparseSelfAdjointView>(lhs.derived(), rhs);
+    }
+    
+    /** Efficient sparse self-adjoint matrix times dense vector/matrix product */
+    template<typename OtherDerived>
+    Product<SparseSelfAdjointView,OtherDerived>
+    operator*(const MatrixBase<OtherDerived>& rhs) const
+    {
+      return Product<SparseSelfAdjointView,OtherDerived>(*this, rhs.derived());
+    }
+
+    /** Efficient dense vector/matrix times sparse self-adjoint matrix product */
+    template<typename OtherDerived> friend
+    Product<OtherDerived,SparseSelfAdjointView>
+    operator*(const MatrixBase<OtherDerived>& lhs, const SparseSelfAdjointView& rhs)
+    {
+      return Product<OtherDerived,SparseSelfAdjointView>(lhs.derived(), rhs);
+    }
+
+    /** Perform a symmetric rank K update of the selfadjoint matrix \c *this:
+      * \f$ this = this + \alpha ( u u^* ) \f$ where \a u is a vector or matrix.
+      *
+      * \returns a reference to \c *this
+      *
+      * To perform \f$ this = this + \alpha ( u^* u ) \f$ you can simply
+      * call this function with u.adjoint().
+      */
+    template<typename DerivedU>
+    SparseSelfAdjointView& rankUpdate(const SparseMatrixBase<DerivedU>& u, const Scalar& alpha = Scalar(1));
+    
+    /** \returns an expression of P H P^-1 */
+    // TODO implement twists in a more evaluator friendly fashion
+    SparseSymmetricPermutationProduct<_MatrixTypeNested,Mode> twistedBy(const PermutationMatrix<Dynamic,Dynamic,StorageIndex>& perm) const
+    {
+      return SparseSymmetricPermutationProduct<_MatrixTypeNested,Mode>(m_matrix, perm);
+    }
+
+    template<typename SrcMatrixType,int SrcMode>
+    SparseSelfAdjointView& operator=(const SparseSymmetricPermutationProduct<SrcMatrixType,SrcMode>& permutedMatrix)
+    {
+      internal::call_assignment_no_alias_no_transpose(*this, permutedMatrix);
+      return *this;
+    }
+
+    SparseSelfAdjointView& operator=(const SparseSelfAdjointView& src)
+    {
+      PermutationMatrix<Dynamic,Dynamic,StorageIndex> pnull;
+      return *this = src.twistedBy(pnull);
+    }
+
+    template<typename SrcMatrixType,unsigned int SrcMode>
+    SparseSelfAdjointView& operator=(const SparseSelfAdjointView<SrcMatrixType,SrcMode>& src)
+    {
+      PermutationMatrix<Dynamic,Dynamic,StorageIndex> pnull;
+      return *this = src.twistedBy(pnull);
+    }
+    
+    void resize(Index rows, Index cols)
+    {
+      EIGEN_ONLY_USED_FOR_DEBUG(rows);
+      EIGEN_ONLY_USED_FOR_DEBUG(cols);
+      eigen_assert(rows == this->rows() && cols == this->cols()
+                && "SparseSelfadjointView::resize() does not actually allow to resize.");
+    }
+    
+  protected:
+
+    MatrixTypeNested m_matrix;
+    //mutable VectorI m_countPerRow;
+    //mutable VectorI m_countPerCol;
+  private:
+    template<typename Dest> void evalTo(Dest &) const;
+};
+
+/***************************************************************************
+* Implementation of SparseMatrixBase methods
+***************************************************************************/
+
+template<typename Derived>
+template<unsigned int UpLo>
+typename SparseMatrixBase<Derived>::template ConstSelfAdjointViewReturnType<UpLo>::Type SparseMatrixBase<Derived>::selfadjointView() const
+{
+  return SparseSelfAdjointView<const Derived, UpLo>(derived());
+}
+
+template<typename Derived>
+template<unsigned int UpLo>
+typename SparseMatrixBase<Derived>::template SelfAdjointViewReturnType<UpLo>::Type SparseMatrixBase<Derived>::selfadjointView()
+{
+  return SparseSelfAdjointView<Derived, UpLo>(derived());
+}
+
+/***************************************************************************
+* Implementation of SparseSelfAdjointView methods
+***************************************************************************/
+
+template<typename MatrixType, unsigned int Mode>
+template<typename DerivedU>
+SparseSelfAdjointView<MatrixType,Mode>&
+SparseSelfAdjointView<MatrixType,Mode>::rankUpdate(const SparseMatrixBase<DerivedU>& u, const Scalar& alpha)
+{
+  SparseMatrix<Scalar,(MatrixType::Flags&RowMajorBit)?RowMajor:ColMajor> tmp = u * u.adjoint();
+  if(alpha==Scalar(0))
+    m_matrix = tmp.template triangularView<Mode>();
+  else
+    m_matrix += alpha * tmp.template triangularView<Mode>();
+
+  return *this;
+}
+
+namespace internal {
+  
+// TODO currently a selfadjoint expression has the form SelfAdjointView<.,.>
+//      in the future selfadjoint-ness should be defined by the expression traits
+//      such that Transpose<SelfAdjointView<.,.> > is valid. (currently TriangularBase::transpose() is overloaded to make it work)
+template<typename MatrixType, unsigned int Mode>
+struct evaluator_traits<SparseSelfAdjointView<MatrixType,Mode> >
+{
+  typedef typename storage_kind_to_evaluator_kind<typename MatrixType::StorageKind>::Kind Kind;
+  typedef SparseSelfAdjointShape Shape;
+};
+
+struct SparseSelfAdjoint2Sparse {};
+
+template<> struct AssignmentKind<SparseShape,SparseSelfAdjointShape> { typedef SparseSelfAdjoint2Sparse Kind; };
+template<> struct AssignmentKind<SparseSelfAdjointShape,SparseShape> { typedef Sparse2Sparse Kind; };
+
+template< typename DstXprType, typename SrcXprType, typename Functor>
+struct Assignment<DstXprType, SrcXprType, Functor, SparseSelfAdjoint2Sparse>
+{
+  typedef typename DstXprType::StorageIndex StorageIndex;
+  typedef internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> AssignOpType;
+
+  template<typename DestScalar,int StorageOrder>
+  static void run(SparseMatrix<DestScalar,StorageOrder,StorageIndex> &dst, const SrcXprType &src, const AssignOpType&/*func*/)
+  {
+    internal::permute_symm_to_fullsymm<SrcXprType::Mode>(src.matrix(), dst);
+  }
+
+  // FIXME: the handling of += and -= in sparse matrices should be cleanup so that next two overloads could be reduced to:
+  template<typename DestScalar,int StorageOrder,typename AssignFunc>
+  static void run(SparseMatrix<DestScalar,StorageOrder,StorageIndex> &dst, const SrcXprType &src, const AssignFunc& func)
+  {
+    SparseMatrix<DestScalar,StorageOrder,StorageIndex> tmp(src.rows(),src.cols());
+    run(tmp, src, AssignOpType());
+    call_assignment_no_alias_no_transpose(dst, tmp, func);
+  }
+
+  template<typename DestScalar,int StorageOrder>
+  static void run(SparseMatrix<DestScalar,StorageOrder,StorageIndex> &dst, const SrcXprType &src,
+                  const internal::add_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar>& /* func */)
+  {
+    SparseMatrix<DestScalar,StorageOrder,StorageIndex> tmp(src.rows(),src.cols());
+    run(tmp, src, AssignOpType());
+    dst += tmp;
+  }
+
+  template<typename DestScalar,int StorageOrder>
+  static void run(SparseMatrix<DestScalar,StorageOrder,StorageIndex> &dst, const SrcXprType &src,
+                  const internal::sub_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar>& /* func */)
+  {
+    SparseMatrix<DestScalar,StorageOrder,StorageIndex> tmp(src.rows(),src.cols());
+    run(tmp, src, AssignOpType());
+    dst -= tmp;
+  }
+  
+  template<typename DestScalar>
+  static void run(DynamicSparseMatrix<DestScalar,ColMajor,StorageIndex>& dst, const SrcXprType &src, const AssignOpType&/*func*/)
+  {
+    // TODO directly evaluate into dst;
+    SparseMatrix<DestScalar,ColMajor,StorageIndex> tmp(dst.rows(),dst.cols());
+    internal::permute_symm_to_fullsymm<SrcXprType::Mode>(src.matrix(), tmp);
+    dst = tmp;
+  }
+};
+
+} // end namespace internal
+
+/***************************************************************************
+* Implementation of sparse self-adjoint time dense matrix
+***************************************************************************/
+
+namespace internal {
+
+template<int Mode, typename SparseLhsType, typename DenseRhsType, typename DenseResType, typename AlphaType>
+inline void sparse_selfadjoint_time_dense_product(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res, const AlphaType& alpha)
+{
+  EIGEN_ONLY_USED_FOR_DEBUG(alpha);
+  
+  typedef typename internal::nested_eval<SparseLhsType,DenseRhsType::MaxColsAtCompileTime>::type SparseLhsTypeNested;
+  typedef typename internal::remove_all<SparseLhsTypeNested>::type SparseLhsTypeNestedCleaned;
+  typedef evaluator<SparseLhsTypeNestedCleaned> LhsEval;
+  typedef typename LhsEval::InnerIterator LhsIterator;
+  typedef typename SparseLhsType::Scalar LhsScalar;
+  
+  enum {
+    LhsIsRowMajor = (LhsEval::Flags&RowMajorBit)==RowMajorBit,
+    ProcessFirstHalf =
+              ((Mode&(Upper|Lower))==(Upper|Lower))
+          || ( (Mode&Upper) && !LhsIsRowMajor)
+          || ( (Mode&Lower) && LhsIsRowMajor),
+    ProcessSecondHalf = !ProcessFirstHalf
+  };
+  
+  SparseLhsTypeNested lhs_nested(lhs);
+  LhsEval lhsEval(lhs_nested);
+
+  // work on one column at once
+  for (Index k=0; k<rhs.cols(); ++k)
+  {
+    for (Index j=0; j<lhs.outerSize(); ++j)
+    {
+      LhsIterator i(lhsEval,j);
+      // handle diagonal coeff
+      if (ProcessSecondHalf)
+      {
+        while (i && i.index()<j) ++i;
+        if(i && i.index()==j)
+        {
+          res(j,k) += alpha * i.value() * rhs(j,k);
+          ++i;
+        }
+      }
+
+      // premultiplied rhs for scatters
+      typename ScalarBinaryOpTraits<AlphaType, typename DenseRhsType::Scalar>::ReturnType rhs_j(alpha*rhs(j,k));
+      // accumulator for partial scalar product
+      typename DenseResType::Scalar res_j(0);
+      for(; (ProcessFirstHalf ? i && i.index() < j : i) ; ++i)
+      {
+        LhsScalar lhs_ij = i.value();
+        if(!LhsIsRowMajor) lhs_ij = numext::conj(lhs_ij);
+        res_j += lhs_ij * rhs(i.index(),k);
+        res(i.index(),k) += numext::conj(lhs_ij) * rhs_j;
+      }
+      res(j,k) += alpha * res_j;
+
+      // handle diagonal coeff
+      if (ProcessFirstHalf && i && (i.index()==j))
+        res(j,k) += alpha * i.value() * rhs(j,k);
+    }
+  }
+}
+
+
+template<typename LhsView, typename Rhs, int ProductType>
+struct generic_product_impl<LhsView, Rhs, SparseSelfAdjointShape, DenseShape, ProductType>
+: generic_product_impl_base<LhsView, Rhs, generic_product_impl<LhsView, Rhs, SparseSelfAdjointShape, DenseShape, ProductType> >
+{
+  template<typename Dest>
+  static void scaleAndAddTo(Dest& dst, const LhsView& lhsView, const Rhs& rhs, const typename Dest::Scalar& alpha)
+  {
+    typedef typename LhsView::_MatrixTypeNested Lhs;
+    typedef typename nested_eval<Lhs,Dynamic>::type LhsNested;
+    typedef typename nested_eval<Rhs,Dynamic>::type RhsNested;
+    LhsNested lhsNested(lhsView.matrix());
+    RhsNested rhsNested(rhs);
+    
+    internal::sparse_selfadjoint_time_dense_product<LhsView::Mode>(lhsNested, rhsNested, dst, alpha);
+  }
+};
+
+template<typename Lhs, typename RhsView, int ProductType>
+struct generic_product_impl<Lhs, RhsView, DenseShape, SparseSelfAdjointShape, ProductType>
+: generic_product_impl_base<Lhs, RhsView, generic_product_impl<Lhs, RhsView, DenseShape, SparseSelfAdjointShape, ProductType> >
+{
+  template<typename Dest>
+  static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const RhsView& rhsView, const typename Dest::Scalar& alpha)
+  {
+    typedef typename RhsView::_MatrixTypeNested Rhs;
+    typedef typename nested_eval<Lhs,Dynamic>::type LhsNested;
+    typedef typename nested_eval<Rhs,Dynamic>::type RhsNested;
+    LhsNested lhsNested(lhs);
+    RhsNested rhsNested(rhsView.matrix());
+    
+    // transpose everything
+    Transpose<Dest> dstT(dst);
+    internal::sparse_selfadjoint_time_dense_product<RhsView::TransposeMode>(rhsNested.transpose(), lhsNested.transpose(), dstT, alpha);
+  }
+};
+
+// NOTE: these two overloads are needed to evaluate the sparse selfadjoint view into a full sparse matrix
+// TODO: maybe the copy could be handled by generic_product_impl so that these overloads would not be needed anymore
+
+template<typename LhsView, typename Rhs, int ProductTag>
+struct product_evaluator<Product<LhsView, Rhs, DefaultProduct>, ProductTag, SparseSelfAdjointShape, SparseShape>
+  : public evaluator<typename Product<typename Rhs::PlainObject, Rhs, DefaultProduct>::PlainObject>
+{
+  typedef Product<LhsView, Rhs, DefaultProduct> XprType;
+  typedef typename XprType::PlainObject PlainObject;
+  typedef evaluator<PlainObject> Base;
+
+  product_evaluator(const XprType& xpr)
+    : m_lhs(xpr.lhs()), m_result(xpr.rows(), xpr.cols())
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+    generic_product_impl<typename Rhs::PlainObject, Rhs, SparseShape, SparseShape, ProductTag>::evalTo(m_result, m_lhs, xpr.rhs());
+  }
+  
+protected:
+  typename Rhs::PlainObject m_lhs;
+  PlainObject m_result;
+};
+
+template<typename Lhs, typename RhsView, int ProductTag>
+struct product_evaluator<Product<Lhs, RhsView, DefaultProduct>, ProductTag, SparseShape, SparseSelfAdjointShape>
+  : public evaluator<typename Product<Lhs, typename Lhs::PlainObject, DefaultProduct>::PlainObject>
+{
+  typedef Product<Lhs, RhsView, DefaultProduct> XprType;
+  typedef typename XprType::PlainObject PlainObject;
+  typedef evaluator<PlainObject> Base;
+
+  product_evaluator(const XprType& xpr)
+    : m_rhs(xpr.rhs()), m_result(xpr.rows(), xpr.cols())
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+    generic_product_impl<Lhs, typename Lhs::PlainObject, SparseShape, SparseShape, ProductTag>::evalTo(m_result, xpr.lhs(), m_rhs);
+  }
+  
+protected:
+  typename Lhs::PlainObject m_rhs;
+  PlainObject m_result;
+};
+
+} // namespace internal
+
+/***************************************************************************
+* Implementation of symmetric copies and permutations
+***************************************************************************/
+namespace internal {
+
+template<int Mode,typename MatrixType,int DestOrder>
+void permute_symm_to_fullsymm(const MatrixType& mat, SparseMatrix<typename MatrixType::Scalar,DestOrder,typename MatrixType::StorageIndex>& _dest, const typename MatrixType::StorageIndex* perm)
+{
+  typedef typename MatrixType::StorageIndex StorageIndex;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef SparseMatrix<Scalar,DestOrder,StorageIndex> Dest;
+  typedef Matrix<StorageIndex,Dynamic,1> VectorI;
+  typedef evaluator<MatrixType> MatEval;
+  typedef typename evaluator<MatrixType>::InnerIterator MatIterator;
+  
+  MatEval matEval(mat);
+  Dest& dest(_dest.derived());
+  enum {
+    StorageOrderMatch = int(Dest::IsRowMajor) == int(MatrixType::IsRowMajor)
+  };
+  
+  Index size = mat.rows();
+  VectorI count;
+  count.resize(size);
+  count.setZero();
+  dest.resize(size,size);
+  for(Index j = 0; j<size; ++j)
+  {
+    Index jp = perm ? perm[j] : j;
+    for(MatIterator it(matEval,j); it; ++it)
+    {
+      Index i = it.index();
+      Index r = it.row();
+      Index c = it.col();
+      Index ip = perm ? perm[i] : i;
+      if(Mode==(Upper|Lower))
+        count[StorageOrderMatch ? jp : ip]++;
+      else if(r==c)
+        count[ip]++;
+      else if(( Mode==Lower && r>c) || ( Mode==Upper && r<c))
+      {
+        count[ip]++;
+        count[jp]++;
+      }
+    }
+  }
+  Index nnz = count.sum();
+  
+  // reserve space
+  dest.resizeNonZeros(nnz);
+  dest.outerIndexPtr()[0] = 0;
+  for(Index j=0; j<size; ++j)
+    dest.outerIndexPtr()[j+1] = dest.outerIndexPtr()[j] + count[j];
+  for(Index j=0; j<size; ++j)
+    count[j] = dest.outerIndexPtr()[j];
+  
+  // copy data
+  for(StorageIndex j = 0; j<size; ++j)
+  {
+    for(MatIterator it(matEval,j); it; ++it)
+    {
+      StorageIndex i = internal::convert_index<StorageIndex>(it.index());
+      Index r = it.row();
+      Index c = it.col();
+      
+      StorageIndex jp = perm ? perm[j] : j;
+      StorageIndex ip = perm ? perm[i] : i;
+      
+      if(Mode==(Upper|Lower))
+      {
+        Index k = count[StorageOrderMatch ? jp : ip]++;
+        dest.innerIndexPtr()[k] = StorageOrderMatch ? ip : jp;
+        dest.valuePtr()[k] = it.value();
+      }
+      else if(r==c)
+      {
+        Index k = count[ip]++;
+        dest.innerIndexPtr()[k] = ip;
+        dest.valuePtr()[k] = it.value();
+      }
+      else if(( (Mode&Lower)==Lower && r>c) || ( (Mode&Upper)==Upper && r<c))
+      {
+        if(!StorageOrderMatch)
+          std::swap(ip,jp);
+        Index k = count[jp]++;
+        dest.innerIndexPtr()[k] = ip;
+        dest.valuePtr()[k] = it.value();
+        k = count[ip]++;
+        dest.innerIndexPtr()[k] = jp;
+        dest.valuePtr()[k] = numext::conj(it.value());
+      }
+    }
+  }
+}
+
+template<int _SrcMode,int _DstMode,typename MatrixType,int DstOrder>
+void permute_symm_to_symm(const MatrixType& mat, SparseMatrix<typename MatrixType::Scalar,DstOrder,typename MatrixType::StorageIndex>& _dest, const typename MatrixType::StorageIndex* perm)
+{
+  typedef typename MatrixType::StorageIndex StorageIndex;
+  typedef typename MatrixType::Scalar Scalar;
+  SparseMatrix<Scalar,DstOrder,StorageIndex>& dest(_dest.derived());
+  typedef Matrix<StorageIndex,Dynamic,1> VectorI;
+  typedef evaluator<MatrixType> MatEval;
+  typedef typename evaluator<MatrixType>::InnerIterator MatIterator;
+
+  enum {
+    SrcOrder = MatrixType::IsRowMajor ? RowMajor : ColMajor,
+    StorageOrderMatch = int(SrcOrder) == int(DstOrder),
+    DstMode = DstOrder==RowMajor ? (_DstMode==Upper ? Lower : Upper) : _DstMode,
+    SrcMode = SrcOrder==RowMajor ? (_SrcMode==Upper ? Lower : Upper) : _SrcMode
+  };
+
+  MatEval matEval(mat);
+  
+  Index size = mat.rows();
+  VectorI count(size);
+  count.setZero();
+  dest.resize(size,size);
+  for(StorageIndex j = 0; j<size; ++j)
+  {
+    StorageIndex jp = perm ? perm[j] : j;
+    for(MatIterator it(matEval,j); it; ++it)
+    {
+      StorageIndex i = it.index();
+      if((int(SrcMode)==int(Lower) && i<j) || (int(SrcMode)==int(Upper) && i>j))
+        continue;
+                  
+      StorageIndex ip = perm ? perm[i] : i;
+      count[int(DstMode)==int(Lower) ? (std::min)(ip,jp) : (std::max)(ip,jp)]++;
+    }
+  }
+  dest.outerIndexPtr()[0] = 0;
+  for(Index j=0; j<size; ++j)
+    dest.outerIndexPtr()[j+1] = dest.outerIndexPtr()[j] + count[j];
+  dest.resizeNonZeros(dest.outerIndexPtr()[size]);
+  for(Index j=0; j<size; ++j)
+    count[j] = dest.outerIndexPtr()[j];
+  
+  for(StorageIndex j = 0; j<size; ++j)
+  {
+    
+    for(MatIterator it(matEval,j); it; ++it)
+    {
+      StorageIndex i = it.index();
+      if((int(SrcMode)==int(Lower) && i<j) || (int(SrcMode)==int(Upper) && i>j))
+        continue;
+                  
+      StorageIndex jp = perm ? perm[j] : j;
+      StorageIndex ip = perm? perm[i] : i;
+      
+      Index k = count[int(DstMode)==int(Lower) ? (std::min)(ip,jp) : (std::max)(ip,jp)]++;
+      dest.innerIndexPtr()[k] = int(DstMode)==int(Lower) ? (std::max)(ip,jp) : (std::min)(ip,jp);
+      
+      if(!StorageOrderMatch) std::swap(ip,jp);
+      if( ((int(DstMode)==int(Lower) && ip<jp) || (int(DstMode)==int(Upper) && ip>jp)))
+        dest.valuePtr()[k] = numext::conj(it.value());
+      else
+        dest.valuePtr()[k] = it.value();
+    }
+  }
+}
+
+}
+
+// TODO implement twists in a more evaluator friendly fashion
+
+namespace internal {
+
+template<typename MatrixType, int Mode>
+struct traits<SparseSymmetricPermutationProduct<MatrixType,Mode> > : traits<MatrixType> {
+};
+
+}
+
+template<typename MatrixType,int Mode>
+class SparseSymmetricPermutationProduct
+  : public EigenBase<SparseSymmetricPermutationProduct<MatrixType,Mode> >
+{
+  public:
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    enum {
+      RowsAtCompileTime = internal::traits<SparseSymmetricPermutationProduct>::RowsAtCompileTime,
+      ColsAtCompileTime = internal::traits<SparseSymmetricPermutationProduct>::ColsAtCompileTime
+    };
+  protected:
+    typedef PermutationMatrix<Dynamic,Dynamic,StorageIndex> Perm;
+  public:
+    typedef Matrix<StorageIndex,Dynamic,1> VectorI;
+    typedef typename MatrixType::Nested MatrixTypeNested;
+    typedef typename internal::remove_all<MatrixTypeNested>::type NestedExpression;
+    
+    SparseSymmetricPermutationProduct(const MatrixType& mat, const Perm& perm)
+      : m_matrix(mat), m_perm(perm)
+    {}
+    
+    inline Index rows() const { return m_matrix.rows(); }
+    inline Index cols() const { return m_matrix.cols(); }
+        
+    const NestedExpression& matrix() const { return m_matrix; }
+    const Perm& perm() const { return m_perm; }
+    
+  protected:
+    MatrixTypeNested m_matrix;
+    const Perm& m_perm;
+
+};
+
+namespace internal {
+  
+template<typename DstXprType, typename MatrixType, int Mode, typename Scalar>
+struct Assignment<DstXprType, SparseSymmetricPermutationProduct<MatrixType,Mode>, internal::assign_op<Scalar,typename MatrixType::Scalar>, Sparse2Sparse>
+{
+  typedef SparseSymmetricPermutationProduct<MatrixType,Mode> SrcXprType;
+  typedef typename DstXprType::StorageIndex DstIndex;
+  template<int Options>
+  static void run(SparseMatrix<Scalar,Options,DstIndex> &dst, const SrcXprType &src, const internal::assign_op<Scalar,typename MatrixType::Scalar> &)
+  {
+    // internal::permute_symm_to_fullsymm<Mode>(m_matrix,_dest,m_perm.indices().data());
+    SparseMatrix<Scalar,(Options&RowMajor)==RowMajor ? ColMajor : RowMajor, DstIndex> tmp;
+    internal::permute_symm_to_fullsymm<Mode>(src.matrix(),tmp,src.perm().indices().data());
+    dst = tmp;
+  }
+  
+  template<typename DestType,unsigned int DestMode>
+  static void run(SparseSelfAdjointView<DestType,DestMode>& dst, const SrcXprType &src, const internal::assign_op<Scalar,typename MatrixType::Scalar> &)
+  {
+    internal::permute_symm_to_symm<Mode,DestMode>(src.matrix(),dst.matrix(),src.perm().indices().data());
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_SELFADJOINTVIEW_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseSolverBase.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseSolverBase.h
new file mode 100644
index 00000000..b4c9a422
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseSolverBase.h
@@ -0,0 +1,124 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSESOLVERBASE_H
+#define EIGEN_SPARSESOLVERBASE_H
+
+namespace Eigen { 
+
+namespace internal {
+
+  /** \internal
+  * Helper functions to solve with a sparse right-hand-side and result.
+  * The rhs is decomposed into small vertical panels which are solved through dense temporaries.
+  */
+template<typename Decomposition, typename Rhs, typename Dest>
+typename enable_if<Rhs::ColsAtCompileTime!=1 && Dest::ColsAtCompileTime!=1>::type
+solve_sparse_through_dense_panels(const Decomposition &dec, const Rhs& rhs, Dest &dest)
+{
+  EIGEN_STATIC_ASSERT((Dest::Flags&RowMajorBit)==0,THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
+  typedef typename Dest::Scalar DestScalar;
+  // we process the sparse rhs per block of NbColsAtOnce columns temporarily stored into a dense matrix.
+  static const Index NbColsAtOnce = 4;
+  Index rhsCols = rhs.cols();
+  Index size = rhs.rows();
+  // the temporary matrices do not need more columns than NbColsAtOnce:
+  Index tmpCols = (std::min)(rhsCols, NbColsAtOnce); 
+  Eigen::Matrix<DestScalar,Dynamic,Dynamic> tmp(size,tmpCols);
+  Eigen::Matrix<DestScalar,Dynamic,Dynamic> tmpX(size,tmpCols);
+  for(Index k=0; k<rhsCols; k+=NbColsAtOnce)
+  {
+    Index actualCols = std::min<Index>(rhsCols-k, NbColsAtOnce);
+    tmp.leftCols(actualCols) = rhs.middleCols(k,actualCols);
+    tmpX.leftCols(actualCols) = dec.solve(tmp.leftCols(actualCols));
+    dest.middleCols(k,actualCols) = tmpX.leftCols(actualCols).sparseView();
+  }
+}
+
+// Overload for vector as rhs
+template<typename Decomposition, typename Rhs, typename Dest>
+typename enable_if<Rhs::ColsAtCompileTime==1 || Dest::ColsAtCompileTime==1>::type
+solve_sparse_through_dense_panels(const Decomposition &dec, const Rhs& rhs, Dest &dest)
+{
+  typedef typename Dest::Scalar DestScalar;
+  Index size = rhs.rows();
+  Eigen::Matrix<DestScalar,Dynamic,1> rhs_dense(rhs);
+  Eigen::Matrix<DestScalar,Dynamic,1> dest_dense(size);
+  dest_dense = dec.solve(rhs_dense);
+  dest = dest_dense.sparseView();
+}
+
+} // end namespace internal
+
+/** \class SparseSolverBase
+  * \ingroup SparseCore_Module
+  * \brief A base class for sparse solvers
+  *
+  * \tparam Derived the actual type of the solver.
+  *
+  */
+template<typename Derived>
+class SparseSolverBase : internal::noncopyable
+{
+  public:
+
+    /** Default constructor */
+    SparseSolverBase()
+      : m_isInitialized(false)
+    {}
+
+    ~SparseSolverBase()
+    {}
+
+    Derived& derived() { return *static_cast<Derived*>(this); }
+    const Derived& derived() const { return *static_cast<const Derived*>(this); }
+    
+    /** \returns an expression of the solution x of \f$ A x = b \f$ using the current decomposition of A.
+      *
+      * \sa compute()
+      */
+    template<typename Rhs>
+    inline const Solve<Derived, Rhs>
+    solve(const MatrixBase<Rhs>& b) const
+    {
+      eigen_assert(m_isInitialized && "Solver is not initialized.");
+      eigen_assert(derived().rows()==b.rows() && "solve(): invalid number of rows of the right hand side matrix b");
+      return Solve<Derived, Rhs>(derived(), b.derived());
+    }
+    
+    /** \returns an expression of the solution x of \f$ A x = b \f$ using the current decomposition of A.
+      *
+      * \sa compute()
+      */
+    template<typename Rhs>
+    inline const Solve<Derived, Rhs>
+    solve(const SparseMatrixBase<Rhs>& b) const
+    {
+      eigen_assert(m_isInitialized && "Solver is not initialized.");
+      eigen_assert(derived().rows()==b.rows() && "solve(): invalid number of rows of the right hand side matrix b");
+      return Solve<Derived, Rhs>(derived(), b.derived());
+    }
+    
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** \internal default implementation of solving with a sparse rhs */
+    template<typename Rhs,typename Dest>
+    void _solve_impl(const SparseMatrixBase<Rhs> &b, SparseMatrixBase<Dest> &dest) const
+    {
+      internal::solve_sparse_through_dense_panels(derived(), b.derived(), dest.derived());
+    }
+    #endif // EIGEN_PARSED_BY_DOXYGEN
+
+  protected:
+    
+    mutable bool m_isInitialized;
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSESOLVERBASE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseSparseProductWithPruning.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseSparseProductWithPruning.h
new file mode 100644
index 00000000..88820a48
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseSparseProductWithPruning.h
@@ -0,0 +1,198 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSESPARSEPRODUCTWITHPRUNING_H
+#define EIGEN_SPARSESPARSEPRODUCTWITHPRUNING_H
+
+namespace Eigen { 
+
+namespace internal {
+
+
+// perform a pseudo in-place sparse * sparse product assuming all matrices are col major
+template<typename Lhs, typename Rhs, typename ResultType>
+static void sparse_sparse_product_with_pruning_impl(const Lhs& lhs, const Rhs& rhs, ResultType& res, const typename ResultType::RealScalar& tolerance)
+{
+  // return sparse_sparse_product_with_pruning_impl2(lhs,rhs,res);
+
+  typedef typename remove_all<Rhs>::type::Scalar RhsScalar;
+  typedef typename remove_all<ResultType>::type::Scalar ResScalar;
+  typedef typename remove_all<Lhs>::type::StorageIndex StorageIndex;
+
+  // make sure to call innerSize/outerSize since we fake the storage order.
+  Index rows = lhs.innerSize();
+  Index cols = rhs.outerSize();
+  //Index size = lhs.outerSize();
+  eigen_assert(lhs.outerSize() == rhs.innerSize());
+
+  // allocate a temporary buffer
+  AmbiVector<ResScalar,StorageIndex> tempVector(rows);
+
+  // mimics a resizeByInnerOuter:
+  if(ResultType::IsRowMajor)
+    res.resize(cols, rows);
+  else
+    res.resize(rows, cols);
+  
+  evaluator<Lhs> lhsEval(lhs);
+  evaluator<Rhs> rhsEval(rhs);
+  
+  // estimate the number of non zero entries
+  // given a rhs column containing Y non zeros, we assume that the respective Y columns
+  // of the lhs differs in average of one non zeros, thus the number of non zeros for
+  // the product of a rhs column with the lhs is X+Y where X is the average number of non zero
+  // per column of the lhs.
+  // Therefore, we have nnz(lhs*rhs) = nnz(lhs) + nnz(rhs)
+  Index estimated_nnz_prod = lhsEval.nonZerosEstimate() + rhsEval.nonZerosEstimate();
+
+  res.reserve(estimated_nnz_prod);
+  double ratioColRes = double(estimated_nnz_prod)/(double(lhs.rows())*double(rhs.cols()));
+  for (Index j=0; j<cols; ++j)
+  {
+    // FIXME:
+    //double ratioColRes = (double(rhs.innerVector(j).nonZeros()) + double(lhs.nonZeros())/double(lhs.cols()))/double(lhs.rows());
+    // let's do a more accurate determination of the nnz ratio for the current column j of res
+    tempVector.init(ratioColRes);
+    tempVector.setZero();
+    for (typename evaluator<Rhs>::InnerIterator rhsIt(rhsEval, j); rhsIt; ++rhsIt)
+    {
+      // FIXME should be written like this: tmp += rhsIt.value() * lhs.col(rhsIt.index())
+      tempVector.restart();
+      RhsScalar x = rhsIt.value();
+      for (typename evaluator<Lhs>::InnerIterator lhsIt(lhsEval, rhsIt.index()); lhsIt; ++lhsIt)
+      {
+        tempVector.coeffRef(lhsIt.index()) += lhsIt.value() * x;
+      }
+    }
+    res.startVec(j);
+    for (typename AmbiVector<ResScalar,StorageIndex>::Iterator it(tempVector,tolerance); it; ++it)
+      res.insertBackByOuterInner(j,it.index()) = it.value();
+  }
+  res.finalize();
+}
+
+template<typename Lhs, typename Rhs, typename ResultType,
+  int LhsStorageOrder = traits<Lhs>::Flags&RowMajorBit,
+  int RhsStorageOrder = traits<Rhs>::Flags&RowMajorBit,
+  int ResStorageOrder = traits<ResultType>::Flags&RowMajorBit>
+struct sparse_sparse_product_with_pruning_selector;
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,ColMajor,ColMajor,ColMajor>
+{
+  typedef typename ResultType::RealScalar RealScalar;
+
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
+  {
+    typename remove_all<ResultType>::type _res(res.rows(), res.cols());
+    internal::sparse_sparse_product_with_pruning_impl<Lhs,Rhs,ResultType>(lhs, rhs, _res, tolerance);
+    res.swap(_res);
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,ColMajor,ColMajor,RowMajor>
+{
+  typedef typename ResultType::RealScalar RealScalar;
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
+  {
+    // we need a col-major matrix to hold the result
+    typedef SparseMatrix<typename ResultType::Scalar,ColMajor,typename ResultType::StorageIndex> SparseTemporaryType;
+    SparseTemporaryType _res(res.rows(), res.cols());
+    internal::sparse_sparse_product_with_pruning_impl<Lhs,Rhs,SparseTemporaryType>(lhs, rhs, _res, tolerance);
+    res = _res;
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,RowMajor,RowMajor,RowMajor>
+{
+  typedef typename ResultType::RealScalar RealScalar;
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
+  {
+    // let's transpose the product to get a column x column product
+    typename remove_all<ResultType>::type _res(res.rows(), res.cols());
+    internal::sparse_sparse_product_with_pruning_impl<Rhs,Lhs,ResultType>(rhs, lhs, _res, tolerance);
+    res.swap(_res);
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,RowMajor,RowMajor,ColMajor>
+{
+  typedef typename ResultType::RealScalar RealScalar;
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
+  {
+    typedef SparseMatrix<typename Lhs::Scalar,ColMajor,typename Lhs::StorageIndex> ColMajorMatrixLhs;
+    typedef SparseMatrix<typename Rhs::Scalar,ColMajor,typename Lhs::StorageIndex> ColMajorMatrixRhs;
+    ColMajorMatrixLhs colLhs(lhs);
+    ColMajorMatrixRhs colRhs(rhs);
+    internal::sparse_sparse_product_with_pruning_impl<ColMajorMatrixLhs,ColMajorMatrixRhs,ResultType>(colLhs, colRhs, res, tolerance);
+
+    // let's transpose the product to get a column x column product
+//     typedef SparseMatrix<typename ResultType::Scalar> SparseTemporaryType;
+//     SparseTemporaryType _res(res.cols(), res.rows());
+//     sparse_sparse_product_with_pruning_impl<Rhs,Lhs,SparseTemporaryType>(rhs, lhs, _res);
+//     res = _res.transpose();
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,ColMajor,RowMajor,RowMajor>
+{
+  typedef typename ResultType::RealScalar RealScalar;
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
+  {
+    typedef SparseMatrix<typename Lhs::Scalar,RowMajor,typename Lhs::StorageIndex> RowMajorMatrixLhs;
+    RowMajorMatrixLhs rowLhs(lhs);
+    sparse_sparse_product_with_pruning_selector<RowMajorMatrixLhs,Rhs,ResultType,RowMajor,RowMajor>(rowLhs,rhs,res,tolerance);
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,RowMajor,ColMajor,RowMajor>
+{
+  typedef typename ResultType::RealScalar RealScalar;
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
+  {
+    typedef SparseMatrix<typename Rhs::Scalar,RowMajor,typename Lhs::StorageIndex> RowMajorMatrixRhs;
+    RowMajorMatrixRhs rowRhs(rhs);
+    sparse_sparse_product_with_pruning_selector<Lhs,RowMajorMatrixRhs,ResultType,RowMajor,RowMajor,RowMajor>(lhs,rowRhs,res,tolerance);
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,ColMajor,RowMajor,ColMajor>
+{
+  typedef typename ResultType::RealScalar RealScalar;
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
+  {
+    typedef SparseMatrix<typename Rhs::Scalar,ColMajor,typename Lhs::StorageIndex> ColMajorMatrixRhs;
+    ColMajorMatrixRhs colRhs(rhs);
+    internal::sparse_sparse_product_with_pruning_impl<Lhs,ColMajorMatrixRhs,ResultType>(lhs, colRhs, res, tolerance);
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,RowMajor,ColMajor,ColMajor>
+{
+  typedef typename ResultType::RealScalar RealScalar;
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
+  {
+    typedef SparseMatrix<typename Lhs::Scalar,ColMajor,typename Lhs::StorageIndex> ColMajorMatrixLhs;
+    ColMajorMatrixLhs colLhs(lhs);
+    internal::sparse_sparse_product_with_pruning_impl<ColMajorMatrixLhs,Rhs,ResultType>(colLhs, rhs, res, tolerance);
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSESPARSEPRODUCTWITHPRUNING_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseTranspose.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseTranspose.h
new file mode 100644
index 00000000..3757d4c6
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseTranspose.h
@@ -0,0 +1,92 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSETRANSPOSE_H
+#define EIGEN_SPARSETRANSPOSE_H
+
+namespace Eigen { 
+
+namespace internal {
+  template<typename MatrixType,int CompressedAccess=int(MatrixType::Flags&CompressedAccessBit)>
+  class SparseTransposeImpl
+    : public SparseMatrixBase<Transpose<MatrixType> >
+  {};
+  
+  template<typename MatrixType>
+  class SparseTransposeImpl<MatrixType,CompressedAccessBit>
+    : public SparseCompressedBase<Transpose<MatrixType> >
+  {
+    typedef SparseCompressedBase<Transpose<MatrixType> > Base;
+  public:
+    using Base::derived;
+    typedef typename Base::Scalar Scalar;
+    typedef typename Base::StorageIndex StorageIndex;
+
+    inline Index nonZeros() const { return derived().nestedExpression().nonZeros(); }
+    
+    inline const Scalar* valuePtr() const { return derived().nestedExpression().valuePtr(); }
+    inline const StorageIndex* innerIndexPtr() const { return derived().nestedExpression().innerIndexPtr(); }
+    inline const StorageIndex* outerIndexPtr() const { return derived().nestedExpression().outerIndexPtr(); }
+    inline const StorageIndex* innerNonZeroPtr() const { return derived().nestedExpression().innerNonZeroPtr(); }
+
+    inline Scalar* valuePtr() { return derived().nestedExpression().valuePtr(); }
+    inline StorageIndex* innerIndexPtr() { return derived().nestedExpression().innerIndexPtr(); }
+    inline StorageIndex* outerIndexPtr() { return derived().nestedExpression().outerIndexPtr(); }
+    inline StorageIndex* innerNonZeroPtr() { return derived().nestedExpression().innerNonZeroPtr(); }
+  };
+}
+  
+template<typename MatrixType> class TransposeImpl<MatrixType,Sparse>
+  : public internal::SparseTransposeImpl<MatrixType>
+{
+  protected:
+    typedef internal::SparseTransposeImpl<MatrixType> Base;
+};
+
+namespace internal {
+  
+template<typename ArgType>
+struct unary_evaluator<Transpose<ArgType>, IteratorBased>
+  : public evaluator_base<Transpose<ArgType> >
+{
+    typedef typename evaluator<ArgType>::InnerIterator        EvalIterator;
+  public:
+    typedef Transpose<ArgType> XprType;
+    
+    inline Index nonZerosEstimate() const {
+      return m_argImpl.nonZerosEstimate();
+    }
+
+    class InnerIterator : public EvalIterator
+    {
+    public:
+      EIGEN_STRONG_INLINE InnerIterator(const unary_evaluator& unaryOp, Index outer)
+        : EvalIterator(unaryOp.m_argImpl,outer)
+      {}
+      
+      Index row() const { return EvalIterator::col(); }
+      Index col() const { return EvalIterator::row(); }
+    };
+    
+    enum {
+      CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+      Flags = XprType::Flags
+    };
+    
+    explicit unary_evaluator(const XprType& op) :m_argImpl(op.nestedExpression()) {}
+
+  protected:
+    evaluator<ArgType> m_argImpl;
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSETRANSPOSE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseTriangularView.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseTriangularView.h
new file mode 100644
index 00000000..9ac12026
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseTriangularView.h
@@ -0,0 +1,189 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_TRIANGULARVIEW_H
+#define EIGEN_SPARSE_TRIANGULARVIEW_H
+
+namespace Eigen {
+
+/** \ingroup SparseCore_Module
+  *
+  * \brief Base class for a triangular part in a \b sparse matrix
+  *
+  * This class is an abstract base class of class TriangularView, and objects of type TriangularViewImpl cannot be instantiated.
+  * It extends class TriangularView with additional methods which are available for sparse expressions only.
+  *
+  * \sa class TriangularView, SparseMatrixBase::triangularView()
+  */
+template<typename MatrixType, unsigned int Mode> class TriangularViewImpl<MatrixType,Mode,Sparse>
+  : public SparseMatrixBase<TriangularView<MatrixType,Mode> >
+{
+    enum { SkipFirst = ((Mode&Lower) && !(MatrixType::Flags&RowMajorBit))
+                    || ((Mode&Upper) &&  (MatrixType::Flags&RowMajorBit)),
+           SkipLast = !SkipFirst,
+           SkipDiag = (Mode&ZeroDiag) ? 1 : 0,
+           HasUnitDiag = (Mode&UnitDiag) ? 1 : 0
+    };
+    
+    typedef TriangularView<MatrixType,Mode> TriangularViewType;
+    
+  protected:
+    // dummy solve function to make TriangularView happy.
+    void solve() const;
+
+    typedef SparseMatrixBase<TriangularViewType> Base;
+  public:
+    
+    EIGEN_SPARSE_PUBLIC_INTERFACE(TriangularViewType)
+    
+    typedef typename MatrixType::Nested MatrixTypeNested;
+    typedef typename internal::remove_reference<MatrixTypeNested>::type MatrixTypeNestedNonRef;
+    typedef typename internal::remove_all<MatrixTypeNested>::type MatrixTypeNestedCleaned;
+
+    template<typename RhsType, typename DstType>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _solve_impl(const RhsType &rhs, DstType &dst) const {
+      if(!(internal::is_same<RhsType,DstType>::value && internal::extract_data(dst) == internal::extract_data(rhs)))
+        dst = rhs;
+      this->solveInPlace(dst);
+    }
+
+    /** Applies the inverse of \c *this to the dense vector or matrix \a other, "in-place" */
+    template<typename OtherDerived> void solveInPlace(MatrixBase<OtherDerived>& other) const;
+
+    /** Applies the inverse of \c *this to the sparse vector or matrix \a other, "in-place" */
+    template<typename OtherDerived> void solveInPlace(SparseMatrixBase<OtherDerived>& other) const;
+  
+};
+
+namespace internal {
+
+template<typename ArgType, unsigned int Mode>
+struct unary_evaluator<TriangularView<ArgType,Mode>, IteratorBased>
+ : evaluator_base<TriangularView<ArgType,Mode> >
+{
+  typedef TriangularView<ArgType,Mode> XprType;
+  
+protected:
+  
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::StorageIndex StorageIndex;
+  typedef typename evaluator<ArgType>::InnerIterator EvalIterator;
+  
+  enum { SkipFirst = ((Mode&Lower) && !(ArgType::Flags&RowMajorBit))
+                    || ((Mode&Upper) &&  (ArgType::Flags&RowMajorBit)),
+         SkipLast = !SkipFirst,
+         SkipDiag = (Mode&ZeroDiag) ? 1 : 0,
+         HasUnitDiag = (Mode&UnitDiag) ? 1 : 0
+  };
+  
+public:
+  
+  enum {
+    CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+    Flags = XprType::Flags
+  };
+    
+  explicit unary_evaluator(const XprType &xpr) : m_argImpl(xpr.nestedExpression()), m_arg(xpr.nestedExpression()) {}
+  
+  inline Index nonZerosEstimate() const {
+    return m_argImpl.nonZerosEstimate();
+  }
+  
+  class InnerIterator : public EvalIterator
+  {
+      typedef EvalIterator Base;
+    public:
+
+      EIGEN_STRONG_INLINE InnerIterator(const unary_evaluator& xprEval, Index outer)
+        : Base(xprEval.m_argImpl,outer), m_returnOne(false), m_containsDiag(Base::outer()<xprEval.m_arg.innerSize())
+      {
+        if(SkipFirst)
+        {
+          while((*this) && ((HasUnitDiag||SkipDiag)  ? this->index()<=outer : this->index()<outer))
+            Base::operator++();
+          if(HasUnitDiag)
+            m_returnOne = m_containsDiag;
+        }
+        else if(HasUnitDiag && ((!Base::operator bool()) || Base::index()>=Base::outer()))
+        {
+          if((!SkipFirst) && Base::operator bool())
+            Base::operator++();
+          m_returnOne = m_containsDiag;
+        }
+      }
+
+      EIGEN_STRONG_INLINE InnerIterator& operator++()
+      {
+        if(HasUnitDiag && m_returnOne)
+          m_returnOne = false;
+        else
+        {
+          Base::operator++();
+          if(HasUnitDiag && (!SkipFirst) && ((!Base::operator bool()) || Base::index()>=Base::outer()))
+          {
+            if((!SkipFirst) && Base::operator bool())
+              Base::operator++();
+            m_returnOne = m_containsDiag;
+          }
+        }
+        return *this;
+      }
+      
+      EIGEN_STRONG_INLINE operator bool() const
+      {
+        if(HasUnitDiag && m_returnOne)
+          return true;
+        if(SkipFirst) return  Base::operator bool();
+        else
+        {
+          if (SkipDiag) return (Base::operator bool() && this->index() < this->outer());
+          else return (Base::operator bool() && this->index() <= this->outer());
+        }
+      }
+
+//       inline Index row() const { return (ArgType::Flags&RowMajorBit ? Base::outer() : this->index()); }
+//       inline Index col() const { return (ArgType::Flags&RowMajorBit ? this->index() : Base::outer()); }
+      inline StorageIndex index() const
+      {
+        if(HasUnitDiag && m_returnOne)  return internal::convert_index<StorageIndex>(Base::outer());
+        else                            return Base::index();
+      }
+      inline Scalar value() const
+      {
+        if(HasUnitDiag && m_returnOne)  return Scalar(1);
+        else                            return Base::value();
+      }
+
+    protected:
+      bool m_returnOne;
+      bool m_containsDiag;
+    private:
+      Scalar& valueRef();
+  };
+  
+protected:
+  evaluator<ArgType> m_argImpl;
+  const ArgType& m_arg;
+};
+
+} // end namespace internal
+
+template<typename Derived>
+template<int Mode>
+inline const TriangularView<const Derived, Mode>
+SparseMatrixBase<Derived>::triangularView() const
+{
+  return TriangularView<const Derived, Mode>(derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_TRIANGULARVIEW_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseUtil.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseUtil.h
new file mode 100644
index 00000000..74df0d49
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseUtil.h
@@ -0,0 +1,178 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSEUTIL_H
+#define EIGEN_SPARSEUTIL_H
+
+namespace Eigen { 
+
+#ifdef NDEBUG
+#define EIGEN_DBG_SPARSE(X)
+#else
+#define EIGEN_DBG_SPARSE(X) X
+#endif
+
+#define EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(Derived, Op) \
+template<typename OtherDerived> \
+EIGEN_STRONG_INLINE Derived& operator Op(const Eigen::SparseMatrixBase<OtherDerived>& other) \
+{ \
+  return Base::operator Op(other.derived()); \
+} \
+EIGEN_STRONG_INLINE Derived& operator Op(const Derived& other) \
+{ \
+  return Base::operator Op(other); \
+}
+
+#define EIGEN_SPARSE_INHERIT_SCALAR_ASSIGNMENT_OPERATOR(Derived, Op) \
+template<typename Other> \
+EIGEN_STRONG_INLINE Derived& operator Op(const Other& scalar) \
+{ \
+  return Base::operator Op(scalar); \
+}
+
+#define EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATORS(Derived) \
+EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(Derived, =)
+
+
+#define EIGEN_SPARSE_PUBLIC_INTERFACE(Derived) \
+  EIGEN_GENERIC_PUBLIC_INTERFACE(Derived)
+
+  
+const int CoherentAccessPattern     = 0x1;
+const int InnerRandomAccessPattern  = 0x2 | CoherentAccessPattern;
+const int OuterRandomAccessPattern  = 0x4 | CoherentAccessPattern;
+const int RandomAccessPattern       = 0x8 | OuterRandomAccessPattern | InnerRandomAccessPattern;
+
+template<typename _Scalar, int _Flags = 0, typename _StorageIndex = int>  class SparseMatrix;
+template<typename _Scalar, int _Flags = 0, typename _StorageIndex = int>  class DynamicSparseMatrix;
+template<typename _Scalar, int _Flags = 0, typename _StorageIndex = int>  class SparseVector;
+template<typename _Scalar, int _Flags = 0, typename _StorageIndex = int>  class MappedSparseMatrix;
+
+template<typename MatrixType, unsigned int UpLo>  class SparseSelfAdjointView;
+template<typename Lhs, typename Rhs>              class SparseDiagonalProduct;
+template<typename MatrixType> class SparseView;
+
+template<typename Lhs, typename Rhs>        class SparseSparseProduct;
+template<typename Lhs, typename Rhs>        class SparseTimeDenseProduct;
+template<typename Lhs, typename Rhs>        class DenseTimeSparseProduct;
+template<typename Lhs, typename Rhs, bool Transpose> class SparseDenseOuterProduct;
+
+template<typename Lhs, typename Rhs> struct SparseSparseProductReturnType;
+template<typename Lhs, typename Rhs,
+         int InnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(internal::traits<Lhs>::ColsAtCompileTime,internal::traits<Rhs>::RowsAtCompileTime)> struct DenseSparseProductReturnType;
+         
+template<typename Lhs, typename Rhs,
+         int InnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(internal::traits<Lhs>::ColsAtCompileTime,internal::traits<Rhs>::RowsAtCompileTime)> struct SparseDenseProductReturnType;
+template<typename MatrixType,int UpLo> class SparseSymmetricPermutationProduct;
+
+namespace internal {
+
+template<typename T,int Rows,int Cols,int Flags> struct sparse_eval;
+
+template<typename T> struct eval<T,Sparse>
+  : sparse_eval<T, traits<T>::RowsAtCompileTime,traits<T>::ColsAtCompileTime,traits<T>::Flags>
+{};
+
+template<typename T,int Cols,int Flags> struct sparse_eval<T,1,Cols,Flags> {
+    typedef typename traits<T>::Scalar _Scalar;
+    typedef typename traits<T>::StorageIndex _StorageIndex;
+  public:
+    typedef SparseVector<_Scalar, RowMajor, _StorageIndex> type;
+};
+
+template<typename T,int Rows,int Flags> struct sparse_eval<T,Rows,1,Flags> {
+    typedef typename traits<T>::Scalar _Scalar;
+    typedef typename traits<T>::StorageIndex _StorageIndex;
+  public:
+    typedef SparseVector<_Scalar, ColMajor, _StorageIndex> type;
+};
+
+// TODO this seems almost identical to plain_matrix_type<T, Sparse>
+template<typename T,int Rows,int Cols,int Flags> struct sparse_eval {
+    typedef typename traits<T>::Scalar _Scalar;
+    typedef typename traits<T>::StorageIndex _StorageIndex;
+    enum { _Options = ((Flags&RowMajorBit)==RowMajorBit) ? RowMajor : ColMajor };
+  public:
+    typedef SparseMatrix<_Scalar, _Options, _StorageIndex> type;
+};
+
+template<typename T,int Flags> struct sparse_eval<T,1,1,Flags> {
+    typedef typename traits<T>::Scalar _Scalar;
+  public:
+    typedef Matrix<_Scalar, 1, 1> type;
+};
+
+template<typename T> struct plain_matrix_type<T,Sparse>
+{
+  typedef typename traits<T>::Scalar _Scalar;
+  typedef typename traits<T>::StorageIndex _StorageIndex;
+  enum { _Options = ((evaluator<T>::Flags&RowMajorBit)==RowMajorBit) ? RowMajor : ColMajor };
+  public:
+    typedef SparseMatrix<_Scalar, _Options, _StorageIndex> type;
+};
+
+template<typename T>
+struct plain_object_eval<T,Sparse>
+  : sparse_eval<T, traits<T>::RowsAtCompileTime,traits<T>::ColsAtCompileTime, evaluator<T>::Flags>
+{};
+
+template<typename Decomposition, typename RhsType>
+struct solve_traits<Decomposition,RhsType,Sparse>
+{
+  typedef typename sparse_eval<RhsType, RhsType::RowsAtCompileTime, RhsType::ColsAtCompileTime,traits<RhsType>::Flags>::type PlainObject;
+};
+
+template<typename Derived>
+struct generic_xpr_base<Derived, MatrixXpr, Sparse>
+{
+  typedef SparseMatrixBase<Derived> type;
+};
+
+struct SparseTriangularShape  { static std::string debugName() { return "SparseTriangularShape"; } };
+struct SparseSelfAdjointShape { static std::string debugName() { return "SparseSelfAdjointShape"; } };
+
+template<> struct glue_shapes<SparseShape,SelfAdjointShape> { typedef SparseSelfAdjointShape type;  };
+template<> struct glue_shapes<SparseShape,TriangularShape > { typedef SparseTriangularShape  type;  };
+
+} // end namespace internal
+
+/** \ingroup SparseCore_Module
+  *
+  * \class Triplet
+  *
+  * \brief A small structure to hold a non zero as a triplet (i,j,value).
+  *
+  * \sa SparseMatrix::setFromTriplets()
+  */
+template<typename Scalar, typename StorageIndex=typename SparseMatrix<Scalar>::StorageIndex >
+class Triplet
+{
+public:
+  Triplet() : m_row(0), m_col(0), m_value(0) {}
+
+  Triplet(const StorageIndex& i, const StorageIndex& j, const Scalar& v = Scalar(0))
+    : m_row(i), m_col(j), m_value(v)
+  {}
+
+  /** \returns the row index of the element */
+  const StorageIndex& row() const { return m_row; }
+
+  /** \returns the column index of the element */
+  const StorageIndex& col() const { return m_col; }
+
+  /** \returns the value of the element */
+  const Scalar& value() const { return m_value; }
+protected:
+  StorageIndex m_row, m_col;
+  Scalar m_value;
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSEUTIL_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseVector.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseVector.h
new file mode 100644
index 00000000..19b0fbc9
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseVector.h
@@ -0,0 +1,478 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSEVECTOR_H
+#define EIGEN_SPARSEVECTOR_H
+
+namespace Eigen { 
+
+/** \ingroup SparseCore_Module
+  * \class SparseVector
+  *
+  * \brief a sparse vector class
+  *
+  * \tparam _Scalar the scalar type, i.e. the type of the coefficients
+  *
+  * See http://www.netlib.org/linalg/html_templates/node91.html for details on the storage scheme.
+  *
+  * This class can be extended with the help of the plugin mechanism described on the page
+  * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_SPARSEVECTOR_PLUGIN.
+  */
+
+namespace internal {
+template<typename _Scalar, int _Options, typename _StorageIndex>
+struct traits<SparseVector<_Scalar, _Options, _StorageIndex> >
+{
+  typedef _Scalar Scalar;
+  typedef _StorageIndex StorageIndex;
+  typedef Sparse StorageKind;
+  typedef MatrixXpr XprKind;
+  enum {
+    IsColVector = (_Options & RowMajorBit) ? 0 : 1,
+
+    RowsAtCompileTime = IsColVector ? Dynamic : 1,
+    ColsAtCompileTime = IsColVector ? 1 : Dynamic,
+    MaxRowsAtCompileTime = RowsAtCompileTime,
+    MaxColsAtCompileTime = ColsAtCompileTime,
+    Flags = _Options | NestByRefBit | LvalueBit | (IsColVector ? 0 : RowMajorBit) | CompressedAccessBit,
+    SupportedAccessPatterns = InnerRandomAccessPattern
+  };
+};
+
+// Sparse-Vector-Assignment kinds:
+enum {
+  SVA_RuntimeSwitch,
+  SVA_Inner,
+  SVA_Outer
+};
+
+template< typename Dest, typename Src,
+          int AssignmentKind = !bool(Src::IsVectorAtCompileTime) ? SVA_RuntimeSwitch
+                             : Src::InnerSizeAtCompileTime==1 ? SVA_Outer
+                             : SVA_Inner>
+struct sparse_vector_assign_selector;
+
+}
+
+template<typename _Scalar, int _Options, typename _StorageIndex>
+class SparseVector
+  : public SparseCompressedBase<SparseVector<_Scalar, _Options, _StorageIndex> >
+{
+    typedef SparseCompressedBase<SparseVector> Base;
+    using Base::convert_index;
+  public:
+    EIGEN_SPARSE_PUBLIC_INTERFACE(SparseVector)
+    EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(SparseVector, +=)
+    EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(SparseVector, -=)
+    
+    typedef internal::CompressedStorage<Scalar,StorageIndex> Storage;
+    enum { IsColVector = internal::traits<SparseVector>::IsColVector };
+    
+    enum {
+      Options = _Options
+    };
+    
+    EIGEN_STRONG_INLINE Index rows() const { return IsColVector ? m_size : 1; }
+    EIGEN_STRONG_INLINE Index cols() const { return IsColVector ? 1 : m_size; }
+    EIGEN_STRONG_INLINE Index innerSize() const { return m_size; }
+    EIGEN_STRONG_INLINE Index outerSize() const { return 1; }
+
+    EIGEN_STRONG_INLINE const Scalar* valuePtr() const { return m_data.valuePtr(); }
+    EIGEN_STRONG_INLINE Scalar* valuePtr() { return m_data.valuePtr(); }
+
+    EIGEN_STRONG_INLINE const StorageIndex* innerIndexPtr() const { return m_data.indexPtr(); }
+    EIGEN_STRONG_INLINE StorageIndex* innerIndexPtr() { return m_data.indexPtr(); }
+
+    inline const StorageIndex* outerIndexPtr() const { return 0; }
+    inline StorageIndex* outerIndexPtr() { return 0; }
+    inline const StorageIndex* innerNonZeroPtr() const { return 0; }
+    inline StorageIndex* innerNonZeroPtr() { return 0; }
+    
+    /** \internal */
+    inline Storage& data() { return m_data; }
+    /** \internal */
+    inline const Storage& data() const { return m_data; }
+
+    inline Scalar coeff(Index row, Index col) const
+    {
+      eigen_assert(IsColVector ? (col==0 && row>=0 && row<m_size) : (row==0 && col>=0 && col<m_size));
+      return coeff(IsColVector ? row : col);
+    }
+    inline Scalar coeff(Index i) const
+    {
+      eigen_assert(i>=0 && i<m_size);
+      return m_data.at(StorageIndex(i));
+    }
+
+    inline Scalar& coeffRef(Index row, Index col)
+    {
+      eigen_assert(IsColVector ? (col==0 && row>=0 && row<m_size) : (row==0 && col>=0 && col<m_size));
+      return coeffRef(IsColVector ? row : col);
+    }
+
+    /** \returns a reference to the coefficient value at given index \a i
+      * This operation involes a log(rho*size) binary search. If the coefficient does not
+      * exist yet, then a sorted insertion into a sequential buffer is performed.
+      *
+      * This insertion might be very costly if the number of nonzeros above \a i is large.
+      */
+    inline Scalar& coeffRef(Index i)
+    {
+      eigen_assert(i>=0 && i<m_size);
+
+      return m_data.atWithInsertion(StorageIndex(i));
+    }
+
+  public:
+
+    typedef typename Base::InnerIterator InnerIterator;
+    typedef typename Base::ReverseInnerIterator ReverseInnerIterator;
+
+    inline void setZero() { m_data.clear(); }
+
+    /** \returns the number of non zero coefficients */
+    inline Index nonZeros() const  { return m_data.size(); }
+
+    inline void startVec(Index outer)
+    {
+      EIGEN_UNUSED_VARIABLE(outer);
+      eigen_assert(outer==0);
+    }
+
+    inline Scalar& insertBackByOuterInner(Index outer, Index inner)
+    {
+      EIGEN_UNUSED_VARIABLE(outer);
+      eigen_assert(outer==0);
+      return insertBack(inner);
+    }
+    inline Scalar& insertBack(Index i)
+    {
+      m_data.append(0, i);
+      return m_data.value(m_data.size()-1);
+    }
+    
+    Scalar& insertBackByOuterInnerUnordered(Index outer, Index inner)
+    {
+      EIGEN_UNUSED_VARIABLE(outer);
+      eigen_assert(outer==0);
+      return insertBackUnordered(inner);
+    }
+    inline Scalar& insertBackUnordered(Index i)
+    {
+      m_data.append(0, i);
+      return m_data.value(m_data.size()-1);
+    }
+
+    inline Scalar& insert(Index row, Index col)
+    {
+      eigen_assert(IsColVector ? (col==0 && row>=0 && row<m_size) : (row==0 && col>=0 && col<m_size));
+      
+      Index inner = IsColVector ? row : col;
+      Index outer = IsColVector ? col : row;
+      EIGEN_ONLY_USED_FOR_DEBUG(outer);
+      eigen_assert(outer==0);
+      return insert(inner);
+    }
+    Scalar& insert(Index i)
+    {
+      eigen_assert(i>=0 && i<m_size);
+      
+      Index startId = 0;
+      Index p = Index(m_data.size()) - 1;
+      // TODO smart realloc
+      m_data.resize(p+2,1);
+
+      while ( (p >= startId) && (m_data.index(p) > i) )
+      {
+        m_data.index(p+1) = m_data.index(p);
+        m_data.value(p+1) = m_data.value(p);
+        --p;
+      }
+      m_data.index(p+1) = convert_index(i);
+      m_data.value(p+1) = 0;
+      return m_data.value(p+1);
+    }
+
+    /**
+      */
+    inline void reserve(Index reserveSize) { m_data.reserve(reserveSize); }
+
+
+    inline void finalize() {}
+
+    /** \copydoc SparseMatrix::prune(const Scalar&,const RealScalar&) */
+    void prune(const Scalar& reference, const RealScalar& epsilon = NumTraits<RealScalar>::dummy_precision())
+    {
+      m_data.prune(reference,epsilon);
+    }
+
+    /** Resizes the sparse vector to \a rows x \a cols
+      *
+      * This method is provided for compatibility with matrices.
+      * For a column vector, \a cols must be equal to 1.
+      * For a row vector, \a rows must be equal to 1.
+      *
+      * \sa resize(Index)
+      */
+    void resize(Index rows, Index cols)
+    {
+      eigen_assert((IsColVector ? cols : rows)==1 && "Outer dimension must equal 1");
+      resize(IsColVector ? rows : cols);
+    }
+
+    /** Resizes the sparse vector to \a newSize
+      * This method deletes all entries, thus leaving an empty sparse vector
+      *
+      * \sa  conservativeResize(), setZero() */
+    void resize(Index newSize)
+    {
+      m_size = newSize;
+      m_data.clear();
+    }
+
+    /** Resizes the sparse vector to \a newSize, while leaving old values untouched.
+      *
+      * If the size of the vector is decreased, then the storage of the out-of bounds coefficients is kept and reserved.
+      * Call .data().squeeze() to free extra memory.
+      *
+      * \sa reserve(), setZero()
+      */
+    void conservativeResize(Index newSize)
+    {
+      if (newSize < m_size)
+      {
+        Index i = 0;
+        while (i<m_data.size() && m_data.index(i)<newSize) ++i;
+        m_data.resize(i);
+      }
+      m_size = newSize;
+    }
+
+    void resizeNonZeros(Index size) { m_data.resize(size); }
+
+    inline SparseVector() : m_size(0) { check_template_parameters(); resize(0); }
+
+    explicit inline SparseVector(Index size) : m_size(0) { check_template_parameters(); resize(size); }
+
+    inline SparseVector(Index rows, Index cols) : m_size(0) { check_template_parameters(); resize(rows,cols); }
+
+    template<typename OtherDerived>
+    inline SparseVector(const SparseMatrixBase<OtherDerived>& other)
+      : m_size(0)
+    {
+      #ifdef EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
+        EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
+      #endif
+      check_template_parameters();
+      *this = other.derived();
+    }
+
+    inline SparseVector(const SparseVector& other)
+      : Base(other), m_size(0)
+    {
+      check_template_parameters();
+      *this = other.derived();
+    }
+
+    /** Swaps the values of \c *this and \a other.
+      * Overloaded for performance: this version performs a \em shallow swap by swaping pointers and attributes only.
+      * \sa SparseMatrixBase::swap()
+      */
+    inline void swap(SparseVector& other)
+    {
+      std::swap(m_size, other.m_size);
+      m_data.swap(other.m_data);
+    }
+
+    template<int OtherOptions>
+    inline void swap(SparseMatrix<Scalar,OtherOptions,StorageIndex>& other)
+    {
+      eigen_assert(other.outerSize()==1);
+      std::swap(m_size, other.m_innerSize);
+      m_data.swap(other.m_data);
+    }
+
+    inline SparseVector& operator=(const SparseVector& other)
+    {
+      if (other.isRValue())
+      {
+        swap(other.const_cast_derived());
+      }
+      else
+      {
+        resize(other.size());
+        m_data = other.m_data;
+      }
+      return *this;
+    }
+
+    template<typename OtherDerived>
+    inline SparseVector& operator=(const SparseMatrixBase<OtherDerived>& other)
+    {
+      SparseVector tmp(other.size());
+      internal::sparse_vector_assign_selector<SparseVector,OtherDerived>::run(tmp,other.derived());
+      this->swap(tmp);
+      return *this;
+    }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename Lhs, typename Rhs>
+    inline SparseVector& operator=(const SparseSparseProduct<Lhs,Rhs>& product)
+    {
+      return Base::operator=(product);
+    }
+    #endif
+
+    friend std::ostream & operator << (std::ostream & s, const SparseVector& m)
+    {
+      for (Index i=0; i<m.nonZeros(); ++i)
+        s << "(" << m.m_data.value(i) << "," << m.m_data.index(i) << ") ";
+      s << std::endl;
+      return s;
+    }
+
+    /** Destructor */
+    inline ~SparseVector() {}
+
+    /** Overloaded for performance */
+    Scalar sum() const;
+
+  public:
+
+    /** \internal \deprecated use setZero() and reserve() */
+    EIGEN_DEPRECATED void startFill(Index reserve)
+    {
+      setZero();
+      m_data.reserve(reserve);
+    }
+
+    /** \internal \deprecated use insertBack(Index,Index) */
+    EIGEN_DEPRECATED Scalar& fill(Index r, Index c)
+    {
+      eigen_assert(r==0 || c==0);
+      return fill(IsColVector ? r : c);
+    }
+
+    /** \internal \deprecated use insertBack(Index) */
+    EIGEN_DEPRECATED Scalar& fill(Index i)
+    {
+      m_data.append(0, i);
+      return m_data.value(m_data.size()-1);
+    }
+
+    /** \internal \deprecated use insert(Index,Index) */
+    EIGEN_DEPRECATED Scalar& fillrand(Index r, Index c)
+    {
+      eigen_assert(r==0 || c==0);
+      return fillrand(IsColVector ? r : c);
+    }
+
+    /** \internal \deprecated use insert(Index) */
+    EIGEN_DEPRECATED Scalar& fillrand(Index i)
+    {
+      return insert(i);
+    }
+
+    /** \internal \deprecated use finalize() */
+    EIGEN_DEPRECATED void endFill() {}
+    
+    // These two functions were here in the 3.1 release, so let's keep them in case some code rely on them.
+    /** \internal \deprecated use data() */
+    EIGEN_DEPRECATED Storage& _data() { return m_data; }
+    /** \internal \deprecated use data() */
+    EIGEN_DEPRECATED const Storage& _data() const { return m_data; }
+    
+#   ifdef EIGEN_SPARSEVECTOR_PLUGIN
+#     include EIGEN_SPARSEVECTOR_PLUGIN
+#   endif
+
+protected:
+  
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT(NumTraits<StorageIndex>::IsSigned,THE_INDEX_TYPE_MUST_BE_A_SIGNED_TYPE);
+      EIGEN_STATIC_ASSERT((_Options&(ColMajor|RowMajor))==Options,INVALID_MATRIX_TEMPLATE_PARAMETERS);
+    }
+    
+    Storage m_data;
+    Index m_size;
+};
+
+namespace internal {
+
+template<typename _Scalar, int _Options, typename _Index>
+struct evaluator<SparseVector<_Scalar,_Options,_Index> >
+  : evaluator_base<SparseVector<_Scalar,_Options,_Index> >
+{
+  typedef SparseVector<_Scalar,_Options,_Index> SparseVectorType;
+  typedef evaluator_base<SparseVectorType> Base;
+  typedef typename SparseVectorType::InnerIterator InnerIterator;
+  typedef typename SparseVectorType::ReverseInnerIterator ReverseInnerIterator;
+  
+  enum {
+    CoeffReadCost = NumTraits<_Scalar>::ReadCost,
+    Flags = SparseVectorType::Flags
+  };
+
+  evaluator() : Base() {}
+  
+  explicit evaluator(const SparseVectorType &mat) : m_matrix(&mat)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+  
+  inline Index nonZerosEstimate() const {
+    return m_matrix->nonZeros();
+  }
+  
+  operator SparseVectorType&() { return m_matrix->const_cast_derived(); }
+  operator const SparseVectorType&() const { return *m_matrix; }
+  
+  const SparseVectorType *m_matrix;
+};
+
+template< typename Dest, typename Src>
+struct sparse_vector_assign_selector<Dest,Src,SVA_Inner> {
+  static void run(Dest& dst, const Src& src) {
+    eigen_internal_assert(src.innerSize()==src.size());
+    typedef internal::evaluator<Src> SrcEvaluatorType;
+    SrcEvaluatorType srcEval(src);
+    for(typename SrcEvaluatorType::InnerIterator it(srcEval, 0); it; ++it)
+      dst.insert(it.index()) = it.value();
+  }
+};
+
+template< typename Dest, typename Src>
+struct sparse_vector_assign_selector<Dest,Src,SVA_Outer> {
+  static void run(Dest& dst, const Src& src) {
+    eigen_internal_assert(src.outerSize()==src.size());
+    typedef internal::evaluator<Src> SrcEvaluatorType;
+    SrcEvaluatorType srcEval(src);
+    for(Index i=0; i<src.size(); ++i)
+    {
+      typename SrcEvaluatorType::InnerIterator it(srcEval, i);
+      if(it)
+        dst.insert(i) = it.value();
+    }
+  }
+};
+
+template< typename Dest, typename Src>
+struct sparse_vector_assign_selector<Dest,Src,SVA_RuntimeSwitch> {
+  static void run(Dest& dst, const Src& src) {
+    if(src.outerSize()==1)  sparse_vector_assign_selector<Dest,Src,SVA_Inner>::run(dst, src);
+    else                    sparse_vector_assign_selector<Dest,Src,SVA_Outer>::run(dst, src);
+  }
+};
+
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSEVECTOR_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseView.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseView.h
new file mode 100644
index 00000000..7c4aea74
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/SparseView.h
@@ -0,0 +1,253 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Daniel Lowengrub <lowdanie@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSEVIEW_H
+#define EIGEN_SPARSEVIEW_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename MatrixType>
+struct traits<SparseView<MatrixType> > : traits<MatrixType>
+{
+  typedef typename MatrixType::StorageIndex StorageIndex;
+  typedef Sparse StorageKind;
+  enum {
+    Flags = int(traits<MatrixType>::Flags) & (RowMajorBit)
+  };
+};
+
+} // end namespace internal
+
+/** \ingroup SparseCore_Module
+  * \class SparseView
+  *
+  * \brief Expression of a dense or sparse matrix with zero or too small values removed
+  *
+  * \tparam MatrixType the type of the object of which we are removing the small entries
+  *
+  * This class represents an expression of a given dense or sparse matrix with
+  * entries smaller than \c reference * \c epsilon are removed.
+  * It is the return type of MatrixBase::sparseView() and SparseMatrixBase::pruned()
+  * and most of the time this is the only way it is used.
+  *
+  * \sa MatrixBase::sparseView(), SparseMatrixBase::pruned()
+  */
+template<typename MatrixType>
+class SparseView : public SparseMatrixBase<SparseView<MatrixType> >
+{
+  typedef typename MatrixType::Nested MatrixTypeNested;
+  typedef typename internal::remove_all<MatrixTypeNested>::type _MatrixTypeNested;
+  typedef SparseMatrixBase<SparseView > Base;
+public:
+  EIGEN_SPARSE_PUBLIC_INTERFACE(SparseView)
+  typedef typename internal::remove_all<MatrixType>::type NestedExpression;
+
+  explicit SparseView(const MatrixType& mat, const Scalar& reference = Scalar(0),
+                      const RealScalar &epsilon = NumTraits<Scalar>::dummy_precision())
+    : m_matrix(mat), m_reference(reference), m_epsilon(epsilon) {}
+
+  inline Index rows() const { return m_matrix.rows(); }
+  inline Index cols() const { return m_matrix.cols(); }
+
+  inline Index innerSize() const { return m_matrix.innerSize(); }
+  inline Index outerSize() const { return m_matrix.outerSize(); }
+  
+  /** \returns the nested expression */
+  const typename internal::remove_all<MatrixTypeNested>::type&
+  nestedExpression() const { return m_matrix; }
+  
+  Scalar reference() const { return m_reference; }
+  RealScalar epsilon() const { return m_epsilon; }
+  
+protected:
+  MatrixTypeNested m_matrix;
+  Scalar m_reference;
+  RealScalar m_epsilon;
+};
+
+namespace internal {
+
+// TODO find a way to unify the two following variants
+// This is tricky because implementing an inner iterator on top of an IndexBased evaluator is
+// not easy because the evaluators do not expose the sizes of the underlying expression.
+  
+template<typename ArgType>
+struct unary_evaluator<SparseView<ArgType>, IteratorBased>
+  : public evaluator_base<SparseView<ArgType> >
+{
+    typedef typename evaluator<ArgType>::InnerIterator EvalIterator;
+  public:
+    typedef SparseView<ArgType> XprType;
+    
+    class InnerIterator : public EvalIterator
+    {
+        typedef typename XprType::Scalar Scalar;
+      public:
+
+        EIGEN_STRONG_INLINE InnerIterator(const unary_evaluator& sve, Index outer)
+          : EvalIterator(sve.m_argImpl,outer), m_view(sve.m_view)
+        {
+          incrementToNonZero();
+        }
+
+        EIGEN_STRONG_INLINE InnerIterator& operator++()
+        {
+          EvalIterator::operator++();
+          incrementToNonZero();
+          return *this;
+        }
+
+        using EvalIterator::value;
+
+      protected:
+        const XprType &m_view;
+
+      private:
+        void incrementToNonZero()
+        {
+          while((bool(*this)) && internal::isMuchSmallerThan(value(), m_view.reference(), m_view.epsilon()))
+          {
+            EvalIterator::operator++();
+          }
+        }
+    };
+    
+    enum {
+      CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+      Flags = XprType::Flags
+    };
+    
+    explicit unary_evaluator(const XprType& xpr) : m_argImpl(xpr.nestedExpression()), m_view(xpr) {}
+
+  protected:
+    evaluator<ArgType> m_argImpl;
+    const XprType &m_view;
+};
+
+template<typename ArgType>
+struct unary_evaluator<SparseView<ArgType>, IndexBased>
+  : public evaluator_base<SparseView<ArgType> >
+{
+  public:
+    typedef SparseView<ArgType> XprType;
+  protected:
+    enum { IsRowMajor = (XprType::Flags&RowMajorBit)==RowMajorBit };
+    typedef typename XprType::Scalar Scalar;
+    typedef typename XprType::StorageIndex StorageIndex;
+  public:
+    
+    class InnerIterator
+    {
+      public:
+
+        EIGEN_STRONG_INLINE InnerIterator(const unary_evaluator& sve, Index outer)
+          : m_sve(sve), m_inner(0), m_outer(outer), m_end(sve.m_view.innerSize())
+        {
+          incrementToNonZero();
+        }
+
+        EIGEN_STRONG_INLINE InnerIterator& operator++()
+        {
+          m_inner++;
+          incrementToNonZero();
+          return *this;
+        }
+
+        EIGEN_STRONG_INLINE Scalar value() const
+        {
+          return (IsRowMajor) ? m_sve.m_argImpl.coeff(m_outer, m_inner)
+                              : m_sve.m_argImpl.coeff(m_inner, m_outer);
+        }
+
+        EIGEN_STRONG_INLINE StorageIndex index() const { return m_inner; }
+        inline Index row() const { return IsRowMajor ? m_outer : index(); }
+        inline Index col() const { return IsRowMajor ? index() : m_outer; }
+
+        EIGEN_STRONG_INLINE operator bool() const { return m_inner < m_end && m_inner>=0; }
+
+      protected:
+        const unary_evaluator &m_sve;
+        Index m_inner;
+        const Index m_outer;
+        const Index m_end;
+
+      private:
+        void incrementToNonZero()
+        {
+          while((bool(*this)) && internal::isMuchSmallerThan(value(), m_sve.m_view.reference(), m_sve.m_view.epsilon()))
+          {
+            m_inner++;
+          }
+        }
+    };
+    
+    enum {
+      CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+      Flags = XprType::Flags
+    };
+    
+    explicit unary_evaluator(const XprType& xpr) : m_argImpl(xpr.nestedExpression()), m_view(xpr) {}
+
+  protected:
+    evaluator<ArgType> m_argImpl;
+    const XprType &m_view;
+};
+
+} // end namespace internal
+
+/** \ingroup SparseCore_Module
+  *
+  * \returns a sparse expression of the dense expression \c *this with values smaller than
+  * \a reference * \a epsilon removed.
+  *
+  * This method is typically used when prototyping to convert a quickly assembled dense Matrix \c D to a SparseMatrix \c S:
+  * \code
+  * MatrixXd D(n,m);
+  * SparseMatrix<double> S;
+  * S = D.sparseView();             // suppress numerical zeros (exact)
+  * S = D.sparseView(reference);
+  * S = D.sparseView(reference,epsilon);
+  * \endcode
+  * where \a reference is a meaningful non zero reference value,
+  * and \a epsilon is a tolerance factor defaulting to NumTraits<Scalar>::dummy_precision().
+  *
+  * \sa SparseMatrixBase::pruned(), class SparseView */
+template<typename Derived>
+const SparseView<Derived> MatrixBase<Derived>::sparseView(const Scalar& reference,
+                                                          const typename NumTraits<Scalar>::Real& epsilon) const
+{
+  return SparseView<Derived>(derived(), reference, epsilon);
+}
+
+/** \returns an expression of \c *this with values smaller than
+  * \a reference * \a epsilon removed.
+  *
+  * This method is typically used in conjunction with the product of two sparse matrices
+  * to automatically prune the smallest values as follows:
+  * \code
+  * C = (A*B).pruned();             // suppress numerical zeros (exact)
+  * C = (A*B).pruned(ref);
+  * C = (A*B).pruned(ref,epsilon);
+  * \endcode
+  * where \c ref is a meaningful non zero reference value.
+  * */
+template<typename Derived>
+const SparseView<Derived>
+SparseMatrixBase<Derived>::pruned(const Scalar& reference,
+                                  const RealScalar& epsilon) const
+{
+  return SparseView<Derived>(derived(), reference, epsilon);
+}
+
+} // end namespace Eigen
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/TriangularSolver.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/TriangularSolver.h
new file mode 100644
index 00000000..f9c56ba7
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseCore/TriangularSolver.h
@@ -0,0 +1,315 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSETRIANGULARSOLVER_H
+#define EIGEN_SPARSETRIANGULARSOLVER_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename Lhs, typename Rhs, int Mode,
+  int UpLo = (Mode & Lower)
+           ? Lower
+           : (Mode & Upper)
+           ? Upper
+           : -1,
+  int StorageOrder = int(traits<Lhs>::Flags) & RowMajorBit>
+struct sparse_solve_triangular_selector;
+
+// forward substitution, row-major
+template<typename Lhs, typename Rhs, int Mode>
+struct sparse_solve_triangular_selector<Lhs,Rhs,Mode,Lower,RowMajor>
+{
+  typedef typename Rhs::Scalar Scalar;
+  typedef evaluator<Lhs> LhsEval;
+  typedef typename evaluator<Lhs>::InnerIterator LhsIterator;
+  static void run(const Lhs& lhs, Rhs& other)
+  {
+    LhsEval lhsEval(lhs);
+    for(Index col=0 ; col<other.cols() ; ++col)
+    {
+      for(Index i=0; i<lhs.rows(); ++i)
+      {
+        Scalar tmp = other.coeff(i,col);
+        Scalar lastVal(0);
+        Index lastIndex = 0;
+        for(LhsIterator it(lhsEval, i); it; ++it)
+        {
+          lastVal = it.value();
+          lastIndex = it.index();
+          if(lastIndex==i)
+            break;
+          tmp -= lastVal * other.coeff(lastIndex,col);
+        }
+        if (Mode & UnitDiag)
+          other.coeffRef(i,col) = tmp;
+        else
+        {
+          eigen_assert(lastIndex==i);
+          other.coeffRef(i,col) = tmp/lastVal;
+        }
+      }
+    }
+  }
+};
+
+// backward substitution, row-major
+template<typename Lhs, typename Rhs, int Mode>
+struct sparse_solve_triangular_selector<Lhs,Rhs,Mode,Upper,RowMajor>
+{
+  typedef typename Rhs::Scalar Scalar;
+  typedef evaluator<Lhs> LhsEval;
+  typedef typename evaluator<Lhs>::InnerIterator LhsIterator;
+  static void run(const Lhs& lhs, Rhs& other)
+  {
+    LhsEval lhsEval(lhs);
+    for(Index col=0 ; col<other.cols() ; ++col)
+    {
+      for(Index i=lhs.rows()-1 ; i>=0 ; --i)
+      {
+        Scalar tmp = other.coeff(i,col);
+        Scalar l_ii(0);
+        LhsIterator it(lhsEval, i);
+        while(it && it.index()<i)
+          ++it;
+        if(!(Mode & UnitDiag))
+        {
+          eigen_assert(it && it.index()==i);
+          l_ii = it.value();
+          ++it;
+        }
+        else if (it && it.index() == i)
+          ++it;
+        for(; it; ++it)
+        {
+          tmp -= it.value() * other.coeff(it.index(),col);
+        }
+
+        if (Mode & UnitDiag)  other.coeffRef(i,col) = tmp;
+        else                  other.coeffRef(i,col) = tmp/l_ii;
+      }
+    }
+  }
+};
+
+// forward substitution, col-major
+template<typename Lhs, typename Rhs, int Mode>
+struct sparse_solve_triangular_selector<Lhs,Rhs,Mode,Lower,ColMajor>
+{
+  typedef typename Rhs::Scalar Scalar;
+  typedef evaluator<Lhs> LhsEval;
+  typedef typename evaluator<Lhs>::InnerIterator LhsIterator;
+  static void run(const Lhs& lhs, Rhs& other)
+  {
+    LhsEval lhsEval(lhs);
+    for(Index col=0 ; col<other.cols() ; ++col)
+    {
+      for(Index i=0; i<lhs.cols(); ++i)
+      {
+        Scalar& tmp = other.coeffRef(i,col);
+        if (tmp!=Scalar(0)) // optimization when other is actually sparse
+        {
+          LhsIterator it(lhsEval, i);
+          while(it && it.index()<i)
+            ++it;
+          if(!(Mode & UnitDiag))
+          {
+            eigen_assert(it && it.index()==i);
+            tmp /= it.value();
+          }
+          if (it && it.index()==i)
+            ++it;
+          for(; it; ++it)
+            other.coeffRef(it.index(), col) -= tmp * it.value();
+        }
+      }
+    }
+  }
+};
+
+// backward substitution, col-major
+template<typename Lhs, typename Rhs, int Mode>
+struct sparse_solve_triangular_selector<Lhs,Rhs,Mode,Upper,ColMajor>
+{
+  typedef typename Rhs::Scalar Scalar;
+  typedef evaluator<Lhs> LhsEval;
+  typedef typename evaluator<Lhs>::InnerIterator LhsIterator;
+  static void run(const Lhs& lhs, Rhs& other)
+  {
+    LhsEval lhsEval(lhs);
+    for(Index col=0 ; col<other.cols() ; ++col)
+    {
+      for(Index i=lhs.cols()-1; i>=0; --i)
+      {
+        Scalar& tmp = other.coeffRef(i,col);
+        if (tmp!=Scalar(0)) // optimization when other is actually sparse
+        {
+          if(!(Mode & UnitDiag))
+          {
+            // TODO replace this by a binary search. make sure the binary search is safe for partially sorted elements
+            LhsIterator it(lhsEval, i);
+            while(it && it.index()!=i)
+              ++it;
+            eigen_assert(it && it.index()==i);
+            other.coeffRef(i,col) /= it.value();
+          }
+          LhsIterator it(lhsEval, i);
+          for(; it && it.index()<i; ++it)
+            other.coeffRef(it.index(), col) -= tmp * it.value();
+        }
+      }
+    }
+  }
+};
+
+} // end namespace internal
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+
+template<typename ExpressionType,unsigned int Mode>
+template<typename OtherDerived>
+void TriangularViewImpl<ExpressionType,Mode,Sparse>::solveInPlace(MatrixBase<OtherDerived>& other) const
+{
+  eigen_assert(derived().cols() == derived().rows() && derived().cols() == other.rows());
+  eigen_assert((!(Mode & ZeroDiag)) && bool(Mode & (Upper|Lower)));
+
+  enum { copy = internal::traits<OtherDerived>::Flags & RowMajorBit };
+
+  typedef typename internal::conditional<copy,
+    typename internal::plain_matrix_type_column_major<OtherDerived>::type, OtherDerived&>::type OtherCopy;
+  OtherCopy otherCopy(other.derived());
+
+  internal::sparse_solve_triangular_selector<ExpressionType, typename internal::remove_reference<OtherCopy>::type, Mode>::run(derived().nestedExpression(), otherCopy);
+
+  if (copy)
+    other = otherCopy;
+}
+#endif
+
+// pure sparse path
+
+namespace internal {
+
+template<typename Lhs, typename Rhs, int Mode,
+  int UpLo = (Mode & Lower)
+           ? Lower
+           : (Mode & Upper)
+           ? Upper
+           : -1,
+  int StorageOrder = int(Lhs::Flags) & (RowMajorBit)>
+struct sparse_solve_triangular_sparse_selector;
+
+// forward substitution, col-major
+template<typename Lhs, typename Rhs, int Mode, int UpLo>
+struct sparse_solve_triangular_sparse_selector<Lhs,Rhs,Mode,UpLo,ColMajor>
+{
+  typedef typename Rhs::Scalar Scalar;
+  typedef typename promote_index_type<typename traits<Lhs>::StorageIndex,
+                                      typename traits<Rhs>::StorageIndex>::type StorageIndex;
+  static void run(const Lhs& lhs, Rhs& other)
+  {
+    const bool IsLower = (UpLo==Lower);
+    AmbiVector<Scalar,StorageIndex> tempVector(other.rows()*2);
+    tempVector.setBounds(0,other.rows());
+
+    Rhs res(other.rows(), other.cols());
+    res.reserve(other.nonZeros());
+
+    for(Index col=0 ; col<other.cols() ; ++col)
+    {
+      // FIXME estimate number of non zeros
+      tempVector.init(.99/*float(other.col(col).nonZeros())/float(other.rows())*/);
+      tempVector.setZero();
+      tempVector.restart();
+      for (typename Rhs::InnerIterator rhsIt(other, col); rhsIt; ++rhsIt)
+      {
+        tempVector.coeffRef(rhsIt.index()) = rhsIt.value();
+      }
+
+      for(Index i=IsLower?0:lhs.cols()-1;
+          IsLower?i<lhs.cols():i>=0;
+          i+=IsLower?1:-1)
+      {
+        tempVector.restart();
+        Scalar& ci = tempVector.coeffRef(i);
+        if (ci!=Scalar(0))
+        {
+          // find
+          typename Lhs::InnerIterator it(lhs, i);
+          if(!(Mode & UnitDiag))
+          {
+            if (IsLower)
+            {
+              eigen_assert(it.index()==i);
+              ci /= it.value();
+            }
+            else
+              ci /= lhs.coeff(i,i);
+          }
+          tempVector.restart();
+          if (IsLower)
+          {
+            if (it.index()==i)
+              ++it;
+            for(; it; ++it)
+              tempVector.coeffRef(it.index()) -= ci * it.value();
+          }
+          else
+          {
+            for(; it && it.index()<i; ++it)
+              tempVector.coeffRef(it.index()) -= ci * it.value();
+          }
+        }
+      }
+
+
+      Index count = 0;
+      // FIXME compute a reference value to filter zeros
+      for (typename AmbiVector<Scalar,StorageIndex>::Iterator it(tempVector/*,1e-12*/); it; ++it)
+      {
+        ++ count;
+//         std::cerr << "fill " << it.index() << ", " << col << "\n";
+//         std::cout << it.value() << "  ";
+        // FIXME use insertBack
+        res.insert(it.index(), col) = it.value();
+      }
+//       std::cout << "tempVector.nonZeros() == " << int(count) << " / " << (other.rows()) << "\n";
+    }
+    res.finalize();
+    other = res.markAsRValue();
+  }
+};
+
+} // end namespace internal
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename ExpressionType,unsigned int Mode>
+template<typename OtherDerived>
+void TriangularViewImpl<ExpressionType,Mode,Sparse>::solveInPlace(SparseMatrixBase<OtherDerived>& other) const
+{
+  eigen_assert(derived().cols() == derived().rows() && derived().cols() == other.rows());
+  eigen_assert( (!(Mode & ZeroDiag)) && bool(Mode & (Upper|Lower)));
+
+//   enum { copy = internal::traits<OtherDerived>::Flags & RowMajorBit };
+
+//   typedef typename internal::conditional<copy,
+//     typename internal::plain_matrix_type_column_major<OtherDerived>::type, OtherDerived&>::type OtherCopy;
+//   OtherCopy otherCopy(other.derived());
+
+  internal::sparse_solve_triangular_sparse_selector<ExpressionType, OtherDerived, Mode>::run(derived().nestedExpression(), other.derived());
+
+//   if (copy)
+//     other = otherCopy;
+}
+#endif
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSETRIANGULARSOLVER_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU.h
new file mode 100644
index 00000000..f883ab38
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU.h
@@ -0,0 +1,775 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+// Copyright (C) 2012-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+#ifndef EIGEN_SPARSE_LU_H
+#define EIGEN_SPARSE_LU_H
+
+namespace Eigen {
+
+template <typename _MatrixType, typename _OrderingType = COLAMDOrdering<typename _MatrixType::StorageIndex> > class SparseLU;
+template <typename MappedSparseMatrixType> struct SparseLUMatrixLReturnType;
+template <typename MatrixLType, typename MatrixUType> struct SparseLUMatrixUReturnType;
+
+/** \ingroup SparseLU_Module
+  * \class SparseLU
+  * 
+  * \brief Sparse supernodal LU factorization for general matrices
+  * 
+  * This class implements the supernodal LU factorization for general matrices.
+  * It uses the main techniques from the sequential SuperLU package 
+  * (http://crd-legacy.lbl.gov/~xiaoye/SuperLU/). It handles transparently real 
+  * and complex arithmetics with single and double precision, depending on the 
+  * scalar type of your input matrix. 
+  * The code has been optimized to provide BLAS-3 operations during supernode-panel updates. 
+  * It benefits directly from the built-in high-performant Eigen BLAS routines. 
+  * Moreover, when the size of a supernode is very small, the BLAS calls are avoided to 
+  * enable a better optimization from the compiler. For best performance, 
+  * you should compile it with NDEBUG flag to avoid the numerous bounds checking on vectors. 
+  * 
+  * An important parameter of this class is the ordering method. It is used to reorder the columns 
+  * (and eventually the rows) of the matrix to reduce the number of new elements that are created during 
+  * numerical factorization. The cheapest method available is COLAMD. 
+  * See  \link OrderingMethods_Module the OrderingMethods module \endlink for the list of 
+  * built-in and external ordering methods. 
+  *
+  * Simple example with key steps 
+  * \code
+  * VectorXd x(n), b(n);
+  * SparseMatrix<double, ColMajor> A;
+  * SparseLU<SparseMatrix<scalar, ColMajor>, COLAMDOrdering<Index> >   solver;
+  * // fill A and b;
+  * // Compute the ordering permutation vector from the structural pattern of A
+  * solver.analyzePattern(A); 
+  * // Compute the numerical factorization 
+  * solver.factorize(A); 
+  * //Use the factors to solve the linear system 
+  * x = solver.solve(b); 
+  * \endcode
+  * 
+  * \warning The input matrix A should be in a \b compressed and \b column-major form.
+  * Otherwise an expensive copy will be made. You can call the inexpensive makeCompressed() to get a compressed matrix.
+  * 
+  * \note Unlike the initial SuperLU implementation, there is no step to equilibrate the matrix. 
+  * For badly scaled matrices, this step can be useful to reduce the pivoting during factorization. 
+  * If this is the case for your matrices, you can try the basic scaling method at
+  *  "unsupported/Eigen/src/IterativeSolvers/Scaling.h"
+  * 
+  * \tparam _MatrixType The type of the sparse matrix. It must be a column-major SparseMatrix<>
+  * \tparam _OrderingType The ordering method to use, either AMD, COLAMD or METIS. Default is COLMAD
+  *
+  * \implsparsesolverconcept
+  * 
+  * \sa \ref TutorialSparseSolverConcept
+  * \sa \ref OrderingMethods_Module
+  */
+template <typename _MatrixType, typename _OrderingType>
+class SparseLU : public SparseSolverBase<SparseLU<_MatrixType,_OrderingType> >, public internal::SparseLUImpl<typename _MatrixType::Scalar, typename _MatrixType::StorageIndex>
+{
+  protected:
+    typedef SparseSolverBase<SparseLU<_MatrixType,_OrderingType> > APIBase;
+    using APIBase::m_isInitialized;
+  public:
+    using APIBase::_solve_impl;
+    
+    typedef _MatrixType MatrixType; 
+    typedef _OrderingType OrderingType;
+    typedef typename MatrixType::Scalar Scalar; 
+    typedef typename MatrixType::RealScalar RealScalar; 
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef SparseMatrix<Scalar,ColMajor,StorageIndex> NCMatrix;
+    typedef internal::MappedSuperNodalMatrix<Scalar, StorageIndex> SCMatrix;
+    typedef Matrix<Scalar,Dynamic,1> ScalarVector;
+    typedef Matrix<StorageIndex,Dynamic,1> IndexVector;
+    typedef PermutationMatrix<Dynamic, Dynamic, StorageIndex> PermutationType;
+    typedef internal::SparseLUImpl<Scalar, StorageIndex> Base;
+
+    enum {
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    
+  public:
+    SparseLU():m_lastError(""),m_Ustore(0,0,0,0,0,0),m_symmetricmode(false),m_diagpivotthresh(1.0),m_detPermR(1)
+    {
+      initperfvalues(); 
+    }
+    explicit SparseLU(const MatrixType& matrix)
+      : m_lastError(""),m_Ustore(0,0,0,0,0,0),m_symmetricmode(false),m_diagpivotthresh(1.0),m_detPermR(1)
+    {
+      initperfvalues(); 
+      compute(matrix);
+    }
+    
+    ~SparseLU()
+    {
+      // Free all explicit dynamic pointers 
+    }
+    
+    void analyzePattern (const MatrixType& matrix);
+    void factorize (const MatrixType& matrix);
+    void simplicialfactorize(const MatrixType& matrix);
+    
+    /**
+      * Compute the symbolic and numeric factorization of the input sparse matrix.
+      * The input matrix should be in column-major storage. 
+      */
+    void compute (const MatrixType& matrix)
+    {
+      // Analyze 
+      analyzePattern(matrix); 
+      //Factorize
+      factorize(matrix);
+    } 
+    
+    inline Index rows() const { return m_mat.rows(); }
+    inline Index cols() const { return m_mat.cols(); }
+    /** Indicate that the pattern of the input matrix is symmetric */
+    void isSymmetric(bool sym)
+    {
+      m_symmetricmode = sym;
+    }
+    
+    /** \returns an expression of the matrix L, internally stored as supernodes
+      * The only operation available with this expression is the triangular solve
+      * \code
+      * y = b; matrixL().solveInPlace(y);
+      * \endcode
+      */
+    SparseLUMatrixLReturnType<SCMatrix> matrixL() const
+    {
+      return SparseLUMatrixLReturnType<SCMatrix>(m_Lstore);
+    }
+    /** \returns an expression of the matrix U,
+      * The only operation available with this expression is the triangular solve
+      * \code
+      * y = b; matrixU().solveInPlace(y);
+      * \endcode
+      */
+    SparseLUMatrixUReturnType<SCMatrix,MappedSparseMatrix<Scalar,ColMajor,StorageIndex> > matrixU() const
+    {
+      return SparseLUMatrixUReturnType<SCMatrix, MappedSparseMatrix<Scalar,ColMajor,StorageIndex> >(m_Lstore, m_Ustore);
+    }
+
+    /**
+      * \returns a reference to the row matrix permutation \f$ P_r \f$ such that \f$P_r A P_c^T = L U\f$
+      * \sa colsPermutation()
+      */
+    inline const PermutationType& rowsPermutation() const
+    {
+      return m_perm_r;
+    }
+    /**
+      * \returns a reference to the column matrix permutation\f$ P_c^T \f$ such that \f$P_r A P_c^T = L U\f$
+      * \sa rowsPermutation()
+      */
+    inline const PermutationType& colsPermutation() const
+    {
+      return m_perm_c;
+    }
+    /** Set the threshold used for a diagonal entry to be an acceptable pivot. */
+    void setPivotThreshold(const RealScalar& thresh)
+    {
+      m_diagpivotthresh = thresh; 
+    }
+
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+    /** \returns the solution X of \f$ A X = B \f$ using the current decomposition of A.
+      *
+      * \warning the destination matrix X in X = this->solve(B) must be colmun-major.
+      *
+      * \sa compute()
+      */
+    template<typename Rhs>
+    inline const Solve<SparseLU, Rhs> solve(const MatrixBase<Rhs>& B) const;
+#endif // EIGEN_PARSED_BY_DOXYGEN
+    
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was succesful,
+      *          \c NumericalIssue if the LU factorization reports a problem, zero diagonal for instance
+      *          \c InvalidInput if the input matrix is invalid
+      *
+      * \sa iparm()          
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_info;
+    }
+    
+    /**
+      * \returns A string describing the type of error
+      */
+    std::string lastErrorMessage() const
+    {
+      return m_lastError; 
+    }
+
+    template<typename Rhs, typename Dest>
+    bool _solve_impl(const MatrixBase<Rhs> &B, MatrixBase<Dest> &X_base) const
+    {
+      Dest& X(X_base.derived());
+      eigen_assert(m_factorizationIsOk && "The matrix should be factorized first");
+      EIGEN_STATIC_ASSERT((Dest::Flags&RowMajorBit)==0,
+                        THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
+      
+      // Permute the right hand side to form X = Pr*B
+      // on return, X is overwritten by the computed solution
+      X.resize(B.rows(),B.cols());
+
+      // this ugly const_cast_derived() helps to detect aliasing when applying the permutations
+      for(Index j = 0; j < B.cols(); ++j)
+        X.col(j) = rowsPermutation() * B.const_cast_derived().col(j);
+      
+      //Forward substitution with L
+      this->matrixL().solveInPlace(X);
+      this->matrixU().solveInPlace(X);
+      
+      // Permute back the solution 
+      for (Index j = 0; j < B.cols(); ++j)
+        X.col(j) = colsPermutation().inverse() * X.col(j);
+      
+      return true; 
+    }
+    
+    /**
+      * \returns the absolute value of the determinant of the matrix of which
+      * *this is the QR decomposition.
+      *
+      * \warning a determinant can be very big or small, so for matrices
+      * of large enough dimension, there is a risk of overflow/underflow.
+      * One way to work around that is to use logAbsDeterminant() instead.
+      *
+      * \sa logAbsDeterminant(), signDeterminant()
+      */
+    Scalar absDeterminant()
+    {
+      using std::abs;
+      eigen_assert(m_factorizationIsOk && "The matrix should be factorized first.");
+      // Initialize with the determinant of the row matrix
+      Scalar det = Scalar(1.);
+      // Note that the diagonal blocks of U are stored in supernodes,
+      // which are available in the  L part :)
+      for (Index j = 0; j < this->cols(); ++j)
+      {
+        for (typename SCMatrix::InnerIterator it(m_Lstore, j); it; ++it)
+        {
+          if(it.index() == j)
+          {
+            det *= abs(it.value());
+            break;
+          }
+        }
+      }
+      return det;
+    }
+
+    /** \returns the natural log of the absolute value of the determinant of the matrix
+      * of which **this is the QR decomposition
+      *
+      * \note This method is useful to work around the risk of overflow/underflow that's
+      * inherent to the determinant computation.
+      *
+      * \sa absDeterminant(), signDeterminant()
+      */
+    Scalar logAbsDeterminant() const
+    {
+      using std::log;
+      using std::abs;
+
+      eigen_assert(m_factorizationIsOk && "The matrix should be factorized first.");
+      Scalar det = Scalar(0.);
+      for (Index j = 0; j < this->cols(); ++j)
+      {
+        for (typename SCMatrix::InnerIterator it(m_Lstore, j); it; ++it)
+        {
+          if(it.row() < j) continue;
+          if(it.row() == j)
+          {
+            det += log(abs(it.value()));
+            break;
+          }
+        }
+      }
+      return det;
+    }
+
+    /** \returns A number representing the sign of the determinant
+      *
+      * \sa absDeterminant(), logAbsDeterminant()
+      */
+    Scalar signDeterminant()
+    {
+      eigen_assert(m_factorizationIsOk && "The matrix should be factorized first.");
+      // Initialize with the determinant of the row matrix
+      Index det = 1;
+      // Note that the diagonal blocks of U are stored in supernodes,
+      // which are available in the  L part :)
+      for (Index j = 0; j < this->cols(); ++j)
+      {
+        for (typename SCMatrix::InnerIterator it(m_Lstore, j); it; ++it)
+        {
+          if(it.index() == j)
+          {
+            if(it.value()<0)
+              det = -det;
+            else if(it.value()==0)
+              return 0;
+            break;
+          }
+        }
+      }
+      return det * m_detPermR * m_detPermC;
+    }
+    
+    /** \returns The determinant of the matrix.
+      *
+      * \sa absDeterminant(), logAbsDeterminant()
+      */
+    Scalar determinant()
+    {
+      eigen_assert(m_factorizationIsOk && "The matrix should be factorized first.");
+      // Initialize with the determinant of the row matrix
+      Scalar det = Scalar(1.);
+      // Note that the diagonal blocks of U are stored in supernodes,
+      // which are available in the  L part :)
+      for (Index j = 0; j < this->cols(); ++j)
+      {
+        for (typename SCMatrix::InnerIterator it(m_Lstore, j); it; ++it)
+        {
+          if(it.index() == j)
+          {
+            det *= it.value();
+            break;
+          }
+        }
+      }
+      return (m_detPermR * m_detPermC) > 0 ? det : -det;
+    }
+
+  protected:
+    // Functions 
+    void initperfvalues()
+    {
+      m_perfv.panel_size = 16;
+      m_perfv.relax = 1; 
+      m_perfv.maxsuper = 128; 
+      m_perfv.rowblk = 16; 
+      m_perfv.colblk = 8; 
+      m_perfv.fillfactor = 20;  
+    }
+      
+    // Variables 
+    mutable ComputationInfo m_info;
+    bool m_factorizationIsOk;
+    bool m_analysisIsOk;
+    std::string m_lastError;
+    NCMatrix m_mat; // The input (permuted ) matrix 
+    SCMatrix m_Lstore; // The lower triangular matrix (supernodal)
+    MappedSparseMatrix<Scalar,ColMajor,StorageIndex> m_Ustore; // The upper triangular matrix
+    PermutationType m_perm_c; // Column permutation 
+    PermutationType m_perm_r ; // Row permutation
+    IndexVector m_etree; // Column elimination tree 
+    
+    typename Base::GlobalLU_t m_glu; 
+                               
+    // SparseLU options 
+    bool m_symmetricmode;
+    // values for performance 
+    internal::perfvalues m_perfv;
+    RealScalar m_diagpivotthresh; // Specifies the threshold used for a diagonal entry to be an acceptable pivot
+    Index m_nnzL, m_nnzU; // Nonzeros in L and U factors
+    Index m_detPermR, m_detPermC; // Determinants of the permutation matrices
+  private:
+    // Disable copy constructor 
+    SparseLU (const SparseLU& );
+  
+}; // End class SparseLU
+
+
+
+// Functions needed by the anaysis phase
+/** 
+  * Compute the column permutation to minimize the fill-in
+  * 
+  *  - Apply this permutation to the input matrix - 
+  * 
+  *  - Compute the column elimination tree on the permuted matrix 
+  * 
+  *  - Postorder the elimination tree and the column permutation
+  * 
+  */
+template <typename MatrixType, typename OrderingType>
+void SparseLU<MatrixType, OrderingType>::analyzePattern(const MatrixType& mat)
+{
+  
+  //TODO  It is possible as in SuperLU to compute row and columns scaling vectors to equilibrate the matrix mat.
+  
+  // Firstly, copy the whole input matrix. 
+  m_mat = mat;
+  
+  // Compute fill-in ordering
+  OrderingType ord; 
+  ord(m_mat,m_perm_c);
+  
+  // Apply the permutation to the column of the input  matrix
+  if (m_perm_c.size())
+  {
+    m_mat.uncompress(); //NOTE: The effect of this command is only to create the InnerNonzeros pointers. FIXME : This vector is filled but not subsequently used.  
+    // Then, permute only the column pointers
+    ei_declare_aligned_stack_constructed_variable(StorageIndex,outerIndexPtr,mat.cols()+1,mat.isCompressed()?const_cast<StorageIndex*>(mat.outerIndexPtr()):0);
+    
+    // If the input matrix 'mat' is uncompressed, then the outer-indices do not match the ones of m_mat, and a copy is thus needed.
+    if(!mat.isCompressed()) 
+      IndexVector::Map(outerIndexPtr, mat.cols()+1) = IndexVector::Map(m_mat.outerIndexPtr(),mat.cols()+1);
+    
+    // Apply the permutation and compute the nnz per column.
+    for (Index i = 0; i < mat.cols(); i++)
+    {
+      m_mat.outerIndexPtr()[m_perm_c.indices()(i)] = outerIndexPtr[i];
+      m_mat.innerNonZeroPtr()[m_perm_c.indices()(i)] = outerIndexPtr[i+1] - outerIndexPtr[i];
+    }
+  }
+  
+  // Compute the column elimination tree of the permuted matrix 
+  IndexVector firstRowElt;
+  internal::coletree(m_mat, m_etree,firstRowElt); 
+     
+  // In symmetric mode, do not do postorder here
+  if (!m_symmetricmode) {
+    IndexVector post, iwork; 
+    // Post order etree
+    internal::treePostorder(StorageIndex(m_mat.cols()), m_etree, post); 
+      
+   
+    // Renumber etree in postorder 
+    Index m = m_mat.cols(); 
+    iwork.resize(m+1);
+    for (Index i = 0; i < m; ++i) iwork(post(i)) = post(m_etree(i));
+    m_etree = iwork;
+    
+    // Postmultiply A*Pc by post, i.e reorder the matrix according to the postorder of the etree
+    PermutationType post_perm(m); 
+    for (Index i = 0; i < m; i++) 
+      post_perm.indices()(i) = post(i); 
+        
+    // Combine the two permutations : postorder the permutation for future use
+    if(m_perm_c.size()) {
+      m_perm_c = post_perm * m_perm_c;
+    }
+    
+  } // end postordering 
+  
+  m_analysisIsOk = true; 
+}
+
+// Functions needed by the numerical factorization phase
+
+
+/** 
+  *  - Numerical factorization 
+  *  - Interleaved with the symbolic factorization 
+  * On exit,  info is 
+  * 
+  *    = 0: successful factorization
+  * 
+  *    > 0: if info = i, and i is
+  * 
+  *       <= A->ncol: U(i,i) is exactly zero. The factorization has
+  *          been completed, but the factor U is exactly singular,
+  *          and division by zero will occur if it is used to solve a
+  *          system of equations.
+  * 
+  *       > A->ncol: number of bytes allocated when memory allocation
+  *         failure occurred, plus A->ncol. If lwork = -1, it is
+  *         the estimated amount of space needed, plus A->ncol.  
+  */
+template <typename MatrixType, typename OrderingType>
+void SparseLU<MatrixType, OrderingType>::factorize(const MatrixType& matrix)
+{
+  using internal::emptyIdxLU;
+  eigen_assert(m_analysisIsOk && "analyzePattern() should be called first"); 
+  eigen_assert((matrix.rows() == matrix.cols()) && "Only for squared matrices");
+  
+  typedef typename IndexVector::Scalar StorageIndex; 
+  
+  m_isInitialized = true;
+  
+  
+  // Apply the column permutation computed in analyzepattern()
+  //   m_mat = matrix * m_perm_c.inverse(); 
+  m_mat = matrix;
+  if (m_perm_c.size()) 
+  {
+    m_mat.uncompress(); //NOTE: The effect of this command is only to create the InnerNonzeros pointers.
+    //Then, permute only the column pointers
+    const StorageIndex * outerIndexPtr;
+    if (matrix.isCompressed()) outerIndexPtr = matrix.outerIndexPtr();
+    else
+    {
+      StorageIndex* outerIndexPtr_t = new StorageIndex[matrix.cols()+1];
+      for(Index i = 0; i <= matrix.cols(); i++) outerIndexPtr_t[i] = m_mat.outerIndexPtr()[i];
+      outerIndexPtr = outerIndexPtr_t;
+    }
+    for (Index i = 0; i < matrix.cols(); i++)
+    {
+      m_mat.outerIndexPtr()[m_perm_c.indices()(i)] = outerIndexPtr[i];
+      m_mat.innerNonZeroPtr()[m_perm_c.indices()(i)] = outerIndexPtr[i+1] - outerIndexPtr[i];
+    }
+    if(!matrix.isCompressed()) delete[] outerIndexPtr;
+  } 
+  else 
+  { //FIXME This should not be needed if the empty permutation is handled transparently
+    m_perm_c.resize(matrix.cols());
+    for(StorageIndex i = 0; i < matrix.cols(); ++i) m_perm_c.indices()(i) = i;
+  }
+  
+  Index m = m_mat.rows();
+  Index n = m_mat.cols();
+  Index nnz = m_mat.nonZeros();
+  Index maxpanel = m_perfv.panel_size * m;
+  // Allocate working storage common to the factor routines
+  Index lwork = 0;
+  Index info = Base::memInit(m, n, nnz, lwork, m_perfv.fillfactor, m_perfv.panel_size, m_glu); 
+  if (info) 
+  {
+    m_lastError = "UNABLE TO ALLOCATE WORKING MEMORY\n\n" ;
+    m_factorizationIsOk = false;
+    return ; 
+  }
+  
+  // Set up pointers for integer working arrays 
+  IndexVector segrep(m); segrep.setZero();
+  IndexVector parent(m); parent.setZero();
+  IndexVector xplore(m); xplore.setZero();
+  IndexVector repfnz(maxpanel);
+  IndexVector panel_lsub(maxpanel);
+  IndexVector xprune(n); xprune.setZero();
+  IndexVector marker(m*internal::LUNoMarker); marker.setZero();
+  
+  repfnz.setConstant(-1); 
+  panel_lsub.setConstant(-1);
+  
+  // Set up pointers for scalar working arrays 
+  ScalarVector dense; 
+  dense.setZero(maxpanel);
+  ScalarVector tempv; 
+  tempv.setZero(internal::LUnumTempV(m, m_perfv.panel_size, m_perfv.maxsuper, /*m_perfv.rowblk*/m) );
+  
+  // Compute the inverse of perm_c
+  PermutationType iperm_c(m_perm_c.inverse()); 
+  
+  // Identify initial relaxed snodes
+  IndexVector relax_end(n);
+  if ( m_symmetricmode == true ) 
+    Base::heap_relax_snode(n, m_etree, m_perfv.relax, marker, relax_end);
+  else
+    Base::relax_snode(n, m_etree, m_perfv.relax, marker, relax_end);
+  
+  
+  m_perm_r.resize(m); 
+  m_perm_r.indices().setConstant(-1);
+  marker.setConstant(-1);
+  m_detPermR = 1; // Record the determinant of the row permutation
+  
+  m_glu.supno(0) = emptyIdxLU; m_glu.xsup.setConstant(0);
+  m_glu.xsup(0) = m_glu.xlsub(0) = m_glu.xusub(0) = m_glu.xlusup(0) = Index(0);
+  
+  // Work on one 'panel' at a time. A panel is one of the following :
+  //  (a) a relaxed supernode at the bottom of the etree, or
+  //  (b) panel_size contiguous columns, <panel_size> defined by the user
+  Index jcol; 
+  IndexVector panel_histo(n);
+  Index pivrow; // Pivotal row number in the original row matrix
+  Index nseg1; // Number of segments in U-column above panel row jcol
+  Index nseg; // Number of segments in each U-column 
+  Index irep; 
+  Index i, k, jj; 
+  for (jcol = 0; jcol < n; )
+  {
+    // Adjust panel size so that a panel won't overlap with the next relaxed snode. 
+    Index panel_size = m_perfv.panel_size; // upper bound on panel width
+    for (k = jcol + 1; k < (std::min)(jcol+panel_size, n); k++)
+    {
+      if (relax_end(k) != emptyIdxLU) 
+      {
+        panel_size = k - jcol; 
+        break; 
+      }
+    }
+    if (k == n) 
+      panel_size = n - jcol; 
+      
+    // Symbolic outer factorization on a panel of columns 
+    Base::panel_dfs(m, panel_size, jcol, m_mat, m_perm_r.indices(), nseg1, dense, panel_lsub, segrep, repfnz, xprune, marker, parent, xplore, m_glu); 
+    
+    // Numeric sup-panel updates in topological order 
+    Base::panel_bmod(m, panel_size, jcol, nseg1, dense, tempv, segrep, repfnz, m_glu); 
+    
+    // Sparse LU within the panel, and below the panel diagonal 
+    for ( jj = jcol; jj< jcol + panel_size; jj++) 
+    {
+      k = (jj - jcol) * m; // Column index for w-wide arrays 
+      
+      nseg = nseg1; // begin after all the panel segments
+      //Depth-first-search for the current column
+      VectorBlock<IndexVector> panel_lsubk(panel_lsub, k, m);
+      VectorBlock<IndexVector> repfnz_k(repfnz, k, m); 
+      info = Base::column_dfs(m, jj, m_perm_r.indices(), m_perfv.maxsuper, nseg, panel_lsubk, segrep, repfnz_k, xprune, marker, parent, xplore, m_glu); 
+      if ( info ) 
+      {
+        m_lastError =  "UNABLE TO EXPAND MEMORY IN COLUMN_DFS() ";
+        m_info = NumericalIssue; 
+        m_factorizationIsOk = false; 
+        return; 
+      }
+      // Numeric updates to this column 
+      VectorBlock<ScalarVector> dense_k(dense, k, m); 
+      VectorBlock<IndexVector> segrep_k(segrep, nseg1, m-nseg1); 
+      info = Base::column_bmod(jj, (nseg - nseg1), dense_k, tempv, segrep_k, repfnz_k, jcol, m_glu); 
+      if ( info ) 
+      {
+        m_lastError = "UNABLE TO EXPAND MEMORY IN COLUMN_BMOD() ";
+        m_info = NumericalIssue; 
+        m_factorizationIsOk = false; 
+        return; 
+      }
+      
+      // Copy the U-segments to ucol(*)
+      info = Base::copy_to_ucol(jj, nseg, segrep, repfnz_k ,m_perm_r.indices(), dense_k, m_glu); 
+      if ( info ) 
+      {
+        m_lastError = "UNABLE TO EXPAND MEMORY IN COPY_TO_UCOL() ";
+        m_info = NumericalIssue; 
+        m_factorizationIsOk = false; 
+        return; 
+      }
+      
+      // Form the L-segment 
+      info = Base::pivotL(jj, m_diagpivotthresh, m_perm_r.indices(), iperm_c.indices(), pivrow, m_glu);
+      if ( info ) 
+      {
+        m_lastError = "THE MATRIX IS STRUCTURALLY SINGULAR ... ZERO COLUMN AT ";
+        std::ostringstream returnInfo;
+        returnInfo << info; 
+        m_lastError += returnInfo.str();
+        m_info = NumericalIssue; 
+        m_factorizationIsOk = false; 
+        return; 
+      }
+      
+      // Update the determinant of the row permutation matrix
+      // FIXME: the following test is not correct, we should probably take iperm_c into account and pivrow is not directly the row pivot.
+      if (pivrow != jj) m_detPermR = -m_detPermR;
+
+      // Prune columns (0:jj-1) using column jj
+      Base::pruneL(jj, m_perm_r.indices(), pivrow, nseg, segrep, repfnz_k, xprune, m_glu); 
+      
+      // Reset repfnz for this column 
+      for (i = 0; i < nseg; i++)
+      {
+        irep = segrep(i); 
+        repfnz_k(irep) = emptyIdxLU; 
+      }
+    } // end SparseLU within the panel  
+    jcol += panel_size;  // Move to the next panel
+  } // end for -- end elimination 
+  
+  m_detPermR = m_perm_r.determinant();
+  m_detPermC = m_perm_c.determinant();
+  
+  // Count the number of nonzeros in factors 
+  Base::countnz(n, m_nnzL, m_nnzU, m_glu); 
+  // Apply permutation  to the L subscripts 
+  Base::fixupL(n, m_perm_r.indices(), m_glu);
+  
+  // Create supernode matrix L 
+  m_Lstore.setInfos(m, n, m_glu.lusup, m_glu.xlusup, m_glu.lsub, m_glu.xlsub, m_glu.supno, m_glu.xsup); 
+  // Create the column major upper sparse matrix  U; 
+  new (&m_Ustore) MappedSparseMatrix<Scalar, ColMajor, StorageIndex> ( m, n, m_nnzU, m_glu.xusub.data(), m_glu.usub.data(), m_glu.ucol.data() );
+  
+  m_info = Success;
+  m_factorizationIsOk = true;
+}
+
+template<typename MappedSupernodalType>
+struct SparseLUMatrixLReturnType : internal::no_assignment_operator
+{
+  typedef typename MappedSupernodalType::Scalar Scalar;
+  explicit SparseLUMatrixLReturnType(const MappedSupernodalType& mapL) : m_mapL(mapL)
+  { }
+  Index rows() { return m_mapL.rows(); }
+  Index cols() { return m_mapL.cols(); }
+  template<typename Dest>
+  void solveInPlace( MatrixBase<Dest> &X) const
+  {
+    m_mapL.solveInPlace(X);
+  }
+  const MappedSupernodalType& m_mapL;
+};
+
+template<typename MatrixLType, typename MatrixUType>
+struct SparseLUMatrixUReturnType : internal::no_assignment_operator
+{
+  typedef typename MatrixLType::Scalar Scalar;
+  SparseLUMatrixUReturnType(const MatrixLType& mapL, const MatrixUType& mapU)
+  : m_mapL(mapL),m_mapU(mapU)
+  { }
+  Index rows() { return m_mapL.rows(); }
+  Index cols() { return m_mapL.cols(); }
+
+  template<typename Dest>   void solveInPlace(MatrixBase<Dest> &X) const
+  {
+    Index nrhs = X.cols();
+    Index n    = X.rows();
+    // Backward solve with U
+    for (Index k = m_mapL.nsuper(); k >= 0; k--)
+    {
+      Index fsupc = m_mapL.supToCol()[k];
+      Index lda = m_mapL.colIndexPtr()[fsupc+1] - m_mapL.colIndexPtr()[fsupc]; // leading dimension
+      Index nsupc = m_mapL.supToCol()[k+1] - fsupc;
+      Index luptr = m_mapL.colIndexPtr()[fsupc];
+
+      if (nsupc == 1)
+      {
+        for (Index j = 0; j < nrhs; j++)
+        {
+          X(fsupc, j) /= m_mapL.valuePtr()[luptr];
+        }
+      }
+      else
+      {
+        Map<const Matrix<Scalar,Dynamic,Dynamic, ColMajor>, 0, OuterStride<> > A( &(m_mapL.valuePtr()[luptr]), nsupc, nsupc, OuterStride<>(lda) );
+        Map< Matrix<Scalar,Dynamic,Dest::ColsAtCompileTime, ColMajor>, 0, OuterStride<> > U (&(X(fsupc,0)), nsupc, nrhs, OuterStride<>(n) );
+        U = A.template triangularView<Upper>().solve(U);
+      }
+
+      for (Index j = 0; j < nrhs; ++j)
+      {
+        for (Index jcol = fsupc; jcol < fsupc + nsupc; jcol++)
+        {
+          typename MatrixUType::InnerIterator it(m_mapU, jcol);
+          for ( ; it; ++it)
+          {
+            Index irow = it.index();
+            X(irow, j) -= X(jcol, j) * it.value();
+          }
+        }
+      }
+    } // End For U-solve
+  }
+  const MatrixLType& m_mapL;
+  const MatrixUType& m_mapU;
+};
+
+} // End namespace Eigen 
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLUImpl.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLUImpl.h
new file mode 100644
index 00000000..fc0cfc4d
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLUImpl.h
@@ -0,0 +1,66 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#ifndef SPARSELU_IMPL_H
+#define SPARSELU_IMPL_H
+
+namespace Eigen {
+namespace internal {
+  
+/** \ingroup SparseLU_Module
+  * \class SparseLUImpl
+  * Base class for sparseLU
+  */
+template <typename Scalar, typename StorageIndex>
+class SparseLUImpl
+{
+  public:
+    typedef Matrix<Scalar,Dynamic,1> ScalarVector;
+    typedef Matrix<StorageIndex,Dynamic,1> IndexVector; 
+    typedef Matrix<Scalar,Dynamic,Dynamic,ColMajor> ScalarMatrix;
+    typedef Map<ScalarMatrix, 0,  OuterStride<> > MappedMatrixBlock;
+    typedef typename ScalarVector::RealScalar RealScalar; 
+    typedef Ref<Matrix<Scalar,Dynamic,1> > BlockScalarVector;
+    typedef Ref<Matrix<StorageIndex,Dynamic,1> > BlockIndexVector;
+    typedef LU_GlobalLU_t<IndexVector, ScalarVector> GlobalLU_t; 
+    typedef SparseMatrix<Scalar,ColMajor,StorageIndex> MatrixType; 
+    
+  protected:
+     template <typename VectorType>
+     Index expand(VectorType& vec, Index& length, Index nbElts, Index keep_prev, Index& num_expansions);
+     Index memInit(Index m, Index n, Index annz, Index lwork, Index fillratio, Index panel_size,  GlobalLU_t& glu); 
+     template <typename VectorType>
+     Index memXpand(VectorType& vec, Index& maxlen, Index nbElts, MemType memtype, Index& num_expansions);
+     void heap_relax_snode (const Index n, IndexVector& et, const Index relax_columns, IndexVector& descendants, IndexVector& relax_end); 
+     void relax_snode (const Index n, IndexVector& et, const Index relax_columns, IndexVector& descendants, IndexVector& relax_end); 
+     Index snode_dfs(const Index jcol, const Index kcol,const MatrixType& mat,  IndexVector& xprune, IndexVector& marker, GlobalLU_t& glu); 
+     Index snode_bmod (const Index jcol, const Index fsupc, ScalarVector& dense, GlobalLU_t& glu);
+     Index pivotL(const Index jcol, const RealScalar& diagpivotthresh, IndexVector& perm_r, IndexVector& iperm_c, Index& pivrow, GlobalLU_t& glu);
+     template <typename Traits>
+     void dfs_kernel(const StorageIndex jj, IndexVector& perm_r,
+                    Index& nseg, IndexVector& panel_lsub, IndexVector& segrep,
+                    Ref<IndexVector> repfnz_col, IndexVector& xprune, Ref<IndexVector> marker, IndexVector& parent,
+                    IndexVector& xplore, GlobalLU_t& glu, Index& nextl_col, Index krow, Traits& traits);
+     void panel_dfs(const Index m, const Index w, const Index jcol, MatrixType& A, IndexVector& perm_r, Index& nseg, ScalarVector& dense, IndexVector& panel_lsub, IndexVector& segrep, IndexVector& repfnz, IndexVector& xprune, IndexVector& marker, IndexVector& parent, IndexVector& xplore, GlobalLU_t& glu);
+    
+     void panel_bmod(const Index m, const Index w, const Index jcol, const Index nseg, ScalarVector& dense, ScalarVector& tempv, IndexVector& segrep, IndexVector& repfnz, GlobalLU_t& glu);
+     Index column_dfs(const Index m, const Index jcol, IndexVector& perm_r, Index maxsuper, Index& nseg,  BlockIndexVector lsub_col, IndexVector& segrep, BlockIndexVector repfnz, IndexVector& xprune, IndexVector& marker, IndexVector& parent, IndexVector& xplore, GlobalLU_t& glu);
+     Index column_bmod(const Index jcol, const Index nseg, BlockScalarVector dense, ScalarVector& tempv, BlockIndexVector segrep, BlockIndexVector repfnz, Index fpanelc, GlobalLU_t& glu); 
+     Index copy_to_ucol(const Index jcol, const Index nseg, IndexVector& segrep, BlockIndexVector repfnz ,IndexVector& perm_r, BlockScalarVector dense, GlobalLU_t& glu); 
+     void pruneL(const Index jcol, const IndexVector& perm_r, const Index pivrow, const Index nseg, const IndexVector& segrep, BlockIndexVector repfnz, IndexVector& xprune, GlobalLU_t& glu);
+     void countnz(const Index n, Index& nnzL, Index& nnzU, GlobalLU_t& glu); 
+     void fixupL(const Index n, const IndexVector& perm_r, GlobalLU_t& glu); 
+     
+     template<typename , typename >
+     friend struct column_dfs_traits;
+}; 
+
+} // end namespace internal
+} // namespace Eigen
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_Memory.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_Memory.h
new file mode 100644
index 00000000..4dc42e87
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_Memory.h
@@ -0,0 +1,226 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* 
+ 
+ * NOTE: This file is the modified version of [s,d,c,z]memory.c files in SuperLU 
+ 
+ * -- SuperLU routine (version 3.1) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * August 1, 2008
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+
+#ifndef EIGEN_SPARSELU_MEMORY
+#define EIGEN_SPARSELU_MEMORY
+
+namespace Eigen {
+namespace internal {
+  
+enum { LUNoMarker = 3 };
+enum {emptyIdxLU = -1};
+inline Index LUnumTempV(Index& m, Index& w, Index& t, Index& b)
+{
+  return (std::max)(m, (t+b)*w);
+}
+
+template< typename Scalar>
+inline Index LUTempSpace(Index&m, Index& w)
+{
+  return (2*w + 4 + LUNoMarker) * m * sizeof(Index) + (w + 1) * m * sizeof(Scalar);
+}
+
+
+
+
+/** 
+  * Expand the existing storage to accomodate more fill-ins
+  * \param vec Valid pointer to the vector to allocate or expand
+  * \param[in,out] length  At input, contain the current length of the vector that is to be increased. At output, length of the newly allocated vector
+  * \param[in] nbElts Current number of elements in the factors
+  * \param keep_prev  1: use length  and do not expand the vector; 0: compute new_len and expand
+  * \param[in,out] num_expansions Number of times the memory has been expanded
+  */
+template <typename Scalar, typename StorageIndex>
+template <typename VectorType>
+Index  SparseLUImpl<Scalar,StorageIndex>::expand(VectorType& vec, Index& length, Index nbElts, Index keep_prev, Index& num_expansions) 
+{
+  
+  float alpha = 1.5; // Ratio of the memory increase 
+  Index new_len; // New size of the allocated memory
+  
+  if(num_expansions == 0 || keep_prev) 
+    new_len = length ; // First time allocate requested
+  else 
+    new_len = (std::max)(length+1,Index(alpha * length));
+  
+  VectorType old_vec; // Temporary vector to hold the previous values   
+  if (nbElts > 0 )
+    old_vec = vec.segment(0,nbElts); 
+  
+  //Allocate or expand the current vector
+#ifdef EIGEN_EXCEPTIONS
+  try
+#endif
+  {
+    vec.resize(new_len); 
+  }
+#ifdef EIGEN_EXCEPTIONS
+  catch(std::bad_alloc& )
+#else
+  if(!vec.size())
+#endif
+  {
+    if (!num_expansions)
+    {
+      // First time to allocate from LUMemInit()
+      // Let LUMemInit() deals with it.
+      return -1;
+    }
+    if (keep_prev)
+    {
+      // In this case, the memory length should not not be reduced
+      return new_len;
+    }
+    else 
+    {
+      // Reduce the size and increase again 
+      Index tries = 0; // Number of attempts
+      do 
+      {
+        alpha = (alpha + 1)/2;
+        new_len = (std::max)(length+1,Index(alpha * length));
+#ifdef EIGEN_EXCEPTIONS
+        try
+#endif
+        {
+          vec.resize(new_len); 
+        }
+#ifdef EIGEN_EXCEPTIONS
+        catch(std::bad_alloc& )
+#else
+        if (!vec.size())
+#endif
+        {
+          tries += 1; 
+          if ( tries > 10) return new_len; 
+        }
+      } while (!vec.size());
+    }
+  }
+  //Copy the previous values to the newly allocated space 
+  if (nbElts > 0)
+    vec.segment(0, nbElts) = old_vec;   
+   
+  
+  length  = new_len;
+  if(num_expansions) ++num_expansions;
+  return 0; 
+}
+
+/**
+ * \brief  Allocate various working space for the numerical factorization phase.
+ * \param m number of rows of the input matrix 
+ * \param n number of columns 
+ * \param annz number of initial nonzeros in the matrix 
+ * \param lwork  if lwork=-1, this routine returns an estimated size of the required memory
+ * \param glu persistent data to facilitate multiple factors : will be deleted later ??
+ * \param fillratio estimated ratio of fill in the factors
+ * \param panel_size Size of a panel
+ * \return an estimated size of the required memory if lwork = -1; otherwise, return the size of actually allocated memory when allocation failed, and 0 on success
+ * \note Unlike SuperLU, this routine does not support successive factorization with the same pattern and the same row permutation
+ */
+template <typename Scalar, typename StorageIndex>
+Index SparseLUImpl<Scalar,StorageIndex>::memInit(Index m, Index n, Index annz, Index lwork, Index fillratio, Index panel_size,  GlobalLU_t& glu)
+{
+  Index& num_expansions = glu.num_expansions; //No memory expansions so far
+  num_expansions = 0;
+  glu.nzumax = glu.nzlumax = (std::min)(fillratio * (annz+1) / n, m) * n; // estimated number of nonzeros in U 
+  glu.nzlmax = (std::max)(Index(4), fillratio) * (annz+1) / 4; // estimated  nnz in L factor
+  // Return the estimated size to the user if necessary
+  Index tempSpace;
+  tempSpace = (2*panel_size + 4 + LUNoMarker) * m * sizeof(Index) + (panel_size + 1) * m * sizeof(Scalar);
+  if (lwork == emptyIdxLU) 
+  {
+    Index estimated_size;
+    estimated_size = (5 * n + 5) * sizeof(Index)  + tempSpace
+                    + (glu.nzlmax + glu.nzumax) * sizeof(Index) + (glu.nzlumax+glu.nzumax) *  sizeof(Scalar) + n; 
+    return estimated_size;
+  }
+  
+  // Setup the required space 
+  
+  // First allocate Integer pointers for L\U factors
+  glu.xsup.resize(n+1);
+  glu.supno.resize(n+1);
+  glu.xlsub.resize(n+1);
+  glu.xlusup.resize(n+1);
+  glu.xusub.resize(n+1);
+
+  // Reserve memory for L/U factors
+  do 
+  {
+    if(     (expand<ScalarVector>(glu.lusup, glu.nzlumax, 0, 0, num_expansions)<0)
+        ||  (expand<ScalarVector>(glu.ucol,  glu.nzumax,  0, 0, num_expansions)<0)
+        ||  (expand<IndexVector> (glu.lsub,  glu.nzlmax,  0, 0, num_expansions)<0)
+        ||  (expand<IndexVector> (glu.usub,  glu.nzumax,  0, 1, num_expansions)<0) )
+    {
+      //Reduce the estimated size and retry
+      glu.nzlumax /= 2;
+      glu.nzumax /= 2;
+      glu.nzlmax /= 2;
+      if (glu.nzlumax < annz ) return glu.nzlumax; 
+    }
+  } while (!glu.lusup.size() || !glu.ucol.size() || !glu.lsub.size() || !glu.usub.size());
+  
+  ++num_expansions;
+  return 0;
+  
+} // end LuMemInit
+
+/** 
+ * \brief Expand the existing storage 
+ * \param vec vector to expand 
+ * \param[in,out] maxlen On input, previous size of vec (Number of elements to copy ). on output, new size
+ * \param nbElts current number of elements in the vector.
+ * \param memtype Type of the element to expand
+ * \param num_expansions Number of expansions 
+ * \return 0 on success, > 0 size of the memory allocated so far
+ */
+template <typename Scalar, typename StorageIndex>
+template <typename VectorType>
+Index SparseLUImpl<Scalar,StorageIndex>::memXpand(VectorType& vec, Index& maxlen, Index nbElts, MemType memtype, Index& num_expansions)
+{
+  Index failed_size; 
+  if (memtype == USUB)
+     failed_size = this->expand<VectorType>(vec, maxlen, nbElts, 1, num_expansions);
+  else
+    failed_size = this->expand<VectorType>(vec, maxlen, nbElts, 0, num_expansions);
+
+  if (failed_size)
+    return failed_size; 
+  
+  return 0 ;  
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+#endif // EIGEN_SPARSELU_MEMORY
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_Structs.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_Structs.h
new file mode 100644
index 00000000..cf5ec449
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_Structs.h
@@ -0,0 +1,110 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* 
+ * NOTE: This file comes from a partly modified version of files slu_[s,d,c,z]defs.h
+ * -- SuperLU routine (version 4.1) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * November, 2010
+ * 
+ * Global data structures used in LU factorization -
+ * 
+ *   nsuper: #supernodes = nsuper + 1, numbered [0, nsuper].
+ *   (xsup,supno): supno[i] is the supernode no to which i belongs;
+ *  xsup(s) points to the beginning of the s-th supernode.
+ *  e.g.   supno 0 1 2 2 3 3 3 4 4 4 4 4   (n=12)
+ *          xsup 0 1 2 4 7 12
+ *  Note: dfs will be performed on supernode rep. relative to the new 
+ *        row pivoting ordering
+ *
+ *   (xlsub,lsub): lsub[*] contains the compressed subscript of
+ *  rectangular supernodes; xlsub[j] points to the starting
+ *  location of the j-th column in lsub[*]. Note that xlsub 
+ *  is indexed by column.
+ *  Storage: original row subscripts
+ *
+ *      During the course of sparse LU factorization, we also use
+ *  (xlsub,lsub) for the purpose of symmetric pruning. For each
+ *  supernode {s,s+1,...,t=s+r} with first column s and last
+ *  column t, the subscript set
+ *    lsub[j], j=xlsub[s], .., xlsub[s+1]-1
+ *  is the structure of column s (i.e. structure of this supernode).
+ *  It is used for the storage of numerical values.
+ *  Furthermore,
+ *    lsub[j], j=xlsub[t], .., xlsub[t+1]-1
+ *  is the structure of the last column t of this supernode.
+ *  It is for the purpose of symmetric pruning. Therefore, the
+ *  structural subscripts can be rearranged without making physical
+ *  interchanges among the numerical values.
+ *
+ *  However, if the supernode has only one column, then we
+ *  only keep one set of subscripts. For any subscript interchange
+ *  performed, similar interchange must be done on the numerical
+ *  values.
+ *
+ *  The last column structures (for pruning) will be removed
+ *  after the numercial LU factorization phase.
+ *
+ *   (xlusup,lusup): lusup[*] contains the numerical values of the
+ *  rectangular supernodes; xlusup[j] points to the starting
+ *  location of the j-th column in storage vector lusup[*]
+ *  Note: xlusup is indexed by column.
+ *  Each rectangular supernode is stored by column-major
+ *  scheme, consistent with Fortran 2-dim array storage.
+ *
+ *   (xusub,ucol,usub): ucol[*] stores the numerical values of
+ *  U-columns outside the rectangular supernodes. The row
+ *  subscript of nonzero ucol[k] is stored in usub[k].
+ *  xusub[i] points to the starting location of column i in ucol.
+ *  Storage: new row subscripts; that is subscripts of PA.
+ */
+
+#ifndef EIGEN_LU_STRUCTS
+#define EIGEN_LU_STRUCTS
+namespace Eigen {
+namespace internal {
+  
+typedef enum {LUSUP, UCOL, LSUB, USUB, LLVL, ULVL} MemType; 
+
+template <typename IndexVector, typename ScalarVector>
+struct LU_GlobalLU_t {
+  typedef typename IndexVector::Scalar StorageIndex; 
+  IndexVector xsup; //First supernode column ... xsup(s) points to the beginning of the s-th supernode
+  IndexVector supno; // Supernode number corresponding to this column (column to supernode mapping)
+  ScalarVector  lusup; // nonzero values of L ordered by columns 
+  IndexVector lsub; // Compressed row indices of L rectangular supernodes. 
+  IndexVector xlusup; // pointers to the beginning of each column in lusup
+  IndexVector xlsub; // pointers to the beginning of each column in lsub
+  Index   nzlmax; // Current max size of lsub
+  Index   nzlumax; // Current max size of lusup
+  ScalarVector  ucol; // nonzero values of U ordered by columns 
+  IndexVector usub; // row indices of U columns in ucol
+  IndexVector xusub; // Pointers to the beginning of each column of U in ucol 
+  Index   nzumax; // Current max size of ucol
+  Index   n; // Number of columns in the matrix  
+  Index   num_expansions; 
+};
+
+// Values to set for performance
+struct perfvalues {
+  Index panel_size; // a panel consists of at most <panel_size> consecutive columns
+  Index relax; // To control degree of relaxing supernodes. If the number of nodes (columns) 
+                // in a subtree of the elimination tree is less than relax, this subtree is considered 
+                // as one supernode regardless of the row structures of those columns
+  Index maxsuper; // The maximum size for a supernode in complete LU
+  Index rowblk; // The minimum row dimension for 2-D blocking to be used;
+  Index colblk; // The minimum column dimension for 2-D blocking to be used;
+  Index fillfactor; // The estimated fills factors for L and U, compared with A
+}; 
+
+} // end namespace internal
+
+} // end namespace Eigen
+#endif // EIGEN_LU_STRUCTS
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_SupernodalMatrix.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_SupernodalMatrix.h
new file mode 100644
index 00000000..721e1883
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_SupernodalMatrix.h
@@ -0,0 +1,301 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+// Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSELU_SUPERNODAL_MATRIX_H
+#define EIGEN_SPARSELU_SUPERNODAL_MATRIX_H
+
+namespace Eigen {
+namespace internal {
+
+/** \ingroup SparseLU_Module
+ * \brief a class to manipulate the L supernodal factor from the SparseLU factorization
+ * 
+ * This class  contain the data to easily store 
+ * and manipulate the supernodes during the factorization and solution phase of Sparse LU. 
+ * Only the lower triangular matrix has supernodes.
+ * 
+ * NOTE : This class corresponds to the SCformat structure in SuperLU
+ * 
+ */
+/* TODO
+ * InnerIterator as for sparsematrix 
+ * SuperInnerIterator to iterate through all supernodes 
+ * Function for triangular solve
+ */
+template <typename _Scalar, typename _StorageIndex>
+class MappedSuperNodalMatrix
+{
+  public:
+    typedef _Scalar Scalar; 
+    typedef _StorageIndex StorageIndex;
+    typedef Matrix<StorageIndex,Dynamic,1> IndexVector;
+    typedef Matrix<Scalar,Dynamic,1> ScalarVector;
+  public:
+    MappedSuperNodalMatrix()
+    {
+      
+    }
+    MappedSuperNodalMatrix(Index m, Index n,  ScalarVector& nzval, IndexVector& nzval_colptr, IndexVector& rowind,
+             IndexVector& rowind_colptr, IndexVector& col_to_sup, IndexVector& sup_to_col )
+    {
+      setInfos(m, n, nzval, nzval_colptr, rowind, rowind_colptr, col_to_sup, sup_to_col);
+    }
+    
+    ~MappedSuperNodalMatrix()
+    {
+      
+    }
+    /**
+     * Set appropriate pointers for the lower triangular supernodal matrix
+     * These infos are available at the end of the numerical factorization
+     * FIXME This class will be modified such that it can be use in the course 
+     * of the factorization.
+     */
+    void setInfos(Index m, Index n, ScalarVector& nzval, IndexVector& nzval_colptr, IndexVector& rowind,
+             IndexVector& rowind_colptr, IndexVector& col_to_sup, IndexVector& sup_to_col )
+    {
+      m_row = m;
+      m_col = n; 
+      m_nzval = nzval.data(); 
+      m_nzval_colptr = nzval_colptr.data(); 
+      m_rowind = rowind.data(); 
+      m_rowind_colptr = rowind_colptr.data(); 
+      m_nsuper = col_to_sup(n); 
+      m_col_to_sup = col_to_sup.data(); 
+      m_sup_to_col = sup_to_col.data(); 
+    }
+    
+    /**
+     * Number of rows
+     */
+    Index rows() { return m_row; }
+    
+    /**
+     * Number of columns
+     */
+    Index cols() { return m_col; }
+    
+    /**
+     * Return the array of nonzero values packed by column
+     * 
+     * The size is nnz
+     */
+    Scalar* valuePtr() {  return m_nzval; }
+    
+    const Scalar* valuePtr() const 
+    {
+      return m_nzval; 
+    }
+    /**
+     * Return the pointers to the beginning of each column in \ref valuePtr()
+     */
+    StorageIndex* colIndexPtr()
+    {
+      return m_nzval_colptr; 
+    }
+    
+    const StorageIndex* colIndexPtr() const
+    {
+      return m_nzval_colptr; 
+    }
+    
+    /**
+     * Return the array of compressed row indices of all supernodes
+     */
+    StorageIndex* rowIndex()  { return m_rowind; }
+    
+    const StorageIndex* rowIndex() const
+    {
+      return m_rowind; 
+    }
+    
+    /**
+     * Return the location in \em rowvaluePtr() which starts each column
+     */
+    StorageIndex* rowIndexPtr() { return m_rowind_colptr; }
+    
+    const StorageIndex* rowIndexPtr() const
+    {
+      return m_rowind_colptr; 
+    }
+    
+    /** 
+     * Return the array of column-to-supernode mapping 
+     */
+    StorageIndex* colToSup()  { return m_col_to_sup; }
+    
+    const StorageIndex* colToSup() const
+    {
+      return m_col_to_sup;       
+    }
+    /**
+     * Return the array of supernode-to-column mapping
+     */
+    StorageIndex* supToCol() { return m_sup_to_col; }
+    
+    const StorageIndex* supToCol() const
+    {
+      return m_sup_to_col;
+    }
+    
+    /**
+     * Return the number of supernodes
+     */
+    Index nsuper() const
+    {
+      return m_nsuper; 
+    }
+    
+    class InnerIterator; 
+    template<typename Dest>
+    void solveInPlace( MatrixBase<Dest>&X) const;
+    
+      
+      
+    
+  protected:
+    Index m_row; // Number of rows
+    Index m_col; // Number of columns
+    Index m_nsuper; // Number of supernodes
+    Scalar* m_nzval; //array of nonzero values packed by column
+    StorageIndex* m_nzval_colptr; //nzval_colptr[j] Stores the location in nzval[] which starts column j
+    StorageIndex* m_rowind; // Array of compressed row indices of rectangular supernodes
+    StorageIndex* m_rowind_colptr; //rowind_colptr[j] stores the location in rowind[] which starts column j
+    StorageIndex* m_col_to_sup; // col_to_sup[j] is the supernode number to which column j belongs
+    StorageIndex* m_sup_to_col; //sup_to_col[s] points to the starting column of the s-th supernode
+    
+  private :
+};
+
+/**
+  * \brief InnerIterator class to iterate over nonzero values of the current column in the supernodal matrix L
+  * 
+  */
+template<typename Scalar, typename StorageIndex>
+class MappedSuperNodalMatrix<Scalar,StorageIndex>::InnerIterator
+{
+  public:
+     InnerIterator(const MappedSuperNodalMatrix& mat, Index outer)
+      : m_matrix(mat),
+        m_outer(outer),
+        m_supno(mat.colToSup()[outer]),
+        m_idval(mat.colIndexPtr()[outer]),
+        m_startidval(m_idval),
+        m_endidval(mat.colIndexPtr()[outer+1]),
+        m_idrow(mat.rowIndexPtr()[mat.supToCol()[mat.colToSup()[outer]]]),
+        m_endidrow(mat.rowIndexPtr()[mat.supToCol()[mat.colToSup()[outer]]+1])
+    {}
+    inline InnerIterator& operator++()
+    { 
+      m_idval++; 
+      m_idrow++;
+      return *this;
+    }
+    inline Scalar value() const { return m_matrix.valuePtr()[m_idval]; }
+    
+    inline Scalar& valueRef() { return const_cast<Scalar&>(m_matrix.valuePtr()[m_idval]); }
+    
+    inline Index index() const { return m_matrix.rowIndex()[m_idrow]; }
+    inline Index row() const { return index(); }
+    inline Index col() const { return m_outer; }
+    
+    inline Index supIndex() const { return m_supno; }
+    
+    inline operator bool() const 
+    { 
+      return ( (m_idval < m_endidval) && (m_idval >= m_startidval)
+                && (m_idrow < m_endidrow) );
+    }
+    
+  protected:
+    const MappedSuperNodalMatrix& m_matrix; // Supernodal lower triangular matrix 
+    const Index m_outer;                    // Current column 
+    const Index m_supno;                    // Current SuperNode number
+    Index m_idval;                          // Index to browse the values in the current column
+    const Index m_startidval;               // Start of the column value
+    const Index m_endidval;                 // End of the column value
+    Index m_idrow;                          // Index to browse the row indices 
+    Index m_endidrow;                       // End index of row indices of the current column
+};
+
+/**
+ * \brief Solve with the supernode triangular matrix
+ * 
+ */
+template<typename Scalar, typename Index_>
+template<typename Dest>
+void MappedSuperNodalMatrix<Scalar,Index_>::solveInPlace( MatrixBase<Dest>&X) const
+{
+    /* Explicit type conversion as the Index type of MatrixBase<Dest> may be wider than Index */
+//    eigen_assert(X.rows() <= NumTraits<Index>::highest());
+//    eigen_assert(X.cols() <= NumTraits<Index>::highest());
+    Index n    = int(X.rows());
+    Index nrhs = Index(X.cols());
+    const Scalar * Lval = valuePtr();                 // Nonzero values 
+    Matrix<Scalar,Dynamic,Dest::ColsAtCompileTime, ColMajor> work(n, nrhs);     // working vector
+    work.setZero();
+    for (Index k = 0; k <= nsuper(); k ++)
+    {
+      Index fsupc = supToCol()[k];                    // First column of the current supernode 
+      Index istart = rowIndexPtr()[fsupc];            // Pointer index to the subscript of the current column
+      Index nsupr = rowIndexPtr()[fsupc+1] - istart;  // Number of rows in the current supernode
+      Index nsupc = supToCol()[k+1] - fsupc;          // Number of columns in the current supernode
+      Index nrow = nsupr - nsupc;                     // Number of rows in the non-diagonal part of the supernode
+      Index irow;                                     //Current index row
+      
+      if (nsupc == 1 )
+      {
+        for (Index j = 0; j < nrhs; j++)
+        {
+          InnerIterator it(*this, fsupc);
+          ++it; // Skip the diagonal element
+          for (; it; ++it)
+          {
+            irow = it.row();
+            X(irow, j) -= X(fsupc, j) * it.value();
+          }
+        }
+      }
+      else
+      {
+        // The supernode has more than one column 
+        Index luptr = colIndexPtr()[fsupc]; 
+        Index lda = colIndexPtr()[fsupc+1] - luptr;
+        
+        // Triangular solve 
+        Map<const Matrix<Scalar,Dynamic,Dynamic, ColMajor>, 0, OuterStride<> > A( &(Lval[luptr]), nsupc, nsupc, OuterStride<>(lda) );
+        Map< Matrix<Scalar,Dynamic,Dest::ColsAtCompileTime, ColMajor>, 0, OuterStride<> > U (&(X(fsupc,0)), nsupc, nrhs, OuterStride<>(n) );
+        U = A.template triangularView<UnitLower>().solve(U); 
+        
+        // Matrix-vector product 
+        new (&A) Map<const Matrix<Scalar,Dynamic,Dynamic, ColMajor>, 0, OuterStride<> > ( &(Lval[luptr+nsupc]), nrow, nsupc, OuterStride<>(lda) );
+        work.topRows(nrow).noalias() = A * U;
+        
+        //Begin Scatter 
+        for (Index j = 0; j < nrhs; j++)
+        {
+          Index iptr = istart + nsupc; 
+          for (Index i = 0; i < nrow; i++)
+          {
+            irow = rowIndex()[iptr]; 
+            X(irow, j) -= work(i, j); // Scatter operation
+            work(i, j) = Scalar(0); 
+            iptr++;
+          }
+        }
+      }
+    } 
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSELU_MATRIX_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_Utils.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_Utils.h
new file mode 100644
index 00000000..9e3dab44
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_Utils.h
@@ -0,0 +1,80 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+#ifndef EIGEN_SPARSELU_UTILS_H
+#define EIGEN_SPARSELU_UTILS_H
+
+namespace Eigen {
+namespace internal {
+
+/**
+ * \brief Count Nonzero elements in the factors
+ */
+template <typename Scalar, typename StorageIndex>
+void SparseLUImpl<Scalar,StorageIndex>::countnz(const Index n, Index& nnzL, Index& nnzU, GlobalLU_t& glu)
+{
+ nnzL = 0; 
+ nnzU = (glu.xusub)(n); 
+ Index nsuper = (glu.supno)(n); 
+ Index jlen; 
+ Index i, j, fsupc;
+ if (n <= 0 ) return; 
+ // For each supernode
+ for (i = 0; i <= nsuper; i++)
+ {
+   fsupc = glu.xsup(i); 
+   jlen = glu.xlsub(fsupc+1) - glu.xlsub(fsupc); 
+   
+   for (j = fsupc; j < glu.xsup(i+1); j++)
+   {
+     nnzL += jlen; 
+     nnzU += j - fsupc + 1; 
+     jlen--; 
+   }
+ }
+}
+
+/**
+ * \brief Fix up the data storage lsub for L-subscripts. 
+ * 
+ * It removes the subscripts sets for structural pruning, 
+ * and applies permutation to the remaining subscripts
+ * 
+ */
+template <typename Scalar, typename StorageIndex>
+void SparseLUImpl<Scalar,StorageIndex>::fixupL(const Index n, const IndexVector& perm_r, GlobalLU_t& glu)
+{
+  Index fsupc, i, j, k, jstart; 
+  
+  StorageIndex nextl = 0; 
+  Index nsuper = (glu.supno)(n); 
+  
+  // For each supernode 
+  for (i = 0; i <= nsuper; i++)
+  {
+    fsupc = glu.xsup(i); 
+    jstart = glu.xlsub(fsupc); 
+    glu.xlsub(fsupc) = nextl; 
+    for (j = jstart; j < glu.xlsub(fsupc + 1); j++)
+    {
+      glu.lsub(nextl) = perm_r(glu.lsub(j)); // Now indexed into P*A
+      nextl++;
+    }
+    for (k = fsupc+1; k < glu.xsup(i+1); k++)
+      glu.xlsub(k) = nextl; // other columns in supernode i
+  }
+  
+  glu.xlsub(n) = nextl; 
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+#endif // EIGEN_SPARSELU_UTILS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_column_bmod.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_column_bmod.h
new file mode 100644
index 00000000..b57f0680
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_column_bmod.h
@@ -0,0 +1,181 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+// Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* 
+ 
+ * NOTE: This file is the modified version of xcolumn_bmod.c file in SuperLU 
+ 
+ * -- SuperLU routine (version 3.0) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * October 15, 2003
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+#ifndef SPARSELU_COLUMN_BMOD_H
+#define SPARSELU_COLUMN_BMOD_H
+
+namespace Eigen {
+
+namespace internal {
+/**
+ * \brief Performs numeric block updates (sup-col) in topological order
+ * 
+ * \param jcol current column to update
+ * \param nseg Number of segments in the U part
+ * \param dense Store the full representation of the column
+ * \param tempv working array 
+ * \param segrep segment representative ...
+ * \param repfnz ??? First nonzero column in each row ???  ...
+ * \param fpanelc First column in the current panel
+ * \param glu Global LU data. 
+ * \return 0 - successful return 
+ *         > 0 - number of bytes allocated when run out of space
+ * 
+ */
+template <typename Scalar, typename StorageIndex>
+Index SparseLUImpl<Scalar,StorageIndex>::column_bmod(const Index jcol, const Index nseg, BlockScalarVector dense, ScalarVector& tempv,
+                                                     BlockIndexVector segrep, BlockIndexVector repfnz, Index fpanelc, GlobalLU_t& glu)
+{
+  Index  jsupno, k, ksub, krep, ksupno; 
+  Index lptr, nrow, isub, irow, nextlu, new_next, ufirst; 
+  Index fsupc, nsupc, nsupr, luptr, kfnz, no_zeros; 
+  /* krep = representative of current k-th supernode
+    * fsupc =  first supernodal column
+    * nsupc = number of columns in a supernode
+    * nsupr = number of rows in a supernode
+    * luptr = location of supernodal LU-block in storage
+    * kfnz = first nonz in the k-th supernodal segment
+    * no_zeros = no lf leading zeros in a supernodal U-segment
+    */
+  
+  jsupno = glu.supno(jcol);
+  // For each nonzero supernode segment of U[*,j] in topological order 
+  k = nseg - 1; 
+  Index d_fsupc; // distance between the first column of the current panel and the 
+               // first column of the current snode
+  Index fst_col; // First column within small LU update
+  Index segsize; 
+  for (ksub = 0; ksub < nseg; ksub++)
+  {
+    krep = segrep(k); k--; 
+    ksupno = glu.supno(krep); 
+    if (jsupno != ksupno )
+    {
+      // outside the rectangular supernode 
+      fsupc = glu.xsup(ksupno); 
+      fst_col = (std::max)(fsupc, fpanelc); 
+      
+      // Distance from the current supernode to the current panel; 
+      // d_fsupc = 0 if fsupc > fpanelc
+      d_fsupc = fst_col - fsupc; 
+      
+      luptr = glu.xlusup(fst_col) + d_fsupc; 
+      lptr = glu.xlsub(fsupc) + d_fsupc; 
+      
+      kfnz = repfnz(krep); 
+      kfnz = (std::max)(kfnz, fpanelc); 
+      
+      segsize = krep - kfnz + 1; 
+      nsupc = krep - fst_col + 1; 
+      nsupr = glu.xlsub(fsupc+1) - glu.xlsub(fsupc); 
+      nrow = nsupr - d_fsupc - nsupc;
+      Index lda = glu.xlusup(fst_col+1) - glu.xlusup(fst_col);
+      
+      
+      // Perform a triangular solver and block update, 
+      // then scatter the result of sup-col update to dense
+      no_zeros = kfnz - fst_col; 
+      if(segsize==1)
+        LU_kernel_bmod<1>::run(segsize, dense, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros);
+      else
+        LU_kernel_bmod<Dynamic>::run(segsize, dense, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros);
+    } // end if jsupno 
+  } // end for each segment
+  
+  // Process the supernodal portion of  L\U[*,j]
+  nextlu = glu.xlusup(jcol); 
+  fsupc = glu.xsup(jsupno);
+  
+  // copy the SPA dense into L\U[*,j]
+  Index mem; 
+  new_next = nextlu + glu.xlsub(fsupc + 1) - glu.xlsub(fsupc); 
+  Index offset = internal::first_multiple<Index>(new_next, internal::packet_traits<Scalar>::size) - new_next;
+  if(offset)
+    new_next += offset;
+  while (new_next > glu.nzlumax )
+  {
+    mem = memXpand<ScalarVector>(glu.lusup, glu.nzlumax, nextlu, LUSUP, glu.num_expansions);  
+    if (mem) return mem; 
+  }
+  
+  for (isub = glu.xlsub(fsupc); isub < glu.xlsub(fsupc+1); isub++)
+  {
+    irow = glu.lsub(isub);
+    glu.lusup(nextlu) = dense(irow);
+    dense(irow) = Scalar(0.0); 
+    ++nextlu; 
+  }
+  
+  if(offset)
+  {
+    glu.lusup.segment(nextlu,offset).setZero();
+    nextlu += offset;
+  }
+  glu.xlusup(jcol + 1) = StorageIndex(nextlu);  // close L\U(*,jcol); 
+  
+  /* For more updates within the panel (also within the current supernode),
+   * should start from the first column of the panel, or the first column
+   * of the supernode, whichever is bigger. There are two cases:
+   *  1) fsupc < fpanelc, then fst_col <-- fpanelc
+   *  2) fsupc >= fpanelc, then fst_col <-- fsupc
+   */
+  fst_col = (std::max)(fsupc, fpanelc); 
+  
+  if (fst_col  < jcol)
+  {
+    // Distance between the current supernode and the current panel
+    // d_fsupc = 0 if fsupc >= fpanelc
+    d_fsupc = fst_col - fsupc; 
+    
+    lptr = glu.xlsub(fsupc) + d_fsupc; 
+    luptr = glu.xlusup(fst_col) + d_fsupc; 
+    nsupr = glu.xlsub(fsupc+1) - glu.xlsub(fsupc); // leading dimension
+    nsupc = jcol - fst_col; // excluding jcol 
+    nrow = nsupr - d_fsupc - nsupc; 
+    
+    // points to the beginning of jcol in snode L\U(jsupno) 
+    ufirst = glu.xlusup(jcol) + d_fsupc; 
+    Index lda = glu.xlusup(jcol+1) - glu.xlusup(jcol);
+    MappedMatrixBlock A( &(glu.lusup.data()[luptr]), nsupc, nsupc, OuterStride<>(lda) );
+    VectorBlock<ScalarVector> u(glu.lusup, ufirst, nsupc); 
+    u = A.template triangularView<UnitLower>().solve(u); 
+    
+    new (&A) MappedMatrixBlock ( &(glu.lusup.data()[luptr+nsupc]), nrow, nsupc, OuterStride<>(lda) );
+    VectorBlock<ScalarVector> l(glu.lusup, ufirst+nsupc, nrow); 
+    l.noalias() -= A * u;
+    
+  } // End if fst_col
+  return 0; 
+}
+
+} // end namespace internal
+} // end namespace Eigen
+
+#endif // SPARSELU_COLUMN_BMOD_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_column_dfs.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_column_dfs.h
new file mode 100644
index 00000000..c98b30e3
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_column_dfs.h
@@ -0,0 +1,179 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* 
+ 
+ * NOTE: This file is the modified version of [s,d,c,z]column_dfs.c file in SuperLU 
+ 
+ * -- SuperLU routine (version 2.0) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * November 15, 1997
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+#ifndef SPARSELU_COLUMN_DFS_H
+#define SPARSELU_COLUMN_DFS_H
+
+template <typename Scalar, typename StorageIndex> class SparseLUImpl;
+namespace Eigen {
+
+namespace internal {
+
+template<typename IndexVector, typename ScalarVector>
+struct column_dfs_traits : no_assignment_operator
+{
+  typedef typename ScalarVector::Scalar Scalar;
+  typedef typename IndexVector::Scalar StorageIndex;
+  column_dfs_traits(Index jcol, Index& jsuper, typename SparseLUImpl<Scalar, StorageIndex>::GlobalLU_t& glu, SparseLUImpl<Scalar, StorageIndex>& luImpl)
+   : m_jcol(jcol), m_jsuper_ref(jsuper), m_glu(glu), m_luImpl(luImpl)
+ {}
+  bool update_segrep(Index /*krep*/, Index /*jj*/)
+  {
+    return true;
+  }
+  void mem_expand(IndexVector& lsub, Index& nextl, Index chmark)
+  {
+    if (nextl >= m_glu.nzlmax)
+      m_luImpl.memXpand(lsub, m_glu.nzlmax, nextl, LSUB, m_glu.num_expansions); 
+    if (chmark != (m_jcol-1)) m_jsuper_ref = emptyIdxLU;
+  }
+  enum { ExpandMem = true };
+  
+  Index m_jcol;
+  Index& m_jsuper_ref;
+  typename SparseLUImpl<Scalar, StorageIndex>::GlobalLU_t& m_glu;
+  SparseLUImpl<Scalar, StorageIndex>& m_luImpl;
+};
+
+
+/**
+ * \brief Performs a symbolic factorization on column jcol and decide the supernode boundary
+ * 
+ * A supernode representative is the last column of a supernode.
+ * The nonzeros in U[*,j] are segments that end at supernodes representatives. 
+ * The routine returns a list of the supernodal representatives 
+ * in topological order of the dfs that generates them. 
+ * The location of the first nonzero in each supernodal segment 
+ * (supernodal entry location) is also returned. 
+ * 
+ * \param m number of rows in the matrix
+ * \param jcol Current column 
+ * \param perm_r Row permutation
+ * \param maxsuper  Maximum number of column allowed in a supernode
+ * \param [in,out] nseg Number of segments in current U[*,j] - new segments appended
+ * \param lsub_col defines the rhs vector to start the dfs
+ * \param [in,out] segrep Segment representatives - new segments appended 
+ * \param repfnz  First nonzero location in each row
+ * \param xprune 
+ * \param marker  marker[i] == jj, if i was visited during dfs of current column jj;
+ * \param parent
+ * \param xplore working array
+ * \param glu global LU data 
+ * \return 0 success
+ *         > 0 number of bytes allocated when run out of space
+ * 
+ */
+template <typename Scalar, typename StorageIndex>
+Index SparseLUImpl<Scalar,StorageIndex>::column_dfs(const Index m, const Index jcol, IndexVector& perm_r, Index maxsuper, Index& nseg,
+                                                    BlockIndexVector lsub_col, IndexVector& segrep, BlockIndexVector repfnz, IndexVector& xprune,
+                                                    IndexVector& marker, IndexVector& parent, IndexVector& xplore, GlobalLU_t& glu)
+{
+  
+  Index jsuper = glu.supno(jcol); 
+  Index nextl = glu.xlsub(jcol); 
+  VectorBlock<IndexVector> marker2(marker, 2*m, m); 
+  
+  
+  column_dfs_traits<IndexVector, ScalarVector> traits(jcol, jsuper, glu, *this);
+  
+  // For each nonzero in A(*,jcol) do dfs 
+  for (Index k = 0; ((k < m) ? lsub_col[k] != emptyIdxLU : false) ; k++)
+  {
+    Index krow = lsub_col(k); 
+    lsub_col(k) = emptyIdxLU; 
+    Index kmark = marker2(krow); 
+    
+    // krow was visited before, go to the next nonz; 
+    if (kmark == jcol) continue;
+    
+    dfs_kernel(StorageIndex(jcol), perm_r, nseg, glu.lsub, segrep, repfnz, xprune, marker2, parent,
+                   xplore, glu, nextl, krow, traits);
+  } // for each nonzero ... 
+  
+  Index fsupc;
+  StorageIndex nsuper = glu.supno(jcol);
+  StorageIndex jcolp1 = StorageIndex(jcol) + 1;
+  Index jcolm1 = jcol - 1;
+  
+  // check to see if j belongs in the same supernode as j-1
+  if ( jcol == 0 )
+  { // Do nothing for column 0 
+    nsuper = glu.supno(0) = 0 ;
+  }
+  else 
+  {
+    fsupc = glu.xsup(nsuper); 
+    StorageIndex jptr = glu.xlsub(jcol); // Not yet compressed
+    StorageIndex jm1ptr = glu.xlsub(jcolm1); 
+    
+    // Use supernodes of type T2 : see SuperLU paper
+    if ( (nextl-jptr != jptr-jm1ptr-1) ) jsuper = emptyIdxLU;
+    
+    // Make sure the number of columns in a supernode doesn't
+    // exceed threshold
+    if ( (jcol - fsupc) >= maxsuper) jsuper = emptyIdxLU; 
+    
+    /* If jcol starts a new supernode, reclaim storage space in
+     * glu.lsub from previous supernode. Note we only store 
+     * the subscript set of the first and last columns of 
+     * a supernode. (first for num values, last for pruning)
+     */
+    if (jsuper == emptyIdxLU)
+    { // starts a new supernode 
+      if ( (fsupc < jcolm1-1) ) 
+      { // >= 3 columns in nsuper
+        StorageIndex ito = glu.xlsub(fsupc+1);
+        glu.xlsub(jcolm1) = ito; 
+        StorageIndex istop = ito + jptr - jm1ptr; 
+        xprune(jcolm1) = istop; // intialize xprune(jcol-1)
+        glu.xlsub(jcol) = istop; 
+        
+        for (StorageIndex ifrom = jm1ptr; ifrom < nextl; ++ifrom, ++ito)
+          glu.lsub(ito) = glu.lsub(ifrom); 
+        nextl = ito;  // = istop + length(jcol)
+      }
+      nsuper++; 
+      glu.supno(jcol) = nsuper; 
+    } // if a new supernode 
+  } // end else:  jcol > 0
+  
+  // Tidy up the pointers before exit
+  glu.xsup(nsuper+1) = jcolp1; 
+  glu.supno(jcolp1) = nsuper; 
+  xprune(jcol) = StorageIndex(nextl);  // Intialize upper bound for pruning
+  glu.xlsub(jcolp1) = StorageIndex(nextl); 
+  
+  return 0; 
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_copy_to_ucol.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_copy_to_ucol.h
new file mode 100644
index 00000000..c32d8d8b
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_copy_to_ucol.h
@@ -0,0 +1,107 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+/* 
+ 
+ * NOTE: This file is the modified version of [s,d,c,z]copy_to_ucol.c file in SuperLU 
+ 
+ * -- SuperLU routine (version 2.0) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * November 15, 1997
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+#ifndef SPARSELU_COPY_TO_UCOL_H
+#define SPARSELU_COPY_TO_UCOL_H
+
+namespace Eigen {
+namespace internal {
+
+/**
+ * \brief Performs numeric block updates (sup-col) in topological order
+ * 
+ * \param jcol current column to update
+ * \param nseg Number of segments in the U part
+ * \param segrep segment representative ...
+ * \param repfnz First nonzero column in each row  ...
+ * \param perm_r Row permutation 
+ * \param dense Store the full representation of the column
+ * \param glu Global LU data. 
+ * \return 0 - successful return 
+ *         > 0 - number of bytes allocated when run out of space
+ * 
+ */
+template <typename Scalar, typename StorageIndex>
+Index SparseLUImpl<Scalar,StorageIndex>::copy_to_ucol(const Index jcol, const Index nseg, IndexVector& segrep,
+                                                      BlockIndexVector repfnz ,IndexVector& perm_r, BlockScalarVector dense, GlobalLU_t& glu)
+{  
+  Index ksub, krep, ksupno; 
+    
+  Index jsupno = glu.supno(jcol);
+  
+  // For each nonzero supernode segment of U[*,j] in topological order 
+  Index k = nseg - 1, i; 
+  StorageIndex nextu = glu.xusub(jcol); 
+  Index kfnz, isub, segsize; 
+  Index new_next,irow; 
+  Index fsupc, mem; 
+  for (ksub = 0; ksub < nseg; ksub++)
+  {
+    krep = segrep(k); k--; 
+    ksupno = glu.supno(krep); 
+    if (jsupno != ksupno ) // should go into ucol(); 
+    {
+      kfnz = repfnz(krep); 
+      if (kfnz != emptyIdxLU)
+      { // Nonzero U-segment 
+        fsupc = glu.xsup(ksupno); 
+        isub = glu.xlsub(fsupc) + kfnz - fsupc; 
+        segsize = krep - kfnz + 1; 
+        new_next = nextu + segsize; 
+        while (new_next > glu.nzumax) 
+        {
+          mem = memXpand<ScalarVector>(glu.ucol, glu.nzumax, nextu, UCOL, glu.num_expansions); 
+          if (mem) return mem; 
+          mem = memXpand<IndexVector>(glu.usub, glu.nzumax, nextu, USUB, glu.num_expansions); 
+          if (mem) return mem; 
+          
+        }
+        
+        for (i = 0; i < segsize; i++)
+        {
+          irow = glu.lsub(isub); 
+          glu.usub(nextu) = perm_r(irow); // Unlike the L part, the U part is stored in its final order
+          glu.ucol(nextu) = dense(irow); 
+          dense(irow) = Scalar(0.0); 
+          nextu++;
+          isub++;
+        }
+        
+      } // end nonzero U-segment 
+      
+    } // end if jsupno 
+    
+  } // end for each segment
+  glu.xusub(jcol + 1) = nextu; // close U(*,jcol)
+  return 0; 
+}
+
+} // namespace internal
+} // end namespace Eigen
+
+#endif // SPARSELU_COPY_TO_UCOL_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_gemm_kernel.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_gemm_kernel.h
new file mode 100644
index 00000000..95ba7413
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_gemm_kernel.h
@@ -0,0 +1,280 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSELU_GEMM_KERNEL_H
+#define EIGEN_SPARSELU_GEMM_KERNEL_H
+
+namespace Eigen {
+
+namespace internal {
+
+
+/** \internal
+  * A general matrix-matrix product kernel optimized for the SparseLU factorization.
+  *  - A, B, and C must be column major
+  *  - lda and ldc must be multiples of the respective packet size
+  *  - C must have the same alignment as A
+  */
+template<typename Scalar>
+EIGEN_DONT_INLINE
+void sparselu_gemm(Index m, Index n, Index d, const Scalar* A, Index lda, const Scalar* B, Index ldb, Scalar* C, Index ldc)
+{
+  using namespace Eigen::internal;
+  
+  typedef typename packet_traits<Scalar>::type Packet;
+  enum {
+    NumberOfRegisters = EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS,
+    PacketSize = packet_traits<Scalar>::size,
+    PM = 8,                             // peeling in M
+    RN = 2,                             // register blocking
+    RK = NumberOfRegisters>=16 ? 4 : 2, // register blocking
+    BM = 4096/sizeof(Scalar),           // number of rows of A-C per chunk
+    SM = PM*PacketSize                  // step along M
+  };
+  Index d_end = (d/RK)*RK;    // number of columns of A (rows of B) suitable for full register blocking
+  Index n_end = (n/RN)*RN;    // number of columns of B-C suitable for processing RN columns at once
+  Index i0 = internal::first_default_aligned(A,m);
+  
+  eigen_internal_assert(((lda%PacketSize)==0) && ((ldc%PacketSize)==0) && (i0==internal::first_default_aligned(C,m)));
+  
+  // handle the non aligned rows of A and C without any optimization:
+  for(Index i=0; i<i0; ++i)
+  {
+    for(Index j=0; j<n; ++j)
+    {
+      Scalar c = C[i+j*ldc];
+      for(Index k=0; k<d; ++k)
+        c += B[k+j*ldb] * A[i+k*lda];
+      C[i+j*ldc] = c;
+    }
+  }
+  // process the remaining rows per chunk of BM rows
+  for(Index ib=i0; ib<m; ib+=BM)
+  {
+    Index actual_b = std::min<Index>(BM, m-ib);                 // actual number of rows
+    Index actual_b_end1 = (actual_b/SM)*SM;                   // actual number of rows suitable for peeling
+    Index actual_b_end2 = (actual_b/PacketSize)*PacketSize;   // actual number of rows suitable for vectorization
+    
+    // Let's process two columns of B-C at once
+    for(Index j=0; j<n_end; j+=RN)
+    {
+      const Scalar* Bc0 = B+(j+0)*ldb;
+      const Scalar* Bc1 = B+(j+1)*ldb;
+      
+      for(Index k=0; k<d_end; k+=RK)
+      {
+        
+        // load and expand a RN x RK block of B
+        Packet b00, b10, b20, b30, b01, b11, b21, b31;
+                  { b00 = pset1<Packet>(Bc0[0]); }
+                  { b10 = pset1<Packet>(Bc0[1]); }
+        if(RK==4) { b20 = pset1<Packet>(Bc0[2]); }
+        if(RK==4) { b30 = pset1<Packet>(Bc0[3]); }
+                  { b01 = pset1<Packet>(Bc1[0]); }
+                  { b11 = pset1<Packet>(Bc1[1]); }
+        if(RK==4) { b21 = pset1<Packet>(Bc1[2]); }
+        if(RK==4) { b31 = pset1<Packet>(Bc1[3]); }
+        
+        Packet a0, a1, a2, a3, c0, c1, t0, t1;
+        
+        const Scalar* A0 = A+ib+(k+0)*lda;
+        const Scalar* A1 = A+ib+(k+1)*lda;
+        const Scalar* A2 = A+ib+(k+2)*lda;
+        const Scalar* A3 = A+ib+(k+3)*lda;
+        
+        Scalar* C0 = C+ib+(j+0)*ldc;
+        Scalar* C1 = C+ib+(j+1)*ldc;
+        
+                  a0 = pload<Packet>(A0);
+                  a1 = pload<Packet>(A1);
+        if(RK==4)
+        {
+          a2 = pload<Packet>(A2);
+          a3 = pload<Packet>(A3);
+        }
+        else
+        {
+          // workaround "may be used uninitialized in this function" warning
+          a2 = a3 = a0;
+        }
+        
+#define KMADD(c, a, b, tmp) {tmp = b; tmp = pmul(a,tmp); c = padd(c,tmp);}
+#define WORK(I)  \
+                     c0 = pload<Packet>(C0+i+(I)*PacketSize);    \
+                     c1 = pload<Packet>(C1+i+(I)*PacketSize);    \
+                     KMADD(c0, a0, b00, t0)                      \
+                     KMADD(c1, a0, b01, t1)                      \
+                     a0 = pload<Packet>(A0+i+(I+1)*PacketSize);  \
+                     KMADD(c0, a1, b10, t0)                      \
+                     KMADD(c1, a1, b11, t1)                      \
+                     a1 = pload<Packet>(A1+i+(I+1)*PacketSize);  \
+          if(RK==4){ KMADD(c0, a2, b20, t0)                     }\
+          if(RK==4){ KMADD(c1, a2, b21, t1)                     }\
+          if(RK==4){ a2 = pload<Packet>(A2+i+(I+1)*PacketSize); }\
+          if(RK==4){ KMADD(c0, a3, b30, t0)                     }\
+          if(RK==4){ KMADD(c1, a3, b31, t1)                     }\
+          if(RK==4){ a3 = pload<Packet>(A3+i+(I+1)*PacketSize); }\
+                     pstore(C0+i+(I)*PacketSize, c0);            \
+                     pstore(C1+i+(I)*PacketSize, c1)
+        
+        // process rows of A' - C' with aggressive vectorization and peeling 
+        for(Index i=0; i<actual_b_end1; i+=PacketSize*8)
+        {
+          EIGEN_ASM_COMMENT("SPARSELU_GEMML_KERNEL1");
+                    prefetch((A0+i+(5)*PacketSize));
+                    prefetch((A1+i+(5)*PacketSize));
+          if(RK==4) prefetch((A2+i+(5)*PacketSize));
+          if(RK==4) prefetch((A3+i+(5)*PacketSize));
+
+          WORK(0);
+          WORK(1);
+          WORK(2);
+          WORK(3);
+          WORK(4);
+          WORK(5);
+          WORK(6);
+          WORK(7);
+        }
+        // process the remaining rows with vectorization only
+        for(Index i=actual_b_end1; i<actual_b_end2; i+=PacketSize)
+        {
+          WORK(0);
+        }
+#undef WORK
+        // process the remaining rows without vectorization
+        for(Index i=actual_b_end2; i<actual_b; ++i)
+        {
+          if(RK==4)
+          {
+            C0[i] += A0[i]*Bc0[0]+A1[i]*Bc0[1]+A2[i]*Bc0[2]+A3[i]*Bc0[3];
+            C1[i] += A0[i]*Bc1[0]+A1[i]*Bc1[1]+A2[i]*Bc1[2]+A3[i]*Bc1[3];
+          }
+          else
+          {
+            C0[i] += A0[i]*Bc0[0]+A1[i]*Bc0[1];
+            C1[i] += A0[i]*Bc1[0]+A1[i]*Bc1[1];
+          }
+        }
+        
+        Bc0 += RK;
+        Bc1 += RK;
+      } // peeled loop on k
+    } // peeled loop on the columns j
+    // process the last column (we now perform a matrix-vector product)
+    if((n-n_end)>0)
+    {
+      const Scalar* Bc0 = B+(n-1)*ldb;
+      
+      for(Index k=0; k<d_end; k+=RK)
+      {
+        
+        // load and expand a 1 x RK block of B
+        Packet b00, b10, b20, b30;
+                  b00 = pset1<Packet>(Bc0[0]);
+                  b10 = pset1<Packet>(Bc0[1]);
+        if(RK==4) b20 = pset1<Packet>(Bc0[2]);
+        if(RK==4) b30 = pset1<Packet>(Bc0[3]);
+        
+        Packet a0, a1, a2, a3, c0, t0/*, t1*/;
+        
+        const Scalar* A0 = A+ib+(k+0)*lda;
+        const Scalar* A1 = A+ib+(k+1)*lda;
+        const Scalar* A2 = A+ib+(k+2)*lda;
+        const Scalar* A3 = A+ib+(k+3)*lda;
+        
+        Scalar* C0 = C+ib+(n_end)*ldc;
+        
+                  a0 = pload<Packet>(A0);
+                  a1 = pload<Packet>(A1);
+        if(RK==4)
+        {
+          a2 = pload<Packet>(A2);
+          a3 = pload<Packet>(A3);
+        }
+        else
+        {
+          // workaround "may be used uninitialized in this function" warning
+          a2 = a3 = a0;
+        }
+        
+#define WORK(I) \
+                   c0 = pload<Packet>(C0+i+(I)*PacketSize);     \
+                   KMADD(c0, a0, b00, t0)                       \
+                   a0 = pload<Packet>(A0+i+(I+1)*PacketSize);   \
+                   KMADD(c0, a1, b10, t0)                       \
+                   a1 = pload<Packet>(A1+i+(I+1)*PacketSize);   \
+        if(RK==4){ KMADD(c0, a2, b20, t0)                      }\
+        if(RK==4){ a2 = pload<Packet>(A2+i+(I+1)*PacketSize);  }\
+        if(RK==4){ KMADD(c0, a3, b30, t0)                      }\
+        if(RK==4){ a3 = pload<Packet>(A3+i+(I+1)*PacketSize);  }\
+                   pstore(C0+i+(I)*PacketSize, c0);
+        
+        // agressive vectorization and peeling
+        for(Index i=0; i<actual_b_end1; i+=PacketSize*8)
+        {
+          EIGEN_ASM_COMMENT("SPARSELU_GEMML_KERNEL2");
+          WORK(0);
+          WORK(1);
+          WORK(2);
+          WORK(3);
+          WORK(4);
+          WORK(5);
+          WORK(6);
+          WORK(7);
+        }
+        // vectorization only
+        for(Index i=actual_b_end1; i<actual_b_end2; i+=PacketSize)
+        {
+          WORK(0);
+        }
+        // remaining scalars
+        for(Index i=actual_b_end2; i<actual_b; ++i)
+        {
+          if(RK==4) 
+            C0[i] += A0[i]*Bc0[0]+A1[i]*Bc0[1]+A2[i]*Bc0[2]+A3[i]*Bc0[3];
+          else
+            C0[i] += A0[i]*Bc0[0]+A1[i]*Bc0[1];
+        }
+        
+        Bc0 += RK;
+#undef WORK
+      }
+    }
+    
+    // process the last columns of A, corresponding to the last rows of B
+    Index rd = d-d_end;
+    if(rd>0)
+    {
+      for(Index j=0; j<n; ++j)
+      {
+        enum {
+          Alignment = PacketSize>1 ? Aligned : 0
+        };
+        typedef Map<Matrix<Scalar,Dynamic,1>, Alignment > MapVector;
+        typedef Map<const Matrix<Scalar,Dynamic,1>, Alignment > ConstMapVector;
+        if(rd==1)       MapVector(C+j*ldc+ib,actual_b) += B[0+d_end+j*ldb] * ConstMapVector(A+(d_end+0)*lda+ib, actual_b);
+        
+        else if(rd==2)  MapVector(C+j*ldc+ib,actual_b) += B[0+d_end+j*ldb] * ConstMapVector(A+(d_end+0)*lda+ib, actual_b)
+                                                        + B[1+d_end+j*ldb] * ConstMapVector(A+(d_end+1)*lda+ib, actual_b);
+        
+        else            MapVector(C+j*ldc+ib,actual_b) += B[0+d_end+j*ldb] * ConstMapVector(A+(d_end+0)*lda+ib, actual_b)
+                                                        + B[1+d_end+j*ldb] * ConstMapVector(A+(d_end+1)*lda+ib, actual_b)
+                                                        + B[2+d_end+j*ldb] * ConstMapVector(A+(d_end+2)*lda+ib, actual_b);
+      }
+    }
+  
+  } // blocking on the rows of A and C
+}
+#undef KMADD
+
+} // namespace internal
+
+} // namespace Eigen
+
+#endif // EIGEN_SPARSELU_GEMM_KERNEL_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_heap_relax_snode.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_heap_relax_snode.h
new file mode 100644
index 00000000..6f75d500
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_heap_relax_snode.h
@@ -0,0 +1,126 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* This file is a modified version of heap_relax_snode.c file in SuperLU
+ * -- SuperLU routine (version 3.0) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * October 15, 2003
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+
+#ifndef SPARSELU_HEAP_RELAX_SNODE_H
+#define SPARSELU_HEAP_RELAX_SNODE_H
+
+namespace Eigen {
+namespace internal {
+
+/** 
+ * \brief Identify the initial relaxed supernodes
+ * 
+ * This routine applied to a symmetric elimination tree. 
+ * It assumes that the matrix has been reordered according to the postorder of the etree
+ * \param n The number of columns
+ * \param et elimination tree 
+ * \param relax_columns Maximum number of columns allowed in a relaxed snode 
+ * \param descendants Number of descendants of each node in the etree
+ * \param relax_end last column in a supernode
+ */
+template <typename Scalar, typename StorageIndex>
+void SparseLUImpl<Scalar,StorageIndex>::heap_relax_snode (const Index n, IndexVector& et, const Index relax_columns, IndexVector& descendants, IndexVector& relax_end)
+{
+  
+  // The etree may not be postordered, but its heap ordered  
+  IndexVector post;
+  internal::treePostorder(StorageIndex(n), et, post); // Post order etree
+  IndexVector inv_post(n+1); 
+  for (StorageIndex i = 0; i < n+1; ++i) inv_post(post(i)) = i; // inv_post = post.inverse()???
+  
+  // Renumber etree in postorder 
+  IndexVector iwork(n);
+  IndexVector et_save(n+1);
+  for (Index i = 0; i < n; ++i)
+  {
+    iwork(post(i)) = post(et(i));
+  }
+  et_save = et; // Save the original etree
+  et = iwork; 
+  
+  // compute the number of descendants of each node in the etree
+  relax_end.setConstant(emptyIdxLU);
+  Index j, parent; 
+  descendants.setZero();
+  for (j = 0; j < n; j++) 
+  {
+    parent = et(j);
+    if (parent != n) // not the dummy root
+      descendants(parent) += descendants(j) + 1;
+  }
+  // Identify the relaxed supernodes by postorder traversal of the etree
+  Index snode_start; // beginning of a snode 
+  StorageIndex k;
+  Index nsuper_et_post = 0; // Number of relaxed snodes in postordered etree 
+  Index nsuper_et = 0; // Number of relaxed snodes in the original etree 
+  StorageIndex l; 
+  for (j = 0; j < n; )
+  {
+    parent = et(j);
+    snode_start = j; 
+    while ( parent != n && descendants(parent) < relax_columns ) 
+    {
+      j = parent; 
+      parent = et(j);
+    }
+    // Found a supernode in postordered etree, j is the last column 
+    ++nsuper_et_post;
+    k = StorageIndex(n);
+    for (Index i = snode_start; i <= j; ++i)
+      k = (std::min)(k, inv_post(i));
+    l = inv_post(j);
+    if ( (l - k) == (j - snode_start) )  // Same number of columns in the snode
+    {
+      // This is also a supernode in the original etree
+      relax_end(k) = l; // Record last column 
+      ++nsuper_et; 
+    }
+    else 
+    {
+      for (Index i = snode_start; i <= j; ++i) 
+      {
+        l = inv_post(i);
+        if (descendants(i) == 0) 
+        {
+          relax_end(l) = l;
+          ++nsuper_et;
+        }
+      }
+    }
+    j++;
+    // Search for a new leaf
+    while (descendants(j) != 0 && j < n) j++;
+  } // End postorder traversal of the etree
+  
+  // Recover the original etree
+  et = et_save; 
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+#endif // SPARSELU_HEAP_RELAX_SNODE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_kernel_bmod.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_kernel_bmod.h
new file mode 100644
index 00000000..8c1b3e8b
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_kernel_bmod.h
@@ -0,0 +1,130 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+// Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef SPARSELU_KERNEL_BMOD_H
+#define SPARSELU_KERNEL_BMOD_H
+
+namespace Eigen {
+namespace internal {
+  
+template <int SegSizeAtCompileTime> struct LU_kernel_bmod
+{
+  /** \internal
+    * \brief Performs numeric block updates from a given supernode to a single column
+    *
+    * \param segsize Size of the segment (and blocks ) to use for updates
+    * \param[in,out] dense Packed values of the original matrix
+    * \param tempv temporary vector to use for updates
+    * \param lusup array containing the supernodes
+    * \param lda Leading dimension in the supernode
+    * \param nrow Number of rows in the rectangular part of the supernode
+    * \param lsub compressed row subscripts of supernodes
+    * \param lptr pointer to the first column of the current supernode in lsub
+    * \param no_zeros Number of nonzeros elements before the diagonal part of the supernode
+    */
+  template <typename BlockScalarVector, typename ScalarVector, typename IndexVector>
+  static EIGEN_DONT_INLINE void run(const Index segsize, BlockScalarVector& dense, ScalarVector& tempv, ScalarVector& lusup, Index& luptr, const Index lda,
+                                    const Index nrow, IndexVector& lsub, const Index lptr, const Index no_zeros);
+};
+
+template <int SegSizeAtCompileTime>
+template <typename BlockScalarVector, typename ScalarVector, typename IndexVector>
+EIGEN_DONT_INLINE void LU_kernel_bmod<SegSizeAtCompileTime>::run(const Index segsize, BlockScalarVector& dense, ScalarVector& tempv, ScalarVector& lusup, Index& luptr, const Index lda,
+                                                                  const Index nrow, IndexVector& lsub, const Index lptr, const Index no_zeros)
+{
+  typedef typename ScalarVector::Scalar Scalar;
+  // First, copy U[*,j] segment from dense(*) to tempv(*)
+  // The result of triangular solve is in tempv[*]; 
+    // The result of matric-vector update is in dense[*]
+  Index isub = lptr + no_zeros; 
+  Index i;
+  Index irow;
+  for (i = 0; i < ((SegSizeAtCompileTime==Dynamic)?segsize:SegSizeAtCompileTime); i++)
+  {
+    irow = lsub(isub); 
+    tempv(i) = dense(irow); 
+    ++isub; 
+  }
+  // Dense triangular solve -- start effective triangle
+  luptr += lda * no_zeros + no_zeros; 
+  // Form Eigen matrix and vector 
+  Map<Matrix<Scalar,SegSizeAtCompileTime,SegSizeAtCompileTime, ColMajor>, 0, OuterStride<> > A( &(lusup.data()[luptr]), segsize, segsize, OuterStride<>(lda) );
+  Map<Matrix<Scalar,SegSizeAtCompileTime,1> > u(tempv.data(), segsize);
+  
+  u = A.template triangularView<UnitLower>().solve(u); 
+  
+  // Dense matrix-vector product y <-- B*x 
+  luptr += segsize;
+  const Index PacketSize = internal::packet_traits<Scalar>::size;
+  Index ldl = internal::first_multiple(nrow, PacketSize);
+  Map<Matrix<Scalar,Dynamic,SegSizeAtCompileTime, ColMajor>, 0, OuterStride<> > B( &(lusup.data()[luptr]), nrow, segsize, OuterStride<>(lda) );
+  Index aligned_offset = internal::first_default_aligned(tempv.data()+segsize, PacketSize);
+  Index aligned_with_B_offset = (PacketSize-internal::first_default_aligned(B.data(), PacketSize))%PacketSize;
+  Map<Matrix<Scalar,Dynamic,1>, 0, OuterStride<> > l(tempv.data()+segsize+aligned_offset+aligned_with_B_offset, nrow, OuterStride<>(ldl) );
+  
+  l.setZero();
+  internal::sparselu_gemm<Scalar>(l.rows(), l.cols(), B.cols(), B.data(), B.outerStride(), u.data(), u.outerStride(), l.data(), l.outerStride());
+  
+  // Scatter tempv[] into SPA dense[] as a temporary storage 
+  isub = lptr + no_zeros;
+  for (i = 0; i < ((SegSizeAtCompileTime==Dynamic)?segsize:SegSizeAtCompileTime); i++)
+  {
+    irow = lsub(isub++); 
+    dense(irow) = tempv(i);
+  }
+  
+  // Scatter l into SPA dense[]
+  for (i = 0; i < nrow; i++)
+  {
+    irow = lsub(isub++); 
+    dense(irow) -= l(i);
+  } 
+}
+
+template <> struct LU_kernel_bmod<1>
+{
+  template <typename BlockScalarVector, typename ScalarVector, typename IndexVector>
+  static EIGEN_DONT_INLINE void run(const Index /*segsize*/, BlockScalarVector& dense, ScalarVector& /*tempv*/, ScalarVector& lusup, Index& luptr,
+                                    const Index lda, const Index nrow, IndexVector& lsub, const Index lptr, const Index no_zeros);
+};
+
+
+template <typename BlockScalarVector, typename ScalarVector, typename IndexVector>
+EIGEN_DONT_INLINE void LU_kernel_bmod<1>::run(const Index /*segsize*/, BlockScalarVector& dense, ScalarVector& /*tempv*/, ScalarVector& lusup, Index& luptr,
+                                              const Index lda, const Index nrow, IndexVector& lsub, const Index lptr, const Index no_zeros)
+{
+  typedef typename ScalarVector::Scalar Scalar;
+  typedef typename IndexVector::Scalar StorageIndex;
+  Scalar f = dense(lsub(lptr + no_zeros));
+  luptr += lda * no_zeros + no_zeros + 1;
+  const Scalar* a(lusup.data() + luptr);
+  const StorageIndex*  irow(lsub.data()+lptr + no_zeros + 1);
+  Index i = 0;
+  for (; i+1 < nrow; i+=2)
+  {
+    Index i0 = *(irow++);
+    Index i1 = *(irow++);
+    Scalar a0 = *(a++);
+    Scalar a1 = *(a++);
+    Scalar d0 = dense.coeff(i0);
+    Scalar d1 = dense.coeff(i1);
+    d0 -= f*a0;
+    d1 -= f*a1;
+    dense.coeffRef(i0) = d0;
+    dense.coeffRef(i1) = d1;
+  }
+  if(i<nrow)
+    dense.coeffRef(*(irow++)) -= f * *(a++);
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+#endif // SPARSELU_KERNEL_BMOD_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_panel_bmod.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_panel_bmod.h
new file mode 100644
index 00000000..822cf32c
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_panel_bmod.h
@@ -0,0 +1,223 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+// Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* 
+ 
+ * NOTE: This file is the modified version of [s,d,c,z]panel_bmod.c file in SuperLU 
+ 
+ * -- SuperLU routine (version 3.0) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * October 15, 2003
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+#ifndef SPARSELU_PANEL_BMOD_H
+#define SPARSELU_PANEL_BMOD_H
+
+namespace Eigen {
+namespace internal {
+
+/**
+ * \brief Performs numeric block updates (sup-panel) in topological order.
+ * 
+ * Before entering this routine, the original nonzeros in the panel
+ * were already copied i nto the spa[m,w]
+ * 
+ * \param m number of rows in the matrix
+ * \param w Panel size
+ * \param jcol Starting  column of the panel
+ * \param nseg Number of segments in the U part
+ * \param dense Store the full representation of the panel 
+ * \param tempv working array 
+ * \param segrep segment representative... first row in the segment
+ * \param repfnz First nonzero rows
+ * \param glu Global LU data. 
+ * 
+ * 
+ */
+template <typename Scalar, typename StorageIndex>
+void SparseLUImpl<Scalar,StorageIndex>::panel_bmod(const Index m, const Index w, const Index jcol, 
+                                            const Index nseg, ScalarVector& dense, ScalarVector& tempv,
+                                            IndexVector& segrep, IndexVector& repfnz, GlobalLU_t& glu)
+{
+  
+  Index ksub,jj,nextl_col; 
+  Index fsupc, nsupc, nsupr, nrow; 
+  Index krep, kfnz; 
+  Index lptr; // points to the row subscripts of a supernode 
+  Index luptr; // ...
+  Index segsize,no_zeros ; 
+  // For each nonz supernode segment of U[*,j] in topological order
+  Index k = nseg - 1; 
+  const Index PacketSize = internal::packet_traits<Scalar>::size;
+  
+  for (ksub = 0; ksub < nseg; ksub++)
+  { // For each updating supernode
+    /* krep = representative of current k-th supernode
+     * fsupc =  first supernodal column
+     * nsupc = number of columns in a supernode
+     * nsupr = number of rows in a supernode
+     */
+    krep = segrep(k); k--; 
+    fsupc = glu.xsup(glu.supno(krep)); 
+    nsupc = krep - fsupc + 1; 
+    nsupr = glu.xlsub(fsupc+1) - glu.xlsub(fsupc); 
+    nrow = nsupr - nsupc; 
+    lptr = glu.xlsub(fsupc); 
+    
+    // loop over the panel columns to detect the actual number of columns and rows
+    Index u_rows = 0;
+    Index u_cols = 0;
+    for (jj = jcol; jj < jcol + w; jj++)
+    {
+      nextl_col = (jj-jcol) * m; 
+      VectorBlock<IndexVector> repfnz_col(repfnz, nextl_col, m); // First nonzero column index for each row
+      
+      kfnz = repfnz_col(krep); 
+      if ( kfnz == emptyIdxLU ) 
+        continue; // skip any zero segment
+      
+      segsize = krep - kfnz + 1;
+      u_cols++;
+      u_rows = (std::max)(segsize,u_rows);
+    }
+    
+    if(nsupc >= 2)
+    { 
+      Index ldu = internal::first_multiple<Index>(u_rows, PacketSize);
+      Map<ScalarMatrix, Aligned,  OuterStride<> > U(tempv.data(), u_rows, u_cols, OuterStride<>(ldu));
+      
+      // gather U
+      Index u_col = 0;
+      for (jj = jcol; jj < jcol + w; jj++)
+      {
+        nextl_col = (jj-jcol) * m; 
+        VectorBlock<IndexVector> repfnz_col(repfnz, nextl_col, m); // First nonzero column index for each row
+        VectorBlock<ScalarVector> dense_col(dense, nextl_col, m); // Scatter/gather entire matrix column from/to here
+        
+        kfnz = repfnz_col(krep); 
+        if ( kfnz == emptyIdxLU ) 
+          continue; // skip any zero segment
+        
+        segsize = krep - kfnz + 1;
+        luptr = glu.xlusup(fsupc);    
+        no_zeros = kfnz - fsupc; 
+        
+        Index isub = lptr + no_zeros;
+        Index off = u_rows-segsize;
+        for (Index i = 0; i < off; i++) U(i,u_col) = 0;
+        for (Index i = 0; i < segsize; i++)
+        {
+          Index irow = glu.lsub(isub); 
+          U(i+off,u_col) = dense_col(irow); 
+          ++isub; 
+        }
+        u_col++;
+      }
+      // solve U = A^-1 U
+      luptr = glu.xlusup(fsupc);
+      Index lda = glu.xlusup(fsupc+1) - glu.xlusup(fsupc);
+      no_zeros = (krep - u_rows + 1) - fsupc;
+      luptr += lda * no_zeros + no_zeros;
+      MappedMatrixBlock A(glu.lusup.data()+luptr, u_rows, u_rows, OuterStride<>(lda) );
+      U = A.template triangularView<UnitLower>().solve(U);
+      
+      // update
+      luptr += u_rows;
+      MappedMatrixBlock B(glu.lusup.data()+luptr, nrow, u_rows, OuterStride<>(lda) );
+      eigen_assert(tempv.size()>w*ldu + nrow*w + 1);
+      
+      Index ldl = internal::first_multiple<Index>(nrow, PacketSize);
+      Index offset = (PacketSize-internal::first_default_aligned(B.data(), PacketSize)) % PacketSize;
+      MappedMatrixBlock L(tempv.data()+w*ldu+offset, nrow, u_cols, OuterStride<>(ldl));
+      
+      L.setZero();
+      internal::sparselu_gemm<Scalar>(L.rows(), L.cols(), B.cols(), B.data(), B.outerStride(), U.data(), U.outerStride(), L.data(), L.outerStride());
+      
+      // scatter U and L
+      u_col = 0;
+      for (jj = jcol; jj < jcol + w; jj++)
+      {
+        nextl_col = (jj-jcol) * m; 
+        VectorBlock<IndexVector> repfnz_col(repfnz, nextl_col, m); // First nonzero column index for each row
+        VectorBlock<ScalarVector> dense_col(dense, nextl_col, m); // Scatter/gather entire matrix column from/to here
+        
+        kfnz = repfnz_col(krep); 
+        if ( kfnz == emptyIdxLU ) 
+          continue; // skip any zero segment
+        
+        segsize = krep - kfnz + 1;
+        no_zeros = kfnz - fsupc; 
+        Index isub = lptr + no_zeros;
+        
+        Index off = u_rows-segsize;
+        for (Index i = 0; i < segsize; i++)
+        {
+          Index irow = glu.lsub(isub++); 
+          dense_col(irow) = U.coeff(i+off,u_col);
+          U.coeffRef(i+off,u_col) = 0;
+        }
+        
+        // Scatter l into SPA dense[]
+        for (Index i = 0; i < nrow; i++)
+        {
+          Index irow = glu.lsub(isub++); 
+          dense_col(irow) -= L.coeff(i,u_col);
+          L.coeffRef(i,u_col) = 0;
+        }
+        u_col++;
+      }
+    }
+    else // level 2 only
+    {
+      // Sequence through each column in the panel
+      for (jj = jcol; jj < jcol + w; jj++)
+      {
+        nextl_col = (jj-jcol) * m; 
+        VectorBlock<IndexVector> repfnz_col(repfnz, nextl_col, m); // First nonzero column index for each row
+        VectorBlock<ScalarVector> dense_col(dense, nextl_col, m); // Scatter/gather entire matrix column from/to here
+        
+        kfnz = repfnz_col(krep); 
+        if ( kfnz == emptyIdxLU ) 
+          continue; // skip any zero segment
+        
+        segsize = krep - kfnz + 1;
+        luptr = glu.xlusup(fsupc);
+        
+        Index lda = glu.xlusup(fsupc+1)-glu.xlusup(fsupc);// nsupr
+        
+        // Perform a trianglar solve and block update, 
+        // then scatter the result of sup-col update to dense[]
+        no_zeros = kfnz - fsupc; 
+              if(segsize==1)  LU_kernel_bmod<1>::run(segsize, dense_col, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros);
+        else  if(segsize==2)  LU_kernel_bmod<2>::run(segsize, dense_col, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros);
+        else  if(segsize==3)  LU_kernel_bmod<3>::run(segsize, dense_col, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros);
+        else                  LU_kernel_bmod<Dynamic>::run(segsize, dense_col, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros); 
+      } // End for each column in the panel 
+    }
+    
+  } // End for each updating supernode
+} // end panel bmod
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // SPARSELU_PANEL_BMOD_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_panel_dfs.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_panel_dfs.h
new file mode 100644
index 00000000..155df733
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_panel_dfs.h
@@ -0,0 +1,258 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* 
+ 
+ * NOTE: This file is the modified version of [s,d,c,z]panel_dfs.c file in SuperLU 
+ 
+ * -- SuperLU routine (version 2.0) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * November 15, 1997
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+#ifndef SPARSELU_PANEL_DFS_H
+#define SPARSELU_PANEL_DFS_H
+
+namespace Eigen {
+
+namespace internal {
+  
+template<typename IndexVector>
+struct panel_dfs_traits
+{
+  typedef typename IndexVector::Scalar StorageIndex;
+  panel_dfs_traits(Index jcol, StorageIndex* marker)
+    : m_jcol(jcol), m_marker(marker)
+  {}
+  bool update_segrep(Index krep, StorageIndex jj)
+  {
+    if(m_marker[krep]<m_jcol)
+    {
+      m_marker[krep] = jj; 
+      return true;
+    }
+    return false;
+  }
+  void mem_expand(IndexVector& /*glu.lsub*/, Index /*nextl*/, Index /*chmark*/) {}
+  enum { ExpandMem = false };
+  Index m_jcol;
+  StorageIndex* m_marker;
+};
+
+
+template <typename Scalar, typename StorageIndex>
+template <typename Traits>
+void SparseLUImpl<Scalar,StorageIndex>::dfs_kernel(const StorageIndex jj, IndexVector& perm_r,
+                   Index& nseg, IndexVector& panel_lsub, IndexVector& segrep,
+                   Ref<IndexVector> repfnz_col, IndexVector& xprune, Ref<IndexVector> marker, IndexVector& parent,
+                   IndexVector& xplore, GlobalLU_t& glu,
+                   Index& nextl_col, Index krow, Traits& traits
+                  )
+{
+  
+  StorageIndex kmark = marker(krow);
+      
+  // For each unmarked krow of jj
+  marker(krow) = jj; 
+  StorageIndex kperm = perm_r(krow); 
+  if (kperm == emptyIdxLU ) {
+    // krow is in L : place it in structure of L(*, jj)
+    panel_lsub(nextl_col++) = StorageIndex(krow);  // krow is indexed into A
+    
+    traits.mem_expand(panel_lsub, nextl_col, kmark);
+  }
+  else 
+  {
+    // krow is in U : if its supernode-representative krep
+    // has been explored, update repfnz(*)
+    // krep = supernode representative of the current row
+    StorageIndex krep = glu.xsup(glu.supno(kperm)+1) - 1; 
+    // First nonzero element in the current column:
+    StorageIndex myfnz = repfnz_col(krep); 
+    
+    if (myfnz != emptyIdxLU )
+    {
+      // Representative visited before
+      if (myfnz > kperm ) repfnz_col(krep) = kperm; 
+      
+    }
+    else 
+    {
+      // Otherwise, perform dfs starting at krep
+      StorageIndex oldrep = emptyIdxLU; 
+      parent(krep) = oldrep; 
+      repfnz_col(krep) = kperm; 
+      StorageIndex xdfs =  glu.xlsub(krep); 
+      Index maxdfs = xprune(krep); 
+      
+      StorageIndex kpar;
+      do 
+      {
+        // For each unmarked kchild of krep
+        while (xdfs < maxdfs) 
+        {
+          StorageIndex kchild = glu.lsub(xdfs); 
+          xdfs++; 
+          StorageIndex chmark = marker(kchild); 
+          
+          if (chmark != jj ) 
+          {
+            marker(kchild) = jj; 
+            StorageIndex chperm = perm_r(kchild); 
+            
+            if (chperm == emptyIdxLU) 
+            {
+              // case kchild is in L: place it in L(*, j)
+              panel_lsub(nextl_col++) = kchild;
+              traits.mem_expand(panel_lsub, nextl_col, chmark);
+            }
+            else
+            {
+              // case kchild is in U :
+              // chrep = its supernode-rep. If its rep has been explored, 
+              // update its repfnz(*)
+              StorageIndex chrep = glu.xsup(glu.supno(chperm)+1) - 1; 
+              myfnz = repfnz_col(chrep); 
+              
+              if (myfnz != emptyIdxLU) 
+              { // Visited before 
+                if (myfnz > chperm) 
+                  repfnz_col(chrep) = chperm; 
+              }
+              else 
+              { // Cont. dfs at snode-rep of kchild
+                xplore(krep) = xdfs; 
+                oldrep = krep; 
+                krep = chrep; // Go deeper down G(L)
+                parent(krep) = oldrep; 
+                repfnz_col(krep) = chperm; 
+                xdfs = glu.xlsub(krep); 
+                maxdfs = xprune(krep); 
+                
+              } // end if myfnz != -1
+            } // end if chperm == -1 
+                
+          } // end if chmark !=jj
+        } // end while xdfs < maxdfs
+        
+        // krow has no more unexplored nbrs :
+        //    Place snode-rep krep in postorder DFS, if this 
+        //    segment is seen for the first time. (Note that 
+        //    "repfnz(krep)" may change later.)
+        //    Baktrack dfs to its parent
+        if(traits.update_segrep(krep,jj))
+        //if (marker1(krep) < jcol )
+        {
+          segrep(nseg) = krep; 
+          ++nseg; 
+          //marker1(krep) = jj; 
+        }
+        
+        kpar = parent(krep); // Pop recursion, mimic recursion 
+        if (kpar == emptyIdxLU) 
+          break; // dfs done 
+        krep = kpar; 
+        xdfs = xplore(krep); 
+        maxdfs = xprune(krep); 
+
+      } while (kpar != emptyIdxLU); // Do until empty stack 
+      
+    } // end if (myfnz = -1)
+
+  } // end if (kperm == -1)   
+}
+
+/**
+ * \brief Performs a symbolic factorization on a panel of columns [jcol, jcol+w)
+ * 
+ * A supernode representative is the last column of a supernode.
+ * The nonzeros in U[*,j] are segments that end at supernodes representatives
+ * 
+ * The routine returns a list of the supernodal representatives 
+ * in topological order of the dfs that generates them. This list is 
+ * a superset of the topological order of each individual column within 
+ * the panel.
+ * The location of the first nonzero in each supernodal segment 
+ * (supernodal entry location) is also returned. Each column has 
+ * a separate list for this purpose. 
+ * 
+ * Two markers arrays are used for dfs :
+ *    marker[i] == jj, if i was visited during dfs of current column jj;
+ *    marker1[i] >= jcol, if i was visited by earlier columns in this panel; 
+ * 
+ * \param[in] m number of rows in the matrix
+ * \param[in] w Panel size
+ * \param[in] jcol Starting  column of the panel
+ * \param[in] A Input matrix in column-major storage
+ * \param[in] perm_r Row permutation
+ * \param[out] nseg Number of U segments
+ * \param[out] dense Accumulate the column vectors of the panel
+ * \param[out] panel_lsub Subscripts of the row in the panel 
+ * \param[out] segrep Segment representative i.e first nonzero row of each segment
+ * \param[out] repfnz First nonzero location in each row
+ * \param[out] xprune The pruned elimination tree
+ * \param[out] marker work vector
+ * \param  parent The elimination tree
+ * \param xplore work vector
+ * \param glu The global data structure
+ * 
+ */
+
+template <typename Scalar, typename StorageIndex>
+void SparseLUImpl<Scalar,StorageIndex>::panel_dfs(const Index m, const Index w, const Index jcol, MatrixType& A, IndexVector& perm_r, Index& nseg, ScalarVector& dense, IndexVector& panel_lsub, IndexVector& segrep, IndexVector& repfnz, IndexVector& xprune, IndexVector& marker, IndexVector& parent, IndexVector& xplore, GlobalLU_t& glu)
+{
+  Index nextl_col; // Next available position in panel_lsub[*,jj] 
+  
+  // Initialize pointers 
+  VectorBlock<IndexVector> marker1(marker, m, m); 
+  nseg = 0; 
+  
+  panel_dfs_traits<IndexVector> traits(jcol, marker1.data());
+  
+  // For each column in the panel 
+  for (StorageIndex jj = StorageIndex(jcol); jj < jcol + w; jj++) 
+  {
+    nextl_col = (jj - jcol) * m; 
+    
+    VectorBlock<IndexVector> repfnz_col(repfnz, nextl_col, m); // First nonzero location in each row
+    VectorBlock<ScalarVector> dense_col(dense,nextl_col, m); // Accumulate a column vector here
+    
+    
+    // For each nnz in A[*, jj] do depth first search
+    for (typename MatrixType::InnerIterator it(A, jj); it; ++it)
+    {
+      Index krow = it.row(); 
+      dense_col(krow) = it.value();
+      
+      StorageIndex kmark = marker(krow); 
+      if (kmark == jj) 
+        continue; // krow visited before, go to the next nonzero
+      
+      dfs_kernel(jj, perm_r, nseg, panel_lsub, segrep, repfnz_col, xprune, marker, parent,
+                   xplore, glu, nextl_col, krow, traits);
+    }// end for nonzeros in column jj
+    
+  } // end for column jj
+}
+
+} // end namespace internal
+} // end namespace Eigen
+
+#endif // SPARSELU_PANEL_DFS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_pivotL.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_pivotL.h
new file mode 100644
index 00000000..a86dac93
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_pivotL.h
@@ -0,0 +1,137 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* 
+ 
+ * NOTE: This file is the modified version of xpivotL.c file in SuperLU 
+ 
+ * -- SuperLU routine (version 3.0) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * October 15, 2003
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+#ifndef SPARSELU_PIVOTL_H
+#define SPARSELU_PIVOTL_H
+
+namespace Eigen {
+namespace internal {
+  
+/**
+ * \brief Performs the numerical pivotin on the current column of L, and the CDIV operation.
+ * 
+ * Pivot policy :
+ * (1) Compute thresh = u * max_(i>=j) abs(A_ij);
+ * (2) IF user specifies pivot row k and abs(A_kj) >= thresh THEN
+ *           pivot row = k;
+ *       ELSE IF abs(A_jj) >= thresh THEN
+ *           pivot row = j;
+ *       ELSE
+ *           pivot row = m;
+ * 
+ *   Note: If you absolutely want to use a given pivot order, then set u=0.0.
+ * 
+ * \param jcol The current column of L
+ * \param diagpivotthresh diagonal pivoting threshold
+ * \param[in,out] perm_r Row permutation (threshold pivoting)
+ * \param[in] iperm_c column permutation - used to finf diagonal of Pc*A*Pc'
+ * \param[out] pivrow  The pivot row
+ * \param glu Global LU data
+ * \return 0 if success, i > 0 if U(i,i) is exactly zero 
+ * 
+ */
+template <typename Scalar, typename StorageIndex>
+Index SparseLUImpl<Scalar,StorageIndex>::pivotL(const Index jcol, const RealScalar& diagpivotthresh, IndexVector& perm_r, IndexVector& iperm_c, Index& pivrow, GlobalLU_t& glu)
+{
+  
+  Index fsupc = (glu.xsup)((glu.supno)(jcol)); // First column in the supernode containing the column jcol
+  Index nsupc = jcol - fsupc; // Number of columns in the supernode portion, excluding jcol; nsupc >=0
+  Index lptr = glu.xlsub(fsupc); // pointer to the starting location of the row subscripts for this supernode portion
+  Index nsupr = glu.xlsub(fsupc+1) - lptr; // Number of rows in the supernode
+  Index lda = glu.xlusup(fsupc+1) - glu.xlusup(fsupc); // leading dimension
+  Scalar* lu_sup_ptr = &(glu.lusup.data()[glu.xlusup(fsupc)]); // Start of the current supernode
+  Scalar* lu_col_ptr = &(glu.lusup.data()[glu.xlusup(jcol)]); // Start of jcol in the supernode
+  StorageIndex* lsub_ptr = &(glu.lsub.data()[lptr]); // Start of row indices of the supernode
+  
+  // Determine the largest abs numerical value for partial pivoting 
+  Index diagind = iperm_c(jcol); // diagonal index 
+  RealScalar pivmax(-1.0);
+  Index pivptr = nsupc; 
+  Index diag = emptyIdxLU; 
+  RealScalar rtemp;
+  Index isub, icol, itemp, k; 
+  for (isub = nsupc; isub < nsupr; ++isub) {
+    using std::abs;
+    rtemp = abs(lu_col_ptr[isub]);
+    if (rtemp > pivmax) {
+      pivmax = rtemp; 
+      pivptr = isub;
+    } 
+    if (lsub_ptr[isub] == diagind) diag = isub;
+  }
+  
+  // Test for singularity
+  if ( pivmax <= RealScalar(0.0) ) {
+    // if pivmax == -1, the column is structurally empty, otherwise it is only numerically zero
+    pivrow = pivmax < RealScalar(0.0) ? diagind : lsub_ptr[pivptr];
+    perm_r(pivrow) = StorageIndex(jcol);
+    return (jcol+1);
+  }
+  
+  RealScalar thresh = diagpivotthresh * pivmax; 
+  
+  // Choose appropriate pivotal element 
+  
+  {
+    // Test if the diagonal element can be used as a pivot (given the threshold value)
+    if (diag >= 0 ) 
+    {
+      // Diagonal element exists
+      using std::abs;
+      rtemp = abs(lu_col_ptr[diag]);
+      if (rtemp != RealScalar(0.0) && rtemp >= thresh) pivptr = diag;
+    }
+    pivrow = lsub_ptr[pivptr];
+  }
+  
+  // Record pivot row
+  perm_r(pivrow) = StorageIndex(jcol);
+  // Interchange row subscripts
+  if (pivptr != nsupc )
+  {
+    std::swap( lsub_ptr[pivptr], lsub_ptr[nsupc] );
+    // Interchange numerical values as well, for the two rows in the whole snode
+    // such that L is indexed the same way as A
+    for (icol = 0; icol <= nsupc; icol++)
+    {
+      itemp = pivptr + icol * lda; 
+      std::swap(lu_sup_ptr[itemp], lu_sup_ptr[nsupc + icol * lda]);
+    }
+  }
+  // cdiv operations
+  Scalar temp = Scalar(1.0) / lu_col_ptr[nsupc];
+  for (k = nsupc+1; k < nsupr; k++)
+    lu_col_ptr[k] *= temp; 
+  return 0;
+}
+
+} // end namespace internal
+} // end namespace Eigen
+
+#endif // SPARSELU_PIVOTL_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_pruneL.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_pruneL.h
new file mode 100644
index 00000000..ad32fed5
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_pruneL.h
@@ -0,0 +1,136 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* 
+ 
+ * NOTE: This file is the modified version of [s,d,c,z]pruneL.c file in SuperLU 
+ 
+ * -- SuperLU routine (version 2.0) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * November 15, 1997
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+#ifndef SPARSELU_PRUNEL_H
+#define SPARSELU_PRUNEL_H
+
+namespace Eigen {
+namespace internal {
+
+/**
+ * \brief Prunes the L-structure.
+ *
+ * It prunes the L-structure  of supernodes whose L-structure contains the current pivot row "pivrow"
+ * 
+ * 
+ * \param jcol The current column of L
+ * \param[in] perm_r Row permutation
+ * \param[out] pivrow  The pivot row
+ * \param nseg Number of segments
+ * \param segrep 
+ * \param repfnz
+ * \param[out] xprune 
+ * \param glu Global LU data
+ * 
+ */
+template <typename Scalar, typename StorageIndex>
+void SparseLUImpl<Scalar,StorageIndex>::pruneL(const Index jcol, const IndexVector& perm_r, const Index pivrow, const Index nseg,
+                                               const IndexVector& segrep, BlockIndexVector repfnz, IndexVector& xprune, GlobalLU_t& glu)
+{
+  // For each supernode-rep irep in U(*,j]
+  Index jsupno = glu.supno(jcol); 
+  Index i,irep,irep1; 
+  bool movnum, do_prune = false; 
+  Index kmin = 0, kmax = 0, minloc, maxloc,krow; 
+  for (i = 0; i < nseg; i++)
+  {
+    irep = segrep(i); 
+    irep1 = irep + 1; 
+    do_prune = false; 
+    
+    // Don't prune with a zero U-segment 
+    if (repfnz(irep) == emptyIdxLU) continue; 
+    
+    // If a snode overlaps with the next panel, then the U-segment
+    // is fragmented into two parts -- irep and irep1. We should let 
+    // pruning occur at the rep-column in irep1s snode. 
+    if (glu.supno(irep) == glu.supno(irep1) ) continue; // don't prune 
+    
+    // If it has not been pruned & it has a nonz in row L(pivrow,i)
+    if (glu.supno(irep) != jsupno )
+    {
+      if ( xprune (irep) >= glu.xlsub(irep1) )
+      {
+        kmin = glu.xlsub(irep);
+        kmax = glu.xlsub(irep1) - 1; 
+        for (krow = kmin; krow <= kmax; krow++)
+        {
+          if (glu.lsub(krow) == pivrow) 
+          {
+            do_prune = true; 
+            break; 
+          }
+        }
+      }
+      
+      if (do_prune) 
+      {
+        // do a quicksort-type partition
+        // movnum=true means that the num values have to be exchanged
+        movnum = false; 
+        if (irep == glu.xsup(glu.supno(irep)) ) // Snode of size 1 
+          movnum = true; 
+        
+        while (kmin <= kmax)
+        {
+          if (perm_r(glu.lsub(kmax)) == emptyIdxLU)
+            kmax--; 
+          else if ( perm_r(glu.lsub(kmin)) != emptyIdxLU)
+            kmin++;
+          else 
+          {
+            // kmin below pivrow (not yet pivoted), and kmax
+            // above pivrow: interchange the two suscripts
+            std::swap(glu.lsub(kmin), glu.lsub(kmax)); 
+            
+            // If the supernode has only one column, then we 
+            // only keep one set of subscripts. For any subscript
+            // intercnahge performed, similar interchange must be 
+            // done on the numerical values. 
+            if (movnum) 
+            {
+              minloc = glu.xlusup(irep) + ( kmin - glu.xlsub(irep) ); 
+              maxloc = glu.xlusup(irep) + ( kmax - glu.xlsub(irep) ); 
+              std::swap(glu.lusup(minloc), glu.lusup(maxloc)); 
+            }
+            kmin++;
+            kmax--;
+          }
+        } // end while 
+        
+        xprune(irep) = StorageIndex(kmin);  //Pruning 
+      } // end if do_prune 
+    } // end pruning 
+  } // End for each U-segment
+}
+
+} // end namespace internal
+} // end namespace Eigen
+
+#endif // SPARSELU_PRUNEL_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_relax_snode.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_relax_snode.h
new file mode 100644
index 00000000..c408d01b
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseLU/SparseLU_relax_snode.h
@@ -0,0 +1,83 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* This file is a modified version of heap_relax_snode.c file in SuperLU
+ * -- SuperLU routine (version 3.0) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * October 15, 2003
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+
+#ifndef SPARSELU_RELAX_SNODE_H
+#define SPARSELU_RELAX_SNODE_H
+
+namespace Eigen {
+
+namespace internal {
+ 
+/** 
+ * \brief Identify the initial relaxed supernodes
+ * 
+ * This routine is applied to a column elimination tree. 
+ * It assumes that the matrix has been reordered according to the postorder of the etree
+ * \param n  the number of columns
+ * \param et elimination tree 
+ * \param relax_columns Maximum number of columns allowed in a relaxed snode 
+ * \param descendants Number of descendants of each node in the etree
+ * \param relax_end last column in a supernode
+ */
+template <typename Scalar, typename StorageIndex>
+void SparseLUImpl<Scalar,StorageIndex>::relax_snode (const Index n, IndexVector& et, const Index relax_columns, IndexVector& descendants, IndexVector& relax_end)
+{
+  
+  // compute the number of descendants of each node in the etree
+  Index parent; 
+  relax_end.setConstant(emptyIdxLU);
+  descendants.setZero();
+  for (Index j = 0; j < n; j++) 
+  {
+    parent = et(j);
+    if (parent != n) // not the dummy root
+      descendants(parent) += descendants(j) + 1;
+  }
+  // Identify the relaxed supernodes by postorder traversal of the etree
+  Index snode_start; // beginning of a snode 
+  for (Index j = 0; j < n; )
+  {
+    parent = et(j);
+    snode_start = j; 
+    while ( parent != n && descendants(parent) < relax_columns ) 
+    {
+      j = parent; 
+      parent = et(j);
+    }
+    // Found a supernode in postordered etree, j is the last column 
+    relax_end(snode_start) = StorageIndex(j); // Record last column
+    j++;
+    // Search for a new leaf
+    while (descendants(j) != 0 && j < n) j++;
+  } // End postorder traversal of the etree
+  
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseQR/SparseQR.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseQR/SparseQR.h
new file mode 100644
index 00000000..f7111fe2
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SparseQR/SparseQR.h
@@ -0,0 +1,739 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012-2013 Desire Nuentsa <desire.nuentsa_wakam@inria.fr>
+// Copyright (C) 2012-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_QR_H
+#define EIGEN_SPARSE_QR_H
+
+namespace Eigen {
+
+template<typename MatrixType, typename OrderingType> class SparseQR;
+template<typename SparseQRType> struct SparseQRMatrixQReturnType;
+template<typename SparseQRType> struct SparseQRMatrixQTransposeReturnType;
+template<typename SparseQRType, typename Derived> struct SparseQR_QProduct;
+namespace internal {
+  template <typename SparseQRType> struct traits<SparseQRMatrixQReturnType<SparseQRType> >
+  {
+    typedef typename SparseQRType::MatrixType ReturnType;
+    typedef typename ReturnType::StorageIndex StorageIndex;
+    typedef typename ReturnType::StorageKind StorageKind;
+    enum {
+      RowsAtCompileTime = Dynamic,
+      ColsAtCompileTime = Dynamic
+    };
+  };
+  template <typename SparseQRType> struct traits<SparseQRMatrixQTransposeReturnType<SparseQRType> >
+  {
+    typedef typename SparseQRType::MatrixType ReturnType;
+  };
+  template <typename SparseQRType, typename Derived> struct traits<SparseQR_QProduct<SparseQRType, Derived> >
+  {
+    typedef typename Derived::PlainObject ReturnType;
+  };
+} // End namespace internal
+
+/**
+  * \ingroup SparseQR_Module
+  * \class SparseQR
+  * \brief Sparse left-looking rank-revealing QR factorization
+  * 
+  * This class implements a left-looking rank-revealing QR decomposition 
+  * of sparse matrices. When a column has a norm less than a given tolerance
+  * it is implicitly permuted to the end. The QR factorization thus obtained is 
+  * given by A*P = Q*R where R is upper triangular or trapezoidal. 
+  * 
+  * P is the column permutation which is the product of the fill-reducing and the
+  * rank-revealing permutations. Use colsPermutation() to get it.
+  * 
+  * Q is the orthogonal matrix represented as products of Householder reflectors. 
+  * Use matrixQ() to get an expression and matrixQ().transpose() to get the transpose.
+  * You can then apply it to a vector.
+  * 
+  * R is the sparse triangular or trapezoidal matrix. The later occurs when A is rank-deficient.
+  * matrixR().topLeftCorner(rank(), rank()) always returns a triangular factor of full rank.
+  * 
+  * \tparam _MatrixType The type of the sparse matrix A, must be a column-major SparseMatrix<>
+  * \tparam _OrderingType The fill-reducing ordering method. See the \link OrderingMethods_Module 
+  *  OrderingMethods \endlink module for the list of built-in and external ordering methods.
+  * 
+  * \implsparsesolverconcept
+  *
+  * \warning The input sparse matrix A must be in compressed mode (see SparseMatrix::makeCompressed()).
+  * 
+  */
+template<typename _MatrixType, typename _OrderingType>
+class SparseQR : public SparseSolverBase<SparseQR<_MatrixType,_OrderingType> >
+{
+  protected:
+    typedef SparseSolverBase<SparseQR<_MatrixType,_OrderingType> > Base;
+    using Base::m_isInitialized;
+  public:
+    using Base::_solve_impl;
+    typedef _MatrixType MatrixType;
+    typedef _OrderingType OrderingType;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef SparseMatrix<Scalar,ColMajor,StorageIndex> QRMatrixType;
+    typedef Matrix<StorageIndex, Dynamic, 1> IndexVector;
+    typedef Matrix<Scalar, Dynamic, 1> ScalarVector;
+    typedef PermutationMatrix<Dynamic, Dynamic, StorageIndex> PermutationType;
+
+    enum {
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    
+  public:
+    SparseQR () :  m_analysisIsok(false), m_lastError(""), m_useDefaultThreshold(true),m_isQSorted(false),m_isEtreeOk(false)
+    { }
+    
+    /** Construct a QR factorization of the matrix \a mat.
+      * 
+      * \warning The matrix \a mat must be in compressed mode (see SparseMatrix::makeCompressed()).
+      * 
+      * \sa compute()
+      */
+    explicit SparseQR(const MatrixType& mat) : m_analysisIsok(false), m_lastError(""), m_useDefaultThreshold(true),m_isQSorted(false),m_isEtreeOk(false)
+    {
+      compute(mat);
+    }
+    
+    /** Computes the QR factorization of the sparse matrix \a mat.
+      * 
+      * \warning The matrix \a mat must be in compressed mode (see SparseMatrix::makeCompressed()).
+      * 
+      * \sa analyzePattern(), factorize()
+      */
+    void compute(const MatrixType& mat)
+    {
+      analyzePattern(mat);
+      factorize(mat);
+    }
+    void analyzePattern(const MatrixType& mat);
+    void factorize(const MatrixType& mat);
+    
+    /** \returns the number of rows of the represented matrix. 
+      */
+    inline Index rows() const { return m_pmat.rows(); }
+    
+    /** \returns the number of columns of the represented matrix. 
+      */
+    inline Index cols() const { return m_pmat.cols();}
+    
+    /** \returns a const reference to the \b sparse upper triangular matrix R of the QR factorization.
+      * \warning The entries of the returned matrix are not sorted. This means that using it in algorithms
+      *          expecting sorted entries will fail. This include random coefficient accesses (SpaseMatrix::coeff()),
+      *          and coefficient-wise operations. Matrix products and triangular solves are fine though.
+      *
+      * To sort the entries, you can assign it to a row-major matrix, and if a column-major matrix
+      * is required, you can copy it again:
+      * \code
+      * SparseMatrix<double>          R  = qr.matrixR();  // column-major, not sorted!
+      * SparseMatrix<double,RowMajor> Rr = qr.matrixR();  // row-major, sorted
+      * SparseMatrix<double>          Rc = Rr;            // column-major, sorted
+      * \endcode
+      */
+    const QRMatrixType& matrixR() const { return m_R; }
+    
+    /** \returns the number of non linearly dependent columns as determined by the pivoting threshold.
+      *
+      * \sa setPivotThreshold()
+      */
+    Index rank() const
+    {
+      eigen_assert(m_isInitialized && "The factorization should be called first, use compute()");
+      return m_nonzeropivots; 
+    }
+    
+    /** \returns an expression of the matrix Q as products of sparse Householder reflectors.
+    * The common usage of this function is to apply it to a dense matrix or vector
+    * \code
+    * VectorXd B1, B2;
+    * // Initialize B1
+    * B2 = matrixQ() * B1;
+    * \endcode
+    *
+    * To get a plain SparseMatrix representation of Q:
+    * \code
+    * SparseMatrix<double> Q;
+    * Q = SparseQR<SparseMatrix<double> >(A).matrixQ();
+    * \endcode
+    * Internally, this call simply performs a sparse product between the matrix Q
+    * and a sparse identity matrix. However, due to the fact that the sparse
+    * reflectors are stored unsorted, two transpositions are needed to sort
+    * them before performing the product.
+    */
+    SparseQRMatrixQReturnType<SparseQR> matrixQ() const 
+    { return SparseQRMatrixQReturnType<SparseQR>(*this); }
+    
+    /** \returns a const reference to the column permutation P that was applied to A such that A*P = Q*R
+      * It is the combination of the fill-in reducing permutation and numerical column pivoting.
+      */
+    const PermutationType& colsPermutation() const
+    { 
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_outputPerm_c;
+    }
+    
+    /** \returns A string describing the type of error.
+      * This method is provided to ease debugging, not to handle errors.
+      */
+    std::string lastErrorMessage() const { return m_lastError; }
+    
+    /** \internal */
+    template<typename Rhs, typename Dest>
+    bool _solve_impl(const MatrixBase<Rhs> &B, MatrixBase<Dest> &dest) const
+    {
+      eigen_assert(m_isInitialized && "The factorization should be called first, use compute()");
+      eigen_assert(this->rows() == B.rows() && "SparseQR::solve() : invalid number of rows in the right hand side matrix");
+
+      Index rank = this->rank();
+      
+      // Compute Q^T * b;
+      typename Dest::PlainObject y, b;
+      y = this->matrixQ().transpose() * B; 
+      b = y;
+      
+      // Solve with the triangular matrix R
+      y.resize((std::max<Index>)(cols(),y.rows()),y.cols());
+      y.topRows(rank) = this->matrixR().topLeftCorner(rank, rank).template triangularView<Upper>().solve(b.topRows(rank));
+      y.bottomRows(y.rows()-rank).setZero();
+      
+      // Apply the column permutation
+      if (m_perm_c.size())  dest = colsPermutation() * y.topRows(cols());
+      else                  dest = y.topRows(cols());
+      
+      m_info = Success;
+      return true;
+    }
+
+    /** Sets the threshold that is used to determine linearly dependent columns during the factorization.
+      *
+      * In practice, if during the factorization the norm of the column that has to be eliminated is below
+      * this threshold, then the entire column is treated as zero, and it is moved at the end.
+      */
+    void setPivotThreshold(const RealScalar& threshold)
+    {
+      m_useDefaultThreshold = false;
+      m_threshold = threshold;
+    }
+    
+    /** \returns the solution X of \f$ A X = B \f$ using the current decomposition of A.
+      *
+      * \sa compute()
+      */
+    template<typename Rhs>
+    inline const Solve<SparseQR, Rhs> solve(const MatrixBase<Rhs>& B) const 
+    {
+      eigen_assert(m_isInitialized && "The factorization should be called first, use compute()");
+      eigen_assert(this->rows() == B.rows() && "SparseQR::solve() : invalid number of rows in the right hand side matrix");
+      return Solve<SparseQR, Rhs>(*this, B.derived());
+    }
+    template<typename Rhs>
+    inline const Solve<SparseQR, Rhs> solve(const SparseMatrixBase<Rhs>& B) const
+    {
+          eigen_assert(m_isInitialized && "The factorization should be called first, use compute()");
+          eigen_assert(this->rows() == B.rows() && "SparseQR::solve() : invalid number of rows in the right hand side matrix");
+          return Solve<SparseQR, Rhs>(*this, B.derived());
+    }
+    
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the QR factorization reports a numerical problem
+      *          \c InvalidInput if the input matrix is invalid
+      *
+      * \sa iparm()          
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_info;
+    }
+
+
+    /** \internal */
+    inline void _sort_matrix_Q()
+    {
+      if(this->m_isQSorted) return;
+      // The matrix Q is sorted during the transposition
+      SparseMatrix<Scalar, RowMajor, Index> mQrm(this->m_Q);
+      this->m_Q = mQrm;
+      this->m_isQSorted = true;
+    }
+
+    
+  protected:
+    bool m_analysisIsok;
+    bool m_factorizationIsok;
+    mutable ComputationInfo m_info;
+    std::string m_lastError;
+    QRMatrixType m_pmat;            // Temporary matrix
+    QRMatrixType m_R;               // The triangular factor matrix
+    QRMatrixType m_Q;               // The orthogonal reflectors
+    ScalarVector m_hcoeffs;         // The Householder coefficients
+    PermutationType m_perm_c;       // Fill-reducing  Column  permutation
+    PermutationType m_pivotperm;    // The permutation for rank revealing
+    PermutationType m_outputPerm_c; // The final column permutation
+    RealScalar m_threshold;         // Threshold to determine null Householder reflections
+    bool m_useDefaultThreshold;     // Use default threshold
+    Index m_nonzeropivots;          // Number of non zero pivots found
+    IndexVector m_etree;            // Column elimination tree
+    IndexVector m_firstRowElt;      // First element in each row
+    bool m_isQSorted;               // whether Q is sorted or not
+    bool m_isEtreeOk;               // whether the elimination tree match the initial input matrix
+    
+    template <typename, typename > friend struct SparseQR_QProduct;
+    
+};
+
+/** \brief Preprocessing step of a QR factorization 
+  * 
+  * \warning The matrix \a mat must be in compressed mode (see SparseMatrix::makeCompressed()).
+  * 
+  * In this step, the fill-reducing permutation is computed and applied to the columns of A
+  * and the column elimination tree is computed as well. Only the sparsity pattern of \a mat is exploited.
+  * 
+  * \note In this step it is assumed that there is no empty row in the matrix \a mat.
+  */
+template <typename MatrixType, typename OrderingType>
+void SparseQR<MatrixType,OrderingType>::analyzePattern(const MatrixType& mat)
+{
+  eigen_assert(mat.isCompressed() && "SparseQR requires a sparse matrix in compressed mode. Call .makeCompressed() before passing it to SparseQR");
+  // Copy to a column major matrix if the input is rowmajor
+  typename internal::conditional<MatrixType::IsRowMajor,QRMatrixType,const MatrixType&>::type matCpy(mat);
+  // Compute the column fill reducing ordering
+  OrderingType ord; 
+  ord(matCpy, m_perm_c); 
+  Index n = mat.cols();
+  Index m = mat.rows();
+  Index diagSize = (std::min)(m,n);
+  
+  if (!m_perm_c.size())
+  {
+    m_perm_c.resize(n);
+    m_perm_c.indices().setLinSpaced(n, 0,StorageIndex(n-1));
+  }
+  
+  // Compute the column elimination tree of the permuted matrix
+  m_outputPerm_c = m_perm_c.inverse();
+  internal::coletree(matCpy, m_etree, m_firstRowElt, m_outputPerm_c.indices().data());
+  m_isEtreeOk = true;
+  
+  m_R.resize(diagSize, n);
+  m_Q.resize(m, diagSize);
+  
+  // Allocate space for nonzero elements : rough estimation
+  m_R.reserve(2*mat.nonZeros()); //FIXME Get a more accurate estimation through symbolic factorization with the etree
+  m_Q.reserve(2*mat.nonZeros());
+  m_hcoeffs.resize(diagSize);
+  m_analysisIsok = true;
+}
+
+/** \brief Performs the numerical QR factorization of the input matrix
+  * 
+  * The function SparseQR::analyzePattern(const MatrixType&) must have been called beforehand with
+  * a matrix having the same sparsity pattern than \a mat.
+  * 
+  * \param mat The sparse column-major matrix
+  */
+template <typename MatrixType, typename OrderingType>
+void SparseQR<MatrixType,OrderingType>::factorize(const MatrixType& mat)
+{
+  using std::abs;
+  
+  eigen_assert(m_analysisIsok && "analyzePattern() should be called before this step");
+  StorageIndex m = StorageIndex(mat.rows());
+  StorageIndex n = StorageIndex(mat.cols());
+  StorageIndex diagSize = (std::min)(m,n);
+  IndexVector mark((std::max)(m,n)); mark.setConstant(-1);  // Record the visited nodes
+  IndexVector Ridx(n), Qidx(m);                             // Store temporarily the row indexes for the current column of R and Q
+  Index nzcolR, nzcolQ;                                     // Number of nonzero for the current column of R and Q
+  ScalarVector tval(m);                                     // The dense vector used to compute the current column
+  RealScalar pivotThreshold = m_threshold;
+  
+  m_R.setZero();
+  m_Q.setZero();
+  m_pmat = mat;
+  if(!m_isEtreeOk)
+  {
+    m_outputPerm_c = m_perm_c.inverse();
+    internal::coletree(m_pmat, m_etree, m_firstRowElt, m_outputPerm_c.indices().data());
+    m_isEtreeOk = true;
+  }
+
+  m_pmat.uncompress(); // To have the innerNonZeroPtr allocated
+  
+  // Apply the fill-in reducing permutation lazily:
+  {
+    // If the input is row major, copy the original column indices,
+    // otherwise directly use the input matrix
+    // 
+    IndexVector originalOuterIndicesCpy;
+    const StorageIndex *originalOuterIndices = mat.outerIndexPtr();
+    if(MatrixType::IsRowMajor)
+    {
+      originalOuterIndicesCpy = IndexVector::Map(m_pmat.outerIndexPtr(),n+1);
+      originalOuterIndices = originalOuterIndicesCpy.data();
+    }
+    
+    for (int i = 0; i < n; i++)
+    {
+      Index p = m_perm_c.size() ? m_perm_c.indices()(i) : i;
+      m_pmat.outerIndexPtr()[p] = originalOuterIndices[i]; 
+      m_pmat.innerNonZeroPtr()[p] = originalOuterIndices[i+1] - originalOuterIndices[i]; 
+    }
+  }
+  
+  /* Compute the default threshold as in MatLab, see:
+   * Tim Davis, "Algorithm 915, SuiteSparseQR: Multifrontal Multithreaded Rank-Revealing
+   * Sparse QR Factorization, ACM Trans. on Math. Soft. 38(1), 2011, Page 8:3 
+   */
+  if(m_useDefaultThreshold) 
+  {
+    RealScalar max2Norm = 0.0;
+    for (int j = 0; j < n; j++) max2Norm = numext::maxi(max2Norm, m_pmat.col(j).norm());
+    if(max2Norm==RealScalar(0))
+      max2Norm = RealScalar(1);
+    pivotThreshold = 20 * (m + n) * max2Norm * NumTraits<RealScalar>::epsilon();
+  }
+  
+  // Initialize the numerical permutation
+  m_pivotperm.setIdentity(n);
+  
+  StorageIndex nonzeroCol = 0; // Record the number of valid pivots
+  m_Q.startVec(0);
+
+  // Left looking rank-revealing QR factorization: compute a column of R and Q at a time
+  for (StorageIndex col = 0; col < n; ++col)
+  {
+    mark.setConstant(-1);
+    m_R.startVec(col);
+    mark(nonzeroCol) = col;
+    Qidx(0) = nonzeroCol;
+    nzcolR = 0; nzcolQ = 1;
+    bool found_diag = nonzeroCol>=m;
+    tval.setZero(); 
+    
+    // Symbolic factorization: find the nonzero locations of the column k of the factors R and Q, i.e.,
+    // all the nodes (with indexes lower than rank) reachable through the column elimination tree (etree) rooted at node k.
+    // Note: if the diagonal entry does not exist, then its contribution must be explicitly added,
+    // thus the trick with found_diag that permits to do one more iteration on the diagonal element if this one has not been found.
+    for (typename QRMatrixType::InnerIterator itp(m_pmat, col); itp || !found_diag; ++itp)
+    {
+      StorageIndex curIdx = nonzeroCol;
+      if(itp) curIdx = StorageIndex(itp.row());
+      if(curIdx == nonzeroCol) found_diag = true;
+      
+      // Get the nonzeros indexes of the current column of R
+      StorageIndex st = m_firstRowElt(curIdx); // The traversal of the etree starts here
+      if (st < 0 )
+      {
+        m_lastError = "Empty row found during numerical factorization";
+        m_info = InvalidInput;
+        return;
+      }
+
+      // Traverse the etree 
+      Index bi = nzcolR;
+      for (; mark(st) != col; st = m_etree(st))
+      {
+        Ridx(nzcolR) = st;  // Add this row to the list,
+        mark(st) = col;     // and mark this row as visited
+        nzcolR++;
+      }
+
+      // Reverse the list to get the topological ordering
+      Index nt = nzcolR-bi;
+      for(Index i = 0; i < nt/2; i++) std::swap(Ridx(bi+i), Ridx(nzcolR-i-1));
+       
+      // Copy the current (curIdx,pcol) value of the input matrix
+      if(itp) tval(curIdx) = itp.value();
+      else    tval(curIdx) = Scalar(0);
+      
+      // Compute the pattern of Q(:,k)
+      if(curIdx > nonzeroCol && mark(curIdx) != col ) 
+      {
+        Qidx(nzcolQ) = curIdx;  // Add this row to the pattern of Q,
+        mark(curIdx) = col;     // and mark it as visited
+        nzcolQ++;
+      }
+    }
+
+    // Browse all the indexes of R(:,col) in reverse order
+    for (Index i = nzcolR-1; i >= 0; i--)
+    {
+      Index curIdx = Ridx(i);
+      
+      // Apply the curIdx-th householder vector to the current column (temporarily stored into tval)
+      Scalar tdot(0);
+      
+      // First compute q' * tval
+      tdot = m_Q.col(curIdx).dot(tval);
+
+      tdot *= m_hcoeffs(curIdx);
+      
+      // Then update tval = tval - q * tau
+      // FIXME: tval -= tdot * m_Q.col(curIdx) should amount to the same (need to check/add support for efficient "dense ?= sparse")
+      for (typename QRMatrixType::InnerIterator itq(m_Q, curIdx); itq; ++itq)
+        tval(itq.row()) -= itq.value() * tdot;
+
+      // Detect fill-in for the current column of Q
+      if(m_etree(Ridx(i)) == nonzeroCol)
+      {
+        for (typename QRMatrixType::InnerIterator itq(m_Q, curIdx); itq; ++itq)
+        {
+          StorageIndex iQ = StorageIndex(itq.row());
+          if (mark(iQ) != col)
+          {
+            Qidx(nzcolQ++) = iQ;  // Add this row to the pattern of Q,
+            mark(iQ) = col;       // and mark it as visited
+          }
+        }
+      }
+    } // End update current column
+    
+    Scalar tau = RealScalar(0);
+    RealScalar beta = 0;
+    
+    if(nonzeroCol < diagSize)
+    {
+      // Compute the Householder reflection that eliminate the current column
+      // FIXME this step should call the Householder module.
+      Scalar c0 = nzcolQ ? tval(Qidx(0)) : Scalar(0);
+      
+      // First, the squared norm of Q((col+1):m, col)
+      RealScalar sqrNorm = 0.;
+      for (Index itq = 1; itq < nzcolQ; ++itq) sqrNorm += numext::abs2(tval(Qidx(itq)));
+      if(sqrNorm == RealScalar(0) && numext::imag(c0) == RealScalar(0))
+      {
+        beta = numext::real(c0);
+        tval(Qidx(0)) = 1;
+      }
+      else
+      {
+        using std::sqrt;
+        beta = sqrt(numext::abs2(c0) + sqrNorm);
+        if(numext::real(c0) >= RealScalar(0))
+          beta = -beta;
+        tval(Qidx(0)) = 1;
+        for (Index itq = 1; itq < nzcolQ; ++itq)
+          tval(Qidx(itq)) /= (c0 - beta);
+        tau = numext::conj((beta-c0) / beta);
+          
+      }
+    }
+
+    // Insert values in R
+    for (Index  i = nzcolR-1; i >= 0; i--)
+    {
+      Index curIdx = Ridx(i);
+      if(curIdx < nonzeroCol) 
+      {
+        m_R.insertBackByOuterInnerUnordered(col, curIdx) = tval(curIdx);
+        tval(curIdx) = Scalar(0.);
+      }
+    }
+
+    if(nonzeroCol < diagSize && abs(beta) >= pivotThreshold)
+    {
+      m_R.insertBackByOuterInner(col, nonzeroCol) = beta;
+      // The householder coefficient
+      m_hcoeffs(nonzeroCol) = tau;
+      // Record the householder reflections
+      for (Index itq = 0; itq < nzcolQ; ++itq)
+      {
+        Index iQ = Qidx(itq);
+        m_Q.insertBackByOuterInnerUnordered(nonzeroCol,iQ) = tval(iQ);
+        tval(iQ) = Scalar(0.);
+      }
+      nonzeroCol++;
+      if(nonzeroCol<diagSize)
+        m_Q.startVec(nonzeroCol);
+    }
+    else
+    {
+      // Zero pivot found: move implicitly this column to the end
+      for (Index j = nonzeroCol; j < n-1; j++) 
+        std::swap(m_pivotperm.indices()(j), m_pivotperm.indices()[j+1]);
+      
+      // Recompute the column elimination tree
+      internal::coletree(m_pmat, m_etree, m_firstRowElt, m_pivotperm.indices().data());
+      m_isEtreeOk = false;
+    }
+  }
+  
+  m_hcoeffs.tail(diagSize-nonzeroCol).setZero();
+  
+  // Finalize the column pointers of the sparse matrices R and Q
+  m_Q.finalize();
+  m_Q.makeCompressed();
+  m_R.finalize();
+  m_R.makeCompressed();
+  m_isQSorted = false;
+
+  m_nonzeropivots = nonzeroCol;
+  
+  if(nonzeroCol<n)
+  {
+    // Permute the triangular factor to put the 'dead' columns to the end
+    QRMatrixType tempR(m_R);
+    m_R = tempR * m_pivotperm;
+    
+    // Update the column permutation
+    m_outputPerm_c = m_outputPerm_c * m_pivotperm;
+  }
+  
+  m_isInitialized = true; 
+  m_factorizationIsok = true;
+  m_info = Success;
+}
+
+template <typename SparseQRType, typename Derived>
+struct SparseQR_QProduct : ReturnByValue<SparseQR_QProduct<SparseQRType, Derived> >
+{
+  typedef typename SparseQRType::QRMatrixType MatrixType;
+  typedef typename SparseQRType::Scalar Scalar;
+  // Get the references 
+  SparseQR_QProduct(const SparseQRType& qr, const Derived& other, bool transpose) : 
+  m_qr(qr),m_other(other),m_transpose(transpose) {}
+  inline Index rows() const { return m_transpose ? m_qr.rows() : m_qr.cols(); }
+  inline Index cols() const { return m_other.cols(); }
+  
+  // Assign to a vector
+  template<typename DesType>
+  void evalTo(DesType& res) const
+  {
+    Index m = m_qr.rows();
+    Index n = m_qr.cols();
+    Index diagSize = (std::min)(m,n);
+    res = m_other;
+    if (m_transpose)
+    {
+      eigen_assert(m_qr.m_Q.rows() == m_other.rows() && "Non conforming object sizes");
+      //Compute res = Q' * other column by column
+      for(Index j = 0; j < res.cols(); j++){
+        for (Index k = 0; k < diagSize; k++)
+        {
+          Scalar tau = Scalar(0);
+          tau = m_qr.m_Q.col(k).dot(res.col(j));
+          if(tau==Scalar(0)) continue;
+          tau = tau * m_qr.m_hcoeffs(k);
+          res.col(j) -= tau * m_qr.m_Q.col(k);
+        }
+      }
+    }
+    else
+    {
+      eigen_assert(m_qr.m_Q.rows() == m_other.rows() && "Non conforming object sizes");
+      // Compute res = Q * other column by column
+      for(Index j = 0; j < res.cols(); j++)
+      {
+        for (Index k = diagSize-1; k >=0; k--)
+        {
+          Scalar tau = Scalar(0);
+          tau = m_qr.m_Q.col(k).dot(res.col(j));
+          if(tau==Scalar(0)) continue;
+          tau = tau * m_qr.m_hcoeffs(k);
+          res.col(j) -= tau * m_qr.m_Q.col(k);
+        }
+      }
+    }
+  }
+  
+  const SparseQRType& m_qr;
+  const Derived& m_other;
+  bool m_transpose;
+};
+
+template<typename SparseQRType>
+struct SparseQRMatrixQReturnType : public EigenBase<SparseQRMatrixQReturnType<SparseQRType> >
+{  
+  typedef typename SparseQRType::Scalar Scalar;
+  typedef Matrix<Scalar,Dynamic,Dynamic> DenseMatrix;
+  enum {
+    RowsAtCompileTime = Dynamic,
+    ColsAtCompileTime = Dynamic
+  };
+  explicit SparseQRMatrixQReturnType(const SparseQRType& qr) : m_qr(qr) {}
+  template<typename Derived>
+  SparseQR_QProduct<SparseQRType, Derived> operator*(const MatrixBase<Derived>& other)
+  {
+    return SparseQR_QProduct<SparseQRType,Derived>(m_qr,other.derived(),false);
+  }
+  SparseQRMatrixQTransposeReturnType<SparseQRType> adjoint() const
+  {
+    return SparseQRMatrixQTransposeReturnType<SparseQRType>(m_qr);
+  }
+  inline Index rows() const { return m_qr.rows(); }
+  inline Index cols() const { return (std::min)(m_qr.rows(),m_qr.cols()); }
+  // To use for operations with the transpose of Q
+  SparseQRMatrixQTransposeReturnType<SparseQRType> transpose() const
+  {
+    return SparseQRMatrixQTransposeReturnType<SparseQRType>(m_qr);
+  }
+  const SparseQRType& m_qr;
+};
+
+template<typename SparseQRType>
+struct SparseQRMatrixQTransposeReturnType
+{
+  explicit SparseQRMatrixQTransposeReturnType(const SparseQRType& qr) : m_qr(qr) {}
+  template<typename Derived>
+  SparseQR_QProduct<SparseQRType,Derived> operator*(const MatrixBase<Derived>& other)
+  {
+    return SparseQR_QProduct<SparseQRType,Derived>(m_qr,other.derived(), true);
+  }
+  const SparseQRType& m_qr;
+};
+
+namespace internal {
+  
+template<typename SparseQRType>
+struct evaluator_traits<SparseQRMatrixQReturnType<SparseQRType> >
+{
+  typedef typename SparseQRType::MatrixType MatrixType;
+  typedef typename storage_kind_to_evaluator_kind<typename MatrixType::StorageKind>::Kind Kind;
+  typedef SparseShape Shape;
+};
+
+template< typename DstXprType, typename SparseQRType>
+struct Assignment<DstXprType, SparseQRMatrixQReturnType<SparseQRType>, internal::assign_op<typename DstXprType::Scalar,typename DstXprType::Scalar>, Sparse2Sparse>
+{
+  typedef SparseQRMatrixQReturnType<SparseQRType> SrcXprType;
+  typedef typename DstXprType::Scalar Scalar;
+  typedef typename DstXprType::StorageIndex StorageIndex;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &/*func*/)
+  {
+    typename DstXprType::PlainObject idMat(src.m_qr.rows(), src.m_qr.rows());
+    idMat.setIdentity();
+    // Sort the sparse householder reflectors if needed
+    const_cast<SparseQRType *>(&src.m_qr)->_sort_matrix_Q();
+    dst = SparseQR_QProduct<SparseQRType, DstXprType>(src.m_qr, idMat, false);
+  }
+};
+
+template< typename DstXprType, typename SparseQRType>
+struct Assignment<DstXprType, SparseQRMatrixQReturnType<SparseQRType>, internal::assign_op<typename DstXprType::Scalar,typename DstXprType::Scalar>, Sparse2Dense>
+{
+  typedef SparseQRMatrixQReturnType<SparseQRType> SrcXprType;
+  typedef typename DstXprType::Scalar Scalar;
+  typedef typename DstXprType::StorageIndex StorageIndex;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &/*func*/)
+  {
+    dst = src.m_qr.matrixQ() * DstXprType::Identity(src.m_qr.rows(), src.m_qr.rows());
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/StlSupport/StdDeque.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/StlSupport/StdDeque.h
new file mode 100644
index 00000000..cf1fedf9
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/StlSupport/StdDeque.h
@@ -0,0 +1,126 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STDDEQUE_H
+#define EIGEN_STDDEQUE_H
+
+#include "details.h"
+
+/**
+ * This section contains a convenience MACRO which allows an easy specialization of
+ * std::deque such that for data types with alignment issues the correct allocator
+ * is used automatically.
+ */
+#define EIGEN_DEFINE_STL_DEQUE_SPECIALIZATION(...) \
+namespace std \
+{ \
+  template<> \
+  class deque<__VA_ARGS__, std::allocator<__VA_ARGS__> >           \
+    : public deque<__VA_ARGS__, EIGEN_ALIGNED_ALLOCATOR<__VA_ARGS__> > \
+  { \
+    typedef deque<__VA_ARGS__, EIGEN_ALIGNED_ALLOCATOR<__VA_ARGS__> > deque_base; \
+  public: \
+    typedef __VA_ARGS__ value_type; \
+    typedef deque_base::allocator_type allocator_type; \
+    typedef deque_base::size_type size_type;  \
+    typedef deque_base::iterator iterator;  \
+    explicit deque(const allocator_type& a = allocator_type()) : deque_base(a) {}  \
+    template<typename InputIterator> \
+    deque(InputIterator first, InputIterator last, const allocator_type& a = allocator_type()) : deque_base(first, last, a) {} \
+    deque(const deque& c) : deque_base(c) {}  \
+    explicit deque(size_type num, const value_type& val = value_type()) : deque_base(num, val) {} \
+    deque(iterator start, iterator end) : deque_base(start, end) {}  \
+    deque& operator=(const deque& x) {  \
+      deque_base::operator=(x);  \
+      return *this;  \
+    } \
+  }; \
+}
+
+// check whether we really need the std::deque specialization
+#if !EIGEN_HAS_CXX11_CONTAINERS && !(defined(_GLIBCXX_DEQUE) && (!EIGEN_GNUC_AT_LEAST(4,1))) /* Note that before gcc-4.1 we already have: std::deque::resize(size_type,const T&). */
+
+namespace std {
+
+#define EIGEN_STD_DEQUE_SPECIALIZATION_BODY \
+  public:  \
+    typedef T value_type; \
+    typedef typename deque_base::allocator_type allocator_type; \
+    typedef typename deque_base::size_type size_type;  \
+    typedef typename deque_base::iterator iterator;  \
+    typedef typename deque_base::const_iterator const_iterator;  \
+    explicit deque(const allocator_type& a = allocator_type()) : deque_base(a) {}  \
+    template<typename InputIterator> \
+    deque(InputIterator first, InputIterator last, const allocator_type& a = allocator_type()) \
+    : deque_base(first, last, a) {} \
+    deque(const deque& c) : deque_base(c) {}  \
+    explicit deque(size_type num, const value_type& val = value_type()) : deque_base(num, val) {} \
+    deque(iterator start, iterator end) : deque_base(start, end) {}  \
+    deque& operator=(const deque& x) {  \
+      deque_base::operator=(x);  \
+      return *this;  \
+    }
+
+  template<typename T>
+  class deque<T,EIGEN_ALIGNED_ALLOCATOR<T> >
+    : public deque<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T),
+                   Eigen::aligned_allocator_indirection<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T)> >
+{
+  typedef deque<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T),
+                Eigen::aligned_allocator_indirection<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T)> > deque_base;
+  EIGEN_STD_DEQUE_SPECIALIZATION_BODY
+
+  void resize(size_type new_size)
+  { resize(new_size, T()); }
+
+#if defined(_DEQUE_)
+  // workaround MSVC std::deque implementation
+  void resize(size_type new_size, const value_type& x)
+  {
+    if (deque_base::size() < new_size)
+      deque_base::_Insert_n(deque_base::end(), new_size - deque_base::size(), x);
+    else if (new_size < deque_base::size())
+      deque_base::erase(deque_base::begin() + new_size, deque_base::end());
+  }
+  void push_back(const value_type& x)
+  { deque_base::push_back(x); } 
+  void push_front(const value_type& x)
+  { deque_base::push_front(x); }
+  using deque_base::insert;  
+  iterator insert(const_iterator position, const value_type& x)
+  { return deque_base::insert(position,x); }
+  void insert(const_iterator position, size_type new_size, const value_type& x)
+  { deque_base::insert(position, new_size, x); }
+#elif defined(_GLIBCXX_DEQUE) && EIGEN_GNUC_AT_LEAST(4,2)
+  // workaround GCC std::deque implementation
+  void resize(size_type new_size, const value_type& x)
+  {
+    if (new_size < deque_base::size())
+      deque_base::_M_erase_at_end(this->_M_impl._M_start + new_size);
+    else
+      deque_base::insert(deque_base::end(), new_size - deque_base::size(), x);
+  }
+#else
+  // either GCC 4.1 or non-GCC
+  // default implementation which should always work.
+  void resize(size_type new_size, const value_type& x)
+  {
+    if (new_size < deque_base::size())
+      deque_base::erase(deque_base::begin() + new_size, deque_base::end());
+    else if (new_size > deque_base::size())
+      deque_base::insert(deque_base::end(), new_size - deque_base::size(), x);
+  }
+#endif
+  };
+}
+
+#endif // check whether specialization is actually required
+
+#endif // EIGEN_STDDEQUE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/StlSupport/StdList.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/StlSupport/StdList.h
new file mode 100644
index 00000000..e1eba498
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/StlSupport/StdList.h
@@ -0,0 +1,106 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STDLIST_H
+#define EIGEN_STDLIST_H
+
+#include "details.h"
+
+/**
+ * This section contains a convenience MACRO which allows an easy specialization of
+ * std::list such that for data types with alignment issues the correct allocator
+ * is used automatically.
+ */
+#define EIGEN_DEFINE_STL_LIST_SPECIALIZATION(...) \
+namespace std \
+{ \
+  template<> \
+  class list<__VA_ARGS__, std::allocator<__VA_ARGS__> >           \
+    : public list<__VA_ARGS__, EIGEN_ALIGNED_ALLOCATOR<__VA_ARGS__> > \
+  { \
+    typedef list<__VA_ARGS__, EIGEN_ALIGNED_ALLOCATOR<__VA_ARGS__> > list_base; \
+  public: \
+    typedef __VA_ARGS__ value_type; \
+    typedef list_base::allocator_type allocator_type; \
+    typedef list_base::size_type size_type;  \
+    typedef list_base::iterator iterator;  \
+    explicit list(const allocator_type& a = allocator_type()) : list_base(a) {}  \
+    template<typename InputIterator> \
+    list(InputIterator first, InputIterator last, const allocator_type& a = allocator_type()) : list_base(first, last, a) {} \
+    list(const list& c) : list_base(c) {}  \
+    explicit list(size_type num, const value_type& val = value_type()) : list_base(num, val) {} \
+    list(iterator start, iterator end) : list_base(start, end) {}  \
+    list& operator=(const list& x) {  \
+      list_base::operator=(x);  \
+      return *this;  \
+    } \
+  }; \
+}
+
+// check whether we really need the std::list specialization
+#if !EIGEN_HAS_CXX11_CONTAINERS && !(defined(_GLIBCXX_LIST) && (!EIGEN_GNUC_AT_LEAST(4,1))) /* Note that before gcc-4.1 we already have: std::list::resize(size_type,const T&). */
+
+namespace std
+{
+
+#define EIGEN_STD_LIST_SPECIALIZATION_BODY \
+  public:  \
+    typedef T value_type; \
+    typedef typename list_base::allocator_type allocator_type; \
+    typedef typename list_base::size_type size_type;  \
+    typedef typename list_base::iterator iterator;  \
+    typedef typename list_base::const_iterator const_iterator;  \
+    explicit list(const allocator_type& a = allocator_type()) : list_base(a) {}  \
+    template<typename InputIterator> \
+    list(InputIterator first, InputIterator last, const allocator_type& a = allocator_type()) \
+    : list_base(first, last, a) {} \
+    list(const list& c) : list_base(c) {}  \
+    explicit list(size_type num, const value_type& val = value_type()) : list_base(num, val) {} \
+    list(iterator start, iterator end) : list_base(start, end) {}  \
+    list& operator=(const list& x) {  \
+    list_base::operator=(x);  \
+    return *this; \
+  }
+
+  template<typename T>
+  class list<T,EIGEN_ALIGNED_ALLOCATOR<T> >
+    : public list<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T),
+                  Eigen::aligned_allocator_indirection<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T)> >
+  {
+    typedef list<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T),
+                 Eigen::aligned_allocator_indirection<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T)> > list_base;
+    EIGEN_STD_LIST_SPECIALIZATION_BODY
+
+    void resize(size_type new_size)
+    { resize(new_size, T()); }
+
+    void resize(size_type new_size, const value_type& x)
+    {
+      if (list_base::size() < new_size)
+        list_base::insert(list_base::end(), new_size - list_base::size(), x);
+      else
+        while (new_size < list_base::size()) list_base::pop_back();
+    }
+
+#if defined(_LIST_)
+    // workaround MSVC std::list implementation
+    void push_back(const value_type& x)
+    { list_base::push_back(x); } 
+    using list_base::insert;  
+    iterator insert(const_iterator position, const value_type& x)
+    { return list_base::insert(position,x); }
+    void insert(const_iterator position, size_type new_size, const value_type& x)
+    { list_base::insert(position, new_size, x); }
+#endif
+  };
+}
+
+#endif // check whether specialization is actually required
+
+#endif // EIGEN_STDLIST_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/StlSupport/StdVector.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/StlSupport/StdVector.h
new file mode 100644
index 00000000..ec22821d
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/StlSupport/StdVector.h
@@ -0,0 +1,131 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STDVECTOR_H
+#define EIGEN_STDVECTOR_H
+
+#include "details.h"
+
+/**
+ * This section contains a convenience MACRO which allows an easy specialization of
+ * std::vector such that for data types with alignment issues the correct allocator
+ * is used automatically.
+ */
+#define EIGEN_DEFINE_STL_VECTOR_SPECIALIZATION(...) \
+namespace std \
+{ \
+  template<> \
+  class vector<__VA_ARGS__, std::allocator<__VA_ARGS__> >  \
+    : public vector<__VA_ARGS__, EIGEN_ALIGNED_ALLOCATOR<__VA_ARGS__> > \
+  { \
+    typedef vector<__VA_ARGS__, EIGEN_ALIGNED_ALLOCATOR<__VA_ARGS__> > vector_base; \
+  public: \
+    typedef __VA_ARGS__ value_type; \
+    typedef vector_base::allocator_type allocator_type; \
+    typedef vector_base::size_type size_type;  \
+    typedef vector_base::iterator iterator;  \
+    explicit vector(const allocator_type& a = allocator_type()) : vector_base(a) {}  \
+    template<typename InputIterator> \
+    vector(InputIterator first, InputIterator last, const allocator_type& a = allocator_type()) : vector_base(first, last, a) {} \
+    vector(const vector& c) : vector_base(c) {}  \
+    explicit vector(size_type num, const value_type& val = value_type()) : vector_base(num, val) {} \
+    vector(iterator start, iterator end) : vector_base(start, end) {}  \
+    vector& operator=(const vector& x) {  \
+      vector_base::operator=(x);  \
+      return *this;  \
+    } \
+  }; \
+}
+
+// Don't specialize if containers are implemented according to C++11
+#if !EIGEN_HAS_CXX11_CONTAINERS
+
+namespace std {
+
+#define EIGEN_STD_VECTOR_SPECIALIZATION_BODY \
+  public:  \
+    typedef T value_type; \
+    typedef typename vector_base::allocator_type allocator_type; \
+    typedef typename vector_base::size_type size_type;  \
+    typedef typename vector_base::iterator iterator;  \
+    typedef typename vector_base::const_iterator const_iterator;  \
+    explicit vector(const allocator_type& a = allocator_type()) : vector_base(a) {}  \
+    template<typename InputIterator> \
+    vector(InputIterator first, InputIterator last, const allocator_type& a = allocator_type()) \
+    : vector_base(first, last, a) {} \
+    vector(const vector& c) : vector_base(c) {}  \
+    explicit vector(size_type num, const value_type& val = value_type()) : vector_base(num, val) {} \
+    vector(iterator start, iterator end) : vector_base(start, end) {}  \
+    vector& operator=(const vector& x) {  \
+      vector_base::operator=(x);  \
+      return *this;  \
+    }
+
+  template<typename T>
+  class vector<T,EIGEN_ALIGNED_ALLOCATOR<T> >
+    : public vector<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T),
+                    Eigen::aligned_allocator_indirection<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T)> >
+{
+  typedef vector<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T),
+                 Eigen::aligned_allocator_indirection<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T)> > vector_base;
+  EIGEN_STD_VECTOR_SPECIALIZATION_BODY
+
+  void resize(size_type new_size)
+  { resize(new_size, T()); }
+
+#if defined(_VECTOR_)
+  // workaround MSVC std::vector implementation
+  void resize(size_type new_size, const value_type& x)
+  {
+    if (vector_base::size() < new_size)
+      vector_base::_Insert_n(vector_base::end(), new_size - vector_base::size(), x);
+    else if (new_size < vector_base::size())
+      vector_base::erase(vector_base::begin() + new_size, vector_base::end());
+  }
+  void push_back(const value_type& x)
+  { vector_base::push_back(x); } 
+  using vector_base::insert;  
+  iterator insert(const_iterator position, const value_type& x)
+  { return vector_base::insert(position,x); }
+  void insert(const_iterator position, size_type new_size, const value_type& x)
+  { vector_base::insert(position, new_size, x); }
+#elif defined(_GLIBCXX_VECTOR) && (!(EIGEN_GNUC_AT_LEAST(4,1)))
+  /* Note that before gcc-4.1 we already have: std::vector::resize(size_type,const T&).
+   * However, this specialization is still needed to make the above EIGEN_DEFINE_STL_VECTOR_SPECIALIZATION trick to work. */
+  void resize(size_type new_size, const value_type& x)
+  {
+    vector_base::resize(new_size,x);
+  }
+#elif defined(_GLIBCXX_VECTOR) && EIGEN_GNUC_AT_LEAST(4,2)
+  // workaround GCC std::vector implementation
+  void resize(size_type new_size, const value_type& x)
+  {
+    if (new_size < vector_base::size())
+      vector_base::_M_erase_at_end(this->_M_impl._M_start + new_size);
+    else
+      vector_base::insert(vector_base::end(), new_size - vector_base::size(), x);
+  }
+#else
+  // either GCC 4.1 or non-GCC
+  // default implementation which should always work.
+  void resize(size_type new_size, const value_type& x)
+  {
+    if (new_size < vector_base::size())
+      vector_base::erase(vector_base::begin() + new_size, vector_base::end());
+    else if (new_size > vector_base::size())
+      vector_base::insert(vector_base::end(), new_size - vector_base::size(), x);
+  }
+#endif
+  };
+}
+#endif // !EIGEN_HAS_CXX11_CONTAINERS
+
+
+#endif // EIGEN_STDVECTOR_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/StlSupport/details.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/StlSupport/details.h
new file mode 100644
index 00000000..2cfd13e0
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/StlSupport/details.h
@@ -0,0 +1,84 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STL_DETAILS_H
+#define EIGEN_STL_DETAILS_H
+
+#ifndef EIGEN_ALIGNED_ALLOCATOR
+  #define EIGEN_ALIGNED_ALLOCATOR Eigen::aligned_allocator
+#endif
+
+namespace Eigen {
+
+  // This one is needed to prevent reimplementing the whole std::vector.
+  template <class T>
+  class aligned_allocator_indirection : public EIGEN_ALIGNED_ALLOCATOR<T>
+  {
+  public:
+    typedef std::size_t     size_type;
+    typedef std::ptrdiff_t  difference_type;
+    typedef T*              pointer;
+    typedef const T*        const_pointer;
+    typedef T&              reference;
+    typedef const T&        const_reference;
+    typedef T               value_type;
+
+    template<class U>
+    struct rebind
+    {
+      typedef aligned_allocator_indirection<U> other;
+    };
+
+    aligned_allocator_indirection() {}
+    aligned_allocator_indirection(const aligned_allocator_indirection& ) : EIGEN_ALIGNED_ALLOCATOR<T>() {}
+    aligned_allocator_indirection(const EIGEN_ALIGNED_ALLOCATOR<T>& ) {}
+    template<class U>
+    aligned_allocator_indirection(const aligned_allocator_indirection<U>& ) {}
+    template<class U>
+    aligned_allocator_indirection(const EIGEN_ALIGNED_ALLOCATOR<U>& ) {}
+    ~aligned_allocator_indirection() {}
+  };
+
+#if EIGEN_COMP_MSVC
+
+  // sometimes, MSVC detects, at compile time, that the argument x
+  // in std::vector::resize(size_t s,T x) won't be aligned and generate an error
+  // even if this function is never called. Whence this little wrapper.
+#define EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T) \
+  typename Eigen::internal::conditional< \
+    Eigen::internal::is_arithmetic<T>::value, \
+    T, \
+    Eigen::internal::workaround_msvc_stl_support<T> \
+  >::type
+
+  namespace internal {
+  template<typename T> struct workaround_msvc_stl_support : public T
+  {
+    inline workaround_msvc_stl_support() : T() {}
+    inline workaround_msvc_stl_support(const T& other) : T(other) {}
+    inline operator T& () { return *static_cast<T*>(this); }
+    inline operator const T& () const { return *static_cast<const T*>(this); }
+    template<typename OtherT>
+    inline T& operator=(const OtherT& other)
+    { T::operator=(other); return *this; }
+    inline workaround_msvc_stl_support& operator=(const workaround_msvc_stl_support& other)
+    { T::operator=(other); return *this; }
+  };
+  }
+
+#else
+
+#define EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T) T
+
+#endif
+
+}
+
+#endif // EIGEN_STL_DETAILS_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SuperLUSupport/SuperLUSupport.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SuperLUSupport/SuperLUSupport.h
new file mode 100644
index 00000000..50a69f30
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/SuperLUSupport/SuperLUSupport.h
@@ -0,0 +1,1027 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SUPERLUSUPPORT_H
+#define EIGEN_SUPERLUSUPPORT_H
+
+namespace Eigen {
+
+#if defined(SUPERLU_MAJOR_VERSION) && (SUPERLU_MAJOR_VERSION >= 5)
+#define DECL_GSSVX(PREFIX,FLOATTYPE,KEYTYPE)		\
+    extern "C" {                                                                                          \
+      extern void PREFIX##gssvx(superlu_options_t *, SuperMatrix *, int *, int *, int *,                  \
+                                char *, FLOATTYPE *, FLOATTYPE *, SuperMatrix *, SuperMatrix *,           \
+                                void *, int, SuperMatrix *, SuperMatrix *,                                \
+                                FLOATTYPE *, FLOATTYPE *, FLOATTYPE *, FLOATTYPE *,                       \
+                                GlobalLU_t *, mem_usage_t *, SuperLUStat_t *, int *);                     \
+    }                                                                                                     \
+    inline float SuperLU_gssvx(superlu_options_t *options, SuperMatrix *A,                                \
+         int *perm_c, int *perm_r, int *etree, char *equed,                                               \
+         FLOATTYPE *R, FLOATTYPE *C, SuperMatrix *L,                                                      \
+         SuperMatrix *U, void *work, int lwork,                                                           \
+         SuperMatrix *B, SuperMatrix *X,                                                                  \
+         FLOATTYPE *recip_pivot_growth,                                                                   \
+         FLOATTYPE *rcond, FLOATTYPE *ferr, FLOATTYPE *berr,                                              \
+         SuperLUStat_t *stats, int *info, KEYTYPE) {                                                      \
+    mem_usage_t mem_usage;                                                                                \
+    GlobalLU_t gLU;                                                                                       \
+    PREFIX##gssvx(options, A, perm_c, perm_r, etree, equed, R, C, L,                                      \
+         U, work, lwork, B, X, recip_pivot_growth, rcond,                                                 \
+         ferr, berr, &gLU, &mem_usage, stats, info);                                                      \
+    return mem_usage.for_lu; /* bytes used by the factor storage */                                       \
+  }
+#else // version < 5.0
+#define DECL_GSSVX(PREFIX,FLOATTYPE,KEYTYPE)		\
+    extern "C" {                                                                                          \
+      extern void PREFIX##gssvx(superlu_options_t *, SuperMatrix *, int *, int *, int *,                  \
+                                char *, FLOATTYPE *, FLOATTYPE *, SuperMatrix *, SuperMatrix *,           \
+                                void *, int, SuperMatrix *, SuperMatrix *,                                \
+                                FLOATTYPE *, FLOATTYPE *, FLOATTYPE *, FLOATTYPE *,                       \
+                                mem_usage_t *, SuperLUStat_t *, int *);                                   \
+    }                                                                                                     \
+    inline float SuperLU_gssvx(superlu_options_t *options, SuperMatrix *A,                                \
+         int *perm_c, int *perm_r, int *etree, char *equed,                                               \
+         FLOATTYPE *R, FLOATTYPE *C, SuperMatrix *L,                                                      \
+         SuperMatrix *U, void *work, int lwork,                                                           \
+         SuperMatrix *B, SuperMatrix *X,                                                                  \
+         FLOATTYPE *recip_pivot_growth,                                                                   \
+         FLOATTYPE *rcond, FLOATTYPE *ferr, FLOATTYPE *berr,                                              \
+         SuperLUStat_t *stats, int *info, KEYTYPE) {                                                      \
+    mem_usage_t mem_usage;                                                                                \
+    PREFIX##gssvx(options, A, perm_c, perm_r, etree, equed, R, C, L,                                      \
+         U, work, lwork, B, X, recip_pivot_growth, rcond,                                                 \
+         ferr, berr, &mem_usage, stats, info);                                                            \
+    return mem_usage.for_lu; /* bytes used by the factor storage */                                       \
+  }
+#endif
+
+DECL_GSSVX(s,float,float)
+DECL_GSSVX(c,float,std::complex<float>)
+DECL_GSSVX(d,double,double)
+DECL_GSSVX(z,double,std::complex<double>)
+
+#ifdef MILU_ALPHA
+#define EIGEN_SUPERLU_HAS_ILU
+#endif
+
+#ifdef EIGEN_SUPERLU_HAS_ILU
+
+// similarly for the incomplete factorization using gsisx
+#define DECL_GSISX(PREFIX,FLOATTYPE,KEYTYPE)                                                    \
+    extern "C" {                                                                                \
+      extern void PREFIX##gsisx(superlu_options_t *, SuperMatrix *, int *, int *, int *,        \
+                         char *, FLOATTYPE *, FLOATTYPE *, SuperMatrix *, SuperMatrix *,        \
+                         void *, int, SuperMatrix *, SuperMatrix *, FLOATTYPE *, FLOATTYPE *,   \
+                         mem_usage_t *, SuperLUStat_t *, int *);                        \
+    }                                                                                           \
+    inline float SuperLU_gsisx(superlu_options_t *options, SuperMatrix *A,                      \
+         int *perm_c, int *perm_r, int *etree, char *equed,                                     \
+         FLOATTYPE *R, FLOATTYPE *C, SuperMatrix *L,                                            \
+         SuperMatrix *U, void *work, int lwork,                                                 \
+         SuperMatrix *B, SuperMatrix *X,                                                        \
+         FLOATTYPE *recip_pivot_growth,                                                         \
+         FLOATTYPE *rcond,                                                                      \
+         SuperLUStat_t *stats, int *info, KEYTYPE) {                                            \
+    mem_usage_t mem_usage;                                                              \
+    PREFIX##gsisx(options, A, perm_c, perm_r, etree, equed, R, C, L,                            \
+         U, work, lwork, B, X, recip_pivot_growth, rcond,                                       \
+         &mem_usage, stats, info);                                                              \
+    return mem_usage.for_lu; /* bytes used by the factor storage */                             \
+  }
+
+DECL_GSISX(s,float,float)
+DECL_GSISX(c,float,std::complex<float>)
+DECL_GSISX(d,double,double)
+DECL_GSISX(z,double,std::complex<double>)
+
+#endif
+
+template<typename MatrixType>
+struct SluMatrixMapHelper;
+
+/** \internal
+  *
+  * A wrapper class for SuperLU matrices. It supports only compressed sparse matrices
+  * and dense matrices. Supernodal and other fancy format are not supported by this wrapper.
+  *
+  * This wrapper class mainly aims to avoids the need of dynamic allocation of the storage structure.
+  */
+struct SluMatrix : SuperMatrix
+{
+  SluMatrix()
+  {
+    Store = &storage;
+  }
+
+  SluMatrix(const SluMatrix& other)
+    : SuperMatrix(other)
+  {
+    Store = &storage;
+    storage = other.storage;
+  }
+
+  SluMatrix& operator=(const SluMatrix& other)
+  {
+    SuperMatrix::operator=(static_cast<const SuperMatrix&>(other));
+    Store = &storage;
+    storage = other.storage;
+    return *this;
+  }
+
+  struct
+  {
+    union {int nnz;int lda;};
+    void *values;
+    int *innerInd;
+    int *outerInd;
+  } storage;
+
+  void setStorageType(Stype_t t)
+  {
+    Stype = t;
+    if (t==SLU_NC || t==SLU_NR || t==SLU_DN)
+      Store = &storage;
+    else
+    {
+      eigen_assert(false && "storage type not supported");
+      Store = 0;
+    }
+  }
+
+  template<typename Scalar>
+  void setScalarType()
+  {
+    if (internal::is_same<Scalar,float>::value)
+      Dtype = SLU_S;
+    else if (internal::is_same<Scalar,double>::value)
+      Dtype = SLU_D;
+    else if (internal::is_same<Scalar,std::complex<float> >::value)
+      Dtype = SLU_C;
+    else if (internal::is_same<Scalar,std::complex<double> >::value)
+      Dtype = SLU_Z;
+    else
+    {
+      eigen_assert(false && "Scalar type not supported by SuperLU");
+    }
+  }
+
+  template<typename MatrixType>
+  static SluMatrix Map(MatrixBase<MatrixType>& _mat)
+  {
+    MatrixType& mat(_mat.derived());
+    eigen_assert( ((MatrixType::Flags&RowMajorBit)!=RowMajorBit) && "row-major dense matrices are not supported by SuperLU");
+    SluMatrix res;
+    res.setStorageType(SLU_DN);
+    res.setScalarType<typename MatrixType::Scalar>();
+    res.Mtype     = SLU_GE;
+
+    res.nrow      = internal::convert_index<int>(mat.rows());
+    res.ncol      = internal::convert_index<int>(mat.cols());
+
+    res.storage.lda       = internal::convert_index<int>(MatrixType::IsVectorAtCompileTime ? mat.size() : mat.outerStride());
+    res.storage.values    = (void*)(mat.data());
+    return res;
+  }
+
+  template<typename MatrixType>
+  static SluMatrix Map(SparseMatrixBase<MatrixType>& a_mat)
+  {
+    MatrixType &mat(a_mat.derived());
+    SluMatrix res;
+    if ((MatrixType::Flags&RowMajorBit)==RowMajorBit)
+    {
+      res.setStorageType(SLU_NR);
+      res.nrow      = internal::convert_index<int>(mat.cols());
+      res.ncol      = internal::convert_index<int>(mat.rows());
+    }
+    else
+    {
+      res.setStorageType(SLU_NC);
+      res.nrow      = internal::convert_index<int>(mat.rows());
+      res.ncol      = internal::convert_index<int>(mat.cols());
+    }
+
+    res.Mtype       = SLU_GE;
+
+    res.storage.nnz       = internal::convert_index<int>(mat.nonZeros());
+    res.storage.values    = mat.valuePtr();
+    res.storage.innerInd  = mat.innerIndexPtr();
+    res.storage.outerInd  = mat.outerIndexPtr();
+
+    res.setScalarType<typename MatrixType::Scalar>();
+
+    // FIXME the following is not very accurate
+    if (MatrixType::Flags & Upper)
+      res.Mtype = SLU_TRU;
+    if (MatrixType::Flags & Lower)
+      res.Mtype = SLU_TRL;
+
+    eigen_assert(((MatrixType::Flags & SelfAdjoint)==0) && "SelfAdjoint matrix shape not supported by SuperLU");
+
+    return res;
+  }
+};
+
+template<typename Scalar, int Rows, int Cols, int Options, int MRows, int MCols>
+struct SluMatrixMapHelper<Matrix<Scalar,Rows,Cols,Options,MRows,MCols> >
+{
+  typedef Matrix<Scalar,Rows,Cols,Options,MRows,MCols> MatrixType;
+  static void run(MatrixType& mat, SluMatrix& res)
+  {
+    eigen_assert( ((Options&RowMajor)!=RowMajor) && "row-major dense matrices is not supported by SuperLU");
+    res.setStorageType(SLU_DN);
+    res.setScalarType<Scalar>();
+    res.Mtype     = SLU_GE;
+
+    res.nrow      = mat.rows();
+    res.ncol      = mat.cols();
+
+    res.storage.lda       = mat.outerStride();
+    res.storage.values    = mat.data();
+  }
+};
+
+template<typename Derived>
+struct SluMatrixMapHelper<SparseMatrixBase<Derived> >
+{
+  typedef Derived MatrixType;
+  static void run(MatrixType& mat, SluMatrix& res)
+  {
+    if ((MatrixType::Flags&RowMajorBit)==RowMajorBit)
+    {
+      res.setStorageType(SLU_NR);
+      res.nrow      = mat.cols();
+      res.ncol      = mat.rows();
+    }
+    else
+    {
+      res.setStorageType(SLU_NC);
+      res.nrow      = mat.rows();
+      res.ncol      = mat.cols();
+    }
+
+    res.Mtype       = SLU_GE;
+
+    res.storage.nnz       = mat.nonZeros();
+    res.storage.values    = mat.valuePtr();
+    res.storage.innerInd  = mat.innerIndexPtr();
+    res.storage.outerInd  = mat.outerIndexPtr();
+
+    res.setScalarType<typename MatrixType::Scalar>();
+
+    // FIXME the following is not very accurate
+    if (MatrixType::Flags & Upper)
+      res.Mtype = SLU_TRU;
+    if (MatrixType::Flags & Lower)
+      res.Mtype = SLU_TRL;
+
+    eigen_assert(((MatrixType::Flags & SelfAdjoint)==0) && "SelfAdjoint matrix shape not supported by SuperLU");
+  }
+};
+
+namespace internal {
+
+template<typename MatrixType>
+SluMatrix asSluMatrix(MatrixType& mat)
+{
+  return SluMatrix::Map(mat);
+}
+
+/** View a Super LU matrix as an Eigen expression */
+template<typename Scalar, int Flags, typename Index>
+MappedSparseMatrix<Scalar,Flags,Index> map_superlu(SluMatrix& sluMat)
+{
+  eigen_assert((Flags&RowMajor)==RowMajor && sluMat.Stype == SLU_NR
+         || (Flags&ColMajor)==ColMajor && sluMat.Stype == SLU_NC);
+
+  Index outerSize = (Flags&RowMajor)==RowMajor ? sluMat.ncol : sluMat.nrow;
+
+  return MappedSparseMatrix<Scalar,Flags,Index>(
+    sluMat.nrow, sluMat.ncol, sluMat.storage.outerInd[outerSize],
+    sluMat.storage.outerInd, sluMat.storage.innerInd, reinterpret_cast<Scalar*>(sluMat.storage.values) );
+}
+
+} // end namespace internal
+
+/** \ingroup SuperLUSupport_Module
+  * \class SuperLUBase
+  * \brief The base class for the direct and incomplete LU factorization of SuperLU
+  */
+template<typename _MatrixType, typename Derived>
+class SuperLUBase : public SparseSolverBase<Derived>
+{
+  protected:
+    typedef SparseSolverBase<Derived> Base;
+    using Base::derived;
+    using Base::m_isInitialized;
+  public:
+    typedef _MatrixType MatrixType;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef Matrix<Scalar,Dynamic,1> Vector;
+    typedef Matrix<int, 1, MatrixType::ColsAtCompileTime> IntRowVectorType;
+    typedef Matrix<int, MatrixType::RowsAtCompileTime, 1> IntColVectorType;    
+    typedef Map<PermutationMatrix<Dynamic,Dynamic,int> > PermutationMap;
+    typedef SparseMatrix<Scalar> LUMatrixType;
+    enum {
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+
+  public:
+
+    SuperLUBase() {}
+
+    ~SuperLUBase()
+    {
+      clearFactors();
+    }
+    
+    inline Index rows() const { return m_matrix.rows(); }
+    inline Index cols() const { return m_matrix.cols(); }
+    
+    /** \returns a reference to the Super LU option object to configure the  Super LU algorithms. */
+    inline superlu_options_t& options() { return m_sluOptions; }
+    
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was succesful,
+      *          \c NumericalIssue if the matrix.appears to be negative.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_info;
+    }
+
+    /** Computes the sparse Cholesky decomposition of \a matrix */
+    void compute(const MatrixType& matrix)
+    {
+      derived().analyzePattern(matrix);
+      derived().factorize(matrix);
+    }
+
+    /** Performs a symbolic decomposition on the sparcity of \a matrix.
+      *
+      * This function is particularly useful when solving for several problems having the same structure.
+      * 
+      * \sa factorize()
+      */
+    void analyzePattern(const MatrixType& /*matrix*/)
+    {
+      m_isInitialized = true;
+      m_info = Success;
+      m_analysisIsOk = true;
+      m_factorizationIsOk = false;
+    }
+    
+    template<typename Stream>
+    void dumpMemory(Stream& /*s*/)
+    {}
+    
+  protected:
+    
+    void initFactorization(const MatrixType& a)
+    {
+      set_default_options(&this->m_sluOptions);
+      
+      const Index size = a.rows();
+      m_matrix = a;
+
+      m_sluA = internal::asSluMatrix(m_matrix);
+      clearFactors();
+
+      m_p.resize(size);
+      m_q.resize(size);
+      m_sluRscale.resize(size);
+      m_sluCscale.resize(size);
+      m_sluEtree.resize(size);
+
+      // set empty B and X
+      m_sluB.setStorageType(SLU_DN);
+      m_sluB.setScalarType<Scalar>();
+      m_sluB.Mtype          = SLU_GE;
+      m_sluB.storage.values = 0;
+      m_sluB.nrow           = 0;
+      m_sluB.ncol           = 0;
+      m_sluB.storage.lda    = internal::convert_index<int>(size);
+      m_sluX                = m_sluB;
+      
+      m_extractedDataAreDirty = true;
+    }
+    
+    void init()
+    {
+      m_info = InvalidInput;
+      m_isInitialized = false;
+      m_sluL.Store = 0;
+      m_sluU.Store = 0;
+    }
+    
+    void extractData() const;
+
+    void clearFactors()
+    {
+      if(m_sluL.Store)
+        Destroy_SuperNode_Matrix(&m_sluL);
+      if(m_sluU.Store)
+        Destroy_CompCol_Matrix(&m_sluU);
+
+      m_sluL.Store = 0;
+      m_sluU.Store = 0;
+
+      memset(&m_sluL,0,sizeof m_sluL);
+      memset(&m_sluU,0,sizeof m_sluU);
+    }
+
+    // cached data to reduce reallocation, etc.
+    mutable LUMatrixType m_l;
+    mutable LUMatrixType m_u;
+    mutable IntColVectorType m_p;
+    mutable IntRowVectorType m_q;
+
+    mutable LUMatrixType m_matrix;  // copy of the factorized matrix
+    mutable SluMatrix m_sluA;
+    mutable SuperMatrix m_sluL, m_sluU;
+    mutable SluMatrix m_sluB, m_sluX;
+    mutable SuperLUStat_t m_sluStat;
+    mutable superlu_options_t m_sluOptions;
+    mutable std::vector<int> m_sluEtree;
+    mutable Matrix<RealScalar,Dynamic,1> m_sluRscale, m_sluCscale;
+    mutable Matrix<RealScalar,Dynamic,1> m_sluFerr, m_sluBerr;
+    mutable char m_sluEqued;
+
+    mutable ComputationInfo m_info;
+    int m_factorizationIsOk;
+    int m_analysisIsOk;
+    mutable bool m_extractedDataAreDirty;
+    
+  private:
+    SuperLUBase(SuperLUBase& ) { }
+};
+
+
+/** \ingroup SuperLUSupport_Module
+  * \class SuperLU
+  * \brief A sparse direct LU factorization and solver based on the SuperLU library
+  *
+  * This class allows to solve for A.X = B sparse linear problems via a direct LU factorization
+  * using the SuperLU library. The sparse matrix A must be squared and invertible. The vectors or matrices
+  * X and B can be either dense or sparse.
+  *
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  *
+  * \warning This class is only for the 4.x versions of SuperLU. The 3.x and 5.x versions are not supported.
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa \ref TutorialSparseSolverConcept, class SparseLU
+  */
+template<typename _MatrixType>
+class SuperLU : public SuperLUBase<_MatrixType,SuperLU<_MatrixType> >
+{
+  public:
+    typedef SuperLUBase<_MatrixType,SuperLU> Base;
+    typedef _MatrixType MatrixType;
+    typedef typename Base::Scalar Scalar;
+    typedef typename Base::RealScalar RealScalar;
+    typedef typename Base::StorageIndex StorageIndex;
+    typedef typename Base::IntRowVectorType IntRowVectorType;
+    typedef typename Base::IntColVectorType IntColVectorType;   
+    typedef typename Base::PermutationMap PermutationMap;
+    typedef typename Base::LUMatrixType LUMatrixType;
+    typedef TriangularView<LUMatrixType, Lower|UnitDiag>  LMatrixType;
+    typedef TriangularView<LUMatrixType,  Upper>          UMatrixType;
+
+  public:
+    using Base::_solve_impl;
+
+    SuperLU() : Base() { init(); }
+
+    explicit SuperLU(const MatrixType& matrix) : Base()
+    {
+      init();
+      Base::compute(matrix);
+    }
+
+    ~SuperLU()
+    {
+    }
+    
+    /** Performs a symbolic decomposition on the sparcity of \a matrix.
+      *
+      * This function is particularly useful when solving for several problems having the same structure.
+      * 
+      * \sa factorize()
+      */
+    void analyzePattern(const MatrixType& matrix)
+    {
+      m_info = InvalidInput;
+      m_isInitialized = false;
+      Base::analyzePattern(matrix);
+    }
+    
+    /** Performs a numeric decomposition of \a matrix
+      *
+      * The given matrix must has the same sparcity than the matrix on which the symbolic decomposition has been performed.
+      *
+      * \sa analyzePattern()
+      */
+    void factorize(const MatrixType& matrix);
+    
+    /** \internal */
+    template<typename Rhs,typename Dest>
+    void _solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &dest) const;
+    
+    inline const LMatrixType& matrixL() const
+    {
+      if (m_extractedDataAreDirty) this->extractData();
+      return m_l;
+    }
+
+    inline const UMatrixType& matrixU() const
+    {
+      if (m_extractedDataAreDirty) this->extractData();
+      return m_u;
+    }
+
+    inline const IntColVectorType& permutationP() const
+    {
+      if (m_extractedDataAreDirty) this->extractData();
+      return m_p;
+    }
+
+    inline const IntRowVectorType& permutationQ() const
+    {
+      if (m_extractedDataAreDirty) this->extractData();
+      return m_q;
+    }
+    
+    Scalar determinant() const;
+    
+  protected:
+    
+    using Base::m_matrix;
+    using Base::m_sluOptions;
+    using Base::m_sluA;
+    using Base::m_sluB;
+    using Base::m_sluX;
+    using Base::m_p;
+    using Base::m_q;
+    using Base::m_sluEtree;
+    using Base::m_sluEqued;
+    using Base::m_sluRscale;
+    using Base::m_sluCscale;
+    using Base::m_sluL;
+    using Base::m_sluU;
+    using Base::m_sluStat;
+    using Base::m_sluFerr;
+    using Base::m_sluBerr;
+    using Base::m_l;
+    using Base::m_u;
+    
+    using Base::m_analysisIsOk;
+    using Base::m_factorizationIsOk;
+    using Base::m_extractedDataAreDirty;
+    using Base::m_isInitialized;
+    using Base::m_info;
+    
+    void init()
+    {
+      Base::init();
+      
+      set_default_options(&this->m_sluOptions);
+      m_sluOptions.PrintStat        = NO;
+      m_sluOptions.ConditionNumber  = NO;
+      m_sluOptions.Trans            = NOTRANS;
+      m_sluOptions.ColPerm          = COLAMD;
+    }
+    
+    
+  private:
+    SuperLU(SuperLU& ) { }
+};
+
+template<typename MatrixType>
+void SuperLU<MatrixType>::factorize(const MatrixType& a)
+{
+  eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
+  if(!m_analysisIsOk)
+  {
+    m_info = InvalidInput;
+    return;
+  }
+  
+  this->initFactorization(a);
+  
+  m_sluOptions.ColPerm = COLAMD;
+  int info = 0;
+  RealScalar recip_pivot_growth, rcond;
+  RealScalar ferr, berr;
+
+  StatInit(&m_sluStat);
+  SuperLU_gssvx(&m_sluOptions, &m_sluA, m_q.data(), m_p.data(), &m_sluEtree[0],
+                &m_sluEqued, &m_sluRscale[0], &m_sluCscale[0],
+                &m_sluL, &m_sluU,
+                NULL, 0,
+                &m_sluB, &m_sluX,
+                &recip_pivot_growth, &rcond,
+                &ferr, &berr,
+                &m_sluStat, &info, Scalar());
+  StatFree(&m_sluStat);
+
+  m_extractedDataAreDirty = true;
+
+  // FIXME how to better check for errors ???
+  m_info = info == 0 ? Success : NumericalIssue;
+  m_factorizationIsOk = true;
+}
+
+template<typename MatrixType>
+template<typename Rhs,typename Dest>
+void SuperLU<MatrixType>::_solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest>& x) const
+{
+  eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or analyzePattern()/factorize()");
+
+  const Index size = m_matrix.rows();
+  const Index rhsCols = b.cols();
+  eigen_assert(size==b.rows());
+
+  m_sluOptions.Trans = NOTRANS;
+  m_sluOptions.Fact = FACTORED;
+  m_sluOptions.IterRefine = NOREFINE;
+  
+
+  m_sluFerr.resize(rhsCols);
+  m_sluBerr.resize(rhsCols);
+  
+  Ref<const Matrix<typename Rhs::Scalar,Dynamic,Dynamic,ColMajor> > b_ref(b);
+  Ref<const Matrix<typename Dest::Scalar,Dynamic,Dynamic,ColMajor> > x_ref(x);
+  
+  m_sluB = SluMatrix::Map(b_ref.const_cast_derived());
+  m_sluX = SluMatrix::Map(x_ref.const_cast_derived());
+  
+  typename Rhs::PlainObject b_cpy;
+  if(m_sluEqued!='N')
+  {
+    b_cpy = b;
+    m_sluB = SluMatrix::Map(b_cpy.const_cast_derived());  
+  }
+
+  StatInit(&m_sluStat);
+  int info = 0;
+  RealScalar recip_pivot_growth, rcond;
+  SuperLU_gssvx(&m_sluOptions, &m_sluA,
+                m_q.data(), m_p.data(),
+                &m_sluEtree[0], &m_sluEqued,
+                &m_sluRscale[0], &m_sluCscale[0],
+                &m_sluL, &m_sluU,
+                NULL, 0,
+                &m_sluB, &m_sluX,
+                &recip_pivot_growth, &rcond,
+                &m_sluFerr[0], &m_sluBerr[0],
+                &m_sluStat, &info, Scalar());
+  StatFree(&m_sluStat);
+  
+  if(x.derived().data() != x_ref.data())
+    x = x_ref;
+  
+  m_info = info==0 ? Success : NumericalIssue;
+}
+
+// the code of this extractData() function has been adapted from the SuperLU's Matlab support code,
+//
+//  Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+//
+//  THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+//  EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+//
+template<typename MatrixType, typename Derived>
+void SuperLUBase<MatrixType,Derived>::extractData() const
+{
+  eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for extracting factors, you must first call either compute() or analyzePattern()/factorize()");
+  if (m_extractedDataAreDirty)
+  {
+    int         upper;
+    int         fsupc, istart, nsupr;
+    int         lastl = 0, lastu = 0;
+    SCformat    *Lstore = static_cast<SCformat*>(m_sluL.Store);
+    NCformat    *Ustore = static_cast<NCformat*>(m_sluU.Store);
+    Scalar      *SNptr;
+
+    const Index size = m_matrix.rows();
+    m_l.resize(size,size);
+    m_l.resizeNonZeros(Lstore->nnz);
+    m_u.resize(size,size);
+    m_u.resizeNonZeros(Ustore->nnz);
+
+    int* Lcol = m_l.outerIndexPtr();
+    int* Lrow = m_l.innerIndexPtr();
+    Scalar* Lval = m_l.valuePtr();
+
+    int* Ucol = m_u.outerIndexPtr();
+    int* Urow = m_u.innerIndexPtr();
+    Scalar* Uval = m_u.valuePtr();
+
+    Ucol[0] = 0;
+    Ucol[0] = 0;
+
+    /* for each supernode */
+    for (int k = 0; k <= Lstore->nsuper; ++k)
+    {
+      fsupc   = L_FST_SUPC(k);
+      istart  = L_SUB_START(fsupc);
+      nsupr   = L_SUB_START(fsupc+1) - istart;
+      upper   = 1;
+
+      /* for each column in the supernode */
+      for (int j = fsupc; j < L_FST_SUPC(k+1); ++j)
+      {
+        SNptr = &((Scalar*)Lstore->nzval)[L_NZ_START(j)];
+
+        /* Extract U */
+        for (int i = U_NZ_START(j); i < U_NZ_START(j+1); ++i)
+        {
+          Uval[lastu] = ((Scalar*)Ustore->nzval)[i];
+          /* Matlab doesn't like explicit zero. */
+          if (Uval[lastu] != 0.0)
+            Urow[lastu++] = U_SUB(i);
+        }
+        for (int i = 0; i < upper; ++i)
+        {
+          /* upper triangle in the supernode */
+          Uval[lastu] = SNptr[i];
+          /* Matlab doesn't like explicit zero. */
+          if (Uval[lastu] != 0.0)
+            Urow[lastu++] = L_SUB(istart+i);
+        }
+        Ucol[j+1] = lastu;
+
+        /* Extract L */
+        Lval[lastl] = 1.0; /* unit diagonal */
+        Lrow[lastl++] = L_SUB(istart + upper - 1);
+        for (int i = upper; i < nsupr; ++i)
+        {
+          Lval[lastl] = SNptr[i];
+          /* Matlab doesn't like explicit zero. */
+          if (Lval[lastl] != 0.0)
+            Lrow[lastl++] = L_SUB(istart+i);
+        }
+        Lcol[j+1] = lastl;
+
+        ++upper;
+      } /* for j ... */
+
+    } /* for k ... */
+
+    // squeeze the matrices :
+    m_l.resizeNonZeros(lastl);
+    m_u.resizeNonZeros(lastu);
+
+    m_extractedDataAreDirty = false;
+  }
+}
+
+template<typename MatrixType>
+typename SuperLU<MatrixType>::Scalar SuperLU<MatrixType>::determinant() const
+{
+  eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for computing the determinant, you must first call either compute() or analyzePattern()/factorize()");
+  
+  if (m_extractedDataAreDirty)
+    this->extractData();
+
+  Scalar det = Scalar(1);
+  for (int j=0; j<m_u.cols(); ++j)
+  {
+    if (m_u.outerIndexPtr()[j+1]-m_u.outerIndexPtr()[j] > 0)
+    {
+      int lastId = m_u.outerIndexPtr()[j+1]-1;
+      eigen_assert(m_u.innerIndexPtr()[lastId]<=j);
+      if (m_u.innerIndexPtr()[lastId]==j)
+        det *= m_u.valuePtr()[lastId];
+    }
+  }
+  if(PermutationMap(m_p.data(),m_p.size()).determinant()*PermutationMap(m_q.data(),m_q.size()).determinant()<0)
+    det = -det;
+  if(m_sluEqued!='N')
+    return det/m_sluRscale.prod()/m_sluCscale.prod();
+  else
+    return det;
+}
+
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+#define EIGEN_SUPERLU_HAS_ILU
+#endif
+
+#ifdef EIGEN_SUPERLU_HAS_ILU
+
+/** \ingroup SuperLUSupport_Module
+  * \class SuperILU
+  * \brief A sparse direct \b incomplete LU factorization and solver based on the SuperLU library
+  *
+  * This class allows to solve for an approximate solution of A.X = B sparse linear problems via an incomplete LU factorization
+  * using the SuperLU library. This class is aimed to be used as a preconditioner of the iterative linear solvers.
+  *
+  * \warning This class is only for the 4.x versions of SuperLU. The 3.x and 5.x versions are not supported.
+  *
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa \ref TutorialSparseSolverConcept, class IncompleteLUT, class ConjugateGradient, class BiCGSTAB
+  */
+
+template<typename _MatrixType>
+class SuperILU : public SuperLUBase<_MatrixType,SuperILU<_MatrixType> >
+{
+  public:
+    typedef SuperLUBase<_MatrixType,SuperILU> Base;
+    typedef _MatrixType MatrixType;
+    typedef typename Base::Scalar Scalar;
+    typedef typename Base::RealScalar RealScalar;
+
+  public:
+    using Base::_solve_impl;
+
+    SuperILU() : Base() { init(); }
+
+    SuperILU(const MatrixType& matrix) : Base()
+    {
+      init();
+      Base::compute(matrix);
+    }
+
+    ~SuperILU()
+    {
+    }
+    
+    /** Performs a symbolic decomposition on the sparcity of \a matrix.
+      *
+      * This function is particularly useful when solving for several problems having the same structure.
+      * 
+      * \sa factorize()
+      */
+    void analyzePattern(const MatrixType& matrix)
+    {
+      Base::analyzePattern(matrix);
+    }
+    
+    /** Performs a numeric decomposition of \a matrix
+      *
+      * The given matrix must has the same sparcity than the matrix on which the symbolic decomposition has been performed.
+      *
+      * \sa analyzePattern()
+      */
+    void factorize(const MatrixType& matrix);
+    
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** \internal */
+    template<typename Rhs,typename Dest>
+    void _solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &dest) const;
+    #endif // EIGEN_PARSED_BY_DOXYGEN
+    
+  protected:
+    
+    using Base::m_matrix;
+    using Base::m_sluOptions;
+    using Base::m_sluA;
+    using Base::m_sluB;
+    using Base::m_sluX;
+    using Base::m_p;
+    using Base::m_q;
+    using Base::m_sluEtree;
+    using Base::m_sluEqued;
+    using Base::m_sluRscale;
+    using Base::m_sluCscale;
+    using Base::m_sluL;
+    using Base::m_sluU;
+    using Base::m_sluStat;
+    using Base::m_sluFerr;
+    using Base::m_sluBerr;
+    using Base::m_l;
+    using Base::m_u;
+    
+    using Base::m_analysisIsOk;
+    using Base::m_factorizationIsOk;
+    using Base::m_extractedDataAreDirty;
+    using Base::m_isInitialized;
+    using Base::m_info;
+
+    void init()
+    {
+      Base::init();
+      
+      ilu_set_default_options(&m_sluOptions);
+      m_sluOptions.PrintStat        = NO;
+      m_sluOptions.ConditionNumber  = NO;
+      m_sluOptions.Trans            = NOTRANS;
+      m_sluOptions.ColPerm          = MMD_AT_PLUS_A;
+      
+      // no attempt to preserve column sum
+      m_sluOptions.ILU_MILU = SILU;
+      // only basic ILU(k) support -- no direct control over memory consumption
+      // better to use ILU_DropRule = DROP_BASIC | DROP_AREA
+      // and set ILU_FillFactor to max memory growth
+      m_sluOptions.ILU_DropRule = DROP_BASIC;
+      m_sluOptions.ILU_DropTol = NumTraits<Scalar>::dummy_precision()*10;
+    }
+    
+  private:
+    SuperILU(SuperILU& ) { }
+};
+
+template<typename MatrixType>
+void SuperILU<MatrixType>::factorize(const MatrixType& a)
+{
+  eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
+  if(!m_analysisIsOk)
+  {
+    m_info = InvalidInput;
+    return;
+  }
+  
+  this->initFactorization(a);
+
+  int info = 0;
+  RealScalar recip_pivot_growth, rcond;
+
+  StatInit(&m_sluStat);
+  SuperLU_gsisx(&m_sluOptions, &m_sluA, m_q.data(), m_p.data(), &m_sluEtree[0],
+                &m_sluEqued, &m_sluRscale[0], &m_sluCscale[0],
+                &m_sluL, &m_sluU,
+                NULL, 0,
+                &m_sluB, &m_sluX,
+                &recip_pivot_growth, &rcond,
+                &m_sluStat, &info, Scalar());
+  StatFree(&m_sluStat);
+
+  // FIXME how to better check for errors ???
+  m_info = info == 0 ? Success : NumericalIssue;
+  m_factorizationIsOk = true;
+}
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename MatrixType>
+template<typename Rhs,typename Dest>
+void SuperILU<MatrixType>::_solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest>& x) const
+{
+  eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or analyzePattern()/factorize()");
+
+  const int size = m_matrix.rows();
+  const int rhsCols = b.cols();
+  eigen_assert(size==b.rows());
+
+  m_sluOptions.Trans = NOTRANS;
+  m_sluOptions.Fact = FACTORED;
+  m_sluOptions.IterRefine = NOREFINE;
+
+  m_sluFerr.resize(rhsCols);
+  m_sluBerr.resize(rhsCols);
+  
+  Ref<const Matrix<typename Rhs::Scalar,Dynamic,Dynamic,ColMajor> > b_ref(b);
+  Ref<const Matrix<typename Dest::Scalar,Dynamic,Dynamic,ColMajor> > x_ref(x);
+  
+  m_sluB = SluMatrix::Map(b_ref.const_cast_derived());
+  m_sluX = SluMatrix::Map(x_ref.const_cast_derived());
+
+  typename Rhs::PlainObject b_cpy;
+  if(m_sluEqued!='N')
+  {
+    b_cpy = b;
+    m_sluB = SluMatrix::Map(b_cpy.const_cast_derived());  
+  }
+  
+  int info = 0;
+  RealScalar recip_pivot_growth, rcond;
+
+  StatInit(&m_sluStat);
+  SuperLU_gsisx(&m_sluOptions, &m_sluA,
+                m_q.data(), m_p.data(),
+                &m_sluEtree[0], &m_sluEqued,
+                &m_sluRscale[0], &m_sluCscale[0],
+                &m_sluL, &m_sluU,
+                NULL, 0,
+                &m_sluB, &m_sluX,
+                &recip_pivot_growth, &rcond,
+                &m_sluStat, &info, Scalar());
+  StatFree(&m_sluStat);
+  
+  if(x.derived().data() != x_ref.data())
+    x = x_ref;
+
+  m_info = info==0 ? Success : NumericalIssue;
+}
+#endif
+
+#endif
+
+} // end namespace Eigen
+
+#endif // EIGEN_SUPERLUSUPPORT_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/UmfPackSupport/UmfPackSupport.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/UmfPackSupport/UmfPackSupport.h
new file mode 100644
index 00000000..9568cc1d
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/UmfPackSupport/UmfPackSupport.h
@@ -0,0 +1,506 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2011 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_UMFPACKSUPPORT_H
+#define EIGEN_UMFPACKSUPPORT_H
+
+namespace Eigen {
+
+/* TODO extract L, extract U, compute det, etc... */
+
+// generic double/complex<double> wrapper functions:
+
+
+inline void umfpack_defaults(double control[UMFPACK_CONTROL], double)
+{ umfpack_di_defaults(control); }
+
+inline void umfpack_defaults(double control[UMFPACK_CONTROL], std::complex<double>)
+{ umfpack_zi_defaults(control); }
+
+inline void umfpack_report_info(double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], double)
+{ umfpack_di_report_info(control, info);}
+
+inline void umfpack_report_info(double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], std::complex<double>)
+{ umfpack_zi_report_info(control, info);}
+
+inline void umfpack_report_status(double control[UMFPACK_CONTROL], int status, double)
+{ umfpack_di_report_status(control, status);}
+
+inline void umfpack_report_status(double control[UMFPACK_CONTROL], int status, std::complex<double>)
+{ umfpack_zi_report_status(control, status);}
+
+inline void umfpack_report_control(double control[UMFPACK_CONTROL], double)
+{ umfpack_di_report_control(control);}
+
+inline void umfpack_report_control(double control[UMFPACK_CONTROL], std::complex<double>)
+{ umfpack_zi_report_control(control);}
+
+inline void umfpack_free_numeric(void **Numeric, double)
+{ umfpack_di_free_numeric(Numeric); *Numeric = 0; }
+
+inline void umfpack_free_numeric(void **Numeric, std::complex<double>)
+{ umfpack_zi_free_numeric(Numeric); *Numeric = 0; }
+
+inline void umfpack_free_symbolic(void **Symbolic, double)
+{ umfpack_di_free_symbolic(Symbolic); *Symbolic = 0; }
+
+inline void umfpack_free_symbolic(void **Symbolic, std::complex<double>)
+{ umfpack_zi_free_symbolic(Symbolic); *Symbolic = 0; }
+
+inline int umfpack_symbolic(int n_row,int n_col,
+                            const int Ap[], const int Ai[], const double Ax[], void **Symbolic,
+                            const double Control [UMFPACK_CONTROL], double Info [UMFPACK_INFO])
+{
+  return umfpack_di_symbolic(n_row,n_col,Ap,Ai,Ax,Symbolic,Control,Info);
+}
+
+inline int umfpack_symbolic(int n_row,int n_col,
+                            const int Ap[], const int Ai[], const std::complex<double> Ax[], void **Symbolic,
+                            const double Control [UMFPACK_CONTROL], double Info [UMFPACK_INFO])
+{
+  return umfpack_zi_symbolic(n_row,n_col,Ap,Ai,&numext::real_ref(Ax[0]),0,Symbolic,Control,Info);
+}
+
+inline int umfpack_numeric( const int Ap[], const int Ai[], const double Ax[],
+                            void *Symbolic, void **Numeric,
+                            const double Control[UMFPACK_CONTROL],double Info [UMFPACK_INFO])
+{
+  return umfpack_di_numeric(Ap,Ai,Ax,Symbolic,Numeric,Control,Info);
+}
+
+inline int umfpack_numeric( const int Ap[], const int Ai[], const std::complex<double> Ax[],
+                            void *Symbolic, void **Numeric,
+                            const double Control[UMFPACK_CONTROL],double Info [UMFPACK_INFO])
+{
+  return umfpack_zi_numeric(Ap,Ai,&numext::real_ref(Ax[0]),0,Symbolic,Numeric,Control,Info);
+}
+
+inline int umfpack_solve( int sys, const int Ap[], const int Ai[], const double Ax[],
+                          double X[], const double B[], void *Numeric,
+                          const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
+{
+  return umfpack_di_solve(sys,Ap,Ai,Ax,X,B,Numeric,Control,Info);
+}
+
+inline int umfpack_solve( int sys, const int Ap[], const int Ai[], const std::complex<double> Ax[],
+                          std::complex<double> X[], const std::complex<double> B[], void *Numeric,
+                          const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
+{
+  return umfpack_zi_solve(sys,Ap,Ai,&numext::real_ref(Ax[0]),0,&numext::real_ref(X[0]),0,&numext::real_ref(B[0]),0,Numeric,Control,Info);
+}
+
+inline int umfpack_get_lunz(int *lnz, int *unz, int *n_row, int *n_col, int *nz_udiag, void *Numeric, double)
+{
+  return umfpack_di_get_lunz(lnz,unz,n_row,n_col,nz_udiag,Numeric);
+}
+
+inline int umfpack_get_lunz(int *lnz, int *unz, int *n_row, int *n_col, int *nz_udiag, void *Numeric, std::complex<double>)
+{
+  return umfpack_zi_get_lunz(lnz,unz,n_row,n_col,nz_udiag,Numeric);
+}
+
+inline int umfpack_get_numeric(int Lp[], int Lj[], double Lx[], int Up[], int Ui[], double Ux[],
+                               int P[], int Q[], double Dx[], int *do_recip, double Rs[], void *Numeric)
+{
+  return umfpack_di_get_numeric(Lp,Lj,Lx,Up,Ui,Ux,P,Q,Dx,do_recip,Rs,Numeric);
+}
+
+inline int umfpack_get_numeric(int Lp[], int Lj[], std::complex<double> Lx[], int Up[], int Ui[], std::complex<double> Ux[],
+                               int P[], int Q[], std::complex<double> Dx[], int *do_recip, double Rs[], void *Numeric)
+{
+  double& lx0_real = numext::real_ref(Lx[0]);
+  double& ux0_real = numext::real_ref(Ux[0]);
+  double& dx0_real = numext::real_ref(Dx[0]);
+  return umfpack_zi_get_numeric(Lp,Lj,Lx?&lx0_real:0,0,Up,Ui,Ux?&ux0_real:0,0,P,Q,
+                                Dx?&dx0_real:0,0,do_recip,Rs,Numeric);
+}
+
+inline int umfpack_get_determinant(double *Mx, double *Ex, void *NumericHandle, double User_Info [UMFPACK_INFO])
+{
+  return umfpack_di_get_determinant(Mx,Ex,NumericHandle,User_Info);
+}
+
+inline int umfpack_get_determinant(std::complex<double> *Mx, double *Ex, void *NumericHandle, double User_Info [UMFPACK_INFO])
+{
+  double& mx_real = numext::real_ref(*Mx);
+  return umfpack_zi_get_determinant(&mx_real,0,Ex,NumericHandle,User_Info);
+}
+
+
+/** \ingroup UmfPackSupport_Module
+  * \brief A sparse LU factorization and solver based on UmfPack
+  *
+  * This class allows to solve for A.X = B sparse linear problems via a LU factorization
+  * using the UmfPack library. The sparse matrix A must be squared and full rank.
+  * The vectors or matrices X and B can be either dense or sparse.
+  *
+  * \warning The input matrix A should be in a \b compressed and \b column-major form.
+  * Otherwise an expensive copy will be made. You can call the inexpensive makeCompressed() to get a compressed matrix.
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa \ref TutorialSparseSolverConcept, class SparseLU
+  */
+template<typename _MatrixType>
+class UmfPackLU : public SparseSolverBase<UmfPackLU<_MatrixType> >
+{
+  protected:
+    typedef SparseSolverBase<UmfPackLU<_MatrixType> > Base;
+    using Base::m_isInitialized;
+  public:
+    using Base::_solve_impl;
+    typedef _MatrixType MatrixType;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef Matrix<Scalar,Dynamic,1> Vector;
+    typedef Matrix<int, 1, MatrixType::ColsAtCompileTime> IntRowVectorType;
+    typedef Matrix<int, MatrixType::RowsAtCompileTime, 1> IntColVectorType;
+    typedef SparseMatrix<Scalar> LUMatrixType;
+    typedef SparseMatrix<Scalar,ColMajor,int> UmfpackMatrixType;
+    typedef Ref<const UmfpackMatrixType, StandardCompressedFormat> UmfpackMatrixRef;
+    enum {
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+
+  public:
+
+    typedef Array<double, UMFPACK_CONTROL, 1> UmfpackControl;
+    typedef Array<double, UMFPACK_INFO, 1> UmfpackInfo;
+
+    UmfPackLU()
+      : m_dummy(0,0), mp_matrix(m_dummy)
+    {
+      init();
+    }
+
+    template<typename InputMatrixType>
+    explicit UmfPackLU(const InputMatrixType& matrix)
+      : mp_matrix(matrix)
+    {
+      init();
+      compute(matrix);
+    }
+
+    ~UmfPackLU()
+    {
+      if(m_symbolic) umfpack_free_symbolic(&m_symbolic,Scalar());
+      if(m_numeric)  umfpack_free_numeric(&m_numeric,Scalar());
+    }
+
+    inline Index rows() const { return mp_matrix.rows(); }
+    inline Index cols() const { return mp_matrix.cols(); }
+
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was succesful,
+      *          \c NumericalIssue if the matrix.appears to be negative.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_info;
+    }
+
+    inline const LUMatrixType& matrixL() const
+    {
+      if (m_extractedDataAreDirty) extractData();
+      return m_l;
+    }
+
+    inline const LUMatrixType& matrixU() const
+    {
+      if (m_extractedDataAreDirty) extractData();
+      return m_u;
+    }
+
+    inline const IntColVectorType& permutationP() const
+    {
+      if (m_extractedDataAreDirty) extractData();
+      return m_p;
+    }
+
+    inline const IntRowVectorType& permutationQ() const
+    {
+      if (m_extractedDataAreDirty) extractData();
+      return m_q;
+    }
+
+    /** Computes the sparse Cholesky decomposition of \a matrix
+     *  Note that the matrix should be column-major, and in compressed format for best performance.
+     *  \sa SparseMatrix::makeCompressed().
+     */
+    template<typename InputMatrixType>
+    void compute(const InputMatrixType& matrix)
+    {
+      if(m_symbolic) umfpack_free_symbolic(&m_symbolic,Scalar());
+      if(m_numeric)  umfpack_free_numeric(&m_numeric,Scalar());
+      grab(matrix.derived());
+      analyzePattern_impl();
+      factorize_impl();
+    }
+
+    /** Performs a symbolic decomposition on the sparcity of \a matrix.
+      *
+      * This function is particularly useful when solving for several problems having the same structure.
+      *
+      * \sa factorize(), compute()
+      */
+    template<typename InputMatrixType>
+    void analyzePattern(const InputMatrixType& matrix)
+    {
+      if(m_symbolic) umfpack_free_symbolic(&m_symbolic,Scalar());
+      if(m_numeric)  umfpack_free_numeric(&m_numeric,Scalar());
+
+      grab(matrix.derived());
+
+      analyzePattern_impl();
+    }
+
+    /** Provides the return status code returned by UmfPack during the numeric
+      * factorization.
+      *
+      * \sa factorize(), compute()
+      */
+    inline int umfpackFactorizeReturncode() const
+    {
+      eigen_assert(m_numeric && "UmfPackLU: you must first call factorize()");
+      return m_fact_errorCode;
+    }
+
+    /** Provides access to the control settings array used by UmfPack.
+      *
+      * If this array contains NaN's, the default values are used.
+      *
+      * See UMFPACK documentation for details.
+      */
+    inline const UmfpackControl& umfpackControl() const
+    {
+      return m_control;
+    }
+
+    /** Provides access to the control settings array used by UmfPack.
+      *
+      * If this array contains NaN's, the default values are used.
+      *
+      * See UMFPACK documentation for details.
+      */
+    inline UmfpackControl& umfpackControl()
+    {
+      return m_control;
+    }
+
+    /** Performs a numeric decomposition of \a matrix
+      *
+      * The given matrix must has the same sparcity than the matrix on which the pattern anylysis has been performed.
+      *
+      * \sa analyzePattern(), compute()
+      */
+    template<typename InputMatrixType>
+    void factorize(const InputMatrixType& matrix)
+    {
+      eigen_assert(m_analysisIsOk && "UmfPackLU: you must first call analyzePattern()");
+      if(m_numeric)
+        umfpack_free_numeric(&m_numeric,Scalar());
+
+      grab(matrix.derived());
+
+      factorize_impl();
+    }
+
+    /** Prints the current UmfPack control settings.
+      *
+      * \sa umfpackControl()
+      */
+    void printUmfpackControl()
+    {
+      umfpack_report_control(m_control.data(), Scalar());
+    }
+
+    /** Prints statistics collected by UmfPack.
+      *
+      * \sa analyzePattern(), compute()
+      */
+    void printUmfpackInfo()
+    {
+      eigen_assert(m_analysisIsOk && "UmfPackLU: you must first call analyzePattern()");
+      umfpack_report_info(m_control.data(), m_umfpackInfo.data(), Scalar());
+    }
+
+    /** Prints the status of the previous factorization operation performed by UmfPack (symbolic or numerical factorization).
+      *
+      * \sa analyzePattern(), compute()
+      */
+    void printUmfpackStatus() {
+      eigen_assert(m_analysisIsOk && "UmfPackLU: you must first call analyzePattern()");
+      umfpack_report_status(m_control.data(), m_fact_errorCode, Scalar());
+    }
+
+    /** \internal */
+    template<typename BDerived,typename XDerived>
+    bool _solve_impl(const MatrixBase<BDerived> &b, MatrixBase<XDerived> &x) const;
+
+    Scalar determinant() const;
+
+    void extractData() const;
+
+  protected:
+
+    void init()
+    {
+      m_info                  = InvalidInput;
+      m_isInitialized         = false;
+      m_numeric               = 0;
+      m_symbolic              = 0;
+      m_extractedDataAreDirty = true;
+
+      umfpack_defaults(m_control.data(), Scalar());
+    }
+
+    void analyzePattern_impl()
+    {
+      m_fact_errorCode = umfpack_symbolic(internal::convert_index<int>(mp_matrix.rows()),
+                                          internal::convert_index<int>(mp_matrix.cols()),
+                                          mp_matrix.outerIndexPtr(), mp_matrix.innerIndexPtr(), mp_matrix.valuePtr(),
+                                          &m_symbolic, m_control.data(), m_umfpackInfo.data());
+
+      m_isInitialized = true;
+      m_info = m_fact_errorCode ? InvalidInput : Success;
+      m_analysisIsOk = true;
+      m_factorizationIsOk = false;
+      m_extractedDataAreDirty = true;
+    }
+
+    void factorize_impl()
+    {
+
+      m_fact_errorCode = umfpack_numeric(mp_matrix.outerIndexPtr(), mp_matrix.innerIndexPtr(), mp_matrix.valuePtr(),
+                                         m_symbolic, &m_numeric, m_control.data(), m_umfpackInfo.data());
+
+      m_info = m_fact_errorCode == UMFPACK_OK ? Success : NumericalIssue;
+      m_factorizationIsOk = true;
+      m_extractedDataAreDirty = true;
+    }
+
+    template<typename MatrixDerived>
+    void grab(const EigenBase<MatrixDerived> &A)
+    {
+      mp_matrix.~UmfpackMatrixRef();
+      ::new (&mp_matrix) UmfpackMatrixRef(A.derived());
+    }
+
+    void grab(const UmfpackMatrixRef &A)
+    {
+      if(&(A.derived()) != &mp_matrix)
+      {
+        mp_matrix.~UmfpackMatrixRef();
+        ::new (&mp_matrix) UmfpackMatrixRef(A);
+      }
+    }
+
+    // cached data to reduce reallocation, etc.
+    mutable LUMatrixType m_l;
+    int m_fact_errorCode;
+    UmfpackControl m_control;
+    mutable UmfpackInfo m_umfpackInfo;
+
+    mutable LUMatrixType m_u;
+    mutable IntColVectorType m_p;
+    mutable IntRowVectorType m_q;
+
+    UmfpackMatrixType m_dummy;
+    UmfpackMatrixRef mp_matrix;
+
+    void* m_numeric;
+    void* m_symbolic;
+
+    mutable ComputationInfo m_info;
+    int m_factorizationIsOk;
+    int m_analysisIsOk;
+    mutable bool m_extractedDataAreDirty;
+
+  private:
+    UmfPackLU(const UmfPackLU& ) { }
+};
+
+
+template<typename MatrixType>
+void UmfPackLU<MatrixType>::extractData() const
+{
+  if (m_extractedDataAreDirty)
+  {
+    // get size of the data
+    int lnz, unz, rows, cols, nz_udiag;
+    umfpack_get_lunz(&lnz, &unz, &rows, &cols, &nz_udiag, m_numeric, Scalar());
+
+    // allocate data
+    m_l.resize(rows,(std::min)(rows,cols));
+    m_l.resizeNonZeros(lnz);
+
+    m_u.resize((std::min)(rows,cols),cols);
+    m_u.resizeNonZeros(unz);
+
+    m_p.resize(rows);
+    m_q.resize(cols);
+
+    // extract
+    umfpack_get_numeric(m_l.outerIndexPtr(), m_l.innerIndexPtr(), m_l.valuePtr(),
+                        m_u.outerIndexPtr(), m_u.innerIndexPtr(), m_u.valuePtr(),
+                        m_p.data(), m_q.data(), 0, 0, 0, m_numeric);
+
+    m_extractedDataAreDirty = false;
+  }
+}
+
+template<typename MatrixType>
+typename UmfPackLU<MatrixType>::Scalar UmfPackLU<MatrixType>::determinant() const
+{
+  Scalar det;
+  umfpack_get_determinant(&det, 0, m_numeric, 0);
+  return det;
+}
+
+template<typename MatrixType>
+template<typename BDerived,typename XDerived>
+bool UmfPackLU<MatrixType>::_solve_impl(const MatrixBase<BDerived> &b, MatrixBase<XDerived> &x) const
+{
+  Index rhsCols = b.cols();
+  eigen_assert((BDerived::Flags&RowMajorBit)==0 && "UmfPackLU backend does not support non col-major rhs yet");
+  eigen_assert((XDerived::Flags&RowMajorBit)==0 && "UmfPackLU backend does not support non col-major result yet");
+  eigen_assert(b.derived().data() != x.derived().data() && " Umfpack does not support inplace solve");
+
+  int errorCode;
+  Scalar* x_ptr = 0;
+  Matrix<Scalar,Dynamic,1> x_tmp;
+  if(x.innerStride()!=1)
+  {
+    x_tmp.resize(x.rows());
+    x_ptr = x_tmp.data();
+  }
+  for (int j=0; j<rhsCols; ++j)
+  {
+    if(x.innerStride()==1)
+      x_ptr = &x.col(j).coeffRef(0);
+    errorCode = umfpack_solve(UMFPACK_A,
+        mp_matrix.outerIndexPtr(), mp_matrix.innerIndexPtr(), mp_matrix.valuePtr(),
+        x_ptr, &b.const_cast_derived().col(j).coeffRef(0), m_numeric, m_control.data(), m_umfpackInfo.data());
+    if(x.innerStride()!=1)
+      x.col(j) = x_tmp;
+    if (errorCode!=0)
+      return false;
+  }
+
+  return true;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_UMFPACKSUPPORT_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/misc/Image.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/misc/Image.h
new file mode 100644
index 00000000..b8b8a045
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/misc/Image.h
@@ -0,0 +1,82 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MISC_IMAGE_H
+#define EIGEN_MISC_IMAGE_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/** \class image_retval_base
+  *
+  */
+template<typename DecompositionType>
+struct traits<image_retval_base<DecompositionType> >
+{
+  typedef typename DecompositionType::MatrixType MatrixType;
+  typedef Matrix<
+    typename MatrixType::Scalar,
+    MatrixType::RowsAtCompileTime, // the image is a subspace of the destination space, whose
+                                   // dimension is the number of rows of the original matrix
+    Dynamic,                       // we don't know at compile time the dimension of the image (the rank)
+    MatrixType::Options,
+    MatrixType::MaxRowsAtCompileTime, // the image matrix will consist of columns from the original matrix,
+    MatrixType::MaxColsAtCompileTime  // so it has the same number of rows and at most as many columns.
+  > ReturnType;
+};
+
+template<typename _DecompositionType> struct image_retval_base
+ : public ReturnByValue<image_retval_base<_DecompositionType> >
+{
+  typedef _DecompositionType DecompositionType;
+  typedef typename DecompositionType::MatrixType MatrixType;
+  typedef ReturnByValue<image_retval_base> Base;
+
+  image_retval_base(const DecompositionType& dec, const MatrixType& originalMatrix)
+    : m_dec(dec), m_rank(dec.rank()),
+      m_cols(m_rank == 0 ? 1 : m_rank),
+      m_originalMatrix(originalMatrix)
+  {}
+
+  inline Index rows() const { return m_dec.rows(); }
+  inline Index cols() const { return m_cols; }
+  inline Index rank() const { return m_rank; }
+  inline const DecompositionType& dec() const { return m_dec; }
+  inline const MatrixType& originalMatrix() const { return m_originalMatrix; }
+
+  template<typename Dest> inline void evalTo(Dest& dst) const
+  {
+    static_cast<const image_retval<DecompositionType>*>(this)->evalTo(dst);
+  }
+
+  protected:
+    const DecompositionType& m_dec;
+    Index m_rank, m_cols;
+    const MatrixType& m_originalMatrix;
+};
+
+} // end namespace internal
+
+#define EIGEN_MAKE_IMAGE_HELPERS(DecompositionType) \
+  typedef typename DecompositionType::MatrixType MatrixType; \
+  typedef typename MatrixType::Scalar Scalar; \
+  typedef typename MatrixType::RealScalar RealScalar; \
+  typedef Eigen::internal::image_retval_base<DecompositionType> Base; \
+  using Base::dec; \
+  using Base::originalMatrix; \
+  using Base::rank; \
+  using Base::rows; \
+  using Base::cols; \
+  image_retval(const DecompositionType& dec, const MatrixType& originalMatrix) \
+    : Base(dec, originalMatrix) {}
+
+} // end namespace Eigen
+
+#endif // EIGEN_MISC_IMAGE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/misc/Kernel.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/misc/Kernel.h
new file mode 100644
index 00000000..bef5d6ff
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/misc/Kernel.h
@@ -0,0 +1,79 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MISC_KERNEL_H
+#define EIGEN_MISC_KERNEL_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/** \class kernel_retval_base
+  *
+  */
+template<typename DecompositionType>
+struct traits<kernel_retval_base<DecompositionType> >
+{
+  typedef typename DecompositionType::MatrixType MatrixType;
+  typedef Matrix<
+    typename MatrixType::Scalar,
+    MatrixType::ColsAtCompileTime, // the number of rows in the "kernel matrix"
+                                   // is the number of cols of the original matrix
+                                   // so that the product "matrix * kernel = zero" makes sense
+    Dynamic,                       // we don't know at compile-time the dimension of the kernel
+    MatrixType::Options,
+    MatrixType::MaxColsAtCompileTime, // see explanation for 2nd template parameter
+    MatrixType::MaxColsAtCompileTime // the kernel is a subspace of the domain space,
+                                     // whose dimension is the number of columns of the original matrix
+  > ReturnType;
+};
+
+template<typename _DecompositionType> struct kernel_retval_base
+ : public ReturnByValue<kernel_retval_base<_DecompositionType> >
+{
+  typedef _DecompositionType DecompositionType;
+  typedef ReturnByValue<kernel_retval_base> Base;
+
+  explicit kernel_retval_base(const DecompositionType& dec)
+    : m_dec(dec),
+      m_rank(dec.rank()),
+      m_cols(m_rank==dec.cols() ? 1 : dec.cols() - m_rank)
+  {}
+
+  inline Index rows() const { return m_dec.cols(); }
+  inline Index cols() const { return m_cols; }
+  inline Index rank() const { return m_rank; }
+  inline const DecompositionType& dec() const { return m_dec; }
+
+  template<typename Dest> inline void evalTo(Dest& dst) const
+  {
+    static_cast<const kernel_retval<DecompositionType>*>(this)->evalTo(dst);
+  }
+
+  protected:
+    const DecompositionType& m_dec;
+    Index m_rank, m_cols;
+};
+
+} // end namespace internal
+
+#define EIGEN_MAKE_KERNEL_HELPERS(DecompositionType) \
+  typedef typename DecompositionType::MatrixType MatrixType; \
+  typedef typename MatrixType::Scalar Scalar; \
+  typedef typename MatrixType::RealScalar RealScalar; \
+  typedef Eigen::internal::kernel_retval_base<DecompositionType> Base; \
+  using Base::dec; \
+  using Base::rank; \
+  using Base::rows; \
+  using Base::cols; \
+  kernel_retval(const DecompositionType& dec) : Base(dec) {}
+
+} // end namespace Eigen
+
+#endif // EIGEN_MISC_KERNEL_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/misc/RealSvd2x2.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/misc/RealSvd2x2.h
new file mode 100644
index 00000000..abb4d3c2
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/misc/RealSvd2x2.h
@@ -0,0 +1,55 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2013-2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_REALSVD2X2_H
+#define EIGEN_REALSVD2X2_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename MatrixType, typename RealScalar, typename Index>
+void real_2x2_jacobi_svd(const MatrixType& matrix, Index p, Index q,
+                         JacobiRotation<RealScalar> *j_left,
+                         JacobiRotation<RealScalar> *j_right)
+{
+  using std::sqrt;
+  using std::abs;
+  Matrix<RealScalar,2,2> m;
+  m << numext::real(matrix.coeff(p,p)), numext::real(matrix.coeff(p,q)),
+       numext::real(matrix.coeff(q,p)), numext::real(matrix.coeff(q,q));
+  JacobiRotation<RealScalar> rot1;
+  RealScalar t = m.coeff(0,0) + m.coeff(1,1);
+  RealScalar d = m.coeff(1,0) - m.coeff(0,1);
+
+  if(abs(d) < (std::numeric_limits<RealScalar>::min)())
+  {
+    rot1.s() = RealScalar(0);
+    rot1.c() = RealScalar(1);
+  }
+  else
+  {
+    // If d!=0, then t/d cannot overflow because the magnitude of the
+    // entries forming d are not too small compared to the ones forming t.
+    RealScalar u = t / d;
+    RealScalar tmp = sqrt(RealScalar(1) + numext::abs2(u));
+    rot1.s() = RealScalar(1) / tmp;
+    rot1.c() = u / tmp;
+  }
+  m.applyOnTheLeft(0,1,rot1);
+  j_right->makeJacobi(m,0,1);
+  *j_left = rot1 * j_right->transpose();
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_REALSVD2X2_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/misc/blas.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/misc/blas.h
new file mode 100644
index 00000000..25215b15
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/misc/blas.h
@@ -0,0 +1,440 @@
+#ifndef BLAS_H
+#define BLAS_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#define BLASFUNC(FUNC) FUNC##_
+
+#ifdef __WIN64__
+typedef long long BLASLONG;
+typedef unsigned long long BLASULONG;
+#else
+typedef long BLASLONG;
+typedef unsigned long BLASULONG;
+#endif
+
+int    BLASFUNC(xerbla)(const char *, int *info, int);
+
+float  BLASFUNC(sdot)  (int *, float  *, int *, float  *, int *);
+float  BLASFUNC(sdsdot)(int *, float  *,        float  *, int *, float  *, int *);
+
+double BLASFUNC(dsdot) (int *, float  *, int *, float  *, int *);
+double BLASFUNC(ddot)  (int *, double *, int *, double *, int *);
+double BLASFUNC(qdot)  (int *, double *, int *, double *, int *);
+
+int  BLASFUNC(cdotuw)  (int *, float  *, int *, float  *, int *, float*);
+int  BLASFUNC(cdotcw)  (int *, float  *, int *, float  *, int *, float*);
+int  BLASFUNC(zdotuw)  (int *, double  *, int *, double  *, int *, double*);
+int  BLASFUNC(zdotcw)  (int *, double  *, int *, double  *, int *, double*);
+
+int    BLASFUNC(saxpy) (const int *, const float  *, const float  *, const int *, float  *, const int *);
+int    BLASFUNC(daxpy) (const int *, const double *, const double *, const int *, double *, const int *);
+int    BLASFUNC(qaxpy) (const int *, const double *, const double *, const int *, double *, const int *);
+int    BLASFUNC(caxpy) (const int *, const float  *, const float  *, const int *, float  *, const int *);
+int    BLASFUNC(zaxpy) (const int *, const double *, const double *, const int *, double *, const int *);
+int    BLASFUNC(xaxpy) (const int *, const double *, const double *, const int *, double *, const int *);
+int    BLASFUNC(caxpyc)(const int *, const float  *, const float  *, const int *, float  *, const int *);
+int    BLASFUNC(zaxpyc)(const int *, const double *, const double *, const int *, double *, const int *);
+int    BLASFUNC(xaxpyc)(const int *, const double *, const double *, const int *, double *, const int *);
+
+int    BLASFUNC(scopy) (int *, float  *, int *, float  *, int *);
+int    BLASFUNC(dcopy) (int *, double *, int *, double *, int *);
+int    BLASFUNC(qcopy) (int *, double *, int *, double *, int *);
+int    BLASFUNC(ccopy) (int *, float  *, int *, float  *, int *);
+int    BLASFUNC(zcopy) (int *, double *, int *, double *, int *);
+int    BLASFUNC(xcopy) (int *, double *, int *, double *, int *);
+
+int    BLASFUNC(sswap) (int *, float  *, int *, float  *, int *);
+int    BLASFUNC(dswap) (int *, double *, int *, double *, int *);
+int    BLASFUNC(qswap) (int *, double *, int *, double *, int *);
+int    BLASFUNC(cswap) (int *, float  *, int *, float  *, int *);
+int    BLASFUNC(zswap) (int *, double *, int *, double *, int *);
+int    BLASFUNC(xswap) (int *, double *, int *, double *, int *);
+
+float  BLASFUNC(sasum) (int *, float  *, int *);
+float  BLASFUNC(scasum)(int *, float  *, int *);
+double BLASFUNC(dasum) (int *, double *, int *);
+double BLASFUNC(qasum) (int *, double *, int *);
+double BLASFUNC(dzasum)(int *, double *, int *);
+double BLASFUNC(qxasum)(int *, double *, int *);
+
+int    BLASFUNC(isamax)(int *, float  *, int *);
+int    BLASFUNC(idamax)(int *, double *, int *);
+int    BLASFUNC(iqamax)(int *, double *, int *);
+int    BLASFUNC(icamax)(int *, float  *, int *);
+int    BLASFUNC(izamax)(int *, double *, int *);
+int    BLASFUNC(ixamax)(int *, double *, int *);
+
+int    BLASFUNC(ismax) (int *, float  *, int *);
+int    BLASFUNC(idmax) (int *, double *, int *);
+int    BLASFUNC(iqmax) (int *, double *, int *);
+int    BLASFUNC(icmax) (int *, float  *, int *);
+int    BLASFUNC(izmax) (int *, double *, int *);
+int    BLASFUNC(ixmax) (int *, double *, int *);
+
+int    BLASFUNC(isamin)(int *, float  *, int *);
+int    BLASFUNC(idamin)(int *, double *, int *);
+int    BLASFUNC(iqamin)(int *, double *, int *);
+int    BLASFUNC(icamin)(int *, float  *, int *);
+int    BLASFUNC(izamin)(int *, double *, int *);
+int    BLASFUNC(ixamin)(int *, double *, int *);
+
+int    BLASFUNC(ismin)(int *, float  *, int *);
+int    BLASFUNC(idmin)(int *, double *, int *);
+int    BLASFUNC(iqmin)(int *, double *, int *);
+int    BLASFUNC(icmin)(int *, float  *, int *);
+int    BLASFUNC(izmin)(int *, double *, int *);
+int    BLASFUNC(ixmin)(int *, double *, int *);
+
+float  BLASFUNC(samax) (int *, float  *, int *);
+double BLASFUNC(damax) (int *, double *, int *);
+double BLASFUNC(qamax) (int *, double *, int *);
+float  BLASFUNC(scamax)(int *, float  *, int *);
+double BLASFUNC(dzamax)(int *, double *, int *);
+double BLASFUNC(qxamax)(int *, double *, int *);
+
+float  BLASFUNC(samin) (int *, float  *, int *);
+double BLASFUNC(damin) (int *, double *, int *);
+double BLASFUNC(qamin) (int *, double *, int *);
+float  BLASFUNC(scamin)(int *, float  *, int *);
+double BLASFUNC(dzamin)(int *, double *, int *);
+double BLASFUNC(qxamin)(int *, double *, int *);
+
+float  BLASFUNC(smax)  (int *, float  *, int *);
+double BLASFUNC(dmax)  (int *, double *, int *);
+double BLASFUNC(qmax)  (int *, double *, int *);
+float  BLASFUNC(scmax) (int *, float  *, int *);
+double BLASFUNC(dzmax) (int *, double *, int *);
+double BLASFUNC(qxmax) (int *, double *, int *);
+
+float  BLASFUNC(smin)  (int *, float  *, int *);
+double BLASFUNC(dmin)  (int *, double *, int *);
+double BLASFUNC(qmin)  (int *, double *, int *);
+float  BLASFUNC(scmin) (int *, float  *, int *);
+double BLASFUNC(dzmin) (int *, double *, int *);
+double BLASFUNC(qxmin) (int *, double *, int *);
+
+int    BLASFUNC(sscal) (int *,  float  *, float  *, int *);
+int    BLASFUNC(dscal) (int *,  double *, double *, int *);
+int    BLASFUNC(qscal) (int *,  double *, double *, int *);
+int    BLASFUNC(cscal) (int *,  float  *, float  *, int *);
+int    BLASFUNC(zscal) (int *,  double *, double *, int *);
+int    BLASFUNC(xscal) (int *,  double *, double *, int *);
+int    BLASFUNC(csscal)(int *,  float  *, float  *, int *);
+int    BLASFUNC(zdscal)(int *,  double *, double *, int *);
+int    BLASFUNC(xqscal)(int *,  double *, double *, int *);
+
+float  BLASFUNC(snrm2) (int *, float  *, int *);
+float  BLASFUNC(scnrm2)(int *, float  *, int *);
+
+double BLASFUNC(dnrm2) (int *, double *, int *);
+double BLASFUNC(qnrm2) (int *, double *, int *);
+double BLASFUNC(dznrm2)(int *, double *, int *);
+double BLASFUNC(qxnrm2)(int *, double *, int *);
+
+int    BLASFUNC(srot)  (int *, float  *, int *, float  *, int *, float  *, float  *);
+int    BLASFUNC(drot)  (int *, double *, int *, double *, int *, double *, double *);
+int    BLASFUNC(qrot)  (int *, double *, int *, double *, int *, double *, double *);
+int    BLASFUNC(csrot) (int *, float  *, int *, float  *, int *, float  *, float  *);
+int    BLASFUNC(zdrot) (int *, double *, int *, double *, int *, double *, double *);
+int    BLASFUNC(xqrot) (int *, double *, int *, double *, int *, double *, double *);
+
+int    BLASFUNC(srotg) (float  *, float  *, float  *, float  *);
+int    BLASFUNC(drotg) (double *, double *, double *, double *);
+int    BLASFUNC(qrotg) (double *, double *, double *, double *);
+int    BLASFUNC(crotg) (float  *, float  *, float  *, float  *);
+int    BLASFUNC(zrotg) (double *, double *, double *, double *);
+int    BLASFUNC(xrotg) (double *, double *, double *, double *);
+
+int    BLASFUNC(srotmg)(float  *, float  *, float  *, float  *, float  *);
+int    BLASFUNC(drotmg)(double *, double *, double *, double *, double *);
+
+int    BLASFUNC(srotm) (int *, float  *, int *, float  *, int *, float  *);
+int    BLASFUNC(drotm) (int *, double *, int *, double *, int *, double *);
+int    BLASFUNC(qrotm) (int *, double *, int *, double *, int *, double *);
+
+/* Level 2 routines */
+
+int BLASFUNC(sger)(int *,    int *, float *,  float *, int *,
+		   float *,  int *, float *,  int *);
+int BLASFUNC(dger)(int *,    int *, double *, double *, int *,
+		   double *, int *, double *, int *);
+int BLASFUNC(qger)(int *,    int *, double *, double *, int *,
+		   double *, int *, double *, int *);
+int BLASFUNC(cgeru)(int *,    int *, float *,  float *, int *,
+		    float *,  int *, float *,  int *);
+int BLASFUNC(cgerc)(int *,    int *, float *,  float *, int *,
+		    float *,  int *, float *,  int *);
+int BLASFUNC(zgeru)(int *,    int *, double *, double *, int *,
+		    double *, int *, double *, int *);
+int BLASFUNC(zgerc)(int *,    int *, double *, double *, int *,
+		    double *, int *, double *, int *);
+int BLASFUNC(xgeru)(int *,    int *, double *, double *, int *,
+		    double *, int *, double *, int *);
+int BLASFUNC(xgerc)(int *,    int *, double *, double *, int *,
+		    double *, int *, double *, int *);
+
+int BLASFUNC(sgemv)(const char *, const int *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(dgemv)(const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(qgemv)(const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(cgemv)(const char *, const int *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zgemv)(const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(xgemv)(const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+
+int BLASFUNC(strsv) (const char *, const char *, const char *, const int *, const float  *, const int *, float  *, const int *);
+int BLASFUNC(dtrsv) (const char *, const char *, const char *, const int *, const double *, const int *, double *, const int *);
+int BLASFUNC(qtrsv) (const char *, const char *, const char *, const int *, const double *, const int *, double *, const int *);
+int BLASFUNC(ctrsv) (const char *, const char *, const char *, const int *, const float  *, const int *, float  *, const int *);
+int BLASFUNC(ztrsv) (const char *, const char *, const char *, const int *, const double *, const int *, double *, const int *);
+int BLASFUNC(xtrsv) (const char *, const char *, const char *, const int *, const double *, const int *, double *, const int *);
+
+int BLASFUNC(stpsv) (char *, char *, char *, int *, float  *, float  *, int *);
+int BLASFUNC(dtpsv) (char *, char *, char *, int *, double *, double *, int *);
+int BLASFUNC(qtpsv) (char *, char *, char *, int *, double *, double *, int *);
+int BLASFUNC(ctpsv) (char *, char *, char *, int *, float  *, float  *, int *);
+int BLASFUNC(ztpsv) (char *, char *, char *, int *, double *, double *, int *);
+int BLASFUNC(xtpsv) (char *, char *, char *, int *, double *, double *, int *);
+
+int BLASFUNC(strmv) (const char *, const char *, const char *, const int *, const float  *, const int *, float  *, const int *);
+int BLASFUNC(dtrmv) (const char *, const char *, const char *, const int *, const double *, const int *, double *, const int *);
+int BLASFUNC(qtrmv) (const char *, const char *, const char *, const int *, const double *, const int *, double *, const int *);
+int BLASFUNC(ctrmv) (const char *, const char *, const char *, const int *, const float  *, const int *, float  *, const int *);
+int BLASFUNC(ztrmv) (const char *, const char *, const char *, const int *, const double *, const int *, double *, const int *);
+int BLASFUNC(xtrmv) (const char *, const char *, const char *, const int *, const double *, const int *, double *, const int *);
+
+int BLASFUNC(stpmv) (char *, char *, char *, int *, float  *, float  *, int *);
+int BLASFUNC(dtpmv) (char *, char *, char *, int *, double *, double *, int *);
+int BLASFUNC(qtpmv) (char *, char *, char *, int *, double *, double *, int *);
+int BLASFUNC(ctpmv) (char *, char *, char *, int *, float  *, float  *, int *);
+int BLASFUNC(ztpmv) (char *, char *, char *, int *, double *, double *, int *);
+int BLASFUNC(xtpmv) (char *, char *, char *, int *, double *, double *, int *);
+
+int BLASFUNC(stbmv) (char *, char *, char *, int *, int *, float  *, int *, float  *, int *);
+int BLASFUNC(dtbmv) (char *, char *, char *, int *, int *, double *, int *, double *, int *);
+int BLASFUNC(qtbmv) (char *, char *, char *, int *, int *, double *, int *, double *, int *);
+int BLASFUNC(ctbmv) (char *, char *, char *, int *, int *, float  *, int *, float  *, int *);
+int BLASFUNC(ztbmv) (char *, char *, char *, int *, int *, double *, int *, double *, int *);
+int BLASFUNC(xtbmv) (char *, char *, char *, int *, int *, double *, int *, double *, int *);
+
+int BLASFUNC(stbsv) (char *, char *, char *, int *, int *, float  *, int *, float  *, int *);
+int BLASFUNC(dtbsv) (char *, char *, char *, int *, int *, double *, int *, double *, int *);
+int BLASFUNC(qtbsv) (char *, char *, char *, int *, int *, double *, int *, double *, int *);
+int BLASFUNC(ctbsv) (char *, char *, char *, int *, int *, float  *, int *, float  *, int *);
+int BLASFUNC(ztbsv) (char *, char *, char *, int *, int *, double *, int *, double *, int *);
+int BLASFUNC(xtbsv) (char *, char *, char *, int *, int *, double *, int *, double *, int *);
+
+int BLASFUNC(ssymv) (const char *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(dsymv) (const char *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(qsymv) (const char *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+
+int BLASFUNC(sspmv) (char *, int *, float  *, float *,
+		     float  *, int *, float *, float *, int *);
+int BLASFUNC(dspmv) (char *, int *, double  *, double *,
+		     double  *, int *, double *, double *, int *);
+int BLASFUNC(qspmv) (char *, int *, double  *, double *,
+		     double  *, int *, double *, double *, int *);
+
+int BLASFUNC(ssyr) (const char *, const int *, const float   *, const float  *, const int *, float  *, const int *);
+int BLASFUNC(dsyr) (const char *, const int *, const double  *, const double *, const int *, double *, const int *);
+int BLASFUNC(qsyr) (const char *, const int *, const double  *, const double *, const int *, double *, const int *);
+
+int BLASFUNC(ssyr2) (const char *, const int *, const float   *, const float  *, const int *, const float  *, const int *, float  *, const int *);
+int BLASFUNC(dsyr2) (const char *, const int *, const double  *, const double *, const int *, const double *, const int *, double *, const int *);
+int BLASFUNC(qsyr2) (const char *, const int *, const double  *, const double *, const int *, const double *, const int *, double *, const int *);
+int BLASFUNC(csyr2) (const char *, const int *, const float   *, const float  *, const int *, const float  *, const int *, float  *, const int *);
+int BLASFUNC(zsyr2) (const char *, const int *, const double  *, const double *, const int *, const double *, const int *, double *, const int *);
+int BLASFUNC(xsyr2) (const char *, const int *, const double  *, const double *, const int *, const double *, const int *, double *, const int *);
+
+int BLASFUNC(sspr) (char *, int *, float   *, float  *, int *,
+		    float  *);
+int BLASFUNC(dspr) (char *, int *, double  *, double *, int *,
+		    double *);
+int BLASFUNC(qspr) (char *, int *, double  *, double *, int *,
+		    double *);
+
+int BLASFUNC(sspr2) (char *, int *, float   *,
+		     float  *, int *, float  *, int *, float  *);
+int BLASFUNC(dspr2) (char *, int *, double  *,
+		     double *, int *, double *, int *, double *);
+int BLASFUNC(qspr2) (char *, int *, double  *,
+		     double *, int *, double *, int *, double *);
+int BLASFUNC(cspr2) (char *, int *, float   *,
+		     float  *, int *, float  *, int *, float  *);
+int BLASFUNC(zspr2) (char *, int *, double  *,
+		     double *, int *, double *, int *, double *);
+int BLASFUNC(xspr2) (char *, int *, double  *,
+		     double *, int *, double *, int *, double *);
+
+int BLASFUNC(cher) (char *, int *, float   *, float  *, int *,
+		    float  *, int *);
+int BLASFUNC(zher) (char *, int *, double  *, double *, int *,
+		    double *, int *);
+int BLASFUNC(xher) (char *, int *, double  *, double *, int *,
+		    double *, int *);
+
+int BLASFUNC(chpr) (char *, int *, float   *, float  *, int *, float  *);
+int BLASFUNC(zhpr) (char *, int *, double  *, double *, int *, double *);
+int BLASFUNC(xhpr) (char *, int *, double  *, double *, int *, double *);
+
+int BLASFUNC(cher2) (char *, int *, float   *,
+		     float  *, int *, float  *, int *, float  *, int *);
+int BLASFUNC(zher2) (char *, int *, double  *,
+		     double *, int *, double *, int *, double *, int *);
+int BLASFUNC(xher2) (char *, int *, double  *,
+		     double *, int *, double *, int *, double *, int *);
+
+int BLASFUNC(chpr2) (char *, int *, float   *,
+		     float  *, int *, float  *, int *, float  *);
+int BLASFUNC(zhpr2) (char *, int *, double  *,
+		     double *, int *, double *, int *, double *);
+int BLASFUNC(xhpr2) (char *, int *, double  *,
+		     double *, int *, double *, int *, double *);
+
+int BLASFUNC(chemv) (const char *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zhemv) (const char *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(xhemv) (const char *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+
+int BLASFUNC(chpmv) (char *, int *, float  *, float *,
+		     float  *, int *, float *, float *, int *);
+int BLASFUNC(zhpmv) (char *, int *, double  *, double *,
+		     double  *, int *, double *, double *, int *);
+int BLASFUNC(xhpmv) (char *, int *, double  *, double *,
+		     double  *, int *, double *, double *, int *);
+
+int BLASFUNC(snorm)(char *, int *, int *, float  *, int *);
+int BLASFUNC(dnorm)(char *, int *, int *, double *, int *);
+int BLASFUNC(cnorm)(char *, int *, int *, float  *, int *);
+int BLASFUNC(znorm)(char *, int *, int *, double *, int *);
+
+int BLASFUNC(sgbmv)(char *, int *, int *, int *, int *, float  *, float  *, int *,
+		    float  *, int *, float  *, float  *, int *);
+int BLASFUNC(dgbmv)(char *, int *, int *, int *, int *, double *, double *, int *,
+		    double *, int *, double *, double *, int *);
+int BLASFUNC(qgbmv)(char *, int *, int *, int *, int *, double *, double *, int *,
+		    double *, int *, double *, double *, int *);
+int BLASFUNC(cgbmv)(char *, int *, int *, int *, int *, float  *, float  *, int *,
+		    float  *, int *, float  *, float  *, int *);
+int BLASFUNC(zgbmv)(char *, int *, int *, int *, int *, double *, double *, int *,
+		    double *, int *, double *, double *, int *);
+int BLASFUNC(xgbmv)(char *, int *, int *, int *, int *, double *, double *, int *,
+		    double *, int *, double *, double *, int *);
+
+int BLASFUNC(ssbmv)(char *, int *, int *, float  *, float  *, int *,
+		    float  *, int *, float  *, float  *, int *);
+int BLASFUNC(dsbmv)(char *, int *, int *, double *, double *, int *,
+		    double *, int *, double *, double *, int *);
+int BLASFUNC(qsbmv)(char *, int *, int *, double *, double *, int *,
+		    double *, int *, double *, double *, int *);
+int BLASFUNC(csbmv)(char *, int *, int *, float  *, float  *, int *,
+		    float  *, int *, float  *, float  *, int *);
+int BLASFUNC(zsbmv)(char *, int *, int *, double *, double *, int *,
+		    double *, int *, double *, double *, int *);
+int BLASFUNC(xsbmv)(char *, int *, int *, double *, double *, int *,
+		    double *, int *, double *, double *, int *);
+
+int BLASFUNC(chbmv)(char *, int *, int *, float  *, float  *, int *,
+		    float  *, int *, float  *, float  *, int *);
+int BLASFUNC(zhbmv)(char *, int *, int *, double *, double *, int *,
+		    double *, int *, double *, double *, int *);
+int BLASFUNC(xhbmv)(char *, int *, int *, double *, double *, int *,
+		    double *, int *, double *, double *, int *);
+
+/* Level 3 routines */
+
+int BLASFUNC(sgemm)(const char *, const char *, const int *, const int *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(dgemm)(const char *, const char *, const int *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(qgemm)(const char *, const char *, const int *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(cgemm)(const char *, const char *, const int *, const int *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zgemm)(const char *, const char *, const int *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(xgemm)(const char *, const char *, const int *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+
+int BLASFUNC(cgemm3m)(char *, char *, int *, int *, int *, float *,
+	   float  *, int *, float  *, int *, float  *, float  *, int *);
+int BLASFUNC(zgemm3m)(char *, char *, int *, int *, int *, double *,
+	   double *, int *, double *, int *, double *, double *, int *);
+int BLASFUNC(xgemm3m)(char *, char *, int *, int *, int *, double *,
+	   double *, int *, double *, int *, double *, double *, int *);
+
+int BLASFUNC(sge2mm)(char *, char *, char *, int *, int *,
+		     float *, float  *, int *, float  *, int *,
+		     float *, float  *, int *);
+int BLASFUNC(dge2mm)(char *, char *, char *, int *, int *,
+		     double *, double  *, int *, double  *, int *,
+		     double *, double  *, int *);
+int BLASFUNC(cge2mm)(char *, char *, char *, int *, int *,
+		     float *, float  *, int *, float  *, int *,
+		     float *, float  *, int *);
+int BLASFUNC(zge2mm)(char *, char *, char *, int *, int *,
+		     double *, double  *, int *, double  *, int *,
+		     double *, double  *, int *);
+
+int BLASFUNC(strsm)(const char *, const char *, const char *, const char *, const int *, const int *, const float *,  const float *,  const int *, float *,  const int *);
+int BLASFUNC(dtrsm)(const char *, const char *, const char *, const char *, const int *, const int *, const double *, const double *, const int *, double *, const int *);
+int BLASFUNC(qtrsm)(const char *, const char *, const char *, const char *, const int *, const int *, const double *, const double *, const int *, double *, const int *);
+int BLASFUNC(ctrsm)(const char *, const char *, const char *, const char *, const int *, const int *, const float *,  const float *,  const int *, float *,  const int *);
+int BLASFUNC(ztrsm)(const char *, const char *, const char *, const char *, const int *, const int *, const double *, const double *, const int *, double *, const int *);
+int BLASFUNC(xtrsm)(const char *, const char *, const char *, const char *, const int *, const int *, const double *, const double *, const int *, double *, const int *);
+
+int BLASFUNC(strmm)(const char *, const char *, const char *, const char *, const int *, const int *, const float *,  const float *,  const int *, float *,  const int *);
+int BLASFUNC(dtrmm)(const char *, const char *, const char *, const char *, const int *, const int *, const double *, const double *, const int *, double *, const int *);
+int BLASFUNC(qtrmm)(const char *, const char *, const char *, const char *, const int *, const int *, const double *, const double *, const int *, double *, const int *);
+int BLASFUNC(ctrmm)(const char *, const char *, const char *, const char *, const int *, const int *, const float *,  const float *,  const int *, float *,  const int *);
+int BLASFUNC(ztrmm)(const char *, const char *, const char *, const char *, const int *, const int *, const double *, const double *, const int *, double *, const int *);
+int BLASFUNC(xtrmm)(const char *, const char *, const char *, const char *, const int *, const int *, const double *, const double *, const int *, double *, const int *);
+
+int BLASFUNC(ssymm)(const char *, const char *, const int *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(dsymm)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(qsymm)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(csymm)(const char *, const char *, const int *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zsymm)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(xsymm)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+
+int BLASFUNC(csymm3m)(char *, char *, int *, int *, float  *, float  *, int *, float  *, int *, float  *, float  *, int *);
+int BLASFUNC(zsymm3m)(char *, char *, int *, int *, double *, double *, int *, double *, int *, double *, double *, int *);
+int BLASFUNC(xsymm3m)(char *, char *, int *, int *, double *, double *, int *, double *, int *, double *, double *, int *);
+
+int BLASFUNC(ssyrk)(const char *, const char *, const int *, const int *, const float  *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(dsyrk)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(qsyrk)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(csyrk)(const char *, const char *, const int *, const int *, const float  *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zsyrk)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(xsyrk)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, double *, const int *);
+
+int BLASFUNC(ssyr2k)(const char *, const char *, const int *, const int *, const float  *, const float  *, const int *, const float *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(dsyr2k)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double*, const int *, const double *, double *, const int *);
+int BLASFUNC(qsyr2k)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double*, const int *, const double *, double *, const int *);
+int BLASFUNC(csyr2k)(const char *, const char *, const int *, const int *, const float  *, const float  *, const int *, const float *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zsyr2k)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double*, const int *, const double *, double *, const int *);
+int BLASFUNC(xsyr2k)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double*, const int *, const double *, double *, const int *);
+
+int BLASFUNC(chemm)(const char *, const char *, const int *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zhemm)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(xhemm)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+
+int BLASFUNC(chemm3m)(char *, char *, int *, int *, float  *, float  *, int *,
+	   float  *, int *, float  *, float  *, int *);
+int BLASFUNC(zhemm3m)(char *, char *, int *, int *, double *, double *, int *,
+	   double *, int *, double *, double *, int *);
+int BLASFUNC(xhemm3m)(char *, char *, int *, int *, double *, double *, int *,
+	   double *, int *, double *, double *, int *);
+
+int BLASFUNC(cherk)(const char *, const char *, const int *, const int *, const float  *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zherk)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(xherk)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, double *, const int *);
+
+int BLASFUNC(cher2k)(const char *, const char *, const int *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zher2k)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(xher2k)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(cher2m)(const char *, const char *, const char *, const int *, const int *, const float  *, const float  *, const int *, const float *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zher2m)(const char *, const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double*, const int *, const double *, double *, const int *);
+int BLASFUNC(xher2m)(const char *, const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double*, const int *, const double *, double *, const int *);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/misc/lapack.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/misc/lapack.h
new file mode 100644
index 00000000..249f3575
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/misc/lapack.h
@@ -0,0 +1,152 @@
+#ifndef LAPACK_H
+#define LAPACK_H
+
+#include "blas.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+int BLASFUNC(csymv) (const char *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zsymv) (const char *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(xsymv) (const char *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+
+
+int BLASFUNC(cspmv) (char *, int *, float  *, float *,
+         float  *, int *, float *, float *, int *);
+int BLASFUNC(zspmv) (char *, int *, double  *, double *,
+         double  *, int *, double *, double *, int *);
+int BLASFUNC(xspmv) (char *, int *, double  *, double *,
+         double  *, int *, double *, double *, int *);
+
+int BLASFUNC(csyr) (char *, int *, float   *, float  *, int *,
+        float  *, int *);
+int BLASFUNC(zsyr) (char *, int *, double  *, double *, int *,
+        double *, int *);
+int BLASFUNC(xsyr) (char *, int *, double  *, double *, int *,
+        double *, int *);
+
+int BLASFUNC(cspr) (char *, int *, float   *, float  *, int *,
+        float  *);
+int BLASFUNC(zspr) (char *, int *, double  *, double *, int *,
+        double *);
+int BLASFUNC(xspr) (char *, int *, double  *, double *, int *,
+        double *);
+
+int BLASFUNC(sgemt)(char *, int *, int *, float  *, float  *, int *,
+        float  *, int *);
+int BLASFUNC(dgemt)(char *, int *, int *, double *, double *, int *,
+        double *, int *);
+int BLASFUNC(cgemt)(char *, int *, int *, float  *, float  *, int *,
+        float  *, int *);
+int BLASFUNC(zgemt)(char *, int *, int *, double *, double *, int *,
+        double *, int *);
+
+int BLASFUNC(sgema)(char *, char *, int *, int *, float  *,
+        float  *, int *, float *, float  *, int *, float *, int *);
+int BLASFUNC(dgema)(char *, char *, int *, int *, double *,
+        double *, int *, double*, double *, int *, double*, int *);
+int BLASFUNC(cgema)(char *, char *, int *, int *, float  *,
+        float  *, int *, float *, float  *, int *, float *, int *);
+int BLASFUNC(zgema)(char *, char *, int *, int *, double *,
+        double *, int *, double*, double *, int *, double*, int *);
+
+int BLASFUNC(sgems)(char *, char *, int *, int *, float  *,
+        float  *, int *, float *, float  *, int *, float *, int *);
+int BLASFUNC(dgems)(char *, char *, int *, int *, double *,
+        double *, int *, double*, double *, int *, double*, int *);
+int BLASFUNC(cgems)(char *, char *, int *, int *, float  *,
+        float  *, int *, float *, float  *, int *, float *, int *);
+int BLASFUNC(zgems)(char *, char *, int *, int *, double *,
+        double *, int *, double*, double *, int *, double*, int *);
+
+int BLASFUNC(sgetf2)(int *, int *, float  *, int *, int *, int *);
+int BLASFUNC(dgetf2)(int *, int *, double *, int *, int *, int *);
+int BLASFUNC(qgetf2)(int *, int *, double *, int *, int *, int *);
+int BLASFUNC(cgetf2)(int *, int *, float  *, int *, int *, int *);
+int BLASFUNC(zgetf2)(int *, int *, double *, int *, int *, int *);
+int BLASFUNC(xgetf2)(int *, int *, double *, int *, int *, int *);
+
+int BLASFUNC(sgetrf)(int *, int *, float  *, int *, int *, int *);
+int BLASFUNC(dgetrf)(int *, int *, double *, int *, int *, int *);
+int BLASFUNC(qgetrf)(int *, int *, double *, int *, int *, int *);
+int BLASFUNC(cgetrf)(int *, int *, float  *, int *, int *, int *);
+int BLASFUNC(zgetrf)(int *, int *, double *, int *, int *, int *);
+int BLASFUNC(xgetrf)(int *, int *, double *, int *, int *, int *);
+
+int BLASFUNC(slaswp)(int *, float  *, int *, int *, int *, int *, int *);
+int BLASFUNC(dlaswp)(int *, double *, int *, int *, int *, int *, int *);
+int BLASFUNC(qlaswp)(int *, double *, int *, int *, int *, int *, int *);
+int BLASFUNC(claswp)(int *, float  *, int *, int *, int *, int *, int *);
+int BLASFUNC(zlaswp)(int *, double *, int *, int *, int *, int *, int *);
+int BLASFUNC(xlaswp)(int *, double *, int *, int *, int *, int *, int *);
+
+int BLASFUNC(sgetrs)(char *, int *, int *, float  *, int *, int *, float  *, int *, int *);
+int BLASFUNC(dgetrs)(char *, int *, int *, double *, int *, int *, double *, int *, int *);
+int BLASFUNC(qgetrs)(char *, int *, int *, double *, int *, int *, double *, int *, int *);
+int BLASFUNC(cgetrs)(char *, int *, int *, float  *, int *, int *, float  *, int *, int *);
+int BLASFUNC(zgetrs)(char *, int *, int *, double *, int *, int *, double *, int *, int *);
+int BLASFUNC(xgetrs)(char *, int *, int *, double *, int *, int *, double *, int *, int *);
+
+int BLASFUNC(sgesv)(int *, int *, float  *, int *, int *, float *, int *, int *);
+int BLASFUNC(dgesv)(int *, int *, double *, int *, int *, double*, int *, int *);
+int BLASFUNC(qgesv)(int *, int *, double *, int *, int *, double*, int *, int *);
+int BLASFUNC(cgesv)(int *, int *, float  *, int *, int *, float *, int *, int *);
+int BLASFUNC(zgesv)(int *, int *, double *, int *, int *, double*, int *, int *);
+int BLASFUNC(xgesv)(int *, int *, double *, int *, int *, double*, int *, int *);
+
+int BLASFUNC(spotf2)(char *, int *, float  *, int *, int *);
+int BLASFUNC(dpotf2)(char *, int *, double *, int *, int *);
+int BLASFUNC(qpotf2)(char *, int *, double *, int *, int *);
+int BLASFUNC(cpotf2)(char *, int *, float  *, int *, int *);
+int BLASFUNC(zpotf2)(char *, int *, double *, int *, int *);
+int BLASFUNC(xpotf2)(char *, int *, double *, int *, int *);
+
+int BLASFUNC(spotrf)(char *, int *, float  *, int *, int *);
+int BLASFUNC(dpotrf)(char *, int *, double *, int *, int *);
+int BLASFUNC(qpotrf)(char *, int *, double *, int *, int *);
+int BLASFUNC(cpotrf)(char *, int *, float  *, int *, int *);
+int BLASFUNC(zpotrf)(char *, int *, double *, int *, int *);
+int BLASFUNC(xpotrf)(char *, int *, double *, int *, int *);
+
+int BLASFUNC(slauu2)(char *, int *, float  *, int *, int *);
+int BLASFUNC(dlauu2)(char *, int *, double *, int *, int *);
+int BLASFUNC(qlauu2)(char *, int *, double *, int *, int *);
+int BLASFUNC(clauu2)(char *, int *, float  *, int *, int *);
+int BLASFUNC(zlauu2)(char *, int *, double *, int *, int *);
+int BLASFUNC(xlauu2)(char *, int *, double *, int *, int *);
+
+int BLASFUNC(slauum)(char *, int *, float  *, int *, int *);
+int BLASFUNC(dlauum)(char *, int *, double *, int *, int *);
+int BLASFUNC(qlauum)(char *, int *, double *, int *, int *);
+int BLASFUNC(clauum)(char *, int *, float  *, int *, int *);
+int BLASFUNC(zlauum)(char *, int *, double *, int *, int *);
+int BLASFUNC(xlauum)(char *, int *, double *, int *, int *);
+
+int BLASFUNC(strti2)(char *, char *, int *, float  *, int *, int *);
+int BLASFUNC(dtrti2)(char *, char *, int *, double *, int *, int *);
+int BLASFUNC(qtrti2)(char *, char *, int *, double *, int *, int *);
+int BLASFUNC(ctrti2)(char *, char *, int *, float  *, int *, int *);
+int BLASFUNC(ztrti2)(char *, char *, int *, double *, int *, int *);
+int BLASFUNC(xtrti2)(char *, char *, int *, double *, int *, int *);
+
+int BLASFUNC(strtri)(char *, char *, int *, float  *, int *, int *);
+int BLASFUNC(dtrtri)(char *, char *, int *, double *, int *, int *);
+int BLASFUNC(qtrtri)(char *, char *, int *, double *, int *, int *);
+int BLASFUNC(ctrtri)(char *, char *, int *, float  *, int *, int *);
+int BLASFUNC(ztrtri)(char *, char *, int *, double *, int *, int *);
+int BLASFUNC(xtrtri)(char *, char *, int *, double *, int *, int *);
+
+int BLASFUNC(spotri)(char *, int *, float  *, int *, int *);
+int BLASFUNC(dpotri)(char *, int *, double *, int *, int *);
+int BLASFUNC(qpotri)(char *, int *, double *, int *, int *);
+int BLASFUNC(cpotri)(char *, int *, float  *, int *, int *);
+int BLASFUNC(zpotri)(char *, int *, double *, int *, int *);
+int BLASFUNC(xpotri)(char *, int *, double *, int *, int *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/misc/lapacke.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/misc/lapacke.h
new file mode 100644
index 00000000..3d8e24f5
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/misc/lapacke.h
@@ -0,0 +1,16292 @@
+/*****************************************************************************
+  Copyright (c) 2010, Intel Corp.
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Intel Corporation nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+  THE POSSIBILITY OF SUCH DAMAGE.
+******************************************************************************
+* Contents: Native C interface to LAPACK
+* Author: Intel Corporation
+* Generated November, 2011
+*****************************************************************************/
+
+#ifndef _MKL_LAPACKE_H_
+
+#ifndef _LAPACKE_H_
+#define _LAPACKE_H_
+
+/*
+*  Turn on HAVE_LAPACK_CONFIG_H to redefine C-LAPACK datatypes
+*/
+#ifdef HAVE_LAPACK_CONFIG_H
+#include "lapacke_config.h"
+#endif
+
+#include <stdlib.h>
+
+#ifndef lapack_int
+#define lapack_int     int
+#endif
+
+#ifndef lapack_logical
+#define lapack_logical lapack_int
+#endif
+
+/* Complex types are structures equivalent to the
+* Fortran complex types COMPLEX(4) and COMPLEX(8).
+*
+* One can also redefine the types with his own types
+* for example by including in the code definitions like
+*
+* #define lapack_complex_float std::complex<float>
+* #define lapack_complex_double std::complex<double>
+*
+* or define these types in the command line:
+*
+* -Dlapack_complex_float="std::complex<float>"
+* -Dlapack_complex_double="std::complex<double>"
+*/
+
+#ifndef LAPACK_COMPLEX_CUSTOM
+
+/* Complex type (single precision) */
+#ifndef lapack_complex_float
+#include <complex.h>
+#define lapack_complex_float    float _Complex
+#endif
+
+#ifndef lapack_complex_float_real
+#define lapack_complex_float_real(z)       (creal(z))
+#endif
+
+#ifndef lapack_complex_float_imag
+#define lapack_complex_float_imag(z)       (cimag(z))
+#endif
+
+lapack_complex_float lapack_make_complex_float( float re, float im );
+
+/* Complex type (double precision) */
+#ifndef lapack_complex_double
+#include <complex.h>
+#define lapack_complex_double   double _Complex
+#endif
+
+#ifndef lapack_complex_double_real
+#define lapack_complex_double_real(z)      (creal(z))
+#endif
+
+#ifndef lapack_complex_double_imag
+#define lapack_complex_double_imag(z)       (cimag(z))
+#endif
+
+lapack_complex_double lapack_make_complex_double( double re, double im );
+
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#ifndef LAPACKE_malloc
+#define LAPACKE_malloc( size ) malloc( size )
+#endif
+#ifndef LAPACKE_free
+#define LAPACKE_free( p )      free( p )
+#endif
+
+#define LAPACK_C2INT( x ) (lapack_int)(*((float*)&x ))
+#define LAPACK_Z2INT( x ) (lapack_int)(*((double*)&x ))
+
+#define LAPACK_ROW_MAJOR               101
+#define LAPACK_COL_MAJOR               102
+
+#define LAPACK_WORK_MEMORY_ERROR       -1010
+#define LAPACK_TRANSPOSE_MEMORY_ERROR  -1011
+
+/* Callback logical functions of one, two, or three arguments are used
+*  to select eigenvalues to sort to the top left of the Schur form.
+*  The value is selected if function returns TRUE (non-zero). */
+
+typedef lapack_logical (*LAPACK_S_SELECT2) ( const float*, const float* );
+typedef lapack_logical (*LAPACK_S_SELECT3)
+    ( const float*, const float*, const float* );
+typedef lapack_logical (*LAPACK_D_SELECT2) ( const double*, const double* );
+typedef lapack_logical (*LAPACK_D_SELECT3)
+    ( const double*, const double*, const double* );
+
+typedef lapack_logical (*LAPACK_C_SELECT1) ( const lapack_complex_float* );
+typedef lapack_logical (*LAPACK_C_SELECT2)
+    ( const lapack_complex_float*, const lapack_complex_float* );
+typedef lapack_logical (*LAPACK_Z_SELECT1) ( const lapack_complex_double* );
+typedef lapack_logical (*LAPACK_Z_SELECT2)
+    ( const lapack_complex_double*, const lapack_complex_double* );
+
+#include "lapacke_mangling.h"
+
+#define LAPACK_lsame LAPACK_GLOBAL(lsame,LSAME)
+lapack_logical LAPACK_lsame( char* ca,  char* cb,
+                              lapack_int lca, lapack_int lcb );
+
+/* C-LAPACK function prototypes */
+
+lapack_int LAPACKE_sbdsdc( int matrix_order, char uplo, char compq,
+                           lapack_int n, float* d, float* e, float* u,
+                           lapack_int ldu, float* vt, lapack_int ldvt, float* q,
+                           lapack_int* iq );
+lapack_int LAPACKE_dbdsdc( int matrix_order, char uplo, char compq,
+                           lapack_int n, double* d, double* e, double* u,
+                           lapack_int ldu, double* vt, lapack_int ldvt,
+                           double* q, lapack_int* iq );
+
+lapack_int LAPACKE_sbdsqr( int matrix_order, char uplo, lapack_int n,
+                           lapack_int ncvt, lapack_int nru, lapack_int ncc,
+                           float* d, float* e, float* vt, lapack_int ldvt,
+                           float* u, lapack_int ldu, float* c, lapack_int ldc );
+lapack_int LAPACKE_dbdsqr( int matrix_order, char uplo, lapack_int n,
+                           lapack_int ncvt, lapack_int nru, lapack_int ncc,
+                           double* d, double* e, double* vt, lapack_int ldvt,
+                           double* u, lapack_int ldu, double* c,
+                           lapack_int ldc );
+lapack_int LAPACKE_cbdsqr( int matrix_order, char uplo, lapack_int n,
+                           lapack_int ncvt, lapack_int nru, lapack_int ncc,
+                           float* d, float* e, lapack_complex_float* vt,
+                           lapack_int ldvt, lapack_complex_float* u,
+                           lapack_int ldu, lapack_complex_float* c,
+                           lapack_int ldc );
+lapack_int LAPACKE_zbdsqr( int matrix_order, char uplo, lapack_int n,
+                           lapack_int ncvt, lapack_int nru, lapack_int ncc,
+                           double* d, double* e, lapack_complex_double* vt,
+                           lapack_int ldvt, lapack_complex_double* u,
+                           lapack_int ldu, lapack_complex_double* c,
+                           lapack_int ldc );
+
+lapack_int LAPACKE_sdisna( char job, lapack_int m, lapack_int n, const float* d,
+                           float* sep );
+lapack_int LAPACKE_ddisna( char job, lapack_int m, lapack_int n,
+                           const double* d, double* sep );
+
+lapack_int LAPACKE_sgbbrd( int matrix_order, char vect, lapack_int m,
+                           lapack_int n, lapack_int ncc, lapack_int kl,
+                           lapack_int ku, float* ab, lapack_int ldab, float* d,
+                           float* e, float* q, lapack_int ldq, float* pt,
+                           lapack_int ldpt, float* c, lapack_int ldc );
+lapack_int LAPACKE_dgbbrd( int matrix_order, char vect, lapack_int m,
+                           lapack_int n, lapack_int ncc, lapack_int kl,
+                           lapack_int ku, double* ab, lapack_int ldab,
+                           double* d, double* e, double* q, lapack_int ldq,
+                           double* pt, lapack_int ldpt, double* c,
+                           lapack_int ldc );
+lapack_int LAPACKE_cgbbrd( int matrix_order, char vect, lapack_int m,
+                           lapack_int n, lapack_int ncc, lapack_int kl,
+                           lapack_int ku, lapack_complex_float* ab,
+                           lapack_int ldab, float* d, float* e,
+                           lapack_complex_float* q, lapack_int ldq,
+                           lapack_complex_float* pt, lapack_int ldpt,
+                           lapack_complex_float* c, lapack_int ldc );
+lapack_int LAPACKE_zgbbrd( int matrix_order, char vect, lapack_int m,
+                           lapack_int n, lapack_int ncc, lapack_int kl,
+                           lapack_int ku, lapack_complex_double* ab,
+                           lapack_int ldab, double* d, double* e,
+                           lapack_complex_double* q, lapack_int ldq,
+                           lapack_complex_double* pt, lapack_int ldpt,
+                           lapack_complex_double* c, lapack_int ldc );
+
+lapack_int LAPACKE_sgbcon( int matrix_order, char norm, lapack_int n,
+                           lapack_int kl, lapack_int ku, const float* ab,
+                           lapack_int ldab, const lapack_int* ipiv, float anorm,
+                           float* rcond );
+lapack_int LAPACKE_dgbcon( int matrix_order, char norm, lapack_int n,
+                           lapack_int kl, lapack_int ku, const double* ab,
+                           lapack_int ldab, const lapack_int* ipiv,
+                           double anorm, double* rcond );
+lapack_int LAPACKE_cgbcon( int matrix_order, char norm, lapack_int n,
+                           lapack_int kl, lapack_int ku,
+                           const lapack_complex_float* ab, lapack_int ldab,
+                           const lapack_int* ipiv, float anorm, float* rcond );
+lapack_int LAPACKE_zgbcon( int matrix_order, char norm, lapack_int n,
+                           lapack_int kl, lapack_int ku,
+                           const lapack_complex_double* ab, lapack_int ldab,
+                           const lapack_int* ipiv, double anorm,
+                           double* rcond );
+
+lapack_int LAPACKE_sgbequ( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku, const float* ab,
+                           lapack_int ldab, float* r, float* c, float* rowcnd,
+                           float* colcnd, float* amax );
+lapack_int LAPACKE_dgbequ( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku, const double* ab,
+                           lapack_int ldab, double* r, double* c,
+                           double* rowcnd, double* colcnd, double* amax );
+lapack_int LAPACKE_cgbequ( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku,
+                           const lapack_complex_float* ab, lapack_int ldab,
+                           float* r, float* c, float* rowcnd, float* colcnd,
+                           float* amax );
+lapack_int LAPACKE_zgbequ( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku,
+                           const lapack_complex_double* ab, lapack_int ldab,
+                           double* r, double* c, double* rowcnd, double* colcnd,
+                           double* amax );
+
+lapack_int LAPACKE_sgbequb( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_int kl, lapack_int ku, const float* ab,
+                            lapack_int ldab, float* r, float* c, float* rowcnd,
+                            float* colcnd, float* amax );
+lapack_int LAPACKE_dgbequb( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_int kl, lapack_int ku, const double* ab,
+                            lapack_int ldab, double* r, double* c,
+                            double* rowcnd, double* colcnd, double* amax );
+lapack_int LAPACKE_cgbequb( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_int kl, lapack_int ku,
+                            const lapack_complex_float* ab, lapack_int ldab,
+                            float* r, float* c, float* rowcnd, float* colcnd,
+                            float* amax );
+lapack_int LAPACKE_zgbequb( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_int kl, lapack_int ku,
+                            const lapack_complex_double* ab, lapack_int ldab,
+                            double* r, double* c, double* rowcnd,
+                            double* colcnd, double* amax );
+
+lapack_int LAPACKE_sgbrfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int kl, lapack_int ku, lapack_int nrhs,
+                           const float* ab, lapack_int ldab, const float* afb,
+                           lapack_int ldafb, const lapack_int* ipiv,
+                           const float* b, lapack_int ldb, float* x,
+                           lapack_int ldx, float* ferr, float* berr );
+lapack_int LAPACKE_dgbrfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int kl, lapack_int ku, lapack_int nrhs,
+                           const double* ab, lapack_int ldab, const double* afb,
+                           lapack_int ldafb, const lapack_int* ipiv,
+                           const double* b, lapack_int ldb, double* x,
+                           lapack_int ldx, double* ferr, double* berr );
+lapack_int LAPACKE_cgbrfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int kl, lapack_int ku, lapack_int nrhs,
+                           const lapack_complex_float* ab, lapack_int ldab,
+                           const lapack_complex_float* afb, lapack_int ldafb,
+                           const lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zgbrfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int kl, lapack_int ku, lapack_int nrhs,
+                           const lapack_complex_double* ab, lapack_int ldab,
+                           const lapack_complex_double* afb, lapack_int ldafb,
+                           const lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_sgbrfsx( int matrix_order, char trans, char equed,
+                            lapack_int n, lapack_int kl, lapack_int ku,
+                            lapack_int nrhs, const float* ab, lapack_int ldab,
+                            const float* afb, lapack_int ldafb,
+                            const lapack_int* ipiv, const float* r,
+                            const float* c, const float* b, lapack_int ldb,
+                            float* x, lapack_int ldx, float* rcond, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_dgbrfsx( int matrix_order, char trans, char equed,
+                            lapack_int n, lapack_int kl, lapack_int ku,
+                            lapack_int nrhs, const double* ab, lapack_int ldab,
+                            const double* afb, lapack_int ldafb,
+                            const lapack_int* ipiv, const double* r,
+                            const double* c, const double* b, lapack_int ldb,
+                            double* x, lapack_int ldx, double* rcond,
+                            double* berr, lapack_int n_err_bnds,
+                            double* err_bnds_norm, double* err_bnds_comp,
+                            lapack_int nparams, double* params );
+lapack_int LAPACKE_cgbrfsx( int matrix_order, char trans, char equed,
+                            lapack_int n, lapack_int kl, lapack_int ku,
+                            lapack_int nrhs, const lapack_complex_float* ab,
+                            lapack_int ldab, const lapack_complex_float* afb,
+                            lapack_int ldafb, const lapack_int* ipiv,
+                            const float* r, const float* c,
+                            const lapack_complex_float* b, lapack_int ldb,
+                            lapack_complex_float* x, lapack_int ldx,
+                            float* rcond, float* berr, lapack_int n_err_bnds,
+                            float* err_bnds_norm, float* err_bnds_comp,
+                            lapack_int nparams, float* params );
+lapack_int LAPACKE_zgbrfsx( int matrix_order, char trans, char equed,
+                            lapack_int n, lapack_int kl, lapack_int ku,
+                            lapack_int nrhs, const lapack_complex_double* ab,
+                            lapack_int ldab, const lapack_complex_double* afb,
+                            lapack_int ldafb, const lapack_int* ipiv,
+                            const double* r, const double* c,
+                            const lapack_complex_double* b, lapack_int ldb,
+                            lapack_complex_double* x, lapack_int ldx,
+                            double* rcond, double* berr, lapack_int n_err_bnds,
+                            double* err_bnds_norm, double* err_bnds_comp,
+                            lapack_int nparams, double* params );
+
+lapack_int LAPACKE_sgbsv( int matrix_order, lapack_int n, lapack_int kl,
+                          lapack_int ku, lapack_int nrhs, float* ab,
+                          lapack_int ldab, lapack_int* ipiv, float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_dgbsv( int matrix_order, lapack_int n, lapack_int kl,
+                          lapack_int ku, lapack_int nrhs, double* ab,
+                          lapack_int ldab, lapack_int* ipiv, double* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_cgbsv( int matrix_order, lapack_int n, lapack_int kl,
+                          lapack_int ku, lapack_int nrhs,
+                          lapack_complex_float* ab, lapack_int ldab,
+                          lapack_int* ipiv, lapack_complex_float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_zgbsv( int matrix_order, lapack_int n, lapack_int kl,
+                          lapack_int ku, lapack_int nrhs,
+                          lapack_complex_double* ab, lapack_int ldab,
+                          lapack_int* ipiv, lapack_complex_double* b,
+                          lapack_int ldb );
+
+lapack_int LAPACKE_sgbsvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int kl, lapack_int ku,
+                           lapack_int nrhs, float* ab, lapack_int ldab,
+                           float* afb, lapack_int ldafb, lapack_int* ipiv,
+                           char* equed, float* r, float* c, float* b,
+                           lapack_int ldb, float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr,
+                           float* rpivot );
+lapack_int LAPACKE_dgbsvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int kl, lapack_int ku,
+                           lapack_int nrhs, double* ab, lapack_int ldab,
+                           double* afb, lapack_int ldafb, lapack_int* ipiv,
+                           char* equed, double* r, double* c, double* b,
+                           lapack_int ldb, double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr,
+                           double* rpivot );
+lapack_int LAPACKE_cgbsvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int kl, lapack_int ku,
+                           lapack_int nrhs, lapack_complex_float* ab,
+                           lapack_int ldab, lapack_complex_float* afb,
+                           lapack_int ldafb, lapack_int* ipiv, char* equed,
+                           float* r, float* c, lapack_complex_float* b,
+                           lapack_int ldb, lapack_complex_float* x,
+                           lapack_int ldx, float* rcond, float* ferr,
+                           float* berr, float* rpivot );
+lapack_int LAPACKE_zgbsvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int kl, lapack_int ku,
+                           lapack_int nrhs, lapack_complex_double* ab,
+                           lapack_int ldab, lapack_complex_double* afb,
+                           lapack_int ldafb, lapack_int* ipiv, char* equed,
+                           double* r, double* c, lapack_complex_double* b,
+                           lapack_int ldb, lapack_complex_double* x,
+                           lapack_int ldx, double* rcond, double* ferr,
+                           double* berr, double* rpivot );
+
+lapack_int LAPACKE_sgbsvxx( int matrix_order, char fact, char trans,
+                            lapack_int n, lapack_int kl, lapack_int ku,
+                            lapack_int nrhs, float* ab, lapack_int ldab,
+                            float* afb, lapack_int ldafb, lapack_int* ipiv,
+                            char* equed, float* r, float* c, float* b,
+                            lapack_int ldb, float* x, lapack_int ldx,
+                            float* rcond, float* rpvgrw, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_dgbsvxx( int matrix_order, char fact, char trans,
+                            lapack_int n, lapack_int kl, lapack_int ku,
+                            lapack_int nrhs, double* ab, lapack_int ldab,
+                            double* afb, lapack_int ldafb, lapack_int* ipiv,
+                            char* equed, double* r, double* c, double* b,
+                            lapack_int ldb, double* x, lapack_int ldx,
+                            double* rcond, double* rpvgrw, double* berr,
+                            lapack_int n_err_bnds, double* err_bnds_norm,
+                            double* err_bnds_comp, lapack_int nparams,
+                            double* params );
+lapack_int LAPACKE_cgbsvxx( int matrix_order, char fact, char trans,
+                            lapack_int n, lapack_int kl, lapack_int ku,
+                            lapack_int nrhs, lapack_complex_float* ab,
+                            lapack_int ldab, lapack_complex_float* afb,
+                            lapack_int ldafb, lapack_int* ipiv, char* equed,
+                            float* r, float* c, lapack_complex_float* b,
+                            lapack_int ldb, lapack_complex_float* x,
+                            lapack_int ldx, float* rcond, float* rpvgrw,
+                            float* berr, lapack_int n_err_bnds,
+                            float* err_bnds_norm, float* err_bnds_comp,
+                            lapack_int nparams, float* params );
+lapack_int LAPACKE_zgbsvxx( int matrix_order, char fact, char trans,
+                            lapack_int n, lapack_int kl, lapack_int ku,
+                            lapack_int nrhs, lapack_complex_double* ab,
+                            lapack_int ldab, lapack_complex_double* afb,
+                            lapack_int ldafb, lapack_int* ipiv, char* equed,
+                            double* r, double* c, lapack_complex_double* b,
+                            lapack_int ldb, lapack_complex_double* x,
+                            lapack_int ldx, double* rcond, double* rpvgrw,
+                            double* berr, lapack_int n_err_bnds,
+                            double* err_bnds_norm, double* err_bnds_comp,
+                            lapack_int nparams, double* params );
+
+lapack_int LAPACKE_sgbtrf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku, float* ab,
+                           lapack_int ldab, lapack_int* ipiv );
+lapack_int LAPACKE_dgbtrf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku, double* ab,
+                           lapack_int ldab, lapack_int* ipiv );
+lapack_int LAPACKE_cgbtrf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku,
+                           lapack_complex_float* ab, lapack_int ldab,
+                           lapack_int* ipiv );
+lapack_int LAPACKE_zgbtrf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku,
+                           lapack_complex_double* ab, lapack_int ldab,
+                           lapack_int* ipiv );
+
+lapack_int LAPACKE_sgbtrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int kl, lapack_int ku, lapack_int nrhs,
+                           const float* ab, lapack_int ldab,
+                           const lapack_int* ipiv, float* b, lapack_int ldb );
+lapack_int LAPACKE_dgbtrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int kl, lapack_int ku, lapack_int nrhs,
+                           const double* ab, lapack_int ldab,
+                           const lapack_int* ipiv, double* b, lapack_int ldb );
+lapack_int LAPACKE_cgbtrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int kl, lapack_int ku, lapack_int nrhs,
+                           const lapack_complex_float* ab, lapack_int ldab,
+                           const lapack_int* ipiv, lapack_complex_float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_zgbtrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int kl, lapack_int ku, lapack_int nrhs,
+                           const lapack_complex_double* ab, lapack_int ldab,
+                           const lapack_int* ipiv, lapack_complex_double* b,
+                           lapack_int ldb );
+
+lapack_int LAPACKE_sgebak( int matrix_order, char job, char side, lapack_int n,
+                           lapack_int ilo, lapack_int ihi, const float* scale,
+                           lapack_int m, float* v, lapack_int ldv );
+lapack_int LAPACKE_dgebak( int matrix_order, char job, char side, lapack_int n,
+                           lapack_int ilo, lapack_int ihi, const double* scale,
+                           lapack_int m, double* v, lapack_int ldv );
+lapack_int LAPACKE_cgebak( int matrix_order, char job, char side, lapack_int n,
+                           lapack_int ilo, lapack_int ihi, const float* scale,
+                           lapack_int m, lapack_complex_float* v,
+                           lapack_int ldv );
+lapack_int LAPACKE_zgebak( int matrix_order, char job, char side, lapack_int n,
+                           lapack_int ilo, lapack_int ihi, const double* scale,
+                           lapack_int m, lapack_complex_double* v,
+                           lapack_int ldv );
+
+lapack_int LAPACKE_sgebal( int matrix_order, char job, lapack_int n, float* a,
+                           lapack_int lda, lapack_int* ilo, lapack_int* ihi,
+                           float* scale );
+lapack_int LAPACKE_dgebal( int matrix_order, char job, lapack_int n, double* a,
+                           lapack_int lda, lapack_int* ilo, lapack_int* ihi,
+                           double* scale );
+lapack_int LAPACKE_cgebal( int matrix_order, char job, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int* ilo, lapack_int* ihi, float* scale );
+lapack_int LAPACKE_zgebal( int matrix_order, char job, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* ilo, lapack_int* ihi, double* scale );
+
+lapack_int LAPACKE_sgebrd( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, float* d, float* e,
+                           float* tauq, float* taup );
+lapack_int LAPACKE_dgebrd( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, double* d, double* e,
+                           double* tauq, double* taup );
+lapack_int LAPACKE_cgebrd( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda, float* d,
+                           float* e, lapack_complex_float* tauq,
+                           lapack_complex_float* taup );
+lapack_int LAPACKE_zgebrd( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda, double* d,
+                           double* e, lapack_complex_double* tauq,
+                           lapack_complex_double* taup );
+
+lapack_int LAPACKE_sgecon( int matrix_order, char norm, lapack_int n,
+                           const float* a, lapack_int lda, float anorm,
+                           float* rcond );
+lapack_int LAPACKE_dgecon( int matrix_order, char norm, lapack_int n,
+                           const double* a, lapack_int lda, double anorm,
+                           double* rcond );
+lapack_int LAPACKE_cgecon( int matrix_order, char norm, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           float anorm, float* rcond );
+lapack_int LAPACKE_zgecon( int matrix_order, char norm, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           double anorm, double* rcond );
+
+lapack_int LAPACKE_sgeequ( int matrix_order, lapack_int m, lapack_int n,
+                           const float* a, lapack_int lda, float* r, float* c,
+                           float* rowcnd, float* colcnd, float* amax );
+lapack_int LAPACKE_dgeequ( int matrix_order, lapack_int m, lapack_int n,
+                           const double* a, lapack_int lda, double* r,
+                           double* c, double* rowcnd, double* colcnd,
+                           double* amax );
+lapack_int LAPACKE_cgeequ( int matrix_order, lapack_int m, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           float* r, float* c, float* rowcnd, float* colcnd,
+                           float* amax );
+lapack_int LAPACKE_zgeequ( int matrix_order, lapack_int m, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           double* r, double* c, double* rowcnd, double* colcnd,
+                           double* amax );
+
+lapack_int LAPACKE_sgeequb( int matrix_order, lapack_int m, lapack_int n,
+                            const float* a, lapack_int lda, float* r, float* c,
+                            float* rowcnd, float* colcnd, float* amax );
+lapack_int LAPACKE_dgeequb( int matrix_order, lapack_int m, lapack_int n,
+                            const double* a, lapack_int lda, double* r,
+                            double* c, double* rowcnd, double* colcnd,
+                            double* amax );
+lapack_int LAPACKE_cgeequb( int matrix_order, lapack_int m, lapack_int n,
+                            const lapack_complex_float* a, lapack_int lda,
+                            float* r, float* c, float* rowcnd, float* colcnd,
+                            float* amax );
+lapack_int LAPACKE_zgeequb( int matrix_order, lapack_int m, lapack_int n,
+                            const lapack_complex_double* a, lapack_int lda,
+                            double* r, double* c, double* rowcnd,
+                            double* colcnd, double* amax );
+
+lapack_int LAPACKE_sgees( int matrix_order, char jobvs, char sort,
+                          LAPACK_S_SELECT2 select, lapack_int n, float* a,
+                          lapack_int lda, lapack_int* sdim, float* wr,
+                          float* wi, float* vs, lapack_int ldvs );
+lapack_int LAPACKE_dgees( int matrix_order, char jobvs, char sort,
+                          LAPACK_D_SELECT2 select, lapack_int n, double* a,
+                          lapack_int lda, lapack_int* sdim, double* wr,
+                          double* wi, double* vs, lapack_int ldvs );
+lapack_int LAPACKE_cgees( int matrix_order, char jobvs, char sort,
+                          LAPACK_C_SELECT1 select, lapack_int n,
+                          lapack_complex_float* a, lapack_int lda,
+                          lapack_int* sdim, lapack_complex_float* w,
+                          lapack_complex_float* vs, lapack_int ldvs );
+lapack_int LAPACKE_zgees( int matrix_order, char jobvs, char sort,
+                          LAPACK_Z_SELECT1 select, lapack_int n,
+                          lapack_complex_double* a, lapack_int lda,
+                          lapack_int* sdim, lapack_complex_double* w,
+                          lapack_complex_double* vs, lapack_int ldvs );
+
+lapack_int LAPACKE_sgeesx( int matrix_order, char jobvs, char sort,
+                           LAPACK_S_SELECT2 select, char sense, lapack_int n,
+                           float* a, lapack_int lda, lapack_int* sdim,
+                           float* wr, float* wi, float* vs, lapack_int ldvs,
+                           float* rconde, float* rcondv );
+lapack_int LAPACKE_dgeesx( int matrix_order, char jobvs, char sort,
+                           LAPACK_D_SELECT2 select, char sense, lapack_int n,
+                           double* a, lapack_int lda, lapack_int* sdim,
+                           double* wr, double* wi, double* vs, lapack_int ldvs,
+                           double* rconde, double* rcondv );
+lapack_int LAPACKE_cgeesx( int matrix_order, char jobvs, char sort,
+                           LAPACK_C_SELECT1 select, char sense, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int* sdim, lapack_complex_float* w,
+                           lapack_complex_float* vs, lapack_int ldvs,
+                           float* rconde, float* rcondv );
+lapack_int LAPACKE_zgeesx( int matrix_order, char jobvs, char sort,
+                           LAPACK_Z_SELECT1 select, char sense, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* sdim, lapack_complex_double* w,
+                           lapack_complex_double* vs, lapack_int ldvs,
+                           double* rconde, double* rcondv );
+
+lapack_int LAPACKE_sgeev( int matrix_order, char jobvl, char jobvr,
+                          lapack_int n, float* a, lapack_int lda, float* wr,
+                          float* wi, float* vl, lapack_int ldvl, float* vr,
+                          lapack_int ldvr );
+lapack_int LAPACKE_dgeev( int matrix_order, char jobvl, char jobvr,
+                          lapack_int n, double* a, lapack_int lda, double* wr,
+                          double* wi, double* vl, lapack_int ldvl, double* vr,
+                          lapack_int ldvr );
+lapack_int LAPACKE_cgeev( int matrix_order, char jobvl, char jobvr,
+                          lapack_int n, lapack_complex_float* a, lapack_int lda,
+                          lapack_complex_float* w, lapack_complex_float* vl,
+                          lapack_int ldvl, lapack_complex_float* vr,
+                          lapack_int ldvr );
+lapack_int LAPACKE_zgeev( int matrix_order, char jobvl, char jobvr,
+                          lapack_int n, lapack_complex_double* a,
+                          lapack_int lda, lapack_complex_double* w,
+                          lapack_complex_double* vl, lapack_int ldvl,
+                          lapack_complex_double* vr, lapack_int ldvr );
+
+lapack_int LAPACKE_sgeevx( int matrix_order, char balanc, char jobvl,
+                           char jobvr, char sense, lapack_int n, float* a,
+                           lapack_int lda, float* wr, float* wi, float* vl,
+                           lapack_int ldvl, float* vr, lapack_int ldvr,
+                           lapack_int* ilo, lapack_int* ihi, float* scale,
+                           float* abnrm, float* rconde, float* rcondv );
+lapack_int LAPACKE_dgeevx( int matrix_order, char balanc, char jobvl,
+                           char jobvr, char sense, lapack_int n, double* a,
+                           lapack_int lda, double* wr, double* wi, double* vl,
+                           lapack_int ldvl, double* vr, lapack_int ldvr,
+                           lapack_int* ilo, lapack_int* ihi, double* scale,
+                           double* abnrm, double* rconde, double* rcondv );
+lapack_int LAPACKE_cgeevx( int matrix_order, char balanc, char jobvl,
+                           char jobvr, char sense, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* w, lapack_complex_float* vl,
+                           lapack_int ldvl, lapack_complex_float* vr,
+                           lapack_int ldvr, lapack_int* ilo, lapack_int* ihi,
+                           float* scale, float* abnrm, float* rconde,
+                           float* rcondv );
+lapack_int LAPACKE_zgeevx( int matrix_order, char balanc, char jobvl,
+                           char jobvr, char sense, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* w, lapack_complex_double* vl,
+                           lapack_int ldvl, lapack_complex_double* vr,
+                           lapack_int ldvr, lapack_int* ilo, lapack_int* ihi,
+                           double* scale, double* abnrm, double* rconde,
+                           double* rcondv );
+
+lapack_int LAPACKE_sgehrd( int matrix_order, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, float* a, lapack_int lda,
+                           float* tau );
+lapack_int LAPACKE_dgehrd( int matrix_order, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, double* a, lapack_int lda,
+                           double* tau );
+lapack_int LAPACKE_cgehrd( int matrix_order, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* tau );
+lapack_int LAPACKE_zgehrd( int matrix_order, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* tau );
+
+lapack_int LAPACKE_sgejsv( int matrix_order, char joba, char jobu, char jobv,
+                           char jobr, char jobt, char jobp, lapack_int m,
+                           lapack_int n, float* a, lapack_int lda, float* sva,
+                           float* u, lapack_int ldu, float* v, lapack_int ldv,
+                           float* stat, lapack_int* istat );
+lapack_int LAPACKE_dgejsv( int matrix_order, char joba, char jobu, char jobv,
+                           char jobr, char jobt, char jobp, lapack_int m,
+                           lapack_int n, double* a, lapack_int lda, double* sva,
+                           double* u, lapack_int ldu, double* v, lapack_int ldv,
+                           double* stat, lapack_int* istat );
+
+lapack_int LAPACKE_sgelq2( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, float* tau );
+lapack_int LAPACKE_dgelq2( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, double* tau );
+lapack_int LAPACKE_cgelq2( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* tau );
+lapack_int LAPACKE_zgelq2( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* tau );
+
+lapack_int LAPACKE_sgelqf( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, float* tau );
+lapack_int LAPACKE_dgelqf( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, double* tau );
+lapack_int LAPACKE_cgelqf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* tau );
+lapack_int LAPACKE_zgelqf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* tau );
+
+lapack_int LAPACKE_sgels( int matrix_order, char trans, lapack_int m,
+                          lapack_int n, lapack_int nrhs, float* a,
+                          lapack_int lda, float* b, lapack_int ldb );
+lapack_int LAPACKE_dgels( int matrix_order, char trans, lapack_int m,
+                          lapack_int n, lapack_int nrhs, double* a,
+                          lapack_int lda, double* b, lapack_int ldb );
+lapack_int LAPACKE_cgels( int matrix_order, char trans, lapack_int m,
+                          lapack_int n, lapack_int nrhs,
+                          lapack_complex_float* a, lapack_int lda,
+                          lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zgels( int matrix_order, char trans, lapack_int m,
+                          lapack_int n, lapack_int nrhs,
+                          lapack_complex_double* a, lapack_int lda,
+                          lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_sgelsd( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, float* a, lapack_int lda, float* b,
+                           lapack_int ldb, float* s, float rcond,
+                           lapack_int* rank );
+lapack_int LAPACKE_dgelsd( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, double* a, lapack_int lda,
+                           double* b, lapack_int ldb, double* s, double rcond,
+                           lapack_int* rank );
+lapack_int LAPACKE_cgelsd( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* b,
+                           lapack_int ldb, float* s, float rcond,
+                           lapack_int* rank );
+lapack_int LAPACKE_zgelsd( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb, double* s, double rcond,
+                           lapack_int* rank );
+
+lapack_int LAPACKE_sgelss( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, float* a, lapack_int lda, float* b,
+                           lapack_int ldb, float* s, float rcond,
+                           lapack_int* rank );
+lapack_int LAPACKE_dgelss( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, double* a, lapack_int lda,
+                           double* b, lapack_int ldb, double* s, double rcond,
+                           lapack_int* rank );
+lapack_int LAPACKE_cgelss( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* b,
+                           lapack_int ldb, float* s, float rcond,
+                           lapack_int* rank );
+lapack_int LAPACKE_zgelss( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb, double* s, double rcond,
+                           lapack_int* rank );
+
+lapack_int LAPACKE_sgelsy( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, float* a, lapack_int lda, float* b,
+                           lapack_int ldb, lapack_int* jpvt, float rcond,
+                           lapack_int* rank );
+lapack_int LAPACKE_dgelsy( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, double* a, lapack_int lda,
+                           double* b, lapack_int ldb, lapack_int* jpvt,
+                           double rcond, lapack_int* rank );
+lapack_int LAPACKE_cgelsy( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* b,
+                           lapack_int ldb, lapack_int* jpvt, float rcond,
+                           lapack_int* rank );
+lapack_int LAPACKE_zgelsy( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb, lapack_int* jpvt, double rcond,
+                           lapack_int* rank );
+
+lapack_int LAPACKE_sgeqlf( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, float* tau );
+lapack_int LAPACKE_dgeqlf( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, double* tau );
+lapack_int LAPACKE_cgeqlf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* tau );
+lapack_int LAPACKE_zgeqlf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* tau );
+
+lapack_int LAPACKE_sgeqp3( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, lapack_int* jpvt,
+                           float* tau );
+lapack_int LAPACKE_dgeqp3( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, lapack_int* jpvt,
+                           double* tau );
+lapack_int LAPACKE_cgeqp3( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int* jpvt, lapack_complex_float* tau );
+lapack_int LAPACKE_zgeqp3( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* jpvt, lapack_complex_double* tau );
+
+lapack_int LAPACKE_sgeqpf( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, lapack_int* jpvt,
+                           float* tau );
+lapack_int LAPACKE_dgeqpf( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, lapack_int* jpvt,
+                           double* tau );
+lapack_int LAPACKE_cgeqpf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int* jpvt, lapack_complex_float* tau );
+lapack_int LAPACKE_zgeqpf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* jpvt, lapack_complex_double* tau );
+
+lapack_int LAPACKE_sgeqr2( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, float* tau );
+lapack_int LAPACKE_dgeqr2( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, double* tau );
+lapack_int LAPACKE_cgeqr2( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* tau );
+lapack_int LAPACKE_zgeqr2( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* tau );
+
+lapack_int LAPACKE_sgeqrf( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, float* tau );
+lapack_int LAPACKE_dgeqrf( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, double* tau );
+lapack_int LAPACKE_cgeqrf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* tau );
+lapack_int LAPACKE_zgeqrf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* tau );
+
+lapack_int LAPACKE_sgeqrfp( int matrix_order, lapack_int m, lapack_int n,
+                            float* a, lapack_int lda, float* tau );
+lapack_int LAPACKE_dgeqrfp( int matrix_order, lapack_int m, lapack_int n,
+                            double* a, lapack_int lda, double* tau );
+lapack_int LAPACKE_cgeqrfp( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_complex_float* a, lapack_int lda,
+                            lapack_complex_float* tau );
+lapack_int LAPACKE_zgeqrfp( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_complex_double* a, lapack_int lda,
+                            lapack_complex_double* tau );
+
+lapack_int LAPACKE_sgerfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const float* a, lapack_int lda,
+                           const float* af, lapack_int ldaf,
+                           const lapack_int* ipiv, const float* b,
+                           lapack_int ldb, float* x, lapack_int ldx,
+                           float* ferr, float* berr );
+lapack_int LAPACKE_dgerfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const double* a, lapack_int lda,
+                           const double* af, lapack_int ldaf,
+                           const lapack_int* ipiv, const double* b,
+                           lapack_int ldb, double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+lapack_int LAPACKE_cgerfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* af,
+                           lapack_int ldaf, const lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zgerfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* af,
+                           lapack_int ldaf, const lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_sgerfsx( int matrix_order, char trans, char equed,
+                            lapack_int n, lapack_int nrhs, const float* a,
+                            lapack_int lda, const float* af, lapack_int ldaf,
+                            const lapack_int* ipiv, const float* r,
+                            const float* c, const float* b, lapack_int ldb,
+                            float* x, lapack_int ldx, float* rcond, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_dgerfsx( int matrix_order, char trans, char equed,
+                            lapack_int n, lapack_int nrhs, const double* a,
+                            lapack_int lda, const double* af, lapack_int ldaf,
+                            const lapack_int* ipiv, const double* r,
+                            const double* c, const double* b, lapack_int ldb,
+                            double* x, lapack_int ldx, double* rcond,
+                            double* berr, lapack_int n_err_bnds,
+                            double* err_bnds_norm, double* err_bnds_comp,
+                            lapack_int nparams, double* params );
+lapack_int LAPACKE_cgerfsx( int matrix_order, char trans, char equed,
+                            lapack_int n, lapack_int nrhs,
+                            const lapack_complex_float* a, lapack_int lda,
+                            const lapack_complex_float* af, lapack_int ldaf,
+                            const lapack_int* ipiv, const float* r,
+                            const float* c, const lapack_complex_float* b,
+                            lapack_int ldb, lapack_complex_float* x,
+                            lapack_int ldx, float* rcond, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_zgerfsx( int matrix_order, char trans, char equed,
+                            lapack_int n, lapack_int nrhs,
+                            const lapack_complex_double* a, lapack_int lda,
+                            const lapack_complex_double* af, lapack_int ldaf,
+                            const lapack_int* ipiv, const double* r,
+                            const double* c, const lapack_complex_double* b,
+                            lapack_int ldb, lapack_complex_double* x,
+                            lapack_int ldx, double* rcond, double* berr,
+                            lapack_int n_err_bnds, double* err_bnds_norm,
+                            double* err_bnds_comp, lapack_int nparams,
+                            double* params );
+
+lapack_int LAPACKE_sgerqf( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, float* tau );
+lapack_int LAPACKE_dgerqf( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, double* tau );
+lapack_int LAPACKE_cgerqf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* tau );
+lapack_int LAPACKE_zgerqf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* tau );
+
+lapack_int LAPACKE_sgesdd( int matrix_order, char jobz, lapack_int m,
+                           lapack_int n, float* a, lapack_int lda, float* s,
+                           float* u, lapack_int ldu, float* vt,
+                           lapack_int ldvt );
+lapack_int LAPACKE_dgesdd( int matrix_order, char jobz, lapack_int m,
+                           lapack_int n, double* a, lapack_int lda, double* s,
+                           double* u, lapack_int ldu, double* vt,
+                           lapack_int ldvt );
+lapack_int LAPACKE_cgesdd( int matrix_order, char jobz, lapack_int m,
+                           lapack_int n, lapack_complex_float* a,
+                           lapack_int lda, float* s, lapack_complex_float* u,
+                           lapack_int ldu, lapack_complex_float* vt,
+                           lapack_int ldvt );
+lapack_int LAPACKE_zgesdd( int matrix_order, char jobz, lapack_int m,
+                           lapack_int n, lapack_complex_double* a,
+                           lapack_int lda, double* s, lapack_complex_double* u,
+                           lapack_int ldu, lapack_complex_double* vt,
+                           lapack_int ldvt );
+
+lapack_int LAPACKE_sgesv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          float* a, lapack_int lda, lapack_int* ipiv, float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_dgesv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          double* a, lapack_int lda, lapack_int* ipiv,
+                          double* b, lapack_int ldb );
+lapack_int LAPACKE_cgesv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          lapack_complex_float* a, lapack_int lda,
+                          lapack_int* ipiv, lapack_complex_float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_zgesv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          lapack_complex_double* a, lapack_int lda,
+                          lapack_int* ipiv, lapack_complex_double* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_dsgesv( int matrix_order, lapack_int n, lapack_int nrhs,
+                           double* a, lapack_int lda, lapack_int* ipiv,
+                           double* b, lapack_int ldb, double* x, lapack_int ldx,
+                           lapack_int* iter );
+lapack_int LAPACKE_zcgesv( int matrix_order, lapack_int n, lapack_int nrhs,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* ipiv, lapack_complex_double* b,
+                           lapack_int ldb, lapack_complex_double* x,
+                           lapack_int ldx, lapack_int* iter );
+
+lapack_int LAPACKE_sgesvd( int matrix_order, char jobu, char jobvt,
+                           lapack_int m, lapack_int n, float* a, lapack_int lda,
+                           float* s, float* u, lapack_int ldu, float* vt,
+                           lapack_int ldvt, float* superb );
+lapack_int LAPACKE_dgesvd( int matrix_order, char jobu, char jobvt,
+                           lapack_int m, lapack_int n, double* a,
+                           lapack_int lda, double* s, double* u, lapack_int ldu,
+                           double* vt, lapack_int ldvt, double* superb );
+lapack_int LAPACKE_cgesvd( int matrix_order, char jobu, char jobvt,
+                           lapack_int m, lapack_int n, lapack_complex_float* a,
+                           lapack_int lda, float* s, lapack_complex_float* u,
+                           lapack_int ldu, lapack_complex_float* vt,
+                           lapack_int ldvt, float* superb );
+lapack_int LAPACKE_zgesvd( int matrix_order, char jobu, char jobvt,
+                           lapack_int m, lapack_int n, lapack_complex_double* a,
+                           lapack_int lda, double* s, lapack_complex_double* u,
+                           lapack_int ldu, lapack_complex_double* vt,
+                           lapack_int ldvt, double* superb );
+
+lapack_int LAPACKE_sgesvj( int matrix_order, char joba, char jobu, char jobv,
+                           lapack_int m, lapack_int n, float* a, lapack_int lda,
+                           float* sva, lapack_int mv, float* v, lapack_int ldv,
+                           float* stat );
+lapack_int LAPACKE_dgesvj( int matrix_order, char joba, char jobu, char jobv,
+                           lapack_int m, lapack_int n, double* a,
+                           lapack_int lda, double* sva, lapack_int mv,
+                           double* v, lapack_int ldv, double* stat );
+
+lapack_int LAPACKE_sgesvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int nrhs, float* a,
+                           lapack_int lda, float* af, lapack_int ldaf,
+                           lapack_int* ipiv, char* equed, float* r, float* c,
+                           float* b, lapack_int ldb, float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr,
+                           float* rpivot );
+lapack_int LAPACKE_dgesvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int nrhs, double* a,
+                           lapack_int lda, double* af, lapack_int ldaf,
+                           lapack_int* ipiv, char* equed, double* r, double* c,
+                           double* b, lapack_int ldb, double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr,
+                           double* rpivot );
+lapack_int LAPACKE_cgesvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int nrhs,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* af, lapack_int ldaf,
+                           lapack_int* ipiv, char* equed, float* r, float* c,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr,
+                           float* rpivot );
+lapack_int LAPACKE_zgesvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int nrhs,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* af, lapack_int ldaf,
+                           lapack_int* ipiv, char* equed, double* r, double* c,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr,
+                           double* rpivot );
+
+lapack_int LAPACKE_sgesvxx( int matrix_order, char fact, char trans,
+                            lapack_int n, lapack_int nrhs, float* a,
+                            lapack_int lda, float* af, lapack_int ldaf,
+                            lapack_int* ipiv, char* equed, float* r, float* c,
+                            float* b, lapack_int ldb, float* x, lapack_int ldx,
+                            float* rcond, float* rpvgrw, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_dgesvxx( int matrix_order, char fact, char trans,
+                            lapack_int n, lapack_int nrhs, double* a,
+                            lapack_int lda, double* af, lapack_int ldaf,
+                            lapack_int* ipiv, char* equed, double* r, double* c,
+                            double* b, lapack_int ldb, double* x,
+                            lapack_int ldx, double* rcond, double* rpvgrw,
+                            double* berr, lapack_int n_err_bnds,
+                            double* err_bnds_norm, double* err_bnds_comp,
+                            lapack_int nparams, double* params );
+lapack_int LAPACKE_cgesvxx( int matrix_order, char fact, char trans,
+                            lapack_int n, lapack_int nrhs,
+                            lapack_complex_float* a, lapack_int lda,
+                            lapack_complex_float* af, lapack_int ldaf,
+                            lapack_int* ipiv, char* equed, float* r, float* c,
+                            lapack_complex_float* b, lapack_int ldb,
+                            lapack_complex_float* x, lapack_int ldx,
+                            float* rcond, float* rpvgrw, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_zgesvxx( int matrix_order, char fact, char trans,
+                            lapack_int n, lapack_int nrhs,
+                            lapack_complex_double* a, lapack_int lda,
+                            lapack_complex_double* af, lapack_int ldaf,
+                            lapack_int* ipiv, char* equed, double* r, double* c,
+                            lapack_complex_double* b, lapack_int ldb,
+                            lapack_complex_double* x, lapack_int ldx,
+                            double* rcond, double* rpvgrw, double* berr,
+                            lapack_int n_err_bnds, double* err_bnds_norm,
+                            double* err_bnds_comp, lapack_int nparams,
+                            double* params );
+
+lapack_int LAPACKE_sgetf2( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, lapack_int* ipiv );
+lapack_int LAPACKE_dgetf2( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, lapack_int* ipiv );
+lapack_int LAPACKE_cgetf2( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int* ipiv );
+lapack_int LAPACKE_zgetf2( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* ipiv );
+
+lapack_int LAPACKE_sgetrf( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, lapack_int* ipiv );
+lapack_int LAPACKE_dgetrf( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, lapack_int* ipiv );
+lapack_int LAPACKE_cgetrf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int* ipiv );
+lapack_int LAPACKE_zgetrf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* ipiv );
+
+lapack_int LAPACKE_sgetri( int matrix_order, lapack_int n, float* a,
+                           lapack_int lda, const lapack_int* ipiv );
+lapack_int LAPACKE_dgetri( int matrix_order, lapack_int n, double* a,
+                           lapack_int lda, const lapack_int* ipiv );
+lapack_int LAPACKE_cgetri( int matrix_order, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           const lapack_int* ipiv );
+lapack_int LAPACKE_zgetri( int matrix_order, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           const lapack_int* ipiv );
+
+lapack_int LAPACKE_sgetrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const float* a, lapack_int lda,
+                           const lapack_int* ipiv, float* b, lapack_int ldb );
+lapack_int LAPACKE_dgetrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const double* a, lapack_int lda,
+                           const lapack_int* ipiv, double* b, lapack_int ldb );
+lapack_int LAPACKE_cgetrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* a,
+                           lapack_int lda, const lapack_int* ipiv,
+                           lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zgetrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* a,
+                           lapack_int lda, const lapack_int* ipiv,
+                           lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_sggbak( int matrix_order, char job, char side, lapack_int n,
+                           lapack_int ilo, lapack_int ihi, const float* lscale,
+                           const float* rscale, lapack_int m, float* v,
+                           lapack_int ldv );
+lapack_int LAPACKE_dggbak( int matrix_order, char job, char side, lapack_int n,
+                           lapack_int ilo, lapack_int ihi, const double* lscale,
+                           const double* rscale, lapack_int m, double* v,
+                           lapack_int ldv );
+lapack_int LAPACKE_cggbak( int matrix_order, char job, char side, lapack_int n,
+                           lapack_int ilo, lapack_int ihi, const float* lscale,
+                           const float* rscale, lapack_int m,
+                           lapack_complex_float* v, lapack_int ldv );
+lapack_int LAPACKE_zggbak( int matrix_order, char job, char side, lapack_int n,
+                           lapack_int ilo, lapack_int ihi, const double* lscale,
+                           const double* rscale, lapack_int m,
+                           lapack_complex_double* v, lapack_int ldv );
+
+lapack_int LAPACKE_sggbal( int matrix_order, char job, lapack_int n, float* a,
+                           lapack_int lda, float* b, lapack_int ldb,
+                           lapack_int* ilo, lapack_int* ihi, float* lscale,
+                           float* rscale );
+lapack_int LAPACKE_dggbal( int matrix_order, char job, lapack_int n, double* a,
+                           lapack_int lda, double* b, lapack_int ldb,
+                           lapack_int* ilo, lapack_int* ihi, double* lscale,
+                           double* rscale );
+lapack_int LAPACKE_cggbal( int matrix_order, char job, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_int* ilo, lapack_int* ihi, float* lscale,
+                           float* rscale );
+lapack_int LAPACKE_zggbal( int matrix_order, char job, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_int* ilo, lapack_int* ihi, double* lscale,
+                           double* rscale );
+
+lapack_int LAPACKE_sgges( int matrix_order, char jobvsl, char jobvsr, char sort,
+                          LAPACK_S_SELECT3 selctg, lapack_int n, float* a,
+                          lapack_int lda, float* b, lapack_int ldb,
+                          lapack_int* sdim, float* alphar, float* alphai,
+                          float* beta, float* vsl, lapack_int ldvsl, float* vsr,
+                          lapack_int ldvsr );
+lapack_int LAPACKE_dgges( int matrix_order, char jobvsl, char jobvsr, char sort,
+                          LAPACK_D_SELECT3 selctg, lapack_int n, double* a,
+                          lapack_int lda, double* b, lapack_int ldb,
+                          lapack_int* sdim, double* alphar, double* alphai,
+                          double* beta, double* vsl, lapack_int ldvsl,
+                          double* vsr, lapack_int ldvsr );
+lapack_int LAPACKE_cgges( int matrix_order, char jobvsl, char jobvsr, char sort,
+                          LAPACK_C_SELECT2 selctg, lapack_int n,
+                          lapack_complex_float* a, lapack_int lda,
+                          lapack_complex_float* b, lapack_int ldb,
+                          lapack_int* sdim, lapack_complex_float* alpha,
+                          lapack_complex_float* beta, lapack_complex_float* vsl,
+                          lapack_int ldvsl, lapack_complex_float* vsr,
+                          lapack_int ldvsr );
+lapack_int LAPACKE_zgges( int matrix_order, char jobvsl, char jobvsr, char sort,
+                          LAPACK_Z_SELECT2 selctg, lapack_int n,
+                          lapack_complex_double* a, lapack_int lda,
+                          lapack_complex_double* b, lapack_int ldb,
+                          lapack_int* sdim, lapack_complex_double* alpha,
+                          lapack_complex_double* beta,
+                          lapack_complex_double* vsl, lapack_int ldvsl,
+                          lapack_complex_double* vsr, lapack_int ldvsr );
+
+lapack_int LAPACKE_sggesx( int matrix_order, char jobvsl, char jobvsr,
+                           char sort, LAPACK_S_SELECT3 selctg, char sense,
+                           lapack_int n, float* a, lapack_int lda, float* b,
+                           lapack_int ldb, lapack_int* sdim, float* alphar,
+                           float* alphai, float* beta, float* vsl,
+                           lapack_int ldvsl, float* vsr, lapack_int ldvsr,
+                           float* rconde, float* rcondv );
+lapack_int LAPACKE_dggesx( int matrix_order, char jobvsl, char jobvsr,
+                           char sort, LAPACK_D_SELECT3 selctg, char sense,
+                           lapack_int n, double* a, lapack_int lda, double* b,
+                           lapack_int ldb, lapack_int* sdim, double* alphar,
+                           double* alphai, double* beta, double* vsl,
+                           lapack_int ldvsl, double* vsr, lapack_int ldvsr,
+                           double* rconde, double* rcondv );
+lapack_int LAPACKE_cggesx( int matrix_order, char jobvsl, char jobvsr,
+                           char sort, LAPACK_C_SELECT2 selctg, char sense,
+                           lapack_int n, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* b,
+                           lapack_int ldb, lapack_int* sdim,
+                           lapack_complex_float* alpha,
+                           lapack_complex_float* beta,
+                           lapack_complex_float* vsl, lapack_int ldvsl,
+                           lapack_complex_float* vsr, lapack_int ldvsr,
+                           float* rconde, float* rcondv );
+lapack_int LAPACKE_zggesx( int matrix_order, char jobvsl, char jobvsr,
+                           char sort, LAPACK_Z_SELECT2 selctg, char sense,
+                           lapack_int n, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb, lapack_int* sdim,
+                           lapack_complex_double* alpha,
+                           lapack_complex_double* beta,
+                           lapack_complex_double* vsl, lapack_int ldvsl,
+                           lapack_complex_double* vsr, lapack_int ldvsr,
+                           double* rconde, double* rcondv );
+
+lapack_int LAPACKE_sggev( int matrix_order, char jobvl, char jobvr,
+                          lapack_int n, float* a, lapack_int lda, float* b,
+                          lapack_int ldb, float* alphar, float* alphai,
+                          float* beta, float* vl, lapack_int ldvl, float* vr,
+                          lapack_int ldvr );
+lapack_int LAPACKE_dggev( int matrix_order, char jobvl, char jobvr,
+                          lapack_int n, double* a, lapack_int lda, double* b,
+                          lapack_int ldb, double* alphar, double* alphai,
+                          double* beta, double* vl, lapack_int ldvl, double* vr,
+                          lapack_int ldvr );
+lapack_int LAPACKE_cggev( int matrix_order, char jobvl, char jobvr,
+                          lapack_int n, lapack_complex_float* a, lapack_int lda,
+                          lapack_complex_float* b, lapack_int ldb,
+                          lapack_complex_float* alpha,
+                          lapack_complex_float* beta, lapack_complex_float* vl,
+                          lapack_int ldvl, lapack_complex_float* vr,
+                          lapack_int ldvr );
+lapack_int LAPACKE_zggev( int matrix_order, char jobvl, char jobvr,
+                          lapack_int n, lapack_complex_double* a,
+                          lapack_int lda, lapack_complex_double* b,
+                          lapack_int ldb, lapack_complex_double* alpha,
+                          lapack_complex_double* beta,
+                          lapack_complex_double* vl, lapack_int ldvl,
+                          lapack_complex_double* vr, lapack_int ldvr );
+
+lapack_int LAPACKE_sggevx( int matrix_order, char balanc, char jobvl,
+                           char jobvr, char sense, lapack_int n, float* a,
+                           lapack_int lda, float* b, lapack_int ldb,
+                           float* alphar, float* alphai, float* beta, float* vl,
+                           lapack_int ldvl, float* vr, lapack_int ldvr,
+                           lapack_int* ilo, lapack_int* ihi, float* lscale,
+                           float* rscale, float* abnrm, float* bbnrm,
+                           float* rconde, float* rcondv );
+lapack_int LAPACKE_dggevx( int matrix_order, char balanc, char jobvl,
+                           char jobvr, char sense, lapack_int n, double* a,
+                           lapack_int lda, double* b, lapack_int ldb,
+                           double* alphar, double* alphai, double* beta,
+                           double* vl, lapack_int ldvl, double* vr,
+                           lapack_int ldvr, lapack_int* ilo, lapack_int* ihi,
+                           double* lscale, double* rscale, double* abnrm,
+                           double* bbnrm, double* rconde, double* rcondv );
+lapack_int LAPACKE_cggevx( int matrix_order, char balanc, char jobvl,
+                           char jobvr, char sense, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* alpha,
+                           lapack_complex_float* beta, lapack_complex_float* vl,
+                           lapack_int ldvl, lapack_complex_float* vr,
+                           lapack_int ldvr, lapack_int* ilo, lapack_int* ihi,
+                           float* lscale, float* rscale, float* abnrm,
+                           float* bbnrm, float* rconde, float* rcondv );
+lapack_int LAPACKE_zggevx( int matrix_order, char balanc, char jobvl,
+                           char jobvr, char sense, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* alpha,
+                           lapack_complex_double* beta,
+                           lapack_complex_double* vl, lapack_int ldvl,
+                           lapack_complex_double* vr, lapack_int ldvr,
+                           lapack_int* ilo, lapack_int* ihi, double* lscale,
+                           double* rscale, double* abnrm, double* bbnrm,
+                           double* rconde, double* rcondv );
+
+lapack_int LAPACKE_sggglm( int matrix_order, lapack_int n, lapack_int m,
+                           lapack_int p, float* a, lapack_int lda, float* b,
+                           lapack_int ldb, float* d, float* x, float* y );
+lapack_int LAPACKE_dggglm( int matrix_order, lapack_int n, lapack_int m,
+                           lapack_int p, double* a, lapack_int lda, double* b,
+                           lapack_int ldb, double* d, double* x, double* y );
+lapack_int LAPACKE_cggglm( int matrix_order, lapack_int n, lapack_int m,
+                           lapack_int p, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* b,
+                           lapack_int ldb, lapack_complex_float* d,
+                           lapack_complex_float* x, lapack_complex_float* y );
+lapack_int LAPACKE_zggglm( int matrix_order, lapack_int n, lapack_int m,
+                           lapack_int p, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb, lapack_complex_double* d,
+                           lapack_complex_double* x, lapack_complex_double* y );
+
+lapack_int LAPACKE_sgghrd( int matrix_order, char compq, char compz,
+                           lapack_int n, lapack_int ilo, lapack_int ihi,
+                           float* a, lapack_int lda, float* b, lapack_int ldb,
+                           float* q, lapack_int ldq, float* z, lapack_int ldz );
+lapack_int LAPACKE_dgghrd( int matrix_order, char compq, char compz,
+                           lapack_int n, lapack_int ilo, lapack_int ihi,
+                           double* a, lapack_int lda, double* b, lapack_int ldb,
+                           double* q, lapack_int ldq, double* z,
+                           lapack_int ldz );
+lapack_int LAPACKE_cgghrd( int matrix_order, char compq, char compz,
+                           lapack_int n, lapack_int ilo, lapack_int ihi,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* q, lapack_int ldq,
+                           lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zgghrd( int matrix_order, char compq, char compz,
+                           lapack_int n, lapack_int ilo, lapack_int ihi,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* q, lapack_int ldq,
+                           lapack_complex_double* z, lapack_int ldz );
+
+lapack_int LAPACKE_sgglse( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int p, float* a, lapack_int lda, float* b,
+                           lapack_int ldb, float* c, float* d, float* x );
+lapack_int LAPACKE_dgglse( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int p, double* a, lapack_int lda, double* b,
+                           lapack_int ldb, double* c, double* d, double* x );
+lapack_int LAPACKE_cgglse( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int p, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* b,
+                           lapack_int ldb, lapack_complex_float* c,
+                           lapack_complex_float* d, lapack_complex_float* x );
+lapack_int LAPACKE_zgglse( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int p, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb, lapack_complex_double* c,
+                           lapack_complex_double* d, lapack_complex_double* x );
+
+lapack_int LAPACKE_sggqrf( int matrix_order, lapack_int n, lapack_int m,
+                           lapack_int p, float* a, lapack_int lda, float* taua,
+                           float* b, lapack_int ldb, float* taub );
+lapack_int LAPACKE_dggqrf( int matrix_order, lapack_int n, lapack_int m,
+                           lapack_int p, double* a, lapack_int lda,
+                           double* taua, double* b, lapack_int ldb,
+                           double* taub );
+lapack_int LAPACKE_cggqrf( int matrix_order, lapack_int n, lapack_int m,
+                           lapack_int p, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* taua,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* taub );
+lapack_int LAPACKE_zggqrf( int matrix_order, lapack_int n, lapack_int m,
+                           lapack_int p, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* taua,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* taub );
+
+lapack_int LAPACKE_sggrqf( int matrix_order, lapack_int m, lapack_int p,
+                           lapack_int n, float* a, lapack_int lda, float* taua,
+                           float* b, lapack_int ldb, float* taub );
+lapack_int LAPACKE_dggrqf( int matrix_order, lapack_int m, lapack_int p,
+                           lapack_int n, double* a, lapack_int lda,
+                           double* taua, double* b, lapack_int ldb,
+                           double* taub );
+lapack_int LAPACKE_cggrqf( int matrix_order, lapack_int m, lapack_int p,
+                           lapack_int n, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* taua,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* taub );
+lapack_int LAPACKE_zggrqf( int matrix_order, lapack_int m, lapack_int p,
+                           lapack_int n, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* taua,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* taub );
+
+lapack_int LAPACKE_sggsvd( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int n, lapack_int p,
+                           lapack_int* k, lapack_int* l, float* a,
+                           lapack_int lda, float* b, lapack_int ldb,
+                           float* alpha, float* beta, float* u, lapack_int ldu,
+                           float* v, lapack_int ldv, float* q, lapack_int ldq,
+                           lapack_int* iwork );
+lapack_int LAPACKE_dggsvd( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int n, lapack_int p,
+                           lapack_int* k, lapack_int* l, double* a,
+                           lapack_int lda, double* b, lapack_int ldb,
+                           double* alpha, double* beta, double* u,
+                           lapack_int ldu, double* v, lapack_int ldv, double* q,
+                           lapack_int ldq, lapack_int* iwork );
+lapack_int LAPACKE_cggsvd( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int n, lapack_int p,
+                           lapack_int* k, lapack_int* l,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* b, lapack_int ldb,
+                           float* alpha, float* beta, lapack_complex_float* u,
+                           lapack_int ldu, lapack_complex_float* v,
+                           lapack_int ldv, lapack_complex_float* q,
+                           lapack_int ldq, lapack_int* iwork );
+lapack_int LAPACKE_zggsvd( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int n, lapack_int p,
+                           lapack_int* k, lapack_int* l,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb,
+                           double* alpha, double* beta,
+                           lapack_complex_double* u, lapack_int ldu,
+                           lapack_complex_double* v, lapack_int ldv,
+                           lapack_complex_double* q, lapack_int ldq,
+                           lapack_int* iwork );
+
+lapack_int LAPACKE_sggsvp( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int p, lapack_int n, float* a,
+                           lapack_int lda, float* b, lapack_int ldb, float tola,
+                           float tolb, lapack_int* k, lapack_int* l, float* u,
+                           lapack_int ldu, float* v, lapack_int ldv, float* q,
+                           lapack_int ldq );
+lapack_int LAPACKE_dggsvp( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int p, lapack_int n, double* a,
+                           lapack_int lda, double* b, lapack_int ldb,
+                           double tola, double tolb, lapack_int* k,
+                           lapack_int* l, double* u, lapack_int ldu, double* v,
+                           lapack_int ldv, double* q, lapack_int ldq );
+lapack_int LAPACKE_cggsvp( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int p, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* b, lapack_int ldb, float tola,
+                           float tolb, lapack_int* k, lapack_int* l,
+                           lapack_complex_float* u, lapack_int ldu,
+                           lapack_complex_float* v, lapack_int ldv,
+                           lapack_complex_float* q, lapack_int ldq );
+lapack_int LAPACKE_zggsvp( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int p, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb,
+                           double tola, double tolb, lapack_int* k,
+                           lapack_int* l, lapack_complex_double* u,
+                           lapack_int ldu, lapack_complex_double* v,
+                           lapack_int ldv, lapack_complex_double* q,
+                           lapack_int ldq );
+
+lapack_int LAPACKE_sgtcon( char norm, lapack_int n, const float* dl,
+                           const float* d, const float* du, const float* du2,
+                           const lapack_int* ipiv, float anorm, float* rcond );
+lapack_int LAPACKE_dgtcon( char norm, lapack_int n, const double* dl,
+                           const double* d, const double* du, const double* du2,
+                           const lapack_int* ipiv, double anorm,
+                           double* rcond );
+lapack_int LAPACKE_cgtcon( char norm, lapack_int n,
+                           const lapack_complex_float* dl,
+                           const lapack_complex_float* d,
+                           const lapack_complex_float* du,
+                           const lapack_complex_float* du2,
+                           const lapack_int* ipiv, float anorm, float* rcond );
+lapack_int LAPACKE_zgtcon( char norm, lapack_int n,
+                           const lapack_complex_double* dl,
+                           const lapack_complex_double* d,
+                           const lapack_complex_double* du,
+                           const lapack_complex_double* du2,
+                           const lapack_int* ipiv, double anorm,
+                           double* rcond );
+
+lapack_int LAPACKE_sgtrfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const float* dl, const float* d,
+                           const float* du, const float* dlf, const float* df,
+                           const float* duf, const float* du2,
+                           const lapack_int* ipiv, const float* b,
+                           lapack_int ldb, float* x, lapack_int ldx,
+                           float* ferr, float* berr );
+lapack_int LAPACKE_dgtrfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const double* dl, const double* d,
+                           const double* du, const double* dlf,
+                           const double* df, const double* duf,
+                           const double* du2, const lapack_int* ipiv,
+                           const double* b, lapack_int ldb, double* x,
+                           lapack_int ldx, double* ferr, double* berr );
+lapack_int LAPACKE_cgtrfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* dl,
+                           const lapack_complex_float* d,
+                           const lapack_complex_float* du,
+                           const lapack_complex_float* dlf,
+                           const lapack_complex_float* df,
+                           const lapack_complex_float* duf,
+                           const lapack_complex_float* du2,
+                           const lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zgtrfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* dl,
+                           const lapack_complex_double* d,
+                           const lapack_complex_double* du,
+                           const lapack_complex_double* dlf,
+                           const lapack_complex_double* df,
+                           const lapack_complex_double* duf,
+                           const lapack_complex_double* du2,
+                           const lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_sgtsv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          float* dl, float* d, float* du, float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_dgtsv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          double* dl, double* d, double* du, double* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_cgtsv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          lapack_complex_float* dl, lapack_complex_float* d,
+                          lapack_complex_float* du, lapack_complex_float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_zgtsv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          lapack_complex_double* dl, lapack_complex_double* d,
+                          lapack_complex_double* du, lapack_complex_double* b,
+                          lapack_int ldb );
+
+lapack_int LAPACKE_sgtsvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int nrhs, const float* dl,
+                           const float* d, const float* du, float* dlf,
+                           float* df, float* duf, float* du2, lapack_int* ipiv,
+                           const float* b, lapack_int ldb, float* x,
+                           lapack_int ldx, float* rcond, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_dgtsvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int nrhs, const double* dl,
+                           const double* d, const double* du, double* dlf,
+                           double* df, double* duf, double* du2,
+                           lapack_int* ipiv, const double* b, lapack_int ldb,
+                           double* x, lapack_int ldx, double* rcond,
+                           double* ferr, double* berr );
+lapack_int LAPACKE_cgtsvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_float* dl,
+                           const lapack_complex_float* d,
+                           const lapack_complex_float* du,
+                           lapack_complex_float* dlf, lapack_complex_float* df,
+                           lapack_complex_float* duf, lapack_complex_float* du2,
+                           lapack_int* ipiv, const lapack_complex_float* b,
+                           lapack_int ldb, lapack_complex_float* x,
+                           lapack_int ldx, float* rcond, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zgtsvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_double* dl,
+                           const lapack_complex_double* d,
+                           const lapack_complex_double* du,
+                           lapack_complex_double* dlf,
+                           lapack_complex_double* df,
+                           lapack_complex_double* duf,
+                           lapack_complex_double* du2, lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr );
+
+lapack_int LAPACKE_sgttrf( lapack_int n, float* dl, float* d, float* du,
+                           float* du2, lapack_int* ipiv );
+lapack_int LAPACKE_dgttrf( lapack_int n, double* dl, double* d, double* du,
+                           double* du2, lapack_int* ipiv );
+lapack_int LAPACKE_cgttrf( lapack_int n, lapack_complex_float* dl,
+                           lapack_complex_float* d, lapack_complex_float* du,
+                           lapack_complex_float* du2, lapack_int* ipiv );
+lapack_int LAPACKE_zgttrf( lapack_int n, lapack_complex_double* dl,
+                           lapack_complex_double* d, lapack_complex_double* du,
+                           lapack_complex_double* du2, lapack_int* ipiv );
+
+lapack_int LAPACKE_sgttrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const float* dl, const float* d,
+                           const float* du, const float* du2,
+                           const lapack_int* ipiv, float* b, lapack_int ldb );
+lapack_int LAPACKE_dgttrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const double* dl, const double* d,
+                           const double* du, const double* du2,
+                           const lapack_int* ipiv, double* b, lapack_int ldb );
+lapack_int LAPACKE_cgttrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* dl,
+                           const lapack_complex_float* d,
+                           const lapack_complex_float* du,
+                           const lapack_complex_float* du2,
+                           const lapack_int* ipiv, lapack_complex_float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_zgttrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* dl,
+                           const lapack_complex_double* d,
+                           const lapack_complex_double* du,
+                           const lapack_complex_double* du2,
+                           const lapack_int* ipiv, lapack_complex_double* b,
+                           lapack_int ldb );
+
+lapack_int LAPACKE_chbev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_int kd, lapack_complex_float* ab,
+                          lapack_int ldab, float* w, lapack_complex_float* z,
+                          lapack_int ldz );
+lapack_int LAPACKE_zhbev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_int kd, lapack_complex_double* ab,
+                          lapack_int ldab, double* w, lapack_complex_double* z,
+                          lapack_int ldz );
+
+lapack_int LAPACKE_chbevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_int kd, lapack_complex_float* ab,
+                           lapack_int ldab, float* w, lapack_complex_float* z,
+                           lapack_int ldz );
+lapack_int LAPACKE_zhbevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_int kd, lapack_complex_double* ab,
+                           lapack_int ldab, double* w, lapack_complex_double* z,
+                           lapack_int ldz );
+
+lapack_int LAPACKE_chbevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_int kd,
+                           lapack_complex_float* ab, lapack_int ldab,
+                           lapack_complex_float* q, lapack_int ldq, float vl,
+                           float vu, lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, lapack_complex_float* z,
+                           lapack_int ldz, lapack_int* ifail );
+lapack_int LAPACKE_zhbevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_int kd,
+                           lapack_complex_double* ab, lapack_int ldab,
+                           lapack_complex_double* q, lapack_int ldq, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w,
+                           lapack_complex_double* z, lapack_int ldz,
+                           lapack_int* ifail );
+
+lapack_int LAPACKE_chbgst( int matrix_order, char vect, char uplo, lapack_int n,
+                           lapack_int ka, lapack_int kb,
+                           lapack_complex_float* ab, lapack_int ldab,
+                           const lapack_complex_float* bb, lapack_int ldbb,
+                           lapack_complex_float* x, lapack_int ldx );
+lapack_int LAPACKE_zhbgst( int matrix_order, char vect, char uplo, lapack_int n,
+                           lapack_int ka, lapack_int kb,
+                           lapack_complex_double* ab, lapack_int ldab,
+                           const lapack_complex_double* bb, lapack_int ldbb,
+                           lapack_complex_double* x, lapack_int ldx );
+
+lapack_int LAPACKE_chbgv( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_int ka, lapack_int kb,
+                          lapack_complex_float* ab, lapack_int ldab,
+                          lapack_complex_float* bb, lapack_int ldbb, float* w,
+                          lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zhbgv( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_int ka, lapack_int kb,
+                          lapack_complex_double* ab, lapack_int ldab,
+                          lapack_complex_double* bb, lapack_int ldbb, double* w,
+                          lapack_complex_double* z, lapack_int ldz );
+
+lapack_int LAPACKE_chbgvd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_int ka, lapack_int kb,
+                           lapack_complex_float* ab, lapack_int ldab,
+                           lapack_complex_float* bb, lapack_int ldbb, float* w,
+                           lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zhbgvd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_int ka, lapack_int kb,
+                           lapack_complex_double* ab, lapack_int ldab,
+                           lapack_complex_double* bb, lapack_int ldbb,
+                           double* w, lapack_complex_double* z,
+                           lapack_int ldz );
+
+lapack_int LAPACKE_chbgvx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_int ka, lapack_int kb,
+                           lapack_complex_float* ab, lapack_int ldab,
+                           lapack_complex_float* bb, lapack_int ldbb,
+                           lapack_complex_float* q, lapack_int ldq, float vl,
+                           float vu, lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, lapack_complex_float* z,
+                           lapack_int ldz, lapack_int* ifail );
+lapack_int LAPACKE_zhbgvx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_int ka, lapack_int kb,
+                           lapack_complex_double* ab, lapack_int ldab,
+                           lapack_complex_double* bb, lapack_int ldbb,
+                           lapack_complex_double* q, lapack_int ldq, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w,
+                           lapack_complex_double* z, lapack_int ldz,
+                           lapack_int* ifail );
+
+lapack_int LAPACKE_chbtrd( int matrix_order, char vect, char uplo, lapack_int n,
+                           lapack_int kd, lapack_complex_float* ab,
+                           lapack_int ldab, float* d, float* e,
+                           lapack_complex_float* q, lapack_int ldq );
+lapack_int LAPACKE_zhbtrd( int matrix_order, char vect, char uplo, lapack_int n,
+                           lapack_int kd, lapack_complex_double* ab,
+                           lapack_int ldab, double* d, double* e,
+                           lapack_complex_double* q, lapack_int ldq );
+
+lapack_int LAPACKE_checon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_int* ipiv, float anorm, float* rcond );
+lapack_int LAPACKE_zhecon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_int* ipiv, double anorm,
+                           double* rcond );
+
+lapack_int LAPACKE_cheequb( int matrix_order, char uplo, lapack_int n,
+                            const lapack_complex_float* a, lapack_int lda,
+                            float* s, float* scond, float* amax );
+lapack_int LAPACKE_zheequb( int matrix_order, char uplo, lapack_int n,
+                            const lapack_complex_double* a, lapack_int lda,
+                            double* s, double* scond, double* amax );
+
+lapack_int LAPACKE_cheev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_complex_float* a, lapack_int lda, float* w );
+lapack_int LAPACKE_zheev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_complex_double* a, lapack_int lda, double* w );
+
+lapack_int LAPACKE_cheevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda, float* w );
+lapack_int LAPACKE_zheevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           double* w );
+
+lapack_int LAPACKE_cheevr( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_complex_float* a,
+                           lapack_int lda, float vl, float vu, lapack_int il,
+                           lapack_int iu, float abstol, lapack_int* m, float* w,
+                           lapack_complex_float* z, lapack_int ldz,
+                           lapack_int* isuppz );
+lapack_int LAPACKE_zheevr( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_complex_double* a,
+                           lapack_int lda, double vl, double vu, lapack_int il,
+                           lapack_int iu, double abstol, lapack_int* m,
+                           double* w, lapack_complex_double* z, lapack_int ldz,
+                           lapack_int* isuppz );
+
+lapack_int LAPACKE_cheevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_complex_float* a,
+                           lapack_int lda, float vl, float vu, lapack_int il,
+                           lapack_int iu, float abstol, lapack_int* m, float* w,
+                           lapack_complex_float* z, lapack_int ldz,
+                           lapack_int* ifail );
+lapack_int LAPACKE_zheevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_complex_double* a,
+                           lapack_int lda, double vl, double vu, lapack_int il,
+                           lapack_int iu, double abstol, lapack_int* m,
+                           double* w, lapack_complex_double* z, lapack_int ldz,
+                           lapack_int* ifail );
+
+lapack_int LAPACKE_chegst( int matrix_order, lapack_int itype, char uplo,
+                           lapack_int n, lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_zhegst( int matrix_order, lapack_int itype, char uplo,
+                           lapack_int n, lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* b,
+                           lapack_int ldb );
+
+lapack_int LAPACKE_chegv( int matrix_order, lapack_int itype, char jobz,
+                          char uplo, lapack_int n, lapack_complex_float* a,
+                          lapack_int lda, lapack_complex_float* b,
+                          lapack_int ldb, float* w );
+lapack_int LAPACKE_zhegv( int matrix_order, lapack_int itype, char jobz,
+                          char uplo, lapack_int n, lapack_complex_double* a,
+                          lapack_int lda, lapack_complex_double* b,
+                          lapack_int ldb, double* w );
+
+lapack_int LAPACKE_chegvd( int matrix_order, lapack_int itype, char jobz,
+                           char uplo, lapack_int n, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* b,
+                           lapack_int ldb, float* w );
+lapack_int LAPACKE_zhegvd( int matrix_order, lapack_int itype, char jobz,
+                           char uplo, lapack_int n, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb, double* w );
+
+lapack_int LAPACKE_chegvx( int matrix_order, lapack_int itype, char jobz,
+                           char range, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* b, lapack_int ldb, float vl,
+                           float vu, lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, lapack_complex_float* z,
+                           lapack_int ldz, lapack_int* ifail );
+lapack_int LAPACKE_zhegvx( int matrix_order, lapack_int itype, char jobz,
+                           char range, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w,
+                           lapack_complex_double* z, lapack_int ldz,
+                           lapack_int* ifail );
+
+lapack_int LAPACKE_cherfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* af,
+                           lapack_int ldaf, const lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zherfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* af,
+                           lapack_int ldaf, const lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_cherfsx( int matrix_order, char uplo, char equed,
+                            lapack_int n, lapack_int nrhs,
+                            const lapack_complex_float* a, lapack_int lda,
+                            const lapack_complex_float* af, lapack_int ldaf,
+                            const lapack_int* ipiv, const float* s,
+                            const lapack_complex_float* b, lapack_int ldb,
+                            lapack_complex_float* x, lapack_int ldx,
+                            float* rcond, float* berr, lapack_int n_err_bnds,
+                            float* err_bnds_norm, float* err_bnds_comp,
+                            lapack_int nparams, float* params );
+lapack_int LAPACKE_zherfsx( int matrix_order, char uplo, char equed,
+                            lapack_int n, lapack_int nrhs,
+                            const lapack_complex_double* a, lapack_int lda,
+                            const lapack_complex_double* af, lapack_int ldaf,
+                            const lapack_int* ipiv, const double* s,
+                            const lapack_complex_double* b, lapack_int ldb,
+                            lapack_complex_double* x, lapack_int ldx,
+                            double* rcond, double* berr, lapack_int n_err_bnds,
+                            double* err_bnds_norm, double* err_bnds_comp,
+                            lapack_int nparams, double* params );
+
+lapack_int LAPACKE_chesv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_float* a,
+                          lapack_int lda, lapack_int* ipiv,
+                          lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zhesv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_double* a,
+                          lapack_int lda, lapack_int* ipiv,
+                          lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_chesvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* af,
+                           lapack_int ldaf, lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr );
+lapack_int LAPACKE_zhesvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* af,
+                           lapack_int ldaf, lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr );
+
+lapack_int LAPACKE_chesvxx( int matrix_order, char fact, char uplo,
+                            lapack_int n, lapack_int nrhs,
+                            lapack_complex_float* a, lapack_int lda,
+                            lapack_complex_float* af, lapack_int ldaf,
+                            lapack_int* ipiv, char* equed, float* s,
+                            lapack_complex_float* b, lapack_int ldb,
+                            lapack_complex_float* x, lapack_int ldx,
+                            float* rcond, float* rpvgrw, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_zhesvxx( int matrix_order, char fact, char uplo,
+                            lapack_int n, lapack_int nrhs,
+                            lapack_complex_double* a, lapack_int lda,
+                            lapack_complex_double* af, lapack_int ldaf,
+                            lapack_int* ipiv, char* equed, double* s,
+                            lapack_complex_double* b, lapack_int ldb,
+                            lapack_complex_double* x, lapack_int ldx,
+                            double* rcond, double* rpvgrw, double* berr,
+                            lapack_int n_err_bnds, double* err_bnds_norm,
+                            double* err_bnds_comp, lapack_int nparams,
+                            double* params );
+
+lapack_int LAPACKE_chetrd( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda, float* d,
+                           float* e, lapack_complex_float* tau );
+lapack_int LAPACKE_zhetrd( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda, double* d,
+                           double* e, lapack_complex_double* tau );
+
+lapack_int LAPACKE_chetrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int* ipiv );
+lapack_int LAPACKE_zhetrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* ipiv );
+
+lapack_int LAPACKE_chetri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           const lapack_int* ipiv );
+lapack_int LAPACKE_zhetri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           const lapack_int* ipiv );
+
+lapack_int LAPACKE_chetrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* a,
+                           lapack_int lda, const lapack_int* ipiv,
+                           lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zhetrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* a,
+                           lapack_int lda, const lapack_int* ipiv,
+                           lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_chfrk( int matrix_order, char transr, char uplo, char trans,
+                          lapack_int n, lapack_int k, float alpha,
+                          const lapack_complex_float* a, lapack_int lda,
+                          float beta, lapack_complex_float* c );
+lapack_int LAPACKE_zhfrk( int matrix_order, char transr, char uplo, char trans,
+                          lapack_int n, lapack_int k, double alpha,
+                          const lapack_complex_double* a, lapack_int lda,
+                          double beta, lapack_complex_double* c );
+
+lapack_int LAPACKE_shgeqz( int matrix_order, char job, char compq, char compz,
+                           lapack_int n, lapack_int ilo, lapack_int ihi,
+                           float* h, lapack_int ldh, float* t, lapack_int ldt,
+                           float* alphar, float* alphai, float* beta, float* q,
+                           lapack_int ldq, float* z, lapack_int ldz );
+lapack_int LAPACKE_dhgeqz( int matrix_order, char job, char compq, char compz,
+                           lapack_int n, lapack_int ilo, lapack_int ihi,
+                           double* h, lapack_int ldh, double* t, lapack_int ldt,
+                           double* alphar, double* alphai, double* beta,
+                           double* q, lapack_int ldq, double* z,
+                           lapack_int ldz );
+lapack_int LAPACKE_chgeqz( int matrix_order, char job, char compq, char compz,
+                           lapack_int n, lapack_int ilo, lapack_int ihi,
+                           lapack_complex_float* h, lapack_int ldh,
+                           lapack_complex_float* t, lapack_int ldt,
+                           lapack_complex_float* alpha,
+                           lapack_complex_float* beta, lapack_complex_float* q,
+                           lapack_int ldq, lapack_complex_float* z,
+                           lapack_int ldz );
+lapack_int LAPACKE_zhgeqz( int matrix_order, char job, char compq, char compz,
+                           lapack_int n, lapack_int ilo, lapack_int ihi,
+                           lapack_complex_double* h, lapack_int ldh,
+                           lapack_complex_double* t, lapack_int ldt,
+                           lapack_complex_double* alpha,
+                           lapack_complex_double* beta,
+                           lapack_complex_double* q, lapack_int ldq,
+                           lapack_complex_double* z, lapack_int ldz );
+
+lapack_int LAPACKE_chpcon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_float* ap,
+                           const lapack_int* ipiv, float anorm, float* rcond );
+lapack_int LAPACKE_zhpcon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_double* ap,
+                           const lapack_int* ipiv, double anorm,
+                           double* rcond );
+
+lapack_int LAPACKE_chpev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_complex_float* ap, float* w,
+                          lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zhpev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_complex_double* ap, double* w,
+                          lapack_complex_double* z, lapack_int ldz );
+
+lapack_int LAPACKE_chpevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_complex_float* ap, float* w,
+                           lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zhpevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_complex_double* ap, double* w,
+                           lapack_complex_double* z, lapack_int ldz );
+
+lapack_int LAPACKE_chpevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_complex_float* ap, float vl,
+                           float vu, lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, lapack_complex_float* z,
+                           lapack_int ldz, lapack_int* ifail );
+lapack_int LAPACKE_zhpevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_complex_double* ap, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w,
+                           lapack_complex_double* z, lapack_int ldz,
+                           lapack_int* ifail );
+
+lapack_int LAPACKE_chpgst( int matrix_order, lapack_int itype, char uplo,
+                           lapack_int n, lapack_complex_float* ap,
+                           const lapack_complex_float* bp );
+lapack_int LAPACKE_zhpgst( int matrix_order, lapack_int itype, char uplo,
+                           lapack_int n, lapack_complex_double* ap,
+                           const lapack_complex_double* bp );
+
+lapack_int LAPACKE_chpgv( int matrix_order, lapack_int itype, char jobz,
+                          char uplo, lapack_int n, lapack_complex_float* ap,
+                          lapack_complex_float* bp, float* w,
+                          lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zhpgv( int matrix_order, lapack_int itype, char jobz,
+                          char uplo, lapack_int n, lapack_complex_double* ap,
+                          lapack_complex_double* bp, double* w,
+                          lapack_complex_double* z, lapack_int ldz );
+
+lapack_int LAPACKE_chpgvd( int matrix_order, lapack_int itype, char jobz,
+                           char uplo, lapack_int n, lapack_complex_float* ap,
+                           lapack_complex_float* bp, float* w,
+                           lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zhpgvd( int matrix_order, lapack_int itype, char jobz,
+                           char uplo, lapack_int n, lapack_complex_double* ap,
+                           lapack_complex_double* bp, double* w,
+                           lapack_complex_double* z, lapack_int ldz );
+
+lapack_int LAPACKE_chpgvx( int matrix_order, lapack_int itype, char jobz,
+                           char range, char uplo, lapack_int n,
+                           lapack_complex_float* ap, lapack_complex_float* bp,
+                           float vl, float vu, lapack_int il, lapack_int iu,
+                           float abstol, lapack_int* m, float* w,
+                           lapack_complex_float* z, lapack_int ldz,
+                           lapack_int* ifail );
+lapack_int LAPACKE_zhpgvx( int matrix_order, lapack_int itype, char jobz,
+                           char range, char uplo, lapack_int n,
+                           lapack_complex_double* ap, lapack_complex_double* bp,
+                           double vl, double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w,
+                           lapack_complex_double* z, lapack_int ldz,
+                           lapack_int* ifail );
+
+lapack_int LAPACKE_chprfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* ap,
+                           const lapack_complex_float* afp,
+                           const lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zhprfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* ap,
+                           const lapack_complex_double* afp,
+                           const lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_chpsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_float* ap,
+                          lapack_int* ipiv, lapack_complex_float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_zhpsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_double* ap,
+                          lapack_int* ipiv, lapack_complex_double* b,
+                          lapack_int ldb );
+
+lapack_int LAPACKE_chpsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* ap,
+                           lapack_complex_float* afp, lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr );
+lapack_int LAPACKE_zhpsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* ap,
+                           lapack_complex_double* afp, lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr );
+
+lapack_int LAPACKE_chptrd( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* ap, float* d, float* e,
+                           lapack_complex_float* tau );
+lapack_int LAPACKE_zhptrd( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* ap, double* d, double* e,
+                           lapack_complex_double* tau );
+
+lapack_int LAPACKE_chptrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* ap, lapack_int* ipiv );
+lapack_int LAPACKE_zhptrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* ap, lapack_int* ipiv );
+
+lapack_int LAPACKE_chptri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* ap, const lapack_int* ipiv );
+lapack_int LAPACKE_zhptri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* ap, const lapack_int* ipiv );
+
+lapack_int LAPACKE_chptrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* ap,
+                           const lapack_int* ipiv, lapack_complex_float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_zhptrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* ap,
+                           const lapack_int* ipiv, lapack_complex_double* b,
+                           lapack_int ldb );
+
+lapack_int LAPACKE_shsein( int matrix_order, char job, char eigsrc, char initv,
+                           lapack_logical* select, lapack_int n, const float* h,
+                           lapack_int ldh, float* wr, const float* wi,
+                           float* vl, lapack_int ldvl, float* vr,
+                           lapack_int ldvr, lapack_int mm, lapack_int* m,
+                           lapack_int* ifaill, lapack_int* ifailr );
+lapack_int LAPACKE_dhsein( int matrix_order, char job, char eigsrc, char initv,
+                           lapack_logical* select, lapack_int n,
+                           const double* h, lapack_int ldh, double* wr,
+                           const double* wi, double* vl, lapack_int ldvl,
+                           double* vr, lapack_int ldvr, lapack_int mm,
+                           lapack_int* m, lapack_int* ifaill,
+                           lapack_int* ifailr );
+lapack_int LAPACKE_chsein( int matrix_order, char job, char eigsrc, char initv,
+                           const lapack_logical* select, lapack_int n,
+                           const lapack_complex_float* h, lapack_int ldh,
+                           lapack_complex_float* w, lapack_complex_float* vl,
+                           lapack_int ldvl, lapack_complex_float* vr,
+                           lapack_int ldvr, lapack_int mm, lapack_int* m,
+                           lapack_int* ifaill, lapack_int* ifailr );
+lapack_int LAPACKE_zhsein( int matrix_order, char job, char eigsrc, char initv,
+                           const lapack_logical* select, lapack_int n,
+                           const lapack_complex_double* h, lapack_int ldh,
+                           lapack_complex_double* w, lapack_complex_double* vl,
+                           lapack_int ldvl, lapack_complex_double* vr,
+                           lapack_int ldvr, lapack_int mm, lapack_int* m,
+                           lapack_int* ifaill, lapack_int* ifailr );
+
+lapack_int LAPACKE_shseqr( int matrix_order, char job, char compz, lapack_int n,
+                           lapack_int ilo, lapack_int ihi, float* h,
+                           lapack_int ldh, float* wr, float* wi, float* z,
+                           lapack_int ldz );
+lapack_int LAPACKE_dhseqr( int matrix_order, char job, char compz, lapack_int n,
+                           lapack_int ilo, lapack_int ihi, double* h,
+                           lapack_int ldh, double* wr, double* wi, double* z,
+                           lapack_int ldz );
+lapack_int LAPACKE_chseqr( int matrix_order, char job, char compz, lapack_int n,
+                           lapack_int ilo, lapack_int ihi,
+                           lapack_complex_float* h, lapack_int ldh,
+                           lapack_complex_float* w, lapack_complex_float* z,
+                           lapack_int ldz );
+lapack_int LAPACKE_zhseqr( int matrix_order, char job, char compz, lapack_int n,
+                           lapack_int ilo, lapack_int ihi,
+                           lapack_complex_double* h, lapack_int ldh,
+                           lapack_complex_double* w, lapack_complex_double* z,
+                           lapack_int ldz );
+
+lapack_int LAPACKE_clacgv( lapack_int n, lapack_complex_float* x,
+                           lapack_int incx );
+lapack_int LAPACKE_zlacgv( lapack_int n, lapack_complex_double* x,
+                           lapack_int incx );
+
+lapack_int LAPACKE_slacpy( int matrix_order, char uplo, lapack_int m,
+                           lapack_int n, const float* a, lapack_int lda, float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_dlacpy( int matrix_order, char uplo, lapack_int m,
+                           lapack_int n, const double* a, lapack_int lda, double* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_clacpy( int matrix_order, char uplo, lapack_int m,
+                           lapack_int n, const lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_zlacpy( int matrix_order, char uplo, lapack_int m,
+                           lapack_int n, const lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb );
+
+lapack_int LAPACKE_zlag2c( int matrix_order, lapack_int m, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_float* sa, lapack_int ldsa );
+
+lapack_int LAPACKE_slag2d( int matrix_order, lapack_int m, lapack_int n,
+                           const float* sa, lapack_int ldsa, double* a,
+                           lapack_int lda );
+
+lapack_int LAPACKE_dlag2s( int matrix_order, lapack_int m, lapack_int n,
+                           const double* a, lapack_int lda, float* sa,
+                           lapack_int ldsa );
+
+lapack_int LAPACKE_clag2z( int matrix_order, lapack_int m, lapack_int n,
+                           const lapack_complex_float* sa, lapack_int ldsa,
+                           lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_slagge( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku, const float* d,
+                           float* a, lapack_int lda, lapack_int* iseed );
+lapack_int LAPACKE_dlagge( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku, const double* d,
+                           double* a, lapack_int lda, lapack_int* iseed );
+lapack_int LAPACKE_clagge( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku, const float* d,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int* iseed );
+lapack_int LAPACKE_zlagge( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku, const double* d,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* iseed );
+
+float LAPACKE_slamch( char cmach );
+double LAPACKE_dlamch( char cmach );
+
+float LAPACKE_slange( int matrix_order, char norm, lapack_int m,
+                           lapack_int n, const float* a, lapack_int lda );
+double LAPACKE_dlange( int matrix_order, char norm, lapack_int m,
+                           lapack_int n, const double* a, lapack_int lda );
+float LAPACKE_clange( int matrix_order, char norm, lapack_int m,
+                           lapack_int n, const lapack_complex_float* a,
+                           lapack_int lda );
+double LAPACKE_zlange( int matrix_order, char norm, lapack_int m,
+                           lapack_int n, const lapack_complex_double* a,
+                           lapack_int lda );
+
+float LAPACKE_clanhe( int matrix_order, char norm, char uplo, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda );
+double LAPACKE_zlanhe( int matrix_order, char norm, char uplo, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda );
+
+float LAPACKE_slansy( int matrix_order, char norm, char uplo, lapack_int n,
+                           const float* a, lapack_int lda );
+double LAPACKE_dlansy( int matrix_order, char norm, char uplo, lapack_int n,
+                           const double* a, lapack_int lda );
+float LAPACKE_clansy( int matrix_order, char norm, char uplo, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda );
+double LAPACKE_zlansy( int matrix_order, char norm, char uplo, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda );
+
+float LAPACKE_slantr( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int m, lapack_int n, const float* a,
+                           lapack_int lda );
+double LAPACKE_dlantr( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int m, lapack_int n, const double* a,
+                           lapack_int lda );
+float LAPACKE_clantr( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int m, lapack_int n, const lapack_complex_float* a,
+                           lapack_int lda );
+double LAPACKE_zlantr( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int m, lapack_int n, const lapack_complex_double* a,
+                           lapack_int lda );
+
+
+lapack_int LAPACKE_slarfb( int matrix_order, char side, char trans, char direct,
+                           char storev, lapack_int m, lapack_int n,
+                           lapack_int k, const float* v, lapack_int ldv,
+                           const float* t, lapack_int ldt, float* c,
+                           lapack_int ldc );
+lapack_int LAPACKE_dlarfb( int matrix_order, char side, char trans, char direct,
+                           char storev, lapack_int m, lapack_int n,
+                           lapack_int k, const double* v, lapack_int ldv,
+                           const double* t, lapack_int ldt, double* c,
+                           lapack_int ldc );
+lapack_int LAPACKE_clarfb( int matrix_order, char side, char trans, char direct,
+                           char storev, lapack_int m, lapack_int n,
+                           lapack_int k, const lapack_complex_float* v,
+                           lapack_int ldv, const lapack_complex_float* t,
+                           lapack_int ldt, lapack_complex_float* c,
+                           lapack_int ldc );
+lapack_int LAPACKE_zlarfb( int matrix_order, char side, char trans, char direct,
+                           char storev, lapack_int m, lapack_int n,
+                           lapack_int k, const lapack_complex_double* v,
+                           lapack_int ldv, const lapack_complex_double* t,
+                           lapack_int ldt, lapack_complex_double* c,
+                           lapack_int ldc );
+
+lapack_int LAPACKE_slarfg( lapack_int n, float* alpha, float* x,
+                           lapack_int incx, float* tau );
+lapack_int LAPACKE_dlarfg( lapack_int n, double* alpha, double* x,
+                           lapack_int incx, double* tau );
+lapack_int LAPACKE_clarfg( lapack_int n, lapack_complex_float* alpha,
+                           lapack_complex_float* x, lapack_int incx,
+                           lapack_complex_float* tau );
+lapack_int LAPACKE_zlarfg( lapack_int n, lapack_complex_double* alpha,
+                           lapack_complex_double* x, lapack_int incx,
+                           lapack_complex_double* tau );
+
+lapack_int LAPACKE_slarft( int matrix_order, char direct, char storev,
+                           lapack_int n, lapack_int k, const float* v,
+                           lapack_int ldv, const float* tau, float* t,
+                           lapack_int ldt );
+lapack_int LAPACKE_dlarft( int matrix_order, char direct, char storev,
+                           lapack_int n, lapack_int k, const double* v,
+                           lapack_int ldv, const double* tau, double* t,
+                           lapack_int ldt );
+lapack_int LAPACKE_clarft( int matrix_order, char direct, char storev,
+                           lapack_int n, lapack_int k,
+                           const lapack_complex_float* v, lapack_int ldv,
+                           const lapack_complex_float* tau,
+                           lapack_complex_float* t, lapack_int ldt );
+lapack_int LAPACKE_zlarft( int matrix_order, char direct, char storev,
+                           lapack_int n, lapack_int k,
+                           const lapack_complex_double* v, lapack_int ldv,
+                           const lapack_complex_double* tau,
+                           lapack_complex_double* t, lapack_int ldt );
+
+lapack_int LAPACKE_slarfx( int matrix_order, char side, lapack_int m,
+                           lapack_int n, const float* v, float tau, float* c,
+                           lapack_int ldc, float* work );
+lapack_int LAPACKE_dlarfx( int matrix_order, char side, lapack_int m,
+                           lapack_int n, const double* v, double tau, double* c,
+                           lapack_int ldc, double* work );
+lapack_int LAPACKE_clarfx( int matrix_order, char side, lapack_int m,
+                           lapack_int n, const lapack_complex_float* v,
+                           lapack_complex_float tau, lapack_complex_float* c,
+                           lapack_int ldc, lapack_complex_float* work );
+lapack_int LAPACKE_zlarfx( int matrix_order, char side, lapack_int m,
+                           lapack_int n, const lapack_complex_double* v,
+                           lapack_complex_double tau, lapack_complex_double* c,
+                           lapack_int ldc, lapack_complex_double* work );
+
+lapack_int LAPACKE_slarnv( lapack_int idist, lapack_int* iseed, lapack_int n,
+                           float* x );
+lapack_int LAPACKE_dlarnv( lapack_int idist, lapack_int* iseed, lapack_int n,
+                           double* x );
+lapack_int LAPACKE_clarnv( lapack_int idist, lapack_int* iseed, lapack_int n,
+                           lapack_complex_float* x );
+lapack_int LAPACKE_zlarnv( lapack_int idist, lapack_int* iseed, lapack_int n,
+                           lapack_complex_double* x );
+
+lapack_int LAPACKE_slaset( int matrix_order, char uplo, lapack_int m,
+                           lapack_int n, float alpha, float beta, float* a,
+                           lapack_int lda );
+lapack_int LAPACKE_dlaset( int matrix_order, char uplo, lapack_int m,
+                           lapack_int n, double alpha, double beta, double* a,
+                           lapack_int lda );
+lapack_int LAPACKE_claset( int matrix_order, char uplo, lapack_int m,
+                           lapack_int n, lapack_complex_float alpha,
+                           lapack_complex_float beta, lapack_complex_float* a,
+                           lapack_int lda );
+lapack_int LAPACKE_zlaset( int matrix_order, char uplo, lapack_int m,
+                           lapack_int n, lapack_complex_double alpha,
+                           lapack_complex_double beta, lapack_complex_double* a,
+                           lapack_int lda );
+
+lapack_int LAPACKE_slasrt( char id, lapack_int n, float* d );
+lapack_int LAPACKE_dlasrt( char id, lapack_int n, double* d );
+
+lapack_int LAPACKE_slaswp( int matrix_order, lapack_int n, float* a,
+                           lapack_int lda, lapack_int k1, lapack_int k2,
+                           const lapack_int* ipiv, lapack_int incx );
+lapack_int LAPACKE_dlaswp( int matrix_order, lapack_int n, double* a,
+                           lapack_int lda, lapack_int k1, lapack_int k2,
+                           const lapack_int* ipiv, lapack_int incx );
+lapack_int LAPACKE_claswp( int matrix_order, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int k1, lapack_int k2, const lapack_int* ipiv,
+                           lapack_int incx );
+lapack_int LAPACKE_zlaswp( int matrix_order, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int k1, lapack_int k2, const lapack_int* ipiv,
+                           lapack_int incx );
+
+lapack_int LAPACKE_slatms( int matrix_order, lapack_int m, lapack_int n,
+                           char dist, lapack_int* iseed, char sym, float* d,
+                           lapack_int mode, float cond, float dmax,
+                           lapack_int kl, lapack_int ku, char pack, float* a,
+                           lapack_int lda );
+lapack_int LAPACKE_dlatms( int matrix_order, lapack_int m, lapack_int n,
+                           char dist, lapack_int* iseed, char sym, double* d,
+                           lapack_int mode, double cond, double dmax,
+                           lapack_int kl, lapack_int ku, char pack, double* a,
+                           lapack_int lda );
+lapack_int LAPACKE_clatms( int matrix_order, lapack_int m, lapack_int n,
+                           char dist, lapack_int* iseed, char sym, float* d,
+                           lapack_int mode, float cond, float dmax,
+                           lapack_int kl, lapack_int ku, char pack,
+                           lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_zlatms( int matrix_order, lapack_int m, lapack_int n,
+                           char dist, lapack_int* iseed, char sym, double* d,
+                           lapack_int mode, double cond, double dmax,
+                           lapack_int kl, lapack_int ku, char pack,
+                           lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_slauum( int matrix_order, char uplo, lapack_int n, float* a,
+                           lapack_int lda );
+lapack_int LAPACKE_dlauum( int matrix_order, char uplo, lapack_int n, double* a,
+                           lapack_int lda );
+lapack_int LAPACKE_clauum( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_zlauum( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_sopgtr( int matrix_order, char uplo, lapack_int n,
+                           const float* ap, const float* tau, float* q,
+                           lapack_int ldq );
+lapack_int LAPACKE_dopgtr( int matrix_order, char uplo, lapack_int n,
+                           const double* ap, const double* tau, double* q,
+                           lapack_int ldq );
+
+lapack_int LAPACKE_sopmtr( int matrix_order, char side, char uplo, char trans,
+                           lapack_int m, lapack_int n, const float* ap,
+                           const float* tau, float* c, lapack_int ldc );
+lapack_int LAPACKE_dopmtr( int matrix_order, char side, char uplo, char trans,
+                           lapack_int m, lapack_int n, const double* ap,
+                           const double* tau, double* c, lapack_int ldc );
+
+lapack_int LAPACKE_sorgbr( int matrix_order, char vect, lapack_int m,
+                           lapack_int n, lapack_int k, float* a, lapack_int lda,
+                           const float* tau );
+lapack_int LAPACKE_dorgbr( int matrix_order, char vect, lapack_int m,
+                           lapack_int n, lapack_int k, double* a,
+                           lapack_int lda, const double* tau );
+
+lapack_int LAPACKE_sorghr( int matrix_order, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, float* a, lapack_int lda,
+                           const float* tau );
+lapack_int LAPACKE_dorghr( int matrix_order, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, double* a, lapack_int lda,
+                           const double* tau );
+
+lapack_int LAPACKE_sorglq( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, float* a, lapack_int lda,
+                           const float* tau );
+lapack_int LAPACKE_dorglq( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, double* a, lapack_int lda,
+                           const double* tau );
+
+lapack_int LAPACKE_sorgql( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, float* a, lapack_int lda,
+                           const float* tau );
+lapack_int LAPACKE_dorgql( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, double* a, lapack_int lda,
+                           const double* tau );
+
+lapack_int LAPACKE_sorgqr( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, float* a, lapack_int lda,
+                           const float* tau );
+lapack_int LAPACKE_dorgqr( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, double* a, lapack_int lda,
+                           const double* tau );
+
+lapack_int LAPACKE_sorgrq( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, float* a, lapack_int lda,
+                           const float* tau );
+lapack_int LAPACKE_dorgrq( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, double* a, lapack_int lda,
+                           const double* tau );
+
+lapack_int LAPACKE_sorgtr( int matrix_order, char uplo, lapack_int n, float* a,
+                           lapack_int lda, const float* tau );
+lapack_int LAPACKE_dorgtr( int matrix_order, char uplo, lapack_int n, double* a,
+                           lapack_int lda, const double* tau );
+
+lapack_int LAPACKE_sormbr( int matrix_order, char vect, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const float* a, lapack_int lda, const float* tau,
+                           float* c, lapack_int ldc );
+lapack_int LAPACKE_dormbr( int matrix_order, char vect, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const double* a, lapack_int lda, const double* tau,
+                           double* c, lapack_int ldc );
+
+lapack_int LAPACKE_sormhr( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, const float* a, lapack_int lda,
+                           const float* tau, float* c, lapack_int ldc );
+lapack_int LAPACKE_dormhr( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, const double* a, lapack_int lda,
+                           const double* tau, double* c, lapack_int ldc );
+
+lapack_int LAPACKE_sormlq( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const float* a, lapack_int lda, const float* tau,
+                           float* c, lapack_int ldc );
+lapack_int LAPACKE_dormlq( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const double* a, lapack_int lda, const double* tau,
+                           double* c, lapack_int ldc );
+
+lapack_int LAPACKE_sormql( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const float* a, lapack_int lda, const float* tau,
+                           float* c, lapack_int ldc );
+lapack_int LAPACKE_dormql( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const double* a, lapack_int lda, const double* tau,
+                           double* c, lapack_int ldc );
+
+lapack_int LAPACKE_sormqr( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const float* a, lapack_int lda, const float* tau,
+                           float* c, lapack_int ldc );
+lapack_int LAPACKE_dormqr( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const double* a, lapack_int lda, const double* tau,
+                           double* c, lapack_int ldc );
+
+lapack_int LAPACKE_sormrq( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const float* a, lapack_int lda, const float* tau,
+                           float* c, lapack_int ldc );
+lapack_int LAPACKE_dormrq( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const double* a, lapack_int lda, const double* tau,
+                           double* c, lapack_int ldc );
+
+lapack_int LAPACKE_sormrz( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           lapack_int l, const float* a, lapack_int lda,
+                           const float* tau, float* c, lapack_int ldc );
+lapack_int LAPACKE_dormrz( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           lapack_int l, const double* a, lapack_int lda,
+                           const double* tau, double* c, lapack_int ldc );
+
+lapack_int LAPACKE_sormtr( int matrix_order, char side, char uplo, char trans,
+                           lapack_int m, lapack_int n, const float* a,
+                           lapack_int lda, const float* tau, float* c,
+                           lapack_int ldc );
+lapack_int LAPACKE_dormtr( int matrix_order, char side, char uplo, char trans,
+                           lapack_int m, lapack_int n, const double* a,
+                           lapack_int lda, const double* tau, double* c,
+                           lapack_int ldc );
+
+lapack_int LAPACKE_spbcon( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, const float* ab, lapack_int ldab,
+                           float anorm, float* rcond );
+lapack_int LAPACKE_dpbcon( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, const double* ab, lapack_int ldab,
+                           double anorm, double* rcond );
+lapack_int LAPACKE_cpbcon( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, const lapack_complex_float* ab,
+                           lapack_int ldab, float anorm, float* rcond );
+lapack_int LAPACKE_zpbcon( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, const lapack_complex_double* ab,
+                           lapack_int ldab, double anorm, double* rcond );
+
+lapack_int LAPACKE_spbequ( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, const float* ab, lapack_int ldab,
+                           float* s, float* scond, float* amax );
+lapack_int LAPACKE_dpbequ( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, const double* ab, lapack_int ldab,
+                           double* s, double* scond, double* amax );
+lapack_int LAPACKE_cpbequ( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, const lapack_complex_float* ab,
+                           lapack_int ldab, float* s, float* scond,
+                           float* amax );
+lapack_int LAPACKE_zpbequ( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, const lapack_complex_double* ab,
+                           lapack_int ldab, double* s, double* scond,
+                           double* amax );
+
+lapack_int LAPACKE_spbrfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs, const float* ab,
+                           lapack_int ldab, const float* afb, lapack_int ldafb,
+                           const float* b, lapack_int ldb, float* x,
+                           lapack_int ldx, float* ferr, float* berr );
+lapack_int LAPACKE_dpbrfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs, const double* ab,
+                           lapack_int ldab, const double* afb, lapack_int ldafb,
+                           const double* b, lapack_int ldb, double* x,
+                           lapack_int ldx, double* ferr, double* berr );
+lapack_int LAPACKE_cpbrfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs,
+                           const lapack_complex_float* ab, lapack_int ldab,
+                           const lapack_complex_float* afb, lapack_int ldafb,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zpbrfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs,
+                           const lapack_complex_double* ab, lapack_int ldab,
+                           const lapack_complex_double* afb, lapack_int ldafb,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_spbstf( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kb, float* bb, lapack_int ldbb );
+lapack_int LAPACKE_dpbstf( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kb, double* bb, lapack_int ldbb );
+lapack_int LAPACKE_cpbstf( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kb, lapack_complex_float* bb,
+                           lapack_int ldbb );
+lapack_int LAPACKE_zpbstf( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kb, lapack_complex_double* bb,
+                           lapack_int ldbb );
+
+lapack_int LAPACKE_spbsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int kd, lapack_int nrhs, float* ab,
+                          lapack_int ldab, float* b, lapack_int ldb );
+lapack_int LAPACKE_dpbsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int kd, lapack_int nrhs, double* ab,
+                          lapack_int ldab, double* b, lapack_int ldb );
+lapack_int LAPACKE_cpbsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int kd, lapack_int nrhs,
+                          lapack_complex_float* ab, lapack_int ldab,
+                          lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zpbsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int kd, lapack_int nrhs,
+                          lapack_complex_double* ab, lapack_int ldab,
+                          lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_spbsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs, float* ab,
+                           lapack_int ldab, float* afb, lapack_int ldafb,
+                           char* equed, float* s, float* b, lapack_int ldb,
+                           float* x, lapack_int ldx, float* rcond, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_dpbsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs, double* ab,
+                           lapack_int ldab, double* afb, lapack_int ldafb,
+                           char* equed, double* s, double* b, lapack_int ldb,
+                           double* x, lapack_int ldx, double* rcond,
+                           double* ferr, double* berr );
+lapack_int LAPACKE_cpbsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs,
+                           lapack_complex_float* ab, lapack_int ldab,
+                           lapack_complex_float* afb, lapack_int ldafb,
+                           char* equed, float* s, lapack_complex_float* b,
+                           lapack_int ldb, lapack_complex_float* x,
+                           lapack_int ldx, float* rcond, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zpbsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs,
+                           lapack_complex_double* ab, lapack_int ldab,
+                           lapack_complex_double* afb, lapack_int ldafb,
+                           char* equed, double* s, lapack_complex_double* b,
+                           lapack_int ldb, lapack_complex_double* x,
+                           lapack_int ldx, double* rcond, double* ferr,
+                           double* berr );
+
+lapack_int LAPACKE_spbtrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, float* ab, lapack_int ldab );
+lapack_int LAPACKE_dpbtrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, double* ab, lapack_int ldab );
+lapack_int LAPACKE_cpbtrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, lapack_complex_float* ab,
+                           lapack_int ldab );
+lapack_int LAPACKE_zpbtrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, lapack_complex_double* ab,
+                           lapack_int ldab );
+
+lapack_int LAPACKE_spbtrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs, const float* ab,
+                           lapack_int ldab, float* b, lapack_int ldb );
+lapack_int LAPACKE_dpbtrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs, const double* ab,
+                           lapack_int ldab, double* b, lapack_int ldb );
+lapack_int LAPACKE_cpbtrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs,
+                           const lapack_complex_float* ab, lapack_int ldab,
+                           lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zpbtrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs,
+                           const lapack_complex_double* ab, lapack_int ldab,
+                           lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_spftrf( int matrix_order, char transr, char uplo,
+                           lapack_int n, float* a );
+lapack_int LAPACKE_dpftrf( int matrix_order, char transr, char uplo,
+                           lapack_int n, double* a );
+lapack_int LAPACKE_cpftrf( int matrix_order, char transr, char uplo,
+                           lapack_int n, lapack_complex_float* a );
+lapack_int LAPACKE_zpftrf( int matrix_order, char transr, char uplo,
+                           lapack_int n, lapack_complex_double* a );
+
+lapack_int LAPACKE_spftri( int matrix_order, char transr, char uplo,
+                           lapack_int n, float* a );
+lapack_int LAPACKE_dpftri( int matrix_order, char transr, char uplo,
+                           lapack_int n, double* a );
+lapack_int LAPACKE_cpftri( int matrix_order, char transr, char uplo,
+                           lapack_int n, lapack_complex_float* a );
+lapack_int LAPACKE_zpftri( int matrix_order, char transr, char uplo,
+                           lapack_int n, lapack_complex_double* a );
+
+lapack_int LAPACKE_spftrs( int matrix_order, char transr, char uplo,
+                           lapack_int n, lapack_int nrhs, const float* a,
+                           float* b, lapack_int ldb );
+lapack_int LAPACKE_dpftrs( int matrix_order, char transr, char uplo,
+                           lapack_int n, lapack_int nrhs, const double* a,
+                           double* b, lapack_int ldb );
+lapack_int LAPACKE_cpftrs( int matrix_order, char transr, char uplo,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_float* a,
+                           lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zpftrs( int matrix_order, char transr, char uplo,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_double* a,
+                           lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_spocon( int matrix_order, char uplo, lapack_int n,
+                           const float* a, lapack_int lda, float anorm,
+                           float* rcond );
+lapack_int LAPACKE_dpocon( int matrix_order, char uplo, lapack_int n,
+                           const double* a, lapack_int lda, double anorm,
+                           double* rcond );
+lapack_int LAPACKE_cpocon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           float anorm, float* rcond );
+lapack_int LAPACKE_zpocon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           double anorm, double* rcond );
+
+lapack_int LAPACKE_spoequ( int matrix_order, lapack_int n, const float* a,
+                           lapack_int lda, float* s, float* scond,
+                           float* amax );
+lapack_int LAPACKE_dpoequ( int matrix_order, lapack_int n, const double* a,
+                           lapack_int lda, double* s, double* scond,
+                           double* amax );
+lapack_int LAPACKE_cpoequ( int matrix_order, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           float* s, float* scond, float* amax );
+lapack_int LAPACKE_zpoequ( int matrix_order, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           double* s, double* scond, double* amax );
+
+lapack_int LAPACKE_spoequb( int matrix_order, lapack_int n, const float* a,
+                            lapack_int lda, float* s, float* scond,
+                            float* amax );
+lapack_int LAPACKE_dpoequb( int matrix_order, lapack_int n, const double* a,
+                            lapack_int lda, double* s, double* scond,
+                            double* amax );
+lapack_int LAPACKE_cpoequb( int matrix_order, lapack_int n,
+                            const lapack_complex_float* a, lapack_int lda,
+                            float* s, float* scond, float* amax );
+lapack_int LAPACKE_zpoequb( int matrix_order, lapack_int n,
+                            const lapack_complex_double* a, lapack_int lda,
+                            double* s, double* scond, double* amax );
+
+lapack_int LAPACKE_sporfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* a, lapack_int lda,
+                           const float* af, lapack_int ldaf, const float* b,
+                           lapack_int ldb, float* x, lapack_int ldx,
+                           float* ferr, float* berr );
+lapack_int LAPACKE_dporfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* a, lapack_int lda,
+                           const double* af, lapack_int ldaf, const double* b,
+                           lapack_int ldb, double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+lapack_int LAPACKE_cporfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* af,
+                           lapack_int ldaf, const lapack_complex_float* b,
+                           lapack_int ldb, lapack_complex_float* x,
+                           lapack_int ldx, float* ferr, float* berr );
+lapack_int LAPACKE_zporfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* af,
+                           lapack_int ldaf, const lapack_complex_double* b,
+                           lapack_int ldb, lapack_complex_double* x,
+                           lapack_int ldx, double* ferr, double* berr );
+
+lapack_int LAPACKE_sporfsx( int matrix_order, char uplo, char equed,
+                            lapack_int n, lapack_int nrhs, const float* a,
+                            lapack_int lda, const float* af, lapack_int ldaf,
+                            const float* s, const float* b, lapack_int ldb,
+                            float* x, lapack_int ldx, float* rcond, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_dporfsx( int matrix_order, char uplo, char equed,
+                            lapack_int n, lapack_int nrhs, const double* a,
+                            lapack_int lda, const double* af, lapack_int ldaf,
+                            const double* s, const double* b, lapack_int ldb,
+                            double* x, lapack_int ldx, double* rcond,
+                            double* berr, lapack_int n_err_bnds,
+                            double* err_bnds_norm, double* err_bnds_comp,
+                            lapack_int nparams, double* params );
+lapack_int LAPACKE_cporfsx( int matrix_order, char uplo, char equed,
+                            lapack_int n, lapack_int nrhs,
+                            const lapack_complex_float* a, lapack_int lda,
+                            const lapack_complex_float* af, lapack_int ldaf,
+                            const float* s, const lapack_complex_float* b,
+                            lapack_int ldb, lapack_complex_float* x,
+                            lapack_int ldx, float* rcond, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_zporfsx( int matrix_order, char uplo, char equed,
+                            lapack_int n, lapack_int nrhs,
+                            const lapack_complex_double* a, lapack_int lda,
+                            const lapack_complex_double* af, lapack_int ldaf,
+                            const double* s, const lapack_complex_double* b,
+                            lapack_int ldb, lapack_complex_double* x,
+                            lapack_int ldx, double* rcond, double* berr,
+                            lapack_int n_err_bnds, double* err_bnds_norm,
+                            double* err_bnds_comp, lapack_int nparams,
+                            double* params );
+
+lapack_int LAPACKE_sposv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, float* a, lapack_int lda, float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_dposv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, double* a, lapack_int lda, double* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_cposv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_float* a,
+                          lapack_int lda, lapack_complex_float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_zposv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_double* a,
+                          lapack_int lda, lapack_complex_double* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_dsposv( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, double* a, lapack_int lda,
+                           double* b, lapack_int ldb, double* x, lapack_int ldx,
+                           lapack_int* iter );
+lapack_int LAPACKE_zcposv( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb, lapack_complex_double* x,
+                           lapack_int ldx, lapack_int* iter );
+
+lapack_int LAPACKE_sposvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, float* a, lapack_int lda, float* af,
+                           lapack_int ldaf, char* equed, float* s, float* b,
+                           lapack_int ldb, float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr );
+lapack_int LAPACKE_dposvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, double* a, lapack_int lda,
+                           double* af, lapack_int ldaf, char* equed, double* s,
+                           double* b, lapack_int ldb, double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr );
+lapack_int LAPACKE_cposvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* af,
+                           lapack_int ldaf, char* equed, float* s,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr );
+lapack_int LAPACKE_zposvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* af,
+                           lapack_int ldaf, char* equed, double* s,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr );
+
+lapack_int LAPACKE_sposvxx( int matrix_order, char fact, char uplo,
+                            lapack_int n, lapack_int nrhs, float* a,
+                            lapack_int lda, float* af, lapack_int ldaf,
+                            char* equed, float* s, float* b, lapack_int ldb,
+                            float* x, lapack_int ldx, float* rcond,
+                            float* rpvgrw, float* berr, lapack_int n_err_bnds,
+                            float* err_bnds_norm, float* err_bnds_comp,
+                            lapack_int nparams, float* params );
+lapack_int LAPACKE_dposvxx( int matrix_order, char fact, char uplo,
+                            lapack_int n, lapack_int nrhs, double* a,
+                            lapack_int lda, double* af, lapack_int ldaf,
+                            char* equed, double* s, double* b, lapack_int ldb,
+                            double* x, lapack_int ldx, double* rcond,
+                            double* rpvgrw, double* berr, lapack_int n_err_bnds,
+                            double* err_bnds_norm, double* err_bnds_comp,
+                            lapack_int nparams, double* params );
+lapack_int LAPACKE_cposvxx( int matrix_order, char fact, char uplo,
+                            lapack_int n, lapack_int nrhs,
+                            lapack_complex_float* a, lapack_int lda,
+                            lapack_complex_float* af, lapack_int ldaf,
+                            char* equed, float* s, lapack_complex_float* b,
+                            lapack_int ldb, lapack_complex_float* x,
+                            lapack_int ldx, float* rcond, float* rpvgrw,
+                            float* berr, lapack_int n_err_bnds,
+                            float* err_bnds_norm, float* err_bnds_comp,
+                            lapack_int nparams, float* params );
+lapack_int LAPACKE_zposvxx( int matrix_order, char fact, char uplo,
+                            lapack_int n, lapack_int nrhs,
+                            lapack_complex_double* a, lapack_int lda,
+                            lapack_complex_double* af, lapack_int ldaf,
+                            char* equed, double* s, lapack_complex_double* b,
+                            lapack_int ldb, lapack_complex_double* x,
+                            lapack_int ldx, double* rcond, double* rpvgrw,
+                            double* berr, lapack_int n_err_bnds,
+                            double* err_bnds_norm, double* err_bnds_comp,
+                            lapack_int nparams, double* params );
+
+lapack_int LAPACKE_spotrf( int matrix_order, char uplo, lapack_int n, float* a,
+                           lapack_int lda );
+lapack_int LAPACKE_dpotrf( int matrix_order, char uplo, lapack_int n, double* a,
+                           lapack_int lda );
+lapack_int LAPACKE_cpotrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_zpotrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_spotri( int matrix_order, char uplo, lapack_int n, float* a,
+                           lapack_int lda );
+lapack_int LAPACKE_dpotri( int matrix_order, char uplo, lapack_int n, double* a,
+                           lapack_int lda );
+lapack_int LAPACKE_cpotri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_zpotri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_spotrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* a, lapack_int lda,
+                           float* b, lapack_int ldb );
+lapack_int LAPACKE_dpotrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* a, lapack_int lda,
+                           double* b, lapack_int ldb );
+lapack_int LAPACKE_cpotrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_zpotrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb );
+
+lapack_int LAPACKE_sppcon( int matrix_order, char uplo, lapack_int n,
+                           const float* ap, float anorm, float* rcond );
+lapack_int LAPACKE_dppcon( int matrix_order, char uplo, lapack_int n,
+                           const double* ap, double anorm, double* rcond );
+lapack_int LAPACKE_cppcon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_float* ap, float anorm,
+                           float* rcond );
+lapack_int LAPACKE_zppcon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_double* ap, double anorm,
+                           double* rcond );
+
+lapack_int LAPACKE_sppequ( int matrix_order, char uplo, lapack_int n,
+                           const float* ap, float* s, float* scond,
+                           float* amax );
+lapack_int LAPACKE_dppequ( int matrix_order, char uplo, lapack_int n,
+                           const double* ap, double* s, double* scond,
+                           double* amax );
+lapack_int LAPACKE_cppequ( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_float* ap, float* s,
+                           float* scond, float* amax );
+lapack_int LAPACKE_zppequ( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_double* ap, double* s,
+                           double* scond, double* amax );
+
+lapack_int LAPACKE_spprfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* ap, const float* afp,
+                           const float* b, lapack_int ldb, float* x,
+                           lapack_int ldx, float* ferr, float* berr );
+lapack_int LAPACKE_dpprfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* ap, const double* afp,
+                           const double* b, lapack_int ldb, double* x,
+                           lapack_int ldx, double* ferr, double* berr );
+lapack_int LAPACKE_cpprfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* ap,
+                           const lapack_complex_float* afp,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zpprfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* ap,
+                           const lapack_complex_double* afp,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_sppsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, float* ap, float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_dppsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, double* ap, double* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_cppsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_float* ap,
+                          lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zppsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_double* ap,
+                          lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_sppsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, float* ap, float* afp, char* equed,
+                           float* s, float* b, lapack_int ldb, float* x,
+                           lapack_int ldx, float* rcond, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_dppsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, double* ap, double* afp,
+                           char* equed, double* s, double* b, lapack_int ldb,
+                           double* x, lapack_int ldx, double* rcond,
+                           double* ferr, double* berr );
+lapack_int LAPACKE_cppsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, lapack_complex_float* ap,
+                           lapack_complex_float* afp, char* equed, float* s,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr );
+lapack_int LAPACKE_zppsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, lapack_complex_double* ap,
+                           lapack_complex_double* afp, char* equed, double* s,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr );
+
+lapack_int LAPACKE_spptrf( int matrix_order, char uplo, lapack_int n,
+                           float* ap );
+lapack_int LAPACKE_dpptrf( int matrix_order, char uplo, lapack_int n,
+                           double* ap );
+lapack_int LAPACKE_cpptrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* ap );
+lapack_int LAPACKE_zpptrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* ap );
+
+lapack_int LAPACKE_spptri( int matrix_order, char uplo, lapack_int n,
+                           float* ap );
+lapack_int LAPACKE_dpptri( int matrix_order, char uplo, lapack_int n,
+                           double* ap );
+lapack_int LAPACKE_cpptri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* ap );
+lapack_int LAPACKE_zpptri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* ap );
+
+lapack_int LAPACKE_spptrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* ap, float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_dpptrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* ap, double* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_cpptrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* ap,
+                           lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zpptrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* ap,
+                           lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_spstrf( int matrix_order, char uplo, lapack_int n, float* a,
+                           lapack_int lda, lapack_int* piv, lapack_int* rank,
+                           float tol );
+lapack_int LAPACKE_dpstrf( int matrix_order, char uplo, lapack_int n, double* a,
+                           lapack_int lda, lapack_int* piv, lapack_int* rank,
+                           double tol );
+lapack_int LAPACKE_cpstrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int* piv, lapack_int* rank, float tol );
+lapack_int LAPACKE_zpstrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* piv, lapack_int* rank, double tol );
+
+lapack_int LAPACKE_sptcon( lapack_int n, const float* d, const float* e,
+                           float anorm, float* rcond );
+lapack_int LAPACKE_dptcon( lapack_int n, const double* d, const double* e,
+                           double anorm, double* rcond );
+lapack_int LAPACKE_cptcon( lapack_int n, const float* d,
+                           const lapack_complex_float* e, float anorm,
+                           float* rcond );
+lapack_int LAPACKE_zptcon( lapack_int n, const double* d,
+                           const lapack_complex_double* e, double anorm,
+                           double* rcond );
+
+lapack_int LAPACKE_spteqr( int matrix_order, char compz, lapack_int n, float* d,
+                           float* e, float* z, lapack_int ldz );
+lapack_int LAPACKE_dpteqr( int matrix_order, char compz, lapack_int n,
+                           double* d, double* e, double* z, lapack_int ldz );
+lapack_int LAPACKE_cpteqr( int matrix_order, char compz, lapack_int n, float* d,
+                           float* e, lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zpteqr( int matrix_order, char compz, lapack_int n,
+                           double* d, double* e, lapack_complex_double* z,
+                           lapack_int ldz );
+
+lapack_int LAPACKE_sptrfs( int matrix_order, lapack_int n, lapack_int nrhs,
+                           const float* d, const float* e, const float* df,
+                           const float* ef, const float* b, lapack_int ldb,
+                           float* x, lapack_int ldx, float* ferr, float* berr );
+lapack_int LAPACKE_dptrfs( int matrix_order, lapack_int n, lapack_int nrhs,
+                           const double* d, const double* e, const double* df,
+                           const double* ef, const double* b, lapack_int ldb,
+                           double* x, lapack_int ldx, double* ferr,
+                           double* berr );
+lapack_int LAPACKE_cptrfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* d,
+                           const lapack_complex_float* e, const float* df,
+                           const lapack_complex_float* ef,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zptrfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* d,
+                           const lapack_complex_double* e, const double* df,
+                           const lapack_complex_double* ef,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_sptsv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          float* d, float* e, float* b, lapack_int ldb );
+lapack_int LAPACKE_dptsv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          double* d, double* e, double* b, lapack_int ldb );
+lapack_int LAPACKE_cptsv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          float* d, lapack_complex_float* e,
+                          lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zptsv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          double* d, lapack_complex_double* e,
+                          lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_sptsvx( int matrix_order, char fact, lapack_int n,
+                           lapack_int nrhs, const float* d, const float* e,
+                           float* df, float* ef, const float* b, lapack_int ldb,
+                           float* x, lapack_int ldx, float* rcond, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_dptsvx( int matrix_order, char fact, lapack_int n,
+                           lapack_int nrhs, const double* d, const double* e,
+                           double* df, double* ef, const double* b,
+                           lapack_int ldb, double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr );
+lapack_int LAPACKE_cptsvx( int matrix_order, char fact, lapack_int n,
+                           lapack_int nrhs, const float* d,
+                           const lapack_complex_float* e, float* df,
+                           lapack_complex_float* ef,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr );
+lapack_int LAPACKE_zptsvx( int matrix_order, char fact, lapack_int n,
+                           lapack_int nrhs, const double* d,
+                           const lapack_complex_double* e, double* df,
+                           lapack_complex_double* ef,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr );
+
+lapack_int LAPACKE_spttrf( lapack_int n, float* d, float* e );
+lapack_int LAPACKE_dpttrf( lapack_int n, double* d, double* e );
+lapack_int LAPACKE_cpttrf( lapack_int n, float* d, lapack_complex_float* e );
+lapack_int LAPACKE_zpttrf( lapack_int n, double* d, lapack_complex_double* e );
+
+lapack_int LAPACKE_spttrs( int matrix_order, lapack_int n, lapack_int nrhs,
+                           const float* d, const float* e, float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_dpttrs( int matrix_order, lapack_int n, lapack_int nrhs,
+                           const double* d, const double* e, double* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_cpttrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* d,
+                           const lapack_complex_float* e,
+                           lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zpttrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* d,
+                           const lapack_complex_double* e,
+                           lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_ssbev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_int kd, float* ab, lapack_int ldab, float* w,
+                          float* z, lapack_int ldz );
+lapack_int LAPACKE_dsbev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_int kd, double* ab, lapack_int ldab, double* w,
+                          double* z, lapack_int ldz );
+
+lapack_int LAPACKE_ssbevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_int kd, float* ab, lapack_int ldab, float* w,
+                           float* z, lapack_int ldz );
+lapack_int LAPACKE_dsbevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_int kd, double* ab, lapack_int ldab,
+                           double* w, double* z, lapack_int ldz );
+
+lapack_int LAPACKE_ssbevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_int kd, float* ab,
+                           lapack_int ldab, float* q, lapack_int ldq, float vl,
+                           float vu, lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, float* z, lapack_int ldz,
+                           lapack_int* ifail );
+lapack_int LAPACKE_dsbevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_int kd, double* ab,
+                           lapack_int ldab, double* q, lapack_int ldq,
+                           double vl, double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w, double* z,
+                           lapack_int ldz, lapack_int* ifail );
+
+lapack_int LAPACKE_ssbgst( int matrix_order, char vect, char uplo, lapack_int n,
+                           lapack_int ka, lapack_int kb, float* ab,
+                           lapack_int ldab, const float* bb, lapack_int ldbb,
+                           float* x, lapack_int ldx );
+lapack_int LAPACKE_dsbgst( int matrix_order, char vect, char uplo, lapack_int n,
+                           lapack_int ka, lapack_int kb, double* ab,
+                           lapack_int ldab, const double* bb, lapack_int ldbb,
+                           double* x, lapack_int ldx );
+
+lapack_int LAPACKE_ssbgv( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_int ka, lapack_int kb, float* ab,
+                          lapack_int ldab, float* bb, lapack_int ldbb, float* w,
+                          float* z, lapack_int ldz );
+lapack_int LAPACKE_dsbgv( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_int ka, lapack_int kb, double* ab,
+                          lapack_int ldab, double* bb, lapack_int ldbb,
+                          double* w, double* z, lapack_int ldz );
+
+lapack_int LAPACKE_ssbgvd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_int ka, lapack_int kb, float* ab,
+                           lapack_int ldab, float* bb, lapack_int ldbb,
+                           float* w, float* z, lapack_int ldz );
+lapack_int LAPACKE_dsbgvd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_int ka, lapack_int kb, double* ab,
+                           lapack_int ldab, double* bb, lapack_int ldbb,
+                           double* w, double* z, lapack_int ldz );
+
+lapack_int LAPACKE_ssbgvx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_int ka, lapack_int kb,
+                           float* ab, lapack_int ldab, float* bb,
+                           lapack_int ldbb, float* q, lapack_int ldq, float vl,
+                           float vu, lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, float* z, lapack_int ldz,
+                           lapack_int* ifail );
+lapack_int LAPACKE_dsbgvx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_int ka, lapack_int kb,
+                           double* ab, lapack_int ldab, double* bb,
+                           lapack_int ldbb, double* q, lapack_int ldq,
+                           double vl, double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w, double* z,
+                           lapack_int ldz, lapack_int* ifail );
+
+lapack_int LAPACKE_ssbtrd( int matrix_order, char vect, char uplo, lapack_int n,
+                           lapack_int kd, float* ab, lapack_int ldab, float* d,
+                           float* e, float* q, lapack_int ldq );
+lapack_int LAPACKE_dsbtrd( int matrix_order, char vect, char uplo, lapack_int n,
+                           lapack_int kd, double* ab, lapack_int ldab,
+                           double* d, double* e, double* q, lapack_int ldq );
+
+lapack_int LAPACKE_ssfrk( int matrix_order, char transr, char uplo, char trans,
+                          lapack_int n, lapack_int k, float alpha,
+                          const float* a, lapack_int lda, float beta,
+                          float* c );
+lapack_int LAPACKE_dsfrk( int matrix_order, char transr, char uplo, char trans,
+                          lapack_int n, lapack_int k, double alpha,
+                          const double* a, lapack_int lda, double beta,
+                          double* c );
+
+lapack_int LAPACKE_sspcon( int matrix_order, char uplo, lapack_int n,
+                           const float* ap, const lapack_int* ipiv, float anorm,
+                           float* rcond );
+lapack_int LAPACKE_dspcon( int matrix_order, char uplo, lapack_int n,
+                           const double* ap, const lapack_int* ipiv,
+                           double anorm, double* rcond );
+lapack_int LAPACKE_cspcon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_float* ap,
+                           const lapack_int* ipiv, float anorm, float* rcond );
+lapack_int LAPACKE_zspcon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_double* ap,
+                           const lapack_int* ipiv, double anorm,
+                           double* rcond );
+
+lapack_int LAPACKE_sspev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          float* ap, float* w, float* z, lapack_int ldz );
+lapack_int LAPACKE_dspev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          double* ap, double* w, double* z, lapack_int ldz );
+
+lapack_int LAPACKE_sspevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           float* ap, float* w, float* z, lapack_int ldz );
+lapack_int LAPACKE_dspevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           double* ap, double* w, double* z, lapack_int ldz );
+
+lapack_int LAPACKE_sspevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, float* ap, float vl, float vu,
+                           lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, float* z, lapack_int ldz,
+                           lapack_int* ifail );
+lapack_int LAPACKE_dspevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, double* ap, double vl, double vu,
+                           lapack_int il, lapack_int iu, double abstol,
+                           lapack_int* m, double* w, double* z, lapack_int ldz,
+                           lapack_int* ifail );
+
+lapack_int LAPACKE_sspgst( int matrix_order, lapack_int itype, char uplo,
+                           lapack_int n, float* ap, const float* bp );
+lapack_int LAPACKE_dspgst( int matrix_order, lapack_int itype, char uplo,
+                           lapack_int n, double* ap, const double* bp );
+
+lapack_int LAPACKE_sspgv( int matrix_order, lapack_int itype, char jobz,
+                          char uplo, lapack_int n, float* ap, float* bp,
+                          float* w, float* z, lapack_int ldz );
+lapack_int LAPACKE_dspgv( int matrix_order, lapack_int itype, char jobz,
+                          char uplo, lapack_int n, double* ap, double* bp,
+                          double* w, double* z, lapack_int ldz );
+
+lapack_int LAPACKE_sspgvd( int matrix_order, lapack_int itype, char jobz,
+                           char uplo, lapack_int n, float* ap, float* bp,
+                           float* w, float* z, lapack_int ldz );
+lapack_int LAPACKE_dspgvd( int matrix_order, lapack_int itype, char jobz,
+                           char uplo, lapack_int n, double* ap, double* bp,
+                           double* w, double* z, lapack_int ldz );
+
+lapack_int LAPACKE_sspgvx( int matrix_order, lapack_int itype, char jobz,
+                           char range, char uplo, lapack_int n, float* ap,
+                           float* bp, float vl, float vu, lapack_int il,
+                           lapack_int iu, float abstol, lapack_int* m, float* w,
+                           float* z, lapack_int ldz, lapack_int* ifail );
+lapack_int LAPACKE_dspgvx( int matrix_order, lapack_int itype, char jobz,
+                           char range, char uplo, lapack_int n, double* ap,
+                           double* bp, double vl, double vu, lapack_int il,
+                           lapack_int iu, double abstol, lapack_int* m,
+                           double* w, double* z, lapack_int ldz,
+                           lapack_int* ifail );
+
+lapack_int LAPACKE_ssprfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* ap, const float* afp,
+                           const lapack_int* ipiv, const float* b,
+                           lapack_int ldb, float* x, lapack_int ldx,
+                           float* ferr, float* berr );
+lapack_int LAPACKE_dsprfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* ap, const double* afp,
+                           const lapack_int* ipiv, const double* b,
+                           lapack_int ldb, double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+lapack_int LAPACKE_csprfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* ap,
+                           const lapack_complex_float* afp,
+                           const lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zsprfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* ap,
+                           const lapack_complex_double* afp,
+                           const lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_sspsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, float* ap, lapack_int* ipiv,
+                          float* b, lapack_int ldb );
+lapack_int LAPACKE_dspsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, double* ap, lapack_int* ipiv,
+                          double* b, lapack_int ldb );
+lapack_int LAPACKE_cspsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_float* ap,
+                          lapack_int* ipiv, lapack_complex_float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_zspsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_double* ap,
+                          lapack_int* ipiv, lapack_complex_double* b,
+                          lapack_int ldb );
+
+lapack_int LAPACKE_sspsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* ap, float* afp,
+                           lapack_int* ipiv, const float* b, lapack_int ldb,
+                           float* x, lapack_int ldx, float* rcond, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_dspsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* ap, double* afp,
+                           lapack_int* ipiv, const double* b, lapack_int ldb,
+                           double* x, lapack_int ldx, double* rcond,
+                           double* ferr, double* berr );
+lapack_int LAPACKE_cspsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* ap,
+                           lapack_complex_float* afp, lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr );
+lapack_int LAPACKE_zspsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* ap,
+                           lapack_complex_double* afp, lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr );
+
+lapack_int LAPACKE_ssptrd( int matrix_order, char uplo, lapack_int n, float* ap,
+                           float* d, float* e, float* tau );
+lapack_int LAPACKE_dsptrd( int matrix_order, char uplo, lapack_int n,
+                           double* ap, double* d, double* e, double* tau );
+
+lapack_int LAPACKE_ssptrf( int matrix_order, char uplo, lapack_int n, float* ap,
+                           lapack_int* ipiv );
+lapack_int LAPACKE_dsptrf( int matrix_order, char uplo, lapack_int n,
+                           double* ap, lapack_int* ipiv );
+lapack_int LAPACKE_csptrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* ap, lapack_int* ipiv );
+lapack_int LAPACKE_zsptrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* ap, lapack_int* ipiv );
+
+lapack_int LAPACKE_ssptri( int matrix_order, char uplo, lapack_int n, float* ap,
+                           const lapack_int* ipiv );
+lapack_int LAPACKE_dsptri( int matrix_order, char uplo, lapack_int n,
+                           double* ap, const lapack_int* ipiv );
+lapack_int LAPACKE_csptri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* ap, const lapack_int* ipiv );
+lapack_int LAPACKE_zsptri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* ap, const lapack_int* ipiv );
+
+lapack_int LAPACKE_ssptrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* ap,
+                           const lapack_int* ipiv, float* b, lapack_int ldb );
+lapack_int LAPACKE_dsptrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* ap,
+                           const lapack_int* ipiv, double* b, lapack_int ldb );
+lapack_int LAPACKE_csptrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* ap,
+                           const lapack_int* ipiv, lapack_complex_float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_zsptrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* ap,
+                           const lapack_int* ipiv, lapack_complex_double* b,
+                           lapack_int ldb );
+
+lapack_int LAPACKE_sstebz( char range, char order, lapack_int n, float vl,
+                           float vu, lapack_int il, lapack_int iu, float abstol,
+                           const float* d, const float* e, lapack_int* m,
+                           lapack_int* nsplit, float* w, lapack_int* iblock,
+                           lapack_int* isplit );
+lapack_int LAPACKE_dstebz( char range, char order, lapack_int n, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, const double* d, const double* e,
+                           lapack_int* m, lapack_int* nsplit, double* w,
+                           lapack_int* iblock, lapack_int* isplit );
+
+lapack_int LAPACKE_sstedc( int matrix_order, char compz, lapack_int n, float* d,
+                           float* e, float* z, lapack_int ldz );
+lapack_int LAPACKE_dstedc( int matrix_order, char compz, lapack_int n,
+                           double* d, double* e, double* z, lapack_int ldz );
+lapack_int LAPACKE_cstedc( int matrix_order, char compz, lapack_int n, float* d,
+                           float* e, lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zstedc( int matrix_order, char compz, lapack_int n,
+                           double* d, double* e, lapack_complex_double* z,
+                           lapack_int ldz );
+
+lapack_int LAPACKE_sstegr( int matrix_order, char jobz, char range,
+                           lapack_int n, float* d, float* e, float vl, float vu,
+                           lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, float* z, lapack_int ldz,
+                           lapack_int* isuppz );
+lapack_int LAPACKE_dstegr( int matrix_order, char jobz, char range,
+                           lapack_int n, double* d, double* e, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w, double* z,
+                           lapack_int ldz, lapack_int* isuppz );
+lapack_int LAPACKE_cstegr( int matrix_order, char jobz, char range,
+                           lapack_int n, float* d, float* e, float vl, float vu,
+                           lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, lapack_complex_float* z,
+                           lapack_int ldz, lapack_int* isuppz );
+lapack_int LAPACKE_zstegr( int matrix_order, char jobz, char range,
+                           lapack_int n, double* d, double* e, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w,
+                           lapack_complex_double* z, lapack_int ldz,
+                           lapack_int* isuppz );
+
+lapack_int LAPACKE_sstein( int matrix_order, lapack_int n, const float* d,
+                           const float* e, lapack_int m, const float* w,
+                           const lapack_int* iblock, const lapack_int* isplit,
+                           float* z, lapack_int ldz, lapack_int* ifailv );
+lapack_int LAPACKE_dstein( int matrix_order, lapack_int n, const double* d,
+                           const double* e, lapack_int m, const double* w,
+                           const lapack_int* iblock, const lapack_int* isplit,
+                           double* z, lapack_int ldz, lapack_int* ifailv );
+lapack_int LAPACKE_cstein( int matrix_order, lapack_int n, const float* d,
+                           const float* e, lapack_int m, const float* w,
+                           const lapack_int* iblock, const lapack_int* isplit,
+                           lapack_complex_float* z, lapack_int ldz,
+                           lapack_int* ifailv );
+lapack_int LAPACKE_zstein( int matrix_order, lapack_int n, const double* d,
+                           const double* e, lapack_int m, const double* w,
+                           const lapack_int* iblock, const lapack_int* isplit,
+                           lapack_complex_double* z, lapack_int ldz,
+                           lapack_int* ifailv );
+
+lapack_int LAPACKE_sstemr( int matrix_order, char jobz, char range,
+                           lapack_int n, float* d, float* e, float vl, float vu,
+                           lapack_int il, lapack_int iu, lapack_int* m,
+                           float* w, float* z, lapack_int ldz, lapack_int nzc,
+                           lapack_int* isuppz, lapack_logical* tryrac );
+lapack_int LAPACKE_dstemr( int matrix_order, char jobz, char range,
+                           lapack_int n, double* d, double* e, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           lapack_int* m, double* w, double* z, lapack_int ldz,
+                           lapack_int nzc, lapack_int* isuppz,
+                           lapack_logical* tryrac );
+lapack_int LAPACKE_cstemr( int matrix_order, char jobz, char range,
+                           lapack_int n, float* d, float* e, float vl, float vu,
+                           lapack_int il, lapack_int iu, lapack_int* m,
+                           float* w, lapack_complex_float* z, lapack_int ldz,
+                           lapack_int nzc, lapack_int* isuppz,
+                           lapack_logical* tryrac );
+lapack_int LAPACKE_zstemr( int matrix_order, char jobz, char range,
+                           lapack_int n, double* d, double* e, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           lapack_int* m, double* w, lapack_complex_double* z,
+                           lapack_int ldz, lapack_int nzc, lapack_int* isuppz,
+                           lapack_logical* tryrac );
+
+lapack_int LAPACKE_ssteqr( int matrix_order, char compz, lapack_int n, float* d,
+                           float* e, float* z, lapack_int ldz );
+lapack_int LAPACKE_dsteqr( int matrix_order, char compz, lapack_int n,
+                           double* d, double* e, double* z, lapack_int ldz );
+lapack_int LAPACKE_csteqr( int matrix_order, char compz, lapack_int n, float* d,
+                           float* e, lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zsteqr( int matrix_order, char compz, lapack_int n,
+                           double* d, double* e, lapack_complex_double* z,
+                           lapack_int ldz );
+
+lapack_int LAPACKE_ssterf( lapack_int n, float* d, float* e );
+lapack_int LAPACKE_dsterf( lapack_int n, double* d, double* e );
+
+lapack_int LAPACKE_sstev( int matrix_order, char jobz, lapack_int n, float* d,
+                          float* e, float* z, lapack_int ldz );
+lapack_int LAPACKE_dstev( int matrix_order, char jobz, lapack_int n, double* d,
+                          double* e, double* z, lapack_int ldz );
+
+lapack_int LAPACKE_sstevd( int matrix_order, char jobz, lapack_int n, float* d,
+                           float* e, float* z, lapack_int ldz );
+lapack_int LAPACKE_dstevd( int matrix_order, char jobz, lapack_int n, double* d,
+                           double* e, double* z, lapack_int ldz );
+
+lapack_int LAPACKE_sstevr( int matrix_order, char jobz, char range,
+                           lapack_int n, float* d, float* e, float vl, float vu,
+                           lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, float* z, lapack_int ldz,
+                           lapack_int* isuppz );
+lapack_int LAPACKE_dstevr( int matrix_order, char jobz, char range,
+                           lapack_int n, double* d, double* e, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w, double* z,
+                           lapack_int ldz, lapack_int* isuppz );
+
+lapack_int LAPACKE_sstevx( int matrix_order, char jobz, char range,
+                           lapack_int n, float* d, float* e, float vl, float vu,
+                           lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, float* z, lapack_int ldz,
+                           lapack_int* ifail );
+lapack_int LAPACKE_dstevx( int matrix_order, char jobz, char range,
+                           lapack_int n, double* d, double* e, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w, double* z,
+                           lapack_int ldz, lapack_int* ifail );
+
+lapack_int LAPACKE_ssycon( int matrix_order, char uplo, lapack_int n,
+                           const float* a, lapack_int lda,
+                           const lapack_int* ipiv, float anorm, float* rcond );
+lapack_int LAPACKE_dsycon( int matrix_order, char uplo, lapack_int n,
+                           const double* a, lapack_int lda,
+                           const lapack_int* ipiv, double anorm,
+                           double* rcond );
+lapack_int LAPACKE_csycon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_int* ipiv, float anorm, float* rcond );
+lapack_int LAPACKE_zsycon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_int* ipiv, double anorm,
+                           double* rcond );
+
+lapack_int LAPACKE_ssyequb( int matrix_order, char uplo, lapack_int n,
+                            const float* a, lapack_int lda, float* s,
+                            float* scond, float* amax );
+lapack_int LAPACKE_dsyequb( int matrix_order, char uplo, lapack_int n,
+                            const double* a, lapack_int lda, double* s,
+                            double* scond, double* amax );
+lapack_int LAPACKE_csyequb( int matrix_order, char uplo, lapack_int n,
+                            const lapack_complex_float* a, lapack_int lda,
+                            float* s, float* scond, float* amax );
+lapack_int LAPACKE_zsyequb( int matrix_order, char uplo, lapack_int n,
+                            const lapack_complex_double* a, lapack_int lda,
+                            double* s, double* scond, double* amax );
+
+lapack_int LAPACKE_ssyev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          float* a, lapack_int lda, float* w );
+lapack_int LAPACKE_dsyev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          double* a, lapack_int lda, double* w );
+
+lapack_int LAPACKE_ssyevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           float* a, lapack_int lda, float* w );
+lapack_int LAPACKE_dsyevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           double* a, lapack_int lda, double* w );
+
+lapack_int LAPACKE_ssyevr( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, float* a, lapack_int lda, float vl,
+                           float vu, lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, float* z, lapack_int ldz,
+                           lapack_int* isuppz );
+lapack_int LAPACKE_dsyevr( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, double* a, lapack_int lda, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w, double* z,
+                           lapack_int ldz, lapack_int* isuppz );
+
+lapack_int LAPACKE_ssyevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, float* a, lapack_int lda, float vl,
+                           float vu, lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, float* z, lapack_int ldz,
+                           lapack_int* ifail );
+lapack_int LAPACKE_dsyevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, double* a, lapack_int lda, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w, double* z,
+                           lapack_int ldz, lapack_int* ifail );
+
+lapack_int LAPACKE_ssygst( int matrix_order, lapack_int itype, char uplo,
+                           lapack_int n, float* a, lapack_int lda,
+                           const float* b, lapack_int ldb );
+lapack_int LAPACKE_dsygst( int matrix_order, lapack_int itype, char uplo,
+                           lapack_int n, double* a, lapack_int lda,
+                           const double* b, lapack_int ldb );
+
+lapack_int LAPACKE_ssygv( int matrix_order, lapack_int itype, char jobz,
+                          char uplo, lapack_int n, float* a, lapack_int lda,
+                          float* b, lapack_int ldb, float* w );
+lapack_int LAPACKE_dsygv( int matrix_order, lapack_int itype, char jobz,
+                          char uplo, lapack_int n, double* a, lapack_int lda,
+                          double* b, lapack_int ldb, double* w );
+
+lapack_int LAPACKE_ssygvd( int matrix_order, lapack_int itype, char jobz,
+                           char uplo, lapack_int n, float* a, lapack_int lda,
+                           float* b, lapack_int ldb, float* w );
+lapack_int LAPACKE_dsygvd( int matrix_order, lapack_int itype, char jobz,
+                           char uplo, lapack_int n, double* a, lapack_int lda,
+                           double* b, lapack_int ldb, double* w );
+
+lapack_int LAPACKE_ssygvx( int matrix_order, lapack_int itype, char jobz,
+                           char range, char uplo, lapack_int n, float* a,
+                           lapack_int lda, float* b, lapack_int ldb, float vl,
+                           float vu, lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, float* z, lapack_int ldz,
+                           lapack_int* ifail );
+lapack_int LAPACKE_dsygvx( int matrix_order, lapack_int itype, char jobz,
+                           char range, char uplo, lapack_int n, double* a,
+                           lapack_int lda, double* b, lapack_int ldb, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w, double* z,
+                           lapack_int ldz, lapack_int* ifail );
+
+lapack_int LAPACKE_ssyrfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* a, lapack_int lda,
+                           const float* af, lapack_int ldaf,
+                           const lapack_int* ipiv, const float* b,
+                           lapack_int ldb, float* x, lapack_int ldx,
+                           float* ferr, float* berr );
+lapack_int LAPACKE_dsyrfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* a, lapack_int lda,
+                           const double* af, lapack_int ldaf,
+                           const lapack_int* ipiv, const double* b,
+                           lapack_int ldb, double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+lapack_int LAPACKE_csyrfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* af,
+                           lapack_int ldaf, const lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zsyrfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* af,
+                           lapack_int ldaf, const lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_ssyrfsx( int matrix_order, char uplo, char equed,
+                            lapack_int n, lapack_int nrhs, const float* a,
+                            lapack_int lda, const float* af, lapack_int ldaf,
+                            const lapack_int* ipiv, const float* s,
+                            const float* b, lapack_int ldb, float* x,
+                            lapack_int ldx, float* rcond, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_dsyrfsx( int matrix_order, char uplo, char equed,
+                            lapack_int n, lapack_int nrhs, const double* a,
+                            lapack_int lda, const double* af, lapack_int ldaf,
+                            const lapack_int* ipiv, const double* s,
+                            const double* b, lapack_int ldb, double* x,
+                            lapack_int ldx, double* rcond, double* berr,
+                            lapack_int n_err_bnds, double* err_bnds_norm,
+                            double* err_bnds_comp, lapack_int nparams,
+                            double* params );
+lapack_int LAPACKE_csyrfsx( int matrix_order, char uplo, char equed,
+                            lapack_int n, lapack_int nrhs,
+                            const lapack_complex_float* a, lapack_int lda,
+                            const lapack_complex_float* af, lapack_int ldaf,
+                            const lapack_int* ipiv, const float* s,
+                            const lapack_complex_float* b, lapack_int ldb,
+                            lapack_complex_float* x, lapack_int ldx,
+                            float* rcond, float* berr, lapack_int n_err_bnds,
+                            float* err_bnds_norm, float* err_bnds_comp,
+                            lapack_int nparams, float* params );
+lapack_int LAPACKE_zsyrfsx( int matrix_order, char uplo, char equed,
+                            lapack_int n, lapack_int nrhs,
+                            const lapack_complex_double* a, lapack_int lda,
+                            const lapack_complex_double* af, lapack_int ldaf,
+                            const lapack_int* ipiv, const double* s,
+                            const lapack_complex_double* b, lapack_int ldb,
+                            lapack_complex_double* x, lapack_int ldx,
+                            double* rcond, double* berr, lapack_int n_err_bnds,
+                            double* err_bnds_norm, double* err_bnds_comp,
+                            lapack_int nparams, double* params );
+
+lapack_int LAPACKE_ssysv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, float* a, lapack_int lda,
+                          lapack_int* ipiv, float* b, lapack_int ldb );
+lapack_int LAPACKE_dsysv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, double* a, lapack_int lda,
+                          lapack_int* ipiv, double* b, lapack_int ldb );
+lapack_int LAPACKE_csysv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_float* a,
+                          lapack_int lda, lapack_int* ipiv,
+                          lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zsysv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_double* a,
+                          lapack_int lda, lapack_int* ipiv,
+                          lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_ssysvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* a, lapack_int lda,
+                           float* af, lapack_int ldaf, lapack_int* ipiv,
+                           const float* b, lapack_int ldb, float* x,
+                           lapack_int ldx, float* rcond, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_dsysvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* a, lapack_int lda,
+                           double* af, lapack_int ldaf, lapack_int* ipiv,
+                           const double* b, lapack_int ldb, double* x,
+                           lapack_int ldx, double* rcond, double* ferr,
+                           double* berr );
+lapack_int LAPACKE_csysvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* af,
+                           lapack_int ldaf, lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr );
+lapack_int LAPACKE_zsysvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* af,
+                           lapack_int ldaf, lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr );
+
+lapack_int LAPACKE_ssysvxx( int matrix_order, char fact, char uplo,
+                            lapack_int n, lapack_int nrhs, float* a,
+                            lapack_int lda, float* af, lapack_int ldaf,
+                            lapack_int* ipiv, char* equed, float* s, float* b,
+                            lapack_int ldb, float* x, lapack_int ldx,
+                            float* rcond, float* rpvgrw, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_dsysvxx( int matrix_order, char fact, char uplo,
+                            lapack_int n, lapack_int nrhs, double* a,
+                            lapack_int lda, double* af, lapack_int ldaf,
+                            lapack_int* ipiv, char* equed, double* s, double* b,
+                            lapack_int ldb, double* x, lapack_int ldx,
+                            double* rcond, double* rpvgrw, double* berr,
+                            lapack_int n_err_bnds, double* err_bnds_norm,
+                            double* err_bnds_comp, lapack_int nparams,
+                            double* params );
+lapack_int LAPACKE_csysvxx( int matrix_order, char fact, char uplo,
+                            lapack_int n, lapack_int nrhs,
+                            lapack_complex_float* a, lapack_int lda,
+                            lapack_complex_float* af, lapack_int ldaf,
+                            lapack_int* ipiv, char* equed, float* s,
+                            lapack_complex_float* b, lapack_int ldb,
+                            lapack_complex_float* x, lapack_int ldx,
+                            float* rcond, float* rpvgrw, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_zsysvxx( int matrix_order, char fact, char uplo,
+                            lapack_int n, lapack_int nrhs,
+                            lapack_complex_double* a, lapack_int lda,
+                            lapack_complex_double* af, lapack_int ldaf,
+                            lapack_int* ipiv, char* equed, double* s,
+                            lapack_complex_double* b, lapack_int ldb,
+                            lapack_complex_double* x, lapack_int ldx,
+                            double* rcond, double* rpvgrw, double* berr,
+                            lapack_int n_err_bnds, double* err_bnds_norm,
+                            double* err_bnds_comp, lapack_int nparams,
+                            double* params );
+
+lapack_int LAPACKE_ssytrd( int matrix_order, char uplo, lapack_int n, float* a,
+                           lapack_int lda, float* d, float* e, float* tau );
+lapack_int LAPACKE_dsytrd( int matrix_order, char uplo, lapack_int n, double* a,
+                           lapack_int lda, double* d, double* e, double* tau );
+
+lapack_int LAPACKE_ssytrf( int matrix_order, char uplo, lapack_int n, float* a,
+                           lapack_int lda, lapack_int* ipiv );
+lapack_int LAPACKE_dsytrf( int matrix_order, char uplo, lapack_int n, double* a,
+                           lapack_int lda, lapack_int* ipiv );
+lapack_int LAPACKE_csytrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int* ipiv );
+lapack_int LAPACKE_zsytrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* ipiv );
+
+lapack_int LAPACKE_ssytri( int matrix_order, char uplo, lapack_int n, float* a,
+                           lapack_int lda, const lapack_int* ipiv );
+lapack_int LAPACKE_dsytri( int matrix_order, char uplo, lapack_int n, double* a,
+                           lapack_int lda, const lapack_int* ipiv );
+lapack_int LAPACKE_csytri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           const lapack_int* ipiv );
+lapack_int LAPACKE_zsytri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           const lapack_int* ipiv );
+
+lapack_int LAPACKE_ssytrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* a, lapack_int lda,
+                           const lapack_int* ipiv, float* b, lapack_int ldb );
+lapack_int LAPACKE_dsytrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* a, lapack_int lda,
+                           const lapack_int* ipiv, double* b, lapack_int ldb );
+lapack_int LAPACKE_csytrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* a,
+                           lapack_int lda, const lapack_int* ipiv,
+                           lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zsytrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* a,
+                           lapack_int lda, const lapack_int* ipiv,
+                           lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_stbcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, lapack_int kd, const float* ab,
+                           lapack_int ldab, float* rcond );
+lapack_int LAPACKE_dtbcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, lapack_int kd, const double* ab,
+                           lapack_int ldab, double* rcond );
+lapack_int LAPACKE_ctbcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, lapack_int kd,
+                           const lapack_complex_float* ab, lapack_int ldab,
+                           float* rcond );
+lapack_int LAPACKE_ztbcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, lapack_int kd,
+                           const lapack_complex_double* ab, lapack_int ldab,
+                           double* rcond );
+
+lapack_int LAPACKE_stbrfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int kd, lapack_int nrhs,
+                           const float* ab, lapack_int ldab, const float* b,
+                           lapack_int ldb, const float* x, lapack_int ldx,
+                           float* ferr, float* berr );
+lapack_int LAPACKE_dtbrfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int kd, lapack_int nrhs,
+                           const double* ab, lapack_int ldab, const double* b,
+                           lapack_int ldb, const double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+lapack_int LAPACKE_ctbrfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int kd, lapack_int nrhs,
+                           const lapack_complex_float* ab, lapack_int ldab,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           const lapack_complex_float* x, lapack_int ldx,
+                           float* ferr, float* berr );
+lapack_int LAPACKE_ztbrfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int kd, lapack_int nrhs,
+                           const lapack_complex_double* ab, lapack_int ldab,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           const lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_stbtrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int kd, lapack_int nrhs,
+                           const float* ab, lapack_int ldab, float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_dtbtrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int kd, lapack_int nrhs,
+                           const double* ab, lapack_int ldab, double* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_ctbtrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int kd, lapack_int nrhs,
+                           const lapack_complex_float* ab, lapack_int ldab,
+                           lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_ztbtrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int kd, lapack_int nrhs,
+                           const lapack_complex_double* ab, lapack_int ldab,
+                           lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_stfsm( int matrix_order, char transr, char side, char uplo,
+                          char trans, char diag, lapack_int m, lapack_int n,
+                          float alpha, const float* a, float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_dtfsm( int matrix_order, char transr, char side, char uplo,
+                          char trans, char diag, lapack_int m, lapack_int n,
+                          double alpha, const double* a, double* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_ctfsm( int matrix_order, char transr, char side, char uplo,
+                          char trans, char diag, lapack_int m, lapack_int n,
+                          lapack_complex_float alpha,
+                          const lapack_complex_float* a,
+                          lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_ztfsm( int matrix_order, char transr, char side, char uplo,
+                          char trans, char diag, lapack_int m, lapack_int n,
+                          lapack_complex_double alpha,
+                          const lapack_complex_double* a,
+                          lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_stftri( int matrix_order, char transr, char uplo, char diag,
+                           lapack_int n, float* a );
+lapack_int LAPACKE_dtftri( int matrix_order, char transr, char uplo, char diag,
+                           lapack_int n, double* a );
+lapack_int LAPACKE_ctftri( int matrix_order, char transr, char uplo, char diag,
+                           lapack_int n, lapack_complex_float* a );
+lapack_int LAPACKE_ztftri( int matrix_order, char transr, char uplo, char diag,
+                           lapack_int n, lapack_complex_double* a );
+
+lapack_int LAPACKE_stfttp( int matrix_order, char transr, char uplo,
+                           lapack_int n, const float* arf, float* ap );
+lapack_int LAPACKE_dtfttp( int matrix_order, char transr, char uplo,
+                           lapack_int n, const double* arf, double* ap );
+lapack_int LAPACKE_ctfttp( int matrix_order, char transr, char uplo,
+                           lapack_int n, const lapack_complex_float* arf,
+                           lapack_complex_float* ap );
+lapack_int LAPACKE_ztfttp( int matrix_order, char transr, char uplo,
+                           lapack_int n, const lapack_complex_double* arf,
+                           lapack_complex_double* ap );
+
+lapack_int LAPACKE_stfttr( int matrix_order, char transr, char uplo,
+                           lapack_int n, const float* arf, float* a,
+                           lapack_int lda );
+lapack_int LAPACKE_dtfttr( int matrix_order, char transr, char uplo,
+                           lapack_int n, const double* arf, double* a,
+                           lapack_int lda );
+lapack_int LAPACKE_ctfttr( int matrix_order, char transr, char uplo,
+                           lapack_int n, const lapack_complex_float* arf,
+                           lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_ztfttr( int matrix_order, char transr, char uplo,
+                           lapack_int n, const lapack_complex_double* arf,
+                           lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_stgevc( int matrix_order, char side, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const float* s, lapack_int lds, const float* p,
+                           lapack_int ldp, float* vl, lapack_int ldvl,
+                           float* vr, lapack_int ldvr, lapack_int mm,
+                           lapack_int* m );
+lapack_int LAPACKE_dtgevc( int matrix_order, char side, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const double* s, lapack_int lds, const double* p,
+                           lapack_int ldp, double* vl, lapack_int ldvl,
+                           double* vr, lapack_int ldvr, lapack_int mm,
+                           lapack_int* m );
+lapack_int LAPACKE_ctgevc( int matrix_order, char side, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const lapack_complex_float* s, lapack_int lds,
+                           const lapack_complex_float* p, lapack_int ldp,
+                           lapack_complex_float* vl, lapack_int ldvl,
+                           lapack_complex_float* vr, lapack_int ldvr,
+                           lapack_int mm, lapack_int* m );
+lapack_int LAPACKE_ztgevc( int matrix_order, char side, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const lapack_complex_double* s, lapack_int lds,
+                           const lapack_complex_double* p, lapack_int ldp,
+                           lapack_complex_double* vl, lapack_int ldvl,
+                           lapack_complex_double* vr, lapack_int ldvr,
+                           lapack_int mm, lapack_int* m );
+
+lapack_int LAPACKE_stgexc( int matrix_order, lapack_logical wantq,
+                           lapack_logical wantz, lapack_int n, float* a,
+                           lapack_int lda, float* b, lapack_int ldb, float* q,
+                           lapack_int ldq, float* z, lapack_int ldz,
+                           lapack_int* ifst, lapack_int* ilst );
+lapack_int LAPACKE_dtgexc( int matrix_order, lapack_logical wantq,
+                           lapack_logical wantz, lapack_int n, double* a,
+                           lapack_int lda, double* b, lapack_int ldb, double* q,
+                           lapack_int ldq, double* z, lapack_int ldz,
+                           lapack_int* ifst, lapack_int* ilst );
+lapack_int LAPACKE_ctgexc( int matrix_order, lapack_logical wantq,
+                           lapack_logical wantz, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* q, lapack_int ldq,
+                           lapack_complex_float* z, lapack_int ldz,
+                           lapack_int ifst, lapack_int ilst );
+lapack_int LAPACKE_ztgexc( int matrix_order, lapack_logical wantq,
+                           lapack_logical wantz, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* q, lapack_int ldq,
+                           lapack_complex_double* z, lapack_int ldz,
+                           lapack_int ifst, lapack_int ilst );
+
+lapack_int LAPACKE_stgsen( int matrix_order, lapack_int ijob,
+                           lapack_logical wantq, lapack_logical wantz,
+                           const lapack_logical* select, lapack_int n, float* a,
+                           lapack_int lda, float* b, lapack_int ldb,
+                           float* alphar, float* alphai, float* beta, float* q,
+                           lapack_int ldq, float* z, lapack_int ldz,
+                           lapack_int* m, float* pl, float* pr, float* dif );
+lapack_int LAPACKE_dtgsen( int matrix_order, lapack_int ijob,
+                           lapack_logical wantq, lapack_logical wantz,
+                           const lapack_logical* select, lapack_int n,
+                           double* a, lapack_int lda, double* b, lapack_int ldb,
+                           double* alphar, double* alphai, double* beta,
+                           double* q, lapack_int ldq, double* z, lapack_int ldz,
+                           lapack_int* m, double* pl, double* pr, double* dif );
+lapack_int LAPACKE_ctgsen( int matrix_order, lapack_int ijob,
+                           lapack_logical wantq, lapack_logical wantz,
+                           const lapack_logical* select, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* alpha,
+                           lapack_complex_float* beta, lapack_complex_float* q,
+                           lapack_int ldq, lapack_complex_float* z,
+                           lapack_int ldz, lapack_int* m, float* pl, float* pr,
+                           float* dif );
+lapack_int LAPACKE_ztgsen( int matrix_order, lapack_int ijob,
+                           lapack_logical wantq, lapack_logical wantz,
+                           const lapack_logical* select, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* alpha,
+                           lapack_complex_double* beta,
+                           lapack_complex_double* q, lapack_int ldq,
+                           lapack_complex_double* z, lapack_int ldz,
+                           lapack_int* m, double* pl, double* pr, double* dif );
+
+lapack_int LAPACKE_stgsja( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int p, lapack_int n,
+                           lapack_int k, lapack_int l, float* a, lapack_int lda,
+                           float* b, lapack_int ldb, float tola, float tolb,
+                           float* alpha, float* beta, float* u, lapack_int ldu,
+                           float* v, lapack_int ldv, float* q, lapack_int ldq,
+                           lapack_int* ncycle );
+lapack_int LAPACKE_dtgsja( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int p, lapack_int n,
+                           lapack_int k, lapack_int l, double* a,
+                           lapack_int lda, double* b, lapack_int ldb,
+                           double tola, double tolb, double* alpha,
+                           double* beta, double* u, lapack_int ldu, double* v,
+                           lapack_int ldv, double* q, lapack_int ldq,
+                           lapack_int* ncycle );
+lapack_int LAPACKE_ctgsja( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int p, lapack_int n,
+                           lapack_int k, lapack_int l, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* b,
+                           lapack_int ldb, float tola, float tolb, float* alpha,
+                           float* beta, lapack_complex_float* u, lapack_int ldu,
+                           lapack_complex_float* v, lapack_int ldv,
+                           lapack_complex_float* q, lapack_int ldq,
+                           lapack_int* ncycle );
+lapack_int LAPACKE_ztgsja( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int p, lapack_int n,
+                           lapack_int k, lapack_int l, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb, double tola, double tolb,
+                           double* alpha, double* beta,
+                           lapack_complex_double* u, lapack_int ldu,
+                           lapack_complex_double* v, lapack_int ldv,
+                           lapack_complex_double* q, lapack_int ldq,
+                           lapack_int* ncycle );
+
+lapack_int LAPACKE_stgsna( int matrix_order, char job, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const float* a, lapack_int lda, const float* b,
+                           lapack_int ldb, const float* vl, lapack_int ldvl,
+                           const float* vr, lapack_int ldvr, float* s,
+                           float* dif, lapack_int mm, lapack_int* m );
+lapack_int LAPACKE_dtgsna( int matrix_order, char job, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const double* a, lapack_int lda, const double* b,
+                           lapack_int ldb, const double* vl, lapack_int ldvl,
+                           const double* vr, lapack_int ldvr, double* s,
+                           double* dif, lapack_int mm, lapack_int* m );
+lapack_int LAPACKE_ctgsna( int matrix_order, char job, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           const lapack_complex_float* vl, lapack_int ldvl,
+                           const lapack_complex_float* vr, lapack_int ldvr,
+                           float* s, float* dif, lapack_int mm, lapack_int* m );
+lapack_int LAPACKE_ztgsna( int matrix_order, char job, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           const lapack_complex_double* vl, lapack_int ldvl,
+                           const lapack_complex_double* vr, lapack_int ldvr,
+                           double* s, double* dif, lapack_int mm,
+                           lapack_int* m );
+
+lapack_int LAPACKE_stgsyl( int matrix_order, char trans, lapack_int ijob,
+                           lapack_int m, lapack_int n, const float* a,
+                           lapack_int lda, const float* b, lapack_int ldb,
+                           float* c, lapack_int ldc, const float* d,
+                           lapack_int ldd, const float* e, lapack_int lde,
+                           float* f, lapack_int ldf, float* scale, float* dif );
+lapack_int LAPACKE_dtgsyl( int matrix_order, char trans, lapack_int ijob,
+                           lapack_int m, lapack_int n, const double* a,
+                           lapack_int lda, const double* b, lapack_int ldb,
+                           double* c, lapack_int ldc, const double* d,
+                           lapack_int ldd, const double* e, lapack_int lde,
+                           double* f, lapack_int ldf, double* scale,
+                           double* dif );
+lapack_int LAPACKE_ctgsyl( int matrix_order, char trans, lapack_int ijob,
+                           lapack_int m, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* c, lapack_int ldc,
+                           const lapack_complex_float* d, lapack_int ldd,
+                           const lapack_complex_float* e, lapack_int lde,
+                           lapack_complex_float* f, lapack_int ldf,
+                           float* scale, float* dif );
+lapack_int LAPACKE_ztgsyl( int matrix_order, char trans, lapack_int ijob,
+                           lapack_int m, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* c, lapack_int ldc,
+                           const lapack_complex_double* d, lapack_int ldd,
+                           const lapack_complex_double* e, lapack_int lde,
+                           lapack_complex_double* f, lapack_int ldf,
+                           double* scale, double* dif );
+
+lapack_int LAPACKE_stpcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, const float* ap, float* rcond );
+lapack_int LAPACKE_dtpcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, const double* ap, double* rcond );
+lapack_int LAPACKE_ctpcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, const lapack_complex_float* ap,
+                           float* rcond );
+lapack_int LAPACKE_ztpcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, const lapack_complex_double* ap,
+                           double* rcond );
+
+lapack_int LAPACKE_stprfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs, const float* ap,
+                           const float* b, lapack_int ldb, const float* x,
+                           lapack_int ldx, float* ferr, float* berr );
+lapack_int LAPACKE_dtprfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs, const double* ap,
+                           const double* b, lapack_int ldb, const double* x,
+                           lapack_int ldx, double* ferr, double* berr );
+lapack_int LAPACKE_ctprfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_float* ap,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           const lapack_complex_float* x, lapack_int ldx,
+                           float* ferr, float* berr );
+lapack_int LAPACKE_ztprfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_double* ap,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           const lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_stptri( int matrix_order, char uplo, char diag, lapack_int n,
+                           float* ap );
+lapack_int LAPACKE_dtptri( int matrix_order, char uplo, char diag, lapack_int n,
+                           double* ap );
+lapack_int LAPACKE_ctptri( int matrix_order, char uplo, char diag, lapack_int n,
+                           lapack_complex_float* ap );
+lapack_int LAPACKE_ztptri( int matrix_order, char uplo, char diag, lapack_int n,
+                           lapack_complex_double* ap );
+
+lapack_int LAPACKE_stptrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs, const float* ap,
+                           float* b, lapack_int ldb );
+lapack_int LAPACKE_dtptrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs, const double* ap,
+                           double* b, lapack_int ldb );
+lapack_int LAPACKE_ctptrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_float* ap,
+                           lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_ztptrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_double* ap,
+                           lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_stpttf( int matrix_order, char transr, char uplo,
+                           lapack_int n, const float* ap, float* arf );
+lapack_int LAPACKE_dtpttf( int matrix_order, char transr, char uplo,
+                           lapack_int n, const double* ap, double* arf );
+lapack_int LAPACKE_ctpttf( int matrix_order, char transr, char uplo,
+                           lapack_int n, const lapack_complex_float* ap,
+                           lapack_complex_float* arf );
+lapack_int LAPACKE_ztpttf( int matrix_order, char transr, char uplo,
+                           lapack_int n, const lapack_complex_double* ap,
+                           lapack_complex_double* arf );
+
+lapack_int LAPACKE_stpttr( int matrix_order, char uplo, lapack_int n,
+                           const float* ap, float* a, lapack_int lda );
+lapack_int LAPACKE_dtpttr( int matrix_order, char uplo, lapack_int n,
+                           const double* ap, double* a, lapack_int lda );
+lapack_int LAPACKE_ctpttr( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_float* ap,
+                           lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_ztpttr( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_double* ap,
+                           lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_strcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, const float* a, lapack_int lda,
+                           float* rcond );
+lapack_int LAPACKE_dtrcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, const double* a, lapack_int lda,
+                           double* rcond );
+lapack_int LAPACKE_ctrcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, const lapack_complex_float* a,
+                           lapack_int lda, float* rcond );
+lapack_int LAPACKE_ztrcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, const lapack_complex_double* a,
+                           lapack_int lda, double* rcond );
+
+lapack_int LAPACKE_strevc( int matrix_order, char side, char howmny,
+                           lapack_logical* select, lapack_int n, const float* t,
+                           lapack_int ldt, float* vl, lapack_int ldvl,
+                           float* vr, lapack_int ldvr, lapack_int mm,
+                           lapack_int* m );
+lapack_int LAPACKE_dtrevc( int matrix_order, char side, char howmny,
+                           lapack_logical* select, lapack_int n,
+                           const double* t, lapack_int ldt, double* vl,
+                           lapack_int ldvl, double* vr, lapack_int ldvr,
+                           lapack_int mm, lapack_int* m );
+lapack_int LAPACKE_ctrevc( int matrix_order, char side, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           lapack_complex_float* t, lapack_int ldt,
+                           lapack_complex_float* vl, lapack_int ldvl,
+                           lapack_complex_float* vr, lapack_int ldvr,
+                           lapack_int mm, lapack_int* m );
+lapack_int LAPACKE_ztrevc( int matrix_order, char side, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           lapack_complex_double* t, lapack_int ldt,
+                           lapack_complex_double* vl, lapack_int ldvl,
+                           lapack_complex_double* vr, lapack_int ldvr,
+                           lapack_int mm, lapack_int* m );
+
+lapack_int LAPACKE_strexc( int matrix_order, char compq, lapack_int n, float* t,
+                           lapack_int ldt, float* q, lapack_int ldq,
+                           lapack_int* ifst, lapack_int* ilst );
+lapack_int LAPACKE_dtrexc( int matrix_order, char compq, lapack_int n,
+                           double* t, lapack_int ldt, double* q, lapack_int ldq,
+                           lapack_int* ifst, lapack_int* ilst );
+lapack_int LAPACKE_ctrexc( int matrix_order, char compq, lapack_int n,
+                           lapack_complex_float* t, lapack_int ldt,
+                           lapack_complex_float* q, lapack_int ldq,
+                           lapack_int ifst, lapack_int ilst );
+lapack_int LAPACKE_ztrexc( int matrix_order, char compq, lapack_int n,
+                           lapack_complex_double* t, lapack_int ldt,
+                           lapack_complex_double* q, lapack_int ldq,
+                           lapack_int ifst, lapack_int ilst );
+
+lapack_int LAPACKE_strrfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs, const float* a,
+                           lapack_int lda, const float* b, lapack_int ldb,
+                           const float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_dtrrfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs, const double* a,
+                           lapack_int lda, const double* b, lapack_int ldb,
+                           const double* x, lapack_int ldx, double* ferr,
+                           double* berr );
+lapack_int LAPACKE_ctrrfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           const lapack_complex_float* x, lapack_int ldx,
+                           float* ferr, float* berr );
+lapack_int LAPACKE_ztrrfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           const lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_strsen( int matrix_order, char job, char compq,
+                           const lapack_logical* select, lapack_int n, float* t,
+                           lapack_int ldt, float* q, lapack_int ldq, float* wr,
+                           float* wi, lapack_int* m, float* s, float* sep );
+lapack_int LAPACKE_dtrsen( int matrix_order, char job, char compq,
+                           const lapack_logical* select, lapack_int n,
+                           double* t, lapack_int ldt, double* q, lapack_int ldq,
+                           double* wr, double* wi, lapack_int* m, double* s,
+                           double* sep );
+lapack_int LAPACKE_ctrsen( int matrix_order, char job, char compq,
+                           const lapack_logical* select, lapack_int n,
+                           lapack_complex_float* t, lapack_int ldt,
+                           lapack_complex_float* q, lapack_int ldq,
+                           lapack_complex_float* w, lapack_int* m, float* s,
+                           float* sep );
+lapack_int LAPACKE_ztrsen( int matrix_order, char job, char compq,
+                           const lapack_logical* select, lapack_int n,
+                           lapack_complex_double* t, lapack_int ldt,
+                           lapack_complex_double* q, lapack_int ldq,
+                           lapack_complex_double* w, lapack_int* m, double* s,
+                           double* sep );
+
+lapack_int LAPACKE_strsna( int matrix_order, char job, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const float* t, lapack_int ldt, const float* vl,
+                           lapack_int ldvl, const float* vr, lapack_int ldvr,
+                           float* s, float* sep, lapack_int mm, lapack_int* m );
+lapack_int LAPACKE_dtrsna( int matrix_order, char job, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const double* t, lapack_int ldt, const double* vl,
+                           lapack_int ldvl, const double* vr, lapack_int ldvr,
+                           double* s, double* sep, lapack_int mm,
+                           lapack_int* m );
+lapack_int LAPACKE_ctrsna( int matrix_order, char job, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const lapack_complex_float* t, lapack_int ldt,
+                           const lapack_complex_float* vl, lapack_int ldvl,
+                           const lapack_complex_float* vr, lapack_int ldvr,
+                           float* s, float* sep, lapack_int mm, lapack_int* m );
+lapack_int LAPACKE_ztrsna( int matrix_order, char job, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const lapack_complex_double* t, lapack_int ldt,
+                           const lapack_complex_double* vl, lapack_int ldvl,
+                           const lapack_complex_double* vr, lapack_int ldvr,
+                           double* s, double* sep, lapack_int mm,
+                           lapack_int* m );
+
+lapack_int LAPACKE_strsyl( int matrix_order, char trana, char tranb,
+                           lapack_int isgn, lapack_int m, lapack_int n,
+                           const float* a, lapack_int lda, const float* b,
+                           lapack_int ldb, float* c, lapack_int ldc,
+                           float* scale );
+lapack_int LAPACKE_dtrsyl( int matrix_order, char trana, char tranb,
+                           lapack_int isgn, lapack_int m, lapack_int n,
+                           const double* a, lapack_int lda, const double* b,
+                           lapack_int ldb, double* c, lapack_int ldc,
+                           double* scale );
+lapack_int LAPACKE_ctrsyl( int matrix_order, char trana, char tranb,
+                           lapack_int isgn, lapack_int m, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* c, lapack_int ldc,
+                           float* scale );
+lapack_int LAPACKE_ztrsyl( int matrix_order, char trana, char tranb,
+                           lapack_int isgn, lapack_int m, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* c, lapack_int ldc,
+                           double* scale );
+
+lapack_int LAPACKE_strtri( int matrix_order, char uplo, char diag, lapack_int n,
+                           float* a, lapack_int lda );
+lapack_int LAPACKE_dtrtri( int matrix_order, char uplo, char diag, lapack_int n,
+                           double* a, lapack_int lda );
+lapack_int LAPACKE_ctrtri( int matrix_order, char uplo, char diag, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_ztrtri( int matrix_order, char uplo, char diag, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_strtrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs, const float* a,
+                           lapack_int lda, float* b, lapack_int ldb );
+lapack_int LAPACKE_dtrtrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs, const double* a,
+                           lapack_int lda, double* b, lapack_int ldb );
+lapack_int LAPACKE_ctrtrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_ztrtrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_strttf( int matrix_order, char transr, char uplo,
+                           lapack_int n, const float* a, lapack_int lda,
+                           float* arf );
+lapack_int LAPACKE_dtrttf( int matrix_order, char transr, char uplo,
+                           lapack_int n, const double* a, lapack_int lda,
+                           double* arf );
+lapack_int LAPACKE_ctrttf( int matrix_order, char transr, char uplo,
+                           lapack_int n, const lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* arf );
+lapack_int LAPACKE_ztrttf( int matrix_order, char transr, char uplo,
+                           lapack_int n, const lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* arf );
+
+lapack_int LAPACKE_strttp( int matrix_order, char uplo, lapack_int n,
+                           const float* a, lapack_int lda, float* ap );
+lapack_int LAPACKE_dtrttp( int matrix_order, char uplo, lapack_int n,
+                           const double* a, lapack_int lda, double* ap );
+lapack_int LAPACKE_ctrttp( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* ap );
+lapack_int LAPACKE_ztrttp( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* ap );
+
+lapack_int LAPACKE_stzrzf( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, float* tau );
+lapack_int LAPACKE_dtzrzf( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, double* tau );
+lapack_int LAPACKE_ctzrzf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* tau );
+lapack_int LAPACKE_ztzrzf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* tau );
+
+lapack_int LAPACKE_cungbr( int matrix_order, char vect, lapack_int m,
+                           lapack_int n, lapack_int k, lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* tau );
+lapack_int LAPACKE_zungbr( int matrix_order, char vect, lapack_int m,
+                           lapack_int n, lapack_int k, lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* tau );
+
+lapack_int LAPACKE_cunghr( int matrix_order, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* tau );
+lapack_int LAPACKE_zunghr( int matrix_order, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* tau );
+
+lapack_int LAPACKE_cunglq( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* tau );
+lapack_int LAPACKE_zunglq( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* tau );
+
+lapack_int LAPACKE_cungql( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* tau );
+lapack_int LAPACKE_zungql( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* tau );
+
+lapack_int LAPACKE_cungqr( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* tau );
+lapack_int LAPACKE_zungqr( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* tau );
+
+lapack_int LAPACKE_cungrq( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* tau );
+lapack_int LAPACKE_zungrq( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* tau );
+
+lapack_int LAPACKE_cungtr( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* tau );
+lapack_int LAPACKE_zungtr( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* tau );
+
+lapack_int LAPACKE_cunmbr( int matrix_order, char vect, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* tau,
+                           lapack_complex_float* c, lapack_int ldc );
+lapack_int LAPACKE_zunmbr( int matrix_order, char vect, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* tau,
+                           lapack_complex_double* c, lapack_int ldc );
+
+lapack_int LAPACKE_cunmhr( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, const lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* tau,
+                           lapack_complex_float* c, lapack_int ldc );
+lapack_int LAPACKE_zunmhr( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, const lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* tau,
+                           lapack_complex_double* c, lapack_int ldc );
+
+lapack_int LAPACKE_cunmlq( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* tau,
+                           lapack_complex_float* c, lapack_int ldc );
+lapack_int LAPACKE_zunmlq( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* tau,
+                           lapack_complex_double* c, lapack_int ldc );
+
+lapack_int LAPACKE_cunmql( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* tau,
+                           lapack_complex_float* c, lapack_int ldc );
+lapack_int LAPACKE_zunmql( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* tau,
+                           lapack_complex_double* c, lapack_int ldc );
+
+lapack_int LAPACKE_cunmqr( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* tau,
+                           lapack_complex_float* c, lapack_int ldc );
+lapack_int LAPACKE_zunmqr( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* tau,
+                           lapack_complex_double* c, lapack_int ldc );
+
+lapack_int LAPACKE_cunmrq( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* tau,
+                           lapack_complex_float* c, lapack_int ldc );
+lapack_int LAPACKE_zunmrq( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* tau,
+                           lapack_complex_double* c, lapack_int ldc );
+
+lapack_int LAPACKE_cunmrz( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           lapack_int l, const lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* tau,
+                           lapack_complex_float* c, lapack_int ldc );
+lapack_int LAPACKE_zunmrz( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           lapack_int l, const lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* tau,
+                           lapack_complex_double* c, lapack_int ldc );
+
+lapack_int LAPACKE_cunmtr( int matrix_order, char side, char uplo, char trans,
+                           lapack_int m, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* tau,
+                           lapack_complex_float* c, lapack_int ldc );
+lapack_int LAPACKE_zunmtr( int matrix_order, char side, char uplo, char trans,
+                           lapack_int m, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* tau,
+                           lapack_complex_double* c, lapack_int ldc );
+
+lapack_int LAPACKE_cupgtr( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_float* ap,
+                           const lapack_complex_float* tau,
+                           lapack_complex_float* q, lapack_int ldq );
+lapack_int LAPACKE_zupgtr( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_double* ap,
+                           const lapack_complex_double* tau,
+                           lapack_complex_double* q, lapack_int ldq );
+
+lapack_int LAPACKE_cupmtr( int matrix_order, char side, char uplo, char trans,
+                           lapack_int m, lapack_int n,
+                           const lapack_complex_float* ap,
+                           const lapack_complex_float* tau,
+                           lapack_complex_float* c, lapack_int ldc );
+lapack_int LAPACKE_zupmtr( int matrix_order, char side, char uplo, char trans,
+                           lapack_int m, lapack_int n,
+                           const lapack_complex_double* ap,
+                           const lapack_complex_double* tau,
+                           lapack_complex_double* c, lapack_int ldc );
+
+lapack_int LAPACKE_sbdsdc_work( int matrix_order, char uplo, char compq,
+                                lapack_int n, float* d, float* e, float* u,
+                                lapack_int ldu, float* vt, lapack_int ldvt,
+                                float* q, lapack_int* iq, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dbdsdc_work( int matrix_order, char uplo, char compq,
+                                lapack_int n, double* d, double* e, double* u,
+                                lapack_int ldu, double* vt, lapack_int ldvt,
+                                double* q, lapack_int* iq, double* work,
+                                lapack_int* iwork );
+
+lapack_int LAPACKE_sbdsqr_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int ncvt, lapack_int nru, lapack_int ncc,
+                                float* d, float* e, float* vt, lapack_int ldvt,
+                                float* u, lapack_int ldu, float* c,
+                                lapack_int ldc, float* work );
+lapack_int LAPACKE_dbdsqr_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int ncvt, lapack_int nru, lapack_int ncc,
+                                double* d, double* e, double* vt,
+                                lapack_int ldvt, double* u, lapack_int ldu,
+                                double* c, lapack_int ldc, double* work );
+lapack_int LAPACKE_cbdsqr_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int ncvt, lapack_int nru, lapack_int ncc,
+                                float* d, float* e, lapack_complex_float* vt,
+                                lapack_int ldvt, lapack_complex_float* u,
+                                lapack_int ldu, lapack_complex_float* c,
+                                lapack_int ldc, float* work );
+lapack_int LAPACKE_zbdsqr_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int ncvt, lapack_int nru, lapack_int ncc,
+                                double* d, double* e, lapack_complex_double* vt,
+                                lapack_int ldvt, lapack_complex_double* u,
+                                lapack_int ldu, lapack_complex_double* c,
+                                lapack_int ldc, double* work );
+
+lapack_int LAPACKE_sdisna_work( char job, lapack_int m, lapack_int n,
+                                const float* d, float* sep );
+lapack_int LAPACKE_ddisna_work( char job, lapack_int m, lapack_int n,
+                                const double* d, double* sep );
+
+lapack_int LAPACKE_sgbbrd_work( int matrix_order, char vect, lapack_int m,
+                                lapack_int n, lapack_int ncc, lapack_int kl,
+                                lapack_int ku, float* ab, lapack_int ldab,
+                                float* d, float* e, float* q, lapack_int ldq,
+                                float* pt, lapack_int ldpt, float* c,
+                                lapack_int ldc, float* work );
+lapack_int LAPACKE_dgbbrd_work( int matrix_order, char vect, lapack_int m,
+                                lapack_int n, lapack_int ncc, lapack_int kl,
+                                lapack_int ku, double* ab, lapack_int ldab,
+                                double* d, double* e, double* q, lapack_int ldq,
+                                double* pt, lapack_int ldpt, double* c,
+                                lapack_int ldc, double* work );
+lapack_int LAPACKE_cgbbrd_work( int matrix_order, char vect, lapack_int m,
+                                lapack_int n, lapack_int ncc, lapack_int kl,
+                                lapack_int ku, lapack_complex_float* ab,
+                                lapack_int ldab, float* d, float* e,
+                                lapack_complex_float* q, lapack_int ldq,
+                                lapack_complex_float* pt, lapack_int ldpt,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zgbbrd_work( int matrix_order, char vect, lapack_int m,
+                                lapack_int n, lapack_int ncc, lapack_int kl,
+                                lapack_int ku, lapack_complex_double* ab,
+                                lapack_int ldab, double* d, double* e,
+                                lapack_complex_double* q, lapack_int ldq,
+                                lapack_complex_double* pt, lapack_int ldpt,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sgbcon_work( int matrix_order, char norm, lapack_int n,
+                                lapack_int kl, lapack_int ku, const float* ab,
+                                lapack_int ldab, const lapack_int* ipiv,
+                                float anorm, float* rcond, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dgbcon_work( int matrix_order, char norm, lapack_int n,
+                                lapack_int kl, lapack_int ku, const double* ab,
+                                lapack_int ldab, const lapack_int* ipiv,
+                                double anorm, double* rcond, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_cgbcon_work( int matrix_order, char norm, lapack_int n,
+                                lapack_int kl, lapack_int ku,
+                                const lapack_complex_float* ab, lapack_int ldab,
+                                const lapack_int* ipiv, float anorm,
+                                float* rcond, lapack_complex_float* work,
+                                float* rwork );
+lapack_int LAPACKE_zgbcon_work( int matrix_order, char norm, lapack_int n,
+                                lapack_int kl, lapack_int ku,
+                                const lapack_complex_double* ab,
+                                lapack_int ldab, const lapack_int* ipiv,
+                                double anorm, double* rcond,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sgbequ_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku, const float* ab,
+                                lapack_int ldab, float* r, float* c,
+                                float* rowcnd, float* colcnd, float* amax );
+lapack_int LAPACKE_dgbequ_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku, const double* ab,
+                                lapack_int ldab, double* r, double* c,
+                                double* rowcnd, double* colcnd, double* amax );
+lapack_int LAPACKE_cgbequ_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku,
+                                const lapack_complex_float* ab, lapack_int ldab,
+                                float* r, float* c, float* rowcnd,
+                                float* colcnd, float* amax );
+lapack_int LAPACKE_zgbequ_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku,
+                                const lapack_complex_double* ab,
+                                lapack_int ldab, double* r, double* c,
+                                double* rowcnd, double* colcnd, double* amax );
+
+lapack_int LAPACKE_sgbequb_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_int kl, lapack_int ku, const float* ab,
+                                 lapack_int ldab, float* r, float* c,
+                                 float* rowcnd, float* colcnd, float* amax );
+lapack_int LAPACKE_dgbequb_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_int kl, lapack_int ku, const double* ab,
+                                 lapack_int ldab, double* r, double* c,
+                                 double* rowcnd, double* colcnd, double* amax );
+lapack_int LAPACKE_cgbequb_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_int kl, lapack_int ku,
+                                 const lapack_complex_float* ab,
+                                 lapack_int ldab, float* r, float* c,
+                                 float* rowcnd, float* colcnd, float* amax );
+lapack_int LAPACKE_zgbequb_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_int kl, lapack_int ku,
+                                 const lapack_complex_double* ab,
+                                 lapack_int ldab, double* r, double* c,
+                                 double* rowcnd, double* colcnd, double* amax );
+
+lapack_int LAPACKE_sgbrfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int kl, lapack_int ku, lapack_int nrhs,
+                                const float* ab, lapack_int ldab,
+                                const float* afb, lapack_int ldafb,
+                                const lapack_int* ipiv, const float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* ferr, float* berr, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dgbrfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int kl, lapack_int ku, lapack_int nrhs,
+                                const double* ab, lapack_int ldab,
+                                const double* afb, lapack_int ldafb,
+                                const lapack_int* ipiv, const double* b,
+                                lapack_int ldb, double* x, lapack_int ldx,
+                                double* ferr, double* berr, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_cgbrfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int kl, lapack_int ku, lapack_int nrhs,
+                                const lapack_complex_float* ab, lapack_int ldab,
+                                const lapack_complex_float* afb,
+                                lapack_int ldafb, const lapack_int* ipiv,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zgbrfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int kl, lapack_int ku, lapack_int nrhs,
+                                const lapack_complex_double* ab,
+                                lapack_int ldab,
+                                const lapack_complex_double* afb,
+                                lapack_int ldafb, const lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sgbrfsx_work( int matrix_order, char trans, char equed,
+                                 lapack_int n, lapack_int kl, lapack_int ku,
+                                 lapack_int nrhs, const float* ab,
+                                 lapack_int ldab, const float* afb,
+                                 lapack_int ldafb, const lapack_int* ipiv,
+                                 const float* r, const float* c, const float* b,
+                                 lapack_int ldb, float* x, lapack_int ldx,
+                                 float* rcond, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, float* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_dgbrfsx_work( int matrix_order, char trans, char equed,
+                                 lapack_int n, lapack_int kl, lapack_int ku,
+                                 lapack_int nrhs, const double* ab,
+                                 lapack_int ldab, const double* afb,
+                                 lapack_int ldafb, const lapack_int* ipiv,
+                                 const double* r, const double* c,
+                                 const double* b, lapack_int ldb, double* x,
+                                 lapack_int ldx, double* rcond, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, double* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_cgbrfsx_work( int matrix_order, char trans, char equed,
+                                 lapack_int n, lapack_int kl, lapack_int ku,
+                                 lapack_int nrhs,
+                                 const lapack_complex_float* ab,
+                                 lapack_int ldab,
+                                 const lapack_complex_float* afb,
+                                 lapack_int ldafb, const lapack_int* ipiv,
+                                 const float* r, const float* c,
+                                 const lapack_complex_float* b, lapack_int ldb,
+                                 lapack_complex_float* x, lapack_int ldx,
+                                 float* rcond, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, lapack_complex_float* work,
+                                 float* rwork );
+lapack_int LAPACKE_zgbrfsx_work( int matrix_order, char trans, char equed,
+                                 lapack_int n, lapack_int kl, lapack_int ku,
+                                 lapack_int nrhs,
+                                 const lapack_complex_double* ab,
+                                 lapack_int ldab,
+                                 const lapack_complex_double* afb,
+                                 lapack_int ldafb, const lapack_int* ipiv,
+                                 const double* r, const double* c,
+                                 const lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* x, lapack_int ldx,
+                                 double* rcond, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, lapack_complex_double* work,
+                                 double* rwork );
+
+lapack_int LAPACKE_sgbsv_work( int matrix_order, lapack_int n, lapack_int kl,
+                               lapack_int ku, lapack_int nrhs, float* ab,
+                               lapack_int ldab, lapack_int* ipiv, float* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_dgbsv_work( int matrix_order, lapack_int n, lapack_int kl,
+                               lapack_int ku, lapack_int nrhs, double* ab,
+                               lapack_int ldab, lapack_int* ipiv, double* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_cgbsv_work( int matrix_order, lapack_int n, lapack_int kl,
+                               lapack_int ku, lapack_int nrhs,
+                               lapack_complex_float* ab, lapack_int ldab,
+                               lapack_int* ipiv, lapack_complex_float* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_zgbsv_work( int matrix_order, lapack_int n, lapack_int kl,
+                               lapack_int ku, lapack_int nrhs,
+                               lapack_complex_double* ab, lapack_int ldab,
+                               lapack_int* ipiv, lapack_complex_double* b,
+                               lapack_int ldb );
+
+lapack_int LAPACKE_sgbsvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int kl, lapack_int ku,
+                                lapack_int nrhs, float* ab, lapack_int ldab,
+                                float* afb, lapack_int ldafb, lapack_int* ipiv,
+                                char* equed, float* r, float* c, float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* rcond, float* ferr, float* berr,
+                                float* work, lapack_int* iwork );
+lapack_int LAPACKE_dgbsvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int kl, lapack_int ku,
+                                lapack_int nrhs, double* ab, lapack_int ldab,
+                                double* afb, lapack_int ldafb, lapack_int* ipiv,
+                                char* equed, double* r, double* c, double* b,
+                                lapack_int ldb, double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_cgbsvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int kl, lapack_int ku,
+                                lapack_int nrhs, lapack_complex_float* ab,
+                                lapack_int ldab, lapack_complex_float* afb,
+                                lapack_int ldafb, lapack_int* ipiv, char* equed,
+                                float* r, float* c, lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* x,
+                                lapack_int ldx, float* rcond, float* ferr,
+                                float* berr, lapack_complex_float* work,
+                                float* rwork );
+lapack_int LAPACKE_zgbsvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int kl, lapack_int ku,
+                                lapack_int nrhs, lapack_complex_double* ab,
+                                lapack_int ldab, lapack_complex_double* afb,
+                                lapack_int ldafb, lapack_int* ipiv, char* equed,
+                                double* r, double* c, lapack_complex_double* b,
+                                lapack_int ldb, lapack_complex_double* x,
+                                lapack_int ldx, double* rcond, double* ferr,
+                                double* berr, lapack_complex_double* work,
+                                double* rwork );
+
+lapack_int LAPACKE_sgbsvxx_work( int matrix_order, char fact, char trans,
+                                 lapack_int n, lapack_int kl, lapack_int ku,
+                                 lapack_int nrhs, float* ab, lapack_int ldab,
+                                 float* afb, lapack_int ldafb, lapack_int* ipiv,
+                                 char* equed, float* r, float* c, float* b,
+                                 lapack_int ldb, float* x, lapack_int ldx,
+                                 float* rcond, float* rpvgrw, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, float* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_dgbsvxx_work( int matrix_order, char fact, char trans,
+                                 lapack_int n, lapack_int kl, lapack_int ku,
+                                 lapack_int nrhs, double* ab, lapack_int ldab,
+                                 double* afb, lapack_int ldafb,
+                                 lapack_int* ipiv, char* equed, double* r,
+                                 double* c, double* b, lapack_int ldb,
+                                 double* x, lapack_int ldx, double* rcond,
+                                 double* rpvgrw, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, double* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_cgbsvxx_work( int matrix_order, char fact, char trans,
+                                 lapack_int n, lapack_int kl, lapack_int ku,
+                                 lapack_int nrhs, lapack_complex_float* ab,
+                                 lapack_int ldab, lapack_complex_float* afb,
+                                 lapack_int ldafb, lapack_int* ipiv,
+                                 char* equed, float* r, float* c,
+                                 lapack_complex_float* b, lapack_int ldb,
+                                 lapack_complex_float* x, lapack_int ldx,
+                                 float* rcond, float* rpvgrw, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, lapack_complex_float* work,
+                                 float* rwork );
+lapack_int LAPACKE_zgbsvxx_work( int matrix_order, char fact, char trans,
+                                 lapack_int n, lapack_int kl, lapack_int ku,
+                                 lapack_int nrhs, lapack_complex_double* ab,
+                                 lapack_int ldab, lapack_complex_double* afb,
+                                 lapack_int ldafb, lapack_int* ipiv,
+                                 char* equed, double* r, double* c,
+                                 lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* x, lapack_int ldx,
+                                 double* rcond, double* rpvgrw, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, lapack_complex_double* work,
+                                 double* rwork );
+
+lapack_int LAPACKE_sgbtrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku, float* ab,
+                                lapack_int ldab, lapack_int* ipiv );
+lapack_int LAPACKE_dgbtrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku, double* ab,
+                                lapack_int ldab, lapack_int* ipiv );
+lapack_int LAPACKE_cgbtrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku,
+                                lapack_complex_float* ab, lapack_int ldab,
+                                lapack_int* ipiv );
+lapack_int LAPACKE_zgbtrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku,
+                                lapack_complex_double* ab, lapack_int ldab,
+                                lapack_int* ipiv );
+
+lapack_int LAPACKE_sgbtrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int kl, lapack_int ku, lapack_int nrhs,
+                                const float* ab, lapack_int ldab,
+                                const lapack_int* ipiv, float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_dgbtrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int kl, lapack_int ku, lapack_int nrhs,
+                                const double* ab, lapack_int ldab,
+                                const lapack_int* ipiv, double* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_cgbtrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int kl, lapack_int ku, lapack_int nrhs,
+                                const lapack_complex_float* ab, lapack_int ldab,
+                                const lapack_int* ipiv, lapack_complex_float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_zgbtrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int kl, lapack_int ku, lapack_int nrhs,
+                                const lapack_complex_double* ab,
+                                lapack_int ldab, const lapack_int* ipiv,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_sgebak_work( int matrix_order, char job, char side,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                const float* scale, lapack_int m, float* v,
+                                lapack_int ldv );
+lapack_int LAPACKE_dgebak_work( int matrix_order, char job, char side,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                const double* scale, lapack_int m, double* v,
+                                lapack_int ldv );
+lapack_int LAPACKE_cgebak_work( int matrix_order, char job, char side,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                const float* scale, lapack_int m,
+                                lapack_complex_float* v, lapack_int ldv );
+lapack_int LAPACKE_zgebak_work( int matrix_order, char job, char side,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                const double* scale, lapack_int m,
+                                lapack_complex_double* v, lapack_int ldv );
+
+lapack_int LAPACKE_sgebal_work( int matrix_order, char job, lapack_int n,
+                                float* a, lapack_int lda, lapack_int* ilo,
+                                lapack_int* ihi, float* scale );
+lapack_int LAPACKE_dgebal_work( int matrix_order, char job, lapack_int n,
+                                double* a, lapack_int lda, lapack_int* ilo,
+                                lapack_int* ihi, double* scale );
+lapack_int LAPACKE_cgebal_work( int matrix_order, char job, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_int* ilo, lapack_int* ihi,
+                                float* scale );
+lapack_int LAPACKE_zgebal_work( int matrix_order, char job, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int* ilo, lapack_int* ihi,
+                                double* scale );
+
+lapack_int LAPACKE_sgebrd_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, float* d, float* e,
+                                float* tauq, float* taup, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dgebrd_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, double* d, double* e,
+                                double* tauq, double* taup, double* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_cgebrd_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                float* d, float* e, lapack_complex_float* tauq,
+                                lapack_complex_float* taup,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zgebrd_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                double* d, double* e,
+                                lapack_complex_double* tauq,
+                                lapack_complex_double* taup,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sgecon_work( int matrix_order, char norm, lapack_int n,
+                                const float* a, lapack_int lda, float anorm,
+                                float* rcond, float* work, lapack_int* iwork );
+lapack_int LAPACKE_dgecon_work( int matrix_order, char norm, lapack_int n,
+                                const double* a, lapack_int lda, double anorm,
+                                double* rcond, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_cgecon_work( int matrix_order, char norm, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                float anorm, float* rcond,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zgecon_work( int matrix_order, char norm, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                double anorm, double* rcond,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sgeequ_work( int matrix_order, lapack_int m, lapack_int n,
+                                const float* a, lapack_int lda, float* r,
+                                float* c, float* rowcnd, float* colcnd,
+                                float* amax );
+lapack_int LAPACKE_dgeequ_work( int matrix_order, lapack_int m, lapack_int n,
+                                const double* a, lapack_int lda, double* r,
+                                double* c, double* rowcnd, double* colcnd,
+                                double* amax );
+lapack_int LAPACKE_cgeequ_work( int matrix_order, lapack_int m, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                float* r, float* c, float* rowcnd,
+                                float* colcnd, float* amax );
+lapack_int LAPACKE_zgeequ_work( int matrix_order, lapack_int m, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                double* r, double* c, double* rowcnd,
+                                double* colcnd, double* amax );
+
+lapack_int LAPACKE_sgeequb_work( int matrix_order, lapack_int m, lapack_int n,
+                                 const float* a, lapack_int lda, float* r,
+                                 float* c, float* rowcnd, float* colcnd,
+                                 float* amax );
+lapack_int LAPACKE_dgeequb_work( int matrix_order, lapack_int m, lapack_int n,
+                                 const double* a, lapack_int lda, double* r,
+                                 double* c, double* rowcnd, double* colcnd,
+                                 double* amax );
+lapack_int LAPACKE_cgeequb_work( int matrix_order, lapack_int m, lapack_int n,
+                                 const lapack_complex_float* a, lapack_int lda,
+                                 float* r, float* c, float* rowcnd,
+                                 float* colcnd, float* amax );
+lapack_int LAPACKE_zgeequb_work( int matrix_order, lapack_int m, lapack_int n,
+                                 const lapack_complex_double* a, lapack_int lda,
+                                 double* r, double* c, double* rowcnd,
+                                 double* colcnd, double* amax );
+
+lapack_int LAPACKE_sgees_work( int matrix_order, char jobvs, char sort,
+                               LAPACK_S_SELECT2 select, lapack_int n, float* a,
+                               lapack_int lda, lapack_int* sdim, float* wr,
+                               float* wi, float* vs, lapack_int ldvs,
+                               float* work, lapack_int lwork,
+                               lapack_logical* bwork );
+lapack_int LAPACKE_dgees_work( int matrix_order, char jobvs, char sort,
+                               LAPACK_D_SELECT2 select, lapack_int n, double* a,
+                               lapack_int lda, lapack_int* sdim, double* wr,
+                               double* wi, double* vs, lapack_int ldvs,
+                               double* work, lapack_int lwork,
+                               lapack_logical* bwork );
+lapack_int LAPACKE_cgees_work( int matrix_order, char jobvs, char sort,
+                               LAPACK_C_SELECT1 select, lapack_int n,
+                               lapack_complex_float* a, lapack_int lda,
+                               lapack_int* sdim, lapack_complex_float* w,
+                               lapack_complex_float* vs, lapack_int ldvs,
+                               lapack_complex_float* work, lapack_int lwork,
+                               float* rwork, lapack_logical* bwork );
+lapack_int LAPACKE_zgees_work( int matrix_order, char jobvs, char sort,
+                               LAPACK_Z_SELECT1 select, lapack_int n,
+                               lapack_complex_double* a, lapack_int lda,
+                               lapack_int* sdim, lapack_complex_double* w,
+                               lapack_complex_double* vs, lapack_int ldvs,
+                               lapack_complex_double* work, lapack_int lwork,
+                               double* rwork, lapack_logical* bwork );
+
+lapack_int LAPACKE_sgeesx_work( int matrix_order, char jobvs, char sort,
+                                LAPACK_S_SELECT2 select, char sense,
+                                lapack_int n, float* a, lapack_int lda,
+                                lapack_int* sdim, float* wr, float* wi,
+                                float* vs, lapack_int ldvs, float* rconde,
+                                float* rcondv, float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork,
+                                lapack_logical* bwork );
+lapack_int LAPACKE_dgeesx_work( int matrix_order, char jobvs, char sort,
+                                LAPACK_D_SELECT2 select, char sense,
+                                lapack_int n, double* a, lapack_int lda,
+                                lapack_int* sdim, double* wr, double* wi,
+                                double* vs, lapack_int ldvs, double* rconde,
+                                double* rcondv, double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork,
+                                lapack_logical* bwork );
+lapack_int LAPACKE_cgeesx_work( int matrix_order, char jobvs, char sort,
+                                LAPACK_C_SELECT1 select, char sense,
+                                lapack_int n, lapack_complex_float* a,
+                                lapack_int lda, lapack_int* sdim,
+                                lapack_complex_float* w,
+                                lapack_complex_float* vs, lapack_int ldvs,
+                                float* rconde, float* rcondv,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork, lapack_logical* bwork );
+lapack_int LAPACKE_zgeesx_work( int matrix_order, char jobvs, char sort,
+                                LAPACK_Z_SELECT1 select, char sense,
+                                lapack_int n, lapack_complex_double* a,
+                                lapack_int lda, lapack_int* sdim,
+                                lapack_complex_double* w,
+                                lapack_complex_double* vs, lapack_int ldvs,
+                                double* rconde, double* rcondv,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork, lapack_logical* bwork );
+
+lapack_int LAPACKE_sgeev_work( int matrix_order, char jobvl, char jobvr,
+                               lapack_int n, float* a, lapack_int lda,
+                               float* wr, float* wi, float* vl, lapack_int ldvl,
+                               float* vr, lapack_int ldvr, float* work,
+                               lapack_int lwork );
+lapack_int LAPACKE_dgeev_work( int matrix_order, char jobvl, char jobvr,
+                               lapack_int n, double* a, lapack_int lda,
+                               double* wr, double* wi, double* vl,
+                               lapack_int ldvl, double* vr, lapack_int ldvr,
+                               double* work, lapack_int lwork );
+lapack_int LAPACKE_cgeev_work( int matrix_order, char jobvl, char jobvr,
+                               lapack_int n, lapack_complex_float* a,
+                               lapack_int lda, lapack_complex_float* w,
+                               lapack_complex_float* vl, lapack_int ldvl,
+                               lapack_complex_float* vr, lapack_int ldvr,
+                               lapack_complex_float* work, lapack_int lwork,
+                               float* rwork );
+lapack_int LAPACKE_zgeev_work( int matrix_order, char jobvl, char jobvr,
+                               lapack_int n, lapack_complex_double* a,
+                               lapack_int lda, lapack_complex_double* w,
+                               lapack_complex_double* vl, lapack_int ldvl,
+                               lapack_complex_double* vr, lapack_int ldvr,
+                               lapack_complex_double* work, lapack_int lwork,
+                               double* rwork );
+
+lapack_int LAPACKE_sgeevx_work( int matrix_order, char balanc, char jobvl,
+                                char jobvr, char sense, lapack_int n, float* a,
+                                lapack_int lda, float* wr, float* wi, float* vl,
+                                lapack_int ldvl, float* vr, lapack_int ldvr,
+                                lapack_int* ilo, lapack_int* ihi, float* scale,
+                                float* abnrm, float* rconde, float* rcondv,
+                                float* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dgeevx_work( int matrix_order, char balanc, char jobvl,
+                                char jobvr, char sense, lapack_int n, double* a,
+                                lapack_int lda, double* wr, double* wi,
+                                double* vl, lapack_int ldvl, double* vr,
+                                lapack_int ldvr, lapack_int* ilo,
+                                lapack_int* ihi, double* scale, double* abnrm,
+                                double* rconde, double* rcondv, double* work,
+                                lapack_int lwork, lapack_int* iwork );
+lapack_int LAPACKE_cgeevx_work( int matrix_order, char balanc, char jobvl,
+                                char jobvr, char sense, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* w,
+                                lapack_complex_float* vl, lapack_int ldvl,
+                                lapack_complex_float* vr, lapack_int ldvr,
+                                lapack_int* ilo, lapack_int* ihi, float* scale,
+                                float* abnrm, float* rconde, float* rcondv,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork );
+lapack_int LAPACKE_zgeevx_work( int matrix_order, char balanc, char jobvl,
+                                char jobvr, char sense, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* w,
+                                lapack_complex_double* vl, lapack_int ldvl,
+                                lapack_complex_double* vr, lapack_int ldvr,
+                                lapack_int* ilo, lapack_int* ihi, double* scale,
+                                double* abnrm, double* rconde, double* rcondv,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork );
+
+lapack_int LAPACKE_sgehrd_work( int matrix_order, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, float* a, lapack_int lda,
+                                float* tau, float* work, lapack_int lwork );
+lapack_int LAPACKE_dgehrd_work( int matrix_order, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, double* a, lapack_int lda,
+                                double* tau, double* work, lapack_int lwork );
+lapack_int LAPACKE_cgehrd_work( int matrix_order, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zgehrd_work( int matrix_order, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sgejsv_work( int matrix_order, char joba, char jobu,
+                                char jobv, char jobr, char jobt, char jobp,
+                                lapack_int m, lapack_int n, float* a,
+                                lapack_int lda, float* sva, float* u,
+                                lapack_int ldu, float* v, lapack_int ldv,
+                                float* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dgejsv_work( int matrix_order, char joba, char jobu,
+                                char jobv, char jobr, char jobt, char jobp,
+                                lapack_int m, lapack_int n, double* a,
+                                lapack_int lda, double* sva, double* u,
+                                lapack_int ldu, double* v, lapack_int ldv,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork );
+
+lapack_int LAPACKE_sgelq2_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, float* tau,
+                                float* work );
+lapack_int LAPACKE_dgelq2_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, double* tau,
+                                double* work );
+lapack_int LAPACKE_cgelq2_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* tau,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zgelq2_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* tau,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_sgelqf_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, float* tau,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dgelqf_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, double* tau,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_cgelqf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zgelqf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sgels_work( int matrix_order, char trans, lapack_int m,
+                               lapack_int n, lapack_int nrhs, float* a,
+                               lapack_int lda, float* b, lapack_int ldb,
+                               float* work, lapack_int lwork );
+lapack_int LAPACKE_dgels_work( int matrix_order, char trans, lapack_int m,
+                               lapack_int n, lapack_int nrhs, double* a,
+                               lapack_int lda, double* b, lapack_int ldb,
+                               double* work, lapack_int lwork );
+lapack_int LAPACKE_cgels_work( int matrix_order, char trans, lapack_int m,
+                               lapack_int n, lapack_int nrhs,
+                               lapack_complex_float* a, lapack_int lda,
+                               lapack_complex_float* b, lapack_int ldb,
+                               lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zgels_work( int matrix_order, char trans, lapack_int m,
+                               lapack_int n, lapack_int nrhs,
+                               lapack_complex_double* a, lapack_int lda,
+                               lapack_complex_double* b, lapack_int ldb,
+                               lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sgelsd_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, float* a, lapack_int lda,
+                                float* b, lapack_int ldb, float* s, float rcond,
+                                lapack_int* rank, float* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dgelsd_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, double* a, lapack_int lda,
+                                double* b, lapack_int ldb, double* s,
+                                double rcond, lapack_int* rank, double* work,
+                                lapack_int lwork, lapack_int* iwork );
+lapack_int LAPACKE_cgelsd_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* b,
+                                lapack_int ldb, float* s, float rcond,
+                                lapack_int* rank, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_zgelsd_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* b,
+                                lapack_int ldb, double* s, double rcond,
+                                lapack_int* rank, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork,
+                                lapack_int* iwork );
+
+lapack_int LAPACKE_sgelss_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, float* a, lapack_int lda,
+                                float* b, lapack_int ldb, float* s, float rcond,
+                                lapack_int* rank, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dgelss_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, double* a, lapack_int lda,
+                                double* b, lapack_int ldb, double* s,
+                                double rcond, lapack_int* rank, double* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_cgelss_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* b,
+                                lapack_int ldb, float* s, float rcond,
+                                lapack_int* rank, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork );
+lapack_int LAPACKE_zgelss_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* b,
+                                lapack_int ldb, double* s, double rcond,
+                                lapack_int* rank, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork );
+
+lapack_int LAPACKE_sgelsy_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, float* a, lapack_int lda,
+                                float* b, lapack_int ldb, lapack_int* jpvt,
+                                float rcond, lapack_int* rank, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dgelsy_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, double* a, lapack_int lda,
+                                double* b, lapack_int ldb, lapack_int* jpvt,
+                                double rcond, lapack_int* rank, double* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_cgelsy_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* b,
+                                lapack_int ldb, lapack_int* jpvt, float rcond,
+                                lapack_int* rank, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork );
+lapack_int LAPACKE_zgelsy_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* b,
+                                lapack_int ldb, lapack_int* jpvt, double rcond,
+                                lapack_int* rank, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork );
+
+lapack_int LAPACKE_sgeqlf_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, float* tau,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dgeqlf_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, double* tau,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_cgeqlf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zgeqlf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sgeqp3_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, lapack_int* jpvt,
+                                float* tau, float* work, lapack_int lwork );
+lapack_int LAPACKE_dgeqp3_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, lapack_int* jpvt,
+                                double* tau, double* work, lapack_int lwork );
+lapack_int LAPACKE_cgeqp3_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_int* jpvt, lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork );
+lapack_int LAPACKE_zgeqp3_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int* jpvt, lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork );
+
+lapack_int LAPACKE_sgeqpf_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, lapack_int* jpvt,
+                                float* tau, float* work );
+lapack_int LAPACKE_dgeqpf_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, lapack_int* jpvt,
+                                double* tau, double* work );
+lapack_int LAPACKE_cgeqpf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_int* jpvt, lapack_complex_float* tau,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zgeqpf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int* jpvt, lapack_complex_double* tau,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sgeqr2_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, float* tau,
+                                float* work );
+lapack_int LAPACKE_dgeqr2_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, double* tau,
+                                double* work );
+lapack_int LAPACKE_cgeqr2_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* tau,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zgeqr2_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* tau,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_sgeqrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, float* tau,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dgeqrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, double* tau,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_cgeqrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zgeqrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sgeqrfp_work( int matrix_order, lapack_int m, lapack_int n,
+                                 float* a, lapack_int lda, float* tau,
+                                 float* work, lapack_int lwork );
+lapack_int LAPACKE_dgeqrfp_work( int matrix_order, lapack_int m, lapack_int n,
+                                 double* a, lapack_int lda, double* tau,
+                                 double* work, lapack_int lwork );
+lapack_int LAPACKE_cgeqrfp_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 lapack_complex_float* tau,
+                                 lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zgeqrfp_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 lapack_complex_double* tau,
+                                 lapack_complex_double* work,
+                                 lapack_int lwork );
+
+lapack_int LAPACKE_sgerfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const float* a, lapack_int lda,
+                                const float* af, lapack_int ldaf,
+                                const lapack_int* ipiv, const float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* ferr, float* berr, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dgerfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const double* a,
+                                lapack_int lda, const double* af,
+                                lapack_int ldaf, const lapack_int* ipiv,
+                                const double* b, lapack_int ldb, double* x,
+                                lapack_int ldx, double* ferr, double* berr,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_cgerfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* af,
+                                lapack_int ldaf, const lapack_int* ipiv,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zgerfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_double* a,
+                                lapack_int lda, const lapack_complex_double* af,
+                                lapack_int ldaf, const lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sgerfsx_work( int matrix_order, char trans, char equed,
+                                 lapack_int n, lapack_int nrhs, const float* a,
+                                 lapack_int lda, const float* af,
+                                 lapack_int ldaf, const lapack_int* ipiv,
+                                 const float* r, const float* c, const float* b,
+                                 lapack_int ldb, float* x, lapack_int ldx,
+                                 float* rcond, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, float* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_dgerfsx_work( int matrix_order, char trans, char equed,
+                                 lapack_int n, lapack_int nrhs, const double* a,
+                                 lapack_int lda, const double* af,
+                                 lapack_int ldaf, const lapack_int* ipiv,
+                                 const double* r, const double* c,
+                                 const double* b, lapack_int ldb, double* x,
+                                 lapack_int ldx, double* rcond, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, double* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_cgerfsx_work( int matrix_order, char trans, char equed,
+                                 lapack_int n, lapack_int nrhs,
+                                 const lapack_complex_float* a, lapack_int lda,
+                                 const lapack_complex_float* af,
+                                 lapack_int ldaf, const lapack_int* ipiv,
+                                 const float* r, const float* c,
+                                 const lapack_complex_float* b, lapack_int ldb,
+                                 lapack_complex_float* x, lapack_int ldx,
+                                 float* rcond, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, lapack_complex_float* work,
+                                 float* rwork );
+lapack_int LAPACKE_zgerfsx_work( int matrix_order, char trans, char equed,
+                                 lapack_int n, lapack_int nrhs,
+                                 const lapack_complex_double* a, lapack_int lda,
+                                 const lapack_complex_double* af,
+                                 lapack_int ldaf, const lapack_int* ipiv,
+                                 const double* r, const double* c,
+                                 const lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* x, lapack_int ldx,
+                                 double* rcond, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, lapack_complex_double* work,
+                                 double* rwork );
+
+lapack_int LAPACKE_sgerqf_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, float* tau,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dgerqf_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, double* tau,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_cgerqf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zgerqf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sgesdd_work( int matrix_order, char jobz, lapack_int m,
+                                lapack_int n, float* a, lapack_int lda,
+                                float* s, float* u, lapack_int ldu, float* vt,
+                                lapack_int ldvt, float* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dgesdd_work( int matrix_order, char jobz, lapack_int m,
+                                lapack_int n, double* a, lapack_int lda,
+                                double* s, double* u, lapack_int ldu,
+                                double* vt, lapack_int ldvt, double* work,
+                                lapack_int lwork, lapack_int* iwork );
+lapack_int LAPACKE_cgesdd_work( int matrix_order, char jobz, lapack_int m,
+                                lapack_int n, lapack_complex_float* a,
+                                lapack_int lda, float* s,
+                                lapack_complex_float* u, lapack_int ldu,
+                                lapack_complex_float* vt, lapack_int ldvt,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork, lapack_int* iwork );
+lapack_int LAPACKE_zgesdd_work( int matrix_order, char jobz, lapack_int m,
+                                lapack_int n, lapack_complex_double* a,
+                                lapack_int lda, double* s,
+                                lapack_complex_double* u, lapack_int ldu,
+                                lapack_complex_double* vt, lapack_int ldvt,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork, lapack_int* iwork );
+
+lapack_int LAPACKE_sgesv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               float* a, lapack_int lda, lapack_int* ipiv,
+                               float* b, lapack_int ldb );
+lapack_int LAPACKE_dgesv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               double* a, lapack_int lda, lapack_int* ipiv,
+                               double* b, lapack_int ldb );
+lapack_int LAPACKE_cgesv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               lapack_complex_float* a, lapack_int lda,
+                               lapack_int* ipiv, lapack_complex_float* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_zgesv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               lapack_complex_double* a, lapack_int lda,
+                               lapack_int* ipiv, lapack_complex_double* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_dsgesv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                                double* a, lapack_int lda, lapack_int* ipiv,
+                                double* b, lapack_int ldb, double* x,
+                                lapack_int ldx, double* work, float* swork,
+                                lapack_int* iter );
+lapack_int LAPACKE_zcgesv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int* ipiv, lapack_complex_double* b,
+                                lapack_int ldb, lapack_complex_double* x,
+                                lapack_int ldx, lapack_complex_double* work,
+                                lapack_complex_float* swork, double* rwork,
+                                lapack_int* iter );
+
+lapack_int LAPACKE_sgesvd_work( int matrix_order, char jobu, char jobvt,
+                                lapack_int m, lapack_int n, float* a,
+                                lapack_int lda, float* s, float* u,
+                                lapack_int ldu, float* vt, lapack_int ldvt,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dgesvd_work( int matrix_order, char jobu, char jobvt,
+                                lapack_int m, lapack_int n, double* a,
+                                lapack_int lda, double* s, double* u,
+                                lapack_int ldu, double* vt, lapack_int ldvt,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_cgesvd_work( int matrix_order, char jobu, char jobvt,
+                                lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                float* s, lapack_complex_float* u,
+                                lapack_int ldu, lapack_complex_float* vt,
+                                lapack_int ldvt, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork );
+lapack_int LAPACKE_zgesvd_work( int matrix_order, char jobu, char jobvt,
+                                lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                double* s, lapack_complex_double* u,
+                                lapack_int ldu, lapack_complex_double* vt,
+                                lapack_int ldvt, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork );
+
+lapack_int LAPACKE_sgesvj_work( int matrix_order, char joba, char jobu,
+                                char jobv, lapack_int m, lapack_int n, float* a,
+                                lapack_int lda, float* sva, lapack_int mv,
+                                float* v, lapack_int ldv, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dgesvj_work( int matrix_order, char joba, char jobu,
+                                char jobv, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, double* sva,
+                                lapack_int mv, double* v, lapack_int ldv,
+                                double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sgesvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int nrhs, float* a,
+                                lapack_int lda, float* af, lapack_int ldaf,
+                                lapack_int* ipiv, char* equed, float* r,
+                                float* c, float* b, lapack_int ldb, float* x,
+                                lapack_int ldx, float* rcond, float* ferr,
+                                float* berr, float* work, lapack_int* iwork );
+lapack_int LAPACKE_dgesvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int nrhs, double* a,
+                                lapack_int lda, double* af, lapack_int ldaf,
+                                lapack_int* ipiv, char* equed, double* r,
+                                double* c, double* b, lapack_int ldb, double* x,
+                                lapack_int ldx, double* rcond, double* ferr,
+                                double* berr, double* work, lapack_int* iwork );
+lapack_int LAPACKE_cgesvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int nrhs,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* af, lapack_int ldaf,
+                                lapack_int* ipiv, char* equed, float* r,
+                                float* c, lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* x,
+                                lapack_int ldx, float* rcond, float* ferr,
+                                float* berr, lapack_complex_float* work,
+                                float* rwork );
+lapack_int LAPACKE_zgesvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int nrhs,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* af, lapack_int ldaf,
+                                lapack_int* ipiv, char* equed, double* r,
+                                double* c, lapack_complex_double* b,
+                                lapack_int ldb, lapack_complex_double* x,
+                                lapack_int ldx, double* rcond, double* ferr,
+                                double* berr, lapack_complex_double* work,
+                                double* rwork );
+
+lapack_int LAPACKE_sgesvxx_work( int matrix_order, char fact, char trans,
+                                 lapack_int n, lapack_int nrhs, float* a,
+                                 lapack_int lda, float* af, lapack_int ldaf,
+                                 lapack_int* ipiv, char* equed, float* r,
+                                 float* c, float* b, lapack_int ldb, float* x,
+                                 lapack_int ldx, float* rcond, float* rpvgrw,
+                                 float* berr, lapack_int n_err_bnds,
+                                 float* err_bnds_norm, float* err_bnds_comp,
+                                 lapack_int nparams, float* params, float* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_dgesvxx_work( int matrix_order, char fact, char trans,
+                                 lapack_int n, lapack_int nrhs, double* a,
+                                 lapack_int lda, double* af, lapack_int ldaf,
+                                 lapack_int* ipiv, char* equed, double* r,
+                                 double* c, double* b, lapack_int ldb,
+                                 double* x, lapack_int ldx, double* rcond,
+                                 double* rpvgrw, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, double* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_cgesvxx_work( int matrix_order, char fact, char trans,
+                                 lapack_int n, lapack_int nrhs,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 lapack_complex_float* af, lapack_int ldaf,
+                                 lapack_int* ipiv, char* equed, float* r,
+                                 float* c, lapack_complex_float* b,
+                                 lapack_int ldb, lapack_complex_float* x,
+                                 lapack_int ldx, float* rcond, float* rpvgrw,
+                                 float* berr, lapack_int n_err_bnds,
+                                 float* err_bnds_norm, float* err_bnds_comp,
+                                 lapack_int nparams, float* params,
+                                 lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zgesvxx_work( int matrix_order, char fact, char trans,
+                                 lapack_int n, lapack_int nrhs,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 lapack_complex_double* af, lapack_int ldaf,
+                                 lapack_int* ipiv, char* equed, double* r,
+                                 double* c, lapack_complex_double* b,
+                                 lapack_int ldb, lapack_complex_double* x,
+                                 lapack_int ldx, double* rcond, double* rpvgrw,
+                                 double* berr, lapack_int n_err_bnds,
+                                 double* err_bnds_norm, double* err_bnds_comp,
+                                 lapack_int nparams, double* params,
+                                 lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sgetf2_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, lapack_int* ipiv );
+lapack_int LAPACKE_dgetf2_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, lapack_int* ipiv );
+lapack_int LAPACKE_cgetf2_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_int* ipiv );
+lapack_int LAPACKE_zgetf2_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int* ipiv );
+
+lapack_int LAPACKE_sgetrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, lapack_int* ipiv );
+lapack_int LAPACKE_dgetrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, lapack_int* ipiv );
+lapack_int LAPACKE_cgetrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_int* ipiv );
+lapack_int LAPACKE_zgetrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int* ipiv );
+
+lapack_int LAPACKE_sgetri_work( int matrix_order, lapack_int n, float* a,
+                                lapack_int lda, const lapack_int* ipiv,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dgetri_work( int matrix_order, lapack_int n, double* a,
+                                lapack_int lda, const lapack_int* ipiv,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_cgetri_work( int matrix_order, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                const lapack_int* ipiv,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zgetri_work( int matrix_order, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                const lapack_int* ipiv,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sgetrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const float* a, lapack_int lda,
+                                const lapack_int* ipiv, float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_dgetrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const double* a,
+                                lapack_int lda, const lapack_int* ipiv,
+                                double* b, lapack_int ldb );
+lapack_int LAPACKE_cgetrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* a,
+                                lapack_int lda, const lapack_int* ipiv,
+                                lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zgetrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_double* a,
+                                lapack_int lda, const lapack_int* ipiv,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_sggbak_work( int matrix_order, char job, char side,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                const float* lscale, const float* rscale,
+                                lapack_int m, float* v, lapack_int ldv );
+lapack_int LAPACKE_dggbak_work( int matrix_order, char job, char side,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                const double* lscale, const double* rscale,
+                                lapack_int m, double* v, lapack_int ldv );
+lapack_int LAPACKE_cggbak_work( int matrix_order, char job, char side,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                const float* lscale, const float* rscale,
+                                lapack_int m, lapack_complex_float* v,
+                                lapack_int ldv );
+lapack_int LAPACKE_zggbak_work( int matrix_order, char job, char side,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                const double* lscale, const double* rscale,
+                                lapack_int m, lapack_complex_double* v,
+                                lapack_int ldv );
+
+lapack_int LAPACKE_sggbal_work( int matrix_order, char job, lapack_int n,
+                                float* a, lapack_int lda, float* b,
+                                lapack_int ldb, lapack_int* ilo,
+                                lapack_int* ihi, float* lscale, float* rscale,
+                                float* work );
+lapack_int LAPACKE_dggbal_work( int matrix_order, char job, lapack_int n,
+                                double* a, lapack_int lda, double* b,
+                                lapack_int ldb, lapack_int* ilo,
+                                lapack_int* ihi, double* lscale, double* rscale,
+                                double* work );
+lapack_int LAPACKE_cggbal_work( int matrix_order, char job, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb,
+                                lapack_int* ilo, lapack_int* ihi, float* lscale,
+                                float* rscale, float* work );
+lapack_int LAPACKE_zggbal_work( int matrix_order, char job, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                lapack_int* ilo, lapack_int* ihi,
+                                double* lscale, double* rscale, double* work );
+
+lapack_int LAPACKE_sgges_work( int matrix_order, char jobvsl, char jobvsr,
+                               char sort, LAPACK_S_SELECT3 selctg, lapack_int n,
+                               float* a, lapack_int lda, float* b,
+                               lapack_int ldb, lapack_int* sdim, float* alphar,
+                               float* alphai, float* beta, float* vsl,
+                               lapack_int ldvsl, float* vsr, lapack_int ldvsr,
+                               float* work, lapack_int lwork,
+                               lapack_logical* bwork );
+lapack_int LAPACKE_dgges_work( int matrix_order, char jobvsl, char jobvsr,
+                               char sort, LAPACK_D_SELECT3 selctg, lapack_int n,
+                               double* a, lapack_int lda, double* b,
+                               lapack_int ldb, lapack_int* sdim, double* alphar,
+                               double* alphai, double* beta, double* vsl,
+                               lapack_int ldvsl, double* vsr, lapack_int ldvsr,
+                               double* work, lapack_int lwork,
+                               lapack_logical* bwork );
+lapack_int LAPACKE_cgges_work( int matrix_order, char jobvsl, char jobvsr,
+                               char sort, LAPACK_C_SELECT2 selctg, lapack_int n,
+                               lapack_complex_float* a, lapack_int lda,
+                               lapack_complex_float* b, lapack_int ldb,
+                               lapack_int* sdim, lapack_complex_float* alpha,
+                               lapack_complex_float* beta,
+                               lapack_complex_float* vsl, lapack_int ldvsl,
+                               lapack_complex_float* vsr, lapack_int ldvsr,
+                               lapack_complex_float* work, lapack_int lwork,
+                               float* rwork, lapack_logical* bwork );
+lapack_int LAPACKE_zgges_work( int matrix_order, char jobvsl, char jobvsr,
+                               char sort, LAPACK_Z_SELECT2 selctg, lapack_int n,
+                               lapack_complex_double* a, lapack_int lda,
+                               lapack_complex_double* b, lapack_int ldb,
+                               lapack_int* sdim, lapack_complex_double* alpha,
+                               lapack_complex_double* beta,
+                               lapack_complex_double* vsl, lapack_int ldvsl,
+                               lapack_complex_double* vsr, lapack_int ldvsr,
+                               lapack_complex_double* work, lapack_int lwork,
+                               double* rwork, lapack_logical* bwork );
+
+lapack_int LAPACKE_sggesx_work( int matrix_order, char jobvsl, char jobvsr,
+                                char sort, LAPACK_S_SELECT3 selctg, char sense,
+                                lapack_int n, float* a, lapack_int lda,
+                                float* b, lapack_int ldb, lapack_int* sdim,
+                                float* alphar, float* alphai, float* beta,
+                                float* vsl, lapack_int ldvsl, float* vsr,
+                                lapack_int ldvsr, float* rconde, float* rcondv,
+                                float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork,
+                                lapack_logical* bwork );
+lapack_int LAPACKE_dggesx_work( int matrix_order, char jobvsl, char jobvsr,
+                                char sort, LAPACK_D_SELECT3 selctg, char sense,
+                                lapack_int n, double* a, lapack_int lda,
+                                double* b, lapack_int ldb, lapack_int* sdim,
+                                double* alphar, double* alphai, double* beta,
+                                double* vsl, lapack_int ldvsl, double* vsr,
+                                lapack_int ldvsr, double* rconde,
+                                double* rcondv, double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork,
+                                lapack_logical* bwork );
+lapack_int LAPACKE_cggesx_work( int matrix_order, char jobvsl, char jobvsr,
+                                char sort, LAPACK_C_SELECT2 selctg, char sense,
+                                lapack_int n, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* b,
+                                lapack_int ldb, lapack_int* sdim,
+                                lapack_complex_float* alpha,
+                                lapack_complex_float* beta,
+                                lapack_complex_float* vsl, lapack_int ldvsl,
+                                lapack_complex_float* vsr, lapack_int ldvsr,
+                                float* rconde, float* rcondv,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork, lapack_int* iwork,
+                                lapack_int liwork, lapack_logical* bwork );
+lapack_int LAPACKE_zggesx_work( int matrix_order, char jobvsl, char jobvsr,
+                                char sort, LAPACK_Z_SELECT2 selctg, char sense,
+                                lapack_int n, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* b,
+                                lapack_int ldb, lapack_int* sdim,
+                                lapack_complex_double* alpha,
+                                lapack_complex_double* beta,
+                                lapack_complex_double* vsl, lapack_int ldvsl,
+                                lapack_complex_double* vsr, lapack_int ldvsr,
+                                double* rconde, double* rcondv,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork, lapack_int* iwork,
+                                lapack_int liwork, lapack_logical* bwork );
+
+lapack_int LAPACKE_sggev_work( int matrix_order, char jobvl, char jobvr,
+                               lapack_int n, float* a, lapack_int lda, float* b,
+                               lapack_int ldb, float* alphar, float* alphai,
+                               float* beta, float* vl, lapack_int ldvl,
+                               float* vr, lapack_int ldvr, float* work,
+                               lapack_int lwork );
+lapack_int LAPACKE_dggev_work( int matrix_order, char jobvl, char jobvr,
+                               lapack_int n, double* a, lapack_int lda,
+                               double* b, lapack_int ldb, double* alphar,
+                               double* alphai, double* beta, double* vl,
+                               lapack_int ldvl, double* vr, lapack_int ldvr,
+                               double* work, lapack_int lwork );
+lapack_int LAPACKE_cggev_work( int matrix_order, char jobvl, char jobvr,
+                               lapack_int n, lapack_complex_float* a,
+                               lapack_int lda, lapack_complex_float* b,
+                               lapack_int ldb, lapack_complex_float* alpha,
+                               lapack_complex_float* beta,
+                               lapack_complex_float* vl, lapack_int ldvl,
+                               lapack_complex_float* vr, lapack_int ldvr,
+                               lapack_complex_float* work, lapack_int lwork,
+                               float* rwork );
+lapack_int LAPACKE_zggev_work( int matrix_order, char jobvl, char jobvr,
+                               lapack_int n, lapack_complex_double* a,
+                               lapack_int lda, lapack_complex_double* b,
+                               lapack_int ldb, lapack_complex_double* alpha,
+                               lapack_complex_double* beta,
+                               lapack_complex_double* vl, lapack_int ldvl,
+                               lapack_complex_double* vr, lapack_int ldvr,
+                               lapack_complex_double* work, lapack_int lwork,
+                               double* rwork );
+
+lapack_int LAPACKE_sggevx_work( int matrix_order, char balanc, char jobvl,
+                                char jobvr, char sense, lapack_int n, float* a,
+                                lapack_int lda, float* b, lapack_int ldb,
+                                float* alphar, float* alphai, float* beta,
+                                float* vl, lapack_int ldvl, float* vr,
+                                lapack_int ldvr, lapack_int* ilo,
+                                lapack_int* ihi, float* lscale, float* rscale,
+                                float* abnrm, float* bbnrm, float* rconde,
+                                float* rcondv, float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_logical* bwork );
+lapack_int LAPACKE_dggevx_work( int matrix_order, char balanc, char jobvl,
+                                char jobvr, char sense, lapack_int n, double* a,
+                                lapack_int lda, double* b, lapack_int ldb,
+                                double* alphar, double* alphai, double* beta,
+                                double* vl, lapack_int ldvl, double* vr,
+                                lapack_int ldvr, lapack_int* ilo,
+                                lapack_int* ihi, double* lscale, double* rscale,
+                                double* abnrm, double* bbnrm, double* rconde,
+                                double* rcondv, double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_logical* bwork );
+lapack_int LAPACKE_cggevx_work( int matrix_order, char balanc, char jobvl,
+                                char jobvr, char sense, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* alpha,
+                                lapack_complex_float* beta,
+                                lapack_complex_float* vl, lapack_int ldvl,
+                                lapack_complex_float* vr, lapack_int ldvr,
+                                lapack_int* ilo, lapack_int* ihi, float* lscale,
+                                float* rscale, float* abnrm, float* bbnrm,
+                                float* rconde, float* rcondv,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork, lapack_int* iwork,
+                                lapack_logical* bwork );
+lapack_int LAPACKE_zggevx_work( int matrix_order, char balanc, char jobvl,
+                                char jobvr, char sense, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* alpha,
+                                lapack_complex_double* beta,
+                                lapack_complex_double* vl, lapack_int ldvl,
+                                lapack_complex_double* vr, lapack_int ldvr,
+                                lapack_int* ilo, lapack_int* ihi,
+                                double* lscale, double* rscale, double* abnrm,
+                                double* bbnrm, double* rconde, double* rcondv,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork, lapack_int* iwork,
+                                lapack_logical* bwork );
+
+lapack_int LAPACKE_sggglm_work( int matrix_order, lapack_int n, lapack_int m,
+                                lapack_int p, float* a, lapack_int lda,
+                                float* b, lapack_int ldb, float* d, float* x,
+                                float* y, float* work, lapack_int lwork );
+lapack_int LAPACKE_dggglm_work( int matrix_order, lapack_int n, lapack_int m,
+                                lapack_int p, double* a, lapack_int lda,
+                                double* b, lapack_int ldb, double* d, double* x,
+                                double* y, double* work, lapack_int lwork );
+lapack_int LAPACKE_cggglm_work( int matrix_order, lapack_int n, lapack_int m,
+                                lapack_int p, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* d,
+                                lapack_complex_float* x,
+                                lapack_complex_float* y,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zggglm_work( int matrix_order, lapack_int n, lapack_int m,
+                                lapack_int p, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* b,
+                                lapack_int ldb, lapack_complex_double* d,
+                                lapack_complex_double* x,
+                                lapack_complex_double* y,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sgghrd_work( int matrix_order, char compq, char compz,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                float* a, lapack_int lda, float* b,
+                                lapack_int ldb, float* q, lapack_int ldq,
+                                float* z, lapack_int ldz );
+lapack_int LAPACKE_dgghrd_work( int matrix_order, char compq, char compz,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                double* a, lapack_int lda, double* b,
+                                lapack_int ldb, double* q, lapack_int ldq,
+                                double* z, lapack_int ldz );
+lapack_int LAPACKE_cgghrd_work( int matrix_order, char compq, char compz,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* q, lapack_int ldq,
+                                lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zgghrd_work( int matrix_order, char compq, char compz,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* q, lapack_int ldq,
+                                lapack_complex_double* z, lapack_int ldz );
+
+lapack_int LAPACKE_sgglse_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int p, float* a, lapack_int lda,
+                                float* b, lapack_int ldb, float* c, float* d,
+                                float* x, float* work, lapack_int lwork );
+lapack_int LAPACKE_dgglse_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int p, double* a, lapack_int lda,
+                                double* b, lapack_int ldb, double* c, double* d,
+                                double* x, double* work, lapack_int lwork );
+lapack_int LAPACKE_cgglse_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int p, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* c,
+                                lapack_complex_float* d,
+                                lapack_complex_float* x,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zgglse_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int p, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* b,
+                                lapack_int ldb, lapack_complex_double* c,
+                                lapack_complex_double* d,
+                                lapack_complex_double* x,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sggqrf_work( int matrix_order, lapack_int n, lapack_int m,
+                                lapack_int p, float* a, lapack_int lda,
+                                float* taua, float* b, lapack_int ldb,
+                                float* taub, float* work, lapack_int lwork );
+lapack_int LAPACKE_dggqrf_work( int matrix_order, lapack_int n, lapack_int m,
+                                lapack_int p, double* a, lapack_int lda,
+                                double* taua, double* b, lapack_int ldb,
+                                double* taub, double* work, lapack_int lwork );
+lapack_int LAPACKE_cggqrf_work( int matrix_order, lapack_int n, lapack_int m,
+                                lapack_int p, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* taua,
+                                lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* taub,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zggqrf_work( int matrix_order, lapack_int n, lapack_int m,
+                                lapack_int p, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* taua,
+                                lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* taub,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sggrqf_work( int matrix_order, lapack_int m, lapack_int p,
+                                lapack_int n, float* a, lapack_int lda,
+                                float* taua, float* b, lapack_int ldb,
+                                float* taub, float* work, lapack_int lwork );
+lapack_int LAPACKE_dggrqf_work( int matrix_order, lapack_int m, lapack_int p,
+                                lapack_int n, double* a, lapack_int lda,
+                                double* taua, double* b, lapack_int ldb,
+                                double* taub, double* work, lapack_int lwork );
+lapack_int LAPACKE_cggrqf_work( int matrix_order, lapack_int m, lapack_int p,
+                                lapack_int n, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* taua,
+                                lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* taub,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zggrqf_work( int matrix_order, lapack_int m, lapack_int p,
+                                lapack_int n, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* taua,
+                                lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* taub,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sggsvd_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int n,
+                                lapack_int p, lapack_int* k, lapack_int* l,
+                                float* a, lapack_int lda, float* b,
+                                lapack_int ldb, float* alpha, float* beta,
+                                float* u, lapack_int ldu, float* v,
+                                lapack_int ldv, float* q, lapack_int ldq,
+                                float* work, lapack_int* iwork );
+lapack_int LAPACKE_dggsvd_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int n,
+                                lapack_int p, lapack_int* k, lapack_int* l,
+                                double* a, lapack_int lda, double* b,
+                                lapack_int ldb, double* alpha, double* beta,
+                                double* u, lapack_int ldu, double* v,
+                                lapack_int ldv, double* q, lapack_int ldq,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_cggsvd_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int n,
+                                lapack_int p, lapack_int* k, lapack_int* l,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb,
+                                float* alpha, float* beta,
+                                lapack_complex_float* u, lapack_int ldu,
+                                lapack_complex_float* v, lapack_int ldv,
+                                lapack_complex_float* q, lapack_int ldq,
+                                lapack_complex_float* work, float* rwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_zggsvd_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int n,
+                                lapack_int p, lapack_int* k, lapack_int* l,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                double* alpha, double* beta,
+                                lapack_complex_double* u, lapack_int ldu,
+                                lapack_complex_double* v, lapack_int ldv,
+                                lapack_complex_double* q, lapack_int ldq,
+                                lapack_complex_double* work, double* rwork,
+                                lapack_int* iwork );
+
+lapack_int LAPACKE_sggsvp_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int p,
+                                lapack_int n, float* a, lapack_int lda,
+                                float* b, lapack_int ldb, float tola,
+                                float tolb, lapack_int* k, lapack_int* l,
+                                float* u, lapack_int ldu, float* v,
+                                lapack_int ldv, float* q, lapack_int ldq,
+                                lapack_int* iwork, float* tau, float* work );
+lapack_int LAPACKE_dggsvp_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int p,
+                                lapack_int n, double* a, lapack_int lda,
+                                double* b, lapack_int ldb, double tola,
+                                double tolb, lapack_int* k, lapack_int* l,
+                                double* u, lapack_int ldu, double* v,
+                                lapack_int ldv, double* q, lapack_int ldq,
+                                lapack_int* iwork, double* tau, double* work );
+lapack_int LAPACKE_cggsvp_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int p,
+                                lapack_int n, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* b,
+                                lapack_int ldb, float tola, float tolb,
+                                lapack_int* k, lapack_int* l,
+                                lapack_complex_float* u, lapack_int ldu,
+                                lapack_complex_float* v, lapack_int ldv,
+                                lapack_complex_float* q, lapack_int ldq,
+                                lapack_int* iwork, float* rwork,
+                                lapack_complex_float* tau,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zggsvp_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int p,
+                                lapack_int n, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* b,
+                                lapack_int ldb, double tola, double tolb,
+                                lapack_int* k, lapack_int* l,
+                                lapack_complex_double* u, lapack_int ldu,
+                                lapack_complex_double* v, lapack_int ldv,
+                                lapack_complex_double* q, lapack_int ldq,
+                                lapack_int* iwork, double* rwork,
+                                lapack_complex_double* tau,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_sgtcon_work( char norm, lapack_int n, const float* dl,
+                                const float* d, const float* du,
+                                const float* du2, const lapack_int* ipiv,
+                                float anorm, float* rcond, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dgtcon_work( char norm, lapack_int n, const double* dl,
+                                const double* d, const double* du,
+                                const double* du2, const lapack_int* ipiv,
+                                double anorm, double* rcond, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_cgtcon_work( char norm, lapack_int n,
+                                const lapack_complex_float* dl,
+                                const lapack_complex_float* d,
+                                const lapack_complex_float* du,
+                                const lapack_complex_float* du2,
+                                const lapack_int* ipiv, float anorm,
+                                float* rcond, lapack_complex_float* work );
+lapack_int LAPACKE_zgtcon_work( char norm, lapack_int n,
+                                const lapack_complex_double* dl,
+                                const lapack_complex_double* d,
+                                const lapack_complex_double* du,
+                                const lapack_complex_double* du2,
+                                const lapack_int* ipiv, double anorm,
+                                double* rcond, lapack_complex_double* work );
+
+lapack_int LAPACKE_sgtrfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const float* dl,
+                                const float* d, const float* du,
+                                const float* dlf, const float* df,
+                                const float* duf, const float* du2,
+                                const lapack_int* ipiv, const float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* ferr, float* berr, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dgtrfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const double* dl,
+                                const double* d, const double* du,
+                                const double* dlf, const double* df,
+                                const double* duf, const double* du2,
+                                const lapack_int* ipiv, const double* b,
+                                lapack_int ldb, double* x, lapack_int ldx,
+                                double* ferr, double* berr, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_cgtrfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* dl,
+                                const lapack_complex_float* d,
+                                const lapack_complex_float* du,
+                                const lapack_complex_float* dlf,
+                                const lapack_complex_float* df,
+                                const lapack_complex_float* duf,
+                                const lapack_complex_float* du2,
+                                const lapack_int* ipiv,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zgtrfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs,
+                                const lapack_complex_double* dl,
+                                const lapack_complex_double* d,
+                                const lapack_complex_double* du,
+                                const lapack_complex_double* dlf,
+                                const lapack_complex_double* df,
+                                const lapack_complex_double* duf,
+                                const lapack_complex_double* du2,
+                                const lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sgtsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               float* dl, float* d, float* du, float* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_dgtsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               double* dl, double* d, double* du, double* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_cgtsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               lapack_complex_float* dl,
+                               lapack_complex_float* d,
+                               lapack_complex_float* du,
+                               lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zgtsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               lapack_complex_double* dl,
+                               lapack_complex_double* d,
+                               lapack_complex_double* du,
+                               lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_sgtsvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int nrhs, const float* dl,
+                                const float* d, const float* du, float* dlf,
+                                float* df, float* duf, float* du2,
+                                lapack_int* ipiv, const float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* rcond, float* ferr, float* berr,
+                                float* work, lapack_int* iwork );
+lapack_int LAPACKE_dgtsvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int nrhs, const double* dl,
+                                const double* d, const double* du, double* dlf,
+                                double* df, double* duf, double* du2,
+                                lapack_int* ipiv, const double* b,
+                                lapack_int ldb, double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_cgtsvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_float* dl,
+                                const lapack_complex_float* d,
+                                const lapack_complex_float* du,
+                                lapack_complex_float* dlf,
+                                lapack_complex_float* df,
+                                lapack_complex_float* duf,
+                                lapack_complex_float* du2, lapack_int* ipiv,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* rcond, float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zgtsvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_double* dl,
+                                const lapack_complex_double* d,
+                                const lapack_complex_double* du,
+                                lapack_complex_double* dlf,
+                                lapack_complex_double* df,
+                                lapack_complex_double* duf,
+                                lapack_complex_double* du2, lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sgttrf_work( lapack_int n, float* dl, float* d, float* du,
+                                float* du2, lapack_int* ipiv );
+lapack_int LAPACKE_dgttrf_work( lapack_int n, double* dl, double* d, double* du,
+                                double* du2, lapack_int* ipiv );
+lapack_int LAPACKE_cgttrf_work( lapack_int n, lapack_complex_float* dl,
+                                lapack_complex_float* d,
+                                lapack_complex_float* du,
+                                lapack_complex_float* du2, lapack_int* ipiv );
+lapack_int LAPACKE_zgttrf_work( lapack_int n, lapack_complex_double* dl,
+                                lapack_complex_double* d,
+                                lapack_complex_double* du,
+                                lapack_complex_double* du2, lapack_int* ipiv );
+
+lapack_int LAPACKE_sgttrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const float* dl,
+                                const float* d, const float* du,
+                                const float* du2, const lapack_int* ipiv,
+                                float* b, lapack_int ldb );
+lapack_int LAPACKE_dgttrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const double* dl,
+                                const double* d, const double* du,
+                                const double* du2, const lapack_int* ipiv,
+                                double* b, lapack_int ldb );
+lapack_int LAPACKE_cgttrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* dl,
+                                const lapack_complex_float* d,
+                                const lapack_complex_float* du,
+                                const lapack_complex_float* du2,
+                                const lapack_int* ipiv, lapack_complex_float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_zgttrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs,
+                                const lapack_complex_double* dl,
+                                const lapack_complex_double* d,
+                                const lapack_complex_double* du,
+                                const lapack_complex_double* du2,
+                                const lapack_int* ipiv,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_chbev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_int kd,
+                               lapack_complex_float* ab, lapack_int ldab,
+                               float* w, lapack_complex_float* z,
+                               lapack_int ldz, lapack_complex_float* work,
+                               float* rwork );
+lapack_int LAPACKE_zhbev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_int kd,
+                               lapack_complex_double* ab, lapack_int ldab,
+                               double* w, lapack_complex_double* z,
+                               lapack_int ldz, lapack_complex_double* work,
+                               double* rwork );
+
+lapack_int LAPACKE_chbevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_int kd,
+                                lapack_complex_float* ab, lapack_int ldab,
+                                float* w, lapack_complex_float* z,
+                                lapack_int ldz, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork,
+                                lapack_int lrwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_zhbevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_int kd,
+                                lapack_complex_double* ab, lapack_int ldab,
+                                double* w, lapack_complex_double* z,
+                                lapack_int ldz, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork,
+                                lapack_int lrwork, lapack_int* iwork,
+                                lapack_int liwork );
+
+lapack_int LAPACKE_chbevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, lapack_int kd,
+                                lapack_complex_float* ab, lapack_int ldab,
+                                lapack_complex_float* q, lapack_int ldq,
+                                float vl, float vu, lapack_int il,
+                                lapack_int iu, float abstol, lapack_int* m,
+                                float* w, lapack_complex_float* z,
+                                lapack_int ldz, lapack_complex_float* work,
+                                float* rwork, lapack_int* iwork,
+                                lapack_int* ifail );
+lapack_int LAPACKE_zhbevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, lapack_int kd,
+                                lapack_complex_double* ab, lapack_int ldab,
+                                lapack_complex_double* q, lapack_int ldq,
+                                double vl, double vu, lapack_int il,
+                                lapack_int iu, double abstol, lapack_int* m,
+                                double* w, lapack_complex_double* z,
+                                lapack_int ldz, lapack_complex_double* work,
+                                double* rwork, lapack_int* iwork,
+                                lapack_int* ifail );
+
+lapack_int LAPACKE_chbgst_work( int matrix_order, char vect, char uplo,
+                                lapack_int n, lapack_int ka, lapack_int kb,
+                                lapack_complex_float* ab, lapack_int ldab,
+                                const lapack_complex_float* bb, lapack_int ldbb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zhbgst_work( int matrix_order, char vect, char uplo,
+                                lapack_int n, lapack_int ka, lapack_int kb,
+                                lapack_complex_double* ab, lapack_int ldab,
+                                const lapack_complex_double* bb,
+                                lapack_int ldbb, lapack_complex_double* x,
+                                lapack_int ldx, lapack_complex_double* work,
+                                double* rwork );
+
+lapack_int LAPACKE_chbgv_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_int ka, lapack_int kb,
+                               lapack_complex_float* ab, lapack_int ldab,
+                               lapack_complex_float* bb, lapack_int ldbb,
+                               float* w, lapack_complex_float* z,
+                               lapack_int ldz, lapack_complex_float* work,
+                               float* rwork );
+lapack_int LAPACKE_zhbgv_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_int ka, lapack_int kb,
+                               lapack_complex_double* ab, lapack_int ldab,
+                               lapack_complex_double* bb, lapack_int ldbb,
+                               double* w, lapack_complex_double* z,
+                               lapack_int ldz, lapack_complex_double* work,
+                               double* rwork );
+
+lapack_int LAPACKE_chbgvd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_int ka, lapack_int kb,
+                                lapack_complex_float* ab, lapack_int ldab,
+                                lapack_complex_float* bb, lapack_int ldbb,
+                                float* w, lapack_complex_float* z,
+                                lapack_int ldz, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork,
+                                lapack_int lrwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_zhbgvd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_int ka, lapack_int kb,
+                                lapack_complex_double* ab, lapack_int ldab,
+                                lapack_complex_double* bb, lapack_int ldbb,
+                                double* w, lapack_complex_double* z,
+                                lapack_int ldz, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork,
+                                lapack_int lrwork, lapack_int* iwork,
+                                lapack_int liwork );
+
+lapack_int LAPACKE_chbgvx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, lapack_int ka,
+                                lapack_int kb, lapack_complex_float* ab,
+                                lapack_int ldab, lapack_complex_float* bb,
+                                lapack_int ldbb, lapack_complex_float* q,
+                                lapack_int ldq, float vl, float vu,
+                                lapack_int il, lapack_int iu, float abstol,
+                                lapack_int* m, float* w,
+                                lapack_complex_float* z, lapack_int ldz,
+                                lapack_complex_float* work, float* rwork,
+                                lapack_int* iwork, lapack_int* ifail );
+lapack_int LAPACKE_zhbgvx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, lapack_int ka,
+                                lapack_int kb, lapack_complex_double* ab,
+                                lapack_int ldab, lapack_complex_double* bb,
+                                lapack_int ldbb, lapack_complex_double* q,
+                                lapack_int ldq, double vl, double vu,
+                                lapack_int il, lapack_int iu, double abstol,
+                                lapack_int* m, double* w,
+                                lapack_complex_double* z, lapack_int ldz,
+                                lapack_complex_double* work, double* rwork,
+                                lapack_int* iwork, lapack_int* ifail );
+
+lapack_int LAPACKE_chbtrd_work( int matrix_order, char vect, char uplo,
+                                lapack_int n, lapack_int kd,
+                                lapack_complex_float* ab, lapack_int ldab,
+                                float* d, float* e, lapack_complex_float* q,
+                                lapack_int ldq, lapack_complex_float* work );
+lapack_int LAPACKE_zhbtrd_work( int matrix_order, char vect, char uplo,
+                                lapack_int n, lapack_int kd,
+                                lapack_complex_double* ab, lapack_int ldab,
+                                double* d, double* e, lapack_complex_double* q,
+                                lapack_int ldq, lapack_complex_double* work );
+
+lapack_int LAPACKE_checon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_int* ipiv, float anorm,
+                                float* rcond, lapack_complex_float* work );
+lapack_int LAPACKE_zhecon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_int* ipiv, double anorm,
+                                double* rcond, lapack_complex_double* work );
+
+lapack_int LAPACKE_cheequb_work( int matrix_order, char uplo, lapack_int n,
+                                 const lapack_complex_float* a, lapack_int lda,
+                                 float* s, float* scond, float* amax,
+                                 lapack_complex_float* work );
+lapack_int LAPACKE_zheequb_work( int matrix_order, char uplo, lapack_int n,
+                                 const lapack_complex_double* a, lapack_int lda,
+                                 double* s, double* scond, double* amax,
+                                 lapack_complex_double* work );
+
+lapack_int LAPACKE_cheev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_complex_float* a,
+                               lapack_int lda, float* w,
+                               lapack_complex_float* work, lapack_int lwork,
+                               float* rwork );
+lapack_int LAPACKE_zheev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_complex_double* a,
+                               lapack_int lda, double* w,
+                               lapack_complex_double* work, lapack_int lwork,
+                               double* rwork );
+
+lapack_int LAPACKE_cheevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_complex_float* a,
+                                lapack_int lda, float* w,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork, lapack_int lrwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_zheevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_complex_double* a,
+                                lapack_int lda, double* w,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork, lapack_int lrwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_cheevr_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                float vl, float vu, lapack_int il,
+                                lapack_int iu, float abstol, lapack_int* m,
+                                float* w, lapack_complex_float* z,
+                                lapack_int ldz, lapack_int* isuppz,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork, lapack_int lrwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_zheevr_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                double vl, double vu, lapack_int il,
+                                lapack_int iu, double abstol, lapack_int* m,
+                                double* w, lapack_complex_double* z,
+                                lapack_int ldz, lapack_int* isuppz,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork, lapack_int lrwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_cheevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                float vl, float vu, lapack_int il,
+                                lapack_int iu, float abstol, lapack_int* m,
+                                float* w, lapack_complex_float* z,
+                                lapack_int ldz, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork,
+                                lapack_int* iwork, lapack_int* ifail );
+lapack_int LAPACKE_zheevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                double vl, double vu, lapack_int il,
+                                lapack_int iu, double abstol, lapack_int* m,
+                                double* w, lapack_complex_double* z,
+                                lapack_int ldz, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork,
+                                lapack_int* iwork, lapack_int* ifail );
+
+lapack_int LAPACKE_chegst_work( int matrix_order, lapack_int itype, char uplo,
+                                lapack_int n, lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_zhegst_work( int matrix_order, lapack_int itype, char uplo,
+                                lapack_int n, lapack_complex_double* a,
+                                lapack_int lda, const lapack_complex_double* b,
+                                lapack_int ldb );
+
+lapack_int LAPACKE_chegv_work( int matrix_order, lapack_int itype, char jobz,
+                               char uplo, lapack_int n, lapack_complex_float* a,
+                               lapack_int lda, lapack_complex_float* b,
+                               lapack_int ldb, float* w,
+                               lapack_complex_float* work, lapack_int lwork,
+                               float* rwork );
+lapack_int LAPACKE_zhegv_work( int matrix_order, lapack_int itype, char jobz,
+                               char uplo, lapack_int n,
+                               lapack_complex_double* a, lapack_int lda,
+                               lapack_complex_double* b, lapack_int ldb,
+                               double* w, lapack_complex_double* work,
+                               lapack_int lwork, double* rwork );
+
+lapack_int LAPACKE_chegvd_work( int matrix_order, lapack_int itype, char jobz,
+                                char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb,
+                                float* w, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork,
+                                lapack_int lrwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_zhegvd_work( int matrix_order, lapack_int itype, char jobz,
+                                char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                double* w, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork,
+                                lapack_int lrwork, lapack_int* iwork,
+                                lapack_int liwork );
+
+lapack_int LAPACKE_chegvx_work( int matrix_order, lapack_int itype, char jobz,
+                                char range, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb,
+                                float vl, float vu, lapack_int il,
+                                lapack_int iu, float abstol, lapack_int* m,
+                                float* w, lapack_complex_float* z,
+                                lapack_int ldz, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork,
+                                lapack_int* iwork, lapack_int* ifail );
+lapack_int LAPACKE_zhegvx_work( int matrix_order, lapack_int itype, char jobz,
+                                char range, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                double vl, double vu, lapack_int il,
+                                lapack_int iu, double abstol, lapack_int* m,
+                                double* w, lapack_complex_double* z,
+                                lapack_int ldz, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork,
+                                lapack_int* iwork, lapack_int* ifail );
+
+lapack_int LAPACKE_cherfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* af,
+                                lapack_int ldaf, const lapack_int* ipiv,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zherfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_double* a,
+                                lapack_int lda, const lapack_complex_double* af,
+                                lapack_int ldaf, const lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_cherfsx_work( int matrix_order, char uplo, char equed,
+                                 lapack_int n, lapack_int nrhs,
+                                 const lapack_complex_float* a, lapack_int lda,
+                                 const lapack_complex_float* af,
+                                 lapack_int ldaf, const lapack_int* ipiv,
+                                 const float* s, const lapack_complex_float* b,
+                                 lapack_int ldb, lapack_complex_float* x,
+                                 lapack_int ldx, float* rcond, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, lapack_complex_float* work,
+                                 float* rwork );
+lapack_int LAPACKE_zherfsx_work( int matrix_order, char uplo, char equed,
+                                 lapack_int n, lapack_int nrhs,
+                                 const lapack_complex_double* a, lapack_int lda,
+                                 const lapack_complex_double* af,
+                                 lapack_int ldaf, const lapack_int* ipiv,
+                                 const double* s,
+                                 const lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* x, lapack_int ldx,
+                                 double* rcond, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, lapack_complex_double* work,
+                                 double* rwork );
+
+lapack_int LAPACKE_chesv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_float* a,
+                               lapack_int lda, lapack_int* ipiv,
+                               lapack_complex_float* b, lapack_int ldb,
+                               lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zhesv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_double* a,
+                               lapack_int lda, lapack_int* ipiv,
+                               lapack_complex_double* b, lapack_int ldb,
+                               lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_chesvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* af, lapack_int ldaf,
+                                lapack_int* ipiv, const lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* x,
+                                lapack_int ldx, float* rcond, float* ferr,
+                                float* berr, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork );
+lapack_int LAPACKE_zhesvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* af, lapack_int ldaf,
+                                lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork );
+
+lapack_int LAPACKE_chesvxx_work( int matrix_order, char fact, char uplo,
+                                 lapack_int n, lapack_int nrhs,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 lapack_complex_float* af, lapack_int ldaf,
+                                 lapack_int* ipiv, char* equed, float* s,
+                                 lapack_complex_float* b, lapack_int ldb,
+                                 lapack_complex_float* x, lapack_int ldx,
+                                 float* rcond, float* rpvgrw, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, lapack_complex_float* work,
+                                 float* rwork );
+lapack_int LAPACKE_zhesvxx_work( int matrix_order, char fact, char uplo,
+                                 lapack_int n, lapack_int nrhs,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 lapack_complex_double* af, lapack_int ldaf,
+                                 lapack_int* ipiv, char* equed, double* s,
+                                 lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* x, lapack_int ldx,
+                                 double* rcond, double* rpvgrw, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, lapack_complex_double* work,
+                                 double* rwork );
+
+lapack_int LAPACKE_chetrd_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                float* d, float* e, lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zhetrd_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                double* d, double* e,
+                                lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_chetrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_int* ipiv, lapack_complex_float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_zhetrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int* ipiv, lapack_complex_double* work,
+                                lapack_int lwork );
+
+lapack_int LAPACKE_chetri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                const lapack_int* ipiv,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zhetri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                const lapack_int* ipiv,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_chetrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* a,
+                                lapack_int lda, const lapack_int* ipiv,
+                                lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zhetrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_double* a,
+                                lapack_int lda, const lapack_int* ipiv,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_chfrk_work( int matrix_order, char transr, char uplo,
+                               char trans, lapack_int n, lapack_int k,
+                               float alpha, const lapack_complex_float* a,
+                               lapack_int lda, float beta,
+                               lapack_complex_float* c );
+lapack_int LAPACKE_zhfrk_work( int matrix_order, char transr, char uplo,
+                               char trans, lapack_int n, lapack_int k,
+                               double alpha, const lapack_complex_double* a,
+                               lapack_int lda, double beta,
+                               lapack_complex_double* c );
+
+lapack_int LAPACKE_shgeqz_work( int matrix_order, char job, char compq,
+                                char compz, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, float* h, lapack_int ldh,
+                                float* t, lapack_int ldt, float* alphar,
+                                float* alphai, float* beta, float* q,
+                                lapack_int ldq, float* z, lapack_int ldz,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dhgeqz_work( int matrix_order, char job, char compq,
+                                char compz, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, double* h, lapack_int ldh,
+                                double* t, lapack_int ldt, double* alphar,
+                                double* alphai, double* beta, double* q,
+                                lapack_int ldq, double* z, lapack_int ldz,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_chgeqz_work( int matrix_order, char job, char compq,
+                                char compz, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, lapack_complex_float* h,
+                                lapack_int ldh, lapack_complex_float* t,
+                                lapack_int ldt, lapack_complex_float* alpha,
+                                lapack_complex_float* beta,
+                                lapack_complex_float* q, lapack_int ldq,
+                                lapack_complex_float* z, lapack_int ldz,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork );
+lapack_int LAPACKE_zhgeqz_work( int matrix_order, char job, char compq,
+                                char compz, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, lapack_complex_double* h,
+                                lapack_int ldh, lapack_complex_double* t,
+                                lapack_int ldt, lapack_complex_double* alpha,
+                                lapack_complex_double* beta,
+                                lapack_complex_double* q, lapack_int ldq,
+                                lapack_complex_double* z, lapack_int ldz,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork );
+
+lapack_int LAPACKE_chpcon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_float* ap,
+                                const lapack_int* ipiv, float anorm,
+                                float* rcond, lapack_complex_float* work );
+lapack_int LAPACKE_zhpcon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_double* ap,
+                                const lapack_int* ipiv, double anorm,
+                                double* rcond, lapack_complex_double* work );
+
+lapack_int LAPACKE_chpev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_complex_float* ap, float* w,
+                               lapack_complex_float* z, lapack_int ldz,
+                               lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zhpev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_complex_double* ap,
+                               double* w, lapack_complex_double* z,
+                               lapack_int ldz, lapack_complex_double* work,
+                               double* rwork );
+
+lapack_int LAPACKE_chpevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_complex_float* ap,
+                                float* w, lapack_complex_float* z,
+                                lapack_int ldz, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork,
+                                lapack_int lrwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_zhpevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_complex_double* ap,
+                                double* w, lapack_complex_double* z,
+                                lapack_int ldz, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork,
+                                lapack_int lrwork, lapack_int* iwork,
+                                lapack_int liwork );
+
+lapack_int LAPACKE_chpevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n,
+                                lapack_complex_float* ap, float vl, float vu,
+                                lapack_int il, lapack_int iu, float abstol,
+                                lapack_int* m, float* w,
+                                lapack_complex_float* z, lapack_int ldz,
+                                lapack_complex_float* work, float* rwork,
+                                lapack_int* iwork, lapack_int* ifail );
+lapack_int LAPACKE_zhpevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n,
+                                lapack_complex_double* ap, double vl, double vu,
+                                lapack_int il, lapack_int iu, double abstol,
+                                lapack_int* m, double* w,
+                                lapack_complex_double* z, lapack_int ldz,
+                                lapack_complex_double* work, double* rwork,
+                                lapack_int* iwork, lapack_int* ifail );
+
+lapack_int LAPACKE_chpgst_work( int matrix_order, lapack_int itype, char uplo,
+                                lapack_int n, lapack_complex_float* ap,
+                                const lapack_complex_float* bp );
+lapack_int LAPACKE_zhpgst_work( int matrix_order, lapack_int itype, char uplo,
+                                lapack_int n, lapack_complex_double* ap,
+                                const lapack_complex_double* bp );
+
+lapack_int LAPACKE_chpgv_work( int matrix_order, lapack_int itype, char jobz,
+                               char uplo, lapack_int n,
+                               lapack_complex_float* ap,
+                               lapack_complex_float* bp, float* w,
+                               lapack_complex_float* z, lapack_int ldz,
+                               lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zhpgv_work( int matrix_order, lapack_int itype, char jobz,
+                               char uplo, lapack_int n,
+                               lapack_complex_double* ap,
+                               lapack_complex_double* bp, double* w,
+                               lapack_complex_double* z, lapack_int ldz,
+                               lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_chpgvd_work( int matrix_order, lapack_int itype, char jobz,
+                                char uplo, lapack_int n,
+                                lapack_complex_float* ap,
+                                lapack_complex_float* bp, float* w,
+                                lapack_complex_float* z, lapack_int ldz,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork, lapack_int lrwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_zhpgvd_work( int matrix_order, lapack_int itype, char jobz,
+                                char uplo, lapack_int n,
+                                lapack_complex_double* ap,
+                                lapack_complex_double* bp, double* w,
+                                lapack_complex_double* z, lapack_int ldz,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork, lapack_int lrwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_chpgvx_work( int matrix_order, lapack_int itype, char jobz,
+                                char range, char uplo, lapack_int n,
+                                lapack_complex_float* ap,
+                                lapack_complex_float* bp, float vl, float vu,
+                                lapack_int il, lapack_int iu, float abstol,
+                                lapack_int* m, float* w,
+                                lapack_complex_float* z, lapack_int ldz,
+                                lapack_complex_float* work, float* rwork,
+                                lapack_int* iwork, lapack_int* ifail );
+lapack_int LAPACKE_zhpgvx_work( int matrix_order, lapack_int itype, char jobz,
+                                char range, char uplo, lapack_int n,
+                                lapack_complex_double* ap,
+                                lapack_complex_double* bp, double vl, double vu,
+                                lapack_int il, lapack_int iu, double abstol,
+                                lapack_int* m, double* w,
+                                lapack_complex_double* z, lapack_int ldz,
+                                lapack_complex_double* work, double* rwork,
+                                lapack_int* iwork, lapack_int* ifail );
+
+lapack_int LAPACKE_chprfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* ap,
+                                const lapack_complex_float* afp,
+                                const lapack_int* ipiv,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zhprfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs,
+                                const lapack_complex_double* ap,
+                                const lapack_complex_double* afp,
+                                const lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_chpsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_float* ap,
+                               lapack_int* ipiv, lapack_complex_float* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_zhpsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_double* ap,
+                               lapack_int* ipiv, lapack_complex_double* b,
+                               lapack_int ldb );
+
+lapack_int LAPACKE_chpsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_float* ap,
+                                lapack_complex_float* afp, lapack_int* ipiv,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* rcond, float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zhpsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_double* ap,
+                                lapack_complex_double* afp, lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_chptrd_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* ap, float* d, float* e,
+                                lapack_complex_float* tau );
+lapack_int LAPACKE_zhptrd_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* ap, double* d, double* e,
+                                lapack_complex_double* tau );
+
+lapack_int LAPACKE_chptrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* ap, lapack_int* ipiv );
+lapack_int LAPACKE_zhptrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* ap, lapack_int* ipiv );
+
+lapack_int LAPACKE_chptri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* ap,
+                                const lapack_int* ipiv,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zhptri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* ap,
+                                const lapack_int* ipiv,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_chptrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* ap,
+                                const lapack_int* ipiv, lapack_complex_float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_zhptrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs,
+                                const lapack_complex_double* ap,
+                                const lapack_int* ipiv,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_shsein_work( int matrix_order, char job, char eigsrc,
+                                char initv, lapack_logical* select,
+                                lapack_int n, const float* h, lapack_int ldh,
+                                float* wr, const float* wi, float* vl,
+                                lapack_int ldvl, float* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m, float* work,
+                                lapack_int* ifaill, lapack_int* ifailr );
+lapack_int LAPACKE_dhsein_work( int matrix_order, char job, char eigsrc,
+                                char initv, lapack_logical* select,
+                                lapack_int n, const double* h, lapack_int ldh,
+                                double* wr, const double* wi, double* vl,
+                                lapack_int ldvl, double* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m, double* work,
+                                lapack_int* ifaill, lapack_int* ifailr );
+lapack_int LAPACKE_chsein_work( int matrix_order, char job, char eigsrc,
+                                char initv, const lapack_logical* select,
+                                lapack_int n, const lapack_complex_float* h,
+                                lapack_int ldh, lapack_complex_float* w,
+                                lapack_complex_float* vl, lapack_int ldvl,
+                                lapack_complex_float* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m,
+                                lapack_complex_float* work, float* rwork,
+                                lapack_int* ifaill, lapack_int* ifailr );
+lapack_int LAPACKE_zhsein_work( int matrix_order, char job, char eigsrc,
+                                char initv, const lapack_logical* select,
+                                lapack_int n, const lapack_complex_double* h,
+                                lapack_int ldh, lapack_complex_double* w,
+                                lapack_complex_double* vl, lapack_int ldvl,
+                                lapack_complex_double* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m,
+                                lapack_complex_double* work, double* rwork,
+                                lapack_int* ifaill, lapack_int* ifailr );
+
+lapack_int LAPACKE_shseqr_work( int matrix_order, char job, char compz,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                float* h, lapack_int ldh, float* wr, float* wi,
+                                float* z, lapack_int ldz, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dhseqr_work( int matrix_order, char job, char compz,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                double* h, lapack_int ldh, double* wr,
+                                double* wi, double* z, lapack_int ldz,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_chseqr_work( int matrix_order, char job, char compz,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                lapack_complex_float* h, lapack_int ldh,
+                                lapack_complex_float* w,
+                                lapack_complex_float* z, lapack_int ldz,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zhseqr_work( int matrix_order, char job, char compz,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                lapack_complex_double* h, lapack_int ldh,
+                                lapack_complex_double* w,
+                                lapack_complex_double* z, lapack_int ldz,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_clacgv_work( lapack_int n, lapack_complex_float* x,
+                                lapack_int incx );
+lapack_int LAPACKE_zlacgv_work( lapack_int n, lapack_complex_double* x,
+                                lapack_int incx );
+
+lapack_int LAPACKE_slacpy_work( int matrix_order, char uplo, lapack_int m,
+                                lapack_int n, const float* a, lapack_int lda,
+                                float* b, lapack_int ldb );
+lapack_int LAPACKE_dlacpy_work( int matrix_order, char uplo, lapack_int m,
+                                lapack_int n, const double* a, lapack_int lda,
+                                double* b, lapack_int ldb );
+lapack_int LAPACKE_clacpy_work( int matrix_order, char uplo, lapack_int m,
+                                lapack_int n, const lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_zlacpy_work( int matrix_order, char uplo, lapack_int m,
+                                lapack_int n, const lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* b,
+                                lapack_int ldb );
+
+lapack_int LAPACKE_zlag2c_work( int matrix_order, lapack_int m, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_float* sa, lapack_int ldsa );
+
+lapack_int LAPACKE_slag2d_work( int matrix_order, lapack_int m, lapack_int n,
+                                const float* sa, lapack_int ldsa, double* a,
+                                lapack_int lda );
+
+lapack_int LAPACKE_dlag2s_work( int matrix_order, lapack_int m, lapack_int n,
+                                const double* a, lapack_int lda, float* sa,
+                                lapack_int ldsa );
+
+lapack_int LAPACKE_clag2z_work( int matrix_order, lapack_int m, lapack_int n,
+                                const lapack_complex_float* sa, lapack_int ldsa,
+                                lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_slagge_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku, const float* d,
+                                float* a, lapack_int lda, lapack_int* iseed,
+                                float* work );
+lapack_int LAPACKE_dlagge_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku, const double* d,
+                                double* a, lapack_int lda, lapack_int* iseed,
+                                double* work );
+lapack_int LAPACKE_clagge_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku, const float* d,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_int* iseed, lapack_complex_float* work );
+lapack_int LAPACKE_zlagge_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku, const double* d,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int* iseed,
+                                lapack_complex_double* work );
+                                
+lapack_int LAPACKE_claghe_work( int matrix_order, lapack_int n, lapack_int k,
+                                const float* d, lapack_complex_float* a,
+                                lapack_int lda, lapack_int* iseed,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zlaghe_work( int matrix_order, lapack_int n, lapack_int k,
+                                const double* d, lapack_complex_double* a,
+                                lapack_int lda, lapack_int* iseed,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_slagsy_work( int matrix_order, lapack_int n, lapack_int k,
+                                const float* d, float* a, lapack_int lda,
+                                lapack_int* iseed, float* work );
+lapack_int LAPACKE_dlagsy_work( int matrix_order, lapack_int n, lapack_int k,
+                                const double* d, double* a, lapack_int lda,
+                                lapack_int* iseed, double* work );
+lapack_int LAPACKE_clagsy_work( int matrix_order, lapack_int n, lapack_int k,
+                                const float* d, lapack_complex_float* a,
+                                lapack_int lda, lapack_int* iseed,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zlagsy_work( int matrix_order, lapack_int n, lapack_int k,
+                                const double* d, lapack_complex_double* a,
+                                lapack_int lda, lapack_int* iseed,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_slapmr_work( int matrix_order, lapack_logical forwrd,
+                                lapack_int m, lapack_int n, float* x,
+                                lapack_int ldx, lapack_int* k );
+lapack_int LAPACKE_dlapmr_work( int matrix_order, lapack_logical forwrd,
+                                lapack_int m, lapack_int n, double* x,
+                                lapack_int ldx, lapack_int* k );
+lapack_int LAPACKE_clapmr_work( int matrix_order, lapack_logical forwrd,
+                                lapack_int m, lapack_int n,
+                                lapack_complex_float* x, lapack_int ldx,
+                                lapack_int* k );
+lapack_int LAPACKE_zlapmr_work( int matrix_order, lapack_logical forwrd,
+                                lapack_int m, lapack_int n,
+                                lapack_complex_double* x, lapack_int ldx,
+                                lapack_int* k );
+
+lapack_int LAPACKE_slartgp_work( float f, float g, float* cs, float* sn,
+                                 float* r );
+lapack_int LAPACKE_dlartgp_work( double f, double g, double* cs, double* sn,
+                                 double* r );
+
+lapack_int LAPACKE_slartgs_work( float x, float y, float sigma, float* cs,
+                                 float* sn );
+lapack_int LAPACKE_dlartgs_work( double x, double y, double sigma, double* cs,
+                                 double* sn );
+                                
+float LAPACKE_slapy2_work( float x, float y );
+double LAPACKE_dlapy2_work( double x, double y );
+
+float LAPACKE_slapy3_work( float x, float y, float z );
+double LAPACKE_dlapy3_work( double x, double y, double z );
+
+float LAPACKE_slamch_work( char cmach );
+double LAPACKE_dlamch_work( char cmach );
+
+float LAPACKE_slange_work( int matrix_order, char norm, lapack_int m,
+                                lapack_int n, const float* a, lapack_int lda,
+                                float* work );
+double LAPACKE_dlange_work( int matrix_order, char norm, lapack_int m,
+                                lapack_int n, const double* a, lapack_int lda,
+                                double* work );
+float LAPACKE_clange_work( int matrix_order, char norm, lapack_int m,
+                                lapack_int n, const lapack_complex_float* a,
+                                lapack_int lda, float* work );
+double LAPACKE_zlange_work( int matrix_order, char norm, lapack_int m,
+                                lapack_int n, const lapack_complex_double* a,
+                                lapack_int lda, double* work );
+
+float LAPACKE_clanhe_work( int matrix_order, char norm, char uplo,
+                                lapack_int n, const lapack_complex_float* a,
+                                lapack_int lda, float* work );
+double LAPACKE_zlanhe_work( int matrix_order, char norm, char uplo,
+                                lapack_int n, const lapack_complex_double* a,
+                                lapack_int lda, double* work );
+
+float LAPACKE_slansy_work( int matrix_order, char norm, char uplo,
+                                lapack_int n, const float* a, lapack_int lda,
+                                float* work );
+double LAPACKE_dlansy_work( int matrix_order, char norm, char uplo,
+                                lapack_int n, const double* a, lapack_int lda,
+                                double* work );
+float LAPACKE_clansy_work( int matrix_order, char norm, char uplo,
+                                lapack_int n, const lapack_complex_float* a,
+                                lapack_int lda, float* work );
+double LAPACKE_zlansy_work( int matrix_order, char norm, char uplo,
+                                lapack_int n, const lapack_complex_double* a,
+                                lapack_int lda, double* work );
+
+float LAPACKE_slantr_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int m, lapack_int n, const float* a,
+                                lapack_int lda, float* work );
+double LAPACKE_dlantr_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int m, lapack_int n,
+                                const double* a, lapack_int lda, double* work );
+float LAPACKE_clantr_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int m, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                float* work );
+double LAPACKE_zlantr_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int m, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                double* work );
+
+lapack_int LAPACKE_slarfb_work( int matrix_order, char side, char trans,
+                                char direct, char storev, lapack_int m,
+                                lapack_int n, lapack_int k, const float* v,
+                                lapack_int ldv, const float* t, lapack_int ldt,
+                                float* c, lapack_int ldc, float* work,
+                                lapack_int ldwork );
+lapack_int LAPACKE_dlarfb_work( int matrix_order, char side, char trans,
+                                char direct, char storev, lapack_int m,
+                                lapack_int n, lapack_int k, const double* v,
+                                lapack_int ldv, const double* t, lapack_int ldt,
+                                double* c, lapack_int ldc, double* work,
+                                lapack_int ldwork );
+lapack_int LAPACKE_clarfb_work( int matrix_order, char side, char trans,
+                                char direct, char storev, lapack_int m,
+                                lapack_int n, lapack_int k,
+                                const lapack_complex_float* v, lapack_int ldv,
+                                const lapack_complex_float* t, lapack_int ldt,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work, lapack_int ldwork );
+lapack_int LAPACKE_zlarfb_work( int matrix_order, char side, char trans,
+                                char direct, char storev, lapack_int m,
+                                lapack_int n, lapack_int k,
+                                const lapack_complex_double* v, lapack_int ldv,
+                                const lapack_complex_double* t, lapack_int ldt,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work,
+                                lapack_int ldwork );
+
+lapack_int LAPACKE_slarfg_work( lapack_int n, float* alpha, float* x,
+                                lapack_int incx, float* tau );
+lapack_int LAPACKE_dlarfg_work( lapack_int n, double* alpha, double* x,
+                                lapack_int incx, double* tau );
+lapack_int LAPACKE_clarfg_work( lapack_int n, lapack_complex_float* alpha,
+                                lapack_complex_float* x, lapack_int incx,
+                                lapack_complex_float* tau );
+lapack_int LAPACKE_zlarfg_work( lapack_int n, lapack_complex_double* alpha,
+                                lapack_complex_double* x, lapack_int incx,
+                                lapack_complex_double* tau );
+
+lapack_int LAPACKE_slarft_work( int matrix_order, char direct, char storev,
+                                lapack_int n, lapack_int k, const float* v,
+                                lapack_int ldv, const float* tau, float* t,
+                                lapack_int ldt );
+lapack_int LAPACKE_dlarft_work( int matrix_order, char direct, char storev,
+                                lapack_int n, lapack_int k, const double* v,
+                                lapack_int ldv, const double* tau, double* t,
+                                lapack_int ldt );
+lapack_int LAPACKE_clarft_work( int matrix_order, char direct, char storev,
+                                lapack_int n, lapack_int k,
+                                const lapack_complex_float* v, lapack_int ldv,
+                                const lapack_complex_float* tau,
+                                lapack_complex_float* t, lapack_int ldt );
+lapack_int LAPACKE_zlarft_work( int matrix_order, char direct, char storev,
+                                lapack_int n, lapack_int k,
+                                const lapack_complex_double* v, lapack_int ldv,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* t, lapack_int ldt );
+
+lapack_int LAPACKE_slarfx_work( int matrix_order, char side, lapack_int m,
+                                lapack_int n, const float* v, float tau,
+                                float* c, lapack_int ldc, float* work );
+lapack_int LAPACKE_dlarfx_work( int matrix_order, char side, lapack_int m,
+                                lapack_int n, const double* v, double tau,
+                                double* c, lapack_int ldc, double* work );
+lapack_int LAPACKE_clarfx_work( int matrix_order, char side, lapack_int m,
+                                lapack_int n, const lapack_complex_float* v,
+                                lapack_complex_float tau,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zlarfx_work( int matrix_order, char side, lapack_int m,
+                                lapack_int n, const lapack_complex_double* v,
+                                lapack_complex_double tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_slarnv_work( lapack_int idist, lapack_int* iseed,
+                                lapack_int n, float* x );
+lapack_int LAPACKE_dlarnv_work( lapack_int idist, lapack_int* iseed,
+                                lapack_int n, double* x );
+lapack_int LAPACKE_clarnv_work( lapack_int idist, lapack_int* iseed,
+                                lapack_int n, lapack_complex_float* x );
+lapack_int LAPACKE_zlarnv_work( lapack_int idist, lapack_int* iseed,
+                                lapack_int n, lapack_complex_double* x );
+
+lapack_int LAPACKE_slaset_work( int matrix_order, char uplo, lapack_int m,
+                                lapack_int n, float alpha, float beta, float* a,
+                                lapack_int lda );
+lapack_int LAPACKE_dlaset_work( int matrix_order, char uplo, lapack_int m,
+                                lapack_int n, double alpha, double beta,
+                                double* a, lapack_int lda );
+lapack_int LAPACKE_claset_work( int matrix_order, char uplo, lapack_int m,
+                                lapack_int n, lapack_complex_float alpha,
+                                lapack_complex_float beta,
+                                lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_zlaset_work( int matrix_order, char uplo, lapack_int m,
+                                lapack_int n, lapack_complex_double alpha,
+                                lapack_complex_double beta,
+                                lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_slasrt_work( char id, lapack_int n, float* d );
+lapack_int LAPACKE_dlasrt_work( char id, lapack_int n, double* d );
+
+lapack_int LAPACKE_slaswp_work( int matrix_order, lapack_int n, float* a,
+                                lapack_int lda, lapack_int k1, lapack_int k2,
+                                const lapack_int* ipiv, lapack_int incx );
+lapack_int LAPACKE_dlaswp_work( int matrix_order, lapack_int n, double* a,
+                                lapack_int lda, lapack_int k1, lapack_int k2,
+                                const lapack_int* ipiv, lapack_int incx );
+lapack_int LAPACKE_claswp_work( int matrix_order, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_int k1, lapack_int k2,
+                                const lapack_int* ipiv, lapack_int incx );
+lapack_int LAPACKE_zlaswp_work( int matrix_order, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int k1, lapack_int k2,
+                                const lapack_int* ipiv, lapack_int incx );
+
+lapack_int LAPACKE_slatms_work( int matrix_order, lapack_int m, lapack_int n,
+                                char dist, lapack_int* iseed, char sym,
+                                float* d, lapack_int mode, float cond,
+                                float dmax, lapack_int kl, lapack_int ku,
+                                char pack, float* a, lapack_int lda,
+                                float* work );
+lapack_int LAPACKE_dlatms_work( int matrix_order, lapack_int m, lapack_int n,
+                                char dist, lapack_int* iseed, char sym,
+                                double* d, lapack_int mode, double cond,
+                                double dmax, lapack_int kl, lapack_int ku,
+                                char pack, double* a, lapack_int lda,
+                                double* work );
+lapack_int LAPACKE_clatms_work( int matrix_order, lapack_int m, lapack_int n,
+                                char dist, lapack_int* iseed, char sym,
+                                float* d, lapack_int mode, float cond,
+                                float dmax, lapack_int kl, lapack_int ku,
+                                char pack, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* work );
+lapack_int LAPACKE_zlatms_work( int matrix_order, lapack_int m, lapack_int n,
+                                char dist, lapack_int* iseed, char sym,
+                                double* d, lapack_int mode, double cond,
+                                double dmax, lapack_int kl, lapack_int ku,
+                                char pack, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* work );
+
+lapack_int LAPACKE_slauum_work( int matrix_order, char uplo, lapack_int n,
+                                float* a, lapack_int lda );
+lapack_int LAPACKE_dlauum_work( int matrix_order, char uplo, lapack_int n,
+                                double* a, lapack_int lda );
+lapack_int LAPACKE_clauum_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_zlauum_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_sopgtr_work( int matrix_order, char uplo, lapack_int n,
+                                const float* ap, const float* tau, float* q,
+                                lapack_int ldq, float* work );
+lapack_int LAPACKE_dopgtr_work( int matrix_order, char uplo, lapack_int n,
+                                const double* ap, const double* tau, double* q,
+                                lapack_int ldq, double* work );
+
+lapack_int LAPACKE_sopmtr_work( int matrix_order, char side, char uplo,
+                                char trans, lapack_int m, lapack_int n,
+                                const float* ap, const float* tau, float* c,
+                                lapack_int ldc, float* work );
+lapack_int LAPACKE_dopmtr_work( int matrix_order, char side, char uplo,
+                                char trans, lapack_int m, lapack_int n,
+                                const double* ap, const double* tau, double* c,
+                                lapack_int ldc, double* work );
+
+lapack_int LAPACKE_sorgbr_work( int matrix_order, char vect, lapack_int m,
+                                lapack_int n, lapack_int k, float* a,
+                                lapack_int lda, const float* tau, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dorgbr_work( int matrix_order, char vect, lapack_int m,
+                                lapack_int n, lapack_int k, double* a,
+                                lapack_int lda, const double* tau, double* work,
+                                lapack_int lwork );
+
+lapack_int LAPACKE_sorghr_work( int matrix_order, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, float* a, lapack_int lda,
+                                const float* tau, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dorghr_work( int matrix_order, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, double* a, lapack_int lda,
+                                const double* tau, double* work,
+                                lapack_int lwork );
+
+lapack_int LAPACKE_sorglq_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, float* a, lapack_int lda,
+                                const float* tau, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dorglq_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, double* a, lapack_int lda,
+                                const double* tau, double* work,
+                                lapack_int lwork );
+
+lapack_int LAPACKE_sorgql_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, float* a, lapack_int lda,
+                                const float* tau, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dorgql_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, double* a, lapack_int lda,
+                                const double* tau, double* work,
+                                lapack_int lwork );
+
+lapack_int LAPACKE_sorgqr_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, float* a, lapack_int lda,
+                                const float* tau, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dorgqr_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, double* a, lapack_int lda,
+                                const double* tau, double* work,
+                                lapack_int lwork );
+
+lapack_int LAPACKE_sorgrq_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, float* a, lapack_int lda,
+                                const float* tau, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dorgrq_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, double* a, lapack_int lda,
+                                const double* tau, double* work,
+                                lapack_int lwork );
+
+lapack_int LAPACKE_sorgtr_work( int matrix_order, char uplo, lapack_int n,
+                                float* a, lapack_int lda, const float* tau,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dorgtr_work( int matrix_order, char uplo, lapack_int n,
+                                double* a, lapack_int lda, const double* tau,
+                                double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sormbr_work( int matrix_order, char vect, char side,
+                                char trans, lapack_int m, lapack_int n,
+                                lapack_int k, const float* a, lapack_int lda,
+                                const float* tau, float* c, lapack_int ldc,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dormbr_work( int matrix_order, char vect, char side,
+                                char trans, lapack_int m, lapack_int n,
+                                lapack_int k, const double* a, lapack_int lda,
+                                const double* tau, double* c, lapack_int ldc,
+                                double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sormhr_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, const float* a, lapack_int lda,
+                                const float* tau, float* c, lapack_int ldc,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dormhr_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, const double* a, lapack_int lda,
+                                const double* tau, double* c, lapack_int ldc,
+                                double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sormlq_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const float* a, lapack_int lda,
+                                const float* tau, float* c, lapack_int ldc,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dormlq_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const double* a, lapack_int lda,
+                                const double* tau, double* c, lapack_int ldc,
+                                double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sormql_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const float* a, lapack_int lda,
+                                const float* tau, float* c, lapack_int ldc,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dormql_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const double* a, lapack_int lda,
+                                const double* tau, double* c, lapack_int ldc,
+                                double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sormqr_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const float* a, lapack_int lda,
+                                const float* tau, float* c, lapack_int ldc,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dormqr_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const double* a, lapack_int lda,
+                                const double* tau, double* c, lapack_int ldc,
+                                double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sormrq_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const float* a, lapack_int lda,
+                                const float* tau, float* c, lapack_int ldc,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dormrq_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const double* a, lapack_int lda,
+                                const double* tau, double* c, lapack_int ldc,
+                                double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sormrz_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                lapack_int l, const float* a, lapack_int lda,
+                                const float* tau, float* c, lapack_int ldc,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dormrz_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                lapack_int l, const double* a, lapack_int lda,
+                                const double* tau, double* c, lapack_int ldc,
+                                double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sormtr_work( int matrix_order, char side, char uplo,
+                                char trans, lapack_int m, lapack_int n,
+                                const float* a, lapack_int lda,
+                                const float* tau, float* c, lapack_int ldc,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dormtr_work( int matrix_order, char side, char uplo,
+                                char trans, lapack_int m, lapack_int n,
+                                const double* a, lapack_int lda,
+                                const double* tau, double* c, lapack_int ldc,
+                                double* work, lapack_int lwork );
+
+lapack_int LAPACKE_spbcon_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, const float* ab, lapack_int ldab,
+                                float anorm, float* rcond, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dpbcon_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, const double* ab,
+                                lapack_int ldab, double anorm, double* rcond,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_cpbcon_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, const lapack_complex_float* ab,
+                                lapack_int ldab, float anorm, float* rcond,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zpbcon_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, const lapack_complex_double* ab,
+                                lapack_int ldab, double anorm, double* rcond,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_spbequ_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, const float* ab, lapack_int ldab,
+                                float* s, float* scond, float* amax );
+lapack_int LAPACKE_dpbequ_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, const double* ab,
+                                lapack_int ldab, double* s, double* scond,
+                                double* amax );
+lapack_int LAPACKE_cpbequ_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, const lapack_complex_float* ab,
+                                lapack_int ldab, float* s, float* scond,
+                                float* amax );
+lapack_int LAPACKE_zpbequ_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, const lapack_complex_double* ab,
+                                lapack_int ldab, double* s, double* scond,
+                                double* amax );
+
+lapack_int LAPACKE_spbrfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, lapack_int nrhs, const float* ab,
+                                lapack_int ldab, const float* afb,
+                                lapack_int ldafb, const float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* ferr, float* berr, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dpbrfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, lapack_int nrhs,
+                                const double* ab, lapack_int ldab,
+                                const double* afb, lapack_int ldafb,
+                                const double* b, lapack_int ldb, double* x,
+                                lapack_int ldx, double* ferr, double* berr,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_cpbrfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, lapack_int nrhs,
+                                const lapack_complex_float* ab, lapack_int ldab,
+                                const lapack_complex_float* afb,
+                                lapack_int ldafb, const lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* x,
+                                lapack_int ldx, float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zpbrfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, lapack_int nrhs,
+                                const lapack_complex_double* ab,
+                                lapack_int ldab,
+                                const lapack_complex_double* afb,
+                                lapack_int ldafb,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_spbstf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kb, float* bb, lapack_int ldbb );
+lapack_int LAPACKE_dpbstf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kb, double* bb, lapack_int ldbb );
+lapack_int LAPACKE_cpbstf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kb, lapack_complex_float* bb,
+                                lapack_int ldbb );
+lapack_int LAPACKE_zpbstf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kb, lapack_complex_double* bb,
+                                lapack_int ldbb );
+
+lapack_int LAPACKE_spbsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int kd, lapack_int nrhs, float* ab,
+                               lapack_int ldab, float* b, lapack_int ldb );
+lapack_int LAPACKE_dpbsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int kd, lapack_int nrhs, double* ab,
+                               lapack_int ldab, double* b, lapack_int ldb );
+lapack_int LAPACKE_cpbsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int kd, lapack_int nrhs,
+                               lapack_complex_float* ab, lapack_int ldab,
+                               lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zpbsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int kd, lapack_int nrhs,
+                               lapack_complex_double* ab, lapack_int ldab,
+                               lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_spbsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int kd, lapack_int nrhs,
+                                float* ab, lapack_int ldab, float* afb,
+                                lapack_int ldafb, char* equed, float* s,
+                                float* b, lapack_int ldb, float* x,
+                                lapack_int ldx, float* rcond, float* ferr,
+                                float* berr, float* work, lapack_int* iwork );
+lapack_int LAPACKE_dpbsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int kd, lapack_int nrhs,
+                                double* ab, lapack_int ldab, double* afb,
+                                lapack_int ldafb, char* equed, double* s,
+                                double* b, lapack_int ldb, double* x,
+                                lapack_int ldx, double* rcond, double* ferr,
+                                double* berr, double* work, lapack_int* iwork );
+lapack_int LAPACKE_cpbsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int kd, lapack_int nrhs,
+                                lapack_complex_float* ab, lapack_int ldab,
+                                lapack_complex_float* afb, lapack_int ldafb,
+                                char* equed, float* s, lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* x,
+                                lapack_int ldx, float* rcond, float* ferr,
+                                float* berr, lapack_complex_float* work,
+                                float* rwork );
+lapack_int LAPACKE_zpbsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int kd, lapack_int nrhs,
+                                lapack_complex_double* ab, lapack_int ldab,
+                                lapack_complex_double* afb, lapack_int ldafb,
+                                char* equed, double* s,
+                                lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_spbtrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, float* ab, lapack_int ldab );
+lapack_int LAPACKE_dpbtrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, double* ab, lapack_int ldab );
+lapack_int LAPACKE_cpbtrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, lapack_complex_float* ab,
+                                lapack_int ldab );
+lapack_int LAPACKE_zpbtrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, lapack_complex_double* ab,
+                                lapack_int ldab );
+
+lapack_int LAPACKE_spbtrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, lapack_int nrhs, const float* ab,
+                                lapack_int ldab, float* b, lapack_int ldb );
+lapack_int LAPACKE_dpbtrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, lapack_int nrhs,
+                                const double* ab, lapack_int ldab, double* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_cpbtrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, lapack_int nrhs,
+                                const lapack_complex_float* ab, lapack_int ldab,
+                                lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zpbtrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, lapack_int nrhs,
+                                const lapack_complex_double* ab,
+                                lapack_int ldab, lapack_complex_double* b,
+                                lapack_int ldb );
+
+lapack_int LAPACKE_spftrf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, float* a );
+lapack_int LAPACKE_dpftrf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, double* a );
+lapack_int LAPACKE_cpftrf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, lapack_complex_float* a );
+lapack_int LAPACKE_zpftrf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, lapack_complex_double* a );
+
+lapack_int LAPACKE_spftri_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, float* a );
+lapack_int LAPACKE_dpftri_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, double* a );
+lapack_int LAPACKE_cpftri_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, lapack_complex_float* a );
+lapack_int LAPACKE_zpftri_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, lapack_complex_double* a );
+
+lapack_int LAPACKE_spftrs_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, lapack_int nrhs, const float* a,
+                                float* b, lapack_int ldb );
+lapack_int LAPACKE_dpftrs_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, lapack_int nrhs, const double* a,
+                                double* b, lapack_int ldb );
+lapack_int LAPACKE_cpftrs_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_float* a,
+                                lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zpftrs_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_double* a,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_spocon_work( int matrix_order, char uplo, lapack_int n,
+                                const float* a, lapack_int lda, float anorm,
+                                float* rcond, float* work, lapack_int* iwork );
+lapack_int LAPACKE_dpocon_work( int matrix_order, char uplo, lapack_int n,
+                                const double* a, lapack_int lda, double anorm,
+                                double* rcond, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_cpocon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                float anorm, float* rcond,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zpocon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                double anorm, double* rcond,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_spoequ_work( int matrix_order, lapack_int n, const float* a,
+                                lapack_int lda, float* s, float* scond,
+                                float* amax );
+lapack_int LAPACKE_dpoequ_work( int matrix_order, lapack_int n, const double* a,
+                                lapack_int lda, double* s, double* scond,
+                                double* amax );
+lapack_int LAPACKE_cpoequ_work( int matrix_order, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                float* s, float* scond, float* amax );
+lapack_int LAPACKE_zpoequ_work( int matrix_order, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                double* s, double* scond, double* amax );
+
+lapack_int LAPACKE_spoequb_work( int matrix_order, lapack_int n, const float* a,
+                                 lapack_int lda, float* s, float* scond,
+                                 float* amax );
+lapack_int LAPACKE_dpoequb_work( int matrix_order, lapack_int n,
+                                 const double* a, lapack_int lda, double* s,
+                                 double* scond, double* amax );
+lapack_int LAPACKE_cpoequb_work( int matrix_order, lapack_int n,
+                                 const lapack_complex_float* a, lapack_int lda,
+                                 float* s, float* scond, float* amax );
+lapack_int LAPACKE_zpoequb_work( int matrix_order, lapack_int n,
+                                 const lapack_complex_double* a, lapack_int lda,
+                                 double* s, double* scond, double* amax );
+
+lapack_int LAPACKE_sporfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const float* a, lapack_int lda,
+                                const float* af, lapack_int ldaf,
+                                const float* b, lapack_int ldb, float* x,
+                                lapack_int ldx, float* ferr, float* berr,
+                                float* work, lapack_int* iwork );
+lapack_int LAPACKE_dporfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const double* a,
+                                lapack_int lda, const double* af,
+                                lapack_int ldaf, const double* b,
+                                lapack_int ldb, double* x, lapack_int ldx,
+                                double* ferr, double* berr, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_cporfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* af,
+                                lapack_int ldaf, const lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* x,
+                                lapack_int ldx, float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zporfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_double* a,
+                                lapack_int lda, const lapack_complex_double* af,
+                                lapack_int ldaf, const lapack_complex_double* b,
+                                lapack_int ldb, lapack_complex_double* x,
+                                lapack_int ldx, double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sporfsx_work( int matrix_order, char uplo, char equed,
+                                 lapack_int n, lapack_int nrhs, const float* a,
+                                 lapack_int lda, const float* af,
+                                 lapack_int ldaf, const float* s,
+                                 const float* b, lapack_int ldb, float* x,
+                                 lapack_int ldx, float* rcond, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, float* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_dporfsx_work( int matrix_order, char uplo, char equed,
+                                 lapack_int n, lapack_int nrhs, const double* a,
+                                 lapack_int lda, const double* af,
+                                 lapack_int ldaf, const double* s,
+                                 const double* b, lapack_int ldb, double* x,
+                                 lapack_int ldx, double* rcond, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, double* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_cporfsx_work( int matrix_order, char uplo, char equed,
+                                 lapack_int n, lapack_int nrhs,
+                                 const lapack_complex_float* a, lapack_int lda,
+                                 const lapack_complex_float* af,
+                                 lapack_int ldaf, const float* s,
+                                 const lapack_complex_float* b, lapack_int ldb,
+                                 lapack_complex_float* x, lapack_int ldx,
+                                 float* rcond, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, lapack_complex_float* work,
+                                 float* rwork );
+lapack_int LAPACKE_zporfsx_work( int matrix_order, char uplo, char equed,
+                                 lapack_int n, lapack_int nrhs,
+                                 const lapack_complex_double* a, lapack_int lda,
+                                 const lapack_complex_double* af,
+                                 lapack_int ldaf, const double* s,
+                                 const lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* x, lapack_int ldx,
+                                 double* rcond, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, lapack_complex_double* work,
+                                 double* rwork );
+
+lapack_int LAPACKE_sposv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, float* a, lapack_int lda,
+                               float* b, lapack_int ldb );
+lapack_int LAPACKE_dposv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, double* a, lapack_int lda,
+                               double* b, lapack_int ldb );
+lapack_int LAPACKE_cposv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_float* a,
+                               lapack_int lda, lapack_complex_float* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_zposv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_double* a,
+                               lapack_int lda, lapack_complex_double* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_dsposv_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, double* a, lapack_int lda,
+                                double* b, lapack_int ldb, double* x,
+                                lapack_int ldx, double* work, float* swork,
+                                lapack_int* iter );
+lapack_int LAPACKE_zcposv_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* b,
+                                lapack_int ldb, lapack_complex_double* x,
+                                lapack_int ldx, lapack_complex_double* work,
+                                lapack_complex_float* swork, double* rwork,
+                                lapack_int* iter );
+
+lapack_int LAPACKE_sposvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs, float* a,
+                                lapack_int lda, float* af, lapack_int ldaf,
+                                char* equed, float* s, float* b, lapack_int ldb,
+                                float* x, lapack_int ldx, float* rcond,
+                                float* ferr, float* berr, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dposvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs, double* a,
+                                lapack_int lda, double* af, lapack_int ldaf,
+                                char* equed, double* s, double* b,
+                                lapack_int ldb, double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_cposvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* af, lapack_int ldaf,
+                                char* equed, float* s, lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* x,
+                                lapack_int ldx, float* rcond, float* ferr,
+                                float* berr, lapack_complex_float* work,
+                                float* rwork );
+lapack_int LAPACKE_zposvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* af, lapack_int ldaf,
+                                char* equed, double* s,
+                                lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sposvxx_work( int matrix_order, char fact, char uplo,
+                                 lapack_int n, lapack_int nrhs, float* a,
+                                 lapack_int lda, float* af, lapack_int ldaf,
+                                 char* equed, float* s, float* b,
+                                 lapack_int ldb, float* x, lapack_int ldx,
+                                 float* rcond, float* rpvgrw, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, float* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_dposvxx_work( int matrix_order, char fact, char uplo,
+                                 lapack_int n, lapack_int nrhs, double* a,
+                                 lapack_int lda, double* af, lapack_int ldaf,
+                                 char* equed, double* s, double* b,
+                                 lapack_int ldb, double* x, lapack_int ldx,
+                                 double* rcond, double* rpvgrw, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, double* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_cposvxx_work( int matrix_order, char fact, char uplo,
+                                 lapack_int n, lapack_int nrhs,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 lapack_complex_float* af, lapack_int ldaf,
+                                 char* equed, float* s, lapack_complex_float* b,
+                                 lapack_int ldb, lapack_complex_float* x,
+                                 lapack_int ldx, float* rcond, float* rpvgrw,
+                                 float* berr, lapack_int n_err_bnds,
+                                 float* err_bnds_norm, float* err_bnds_comp,
+                                 lapack_int nparams, float* params,
+                                 lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zposvxx_work( int matrix_order, char fact, char uplo,
+                                 lapack_int n, lapack_int nrhs,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 lapack_complex_double* af, lapack_int ldaf,
+                                 char* equed, double* s,
+                                 lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* x, lapack_int ldx,
+                                 double* rcond, double* rpvgrw, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, lapack_complex_double* work,
+                                 double* rwork );
+
+lapack_int LAPACKE_spotrf_work( int matrix_order, char uplo, lapack_int n,
+                                float* a, lapack_int lda );
+lapack_int LAPACKE_dpotrf_work( int matrix_order, char uplo, lapack_int n,
+                                double* a, lapack_int lda );
+lapack_int LAPACKE_cpotrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_zpotrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_spotri_work( int matrix_order, char uplo, lapack_int n,
+                                float* a, lapack_int lda );
+lapack_int LAPACKE_dpotri_work( int matrix_order, char uplo, lapack_int n,
+                                double* a, lapack_int lda );
+lapack_int LAPACKE_cpotri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_zpotri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_spotrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const float* a, lapack_int lda,
+                                float* b, lapack_int ldb );
+lapack_int LAPACKE_dpotrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const double* a,
+                                lapack_int lda, double* b, lapack_int ldb );
+lapack_int LAPACKE_cpotrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_zpotrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* b,
+                                lapack_int ldb );
+
+lapack_int LAPACKE_sppcon_work( int matrix_order, char uplo, lapack_int n,
+                                const float* ap, float anorm, float* rcond,
+                                float* work, lapack_int* iwork );
+lapack_int LAPACKE_dppcon_work( int matrix_order, char uplo, lapack_int n,
+                                const double* ap, double anorm, double* rcond,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_cppcon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_float* ap, float anorm,
+                                float* rcond, lapack_complex_float* work,
+                                float* rwork );
+lapack_int LAPACKE_zppcon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_double* ap, double anorm,
+                                double* rcond, lapack_complex_double* work,
+                                double* rwork );
+
+lapack_int LAPACKE_sppequ_work( int matrix_order, char uplo, lapack_int n,
+                                const float* ap, float* s, float* scond,
+                                float* amax );
+lapack_int LAPACKE_dppequ_work( int matrix_order, char uplo, lapack_int n,
+                                const double* ap, double* s, double* scond,
+                                double* amax );
+lapack_int LAPACKE_cppequ_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_float* ap, float* s,
+                                float* scond, float* amax );
+lapack_int LAPACKE_zppequ_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_double* ap, double* s,
+                                double* scond, double* amax );
+
+lapack_int LAPACKE_spprfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const float* ap,
+                                const float* afp, const float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* ferr, float* berr, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dpprfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const double* ap,
+                                const double* afp, const double* b,
+                                lapack_int ldb, double* x, lapack_int ldx,
+                                double* ferr, double* berr, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_cpprfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* ap,
+                                const lapack_complex_float* afp,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zpprfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs,
+                                const lapack_complex_double* ap,
+                                const lapack_complex_double* afp,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sppsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, float* ap, float* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_dppsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, double* ap, double* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_cppsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_float* ap,
+                               lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zppsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_double* ap,
+                               lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_sppsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs, float* ap,
+                                float* afp, char* equed, float* s, float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* rcond, float* ferr, float* berr,
+                                float* work, lapack_int* iwork );
+lapack_int LAPACKE_dppsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs, double* ap,
+                                double* afp, char* equed, double* s, double* b,
+                                lapack_int ldb, double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_cppsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                lapack_complex_float* ap,
+                                lapack_complex_float* afp, char* equed,
+                                float* s, lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* x,
+                                lapack_int ldx, float* rcond, float* ferr,
+                                float* berr, lapack_complex_float* work,
+                                float* rwork );
+lapack_int LAPACKE_zppsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                lapack_complex_double* ap,
+                                lapack_complex_double* afp, char* equed,
+                                double* s, lapack_complex_double* b,
+                                lapack_int ldb, lapack_complex_double* x,
+                                lapack_int ldx, double* rcond, double* ferr,
+                                double* berr, lapack_complex_double* work,
+                                double* rwork );
+
+lapack_int LAPACKE_spptrf_work( int matrix_order, char uplo, lapack_int n,
+                                float* ap );
+lapack_int LAPACKE_dpptrf_work( int matrix_order, char uplo, lapack_int n,
+                                double* ap );
+lapack_int LAPACKE_cpptrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* ap );
+lapack_int LAPACKE_zpptrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* ap );
+
+lapack_int LAPACKE_spptri_work( int matrix_order, char uplo, lapack_int n,
+                                float* ap );
+lapack_int LAPACKE_dpptri_work( int matrix_order, char uplo, lapack_int n,
+                                double* ap );
+lapack_int LAPACKE_cpptri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* ap );
+lapack_int LAPACKE_zpptri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* ap );
+
+lapack_int LAPACKE_spptrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const float* ap, float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_dpptrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const double* ap, double* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_cpptrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* ap,
+                                lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zpptrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs,
+                                const lapack_complex_double* ap,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_spstrf_work( int matrix_order, char uplo, lapack_int n,
+                                float* a, lapack_int lda, lapack_int* piv,
+                                lapack_int* rank, float tol, float* work );
+lapack_int LAPACKE_dpstrf_work( int matrix_order, char uplo, lapack_int n,
+                                double* a, lapack_int lda, lapack_int* piv,
+                                lapack_int* rank, double tol, double* work );
+lapack_int LAPACKE_cpstrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_int* piv, lapack_int* rank, float tol,
+                                float* work );
+lapack_int LAPACKE_zpstrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int* piv, lapack_int* rank, double tol,
+                                double* work );
+
+lapack_int LAPACKE_sptcon_work( lapack_int n, const float* d, const float* e,
+                                float anorm, float* rcond, float* work );
+lapack_int LAPACKE_dptcon_work( lapack_int n, const double* d, const double* e,
+                                double anorm, double* rcond, double* work );
+lapack_int LAPACKE_cptcon_work( lapack_int n, const float* d,
+                                const lapack_complex_float* e, float anorm,
+                                float* rcond, float* work );
+lapack_int LAPACKE_zptcon_work( lapack_int n, const double* d,
+                                const lapack_complex_double* e, double anorm,
+                                double* rcond, double* work );
+
+lapack_int LAPACKE_spteqr_work( int matrix_order, char compz, lapack_int n,
+                                float* d, float* e, float* z, lapack_int ldz,
+                                float* work );
+lapack_int LAPACKE_dpteqr_work( int matrix_order, char compz, lapack_int n,
+                                double* d, double* e, double* z, lapack_int ldz,
+                                double* work );
+lapack_int LAPACKE_cpteqr_work( int matrix_order, char compz, lapack_int n,
+                                float* d, float* e, lapack_complex_float* z,
+                                lapack_int ldz, float* work );
+lapack_int LAPACKE_zpteqr_work( int matrix_order, char compz, lapack_int n,
+                                double* d, double* e, lapack_complex_double* z,
+                                lapack_int ldz, double* work );
+
+lapack_int LAPACKE_sptrfs_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                                const float* d, const float* e, const float* df,
+                                const float* ef, const float* b, lapack_int ldb,
+                                float* x, lapack_int ldx, float* ferr,
+                                float* berr, float* work );
+lapack_int LAPACKE_dptrfs_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                                const double* d, const double* e,
+                                const double* df, const double* ef,
+                                const double* b, lapack_int ldb, double* x,
+                                lapack_int ldx, double* ferr, double* berr,
+                                double* work );
+lapack_int LAPACKE_cptrfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const float* d,
+                                const lapack_complex_float* e, const float* df,
+                                const lapack_complex_float* ef,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zptrfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const double* d,
+                                const lapack_complex_double* e,
+                                const double* df,
+                                const lapack_complex_double* ef,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sptsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               float* d, float* e, float* b, lapack_int ldb );
+lapack_int LAPACKE_dptsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               double* d, double* e, double* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_cptsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               float* d, lapack_complex_float* e,
+                               lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zptsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               double* d, lapack_complex_double* e,
+                               lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_sptsvx_work( int matrix_order, char fact, lapack_int n,
+                                lapack_int nrhs, const float* d, const float* e,
+                                float* df, float* ef, const float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* rcond, float* ferr, float* berr,
+                                float* work );
+lapack_int LAPACKE_dptsvx_work( int matrix_order, char fact, lapack_int n,
+                                lapack_int nrhs, const double* d,
+                                const double* e, double* df, double* ef,
+                                const double* b, lapack_int ldb, double* x,
+                                lapack_int ldx, double* rcond, double* ferr,
+                                double* berr, double* work );
+lapack_int LAPACKE_cptsvx_work( int matrix_order, char fact, lapack_int n,
+                                lapack_int nrhs, const float* d,
+                                const lapack_complex_float* e, float* df,
+                                lapack_complex_float* ef,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* rcond, float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zptsvx_work( int matrix_order, char fact, lapack_int n,
+                                lapack_int nrhs, const double* d,
+                                const lapack_complex_double* e, double* df,
+                                lapack_complex_double* ef,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_spttrf_work( lapack_int n, float* d, float* e );
+lapack_int LAPACKE_dpttrf_work( lapack_int n, double* d, double* e );
+lapack_int LAPACKE_cpttrf_work( lapack_int n, float* d,
+                                lapack_complex_float* e );
+lapack_int LAPACKE_zpttrf_work( lapack_int n, double* d,
+                                lapack_complex_double* e );
+
+lapack_int LAPACKE_spttrs_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                                const float* d, const float* e, float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_dpttrs_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                                const double* d, const double* e, double* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_cpttrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const float* d,
+                                const lapack_complex_float* e,
+                                lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zpttrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const double* d,
+                                const lapack_complex_double* e,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_ssbev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_int kd, float* ab,
+                               lapack_int ldab, float* w, float* z,
+                               lapack_int ldz, float* work );
+lapack_int LAPACKE_dsbev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_int kd, double* ab,
+                               lapack_int ldab, double* w, double* z,
+                               lapack_int ldz, double* work );
+
+lapack_int LAPACKE_ssbevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_int kd, float* ab,
+                                lapack_int ldab, float* w, float* z,
+                                lapack_int ldz, float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_dsbevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_int kd, double* ab,
+                                lapack_int ldab, double* w, double* z,
+                                lapack_int ldz, double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_ssbevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, lapack_int kd,
+                                float* ab, lapack_int ldab, float* q,
+                                lapack_int ldq, float vl, float vu,
+                                lapack_int il, lapack_int iu, float abstol,
+                                lapack_int* m, float* w, float* z,
+                                lapack_int ldz, float* work, lapack_int* iwork,
+                                lapack_int* ifail );
+lapack_int LAPACKE_dsbevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, lapack_int kd,
+                                double* ab, lapack_int ldab, double* q,
+                                lapack_int ldq, double vl, double vu,
+                                lapack_int il, lapack_int iu, double abstol,
+                                lapack_int* m, double* w, double* z,
+                                lapack_int ldz, double* work, lapack_int* iwork,
+                                lapack_int* ifail );
+
+lapack_int LAPACKE_ssbgst_work( int matrix_order, char vect, char uplo,
+                                lapack_int n, lapack_int ka, lapack_int kb,
+                                float* ab, lapack_int ldab, const float* bb,
+                                lapack_int ldbb, float* x, lapack_int ldx,
+                                float* work );
+lapack_int LAPACKE_dsbgst_work( int matrix_order, char vect, char uplo,
+                                lapack_int n, lapack_int ka, lapack_int kb,
+                                double* ab, lapack_int ldab, const double* bb,
+                                lapack_int ldbb, double* x, lapack_int ldx,
+                                double* work );
+
+lapack_int LAPACKE_ssbgv_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_int ka, lapack_int kb,
+                               float* ab, lapack_int ldab, float* bb,
+                               lapack_int ldbb, float* w, float* z,
+                               lapack_int ldz, float* work );
+lapack_int LAPACKE_dsbgv_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_int ka, lapack_int kb,
+                               double* ab, lapack_int ldab, double* bb,
+                               lapack_int ldbb, double* w, double* z,
+                               lapack_int ldz, double* work );
+
+lapack_int LAPACKE_ssbgvd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_int ka, lapack_int kb,
+                                float* ab, lapack_int ldab, float* bb,
+                                lapack_int ldbb, float* w, float* z,
+                                lapack_int ldz, float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_dsbgvd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_int ka, lapack_int kb,
+                                double* ab, lapack_int ldab, double* bb,
+                                lapack_int ldbb, double* w, double* z,
+                                lapack_int ldz, double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_ssbgvx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, lapack_int ka,
+                                lapack_int kb, float* ab, lapack_int ldab,
+                                float* bb, lapack_int ldbb, float* q,
+                                lapack_int ldq, float vl, float vu,
+                                lapack_int il, lapack_int iu, float abstol,
+                                lapack_int* m, float* w, float* z,
+                                lapack_int ldz, float* work, lapack_int* iwork,
+                                lapack_int* ifail );
+lapack_int LAPACKE_dsbgvx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, lapack_int ka,
+                                lapack_int kb, double* ab, lapack_int ldab,
+                                double* bb, lapack_int ldbb, double* q,
+                                lapack_int ldq, double vl, double vu,
+                                lapack_int il, lapack_int iu, double abstol,
+                                lapack_int* m, double* w, double* z,
+                                lapack_int ldz, double* work, lapack_int* iwork,
+                                lapack_int* ifail );
+
+lapack_int LAPACKE_ssbtrd_work( int matrix_order, char vect, char uplo,
+                                lapack_int n, lapack_int kd, float* ab,
+                                lapack_int ldab, float* d, float* e, float* q,
+                                lapack_int ldq, float* work );
+lapack_int LAPACKE_dsbtrd_work( int matrix_order, char vect, char uplo,
+                                lapack_int n, lapack_int kd, double* ab,
+                                lapack_int ldab, double* d, double* e,
+                                double* q, lapack_int ldq, double* work );
+
+lapack_int LAPACKE_ssfrk_work( int matrix_order, char transr, char uplo,
+                               char trans, lapack_int n, lapack_int k,
+                               float alpha, const float* a, lapack_int lda,
+                               float beta, float* c );
+lapack_int LAPACKE_dsfrk_work( int matrix_order, char transr, char uplo,
+                               char trans, lapack_int n, lapack_int k,
+                               double alpha, const double* a, lapack_int lda,
+                               double beta, double* c );
+
+lapack_int LAPACKE_sspcon_work( int matrix_order, char uplo, lapack_int n,
+                                const float* ap, const lapack_int* ipiv,
+                                float anorm, float* rcond, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dspcon_work( int matrix_order, char uplo, lapack_int n,
+                                const double* ap, const lapack_int* ipiv,
+                                double anorm, double* rcond, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_cspcon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_float* ap,
+                                const lapack_int* ipiv, float anorm,
+                                float* rcond, lapack_complex_float* work );
+lapack_int LAPACKE_zspcon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_double* ap,
+                                const lapack_int* ipiv, double anorm,
+                                double* rcond, lapack_complex_double* work );
+
+lapack_int LAPACKE_sspev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, float* ap, float* w, float* z,
+                               lapack_int ldz, float* work );
+lapack_int LAPACKE_dspev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, double* ap, double* w, double* z,
+                               lapack_int ldz, double* work );
+
+lapack_int LAPACKE_sspevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, float* ap, float* w, float* z,
+                                lapack_int ldz, float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_dspevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, double* ap, double* w, double* z,
+                                lapack_int ldz, double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_sspevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, float* ap, float vl,
+                                float vu, lapack_int il, lapack_int iu,
+                                float abstol, lapack_int* m, float* w, float* z,
+                                lapack_int ldz, float* work, lapack_int* iwork,
+                                lapack_int* ifail );
+lapack_int LAPACKE_dspevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, double* ap, double vl,
+                                double vu, lapack_int il, lapack_int iu,
+                                double abstol, lapack_int* m, double* w,
+                                double* z, lapack_int ldz, double* work,
+                                lapack_int* iwork, lapack_int* ifail );
+
+lapack_int LAPACKE_sspgst_work( int matrix_order, lapack_int itype, char uplo,
+                                lapack_int n, float* ap, const float* bp );
+lapack_int LAPACKE_dspgst_work( int matrix_order, lapack_int itype, char uplo,
+                                lapack_int n, double* ap, const double* bp );
+
+lapack_int LAPACKE_sspgv_work( int matrix_order, lapack_int itype, char jobz,
+                               char uplo, lapack_int n, float* ap, float* bp,
+                               float* w, float* z, lapack_int ldz,
+                               float* work );
+lapack_int LAPACKE_dspgv_work( int matrix_order, lapack_int itype, char jobz,
+                               char uplo, lapack_int n, double* ap, double* bp,
+                               double* w, double* z, lapack_int ldz,
+                               double* work );
+
+lapack_int LAPACKE_sspgvd_work( int matrix_order, lapack_int itype, char jobz,
+                                char uplo, lapack_int n, float* ap, float* bp,
+                                float* w, float* z, lapack_int ldz, float* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_dspgvd_work( int matrix_order, lapack_int itype, char jobz,
+                                char uplo, lapack_int n, double* ap, double* bp,
+                                double* w, double* z, lapack_int ldz,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_sspgvx_work( int matrix_order, lapack_int itype, char jobz,
+                                char range, char uplo, lapack_int n, float* ap,
+                                float* bp, float vl, float vu, lapack_int il,
+                                lapack_int iu, float abstol, lapack_int* m,
+                                float* w, float* z, lapack_int ldz, float* work,
+                                lapack_int* iwork, lapack_int* ifail );
+lapack_int LAPACKE_dspgvx_work( int matrix_order, lapack_int itype, char jobz,
+                                char range, char uplo, lapack_int n, double* ap,
+                                double* bp, double vl, double vu, lapack_int il,
+                                lapack_int iu, double abstol, lapack_int* m,
+                                double* w, double* z, lapack_int ldz,
+                                double* work, lapack_int* iwork,
+                                lapack_int* ifail );
+
+lapack_int LAPACKE_ssprfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const float* ap,
+                                const float* afp, const lapack_int* ipiv,
+                                const float* b, lapack_int ldb, float* x,
+                                lapack_int ldx, float* ferr, float* berr,
+                                float* work, lapack_int* iwork );
+lapack_int LAPACKE_dsprfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const double* ap,
+                                const double* afp, const lapack_int* ipiv,
+                                const double* b, lapack_int ldb, double* x,
+                                lapack_int ldx, double* ferr, double* berr,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_csprfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* ap,
+                                const lapack_complex_float* afp,
+                                const lapack_int* ipiv,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zsprfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs,
+                                const lapack_complex_double* ap,
+                                const lapack_complex_double* afp,
+                                const lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sspsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, float* ap, lapack_int* ipiv,
+                               float* b, lapack_int ldb );
+lapack_int LAPACKE_dspsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, double* ap, lapack_int* ipiv,
+                               double* b, lapack_int ldb );
+lapack_int LAPACKE_cspsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_float* ap,
+                               lapack_int* ipiv, lapack_complex_float* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_zspsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_double* ap,
+                               lapack_int* ipiv, lapack_complex_double* b,
+                               lapack_int ldb );
+
+lapack_int LAPACKE_sspsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs, const float* ap,
+                                float* afp, lapack_int* ipiv, const float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* rcond, float* ferr, float* berr,
+                                float* work, lapack_int* iwork );
+lapack_int LAPACKE_dspsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs, const double* ap,
+                                double* afp, lapack_int* ipiv, const double* b,
+                                lapack_int ldb, double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_cspsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_float* ap,
+                                lapack_complex_float* afp, lapack_int* ipiv,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* rcond, float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zspsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_double* ap,
+                                lapack_complex_double* afp, lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_ssptrd_work( int matrix_order, char uplo, lapack_int n,
+                                float* ap, float* d, float* e, float* tau );
+lapack_int LAPACKE_dsptrd_work( int matrix_order, char uplo, lapack_int n,
+                                double* ap, double* d, double* e, double* tau );
+
+lapack_int LAPACKE_ssptrf_work( int matrix_order, char uplo, lapack_int n,
+                                float* ap, lapack_int* ipiv );
+lapack_int LAPACKE_dsptrf_work( int matrix_order, char uplo, lapack_int n,
+                                double* ap, lapack_int* ipiv );
+lapack_int LAPACKE_csptrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* ap, lapack_int* ipiv );
+lapack_int LAPACKE_zsptrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* ap, lapack_int* ipiv );
+
+lapack_int LAPACKE_ssptri_work( int matrix_order, char uplo, lapack_int n,
+                                float* ap, const lapack_int* ipiv,
+                                float* work );
+lapack_int LAPACKE_dsptri_work( int matrix_order, char uplo, lapack_int n,
+                                double* ap, const lapack_int* ipiv,
+                                double* work );
+lapack_int LAPACKE_csptri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* ap,
+                                const lapack_int* ipiv,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zsptri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* ap,
+                                const lapack_int* ipiv,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_ssptrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const float* ap,
+                                const lapack_int* ipiv, float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_dsptrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const double* ap,
+                                const lapack_int* ipiv, double* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_csptrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* ap,
+                                const lapack_int* ipiv, lapack_complex_float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_zsptrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs,
+                                const lapack_complex_double* ap,
+                                const lapack_int* ipiv,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_sstebz_work( char range, char order, lapack_int n, float vl,
+                                float vu, lapack_int il, lapack_int iu,
+                                float abstol, const float* d, const float* e,
+                                lapack_int* m, lapack_int* nsplit, float* w,
+                                lapack_int* iblock, lapack_int* isplit,
+                                float* work, lapack_int* iwork );
+lapack_int LAPACKE_dstebz_work( char range, char order, lapack_int n, double vl,
+                                double vu, lapack_int il, lapack_int iu,
+                                double abstol, const double* d, const double* e,
+                                lapack_int* m, lapack_int* nsplit, double* w,
+                                lapack_int* iblock, lapack_int* isplit,
+                                double* work, lapack_int* iwork );
+
+lapack_int LAPACKE_sstedc_work( int matrix_order, char compz, lapack_int n,
+                                float* d, float* e, float* z, lapack_int ldz,
+                                float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_dstedc_work( int matrix_order, char compz, lapack_int n,
+                                double* d, double* e, double* z, lapack_int ldz,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_cstedc_work( int matrix_order, char compz, lapack_int n,
+                                float* d, float* e, lapack_complex_float* z,
+                                lapack_int ldz, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork,
+                                lapack_int lrwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_zstedc_work( int matrix_order, char compz, lapack_int n,
+                                double* d, double* e, lapack_complex_double* z,
+                                lapack_int ldz, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork,
+                                lapack_int lrwork, lapack_int* iwork,
+                                lapack_int liwork );
+
+lapack_int LAPACKE_sstegr_work( int matrix_order, char jobz, char range,
+                                lapack_int n, float* d, float* e, float vl,
+                                float vu, lapack_int il, lapack_int iu,
+                                float abstol, lapack_int* m, float* w, float* z,
+                                lapack_int ldz, lapack_int* isuppz, float* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_dstegr_work( int matrix_order, char jobz, char range,
+                                lapack_int n, double* d, double* e, double vl,
+                                double vu, lapack_int il, lapack_int iu,
+                                double abstol, lapack_int* m, double* w,
+                                double* z, lapack_int ldz, lapack_int* isuppz,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_cstegr_work( int matrix_order, char jobz, char range,
+                                lapack_int n, float* d, float* e, float vl,
+                                float vu, lapack_int il, lapack_int iu,
+                                float abstol, lapack_int* m, float* w,
+                                lapack_complex_float* z, lapack_int ldz,
+                                lapack_int* isuppz, float* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_zstegr_work( int matrix_order, char jobz, char range,
+                                lapack_int n, double* d, double* e, double vl,
+                                double vu, lapack_int il, lapack_int iu,
+                                double abstol, lapack_int* m, double* w,
+                                lapack_complex_double* z, lapack_int ldz,
+                                lapack_int* isuppz, double* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int liwork );
+
+lapack_int LAPACKE_sstein_work( int matrix_order, lapack_int n, const float* d,
+                                const float* e, lapack_int m, const float* w,
+                                const lapack_int* iblock,
+                                const lapack_int* isplit, float* z,
+                                lapack_int ldz, float* work, lapack_int* iwork,
+                                lapack_int* ifailv );
+lapack_int LAPACKE_dstein_work( int matrix_order, lapack_int n, const double* d,
+                                const double* e, lapack_int m, const double* w,
+                                const lapack_int* iblock,
+                                const lapack_int* isplit, double* z,
+                                lapack_int ldz, double* work, lapack_int* iwork,
+                                lapack_int* ifailv );
+lapack_int LAPACKE_cstein_work( int matrix_order, lapack_int n, const float* d,
+                                const float* e, lapack_int m, const float* w,
+                                const lapack_int* iblock,
+                                const lapack_int* isplit,
+                                lapack_complex_float* z, lapack_int ldz,
+                                float* work, lapack_int* iwork,
+                                lapack_int* ifailv );
+lapack_int LAPACKE_zstein_work( int matrix_order, lapack_int n, const double* d,
+                                const double* e, lapack_int m, const double* w,
+                                const lapack_int* iblock,
+                                const lapack_int* isplit,
+                                lapack_complex_double* z, lapack_int ldz,
+                                double* work, lapack_int* iwork,
+                                lapack_int* ifailv );
+
+lapack_int LAPACKE_sstemr_work( int matrix_order, char jobz, char range,
+                                lapack_int n, float* d, float* e, float vl,
+                                float vu, lapack_int il, lapack_int iu,
+                                lapack_int* m, float* w, float* z,
+                                lapack_int ldz, lapack_int nzc,
+                                lapack_int* isuppz, lapack_logical* tryrac,
+                                float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_dstemr_work( int matrix_order, char jobz, char range,
+                                lapack_int n, double* d, double* e, double vl,
+                                double vu, lapack_int il, lapack_int iu,
+                                lapack_int* m, double* w, double* z,
+                                lapack_int ldz, lapack_int nzc,
+                                lapack_int* isuppz, lapack_logical* tryrac,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_cstemr_work( int matrix_order, char jobz, char range,
+                                lapack_int n, float* d, float* e, float vl,
+                                float vu, lapack_int il, lapack_int iu,
+                                lapack_int* m, float* w,
+                                lapack_complex_float* z, lapack_int ldz,
+                                lapack_int nzc, lapack_int* isuppz,
+                                lapack_logical* tryrac, float* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_zstemr_work( int matrix_order, char jobz, char range,
+                                lapack_int n, double* d, double* e, double vl,
+                                double vu, lapack_int il, lapack_int iu,
+                                lapack_int* m, double* w,
+                                lapack_complex_double* z, lapack_int ldz,
+                                lapack_int nzc, lapack_int* isuppz,
+                                lapack_logical* tryrac, double* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int liwork );
+
+lapack_int LAPACKE_ssteqr_work( int matrix_order, char compz, lapack_int n,
+                                float* d, float* e, float* z, lapack_int ldz,
+                                float* work );
+lapack_int LAPACKE_dsteqr_work( int matrix_order, char compz, lapack_int n,
+                                double* d, double* e, double* z, lapack_int ldz,
+                                double* work );
+lapack_int LAPACKE_csteqr_work( int matrix_order, char compz, lapack_int n,
+                                float* d, float* e, lapack_complex_float* z,
+                                lapack_int ldz, float* work );
+lapack_int LAPACKE_zsteqr_work( int matrix_order, char compz, lapack_int n,
+                                double* d, double* e, lapack_complex_double* z,
+                                lapack_int ldz, double* work );
+
+lapack_int LAPACKE_ssterf_work( lapack_int n, float* d, float* e );
+lapack_int LAPACKE_dsterf_work( lapack_int n, double* d, double* e );
+
+lapack_int LAPACKE_sstev_work( int matrix_order, char jobz, lapack_int n,
+                               float* d, float* e, float* z, lapack_int ldz,
+                               float* work );
+lapack_int LAPACKE_dstev_work( int matrix_order, char jobz, lapack_int n,
+                               double* d, double* e, double* z, lapack_int ldz,
+                               double* work );
+
+lapack_int LAPACKE_sstevd_work( int matrix_order, char jobz, lapack_int n,
+                                float* d, float* e, float* z, lapack_int ldz,
+                                float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_dstevd_work( int matrix_order, char jobz, lapack_int n,
+                                double* d, double* e, double* z, lapack_int ldz,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_sstevr_work( int matrix_order, char jobz, char range,
+                                lapack_int n, float* d, float* e, float vl,
+                                float vu, lapack_int il, lapack_int iu,
+                                float abstol, lapack_int* m, float* w, float* z,
+                                lapack_int ldz, lapack_int* isuppz, float* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_dstevr_work( int matrix_order, char jobz, char range,
+                                lapack_int n, double* d, double* e, double vl,
+                                double vu, lapack_int il, lapack_int iu,
+                                double abstol, lapack_int* m, double* w,
+                                double* z, lapack_int ldz, lapack_int* isuppz,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_sstevx_work( int matrix_order, char jobz, char range,
+                                lapack_int n, float* d, float* e, float vl,
+                                float vu, lapack_int il, lapack_int iu,
+                                float abstol, lapack_int* m, float* w, float* z,
+                                lapack_int ldz, float* work, lapack_int* iwork,
+                                lapack_int* ifail );
+lapack_int LAPACKE_dstevx_work( int matrix_order, char jobz, char range,
+                                lapack_int n, double* d, double* e, double vl,
+                                double vu, lapack_int il, lapack_int iu,
+                                double abstol, lapack_int* m, double* w,
+                                double* z, lapack_int ldz, double* work,
+                                lapack_int* iwork, lapack_int* ifail );
+
+lapack_int LAPACKE_ssycon_work( int matrix_order, char uplo, lapack_int n,
+                                const float* a, lapack_int lda,
+                                const lapack_int* ipiv, float anorm,
+                                float* rcond, float* work, lapack_int* iwork );
+lapack_int LAPACKE_dsycon_work( int matrix_order, char uplo, lapack_int n,
+                                const double* a, lapack_int lda,
+                                const lapack_int* ipiv, double anorm,
+                                double* rcond, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_csycon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_int* ipiv, float anorm,
+                                float* rcond, lapack_complex_float* work );
+lapack_int LAPACKE_zsycon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_int* ipiv, double anorm,
+                                double* rcond, lapack_complex_double* work );
+
+lapack_int LAPACKE_ssyequb_work( int matrix_order, char uplo, lapack_int n,
+                                 const float* a, lapack_int lda, float* s,
+                                 float* scond, float* amax, float* work );
+lapack_int LAPACKE_dsyequb_work( int matrix_order, char uplo, lapack_int n,
+                                 const double* a, lapack_int lda, double* s,
+                                 double* scond, double* amax, double* work );
+lapack_int LAPACKE_csyequb_work( int matrix_order, char uplo, lapack_int n,
+                                 const lapack_complex_float* a, lapack_int lda,
+                                 float* s, float* scond, float* amax,
+                                 lapack_complex_float* work );
+lapack_int LAPACKE_zsyequb_work( int matrix_order, char uplo, lapack_int n,
+                                 const lapack_complex_double* a, lapack_int lda,
+                                 double* s, double* scond, double* amax,
+                                 lapack_complex_double* work );
+
+lapack_int LAPACKE_ssyev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, float* a, lapack_int lda, float* w,
+                               float* work, lapack_int lwork );
+lapack_int LAPACKE_dsyev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, double* a, lapack_int lda,
+                               double* w, double* work, lapack_int lwork );
+
+lapack_int LAPACKE_ssyevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, float* a, lapack_int lda,
+                                float* w, float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_dsyevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, double* a, lapack_int lda,
+                                double* w, double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_ssyevr_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, float* a,
+                                lapack_int lda, float vl, float vu,
+                                lapack_int il, lapack_int iu, float abstol,
+                                lapack_int* m, float* w, float* z,
+                                lapack_int ldz, lapack_int* isuppz, float* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_dsyevr_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, double* a,
+                                lapack_int lda, double vl, double vu,
+                                lapack_int il, lapack_int iu, double abstol,
+                                lapack_int* m, double* w, double* z,
+                                lapack_int ldz, lapack_int* isuppz,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_ssyevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, float* a,
+                                lapack_int lda, float vl, float vu,
+                                lapack_int il, lapack_int iu, float abstol,
+                                lapack_int* m, float* w, float* z,
+                                lapack_int ldz, float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int* ifail );
+lapack_int LAPACKE_dsyevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, double* a,
+                                lapack_int lda, double vl, double vu,
+                                lapack_int il, lapack_int iu, double abstol,
+                                lapack_int* m, double* w, double* z,
+                                lapack_int ldz, double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int* ifail );
+
+lapack_int LAPACKE_ssygst_work( int matrix_order, lapack_int itype, char uplo,
+                                lapack_int n, float* a, lapack_int lda,
+                                const float* b, lapack_int ldb );
+lapack_int LAPACKE_dsygst_work( int matrix_order, lapack_int itype, char uplo,
+                                lapack_int n, double* a, lapack_int lda,
+                                const double* b, lapack_int ldb );
+
+lapack_int LAPACKE_ssygv_work( int matrix_order, lapack_int itype, char jobz,
+                               char uplo, lapack_int n, float* a,
+                               lapack_int lda, float* b, lapack_int ldb,
+                               float* w, float* work, lapack_int lwork );
+lapack_int LAPACKE_dsygv_work( int matrix_order, lapack_int itype, char jobz,
+                               char uplo, lapack_int n, double* a,
+                               lapack_int lda, double* b, lapack_int ldb,
+                               double* w, double* work, lapack_int lwork );
+
+lapack_int LAPACKE_ssygvd_work( int matrix_order, lapack_int itype, char jobz,
+                                char uplo, lapack_int n, float* a,
+                                lapack_int lda, float* b, lapack_int ldb,
+                                float* w, float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_dsygvd_work( int matrix_order, lapack_int itype, char jobz,
+                                char uplo, lapack_int n, double* a,
+                                lapack_int lda, double* b, lapack_int ldb,
+                                double* w, double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_ssygvx_work( int matrix_order, lapack_int itype, char jobz,
+                                char range, char uplo, lapack_int n, float* a,
+                                lapack_int lda, float* b, lapack_int ldb,
+                                float vl, float vu, lapack_int il,
+                                lapack_int iu, float abstol, lapack_int* m,
+                                float* w, float* z, lapack_int ldz, float* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int* ifail );
+lapack_int LAPACKE_dsygvx_work( int matrix_order, lapack_int itype, char jobz,
+                                char range, char uplo, lapack_int n, double* a,
+                                lapack_int lda, double* b, lapack_int ldb,
+                                double vl, double vu, lapack_int il,
+                                lapack_int iu, double abstol, lapack_int* m,
+                                double* w, double* z, lapack_int ldz,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int* ifail );
+
+lapack_int LAPACKE_ssyrfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const float* a, lapack_int lda,
+                                const float* af, lapack_int ldaf,
+                                const lapack_int* ipiv, const float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* ferr, float* berr, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dsyrfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const double* a,
+                                lapack_int lda, const double* af,
+                                lapack_int ldaf, const lapack_int* ipiv,
+                                const double* b, lapack_int ldb, double* x,
+                                lapack_int ldx, double* ferr, double* berr,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_csyrfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* af,
+                                lapack_int ldaf, const lapack_int* ipiv,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zsyrfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_double* a,
+                                lapack_int lda, const lapack_complex_double* af,
+                                lapack_int ldaf, const lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_ssyrfsx_work( int matrix_order, char uplo, char equed,
+                                 lapack_int n, lapack_int nrhs, const float* a,
+                                 lapack_int lda, const float* af,
+                                 lapack_int ldaf, const lapack_int* ipiv,
+                                 const float* s, const float* b, lapack_int ldb,
+                                 float* x, lapack_int ldx, float* rcond,
+                                 float* berr, lapack_int n_err_bnds,
+                                 float* err_bnds_norm, float* err_bnds_comp,
+                                 lapack_int nparams, float* params, float* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_dsyrfsx_work( int matrix_order, char uplo, char equed,
+                                 lapack_int n, lapack_int nrhs, const double* a,
+                                 lapack_int lda, const double* af,
+                                 lapack_int ldaf, const lapack_int* ipiv,
+                                 const double* s, const double* b,
+                                 lapack_int ldb, double* x, lapack_int ldx,
+                                 double* rcond, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, double* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_csyrfsx_work( int matrix_order, char uplo, char equed,
+                                 lapack_int n, lapack_int nrhs,
+                                 const lapack_complex_float* a, lapack_int lda,
+                                 const lapack_complex_float* af,
+                                 lapack_int ldaf, const lapack_int* ipiv,
+                                 const float* s, const lapack_complex_float* b,
+                                 lapack_int ldb, lapack_complex_float* x,
+                                 lapack_int ldx, float* rcond, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, lapack_complex_float* work,
+                                 float* rwork );
+lapack_int LAPACKE_zsyrfsx_work( int matrix_order, char uplo, char equed,
+                                 lapack_int n, lapack_int nrhs,
+                                 const lapack_complex_double* a, lapack_int lda,
+                                 const lapack_complex_double* af,
+                                 lapack_int ldaf, const lapack_int* ipiv,
+                                 const double* s,
+                                 const lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* x, lapack_int ldx,
+                                 double* rcond, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, lapack_complex_double* work,
+                                 double* rwork );
+
+lapack_int LAPACKE_ssysv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, float* a, lapack_int lda,
+                               lapack_int* ipiv, float* b, lapack_int ldb,
+                               float* work, lapack_int lwork );
+lapack_int LAPACKE_dsysv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, double* a, lapack_int lda,
+                               lapack_int* ipiv, double* b, lapack_int ldb,
+                               double* work, lapack_int lwork );
+lapack_int LAPACKE_csysv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_float* a,
+                               lapack_int lda, lapack_int* ipiv,
+                               lapack_complex_float* b, lapack_int ldb,
+                               lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zsysv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_double* a,
+                               lapack_int lda, lapack_int* ipiv,
+                               lapack_complex_double* b, lapack_int ldb,
+                               lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_ssysvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs, const float* a,
+                                lapack_int lda, float* af, lapack_int ldaf,
+                                lapack_int* ipiv, const float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* rcond, float* ferr, float* berr,
+                                float* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dsysvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs, const double* a,
+                                lapack_int lda, double* af, lapack_int ldaf,
+                                lapack_int* ipiv, const double* b,
+                                lapack_int ldb, double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_csysvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* af, lapack_int ldaf,
+                                lapack_int* ipiv, const lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* x,
+                                lapack_int ldx, float* rcond, float* ferr,
+                                float* berr, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork );
+lapack_int LAPACKE_zsysvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* af, lapack_int ldaf,
+                                lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork );
+
+lapack_int LAPACKE_ssysvxx_work( int matrix_order, char fact, char uplo,
+                                 lapack_int n, lapack_int nrhs, float* a,
+                                 lapack_int lda, float* af, lapack_int ldaf,
+                                 lapack_int* ipiv, char* equed, float* s,
+                                 float* b, lapack_int ldb, float* x,
+                                 lapack_int ldx, float* rcond, float* rpvgrw,
+                                 float* berr, lapack_int n_err_bnds,
+                                 float* err_bnds_norm, float* err_bnds_comp,
+                                 lapack_int nparams, float* params, float* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_dsysvxx_work( int matrix_order, char fact, char uplo,
+                                 lapack_int n, lapack_int nrhs, double* a,
+                                 lapack_int lda, double* af, lapack_int ldaf,
+                                 lapack_int* ipiv, char* equed, double* s,
+                                 double* b, lapack_int ldb, double* x,
+                                 lapack_int ldx, double* rcond, double* rpvgrw,
+                                 double* berr, lapack_int n_err_bnds,
+                                 double* err_bnds_norm, double* err_bnds_comp,
+                                 lapack_int nparams, double* params,
+                                 double* work, lapack_int* iwork );
+lapack_int LAPACKE_csysvxx_work( int matrix_order, char fact, char uplo,
+                                 lapack_int n, lapack_int nrhs,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 lapack_complex_float* af, lapack_int ldaf,
+                                 lapack_int* ipiv, char* equed, float* s,
+                                 lapack_complex_float* b, lapack_int ldb,
+                                 lapack_complex_float* x, lapack_int ldx,
+                                 float* rcond, float* rpvgrw, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, lapack_complex_float* work,
+                                 float* rwork );
+lapack_int LAPACKE_zsysvxx_work( int matrix_order, char fact, char uplo,
+                                 lapack_int n, lapack_int nrhs,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 lapack_complex_double* af, lapack_int ldaf,
+                                 lapack_int* ipiv, char* equed, double* s,
+                                 lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* x, lapack_int ldx,
+                                 double* rcond, double* rpvgrw, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, lapack_complex_double* work,
+                                 double* rwork );
+
+lapack_int LAPACKE_ssytrd_work( int matrix_order, char uplo, lapack_int n,
+                                float* a, lapack_int lda, float* d, float* e,
+                                float* tau, float* work, lapack_int lwork );
+lapack_int LAPACKE_dsytrd_work( int matrix_order, char uplo, lapack_int n,
+                                double* a, lapack_int lda, double* d, double* e,
+                                double* tau, double* work, lapack_int lwork );
+
+lapack_int LAPACKE_ssytrf_work( int matrix_order, char uplo, lapack_int n,
+                                float* a, lapack_int lda, lapack_int* ipiv,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dsytrf_work( int matrix_order, char uplo, lapack_int n,
+                                double* a, lapack_int lda, lapack_int* ipiv,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_csytrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_int* ipiv, lapack_complex_float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_zsytrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int* ipiv, lapack_complex_double* work,
+                                lapack_int lwork );
+
+lapack_int LAPACKE_ssytri_work( int matrix_order, char uplo, lapack_int n,
+                                float* a, lapack_int lda,
+                                const lapack_int* ipiv, float* work );
+lapack_int LAPACKE_dsytri_work( int matrix_order, char uplo, lapack_int n,
+                                double* a, lapack_int lda,
+                                const lapack_int* ipiv, double* work );
+lapack_int LAPACKE_csytri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                const lapack_int* ipiv,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zsytri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                const lapack_int* ipiv,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_ssytrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const float* a, lapack_int lda,
+                                const lapack_int* ipiv, float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_dsytrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const double* a,
+                                lapack_int lda, const lapack_int* ipiv,
+                                double* b, lapack_int ldb );
+lapack_int LAPACKE_csytrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* a,
+                                lapack_int lda, const lapack_int* ipiv,
+                                lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zsytrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_double* a,
+                                lapack_int lda, const lapack_int* ipiv,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_stbcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n, lapack_int kd,
+                                const float* ab, lapack_int ldab, float* rcond,
+                                float* work, lapack_int* iwork );
+lapack_int LAPACKE_dtbcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n, lapack_int kd,
+                                const double* ab, lapack_int ldab,
+                                double* rcond, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_ctbcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n, lapack_int kd,
+                                const lapack_complex_float* ab, lapack_int ldab,
+                                float* rcond, lapack_complex_float* work,
+                                float* rwork );
+lapack_int LAPACKE_ztbcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n, lapack_int kd,
+                                const lapack_complex_double* ab,
+                                lapack_int ldab, double* rcond,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_stbrfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int kd,
+                                lapack_int nrhs, const float* ab,
+                                lapack_int ldab, const float* b, lapack_int ldb,
+                                const float* x, lapack_int ldx, float* ferr,
+                                float* berr, float* work, lapack_int* iwork );
+lapack_int LAPACKE_dtbrfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int kd,
+                                lapack_int nrhs, const double* ab,
+                                lapack_int ldab, const double* b,
+                                lapack_int ldb, const double* x, lapack_int ldx,
+                                double* ferr, double* berr, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_ctbrfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int kd,
+                                lapack_int nrhs, const lapack_complex_float* ab,
+                                lapack_int ldab, const lapack_complex_float* b,
+                                lapack_int ldb, const lapack_complex_float* x,
+                                lapack_int ldx, float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_ztbrfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int kd,
+                                lapack_int nrhs,
+                                const lapack_complex_double* ab,
+                                lapack_int ldab, const lapack_complex_double* b,
+                                lapack_int ldb, const lapack_complex_double* x,
+                                lapack_int ldx, double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_stbtrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int kd,
+                                lapack_int nrhs, const float* ab,
+                                lapack_int ldab, float* b, lapack_int ldb );
+lapack_int LAPACKE_dtbtrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int kd,
+                                lapack_int nrhs, const double* ab,
+                                lapack_int ldab, double* b, lapack_int ldb );
+lapack_int LAPACKE_ctbtrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int kd,
+                                lapack_int nrhs, const lapack_complex_float* ab,
+                                lapack_int ldab, lapack_complex_float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_ztbtrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int kd,
+                                lapack_int nrhs,
+                                const lapack_complex_double* ab,
+                                lapack_int ldab, lapack_complex_double* b,
+                                lapack_int ldb );
+
+lapack_int LAPACKE_stfsm_work( int matrix_order, char transr, char side,
+                               char uplo, char trans, char diag, lapack_int m,
+                               lapack_int n, float alpha, const float* a,
+                               float* b, lapack_int ldb );
+lapack_int LAPACKE_dtfsm_work( int matrix_order, char transr, char side,
+                               char uplo, char trans, char diag, lapack_int m,
+                               lapack_int n, double alpha, const double* a,
+                               double* b, lapack_int ldb );
+lapack_int LAPACKE_ctfsm_work( int matrix_order, char transr, char side,
+                               char uplo, char trans, char diag, lapack_int m,
+                               lapack_int n, lapack_complex_float alpha,
+                               const lapack_complex_float* a,
+                               lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_ztfsm_work( int matrix_order, char transr, char side,
+                               char uplo, char trans, char diag, lapack_int m,
+                               lapack_int n, lapack_complex_double alpha,
+                               const lapack_complex_double* a,
+                               lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_stftri_work( int matrix_order, char transr, char uplo,
+                                char diag, lapack_int n, float* a );
+lapack_int LAPACKE_dtftri_work( int matrix_order, char transr, char uplo,
+                                char diag, lapack_int n, double* a );
+lapack_int LAPACKE_ctftri_work( int matrix_order, char transr, char uplo,
+                                char diag, lapack_int n,
+                                lapack_complex_float* a );
+lapack_int LAPACKE_ztftri_work( int matrix_order, char transr, char uplo,
+                                char diag, lapack_int n,
+                                lapack_complex_double* a );
+
+lapack_int LAPACKE_stfttp_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const float* arf, float* ap );
+lapack_int LAPACKE_dtfttp_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const double* arf, double* ap );
+lapack_int LAPACKE_ctfttp_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const lapack_complex_float* arf,
+                                lapack_complex_float* ap );
+lapack_int LAPACKE_ztfttp_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const lapack_complex_double* arf,
+                                lapack_complex_double* ap );
+
+lapack_int LAPACKE_stfttr_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const float* arf, float* a,
+                                lapack_int lda );
+lapack_int LAPACKE_dtfttr_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const double* arf, double* a,
+                                lapack_int lda );
+lapack_int LAPACKE_ctfttr_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const lapack_complex_float* arf,
+                                lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_ztfttr_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const lapack_complex_double* arf,
+                                lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_stgevc_work( int matrix_order, char side, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const float* s, lapack_int lds, const float* p,
+                                lapack_int ldp, float* vl, lapack_int ldvl,
+                                float* vr, lapack_int ldvr, lapack_int mm,
+                                lapack_int* m, float* work );
+lapack_int LAPACKE_dtgevc_work( int matrix_order, char side, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const double* s, lapack_int lds,
+                                const double* p, lapack_int ldp, double* vl,
+                                lapack_int ldvl, double* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m, double* work );
+lapack_int LAPACKE_ctgevc_work( int matrix_order, char side, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const lapack_complex_float* s, lapack_int lds,
+                                const lapack_complex_float* p, lapack_int ldp,
+                                lapack_complex_float* vl, lapack_int ldvl,
+                                lapack_complex_float* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_ztgevc_work( int matrix_order, char side, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const lapack_complex_double* s, lapack_int lds,
+                                const lapack_complex_double* p, lapack_int ldp,
+                                lapack_complex_double* vl, lapack_int ldvl,
+                                lapack_complex_double* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_stgexc_work( int matrix_order, lapack_logical wantq,
+                                lapack_logical wantz, lapack_int n, float* a,
+                                lapack_int lda, float* b, lapack_int ldb,
+                                float* q, lapack_int ldq, float* z,
+                                lapack_int ldz, lapack_int* ifst,
+                                lapack_int* ilst, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dtgexc_work( int matrix_order, lapack_logical wantq,
+                                lapack_logical wantz, lapack_int n, double* a,
+                                lapack_int lda, double* b, lapack_int ldb,
+                                double* q, lapack_int ldq, double* z,
+                                lapack_int ldz, lapack_int* ifst,
+                                lapack_int* ilst, double* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_ctgexc_work( int matrix_order, lapack_logical wantq,
+                                lapack_logical wantz, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* q, lapack_int ldq,
+                                lapack_complex_float* z, lapack_int ldz,
+                                lapack_int ifst, lapack_int ilst );
+lapack_int LAPACKE_ztgexc_work( int matrix_order, lapack_logical wantq,
+                                lapack_logical wantz, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* q, lapack_int ldq,
+                                lapack_complex_double* z, lapack_int ldz,
+                                lapack_int ifst, lapack_int ilst );
+
+lapack_int LAPACKE_stgsen_work( int matrix_order, lapack_int ijob,
+                                lapack_logical wantq, lapack_logical wantz,
+                                const lapack_logical* select, lapack_int n,
+                                float* a, lapack_int lda, float* b,
+                                lapack_int ldb, float* alphar, float* alphai,
+                                float* beta, float* q, lapack_int ldq, float* z,
+                                lapack_int ldz, lapack_int* m, float* pl,
+                                float* pr, float* dif, float* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_dtgsen_work( int matrix_order, lapack_int ijob,
+                                lapack_logical wantq, lapack_logical wantz,
+                                const lapack_logical* select, lapack_int n,
+                                double* a, lapack_int lda, double* b,
+                                lapack_int ldb, double* alphar, double* alphai,
+                                double* beta, double* q, lapack_int ldq,
+                                double* z, lapack_int ldz, lapack_int* m,
+                                double* pl, double* pr, double* dif,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_ctgsen_work( int matrix_order, lapack_int ijob,
+                                lapack_logical wantq, lapack_logical wantz,
+                                const lapack_logical* select, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* alpha,
+                                lapack_complex_float* beta,
+                                lapack_complex_float* q, lapack_int ldq,
+                                lapack_complex_float* z, lapack_int ldz,
+                                lapack_int* m, float* pl, float* pr, float* dif,
+                                lapack_complex_float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_ztgsen_work( int matrix_order, lapack_int ijob,
+                                lapack_logical wantq, lapack_logical wantz,
+                                const lapack_logical* select, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* alpha,
+                                lapack_complex_double* beta,
+                                lapack_complex_double* q, lapack_int ldq,
+                                lapack_complex_double* z, lapack_int ldz,
+                                lapack_int* m, double* pl, double* pr,
+                                double* dif, lapack_complex_double* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int liwork );
+
+lapack_int LAPACKE_stgsja_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int p,
+                                lapack_int n, lapack_int k, lapack_int l,
+                                float* a, lapack_int lda, float* b,
+                                lapack_int ldb, float tola, float tolb,
+                                float* alpha, float* beta, float* u,
+                                lapack_int ldu, float* v, lapack_int ldv,
+                                float* q, lapack_int ldq, float* work,
+                                lapack_int* ncycle );
+lapack_int LAPACKE_dtgsja_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int p,
+                                lapack_int n, lapack_int k, lapack_int l,
+                                double* a, lapack_int lda, double* b,
+                                lapack_int ldb, double tola, double tolb,
+                                double* alpha, double* beta, double* u,
+                                lapack_int ldu, double* v, lapack_int ldv,
+                                double* q, lapack_int ldq, double* work,
+                                lapack_int* ncycle );
+lapack_int LAPACKE_ctgsja_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int p,
+                                lapack_int n, lapack_int k, lapack_int l,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb,
+                                float tola, float tolb, float* alpha,
+                                float* beta, lapack_complex_float* u,
+                                lapack_int ldu, lapack_complex_float* v,
+                                lapack_int ldv, lapack_complex_float* q,
+                                lapack_int ldq, lapack_complex_float* work,
+                                lapack_int* ncycle );
+lapack_int LAPACKE_ztgsja_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int p,
+                                lapack_int n, lapack_int k, lapack_int l,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                double tola, double tolb, double* alpha,
+                                double* beta, lapack_complex_double* u,
+                                lapack_int ldu, lapack_complex_double* v,
+                                lapack_int ldv, lapack_complex_double* q,
+                                lapack_int ldq, lapack_complex_double* work,
+                                lapack_int* ncycle );
+
+lapack_int LAPACKE_stgsna_work( int matrix_order, char job, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const float* a, lapack_int lda, const float* b,
+                                lapack_int ldb, const float* vl,
+                                lapack_int ldvl, const float* vr,
+                                lapack_int ldvr, float* s, float* dif,
+                                lapack_int mm, lapack_int* m, float* work,
+                                lapack_int lwork, lapack_int* iwork );
+lapack_int LAPACKE_dtgsna_work( int matrix_order, char job, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const double* a, lapack_int lda,
+                                const double* b, lapack_int ldb,
+                                const double* vl, lapack_int ldvl,
+                                const double* vr, lapack_int ldvr, double* s,
+                                double* dif, lapack_int mm, lapack_int* m,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_ctgsna_work( int matrix_order, char job, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                const lapack_complex_float* vl, lapack_int ldvl,
+                                const lapack_complex_float* vr, lapack_int ldvr,
+                                float* s, float* dif, lapack_int mm,
+                                lapack_int* m, lapack_complex_float* work,
+                                lapack_int lwork, lapack_int* iwork );
+lapack_int LAPACKE_ztgsna_work( int matrix_order, char job, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                const lapack_complex_double* vl,
+                                lapack_int ldvl,
+                                const lapack_complex_double* vr,
+                                lapack_int ldvr, double* s, double* dif,
+                                lapack_int mm, lapack_int* m,
+                                lapack_complex_double* work, lapack_int lwork,
+                                lapack_int* iwork );
+
+lapack_int LAPACKE_stgsyl_work( int matrix_order, char trans, lapack_int ijob,
+                                lapack_int m, lapack_int n, const float* a,
+                                lapack_int lda, const float* b, lapack_int ldb,
+                                float* c, lapack_int ldc, const float* d,
+                                lapack_int ldd, const float* e, lapack_int lde,
+                                float* f, lapack_int ldf, float* scale,
+                                float* dif, float* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dtgsyl_work( int matrix_order, char trans, lapack_int ijob,
+                                lapack_int m, lapack_int n, const double* a,
+                                lapack_int lda, const double* b, lapack_int ldb,
+                                double* c, lapack_int ldc, const double* d,
+                                lapack_int ldd, const double* e, lapack_int lde,
+                                double* f, lapack_int ldf, double* scale,
+                                double* dif, double* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_ctgsyl_work( int matrix_order, char trans, lapack_int ijob,
+                                lapack_int m, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* c, lapack_int ldc,
+                                const lapack_complex_float* d, lapack_int ldd,
+                                const lapack_complex_float* e, lapack_int lde,
+                                lapack_complex_float* f, lapack_int ldf,
+                                float* scale, float* dif,
+                                lapack_complex_float* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_ztgsyl_work( int matrix_order, char trans, lapack_int ijob,
+                                lapack_int m, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* c, lapack_int ldc,
+                                const lapack_complex_double* d, lapack_int ldd,
+                                const lapack_complex_double* e, lapack_int lde,
+                                lapack_complex_double* f, lapack_int ldf,
+                                double* scale, double* dif,
+                                lapack_complex_double* work, lapack_int lwork,
+                                lapack_int* iwork );
+
+lapack_int LAPACKE_stpcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n, const float* ap,
+                                float* rcond, float* work, lapack_int* iwork );
+lapack_int LAPACKE_dtpcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n, const double* ap,
+                                double* rcond, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_ctpcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n,
+                                const lapack_complex_float* ap, float* rcond,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_ztpcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n,
+                                const lapack_complex_double* ap, double* rcond,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_stprfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const float* ap, const float* b, lapack_int ldb,
+                                const float* x, lapack_int ldx, float* ferr,
+                                float* berr, float* work, lapack_int* iwork );
+lapack_int LAPACKE_dtprfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const double* ap, const double* b,
+                                lapack_int ldb, const double* x, lapack_int ldx,
+                                double* ferr, double* berr, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_ctprfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const lapack_complex_float* ap,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                const lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_ztprfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const lapack_complex_double* ap,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                const lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_stptri_work( int matrix_order, char uplo, char diag,
+                                lapack_int n, float* ap );
+lapack_int LAPACKE_dtptri_work( int matrix_order, char uplo, char diag,
+                                lapack_int n, double* ap );
+lapack_int LAPACKE_ctptri_work( int matrix_order, char uplo, char diag,
+                                lapack_int n, lapack_complex_float* ap );
+lapack_int LAPACKE_ztptri_work( int matrix_order, char uplo, char diag,
+                                lapack_int n, lapack_complex_double* ap );
+
+lapack_int LAPACKE_stptrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const float* ap, float* b, lapack_int ldb );
+lapack_int LAPACKE_dtptrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const double* ap, double* b, lapack_int ldb );
+lapack_int LAPACKE_ctptrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const lapack_complex_float* ap,
+                                lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_ztptrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const lapack_complex_double* ap,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_stpttf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const float* ap, float* arf );
+lapack_int LAPACKE_dtpttf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const double* ap, double* arf );
+lapack_int LAPACKE_ctpttf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const lapack_complex_float* ap,
+                                lapack_complex_float* arf );
+lapack_int LAPACKE_ztpttf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const lapack_complex_double* ap,
+                                lapack_complex_double* arf );
+
+lapack_int LAPACKE_stpttr_work( int matrix_order, char uplo, lapack_int n,
+                                const float* ap, float* a, lapack_int lda );
+lapack_int LAPACKE_dtpttr_work( int matrix_order, char uplo, lapack_int n,
+                                const double* ap, double* a, lapack_int lda );
+lapack_int LAPACKE_ctpttr_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_float* ap,
+                                lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_ztpttr_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_double* ap,
+                                lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_strcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n, const float* a,
+                                lapack_int lda, float* rcond, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dtrcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n, const double* a,
+                                lapack_int lda, double* rcond, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_ctrcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                float* rcond, lapack_complex_float* work,
+                                float* rwork );
+lapack_int LAPACKE_ztrcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                double* rcond, lapack_complex_double* work,
+                                double* rwork );
+
+lapack_int LAPACKE_strevc_work( int matrix_order, char side, char howmny,
+                                lapack_logical* select, lapack_int n,
+                                const float* t, lapack_int ldt, float* vl,
+                                lapack_int ldvl, float* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m, float* work );
+lapack_int LAPACKE_dtrevc_work( int matrix_order, char side, char howmny,
+                                lapack_logical* select, lapack_int n,
+                                const double* t, lapack_int ldt, double* vl,
+                                lapack_int ldvl, double* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m, double* work );
+lapack_int LAPACKE_ctrevc_work( int matrix_order, char side, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                lapack_complex_float* t, lapack_int ldt,
+                                lapack_complex_float* vl, lapack_int ldvl,
+                                lapack_complex_float* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_ztrevc_work( int matrix_order, char side, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                lapack_complex_double* t, lapack_int ldt,
+                                lapack_complex_double* vl, lapack_int ldvl,
+                                lapack_complex_double* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_strexc_work( int matrix_order, char compq, lapack_int n,
+                                float* t, lapack_int ldt, float* q,
+                                lapack_int ldq, lapack_int* ifst,
+                                lapack_int* ilst, float* work );
+lapack_int LAPACKE_dtrexc_work( int matrix_order, char compq, lapack_int n,
+                                double* t, lapack_int ldt, double* q,
+                                lapack_int ldq, lapack_int* ifst,
+                                lapack_int* ilst, double* work );
+lapack_int LAPACKE_ctrexc_work( int matrix_order, char compq, lapack_int n,
+                                lapack_complex_float* t, lapack_int ldt,
+                                lapack_complex_float* q, lapack_int ldq,
+                                lapack_int ifst, lapack_int ilst );
+lapack_int LAPACKE_ztrexc_work( int matrix_order, char compq, lapack_int n,
+                                lapack_complex_double* t, lapack_int ldt,
+                                lapack_complex_double* q, lapack_int ldq,
+                                lapack_int ifst, lapack_int ilst );
+
+lapack_int LAPACKE_strrfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const float* a, lapack_int lda, const float* b,
+                                lapack_int ldb, const float* x, lapack_int ldx,
+                                float* ferr, float* berr, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dtrrfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const double* a, lapack_int lda,
+                                const double* b, lapack_int ldb,
+                                const double* x, lapack_int ldx, double* ferr,
+                                double* berr, double* work, lapack_int* iwork );
+lapack_int LAPACKE_ctrrfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                const lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_ztrrfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                const lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_strsen_work( int matrix_order, char job, char compq,
+                                const lapack_logical* select, lapack_int n,
+                                float* t, lapack_int ldt, float* q,
+                                lapack_int ldq, float* wr, float* wi,
+                                lapack_int* m, float* s, float* sep,
+                                float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_dtrsen_work( int matrix_order, char job, char compq,
+                                const lapack_logical* select, lapack_int n,
+                                double* t, lapack_int ldt, double* q,
+                                lapack_int ldq, double* wr, double* wi,
+                                lapack_int* m, double* s, double* sep,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_ctrsen_work( int matrix_order, char job, char compq,
+                                const lapack_logical* select, lapack_int n,
+                                lapack_complex_float* t, lapack_int ldt,
+                                lapack_complex_float* q, lapack_int ldq,
+                                lapack_complex_float* w, lapack_int* m,
+                                float* s, float* sep,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_ztrsen_work( int matrix_order, char job, char compq,
+                                const lapack_logical* select, lapack_int n,
+                                lapack_complex_double* t, lapack_int ldt,
+                                lapack_complex_double* q, lapack_int ldq,
+                                lapack_complex_double* w, lapack_int* m,
+                                double* s, double* sep,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_strsna_work( int matrix_order, char job, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const float* t, lapack_int ldt, const float* vl,
+                                lapack_int ldvl, const float* vr,
+                                lapack_int ldvr, float* s, float* sep,
+                                lapack_int mm, lapack_int* m, float* work,
+                                lapack_int ldwork, lapack_int* iwork );
+lapack_int LAPACKE_dtrsna_work( int matrix_order, char job, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const double* t, lapack_int ldt,
+                                const double* vl, lapack_int ldvl,
+                                const double* vr, lapack_int ldvr, double* s,
+                                double* sep, lapack_int mm, lapack_int* m,
+                                double* work, lapack_int ldwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_ctrsna_work( int matrix_order, char job, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const lapack_complex_float* t, lapack_int ldt,
+                                const lapack_complex_float* vl, lapack_int ldvl,
+                                const lapack_complex_float* vr, lapack_int ldvr,
+                                float* s, float* sep, lapack_int mm,
+                                lapack_int* m, lapack_complex_float* work,
+                                lapack_int ldwork, float* rwork );
+lapack_int LAPACKE_ztrsna_work( int matrix_order, char job, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const lapack_complex_double* t, lapack_int ldt,
+                                const lapack_complex_double* vl,
+                                lapack_int ldvl,
+                                const lapack_complex_double* vr,
+                                lapack_int ldvr, double* s, double* sep,
+                                lapack_int mm, lapack_int* m,
+                                lapack_complex_double* work, lapack_int ldwork,
+                                double* rwork );
+
+lapack_int LAPACKE_strsyl_work( int matrix_order, char trana, char tranb,
+                                lapack_int isgn, lapack_int m, lapack_int n,
+                                const float* a, lapack_int lda, const float* b,
+                                lapack_int ldb, float* c, lapack_int ldc,
+                                float* scale );
+lapack_int LAPACKE_dtrsyl_work( int matrix_order, char trana, char tranb,
+                                lapack_int isgn, lapack_int m, lapack_int n,
+                                const double* a, lapack_int lda,
+                                const double* b, lapack_int ldb, double* c,
+                                lapack_int ldc, double* scale );
+lapack_int LAPACKE_ctrsyl_work( int matrix_order, char trana, char tranb,
+                                lapack_int isgn, lapack_int m, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* c, lapack_int ldc,
+                                float* scale );
+lapack_int LAPACKE_ztrsyl_work( int matrix_order, char trana, char tranb,
+                                lapack_int isgn, lapack_int m, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* c, lapack_int ldc,
+                                double* scale );
+
+lapack_int LAPACKE_strtri_work( int matrix_order, char uplo, char diag,
+                                lapack_int n, float* a, lapack_int lda );
+lapack_int LAPACKE_dtrtri_work( int matrix_order, char uplo, char diag,
+                                lapack_int n, double* a, lapack_int lda );
+lapack_int LAPACKE_ctrtri_work( int matrix_order, char uplo, char diag,
+                                lapack_int n, lapack_complex_float* a,
+                                lapack_int lda );
+lapack_int LAPACKE_ztrtri_work( int matrix_order, char uplo, char diag,
+                                lapack_int n, lapack_complex_double* a,
+                                lapack_int lda );
+
+lapack_int LAPACKE_strtrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const float* a, lapack_int lda, float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_dtrtrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const double* a, lapack_int lda, double* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_ctrtrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_ztrtrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_strttf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const float* a, lapack_int lda,
+                                float* arf );
+lapack_int LAPACKE_dtrttf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const double* a, lapack_int lda,
+                                double* arf );
+lapack_int LAPACKE_ctrttf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* arf );
+lapack_int LAPACKE_ztrttf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* arf );
+
+lapack_int LAPACKE_strttp_work( int matrix_order, char uplo, lapack_int n,
+                                const float* a, lapack_int lda, float* ap );
+lapack_int LAPACKE_dtrttp_work( int matrix_order, char uplo, lapack_int n,
+                                const double* a, lapack_int lda, double* ap );
+lapack_int LAPACKE_ctrttp_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* ap );
+lapack_int LAPACKE_ztrttp_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* ap );
+
+lapack_int LAPACKE_stzrzf_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, float* tau,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dtzrzf_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, double* tau,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_ctzrzf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_ztzrzf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cungbr_work( int matrix_order, char vect, lapack_int m,
+                                lapack_int n, lapack_int k,
+                                lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zungbr_work( int matrix_order, char vect, lapack_int m,
+                                lapack_int n, lapack_int k,
+                                lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cunghr_work( int matrix_order, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zunghr_work( int matrix_order, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, lapack_complex_double* a,
+                                lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cunglq_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zunglq_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, lapack_complex_double* a,
+                                lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cungql_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zungql_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, lapack_complex_double* a,
+                                lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cungqr_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zungqr_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, lapack_complex_double* a,
+                                lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cungrq_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zungrq_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, lapack_complex_double* a,
+                                lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cungtr_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zungtr_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cunmbr_work( int matrix_order, char vect, char side,
+                                char trans, lapack_int m, lapack_int n,
+                                lapack_int k, const lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* tau,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zunmbr_work( int matrix_order, char vect, char side,
+                                char trans, lapack_int m, lapack_int n,
+                                lapack_int k, const lapack_complex_double* a,
+                                lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cunmhr_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, const lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* tau,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zunmhr_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, const lapack_complex_double* a,
+                                lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cunmlq_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* tau,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zunmlq_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cunmql_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* tau,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zunmql_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cunmqr_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* tau,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zunmqr_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cunmrq_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* tau,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zunmrq_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cunmrz_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                lapack_int l, const lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* tau,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zunmrz_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                lapack_int l, const lapack_complex_double* a,
+                                lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cunmtr_work( int matrix_order, char side, char uplo,
+                                char trans, lapack_int m, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* tau,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zunmtr_work( int matrix_order, char side, char uplo,
+                                char trans, lapack_int m, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cupgtr_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_float* ap,
+                                const lapack_complex_float* tau,
+                                lapack_complex_float* q, lapack_int ldq,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zupgtr_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_double* ap,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* q, lapack_int ldq,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_cupmtr_work( int matrix_order, char side, char uplo,
+                                char trans, lapack_int m, lapack_int n,
+                                const lapack_complex_float* ap,
+                                const lapack_complex_float* tau,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zupmtr_work( int matrix_order, char side, char uplo,
+                                char trans, lapack_int m, lapack_int n,
+                                const lapack_complex_double* ap,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_claghe( int matrix_order, lapack_int n, lapack_int k,
+                           const float* d, lapack_complex_float* a,
+                           lapack_int lda, lapack_int* iseed );
+lapack_int LAPACKE_zlaghe( int matrix_order, lapack_int n, lapack_int k,
+                           const double* d, lapack_complex_double* a,
+                           lapack_int lda, lapack_int* iseed );
+
+lapack_int LAPACKE_slagsy( int matrix_order, lapack_int n, lapack_int k,
+                           const float* d, float* a, lapack_int lda,
+                           lapack_int* iseed );
+lapack_int LAPACKE_dlagsy( int matrix_order, lapack_int n, lapack_int k,
+                           const double* d, double* a, lapack_int lda,
+                           lapack_int* iseed );
+lapack_int LAPACKE_clagsy( int matrix_order, lapack_int n, lapack_int k,
+                           const float* d, lapack_complex_float* a,
+                           lapack_int lda, lapack_int* iseed );
+lapack_int LAPACKE_zlagsy( int matrix_order, lapack_int n, lapack_int k,
+                           const double* d, lapack_complex_double* a,
+                           lapack_int lda, lapack_int* iseed );
+
+lapack_int LAPACKE_slapmr( int matrix_order, lapack_logical forwrd,
+                           lapack_int m, lapack_int n, float* x, lapack_int ldx,
+                           lapack_int* k );
+lapack_int LAPACKE_dlapmr( int matrix_order, lapack_logical forwrd,
+                           lapack_int m, lapack_int n, double* x,
+                           lapack_int ldx, lapack_int* k );
+lapack_int LAPACKE_clapmr( int matrix_order, lapack_logical forwrd,
+                           lapack_int m, lapack_int n, lapack_complex_float* x,
+                           lapack_int ldx, lapack_int* k );
+lapack_int LAPACKE_zlapmr( int matrix_order, lapack_logical forwrd,
+                           lapack_int m, lapack_int n, lapack_complex_double* x,
+                           lapack_int ldx, lapack_int* k );
+
+
+float LAPACKE_slapy2( float x, float y );
+double LAPACKE_dlapy2( double x, double y );
+
+float LAPACKE_slapy3( float x, float y, float z );
+double LAPACKE_dlapy3( double x, double y, double z );
+
+lapack_int LAPACKE_slartgp( float f, float g, float* cs, float* sn, float* r );
+lapack_int LAPACKE_dlartgp( double f, double g, double* cs, double* sn,
+                            double* r );
+
+lapack_int LAPACKE_slartgs( float x, float y, float sigma, float* cs,
+                            float* sn );
+lapack_int LAPACKE_dlartgs( double x, double y, double sigma, double* cs,
+                            double* sn );
+
+
+//LAPACK 3.3.0
+lapack_int LAPACKE_cbbcsd( int matrix_order, char jobu1, char jobu2,
+                           char jobv1t, char jobv2t, char trans, lapack_int m,
+                           lapack_int p, lapack_int q, float* theta, float* phi,
+                           lapack_complex_float* u1, lapack_int ldu1,
+                           lapack_complex_float* u2, lapack_int ldu2,
+                           lapack_complex_float* v1t, lapack_int ldv1t,
+                           lapack_complex_float* v2t, lapack_int ldv2t,
+                           float* b11d, float* b11e, float* b12d, float* b12e,
+                           float* b21d, float* b21e, float* b22d, float* b22e );
+lapack_int LAPACKE_cbbcsd_work( int matrix_order, char jobu1, char jobu2,
+                                char jobv1t, char jobv2t, char trans,
+                                lapack_int m, lapack_int p, lapack_int q,
+                                float* theta, float* phi,
+                                lapack_complex_float* u1, lapack_int ldu1,
+                                lapack_complex_float* u2, lapack_int ldu2,
+                                lapack_complex_float* v1t, lapack_int ldv1t,
+                                lapack_complex_float* v2t, lapack_int ldv2t,
+                                float* b11d, float* b11e, float* b12d,
+                                float* b12e, float* b21d, float* b21e,
+                                float* b22d, float* b22e, float* rwork,
+                                lapack_int lrwork );
+lapack_int LAPACKE_cheswapr( int matrix_order, char uplo, lapack_int n,
+                             lapack_complex_float* a, lapack_int i1,
+                             lapack_int i2 );
+lapack_int LAPACKE_cheswapr_work( int matrix_order, char uplo, lapack_int n,
+                                  lapack_complex_float* a, lapack_int i1,
+                                  lapack_int i2 );
+lapack_int LAPACKE_chetri2( int matrix_order, char uplo, lapack_int n,
+                            lapack_complex_float* a, lapack_int lda,
+                            const lapack_int* ipiv );
+lapack_int LAPACKE_chetri2_work( int matrix_order, char uplo, lapack_int n,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 const lapack_int* ipiv,
+                                 lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_chetri2x( int matrix_order, char uplo, lapack_int n,
+                             lapack_complex_float* a, lapack_int lda,
+                             const lapack_int* ipiv, lapack_int nb );
+lapack_int LAPACKE_chetri2x_work( int matrix_order, char uplo, lapack_int n,
+                                  lapack_complex_float* a, lapack_int lda,
+                                  const lapack_int* ipiv,
+                                  lapack_complex_float* work, lapack_int nb );
+lapack_int LAPACKE_chetrs2( int matrix_order, char uplo, lapack_int n,
+                            lapack_int nrhs, const lapack_complex_float* a,
+                            lapack_int lda, const lapack_int* ipiv,
+                            lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_chetrs2_work( int matrix_order, char uplo, lapack_int n,
+                                 lapack_int nrhs, const lapack_complex_float* a,
+                                 lapack_int lda, const lapack_int* ipiv,
+                                 lapack_complex_float* b, lapack_int ldb,
+                                 lapack_complex_float* work );
+lapack_int LAPACKE_csyconv( int matrix_order, char uplo, char way, lapack_int n,
+                            lapack_complex_float* a, lapack_int lda,
+                            const lapack_int* ipiv );
+lapack_int LAPACKE_csyconv_work( int matrix_order, char uplo, char way,
+                                 lapack_int n, lapack_complex_float* a,
+                                 lapack_int lda, const lapack_int* ipiv,
+                                 lapack_complex_float* work );
+lapack_int LAPACKE_csyswapr( int matrix_order, char uplo, lapack_int n,
+                             lapack_complex_float* a, lapack_int i1,
+                             lapack_int i2 );
+lapack_int LAPACKE_csyswapr_work( int matrix_order, char uplo, lapack_int n,
+                                  lapack_complex_float* a, lapack_int i1,
+                                  lapack_int i2 );
+lapack_int LAPACKE_csytri2( int matrix_order, char uplo, lapack_int n,
+                            lapack_complex_float* a, lapack_int lda,
+                            const lapack_int* ipiv );
+lapack_int LAPACKE_csytri2_work( int matrix_order, char uplo, lapack_int n,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 const lapack_int* ipiv,
+                                 lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_csytri2x( int matrix_order, char uplo, lapack_int n,
+                             lapack_complex_float* a, lapack_int lda,
+                             const lapack_int* ipiv, lapack_int nb );
+lapack_int LAPACKE_csytri2x_work( int matrix_order, char uplo, lapack_int n,
+                                  lapack_complex_float* a, lapack_int lda,
+                                  const lapack_int* ipiv,
+                                  lapack_complex_float* work, lapack_int nb );
+lapack_int LAPACKE_csytrs2( int matrix_order, char uplo, lapack_int n,
+                            lapack_int nrhs, const lapack_complex_float* a,
+                            lapack_int lda, const lapack_int* ipiv,
+                            lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_csytrs2_work( int matrix_order, char uplo, lapack_int n,
+                                 lapack_int nrhs, const lapack_complex_float* a,
+                                 lapack_int lda, const lapack_int* ipiv,
+                                 lapack_complex_float* b, lapack_int ldb,
+                                 lapack_complex_float* work );
+lapack_int LAPACKE_cunbdb( int matrix_order, char trans, char signs,
+                           lapack_int m, lapack_int p, lapack_int q,
+                           lapack_complex_float* x11, lapack_int ldx11,
+                           lapack_complex_float* x12, lapack_int ldx12,
+                           lapack_complex_float* x21, lapack_int ldx21,
+                           lapack_complex_float* x22, lapack_int ldx22,
+                           float* theta, float* phi,
+                           lapack_complex_float* taup1,
+                           lapack_complex_float* taup2,
+                           lapack_complex_float* tauq1,
+                           lapack_complex_float* tauq2 );
+lapack_int LAPACKE_cunbdb_work( int matrix_order, char trans, char signs,
+                                lapack_int m, lapack_int p, lapack_int q,
+                                lapack_complex_float* x11, lapack_int ldx11,
+                                lapack_complex_float* x12, lapack_int ldx12,
+                                lapack_complex_float* x21, lapack_int ldx21,
+                                lapack_complex_float* x22, lapack_int ldx22,
+                                float* theta, float* phi,
+                                lapack_complex_float* taup1,
+                                lapack_complex_float* taup2,
+                                lapack_complex_float* tauq1,
+                                lapack_complex_float* tauq2,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_cuncsd( int matrix_order, char jobu1, char jobu2,
+                           char jobv1t, char jobv2t, char trans, char signs,
+                           lapack_int m, lapack_int p, lapack_int q,
+                           lapack_complex_float* x11, lapack_int ldx11,
+                           lapack_complex_float* x12, lapack_int ldx12,
+                           lapack_complex_float* x21, lapack_int ldx21,
+                           lapack_complex_float* x22, lapack_int ldx22,
+                           float* theta, lapack_complex_float* u1,
+                           lapack_int ldu1, lapack_complex_float* u2,
+                           lapack_int ldu2, lapack_complex_float* v1t,
+                           lapack_int ldv1t, lapack_complex_float* v2t,
+                           lapack_int ldv2t );
+lapack_int LAPACKE_cuncsd_work( int matrix_order, char jobu1, char jobu2,
+                                char jobv1t, char jobv2t, char trans,
+                                char signs, lapack_int m, lapack_int p,
+                                lapack_int q, lapack_complex_float* x11,
+                                lapack_int ldx11, lapack_complex_float* x12,
+                                lapack_int ldx12, lapack_complex_float* x21,
+                                lapack_int ldx21, lapack_complex_float* x22,
+                                lapack_int ldx22, float* theta,
+                                lapack_complex_float* u1, lapack_int ldu1,
+                                lapack_complex_float* u2, lapack_int ldu2,
+                                lapack_complex_float* v1t, lapack_int ldv1t,
+                                lapack_complex_float* v2t, lapack_int ldv2t,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork, lapack_int lrwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dbbcsd( int matrix_order, char jobu1, char jobu2,
+                           char jobv1t, char jobv2t, char trans, lapack_int m,
+                           lapack_int p, lapack_int q, double* theta,
+                           double* phi, double* u1, lapack_int ldu1, double* u2,
+                           lapack_int ldu2, double* v1t, lapack_int ldv1t,
+                           double* v2t, lapack_int ldv2t, double* b11d,
+                           double* b11e, double* b12d, double* b12e,
+                           double* b21d, double* b21e, double* b22d,
+                           double* b22e );
+lapack_int LAPACKE_dbbcsd_work( int matrix_order, char jobu1, char jobu2,
+                                char jobv1t, char jobv2t, char trans,
+                                lapack_int m, lapack_int p, lapack_int q,
+                                double* theta, double* phi, double* u1,
+                                lapack_int ldu1, double* u2, lapack_int ldu2,
+                                double* v1t, lapack_int ldv1t, double* v2t,
+                                lapack_int ldv2t, double* b11d, double* b11e,
+                                double* b12d, double* b12e, double* b21d,
+                                double* b21e, double* b22d, double* b22e,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_dorbdb( int matrix_order, char trans, char signs,
+                           lapack_int m, lapack_int p, lapack_int q,
+                           double* x11, lapack_int ldx11, double* x12,
+                           lapack_int ldx12, double* x21, lapack_int ldx21,
+                           double* x22, lapack_int ldx22, double* theta,
+                           double* phi, double* taup1, double* taup2,
+                           double* tauq1, double* tauq2 );
+lapack_int LAPACKE_dorbdb_work( int matrix_order, char trans, char signs,
+                                lapack_int m, lapack_int p, lapack_int q,
+                                double* x11, lapack_int ldx11, double* x12,
+                                lapack_int ldx12, double* x21, lapack_int ldx21,
+                                double* x22, lapack_int ldx22, double* theta,
+                                double* phi, double* taup1, double* taup2,
+                                double* tauq1, double* tauq2, double* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dorcsd( int matrix_order, char jobu1, char jobu2,
+                           char jobv1t, char jobv2t, char trans, char signs,
+                           lapack_int m, lapack_int p, lapack_int q,
+                           double* x11, lapack_int ldx11, double* x12,
+                           lapack_int ldx12, double* x21, lapack_int ldx21,
+                           double* x22, lapack_int ldx22, double* theta,
+                           double* u1, lapack_int ldu1, double* u2,
+                           lapack_int ldu2, double* v1t, lapack_int ldv1t,
+                           double* v2t, lapack_int ldv2t );
+lapack_int LAPACKE_dorcsd_work( int matrix_order, char jobu1, char jobu2,
+                                char jobv1t, char jobv2t, char trans,
+                                char signs, lapack_int m, lapack_int p,
+                                lapack_int q, double* x11, lapack_int ldx11,
+                                double* x12, lapack_int ldx12, double* x21,
+                                lapack_int ldx21, double* x22, lapack_int ldx22,
+                                double* theta, double* u1, lapack_int ldu1,
+                                double* u2, lapack_int ldu2, double* v1t,
+                                lapack_int ldv1t, double* v2t, lapack_int ldv2t,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dsyconv( int matrix_order, char uplo, char way, lapack_int n,
+                            double* a, lapack_int lda, const lapack_int* ipiv );
+lapack_int LAPACKE_dsyconv_work( int matrix_order, char uplo, char way,
+                                 lapack_int n, double* a, lapack_int lda,
+                                 const lapack_int* ipiv, double* work );
+lapack_int LAPACKE_dsyswapr( int matrix_order, char uplo, lapack_int n,
+                             double* a, lapack_int i1, lapack_int i2 );
+lapack_int LAPACKE_dsyswapr_work( int matrix_order, char uplo, lapack_int n,
+                                  double* a, lapack_int i1, lapack_int i2 );
+lapack_int LAPACKE_dsytri2( int matrix_order, char uplo, lapack_int n,
+                            double* a, lapack_int lda, const lapack_int* ipiv );
+lapack_int LAPACKE_dsytri2_work( int matrix_order, char uplo, lapack_int n,
+                                 double* a, lapack_int lda,
+                                 const lapack_int* ipiv,
+                                 lapack_complex_double* work, lapack_int lwork );
+lapack_int LAPACKE_dsytri2x( int matrix_order, char uplo, lapack_int n,
+                             double* a, lapack_int lda, const lapack_int* ipiv,
+                             lapack_int nb );
+lapack_int LAPACKE_dsytri2x_work( int matrix_order, char uplo, lapack_int n,
+                                  double* a, lapack_int lda,
+                                  const lapack_int* ipiv, double* work,
+                                  lapack_int nb );
+lapack_int LAPACKE_dsytrs2( int matrix_order, char uplo, lapack_int n,
+                            lapack_int nrhs, const double* a, lapack_int lda,
+                            const lapack_int* ipiv, double* b, lapack_int ldb );
+lapack_int LAPACKE_dsytrs2_work( int matrix_order, char uplo, lapack_int n,
+                                 lapack_int nrhs, const double* a,
+                                 lapack_int lda, const lapack_int* ipiv,
+                                 double* b, lapack_int ldb, double* work );
+lapack_int LAPACKE_sbbcsd( int matrix_order, char jobu1, char jobu2,
+                           char jobv1t, char jobv2t, char trans, lapack_int m,
+                           lapack_int p, lapack_int q, float* theta, float* phi,
+                           float* u1, lapack_int ldu1, float* u2,
+                           lapack_int ldu2, float* v1t, lapack_int ldv1t,
+                           float* v2t, lapack_int ldv2t, float* b11d,
+                           float* b11e, float* b12d, float* b12e, float* b21d,
+                           float* b21e, float* b22d, float* b22e );
+lapack_int LAPACKE_sbbcsd_work( int matrix_order, char jobu1, char jobu2,
+                                char jobv1t, char jobv2t, char trans,
+                                lapack_int m, lapack_int p, lapack_int q,
+                                float* theta, float* phi, float* u1,
+                                lapack_int ldu1, float* u2, lapack_int ldu2,
+                                float* v1t, lapack_int ldv1t, float* v2t,
+                                lapack_int ldv2t, float* b11d, float* b11e,
+                                float* b12d, float* b12e, float* b21d,
+                                float* b21e, float* b22d, float* b22e,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_sorbdb( int matrix_order, char trans, char signs,
+                           lapack_int m, lapack_int p, lapack_int q, float* x11,
+                           lapack_int ldx11, float* x12, lapack_int ldx12,
+                           float* x21, lapack_int ldx21, float* x22,
+                           lapack_int ldx22, float* theta, float* phi,
+                           float* taup1, float* taup2, float* tauq1,
+                           float* tauq2 );
+lapack_int LAPACKE_sorbdb_work( int matrix_order, char trans, char signs,
+                                lapack_int m, lapack_int p, lapack_int q,
+                                float* x11, lapack_int ldx11, float* x12,
+                                lapack_int ldx12, float* x21, lapack_int ldx21,
+                                float* x22, lapack_int ldx22, float* theta,
+                                float* phi, float* taup1, float* taup2,
+                                float* tauq1, float* tauq2, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_sorcsd( int matrix_order, char jobu1, char jobu2,
+                           char jobv1t, char jobv2t, char trans, char signs,
+                           lapack_int m, lapack_int p, lapack_int q, float* x11,
+                           lapack_int ldx11, float* x12, lapack_int ldx12,
+                           float* x21, lapack_int ldx21, float* x22,
+                           lapack_int ldx22, float* theta, float* u1,
+                           lapack_int ldu1, float* u2, lapack_int ldu2,
+                           float* v1t, lapack_int ldv1t, float* v2t,
+                           lapack_int ldv2t );
+lapack_int LAPACKE_sorcsd_work( int matrix_order, char jobu1, char jobu2,
+                                char jobv1t, char jobv2t, char trans,
+                                char signs, lapack_int m, lapack_int p,
+                                lapack_int q, float* x11, lapack_int ldx11,
+                                float* x12, lapack_int ldx12, float* x21,
+                                lapack_int ldx21, float* x22, lapack_int ldx22,
+                                float* theta, float* u1, lapack_int ldu1,
+                                float* u2, lapack_int ldu2, float* v1t,
+                                lapack_int ldv1t, float* v2t, lapack_int ldv2t,
+                                float* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_ssyconv( int matrix_order, char uplo, char way, lapack_int n,
+                            float* a, lapack_int lda, const lapack_int* ipiv );
+lapack_int LAPACKE_ssyconv_work( int matrix_order, char uplo, char way,
+                                 lapack_int n, float* a, lapack_int lda,
+                                 const lapack_int* ipiv, float* work );
+lapack_int LAPACKE_ssyswapr( int matrix_order, char uplo, lapack_int n,
+                             float* a, lapack_int i1, lapack_int i2 );
+lapack_int LAPACKE_ssyswapr_work( int matrix_order, char uplo, lapack_int n,
+                                  float* a, lapack_int i1, lapack_int i2 );
+lapack_int LAPACKE_ssytri2( int matrix_order, char uplo, lapack_int n, float* a,
+                            lapack_int lda, const lapack_int* ipiv );
+lapack_int LAPACKE_ssytri2_work( int matrix_order, char uplo, lapack_int n,
+                                 float* a, lapack_int lda,
+                                 const lapack_int* ipiv,
+                                 lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_ssytri2x( int matrix_order, char uplo, lapack_int n,
+                             float* a, lapack_int lda, const lapack_int* ipiv,
+                             lapack_int nb );
+lapack_int LAPACKE_ssytri2x_work( int matrix_order, char uplo, lapack_int n,
+                                  float* a, lapack_int lda,
+                                  const lapack_int* ipiv, float* work,
+                                  lapack_int nb );
+lapack_int LAPACKE_ssytrs2( int matrix_order, char uplo, lapack_int n,
+                            lapack_int nrhs, const float* a, lapack_int lda,
+                            const lapack_int* ipiv, float* b, lapack_int ldb );
+lapack_int LAPACKE_ssytrs2_work( int matrix_order, char uplo, lapack_int n,
+                                 lapack_int nrhs, const float* a,
+                                 lapack_int lda, const lapack_int* ipiv,
+                                 float* b, lapack_int ldb, float* work );
+lapack_int LAPACKE_zbbcsd( int matrix_order, char jobu1, char jobu2,
+                           char jobv1t, char jobv2t, char trans, lapack_int m,
+                           lapack_int p, lapack_int q, double* theta,
+                           double* phi, lapack_complex_double* u1,
+                           lapack_int ldu1, lapack_complex_double* u2,
+                           lapack_int ldu2, lapack_complex_double* v1t,
+                           lapack_int ldv1t, lapack_complex_double* v2t,
+                           lapack_int ldv2t, double* b11d, double* b11e,
+                           double* b12d, double* b12e, double* b21d,
+                           double* b21e, double* b22d, double* b22e );
+lapack_int LAPACKE_zbbcsd_work( int matrix_order, char jobu1, char jobu2,
+                                char jobv1t, char jobv2t, char trans,
+                                lapack_int m, lapack_int p, lapack_int q,
+                                double* theta, double* phi,
+                                lapack_complex_double* u1, lapack_int ldu1,
+                                lapack_complex_double* u2, lapack_int ldu2,
+                                lapack_complex_double* v1t, lapack_int ldv1t,
+                                lapack_complex_double* v2t, lapack_int ldv2t,
+                                double* b11d, double* b11e, double* b12d,
+                                double* b12e, double* b21d, double* b21e,
+                                double* b22d, double* b22e, double* rwork,
+                                lapack_int lrwork );
+lapack_int LAPACKE_zheswapr( int matrix_order, char uplo, lapack_int n,
+                             lapack_complex_double* a, lapack_int i1,
+                             lapack_int i2 );
+lapack_int LAPACKE_zheswapr_work( int matrix_order, char uplo, lapack_int n,
+                                  lapack_complex_double* a, lapack_int i1,
+                                  lapack_int i2 );
+lapack_int LAPACKE_zhetri2( int matrix_order, char uplo, lapack_int n,
+                            lapack_complex_double* a, lapack_int lda,
+                            const lapack_int* ipiv );
+lapack_int LAPACKE_zhetri2_work( int matrix_order, char uplo, lapack_int n,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 const lapack_int* ipiv,
+                                 lapack_complex_double* work, lapack_int lwork );
+lapack_int LAPACKE_zhetri2x( int matrix_order, char uplo, lapack_int n,
+                             lapack_complex_double* a, lapack_int lda,
+                             const lapack_int* ipiv, lapack_int nb );
+lapack_int LAPACKE_zhetri2x_work( int matrix_order, char uplo, lapack_int n,
+                                  lapack_complex_double* a, lapack_int lda,
+                                  const lapack_int* ipiv,
+                                  lapack_complex_double* work, lapack_int nb );
+lapack_int LAPACKE_zhetrs2( int matrix_order, char uplo, lapack_int n,
+                            lapack_int nrhs, const lapack_complex_double* a,
+                            lapack_int lda, const lapack_int* ipiv,
+                            lapack_complex_double* b, lapack_int ldb );
+lapack_int LAPACKE_zhetrs2_work( int matrix_order, char uplo, lapack_int n,
+                                 lapack_int nrhs, const lapack_complex_double* a,
+                                 lapack_int lda, const lapack_int* ipiv,
+                                 lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* work );
+lapack_int LAPACKE_zsyconv( int matrix_order, char uplo, char way, lapack_int n,
+                            lapack_complex_double* a, lapack_int lda,
+                            const lapack_int* ipiv );
+lapack_int LAPACKE_zsyconv_work( int matrix_order, char uplo, char way,
+                                 lapack_int n, lapack_complex_double* a,
+                                 lapack_int lda, const lapack_int* ipiv,
+                                 lapack_complex_double* work );
+lapack_int LAPACKE_zsyswapr( int matrix_order, char uplo, lapack_int n,
+                             lapack_complex_double* a, lapack_int i1,
+                             lapack_int i2 );
+lapack_int LAPACKE_zsyswapr_work( int matrix_order, char uplo, lapack_int n,
+                                  lapack_complex_double* a, lapack_int i1,
+                                  lapack_int i2 );
+lapack_int LAPACKE_zsytri2( int matrix_order, char uplo, lapack_int n,
+                            lapack_complex_double* a, lapack_int lda,
+                            const lapack_int* ipiv );
+lapack_int LAPACKE_zsytri2_work( int matrix_order, char uplo, lapack_int n,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 const lapack_int* ipiv,
+                                 lapack_complex_double* work, lapack_int lwork );
+lapack_int LAPACKE_zsytri2x( int matrix_order, char uplo, lapack_int n,
+                             lapack_complex_double* a, lapack_int lda,
+                             const lapack_int* ipiv, lapack_int nb );
+lapack_int LAPACKE_zsytri2x_work( int matrix_order, char uplo, lapack_int n,
+                                  lapack_complex_double* a, lapack_int lda,
+                                  const lapack_int* ipiv,
+                                  lapack_complex_double* work, lapack_int nb );
+lapack_int LAPACKE_zsytrs2( int matrix_order, char uplo, lapack_int n,
+                            lapack_int nrhs, const lapack_complex_double* a,
+                            lapack_int lda, const lapack_int* ipiv,
+                            lapack_complex_double* b, lapack_int ldb );
+lapack_int LAPACKE_zsytrs2_work( int matrix_order, char uplo, lapack_int n,
+                                 lapack_int nrhs, const lapack_complex_double* a,
+                                 lapack_int lda, const lapack_int* ipiv,
+                                 lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* work );
+lapack_int LAPACKE_zunbdb( int matrix_order, char trans, char signs,
+                           lapack_int m, lapack_int p, lapack_int q,
+                           lapack_complex_double* x11, lapack_int ldx11,
+                           lapack_complex_double* x12, lapack_int ldx12,
+                           lapack_complex_double* x21, lapack_int ldx21,
+                           lapack_complex_double* x22, lapack_int ldx22,
+                           double* theta, double* phi,
+                           lapack_complex_double* taup1,
+                           lapack_complex_double* taup2,
+                           lapack_complex_double* tauq1,
+                           lapack_complex_double* tauq2 );
+lapack_int LAPACKE_zunbdb_work( int matrix_order, char trans, char signs,
+                                lapack_int m, lapack_int p, lapack_int q,
+                                lapack_complex_double* x11, lapack_int ldx11,
+                                lapack_complex_double* x12, lapack_int ldx12,
+                                lapack_complex_double* x21, lapack_int ldx21,
+                                lapack_complex_double* x22, lapack_int ldx22,
+                                double* theta, double* phi,
+                                lapack_complex_double* taup1,
+                                lapack_complex_double* taup2,
+                                lapack_complex_double* tauq1,
+                                lapack_complex_double* tauq2,
+                                lapack_complex_double* work, lapack_int lwork );
+lapack_int LAPACKE_zuncsd( int matrix_order, char jobu1, char jobu2,
+                           char jobv1t, char jobv2t, char trans, char signs,
+                           lapack_int m, lapack_int p, lapack_int q,
+                           lapack_complex_double* x11, lapack_int ldx11,
+                           lapack_complex_double* x12, lapack_int ldx12,
+                           lapack_complex_double* x21, lapack_int ldx21,
+                           lapack_complex_double* x22, lapack_int ldx22,
+                           double* theta, lapack_complex_double* u1,
+                           lapack_int ldu1, lapack_complex_double* u2,
+                           lapack_int ldu2, lapack_complex_double* v1t,
+                           lapack_int ldv1t, lapack_complex_double* v2t,
+                           lapack_int ldv2t );
+lapack_int LAPACKE_zuncsd_work( int matrix_order, char jobu1, char jobu2,
+                                char jobv1t, char jobv2t, char trans,
+                                char signs, lapack_int m, lapack_int p,
+                                lapack_int q, lapack_complex_double* x11,
+                                lapack_int ldx11, lapack_complex_double* x12,
+                                lapack_int ldx12, lapack_complex_double* x21,
+                                lapack_int ldx21, lapack_complex_double* x22,
+                                lapack_int ldx22, double* theta,
+                                lapack_complex_double* u1, lapack_int ldu1,
+                                lapack_complex_double* u2, lapack_int ldu2,
+                                lapack_complex_double* v1t, lapack_int ldv1t,
+                                lapack_complex_double* v2t, lapack_int ldv2t,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork, lapack_int lrwork,
+                                lapack_int* iwork );
+//LAPACK 3.4.0
+lapack_int LAPACKE_sgemqrt( int matrix_order, char side, char trans,
+                            lapack_int m, lapack_int n, lapack_int k,
+                            lapack_int nb, const float* v, lapack_int ldv,
+                            const float* t, lapack_int ldt, float* c,
+                            lapack_int ldc );
+lapack_int LAPACKE_dgemqrt( int matrix_order, char side, char trans,
+                            lapack_int m, lapack_int n, lapack_int k,
+                            lapack_int nb, const double* v, lapack_int ldv,
+                            const double* t, lapack_int ldt, double* c,
+                            lapack_int ldc );
+lapack_int LAPACKE_cgemqrt( int matrix_order, char side, char trans,
+                            lapack_int m, lapack_int n, lapack_int k,
+                            lapack_int nb, const lapack_complex_float* v,
+                            lapack_int ldv, const lapack_complex_float* t,
+                            lapack_int ldt, lapack_complex_float* c,
+                            lapack_int ldc );
+lapack_int LAPACKE_zgemqrt( int matrix_order, char side, char trans,
+                            lapack_int m, lapack_int n, lapack_int k,
+                            lapack_int nb, const lapack_complex_double* v,
+                            lapack_int ldv, const lapack_complex_double* t,
+                            lapack_int ldt, lapack_complex_double* c,
+                            lapack_int ldc );
+
+lapack_int LAPACKE_sgeqrt( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nb, float* a, lapack_int lda, float* t,
+                           lapack_int ldt );
+lapack_int LAPACKE_dgeqrt( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nb, double* a, lapack_int lda, double* t,
+                           lapack_int ldt );
+lapack_int LAPACKE_cgeqrt( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nb, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* t,
+                           lapack_int ldt );
+lapack_int LAPACKE_zgeqrt( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nb, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* t,
+                           lapack_int ldt );
+
+lapack_int LAPACKE_sgeqrt2( int matrix_order, lapack_int m, lapack_int n,
+                            float* a, lapack_int lda, float* t,
+                            lapack_int ldt );
+lapack_int LAPACKE_dgeqrt2( int matrix_order, lapack_int m, lapack_int n,
+                            double* a, lapack_int lda, double* t,
+                            lapack_int ldt );
+lapack_int LAPACKE_cgeqrt2( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_complex_float* a, lapack_int lda,
+                            lapack_complex_float* t, lapack_int ldt );
+lapack_int LAPACKE_zgeqrt2( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_complex_double* a, lapack_int lda,
+                            lapack_complex_double* t, lapack_int ldt );
+
+lapack_int LAPACKE_sgeqrt3( int matrix_order, lapack_int m, lapack_int n,
+                            float* a, lapack_int lda, float* t,
+                            lapack_int ldt );
+lapack_int LAPACKE_dgeqrt3( int matrix_order, lapack_int m, lapack_int n,
+                            double* a, lapack_int lda, double* t,
+                            lapack_int ldt );
+lapack_int LAPACKE_cgeqrt3( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_complex_float* a, lapack_int lda,
+                            lapack_complex_float* t, lapack_int ldt );
+lapack_int LAPACKE_zgeqrt3( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_complex_double* a, lapack_int lda,
+                            lapack_complex_double* t, lapack_int ldt );
+
+lapack_int LAPACKE_stpmqrt( int matrix_order, char side, char trans,
+                            lapack_int m, lapack_int n, lapack_int k,
+                            lapack_int l, lapack_int nb, const float* v,
+                            lapack_int ldv, const float* t, lapack_int ldt,
+                            float* a, lapack_int lda, float* b,
+                            lapack_int ldb );
+lapack_int LAPACKE_dtpmqrt( int matrix_order, char side, char trans,
+                            lapack_int m, lapack_int n, lapack_int k,
+                            lapack_int l, lapack_int nb, const double* v,
+                            lapack_int ldv, const double* t, lapack_int ldt,
+                            double* a, lapack_int lda, double* b,
+                            lapack_int ldb );
+lapack_int LAPACKE_ctpmqrt( int matrix_order, char side, char trans,
+                            lapack_int m, lapack_int n, lapack_int k,
+                            lapack_int l, lapack_int nb,
+                            const lapack_complex_float* v, lapack_int ldv,
+                            const lapack_complex_float* t, lapack_int ldt,
+                            lapack_complex_float* a, lapack_int lda,
+                            lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_ztpmqrt( int matrix_order, char side, char trans,
+                            lapack_int m, lapack_int n, lapack_int k,
+                            lapack_int l, lapack_int nb,
+                            const lapack_complex_double* v, lapack_int ldv,
+                            const lapack_complex_double* t, lapack_int ldt,
+                            lapack_complex_double* a, lapack_int lda,
+                            lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_dtpqrt( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int l, lapack_int nb, double* a,
+                           lapack_int lda, double* b, lapack_int ldb, double* t,
+                           lapack_int ldt );
+lapack_int LAPACKE_ctpqrt( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int l, lapack_int nb, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* t,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_int ldt );
+lapack_int LAPACKE_ztpqrt( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int l, lapack_int nb,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* t, lapack_int ldt );
+
+lapack_int LAPACKE_stpqrt2( int matrix_order, lapack_int m, lapack_int n,
+                            float* a, lapack_int lda, float* b, lapack_int ldb,
+                            float* t, lapack_int ldt );
+lapack_int LAPACKE_dtpqrt2( int matrix_order, lapack_int m, lapack_int n,
+                            double* a, lapack_int lda, double* b,
+                            lapack_int ldb, double* t, lapack_int ldt );
+lapack_int LAPACKE_ctpqrt2( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_complex_float* a, lapack_int lda,
+                            lapack_complex_float* b, lapack_int ldb,
+                            lapack_complex_float* t, lapack_int ldt );
+lapack_int LAPACKE_ztpqrt2( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_complex_double* a, lapack_int lda,
+                            lapack_complex_double* b, lapack_int ldb,
+                            lapack_complex_double* t, lapack_int ldt );
+
+lapack_int LAPACKE_stprfb( int matrix_order, char side, char trans, char direct,
+                           char storev, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_int l, const float* v,
+                           lapack_int ldv, const float* t, lapack_int ldt,
+                           float* a, lapack_int lda, float* b, lapack_int ldb,
+                           lapack_int myldwork );
+lapack_int LAPACKE_dtprfb( int matrix_order, char side, char trans, char direct,
+                           char storev, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_int l, const double* v,
+                           lapack_int ldv, const double* t, lapack_int ldt,
+                           double* a, lapack_int lda, double* b, lapack_int ldb,
+                           lapack_int myldwork );
+lapack_int LAPACKE_ctprfb( int matrix_order, char side, char trans, char direct,
+                           char storev, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_int l,
+                           const lapack_complex_float* v, lapack_int ldv,
+                           const lapack_complex_float* t, lapack_int ldt,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_int myldwork );
+lapack_int LAPACKE_ztprfb( int matrix_order, char side, char trans, char direct,
+                           char storev, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_int l,
+                           const lapack_complex_double* v, lapack_int ldv,
+                           const lapack_complex_double* t, lapack_int ldt,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_int myldwork );
+
+lapack_int LAPACKE_sgemqrt_work( int matrix_order, char side, char trans,
+                                 lapack_int m, lapack_int n, lapack_int k,
+                                 lapack_int nb, const float* v, lapack_int ldv,
+                                 const float* t, lapack_int ldt, float* c,
+                                 lapack_int ldc, float* work );
+lapack_int LAPACKE_dgemqrt_work( int matrix_order, char side, char trans,
+                                 lapack_int m, lapack_int n, lapack_int k,
+                                 lapack_int nb, const double* v, lapack_int ldv,
+                                 const double* t, lapack_int ldt, double* c,
+                                 lapack_int ldc, double* work );
+lapack_int LAPACKE_cgemqrt_work( int matrix_order, char side, char trans,
+                                 lapack_int m, lapack_int n, lapack_int k,
+                                 lapack_int nb, const lapack_complex_float* v,
+                                 lapack_int ldv, const lapack_complex_float* t,
+                                 lapack_int ldt, lapack_complex_float* c,
+                                 lapack_int ldc, lapack_complex_float* work );
+lapack_int LAPACKE_zgemqrt_work( int matrix_order, char side, char trans,
+                                 lapack_int m, lapack_int n, lapack_int k,
+                                 lapack_int nb, const lapack_complex_double* v,
+                                 lapack_int ldv, const lapack_complex_double* t,
+                                 lapack_int ldt, lapack_complex_double* c,
+                                 lapack_int ldc, lapack_complex_double* work );
+
+lapack_int LAPACKE_sgeqrt_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nb, float* a, lapack_int lda,
+                                float* t, lapack_int ldt, float* work );
+lapack_int LAPACKE_dgeqrt_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nb, double* a, lapack_int lda,
+                                double* t, lapack_int ldt, double* work );
+lapack_int LAPACKE_cgeqrt_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nb, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* t,
+                                lapack_int ldt, lapack_complex_float* work );
+lapack_int LAPACKE_zgeqrt_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nb, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* t,
+                                lapack_int ldt, lapack_complex_double* work );
+
+lapack_int LAPACKE_sgeqrt2_work( int matrix_order, lapack_int m, lapack_int n,
+                                 float* a, lapack_int lda, float* t,
+                                 lapack_int ldt );
+lapack_int LAPACKE_dgeqrt2_work( int matrix_order, lapack_int m, lapack_int n,
+                                 double* a, lapack_int lda, double* t,
+                                 lapack_int ldt );
+lapack_int LAPACKE_cgeqrt2_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 lapack_complex_float* t, lapack_int ldt );
+lapack_int LAPACKE_zgeqrt2_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 lapack_complex_double* t, lapack_int ldt );
+
+lapack_int LAPACKE_sgeqrt3_work( int matrix_order, lapack_int m, lapack_int n,
+                                 float* a, lapack_int lda, float* t,
+                                 lapack_int ldt );
+lapack_int LAPACKE_dgeqrt3_work( int matrix_order, lapack_int m, lapack_int n,
+                                 double* a, lapack_int lda, double* t,
+                                 lapack_int ldt );
+lapack_int LAPACKE_cgeqrt3_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 lapack_complex_float* t, lapack_int ldt );
+lapack_int LAPACKE_zgeqrt3_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 lapack_complex_double* t, lapack_int ldt );
+
+lapack_int LAPACKE_stpmqrt_work( int matrix_order, char side, char trans,
+                                 lapack_int m, lapack_int n, lapack_int k,
+                                 lapack_int l, lapack_int nb, const float* v,
+                                 lapack_int ldv, const float* t, lapack_int ldt,
+                                 float* a, lapack_int lda, float* b,
+                                 lapack_int ldb, float* work );
+lapack_int LAPACKE_dtpmqrt_work( int matrix_order, char side, char trans,
+                                 lapack_int m, lapack_int n, lapack_int k,
+                                 lapack_int l, lapack_int nb, const double* v,
+                                 lapack_int ldv, const double* t,
+                                 lapack_int ldt, double* a, lapack_int lda,
+                                 double* b, lapack_int ldb, double* work );
+lapack_int LAPACKE_ctpmqrt_work( int matrix_order, char side, char trans,
+                                 lapack_int m, lapack_int n, lapack_int k,
+                                 lapack_int l, lapack_int nb,
+                                 const lapack_complex_float* v, lapack_int ldv,
+                                 const lapack_complex_float* t, lapack_int ldt,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 lapack_complex_float* b, lapack_int ldb,
+                                 lapack_complex_float* work );
+lapack_int LAPACKE_ztpmqrt_work( int matrix_order, char side, char trans,
+                                 lapack_int m, lapack_int n, lapack_int k,
+                                 lapack_int l, lapack_int nb,
+                                 const lapack_complex_double* v, lapack_int ldv,
+                                 const lapack_complex_double* t, lapack_int ldt,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* work );
+
+lapack_int LAPACKE_dtpqrt_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int l, lapack_int nb, double* a,
+                                lapack_int lda, double* b, lapack_int ldb,
+                                double* t, lapack_int ldt, double* work );
+lapack_int LAPACKE_ctpqrt_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int l, lapack_int nb,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* t,
+                                lapack_complex_float* b, lapack_int ldb,
+                                lapack_int ldt, lapack_complex_float* work );
+lapack_int LAPACKE_ztpqrt_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int l, lapack_int nb,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* t, lapack_int ldt,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_stpqrt2_work( int matrix_order, lapack_int m, lapack_int n,
+                                 float* a, lapack_int lda, float* b,
+                                 lapack_int ldb, float* t, lapack_int ldt );
+lapack_int LAPACKE_dtpqrt2_work( int matrix_order, lapack_int m, lapack_int n,
+                                 double* a, lapack_int lda, double* b,
+                                 lapack_int ldb, double* t, lapack_int ldt );
+lapack_int LAPACKE_ctpqrt2_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 lapack_complex_float* b, lapack_int ldb,
+                                 lapack_complex_float* t, lapack_int ldt );
+lapack_int LAPACKE_ztpqrt2_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* t, lapack_int ldt );
+
+lapack_int LAPACKE_stprfb_work( int matrix_order, char side, char trans,
+                                char direct, char storev, lapack_int m,
+                                lapack_int n, lapack_int k, lapack_int l,
+                                const float* v, lapack_int ldv, const float* t,
+                                lapack_int ldt, float* a, lapack_int lda,
+                                float* b, lapack_int ldb, const float* mywork,
+                                lapack_int myldwork );
+lapack_int LAPACKE_dtprfb_work( int matrix_order, char side, char trans,
+                                char direct, char storev, lapack_int m,
+                                lapack_int n, lapack_int k, lapack_int l,
+                                const double* v, lapack_int ldv,
+                                const double* t, lapack_int ldt, double* a,
+                                lapack_int lda, double* b, lapack_int ldb,
+                                const double* mywork, lapack_int myldwork );
+lapack_int LAPACKE_ctprfb_work( int matrix_order, char side, char trans,
+                                char direct, char storev, lapack_int m,
+                                lapack_int n, lapack_int k, lapack_int l,
+                                const lapack_complex_float* v, lapack_int ldv,
+                                const lapack_complex_float* t, lapack_int ldt,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb,
+                                const float* mywork, lapack_int myldwork );
+lapack_int LAPACKE_ztprfb_work( int matrix_order, char side, char trans,
+                                char direct, char storev, lapack_int m,
+                                lapack_int n, lapack_int k, lapack_int l,
+                                const lapack_complex_double* v, lapack_int ldv,
+                                const lapack_complex_double* t, lapack_int ldt,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                const double* mywork, lapack_int myldwork );
+//LAPACK 3.X.X
+lapack_int LAPACKE_csyr( int matrix_order, char uplo, lapack_int n,
+                             lapack_complex_float alpha,
+                             const lapack_complex_float* x, lapack_int incx,
+                             lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_zsyr( int matrix_order, char uplo, lapack_int n,
+                             lapack_complex_double alpha,
+                             const lapack_complex_double* x, lapack_int incx,
+                             lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_csyr_work( int matrix_order, char uplo, lapack_int n,
+                                  lapack_complex_float alpha,
+                                  const lapack_complex_float* x,
+                                  lapack_int incx, lapack_complex_float* a,
+                                  lapack_int lda );
+lapack_int LAPACKE_zsyr_work( int matrix_order, char uplo, lapack_int n,
+                                  lapack_complex_double alpha,
+                                  const lapack_complex_double* x,
+                                  lapack_int incx, lapack_complex_double* a,
+                                  lapack_int lda );
+
+
+
+#define LAPACK_sgetrf LAPACK_GLOBAL(sgetrf,SGETRF)
+#define LAPACK_dgetrf LAPACK_GLOBAL(dgetrf,DGETRF)
+#define LAPACK_cgetrf LAPACK_GLOBAL(cgetrf,CGETRF)
+#define LAPACK_zgetrf LAPACK_GLOBAL(zgetrf,ZGETRF)
+#define LAPACK_sgbtrf LAPACK_GLOBAL(sgbtrf,SGBTRF)
+#define LAPACK_dgbtrf LAPACK_GLOBAL(dgbtrf,DGBTRF)
+#define LAPACK_cgbtrf LAPACK_GLOBAL(cgbtrf,CGBTRF)
+#define LAPACK_zgbtrf LAPACK_GLOBAL(zgbtrf,ZGBTRF)
+#define LAPACK_sgttrf LAPACK_GLOBAL(sgttrf,SGTTRF)
+#define LAPACK_dgttrf LAPACK_GLOBAL(dgttrf,DGTTRF)
+#define LAPACK_cgttrf LAPACK_GLOBAL(cgttrf,CGTTRF)
+#define LAPACK_zgttrf LAPACK_GLOBAL(zgttrf,ZGTTRF)
+#define LAPACK_spotrf LAPACK_GLOBAL(spotrf,SPOTRF)
+#define LAPACK_dpotrf LAPACK_GLOBAL(dpotrf,DPOTRF)
+#define LAPACK_cpotrf LAPACK_GLOBAL(cpotrf,CPOTRF)
+#define LAPACK_zpotrf LAPACK_GLOBAL(zpotrf,ZPOTRF)
+#define LAPACK_dpstrf LAPACK_GLOBAL(dpstrf,DPSTRF)
+#define LAPACK_spstrf LAPACK_GLOBAL(spstrf,SPSTRF)
+#define LAPACK_zpstrf LAPACK_GLOBAL(zpstrf,ZPSTRF)
+#define LAPACK_cpstrf LAPACK_GLOBAL(cpstrf,CPSTRF)
+#define LAPACK_dpftrf LAPACK_GLOBAL(dpftrf,DPFTRF)
+#define LAPACK_spftrf LAPACK_GLOBAL(spftrf,SPFTRF)
+#define LAPACK_zpftrf LAPACK_GLOBAL(zpftrf,ZPFTRF)
+#define LAPACK_cpftrf LAPACK_GLOBAL(cpftrf,CPFTRF)
+#define LAPACK_spptrf LAPACK_GLOBAL(spptrf,SPPTRF)
+#define LAPACK_dpptrf LAPACK_GLOBAL(dpptrf,DPPTRF)
+#define LAPACK_cpptrf LAPACK_GLOBAL(cpptrf,CPPTRF)
+#define LAPACK_zpptrf LAPACK_GLOBAL(zpptrf,ZPPTRF)
+#define LAPACK_spbtrf LAPACK_GLOBAL(spbtrf,SPBTRF)
+#define LAPACK_dpbtrf LAPACK_GLOBAL(dpbtrf,DPBTRF)
+#define LAPACK_cpbtrf LAPACK_GLOBAL(cpbtrf,CPBTRF)
+#define LAPACK_zpbtrf LAPACK_GLOBAL(zpbtrf,ZPBTRF)
+#define LAPACK_spttrf LAPACK_GLOBAL(spttrf,SPTTRF)
+#define LAPACK_dpttrf LAPACK_GLOBAL(dpttrf,DPTTRF)
+#define LAPACK_cpttrf LAPACK_GLOBAL(cpttrf,CPTTRF)
+#define LAPACK_zpttrf LAPACK_GLOBAL(zpttrf,ZPTTRF)
+#define LAPACK_ssytrf LAPACK_GLOBAL(ssytrf,SSYTRF)
+#define LAPACK_dsytrf LAPACK_GLOBAL(dsytrf,DSYTRF)
+#define LAPACK_csytrf LAPACK_GLOBAL(csytrf,CSYTRF)
+#define LAPACK_zsytrf LAPACK_GLOBAL(zsytrf,ZSYTRF)
+#define LAPACK_chetrf LAPACK_GLOBAL(chetrf,CHETRF)
+#define LAPACK_zhetrf LAPACK_GLOBAL(zhetrf,ZHETRF)
+#define LAPACK_ssptrf LAPACK_GLOBAL(ssptrf,SSPTRF)
+#define LAPACK_dsptrf LAPACK_GLOBAL(dsptrf,DSPTRF)
+#define LAPACK_csptrf LAPACK_GLOBAL(csptrf,CSPTRF)
+#define LAPACK_zsptrf LAPACK_GLOBAL(zsptrf,ZSPTRF)
+#define LAPACK_chptrf LAPACK_GLOBAL(chptrf,CHPTRF)
+#define LAPACK_zhptrf LAPACK_GLOBAL(zhptrf,ZHPTRF)
+#define LAPACK_sgetrs LAPACK_GLOBAL(sgetrs,SGETRS)
+#define LAPACK_dgetrs LAPACK_GLOBAL(dgetrs,DGETRS)
+#define LAPACK_cgetrs LAPACK_GLOBAL(cgetrs,CGETRS)
+#define LAPACK_zgetrs LAPACK_GLOBAL(zgetrs,ZGETRS)
+#define LAPACK_sgbtrs LAPACK_GLOBAL(sgbtrs,SGBTRS)
+#define LAPACK_dgbtrs LAPACK_GLOBAL(dgbtrs,DGBTRS)
+#define LAPACK_cgbtrs LAPACK_GLOBAL(cgbtrs,CGBTRS)
+#define LAPACK_zgbtrs LAPACK_GLOBAL(zgbtrs,ZGBTRS)
+#define LAPACK_sgttrs LAPACK_GLOBAL(sgttrs,SGTTRS)
+#define LAPACK_dgttrs LAPACK_GLOBAL(dgttrs,DGTTRS)
+#define LAPACK_cgttrs LAPACK_GLOBAL(cgttrs,CGTTRS)
+#define LAPACK_zgttrs LAPACK_GLOBAL(zgttrs,ZGTTRS)
+#define LAPACK_spotrs LAPACK_GLOBAL(spotrs,SPOTRS)
+#define LAPACK_dpotrs LAPACK_GLOBAL(dpotrs,DPOTRS)
+#define LAPACK_cpotrs LAPACK_GLOBAL(cpotrs,CPOTRS)
+#define LAPACK_zpotrs LAPACK_GLOBAL(zpotrs,ZPOTRS)
+#define LAPACK_dpftrs LAPACK_GLOBAL(dpftrs,DPFTRS)
+#define LAPACK_spftrs LAPACK_GLOBAL(spftrs,SPFTRS)
+#define LAPACK_zpftrs LAPACK_GLOBAL(zpftrs,ZPFTRS)
+#define LAPACK_cpftrs LAPACK_GLOBAL(cpftrs,CPFTRS)
+#define LAPACK_spptrs LAPACK_GLOBAL(spptrs,SPPTRS)
+#define LAPACK_dpptrs LAPACK_GLOBAL(dpptrs,DPPTRS)
+#define LAPACK_cpptrs LAPACK_GLOBAL(cpptrs,CPPTRS)
+#define LAPACK_zpptrs LAPACK_GLOBAL(zpptrs,ZPPTRS)
+#define LAPACK_spbtrs LAPACK_GLOBAL(spbtrs,SPBTRS)
+#define LAPACK_dpbtrs LAPACK_GLOBAL(dpbtrs,DPBTRS)
+#define LAPACK_cpbtrs LAPACK_GLOBAL(cpbtrs,CPBTRS)
+#define LAPACK_zpbtrs LAPACK_GLOBAL(zpbtrs,ZPBTRS)
+#define LAPACK_spttrs LAPACK_GLOBAL(spttrs,SPTTRS)
+#define LAPACK_dpttrs LAPACK_GLOBAL(dpttrs,DPTTRS)
+#define LAPACK_cpttrs LAPACK_GLOBAL(cpttrs,CPTTRS)
+#define LAPACK_zpttrs LAPACK_GLOBAL(zpttrs,ZPTTRS)
+#define LAPACK_ssytrs LAPACK_GLOBAL(ssytrs,SSYTRS)
+#define LAPACK_dsytrs LAPACK_GLOBAL(dsytrs,DSYTRS)
+#define LAPACK_csytrs LAPACK_GLOBAL(csytrs,CSYTRS)
+#define LAPACK_zsytrs LAPACK_GLOBAL(zsytrs,ZSYTRS)
+#define LAPACK_chetrs LAPACK_GLOBAL(chetrs,CHETRS)
+#define LAPACK_zhetrs LAPACK_GLOBAL(zhetrs,ZHETRS)
+#define LAPACK_ssptrs LAPACK_GLOBAL(ssptrs,SSPTRS)
+#define LAPACK_dsptrs LAPACK_GLOBAL(dsptrs,DSPTRS)
+#define LAPACK_csptrs LAPACK_GLOBAL(csptrs,CSPTRS)
+#define LAPACK_zsptrs LAPACK_GLOBAL(zsptrs,ZSPTRS)
+#define LAPACK_chptrs LAPACK_GLOBAL(chptrs,CHPTRS)
+#define LAPACK_zhptrs LAPACK_GLOBAL(zhptrs,ZHPTRS)
+#define LAPACK_strtrs LAPACK_GLOBAL(strtrs,STRTRS)
+#define LAPACK_dtrtrs LAPACK_GLOBAL(dtrtrs,DTRTRS)
+#define LAPACK_ctrtrs LAPACK_GLOBAL(ctrtrs,CTRTRS)
+#define LAPACK_ztrtrs LAPACK_GLOBAL(ztrtrs,ZTRTRS)
+#define LAPACK_stptrs LAPACK_GLOBAL(stptrs,STPTRS)
+#define LAPACK_dtptrs LAPACK_GLOBAL(dtptrs,DTPTRS)
+#define LAPACK_ctptrs LAPACK_GLOBAL(ctptrs,CTPTRS)
+#define LAPACK_ztptrs LAPACK_GLOBAL(ztptrs,ZTPTRS)
+#define LAPACK_stbtrs LAPACK_GLOBAL(stbtrs,STBTRS)
+#define LAPACK_dtbtrs LAPACK_GLOBAL(dtbtrs,DTBTRS)
+#define LAPACK_ctbtrs LAPACK_GLOBAL(ctbtrs,CTBTRS)
+#define LAPACK_ztbtrs LAPACK_GLOBAL(ztbtrs,ZTBTRS)
+#define LAPACK_sgecon LAPACK_GLOBAL(sgecon,SGECON)
+#define LAPACK_dgecon LAPACK_GLOBAL(dgecon,DGECON)
+#define LAPACK_cgecon LAPACK_GLOBAL(cgecon,CGECON)
+#define LAPACK_zgecon LAPACK_GLOBAL(zgecon,ZGECON)
+#define LAPACK_sgbcon LAPACK_GLOBAL(sgbcon,SGBCON)
+#define LAPACK_dgbcon LAPACK_GLOBAL(dgbcon,DGBCON)
+#define LAPACK_cgbcon LAPACK_GLOBAL(cgbcon,CGBCON)
+#define LAPACK_zgbcon LAPACK_GLOBAL(zgbcon,ZGBCON)
+#define LAPACK_sgtcon LAPACK_GLOBAL(sgtcon,SGTCON)
+#define LAPACK_dgtcon LAPACK_GLOBAL(dgtcon,DGTCON)
+#define LAPACK_cgtcon LAPACK_GLOBAL(cgtcon,CGTCON)
+#define LAPACK_zgtcon LAPACK_GLOBAL(zgtcon,ZGTCON)
+#define LAPACK_spocon LAPACK_GLOBAL(spocon,SPOCON)
+#define LAPACK_dpocon LAPACK_GLOBAL(dpocon,DPOCON)
+#define LAPACK_cpocon LAPACK_GLOBAL(cpocon,CPOCON)
+#define LAPACK_zpocon LAPACK_GLOBAL(zpocon,ZPOCON)
+#define LAPACK_sppcon LAPACK_GLOBAL(sppcon,SPPCON)
+#define LAPACK_dppcon LAPACK_GLOBAL(dppcon,DPPCON)
+#define LAPACK_cppcon LAPACK_GLOBAL(cppcon,CPPCON)
+#define LAPACK_zppcon LAPACK_GLOBAL(zppcon,ZPPCON)
+#define LAPACK_spbcon LAPACK_GLOBAL(spbcon,SPBCON)
+#define LAPACK_dpbcon LAPACK_GLOBAL(dpbcon,DPBCON)
+#define LAPACK_cpbcon LAPACK_GLOBAL(cpbcon,CPBCON)
+#define LAPACK_zpbcon LAPACK_GLOBAL(zpbcon,ZPBCON)
+#define LAPACK_sptcon LAPACK_GLOBAL(sptcon,SPTCON)
+#define LAPACK_dptcon LAPACK_GLOBAL(dptcon,DPTCON)
+#define LAPACK_cptcon LAPACK_GLOBAL(cptcon,CPTCON)
+#define LAPACK_zptcon LAPACK_GLOBAL(zptcon,ZPTCON)
+#define LAPACK_ssycon LAPACK_GLOBAL(ssycon,SSYCON)
+#define LAPACK_dsycon LAPACK_GLOBAL(dsycon,DSYCON)
+#define LAPACK_csycon LAPACK_GLOBAL(csycon,CSYCON)
+#define LAPACK_zsycon LAPACK_GLOBAL(zsycon,ZSYCON)
+#define LAPACK_checon LAPACK_GLOBAL(checon,CHECON)
+#define LAPACK_zhecon LAPACK_GLOBAL(zhecon,ZHECON)
+#define LAPACK_sspcon LAPACK_GLOBAL(sspcon,SSPCON)
+#define LAPACK_dspcon LAPACK_GLOBAL(dspcon,DSPCON)
+#define LAPACK_cspcon LAPACK_GLOBAL(cspcon,CSPCON)
+#define LAPACK_zspcon LAPACK_GLOBAL(zspcon,ZSPCON)
+#define LAPACK_chpcon LAPACK_GLOBAL(chpcon,CHPCON)
+#define LAPACK_zhpcon LAPACK_GLOBAL(zhpcon,ZHPCON)
+#define LAPACK_strcon LAPACK_GLOBAL(strcon,STRCON)
+#define LAPACK_dtrcon LAPACK_GLOBAL(dtrcon,DTRCON)
+#define LAPACK_ctrcon LAPACK_GLOBAL(ctrcon,CTRCON)
+#define LAPACK_ztrcon LAPACK_GLOBAL(ztrcon,ZTRCON)
+#define LAPACK_stpcon LAPACK_GLOBAL(stpcon,STPCON)
+#define LAPACK_dtpcon LAPACK_GLOBAL(dtpcon,DTPCON)
+#define LAPACK_ctpcon LAPACK_GLOBAL(ctpcon,CTPCON)
+#define LAPACK_ztpcon LAPACK_GLOBAL(ztpcon,ZTPCON)
+#define LAPACK_stbcon LAPACK_GLOBAL(stbcon,STBCON)
+#define LAPACK_dtbcon LAPACK_GLOBAL(dtbcon,DTBCON)
+#define LAPACK_ctbcon LAPACK_GLOBAL(ctbcon,CTBCON)
+#define LAPACK_ztbcon LAPACK_GLOBAL(ztbcon,ZTBCON)
+#define LAPACK_sgerfs LAPACK_GLOBAL(sgerfs,SGERFS)
+#define LAPACK_dgerfs LAPACK_GLOBAL(dgerfs,DGERFS)
+#define LAPACK_cgerfs LAPACK_GLOBAL(cgerfs,CGERFS)
+#define LAPACK_zgerfs LAPACK_GLOBAL(zgerfs,ZGERFS)
+#define LAPACK_dgerfsx LAPACK_GLOBAL(dgerfsx,DGERFSX)
+#define LAPACK_sgerfsx LAPACK_GLOBAL(sgerfsx,SGERFSX)
+#define LAPACK_zgerfsx LAPACK_GLOBAL(zgerfsx,ZGERFSX)
+#define LAPACK_cgerfsx LAPACK_GLOBAL(cgerfsx,CGERFSX)
+#define LAPACK_sgbrfs LAPACK_GLOBAL(sgbrfs,SGBRFS)
+#define LAPACK_dgbrfs LAPACK_GLOBAL(dgbrfs,DGBRFS)
+#define LAPACK_cgbrfs LAPACK_GLOBAL(cgbrfs,CGBRFS)
+#define LAPACK_zgbrfs LAPACK_GLOBAL(zgbrfs,ZGBRFS)
+#define LAPACK_dgbrfsx LAPACK_GLOBAL(dgbrfsx,DGBRFSX)
+#define LAPACK_sgbrfsx LAPACK_GLOBAL(sgbrfsx,SGBRFSX)
+#define LAPACK_zgbrfsx LAPACK_GLOBAL(zgbrfsx,ZGBRFSX)
+#define LAPACK_cgbrfsx LAPACK_GLOBAL(cgbrfsx,CGBRFSX)
+#define LAPACK_sgtrfs LAPACK_GLOBAL(sgtrfs,SGTRFS)
+#define LAPACK_dgtrfs LAPACK_GLOBAL(dgtrfs,DGTRFS)
+#define LAPACK_cgtrfs LAPACK_GLOBAL(cgtrfs,CGTRFS)
+#define LAPACK_zgtrfs LAPACK_GLOBAL(zgtrfs,ZGTRFS)
+#define LAPACK_sporfs LAPACK_GLOBAL(sporfs,SPORFS)
+#define LAPACK_dporfs LAPACK_GLOBAL(dporfs,DPORFS)
+#define LAPACK_cporfs LAPACK_GLOBAL(cporfs,CPORFS)
+#define LAPACK_zporfs LAPACK_GLOBAL(zporfs,ZPORFS)
+#define LAPACK_dporfsx LAPACK_GLOBAL(dporfsx,DPORFSX)
+#define LAPACK_sporfsx LAPACK_GLOBAL(sporfsx,SPORFSX)
+#define LAPACK_zporfsx LAPACK_GLOBAL(zporfsx,ZPORFSX)
+#define LAPACK_cporfsx LAPACK_GLOBAL(cporfsx,CPORFSX)
+#define LAPACK_spprfs LAPACK_GLOBAL(spprfs,SPPRFS)
+#define LAPACK_dpprfs LAPACK_GLOBAL(dpprfs,DPPRFS)
+#define LAPACK_cpprfs LAPACK_GLOBAL(cpprfs,CPPRFS)
+#define LAPACK_zpprfs LAPACK_GLOBAL(zpprfs,ZPPRFS)
+#define LAPACK_spbrfs LAPACK_GLOBAL(spbrfs,SPBRFS)
+#define LAPACK_dpbrfs LAPACK_GLOBAL(dpbrfs,DPBRFS)
+#define LAPACK_cpbrfs LAPACK_GLOBAL(cpbrfs,CPBRFS)
+#define LAPACK_zpbrfs LAPACK_GLOBAL(zpbrfs,ZPBRFS)
+#define LAPACK_sptrfs LAPACK_GLOBAL(sptrfs,SPTRFS)
+#define LAPACK_dptrfs LAPACK_GLOBAL(dptrfs,DPTRFS)
+#define LAPACK_cptrfs LAPACK_GLOBAL(cptrfs,CPTRFS)
+#define LAPACK_zptrfs LAPACK_GLOBAL(zptrfs,ZPTRFS)
+#define LAPACK_ssyrfs LAPACK_GLOBAL(ssyrfs,SSYRFS)
+#define LAPACK_dsyrfs LAPACK_GLOBAL(dsyrfs,DSYRFS)
+#define LAPACK_csyrfs LAPACK_GLOBAL(csyrfs,CSYRFS)
+#define LAPACK_zsyrfs LAPACK_GLOBAL(zsyrfs,ZSYRFS)
+#define LAPACK_dsyrfsx LAPACK_GLOBAL(dsyrfsx,DSYRFSX)
+#define LAPACK_ssyrfsx LAPACK_GLOBAL(ssyrfsx,SSYRFSX)
+#define LAPACK_zsyrfsx LAPACK_GLOBAL(zsyrfsx,ZSYRFSX)
+#define LAPACK_csyrfsx LAPACK_GLOBAL(csyrfsx,CSYRFSX)
+#define LAPACK_cherfs LAPACK_GLOBAL(cherfs,CHERFS)
+#define LAPACK_zherfs LAPACK_GLOBAL(zherfs,ZHERFS)
+#define LAPACK_zherfsx LAPACK_GLOBAL(zherfsx,ZHERFSX)
+#define LAPACK_cherfsx LAPACK_GLOBAL(cherfsx,CHERFSX)
+#define LAPACK_ssprfs LAPACK_GLOBAL(ssprfs,SSPRFS)
+#define LAPACK_dsprfs LAPACK_GLOBAL(dsprfs,DSPRFS)
+#define LAPACK_csprfs LAPACK_GLOBAL(csprfs,CSPRFS)
+#define LAPACK_zsprfs LAPACK_GLOBAL(zsprfs,ZSPRFS)
+#define LAPACK_chprfs LAPACK_GLOBAL(chprfs,CHPRFS)
+#define LAPACK_zhprfs LAPACK_GLOBAL(zhprfs,ZHPRFS)
+#define LAPACK_strrfs LAPACK_GLOBAL(strrfs,STRRFS)
+#define LAPACK_dtrrfs LAPACK_GLOBAL(dtrrfs,DTRRFS)
+#define LAPACK_ctrrfs LAPACK_GLOBAL(ctrrfs,CTRRFS)
+#define LAPACK_ztrrfs LAPACK_GLOBAL(ztrrfs,ZTRRFS)
+#define LAPACK_stprfs LAPACK_GLOBAL(stprfs,STPRFS)
+#define LAPACK_dtprfs LAPACK_GLOBAL(dtprfs,DTPRFS)
+#define LAPACK_ctprfs LAPACK_GLOBAL(ctprfs,CTPRFS)
+#define LAPACK_ztprfs LAPACK_GLOBAL(ztprfs,ZTPRFS)
+#define LAPACK_stbrfs LAPACK_GLOBAL(stbrfs,STBRFS)
+#define LAPACK_dtbrfs LAPACK_GLOBAL(dtbrfs,DTBRFS)
+#define LAPACK_ctbrfs LAPACK_GLOBAL(ctbrfs,CTBRFS)
+#define LAPACK_ztbrfs LAPACK_GLOBAL(ztbrfs,ZTBRFS)
+#define LAPACK_sgetri LAPACK_GLOBAL(sgetri,SGETRI)
+#define LAPACK_dgetri LAPACK_GLOBAL(dgetri,DGETRI)
+#define LAPACK_cgetri LAPACK_GLOBAL(cgetri,CGETRI)
+#define LAPACK_zgetri LAPACK_GLOBAL(zgetri,ZGETRI)
+#define LAPACK_spotri LAPACK_GLOBAL(spotri,SPOTRI)
+#define LAPACK_dpotri LAPACK_GLOBAL(dpotri,DPOTRI)
+#define LAPACK_cpotri LAPACK_GLOBAL(cpotri,CPOTRI)
+#define LAPACK_zpotri LAPACK_GLOBAL(zpotri,ZPOTRI)
+#define LAPACK_dpftri LAPACK_GLOBAL(dpftri,DPFTRI)
+#define LAPACK_spftri LAPACK_GLOBAL(spftri,SPFTRI)
+#define LAPACK_zpftri LAPACK_GLOBAL(zpftri,ZPFTRI)
+#define LAPACK_cpftri LAPACK_GLOBAL(cpftri,CPFTRI)
+#define LAPACK_spptri LAPACK_GLOBAL(spptri,SPPTRI)
+#define LAPACK_dpptri LAPACK_GLOBAL(dpptri,DPPTRI)
+#define LAPACK_cpptri LAPACK_GLOBAL(cpptri,CPPTRI)
+#define LAPACK_zpptri LAPACK_GLOBAL(zpptri,ZPPTRI)
+#define LAPACK_ssytri LAPACK_GLOBAL(ssytri,SSYTRI)
+#define LAPACK_dsytri LAPACK_GLOBAL(dsytri,DSYTRI)
+#define LAPACK_csytri LAPACK_GLOBAL(csytri,CSYTRI)
+#define LAPACK_zsytri LAPACK_GLOBAL(zsytri,ZSYTRI)
+#define LAPACK_chetri LAPACK_GLOBAL(chetri,CHETRI)
+#define LAPACK_zhetri LAPACK_GLOBAL(zhetri,ZHETRI)
+#define LAPACK_ssptri LAPACK_GLOBAL(ssptri,SSPTRI)
+#define LAPACK_dsptri LAPACK_GLOBAL(dsptri,DSPTRI)
+#define LAPACK_csptri LAPACK_GLOBAL(csptri,CSPTRI)
+#define LAPACK_zsptri LAPACK_GLOBAL(zsptri,ZSPTRI)
+#define LAPACK_chptri LAPACK_GLOBAL(chptri,CHPTRI)
+#define LAPACK_zhptri LAPACK_GLOBAL(zhptri,ZHPTRI)
+#define LAPACK_strtri LAPACK_GLOBAL(strtri,STRTRI)
+#define LAPACK_dtrtri LAPACK_GLOBAL(dtrtri,DTRTRI)
+#define LAPACK_ctrtri LAPACK_GLOBAL(ctrtri,CTRTRI)
+#define LAPACK_ztrtri LAPACK_GLOBAL(ztrtri,ZTRTRI)
+#define LAPACK_dtftri LAPACK_GLOBAL(dtftri,DTFTRI)
+#define LAPACK_stftri LAPACK_GLOBAL(stftri,STFTRI)
+#define LAPACK_ztftri LAPACK_GLOBAL(ztftri,ZTFTRI)
+#define LAPACK_ctftri LAPACK_GLOBAL(ctftri,CTFTRI)
+#define LAPACK_stptri LAPACK_GLOBAL(stptri,STPTRI)
+#define LAPACK_dtptri LAPACK_GLOBAL(dtptri,DTPTRI)
+#define LAPACK_ctptri LAPACK_GLOBAL(ctptri,CTPTRI)
+#define LAPACK_ztptri LAPACK_GLOBAL(ztptri,ZTPTRI)
+#define LAPACK_sgeequ LAPACK_GLOBAL(sgeequ,SGEEQU)
+#define LAPACK_dgeequ LAPACK_GLOBAL(dgeequ,DGEEQU)
+#define LAPACK_cgeequ LAPACK_GLOBAL(cgeequ,CGEEQU)
+#define LAPACK_zgeequ LAPACK_GLOBAL(zgeequ,ZGEEQU)
+#define LAPACK_dgeequb LAPACK_GLOBAL(dgeequb,DGEEQUB)
+#define LAPACK_sgeequb LAPACK_GLOBAL(sgeequb,SGEEQUB)
+#define LAPACK_zgeequb LAPACK_GLOBAL(zgeequb,ZGEEQUB)
+#define LAPACK_cgeequb LAPACK_GLOBAL(cgeequb,CGEEQUB)
+#define LAPACK_sgbequ LAPACK_GLOBAL(sgbequ,SGBEQU)
+#define LAPACK_dgbequ LAPACK_GLOBAL(dgbequ,DGBEQU)
+#define LAPACK_cgbequ LAPACK_GLOBAL(cgbequ,CGBEQU)
+#define LAPACK_zgbequ LAPACK_GLOBAL(zgbequ,ZGBEQU)
+#define LAPACK_dgbequb LAPACK_GLOBAL(dgbequb,DGBEQUB)
+#define LAPACK_sgbequb LAPACK_GLOBAL(sgbequb,SGBEQUB)
+#define LAPACK_zgbequb LAPACK_GLOBAL(zgbequb,ZGBEQUB)
+#define LAPACK_cgbequb LAPACK_GLOBAL(cgbequb,CGBEQUB)
+#define LAPACK_spoequ LAPACK_GLOBAL(spoequ,SPOEQU)
+#define LAPACK_dpoequ LAPACK_GLOBAL(dpoequ,DPOEQU)
+#define LAPACK_cpoequ LAPACK_GLOBAL(cpoequ,CPOEQU)
+#define LAPACK_zpoequ LAPACK_GLOBAL(zpoequ,ZPOEQU)
+#define LAPACK_dpoequb LAPACK_GLOBAL(dpoequb,DPOEQUB)
+#define LAPACK_spoequb LAPACK_GLOBAL(spoequb,SPOEQUB)
+#define LAPACK_zpoequb LAPACK_GLOBAL(zpoequb,ZPOEQUB)
+#define LAPACK_cpoequb LAPACK_GLOBAL(cpoequb,CPOEQUB)
+#define LAPACK_sppequ LAPACK_GLOBAL(sppequ,SPPEQU)
+#define LAPACK_dppequ LAPACK_GLOBAL(dppequ,DPPEQU)
+#define LAPACK_cppequ LAPACK_GLOBAL(cppequ,CPPEQU)
+#define LAPACK_zppequ LAPACK_GLOBAL(zppequ,ZPPEQU)
+#define LAPACK_spbequ LAPACK_GLOBAL(spbequ,SPBEQU)
+#define LAPACK_dpbequ LAPACK_GLOBAL(dpbequ,DPBEQU)
+#define LAPACK_cpbequ LAPACK_GLOBAL(cpbequ,CPBEQU)
+#define LAPACK_zpbequ LAPACK_GLOBAL(zpbequ,ZPBEQU)
+#define LAPACK_dsyequb LAPACK_GLOBAL(dsyequb,DSYEQUB)
+#define LAPACK_ssyequb LAPACK_GLOBAL(ssyequb,SSYEQUB)
+#define LAPACK_zsyequb LAPACK_GLOBAL(zsyequb,ZSYEQUB)
+#define LAPACK_csyequb LAPACK_GLOBAL(csyequb,CSYEQUB)
+#define LAPACK_zheequb LAPACK_GLOBAL(zheequb,ZHEEQUB)
+#define LAPACK_cheequb LAPACK_GLOBAL(cheequb,CHEEQUB)
+#define LAPACK_sgesv LAPACK_GLOBAL(sgesv,SGESV)
+#define LAPACK_dgesv LAPACK_GLOBAL(dgesv,DGESV)
+#define LAPACK_cgesv LAPACK_GLOBAL(cgesv,CGESV)
+#define LAPACK_zgesv LAPACK_GLOBAL(zgesv,ZGESV)
+#define LAPACK_dsgesv LAPACK_GLOBAL(dsgesv,DSGESV)
+#define LAPACK_zcgesv LAPACK_GLOBAL(zcgesv,ZCGESV)
+#define LAPACK_sgesvx LAPACK_GLOBAL(sgesvx,SGESVX)
+#define LAPACK_dgesvx LAPACK_GLOBAL(dgesvx,DGESVX)
+#define LAPACK_cgesvx LAPACK_GLOBAL(cgesvx,CGESVX)
+#define LAPACK_zgesvx LAPACK_GLOBAL(zgesvx,ZGESVX)
+#define LAPACK_dgesvxx LAPACK_GLOBAL(dgesvxx,DGESVXX)
+#define LAPACK_sgesvxx LAPACK_GLOBAL(sgesvxx,SGESVXX)
+#define LAPACK_zgesvxx LAPACK_GLOBAL(zgesvxx,ZGESVXX)
+#define LAPACK_cgesvxx LAPACK_GLOBAL(cgesvxx,CGESVXX)
+#define LAPACK_sgbsv LAPACK_GLOBAL(sgbsv,SGBSV)
+#define LAPACK_dgbsv LAPACK_GLOBAL(dgbsv,DGBSV)
+#define LAPACK_cgbsv LAPACK_GLOBAL(cgbsv,CGBSV)
+#define LAPACK_zgbsv LAPACK_GLOBAL(zgbsv,ZGBSV)
+#define LAPACK_sgbsvx LAPACK_GLOBAL(sgbsvx,SGBSVX)
+#define LAPACK_dgbsvx LAPACK_GLOBAL(dgbsvx,DGBSVX)
+#define LAPACK_cgbsvx LAPACK_GLOBAL(cgbsvx,CGBSVX)
+#define LAPACK_zgbsvx LAPACK_GLOBAL(zgbsvx,ZGBSVX)
+#define LAPACK_dgbsvxx LAPACK_GLOBAL(dgbsvxx,DGBSVXX)
+#define LAPACK_sgbsvxx LAPACK_GLOBAL(sgbsvxx,SGBSVXX)
+#define LAPACK_zgbsvxx LAPACK_GLOBAL(zgbsvxx,ZGBSVXX)
+#define LAPACK_cgbsvxx LAPACK_GLOBAL(cgbsvxx,CGBSVXX)
+#define LAPACK_sgtsv LAPACK_GLOBAL(sgtsv,SGTSV)
+#define LAPACK_dgtsv LAPACK_GLOBAL(dgtsv,DGTSV)
+#define LAPACK_cgtsv LAPACK_GLOBAL(cgtsv,CGTSV)
+#define LAPACK_zgtsv LAPACK_GLOBAL(zgtsv,ZGTSV)
+#define LAPACK_sgtsvx LAPACK_GLOBAL(sgtsvx,SGTSVX)
+#define LAPACK_dgtsvx LAPACK_GLOBAL(dgtsvx,DGTSVX)
+#define LAPACK_cgtsvx LAPACK_GLOBAL(cgtsvx,CGTSVX)
+#define LAPACK_zgtsvx LAPACK_GLOBAL(zgtsvx,ZGTSVX)
+#define LAPACK_sposv LAPACK_GLOBAL(sposv,SPOSV)
+#define LAPACK_dposv LAPACK_GLOBAL(dposv,DPOSV)
+#define LAPACK_cposv LAPACK_GLOBAL(cposv,CPOSV)
+#define LAPACK_zposv LAPACK_GLOBAL(zposv,ZPOSV)
+#define LAPACK_dsposv LAPACK_GLOBAL(dsposv,DSPOSV)
+#define LAPACK_zcposv LAPACK_GLOBAL(zcposv,ZCPOSV)
+#define LAPACK_sposvx LAPACK_GLOBAL(sposvx,SPOSVX)
+#define LAPACK_dposvx LAPACK_GLOBAL(dposvx,DPOSVX)
+#define LAPACK_cposvx LAPACK_GLOBAL(cposvx,CPOSVX)
+#define LAPACK_zposvx LAPACK_GLOBAL(zposvx,ZPOSVX)
+#define LAPACK_dposvxx LAPACK_GLOBAL(dposvxx,DPOSVXX)
+#define LAPACK_sposvxx LAPACK_GLOBAL(sposvxx,SPOSVXX)
+#define LAPACK_zposvxx LAPACK_GLOBAL(zposvxx,ZPOSVXX)
+#define LAPACK_cposvxx LAPACK_GLOBAL(cposvxx,CPOSVXX)
+#define LAPACK_sppsv LAPACK_GLOBAL(sppsv,SPPSV)
+#define LAPACK_dppsv LAPACK_GLOBAL(dppsv,DPPSV)
+#define LAPACK_cppsv LAPACK_GLOBAL(cppsv,CPPSV)
+#define LAPACK_zppsv LAPACK_GLOBAL(zppsv,ZPPSV)
+#define LAPACK_sppsvx LAPACK_GLOBAL(sppsvx,SPPSVX)
+#define LAPACK_dppsvx LAPACK_GLOBAL(dppsvx,DPPSVX)
+#define LAPACK_cppsvx LAPACK_GLOBAL(cppsvx,CPPSVX)
+#define LAPACK_zppsvx LAPACK_GLOBAL(zppsvx,ZPPSVX)
+#define LAPACK_spbsv LAPACK_GLOBAL(spbsv,SPBSV)
+#define LAPACK_dpbsv LAPACK_GLOBAL(dpbsv,DPBSV)
+#define LAPACK_cpbsv LAPACK_GLOBAL(cpbsv,CPBSV)
+#define LAPACK_zpbsv LAPACK_GLOBAL(zpbsv,ZPBSV)
+#define LAPACK_spbsvx LAPACK_GLOBAL(spbsvx,SPBSVX)
+#define LAPACK_dpbsvx LAPACK_GLOBAL(dpbsvx,DPBSVX)
+#define LAPACK_cpbsvx LAPACK_GLOBAL(cpbsvx,CPBSVX)
+#define LAPACK_zpbsvx LAPACK_GLOBAL(zpbsvx,ZPBSVX)
+#define LAPACK_sptsv LAPACK_GLOBAL(sptsv,SPTSV)
+#define LAPACK_dptsv LAPACK_GLOBAL(dptsv,DPTSV)
+#define LAPACK_cptsv LAPACK_GLOBAL(cptsv,CPTSV)
+#define LAPACK_zptsv LAPACK_GLOBAL(zptsv,ZPTSV)
+#define LAPACK_sptsvx LAPACK_GLOBAL(sptsvx,SPTSVX)
+#define LAPACK_dptsvx LAPACK_GLOBAL(dptsvx,DPTSVX)
+#define LAPACK_cptsvx LAPACK_GLOBAL(cptsvx,CPTSVX)
+#define LAPACK_zptsvx LAPACK_GLOBAL(zptsvx,ZPTSVX)
+#define LAPACK_ssysv LAPACK_GLOBAL(ssysv,SSYSV)
+#define LAPACK_dsysv LAPACK_GLOBAL(dsysv,DSYSV)
+#define LAPACK_csysv LAPACK_GLOBAL(csysv,CSYSV)
+#define LAPACK_zsysv LAPACK_GLOBAL(zsysv,ZSYSV)
+#define LAPACK_ssysvx LAPACK_GLOBAL(ssysvx,SSYSVX)
+#define LAPACK_dsysvx LAPACK_GLOBAL(dsysvx,DSYSVX)
+#define LAPACK_csysvx LAPACK_GLOBAL(csysvx,CSYSVX)
+#define LAPACK_zsysvx LAPACK_GLOBAL(zsysvx,ZSYSVX)
+#define LAPACK_dsysvxx LAPACK_GLOBAL(dsysvxx,DSYSVXX)
+#define LAPACK_ssysvxx LAPACK_GLOBAL(ssysvxx,SSYSVXX)
+#define LAPACK_zsysvxx LAPACK_GLOBAL(zsysvxx,ZSYSVXX)
+#define LAPACK_csysvxx LAPACK_GLOBAL(csysvxx,CSYSVXX)
+#define LAPACK_chesv LAPACK_GLOBAL(chesv,CHESV)
+#define LAPACK_zhesv LAPACK_GLOBAL(zhesv,ZHESV)
+#define LAPACK_chesvx LAPACK_GLOBAL(chesvx,CHESVX)
+#define LAPACK_zhesvx LAPACK_GLOBAL(zhesvx,ZHESVX)
+#define LAPACK_zhesvxx LAPACK_GLOBAL(zhesvxx,ZHESVXX)
+#define LAPACK_chesvxx LAPACK_GLOBAL(chesvxx,CHESVXX)
+#define LAPACK_sspsv LAPACK_GLOBAL(sspsv,SSPSV)
+#define LAPACK_dspsv LAPACK_GLOBAL(dspsv,DSPSV)
+#define LAPACK_cspsv LAPACK_GLOBAL(cspsv,CSPSV)
+#define LAPACK_zspsv LAPACK_GLOBAL(zspsv,ZSPSV)
+#define LAPACK_sspsvx LAPACK_GLOBAL(sspsvx,SSPSVX)
+#define LAPACK_dspsvx LAPACK_GLOBAL(dspsvx,DSPSVX)
+#define LAPACK_cspsvx LAPACK_GLOBAL(cspsvx,CSPSVX)
+#define LAPACK_zspsvx LAPACK_GLOBAL(zspsvx,ZSPSVX)
+#define LAPACK_chpsv LAPACK_GLOBAL(chpsv,CHPSV)
+#define LAPACK_zhpsv LAPACK_GLOBAL(zhpsv,ZHPSV)
+#define LAPACK_chpsvx LAPACK_GLOBAL(chpsvx,CHPSVX)
+#define LAPACK_zhpsvx LAPACK_GLOBAL(zhpsvx,ZHPSVX)
+#define LAPACK_sgeqrf LAPACK_GLOBAL(sgeqrf,SGEQRF)
+#define LAPACK_dgeqrf LAPACK_GLOBAL(dgeqrf,DGEQRF)
+#define LAPACK_cgeqrf LAPACK_GLOBAL(cgeqrf,CGEQRF)
+#define LAPACK_zgeqrf LAPACK_GLOBAL(zgeqrf,ZGEQRF)
+#define LAPACK_sgeqpf LAPACK_GLOBAL(sgeqpf,SGEQPF)
+#define LAPACK_dgeqpf LAPACK_GLOBAL(dgeqpf,DGEQPF)
+#define LAPACK_cgeqpf LAPACK_GLOBAL(cgeqpf,CGEQPF)
+#define LAPACK_zgeqpf LAPACK_GLOBAL(zgeqpf,ZGEQPF)
+#define LAPACK_sgeqp3 LAPACK_GLOBAL(sgeqp3,SGEQP3)
+#define LAPACK_dgeqp3 LAPACK_GLOBAL(dgeqp3,DGEQP3)
+#define LAPACK_cgeqp3 LAPACK_GLOBAL(cgeqp3,CGEQP3)
+#define LAPACK_zgeqp3 LAPACK_GLOBAL(zgeqp3,ZGEQP3)
+#define LAPACK_sorgqr LAPACK_GLOBAL(sorgqr,SORGQR)
+#define LAPACK_dorgqr LAPACK_GLOBAL(dorgqr,DORGQR)
+#define LAPACK_sormqr LAPACK_GLOBAL(sormqr,SORMQR)
+#define LAPACK_dormqr LAPACK_GLOBAL(dormqr,DORMQR)
+#define LAPACK_cungqr LAPACK_GLOBAL(cungqr,CUNGQR)
+#define LAPACK_zungqr LAPACK_GLOBAL(zungqr,ZUNGQR)
+#define LAPACK_cunmqr LAPACK_GLOBAL(cunmqr,CUNMQR)
+#define LAPACK_zunmqr LAPACK_GLOBAL(zunmqr,ZUNMQR)
+#define LAPACK_sgelqf LAPACK_GLOBAL(sgelqf,SGELQF)
+#define LAPACK_dgelqf LAPACK_GLOBAL(dgelqf,DGELQF)
+#define LAPACK_cgelqf LAPACK_GLOBAL(cgelqf,CGELQF)
+#define LAPACK_zgelqf LAPACK_GLOBAL(zgelqf,ZGELQF)
+#define LAPACK_sorglq LAPACK_GLOBAL(sorglq,SORGLQ)
+#define LAPACK_dorglq LAPACK_GLOBAL(dorglq,DORGLQ)
+#define LAPACK_sormlq LAPACK_GLOBAL(sormlq,SORMLQ)
+#define LAPACK_dormlq LAPACK_GLOBAL(dormlq,DORMLQ)
+#define LAPACK_cunglq LAPACK_GLOBAL(cunglq,CUNGLQ)
+#define LAPACK_zunglq LAPACK_GLOBAL(zunglq,ZUNGLQ)
+#define LAPACK_cunmlq LAPACK_GLOBAL(cunmlq,CUNMLQ)
+#define LAPACK_zunmlq LAPACK_GLOBAL(zunmlq,ZUNMLQ)
+#define LAPACK_sgeqlf LAPACK_GLOBAL(sgeqlf,SGEQLF)
+#define LAPACK_dgeqlf LAPACK_GLOBAL(dgeqlf,DGEQLF)
+#define LAPACK_cgeqlf LAPACK_GLOBAL(cgeqlf,CGEQLF)
+#define LAPACK_zgeqlf LAPACK_GLOBAL(zgeqlf,ZGEQLF)
+#define LAPACK_sorgql LAPACK_GLOBAL(sorgql,SORGQL)
+#define LAPACK_dorgql LAPACK_GLOBAL(dorgql,DORGQL)
+#define LAPACK_cungql LAPACK_GLOBAL(cungql,CUNGQL)
+#define LAPACK_zungql LAPACK_GLOBAL(zungql,ZUNGQL)
+#define LAPACK_sormql LAPACK_GLOBAL(sormql,SORMQL)
+#define LAPACK_dormql LAPACK_GLOBAL(dormql,DORMQL)
+#define LAPACK_cunmql LAPACK_GLOBAL(cunmql,CUNMQL)
+#define LAPACK_zunmql LAPACK_GLOBAL(zunmql,ZUNMQL)
+#define LAPACK_sgerqf LAPACK_GLOBAL(sgerqf,SGERQF)
+#define LAPACK_dgerqf LAPACK_GLOBAL(dgerqf,DGERQF)
+#define LAPACK_cgerqf LAPACK_GLOBAL(cgerqf,CGERQF)
+#define LAPACK_zgerqf LAPACK_GLOBAL(zgerqf,ZGERQF)
+#define LAPACK_sorgrq LAPACK_GLOBAL(sorgrq,SORGRQ)
+#define LAPACK_dorgrq LAPACK_GLOBAL(dorgrq,DORGRQ)
+#define LAPACK_cungrq LAPACK_GLOBAL(cungrq,CUNGRQ)
+#define LAPACK_zungrq LAPACK_GLOBAL(zungrq,ZUNGRQ)
+#define LAPACK_sormrq LAPACK_GLOBAL(sormrq,SORMRQ)
+#define LAPACK_dormrq LAPACK_GLOBAL(dormrq,DORMRQ)
+#define LAPACK_cunmrq LAPACK_GLOBAL(cunmrq,CUNMRQ)
+#define LAPACK_zunmrq LAPACK_GLOBAL(zunmrq,ZUNMRQ)
+#define LAPACK_stzrzf LAPACK_GLOBAL(stzrzf,STZRZF)
+#define LAPACK_dtzrzf LAPACK_GLOBAL(dtzrzf,DTZRZF)
+#define LAPACK_ctzrzf LAPACK_GLOBAL(ctzrzf,CTZRZF)
+#define LAPACK_ztzrzf LAPACK_GLOBAL(ztzrzf,ZTZRZF)
+#define LAPACK_sormrz LAPACK_GLOBAL(sormrz,SORMRZ)
+#define LAPACK_dormrz LAPACK_GLOBAL(dormrz,DORMRZ)
+#define LAPACK_cunmrz LAPACK_GLOBAL(cunmrz,CUNMRZ)
+#define LAPACK_zunmrz LAPACK_GLOBAL(zunmrz,ZUNMRZ)
+#define LAPACK_sggqrf LAPACK_GLOBAL(sggqrf,SGGQRF)
+#define LAPACK_dggqrf LAPACK_GLOBAL(dggqrf,DGGQRF)
+#define LAPACK_cggqrf LAPACK_GLOBAL(cggqrf,CGGQRF)
+#define LAPACK_zggqrf LAPACK_GLOBAL(zggqrf,ZGGQRF)
+#define LAPACK_sggrqf LAPACK_GLOBAL(sggrqf,SGGRQF)
+#define LAPACK_dggrqf LAPACK_GLOBAL(dggrqf,DGGRQF)
+#define LAPACK_cggrqf LAPACK_GLOBAL(cggrqf,CGGRQF)
+#define LAPACK_zggrqf LAPACK_GLOBAL(zggrqf,ZGGRQF)
+#define LAPACK_sgebrd LAPACK_GLOBAL(sgebrd,SGEBRD)
+#define LAPACK_dgebrd LAPACK_GLOBAL(dgebrd,DGEBRD)
+#define LAPACK_cgebrd LAPACK_GLOBAL(cgebrd,CGEBRD)
+#define LAPACK_zgebrd LAPACK_GLOBAL(zgebrd,ZGEBRD)
+#define LAPACK_sgbbrd LAPACK_GLOBAL(sgbbrd,SGBBRD)
+#define LAPACK_dgbbrd LAPACK_GLOBAL(dgbbrd,DGBBRD)
+#define LAPACK_cgbbrd LAPACK_GLOBAL(cgbbrd,CGBBRD)
+#define LAPACK_zgbbrd LAPACK_GLOBAL(zgbbrd,ZGBBRD)
+#define LAPACK_sorgbr LAPACK_GLOBAL(sorgbr,SORGBR)
+#define LAPACK_dorgbr LAPACK_GLOBAL(dorgbr,DORGBR)
+#define LAPACK_sormbr LAPACK_GLOBAL(sormbr,SORMBR)
+#define LAPACK_dormbr LAPACK_GLOBAL(dormbr,DORMBR)
+#define LAPACK_cungbr LAPACK_GLOBAL(cungbr,CUNGBR)
+#define LAPACK_zungbr LAPACK_GLOBAL(zungbr,ZUNGBR)
+#define LAPACK_cunmbr LAPACK_GLOBAL(cunmbr,CUNMBR)
+#define LAPACK_zunmbr LAPACK_GLOBAL(zunmbr,ZUNMBR)
+#define LAPACK_sbdsqr LAPACK_GLOBAL(sbdsqr,SBDSQR)
+#define LAPACK_dbdsqr LAPACK_GLOBAL(dbdsqr,DBDSQR)
+#define LAPACK_cbdsqr LAPACK_GLOBAL(cbdsqr,CBDSQR)
+#define LAPACK_zbdsqr LAPACK_GLOBAL(zbdsqr,ZBDSQR)
+#define LAPACK_sbdsdc LAPACK_GLOBAL(sbdsdc,SBDSDC)
+#define LAPACK_dbdsdc LAPACK_GLOBAL(dbdsdc,DBDSDC)
+#define LAPACK_ssytrd LAPACK_GLOBAL(ssytrd,SSYTRD)
+#define LAPACK_dsytrd LAPACK_GLOBAL(dsytrd,DSYTRD)
+#define LAPACK_sorgtr LAPACK_GLOBAL(sorgtr,SORGTR)
+#define LAPACK_dorgtr LAPACK_GLOBAL(dorgtr,DORGTR)
+#define LAPACK_sormtr LAPACK_GLOBAL(sormtr,SORMTR)
+#define LAPACK_dormtr LAPACK_GLOBAL(dormtr,DORMTR)
+#define LAPACK_chetrd LAPACK_GLOBAL(chetrd,CHETRD)
+#define LAPACK_zhetrd LAPACK_GLOBAL(zhetrd,ZHETRD)
+#define LAPACK_cungtr LAPACK_GLOBAL(cungtr,CUNGTR)
+#define LAPACK_zungtr LAPACK_GLOBAL(zungtr,ZUNGTR)
+#define LAPACK_cunmtr LAPACK_GLOBAL(cunmtr,CUNMTR)
+#define LAPACK_zunmtr LAPACK_GLOBAL(zunmtr,ZUNMTR)
+#define LAPACK_ssptrd LAPACK_GLOBAL(ssptrd,SSPTRD)
+#define LAPACK_dsptrd LAPACK_GLOBAL(dsptrd,DSPTRD)
+#define LAPACK_sopgtr LAPACK_GLOBAL(sopgtr,SOPGTR)
+#define LAPACK_dopgtr LAPACK_GLOBAL(dopgtr,DOPGTR)
+#define LAPACK_sopmtr LAPACK_GLOBAL(sopmtr,SOPMTR)
+#define LAPACK_dopmtr LAPACK_GLOBAL(dopmtr,DOPMTR)
+#define LAPACK_chptrd LAPACK_GLOBAL(chptrd,CHPTRD)
+#define LAPACK_zhptrd LAPACK_GLOBAL(zhptrd,ZHPTRD)
+#define LAPACK_cupgtr LAPACK_GLOBAL(cupgtr,CUPGTR)
+#define LAPACK_zupgtr LAPACK_GLOBAL(zupgtr,ZUPGTR)
+#define LAPACK_cupmtr LAPACK_GLOBAL(cupmtr,CUPMTR)
+#define LAPACK_zupmtr LAPACK_GLOBAL(zupmtr,ZUPMTR)
+#define LAPACK_ssbtrd LAPACK_GLOBAL(ssbtrd,SSBTRD)
+#define LAPACK_dsbtrd LAPACK_GLOBAL(dsbtrd,DSBTRD)
+#define LAPACK_chbtrd LAPACK_GLOBAL(chbtrd,CHBTRD)
+#define LAPACK_zhbtrd LAPACK_GLOBAL(zhbtrd,ZHBTRD)
+#define LAPACK_ssterf LAPACK_GLOBAL(ssterf,SSTERF)
+#define LAPACK_dsterf LAPACK_GLOBAL(dsterf,DSTERF)
+#define LAPACK_ssteqr LAPACK_GLOBAL(ssteqr,SSTEQR)
+#define LAPACK_dsteqr LAPACK_GLOBAL(dsteqr,DSTEQR)
+#define LAPACK_csteqr LAPACK_GLOBAL(csteqr,CSTEQR)
+#define LAPACK_zsteqr LAPACK_GLOBAL(zsteqr,ZSTEQR)
+#define LAPACK_sstemr LAPACK_GLOBAL(sstemr,SSTEMR)
+#define LAPACK_dstemr LAPACK_GLOBAL(dstemr,DSTEMR)
+#define LAPACK_cstemr LAPACK_GLOBAL(cstemr,CSTEMR)
+#define LAPACK_zstemr LAPACK_GLOBAL(zstemr,ZSTEMR)
+#define LAPACK_sstedc LAPACK_GLOBAL(sstedc,SSTEDC)
+#define LAPACK_dstedc LAPACK_GLOBAL(dstedc,DSTEDC)
+#define LAPACK_cstedc LAPACK_GLOBAL(cstedc,CSTEDC)
+#define LAPACK_zstedc LAPACK_GLOBAL(zstedc,ZSTEDC)
+#define LAPACK_sstegr LAPACK_GLOBAL(sstegr,SSTEGR)
+#define LAPACK_dstegr LAPACK_GLOBAL(dstegr,DSTEGR)
+#define LAPACK_cstegr LAPACK_GLOBAL(cstegr,CSTEGR)
+#define LAPACK_zstegr LAPACK_GLOBAL(zstegr,ZSTEGR)
+#define LAPACK_spteqr LAPACK_GLOBAL(spteqr,SPTEQR)
+#define LAPACK_dpteqr LAPACK_GLOBAL(dpteqr,DPTEQR)
+#define LAPACK_cpteqr LAPACK_GLOBAL(cpteqr,CPTEQR)
+#define LAPACK_zpteqr LAPACK_GLOBAL(zpteqr,ZPTEQR)
+#define LAPACK_sstebz LAPACK_GLOBAL(sstebz,SSTEBZ)
+#define LAPACK_dstebz LAPACK_GLOBAL(dstebz,DSTEBZ)
+#define LAPACK_sstein LAPACK_GLOBAL(sstein,SSTEIN)
+#define LAPACK_dstein LAPACK_GLOBAL(dstein,DSTEIN)
+#define LAPACK_cstein LAPACK_GLOBAL(cstein,CSTEIN)
+#define LAPACK_zstein LAPACK_GLOBAL(zstein,ZSTEIN)
+#define LAPACK_sdisna LAPACK_GLOBAL(sdisna,SDISNA)
+#define LAPACK_ddisna LAPACK_GLOBAL(ddisna,DDISNA)
+#define LAPACK_ssygst LAPACK_GLOBAL(ssygst,SSYGST)
+#define LAPACK_dsygst LAPACK_GLOBAL(dsygst,DSYGST)
+#define LAPACK_chegst LAPACK_GLOBAL(chegst,CHEGST)
+#define LAPACK_zhegst LAPACK_GLOBAL(zhegst,ZHEGST)
+#define LAPACK_sspgst LAPACK_GLOBAL(sspgst,SSPGST)
+#define LAPACK_dspgst LAPACK_GLOBAL(dspgst,DSPGST)
+#define LAPACK_chpgst LAPACK_GLOBAL(chpgst,CHPGST)
+#define LAPACK_zhpgst LAPACK_GLOBAL(zhpgst,ZHPGST)
+#define LAPACK_ssbgst LAPACK_GLOBAL(ssbgst,SSBGST)
+#define LAPACK_dsbgst LAPACK_GLOBAL(dsbgst,DSBGST)
+#define LAPACK_chbgst LAPACK_GLOBAL(chbgst,CHBGST)
+#define LAPACK_zhbgst LAPACK_GLOBAL(zhbgst,ZHBGST)
+#define LAPACK_spbstf LAPACK_GLOBAL(spbstf,SPBSTF)
+#define LAPACK_dpbstf LAPACK_GLOBAL(dpbstf,DPBSTF)
+#define LAPACK_cpbstf LAPACK_GLOBAL(cpbstf,CPBSTF)
+#define LAPACK_zpbstf LAPACK_GLOBAL(zpbstf,ZPBSTF)
+#define LAPACK_sgehrd LAPACK_GLOBAL(sgehrd,SGEHRD)
+#define LAPACK_dgehrd LAPACK_GLOBAL(dgehrd,DGEHRD)
+#define LAPACK_cgehrd LAPACK_GLOBAL(cgehrd,CGEHRD)
+#define LAPACK_zgehrd LAPACK_GLOBAL(zgehrd,ZGEHRD)
+#define LAPACK_sorghr LAPACK_GLOBAL(sorghr,SORGHR)
+#define LAPACK_dorghr LAPACK_GLOBAL(dorghr,DORGHR)
+#define LAPACK_sormhr LAPACK_GLOBAL(sormhr,SORMHR)
+#define LAPACK_dormhr LAPACK_GLOBAL(dormhr,DORMHR)
+#define LAPACK_cunghr LAPACK_GLOBAL(cunghr,CUNGHR)
+#define LAPACK_zunghr LAPACK_GLOBAL(zunghr,ZUNGHR)
+#define LAPACK_cunmhr LAPACK_GLOBAL(cunmhr,CUNMHR)
+#define LAPACK_zunmhr LAPACK_GLOBAL(zunmhr,ZUNMHR)
+#define LAPACK_sgebal LAPACK_GLOBAL(sgebal,SGEBAL)
+#define LAPACK_dgebal LAPACK_GLOBAL(dgebal,DGEBAL)
+#define LAPACK_cgebal LAPACK_GLOBAL(cgebal,CGEBAL)
+#define LAPACK_zgebal LAPACK_GLOBAL(zgebal,ZGEBAL)
+#define LAPACK_sgebak LAPACK_GLOBAL(sgebak,SGEBAK)
+#define LAPACK_dgebak LAPACK_GLOBAL(dgebak,DGEBAK)
+#define LAPACK_cgebak LAPACK_GLOBAL(cgebak,CGEBAK)
+#define LAPACK_zgebak LAPACK_GLOBAL(zgebak,ZGEBAK)
+#define LAPACK_shseqr LAPACK_GLOBAL(shseqr,SHSEQR)
+#define LAPACK_dhseqr LAPACK_GLOBAL(dhseqr,DHSEQR)
+#define LAPACK_chseqr LAPACK_GLOBAL(chseqr,CHSEQR)
+#define LAPACK_zhseqr LAPACK_GLOBAL(zhseqr,ZHSEQR)
+#define LAPACK_shsein LAPACK_GLOBAL(shsein,SHSEIN)
+#define LAPACK_dhsein LAPACK_GLOBAL(dhsein,DHSEIN)
+#define LAPACK_chsein LAPACK_GLOBAL(chsein,CHSEIN)
+#define LAPACK_zhsein LAPACK_GLOBAL(zhsein,ZHSEIN)
+#define LAPACK_strevc LAPACK_GLOBAL(strevc,STREVC)
+#define LAPACK_dtrevc LAPACK_GLOBAL(dtrevc,DTREVC)
+#define LAPACK_ctrevc LAPACK_GLOBAL(ctrevc,CTREVC)
+#define LAPACK_ztrevc LAPACK_GLOBAL(ztrevc,ZTREVC)
+#define LAPACK_strsna LAPACK_GLOBAL(strsna,STRSNA)
+#define LAPACK_dtrsna LAPACK_GLOBAL(dtrsna,DTRSNA)
+#define LAPACK_ctrsna LAPACK_GLOBAL(ctrsna,CTRSNA)
+#define LAPACK_ztrsna LAPACK_GLOBAL(ztrsna,ZTRSNA)
+#define LAPACK_strexc LAPACK_GLOBAL(strexc,STREXC)
+#define LAPACK_dtrexc LAPACK_GLOBAL(dtrexc,DTREXC)
+#define LAPACK_ctrexc LAPACK_GLOBAL(ctrexc,CTREXC)
+#define LAPACK_ztrexc LAPACK_GLOBAL(ztrexc,ZTREXC)
+#define LAPACK_strsen LAPACK_GLOBAL(strsen,STRSEN)
+#define LAPACK_dtrsen LAPACK_GLOBAL(dtrsen,DTRSEN)
+#define LAPACK_ctrsen LAPACK_GLOBAL(ctrsen,CTRSEN)
+#define LAPACK_ztrsen LAPACK_GLOBAL(ztrsen,ZTRSEN)
+#define LAPACK_strsyl LAPACK_GLOBAL(strsyl,STRSYL)
+#define LAPACK_dtrsyl LAPACK_GLOBAL(dtrsyl,DTRSYL)
+#define LAPACK_ctrsyl LAPACK_GLOBAL(ctrsyl,CTRSYL)
+#define LAPACK_ztrsyl LAPACK_GLOBAL(ztrsyl,ZTRSYL)
+#define LAPACK_sgghrd LAPACK_GLOBAL(sgghrd,SGGHRD)
+#define LAPACK_dgghrd LAPACK_GLOBAL(dgghrd,DGGHRD)
+#define LAPACK_cgghrd LAPACK_GLOBAL(cgghrd,CGGHRD)
+#define LAPACK_zgghrd LAPACK_GLOBAL(zgghrd,ZGGHRD)
+#define LAPACK_sggbal LAPACK_GLOBAL(sggbal,SGGBAL)
+#define LAPACK_dggbal LAPACK_GLOBAL(dggbal,DGGBAL)
+#define LAPACK_cggbal LAPACK_GLOBAL(cggbal,CGGBAL)
+#define LAPACK_zggbal LAPACK_GLOBAL(zggbal,ZGGBAL)
+#define LAPACK_sggbak LAPACK_GLOBAL(sggbak,SGGBAK)
+#define LAPACK_dggbak LAPACK_GLOBAL(dggbak,DGGBAK)
+#define LAPACK_cggbak LAPACK_GLOBAL(cggbak,CGGBAK)
+#define LAPACK_zggbak LAPACK_GLOBAL(zggbak,ZGGBAK)
+#define LAPACK_shgeqz LAPACK_GLOBAL(shgeqz,SHGEQZ)
+#define LAPACK_dhgeqz LAPACK_GLOBAL(dhgeqz,DHGEQZ)
+#define LAPACK_chgeqz LAPACK_GLOBAL(chgeqz,CHGEQZ)
+#define LAPACK_zhgeqz LAPACK_GLOBAL(zhgeqz,ZHGEQZ)
+#define LAPACK_stgevc LAPACK_GLOBAL(stgevc,STGEVC)
+#define LAPACK_dtgevc LAPACK_GLOBAL(dtgevc,DTGEVC)
+#define LAPACK_ctgevc LAPACK_GLOBAL(ctgevc,CTGEVC)
+#define LAPACK_ztgevc LAPACK_GLOBAL(ztgevc,ZTGEVC)
+#define LAPACK_stgexc LAPACK_GLOBAL(stgexc,STGEXC)
+#define LAPACK_dtgexc LAPACK_GLOBAL(dtgexc,DTGEXC)
+#define LAPACK_ctgexc LAPACK_GLOBAL(ctgexc,CTGEXC)
+#define LAPACK_ztgexc LAPACK_GLOBAL(ztgexc,ZTGEXC)
+#define LAPACK_stgsen LAPACK_GLOBAL(stgsen,STGSEN)
+#define LAPACK_dtgsen LAPACK_GLOBAL(dtgsen,DTGSEN)
+#define LAPACK_ctgsen LAPACK_GLOBAL(ctgsen,CTGSEN)
+#define LAPACK_ztgsen LAPACK_GLOBAL(ztgsen,ZTGSEN)
+#define LAPACK_stgsyl LAPACK_GLOBAL(stgsyl,STGSYL)
+#define LAPACK_dtgsyl LAPACK_GLOBAL(dtgsyl,DTGSYL)
+#define LAPACK_ctgsyl LAPACK_GLOBAL(ctgsyl,CTGSYL)
+#define LAPACK_ztgsyl LAPACK_GLOBAL(ztgsyl,ZTGSYL)
+#define LAPACK_stgsna LAPACK_GLOBAL(stgsna,STGSNA)
+#define LAPACK_dtgsna LAPACK_GLOBAL(dtgsna,DTGSNA)
+#define LAPACK_ctgsna LAPACK_GLOBAL(ctgsna,CTGSNA)
+#define LAPACK_ztgsna LAPACK_GLOBAL(ztgsna,ZTGSNA)
+#define LAPACK_sggsvp LAPACK_GLOBAL(sggsvp,SGGSVP)
+#define LAPACK_dggsvp LAPACK_GLOBAL(dggsvp,DGGSVP)
+#define LAPACK_cggsvp LAPACK_GLOBAL(cggsvp,CGGSVP)
+#define LAPACK_zggsvp LAPACK_GLOBAL(zggsvp,ZGGSVP)
+#define LAPACK_stgsja LAPACK_GLOBAL(stgsja,STGSJA)
+#define LAPACK_dtgsja LAPACK_GLOBAL(dtgsja,DTGSJA)
+#define LAPACK_ctgsja LAPACK_GLOBAL(ctgsja,CTGSJA)
+#define LAPACK_ztgsja LAPACK_GLOBAL(ztgsja,ZTGSJA)
+#define LAPACK_sgels LAPACK_GLOBAL(sgels,SGELS)
+#define LAPACK_dgels LAPACK_GLOBAL(dgels,DGELS)
+#define LAPACK_cgels LAPACK_GLOBAL(cgels,CGELS)
+#define LAPACK_zgels LAPACK_GLOBAL(zgels,ZGELS)
+#define LAPACK_sgelsy LAPACK_GLOBAL(sgelsy,SGELSY)
+#define LAPACK_dgelsy LAPACK_GLOBAL(dgelsy,DGELSY)
+#define LAPACK_cgelsy LAPACK_GLOBAL(cgelsy,CGELSY)
+#define LAPACK_zgelsy LAPACK_GLOBAL(zgelsy,ZGELSY)
+#define LAPACK_sgelss LAPACK_GLOBAL(sgelss,SGELSS)
+#define LAPACK_dgelss LAPACK_GLOBAL(dgelss,DGELSS)
+#define LAPACK_cgelss LAPACK_GLOBAL(cgelss,CGELSS)
+#define LAPACK_zgelss LAPACK_GLOBAL(zgelss,ZGELSS)
+#define LAPACK_sgelsd LAPACK_GLOBAL(sgelsd,SGELSD)
+#define LAPACK_dgelsd LAPACK_GLOBAL(dgelsd,DGELSD)
+#define LAPACK_cgelsd LAPACK_GLOBAL(cgelsd,CGELSD)
+#define LAPACK_zgelsd LAPACK_GLOBAL(zgelsd,ZGELSD)
+#define LAPACK_sgglse LAPACK_GLOBAL(sgglse,SGGLSE)
+#define LAPACK_dgglse LAPACK_GLOBAL(dgglse,DGGLSE)
+#define LAPACK_cgglse LAPACK_GLOBAL(cgglse,CGGLSE)
+#define LAPACK_zgglse LAPACK_GLOBAL(zgglse,ZGGLSE)
+#define LAPACK_sggglm LAPACK_GLOBAL(sggglm,SGGGLM)
+#define LAPACK_dggglm LAPACK_GLOBAL(dggglm,DGGGLM)
+#define LAPACK_cggglm LAPACK_GLOBAL(cggglm,CGGGLM)
+#define LAPACK_zggglm LAPACK_GLOBAL(zggglm,ZGGGLM)
+#define LAPACK_ssyev LAPACK_GLOBAL(ssyev,SSYEV)
+#define LAPACK_dsyev LAPACK_GLOBAL(dsyev,DSYEV)
+#define LAPACK_cheev LAPACK_GLOBAL(cheev,CHEEV)
+#define LAPACK_zheev LAPACK_GLOBAL(zheev,ZHEEV)
+#define LAPACK_ssyevd LAPACK_GLOBAL(ssyevd,SSYEVD)
+#define LAPACK_dsyevd LAPACK_GLOBAL(dsyevd,DSYEVD)
+#define LAPACK_cheevd LAPACK_GLOBAL(cheevd,CHEEVD)
+#define LAPACK_zheevd LAPACK_GLOBAL(zheevd,ZHEEVD)
+#define LAPACK_ssyevx LAPACK_GLOBAL(ssyevx,SSYEVX)
+#define LAPACK_dsyevx LAPACK_GLOBAL(dsyevx,DSYEVX)
+#define LAPACK_cheevx LAPACK_GLOBAL(cheevx,CHEEVX)
+#define LAPACK_zheevx LAPACK_GLOBAL(zheevx,ZHEEVX)
+#define LAPACK_ssyevr LAPACK_GLOBAL(ssyevr,SSYEVR)
+#define LAPACK_dsyevr LAPACK_GLOBAL(dsyevr,DSYEVR)
+#define LAPACK_cheevr LAPACK_GLOBAL(cheevr,CHEEVR)
+#define LAPACK_zheevr LAPACK_GLOBAL(zheevr,ZHEEVR)
+#define LAPACK_sspev LAPACK_GLOBAL(sspev,SSPEV)
+#define LAPACK_dspev LAPACK_GLOBAL(dspev,DSPEV)
+#define LAPACK_chpev LAPACK_GLOBAL(chpev,CHPEV)
+#define LAPACK_zhpev LAPACK_GLOBAL(zhpev,ZHPEV)
+#define LAPACK_sspevd LAPACK_GLOBAL(sspevd,SSPEVD)
+#define LAPACK_dspevd LAPACK_GLOBAL(dspevd,DSPEVD)
+#define LAPACK_chpevd LAPACK_GLOBAL(chpevd,CHPEVD)
+#define LAPACK_zhpevd LAPACK_GLOBAL(zhpevd,ZHPEVD)
+#define LAPACK_sspevx LAPACK_GLOBAL(sspevx,SSPEVX)
+#define LAPACK_dspevx LAPACK_GLOBAL(dspevx,DSPEVX)
+#define LAPACK_chpevx LAPACK_GLOBAL(chpevx,CHPEVX)
+#define LAPACK_zhpevx LAPACK_GLOBAL(zhpevx,ZHPEVX)
+#define LAPACK_ssbev LAPACK_GLOBAL(ssbev,SSBEV)
+#define LAPACK_dsbev LAPACK_GLOBAL(dsbev,DSBEV)
+#define LAPACK_chbev LAPACK_GLOBAL(chbev,CHBEV)
+#define LAPACK_zhbev LAPACK_GLOBAL(zhbev,ZHBEV)
+#define LAPACK_ssbevd LAPACK_GLOBAL(ssbevd,SSBEVD)
+#define LAPACK_dsbevd LAPACK_GLOBAL(dsbevd,DSBEVD)
+#define LAPACK_chbevd LAPACK_GLOBAL(chbevd,CHBEVD)
+#define LAPACK_zhbevd LAPACK_GLOBAL(zhbevd,ZHBEVD)
+#define LAPACK_ssbevx LAPACK_GLOBAL(ssbevx,SSBEVX)
+#define LAPACK_dsbevx LAPACK_GLOBAL(dsbevx,DSBEVX)
+#define LAPACK_chbevx LAPACK_GLOBAL(chbevx,CHBEVX)
+#define LAPACK_zhbevx LAPACK_GLOBAL(zhbevx,ZHBEVX)
+#define LAPACK_sstev LAPACK_GLOBAL(sstev,SSTEV)
+#define LAPACK_dstev LAPACK_GLOBAL(dstev,DSTEV)
+#define LAPACK_sstevd LAPACK_GLOBAL(sstevd,SSTEVD)
+#define LAPACK_dstevd LAPACK_GLOBAL(dstevd,DSTEVD)
+#define LAPACK_sstevx LAPACK_GLOBAL(sstevx,SSTEVX)
+#define LAPACK_dstevx LAPACK_GLOBAL(dstevx,DSTEVX)
+#define LAPACK_sstevr LAPACK_GLOBAL(sstevr,SSTEVR)
+#define LAPACK_dstevr LAPACK_GLOBAL(dstevr,DSTEVR)
+#define LAPACK_sgees LAPACK_GLOBAL(sgees,SGEES)
+#define LAPACK_dgees LAPACK_GLOBAL(dgees,DGEES)
+#define LAPACK_cgees LAPACK_GLOBAL(cgees,CGEES)
+#define LAPACK_zgees LAPACK_GLOBAL(zgees,ZGEES)
+#define LAPACK_sgeesx LAPACK_GLOBAL(sgeesx,SGEESX)
+#define LAPACK_dgeesx LAPACK_GLOBAL(dgeesx,DGEESX)
+#define LAPACK_cgeesx LAPACK_GLOBAL(cgeesx,CGEESX)
+#define LAPACK_zgeesx LAPACK_GLOBAL(zgeesx,ZGEESX)
+#define LAPACK_sgeev LAPACK_GLOBAL(sgeev,SGEEV)
+#define LAPACK_dgeev LAPACK_GLOBAL(dgeev,DGEEV)
+#define LAPACK_cgeev LAPACK_GLOBAL(cgeev,CGEEV)
+#define LAPACK_zgeev LAPACK_GLOBAL(zgeev,ZGEEV)
+#define LAPACK_sgeevx LAPACK_GLOBAL(sgeevx,SGEEVX)
+#define LAPACK_dgeevx LAPACK_GLOBAL(dgeevx,DGEEVX)
+#define LAPACK_cgeevx LAPACK_GLOBAL(cgeevx,CGEEVX)
+#define LAPACK_zgeevx LAPACK_GLOBAL(zgeevx,ZGEEVX)
+#define LAPACK_sgesvd LAPACK_GLOBAL(sgesvd,SGESVD)
+#define LAPACK_dgesvd LAPACK_GLOBAL(dgesvd,DGESVD)
+#define LAPACK_cgesvd LAPACK_GLOBAL(cgesvd,CGESVD)
+#define LAPACK_zgesvd LAPACK_GLOBAL(zgesvd,ZGESVD)
+#define LAPACK_sgesdd LAPACK_GLOBAL(sgesdd,SGESDD)
+#define LAPACK_dgesdd LAPACK_GLOBAL(dgesdd,DGESDD)
+#define LAPACK_cgesdd LAPACK_GLOBAL(cgesdd,CGESDD)
+#define LAPACK_zgesdd LAPACK_GLOBAL(zgesdd,ZGESDD)
+#define LAPACK_dgejsv LAPACK_GLOBAL(dgejsv,DGEJSV)
+#define LAPACK_sgejsv LAPACK_GLOBAL(sgejsv,SGEJSV)
+#define LAPACK_dgesvj LAPACK_GLOBAL(dgesvj,DGESVJ)
+#define LAPACK_sgesvj LAPACK_GLOBAL(sgesvj,SGESVJ)
+#define LAPACK_sggsvd LAPACK_GLOBAL(sggsvd,SGGSVD)
+#define LAPACK_dggsvd LAPACK_GLOBAL(dggsvd,DGGSVD)
+#define LAPACK_cggsvd LAPACK_GLOBAL(cggsvd,CGGSVD)
+#define LAPACK_zggsvd LAPACK_GLOBAL(zggsvd,ZGGSVD)
+#define LAPACK_ssygv LAPACK_GLOBAL(ssygv,SSYGV)
+#define LAPACK_dsygv LAPACK_GLOBAL(dsygv,DSYGV)
+#define LAPACK_chegv LAPACK_GLOBAL(chegv,CHEGV)
+#define LAPACK_zhegv LAPACK_GLOBAL(zhegv,ZHEGV)
+#define LAPACK_ssygvd LAPACK_GLOBAL(ssygvd,SSYGVD)
+#define LAPACK_dsygvd LAPACK_GLOBAL(dsygvd,DSYGVD)
+#define LAPACK_chegvd LAPACK_GLOBAL(chegvd,CHEGVD)
+#define LAPACK_zhegvd LAPACK_GLOBAL(zhegvd,ZHEGVD)
+#define LAPACK_ssygvx LAPACK_GLOBAL(ssygvx,SSYGVX)
+#define LAPACK_dsygvx LAPACK_GLOBAL(dsygvx,DSYGVX)
+#define LAPACK_chegvx LAPACK_GLOBAL(chegvx,CHEGVX)
+#define LAPACK_zhegvx LAPACK_GLOBAL(zhegvx,ZHEGVX)
+#define LAPACK_sspgv LAPACK_GLOBAL(sspgv,SSPGV)
+#define LAPACK_dspgv LAPACK_GLOBAL(dspgv,DSPGV)
+#define LAPACK_chpgv LAPACK_GLOBAL(chpgv,CHPGV)
+#define LAPACK_zhpgv LAPACK_GLOBAL(zhpgv,ZHPGV)
+#define LAPACK_sspgvd LAPACK_GLOBAL(sspgvd,SSPGVD)
+#define LAPACK_dspgvd LAPACK_GLOBAL(dspgvd,DSPGVD)
+#define LAPACK_chpgvd LAPACK_GLOBAL(chpgvd,CHPGVD)
+#define LAPACK_zhpgvd LAPACK_GLOBAL(zhpgvd,ZHPGVD)
+#define LAPACK_sspgvx LAPACK_GLOBAL(sspgvx,SSPGVX)
+#define LAPACK_dspgvx LAPACK_GLOBAL(dspgvx,DSPGVX)
+#define LAPACK_chpgvx LAPACK_GLOBAL(chpgvx,CHPGVX)
+#define LAPACK_zhpgvx LAPACK_GLOBAL(zhpgvx,ZHPGVX)
+#define LAPACK_ssbgv LAPACK_GLOBAL(ssbgv,SSBGV)
+#define LAPACK_dsbgv LAPACK_GLOBAL(dsbgv,DSBGV)
+#define LAPACK_chbgv LAPACK_GLOBAL(chbgv,CHBGV)
+#define LAPACK_zhbgv LAPACK_GLOBAL(zhbgv,ZHBGV)
+#define LAPACK_ssbgvd LAPACK_GLOBAL(ssbgvd,SSBGVD)
+#define LAPACK_dsbgvd LAPACK_GLOBAL(dsbgvd,DSBGVD)
+#define LAPACK_chbgvd LAPACK_GLOBAL(chbgvd,CHBGVD)
+#define LAPACK_zhbgvd LAPACK_GLOBAL(zhbgvd,ZHBGVD)
+#define LAPACK_ssbgvx LAPACK_GLOBAL(ssbgvx,SSBGVX)
+#define LAPACK_dsbgvx LAPACK_GLOBAL(dsbgvx,DSBGVX)
+#define LAPACK_chbgvx LAPACK_GLOBAL(chbgvx,CHBGVX)
+#define LAPACK_zhbgvx LAPACK_GLOBAL(zhbgvx,ZHBGVX)
+#define LAPACK_sgges LAPACK_GLOBAL(sgges,SGGES)
+#define LAPACK_dgges LAPACK_GLOBAL(dgges,DGGES)
+#define LAPACK_cgges LAPACK_GLOBAL(cgges,CGGES)
+#define LAPACK_zgges LAPACK_GLOBAL(zgges,ZGGES)
+#define LAPACK_sggesx LAPACK_GLOBAL(sggesx,SGGESX)
+#define LAPACK_dggesx LAPACK_GLOBAL(dggesx,DGGESX)
+#define LAPACK_cggesx LAPACK_GLOBAL(cggesx,CGGESX)
+#define LAPACK_zggesx LAPACK_GLOBAL(zggesx,ZGGESX)
+#define LAPACK_sggev LAPACK_GLOBAL(sggev,SGGEV)
+#define LAPACK_dggev LAPACK_GLOBAL(dggev,DGGEV)
+#define LAPACK_cggev LAPACK_GLOBAL(cggev,CGGEV)
+#define LAPACK_zggev LAPACK_GLOBAL(zggev,ZGGEV)
+#define LAPACK_sggevx LAPACK_GLOBAL(sggevx,SGGEVX)
+#define LAPACK_dggevx LAPACK_GLOBAL(dggevx,DGGEVX)
+#define LAPACK_cggevx LAPACK_GLOBAL(cggevx,CGGEVX)
+#define LAPACK_zggevx LAPACK_GLOBAL(zggevx,ZGGEVX)
+#define LAPACK_dsfrk LAPACK_GLOBAL(dsfrk,DSFRK)
+#define LAPACK_ssfrk LAPACK_GLOBAL(ssfrk,SSFRK)
+#define LAPACK_zhfrk LAPACK_GLOBAL(zhfrk,ZHFRK)
+#define LAPACK_chfrk LAPACK_GLOBAL(chfrk,CHFRK)
+#define LAPACK_dtfsm LAPACK_GLOBAL(dtfsm,DTFSM)
+#define LAPACK_stfsm LAPACK_GLOBAL(stfsm,STFSM)
+#define LAPACK_ztfsm LAPACK_GLOBAL(ztfsm,ZTFSM)
+#define LAPACK_ctfsm LAPACK_GLOBAL(ctfsm,CTFSM)
+#define LAPACK_dtfttp LAPACK_GLOBAL(dtfttp,DTFTTP)
+#define LAPACK_stfttp LAPACK_GLOBAL(stfttp,STFTTP)
+#define LAPACK_ztfttp LAPACK_GLOBAL(ztfttp,ZTFTTP)
+#define LAPACK_ctfttp LAPACK_GLOBAL(ctfttp,CTFTTP)
+#define LAPACK_dtfttr LAPACK_GLOBAL(dtfttr,DTFTTR)
+#define LAPACK_stfttr LAPACK_GLOBAL(stfttr,STFTTR)
+#define LAPACK_ztfttr LAPACK_GLOBAL(ztfttr,ZTFTTR)
+#define LAPACK_ctfttr LAPACK_GLOBAL(ctfttr,CTFTTR)
+#define LAPACK_dtpttf LAPACK_GLOBAL(dtpttf,DTPTTF)
+#define LAPACK_stpttf LAPACK_GLOBAL(stpttf,STPTTF)
+#define LAPACK_ztpttf LAPACK_GLOBAL(ztpttf,ZTPTTF)
+#define LAPACK_ctpttf LAPACK_GLOBAL(ctpttf,CTPTTF)
+#define LAPACK_dtpttr LAPACK_GLOBAL(dtpttr,DTPTTR)
+#define LAPACK_stpttr LAPACK_GLOBAL(stpttr,STPTTR)
+#define LAPACK_ztpttr LAPACK_GLOBAL(ztpttr,ZTPTTR)
+#define LAPACK_ctpttr LAPACK_GLOBAL(ctpttr,CTPTTR)
+#define LAPACK_dtrttf LAPACK_GLOBAL(dtrttf,DTRTTF)
+#define LAPACK_strttf LAPACK_GLOBAL(strttf,STRTTF)
+#define LAPACK_ztrttf LAPACK_GLOBAL(ztrttf,ZTRTTF)
+#define LAPACK_ctrttf LAPACK_GLOBAL(ctrttf,CTRTTF)
+#define LAPACK_dtrttp LAPACK_GLOBAL(dtrttp,DTRTTP)
+#define LAPACK_strttp LAPACK_GLOBAL(strttp,STRTTP)
+#define LAPACK_ztrttp LAPACK_GLOBAL(ztrttp,ZTRTTP)
+#define LAPACK_ctrttp LAPACK_GLOBAL(ctrttp,CTRTTP)
+#define LAPACK_sgeqrfp LAPACK_GLOBAL(sgeqrfp,SGEQRFP)
+#define LAPACK_dgeqrfp LAPACK_GLOBAL(dgeqrfp,DGEQRFP)
+#define LAPACK_cgeqrfp LAPACK_GLOBAL(cgeqrfp,CGEQRFP)
+#define LAPACK_zgeqrfp LAPACK_GLOBAL(zgeqrfp,ZGEQRFP)
+#define LAPACK_clacgv LAPACK_GLOBAL(clacgv,CLACGV)
+#define LAPACK_zlacgv LAPACK_GLOBAL(zlacgv,ZLACGV)
+#define LAPACK_slarnv LAPACK_GLOBAL(slarnv,SLARNV)
+#define LAPACK_dlarnv LAPACK_GLOBAL(dlarnv,DLARNV)
+#define LAPACK_clarnv LAPACK_GLOBAL(clarnv,CLARNV)
+#define LAPACK_zlarnv LAPACK_GLOBAL(zlarnv,ZLARNV)
+#define LAPACK_sgeqr2 LAPACK_GLOBAL(sgeqr2,SGEQR2)
+#define LAPACK_dgeqr2 LAPACK_GLOBAL(dgeqr2,DGEQR2)
+#define LAPACK_cgeqr2 LAPACK_GLOBAL(cgeqr2,CGEQR2)
+#define LAPACK_zgeqr2 LAPACK_GLOBAL(zgeqr2,ZGEQR2)
+#define LAPACK_slacpy LAPACK_GLOBAL(slacpy,SLACPY)
+#define LAPACK_dlacpy LAPACK_GLOBAL(dlacpy,DLACPY)
+#define LAPACK_clacpy LAPACK_GLOBAL(clacpy,CLACPY)
+#define LAPACK_zlacpy LAPACK_GLOBAL(zlacpy,ZLACPY)
+#define LAPACK_sgetf2 LAPACK_GLOBAL(sgetf2,SGETF2)
+#define LAPACK_dgetf2 LAPACK_GLOBAL(dgetf2,DGETF2)
+#define LAPACK_cgetf2 LAPACK_GLOBAL(cgetf2,CGETF2)
+#define LAPACK_zgetf2 LAPACK_GLOBAL(zgetf2,ZGETF2)
+#define LAPACK_slaswp LAPACK_GLOBAL(slaswp,SLASWP)
+#define LAPACK_dlaswp LAPACK_GLOBAL(dlaswp,DLASWP)
+#define LAPACK_claswp LAPACK_GLOBAL(claswp,CLASWP)
+#define LAPACK_zlaswp LAPACK_GLOBAL(zlaswp,ZLASWP)
+#define LAPACK_slange LAPACK_GLOBAL(slange,SLANGE)
+#define LAPACK_dlange LAPACK_GLOBAL(dlange,DLANGE)
+#define LAPACK_clange LAPACK_GLOBAL(clange,CLANGE)
+#define LAPACK_zlange LAPACK_GLOBAL(zlange,ZLANGE)
+#define LAPACK_clanhe LAPACK_GLOBAL(clanhe,CLANHE)
+#define LAPACK_zlanhe LAPACK_GLOBAL(zlanhe,ZLANHE)
+#define LAPACK_slansy LAPACK_GLOBAL(slansy,SLANSY)
+#define LAPACK_dlansy LAPACK_GLOBAL(dlansy,DLANSY)
+#define LAPACK_clansy LAPACK_GLOBAL(clansy,CLANSY)
+#define LAPACK_zlansy LAPACK_GLOBAL(zlansy,ZLANSY)
+#define LAPACK_slantr LAPACK_GLOBAL(slantr,SLANTR)
+#define LAPACK_dlantr LAPACK_GLOBAL(dlantr,DLANTR)
+#define LAPACK_clantr LAPACK_GLOBAL(clantr,CLANTR)
+#define LAPACK_zlantr LAPACK_GLOBAL(zlantr,ZLANTR)
+#define LAPACK_slamch LAPACK_GLOBAL(slamch,SLAMCH)
+#define LAPACK_dlamch LAPACK_GLOBAL(dlamch,DLAMCH)
+#define LAPACK_sgelq2 LAPACK_GLOBAL(sgelq2,SGELQ2)
+#define LAPACK_dgelq2 LAPACK_GLOBAL(dgelq2,DGELQ2)
+#define LAPACK_cgelq2 LAPACK_GLOBAL(cgelq2,CGELQ2)
+#define LAPACK_zgelq2 LAPACK_GLOBAL(zgelq2,ZGELQ2)
+#define LAPACK_slarfb LAPACK_GLOBAL(slarfb,SLARFB)
+#define LAPACK_dlarfb LAPACK_GLOBAL(dlarfb,DLARFB)
+#define LAPACK_clarfb LAPACK_GLOBAL(clarfb,CLARFB)
+#define LAPACK_zlarfb LAPACK_GLOBAL(zlarfb,ZLARFB)
+#define LAPACK_slarfg LAPACK_GLOBAL(slarfg,SLARFG)
+#define LAPACK_dlarfg LAPACK_GLOBAL(dlarfg,DLARFG)
+#define LAPACK_clarfg LAPACK_GLOBAL(clarfg,CLARFG)
+#define LAPACK_zlarfg LAPACK_GLOBAL(zlarfg,ZLARFG)
+#define LAPACK_slarft LAPACK_GLOBAL(slarft,SLARFT)
+#define LAPACK_dlarft LAPACK_GLOBAL(dlarft,DLARFT)
+#define LAPACK_clarft LAPACK_GLOBAL(clarft,CLARFT)
+#define LAPACK_zlarft LAPACK_GLOBAL(zlarft,ZLARFT)
+#define LAPACK_slarfx LAPACK_GLOBAL(slarfx,SLARFX)
+#define LAPACK_dlarfx LAPACK_GLOBAL(dlarfx,DLARFX)
+#define LAPACK_clarfx LAPACK_GLOBAL(clarfx,CLARFX)
+#define LAPACK_zlarfx LAPACK_GLOBAL(zlarfx,ZLARFX)
+#define LAPACK_slatms LAPACK_GLOBAL(slatms,SLATMS)
+#define LAPACK_dlatms LAPACK_GLOBAL(dlatms,DLATMS)
+#define LAPACK_clatms LAPACK_GLOBAL(clatms,CLATMS)
+#define LAPACK_zlatms LAPACK_GLOBAL(zlatms,ZLATMS)
+#define LAPACK_slag2d LAPACK_GLOBAL(slag2d,SLAG2D)
+#define LAPACK_dlag2s LAPACK_GLOBAL(dlag2s,DLAG2S)
+#define LAPACK_clag2z LAPACK_GLOBAL(clag2z,CLAG2Z)
+#define LAPACK_zlag2c LAPACK_GLOBAL(zlag2c,ZLAG2C)
+#define LAPACK_slauum LAPACK_GLOBAL(slauum,SLAUUM)
+#define LAPACK_dlauum LAPACK_GLOBAL(dlauum,DLAUUM)
+#define LAPACK_clauum LAPACK_GLOBAL(clauum,CLAUUM)
+#define LAPACK_zlauum LAPACK_GLOBAL(zlauum,ZLAUUM)
+#define LAPACK_slagge LAPACK_GLOBAL(slagge,SLAGGE)
+#define LAPACK_dlagge LAPACK_GLOBAL(dlagge,DLAGGE)
+#define LAPACK_clagge LAPACK_GLOBAL(clagge,CLAGGE)
+#define LAPACK_zlagge LAPACK_GLOBAL(zlagge,ZLAGGE)
+#define LAPACK_slaset LAPACK_GLOBAL(slaset,SLASET)
+#define LAPACK_dlaset LAPACK_GLOBAL(dlaset,DLASET)
+#define LAPACK_claset LAPACK_GLOBAL(claset,CLASET)
+#define LAPACK_zlaset LAPACK_GLOBAL(zlaset,ZLASET)
+#define LAPACK_slasrt LAPACK_GLOBAL(slasrt,SLASRT)
+#define LAPACK_dlasrt LAPACK_GLOBAL(dlasrt,DLASRT)
+#define LAPACK_slagsy LAPACK_GLOBAL(slagsy,SLAGSY)
+#define LAPACK_dlagsy LAPACK_GLOBAL(dlagsy,DLAGSY)
+#define LAPACK_clagsy LAPACK_GLOBAL(clagsy,CLAGSY)
+#define LAPACK_zlagsy LAPACK_GLOBAL(zlagsy,ZLAGSY)
+#define LAPACK_claghe LAPACK_GLOBAL(claghe,CLAGHE)
+#define LAPACK_zlaghe LAPACK_GLOBAL(zlaghe,ZLAGHE)
+#define LAPACK_slapmr LAPACK_GLOBAL(slapmr,SLAPMR)
+#define LAPACK_dlapmr LAPACK_GLOBAL(dlapmr,DLAPMR)
+#define LAPACK_clapmr LAPACK_GLOBAL(clapmr,CLAPMR)
+#define LAPACK_zlapmr LAPACK_GLOBAL(zlapmr,ZLAPMR)
+#define LAPACK_slapy2 LAPACK_GLOBAL(slapy2,SLAPY2)
+#define LAPACK_dlapy2 LAPACK_GLOBAL(dlapy2,DLAPY2)
+#define LAPACK_slapy3 LAPACK_GLOBAL(slapy3,SLAPY3)
+#define LAPACK_dlapy3 LAPACK_GLOBAL(dlapy3,DLAPY3)
+#define LAPACK_slartgp LAPACK_GLOBAL(slartgp,SLARTGP)
+#define LAPACK_dlartgp LAPACK_GLOBAL(dlartgp,DLARTGP)
+#define LAPACK_slartgs LAPACK_GLOBAL(slartgs,SLARTGS)
+#define LAPACK_dlartgs LAPACK_GLOBAL(dlartgs,DLARTGS)
+// LAPACK 3.3.0
+#define LAPACK_cbbcsd LAPACK_GLOBAL(cbbcsd,CBBCSD)
+#define LAPACK_cheswapr LAPACK_GLOBAL(cheswapr,CHESWAPR)
+#define LAPACK_chetri2 LAPACK_GLOBAL(chetri2,CHETRI2)
+#define LAPACK_chetri2x LAPACK_GLOBAL(chetri2x,CHETRI2X)
+#define LAPACK_chetrs2 LAPACK_GLOBAL(chetrs2,CHETRS2)
+#define LAPACK_csyconv LAPACK_GLOBAL(csyconv,CSYCONV)
+#define LAPACK_csyswapr LAPACK_GLOBAL(csyswapr,CSYSWAPR)
+#define LAPACK_csytri2 LAPACK_GLOBAL(csytri2,CSYTRI2)
+#define LAPACK_csytri2x LAPACK_GLOBAL(csytri2x,CSYTRI2X)
+#define LAPACK_csytrs2 LAPACK_GLOBAL(csytrs2,CSYTRS2)
+#define LAPACK_cunbdb LAPACK_GLOBAL(cunbdb,CUNBDB)
+#define LAPACK_cuncsd LAPACK_GLOBAL(cuncsd,CUNCSD)
+#define LAPACK_dbbcsd LAPACK_GLOBAL(dbbcsd,DBBCSD)
+#define LAPACK_dorbdb LAPACK_GLOBAL(dorbdb,DORBDB)
+#define LAPACK_dorcsd LAPACK_GLOBAL(dorcsd,DORCSD)
+#define LAPACK_dsyconv LAPACK_GLOBAL(dsyconv,DSYCONV)
+#define LAPACK_dsyswapr LAPACK_GLOBAL(dsyswapr,DSYSWAPR)
+#define LAPACK_dsytri2 LAPACK_GLOBAL(dsytri2,DSYTRI2)
+#define LAPACK_dsytri2x LAPACK_GLOBAL(dsytri2x,DSYTRI2X)
+#define LAPACK_dsytrs2 LAPACK_GLOBAL(dsytrs2,DSYTRS2)
+#define LAPACK_sbbcsd LAPACK_GLOBAL(sbbcsd,SBBCSD)
+#define LAPACK_sorbdb LAPACK_GLOBAL(sorbdb,SORBDB)
+#define LAPACK_sorcsd LAPACK_GLOBAL(sorcsd,SORCSD)
+#define LAPACK_ssyconv LAPACK_GLOBAL(ssyconv,SSYCONV)
+#define LAPACK_ssyswapr LAPACK_GLOBAL(ssyswapr,SSYSWAPR)
+#define LAPACK_ssytri2 LAPACK_GLOBAL(ssytri2,SSYTRI2)
+#define LAPACK_ssytri2x LAPACK_GLOBAL(ssytri2x,SSYTRI2X)
+#define LAPACK_ssytrs2 LAPACK_GLOBAL(ssytrs2,SSYTRS2)
+#define LAPACK_zbbcsd LAPACK_GLOBAL(zbbcsd,ZBBCSD)
+#define LAPACK_zheswapr LAPACK_GLOBAL(zheswapr,ZHESWAPR)
+#define LAPACK_zhetri2 LAPACK_GLOBAL(zhetri2,ZHETRI2)
+#define LAPACK_zhetri2x LAPACK_GLOBAL(zhetri2x,ZHETRI2X)
+#define LAPACK_zhetrs2 LAPACK_GLOBAL(zhetrs2,ZHETRS2)
+#define LAPACK_zsyconv LAPACK_GLOBAL(zsyconv,ZSYCONV)
+#define LAPACK_zsyswapr LAPACK_GLOBAL(zsyswapr,ZSYSWAPR)
+#define LAPACK_zsytri2 LAPACK_GLOBAL(zsytri2,ZSYTRI2)
+#define LAPACK_zsytri2x LAPACK_GLOBAL(zsytri2x,ZSYTRI2X)
+#define LAPACK_zsytrs2 LAPACK_GLOBAL(zsytrs2,ZSYTRS2)
+#define LAPACK_zunbdb LAPACK_GLOBAL(zunbdb,ZUNBDB)
+#define LAPACK_zuncsd LAPACK_GLOBAL(zuncsd,ZUNCSD)
+// LAPACK 3.4.0
+#define LAPACK_sgemqrt LAPACK_GLOBAL(sgemqrt,SGEMQRT)
+#define LAPACK_dgemqrt LAPACK_GLOBAL(dgemqrt,DGEMQRT)
+#define LAPACK_cgemqrt LAPACK_GLOBAL(cgemqrt,CGEMQRT)
+#define LAPACK_zgemqrt LAPACK_GLOBAL(zgemqrt,ZGEMQRT)
+#define LAPACK_sgeqrt LAPACK_GLOBAL(sgeqrt,SGEQRT)
+#define LAPACK_dgeqrt LAPACK_GLOBAL(dgeqrt,DGEQRT)
+#define LAPACK_cgeqrt LAPACK_GLOBAL(cgeqrt,CGEQRT)
+#define LAPACK_zgeqrt LAPACK_GLOBAL(zgeqrt,ZGEQRT)
+#define LAPACK_sgeqrt2 LAPACK_GLOBAL(sgeqrt2,SGEQRT2)
+#define LAPACK_dgeqrt2 LAPACK_GLOBAL(dgeqrt2,DGEQRT2)
+#define LAPACK_cgeqrt2 LAPACK_GLOBAL(cgeqrt2,CGEQRT2)
+#define LAPACK_zgeqrt2 LAPACK_GLOBAL(zgeqrt2,ZGEQRT2)
+#define LAPACK_sgeqrt3 LAPACK_GLOBAL(sgeqrt3,SGEQRT3)
+#define LAPACK_dgeqrt3 LAPACK_GLOBAL(dgeqrt3,DGEQRT3)
+#define LAPACK_cgeqrt3 LAPACK_GLOBAL(cgeqrt3,CGEQRT3)
+#define LAPACK_zgeqrt3 LAPACK_GLOBAL(zgeqrt3,ZGEQRT3)
+#define LAPACK_stpmqrt LAPACK_GLOBAL(stpmqrt,STPMQRT)
+#define LAPACK_dtpmqrt LAPACK_GLOBAL(dtpmqrt,DTPMQRT)
+#define LAPACK_ctpmqrt LAPACK_GLOBAL(ctpmqrt,CTPMQRT)
+#define LAPACK_ztpmqrt LAPACK_GLOBAL(ztpmqrt,ZTPMQRT)
+#define LAPACK_dtpqrt LAPACK_GLOBAL(dtpqrt,DTPQRT)
+#define LAPACK_ctpqrt LAPACK_GLOBAL(ctpqrt,CTPQRT)
+#define LAPACK_ztpqrt LAPACK_GLOBAL(ztpqrt,ZTPQRT)
+#define LAPACK_stpqrt2 LAPACK_GLOBAL(stpqrt2,STPQRT2)
+#define LAPACK_dtpqrt2 LAPACK_GLOBAL(dtpqrt2,DTPQRT2)
+#define LAPACK_ctpqrt2 LAPACK_GLOBAL(ctpqrt2,CTPQRT2)
+#define LAPACK_ztpqrt2 LAPACK_GLOBAL(ztpqrt2,ZTPQRT2)
+#define LAPACK_stprfb LAPACK_GLOBAL(stprfb,STPRFB)
+#define LAPACK_dtprfb LAPACK_GLOBAL(dtprfb,DTPRFB)
+#define LAPACK_ctprfb LAPACK_GLOBAL(ctprfb,CTPRFB)
+#define LAPACK_ztprfb LAPACK_GLOBAL(ztprfb,ZTPRFB)
+// LAPACK 3.X.X
+#define LAPACK_csyr LAPACK_GLOBAL(csyr,CSYR)
+#define LAPACK_zsyr LAPACK_GLOBAL(zsyr,ZSYR)
+
+
+void LAPACK_sgetrf( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_dgetrf( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_cgetrf( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int* ipiv, lapack_int *info );
+void LAPACK_zgetrf( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* ipiv, lapack_int *info );
+void LAPACK_sgbtrf( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, float* ab, lapack_int* ldab,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_dgbtrf( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, double* ab, lapack_int* ldab,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_cgbtrf( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, lapack_complex_float* ab, lapack_int* ldab,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_zgbtrf( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, lapack_complex_double* ab, lapack_int* ldab,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_sgttrf( lapack_int* n, float* dl, float* d, float* du, float* du2,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_dgttrf( lapack_int* n, double* dl, double* d, double* du,
+                    double* du2, lapack_int* ipiv, lapack_int *info );
+void LAPACK_cgttrf( lapack_int* n, lapack_complex_float* dl,
+                    lapack_complex_float* d, lapack_complex_float* du,
+                    lapack_complex_float* du2, lapack_int* ipiv,
+                    lapack_int *info );
+void LAPACK_zgttrf( lapack_int* n, lapack_complex_double* dl,
+                    lapack_complex_double* d, lapack_complex_double* du,
+                    lapack_complex_double* du2, lapack_int* ipiv,
+                    lapack_int *info );
+void LAPACK_spotrf( char* uplo, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_dpotrf( char* uplo, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_cpotrf( char* uplo, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_zpotrf( char* uplo, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_dpstrf( char* uplo, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int* piv, lapack_int* rank, double* tol,
+                    double* work, lapack_int *info );
+void LAPACK_spstrf( char* uplo, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int* piv, lapack_int* rank, float* tol, float* work,
+                    lapack_int *info );
+void LAPACK_zpstrf( char* uplo, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* piv, lapack_int* rank,
+                    double* tol, double* work, lapack_int *info );
+void LAPACK_cpstrf( char* uplo, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int* piv, lapack_int* rank,
+                    float* tol, float* work, lapack_int *info );
+void LAPACK_dpftrf( char* transr, char* uplo, lapack_int* n, double* a,
+                    lapack_int *info );
+void LAPACK_spftrf( char* transr, char* uplo, lapack_int* n, float* a,
+                    lapack_int *info );
+void LAPACK_zpftrf( char* transr, char* uplo, lapack_int* n,
+                    lapack_complex_double* a, lapack_int *info );
+void LAPACK_cpftrf( char* transr, char* uplo, lapack_int* n,
+                    lapack_complex_float* a, lapack_int *info );
+void LAPACK_spptrf( char* uplo, lapack_int* n, float* ap, lapack_int *info );
+void LAPACK_dpptrf( char* uplo, lapack_int* n, double* ap, lapack_int *info );
+void LAPACK_cpptrf( char* uplo, lapack_int* n, lapack_complex_float* ap,
+                    lapack_int *info );
+void LAPACK_zpptrf( char* uplo, lapack_int* n, lapack_complex_double* ap,
+                    lapack_int *info );
+void LAPACK_spbtrf( char* uplo, lapack_int* n, lapack_int* kd, float* ab,
+                    lapack_int* ldab, lapack_int *info );
+void LAPACK_dpbtrf( char* uplo, lapack_int* n, lapack_int* kd, double* ab,
+                    lapack_int* ldab, lapack_int *info );
+void LAPACK_cpbtrf( char* uplo, lapack_int* n, lapack_int* kd,
+                    lapack_complex_float* ab, lapack_int* ldab,
+                    lapack_int *info );
+void LAPACK_zpbtrf( char* uplo, lapack_int* n, lapack_int* kd,
+                    lapack_complex_double* ab, lapack_int* ldab,
+                    lapack_int *info );
+void LAPACK_spttrf( lapack_int* n, float* d, float* e, lapack_int *info );
+void LAPACK_dpttrf( lapack_int* n, double* d, double* e, lapack_int *info );
+void LAPACK_cpttrf( lapack_int* n, float* d, lapack_complex_float* e,
+                    lapack_int *info );
+void LAPACK_zpttrf( lapack_int* n, double* d, lapack_complex_double* e,
+                    lapack_int *info );
+void LAPACK_ssytrf( char* uplo, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int* ipiv, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dsytrf( char* uplo, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int* ipiv, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_csytrf( char* uplo, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int* ipiv,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zsytrf( char* uplo, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* ipiv,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_chetrf( char* uplo, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int* ipiv,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zhetrf( char* uplo, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* ipiv,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_ssptrf( char* uplo, lapack_int* n, float* ap, lapack_int* ipiv,
+                    lapack_int *info );
+void LAPACK_dsptrf( char* uplo, lapack_int* n, double* ap, lapack_int* ipiv,
+                    lapack_int *info );
+void LAPACK_csptrf( char* uplo, lapack_int* n, lapack_complex_float* ap,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_zsptrf( char* uplo, lapack_int* n, lapack_complex_double* ap,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_chptrf( char* uplo, lapack_int* n, lapack_complex_float* ap,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_zhptrf( char* uplo, lapack_int* n, lapack_complex_double* ap,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_sgetrs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const float* a, lapack_int* lda, const lapack_int* ipiv,
+                    float* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_dgetrs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const double* a, lapack_int* lda, const lapack_int* ipiv,
+                    double* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_cgetrs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    const lapack_int* ipiv, lapack_complex_float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_zgetrs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_int* ipiv, lapack_complex_double* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_sgbtrs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    lapack_int* nrhs, const float* ab, lapack_int* ldab,
+                    const lapack_int* ipiv, float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_dgbtrs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    lapack_int* nrhs, const double* ab, lapack_int* ldab,
+                    const lapack_int* ipiv, double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_cgbtrs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    lapack_int* nrhs, const lapack_complex_float* ab,
+                    lapack_int* ldab, const lapack_int* ipiv,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_zgbtrs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    lapack_int* nrhs, const lapack_complex_double* ab,
+                    lapack_int* ldab, const lapack_int* ipiv,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_sgttrs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const float* dl, const float* d, const float* du,
+                    const float* du2, const lapack_int* ipiv, float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_dgttrs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const double* dl, const double* d, const double* du,
+                    const double* du2, const lapack_int* ipiv, double* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_cgttrs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* dl,
+                    const lapack_complex_float* d,
+                    const lapack_complex_float* du,
+                    const lapack_complex_float* du2, const lapack_int* ipiv,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_zgttrs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* dl,
+                    const lapack_complex_double* d,
+                    const lapack_complex_double* du,
+                    const lapack_complex_double* du2, const lapack_int* ipiv,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_spotrs( char* uplo, lapack_int* n, lapack_int* nrhs, const float* a,
+                    lapack_int* lda, float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_dpotrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* a, lapack_int* lda, double* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_cpotrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_zpotrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_dpftrs( char* transr, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* a, double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_spftrs( char* transr, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const float* a, float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_zpftrs( char* transr, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_complex_double* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_cpftrs( char* transr, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_complex_float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_spptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const float* ap, float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_dpptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* ap, double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_cpptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* ap, lapack_complex_float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_zpptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* ap, lapack_complex_double* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_spbtrs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                    const float* ab, lapack_int* ldab, float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_dpbtrs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                    const double* ab, lapack_int* ldab, double* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_cpbtrs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                    const lapack_complex_float* ab, lapack_int* ldab,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_zpbtrs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                    const lapack_complex_double* ab, lapack_int* ldab,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_spttrs( lapack_int* n, lapack_int* nrhs, const float* d,
+                    const float* e, float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_dpttrs( lapack_int* n, lapack_int* nrhs, const double* d,
+                    const double* e, double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_cpttrs( char* uplo, lapack_int* n, lapack_int* nrhs, const float* d,
+                    const lapack_complex_float* e, lapack_complex_float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_zpttrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* d, const lapack_complex_double* e,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_ssytrs( char* uplo, lapack_int* n, lapack_int* nrhs, const float* a,
+                    lapack_int* lda, const lapack_int* ipiv, float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_dsytrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* a, lapack_int* lda, const lapack_int* ipiv,
+                    double* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_csytrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    const lapack_int* ipiv, lapack_complex_float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_zsytrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_int* ipiv, lapack_complex_double* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_chetrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    const lapack_int* ipiv, lapack_complex_float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_zhetrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_int* ipiv, lapack_complex_double* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_ssptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const float* ap, const lapack_int* ipiv, float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_dsptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* ap, const lapack_int* ipiv, double* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_csptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* ap, const lapack_int* ipiv,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_zsptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* ap, const lapack_int* ipiv,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_chptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* ap, const lapack_int* ipiv,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_zhptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* ap, const lapack_int* ipiv,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_strtrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const float* a, lapack_int* lda, float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_dtrtrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const double* a, lapack_int* lda,
+                    double* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_ctrtrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_ztrtrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_stptrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const float* ap, float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_dtptrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const double* ap, double* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_ctptrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const lapack_complex_float* ap,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_ztptrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const lapack_complex_double* ap,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_stbtrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* kd, lapack_int* nrhs, const float* ab,
+                    lapack_int* ldab, float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_dtbtrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* kd, lapack_int* nrhs, const double* ab,
+                    lapack_int* ldab, double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_ctbtrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* kd, lapack_int* nrhs,
+                    const lapack_complex_float* ab, lapack_int* ldab,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_ztbtrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* kd, lapack_int* nrhs,
+                    const lapack_complex_double* ab, lapack_int* ldab,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_sgecon( char* norm, lapack_int* n, const float* a, lapack_int* lda,
+                    float* anorm, float* rcond, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dgecon( char* norm, lapack_int* n, const double* a, lapack_int* lda,
+                    double* anorm, double* rcond, double* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_cgecon( char* norm, lapack_int* n, const lapack_complex_float* a,
+                    lapack_int* lda, float* anorm, float* rcond,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zgecon( char* norm, lapack_int* n, const lapack_complex_double* a,
+                    lapack_int* lda, double* anorm, double* rcond,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_sgbcon( char* norm, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    const float* ab, lapack_int* ldab, const lapack_int* ipiv,
+                    float* anorm, float* rcond, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dgbcon( char* norm, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    const double* ab, lapack_int* ldab, const lapack_int* ipiv,
+                    double* anorm, double* rcond, double* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_cgbcon( char* norm, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    const lapack_complex_float* ab, lapack_int* ldab,
+                    const lapack_int* ipiv, float* anorm, float* rcond,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zgbcon( char* norm, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    const lapack_complex_double* ab, lapack_int* ldab,
+                    const lapack_int* ipiv, double* anorm, double* rcond,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_sgtcon( char* norm, lapack_int* n, const float* dl, const float* d,
+                    const float* du, const float* du2, const lapack_int* ipiv,
+                    float* anorm, float* rcond, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dgtcon( char* norm, lapack_int* n, const double* dl,
+                    const double* d, const double* du, const double* du2,
+                    const lapack_int* ipiv, double* anorm, double* rcond,
+                    double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_cgtcon( char* norm, lapack_int* n, const lapack_complex_float* dl,
+                    const lapack_complex_float* d,
+                    const lapack_complex_float* du,
+                    const lapack_complex_float* du2, const lapack_int* ipiv,
+                    float* anorm, float* rcond, lapack_complex_float* work,
+                    lapack_int *info );
+void LAPACK_zgtcon( char* norm, lapack_int* n, const lapack_complex_double* dl,
+                    const lapack_complex_double* d,
+                    const lapack_complex_double* du,
+                    const lapack_complex_double* du2, const lapack_int* ipiv,
+                    double* anorm, double* rcond, lapack_complex_double* work,
+                    lapack_int *info );
+void LAPACK_spocon( char* uplo, lapack_int* n, const float* a, lapack_int* lda,
+                    float* anorm, float* rcond, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dpocon( char* uplo, lapack_int* n, const double* a, lapack_int* lda,
+                    double* anorm, double* rcond, double* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_cpocon( char* uplo, lapack_int* n, const lapack_complex_float* a,
+                    lapack_int* lda, float* anorm, float* rcond,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zpocon( char* uplo, lapack_int* n, const lapack_complex_double* a,
+                    lapack_int* lda, double* anorm, double* rcond,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_sppcon( char* uplo, lapack_int* n, const float* ap, float* anorm,
+                    float* rcond, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dppcon( char* uplo, lapack_int* n, const double* ap, double* anorm,
+                    double* rcond, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_cppcon( char* uplo, lapack_int* n, const lapack_complex_float* ap,
+                    float* anorm, float* rcond, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zppcon( char* uplo, lapack_int* n, const lapack_complex_double* ap,
+                    double* anorm, double* rcond, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_spbcon( char* uplo, lapack_int* n, lapack_int* kd, const float* ab,
+                    lapack_int* ldab, float* anorm, float* rcond, float* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_dpbcon( char* uplo, lapack_int* n, lapack_int* kd, const double* ab,
+                    lapack_int* ldab, double* anorm, double* rcond,
+                    double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_cpbcon( char* uplo, lapack_int* n, lapack_int* kd,
+                    const lapack_complex_float* ab, lapack_int* ldab,
+                    float* anorm, float* rcond, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zpbcon( char* uplo, lapack_int* n, lapack_int* kd,
+                    const lapack_complex_double* ab, lapack_int* ldab,
+                    double* anorm, double* rcond, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_sptcon( lapack_int* n, const float* d, const float* e, float* anorm,
+                    float* rcond, float* work, lapack_int *info );
+void LAPACK_dptcon( lapack_int* n, const double* d, const double* e,
+                    double* anorm, double* rcond, double* work,
+                    lapack_int *info );
+void LAPACK_cptcon( lapack_int* n, const float* d,
+                    const lapack_complex_float* e, float* anorm, float* rcond,
+                    float* work, lapack_int *info );
+void LAPACK_zptcon( lapack_int* n, const double* d,
+                    const lapack_complex_double* e, double* anorm,
+                    double* rcond, double* work, lapack_int *info );
+void LAPACK_ssycon( char* uplo, lapack_int* n, const float* a, lapack_int* lda,
+                    const lapack_int* ipiv, float* anorm, float* rcond,
+                    float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_dsycon( char* uplo, lapack_int* n, const double* a, lapack_int* lda,
+                    const lapack_int* ipiv, double* anorm, double* rcond,
+                    double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_csycon( char* uplo, lapack_int* n, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_int* ipiv, float* anorm,
+                    float* rcond, lapack_complex_float* work,
+                    lapack_int *info );
+void LAPACK_zsycon( char* uplo, lapack_int* n, const lapack_complex_double* a,
+                    lapack_int* lda, const lapack_int* ipiv, double* anorm,
+                    double* rcond, lapack_complex_double* work,
+                    lapack_int *info );
+void LAPACK_checon( char* uplo, lapack_int* n, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_int* ipiv, float* anorm,
+                    float* rcond, lapack_complex_float* work,
+                    lapack_int *info );
+void LAPACK_zhecon( char* uplo, lapack_int* n, const lapack_complex_double* a,
+                    lapack_int* lda, const lapack_int* ipiv, double* anorm,
+                    double* rcond, lapack_complex_double* work,
+                    lapack_int *info );
+void LAPACK_sspcon( char* uplo, lapack_int* n, const float* ap,
+                    const lapack_int* ipiv, float* anorm, float* rcond,
+                    float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_dspcon( char* uplo, lapack_int* n, const double* ap,
+                    const lapack_int* ipiv, double* anorm, double* rcond,
+                    double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_cspcon( char* uplo, lapack_int* n, const lapack_complex_float* ap,
+                    const lapack_int* ipiv, float* anorm, float* rcond,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zspcon( char* uplo, lapack_int* n, const lapack_complex_double* ap,
+                    const lapack_int* ipiv, double* anorm, double* rcond,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_chpcon( char* uplo, lapack_int* n, const lapack_complex_float* ap,
+                    const lapack_int* ipiv, float* anorm, float* rcond,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zhpcon( char* uplo, lapack_int* n, const lapack_complex_double* ap,
+                    const lapack_int* ipiv, double* anorm, double* rcond,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_strcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    const float* a, lapack_int* lda, float* rcond, float* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_dtrcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    const double* a, lapack_int* lda, double* rcond,
+                    double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_ctrcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    float* rcond, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_ztrcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    double* rcond, lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_stpcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    const float* ap, float* rcond, float* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_dtpcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    const double* ap, double* rcond, double* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_ctpcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    const lapack_complex_float* ap, float* rcond,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_ztpcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    const lapack_complex_double* ap, double* rcond,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_stbcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    lapack_int* kd, const float* ab, lapack_int* ldab,
+                    float* rcond, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dtbcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    lapack_int* kd, const double* ab, lapack_int* ldab,
+                    double* rcond, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_ctbcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    lapack_int* kd, const lapack_complex_float* ab,
+                    lapack_int* ldab, float* rcond, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_ztbcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    lapack_int* kd, const lapack_complex_double* ab,
+                    lapack_int* ldab, double* rcond,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_sgerfs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const float* a, lapack_int* lda, const float* af,
+                    lapack_int* ldaf, const lapack_int* ipiv, const float* b,
+                    lapack_int* ldb, float* x, lapack_int* ldx, float* ferr,
+                    float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dgerfs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const double* a, lapack_int* lda, const double* af,
+                    lapack_int* ldaf, const lapack_int* ipiv, const double* b,
+                    lapack_int* ldb, double* x, lapack_int* ldx, double* ferr,
+                    double* berr, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_cgerfs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* af, lapack_int* ldaf,
+                    const lapack_int* ipiv, const lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
+                    float* ferr, float* berr, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zgerfs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* af, lapack_int* ldaf,
+                    const lapack_int* ipiv, const lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                    double* ferr, double* berr, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_dgerfsx( char* trans, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const double* a, lapack_int* lda, const double* af,
+                     lapack_int* ldaf, const lapack_int* ipiv, const double* r,
+                     const double* c, const double* b, lapack_int* ldb,
+                     double* x, lapack_int* ldx, double* rcond, double* berr,
+                     lapack_int* n_err_bnds, double* err_bnds_norm,
+                     double* err_bnds_comp, lapack_int* nparams, double* params,
+                     double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_sgerfsx( char* trans, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const float* a, lapack_int* lda, const float* af,
+                     lapack_int* ldaf, const lapack_int* ipiv, const float* r,
+                     const float* c, const float* b, lapack_int* ldb, float* x,
+                     lapack_int* ldx, float* rcond, float* berr,
+                     lapack_int* n_err_bnds, float* err_bnds_norm,
+                     float* err_bnds_comp, lapack_int* nparams, float* params,
+                     float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_zgerfsx( char* trans, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const lapack_complex_double* a, lapack_int* lda,
+                     const lapack_complex_double* af, lapack_int* ldaf,
+                     const lapack_int* ipiv, const double* r, const double* c,
+                     const lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                     double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params,
+                     lapack_complex_double* work, double* rwork,
+                     lapack_int *info );
+void LAPACK_cgerfsx( char* trans, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const lapack_complex_float* a, lapack_int* lda,
+                     const lapack_complex_float* af, lapack_int* ldaf,
+                     const lapack_int* ipiv, const float* r, const float* c,
+                     const lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                     float* berr, lapack_int* n_err_bnds, float* err_bnds_norm,
+                     float* err_bnds_comp, lapack_int* nparams, float* params,
+                     lapack_complex_float* work, float* rwork,
+                     lapack_int *info );
+void LAPACK_sgbrfs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    lapack_int* nrhs, const float* ab, lapack_int* ldab,
+                    const float* afb, lapack_int* ldafb, const lapack_int* ipiv,
+                    const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
+                    float* ferr, float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dgbrfs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    lapack_int* nrhs, const double* ab, lapack_int* ldab,
+                    const double* afb, lapack_int* ldafb,
+                    const lapack_int* ipiv, const double* b, lapack_int* ldb,
+                    double* x, lapack_int* ldx, double* ferr, double* berr,
+                    double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_cgbrfs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    lapack_int* nrhs, const lapack_complex_float* ab,
+                    lapack_int* ldab, const lapack_complex_float* afb,
+                    lapack_int* ldafb, const lapack_int* ipiv,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* ferr,
+                    float* berr, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zgbrfs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    lapack_int* nrhs, const lapack_complex_double* ab,
+                    lapack_int* ldab, const lapack_complex_double* afb,
+                    lapack_int* ldafb, const lapack_int* ipiv,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* ferr,
+                    double* berr, lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_dgbrfsx( char* trans, char* equed, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, lapack_int* nrhs, const double* ab,
+                     lapack_int* ldab, const double* afb, lapack_int* ldafb,
+                     const lapack_int* ipiv, const double* r, const double* c,
+                     const double* b, lapack_int* ldb, double* x,
+                     lapack_int* ldx, double* rcond, double* berr,
+                     lapack_int* n_err_bnds, double* err_bnds_norm,
+                     double* err_bnds_comp, lapack_int* nparams, double* params,
+                     double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_sgbrfsx( char* trans, char* equed, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, lapack_int* nrhs, const float* ab,
+                     lapack_int* ldab, const float* afb, lapack_int* ldafb,
+                     const lapack_int* ipiv, const float* r, const float* c,
+                     const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
+                     float* rcond, float* berr, lapack_int* n_err_bnds,
+                     float* err_bnds_norm, float* err_bnds_comp,
+                     lapack_int* nparams, float* params, float* work,
+                     lapack_int* iwork, lapack_int *info );
+void LAPACK_zgbrfsx( char* trans, char* equed, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, lapack_int* nrhs,
+                     const lapack_complex_double* ab, lapack_int* ldab,
+                     const lapack_complex_double* afb, lapack_int* ldafb,
+                     const lapack_int* ipiv, const double* r, const double* c,
+                     const lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                     double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params,
+                     lapack_complex_double* work, double* rwork,
+                     lapack_int *info );
+void LAPACK_cgbrfsx( char* trans, char* equed, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, lapack_int* nrhs,
+                     const lapack_complex_float* ab, lapack_int* ldab,
+                     const lapack_complex_float* afb, lapack_int* ldafb,
+                     const lapack_int* ipiv, const float* r, const float* c,
+                     const lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                     float* berr, lapack_int* n_err_bnds, float* err_bnds_norm,
+                     float* err_bnds_comp, lapack_int* nparams, float* params,
+                     lapack_complex_float* work, float* rwork,
+                     lapack_int *info );
+void LAPACK_sgtrfs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const float* dl, const float* d, const float* du,
+                    const float* dlf, const float* df, const float* duf,
+                    const float* du2, const lapack_int* ipiv, const float* b,
+                    lapack_int* ldb, float* x, lapack_int* ldx, float* ferr,
+                    float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dgtrfs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const double* dl, const double* d, const double* du,
+                    const double* dlf, const double* df, const double* duf,
+                    const double* du2, const lapack_int* ipiv, const double* b,
+                    lapack_int* ldb, double* x, lapack_int* ldx, double* ferr,
+                    double* berr, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_cgtrfs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* dl,
+                    const lapack_complex_float* d,
+                    const lapack_complex_float* du,
+                    const lapack_complex_float* dlf,
+                    const lapack_complex_float* df,
+                    const lapack_complex_float* duf,
+                    const lapack_complex_float* du2, const lapack_int* ipiv,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* ferr,
+                    float* berr, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zgtrfs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* dl,
+                    const lapack_complex_double* d,
+                    const lapack_complex_double* du,
+                    const lapack_complex_double* dlf,
+                    const lapack_complex_double* df,
+                    const lapack_complex_double* duf,
+                    const lapack_complex_double* du2, const lapack_int* ipiv,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* ferr,
+                    double* berr, lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_sporfs( char* uplo, lapack_int* n, lapack_int* nrhs, const float* a,
+                    lapack_int* lda, const float* af, lapack_int* ldaf,
+                    const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
+                    float* ferr, float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dporfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* a, lapack_int* lda, const double* af,
+                    lapack_int* ldaf, const double* b, lapack_int* ldb,
+                    double* x, lapack_int* ldx, double* ferr, double* berr,
+                    double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_cporfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* af, lapack_int* ldaf,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* ferr,
+                    float* berr, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zporfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* af, lapack_int* ldaf,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* ferr,
+                    double* berr, lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_dporfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const double* a, lapack_int* lda, const double* af,
+                     lapack_int* ldaf, const double* s, const double* b,
+                     lapack_int* ldb, double* x, lapack_int* ldx, double* rcond,
+                     double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params, double* work,
+                     lapack_int* iwork, lapack_int *info );
+void LAPACK_sporfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const float* a, lapack_int* lda, const float* af,
+                     lapack_int* ldaf, const float* s, const float* b,
+                     lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
+                     float* berr, lapack_int* n_err_bnds, float* err_bnds_norm,
+                     float* err_bnds_comp, lapack_int* nparams, float* params,
+                     float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_zporfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const lapack_complex_double* a, lapack_int* lda,
+                     const lapack_complex_double* af, lapack_int* ldaf,
+                     const double* s, const lapack_complex_double* b,
+                     lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                     double* rcond, double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params,
+                     lapack_complex_double* work, double* rwork,
+                     lapack_int *info );
+void LAPACK_cporfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const lapack_complex_float* a, lapack_int* lda,
+                     const lapack_complex_float* af, lapack_int* ldaf,
+                     const float* s, const lapack_complex_float* b,
+                     lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
+                     float* rcond, float* berr, lapack_int* n_err_bnds,
+                     float* err_bnds_norm, float* err_bnds_comp,
+                     lapack_int* nparams, float* params,
+                     lapack_complex_float* work, float* rwork,
+                     lapack_int *info );
+void LAPACK_spprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const float* ap, const float* afp, const float* b,
+                    lapack_int* ldb, float* x, lapack_int* ldx, float* ferr,
+                    float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dpprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* ap, const double* afp, const double* b,
+                    lapack_int* ldb, double* x, lapack_int* ldx, double* ferr,
+                    double* berr, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_cpprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* ap,
+                    const lapack_complex_float* afp,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* ferr,
+                    float* berr, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zpprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* ap,
+                    const lapack_complex_double* afp,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* ferr,
+                    double* berr, lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_spbrfs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                    const float* ab, lapack_int* ldab, const float* afb,
+                    lapack_int* ldafb, const float* b, lapack_int* ldb,
+                    float* x, lapack_int* ldx, float* ferr, float* berr,
+                    float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_dpbrfs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                    const double* ab, lapack_int* ldab, const double* afb,
+                    lapack_int* ldafb, const double* b, lapack_int* ldb,
+                    double* x, lapack_int* ldx, double* ferr, double* berr,
+                    double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_cpbrfs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                    const lapack_complex_float* ab, lapack_int* ldab,
+                    const lapack_complex_float* afb, lapack_int* ldafb,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* ferr,
+                    float* berr, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zpbrfs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                    const lapack_complex_double* ab, lapack_int* ldab,
+                    const lapack_complex_double* afb, lapack_int* ldafb,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* ferr,
+                    double* berr, lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_sptrfs( lapack_int* n, lapack_int* nrhs, const float* d,
+                    const float* e, const float* df, const float* ef,
+                    const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
+                    float* ferr, float* berr, float* work, lapack_int *info );
+void LAPACK_dptrfs( lapack_int* n, lapack_int* nrhs, const double* d,
+                    const double* e, const double* df, const double* ef,
+                    const double* b, lapack_int* ldb, double* x,
+                    lapack_int* ldx, double* ferr, double* berr, double* work,
+                    lapack_int *info );
+void LAPACK_cptrfs( char* uplo, lapack_int* n, lapack_int* nrhs, const float* d,
+                    const lapack_complex_float* e, const float* df,
+                    const lapack_complex_float* ef,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* ferr,
+                    float* berr, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zptrfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* d, const lapack_complex_double* e,
+                    const double* df, const lapack_complex_double* ef,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* ferr,
+                    double* berr, lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_ssyrfs( char* uplo, lapack_int* n, lapack_int* nrhs, const float* a,
+                    lapack_int* lda, const float* af, lapack_int* ldaf,
+                    const lapack_int* ipiv, const float* b, lapack_int* ldb,
+                    float* x, lapack_int* ldx, float* ferr, float* berr,
+                    float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_dsyrfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* a, lapack_int* lda, const double* af,
+                    lapack_int* ldaf, const lapack_int* ipiv, const double* b,
+                    lapack_int* ldb, double* x, lapack_int* ldx, double* ferr,
+                    double* berr, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_csyrfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* af, lapack_int* ldaf,
+                    const lapack_int* ipiv, const lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
+                    float* ferr, float* berr, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zsyrfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* af, lapack_int* ldaf,
+                    const lapack_int* ipiv, const lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                    double* ferr, double* berr, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_dsyrfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const double* a, lapack_int* lda, const double* af,
+                     lapack_int* ldaf, const lapack_int* ipiv, const double* s,
+                     const double* b, lapack_int* ldb, double* x,
+                     lapack_int* ldx, double* rcond, double* berr,
+                     lapack_int* n_err_bnds, double* err_bnds_norm,
+                     double* err_bnds_comp, lapack_int* nparams, double* params,
+                     double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_ssyrfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const float* a, lapack_int* lda, const float* af,
+                     lapack_int* ldaf, const lapack_int* ipiv, const float* s,
+                     const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
+                     float* rcond, float* berr, lapack_int* n_err_bnds,
+                     float* err_bnds_norm, float* err_bnds_comp,
+                     lapack_int* nparams, float* params, float* work,
+                     lapack_int* iwork, lapack_int *info );
+void LAPACK_zsyrfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const lapack_complex_double* a, lapack_int* lda,
+                     const lapack_complex_double* af, lapack_int* ldaf,
+                     const lapack_int* ipiv, const double* s,
+                     const lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                     double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params,
+                     lapack_complex_double* work, double* rwork,
+                     lapack_int *info );
+void LAPACK_csyrfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const lapack_complex_float* a, lapack_int* lda,
+                     const lapack_complex_float* af, lapack_int* ldaf,
+                     const lapack_int* ipiv, const float* s,
+                     const lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                     float* berr, lapack_int* n_err_bnds, float* err_bnds_norm,
+                     float* err_bnds_comp, lapack_int* nparams, float* params,
+                     lapack_complex_float* work, float* rwork,
+                     lapack_int *info );
+void LAPACK_cherfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* af, lapack_int* ldaf,
+                    const lapack_int* ipiv, const lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
+                    float* ferr, float* berr, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zherfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* af, lapack_int* ldaf,
+                    const lapack_int* ipiv, const lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                    double* ferr, double* berr, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_zherfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const lapack_complex_double* a, lapack_int* lda,
+                     const lapack_complex_double* af, lapack_int* ldaf,
+                     const lapack_int* ipiv, const double* s,
+                     const lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                     double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params,
+                     lapack_complex_double* work, double* rwork,
+                     lapack_int *info );
+void LAPACK_cherfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const lapack_complex_float* a, lapack_int* lda,
+                     const lapack_complex_float* af, lapack_int* ldaf,
+                     const lapack_int* ipiv, const float* s,
+                     const lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                     float* berr, lapack_int* n_err_bnds, float* err_bnds_norm,
+                     float* err_bnds_comp, lapack_int* nparams, float* params,
+                     lapack_complex_float* work, float* rwork,
+                     lapack_int *info );
+void LAPACK_ssprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const float* ap, const float* afp, const lapack_int* ipiv,
+                    const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
+                    float* ferr, float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dsprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* ap, const double* afp, const lapack_int* ipiv,
+                    const double* b, lapack_int* ldb, double* x,
+                    lapack_int* ldx, double* ferr, double* berr, double* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_csprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* ap,
+                    const lapack_complex_float* afp, const lapack_int* ipiv,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* ferr,
+                    float* berr, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zsprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* ap,
+                    const lapack_complex_double* afp, const lapack_int* ipiv,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* ferr,
+                    double* berr, lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_chprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* ap,
+                    const lapack_complex_float* afp, const lapack_int* ipiv,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* ferr,
+                    float* berr, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zhprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* ap,
+                    const lapack_complex_double* afp, const lapack_int* ipiv,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* ferr,
+                    double* berr, lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_strrfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const float* a, lapack_int* lda,
+                    const float* b, lapack_int* ldb, const float* x,
+                    lapack_int* ldx, float* ferr, float* berr, float* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_dtrrfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const double* a, lapack_int* lda,
+                    const double* b, lapack_int* ldb, const double* x,
+                    lapack_int* ldx, double* ferr, double* berr, double* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_ctrrfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* b,
+                    lapack_int* ldb, const lapack_complex_float* x,
+                    lapack_int* ldx, float* ferr, float* berr,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_ztrrfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const lapack_complex_double* a,
+                    lapack_int* lda, const lapack_complex_double* b,
+                    lapack_int* ldb, const lapack_complex_double* x,
+                    lapack_int* ldx, double* ferr, double* berr,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_stprfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const float* ap, const float* b,
+                    lapack_int* ldb, const float* x, lapack_int* ldx,
+                    float* ferr, float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dtprfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const double* ap, const double* b,
+                    lapack_int* ldb, const double* x, lapack_int* ldx,
+                    double* ferr, double* berr, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_ctprfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const lapack_complex_float* ap,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    const lapack_complex_float* x, lapack_int* ldx, float* ferr,
+                    float* berr, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_ztprfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const lapack_complex_double* ap,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    const lapack_complex_double* x, lapack_int* ldx,
+                    double* ferr, double* berr, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_stbrfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* kd, lapack_int* nrhs, const float* ab,
+                    lapack_int* ldab, const float* b, lapack_int* ldb,
+                    const float* x, lapack_int* ldx, float* ferr, float* berr,
+                    float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_dtbrfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* kd, lapack_int* nrhs, const double* ab,
+                    lapack_int* ldab, const double* b, lapack_int* ldb,
+                    const double* x, lapack_int* ldx, double* ferr,
+                    double* berr, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_ctbrfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* kd, lapack_int* nrhs,
+                    const lapack_complex_float* ab, lapack_int* ldab,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    const lapack_complex_float* x, lapack_int* ldx, float* ferr,
+                    float* berr, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_ztbrfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* kd, lapack_int* nrhs,
+                    const lapack_complex_double* ab, lapack_int* ldab,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    const lapack_complex_double* x, lapack_int* ldx,
+                    double* ferr, double* berr, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_sgetri( lapack_int* n, float* a, lapack_int* lda,
+                    const lapack_int* ipiv, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dgetri( lapack_int* n, double* a, lapack_int* lda,
+                    const lapack_int* ipiv, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cgetri( lapack_int* n, lapack_complex_float* a, lapack_int* lda,
+                    const lapack_int* ipiv, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zgetri( lapack_int* n, lapack_complex_double* a, lapack_int* lda,
+                    const lapack_int* ipiv, lapack_complex_double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_spotri( char* uplo, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_dpotri( char* uplo, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_cpotri( char* uplo, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_zpotri( char* uplo, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_dpftri( char* transr, char* uplo, lapack_int* n, double* a,
+                    lapack_int *info );
+void LAPACK_spftri( char* transr, char* uplo, lapack_int* n, float* a,
+                    lapack_int *info );
+void LAPACK_zpftri( char* transr, char* uplo, lapack_int* n,
+                    lapack_complex_double* a, lapack_int *info );
+void LAPACK_cpftri( char* transr, char* uplo, lapack_int* n,
+                    lapack_complex_float* a, lapack_int *info );
+void LAPACK_spptri( char* uplo, lapack_int* n, float* ap, lapack_int *info );
+void LAPACK_dpptri( char* uplo, lapack_int* n, double* ap, lapack_int *info );
+void LAPACK_cpptri( char* uplo, lapack_int* n, lapack_complex_float* ap,
+                    lapack_int *info );
+void LAPACK_zpptri( char* uplo, lapack_int* n, lapack_complex_double* ap,
+                    lapack_int *info );
+void LAPACK_ssytri( char* uplo, lapack_int* n, float* a, lapack_int* lda,
+                    const lapack_int* ipiv, float* work, lapack_int *info );
+void LAPACK_dsytri( char* uplo, lapack_int* n, double* a, lapack_int* lda,
+                    const lapack_int* ipiv, double* work, lapack_int *info );
+void LAPACK_csytri( char* uplo, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, const lapack_int* ipiv,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zsytri( char* uplo, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, const lapack_int* ipiv,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_chetri( char* uplo, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, const lapack_int* ipiv,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zhetri( char* uplo, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, const lapack_int* ipiv,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_ssptri( char* uplo, lapack_int* n, float* ap,
+                    const lapack_int* ipiv, float* work, lapack_int *info );
+void LAPACK_dsptri( char* uplo, lapack_int* n, double* ap,
+                    const lapack_int* ipiv, double* work, lapack_int *info );
+void LAPACK_csptri( char* uplo, lapack_int* n, lapack_complex_float* ap,
+                    const lapack_int* ipiv, lapack_complex_float* work,
+                    lapack_int *info );
+void LAPACK_zsptri( char* uplo, lapack_int* n, lapack_complex_double* ap,
+                    const lapack_int* ipiv, lapack_complex_double* work,
+                    lapack_int *info );
+void LAPACK_chptri( char* uplo, lapack_int* n, lapack_complex_float* ap,
+                    const lapack_int* ipiv, lapack_complex_float* work,
+                    lapack_int *info );
+void LAPACK_zhptri( char* uplo, lapack_int* n, lapack_complex_double* ap,
+                    const lapack_int* ipiv, lapack_complex_double* work,
+                    lapack_int *info );
+void LAPACK_strtri( char* uplo, char* diag, lapack_int* n, float* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_dtrtri( char* uplo, char* diag, lapack_int* n, double* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_ctrtri( char* uplo, char* diag, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_ztrtri( char* uplo, char* diag, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_dtftri( char* transr, char* uplo, char* diag, lapack_int* n,
+                    double* a, lapack_int *info );
+void LAPACK_stftri( char* transr, char* uplo, char* diag, lapack_int* n,
+                    float* a, lapack_int *info );
+void LAPACK_ztftri( char* transr, char* uplo, char* diag, lapack_int* n,
+                    lapack_complex_double* a, lapack_int *info );
+void LAPACK_ctftri( char* transr, char* uplo, char* diag, lapack_int* n,
+                    lapack_complex_float* a, lapack_int *info );
+void LAPACK_stptri( char* uplo, char* diag, lapack_int* n, float* ap,
+                    lapack_int *info );
+void LAPACK_dtptri( char* uplo, char* diag, lapack_int* n, double* ap,
+                    lapack_int *info );
+void LAPACK_ctptri( char* uplo, char* diag, lapack_int* n,
+                    lapack_complex_float* ap, lapack_int *info );
+void LAPACK_ztptri( char* uplo, char* diag, lapack_int* n,
+                    lapack_complex_double* ap, lapack_int *info );
+void LAPACK_sgeequ( lapack_int* m, lapack_int* n, const float* a,
+                    lapack_int* lda, float* r, float* c, float* rowcnd,
+                    float* colcnd, float* amax, lapack_int *info );
+void LAPACK_dgeequ( lapack_int* m, lapack_int* n, const double* a,
+                    lapack_int* lda, double* r, double* c, double* rowcnd,
+                    double* colcnd, double* amax, lapack_int *info );
+void LAPACK_cgeequ( lapack_int* m, lapack_int* n, const lapack_complex_float* a,
+                    lapack_int* lda, float* r, float* c, float* rowcnd,
+                    float* colcnd, float* amax, lapack_int *info );
+void LAPACK_zgeequ( lapack_int* m, lapack_int* n,
+                    const lapack_complex_double* a, lapack_int* lda, double* r,
+                    double* c, double* rowcnd, double* colcnd, double* amax,
+                    lapack_int *info );
+void LAPACK_dgeequb( lapack_int* m, lapack_int* n, const double* a,
+                     lapack_int* lda, double* r, double* c, double* rowcnd,
+                     double* colcnd, double* amax, lapack_int *info );
+void LAPACK_sgeequb( lapack_int* m, lapack_int* n, const float* a,
+                     lapack_int* lda, float* r, float* c, float* rowcnd,
+                     float* colcnd, float* amax, lapack_int *info );
+void LAPACK_zgeequb( lapack_int* m, lapack_int* n,
+                     const lapack_complex_double* a, lapack_int* lda, double* r,
+                     double* c, double* rowcnd, double* colcnd, double* amax,
+                     lapack_int *info );
+void LAPACK_cgeequb( lapack_int* m, lapack_int* n,
+                     const lapack_complex_float* a, lapack_int* lda, float* r,
+                     float* c, float* rowcnd, float* colcnd, float* amax,
+                     lapack_int *info );
+void LAPACK_sgbequ( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, const float* ab, lapack_int* ldab, float* r,
+                    float* c, float* rowcnd, float* colcnd, float* amax,
+                    lapack_int *info );
+void LAPACK_dgbequ( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, const double* ab, lapack_int* ldab,
+                    double* r, double* c, double* rowcnd, double* colcnd,
+                    double* amax, lapack_int *info );
+void LAPACK_cgbequ( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, const lapack_complex_float* ab,
+                    lapack_int* ldab, float* r, float* c, float* rowcnd,
+                    float* colcnd, float* amax, lapack_int *info );
+void LAPACK_zgbequ( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, const lapack_complex_double* ab,
+                    lapack_int* ldab, double* r, double* c, double* rowcnd,
+                    double* colcnd, double* amax, lapack_int *info );
+void LAPACK_dgbequb( lapack_int* m, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, const double* ab, lapack_int* ldab,
+                     double* r, double* c, double* rowcnd, double* colcnd,
+                     double* amax, lapack_int *info );
+void LAPACK_sgbequb( lapack_int* m, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, const float* ab, lapack_int* ldab,
+                     float* r, float* c, float* rowcnd, float* colcnd,
+                     float* amax, lapack_int *info );
+void LAPACK_zgbequb( lapack_int* m, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, const lapack_complex_double* ab,
+                     lapack_int* ldab, double* r, double* c, double* rowcnd,
+                     double* colcnd, double* amax, lapack_int *info );
+void LAPACK_cgbequb( lapack_int* m, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, const lapack_complex_float* ab,
+                     lapack_int* ldab, float* r, float* c, float* rowcnd,
+                     float* colcnd, float* amax, lapack_int *info );
+void LAPACK_spoequ( lapack_int* n, const float* a, lapack_int* lda, float* s,
+                    float* scond, float* amax, lapack_int *info );
+void LAPACK_dpoequ( lapack_int* n, const double* a, lapack_int* lda, double* s,
+                    double* scond, double* amax, lapack_int *info );
+void LAPACK_cpoequ( lapack_int* n, const lapack_complex_float* a,
+                    lapack_int* lda, float* s, float* scond, float* amax,
+                    lapack_int *info );
+void LAPACK_zpoequ( lapack_int* n, const lapack_complex_double* a,
+                    lapack_int* lda, double* s, double* scond, double* amax,
+                    lapack_int *info );
+void LAPACK_dpoequb( lapack_int* n, const double* a, lapack_int* lda, double* s,
+                     double* scond, double* amax, lapack_int *info );
+void LAPACK_spoequb( lapack_int* n, const float* a, lapack_int* lda, float* s,
+                     float* scond, float* amax, lapack_int *info );
+void LAPACK_zpoequb( lapack_int* n, const lapack_complex_double* a,
+                     lapack_int* lda, double* s, double* scond, double* amax,
+                     lapack_int *info );
+void LAPACK_cpoequb( lapack_int* n, const lapack_complex_float* a,
+                     lapack_int* lda, float* s, float* scond, float* amax,
+                     lapack_int *info );
+void LAPACK_sppequ( char* uplo, lapack_int* n, const float* ap, float* s,
+                    float* scond, float* amax, lapack_int *info );
+void LAPACK_dppequ( char* uplo, lapack_int* n, const double* ap, double* s,
+                    double* scond, double* amax, lapack_int *info );
+void LAPACK_cppequ( char* uplo, lapack_int* n, const lapack_complex_float* ap,
+                    float* s, float* scond, float* amax, lapack_int *info );
+void LAPACK_zppequ( char* uplo, lapack_int* n, const lapack_complex_double* ap,
+                    double* s, double* scond, double* amax, lapack_int *info );
+void LAPACK_spbequ( char* uplo, lapack_int* n, lapack_int* kd, const float* ab,
+                    lapack_int* ldab, float* s, float* scond, float* amax,
+                    lapack_int *info );
+void LAPACK_dpbequ( char* uplo, lapack_int* n, lapack_int* kd, const double* ab,
+                    lapack_int* ldab, double* s, double* scond, double* amax,
+                    lapack_int *info );
+void LAPACK_cpbequ( char* uplo, lapack_int* n, lapack_int* kd,
+                    const lapack_complex_float* ab, lapack_int* ldab, float* s,
+                    float* scond, float* amax, lapack_int *info );
+void LAPACK_zpbequ( char* uplo, lapack_int* n, lapack_int* kd,
+                    const lapack_complex_double* ab, lapack_int* ldab,
+                    double* s, double* scond, double* amax, lapack_int *info );
+void LAPACK_dsyequb( char* uplo, lapack_int* n, const double* a,
+                     lapack_int* lda, double* s, double* scond, double* amax,
+                     double* work, lapack_int *info );
+void LAPACK_ssyequb( char* uplo, lapack_int* n, const float* a, lapack_int* lda,
+                     float* s, float* scond, float* amax, float* work,
+                     lapack_int *info );
+void LAPACK_zsyequb( char* uplo, lapack_int* n, const lapack_complex_double* a,
+                     lapack_int* lda, double* s, double* scond, double* amax,
+                     lapack_complex_double* work, lapack_int *info );
+void LAPACK_csyequb( char* uplo, lapack_int* n, const lapack_complex_float* a,
+                     lapack_int* lda, float* s, float* scond, float* amax,
+                     lapack_complex_float* work, lapack_int *info );
+void LAPACK_zheequb( char* uplo, lapack_int* n, const lapack_complex_double* a,
+                     lapack_int* lda, double* s, double* scond, double* amax,
+                     lapack_complex_double* work, lapack_int *info );
+void LAPACK_cheequb( char* uplo, lapack_int* n, const lapack_complex_float* a,
+                     lapack_int* lda, float* s, float* scond, float* amax,
+                     lapack_complex_float* work, lapack_int *info );
+void LAPACK_sgesv( lapack_int* n, lapack_int* nrhs, float* a, lapack_int* lda,
+                   lapack_int* ipiv, float* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_dgesv( lapack_int* n, lapack_int* nrhs, double* a, lapack_int* lda,
+                   lapack_int* ipiv, double* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_cgesv( lapack_int* n, lapack_int* nrhs, lapack_complex_float* a,
+                   lapack_int* lda, lapack_int* ipiv, lapack_complex_float* b,
+                   lapack_int* ldb, lapack_int *info );
+void LAPACK_zgesv( lapack_int* n, lapack_int* nrhs, lapack_complex_double* a,
+                   lapack_int* lda, lapack_int* ipiv, lapack_complex_double* b,
+                   lapack_int* ldb, lapack_int *info );
+void LAPACK_dsgesv( lapack_int* n, lapack_int* nrhs, double* a, lapack_int* lda,
+                    lapack_int* ipiv, double* b, lapack_int* ldb, double* x,
+                    lapack_int* ldx, double* work, float* swork,
+                    lapack_int* iter, lapack_int *info );
+void LAPACK_zcgesv( lapack_int* n, lapack_int* nrhs, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* ipiv, lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                    lapack_complex_double* work, lapack_complex_float* swork,
+                    double* rwork, lapack_int* iter, lapack_int *info );
+void LAPACK_sgesvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                    float* a, lapack_int* lda, float* af, lapack_int* ldaf,
+                    lapack_int* ipiv, char* equed, float* r, float* c, float* b,
+                    lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dgesvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                    double* a, lapack_int* lda, double* af, lapack_int* ldaf,
+                    lapack_int* ipiv, char* equed, double* r, double* c,
+                    double* b, lapack_int* ldb, double* x, lapack_int* ldx,
+                    double* rcond, double* ferr, double* berr, double* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_cgesvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* af, lapack_int* ldaf,
+                    lapack_int* ipiv, char* equed, float* r, float* c,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zgesvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* af, lapack_int* ldaf,
+                    lapack_int* ipiv, char* equed, double* r, double* c,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                    double* ferr, double* berr, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_dgesvxx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                     double* a, lapack_int* lda, double* af, lapack_int* ldaf,
+                     lapack_int* ipiv, char* equed, double* r, double* c,
+                     double* b, lapack_int* ldb, double* x, lapack_int* ldx,
+                     double* rcond, double* rpvgrw, double* berr,
+                     lapack_int* n_err_bnds, double* err_bnds_norm,
+                     double* err_bnds_comp, lapack_int* nparams, double* params,
+                     double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_sgesvxx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                     float* a, lapack_int* lda, float* af, lapack_int* ldaf,
+                     lapack_int* ipiv, char* equed, float* r, float* c,
+                     float* b, lapack_int* ldb, float* x, lapack_int* ldx,
+                     float* rcond, float* rpvgrw, float* berr,
+                     lapack_int* n_err_bnds, float* err_bnds_norm,
+                     float* err_bnds_comp, lapack_int* nparams, float* params,
+                     float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_zgesvxx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                     lapack_complex_double* a, lapack_int* lda,
+                     lapack_complex_double* af, lapack_int* ldaf,
+                     lapack_int* ipiv, char* equed, double* r, double* c,
+                     lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                     double* rpvgrw, double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params,
+                     lapack_complex_double* work, double* rwork,
+                     lapack_int *info );
+void LAPACK_cgesvxx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                     lapack_complex_float* a, lapack_int* lda,
+                     lapack_complex_float* af, lapack_int* ldaf,
+                     lapack_int* ipiv, char* equed, float* r, float* c,
+                     lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                     float* rpvgrw, float* berr, lapack_int* n_err_bnds,
+                     float* err_bnds_norm, float* err_bnds_comp,
+                     lapack_int* nparams, float* params,
+                     lapack_complex_float* work, float* rwork,
+                     lapack_int *info );
+void LAPACK_sgbsv( lapack_int* n, lapack_int* kl, lapack_int* ku,
+                   lapack_int* nrhs, float* ab, lapack_int* ldab,
+                   lapack_int* ipiv, float* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_dgbsv( lapack_int* n, lapack_int* kl, lapack_int* ku,
+                   lapack_int* nrhs, double* ab, lapack_int* ldab,
+                   lapack_int* ipiv, double* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_cgbsv( lapack_int* n, lapack_int* kl, lapack_int* ku,
+                   lapack_int* nrhs, lapack_complex_float* ab, lapack_int* ldab,
+                   lapack_int* ipiv, lapack_complex_float* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_zgbsv( lapack_int* n, lapack_int* kl, lapack_int* ku,
+                   lapack_int* nrhs, lapack_complex_double* ab,
+                   lapack_int* ldab, lapack_int* ipiv, lapack_complex_double* b,
+                   lapack_int* ldb, lapack_int *info );
+void LAPACK_sgbsvx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, lapack_int* nrhs, float* ab,
+                    lapack_int* ldab, float* afb, lapack_int* ldafb,
+                    lapack_int* ipiv, char* equed, float* r, float* c, float* b,
+                    lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dgbsvx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, lapack_int* nrhs, double* ab,
+                    lapack_int* ldab, double* afb, lapack_int* ldafb,
+                    lapack_int* ipiv, char* equed, double* r, double* c,
+                    double* b, lapack_int* ldb, double* x, lapack_int* ldx,
+                    double* rcond, double* ferr, double* berr, double* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_cgbsvx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, lapack_int* nrhs, lapack_complex_float* ab,
+                    lapack_int* ldab, lapack_complex_float* afb,
+                    lapack_int* ldafb, lapack_int* ipiv, char* equed, float* r,
+                    float* c, lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zgbsvx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, lapack_int* nrhs, lapack_complex_double* ab,
+                    lapack_int* ldab, lapack_complex_double* afb,
+                    lapack_int* ldafb, lapack_int* ipiv, char* equed, double* r,
+                    double* c, lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                    double* ferr, double* berr, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_dgbsvxx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, lapack_int* nrhs, double* ab,
+                     lapack_int* ldab, double* afb, lapack_int* ldafb,
+                     lapack_int* ipiv, char* equed, double* r, double* c,
+                     double* b, lapack_int* ldb, double* x, lapack_int* ldx,
+                     double* rcond, double* rpvgrw, double* berr,
+                     lapack_int* n_err_bnds, double* err_bnds_norm,
+                     double* err_bnds_comp, lapack_int* nparams, double* params,
+                     double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_sgbsvxx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, lapack_int* nrhs, float* ab,
+                     lapack_int* ldab, float* afb, lapack_int* ldafb,
+                     lapack_int* ipiv, char* equed, float* r, float* c,
+                     float* b, lapack_int* ldb, float* x, lapack_int* ldx,
+                     float* rcond, float* rpvgrw, float* berr,
+                     lapack_int* n_err_bnds, float* err_bnds_norm,
+                     float* err_bnds_comp, lapack_int* nparams, float* params,
+                     float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_zgbsvxx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, lapack_int* nrhs,
+                     lapack_complex_double* ab, lapack_int* ldab,
+                     lapack_complex_double* afb, lapack_int* ldafb,
+                     lapack_int* ipiv, char* equed, double* r, double* c,
+                     lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                     double* rpvgrw, double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params,
+                     lapack_complex_double* work, double* rwork,
+                     lapack_int *info );
+void LAPACK_cgbsvxx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, lapack_int* nrhs, lapack_complex_float* ab,
+                     lapack_int* ldab, lapack_complex_float* afb,
+                     lapack_int* ldafb, lapack_int* ipiv, char* equed, float* r,
+                     float* c, lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                     float* rpvgrw, float* berr, lapack_int* n_err_bnds,
+                     float* err_bnds_norm, float* err_bnds_comp,
+                     lapack_int* nparams, float* params,
+                     lapack_complex_float* work, float* rwork,
+                     lapack_int *info );
+void LAPACK_sgtsv( lapack_int* n, lapack_int* nrhs, float* dl, float* d,
+                   float* du, float* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_dgtsv( lapack_int* n, lapack_int* nrhs, double* dl, double* d,
+                   double* du, double* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_cgtsv( lapack_int* n, lapack_int* nrhs, lapack_complex_float* dl,
+                   lapack_complex_float* d, lapack_complex_float* du,
+                   lapack_complex_float* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_zgtsv( lapack_int* n, lapack_int* nrhs, lapack_complex_double* dl,
+                   lapack_complex_double* d, lapack_complex_double* du,
+                   lapack_complex_double* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_sgtsvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                    const float* dl, const float* d, const float* du,
+                    float* dlf, float* df, float* duf, float* du2,
+                    lapack_int* ipiv, const float* b, lapack_int* ldb, float* x,
+                    lapack_int* ldx, float* rcond, float* ferr, float* berr,
+                    float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_dgtsvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                    const double* dl, const double* d, const double* du,
+                    double* dlf, double* df, double* duf, double* du2,
+                    lapack_int* ipiv, const double* b, lapack_int* ldb,
+                    double* x, lapack_int* ldx, double* rcond, double* ferr,
+                    double* berr, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_cgtsvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* dl,
+                    const lapack_complex_float* d,
+                    const lapack_complex_float* du, lapack_complex_float* dlf,
+                    lapack_complex_float* df, lapack_complex_float* duf,
+                    lapack_complex_float* du2, lapack_int* ipiv,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zgtsvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* dl,
+                    const lapack_complex_double* d,
+                    const lapack_complex_double* du, lapack_complex_double* dlf,
+                    lapack_complex_double* df, lapack_complex_double* duf,
+                    lapack_complex_double* du2, lapack_int* ipiv,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                    double* ferr, double* berr, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_sposv( char* uplo, lapack_int* n, lapack_int* nrhs, float* a,
+                   lapack_int* lda, float* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_dposv( char* uplo, lapack_int* n, lapack_int* nrhs, double* a,
+                   lapack_int* lda, double* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_cposv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_float* a, lapack_int* lda,
+                   lapack_complex_float* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_zposv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_double* a, lapack_int* lda,
+                   lapack_complex_double* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_dsposv( char* uplo, lapack_int* n, lapack_int* nrhs, double* a,
+                    lapack_int* lda, double* b, lapack_int* ldb, double* x,
+                    lapack_int* ldx, double* work, float* swork,
+                    lapack_int* iter, lapack_int *info );
+void LAPACK_zcposv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx,
+                    lapack_complex_double* work, lapack_complex_float* swork,
+                    double* rwork, lapack_int* iter, lapack_int *info );
+void LAPACK_sposvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    float* a, lapack_int* lda, float* af, lapack_int* ldaf,
+                    char* equed, float* s, float* b, lapack_int* ldb, float* x,
+                    lapack_int* ldx, float* rcond, float* ferr, float* berr,
+                    float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_dposvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    double* a, lapack_int* lda, double* af, lapack_int* ldaf,
+                    char* equed, double* s, double* b, lapack_int* ldb,
+                    double* x, lapack_int* ldx, double* rcond, double* ferr,
+                    double* berr, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_cposvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* af, lapack_int* ldaf, char* equed,
+                    float* s, lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zposvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* af, lapack_int* ldaf, char* equed,
+                    double* s, lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                    double* ferr, double* berr, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_dposvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                     double* a, lapack_int* lda, double* af, lapack_int* ldaf,
+                     char* equed, double* s, double* b, lapack_int* ldb,
+                     double* x, lapack_int* ldx, double* rcond, double* rpvgrw,
+                     double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params, double* work,
+                     lapack_int* iwork, lapack_int *info );
+void LAPACK_sposvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                     float* a, lapack_int* lda, float* af, lapack_int* ldaf,
+                     char* equed, float* s, float* b, lapack_int* ldb, float* x,
+                     lapack_int* ldx, float* rcond, float* rpvgrw, float* berr,
+                     lapack_int* n_err_bnds, float* err_bnds_norm,
+                     float* err_bnds_comp, lapack_int* nparams, float* params,
+                     float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_zposvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                     lapack_complex_double* a, lapack_int* lda,
+                     lapack_complex_double* af, lapack_int* ldaf, char* equed,
+                     double* s, lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                     double* rpvgrw, double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params,
+                     lapack_complex_double* work, double* rwork,
+                     lapack_int *info );
+void LAPACK_cposvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                     lapack_complex_float* a, lapack_int* lda,
+                     lapack_complex_float* af, lapack_int* ldaf, char* equed,
+                     float* s, lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                     float* rpvgrw, float* berr, lapack_int* n_err_bnds,
+                     float* err_bnds_norm, float* err_bnds_comp,
+                     lapack_int* nparams, float* params,
+                     lapack_complex_float* work, float* rwork,
+                     lapack_int *info );
+void LAPACK_sppsv( char* uplo, lapack_int* n, lapack_int* nrhs, float* ap,
+                   float* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_dppsv( char* uplo, lapack_int* n, lapack_int* nrhs, double* ap,
+                   double* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_cppsv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_float* ap, lapack_complex_float* b,
+                   lapack_int* ldb, lapack_int *info );
+void LAPACK_zppsv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_double* ap, lapack_complex_double* b,
+                   lapack_int* ldb, lapack_int *info );
+void LAPACK_sppsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    float* ap, float* afp, char* equed, float* s, float* b,
+                    lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dppsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    double* ap, double* afp, char* equed, double* s, double* b,
+                    lapack_int* ldb, double* x, lapack_int* ldx, double* rcond,
+                    double* ferr, double* berr, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_cppsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_float* ap, lapack_complex_float* afp,
+                    char* equed, float* s, lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
+                    float* rcond, float* ferr, float* berr,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zppsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_double* ap, lapack_complex_double* afp,
+                    char* equed, double* s, lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                    double* rcond, double* ferr, double* berr,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_spbsv( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                   float* ab, lapack_int* ldab, float* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_dpbsv( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                   double* ab, lapack_int* ldab, double* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_cpbsv( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                   lapack_complex_float* ab, lapack_int* ldab,
+                   lapack_complex_float* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_zpbsv( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                   lapack_complex_double* ab, lapack_int* ldab,
+                   lapack_complex_double* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_spbsvx( char* fact, char* uplo, lapack_int* n, lapack_int* kd,
+                    lapack_int* nrhs, float* ab, lapack_int* ldab, float* afb,
+                    lapack_int* ldafb, char* equed, float* s, float* b,
+                    lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dpbsvx( char* fact, char* uplo, lapack_int* n, lapack_int* kd,
+                    lapack_int* nrhs, double* ab, lapack_int* ldab, double* afb,
+                    lapack_int* ldafb, char* equed, double* s, double* b,
+                    lapack_int* ldb, double* x, lapack_int* ldx, double* rcond,
+                    double* ferr, double* berr, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_cpbsvx( char* fact, char* uplo, lapack_int* n, lapack_int* kd,
+                    lapack_int* nrhs, lapack_complex_float* ab,
+                    lapack_int* ldab, lapack_complex_float* afb,
+                    lapack_int* ldafb, char* equed, float* s,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zpbsvx( char* fact, char* uplo, lapack_int* n, lapack_int* kd,
+                    lapack_int* nrhs, lapack_complex_double* ab,
+                    lapack_int* ldab, lapack_complex_double* afb,
+                    lapack_int* ldafb, char* equed, double* s,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                    double* ferr, double* berr, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_sptsv( lapack_int* n, lapack_int* nrhs, float* d, float* e,
+                   float* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_dptsv( lapack_int* n, lapack_int* nrhs, double* d, double* e,
+                   double* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_cptsv( lapack_int* n, lapack_int* nrhs, float* d,
+                   lapack_complex_float* e, lapack_complex_float* b,
+                   lapack_int* ldb, lapack_int *info );
+void LAPACK_zptsv( lapack_int* n, lapack_int* nrhs, double* d,
+                   lapack_complex_double* e, lapack_complex_double* b,
+                   lapack_int* ldb, lapack_int *info );
+void LAPACK_sptsvx( char* fact, lapack_int* n, lapack_int* nrhs, const float* d,
+                    const float* e, float* df, float* ef, const float* b,
+                    lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, float* work, lapack_int *info );
+void LAPACK_dptsvx( char* fact, lapack_int* n, lapack_int* nrhs,
+                    const double* d, const double* e, double* df, double* ef,
+                    const double* b, lapack_int* ldb, double* x,
+                    lapack_int* ldx, double* rcond, double* ferr, double* berr,
+                    double* work, lapack_int *info );
+void LAPACK_cptsvx( char* fact, lapack_int* n, lapack_int* nrhs, const float* d,
+                    const lapack_complex_float* e, float* df,
+                    lapack_complex_float* ef, const lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
+                    float* rcond, float* ferr, float* berr,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zptsvx( char* fact, lapack_int* n, lapack_int* nrhs,
+                    const double* d, const lapack_complex_double* e, double* df,
+                    lapack_complex_double* ef, const lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                    double* rcond, double* ferr, double* berr,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_ssysv( char* uplo, lapack_int* n, lapack_int* nrhs, float* a,
+                   lapack_int* lda, lapack_int* ipiv, float* b, lapack_int* ldb,
+                   float* work, lapack_int* lwork, lapack_int *info );
+void LAPACK_dsysv( char* uplo, lapack_int* n, lapack_int* nrhs, double* a,
+                   lapack_int* lda, lapack_int* ipiv, double* b,
+                   lapack_int* ldb, double* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_csysv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_float* a, lapack_int* lda, lapack_int* ipiv,
+                   lapack_complex_float* b, lapack_int* ldb,
+                   lapack_complex_float* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_zsysv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_double* a, lapack_int* lda, lapack_int* ipiv,
+                   lapack_complex_double* b, lapack_int* ldb,
+                   lapack_complex_double* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_ssysvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const float* a, lapack_int* lda, float* af,
+                    lapack_int* ldaf, lapack_int* ipiv, const float* b,
+                    lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_dsysvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* a, lapack_int* lda, double* af,
+                    lapack_int* ldaf, lapack_int* ipiv, const double* b,
+                    lapack_int* ldb, double* x, lapack_int* ldx, double* rcond,
+                    double* ferr, double* berr, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_csysvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* af, lapack_int* ldaf,
+                    lapack_int* ipiv, const lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
+                    float* rcond, float* ferr, float* berr,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int *info );
+void LAPACK_zsysvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* af, lapack_int* ldaf,
+                    lapack_int* ipiv, const lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                    double* rcond, double* ferr, double* berr,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int *info );
+void LAPACK_dsysvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                     double* a, lapack_int* lda, double* af, lapack_int* ldaf,
+                     lapack_int* ipiv, char* equed, double* s, double* b,
+                     lapack_int* ldb, double* x, lapack_int* ldx, double* rcond,
+                     double* rpvgrw, double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params, double* work,
+                     lapack_int* iwork, lapack_int *info );
+void LAPACK_ssysvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                     float* a, lapack_int* lda, float* af, lapack_int* ldaf,
+                     lapack_int* ipiv, char* equed, float* s, float* b,
+                     lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
+                     float* rpvgrw, float* berr, lapack_int* n_err_bnds,
+                     float* err_bnds_norm, float* err_bnds_comp,
+                     lapack_int* nparams, float* params, float* work,
+                     lapack_int* iwork, lapack_int *info );
+void LAPACK_zsysvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                     lapack_complex_double* a, lapack_int* lda,
+                     lapack_complex_double* af, lapack_int* ldaf,
+                     lapack_int* ipiv, char* equed, double* s,
+                     lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                     double* rpvgrw, double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params,
+                     lapack_complex_double* work, double* rwork,
+                     lapack_int *info );
+void LAPACK_csysvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                     lapack_complex_float* a, lapack_int* lda,
+                     lapack_complex_float* af, lapack_int* ldaf,
+                     lapack_int* ipiv, char* equed, float* s,
+                     lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                     float* rpvgrw, float* berr, lapack_int* n_err_bnds,
+                     float* err_bnds_norm, float* err_bnds_comp,
+                     lapack_int* nparams, float* params,
+                     lapack_complex_float* work, float* rwork,
+                     lapack_int *info );
+void LAPACK_chesv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_float* a, lapack_int* lda, lapack_int* ipiv,
+                   lapack_complex_float* b, lapack_int* ldb,
+                   lapack_complex_float* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_zhesv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_double* a, lapack_int* lda, lapack_int* ipiv,
+                   lapack_complex_double* b, lapack_int* ldb,
+                   lapack_complex_double* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_chesvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* af, lapack_int* ldaf,
+                    lapack_int* ipiv, const lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
+                    float* rcond, float* ferr, float* berr,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int *info );
+void LAPACK_zhesvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* af, lapack_int* ldaf,
+                    lapack_int* ipiv, const lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                    double* rcond, double* ferr, double* berr,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int *info );
+void LAPACK_zhesvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                     lapack_complex_double* a, lapack_int* lda,
+                     lapack_complex_double* af, lapack_int* ldaf,
+                     lapack_int* ipiv, char* equed, double* s,
+                     lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                     double* rpvgrw, double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params,
+                     lapack_complex_double* work, double* rwork,
+                     lapack_int *info );
+void LAPACK_chesvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                     lapack_complex_float* a, lapack_int* lda,
+                     lapack_complex_float* af, lapack_int* ldaf,
+                     lapack_int* ipiv, char* equed, float* s,
+                     lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                     float* rpvgrw, float* berr, lapack_int* n_err_bnds,
+                     float* err_bnds_norm, float* err_bnds_comp,
+                     lapack_int* nparams, float* params,
+                     lapack_complex_float* work, float* rwork,
+                     lapack_int *info );
+void LAPACK_sspsv( char* uplo, lapack_int* n, lapack_int* nrhs, float* ap,
+                   lapack_int* ipiv, float* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_dspsv( char* uplo, lapack_int* n, lapack_int* nrhs, double* ap,
+                   lapack_int* ipiv, double* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_cspsv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_float* ap, lapack_int* ipiv,
+                   lapack_complex_float* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_zspsv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_double* ap, lapack_int* ipiv,
+                   lapack_complex_double* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_sspsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const float* ap, float* afp, lapack_int* ipiv,
+                    const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
+                    float* rcond, float* ferr, float* berr, float* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_dspsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* ap, double* afp, lapack_int* ipiv,
+                    const double* b, lapack_int* ldb, double* x,
+                    lapack_int* ldx, double* rcond, double* ferr, double* berr,
+                    double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_cspsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* ap, lapack_complex_float* afp,
+                    lapack_int* ipiv, const lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
+                    float* rcond, float* ferr, float* berr,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zspsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* ap, lapack_complex_double* afp,
+                    lapack_int* ipiv, const lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                    double* rcond, double* ferr, double* berr,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_chpsv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_float* ap, lapack_int* ipiv,
+                   lapack_complex_float* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_zhpsv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_double* ap, lapack_int* ipiv,
+                   lapack_complex_double* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_chpsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* ap, lapack_complex_float* afp,
+                    lapack_int* ipiv, const lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
+                    float* rcond, float* ferr, float* berr,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zhpsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* ap, lapack_complex_double* afp,
+                    lapack_int* ipiv, const lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                    double* rcond, double* ferr, double* berr,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_sgeqrf( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    float* tau, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dgeqrf( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    double* tau, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cgeqrf( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* tau,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zgeqrf( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sgeqpf( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int* jpvt, float* tau, float* work,
+                    lapack_int *info );
+void LAPACK_dgeqpf( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int* jpvt, double* tau, double* work,
+                    lapack_int *info );
+void LAPACK_cgeqpf( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int* jpvt,
+                    lapack_complex_float* tau, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zgeqpf( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* jpvt,
+                    lapack_complex_double* tau, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_sgeqp3( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int* jpvt, float* tau, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dgeqp3( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int* jpvt, double* tau, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cgeqp3( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int* jpvt,
+                    lapack_complex_float* tau, lapack_complex_float* work,
+                    lapack_int* lwork, float* rwork, lapack_int *info );
+void LAPACK_zgeqp3( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* jpvt,
+                    lapack_complex_double* tau, lapack_complex_double* work,
+                    lapack_int* lwork, double* rwork, lapack_int *info );
+void LAPACK_sorgqr( lapack_int* m, lapack_int* n, lapack_int* k, float* a,
+                    lapack_int* lda, const float* tau, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dorgqr( lapack_int* m, lapack_int* n, lapack_int* k, double* a,
+                    lapack_int* lda, const double* tau, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sormqr( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const float* a, lapack_int* lda,
+                    const float* tau, float* c, lapack_int* ldc, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dormqr( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const double* a, lapack_int* lda,
+                    const double* tau, double* c, lapack_int* ldc, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cungqr( lapack_int* m, lapack_int* n, lapack_int* k,
+                    lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* tau, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zungqr( lapack_int* m, lapack_int* n, lapack_int* k,
+                    lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cunmqr( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* tau,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zunmqr( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const lapack_complex_double* a,
+                    lapack_int* lda, const lapack_complex_double* tau,
+                    lapack_complex_double* c, lapack_int* ldc,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sgelqf( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    float* tau, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dgelqf( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    double* tau, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cgelqf( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* tau,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zgelqf( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sorglq( lapack_int* m, lapack_int* n, lapack_int* k, float* a,
+                    lapack_int* lda, const float* tau, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dorglq( lapack_int* m, lapack_int* n, lapack_int* k, double* a,
+                    lapack_int* lda, const double* tau, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sormlq( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const float* a, lapack_int* lda,
+                    const float* tau, float* c, lapack_int* ldc, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dormlq( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const double* a, lapack_int* lda,
+                    const double* tau, double* c, lapack_int* ldc, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cunglq( lapack_int* m, lapack_int* n, lapack_int* k,
+                    lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* tau, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zunglq( lapack_int* m, lapack_int* n, lapack_int* k,
+                    lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cunmlq( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* tau,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zunmlq( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const lapack_complex_double* a,
+                    lapack_int* lda, const lapack_complex_double* tau,
+                    lapack_complex_double* c, lapack_int* ldc,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sgeqlf( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    float* tau, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dgeqlf( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    double* tau, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cgeqlf( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* tau,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zgeqlf( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sorgql( lapack_int* m, lapack_int* n, lapack_int* k, float* a,
+                    lapack_int* lda, const float* tau, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dorgql( lapack_int* m, lapack_int* n, lapack_int* k, double* a,
+                    lapack_int* lda, const double* tau, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cungql( lapack_int* m, lapack_int* n, lapack_int* k,
+                    lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* tau, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zungql( lapack_int* m, lapack_int* n, lapack_int* k,
+                    lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sormql( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const float* a, lapack_int* lda,
+                    const float* tau, float* c, lapack_int* ldc, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dormql( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const double* a, lapack_int* lda,
+                    const double* tau, double* c, lapack_int* ldc, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cunmql( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* tau,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zunmql( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const lapack_complex_double* a,
+                    lapack_int* lda, const lapack_complex_double* tau,
+                    lapack_complex_double* c, lapack_int* ldc,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sgerqf( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    float* tau, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dgerqf( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    double* tau, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cgerqf( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* tau,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zgerqf( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sorgrq( lapack_int* m, lapack_int* n, lapack_int* k, float* a,
+                    lapack_int* lda, const float* tau, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dorgrq( lapack_int* m, lapack_int* n, lapack_int* k, double* a,
+                    lapack_int* lda, const double* tau, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cungrq( lapack_int* m, lapack_int* n, lapack_int* k,
+                    lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* tau, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zungrq( lapack_int* m, lapack_int* n, lapack_int* k,
+                    lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sormrq( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const float* a, lapack_int* lda,
+                    const float* tau, float* c, lapack_int* ldc, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dormrq( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const double* a, lapack_int* lda,
+                    const double* tau, double* c, lapack_int* ldc, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cunmrq( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* tau,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zunmrq( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const lapack_complex_double* a,
+                    lapack_int* lda, const lapack_complex_double* tau,
+                    lapack_complex_double* c, lapack_int* ldc,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_stzrzf( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    float* tau, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dtzrzf( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    double* tau, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_ctzrzf( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* tau,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_ztzrzf( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sormrz( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, lapack_int* l, const float* a,
+                    lapack_int* lda, const float* tau, float* c,
+                    lapack_int* ldc, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dormrz( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, lapack_int* l, const double* a,
+                    lapack_int* lda, const double* tau, double* c,
+                    lapack_int* ldc, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cunmrz( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, lapack_int* l, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* tau,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zunmrz( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, lapack_int* l,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* tau, lapack_complex_double* c,
+                    lapack_int* ldc, lapack_complex_double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sggqrf( lapack_int* n, lapack_int* m, lapack_int* p, float* a,
+                    lapack_int* lda, float* taua, float* b, lapack_int* ldb,
+                    float* taub, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dggqrf( lapack_int* n, lapack_int* m, lapack_int* p, double* a,
+                    lapack_int* lda, double* taua, double* b, lapack_int* ldb,
+                    double* taub, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cggqrf( lapack_int* n, lapack_int* m, lapack_int* p,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* taua, lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* taub,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zggqrf( lapack_int* n, lapack_int* m, lapack_int* p,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* taua, lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* taub,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sggrqf( lapack_int* m, lapack_int* p, lapack_int* n, float* a,
+                    lapack_int* lda, float* taua, float* b, lapack_int* ldb,
+                    float* taub, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dggrqf( lapack_int* m, lapack_int* p, lapack_int* n, double* a,
+                    lapack_int* lda, double* taua, double* b, lapack_int* ldb,
+                    double* taub, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cggrqf( lapack_int* m, lapack_int* p, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* taua, lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* taub,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zggrqf( lapack_int* m, lapack_int* p, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* taua, lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* taub,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sgebrd( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    float* d, float* e, float* tauq, float* taup, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dgebrd( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    double* d, double* e, double* tauq, double* taup,
+                    double* work, lapack_int* lwork, lapack_int *info );
+void LAPACK_cgebrd( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, float* d, float* e,
+                    lapack_complex_float* tauq, lapack_complex_float* taup,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zgebrd( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, double* d, double* e,
+                    lapack_complex_double* tauq, lapack_complex_double* taup,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sgbbrd( char* vect, lapack_int* m, lapack_int* n, lapack_int* ncc,
+                    lapack_int* kl, lapack_int* ku, float* ab, lapack_int* ldab,
+                    float* d, float* e, float* q, lapack_int* ldq, float* pt,
+                    lapack_int* ldpt, float* c, lapack_int* ldc, float* work,
+                    lapack_int *info );
+void LAPACK_dgbbrd( char* vect, lapack_int* m, lapack_int* n, lapack_int* ncc,
+                    lapack_int* kl, lapack_int* ku, double* ab,
+                    lapack_int* ldab, double* d, double* e, double* q,
+                    lapack_int* ldq, double* pt, lapack_int* ldpt, double* c,
+                    lapack_int* ldc, double* work, lapack_int *info );
+void LAPACK_cgbbrd( char* vect, lapack_int* m, lapack_int* n, lapack_int* ncc,
+                    lapack_int* kl, lapack_int* ku, lapack_complex_float* ab,
+                    lapack_int* ldab, float* d, float* e,
+                    lapack_complex_float* q, lapack_int* ldq,
+                    lapack_complex_float* pt, lapack_int* ldpt,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zgbbrd( char* vect, lapack_int* m, lapack_int* n, lapack_int* ncc,
+                    lapack_int* kl, lapack_int* ku, lapack_complex_double* ab,
+                    lapack_int* ldab, double* d, double* e,
+                    lapack_complex_double* q, lapack_int* ldq,
+                    lapack_complex_double* pt, lapack_int* ldpt,
+                    lapack_complex_double* c, lapack_int* ldc,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_sorgbr( char* vect, lapack_int* m, lapack_int* n, lapack_int* k,
+                    float* a, lapack_int* lda, const float* tau, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dorgbr( char* vect, lapack_int* m, lapack_int* n, lapack_int* k,
+                    double* a, lapack_int* lda, const double* tau, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sormbr( char* vect, char* side, char* trans, lapack_int* m,
+                    lapack_int* n, lapack_int* k, const float* a,
+                    lapack_int* lda, const float* tau, float* c,
+                    lapack_int* ldc, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dormbr( char* vect, char* side, char* trans, lapack_int* m,
+                    lapack_int* n, lapack_int* k, const double* a,
+                    lapack_int* lda, const double* tau, double* c,
+                    lapack_int* ldc, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cungbr( char* vect, lapack_int* m, lapack_int* n, lapack_int* k,
+                    lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* tau, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zungbr( char* vect, lapack_int* m, lapack_int* n, lapack_int* k,
+                    lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cunmbr( char* vect, char* side, char* trans, lapack_int* m,
+                    lapack_int* n, lapack_int* k, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* tau,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zunmbr( char* vect, char* side, char* trans, lapack_int* m,
+                    lapack_int* n, lapack_int* k,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* tau, lapack_complex_double* c,
+                    lapack_int* ldc, lapack_complex_double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sbdsqr( char* uplo, lapack_int* n, lapack_int* ncvt,
+                    lapack_int* nru, lapack_int* ncc, float* d, float* e,
+                    float* vt, lapack_int* ldvt, float* u, lapack_int* ldu,
+                    float* c, lapack_int* ldc, float* work, lapack_int *info );
+void LAPACK_dbdsqr( char* uplo, lapack_int* n, lapack_int* ncvt,
+                    lapack_int* nru, lapack_int* ncc, double* d, double* e,
+                    double* vt, lapack_int* ldvt, double* u, lapack_int* ldu,
+                    double* c, lapack_int* ldc, double* work,
+                    lapack_int *info );
+void LAPACK_cbdsqr( char* uplo, lapack_int* n, lapack_int* ncvt,
+                    lapack_int* nru, lapack_int* ncc, float* d, float* e,
+                    lapack_complex_float* vt, lapack_int* ldvt,
+                    lapack_complex_float* u, lapack_int* ldu,
+                    lapack_complex_float* c, lapack_int* ldc, float* work,
+                    lapack_int *info );
+void LAPACK_zbdsqr( char* uplo, lapack_int* n, lapack_int* ncvt,
+                    lapack_int* nru, lapack_int* ncc, double* d, double* e,
+                    lapack_complex_double* vt, lapack_int* ldvt,
+                    lapack_complex_double* u, lapack_int* ldu,
+                    lapack_complex_double* c, lapack_int* ldc, double* work,
+                    lapack_int *info );
+void LAPACK_sbdsdc( char* uplo, char* compq, lapack_int* n, float* d, float* e,
+                    float* u, lapack_int* ldu, float* vt, lapack_int* ldvt,
+                    float* q, lapack_int* iq, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dbdsdc( char* uplo, char* compq, lapack_int* n, double* d,
+                    double* e, double* u, lapack_int* ldu, double* vt,
+                    lapack_int* ldvt, double* q, lapack_int* iq, double* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_ssytrd( char* uplo, lapack_int* n, float* a, lapack_int* lda,
+                    float* d, float* e, float* tau, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dsytrd( char* uplo, lapack_int* n, double* a, lapack_int* lda,
+                    double* d, double* e, double* tau, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sorgtr( char* uplo, lapack_int* n, float* a, lapack_int* lda,
+                    const float* tau, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dorgtr( char* uplo, lapack_int* n, double* a, lapack_int* lda,
+                    const double* tau, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sormtr( char* side, char* uplo, char* trans, lapack_int* m,
+                    lapack_int* n, const float* a, lapack_int* lda,
+                    const float* tau, float* c, lapack_int* ldc, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dormtr( char* side, char* uplo, char* trans, lapack_int* m,
+                    lapack_int* n, const double* a, lapack_int* lda,
+                    const double* tau, double* c, lapack_int* ldc, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_chetrd( char* uplo, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, float* d, float* e,
+                    lapack_complex_float* tau, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zhetrd( char* uplo, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, double* d, double* e,
+                    lapack_complex_double* tau, lapack_complex_double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cungtr( char* uplo, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* tau,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zungtr( char* uplo, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, const lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cunmtr( char* side, char* uplo, char* trans, lapack_int* m,
+                    lapack_int* n, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* tau,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zunmtr( char* side, char* uplo, char* trans, lapack_int* m,
+                    lapack_int* n, const lapack_complex_double* a,
+                    lapack_int* lda, const lapack_complex_double* tau,
+                    lapack_complex_double* c, lapack_int* ldc,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_ssptrd( char* uplo, lapack_int* n, float* ap, float* d, float* e,
+                    float* tau, lapack_int *info );
+void LAPACK_dsptrd( char* uplo, lapack_int* n, double* ap, double* d, double* e,
+                    double* tau, lapack_int *info );
+void LAPACK_sopgtr( char* uplo, lapack_int* n, const float* ap,
+                    const float* tau, float* q, lapack_int* ldq, float* work,
+                    lapack_int *info );
+void LAPACK_dopgtr( char* uplo, lapack_int* n, const double* ap,
+                    const double* tau, double* q, lapack_int* ldq, double* work,
+                    lapack_int *info );
+void LAPACK_sopmtr( char* side, char* uplo, char* trans, lapack_int* m,
+                    lapack_int* n, const float* ap, const float* tau, float* c,
+                    lapack_int* ldc, float* work, lapack_int *info );
+void LAPACK_dopmtr( char* side, char* uplo, char* trans, lapack_int* m,
+                    lapack_int* n, const double* ap, const double* tau,
+                    double* c, lapack_int* ldc, double* work,
+                    lapack_int *info );
+void LAPACK_chptrd( char* uplo, lapack_int* n, lapack_complex_float* ap,
+                    float* d, float* e, lapack_complex_float* tau,
+                    lapack_int *info );
+void LAPACK_zhptrd( char* uplo, lapack_int* n, lapack_complex_double* ap,
+                    double* d, double* e, lapack_complex_double* tau,
+                    lapack_int *info );
+void LAPACK_cupgtr( char* uplo, lapack_int* n, const lapack_complex_float* ap,
+                    const lapack_complex_float* tau, lapack_complex_float* q,
+                    lapack_int* ldq, lapack_complex_float* work,
+                    lapack_int *info );
+void LAPACK_zupgtr( char* uplo, lapack_int* n, const lapack_complex_double* ap,
+                    const lapack_complex_double* tau, lapack_complex_double* q,
+                    lapack_int* ldq, lapack_complex_double* work,
+                    lapack_int *info );
+void LAPACK_cupmtr( char* side, char* uplo, char* trans, lapack_int* m,
+                    lapack_int* n, const lapack_complex_float* ap,
+                    const lapack_complex_float* tau, lapack_complex_float* c,
+                    lapack_int* ldc, lapack_complex_float* work,
+                    lapack_int *info );
+void LAPACK_zupmtr( char* side, char* uplo, char* trans, lapack_int* m,
+                    lapack_int* n, const lapack_complex_double* ap,
+                    const lapack_complex_double* tau, lapack_complex_double* c,
+                    lapack_int* ldc, lapack_complex_double* work,
+                    lapack_int *info );
+void LAPACK_ssbtrd( char* vect, char* uplo, lapack_int* n, lapack_int* kd,
+                    float* ab, lapack_int* ldab, float* d, float* e, float* q,
+                    lapack_int* ldq, float* work, lapack_int *info );
+void LAPACK_dsbtrd( char* vect, char* uplo, lapack_int* n, lapack_int* kd,
+                    double* ab, lapack_int* ldab, double* d, double* e,
+                    double* q, lapack_int* ldq, double* work,
+                    lapack_int *info );
+void LAPACK_chbtrd( char* vect, char* uplo, lapack_int* n, lapack_int* kd,
+                    lapack_complex_float* ab, lapack_int* ldab, float* d,
+                    float* e, lapack_complex_float* q, lapack_int* ldq,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zhbtrd( char* vect, char* uplo, lapack_int* n, lapack_int* kd,
+                    lapack_complex_double* ab, lapack_int* ldab, double* d,
+                    double* e, lapack_complex_double* q, lapack_int* ldq,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_ssterf( lapack_int* n, float* d, float* e, lapack_int *info );
+void LAPACK_dsterf( lapack_int* n, double* d, double* e, lapack_int *info );
+void LAPACK_ssteqr( char* compz, lapack_int* n, float* d, float* e, float* z,
+                    lapack_int* ldz, float* work, lapack_int *info );
+void LAPACK_dsteqr( char* compz, lapack_int* n, double* d, double* e, double* z,
+                    lapack_int* ldz, double* work, lapack_int *info );
+void LAPACK_csteqr( char* compz, lapack_int* n, float* d, float* e,
+                    lapack_complex_float* z, lapack_int* ldz, float* work,
+                    lapack_int *info );
+void LAPACK_zsteqr( char* compz, lapack_int* n, double* d, double* e,
+                    lapack_complex_double* z, lapack_int* ldz, double* work,
+                    lapack_int *info );
+void LAPACK_sstemr( char* jobz, char* range, lapack_int* n, float* d, float* e,
+                    float* vl, float* vu, lapack_int* il, lapack_int* iu,
+                    lapack_int* m, float* w, float* z, lapack_int* ldz,
+                    lapack_int* nzc, lapack_int* isuppz, lapack_logical* tryrac,
+                    float* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_dstemr( char* jobz, char* range, lapack_int* n, double* d,
+                    double* e, double* vl, double* vu, lapack_int* il,
+                    lapack_int* iu, lapack_int* m, double* w, double* z,
+                    lapack_int* ldz, lapack_int* nzc, lapack_int* isuppz,
+                    lapack_logical* tryrac, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_cstemr( char* jobz, char* range, lapack_int* n, float* d, float* e,
+                    float* vl, float* vu, lapack_int* il, lapack_int* iu,
+                    lapack_int* m, float* w, lapack_complex_float* z,
+                    lapack_int* ldz, lapack_int* nzc, lapack_int* isuppz,
+                    lapack_logical* tryrac, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_zstemr( char* jobz, char* range, lapack_int* n, double* d,
+                    double* e, double* vl, double* vu, lapack_int* il,
+                    lapack_int* iu, lapack_int* m, double* w,
+                    lapack_complex_double* z, lapack_int* ldz, lapack_int* nzc,
+                    lapack_int* isuppz, lapack_logical* tryrac, double* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_sstedc( char* compz, lapack_int* n, float* d, float* e, float* z,
+                    lapack_int* ldz, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_dstedc( char* compz, lapack_int* n, double* d, double* e, double* z,
+                    lapack_int* ldz, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_cstedc( char* compz, lapack_int* n, float* d, float* e,
+                    lapack_complex_float* z, lapack_int* ldz,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_zstedc( char* compz, lapack_int* n, double* d, double* e,
+                    lapack_complex_double* z, lapack_int* ldz,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* lrwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_sstegr( char* jobz, char* range, lapack_int* n, float* d, float* e,
+                    float* vl, float* vu, lapack_int* il, lapack_int* iu,
+                    float* abstol, lapack_int* m, float* w, float* z,
+                    lapack_int* ldz, lapack_int* isuppz, float* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_dstegr( char* jobz, char* range, lapack_int* n, double* d,
+                    double* e, double* vl, double* vu, lapack_int* il,
+                    lapack_int* iu, double* abstol, lapack_int* m, double* w,
+                    double* z, lapack_int* ldz, lapack_int* isuppz,
+                    double* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_cstegr( char* jobz, char* range, lapack_int* n, float* d, float* e,
+                    float* vl, float* vu, lapack_int* il, lapack_int* iu,
+                    float* abstol, lapack_int* m, float* w,
+                    lapack_complex_float* z, lapack_int* ldz,
+                    lapack_int* isuppz, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_zstegr( char* jobz, char* range, lapack_int* n, double* d,
+                    double* e, double* vl, double* vu, lapack_int* il,
+                    lapack_int* iu, double* abstol, lapack_int* m, double* w,
+                    lapack_complex_double* z, lapack_int* ldz,
+                    lapack_int* isuppz, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_spteqr( char* compz, lapack_int* n, float* d, float* e, float* z,
+                    lapack_int* ldz, float* work, lapack_int *info );
+void LAPACK_dpteqr( char* compz, lapack_int* n, double* d, double* e, double* z,
+                    lapack_int* ldz, double* work, lapack_int *info );
+void LAPACK_cpteqr( char* compz, lapack_int* n, float* d, float* e,
+                    lapack_complex_float* z, lapack_int* ldz, float* work,
+                    lapack_int *info );
+void LAPACK_zpteqr( char* compz, lapack_int* n, double* d, double* e,
+                    lapack_complex_double* z, lapack_int* ldz, double* work,
+                    lapack_int *info );
+void LAPACK_sstebz( char* range, char* order, lapack_int* n, float* vl,
+                    float* vu, lapack_int* il, lapack_int* iu, float* abstol,
+                    const float* d, const float* e, lapack_int* m,
+                    lapack_int* nsplit, float* w, lapack_int* iblock,
+                    lapack_int* isplit, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dstebz( char* range, char* order, lapack_int* n, double* vl,
+                    double* vu, lapack_int* il, lapack_int* iu, double* abstol,
+                    const double* d, const double* e, lapack_int* m,
+                    lapack_int* nsplit, double* w, lapack_int* iblock,
+                    lapack_int* isplit, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_sstein( lapack_int* n, const float* d, const float* e,
+                    lapack_int* m, const float* w, const lapack_int* iblock,
+                    const lapack_int* isplit, float* z, lapack_int* ldz,
+                    float* work, lapack_int* iwork, lapack_int* ifailv,
+                    lapack_int *info );
+void LAPACK_dstein( lapack_int* n, const double* d, const double* e,
+                    lapack_int* m, const double* w, const lapack_int* iblock,
+                    const lapack_int* isplit, double* z, lapack_int* ldz,
+                    double* work, lapack_int* iwork, lapack_int* ifailv,
+                    lapack_int *info );
+void LAPACK_cstein( lapack_int* n, const float* d, const float* e,
+                    lapack_int* m, const float* w, const lapack_int* iblock,
+                    const lapack_int* isplit, lapack_complex_float* z,
+                    lapack_int* ldz, float* work, lapack_int* iwork,
+                    lapack_int* ifailv, lapack_int *info );
+void LAPACK_zstein( lapack_int* n, const double* d, const double* e,
+                    lapack_int* m, const double* w, const lapack_int* iblock,
+                    const lapack_int* isplit, lapack_complex_double* z,
+                    lapack_int* ldz, double* work, lapack_int* iwork,
+                    lapack_int* ifailv, lapack_int *info );
+void LAPACK_sdisna( char* job, lapack_int* m, lapack_int* n, const float* d,
+                    float* sep, lapack_int *info );
+void LAPACK_ddisna( char* job, lapack_int* m, lapack_int* n, const double* d,
+                    double* sep, lapack_int *info );
+void LAPACK_ssygst( lapack_int* itype, char* uplo, lapack_int* n, float* a,
+                    lapack_int* lda, const float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_dsygst( lapack_int* itype, char* uplo, lapack_int* n, double* a,
+                    lapack_int* lda, const double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_chegst( lapack_int* itype, char* uplo, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_zhegst( lapack_int* itype, char* uplo, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_sspgst( lapack_int* itype, char* uplo, lapack_int* n, float* ap,
+                    const float* bp, lapack_int *info );
+void LAPACK_dspgst( lapack_int* itype, char* uplo, lapack_int* n, double* ap,
+                    const double* bp, lapack_int *info );
+void LAPACK_chpgst( lapack_int* itype, char* uplo, lapack_int* n,
+                    lapack_complex_float* ap, const lapack_complex_float* bp,
+                    lapack_int *info );
+void LAPACK_zhpgst( lapack_int* itype, char* uplo, lapack_int* n,
+                    lapack_complex_double* ap, const lapack_complex_double* bp,
+                    lapack_int *info );
+void LAPACK_ssbgst( char* vect, char* uplo, lapack_int* n, lapack_int* ka,
+                    lapack_int* kb, float* ab, lapack_int* ldab,
+                    const float* bb, lapack_int* ldbb, float* x,
+                    lapack_int* ldx, float* work, lapack_int *info );
+void LAPACK_dsbgst( char* vect, char* uplo, lapack_int* n, lapack_int* ka,
+                    lapack_int* kb, double* ab, lapack_int* ldab,
+                    const double* bb, lapack_int* ldbb, double* x,
+                    lapack_int* ldx, double* work, lapack_int *info );
+void LAPACK_chbgst( char* vect, char* uplo, lapack_int* n, lapack_int* ka,
+                    lapack_int* kb, lapack_complex_float* ab, lapack_int* ldab,
+                    const lapack_complex_float* bb, lapack_int* ldbb,
+                    lapack_complex_float* x, lapack_int* ldx,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zhbgst( char* vect, char* uplo, lapack_int* n, lapack_int* ka,
+                    lapack_int* kb, lapack_complex_double* ab, lapack_int* ldab,
+                    const lapack_complex_double* bb, lapack_int* ldbb,
+                    lapack_complex_double* x, lapack_int* ldx,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_spbstf( char* uplo, lapack_int* n, lapack_int* kb, float* bb,
+                    lapack_int* ldbb, lapack_int *info );
+void LAPACK_dpbstf( char* uplo, lapack_int* n, lapack_int* kb, double* bb,
+                    lapack_int* ldbb, lapack_int *info );
+void LAPACK_cpbstf( char* uplo, lapack_int* n, lapack_int* kb,
+                    lapack_complex_float* bb, lapack_int* ldbb,
+                    lapack_int *info );
+void LAPACK_zpbstf( char* uplo, lapack_int* n, lapack_int* kb,
+                    lapack_complex_double* bb, lapack_int* ldbb,
+                    lapack_int *info );
+void LAPACK_sgehrd( lapack_int* n, lapack_int* ilo, lapack_int* ihi, float* a,
+                    lapack_int* lda, float* tau, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dgehrd( lapack_int* n, lapack_int* ilo, lapack_int* ihi, double* a,
+                    lapack_int* lda, double* tau, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cgehrd( lapack_int* n, lapack_int* ilo, lapack_int* ihi,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* tau, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zgehrd( lapack_int* n, lapack_int* ilo, lapack_int* ihi,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* tau, lapack_complex_double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sorghr( lapack_int* n, lapack_int* ilo, lapack_int* ihi, float* a,
+                    lapack_int* lda, const float* tau, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dorghr( lapack_int* n, lapack_int* ilo, lapack_int* ihi, double* a,
+                    lapack_int* lda, const double* tau, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sormhr( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* ilo, lapack_int* ihi, const float* a,
+                    lapack_int* lda, const float* tau, float* c,
+                    lapack_int* ldc, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dormhr( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* ilo, lapack_int* ihi, const double* a,
+                    lapack_int* lda, const double* tau, double* c,
+                    lapack_int* ldc, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cunghr( lapack_int* n, lapack_int* ilo, lapack_int* ihi,
+                    lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* tau, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zunghr( lapack_int* n, lapack_int* ilo, lapack_int* ihi,
+                    lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cunmhr( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* ilo, lapack_int* ihi,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* tau, lapack_complex_float* c,
+                    lapack_int* ldc, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zunmhr( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* ilo, lapack_int* ihi,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* tau, lapack_complex_double* c,
+                    lapack_int* ldc, lapack_complex_double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sgebal( char* job, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int* ilo, lapack_int* ihi, float* scale,
+                    lapack_int *info );
+void LAPACK_dgebal( char* job, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int* ilo, lapack_int* ihi, double* scale,
+                    lapack_int *info );
+void LAPACK_cgebal( char* job, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int* ilo, lapack_int* ihi,
+                    float* scale, lapack_int *info );
+void LAPACK_zgebal( char* job, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* ilo, lapack_int* ihi,
+                    double* scale, lapack_int *info );
+void LAPACK_sgebak( char* job, char* side, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, const float* scale, lapack_int* m,
+                    float* v, lapack_int* ldv, lapack_int *info );
+void LAPACK_dgebak( char* job, char* side, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, const double* scale, lapack_int* m,
+                    double* v, lapack_int* ldv, lapack_int *info );
+void LAPACK_cgebak( char* job, char* side, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, const float* scale, lapack_int* m,
+                    lapack_complex_float* v, lapack_int* ldv,
+                    lapack_int *info );
+void LAPACK_zgebak( char* job, char* side, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, const double* scale, lapack_int* m,
+                    lapack_complex_double* v, lapack_int* ldv,
+                    lapack_int *info );
+void LAPACK_shseqr( char* job, char* compz, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, float* h, lapack_int* ldh, float* wr,
+                    float* wi, float* z, lapack_int* ldz, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dhseqr( char* job, char* compz, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, double* h, lapack_int* ldh, double* wr,
+                    double* wi, double* z, lapack_int* ldz, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_chseqr( char* job, char* compz, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, lapack_complex_float* h, lapack_int* ldh,
+                    lapack_complex_float* w, lapack_complex_float* z,
+                    lapack_int* ldz, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zhseqr( char* job, char* compz, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, lapack_complex_double* h, lapack_int* ldh,
+                    lapack_complex_double* w, lapack_complex_double* z,
+                    lapack_int* ldz, lapack_complex_double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_shsein( char* job, char* eigsrc, char* initv,
+                    lapack_logical* select, lapack_int* n, const float* h,
+                    lapack_int* ldh, float* wr, const float* wi, float* vl,
+                    lapack_int* ldvl, float* vr, lapack_int* ldvr,
+                    lapack_int* mm, lapack_int* m, float* work,
+                    lapack_int* ifaill, lapack_int* ifailr, lapack_int *info );
+void LAPACK_dhsein( char* job, char* eigsrc, char* initv,
+                    lapack_logical* select, lapack_int* n, const double* h,
+                    lapack_int* ldh, double* wr, const double* wi, double* vl,
+                    lapack_int* ldvl, double* vr, lapack_int* ldvr,
+                    lapack_int* mm, lapack_int* m, double* work,
+                    lapack_int* ifaill, lapack_int* ifailr, lapack_int *info );
+void LAPACK_chsein( char* job, char* eigsrc, char* initv,
+                    const lapack_logical* select, lapack_int* n,
+                    const lapack_complex_float* h, lapack_int* ldh,
+                    lapack_complex_float* w, lapack_complex_float* vl,
+                    lapack_int* ldvl, lapack_complex_float* vr,
+                    lapack_int* ldvr, lapack_int* mm, lapack_int* m,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int* ifaill, lapack_int* ifailr, lapack_int *info );
+void LAPACK_zhsein( char* job, char* eigsrc, char* initv,
+                    const lapack_logical* select, lapack_int* n,
+                    const lapack_complex_double* h, lapack_int* ldh,
+                    lapack_complex_double* w, lapack_complex_double* vl,
+                    lapack_int* ldvl, lapack_complex_double* vr,
+                    lapack_int* ldvr, lapack_int* mm, lapack_int* m,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int* ifaill, lapack_int* ifailr, lapack_int *info );
+void LAPACK_strevc( char* side, char* howmny, lapack_logical* select,
+                    lapack_int* n, const float* t, lapack_int* ldt, float* vl,
+                    lapack_int* ldvl, float* vr, lapack_int* ldvr,
+                    lapack_int* mm, lapack_int* m, float* work,
+                    lapack_int *info );
+void LAPACK_dtrevc( char* side, char* howmny, lapack_logical* select,
+                    lapack_int* n, const double* t, lapack_int* ldt, double* vl,
+                    lapack_int* ldvl, double* vr, lapack_int* ldvr,
+                    lapack_int* mm, lapack_int* m, double* work,
+                    lapack_int *info );
+void LAPACK_ctrevc( char* side, char* howmny, const lapack_logical* select,
+                    lapack_int* n, lapack_complex_float* t, lapack_int* ldt,
+                    lapack_complex_float* vl, lapack_int* ldvl,
+                    lapack_complex_float* vr, lapack_int* ldvr, lapack_int* mm,
+                    lapack_int* m, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_ztrevc( char* side, char* howmny, const lapack_logical* select,
+                    lapack_int* n, lapack_complex_double* t, lapack_int* ldt,
+                    lapack_complex_double* vl, lapack_int* ldvl,
+                    lapack_complex_double* vr, lapack_int* ldvr, lapack_int* mm,
+                    lapack_int* m, lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_strsna( char* job, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const float* t, lapack_int* ldt,
+                    const float* vl, lapack_int* ldvl, const float* vr,
+                    lapack_int* ldvr, float* s, float* sep, lapack_int* mm,
+                    lapack_int* m, float* work, lapack_int* ldwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_dtrsna( char* job, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const double* t, lapack_int* ldt,
+                    const double* vl, lapack_int* ldvl, const double* vr,
+                    lapack_int* ldvr, double* s, double* sep, lapack_int* mm,
+                    lapack_int* m, double* work, lapack_int* ldwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_ctrsna( char* job, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const lapack_complex_float* t,
+                    lapack_int* ldt, const lapack_complex_float* vl,
+                    lapack_int* ldvl, const lapack_complex_float* vr,
+                    lapack_int* ldvr, float* s, float* sep, lapack_int* mm,
+                    lapack_int* m, lapack_complex_float* work,
+                    lapack_int* ldwork, float* rwork, lapack_int *info );
+void LAPACK_ztrsna( char* job, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const lapack_complex_double* t,
+                    lapack_int* ldt, const lapack_complex_double* vl,
+                    lapack_int* ldvl, const lapack_complex_double* vr,
+                    lapack_int* ldvr, double* s, double* sep, lapack_int* mm,
+                    lapack_int* m, lapack_complex_double* work,
+                    lapack_int* ldwork, double* rwork, lapack_int *info );
+void LAPACK_strexc( char* compq, lapack_int* n, float* t, lapack_int* ldt,
+                    float* q, lapack_int* ldq, lapack_int* ifst,
+                    lapack_int* ilst, float* work, lapack_int *info );
+void LAPACK_dtrexc( char* compq, lapack_int* n, double* t, lapack_int* ldt,
+                    double* q, lapack_int* ldq, lapack_int* ifst,
+                    lapack_int* ilst, double* work, lapack_int *info );
+void LAPACK_ctrexc( char* compq, lapack_int* n, lapack_complex_float* t,
+                    lapack_int* ldt, lapack_complex_float* q, lapack_int* ldq,
+                    lapack_int* ifst, lapack_int* ilst, lapack_int *info );
+void LAPACK_ztrexc( char* compq, lapack_int* n, lapack_complex_double* t,
+                    lapack_int* ldt, lapack_complex_double* q, lapack_int* ldq,
+                    lapack_int* ifst, lapack_int* ilst, lapack_int *info );
+void LAPACK_strsen( char* job, char* compq, const lapack_logical* select,
+                    lapack_int* n, float* t, lapack_int* ldt, float* q,
+                    lapack_int* ldq, float* wr, float* wi, lapack_int* m,
+                    float* s, float* sep, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_dtrsen( char* job, char* compq, const lapack_logical* select,
+                    lapack_int* n, double* t, lapack_int* ldt, double* q,
+                    lapack_int* ldq, double* wr, double* wi, lapack_int* m,
+                    double* s, double* sep, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_ctrsen( char* job, char* compq, const lapack_logical* select,
+                    lapack_int* n, lapack_complex_float* t, lapack_int* ldt,
+                    lapack_complex_float* q, lapack_int* ldq,
+                    lapack_complex_float* w, lapack_int* m, float* s,
+                    float* sep, lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_ztrsen( char* job, char* compq, const lapack_logical* select,
+                    lapack_int* n, lapack_complex_double* t, lapack_int* ldt,
+                    lapack_complex_double* q, lapack_int* ldq,
+                    lapack_complex_double* w, lapack_int* m, double* s,
+                    double* sep, lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_strsyl( char* trana, char* tranb, lapack_int* isgn, lapack_int* m,
+                    lapack_int* n, const float* a, lapack_int* lda,
+                    const float* b, lapack_int* ldb, float* c, lapack_int* ldc,
+                    float* scale, lapack_int *info );
+void LAPACK_dtrsyl( char* trana, char* tranb, lapack_int* isgn, lapack_int* m,
+                    lapack_int* n, const double* a, lapack_int* lda,
+                    const double* b, lapack_int* ldb, double* c,
+                    lapack_int* ldc, double* scale, lapack_int *info );
+void LAPACK_ctrsyl( char* trana, char* tranb, lapack_int* isgn, lapack_int* m,
+                    lapack_int* n, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* c, lapack_int* ldc,
+                    float* scale, lapack_int *info );
+void LAPACK_ztrsyl( char* trana, char* tranb, lapack_int* isgn, lapack_int* m,
+                    lapack_int* n, const lapack_complex_double* a,
+                    lapack_int* lda, const lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* c, lapack_int* ldc,
+                    double* scale, lapack_int *info );
+void LAPACK_sgghrd( char* compq, char* compz, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, float* a, lapack_int* lda, float* b,
+                    lapack_int* ldb, float* q, lapack_int* ldq, float* z,
+                    lapack_int* ldz, lapack_int *info );
+void LAPACK_dgghrd( char* compq, char* compz, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, double* a, lapack_int* lda, double* b,
+                    lapack_int* ldb, double* q, lapack_int* ldq, double* z,
+                    lapack_int* ldz, lapack_int *info );
+void LAPACK_cgghrd( char* compq, char* compz, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* q, lapack_int* ldq,
+                    lapack_complex_float* z, lapack_int* ldz,
+                    lapack_int *info );
+void LAPACK_zgghrd( char* compq, char* compz, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* q, lapack_int* ldq,
+                    lapack_complex_double* z, lapack_int* ldz,
+                    lapack_int *info );
+void LAPACK_sggbal( char* job, lapack_int* n, float* a, lapack_int* lda,
+                    float* b, lapack_int* ldb, lapack_int* ilo, lapack_int* ihi,
+                    float* lscale, float* rscale, float* work,
+                    lapack_int *info );
+void LAPACK_dggbal( char* job, lapack_int* n, double* a, lapack_int* lda,
+                    double* b, lapack_int* ldb, lapack_int* ilo,
+                    lapack_int* ihi, double* lscale, double* rscale,
+                    double* work, lapack_int *info );
+void LAPACK_cggbal( char* job, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int* ilo, lapack_int* ihi, float* lscale,
+                    float* rscale, float* work, lapack_int *info );
+void LAPACK_zggbal( char* job, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int* ilo, lapack_int* ihi, double* lscale,
+                    double* rscale, double* work, lapack_int *info );
+void LAPACK_sggbak( char* job, char* side, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, const float* lscale, const float* rscale,
+                    lapack_int* m, float* v, lapack_int* ldv,
+                    lapack_int *info );
+void LAPACK_dggbak( char* job, char* side, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, const double* lscale, const double* rscale,
+                    lapack_int* m, double* v, lapack_int* ldv,
+                    lapack_int *info );
+void LAPACK_cggbak( char* job, char* side, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, const float* lscale, const float* rscale,
+                    lapack_int* m, lapack_complex_float* v, lapack_int* ldv,
+                    lapack_int *info );
+void LAPACK_zggbak( char* job, char* side, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, const double* lscale, const double* rscale,
+                    lapack_int* m, lapack_complex_double* v, lapack_int* ldv,
+                    lapack_int *info );
+void LAPACK_shgeqz( char* job, char* compq, char* compz, lapack_int* n,
+                    lapack_int* ilo, lapack_int* ihi, float* h, lapack_int* ldh,
+                    float* t, lapack_int* ldt, float* alphar, float* alphai,
+                    float* beta, float* q, lapack_int* ldq, float* z,
+                    lapack_int* ldz, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dhgeqz( char* job, char* compq, char* compz, lapack_int* n,
+                    lapack_int* ilo, lapack_int* ihi, double* h,
+                    lapack_int* ldh, double* t, lapack_int* ldt, double* alphar,
+                    double* alphai, double* beta, double* q, lapack_int* ldq,
+                    double* z, lapack_int* ldz, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_chgeqz( char* job, char* compq, char* compz, lapack_int* n,
+                    lapack_int* ilo, lapack_int* ihi, lapack_complex_float* h,
+                    lapack_int* ldh, lapack_complex_float* t, lapack_int* ldt,
+                    lapack_complex_float* alpha, lapack_complex_float* beta,
+                    lapack_complex_float* q, lapack_int* ldq,
+                    lapack_complex_float* z, lapack_int* ldz,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int *info );
+void LAPACK_zhgeqz( char* job, char* compq, char* compz, lapack_int* n,
+                    lapack_int* ilo, lapack_int* ihi, lapack_complex_double* h,
+                    lapack_int* ldh, lapack_complex_double* t, lapack_int* ldt,
+                    lapack_complex_double* alpha, lapack_complex_double* beta,
+                    lapack_complex_double* q, lapack_int* ldq,
+                    lapack_complex_double* z, lapack_int* ldz,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int *info );
+void LAPACK_stgevc( char* side, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const float* s, lapack_int* lds,
+                    const float* p, lapack_int* ldp, float* vl,
+                    lapack_int* ldvl, float* vr, lapack_int* ldvr,
+                    lapack_int* mm, lapack_int* m, float* work,
+                    lapack_int *info );
+void LAPACK_dtgevc( char* side, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const double* s, lapack_int* lds,
+                    const double* p, lapack_int* ldp, double* vl,
+                    lapack_int* ldvl, double* vr, lapack_int* ldvr,
+                    lapack_int* mm, lapack_int* m, double* work,
+                    lapack_int *info );
+void LAPACK_ctgevc( char* side, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const lapack_complex_float* s,
+                    lapack_int* lds, const lapack_complex_float* p,
+                    lapack_int* ldp, lapack_complex_float* vl, lapack_int* ldvl,
+                    lapack_complex_float* vr, lapack_int* ldvr, lapack_int* mm,
+                    lapack_int* m, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_ztgevc( char* side, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const lapack_complex_double* s,
+                    lapack_int* lds, const lapack_complex_double* p,
+                    lapack_int* ldp, lapack_complex_double* vl,
+                    lapack_int* ldvl, lapack_complex_double* vr,
+                    lapack_int* ldvr, lapack_int* mm, lapack_int* m,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_stgexc( lapack_logical* wantq, lapack_logical* wantz, lapack_int* n,
+                    float* a, lapack_int* lda, float* b, lapack_int* ldb,
+                    float* q, lapack_int* ldq, float* z, lapack_int* ldz,
+                    lapack_int* ifst, lapack_int* ilst, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dtgexc( lapack_logical* wantq, lapack_logical* wantz, lapack_int* n,
+                    double* a, lapack_int* lda, double* b, lapack_int* ldb,
+                    double* q, lapack_int* ldq, double* z, lapack_int* ldz,
+                    lapack_int* ifst, lapack_int* ilst, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_ctgexc( lapack_logical* wantq, lapack_logical* wantz, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* q, lapack_int* ldq,
+                    lapack_complex_float* z, lapack_int* ldz, lapack_int* ifst,
+                    lapack_int* ilst, lapack_int *info );
+void LAPACK_ztgexc( lapack_logical* wantq, lapack_logical* wantz, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* q, lapack_int* ldq,
+                    lapack_complex_double* z, lapack_int* ldz, lapack_int* ifst,
+                    lapack_int* ilst, lapack_int *info );
+void LAPACK_stgsen( lapack_int* ijob, lapack_logical* wantq,
+                    lapack_logical* wantz, const lapack_logical* select,
+                    lapack_int* n, float* a, lapack_int* lda, float* b,
+                    lapack_int* ldb, float* alphar, float* alphai, float* beta,
+                    float* q, lapack_int* ldq, float* z, lapack_int* ldz,
+                    lapack_int* m, float* pl, float* pr, float* dif,
+                    float* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_dtgsen( lapack_int* ijob, lapack_logical* wantq,
+                    lapack_logical* wantz, const lapack_logical* select,
+                    lapack_int* n, double* a, lapack_int* lda, double* b,
+                    lapack_int* ldb, double* alphar, double* alphai,
+                    double* beta, double* q, lapack_int* ldq, double* z,
+                    lapack_int* ldz, lapack_int* m, double* pl, double* pr,
+                    double* dif, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_ctgsen( lapack_int* ijob, lapack_logical* wantq,
+                    lapack_logical* wantz, const lapack_logical* select,
+                    lapack_int* n, lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* alpha, lapack_complex_float* beta,
+                    lapack_complex_float* q, lapack_int* ldq,
+                    lapack_complex_float* z, lapack_int* ldz, lapack_int* m,
+                    float* pl, float* pr, float* dif,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_ztgsen( lapack_int* ijob, lapack_logical* wantq,
+                    lapack_logical* wantz, const lapack_logical* select,
+                    lapack_int* n, lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* alpha, lapack_complex_double* beta,
+                    lapack_complex_double* q, lapack_int* ldq,
+                    lapack_complex_double* z, lapack_int* ldz, lapack_int* m,
+                    double* pl, double* pr, double* dif,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_stgsyl( char* trans, lapack_int* ijob, lapack_int* m, lapack_int* n,
+                    const float* a, lapack_int* lda, const float* b,
+                    lapack_int* ldb, float* c, lapack_int* ldc, const float* d,
+                    lapack_int* ldd, const float* e, lapack_int* lde, float* f,
+                    lapack_int* ldf, float* scale, float* dif, float* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int *info );
+void LAPACK_dtgsyl( char* trans, lapack_int* ijob, lapack_int* m, lapack_int* n,
+                    const double* a, lapack_int* lda, const double* b,
+                    lapack_int* ldb, double* c, lapack_int* ldc,
+                    const double* d, lapack_int* ldd, const double* e,
+                    lapack_int* lde, double* f, lapack_int* ldf, double* scale,
+                    double* dif, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_ctgsyl( char* trans, lapack_int* ijob, lapack_int* m, lapack_int* n,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    const lapack_complex_float* d, lapack_int* ldd,
+                    const lapack_complex_float* e, lapack_int* lde,
+                    lapack_complex_float* f, lapack_int* ldf, float* scale,
+                    float* dif, lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_ztgsyl( char* trans, lapack_int* ijob, lapack_int* m, lapack_int* n,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* c, lapack_int* ldc,
+                    const lapack_complex_double* d, lapack_int* ldd,
+                    const lapack_complex_double* e, lapack_int* lde,
+                    lapack_complex_double* f, lapack_int* ldf, double* scale,
+                    double* dif, lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_stgsna( char* job, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const float* a, lapack_int* lda,
+                    const float* b, lapack_int* ldb, const float* vl,
+                    lapack_int* ldvl, const float* vr, lapack_int* ldvr,
+                    float* s, float* dif, lapack_int* mm, lapack_int* m,
+                    float* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dtgsna( char* job, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const double* a, lapack_int* lda,
+                    const double* b, lapack_int* ldb, const double* vl,
+                    lapack_int* ldvl, const double* vr, lapack_int* ldvr,
+                    double* s, double* dif, lapack_int* mm, lapack_int* m,
+                    double* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_ctgsna( char* job, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* b,
+                    lapack_int* ldb, const lapack_complex_float* vl,
+                    lapack_int* ldvl, const lapack_complex_float* vr,
+                    lapack_int* ldvr, float* s, float* dif, lapack_int* mm,
+                    lapack_int* m, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int *info );
+void LAPACK_ztgsna( char* job, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const lapack_complex_double* a,
+                    lapack_int* lda, const lapack_complex_double* b,
+                    lapack_int* ldb, const lapack_complex_double* vl,
+                    lapack_int* ldvl, const lapack_complex_double* vr,
+                    lapack_int* ldvr, double* s, double* dif, lapack_int* mm,
+                    lapack_int* m, lapack_complex_double* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int *info );
+void LAPACK_sggsvp( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* p, lapack_int* n, float* a, lapack_int* lda,
+                    float* b, lapack_int* ldb, float* tola, float* tolb,
+                    lapack_int* k, lapack_int* l, float* u, lapack_int* ldu,
+                    float* v, lapack_int* ldv, float* q, lapack_int* ldq,
+                    lapack_int* iwork, float* tau, float* work,
+                    lapack_int *info );
+void LAPACK_dggsvp( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* p, lapack_int* n, double* a, lapack_int* lda,
+                    double* b, lapack_int* ldb, double* tola, double* tolb,
+                    lapack_int* k, lapack_int* l, double* u, lapack_int* ldu,
+                    double* v, lapack_int* ldv, double* q, lapack_int* ldq,
+                    lapack_int* iwork, double* tau, double* work,
+                    lapack_int *info );
+void LAPACK_cggsvp( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* p, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* b, lapack_int* ldb,
+                    float* tola, float* tolb, lapack_int* k, lapack_int* l,
+                    lapack_complex_float* u, lapack_int* ldu,
+                    lapack_complex_float* v, lapack_int* ldv,
+                    lapack_complex_float* q, lapack_int* ldq, lapack_int* iwork,
+                    float* rwork, lapack_complex_float* tau,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zggsvp( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* p, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* b, lapack_int* ldb,
+                    double* tola, double* tolb, lapack_int* k, lapack_int* l,
+                    lapack_complex_double* u, lapack_int* ldu,
+                    lapack_complex_double* v, lapack_int* ldv,
+                    lapack_complex_double* q, lapack_int* ldq,
+                    lapack_int* iwork, double* rwork,
+                    lapack_complex_double* tau, lapack_complex_double* work,
+                    lapack_int *info );
+void LAPACK_stgsja( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* p, lapack_int* n, lapack_int* k, lapack_int* l,
+                    float* a, lapack_int* lda, float* b, lapack_int* ldb,
+                    float* tola, float* tolb, float* alpha, float* beta,
+                    float* u, lapack_int* ldu, float* v, lapack_int* ldv,
+                    float* q, lapack_int* ldq, float* work, lapack_int* ncycle,
+                    lapack_int *info );
+void LAPACK_dtgsja( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* p, lapack_int* n, lapack_int* k, lapack_int* l,
+                    double* a, lapack_int* lda, double* b, lapack_int* ldb,
+                    double* tola, double* tolb, double* alpha, double* beta,
+                    double* u, lapack_int* ldu, double* v, lapack_int* ldv,
+                    double* q, lapack_int* ldq, double* work,
+                    lapack_int* ncycle, lapack_int *info );
+void LAPACK_ctgsja( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* p, lapack_int* n, lapack_int* k, lapack_int* l,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb, float* tola,
+                    float* tolb, float* alpha, float* beta,
+                    lapack_complex_float* u, lapack_int* ldu,
+                    lapack_complex_float* v, lapack_int* ldv,
+                    lapack_complex_float* q, lapack_int* ldq,
+                    lapack_complex_float* work, lapack_int* ncycle,
+                    lapack_int *info );
+void LAPACK_ztgsja( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* p, lapack_int* n, lapack_int* k, lapack_int* l,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb, double* tola,
+                    double* tolb, double* alpha, double* beta,
+                    lapack_complex_double* u, lapack_int* ldu,
+                    lapack_complex_double* v, lapack_int* ldv,
+                    lapack_complex_double* q, lapack_int* ldq,
+                    lapack_complex_double* work, lapack_int* ncycle,
+                    lapack_int *info );
+void LAPACK_sgels( char* trans, lapack_int* m, lapack_int* n, lapack_int* nrhs,
+                   float* a, lapack_int* lda, float* b, lapack_int* ldb,
+                   float* work, lapack_int* lwork, lapack_int *info );
+void LAPACK_dgels( char* trans, lapack_int* m, lapack_int* n, lapack_int* nrhs,
+                   double* a, lapack_int* lda, double* b, lapack_int* ldb,
+                   double* work, lapack_int* lwork, lapack_int *info );
+void LAPACK_cgels( char* trans, lapack_int* m, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_float* a, lapack_int* lda,
+                   lapack_complex_float* b, lapack_int* ldb,
+                   lapack_complex_float* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_zgels( char* trans, lapack_int* m, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_double* a, lapack_int* lda,
+                   lapack_complex_double* b, lapack_int* ldb,
+                   lapack_complex_double* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_sgelsy( lapack_int* m, lapack_int* n, lapack_int* nrhs, float* a,
+                    lapack_int* lda, float* b, lapack_int* ldb,
+                    lapack_int* jpvt, float* rcond, lapack_int* rank,
+                    float* work, lapack_int* lwork, lapack_int *info );
+void LAPACK_dgelsy( lapack_int* m, lapack_int* n, lapack_int* nrhs, double* a,
+                    lapack_int* lda, double* b, lapack_int* ldb,
+                    lapack_int* jpvt, double* rcond, lapack_int* rank,
+                    double* work, lapack_int* lwork, lapack_int *info );
+void LAPACK_cgelsy( lapack_int* m, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb, lapack_int* jpvt,
+                    float* rcond, lapack_int* rank, lapack_complex_float* work,
+                    lapack_int* lwork, float* rwork, lapack_int *info );
+void LAPACK_zgelsy( lapack_int* m, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb, lapack_int* jpvt,
+                    double* rcond, lapack_int* rank,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int *info );
+void LAPACK_sgelss( lapack_int* m, lapack_int* n, lapack_int* nrhs, float* a,
+                    lapack_int* lda, float* b, lapack_int* ldb, float* s,
+                    float* rcond, lapack_int* rank, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dgelss( lapack_int* m, lapack_int* n, lapack_int* nrhs, double* a,
+                    lapack_int* lda, double* b, lapack_int* ldb, double* s,
+                    double* rcond, lapack_int* rank, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cgelss( lapack_int* m, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb, float* s,
+                    float* rcond, lapack_int* rank, lapack_complex_float* work,
+                    lapack_int* lwork, float* rwork, lapack_int *info );
+void LAPACK_zgelss( lapack_int* m, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb, double* s,
+                    double* rcond, lapack_int* rank,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int *info );
+void LAPACK_sgelsd( lapack_int* m, lapack_int* n, lapack_int* nrhs, float* a,
+                    lapack_int* lda, float* b, lapack_int* ldb, float* s,
+                    float* rcond, lapack_int* rank, float* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int *info );
+void LAPACK_dgelsd( lapack_int* m, lapack_int* n, lapack_int* nrhs, double* a,
+                    lapack_int* lda, double* b, lapack_int* ldb, double* s,
+                    double* rcond, lapack_int* rank, double* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int *info );
+void LAPACK_cgelsd( lapack_int* m, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb, float* s,
+                    float* rcond, lapack_int* rank, lapack_complex_float* work,
+                    lapack_int* lwork, float* rwork, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_zgelsd( lapack_int* m, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb, double* s,
+                    double* rcond, lapack_int* rank,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* iwork, lapack_int *info );
+void LAPACK_sgglse( lapack_int* m, lapack_int* n, lapack_int* p, float* a,
+                    lapack_int* lda, float* b, lapack_int* ldb, float* c,
+                    float* d, float* x, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dgglse( lapack_int* m, lapack_int* n, lapack_int* p, double* a,
+                    lapack_int* lda, double* b, lapack_int* ldb, double* c,
+                    double* d, double* x, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cgglse( lapack_int* m, lapack_int* n, lapack_int* p,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* c, lapack_complex_float* d,
+                    lapack_complex_float* x, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zgglse( lapack_int* m, lapack_int* n, lapack_int* p,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* c, lapack_complex_double* d,
+                    lapack_complex_double* x, lapack_complex_double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sggglm( lapack_int* n, lapack_int* m, lapack_int* p, float* a,
+                    lapack_int* lda, float* b, lapack_int* ldb, float* d,
+                    float* x, float* y, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dggglm( lapack_int* n, lapack_int* m, lapack_int* p, double* a,
+                    lapack_int* lda, double* b, lapack_int* ldb, double* d,
+                    double* x, double* y, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cggglm( lapack_int* n, lapack_int* m, lapack_int* p,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* d, lapack_complex_float* x,
+                    lapack_complex_float* y, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zggglm( lapack_int* n, lapack_int* m, lapack_int* p,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* d, lapack_complex_double* x,
+                    lapack_complex_double* y, lapack_complex_double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_ssyev( char* jobz, char* uplo, lapack_int* n, float* a,
+                   lapack_int* lda, float* w, float* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_dsyev( char* jobz, char* uplo, lapack_int* n, double* a,
+                   lapack_int* lda, double* w, double* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_cheev( char* jobz, char* uplo, lapack_int* n,
+                   lapack_complex_float* a, lapack_int* lda, float* w,
+                   lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                   lapack_int *info );
+void LAPACK_zheev( char* jobz, char* uplo, lapack_int* n,
+                   lapack_complex_double* a, lapack_int* lda, double* w,
+                   lapack_complex_double* work, lapack_int* lwork,
+                   double* rwork, lapack_int *info );
+void LAPACK_ssyevd( char* jobz, char* uplo, lapack_int* n, float* a,
+                    lapack_int* lda, float* w, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_dsyevd( char* jobz, char* uplo, lapack_int* n, double* a,
+                    lapack_int* lda, double* w, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_cheevd( char* jobz, char* uplo, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda, float* w,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_zheevd( char* jobz, char* uplo, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda, double* w,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* lrwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_ssyevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    float* a, lapack_int* lda, float* vl, float* vu,
+                    lapack_int* il, lapack_int* iu, float* abstol,
+                    lapack_int* m, float* w, float* z, lapack_int* ldz,
+                    float* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_dsyevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    double* a, lapack_int* lda, double* vl, double* vu,
+                    lapack_int* il, lapack_int* iu, double* abstol,
+                    lapack_int* m, double* w, double* z, lapack_int* ldz,
+                    double* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_cheevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda, float* vl,
+                    float* vu, lapack_int* il, lapack_int* iu, float* abstol,
+                    lapack_int* m, float* w, lapack_complex_float* z,
+                    lapack_int* ldz, lapack_complex_float* work,
+                    lapack_int* lwork, float* rwork, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_zheevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda, double* vl,
+                    double* vu, lapack_int* il, lapack_int* iu, double* abstol,
+                    lapack_int* m, double* w, lapack_complex_double* z,
+                    lapack_int* ldz, lapack_complex_double* work,
+                    lapack_int* lwork, double* rwork, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_ssyevr( char* jobz, char* range, char* uplo, lapack_int* n,
+                    float* a, lapack_int* lda, float* vl, float* vu,
+                    lapack_int* il, lapack_int* iu, float* abstol,
+                    lapack_int* m, float* w, float* z, lapack_int* ldz,
+                    lapack_int* isuppz, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_dsyevr( char* jobz, char* range, char* uplo, lapack_int* n,
+                    double* a, lapack_int* lda, double* vl, double* vu,
+                    lapack_int* il, lapack_int* iu, double* abstol,
+                    lapack_int* m, double* w, double* z, lapack_int* ldz,
+                    lapack_int* isuppz, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_cheevr( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda, float* vl,
+                    float* vu, lapack_int* il, lapack_int* iu, float* abstol,
+                    lapack_int* m, float* w, lapack_complex_float* z,
+                    lapack_int* ldz, lapack_int* isuppz,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_zheevr( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda, double* vl,
+                    double* vu, lapack_int* il, lapack_int* iu, double* abstol,
+                    lapack_int* m, double* w, lapack_complex_double* z,
+                    lapack_int* ldz, lapack_int* isuppz,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* lrwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_sspev( char* jobz, char* uplo, lapack_int* n, float* ap, float* w,
+                   float* z, lapack_int* ldz, float* work, lapack_int *info );
+void LAPACK_dspev( char* jobz, char* uplo, lapack_int* n, double* ap, double* w,
+                   double* z, lapack_int* ldz, double* work, lapack_int *info );
+void LAPACK_chpev( char* jobz, char* uplo, lapack_int* n,
+                   lapack_complex_float* ap, float* w, lapack_complex_float* z,
+                   lapack_int* ldz, lapack_complex_float* work, float* rwork,
+                   lapack_int *info );
+void LAPACK_zhpev( char* jobz, char* uplo, lapack_int* n,
+                   lapack_complex_double* ap, double* w,
+                   lapack_complex_double* z, lapack_int* ldz,
+                   lapack_complex_double* work, double* rwork,
+                   lapack_int *info );
+void LAPACK_sspevd( char* jobz, char* uplo, lapack_int* n, float* ap, float* w,
+                    float* z, lapack_int* ldz, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_dspevd( char* jobz, char* uplo, lapack_int* n, double* ap,
+                    double* w, double* z, lapack_int* ldz, double* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_chpevd( char* jobz, char* uplo, lapack_int* n,
+                    lapack_complex_float* ap, float* w, lapack_complex_float* z,
+                    lapack_int* ldz, lapack_complex_float* work,
+                    lapack_int* lwork, float* rwork, lapack_int* lrwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_zhpevd( char* jobz, char* uplo, lapack_int* n,
+                    lapack_complex_double* ap, double* w,
+                    lapack_complex_double* z, lapack_int* ldz,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* lrwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_sspevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    float* ap, float* vl, float* vu, lapack_int* il,
+                    lapack_int* iu, float* abstol, lapack_int* m, float* w,
+                    float* z, lapack_int* ldz, float* work, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_dspevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    double* ap, double* vl, double* vu, lapack_int* il,
+                    lapack_int* iu, double* abstol, lapack_int* m, double* w,
+                    double* z, lapack_int* ldz, double* work, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_chpevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_complex_float* ap, float* vl, float* vu,
+                    lapack_int* il, lapack_int* iu, float* abstol,
+                    lapack_int* m, float* w, lapack_complex_float* z,
+                    lapack_int* ldz, lapack_complex_float* work, float* rwork,
+                    lapack_int* iwork, lapack_int* ifail, lapack_int *info );
+void LAPACK_zhpevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_complex_double* ap, double* vl, double* vu,
+                    lapack_int* il, lapack_int* iu, double* abstol,
+                    lapack_int* m, double* w, lapack_complex_double* z,
+                    lapack_int* ldz, lapack_complex_double* work, double* rwork,
+                    lapack_int* iwork, lapack_int* ifail, lapack_int *info );
+void LAPACK_ssbev( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
+                   float* ab, lapack_int* ldab, float* w, float* z,
+                   lapack_int* ldz, float* work, lapack_int *info );
+void LAPACK_dsbev( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
+                   double* ab, lapack_int* ldab, double* w, double* z,
+                   lapack_int* ldz, double* work, lapack_int *info );
+void LAPACK_chbev( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
+                   lapack_complex_float* ab, lapack_int* ldab, float* w,
+                   lapack_complex_float* z, lapack_int* ldz,
+                   lapack_complex_float* work, float* rwork, lapack_int *info );
+void LAPACK_zhbev( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
+                   lapack_complex_double* ab, lapack_int* ldab, double* w,
+                   lapack_complex_double* z, lapack_int* ldz,
+                   lapack_complex_double* work, double* rwork,
+                   lapack_int *info );
+void LAPACK_ssbevd( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
+                    float* ab, lapack_int* ldab, float* w, float* z,
+                    lapack_int* ldz, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_dsbevd( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
+                    double* ab, lapack_int* ldab, double* w, double* z,
+                    lapack_int* ldz, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_chbevd( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
+                    lapack_complex_float* ab, lapack_int* ldab, float* w,
+                    lapack_complex_float* z, lapack_int* ldz,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_zhbevd( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
+                    lapack_complex_double* ab, lapack_int* ldab, double* w,
+                    lapack_complex_double* z, lapack_int* ldz,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* lrwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_ssbevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_int* kd, float* ab, lapack_int* ldab, float* q,
+                    lapack_int* ldq, float* vl, float* vu, lapack_int* il,
+                    lapack_int* iu, float* abstol, lapack_int* m, float* w,
+                    float* z, lapack_int* ldz, float* work, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_dsbevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_int* kd, double* ab, lapack_int* ldab, double* q,
+                    lapack_int* ldq, double* vl, double* vu, lapack_int* il,
+                    lapack_int* iu, double* abstol, lapack_int* m, double* w,
+                    double* z, lapack_int* ldz, double* work, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_chbevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_int* kd, lapack_complex_float* ab, lapack_int* ldab,
+                    lapack_complex_float* q, lapack_int* ldq, float* vl,
+                    float* vu, lapack_int* il, lapack_int* iu, float* abstol,
+                    lapack_int* m, float* w, lapack_complex_float* z,
+                    lapack_int* ldz, lapack_complex_float* work, float* rwork,
+                    lapack_int* iwork, lapack_int* ifail, lapack_int *info );
+void LAPACK_zhbevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_int* kd, lapack_complex_double* ab, lapack_int* ldab,
+                    lapack_complex_double* q, lapack_int* ldq, double* vl,
+                    double* vu, lapack_int* il, lapack_int* iu, double* abstol,
+                    lapack_int* m, double* w, lapack_complex_double* z,
+                    lapack_int* ldz, lapack_complex_double* work, double* rwork,
+                    lapack_int* iwork, lapack_int* ifail, lapack_int *info );
+void LAPACK_sstev( char* jobz, lapack_int* n, float* d, float* e, float* z,
+                   lapack_int* ldz, float* work, lapack_int *info );
+void LAPACK_dstev( char* jobz, lapack_int* n, double* d, double* e, double* z,
+                   lapack_int* ldz, double* work, lapack_int *info );
+void LAPACK_sstevd( char* jobz, lapack_int* n, float* d, float* e, float* z,
+                    lapack_int* ldz, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_dstevd( char* jobz, lapack_int* n, double* d, double* e, double* z,
+                    lapack_int* ldz, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_sstevx( char* jobz, char* range, lapack_int* n, float* d, float* e,
+                    float* vl, float* vu, lapack_int* il, lapack_int* iu,
+                    float* abstol, lapack_int* m, float* w, float* z,
+                    lapack_int* ldz, float* work, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_dstevx( char* jobz, char* range, lapack_int* n, double* d,
+                    double* e, double* vl, double* vu, lapack_int* il,
+                    lapack_int* iu, double* abstol, lapack_int* m, double* w,
+                    double* z, lapack_int* ldz, double* work, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_sstevr( char* jobz, char* range, lapack_int* n, float* d, float* e,
+                    float* vl, float* vu, lapack_int* il, lapack_int* iu,
+                    float* abstol, lapack_int* m, float* w, float* z,
+                    lapack_int* ldz, lapack_int* isuppz, float* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_dstevr( char* jobz, char* range, lapack_int* n, double* d,
+                    double* e, double* vl, double* vu, lapack_int* il,
+                    lapack_int* iu, double* abstol, lapack_int* m, double* w,
+                    double* z, lapack_int* ldz, lapack_int* isuppz,
+                    double* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_sgees( char* jobvs, char* sort, LAPACK_S_SELECT2 select,
+                   lapack_int* n, float* a, lapack_int* lda, lapack_int* sdim,
+                   float* wr, float* wi, float* vs, lapack_int* ldvs,
+                   float* work, lapack_int* lwork, lapack_logical* bwork,
+                   lapack_int *info );
+void LAPACK_dgees( char* jobvs, char* sort, LAPACK_D_SELECT2 select,
+                   lapack_int* n, double* a, lapack_int* lda, lapack_int* sdim,
+                   double* wr, double* wi, double* vs, lapack_int* ldvs,
+                   double* work, lapack_int* lwork, lapack_logical* bwork,
+                   lapack_int *info );
+void LAPACK_cgees( char* jobvs, char* sort, LAPACK_C_SELECT1 select,
+                   lapack_int* n, lapack_complex_float* a, lapack_int* lda,
+                   lapack_int* sdim, lapack_complex_float* w,
+                   lapack_complex_float* vs, lapack_int* ldvs,
+                   lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                   lapack_logical* bwork, lapack_int *info );
+void LAPACK_zgees( char* jobvs, char* sort, LAPACK_Z_SELECT1 select,
+                   lapack_int* n, lapack_complex_double* a, lapack_int* lda,
+                   lapack_int* sdim, lapack_complex_double* w,
+                   lapack_complex_double* vs, lapack_int* ldvs,
+                   lapack_complex_double* work, lapack_int* lwork,
+                   double* rwork, lapack_logical* bwork, lapack_int *info );
+void LAPACK_sgeesx( char* jobvs, char* sort, LAPACK_S_SELECT2 select,
+                    char* sense, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int* sdim, float* wr, float* wi, float* vs,
+                    lapack_int* ldvs, float* rconde, float* rcondv, float* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_logical* bwork, lapack_int *info );
+void LAPACK_dgeesx( char* jobvs, char* sort, LAPACK_D_SELECT2 select,
+                    char* sense, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int* sdim, double* wr, double* wi, double* vs,
+                    lapack_int* ldvs, double* rconde, double* rcondv,
+                    double* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_logical* bwork,
+                    lapack_int *info );
+void LAPACK_cgeesx( char* jobvs, char* sort, LAPACK_C_SELECT1 select,
+                    char* sense, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int* sdim, lapack_complex_float* w,
+                    lapack_complex_float* vs, lapack_int* ldvs, float* rconde,
+                    float* rcondv, lapack_complex_float* work,
+                    lapack_int* lwork, float* rwork, lapack_logical* bwork,
+                    lapack_int *info );
+void LAPACK_zgeesx( char* jobvs, char* sort, LAPACK_Z_SELECT1 select,
+                    char* sense, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* sdim, lapack_complex_double* w,
+                    lapack_complex_double* vs, lapack_int* ldvs, double* rconde,
+                    double* rcondv, lapack_complex_double* work,
+                    lapack_int* lwork, double* rwork, lapack_logical* bwork,
+                    lapack_int *info );
+void LAPACK_sgeev( char* jobvl, char* jobvr, lapack_int* n, float* a,
+                   lapack_int* lda, float* wr, float* wi, float* vl,
+                   lapack_int* ldvl, float* vr, lapack_int* ldvr, float* work,
+                   lapack_int* lwork, lapack_int *info );
+void LAPACK_dgeev( char* jobvl, char* jobvr, lapack_int* n, double* a,
+                   lapack_int* lda, double* wr, double* wi, double* vl,
+                   lapack_int* ldvl, double* vr, lapack_int* ldvr, double* work,
+                   lapack_int* lwork, lapack_int *info );
+void LAPACK_cgeev( char* jobvl, char* jobvr, lapack_int* n,
+                   lapack_complex_float* a, lapack_int* lda,
+                   lapack_complex_float* w, lapack_complex_float* vl,
+                   lapack_int* ldvl, lapack_complex_float* vr, lapack_int* ldvr,
+                   lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                   lapack_int *info );
+void LAPACK_zgeev( char* jobvl, char* jobvr, lapack_int* n,
+                   lapack_complex_double* a, lapack_int* lda,
+                   lapack_complex_double* w, lapack_complex_double* vl,
+                   lapack_int* ldvl, lapack_complex_double* vr,
+                   lapack_int* ldvr, lapack_complex_double* work,
+                   lapack_int* lwork, double* rwork, lapack_int *info );
+void LAPACK_sgeevx( char* balanc, char* jobvl, char* jobvr, char* sense,
+                    lapack_int* n, float* a, lapack_int* lda, float* wr,
+                    float* wi, float* vl, lapack_int* ldvl, float* vr,
+                    lapack_int* ldvr, lapack_int* ilo, lapack_int* ihi,
+                    float* scale, float* abnrm, float* rconde, float* rcondv,
+                    float* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dgeevx( char* balanc, char* jobvl, char* jobvr, char* sense,
+                    lapack_int* n, double* a, lapack_int* lda, double* wr,
+                    double* wi, double* vl, lapack_int* ldvl, double* vr,
+                    lapack_int* ldvr, lapack_int* ilo, lapack_int* ihi,
+                    double* scale, double* abnrm, double* rconde,
+                    double* rcondv, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_cgeevx( char* balanc, char* jobvl, char* jobvr, char* sense,
+                    lapack_int* n, lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* w, lapack_complex_float* vl,
+                    lapack_int* ldvl, lapack_complex_float* vr,
+                    lapack_int* ldvr, lapack_int* ilo, lapack_int* ihi,
+                    float* scale, float* abnrm, float* rconde, float* rcondv,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int *info );
+void LAPACK_zgeevx( char* balanc, char* jobvl, char* jobvr, char* sense,
+                    lapack_int* n, lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* w, lapack_complex_double* vl,
+                    lapack_int* ldvl, lapack_complex_double* vr,
+                    lapack_int* ldvr, lapack_int* ilo, lapack_int* ihi,
+                    double* scale, double* abnrm, double* rconde,
+                    double* rcondv, lapack_complex_double* work,
+                    lapack_int* lwork, double* rwork, lapack_int *info );
+void LAPACK_sgesvd( char* jobu, char* jobvt, lapack_int* m, lapack_int* n,
+                    float* a, lapack_int* lda, float* s, float* u,
+                    lapack_int* ldu, float* vt, lapack_int* ldvt, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dgesvd( char* jobu, char* jobvt, lapack_int* m, lapack_int* n,
+                    double* a, lapack_int* lda, double* s, double* u,
+                    lapack_int* ldu, double* vt, lapack_int* ldvt, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cgesvd( char* jobu, char* jobvt, lapack_int* m, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda, float* s,
+                    lapack_complex_float* u, lapack_int* ldu,
+                    lapack_complex_float* vt, lapack_int* ldvt,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int *info );
+void LAPACK_zgesvd( char* jobu, char* jobvt, lapack_int* m, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda, double* s,
+                    lapack_complex_double* u, lapack_int* ldu,
+                    lapack_complex_double* vt, lapack_int* ldvt,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int *info );
+void LAPACK_sgesdd( char* jobz, lapack_int* m, lapack_int* n, float* a,
+                    lapack_int* lda, float* s, float* u, lapack_int* ldu,
+                    float* vt, lapack_int* ldvt, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_dgesdd( char* jobz, lapack_int* m, lapack_int* n, double* a,
+                    lapack_int* lda, double* s, double* u, lapack_int* ldu,
+                    double* vt, lapack_int* ldvt, double* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int *info );
+void LAPACK_cgesdd( char* jobz, lapack_int* m, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda, float* s,
+                    lapack_complex_float* u, lapack_int* ldu,
+                    lapack_complex_float* vt, lapack_int* ldvt,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_zgesdd( char* jobz, lapack_int* m, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda, double* s,
+                    lapack_complex_double* u, lapack_int* ldu,
+                    lapack_complex_double* vt, lapack_int* ldvt,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* iwork, lapack_int *info );
+void LAPACK_dgejsv( char* joba, char* jobu, char* jobv, char* jobr, char* jobt,
+                    char* jobp, lapack_int* m, lapack_int* n, double* a,
+                    lapack_int* lda, double* sva, double* u, lapack_int* ldu,
+                    double* v, lapack_int* ldv, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_sgejsv( char* joba, char* jobu, char* jobv, char* jobr, char* jobt,
+                    char* jobp, lapack_int* m, lapack_int* n, float* a,
+                    lapack_int* lda, float* sva, float* u, lapack_int* ldu,
+                    float* v, lapack_int* ldv, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_dgesvj( char* joba, char* jobu, char* jobv, lapack_int* m,
+                    lapack_int* n, double* a, lapack_int* lda, double* sva,
+                    lapack_int* mv, double* v, lapack_int* ldv, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sgesvj( char* joba, char* jobu, char* jobv, lapack_int* m,
+                    lapack_int* n, float* a, lapack_int* lda, float* sva,
+                    lapack_int* mv, float* v, lapack_int* ldv, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sggsvd( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* n, lapack_int* p, lapack_int* k, lapack_int* l,
+                    float* a, lapack_int* lda, float* b, lapack_int* ldb,
+                    float* alpha, float* beta, float* u, lapack_int* ldu,
+                    float* v, lapack_int* ldv, float* q, lapack_int* ldq,
+                    float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_dggsvd( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* n, lapack_int* p, lapack_int* k, lapack_int* l,
+                    double* a, lapack_int* lda, double* b, lapack_int* ldb,
+                    double* alpha, double* beta, double* u, lapack_int* ldu,
+                    double* v, lapack_int* ldv, double* q, lapack_int* ldq,
+                    double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_cggsvd( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* n, lapack_int* p, lapack_int* k, lapack_int* l,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb, float* alpha,
+                    float* beta, lapack_complex_float* u, lapack_int* ldu,
+                    lapack_complex_float* v, lapack_int* ldv,
+                    lapack_complex_float* q, lapack_int* ldq,
+                    lapack_complex_float* work, float* rwork, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_zggsvd( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* n, lapack_int* p, lapack_int* k, lapack_int* l,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb, double* alpha,
+                    double* beta, lapack_complex_double* u, lapack_int* ldu,
+                    lapack_complex_double* v, lapack_int* ldv,
+                    lapack_complex_double* q, lapack_int* ldq,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_ssygv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                   float* a, lapack_int* lda, float* b, lapack_int* ldb,
+                   float* w, float* work, lapack_int* lwork, lapack_int *info );
+void LAPACK_dsygv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                   double* a, lapack_int* lda, double* b, lapack_int* ldb,
+                   double* w, double* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_chegv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                   lapack_complex_float* a, lapack_int* lda,
+                   lapack_complex_float* b, lapack_int* ldb, float* w,
+                   lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                   lapack_int *info );
+void LAPACK_zhegv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                   lapack_complex_double* a, lapack_int* lda,
+                   lapack_complex_double* b, lapack_int* ldb, double* w,
+                   lapack_complex_double* work, lapack_int* lwork,
+                   double* rwork, lapack_int *info );
+void LAPACK_ssygvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                    float* a, lapack_int* lda, float* b, lapack_int* ldb,
+                    float* w, float* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_dsygvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                    double* a, lapack_int* lda, double* b, lapack_int* ldb,
+                    double* w, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_chegvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb, float* w,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_zhegvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb, double* w,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* lrwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_ssygvx( lapack_int* itype, char* jobz, char* range, char* uplo,
+                    lapack_int* n, float* a, lapack_int* lda, float* b,
+                    lapack_int* ldb, float* vl, float* vu, lapack_int* il,
+                    lapack_int* iu, float* abstol, lapack_int* m, float* w,
+                    float* z, lapack_int* ldz, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* ifail, lapack_int *info );
+void LAPACK_dsygvx( lapack_int* itype, char* jobz, char* range, char* uplo,
+                    lapack_int* n, double* a, lapack_int* lda, double* b,
+                    lapack_int* ldb, double* vl, double* vu, lapack_int* il,
+                    lapack_int* iu, double* abstol, lapack_int* m, double* w,
+                    double* z, lapack_int* ldz, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* ifail, lapack_int *info );
+void LAPACK_chegvx( lapack_int* itype, char* jobz, char* range, char* uplo,
+                    lapack_int* n, lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb, float* vl,
+                    float* vu, lapack_int* il, lapack_int* iu, float* abstol,
+                    lapack_int* m, float* w, lapack_complex_float* z,
+                    lapack_int* ldz, lapack_complex_float* work,
+                    lapack_int* lwork, float* rwork, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_zhegvx( lapack_int* itype, char* jobz, char* range, char* uplo,
+                    lapack_int* n, lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb, double* vl,
+                    double* vu, lapack_int* il, lapack_int* iu, double* abstol,
+                    lapack_int* m, double* w, lapack_complex_double* z,
+                    lapack_int* ldz, lapack_complex_double* work,
+                    lapack_int* lwork, double* rwork, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_sspgv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                   float* ap, float* bp, float* w, float* z, lapack_int* ldz,
+                   float* work, lapack_int *info );
+void LAPACK_dspgv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                   double* ap, double* bp, double* w, double* z,
+                   lapack_int* ldz, double* work, lapack_int *info );
+void LAPACK_chpgv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                   lapack_complex_float* ap, lapack_complex_float* bp, float* w,
+                   lapack_complex_float* z, lapack_int* ldz,
+                   lapack_complex_float* work, float* rwork, lapack_int *info );
+void LAPACK_zhpgv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                   lapack_complex_double* ap, lapack_complex_double* bp,
+                   double* w, lapack_complex_double* z, lapack_int* ldz,
+                   lapack_complex_double* work, double* rwork,
+                   lapack_int *info );
+void LAPACK_sspgvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                    float* ap, float* bp, float* w, float* z, lapack_int* ldz,
+                    float* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_dspgvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                    double* ap, double* bp, double* w, double* z,
+                    lapack_int* ldz, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_chpgvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                    lapack_complex_float* ap, lapack_complex_float* bp,
+                    float* w, lapack_complex_float* z, lapack_int* ldz,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_zhpgvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                    lapack_complex_double* ap, lapack_complex_double* bp,
+                    double* w, lapack_complex_double* z, lapack_int* ldz,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* lrwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_sspgvx( lapack_int* itype, char* jobz, char* range, char* uplo,
+                    lapack_int* n, float* ap, float* bp, float* vl, float* vu,
+                    lapack_int* il, lapack_int* iu, float* abstol,
+                    lapack_int* m, float* w, float* z, lapack_int* ldz,
+                    float* work, lapack_int* iwork, lapack_int* ifail,
+                    lapack_int *info );
+void LAPACK_dspgvx( lapack_int* itype, char* jobz, char* range, char* uplo,
+                    lapack_int* n, double* ap, double* bp, double* vl,
+                    double* vu, lapack_int* il, lapack_int* iu, double* abstol,
+                    lapack_int* m, double* w, double* z, lapack_int* ldz,
+                    double* work, lapack_int* iwork, lapack_int* ifail,
+                    lapack_int *info );
+void LAPACK_chpgvx( lapack_int* itype, char* jobz, char* range, char* uplo,
+                    lapack_int* n, lapack_complex_float* ap,
+                    lapack_complex_float* bp, float* vl, float* vu,
+                    lapack_int* il, lapack_int* iu, float* abstol,
+                    lapack_int* m, float* w, lapack_complex_float* z,
+                    lapack_int* ldz, lapack_complex_float* work, float* rwork,
+                    lapack_int* iwork, lapack_int* ifail, lapack_int *info );
+void LAPACK_zhpgvx( lapack_int* itype, char* jobz, char* range, char* uplo,
+                    lapack_int* n, lapack_complex_double* ap,
+                    lapack_complex_double* bp, double* vl, double* vu,
+                    lapack_int* il, lapack_int* iu, double* abstol,
+                    lapack_int* m, double* w, lapack_complex_double* z,
+                    lapack_int* ldz, lapack_complex_double* work, double* rwork,
+                    lapack_int* iwork, lapack_int* ifail, lapack_int *info );
+void LAPACK_ssbgv( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
+                   lapack_int* kb, float* ab, lapack_int* ldab, float* bb,
+                   lapack_int* ldbb, float* w, float* z, lapack_int* ldz,
+                   float* work, lapack_int *info );
+void LAPACK_dsbgv( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
+                   lapack_int* kb, double* ab, lapack_int* ldab, double* bb,
+                   lapack_int* ldbb, double* w, double* z, lapack_int* ldz,
+                   double* work, lapack_int *info );
+void LAPACK_chbgv( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
+                   lapack_int* kb, lapack_complex_float* ab, lapack_int* ldab,
+                   lapack_complex_float* bb, lapack_int* ldbb, float* w,
+                   lapack_complex_float* z, lapack_int* ldz,
+                   lapack_complex_float* work, float* rwork, lapack_int *info );
+void LAPACK_zhbgv( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
+                   lapack_int* kb, lapack_complex_double* ab, lapack_int* ldab,
+                   lapack_complex_double* bb, lapack_int* ldbb, double* w,
+                   lapack_complex_double* z, lapack_int* ldz,
+                   lapack_complex_double* work, double* rwork,
+                   lapack_int *info );
+void LAPACK_ssbgvd( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
+                    lapack_int* kb, float* ab, lapack_int* ldab, float* bb,
+                    lapack_int* ldbb, float* w, float* z, lapack_int* ldz,
+                    float* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_dsbgvd( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
+                    lapack_int* kb, double* ab, lapack_int* ldab, double* bb,
+                    lapack_int* ldbb, double* w, double* z, lapack_int* ldz,
+                    double* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_chbgvd( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
+                    lapack_int* kb, lapack_complex_float* ab, lapack_int* ldab,
+                    lapack_complex_float* bb, lapack_int* ldbb, float* w,
+                    lapack_complex_float* z, lapack_int* ldz,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_zhbgvd( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
+                    lapack_int* kb, lapack_complex_double* ab, lapack_int* ldab,
+                    lapack_complex_double* bb, lapack_int* ldbb, double* w,
+                    lapack_complex_double* z, lapack_int* ldz,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* lrwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_ssbgvx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_int* ka, lapack_int* kb, float* ab, lapack_int* ldab,
+                    float* bb, lapack_int* ldbb, float* q, lapack_int* ldq,
+                    float* vl, float* vu, lapack_int* il, lapack_int* iu,
+                    float* abstol, lapack_int* m, float* w, float* z,
+                    lapack_int* ldz, float* work, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_dsbgvx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_int* ka, lapack_int* kb, double* ab,
+                    lapack_int* ldab, double* bb, lapack_int* ldbb, double* q,
+                    lapack_int* ldq, double* vl, double* vu, lapack_int* il,
+                    lapack_int* iu, double* abstol, lapack_int* m, double* w,
+                    double* z, lapack_int* ldz, double* work, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_chbgvx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_int* ka, lapack_int* kb, lapack_complex_float* ab,
+                    lapack_int* ldab, lapack_complex_float* bb,
+                    lapack_int* ldbb, lapack_complex_float* q, lapack_int* ldq,
+                    float* vl, float* vu, lapack_int* il, lapack_int* iu,
+                    float* abstol, lapack_int* m, float* w,
+                    lapack_complex_float* z, lapack_int* ldz,
+                    lapack_complex_float* work, float* rwork, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_zhbgvx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_int* ka, lapack_int* kb, lapack_complex_double* ab,
+                    lapack_int* ldab, lapack_complex_double* bb,
+                    lapack_int* ldbb, lapack_complex_double* q, lapack_int* ldq,
+                    double* vl, double* vu, lapack_int* il, lapack_int* iu,
+                    double* abstol, lapack_int* m, double* w,
+                    lapack_complex_double* z, lapack_int* ldz,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int* iwork, lapack_int* ifail, lapack_int *info );
+void LAPACK_sgges( char* jobvsl, char* jobvsr, char* sort,
+                   LAPACK_S_SELECT3 selctg, lapack_int* n, float* a,
+                   lapack_int* lda, float* b, lapack_int* ldb, lapack_int* sdim,
+                   float* alphar, float* alphai, float* beta, float* vsl,
+                   lapack_int* ldvsl, float* vsr, lapack_int* ldvsr,
+                   float* work, lapack_int* lwork, lapack_logical* bwork,
+                   lapack_int *info );
+void LAPACK_dgges( char* jobvsl, char* jobvsr, char* sort,
+                   LAPACK_D_SELECT3 selctg, lapack_int* n, double* a,
+                   lapack_int* lda, double* b, lapack_int* ldb,
+                   lapack_int* sdim, double* alphar, double* alphai,
+                   double* beta, double* vsl, lapack_int* ldvsl, double* vsr,
+                   lapack_int* ldvsr, double* work, lapack_int* lwork,
+                   lapack_logical* bwork, lapack_int *info );
+void LAPACK_cgges( char* jobvsl, char* jobvsr, char* sort,
+                   LAPACK_C_SELECT2 selctg, lapack_int* n,
+                   lapack_complex_float* a, lapack_int* lda,
+                   lapack_complex_float* b, lapack_int* ldb, lapack_int* sdim,
+                   lapack_complex_float* alpha, lapack_complex_float* beta,
+                   lapack_complex_float* vsl, lapack_int* ldvsl,
+                   lapack_complex_float* vsr, lapack_int* ldvsr,
+                   lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                   lapack_logical* bwork, lapack_int *info );
+void LAPACK_zgges( char* jobvsl, char* jobvsr, char* sort,
+                   LAPACK_Z_SELECT2 selctg, lapack_int* n,
+                   lapack_complex_double* a, lapack_int* lda,
+                   lapack_complex_double* b, lapack_int* ldb, lapack_int* sdim,
+                   lapack_complex_double* alpha, lapack_complex_double* beta,
+                   lapack_complex_double* vsl, lapack_int* ldvsl,
+                   lapack_complex_double* vsr, lapack_int* ldvsr,
+                   lapack_complex_double* work, lapack_int* lwork,
+                   double* rwork, lapack_logical* bwork, lapack_int *info );
+void LAPACK_sggesx( char* jobvsl, char* jobvsr, char* sort,
+                    LAPACK_S_SELECT3 selctg, char* sense, lapack_int* n,
+                    float* a, lapack_int* lda, float* b, lapack_int* ldb,
+                    lapack_int* sdim, float* alphar, float* alphai, float* beta,
+                    float* vsl, lapack_int* ldvsl, float* vsr,
+                    lapack_int* ldvsr, float* rconde, float* rcondv,
+                    float* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_logical* bwork,
+                    lapack_int *info );
+void LAPACK_dggesx( char* jobvsl, char* jobvsr, char* sort,
+                    LAPACK_D_SELECT3 selctg, char* sense, lapack_int* n,
+                    double* a, lapack_int* lda, double* b, lapack_int* ldb,
+                    lapack_int* sdim, double* alphar, double* alphai,
+                    double* beta, double* vsl, lapack_int* ldvsl, double* vsr,
+                    lapack_int* ldvsr, double* rconde, double* rcondv,
+                    double* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_logical* bwork,
+                    lapack_int *info );
+void LAPACK_cggesx( char* jobvsl, char* jobvsr, char* sort,
+                    LAPACK_C_SELECT2 selctg, char* sense, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb, lapack_int* sdim,
+                    lapack_complex_float* alpha, lapack_complex_float* beta,
+                    lapack_complex_float* vsl, lapack_int* ldvsl,
+                    lapack_complex_float* vsr, lapack_int* ldvsr, float* rconde,
+                    float* rcondv, lapack_complex_float* work,
+                    lapack_int* lwork, float* rwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_logical* bwork,
+                    lapack_int *info );
+void LAPACK_zggesx( char* jobvsl, char* jobvsr, char* sort,
+                    LAPACK_Z_SELECT2 selctg, char* sense, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb, lapack_int* sdim,
+                    lapack_complex_double* alpha, lapack_complex_double* beta,
+                    lapack_complex_double* vsl, lapack_int* ldvsl,
+                    lapack_complex_double* vsr, lapack_int* ldvsr,
+                    double* rconde, double* rcondv, lapack_complex_double* work,
+                    lapack_int* lwork, double* rwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_logical* bwork,
+                    lapack_int *info );
+void LAPACK_sggev( char* jobvl, char* jobvr, lapack_int* n, float* a,
+                   lapack_int* lda, float* b, lapack_int* ldb, float* alphar,
+                   float* alphai, float* beta, float* vl, lapack_int* ldvl,
+                   float* vr, lapack_int* ldvr, float* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_dggev( char* jobvl, char* jobvr, lapack_int* n, double* a,
+                   lapack_int* lda, double* b, lapack_int* ldb, double* alphar,
+                   double* alphai, double* beta, double* vl, lapack_int* ldvl,
+                   double* vr, lapack_int* ldvr, double* work,
+                   lapack_int* lwork, lapack_int *info );
+void LAPACK_cggev( char* jobvl, char* jobvr, lapack_int* n,
+                   lapack_complex_float* a, lapack_int* lda,
+                   lapack_complex_float* b, lapack_int* ldb,
+                   lapack_complex_float* alpha, lapack_complex_float* beta,
+                   lapack_complex_float* vl, lapack_int* ldvl,
+                   lapack_complex_float* vr, lapack_int* ldvr,
+                   lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                   lapack_int *info );
+void LAPACK_zggev( char* jobvl, char* jobvr, lapack_int* n,
+                   lapack_complex_double* a, lapack_int* lda,
+                   lapack_complex_double* b, lapack_int* ldb,
+                   lapack_complex_double* alpha, lapack_complex_double* beta,
+                   lapack_complex_double* vl, lapack_int* ldvl,
+                   lapack_complex_double* vr, lapack_int* ldvr,
+                   lapack_complex_double* work, lapack_int* lwork,
+                   double* rwork, lapack_int *info );
+void LAPACK_sggevx( char* balanc, char* jobvl, char* jobvr, char* sense,
+                    lapack_int* n, float* a, lapack_int* lda, float* b,
+                    lapack_int* ldb, float* alphar, float* alphai, float* beta,
+                    float* vl, lapack_int* ldvl, float* vr, lapack_int* ldvr,
+                    lapack_int* ilo, lapack_int* ihi, float* lscale,
+                    float* rscale, float* abnrm, float* bbnrm, float* rconde,
+                    float* rcondv, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_logical* bwork,
+                    lapack_int *info );
+void LAPACK_dggevx( char* balanc, char* jobvl, char* jobvr, char* sense,
+                    lapack_int* n, double* a, lapack_int* lda, double* b,
+                    lapack_int* ldb, double* alphar, double* alphai,
+                    double* beta, double* vl, lapack_int* ldvl, double* vr,
+                    lapack_int* ldvr, lapack_int* ilo, lapack_int* ihi,
+                    double* lscale, double* rscale, double* abnrm,
+                    double* bbnrm, double* rconde, double* rcondv, double* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_logical* bwork,
+                    lapack_int *info );
+void LAPACK_cggevx( char* balanc, char* jobvl, char* jobvr, char* sense,
+                    lapack_int* n, lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* alpha, lapack_complex_float* beta,
+                    lapack_complex_float* vl, lapack_int* ldvl,
+                    lapack_complex_float* vr, lapack_int* ldvr, lapack_int* ilo,
+                    lapack_int* ihi, float* lscale, float* rscale, float* abnrm,
+                    float* bbnrm, float* rconde, float* rcondv,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int* iwork, lapack_logical* bwork,
+                    lapack_int *info );
+void LAPACK_zggevx( char* balanc, char* jobvl, char* jobvr, char* sense,
+                    lapack_int* n, lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* alpha, lapack_complex_double* beta,
+                    lapack_complex_double* vl, lapack_int* ldvl,
+                    lapack_complex_double* vr, lapack_int* ldvr,
+                    lapack_int* ilo, lapack_int* ihi, double* lscale,
+                    double* rscale, double* abnrm, double* bbnrm,
+                    double* rconde, double* rcondv, lapack_complex_double* work,
+                    lapack_int* lwork, double* rwork, lapack_int* iwork,
+                    lapack_logical* bwork, lapack_int *info );
+void LAPACK_dsfrk( char* transr, char* uplo, char* trans, lapack_int* n,
+                   lapack_int* k, double* alpha, const double* a,
+                   lapack_int* lda, double* beta, double* c );
+void LAPACK_ssfrk( char* transr, char* uplo, char* trans, lapack_int* n,
+                   lapack_int* k, float* alpha, const float* a, lapack_int* lda,
+                   float* beta, float* c );
+void LAPACK_zhfrk( char* transr, char* uplo, char* trans, lapack_int* n,
+                   lapack_int* k, double* alpha, const lapack_complex_double* a,
+                   lapack_int* lda, double* beta, lapack_complex_double* c );
+void LAPACK_chfrk( char* transr, char* uplo, char* trans, lapack_int* n,
+                   lapack_int* k, float* alpha, const lapack_complex_float* a,
+                   lapack_int* lda, float* beta, lapack_complex_float* c );
+void LAPACK_dtfsm( char* transr, char* side, char* uplo, char* trans,
+                   char* diag, lapack_int* m, lapack_int* n, double* alpha,
+                   const double* a, double* b, lapack_int* ldb );
+void LAPACK_stfsm( char* transr, char* side, char* uplo, char* trans,
+                   char* diag, lapack_int* m, lapack_int* n, float* alpha,
+                   const float* a, float* b, lapack_int* ldb );
+void LAPACK_ztfsm( char* transr, char* side, char* uplo, char* trans,
+                   char* diag, lapack_int* m, lapack_int* n,
+                   lapack_complex_double* alpha, const lapack_complex_double* a,
+                   lapack_complex_double* b, lapack_int* ldb );
+void LAPACK_ctfsm( char* transr, char* side, char* uplo, char* trans,
+                   char* diag, lapack_int* m, lapack_int* n,
+                   lapack_complex_float* alpha, const lapack_complex_float* a,
+                   lapack_complex_float* b, lapack_int* ldb );
+void LAPACK_dtfttp( char* transr, char* uplo, lapack_int* n, const double* arf,
+                    double* ap, lapack_int *info );
+void LAPACK_stfttp( char* transr, char* uplo, lapack_int* n, const float* arf,
+                    float* ap, lapack_int *info );
+void LAPACK_ztfttp( char* transr, char* uplo, lapack_int* n,
+                    const lapack_complex_double* arf, lapack_complex_double* ap,
+                    lapack_int *info );
+void LAPACK_ctfttp( char* transr, char* uplo, lapack_int* n,
+                    const lapack_complex_float* arf, lapack_complex_float* ap,
+                    lapack_int *info );
+void LAPACK_dtfttr( char* transr, char* uplo, lapack_int* n, const double* arf,
+                    double* a, lapack_int* lda, lapack_int *info );
+void LAPACK_stfttr( char* transr, char* uplo, lapack_int* n, const float* arf,
+                    float* a, lapack_int* lda, lapack_int *info );
+void LAPACK_ztfttr( char* transr, char* uplo, lapack_int* n,
+                    const lapack_complex_double* arf, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_ctfttr( char* transr, char* uplo, lapack_int* n,
+                    const lapack_complex_float* arf, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_dtpttf( char* transr, char* uplo, lapack_int* n, const double* ap,
+                    double* arf, lapack_int *info );
+void LAPACK_stpttf( char* transr, char* uplo, lapack_int* n, const float* ap,
+                    float* arf, lapack_int *info );
+void LAPACK_ztpttf( char* transr, char* uplo, lapack_int* n,
+                    const lapack_complex_double* ap, lapack_complex_double* arf,
+                    lapack_int *info );
+void LAPACK_ctpttf( char* transr, char* uplo, lapack_int* n,
+                    const lapack_complex_float* ap, lapack_complex_float* arf,
+                    lapack_int *info );
+void LAPACK_dtpttr( char* uplo, lapack_int* n, const double* ap, double* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_stpttr( char* uplo, lapack_int* n, const float* ap, float* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_ztpttr( char* uplo, lapack_int* n, const lapack_complex_double* ap,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_ctpttr( char* uplo, lapack_int* n, const lapack_complex_float* ap,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_dtrttf( char* transr, char* uplo, lapack_int* n, const double* a,
+                    lapack_int* lda, double* arf, lapack_int *info );
+void LAPACK_strttf( char* transr, char* uplo, lapack_int* n, const float* a,
+                    lapack_int* lda, float* arf, lapack_int *info );
+void LAPACK_ztrttf( char* transr, char* uplo, lapack_int* n,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* arf, lapack_int *info );
+void LAPACK_ctrttf( char* transr, char* uplo, lapack_int* n,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* arf, lapack_int *info );
+void LAPACK_dtrttp( char* uplo, lapack_int* n, const double* a, lapack_int* lda,
+                    double* ap, lapack_int *info );
+void LAPACK_strttp( char* uplo, lapack_int* n, const float* a, lapack_int* lda,
+                    float* ap, lapack_int *info );
+void LAPACK_ztrttp( char* uplo, lapack_int* n, const lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* ap,
+                    lapack_int *info );
+void LAPACK_ctrttp( char* uplo, lapack_int* n, const lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* ap,
+                    lapack_int *info );
+void LAPACK_sgeqrfp( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                     float* tau, float* work, lapack_int* lwork,
+                     lapack_int *info );
+void LAPACK_dgeqrfp( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                     double* tau, double* work, lapack_int* lwork,
+                     lapack_int *info );
+void LAPACK_cgeqrfp( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                     lapack_int* lda, lapack_complex_float* tau,
+                     lapack_complex_float* work, lapack_int* lwork,
+                     lapack_int *info );
+void LAPACK_zgeqrfp( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                     lapack_int* lda, lapack_complex_double* tau,
+                     lapack_complex_double* work, lapack_int* lwork,
+                     lapack_int *info );
+void LAPACK_clacgv( lapack_int* n, lapack_complex_float* x, lapack_int* incx );
+void LAPACK_zlacgv( lapack_int* n, lapack_complex_double* x, lapack_int* incx );
+void LAPACK_slarnv( lapack_int* idist, lapack_int* iseed, lapack_int* n,
+                    float* x );
+void LAPACK_dlarnv( lapack_int* idist, lapack_int* iseed, lapack_int* n,
+                    double* x );
+void LAPACK_clarnv( lapack_int* idist, lapack_int* iseed, lapack_int* n,
+                    lapack_complex_float* x );
+void LAPACK_zlarnv( lapack_int* idist, lapack_int* iseed, lapack_int* n,
+                    lapack_complex_double* x );
+void LAPACK_sgeqr2( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    float* tau, float* work, lapack_int *info );
+void LAPACK_dgeqr2( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    double* tau, double* work, lapack_int *info );
+void LAPACK_cgeqr2( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* tau,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zgeqr2( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_slacpy( char* uplo, lapack_int* m, lapack_int* n, const float* a,
+                    lapack_int* lda, float* b, lapack_int* ldb );
+void LAPACK_dlacpy( char* uplo, lapack_int* m, lapack_int* n, const double* a,
+                    lapack_int* lda, double* b, lapack_int* ldb );
+void LAPACK_clacpy( char* uplo, lapack_int* m, lapack_int* n,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb );
+void LAPACK_zlacpy( char* uplo, lapack_int* m, lapack_int* n,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb );
+void LAPACK_sgetf2( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_dgetf2( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_cgetf2( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int* ipiv, lapack_int *info );
+void LAPACK_zgetf2( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* ipiv, lapack_int *info );
+void LAPACK_slaswp( lapack_int* n, float* a, lapack_int* lda, lapack_int* k1,
+                    lapack_int* k2, const lapack_int* ipiv, lapack_int* incx );
+void LAPACK_dlaswp( lapack_int* n, double* a, lapack_int* lda, lapack_int* k1,
+                    lapack_int* k2, const lapack_int* ipiv, lapack_int* incx );
+void LAPACK_claswp( lapack_int* n, lapack_complex_float* a, lapack_int* lda,
+                    lapack_int* k1, lapack_int* k2, const lapack_int* ipiv,
+                    lapack_int* incx );
+void LAPACK_zlaswp( lapack_int* n, lapack_complex_double* a, lapack_int* lda,
+                    lapack_int* k1, lapack_int* k2, const lapack_int* ipiv,
+                    lapack_int* incx );
+float LAPACK_slange( char* norm, lapack_int* m, lapack_int* n, const float* a,
+                    lapack_int* lda, float* work );
+double LAPACK_dlange( char* norm, lapack_int* m, lapack_int* n, const double* a,
+                    lapack_int* lda, double* work );
+float LAPACK_clange( char* norm, lapack_int* m, lapack_int* n,
+                    const lapack_complex_float* a, lapack_int* lda, float* work );
+double LAPACK_zlange( char* norm, lapack_int* m, lapack_int* n,
+                    const lapack_complex_double* a, lapack_int* lda, double* work );
+float LAPACK_clanhe( char* norm, char* uplo, lapack_int* n,
+                    const lapack_complex_float* a, lapack_int* lda, float* work );
+double LAPACK_zlanhe( char* norm, char* uplo, lapack_int* n,
+                    const lapack_complex_double* a, lapack_int* lda, double* work );
+float LAPACK_slansy( char* norm, char* uplo, lapack_int* n, const float* a,
+                    lapack_int* lda, float* work );
+double LAPACK_dlansy( char* norm, char* uplo, lapack_int* n, const double* a,
+                    lapack_int* lda, double* work );
+float LAPACK_clansy( char* norm, char* uplo, lapack_int* n,
+                    const lapack_complex_float* a, lapack_int* lda, float* work );
+double LAPACK_zlansy( char* norm, char* uplo, lapack_int* n,
+                    const lapack_complex_double* a, lapack_int* lda, double* work );
+float LAPACK_slantr( char* norm, char* uplo, char* diag, lapack_int* m,
+                    lapack_int* n, const float* a, lapack_int* lda, float* work );
+double LAPACK_dlantr( char* norm, char* uplo, char* diag, lapack_int* m,
+                    lapack_int* n, const double* a, lapack_int* lda, double* work );
+float LAPACK_clantr( char* norm, char* uplo, char* diag, lapack_int* m,
+                    lapack_int* n, const lapack_complex_float* a, lapack_int* lda,
+                    float* work );
+double LAPACK_zlantr( char* norm, char* uplo, char* diag, lapack_int* m,
+                    lapack_int* n, const lapack_complex_double* a, lapack_int* lda,
+                    double* work );
+float LAPACK_slamch( char* cmach );
+double LAPACK_dlamch( char* cmach );
+void LAPACK_sgelq2( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    float* tau, float* work, lapack_int *info );
+void LAPACK_dgelq2( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    double* tau, double* work, lapack_int *info );
+void LAPACK_cgelq2( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* tau,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zgelq2( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_slarfb( char* side, char* trans, char* direct, char* storev,
+                    lapack_int* m, lapack_int* n, lapack_int* k, const float* v,
+                    lapack_int* ldv, const float* t, lapack_int* ldt, float* c,
+                    lapack_int* ldc, float* work, lapack_int* ldwork );
+void LAPACK_dlarfb( char* side, char* trans, char* direct, char* storev,
+                    lapack_int* m, lapack_int* n, lapack_int* k,
+                    const double* v, lapack_int* ldv, const double* t,
+                    lapack_int* ldt, double* c, lapack_int* ldc, double* work,
+                    lapack_int* ldwork );
+void LAPACK_clarfb( char* side, char* trans, char* direct, char* storev,
+                    lapack_int* m, lapack_int* n, lapack_int* k,
+                    const lapack_complex_float* v, lapack_int* ldv,
+                    const lapack_complex_float* t, lapack_int* ldt,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    lapack_complex_float* work, lapack_int* ldwork );
+void LAPACK_zlarfb( char* side, char* trans, char* direct, char* storev,
+                    lapack_int* m, lapack_int* n, lapack_int* k,
+                    const lapack_complex_double* v, lapack_int* ldv,
+                    const lapack_complex_double* t, lapack_int* ldt,
+                    lapack_complex_double* c, lapack_int* ldc,
+                    lapack_complex_double* work, lapack_int* ldwork );
+void LAPACK_slarfg( lapack_int* n, float* alpha, float* x, lapack_int* incx,
+                    float* tau );
+void LAPACK_dlarfg( lapack_int* n, double* alpha, double* x, lapack_int* incx,
+                    double* tau );
+void LAPACK_clarfg( lapack_int* n, lapack_complex_float* alpha,
+                    lapack_complex_float* x, lapack_int* incx,
+                    lapack_complex_float* tau );
+void LAPACK_zlarfg( lapack_int* n, lapack_complex_double* alpha,
+                    lapack_complex_double* x, lapack_int* incx,
+                    lapack_complex_double* tau );
+void LAPACK_slarft( char* direct, char* storev, lapack_int* n, lapack_int* k,
+                    const float* v, lapack_int* ldv, const float* tau, float* t,
+                    lapack_int* ldt );
+void LAPACK_dlarft( char* direct, char* storev, lapack_int* n, lapack_int* k,
+                    const double* v, lapack_int* ldv, const double* tau,
+                    double* t, lapack_int* ldt );
+void LAPACK_clarft( char* direct, char* storev, lapack_int* n, lapack_int* k,
+                    const lapack_complex_float* v, lapack_int* ldv,
+                    const lapack_complex_float* tau, lapack_complex_float* t,
+                    lapack_int* ldt );
+void LAPACK_zlarft( char* direct, char* storev, lapack_int* n, lapack_int* k,
+                    const lapack_complex_double* v, lapack_int* ldv,
+                    const lapack_complex_double* tau, lapack_complex_double* t,
+                    lapack_int* ldt );
+void LAPACK_slarfx( char* side, lapack_int* m, lapack_int* n, const float* v,
+                    float* tau, float* c, lapack_int* ldc, float* work );
+void LAPACK_dlarfx( char* side, lapack_int* m, lapack_int* n, const double* v,
+                    double* tau, double* c, lapack_int* ldc, double* work );
+void LAPACK_clarfx( char* side, lapack_int* m, lapack_int* n,
+                    const lapack_complex_float* v, lapack_complex_float* tau,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    lapack_complex_float* work );
+void LAPACK_zlarfx( char* side, lapack_int* m, lapack_int* n,
+                    const lapack_complex_double* v, lapack_complex_double* tau,
+                    lapack_complex_double* c, lapack_int* ldc,
+                    lapack_complex_double* work );
+void LAPACK_slatms( lapack_int* m, lapack_int* n, char* dist, lapack_int* iseed,
+                    char* sym, float* d, lapack_int* mode, float* cond,
+                    float* dmax, lapack_int* kl, lapack_int* ku, char* pack,
+                    float* a, lapack_int* lda, float* work, lapack_int *info );
+void LAPACK_dlatms( lapack_int* m, lapack_int* n, char* dist, lapack_int* iseed,
+                    char* sym, double* d, lapack_int* mode, double* cond,
+                    double* dmax, lapack_int* kl, lapack_int* ku, char* pack,
+                    double* a, lapack_int* lda, double* work,
+                    lapack_int *info );
+void LAPACK_clatms( lapack_int* m, lapack_int* n, char* dist, lapack_int* iseed,
+                    char* sym, float* d, lapack_int* mode, float* cond,
+                    float* dmax, lapack_int* kl, lapack_int* ku, char* pack,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zlatms( lapack_int* m, lapack_int* n, char* dist, lapack_int* iseed,
+                    char* sym, double* d, lapack_int* mode, double* cond,
+                    double* dmax, lapack_int* kl, lapack_int* ku, char* pack,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_slag2d( lapack_int* m, lapack_int* n, const float* sa,
+                    lapack_int* ldsa, double* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_dlag2s( lapack_int* m, lapack_int* n, const double* a,
+                    lapack_int* lda, float* sa, lapack_int* ldsa,
+                    lapack_int *info );
+void LAPACK_clag2z( lapack_int* m, lapack_int* n,
+                    const lapack_complex_float* sa, lapack_int* ldsa,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_zlag2c( lapack_int* m, lapack_int* n,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_float* sa, lapack_int* ldsa,
+                    lapack_int *info );
+void LAPACK_slauum( char* uplo, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_dlauum( char* uplo, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_clauum( char* uplo, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_zlauum( char* uplo, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_slagge( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, const float* d, float* a, lapack_int* lda,
+                    lapack_int* iseed, float* work, lapack_int *info );
+void LAPACK_dlagge( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, const double* d, double* a, lapack_int* lda,
+                    lapack_int* iseed, double* work, lapack_int *info );
+void LAPACK_clagge( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, const float* d, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int* iseed,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zlagge( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, const double* d, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* iseed,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_slaset( char* uplo, lapack_int* m, lapack_int* n, float* alpha,
+                    float* beta, float* a, lapack_int* lda );
+void LAPACK_dlaset( char* uplo, lapack_int* m, lapack_int* n, double* alpha,
+                    double* beta, double* a, lapack_int* lda );
+void LAPACK_claset( char* uplo, lapack_int* m, lapack_int* n,
+                    lapack_complex_float* alpha, lapack_complex_float* beta,
+                    lapack_complex_float* a, lapack_int* lda );
+void LAPACK_zlaset( char* uplo, lapack_int* m, lapack_int* n,
+                    lapack_complex_double* alpha, lapack_complex_double* beta,
+                    lapack_complex_double* a, lapack_int* lda );
+void LAPACK_slasrt( char* id, lapack_int* n, float* d, lapack_int *info );
+void LAPACK_dlasrt( char* id, lapack_int* n, double* d, lapack_int *info );
+void LAPACK_claghe( lapack_int* n, lapack_int* k, const float* d,
+                    lapack_complex_float* a, lapack_int* lda, lapack_int* iseed,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zlaghe( lapack_int* n, lapack_int* k, const double* d,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_int* iseed, lapack_complex_double* work,
+                    lapack_int *info );
+void LAPACK_slagsy( lapack_int* n, lapack_int* k, const float* d, float* a,
+                    lapack_int* lda, lapack_int* iseed, float* work,
+                    lapack_int *info );
+void LAPACK_dlagsy( lapack_int* n, lapack_int* k, const double* d, double* a,
+                    lapack_int* lda, lapack_int* iseed, double* work,
+                    lapack_int *info );
+void LAPACK_clagsy( lapack_int* n, lapack_int* k, const float* d,
+                    lapack_complex_float* a, lapack_int* lda, lapack_int* iseed,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zlagsy( lapack_int* n, lapack_int* k, const double* d,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_int* iseed, lapack_complex_double* work,
+                    lapack_int *info );
+void LAPACK_slapmr( lapack_logical* forwrd, lapack_int* m, lapack_int* n,
+                    float* x, lapack_int* ldx, lapack_int* k );
+void LAPACK_dlapmr( lapack_logical* forwrd, lapack_int* m, lapack_int* n,
+                    double* x, lapack_int* ldx, lapack_int* k );
+void LAPACK_clapmr( lapack_logical* forwrd, lapack_int* m, lapack_int* n,
+                    lapack_complex_float* x, lapack_int* ldx, lapack_int* k );
+void LAPACK_zlapmr( lapack_logical* forwrd, lapack_int* m, lapack_int* n,
+                    lapack_complex_double* x, lapack_int* ldx, lapack_int* k );
+float LAPACK_slapy2( float* x, float* y );
+double LAPACK_dlapy2( double* x, double* y );
+float LAPACK_slapy3( float* x, float* y, float* z );
+double LAPACK_dlapy3( double* x, double* y, double* z );
+void LAPACK_slartgp( float* f, float* g, float* cs, float* sn, float* r );
+void LAPACK_dlartgp( double* f, double* g, double* cs, double* sn, double* r );
+void LAPACK_slartgs( float* x, float* y, float* sigma, float* cs, float* sn );
+void LAPACK_dlartgs( double* x, double* y, double* sigma, double* cs,
+                     double* sn );
+// LAPACK 3.3.0
+void LAPACK_cbbcsd( char* jobu1, char* jobu2,
+                    char* jobv1t, char* jobv2t, char* trans,
+                    lapack_int* m, lapack_int* p, lapack_int* q,
+                    float* theta, float* phi,
+                    lapack_complex_float* u1, lapack_int* ldu1,
+                    lapack_complex_float* u2, lapack_int* ldu2,
+                    lapack_complex_float* v1t, lapack_int* ldv1t,
+                    lapack_complex_float* v2t, lapack_int* ldv2t,
+                    float* b11d, float* b11e, float* b12d,
+                    float* b12e, float* b21d, float* b21e,
+                    float* b22d, float* b22e, float* rwork,
+                    lapack_int* lrwork , lapack_int *info );
+void LAPACK_cheswapr( char* uplo, lapack_int* n,
+                      lapack_complex_float* a, lapack_int* i1,
+                      lapack_int* i2 );
+void LAPACK_chetri2( char* uplo, lapack_int* n,
+                     lapack_complex_float* a, lapack_int* lda,
+                     const lapack_int* ipiv,
+                     lapack_complex_float* work, lapack_int* lwork , lapack_int *info );
+void LAPACK_chetri2x( char* uplo, lapack_int* n,
+                      lapack_complex_float* a, lapack_int* lda,
+                      const lapack_int* ipiv,
+                      lapack_complex_float* work, lapack_int* nb , lapack_int *info );
+void LAPACK_chetrs2( char* uplo, lapack_int* n,
+                     lapack_int* nrhs, const lapack_complex_float* a,
+                     lapack_int* lda, const lapack_int* ipiv,
+                     lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* work , lapack_int *info );
+void LAPACK_csyconv( char* uplo, char* way,
+                     lapack_int* n, lapack_complex_float* a,
+                     lapack_int* lda, const lapack_int* ipiv,
+                     lapack_complex_float* work , lapack_int *info );
+void LAPACK_csyswapr( char* uplo, lapack_int* n,
+                      lapack_complex_float* a, lapack_int* i1,
+                      lapack_int* i2 );
+void LAPACK_csytri2( char* uplo, lapack_int* n,
+                     lapack_complex_float* a, lapack_int* lda,
+                     const lapack_int* ipiv,
+                     lapack_complex_float* work, lapack_int* lwork , lapack_int *info );
+void LAPACK_csytri2x( char* uplo, lapack_int* n,
+                      lapack_complex_float* a, lapack_int* lda,
+                      const lapack_int* ipiv,
+                      lapack_complex_float* work, lapack_int* nb , lapack_int *info );
+void LAPACK_csytrs2( char* uplo, lapack_int* n,
+                     lapack_int* nrhs, const lapack_complex_float* a,
+                     lapack_int* lda, const lapack_int* ipiv,
+                     lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* work , lapack_int *info );
+void LAPACK_cunbdb( char* trans, char* signs,
+                    lapack_int* m, lapack_int* p, lapack_int* q,
+                    lapack_complex_float* x11, lapack_int* ldx11,
+                    lapack_complex_float* x12, lapack_int* ldx12,
+                    lapack_complex_float* x21, lapack_int* ldx21,
+                    lapack_complex_float* x22, lapack_int* ldx22,
+                    float* theta, float* phi,
+                    lapack_complex_float* taup1,
+                    lapack_complex_float* taup2,
+                    lapack_complex_float* tauq1,
+                    lapack_complex_float* tauq2,
+                    lapack_complex_float* work, lapack_int* lwork , lapack_int *info );
+void LAPACK_cuncsd( char* jobu1, char* jobu2,
+                    char* jobv1t, char* jobv2t, char* trans,
+                    char* signs, lapack_int* m, lapack_int* p,
+                    lapack_int* q, lapack_complex_float* x11,
+                    lapack_int* ldx11, lapack_complex_float* x12,
+                    lapack_int* ldx12, lapack_complex_float* x21,
+                    lapack_int* ldx21, lapack_complex_float* x22,
+                    lapack_int* ldx22, float* theta,
+                    lapack_complex_float* u1, lapack_int* ldu1,
+                    lapack_complex_float* u2, lapack_int* ldu2,
+                    lapack_complex_float* v1t, lapack_int* ldv1t,
+                    lapack_complex_float* v2t, lapack_int* ldv2t,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    float* rwork, lapack_int* lrwork,
+                    lapack_int* iwork , lapack_int *info );
+void LAPACK_dbbcsd( char* jobu1, char* jobu2,
+                    char* jobv1t, char* jobv2t, char* trans,
+                    lapack_int* m, lapack_int* p, lapack_int* q,
+                    double* theta, double* phi, double* u1,
+                    lapack_int* ldu1, double* u2, lapack_int* ldu2,
+                    double* v1t, lapack_int* ldv1t, double* v2t,
+                    lapack_int* ldv2t, double* b11d, double* b11e,
+                    double* b12d, double* b12e, double* b21d,
+                    double* b21e, double* b22d, double* b22e,
+                    double* work, lapack_int* lwork , lapack_int *info );
+void LAPACK_dorbdb( char* trans, char* signs,
+                    lapack_int* m, lapack_int* p, lapack_int* q,
+                    double* x11, lapack_int* ldx11, double* x12,
+                    lapack_int* ldx12, double* x21, lapack_int* ldx21,
+                    double* x22, lapack_int* ldx22, double* theta,
+                    double* phi, double* taup1, double* taup2,
+                    double* tauq1, double* tauq2, double* work,
+                    lapack_int* lwork , lapack_int *info );
+void LAPACK_dorcsd( char* jobu1, char* jobu2,
+                    char* jobv1t, char* jobv2t, char* trans,
+                    char* signs, lapack_int* m, lapack_int* p,
+                    lapack_int* q, double* x11, lapack_int* ldx11,
+                    double* x12, lapack_int* ldx12, double* x21,
+                    lapack_int* ldx21, double* x22, lapack_int* ldx22,
+                    double* theta, double* u1, lapack_int* ldu1,
+                    double* u2, lapack_int* ldu2, double* v1t,
+                    lapack_int* ldv1t, double* v2t, lapack_int* ldv2t,
+                    double* work, lapack_int* lwork,
+                    lapack_int* iwork , lapack_int *info );
+void LAPACK_dsyconv( char* uplo, char* way,
+                     lapack_int* n, double* a, lapack_int* lda,
+                     const lapack_int* ipiv, double* work , lapack_int *info );
+void LAPACK_dsyswapr( char* uplo, lapack_int* n,
+                      double* a, lapack_int* i1, lapack_int* i2 );
+void LAPACK_dsytri2( char* uplo, lapack_int* n,
+                     double* a, lapack_int* lda,
+                     const lapack_int* ipiv,
+                     lapack_complex_double* work, lapack_int* lwork , lapack_int *info );
+void LAPACK_dsytri2x( char* uplo, lapack_int* n,
+                      double* a, lapack_int* lda,
+                      const lapack_int* ipiv, double* work,
+                      lapack_int* nb , lapack_int *info );
+void LAPACK_dsytrs2( char* uplo, lapack_int* n,
+                     lapack_int* nrhs, const double* a,
+                     lapack_int* lda, const lapack_int* ipiv,
+                     double* b, lapack_int* ldb, double* work , lapack_int *info );
+void LAPACK_sbbcsd( char* jobu1, char* jobu2,
+                    char* jobv1t, char* jobv2t, char* trans,
+                    lapack_int* m, lapack_int* p, lapack_int* q,
+                    float* theta, float* phi, float* u1,
+                    lapack_int* ldu1, float* u2, lapack_int* ldu2,
+                    float* v1t, lapack_int* ldv1t, float* v2t,
+                    lapack_int* ldv2t, float* b11d, float* b11e,
+                    float* b12d, float* b12e, float* b21d,
+                    float* b21e, float* b22d, float* b22e,
+                    float* work, lapack_int* lwork , lapack_int *info );
+void LAPACK_sorbdb( char* trans, char* signs,
+                    lapack_int* m, lapack_int* p, lapack_int* q,
+                    float* x11, lapack_int* ldx11, float* x12,
+                    lapack_int* ldx12, float* x21, lapack_int* ldx21,
+                    float* x22, lapack_int* ldx22, float* theta,
+                    float* phi, float* taup1, float* taup2,
+                    float* tauq1, float* tauq2, float* work,
+                    lapack_int* lwork , lapack_int *info );
+void LAPACK_sorcsd( char* jobu1, char* jobu2,
+                    char* jobv1t, char* jobv2t, char* trans,
+                    char* signs, lapack_int* m, lapack_int* p,
+                    lapack_int* q, float* x11, lapack_int* ldx11,
+                    float* x12, lapack_int* ldx12, float* x21,
+                    lapack_int* ldx21, float* x22, lapack_int* ldx22,
+                    float* theta, float* u1, lapack_int* ldu1,
+                    float* u2, lapack_int* ldu2, float* v1t,
+                    lapack_int* ldv1t, float* v2t, lapack_int* ldv2t,
+                    float* work, lapack_int* lwork,
+                    lapack_int* iwork , lapack_int *info );
+void LAPACK_ssyconv( char* uplo, char* way,
+                     lapack_int* n, float* a, lapack_int* lda,
+                     const lapack_int* ipiv, float* work , lapack_int *info );
+void LAPACK_ssyswapr( char* uplo, lapack_int* n,
+                      float* a, lapack_int* i1, lapack_int* i2 );
+void LAPACK_ssytri2( char* uplo, lapack_int* n,
+                     float* a, lapack_int* lda,
+                     const lapack_int* ipiv,
+                     lapack_complex_float* work, lapack_int* lwork , lapack_int *info );
+void LAPACK_ssytri2x( char* uplo, lapack_int* n,
+                      float* a, lapack_int* lda,
+                      const lapack_int* ipiv, float* work,
+                      lapack_int* nb , lapack_int *info );
+void LAPACK_ssytrs2( char* uplo, lapack_int* n,
+                     lapack_int* nrhs, const float* a,
+                     lapack_int* lda, const lapack_int* ipiv,
+                     float* b, lapack_int* ldb, float* work , lapack_int *info );
+void LAPACK_zbbcsd( char* jobu1, char* jobu2,
+                    char* jobv1t, char* jobv2t, char* trans,
+                    lapack_int* m, lapack_int* p, lapack_int* q,
+                    double* theta, double* phi,
+                    lapack_complex_double* u1, lapack_int* ldu1,
+                    lapack_complex_double* u2, lapack_int* ldu2,
+                    lapack_complex_double* v1t, lapack_int* ldv1t,
+                    lapack_complex_double* v2t, lapack_int* ldv2t,
+                    double* b11d, double* b11e, double* b12d,
+                    double* b12e, double* b21d, double* b21e,
+                    double* b22d, double* b22e, double* rwork,
+                    lapack_int* lrwork , lapack_int *info );
+void LAPACK_zheswapr( char* uplo, lapack_int* n,
+                      lapack_complex_double* a, lapack_int* i1,
+                      lapack_int* i2 );
+void LAPACK_zhetri2( char* uplo, lapack_int* n,
+                     lapack_complex_double* a, lapack_int* lda,
+                     const lapack_int* ipiv,
+                     lapack_complex_double* work, lapack_int* lwork , lapack_int *info );
+void LAPACK_zhetri2x( char* uplo, lapack_int* n,
+                      lapack_complex_double* a, lapack_int* lda,
+                      const lapack_int* ipiv,
+                      lapack_complex_double* work, lapack_int* nb , lapack_int *info );
+void LAPACK_zhetrs2( char* uplo, lapack_int* n,
+                     lapack_int* nrhs,
+                     const lapack_complex_double* a, lapack_int* lda,
+                     const lapack_int* ipiv,
+                     lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* work , lapack_int *info );
+void LAPACK_zsyconv( char* uplo, char* way,
+                     lapack_int* n, lapack_complex_double* a,
+                     lapack_int* lda, const lapack_int* ipiv,
+                     lapack_complex_double* work , lapack_int *info );
+void LAPACK_zsyswapr( char* uplo, lapack_int* n,
+                      lapack_complex_double* a, lapack_int* i1,
+                      lapack_int* i2 );
+void LAPACK_zsytri2( char* uplo, lapack_int* n,
+                     lapack_complex_double* a, lapack_int* lda,
+                     const lapack_int* ipiv,
+                     lapack_complex_double* work, lapack_int* lwork , lapack_int *info );
+void LAPACK_zsytri2x( char* uplo, lapack_int* n,
+                      lapack_complex_double* a, lapack_int* lda,
+                      const lapack_int* ipiv,
+                      lapack_complex_double* work, lapack_int* nb , lapack_int *info );
+void LAPACK_zsytrs2( char* uplo, lapack_int* n,
+                     lapack_int* nrhs,
+                     const lapack_complex_double* a, lapack_int* lda,
+                     const lapack_int* ipiv,
+                     lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* work , lapack_int *info );
+void LAPACK_zunbdb( char* trans, char* signs,
+                    lapack_int* m, lapack_int* p, lapack_int* q,
+                    lapack_complex_double* x11, lapack_int* ldx11,
+                    lapack_complex_double* x12, lapack_int* ldx12,
+                    lapack_complex_double* x21, lapack_int* ldx21,
+                    lapack_complex_double* x22, lapack_int* ldx22,
+                    double* theta, double* phi,
+                    lapack_complex_double* taup1,
+                    lapack_complex_double* taup2,
+                    lapack_complex_double* tauq1,
+                    lapack_complex_double* tauq2,
+                    lapack_complex_double* work, lapack_int* lwork , lapack_int *info );
+void LAPACK_zuncsd( char* jobu1, char* jobu2,
+                    char* jobv1t, char* jobv2t, char* trans,
+                    char* signs, lapack_int* m, lapack_int* p,
+                    lapack_int* q, lapack_complex_double* x11,
+                    lapack_int* ldx11, lapack_complex_double* x12,
+                    lapack_int* ldx12, lapack_complex_double* x21,
+                    lapack_int* ldx21, lapack_complex_double* x22,
+                    lapack_int* ldx22, double* theta,
+                    lapack_complex_double* u1, lapack_int* ldu1,
+                    lapack_complex_double* u2, lapack_int* ldu2,
+                    lapack_complex_double* v1t, lapack_int* ldv1t,
+                    lapack_complex_double* v2t, lapack_int* ldv2t,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* lrwork,
+                    lapack_int* iwork , lapack_int *info );
+// LAPACK 3.4.0
+void LAPACK_sgemqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
+                     lapack_int* k, lapack_int* nb, const float* v,
+                     lapack_int* ldv, const float* t, lapack_int* ldt, float* c,
+                     lapack_int* ldc, float* work, lapack_int *info );
+void LAPACK_dgemqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
+                     lapack_int* k, lapack_int* nb, const double* v,
+                     lapack_int* ldv, const double* t, lapack_int* ldt,
+                     double* c, lapack_int* ldc, double* work,
+                     lapack_int *info );
+void LAPACK_cgemqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
+                     lapack_int* k, lapack_int* nb,
+                     const lapack_complex_float* v, lapack_int* ldv,
+                     const lapack_complex_float* t, lapack_int* ldt,
+                     lapack_complex_float* c, lapack_int* ldc,
+                     lapack_complex_float* work, lapack_int *info );
+void LAPACK_zgemqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
+                     lapack_int* k, lapack_int* nb,
+                     const lapack_complex_double* v, lapack_int* ldv,
+                     const lapack_complex_double* t, lapack_int* ldt,
+                     lapack_complex_double* c, lapack_int* ldc,
+                     lapack_complex_double* work, lapack_int *info );
+void LAPACK_sgeqrt( lapack_int* m, lapack_int* n, lapack_int* nb, float* a,
+                    lapack_int* lda, float* t, lapack_int* ldt, float* work,
+                    lapack_int *info );
+void LAPACK_dgeqrt( lapack_int* m, lapack_int* n, lapack_int* nb, double* a,
+                    lapack_int* lda, double* t, lapack_int* ldt, double* work,
+                    lapack_int *info );
+void LAPACK_cgeqrt( lapack_int* m, lapack_int* n, lapack_int* nb,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* t, lapack_int* ldt,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zgeqrt( lapack_int* m, lapack_int* n, lapack_int* nb,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* t, lapack_int* ldt,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_sgeqrt2( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                     float* t, lapack_int* ldt, lapack_int *info );
+void LAPACK_dgeqrt2( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                     double* t, lapack_int* ldt, lapack_int *info );
+void LAPACK_cgeqrt2( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                     lapack_int* lda, lapack_complex_float* t, lapack_int* ldt,
+                     lapack_int *info );
+void LAPACK_zgeqrt2( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                     lapack_int* lda, lapack_complex_double* t, lapack_int* ldt,
+                     lapack_int *info );
+void LAPACK_sgeqrt3( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                     float* t, lapack_int* ldt, lapack_int *info );
+void LAPACK_dgeqrt3( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                     double* t, lapack_int* ldt, lapack_int *info );
+void LAPACK_cgeqrt3( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                     lapack_int* lda, lapack_complex_float* t, lapack_int* ldt,
+                     lapack_int *info );
+void LAPACK_zgeqrt3( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                     lapack_int* lda, lapack_complex_double* t, lapack_int* ldt,
+                     lapack_int *info );
+void LAPACK_stpmqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
+                     lapack_int* k, lapack_int* l, lapack_int* nb,
+                     const float* v, lapack_int* ldv, const float* t,
+                     lapack_int* ldt, float* a, lapack_int* lda, float* b,
+                     lapack_int* ldb, float* work, lapack_int *info );
+void LAPACK_dtpmqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
+                     lapack_int* k, lapack_int* l, lapack_int* nb,
+                     const double* v, lapack_int* ldv, const double* t,
+                     lapack_int* ldt, double* a, lapack_int* lda, double* b,
+                     lapack_int* ldb, double* work, lapack_int *info );
+void LAPACK_ctpmqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
+                     lapack_int* k, lapack_int* l, lapack_int* nb,
+                     const lapack_complex_float* v, lapack_int* ldv,
+                     const lapack_complex_float* t, lapack_int* ldt,
+                     lapack_complex_float* a, lapack_int* lda,
+                     lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* work, lapack_int *info );
+void LAPACK_ztpmqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
+                     lapack_int* k, lapack_int* l, lapack_int* nb,
+                     const lapack_complex_double* v, lapack_int* ldv,
+                     const lapack_complex_double* t, lapack_int* ldt,
+                     lapack_complex_double* a, lapack_int* lda,
+                     lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* work, lapack_int *info );
+void LAPACK_dtpqrt( lapack_int* m, lapack_int* n, lapack_int* l, lapack_int* nb,
+                    double* a, lapack_int* lda, double* b, lapack_int* ldb,
+                    double* t, lapack_int* ldt, double* work,
+                    lapack_int *info );
+void LAPACK_ctpqrt( lapack_int* m, lapack_int* n, lapack_int* l, lapack_int* nb,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* t, lapack_complex_float* b,
+                    lapack_int* ldb, lapack_int* ldt,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_ztpqrt( lapack_int* m, lapack_int* n, lapack_int* l, lapack_int* nb,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* t, lapack_int* ldt,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_stpqrt2( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                     float* b, lapack_int* ldb, float* t, lapack_int* ldt,
+                     lapack_int *info );
+void LAPACK_dtpqrt2( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                     double* b, lapack_int* ldb, double* t, lapack_int* ldt,
+                     lapack_int *info );
+void LAPACK_ctpqrt2( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                     lapack_int* lda, lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* t, lapack_int* ldt,
+                     lapack_int *info );
+void LAPACK_ztpqrt2( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                     lapack_int* lda, lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* t, lapack_int* ldt,
+                     lapack_int *info );
+void LAPACK_stprfb( char* side, char* trans, char* direct, char* storev,
+                    lapack_int* m, lapack_int* n, lapack_int* k, lapack_int* l,
+                    const float* v, lapack_int* ldv, const float* t,
+                    lapack_int* ldt, float* a, lapack_int* lda, float* b,
+                    lapack_int* ldb, const float* mywork,
+                    lapack_int* myldwork );
+void LAPACK_dtprfb( char* side, char* trans, char* direct, char* storev,
+                    lapack_int* m, lapack_int* n, lapack_int* k, lapack_int* l,
+                    const double* v, lapack_int* ldv, const double* t,
+                    lapack_int* ldt, double* a, lapack_int* lda, double* b,
+                    lapack_int* ldb, const double* mywork,
+                    lapack_int* myldwork );
+void LAPACK_ctprfb( char* side, char* trans, char* direct, char* storev,
+                    lapack_int* m, lapack_int* n, lapack_int* k, lapack_int* l,
+                    const lapack_complex_float* v, lapack_int* ldv,
+                    const lapack_complex_float* t, lapack_int* ldt,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    const float* mywork, lapack_int* myldwork );
+void LAPACK_ztprfb( char* side, char* trans, char* direct, char* storev,
+                    lapack_int* m, lapack_int* n, lapack_int* k, lapack_int* l,
+                    const lapack_complex_double* v, lapack_int* ldv,
+                    const lapack_complex_double* t, lapack_int* ldt,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    const double* mywork, lapack_int* myldwork );
+// LAPACK 3.X.X
+void LAPACK_csyr( char* uplo, lapack_int* n, lapack_complex_float* alpha,
+                      const lapack_complex_float* x, lapack_int* incx,
+                      lapack_complex_float* a, lapack_int* lda );
+void LAPACK_zsyr( char* uplo, lapack_int* n, lapack_complex_double* alpha,
+                      const lapack_complex_double* x, lapack_int* incx,
+                      lapack_complex_double* a, lapack_int* lda );
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* _LAPACKE_H_ */
+
+#endif /* _MKL_LAPACKE_H_ */
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/misc/lapacke_mangling.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/misc/lapacke_mangling.h
new file mode 100644
index 00000000..6211fd14
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/misc/lapacke_mangling.h
@@ -0,0 +1,17 @@
+#ifndef LAPACK_HEADER_INCLUDED
+#define LAPACK_HEADER_INCLUDED
+
+#ifndef LAPACK_GLOBAL
+#if defined(LAPACK_GLOBAL_PATTERN_LC) || defined(ADD_)
+#define LAPACK_GLOBAL(lcname,UCNAME)  lcname##_
+#elif defined(LAPACK_GLOBAL_PATTERN_UC) || defined(UPPER)
+#define LAPACK_GLOBAL(lcname,UCNAME)  UCNAME
+#elif defined(LAPACK_GLOBAL_PATTERN_MC) || defined(NOCHANGE)
+#define LAPACK_GLOBAL(lcname,UCNAME)  lcname
+#else
+#define LAPACK_GLOBAL(lcname,UCNAME)  lcname##_
+#endif
+#endif
+
+#endif
+
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/plugins/ArrayCwiseBinaryOps.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/plugins/ArrayCwiseBinaryOps.h
new file mode 100644
index 00000000..1f8a531a
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/plugins/ArrayCwiseBinaryOps.h
@@ -0,0 +1,332 @@
+
+/** \returns an expression of the coefficient wise product of \c *this and \a other
+  *
+  * \sa MatrixBase::cwiseProduct
+  */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const EIGEN_CWISE_BINARY_RETURN_TYPE(Derived,OtherDerived,product)
+operator*(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  return EIGEN_CWISE_BINARY_RETURN_TYPE(Derived,OtherDerived,product)(derived(), other.derived());
+}
+
+/** \returns an expression of the coefficient wise quotient of \c *this and \a other
+  *
+  * \sa MatrixBase::cwiseQuotient
+  */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_quotient_op<Scalar,typename OtherDerived::Scalar>, const Derived, const OtherDerived>
+operator/(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  return CwiseBinaryOp<internal::scalar_quotient_op<Scalar,typename OtherDerived::Scalar>, const Derived, const OtherDerived>(derived(), other.derived());
+}
+
+/** \returns an expression of the coefficient-wise min of \c *this and \a other
+  *
+  * Example: \include Cwise_min.cpp
+  * Output: \verbinclude Cwise_min.out
+  *
+  * \sa max()
+  */
+EIGEN_MAKE_CWISE_BINARY_OP(min,min)
+
+/** \returns an expression of the coefficient-wise min of \c *this and scalar \a other
+  *
+  * \sa max()
+  */
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_min_op<Scalar,Scalar>, const Derived,
+                                        const CwiseNullaryOp<internal::scalar_constant_op<Scalar>, PlainObject> >
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+min
+#else
+(min)
+#endif
+(const Scalar &other) const
+{
+  return (min)(Derived::PlainObject::Constant(rows(), cols(), other));
+}
+
+/** \returns an expression of the coefficient-wise max of \c *this and \a other
+  *
+  * Example: \include Cwise_max.cpp
+  * Output: \verbinclude Cwise_max.out
+  *
+  * \sa min()
+  */
+EIGEN_MAKE_CWISE_BINARY_OP(max,max)
+
+/** \returns an expression of the coefficient-wise max of \c *this and scalar \a other
+  *
+  * \sa min()
+  */
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_max_op<Scalar,Scalar>, const Derived,
+                                        const CwiseNullaryOp<internal::scalar_constant_op<Scalar>, PlainObject> >
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+max
+#else
+(max)
+#endif
+(const Scalar &other) const
+{
+  return (max)(Derived::PlainObject::Constant(rows(), cols(), other));
+}
+
+/** \returns an expression of the coefficient-wise power of \c *this to the given array of \a exponents.
+  *
+  * This function computes the coefficient-wise power.
+  *
+  * Example: \include Cwise_array_power_array.cpp
+  * Output: \verbinclude Cwise_array_power_array.out
+  */
+EIGEN_MAKE_CWISE_BINARY_OP(pow,pow)
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+EIGEN_MAKE_SCALAR_BINARY_OP_ONTHERIGHT(pow,pow)
+#else
+/** \returns an expression of the coefficients of \c *this rasied to the constant power \a exponent
+  *
+  * \tparam T is the scalar type of \a exponent. It must be compatible with the scalar type of the given expression.
+  *
+  * This function computes the coefficient-wise power. The function MatrixBase::pow() in the
+  * unsupported module MatrixFunctions computes the matrix power.
+  *
+  * Example: \include Cwise_pow.cpp
+  * Output: \verbinclude Cwise_pow.out
+  *
+  * \sa ArrayBase::pow(ArrayBase), square(), cube(), exp(), log()
+  */
+template<typename T>
+const CwiseBinaryOp<internal::scalar_pow_op<Scalar,T>,Derived,Constant<T> > pow(const T& exponent) const;
+#endif
+
+
+// TODO code generating macros could be moved to Macros.h and could include generation of documentation
+#define EIGEN_MAKE_CWISE_COMP_OP(OP, COMPARATOR) \
+template<typename OtherDerived> \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_cmp_op<Scalar, typename OtherDerived::Scalar, internal::cmp_ ## COMPARATOR>, const Derived, const OtherDerived> \
+OP(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const \
+{ \
+  return CwiseBinaryOp<internal::scalar_cmp_op<Scalar, typename OtherDerived::Scalar, internal::cmp_ ## COMPARATOR>, const Derived, const OtherDerived>(derived(), other.derived()); \
+}\
+typedef CwiseBinaryOp<internal::scalar_cmp_op<Scalar,Scalar, internal::cmp_ ## COMPARATOR>, const Derived, const CwiseNullaryOp<internal::scalar_constant_op<Scalar>, PlainObject> > Cmp ## COMPARATOR ## ReturnType; \
+typedef CwiseBinaryOp<internal::scalar_cmp_op<Scalar,Scalar, internal::cmp_ ## COMPARATOR>, const CwiseNullaryOp<internal::scalar_constant_op<Scalar>, PlainObject>, const Derived > RCmp ## COMPARATOR ## ReturnType; \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Cmp ## COMPARATOR ## ReturnType \
+OP(const Scalar& s) const { \
+  return this->OP(Derived::PlainObject::Constant(rows(), cols(), s)); \
+} \
+EIGEN_DEVICE_FUNC friend EIGEN_STRONG_INLINE const RCmp ## COMPARATOR ## ReturnType \
+OP(const Scalar& s, const Derived& d) { \
+  return Derived::PlainObject::Constant(d.rows(), d.cols(), s).OP(d); \
+}
+
+#define EIGEN_MAKE_CWISE_COMP_R_OP(OP, R_OP, RCOMPARATOR) \
+template<typename OtherDerived> \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_cmp_op<typename OtherDerived::Scalar, Scalar, internal::cmp_##RCOMPARATOR>, const OtherDerived, const Derived> \
+OP(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const \
+{ \
+  return CwiseBinaryOp<internal::scalar_cmp_op<typename OtherDerived::Scalar, Scalar, internal::cmp_##RCOMPARATOR>, const OtherDerived, const Derived>(other.derived(), derived()); \
+} \
+EIGEN_DEVICE_FUNC \
+inline const RCmp ## RCOMPARATOR ## ReturnType \
+OP(const Scalar& s) const { \
+  return Derived::PlainObject::Constant(rows(), cols(), s).R_OP(*this); \
+} \
+friend inline const Cmp ## RCOMPARATOR ## ReturnType \
+OP(const Scalar& s, const Derived& d) { \
+  return d.R_OP(Derived::PlainObject::Constant(d.rows(), d.cols(), s)); \
+}
+
+
+
+/** \returns an expression of the coefficient-wise \< operator of *this and \a other
+  *
+  * Example: \include Cwise_less.cpp
+  * Output: \verbinclude Cwise_less.out
+  *
+  * \sa all(), any(), operator>(), operator<=()
+  */
+EIGEN_MAKE_CWISE_COMP_OP(operator<, LT)
+
+/** \returns an expression of the coefficient-wise \<= operator of *this and \a other
+  *
+  * Example: \include Cwise_less_equal.cpp
+  * Output: \verbinclude Cwise_less_equal.out
+  *
+  * \sa all(), any(), operator>=(), operator<()
+  */
+EIGEN_MAKE_CWISE_COMP_OP(operator<=, LE)
+
+/** \returns an expression of the coefficient-wise \> operator of *this and \a other
+  *
+  * Example: \include Cwise_greater.cpp
+  * Output: \verbinclude Cwise_greater.out
+  *
+  * \sa all(), any(), operator>=(), operator<()
+  */
+EIGEN_MAKE_CWISE_COMP_R_OP(operator>, operator<, LT)
+
+/** \returns an expression of the coefficient-wise \>= operator of *this and \a other
+  *
+  * Example: \include Cwise_greater_equal.cpp
+  * Output: \verbinclude Cwise_greater_equal.out
+  *
+  * \sa all(), any(), operator>(), operator<=()
+  */
+EIGEN_MAKE_CWISE_COMP_R_OP(operator>=, operator<=, LE)
+
+/** \returns an expression of the coefficient-wise == operator of *this and \a other
+  *
+  * \warning this performs an exact comparison, which is generally a bad idea with floating-point types.
+  * In order to check for equality between two vectors or matrices with floating-point coefficients, it is
+  * generally a far better idea to use a fuzzy comparison as provided by isApprox() and
+  * isMuchSmallerThan().
+  *
+  * Example: \include Cwise_equal_equal.cpp
+  * Output: \verbinclude Cwise_equal_equal.out
+  *
+  * \sa all(), any(), isApprox(), isMuchSmallerThan()
+  */
+EIGEN_MAKE_CWISE_COMP_OP(operator==, EQ)
+
+/** \returns an expression of the coefficient-wise != operator of *this and \a other
+  *
+  * \warning this performs an exact comparison, which is generally a bad idea with floating-point types.
+  * In order to check for equality between two vectors or matrices with floating-point coefficients, it is
+  * generally a far better idea to use a fuzzy comparison as provided by isApprox() and
+  * isMuchSmallerThan().
+  *
+  * Example: \include Cwise_not_equal.cpp
+  * Output: \verbinclude Cwise_not_equal.out
+  *
+  * \sa all(), any(), isApprox(), isMuchSmallerThan()
+  */
+EIGEN_MAKE_CWISE_COMP_OP(operator!=, NEQ)
+
+
+#undef EIGEN_MAKE_CWISE_COMP_OP
+#undef EIGEN_MAKE_CWISE_COMP_R_OP
+
+// scalar addition
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+EIGEN_MAKE_SCALAR_BINARY_OP(operator+,sum)
+#else
+/** \returns an expression of \c *this with each coeff incremented by the constant \a scalar
+  *
+  * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression.
+  *
+  * Example: \include Cwise_plus.cpp
+  * Output: \verbinclude Cwise_plus.out
+  *
+  * \sa operator+=(), operator-()
+  */
+template<typename T>
+const CwiseBinaryOp<internal::scalar_sum_op<Scalar,T>,Derived,Constant<T> > operator+(const T& scalar) const;
+/** \returns an expression of \a expr with each coeff incremented by the constant \a scalar
+  *
+  * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression.
+  */
+template<typename T> friend
+const CwiseBinaryOp<internal::scalar_sum_op<T,Scalar>,Constant<T>,Derived> operator+(const T& scalar, const StorageBaseType& expr);
+#endif
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+EIGEN_MAKE_SCALAR_BINARY_OP(operator-,difference)
+#else
+/** \returns an expression of \c *this with each coeff decremented by the constant \a scalar
+  *
+  * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression.
+  *
+  * Example: \include Cwise_minus.cpp
+  * Output: \verbinclude Cwise_minus.out
+  *
+  * \sa operator+=(), operator-()
+  */
+template<typename T>
+const CwiseBinaryOp<internal::scalar_difference_op<Scalar,T>,Derived,Constant<T> > operator-(const T& scalar) const;
+/** \returns an expression of the constant matrix of value \a scalar decremented by the coefficients of \a expr
+  *
+  * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression.
+  */
+template<typename T> friend
+const CwiseBinaryOp<internal::scalar_difference_op<T,Scalar>,Constant<T>,Derived> operator-(const T& scalar, const StorageBaseType& expr);
+#endif
+
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+  EIGEN_MAKE_SCALAR_BINARY_OP_ONTHELEFT(operator/,quotient)
+#else
+  /**
+    * \brief Component-wise division of the scalar \a s by array elements of \a a.
+    *
+    * \tparam Scalar is the scalar type of \a x. It must be compatible with the scalar type of the given array expression (\c Derived::Scalar).
+    */
+  template<typename T> friend
+  inline const CwiseBinaryOp<internal::scalar_quotient_op<T,Scalar>,Constant<T>,Derived>
+  operator/(const T& s,const StorageBaseType& a);
+#endif
+
+/** \returns an expression of the coefficient-wise ^ operator of *this and \a other
+ *
+ * \warning this operator is for expression of bool only.
+ *
+ * Example: \include Cwise_boolean_xor.cpp
+ * Output: \verbinclude Cwise_boolean_xor.out
+ *
+ * \sa operator&&(), select()
+ */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+inline const CwiseBinaryOp<internal::scalar_boolean_xor_op, const Derived, const OtherDerived>
+operator^(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  EIGEN_STATIC_ASSERT((internal::is_same<bool,Scalar>::value && internal::is_same<bool,typename OtherDerived::Scalar>::value),
+                      THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_OF_BOOL);
+  return CwiseBinaryOp<internal::scalar_boolean_xor_op, const Derived, const OtherDerived>(derived(),other.derived());
+}
+
+// NOTE disabled until we agree on argument order
+#if 0
+/** \cpp11 \returns an expression of the coefficient-wise polygamma function.
+  *
+  * \specialfunctions_module
+  *
+  * It returns the \a n -th derivative of the digamma(psi) evaluated at \c *this.
+  *
+  * \warning Be careful with the order of the parameters: x.polygamma(n) is equivalent to polygamma(n,x)
+  *
+  * \sa Eigen::polygamma()
+  */
+template<typename DerivedN>
+inline const CwiseBinaryOp<internal::scalar_polygamma_op<Scalar>, const DerivedN, const Derived>
+polygamma(const EIGEN_CURRENT_STORAGE_BASE_CLASS<DerivedN> &n) const
+{
+  return CwiseBinaryOp<internal::scalar_polygamma_op<Scalar>, const DerivedN, const Derived>(n.derived(), this->derived());
+}
+#endif
+
+/** \returns an expression of the coefficient-wise zeta function.
+  *
+  * \specialfunctions_module
+  *
+  * It returns the Riemann zeta function of two arguments \c *this and \a q:
+  *
+  * \param *this is the exposent, it must be > 1
+  * \param q is the shift, it must be > 0
+  *
+  * \note This function supports only float and double scalar types. To support other scalar types, the user has
+  * to provide implementations of zeta(T,T) for any scalar type T to be supported.
+  *
+  * This method is an alias for zeta(*this,q);
+  *
+  * \sa Eigen::zeta()
+  */
+template<typename DerivedQ>
+inline const CwiseBinaryOp<internal::scalar_zeta_op<Scalar>, const Derived, const DerivedQ>
+zeta(const EIGEN_CURRENT_STORAGE_BASE_CLASS<DerivedQ> &q) const
+{
+  return CwiseBinaryOp<internal::scalar_zeta_op<Scalar>, const Derived, const DerivedQ>(this->derived(), q.derived());
+}
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/plugins/ArrayCwiseUnaryOps.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/plugins/ArrayCwiseUnaryOps.h
new file mode 100644
index 00000000..43615bd5
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/plugins/ArrayCwiseUnaryOps.h
@@ -0,0 +1,567 @@
+
+
+typedef CwiseUnaryOp<internal::scalar_abs_op<Scalar>, const Derived> AbsReturnType;
+typedef CwiseUnaryOp<internal::scalar_arg_op<Scalar>, const Derived> ArgReturnType;
+typedef CwiseUnaryOp<internal::scalar_abs2_op<Scalar>, const Derived> Abs2ReturnType;
+typedef CwiseUnaryOp<internal::scalar_sqrt_op<Scalar>, const Derived> SqrtReturnType;
+typedef CwiseUnaryOp<internal::scalar_rsqrt_op<Scalar>, const Derived> RsqrtReturnType;
+typedef CwiseUnaryOp<internal::scalar_sign_op<Scalar>, const Derived> SignReturnType;
+typedef CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, const Derived> InverseReturnType;
+typedef CwiseUnaryOp<internal::scalar_boolean_not_op<Scalar>, const Derived> BooleanNotReturnType;
+
+typedef CwiseUnaryOp<internal::scalar_exp_op<Scalar>, const Derived> ExpReturnType;
+typedef CwiseUnaryOp<internal::scalar_expm1_op<Scalar>, const Derived> Expm1ReturnType;
+typedef CwiseUnaryOp<internal::scalar_log_op<Scalar>, const Derived> LogReturnType;
+typedef CwiseUnaryOp<internal::scalar_log1p_op<Scalar>, const Derived> Log1pReturnType;
+typedef CwiseUnaryOp<internal::scalar_log10_op<Scalar>, const Derived> Log10ReturnType;
+typedef CwiseUnaryOp<internal::scalar_cos_op<Scalar>, const Derived> CosReturnType;
+typedef CwiseUnaryOp<internal::scalar_sin_op<Scalar>, const Derived> SinReturnType;
+typedef CwiseUnaryOp<internal::scalar_tan_op<Scalar>, const Derived> TanReturnType;
+typedef CwiseUnaryOp<internal::scalar_acos_op<Scalar>, const Derived> AcosReturnType;
+typedef CwiseUnaryOp<internal::scalar_asin_op<Scalar>, const Derived> AsinReturnType;
+typedef CwiseUnaryOp<internal::scalar_atan_op<Scalar>, const Derived> AtanReturnType;
+typedef CwiseUnaryOp<internal::scalar_tanh_op<Scalar>, const Derived> TanhReturnType;
+typedef CwiseUnaryOp<internal::scalar_sinh_op<Scalar>, const Derived> SinhReturnType;
+typedef CwiseUnaryOp<internal::scalar_cosh_op<Scalar>, const Derived> CoshReturnType;
+typedef CwiseUnaryOp<internal::scalar_square_op<Scalar>, const Derived> SquareReturnType;
+typedef CwiseUnaryOp<internal::scalar_cube_op<Scalar>, const Derived> CubeReturnType;
+typedef CwiseUnaryOp<internal::scalar_round_op<Scalar>, const Derived> RoundReturnType;
+typedef CwiseUnaryOp<internal::scalar_floor_op<Scalar>, const Derived> FloorReturnType;
+typedef CwiseUnaryOp<internal::scalar_ceil_op<Scalar>, const Derived> CeilReturnType;
+typedef CwiseUnaryOp<internal::scalar_isnan_op<Scalar>, const Derived> IsNaNReturnType;
+typedef CwiseUnaryOp<internal::scalar_isinf_op<Scalar>, const Derived> IsInfReturnType;
+typedef CwiseUnaryOp<internal::scalar_isfinite_op<Scalar>, const Derived> IsFiniteReturnType;
+
+/** \returns an expression of the coefficient-wise absolute value of \c *this
+  *
+  * Example: \include Cwise_abs.cpp
+  * Output: \verbinclude Cwise_abs.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_abs">Math functions</a>, abs2()
+  */
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const AbsReturnType
+abs() const
+{
+  return AbsReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise phase angle of \c *this
+  *
+  * Example: \include Cwise_arg.cpp
+  * Output: \verbinclude Cwise_arg.out
+  *
+  * \sa abs()
+  */
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const ArgReturnType
+arg() const
+{
+  return ArgReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise squared absolute value of \c *this
+  *
+  * Example: \include Cwise_abs2.cpp
+  * Output: \verbinclude Cwise_abs2.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_abs2">Math functions</a>, abs(), square()
+  */
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const Abs2ReturnType
+abs2() const
+{
+  return Abs2ReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise exponential of *this.
+  *
+  * This function computes the coefficient-wise exponential. The function MatrixBase::exp() in the
+  * unsupported module MatrixFunctions computes the matrix exponential.
+  *
+  * Example: \include Cwise_exp.cpp
+  * Output: \verbinclude Cwise_exp.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_exp">Math functions</a>, pow(), log(), sin(), cos()
+  */
+EIGEN_DEVICE_FUNC
+inline const ExpReturnType
+exp() const
+{
+  return ExpReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise exponential of *this minus 1.
+  *
+  * In exact arithmetic, \c x.expm1() is equivalent to \c x.exp() - 1,
+  * however, with finite precision, this function is much more accurate when \c x is close to zero.
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_expm1">Math functions</a>, exp()
+  */
+EIGEN_DEVICE_FUNC
+inline const Expm1ReturnType
+expm1() const
+{
+  return Expm1ReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise logarithm of *this.
+  *
+  * This function computes the coefficient-wise logarithm. The function MatrixBase::log() in the
+  * unsupported module MatrixFunctions computes the matrix logarithm.
+  *
+  * Example: \include Cwise_log.cpp
+  * Output: \verbinclude Cwise_log.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_log">Math functions</a>, log()
+  */
+EIGEN_DEVICE_FUNC
+inline const LogReturnType
+log() const
+{
+  return LogReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise logarithm of 1 plus \c *this.
+  *
+  * In exact arithmetic, \c x.log() is equivalent to \c (x+1).log(),
+  * however, with finite precision, this function is much more accurate when \c x is close to zero.
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_log1p">Math functions</a>, log()
+  */
+EIGEN_DEVICE_FUNC
+inline const Log1pReturnType
+log1p() const
+{
+  return Log1pReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise base-10 logarithm of *this.
+  *
+  * This function computes the coefficient-wise base-10 logarithm.
+  *
+  * Example: \include Cwise_log10.cpp
+  * Output: \verbinclude Cwise_log10.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_log10">Math functions</a>, log()
+  */
+EIGEN_DEVICE_FUNC
+inline const Log10ReturnType
+log10() const
+{
+  return Log10ReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise square root of *this.
+  *
+  * This function computes the coefficient-wise square root. The function MatrixBase::sqrt() in the
+  * unsupported module MatrixFunctions computes the matrix square root.
+  *
+  * Example: \include Cwise_sqrt.cpp
+  * Output: \verbinclude Cwise_sqrt.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_sqrt">Math functions</a>, pow(), square()
+  */
+EIGEN_DEVICE_FUNC
+inline const SqrtReturnType
+sqrt() const
+{
+  return SqrtReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise inverse square root of *this.
+  *
+  * This function computes the coefficient-wise inverse square root.
+  *
+  * Example: \include Cwise_sqrt.cpp
+  * Output: \verbinclude Cwise_sqrt.out
+  *
+  * \sa pow(), square()
+  */
+EIGEN_DEVICE_FUNC
+inline const RsqrtReturnType
+rsqrt() const
+{
+  return RsqrtReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise signum of *this.
+  *
+  * This function computes the coefficient-wise signum.
+  *
+  * Example: \include Cwise_sign.cpp
+  * Output: \verbinclude Cwise_sign.out
+  *
+  * \sa pow(), square()
+  */
+EIGEN_DEVICE_FUNC
+inline const SignReturnType
+sign() const
+{
+  return SignReturnType(derived());
+}
+
+
+/** \returns an expression of the coefficient-wise cosine of *this.
+  *
+  * This function computes the coefficient-wise cosine. The function MatrixBase::cos() in the
+  * unsupported module MatrixFunctions computes the matrix cosine.
+  *
+  * Example: \include Cwise_cos.cpp
+  * Output: \verbinclude Cwise_cos.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_cos">Math functions</a>, sin(), acos()
+  */
+EIGEN_DEVICE_FUNC
+inline const CosReturnType
+cos() const
+{
+  return CosReturnType(derived());
+}
+
+
+/** \returns an expression of the coefficient-wise sine of *this.
+  *
+  * This function computes the coefficient-wise sine. The function MatrixBase::sin() in the
+  * unsupported module MatrixFunctions computes the matrix sine.
+  *
+  * Example: \include Cwise_sin.cpp
+  * Output: \verbinclude Cwise_sin.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_sin">Math functions</a>, cos(), asin()
+  */
+EIGEN_DEVICE_FUNC
+inline const SinReturnType
+sin() const
+{
+  return SinReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise tan of *this.
+  *
+  * Example: \include Cwise_tan.cpp
+  * Output: \verbinclude Cwise_tan.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_tan">Math functions</a>, cos(), sin()
+  */
+EIGEN_DEVICE_FUNC
+inline const TanReturnType
+tan() const
+{
+  return TanReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise arc tan of *this.
+  *
+  * Example: \include Cwise_atan.cpp
+  * Output: \verbinclude Cwise_atan.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_atan">Math functions</a>, tan(), asin(), acos()
+  */
+EIGEN_DEVICE_FUNC
+inline const AtanReturnType
+atan() const
+{
+  return AtanReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise arc cosine of *this.
+  *
+  * Example: \include Cwise_acos.cpp
+  * Output: \verbinclude Cwise_acos.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_acos">Math functions</a>, cos(), asin()
+  */
+EIGEN_DEVICE_FUNC
+inline const AcosReturnType
+acos() const
+{
+  return AcosReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise arc sine of *this.
+  *
+  * Example: \include Cwise_asin.cpp
+  * Output: \verbinclude Cwise_asin.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_asin">Math functions</a>, sin(), acos()
+  */
+EIGEN_DEVICE_FUNC
+inline const AsinReturnType
+asin() const
+{
+  return AsinReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise hyperbolic tan of *this.
+  *
+  * Example: \include Cwise_tanh.cpp
+  * Output: \verbinclude Cwise_tanh.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_tanh">Math functions</a>, tan(), sinh(), cosh()
+  */
+EIGEN_DEVICE_FUNC
+inline const TanhReturnType
+tanh() const
+{
+  return TanhReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise hyperbolic sin of *this.
+  *
+  * Example: \include Cwise_sinh.cpp
+  * Output: \verbinclude Cwise_sinh.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_sinh">Math functions</a>, sin(), tanh(), cosh()
+  */
+EIGEN_DEVICE_FUNC
+inline const SinhReturnType
+sinh() const
+{
+  return SinhReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise hyperbolic cos of *this.
+  *
+  * Example: \include Cwise_cosh.cpp
+  * Output: \verbinclude Cwise_cosh.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_cosh">Math functions</a>, tan(), sinh(), cosh()
+  */
+EIGEN_DEVICE_FUNC
+inline const CoshReturnType
+cosh() const
+{
+  return CoshReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise inverse of *this.
+  *
+  * Example: \include Cwise_inverse.cpp
+  * Output: \verbinclude Cwise_inverse.out
+  *
+  * \sa operator/(), operator*()
+  */
+EIGEN_DEVICE_FUNC
+inline const InverseReturnType
+inverse() const
+{
+  return InverseReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise square of *this.
+  *
+  * Example: \include Cwise_square.cpp
+  * Output: \verbinclude Cwise_square.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_squareE">Math functions</a>, abs2(), cube(), pow()
+  */
+EIGEN_DEVICE_FUNC
+inline const SquareReturnType
+square() const
+{
+  return SquareReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise cube of *this.
+  *
+  * Example: \include Cwise_cube.cpp
+  * Output: \verbinclude Cwise_cube.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_cube">Math functions</a>, square(), pow()
+  */
+EIGEN_DEVICE_FUNC
+inline const CubeReturnType
+cube() const
+{
+  return CubeReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise round of *this.
+  *
+  * Example: \include Cwise_round.cpp
+  * Output: \verbinclude Cwise_round.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_round">Math functions</a>, ceil(), floor()
+  */
+EIGEN_DEVICE_FUNC
+inline const RoundReturnType
+round() const
+{
+  return RoundReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise floor of *this.
+  *
+  * Example: \include Cwise_floor.cpp
+  * Output: \verbinclude Cwise_floor.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_floor">Math functions</a>, ceil(), round()
+  */
+EIGEN_DEVICE_FUNC
+inline const FloorReturnType
+floor() const
+{
+  return FloorReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise ceil of *this.
+  *
+  * Example: \include Cwise_ceil.cpp
+  * Output: \verbinclude Cwise_ceil.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_ceil">Math functions</a>, floor(), round()
+  */
+EIGEN_DEVICE_FUNC
+inline const CeilReturnType
+ceil() const
+{
+  return CeilReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise isnan of *this.
+  *
+  * Example: \include Cwise_isNaN.cpp
+  * Output: \verbinclude Cwise_isNaN.out
+  *
+  * \sa isfinite(), isinf()
+  */
+EIGEN_DEVICE_FUNC
+inline const IsNaNReturnType
+isNaN() const
+{
+  return IsNaNReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise isinf of *this.
+  *
+  * Example: \include Cwise_isInf.cpp
+  * Output: \verbinclude Cwise_isInf.out
+  *
+  * \sa isnan(), isfinite()
+  */
+EIGEN_DEVICE_FUNC
+inline const IsInfReturnType
+isInf() const
+{
+  return IsInfReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise isfinite of *this.
+  *
+  * Example: \include Cwise_isFinite.cpp
+  * Output: \verbinclude Cwise_isFinite.out
+  *
+  * \sa isnan(), isinf()
+  */
+EIGEN_DEVICE_FUNC
+inline const IsFiniteReturnType
+isFinite() const
+{
+  return IsFiniteReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise ! operator of *this
+  *
+  * \warning this operator is for expression of bool only.
+  *
+  * Example: \include Cwise_boolean_not.cpp
+  * Output: \verbinclude Cwise_boolean_not.out
+  *
+  * \sa operator!=()
+  */
+EIGEN_DEVICE_FUNC
+inline const BooleanNotReturnType
+operator!() const
+{
+  EIGEN_STATIC_ASSERT((internal::is_same<bool,Scalar>::value),
+                      THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_OF_BOOL);
+  return BooleanNotReturnType(derived());
+}
+
+
+// --- SpecialFunctions module ---
+
+typedef CwiseUnaryOp<internal::scalar_lgamma_op<Scalar>, const Derived> LgammaReturnType;
+typedef CwiseUnaryOp<internal::scalar_digamma_op<Scalar>, const Derived> DigammaReturnType;
+typedef CwiseUnaryOp<internal::scalar_erf_op<Scalar>, const Derived> ErfReturnType;
+typedef CwiseUnaryOp<internal::scalar_erfc_op<Scalar>, const Derived> ErfcReturnType;
+
+/** \cpp11 \returns an expression of the coefficient-wise ln(|gamma(*this)|).
+  *
+  * \specialfunctions_module
+  *
+  * Example: \include Cwise_lgamma.cpp
+  * Output: \verbinclude Cwise_lgamma.out
+  *
+  * \note This function supports only float and double scalar types in c++11 mode. To support other scalar types,
+  * or float/double in non c++11 mode, the user has to provide implementations of lgamma(T) for any scalar
+  * type T to be supported.
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_lgamma">Math functions</a>, digamma()
+  */
+EIGEN_DEVICE_FUNC
+inline const LgammaReturnType
+lgamma() const
+{
+  return LgammaReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise digamma (psi, derivative of lgamma).
+  *
+  * \specialfunctions_module
+  *
+  * \note This function supports only float and double scalar types. To support other scalar types,
+  * the user has to provide implementations of digamma(T) for any scalar
+  * type T to be supported.
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_digamma">Math functions</a>, Eigen::digamma(), Eigen::polygamma(), lgamma()
+  */
+EIGEN_DEVICE_FUNC
+inline const DigammaReturnType
+digamma() const
+{
+  return DigammaReturnType(derived());
+}
+
+/** \cpp11 \returns an expression of the coefficient-wise Gauss error
+  * function of *this.
+  *
+  * \specialfunctions_module
+  *
+  * Example: \include Cwise_erf.cpp
+  * Output: \verbinclude Cwise_erf.out
+  *
+  * \note This function supports only float and double scalar types in c++11 mode. To support other scalar types,
+  * or float/double in non c++11 mode, the user has to provide implementations of erf(T) for any scalar
+  * type T to be supported.
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_erf">Math functions</a>, erfc()
+  */
+EIGEN_DEVICE_FUNC
+inline const ErfReturnType
+erf() const
+{
+  return ErfReturnType(derived());
+}
+
+/** \cpp11 \returns an expression of the coefficient-wise Complementary error
+  * function of *this.
+  *
+  * \specialfunctions_module
+  *
+  * Example: \include Cwise_erfc.cpp
+  * Output: \verbinclude Cwise_erfc.out
+  *
+  * \note This function supports only float and double scalar types in c++11 mode. To support other scalar types,
+  * or float/double in non c++11 mode, the user has to provide implementations of erfc(T) for any scalar
+  * type T to be supported.
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_erfc">Math functions</a>, erf()
+  */
+EIGEN_DEVICE_FUNC
+inline const ErfcReturnType
+erfc() const
+{
+  return ErfcReturnType(derived());
+}
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/plugins/BlockMethods.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/plugins/BlockMethods.h
new file mode 100644
index 00000000..5caf1446
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/plugins/BlockMethods.h
@@ -0,0 +1,1356 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+
+/// \internal expression type of a column */
+typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, 1, !IsRowMajor> ColXpr;
+typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, 1, !IsRowMajor> ConstColXpr;
+/// \internal expression type of a row */
+typedef Block<Derived, 1, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> RowXpr;
+typedef const Block<const Derived, 1, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> ConstRowXpr;
+/// \internal expression type of a block of whole columns */
+typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, Dynamic, !IsRowMajor> ColsBlockXpr;
+typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, Dynamic, !IsRowMajor> ConstColsBlockXpr;
+/// \internal expression type of a block of whole rows */
+typedef Block<Derived, Dynamic, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> RowsBlockXpr;
+typedef const Block<const Derived, Dynamic, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> ConstRowsBlockXpr;
+/// \internal expression type of a block of whole columns */
+template<int N> struct NColsBlockXpr { typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, N, !IsRowMajor> Type; };
+template<int N> struct ConstNColsBlockXpr { typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, N, !IsRowMajor> Type; };
+/// \internal expression type of a block of whole rows */
+template<int N> struct NRowsBlockXpr { typedef Block<Derived, N, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> Type; };
+template<int N> struct ConstNRowsBlockXpr { typedef const Block<const Derived, N, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> Type; };
+/// \internal expression of a block */
+typedef Block<Derived> BlockXpr;
+typedef const Block<const Derived> ConstBlockXpr;
+/// \internal expression of a block of fixed sizes */
+template<int Rows, int Cols> struct FixedBlockXpr { typedef Block<Derived,Rows,Cols> Type; };
+template<int Rows, int Cols> struct ConstFixedBlockXpr { typedef Block<const Derived,Rows,Cols> Type; };
+
+typedef VectorBlock<Derived> SegmentReturnType;
+typedef const VectorBlock<const Derived> ConstSegmentReturnType;
+template<int Size> struct FixedSegmentReturnType { typedef VectorBlock<Derived, Size> Type; };
+template<int Size> struct ConstFixedSegmentReturnType { typedef const VectorBlock<const Derived, Size> Type; };
+
+#endif // not EIGEN_PARSED_BY_DOXYGEN
+
+/// \returns an expression of a block in \c *this with either dynamic or fixed sizes.
+///
+/// \param  startRow  the first row in the block
+/// \param  startCol  the first column in the block
+/// \param  blockRows number of rows in the block, specified at either run-time or compile-time
+/// \param  blockCols number of columns in the block, specified at either run-time or compile-time
+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
+///
+/// Example using runtime (aka dynamic) sizes: \include MatrixBase_block_int_int_int_int.cpp
+/// Output: \verbinclude MatrixBase_block_int_int_int_int.out
+///
+/// \newin{3.4}:
+///
+/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments. In the later case, \c n plays the role of a runtime fallback value in case \c N equals Eigen::Dynamic.
+/// Here is an example with a fixed number of rows \c NRows and dynamic number of columns \c cols:
+/// \code
+/// mat.block(i,j,fix<NRows>,cols)
+/// \endcode
+///
+/// This function thus fully covers the features offered by the following overloads block<NRows,NCols>(Index, Index),
+/// and block<NRows,NCols>(Index, Index, Index, Index) that are thus obsolete. Indeed, this generic version avoids
+/// redundancy, it preserves the argument order, and prevents the need to rely on the template keyword in templated code.
+///
+/// but with less redundancy and more consistency as it does not modify the argument order
+/// and seamlessly enable hybrid fixed/dynamic sizes.
+///
+/// \note Even in the case that the returned expression has dynamic size, in the case
+/// when it is applied to a fixed-size matrix, it inherits a fixed maximal size,
+/// which means that evaluating it does not cause a dynamic memory allocation.
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa class Block, fix, fix<N>(int)
+///
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+inline typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+#else
+inline typename FixedBlockXpr<...,...>::Type
+#endif
+block(Index startRow, Index startCol, NRowsType blockRows, NColsType blockCols)
+{
+  return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type(
+            derived(), startRow, startCol, internal::get_runtime_value(blockRows), internal::get_runtime_value(blockCols));
+}
+
+/// This is the const version of block(Index,Index,NRowsType,NColsType)
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+inline const typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+#else
+inline const typename ConstFixedBlockXpr<...,...>::Type
+#endif
+block(Index startRow, Index startCol, NRowsType blockRows, NColsType blockCols) const
+{
+  return typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type(
+            derived(), startRow, startCol, internal::get_runtime_value(blockRows), internal::get_runtime_value(blockCols));
+}
+
+
+
+/// \returns a expression of a top-right corner of \c *this with either dynamic or fixed sizes.
+///
+/// \param cRows the number of rows in the corner
+/// \param cCols the number of columns in the corner
+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
+///
+/// Example with dynamic sizes: \include MatrixBase_topRightCorner_int_int.cpp
+/// Output: \verbinclude MatrixBase_topRightCorner_int_int.out
+///
+/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments. See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+inline typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+#else
+inline typename FixedBlockXpr<...,...>::Type
+#endif
+topRightCorner(NRowsType cRows, NColsType cCols)
+{
+  return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), 0, cols() - internal::get_runtime_value(cCols), internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+}
+
+/// This is the const version of topRightCorner(NRowsType, NColsType).
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+inline const typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+#else
+inline const typename ConstFixedBlockXpr<...,...>::Type
+#endif
+topRightCorner(NRowsType cRows, NColsType cCols) const
+{
+  return typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), 0, cols() - internal::get_runtime_value(cCols), internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+}
+
+/// \returns an expression of a fixed-size top-right corner of \c *this.
+///
+/// \tparam CRows the number of rows in the corner
+/// \tparam CCols the number of columns in the corner
+///
+/// Example: \include MatrixBase_template_int_int_topRightCorner.cpp
+/// Output: \verbinclude MatrixBase_template_int_int_topRightCorner.out
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa class Block, block<int,int>(Index,Index)
+///
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC
+inline typename FixedBlockXpr<CRows,CCols>::Type topRightCorner()
+{
+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), 0, cols() - CCols);
+}
+
+/// This is the const version of topRightCorner<int, int>().
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC
+inline const typename ConstFixedBlockXpr<CRows,CCols>::Type topRightCorner() const
+{
+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, cols() - CCols);
+}
+
+/// \returns an expression of a top-right corner of \c *this.
+///
+/// \tparam CRows number of rows in corner as specified at compile-time
+/// \tparam CCols number of columns in corner as specified at compile-time
+/// \param  cRows number of rows in corner as specified at run-time
+/// \param  cCols number of columns in corner as specified at run-time
+///
+/// This function is mainly useful for corners where the number of rows is specified at compile-time
+/// and the number of columns is specified at run-time, or vice versa. The compile-time and run-time
+/// information should not contradict. In other words, \a cRows should equal \a CRows unless
+/// \a CRows is \a Dynamic, and the same for the number of columns.
+///
+/// Example: \include MatrixBase_template_int_int_topRightCorner_int_int.cpp
+/// Output: \verbinclude MatrixBase_template_int_int_topRightCorner_int_int.out
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa class Block
+///
+template<int CRows, int CCols>
+inline typename FixedBlockXpr<CRows,CCols>::Type topRightCorner(Index cRows, Index cCols)
+{
+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), 0, cols() - cCols, cRows, cCols);
+}
+
+/// This is the const version of topRightCorner<int, int>(Index, Index).
+template<int CRows, int CCols>
+inline const typename ConstFixedBlockXpr<CRows,CCols>::Type topRightCorner(Index cRows, Index cCols) const
+{
+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, cols() - cCols, cRows, cCols);
+}
+
+
+
+/// \returns an expression of a top-left corner of \c *this  with either dynamic or fixed sizes.
+///
+/// \param cRows the number of rows in the corner
+/// \param cCols the number of columns in the corner
+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
+///
+/// Example: \include MatrixBase_topLeftCorner_int_int.cpp
+/// Output: \verbinclude MatrixBase_topLeftCorner_int_int.out
+///
+/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments. See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+inline typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+#else
+inline typename FixedBlockXpr<...,...>::Type
+#endif
+topLeftCorner(NRowsType cRows, NColsType cCols)
+{
+  return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), 0, 0, internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+}
+
+/// This is the const version of topLeftCorner(Index, Index).
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+inline const typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+#else
+inline const typename ConstFixedBlockXpr<...,...>::Type
+#endif
+topLeftCorner(NRowsType cRows, NColsType cCols) const
+{
+  return typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), 0, 0, internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+}
+
+/// \returns an expression of a fixed-size top-left corner of \c *this.
+///
+/// The template parameters CRows and CCols are the number of rows and columns in the corner.
+///
+/// Example: \include MatrixBase_template_int_int_topLeftCorner.cpp
+/// Output: \verbinclude MatrixBase_template_int_int_topLeftCorner.out
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC
+inline typename FixedBlockXpr<CRows,CCols>::Type topLeftCorner()
+{
+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), 0, 0);
+}
+
+/// This is the const version of topLeftCorner<int, int>().
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC
+inline const typename ConstFixedBlockXpr<CRows,CCols>::Type topLeftCorner() const
+{
+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, 0);
+}
+
+/// \returns an expression of a top-left corner of \c *this.
+///
+/// \tparam CRows number of rows in corner as specified at compile-time
+/// \tparam CCols number of columns in corner as specified at compile-time
+/// \param  cRows number of rows in corner as specified at run-time
+/// \param  cCols number of columns in corner as specified at run-time
+///
+/// This function is mainly useful for corners where the number of rows is specified at compile-time
+/// and the number of columns is specified at run-time, or vice versa. The compile-time and run-time
+/// information should not contradict. In other words, \a cRows should equal \a CRows unless
+/// \a CRows is \a Dynamic, and the same for the number of columns.
+///
+/// Example: \include MatrixBase_template_int_int_topLeftCorner_int_int.cpp
+/// Output: \verbinclude MatrixBase_template_int_int_topLeftCorner_int_int.out
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa class Block
+///
+template<int CRows, int CCols>
+inline typename FixedBlockXpr<CRows,CCols>::Type topLeftCorner(Index cRows, Index cCols)
+{
+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), 0, 0, cRows, cCols);
+}
+
+/// This is the const version of topLeftCorner<int, int>(Index, Index).
+template<int CRows, int CCols>
+inline const typename ConstFixedBlockXpr<CRows,CCols>::Type topLeftCorner(Index cRows, Index cCols) const
+{
+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, 0, cRows, cCols);
+}
+
+
+
+/// \returns an expression of a bottom-right corner of \c *this  with either dynamic or fixed sizes.
+///
+/// \param cRows the number of rows in the corner
+/// \param cCols the number of columns in the corner
+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
+///
+/// Example: \include MatrixBase_bottomRightCorner_int_int.cpp
+/// Output: \verbinclude MatrixBase_bottomRightCorner_int_int.out
+///
+/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments. See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+inline typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+#else
+inline typename FixedBlockXpr<...,...>::Type
+#endif
+bottomRightCorner(NRowsType cRows, NColsType cCols)
+{
+  return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), rows() - internal::get_runtime_value(cRows), cols() - internal::get_runtime_value(cCols),
+                        internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+}
+
+/// This is the const version of bottomRightCorner(NRowsType, NColsType).
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+inline const typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+#else
+inline const typename ConstFixedBlockXpr<...,...>::Type
+#endif
+bottomRightCorner(NRowsType cRows, NColsType cCols) const
+{
+  return typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), rows() - internal::get_runtime_value(cRows), cols() - internal::get_runtime_value(cCols),
+                        internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+}
+
+/// \returns an expression of a fixed-size bottom-right corner of \c *this.
+///
+/// The template parameters CRows and CCols are the number of rows and columns in the corner.
+///
+/// Example: \include MatrixBase_template_int_int_bottomRightCorner.cpp
+/// Output: \verbinclude MatrixBase_template_int_int_bottomRightCorner.out
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC
+inline typename FixedBlockXpr<CRows,CCols>::Type bottomRightCorner()
+{
+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, cols() - CCols);
+}
+
+/// This is the const version of bottomRightCorner<int, int>().
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC
+inline const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomRightCorner() const
+{
+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, cols() - CCols);
+}
+
+/// \returns an expression of a bottom-right corner of \c *this.
+///
+/// \tparam CRows number of rows in corner as specified at compile-time
+/// \tparam CCols number of columns in corner as specified at compile-time
+/// \param  cRows number of rows in corner as specified at run-time
+/// \param  cCols number of columns in corner as specified at run-time
+///
+/// This function is mainly useful for corners where the number of rows is specified at compile-time
+/// and the number of columns is specified at run-time, or vice versa. The compile-time and run-time
+/// information should not contradict. In other words, \a cRows should equal \a CRows unless
+/// \a CRows is \a Dynamic, and the same for the number of columns.
+///
+/// Example: \include MatrixBase_template_int_int_bottomRightCorner_int_int.cpp
+/// Output: \verbinclude MatrixBase_template_int_int_bottomRightCorner_int_int.out
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa class Block
+///
+template<int CRows, int CCols>
+inline typename FixedBlockXpr<CRows,CCols>::Type bottomRightCorner(Index cRows, Index cCols)
+{
+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), rows() - cRows, cols() - cCols, cRows, cCols);
+}
+
+/// This is the const version of bottomRightCorner<int, int>(Index, Index).
+template<int CRows, int CCols>
+inline const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomRightCorner(Index cRows, Index cCols) const
+{
+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - cRows, cols() - cCols, cRows, cCols);
+}
+
+
+
+/// \returns an expression of a bottom-left corner of \c *this  with either dynamic or fixed sizes.
+///
+/// \param cRows the number of rows in the corner
+/// \param cCols the number of columns in the corner
+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
+///
+/// Example: \include MatrixBase_bottomLeftCorner_int_int.cpp
+/// Output: \verbinclude MatrixBase_bottomLeftCorner_int_int.out
+///
+/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments. See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+inline typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+#else
+inline typename FixedBlockXpr<...,...>::Type
+#endif
+bottomLeftCorner(NRowsType cRows, NColsType cCols)
+{
+  return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), rows() - internal::get_runtime_value(cRows), 0,
+                        internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+}
+
+/// This is the const version of bottomLeftCorner(NRowsType, NColsType).
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+inline typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+#else
+inline typename ConstFixedBlockXpr<...,...>::Type
+#endif
+bottomLeftCorner(NRowsType cRows, NColsType cCols) const
+{
+  return typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), rows() - internal::get_runtime_value(cRows), 0,
+                        internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+}
+
+/// \returns an expression of a fixed-size bottom-left corner of \c *this.
+///
+/// The template parameters CRows and CCols are the number of rows and columns in the corner.
+///
+/// Example: \include MatrixBase_template_int_int_bottomLeftCorner.cpp
+/// Output: \verbinclude MatrixBase_template_int_int_bottomLeftCorner.out
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC
+inline typename FixedBlockXpr<CRows,CCols>::Type bottomLeftCorner()
+{
+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, 0);
+}
+
+/// This is the const version of bottomLeftCorner<int, int>().
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC
+inline const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomLeftCorner() const
+{
+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, 0);
+}
+
+/// \returns an expression of a bottom-left corner of \c *this.
+///
+/// \tparam CRows number of rows in corner as specified at compile-time
+/// \tparam CCols number of columns in corner as specified at compile-time
+/// \param  cRows number of rows in corner as specified at run-time
+/// \param  cCols number of columns in corner as specified at run-time
+///
+/// This function is mainly useful for corners where the number of rows is specified at compile-time
+/// and the number of columns is specified at run-time, or vice versa. The compile-time and run-time
+/// information should not contradict. In other words, \a cRows should equal \a CRows unless
+/// \a CRows is \a Dynamic, and the same for the number of columns.
+///
+/// Example: \include MatrixBase_template_int_int_bottomLeftCorner_int_int.cpp
+/// Output: \verbinclude MatrixBase_template_int_int_bottomLeftCorner_int_int.out
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa class Block
+///
+template<int CRows, int CCols>
+inline typename FixedBlockXpr<CRows,CCols>::Type bottomLeftCorner(Index cRows, Index cCols)
+{
+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), rows() - cRows, 0, cRows, cCols);
+}
+
+/// This is the const version of bottomLeftCorner<int, int>(Index, Index).
+template<int CRows, int CCols>
+inline const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomLeftCorner(Index cRows, Index cCols) const
+{
+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - cRows, 0, cRows, cCols);
+}
+
+
+
+/// \returns a block consisting of the top rows of \c *this.
+///
+/// \param n the number of rows in the block
+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
+///
+/// Example: \include MatrixBase_topRows_int.cpp
+/// Output: \verbinclude MatrixBase_topRows_int.out
+///
+/// The number of rows \a n can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments.
+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<typename NRowsType>
+EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+inline typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+#else
+inline typename NRowsBlockXpr<...>::Type
+#endif
+topRows(NRowsType n)
+{
+  return typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+            (derived(), 0, 0, internal::get_runtime_value(n), cols());
+}
+
+/// This is the const version of topRows(NRowsType).
+template<typename NRowsType>
+EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+inline const typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+#else
+inline const typename ConstNRowsBlockXpr<...>::Type
+#endif
+topRows(NRowsType n) const
+{
+  return typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+            (derived(), 0, 0, internal::get_runtime_value(n), cols());
+}
+
+/// \returns a block consisting of the top rows of \c *this.
+///
+/// \tparam N the number of rows in the block as specified at compile-time
+/// \param n the number of rows in the block as specified at run-time
+///
+/// The compile-time and run-time information should not contradict. In other words,
+/// \a n should equal \a N unless \a N is \a Dynamic.
+///
+/// Example: \include MatrixBase_template_int_topRows.cpp
+/// Output: \verbinclude MatrixBase_template_int_topRows.out
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int N>
+EIGEN_DEVICE_FUNC
+inline typename NRowsBlockXpr<N>::Type topRows(Index n = N)
+{
+  return typename NRowsBlockXpr<N>::Type(derived(), 0, 0, n, cols());
+}
+
+/// This is the const version of topRows<int>().
+template<int N>
+EIGEN_DEVICE_FUNC
+inline typename ConstNRowsBlockXpr<N>::Type topRows(Index n = N) const
+{
+  return typename ConstNRowsBlockXpr<N>::Type(derived(), 0, 0, n, cols());
+}
+
+
+
+/// \returns a block consisting of the bottom rows of \c *this.
+///
+/// \param n the number of rows in the block
+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
+///
+/// Example: \include MatrixBase_bottomRows_int.cpp
+/// Output: \verbinclude MatrixBase_bottomRows_int.out
+///
+/// The number of rows \a n can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments.
+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<typename NRowsType>
+EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+inline typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+#else
+inline typename NRowsBlockXpr<...>::Type
+#endif
+bottomRows(NRowsType n)
+{
+  return typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+            (derived(), rows() - internal::get_runtime_value(n), 0, internal::get_runtime_value(n), cols());
+}
+
+/// This is the const version of bottomRows(NRowsType).
+template<typename NRowsType>
+EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+inline const typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+#else
+inline const typename ConstNRowsBlockXpr<...>::Type
+#endif
+bottomRows(NRowsType n) const
+{
+  return typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+            (derived(), rows() - internal::get_runtime_value(n), 0, internal::get_runtime_value(n), cols());
+}
+
+/// \returns a block consisting of the bottom rows of \c *this.
+///
+/// \tparam N the number of rows in the block as specified at compile-time
+/// \param n the number of rows in the block as specified at run-time
+///
+/// The compile-time and run-time information should not contradict. In other words,
+/// \a n should equal \a N unless \a N is \a Dynamic.
+///
+/// Example: \include MatrixBase_template_int_bottomRows.cpp
+/// Output: \verbinclude MatrixBase_template_int_bottomRows.out
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int N>
+EIGEN_DEVICE_FUNC
+inline typename NRowsBlockXpr<N>::Type bottomRows(Index n = N)
+{
+  return typename NRowsBlockXpr<N>::Type(derived(), rows() - n, 0, n, cols());
+}
+
+/// This is the const version of bottomRows<int>().
+template<int N>
+EIGEN_DEVICE_FUNC
+inline typename ConstNRowsBlockXpr<N>::Type bottomRows(Index n = N) const
+{
+  return typename ConstNRowsBlockXpr<N>::Type(derived(), rows() - n, 0, n, cols());
+}
+
+
+
+/// \returns a block consisting of a range of rows of \c *this.
+///
+/// \param startRow the index of the first row in the block
+/// \param n the number of rows in the block
+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
+///
+/// Example: \include DenseBase_middleRows_int.cpp
+/// Output: \verbinclude DenseBase_middleRows_int.out
+///
+/// The number of rows \a n can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments.
+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<typename NRowsType>
+EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+inline typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+#else
+inline typename NRowsBlockXpr<...>::Type
+#endif
+middleRows(Index startRow, NRowsType n)
+{
+  return typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+            (derived(), startRow, 0, internal::get_runtime_value(n), cols());
+}
+
+/// This is the const version of middleRows(Index,NRowsType).
+template<typename NRowsType>
+EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+inline const typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+#else
+inline const typename ConstNRowsBlockXpr<...>::Type
+#endif
+middleRows(Index startRow, NRowsType n) const
+{
+  return typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+            (derived(), startRow, 0, internal::get_runtime_value(n), cols());
+}
+
+/// \returns a block consisting of a range of rows of \c *this.
+///
+/// \tparam N the number of rows in the block as specified at compile-time
+/// \param startRow the index of the first row in the block
+/// \param n the number of rows in the block as specified at run-time
+///
+/// The compile-time and run-time information should not contradict. In other words,
+/// \a n should equal \a N unless \a N is \a Dynamic.
+///
+/// Example: \include DenseBase_template_int_middleRows.cpp
+/// Output: \verbinclude DenseBase_template_int_middleRows.out
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int N>
+EIGEN_DEVICE_FUNC
+inline typename NRowsBlockXpr<N>::Type middleRows(Index startRow, Index n = N)
+{
+  return typename NRowsBlockXpr<N>::Type(derived(), startRow, 0, n, cols());
+}
+
+/// This is the const version of middleRows<int>().
+template<int N>
+EIGEN_DEVICE_FUNC
+inline typename ConstNRowsBlockXpr<N>::Type middleRows(Index startRow, Index n = N) const
+{
+  return typename ConstNRowsBlockXpr<N>::Type(derived(), startRow, 0, n, cols());
+}
+
+
+
+/// \returns a block consisting of the left columns of \c *this.
+///
+/// \param n the number of columns in the block
+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
+///
+/// Example: \include MatrixBase_leftCols_int.cpp
+/// Output: \verbinclude MatrixBase_leftCols_int.out
+///
+/// The number of columns \a n can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments.
+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<typename NColsType>
+EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+inline typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+#else
+inline typename NColsBlockXpr<...>::Type
+#endif
+leftCols(NColsType n)
+{
+  return typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), 0, 0, rows(), internal::get_runtime_value(n));
+}
+
+/// This is the const version of leftCols(NColsType).
+template<typename NColsType>
+EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+inline const typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+#else
+inline const typename ConstNColsBlockXpr<...>::Type
+#endif
+leftCols(NColsType n) const
+{
+  return typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), 0, 0, rows(), internal::get_runtime_value(n));
+}
+
+/// \returns a block consisting of the left columns of \c *this.
+///
+/// \tparam N the number of columns in the block as specified at compile-time
+/// \param n the number of columns in the block as specified at run-time
+///
+/// The compile-time and run-time information should not contradict. In other words,
+/// \a n should equal \a N unless \a N is \a Dynamic.
+///
+/// Example: \include MatrixBase_template_int_leftCols.cpp
+/// Output: \verbinclude MatrixBase_template_int_leftCols.out
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int N>
+EIGEN_DEVICE_FUNC
+inline typename NColsBlockXpr<N>::Type leftCols(Index n = N)
+{
+  return typename NColsBlockXpr<N>::Type(derived(), 0, 0, rows(), n);
+}
+
+/// This is the const version of leftCols<int>().
+template<int N>
+EIGEN_DEVICE_FUNC
+inline typename ConstNColsBlockXpr<N>::Type leftCols(Index n = N) const
+{
+  return typename ConstNColsBlockXpr<N>::Type(derived(), 0, 0, rows(), n);
+}
+
+
+
+/// \returns a block consisting of the right columns of \c *this.
+///
+/// \param n the number of columns in the block
+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
+///
+/// Example: \include MatrixBase_rightCols_int.cpp
+/// Output: \verbinclude MatrixBase_rightCols_int.out
+///
+/// The number of columns \a n can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments.
+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<typename NColsType>
+EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+inline typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+#else
+inline typename NColsBlockXpr<...>::Type
+#endif
+rightCols(NColsType n)
+{
+  return typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), 0, cols() - internal::get_runtime_value(n), rows(), internal::get_runtime_value(n));
+}
+
+/// This is the const version of rightCols(NColsType).
+template<typename NColsType>
+EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+inline const typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+#else
+inline const typename ConstNColsBlockXpr<...>::Type
+#endif
+rightCols(NColsType n) const
+{
+  return typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), 0, cols() - internal::get_runtime_value(n), rows(), internal::get_runtime_value(n));
+}
+
+/// \returns a block consisting of the right columns of \c *this.
+///
+/// \tparam N the number of columns in the block as specified at compile-time
+/// \param n the number of columns in the block as specified at run-time
+///
+/// The compile-time and run-time information should not contradict. In other words,
+/// \a n should equal \a N unless \a N is \a Dynamic.
+///
+/// Example: \include MatrixBase_template_int_rightCols.cpp
+/// Output: \verbinclude MatrixBase_template_int_rightCols.out
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int N>
+EIGEN_DEVICE_FUNC
+inline typename NColsBlockXpr<N>::Type rightCols(Index n = N)
+{
+  return typename NColsBlockXpr<N>::Type(derived(), 0, cols() - n, rows(), n);
+}
+
+/// This is the const version of rightCols<int>().
+template<int N>
+EIGEN_DEVICE_FUNC
+inline typename ConstNColsBlockXpr<N>::Type rightCols(Index n = N) const
+{
+  return typename ConstNColsBlockXpr<N>::Type(derived(), 0, cols() - n, rows(), n);
+}
+
+
+
+/// \returns a block consisting of a range of columns of \c *this.
+///
+/// \param startCol the index of the first column in the block
+/// \param numCols the number of columns in the block
+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
+///
+/// Example: \include DenseBase_middleCols_int.cpp
+/// Output: \verbinclude DenseBase_middleCols_int.out
+///
+/// The number of columns \a n can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments.
+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<typename NColsType>
+EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+inline typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+#else
+inline typename NColsBlockXpr<...>::Type
+#endif
+middleCols(Index startCol, NColsType numCols)
+{
+  return typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), 0, startCol, rows(), internal::get_runtime_value(numCols));
+}
+
+/// This is the const version of middleCols(Index,NColsType).
+template<typename NColsType>
+EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+inline const typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+#else
+inline const typename ConstNColsBlockXpr<...>::Type
+#endif
+middleCols(Index startCol, NColsType numCols) const
+{
+  return typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), 0, startCol, rows(), internal::get_runtime_value(numCols));
+}
+
+/// \returns a block consisting of a range of columns of \c *this.
+///
+/// \tparam N the number of columns in the block as specified at compile-time
+/// \param startCol the index of the first column in the block
+/// \param n the number of columns in the block as specified at run-time
+///
+/// The compile-time and run-time information should not contradict. In other words,
+/// \a n should equal \a N unless \a N is \a Dynamic.
+///
+/// Example: \include DenseBase_template_int_middleCols.cpp
+/// Output: \verbinclude DenseBase_template_int_middleCols.out
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int N>
+EIGEN_DEVICE_FUNC
+inline typename NColsBlockXpr<N>::Type middleCols(Index startCol, Index n = N)
+{
+  return typename NColsBlockXpr<N>::Type(derived(), 0, startCol, rows(), n);
+}
+
+/// This is the const version of middleCols<int>().
+template<int N>
+EIGEN_DEVICE_FUNC
+inline typename ConstNColsBlockXpr<N>::Type middleCols(Index startCol, Index n = N) const
+{
+  return typename ConstNColsBlockXpr<N>::Type(derived(), 0, startCol, rows(), n);
+}
+
+
+
+/// \returns a fixed-size expression of a block of \c *this.
+///
+/// The template parameters \a NRows and \a NCols are the number of
+/// rows and columns in the block.
+///
+/// \param startRow the first row in the block
+/// \param startCol the first column in the block
+///
+/// Example: \include MatrixBase_block_int_int.cpp
+/// Output: \verbinclude MatrixBase_block_int_int.out
+///
+/// \note The usage of of this overload is discouraged from %Eigen 3.4, better used the generic
+/// block(Index,Index,NRowsType,NColsType), here is the one-to-one equivalence:
+/// \code
+/// mat.template block<NRows,NCols>(i,j)  <-->  mat.block(i,j,fix<NRows>,fix<NCols>)
+/// \endcode
+///
+/// \note since block is a templated member, the keyword template has to be used
+/// if the matrix type is also a template parameter: \code m.template block<3,3>(1,1); \endcode
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int NRows, int NCols>
+EIGEN_DEVICE_FUNC
+inline typename FixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index startCol)
+{
+  return typename FixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol);
+}
+
+/// This is the const version of block<>(Index, Index). */
+template<int NRows, int NCols>
+EIGEN_DEVICE_FUNC
+inline const typename ConstFixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index startCol) const
+{
+  return typename ConstFixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol);
+}
+
+/// \returns an expression of a block of \c *this.
+///
+/// \tparam NRows number of rows in block as specified at compile-time
+/// \tparam NCols number of columns in block as specified at compile-time
+/// \param  startRow  the first row in the block
+/// \param  startCol  the first column in the block
+/// \param  blockRows number of rows in block as specified at run-time
+/// \param  blockCols number of columns in block as specified at run-time
+///
+/// This function is mainly useful for blocks where the number of rows is specified at compile-time
+/// and the number of columns is specified at run-time, or vice versa. The compile-time and run-time
+/// information should not contradict. In other words, \a blockRows should equal \a NRows unless
+/// \a NRows is \a Dynamic, and the same for the number of columns.
+///
+/// Example: \include MatrixBase_template_int_int_block_int_int_int_int.cpp
+/// Output: \verbinclude MatrixBase_template_int_int_block_int_int_int_int.cpp
+///
+/// \note The usage of of this overload is discouraged from %Eigen 3.4, better used the generic
+/// block(Index,Index,NRowsType,NColsType), here is the one-to-one complete equivalence:
+/// \code
+/// mat.template block<NRows,NCols>(i,j,rows,cols)     <-->  mat.block(i,j,fix<NRows>(rows),fix<NCols>(cols))
+/// \endcode
+/// If we known that, e.g., NRows==Dynamic and NCols!=Dynamic, then the equivalence becomes:
+/// \code
+/// mat.template block<Dynamic,NCols>(i,j,rows,NCols)  <-->  mat.block(i,j,rows,fix<NCols>)
+/// \endcode
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int NRows, int NCols>
+inline typename FixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index startCol,
+                                                  Index blockRows, Index blockCols)
+{
+  return typename FixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol, blockRows, blockCols);
+}
+
+/// This is the const version of block<>(Index, Index, Index, Index).
+template<int NRows, int NCols>
+inline const typename ConstFixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index startCol,
+                                                              Index blockRows, Index blockCols) const
+{
+  return typename ConstFixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol, blockRows, blockCols);
+}
+
+/// \returns an expression of the \a i-th column of \c *this. Note that the numbering starts at 0.
+///
+/// Example: \include MatrixBase_col.cpp
+/// Output: \verbinclude MatrixBase_col.out
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
+/**
+  * \sa row(), class Block */
+EIGEN_DEVICE_FUNC
+inline ColXpr col(Index i)
+{
+  return ColXpr(derived(), i);
+}
+
+/// This is the const version of col().
+EIGEN_DEVICE_FUNC
+inline ConstColXpr col(Index i) const
+{
+  return ConstColXpr(derived(), i);
+}
+
+/// \returns an expression of the \a i-th row of \c *this. Note that the numbering starts at 0.
+///
+/// Example: \include MatrixBase_row.cpp
+/// Output: \verbinclude MatrixBase_row.out
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
+/**
+  * \sa col(), class Block */
+EIGEN_DEVICE_FUNC
+inline RowXpr row(Index i)
+{
+  return RowXpr(derived(), i);
+}
+
+/// This is the const version of row(). */
+EIGEN_DEVICE_FUNC
+inline ConstRowXpr row(Index i) const
+{
+  return ConstRowXpr(derived(), i);
+}
+
+/// \returns an expression of a segment (i.e. a vector block) in \c *this with either dynamic or fixed sizes.
+///
+/// \only_for_vectors
+///
+/// \param start the first coefficient in the segment
+/// \param n the number of coefficients in the segment
+/// \tparam NType the type of the value handling the number of coefficients in the segment, typically Index.
+///
+/// Example: \include MatrixBase_segment_int_int.cpp
+/// Output: \verbinclude MatrixBase_segment_int_int.out
+///
+/// The number of coefficients \a n can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments.
+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+/// \note Even in the case that the returned expression has dynamic size, in the case
+/// when it is applied to a fixed-size vector, it inherits a fixed maximal size,
+/// which means that evaluating it does not cause a dynamic memory allocation.
+///
+/// \sa block(Index,Index,NRowsType,NColsType), fix<N>, fix<N>(int), class Block
+///
+template<typename NType>
+EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+inline typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+#else
+inline typename FixedSegmentReturnType<...>::Type
+#endif
+segment(Index start, NType n)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+            (derived(), start, internal::get_runtime_value(n));
+}
+
+
+/// This is the const version of segment(Index,NType).
+template<typename NType>
+EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+inline const typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+#else
+inline const typename ConstFixedSegmentReturnType<...>::Type
+#endif
+segment(Index start, NType n) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+            (derived(), start, internal::get_runtime_value(n));
+}
+
+/// \returns an expression of the first coefficients of \c *this with either dynamic or fixed sizes.
+///
+/// \only_for_vectors
+///
+/// \param n the number of coefficients in the segment
+/// \tparam NType the type of the value handling the number of coefficients in the segment, typically Index.
+///
+/// Example: \include MatrixBase_start_int.cpp
+/// Output: \verbinclude MatrixBase_start_int.out
+///
+/// The number of coefficients \a n can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments.
+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+/// \note Even in the case that the returned expression has dynamic size, in the case
+/// when it is applied to a fixed-size vector, it inherits a fixed maximal size,
+/// which means that evaluating it does not cause a dynamic memory allocation.
+///
+/// \sa class Block, block(Index,Index)
+///
+template<typename NType>
+EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+inline typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+#else
+inline typename FixedSegmentReturnType<...>::Type
+#endif
+head(NType n)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+              (derived(), 0, internal::get_runtime_value(n));
+}
+
+/// This is the const version of head(NType).
+template<typename NType>
+EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+inline const typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+#else
+inline const typename ConstFixedSegmentReturnType<...>::Type
+#endif
+head(NType n) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+            (derived(), 0, internal::get_runtime_value(n));
+}
+
+/// \returns an expression of a last coefficients of \c *this with either dynamic or fixed sizes.
+///
+/// \only_for_vectors
+///
+/// \param n the number of coefficients in the segment
+/// \tparam NType the type of the value handling the number of coefficients in the segment, typically Index.
+///
+/// Example: \include MatrixBase_end_int.cpp
+/// Output: \verbinclude MatrixBase_end_int.out
+///
+/// The number of coefficients \a n can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments.
+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+/// \note Even in the case that the returned expression has dynamic size, in the case
+/// when it is applied to a fixed-size vector, it inherits a fixed maximal size,
+/// which means that evaluating it does not cause a dynamic memory allocation.
+///
+/// \sa class Block, block(Index,Index)
+///
+template<typename NType>
+EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+inline typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+#else
+inline typename FixedSegmentReturnType<...>::Type
+#endif
+tail(NType n)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+            (derived(), this->size() - internal::get_runtime_value(n), internal::get_runtime_value(n));
+}
+
+/// This is the const version of tail(Index).
+template<typename NType>
+EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+inline const typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+#else
+inline const typename ConstFixedSegmentReturnType<...>::Type
+#endif
+tail(NType n) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+            (derived(), this->size() - internal::get_runtime_value(n), internal::get_runtime_value(n));
+}
+
+/// \returns a fixed-size expression of a segment (i.e. a vector block) in \c *this
+///
+/// \only_for_vectors
+///
+/// \tparam N the number of coefficients in the segment as specified at compile-time
+/// \param start the index of the first element in the segment
+/// \param n the number of coefficients in the segment as specified at compile-time
+///
+/// The compile-time and run-time information should not contradict. In other words,
+/// \a n should equal \a N unless \a N is \a Dynamic.
+///
+/// Example: \include MatrixBase_template_int_segment.cpp
+/// Output: \verbinclude MatrixBase_template_int_segment.out
+///
+/// \sa segment(Index,NType), class Block
+///
+template<int N>
+EIGEN_DEVICE_FUNC
+inline typename FixedSegmentReturnType<N>::Type segment(Index start, Index n = N)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename FixedSegmentReturnType<N>::Type(derived(), start, n);
+}
+
+/// This is the const version of segment<int>(Index).
+template<int N>
+EIGEN_DEVICE_FUNC
+inline typename ConstFixedSegmentReturnType<N>::Type segment(Index start, Index n = N) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename ConstFixedSegmentReturnType<N>::Type(derived(), start, n);
+}
+
+/// \returns a fixed-size expression of the first coefficients of \c *this.
+///
+/// \only_for_vectors
+///
+/// \tparam N the number of coefficients in the segment as specified at compile-time
+/// \param  n the number of coefficients in the segment as specified at run-time
+///
+/// The compile-time and run-time information should not contradict. In other words,
+/// \a n should equal \a N unless \a N is \a Dynamic.
+///
+/// Example: \include MatrixBase_template_int_start.cpp
+/// Output: \verbinclude MatrixBase_template_int_start.out
+///
+/// \sa head(NType), class Block
+///
+template<int N>
+EIGEN_DEVICE_FUNC
+inline typename FixedSegmentReturnType<N>::Type head(Index n = N)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename FixedSegmentReturnType<N>::Type(derived(), 0, n);
+}
+
+/// This is the const version of head<int>().
+template<int N>
+EIGEN_DEVICE_FUNC
+inline typename ConstFixedSegmentReturnType<N>::Type head(Index n = N) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename ConstFixedSegmentReturnType<N>::Type(derived(), 0, n);
+}
+
+/// \returns a fixed-size expression of the last coefficients of \c *this.
+///
+/// \only_for_vectors
+///
+/// \tparam N the number of coefficients in the segment as specified at compile-time
+/// \param  n the number of coefficients in the segment as specified at run-time
+///
+/// The compile-time and run-time information should not contradict. In other words,
+/// \a n should equal \a N unless \a N is \a Dynamic.
+///
+/// Example: \include MatrixBase_template_int_end.cpp
+/// Output: \verbinclude MatrixBase_template_int_end.out
+///
+/// \sa tail(NType), class Block
+///
+template<int N>
+EIGEN_DEVICE_FUNC
+inline typename FixedSegmentReturnType<N>::Type tail(Index n = N)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename FixedSegmentReturnType<N>::Type(derived(), size() - n);
+}
+
+/// This is the const version of tail<int>.
+template<int N>
+EIGEN_DEVICE_FUNC
+inline typename ConstFixedSegmentReturnType<N>::Type tail(Index n = N) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename ConstFixedSegmentReturnType<N>::Type(derived(), size() - n);
+}
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/plugins/CommonCwiseBinaryOps.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/plugins/CommonCwiseBinaryOps.h
new file mode 100644
index 00000000..8b6730ed
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/plugins/CommonCwiseBinaryOps.h
@@ -0,0 +1,115 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+// This file is a base class plugin containing common coefficient wise functions.
+
+/** \returns an expression of the difference of \c *this and \a other
+  *
+  * \note If you want to substract a given scalar from all coefficients, see Cwise::operator-().
+  *
+  * \sa class CwiseBinaryOp, operator-=()
+  */
+EIGEN_MAKE_CWISE_BINARY_OP(operator-,difference)
+
+/** \returns an expression of the sum of \c *this and \a other
+  *
+  * \note If you want to add a given scalar to all coefficients, see Cwise::operator+().
+  *
+  * \sa class CwiseBinaryOp, operator+=()
+  */
+EIGEN_MAKE_CWISE_BINARY_OP(operator+,sum)
+
+/** \returns an expression of a custom coefficient-wise operator \a func of *this and \a other
+  *
+  * The template parameter \a CustomBinaryOp is the type of the functor
+  * of the custom operator (see class CwiseBinaryOp for an example)
+  *
+  * Here is an example illustrating the use of custom functors:
+  * \include class_CwiseBinaryOp.cpp
+  * Output: \verbinclude class_CwiseBinaryOp.out
+  *
+  * \sa class CwiseBinaryOp, operator+(), operator-(), cwiseProduct()
+  */
+template<typename CustomBinaryOp, typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseBinaryOp<CustomBinaryOp, const Derived, const OtherDerived>
+binaryExpr(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other, const CustomBinaryOp& func = CustomBinaryOp()) const
+{
+  return CwiseBinaryOp<CustomBinaryOp, const Derived, const OtherDerived>(derived(), other.derived(), func);
+}
+
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+EIGEN_MAKE_SCALAR_BINARY_OP(operator*,product)
+#else
+/** \returns an expression of \c *this scaled by the scalar factor \a scalar
+  *
+  * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression.
+  */
+template<typename T>
+const CwiseBinaryOp<internal::scalar_product_op<Scalar,T>,Derived,Constant<T> > operator*(const T& scalar) const;
+/** \returns an expression of \a expr scaled by the scalar factor \a scalar
+  *
+  * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression.
+  */
+template<typename T> friend
+const CwiseBinaryOp<internal::scalar_product_op<T,Scalar>,Constant<T>,Derived> operator*(const T& scalar, const StorageBaseType& expr);
+#endif
+
+
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+EIGEN_MAKE_SCALAR_BINARY_OP_ONTHERIGHT(operator/,quotient)
+#else
+/** \returns an expression of \c *this divided by the scalar value \a scalar
+  *
+  * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression.
+  */
+template<typename T>
+const CwiseBinaryOp<internal::scalar_quotient_op<Scalar,T>,Derived,Constant<T> > operator/(const T& scalar) const;
+#endif
+
+/** \returns an expression of the coefficient-wise boolean \b and operator of \c *this and \a other
+  *
+  * \warning this operator is for expression of bool only.
+  *
+  * Example: \include Cwise_boolean_and.cpp
+  * Output: \verbinclude Cwise_boolean_and.out
+  *
+  * \sa operator||(), select()
+  */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+inline const CwiseBinaryOp<internal::scalar_boolean_and_op, const Derived, const OtherDerived>
+operator&&(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  EIGEN_STATIC_ASSERT((internal::is_same<bool,Scalar>::value && internal::is_same<bool,typename OtherDerived::Scalar>::value),
+                      THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_OF_BOOL);
+  return CwiseBinaryOp<internal::scalar_boolean_and_op, const Derived, const OtherDerived>(derived(),other.derived());
+}
+
+/** \returns an expression of the coefficient-wise boolean \b or operator of \c *this and \a other
+  *
+  * \warning this operator is for expression of bool only.
+  *
+  * Example: \include Cwise_boolean_or.cpp
+  * Output: \verbinclude Cwise_boolean_or.out
+  *
+  * \sa operator&&(), select()
+  */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+inline const CwiseBinaryOp<internal::scalar_boolean_or_op, const Derived, const OtherDerived>
+operator||(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  EIGEN_STATIC_ASSERT((internal::is_same<bool,Scalar>::value && internal::is_same<bool,typename OtherDerived::Scalar>::value),
+                      THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_OF_BOOL);
+  return CwiseBinaryOp<internal::scalar_boolean_or_op, const Derived, const OtherDerived>(derived(),other.derived());
+}
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/plugins/CommonCwiseUnaryOps.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/plugins/CommonCwiseUnaryOps.h
new file mode 100644
index 00000000..89f4faaa
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/plugins/CommonCwiseUnaryOps.h
@@ -0,0 +1,163 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+// This file is a base class plugin containing common coefficient wise functions.
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+
+/** \internal the return type of conjugate() */
+typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
+                    const CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, const Derived>,
+                    const Derived&
+                  >::type ConjugateReturnType;
+/** \internal the return type of real() const */
+typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
+                    const CwiseUnaryOp<internal::scalar_real_op<Scalar>, const Derived>,
+                    const Derived&
+                  >::type RealReturnType;
+/** \internal the return type of real() */
+typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
+                    CwiseUnaryView<internal::scalar_real_ref_op<Scalar>, Derived>,
+                    Derived&
+                  >::type NonConstRealReturnType;
+/** \internal the return type of imag() const */
+typedef CwiseUnaryOp<internal::scalar_imag_op<Scalar>, const Derived> ImagReturnType;
+/** \internal the return type of imag() */
+typedef CwiseUnaryView<internal::scalar_imag_ref_op<Scalar>, Derived> NonConstImagReturnType;
+
+typedef CwiseUnaryOp<internal::scalar_opposite_op<Scalar>, const Derived> NegativeReturnType;
+
+#endif // not EIGEN_PARSED_BY_DOXYGEN
+
+/// \returns an expression of the opposite of \c *this
+///
+EIGEN_DOC_UNARY_ADDONS(operator-,opposite)
+///
+EIGEN_DEVICE_FUNC
+inline const NegativeReturnType
+operator-() const { return NegativeReturnType(derived()); }
+
+
+template<class NewType> struct CastXpr { typedef typename internal::cast_return_type<Derived,const CwiseUnaryOp<internal::scalar_cast_op<Scalar, NewType>, const Derived> >::type Type; };
+
+/// \returns an expression of \c *this with the \a Scalar type casted to
+/// \a NewScalar.
+///
+/// The template parameter \a NewScalar is the type we are casting the scalars to.
+///
+EIGEN_DOC_UNARY_ADDONS(cast,conversion function)
+///
+/// \sa class CwiseUnaryOp
+///
+template<typename NewType>
+EIGEN_DEVICE_FUNC
+typename CastXpr<NewType>::Type
+cast() const
+{
+  return typename CastXpr<NewType>::Type(derived());
+}
+
+/// \returns an expression of the complex conjugate of \c *this.
+///
+EIGEN_DOC_UNARY_ADDONS(conjugate,complex conjugate)
+///
+/// \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_conj">Math functions</a>, MatrixBase::adjoint()
+EIGEN_DEVICE_FUNC
+inline ConjugateReturnType
+conjugate() const
+{
+  return ConjugateReturnType(derived());
+}
+
+/// \returns a read-only expression of the real part of \c *this.
+///
+EIGEN_DOC_UNARY_ADDONS(real,real part function)
+///
+/// \sa imag()
+EIGEN_DEVICE_FUNC
+inline RealReturnType
+real() const { return RealReturnType(derived()); }
+
+/// \returns an read-only expression of the imaginary part of \c *this.
+///
+EIGEN_DOC_UNARY_ADDONS(imag,imaginary part function)
+///
+/// \sa real()
+EIGEN_DEVICE_FUNC
+inline const ImagReturnType
+imag() const { return ImagReturnType(derived()); }
+
+/// \brief Apply a unary operator coefficient-wise
+/// \param[in]  func  Functor implementing the unary operator
+/// \tparam  CustomUnaryOp Type of \a func
+/// \returns An expression of a custom coefficient-wise unary operator \a func of *this
+///
+/// The function \c ptr_fun() from the C++ standard library can be used to make functors out of normal functions.
+///
+/// Example:
+/// \include class_CwiseUnaryOp_ptrfun.cpp
+/// Output: \verbinclude class_CwiseUnaryOp_ptrfun.out
+///
+/// Genuine functors allow for more possibilities, for instance it may contain a state.
+///
+/// Example:
+/// \include class_CwiseUnaryOp.cpp
+/// Output: \verbinclude class_CwiseUnaryOp.out
+///
+EIGEN_DOC_UNARY_ADDONS(unaryExpr,unary function)
+///
+/// \sa unaryViewExpr, binaryExpr, class CwiseUnaryOp
+///
+template<typename CustomUnaryOp>
+EIGEN_DEVICE_FUNC
+inline const CwiseUnaryOp<CustomUnaryOp, const Derived>
+unaryExpr(const CustomUnaryOp& func = CustomUnaryOp()) const
+{
+  return CwiseUnaryOp<CustomUnaryOp, const Derived>(derived(), func);
+}
+
+/// \returns an expression of a custom coefficient-wise unary operator \a func of *this
+///
+/// The template parameter \a CustomUnaryOp is the type of the functor
+/// of the custom unary operator.
+///
+/// Example:
+/// \include class_CwiseUnaryOp.cpp
+/// Output: \verbinclude class_CwiseUnaryOp.out
+///
+EIGEN_DOC_UNARY_ADDONS(unaryViewExpr,unary function)
+///
+/// \sa unaryExpr, binaryExpr class CwiseUnaryOp
+///
+template<typename CustomViewOp>
+EIGEN_DEVICE_FUNC
+inline const CwiseUnaryView<CustomViewOp, const Derived>
+unaryViewExpr(const CustomViewOp& func = CustomViewOp()) const
+{
+  return CwiseUnaryView<CustomViewOp, const Derived>(derived(), func);
+}
+
+/// \returns a non const expression of the real part of \c *this.
+///
+EIGEN_DOC_UNARY_ADDONS(real,real part function)
+///
+/// \sa imag()
+EIGEN_DEVICE_FUNC
+inline NonConstRealReturnType
+real() { return NonConstRealReturnType(derived()); }
+
+/// \returns a non const expression of the imaginary part of \c *this.
+///
+EIGEN_DOC_UNARY_ADDONS(imag,imaginary part function)
+///
+/// \sa real()
+EIGEN_DEVICE_FUNC
+inline NonConstImagReturnType
+imag() { return NonConstImagReturnType(derived()); }
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/plugins/IndexedViewMethods.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/plugins/IndexedViewMethods.h
new file mode 100644
index 00000000..a7ec63ad
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/plugins/IndexedViewMethods.h
@@ -0,0 +1,267 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2017 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#if !defined(EIGEN_PARSED_BY_DOXYGEN)
+
+// This file is automatically included twice to generate const and non-const versions
+
+#ifndef EIGEN_INDEXED_VIEW_METHOD_2ND_PASS
+#define EIGEN_INDEXED_VIEW_METHOD_CONST const
+#define EIGEN_INDEXED_VIEW_METHOD_TYPE  ConstIndexedViewType
+#else
+#define EIGEN_INDEXED_VIEW_METHOD_CONST
+#define EIGEN_INDEXED_VIEW_METHOD_TYPE IndexedViewType
+#endif
+
+#ifndef EIGEN_INDEXED_VIEW_METHOD_2ND_PASS
+protected:
+
+// define some aliases to ease readability
+
+template<typename Indices>
+struct IvcRowType : public internal::IndexedViewCompatibleType<Indices,RowsAtCompileTime> {};
+
+template<typename Indices>
+struct IvcColType : public internal::IndexedViewCompatibleType<Indices,ColsAtCompileTime> {};
+
+template<typename Indices>
+struct IvcType : public internal::IndexedViewCompatibleType<Indices,SizeAtCompileTime> {};
+
+typedef typename internal::IndexedViewCompatibleType<Index,1>::type IvcIndex;
+
+template<typename Indices>
+typename IvcRowType<Indices>::type
+ivcRow(const Indices& indices) const {
+  return internal::makeIndexedViewCompatible(indices, internal::variable_if_dynamic<Index,RowsAtCompileTime>(derived().rows()),Specialized);
+}
+
+template<typename Indices>
+typename IvcColType<Indices>::type
+ivcCol(const Indices& indices) const {
+  return internal::makeIndexedViewCompatible(indices, internal::variable_if_dynamic<Index,ColsAtCompileTime>(derived().cols()),Specialized);
+}
+
+template<typename Indices>
+typename IvcColType<Indices>::type
+ivcSize(const Indices& indices) const {
+  return internal::makeIndexedViewCompatible(indices, internal::variable_if_dynamic<Index,SizeAtCompileTime>(derived().size()),Specialized);
+}
+
+template<typename RowIndices, typename ColIndices>
+struct valid_indexed_view_overload {
+  enum { value = !(internal::is_valid_index_type<RowIndices>::value && internal::is_valid_index_type<ColIndices>::value) };
+};
+
+public:
+
+#endif
+
+template<typename RowIndices, typename ColIndices>
+struct EIGEN_INDEXED_VIEW_METHOD_TYPE {
+  typedef IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,
+                      typename IvcRowType<RowIndices>::type,
+                      typename IvcColType<ColIndices>::type> type;
+};
+
+// This is the generic version
+
+template<typename RowIndices, typename ColIndices>
+typename internal::enable_if<valid_indexed_view_overload<RowIndices,ColIndices>::value
+  && internal::traits<typename EIGEN_INDEXED_VIEW_METHOD_TYPE<RowIndices,ColIndices>::type>::ReturnAsIndexedView,
+  typename EIGEN_INDEXED_VIEW_METHOD_TYPE<RowIndices,ColIndices>::type >::type
+operator()(const RowIndices& rowIndices, const ColIndices& colIndices) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  return typename EIGEN_INDEXED_VIEW_METHOD_TYPE<RowIndices,ColIndices>::type
+            (derived(), ivcRow(rowIndices), ivcCol(colIndices));
+}
+
+// The following overload returns a Block<> object
+
+template<typename RowIndices, typename ColIndices>
+typename internal::enable_if<valid_indexed_view_overload<RowIndices,ColIndices>::value
+  && internal::traits<typename EIGEN_INDEXED_VIEW_METHOD_TYPE<RowIndices,ColIndices>::type>::ReturnAsBlock,
+  typename internal::traits<typename EIGEN_INDEXED_VIEW_METHOD_TYPE<RowIndices,ColIndices>::type>::BlockType>::type
+operator()(const RowIndices& rowIndices, const ColIndices& colIndices) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  typedef typename internal::traits<typename EIGEN_INDEXED_VIEW_METHOD_TYPE<RowIndices,ColIndices>::type>::BlockType BlockType;
+  typename IvcRowType<RowIndices>::type actualRowIndices = ivcRow(rowIndices);
+  typename IvcColType<ColIndices>::type actualColIndices = ivcCol(colIndices);
+  return BlockType(derived(),
+                   internal::first(actualRowIndices),
+                   internal::first(actualColIndices),
+                   internal::size(actualRowIndices),
+                   internal::size(actualColIndices));
+}
+
+// The following overload returns a Scalar
+
+template<typename RowIndices, typename ColIndices>
+typename internal::enable_if<valid_indexed_view_overload<RowIndices,ColIndices>::value
+  && internal::traits<typename EIGEN_INDEXED_VIEW_METHOD_TYPE<RowIndices,ColIndices>::type>::ReturnAsScalar,
+  CoeffReturnType >::type
+operator()(const RowIndices& rowIndices, const ColIndices& colIndices) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  return Base::operator()(internal::eval_expr_given_size(rowIndices,rows()),internal::eval_expr_given_size(colIndices,cols()));
+}
+
+#if EIGEN_HAS_STATIC_ARRAY_TEMPLATE
+
+// The folowing three overloads are needed to handle raw Index[N] arrays.
+
+template<typename RowIndicesT, std::size_t RowIndicesN, typename ColIndices>
+IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,const RowIndicesT (&)[RowIndicesN],typename IvcColType<ColIndices>::type>
+operator()(const RowIndicesT (&rowIndices)[RowIndicesN], const ColIndices& colIndices) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  return IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,const RowIndicesT (&)[RowIndicesN],typename IvcColType<ColIndices>::type>
+                    (derived(), rowIndices, ivcCol(colIndices));
+}
+
+template<typename RowIndices, typename ColIndicesT, std::size_t ColIndicesN>
+IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,typename IvcRowType<RowIndices>::type, const ColIndicesT (&)[ColIndicesN]>
+operator()(const RowIndices& rowIndices, const ColIndicesT (&colIndices)[ColIndicesN]) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  return IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,typename IvcRowType<RowIndices>::type,const ColIndicesT (&)[ColIndicesN]>
+                    (derived(), ivcRow(rowIndices), colIndices);
+}
+
+template<typename RowIndicesT, std::size_t RowIndicesN, typename ColIndicesT, std::size_t ColIndicesN>
+IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,const RowIndicesT (&)[RowIndicesN], const ColIndicesT (&)[ColIndicesN]>
+operator()(const RowIndicesT (&rowIndices)[RowIndicesN], const ColIndicesT (&colIndices)[ColIndicesN]) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  return IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,const RowIndicesT (&)[RowIndicesN],const ColIndicesT (&)[ColIndicesN]>
+                    (derived(), rowIndices, colIndices);
+}
+
+#endif // EIGEN_HAS_STATIC_ARRAY_TEMPLATE
+
+// Overloads for 1D vectors/arrays
+
+template<typename Indices>
+typename internal::enable_if<
+  IsRowMajor && (!(internal::get_compile_time_incr<typename IvcType<Indices>::type>::value==1 || internal::is_valid_index_type<Indices>::value)),
+  IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,IvcIndex,typename IvcType<Indices>::type> >::type
+operator()(const Indices& indices) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,IvcIndex,typename IvcType<Indices>::type>
+            (derived(), IvcIndex(0), ivcCol(indices));
+}
+
+template<typename Indices>
+typename internal::enable_if<
+  (!IsRowMajor) && (!(internal::get_compile_time_incr<typename IvcType<Indices>::type>::value==1 || internal::is_valid_index_type<Indices>::value)),
+  IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,typename IvcType<Indices>::type,IvcIndex> >::type
+operator()(const Indices& indices) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,typename IvcType<Indices>::type,IvcIndex>
+            (derived(), ivcRow(indices), IvcIndex(0));
+}
+
+template<typename Indices>
+typename internal::enable_if<
+  (internal::get_compile_time_incr<typename IvcType<Indices>::type>::value==1) && (!internal::is_valid_index_type<Indices>::value) && (!Symbolic::is_symbolic<Indices>::value),
+  VectorBlock<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,internal::array_size<Indices>::value> >::type
+operator()(const Indices& indices) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  typename IvcType<Indices>::type actualIndices = ivcSize(indices);
+  return VectorBlock<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,internal::array_size<Indices>::value>
+            (derived(), internal::first(actualIndices), internal::size(actualIndices));
+}
+
+template<typename IndexType>
+typename internal::enable_if<Symbolic::is_symbolic<IndexType>::value, CoeffReturnType >::type
+operator()(const IndexType& id) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  return Base::operator()(internal::eval_expr_given_size(id,size()));
+}
+
+#if EIGEN_HAS_STATIC_ARRAY_TEMPLATE
+
+template<typename IndicesT, std::size_t IndicesN>
+typename internal::enable_if<IsRowMajor,
+  IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,IvcIndex,const IndicesT (&)[IndicesN]> >::type
+operator()(const IndicesT (&indices)[IndicesN]) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,IvcIndex,const IndicesT (&)[IndicesN]>
+            (derived(), IvcIndex(0), indices);
+}
+
+template<typename IndicesT, std::size_t IndicesN>
+typename internal::enable_if<!IsRowMajor,
+  IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,const IndicesT (&)[IndicesN],IvcIndex> >::type
+operator()(const IndicesT (&indices)[IndicesN]) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,const IndicesT (&)[IndicesN],IvcIndex>
+            (derived(), indices, IvcIndex(0));
+}
+
+#endif // EIGEN_HAS_STATIC_ARRAY_TEMPLATE
+
+#undef EIGEN_INDEXED_VIEW_METHOD_CONST
+#undef EIGEN_INDEXED_VIEW_METHOD_TYPE
+
+#ifndef EIGEN_INDEXED_VIEW_METHOD_2ND_PASS
+#define EIGEN_INDEXED_VIEW_METHOD_2ND_PASS
+#include "IndexedViewMethods.h"
+#undef EIGEN_INDEXED_VIEW_METHOD_2ND_PASS
+#endif
+
+#else // EIGEN_PARSED_BY_DOXYGEN
+
+/**
+  * \returns a generic submatrix view defined by the rows and columns indexed \a rowIndices and \a colIndices respectively.
+  *
+  * Each parameter must either be:
+  *  - An integer indexing a single row or column
+  *  - Eigen::all indexing the full set of respective rows or columns in increasing order
+  *  - An ArithmeticSequence as returned by the Eigen::seq and Eigen::seqN functions
+  *  - Any %Eigen's vector/array of integers or expressions
+  *  - Plain C arrays: \c int[N]
+  *  - And more generally any type exposing the following two member functions:
+  * \code
+  * <integral type> operator[](<integral type>) const;
+  * <integral type> size() const;
+  * \endcode
+  * where \c <integral \c type>  stands for any integer type compatible with Eigen::Index (i.e. \c std::ptrdiff_t).
+  *
+  * The last statement implies compatibility with \c std::vector, \c std::valarray, \c std::array, many of the Range-v3's ranges, etc.
+  *
+  * If the submatrix can be represented using a starting position \c (i,j) and positive sizes \c (rows,columns), then this
+  * method will returns a Block object after extraction of the relevant information from the passed arguments. This is the case
+  * when all arguments are either:
+  *  - An integer
+  *  - Eigen::all
+  *  - An ArithmeticSequence with compile-time increment strictly equal to 1, as returned by Eigen::seq(a,b), and Eigen::seqN(a,N).
+  *
+  * Otherwise a more general IndexedView<Derived,RowIndices',ColIndices'> object will be returned, after conversion of the inputs
+  * to more suitable types \c RowIndices' and \c ColIndices'.
+  *
+  * For 1D vectors and arrays, you better use the operator()(const Indices&) overload, which behave the same way but taking a single parameter.
+  *
+  * See also this <a href="https://stackoverflow.com/questions/46110917/eigen-replicate-items-along-one-dimension-without-useless-allocations">question</a> and its answer for an example of how to duplicate coefficients.
+  *
+  * \sa operator()(const Indices&), class Block, class IndexedView, DenseBase::block(Index,Index,Index,Index)
+  */
+template<typename RowIndices, typename ColIndices>
+IndexedView_or_Block
+operator()(const RowIndices& rowIndices, const ColIndices& colIndices);
+
+/** This is an overload of operator()(const RowIndices&, const ColIndices&) for 1D vectors or arrays
+  *
+  * \only_for_vectors
+  */
+template<typename Indices>
+IndexedView_or_VectorBlock
+operator()(const Indices& indices);
+
+#endif  // EIGEN_PARSED_BY_DOXYGEN
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/plugins/MatrixCwiseBinaryOps.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/plugins/MatrixCwiseBinaryOps.h
new file mode 100644
index 00000000..f1084abe
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/plugins/MatrixCwiseBinaryOps.h
@@ -0,0 +1,152 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+// This file is a base class plugin containing matrix specifics coefficient wise functions.
+
+/** \returns an expression of the Schur product (coefficient wise product) of *this and \a other
+  *
+  * Example: \include MatrixBase_cwiseProduct.cpp
+  * Output: \verbinclude MatrixBase_cwiseProduct.out
+  *
+  * \sa class CwiseBinaryOp, cwiseAbs2
+  */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const EIGEN_CWISE_BINARY_RETURN_TYPE(Derived,OtherDerived,product)
+cwiseProduct(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  return EIGEN_CWISE_BINARY_RETURN_TYPE(Derived,OtherDerived,product)(derived(), other.derived());
+}
+
+/** \returns an expression of the coefficient-wise == operator of *this and \a other
+  *
+  * \warning this performs an exact comparison, which is generally a bad idea with floating-point types.
+  * In order to check for equality between two vectors or matrices with floating-point coefficients, it is
+  * generally a far better idea to use a fuzzy comparison as provided by isApprox() and
+  * isMuchSmallerThan().
+  *
+  * Example: \include MatrixBase_cwiseEqual.cpp
+  * Output: \verbinclude MatrixBase_cwiseEqual.out
+  *
+  * \sa cwiseNotEqual(), isApprox(), isMuchSmallerThan()
+  */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+inline const CwiseBinaryOp<std::equal_to<Scalar>, const Derived, const OtherDerived>
+cwiseEqual(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  return CwiseBinaryOp<std::equal_to<Scalar>, const Derived, const OtherDerived>(derived(), other.derived());
+}
+
+/** \returns an expression of the coefficient-wise != operator of *this and \a other
+  *
+  * \warning this performs an exact comparison, which is generally a bad idea with floating-point types.
+  * In order to check for equality between two vectors or matrices with floating-point coefficients, it is
+  * generally a far better idea to use a fuzzy comparison as provided by isApprox() and
+  * isMuchSmallerThan().
+  *
+  * Example: \include MatrixBase_cwiseNotEqual.cpp
+  * Output: \verbinclude MatrixBase_cwiseNotEqual.out
+  *
+  * \sa cwiseEqual(), isApprox(), isMuchSmallerThan()
+  */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+inline const CwiseBinaryOp<std::not_equal_to<Scalar>, const Derived, const OtherDerived>
+cwiseNotEqual(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  return CwiseBinaryOp<std::not_equal_to<Scalar>, const Derived, const OtherDerived>(derived(), other.derived());
+}
+
+/** \returns an expression of the coefficient-wise min of *this and \a other
+  *
+  * Example: \include MatrixBase_cwiseMin.cpp
+  * Output: \verbinclude MatrixBase_cwiseMin.out
+  *
+  * \sa class CwiseBinaryOp, max()
+  */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_min_op<Scalar,Scalar>, const Derived, const OtherDerived>
+cwiseMin(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  return CwiseBinaryOp<internal::scalar_min_op<Scalar,Scalar>, const Derived, const OtherDerived>(derived(), other.derived());
+}
+
+/** \returns an expression of the coefficient-wise min of *this and scalar \a other
+  *
+  * \sa class CwiseBinaryOp, min()
+  */
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_min_op<Scalar,Scalar>, const Derived, const ConstantReturnType>
+cwiseMin(const Scalar &other) const
+{
+  return cwiseMin(Derived::Constant(rows(), cols(), other));
+}
+
+/** \returns an expression of the coefficient-wise max of *this and \a other
+  *
+  * Example: \include MatrixBase_cwiseMax.cpp
+  * Output: \verbinclude MatrixBase_cwiseMax.out
+  *
+  * \sa class CwiseBinaryOp, min()
+  */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_max_op<Scalar,Scalar>, const Derived, const OtherDerived>
+cwiseMax(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  return CwiseBinaryOp<internal::scalar_max_op<Scalar,Scalar>, const Derived, const OtherDerived>(derived(), other.derived());
+}
+
+/** \returns an expression of the coefficient-wise max of *this and scalar \a other
+  *
+  * \sa class CwiseBinaryOp, min()
+  */
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_max_op<Scalar,Scalar>, const Derived, const ConstantReturnType>
+cwiseMax(const Scalar &other) const
+{
+  return cwiseMax(Derived::Constant(rows(), cols(), other));
+}
+
+
+/** \returns an expression of the coefficient-wise quotient of *this and \a other
+  *
+  * Example: \include MatrixBase_cwiseQuotient.cpp
+  * Output: \verbinclude MatrixBase_cwiseQuotient.out
+  *
+  * \sa class CwiseBinaryOp, cwiseProduct(), cwiseInverse()
+  */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_quotient_op<Scalar>, const Derived, const OtherDerived>
+cwiseQuotient(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  return CwiseBinaryOp<internal::scalar_quotient_op<Scalar>, const Derived, const OtherDerived>(derived(), other.derived());
+}
+
+typedef CwiseBinaryOp<internal::scalar_cmp_op<Scalar,Scalar,internal::cmp_EQ>, const Derived, const ConstantReturnType> CwiseScalarEqualReturnType;
+
+/** \returns an expression of the coefficient-wise == operator of \c *this and a scalar \a s
+  *
+  * \warning this performs an exact comparison, which is generally a bad idea with floating-point types.
+  * In order to check for equality between two vectors or matrices with floating-point coefficients, it is
+  * generally a far better idea to use a fuzzy comparison as provided by isApprox() and
+  * isMuchSmallerThan().
+  *
+  * \sa cwiseEqual(const MatrixBase<OtherDerived> &) const
+  */
+EIGEN_DEVICE_FUNC
+inline const CwiseScalarEqualReturnType
+cwiseEqual(const Scalar& s) const
+{
+  return CwiseScalarEqualReturnType(derived(), Derived::Constant(rows(), cols(), s), internal::scalar_cmp_op<Scalar,Scalar,internal::cmp_EQ>());
+}
diff --git a/engine/inc/bullet/ThirdPartyLibs/Eigen/src/plugins/MatrixCwiseUnaryOps.h b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/plugins/MatrixCwiseUnaryOps.h
new file mode 100644
index 00000000..b1be3d56
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Eigen/src/plugins/MatrixCwiseUnaryOps.h
@@ -0,0 +1,85 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+// This file is included into the body of the base classes supporting matrix specific coefficient-wise functions.
+// This include MatrixBase and SparseMatrixBase.
+
+
+typedef CwiseUnaryOp<internal::scalar_abs_op<Scalar>, const Derived> CwiseAbsReturnType;
+typedef CwiseUnaryOp<internal::scalar_abs2_op<Scalar>, const Derived> CwiseAbs2ReturnType;
+typedef CwiseUnaryOp<internal::scalar_sqrt_op<Scalar>, const Derived> CwiseSqrtReturnType;
+typedef CwiseUnaryOp<internal::scalar_sign_op<Scalar>, const Derived> CwiseSignReturnType;
+typedef CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, const Derived> CwiseInverseReturnType;
+
+/// \returns an expression of the coefficient-wise absolute value of \c *this
+///
+/// Example: \include MatrixBase_cwiseAbs.cpp
+/// Output: \verbinclude MatrixBase_cwiseAbs.out
+///
+EIGEN_DOC_UNARY_ADDONS(cwiseAbs,absolute value)
+///
+/// \sa cwiseAbs2()
+///
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseAbsReturnType
+cwiseAbs() const { return CwiseAbsReturnType(derived()); }
+
+/// \returns an expression of the coefficient-wise squared absolute value of \c *this
+///
+/// Example: \include MatrixBase_cwiseAbs2.cpp
+/// Output: \verbinclude MatrixBase_cwiseAbs2.out
+///
+EIGEN_DOC_UNARY_ADDONS(cwiseAbs2,squared absolute value)
+///
+/// \sa cwiseAbs()
+///
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseAbs2ReturnType
+cwiseAbs2() const { return CwiseAbs2ReturnType(derived()); }
+
+/// \returns an expression of the coefficient-wise square root of *this.
+///
+/// Example: \include MatrixBase_cwiseSqrt.cpp
+/// Output: \verbinclude MatrixBase_cwiseSqrt.out
+///
+EIGEN_DOC_UNARY_ADDONS(cwiseSqrt,square-root)
+///
+/// \sa cwisePow(), cwiseSquare()
+///
+EIGEN_DEVICE_FUNC
+inline const CwiseSqrtReturnType
+cwiseSqrt() const { return CwiseSqrtReturnType(derived()); }
+
+/// \returns an expression of the coefficient-wise signum of *this.
+///
+/// Example: \include MatrixBase_cwiseSign.cpp
+/// Output: \verbinclude MatrixBase_cwiseSign.out
+///
+EIGEN_DOC_UNARY_ADDONS(cwiseSign,sign function)
+///
+EIGEN_DEVICE_FUNC
+inline const CwiseSignReturnType
+cwiseSign() const { return CwiseSignReturnType(derived()); }
+
+
+/// \returns an expression of the coefficient-wise inverse of *this.
+///
+/// Example: \include MatrixBase_cwiseInverse.cpp
+/// Output: \verbinclude MatrixBase_cwiseInverse.out
+///
+EIGEN_DOC_UNARY_ADDONS(cwiseInverse,inverse)
+///
+/// \sa cwiseProduct()
+///
+EIGEN_DEVICE_FUNC
+inline const CwiseInverseReturnType
+cwiseInverse() const { return CwiseInverseReturnType(derived()); }
+
+
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Align.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Align.h
new file mode 100644
index 00000000..c74ec77a
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Align.h
@@ -0,0 +1,77 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_ALIGN_H
+#define GWEN_ALIGN_H
+#include "Gwen/Controls/Base.h"
+
+namespace Gwen
+{
+namespace Align
+{
+inline void Center(Controls::Base* ctrl)
+{
+	Controls::Base* parent = ctrl->GetParent();
+	if (!parent) return;
+
+	ctrl->SetPos(parent->GetPadding().left + (((parent->Width() - parent->GetPadding().left - parent->GetPadding().right) - ctrl->Width()) / 2),
+				 (parent->Height() - ctrl->Height()) / 2);
+}
+
+inline void AlignLeft(Controls::Base* ctrl)
+{
+	Controls::Base* parent = ctrl->GetParent();
+	if (!parent) return;
+
+	ctrl->SetPos(parent->GetPadding().left, ctrl->Y());
+}
+
+inline void CenterHorizontally(Controls::Base* ctrl)
+{
+	Controls::Base* parent = ctrl->GetParent();
+	if (!parent) return;
+
+	ctrl->SetPos(parent->GetPadding().left + (((parent->Width() - parent->GetPadding().left - parent->GetPadding().right) - ctrl->Width()) / 2), ctrl->Y());
+}
+
+inline void AlignRight(Controls::Base* ctrl)
+{
+	Controls::Base* parent = ctrl->GetParent();
+	if (!parent) return;
+
+	ctrl->SetPos(parent->Width() - ctrl->Width() - parent->GetPadding().right, ctrl->Y());
+}
+
+inline void AlignTop(Controls::Base* ctrl)
+{
+	ctrl->SetPos(ctrl->X(), 0);
+}
+
+inline void CenterVertically(Controls::Base* ctrl)
+{
+	Controls::Base* parent = ctrl->GetParent();
+	if (!parent) return;
+
+	ctrl->SetPos(ctrl->X(), (parent->Height() - ctrl->Height()) / 2);
+}
+
+inline void AlignBottom(Controls::Base* ctrl)
+{
+	Controls::Base* parent = ctrl->GetParent();
+	if (!parent) return;
+
+	ctrl->SetPos(ctrl->X(), parent->Height() - ctrl->Height());
+}
+
+inline void PlaceBelow(Controls::Base* ctrl, Controls::Base* below, int iBorder = 0)
+{
+	ctrl->SetPos(ctrl->X(), below->Bottom() + iBorder);
+}
+
+}  // namespace Align
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Anim.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Anim.h
new file mode 100644
index 00000000..0bf0ba88
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Anim.h
@@ -0,0 +1,129 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_ANIM_H
+#define GWEN_ANIM_H
+#include "Gwen/Gwen.h"
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Platform.h"
+
+#ifndef GWEN_NO_ANIMATION
+
+namespace Gwen
+{
+namespace Anim
+{
+class GWEN_EXPORT Animation
+{
+public:
+	typedef std::list<Animation*> ChildList;
+	typedef std::map<Gwen::Controls::Base*, ChildList> List;
+
+	virtual void Think() = 0;
+	virtual bool Finished() = 0;
+
+	virtual ~Animation() {}
+
+	Gwen::Controls::Base* m_Control;
+};
+
+GWEN_EXPORT void Add(Gwen::Controls::Base* control, Animation* animation);
+GWEN_EXPORT void Cancel(Gwen::Controls::Base* control);
+GWEN_EXPORT void Think();
+
+//
+// Timed animation. Provides a useful base for animations.
+//
+class GWEN_EXPORT TimedAnimation : public Animation
+{
+public:
+	TimedAnimation(float fLength, float fDelay = 0.0f, float fEase = 1.0f);
+
+	virtual void Think();
+	virtual bool Finished();
+
+	//
+	// These are the magic functions you should be overriding
+	//
+	virtual void OnStart() {}
+	virtual void Run(float /*delta*/) {}
+	virtual void OnFinish() {}
+
+protected:
+	bool m_bStarted;
+	bool m_bFinished;
+	float m_fStart;
+	float m_fEnd;
+	float m_fEase;
+};
+
+namespace Size
+{
+class GWEN_EXPORT Height : public TimedAnimation
+{
+public:
+	Height(int iStartSize, int iEndSize, float fLength, bool bHide = false, float fDelay = 0.0f, float fEase = 1.0f) : TimedAnimation(fLength, fDelay, fEase)
+	{
+		m_iStartSize = iStartSize;
+		m_iDelta = iEndSize - m_iStartSize;
+		m_bHide = bHide;
+	}
+
+	virtual void OnStart() { m_Control->SetHeight(m_iStartSize); }
+	virtual void Run(float delta) { m_Control->SetHeight(m_iStartSize + (((float)m_iDelta) * delta)); }
+	virtual void OnFinish()
+	{
+		m_Control->SetHeight(m_iStartSize + m_iDelta);
+		m_Control->SetHidden(m_bHide);
+	}
+
+protected:
+	int m_iStartSize;
+	int m_iDelta;
+	bool m_bHide;
+};
+
+class Width : public TimedAnimation
+{
+public:
+	Width(int iStartSize, int iEndSize, float fLength, bool bHide = false, float fDelay = 0.0f, float fEase = 1.0f) : TimedAnimation(fLength, fDelay, fEase)
+	{
+		m_iStartSize = iStartSize;
+		m_iDelta = iEndSize - m_iStartSize;
+		m_bHide = bHide;
+	}
+
+	virtual void OnStart() { m_Control->SetWidth(m_iStartSize); }
+	virtual void Run(float delta) { m_Control->SetWidth(m_iStartSize + (((float)m_iDelta) * delta)); }
+	virtual void OnFinish()
+	{
+		m_Control->SetWidth(m_iStartSize + m_iDelta);
+		m_Control->SetHidden(m_bHide);
+	}
+
+protected:
+	int m_iStartSize;
+	int m_iDelta;
+	bool m_bHide;
+};
+}  // namespace Size
+
+namespace Tools
+{
+class Remove : public TimedAnimation
+{
+public:
+	Remove(float fDelay = 0.0f) : TimedAnimation(0.0f, fDelay) {}
+	virtual void OnFinish() { m_Control->DelayedDelete(); }
+};
+}  // namespace Tools
+
+}  // namespace Anim
+}  // namespace Gwen
+
+#endif
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/BaseRender.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/BaseRender.h
new file mode 100644
index 00000000..f96ed700
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/BaseRender.h
@@ -0,0 +1,117 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_BASERENDER_H
+#define GWEN_BASERENDER_H
+
+#include "Gwen/Structures.h"
+
+namespace Gwen
+{
+struct Font;
+struct Texture;
+
+namespace Renderer
+{
+class Base;
+
+class ICacheToTexture
+{
+public:
+	virtual void Initialize() = 0;
+	virtual void ShutDown() = 0;
+	virtual void SetupCacheTexture(Gwen::Controls::Base* control) = 0;
+	virtual void FinishCacheTexture(Gwen::Controls::Base* control) = 0;
+	virtual void DrawCachedControlTexture(Gwen::Controls::Base* control) = 0;
+	virtual void CreateControlCacheTexture(Gwen::Controls::Base* control) = 0;
+	virtual void UpdateControlCacheTexture(Gwen::Controls::Base* control) = 0;
+	virtual void SetRenderer(Gwen::Renderer::Base* renderer) = 0;
+};
+
+class GWEN_EXPORT Base
+{
+public:
+	Base();
+	virtual ~Base();
+
+	virtual void Begin(){};
+	virtual void End(){};
+
+	virtual void SetDrawColor(Color color){};
+
+	virtual void DrawLine(int x, int y, int a, int b){};
+	virtual void DrawFilledRect(Gwen::Rect rect){};
+	;
+
+	virtual void StartClip(){};
+	virtual void EndClip(){};
+
+	virtual void LoadTexture(Gwen::Texture* pTexture){};
+	virtual void FreeTexture(Gwen::Texture* pTexture){};
+	virtual void DrawTexturedRect(Gwen::Texture* pTexture, Gwen::Rect pTargetRect, float u1 = 0.0f, float v1 = 0.0f, float u2 = 1.0f, float v2 = 1.0f){};
+	virtual void DrawMissingImage(Gwen::Rect pTargetRect);
+
+	virtual ICacheToTexture* GetCTT() { return NULL; }
+
+	virtual void LoadFont(Gwen::Font* pFont){};
+	virtual void FreeFont(Gwen::Font* pFont){};
+	virtual void RenderText(Gwen::Font* pFont, Gwen::Point pos, const Gwen::UnicodeString& text);
+	virtual Gwen::Point MeasureText(Gwen::Font* pFont, const Gwen::UnicodeString& text);
+
+	//
+	// No need to implement these functions in your derived class, but if
+	// you can do them faster than the default implementation it's a good idea to.
+	//
+	virtual void DrawLinedRect(Gwen::Rect rect);
+	virtual void DrawPixel(int x, int y);
+	virtual void DrawShavedCornerRect(Gwen::Rect rect, bool bSlight = false);
+	virtual Gwen::Point MeasureText(Gwen::Font* pFont, const Gwen::String& text);
+	virtual void RenderText(Gwen::Font* pFont, Gwen::Point pos, const Gwen::String& text);
+
+	virtual void Resize(int width, int height) = 0;
+
+public:
+	//
+	// Translate a panel's local drawing coordinate
+	//  into view space, taking Offset's into account.
+	//
+	void Translate(int& x, int& y);
+	void Translate(Gwen::Rect& rect);
+
+	//
+	// Set the rendering offset. You shouldn't have to
+	// touch these, ever.
+	//
+	void SetRenderOffset(const Gwen::Point& offset) { m_RenderOffset = offset; }
+	void AddRenderOffset(const Gwen::Rect& offset)
+	{
+		m_RenderOffset.x += offset.x;
+		m_RenderOffset.y += offset.y;
+	}
+	const Gwen::Point& GetRenderOffset() const { return m_RenderOffset; }
+
+private:
+	Gwen::Point m_RenderOffset;
+
+public:
+	void SetClipRegion(Gwen::Rect rect);
+	void AddClipRegion(Gwen::Rect rect);
+	bool ClipRegionVisible();
+	const Gwen::Rect& ClipRegion() const;
+
+private:
+	Gwen::Rect m_rectClipRegion;
+
+public:
+	void SetScale(float fScale) { m_fScale = fScale; }
+	float Scale() const { return m_fScale; }
+
+	float m_fScale;
+};
+}  // namespace Renderer
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Config.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Config.h
new file mode 100644
index 00000000..2144a977
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Config.h
@@ -0,0 +1,16 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONFIG_H
+#define GWEN_CONFIG_H
+
+//
+// Disables animation functions.
+//
+//#define GWEN_NO_ANIMATION
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls.h
new file mode 100644
index 00000000..8c0d8dbb
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls.h
@@ -0,0 +1,10 @@
+#pragma once
+#ifndef GWEN_CONTROLS_H
+#define GWEN_CONTROLS_H
+
+#include "Gwen/Controls/Button.h"
+#include "Gwen/Controls/TextBox.h"
+
+#include "Gwen/Anim.h"
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Base.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Base.h
new file mode 100644
index 00000000..3cdfaef4
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Base.h
@@ -0,0 +1,510 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_BASE_H
+#define GWEN_CONTROLS_BASE_H
+
+#include "Gwen/Exports.h"
+#include "Gwen/Structures.h"
+#include "Gwen/BaseRender.h"
+#include "Gwen/Events.h"
+#include <list>
+#include <map>
+
+#define GWEN_DECLARE_CAST(T)                        \
+	virtual class T* DynamicCast##T() { return 0; } \
+	virtual const class T* DynamicCast##T() const { return 0; }
+
+#define GWEN_IMPLEMENT_CAST(T)                             \
+	virtual class T* DynamicCast##T() { return (T*)this; } \
+	virtual const class T* DynamicCast##T() const { return (T*)this; }
+
+namespace Gwen
+{
+namespace ControlsInternal
+{
+class ColorDisplay;
+class Resizer;
+
+};  // namespace ControlsInternal
+
+namespace Pos
+{
+enum
+{
+	None = 0,
+	Left = (1 << 1),
+	Right = (1 << 2),
+	Top = (1 << 3),
+	Bottom = (1 << 4),
+	CenterV = (1 << 5),
+	CenterH = (1 << 6),
+	Fill = (1 << 7),
+	Center = CenterV | CenterH,
+};
+}
+
+namespace Skin
+{
+class Base;
+}
+
+namespace Controls
+{
+class Canvas;
+
+namespace Layout
+{
+class TableRow;
+};
+
+class GWEN_EXPORT Base : public Event::Handler
+{
+public:
+	GWEN_DECLARE_CAST(TabButton)
+	GWEN_DECLARE_CAST(DockedTabControl)
+	virtual class Layout::TableRow* DynamicCastLayoutTableRow() { return 0; }
+	virtual const class Layout::TableRow* DynamicCastLayoutTableRow() const { return 0; }
+
+	GWEN_DECLARE_CAST(TextBoxNumeric)
+	GWEN_DECLARE_CAST(HorizontalSlider)
+	GWEN_DECLARE_CAST(DockBase)
+	GWEN_DECLARE_CAST(MenuItem)
+	GWEN_DECLARE_CAST(PropertyRow)
+	GWEN_DECLARE_CAST(WindowControl)
+
+	GWEN_DECLARE_CAST(TreeControl)
+	GWEN_DECLARE_CAST(TreeNode)
+	GWEN_DECLARE_CAST(HSVColorPicker)
+	GWEN_DECLARE_CAST(TabControl)
+
+	GWEN_DECLARE_CAST(TabControlInner)
+	GWEN_DECLARE_CAST(GroupBox)
+	GWEN_DECLARE_CAST(Properties)
+	GWEN_DECLARE_CAST(RadioButton)
+	GWEN_DECLARE_CAST(LabeledRadioButton)
+
+	virtual class ::Gwen::ControlsInternal::Resizer* DynamicCastResizer() { return 0; }
+	virtual const class ::Gwen::ControlsInternal::Resizer* DynamicCastResizer() const { return 0; }
+
+	virtual class ::Gwen::ControlsInternal::ColorDisplay* DynamicCastColorDisplay() { return 0; }
+	virtual const class ::Gwen::ControlsInternal::ColorDisplay* DynamicCastColorDisplay() const { return 0; }
+
+	typedef std::list<Base*> List;
+
+	typedef std::map<Gwen::UnicodeString, Gwen::Event::Caller*> AccelMap;
+
+	Base(Base* pParent);
+	virtual ~Base();
+
+	virtual void DelayedDelete();
+
+	virtual void SetParent(Controls::Base* pParent);
+	virtual Controls::Base* GetParent() const { return m_Parent; }
+	virtual Controls::Canvas* GetCanvas();
+
+	virtual Base::List& GetChildren()
+	{
+		if (m_InnerPanel) return m_InnerPanel->GetChildren();
+		return Children;
+	}
+	virtual bool IsChild(Controls::Base* pChild);
+	virtual int NumChildren();
+	virtual bool SizeToChildren(bool w = true, bool h = true);
+	virtual Gwen::Point ChildrenSize();
+	virtual Controls::Base* FindChildByName(const Gwen::String& name, bool bRecursive = false);
+
+	virtual void SetName(Gwen::String name) { m_Name = name; }
+	virtual const Gwen::String& GetName() { return m_Name; }
+
+	virtual void Think() {}
+	virtual void ExpandAll() {}
+	virtual void SizeToContents() {}
+	virtual bool IsActive() { return false; }
+
+	virtual void AddChild(Controls::Base* pChild);
+
+	virtual void RemoveChild(Controls::Base* pParent);
+
+protected:
+	virtual void OnChildAdded(Controls::Base* pChild);
+	virtual void OnChildRemoved(Controls::Base* pChild);
+
+public:
+	virtual void RemoveAllChildren();
+
+	virtual void SendToBack(void);
+	virtual void BringToFront(void);
+	virtual void BringNextToControl(Controls::Base* pChild, bool bBehind);
+
+	virtual Gwen::Point LocalPosToCanvas(const Gwen::Point& in);
+	virtual Gwen::Point CanvasPosToLocal(const Gwen::Point& in);
+
+	virtual void Dock(int iDock);
+	virtual int GetDock();
+
+	virtual void RestrictToParent(bool restrict) { m_bRestrictToParent = restrict; }
+	virtual bool ShouldRestrictToParent() { return m_bRestrictToParent; }
+
+	virtual int X() const
+	{
+		return m_Bounds.x;
+	}
+	virtual int Y() const
+	{
+		return m_Bounds.y;
+	}
+	virtual int Width() const
+	{
+		return m_Bounds.w;
+	}
+	virtual int Height() const
+	{
+		return m_Bounds.h;
+	}
+	virtual int Bottom() const
+	{
+		return m_Bounds.y + m_Bounds.h + m_Margin.bottom;
+	}
+	virtual int Right() const
+	{
+		return m_Bounds.x + m_Bounds.w + m_Margin.right;
+	}
+
+	virtual const Margin& GetMargin() const { return m_Margin; }
+	virtual const Padding& GetPadding() const { return m_Padding; }
+
+	virtual void SetPos(int x, int y);
+	virtual void SetWidth(int w)
+	{
+		SetSize(w, Height());
+	}
+	virtual void SetHeight(int h)
+	{
+		SetSize(Width(), h);
+	}
+	virtual bool SetSize(int w, int h);
+	virtual bool SetBounds(int x, int y, int w, int h);
+	virtual bool SetBounds(const Gwen::Rect& bounds);
+
+	virtual void SetPadding(const Padding& padding);
+	virtual void SetMargin(const Margin& margin);
+
+	// MoveTo is identical to SetPos except it uses ShouldRestrictToParent()
+	virtual void MoveTo(int x, int y);
+	virtual void MoveBy(int x, int y);
+
+	virtual const Gwen::Rect& GetBounds() const
+	{
+		return m_Bounds;
+	}
+
+	virtual Controls::Base* GetControlAt(int x, int y);
+
+protected:
+	virtual void OnBoundsChanged(Gwen::Rect oldBounds);
+	virtual void OnChildBoundsChanged(Gwen::Rect oldChildBounds, Base* pChild);
+
+	virtual void OnScaleChanged();
+
+public:
+	// Innerbounds is the area inside the control that
+	// doesn't have child controls docked to it.
+	virtual const Gwen::Rect& GetInnerBounds() const { return m_InnerBounds; }
+
+protected:
+	Gwen::Rect m_InnerBounds;
+
+public:
+	virtual const Gwen::Rect& GetRenderBounds() const { return m_RenderBounds; }
+
+protected:
+	virtual void UpdateRenderBounds();
+
+public:
+	virtual void DoRender(Gwen::Skin::Base* skin);
+	virtual void DoCacheRender(Gwen::Skin::Base* skin, Gwen::Controls::Base* pMaster);
+
+protected:
+	virtual void Render(Gwen::Skin::Base* skin);
+	virtual void RenderUnder(Gwen::Skin::Base* /*skin*/){};
+	virtual void RenderOver(Gwen::Skin::Base* /*skin*/){};
+	virtual void RenderFocus(Gwen::Skin::Base* /*skin*/);
+
+public:
+	virtual void SetHidden(bool hidden)
+	{
+		if (m_bHidden == hidden)
+			return;
+		m_bHidden = hidden;
+		Invalidate();
+	}
+	virtual bool Hidden() const;   // Returns true only if this control is hidden
+	virtual bool Visible() const;  // Returns false if this control or its parents are hidden
+	virtual void Hide() { SetHidden(true); }
+	virtual void Show() { SetHidden(false); }
+
+	//Skin
+	virtual void SetSkin(Skin::Base* skin, bool doChildren = false);
+	virtual Gwen::Skin::Base* GetSkin(void);
+
+	// Background drawing
+	virtual bool ShouldDrawBackground() { return m_bDrawBackground; }
+	virtual void SetShouldDrawBackground(bool b) { m_bDrawBackground = b; }
+
+protected:
+	virtual void OnSkinChanged(Gwen::Skin::Base* newSkin);
+
+public:
+	virtual void OnMouseMoved(int x, int y, int deltaX, int deltaY);
+	virtual bool OnMouseWheeled(int iDelta);
+	virtual void OnMouseClickLeft(int /*x*/, int /*y*/, bool /*bDown*/){};
+	virtual void OnMouseClickRight(int /*x*/, int /*y*/, bool /*bDown*/) {}
+	virtual void OnMouseDoubleClickLeft(int x, int y) { OnMouseClickLeft(x, y, true); };
+	virtual void OnMouseDoubleClickRight(int x, int y) { OnMouseClickRight(x, y, true); };
+	virtual void OnLostKeyboardFocus() {}
+	virtual void OnKeyboardFocus() {}
+
+	virtual void SetMouseInputEnabled(bool b) { m_bMouseInputEnabled = b; }
+	virtual bool GetMouseInputEnabled() { return m_bMouseInputEnabled; }
+
+	virtual void SetKeyboardInputEnabled(bool b) { m_bKeyboardInputEnabled = b; }
+	virtual bool GetKeyboardInputEnabled() const { return m_bKeyboardInputEnabled; }
+	virtual bool NeedsInputChars() { return false; }
+
+	virtual bool OnChar(Gwen::UnicodeChar /*c*/) { return false; }
+
+	virtual bool OnKeyPress(int iKey, bool bPress = true);
+	virtual bool OnKeyRelease(int iKey);
+
+	virtual void OnPaste(Controls::Base* /*pFrom*/) {}
+	virtual void OnCopy(Controls::Base* /*pFrom*/) {}
+	virtual void OnCut(Controls::Base* /*pFrom*/) {}
+	virtual void OnSelectAll(Controls::Base* /*pFrom*/) {}
+
+	virtual bool OnKeyTab(bool bDown);
+	virtual bool OnKeySpace(bool /*bDown*/) { return false; }
+	virtual bool OnKeyReturn(bool /*bDown*/) { return false; }
+	virtual bool OnKeyBackspace(bool /*bDown*/) { return false; }
+	virtual bool OnKeyDelete(bool /*bDown*/) { return false; }
+	virtual bool OnKeyRight(bool /*bDown*/) { return false; }
+	virtual bool OnKeyLeft(bool /*bDown*/) { return false; }
+	virtual bool OnKeyHome(bool /*bDown*/) { return false; }
+	virtual bool OnKeyEnd(bool /*bDown*/) { return false; }
+	virtual bool OnKeyUp(bool /*bDown*/) { return false; }
+	virtual bool OnKeyDown(bool /*bDown*/) { return false; }
+	virtual bool OnKeyEscape(bool /*bDown*/) { return false; }
+
+	virtual void OnMouseEnter();
+	virtual void OnMouseLeave();
+	virtual bool IsHovered();
+	virtual bool ShouldDrawHover();
+
+	virtual void Touch();
+	virtual void OnChildTouched(Controls::Base* pChild);
+
+	virtual bool IsOnTop();
+
+	virtual bool HasFocus();
+	virtual void Focus();
+	virtual void Blur();
+
+	//Other
+	virtual void SetDisabled(bool active) { m_bDisabled = active; }
+	virtual bool IsDisabled() { return m_bDisabled; }
+
+	virtual void Redraw()
+	{
+		m_bCacheTextureDirty = true;
+		if (m_Parent) m_Parent->Redraw();
+	}
+	virtual void SetCacheToTexture() { m_bCacheToTexture = true; }
+	virtual bool ShouldCacheToTexture() { return m_bCacheToTexture; }
+
+	virtual void SetCursor(unsigned char c) { m_Cursor = c; }
+	virtual void UpdateCursor();
+
+	virtual Gwen::Point GetMinimumSize() { return Gwen::Point(1, 1); }
+	virtual Gwen::Point GetMaximumSize() { return Gwen::Point(4096, 4096); }
+
+	virtual void SetToolTip(const String& strText);
+	virtual void SetToolTip(const UnicodeString& strText);
+	virtual void SetToolTip(Base* tooltip)
+	{
+		m_ToolTip = tooltip;
+		if (m_ToolTip)
+		{
+			m_ToolTip->SetParent(this);
+			m_ToolTip->SetHidden(true);
+		}
+	}
+	virtual Base* GetToolTip() { return m_ToolTip; }
+
+	virtual bool IsMenuComponent();
+	virtual void CloseMenus();
+
+	virtual bool IsTabable() { return m_Tabable; }
+	virtual void SetTabable(bool isTabable) { m_Tabable = isTabable; }
+
+	//Accelerator functionality
+	void DefaultAccel(Gwen::Controls::Base* /*pCtrl*/) { AcceleratePressed(); }
+	virtual void AcceleratePressed(){};
+	virtual bool AccelOnlyFocus() { return false; }
+	virtual bool HandleAccelerator(Gwen::UnicodeString& accelerator);
+
+	template <typename T>
+	void AddAccelerator(Gwen::UnicodeString accelerator, T func, Gwen::Event::Handler* handler = NULL)
+	{
+		if (handler == NULL)
+			handler = this;
+		Gwen::Event::Caller* caller = new Gwen::Event::Caller();
+		caller->Add(handler, func);
+		m_Accelerators[accelerator] = caller;
+	}
+
+	void AddAccelerator(Gwen::UnicodeString accelerator)
+	{
+		AddAccelerator(accelerator, &Base::DefaultAccel, this);
+	}
+
+	AccelMap m_Accelerators;
+
+	// Default Events
+
+	Gwen::Event::Caller onHoverEnter;
+	Gwen::Event::Caller onHoverLeave;
+
+	// Childrens List
+
+	Base::List Children;
+
+protected:
+	// The logical parent
+	// It's usually what you expect, the control you've parented it to.
+	Base* m_Parent;
+
+	// If the innerpanel exists our children will automatically
+	//  become children of that instead of us - allowing us to move
+	//  them all around by moving that panel (useful for scrolling etc)
+	Base* m_InnerPanel;
+
+	// This is the panel's actual parent - most likely the logical
+	//  parent's InnerPanel (if it has one). You should rarely need this.
+	Base* m_ActualParent;
+
+	Base* m_ToolTip;
+
+	Skin::Base* m_Skin;
+
+	Gwen::Rect m_Bounds;
+	Gwen::Rect m_RenderBounds;
+	Padding m_Padding;
+	Margin m_Margin;
+
+	Gwen::String m_Name;
+
+	bool m_bRestrictToParent;
+	bool m_bDisabled;
+	bool m_bHidden;
+	bool m_bMouseInputEnabled;
+	bool m_bKeyboardInputEnabled;
+	bool m_bDrawBackground;
+
+	int m_iDock;
+
+	unsigned char m_Cursor;
+
+	bool m_Tabable;
+
+public:
+	bool NeedsLayout() { return m_bNeedsLayout; }
+	void Invalidate();
+	void InvalidateParent()
+	{
+		if (m_Parent)
+		{
+			m_Parent->Invalidate();
+		}
+	}
+	void InvalidateChildren(bool bRecursive = false);
+	void Position(int pos, int xpadding = 0, int ypadding = 0);
+
+protected:
+	virtual void RecurseLayout(Skin::Base* skin);
+	virtual void Layout(Skin::Base* skin);
+	virtual void PostLayout(Skin::Base* /*skin*/){};
+
+	bool m_bNeedsLayout;
+	bool m_bCacheTextureDirty;
+	bool m_bCacheToTexture;
+
+	//
+	// Drag + Drop
+public:
+	// Giver
+
+	virtual void DragAndDrop_SetPackage(bool bDraggable, const String& strName = "", void* pUserData = NULL);
+	virtual bool DragAndDrop_Draggable();
+	virtual bool DragAndDrop_ShouldStartDrag() { return true; }
+	virtual void DragAndDrop_StartDragging(Gwen::DragAndDrop::Package* pPackage, int x, int y);
+	virtual Gwen::DragAndDrop::Package* DragAndDrop_GetPackage(int x, int y);
+	virtual void DragAndDrop_EndDragging(bool /*bSuccess*/, int /*x*/, int /*y*/){};
+
+protected:
+	DragAndDrop::Package* m_DragAndDrop_Package;
+
+public:
+	// Receiver
+	virtual void DragAndDrop_HoverEnter(Gwen::DragAndDrop::Package* /*pPackage*/, int /*x*/, int /*y*/) {}
+	virtual void DragAndDrop_HoverLeave(Gwen::DragAndDrop::Package* /*pPackage*/) {}
+	virtual void DragAndDrop_Hover(Gwen::DragAndDrop::Package* /*pPackage*/, int /*x*/, int /*y*/){};
+	virtual bool DragAndDrop_HandleDrop(Gwen::DragAndDrop::Package* pPackage, int x, int y);
+	virtual bool DragAndDrop_CanAcceptPackage(Gwen::DragAndDrop::Package* /*pPackage*/) { return false; }
+
+	//
+	// This is to be used by the client implementation
+	// NOT HOOKS ETC.
+	//
+public:
+	void* GetUserData() { return m_pUserData; }
+	void SetUserData(void* pData) { m_pUserData = pData; }
+
+private:
+	void* m_pUserData;
+
+	//
+	// Useful anim shortcuts
+	//
+public:
+#ifndef GWEN_NO_ANIMATION
+
+	virtual void Anim_WidthIn(float fLength, float fDelay = 0.0f, float fEase = 1.0f);
+	virtual void Anim_HeightIn(float fLength, float fDelay = 0.0f, float fEase = 1.0f);
+	virtual void Anim_WidthOut(float fLength, bool bHide = true, float fDelay = 0.0f, float fEase = 1.0f);
+	virtual void Anim_HeightOut(float fLength, bool bHide = true, float fDelay = 0.0f, float fEase = 1.0f);
+
+#endif
+};
+
+}  // namespace Controls
+}  // namespace Gwen
+
+// To be placed in the controls .h definition.
+#define GWEN_CONTROL(ThisName, BaseName) \
+public:                                  \
+	typedef BaseName BaseClass;          \
+	typedef ThisName ThisClass;          \
+	GWEN_IMPLEMENT_CAST(ThisName);       \
+	ThisName(Gwen::Controls::Base* pParent)
+
+#define GWEN_CONTROL_INLINE(ThisName, BaseName) \
+	GWEN_CONTROL(ThisName, BaseName) : BaseClass(pParent)
+
+#define GWEN_CONTROL_CONSTRUCTOR(ThisName) \
+	ThisName::ThisName(Gwen::Controls::Base* pParent) : BaseClass(pParent)
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Button.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Button.h
new file mode 100644
index 00000000..135d06bc
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Button.h
@@ -0,0 +1,86 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_BUTTON_H
+#define GWEN_CONTROLS_BUTTON_H
+
+#include "Gwen/TextObject.h"
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Label.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class ImagePanel;
+
+class GWEN_EXPORT Button : public Label
+{
+public:
+	GWEN_CONTROL(Button, Label);
+
+	virtual void Render(Skin::Base* skin);
+	virtual void OnMouseClickLeft(int x, int y, bool bDown);
+	virtual void OnMouseDoubleClickLeft(int x, int y);
+	virtual bool OnKeySpace(bool bDown);
+
+	virtual void OnPress();
+
+	virtual void AcceleratePressed();
+
+	virtual bool IsDepressed() const { return m_bDepressed; }
+
+	//
+	// Buttons can be toggle type, which means that it is
+	// toggled on and off. Its toggle status is in IsDepressed.
+	//
+	virtual void SetIsToggle(bool b) { m_bToggle = b; }
+	virtual bool IsToggle() const { return m_bToggle; }
+	virtual bool GetToggleState() const { return m_bToggleStatus; }
+	virtual void SetToggleState(bool b);
+	virtual void Toggle() { SetToggleState(!GetToggleState()); }
+
+	virtual void SetImage(const TextObject& strName, bool bCenter = false);
+
+	// You can use this to trigger OnPress directly from other controls using GWEN_CALL_EX
+	virtual void ReceiveEventPress(Base* /*pControl*/)
+	{
+		OnPress();
+	}
+
+	virtual void SizeToContents();
+	virtual void Layout(Skin::Base* pSkin);
+
+	virtual bool OnKeyReturn(bool bDown)
+	{
+		onKeyboardReturn.Call(this);
+		return true;
+	}
+
+public:
+	Gwen::Event::Caller onPress;
+	Gwen::Event::Caller onDown;
+	Gwen::Event::Caller onUp;
+	Gwen::Event::Caller onDoubleClick;
+	Gwen::Event::Caller onKeyboardReturn;
+
+	Gwen::Event::Caller onToggle;
+	Gwen::Event::Caller onToggleOn;
+	Gwen::Event::Caller onToggleOff;
+
+protected:
+	ImagePanel* m_Image;
+
+	bool m_bDepressed;
+	bool m_bToggle;
+	bool m_bToggleStatus;
+
+	bool m_bCenterImage;
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Canvas.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Canvas.h
new file mode 100644
index 00000000..689640f8
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Canvas.h
@@ -0,0 +1,103 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_CANVAS_H
+#define GWEN_CONTROLS_CANVAS_H
+
+#include <set>
+#include "Gwen/Controls/Base.h"
+#include "Gwen/InputHandler.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class GWEN_EXPORT Canvas : public Base
+{
+public:
+	typedef Controls::Base BaseClass;
+
+	Canvas(Skin::Base* pSkin);
+
+	//
+	// For additional initialization
+	// (which is sometimes not appropriate in the constructor)
+	//
+	virtual void Initialize(){};
+
+	//
+	// You should call this to render your canvas.
+	//
+	virtual void RenderCanvas();
+
+	//
+	// Call this whenever you want to process input. This
+	// is usually once a frame..
+	//
+	virtual void DoThink();
+
+	//
+	// In most situations you will be rendering the canvas
+	// every frame. But in some situations you will only want
+	// to render when there have been changes. You can do this
+	// by checking NeedsRedraw().
+	//
+	virtual bool NeedsRedraw() { return m_bNeedsRedraw; }
+	virtual void Redraw() { m_bNeedsRedraw = true; }
+
+	// Internal. Do not call directly.
+	virtual void Render(Skin::Base* pRender);
+
+	// Childpanels call parent->GetCanvas() until they get to
+	// this top level function.
+	virtual Controls::Canvas* GetCanvas() { return this; }
+
+	virtual void SetScale(float f);
+	virtual float Scale() const { return m_fScale; }
+
+	virtual void OnBoundsChanged(Gwen::Rect oldBounds);
+
+	//
+	// Call this to delete the canvas, and its children
+	// in the right order.
+	//
+	virtual void Release();
+
+	// Delayed deletes
+	virtual void AddDelayedDelete(Controls::Base* pControl);
+	virtual void ProcessDelayedDeletes();
+
+	Controls::Base* FirstTab;
+	Controls::Base* NextTab;
+
+	// Input
+	virtual bool InputMouseMoved(int x, int y, int deltaX, int deltaY);
+	virtual bool InputMouseButton(int iButton, bool bDown);
+	virtual bool InputKey(int iKey, bool bDown);
+	virtual bool InputCharacter(Gwen::UnicodeChar chr);
+	virtual bool InputMouseWheel(int val);
+
+	// Background
+	virtual void SetBackgroundColor(const Gwen::Color& color) { m_BackgroundColor = color; }
+	virtual void SetDrawBackground(bool bShouldDraw) { m_bDrawBackground = bShouldDraw; }
+
+private:
+	bool m_bNeedsRedraw;
+	bool m_bAnyDelete;
+	float m_fScale;
+
+	Controls::Base::List m_DeleteList;
+	std::set<Controls::Base*> m_DeleteSet;
+	friend class Controls::Base;
+	void PreDelete(Controls::Base*);
+
+	bool m_bDrawBackground;
+	Gwen::Color m_BackgroundColor;
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/CheckBox.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/CheckBox.h
new file mode 100644
index 00000000..4d0bd91b
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/CheckBox.h
@@ -0,0 +1,81 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_CHECKBOX_H
+#define GWEN_CONTROLS_CHECKBOX_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Button.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Skin.h"
+#include "Gwen/Controls/Symbol.h"
+#include "Gwen/Controls/LabelClickable.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class GWEN_EXPORT CheckBox : public Button
+{
+public:
+	GWEN_CONTROL(CheckBox, Button);
+
+	virtual void Render(Skin::Base* skin);
+	virtual void OnPress();
+
+	virtual void SetChecked(bool Checked);
+	virtual void Toggle() { SetChecked(!IsChecked()); }
+	virtual bool IsChecked() { return m_bChecked; }
+
+	Gwen::Event::Caller onChecked;
+	Gwen::Event::Caller onUnChecked;
+	Gwen::Event::Caller onCheckChanged;
+
+private:
+	// For derived controls
+	virtual bool AllowUncheck() { return true; }
+
+	void OnCheckStatusChanged();
+
+	bool m_bChecked;
+};
+
+class GWEN_EXPORT CheckBoxWithLabel : public Base
+{
+public:
+	GWEN_CONTROL_INLINE(CheckBoxWithLabel, Base)
+	{
+		SetSize(200, 19);
+
+		m_Checkbox = new CheckBox(this);
+		m_Checkbox->Dock(Pos::Left);
+		m_Checkbox->SetMargin(Margin(0, 3, 3, 3));
+		m_Checkbox->SetTabable(false);
+
+		m_Label = new LabelClickable(this);
+		m_Label->Dock(Pos::Fill);
+		m_Label->onPress.Add(m_Checkbox, &CheckBox::ReceiveEventPress);
+		m_Label->SetTabable(false);
+
+		SetTabable(false);
+	}
+
+	virtual CheckBox* Checkbox() { return m_Checkbox; }
+	virtual LabelClickable* Label() { return m_Label; }
+	virtual bool OnKeySpace(bool bDown)
+	{
+		if (bDown) m_Checkbox->SetChecked(!m_Checkbox->IsChecked());
+		return true;
+	}
+
+private:
+	CheckBox* m_Checkbox;
+	LabelClickable* m_Label;
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ColorControls.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ColorControls.h
new file mode 100644
index 00000000..65a01ac3
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ColorControls.h
@@ -0,0 +1,58 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_COLORCONTROLS_H
+#define GWEN_CONTROLS_COLORCONTROLS_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Skin.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class GWEN_EXPORT ColorLerpBox : public Controls::Base
+{
+public:
+	GWEN_CONTROL(ColorLerpBox, Controls::Base);
+	virtual void Render(Gwen::Skin::Base* skin);
+	Gwen::Color GetColorAtPos(int x, int y);
+	void SetColor(Gwen::Color color, bool onlyHue = true);
+	virtual void OnMouseMoved(int x, int y, int deltaX, int deltaY);
+	virtual void OnMouseClickLeft(int x, int y, bool bDown);
+	Gwen::Color GetSelectedColor();
+
+	Event::Caller onSelectionChanged;
+
+protected:
+	Gwen::Point cursorPos;
+	bool m_bDepressed;
+	int m_Hue;
+};
+
+class GWEN_EXPORT ColorSlider : public Controls::Base
+{
+public:
+	GWEN_CONTROL(ColorSlider, Controls::Base);
+	virtual void Render(Gwen::Skin::Base* skin);
+	virtual void OnMouseMoved(int x, int y, int deltaX, int deltaY);
+	virtual void OnMouseClickLeft(int x, int y, bool bDown);
+	Gwen::Color GetSelectedColor();
+	Gwen::Color GetColorAtHeight(int y);
+	void SetColor(Gwen::Color color);
+
+	Event::Caller onSelectionChanged;
+
+protected:
+	int m_iSelectedDist;
+	bool m_bDepressed;
+};
+}  // namespace Controls
+
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ColorPicker.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ColorPicker.h
new file mode 100644
index 00000000..645ce5aa
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ColorPicker.h
@@ -0,0 +1,85 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_COLORPICKER_H
+#define GWEN_CONTROLS_COLORPICKER_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Skin.h"
+
+namespace Gwen
+{
+namespace ControlsInternal
+{
+class GWEN_EXPORT ColorDisplay : public Controls::Base
+{
+public:
+	GWEN_CONTROL_INLINE(ColorDisplay, Controls::Base)
+	{
+		SetSize(32, 32);
+		m_Color = Color(255, 0, 0, 255);
+		m_DrawCheckers = true;
+	}
+
+	virtual void Render(Gwen::Skin::Base* skin)
+	{
+		skin->DrawColorDisplay(this, m_Color);
+	}
+
+	virtual void SetColor(Gwen::Color color) { m_Color = color; }
+	virtual Gwen::Color GetColor() { return m_Color; }
+
+	virtual void SetRed(int red) { m_Color.r = red; }
+	virtual void SetGreen(int green) { m_Color.g = green; }
+	virtual void SetBlue(int blue) { m_Color.b = blue; }
+	virtual void SetAlpha(int alpha) { m_Color.a = alpha; }
+
+	virtual void SetDrawCheckers(bool should) { m_DrawCheckers = should; }
+
+protected:
+	Gwen::Color m_Color;
+	bool m_DrawCheckers;
+};
+}  // namespace ControlsInternal
+namespace Controls
+{
+class GWEN_EXPORT ColorPicker : public Base
+{
+public:
+	GWEN_CONTROL(ColorPicker, Base);
+
+	virtual void Render(Skin::Base* skin);
+	virtual void Layout(Skin::Base* skin);
+	virtual void CreateControls();
+	virtual void SlidersMoved(Gwen::Controls::Base* control);
+	virtual void NumericTyped(Gwen::Controls::Base* control);
+	virtual void UpdateControls();
+	virtual void UpdateColorControls(Gwen::String name, Gwen::Color col, int sliderVal);
+	virtual void CreateColorControl(Gwen::String name, int y);
+
+	virtual void SetColor(Gwen::Color color);
+	virtual Gwen::Color GetColor() { return m_Color; }
+
+	int GetColorByName(Gwen::String colorName);
+	void SetColorByName(Gwen::String colorName, int colorValue);
+	Gwen::String GetColorFromName(Gwen::String name);
+	virtual void SetAlphaVisible(bool visible);
+
+	virtual void SetRed(int red) { m_Color.r = red; }
+	virtual void SetGreen(int green) { m_Color.g = green; }
+	virtual void SetBlue(int blue) { m_Color.b = blue; }
+	virtual void SetAlpha(int alpha) { m_Color.a = alpha; }
+
+	Event::Caller onColorChanged;
+
+protected:
+	Gwen::Color m_Color;
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ComboBox.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ComboBox.h
new file mode 100644
index 00000000..c0f5a6d1
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ComboBox.h
@@ -0,0 +1,83 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_COMBOBOX_H
+#define GWEN_CONTROLS_COMBOBOX_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Button.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Skin.h"
+#include "Gwen/Controls/TextBox.h"
+#include "Gwen/Controls/Menu.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class GWEN_EXPORT ComboBoxButton : public Button
+{
+	GWEN_CONTROL_INLINE(ComboBoxButton, Button) {}
+
+	virtual void Render(Skin::Base* skin)
+	{
+		skin->DrawComboBoxButton(this, m_bDepressed);
+	}
+};
+
+class GWEN_EXPORT ComboBox : public Button
+{
+public:
+	GWEN_CONTROL(ComboBox, Button);
+
+	virtual void Render(Skin::Base* skin);
+
+	virtual Gwen::Controls::Label* GetSelectedItem();
+
+	virtual void OnPress();
+	void OpenButtonPressed(Controls::Base* /*pControl*/);
+
+	virtual void OnItemSelected(Controls::Base* pControl);
+	virtual void OpenList();
+	virtual void CloseList();
+
+	virtual Controls::Base* GetControlAt(int x, int y)
+	{
+		if (x < 0 || y < 0 || x >= Width() || y >= Height())
+			return NULL;
+
+		return this;
+	}
+	virtual bool IsMenuComponent()
+	{
+		return true;
+	}
+
+	virtual void ClearItems();
+
+	virtual MenuItem* AddItem(const UnicodeString& strLabel, const String& strName = "", Gwen::Event::Handler* pHandler = NULL, Gwen::Event::Handler::Function fn = NULL);
+	virtual bool OnKeyUp(bool bDown);
+	virtual bool OnKeyDown(bool bDown);
+
+	virtual void RenderFocus(Gwen::Skin::Base* skin);
+	virtual void OnLostKeyboardFocus();
+	virtual void OnKeyboardFocus();
+
+	virtual bool IsMenuOpen();
+
+	Gwen::Event::Caller onSelection;
+
+protected:
+	Menu* m_Menu;
+	MenuItem* m_SelectedItem;
+
+	Controls::Base* m_Button;
+};
+
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/CrossSplitter.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/CrossSplitter.h
new file mode 100644
index 00000000..d03ea145
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/CrossSplitter.h
@@ -0,0 +1,71 @@
+#pragma once
+#ifndef GWEN_CONTROLS_CROSSSPLITTER_H
+#define GWEN_CONTROLS_CROSSSPLITTER_H
+
+#include "Gwen/Gwen.h"
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/SplitterBar.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class GWEN_EXPORT CrossSplitter : public Controls::Base
+{
+public:
+	GWEN_CONTROL(CrossSplitter, Controls::Base);
+
+	void Layout(Skin::Base* skin);
+
+	virtual float CalculateValueVertical();
+	virtual float CalculateValueHorizontal();
+	virtual void CalculateValueCenter();
+	virtual void UpdateHSplitter();
+	virtual void UpdateVSplitter();
+	virtual void UpdateCSplitter();
+	virtual void OnVerticalMoved(Controls::Base* control);
+	virtual void OnHorizontalMoved(Controls::Base* control);
+	virtual void OnCenterMoved(Controls::Base* control);
+
+	virtual void SetPanel(int i, Controls::Base* pPanel);
+	virtual Controls::Base* GetPanel(int i);
+
+	virtual bool IsZoomed() { return m_iZoomedSection != -1; }
+	virtual void Zoom(int section);
+	virtual void UnZoom();
+	virtual void ZoomChanged();
+	virtual void CenterPanels()
+	{
+		m_fHVal = 0.5f;
+		m_fVVal = 0.5f;
+		Invalidate();
+	}
+
+	virtual void SetSplittersVisible(bool b)
+	{
+		m_VSplitter->SetShouldDrawBackground(b);
+		m_HSplitter->SetShouldDrawBackground(b);
+		m_CSplitter->SetShouldDrawBackground(b);
+	}
+	virtual void SetSplitterSize(int size) { m_fBarSize = size; }
+
+private:
+	SplitterBar* m_VSplitter;
+	SplitterBar* m_HSplitter;
+	SplitterBar* m_CSplitter;
+
+	Controls::Base* m_Sections[4];
+
+	float m_fHVal;
+	float m_fVVal;
+	int m_fBarSize;
+
+	int m_iZoomedSection;
+
+	Gwen::Event::Caller onZoomed;
+	Gwen::Event::Caller onUnZoomed;
+	Gwen::Event::Caller onZoomChange;
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Dialogs/FileOpen.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Dialogs/FileOpen.h
new file mode 100644
index 00000000..fd53cf8d
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Dialogs/FileOpen.h
@@ -0,0 +1,34 @@
+#pragma once
+#ifndef GWEN_CONTROLS_DIALOGS_FILEOPEN_H
+#define GWEN_CONTROLS_DIALOGS_FILEOPEN_H
+
+#include "Gwen/Gwen.h"
+
+namespace Gwen
+{
+namespace Dialogs
+{
+// Usage:
+//
+// Gwen::Dialogs::FileOpen( true, "Open Map", "C:\my\folder\", "My Map Format|*.bmf", this, &MyClass::OpenFilename );
+//
+
+//
+// The REAL function.
+// If bUseSystem is used, it may use the system's modal dialog - which
+// will steal focus and pause the rest of GWEN until it's continued.
+//
+void GWEN_EXPORT FileOpenEx(bool bUseSystem, const String& Name, const String& StartPath, const String& Extension, Gwen::Event::Handler* pHandler = NULL, Gwen::Event::Handler::FunctionStr fnCallback = NULL);
+
+//
+// Templated function simply to avoid having to manually cast the callback function.
+//
+template <typename A>
+void FileOpen(bool bUseSystem, const String& Name, const String& StartPath, const String& Extension, Gwen::Event::Handler* pHandler = NULL, A fnCallback = NULL)
+{
+	FileOpenEx(bUseSystem, Name, StartPath, Extension, pHandler, (Gwen::Event::Handler::FunctionStr)fnCallback);
+}
+
+}  // namespace Dialogs
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Dialogs/FileSave.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Dialogs/FileSave.h
new file mode 100644
index 00000000..176c7c4d
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Dialogs/FileSave.h
@@ -0,0 +1,39 @@
+#pragma once
+#ifndef GWEN_CONTROLS_DIALOGS_FILESAVE_H
+#define GWEN_CONTROLS_DIALOGS_FILESAVE_H
+
+#include "Gwen/Gwen.h"
+
+namespace Gwen
+{
+namespace Dialogs
+{
+// Usage:
+//
+// Gwen::Dialogs::FileOpen( true, "Open Map", "C:\my\folder\", "My Map Format|*.bmf", this, &MyClass::OpenFilename );
+//
+
+//
+// Callback function, for success
+//
+typedef void (Event::Handler::*FileSaveSuccessCallback)(const String& filename);
+
+//
+// The REAL function.
+// If bUseSystem is used, it may use the system's modal dialog - which
+// will steal focus and pause the rest of GWEN until it's continued.
+//
+void GWEN_EXPORT FileSaveEx(bool bUseSystem, const String& Name, const String& StartPath, const String& Extension, Gwen::Event::Handler* pHandler = NULL, Gwen::Event::Handler::FunctionStr fnCallback = NULL);
+
+//
+// Templated function simply to avoid having to manually cast the callback function.
+//
+template <typename A>
+void FileSave(bool bUseSystem, const String& Name, const String& StartPath, const String& Extension, Gwen::Event::Handler* pHandler = NULL, A fnCallback = NULL)
+{
+	FileSaveEx(bUseSystem, Name, StartPath, Extension, pHandler, (Gwen::Event::Handler::FunctionStr)fnCallback);
+}
+
+}  // namespace Dialogs
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Dialogs/Query.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Dialogs/Query.h
new file mode 100644
index 00000000..fba19876
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Dialogs/Query.h
@@ -0,0 +1,14 @@
+#pragma once
+#ifndef GWEN_CONTROLS_DIALOGS_QUERY_H
+#define GWEN_CONTROLS_DIALOGS_QUERY_H
+
+#include "Gwen/Gwen.h"
+
+namespace Gwen
+{
+namespace Dialogs
+{
+//TODO. YesNo, Ok etc
+}
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/DockBase.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/DockBase.h
new file mode 100644
index 00000000..907b5cb7
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/DockBase.h
@@ -0,0 +1,74 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_DOCKBASE_H
+#define GWEN_CONTROLS_DOCKBASE_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Button.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class DockedTabControl;
+class TabControl;
+
+class GWEN_EXPORT DockBase : public Base
+{
+public:
+	GWEN_CONTROL(DockBase, Base);
+
+	virtual void Render(Skin::Base* skin);
+	virtual void RenderOver(Skin::Base* skin);
+	virtual bool IsEmpty();
+
+	virtual TabControl* GetTabControl();
+
+	virtual DockBase* GetRight() { return GetChildDock(Pos::Right); }
+	virtual DockBase* GetLeft() { return GetChildDock(Pos::Left); }
+	virtual DockBase* GetTop() { return GetChildDock(Pos::Top); }
+	virtual DockBase* GetBottom() { return GetChildDock(Pos::Bottom); }
+
+	// No action on space (default button action is to press)
+	virtual bool OnKeySpace(bool /*bDown*/) { return false; }
+
+private:
+	// Drag n Drop
+	virtual bool DragAndDrop_HandleDrop(Gwen::DragAndDrop::Package* pPackage, int x, int y);
+	virtual bool DragAndDrop_CanAcceptPackage(Gwen::DragAndDrop::Package* pPackage);
+	virtual void DragAndDrop_HoverEnter(Gwen::DragAndDrop::Package* pPackage, int x, int y);
+	virtual void DragAndDrop_HoverLeave(Gwen::DragAndDrop::Package* pPackage);
+	virtual void DragAndDrop_Hover(Gwen::DragAndDrop::Package* pPackage, int x, int y);
+
+	virtual void SetupChildDock(int iPos);
+
+	virtual void DoRedundancyCheck();
+	virtual void DoConsolidateCheck();
+	virtual void OnRedundantChildDock(DockBase* pDockBase);
+
+	virtual int GetDroppedTabDirection(int x, int y);
+	virtual void OnTabRemoved(Gwen::Controls::Base* pControl);
+
+	DockBase* GetChildDock(int iPos);
+	DockBase** GetChildDockPtr(int iPos);
+
+	DockBase* m_Left;
+	DockBase* m_Right;
+	DockBase* m_Top;
+	DockBase* m_Bottom;
+
+	// Only CHILD dockpanels have a tabcontrol.
+	DockedTabControl* m_DockedTabControl;
+
+	bool m_bDrawHover;
+	bool m_bDropFar;
+	Gwen::Rect m_HoverRect;
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/DockedTabControl.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/DockedTabControl.h
new file mode 100644
index 00000000..86f0d92c
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/DockedTabControl.h
@@ -0,0 +1,39 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_DOCKEDTABCONTROL_H
+#define GWEN_CONTROLS_DOCKEDTABCONTROL_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/TabControl.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class GWEN_EXPORT DockedTabControl : public TabControl
+{
+public:
+	GWEN_CONTROL(DockedTabControl, TabControl);
+
+	void SetShowTitlebar(bool bShow) { m_pTitleBar->SetHidden(!bShow); }
+
+	void Layout(Skin::Base* skin);
+	void UpdateTitleBar();
+
+	virtual void DragAndDrop_StartDragging(Gwen::DragAndDrop::Package* pPackage, int x, int y);
+	virtual void DragAndDrop_EndDragging(bool bSuccess, int x, int y);
+
+	void MoveTabsTo(DockedTabControl* pTarget);
+
+private:
+	TabTitleBar* m_pTitleBar;
+	Base* m_WindowControl;
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Dragger.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Dragger.h
new file mode 100644
index 00000000..4465eb90
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Dragger.h
@@ -0,0 +1,40 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_DRAGGER_H
+#define GWEN_CONTROLS_DRAGGER_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Skin.h"
+
+namespace Gwen
+{
+namespace ControlsInternal
+{
+class GWEN_EXPORT Dragger : public Controls::Base
+{
+public:
+	GWEN_CONTROL(Dragger, Controls::Base);
+
+	virtual void OnMouseMoved(int x, int y, int deltaX, int deltaY);
+
+	virtual void OnMouseClickLeft(int x, int y, bool bDown);
+	virtual void Render(Skin::Base* skin);
+
+	virtual void SetTarget(Controls::Base* pBase) { m_pTarget = pBase; }
+
+	Gwen::Event::Caller onDragged;
+
+protected:
+	bool m_bDepressed;
+	Gwen::Point m_HoldPos;
+	Controls::Base* m_pTarget;
+};
+}  // namespace ControlsInternal
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/GroupBox.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/GroupBox.h
new file mode 100644
index 00000000..498366b6
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/GroupBox.h
@@ -0,0 +1,30 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_GROUPBOX_H
+#define GWEN_CONTROLS_GROUPBOX_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Label.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Skin.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class GWEN_EXPORT GroupBox : public Label
+{
+public:
+	GWEN_CONTROL(GroupBox, Label);
+
+	virtual void Render(Skin::Base* skin);
+	virtual void Layout(Skin::Base* skin);
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/HSVColorPicker.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/HSVColorPicker.h
new file mode 100644
index 00000000..601f5f38
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/HSVColorPicker.h
@@ -0,0 +1,46 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_HSVCOLORPICKER_H
+#define GWEN_CONTROLS_HSVCOLORPICKER_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Skin.h"
+#include "Gwen/Controls/ColorControls.h"
+#include "Gwen/Controls/ColorPicker.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class GWEN_EXPORT HSVColorPicker : public Controls::Base
+{
+public:
+	GWEN_CONTROL(HSVColorPicker, Controls::Base);
+
+	Gwen::Color GetColor();
+	Gwen::Color GetDefaultColor() { return m_Before->GetColor(); }
+	void SetColor(Gwen::Color color, bool onlyHue = false, bool reset = false);
+
+	void ColorBoxChanged(Gwen::Controls::Base* pControl);
+	void ColorSliderChanged(Gwen::Controls::Base* pControl);
+	void NumericTyped(Gwen::Controls::Base* control);
+
+	void UpdateControls(Gwen::Color newColor);
+
+	Event::Caller onColorChanged;
+
+protected:
+	ColorLerpBox* m_LerpBox;
+	ColorSlider* m_ColorSlider;
+	ControlsInternal::ColorDisplay* m_Before;
+	ControlsInternal::ColorDisplay* m_After;
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Highlight.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Highlight.h
new file mode 100644
index 00000000..36159354
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Highlight.h
@@ -0,0 +1,34 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_HIGHLIGHT_H
+#define GWEN_CONTROLS_HIGHLIGHT_H
+
+#include "Gwen/BaseRender.h"
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Skin.h"
+
+namespace Gwen
+{
+namespace ControlsInternal
+{
+class GWEN_EXPORT Highlight : public Controls::Base
+{
+public:
+	GWEN_CONTROL_INLINE(Highlight, Controls::Base)
+	{
+	}
+
+	void Render(Skin::Base* skin)
+	{
+		skin->DrawHighlight(this);
+	}
+};
+}  // namespace ControlsInternal
+
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/HorizontalScrollBar.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/HorizontalScrollBar.h
new file mode 100644
index 00000000..61a718c3
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/HorizontalScrollBar.h
@@ -0,0 +1,48 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_HORIZONTALSCROLLBAR_H
+#define GWEN_CONTROLS_HORIZONTALSCROLLBAR_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Button.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Skin.h"
+#include "Gwen/Controls/Dragger.h"
+#include "Gwen/Controls/ScrollBar.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class GWEN_EXPORT HorizontalScrollBar : public BaseScrollBar
+{
+public:
+	GWEN_CONTROL(HorizontalScrollBar, BaseScrollBar);
+
+	virtual void Layout(Skin::Base* skin);
+
+	virtual void OnMouseClickLeft(int x, int y, bool bDown);
+	virtual void OnBarMoved(Controls::Base* control);
+
+	virtual int GetBarSize() { return m_Bar->Width(); }
+	virtual int GetBarPos() { return m_Bar->X() - Height(); }
+	virtual void SetBarSize(int size) { m_Bar->SetWidth(size); }
+	virtual int GetButtonSize() { return Height(); }
+
+	virtual void ScrollToLeft();
+	virtual void ScrollToRight();
+	virtual void NudgeLeft(Base* control);
+	virtual void NudgeRight(Base* control);
+	virtual float GetNudgeAmount();
+
+	virtual float CalculateScrolledAmount();
+	virtual bool SetScrolledAmount(float amount, bool forceUpdate);
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/HorizontalSlider.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/HorizontalSlider.h
new file mode 100644
index 00000000..f3a56ce5
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/HorizontalSlider.h
@@ -0,0 +1,35 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_HORIZONTALSLIDER_H
+#define GWEN_CONTROLS_HORIZONTALSLIDER_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Button.h"
+#include "Gwen/Controls/Dragger.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Skin.h"
+#include "Gwen/Controls/Slider.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class GWEN_EXPORT HorizontalSlider : public Slider
+{
+	GWEN_CONTROL(HorizontalSlider, Slider);
+
+	virtual void Layout(Skin::Base* skin);
+	virtual void Render(Skin::Base* skin);
+
+	virtual float CalculateValue();
+	virtual void UpdateBarFromValue();
+	virtual void OnMouseClickLeft(int x, int y, bool bDown);
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ImagePanel.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ImagePanel.h
new file mode 100644
index 00000000..d705d18f
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ImagePanel.h
@@ -0,0 +1,75 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_IMAGEPANEL_H
+#define GWEN_CONTROLS_IMAGEPANEL_H
+
+#include "Gwen/Gwen.h"
+#include "Gwen/Controls/Base.h"
+#include "Gwen/BaseRender.h"
+#include "Gwen/Texture.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class GWEN_EXPORT ImagePanel : public Controls::Base
+{
+public:
+	GWEN_CONTROL_INLINE(ImagePanel, Controls::Base)
+	{
+		SetUV(0, 0, 1, 1);
+		SetMouseInputEnabled(false);
+		m_DrawColor = Colors::White;
+	}
+
+	virtual ~ImagePanel()
+	{
+		m_Texture.Release(GetSkin()->GetRender());
+	}
+
+	virtual void SetUV(float u1, float v1, float u2, float v2)
+	{
+		m_uv[0] = u1;
+		m_uv[1] = v1;
+		m_uv[2] = u2;
+		m_uv[3] = v2;
+	}
+
+	virtual void SetImage(const TextObject& imageName)
+	{
+		m_Texture.Load(imageName, GetSkin()->GetRender());
+	}
+
+	virtual const TextObject& GetImageName()
+	{
+		return m_Texture.name;
+	}
+
+	virtual void Render(Skin::Base* skin)
+	{
+		skin->GetRender()->SetDrawColor(m_DrawColor);
+		skin->GetRender()->DrawTexturedRect(&m_Texture, GetRenderBounds(), m_uv[0], m_uv[1], m_uv[2], m_uv[3]);
+	}
+
+	virtual void SizeToContents()
+	{
+		SetSize(m_Texture.width, m_Texture.height);
+	}
+
+	virtual void SetDrawColor(Gwen::Color& color)
+	{
+		m_DrawColor = color;
+	}
+
+	Texture m_Texture;
+	float m_uv[4];
+	Gwen::Color m_DrawColor;
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Label.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Label.h
new file mode 100644
index 00000000..d205266c
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Label.h
@@ -0,0 +1,72 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_LABEL_H
+#define GWEN_CONTROLS_LABEL_H
+
+#include "Gwen/BaseRender.h"
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Text.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class GWEN_EXPORT Label : public Controls::Base
+{
+public:
+	GWEN_CONTROL(Label, Controls::Base);
+
+	virtual void SetText(const UnicodeString& str, bool bDoEvents = true);
+	virtual void SetText(const String& str, bool bDoEvents = true);
+
+	virtual const UnicodeString& GetText() const { return m_Text->GetText(); }
+
+	virtual void Render(Skin::Base* /*skin*/) {}
+
+	virtual void Layout(Skin::Base* skin);
+
+	virtual void SizeToContents();
+
+	virtual void SetAlignment(int iAlign) { m_iAlign = iAlign; }
+
+	virtual void SetFont(Gwen::Font* pFont) { m_Text->SetFont(pFont); }
+	virtual Gwen::Font* GetFont() { return m_Text->GetFont(); }
+	virtual void SetTextColor(const Gwen::Color& col) { m_Text->SetTextColor(col); }
+	inline const Gwen::Color& TextColor() const { return m_Text->TextColor(); }
+
+	virtual int TextWidth() { return m_Text->Width(); }
+	virtual int TextRight() { return m_Text->Right(); }
+	virtual int TextHeight() { return m_Text->Height(); }
+	virtual int TextX() { return m_Text->X(); }
+	virtual int TextY() { return m_Text->Y(); }
+	virtual int TextLength() { return m_Text->Length(); }
+
+	Gwen::Point GetCharacterPosition(int iChar);
+
+	virtual void SetTextPadding(const Padding& padding)
+	{
+		m_rTextPadding = padding;
+		Invalidate();
+		InvalidateParent();
+	}
+	virtual const Padding& GetTextPadding() { return m_rTextPadding; }
+
+	virtual Gwen::UnicodeString GetText() { return m_Text->GetText(); }
+
+	inline int Alignment() const { return m_iAlign; }
+
+protected:
+	virtual void OnTextChanged(){};
+
+	Padding m_rTextPadding;
+	ControlsInternal::Text* m_Text;
+	int m_iAlign;
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/LabelClickable.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/LabelClickable.h
new file mode 100644
index 00000000..3b92a1c7
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/LabelClickable.h
@@ -0,0 +1,27 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_LABELCLICKABLE_H
+#define GWEN_CONTROLS_LABELCLICKABLE_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Button.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class GWEN_EXPORT LabelClickable : public Button
+{
+public:
+	GWEN_CONTROL(LabelClickable, Button);
+
+	virtual void Render(Skin::Base* skin);
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Layout/Splitter.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Layout/Splitter.h
new file mode 100644
index 00000000..2b1b7f0a
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Layout/Splitter.h
@@ -0,0 +1,82 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_LAYOUT_SPLITTER_H
+#define GWEN_CONTROLS_LAYOUT_SPLITTER_H
+
+#include "Gwen/Controls/Base.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+namespace Layout
+{
+class GWEN_EXPORT Splitter : public Base
+{
+public:
+	typedef Base BaseClass;
+
+	Splitter(Base* pParent) : BaseClass(pParent)
+	{
+		for (int i = 0; i < 2; i++)
+			m_pPanel[i] = NULL;
+	}
+
+	void SetPanel(int i, Base* pPanel)
+	{
+		if (i < 0 || i > 1) return;
+
+		m_pPanel[i] = pPanel;
+
+		if (m_pPanel[i])
+		{
+			m_pPanel[i]->SetParent(this);
+		}
+	}
+
+	Base* GetPanel(int i) const
+	{
+		if (i < 0 || i > 1) return NULL;
+		return m_pPanel[i];
+	}
+
+	void Layout(Skin::Base* skin)
+	{
+		LayoutVertical(skin);
+	}
+
+private:
+	void LayoutVertical(Skin::Base* /*skin*/)
+	{
+		int w = Width();
+		int h = Height();
+
+		if (m_pPanel[0])
+		{
+			const Margin& m = m_pPanel[0]->GetMargin();
+			m_pPanel[0]->SetBounds(m.left, m.top, w - m.left - m.right, (h * 0.5) - m.top - m.bottom);
+		}
+
+		if (m_pPanel[1])
+		{
+			const Margin& m = m_pPanel[1]->GetMargin();
+			m_pPanel[1]->SetBounds(m.left, m.top + (h * 0.5f), w - m.left - m.right, (h * 0.5f) - m.top - m.bottom);
+		}
+	}
+
+	void LayoutHorizontal(Skin::Base* /*skin*/)
+	{
+		// Todo.
+	}
+
+	Base* m_pPanel[2];
+};
+}  // namespace Layout
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Layout/Table.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Layout/Table.h
new file mode 100644
index 00000000..02a92761
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Layout/Table.h
@@ -0,0 +1,309 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_LAYOUT_TABLE_H
+#define GWEN_CONTROLS_LAYOUT_TABLE_H
+
+#include "Gwen/Controls/Label.h"
+#include "Gwen/Utility.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+namespace Layout
+{
+class Table;
+
+class GWEN_EXPORT TableRow : public Base
+{
+	static const int MaxColumns = 5;
+
+	GWEN_CONTROL_INLINE(TableRow, Base)
+	{
+		for (int i = 0; i < MaxColumns; i++)
+			m_Columns[i] = NULL;
+
+		m_ColumnCount = 0;
+	}
+
+	virtual class TableRow* DynamicCastLayoutTableRow()
+	{
+		return this;
+	}
+	virtual const class TableRow* DynamicCastLayoutTableRow() const
+	{
+		return this;
+	}
+
+	void SetColumnCount(int iCount)
+	{
+		if (iCount == m_ColumnCount) return;
+
+		if (iCount >= MaxColumns)
+			m_ColumnCount = MaxColumns;
+
+		for (int i = 0; i < MaxColumns; i++)
+		{
+			if (i < iCount)
+			{
+				if (!m_Columns[i])
+				{
+					m_Columns[i] = new Label(this);
+					m_Columns[i]->Dock(Pos::Left);
+					m_Columns[i]->SetPadding(Padding(3, 3, 3, 3));
+				}
+			}
+			else if (m_Columns[i])
+			{
+				m_Columns[i]->DelayedDelete();
+				m_Columns[i] = NULL;
+			}
+
+			m_ColumnCount = iCount;
+		}
+	}
+
+	void SetColumnWidth(int i, int iWidth)
+	{
+		if (!m_Columns[i]) return;
+		if (m_Columns[i]->Width() == iWidth) return;
+
+		m_Columns[i]->SetWidth(iWidth);
+	}
+
+	template <typename T>
+	void SetCellText(int i, const T& strString)
+	{
+		if (!m_Columns[i]) return;
+		m_Columns[i]->SetText(strString);
+	}
+
+	void SetCellContents(int i, Base* pControl, bool bEnableMouseInput = false)
+	{
+		if (!m_Columns[i]) return;
+		pControl->SetParent(m_Columns[i]);
+
+		m_Columns[i]->SetMouseInputEnabled(bEnableMouseInput);
+	}
+
+	Label* GetCellContents(int i)
+	{
+		return m_Columns[i];
+	}
+
+	void SizeToContents()
+	{
+		int iHeight = 0;
+
+		for (int i = 0; i < m_ColumnCount; i++)
+		{
+			if (!m_Columns[i]) continue;
+
+			// Note, more than 1 child here, because the
+			// label has a child built in ( The Text )
+			if (m_Columns[i]->NumChildren() > 1)
+			{
+				m_Columns[i]->SizeToChildren();
+			}
+			else
+			{
+				m_Columns[i]->SizeToContents();
+			}
+
+			iHeight = Utility::Max(iHeight, m_Columns[i]->Height());
+		}
+
+		SetHeight(iHeight);
+	}
+
+	void SetTextColor(const Gwen::Color& color)
+	{
+		for (int i = 0; i < m_ColumnCount; i++)
+		{
+			if (!m_Columns[i]) continue;
+			m_Columns[i]->SetTextColor(color);
+		}
+	}
+
+	//You might hate this. Actually I know you will
+	virtual UnicodeString GetText(int i)
+	{
+		return m_Columns[i]->GetText();
+	}
+	virtual void SetSelected(bool /*b*/) {}
+
+	//
+	// This is sometimes called by derivatives.
+	//
+	Gwen::Event::Caller onRowSelected;
+
+private:
+	int m_ColumnCount;
+	Label* m_Columns[MaxColumns];
+
+	friend class Table;
+};
+
+class GWEN_EXPORT Table : public Base
+{
+public:
+	GWEN_CONTROL_INLINE(Table, Base)
+	{
+		m_iColumnCount = 1;
+		m_iDefaultRowHeight = 22;
+
+		for (int i = 0; i < TableRow::MaxColumns; i++)
+		{
+			m_ColumnWidth[i] = 20;
+		}
+
+		m_bSizeToContents = false;
+	}
+
+	void SetColumnCount(int i)
+	{
+		if (m_iColumnCount == i) return;
+
+		for (Base::List::iterator it = Children.begin(); it != Children.end(); ++it)
+		{
+			if (!*it)
+				continue;
+
+			TableRow* pRow = (*it)->DynamicCastLayoutTableRow();
+			if (!pRow) continue;
+
+			pRow->SetColumnCount(i);
+		}
+
+		m_iColumnCount = i;
+	}
+
+	void SetColumnWidth(int i, int iWidth)
+	{
+		if (m_ColumnWidth[i] == iWidth) return;
+
+		m_ColumnWidth[i] = iWidth;
+		Invalidate();
+	}
+
+	TableRow* AddRow()
+	{
+		TableRow* row = new TableRow(this);
+		row->SetColumnCount(m_iColumnCount);
+		row->SetHeight(m_iDefaultRowHeight);
+		row->Dock(Pos::Top);
+		return row;
+	}
+
+	void AddRow(TableRow* pRow)
+	{
+		pRow->SetParent(this);
+		pRow->SetColumnCount(m_iColumnCount);
+		pRow->SetHeight(m_iDefaultRowHeight);
+		pRow->Dock(Pos::Top);
+	}
+
+	void Remove(TableRow* pRow)
+	{
+		pRow->DelayedDelete();
+	}
+
+	void Clear()
+	{
+		for (Base::List::iterator it = Children.begin(); it != Children.end(); ++it)
+		{
+			if (!(*it))
+				continue;
+
+			TableRow* pRow = (*it)->DynamicCastLayoutTableRow();
+
+			if (!pRow) continue;
+			Remove(pRow);
+		}
+	}
+
+	void Layout(Skin::Base* skin)
+	{
+		BaseClass::Layout(skin);
+
+		if (m_bSizeToContents)
+		{
+			DoSizeToContents();
+		}
+
+		for (Base::List::iterator it = Children.begin(); it != Children.end(); ++it)
+		{
+			if (!*it)
+				continue;
+
+			TableRow* pRow = (*it)->DynamicCastLayoutTableRow();
+			if (!pRow) continue;
+
+			for (int i = 0; i < TableRow::MaxColumns && i < m_iColumnCount; i++)
+			{
+				pRow->SetColumnWidth(i, m_ColumnWidth[i]);
+			}
+		}
+	}
+
+	void PostLayout(Skin::Base* /*skin*/)
+	{
+		if (m_bSizeToContents)
+		{
+			SizeToChildren();
+			m_bSizeToContents = false;
+		}
+	}
+
+	void SizeToContents()
+	{
+		m_bSizeToContents = true;
+		Invalidate();
+	}
+
+	void DoSizeToContents()
+	{
+		for (int i = 0; i < TableRow::MaxColumns; i++)
+		{
+			m_ColumnWidth[i] = 10;
+		}
+
+		for (Base::List::iterator it = Children.begin(); it != Children.end(); ++it)
+		{
+			if (!*it)
+				continue;
+
+			TableRow* pRow = (*it)->DynamicCastLayoutTableRow();
+			if (!pRow) continue;
+
+			pRow->SizeToContents();
+
+			for (int i = 0; i < TableRow::MaxColumns; i++)
+			{
+				if (pRow->m_Columns[i])
+				{
+					m_ColumnWidth[i] = Utility::Max(m_ColumnWidth[i], pRow->m_Columns[i]->Width());
+				}
+			}
+			//iBottom += pRow->Height();
+		}
+
+		InvalidateParent();
+	}
+
+private:
+	bool m_bSizeToContents;
+	int m_iColumnCount;
+	int m_iDefaultRowHeight;
+
+	int m_ColumnWidth[TableRow::MaxColumns];
+};
+}  // namespace Layout
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ListBox.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ListBox.h
new file mode 100644
index 00000000..096b94a2
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ListBox.h
@@ -0,0 +1,63 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_LISTBOX_H
+#define GWEN_CONTROLS_LISTBOX_H
+
+#include "Gwen/Gwen.h"
+#include "Gwen/Controls/Layout/Table.h"
+#include "Gwen/Controls/ScrollControl.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class ScrollControl;
+
+class GWEN_EXPORT ListBox : public Base
+{
+public:
+	GWEN_CONTROL(ListBox, Base);
+
+	typedef std::list<Layout::TableRow*> Rows;
+
+	Layout::TableRow* AddItem(const String& strLabel, const String& strName = "");
+	Layout::TableRow* AddItem(const UnicodeString& strLabel, const String& strName = "");
+
+	void Render(Skin::Base* skin);
+
+	void UnselectAll();
+
+	void SetColumnCount(int iCount) { m_Table->SetColumnCount(iCount); }
+
+	void SetAllowMultiSelect(bool bMultiSelect) { m_bMultiSelect = bMultiSelect; }
+	bool AllowMultiSelect() const { return m_bMultiSelect; }
+
+	const ListBox::Rows& GetSelectedRows() { return m_SelectedRows; }
+	Layout::TableRow* GetSelectedRow();
+
+	Gwen::Controls::ScrollControl* Scroller() { return m_ScrollControl; }
+
+	void OnChildBoundsChanged(Gwen::Rect oldChildBounds, Base* pChild);
+
+	Gwen::Event::Caller onRowSelected;
+
+	Controls::Layout::Table* GetTable() { return m_Table; }
+	virtual void Clear();
+
+protected:
+	void OnRowSelected(Base* pControl);
+
+	Controls::Layout::Table* m_Table;
+	ListBox::Rows m_SelectedRows;
+	Controls::ScrollControl* m_ScrollControl;
+
+	bool m_bMultiSelect;
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Menu.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Menu.h
new file mode 100644
index 00000000..a622c83c
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Menu.h
@@ -0,0 +1,83 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_MENU_H
+#define GWEN_CONTROLS_MENU_H
+
+#include "Gwen/BaseRender.h"
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/MenuItem.h"
+#include "Gwen/Controls/ScrollControl.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class MenuItem;
+
+class GWEN_EXPORT Menu : public ScrollControl
+{
+public:
+	GWEN_CONTROL(Menu, ScrollControl);
+
+	virtual void Render(Skin::Base* skin);
+	virtual void RenderUnder(Skin::Base* skin);
+
+	virtual void Layout(Skin::Base* skin);
+
+	virtual MenuItem* AddItem(const Gwen::UnicodeString& strName, const UnicodeString& strIconName, Gwen::Event::Handler* pHandler = NULL, Gwen::Event::Handler::Function fn = NULL);
+
+	virtual MenuItem* AddItem(const Gwen::UnicodeString& strName, Gwen::Event::Handler* pHandler = NULL, Gwen::Event::Handler::Function fn = NULL)
+	{
+		return AddItem(strName, L"", pHandler, fn);
+	}
+
+	virtual MenuItem* AddItem(const Gwen::String& strName, const String& strIconName, Gwen::Event::Handler* pHandler = NULL, Gwen::Event::Handler::Function fn = NULL);
+
+	virtual MenuItem* AddItem(const Gwen::String& strName, Gwen::Event::Handler* pHandler = NULL, Gwen::Event::Handler::Function fn = NULL)
+	{
+		return AddItem(strName, "", pHandler, fn);
+	}
+
+	virtual void AddDivider();
+
+	void OnHoverItem(Gwen::Controls::Base* pControl);
+	void CloseAll();
+	bool IsMenuOpen();
+	void ClearItems();
+
+	virtual void Close();
+
+	virtual bool IsMenuComponent() { return true; }
+	virtual void CloseMenus();
+
+	bool IconMarginDisabled() { return m_bDisableIconMargin; }
+	void SetDisableIconMargin(bool bDisable) { m_bDisableIconMargin = bDisable; }
+
+	virtual bool ShouldClip() { return false; }
+
+protected:
+	virtual bool ShouldHoverOpenMenu() { return true; }
+	virtual void OnAddItem(MenuItem* item);
+
+	bool m_bDisableIconMargin;
+};
+
+class GWEN_EXPORT MenuDivider : public Base
+{
+public:
+	GWEN_CONTROL_INLINE(MenuDivider, Base)
+	{
+		SetHeight(1);
+	}
+
+	void Render(Gwen::Skin::Base* skin);
+};
+}  // namespace Controls
+
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/MenuItem.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/MenuItem.h
new file mode 100644
index 00000000..ae997a83
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/MenuItem.h
@@ -0,0 +1,65 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_MENUITEM_H
+#define GWEN_CONTROLS_MENUITEM_H
+
+#include "Gwen/BaseRender.h"
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Button.h"
+#include "Gwen/Controls/Menu.h"
+#include "Gwen/Controls/Symbol.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class Menu;
+
+class GWEN_EXPORT MenuItem : public Button
+{
+public:
+	GWEN_CONTROL(MenuItem, Button);
+
+	virtual ~MenuItem();
+
+	virtual void Render(Skin::Base* skin);
+	virtual void Layout(Skin::Base* skin);
+
+	virtual void OnPress();
+
+	Menu* GetMenu();
+
+	bool IsMenuOpen();
+	void OpenMenu();
+	void CloseMenu();
+	void ToggleMenu();
+
+	void SetOnStrip(bool b) { m_bOnStrip = b; }
+	bool OnStrip() { return m_bOnStrip; }
+
+	virtual void SetCheckable(bool bCheck) { m_bCheckable = bCheck; }
+	virtual void SetCheck(bool bCheck);
+	virtual bool GetChecked() { return m_bChecked; }
+
+	Gwen::Event::Caller onMenuItemSelected;
+	Gwen::Event::Caller onChecked;
+	Gwen::Event::Caller onUnChecked;
+	Gwen::Event::Caller onCheckChange;
+
+private:
+	Menu* m_Menu;
+	bool m_bOnStrip;
+	bool m_bCheckable;
+	bool m_bChecked;
+
+	Symbol::Arrow* m_SubmenuArrow;
+};
+}  // namespace Controls
+
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/MenuStrip.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/MenuStrip.h
new file mode 100644
index 00000000..765334e6
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/MenuStrip.h
@@ -0,0 +1,36 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_MENUSTRIP_H
+#define GWEN_CONTROLS_MENUSTRIP_H
+
+#include "Gwen/BaseRender.h"
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Menu.h"
+#include "Gwen/Controls/MenuItem.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class GWEN_EXPORT MenuStrip : public Menu
+{
+	GWEN_CONTROL(MenuStrip, Menu);
+
+	virtual void Render(Skin::Base* skin);
+	virtual void RenderUnder(Skin::Base* /*skin*/) {}
+	virtual void Layout(Skin::Base* skin);
+
+protected:
+	virtual void OnAddItem(MenuItem* item);
+	virtual bool ShouldHoverOpenMenu();
+	virtual void Close() {}
+};
+}  // namespace Controls
+
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Modal.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Modal.h
new file mode 100644
index 00000000..48934e8f
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Modal.h
@@ -0,0 +1,36 @@
+#pragma once
+#ifndef GWEN_CONTROLS_MODAL_H
+#define GWEN_CONTROLS_MODAL_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Skin.h"
+
+namespace Gwen
+{
+namespace ControlsInternal
+{
+class Modal : public Controls::Base
+{
+	GWEN_CONTROL_INLINE(Modal, Controls::Base)
+	{
+		SetKeyboardInputEnabled(true);
+		SetMouseInputEnabled(true);
+		SetShouldDrawBackground(true);
+	}
+
+	virtual void Layout(Skin::Base* /*skin*/)
+	{
+		SetBounds(0, 0, GetCanvas()->Width(), GetCanvas()->Height());
+	}
+
+	virtual void Render(Skin::Base* skin)
+	{
+		if (!ShouldDrawBackground()) return;
+
+		skin->DrawModalControl(this);
+	}
+};
+}  // namespace ControlsInternal
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/NumericUpDown.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/NumericUpDown.h
new file mode 100644
index 00000000..40a51552
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/NumericUpDown.h
@@ -0,0 +1,78 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_NUMERICUPDOWN_H
+#define GWEN_CONTROLS_NUMERICUPDOWN_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Button.h"
+#include "Gwen/Controls/TextBox.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class GWEN_EXPORT NumericUpDownButton_Up : public Button
+{
+	GWEN_CONTROL_INLINE(NumericUpDownButton_Up, Button) {}
+
+	virtual void Render(Skin::Base* skin)
+	{
+		skin->DrawNumericUpDownButton(this, m_bDepressed, true);
+	}
+};
+
+class GWEN_EXPORT NumericUpDownButton_Down : public Button
+{
+	GWEN_CONTROL_INLINE(NumericUpDownButton_Down, Button) {}
+
+	virtual void Render(Skin::Base* skin)
+	{
+		skin->DrawNumericUpDownButton(this, m_bDepressed, false);
+	}
+};
+
+class GWEN_EXPORT NumericUpDown : public TextBoxNumeric
+{
+public:
+	GWEN_CONTROL(NumericUpDown, TextBoxNumeric);
+
+	virtual void SetMin(int i);
+	virtual void SetMax(int i);
+	virtual void SetValue(int i);
+
+	Event::Caller onChanged;
+
+private:
+	virtual void OnEnter();
+	virtual void OnChange();
+	virtual void OnTextChanged();
+
+	virtual void OnButtonUp(Base* control);
+	virtual void OnButtonDown(Base* control);
+
+	virtual bool OnKeyUp(bool bDown)
+	{
+		if (bDown) OnButtonUp(NULL);
+		return true;
+	}
+	virtual bool OnKeyDown(bool bDown)
+	{
+		if (bDown) OnButtonDown(NULL);
+		return true;
+	}
+
+	virtual void SyncTextFromNumber();
+	virtual void SyncNumberFromText();
+
+	int m_iNumber;
+	int m_iMax;
+	int m_iMin;
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/PanelListPanel.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/PanelListPanel.h
new file mode 100644
index 00000000..2353d6a9
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/PanelListPanel.h
@@ -0,0 +1,52 @@
+#pragma once
+#ifndef GWEN_CONTROLS_PANELLISTPANEL_H
+#define GWEN_CONTROLS_PANELLISTPANEL_H
+
+#include "Gwen/Gwen.h"
+#include "Gwen/Controls/Base.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class GWEN_EXPORT PanelListPanel : public Controls::Base
+{
+public:
+	GWEN_CONTROL(PanelListPanel, Controls::Base);
+
+	void Render(Gwen::Skin::Base* skin);
+	void Layout(Skin::Base* skin);
+
+	void DoHorizontalLayout();
+	void DoVerticalLayout();
+
+	bool IsVerticalLayout() { return m_bVertical; }
+	bool IsHorizontalLayout() { return !m_bVertical; }
+	void SetVertical()
+	{
+		m_bVertical = true;
+		Invalidate();
+	}
+	void SetHorizontal()
+	{
+		m_bVertical = false;
+		Invalidate();
+	}
+
+	void SetSizeToChildren(bool bShould) { m_bSizeToChildren = bShould; }
+	void SetControlSpacing(int spacing) { m_iControlSpacing = spacing; }
+	void SetLineSpacing(int spacing) { m_iLineSpacing = spacing; }
+	void SetWrapping(bool wrap) { m_bWrapping = wrap; }
+
+	Gwen::Point GetBiggestChildSize();
+
+protected:
+	bool m_bVertical;
+	bool m_bSizeToChildren;
+	int m_iControlSpacing;
+	int m_iLineSpacing;
+	bool m_bWrapping;
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ProgressBar.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ProgressBar.h
new file mode 100644
index 00000000..ff2ab903
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ProgressBar.h
@@ -0,0 +1,42 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_PROGRESSBAR_H
+#define GWEN_CONTROLS_PROGRESSBAR_H
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Label.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Skin.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class GWEN_EXPORT ProgressBar : public Label
+{
+public:
+	GWEN_CONTROL(ProgressBar, Label);
+
+	virtual void Render(Skin::Base* skin);
+
+	virtual void SetVertical() { m_bHorizontal = false; }
+	virtual void SetHorizontal() { m_bHorizontal = true; }
+
+	virtual void SetValue(float val);
+	virtual float GetValue() const { return m_fProgress; }
+
+	virtual void SetAutoLabel(bool b) { m_bAutoLabel = b; }
+
+protected:
+	float m_fProgress;
+
+	bool m_bHorizontal;
+	bool m_bAutoLabel;
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Properties.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Properties.h
new file mode 100644
index 00000000..642dd8f1
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Properties.h
@@ -0,0 +1,69 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_PROPERTIES_H
+#define GWEN_CONTROLS_PROPERTIES_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Label.h"
+#include "Gwen/Controls/Property/BaseProperty.h"
+#include "Gwen/Controls/Property/Text.h"
+#include "Gwen/Controls/SplitterBar.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Skin.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class PropertyRow;
+
+class GWEN_EXPORT Properties : public Base
+{
+public:
+	GWEN_CONTROL(Properties, Base);
+
+	virtual void PostLayout(Gwen::Skin::Base* skin);
+
+	PropertyRow* Add(const UnicodeString& text, const UnicodeString& value = L"");
+	PropertyRow* Add(const String& text, const String& value = "");
+	PropertyRow* Add(const UnicodeString& text, Property::Base* pProp);
+	PropertyRow* Add(const String& text, Property::Base* pProp);
+
+	virtual int GetSplitWidth();
+
+	virtual void Clear();
+
+protected:
+	virtual void OnSplitterMoved(Controls::Base* control);
+
+	Controls::SplitterBar* m_SplitterBar;
+};
+
+class GWEN_EXPORT PropertyRow : public Base
+{
+public:
+	GWEN_CONTROL(PropertyRow, Base);
+
+	virtual Label* GetLabel() { return m_Label; }
+	virtual void SetProperty(Property::Base* prop);
+	virtual Property::Base* GetProperty() { return m_Property; }
+
+	virtual void Layout(Gwen::Skin::Base* skin);
+	virtual void Render(Gwen::Skin::Base* skin);
+
+	Event::Caller onChange;
+
+protected:
+	void OnPropertyValueChanged(Gwen::Controls::Base* control);
+
+	Label* m_Label;
+	Property::Base* m_Property;
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Property/BaseProperty.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Property/BaseProperty.h
new file mode 100644
index 00000000..484cac25
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Property/BaseProperty.h
@@ -0,0 +1,58 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_PROPERTY_BASEPROPERTY_H
+#define GWEN_CONTROLS_PROPERTY_BASEPROPERTY_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Skin.h"
+#include "Gwen/Utility.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+namespace Property
+{
+class GWEN_EXPORT Base : public Gwen::Controls::Base
+{
+public:
+	GWEN_CONTROL_INLINE(Base, Gwen::Controls::Base) {}
+
+	virtual String GetPropertyValueAnsi()
+	{
+		return Gwen::Utility::UnicodeToString(GetPropertyValue());
+	}
+
+	virtual void SetPropertyValue(const String& v, bool bFireChangeEvents = false)
+	{
+		SetPropertyValue(Gwen::Utility::StringToUnicode(v), bFireChangeEvents);
+	}
+
+	virtual UnicodeString GetPropertyValue() = 0;
+
+	virtual void SetPropertyValue(const UnicodeString& v, bool bFireChangeEvents = false) = 0;
+
+	virtual bool IsEditing() = 0;
+
+	virtual void DoChanged()
+	{
+		onChange.Call(this);
+	}
+
+	virtual void OnPropertyValueChanged(Gwen::Controls::Base* /*control*/)
+	{
+		DoChanged();
+	}
+
+	Event::Caller onChange;
+};
+}  // namespace Property
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Property/ColorSelector.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Property/ColorSelector.h
new file mode 100644
index 00000000..c191c212
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Property/ColorSelector.h
@@ -0,0 +1,79 @@
+#pragma once
+#ifndef GWEN_CONTROLS_PROPERTY_COLORSELECTOR_H
+#define GWEN_CONTROLS_PROPERTY_COLORSELECTOR_H
+
+#include "Gwen/Controls/Properties.h"
+#include "Gwen/Controls/WindowControl.h"
+#include "Gwen/Controls/HSVColorPicker.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+namespace Property
+{
+class ColorSelector : public Property::Text
+{
+public:
+	GWEN_CONTROL_INLINE(ColorSelector, Property::Text)
+	{
+		m_Button = new Button(this);
+		m_Button->Dock(Pos::Right);
+		m_Button->SetWidth(20);
+		m_Button->onPress.Add(this, &ThisClass::OnButtonPress);
+	}
+
+	void OnButtonPress(Controls::Base* control)
+	{
+		Gwen::Controls::WindowControl* wind = new Gwen::Controls::WindowControl(GetCanvas());
+		wind->SetTitle(L"Color Selection");
+		wind->SetSize(256, 180);
+		wind->SetPos(GetCanvas()->Width() * 0.5 - 128, GetCanvas()->Height() * 0.5 - 128);
+		wind->SetDeleteOnClose(true);
+		wind->DisableResizing();
+		wind->MakeModal(true);
+
+		Gwen::Controls::HSVColorPicker* picker = new Gwen::Controls::HSVColorPicker(wind);
+		picker->SetName("picker");
+
+		float defaultColor[3];
+		Gwen::Utility::Strings::To::Floats(Gwen::Utility::UnicodeToString(m_TextBox->GetText()), defaultColor, 3);
+
+		picker->SetColor(Gwen::Color(defaultColor[0], defaultColor[1], defaultColor[2], 255), false, true);
+		picker->onColorChanged.Add(this, &ThisClass::ColorChanged);
+	}
+
+	void ColorChanged(Controls::Base* control)
+	{
+		Gwen::Controls::HSVColorPicker* picker = control->DynamicCastHSVColorPicker();
+
+		Gwen::String colorStr;
+		colorStr += Gwen::Utility::ToString((int)picker->GetColor().r) + " ";
+		colorStr += Gwen::Utility::ToString((int)picker->GetColor().g) + " ";
+		colorStr += Gwen::Utility::ToString((int)picker->GetColor().b);
+
+		m_TextBox->SetText(colorStr);
+		DoChanged();
+	}
+
+	virtual UnicodeString GetPropertyValue()
+	{
+		return m_TextBox->GetText();
+	}
+
+	virtual void SetPropertyValue(const UnicodeString& v, bool bFireChangeEvents)
+	{
+		m_TextBox->SetText(v, bFireChangeEvents);
+	}
+
+	virtual bool IsEditing()
+	{
+		return m_TextBox == Gwen::KeyboardFocus;
+	}
+
+	Button* m_Button;
+};
+}  // namespace Property
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Property/Text.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Property/Text.h
new file mode 100644
index 00000000..31ca2c8d
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Property/Text.h
@@ -0,0 +1,51 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_PROPERTY_TEXT_H
+#define GWEN_CONTROLS_PROPERTY_TEXT_H
+
+#include "Gwen/Controls/Property/BaseProperty.h"
+#include "Gwen/Controls/TextBox.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+namespace Property
+{
+class GWEN_EXPORT Text : public Property::Base
+{
+public:
+	GWEN_CONTROL_INLINE(Text, Property::Base)
+	{
+		m_TextBox = new TextBox(this);
+		m_TextBox->Dock(Pos::Fill);
+		m_TextBox->SetShouldDrawBackground(false);
+		m_TextBox->onTextChanged.Add(this, &BaseClass::OnPropertyValueChanged);
+	}
+
+	virtual UnicodeString GetPropertyValue()
+	{
+		return m_TextBox->GetText();
+	}
+
+	virtual void SetPropertyValue(const UnicodeString& v, bool bFireChangeEvents)
+	{
+		m_TextBox->SetText(v, bFireChangeEvents);
+	}
+
+	virtual bool IsEditing()
+	{
+		return m_TextBox->HasFocus();
+	}
+
+	TextBox* m_TextBox;
+};
+}  // namespace Property
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/PropertyTree.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/PropertyTree.h
new file mode 100644
index 00000000..9b71c467
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/PropertyTree.h
@@ -0,0 +1,57 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_PROPERTYTREE_H
+#define GWEN_CONTROLS_PROPERTYTREE_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Label.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Skin.h"
+#include "Gwen/Controls/TreeControl.h"
+#include "Gwen/Controls/Properties.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class PropertyTreeNode : public TreeNode
+{
+public:
+	GWEN_CONTROL_INLINE(PropertyTreeNode, TreeNode)
+	{
+	}
+
+	virtual void Render(Skin::Base* skin)
+	{
+		skin->DrawPropertyTreeNode(this, m_InnerPanel->X(), m_InnerPanel->Y());
+	}
+};
+
+class PropertyTree : public TreeControl
+{
+public:
+	GWEN_CONTROL_INLINE(PropertyTree, TreeControl)
+	{
+	}
+
+	Properties* Add(const UnicodeString& text)
+	{
+		TreeNode* node = new PropertyTreeNode(this);
+		node->SetText(text);
+		node->Dock(Pos::Top);
+
+		Properties* props = new Properties(node);
+		props->Dock(Pos::Top);
+
+		return props;
+	}
+};
+
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/RadioButton.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/RadioButton.h
new file mode 100644
index 00000000..541280f4
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/RadioButton.h
@@ -0,0 +1,79 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_RADIOBUTTON_H
+#define GWEN_CONTROLS_RADIOBUTTON_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Label.h"
+#include "Gwen/Controls/Button.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Skin.h"
+#include "Gwen/Controls/CheckBox.h"
+#include "Gwen/Controls/LabelClickable.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class GWEN_EXPORT RadioButton : public CheckBox
+{
+	GWEN_CONTROL(RadioButton, CheckBox);
+	virtual void Render(Skin::Base* skin);
+
+private:
+	// From CheckBox
+	virtual bool AllowUncheck() { return false; }
+};
+
+class GWEN_EXPORT LabeledRadioButton : public Base
+{
+public:
+	GWEN_CONTROL_INLINE(LabeledRadioButton, Base)
+	{
+		SetSize(200, 19);
+
+		m_RadioButton = new RadioButton(this);
+		m_RadioButton->Dock(Pos::Left);
+		m_RadioButton->SetMargin(Margin(0, 4, 2, 4));
+		m_RadioButton->SetTabable(false);
+		m_RadioButton->SetKeyboardInputEnabled(false);
+
+		m_Label = new LabelClickable(this);
+		m_Label->SetAlignment(Pos::CenterV | Pos::Left);
+		m_Label->SetText("Radio Button");
+		m_Label->Dock(Pos::Fill);
+		m_Label->onPress.Add(m_RadioButton, &CheckBox::ReceiveEventPress);
+		m_Label->SetTabable(false);
+		m_Label->SetKeyboardInputEnabled(false);
+	}
+
+	void RenderFocus(Gwen::Skin::Base* skin)
+	{
+		if (Gwen::KeyboardFocus != this) return;
+		if (!IsTabable()) return;
+
+		skin->DrawKeyboardHighlight(this, GetRenderBounds(), 0);
+	}
+
+	virtual RadioButton* GetRadioButton() { return m_RadioButton; }
+	virtual LabelClickable* GetLabel() { return m_Label; }
+	virtual bool OnKeySpace(bool bDown)
+	{
+		if (bDown) m_RadioButton->SetChecked(!m_RadioButton->IsChecked());
+		return true;
+	}
+
+	virtual void Select() { m_RadioButton->SetChecked(true); }
+
+private:
+	RadioButton* m_RadioButton;
+	LabelClickable* m_Label;
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/RadioButtonController.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/RadioButtonController.h
new file mode 100644
index 00000000..fdfa5a41
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/RadioButtonController.h
@@ -0,0 +1,44 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_RADIOBOTTONCONTROLLER_H
+#define GWEN_CONTROLS_RADIOBOTTONCONTROLLER_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Label.h"
+#include "Gwen/Controls/RadioButton.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class GWEN_EXPORT RadioButtonController : public Base
+{
+public:
+	GWEN_CONTROL(RadioButtonController, Base);
+
+	virtual void Render(Skin::Base* /*skin*/){};
+	virtual void OnRadioClicked(Base* pFromPanel);
+
+	virtual void OnChange();
+
+	virtual LabeledRadioButton* AddOption(const Gwen::String& strText, const Gwen::String& strOptionName = "");
+	virtual LabeledRadioButton* AddOption(const Gwen::UnicodeString& strText, const Gwen::String& strOptionName = "");
+
+	virtual LabeledRadioButton* GetSelected() { return m_Selected; }
+
+	virtual String GetSelectedName() { return m_Selected->GetName(); }
+	virtual UnicodeString GetSelectedLabel() { return m_Selected->GetLabel()->GetText(); }
+
+	Event::Caller onSelectionChange;
+
+private:
+	LabeledRadioButton* m_Selected;
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ResizableControl.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ResizableControl.h
new file mode 100644
index 00000000..fac2de8a
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ResizableControl.h
@@ -0,0 +1,51 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_RESIZABLECONTROL_H
+#define GWEN_CONTROLS_RESIZABLECONTROL_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Label.h"
+#include "Gwen/Controls/Button.h"
+#include "Gwen/Controls/Dragger.h"
+#include "Gwen/Controls/Label.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Skin.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class GWEN_EXPORT ResizableControl : public Base
+{
+public:
+	GWEN_CONTROL(ResizableControl, Base);
+
+	virtual void SetClampMovement(bool shouldClamp) { m_bClampMovement = shouldClamp; }
+	virtual bool GetClampMovement() { return m_bClampMovement; }
+
+	virtual void SetMinimumSize(const Gwen::Point& minSize) { m_MinimumSize = minSize; }
+	virtual Gwen::Point GetMinimumSize() { return m_MinimumSize; }
+
+	virtual void DisableResizing();
+
+	virtual bool SetBounds(int x, int y, int w, int h);
+
+	virtual void OnResized(){};
+
+	Event::Caller onResize;
+
+protected:
+	void OnResizedInternal(Controls::Base* pControl);
+
+	Gwen::Point m_MinimumSize;
+	bool m_bClampMovement;
+	bool m_bResizable;
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Resizer.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Resizer.h
new file mode 100644
index 00000000..c2c49c5e
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Resizer.h
@@ -0,0 +1,35 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_RESIZER_H
+#define GWEN_CONTROLS_RESIZER_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Skin.h"
+#include "Gwen/Controls/Dragger.h"
+
+namespace Gwen
+{
+namespace ControlsInternal
+{
+class GWEN_EXPORT Resizer : public Dragger
+{
+public:
+	GWEN_CONTROL(Resizer, Dragger);
+
+	virtual void OnMouseMoved(int x, int y, int deltaX, int deltaY);
+	virtual void SetResizeDir(int dir);
+
+	Event::Caller onResize;
+
+protected:
+	int m_iResizeDir;
+};
+}  // namespace ControlsInternal
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/RichLabel.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/RichLabel.h
new file mode 100644
index 00000000..1d9b857b
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/RichLabel.h
@@ -0,0 +1,59 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_RICHLABEL_H
+#define GWEN_CONTROLS_RICHLABEL_H
+
+#include "Gwen/BaseRender.h"
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Text.h"
+#include "Gwen/TextObject.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class GWEN_EXPORT RichLabel : public Controls::Base
+{
+public:
+	GWEN_CONTROL(RichLabel, Gwen::Controls::Base);
+
+	void AddLineBreak();
+	void AddText(const Gwen::TextObject& text, Gwen::Color color, Gwen::Font* font = NULL);
+
+	virtual bool SizeToChildren(bool w = true, bool h = true);
+
+protected:
+	struct DividedText
+	{
+		typedef std::list<DividedText> List;
+		DividedText()
+		{
+			type = 0;
+			font = NULL;
+		}
+
+		unsigned char type;
+		Gwen::UnicodeString text;
+		Gwen::Color color;
+		Gwen::Font* font;
+	};
+
+	void Layout(Gwen::Skin::Base* skin);
+	void SplitLabel(const Gwen::UnicodeString& text, Gwen::Font* pFont, const DividedText& txt, int& x, int& y, int& lineheight);
+	void CreateNewline(int& x, int& y, int& lineheight);
+	void CreateLabel(const Gwen::UnicodeString& text, const DividedText& txt, int& x, int& y, int& lineheight, bool NoSplit);
+	void Rebuild();
+
+	void OnBoundsChanged(Gwen::Rect oldBounds);
+
+	DividedText::List m_TextBlocks;
+	bool m_bNeedsRebuild;
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ScrollBar.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ScrollBar.h
new file mode 100644
index 00000000..dbf5a5ea
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ScrollBar.h
@@ -0,0 +1,83 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_SCROLLBAR_H
+#define GWEN_CONTROLS_SCROLLBAR_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/ScrollBarBar.h"
+#include "Gwen/Controls/ScrollBarButton.h"
+#include "Gwen/Gwen.h"
+
+#define SCROLL_BUTTON_UP 0
+#define SCROLL_BUTTON_LEFT 0
+#define SCROLL_BUTTON_DOWN 1
+#define SCROLL_BUTTON_RIGHT 1
+#define NUDGE_DIST 10
+
+namespace Gwen
+{
+namespace Controls
+{
+class GWEN_EXPORT BaseScrollBar : public Base
+{
+public:
+	GWEN_CONTROL(BaseScrollBar, Base);
+
+	virtual void Render(Skin::Base* skin);
+
+	virtual void SetBarSize(int size) = 0;
+	virtual int GetBarSize() = 0;
+	virtual int GetBarPos() = 0;
+
+	virtual void OnBarMoved(Controls::Base* control);
+	virtual void OnMouseClickLeft(int /*x*/, int /*y*/, bool /*bDown*/) {}
+
+	virtual void ScrollToLeft() {}
+	virtual void ScrollToRight() {}
+	virtual void ScrollToTop() {}
+	virtual void ScrollToBottom() {}
+
+	virtual float GetNudgeAmount() { return m_fNudgeAmount / m_fContentSize; }
+	virtual void SetNudgeAmount(float nudge) { m_fNudgeAmount = nudge; }
+
+	virtual void BarMovedNotification();
+
+	virtual float CalculateScrolledAmount() { return 0; }
+	virtual int CalculateBarSize() { return 0; }
+	virtual bool SetScrolledAmount(float amount, bool forceUpdate);
+
+	virtual void SetContentSize(float size);
+	virtual void SetViewableContentSize(float size);
+
+	virtual int GetButtonSize() { return 0; }
+	virtual float GetScrolledAmount() { return m_fScrolledAmount; }
+
+	Gwen::Event::Caller onBarMoved;
+
+	float getContentSize()
+	{
+		return m_fContentSize;
+	}
+	float getViewableContentSize() const
+	{
+		return m_fViewableContentSize;
+	}
+
+protected:
+	ControlsInternal::ScrollBarButton* m_ScrollButton[2];
+	ControlsInternal::ScrollBarBar* m_Bar;
+
+	bool m_bDepressed;
+	float m_fScrolledAmount;
+	float m_fContentSize;
+	float m_fViewableContentSize;
+	float m_fNudgeAmount;
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ScrollBarBar.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ScrollBarBar.h
new file mode 100644
index 00000000..4b517fbe
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ScrollBarBar.h
@@ -0,0 +1,43 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_SCROLLBARBAR_H
+#define GWEN_CONTROLS_SCROLLBARBAR_H
+
+#include "Gwen/Controls/Dragger.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Skin.h"
+
+namespace Gwen
+{
+namespace ControlsInternal
+{
+class GWEN_EXPORT ScrollBarBar : public ControlsInternal::Dragger
+{
+public:
+	GWEN_CONTROL(ScrollBarBar, ControlsInternal::Dragger);
+
+	virtual void Render(Skin::Base* skin);
+	virtual void Layout(Skin::Base* skin);
+
+	virtual void OnMouseMoved(int x, int y, int deltaX, int deltaY);
+	virtual void OnMouseClickLeft(int x, int y, bool bDown);
+
+	virtual void MoveTo(int x, int y);
+
+	virtual void SetHorizontal() { m_bHorizontal = true; }
+	virtual void SetVertical() { m_bHorizontal = false; }
+	virtual bool IsVertical() { return !m_bHorizontal; }
+	virtual bool IsHorizontal() { return m_bHorizontal; }
+	virtual bool IsDepressed() { return m_bDepressed; }
+
+protected:
+	bool m_bHorizontal;
+};
+}  // namespace ControlsInternal
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ScrollBarButton.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ScrollBarButton.h
new file mode 100644
index 00000000..46293d16
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ScrollBarButton.h
@@ -0,0 +1,34 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_SCROLLBARBOTTON_H
+#define GWEN_CONTROLS_SCROLLBARBOTTON_H
+
+#include "Gwen/Controls/Button.h"
+
+namespace Gwen
+{
+namespace ControlsInternal
+{
+class GWEN_EXPORT ScrollBarButton : public Controls::Button
+{
+public:
+	GWEN_CONTROL(ScrollBarButton, Controls::Button);
+
+	void Render(Skin::Base* skin);
+
+	void SetDirectionUp();
+	void SetDirectionDown();
+	void SetDirectionLeft();
+	void SetDirectionRight();
+
+protected:
+	int m_iDirection;
+};
+}  // namespace ControlsInternal
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ScrollControl.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ScrollControl.h
new file mode 100644
index 00000000..c906b9d4
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ScrollControl.h
@@ -0,0 +1,67 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_SCROLLCONTROL_H
+#define GWEN_CONTROLS_SCROLLCONTROL_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Button.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Skin.h"
+#include "Gwen/Controls/ScrollBar.h"
+#include "Gwen/Controls/VerticalScrollBar.h"
+#include "Gwen/Controls/HorizontalScrollBar.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class GWEN_EXPORT ScrollControl : public Base
+{
+public:
+	GWEN_CONTROL(ScrollControl, Base);
+
+	virtual void Layout(Skin::Base* skin);
+	virtual void Render(Skin::Base* skin);
+
+	virtual void SetScroll(bool h, bool v);
+	virtual void SetAutoHideBars(bool should) { m_bAutoHideBars = should; }
+	virtual bool CanScrollH() { return m_bCanScrollH; }
+	virtual bool CanScrollV() { return m_bCanScrollV; }
+	virtual void OnChildBoundsChanged(Gwen::Rect oldChildBounds, Base* pChild);
+	virtual void UpdateScrollBars();
+
+	virtual void SetVScrollRequired(bool req);
+	virtual void SetHScrollRequired(bool req);
+
+	virtual void SetInnerSize(int w, int h);
+
+	virtual void VBarMoved(Controls::Base* control);
+	virtual void HBarMoved(Controls::Base* control);
+
+	virtual bool OnMouseWheeled(int iDelta);
+
+	virtual void ScrollToBottom();
+	virtual void ScrollToTop();
+	virtual void ScrollToLeft();
+	virtual void ScrollToRight();
+
+	virtual void Clear();
+
+protected:
+	bool m_bCanScrollH;
+	bool m_bCanScrollV;
+
+	bool m_bAutoHideBars;
+
+public:
+	Controls::BaseScrollBar* m_VerticalScrollBar;
+	Controls::BaseScrollBar* m_HorizontalScrollBar;
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Slider.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Slider.h
new file mode 100644
index 00000000..9e920f8b
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Slider.h
@@ -0,0 +1,100 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_SLIDER_H
+#define GWEN_CONTROLS_SLIDER_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Button.h"
+#include "Gwen/Controls/Dragger.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Skin.h"
+
+namespace Gwen
+{
+namespace ControlsInternal
+{
+class GWEN_EXPORT SliderBar : public ControlsInternal::Dragger
+{
+	GWEN_CONTROL(SliderBar, ControlsInternal::Dragger);
+
+	virtual void Render(Skin::Base* skin);
+};
+}  // namespace ControlsInternal
+
+namespace Controls
+{
+class GWEN_EXPORT Slider : public Base
+{
+	GWEN_CONTROL(Slider, Base);
+
+	virtual void Render(Skin::Base* skin) = 0;
+	virtual void Layout(Skin::Base* skin);
+
+	virtual void SetClampToNotches(bool bClamp) { m_bClampToNotches = bClamp; }
+
+	virtual void SetNotchCount(int num) { m_iNumNotches = num; }
+	virtual int GetNotchCount() { return m_iNumNotches; }
+
+	virtual void SetRange(float fMin, float fMax);
+	virtual float GetRangeMin() const
+	{
+		return m_fMin;
+	}
+	virtual float GetRangeMax() const
+	{
+		return m_fMax;
+	}
+	virtual float GetValue();
+	virtual void SetValue(float val, bool forceUpdate = true);
+
+	virtual float CalculateValue();
+	virtual void OnMoved(Controls::Base* control);
+
+	virtual void OnMouseClickLeft(int /*x*/, int /*y*/, bool /*bDown*/){};
+
+	virtual bool OnKeyRight(bool bDown)
+	{
+		if (bDown) SetValue(GetValue() + 1, true);
+		return true;
+	}
+	virtual bool OnKeyLeft(bool bDown)
+	{
+		if (bDown) SetValue(GetValue() - 1, true);
+		return true;
+	}
+	virtual bool OnKeyUp(bool bDown)
+	{
+		if (bDown) SetValue(GetValue() + 1, true);
+		return true;
+	}
+	virtual bool OnKeyDown(bool bDown)
+	{
+		if (bDown) SetValue(GetValue() - 1, true);
+		return true;
+	}
+
+	virtual void RenderFocus(Gwen::Skin::Base* skin);
+
+	Gwen::Event::Caller onValueChanged;
+
+protected:
+	virtual void SetValueInternal(float fVal);
+	virtual void UpdateBarFromValue() = 0;
+
+	ControlsInternal::SliderBar* m_SliderBar;
+	bool m_bClampToNotches;
+	int m_iNumNotches;
+	float m_fValue;
+
+	float m_fMin;
+	float m_fMax;
+};
+}  // namespace Controls
+
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/SplitterBar.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/SplitterBar.h
new file mode 100644
index 00000000..8f0f38e5
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/SplitterBar.h
@@ -0,0 +1,23 @@
+#pragma once
+#ifndef GWEN_CONTROLS_SPLITTERBAR_H
+#define GWEN_CONTROLS_SPLITTERBAR_H
+
+#include "Gwen/Gwen.h"
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Dragger.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class GWEN_EXPORT SplitterBar : public ControlsInternal::Dragger
+{
+public:
+	GWEN_CONTROL(SplitterBar, ControlsInternal::Dragger);
+
+	void Render(Skin::Base* skin);
+	void Layout(Skin::Base* skin);
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/StatusBar.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/StatusBar.h
new file mode 100644
index 00000000..9f469e66
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/StatusBar.h
@@ -0,0 +1,35 @@
+#pragma once
+#ifndef GWEN_CONTROLS_STATUSBAR_H
+#define GWEN_CONTROLS_STATUSBAR_H
+
+#include "Gwen/Gwen.h"
+#include "Gwen/Controls/Base.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class StatusBar : public Controls::Base
+{
+public:
+	GWEN_CONTROL_INLINE(StatusBar, Controls::Base)
+	{
+		SetBounds(0, 0, 200, 22);
+		Dock(Pos::Bottom);
+		SetPadding(Padding(2, 2, 2, 2));
+	}
+
+	virtual void AddControl(Controls::Base* pCtrl, bool bRight)
+	{
+		pCtrl->SetParent(this);
+		pCtrl->Dock(bRight ? Pos::Right : Pos::Left);
+	}
+
+	virtual void Render(Skin::Base* skin)
+	{
+		skin->DrawStatusBar(this);
+	}
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Symbol.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Symbol.h
new file mode 100644
index 00000000..df4a1de2
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Symbol.h
@@ -0,0 +1,48 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_SYMBOL_H
+#define GWEN_CONTROLS_SYMBOL_H
+
+#include "Gwen/BaseRender.h"
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Skin.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+namespace Symbol
+{
+class GWEN_EXPORT Base : public Controls::Base
+{
+public:
+	GWEN_CONTROL_INLINE(Base, Controls::Base)
+	{
+		SetMouseInputEnabled(false);
+	}
+};
+
+class GWEN_EXPORT Arrow : public Base
+{
+public:
+	Arrow(Gwen::Controls::Base* pnl) : Base(pnl)
+	{
+	}
+
+	virtual void Render(Gwen::Skin::Base* pSkin)
+	{
+		Gwen::Rect r(Width() / 2 - 2, Height() / 2 - 2, 5, 5);
+		pSkin->DrawArrowRight(r);
+	}
+};
+
+}  // namespace Symbol
+}  // namespace Controls
+
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/TabButton.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/TabButton.h
new file mode 100644
index 00000000..5a7ccd09
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/TabButton.h
@@ -0,0 +1,50 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_TABBUTTON_H
+#define GWEN_CONTROLS_TABBUTTON_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Button.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class TabControl;
+
+class GWEN_EXPORT TabButton : public Button
+{
+public:
+	GWEN_CONTROL(TabButton, Button);
+	virtual void Render(Skin::Base* skin);
+
+	void SetPage(Base* page) { m_Page = page; }
+	Base* GetPage() { return m_Page; }
+
+	void SetTabControl(TabControl* ctrl);
+	TabControl* GetTabControl() { return m_Control; }
+
+	bool IsActive() { return m_Page && m_Page->Visible(); }
+
+	virtual bool DragAndDrop_ShouldStartDrag();
+	virtual void DragAndDrop_StartDragging(Gwen::DragAndDrop::Package* /*pPackage*/, int /*x*/, int /*y*/) { SetHidden(true); }
+	virtual void DragAndDrop_EndDragging(bool /*bSuccess*/, int /*x*/, int /*y*/) { SetHidden(false); }
+
+	virtual bool OnKeyLeft(bool bDown);
+	virtual bool OnKeyRight(bool bDown);
+	virtual bool OnKeyUp(bool bDown);
+	virtual bool OnKeyDown(bool bDown);
+
+private:
+	Base* m_Page;
+	TabControl* m_Control;
+};
+
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/TabControl.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/TabControl.h
new file mode 100644
index 00000000..24b1bf32
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/TabControl.h
@@ -0,0 +1,64 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_TABCONTROL_H
+#define GWEN_CONTROLS_TABCONTROL_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Button.h"
+#include "Gwen/Controls/TabButton.h"
+#include "Gwen/Controls/TabStrip.h"
+#include "Gwen/Controls/TabTitleBar.h"
+
+namespace Gwen
+{
+namespace ControlsInternal
+{
+class ScrollBarButton;
+}
+
+namespace Controls
+{
+class GWEN_EXPORT TabControl : public Base
+{
+	GWEN_CONTROL(TabControl, Base);
+
+	virtual TabButton* AddPage(const UnicodeString& strText, Controls::Base* pPage = NULL);
+	virtual void AddPage(TabButton* pButton);
+
+	virtual void OnTabPressed(Controls::Base* control);
+	virtual void OnLoseTab(TabButton* pButton);
+
+	virtual int TabCount(void);
+	virtual TabButton* GetCurrentButton() { return m_pCurrentButton; }
+	virtual TabStrip* GetTabStrip() { return m_TabStrip; }
+
+	virtual void SetTabStripPosition(int iDock);
+
+	virtual bool DoesAllowDrag();
+
+	virtual void SetAllowReorder(bool b) { GetTabStrip()->SetAllowReorder(b); }
+
+	Gwen::Event::Caller onLoseTab;
+	Gwen::Event::Caller onAddTab;
+
+private:
+	virtual void PostLayout(Skin::Base* skin);
+	void HandleOverflow();
+
+	void ScrollPressLeft(Base* pFrom);
+	void ScrollPressRight(Base* pFrom);
+
+	TabStrip* m_TabStrip;
+	TabButton* m_pCurrentButton;
+
+	ControlsInternal::ScrollBarButton* m_pScroll[2];
+	int m_iScrollOffset;
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/TabStrip.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/TabStrip.h
new file mode 100644
index 00000000..ae237377
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/TabStrip.h
@@ -0,0 +1,46 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_TABSTRIP_H
+#define GWEN_CONTROLS_TABSTRIP_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Button.h"
+#include "Gwen/Controls/TabButton.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+//class TabControl;
+
+class GWEN_EXPORT TabStrip : public Base
+{
+public:
+	GWEN_CONTROL(TabStrip, Base);
+
+	virtual void Layout(Skin::Base* skin);
+
+	virtual bool DragAndDrop_HandleDrop(Gwen::DragAndDrop::Package* pPackage, int x, int y);
+	virtual bool DragAndDrop_CanAcceptPackage(Gwen::DragAndDrop::Package* pPackage);
+
+	virtual void DragAndDrop_HoverEnter(Gwen::DragAndDrop::Package* pPackage, int x, int y);
+	virtual void DragAndDrop_HoverLeave(Gwen::DragAndDrop::Package* pPackage);
+	virtual void DragAndDrop_Hover(Gwen::DragAndDrop::Package* pPackage, int x, int y);
+
+	virtual void SetTabPosition(int iPos);
+
+	virtual void SetAllowReorder(bool b) { m_bAllowReorder = b; }
+	virtual bool AllowsTabReorder() { return m_bAllowReorder; }
+
+private:
+	Base* m_TabDragControl;
+	bool m_bAllowReorder;
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/TabTitleBar.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/TabTitleBar.h
new file mode 100644
index 00000000..9ead2909
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/TabTitleBar.h
@@ -0,0 +1,54 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_TABTITLEBAR_H
+#define GWEN_CONTROLS_TABTITLEBAR_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Label.h"
+#include "Gwen/Controls/TabButton.h"
+#include "Gwen/DragAndDrop.h"
+#include "Gwen/Skin.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class GWEN_EXPORT TabTitleBar : public Label
+{
+public:
+	GWEN_CONTROL_INLINE(TabTitleBar, Label)
+	{
+		SetMouseInputEnabled(true);
+		SetTextPadding(Gwen::Padding(5, 2, 5, 2));
+		SetPadding(Gwen::Padding(1, 2, 1, 2));
+
+		DragAndDrop_SetPackage(true, "TabWindowMove");
+	}
+
+	void Render(Skin::Base* skin)
+	{
+		skin->DrawTabTitleBar(this);
+	}
+
+	void DragAndDrop_StartDragging(Gwen::DragAndDrop::Package* pPackage, int x, int y)
+	{
+		DragAndDrop::SourceControl = GetParent();
+		DragAndDrop::SourceControl->DragAndDrop_StartDragging(pPackage, x, y);
+	}
+
+	void UpdateFromTab(TabButton* pButton)
+	{
+		SetText(pButton->GetText());
+		SizeToContents();
+	}
+
+private:
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Text.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Text.h
new file mode 100644
index 00000000..5f228256
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/Text.h
@@ -0,0 +1,57 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_TEXT_H
+#define GWEN_CONTROLS_TEXT_H
+
+#include "Gwen/BaseRender.h"
+#include "Gwen/Controls/Base.h"
+
+namespace Gwen
+{
+namespace ControlsInternal
+{
+class GWEN_EXPORT Text : public Controls::Base
+{
+public:
+	GWEN_CONTROL(Text, Controls::Base);
+
+	virtual ~Text();
+	Gwen::Font* GetFont();
+
+	void SetString(const UnicodeString& str);
+	void SetString(const String& str);
+
+	void Render(Skin::Base* skin);
+	void Layout(Skin::Base* skin);
+
+	void RefreshSize();
+
+	void SetFont(Gwen::Font* pFont) { m_Font = pFont; }
+
+	const UnicodeString& GetText() const { return m_String; }
+
+	Gwen::Point GetCharacterPosition(int iChar);
+	int GetClosestCharacter(Gwen::Point p);
+
+	int Length() const { return (int)m_String.size(); }
+
+	virtual void SetTextColor(const Gwen::Color& col) { m_Color = col; }
+
+	virtual void OnScaleChanged();
+
+	inline const Gwen::Color& TextColor() const { return m_Color; }
+
+private:
+	Gwen::UnicodeString m_String;
+	Gwen::Font* m_Font;
+	Gwen::Color m_Color;
+};
+}  // namespace ControlsInternal
+
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/TextBox.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/TextBox.h
new file mode 100644
index 00000000..b8292716
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/TextBox.h
@@ -0,0 +1,104 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_TEXTBOX_H
+#define GWEN_CONTROLS_TEXTOBX_H
+
+#include "Gwen/BaseRender.h"
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Label.h"
+#include "Gwen/Controls/ScrollControl.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class GWEN_EXPORT TextBox : public Label
+{
+	GWEN_CONTROL(TextBox, Label);
+
+	virtual void Render(Skin::Base* skin);
+	virtual void RenderFocus(Gwen::Skin::Base* /*skin*/){};
+	virtual void Layout(Skin::Base* skin);
+
+	virtual bool OnChar(Gwen::UnicodeChar c);
+
+	virtual void InsertText(const Gwen::UnicodeString& str);
+	virtual void DeleteText(int iStartPos, int iLength);
+
+	virtual void RefreshCursorBounds();
+
+	virtual bool OnKeyReturn(bool bDown);
+	virtual bool OnKeyBackspace(bool bDown);
+	virtual bool OnKeyDelete(bool bDown);
+	virtual bool OnKeyRight(bool bDown);
+	virtual bool OnKeyLeft(bool bDown);
+	virtual bool OnKeyHome(bool bDown);
+	virtual bool OnKeyEnd(bool bDown);
+
+	virtual bool AccelOnlyFocus() { return true; }
+
+	virtual void OnPaste(Gwen::Controls::Base* pCtrl);
+	virtual void OnCopy(Gwen::Controls::Base* pCtrl);
+	virtual void OnCut(Gwen::Controls::Base* pCtrl);
+	virtual void OnSelectAll(Gwen::Controls::Base* pCtrl);
+
+	virtual void OnMouseDoubleClickLeft(int x, int y);
+
+	virtual void EraseSelection();
+	virtual bool HasSelection();
+	virtual UnicodeString GetSelection();
+
+	virtual void SetCursorPos(int i);
+	virtual void SetCursorEnd(int i);
+
+	virtual void OnMouseClickLeft(int x, int y, bool bDown);
+	virtual void OnMouseMoved(int x, int y, int deltaX, int deltaY);
+
+	virtual void SetSelectAllOnFocus(bool b)
+	{
+		m_bSelectAll = b;
+		if (b) OnSelectAll(this);
+	}
+
+	virtual void MakeCaratVisible();
+
+	virtual void OnEnter();
+
+	virtual bool NeedsInputChars() { return true; }
+
+	Event::Caller onTextChanged;
+	Event::Caller onReturnPressed;
+
+protected:
+	virtual void OnTextChanged();
+	virtual bool IsTextAllowed(const Gwen::UnicodeString& /*str*/, int /*iPos*/) { return true; }
+
+	bool m_bSelectAll;
+
+	int m_iCursorPos;
+	int m_iCursorEnd;
+
+	Gwen::Rect m_rectSelectionBounds;
+	Gwen::Rect m_rectCaretBounds;
+
+	float m_fLastInputTime;
+};
+
+class GWEN_EXPORT TextBoxNumeric : public TextBox
+{
+public:
+	GWEN_CONTROL(TextBoxNumeric, TextBox);
+
+	virtual float GetFloatFromText();
+
+private:
+	virtual bool IsTextAllowed(const Gwen::UnicodeString& str, int iPos);
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ToolBar.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ToolBar.h
new file mode 100644
index 00000000..bfeb51a2
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/ToolBar.h
@@ -0,0 +1,48 @@
+/*
+	GWEN
+	Copyright (c) 2011 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_TOOLBAR_H
+#define GWEN_CONTROLS_TOOLBAR_H
+
+#include "Gwen/BaseRender.h"
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Skin.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+/*
+
+		TODO!
+
+		*/
+
+class ToolBarStrip : public Base
+{
+	GWEN_CONTROL_INLINE(ToolBarStrip, Base)
+	{
+		SetPadding(Padding(2, 2, 2, 2));
+	}
+
+	virtual void Render(Skin::Base* skin)
+	{
+		skin->DrawMenuStrip(this);
+	}
+
+	virtual void RenderUnder(Skin::Base* skin)
+	{
+	}
+
+	virtual void Layout(Skin::Base* skin)
+	{
+	}
+};
+}  // namespace Controls
+
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/TreeControl.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/TreeControl.h
new file mode 100644
index 00000000..c0de9a3d
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/TreeControl.h
@@ -0,0 +1,55 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_TREECONTROL_H
+#define GWEN_CONTROLS_TREECONTROL_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/TreeNode.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class GWEN_EXPORT TreeControl : public TreeNode
+{
+public:
+	GWEN_CONTROL(TreeControl, TreeNode);
+
+	virtual void Render(Skin::Base* skin);
+
+	virtual void OnChildBoundsChanged(Gwen::Rect oldChildBounds, Base* pChild);
+
+	ScrollControl* Scroller() { return m_ScrollControl; }
+
+	virtual void Clear();
+
+	virtual void Layout(Skin::Base* skin);
+	virtual void PostLayout(Skin::Base* skin);
+
+	virtual void AllowMultiSelect(bool b) { m_bAllowMultipleSelection = b; }
+
+	virtual void OnNodeAdded(TreeNode* pNode);
+
+	virtual bool OnKeyUp(bool bDown);
+	virtual bool OnKeyDown(bool bDown);
+	virtual bool OnKeyRight(bool bDown);
+	virtual bool OnKeyLeft(bool bDown);
+
+	virtual void iterate(int action, int* curIndex, int* resultIndex);
+
+	virtual void ForceUpdateScrollBars();
+
+private:
+	void OnNodeSelection(Controls::Base* control);
+
+	ScrollControl* m_ScrollControl;
+	bool m_bAllowMultipleSelection;
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/TreeNode.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/TreeNode.h
new file mode 100644
index 00000000..c86812e0
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/TreeNode.h
@@ -0,0 +1,98 @@
+/*
+	GWEN
+	Copyright (c) 2011 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_TREENODE_H
+#define GWEN_CONTROLS_TREENODE_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Button.h"
+#include "Gwen/Controls/ScrollControl.h"
+
+enum
+{
+	ITERATE_ACTION_OPEN = 1,
+	ITERATE_ACTION_CLOSE,
+	ITERATE_ACTION_FIND_SELECTED_INDEX,
+	ITERATE_ACTION_DESELECT_INDEX,
+	ITERATE_ACTION_SELECT,
+};
+
+namespace Gwen
+{
+namespace Controls
+{
+class TreeControl;
+
+class GWEN_EXPORT TreeNode : public Base
+{
+public:
+	GWEN_CONTROL(TreeNode, Base);
+
+	virtual TreeNode* AddNode(const UnicodeString& strLabel);
+	virtual TreeNode* AddNode(const String& strLabel);
+
+	virtual void SetText(const UnicodeString& text);
+	virtual void SetText(const String& text);
+	UnicodeString GetText() const;
+
+	virtual void Open();
+	virtual void Close();
+
+	virtual void ExpandAll();
+
+	virtual Button* GetButton();
+
+	virtual void Render(Skin::Base* skin);
+	virtual void Layout(Skin::Base* skin);
+	virtual void PostLayout(Skin::Base* skin);
+
+	virtual void SetRoot(bool b) { m_bRoot = b; }
+	virtual void SetTreeControl(TreeControl* pCtrl) { m_TreeControl = pCtrl; }
+
+	virtual void SetSelectable(bool b) { m_bSelectable = b; }
+	virtual bool IsSelected() { return m_bSelected; }
+	virtual void SetSelected(bool b);
+
+	virtual void DeselectAll();
+
+	virtual void iterate(int action, int* curIndex, int* resultIndex);
+	virtual bool OnKeyReturn(bool bDown)
+	{
+		static bool prevDown = false;
+		if (!prevDown && bDown)
+		{
+			onReturnKeyDown.Call(this);
+		}
+		prevDown = bDown;
+		return Base::OnKeyReturn(bDown);
+	}
+
+	Event::Caller onReturnKeyDown;
+
+	Event::Caller onNamePress;
+	Event::Caller onSelectChange;
+	Event::Caller onSelect;
+	Event::Caller onUnselect;
+
+protected:
+	void OnToggleButtonPress(Base* control);
+	void OnDoubleClickName(Base* control);
+	void OnClickName(Base* control);
+
+	TreeControl* m_TreeControl;
+	Button* m_ToggleButton;
+	Button* m_Title;
+
+	bool m_bRoot;
+	bool m_bSelected;
+	bool m_bSelectable;
+	int m_bUpdateScrollBar;
+};
+
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/VerticalScrollBar.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/VerticalScrollBar.h
new file mode 100644
index 00000000..2e17f7a8
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/VerticalScrollBar.h
@@ -0,0 +1,44 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_VERTICALSCROLLBAR_H
+#define GWEN_CONTROLS_VERTICALSCROLLBAR_H
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/ScrollBar.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Skin.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class GWEN_EXPORT VerticalScrollBar : public BaseScrollBar
+{
+	GWEN_CONTROL(VerticalScrollBar, BaseScrollBar);
+
+	virtual void Layout(Skin::Base* skin);
+
+	virtual void OnMouseClickLeft(int x, int y, bool bDown);
+	virtual void OnBarMoved(Controls::Base* control);
+
+	virtual int GetBarSize() { return m_Bar->Height(); }
+	virtual int GetBarPos() { return m_Bar->Y() - Width(); }
+	virtual void SetBarSize(int size) { m_Bar->SetHeight(size); }
+	virtual int GetButtonSize() { return Width(); }
+
+	virtual void ScrollToTop();
+	virtual void ScrollToBottom();
+	virtual void NudgeUp(Base* control);
+	virtual void NudgeDown(Base* control);
+	virtual float GetNudgeAmount();
+
+	virtual float CalculateScrolledAmount();
+	virtual bool SetScrolledAmount(float amount, bool forceUpdate);
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/VerticalSlider.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/VerticalSlider.h
new file mode 100644
index 00000000..7b19cd2b
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/VerticalSlider.h
@@ -0,0 +1,35 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_VERTICALSLIDER_H
+#define GWEN_CONTROLS_VERTICALSLIDER_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Button.h"
+#include "Gwen/Controls/Dragger.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Skin.h"
+#include "Gwen/Controls/Slider.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class GWEN_EXPORT VerticalSlider : public Slider
+{
+	GWEN_CONTROL(VerticalSlider, Slider);
+
+	virtual void Layout(Skin::Base* skin);
+	virtual void Render(Skin::Base* skin);
+
+	virtual float CalculateValue();
+	virtual void UpdateBarFromValue();
+	virtual void OnMouseClickLeft(int x, int y, bool bDown);
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/WindowControl.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/WindowControl.h
new file mode 100644
index 00000000..0af35d14
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Controls/WindowControl.h
@@ -0,0 +1,60 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_CONTROLS_WINDOWCONTROL_H
+#define GWEN_CONTROLS_WINDOWCONTROL_H
+
+#include "Gwen/Gwen.h"
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Label.h"
+#include "Gwen/Controls/Button.h"
+#include "Gwen/Controls/Dragger.h"
+#include "Gwen/Controls/Label.h"
+#include "Gwen/Controls/ResizableControl.h"
+#include "Gwen/Controls/Modal.h"
+#include "Gwen/Skin.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class GWEN_EXPORT WindowControl : public ResizableControl
+{
+public:
+	GWEN_CONTROL(WindowControl, ResizableControl);
+
+	virtual ~WindowControl();
+	virtual void Render(Skin::Base* skin);
+	virtual void RenderUnder(Skin::Base* skin);
+
+	virtual void SetTitle(Gwen::UnicodeString title);
+	virtual void SetTitle(Gwen::String title) { SetTitle(Gwen::Utility::StringToUnicode(title)); }
+	virtual void SetClosable(bool closeable);
+
+	virtual void Touch();
+	bool IsOnTop();
+
+	virtual void SetHidden(bool hidden);
+
+	void CloseButtonPressed(Gwen::Controls::Base* pFromPanel);
+	void RenderFocus(Gwen::Skin::Base* skin);
+	void SetDeleteOnClose(bool b) { m_bDeleteOnClose = b; }
+	void MakeModal(bool invisible = false);
+
+protected:
+	ControlsInternal::Dragger* m_TitleBar;
+	Label* m_Title;
+	Button* m_CloseButton;
+
+	bool m_bInFocus;
+	bool m_bDeleteOnClose;
+
+	ControlsInternal::Modal* m_Modal;
+};
+}  // namespace Controls
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/DragAndDrop.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/DragAndDrop.h
new file mode 100644
index 00000000..bcc12be3
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/DragAndDrop.h
@@ -0,0 +1,35 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_DRAGANDDROP_H
+#define GWEN_DRAGANDDROP_H
+
+#include <sstream>
+
+#include "Gwen/Skin.h"
+#include "Gwen/Structures.h"
+
+namespace Gwen
+{
+namespace DragAndDrop
+{
+extern GWEN_EXPORT Package* CurrentPackage;
+extern GWEN_EXPORT Gwen::Controls::Base* SourceControl;
+extern GWEN_EXPORT Gwen::Controls::Base* HoveredControl;
+
+bool GWEN_EXPORT Start(Gwen::Controls::Base* pControl, Package* pPackage);
+
+bool GWEN_EXPORT OnMouseButton(Gwen::Controls::Base* pHoveredControl, int x, int y, bool bDown);
+void GWEN_EXPORT OnMouseMoved(Gwen::Controls::Base* pHoveredControl, int x, int y);
+
+void GWEN_EXPORT RenderOverlay(Gwen::Controls::Canvas* pCanvas, Skin::Base* skin);
+
+void GWEN_EXPORT ControlDeleted(Gwen::Controls::Base* pControl);
+}  // namespace DragAndDrop
+
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Events.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Events.h
new file mode 100644
index 00000000..26ba7562
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Events.h
@@ -0,0 +1,83 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_EVENTS_H
+#define GWEN_EVENTS_H
+
+#include <list>
+#include "Gwen/Exports.h"
+#include "Gwen/Structures.h"
+
+// TODO: REMOVE THIS - IT SUCKS. Template the function instead.
+#define GWEN_MCALL(fnc) this, (Gwen::Event::Handler::Function)&fnc
+
+namespace Gwen
+{
+namespace Controls
+{
+class Base;
+}
+
+namespace Event
+{
+class Caller;
+
+// A class must be derived from this
+class GWEN_EXPORT Handler
+{
+public:
+	Handler();
+	virtual ~Handler();
+
+	void RegisterCaller(Caller*);
+	void UnRegisterCaller(Caller*);
+
+protected:
+	void CleanLinks();
+	std::list<Caller*> m_Callers;
+
+public:
+	typedef void (Handler::*Function)(Gwen::Controls::Base* pFromPanel);
+	typedef void (Handler::*FunctionStr)(const Gwen::String& string);
+};
+
+//
+//
+//
+class GWEN_EXPORT Caller
+{
+public:
+	Caller();
+	~Caller();
+
+	void Call(Controls::Base* pThis);
+
+	template <typename T>
+	void Add(Event::Handler* ob, T f)
+	{
+		AddInternal(ob, static_cast<Handler::Function>(f));
+	}
+
+	void RemoveHandler(Event::Handler* pObject);
+
+protected:
+	void CleanLinks();
+	void AddInternal(Event::Handler* pObject, Handler::Function pFunction);
+
+	struct handler
+	{
+		Handler::Function fnFunction;
+		Event::Handler* pObject;
+	};
+
+	std::list<handler> m_Handlers;
+};
+
+}  // namespace Event
+
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Exports.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Exports.h
new file mode 100644
index 00000000..62166bf4
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Exports.h
@@ -0,0 +1,29 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_EXPORTS_H
+#define GWEN_EXPORTS_H
+
+#define GWEN_EXPORT
+
+#ifdef _MSC_VER
+
+#define GWEN_FINLINE __forceinline
+#define GWEN_PURE_INTERFACE __declspec(novtable)
+
+#elif defined(__GNUC__)
+
+#define GWEN_FINLINE __attribute__((always_inline)) inline
+#define GWEN_PUREINTERFACE
+
+#else
+
+#define GWEN_FINLINE inline
+#define GWEN_PUREINTERFACE
+
+#endif
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Font.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Font.h
new file mode 100644
index 00000000..0a02a716
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Font.h
@@ -0,0 +1,49 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_FONT_H
+#define GWEN_FONT_H
+
+#include <string>
+#include <list>
+
+#include "Gwen/BaseRender.h"
+
+namespace Gwen
+{
+struct Font
+{
+	typedef std::list<Font*> List;
+
+	Font()
+	{
+		data = NULL;
+
+		facename = L"Arial";
+		size = 10;
+
+		dropshadow = false;
+		bold = false;
+	}
+
+	UnicodeString facename;
+	float size;
+	bool bold;
+	bool dropshadow;
+
+	// This should be set by the renderer
+	// if it tries to use a font where it's
+	// NULL.
+	void* data;
+
+	// This is the real font size, after it's
+	// been scaled by Render->Scale()
+	float realsize;
+};
+
+}  //namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Gwen.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Gwen.h
new file mode 100644
index 00000000..6e54d539
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Gwen.h
@@ -0,0 +1,73 @@
+/*
+
+GWEN modified and adapted for the Bullet Physics Library
+Using the Zlib license with permission from Garry Newman
+
+Copyright (c) 2010 Facepunch Studios
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef GWEN_GWEN_H
+#define GWEN_GWEN_H
+
+#include "Gwen/Macros.h"
+#include "Gwen/Config.h"
+#include "Gwen/Exports.h"
+#include "Gwen/Structures.h"
+#include "Gwen/Skin.h"
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Controls/Canvas.h"
+#include "Gwen/Align.h"
+#include "Gwen/TextObject.h"
+
+// Enable the hook system (se Hook.h)
+#define GWEN_HOOKSYSTEM
+
+namespace Gwen
+{
+namespace Controls
+{
+class Base;
+class Canvas;
+}  // namespace Controls
+
+namespace Renderer
+{
+class Base;
+}
+
+namespace Debug
+{
+void GWEN_EXPORT Msg(const wchar_t* str, ...);
+void GWEN_EXPORT Msg(const char* str, ...);
+void GWEN_EXPORT AssertCheck(bool b, const char* strMsg);
+}  // namespace Debug
+
+namespace Colors
+{
+static const Color Black(0, 0, 0, 255);
+static const Color Red(255, 0, 0, 255);
+static const Color Yellow(255, 255, 0, 255);
+static const Color White(255, 255, 255, 255);
+static const Color Blue(0, 0, 255, 255);
+static const Color Green(0, 255, 0, 255);
+static const Color Grey(200, 200, 200, 255);
+static const Color GreyLight(230, 230, 230, 255);
+static const Color GwenPink(255, 65, 199, 255);
+
+};  // namespace Colors
+
+extern GWEN_EXPORT Controls::Base* HoveredControl;
+extern GWEN_EXPORT Controls::Base* KeyboardFocus;
+extern GWEN_EXPORT Controls::Base* MouseFocus;
+
+}  //namespace Gwen
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Hook.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Hook.h
new file mode 100644
index 00000000..a2ec3ba4
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Hook.h
@@ -0,0 +1,81 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_HOOK_H
+#define GWEN_HOOK_H
+
+#include "Gwen/Gwen.h"
+#include <list>
+
+#ifdef GWEN_HOOKSYSTEM
+
+namespace Gwen
+{
+namespace Hook
+{
+class GWEN_EXPORT BaseHook
+{
+public:
+	virtual bool OnControlClicked(Gwen::Controls::Base*, int /*iMouseX*/, int /*iMouseY*/) { return false; };
+};
+
+typedef std::list<BaseHook*> HookList;
+
+GWEN_EXPORT HookList& GetHookList();
+
+GWEN_EXPORT void AddHook(BaseHook* pHook);
+GWEN_EXPORT void RemoveHook(BaseHook* pHook);
+
+template <typename fnc>
+bool CallHook(fnc f)
+{
+	for (HookList::iterator it = GetHookList().begin(); it != GetHookList().end(); ++it)
+	{
+		if (((*it)->*f)()) return true;
+	}
+
+	return false;
+}
+
+template <typename fnc, typename AA>
+bool CallHook(fnc f, AA a)
+{
+	for (HookList::iterator it = GetHookList().begin(); it != GetHookList().end(); ++it)
+	{
+		if (((*it)->*f)(a)) return true;
+	}
+
+	return false;
+}
+
+template <typename fnc, typename AA, typename AB>
+bool CallHook(fnc f, AA a, AB b)
+{
+	for (HookList::iterator it = GetHookList().begin(); it != GetHookList().end(); ++it)
+	{
+		if (((*it)->*f)(a, b)) return true;
+	}
+
+	return false;
+}
+
+template <typename fnc, typename AA, typename AB, typename AC>
+bool CallHook(fnc f, AA a, AB b, AC c)
+{
+	for (HookList::iterator it = GetHookList().begin(); it != GetHookList().end(); ++it)
+	{
+		if (((*it)->*f)(a, b, c)) return true;
+	}
+
+	return false;
+}
+}  // namespace Hook
+
+}  // namespace Gwen
+
+#endif
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Input/SDL13.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Input/SDL13.h
new file mode 100644
index 00000000..88fa7626
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Input/SDL13.h
@@ -0,0 +1,160 @@
+/*
+	GWEN
+	Copyright (c) 2011 Facepunch Studios
+	See license in Gwen.h
+*/
+#ifndef GWEN_INPUT_SDL13_H
+#define GWEN_INPUT_SDL13_H
+
+#include "Gwen/InputHandler.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Controls/Canvas.h"
+
+#ifdef _WIN32
+#define UCS_STRING "UCS-2"
+#else
+#define UCS_STRING "UCS-4"
+#endif
+
+namespace Gwen
+{
+namespace Input
+{
+class SDL13
+{
+public:
+	SDL13()
+	{
+		m_Canvas = NULL;
+	}
+
+	void Initialize(Gwen::Controls::Canvas* c)
+	{
+		m_Canvas = c;
+	}
+
+	bool ProcessEvent(SDL_Event* Event)
+	{
+		if (!m_Canvas) return false;
+
+		switch (Event->type)
+		{
+			case SDL_KEYUP:
+			case SDL_KEYDOWN:
+			{
+				SDL_KeyboardEvent* E = &Event->key;
+				int iKey = -1;
+				SDL_scancode scancode = E->keysym.scancode;
+				switch (scancode)
+				{
+					case SDL_SCANCODE_RETURN:
+						iKey = Gwen::Key::Return;
+						break;
+					case SDL_SCANCODE_BACKSPACE:
+						iKey = Gwen::Key::Backspace;
+						break;
+					case SDL_SCANCODE_DELETE:
+						iKey = Gwen::Key::Delete;
+						break;
+					case SDL_SCANCODE_LEFT:
+						iKey = Gwen::Key::Left;
+						break;
+					case SDL_SCANCODE_RIGHT:
+						iKey = Gwen::Key::Right;
+						break;
+					case SDL_SCANCODE_LSHIFT:
+						iKey = Gwen::Key::Shift;
+						break;
+					case SDL_SCANCODE_RSHIFT:
+						iKey = Gwen::Key::Shift;
+						break;
+					case SDL_SCANCODE_TAB:
+						iKey = Gwen::Key::Tab;
+						break;
+					case SDL_SCANCODE_SPACE:
+						iKey = Gwen::Key::Space;
+						break;
+					case SDL_SCANCODE_HOME:
+						iKey = Gwen::Key::Home;
+						break;
+					case SDL_SCANCODE_END:
+						iKey = Gwen::Key::End;
+						break;
+					case SDL_SCANCODE_LCTRL:
+						iKey = Gwen::Key::Control;
+						break;
+					case SDL_SCANCODE_RCTRL:
+						iKey = Gwen::Key::Control;
+						break;
+					case SDL_SCANCODE_UP:
+						iKey = Gwen::Key::Up;
+						break;
+					case SDL_SCANCODE_DOWN:
+						iKey = Gwen::Key::Down;
+						break;
+					case SDL_SCANCODE_ESCAPE:
+						iKey = Gwen::Key::Escape;
+						break;
+					case SDL_SCANCODE_LALT:
+						iKey = Gwen::Key::Alt;
+						break;
+					case SDL_SCANCODE_RALT:
+						iKey = Gwen::Key::Alt;
+						break;
+					default:
+						return false;
+				}
+				return m_Canvas->InputKey(iKey, E->state);
+			}
+			case SDL_TEXTINPUT:
+			{
+				SDL_TextInputEvent* E = &Event->text;
+				wchar_t* widechar = (wchar_t*)SDL_iconv_string(UCS_STRING, "UTF-8", E->text, SDL_strlen(E->text) + 1);
+				bool ret = m_Canvas->InputCharacter(*widechar);
+				SDL_free(widechar);
+				return ret;
+			}
+			case SDL_MOUSEMOTION:
+			{
+				SDL_MouseMotionEvent* E = &Event->motion;
+				return m_Canvas->InputMouseMoved(E->x, E->y, E->xrel, E->yrel);
+			}
+			case SDL_MOUSEBUTTONDOWN:
+			case SDL_MOUSEBUTTONUP:
+			{
+				SDL_MouseButtonEvent* E = &Event->button;
+				int Button = -1;
+				switch (E->button)
+				{
+					case SDL_BUTTON_LEFT:
+						Button = 0;
+						break;
+					case SDL_BUTTON_MIDDLE:
+						Button = 2;
+						break;
+					case SDL_BUTTON_RIGHT:
+						Button = 1;
+						break;
+					default:
+						return false;
+				}
+				return m_Canvas->InputMouseButton(Button, E->state);
+			}
+			case SDL_MOUSEWHEEL:
+			{
+				SDL_MouseWheelEvent* E = &Event->wheel;
+				return m_Canvas->InputMouseWheel(E->y);
+			}
+			default:
+			{
+				return false;
+			}
+		}
+	}
+
+protected:
+	Gwen::Controls::Canvas* m_Canvas;
+};
+}  // namespace Input
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Input/SFML.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Input/SFML.h
new file mode 100644
index 00000000..dd0ad5be
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Input/SFML.h
@@ -0,0 +1,179 @@
+/*
+	GWEN
+	Copyright (c) 2011 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_INPUT_SFML_H
+#define GWEN_INPUT_SFML_H
+
+#include "Gwen/InputHandler.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Controls/Canvas.h"
+
+#include <SFML/Graphics.hpp>
+
+namespace Gwen
+{
+namespace Input
+{
+class SFML
+{
+public:
+	SFML()
+	{
+		m_Canvas = NULL;
+		m_MouseX = 0;
+		m_MouseY = 0;
+	}
+
+	void Initialize(Gwen::Controls::Canvas* c)
+	{
+		m_Canvas = c;
+	}
+
+	unsigned char TranslateKeyCode(int iKeyCode)
+	{
+		switch (iKeyCode)
+		{
+#if SFML_VERSION_MAJOR == 2
+			case sf::Keyboard::Back:
+				return Gwen::Key::Backspace;
+			case sf::Keyboard::Return:
+				return Gwen::Key::Return;
+			case sf::Keyboard::Escape:
+				return Gwen::Key::Escape;
+			case sf::Keyboard::Tab:
+				return Gwen::Key::Tab;
+			case sf::Keyboard::Space:
+				return Gwen::Key::Space;
+			case sf::Keyboard::Up:
+				return Gwen::Key::Up;
+			case sf::Keyboard::Down:
+				return Gwen::Key::Down;
+			case sf::Keyboard::Left:
+				return Gwen::Key::Left;
+			case sf::Keyboard::Right:
+				return Gwen::Key::Right;
+			case sf::Keyboard::Home:
+				return Gwen::Key::Home;
+			case sf::Keyboard::End:
+				return Gwen::Key::End;
+			case sf::Keyboard::Delete:
+				return Gwen::Key::Delete;
+			case sf::Keyboard::LControl:
+				return Gwen::Key::Control;
+			case sf::Keyboard::LAlt:
+				return Gwen::Key::Alt;
+			case sf::Keyboard::LShift:
+				return Gwen::Key::Shift;
+			case sf::Keyboard::RControl:
+				return Gwen::Key::Control;
+			case sf::Keyboard::RAlt:
+				return Gwen::Key::Alt;
+			case sf::Keyboard::RShift:
+				return Gwen::Key::Shift;
+#else
+			case sf::Key::Back:
+				return Gwen::Key::Backspace;
+			case sf::Key::Return:
+				return Gwen::Key::Return;
+			case sf::Key::Escape:
+				return Gwen::Key::Escape;
+			case sf::Key::Tab:
+				return Gwen::Key::Tab;
+			case sf::Key::Space:
+				return Gwen::Key::Space;
+			case sf::Key::Up:
+				return Gwen::Key::Up;
+			case sf::Key::Down:
+				return Gwen::Key::Down;
+			case sf::Key::Left:
+				return Gwen::Key::Left;
+			case sf::Key::Right:
+				return Gwen::Key::Right;
+			case sf::Key::Home:
+				return Gwen::Key::Home;
+			case sf::Key::End:
+				return Gwen::Key::End;
+			case sf::Key::Delete:
+				return Gwen::Key::Delete;
+			case sf::Key::LControl:
+				return Gwen::Key::Control;
+			case sf::Key::LAlt:
+				return Gwen::Key::Alt;
+			case sf::Key::LShift:
+				return Gwen::Key::Shift;
+			case sf::Key::RControl:
+				return Gwen::Key::Control;
+			case sf::Key::RAlt:
+				return Gwen::Key::Alt;
+			case sf::Key::RShift:
+				return Gwen::Key::Shift;
+#endif
+		}
+
+		return Gwen::Key::Invalid;
+	}
+
+	bool ProcessMessage(sf::Event& event)
+	{
+		if (!m_Canvas) return false;
+
+		switch (event.Type)
+		{
+			case sf::Event::MouseMoved:
+			{
+				int dx = event.MouseMove.X - m_MouseX;
+				int dy = event.MouseMove.Y - m_MouseY;
+
+				m_MouseX = event.MouseMove.X;
+				m_MouseY = event.MouseMove.Y;
+
+				return m_Canvas->InputMouseMoved(m_MouseX, m_MouseY, dx, dy);
+			}
+
+			case sf::Event::MouseButtonPressed:
+			case sf::Event::MouseButtonReleased:
+			{
+				return m_Canvas->InputMouseButton(event.MouseButton.Button, event.Type == sf::Event::MouseButtonPressed);
+			}
+
+			case sf::Event::MouseWheelMoved:
+			{
+				return m_Canvas->InputMouseWheel(event.MouseWheel.Delta * 60);
+			}
+
+			case sf::Event::TextEntered:
+			{
+				return m_Canvas->InputCharacter(event.Text.Unicode);
+			}
+
+			case sf::Event::KeyPressed:
+			case sf::Event::KeyReleased:
+			{
+				bool bPressed = (event.Type == sf::Event::KeyPressed);
+
+				if (event.Key.Control && bPressed && event.Key.Code >= 'a' && event.Key.Code <= 'z')
+				{
+					return m_Canvas->InputCharacter(event.Key.Code);
+				}
+
+				unsigned char iKey = TranslateKeyCode(event.Key.Code);
+
+				return m_Canvas->InputKey(iKey, bPressed);
+			}
+		}
+
+		return false;
+	}
+
+protected:
+	Gwen::Controls::Canvas* m_Canvas;
+	int m_MouseX;
+	int m_MouseY;
+};
+}  // namespace Input
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Input/Windows.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Input/Windows.h
new file mode 100644
index 00000000..feb17411
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Input/Windows.h
@@ -0,0 +1,175 @@
+/*
+	GWEN
+	Copyright (c) 2011 Facepunch Studios
+	See license in Gwen.h
+*/
+#ifndef GWEN_INPUT_WINDOWS_H
+#define GWEN_INPUT_WINDOWS_H
+
+#include "Gwen/InputHandler.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Controls/Canvas.h"
+
+#include <windows.h>
+
+namespace Gwen
+{
+namespace Input
+{
+class Windows
+{
+public:
+	Windows()
+	{
+		m_Canvas = NULL;
+		m_MouseX = 0;
+		m_MouseY = 0;
+	}
+
+	void Initialize(Gwen::Controls::Canvas* c)
+	{
+		m_Canvas = c;
+	}
+
+	bool ProcessMessage(MSG msg)
+	{
+		if (!m_Canvas) return false;
+
+		switch (msg.message)
+		{
+			case WM_MOUSEMOVE:
+			{
+				int x = (signed short)LOWORD(msg.lParam);
+				int y = (signed short)HIWORD(msg.lParam);
+				int dx = x - m_MouseX;
+				int dy = y - m_MouseY;
+
+				m_MouseX = x;
+				m_MouseY = y;
+
+				return m_Canvas->InputMouseMoved(x, y, dx, dy);
+			}
+
+			case WM_CHAR:
+			{
+				Gwen::UnicodeChar chr = (Gwen::UnicodeChar)msg.wParam;
+				return m_Canvas->InputCharacter(chr);
+			}
+
+			case WM_MOUSEWHEEL:
+			{
+				return m_Canvas->InputMouseWheel((short)HIWORD(msg.wParam));
+			}
+
+			case WM_LBUTTONDOWN:
+			{
+				SetCapture(msg.hwnd);
+				return m_Canvas->InputMouseButton(0, true);
+			}
+
+			case WM_LBUTTONUP:
+			{
+				ReleaseCapture();
+				return m_Canvas->InputMouseButton(0, false);
+			}
+
+			case WM_RBUTTONDOWN:
+			{
+				SetCapture(msg.hwnd);
+				return m_Canvas->InputMouseButton(1, true);
+			}
+
+			case WM_RBUTTONUP:
+			{
+				ReleaseCapture();
+				return m_Canvas->InputMouseButton(1, false);
+			}
+
+			case WM_MBUTTONDOWN:
+			{
+				SetCapture(msg.hwnd);
+				return m_Canvas->InputMouseButton(2, true);
+			}
+
+			case WM_MBUTTONUP:
+			{
+				ReleaseCapture();
+				return m_Canvas->InputMouseButton(2, true);
+			}
+
+			case WM_LBUTTONDBLCLK:
+			case WM_RBUTTONDBLCLK:
+			case WM_MBUTTONDBLCLK:
+			{
+				// Filter out those events from the application
+				return true;
+			}
+
+			case WM_KEYDOWN:
+			case WM_KEYUP:
+			{
+				bool bDown = msg.message == WM_KEYDOWN;
+				int iKey = -1;
+
+				// These aren't sent by WM_CHAR when CTRL is down - but we need
+				// them internally for copy and paste etc..
+				if (bDown && GetKeyState(VK_CONTROL) & 0x80 && msg.wParam >= 'A' && msg.wParam <= 'Z')
+				{
+					Gwen::UnicodeChar chr = (Gwen::UnicodeChar)msg.wParam;
+					return m_Canvas->InputCharacter(chr);
+				}
+
+				if (msg.wParam == VK_SHIFT)
+					iKey = Gwen::Key::Shift;
+				else if (msg.wParam == VK_RETURN)
+					iKey = Gwen::Key::Return;
+				else if (msg.wParam == VK_BACK)
+					iKey = Gwen::Key::Backspace;
+				else if (msg.wParam == VK_DELETE)
+					iKey = Gwen::Key::Delete;
+				else if (msg.wParam == VK_LEFT)
+					iKey = Gwen::Key::Left;
+				else if (msg.wParam == VK_RIGHT)
+					iKey = Gwen::Key::Right;
+				else if (msg.wParam == VK_TAB)
+					iKey = Gwen::Key::Tab;
+				else if (msg.wParam == VK_SPACE)
+					iKey = Gwen::Key::Space;
+				else if (msg.wParam == VK_HOME)
+					iKey = Gwen::Key::Home;
+				else if (msg.wParam == VK_END)
+					iKey = Gwen::Key::End;
+				else if (msg.wParam == VK_CONTROL)
+					iKey = Gwen::Key::Control;
+				else if (msg.wParam == VK_SPACE)
+					iKey = Gwen::Key::Space;
+				else if (msg.wParam == VK_UP)
+					iKey = Gwen::Key::Up;
+				else if (msg.wParam == VK_DOWN)
+					iKey = Gwen::Key::Down;
+
+				if (iKey != -1)
+				{
+					return m_Canvas->InputKey(iKey, bDown);
+				}
+
+				break;
+			}
+
+			default:
+			{
+				break;
+			}
+		}
+
+		return false;
+	}
+
+protected:
+	Gwen::Controls::Canvas* m_Canvas;
+	int m_MouseX;
+	int m_MouseY;
+};
+}  // namespace Input
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/InputHandler.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/InputHandler.h
new file mode 100644
index 00000000..29f35af9
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/InputHandler.h
@@ -0,0 +1,79 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_INPUTHANDLER_H
+#define GWEN_INPUTHANDLER_H
+
+#include <queue>
+#include "Gwen/Gwen.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class Base;
+}
+
+namespace Key
+{
+const unsigned char Invalid = 0;
+const unsigned char Return = 1;
+const unsigned char Backspace = 2;
+const unsigned char Delete = 3;
+const unsigned char Left = 4;
+const unsigned char Right = 5;
+const unsigned char Shift = 6;
+const unsigned char Tab = 7;
+const unsigned char Space = 8;
+const unsigned char Home = 9;
+const unsigned char End = 10;
+const unsigned char Control = 11;
+const unsigned char Up = 12;
+const unsigned char Down = 13;
+const unsigned char Escape = 14;
+const unsigned char Alt = 15;
+
+const unsigned char Count = 16;
+}  // namespace Key
+
+namespace Input
+{
+namespace Message
+{
+enum
+{
+	Copy,
+	Paste,
+	Cut,
+	Undo,
+	Redo,
+	SelectAll
+};
+};
+
+// For use in panels
+bool GWEN_EXPORT IsKeyDown(int iKey);
+bool GWEN_EXPORT IsLeftMouseDown();
+bool GWEN_EXPORT IsRightMouseDown();
+Gwen::Point GWEN_EXPORT GetMousePosition();
+
+inline bool IsShiftDown() { return IsKeyDown(Gwen::Key::Shift); }
+inline bool IsControlDown() { return IsKeyDown(Gwen::Key::Control); }
+
+// Does copy, paste etc
+bool GWEN_EXPORT DoSpecialKeys(Controls::Base* pCanvas, Gwen::UnicodeChar chr);
+bool GWEN_EXPORT HandleAccelerator(Controls::Base* pCanvas, Gwen::UnicodeChar chr);
+
+// Send input to canvas for study
+void GWEN_EXPORT OnMouseMoved(Controls::Base* pCanvas, int x, int y, int deltaX, int deltaY);
+bool GWEN_EXPORT OnMouseClicked(Controls::Base* pCanvas, int iButton, bool bDown);
+bool GWEN_EXPORT OnKeyEvent(Controls::Base* pCanvas, int iKey, bool bDown);
+void GWEN_EXPORT OnCanvasThink(Controls::Base* pControl);
+
+};  // namespace Input
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Macros.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Macros.h
new file mode 100644
index 00000000..6f0c09ed
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Macros.h
@@ -0,0 +1,90 @@
+
+// C RunTime Header Files
+#ifndef GWEN_MACROS_H
+#define GWEN_MACROS_H
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stdio.h>  // vsnprintf
+#if !defined(__APPLE__) && !defined(__OpenBSD__) && !defined(__FreeBSD__)
+#include <malloc.h>
+#else
+#include <stdlib.h>
+#endif  //__APPLE__
+#include <memory.h>
+#include <algorithm>
+
+// Not tied to platform api.
+#define GwenUtil_Min(a, b) (((a) < (b)) ? (a) : (b))
+#define GwenUtil_Max(a, b) (((a) > (b)) ? (a) : (b))
+#define GwenUtil_VSWPrintFSafeSized(_DstBuf_ARRAY_, _Format, _ArgList) GwenUtil_VSWPrintFSafe(_DstBuf_ARRAY_, sizeof(_DstBuf_ARRAY_) / sizeof(wchar_t), _Format, _ArgList)
+
+#ifdef _MSC_VER
+
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <windows.h>
+
+#define GwenUtil_VSNPrintFSafe(_DstBuf, _DstSize, _MaxCount, _Format, _ArgList) vsnprintf_s(_DstBuf, _DstSize, _MaxCount, _Format, _ArgList)
+#define GwenUtil_VSWPrintFSafe(_DstBuf, _SizeInWords, _Format, _ArgList) vswprintf_s(_DstBuf, _SizeInWords, _Format, _ArgList)
+#define GwenUtil_OutputDebugCharString(lpOutputString) OutputDebugStringA(lpOutputString)
+#define GwenUtil_OutputDebugWideString(lpOutputString) OutputDebugStringW(lpOutputString)
+#define GwenUtil_WideStringToFloat(_Str) _wtof(_Str)
+
+#elif defined(__APPLE__)
+
+#include <CoreFoundation/CoreFoundation.h>
+
+#define GwenUtil_VSNPrintFSafe(_DstBuf, _DstSize, _MaxCount, _Format, _ArgList) vsnprintf(_DstBuf, _DstSize, _Format, _ArgList)
+#define GwenUtil_VSWPrintFSafe(_DstBuf, _SizeInWords, _Format, _ArgList) vswprintf(_DstBuf, _SizeInWords, _Format, _ArgList)
+#define GwenUtil_OutputDebugCharString(lpOutputString)  //printf( lpOutputString )
+#define GwenUtil_OutputDebugWideString(lpOutputString)  //wprintf( lpOutputString  )
+#define GwenUtil_WideStringToFloat(_Str) wcstof(_Str, NULL)
+
+#elif defined(__linux__) || defined(__GNUC__)
+
+#define GwenUtil_VSNPrintFSafe(_DstBuf, _DstSize, _MaxCount, _Format, _ArgList) vsnprintf(_DstBuf, _DstSize, _Format, _ArgList)
+#ifdef _WIN32
+#define GwenUtil_VSWPrintFSafe(_DstBuf, _SizeInWords, _Format, _ArgList) vsnwprintf(_DstBuf, _SizeInWords, _Format, _ArgList)
+#else
+#define GwenUtil_VSWPrintFSafe(_DstBuf, _SizeInWords, _Format, _ArgList) vswprintf(_DstBuf, _SizeInWords, _Format, _ArgList)
+#endif
+#define GwenUtil_OutputDebugCharString(lpOutputString)  //printf( lpOutputString )
+#define GwenUtil_OutputDebugWideString(lpOutputString)  //wprintf( lpOutputString  )
+#define GwenUtil_WideStringToFloat(_Str) wcstof(_Str, NULL)
+
+#else
+
+#error MUST_IMPLEMENT_PLATFORM
+
+#endif
+
+namespace Gwen
+{
+template <typename T1, typename T2, typename T3>
+T1 Clamp(T1 current, T2 vmin, T3 vmax)
+{
+	if (current > vmax) return (T1)vmax;
+	if (current < vmin) return (T1)vmin;
+	return current;
+}
+
+template <typename T, typename T2>
+inline T Approach(T fCurrent, T fTarget, T2 fDelta)
+{
+	if (fCurrent < fTarget)
+	{
+		fCurrent += fDelta;
+		if (fCurrent > fTarget) return fTarget;
+	}
+	else if (fCurrent > fTarget)
+	{
+		fCurrent -= fDelta;
+		if (fCurrent < fTarget) return fTarget;
+	}
+
+	return fCurrent;
+}
+}  // namespace Gwen
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Platform.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Platform.h
new file mode 100644
index 00000000..530a0c14
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Platform.h
@@ -0,0 +1,43 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_PLATFORM_H
+#define GWEN_PLATFORM_H
+
+#include "Gwen/Structures.h"
+#include "Gwen/Events.h"
+
+namespace Gwen
+{
+namespace Platform
+{
+//
+// Set the system cursor to iCursor
+// Cursors are defined in Structures.h
+//
+void GWEN_EXPORT SetCursor(unsigned char iCursor);
+
+//
+// Used by copy/paste
+//
+UnicodeString GWEN_EXPORT GetClipboardText();
+bool GWEN_EXPORT SetClipboardText(const UnicodeString& str);
+
+//
+// Needed for things like double click
+//
+float GWEN_EXPORT GetTimeInSeconds();
+
+//
+// System Dialogs ( Can return false if unhandled )
+//
+bool GWEN_EXPORT FileOpen(const String& Name, const String& StartPath, const String& Extension, Gwen::Event::Handler* pHandler, Event::Handler::FunctionStr fnCallback);
+bool GWEN_EXPORT FileSave(const String& Name, const String& StartPath, const String& Extension, Gwen::Event::Handler* pHandler, Event::Handler::FunctionStr fnCallback);
+}  // namespace Platform
+
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Renderers/DirectX9.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Renderers/DirectX9.h
new file mode 100644
index 00000000..308450a5
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Renderers/DirectX9.h
@@ -0,0 +1,70 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#ifndef GWEN_RENDERERS_DIRECTX9_H
+#define GWEN_RENDERERS_DIRECTX9_H
+#include "Gwen/Gwen.h"
+#include "Gwen/BaseRender.h"
+
+struct VERTEXFORMAT2D
+{
+	FLOAT x, y, z, rhw;
+	DWORD color;
+	float u, v;
+};
+
+#define D3DFVF_VERTEXFORMAT2D (D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1)
+
+namespace Gwen
+{
+namespace Renderer
+{
+class GWEN_EXPORT DirectX9 : public Gwen::Renderer::Base
+{
+public:
+	DirectX9(IDirect3DDevice9* pDevice);
+	~DirectX9();
+
+	virtual void Begin();
+	virtual void End();
+	virtual void Release();
+
+	virtual void SetDrawColor(Gwen::Color color);
+
+	virtual void DrawLine(int x, int y, int a, int b);
+	virtual void DrawFilledRect(Gwen::Rect rect);
+
+	virtual void LoadFont(Gwen::Font* pFont);
+	virtual void FreeFont(Gwen::Font* pFont);
+	virtual void RenderText(Gwen::Font* pFont, Gwen::Point pos, const Gwen::UnicodeString& text);
+	virtual Gwen::Point MeasureText(Gwen::Font* pFont, const Gwen::UnicodeString& text);
+
+	void StartClip();
+	void EndClip();
+
+	void DrawTexturedRect(Gwen::Texture* pTexture, Gwen::Rect pTargetRect, float u1 = 0.0f, float v1 = 0.0f, float u2 = 1.0f, float v2 = 1.0f);
+	void LoadTexture(Gwen::Texture* pTexture);
+	void FreeTexture(Gwen::Texture* pTexture);
+
+protected:
+	void* m_pCurrentTexture;
+	IDirect3DDevice9* m_pDevice;
+	DWORD m_Color;
+
+	void Flush();
+	void AddVert(int x, int y);
+	void AddVert(int x, int y, float u, float v);
+
+	static const int MaxVerts = 1024;
+	VERTEXFORMAT2D m_pVerts[MaxVerts];
+	int m_iVertNum;
+
+	Gwen::Font::List m_FontList;
+};
+
+}  // namespace Renderer
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Renderers/FontData.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Renderers/FontData.h
new file mode 100644
index 00000000..6cb514eb
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Renderers/FontData.h
@@ -0,0 +1,263 @@
+
+unsigned char sGwenFontData[] =
+	{
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 0, 0, 255, 255, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 0, 255, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 0, 255, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 0, 255, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 0, 0, 255, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 0, 0, 255, 255, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 255, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 255, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 255, 255, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		255, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+static const signed char sGwenDebugFontSpacing[] =
+	{
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 4, 6, 6, 9, 8, 3, 4, 4, 4, 6, 3, 7, 3, 3, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 3, 3, 6, 5, 6, 6, 11, 7, 7, 8, 8, 7, 6, 8, 8, 3, 5, 7, 6, 9, 8, 8, 7, 8, 7, 7, 5, 8, 7, 9, 7, 7, 7, 3, 3, 3, 6, 6, 3, 5, 6, 5, 6, 5, 4, 6, 6, 2, 2, 5, 2, 8, 6, 6, 6, 6, 4, 5, 4, 5, 6, 8, 6, 5, 5, 3, 3, 3, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 6, 6, 5, 6, 3, 6, 3, 9, 4, 6, 7, 4, 9, 3, 4, 6, 3, 3, 3, 5, 6, 3, 3, 3, 4, 6, 9, 9, 9, 6, 7, 7, 7, 7, 7, 7, 10, 8, 7, 7, 7, 7, 3, 3, 3, 3, 8, 8, 8, 8, 8, 8, 8, 6, 8, 8, 8, 8, 8, 7, 7, 5, 5, 5, 5, 5, 5, 5, 8, 5, 5, 5, 5, 5, 2, 2, 2, 2, 6, 5, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 6, 5, 116, 112, 61, 0, 0, 0, 0, -96, -48, 96, 80, -64, 0, 64, -96, 16, 0, 0, 0, 98, 99, 0, 16, 0, -96, -48, 96, 80, -64, 0, -16, -128, 16, 98, 99, 0, -80, 32, 16, -16, 16, 112, -64, -64, -32, -16, -48, 16, -48, 0, 64, -128, -64, 32, -48, -64, -48, -16, 96, 32, 64, 96, 96, 32, 32, -96, -64, -96, 80, 64, -80, 16, -48, 16, -80, -16, 48, 112, 80, -80, -16, 64, 80, -112, -48, 16, 80, 48, 96, 16, 16, 16, -112, -16, -16, 0, 96, 48, 48, -112, 112, -80, -32, -48, -96, -112, 16, 80, 80, 48, -64, -80, -112, 96, 80, 64, 96, 48, 80, 73, 65, 32, 84, 82, 84, 0, 92, 103, 32, 101, 120, 92, 114, 102, 105, 108, 117, 32, 92, 105, 117, 120, 108, 0, 115, 114, 32, 114, 114, 116, 101, 110, 0, 92, 103, 32, 101, 120, 92, 114, 102, 105, 108, 117, 32, 92, 105, 117, 108, 0, 92, 103, 32, 101, 120, 92, 114, 102, 105, 108, 117, 32, 92, 105, 117, 120, 101, 110, 105, 114, 101, 0, 100, 84, 60, 115, 116, 95, 116, 97, 60, 115, 119, 58, 116, 115, 97, 42, 114, 32, 58, 115, 108, 32, 110, 111, 111, 58, 101, 44, 115, 116, 97, 99, 114, 97, 71, 58, 110, 108, 66, 32, 48, 58, 110, 105, 97, 58, 101, 111, 61, 83, 100, 32, 32, 114, 101, 110, 105, 114, 101, 44, 0, 112, 116, 101, 111, 105, 109, 105, 0, 115, 110, 116, 101, 111, 117, 100, 97, 0, 115, 111, 64, 80, -112, 34, 32, 114, 101, 0, 100, 105, 99, 115, 101, 67, 114, 58, 115, 44, 115, 116, 97, 99, 114, 97, 71, 58, 110, 108, 66, 32, 62, 67, 116, 101, 111, 62, 112, 116, 42, 83, 100, 32, 32, 114, 101, 117, 102, 110, 44, 0, 115, 116, 116, 110, 100, 102, 110, 108, 0, 100, 105, 99, 115, 101, 67, 114, 58, 115, 44, 115, 116, 97, 99, 114, 97, 71, 58, 110, 108, 66, 32, 62, 67, 116, 101, 111, 62, 112, 116, 43, 0, 115, 116, 116, 110, 105, 101, 116, 101, 60, 108, 0, 112, 116, 97, 105, 97, 32, 115, 32, 103, 0, 100, 105, 99, 115, 101, 67, 114, 58, 115, 44, 115, 116, 97, 99, 114, 97, 71, 58, 110, 108, 66, 32, 62, 67, 116, 101, 111, 62, 67, 97, 108, 32, 114, 114, 110, 112, 98, 0, 100, 84, 60, 115, 116, 95, 116, 97, 60, 115, 119, 58, 116, 115, 97, 42, 114, 32, 58, 115, 108, 32, 110, 111, 111, 58, 101, 44, 115, 116, 97, 99, 114, 97, 71, 58, 110, 108, 66, 32, 48, 58, 110, 105, 97, 58, 101, 0, 112, 116, 101, 111, 111, 101, 109, 97, 0, 100, 84, 60, 115, 116, 95, 116, 97, 60, 115, 119, 58, 116, 115, 97, 42, 114, 32, 58, 115, 108, 32, 110, 111, 111, 58, 101, 44, 115, 116, 97, 99, 114, 97, 71, 58, 110, 108, 66, 32, 48, 58, 110, 105, 97, 58, 110, 0, 112, 116, 101, 111, 111, 110, 109, 97, 0, 118, 100, 101, 111, 16, -26, 100, 105, 99, 115, 101, 67, 114, 58, 115, 44, 115, 116, 97, 99, 114, 97, 71, 58, 110, 108, 66, 32, 62, 67, 116, 101, 111, 62, 112, 116, 45, 0, 115, 116, 116, 110, 100, 101, 116, 101, 97, 111, 0, 0, 0, 0, 97, 111, 48, 48, -96, -112, -48, 16, -64, 0, -16, -128, 16, 0, -103, 97, 111, 58, 110, 105, 33, -128, 32, -64, -16, 16, 112, -64, -64, -32, -16, -48, 16, -48, 0, 64, -128, -64, 32, -48, -64, -48, -16, 96, 32, 112, 96, 96, 32, -96, -96, -64, -96, 80, 64, -80, 16, -48, 16, -80, -16, 48, 112, 80, -80, -16, 64, 80, -112, -48, 16, 80, 48, 96, 16, 16, 16, -112, 32, -16, 0, 96, 48, 48, -112, 112, -80, -32, -48, -96, -112, 16, 80, 80, 48, -64, -124, -96, -112, 64, -110, -128, 0, 80, 112, 0, 100, 84, 60, 115, 116, 95, 112, 97, 60, 115, 116, 98, 99, 114, 60, 97, 44, 117, 115, 58, 114, 97, 60, 97, 62, 97, 115, 58, 111, 111, 99, 95, 62, 97, 71, 58, 101, 58, 108, 42, 114, 32, 58, 115, 108, 32, 58, 115, 115, 110, 99, 95, 116, 116, 100, 104, 116, 116, 99, 95, 99, 115, 100, 108, 97, 60, 97, 62, 62, 97, 115, 58, 111, 111, 116, 116, 100, 97, 99, 115, 100, 97, 95, 105, 119, 114, 115, 99, 116, 99, 95, 105, 119, 114, 44, 115, 116, 97, 99, 114, 104, 116, 32, 115, 99, 115, 101, 69, 116, 97, 114, 32, 62, 58, 115, 116, 116, 58, 114, 114, 0, 100, 84, 60, 115, 116, 95, 112, 97, 60, 115, 116, 98, 99, 114, 60, 97, 44, 117, 115, 58, 114, 97, 60, 97, 62, 97, 115, 58, 111, 111, 99, 95, 62, 97, 71, 58, 101, 58, 108, 42, 114, 32, 58, 115, 108, 32, 58, 115, 115, 110, 99, 95, 116, 116, 100, 104, 116, 116, 99, 95, 99, 115, 100, 108, 97, 60, 97, 62, 62, 97, 115, 58, 111, 111, 116, 116, 100, 97, 99, 115, 100, 97, 95, 105, 119, 114, 115, 99, 116, 99, 95, 105, 119, 114, 44, 115, 116, 97, 99, 114, 104, 116, 32, 115, 99, 115, 101, 69, 116, 97, 114, 32, 62, 58, 115, 116, 116, 58, 114, 114, 0, 112, 116, 101, 111, 111, 101, 101, 99, 101, 100, 84, 60, 115, 116, 95, 112, 97, 60, 115, 116, 98, 99, 114, 60, 97, 44, 117, 115, 58, 114, 97, 60, 97, 62, 97, 115, 58, 111, 111, 99, 95, 62, 97, 71, 58, 101, 58, 108, 42, 114, 32, 58, 115, 108, 32, 58, 115, 115, 110, 99, 95, 116, 116, 100, 104, 116, 116, 99, 95, 99, 115, 100, 108, 97, 60, 97, 62, 62, 97, 115, 58, 111, 111, 116, 116, 100, 97, 99, 115, 100, 97, 95, 105, 119, 114, 115, 99, 116, 99, 95, 105, 119, 114, 44, 115, 116, 97, 99, 114, 104, 116, 32, 115, 99, 115, 101, 69, 116, 97, 114, 32, 62, 58, 115, 116, 116, 58, 99, 92, 103, 32, 101, 120, 92, 114, 102, 105, 108, 117, 32, 92, 105, 117, 97, 114, 109, 100, 105, 99, 115, 101, 67, 114, 58, 115, 44, 115, 116, 97, 99, 114, 97, 71, 58, 110, 108, 66, 32, 62, 73, 97, 60, 58, 101, 100, 101, 111, 115, 110, 111, 97, 0, 116, 45, 97, 99, 97, 114, 97, 34, 41, 100, 105, 99, 115, 101, 67, 114, 58, 115, 44, 115, 116, 97, 99, 114, 97, 71, 58, 110, 108, 66, 32, 62, 67, 116, 101, 111, 62, 112, 116, 42, 100, 105, 99, 115, 101, 67, 114, 58, 115, 44, 115, 116, 97, 99, 114, 97, 71, 58, 110, 108, 66, 32, 62, 67, 116, 101, 111, 62, 112, 116, 43, 0, 100, 105, 99, 115, 101, 67, 114, 58, 115, 44, 115, 116, 97, 99, 114, 97, 71, 58, 110, 108, 66, 32, 62, 67, 116, 101, 111, 62, 67, 97, 98, 99, 98, 99, 98, 99, -113, 67, 32, 83, 116, 0, 100, 105, 99, 115, 101, 72, 58, 115, 111, 44, 115, 116, 97, 99, 114, 97, 71, 58, 111, 66, 72, 32, 62, 67, 116, 101, 111, 62, 112, 116, 42, 100, 105, 99, 115, 101, 72, 58, 115, 111, 44, 115, 116, 97, 99, 114, 97, 71, 58, 111, 66, 72, 32, 62, 67, 116, 101, 111, 62, 112, 116, 43, 0, 100, 105, 99, 115, 101, 72, 58, 115, 111, 44, 115, 116, 97, 99, 114, 97, 71, 58, 111, 66, 72, 32, 62, 67, 116, 101, 111, 62, 67, 97, 98, 99, -92, -96, 64, -128, 112, 116, 115, 32, 114, 114, 116, 101, 110, 0, 100, 84, 60, 115, 116, 95, 112, 97, 60, 115, 119, 58, 116, 115, 97, 42, 97, 115, 58, 116, 97, 71, 58, 105, 65, 97, 110, 99, 115, 100, 108, 97, 60, 115, 119, 58, 109, 110, 116, 32, 62, 114, 32, 58, 115, 108, 32, 110, 111, 111, 58, 101, 44, 115, 116, 97, 99, 114, 114, 32, 58, 105, 108, 32, 110, 111, 111, 58, 101, 99, 116, 97, 115, 58, 116, 97, 71, 58, 105, 65, 97, 110, 99, 115, 100, 108, 97, 60, 115, 119, 58, 109, 110, 116, 32, 62, 62, 32, 99, 116, 101, 111, 111, 97, 32, 0, 100, 105, 99, 115, 101, 65, 58, 105, 105, 42, 97, 115, 58, 111, 111, 108, 32, 110, 110, 58, 109, 111, 62, 58, 110, 105, 97, 60, 58, 114, 114, 0, 100, 105, 99, 115, 101, 65, 58, 105, 105, 42, 97, 115, 58, 111, 111, 108, 32, 110, 110, 58, 109, 111, 62, 58, 110, 105, 97, 60, 58, 114, 114, 0, 100, 84, 60, 115, 116, 95, 112, 97, 60, 115, 119, 58, 116, 115, 97, 42, 97, 115, 58, 116, 97, 71, 58, 105, 65, 97, 110, 99, 115, 100, 108, 97, 60, 115, 119, 58, 109, 110, 116, 32, 62, 114, 32, 58, 115, 108, 32, 110, 111, 111, 58, 101, 44, 115, 116, 97, 99, 114, 114, 32, 58, 105, 108, 32, 110, 111, 111, 58, 101, 99, 116, 97, 115, 58, 116, 97, 71, 58, 105, 65, 97, 110, 99, 115, 100, 108, 97, 60, 115, 119, 58, 109, 110, 116, 32, 62, 62, 32, 99, 116, 101, 111, 111, 97, 32, 0, 100, 84, 60, 115, 116, 95, 112, 97, 60, 115, 119, 58, 116, 115, 97, 42, 97, 115, 58, 116, 97, 71, 58, 105, 65, 97, 110, 99, 115, 100, 108, 97, 60, 115, 119, 58, 109, 110, 116, 32, 62, 114, 32, 58, 115, 108, 32, 110, 111, 111, 58, 101, 44, 115, 116, 97, 99, 114, 114, 32, 58, 105, 108, 32, 110, 111, 111, 58, 101, 99, 116, 97, 115, 58, 116, 97, 71, 58, 105, 65, 97, 110, 99, 115, 100, 108, 97, 60, 115, 119, 58, 109, 110, 116, 32, 62, 62, 32, 99, 116, 101, 111, 95, 0, 100, 105, 99, 115, 101, 65, 58, 105, 105, 42, 97, 115, 58, 111, 111, 108, 32, 110, 110, 58, 109, 111, 62, 58, 110, 105, 97, 60, 58, 109, 0, 100, 84, 60, 115, 116, 95, 112, 97, 60, 115, 119, 58, 116, 115, 97, 42, 97, 115, 58, 116, 97, 71, 58, 105, 65, 97, 110, 99, 115, 100, 108, 97, 60, 115, 119, 58, 109, 110, 116, 32};
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Renderers/GDIPlus.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Renderers/GDIPlus.h
new file mode 100644
index 00000000..7c6383db
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Renderers/GDIPlus.h
@@ -0,0 +1,88 @@
+/*
+	GWEN
+	Copyright (c) 2011 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#ifndef GWEN_RENDERERS_GDIPLUS_H
+#define GWEN_RENDERERS_GDIPLUS_H
+
+#include "Gwen/Gwen.h"
+#include "Gwen/BaseRender.h"
+
+/*
+
+ GDI(plus) is pretty slow for rendering GWEN, because we're
+ re-rendering everything on redraw.
+
+ Therefore its usage should be as a test - rather than production.
+
+ // Note: For this to work you should be including
+
+ #include <gdiplus.h>
+
+ // Which we don't do in the header, for the sake of usability
+
+*/
+
+namespace Gwen
+{
+namespace Renderer
+{
+class GDIPlus : public Gwen::Renderer::Base
+{
+public:
+	GDIPlus(HWND pHWND);
+	~GDIPlus();
+
+	virtual void Begin();
+	virtual void End();
+
+	virtual void SetDrawColor(Gwen::Color color);
+
+	virtual void DrawLine(int x, int y, int a, int b);
+	virtual void DrawFilledRect(Gwen::Rect rect);
+
+	virtual void LoadFont(Gwen::Font* pFont);
+	virtual void FreeFont(Gwen::Font* pFont);
+	virtual void RenderText(Gwen::Font* pFont, Gwen::Point pos, const Gwen::UnicodeString& text);
+	virtual Gwen::Point MeasureText(Gwen::Font* pFont, const Gwen::UnicodeString& text);
+
+	void StartClip();
+	void EndClip();
+
+	void DrawTexturedRect(Gwen::Texture* pTexture, Gwen::Rect pTargetRect, float u1 = 0.0f, float v1 = 0.0f, float u2 = 1.0f, float v2 = 1.0f);
+	void LoadTexture(Gwen::Texture* pTexture);
+	void FreeTexture(Gwen::Texture* pTexture);
+
+protected:
+	int m_iWidth;
+	int m_iHeight;
+
+	Gdiplus::Color m_Colour;
+
+	HWND m_HWND;
+	HDC m_hDC;
+	ULONG_PTR m_gdiplusToken;
+
+	Gdiplus::Graphics* graphics;
+};
+
+class GDIPlusBuffered : public GDIPlus
+{
+public:
+	GDIPlusBuffered(HWND pHWND);
+	~GDIPlusBuffered();
+
+	virtual void Begin();
+	virtual void End();
+
+private:
+	void CreateBackbuffer();
+	void DestroyBackbuffer();
+
+	Gdiplus::Bitmap* m_Bitmap;
+};
+}  // namespace Renderer
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Renderers/OpenGL.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Renderers/OpenGL.h
new file mode 100644
index 00000000..986ed1df
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Renderers/OpenGL.h
@@ -0,0 +1,56 @@
+/*
+	GWEN
+	Copyright (c) 2011 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#ifndef GWEN_RENDERERS_OPENGL_H
+#define GWEN_RENDERERS_OPENGL_H
+
+#include "Gwen/Gwen.h"
+#include "Gwen/BaseRender.h"
+
+namespace Gwen
+{
+namespace Renderer
+{
+class OpenGL : public Gwen::Renderer::Base
+{
+public:
+	struct Vertex
+	{
+		float x, y, z;
+		float u, v;
+		unsigned char r, g, b, a;
+	};
+
+	OpenGL();
+	~OpenGL();
+
+	virtual void Begin();
+	virtual void End();
+
+	virtual void SetDrawColor(Gwen::Color color);
+	virtual void DrawFilledRect(Gwen::Rect rect);
+
+	void StartClip();
+	void EndClip();
+
+	void DrawTexturedRect(Gwen::Texture* pTexture, Gwen::Rect pTargetRect, float u1 = 0.0f, float v1 = 0.0f, float u2 = 1.0f, float v2 = 1.0f);
+	void LoadTexture(Gwen::Texture* pTexture);
+	void FreeTexture(Gwen::Texture* pTexture);
+
+protected:
+	static const int MaxVerts = 1024;
+
+	void Flush();
+	void AddVert(int x, int y, float u = 0.0f, float v = 0.0f);
+
+	Gwen::Color m_Color;
+	int m_iVertNum;
+	Vertex m_Vertices[MaxVerts];
+};
+
+}  // namespace Renderer
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Renderers/OpenGL_DebugFont.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Renderers/OpenGL_DebugFont.h
new file mode 100644
index 00000000..9da60f58
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Renderers/OpenGL_DebugFont.h
@@ -0,0 +1,67 @@
+/*
+	GWEN
+	Copyright (c) 2011 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#ifndef GWEN_RENDERERS_OPENGL_DEBUGFONT_H
+#define GWEN_RENDERERS_OPENGL_DEBUGFONT_H
+
+#include "../ThirdPartyLibs/Gwen/Gwen.h"
+#include "../ThirdPartyLibs/Gwen/Renderers/OpenGL.h"
+
+void restoreOpenGLState();
+void saveOpenGLState(int screenWidth, int screenHeight);
+
+namespace Gwen
+{
+namespace Renderer
+{
+class OpenGL_DebugFont : public Gwen::Renderer::Base
+{
+	float m_retinaScale;
+
+public:
+	struct Vertex
+	{
+		float x, y, z;
+		float u, v;
+		unsigned char r, g, b, a;
+	};
+
+	static const int MaxVerts = 1024;
+
+	OpenGL_DebugFont(float retinaScale);
+	~OpenGL_DebugFont();
+
+	void RenderText(Gwen::Font* pFont, Gwen::Point pos, const Gwen::UnicodeString& text);
+	Gwen::Point MeasureText(Gwen::Font* pFont, const Gwen::UnicodeString& text);
+
+	virtual void Begin();
+	virtual void End();
+
+	virtual void SetDrawColor(Gwen::Color color);
+	virtual void DrawFilledRect(Gwen::Rect rect);
+	void DrawTexturedRect(Gwen::Texture* pTexture, Gwen::Rect rect, float u1, float v1, float u2, float v2);
+
+	void StartClip();
+	void EndClip();
+
+	void Flush();
+	void AddVert(int x, int y, float u = 0.0f, float v = 0.0f);
+
+	virtual void Resize(int width, int height) {}
+
+protected:
+	Gwen::Texture* m_pFontTexture;
+	float m_fFontScale[2];
+	float m_fLetterSpacing;
+
+	Gwen::Color m_Color;
+	int m_iVertNum;
+	Vertex m_Vertices[MaxVerts];
+};
+
+}  // namespace Renderer
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Renderers/SFML.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Renderers/SFML.h
new file mode 100644
index 00000000..309ad409
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Renderers/SFML.h
@@ -0,0 +1,47 @@
+/*
+	GWEN
+	Copyright (c) 2011 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_RENDERERS_SFML_H
+#define GWEN_RENDERERS_SFML_H
+#include "Gwen/Gwen.h"
+#include "Gwen/BaseRender.h"
+#include <SFML/Graphics.hpp>
+
+namespace Gwen
+{
+namespace Renderer
+{
+class SFML : public Gwen::Renderer::Base
+{
+public:
+	SFML(sf::RenderTarget& target);
+	~SFML();
+
+	virtual void SetDrawColor(Gwen::Color color);
+
+	virtual void DrawLine(int x, int y, int a, int b);
+	virtual void DrawFilledRect(Gwen::Rect rect);
+
+	virtual void LoadFont(Gwen::Font* pFont);
+	virtual void FreeFont(Gwen::Font* pFont);
+	virtual void RenderText(Gwen::Font* pFont, Gwen::Point pos, const Gwen::UnicodeString& text);
+	virtual Gwen::Point MeasureText(Gwen::Font* pFont, const Gwen::UnicodeString& text);
+
+	void StartClip();
+	void EndClip();
+
+	void DrawTexturedRect(Gwen::Texture* pTexture, Gwen::Rect pTargetRect, float u1 = 0.0f, float v1 = 0.0f, float u2 = 1.0f, float v2 = 1.0f);
+	void LoadTexture(Gwen::Texture* pTexture);
+	void FreeTexture(Gwen::Texture* pTexture);
+
+protected:
+	sf::RenderTarget& m_Target;
+	sf::Color m_Color;
+};
+}  // namespace Renderer
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Skin.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Skin.h
new file mode 100644
index 00000000..2541ae99
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Skin.h
@@ -0,0 +1,132 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_SKIN_H
+#define GWEN_SKIN_H
+
+#include "Gwen/BaseRender.h"
+#include "Gwen/Font.h"
+
+namespace Gwen
+{
+namespace Controls
+{
+class Base;
+}
+
+namespace Skin
+{
+namespace Symbol
+{
+const unsigned char None = 0;
+const unsigned char ArrowRight = 1;
+const unsigned char Check = 2;
+const unsigned char Dot = 3;
+}  // namespace Symbol
+
+class GWEN_EXPORT Base
+{
+public:
+	Base()
+	{
+		m_DefaultFont.facename = L"Arial";
+		m_DefaultFont.size = 10.0f;
+		m_Render = NULL;
+	}
+
+	virtual ~Base()
+	{
+		ReleaseFont(&m_DefaultFont);
+	}
+
+	virtual void ReleaseFont(Gwen::Font* fnt)
+	{
+		if (!fnt) return;
+		if (!m_Render) return;
+
+		m_Render->FreeFont(fnt);
+	}
+
+	virtual void DrawButton(Controls::Base* control, bool bDepressed, bool bHovered) = 0;
+	virtual void DrawTabButton(Controls::Base* control, bool bActive) = 0;
+	virtual void DrawTabControl(Controls::Base* control, Gwen::Rect CurrentButtonRect) = 0;
+	virtual void DrawTabTitleBar(Controls::Base* control) = 0;
+
+	virtual void DrawMenuItem(Controls::Base* control, bool bSubmenuOpen, bool bChecked) = 0;
+	virtual void DrawMenuStrip(Controls::Base* control) = 0;
+	virtual void DrawMenu(Controls::Base* control, bool bPaddingDisabled) = 0;
+	virtual void DrawRadioButton(Controls::Base* control, bool bSelected, bool bDepressed) = 0;
+	virtual void DrawCheckBox(Controls::Base* control, bool bSelected, bool bDepressed) = 0;
+	virtual void DrawGroupBox(Controls::Base* control, int textStart, int textHeight, int textWidth) = 0;
+	virtual void DrawTextBox(Controls::Base* control) = 0;
+	virtual void DrawWindow(Controls::Base* control, int topHeight, bool inFocus) = 0;
+	virtual void DrawHighlight(Controls::Base* control) = 0;
+	virtual void DrawBackground(Controls::Base* control) = 0;
+	virtual void DrawStatusBar(Controls::Base* control) = 0;
+
+	virtual void DrawShadow(Controls::Base* control) = 0;
+	virtual void DrawScrollBarBar(Controls::Base* control, bool bDepressed, bool isHovered, bool isHorizontal) = 0;
+	virtual void DrawScrollBar(Controls::Base* control, bool isHorizontal, bool bDepressed) = 0;
+	virtual void DrawScrollButton(Controls::Base* control, int iDirection, bool bDepressed) = 0;
+	virtual void DrawProgressBar(Controls::Base* control, bool isHorizontal, float progress) = 0;
+
+	virtual void DrawListBox(Controls::Base* control) = 0;
+	virtual void DrawListBoxLine(Controls::Base* control, bool bSelected) = 0;
+
+	virtual void DrawSlider(Controls::Base* control, bool bIsHorizontal, int numNotches, int barSize) = 0;
+	virtual void DrawComboBox(Controls::Base* control) = 0;
+	virtual void DrawComboBoxButton(Controls::Base* control, bool bDepressed) = 0;
+	virtual void DrawKeyboardHighlight(Controls::Base* control, const Gwen::Rect& rect, int offset) = 0;
+	//virtual void DrawComboBoxKeyboardHighlight( Controls::Base* control );
+	virtual void DrawToolTip(Controls::Base* control) = 0;
+
+	virtual void DrawNumericUpDownButton(Controls::Base* control, bool bDepressed, bool bUp) = 0;
+
+	virtual void DrawTreeButton(Controls::Base* control, bool bOpen) = 0;
+	virtual void DrawTreeControl(Controls::Base* control) = 0;
+	virtual void DrawTreeNode(Controls::Base* ctrl, bool bOpen, bool bSelected, int iLabelHeight, int iLabelWidth, int iHalfWay, int iLastBranch, bool bIsRoot) = 0;
+
+	virtual void DrawPropertyRow(Controls::Base* control, int iWidth, bool bBeingEdited) = 0;
+	virtual void DrawPropertyTreeNode(Controls::Base* control, int BorderLeft, int BorderTop) = 0;
+	virtual void DrawColorDisplay(Controls::Base* control, Gwen::Color color) = 0;
+	virtual void DrawModalControl(Controls::Base* control) = 0;
+	virtual void DrawMenuDivider(Controls::Base* control) = 0;
+
+	virtual void SetRender(Gwen::Renderer::Base* renderer)
+	{
+		m_Render = renderer;
+	}
+	virtual Gwen::Renderer::Base* GetRender()
+	{
+		return m_Render;
+	}
+
+	virtual void DrawArrowDown(Gwen::Rect rect);
+	virtual void DrawArrowUp(Gwen::Rect rect);
+	virtual void DrawArrowLeft(Gwen::Rect rect);
+	virtual void DrawArrowRight(Gwen::Rect rect);
+	virtual void DrawCheck(Gwen::Rect rect);
+
+public:
+	virtual Gwen::Font* GetDefaultFont()
+	{
+		return &m_DefaultFont;
+	}
+
+	virtual void SetDefaultFont(const Gwen::UnicodeString& strFacename, float fSize = 10.0f)
+	{
+		m_DefaultFont.facename = strFacename;
+		m_DefaultFont.size = fSize;
+	}
+
+protected:
+	Gwen::Font m_DefaultFont;
+	Gwen::Renderer::Base* m_Render;
+};
+};  // namespace Skin
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Skins/Simple.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Skins/Simple.h
new file mode 100644
index 00000000..d9c71c20
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Skins/Simple.h
@@ -0,0 +1,764 @@
+#pragma once
+#ifndef GWEN_SKINS_SIMPLE_H
+#define GWEN_SKINS_SIMPLE_H
+
+#include "Gwen/Skin.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Controls/Base.h"
+
+namespace Gwen
+{
+namespace Skin
+{
+class Simple : public Gwen::Skin::Base
+{
+public:
+	Gwen::Color m_colBorderColor;
+	Gwen::Color m_colControlOutlineLight;
+	Gwen::Color m_colControlOutlineLighter;
+	Gwen::Color m_colBG;
+	Gwen::Color m_colBGDark;
+	Gwen::Color m_colControl;
+	Gwen::Color m_colControlBorderHighlight;
+	Gwen::Color m_colControlDarker;
+	Gwen::Color m_colControlOutlineNormal;
+	Gwen::Color m_colControlBright;
+	Gwen::Color m_colControlDark;
+	Gwen::Color m_colHighlightBG;
+	Gwen::Color m_colHighlightBorder;
+	Gwen::Color m_colToolTipBackground;
+	Gwen::Color m_colToolTipBorder;
+	Gwen::Color m_colModal;
+
+	Simple()
+	{
+		m_colBorderColor = Gwen::Color(80, 80, 80, 255);
+		m_colBG = Gwen::Color(248, 248, 248, 255);
+		m_colBGDark = Gwen::Color(235, 235, 235, 255);
+
+		m_colControl = Gwen::Color(240, 240, 240, 255);
+		m_colControlBright = Gwen::Color(255, 255, 255, 255);
+		m_colControlDark = Gwen::Color(214, 214, 214, 255);
+		m_colControlDarker = Gwen::Color(180, 180, 180, 255);
+
+		m_colControlOutlineNormal = Gwen::Color(112, 112, 112, 255);
+		m_colControlOutlineLight = Gwen::Color(144, 144, 144, 255);
+		m_colControlOutlineLighter = Gwen::Color(210, 210, 210, 255);
+
+		m_colHighlightBG = Gwen::Color(192, 221, 252, 255);
+		m_colHighlightBorder = Gwen::Color(51, 153, 255, 255);
+
+		m_colToolTipBackground = Gwen::Color(255, 255, 225, 255);
+		m_colToolTipBorder = Gwen::Color(0, 0, 0, 255);
+
+		m_colModal = Gwen::Color(25, 25, 25, 150);
+
+		m_DefaultFont.facename = L"Microsoft Sans Serif";
+		m_DefaultFont.size = 11;
+	}
+
+	virtual void DrawButton(Gwen::Controls::Base* control, bool bDepressed, bool bHovered)
+	{
+		int w = control->Width();
+		int h = control->Height();
+
+		DrawButton(w, h, bDepressed, bHovered);
+	}
+
+	virtual void DrawMenuItem(Gwen::Controls::Base* control, bool bSubmenuOpen, bool bChecked)
+	{
+		if (bSubmenuOpen || control->IsHovered())
+		{
+			m_Render->SetDrawColor(m_colHighlightBG);
+			m_Render->DrawFilledRect(control->GetRenderBounds());
+
+			m_Render->SetDrawColor(m_colHighlightBorder);
+			m_Render->DrawLinedRect(control->GetRenderBounds());
+		}
+
+		//	Gwen::Rect rect = control->GetRenderBounds();
+		if (bChecked)
+		{
+			m_Render->SetDrawColor(Color(0, 0, 0, 255));
+
+			Gwen::Rect r(control->Width() / 2 - 2, control->Height() / 2 - 2, 5, 5);
+			DrawCheck(r);
+		}
+	}
+
+	virtual void DrawMenuStrip(Gwen::Controls::Base* control)
+	{
+		int w = control->Width();
+		int h = control->Height();
+
+		m_Render->SetDrawColor(Gwen::Color(246, 248, 252, 255));
+		m_Render->DrawFilledRect(Gwen::Rect(0, 0, w, h));
+
+		m_Render->SetDrawColor(Gwen::Color(218, 224, 241, 150));
+
+		m_Render->DrawFilledRect(Gwen::Rect(0, h * 0.4f, w, h * 0.6f));
+		m_Render->DrawFilledRect(Gwen::Rect(0, h * 0.5f, w, h * 0.5f));
+	}
+
+	virtual void DrawMenu(Gwen::Controls::Base* control, bool bPaddingDisabled)
+	{
+		int w = control->Width();
+		int h = control->Height();
+
+		m_Render->SetDrawColor(m_colControlBright);
+		m_Render->DrawFilledRect(Gwen::Rect(0, 0, w, h));
+
+		if (!bPaddingDisabled)
+		{
+			m_Render->SetDrawColor(m_colControl);
+			m_Render->DrawFilledRect(Gwen::Rect(1, 0, 22, h));
+		}
+
+		m_Render->SetDrawColor(m_colControlOutlineNormal);
+		m_Render->DrawLinedRect(Gwen::Rect(0, 0, w, h));
+	}
+
+	virtual void DrawShadow(Gwen::Controls::Base* control)
+	{
+		int w = control->Width();
+		int h = control->Height();
+
+		int x = 4;
+		int y = 6;
+
+		m_Render->SetDrawColor(Gwen::Color(0, 0, 0, 10));
+
+		m_Render->DrawFilledRect(Gwen::Rect(x, y, w, h));
+		x += 2;
+		m_Render->DrawFilledRect(Gwen::Rect(x, y, w, h));
+		y += 2;
+		m_Render->DrawFilledRect(Gwen::Rect(x, y, w, h));
+	}
+
+	virtual void DrawButton(int w, int h, bool bDepressed, bool bHovered, bool bSquared = false)
+	{
+		if (bDepressed)
+			m_Render->SetDrawColor(m_colControlDark);
+		else if (bHovered)
+			m_Render->SetDrawColor(m_colControlBright);
+		else
+			m_Render->SetDrawColor(m_colControl);
+
+		m_Render->DrawFilledRect(Gwen::Rect(1, 1, w - 2, h - 2));
+
+		if (bDepressed)
+			m_Render->SetDrawColor(m_colControlDark);
+		else if (bHovered)
+			m_Render->SetDrawColor(m_colControl);
+		else
+			m_Render->SetDrawColor(m_colControlDark);
+
+		m_Render->DrawFilledRect(Gwen::Rect(1, h * 0.5, w - 2, h * 0.5 - 2));
+
+		if (!bDepressed)
+		{
+			m_Render->SetDrawColor(m_colControlBright);
+			m_Render->DrawShavedCornerRect(Gwen::Rect(1, 1, w - 2, h - 2), bSquared);
+		}
+		else
+		{
+			m_Render->SetDrawColor(m_colControlDarker);
+			m_Render->DrawShavedCornerRect(Gwen::Rect(1, 1, w - 2, h - 2), bSquared);
+		}
+
+		// Border
+		m_Render->SetDrawColor(m_colControlOutlineNormal);
+		m_Render->DrawShavedCornerRect(Gwen::Rect(0, 0, w, h), bSquared);
+	}
+
+	virtual void DrawRadioButton(Gwen::Controls::Base* control, bool bSelected, bool bDepressed)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+
+		// Inside colour
+		if (control->IsHovered())
+			m_Render->SetDrawColor(Gwen::Color(220, 242, 254, 255));
+		else
+			m_Render->SetDrawColor(m_colControlBright);
+
+		m_Render->DrawFilledRect(Gwen::Rect(1, 1, rect.w - 2, rect.h - 2));
+
+		// Border
+		if (control->IsHovered())
+			m_Render->SetDrawColor(Gwen::Color(85, 130, 164, 255));
+		else
+			m_Render->SetDrawColor(m_colControlOutlineLight);
+
+		m_Render->DrawShavedCornerRect(rect);
+
+		m_Render->SetDrawColor(Gwen::Color(0, 50, 60, 15));
+		m_Render->DrawFilledRect(Gwen::Rect(rect.x + 2, rect.y + 2, rect.w - 4, rect.h - 4));
+		m_Render->DrawFilledRect(Gwen::Rect(rect.x + 2, rect.y + 2, rect.w * 0.3f, rect.h - 4));
+		m_Render->DrawFilledRect(Gwen::Rect(rect.x + 2, rect.y + 2, rect.w - 4, rect.h * 0.3f));
+
+		if (control->IsHovered())
+			m_Render->SetDrawColor(Gwen::Color(121, 198, 249, 255));
+		else
+			m_Render->SetDrawColor(Gwen::Color(0, 50, 60, 50));
+
+		m_Render->DrawFilledRect(Gwen::Rect(rect.x + 2, rect.y + 3, 1, rect.h - 5));
+		m_Render->DrawFilledRect(Gwen::Rect(rect.x + 3, rect.y + 2, rect.w - 5, 1));
+
+		if (bSelected)
+		{
+			m_Render->SetDrawColor(Gwen::Color(40, 230, 30, 255));
+			m_Render->DrawFilledRect(Gwen::Rect(rect.x + 2, rect.y + 2, rect.w - 4, rect.h - 4));
+		}
+	}
+
+	virtual void DrawCheckBox(Gwen::Controls::Base* control, bool bSelected, bool bDepressed)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+
+		// Inside colour
+		if (control->IsHovered())
+			m_Render->SetDrawColor(Gwen::Color(220, 242, 254, 255));
+		else
+			m_Render->SetDrawColor(m_colControlBright);
+
+		m_Render->DrawFilledRect(rect);
+
+		// Border
+		if (control->IsHovered())
+			m_Render->SetDrawColor(Gwen::Color(85, 130, 164, 255));
+		else
+			m_Render->SetDrawColor(m_colControlOutlineLight);
+
+		m_Render->DrawLinedRect(rect);
+
+		m_Render->SetDrawColor(Gwen::Color(0, 50, 60, 15));
+		m_Render->DrawFilledRect(Gwen::Rect(rect.x + 2, rect.y + 2, rect.w - 4, rect.h - 4));
+		m_Render->DrawFilledRect(Gwen::Rect(rect.x + 2, rect.y + 2, rect.w * 0.3f, rect.h - 4));
+		m_Render->DrawFilledRect(Gwen::Rect(rect.x + 2, rect.y + 2, rect.w - 4, rect.h * 0.3f));
+
+		if (control->IsHovered())
+			m_Render->SetDrawColor(Gwen::Color(121, 198, 249, 255));
+		else
+			m_Render->SetDrawColor(Gwen::Color(0, 50, 60, 50));
+
+		m_Render->DrawFilledRect(Gwen::Rect(rect.x + 2, rect.y + 2, 1, rect.h - 4));
+		m_Render->DrawFilledRect(Gwen::Rect(rect.x + 2, rect.y + 2, rect.w - 4, 1));
+
+		if (bDepressed)
+		{
+			m_Render->SetDrawColor(Color(100, 100, 100, 255));
+			Gwen::Rect r(control->Width() / 2 - 2, control->Height() / 2 - 2, 5, 5);
+			DrawCheck(r);
+		}
+		else if (bSelected)
+		{
+			m_Render->SetDrawColor(Color(0, 0, 0, 255));
+			Gwen::Rect r(control->Width() / 2 - 2, control->Height() / 2 - 2, 5, 5);
+			DrawCheck(r);
+		}
+	}
+
+	virtual void DrawGroupBox(Gwen::Controls::Base* control, int textStart, int textHeight, int textWidth)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+
+		rect.y += textHeight * 0.5f;
+		rect.h -= textHeight * 0.5f;
+
+		Gwen::Color m_colDarker = Gwen::Color(0, 50, 60, 50);
+		Gwen::Color m_colLighter = Gwen::Color(255, 255, 255, 150);
+
+		m_Render->SetDrawColor(m_colLighter);
+
+		m_Render->DrawFilledRect(Gwen::Rect(rect.x + 1, rect.y + 1, textStart - 3, 1));
+		m_Render->DrawFilledRect(Gwen::Rect(rect.x + 1 + textStart + textWidth, rect.y + 1, rect.w - textStart + textWidth - 2, 1));
+		m_Render->DrawFilledRect(Gwen::Rect(rect.x + 1, (rect.y + rect.h) - 1, rect.w - 2, 1));
+
+		m_Render->DrawFilledRect(Gwen::Rect(rect.x + 1, rect.y + 1, 1, rect.h));
+		m_Render->DrawFilledRect(Gwen::Rect((rect.x + rect.w) - 2, rect.y + 1, 1, rect.h - 1));
+
+		m_Render->SetDrawColor(m_colDarker);
+
+		m_Render->DrawFilledRect(Gwen::Rect(rect.x + 1, rect.y, textStart - 3, 1));
+		m_Render->DrawFilledRect(Gwen::Rect(rect.x + 1 + textStart + textWidth, rect.y, rect.w - textStart - textWidth - 2, 1));
+		m_Render->DrawFilledRect(Gwen::Rect(rect.x + 1, (rect.y + rect.h) - 1, rect.w - 2, 1));
+
+		m_Render->DrawFilledRect(Gwen::Rect(rect.x, rect.y + 1, 1, rect.h - 1));
+		m_Render->DrawFilledRect(Gwen::Rect((rect.x + rect.w) - 1, rect.y + 1, 1, rect.h - 1));
+	}
+
+	virtual void DrawTextBox(Gwen::Controls::Base* control)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+		bool bHasFocus = control->HasFocus();
+
+		// Box inside
+		m_Render->SetDrawColor(Gwen::Color(255, 255, 255, 255));
+		m_Render->DrawFilledRect(Gwen::Rect(1, 1, rect.w - 2, rect.h - 2));
+
+		m_Render->SetDrawColor(m_colControlOutlineLight);
+		m_Render->DrawFilledRect(Gwen::Rect(rect.x + 1, rect.y, rect.w - 2, 1));
+		m_Render->DrawFilledRect(Gwen::Rect(rect.x, rect.y + 1, 1, rect.h - 2));
+
+		m_Render->SetDrawColor(m_colControlOutlineLighter);
+		m_Render->DrawFilledRect(Gwen::Rect(rect.x + 1, (rect.y + rect.h) - 1, rect.w - 2, 1));
+		m_Render->DrawFilledRect(Gwen::Rect((rect.x + rect.w) - 1, rect.y + 1, 1, rect.h - 2));
+
+		if (bHasFocus)
+		{
+			m_Render->SetDrawColor(Gwen::Color(50, 200, 255, 150));
+			m_Render->DrawLinedRect(rect);
+		}
+	}
+
+	virtual void DrawTabButton(Gwen::Controls::Base* control, bool bActive)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+		bool bHovered = control->IsHovered();
+
+		if (bActive)
+		{
+			m_Render->SetDrawColor(m_colControl);
+			m_Render->DrawFilledRect(Gwen::Rect(rect.x + 1, rect.y + 1, rect.w - 2, rect.h - 1));
+		}
+		else
+		{
+			if (bHovered)
+				m_Render->SetDrawColor(m_colControlBright);
+			else
+				m_Render->SetDrawColor(m_colControl);
+
+			m_Render->DrawFilledRect(Gwen::Rect(1, 1, rect.w - 2, rect.h - 1));
+
+			if (bHovered)
+				m_Render->SetDrawColor(m_colControl);
+			else
+				m_Render->SetDrawColor(m_colControlDark);
+
+			m_Render->DrawFilledRect(Gwen::Rect(1, rect.h * 0.5, rect.w - 2, rect.h * 0.5 - 1));
+
+			m_Render->SetDrawColor(m_colControlBright);
+			m_Render->DrawShavedCornerRect(Gwen::Rect(1, 1, rect.w - 2, rect.h));
+		}
+
+		m_Render->SetDrawColor(m_colBorderColor);
+
+		m_Render->DrawShavedCornerRect(Gwen::Rect(0, 0, rect.w, rect.h));
+	}
+
+	virtual void DrawTabControl(Gwen::Controls::Base* control, Gwen::Rect CurrentButtonRect)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+
+		m_Render->SetDrawColor(m_colControl);
+		m_Render->DrawFilledRect(rect);
+
+		m_Render->SetDrawColor(m_colBorderColor);
+		m_Render->DrawLinedRect(rect);
+
+		m_Render->SetDrawColor(m_colControl);
+		m_Render->DrawFilledRect(CurrentButtonRect);
+	}
+
+	virtual void DrawWindow(Gwen::Controls::Base* control, int topHeight, bool inFocus)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+
+		// Titlebar
+		if (inFocus)
+			m_Render->SetDrawColor(Gwen::Color(87, 164, 232, 230));
+		else
+			m_Render->SetDrawColor(Gwen::Color(87 * 0.70, 164 * 0.70, 232 * 0.70, 230));
+
+		int iBorderSize = 5;
+		m_Render->DrawFilledRect(Gwen::Rect(rect.x + 1, rect.y + 1, rect.w - 2, topHeight - 1));
+		m_Render->DrawFilledRect(Gwen::Rect(rect.x + 1, rect.y + topHeight - 1, iBorderSize, rect.h - 2 - topHeight));
+		m_Render->DrawFilledRect(Gwen::Rect(rect.x + rect.w - iBorderSize, rect.y + topHeight - 1, iBorderSize, rect.h - 2 - topHeight));
+		m_Render->DrawFilledRect(Gwen::Rect(rect.x + 1, rect.y + rect.h - iBorderSize, rect.w - 2, iBorderSize));
+
+		// Main inner
+		m_Render->SetDrawColor(Gwen::Color(m_colControlDark.r, m_colControlDark.g, m_colControlDark.b, 230));
+		m_Render->DrawFilledRect(Gwen::Rect(rect.x + iBorderSize + 1, rect.y + topHeight, rect.w - iBorderSize * 2 - 2, rect.h - topHeight - iBorderSize - 1));
+
+		// Light inner border
+		m_Render->SetDrawColor(Gwen::Color(255, 255, 255, 100));
+		m_Render->DrawShavedCornerRect(Gwen::Rect(rect.x + 1, rect.y + 1, rect.w - 2, rect.h - 2));
+
+		// Dark line between titlebar and main
+		m_Render->SetDrawColor(m_colBorderColor);
+
+		// Inside border
+		m_Render->SetDrawColor(m_colControlOutlineNormal);
+		m_Render->DrawLinedRect(Gwen::Rect(rect.x + iBorderSize, rect.y + topHeight - 1, rect.w - 10, rect.h - topHeight - (iBorderSize - 1)));
+
+		// Dark outer border
+		m_Render->SetDrawColor(m_colBorderColor);
+		m_Render->DrawShavedCornerRect(Gwen::Rect(rect.x, rect.y, rect.w, rect.h));
+	}
+
+	virtual void DrawHighlight(Gwen::Controls::Base* control)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+		m_Render->SetDrawColor(Gwen::Color(255, 100, 255, 255));
+		m_Render->DrawFilledRect(rect);
+	}
+
+	virtual void DrawScrollBar(Gwen::Controls::Base* control, bool isHorizontal, bool bDepressed)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+		if (bDepressed)
+			m_Render->SetDrawColor(m_colControlDarker);
+		else
+			m_Render->SetDrawColor(m_colControlBright);
+		m_Render->DrawFilledRect(rect);
+	}
+
+	virtual void DrawScrollBarBar(Controls::Base* control, bool bDepressed, bool isHovered, bool isHorizontal)
+	{
+		//TODO: something specialized
+		DrawButton(control, bDepressed, isHovered);
+	}
+
+	virtual void DrawTabTitleBar(Gwen::Controls::Base* control)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+
+		m_Render->SetDrawColor(Gwen::Color(177, 193, 214, 255));
+		m_Render->DrawFilledRect(rect);
+
+		m_Render->SetDrawColor(m_colBorderColor);
+		rect.h += 1;
+		m_Render->DrawLinedRect(rect);
+	}
+
+	virtual void DrawProgressBar(Gwen::Controls::Base* control, bool isHorizontal, float progress)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+		Gwen::Color FillColour(0, 211, 40, 255);
+
+		if (isHorizontal)
+		{
+			//Background
+			m_Render->SetDrawColor(m_colControlDark);
+			m_Render->DrawFilledRect(Gwen::Rect(1, 1, rect.w - 2, rect.h - 2));
+
+			//Right half
+			m_Render->SetDrawColor(FillColour);
+			m_Render->DrawFilledRect(Gwen::Rect(1, 1, rect.w * progress - 2, rect.h - 2));
+
+			m_Render->SetDrawColor(Gwen::Color(255, 255, 255, 150));
+			m_Render->DrawFilledRect(Gwen::Rect(1, 1, rect.w - 2, rect.h * 0.45f));
+		}
+		else
+		{
+			//Background
+			m_Render->SetDrawColor(m_colControlDark);
+			m_Render->DrawFilledRect(Gwen::Rect(1, 1, rect.w - 2, rect.h - 2));
+
+			//Top half
+			m_Render->SetDrawColor(FillColour);
+			m_Render->DrawFilledRect(Gwen::Rect(1, 1 + (rect.h * (1 - progress)), rect.w - 2, rect.h * progress - 2));
+
+			m_Render->SetDrawColor(Gwen::Color(255, 255, 255, 150));
+			m_Render->DrawFilledRect(Gwen::Rect(1, 1, rect.w * 0.45f, rect.h - 2));
+		}
+
+		m_Render->SetDrawColor(Gwen::Color(255, 255, 255, 150));
+		m_Render->DrawShavedCornerRect(Gwen::Rect(1, 1, rect.w - 2, rect.h - 2));
+
+		m_Render->SetDrawColor(Gwen::Color(255, 255, 255, 70));
+		m_Render->DrawShavedCornerRect(Gwen::Rect(2, 2, rect.w - 4, rect.h - 4));
+
+		m_Render->SetDrawColor(m_colBorderColor);
+		m_Render->DrawShavedCornerRect(rect);
+	}
+
+	virtual void DrawListBox(Gwen::Controls::Base* control)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+
+		m_Render->SetDrawColor(m_colControlBright);
+		m_Render->DrawFilledRect(rect);
+
+		m_Render->SetDrawColor(m_colBorderColor);
+		m_Render->DrawLinedRect(rect);
+	}
+
+	virtual void DrawListBoxLine(Gwen::Controls::Base* control, bool bSelected)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+
+		if (bSelected)
+		{
+			m_Render->SetDrawColor(m_colHighlightBorder);
+			m_Render->DrawFilledRect(rect);
+		}
+		else if (control->IsHovered())
+		{
+			m_Render->SetDrawColor(m_colHighlightBG);
+			m_Render->DrawFilledRect(rect);
+		}
+	}
+
+	virtual void DrawSlider(Gwen::Controls::Base* control, bool bIsHorizontal, int numNotches, int barSize)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+		//					Gwen::Rect notchRect = rect;
+
+		if (bIsHorizontal)
+		{
+			rect.y += rect.h * 0.4;
+			rect.h -= rect.h * 0.8;
+		}
+		else
+		{
+			rect.x += rect.w * 0.4;
+			rect.w -= rect.w * 0.8;
+		}
+
+		m_Render->SetDrawColor(m_colBGDark);
+		m_Render->DrawFilledRect(rect);
+
+		m_Render->SetDrawColor(m_colControlDarker);
+		m_Render->DrawLinedRect(rect);
+	}
+
+	virtual void DrawComboBox(Gwen::Controls::Base* control)
+	{
+		DrawTextBox(control);
+	}
+
+	virtual void DrawBackground(Gwen::Controls::Base* control)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+		m_Render->SetDrawColor(m_colBGDark);
+		m_Render->DrawFilledRect(rect);
+		m_Render->SetDrawColor(m_colControlDarker);
+		m_Render->DrawLinedRect(rect);
+	}
+
+	virtual void DrawKeyboardHighlight(Gwen::Controls::Base* control, const Gwen::Rect& r, int iOffset)
+	{
+		Gwen::Rect rect = r;
+
+		rect.x += iOffset;
+		rect.y += iOffset;
+		rect.w -= iOffset * 2;
+		rect.h -= iOffset * 2;
+
+		//draw the top and bottom
+		bool skip = true;
+		for (int i = 0; i < rect.w * 0.5; i++)
+		{
+			m_Render->SetDrawColor(Gwen::Color(0, 0, 0, 255));
+			if (!skip)
+			{
+				m_Render->DrawPixel(rect.x + (i * 2), rect.y);
+				m_Render->DrawPixel(rect.x + (i * 2), rect.y + rect.h - 1);
+			}
+			else
+				skip = !skip;
+		}
+		skip = false;
+		for (int i = 0; i < rect.h * 0.5; i++)
+		{
+			m_Render->SetDrawColor(Gwen::Color(0, 0, 0, 255));
+			if (!skip)
+			{
+				m_Render->DrawPixel(rect.x, rect.y + i * 2);
+				m_Render->DrawPixel(rect.x + rect.w - 1, rect.y + i * 2);
+			}
+			else
+				skip = !skip;
+		}
+	}
+
+	virtual void DrawToolTip(Gwen::Controls::Base* control)
+	{
+		Gwen::Rect rct = control->GetRenderBounds();
+		rct.x -= 3;
+		rct.y -= 3;
+		rct.w += 6;
+		rct.h += 6;
+
+		m_Render->SetDrawColor(m_colToolTipBackground);
+		m_Render->DrawFilledRect(rct);
+
+		m_Render->SetDrawColor(m_colToolTipBorder);
+		m_Render->DrawLinedRect(rct);
+	}
+
+	virtual void DrawScrollButton(Gwen::Controls::Base* control, int iDirection, bool bDepressed)
+	{
+		DrawButton(control, bDepressed, false);
+
+		m_Render->SetDrawColor(Gwen::Color(0, 0, 0, 240));
+
+		Gwen::Rect r(control->Width() / 2 - 2, control->Height() / 2 - 2, 5, 5);
+
+		if (iDirection == Gwen::Pos::Top)
+			DrawArrowUp(r);
+		else if (iDirection == Gwen::Pos::Bottom)
+			DrawArrowDown(r);
+		else if (iDirection == Gwen::Pos::Left)
+			DrawArrowLeft(r);
+		else
+			DrawArrowRight(r);
+	}
+
+	virtual void DrawComboBoxButton(Gwen::Controls::Base* control, bool bDepressed)
+	{
+		//DrawButton( control->Width(), control->Height(), bDepressed, false, true );
+
+		m_Render->SetDrawColor(Gwen::Color(0, 0, 0, 240));
+
+		Gwen::Rect r(control->Width() / 2 - 2, control->Height() / 2 - 2, 5, 5);
+		DrawArrowDown(r);
+	}
+
+	virtual void DrawNumericUpDownButton(Gwen::Controls::Base* control, bool bDepressed, bool bUp)
+	{
+		//DrawButton( control->Width(), control->Height(), bDepressed, false, true );
+
+		m_Render->SetDrawColor(Gwen::Color(0, 0, 0, 240));
+
+		Gwen::Rect r(control->Width() / 2 - 2, control->Height() / 2 - 2, 5, 5);
+
+		if (bUp)
+			DrawArrowUp(r);
+		else
+			DrawArrowDown(r);
+	}
+
+	virtual void DrawTreeButton(Controls::Base* control, bool bOpen)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+		rect.x += 2;
+		rect.y += 2;
+		rect.w -= 4;
+		rect.h -= 4;
+
+		m_Render->SetDrawColor(m_colControlBright);
+		m_Render->DrawFilledRect(rect);
+
+		m_Render->SetDrawColor(m_colBorderColor);
+		m_Render->DrawLinedRect(rect);
+
+		m_Render->SetDrawColor(m_colBorderColor);
+
+		if (!bOpen)  // ! because the button shows intention, not the current state
+			m_Render->DrawFilledRect(Gwen::Rect(rect.x + rect.w / 2, rect.y + 2, 1, rect.h - 4));
+
+		m_Render->DrawFilledRect(Gwen::Rect(rect.x + 2, rect.y + rect.h / 2, rect.w - 4, 1));
+	}
+
+	virtual void DrawTreeControl(Controls::Base* control)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+
+		m_Render->SetDrawColor(m_colControlBright);
+		m_Render->DrawFilledRect(rect);
+
+		m_Render->SetDrawColor(m_colBorderColor);
+		m_Render->DrawLinedRect(rect);
+	}
+
+	void DrawTreeNode(Controls::Base* ctrl, bool bOpen, bool bSelected, int iLabelHeight, int iLabelWidth, int iHalfWay, int iLastBranch, bool bIsRoot)
+	{
+		if (bSelected)
+		{
+			m_Render->SetDrawColor(Color(0, 150, 255, 100));
+			m_Render->DrawFilledRect(Gwen::Rect(17, 0, iLabelWidth + 2, iLabelHeight - 1));
+			m_Render->SetDrawColor(Color(0, 150, 255, 200));
+			m_Render->DrawLinedRect(Gwen::Rect(17, 0, iLabelWidth + 2, iLabelHeight - 1));
+		}
+
+		m_Render->SetDrawColor(Color(0, 0, 0, 50));
+
+		if (!bIsRoot)
+			m_Render->DrawFilledRect(Gwen::Rect(9, iHalfWay, 16 - 9, 1));
+
+		if (!bOpen) return;
+
+		m_Render->DrawFilledRect(Gwen::Rect(14 + 8, iLabelHeight, 1, iLastBranch + iHalfWay - iLabelHeight));
+	}
+
+	virtual void DrawStatusBar(Controls::Base* control)
+	{
+		DrawBackground(control);
+	}
+
+	virtual void DrawPropertyRow(Controls::Base* control, int iWidth, bool bBeingEdited)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+
+		if (bBeingEdited)
+		{
+			m_Render->SetDrawColor(m_colHighlightBG);
+			m_Render->DrawFilledRect(Gwen::Rect(0, rect.y, iWidth, rect.h));
+		}
+
+		m_Render->SetDrawColor(m_colControlOutlineLighter);
+
+		m_Render->DrawFilledRect(Gwen::Rect(iWidth, rect.y, 1, rect.h));
+
+		rect.y += rect.h - 1;
+		rect.h = 1;
+
+		m_Render->DrawFilledRect(rect);
+	}
+
+	virtual void DrawPropertyTreeNode(Controls::Base* control, int BorderLeft, int BorderTop)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+
+		m_Render->SetDrawColor(m_colControlOutlineLighter);
+
+		m_Render->DrawFilledRect(Gwen::Rect(rect.x, rect.y, BorderLeft, rect.h));
+		m_Render->DrawFilledRect(Gwen::Rect(rect.x + BorderLeft, rect.y, rect.w - BorderLeft, BorderTop));
+	}
+
+	void DrawColorDisplay(Controls::Base* control, Gwen::Color color)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+
+		if (color.a != 255)
+		{
+			GetRender()->SetDrawColor(Gwen::Color(255, 255, 255, 255));
+			GetRender()->DrawFilledRect(rect);
+
+			GetRender()->SetDrawColor(Gwen::Color(128, 128, 128, 128));
+
+			GetRender()->DrawFilledRect(Gwen::Rect(0, 0, rect.w * 0.5, rect.h * 0.5));
+			GetRender()->DrawFilledRect(Gwen::Rect(rect.w * 0.5, rect.h * 0.5, rect.w * 0.5, rect.h * 0.5));
+		}
+
+		GetRender()->SetDrawColor(color);
+		GetRender()->DrawFilledRect(rect);
+
+		GetRender()->SetDrawColor(Gwen::Color(0, 0, 0, 255));
+		GetRender()->DrawLinedRect(rect);
+	}
+
+	virtual void DrawModalControl(Controls::Base* control)
+	{
+		if (control->ShouldDrawBackground())
+		{
+			Gwen::Rect rect = control->GetRenderBounds();
+			GetRender()->SetDrawColor(m_colModal);
+			GetRender()->DrawFilledRect(rect);
+		}
+	}
+
+	virtual void DrawMenuDivider(Controls::Base* control)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+		GetRender()->SetDrawColor(m_colBGDark);
+		GetRender()->DrawFilledRect(rect);
+		GetRender()->SetDrawColor(m_colControlDarker);
+		GetRender()->DrawLinedRect(rect);
+	}
+};
+}  // namespace Skin
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Skins/TexturedBase.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Skins/TexturedBase.h
new file mode 100644
index 00000000..c0529cdb
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Skins/TexturedBase.h
@@ -0,0 +1,614 @@
+#pragma once
+#ifndef GWEN_SKINS_TEXTUREDBASE_H
+#define GWEN_SKINS_TEXTUREDBASE_H
+
+#include "Gwen/Skin.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Texture.h"
+#include "Gwen/Skins/Texturing.h"
+
+namespace Gwen
+{
+namespace Skin
+{
+class TexturedBase : public Gwen::Skin::Base
+{
+public:
+	Gwen::Color m_colBorderColor;
+	Gwen::Color m_colControlOutlineLight;
+	Gwen::Color m_colControlOutlineLighter;
+	Gwen::Color m_colBG;
+	Gwen::Color m_colBGDark;
+	Gwen::Color m_colControl;
+	Gwen::Color m_colControlBorderHighlight;
+	Gwen::Color m_colControlDarker;
+	Gwen::Color m_colControlOutlineNormal;
+	Gwen::Color m_colControlBright;
+	Gwen::Color m_colControlDark;
+	Gwen::Color m_colHighlightBG;
+	Gwen::Color m_colHighlightBorder;
+	Gwen::Color m_colToolTipBackground;
+	Gwen::Color m_colToolTipBorder;
+	Gwen::Color m_colModal;
+
+	Texture m_Texture;
+
+	Texturing::Bordered m_texButton;
+	Texturing::Bordered m_texButton_Hovered;
+	Texturing::Bordered m_texButton_Pressed;
+
+	Texturing::Bordered m_texMenu_Strip, m_texMenu_Panel, m_texMenu_Panel_Border;
+	Texturing::Bordered m_texMenu_Hover;
+	Texturing::Bordered m_texShadow;
+
+	Texturing::Bordered m_texTextBox, m_texTextBox_Focus;
+
+	Texturing::Bordered m_texTab_Control, m_texTab, m_texTab_Inactive, m_texTab_Gap, m_texTabBar;
+
+	Texturing::Bordered m_texWindow, m_texWindow_Inactive;
+	Texturing::Bordered m_texTreeBG;
+
+	Texturing::Single m_Checkbox, m_Checkbox_Checked;
+	Texturing::Single m_RadioButton, m_RadioButton_Checked;
+
+	Texturing::Single m_CheckMark;
+
+	Texturing::Single m_TreeMinus, m_TreePlus;
+
+	virtual void Init(const TextObject& TextureName)
+	{
+		m_colBorderColor = Gwen::Color(80, 80, 80, 255);
+		m_colBG = Gwen::Color(248, 248, 248, 255);
+		m_colBGDark = Gwen::Color(235, 235, 235, 255);
+
+		m_colControl = Gwen::Color(240, 240, 240, 255);
+		m_colControlBright = Gwen::Color(255, 255, 255, 255);
+		m_colControlDark = Gwen::Color(214, 214, 214, 255);
+		m_colControlDarker = Gwen::Color(180, 180, 180, 255);
+
+		m_colControlOutlineNormal = Gwen::Color(112, 112, 112, 255);
+		m_colControlOutlineLight = Gwen::Color(144, 144, 144, 255);
+		m_colControlOutlineLighter = Gwen::Color(210, 210, 210, 255);
+
+		m_colHighlightBG = Gwen::Color(192, 221, 252, 255);
+		m_colHighlightBorder = Gwen::Color(51, 153, 255, 255);
+
+		m_colToolTipBackground = Gwen::Color(255, 255, 225, 255);
+		m_colToolTipBorder = Gwen::Color(0, 0, 0, 255);
+
+		m_colModal = Gwen::Color(25, 25, 25, 150);
+
+		m_DefaultFont.facename = L"Microsoft Sans Serif";
+		m_DefaultFont.size = 11;
+
+		m_Texture.Load(TextureName, GetRender());
+
+		m_texButton.Init(&m_Texture, 194, 0, 24, 24, Margin(8, 8, 8, 8));
+		m_texButton_Hovered.Init(&m_Texture, 194, 25, 24, 24, Margin(8, 8, 8, 8));
+		m_texButton_Pressed.Init(&m_Texture, 194, 50, 24, 24, Margin(8, 8, 8, 8));
+
+		m_texMenu_Strip.Init(&m_Texture, 194, 75, 62, 21, Margin(8, 8, 8, 8));
+		m_texMenu_Panel.Init(&m_Texture, 194, 130, 62, 32, Margin(8, 8, 8, 8));
+		m_texMenu_Panel_Border.Init(&m_Texture, 194, 97, 62, 32, Margin(24, 8, 8, 8));
+		m_texMenu_Hover.Init(&m_Texture, 219, 50, 24, 24, Margin(8, 8, 8, 8));
+
+		m_texShadow.Init(&m_Texture, 223, 0, 32, 32, Margin(8, 8, 8, 8));
+
+		m_texTextBox.Init(&m_Texture, 0, 122, 24, 24, Margin(8, 8, 8, 8));
+		m_texTextBox_Focus.Init(&m_Texture, 25, 122, 24, 24, Margin(8, 8, 8, 8));
+
+		m_texTab.Init(&m_Texture, 0, 97, 24, 24, Margin(8, 8, 8, 8));
+		m_texTab_Inactive.Init(&m_Texture, 25, 97, 24, 24, Margin(8, 8, 8, 8));
+		m_texTab_Control.Init(&m_Texture, 50, 97, 24, 24, Margin(8, 8, 8, 8));
+		m_texTab_Gap.Init(&m_Texture, 50 + 8, 97 + 8, 8, 8, Margin(8, 8, 8, 8));
+		m_texTabBar.Init(&m_Texture, 0, 147, 74, 16, Margin(4, 4, 4, 4));
+
+		m_texWindow.Init(&m_Texture, 0, 0, 96, 96, Margin(16, 32, 16, 16));
+		m_texWindow_Inactive.Init(&m_Texture, 97, 0, 96, 96, Margin(16, 32, 16, 16));
+
+		m_Checkbox.Init(&m_Texture, 75, 97, 16, 16);
+		m_Checkbox_Checked.Init(&m_Texture, 93, 97, 16, 16);
+
+		m_RadioButton.Init(&m_Texture, 110, 97, 16, 16);
+		m_RadioButton_Checked.Init(&m_Texture, 127, 97, 16, 16);
+
+		m_CheckMark.Init(&m_Texture, 145, 97, 16, 16);
+		m_TreeMinus.Init(&m_Texture, 75, 115, 11, 11);
+		m_TreePlus.Init(&m_Texture, 93, 115, 11, 11);
+
+		m_texTreeBG.Init(&m_Texture, 0, 164, 49, 49, Margin(16, 16, 16, 16));
+	}
+
+	virtual void DrawButton(Gwen::Controls::Base* control, bool bDepressed, bool bHovered)
+	{
+		if (bDepressed)
+			m_texButton_Pressed.Draw(GetRender(), control->GetRenderBounds());
+		else
+			m_texButton.Draw(GetRender(), control->GetRenderBounds());
+
+		if (bHovered)
+			m_texButton_Hovered.Draw(GetRender(), control->GetRenderBounds());
+	}
+
+	virtual void DrawMenuItem(Gwen::Controls::Base* control, bool bSubmenuOpen, bool bChecked)
+	{
+		if (bSubmenuOpen || control->IsHovered())
+			m_texMenu_Hover.Draw(GetRender(), control->GetRenderBounds());
+
+		if (bChecked)
+			m_CheckMark.Draw(GetRender(), Gwen::Rect(control->GetRenderBounds().x + 2, control->GetRenderBounds().y + 2, 16, 16));
+	}
+
+	virtual void DrawMenuStrip(Gwen::Controls::Base* control)
+	{
+		m_texMenu_Strip.Draw(GetRender(), control->GetRenderBounds());
+	}
+
+	virtual void DrawMenu(Gwen::Controls::Base* control, bool bPaddingDisabled)
+	{
+		if (!bPaddingDisabled)
+		{
+			return m_texMenu_Panel_Border.Draw(GetRender(), control->GetRenderBounds());
+		}
+
+		m_texMenu_Panel.Draw(GetRender(), control->GetRenderBounds());
+	}
+
+	virtual void DrawShadow(Gwen::Controls::Base* control)
+	{
+		Gwen::Rect r = control->GetRenderBounds();
+		r.x -= 8;
+		r.y -= 8;
+		r.w += 16;
+		r.h += 16;
+		//	m_texShadow.Draw( r );
+	}
+
+	virtual void DrawRadioButton(Gwen::Controls::Base* control, bool bSelected, bool bDepressed)
+	{
+		if (bSelected)
+			m_RadioButton_Checked.Draw(GetRender(), control->GetRenderBounds());
+		else
+			m_RadioButton.Draw(GetRender(), control->GetRenderBounds());
+	}
+
+	virtual void DrawCheckBox(Gwen::Controls::Base* control, bool bSelected, bool bDepressed)
+	{
+		if (bSelected)
+			m_Checkbox_Checked.Draw(GetRender(), control->GetRenderBounds());
+		else
+			m_Checkbox.Draw(GetRender(), control->GetRenderBounds());
+	}
+
+	virtual void DrawGroupBox(Gwen::Controls::Base* control, int textStart, int textHeight, int textWidth)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+
+		rect.y += textHeight * 0.5f;
+		rect.h -= textHeight * 0.5f;
+
+		Gwen::Color m_colDarker = Gwen::Color(0, 50, 60, 50);
+		Gwen::Color m_colLighter = Gwen::Color(255, 255, 255, 150);
+
+		GetRender()->SetDrawColor(m_colLighter);
+
+		GetRender()->DrawFilledRect(Gwen::Rect(rect.x + 1, rect.y + 1, textStart - 3, 1));
+		GetRender()->DrawFilledRect(Gwen::Rect(rect.x + 1 + textStart + textWidth, rect.y + 1, rect.w - textStart + textWidth - 2, 1));
+		GetRender()->DrawFilledRect(Gwen::Rect(rect.x + 1, (rect.y + rect.h) - 1, rect.x + rect.w - 2, 1));
+
+		GetRender()->DrawFilledRect(Gwen::Rect(rect.x + 1, rect.y + 1, 1, rect.h));
+		GetRender()->DrawFilledRect(Gwen::Rect((rect.x + rect.w) - 2, rect.y + 1, 1, rect.h - 1));
+
+		GetRender()->SetDrawColor(m_colDarker);
+
+		GetRender()->DrawFilledRect(Gwen::Rect(rect.x + 1, rect.y, textStart - 3, 1));
+		GetRender()->DrawFilledRect(Gwen::Rect(rect.x + 1 + textStart + textWidth, rect.y, rect.w - textStart - textWidth - 2, 1));
+		GetRender()->DrawFilledRect(Gwen::Rect(rect.x + 1, (rect.y + rect.h) - 1, rect.x + rect.w - 2, 1));
+
+		GetRender()->DrawFilledRect(Gwen::Rect(rect.x, rect.y + 1, 1, rect.h - 1));
+		GetRender()->DrawFilledRect(Gwen::Rect((rect.x + rect.w) - 1, rect.y + 1, 1, rect.h - 1));
+	}
+
+	virtual void DrawTextBox(Gwen::Controls::Base* control)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+		bool bHasFocus = control->HasFocus();
+
+		if (bHasFocus)
+			m_texTextBox_Focus.Draw(GetRender(), control->GetRenderBounds());
+		else
+			m_texTextBox.Draw(GetRender(), control->GetRenderBounds());
+
+		//I dunno what this is for yet
+		/*
+					if ( CursorRect.w == 1 )
+					{
+						if ( bHasFocus )
+						{
+							GetRender()->SetDrawColor( Gwen::Color( 0, 0, 0, 200 ) );
+							GetRender()->DrawFilledRect( CursorRect );	
+						}
+					}
+					else
+					{
+						if ( bHasFocus )
+						{
+							GetRender()->SetDrawColor( Gwen::Color( 50, 150, 255, 250 ) );
+							GetRender()->DrawFilledRect( CursorRect );	
+						}
+					}
+					*/
+	}
+
+	virtual void DrawTabButton(Gwen::Controls::Base* control, bool bActive)
+	{
+		if (bActive)
+			m_texTab.Draw(GetRender(), control->GetRenderBounds());
+		else
+			m_texTab_Inactive.Draw(GetRender(), control->GetRenderBounds());
+	}
+
+	virtual void DrawTabControl(Gwen::Controls::Base* control, Gwen::Rect CurrentButtonRect)
+	{
+		m_texTab_Control.Draw(GetRender(), control->GetRenderBounds());
+
+		if (CurrentButtonRect.w > 0 && CurrentButtonRect.h > 0)
+			m_texTab_Gap.Draw(GetRender(), CurrentButtonRect);
+	}
+
+	virtual void DrawTabTitleBar(Gwen::Controls::Base* control)
+	{
+		m_texTabBar.Draw(GetRender(), control->GetRenderBounds());
+	}
+
+	virtual void DrawWindow(Gwen::Controls::Base* control, int topHeight, bool inFocus)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+
+		if (inFocus)
+			m_texWindow.Draw(GetRender(), control->GetRenderBounds());
+		else
+			m_texWindow_Inactive.Draw(GetRender(), control->GetRenderBounds());
+	}
+
+	virtual void DrawHighlight(Gwen::Controls::Base* control)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+		GetRender()->SetDrawColor(Gwen::Color(255, 100, 255, 255));
+		GetRender()->DrawFilledRect(rect);
+	}
+
+	virtual void DrawScrollBar(Gwen::Controls::Base* control, bool isHorizontal, bool bDepressed)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+		if (bDepressed)
+			GetRender()->SetDrawColor(m_colControlDarker);
+		else
+			GetRender()->SetDrawColor(m_colControlBright);
+		GetRender()->DrawFilledRect(rect);
+	}
+
+	virtual void DrawScrollBarBar(Controls::Base* control, bool bDepressed, bool isHovered, bool isHorizontal)
+	{
+		//TODO: something specialized
+		DrawButton(control, bDepressed, isHovered);
+	}
+
+	virtual void DrawProgressBar(Gwen::Controls::Base* control, bool isHorizontal, float progress)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+		Gwen::Color FillColour(0, 211, 40, 255);
+
+		if (isHorizontal)
+		{
+			//Background
+			GetRender()->SetDrawColor(m_colControlDark);
+			GetRender()->DrawFilledRect(Gwen::Rect(1, 1, rect.w - 2, rect.h - 2));
+
+			//Right half
+			GetRender()->SetDrawColor(FillColour);
+			GetRender()->DrawFilledRect(Gwen::Rect(1, 1, rect.w * progress - 2, rect.h - 2));
+
+			GetRender()->SetDrawColor(Gwen::Color(255, 255, 255, 150));
+			GetRender()->DrawFilledRect(Gwen::Rect(1, 1, rect.w - 2, rect.h * 0.45f));
+		}
+		else
+		{
+			//Background
+			GetRender()->SetDrawColor(m_colControlDark);
+			GetRender()->DrawFilledRect(Gwen::Rect(1, 1, rect.w - 2, rect.h - 2));
+
+			//Top half
+			GetRender()->SetDrawColor(FillColour);
+			GetRender()->DrawFilledRect(Gwen::Rect(1, 1 + (rect.h * (1 - progress)), rect.w - 2, rect.h * progress - 2));
+
+			GetRender()->SetDrawColor(Gwen::Color(255, 255, 255, 150));
+			GetRender()->DrawFilledRect(Gwen::Rect(1, 1, rect.w * 0.45f, rect.h - 2));
+		}
+
+		GetRender()->SetDrawColor(Gwen::Color(255, 255, 255, 150));
+		GetRender()->DrawShavedCornerRect(Gwen::Rect(1, 1, rect.w - 2, rect.h - 2));
+
+		GetRender()->SetDrawColor(Gwen::Color(255, 255, 255, 70));
+		GetRender()->DrawShavedCornerRect(Gwen::Rect(2, 2, rect.w - 4, rect.h - 4));
+
+		GetRender()->SetDrawColor(m_colBorderColor);
+		GetRender()->DrawShavedCornerRect(rect);
+	}
+
+	virtual void DrawListBox(Gwen::Controls::Base* control)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+
+		GetRender()->SetDrawColor(m_colControlBright);
+		GetRender()->DrawFilledRect(rect);
+
+		GetRender()->SetDrawColor(m_colBorderColor);
+		GetRender()->DrawLinedRect(rect);
+	}
+
+	virtual void DrawListBoxLine(Gwen::Controls::Base* control, bool bSelected)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+
+		if (bSelected)
+		{
+			GetRender()->SetDrawColor(m_colHighlightBorder);
+			GetRender()->DrawFilledRect(rect);
+		}
+		else if (control->IsHovered())
+		{
+			GetRender()->SetDrawColor(m_colHighlightBG);
+			GetRender()->DrawFilledRect(rect);
+		}
+	}
+
+	virtual void DrawSlider(Gwen::Controls::Base* control, bool bIsHorizontal, int numNotches, int barSize)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+		Gwen::Rect notchRect = rect;
+
+		if (bIsHorizontal)
+		{
+			rect.y += rect.h * 0.4;
+			rect.h -= rect.h * 0.8;
+		}
+		else
+		{
+			rect.x += rect.w * 0.4;
+			rect.w -= rect.w * 0.8;
+		}
+
+		GetRender()->SetDrawColor(m_colBGDark);
+		GetRender()->DrawFilledRect(rect);
+
+		GetRender()->SetDrawColor(m_colControlDarker);
+		GetRender()->DrawLinedRect(rect);
+	}
+
+	virtual void DrawComboBox(Gwen::Controls::Base* control)
+	{
+		DrawTextBox(control);
+	}
+
+	virtual void DrawKeyboardHighlight(Gwen::Controls::Base* control, const Gwen::Rect& r, int iOffset)
+	{
+		Gwen::Rect rect = r;
+
+		rect.x += iOffset;
+		rect.y += iOffset;
+		rect.w -= iOffset * 2;
+		rect.h -= iOffset * 2;
+
+		//draw the top and bottom
+		bool skip = true;
+		for (int i = 0; i < rect.w * 0.5; i++)
+		{
+			m_Render->SetDrawColor(Gwen::Color(0, 0, 0, 255));
+			if (!skip)
+			{
+				GetRender()->DrawPixel(rect.x + (i * 2), rect.y);
+				GetRender()->DrawPixel(rect.x + (i * 2), rect.y + rect.h - 1);
+			}
+			else
+				skip = !skip;
+		}
+		skip = false;
+		for (int i = 0; i < rect.h * 0.5; i++)
+		{
+			GetRender()->SetDrawColor(Gwen::Color(0, 0, 0, 255));
+			if (!skip)
+			{
+				GetRender()->DrawPixel(rect.x, rect.y + i * 2);
+				GetRender()->DrawPixel(rect.x + rect.w - 1, rect.y + i * 2);
+			}
+			else
+				skip = !skip;
+		}
+	}
+
+	virtual void DrawToolTip(Gwen::Controls::Base* control)
+	{
+		Gwen::Rect rct = control->GetRenderBounds();
+		rct.x -= 3;
+		rct.y -= 3;
+		rct.w += 6;
+		rct.h += 6;
+
+		GetRender()->SetDrawColor(m_colToolTipBackground);
+		GetRender()->DrawFilledRect(rct);
+
+		GetRender()->SetDrawColor(m_colToolTipBorder);
+		GetRender()->DrawLinedRect(rct);
+	}
+
+	virtual void DrawScrollButton(Gwen::Controls::Base* control, int iDirection, bool bDepressed)
+	{
+		DrawButton(control, bDepressed, false);
+
+		m_Render->SetDrawColor(Gwen::Color(0, 0, 0, 240));
+
+		Gwen::Rect r(control->Width() / 2 - 2, control->Height() / 2 - 2, 5, 5);
+
+		if (iDirection == Gwen::Pos::Top)
+			DrawArrowUp(r);
+		else if (iDirection == Gwen::Pos::Bottom)
+			DrawArrowDown(r);
+		else if (iDirection == Gwen::Pos::Left)
+			DrawArrowLeft(r);
+		else
+			DrawArrowRight(r);
+	}
+
+	virtual void DrawComboBoxButton(Gwen::Controls::Base* control, bool bDepressed)
+	{
+		m_Render->SetDrawColor(Gwen::Color(0, 0, 0, 240));
+
+		Gwen::Rect r(control->Width() / 2 - 2, control->Height() / 2 - 2, 5, 5);
+		DrawArrowDown(r);
+	}
+
+	virtual void DrawNumericUpDownButton(Gwen::Controls::Base* control, bool bDepressed, bool bUp)
+	{
+		//	DrawButton( control->Width(), control->Height(), bDepressed, false, true );
+
+		m_Render->SetDrawColor(Gwen::Color(0, 0, 0, 240));
+
+		Gwen::Rect r(control->Width() / 2 - 2, control->Height() / 2 - 2, 5, 5);
+
+		if (bUp)
+			DrawArrowUp(r);
+		else
+			DrawArrowDown(r);
+	}
+
+	virtual void DrawStatusBar(Controls::Base* control)
+	{
+		DrawBackground(control);
+	}
+
+	virtual void DrawBackground(Gwen::Controls::Base* control)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+		m_Render->SetDrawColor(m_colBGDark);
+		m_Render->DrawFilledRect(rect);
+		m_Render->SetDrawColor(m_colControlDarker);
+		m_Render->DrawLinedRect(rect);
+	}
+
+	virtual void DrawTreeButton(Controls::Base* control, bool bOpen)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+
+		rect.x += 2;
+		rect.y += 2;
+		rect.w -= 2;
+		rect.h -= 2;
+		if (bOpen)
+		{
+			m_TreeMinus.Draw(GetRender(), rect);
+		}
+		else
+			m_TreePlus.Draw(GetRender(), rect);
+	}
+
+	virtual void DrawTreeControl(Controls::Base* control)
+	{
+		m_texTreeBG.Draw(GetRender(), control->GetRenderBounds());
+	}
+
+	virtual void DrawPropertyRow(Controls::Base* control, int iWidth, bool bBeingEdited)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+
+		if (bBeingEdited)
+		{
+			GetRender()->SetDrawColor(m_colHighlightBG);
+			GetRender()->DrawFilledRect(Gwen::Rect(0, rect.y, iWidth, rect.h));
+		}
+
+		GetRender()->SetDrawColor(m_colControlOutlineLighter);
+
+		GetRender()->DrawFilledRect(Gwen::Rect(iWidth, rect.y, 1, rect.h));
+
+		rect.y += rect.h - 1;
+		rect.h = 1;
+
+		GetRender()->DrawFilledRect(rect);
+	}
+
+	virtual void DrawPropertyTreeNode(Controls::Base* control, int BorderLeft, int BorderTop)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+
+		GetRender()->SetDrawColor(m_colControlOutlineLighter);
+
+		GetRender()->DrawFilledRect(Gwen::Rect(rect.x, rect.y, BorderLeft, rect.h));
+		GetRender()->DrawFilledRect(Gwen::Rect(rect.x + BorderLeft, rect.y, rect.w - BorderLeft, BorderTop));
+	}
+
+	void DrawTreeNode(Controls::Base* ctrl, bool bOpen, bool bSelected, int iLabelHeight, int iLabelWidth, int iHalfWay, int iLastBranch, bool bIsRoot)
+	{
+		if (bSelected)
+		{
+			GetRender()->SetDrawColor(Color(0, 150, 255, 100));
+			GetRender()->DrawFilledRect(Gwen::Rect(17, 0, iLabelWidth + 2, iLabelHeight - 1));
+			GetRender()->SetDrawColor(Color(0, 150, 255, 200));
+			GetRender()->DrawLinedRect(Gwen::Rect(17, 0, iLabelWidth + 2, iLabelHeight - 1));
+		}
+
+		GetRender()->SetDrawColor(Color(0, 0, 0, 50));
+
+		if (!bIsRoot)
+			GetRender()->DrawFilledRect(Gwen::Rect(9, iHalfWay, 16 - 9, 1));
+
+		if (!bOpen) return;
+
+		GetRender()->DrawFilledRect(Gwen::Rect(14 + 8, iLabelHeight, 1, iLastBranch + iHalfWay - iLabelHeight));
+	}
+
+	void DrawColorDisplay(Controls::Base* control, Gwen::Color color)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+
+		if (color.a != 255)
+		{
+			GetRender()->SetDrawColor(Gwen::Color(255, 255, 255, 255));
+			GetRender()->DrawFilledRect(rect);
+
+			GetRender()->SetDrawColor(Gwen::Color(128, 128, 128, 128));
+
+			GetRender()->DrawFilledRect(Gwen::Rect(0, 0, rect.w * 0.5, rect.h * 0.5));
+			GetRender()->DrawFilledRect(Gwen::Rect(rect.w * 0.5, rect.h * 0.5, rect.w * 0.5, rect.h * 0.5));
+		}
+
+		GetRender()->SetDrawColor(color);
+		GetRender()->DrawFilledRect(rect);
+
+		GetRender()->SetDrawColor(Gwen::Color(0, 0, 0, 255));
+		GetRender()->DrawLinedRect(rect);
+	}
+
+	virtual void DrawModalControl(Controls::Base* control)
+	{
+		if (control->ShouldDrawBackground())
+		{
+			Gwen::Rect rect = control->GetRenderBounds();
+			GetRender()->SetDrawColor(m_colModal);
+			GetRender()->DrawFilledRect(rect);
+		}
+	}
+
+	virtual void DrawMenuDivider(Controls::Base* control)
+	{
+		Gwen::Rect rect = control->GetRenderBounds();
+		GetRender()->SetDrawColor(m_colBGDark);
+		GetRender()->DrawFilledRect(rect);
+		GetRender()->SetDrawColor(m_colControlDarker);
+		GetRender()->DrawLinedRect(rect);
+	}
+};
+}  // namespace Skin
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Skins/Texturing.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Skins/Texturing.h
new file mode 100644
index 00000000..8688736e
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Skins/Texturing.h
@@ -0,0 +1,145 @@
+#pragma once
+#ifndef GWEN_SKINS_TEXTURING_H
+#define GWEN_SKINS_TEXTURING_H
+
+#include "Gwen/Gwen.h"
+#include "Gwen/Texture.h"
+
+namespace Gwen
+{
+namespace Skin
+{
+namespace Texturing
+{
+struct Single
+{
+	Single()
+	{
+		texture = NULL;
+	}
+
+	void Init(Texture* pTexture, float x, float y, float w, float h)
+	{
+		texture = pTexture;
+
+		float texw = texture->width;
+		float texh = texture->height;
+
+		uv[0] = x / texw;
+		uv[1] = y / texh;
+		uv[2] = (x + w) / texw;
+		uv[3] = (y + h) / texh;
+	}
+
+	void Draw(Gwen::Renderer::Base* render, Gwen::Rect r, const Gwen::Color& col = Gwen::Colors::White)
+	{
+		render->SetDrawColor(col);
+
+		render->DrawTexturedRect(texture, r, uv[0], uv[1], uv[2], uv[3]);
+	}
+
+	Texture* texture;
+	float uv[4];
+};
+
+struct Bordered
+{
+	Bordered()
+	{
+		texture = NULL;
+	}
+
+	void Init(Texture* pTexture, float x, float y, float w, float h, Margin in_margin, float DrawMarginScale = 1.0f)
+	{
+		texture = pTexture;
+
+		margin = in_margin;
+
+		SetRect(0, x, y, margin.left, margin.top);
+		SetRect(1, x + margin.left, y, w - margin.left - margin.right - 1, margin.top);
+		SetRect(2, (x + w) - margin.right, y, margin.right, margin.top);
+
+		SetRect(3, x, y + margin.top, margin.left, h - margin.top - margin.bottom - 1);
+		SetRect(4, x + margin.left, y + margin.top, w - margin.left - margin.right - 1, h - margin.top - margin.bottom - 1);
+		SetRect(5, (x + w) - margin.right, y + margin.top, margin.right, h - margin.top - margin.bottom - 1);
+
+		SetRect(6, x, (y + h) - margin.bottom, margin.left, margin.bottom);
+		SetRect(7, x + margin.left, (y + h) - margin.bottom, w - margin.left - margin.right - 1, margin.bottom);
+		SetRect(8, (x + w) - margin.right, (y + h) - margin.bottom, margin.right, margin.bottom);
+
+		margin.left *= DrawMarginScale;
+		margin.right *= DrawMarginScale;
+		margin.top *= DrawMarginScale;
+		margin.bottom *= DrawMarginScale;
+
+		width = w - x;
+		height = h - y;
+	}
+
+	void SetRect(int iNum, float x, float y, float w, float h)
+	{
+		float texw = texture->width;
+		float texh = texture->height;
+
+		//x -= 1.0f;
+		//y -= 1.0f;
+
+		rects[iNum].uv[0] = x / texw;
+		rects[iNum].uv[1] = y / texh;
+
+		rects[iNum].uv[2] = (x + w) / texw;
+		rects[iNum].uv[3] = (y + h) / texh;
+
+		//	rects[iNum].uv[0] += 1.0f / texture->width;
+		//	rects[iNum].uv[1] += 1.0f / texture->width;
+	}
+
+	void Draw(Gwen::Renderer::Base* render, Gwen::Rect r, const Gwen::Color& col = Gwen::Colors::White)
+	{
+		render->SetDrawColor(col);
+
+		if (r.w < width && r.h < height)
+		{
+			render->DrawTexturedRect(texture,
+									 r,
+									 rects[0].uv[0], rects[0].uv[1], rects[8].uv[2], rects[8].uv[3]);
+			return;
+		}
+
+		DrawRect(render, 0, r.x, r.y, margin.left, margin.top);
+		DrawRect(render, 1, r.x + margin.left, r.y, r.w - margin.left - margin.right, margin.top);
+		DrawRect(render, 2, (r.x + r.w) - margin.right, r.y, margin.right, margin.top);
+
+		DrawRect(render, 3, r.x, r.y + margin.top, margin.left, r.h - margin.top - margin.bottom);
+		DrawRect(render, 4, r.x + margin.left, r.y + margin.top, r.w - margin.left - margin.right, r.h - margin.top - margin.bottom);
+		DrawRect(render, 5, (r.x + r.w) - margin.right, r.y + margin.top, margin.right, r.h - margin.top - margin.bottom);
+
+		DrawRect(render, 6, r.x, (r.y + r.h) - margin.bottom, margin.left, margin.bottom);
+		DrawRect(render, 7, r.x + margin.left, (r.y + r.h) - margin.bottom, r.w - margin.left - margin.right, margin.bottom);
+		DrawRect(render, 8, (r.x + r.w) - margin.right, (r.y + r.h) - margin.bottom, margin.right, margin.bottom);
+	}
+
+	void DrawRect(Gwen::Renderer::Base* render, int i, int x, int y, int w, int h)
+	{
+		render->DrawTexturedRect(texture,
+								 Gwen::Rect(x, y, w, h),
+								 rects[i].uv[0], rects[i].uv[1], rects[i].uv[2], rects[i].uv[3]);
+	}
+
+	Texture* texture;
+
+	struct SubRect
+	{
+		float uv[4];
+	};
+
+	SubRect rects[9];
+	Margin margin;
+
+	float width;
+	float height;
+};
+}  // namespace Texturing
+}  // namespace Skin
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Structures.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Structures.h
new file mode 100644
index 00000000..883852c5
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Structures.h
@@ -0,0 +1,191 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifdef _MSC_VER
+#pragma warning(disable : 4244)
+#pragma warning(disable : 4251)
+#endif
+#ifndef GWEN_STRUCTURES_H
+#define GWEN_STRUCTURES_H
+
+#include "Gwen/Exports.h"
+#include <string>
+
+namespace Gwen
+{
+namespace Controls
+{
+class Base;
+class Canvas;
+}  // namespace Controls
+
+namespace CursorType
+{
+static const unsigned char Normal = 0;
+static const unsigned char Beam = 1;
+static const unsigned char SizeNS = 2;
+static const unsigned char SizeWE = 3;
+static const unsigned char SizeNWSE = 4;
+static const unsigned char SizeNESW = 5;
+static const unsigned char SizeAll = 6;
+static const unsigned char No = 7;
+static const unsigned char Wait = 8;
+static const unsigned char Finger = 9;
+
+static const unsigned char Count = 10;
+}  // namespace CursorType
+
+typedef std::wstring UnicodeString;
+typedef std::string String;
+typedef wchar_t UnicodeChar;  // Portability??
+
+struct GWEN_EXPORT Margin
+{
+	Margin(int left = 0, int top = 0, int right = 0, int bottom = 0)
+	{
+		this->top = top;
+		this->bottom = bottom;
+		this->left = left;
+		this->right = right;
+	}
+
+	int top, bottom, left, right;
+};
+
+typedef Margin Padding;
+
+struct GWEN_EXPORT Rect
+{
+	Rect(int x = 0, int y = 0, int w = 0, int h = 0)
+	{
+		this->x = x;
+		this->y = y;
+		this->w = w;
+		this->h = h;
+	}
+
+	int x, y, w, h;
+};
+
+struct GWEN_EXPORT Point
+{
+	Point(int x = 0, int y = 0)
+	{
+		this->x = x;
+		this->y = y;
+	}
+
+	int x, y;
+};
+
+struct GWEN_EXPORT HSV
+{
+	float h;
+	float s;
+	float v;
+};
+
+struct GWEN_EXPORT Color
+{
+	Color(unsigned char r = 255, unsigned char g = 255, unsigned char b = 255, unsigned char a = 255)
+	{
+		this->r = r;
+		this->g = g;
+		this->b = b;
+		this->a = a;
+	}
+
+	void operator=(Color c)
+	{
+		this->r = c.r;
+		this->g = c.g;
+		this->b = c.b;
+		this->a = c.a;
+	}
+
+	void operator+=(Color c)
+	{
+		this->r += c.r;
+		this->g += c.g;
+		this->b += c.b;
+		this->a += c.a;
+	}
+
+	void operator-=(Color c)
+	{
+		this->r -= c.r;
+		this->g -= c.g;
+		this->b -= c.b;
+		this->a -= c.a;
+	}
+
+	void operator*=(float f)
+	{
+		this->r *= f;
+		this->g *= f;
+		this->b *= f;
+		this->a *= f;
+	}
+
+	Color operator*(float f)
+	{
+		return Color(
+			(float)this->r * f,
+			(float)this->g * f,
+			(float)this->b * f,
+			(float)this->a * f);
+	}
+
+	Color operator-(Color c)
+	{
+		return Color(
+			this->r - c.r,
+			this->g - c.g,
+			this->b - c.b,
+			this->a - c.a);
+	}
+
+	Color operator+(Color c)
+	{
+		return Color(
+			this->r + c.r,
+			this->g + c.g,
+			this->b + c.b,
+			this->a + c.a);
+	}
+
+	bool operator==(const Color& c) const
+	{
+		return c.r == r && c.g == g && c.b == b && c.a == a;
+	}
+
+	unsigned char r, g, b, a;
+};
+
+namespace DragAndDrop
+{
+struct GWEN_EXPORT Package
+{
+	Package()
+	{
+		userdata = NULL;
+		draggable = false;
+		drawcontrol = NULL;
+		holdoffset = Gwen::Point(0, 0);
+	}
+
+	String name;
+	void* userdata;
+	bool draggable;
+
+	Gwen::Controls::Base* drawcontrol;
+	Gwen::Point holdoffset;
+};
+}  // namespace DragAndDrop
+
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/TextObject.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/TextObject.h
new file mode 100644
index 00000000..1e6ffaab
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/TextObject.h
@@ -0,0 +1,64 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_TEXTOBJECT_H
+#define GWEN_TEXTOBJECT_H
+
+#include "Gwen/Gwen.h"
+#include "Gwen/Utility.h"
+
+namespace Gwen
+{
+class TextObject
+{
+public:
+	TextObject() {}
+
+	TextObject(const Gwen::String& text)
+	{
+		*this = text;
+	}
+
+	TextObject(const char* text)
+	{
+		*this = Gwen::String(text);
+	}
+
+	TextObject(const wchar_t* text)
+	{
+		*this = Gwen::UnicodeString(text);
+	}
+
+	TextObject(const Gwen::UnicodeString& unicode)
+	{
+		*this = unicode;
+	}
+
+	void operator=(const Gwen::String& str)
+	{
+		m_Data = Gwen::Utility::StringToUnicode(str);
+	}
+
+	void operator=(const Gwen::UnicodeString& unicodeStr)
+	{
+		m_Data = unicodeStr;
+	}
+
+	Gwen::String Get() const
+	{
+		return Gwen::Utility::UnicodeToString(m_Data);
+	}
+
+	const Gwen::UnicodeString& GetUnicode() const
+	{
+		return m_Data;
+	}
+
+	Gwen::UnicodeString m_Data;
+};
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Texture.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Texture.h
new file mode 100644
index 00000000..5b29e0b5
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Texture.h
@@ -0,0 +1,57 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_TEXTURE_H
+#define GWEN_TEXTURE_H
+
+#include <string>
+
+#include "Gwen/BaseRender.h"
+#include "Gwen/TextObject.h"
+
+namespace Gwen
+{
+//
+// Texture
+//
+struct Texture
+{
+	TextObject name;
+	void* data;
+	int m_intData;
+
+	bool failed;
+	int width;
+	int height;
+
+	Texture()
+	{
+		data = NULL;
+		m_intData = 0;
+		width = 4;
+		height = 4;
+		failed = false;
+	}
+
+	~Texture()
+	{
+	}
+
+	void Load(const TextObject& str, Gwen::Renderer::Base* render)
+	{
+		name = str;
+		render->LoadTexture(this);
+	}
+
+	void Release(Gwen::Renderer::Base* render)
+	{
+		render->FreeTexture(this);
+	}
+};
+
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/ToolTip.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/ToolTip.h
new file mode 100644
index 00000000..71527daf
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/ToolTip.h
@@ -0,0 +1,28 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_TOOLTIP_H
+#define GWEN_TOOLTIP_H
+
+#include "Gwen/Controls/Base.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Skin.h"
+
+using namespace Gwen;
+using namespace Gwen::Controls;
+
+namespace ToolTip
+{
+GWEN_EXPORT void Enable(Controls::Base* pControl);
+GWEN_EXPORT void Disable(Controls::Base* pControl);
+
+GWEN_EXPORT void ControlDeleted(Controls::Base* pControl);
+
+GWEN_EXPORT void RenderToolTip(Skin::Base* skin);
+}  // namespace ToolTip
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/UnitTest/UnitTest.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/UnitTest/UnitTest.h
new file mode 100644
index 00000000..13b03d8a
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/UnitTest/UnitTest.h
@@ -0,0 +1,59 @@
+/*
+	GWEN
+	Copyright (c) 2011 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_UNITTEST_UNITTEST_H
+#define GWEN_UNITTEST_UNITTEST_H
+
+#include "Gwen/Gwen.h"
+#include "Gwen/Align.h"
+#include "Gwen/Utility.h"
+#include "Gwen/Controls/WindowControl.h"
+#include "Gwen/Controls/TabControl.h"
+#include "Gwen/Controls/ListBox.h"
+
+class UnitTest;
+
+class GUnit : public Gwen::Controls::Base
+{
+public:
+	GWEN_CONTROL_INLINE(GUnit, Gwen::Controls::Base)
+	{
+		m_pUnitTest = NULL;
+	}
+
+	void SetUnitTest(UnitTest* u) { m_pUnitTest = u; }
+
+	void UnitPrint(const Gwen::UnicodeString& str);
+	void UnitPrint(const Gwen::String& str);
+
+	UnitTest* m_pUnitTest;
+};
+
+class UnitTest : public Gwen::Controls::WindowControl
+{
+public:
+	GWEN_CONTROL(UnitTest, Gwen::Controls::WindowControl);
+
+	void PrintText(const Gwen::UnicodeString& str);
+
+	void Render(Gwen::Skin::Base* skin);
+
+private:
+	Gwen::Controls::TabControl* m_TabControl;
+	Gwen::Controls::ListBox* m_TextOutput;
+	unsigned int m_iFrames;
+	float m_fLastSecond;
+};
+
+#define DEFINE_UNIT_TEST(name, displayname)                         \
+	GUnit* RegisterUnitTest_##name(Gwen::Controls::TabControl* tab) \
+	{                                                               \
+		GUnit* u = new name(tab);                                   \
+		tab->AddPage(displayname, u);                               \
+		return u;                                                   \
+	}
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Gwen/Utility.h b/engine/inc/bullet/ThirdPartyLibs/Gwen/Utility.h
new file mode 100644
index 00000000..5bd63f6d
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Gwen/Utility.h
@@ -0,0 +1,126 @@
+/*
+	GWEN
+	Copyright (c) 2010 Facepunch Studios
+	See license in Gwen.h
+*/
+
+#pragma once
+#ifndef GWEN_UTILITY_H
+#define GWEN_UTILITY_H
+#include <sstream>
+#include <vector>
+#include "Gwen/Structures.h"
+
+namespace Gwen
+{
+namespace Utility
+{
+template <typename T>
+const T& Max(const T& x, const T& y)
+{
+	if (y < x) return x;
+	return y;
+}
+
+template <typename T>
+const T& Min(const T& x, const T& y)
+{
+	if (y > x) return x;
+	return y;
+}
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4996)
+#endif
+
+inline String UnicodeToString(const UnicodeString& strIn)
+{
+	if (!strIn.length()) return "";
+
+	String temp(strIn.length(), (char)0);
+
+	std::use_facet<std::ctype<wchar_t> >(std::locale()).narrow(&strIn[0], &strIn[0] + strIn.length(), ' ', &temp[0]);
+
+	return temp;
+}
+
+inline UnicodeString StringToUnicode(const String& strIn)
+{
+	if (!strIn.length()) return L"";
+
+	UnicodeString temp(strIn.length(), (wchar_t)0);
+
+	std::use_facet<std::ctype<wchar_t> >(std::locale()).widen(&strIn[0], &strIn[0] + strIn.length(), &temp[0]);
+
+	return temp;
+}
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+template <class T>
+String ToString(const T& object)
+{
+	std::ostringstream os;
+	os << object;
+	return os.str();
+}
+
+inline Gwen::Rect ClampRectToRect(Gwen::Rect inside, Gwen::Rect outside, bool clampSize = false)
+{
+	if (inside.x < outside.x)
+		inside.x = outside.x;
+
+	if (inside.y < outside.y)
+		inside.y = outside.y;
+
+	if (inside.x + inside.w > outside.x + outside.w)
+	{
+		if (clampSize)
+			inside.w = outside.w;
+		else
+			inside.x = outside.x + outside.w - inside.w;
+	}
+	if (inside.y + inside.h > outside.y + outside.h)
+	{
+		if (clampSize)
+			inside.h = outside.h;
+		else
+			inside.y = outside.w + outside.h - inside.h;
+	}
+
+	return inside;
+}
+
+GWEN_EXPORT UnicodeString Format(const wchar_t* fmt, ...);
+
+namespace Strings
+{
+typedef std::vector<Gwen::String> List;
+typedef std::vector<Gwen::UnicodeString> UnicodeList;
+
+GWEN_EXPORT void Split(const Gwen::String& str, const Gwen::String& seperator, Strings::List& outbits, bool bLeaveSeperators = false);
+GWEN_EXPORT void Split(const Gwen::UnicodeString& str, const Gwen::UnicodeString& seperator, Strings::UnicodeList& outbits, bool bLeaveSeperators = false);
+
+template <typename T>
+T TrimLeft(const T& str, const T& strChars)
+{
+	T outstr = str;
+	outstr.erase(0, outstr.find_first_not_of(strChars));
+	return outstr;
+}
+
+namespace To
+{
+GWEN_EXPORT bool Bool(const Gwen::String& str);
+GWEN_EXPORT int Int(const Gwen::String& str);
+GWEN_EXPORT float Float(const Gwen::String& str);
+GWEN_EXPORT bool Floats(const Gwen::String& str, float* f, size_t iCount);
+}  // namespace To
+}  // namespace Strings
+}  // namespace Utility
+
+}  // namespace Gwen
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/Wavefront/tiny_obj_loader.h b/engine/inc/bullet/ThirdPartyLibs/Wavefront/tiny_obj_loader.h
new file mode 100644
index 00000000..1fb15b34
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/Wavefront/tiny_obj_loader.h
@@ -0,0 +1,99 @@
+//
+// Copyright 2012-2013, Syoyo Fujita.
+//
+// Licensed under 2-clause BSD liecense.
+//
+#ifndef _TINY_OBJ_LOADER_H
+#define _TINY_OBJ_LOADER_H
+
+#include <string>
+#include <vector>
+#include <map>
+
+struct CommonFileIOInterface;
+
+namespace tinyobj
+{
+struct vertex_index_t
+{
+	int v_idx, vt_idx, vn_idx;
+	vertex_index_t() : v_idx(-1), vt_idx(-1), vn_idx(-1) {}
+	explicit vertex_index_t(int idx) : v_idx(idx), vt_idx(idx), vn_idx(idx) {}
+	vertex_index_t(int vidx, int vtidx, int vnidx)
+		: v_idx(vidx), vt_idx(vtidx), vn_idx(vnidx) {}
+};
+
+typedef std::vector<vertex_index_t> face_t;
+
+typedef struct
+{
+	std::string name;
+
+	float ambient[3];
+	float diffuse[3];
+	float specular[3];
+	float transmittance[3];
+	float emission[3];
+	float shininess;
+	float transparency;  // 1 == opaque; 0 == fully transparent
+
+	std::string ambient_texname;   // map_Ka
+	std::string diffuse_texname;   // map_Kd
+	std::string specular_texname;  // map_Ks
+	std::string normal_texname;
+	std::map<std::string, std::string> unknown_parameter;
+} material_t;
+
+// Index struct to support different indices for vtx/normal/texcoord.
+// -1 means not used.
+typedef struct
+{
+	int vertex_index;
+	int normal_index;
+	int texcoord_index;
+} index_t;
+
+typedef struct
+{
+	std::vector<index_t> indices;
+} mesh_t;
+
+typedef struct
+{
+	std::string name;
+	material_t material;
+	mesh_t mesh;
+} shape_t;
+
+// Vertex attributes
+struct attrib_t
+{
+	std::vector<float> vertices;   // 'v'(xyz)
+	std::vector<float> normals;    // 'vn'
+	std::vector<float> texcoords;  // 'vt'(uv)
+	attrib_t() {}
+};
+/// Loads .obj from a file.
+/// 'shapes' will be filled with parsed shape data
+/// The function returns error string.
+/// Returns empty string when loading .obj success.
+/// 'mtl_basepath' is optional, and used for base path for .mtl file.
+#ifdef USE_STREAM
+std::string LoadObj(
+	attrib_t& attrib,
+	std::vector<shape_t>& shapes,  // [output]
+	const char* filename,
+	const char* mtl_basepath = NULL);
+#else
+std::string
+LoadObj(
+	attrib_t& attrib,
+	std::vector<shape_t>& shapes,
+	const char* filename,
+	const char* mtl_basepath,
+	CommonFileIOInterface* fileIO);
+#endif
+
+};  // namespace tinyobj
+
+#endif  // _TINY_OBJ_LOADER_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/clsocket/src/ActiveSocket.h b/engine/inc/bullet/ThirdPartyLibs/clsocket/src/ActiveSocket.h
new file mode 100644
index 00000000..5c2d0df4
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/clsocket/src/ActiveSocket.h
@@ -0,0 +1,92 @@
+/*---------------------------------------------------------------------------*/
+/*                                                                           */
+/* ActiveSocket.h - Active Socket Decleration                                */
+/*                                                                           */
+/* Author : Mark Carrier (mark@carrierlabs.com)                              */
+/*                                                                           */
+/*---------------------------------------------------------------------------*/
+/* Copyright (c) 2007-2009 CarrierLabs, LLC.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * 4. The name "CarrierLabs" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    mark@carrierlabs.com.
+ *
+ * THIS SOFTWARE IS PROVIDED BY MARK CARRIER ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL MARK CARRIER OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ *----------------------------------------------------------------------------*/
+#ifndef __ACTIVESOCKET_H__
+#define __ACTIVESOCKET_H__
+
+#include "SimpleSocket.h"
+
+class CPassiveSocket;
+
+/// Provides a platform independent class to create an active socket.
+/// An active socket is used to create a socket which connects to a server.
+/// This type of object would be used when an application needs to send/receive
+/// data from a server.
+class CActiveSocket : public CSimpleSocket
+{
+public:
+	friend class CPassiveSocket;
+
+	CActiveSocket(CSocketType type = SocketTypeTcp);
+	virtual ~CActiveSocket()
+	{
+		Close();
+	};
+
+	/// Established a connection to the address specified by pAddr.
+	/// Connection-based protocol sockets (CSocket::SocketTypeTcp) may
+	/// successfully call Open() only once, however; connectionless protocol
+	/// sockets (CSocket::SocketTypeUdp) may use Open() multiple times to
+	/// change their association.
+	///  @param pAddr specifies the destination address to connect.
+	///  @param nPort specifies the destination port.
+	///  @return true if successful connection made, otherwise false.
+	virtual bool Open(const char *pAddr, uint16 nPort);
+
+private:
+	/// Utility function used to create a TCP connection, called from Open().
+	///  @return true if successful connection made, otherwise false.
+	bool ConnectTCP(const char *pAddr, uint16 nPort);
+
+	/// Utility function used to create a UDP connection, called from Open().
+	///  @return true if successful connection made, otherwise false.
+	bool ConnectUDP(const char *pAddr, uint16 nPort);
+
+	/// Utility function used to create a RAW connection, called from Open().
+	///  @return true if successful connection made, otherwise false.
+	bool ConnectRAW(const char *pAddr, uint16 nPort);
+
+private:
+	struct hostent *m_pHE;
+};
+
+#endif /*  __ACTIVESOCKET_H__  */
diff --git a/engine/inc/bullet/ThirdPartyLibs/clsocket/src/Host.h b/engine/inc/bullet/ThirdPartyLibs/clsocket/src/Host.h
new file mode 100644
index 00000000..47de25c4
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/clsocket/src/Host.h
@@ -0,0 +1,254 @@
+/*---------------------------------------------------------------------------*/
+/*                                                                           */
+/* Host.h - Basic header file to provide cross-platform solutions via        */
+/*                   macros, conditional compilation, etc.                   */
+/*                                                                           */
+/* Author : Mark Carrier (mark@carrierlabs.com)                              */
+/*                                                                           */
+/*---------------------------------------------------------------------------*/
+/* Copyright (c) 2007 CarrierLabs, LLC.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * 4. The name "CarrierLabs" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    mark@carrierlabs.com.
+ *
+ * THIS SOFTWARE IS PROVIDED BY MARK CARRIER ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL MARK CARRIER OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ *----------------------------------------------------------------------------*/
+#ifndef __HOST_H__
+#define __HOST_H__
+
+#include <limits.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*---------------------------------------------------------------------------*/
+/*                                                                           */
+/* Type Definition Macros                                                    */
+/*                                                                           */
+/*---------------------------------------------------------------------------*/
+#ifndef __WORDSIZE
+/* Assume 32 */
+#define __WORDSIZE 32
+#endif
+
+#if defined(_LINUX) || defined(_DARWIN) || defined(_BSD)
+	typedef unsigned char uint8;
+	typedef char int8;
+	typedef unsigned short uint16;
+	typedef short int16;
+	typedef unsigned int uint32;
+	typedef int int32;
+	typedef int SOCKET;
+#endif
+
+#ifdef WIN32
+	struct iovec
+	{
+		void *iov_base;
+		size_t iov_len;
+	};
+
+	typedef unsigned char uint8;
+	typedef char int8;
+	typedef unsigned short uint16;
+	typedef short int16;
+	typedef unsigned int uint32;
+	typedef int int32;
+#endif
+
+#ifdef WIN32
+	typedef int socklen_t;
+#endif
+
+#if defined(WIN32)
+	typedef unsigned long long int uint64;
+	typedef long long int int64;
+#elif (__WORDSIZE == 32)
+__extension__ typedef long long int int64;
+__extension__ typedef unsigned long long int uint64;
+#elif (__WORDSIZE == 64)
+typedef unsigned long int uint64;
+typedef long int int64;
+#endif
+
+#ifdef WIN32
+
+#ifndef UINT8_MAX
+#define UINT8_MAX (UCHAR_MAX)
+#endif
+#ifndef UINT16_MAX
+#define UINT16_MAX (USHRT_MAX)
+#endif
+#ifndef UINT32_MAX
+#define UINT32_MAX (ULONG_MAX)
+#endif
+
+#if __WORDSIZE == 64
+#define SIZE_MAX (18446744073709551615UL)
+#else
+#ifndef SIZE_MAX
+#define SIZE_MAX (4294967295U)
+#endif
+#endif
+#endif
+
+#if defined(WIN32)
+#define ssize_t size_t
+#endif
+
+#ifndef TRUE
+#define TRUE 1
+#endif
+
+#ifndef FALSE
+#define FALSE 0
+#endif
+
+#ifndef htonll
+#ifdef _BIG_ENDIAN
+#define htonll(x) (x)
+#define ntohll(x) (x)
+#else
+#define htonll(x) ((((uint64)htonl(x)) << 32) + htonl(x >> 32))
+#define ntohll(x) ((((uint64)ntohl(x)) << 32) + ntohl(x >> 32))
+#endif
+#endif
+
+/*---------------------------------------------------------------------------*/
+/*                                                                           */
+/* Socket Macros                                                             */
+/*                                                                           */
+/*---------------------------------------------------------------------------*/
+#ifdef WIN32
+#define SHUT_RD 0
+#define SHUT_WR 1
+#define SHUT_RDWR 2
+#define ACCEPT(a, b, c) accept(a, b, c)
+#define CONNECT(a, b, c) connect(a, b, c)
+#define CLOSE(a) closesocket(a)
+#define READ(a, b, c) read(a, b, c)
+#define RECV(a, b, c, d) recv(a, (char *)b, c, d)
+#define RECVFROM(a, b, c, d, e, f) recvfrom(a, (char *)b, c, d, (sockaddr *)e, (int *)f)
+#define RECV_FLAGS MSG_WAITALL
+#define SELECT(a, b, c, d, e) select((int32)a, b, c, d, e)
+#define SEND(a, b, c, d) send(a, (const char *)b, (int)c, d)
+#define SENDTO(a, b, c, d, e, f) sendto(a, (const char *)b, (int)c, d, e, f)
+#define SEND_FLAGS 0
+#define SENDFILE(a, b, c, d) sendfile(a, b, c, d)
+#define SET_SOCKET_ERROR(x, y) errno = y
+#define SOCKET_ERROR_INTERUPT EINTR
+#define SOCKET_ERROR_TIMEDOUT EAGAIN
+#define WRITE(a, b, c) write(a, b, c)
+#define WRITEV(a, b, c) Writev(b, c)
+#define GETSOCKOPT(a, b, c, d, e) getsockopt(a, b, c, (char *)d, (int *)e)
+#define SETSOCKOPT(a, b, c, d, e) setsockopt(a, b, c, (char *)d, (int)e)
+#define GETHOSTBYNAME(a) gethostbyname(a)
+#endif
+
+#if defined(_LINUX) || defined(_DARWIN) || defined(_BSD)
+#define ACCEPT(a, b, c) accept(a, b, c)
+#define CONNECT(a, b, c) connect(a, b, c)
+#define CLOSE(a) close(a)
+#define READ(a, b, c) read(a, b, c)
+#define RECV(a, b, c, d) recv(a, (void *)b, c, d)
+#define RECVFROM(a, b, c, d, e, f) recvfrom(a, (char *)b, c, d, (sockaddr *)e, f)
+#define RECV_FLAGS MSG_WAITALL
+#define SELECT(a, b, c, d, e) select(a, b, c, d, e)
+#define SEND(a, b, c, d) send(a, (const int8 *)b, c, d)
+#define SENDTO(a, b, c, d, e, f) sendto(a, (const int8 *)b, c, d, e, f)
+#define SEND_FLAGS 0
+#define SENDFILE(a, b, c, d) sendfile(a, b, c, d)
+#define SET_SOCKET_ERROR(x, y) errno = y
+#define SOCKET_ERROR_INTERUPT EINTR
+#define SOCKET_ERROR_TIMEDOUT EAGAIN
+#define WRITE(a, b, c) write(a, b, c)
+#define WRITEV(a, b, c) writev(a, b, c)
+#define GETSOCKOPT(a, b, c, d, e) getsockopt((int)a, (int)b, (int)c, (void *)d, (socklen_t *)e)
+#define SETSOCKOPT(a, b, c, d, e) setsockopt((int)a, (int)b, (int)c, (const void *)d, (int)e)
+#define GETHOSTBYNAME(a) gethostbyname(a)
+#endif
+
+/*---------------------------------------------------------------------------*/
+/*                                                                           */
+/* File Macros                                                               */
+/*                                                                           */
+/*---------------------------------------------------------------------------*/
+#define STRUCT_STAT struct stat
+#define LSTAT(x, y) lstat(x, y)
+#define FILE_HANDLE FILE *
+#define CLEARERR(x) clearerr(x)
+#define FCLOSE(x) fclose(x)
+#define FEOF(x) feof(x)
+#define FERROR(x) ferror(x)
+#define FFLUSH(x) fflush(x)
+#define FILENO(s) fileno(s)
+#define FOPEN(x, y) fopen(x, y)
+	//#define FREAD(a,b,c,d)      fread(a, b, c, d)
+#define FSTAT(s, st) fstat(FILENO(s), st)
+	//#define FWRITE(a,b,c,d)     fwrite(a, b, c, d)
+#define STAT_BLK_SIZE(x) ((x).st_blksize)
+
+/*---------------------------------------------------------------------------*/
+/*                                                                           */
+/* Misc Macros                                                               */
+/*                                                                           */
+/*---------------------------------------------------------------------------*/
+#if defined(WIN32)
+#define GET_CLOCK_COUNT(x) QueryPerformanceCounter((LARGE_INTEGER *)x)
+#else
+#define GET_CLOCK_COUNT(x) gettimeofday(x, NULL)
+#endif
+
+#if defined(WIN32)
+#define STRTOULL(x) _atoi64(x)
+#else
+#define STRTOULL(x) strtoull(x, NULL, 10)
+#endif
+
+#if defined(WIN32)
+#define SNPRINTF _snprintf
+#define PRINTF printf
+#define VPRINTF vprintf
+#define FPRINTF fprintf
+#else
+#define SNPRINTF snprintf
+#define PRINTF printf
+#define VPRINTF vprintf
+#define FPRINTF fprintf
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __HOST_H__ */
diff --git a/engine/inc/bullet/ThirdPartyLibs/clsocket/src/PassiveSocket.h b/engine/inc/bullet/ThirdPartyLibs/clsocket/src/PassiveSocket.h
new file mode 100644
index 00000000..0dbf069b
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/clsocket/src/PassiveSocket.h
@@ -0,0 +1,120 @@
+/*---------------------------------------------------------------------------*/
+/*                                                                           */
+/* Socket.h - Passive Socket Decleration.                                    */
+/*                                                                           */
+/* Author : Mark Carrier (mark@carrierlabs.com)                              */
+/*                                                                           */
+/*---------------------------------------------------------------------------*/
+/* Copyright (c) 2007-2009 CarrierLabs, LLC.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * 4. The name "CarrierLabs" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    mark@carrierlabs.com.
+ *
+ * THIS SOFTWARE IS PROVIDED BY MARK CARRIER ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL MARK CARRIER OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ *----------------------------------------------------------------------------*/
+#ifndef __PASSIVESOCKET_H__
+#define __PASSIVESOCKET_H__
+#include "ActiveSocket.h"
+
+/// Provides a platform independent class to create a passive socket.
+/// A passive socket is used to create a "listening" socket.  This type
+/// of object would be used when an application needs to wait for
+/// inbound connections.  Support for CSimpleSocket::SocketTypeTcp,
+/// CSimpleSocket::SocketTypeUdp, and CSimpleSocket::SocketTypeRaw is handled
+/// in a similar fashion.  The big difference is that the method
+/// CPassiveSocket::Accept should not be called on the latter two socket
+/// types.
+class CPassiveSocket : public CSimpleSocket
+{
+public:
+	CPassiveSocket(CSocketType type = SocketTypeTcp);
+	virtual ~CPassiveSocket()
+	{
+		Close();
+	};
+
+	/// Extracts the first connection request on the queue of pending
+	/// connections and creates a newly connected socket.  Used with
+	/// CSocketType CSimpleSocket::SocketTypeTcp.  It is the responsibility of
+	/// the caller to delete the returned object when finished.
+	///  @return if successful a pointer to a newly created CActiveSocket object
+	///          will be returned and the internal error condition of the CPassiveSocket
+	///          object will be CPassiveSocket::SocketSuccess.  If an error condition was encountered
+	///          the NULL will be returned and one of the following error conditions will be set:
+	///    CPassiveSocket::SocketEwouldblock, CPassiveSocket::SocketInvalidSocket,
+	///    CPassiveSocket::SocketConnectionAborted, CPassiveSocket::SocketInterrupted
+	///    CPassiveSocket::SocketProtocolError, CPassiveSocket::SocketFirewallError
+	virtual CActiveSocket *Accept(void);
+
+	/// Bind to a multicast group on  a specified interface, multicast group, and port
+	///
+	///  @param pInterface - interface on which to bind.
+	///  @param pGroup - multicast group address to bind.
+	///  @param nPort - port on which multicast
+	///  @return true if able to bind to interface and multicast group.
+	///      If not successful, the false is returned and one of the following error
+	///      condiitions will be set: CPassiveSocket::SocketAddressInUse, CPassiveSocket::SocketProtocolError,
+	///      CPassiveSocket::SocketInvalidSocket.  The following socket errors are for Linux/Unix
+	///      derived systems only: CPassiveSocket::SocketInvalidSocketBuffer
+	bool BindMulticast(const char *pInterface, const char *pGroup, uint16 nPort);
+
+	/// Create a listening socket at local ip address 'x.x.x.x' or 'localhost'
+	/// if pAddr is NULL on port nPort.
+	///
+	///  @param pAddr specifies the IP address on which to listen.
+	///  @param nPort specifies the port on which to listen.
+	///  @param nConnectionBacklog specifies connection queue backlog (default 30,000)
+	///  @return true if a listening socket was created.
+	///      If not successful, the false is returned and one of the following error
+	///      conditions will be set: CPassiveSocket::SocketAddressInUse, CPassiveSocket::SocketProtocolError,
+	///      CPassiveSocket::SocketInvalidSocket.  The following socket errors are for Linux/Unix
+	///      derived systems only: CPassiveSocket::SocketInvalidSocketBuffer
+	virtual bool Listen(const char *pAddr, uint16 nPort, int32 nConnectionBacklog = 30000);
+
+	/// Attempts to send a block of data on an established connection.
+	/// @param pBuf block of data to be sent.
+	/// @param bytesToSend size of data block to be sent.
+	/// @return number of bytes actually sent, return of zero means the
+	/// connection has been shutdown on the other side, and a return of -1
+	/// means that an error has occurred.  If an error was signaled then one
+	/// of the following error codes will be set: CPassiveSocket::SocketInvalidSocket,
+	/// CPassiveSocket::SocketEwouldblock, SimpleSocket::SocketConnectionReset,
+	/// CPassiveSocket::SocketInvalidSocketBuffer, CPassiveSocket::SocketInterrupted,
+	/// CPassiveSocket::SocketProtocolError, CPassiveSocket::SocketNotconnected
+	/// <br>\b Note: This function is used only for a socket of type
+	/// CSimpleSocket::SocketTypeUdp
+	virtual int32 Send(const uint8 *pBuf, size_t bytesToSend);
+
+private:
+	struct ip_mreq m_stMulticastRequest;  /// group address for multicast
+};
+
+#endif  // __PASSIVESOCKET_H__
diff --git a/engine/inc/bullet/ThirdPartyLibs/clsocket/src/SimpleSocket.h b/engine/inc/bullet/ThirdPartyLibs/clsocket/src/SimpleSocket.h
new file mode 100644
index 00000000..99cd2e1b
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/clsocket/src/SimpleSocket.h
@@ -0,0 +1,617 @@
+/*---------------------------------------------------------------------------*/
+/*                                                                           */
+/* SimpleSocket.h - Simple Socket base class decleration.                    */
+/*                                                                           */
+/* Author : Mark Carrier (mark@carrierlabs.com)                              */
+/*                                                                           */
+/*---------------------------------------------------------------------------*/
+/* Copyright (c) 2007-2009 CarrierLabs, LLC.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * 4. The name "CarrierLabs" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    mark@carrierlabs.com.
+ *
+ * THIS SOFTWARE IS PROVIDED BY MARK CARRIER ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL MARK CARRIER OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ *----------------------------------------------------------------------------*/
+#ifndef __SOCKET_H__
+#define __SOCKET_H__
+
+#include <sys/stat.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <errno.h>
+
+#if defined(_LINUX) || defined(_DARWIN) || defined(_BSD)
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netinet/tcp.h>
+#include <netinet/ip.h>
+#include <netdb.h>
+#endif
+#ifdef _LINUX
+#include <linux/if_packet.h>
+#include <linux/if_ether.h>
+#include <linux/if.h>
+#include <sys/sendfile.h>
+#endif
+#ifdef _DARWIN
+#include <net/if.h>
+#endif
+#if defined(_LINUX) || defined(_DARWIN) || defined(_BSD)
+#include <sys/time.h>
+#include <sys/uio.h>
+#include <unistd.h>
+#include <fcntl.h>
+#endif
+
+#ifdef _WIN32
+#include <io.h>
+#include <winsock2.h>
+#include <ws2tcpip.h>
+
+#define IPTOS_LOWDELAY 0x10
+
+#endif
+#include "Host.h"
+#include "StatTimer.h"
+
+//-----------------------------------------------------------------------------
+// General class macro definitions and typedefs
+//-----------------------------------------------------------------------------
+#ifndef INVALID_SOCKET
+#define INVALID_SOCKET ~(0)
+#endif
+
+#define SOCKET_SENDFILE_BLOCKSIZE 8192
+
+/// Provides a platform independent class to for socket development.
+/// This class is designed to abstract socket communication development in a
+/// platform independent manner.
+/// - Socket types
+///  -# CActiveSocket Class
+///  -# CPassiveSocket Class
+class CSimpleSocket
+{
+public:
+	/// Defines the three possible states for shuting down a socket.
+	typedef enum
+	{
+		Receives = SHUT_RD,  ///< Shutdown passive socket.
+		Sends = SHUT_WR,     ///< Shutdown active socket.
+		Both = SHUT_RDWR     ///< Shutdown both active and passive sockets.
+	} CShutdownMode;
+
+	/// Defines the socket types defined by CSimpleSocket class.
+	typedef enum
+	{
+		SocketTypeInvalid,  ///< Invalid socket type.
+		SocketTypeTcp,      ///< Defines socket as TCP socket.
+		SocketTypeUdp,      ///< Defines socket as UDP socket.
+		SocketTypeTcp6,     ///< Defines socket as IPv6 TCP socket.
+		SocketTypeUdp6,     ///< Defines socket as IPv6 UDP socket.
+		SocketTypeRaw       ///< Provides raw network protocol access.
+	} CSocketType;
+
+	/// Defines all error codes handled by the CSimpleSocket class.
+	typedef enum
+	{
+		SocketError = -1,           ///< Generic socket error translates to error below.
+		SocketSuccess = 0,          ///< No socket error.
+		SocketInvalidSocket,        ///< Invalid socket handle.
+		SocketInvalidAddress,       ///< Invalid destination address specified.
+		SocketInvalidPort,          ///< Invalid destination port specified.
+		SocketConnectionRefused,    ///< No server is listening at remote address.
+		SocketTimedout,             ///< Timed out while attempting operation.
+		SocketEwouldblock,          ///< Operation would block if socket were blocking.
+		SocketNotconnected,         ///< Currently not connected.
+		SocketEinprogress,          ///< Socket is non-blocking and the connection cannot be completed immediately
+		SocketInterrupted,          ///< Call was interrupted by a signal that was caught before a valid connection arrived.
+		SocketConnectionAborted,    ///< The connection has been aborted.
+		SocketProtocolError,        ///< Invalid protocol for operation.
+		SocketFirewallError,        ///< Firewall rules forbid connection.
+		SocketInvalidSocketBuffer,  ///< The receive buffer point outside the process's address space.
+		SocketConnectionReset,      ///< Connection was forcibly closed by the remote host.
+		SocketAddressInUse,         ///< Address already in use.
+		SocketInvalidPointer,       ///< Pointer type supplied as argument is invalid.
+		SocketEunknown              ///< Unknown error please report to mark@carrierlabs.com
+	} CSocketError;
+
+public:
+	CSimpleSocket(CSocketType type = SocketTypeTcp);
+	CSimpleSocket(CSimpleSocket &socket);
+
+	virtual ~CSimpleSocket()
+	{
+		if (m_pBuffer != NULL)
+		{
+			delete[] m_pBuffer;
+			m_pBuffer = NULL;
+		}
+	};
+
+	/// Initialize instance of CSocket.  This method MUST be called before an
+	/// object can be used. Errors : CSocket::SocketProtocolError,
+	/// CSocket::SocketInvalidSocket,
+	/// @return true if properly initialized.
+	virtual bool Initialize(void);
+
+	/// Close socket
+	/// @return true if successfully closed otherwise returns false.
+	virtual bool Close(void);
+
+	/// Shutdown shut down socket send and receive operations
+	///    CShutdownMode::Receives - Disables further receive operations.
+	///    CShutdownMode::Sends    - Disables further send operations.
+	///    CShutdownBoth::         - Disables further send and receive operations.
+	/// @param nShutdown specifies the type of shutdown.
+	/// @return true if successfully shutdown otherwise returns false.
+	virtual bool Shutdown(CShutdownMode nShutdown);
+
+	/// Examine the socket descriptor sets currently owned by the instance of
+	/// the socket class (the readfds, writefds, and errorfds parameters) to
+	/// see whether some of their descriptors are ready for reading, are ready
+	/// for writing, or have an exceptional condition pending, respectively.
+	/// Block until an event happens on the specified file descriptors.
+	/// @return true if socket has data ready, or false if not ready or timed out.
+	virtual bool Select(void)
+	{
+		return Select(0, 0);
+	};
+
+	/// Examine the socket descriptor sets currently owned by the instance of
+	/// the socket class (the readfds, writefds, and errorfds parameters) to
+	/// see whether some of their descriptors are ready for reading, are ready
+	/// for writing, or have an exceptional condition pending, respectively.
+	/// @param nTimeoutSec timeout in seconds for select.
+	/// @param nTimeoutUSec timeout in micro seconds for select.
+	/// @return true if socket has data ready, or false if not ready or timed out.
+	virtual bool Select(int32 nTimeoutSec, int32 nTimeoutUSec);
+
+	/// Does the current instance of the socket object contain a valid socket
+	/// descriptor.
+	///  @return true if the socket object contains a valid socket descriptor.
+	virtual bool IsSocketValid(void)
+	{
+		return (m_socket != SocketError);
+	};
+
+	/// Provides a standard error code for cross platform development by
+	/// mapping the operating system error to an error defined by the CSocket
+	/// class.
+	void TranslateSocketError(void);
+
+	/// Returns a human-readable description of the given error code
+	/// or the last error code of a socket
+	static const char *DescribeError(CSocketError err);
+	inline const char *DescribeError()
+	{
+		return DescribeError(m_socketErrno);
+	};
+
+	/// Attempts to receive a block of data on an established connection.
+	/// @param nMaxBytes maximum number of bytes to receive.
+	/// @param pBuffer, memory where to receive the data,
+	///        NULL receives to internal buffer returned with GetData()
+	///        Non-NULL receives directly there, but GetData() will return WRONG ptr!
+	/// @return number of bytes actually received.
+	/// @return of zero means the connection has been shutdown on the other side.
+	/// @return of -1 means that an error has occurred.
+	virtual int32 Receive(int32 nMaxBytes = 1, uint8 *pBuffer = 0);
+
+	/// Attempts to send a block of data on an established connection.
+	/// @param pBuf block of data to be sent.
+	/// @param bytesToSend size of data block to be sent.
+	/// @return number of bytes actually sent.
+	/// @return of zero means the connection has been shutdown on the other side.
+	/// @return of -1 means that an error has occurred.
+	virtual int32 Send(const uint8 *pBuf, size_t bytesToSend);
+
+	/// Attempts to send at most nNumItem blocks described by sendVector
+	/// to the socket descriptor associated with the socket object.
+	/// @param sendVector pointer to an array of iovec structures
+	/// @param nNumItems number of items in the vector to process
+	/// <br>\b NOTE: Buffers are processed in the order specified.
+	/// @return number of bytes actually sent, return of zero means the
+	/// connection has been shutdown on the other side, and a return of -1
+	/// means that an error has occurred.
+	virtual int32 Send(const struct iovec *sendVector, int32 nNumItems);
+
+	/// Copies data between one file descriptor and another.
+	/// On some systems this copying is done within the kernel, and thus is
+	/// more efficient than the combination of CSimpleSocket::Send and
+	/// CSimpleSocket::Receive, which would require transferring data to and
+	/// from user space.
+	/// <br>\b Note: This is available on all implementations, but the kernel
+	/// implementation is only available on Unix type systems.
+	/// @param nOutFd descriptor opened for writing.
+	/// @param nInFd descriptor opened for reading.
+	/// @param pOffset from which to start reading data from input file.
+	/// @param nCount number of bytes to copy between file descriptors.
+	/// @return number of bytes written to the out socket descriptor.
+	virtual int32 SendFile(int32 nOutFd, int32 nInFd, off_t *pOffset, int32 nCount);
+
+	/// Returns blocking/non-blocking state of socket.
+	/// @return true if the socket is non-blocking, else return false.
+	bool IsNonblocking(void)
+	{
+		return (m_bIsBlocking == false);
+	};
+
+	/// Set the socket to blocking.
+	/// @return true if successful set to blocking, else return false;
+	bool SetBlocking(void);
+
+	/// Set the socket as non-blocking.
+	/// @return true if successful set to non-blocking, else return false;
+	bool SetNonblocking(void);
+
+	/// Get a pointer to internal receive buffer.  The user MUST not free this
+	/// pointer when finished.  This memory is managed internally by the CSocket
+	/// class.
+	/// @return pointer to data if valid, else returns NULL.
+	uint8 *GetData(void)
+	{
+		return m_pBuffer;
+	};
+
+	/// Returns the number of bytes received on the last call to
+	/// CSocket::Receive().
+	/// @return number of bytes received.
+	int32 GetBytesReceived(void)
+	{
+		return m_nBytesReceived;
+	};
+
+	/// Returns the number of bytes sent on the last call to
+	/// CSocket::Send().
+	/// @return number of bytes sent.
+	int32 GetBytesSent(void)
+	{
+		return m_nBytesSent;
+	};
+
+	/// Controls the actions taken when CSimpleSocket::Close is executed on a
+	/// socket object that has unsent data.  The default value for this option
+	/// is \b off.
+	/// - Following are the three possible scenarios.
+	///  -# \b bEnable is false, CSimpleSocket::Close returns immediately, but
+	///  any unset data is transmitted (after CSimpleSocket::Close returns)
+	///  -# \b bEnable is true and \b nTime is zero, CSimpleSocket::Close return
+	/// immediately and any unsent data is discarded.
+	///  -# \b bEnable is true and \b nTime is nonzero, CSimpleSocket::Close does
+	///  not return until all unsent data is transmitted (or the connection is
+	///  Closed by the remote system).
+	/// <br><p>
+	/// @param bEnable true to enable option false to disable option.
+	/// @param nTime time in seconds to linger.
+	/// @return true if option successfully set
+	bool SetOptionLinger(bool bEnable, uint16 nTime);
+
+	/// Tells the kernel that even if this port is busy (in the TIME_WAIT state),
+	/// go ahead and reuse it anyway.  If it is busy, but with another state,
+	/// you will still get an address already in use error.
+	/// @return true if option successfully set
+	bool SetOptionReuseAddr();
+
+	/// Gets the timeout value that specifies the maximum number of seconds a
+	/// call to CSimpleSocket::Open waits until it completes.
+	/// @return the length of time in seconds
+	int32 GetConnectTimeoutSec(void)
+	{
+		return m_stConnectTimeout.tv_sec;
+	};
+
+	/// Gets the timeout value that specifies the maximum number of microseconds
+	/// a call to CSimpleSocket::Open waits until it completes.
+	/// @return the length of time in microseconds
+	int32 GetConnectTimeoutUSec(void)
+	{
+		return m_stConnectTimeout.tv_usec;
+	};
+
+	/// Sets the timeout value that specifies the maximum amount of time a call
+	/// to CSimpleSocket::Receive waits until it completes. Use the method
+	/// CSimpleSocket::SetReceiveTimeout to specify the number of seconds to wait.
+	/// If a call to CSimpleSocket::Receive has blocked for the specified length of
+	/// time without receiving additional data, it returns with a partial count
+	/// or CSimpleSocket::GetSocketError set to CSimpleSocket::SocketEwouldblock if no data
+	/// were received.
+	/// @param nConnectTimeoutSec of timeout in seconds.
+	/// @param nConnectTimeoutUsec of timeout in microseconds.
+	/// @return true if socket connection timeout was successfully set.
+	void SetConnectTimeout(int32 nConnectTimeoutSec, int32 nConnectTimeoutUsec = 0)
+	{
+		m_stConnectTimeout.tv_sec = nConnectTimeoutSec;
+		m_stConnectTimeout.tv_usec = nConnectTimeoutUsec;
+	};
+
+	/// Gets the timeout value that specifies the maximum number of seconds a
+	/// a call to CSimpleSocket::Receive waits until it completes.
+	/// @return the length of time in seconds
+	int32 GetReceiveTimeoutSec(void)
+	{
+		return m_stRecvTimeout.tv_sec;
+	};
+
+	/// Gets the timeout value that specifies the maximum number of microseconds
+	/// a call to CSimpleSocket::Receive waits until it completes.
+	/// @return the length of time in microseconds
+	int32 GetReceiveTimeoutUSec(void)
+	{
+		return m_stRecvTimeout.tv_usec;
+	};
+
+	/// Sets the timeout value that specifies the maximum amount of time a call
+	/// to CSimpleSocket::Receive waits until it completes. Use the method
+	/// CSimpleSocket::SetReceiveTimeout to specify the number of seconds to wait.
+	/// If a call to CSimpleSocket::Receive has blocked for the specified length of
+	/// time without receiving additional data, it returns with a partial count
+	/// or CSimpleSocket::GetSocketError set to CSimpleSocket::SocketEwouldblock if no data
+	/// were received.
+	///  @param nRecvTimeoutSec of timeout in seconds.
+	///  @param nRecvTimeoutUsec of timeout in microseconds.
+	///  @return true if socket timeout was successfully set.
+	bool SetReceiveTimeout(int32 nRecvTimeoutSec, int32 nRecvTimeoutUsec = 0);
+
+	/// Enable/disable multicast for a socket.  This options is only valid for
+	/// socket descriptors of type CSimpleSocket::SocketTypeUdp.
+	/// @return true if multicast was enabled or false if socket type is not
+	/// CSimpleSocket::SocketTypeUdp and the error will be set to
+	/// CSimpleSocket::SocketProtocolError
+	bool SetMulticast(bool bEnable, uint8 multicastTTL = 1);
+
+	/// Return true if socket is multicast or false is socket is unicast
+	/// @return true if multicast is enabled
+	bool GetMulticast()
+	{
+		return m_bIsMulticast;
+	};
+
+	/// Bind socket to a specific interface when using multicast.
+	/// @return true if successfully bound to interface
+	bool BindInterface(const char *pInterface);
+
+	/// Gets the timeout value that specifies the maximum number of seconds a
+	/// a call to CSimpleSocket::Send waits until it completes.
+	/// @return the length of time in seconds
+	int32 GetSendTimeoutSec(void)
+	{
+		return m_stSendTimeout.tv_sec;
+	};
+
+	/// Gets the timeout value that specifies the maximum number of microseconds
+	/// a call to CSimpleSocket::Send waits until it completes.
+	/// @return the length of time in microseconds
+	int32 GetSendTimeoutUSec(void)
+	{
+		return m_stSendTimeout.tv_usec;
+	};
+
+	/// Gets the timeout value that specifies the maximum amount of time a call
+	/// to CSimpleSocket::Send waits until it completes.
+	/// @return the length of time in seconds
+	bool SetSendTimeout(int32 nSendTimeoutSec, int32 nSendTimeoutUsec = 0);
+
+	/// Returns the last error that occured for the instace of the CSimpleSocket
+	/// instance.  This method should be called immediately to retrieve the
+	/// error code for the failing mehtod call.
+	///  @return last error that occured.
+	CSocketError GetSocketError(void)
+	{
+		return m_socketErrno;
+	};
+	/*
+     CSocketError GetSocketError(void) {
+     CSocketError err = m_socketErrno;
+     m_socketErrno = SocketSuccess;
+     return err;
+     
+     };
+     */
+
+	/// Get the total time the of the last operation in milliseconds.
+	///  @return number of milliseconds of last operation.
+	uint32 GetTotalTimeMs()
+	{
+		return m_timer.GetMilliSeconds();
+	};
+
+	/// Get the total time the of the last operation in microseconds.
+	///  @return number of microseconds or last operation.
+	uint32 GetTotalTimeUsec()
+	{
+		return m_timer.GetMicroSeconds();
+	};
+
+	/// Return Differentiated Services Code Point (DSCP) value currently set on the socket object.
+	/// @return DSCP for current socket object.
+	/// <br><br> \b NOTE: Windows special notes http://support.microsoft.com/kb/248611.
+	int GetSocketDscp(void);
+
+	/// Set Differentiated Services Code Point (DSCP) for socket object.
+	///  @param nDscp value of TOS setting which will be converted to DSCP
+	///  @return true if DSCP value was properly set
+	/// <br><br> \b NOTE: Windows special notes http://support.microsoft.com/kb/248611.
+	bool SetSocketDscp(int nDscp);
+
+	/// Return socket descriptor
+	///  @return socket descriptor which is a signed 32 bit integer.
+	SOCKET GetSocketDescriptor()
+	{
+		return m_socket;
+	};
+
+	/// Return socket descriptor
+	///  @return socket descriptor which is a signed 32 bit integer.
+	CSocketType GetSocketType()
+	{
+		return m_nSocketType;
+	};
+
+	/// Returns clients Internet host address as a string in standard numbers-and-dots notation.
+	///  @return NULL if invalid
+	const char *GetClientAddr()
+	{
+		return inet_ntoa(m_stClientSockaddr.sin_addr);
+	};
+
+	/// Returns the port number on which the client is connected.
+	///  @return client port number.
+	uint16 GetClientPort()
+	{
+		return m_stClientSockaddr.sin_port;
+	};
+
+	/// Returns server Internet host address as a string in standard numbers-and-dots notation.
+	///  @return NULL if invalid
+	const char *GetServerAddr()
+	{
+		return inet_ntoa(m_stServerSockaddr.sin_addr);
+	};
+
+	/// Returns the port number on which the server is connected.
+	///  @return server port number.
+	uint16 GetServerPort()
+	{
+		return ntohs(m_stServerSockaddr.sin_port);
+	};
+
+	/// Get the TCP receive buffer window size for the current socket object.
+	/// <br><br>\b NOTE: Linux will set the receive buffer to twice the value passed.
+	///  @return zero on failure else the number of bytes of the TCP receive buffer window size if successful.
+	uint32 GetReceiveWindowSize()
+	{
+		return GetWindowSize(SO_RCVBUF);
+	};
+
+	/// Get the TCP send buffer window size for the current socket object.
+	/// <br><br>\b NOTE: Linux will set the send buffer to twice the value passed.
+	///  @return zero on failure else the number of bytes of the TCP receive buffer window size if successful.
+	uint32 GetSendWindowSize()
+	{
+		return GetWindowSize(SO_SNDBUF);
+	};
+
+	/// Set the TCP receive buffer window size for the current socket object.
+	/// <br><br>\b NOTE: Linux will set the receive buffer to twice the value passed.
+	///  @return zero on failure else the number of bytes of the TCP send buffer window size if successful.
+	uint32 SetReceiveWindowSize(uint32 nWindowSize)
+	{
+		return SetWindowSize(SO_RCVBUF, nWindowSize);
+	};
+
+	/// Set the TCP send buffer window size for the current socket object.
+	/// <br><br>\b NOTE: Linux will set the send buffer to twice the value passed.
+	///  @return zero on failure else the number of bytes of the TCP send buffer window size if successful.
+	uint32 SetSendWindowSize(uint32 nWindowSize)
+	{
+		return SetWindowSize(SO_SNDBUF, nWindowSize);
+	};
+
+	/// Disable the Nagle algorithm (Set TCP_NODELAY to true)
+	/// @return false if failed to set socket option otherwise return true;
+	bool DisableNagleAlgoritm();
+
+	/// Enable the Nagle algorithm (Set TCP_NODELAY to false)
+	/// @return false if failed to set socket option otherwise return true;
+	bool EnableNagleAlgoritm();
+
+protected:
+	/// Set internal socket error to that specified error
+	///  @param error type of error
+	void SetSocketError(CSimpleSocket::CSocketError error)
+	{
+		m_socketErrno = error;
+	};
+
+	/// Set object socket handle to that specified as parameter
+	///  @param socket value of socket descriptor
+	void SetSocketHandle(SOCKET socket)
+	{
+		m_socket = socket;
+	};
+
+private:
+	/// Generic function used to get the send/receive window size
+	///  @return zero on failure else the number of bytes of the TCP window size if successful.
+	uint32 GetWindowSize(uint32 nOptionName);
+
+	/// Generic function used to set the send/receive window size
+	///  @return zero on failure else the number of bytes of the TCP window size if successful.
+	uint32 SetWindowSize(uint32 nOptionName, uint32 nWindowSize);
+
+	/// Attempts to send at most nNumItem blocks described by sendVector
+	/// to the socket descriptor associated with the socket object.
+	/// @param sendVector pointer to an array of iovec structures
+	/// @param nNumItems number of items in the vector to process
+	/// <br>\b Note: This implementation is for systems that don't natively
+	/// support this functionality.
+	/// @return number of bytes actually sent, return of zero means the
+	/// connection has been shutdown on the other side, and a return of -1
+	/// means that an error has occurred.
+	int32 Writev(const struct iovec *pVector, size_t nCount);
+
+	/// Flush the socket descriptor owned by the object.
+	/// @return true data was successfully sent, else return false;
+	bool Flush();
+
+	CSimpleSocket *operator=(CSimpleSocket &socket);
+
+protected:
+	SOCKET m_socket;                        /// socket handle
+	CSocketError m_socketErrno;             /// number of last error
+	uint8 *m_pBuffer;                       /// internal send/receive buffer
+	int32 m_nBufferSize;                    /// size of internal send/receive buffer
+	int32 m_nSocketDomain;                  /// socket type PF_INET, PF_INET6
+	CSocketType m_nSocketType;              /// socket type - UDP, TCP or RAW
+	int32 m_nBytesReceived;                 /// number of bytes received
+	int32 m_nBytesSent;                     /// number of bytes sent
+	uint32 m_nFlags;                        /// socket flags
+	bool m_bIsBlocking;                     /// is socket blocking
+	bool m_bIsMulticast;                    /// is the UDP socket multicast;
+	struct timeval m_stConnectTimeout;      /// connection timeout
+	struct timeval m_stRecvTimeout;         /// receive timeout
+	struct timeval m_stSendTimeout;         /// send timeout
+	struct sockaddr_in m_stServerSockaddr;  /// server address
+	struct sockaddr_in m_stClientSockaddr;  /// client address
+	struct sockaddr_in m_stMulticastGroup;  /// multicast group to bind to
+	struct linger m_stLinger;               /// linger flag
+	CStatTimer m_timer;                     /// internal statistics.
+#ifdef WIN32
+	WSADATA m_hWSAData;  /// Windows
+#endif
+	fd_set m_writeFds;  /// write file descriptor set
+	fd_set m_readFds;   /// read file descriptor set
+	fd_set m_errorFds;  /// error file descriptor set
+};
+
+#endif /*  __SOCKET_H__  */
diff --git a/engine/inc/bullet/ThirdPartyLibs/clsocket/src/StatTimer.h b/engine/inc/bullet/ThirdPartyLibs/clsocket/src/StatTimer.h
new file mode 100644
index 00000000..89d4cfa8
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/clsocket/src/StatTimer.h
@@ -0,0 +1,110 @@
+/*----------------------------------------------------------------------------*/
+/*                                                                            */
+/* StatTimer.h: interface for the CStatTimer class.                           */
+/*                                                                            */
+/* Author: Mark Carrier (mark@carrierlabs.com)                                */
+/*                                                                            */
+/*----------------------------------------------------------------------------*/
+/* Copyright (c) 2006 CarrierLabs, LLC.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * 4. The name "CarrierLabs" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    mark@carrierlabs.com.
+ *
+ * THIS SOFTWARE IS PROVIDED BY MARK CARRIER ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL MARK CARRIER OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ *----------------------------------------------------------------------------*/
+#ifndef __CSTATTIMER_H__
+#define __CSTATTIMER_H__
+
+#include <string.h>
+
+#ifdef WIN32
+#include <winsock2.h>
+#include <time.h>
+#endif
+
+#ifdef _LINUX
+#include <stdio.h>
+#include <sys/time.h>
+#endif
+
+#include "Host.h"
+
+#if defined(WIN32)
+#define GET_CLOCK_COUNT(x) QueryPerformanceCounter((LARGE_INTEGER *)x)
+#else
+#define GET_CLOCK_COUNT(x) gettimeofday(x, NULL)
+#endif
+
+#define MILLISECONDS_CONVERSION 1000
+#define MICROSECONDS_CONVERSION 1000000
+
+/// Class to abstract socket communications in a cross platform manner.
+/// This class is designed
+class CStatTimer
+{
+public:
+	CStatTimer(){};
+
+	~CStatTimer(){};
+
+	void Initialize()
+	{
+		memset(&m_startTime, 0, sizeof(struct timeval));
+		memset(&m_endTime, 0, sizeof(struct timeval));
+	};
+
+	struct timeval GetStartTime() { return m_startTime; };
+	void SetStartTime() { GET_CLOCK_COUNT(&m_startTime); };
+
+	struct timeval GetEndTime() { return m_endTime; };
+	void SetEndTime() { GET_CLOCK_COUNT(&m_endTime); };
+
+	uint32 GetMilliSeconds() { return (CalcTotalUSec() / MILLISECONDS_CONVERSION); };
+	uint32 GetMicroSeconds() { return (CalcTotalUSec()); };
+	uint32 GetSeconds() { return (CalcTotalUSec() / MICROSECONDS_CONVERSION); };
+
+	uint32 GetCurrentTime()
+	{
+		struct timeval tmpTime;
+		GET_CLOCK_COUNT(&tmpTime);
+		return ((tmpTime.tv_sec * MICROSECONDS_CONVERSION) + tmpTime.tv_usec);
+	};
+
+private:
+	uint32 CalcTotalUSec() { return (((m_endTime.tv_sec - m_startTime.tv_sec) * MICROSECONDS_CONVERSION) +
+									 (m_endTime.tv_usec - m_startTime.tv_usec)); };
+
+private:
+	struct timeval m_startTime;
+	struct timeval m_endTime;
+};
+
+#endif  // __CSTATTIMER_H__
diff --git a/engine/inc/bullet/ThirdPartyLibs/cpp_base64/include/cpp_base64/base64.h b/engine/inc/bullet/ThirdPartyLibs/cpp_base64/include/cpp_base64/base64.h
new file mode 100644
index 00000000..ea1f22d3
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/cpp_base64/include/cpp_base64/base64.h
@@ -0,0 +1,18 @@
+//
+//  base64 encoding and decoding with C++.
+//  Version: 2.rc.00 (release candidate)
+//
+
+#ifndef BASE64_H_C0CE2A47_D10E_42C9_A27C_C883944E704A
+#define BASE64_H_C0CE2A47_D10E_42C9_A27C_C883944E704A
+
+#include <string>
+
+std::string base64_encode     (std::string const& s, bool url = false);
+std::string base64_encode_pem (std::string const& s);
+std::string base64_encode_mime(std::string const& s);
+
+std::string base64_decode(std::string const& encoded_string, bool remove_linebreaks = false);
+std::string base64_encode(unsigned char const*, unsigned int len, bool url = false);
+
+#endif /* BASE64_H_C0CE2A47_D10E_42C9_A27C_C883944E704A */
diff --git a/engine/inc/bullet/ThirdPartyLibs/crossguid/crossguid/guid.hpp b/engine/inc/bullet/ThirdPartyLibs/crossguid/crossguid/guid.hpp
new file mode 100644
index 00000000..1679a8f0
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/crossguid/crossguid/guid.hpp
@@ -0,0 +1,147 @@
+/*
+The MIT License (MIT)
+
+Copyright (c) 2014 Graeme Hill (http://graemehill.ca)
+
+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.
+*/
+
+#pragma once
+
+#ifdef GUID_ANDROID
+#include <thread>
+#include <jni.h>
+#endif
+
+#include <functional>
+#include <iostream>
+#include <array>
+#include <sstream>
+#include <utility>
+#include <iomanip>
+
+#define BEGIN_XG_NAMESPACE namespace xg {
+#define END_XG_NAMESPACE }
+
+BEGIN_XG_NAMESPACE
+
+// Class to represent a GUID/UUID. Each instance acts as a wrapper around a
+// 16 byte value that can be passed around by value. It also supports
+// conversion to string (via the stream operator <<) and conversion from a
+// string via constructor.
+class Guid
+{
+public:
+	explicit Guid(const std::array<unsigned char, 16> &bytes);
+	explicit Guid(std::array<unsigned char, 16> &&bytes);
+
+	Guid();
+	
+	Guid(const Guid &other) = default;
+	Guid &operator=(const Guid &other) = default;
+	Guid(Guid &&other) = default;
+	Guid &operator=(Guid &&other) = default;
+
+	bool operator==(const Guid &other) const;
+	bool operator!=(const Guid &other) const;
+
+	std::string str() const;
+	operator std::string() const;
+	const std::array<unsigned char, 16>& bytes() const;
+	void swap(Guid &other);
+	bool isValid() const;
+
+private:
+	void zeroify();
+
+	// actual data
+	std::array<unsigned char, 16> _bytes;
+
+	// make the << operator a friend so it can access _bytes
+	friend std::ostream &operator<<(std::ostream &s, const Guid &guid);
+	friend bool operator<(const Guid &lhs, const Guid &rhs);
+};
+
+Guid newGuid();
+
+#ifdef GUID_ANDROID
+struct AndroidGuidInfo
+{
+	static AndroidGuidInfo fromJniEnv(JNIEnv *env);
+
+	JNIEnv *env;
+	jclass uuidClass;
+	jmethodID newGuidMethod;
+	jmethodID mostSignificantBitsMethod;
+	jmethodID leastSignificantBitsMethod;
+	std::thread::id initThreadId;
+};
+
+extern AndroidGuidInfo androidInfo;
+
+void initJni(JNIEnv *env);
+
+// overloading for multi-threaded calls
+Guid newGuid(JNIEnv *env);
+#endif
+
+namespace details
+{
+	template <typename...> struct hash;
+
+	template<typename T> 
+	struct hash<T> : public std::hash<T>
+	{
+		using std::hash<T>::hash;
+	};
+
+
+	template <typename T, typename... Rest>
+	struct hash<T, Rest...>
+	{
+		inline std::size_t operator()(const T& v, const Rest&... rest) {
+			std::size_t seed = hash<Rest...>{}(rest...);
+			seed ^= hash<T>{}(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+			return seed;
+		}
+	};
+}
+
+END_XG_NAMESPACE
+
+namespace std
+{
+	// Template specialization for std::swap<Guid>() --
+	// See guid.cpp for the function definition
+	template <>
+	void swap(xg::Guid &guid0, xg::Guid &guid1) noexcept;
+
+	// Specialization for std::hash<Guid> -- this implementation
+	// uses std::hash<std::string> on the stringification of the guid
+	// to calculate the hash
+	template <>
+	struct hash<xg::Guid>
+	{
+		std::size_t operator()(xg::Guid const &guid) const
+		{
+			const uint64_t* p = reinterpret_cast<const uint64_t*>(guid.bytes().data());
+			return xg::details::hash<uint64_t, uint64_t>{}(p[0], p[1]);
+		}
+	};
+}
diff --git a/engine/inc/bullet/ThirdPartyLibs/enet/include/enet/callbacks.h b/engine/inc/bullet/ThirdPartyLibs/enet/include/enet/callbacks.h
new file mode 100644
index 00000000..46a0f4f4
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/enet/include/enet/callbacks.h
@@ -0,0 +1,26 @@
+/** 
+ @file  callbacks.h
+ @brief ENet callbacks
+*/
+#ifndef __ENET_CALLBACKS_H__
+#define __ENET_CALLBACKS_H__
+
+#include <stdlib.h>
+
+typedef struct _ENetCallbacks
+{
+	void *(ENET_CALLBACK *malloc)(size_t size);
+	void(ENET_CALLBACK *free)(void *memory);
+	void(ENET_CALLBACK *no_memory)(void);
+} ENetCallbacks;
+
+/** @defgroup callbacks ENet internal callbacks
+    @{
+    @ingroup private
+*/
+extern void *enet_malloc(size_t);
+extern void enet_free(void *);
+
+/** @} */
+
+#endif /* __ENET_CALLBACKS_H__ */
diff --git a/engine/inc/bullet/ThirdPartyLibs/enet/include/enet/enet.h b/engine/inc/bullet/ThirdPartyLibs/enet/include/enet/enet.h
new file mode 100644
index 00000000..1d27227e
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/enet/include/enet/enet.h
@@ -0,0 +1,570 @@
+/** 
+ @file  enet.h
+ @brief ENet public header file
+*/
+#ifndef __ENET_ENET_H__
+#define __ENET_ENET_H__
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <stdlib.h>
+
+#ifdef WIN32
+#include "enet/win32.h"
+#else
+#include "enet/unix.h"
+#endif
+
+#include "enet/types.h"
+#include "enet/protocol.h"
+#include "enet/list.h"
+#include "enet/callbacks.h"
+
+#define ENET_VERSION_MAJOR 1
+#define ENET_VERSION_MINOR 3
+#define ENET_VERSION_PATCH 7
+#define ENET_VERSION_CREATE(major, minor, patch) (((major) << 16) | ((minor) << 8) | (patch))
+#define ENET_VERSION ENET_VERSION_CREATE(ENET_VERSION_MAJOR, ENET_VERSION_MINOR, ENET_VERSION_PATCH)
+
+	typedef enet_uint32 ENetVersion;
+
+	struct _ENetHost;
+	struct _ENetEvent;
+	struct _ENetPacket;
+
+	typedef enum _ENetSocketType
+	{
+		ENET_SOCKET_TYPE_STREAM = 1,
+		ENET_SOCKET_TYPE_DATAGRAM = 2
+	} ENetSocketType;
+
+	typedef enum _ENetSocketWait
+	{
+		ENET_SOCKET_WAIT_NONE = 0,
+		ENET_SOCKET_WAIT_SEND = (1 << 0),
+		ENET_SOCKET_WAIT_RECEIVE = (1 << 1)
+	} ENetSocketWait;
+
+	typedef enum _ENetSocketOption
+	{
+		ENET_SOCKOPT_NONBLOCK = 1,
+		ENET_SOCKOPT_BROADCAST = 2,
+		ENET_SOCKOPT_RCVBUF = 3,
+		ENET_SOCKOPT_SNDBUF = 4,
+		ENET_SOCKOPT_REUSEADDR = 5,
+		ENET_SOCKOPT_RCVTIMEO = 6,
+		ENET_SOCKOPT_SNDTIMEO = 7
+	} ENetSocketOption;
+
+	typedef enum _ENetSocketShutdown
+	{
+		ENET_SOCKET_SHUTDOWN_READ = 0,
+		ENET_SOCKET_SHUTDOWN_WRITE = 1,
+		ENET_SOCKET_SHUTDOWN_READ_WRITE = 2
+	} ENetSocketShutdown;
+
+	enum
+	{
+		ENET_HOST_ANY = 0,                /**< specifies the default server host */
+		ENET_HOST_BROADCAST = 0xFFFFFFFF, /**< specifies a subnet-wide broadcast */
+
+		ENET_PORT_ANY = 0 /**< specifies that a port should be automatically chosen */
+	};
+
+	/**
+ * Portable internet address structure. 
+ *
+ * The host must be specified in network byte-order, and the port must be in host 
+ * byte-order. The constant ENET_HOST_ANY may be used to specify the default 
+ * server host. The constant ENET_HOST_BROADCAST may be used to specify the
+ * broadcast address (255.255.255.255).  This makes sense for enet_host_connect,
+ * but not for enet_host_create.  Once a server responds to a broadcast, the
+ * address is updated from ENET_HOST_BROADCAST to the server's actual IP address.
+ */
+	typedef struct _ENetAddress
+	{
+		enet_uint32 host;
+		enet_uint16 port;
+	} ENetAddress;
+
+	/**
+ * Packet flag bit constants.
+ *
+ * The host must be specified in network byte-order, and the port must be in
+ * host byte-order. The constant ENET_HOST_ANY may be used to specify the
+ * default server host.
+ 
+   @sa ENetPacket
+*/
+	typedef enum _ENetPacketFlag
+	{
+		/** packet must be received by the target peer and resend attempts should be
+     * made until the packet is delivered */
+		ENET_PACKET_FLAG_RELIABLE = (1 << 0),
+		/** packet will not be sequenced with other packets
+     * not supported for reliable packets
+     */
+		ENET_PACKET_FLAG_UNSEQUENCED = (1 << 1),
+		/** packet will not allocate data, and user must supply it instead */
+		ENET_PACKET_FLAG_NO_ALLOCATE = (1 << 2),
+		/** packet will be fragmented using unreliable (instead of reliable) sends
+     * if it exceeds the MTU */
+		ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT = (1 << 3),
+
+		/** whether the packet has been sent from all queues it has been entered into */
+		ENET_PACKET_FLAG_SENT = (1 << 8)
+	} ENetPacketFlag;
+
+	typedef void(ENET_CALLBACK *ENetPacketFreeCallback)(struct _ENetPacket *);
+
+	/**
+ * ENet packet structure.
+ *
+ * An ENet data packet that may be sent to or received from a peer. The shown 
+ * fields should only be read and never modified. The data field contains the 
+ * allocated data for the packet. The dataLength fields specifies the length 
+ * of the allocated data.  The flags field is either 0 (specifying no flags), 
+ * or a bitwise-or of any combination of the following flags:
+ *
+ *    ENET_PACKET_FLAG_RELIABLE - packet must be received by the target peer
+ *    and resend attempts should be made until the packet is delivered
+ *
+ *    ENET_PACKET_FLAG_UNSEQUENCED - packet will not be sequenced with other packets 
+ *    (not supported for reliable packets)
+ *
+ *    ENET_PACKET_FLAG_NO_ALLOCATE - packet will not allocate data, and user must supply it instead
+ 
+   @sa ENetPacketFlag
+ */
+	typedef struct _ENetPacket
+	{
+		size_t referenceCount;               /**< internal use only */
+		enet_uint32 flags;                   /**< bitwise-or of ENetPacketFlag constants */
+		enet_uint8 *data;                    /**< allocated data for packet */
+		size_t dataLength;                   /**< length of data */
+		ENetPacketFreeCallback freeCallback; /**< function to be called when the packet is no longer in use */
+		void *userData;                      /**< application private data, may be freely modified */
+	} ENetPacket;
+
+	typedef struct _ENetAcknowledgement
+	{
+		ENetListNode acknowledgementList;
+		enet_uint32 sentTime;
+		ENetProtocol command;
+	} ENetAcknowledgement;
+
+	typedef struct _ENetOutgoingCommand
+	{
+		ENetListNode outgoingCommandList;
+		enet_uint16 reliableSequenceNumber;
+		enet_uint16 unreliableSequenceNumber;
+		enet_uint32 sentTime;
+		enet_uint32 roundTripTimeout;
+		enet_uint32 roundTripTimeoutLimit;
+		enet_uint32 fragmentOffset;
+		enet_uint16 fragmentLength;
+		enet_uint16 sendAttempts;
+		ENetProtocol command;
+		ENetPacket *packet;
+	} ENetOutgoingCommand;
+
+	typedef struct _ENetIncomingCommand
+	{
+		ENetListNode incomingCommandList;
+		enet_uint16 reliableSequenceNumber;
+		enet_uint16 unreliableSequenceNumber;
+		ENetProtocol command;
+		enet_uint32 fragmentCount;
+		enet_uint32 fragmentsRemaining;
+		enet_uint32 *fragments;
+		ENetPacket *packet;
+	} ENetIncomingCommand;
+
+	typedef enum _ENetPeerState
+	{
+		ENET_PEER_STATE_DISCONNECTED = 0,
+		ENET_PEER_STATE_CONNECTING = 1,
+		ENET_PEER_STATE_ACKNOWLEDGING_CONNECT = 2,
+		ENET_PEER_STATE_CONNECTION_PENDING = 3,
+		ENET_PEER_STATE_CONNECTION_SUCCEEDED = 4,
+		ENET_PEER_STATE_CONNECTED = 5,
+		ENET_PEER_STATE_DISCONNECT_LATER = 6,
+		ENET_PEER_STATE_DISCONNECTING = 7,
+		ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT = 8,
+		ENET_PEER_STATE_ZOMBIE = 9
+	} ENetPeerState;
+
+#ifndef ENET_BUFFER_MAXIMUM
+#define ENET_BUFFER_MAXIMUM (1 + 2 * ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS)
+#endif
+
+	enum
+	{
+		ENET_HOST_RECEIVE_BUFFER_SIZE = 256 * 1024,
+		ENET_HOST_SEND_BUFFER_SIZE = 256 * 1024,
+		ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL = 1000,
+		ENET_HOST_DEFAULT_MTU = 1400,
+
+		ENET_PEER_DEFAULT_ROUND_TRIP_TIME = 500,
+		ENET_PEER_DEFAULT_PACKET_THROTTLE = 32,
+		ENET_PEER_PACKET_THROTTLE_SCALE = 32,
+		ENET_PEER_PACKET_THROTTLE_COUNTER = 7,
+		ENET_PEER_PACKET_THROTTLE_ACCELERATION = 2,
+		ENET_PEER_PACKET_THROTTLE_DECELERATION = 2,
+		ENET_PEER_PACKET_THROTTLE_INTERVAL = 5000,
+		ENET_PEER_PACKET_LOSS_SCALE = (1 << 16),
+		ENET_PEER_PACKET_LOSS_INTERVAL = 10000,
+		ENET_PEER_WINDOW_SIZE_SCALE = 64 * 1024,
+		ENET_PEER_TIMEOUT_LIMIT = 32,
+		ENET_PEER_TIMEOUT_MINIMUM = 5000,
+		ENET_PEER_TIMEOUT_MAXIMUM = 30000,
+		ENET_PEER_PING_INTERVAL = 500,
+		ENET_PEER_UNSEQUENCED_WINDOWS = 64,
+		ENET_PEER_UNSEQUENCED_WINDOW_SIZE = 1024,
+		ENET_PEER_FREE_UNSEQUENCED_WINDOWS = 32,
+		ENET_PEER_RELIABLE_WINDOWS = 16,
+		ENET_PEER_RELIABLE_WINDOW_SIZE = 0x1000,
+		ENET_PEER_FREE_RELIABLE_WINDOWS = 8
+	};
+
+	typedef struct _ENetChannel
+	{
+		enet_uint16 outgoingReliableSequenceNumber;
+		enet_uint16 outgoingUnreliableSequenceNumber;
+		enet_uint16 usedReliableWindows;
+		enet_uint16 reliableWindows[ENET_PEER_RELIABLE_WINDOWS];
+		enet_uint16 incomingReliableSequenceNumber;
+		enet_uint16 incomingUnreliableSequenceNumber;
+		ENetList incomingReliableCommands;
+		ENetList incomingUnreliableCommands;
+	} ENetChannel;
+
+	/**
+ * An ENet peer which data packets may be sent or received from. 
+ *
+ * No fields should be modified unless otherwise specified. 
+ */
+	typedef struct _ENetPeer
+	{
+		ENetListNode dispatchList;
+		struct _ENetHost *host;
+		enet_uint16 outgoingPeerID;
+		enet_uint16 incomingPeerID;
+		enet_uint32 connectID;
+		enet_uint8 outgoingSessionID;
+		enet_uint8 incomingSessionID;
+		ENetAddress address; /**< Internet address of the peer */
+		void *data;          /**< Application private data, may be freely modified */
+		ENetPeerState state;
+		ENetChannel *channels;
+		size_t channelCount;           /**< Number of channels allocated for communication with peer */
+		enet_uint32 incomingBandwidth; /**< Downstream bandwidth of the client in bytes/second */
+		enet_uint32 outgoingBandwidth; /**< Upstream bandwidth of the client in bytes/second */
+		enet_uint32 incomingBandwidthThrottleEpoch;
+		enet_uint32 outgoingBandwidthThrottleEpoch;
+		enet_uint32 incomingDataTotal;
+		enet_uint32 outgoingDataTotal;
+		enet_uint32 lastSendTime;
+		enet_uint32 lastReceiveTime;
+		enet_uint32 nextTimeout;
+		enet_uint32 earliestTimeout;
+		enet_uint32 packetLossEpoch;
+		enet_uint32 packetsSent;
+		enet_uint32 packetsLost;
+		enet_uint32 packetLoss; /**< mean packet loss of reliable packets as a ratio with respect to the constant ENET_PEER_PACKET_LOSS_SCALE */
+		enet_uint32 packetLossVariance;
+		enet_uint32 packetThrottle;
+		enet_uint32 packetThrottleLimit;
+		enet_uint32 packetThrottleCounter;
+		enet_uint32 packetThrottleEpoch;
+		enet_uint32 packetThrottleAcceleration;
+		enet_uint32 packetThrottleDeceleration;
+		enet_uint32 packetThrottleInterval;
+		enet_uint32 pingInterval;
+		enet_uint32 timeoutLimit;
+		enet_uint32 timeoutMinimum;
+		enet_uint32 timeoutMaximum;
+		enet_uint32 lastRoundTripTime;
+		enet_uint32 lowestRoundTripTime;
+		enet_uint32 lastRoundTripTimeVariance;
+		enet_uint32 highestRoundTripTimeVariance;
+		enet_uint32 roundTripTime; /**< mean round trip time (RTT), in milliseconds, between sending a reliable packet and receiving its acknowledgement */
+		enet_uint32 roundTripTimeVariance;
+		enet_uint32 mtu;
+		enet_uint32 windowSize;
+		enet_uint32 reliableDataInTransit;
+		enet_uint16 outgoingReliableSequenceNumber;
+		ENetList acknowledgements;
+		ENetList sentReliableCommands;
+		ENetList sentUnreliableCommands;
+		ENetList outgoingReliableCommands;
+		ENetList outgoingUnreliableCommands;
+		ENetList dispatchedCommands;
+		int needsDispatch;
+		enet_uint16 incomingUnsequencedGroup;
+		enet_uint16 outgoingUnsequencedGroup;
+		enet_uint32 unsequencedWindow[ENET_PEER_UNSEQUENCED_WINDOW_SIZE / 32];
+		enet_uint32 eventData;
+	} ENetPeer;
+
+	/** An ENet packet compressor for compressing UDP packets before socket sends or receives.
+ */
+	typedef struct _ENetCompressor
+	{
+		/** Context data for the compressor. Must be non-NULL. */
+		void *context;
+		/** Compresses from inBuffers[0:inBufferCount-1], containing inLimit bytes, to outData, outputting at most outLimit bytes. Should return 0 on failure. */
+		size_t(ENET_CALLBACK *compress)(void *context, const ENetBuffer *inBuffers, size_t inBufferCount, size_t inLimit, enet_uint8 *outData, size_t outLimit);
+		/** Decompresses from inData, containing inLimit bytes, to outData, outputting at most outLimit bytes. Should return 0 on failure. */
+		size_t(ENET_CALLBACK *decompress)(void *context, const enet_uint8 *inData, size_t inLimit, enet_uint8 *outData, size_t outLimit);
+		/** Destroys the context when compression is disabled or the host is destroyed. May be NULL. */
+		void(ENET_CALLBACK *destroy)(void *context);
+	} ENetCompressor;
+
+	/** Callback that computes the checksum of the data held in buffers[0:bufferCount-1] */
+	typedef enet_uint32(ENET_CALLBACK *ENetChecksumCallback)(const ENetBuffer *buffers, size_t bufferCount);
+
+	/** Callback for intercepting received raw UDP packets. Should return 1 to intercept, 0 to ignore, or -1 to propagate an error. */
+	typedef int(ENET_CALLBACK *ENetInterceptCallback)(struct _ENetHost *host, struct _ENetEvent *event);
+
+	/** An ENet host for communicating with peers.
+  *
+  * No fields should be modified unless otherwise stated.
+
+    @sa enet_host_create()
+    @sa enet_host_destroy()
+    @sa enet_host_connect()
+    @sa enet_host_service()
+    @sa enet_host_flush()
+    @sa enet_host_broadcast()
+    @sa enet_host_compress()
+    @sa enet_host_compress_with_range_coder()
+    @sa enet_host_channel_limit()
+    @sa enet_host_bandwidth_limit()
+    @sa enet_host_bandwidth_throttle()
+  */
+	typedef struct _ENetHost
+	{
+		ENetSocket socket;
+		ENetAddress address;           /**< Internet address of the host */
+		enet_uint32 incomingBandwidth; /**< downstream bandwidth of the host */
+		enet_uint32 outgoingBandwidth; /**< upstream bandwidth of the host */
+		enet_uint32 bandwidthThrottleEpoch;
+		enet_uint32 mtu;
+		enet_uint32 randomSeed;
+		int recalculateBandwidthLimits;
+		ENetPeer *peers;     /**< array of peers allocated for this host */
+		size_t peerCount;    /**< number of peers allocated for this host */
+		size_t channelLimit; /**< maximum number of channels allowed for connected peers */
+		enet_uint32 serviceTime;
+		ENetList dispatchQueue;
+		int continueSending;
+		size_t packetSize;
+		enet_uint16 headerFlags;
+		ENetProtocol commands[ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS];
+		size_t commandCount;
+		ENetBuffer buffers[ENET_BUFFER_MAXIMUM];
+		size_t bufferCount;
+		ENetChecksumCallback checksum; /**< callback the user can set to enable packet checksums for this host */
+		ENetCompressor compressor;
+		enet_uint8 packetData[2][ENET_PROTOCOL_MAXIMUM_MTU];
+		ENetAddress receivedAddress;
+		enet_uint8 *receivedData;
+		size_t receivedDataLength;
+		enet_uint32 totalSentData;        /**< total data sent, user should reset to 0 as needed to prevent overflow */
+		enet_uint32 totalSentPackets;     /**< total UDP packets sent, user should reset to 0 as needed to prevent overflow */
+		enet_uint32 totalReceivedData;    /**< total data received, user should reset to 0 as needed to prevent overflow */
+		enet_uint32 totalReceivedPackets; /**< total UDP packets received, user should reset to 0 as needed to prevent overflow */
+		ENetInterceptCallback intercept;  /**< callback the user can set to intercept received raw UDP packets */
+	} ENetHost;
+
+	/**
+ * An ENet event type, as specified in @ref ENetEvent.
+ */
+	typedef enum _ENetEventType
+	{
+		/** no event occurred within the specified time limit */
+		ENET_EVENT_TYPE_NONE = 0,
+
+		/** a connection request initiated by enet_host_connect has completed.  
+     * The peer field contains the peer which successfully connected. 
+     */
+		ENET_EVENT_TYPE_CONNECT = 1,
+
+		/** a peer has disconnected.  This event is generated on a successful 
+     * completion of a disconnect initiated by enet_pper_disconnect, if 
+     * a peer has timed out, or if a connection request intialized by 
+     * enet_host_connect has timed out.  The peer field contains the peer 
+     * which disconnected. The data field contains user supplied data 
+     * describing the disconnection, or 0, if none is available.
+     */
+		ENET_EVENT_TYPE_DISCONNECT = 2,
+
+		/** a packet has been received from a peer.  The peer field specifies the
+     * peer which sent the packet.  The channelID field specifies the channel
+     * number upon which the packet was received.  The packet field contains
+     * the packet that was received; this packet must be destroyed with
+     * enet_packet_destroy after use.
+     */
+		ENET_EVENT_TYPE_RECEIVE = 3
+	} ENetEventType;
+
+	/**
+ * An ENet event as returned by enet_host_service().
+   
+   @sa enet_host_service
+ */
+	typedef struct _ENetEvent
+	{
+		ENetEventType type;   /**< type of the event */
+		ENetPeer *peer;       /**< peer that generated a connect, disconnect or receive event */
+		enet_uint8 channelID; /**< channel on the peer that generated the event, if appropriate */
+		enet_uint32 data;     /**< data associated with the event, if appropriate */
+		ENetPacket *packet;   /**< packet associated with the event, if appropriate */
+	} ENetEvent;
+
+	/** @defgroup global ENet global functions
+    @{ 
+*/
+
+	/** 
+  Initializes ENet globally.  Must be called prior to using any functions in
+  ENet.
+  @returns 0 on success, < 0 on failure
+*/
+	ENET_API int enet_initialize(void);
+
+	/** 
+  Initializes ENet globally and supplies user-overridden callbacks. Must be called prior to using any functions in ENet. Do not use enet_initialize() if you use this variant. Make sure the ENetCallbacks structure is zeroed out so that any additional callbacks added in future versions will be properly ignored.
+
+  @param version the constant ENET_VERSION should be supplied so ENet knows which version of ENetCallbacks struct to use
+  @param inits user-overriden callbacks where any NULL callbacks will use ENet's defaults
+  @returns 0 on success, < 0 on failure
+*/
+	ENET_API int enet_initialize_with_callbacks(ENetVersion version, const ENetCallbacks *inits);
+
+	/** 
+  Shuts down ENet globally.  Should be called when a program that has
+  initialized ENet exits.
+*/
+	ENET_API void enet_deinitialize(void);
+
+	/** @} */
+
+	/** @defgroup private ENet private implementation functions */
+
+	/**
+  Returns the wall-time in milliseconds.  Its initial value is unspecified
+  unless otherwise set.
+  */
+	ENET_API enet_uint32 enet_time_get(void);
+	/**
+  Sets the current wall-time in milliseconds.
+  */
+	ENET_API void enet_time_set(enet_uint32);
+
+	/** @defgroup socket ENet socket functions
+    @{
+*/
+	ENET_API ENetSocket enet_socket_create(ENetSocketType);
+	ENET_API int enet_socket_bind(ENetSocket, const ENetAddress *);
+	ENET_API int enet_socket_listen(ENetSocket, int);
+	ENET_API ENetSocket enet_socket_accept(ENetSocket, ENetAddress *);
+	ENET_API int enet_socket_connect(ENetSocket, const ENetAddress *);
+	ENET_API int enet_socket_send(ENetSocket, const ENetAddress *, const ENetBuffer *, size_t);
+	ENET_API int enet_socket_receive(ENetSocket, ENetAddress *, ENetBuffer *, size_t);
+	ENET_API int enet_socket_wait(ENetSocket, enet_uint32 *, enet_uint32);
+	ENET_API int enet_socket_set_option(ENetSocket, ENetSocketOption, int);
+	ENET_API int enet_socket_shutdown(ENetSocket, ENetSocketShutdown);
+	ENET_API void enet_socket_destroy(ENetSocket);
+	ENET_API int enet_socketset_select(ENetSocket, ENetSocketSet *, ENetSocketSet *, enet_uint32);
+
+	/** @} */
+
+	/** @defgroup Address ENet address functions
+    @{
+*/
+	/** Attempts to resolve the host named by the parameter hostName and sets
+    the host field in the address parameter if successful.
+    @param address destination to store resolved address
+    @param hostName host name to lookup
+    @retval 0 on success
+    @retval < 0 on failure
+    @returns the address of the given hostName in address on success
+*/
+	ENET_API int enet_address_set_host(ENetAddress *address, const char *hostName);
+
+	/** Gives the printable form of the ip address specified in the address parameter.
+    @param address    address printed
+    @param hostName   destination for name, must not be NULL
+    @param nameLength maximum length of hostName.
+    @returns the null-terminated name of the host in hostName on success
+    @retval 0 on success
+    @retval < 0 on failure
+*/
+	ENET_API int enet_address_get_host_ip(const ENetAddress *address, char *hostName, size_t nameLength);
+
+	/** Attempts to do a reverse lookup of the host field in the address parameter.
+    @param address    address used for reverse lookup
+    @param hostName   destination for name, must not be NULL
+    @param nameLength maximum length of hostName.
+    @returns the null-terminated name of the host in hostName on success
+    @retval 0 on success
+    @retval < 0 on failure
+*/
+	ENET_API int enet_address_get_host(const ENetAddress *address, char *hostName, size_t nameLength);
+
+	/** @} */
+
+	ENET_API ENetPacket *enet_packet_create(const void *, size_t, enet_uint32);
+	ENET_API void enet_packet_destroy(ENetPacket *);
+	ENET_API int enet_packet_resize(ENetPacket *, size_t);
+	ENET_API enet_uint32 enet_crc32(const ENetBuffer *, size_t);
+
+	ENET_API ENetHost *enet_host_create(const ENetAddress *, size_t, size_t, enet_uint32, enet_uint32);
+	ENET_API void enet_host_destroy(ENetHost *);
+	ENET_API ENetPeer *enet_host_connect(ENetHost *, const ENetAddress *, size_t, enet_uint32);
+	ENET_API int enet_host_check_events(ENetHost *, ENetEvent *);
+	ENET_API int enet_host_service(ENetHost *, ENetEvent *, enet_uint32);
+	ENET_API void enet_host_flush(ENetHost *);
+	ENET_API void enet_host_broadcast(ENetHost *, enet_uint8, ENetPacket *);
+	ENET_API void enet_host_compress(ENetHost *, const ENetCompressor *);
+	ENET_API int enet_host_compress_with_range_coder(ENetHost *host);
+	ENET_API void enet_host_channel_limit(ENetHost *, size_t);
+	ENET_API void enet_host_bandwidth_limit(ENetHost *, enet_uint32, enet_uint32);
+	extern void enet_host_bandwidth_throttle(ENetHost *);
+
+	ENET_API int enet_peer_send(ENetPeer *, enet_uint8, ENetPacket *);
+	ENET_API ENetPacket *enet_peer_receive(ENetPeer *, enet_uint8 *channelID);
+	ENET_API void enet_peer_ping(ENetPeer *);
+	ENET_API void enet_peer_ping_interval(ENetPeer *, enet_uint32);
+	ENET_API void enet_peer_timeout(ENetPeer *, enet_uint32, enet_uint32, enet_uint32);
+	ENET_API void enet_peer_reset(ENetPeer *);
+	ENET_API void enet_peer_disconnect(ENetPeer *, enet_uint32);
+	ENET_API void enet_peer_disconnect_now(ENetPeer *, enet_uint32);
+	ENET_API void enet_peer_disconnect_later(ENetPeer *, enet_uint32);
+	ENET_API void enet_peer_throttle_configure(ENetPeer *, enet_uint32, enet_uint32, enet_uint32);
+	extern int enet_peer_throttle(ENetPeer *, enet_uint32);
+	extern void enet_peer_reset_queues(ENetPeer *);
+	extern void enet_peer_setup_outgoing_command(ENetPeer *, ENetOutgoingCommand *);
+	extern ENetOutgoingCommand *enet_peer_queue_outgoing_command(ENetPeer *, const ENetProtocol *, ENetPacket *, enet_uint32, enet_uint16);
+	extern ENetIncomingCommand *enet_peer_queue_incoming_command(ENetPeer *, const ENetProtocol *, ENetPacket *, enet_uint32);
+	extern ENetAcknowledgement *enet_peer_queue_acknowledgement(ENetPeer *, const ENetProtocol *, enet_uint16);
+	extern void enet_peer_dispatch_incoming_unreliable_commands(ENetPeer *, ENetChannel *);
+	extern void enet_peer_dispatch_incoming_reliable_commands(ENetPeer *, ENetChannel *);
+
+	ENET_API void *enet_range_coder_create(void);
+	ENET_API void enet_range_coder_destroy(void *);
+	ENET_API size_t enet_range_coder_compress(void *, const ENetBuffer *, size_t, size_t, enet_uint8 *, size_t);
+	ENET_API size_t enet_range_coder_decompress(void *, const enet_uint8 *, size_t, enet_uint8 *, size_t);
+
+	extern size_t enet_protocol_command_size(enet_uint8);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __ENET_ENET_H__ */
diff --git a/engine/inc/bullet/ThirdPartyLibs/enet/include/enet/list.h b/engine/inc/bullet/ThirdPartyLibs/enet/include/enet/list.h
new file mode 100644
index 00000000..ec1b3966
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/enet/include/enet/list.h
@@ -0,0 +1,42 @@
+/** 
+ @file  list.h
+ @brief ENet list management 
+*/
+#ifndef __ENET_LIST_H__
+#define __ENET_LIST_H__
+
+#include <stdlib.h>
+
+typedef struct _ENetListNode
+{
+	struct _ENetListNode *next;
+	struct _ENetListNode *previous;
+} ENetListNode;
+
+typedef ENetListNode *ENetListIterator;
+
+typedef struct _ENetList
+{
+	ENetListNode sentinel;
+} ENetList;
+
+extern void enet_list_clear(ENetList *);
+
+extern ENetListIterator enet_list_insert(ENetListIterator, void *);
+extern void *enet_list_remove(ENetListIterator);
+extern ENetListIterator enet_list_move(ENetListIterator, void *, void *);
+
+extern size_t enet_list_size(ENetList *);
+
+#define enet_list_begin(list) ((list)->sentinel.next)
+#define enet_list_end(list) (&(list)->sentinel)
+
+#define enet_list_empty(list) (enet_list_begin(list) == enet_list_end(list))
+
+#define enet_list_next(iterator) ((iterator)->next)
+#define enet_list_previous(iterator) ((iterator)->previous)
+
+#define enet_list_front(list) ((void *)(list)->sentinel.next)
+#define enet_list_back(list) ((void *)(list)->sentinel.previous)
+
+#endif /* __ENET_LIST_H__ */
diff --git a/engine/inc/bullet/ThirdPartyLibs/enet/include/enet/protocol.h b/engine/inc/bullet/ThirdPartyLibs/enet/include/enet/protocol.h
new file mode 100644
index 00000000..ba71419d
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/enet/include/enet/protocol.h
@@ -0,0 +1,197 @@
+/** 
+ @file  protocol.h
+ @brief ENet protocol
+*/
+#ifndef __ENET_PROTOCOL_H__
+#define __ENET_PROTOCOL_H__
+
+#include "enet/types.h"
+
+enum
+{
+	ENET_PROTOCOL_MINIMUM_MTU = 576,
+	ENET_PROTOCOL_MAXIMUM_MTU = 4096,
+	ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS = 32,
+	ENET_PROTOCOL_MINIMUM_WINDOW_SIZE = 4096,
+	ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE = 32768,
+	ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT = 1,
+	ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT = 255,
+	ENET_PROTOCOL_MAXIMUM_PEER_ID = 0xFFF,
+	ENET_PROTOCOL_MAXIMUM_PACKET_SIZE = 1024 * 1024 * 1024,
+	ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT = 1024 * 1024
+};
+
+typedef enum _ENetProtocolCommand
+{
+	ENET_PROTOCOL_COMMAND_NONE = 0,
+	ENET_PROTOCOL_COMMAND_ACKNOWLEDGE = 1,
+	ENET_PROTOCOL_COMMAND_CONNECT = 2,
+	ENET_PROTOCOL_COMMAND_VERIFY_CONNECT = 3,
+	ENET_PROTOCOL_COMMAND_DISCONNECT = 4,
+	ENET_PROTOCOL_COMMAND_PING = 5,
+	ENET_PROTOCOL_COMMAND_SEND_RELIABLE = 6,
+	ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE = 7,
+	ENET_PROTOCOL_COMMAND_SEND_FRAGMENT = 8,
+	ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED = 9,
+	ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT = 10,
+	ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE = 11,
+	ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE_FRAGMENT = 12,
+	ENET_PROTOCOL_COMMAND_COUNT = 13,
+
+	ENET_PROTOCOL_COMMAND_MASK = 0x0F
+} ENetProtocolCommand;
+
+typedef enum _ENetProtocolFlag
+{
+	ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE = (1 << 7),
+	ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED = (1 << 6),
+
+	ENET_PROTOCOL_HEADER_FLAG_COMPRESSED = (1 << 14),
+	ENET_PROTOCOL_HEADER_FLAG_SENT_TIME = (1 << 15),
+	ENET_PROTOCOL_HEADER_FLAG_MASK = ENET_PROTOCOL_HEADER_FLAG_COMPRESSED | ENET_PROTOCOL_HEADER_FLAG_SENT_TIME,
+
+	ENET_PROTOCOL_HEADER_SESSION_MASK = (3 << 12),
+	ENET_PROTOCOL_HEADER_SESSION_SHIFT = 12
+} ENetProtocolFlag;
+
+#ifdef _MSC_VER_
+#pragma pack(push, 1)
+#define ENET_PACKED
+#elif defined(__GNUC__)
+#define ENET_PACKED __attribute__((packed))
+#else
+#define ENET_PACKED
+#endif
+
+typedef struct _ENetProtocolHeader
+{
+	enet_uint16 peerID;
+	enet_uint16 sentTime;
+} ENET_PACKED ENetProtocolHeader;
+
+typedef struct _ENetProtocolCommandHeader
+{
+	enet_uint8 command;
+	enet_uint8 channelID;
+	enet_uint16 reliableSequenceNumber;
+} ENET_PACKED ENetProtocolCommandHeader;
+
+typedef struct _ENetProtocolAcknowledge
+{
+	ENetProtocolCommandHeader header;
+	enet_uint16 receivedReliableSequenceNumber;
+	enet_uint16 receivedSentTime;
+} ENET_PACKED ENetProtocolAcknowledge;
+
+typedef struct _ENetProtocolConnect
+{
+	ENetProtocolCommandHeader header;
+	enet_uint16 outgoingPeerID;
+	enet_uint8 incomingSessionID;
+	enet_uint8 outgoingSessionID;
+	enet_uint32 mtu;
+	enet_uint32 windowSize;
+	enet_uint32 channelCount;
+	enet_uint32 incomingBandwidth;
+	enet_uint32 outgoingBandwidth;
+	enet_uint32 packetThrottleInterval;
+	enet_uint32 packetThrottleAcceleration;
+	enet_uint32 packetThrottleDeceleration;
+	enet_uint32 connectID;
+	enet_uint32 data;
+} ENET_PACKED ENetProtocolConnect;
+
+typedef struct _ENetProtocolVerifyConnect
+{
+	ENetProtocolCommandHeader header;
+	enet_uint16 outgoingPeerID;
+	enet_uint8 incomingSessionID;
+	enet_uint8 outgoingSessionID;
+	enet_uint32 mtu;
+	enet_uint32 windowSize;
+	enet_uint32 channelCount;
+	enet_uint32 incomingBandwidth;
+	enet_uint32 outgoingBandwidth;
+	enet_uint32 packetThrottleInterval;
+	enet_uint32 packetThrottleAcceleration;
+	enet_uint32 packetThrottleDeceleration;
+	enet_uint32 connectID;
+} ENET_PACKED ENetProtocolVerifyConnect;
+
+typedef struct _ENetProtocolBandwidthLimit
+{
+	ENetProtocolCommandHeader header;
+	enet_uint32 incomingBandwidth;
+	enet_uint32 outgoingBandwidth;
+} ENET_PACKED ENetProtocolBandwidthLimit;
+
+typedef struct _ENetProtocolThrottleConfigure
+{
+	ENetProtocolCommandHeader header;
+	enet_uint32 packetThrottleInterval;
+	enet_uint32 packetThrottleAcceleration;
+	enet_uint32 packetThrottleDeceleration;
+} ENET_PACKED ENetProtocolThrottleConfigure;
+
+typedef struct _ENetProtocolDisconnect
+{
+	ENetProtocolCommandHeader header;
+	enet_uint32 data;
+} ENET_PACKED ENetProtocolDisconnect;
+
+typedef struct _ENetProtocolPing
+{
+	ENetProtocolCommandHeader header;
+} ENET_PACKED ENetProtocolPing;
+
+typedef struct _ENetProtocolSendReliable
+{
+	ENetProtocolCommandHeader header;
+	enet_uint16 dataLength;
+} ENET_PACKED ENetProtocolSendReliable;
+
+typedef struct _ENetProtocolSendUnreliable
+{
+	ENetProtocolCommandHeader header;
+	enet_uint16 unreliableSequenceNumber;
+	enet_uint16 dataLength;
+} ENET_PACKED ENetProtocolSendUnreliable;
+
+typedef struct _ENetProtocolSendUnsequenced
+{
+	ENetProtocolCommandHeader header;
+	enet_uint16 unsequencedGroup;
+	enet_uint16 dataLength;
+} ENET_PACKED ENetProtocolSendUnsequenced;
+
+typedef struct _ENetProtocolSendFragment
+{
+	ENetProtocolCommandHeader header;
+	enet_uint16 startSequenceNumber;
+	enet_uint16 dataLength;
+	enet_uint32 fragmentCount;
+	enet_uint32 fragmentNumber;
+	enet_uint32 totalLength;
+	enet_uint32 fragmentOffset;
+} ENET_PACKED ENetProtocolSendFragment;
+
+typedef union _ENetProtocol {
+	ENetProtocolCommandHeader header;
+	ENetProtocolAcknowledge acknowledge;
+	ENetProtocolConnect connect;
+	ENetProtocolVerifyConnect verifyConnect;
+	ENetProtocolDisconnect disconnect;
+	ENetProtocolPing ping;
+	ENetProtocolSendReliable sendReliable;
+	ENetProtocolSendUnreliable sendUnreliable;
+	ENetProtocolSendUnsequenced sendUnsequenced;
+	ENetProtocolSendFragment sendFragment;
+	ENetProtocolBandwidthLimit bandwidthLimit;
+	ENetProtocolThrottleConfigure throttleConfigure;
+} ENET_PACKED ENetProtocol;
+
+#ifdef _MSC_VER_
+#pragma pack(pop)
+#endif
+
+#endif /* __ENET_PROTOCOL_H__ */
diff --git a/engine/inc/bullet/ThirdPartyLibs/enet/include/enet/time.h b/engine/inc/bullet/ThirdPartyLibs/enet/include/enet/time.h
new file mode 100644
index 00000000..3297e493
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/enet/include/enet/time.h
@@ -0,0 +1,17 @@
+/** 
+ @file  time.h
+ @brief ENet time constants and macros
+*/
+#ifndef __ENET_TIME_H__
+#define __ENET_TIME_H__
+
+#define ENET_TIME_OVERFLOW 86400000
+
+#define ENET_TIME_LESS(a, b) ((a) - (b) >= ENET_TIME_OVERFLOW)
+#define ENET_TIME_GREATER(a, b) ((b) - (a) >= ENET_TIME_OVERFLOW)
+#define ENET_TIME_LESS_EQUAL(a, b) (!ENET_TIME_GREATER(a, b))
+#define ENET_TIME_GREATER_EQUAL(a, b) (!ENET_TIME_LESS(a, b))
+
+#define ENET_TIME_DIFFERENCE(a, b) ((a) - (b) >= ENET_TIME_OVERFLOW ? (b) - (a) : (a) - (b))
+
+#endif /* __ENET_TIME_H__ */
diff --git a/engine/inc/bullet/ThirdPartyLibs/enet/include/enet/types.h b/engine/inc/bullet/ThirdPartyLibs/enet/include/enet/types.h
new file mode 100644
index 00000000..1337ef3a
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/enet/include/enet/types.h
@@ -0,0 +1,12 @@
+/** 
+ @file  types.h
+ @brief type definitions for ENet
+*/
+#ifndef __ENET_TYPES_H__
+#define __ENET_TYPES_H__
+
+typedef unsigned char enet_uint8;   /**< unsigned 8-bit type  */
+typedef unsigned short enet_uint16; /**< unsigned 16-bit type */
+typedef unsigned int enet_uint32;   /**< unsigned 32-bit type */
+
+#endif /* __ENET_TYPES_H__ */
diff --git a/engine/inc/bullet/ThirdPartyLibs/enet/include/enet/unix.h b/engine/inc/bullet/ThirdPartyLibs/enet/include/enet/unix.h
new file mode 100644
index 00000000..a63dc70a
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/enet/include/enet/unix.h
@@ -0,0 +1,44 @@
+/** 
+ @file  unix.h
+ @brief ENet Unix header
+*/
+#ifndef __ENET_UNIX_H__
+#define __ENET_UNIX_H__
+
+#include <stdlib.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <unistd.h>
+
+typedef int ENetSocket;
+
+enum
+{
+	ENET_SOCKET_NULL = -1
+};
+
+#define ENET_HOST_TO_NET_16(value) (htons(value)) /**< macro that converts host to net byte-order of a 16-bit value */
+#define ENET_HOST_TO_NET_32(value) (htonl(value)) /**< macro that converts host to net byte-order of a 32-bit value */
+
+#define ENET_NET_TO_HOST_16(value) (ntohs(value)) /**< macro that converts net to host byte-order of a 16-bit value */
+#define ENET_NET_TO_HOST_32(value) (ntohl(value)) /**< macro that converts net to host byte-order of a 32-bit value */
+
+typedef struct
+{
+	void* data;
+	size_t dataLength;
+} ENetBuffer;
+
+#define ENET_CALLBACK
+
+#define ENET_API extern
+
+typedef fd_set ENetSocketSet;
+
+#define ENET_SOCKETSET_EMPTY(sockset) FD_ZERO(&(sockset))
+#define ENET_SOCKETSET_ADD(sockset, socket) FD_SET(socket, &(sockset))
+#define ENET_SOCKETSET_REMOVE(sockset, socket) FD_CLEAR(socket, &(sockset))
+#define ENET_SOCKETSET_CHECK(sockset, socket) FD_ISSET(socket, &(sockset))
+
+#endif /* __ENET_UNIX_H__ */
diff --git a/engine/inc/bullet/ThirdPartyLibs/enet/include/enet/utility.h b/engine/inc/bullet/ThirdPartyLibs/enet/include/enet/utility.h
new file mode 100644
index 00000000..18f511d9
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/enet/include/enet/utility.h
@@ -0,0 +1,11 @@
+/** 
+ @file  utility.h
+ @brief ENet utility header
+*/
+#ifndef __ENET_UTILITY_H__
+#define __ENET_UTILITY_H__
+
+#define ENET_MAX(x, y) ((x) > (y) ? (x) : (y))
+#define ENET_MIN(x, y) ((x) < (y) ? (x) : (y))
+
+#endif /* __ENET_UTILITY_H__ */
diff --git a/engine/inc/bullet/ThirdPartyLibs/enet/include/enet/win32.h b/engine/inc/bullet/ThirdPartyLibs/enet/include/enet/win32.h
new file mode 100644
index 00000000..b4646e67
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/enet/include/enet/win32.h
@@ -0,0 +1,56 @@
+/** 
+ @file  win32.h
+ @brief ENet Win32 header
+*/
+#ifndef __ENET_WIN32_H__
+#define __ENET_WIN32_H__
+
+#ifdef ENET_BUILDING_LIB
+#pragma warning(disable : 4996)  // 'strncpy' was declared deprecated
+#pragma warning(disable : 4267)  // size_t to int conversion
+#pragma warning(disable : 4244)  // 64bit to 32bit int
+#pragma warning(disable : 4018)  // signed/unsigned mismatch
+#endif
+
+#include <stdlib.h>
+#include <winsock2.h>
+
+typedef SOCKET ENetSocket;
+
+enum
+{
+	ENET_SOCKET_NULL = INVALID_SOCKET
+};
+
+#define ENET_HOST_TO_NET_16(value) (htons(value))
+#define ENET_HOST_TO_NET_32(value) (htonl(value))
+
+#define ENET_NET_TO_HOST_16(value) (ntohs(value))
+#define ENET_NET_TO_HOST_32(value) (ntohl(value))
+
+typedef struct
+{
+	size_t dataLength;
+	void* data;
+} ENetBuffer;
+
+#define ENET_CALLBACK __cdecl
+
+#if defined ENET_DLL
+#if defined ENET_BUILDING_LIB
+#define ENET_API __declspec(dllexport)
+#else
+#define ENET_API __declspec(dllimport)
+#endif /* ENET_BUILDING_LIB */
+#else  /* !ENET_DLL */
+#define ENET_API extern
+#endif /* ENET_DLL */
+
+typedef fd_set ENetSocketSet;
+
+#define ENET_SOCKETSET_EMPTY(sockset) FD_ZERO(&(sockset))
+#define ENET_SOCKETSET_ADD(sockset, socket) FD_SET(socket, &(sockset))
+#define ENET_SOCKETSET_REMOVE(sockset, socket) FD_CLEAR(socket, &(sockset))
+#define ENET_SOCKETSET_CHECK(sockset, socket) FD_ISSET(socket, &(sockset))
+
+#endif /* __ENET_WIN32_H__ */
diff --git a/engine/inc/bullet/ThirdPartyLibs/glad/EGL/eglplatform.h b/engine/inc/bullet/ThirdPartyLibs/glad/EGL/eglplatform.h
new file mode 100644
index 00000000..694ef567
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/glad/EGL/eglplatform.h
@@ -0,0 +1,158 @@
+#ifndef __eglplatform_h_
+#define __eglplatform_h_
+
+/*
+** Copyright (c) 2007-2016 The Khronos Group Inc.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a
+** copy of this software and/or associated documentation files (the
+** "Materials"), to deal in the Materials without restriction, including
+** without limitation the rights to use, copy, modify, merge, publish,
+** distribute, sublicense, and/or sell copies of the Materials, and to
+** permit persons to whom the Materials are 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 Materials.
+**
+** THE MATERIALS ARE 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
+** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+*/
+
+/* Platform-specific types and definitions for egl.h
+ * $Revision: 30994 $ on $Date: 2015-04-30 13:36:48 -0700 (Thu, 30 Apr 2015) $
+ *
+ * Adopters may modify khrplatform.h and this file to suit their platform.
+ * You are encouraged to submit all modifications to the Khronos group so that
+ * they can be included in future versions of this file.  Please submit changes
+ * by sending them to the public Khronos Bugzilla (http://khronos.org/bugzilla)
+ * by filing a bug against product "EGL" component "Registry".
+ */
+
+#include <KHR/khrplatform.h>
+
+/* Macros used in EGL function prototype declarations.
+ *
+ * EGL functions should be prototyped as:
+ *
+ * EGLAPI return-type EGLAPIENTRY eglFunction(arguments);
+ * typedef return-type (EXPAPIENTRYP PFNEGLFUNCTIONPROC) (arguments);
+ *
+ * KHRONOS_APICALL and KHRONOS_APIENTRY are defined in KHR/khrplatform.h
+ */
+
+#ifndef EGLAPI
+#define EGLAPI KHRONOS_APICALL
+#endif
+
+#ifndef EGLAPIENTRY
+#define EGLAPIENTRY KHRONOS_APIENTRY
+#endif
+#define EGLAPIENTRYP EGLAPIENTRY*
+
+/* The types NativeDisplayType, NativeWindowType, and NativePixmapType
+ * are aliases of window-system-dependent types, such as X Display * or
+ * Windows Device Context. They must be defined in platform-specific
+ * code below. The EGL-prefixed versions of Native*Type are the same
+ * types, renamed in EGL 1.3 so all types in the API start with "EGL".
+ *
+ * Khronos STRONGLY RECOMMENDS that you use the default definitions
+ * provided below, since these changes affect both binary and source
+ * portability of applications using EGL running on different EGL
+ * implementations.
+ */
+
+#if defined(_WIN32) || defined(__VC32__) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) /* Win32 and WinCE */
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN 1
+#endif
+#include <windows.h>
+
+typedef HDC EGLNativeDisplayType;
+typedef HBITMAP EGLNativePixmapType;
+typedef HWND EGLNativeWindowType;
+
+#elif defined(__WINSCW__) || defined(__SYMBIAN32__) /* Symbian */
+
+typedef int EGLNativeDisplayType;
+typedef void *EGLNativeWindowType;
+typedef void *EGLNativePixmapType;
+
+#elif defined(WL_EGL_PLATFORM)
+
+typedef struct wl_display *EGLNativeDisplayType;
+typedef struct wl_egl_pixmap *EGLNativePixmapType;
+typedef struct wl_egl_window *EGLNativeWindowType;
+
+#elif defined(__GBM__)
+
+typedef struct gbm_device *EGLNativeDisplayType;
+typedef struct gbm_bo *EGLNativePixmapType;
+typedef void *EGLNativeWindowType;
+
+#elif defined(__ANDROID__) || defined(ANDROID)
+
+struct ANativeWindow;
+struct egl_native_pixmap_t;
+
+typedef struct ANativeWindow* EGLNativeWindowType;
+typedef struct egl_native_pixmap_t* EGLNativePixmapType;
+typedef void* EGLNativeDisplayType;
+
+#elif defined(__unix__) || defined(__APPLE__)
+
+#if defined(MESA_EGL_NO_X11_HEADERS)
+
+typedef void *EGLNativeDisplayType;
+typedef khronos_uintptr_t EGLNativePixmapType;
+typedef khronos_uintptr_t EGLNativeWindowType;
+
+#else
+
+/* X11 (tentative)  */
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+
+typedef Display *EGLNativeDisplayType;
+typedef Pixmap EGLNativePixmapType;
+typedef Window EGLNativeWindowType;
+
+#endif /* MESA_EGL_NO_X11_HEADERS */
+
+#elif __HAIKU__
+#include <kernel/image.h>
+typedef void *EGLNativeDisplayType;
+typedef khronos_uintptr_t EGLNativePixmapType;
+typedef khronos_uintptr_t EGLNativeWindowType;
+
+#else
+#error "Platform not recognized"
+#endif
+
+/* EGL 1.2 types, renamed for consistency in EGL 1.3 */
+typedef EGLNativeDisplayType NativeDisplayType;
+typedef EGLNativePixmapType NativePixmapType;
+typedef EGLNativeWindowType NativeWindowType;
+
+/* Define EGLint. This must be a signed integral type large enough to contain
+ * all legal attribute names and values passed into and out of EGL, whether
+ * their type is boolean, bitmask, enumerant (symbolic constant), integer,
+ * handle, or other.  While in general a 32-bit integer will suffice, if
+ * handles are 64 bit types, then EGLint should be defined as a signed 64-bit
+ * integer type.
+ */
+typedef khronos_int32_t EGLint;
+
+/* C++ / C typecast macros for special EGL handle values */
+#if defined(__cplusplus)
+#define EGL_CAST(type, value) (static_cast<type>(value))
+#else
+#define EGL_CAST(type, value) ((type)(value))
+#endif
+
+#endif /* __eglplatform_h */
diff --git a/engine/inc/bullet/ThirdPartyLibs/glad/KHR/khrplatform.h b/engine/inc/bullet/ThirdPartyLibs/glad/KHR/khrplatform.h
new file mode 100644
index 00000000..6b368ee9
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/glad/KHR/khrplatform.h
@@ -0,0 +1,283 @@
+#ifndef __khrplatform_h_
+#define __khrplatform_h_
+
+/*
+** Copyright (c) 2008-2009 The Khronos Group Inc.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a
+** copy of this software and/or associated documentation files (the
+** "Materials"), to deal in the Materials without restriction, including
+** without limitation the rights to use, copy, modify, merge, publish,
+** distribute, sublicense, and/or sell copies of the Materials, and to
+** permit persons to whom the Materials are 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 Materials.
+**
+** THE MATERIALS ARE 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
+** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+*/
+
+/* Khronos platform-specific types and definitions.
+ *
+ * $Revision: 32517 $ on $Date: 2016-03-11 02:41:19 -0800 (Fri, 11 Mar 2016) $
+ *
+ * Adopters may modify this file to suit their platform. Adopters are
+ * encouraged to submit platform specific modifications to the Khronos
+ * group so that they can be included in future versions of this file.
+ * Please submit changes by sending them to the public Khronos Bugzilla
+ * (http://khronos.org/bugzilla) by filing a bug against product
+ * "Khronos (general)" component "Registry".
+ *
+ * A predefined template which fills in some of the bug fields can be
+ * reached using http://tinyurl.com/khrplatform-h-bugreport, but you
+ * must create a Bugzilla login first.
+ *
+ *
+ * See the Implementer's Guidelines for information about where this file
+ * should be located on your system and for more details of its use:
+ *    http://www.khronos.org/registry/implementers_guide.pdf
+ *
+ * This file should be included as
+ *        #include <KHR/khrplatform.h>
+ * by Khronos client API header files that use its types and defines.
+ *
+ * The types in khrplatform.h should only be used to define API-specific types.
+ *
+ * Types defined in khrplatform.h:
+ *    khronos_int8_t              signed   8  bit
+ *    khronos_uint8_t             unsigned 8  bit
+ *    khronos_int16_t             signed   16 bit
+ *    khronos_uint16_t            unsigned 16 bit
+ *    khronos_int32_t             signed   32 bit
+ *    khronos_uint32_t            unsigned 32 bit
+ *    khronos_int64_t             signed   64 bit
+ *    khronos_uint64_t            unsigned 64 bit
+ *    khronos_intptr_t            signed   same number of bits as a pointer
+ *    khronos_uintptr_t           unsigned same number of bits as a pointer
+ *    khronos_ssize_t             signed   size
+ *    khronos_usize_t             unsigned size
+ *    khronos_float_t             signed   32 bit floating point
+ *    khronos_time_ns_t           unsigned 64 bit time in nanoseconds
+ *    khronos_utime_nanoseconds_t unsigned time interval or absolute time in
+ *                                         nanoseconds
+ *    khronos_stime_nanoseconds_t signed time interval in nanoseconds
+ *    khronos_boolean_enum_t      enumerated boolean type. This should
+ *      only be used as a base type when a client API's boolean type is
+ *      an enum. Client APIs which use an integer or other type for
+ *      booleans cannot use this as the base type for their boolean.
+ *
+ * Tokens defined in khrplatform.h:
+ *
+ *    KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values.
+ *
+ *    KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0.
+ *    KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0.
+ *
+ * Calling convention macros defined in this file:
+ *    KHRONOS_APICALL
+ *    KHRONOS_APIENTRY
+ *    KHRONOS_APIATTRIBUTES
+ *
+ * These may be used in function prototypes as:
+ *
+ *      KHRONOS_APICALL void KHRONOS_APIENTRY funcname(
+ *                                  int arg1,
+ *                                  int arg2) KHRONOS_APIATTRIBUTES;
+ */
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APICALL
+ *-------------------------------------------------------------------------
+ * This precedes the return type of the function in the function prototype.
+ */
+#if defined(_WIN32) && !defined(__SCITECH_SNAP__)
+#define KHRONOS_APICALL __declspec(dllimport)
+#elif defined(__SYMBIAN32__)
+#define KHRONOS_APICALL IMPORT_C
+#elif defined(__ANDROID__)
+#define KHRONOS_APICALL __attribute__((visibility("default")))
+#else
+#define KHRONOS_APICALL
+#endif
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APIENTRY
+ *-------------------------------------------------------------------------
+ * This follows the return type of the function  and precedes the function
+ * name in the function prototype.
+ */
+#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__)
+/* Win32 but not WinCE */
+#define KHRONOS_APIENTRY __stdcall
+#else
+#define KHRONOS_APIENTRY
+#endif
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APIATTRIBUTES
+ *-------------------------------------------------------------------------
+ * This follows the closing parenthesis of the function prototype arguments.
+ */
+#if defined(__ARMCC_2__)
+#define KHRONOS_APIATTRIBUTES __softfp
+#else
+#define KHRONOS_APIATTRIBUTES
+#endif
+
+/*-------------------------------------------------------------------------
+ * basic type definitions
+ *-----------------------------------------------------------------------*/
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__)
+
+/*
+ * Using <stdint.h>
+ */
+#include <stdint.h>
+typedef int32_t khronos_int32_t;
+typedef uint32_t khronos_uint32_t;
+typedef int64_t khronos_int64_t;
+typedef uint64_t khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64 1
+#define KHRONOS_SUPPORT_FLOAT 1
+
+#elif defined(__VMS) || defined(__sgi)
+
+/*
+ * Using <inttypes.h>
+ */
+#include <inttypes.h>
+typedef int32_t khronos_int32_t;
+typedef uint32_t khronos_uint32_t;
+typedef int64_t khronos_int64_t;
+typedef uint64_t khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64 1
+#define KHRONOS_SUPPORT_FLOAT 1
+
+#elif defined(_WIN32) && !defined(__SCITECH_SNAP__)
+
+/*
+ * Win32
+ */
+typedef __int32 khronos_int32_t;
+typedef unsigned __int32 khronos_uint32_t;
+typedef __int64 khronos_int64_t;
+typedef unsigned __int64 khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64 1
+#define KHRONOS_SUPPORT_FLOAT 1
+
+#elif defined(__sun__) || defined(__digital__)
+
+/*
+ * Sun or Digital
+ */
+typedef int khronos_int32_t;
+typedef unsigned int khronos_uint32_t;
+#if defined(__arch64__) || defined(_LP64)
+typedef long int khronos_int64_t;
+typedef unsigned long int khronos_uint64_t;
+#else
+typedef long long int khronos_int64_t;
+typedef unsigned long long int khronos_uint64_t;
+#endif /* __arch64__ */
+#define KHRONOS_SUPPORT_INT64 1
+#define KHRONOS_SUPPORT_FLOAT 1
+
+#elif 0
+
+/*
+ * Hypothetical platform with no float or int64 support
+ */
+typedef int khronos_int32_t;
+typedef unsigned int khronos_uint32_t;
+#define KHRONOS_SUPPORT_INT64 0
+#define KHRONOS_SUPPORT_FLOAT 0
+
+#else
+
+/*
+ * Generic fallback
+ */
+#include <stdint.h>
+typedef int32_t khronos_int32_t;
+typedef uint32_t khronos_uint32_t;
+typedef int64_t khronos_int64_t;
+typedef uint64_t khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64 1
+#define KHRONOS_SUPPORT_FLOAT 1
+
+#endif
+
+/*
+ * Types that are (so far) the same on all platforms
+ */
+typedef signed char khronos_int8_t;
+typedef unsigned char khronos_uint8_t;
+typedef signed short int khronos_int16_t;
+typedef unsigned short int khronos_uint16_t;
+
+/*
+ * Types that differ between LLP64 and LP64 architectures - in LLP64,
+ * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
+ * to be the only LLP64 architecture in current use.
+ */
+#ifdef _WIN64
+typedef signed long long int khronos_intptr_t;
+typedef unsigned long long int khronos_uintptr_t;
+typedef signed long long int khronos_ssize_t;
+typedef unsigned long long int khronos_usize_t;
+#else
+typedef signed long int khronos_intptr_t;
+typedef unsigned long int khronos_uintptr_t;
+typedef signed long int khronos_ssize_t;
+typedef unsigned long int khronos_usize_t;
+#endif
+
+#if KHRONOS_SUPPORT_FLOAT
+/*
+ * Float type
+ */
+typedef float khronos_float_t;
+#endif
+
+#if KHRONOS_SUPPORT_INT64
+/* Time types
+ *
+ * These types can be used to represent a time interval in nanoseconds or
+ * an absolute Unadjusted System Time.  Unadjusted System Time is the number
+ * of nanoseconds since some arbitrary system event (e.g. since the last
+ * time the system booted).  The Unadjusted System Time is an unsigned
+ * 64 bit value that wraps back to 0 every 584 years.  Time intervals
+ * may be either signed or unsigned.
+ */
+typedef khronos_uint64_t khronos_utime_nanoseconds_t;
+typedef khronos_int64_t khronos_stime_nanoseconds_t;
+#endif
+
+/*
+ * Dummy value used to pad enum types to 32 bits.
+ */
+#ifndef KHRONOS_MAX_ENUM
+#define KHRONOS_MAX_ENUM 0x7FFFFFFF
+#endif
+
+/*
+ * Enumerated boolean type
+ *
+ * Values other than zero should be considered to be true.  Therefore
+ * comparisons should not be made against KHRONOS_TRUE.
+ */
+typedef enum
+{
+	KHRONOS_FALSE = 0,
+	KHRONOS_TRUE = 1,
+	KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM
+} khronos_boolean_enum_t;
+
+#endif /* __khrplatform_h_ */
diff --git a/engine/inc/bullet/ThirdPartyLibs/glad/glad/egl.h b/engine/inc/bullet/ThirdPartyLibs/glad/glad/egl.h
new file mode 100644
index 00000000..5c7e3cd9
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/glad/glad/egl.h
@@ -0,0 +1,541 @@
+/**
+ * Loader generated by glad 0.1.11a0 on Wed Jun 13 07:59:54 2018
+ *
+ * Generator: C/C++
+ * Specification: egl
+ * Extensions: 7
+ *
+ * APIs:
+ *  - egl=1.5
+ *
+ * Options:
+ *  - HEADER_ONLY = False
+ *  - DEBUG = False
+ *  - MX = False
+ *  - LOADER = True
+ *  - MX_GLOBAL = False
+ *  - ALIAS = False
+ *
+ * Commandline:
+ *    --api='egl=1.5' --extensions='EGL_EXT_platform_device,EGL_EXT_platform_base,EGL_NV_device_cuda,EGL_EXT_device_enumeration,EGL_EXT_device_query,EGL_EXT_device_base,EGL_NV_cuda_event' c --loader
+ *
+ * Online:
+ *    http://glad2.dav1d.de/#merge=off&api=egl%3D1.5&extensions=EGL_EXT_platform_device%2CEGL_EXT_platform_base%2CEGL_NV_device_cuda%2CEGL_EXT_device_enumeration%2CEGL_EXT_device_query%2CEGL_EXT_device_base%2CEGL_NV_cuda_event&generator=c&header_only=off&debug=off&mx=off&loader=on&mx_global=off&alias=off
+ *
+ */
+
+#ifndef GLAD_EGL_H_
+#define GLAD_EGL_H_
+
+#define GLAD_EGL
+#define GLAD_OPTION_EGL_LOADER
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#ifndef GLAD_PLATFORM_H_
+#define GLAD_PLATFORM_H_
+
+#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__MINGW32__)
+#define GLAD_PLATFORM_WIN32 1
+#else
+#define GLAD_PLATFORM_WIN32 0
+#endif
+
+#ifndef GLAD_PLATFORM_UWP
+#if defined(_MSC_VER) && !defined(GLAD_INTERNAL_HAVE_WINAPIFAMILY)
+#ifdef __has_include
+#if __has_include(<winapifamily.h>)
+#define GLAD_INTERNAL_HAVE_WINAPIFAMILY 1
+#endif
+#elif _MSC_VER >= 1700 && !_USING_V110_SDK71_
+#define GLAD_INTERNAL_HAVE_WINAPIFAMILY 1
+#endif
+#endif
+
+#ifdef GLAD_INTERNAL_HAVE_WINAPIFAMILY
+#include <winapifamily.h>
+#if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
+#define GLAD_PLATFORM_UWP 1
+#endif
+#endif
+
+#ifndef GLAD_PLATFORM_UWP
+#define GLAD_PLATFORM_UWP 0
+#endif
+#endif
+
+#ifdef __GNUC__
+#define GLAD_GNUC_EXTENSION __extension__
+#else
+#define GLAD_GNUC_EXTENSION
+#endif
+
+#ifndef GLAD_API_CALL
+#if defined(GLAD_API_CALL_EXPORT)
+#if GLAD_PLATFORM_WIN32 || defined(__CYGWIN__)
+#if defined(GLAD_API_CALL_EXPORT_BUILD)
+#if defined(__GNUC__)
+#define GLAD_API_CALL __attribute__((dllexport)) extern
+#else
+#define GLAD_API_CALL __declspec(dllexport) extern
+#endif
+#else
+#if defined(__GNUC__)
+#define GLAD_API_CALL __attribute__((dllimport)) extern
+#else
+#define GLAD_API_CALL __declspec(dllimport) extern
+#endif
+#endif
+#elif defined(__GNUC__) && defined(GLAD_API_CALL_EXPORT_BUILD)
+#define GLAD_API_CALL __attribute__((visibility("default"))) extern
+#else
+#define GLAD_API_CALL extern
+#endif
+#else
+#define GLAD_API_CALL extern
+#endif
+#endif
+
+#ifdef APIENTRY
+#define GLAD_API_PTR APIENTRY
+#elif GLAD_PLATFORM_WIN32
+#define GLAD_API_PTR __stdcall
+#else
+#define GLAD_API_PTR
+#endif
+
+#define GLAD_MAKE_VERSION(major, minor) (major * 10000 + minor)
+#define GLAD_VERSION_MAJOR(version) (version / 10000)
+#define GLAD_VERSION_MINOR(version) (version % 10000)
+
+	typedef void (*GLADapiproc)(void);
+
+	typedef GLADapiproc (*GLADloadfunc)(const char *name);
+	typedef GLADapiproc (*GLADuserptrloadfunc)(const char *name, void *userptr);
+
+	typedef void (*GLADprecallback)(const char *name, GLADapiproc apiproc, int len_args, ...);
+	typedef void (*GLADpostcallback)(void *ret, const char *name, GLADapiproc apiproc, int len_args, ...);
+
+#endif /* GLAD_PLATFORM_H_ */
+
+#define EGL_VERSION 0x3054
+#define EGL_CONFIG_CAVEAT 0x3027
+#define EGL_NATIVE_VISUAL_ID 0x302E
+#define EGL_CONTEXT_OPENGL_ROBUST_ACCESS 0x31B2
+#define EGL_NATIVE_RENDERABLE 0x302D
+#define EGL_BAD_SURFACE 0x300D
+#define EGL_MULTISAMPLE_RESOLVE 0x3099
+#define EGL_PIXEL_ASPECT_RATIO 0x3092
+#define EGL_BLUE_SIZE 0x3022
+#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x30B5
+#define EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY 0x31BD
+#define EGL_BAD_ALLOC 0x3003
+#define EGL_SAMPLES 0x3031
+#define EGL_SYNC_TYPE 0x30F7
+#define EGL_LUMINANCE_SIZE 0x303D
+#define EGL_PBUFFER_BIT 0x0001
+#define EGL_ALPHA_FORMAT_NONPRE EGL_VG_ALPHA_FORMAT_NONPRE
+#define EGL_VG_ALPHA_FORMAT_NONPRE 0x308B
+#define EGL_CONTEXT_LOST 0x300E
+#define EGL_BUFFER_PRESERVED 0x3094
+#define EGL_GL_COLORSPACE_LINEAR EGL_COLORSPACE_LINEAR
+#define EGL_SAMPLE_BUFFERS 0x3032
+#define EGL_GL_RENDERBUFFER 0x30B9
+#define EGL_UNSIGNALED 0x30F3
+#define EGL_OPENGL_ES_API 0x30A0
+#define EGL_EXTENSIONS 0x3055
+#define EGL_GL_TEXTURE_2D 0x30B1
+#define EGL_BACK_BUFFER 0x3084
+#define EGL_SYNC_CONDITION 0x30F8
+#define EGL_BAD_NATIVE_PIXMAP 0x300A
+#define EGL_CONTEXT_OPENGL_DEBUG 0x31B0
+#define EGL_TEXTURE_2D 0x305F
+#define EGL_CONFORMANT 0x3042
+#define EGL_PIXMAP_BIT 0x0002
+#define EGL_SLOW_CONFIG 0x3050
+#define EGL_CL_EVENT_HANDLE 0x309C
+#define EGL_BAD_CURRENT_SURFACE 0x3007
+#define EGL_BIND_TO_TEXTURE_RGBA 0x303A
+#define EGL_VG_COLORSPACE_sRGB EGL_COLORSPACE_sRGB
+#define EGL_IMAGE_PRESERVED 0x30D2
+#define EGL_SURFACE_TYPE 0x3033
+#define EGL_OPENVG_BIT 0x0002
+#define EGL_VERTICAL_RESOLUTION 0x3091
+#define EGL_MAX_PBUFFER_PIXELS 0x302B
+#define EGL_DEVICE_EXT 0x322C
+#define EGL_SWAP_BEHAVIOR 0x3093
+#define EGL_MULTISAMPLE_RESOLVE_BOX_BIT 0x0200
+#define EGL_VG_ALPHA_FORMAT 0x3088
+#define EGL_RENDER_BUFFER 0x3086
+#define EGL_VG_COLORSPACE 0x3087
+#define EGL_NO_CONTEXT EGL_CAST(EGLContext, 0)
+#define EGL_OPENGL_API 0x30A2
+#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x30B7
+#define EGL_LUMINANCE_BUFFER 0x308F
+#define EGL_NO_RESET_NOTIFICATION 0x31BE
+#define EGL_COLORSPACE_sRGB 0x3089
+#define EGL_OPENGL_ES_BIT 0x0001
+#define EGL_BAD_ACCESS 0x3002
+#define EGL_OPENGL_ES2_BIT 0x0004
+#define EGL_LOSE_CONTEXT_ON_RESET 0x31BF
+#define EGL_NO_DISPLAY EGL_CAST(EGLDisplay, 0)
+#define EGL_NO_DEVICE_EXT EGL_CAST(EGLDeviceEXT, 0)
+#define EGL_BAD_CONFIG 0x3005
+#define EGL_NO_TEXTURE 0x305C
+#define EGL_LARGEST_PBUFFER 0x3058
+#define EGL_SWAP_BEHAVIOR_PRESERVED_BIT 0x0400
+#define EGL_ALPHA_FORMAT EGL_VG_ALPHA_FORMAT
+#define EGL_ALPHA_MASK_SIZE 0x303E
+#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x30B4
+#define EGL_CUDA_DEVICE_NV 0x323A
+#define EGL_VENDOR 0x3053
+#define EGL_STENCIL_SIZE 0x3026
+#define EGL_BAD_ATTRIBUTE 0x3004
+#define EGL_DRAW 0x3059
+#define EGL_SYNC_FLUSH_COMMANDS_BIT 0x0001
+#define EGL_COLORSPACE EGL_VG_COLORSPACE
+#define EGL_SYNC_CUDA_EVENT_NV 0x323C
+#define EGL_OPENVG_IMAGE 0x3096
+#define EGL_NO_IMAGE EGL_CAST(EGLImage, 0)
+#define EGL_TEXTURE_TARGET 0x3081
+#define EGL_CORE_NATIVE_ENGINE 0x305B
+#define EGL_DEFAULT_DISPLAY EGL_CAST(EGLNativeDisplayType, 0)
+#define EGL_SIGNALED 0x30F2
+#define EGL_GL_COLORSPACE 0x309D
+#define EGL_SYNC_PRIOR_COMMANDS_COMPLETE 0x30F0
+#define EGL_WIDTH 0x3057
+#define EGL_TRANSPARENT_RGB 0x3052
+#define EGL_SYNC_FENCE 0x30F9
+#define EGL_RENDERABLE_TYPE 0x3040
+#define EGL_TRANSPARENT_BLUE_VALUE 0x3035
+#define EGL_MAX_SWAP_INTERVAL 0x303C
+#define EGL_HEIGHT 0x3056
+#define EGL_TRANSPARENT_TYPE 0x3034
+#define EGL_DEPTH_SIZE 0x3025
+#define EGL_CONTEXT_OPENGL_PROFILE_MASK 0x30FD
+#define EGL_FOREVER 0xFFFFFFFFFFFFFFFF
+#define EGL_NATIVE_VISUAL_TYPE 0x302F
+#define EGL_GREEN_SIZE 0x3023
+#define EGL_DISPLAY_SCALING 10000
+#define EGL_WINDOW_BIT 0x0004
+#define EGL_BIND_TO_TEXTURE_RGB 0x3039
+#define EGL_VG_COLORSPACE_LINEAR EGL_COLORSPACE_LINEAR
+#define EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT 0x00000001
+#define EGL_BAD_DISPLAY 0x3008
+#define EGL_CONDITION_SATISFIED 0x30F6
+#define EGL_SYNC_CL_EVENT 0x30FE
+#define EGL_COLORSPACE_LINEAR 0x308A
+#define EGL_NONE 0x3038
+#define EGL_MATCH_NATIVE_PIXMAP 0x3041
+#define EGL_MIPMAP_LEVEL 0x3083
+#define EGL_PLATFORM_DEVICE_EXT 0x313F
+#define EGL_BAD_CONTEXT 0x3006
+#define EGL_MIN_SWAP_INTERVAL 0x303B
+#define EGL_BAD_DEVICE_EXT 0x322B
+#define EGL_FALSE 0
+#define EGL_TEXTURE_FORMAT 0x3080
+#define EGL_GL_TEXTURE_3D 0x30B2
+#define EGL_COLOR_BUFFER_TYPE 0x303F
+#define EGL_MAX_PBUFFER_WIDTH 0x302C
+#define EGL_SINGLE_BUFFER 0x3085
+#define EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT 0x00000002
+#define EGL_ALPHA_SIZE 0x3021
+#define EGL_MULTISAMPLE_RESOLVE_DEFAULT 0x309A
+#define EGL_VG_COLORSPACE_LINEAR_BIT 0x0020
+#define EGL_SYNC_STATUS 0x30F1
+#define EGL_TRUE 1
+#define EGL_TIMEOUT_EXPIRED 0x30F5
+#define EGL_NO_SURFACE EGL_CAST(EGLSurface, 0)
+#define EGL_RED_SIZE 0x3024
+#define EGL_TEXTURE_RGBA 0x305E
+#define EGL_TRANSPARENT_GREEN_VALUE 0x3036
+#define EGL_GL_TEXTURE_ZOFFSET 0x30BD
+#define EGL_ALPHA_FORMAT_PRE EGL_VG_ALPHA_FORMAT_PRE
+#define EGL_UNKNOWN EGL_CAST(EGLint, -1)
+#define EGL_SUCCESS 0x3000
+#define EGL_CONTEXT_CLIENT_VERSION 0x3098
+#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x30B3
+#define EGL_SYNC_CUDA_EVENT_COMPLETE_NV 0x323D
+#define EGL_BUFFER_SIZE 0x3020
+#define EGL_MAX_PBUFFER_HEIGHT 0x302A
+#define EGL_HORIZONTAL_RESOLUTION 0x3090
+#define EGL_SYNC_CL_EVENT_COMPLETE 0x30FF
+#define EGL_LEVEL 0x3029
+#define EGL_CONTEXT_MAJOR_VERSION EGL_CONTEXT_CLIENT_VERSION
+#define EGL_VG_ALPHA_FORMAT_PRE_BIT 0x0040
+#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x30B8
+#define EGL_READ 0x305A
+#define EGL_BAD_PARAMETER 0x300C
+#define EGL_RGB_BUFFER 0x308E
+#define EGL_MULTISAMPLE_RESOLVE_BOX 0x309B
+#define EGL_NON_CONFORMANT_CONFIG 0x3051
+#define EGL_MIPMAP_TEXTURE 0x3082
+#define EGL_CONFIG_ID 0x3028
+#define EGL_CONTEXT_MINOR_VERSION 0x30FB
+#define EGL_TRANSPARENT_RED_VALUE 0x3037
+#define EGL_BUFFER_DESTROYED 0x3095
+#define EGL_CONTEXT_CLIENT_TYPE 0x3097
+#define EGL_BAD_NATIVE_WINDOW 0x300B
+#define EGL_OPENGL_BIT 0x0008
+#define EGL_OPENVG_API 0x30A1
+#define EGL_OPENGL_ES3_BIT 0x00000040
+#define EGL_BAD_MATCH 0x3009
+#define EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE 0x31B1
+#define EGL_TEXTURE_RGB 0x305D
+#define EGL_CLIENT_APIS 0x308D
+#define EGL_GL_TEXTURE_LEVEL 0x30BC
+#define EGL_NOT_INITIALIZED 0x3001
+#define EGL_NO_SYNC EGL_CAST(EGLSync, 0)
+#define EGL_VG_ALPHA_FORMAT_PRE 0x308C
+#define EGL_DONT_CARE EGL_CAST(EGLint, -1)
+#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x30B6
+#define EGL_GL_COLORSPACE_SRGB EGL_COLORSPACE_sRGB
+#define EGL_CUDA_EVENT_HANDLE_NV 0x323B
+
+#include <KHR/khrplatform.h>
+#include <EGL/eglplatform.h>
+
+	struct AHardwareBuffer;
+
+	typedef unsigned int EGLBoolean;
+	typedef unsigned int EGLenum;
+	typedef intptr_t EGLAttribKHR;
+	typedef intptr_t EGLAttrib;
+	typedef void *EGLClientBuffer;
+	typedef void *EGLConfig;
+	typedef void *EGLContext;
+	typedef void *EGLDeviceEXT;
+	typedef void *EGLDisplay;
+	typedef void *EGLImage;
+	typedef void *EGLImageKHR;
+	typedef void *EGLLabelKHR;
+	typedef void *EGLObjectKHR;
+	typedef void *EGLOutputLayerEXT;
+	typedef void *EGLOutputPortEXT;
+	typedef void *EGLStreamKHR;
+	typedef void *EGLSurface;
+	typedef void *EGLSync;
+	typedef void *EGLSyncKHR;
+	typedef void *EGLSyncNV;
+	typedef void (*__eglMustCastToProperFunctionPointerType)(void);
+	typedef khronos_utime_nanoseconds_t EGLTimeKHR;
+	typedef khronos_utime_nanoseconds_t EGLTime;
+	typedef khronos_utime_nanoseconds_t EGLTimeNV;
+	typedef khronos_utime_nanoseconds_t EGLuint64NV;
+	typedef khronos_uint64_t EGLuint64KHR;
+	typedef khronos_stime_nanoseconds_t EGLnsecsANDROID;
+	typedef int EGLNativeFileDescriptorKHR;
+	typedef khronos_ssize_t EGLsizeiANDROID;
+	typedef void (*EGLSetBlobFuncANDROID)(const void *key, EGLsizeiANDROID keySize, const void *value, EGLsizeiANDROID valueSize);
+	typedef EGLsizeiANDROID (*EGLGetBlobFuncANDROID)(const void *key, EGLsizeiANDROID keySize, void *value, EGLsizeiANDROID valueSize);
+	struct EGLClientPixmapHI
+	{
+		void *pData;
+		EGLint iWidth;
+		EGLint iHeight;
+		EGLint iStride;
+	};
+	typedef void(GLAD_API_PTR *EGLDEBUGPROCKHR)(EGLenum error, const char *command, EGLint messageType, EGLLabelKHR threadLabel, EGLLabelKHR objectLabel, const char *message);
+
+#define EGL_VERSION_1_0 1
+	GLAD_API_CALL int GLAD_EGL_VERSION_1_0;
+#define EGL_VERSION_1_1 1
+	GLAD_API_CALL int GLAD_EGL_VERSION_1_1;
+#define EGL_VERSION_1_2 1
+	GLAD_API_CALL int GLAD_EGL_VERSION_1_2;
+#define EGL_VERSION_1_3 1
+	GLAD_API_CALL int GLAD_EGL_VERSION_1_3;
+#define EGL_VERSION_1_4 1
+	GLAD_API_CALL int GLAD_EGL_VERSION_1_4;
+#define EGL_VERSION_1_5 1
+	GLAD_API_CALL int GLAD_EGL_VERSION_1_5;
+#define EGL_EXT_platform_device 1
+	GLAD_API_CALL int GLAD_EGL_EXT_platform_device;
+#define EGL_EXT_platform_base 1
+	GLAD_API_CALL int GLAD_EGL_EXT_platform_base;
+#define EGL_NV_device_cuda 1
+	GLAD_API_CALL int GLAD_EGL_NV_device_cuda;
+#define EGL_EXT_device_enumeration 1
+	GLAD_API_CALL int GLAD_EGL_EXT_device_enumeration;
+#define EGL_EXT_device_query 1
+	GLAD_API_CALL int GLAD_EGL_EXT_device_query;
+#define EGL_EXT_device_base 1
+	GLAD_API_CALL int GLAD_EGL_EXT_device_base;
+#define EGL_NV_cuda_event 1
+	GLAD_API_CALL int GLAD_EGL_NV_cuda_event;
+
+	typedef EGLBoolean(GLAD_API_PTR *PFNEGLQUERYDEVICESEXTPROC)(EGLint max_devices, EGLDeviceEXT *devices, EGLint *num_devices);
+	typedef EGLSurface(GLAD_API_PTR *PFNEGLCREATEPBUFFERSURFACEPROC)(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list);
+	typedef EGLint(GLAD_API_PTR *PFNEGLGETERRORPROC)(void);
+	typedef __eglMustCastToProperFunctionPointerType(GLAD_API_PTR *PFNEGLGETPROCADDRESSPROC)(const char *procname);
+	typedef EGLDisplay(GLAD_API_PTR *PFNEGLGETCURRENTDISPLAYPROC)(void);
+	typedef EGLenum(GLAD_API_PTR *PFNEGLQUERYAPIPROC)(void);
+	typedef EGLSurface(GLAD_API_PTR *PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC)(EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLAttrib *attrib_list);
+	typedef EGLBoolean(GLAD_API_PTR *PFNEGLQUERYDISPLAYATTRIBKHRPROC)(EGLDisplay dpy, EGLint name, EGLAttrib *value);
+	typedef EGLBoolean(GLAD_API_PTR *PFNEGLDESTROYSYNCPROC)(EGLDisplay dpy, EGLSync sync);
+	typedef EGLImage(GLAD_API_PTR *PFNEGLCREATEIMAGEPROC)(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLAttrib *attrib_list);
+	typedef EGLBoolean(GLAD_API_PTR *PFNEGLQUERYCONTEXTPROC)(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value);
+	typedef EGLBoolean(GLAD_API_PTR *PFNEGLSWAPBUFFERSPROC)(EGLDisplay dpy, EGLSurface surface);
+	typedef EGLContext(GLAD_API_PTR *PFNEGLCREATECONTEXTPROC)(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list);
+	typedef EGLBoolean(GLAD_API_PTR *PFNEGLCHOOSECONFIGPROC)(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config);
+	typedef EGLBoolean(GLAD_API_PTR *PFNEGLBINDAPIPROC)(EGLenum api);
+	typedef EGLBoolean(GLAD_API_PTR *PFNEGLWAITNATIVEPROC)(EGLint engine);
+	typedef EGLBoolean(GLAD_API_PTR *PFNEGLTERMINATEPROC)(EGLDisplay dpy);
+	typedef EGLSurface(GLAD_API_PTR *PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC)(EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLint *attrib_list);
+	typedef EGLBoolean(GLAD_API_PTR *PFNEGLRELEASETHREADPROC)(void);
+	typedef EGLSurface(GLAD_API_PTR *PFNEGLCREATEPLATFORMWINDOWSURFACEPROC)(EGLDisplay dpy, EGLConfig config, void *native_window, const EGLAttrib *attrib_list);
+	typedef EGLBoolean(GLAD_API_PTR *PFNEGLGETCONFIGATTRIBPROC)(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value);
+	typedef EGLSurface(GLAD_API_PTR *PFNEGLGETCURRENTSURFACEPROC)(EGLint readdraw);
+	typedef EGLBoolean(GLAD_API_PTR *PFNEGLCOPYBUFFERSPROC)(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target);
+	typedef EGLDisplay(GLAD_API_PTR *PFNEGLGETPLATFORMDISPLAYEXTPROC)(EGLenum platform, void *native_display, const EGLint *attrib_list);
+	typedef EGLBoolean(GLAD_API_PTR *PFNEGLQUERYDEVICEATTRIBEXTPROC)(EGLDeviceEXT device, EGLint attribute, EGLAttrib *value);
+	typedef EGLSurface(GLAD_API_PTR *PFNEGLCREATEPIXMAPSURFACEPROC)(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list);
+	typedef EGLBoolean(GLAD_API_PTR *PFNEGLBINDTEXIMAGEPROC)(EGLDisplay dpy, EGLSurface surface, EGLint buffer);
+	typedef EGLDisplay(GLAD_API_PTR *PFNEGLGETPLATFORMDISPLAYPROC)(EGLenum platform, void *native_display, const EGLAttrib *attrib_list);
+	typedef EGLDisplay(GLAD_API_PTR *PFNEGLGETDISPLAYPROC)(EGLNativeDisplayType display_id);
+	typedef const char *(GLAD_API_PTR *PFNEGLQUERYSTRINGPROC)(EGLDisplay dpy, EGLint name);
+	typedef EGLint(GLAD_API_PTR *PFNEGLCLIENTWAITSYNCPROC)(EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout);
+	typedef EGLBoolean(GLAD_API_PTR *PFNEGLWAITSYNCPROC)(EGLDisplay dpy, EGLSync sync, EGLint flags);
+	typedef EGLBoolean(GLAD_API_PTR *PFNEGLDESTROYIMAGEPROC)(EGLDisplay dpy, EGLImage image);
+	typedef EGLBoolean(GLAD_API_PTR *PFNEGLRELEASETEXIMAGEPROC)(EGLDisplay dpy, EGLSurface surface, EGLint buffer);
+	typedef EGLBoolean(GLAD_API_PTR *PFNEGLQUERYDISPLAYATTRIBEXTPROC)(EGLDisplay dpy, EGLint attribute, EGLAttrib *value);
+	typedef EGLBoolean(GLAD_API_PTR *PFNEGLDESTROYCONTEXTPROC)(EGLDisplay dpy, EGLContext ctx);
+	typedef const char *(GLAD_API_PTR *PFNEGLQUERYDEVICESTRINGEXTPROC)(EGLDeviceEXT device, EGLint name);
+	typedef EGLSurface(GLAD_API_PTR *PFNEGLCREATEWINDOWSURFACEPROC)(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list);
+	typedef EGLContext(GLAD_API_PTR *PFNEGLGETCURRENTCONTEXTPROC)(void);
+	typedef EGLBoolean(GLAD_API_PTR *PFNEGLINITIALIZEPROC)(EGLDisplay dpy, EGLint *major, EGLint *minor);
+	typedef EGLBoolean(GLAD_API_PTR *PFNEGLDESTROYSURFACEPROC)(EGLDisplay dpy, EGLSurface surface);
+	typedef EGLBoolean(GLAD_API_PTR *PFNEGLMAKECURRENTPROC)(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
+	typedef EGLSurface(GLAD_API_PTR *PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC)(EGLDisplay dpy, EGLConfig config, void *native_window, const EGLint *attrib_list);
+	typedef EGLBoolean(GLAD_API_PTR *PFNEGLSWAPINTERVALPROC)(EGLDisplay dpy, EGLint interval);
+	typedef EGLSync(GLAD_API_PTR *PFNEGLCREATESYNCPROC)(EGLDisplay dpy, EGLenum type, const EGLAttrib *attrib_list);
+	typedef EGLBoolean(GLAD_API_PTR *PFNEGLGETSYNCATTRIBPROC)(EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib *value);
+	typedef EGLBoolean(GLAD_API_PTR *PFNEGLSURFACEATTRIBPROC)(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value);
+	typedef EGLBoolean(GLAD_API_PTR *PFNEGLWAITGLPROC)(void);
+	typedef EGLBoolean(GLAD_API_PTR *PFNEGLQUERYSURFACEPROC)(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value);
+	typedef EGLBoolean(GLAD_API_PTR *PFNEGLGETCONFIGSPROC)(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config);
+	typedef EGLBoolean(GLAD_API_PTR *PFNEGLWAITCLIENTPROC)(void);
+	typedef EGLSurface(GLAD_API_PTR *PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC)(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list);
+
+	GLAD_API_CALL PFNEGLQUERYDEVICESEXTPROC glad_eglQueryDevicesEXT;
+#define eglQueryDevicesEXT glad_eglQueryDevicesEXT
+	GLAD_API_CALL PFNEGLCREATEPBUFFERSURFACEPROC glad_eglCreatePbufferSurface;
+#define eglCreatePbufferSurface glad_eglCreatePbufferSurface
+	GLAD_API_CALL PFNEGLGETERRORPROC glad_eglGetError;
+#define eglGetError glad_eglGetError
+	GLAD_API_CALL PFNEGLGETPROCADDRESSPROC glad_eglGetProcAddress;
+#define eglGetProcAddress glad_eglGetProcAddress
+	GLAD_API_CALL PFNEGLGETCURRENTDISPLAYPROC glad_eglGetCurrentDisplay;
+#define eglGetCurrentDisplay glad_eglGetCurrentDisplay
+	GLAD_API_CALL PFNEGLQUERYAPIPROC glad_eglQueryAPI;
+#define eglQueryAPI glad_eglQueryAPI
+	GLAD_API_CALL PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC glad_eglCreatePlatformPixmapSurface;
+#define eglCreatePlatformPixmapSurface glad_eglCreatePlatformPixmapSurface
+	GLAD_API_CALL PFNEGLQUERYDISPLAYATTRIBKHRPROC glad_eglQueryDisplayAttribKHR;
+#define eglQueryDisplayAttribKHR glad_eglQueryDisplayAttribKHR
+	GLAD_API_CALL PFNEGLDESTROYSYNCPROC glad_eglDestroySync;
+#define eglDestroySync glad_eglDestroySync
+	GLAD_API_CALL PFNEGLCREATEIMAGEPROC glad_eglCreateImage;
+#define eglCreateImage glad_eglCreateImage
+	GLAD_API_CALL PFNEGLQUERYCONTEXTPROC glad_eglQueryContext;
+#define eglQueryContext glad_eglQueryContext
+	GLAD_API_CALL PFNEGLSWAPBUFFERSPROC glad_eglSwapBuffers;
+#define eglSwapBuffers glad_eglSwapBuffers
+	GLAD_API_CALL PFNEGLCREATECONTEXTPROC glad_eglCreateContext;
+#define eglCreateContext glad_eglCreateContext
+	GLAD_API_CALL PFNEGLCHOOSECONFIGPROC glad_eglChooseConfig;
+#define eglChooseConfig glad_eglChooseConfig
+	GLAD_API_CALL PFNEGLBINDAPIPROC glad_eglBindAPI;
+#define eglBindAPI glad_eglBindAPI
+	GLAD_API_CALL PFNEGLWAITNATIVEPROC glad_eglWaitNative;
+#define eglWaitNative glad_eglWaitNative
+	GLAD_API_CALL PFNEGLTERMINATEPROC glad_eglTerminate;
+#define eglTerminate glad_eglTerminate
+	GLAD_API_CALL PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC glad_eglCreatePlatformPixmapSurfaceEXT;
+#define eglCreatePlatformPixmapSurfaceEXT glad_eglCreatePlatformPixmapSurfaceEXT
+	GLAD_API_CALL PFNEGLRELEASETHREADPROC glad_eglReleaseThread;
+#define eglReleaseThread glad_eglReleaseThread
+	GLAD_API_CALL PFNEGLCREATEPLATFORMWINDOWSURFACEPROC glad_eglCreatePlatformWindowSurface;
+#define eglCreatePlatformWindowSurface glad_eglCreatePlatformWindowSurface
+	GLAD_API_CALL PFNEGLGETCONFIGATTRIBPROC glad_eglGetConfigAttrib;
+#define eglGetConfigAttrib glad_eglGetConfigAttrib
+	GLAD_API_CALL PFNEGLGETCURRENTSURFACEPROC glad_eglGetCurrentSurface;
+#define eglGetCurrentSurface glad_eglGetCurrentSurface
+	GLAD_API_CALL PFNEGLCOPYBUFFERSPROC glad_eglCopyBuffers;
+#define eglCopyBuffers glad_eglCopyBuffers
+	GLAD_API_CALL PFNEGLGETPLATFORMDISPLAYEXTPROC glad_eglGetPlatformDisplayEXT;
+#define eglGetPlatformDisplayEXT glad_eglGetPlatformDisplayEXT
+	GLAD_API_CALL PFNEGLQUERYDEVICEATTRIBEXTPROC glad_eglQueryDeviceAttribEXT;
+#define eglQueryDeviceAttribEXT glad_eglQueryDeviceAttribEXT
+	GLAD_API_CALL PFNEGLCREATEPIXMAPSURFACEPROC glad_eglCreatePixmapSurface;
+#define eglCreatePixmapSurface glad_eglCreatePixmapSurface
+	GLAD_API_CALL PFNEGLBINDTEXIMAGEPROC glad_eglBindTexImage;
+#define eglBindTexImage glad_eglBindTexImage
+	GLAD_API_CALL PFNEGLGETPLATFORMDISPLAYPROC glad_eglGetPlatformDisplay;
+#define eglGetPlatformDisplay glad_eglGetPlatformDisplay
+	GLAD_API_CALL PFNEGLGETDISPLAYPROC glad_eglGetDisplay;
+#define eglGetDisplay glad_eglGetDisplay
+	GLAD_API_CALL PFNEGLQUERYSTRINGPROC glad_eglQueryString;
+#define eglQueryString glad_eglQueryString
+	GLAD_API_CALL PFNEGLCLIENTWAITSYNCPROC glad_eglClientWaitSync;
+#define eglClientWaitSync glad_eglClientWaitSync
+	GLAD_API_CALL PFNEGLWAITSYNCPROC glad_eglWaitSync;
+#define eglWaitSync glad_eglWaitSync
+	GLAD_API_CALL PFNEGLDESTROYIMAGEPROC glad_eglDestroyImage;
+#define eglDestroyImage glad_eglDestroyImage
+	GLAD_API_CALL PFNEGLRELEASETEXIMAGEPROC glad_eglReleaseTexImage;
+#define eglReleaseTexImage glad_eglReleaseTexImage
+	GLAD_API_CALL PFNEGLQUERYDISPLAYATTRIBEXTPROC glad_eglQueryDisplayAttribEXT;
+#define eglQueryDisplayAttribEXT glad_eglQueryDisplayAttribEXT
+	GLAD_API_CALL PFNEGLDESTROYCONTEXTPROC glad_eglDestroyContext;
+#define eglDestroyContext glad_eglDestroyContext
+	GLAD_API_CALL PFNEGLQUERYDEVICESTRINGEXTPROC glad_eglQueryDeviceStringEXT;
+#define eglQueryDeviceStringEXT glad_eglQueryDeviceStringEXT
+	GLAD_API_CALL PFNEGLCREATEWINDOWSURFACEPROC glad_eglCreateWindowSurface;
+#define eglCreateWindowSurface glad_eglCreateWindowSurface
+	GLAD_API_CALL PFNEGLGETCURRENTCONTEXTPROC glad_eglGetCurrentContext;
+#define eglGetCurrentContext glad_eglGetCurrentContext
+	GLAD_API_CALL PFNEGLINITIALIZEPROC glad_eglInitialize;
+#define eglInitialize glad_eglInitialize
+	GLAD_API_CALL PFNEGLDESTROYSURFACEPROC glad_eglDestroySurface;
+#define eglDestroySurface glad_eglDestroySurface
+	GLAD_API_CALL PFNEGLMAKECURRENTPROC glad_eglMakeCurrent;
+#define eglMakeCurrent glad_eglMakeCurrent
+	GLAD_API_CALL PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC glad_eglCreatePlatformWindowSurfaceEXT;
+#define eglCreatePlatformWindowSurfaceEXT glad_eglCreatePlatformWindowSurfaceEXT
+	GLAD_API_CALL PFNEGLSWAPINTERVALPROC glad_eglSwapInterval;
+#define eglSwapInterval glad_eglSwapInterval
+	GLAD_API_CALL PFNEGLCREATESYNCPROC glad_eglCreateSync;
+#define eglCreateSync glad_eglCreateSync
+	GLAD_API_CALL PFNEGLGETSYNCATTRIBPROC glad_eglGetSyncAttrib;
+#define eglGetSyncAttrib glad_eglGetSyncAttrib
+	GLAD_API_CALL PFNEGLSURFACEATTRIBPROC glad_eglSurfaceAttrib;
+#define eglSurfaceAttrib glad_eglSurfaceAttrib
+	GLAD_API_CALL PFNEGLWAITGLPROC glad_eglWaitGL;
+#define eglWaitGL glad_eglWaitGL
+	GLAD_API_CALL PFNEGLQUERYSURFACEPROC glad_eglQuerySurface;
+#define eglQuerySurface glad_eglQuerySurface
+	GLAD_API_CALL PFNEGLGETCONFIGSPROC glad_eglGetConfigs;
+#define eglGetConfigs glad_eglGetConfigs
+	GLAD_API_CALL PFNEGLWAITCLIENTPROC glad_eglWaitClient;
+#define eglWaitClient glad_eglWaitClient
+	GLAD_API_CALL PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC glad_eglCreatePbufferFromClientBuffer;
+#define eglCreatePbufferFromClientBuffer glad_eglCreatePbufferFromClientBuffer
+
+	GLAD_API_CALL int gladLoadEGLUserPtr(EGLDisplay display, GLADuserptrloadfunc load, void *userptr);
+	GLAD_API_CALL int gladLoadEGL(EGLDisplay display, GLADloadfunc load);
+
+#ifdef GLAD_EGL
+
+	GLAD_API_CALL int gladLoaderLoadEGL(EGLDisplay display);
+
+	GLAD_API_CALL void gladLoaderUnloadEGL(void);
+
+#endif
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/glad/glad/gl.h b/engine/inc/bullet/ThirdPartyLibs/glad/glad/gl.h
new file mode 100644
index 00000000..0dfb4d9c
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/glad/glad/gl.h
@@ -0,0 +1,5233 @@
+/**
+ * Loader generated by glad 0.1.11a0 on Wed Jun 13 07:59:51 2018
+ *
+ * Generator: C/C++
+ * Specification: gl
+ * Extensions: 1
+ *
+ * APIs:
+ *  - gl:compatibility=4.6
+ *
+ * Options:
+ *  - LOADER = True
+ *  - DEBUG = False
+ *  - ALIAS = False
+ *  - MX = False
+ *  - HEADER_ONLY = False
+ *  - MX_GLOBAL = False
+ *
+ * Commandline:
+ *    --api='gl:compatibility=4.6' --extensions='GL_ARB_point_sprite' c --loader
+ *
+ * Online:
+ *    http://glad2.dav1d.de/#merge=off&api=gl%3Acompatibility%3D4.6&extensions=GL_ARB_point_sprite&generator=c&loader=on&debug=off&alias=off&mx=off&header_only=off&mx_global=off
+ *
+ */
+
+#ifndef GLAD_GL_H_
+#define GLAD_GL_H_
+
+#ifdef __gl_h_
+#error OpenGL header already included (API: gl), remove previous include!
+#endif
+#define __gl_h_ 1
+
+#define GLAD_GL
+#define GLAD_OPTION_GL_LOADER
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#ifndef GLAD_PLATFORM_H_
+#define GLAD_PLATFORM_H_
+
+#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__MINGW32__)
+#define GLAD_PLATFORM_WIN32 1
+#else
+#define GLAD_PLATFORM_WIN32 0
+#endif
+
+#ifndef GLAD_PLATFORM_UWP
+#if defined(_MSC_VER) && !defined(GLAD_INTERNAL_HAVE_WINAPIFAMILY)
+#ifdef __has_include
+#if __has_include(<winapifamily.h>)
+#define GLAD_INTERNAL_HAVE_WINAPIFAMILY 1
+#endif
+#elif _MSC_VER >= 1700 && !_USING_V110_SDK71_
+#define GLAD_INTERNAL_HAVE_WINAPIFAMILY 1
+#endif
+#endif
+
+#ifdef GLAD_INTERNAL_HAVE_WINAPIFAMILY
+#include <winapifamily.h>
+#if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
+#define GLAD_PLATFORM_UWP 1
+#endif
+#endif
+
+#ifndef GLAD_PLATFORM_UWP
+#define GLAD_PLATFORM_UWP 0
+#endif
+#endif
+
+#ifdef __GNUC__
+#define GLAD_GNUC_EXTENSION __extension__
+#else
+#define GLAD_GNUC_EXTENSION
+#endif
+
+#ifndef GLAD_API_CALL
+#if defined(GLAD_API_CALL_EXPORT)
+#if GLAD_PLATFORM_WIN32 || defined(__CYGWIN__)
+#if defined(GLAD_API_CALL_EXPORT_BUILD)
+#if defined(__GNUC__)
+#define GLAD_API_CALL __attribute__((dllexport)) extern
+#else
+#define GLAD_API_CALL __declspec(dllexport) extern
+#endif
+#else
+#if defined(__GNUC__)
+#define GLAD_API_CALL __attribute__((dllimport)) extern
+#else
+#define GLAD_API_CALL __declspec(dllimport) extern
+#endif
+#endif
+#elif defined(__GNUC__) && defined(GLAD_API_CALL_EXPORT_BUILD)
+#define GLAD_API_CALL __attribute__((visibility("default"))) extern
+#else
+#define GLAD_API_CALL extern
+#endif
+#else
+#define GLAD_API_CALL extern
+#endif
+#endif
+
+#ifdef APIENTRY
+#define GLAD_API_PTR APIENTRY
+#elif GLAD_PLATFORM_WIN32
+#define GLAD_API_PTR __stdcall
+#else
+#define GLAD_API_PTR
+#endif
+
+#define GLAD_MAKE_VERSION(major, minor) (major * 10000 + minor)
+#define GLAD_VERSION_MAJOR(version) (version / 10000)
+#define GLAD_VERSION_MINOR(version) (version % 10000)
+
+	typedef void (*GLADapiproc)(void);
+
+	typedef GLADapiproc (*GLADloadfunc)(const char *name);
+	typedef GLADapiproc (*GLADuserptrloadfunc)(const char *name, void *userptr);
+
+	typedef void (*GLADprecallback)(const char *name, GLADapiproc apiproc, int len_args, ...);
+	typedef void (*GLADpostcallback)(void *ret, const char *name, GLADapiproc apiproc, int len_args, ...);
+
+#endif /* GLAD_PLATFORM_H_ */
+
+#define GL_PACK_COMPRESSED_BLOCK_HEIGHT 0x912C
+#define GL_MAX_COMPUTE_UNIFORM_COMPONENTS 0x8263
+#define GL_PROJECTION_MATRIX 0x0BA7
+#define GL_MAP1_GRID_DOMAIN 0x0DD0
+#define GL_INT_SAMPLER_1D_ARRAY 0x8DCE
+#define GL_MAX_ELEMENTS_INDICES 0x80E9
+#define GL_TEXTURE_INTENSITY_TYPE 0x8C15
+#define GL_TEXTURE31 0x84DF
+#define GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS 0x92DC
+#define GL_RGBA_MODE 0x0C31
+#define GL_ONE_MINUS_SRC_ALPHA 0x0303
+#define GL_SAMPLE_COVERAGE_INVERT 0x80AB
+#define GL_R32UI 0x8236
+#define GL_VERTEX_BINDING_BUFFER 0x8F4F
+#define GL_UNSIGNED_BYTE_3_3_2 0x8032
+#define GL_UNSIGNED_INT_IMAGE_BUFFER 0x9067
+#define GL_FOG_COORD_ARRAY_BUFFER_BINDING GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING
+#define GL_QUERY_WAIT 0x8E13
+#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88
+#define GL_MINOR_VERSION 0x821C
+#define GL_IMAGE_2D_MULTISAMPLE_ARRAY 0x9056
+#define GL_ATOMIC_COUNTER_BUFFER_INDEX 0x9301
+#define GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS 0x90EB
+#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105
+#define GL_TRIANGLE_STRIP_ADJACENCY 0x000D
+#define GL_MAX_LABEL_LENGTH 0x82E8
+#define GL_TEXTURE_DEPTH_SIZE 0x884A
+#define GL_IMAGE_CUBE_MAP_ARRAY 0x9054
+#define GL_NOOP 0x1505
+#define GL_COLOR_MATERIAL 0x0B57
+#define GL_RG32UI 0x823C
+#define GL_READ_WRITE 0x88BA
+#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214
+#define GL_4D_COLOR_TEXTURE 0x0604
+#define GL_BUFFER_USAGE 0x8765
+#define GL_TEXTURE_GEN_MODE 0x2500
+#define GL_T2F_V3F 0x2A27
+#define GL_COLOR_ATTACHMENT26 0x8CFA
+#define GL_INT_SAMPLER_BUFFER 0x8DD0
+#define GL_R16F 0x822D
+#define GL_TEXTURE_BINDING_3D 0x806A
+#define GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT 0x82B2
+#define GL_DONT_CARE 0x1100
+#define GL_STREAM_READ 0x88E1
+#define GL_DOUBLE_VEC4 0x8FFE
+#define GL_FUNC_SUBTRACT 0x800A
+#define GL_ACCUM_GREEN_BITS 0x0D59
+#define GL_S 0x2000
+#define GL_POINT_SIZE_RANGE 0x0B12
+#define GL_CURRENT_SECONDARY_COLOR 0x8459
+#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43
+#define GL_DEPTH_RENDERABLE 0x8287
+#define GL_FOG_COORDINATE 0x8451
+#define GL_REPLACE 0x1E01
+#define GL_SAMPLE_SHADING 0x8C36
+#define GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST 0x82AC
+#define GL_MAX_RENDERBUFFER_SIZE 0x84E8
+#define GL_SEPARATE_SPECULAR_COLOR 0x81FA
+#define GL_LEQUAL 0x0203
+#define GL_INDEX_ARRAY_POINTER 0x8091
+#define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF
+#define GL_OPERAND0_ALPHA 0x8598
+#define GL_UNPACK_COMPRESSED_BLOCK_SIZE 0x912A
+#define GL_MAX_GEOMETRY_INPUT_COMPONENTS 0x9123
+#define GL_LUMINANCE16 0x8042
+#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4
+#define GL_DEBUG_TYPE_POP_GROUP 0x826A
+#define GL_SHADER_STORAGE_BUFFER 0x90D2
+#define GL_INDEX_ARRAY_TYPE 0x8085
+#define GL_SCISSOR_BOX 0x0C10
+#define GL_IMAGE_CLASS_2_X_16 0x82BD
+#define GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT 0x90DF
+#define GL_OR 0x1507
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A
+#define GL_GREATER 0x0204
+#define GL_ANY_SAMPLES_PASSED_CONSERVATIVE 0x8D6A
+#define GL_VERTEX_BINDING_OFFSET 0x82D7
+#define GL_LIGHT_MODEL_AMBIENT 0x0B53
+#define GL_CW 0x0900
+#define GL_CONSTANT 0x8576
+#define GL_VIEW_CLASS_8_BITS 0x82CB
+#define GL_ALWAYS 0x0207
+#define GL_RENDERBUFFER_BINDING 0x8CA7
+#define GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY 0x9061
+#define GL_PIXEL_MAP_I_TO_G 0x0C73
+#define GL_COMPARE_R_TO_TEXTURE 0x884E
+#define GL_LUMINANCE16_ALPHA16 0x8048
+#define GL_INT_IMAGE_2D_RECT 0x905A
+#define GL_INTERNALFORMAT_GREEN_SIZE 0x8272
+#define GL_DEPTH_FUNC 0x0B74
+#define GL_MAX_TESS_PATCH_COMPONENTS 0x8E84
+#define GL_COMPRESSED_SLUMINANCE 0x8C4A
+#define GL_TEXTURE24 0x84D8
+#define GL_PACK_LSB_FIRST 0x0D01
+#define GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE 0x90C8
+#define GL_REFERENCED_BY_VERTEX_SHADER 0x9306
+#define GL_COLOR_WRITEMASK 0x0C23
+#define GL_UNIFORM_BUFFER_START 0x8A29
+#define GL_CLEAR 0x1500
+#define GL_UNIFORM_BLOCK_INDEX 0x8A3A
+#define GL_VERTEX_TEXTURE 0x829B
+#define GL_TEXTURE_WRAP_T 0x2803
+#define GL_T2F_C4F_N3F_V3F 0x2A2C
+#define GL_LUMINANCE4_ALPHA4 0x8043
+#define GL_SAMPLER_2D 0x8B5E
+#define GL_MAX_VARYING_COMPONENTS MAX_VARYING_FLOATS
+#define GL_PACK_COMPRESSED_BLOCK_WIDTH 0x912B
+#define GL_FEEDBACK_BUFFER_POINTER 0x0DF0
+#define GL_GEOMETRY_SHADER_BIT 0x00000004
+#define GL_DRAW_BUFFER7 0x882C
+#define GL_IMAGE_CLASS_4_X_8 0x82BF
+#define GL_POINT_SPRITE 0x8861
+#define GL_SOURCE1_RGB 0x8581
+#define GL_RGB 0x1907
+#define GL_RG16 0x822C
+#define GL_VIEWPORT_BIT 0x00000800
+#define GL_VERSION 0x1F02
+#define GL_SAMPLE_COVERAGE 0x80A0
+#define GL_INT_SAMPLER_2D_RECT 0x8DCD
+#define GL_RGB10_A2 0x8059
+#define GL_TESS_CONTROL_TEXTURE 0x829C
+#define GL_FRAGMENT_SUBROUTINE_UNIFORM 0x92F2
+#define GL_TEXTURE_GREEN_SIZE 0x805D
+#define GL_TEXTURE2 0x84C2
+#define GL_NEGATIVE_ONE_TO_ONE 0x935E
+#define GL_QUADRATIC_ATTENUATION 0x1209
+#define GL_CLAMP_VERTEX_COLOR 0x891A
+#define GL_SAMPLES 0x80A9
+#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128
+#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623
+#define GL_CLEAR_TEXTURE 0x9365
+#define GL_MAX_NAME_LENGTH 0x92F6
+#define GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT 0x00000001
+#define GL_POLYGON_OFFSET_FILL 0x8037
+#define GL_MAX_VERTEX_OUTPUT_COMPONENTS 0x9122
+#define GL_DEBUG_SOURCE_API 0x8246
+#define GL_INDEX_SHIFT 0x0D12
+#define GL_UNSIGNED_INT_ATOMIC_COUNTER 0x92DB
+#define GL_SHADER 0x82E1
+#define GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS 0x8E7F
+#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2
+#define GL_PROVOKING_VERTEX 0x8E4F
+#define GL_DEPTH_COMPONENT32F 0x8CAC
+#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212
+#define GL_MODULATE 0x2100
+#define GL_POLYGON_OFFSET_CLAMP 0x8E1B
+#define GL_FOG_COORDINATE_SOURCE 0x8450
+#define GL_FRAMEBUFFER_COMPLETE 0x8CD5
+#define GL_GET_TEXTURE_IMAGE_FORMAT 0x8291
+#define GL_SAMPLER_2D_SHADOW 0x8B62
+#define GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC 0x9279
+#define GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS 0x886D
+#define GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS 0x90DD
+#define GL_DEBUG_TYPE_ERROR 0x824C
+#define GL_DOUBLEBUFFER 0x0C32
+#define GL_SYNC_FLAGS 0x9115
+#define GL_SAMPLER_2D_MULTISAMPLE 0x9108
+#define GL_TRANSFORM_FEEDBACK_BARRIER_BIT 0x00000800
+#define GL_AMBIENT 0x1200
+#define GL_SRC0_RGB GL_SOURCE0_RGB
+#define GL_EXP 0x0800
+#define GL_FIXED 0x140C
+#define GL_NOTEQUAL 0x0205
+#define GL_VIEW_CLASS_48_BITS 0x82C7
+#define GL_DEPTH_STENCIL 0x84F9
+#define GL_UNIFORM_TYPE 0x8A37
+#define GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM 0x8E8D
+#define GL_RGBA32F 0x8814
+#define GL_MAX_NAME_STACK_DEPTH 0x0D37
+#define GL_BUFFER_MAP_OFFSET 0x9121
+#define GL_FOG_HINT 0x0C54
+#define GL_UNPACK_ALIGNMENT 0x0CF5
+#define GL_COLOR_LOGIC_OP 0x0BF2
+#define GL_VERTICES_SUBMITTED 0x82EE
+#define GL_STENCIL_INDEX4 0x8D47
+#define GL_PIXEL_MAP_G_TO_G 0x0C77
+#define GL_TEXTURE_1D 0x0DE0
+#define GL_NO_ERROR 0
+#define GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT 0x00004000
+#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56
+#define GL_INTERLEAVED_ATTRIBS 0x8C8C
+#define GL_MAX_DEBUG_GROUP_STACK_DEPTH 0x826C
+#define GL_SECONDARY_COLOR_ARRAY_TYPE 0x845B
+#define GL_TRANSFORM_FEEDBACK 0x8E22
+#define GL_CLIP_DEPTH_MODE 0x935D
+#define GL_TEXTURE_SHARED_SIZE 0x8C3F
+#define GL_MAX 0x8008
+#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED 0x8DA7
+#define GL_RENDER_MODE 0x0C40
+#define GL_COLOR_ATTACHMENT12 0x8CEC
+#define GL_LIST_BIT 0x00020000
+#define GL_DOT3_RGB 0x86AE
+#define GL_RG16I 0x8239
+#define GL_T2F_C4UB_V3F 0x2A29
+#define GL_INTERNALFORMAT_RED_SIZE 0x8271
+#define GL_QUERY_BUFFER_BARRIER_BIT 0x00008000
+#define GL_R11F_G11F_B10F 0x8C3A
+#define GL_TEXTURE27 0x84DB
+#define GL_MAX_CLIENT_ATTRIB_STACK_DEPTH 0x0D3B
+#define GL_COEFF 0x0A00
+#define GL_MAP2_VERTEX_3 0x0DB7
+#define GL_QUERY 0x82E3
+#define GL_FRAGMENT_SHADER_INVOCATIONS 0x82F4
+#define GL_ALPHA_BITS 0x0D55
+#define GL_CURRENT_FOG_COORDINATE 0x8453
+#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D
+#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0
+#define GL_SAMPLE_MASK_VALUE 0x8E52
+#define GL_LINEAR_MIPMAP_LINEAR 0x2703
+#define GL_INTERNALFORMAT_ALPHA_SIZE 0x8274
+#define GL_MAX_DUAL_SOURCE_DRAW_BUFFERS 0x88FC
+#define GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS 0x8E1F
+#define GL_MAX_CULL_DISTANCES 0x82F9
+#define GL_INTERNALFORMAT_DEPTH_TYPE 0x827C
+#define GL_FLOAT_MAT2x4 0x8B66
+#define GL_FLOAT_VEC3 0x8B51
+#define GL_RENDERBUFFER 0x8D41
+#define GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH 0x8E49
+#define GL_SPIR_V_EXTENSIONS 0x9553
+#define GL_TEXTURE_COMPRESSION_HINT 0x84EF
+#define GL_TEXTURE4 0x84C4
+#define GL_VERTEX_ARRAY_POINTER 0x808E
+#define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84
+#define GL_MAX_COMPUTE_UNIFORM_BLOCKS 0x91BB
+#define GL_COLOR_ATTACHMENT16 0x8CF0
+#define GL_ADD_SIGNED 0x8574
+#define GL_RENDERER 0x1F01
+#define GL_VIEW_COMPATIBILITY_CLASS 0x82B6
+#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910B
+#define GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED 0x82F3
+#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION 0x8E4C
+#define GL_TESS_CONTROL_SHADER_BIT 0x00000008
+#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD
+#define GL_FILL 0x1B02
+#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213
+#define GL_INDEX_LOGIC_OP 0x0BF1
+#define GL_IMAGE_CLASS_1_X_8 0x82C1
+#define GL_RGB5_A1 0x8057
+#define GL_STENCIL_INDEX 0x1901
+#define GL_INT_IMAGE_2D 0x9058
+#define GL_FRAMEBUFFER_UNDEFINED 0x8219
+#define GL_ACCUM_RED_BITS 0x0D58
+#define GL_POLYGON_OFFSET_POINT 0x2A01
+#define GL_MAX_3D_TEXTURE_SIZE 0x8073
+#define GL_ZOOM_Y 0x0D17
+#define GL_DEBUG_SEVERITY_HIGH 0x9146
+#define GL_R16 0x822A
+#define GL_SCISSOR_TEST 0x0C11
+#define GL_RGB10_A2UI 0x906F
+#define GL_ACTIVE_SUBROUTINE_UNIFORMS 0x8DE6
+#define GL_FOG_BIT 0x00000080
+#define GL_GEOMETRY_TEXTURE 0x829E
+#define GL_UNIFORM_BLOCK 0x92E2
+#define GL_INT_SAMPLER_CUBE 0x8DCC
+#define GL_PACK_SKIP_PIXELS 0x0D04
+#define GL_TEXTURE_SHADOW 0x82A1
+#define GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS 0x90CC
+#define GL_RED_BITS 0x0D52
+#define GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT 0x8E8F
+#define GL_COLOR_ATTACHMENT6 0x8CE6
+#define GL_TEXTURE_CUBE_MAP_ARRAY 0x9009
+#define GL_COLOR_INDEXES 0x1603
+#define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4
+#define GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS 0x92D4
+#define GL_TEXTURE_WRAP_R 0x8072
+#define GL_TESS_GEN_SPACING 0x8E77
+#define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36
+#define GL_INTENSITY16 0x804D
+#define GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE 0x8E24
+#define GL_COLOR_ATTACHMENT2 0x8CE2
+#define GL_WRITE_ONLY 0x88B9
+#define GL_GREEN_INTEGER 0x8D95
+#define GL_IMAGE_FORMAT_COMPATIBILITY_TYPE 0x90C7
+#define GL_TEXTURE_BINDING_2D_MULTISAMPLE 0x9104
+#define GL_R8UI 0x8232
+#define GL_DRAW_BUFFER1 0x8826
+#define GL_PIXEL_MAP_I_TO_B 0x0C74
+#define GL_MEDIUM_INT 0x8DF4
+#define GL_TEXTURE_VIEW_NUM_LEVELS 0x82DC
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517
+#define GL_IMAGE_BINDING_LAYERED 0x8F3C
+#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803
+#define GL_RED_BIAS 0x0D15
+#define GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY 0x906C
+#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004
+#define GL_FLOAT 0x1406
+#define GL_MAP_WRITE_BIT 0x0002
+#define GL_CONDITION_SATISFIED 0x911C
+#define GL_NUM_ACTIVE_VARIABLES 0x9304
+#define GL_PROGRAM_PIPELINE_BINDING 0x825A
+#define GL_OBJECT_PLANE 0x2501
+#define GL_DEBUG_SOURCE_THIRD_PARTY 0x8249
+#define GL_TEXTURE_ALPHA_SIZE 0x805F
+#define GL_COMPRESSED_LUMINANCE 0x84EA
+#define GL_FLOAT_MAT4x2 0x8B69
+#define GL_COLOR_ATTACHMENT19 0x8CF3
+#define GL_RGBA8I 0x8D8E
+#define GL_GEOMETRY_SUBROUTINE 0x92EB
+#define GL_FOG_COORD_ARRAY_STRIDE GL_FOG_COORDINATE_ARRAY_STRIDE
+#define GL_FEEDBACK 0x1C01
+#define GL_POLYGON_BIT 0x00000008
+#define GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS 0x92C5
+#define GL_ALPHA12 0x803D
+#define GL_TEXTURE_COMPRESSED 0x86A1
+#define GL_FRAMEBUFFER_BINDING 0x8CA6
+#define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B
+#define GL_TEXTURE1 0x84C1
+#define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3
+#define GL_DOUBLE_MAT3x2 0x8F4B
+#define GL_ONE_MINUS_DST_ALPHA 0x0305
+#define GL_CULL_FACE_MODE 0x0B45
+#define GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED 0x8221
+#define GL_SHADER_STORAGE_BUFFER_BINDING 0x90D3
+#define GL_COLOR_RENDERABLE 0x8286
+#define GL_MAX_FRAGMENT_UNIFORM_VECTORS 0x8DFD
+#define GL_T2F_N3F_V3F 0x2A2B
+#define GL_TEXTURE_DEPTH 0x8071
+#define GL_DEPTH_COMPONENT16 0x81A5
+#define GL_STENCIL_BACK_FAIL 0x8801
+#define GL_COMPRESSED_RG_RGTC2 0x8DBD
+#define GL_ATTACHED_SHADERS 0x8B85
+#define GL_TEXTURE_IMAGE_FORMAT 0x828F
+#define GL_TEXTURE_GATHER 0x82A2
+#define GL_LOAD 0x0101
+#define GL_DEPTH32F_STENCIL8 0x8CAD
+#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215
+#define GL_ACTIVE_TEXTURE 0x84E0
+#define GL_TEXTURE_BORDER 0x1005
+#define GL_COMPUTE_SUBROUTINE_UNIFORM 0x92F3
+#define GL_MAX_LIGHTS 0x0D31
+#define GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE 0x906B
+#define GL_V3F 0x2A21
+#define GL_TESS_EVALUATION_TEXTURE 0x829D
+#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6
+#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9102
+#define GL_INTERNALFORMAT_PREFERRED 0x8270
+#define GL_UNSIGNED_INT_SAMPLER_1D 0x8DD1
+#define GL_FRAGMENT_TEXTURE 0x829F
+#define GL_IMAGE_TEXEL_SIZE 0x82A7
+#define GL_POINT_DISTANCE_ATTENUATION 0x8129
+#define GL_RGB32I 0x8D83
+#define GL_INT_VEC4 0x8B55
+#define GL_FRONT 0x0404
+#define GL_TEXTURE18 0x84D2
+#define GL_DRAW_BUFFER9 0x882E
+#define GL_SHADER_COMPILER 0x8DFA
+#define GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET 0x8E5F
+#define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E
+#define GL_INT_SAMPLER_3D 0x8DCB
+#define GL_RGBA16 0x805B
+#define GL_2D 0x0600
+#define GL_FRONT_LEFT 0x0400
+#define GL_UNPACK_LSB_FIRST 0x0CF1
+#define GL_EQUIV 0x1509
+#define GL_LIGHTING_BIT 0x00000040
+#define GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 0x9277
+#define GL_INVALID_OPERATION 0x0502
+#define GL_TEXTURE25 0x84D9
+#define GL_POINT_SIZE_MAX 0x8127
+#define GL_MAX_CLIP_DISTANCES GL_MAX_CLIP_PLANES
+#define GL_DEBUG_TYPE_PUSH_GROUP 0x8269
+#define GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS 0x90DC
+#define GL_SPHERE_MAP 0x2402
+#define GL_RG32F 0x8230
+#define GL_QUERY_NO_WAIT 0x8E14
+#define GL_POINT_SIZE_MIN 0x8126
+#define GL_MAX_VERTEX_UNIFORM_VECTORS 0x8DFB
+#define GL_RG8I 0x8237
+#define GL_FRAGMENT_SHADER_BIT 0x00000002
+#define GL_MAP2_NORMAL 0x0DB2
+#define GL_TEXTURE_BLUE_SIZE 0x805E
+#define GL_UNSIGNED_INT_VEC4 0x8DC8
+#define GL_INT_VEC3 0x8B54
+#define GL_COPY_READ_BUFFER_BINDING GL_COPY_READ_BUFFER
+#define GL_CLIP_DISTANCE6 0x3006
+#define GL_TEXTURE_SWIZZLE_B 0x8E44
+#define GL_CLIPPING_OUTPUT_PRIMITIVES 0x82F7
+#define GL_DOUBLE_MAT2x3 0x8F49
+#define GL_COLOR_ARRAY 0x8076
+#define GL_DEPTH_WRITEMASK 0x0B72
+#define GL_CURRENT_RASTER_TEXTURE_COORDS 0x0B06
+#define GL_COLOR_ARRAY_STRIDE 0x8083
+#define GL_PARAMETER_BUFFER 0x80EE
+#define GL_LINE_BIT 0x00000004
+#define GL_IS_PER_PATCH 0x92E7
+#define GL_DEBUG_CALLBACK_FUNCTION 0x8244
+#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0
+#define GL_UNSIGNED_SHORT 0x1403
+#define GL_R 0x2002
+#define GL_COLOR_ATTACHMENT18 0x8CF2
+#define GL_IMAGE_BINDING_LEVEL 0x8F3B
+#define GL_TEXTURE_UPDATE_BARRIER_BIT 0x00000100
+#define GL_TEXTURE_BORDER_COLOR 0x1004
+#define GL_COLOR_SUM 0x8458
+#define GL_DRAW_BUFFER5 0x882A
+#define GL_FRAMEBUFFER_DEFAULT 0x8218
+#define GL_MAX_TEXTURE_UNITS 0x84E2
+#define GL_COLOR_MATERIAL_FACE 0x0B55
+#define GL_LIGHT4 0x4004
+#define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD
+#define GL_BUFFER_MAPPED 0x88BC
+#define GL_DISPLAY_LIST 0x82E7
+#define GL_UNSIGNED_INT_SAMPLER_BUFFER 0x8DD8
+#define GL_BITMAP 0x1A00
+#define GL_T2F_C3F_V3F 0x2A2A
+#define GL_COLOR_ATTACHMENT20 0x8CF4
+#define GL_INVALID_VALUE 0x0501
+#define GL_COMPARE_REF_TO_TEXTURE GL_COMPARE_R_TO_TEXTURE
+#define GL_PROGRAM_SEPARABLE 0x8258
+#define GL_BACK 0x0405
+#define GL_TESS_GEN_VERTEX_ORDER 0x8E78
+#define GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS 0x8264
+#define GL_FOG 0x0B60
+#define GL_LOW_INT 0x8DF3
+#define GL_ARRAY_BUFFER 0x8892
+#define GL_COLOR_ARRAY_TYPE 0x8082
+#define GL_NUM_COMPATIBLE_SUBROUTINES 0x8E4A
+#define GL_COMPILE_STATUS 0x8B81
+#define GL_STENCIL_INDEX16 0x8D49
+#define GL_VIEW_CLASS_32_BITS 0x82C8
+#define GL_R3_G3_B2 0x2A10
+#define GL_QUERY_TARGET 0x82EA
+#define GL_CLIP_ORIGIN 0x935C
+#define GL_DRAW_BUFFER12 0x8831
+#define GL_ONE_MINUS_SRC1_COLOR 0x88FA
+#define GL_TEXTURE30 0x84DE
+#define GL_STATIC_READ 0x88E5
+#define GL_RGB565 0x8D62
+#define GL_TESS_EVALUATION_SHADER_BIT 0x00000010
+#define GL_CURRENT_RASTER_POSITION_VALID 0x0B08
+#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE 0x910A
+#define GL_MANUAL_GENERATE_MIPMAP 0x8294
+#define GL_PRIMITIVES_GENERATED 0x8C87
+#define GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS 0x8E82
+#define GL_ALL_BARRIER_BITS 0xFFFFFFFF
+#define GL_CONSTANT_ALPHA 0x8003
+#define GL_RGB16_SNORM 0x8F9A
+#define GL_INVERT 0x150A
+#define GL_BLOCK_INDEX 0x92FD
+#define GL_MAX_VIEWPORT_DIMS 0x0D3A
+#define GL_TEXTURE11 0x84CB
+#define GL_RG 0x8227
+#define GL_BUFFER_SIZE 0x8764
+#define GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS 0x8E85
+#define GL_GUILTY_CONTEXT_RESET 0x8253
+#define GL_COMPUTE_WORK_GROUP_SIZE 0x8267
+#define GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS 0x8E89
+#define GL_TEXTURE21 0x84D5
+#define GL_HIGH_INT 0x8DF5
+#define GL_COMPUTE_SHADER_INVOCATIONS 0x82F5
+#define GL_LESS 0x0201
+#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0
+#define GL_PROXY_TEXTURE_2D_ARRAY 0x8C1B
+#define GL_AUX_BUFFERS 0x0C00
+#define GL_TEXTURE_INTENSITY_SIZE 0x8061
+#define GL_ACCUM_BLUE_BITS 0x0D5A
+#define GL_ACTIVE_ATTRIBUTES 0x8B89
+#define GL_SAMPLE_MASK 0x8E51
+#define GL_MAP1_INDEX 0x0D91
+#define GL_UNSIGNED_INT_IMAGE_1D 0x9062
+#define GL_UNPACK_SKIP_IMAGES 0x806D
+#define GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST 0x82AD
+#define GL_BOOL_VEC3 0x8B58
+#define GL_FOG_COORDINATE_ARRAY_POINTER 0x8456
+#define GL_MULTISAMPLE 0x809D
+#define GL_TEXTURE_COORD_ARRAY_TYPE 0x8089
+#define GL_PROXY_TEXTURE_RECTANGLE 0x84F7
+#define GL_LIGHT5 0x4005
+#define GL_LOSE_CONTEXT_ON_RESET 0x8252
+#define GL_QUERY_WAIT_INVERTED 0x8E17
+#define GL_DEPTH24_STENCIL8 0x88F0
+#define GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW 0x900D
+#define GL_FOG_END 0x0B64
+#define GL_MAX_COMBINED_DIMENSIONS 0x8282
+#define GL_TRANSPOSE_MODELVIEW_MATRIX 0x84E3
+#define GL_MAX_GEOMETRY_SHADER_INVOCATIONS 0x8E5A
+#define GL_FLOAT_VEC2 0x8B50
+#define GL_STEREO 0x0C33
+#define GL_READ_PIXELS_FORMAT 0x828D
+#define GL_SAMPLE_POSITION 0x8E50
+#define GL_DOUBLE_MAT4x3 0x8F4E
+#define GL_SECONDARY_COLOR_ARRAY_STRIDE 0x845C
+#define GL_NEAREST_MIPMAP_LINEAR 0x2702
+#define GL_SMOOTH 0x1D01
+#define GL_BUFFER_ACCESS_FLAGS 0x911F
+#define GL_TEXTURE_COMPONENTS 0x1003
+#define GL_CLIP_DISTANCE7 0x3007
+#define GL_LUMINANCE_ALPHA 0x190A
+#define GL_TEXTURE_CUBE_MAP 0x8513
+#define GL_NORMALIZE 0x0BA1
+#define GL_SOURCE1_ALPHA 0x8589
+#define GL_INT_SAMPLER_2D 0x8DCA
+#define GL_RGBA2 0x8055
+#define GL_TEXTURE_BUFFER 0x8C2A
+#define GL_TEXTURE_LUMINANCE_SIZE 0x8060
+#define GL_ARRAY_BUFFER_BINDING 0x8894
+#define GL_OPERAND1_RGB 0x8591
+#define GL_C4UB_V3F 0x2A23
+#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76
+#define GL_SAMPLE_BUFFERS 0x80A8
+#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211
+#define GL_ONE_MINUS_SRC_COLOR 0x0301
+#define GL_NUM_PROGRAM_BINARY_FORMATS 0x87FE
+#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD
+#define GL_INT_IMAGE_3D 0x9059
+#define GL_BLEND_DST_RGB 0x80C8
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4
+#define GL_SHADER_STORAGE_BUFFER_START 0x90D4
+#define GL_MAP2_GRID_SEGMENTS 0x0DD3
+#define GL_NUM_SPIR_V_EXTENSIONS 0x9554
+#define GL_COLOR_MATERIAL_PARAMETER 0x0B56
+#define GL_SIGNALED 0x9119
+#define GL_ACTIVE_SUBROUTINE_MAX_LENGTH 0x8E48
+#define GL_TEXTURE_COORD_ARRAY_STRIDE 0x808A
+#define GL_MAX_GEOMETRY_OUTPUT_VERTICES 0x8DE0
+#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117
+#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER 0x92CA
+#define GL_COPY_INVERTED 0x150C
+#define GL_STENCIL_COMPONENTS 0x8285
+#define GL_PIXEL_MAP_I_TO_I 0x0C70
+#define GL_COMPRESSED_RGB 0x84ED
+#define GL_BYTE 0x1400
+#define GL_MAX_FRAMEBUFFER_SAMPLES 0x9318
+#define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E
+#define GL_COMBINE_RGB 0x8571
+#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F
+#define GL_UNIFORM_MATRIX_STRIDE 0x8A3D
+#define GL_TRANSFORM_FEEDBACK_BUFFER_STRIDE 0x934C
+#define GL_PROXY_TEXTURE_2D_MULTISAMPLE 0x9101
+#define GL_PROXY_TEXTURE_1D_ARRAY 0x8C19
+#define GL_FOG_COORD_ARRAY_TYPE GL_FOG_COORDINATE_ARRAY_TYPE
+#define GL_DISPATCH_INDIRECT_BUFFER 0x90EE
+#define GL_BUFFER_ACCESS 0x88BB
+#define GL_STACK_UNDERFLOW 0x0504
+#define GL_SUBTRACT 0x84E7
+#define GL_QUERY_BUFFER_BINDING 0x9193
+#define GL_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC
+#define GL_PARAMETER_BUFFER_BINDING 0x80EF
+#define GL_STENCIL_FUNC 0x0B92
+#define GL_PIXEL_MAP_I_TO_R_SIZE 0x0CB2
+#define GL_MAP1_TEXTURE_COORD_4 0x0D96
+#define GL_SMOOTH_POINT_SIZE_RANGE GL_POINT_SIZE_RANGE
+#define GL_FRAMEBUFFER_RENDERABLE_LAYERED 0x828A
+#define GL_ALPHA_INTEGER 0x8D97
+#define GL_SPOT_CUTOFF 0x1206
+#define GL_PATCHES 0x000E
+#define GL_TESS_CONTROL_SUBROUTINE_UNIFORM 0x92EF
+#define GL_COMPRESSED_RGBA_BPTC_UNORM 0x8E8C
+#define GL_RGB8I 0x8D8F
+#define GL_PROGRAM_PIPELINE 0x82E4
+#define GL_SHADER_IMAGE_LOAD 0x82A4
+#define GL_STATIC_DRAW 0x88E4
+#define GL_EQUAL 0x0202
+#define GL_SRGB 0x8C40
+#define GL_Q 0x2003
+#define GL_DRAW_BUFFER2 0x8827
+#define GL_TEXTURE_GREEN_TYPE 0x8C11
+#define GL_COMBINE 0x8570
+#define GL_READ_BUFFER 0x0C02
+#define GL_TEXTURE_BUFFER_OFFSET 0x919D
+#define GL_SHADING_LANGUAGE_VERSION 0x8B8C
+#define GL_CONTEXT_PROFILE_MASK 0x9126
+#define GL_DRAW_INDIRECT_BUFFER_BINDING 0x8F43
+#define GL_TEXTURE_BLUE_TYPE 0x8C12
+#define GL_ACTIVE_ATOMIC_COUNTER_BUFFERS 0x92D9
+#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF
+#define GL_TEXTURE16 0x84D0
+#define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30
+#define GL_ALPHA_TEST 0x0BC0
+#define GL_REFERENCED_BY_GEOMETRY_SHADER 0x9309
+#define GL_COLOR_ATTACHMENT4 0x8CE4
+#define GL_COLOR_ATTACHMENT28 0x8CFC
+#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS 0x9124
+#define GL_MEDIUM_FLOAT 0x8DF1
+#define GL_COMPRESSED_SRGB 0x8C48
+#define GL_PIXEL_MODE_BIT 0x00000020
+#define GL_SMOOTH_LINE_WIDTH_GRANULARITY GL_LINE_WIDTH_GRANULARITY
+#define GL_4_BYTES 0x1409
+#define GL_COMPRESSED_SRGB8_ETC2 0x9275
+#define GL_IMAGE_CLASS_2_X_8 0x82C0
+#define GL_POLYGON_STIPPLE_BIT 0x00000010
+#define GL_CURRENT_PROGRAM 0x8B8D
+#define GL_STACK_OVERFLOW 0x0503
+#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002
+#define GL_CURRENT_RASTER_SECONDARY_COLOR 0x845F
+#define GL_BLUE_BITS 0x0D54
+#define GL_SAMPLER_CUBE 0x8B60
+#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY 0x8DD6
+#define GL_TRANSFORM_BIT 0x00001000
+#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E
+#define GL_INNOCENT_CONTEXT_RESET 0x8254
+#define GL_COMPRESSED_RG 0x8226
+#define GL_UNSIGNED_SHORT_5_6_5 0x8363
+#define GL_FLOAT_MAT4 0x8B5C
+#define GL_RGB_INTEGER 0x8D98
+#define GL_TRUE 1
+#define GL_COLOR_ATTACHMENT21 0x8CF5
+#define GL_TRANSPOSE_COLOR_MATRIX 0x84E6
+#define GL_RENDERBUFFER_RED_SIZE 0x8D50
+#define GL_LEFT 0x0406
+#define GL_MAP1_VERTEX_4 0x0D98
+#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362
+#define GL_INTENSITY4 0x804A
+#define GL_CURRENT_QUERY 0x8865
+#define GL_TEXTURE_VIEW_NUM_LAYERS 0x82DE
+#define GL_QUERY_RESULT 0x8866
+#define GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS 0x8E80
+#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624
+#define GL_UNIFORM_BUFFER_SIZE 0x8A2A
+#define GL_DEBUG_TYPE_PORTABILITY 0x824F
+#define GL_COMBINE_ALPHA 0x8572
+#define GL_CURRENT_INDEX 0x0B01
+#define GL_TEXTURE_COMPARE_MODE 0x884C
+#define GL_GENERATE_MIPMAP 0x8191
+#define GL_LOW_FLOAT 0x8DF0
+#define GL_MAP2_TEXTURE_COORD_3 0x0DB5
+#define GL_UNSIGNED_INT_IMAGE_2D 0x9063
+#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F
+#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367
+#define GL_LOGIC_OP 0x0BF1
+#define GL_BUFFER_VARIABLE 0x92E5
+#define GL_NOR 0x1508
+#define GL_STREAM_COPY 0x88E2
+#define GL_SELECTION_BUFFER_POINTER 0x0DF3
+#define GL_IMAGE_CLASS_4_X_16 0x82BC
+#define GL_TRANSPOSE_TEXTURE_MATRIX 0x84E5
+#define GL_COMPILE_AND_EXECUTE 0x1301
+#define GL_VIEWPORT_SUBPIXEL_BITS 0x825C
+#define GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS 0x8E8A
+#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B
+#define GL_ALPHA4 0x803B
+#define GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS 0x90C9
+#define GL_CCW 0x0901
+#define GL_FLOAT_MAT2x3 0x8B65
+#define GL_PATCH_DEFAULT_INNER_LEVEL 0x8E73
+#define GL_DRAW_BUFFER13 0x8832
+#define GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET 0x82D9
+#define GL_UPPER_LEFT 0x8CA2
+#define GL_COMPRESSED_ALPHA 0x84E9
+#define GL_SIGNED_NORMALIZED 0x8F9C
+#define GL_MAX_VERTEX_STREAMS 0x8E71
+#define GL_PRIMARY_COLOR 0x8577
+#define GL_COMPRESSED_SIGNED_R11_EAC 0x9271
+#define GL_TEXTURE_BINDING_CUBE_MAP_ARRAY 0x900A
+#define GL_MAP2_VERTEX_4 0x0DB8
+#define GL_FRONT_AND_BACK 0x0408
+#define GL_DEBUG_TYPE_PERFORMANCE 0x8250
+#define GL_ALPHA8 0x803C
+#define GL_IMAGE_PIXEL_TYPE 0x82AA
+#define GL_QUERY_BY_REGION_WAIT_INVERTED 0x8E19
+#define GL_UNSIGNED_INT_10_10_10_2 0x8036
+#define GL_EXP2 0x0801
+#define GL_TEXTURE_GEN_S 0x0C60
+#define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F
+#define GL_VIEW_CLASS_128_BITS 0x82C4
+#define GL_ATOMIC_COUNTER_BUFFER 0x92C0
+#define GL_LINE_RESET_TOKEN 0x0707
+#define GL_CLAMP 0x2900
+#define GL_PIXEL_UNPACK_BUFFER 0x88EC
+#define GL_RGB16UI 0x8D77
+#define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55
+#define GL_UNPACK_COMPRESSED_BLOCK_WIDTH 0x9127
+#define GL_FRAMEBUFFER_RENDERABLE 0x8289
+#define GL_DIFFUSE 0x1201
+#define GL_DEPTH_BIAS 0x0D1F
+#define GL_IMAGE_PIXEL_FORMAT 0x82A9
+#define GL_FLOAT_MAT3x2 0x8B67
+#define GL_TEXTURE_SWIZZLE_RGBA 0x8E46
+#define GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS 0x92D0
+#define GL_FRONT_RIGHT 0x0401
+#define GL_DRAW_FRAMEBUFFER_BINDING 0x8CA6
+#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95
+#define GL_CLIP_DISTANCE2 GL_CLIP_PLANE2
+#define GL_DEPTH_BITS 0x0D56
+#define GL_MAX_TRANSFORM_FEEDBACK_BUFFERS 0x8E70
+#define GL_SOURCE2_ALPHA 0x858A
+#define GL_AND_INVERTED 0x1504
+#define GL_IMAGE_BINDING_FORMAT 0x906E
+#define GL_RGB8_SNORM 0x8F96
+#define GL_BOOL_VEC2 0x8B57
+#define GL_SAMPLER_2D_ARRAY 0x8DC1
+#define GL_UNIFORM_BLOCK_BINDING 0x8A3F
+#define GL_VIEW_CLASS_96_BITS 0x82C5
+#define GL_DEPTH_TEST 0x0B71
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER 0x8A45
+#define GL_SAMPLE_ALPHA_TO_ONE 0x809F
+#define GL_POLYGON 0x0009
+#define GL_BOOL_VEC4 0x8B59
+#define GL_MAX_SERVER_WAIT_TIMEOUT 0x9111
+#define GL_FRACTIONAL_ODD 0x8E7B
+#define GL_UNIFORM 0x92E1
+#define GL_PRIMITIVE_RESTART_FIXED_INDEX 0x8D69
+#define GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS 0x8E86
+#define GL_MAX_COMPUTE_SHARED_MEMORY_SIZE 0x8262
+#define GL_ALPHA_BIAS 0x0D1D
+#define GL_POINT_TOKEN 0x0701
+#define GL_TEXTURE_BINDING_RECTANGLE 0x84F6
+#define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53
+#define GL_TEXTURE_VIEW_MIN_LAYER 0x82DD
+#define GL_FLOAT_MAT3 0x8B5B
+#define GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS 0x8E81
+#define GL_MAX_VERTEX_IMAGE_UNIFORMS 0x90CA
+#define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F
+#define GL_NICEST 0x1102
+#define GL_C3F_V3F 0x2A24
+#define GL_PROXY_TEXTURE_CUBE_MAP_ARRAY 0x900B
+#define GL_BACK_LEFT 0x0402
+#define GL_SOURCE0_RGB 0x8580
+#define GL_ACTIVE_PROGRAM 0x8259
+#define GL_INT_SAMPLER_2D_ARRAY 0x8DCF
+#define GL_STENCIL_REF 0x0B97
+#define GL_MIN_SAMPLE_SHADING_VALUE 0x8C37
+#define GL_DRAW_BUFFER3 0x8828
+#define GL_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE
+#define GL_UNIFORM_ARRAY_STRIDE 0x8A3C
+#define GL_BLEND_EQUATION_RGB 0x8009
+#define GL_LUMINANCE 0x1909
+#define GL_COMPRESSED_INTENSITY 0x84EC
+#define GL_LUMINANCE12 0x8041
+#define GL_PACK_SKIP_IMAGES 0x806B
+#define GL_SHADER_IMAGE_ACCESS_BARRIER_BIT 0x00000020
+#define GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS 0x92CC
+#define GL_COLOR_ATTACHMENT17 0x8CF1
+#define GL_TEXTURE_GEN_R 0x0C62
+#define GL_SAMPLER_CUBE_MAP_ARRAY 0x900C
+#define GL_HALF_FLOAT 0x140B
+#define GL_TEXTURE_FIXED_SAMPLE_LOCATIONS 0x9107
+#define GL_AND_REVERSE 0x1502
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516
+#define GL_PIXEL_PACK_BUFFER 0x88EB
+#define GL_MAX_DEPTH_TEXTURE_SAMPLES 0x910F
+#define GL_INT_VEC2 0x8B53
+#define GL_INDEX_OFFSET 0x0D13
+#define GL_SAMPLER_1D_ARRAY 0x8DC0
+#define GL_TEXTURE20 0x84D4
+#define GL_LOGIC_OP_MODE 0x0BF0
+#define GL_ZERO 0
+#define GL_UNIFORM_BUFFER_BINDING 0x8A28
+#define GL_SCISSOR_BIT 0x00080000
+#define GL_TEXTURE_PRIORITY 0x8066
+#define GL_DRAW_BUFFER11 0x8830
+#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB
+#define GL_COLOR_ATTACHMENT23 0x8CF7
+#define GL_NAME_STACK_DEPTH 0x0D70
+#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216
+#define GL_COLOR_ATTACHMENT30 0x8CFE
+#define GL_FOG_COORD GL_FOG_COORDINATE
+#define GL_IMAGE_CLASS_10_10_10_2 0x82C3
+#define GL_MIN_MAP_BUFFER_ALIGNMENT 0x90BC
+#define GL_COMMAND_BARRIER_BIT 0x00000040
+#define GL_LUMINANCE4 0x803F
+#define GL_INTERNALFORMAT_GREEN_TYPE 0x8279
+#define GL_DEPTH_COMPONENTS 0x8284
+#define GL_BGR 0x80E0
+#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED
+#define GL_LINE_STIPPLE 0x0B24
+#define GL_COLOR_COMPONENTS 0x8283
+#define GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS 0x90D9
+#define GL_UNSIGNED_INT_IMAGE_2D_RECT 0x9065
+#define GL_UNSIGNED_INT_8_8_8_8 0x8035
+#define GL_XOR 0x1506
+#define GL_INT_SAMPLER_CUBE_MAP_ARRAY 0x900E
+#define GL_MATRIX_MODE 0x0BA0
+#define GL_TEXTURE_COORD_ARRAY_POINTER 0x8092
+#define GL_INDEX_MODE 0x0C30
+#define GL_MAX_VERTEX_ATTRIBS 0x8869
+#define GL_LIGHT_MODEL_COLOR_CONTROL 0x81F8
+#define GL_NORMAL_ARRAY 0x8075
+#define GL_PACK_ROW_LENGTH 0x0D02
+#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS 0x8A2C
+#define GL_INDEX_WRITEMASK 0x0C21
+#define GL_COLOR_ATTACHMENT0 0x8CE0
+#define GL_RENDERBUFFER_HEIGHT 0x8D43
+#define GL_FLOAT_MAT2 0x8B5A
+#define GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR 0x824D
+#define GL_TEXTURE23 0x84D7
+#define GL_MAX_SAMPLES 0x8D57
+#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802
+#define GL_AUX3 0x040C
+#define GL_FRAMEBUFFER_DEFAULT_HEIGHT 0x9311
+#define GL_INTERNALFORMAT_BLUE_SIZE 0x8273
+#define GL_MAX_COMBINED_IMAGE_UNIFORMS 0x90CF
+#define GL_DOUBLE_MAT2 0x8F46
+#define GL_RESET_NOTIFICATION_STRATEGY 0x8256
+#define GL_INDEX_CLEAR_VALUE 0x0C20
+#define GL_MAX_PATCH_VERTICES 0x8E7D
+#define GL_TEXTURE_COMPRESSED_BLOCK_SIZE 0x82B3
+#define GL_COLOR_ATTACHMENT1 0x8CE1
+#define GL_FEEDBACK_BUFFER_SIZE 0x0DF1
+#define GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9103
+#define GL_RGB9_E5 0x8C3D
+#define GL_MAX_ELEMENT_INDEX 0x8D6B
+#define GL_CONTEXT_FLAG_NO_ERROR_BIT 0x00000008
+#define GL_SAMPLER_1D_ARRAY_SHADOW 0x8DC3
+#define GL_MAP2_INDEX 0x0DB1
+#define GL_TEXTURE5 0x84C5
+#define GL_MAX_DEBUG_LOGGED_MESSAGES 0x9144
+#define GL_INTERNALFORMAT_STENCIL_SIZE 0x8276
+#define GL_BUFFER_UPDATE_BARRIER_BIT 0x00000200
+#define GL_CLIENT_ALL_ATTRIB_BITS 0xFFFFFFFF
+#define GL_ONE 1
+#define GL_LINE_WIDTH 0x0B21
+#define GL_DRAW_INDIRECT_BUFFER 0x8F3F
+#define GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS
+#define GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS 0x90CB
+#define GL_VERTEX_ARRAY_BUFFER_BINDING 0x8896
+#define GL_DOUBLE_MAT2x4 0x8F4A
+#define GL_LINES_ADJACENCY 0x000A
+#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87
+#define GL_ATOMIC_COUNTER_BUFFER_BINDING 0x92C1
+#define GL_PACK_SWAP_BYTES 0x0D00
+#define GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS 0x92CF
+#define GL_NORMAL_ARRAY_POINTER 0x808F
+#define GL_IMAGE_CLASS_11_11_10 0x82C2
+#define GL_MULT 0x0103
+#define GL_R16I 0x8233
+#define GL_ALPHA 0x1906
+#define GL_FUNC_REVERSE_SUBTRACT 0x800B
+#define GL_3D_COLOR 0x0602
+#define GL_PROJECTION 0x1701
+#define GL_TRANSFORM_FEEDBACK_VARYING 0x92F4
+#define GL_NAME_LENGTH 0x92F9
+#define GL_TEXTURE_DEPTH_TYPE 0x8C16
+#define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B
+#define GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH 0x8243
+#define GL_TEXTURE_IMAGE_TYPE 0x8290
+#define GL_FUNC_ADD 0x8006
+#define GL_STENCIL_INDEX1 0x8D46
+#define GL_SHADER_BINARY_FORMATS 0x8DF8
+#define GL_RGB16I 0x8D89
+#define GL_AUTO_NORMAL 0x0D80
+#define GL_SYNC_FENCE 0x9116
+#define GL_COLOR_ENCODING 0x8296
+#define GL_GREEN_SCALE 0x0D18
+#define GL_GEOMETRY_SHADER_INVOCATIONS 0x887F
+#define GL_TEXTURE7 0x84C7
+#define GL_ELEMENT_ARRAY_BARRIER_BIT 0x00000002
+#define GL_DEBUG_SOURCE_OTHER 0x824B
+#define GL_GEOMETRY_SHADER 0x8DD9
+#define GL_OR_REVERSE 0x150B
+#define GL_MAP1_VERTEX_3 0x0D97
+#define GL_MAX_NUM_COMPATIBLE_SUBROUTINES 0x92F8
+#define GL_TEXTURE_SAMPLES 0x9106
+#define GL_MAX_CLIP_PLANES 0x0D32
+#define GL_COLOR_ATTACHMENT15 0x8CEF
+#define GL_PIXEL_MAP_R_TO_R 0x0C76
+#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895
+#define GL_SRC2_RGB GL_SOURCE2_RGB
+#define GL_PIXEL_MAP_S_TO_S 0x0C71
+#define GL_SAMPLER_BINDING 0x8919
+#define GL_MAX_GEOMETRY_IMAGE_UNIFORMS 0x90CD
+#define GL_PRIMITIVE_RESTART 0x8F9D
+#define GL_MAX_IMAGE_UNITS 0x8F38
+#define GL_LIGHT0 0x4000
+#define GL_BGRA 0x80E1
+#define GL_FOG_INDEX 0x0B61
+#define GL_VERTEX_SUBROUTINE 0x92E8
+#define GL_SELECT 0x1C02
+#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020
+#define GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT 0x00000004
+#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x00000001
+#define GL_POINT_SPRITE_ARB 0x8861
+#define GL_SPOT_DIRECTION 0x1204
+#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506
+#define GL_CLIP_PLANE0 0x3000
+#define GL_FULL_SUPPORT 0x82B7
+#define GL_OPERAND0_RGB 0x8590
+#define GL_RENDERBUFFER_GREEN_SIZE 0x8D51
+#define GL_MAX_FRAGMENT_INPUT_COMPONENTS 0x9125
+#define GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 0x9276
+#define GL_VIEW_CLASS_64_BITS 0x82C6
+#define GL_VIEW_CLASS_16_BITS 0x82CA
+#define GL_BLEND_EQUATION 0x8009
+#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C
+#define GL_OPERAND2_RGB 0x8592
+#define GL_MAJOR_VERSION 0x821B
+#define GL_FRAMEBUFFER_BARRIER_BIT 0x00000400
+#define GL_COMPRESSED_RED_RGTC1 0x8DBB
+#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210
+#define GL_IMPLEMENTATION_COLOR_READ_TYPE 0x8B9A
+#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514
+#define GL_MIRRORED_REPEAT 0x8370
+#define GL_BUFFER_MAP_LENGTH 0x9120
+#define GL_BLEND_SRC 0x0BE1
+#define GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS 0x8E83
+#define GL_MAX_HEIGHT 0x827F
+#define GL_FRAGMENT_INTERPOLATION_OFFSET_BITS 0x8E5D
+#define GL_BUFFER_DATA_SIZE 0x9303
+#define GL_BLUE_INTEGER 0x8D96
+#define GL_TRIANGLES 0x0004
+#define GL_UNKNOWN_CONTEXT_RESET 0x8255
+#define GL_IMAGE_BUFFER 0x9051
+#define GL_FILTER 0x829A
+#define GL_RGBA12 0x805A
+#define GL_BLEND 0x0BE2
+#define GL_RGB8UI 0x8D7D
+#define GL_MAX_VARYING_VECTORS 0x8DFC
+#define GL_COLOR_ATTACHMENT3 0x8CE3
+#define GL_WEIGHT_ARRAY_BUFFER_BINDING 0x889E
+#define GL_FLOAT_VEC4 0x8B52
+#define GL_FRAMEBUFFER_DEFAULT_WIDTH 0x9310
+#define GL_SAMPLER_1D 0x8B5D
+#define GL_MAP1_COLOR_4 0x0D90
+#define GL_TEXTURE_BIT 0x00040000
+#define GL_MAX_NUM_ACTIVE_VARIABLES 0x92F7
+#define GL_SRC2_ALPHA GL_SOURCE2_ALPHA
+#define GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED 0x8E23
+#define GL_PIXEL_MAP_A_TO_A_SIZE 0x0CB9
+#define GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS 0x8E1E
+#define GL_STENCIL_BACK_FUNC 0x8800
+#define GL_INFO_LOG_LENGTH 0x8B84
+#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A
+#define GL_SPOT_EXPONENT 0x1205
+#define GL_REFERENCED_BY_TESS_CONTROL_SHADER 0x9307
+#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31
+#define GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS 0x92D1
+#define GL_LINE_WIDTH_RANGE 0x0B22
+#define GL_PROGRAM_BINARY_FORMATS 0x87FF
+#define GL_UNPACK_SKIP_PIXELS 0x0CF4
+#define GL_MAP_COHERENT_BIT 0x0080
+#define GL_IMAGE_BINDING_LAYER 0x8F3D
+#define GL_FRAMEBUFFER_BLEND 0x828B
+#define GL_RGB10 0x8052
+#define GL_POLYGON_OFFSET_LINE 0x2A02
+#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366
+#define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83
+#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80
+#define GL_R16_SNORM 0x8F98
+#define GL_FRAGMENT_SHADER 0x8B30
+#define GL_PIXEL_BUFFER_BARRIER_BIT 0x00000080
+#define GL_EDGE_FLAG 0x0B43
+#define GL_TEXTURE_GATHER_SHADOW 0x82A3
+#define GL_INT_IMAGE_BUFFER 0x905C
+#define GL_LOCATION 0x930E
+#define GL_SYNC_STATUS 0x9114
+#define GL_MODELVIEW_STACK_DEPTH 0x0BA3
+#define GL_PROGRAM_INPUT 0x92E3
+#define GL_STENCIL_RENDERABLE 0x8288
+#define GL_MAP_STENCIL 0x0D11
+#define GL_LIGHT7 0x4007
+#define GL_LAST_VERTEX_CONVENTION 0x8E4E
+#define GL_TEXTURE13 0x84CD
+#define GL_MAX_SAMPLE_MASK_WORDS 0x8E59
+#define GL_ACCUM 0x0100
+#define GL_INT_2_10_10_10_REV 0x8D9F
+#define GL_TESS_EVALUATION_SUBROUTINE 0x92EA
+#define GL_2_BYTES 0x1407
+#define GL_REFLECTION_MAP 0x8512
+#define GL_GREEN 0x1904
+#define GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT 0x8E8E
+#define GL_RGB4 0x804F
+#define GL_SLUMINANCE8 0x8C47
+#define GL_TRIANGLE_STRIP 0x0005
+#define GL_INTERNALFORMAT_SUPPORTED 0x826F
+#define GL_TIME_ELAPSED 0x88BF
+#define GL_SEPARATE_ATTRIBS 0x8C8D
+#define GL_COLOR_INDEX 0x1900
+#define GL_COLOR_ARRAY_POINTER 0x8090
+#define GL_COMPRESSED_R11_EAC 0x9270
+#define GL_CLAMP_READ_COLOR 0x891C
+#define GL_COPY_PIXEL_TOKEN 0x0706
+#define GL_PATCH_DEFAULT_OUTER_LEVEL 0x8E74
+#define GL_DEPTH 0x1801
+#define GL_SLUMINANCE8_ALPHA8 0x8C45
+#define GL_FOG_START 0x0B63
+#define GL_FRAMEBUFFER_SRGB 0x8DB9
+#define GL_STENCIL_FAIL 0x0B94
+#define GL_LUMINANCE8_ALPHA8 0x8045
+#define GL_COLOR_ATTACHMENT14 0x8CEE
+#define GL_INTENSITY8 0x804B
+#define GL_NAND 0x150E
+#define GL_PIXEL_MAP_I_TO_G_SIZE 0x0CB3
+#define GL_MIN 0x8007
+#define GL_SYNC_CONDITION 0x9113
+#define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING 0x889C
+#define GL_SAMPLER_BUFFER 0x8DC2
+#define GL_PACK_ALIGNMENT 0x0D05
+#define GL_DEPTH_SCALE 0x0D1E
+#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS 0x8DDF
+#define GL_PROGRAM_BINARY_RETRIEVABLE_HINT 0x8257
+#define GL_RG8_SNORM 0x8F95
+#define GL_MAX_COMPUTE_WORK_GROUP_COUNT 0x91BE
+#define GL_BOOL 0x8B56
+#define GL_DST_COLOR 0x0306
+#define GL_INT_SAMPLER_1D 0x8DC9
+#define GL_BLEND_DST 0x0BE0
+#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33
+#define GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE 0x82AE
+#define GL_COLOR_ARRAY_BUFFER_BINDING 0x8898
+#define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001
+#define GL_LUMINANCE6_ALPHA2 0x8044
+#define GL_DOUBLE_MAT4x2 0x8F4D
+#define GL_STENCIL_ATTACHMENT 0x8D20
+#define GL_ACTIVE_VARIABLES 0x9305
+#define GL_TEXTURE26 0x84DA
+#define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54
+#define GL_DEBUG_LOGGED_MESSAGES 0x9145
+#define GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES 0x82FA
+#define GL_FIXED_ONLY 0x891D
+#define GL_MAP1_TEXTURE_COORD_3 0x0D95
+#define GL_COMPRESSED_RGBA 0x84EE
+#define GL_DEBUG_TYPE_MARKER 0x8268
+#define GL_SHADER_STORAGE_BLOCK 0x92E6
+#define GL_BLEND_COLOR 0x8005
+#define GL_TEXTURE_WRAP_S 0x2802
+#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645
+#define GL_LIGHTING 0x0B50
+#define GL_COMPATIBLE_SUBROUTINES 0x8E4B
+#define GL_VIEW_CLASS_S3TC_DXT1_RGB 0x82CC
+#define GL_TOP_LEVEL_ARRAY_STRIDE 0x930D
+#define GL_MAX_TESS_CONTROL_INPUT_COMPONENTS 0x886C
+#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D
+#define GL_PACK_COMPRESSED_BLOCK_SIZE 0x912E
+#define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2
+#define GL_GET_TEXTURE_IMAGE_TYPE 0x8292
+#define GL_COMPRESSED_LUMINANCE_ALPHA 0x84EB
+#define GL_MAX_COMPUTE_IMAGE_UNIFORMS 0x91BD
+#define GL_ACTIVE_RESOURCES 0x92F5
+#define GL_QUERY_NO_WAIT_INVERTED 0x8E18
+#define GL_EDGE_FLAG_ARRAY_STRIDE 0x808C
+#define GL_TEXTURE_RESIDENT 0x8067
+#define GL_CLIP_DISTANCE5 GL_CLIP_PLANE5
+#define GL_SHADER_STORAGE_BUFFER_SIZE 0x90D5
+#define GL_MAX_WIDTH 0x827E
+#define GL_LIST_MODE 0x0B30
+#define GL_PACK_IMAGE_HEIGHT 0x806C
+#define GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS 0x90DA
+#define GL_BUFFER_BINDING 0x9302
+#define GL_LINE_SMOOTH_HINT 0x0C52
+#define GL_TEXTURE3 0x84C3
+#define GL_FLAT 0x1D00
+#define GL_COPY_READ_BUFFER 0x8F36
+#define GL_MAX_VARYING_FLOATS 0x8B4B
+#define GL_EYE_PLANE 0x2502
+#define GL_CLIENT_PIXEL_STORE_BIT 0x00000001
+#define GL_NORMAL_ARRAY_BUFFER_BINDING 0x8897
+#define GL_TEXTURE_ENV_MODE 0x2200
+#define GL_VIEW_CLASS_BPTC_UNORM 0x82D2
+#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622
+#define GL_PROXY_TEXTURE_3D 0x8070
+#define GL_QUERY_BY_REGION_NO_WAIT_INVERTED 0x8E1A
+#define GL_TEXTURE_BINDING_BUFFER 0x8C2C
+#define GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT 0x919F
+#define GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR 0x824E
+#define GL_UNPACK_SWAP_BYTES 0x0CF0
+#define GL_R32F 0x822E
+#define GL_DRAW_BUFFER8 0x882D
+#define GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS 0x90D7
+#define GL_LOCATION_COMPONENT 0x934A
+#define GL_T4F_V4F 0x2A28
+#define GL_DEPTH_BUFFER_BIT 0x00000100
+#define GL_GEOMETRY_SUBROUTINE_UNIFORM 0x92F1
+#define GL_REPEAT 0x2901
+#define GL_MAX_COMPUTE_ATOMIC_COUNTERS 0x8265
+#define GL_MULTISAMPLE_BIT 0x20000000
+#define GL_ATOMIC_COUNTER_BARRIER_BIT 0x00001000
+#define GL_SRC_COLOR 0x0300
+#define GL_INT_IMAGE_1D 0x9057
+#define GL_INTERNALFORMAT_BLUE_TYPE 0x827A
+#define GL_IMAGE_3D 0x904E
+#define GL_ONE_MINUS_DST_COLOR 0x0307
+#define GL_FALSE 0
+#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A
+#define GL_MAP2_TEXTURE_COORD_2 0x0DB4
+#define GL_HINT_BIT 0x00008000
+#define GL_BLUE_BIAS 0x0D1B
+#define GL_RG16UI 0x823A
+#define GL_UNSIGNED_INT_SAMPLER_2D_RECT 0x8DD5
+#define GL_KEEP 0x1E00
+#define GL_TESS_EVALUATION_SHADER 0x8E87
+#define GL_STENCIL_TEST 0x0B90
+#define GL_TEXTURE6 0x84C6
+#define GL_DEPTH_COMPONENT24 0x81A6
+#define GL_VIEWPORT_BOUNDS_RANGE 0x825D
+#define GL_MAX_UNIFORM_LOCATIONS 0x826E
+#define GL_RGBA 0x1908
+#define GL_DYNAMIC_COPY 0x88EA
+#define GL_PACK_SKIP_ROWS 0x0D03
+#define GL_LIST_INDEX 0x0B33
+#define GL_IMAGE_BINDING_NAME 0x8F3A
+#define GL_TEXTURE_IMMUTABLE_FORMAT 0x912F
+#define GL_RED_INTEGER 0x8D94
+#define GL_OPERAND2_ALPHA 0x859A
+#define GL_INVALID_INDEX 0xFFFFFFFF
+#define GL_VERTEX_SHADER_INVOCATIONS 0x82F0
+#define GL_TEXTURE_GEN_T 0x0C61
+#define GL_TEXTURE_GEN_Q 0x0C63
+#define GL_CURRENT_RASTER_COLOR 0x0B04
+#define GL_RGBA4 0x8056
+#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER 0x92C8
+#define GL_DECAL 0x2101
+#define GL_TEXTURE_SWIZZLE_R 0x8E42
+#define GL_RED_SCALE 0x0D14
+#define GL_CLIENT_ATTRIB_STACK_DEPTH 0x0BB1
+#define GL_UNPACK_COMPRESSED_BLOCK_HEIGHT 0x9128
+#define GL_MAX_DEBUG_MESSAGE_LENGTH 0x9143
+#define GL_PATCH_VERTICES 0x8E72
+#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872
+#define GL_TEXTURE_SWIZZLE_G 0x8E43
+#define GL_PROGRAM_POINT_SIZE GL_VERTEX_PROGRAM_POINT_SIZE
+#define GL_COMPRESSED_RGB8_ETC2 0x9274
+#define GL_DYNAMIC_READ 0x88E9
+#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D
+#define GL_POLYGON_STIPPLE 0x0B42
+#define GL_ADD 0x0104
+#define GL_COLOR_ATTACHMENT25 0x8CF9
+#define GL_TEXTURE_ENV_COLOR 0x2201
+#define GL_DEPTH_ATTACHMENT 0x8D00
+#define GL_POINT_SIZE_GRANULARITY 0x0B13
+#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER 0x90ED
+#define GL_SRGB8 0x8C41
+#define GL_LINE_STRIP_ADJACENCY 0x000B
+#define GL_FOG_COORD_ARRAY_POINTER GL_FOG_COORDINATE_ARRAY_POINTER
+#define GL_CLIP_DISTANCE0 GL_CLIP_PLANE0
+#define GL_MAX_TEXTURE_COORDS 0x8871
+#define GL_COLOR_ARRAY_SIZE 0x8081
+#define GL_RG8 0x822B
+#define GL_SRC0_ALPHA GL_SOURCE0_ALPHA
+#define GL_TESS_GEN_MODE 0x8E76
+#define GL_COLOR_ATTACHMENT29 0x8CFD
+#define GL_HIGH_FLOAT 0x8DF2
+#define GL_GREEN_BITS 0x0D53
+#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C
+#define GL_MIN_FRAGMENT_INTERPOLATION_OFFSET 0x8E5B
+#define GL_DRAW_BUFFER 0x0C01
+#define GL_QUERY_BY_REGION_NO_WAIT 0x8E16
+#define GL_ACTIVE_UNIFORMS 0x8B86
+#define GL_LINEAR_ATTENUATION 0x1208
+#define GL_COPY_WRITE_BUFFER 0x8F37
+#define GL_BITMAP_TOKEN 0x0704
+#define GL_PACK_COMPRESSED_BLOCK_DEPTH 0x912D
+#define GL_IMAGE_2D_ARRAY 0x9053
+#define GL_FOG_COORD_SRC GL_FOG_COORDINATE_SOURCE
+#define GL_VIEWPORT 0x0BA2
+#define GL_VENDOR 0x1F00
+#define GL_LIGHT1 0x4001
+#define GL_CLEAR_BUFFER 0x82B4
+#define GL_R8 0x8229
+#define GL_RENDER 0x1C00
+#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS 0x8C29
+#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A
+#define GL_SAMPLER_2D_RECT 0x8B63
+#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC
+#define GL_RGBA16UI 0x8D76
+#define GL_VERTEX_ARRAY_TYPE 0x807B
+#define GL_QUAD_STRIP 0x0008
+#define GL_TEXTURE_MAX_ANISOTROPY 0x84FE
+#define GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS 0x92D3
+#define GL_MAX_TEXTURE_MAX_ANISOTROPY 0x84FF
+#define GL_TRANSFORM_FEEDBACK_ACTIVE GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE
+#define GL_CURRENT_FOG_COORD GL_CURRENT_FOG_COORDINATE
+#define GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS 0x90D8
+#define GL_VERTEX_SUBROUTINE_UNIFORM 0x92EE
+#define GL_LINE 0x1B01
+#define GL_LINK_STATUS 0x8B82
+#define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFF
+#define GL_ACTIVE_SUBROUTINES 0x8DE5
+#define GL_INT 0x1404
+#define GL_LUMINANCE12_ALPHA12 0x8047
+#define GL_MAX_PIXEL_MAP_TABLE 0x0D34
+#define GL_EYE_LINEAR 0x2400
+#define GL_COLOR_ATTACHMENT13 0x8CED
+#define GL_POLYGON_OFFSET_UNITS 0x2A00
+#define GL_TEXTURE_COMPRESSED_BLOCK_WIDTH 0x82B1
+#define GL_VERTEX_ARRAY_STRIDE 0x807C
+#define GL_TEXTURE_COORD_ARRAY_SIZE 0x8088
+#define GL_COLOR_ATTACHMENT11 0x8CEB
+#define GL_OR_INVERTED 0x150D
+#define GL_ACCUM_ALPHA_BITS 0x0D5B
+#define GL_FOG_COLOR 0x0B66
+#define GL_VIEW_CLASS_S3TC_DXT3_RGBA 0x82CE
+#define GL_DEBUG_TYPE_OTHER 0x8251
+#define GL_LINES 0x0001
+#define GL_READ_PIXELS_TYPE 0x828E
+#define GL_PROGRAM_OUTPUT 0x92E4
+#define GL_DEPTH_RANGE 0x0B70
+#define GL_INTERPOLATE 0x8575
+#define GL_DOT3_RGBA 0x86AF
+#define GL_IMAGE_BINDING_ACCESS 0x8F3E
+#define GL_BGR_INTEGER 0x8D9A
+#define GL_GREEN_BIAS 0x0D19
+#define GL_BLEND_DST_ALPHA 0x80CA
+#define GL_CURRENT_VERTEX_ATTRIB 0x8626
+#define GL_RG_INTEGER 0x8228
+#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365
+#define GL_ATOMIC_COUNTER_BUFFER_START 0x92C2
+#define GL_CLAMP_FRAGMENT_COLOR 0x891B
+#define GL_COMPRESSED_SLUMINANCE_ALPHA 0x8C4B
+#define GL_GEQUAL 0x0206
+#define GL_DEPTH_CLAMP 0x864F
+#define GL_STATIC_COPY 0x88E6
+#define GL_TEXTURE_STACK_DEPTH 0x0BA5
+#define GL_COLOR_ATTACHMENT8 0x8CE8
+#define GL_RGB16F 0x881B
+#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35
+#define GL_MAX_COLOR_ATTACHMENTS 0x8CDF
+#define GL_DEBUG_SEVERITY_MEDIUM 0x9147
+#define GL_3D 0x0601
+#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A
+#define GL_SOURCE0_ALPHA 0x8588
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44
+#define GL_ALIASED_POINT_SIZE_RANGE 0x846D
+#define GL_TEXTURE_LUMINANCE_TYPE 0x8C14
+#define GL_R16UI 0x8234
+#define GL_SAMPLER_1D_SHADOW 0x8B61
+#define GL_CLIPPING_INPUT_PRIMITIVES 0x82F6
+#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033
+#define GL_TEXTURE_VIEW 0x82B5
+#define GL_DST_ALPHA 0x0304
+#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364
+#define GL_DEBUG_GROUP_STACK_DEPTH 0x826D
+#define GL_LUMINANCE8 0x8040
+#define GL_UNSIGNED_BYTE 0x1401
+#define GL_N3F_V3F 0x2A25
+#define GL_ACCUM_CLEAR_VALUE 0x0B80
+#define GL_SHADER_IMAGE_ATOMIC 0x82A6
+#define GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS 0x8DE8
+#define GL_POINTS 0x0000
+#define GL_CLIP_DISTANCE3 GL_CLIP_PLANE3
+#define GL_ALPHA_SCALE 0x0D1C
+#define GL_RGBA8_SNORM 0x8F97
+#define GL_MAP_COLOR 0x0D10
+#define GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS 0x8266
+#define GL_VIEW_CLASS_RGTC1_RED 0x82D0
+#define GL_DOUBLE_VEC2 0x8FFC
+#define GL_MAX_TESS_GEN_LEVEL 0x8E7E
+#define GL_RGB32F 0x8815
+#define GL_FOG_COORDINATE_ARRAY_TYPE 0x8454
+#define GL_BUFFER_MAP_POINTER 0x88BD
+#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001
+#define GL_PIXEL_MAP_I_TO_A 0x0C75
+#define GL_MAX_ELEMENTS_VERTICES 0x80E8
+#define GL_MAX_LIST_NESTING 0x0B31
+#define GL_IMAGE_CLASS_1_X_32 0x82BB
+#define GL_POLYGON_SMOOTH_HINT 0x0C53
+#define GL_TEXTURE_MAG_FILTER 0x2800
+#define GL_DOUBLE 0x140A
+#define GL_PIXEL_MAP_B_TO_B 0x0C78
+#define GL_COMPRESSED_RG11_EAC 0x9272
+#define GL_ZOOM_X 0x0D16
+#define GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS 0x8E47
+#define GL_DRAW_BUFFER15 0x8834
+#define GL_PIXEL_MAP_I_TO_A_SIZE 0x0CB5
+#define GL_PIXEL_MAP_G_TO_G_SIZE 0x0CB7
+#define GL_BLUE_SCALE 0x0D1A
+#define GL_DELETE_STATUS 0x8B80
+#define GL_PROGRAM 0x82E2
+#define GL_QUERY_RESULT_NO_WAIT 0x9194
+#define GL_LINE_WIDTH_GRANULARITY 0x0B23
+#define GL_OPERAND1_ALPHA 0x8599
+#define GL_MAX_EVAL_ORDER 0x0D30
+#define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905
+#define GL_SHADER_IMAGE_STORE 0x82A5
+#define GL_PASS_THROUGH_TOKEN 0x0700
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER 0x84F0
+#define GL_MAX_FRAMEBUFFER_LAYERS 0x9317
+#define GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS 0x92CD
+#define GL_ACCUM_BUFFER_BIT 0x00000200
+#define GL_DEPTH_CLEAR_VALUE 0x0B73
+#define GL_IMAGE_2D_RECT 0x904F
+#define GL_TEXTURE12 0x84CC
+#define GL_RGBA16I 0x8D88
+#define GL_FRONT_FACE 0x0B46
+#define GL_AUX0 0x0409
+#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034
+#define GL_UNSIGNED_INT_IMAGE_2D_ARRAY 0x9069
+#define GL_UNSIGNED_INT_VEC2 0x8DC6
+#define GL_COMPRESSED_RGBA8_ETC2_EAC 0x9278
+#define GL_SAMPLER_3D 0x8B5F
+#define GL_C4F_N3F_V3F 0x2A26
+#define GL_FEEDBACK_BUFFER_TYPE 0x0DF2
+#define GL_CONTEXT_FLAG_DEBUG_BIT 0x00000002
+#define GL_CLIP_PLANE2 0x3002
+#define GL_RGBA8 0x8058
+#define GL_PIXEL_MAP_I_TO_B_SIZE 0x0CB4
+#define GL_RETURN 0x0102
+#define GL_MAX_SUBROUTINES 0x8DE7
+#define GL_COLOR_ATTACHMENT7 0x8CE7
+#define GL_AUTO_GENERATE_MIPMAP 0x8295
+#define GL_DEPTH_STENCIL_TEXTURE_MODE 0x90EA
+#define GL_MAX_COMBINED_ATOMIC_COUNTERS 0x92D7
+#define GL_MAP_PERSISTENT_BIT 0x0040
+#define GL_BACK_RIGHT 0x0403
+#define GL_COMPRESSED_SRGB_ALPHA 0x8C49
+#define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519
+#define GL_3D_COLOR_TEXTURE 0x0603
+#define GL_PIXEL_MAP_I_TO_I_SIZE 0x0CB0
+#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR 0x88FE
+#define GL_INT_IMAGE_2D_ARRAY 0x905E
+#define GL_POLYGON_MODE 0x0B40
+#define GL_MAX_RECTANGLE_TEXTURE_SIZE 0x84F8
+#define GL_CULL_FACE 0x0B44
+#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C
+#define GL_TEXTURE_RED_SIZE 0x805C
+#define GL_R8_SNORM 0x8F94
+#define GL_COMPRESSED_RED 0x8225
+#define GL_IMAGE_CUBE 0x9050
+#define GL_IMAGE_1D_ARRAY 0x9052
+#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER 0x92C9
+#define GL_NO_RESET_NOTIFICATION 0x8261
+#define GL_RG16F 0x822F
+#define GL_POINT_SIZE 0x0B11
+#define GL_SOURCE2_RGB 0x8582
+#define GL_BGRA_INTEGER 0x8D9B
+#define GL_FASTEST 0x1101
+#define GL_MAX_FRAMEBUFFER_WIDTH 0x9315
+#define GL_EDGE_FLAG_ARRAY_POINTER 0x8093
+#define GL_TYPE 0x92FA
+#define GL_TEXTURE10 0x84CA
+#define GL_TOP_LEVEL_ARRAY_SIZE 0x930C
+#define GL_PRIMITIVE_RESTART_INDEX 0x8F9E
+#define GL_DEPTH_TEXTURE_MODE 0x884B
+#define GL_WAIT_FAILED 0x911D
+#define GL_BLEND_SRC_ALPHA 0x80CB
+#define GL_DRAW_BUFFER14 0x8833
+#define GL_REFERENCED_BY_TESS_EVALUATION_SHADER 0x9308
+#define GL_IS_ROW_MAJOR 0x9300
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515
+#define GL_RENDERBUFFER_BLUE_SIZE 0x8D52
+#define GL_INDEX_ARRAY_BUFFER_BINDING 0x8899
+#define GL_MAP_READ_BIT 0x0001
+#define GL_VERTEX_ATTRIB_RELATIVE_OFFSET 0x82D5
+#define GL_INTERNALFORMAT_SHARED_SIZE 0x8277
+#define GL_UNIFORM_SIZE 0x8A38
+#define GL_MAP2_GRID_DOMAIN 0x0DD2
+#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER 0x92C7
+#define GL_MAX_TEXTURE_BUFFER_SIZE 0x8C2B
+#define GL_RGB32UI 0x8D71
+#define GL_VIEWPORT_INDEX_PROVOKING_VERTEX 0x825F
+#define GL_OUT_OF_MEMORY 0x0505
+#define GL_VERTEX_ATTRIB_ARRAY_LONG 0x874E
+#define GL_FOG_COORDINATE_ARRAY_STRIDE 0x8455
+#define GL_LINEAR_MIPMAP_NEAREST 0x2701
+#define GL_AUX2 0x040B
+#define GL_FOG_MODE 0x0B65
+#define GL_POSITION 0x1203
+#define GL_CLIP_DISTANCE4 GL_CLIP_PLANE4
+#define GL_SPIR_V_BINARY 0x9552
+#define GL_IMAGE_CLASS_1_X_16 0x82BE
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46
+#define GL_TEXTURE_2D 0x0DE1
+#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B
+#define GL_ALPHA16 0x803E
+#define GL_VIEW_CLASS_RGTC2_RG 0x82D1
+#define GL_TEXTURE_WIDTH 0x1000
+#define GL_PIXEL_MAP_A_TO_A 0x0C79
+#define GL_MATRIX_STRIDE 0x92FF
+#define GL_MAX_LAYERS 0x8281
+#define GL_TEXTURE15 0x84CF
+#define GL_TEXTURE_ALPHA_TYPE 0x8C13
+#define GL_VERTEX_ATTRIB_BINDING 0x82D4
+#define GL_TEXTURE28 0x84DC
+#define GL_QUERY_BUFFER 0x9192
+#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3
+#define GL_DEPTH_COMPONENT32 0x81A7
+#define GL_DEBUG_SEVERITY_NOTIFICATION 0x826B
+#define GL_CURRENT_NORMAL 0x0B02
+#define GL_RASTERIZER_DISCARD 0x8C89
+#define GL_TEXTURE19 0x84D3
+#define GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES 0x92C6
+#define GL_3_BYTES 0x1408
+#define GL_VERTEX_ARRAY_SIZE 0x807A
+#define GL_DITHER 0x0BD0
+#define GL_CONSTANT_ATTENUATION 0x1207
+#define GL_FRAMEBUFFER 0x8D40
+#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002
+#define GL_TEXTURE_TARGET 0x1006
+#define GL_STENCIL_BACK_WRITEMASK 0x8CA5
+#define GL_QUADS 0x0007
+#define GL_SHORT 0x1402
+#define GL_RG16_SNORM 0x8F99
+#define GL_SHADER_SOURCE_LENGTH 0x8B88
+#define GL_DEBUG_SOURCE_SHADER_COMPILER 0x8248
+#define GL_MAX_VERTEX_ATTRIB_STRIDE 0x82E5
+#define GL_TEXTURE_VIEW_MIN_LEVEL 0x82DB
+#define GL_EDGE_FLAG_ARRAY 0x8079
+#define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41
+#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS 0x8DE1
+#define GL_INTERNALFORMAT_RED_TYPE 0x8278
+#define GL_ALPHA_TEST_FUNC 0x0BC1
+#define GL_DRAW_BUFFER6 0x882B
+#define GL_VIEW_CLASS_24_BITS 0x82C9
+#define GL_T 0x2001
+#define GL_AND 0x1501
+#define GL_OBJECT_LINEAR 0x2401
+#define GL_SRGB8_ALPHA8 0x8C43
+#define GL_LINE_STIPPLE_PATTERN 0x0B25
+#define GL_INDEX_ARRAY 0x8077
+#define GL_DRAW_FRAMEBUFFER 0x8CA9
+#define GL_TEXTURE_2D_MULTISAMPLE 0x9100
+#define GL_READ_PIXELS 0x828C
+#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34
+#define GL_CLIP_PLANE3 0x3003
+#define GL_TRANSPOSE_PROJECTION_MATRIX 0x84E4
+#define GL_RGB_SCALE 0x8573
+#define GL_SECONDARY_COLOR_ARRAY_POINTER 0x845D
+#define GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET 0x8E5E
+#define GL_TEXTURE14 0x84CE
+#define GL_DOUBLE_VEC3 0x8FFD
+#define GL_ISOLINES 0x8E7A
+#define GL_CLAMP_TO_BORDER 0x812D
+#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B
+#define GL_COORD_REPLACE_ARB 0x8862
+#define GL_MAX_COLOR_TEXTURE_SAMPLES 0x910E
+#define GL_UNPACK_IMAGE_HEIGHT 0x806E
+#define GL_UNIFORM_NAME_LENGTH 0x8A39
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER 0x90EC
+#define GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS 0x91BC
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2
+#define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING 0x889B
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518
+#define GL_CONTEXT_FLAGS 0x821E
+#define GL_TEXTURE_SWIZZLE_A 0x8E45
+#define GL_R32I 0x8235
+#define GL_EXTENSIONS 0x1F03
+#define GL_LIGHT_MODEL_TWO_SIDE 0x0B52
+#define GL_RG32I 0x823B
+#define GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX 0x92DA
+#define GL_LINE_SMOOTH 0x0B20
+#define GL_VERTEX_BINDING_STRIDE 0x82D8
+#define GL_COMPUTE_SHADER_BIT 0x00000020
+#define GL_VIEW_CLASS_BPTC_FLOAT 0x82D3
+#define GL_TESS_CONTROL_SHADER 0x8E88
+#define GL_PIXEL_MAP_S_TO_S_SIZE 0x0CB1
+#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS 0x8DA8
+#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217
+#define GL_BLEND_SRC_RGB 0x80C9
+#define GL_TEXTURE_1D_ARRAY 0x8C18
+#define GL_INT_IMAGE_2D_MULTISAMPLE 0x9060
+#define GL_SECONDARY_COLOR_ARRAY 0x845E
+#define GL_SELECTION_BUFFER_SIZE 0x0DF4
+#define GL_VERTEX_PROGRAM_TWO_SIDE 0x8643
+#define GL_VERTEX_ARRAY 0x8074
+#define GL_POLYGON_SMOOTH 0x0B41
+#define GL_MAX_INTEGER_SAMPLES 0x9110
+#define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D
+#define GL_PIXEL_MAP_B_TO_B_SIZE 0x0CB8
+#define GL_ZERO_TO_ONE 0x935F
+#define GL_INDEX_BITS 0x0D51
+#define GL_SRC_ALPHA_SATURATE 0x0308
+#define GL_TRANSFORM_FEEDBACK_BINDING 0x8E25
+#define GL_TRIANGLE_FAN 0x0006
+#define GL_FRAGMENT_DEPTH 0x8452
+#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625
+#define GL_BUFFER_IMMUTABLE_STORAGE 0x821F
+#define GL_ALPHA_TEST_REF 0x0BC2
+#define GL_MAX_MODELVIEW_STACK_DEPTH 0x0D36
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER 0x84F1
+#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD
+#define GL_MAX_ATTRIB_STACK_DEPTH 0x0D35
+#define GL_COLOR_ATTACHMENT31 0x8CFF
+#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E
+#define GL_GENERATE_MIPMAP_HINT 0x8192
+#define GL_UNIFORM_BARRIER_BIT 0x00000004
+#define GL_RGB5 0x8050
+#define GL_EVAL_BIT 0x00010000
+#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008
+#define GL_SAMPLES_PASSED 0x8914
+#define GL_R8I 0x8231
+#define GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS 0x9314
+#define GL_LIST_BASE 0x0B32
+#define GL_TEXTURE_COMPARE_FUNC 0x884D
+#define GL_MAP1_GRID_SEGMENTS 0x0DD1
+#define GL_NORMAL_ARRAY_TYPE 0x807E
+#define GL_MAX_DEPTH 0x8280
+#define GL_TRANSFORM_FEEDBACK_PAUSED GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED
+#define GL_VERTEX_SHADER_BIT 0x00000001
+#define GL_OFFSET 0x92FC
+#define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3
+#define GL_TEXTURE 0x1702
+#define GL_TEXTURE_IMMUTABLE_LEVELS 0x82DF
+#define GL_COLOR_BUFFER_BIT 0x00004000
+#define GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS 0x8F39
+#define GL_AUX1 0x040A
+#define GL_STENCIL_BITS 0x0D57
+#define GL_REFERENCED_BY_COMPUTE_SHADER 0x930B
+#define GL_GEOMETRY_VERTICES_OUT 0x8916
+#define GL_UNIFORM_BUFFER 0x8A11
+#define GL_INT_IMAGE_1D_ARRAY 0x905D
+#define GL_ORDER 0x0A01
+#define GL_AMBIENT_AND_DIFFUSE 0x1602
+#define GL_FOG_COORD_ARRAY GL_FOG_COORDINATE_ARRAY
+#define GL_SMOOTH_LINE_WIDTH_RANGE GL_LINE_WIDTH_RANGE
+#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F
+#define GL_INDEX_ARRAY_STRIDE 0x8086
+#define GL_INT_IMAGE_CUBE 0x905B
+#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7
+#define GL_UNSIGNED_INT_IMAGE_3D 0x9064
+#define GL_STENCIL_BUFFER_BIT 0x00000400
+#define GL_SUBPIXEL_BITS 0x0D50
+#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004
+#define GL_UNDEFINED_VERTEX 0x8260
+#define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40
+#define GL_IMAGE_COMPATIBILITY_CLASS 0x82A8
+#define GL_SRGB_READ 0x8297
+#define GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH 0x82FC
+#define GL_SRC_ALPHA 0x0302
+#define GL_DEBUG_SOURCE_APPLICATION 0x824A
+#define GL_DRAW_PIXEL_TOKEN 0x0705
+#define GL_MIRROR_CLAMP_TO_EDGE 0x8743
+#define GL_FRAMEBUFFER_DEFAULT_LAYERS 0x9312
+#define GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS 0x92CE
+#define GL_BUFFER_STORAGE_FLAGS 0x8220
+#define GL_DEBUG_OUTPUT 0x92E0
+#define GL_LINE_TOKEN 0x0702
+#define GL_CURRENT_RASTER_DISTANCE 0x0B09
+#define GL_MAP2_COLOR_4 0x0DB0
+#define GL_SPECULAR 0x1202
+#define GL_DEBUG_SOURCE_WINDOW_SYSTEM 0x8247
+#define GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE 0x82AF
+#define GL_T4F_C4F_N3F_V4F 0x2A2D
+#define GL_TEXTURE_BINDING_2D 0x8069
+#define GL_TESS_CONTROL_SUBROUTINE 0x92E9
+#define GL_CLIP_PLANE1 0x3001
+#define GL_UNSIGNED_INT 0x1405
+#define GL_READ_FRAMEBUFFER 0x8CA8
+#define GL_INTERNALFORMAT_DEPTH_SIZE 0x8275
+#define GL_MAX_TEXTURE_SIZE 0x0D33
+#define GL_UNPACK_SKIP_ROWS 0x0CF3
+#define GL_BUFFER 0x82E0
+#define GL_TESS_CONTROL_OUTPUT_VERTICES 0x8E75
+#define GL_REFERENCED_BY_FRAGMENT_SHADER 0x930A
+#define GL_TRIANGLES_ADJACENCY 0x000C
+#define GL_VERTEX_BINDING_DIVISOR 0x82D6
+#define GL_MODELVIEW_MATRIX 0x0BA6
+#define GL_C4UB_V2F 0x2A22
+#define GL_FRAMEBUFFER_DEFAULT_SAMPLES 0x9313
+#define GL_RESCALE_NORMAL 0x803A
+#define GL_COMPILE 0x1300
+#define GL_DEBUG_SEVERITY_LOW 0x9148
+#define GL_NUM_EXTENSIONS 0x821D
+#define GL_TEXTURE22 0x84D6
+#define GL_PREVIOUS 0x8578
+#define GL_UNPACK_ROW_LENGTH 0x0CF2
+#define GL_QUERY_COUNTER_BITS 0x8864
+#define GL_LIGHT2 0x4002
+#define GL_MAX_SHADER_STORAGE_BLOCK_SIZE 0x90DE
+#define GL_RGB12 0x8053
+#define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING 0x889A
+#define GL_TEXTURE_2D_ARRAY 0x8C1A
+#define GL_CONSTANT_COLOR 0x8001
+#define GL_RED 0x1903
+#define GL_LOCATION_INDEX 0x930F
+#define GL_PROXY_TEXTURE_2D 0x8064
+#define GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE 0x92C4
+#define GL_RENDERBUFFER_WIDTH 0x8D42
+#define GL_READ_ONLY 0x88B8
+#define GL_READ_FRAMEBUFFER_BINDING 0x8CAA
+#define GL_MAX_VERTEX_ATOMIC_COUNTERS 0x92D2
+#define GL_VERTEX_SHADER 0x8B31
+#define GL_SHADER_BINARY_FORMAT_SPIR_V 0x9551
+#define GL_MAX_FRAMEBUFFER_HEIGHT 0x9316
+#define GL_RGBA32I 0x8D82
+#define GL_CONTEXT_RELEASE_BEHAVIOR 0x82FB
+#define GL_PERSPECTIVE_CORRECTION_HINT 0x0C50
+#define GL_MAX_VERTEX_ATTRIB_BINDINGS 0x82DA
+#define GL_LINEAR 0x2601
+#define GL_MAX_FRAGMENT_ATOMIC_COUNTERS 0x92D6
+#define GL_TEXTURE_MIN_LOD 0x813A
+#define GL_LOWER_LEFT 0x8CA1
+#define GL_POINT_SMOOTH_HINT 0x0C51
+#define GL_LUMINANCE12_ALPHA4 0x8046
+#define GL_COMPUTE_SHADER 0x91B9
+#define GL_MAP2_TEXTURE_COORD_4 0x0DB6
+#define GL_COPY_WRITE_BUFFER_BINDING GL_COPY_WRITE_BUFFER
+#define GL_INTERNALFORMAT_ALPHA_TYPE 0x827B
+#define GL_NEVER 0x0200
+#define GL_EMISSION 0x1600
+#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING 0x8C2D
+#define GL_SINGLE_COLOR 0x81F9
+#define GL_MAP1_TEXTURE_COORD_1 0x0D93
+#define GL_TEXTURE_HEIGHT 0x1001
+#define GL_TRANSFORM_FEEDBACK_OVERFLOW 0x82EC
+#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010
+#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368
+#define GL_COLOR_ATTACHMENT27 0x8CFB
+#define GL_TIMEOUT_EXPIRED 0x911B
+#define GL_TESS_EVALUATION_SHADER_INVOCATIONS 0x82F2
+#define GL_UNIFORM_OFFSET 0x8A3B
+#define GL_ATTRIB_STACK_DEPTH 0x0BB0
+#define GL_SHININESS 0x1601
+#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42
+#define GL_COMPRESSED_SIGNED_RG11_EAC 0x9273
+#define GL_ATOMIC_COUNTER_BUFFER_SIZE 0x92C3
+#define GL_PIXEL_MAP_R_TO_R_SIZE 0x0CB6
+#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85
+#define GL_CONTEXT_LOST 0x0507
+#define GL_STENCIL_VALUE_MASK 0x0B93
+#define GL_LINE_LOOP 0x0002
+#define GL_BLEND_EQUATION_ALPHA 0x883D
+#define GL_DOUBLE_MAT4 0x8F48
+#define GL_MAP1_TEXTURE_COORD_2 0x0D94
+#define GL_DYNAMIC_DRAW 0x88E8
+#define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E
+#define GL_VALIDATE_STATUS 0x8B83
+#define GL_QUERY_RESULT_AVAILABLE 0x8867
+#define GL_IMAGE_1D 0x904C
+#define GL_UNSIGNED_INT_IMAGE_CUBE 0x9066
+#define GL_TEXTURE_LOD_BIAS 0x8501
+#define GL_PROGRAM_BINARY_LENGTH 0x8741
+#define GL_INCR_WRAP 0x8507
+#define GL_NEAREST 0x2600
+#define GL_NUM_SHADER_BINARY_FORMATS 0x8DF9
+#define GL_MAX_VIEWPORTS 0x825B
+#define GL_SRGB_ALPHA 0x8C42
+#define GL_TEXTURE_STENCIL_SIZE 0x88F1
+#define GL_COLOR_CLEAR_VALUE 0x0C22
+#define GL_TEXTURE_BUFFER_SIZE 0x919E
+#define GL_LINE_STIPPLE_REPEAT 0x0B26
+#define GL_NORMAL_ARRAY_STRIDE 0x807F
+#define GL_NEAREST_MIPMAP_NEAREST 0x2700
+#define GL_RGBA8UI 0x8D7C
+#define GL_VIEW_CLASS_S3TC_DXT5_RGBA 0x82CF
+#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96
+#define GL_MIPMAP 0x8293
+#define GL_DECR 0x1E03
+#define GL_MAX_TEXTURE_STACK_DEPTH 0x0D39
+#define GL_TEXTURE_RECTANGLE 0x84F5
+#define GL_ALL_SHADER_BITS 0xFFFFFFFF
+#define GL_SMOOTH_POINT_SIZE_GRANULARITY GL_POINT_SIZE_GRANULARITY
+#define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING 0x889D
+#define GL_POINT_SMOOTH 0x0B10
+#define GL_UNPACK_COMPRESSED_BLOCK_DEPTH 0x9129
+#define GL_SAMPLE_COVERAGE_VALUE 0x80AA
+#define GL_COPY 0x1503
+#define GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS 0x90DB
+#define GL_RIGHT 0x0407
+#define GL_COMPUTE_TEXTURE 0x82A0
+#define GL_TEXTURE_MAX_LEVEL 0x813D
+#define GL_RGB8 0x8051
+#define GL_UNSIGNED_INT_VEC3 0x8DC7
+#define GL_SRC1_COLOR 0x88F9
+#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642
+#define GL_STENCIL_BACK_REF 0x8CA3
+#define GL_TEXTURE0 0x84C0
+#define GL_TEXTURE_MAX_LOD 0x813B
+#define GL_SRC1_ALPHA GL_SOURCE1_ALPHA
+#define GL_LINE_STRIP 0x0003
+#define GL_RGBA32UI 0x8D70
+#define GL_SHADE_MODEL 0x0B54
+#define GL_FLOAT_MAT4x3 0x8B6A
+#define GL_DRAW_BUFFER10 0x882F
+#define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E
+#define GL_IMAGE_2D_MULTISAMPLE 0x9055
+#define GL_NUM_SHADING_LANGUAGE_VERSIONS 0x82E9
+#define GL_CLIP_DISTANCE1 GL_CLIP_PLANE1
+#define GL_GEOMETRY_OUTPUT_TYPE 0x8918
+#define GL_TEXTURE_RED_TYPE 0x8C10
+#define GL_PIXEL_MAP_I_TO_R 0x0C72
+#define GL_FOG_DENSITY 0x0B62
+#define GL_CLIENT_STORAGE_BIT 0x0200
+#define GL_POLYGON_OFFSET_FACTOR 0x8038
+#define GL_INDEX 0x8222
+#define GL_SRGB_WRITE 0x8298
+#define GL_DEBUG_CALLBACK_USER_PARAM 0x8245
+#define GL_ENABLE_BIT 0x00002000
+#define GL_COMPUTE_SUBROUTINE 0x92ED
+#define GL_TESS_CONTROL_SHADER_PATCHES 0x82F1
+#define GL_TEXTURE_BINDING_1D_ARRAY 0x8C1C
+#define GL_FOG_COORDINATE_ARRAY 0x8457
+#define GL_COLOR_ATTACHMENT9 0x8CE9
+#define GL_FLOAT_MAT3x4 0x8B68
+#define GL_STREAM_DRAW 0x88E0
+#define GL_UNSIGNED_NORMALIZED 0x8C17
+#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7
+#define GL_DISPATCH_INDIRECT_BUFFER_BINDING 0x90EF
+#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32
+#define GL_CLIP_PLANE4 0x3004
+#define GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS 0x90D6
+#define GL_INTENSITY 0x8049
+#define GL_INTENSITY12 0x804C
+#define GL_ALL_ATTRIB_BITS 0xFFFFFFFF
+#define GL_SRC1_RGB GL_SOURCE1_RGB
+#define GL_UNSIGNALED 0x9118
+#define GL_COLOR_ATTACHMENT10 0x8CEA
+#define GL_STENCIL_INDEX8 0x8D48
+#define GL_CLIP_PLANE5 0x3005
+#define GL_MAX_DRAW_BUFFERS 0x8824
+#define GL_RGBA_INTEGER 0x8D99
+#define GL_COLOR 0x1800
+#define GL_DOUBLE_MAT3 0x8F47
+#define GL_ALREADY_SIGNALED 0x911A
+#define GL_ARRAY_STRIDE 0x92FE
+#define GL_TEXTURE_MIN_FILTER 0x2801
+#define GL_INTERNALFORMAT_STENCIL_TYPE 0x827D
+#define GL_ARRAY_SIZE 0x92FB
+#define GL_CLAMP_TO_EDGE 0x812F
+#define GL_VIEW_CLASS_S3TC_DXT1_RGBA 0x82CD
+#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1
+#define GL_IMAGE_2D 0x904D
+#define GL_CAVEAT_SUPPORT 0x82B8
+#define GL_SHADER_STORAGE_BARRIER_BIT 0x00002000
+#define GL_ONE_MINUS_SRC1_ALPHA 0x88FB
+#define GL_TEXTURE_BUFFER_BINDING 0x8C2A
+#define GL_VERTEX_ARRAY_BINDING 0x85B5
+#define GL_INCR 0x1E02
+#define GL_TEXTURE_COORD_ARRAY 0x8078
+#define GL_SAMPLER_CUBE_SHADOW 0x8DC5
+#define GL_TEXTURE_FETCH_BARRIER_BIT 0x00000008
+#define GL_COLOR_ATTACHMENT5 0x8CE5
+#define GL_MAX_COMPUTE_WORK_GROUP_SIZE 0x91BF
+#define GL_COLOR_ATTACHMENT24 0x8CF8
+#define GL_FRACTIONAL_EVEN 0x8E7C
+#define GL_STENCIL_CLEAR_VALUE 0x0B91
+#define GL_DRAW_BUFFER4 0x8829
+#define GL_RGBA16_SNORM 0x8F9B
+#define GL_TEXTURE_ENV 0x2300
+#define GL_POINT 0x1B00
+#define GL_DOUBLE_MAT3x4 0x8F4C
+#define GL_CURRENT_TEXTURE_COORDS 0x0B03
+#define GL_MAX_GEOMETRY_ATOMIC_COUNTERS 0x92D5
+#define GL_V2F 0x2A20
+#define GL_RG8UI 0x8238
+#define GL_MAP2_TEXTURE_COORD_1 0x0DB3
+#define GL_SECONDARY_COLOR_ARRAY_SIZE 0x845A
+#define GL_PROJECTION_STACK_DEPTH 0x0BA4
+#define GL_SAMPLER 0x82E6
+#define GL_GEOMETRY_INPUT_TYPE 0x8917
+#define GL_LIGHT_MODEL_LOCAL_VIEWER 0x0B51
+#define GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY 0x900F
+#define GL_NORMAL_MAP 0x8511
+#define GL_RGB16 0x8054
+#define GL_UNSIGNED_INT_IMAGE_1D_ARRAY 0x9068
+#define GL_DEPTH_COMPONENT 0x1902
+#define GL_DEBUG_OUTPUT_SYNCHRONOUS 0x8242
+#define GL_DRAW_BUFFER0 0x8825
+#define GL_STENCIL_WRITEMASK 0x0B98
+#define GL_ANY_SAMPLES_PASSED 0x8C2F
+#define GL_UNSIGNED_INT_24_8 0x84FA
+#define GL_FRAGMENT_SUBROUTINE 0x92EC
+#define GL_PRIMITIVES_SUBMITTED 0x82EF
+#define GL_MAP1_NORMAL 0x0D92
+#define GL_INT_SAMPLER_2D_MULTISAMPLE 0x9109
+#define GL_NONE 0
+#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A
+#define GL_TEXTURE_3D 0x806F
+#define GL_MAX_FRAGMENT_INTERPOLATION_OFFSET 0x8E5C
+#define GL_TESS_EVALUATION_SUBROUTINE_UNIFORM 0x92F0
+#define GL_DYNAMIC_STORAGE_BIT 0x0100
+#define GL_IMAGE_CLASS_4_X_32 0x82B9
+#define GL_STENCIL 0x1802
+#define GL_BLUE 0x1905
+#define GL_IMAGE_CLASS_2_X_32 0x82BA
+#define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904
+#define GL_MAX_PROJECTION_STACK_DEPTH 0x0D38
+#define GL_TIMESTAMP 0x8E28
+#define GL_IMPLEMENTATION_COLOR_READ_FORMAT 0x8B9B
+#define GL_MODELVIEW 0x1700
+#define GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE 0x92D8
+#define GL_SET 0x150F
+#define GL_LIGHT6 0x4006
+#define GL_MAX_FRAGMENT_IMAGE_UNIFORMS 0x90CE
+#define GL_INT_IMAGE_CUBE_MAP_ARRAY 0x905F
+#define GL_TEXTURE_FILTER_CONTROL 0x8500
+#define GL_QUERY_BY_REGION_WAIT 0x8E15
+#define GL_COLOR_ATTACHMENT22 0x8CF6
+#define GL_TEXTURE29 0x84DD
+#define GL_DECR_WRAP 0x8508
+#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER 0x92CB
+#define GL_TEXTURE_BASE_LEVEL 0x813C
+#define GL_COORD_REPLACE 0x8862
+#define GL_TEXTURE_MATRIX 0x0BA8
+#define GL_CURRENT_BIT 0x00000001
+#define GL_POLYGON_TOKEN 0x0703
+#define GL_POINT_BIT 0x00000002
+#define GL_CURRENT_RASTER_POSITION 0x0B07
+#define GL_SLUMINANCE_ALPHA 0x8C44
+#define GL_RENDERBUFFER_SAMPLES 0x8CAB
+#define GL_TRANSFORM_FEEDBACK_BUFFER_INDEX 0x934B
+#define GL_CLIENT_ACTIVE_TEXTURE 0x84E1
+#define GL_ELEMENT_ARRAY_BUFFER 0x8893
+#define GL_SLUMINANCE 0x8C46
+#define GL_TEXTURE9 0x84C9
+#define GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY 0x906A
+#define GL_CURRENT_COLOR 0x0B00
+#define GL_PROXY_TEXTURE_1D 0x8063
+#define GL_LAYER_PROVOKING_VERTEX 0x825E
+#define GL_RGBA16F 0x881A
+#define GL_TEXTURE8 0x84C8
+#define GL_TRANSFORM_FEEDBACK_STREAM_OVERFLOW 0x82ED
+#define GL_TEXTURE17 0x84D1
+#define GL_INVALID_ENUM 0x0500
+#define GL_NUM_SAMPLE_COUNTS 0x9380
+#define GL_OBJECT_TYPE 0x9112
+#define GL_DOMAIN 0x0A02
+#define GL_FIRST_VERTEX_CONVENTION 0x8E4D
+#define GL_TEXTURE_INTERNAL_FORMAT 0x1003
+#define GL_TESS_GEN_POINT_MODE 0x8E79
+#define GL_TEXTURE_BINDING_1D 0x8068
+#define GL_SHADER_TYPE 0x8B4F
+#define GL_LIGHT3 0x4003
+#define GL_MAX_IMAGE_SAMPLES 0x906D
+#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49
+#define GL_CURRENT_RASTER_INDEX 0x0B05
+#define GL_CLIENT_VERTEX_ARRAY_BIT 0x00000002
+#define GL_SAMPLER_2D_RECT_SHADOW 0x8B64
+
+#include <stddef.h>
+#include <KHR/khrplatform.h>
+#ifndef GLEXT_64_TYPES_DEFINED
+/* This code block is duplicated in glxext.h, so must be protected */
+#define GLEXT_64_TYPES_DEFINED
+/* Define int32_t, int64_t, and uint64_t types for UST/MSC */
+/* (as used in the GL_EXT_timer_query extension). */
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+#include <inttypes.h>
+#elif defined(__sun__) || defined(__digital__)
+#include <inttypes.h>
+#if defined(__STDC__)
+#if defined(__arch64__) || defined(_LP64)
+	typedef long int int64_t;
+	typedef unsigned long int uint64_t;
+#else
+	typedef long long int int64_t;
+	typedef unsigned long long int uint64_t;
+#endif /* __arch64__ */
+#endif /* __STDC__ */
+#elif defined(__VMS) || defined(__sgi)
+#include <inttypes.h>
+#elif defined(__SCO__) || defined(__USLC__)
+#include <stdint.h>
+#elif defined(__UNIXOS2__) || defined(__SOL64__)
+	typedef long int int32_t;
+	typedef long long int int64_t;
+	typedef unsigned long long int uint64_t;
+#elif defined(_WIN32) && defined(__GNUC__)
+#include <stdint.h>
+#elif defined(_WIN32)
+	typedef __int32 int32_t;
+	typedef __int64 int64_t;
+	typedef unsigned __int64 uint64_t;
+#else
+/* Fallback if nothing above works */
+#include <inttypes.h>
+#endif
+#endif
+	typedef unsigned int GLenum;
+	typedef unsigned char GLboolean;
+	typedef unsigned int GLbitfield;
+	typedef void GLvoid;
+	typedef signed char GLbyte;
+	typedef short GLshort;
+	typedef int GLint;
+	typedef int GLclampx;
+	typedef unsigned char GLubyte;
+	typedef unsigned short GLushort;
+	typedef unsigned int GLuint;
+	typedef int GLsizei;
+	typedef float GLfloat;
+	typedef float GLclampf;
+	typedef double GLdouble;
+	typedef double GLclampd;
+	typedef void *GLeglClientBufferEXT;
+	typedef void *GLeglImageOES;
+	typedef char GLchar;
+	typedef char GLcharARB;
+#ifdef __APPLE__
+	typedef void *GLhandleARB;
+#else
+typedef unsigned int GLhandleARB;
+#endif
+	typedef unsigned short GLhalfARB;
+	typedef unsigned short GLhalf;
+	typedef GLint GLfixed;
+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060)
+	typedef khronos_intptr_t GLintptr;
+#else
+typedef khronos_intptr_t GLintptr;
+#endif
+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060)
+	typedef khronos_ssize_t GLsizeiptr;
+#else
+typedef khronos_ssize_t GLsizeiptr;
+#endif
+	typedef int64_t GLint64;
+	typedef uint64_t GLuint64;
+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060)
+	typedef long GLintptrARB;
+#else
+#ifndef __gltypes_h_
+typedef ptrdiff_t GLintptrARB;
+#endif
+#endif
+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060)
+	typedef long GLsizeiptrARB;
+#else
+#ifndef __gltypes_h_
+typedef ptrdiff_t GLsizeiptrARB;
+#endif
+#endif
+	typedef int64_t GLint64EXT;
+	typedef uint64_t GLuint64EXT;
+	typedef struct __GLsync *GLsync;
+	struct _cl_context;
+	struct _cl_event;
+	typedef void(GLAD_API_PTR *GLDEBUGPROC)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const void *userParam);
+	typedef void(GLAD_API_PTR *GLDEBUGPROCARB)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const void *userParam);
+	typedef void(GLAD_API_PTR *GLDEBUGPROCKHR)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const void *userParam);
+	typedef void(GLAD_API_PTR *GLDEBUGPROCAMD)(GLuint id, GLenum category, GLenum severity, GLsizei length, const GLchar *message, void *userParam);
+	typedef unsigned short GLhalfNV;
+	typedef GLintptr GLvdpauSurfaceNV;
+	typedef void(GLAD_API_PTR *GLVULKANPROCNV)(void);
+
+#define GL_VERSION_1_0 1
+	GLAD_API_CALL int GLAD_GL_VERSION_1_0;
+#define GL_VERSION_1_1 1
+	GLAD_API_CALL int GLAD_GL_VERSION_1_1;
+#define GL_VERSION_1_2 1
+	GLAD_API_CALL int GLAD_GL_VERSION_1_2;
+#define GL_VERSION_1_3 1
+	GLAD_API_CALL int GLAD_GL_VERSION_1_3;
+#define GL_VERSION_1_4 1
+	GLAD_API_CALL int GLAD_GL_VERSION_1_4;
+#define GL_VERSION_1_5 1
+	GLAD_API_CALL int GLAD_GL_VERSION_1_5;
+#define GL_VERSION_2_0 1
+	GLAD_API_CALL int GLAD_GL_VERSION_2_0;
+#define GL_VERSION_2_1 1
+	GLAD_API_CALL int GLAD_GL_VERSION_2_1;
+#define GL_VERSION_3_0 1
+	GLAD_API_CALL int GLAD_GL_VERSION_3_0;
+#define GL_VERSION_3_1 1
+	GLAD_API_CALL int GLAD_GL_VERSION_3_1;
+#define GL_VERSION_3_2 1
+	GLAD_API_CALL int GLAD_GL_VERSION_3_2;
+#define GL_VERSION_3_3 1
+	GLAD_API_CALL int GLAD_GL_VERSION_3_3;
+#define GL_VERSION_4_0 1
+	GLAD_API_CALL int GLAD_GL_VERSION_4_0;
+#define GL_VERSION_4_1 1
+	GLAD_API_CALL int GLAD_GL_VERSION_4_1;
+#define GL_VERSION_4_2 1
+	GLAD_API_CALL int GLAD_GL_VERSION_4_2;
+#define GL_VERSION_4_3 1
+	GLAD_API_CALL int GLAD_GL_VERSION_4_3;
+#define GL_VERSION_4_4 1
+	GLAD_API_CALL int GLAD_GL_VERSION_4_4;
+#define GL_VERSION_4_5 1
+	GLAD_API_CALL int GLAD_GL_VERSION_4_5;
+#define GL_VERSION_4_6 1
+	GLAD_API_CALL int GLAD_GL_VERSION_4_6;
+#define GL_ARB_point_sprite 1
+	GLAD_API_CALL int GLAD_GL_ARB_point_sprite;
+
+	typedef void(GLAD_API_PTR *PFNGLGETTEXTUREPARAMETERIIVPROC)(GLuint texture, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORDP1UIVPROC)(GLenum type, const GLuint *coords);
+	typedef void(GLAD_API_PTR *PFNGLTEXTURESTORAGE3DMULTISAMPLEPROC)(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
+	typedef void(GLAD_API_PTR *PFNGLEVALPOINT2PROC)(GLint i, GLint j);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXARRAYATTRIBBINDINGPROC)(GLuint vaobj, GLuint attribindex, GLuint bindingindex);
+	typedef void(GLAD_API_PTR *PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEPROC)(GLuint buffer, GLintptr offset, GLsizeiptr length);
+	typedef void(GLAD_API_PTR *PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVPROC)(GLuint framebuffer, GLenum pname, GLint *param);
+	typedef void(GLAD_API_PTR *PFNGLPIXELTRANSFERFPROC)(GLenum pname, GLfloat param);
+	typedef void(GLAD_API_PTR *PFNGLGETFLOATI_VPROC)(GLenum target, GLuint index, GLfloat *data);
+	typedef void(GLAD_API_PTR *PFNGLLOADNAMEPROC)(GLuint name);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORMMATRIX4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+	typedef void(GLAD_API_PTR *PFNGLSECONDARYCOLOR3SVPROC)(const GLshort *v);
+	typedef void(GLAD_API_PTR *PFNGLCOPYTEXTURESUBIMAGE1DPROC)(GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+	typedef void(GLAD_API_PTR *PFNGLSECONDARYCOLOR3UIVPROC)(const GLuint *v);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM1DVPROC)(GLint location, GLsizei count, const GLdouble *value);
+	typedef void(GLAD_API_PTR *PFNGLWINDOWPOS3DVPROC)(const GLdouble *v);
+	typedef void(GLAD_API_PTR *PFNGLSECONDARYCOLOR3BVPROC)(const GLbyte *v);
+	typedef void(GLAD_API_PTR *PFNGLSECONDARYCOLOR3UIPROC)(GLuint red, GLuint green, GLuint blue);
+	typedef void(GLAD_API_PTR *PFNGLGETNCOLORTABLEPROC)(GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *table);
+	typedef void(GLAD_API_PTR *PFNGLRASTERPOS3IPROC)(GLint x, GLint y, GLint z);
+	typedef void(GLAD_API_PTR *PFNGLACTIVETEXTUREPROC)(GLenum texture);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB4NUIVPROC)(GLuint index, const GLuint *v);
+	typedef void(GLAD_API_PTR *PFNGLCLEARNAMEDBUFFERDATAPROC)(GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void *data);
+	typedef void(GLAD_API_PTR *PFNGLNORMAL3DPROC)(GLdouble nx, GLdouble ny, GLdouble nz);
+	typedef void(GLAD_API_PTR *PFNGLINVALIDATENAMEDFRAMEBUFFERSUBDATAPROC)(GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height);
+	typedef void(GLAD_API_PTR *PFNGLBINDBUFFERSBASEPROC)(GLenum target, GLuint first, GLsizei count, const GLuint *buffers);
+	typedef void(GLAD_API_PTR *PFNGLEVALCOORD1DPROC)(GLdouble u);
+	typedef void(GLAD_API_PTR *PFNGLGETMAPFVPROC)(GLenum target, GLenum query, GLfloat *v);
+	typedef GLboolean(GLAD_API_PTR *PFNGLISSYNCPROC)(GLsync sync);
+	typedef void(GLAD_API_PTR *PFNGLTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);
+	typedef GLint(GLAD_API_PTR *PFNGLGETATTRIBLOCATIONPROC)(GLuint program, const GLchar *name);
+	typedef void(GLAD_API_PTR *PFNGLCOPYTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM4IPROC)(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+	typedef void(GLAD_API_PTR *PFNGLGETPIXELMAPFVPROC)(GLenum map, GLfloat *values);
+	typedef void(GLAD_API_PTR *PFNGLVERTEX4SVPROC)(const GLshort *v);
+	typedef void(GLAD_API_PTR *PFNGLTEXSTORAGE2DPROC)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD2FVPROC)(const GLfloat *v);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORMMATRIX3X2DVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+	typedef void(GLAD_API_PTR *PFNGLGETVERTEXATTRIBIUIVPROC)(GLuint index, GLenum pname, GLuint *params);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB3SVPROC)(GLuint index, const GLshort *v);
+	typedef void(GLAD_API_PTR *PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex);
+	typedef void(GLAD_API_PTR *PFNGLDEPTHRANGEINDEXEDPROC)(GLuint index, GLdouble n, GLdouble f);
+	typedef GLboolean(GLAD_API_PTR *PFNGLISQUERYPROC)(GLuint id);
+	typedef void(GLAD_API_PTR *PFNGLDELETEPROGRAMPIPELINESPROC)(GLsizei n, const GLuint *pipelines);
+	typedef void(GLAD_API_PTR *PFNGLGETTEXTURELEVELPARAMETERFVPROC)(GLuint texture, GLint level, GLenum pname, GLfloat *params);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORMMATRIX4X3DVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+	typedef void(GLAD_API_PTR *PFNGLBLITNAMEDFRAMEBUFFERPROC)(GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORDP1UIPROC)(GLenum texture, GLenum type, GLuint coords);
+	typedef void(GLAD_API_PTR *PFNGLINDEXSPROC)(GLshort c);
+	typedef void(GLAD_API_PTR *PFNGLCOLORP3UIPROC)(GLenum type, GLuint color);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORDP4UIPROC)(GLenum texture, GLenum type, GLuint coords);
+	typedef GLuint(GLAD_API_PTR *PFNGLCREATESHADERPROC)(GLenum type);
+	typedef void(GLAD_API_PTR *PFNGLCLEARNAMEDFRAMEBUFFERFIPROC)(GLuint framebuffer, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
+	typedef void(GLAD_API_PTR *PFNGLGETCOMPRESSEDTEXTUREIMAGEPROC)(GLuint texture, GLint level, GLsizei bufSize, void *pixels);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR4SVPROC)(const GLshort *v);
+	typedef void(GLAD_API_PTR *PFNGLDEBUGMESSAGEINSERTPROC)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf);
+	typedef void(GLAD_API_PTR *PFNGLRECTFPROC)(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
+	typedef GLuint(GLAD_API_PTR *PFNGLGETDEBUGMESSAGELOGPROC)(GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog);
+	typedef void(GLAD_API_PTR *PFNGLWINDOWPOS3SPROC)(GLshort x, GLshort y, GLshort z);
+	typedef GLboolean(GLAD_API_PTR *PFNGLISFRAMEBUFFERPROC)(GLuint framebuffer);
+	typedef void(GLAD_API_PTR *PFNGLCOPYIMAGESUBDATAPROC)(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth);
+	typedef void(GLAD_API_PTR *PFNGLCOLORPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void *pointer);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORMMATRIX4X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+	typedef void(GLAD_API_PTR *PFNGLGETMATERIALFVPROC)(GLenum face, GLenum pname, GLfloat *params);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD4IVPROC)(GLenum target, const GLint *v);
+	typedef void(GLAD_API_PTR *PFNGLDELETESAMPLERSPROC)(GLsizei count, const GLuint *samplers);
+	typedef void(GLAD_API_PTR *PFNGLGETMATERIALIVPROC)(GLenum face, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLBLENDFUNCPROC)(GLenum sfactor, GLenum dfactor);
+	typedef void(GLAD_API_PTR *PFNGLNAMEDFRAMEBUFFERRENDERBUFFERPROC)(GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
+	typedef void(GLAD_API_PTR *PFNGLNAMEDBUFFERDATAPROC)(GLuint buffer, GLsizeiptr size, const void *data, GLenum usage);
+	typedef void(GLAD_API_PTR *PFNGLMULTIDRAWELEMENTSPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei drawcount);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM3IPROC)(GLuint program, GLint location, GLint v0, GLint v1, GLint v2);
+	typedef void(GLAD_API_PTR *PFNGLGETPROGRAMSTAGEIVPROC)(GLuint program, GLenum shadertype, GLenum pname, GLint *values);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBLFORMATPROC)(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
+	typedef void(GLAD_API_PTR *PFNGLVERTEX2SVPROC)(const GLshort *v);
+	typedef void(GLAD_API_PTR *PFNGLRECTSVPROC)(const GLshort *v1, const GLshort *v2);
+	typedef void(GLAD_API_PTR *PFNGLTEXTURESTORAGE2DPROC)(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM3FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+	typedef void(GLAD_API_PTR *PFNGLDRAWBUFFERPROC)(GLenum buf);
+	typedef void(GLAD_API_PTR *PFNGLTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORDP2UIVPROC)(GLenum type, const GLuint *coords);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM4FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB2DPROC)(GLuint index, GLdouble x, GLdouble y);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB2FPROC)(GLuint index, GLfloat x, GLfloat y);
+	typedef void(GLAD_API_PTR *PFNGLSECONDARYCOLOR3UBVPROC)(const GLubyte *v);
+	typedef void(GLAD_API_PTR *PFNGLDELETEFRAMEBUFFERSPROC)(GLsizei n, const GLuint *framebuffers);
+	typedef void(GLAD_API_PTR *PFNGLCLEARCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+	typedef void(GLAD_API_PTR *PFNGLFRAMEBUFFERRENDERBUFFERPROC)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
+	typedef void(GLAD_API_PTR *PFNGLGETTEXGENFVPROC)(GLenum coord, GLenum pname, GLfloat *params);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR4DVPROC)(const GLdouble *v);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORDP4UIVPROC)(GLenum texture, GLenum type, const GLuint *coords);
+	typedef void(GLAD_API_PTR *PFNGLACTIVESHADERPROGRAMPROC)(GLuint pipeline, GLuint program);
+	typedef void(GLAD_API_PTR *PFNGLBEGINCONDITIONALRENDERPROC)(GLuint id, GLenum mode);
+	typedef void(GLAD_API_PTR *PFNGLTEXIMAGE3DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
+	typedef void(GLAD_API_PTR *PFNGLVIEWPORTINDEXEDFVPROC)(GLuint index, const GLfloat *v);
+	typedef void(GLAD_API_PTR *PFNGLMAPGRID1FPROC)(GLint un, GLfloat u1, GLfloat u2);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD3DPROC)(GLenum target, GLdouble s, GLdouble t, GLdouble r);
+	typedef void(GLAD_API_PTR *PFNGLWINDOWPOS2DVPROC)(const GLdouble *v);
+	typedef void(GLAD_API_PTR *PFNGLGETBUFFERPOINTERVPROC)(GLenum target, GLenum pname, void **params);
+	typedef void(GLAD_API_PTR *PFNGLTEXGENFVPROC)(GLenum coord, GLenum pname, const GLfloat *params);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBP4UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
+	typedef void(GLAD_API_PTR *PFNGLROTATEDPROC)(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
+	typedef void(GLAD_API_PTR *PFNGLCREATEQUERIESPROC)(GLenum target, GLsizei n, GLuint *ids);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORMMATRIX3X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+	typedef void(GLAD_API_PTR *PFNGLTEXIMAGE1DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels);
+	typedef void(GLAD_API_PTR *PFNGLWINDOWPOS3IPROC)(GLint x, GLint y, GLint z);
+	typedef void(GLAD_API_PTR *PFNGLCLAMPCOLORPROC)(GLenum target, GLenum clamp);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORMMATRIX4X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+	typedef void(GLAD_API_PTR *PFNGLVERTEX4FPROC)(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+	typedef void(GLAD_API_PTR *PFNGLNORMAL3FPROC)(GLfloat nx, GLfloat ny, GLfloat nz);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR3UBPROC)(GLubyte red, GLubyte green, GLubyte blue);
+	typedef void(GLAD_API_PTR *PFNGLSCISSORINDEXEDPROC)(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height);
+	typedef void(GLAD_API_PTR *PFNGLPUSHCLIENTATTRIBPROC)(GLbitfield mask);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB4DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+	typedef void(GLAD_API_PTR *PFNGLUSEPROGRAMSTAGESPROC)(GLuint pipeline, GLbitfield stages, GLuint program);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD3SPROC)(GLshort s, GLshort t, GLshort r);
+	typedef void(GLAD_API_PTR *PFNGLLIGHTFPROC)(GLenum light, GLenum pname, GLfloat param);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD3FVPROC)(const GLfloat *v);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB4NUBVPROC)(GLuint index, const GLubyte *v);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBL2DPROC)(GLuint index, GLdouble x, GLdouble y);
+	typedef void(GLAD_API_PTR *PFNGLFOGCOORDDPROC)(GLdouble coord);
+	typedef void(GLAD_API_PTR *PFNGLGETNPIXELMAPUIVPROC)(GLenum map, GLsizei bufSize, GLuint *values);
+	typedef void(GLAD_API_PTR *PFNGLTEXIMAGE2DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
+	typedef void(GLAD_API_PTR *PFNGLGETQUERYBUFFEROBJECTIVPROC)(GLuint id, GLuint buffer, GLenum pname, GLintptr offset);
+	typedef const GLubyte *(GLAD_API_PTR *PFNGLGETSTRINGIPROC)(GLenum name, GLuint index);
+	typedef void(GLAD_API_PTR *PFNGLRASTERPOS4SPROC)(GLshort x, GLshort y, GLshort z, GLshort w);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBP2UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value);
+	typedef void(GLAD_API_PTR *PFNGLGETQUERYIVPROC)(GLenum target, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLBINDVERTEXARRAYPROC)(GLuint array);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM3DVPROC)(GLuint program, GLint location, GLsizei count, const GLdouble *value);
+	typedef void(GLAD_API_PTR *PFNGLTEXPARAMETERFPROC)(GLenum target, GLenum pname, GLfloat param);
+	typedef void(GLAD_API_PTR *PFNGLWINDOWPOS3DPROC)(GLdouble x, GLdouble y, GLdouble z);
+	typedef void(GLAD_API_PTR *PFNGLGENERATETEXTUREMIPMAPPROC)(GLuint texture);
+	typedef void(GLAD_API_PTR *PFNGLDELETESYNCPROC)(GLsync sync);
+	typedef void(GLAD_API_PTR *PFNGLBINDBUFFERPROC)(GLenum target, GLuint buffer);
+	typedef void(GLAD_API_PTR *PFNGLPUSHDEBUGGROUPPROC)(GLenum source, GLuint id, GLsizei length, const GLchar *message);
+	typedef void(GLAD_API_PTR *PFNGLRASTERPOS2IPROC)(GLint x, GLint y);
+	typedef void(GLAD_API_PTR *PFNGLBINDIMAGETEXTUREPROC)(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format);
+	typedef void(GLAD_API_PTR *PFNGLFEEDBACKBUFFERPROC)(GLsizei size, GLenum type, GLfloat *buffer);
+	typedef void(GLAD_API_PTR *PFNGLEVALMESH2PROC)(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
+	typedef void(GLAD_API_PTR *PFNGLLINKPROGRAMPROC)(GLuint program);
+	typedef void(GLAD_API_PTR *PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data);
+	typedef void(GLAD_API_PTR *PFNGLPUSHMATRIXPROC)(void);
+	typedef void(GLAD_API_PTR *PFNGLFRAMEBUFFERPARAMETERIPROC)(GLenum target, GLenum pname, GLint param);
+	typedef void(GLAD_API_PTR *PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM3DPROC)(GLint location, GLdouble x, GLdouble y, GLdouble z);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB4UBVPROC)(GLuint index, const GLubyte *v);
+	typedef void(GLAD_API_PTR *PFNGLCOMPRESSEDTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data);
+	typedef void(GLAD_API_PTR *PFNGLGETTRANSFORMFEEDBACKI64_VPROC)(GLuint xfb, GLenum pname, GLuint index, GLint64 *param);
+	typedef void(GLAD_API_PTR *PFNGLCOMPILESHADERPROC)(GLuint shader);
+	typedef void(GLAD_API_PTR *PFNGLGETLIGHTFVPROC)(GLenum light, GLenum pname, GLfloat *params);
+	typedef void(GLAD_API_PTR *PFNGLPIXELMAPUSVPROC)(GLenum map, GLsizei mapsize, const GLushort *values);
+	typedef void(GLAD_API_PTR *PFNGLRASTERPOS4IPROC)(GLint x, GLint y, GLint z, GLint w);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORMMATRIX4X2DVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+	typedef void(GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTURE1DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+	typedef void(GLAD_API_PTR *PFNGLINITNAMESPROC)(void);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBI1UIPROC)(GLuint index, GLuint x);
+	typedef void(GLAD_API_PTR *PFNGLCLEARBUFFERIVPROC)(GLenum buffer, GLint drawbuffer, const GLint *value);
+	typedef void(GLAD_API_PTR *PFNGLMAP1FPROC)(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX4DVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+	typedef void(GLAD_API_PTR *PFNGLGETVERTEXATTRIBFVPROC)(GLuint index, GLenum pname, GLfloat *params);
+	typedef void(GLAD_API_PTR *PFNGLGETACTIVEUNIFORMBLOCKIVPROC)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+	typedef void(GLAD_API_PTR *PFNGLGETVERTEXARRAYINDEXEDIVPROC)(GLuint vaobj, GLuint index, GLenum pname, GLint *param);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXARRAYELEMENTBUFFERPROC)(GLuint vaobj, GLuint buffer);
+	typedef void(GLAD_API_PTR *PFNGLGETTEXGENDVPROC)(GLenum coord, GLenum pname, GLdouble *params);
+	typedef void(GLAD_API_PTR *PFNGLCLEARNAMEDFRAMEBUFFERFVPROC)(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat *value);
+	typedef void(GLAD_API_PTR *PFNGLSECONDARYCOLOR3FPROC)(GLfloat red, GLfloat green, GLfloat blue);
+	typedef void(GLAD_API_PTR *PFNGLSHADERBINARYPROC)(GLsizei count, const GLuint *shaders, GLenum binaryformat, const void *binary, GLsizei length);
+	typedef void(GLAD_API_PTR *PFNGLMAP1DPROC)(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBL2DVPROC)(GLuint index, const GLdouble *v);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD4DPROC)(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD1DVPROC)(const GLdouble *v);
+	typedef void(GLAD_API_PTR *PFNGLTEXSTORAGE2DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
+	typedef void(GLAD_API_PTR *PFNGLGENTRANSFORMFEEDBACKSPROC)(GLsizei n, GLuint *ids);
+	typedef void(GLAD_API_PTR *PFNGLCLEARBUFFERSUBDATAPROC)(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX2FVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+	typedef void(GLAD_API_PTR *PFNGLGETFRAMEBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLPIXELMAPFVPROC)(GLenum map, GLsizei mapsize, const GLfloat *values);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR3FPROC)(GLfloat red, GLfloat green, GLfloat blue);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+	typedef void(GLAD_API_PTR *PFNGLMULTMATRIXDPROC)(const GLdouble *m);
+	typedef void(GLAD_API_PTR *PFNGLCOPYPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM2DVPROC)(GLint location, GLsizei count, const GLdouble *value);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR3SVPROC)(const GLshort *v);
+	typedef void(GLAD_API_PTR *PFNGLOBJECTLABELPROC)(GLenum identifier, GLuint name, GLsizei length, const GLchar *label);
+	typedef void(GLAD_API_PTR *PFNGLGETOBJECTLABELPROC)(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label);
+	typedef void(GLAD_API_PTR *PFNGLINDEXFVPROC)(const GLfloat *c);
+	typedef void(GLAD_API_PTR *PFNGLCOMPRESSEDTEXTURESUBIMAGE3DPROC)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data);
+	typedef void(GLAD_API_PTR *PFNGLMAPGRID1DPROC)(GLint un, GLdouble u1, GLdouble u2);
+	typedef void(GLAD_API_PTR *PFNGLGETQUERYBUFFEROBJECTUIVPROC)(GLuint id, GLuint buffer, GLenum pname, GLintptr offset);
+	typedef void(GLAD_API_PTR *PFNGLRASTERPOS3SVPROC)(const GLshort *v);
+	typedef void(GLAD_API_PTR *PFNGLSELECTBUFFERPROC)(GLsizei size, GLuint *buffer);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBI3IVPROC)(GLuint index, const GLint *v);
+	typedef void(GLAD_API_PTR *PFNGLPATCHPARAMETERIPROC)(GLenum pname, GLint value);
+	typedef void(GLAD_API_PTR *PFNGLGETTEXTUREPARAMETERIUIVPROC)(GLuint texture, GLenum pname, GLuint *params);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR3IVPROC)(const GLint *v);
+	typedef void *(GLAD_API_PTR *PFNGLMAPBUFFERPROC)(GLenum target, GLenum access);
+	typedef void(GLAD_API_PTR *PFNGLNORMALP3UIPROC)(GLenum type, GLuint coords);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void *pointer);
+	typedef void(GLAD_API_PTR *PFNGLGETTEXTUREPARAMETERFVPROC)(GLuint texture, GLenum pname, GLfloat *params);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBPOINTERPROC)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer);
+	typedef void(GLAD_API_PTR *PFNGLDEPTHRANGEFPROC)(GLfloat n, GLfloat f);
+	typedef void(GLAD_API_PTR *PFNGLTEXTUREPARAMETERIVPROC)(GLuint texture, GLenum pname, const GLint *param);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXP2UIVPROC)(GLenum type, const GLuint *value);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBI4USVPROC)(GLuint index, const GLushort *v);
+	typedef void(GLAD_API_PTR *PFNGLTEXPARAMETERIVPROC)(GLenum target, GLenum pname, const GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLBINDVERTEXBUFFERSPROC)(GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXP3UIVPROC)(GLenum type, const GLuint *value);
+	typedef void(GLAD_API_PTR *PFNGLINDEXIPROC)(GLint c);
+	typedef void(GLAD_API_PTR *PFNGLGETACTIVESUBROUTINENAMEPROC)(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
+	typedef void(GLAD_API_PTR *PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data);
+	typedef void(GLAD_API_PTR *PFNGLGETVERTEXATTRIBPOINTERVPROC)(GLuint index, GLenum pname, void **pointer);
+	typedef void(GLAD_API_PTR *PFNGLGETPIXELMAPUIVPROC)(GLenum map, GLuint *values);
+	typedef void(GLAD_API_PTR *PFNGLGETTEXGENIVPROC)(GLenum coord, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB3SPROC)(GLuint index, GLshort x, GLshort y, GLshort z);
+	typedef void(GLAD_API_PTR *PFNGLPOINTSIZEPROC)(GLfloat size);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXP2UIPROC)(GLenum type, GLuint value);
+	typedef void(GLAD_API_PTR *PFNGLMULTIDRAWARRAYSINDIRECTCOUNTPROC)(GLenum mode, const void *indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride);
+	typedef void(GLAD_API_PTR *PFNGLGETNTEXIMAGEPROC)(GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels);
+	typedef void(GLAD_API_PTR *PFNGLCULLFACEPROC)(GLenum mode);
+	typedef void(GLAD_API_PTR *PFNGLSAMPLERPARAMETERIPROC)(GLuint sampler, GLenum pname, GLint param);
+	typedef void(GLAD_API_PTR *PFNGLTEXTUREBARRIERPROC)(void);
+	typedef GLboolean(GLAD_API_PTR *PFNGLISRENDERBUFFERPROC)(GLuint renderbuffer);
+	typedef void(GLAD_API_PTR *PFNGLBEGINQUERYPROC)(GLenum target, GLuint id);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR4USPROC)(GLushort red, GLushort green, GLushort blue, GLushort alpha);
+	typedef void(GLAD_API_PTR *PFNGLGETVERTEXATTRIBDVPROC)(GLuint index, GLenum pname, GLdouble *params);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD4IVPROC)(const GLint *v);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM1FVPROC)(GLuint program, GLint location, GLsizei count, const GLfloat *value);
+	typedef void(GLAD_API_PTR *PFNGLDELETETEXTURESPROC)(GLsizei n, const GLuint *textures);
+	typedef void(GLAD_API_PTR *PFNGLWINDOWPOS2IVPROC)(const GLint *v);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBIPOINTERPROC)(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer);
+	typedef void(GLAD_API_PTR *PFNGLCREATEVERTEXARRAYSPROC)(GLsizei n, GLuint *arrays);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBI1IPROC)(GLuint index, GLint x);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM3UIPROC)(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);
+	typedef void(GLAD_API_PTR *PFNGLCOMPRESSEDTEXTURESUBIMAGE2DPROC)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data);
+	typedef void(GLAD_API_PTR *PFNGLRECTDPROC)(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
+	typedef void(GLAD_API_PTR *PFNGLMULTTRANSPOSEMATRIXDPROC)(const GLdouble *m);
+	typedef void(GLAD_API_PTR *PFNGLTEXENVFPROC)(GLenum target, GLenum pname, GLfloat param);
+	typedef void(GLAD_API_PTR *PFNGLNORMAL3IPROC)(GLint nx, GLint ny, GLint nz);
+	typedef void(GLAD_API_PTR *PFNGLBINDATTRIBLOCATIONPROC)(GLuint program, GLuint index, const GLchar *name);
+	typedef void(GLAD_API_PTR *PFNGLSTENCILMASKSEPARATEPROC)(GLenum face, GLuint mask);
+	typedef void(GLAD_API_PTR *PFNGLGETINTEGERVPROC)(GLenum pname, GLint *data);
+	typedef void(GLAD_API_PTR *PFNGLUSEPROGRAMPROC)(GLuint program);
+	typedef void(GLAD_API_PTR *PFNGLNORMAL3BVPROC)(const GLbyte *v);
+	typedef void(GLAD_API_PTR *PFNGLPIXELSTOREIPROC)(GLenum pname, GLint param);
+	typedef void(GLAD_API_PTR *PFNGLNORMAL3SPROC)(GLshort nx, GLshort ny, GLshort nz);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR4IVPROC)(const GLint *v);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORDP2UIVPROC)(GLenum texture, GLenum type, const GLuint *coords);
+	typedef GLboolean(GLAD_API_PTR *PFNGLARETEXTURESRESIDENTPROC)(GLsizei n, const GLuint *textures, GLboolean *residences);
+	typedef void(GLAD_API_PTR *PFNGLGETUNIFORMFVPROC)(GLuint program, GLint location, GLfloat *params);
+	typedef void(GLAD_API_PTR *PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC)(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+	typedef void(GLAD_API_PTR *PFNGLTEXSTORAGE3DPROC)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD1IPROC)(GLint s);
+	typedef void(GLAD_API_PTR *PFNGLGETCOMPRESSEDTEXTURESUBIMAGEPROC)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void *pixels);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXARRAYVERTEXBUFFERSPROC)(GLuint vaobj, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides);
+	typedef void(GLAD_API_PTR *PFNGLSECONDARYCOLOR3DPROC)(GLdouble red, GLdouble green, GLdouble blue);
+	typedef void(GLAD_API_PTR *PFNGLINTERLEAVEDARRAYSPROC)(GLenum format, GLsizei stride, const void *pointer);
+	typedef GLboolean(GLAD_API_PTR *PFNGLUNMAPBUFFERPROC)(GLenum target);
+	typedef GLboolean(GLAD_API_PTR *PFNGLISENABLEDIPROC)(GLenum target, GLuint index);
+	typedef void(GLAD_API_PTR *PFNGLBINDSAMPLERSPROC)(GLuint first, GLsizei count, const GLuint *samplers);
+	typedef void(GLAD_API_PTR *PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data);
+	typedef void(GLAD_API_PTR *PFNGLPRIORITIZETEXTURESPROC)(GLsizei n, const GLuint *textures, const GLfloat *priorities);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+	typedef void(GLAD_API_PTR *PFNGLRASTERPOS4DPROC)(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+	typedef void(GLAD_API_PTR *PFNGLSECONDARYCOLOR3USVPROC)(const GLushort *v);
+	typedef void(GLAD_API_PTR *PFNGLGETSYNCIVPROC)(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
+	typedef void(GLAD_API_PTR *PFNGLSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, const GLint *param);
+	typedef void(GLAD_API_PTR *PFNGLLIGHTMODELFVPROC)(GLenum pname, const GLfloat *params);
+	typedef void(GLAD_API_PTR *PFNGLTEXTURESTORAGE3DPROC)(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
+	typedef void(GLAD_API_PTR *PFNGLRESUMETRANSFORMFEEDBACKPROC)(void);
+	typedef void(GLAD_API_PTR *PFNGLGENPROGRAMPIPELINESPROC)(GLsizei n, GLuint *pipelines);
+	typedef void(GLAD_API_PTR *PFNGLVERTEX4FVPROC)(const GLfloat *v);
+	typedef void(GLAD_API_PTR *PFNGLLIGHTIVPROC)(GLenum light, GLenum pname, const GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLCLEARNAMEDFRAMEBUFFERIVPROC)(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint *value);
+	typedef void(GLAD_API_PTR *PFNGLGETTEXPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD3DVPROC)(const GLdouble *v);
+	typedef void(GLAD_API_PTR *PFNGLFOGCOORDPOINTERPROC)(GLenum type, GLsizei stride, const void *pointer);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM2IPROC)(GLint location, GLint v0, GLint v1);
+	typedef void(GLAD_API_PTR *PFNGLTEXTURESUBIMAGE3DPROC)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels);
+	typedef void(GLAD_API_PTR *PFNGLGETDOUBLEI_VPROC)(GLenum target, GLuint index, GLdouble *data);
+	typedef void(GLAD_API_PTR *PFNGLCLEARBUFFERDATAPROC)(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data);
+	typedef void(GLAD_API_PTR *PFNGLBINDTEXTUREPROC)(GLenum target, GLuint texture);
+	typedef void(GLAD_API_PTR *PFNGLTEXTUREBUFFERRANGEPROC)(GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size);
+	typedef void(GLAD_API_PTR *PFNGLGETTEXLEVELPARAMETERFVPROC)(GLenum target, GLint level, GLenum pname, GLfloat *params);
+	typedef void(GLAD_API_PTR *PFNGLSAMPLEMASKIPROC)(GLuint maskNumber, GLbitfield mask);
+	typedef void(GLAD_API_PTR *PFNGLCLEARACCUMPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+	typedef void(GLAD_API_PTR *PFNGLGETACTIVEUNIFORMPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
+	typedef void(GLAD_API_PTR *PFNGLGETPROGRAMBINARYPROC)(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary);
+	typedef void(GLAD_API_PTR *PFNGLDETACHSHADERPROC)(GLuint program, GLuint shader);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB4SPROC)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+	typedef void(GLAD_API_PTR *PFNGLTEXTUREPARAMETERIPROC)(GLuint texture, GLenum pname, GLint param);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR3DVPROC)(const GLdouble *v);
+	typedef void(GLAD_API_PTR *PFNGLBINDSAMPLERPROC)(GLuint unit, GLuint sampler);
+	typedef GLenum(GLAD_API_PTR *PFNGLCHECKNAMEDFRAMEBUFFERSTATUSPROC)(GLuint framebuffer, GLenum target);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM1IVPROC)(GLuint program, GLint location, GLsizei count, const GLint *value);
+	typedef void(GLAD_API_PTR *PFNGLMULTIDRAWARRAYSPROC)(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
+	typedef void(GLAD_API_PTR *PFNGLRASTERPOS4DVPROC)(const GLdouble *v);
+	typedef void(GLAD_API_PTR *PFNGLGETFLOATVPROC)(GLenum pname, GLfloat *data);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMPARAMETERIPROC)(GLuint program, GLenum pname, GLint value);
+	typedef void(GLAD_API_PTR *PFNGLDELETERENDERBUFFERSPROC)(GLsizei n, const GLuint *renderbuffers);
+	typedef void(GLAD_API_PTR *PFNGLSECONDARYCOLORPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void *pointer);
+	typedef GLboolean(GLAD_API_PTR *PFNGLISSAMPLERPROC)(GLuint sampler);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD1DVPROC)(GLenum target, const GLdouble *v);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+	typedef void(GLAD_API_PTR *PFNGLDEBUGMESSAGECONTROLPROC)(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled);
+	typedef void(GLAD_API_PTR *PFNGLBINDBUFFERSRANGEPROC)(GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes);
+	typedef void(GLAD_API_PTR *PFNGLMULTIDRAWARRAYSINDIRECTPROC)(GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride);
+	typedef void(GLAD_API_PTR *PFNGLGETMAPDVPROC)(GLenum target, GLenum query, GLdouble *v);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORDP3UIPROC)(GLenum type, GLuint coords);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBIFORMATPROC)(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
+	typedef void(GLAD_API_PTR *PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC)(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount);
+	typedef void(GLAD_API_PTR *PFNGLTRANSFORMFEEDBACKBUFFERBASEPROC)(GLuint xfb, GLuint index, GLuint buffer);
+	typedef void(GLAD_API_PTR *PFNGLGETTEXENVIVPROC)(GLenum target, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLCOLORP3UIVPROC)(GLenum type, const GLuint *color);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB1FPROC)(GLuint index, GLfloat x);
+	typedef void(GLAD_API_PTR *PFNGLPOPCLIENTATTRIBPROC)(void);
+	typedef void(GLAD_API_PTR *PFNGLGETTEXIMAGEPROC)(GLenum target, GLint level, GLenum format, GLenum type, void *pixels);
+	typedef void(GLAD_API_PTR *PFNGLRENDERBUFFERSTORAGEPROC)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
+	typedef void(GLAD_API_PTR *PFNGLDELETEBUFFERSPROC)(GLsizei n, const GLuint *buffers);
+	typedef GLenum(GLAD_API_PTR *PFNGLCLIENTWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM1DVPROC)(GLuint program, GLint location, GLsizei count, const GLdouble *value);
+	typedef void(GLAD_API_PTR *PFNGLCLEARTEXIMAGEPROC)(GLuint texture, GLint level, GLenum format, GLenum type, const void *data);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD2FVPROC)(GLenum target, const GLfloat *v);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM3UIVPROC)(GLint location, GLsizei count, const GLuint *value);
+	typedef void(GLAD_API_PTR *PFNGLGETACTIVEUNIFORMNAMEPROC)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName);
+	typedef void(GLAD_API_PTR *PFNGLEVALPOINT1PROC)(GLint i);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR3USPROC)(GLushort red, GLushort green, GLushort blue);
+	typedef void(GLAD_API_PTR *PFNGLGETTEXTURESUBIMAGEPROC)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void *pixels);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR3IPROC)(GLint red, GLint green, GLint blue);
+	typedef void(GLAD_API_PTR *PFNGLSECONDARYCOLOR3DVPROC)(const GLdouble *v);
+	typedef void(GLAD_API_PTR *PFNGLEVALCOORD1FVPROC)(const GLfloat *u);
+	typedef void(GLAD_API_PTR *PFNGLVIEWPORTARRAYVPROC)(GLuint first, GLsizei count, const GLfloat *v);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBI4IPROC)(GLuint index, GLint x, GLint y, GLint z, GLint w);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBL4DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR4DPROC)(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
+	typedef GLint(GLAD_API_PTR *PFNGLGETFRAGDATALOCATIONPROC)(GLuint program, const GLchar *name);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR4UBVPROC)(const GLubyte *v);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORMMATRIX4DVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORMMATRIX3X4DVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+	typedef void(GLAD_API_PTR *PFNGLSCISSORPROC)(GLint x, GLint y, GLsizei width, GLsizei height);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORMSUBROUTINESUIVPROC)(GLenum shadertype, GLsizei count, const GLuint *indices);
+	typedef void(GLAD_API_PTR *PFNGLVERTEX4IVPROC)(const GLint *v);
+	typedef void(GLAD_API_PTR *PFNGLCOLORMASKPROC)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+	typedef void(GLAD_API_PTR *PFNGLSTENCILOPSEPARATEPROC)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
+	typedef void(GLAD_API_PTR *PFNGLGETBOOLEANVPROC)(GLenum pname, GLboolean *data);
+	typedef void(GLAD_API_PTR *PFNGLVERTEX3DPROC)(GLdouble x, GLdouble y, GLdouble z);
+	typedef void(GLAD_API_PTR *PFNGLGETNAMEDBUFFERPOINTERVPROC)(GLuint buffer, GLenum pname, void **params);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXARRAYVERTEXBUFFERPROC)(GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);
+	typedef void(GLAD_API_PTR *PFNGLGETPOLYGONSTIPPLEPROC)(GLubyte *mask);
+	typedef void(GLAD_API_PTR *PFNGLSTENCILOPPROC)(GLenum fail, GLenum zfail, GLenum zpass);
+	typedef void(GLAD_API_PTR *PFNGLVIEWPORTPROC)(GLint x, GLint y, GLsizei width, GLsizei height);
+	typedef void(GLAD_API_PTR *PFNGLGETNPOLYGONSTIPPLEPROC)(GLsizei bufSize, GLubyte *pattern);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB4USVPROC)(GLuint index, const GLushort *v);
+	typedef void(GLAD_API_PTR *PFNGLENDTRANSFORMFEEDBACKPROC)(void);
+	typedef GLuint(GLAD_API_PTR *PFNGLCREATEPROGRAMPROC)(void);
+	typedef void(GLAD_API_PTR *PFNGLGETSHADERINFOLOGPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+	typedef void(GLAD_API_PTR *PFNGLGETVERTEXARRAYINDEXED64IVPROC)(GLuint vaobj, GLuint index, GLenum pname, GLint64 *param);
+	typedef void(GLAD_API_PTR *PFNGLTEXGENDPROC)(GLenum coord, GLenum pname, GLdouble param);
+	typedef void(GLAD_API_PTR *PFNGLINDEXUBPROC)(GLubyte c);
+	typedef void(GLAD_API_PTR *PFNGLMULTMATRIXFPROC)(const GLfloat *m);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORDP2UIPROC)(GLenum texture, GLenum type, GLuint coords);
+	typedef void(GLAD_API_PTR *PFNGLTEXIMAGE3DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels);
+	typedef void(GLAD_API_PTR *PFNGLGETNUNIFORMDVPROC)(GLuint program, GLint location, GLsizei bufSize, GLdouble *params);
+	typedef void(GLAD_API_PTR *PFNGLRECTIVPROC)(const GLint *v1, const GLint *v2);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD4SPROC)(GLshort s, GLshort t, GLshort r, GLshort q);
+	typedef void(GLAD_API_PTR *PFNGLCOPYTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+	typedef void(GLAD_API_PTR *PFNGLLOGICOPPROC)(GLenum opcode);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORMMATRIX2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+	typedef void(GLAD_API_PTR *PFNGLSECONDARYCOLOR3FVPROC)(const GLfloat *v);
+	typedef void(GLAD_API_PTR *PFNGLBINDRENDERBUFFERPROC)(GLenum target, GLuint renderbuffer);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM4UIVPROC)(GLuint program, GLint location, GLsizei count, const GLuint *value);
+	typedef void(GLAD_API_PTR *PFNGLCREATESAMPLERSPROC)(GLsizei n, GLuint *samplers);
+	typedef void(GLAD_API_PTR *PFNGLPIXELMAPUIVPROC)(GLenum map, GLsizei mapsize, const GLuint *values);
+	typedef void(GLAD_API_PTR *PFNGLBLENDCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+	typedef void(GLAD_API_PTR *PFNGLLIGHTMODELIPROC)(GLenum pname, GLint param);
+	typedef void(GLAD_API_PTR *PFNGLPOINTPARAMETERIPROC)(GLenum pname, GLint param);
+	typedef void(GLAD_API_PTR *PFNGLGENQUERIESPROC)(GLsizei n, GLuint *ids);
+	typedef void(GLAD_API_PTR *PFNGLNAMEDFRAMEBUFFERTEXTUREPROC)(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level);
+	typedef void(GLAD_API_PTR *PFNGLGETNSEPARABLEFILTERPROC)(GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, void *row, GLsizei columnBufSize, void *column, void *span);
+	typedef void(GLAD_API_PTR *PFNGLGETQUERYOBJECTUIVPROC)(GLuint id, GLenum pname, GLuint *params);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR4FVPROC)(const GLfloat *v);
+	typedef void(GLAD_API_PTR *PFNGLGETVERTEXARRAYIVPROC)(GLuint vaobj, GLenum pname, GLint *param);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM1UIPROC)(GLint location, GLuint v0);
+	typedef void(GLAD_API_PTR *PFNGLGETNMAPFVPROC)(GLenum target, GLenum query, GLsizei bufSize, GLfloat *v);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM4FVPROC)(GLint location, GLsizei count, const GLfloat *value);
+	typedef void(GLAD_API_PTR *PFNGLTEXGENFPROC)(GLenum coord, GLenum pname, GLfloat param);
+	typedef void(GLAD_API_PTR *PFNGLINDEXIVPROC)(const GLint *c);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB1FVPROC)(GLuint index, const GLfloat *v);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD3IPROC)(GLenum target, GLint s, GLint t, GLint r);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR4USVPROC)(const GLushort *v);
+	typedef void(GLAD_API_PTR *PFNGLDRAWBUFFERSPROC)(GLsizei n, const GLenum *bufs);
+	typedef void(GLAD_API_PTR *PFNGLWINDOWPOS2IPROC)(GLint x, GLint y);
+	typedef void(GLAD_API_PTR *PFNGLTEXBUFFERRANGEPROC)(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORDP1UIVPROC)(GLenum texture, GLenum type, const GLuint *coords);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBI2IVPROC)(GLuint index, const GLint *v);
+	typedef void(GLAD_API_PTR *PFNGLMULTIDRAWELEMENTSINDIRECTPROC)(GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORMMATRIX2X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM3IPROC)(GLint location, GLint v0, GLint v1, GLint v2);
+	typedef void(GLAD_API_PTR *PFNGLGETCLIPPLANEPROC)(GLenum plane, GLdouble *equation);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBP2UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD2IPROC)(GLint s, GLint t);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM4UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
+	typedef void(GLAD_API_PTR *PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB4NUSVPROC)(GLuint index, const GLushort *v);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB1DPROC)(GLuint index, GLdouble x);
+	typedef void(GLAD_API_PTR *PFNGLGETLIGHTIVPROC)(GLenum light, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+	typedef void(GLAD_API_PTR *PFNGLTEXTURESTORAGE1DPROC)(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width);
+	typedef void(GLAD_API_PTR *PFNGLSTENCILMASKPROC)(GLuint mask);
+	typedef void(GLAD_API_PTR *PFNGLGETRENDERBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD4FPROC)(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+	typedef void(GLAD_API_PTR *PFNGLINDEXDPROC)(GLdouble c);
+	typedef void(GLAD_API_PTR *PFNGLNORMALP3UIVPROC)(GLenum type, const GLuint *coords);
+	typedef void(GLAD_API_PTR *PFNGLEVALMESH1PROC)(GLenum mode, GLint i1, GLint i2);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORDP3UIVPROC)(GLenum type, const GLuint *coords);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBL4DVPROC)(GLuint index, const GLdouble *v);
+	typedef void(GLAD_API_PTR *PFNGLCLIENTACTIVETEXTUREPROC)(GLenum texture);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB2SPROC)(GLuint index, GLshort x, GLshort y);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB3DVPROC)(GLuint index, const GLdouble *v);
+	typedef void(GLAD_API_PTR *PFNGLTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, const GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLRASTERPOS3DPROC)(GLdouble x, GLdouble y, GLdouble z);
+	typedef void(GLAD_API_PTR *PFNGLEVALCOORD2FVPROC)(const GLfloat *u);
+	typedef void(GLAD_API_PTR *PFNGLBINDTEXTUREUNITPROC)(GLuint unit, GLuint texture);
+	typedef void(GLAD_API_PTR *PFNGLWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout);
+	typedef void(GLAD_API_PTR *PFNGLMATERIALFVPROC)(GLenum face, GLenum pname, const GLfloat *params);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM2IPROC)(GLuint program, GLint location, GLint v0, GLint v1);
+	typedef void(GLAD_API_PTR *PFNGLRASTERPOS2SPROC)(GLshort x, GLshort y);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBI4BVPROC)(GLuint index, const GLbyte *v);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBI4SVPROC)(GLuint index, const GLshort *v);
+	typedef void(GLAD_API_PTR *PFNGLBLENDEQUATIONSEPARATEPROC)(GLenum modeRGB, GLenum modeAlpha);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBI3UIVPROC)(GLuint index, const GLuint *v);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBI2UIVPROC)(GLuint index, const GLuint *v);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXP4UIVPROC)(GLenum type, const GLuint *value);
+	typedef GLuint(GLAD_API_PTR *PFNGLGETUNIFORMBLOCKINDEXPROC)(GLuint program, const GLchar *uniformBlockName);
+	typedef void(GLAD_API_PTR *PFNGLDEPTHFUNCPROC)(GLenum func);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM4FPROC)(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+	typedef void(GLAD_API_PTR *PFNGLSHADERSOURCEPROC)(GLuint shader, GLsizei count, const GLchar *const *string, const GLint *length);
+	typedef void(GLAD_API_PTR *PFNGLVERTEX2IVPROC)(const GLint *v);
+	typedef void *(GLAD_API_PTR *PFNGLMAPNAMEDBUFFERPROC)(GLuint buffer, GLenum access);
+	typedef void(GLAD_API_PTR *PFNGLCLEARDEPTHFPROC)(GLfloat d);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM1FPROC)(GLint location, GLfloat v0);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD1DPROC)(GLenum target, GLdouble s);
+	typedef void(GLAD_API_PTR *PFNGLGETQUERYOBJECTUI64VPROC)(GLuint id, GLenum pname, GLuint64 *params);
+	typedef void(GLAD_API_PTR *PFNGLNAMEDFRAMEBUFFERDRAWBUFFERSPROC)(GLuint framebuffer, GLsizei n, const GLenum *bufs);
+	typedef void(GLAD_API_PTR *PFNGLTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels);
+	typedef void(GLAD_API_PTR *PFNGLDELETETRANSFORMFEEDBACKSPROC)(GLsizei n, const GLuint *ids);
+	typedef void(GLAD_API_PTR *PFNGLVERTEX3IVPROC)(const GLint *v);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORMMATRIX2X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+	typedef GLboolean(GLAD_API_PTR *PFNGLISTEXTUREPROC)(GLuint texture);
+	typedef void(GLAD_API_PTR *PFNGLMULTTRANSPOSEMATRIXFPROC)(const GLfloat *m);
+	typedef void(GLAD_API_PTR *PFNGLNEWLISTPROC)(GLuint list, GLenum mode);
+	typedef void(GLAD_API_PTR *PFNGLSCALEFPROC)(GLfloat x, GLfloat y, GLfloat z);
+	typedef void(GLAD_API_PTR *PFNGLVERTEX3FPROC)(GLfloat x, GLfloat y, GLfloat z);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD1IVPROC)(const GLint *v);
+	typedef void(GLAD_API_PTR *PFNGLFOGCOORDFVPROC)(const GLfloat *coord);
+	typedef void(GLAD_API_PTR *PFNGLMAPGRID2DPROC)(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
+	typedef void(GLAD_API_PTR *PFNGLWINDOWPOS2FVPROC)(const GLfloat *v);
+	typedef void(GLAD_API_PTR *PFNGLREADPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels);
+	typedef void(GLAD_API_PTR *PFNGLINVALIDATETEXSUBIMAGEPROC)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth);
+	typedef void(GLAD_API_PTR *PFNGLORTHOPROC)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+	typedef void(GLAD_API_PTR *PFNGLGETQUERYOBJECTIVPROC)(GLuint id, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLWINDOWPOS2SVPROC)(const GLshort *v);
+	typedef void(GLAD_API_PTR *PFNGLFOGFPROC)(GLenum pname, GLfloat param);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR3SPROC)(GLshort red, GLshort green, GLshort blue);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM2UIVPROC)(GLint location, GLsizei count, const GLuint *value);
+	typedef void(GLAD_API_PTR *PFNGLPIXELZOOMPROC)(GLfloat xfactor, GLfloat yfactor);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM3FPROC)(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+	typedef void(GLAD_API_PTR *PFNGLEVALCOORD2DVPROC)(const GLdouble *u);
+	typedef void(GLAD_API_PTR *PFNGLVERTEX3DVPROC)(const GLdouble *v);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM3FVPROC)(GLint location, GLsizei count, const GLfloat *value);
+	typedef void(GLAD_API_PTR *PFNGLENABLEPROC)(GLenum cap);
+	typedef void(GLAD_API_PTR *PFNGLTEXTUREPARAMETERIUIVPROC)(GLuint texture, GLenum pname, const GLuint *params);
+	typedef void(GLAD_API_PTR *PFNGLFOGCOORDDVPROC)(const GLdouble *coord);
+	typedef void(GLAD_API_PTR *PFNGLBUFFERDATAPROC)(GLenum target, GLsizeiptr size, const void *data, GLenum usage);
+	typedef void(GLAD_API_PTR *PFNGLPOPATTRIBPROC)(void);
+	typedef void(GLAD_API_PTR *PFNGLNORMAL3DVPROC)(const GLdouble *v);
+	typedef GLint(GLAD_API_PTR *PFNGLGETFRAGDATAINDEXPROC)(GLuint program, const GLchar *name);
+	typedef void(GLAD_API_PTR *PFNGLPASSTHROUGHPROC)(GLfloat token);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD2DVPROC)(const GLdouble *v);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORDP4UIVPROC)(GLenum type, const GLuint *coords);
+	typedef void(GLAD_API_PTR *PFNGLCLEARBUFFERUIVPROC)(GLenum buffer, GLint drawbuffer, const GLuint *value);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM3DVPROC)(GLint location, GLsizei count, const GLdouble *value);
+	typedef void(GLAD_API_PTR *PFNGLBLENDEQUATIONIPROC)(GLuint buf, GLenum mode);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBI4UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
+	typedef void(GLAD_API_PTR *PFNGLGETTEXLEVELPARAMETERIVPROC)(GLenum target, GLint level, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLVERTEX4IPROC)(GLint x, GLint y, GLint z, GLint w);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM4UIVPROC)(GLint location, GLsizei count, const GLuint *value);
+	typedef void(GLAD_API_PTR *PFNGLTEXENVFVPROC)(GLenum target, GLenum pname, const GLfloat *params);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD4DVPROC)(GLenum target, const GLdouble *v);
+	typedef void(GLAD_API_PTR *PFNGLCLEARTEXSUBIMAGEPROC)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data);
+	typedef void(GLAD_API_PTR *PFNGLTRANSLATEDPROC)(GLdouble x, GLdouble y, GLdouble z);
+	typedef void(GLAD_API_PTR *PFNGLPOINTPARAMETERFPROC)(GLenum pname, GLfloat param);
+	typedef void(GLAD_API_PTR *PFNGLSCISSORINDEXEDVPROC)(GLuint index, const GLint *v);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM2DVPROC)(GLuint program, GLint location, GLsizei count, const GLdouble *value);
+	typedef void(GLAD_API_PTR *PFNGLREADBUFFERPROC)(GLenum src);
+	typedef void(GLAD_API_PTR *PFNGLENDPROC)(void);
+	typedef void(GLAD_API_PTR *PFNGLDRAWARRAYSINSTANCEDPROC)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB4UIVPROC)(GLuint index, const GLuint *v);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBI4UBVPROC)(GLuint index, const GLubyte *v);
+	typedef void(GLAD_API_PTR *PFNGLCOMPRESSEDTEXTURESUBIMAGE1DPROC)(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data);
+	typedef void(GLAD_API_PTR *PFNGLVERTEX2DVPROC)(const GLdouble *v);
+	typedef void(GLAD_API_PTR *PFNGLPUSHNAMEPROC)(GLuint name);
+	typedef void(GLAD_API_PTR *PFNGLINVALIDATEBUFFERDATAPROC)(GLuint buffer);
+	typedef void(GLAD_API_PTR *PFNGLPOINTPARAMETERIVPROC)(GLenum pname, const GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLGENTEXTURESPROC)(GLsizei n, GLuint *textures);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD4FVPROC)(const GLfloat *v);
+	typedef void(GLAD_API_PTR *PFNGLDISPATCHCOMPUTEPROC)(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z);
+	typedef void(GLAD_API_PTR *PFNGLGETUNIFORMUIVPROC)(GLuint program, GLint location, GLuint *params);
+	typedef void(GLAD_API_PTR *PFNGLGETACTIVEUNIFORMSIVPROC)(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLGETPROGRAMRESOURCENAMEPROC)(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name);
+	typedef void(GLAD_API_PTR *PFNGLVERTEX2FVPROC)(const GLfloat *v);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR4UBPROC)(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM3IVPROC)(GLint location, GLsizei count, const GLint *value);
+	typedef void(GLAD_API_PTR *PFNGLCLIPPLANEPROC)(GLenum plane, const GLdouble *equation);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM4IPROC)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+	typedef void(GLAD_API_PTR *PFNGLWINDOWPOS3IVPROC)(const GLint *v);
+	typedef void(GLAD_API_PTR *PFNGLSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, const GLint *param);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM2DPROC)(GLint location, GLdouble x, GLdouble y);
+	typedef void(GLAD_API_PTR *PFNGLPOPMATRIXPROC)(void);
+	typedef void(GLAD_API_PTR *PFNGLVALIDATEPROGRAMPIPELINEPROC)(GLuint pipeline);
+	typedef void(GLAD_API_PTR *PFNGLRASTERPOS3DVPROC)(const GLdouble *v);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD1FVPROC)(const GLfloat *v);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD2IVPROC)(const GLint *v);
+	typedef void(GLAD_API_PTR *PFNGLCOPYTEXTURESUBIMAGE2DPROC)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+	typedef void(GLAD_API_PTR *PFNGLGETATTACHEDSHADERSPROC)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders);
+	typedef void(GLAD_API_PTR *PFNGLGETTRANSFORMFEEDBACKI_VPROC)(GLuint xfb, GLenum pname, GLuint index, GLint *param);
+	typedef void(GLAD_API_PTR *PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLenum target, GLenum attachment, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXARRAYATTRIBIFORMATPROC)(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
+	typedef void(GLAD_API_PTR *PFNGLOBJECTPTRLABELPROC)(const void *ptr, GLsizei length, const GLchar *label);
+	typedef void(GLAD_API_PTR *PFNGLGETNPIXELMAPUSVPROC)(GLenum map, GLsizei bufSize, GLushort *values);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM1FPROC)(GLuint program, GLint location, GLfloat v0);
+	typedef void(GLAD_API_PTR *PFNGLCLEARSTENCILPROC)(GLint s);
+	typedef void(GLAD_API_PTR *PFNGLDISABLEPROC)(GLenum cap);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB4FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+	typedef GLuint(GLAD_API_PTR *PFNGLGETSUBROUTINEINDEXPROC)(GLuint program, GLenum shadertype, const GLchar *name);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD2DPROC)(GLenum target, GLdouble s, GLdouble t);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORDP3UIVPROC)(GLenum texture, GLenum type, const GLuint *coords);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD3FVPROC)(GLenum target, const GLfloat *v);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM4IVPROC)(GLint location, GLsizei count, const GLint *value);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBDIVISORPROC)(GLuint index, GLuint divisor);
+	typedef void(GLAD_API_PTR *PFNGLBINDFRAGDATALOCATIONPROC)(GLuint program, GLuint color, const GLchar *name);
+	typedef void(GLAD_API_PTR *PFNGLGETNCOMPRESSEDTEXIMAGEPROC)(GLenum target, GLint lod, GLsizei bufSize, void *pixels);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORMMATRIX3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB2FVPROC)(GLuint index, const GLfloat *v);
+	typedef void(GLAD_API_PTR *PFNGLEVALCOORD2DPROC)(GLdouble u, GLdouble v);
+	typedef void(GLAD_API_PTR *PFNGLGETPOINTERVPROC)(GLenum pname, void **params);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM4DPROC)(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD2FPROC)(GLfloat s, GLfloat t);
+	typedef void(GLAD_API_PTR *PFNGLCOPYBUFFERSUBDATAPROC)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORMMATRIX3DVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+	typedef void(GLAD_API_PTR *PFNGLSECONDARYCOLOR3IVPROC)(const GLint *v);
+	typedef void(GLAD_API_PTR *PFNGLFINISHPROC)(void);
+	typedef GLboolean(GLAD_API_PTR *PFNGLISPROGRAMPIPELINEPROC)(GLuint pipeline);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBP1UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
+	typedef void(GLAD_API_PTR *PFNGLGETNMAPDVPROC)(GLenum target, GLenum query, GLsizei bufSize, GLdouble *v);
+	typedef void(GLAD_API_PTR *PFNGLBINDTEXTURESPROC)(GLuint first, GLsizei count, const GLuint *textures);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORDP3UIPROC)(GLenum texture, GLenum type, GLuint coords);
+	typedef void(GLAD_API_PTR *PFNGLCOLORMASKIPROC)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
+	typedef void(GLAD_API_PTR *PFNGLGETQUERYOBJECTI64VPROC)(GLuint id, GLenum pname, GLint64 *params);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD3SPROC)(GLenum target, GLshort s, GLshort t, GLshort r);
+	typedef void(GLAD_API_PTR *PFNGLWINDOWPOS2DPROC)(GLdouble x, GLdouble y);
+	typedef void(GLAD_API_PTR *PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance);
+	typedef void(GLAD_API_PTR *PFNGLDRAWTRANSFORMFEEDBACKPROC)(GLenum mode, GLuint id);
+	typedef void(GLAD_API_PTR *PFNGLWINDOWPOS2FPROC)(GLfloat x, GLfloat y);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBLPOINTERPROC)(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD4FPROC)(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+	typedef void(GLAD_API_PTR *PFNGLLIGHTMODELIVPROC)(GLenum pname, const GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM2UIPROC)(GLint location, GLuint v0, GLuint v1);
+	typedef void(GLAD_API_PTR *PFNGLDELETEVERTEXARRAYSPROC)(GLsizei n, const GLuint *arrays);
+	typedef void(GLAD_API_PTR *PFNGLTEXBUFFERPROC)(GLenum target, GLenum internalformat, GLuint buffer);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM2FPROC)(GLint location, GLfloat v0, GLfloat v1);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD1DPROC)(GLdouble s);
+	typedef void(GLAD_API_PTR *PFNGLCOMPRESSEDTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data);
+	typedef GLenum(GLAD_API_PTR *PFNGLGETGRAPHICSRESETSTATUSPROC)(void);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD1SPROC)(GLshort s);
+	typedef void(GLAD_API_PTR *PFNGLINDEXSVPROC)(const GLshort *c);
+	typedef void(GLAD_API_PTR *PFNGLRASTERPOS4IVPROC)(const GLint *v);
+	typedef void(GLAD_API_PTR *PFNGLSECONDARYCOLOR3IPROC)(GLint red, GLint green, GLint blue);
+	typedef void(GLAD_API_PTR *PFNGLCALLLISTPROC)(GLuint list);
+	typedef void(GLAD_API_PTR *PFNGLINDEXUBVPROC)(const GLubyte *c);
+	typedef void(GLAD_API_PTR *PFNGLPOLYGONMODEPROC)(GLenum face, GLenum mode);
+	typedef void(GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTUREPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORMMATRIX3X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+	typedef GLboolean(GLAD_API_PTR *PFNGLISTRANSFORMFEEDBACKPROC)(GLuint id);
+	typedef void(GLAD_API_PTR *PFNGLNAMEDBUFFERSUBDATAPROC)(GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data);
+	typedef void(GLAD_API_PTR *PFNGLGETPROGRAMINTERFACEIVPROC)(GLuint program, GLenum programInterface, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLDISABLECLIENTSTATEPROC)(GLenum array);
+	typedef void(GLAD_API_PTR *PFNGLCLEARNAMEDFRAMEBUFFERUIVPROC)(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint *value);
+	typedef void(GLAD_API_PTR *PFNGLGETTEXPARAMETERFVPROC)(GLenum target, GLenum pname, GLfloat *params);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXARRAYATTRIBLFORMATPROC)(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
+	typedef void(GLAD_API_PTR *PFNGLVERTEX4DPROC)(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+	typedef void(GLAD_API_PTR *PFNGLNORMAL3SVPROC)(const GLshort *v);
+	typedef void(GLAD_API_PTR *PFNGLRASTERPOS4FPROC)(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORDP4UIPROC)(GLenum type, GLuint coords);
+	typedef void(GLAD_API_PTR *PFNGLGENRENDERBUFFERSPROC)(GLsizei n, GLuint *renderbuffers);
+	typedef void(GLAD_API_PTR *PFNGLTRANSFORMFEEDBACKVARYINGSPROC)(GLuint program, GLsizei count, const GLchar *const *varyings, GLenum bufferMode);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM4FVPROC)(GLuint program, GLint location, GLsizei count, const GLfloat *value);
+	typedef void(GLAD_API_PTR *PFNGLNAMEDFRAMEBUFFERREADBUFFERPROC)(GLuint framebuffer, GLenum src);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORMMATRIX2X3DVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBL3DVPROC)(GLuint index, const GLdouble *v);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM1UIVPROC)(GLint location, GLsizei count, const GLuint *value);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD1SVPROC)(const GLshort *v);
+	typedef void(GLAD_API_PTR *PFNGLGETINTEGERI_VPROC)(GLenum target, GLuint index, GLint *data);
+	typedef void(GLAD_API_PTR *PFNGLTEXTURESUBIMAGE2DPROC)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);
+	typedef void(GLAD_API_PTR *PFNGLNAMEDRENDERBUFFERSTORAGEPROC)(GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height);
+	typedef void(GLAD_API_PTR *PFNGLGETMAPIVPROC)(GLenum target, GLenum query, GLint *v);
+	typedef void(GLAD_API_PTR *PFNGLMATRIXMODEPROC)(GLenum mode);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBI4UIVPROC)(GLuint index, const GLuint *v);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBL1DVPROC)(GLuint index, const GLdouble *v);
+	typedef void(GLAD_API_PTR *PFNGLGETNAMEDBUFFERSUBDATAPROC)(GLuint buffer, GLintptr offset, GLsizeiptr size, void *data);
+	typedef void(GLAD_API_PTR *PFNGLGENVERTEXARRAYSPROC)(GLsizei n, GLuint *arrays);
+	typedef void(GLAD_API_PTR *PFNGLGETTEXTUREPARAMETERIVPROC)(GLuint texture, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLVERTEX3FVPROC)(const GLfloat *v);
+	typedef void(GLAD_API_PTR *PFNGLMATERIALIVPROC)(GLenum face, GLenum pname, const GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLPIXELTRANSFERIPROC)(GLenum pname, GLint param);
+	typedef void(GLAD_API_PTR *PFNGLGETNHISTOGRAMPROC)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void *values);
+	typedef GLuint(GLAD_API_PTR *PFNGLCREATESHADERPROGRAMVPROC)(GLenum type, GLsizei count, const GLchar *const *strings);
+	typedef void(GLAD_API_PTR *PFNGLENABLEVERTEXARRAYATTRIBPROC)(GLuint vaobj, GLuint index);
+	typedef void(GLAD_API_PTR *PFNGLENDCONDITIONALRENDERPROC)(void);
+	typedef void(GLAD_API_PTR *PFNGLDELETELISTSPROC)(GLuint list, GLsizei range);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD2SVPROC)(const GLshort *v);
+	typedef void(GLAD_API_PTR *PFNGLDEBUGMESSAGECALLBACKPROC)(GLDEBUGPROC callback, const void *userParam);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD1FPROC)(GLenum target, GLfloat s);
+	typedef void(GLAD_API_PTR *PFNGLGETCOMPRESSEDTEXIMAGEPROC)(GLenum target, GLint level, void *img);
+	typedef GLenum(GLAD_API_PTR *PFNGLCHECKFRAMEBUFFERSTATUSPROC)(GLenum target);
+	typedef void(GLAD_API_PTR *PFNGLGETINTERNALFORMATI64VPROC)(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params);
+	typedef void(GLAD_API_PTR *PFNGLGENERATEMIPMAPPROC)(GLenum target);
+	typedef void(GLAD_API_PTR *PFNGLDELETEQUERIESPROC)(GLsizei n, const GLuint *ids);
+	typedef void(GLAD_API_PTR *PFNGLNAMEDFRAMEBUFFERPARAMETERIPROC)(GLuint framebuffer, GLenum pname, GLint param);
+	typedef void(GLAD_API_PTR *PFNGLDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM1DPROC)(GLuint program, GLint location, GLdouble v0);
+	typedef void(GLAD_API_PTR *PFNGLALPHAFUNCPROC)(GLenum func, GLfloat ref);
+	typedef void(GLAD_API_PTR *PFNGLTRANSFORMFEEDBACKBUFFERRANGEPROC)(GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
+	typedef void(GLAD_API_PTR *PFNGLLINESTIPPLEPROC)(GLint factor, GLushort pattern);
+	typedef void(GLAD_API_PTR *PFNGLTEXGENIPROC)(GLenum coord, GLenum pname, GLint param);
+	typedef void(GLAD_API_PTR *PFNGLTEXSTORAGE3DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
+	typedef GLboolean(GLAD_API_PTR *PFNGLISVERTEXARRAYPROC)(GLuint array);
+	typedef void(GLAD_API_PTR *PFNGLGETNAMEDRENDERBUFFERPARAMETERIVPROC)(GLuint renderbuffer, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLINVALIDATEFRAMEBUFFERPROC)(GLenum target, GLsizei numAttachments, const GLenum *attachments);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMBINARYPROC)(GLuint program, GLenum binaryFormat, const void *binary, GLsizei length);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD4DVPROC)(const GLdouble *v);
+	typedef void(GLAD_API_PTR *PFNGLVERTEX3IPROC)(GLint x, GLint y, GLint z);
+	typedef void(GLAD_API_PTR *PFNGLSECONDARYCOLOR3BPROC)(GLbyte red, GLbyte green, GLbyte blue);
+	typedef void(GLAD_API_PTR *PFNGLRASTERPOS4SVPROC)(const GLshort *v);
+	typedef void(GLAD_API_PTR *PFNGLDISABLEIPROC)(GLenum target, GLuint index);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB1SVPROC)(GLuint index, const GLshort *v);
+	typedef void(GLAD_API_PTR *PFNGLINVALIDATETEXIMAGEPROC)(GLuint texture, GLint level);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBI2IPROC)(GLuint index, GLint x, GLint y);
+	typedef void(GLAD_API_PTR *PFNGLINDEXFPROC)(GLfloat c);
+	typedef void(GLAD_API_PTR *PFNGLPRIMITIVERESTARTINDEXPROC)(GLuint index);
+	typedef void(GLAD_API_PTR *PFNGLGETNCONVOLUTIONFILTERPROC)(GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *image);
+	typedef GLenum(GLAD_API_PTR *PFNGLGETERRORPROC)(void);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB4BVPROC)(GLuint index, const GLbyte *v);
+	typedef void(GLAD_API_PTR *PFNGLFLUSHMAPPEDBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORDP1UIPROC)(GLenum type, GLuint coords);
+	typedef void(GLAD_API_PTR *PFNGLSAMPLECOVERAGEPROC)(GLfloat value, GLboolean invert);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD2IVPROC)(GLenum target, const GLint *v);
+	typedef GLboolean(GLAD_API_PTR *PFNGLISPROGRAMPROC)(GLuint program);
+	typedef GLboolean(GLAD_API_PTR *PFNGLISLISTPROC)(GLuint list);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB2DVPROC)(GLuint index, const GLdouble *v);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB3FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z);
+	typedef void(GLAD_API_PTR *PFNGLTEXPARAMETERIPROC)(GLenum target, GLenum pname, GLint param);
+	typedef void(GLAD_API_PTR *PFNGLPUSHATTRIBPROC)(GLbitfield mask);
+	typedef void(GLAD_API_PTR *PFNGLFRONTFACEPROC)(GLenum mode);
+	typedef void(GLAD_API_PTR *PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD1SPROC)(GLenum target, GLshort s);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBI3IPROC)(GLuint index, GLint x, GLint y, GLint z);
+	typedef void(GLAD_API_PTR *PFNGLCOPYTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+	typedef void(GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTURE3DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
+	typedef void(GLAD_API_PTR *PFNGLGENSAMPLERSPROC)(GLsizei count, GLuint *samplers);
+	typedef void(GLAD_API_PTR *PFNGLSAMPLERPARAMETERFPROC)(GLuint sampler, GLenum pname, GLfloat param);
+	typedef void(GLAD_API_PTR *PFNGLRASTERPOS4FVPROC)(const GLfloat *v);
+	typedef void(GLAD_API_PTR *PFNGLPAUSETRANSFORMFEEDBACKPROC)(void);
+	typedef void(GLAD_API_PTR *PFNGLPOPNAMEPROC)(void);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBI1IVPROC)(GLuint index, const GLint *v);
+	typedef void(GLAD_API_PTR *PFNGLEVALCOORD1FPROC)(GLfloat u);
+	typedef void(GLAD_API_PTR *PFNGLGENFRAMEBUFFERSPROC)(GLsizei n, GLuint *framebuffers);
+	typedef void(GLAD_API_PTR *PFNGLLIGHTIPROC)(GLenum light, GLenum pname, GLint param);
+	typedef void(GLAD_API_PTR *PFNGLTEXTUREVIEWPROC)(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers);
+	typedef void(GLAD_API_PTR *PFNGLLOADTRANSPOSEMATRIXDPROC)(const GLdouble *m);
+	typedef void(GLAD_API_PTR *PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM4DPROC)(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBI3UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z);
+	typedef void(GLAD_API_PTR *PFNGLEDGEFLAGPOINTERPROC)(GLsizei stride, const void *pointer);
+	typedef void(GLAD_API_PTR *PFNGLSTENCILFUNCPROC)(GLenum func, GLint ref, GLuint mask);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM1IPROC)(GLint location, GLint v0);
+	typedef void(GLAD_API_PTR *PFNGLGETTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, GLuint *params);
+	typedef void(GLAD_API_PTR *PFNGLINVALIDATENAMEDFRAMEBUFFERDATAPROC)(GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments);
+	typedef void(GLAD_API_PTR *PFNGLPATCHPARAMETERFVPROC)(GLenum pname, const GLfloat *values);
+	typedef void(GLAD_API_PTR *PFNGLFOGFVPROC)(GLenum pname, const GLfloat *params);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXP3UIPROC)(GLenum type, GLuint value);
+	typedef void(GLAD_API_PTR *PFNGLREADNPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD1IPROC)(GLenum target, GLint s);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBBINDINGPROC)(GLuint attribindex, GLuint bindingindex);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD3DVPROC)(GLenum target, const GLdouble *v);
+	typedef void(GLAD_API_PTR *PFNGLVERTEX4SPROC)(GLshort x, GLshort y, GLshort z, GLshort w);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXBINDINGDIVISORPROC)(GLuint bindingindex, GLuint divisor);
+	typedef void(GLAD_API_PTR *PFNGLTEXTUREPARAMETERFVPROC)(GLuint texture, GLenum pname, const GLfloat *param);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+	typedef void(GLAD_API_PTR *PFNGLNORMAL3BPROC)(GLbyte nx, GLbyte ny, GLbyte nz);
+	typedef void(GLAD_API_PTR *PFNGLGETUNIFORMSUBROUTINEUIVPROC)(GLenum shadertype, GLint location, GLuint *params);
+	typedef void(GLAD_API_PTR *PFNGLVERTEX3SVPROC)(const GLshort *v);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD3SVPROC)(GLenum target, const GLshort *v);
+	typedef void(GLAD_API_PTR *PFNGLGETNAMEDBUFFERPARAMETERI64VPROC)(GLuint buffer, GLenum pname, GLint64 *params);
+	typedef void(GLAD_API_PTR *PFNGLDRAWPIXELSPROC)(GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);
+	typedef void(GLAD_API_PTR *PFNGLCALLLISTSPROC)(GLsizei n, GLenum type, const void *lists);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD3IPROC)(GLint s, GLint t, GLint r);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM2UIPROC)(GLuint program, GLint location, GLuint v0, GLuint v1);
+	typedef void(GLAD_API_PTR *PFNGLQUERYCOUNTERPROC)(GLuint id, GLenum target);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM1IVPROC)(GLint location, GLsizei count, const GLint *value);
+	typedef void(GLAD_API_PTR *PFNGLSTENCILFUNCSEPARATEPROC)(GLenum face, GLenum func, GLint ref, GLuint mask);
+	typedef void(GLAD_API_PTR *PFNGLGETNAMEDBUFFERPARAMETERIVPROC)(GLuint buffer, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX2DVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+	typedef void(GLAD_API_PTR *PFNGLGETACTIVEATTRIBPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
+	typedef void(GLAD_API_PTR *PFNGLENABLEVERTEXATTRIBARRAYPROC)(GLuint index);
+	typedef void(GLAD_API_PTR *PFNGLMATERIALIPROC)(GLenum face, GLenum pname, GLint param);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM2FVPROC)(GLint location, GLsizei count, const GLfloat *value);
+	typedef void(GLAD_API_PTR *PFNGLRASTERPOS3FVPROC)(const GLfloat *v);
+	typedef GLint(GLAD_API_PTR *PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC)(GLuint program, GLenum programInterface, const GLchar *name);
+	typedef void(GLAD_API_PTR *PFNGLGETDOUBLEVPROC)(GLenum pname, GLdouble *data);
+	typedef void(GLAD_API_PTR *PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORMMATRIX2X4DVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR4BVPROC)(const GLbyte *v);
+	typedef void(GLAD_API_PTR *PFNGLGETINTERNALFORMATIVPROC)(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC)(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values);
+	typedef void(GLAD_API_PTR *PFNGLGETQUERYINDEXEDIVPROC)(GLenum target, GLuint index, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLBINDVERTEXBUFFERPROC)(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD3FPROC)(GLfloat s, GLfloat t, GLfloat r);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR3UIVPROC)(const GLuint *v);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB4NBVPROC)(GLuint index, const GLbyte *v);
+	typedef void(GLAD_API_PTR *PFNGLCLEARPROC)(GLbitfield mask);
+	typedef void(GLAD_API_PTR *PFNGLRASTERPOS2DVPROC)(const GLdouble *v);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD2SPROC)(GLshort s, GLshort t);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBP4UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value);
+	typedef void(GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTURELAYERPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
+	typedef void(GLAD_API_PTR *PFNGLTEXENVIPROC)(GLenum target, GLenum pname, GLint param);
+	typedef void(GLAD_API_PTR *PFNGLTEXTUREPARAMETERFPROC)(GLuint texture, GLenum pname, GLfloat param);
+	typedef void(GLAD_API_PTR *PFNGLMATERIALFPROC)(GLenum face, GLenum pname, GLfloat param);
+	typedef void(GLAD_API_PTR *PFNGLGETUNIFORMDVPROC)(GLuint program, GLint location, GLdouble *params);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM3IVPROC)(GLuint program, GLint location, GLsizei count, const GLint *value);
+	typedef void(GLAD_API_PTR *PFNGLTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, const GLuint *params);
+	typedef void(GLAD_API_PTR *PFNGLCLEARINDEXPROC)(GLfloat c);
+	typedef void(GLAD_API_PTR *PFNGLDISPATCHCOMPUTEINDIRECTPROC)(GLintptr indirect);
+	typedef void(GLAD_API_PTR *PFNGLROTATEFPROC)(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
+	typedef void(GLAD_API_PTR *PFNGLTEXTURESUBIMAGE1DPROC)(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels);
+	typedef void(GLAD_API_PTR *PFNGLPOLYGONOFFSETCLAMPPROC)(GLfloat factor, GLfloat units, GLfloat clamp);
+	typedef void(GLAD_API_PTR *PFNGLSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, const GLuint *param);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM4IVPROC)(GLuint program, GLint location, GLsizei count, const GLint *value);
+	typedef void(GLAD_API_PTR *PFNGLSECONDARYCOLOR3SPROC)(GLshort red, GLshort green, GLshort blue);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+	typedef void(GLAD_API_PTR *PFNGLGETVERTEXATTRIBLDVPROC)(GLuint index, GLenum pname, GLdouble *params);
+	typedef void(GLAD_API_PTR *PFNGLRASTERPOS2FVPROC)(const GLfloat *v);
+	typedef void(GLAD_API_PTR *PFNGLSHADEMODELPROC)(GLenum mode);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM4DVPROC)(GLuint program, GLint location, GLsizei count, const GLdouble *value);
+	typedef void(GLAD_API_PTR *PFNGLNORMAL3FVPROC)(const GLfloat *v);
+	typedef GLboolean(GLAD_API_PTR *PFNGLISBUFFERPROC)(GLuint buffer);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD3FPROC)(GLenum target, GLfloat s, GLfloat t, GLfloat r);
+	typedef void(GLAD_API_PTR *PFNGLBINDFRAMEBUFFERPROC)(GLenum target, GLuint framebuffer);
+	typedef void(GLAD_API_PTR *PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name);
+	typedef void(GLAD_API_PTR *PFNGLBINDBUFFERBASEPROC)(GLenum target, GLuint index, GLuint buffer);
+	typedef void(GLAD_API_PTR *PFNGLGENBUFFERSPROC)(GLsizei n, GLuint *buffers);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD1FPROC)(GLfloat s);
+	typedef void(GLAD_API_PTR *PFNGLGETBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, void *data);
+	typedef void(GLAD_API_PTR *PFNGLCREATETRANSFORMFEEDBACKSPROC)(GLsizei n, GLuint *ids);
+	typedef void(GLAD_API_PTR *PFNGLMAP2FPROC)(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
+	typedef void(GLAD_API_PTR *PFNGLCREATEBUFFERSPROC)(GLsizei n, GLuint *buffers);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR3USVPROC)(const GLushort *v);
+	typedef void(GLAD_API_PTR *PFNGLGETSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, GLfloat *params);
+	typedef GLint(GLAD_API_PTR *PFNGLGETUNIFORMLOCATIONPROC)(GLuint program, const GLchar *name);
+	typedef void(GLAD_API_PTR *PFNGLVERTEX2DPROC)(GLdouble x, GLdouble y);
+	typedef GLint(GLAD_API_PTR *PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC)(GLuint program, GLenum shadertype, const GLchar *name);
+	typedef void(GLAD_API_PTR *PFNGLINVALIDATEBUFFERSUBDATAPROC)(GLuint buffer, GLintptr offset, GLsizeiptr length);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORMMATRIX2DVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+	typedef void(GLAD_API_PTR *PFNGLCLEARNAMEDBUFFERSUBDATAPROC)(GLuint buffer, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data);
+	typedef void(GLAD_API_PTR *PFNGLGETPROGRAMIVPROC)(GLuint program, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLDRAWRANGEELEMENTSPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX4FVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+	typedef void(GLAD_API_PTR *PFNGLGETINTEGER64I_VPROC)(GLenum target, GLuint index, GLint64 *data);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBL1DPROC)(GLuint index, GLdouble x);
+	typedef void(GLAD_API_PTR *PFNGLGETTEXTUREIMAGEPROC)(GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels);
+	typedef void(GLAD_API_PTR *PFNGLGETNUNIFORMIVPROC)(GLuint program, GLint location, GLsizei bufSize, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM1IPROC)(GLuint program, GLint location, GLint v0);
+	typedef void(GLAD_API_PTR *PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC)(GLenum mode, GLuint id, GLsizei instancecount);
+	typedef GLuint(GLAD_API_PTR *PFNGLGETPROGRAMRESOURCEINDEXPROC)(GLuint program, GLenum programInterface, const GLchar *name);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM2DPROC)(GLuint program, GLint location, GLdouble v0, GLdouble v1);
+	typedef GLboolean(GLAD_API_PTR *PFNGLUNMAPNAMEDBUFFERPROC)(GLuint buffer);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD2FPROC)(GLenum target, GLfloat s, GLfloat t);
+	typedef void(GLAD_API_PTR *PFNGLPOINTPARAMETERFVPROC)(GLenum pname, const GLfloat *params);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX3FVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+	typedef void(GLAD_API_PTR *PFNGLBINDBUFFERRANGEPROC)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD2DVPROC)(GLenum target, const GLdouble *v);
+	typedef void(GLAD_API_PTR *PFNGLCOLORMATERIALPROC)(GLenum face, GLenum mode);
+	typedef void(GLAD_API_PTR *PFNGLBLENDEQUATIONPROC)(GLenum mode);
+	typedef void(GLAD_API_PTR *PFNGLBLITFRAMEBUFFERPROC)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR3DPROC)(GLdouble red, GLdouble green, GLdouble blue);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD3IVPROC)(GLenum target, const GLint *v);
+	typedef void(GLAD_API_PTR *PFNGLLIGHTFVPROC)(GLenum light, GLenum pname, const GLfloat *params);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB1DVPROC)(GLuint index, const GLdouble *v);
+	typedef void(GLAD_API_PTR *PFNGLDEPTHMASKPROC)(GLboolean flag);
+	typedef void(GLAD_API_PTR *PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM1UIPROC)(GLuint program, GLint location, GLuint v0);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBL3DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z);
+	typedef void(GLAD_API_PTR *PFNGLDRAWELEMENTSINDIRECTPROC)(GLenum mode, GLenum type, const void *indirect);
+	typedef void(GLAD_API_PTR *PFNGLLOADTRANSPOSEMATRIXFPROC)(const GLfloat *m);
+	typedef void(GLAD_API_PTR *PFNGLENDQUERYINDEXEDPROC)(GLenum target, GLuint index);
+	typedef void(GLAD_API_PTR *PFNGLSECONDARYCOLOR3USPROC)(GLushort red, GLushort green, GLushort blue);
+	typedef void(GLAD_API_PTR *PFNGLTEXTURESTORAGE2DMULTISAMPLEPROC)(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
+	typedef void(GLAD_API_PTR *PFNGLPIXELSTOREFPROC)(GLenum pname, GLfloat param);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM2IVPROC)(GLint location, GLsizei count, const GLint *value);
+	typedef void(GLAD_API_PTR *PFNGLRASTERPOS2SVPROC)(const GLshort *v);
+	typedef void(GLAD_API_PTR *PFNGLVERTEX2IPROC)(GLint x, GLint y);
+	typedef void(GLAD_API_PTR *PFNGLFRUSTUMPROC)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+	typedef void(GLAD_API_PTR *PFNGLMEMORYBARRIERPROC)(GLbitfield barriers);
+	typedef const GLubyte *(GLAD_API_PTR *PFNGLGETSTRINGPROC)(GLenum name);
+	typedef void(GLAD_API_PTR *PFNGLLINEWIDTHPROC)(GLfloat width);
+	typedef void(GLAD_API_PTR *PFNGLNORMALPOINTERPROC)(GLenum type, GLsizei stride, const void *pointer);
+	typedef void(GLAD_API_PTR *PFNGLGETNUNIFORMUIVPROC)(GLuint program, GLint location, GLsizei bufSize, GLuint *params);
+	typedef void(GLAD_API_PTR *PFNGLDEPTHRANGEARRAYVPROC)(GLuint first, GLsizei count, const GLdouble *v);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORDP2UIPROC)(GLenum type, GLuint coords);
+	typedef void(GLAD_API_PTR *PFNGLATTACHSHADERPROC)(GLuint program, GLuint shader);
+	typedef void(GLAD_API_PTR *PFNGLDRAWARRAYSPROC)(GLenum mode, GLint first, GLsizei count);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR4SPROC)(GLshort red, GLshort green, GLshort blue, GLshort alpha);
+	typedef void(GLAD_API_PTR *PFNGLTEXGENDVPROC)(GLenum coord, GLenum pname, const GLdouble *params);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+	typedef void(GLAD_API_PTR *PFNGLGETSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, GLuint *params);
+	typedef void(GLAD_API_PTR *PFNGLENDQUERYPROC)(GLenum target);
+	typedef void(GLAD_API_PTR *PFNGLWINDOWPOS2SPROC)(GLshort x, GLshort y);
+	typedef void(GLAD_API_PTR *PFNGLDRAWARRAYSINDIRECTPROC)(GLenum mode, const void *indirect);
+	typedef void(GLAD_API_PTR *PFNGLRASTERPOS3SPROC)(GLshort x, GLshort y, GLshort z);
+	typedef void(GLAD_API_PTR *PFNGLGETNPIXELMAPFVPROC)(GLenum map, GLsizei bufSize, GLfloat *values);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD3SVPROC)(const GLshort *v);
+	typedef void(GLAD_API_PTR *PFNGLRECTIPROC)(GLint x1, GLint y1, GLint x2, GLint y2);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM4DVPROC)(GLint location, GLsizei count, const GLdouble *value);
+	typedef void(GLAD_API_PTR *PFNGLBLENDEQUATIONSEPARATEIPROC)(GLuint buf, GLenum modeRGB, GLenum modeAlpha);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM3FVPROC)(GLuint program, GLint location, GLsizei count, const GLfloat *value);
+	typedef void(GLAD_API_PTR *PFNGLGETPROGRAMRESOURCEIVPROC)(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLINVALIDATESUBFRAMEBUFFERPROC)(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height);
+	typedef GLsync(GLAD_API_PTR *PFNGLFENCESYNCPROC)(GLenum condition, GLbitfield flags);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM3UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2);
+	typedef void(GLAD_API_PTR *PFNGLSECONDARYCOLORP3UIVPROC)(GLenum type, const GLuint *color);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB1SPROC)(GLuint index, GLshort x);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB4NSVPROC)(GLuint index, const GLshort *v);
+	typedef void(GLAD_API_PTR *PFNGLLOADMATRIXFPROC)(const GLfloat *m);
+	typedef void(GLAD_API_PTR *PFNGLTRANSLATEFPROC)(GLfloat x, GLfloat y, GLfloat z);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD4SVPROC)(GLenum target, const GLshort *v);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM2IVPROC)(GLuint program, GLint location, GLsizei count, const GLint *value);
+	typedef void(GLAD_API_PTR *PFNGLMAPGRID2FPROC)(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
+	typedef void(GLAD_API_PTR *PFNGLENABLECLIENTSTATEPROC)(GLenum array);
+	typedef void(GLAD_API_PTR *PFNGLGETUNIFORMIVPROC)(GLuint program, GLint location, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLEVALCOORD1DVPROC)(const GLdouble *u);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBI4IVPROC)(GLuint index, const GLint *v);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB4SVPROC)(GLuint index, const GLshort *v);
+	typedef void(GLAD_API_PTR *PFNGLGETMULTISAMPLEFVPROC)(GLenum pname, GLuint index, GLfloat *val);
+	typedef void(GLAD_API_PTR *PFNGLINDEXDVPROC)(const GLdouble *c);
+	typedef void(GLAD_API_PTR *PFNGLBLENDFUNCIPROC)(GLuint buf, GLenum src, GLenum dst);
+	typedef GLboolean(GLAD_API_PTR *PFNGLISENABLEDPROC)(GLenum cap);
+	typedef void(GLAD_API_PTR *PFNGLGETPIXELMAPUSVPROC)(GLenum map, GLushort *values);
+	typedef void(GLAD_API_PTR *PFNGLRASTERPOS3IVPROC)(const GLint *v);
+	typedef void *(GLAD_API_PTR *PFNGLMAPBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD2SPROC)(GLenum target, GLshort s, GLshort t);
+	typedef void(GLAD_API_PTR *PFNGLRASTERPOS2FPROC)(GLfloat x, GLfloat y);
+	typedef void(GLAD_API_PTR *PFNGLMINSAMPLESHADINGPROC)(GLfloat value);
+	typedef void(GLAD_API_PTR *PFNGLGETQUERYBUFFEROBJECTUI64VPROC)(GLuint id, GLuint buffer, GLenum pname, GLintptr offset);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD2IPROC)(GLenum target, GLint s, GLint t);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBP3UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
+	typedef void(GLAD_API_PTR *PFNGLVERTEX2FPROC)(GLfloat x, GLfloat y);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXARRAYBINDINGDIVISORPROC)(GLuint vaobj, GLuint bindingindex, GLuint divisor);
+	typedef void(GLAD_API_PTR *PFNGLINDEXPOINTERPROC)(GLenum type, GLsizei stride, const void *pointer);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORMBLOCKBINDINGPROC)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
+	typedef GLint(GLAD_API_PTR *PFNGLRENDERMODEPROC)(GLenum mode);
+	typedef void(GLAD_API_PTR *PFNGLTEXSTORAGE1DPROC)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);
+	typedef void(GLAD_API_PTR *PFNGLBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, const void *data);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR3FVPROC)(const GLfloat *v);
+	typedef void(GLAD_API_PTR *PFNGLBITMAPPROC)(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM3UIVPROC)(GLuint program, GLint location, GLsizei count, const GLuint *value);
+	typedef void(GLAD_API_PTR *PFNGLVIEWPORTINDEXEDFPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h);
+	typedef void(GLAD_API_PTR *PFNGLRASTERPOS2DPROC)(GLdouble x, GLdouble y);
+	typedef void(GLAD_API_PTR *PFNGLGETUNIFORMINDICESPROC)(GLuint program, GLsizei uniformCount, const GLchar *const *uniformNames, GLuint *uniformIndices);
+	typedef void(GLAD_API_PTR *PFNGLENABLEIPROC)(GLenum target, GLuint index);
+	typedef void(GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTURE2DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+	typedef void(GLAD_API_PTR *PFNGLBLENDFUNCSEPARATEPROC)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+	typedef void(GLAD_API_PTR *PFNGLNAMEDBUFFERSTORAGEPROC)(GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags);
+	typedef void(GLAD_API_PTR *PFNGLRECTSPROC)(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM2FVPROC)(GLuint program, GLint location, GLsizei count, const GLfloat *value);
+	typedef void(GLAD_API_PTR *PFNGLPOLYGONSTIPPLEPROC)(const GLubyte *mask);
+	typedef void(GLAD_API_PTR *PFNGLCOPYTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+	typedef void(GLAD_API_PTR *PFNGLSECONDARYCOLOR3UBPROC)(GLubyte red, GLubyte green, GLubyte blue);
+	typedef void(GLAD_API_PTR *PFNGLWINDOWPOS3FPROC)(GLfloat x, GLfloat y, GLfloat z);
+	typedef void(GLAD_API_PTR *PFNGLGETSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLSHADERSTORAGEBLOCKBINDINGPROC)(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding);
+	typedef void(GLAD_API_PTR *PFNGLLOADIDENTITYPROC)(void);
+	typedef void(GLAD_API_PTR *PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei drawcount, const GLint *basevertex);
+	typedef void(GLAD_API_PTR *PFNGLVERTEX2SPROC)(GLshort x, GLshort y);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD1IVPROC)(GLenum target, const GLint *v);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD4SPROC)(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
+	typedef void(GLAD_API_PTR *PFNGLRELEASESHADERCOMPILERPROC)(void);
+	typedef void(GLAD_API_PTR *PFNGLGETSHADERSOURCEPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD2SVPROC)(GLenum target, const GLshort *v);
+	typedef void(GLAD_API_PTR *PFNGLTEXPARAMETERFVPROC)(GLenum target, GLenum pname, const GLfloat *params);
+	typedef GLboolean(GLAD_API_PTR *PFNGLISSHADERPROC)(GLuint shader);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB4IVPROC)(GLuint index, const GLint *v);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD4IPROC)(GLint s, GLint t, GLint r, GLint q);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR4UIPROC)(GLuint red, GLuint green, GLuint blue, GLuint alpha);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX3DVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+	typedef void(GLAD_API_PTR *PFNGLGETTEXENVFVPROC)(GLenum target, GLenum pname, GLfloat *params);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD4DPROC)(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+	typedef void(GLAD_API_PTR *PFNGLSCISSORARRAYVPROC)(GLuint first, GLsizei count, const GLint *v);
+	typedef void(GLAD_API_PTR *PFNGLCREATERENDERBUFFERSPROC)(GLsizei n, GLuint *renderbuffers);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB3FVPROC)(GLuint index, const GLfloat *v);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR4FPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB4NUBPROC)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+	typedef void(GLAD_API_PTR *PFNGLGETSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLCOPYTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+	typedef void(GLAD_API_PTR *PFNGLNORMAL3IVPROC)(const GLint *v);
+	typedef void(GLAD_API_PTR *PFNGLBINDIMAGETEXTURESPROC)(GLuint first, GLsizei count, const GLuint *textures);
+	typedef void(GLAD_API_PTR *PFNGLTEXGENIVPROC)(GLenum coord, GLenum pname, const GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLCOMPRESSEDTEXIMAGE3DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data);
+	typedef void(GLAD_API_PTR *PFNGLSCALEDPROC)(GLdouble x, GLdouble y, GLdouble z);
+	typedef void(GLAD_API_PTR *PFNGLCREATEPROGRAMPIPELINESPROC)(GLsizei n, GLuint *pipelines);
+	typedef void(GLAD_API_PTR *PFNGLBLENDFUNCSEPARATEIPROC)(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
+	typedef void(GLAD_API_PTR *PFNGLHINTPROC)(GLenum target, GLenum mode);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD4IPROC)(GLenum target, GLint s, GLint t, GLint r, GLint q);
+	typedef void(GLAD_API_PTR *PFNGLINDEXMASKPROC)(GLuint mask);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM2FPROC)(GLuint program, GLint location, GLfloat v0, GLfloat v1);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR3BPROC)(GLbyte red, GLbyte green, GLbyte blue);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBI1UIVPROC)(GLuint index, const GLuint *v);
+	typedef void(GLAD_API_PTR *PFNGLSPECIALIZESHADERPROC)(GLuint shader, const GLchar *pEntryPoint, GLuint numSpecializationConstants, const GLuint *pConstantIndex, const GLuint *pConstantValue);
+	typedef void(GLAD_API_PTR *PFNGLNAMEDFRAMEBUFFERDRAWBUFFERPROC)(GLuint framebuffer, GLenum buf);
+	typedef void(GLAD_API_PTR *PFNGLGETQUERYBUFFEROBJECTI64VPROC)(GLuint id, GLuint buffer, GLenum pname, GLintptr offset);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD3IVPROC)(const GLint *v);
+	typedef void(GLAD_API_PTR *PFNGLSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, const GLfloat *param);
+	typedef void(GLAD_API_PTR *PFNGLGETVERTEXATTRIBIIVPROC)(GLuint index, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLBUFFERSTORAGEPROC)(GLenum target, GLsizeiptr size, const void *data, GLbitfield flags);
+	typedef void(GLAD_API_PTR *PFNGLVERTEX3SPROC)(GLshort x, GLshort y, GLshort z);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM2UIVPROC)(GLuint program, GLint location, GLsizei count, const GLuint *value);
+	typedef void(GLAD_API_PTR *PFNGLDEPTHRANGEPROC)(GLdouble n, GLdouble f);
+	typedef void(GLAD_API_PTR *PFNGLRASTERPOS3FPROC)(GLfloat x, GLfloat y, GLfloat z);
+	typedef void(GLAD_API_PTR *PFNGLDELETESHADERPROC)(GLuint shader);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR3BVPROC)(const GLbyte *v);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR3UBVPROC)(const GLubyte *v);
+	typedef void(GLAD_API_PTR *PFNGLGETVERTEXATTRIBIVPROC)(GLuint index, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD4SVPROC)(const GLshort *v);
+	typedef void(GLAD_API_PTR *PFNGLMAP2DPROC)(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
+	typedef void(GLAD_API_PTR *PFNGLFOGCOORDFPROC)(GLfloat coord);
+	typedef void(GLAD_API_PTR *PFNGLEDGEFLAGVPROC)(const GLboolean *flag);
+	typedef void(GLAD_API_PTR *PFNGLCLIPCONTROLPROC)(GLenum origin, GLenum depth);
+	typedef void(GLAD_API_PTR *PFNGLGETBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLGETTRANSFORMFEEDBACKIVPROC)(GLuint xfb, GLenum pname, GLint *param);
+	typedef void(GLAD_API_PTR *PFNGLGETPROGRAMPIPELINEIVPROC)(GLuint pipeline, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLGETNMINMAXPROC)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void *values);
+	typedef void(GLAD_API_PTR *PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEPROC)(GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+	typedef void(GLAD_API_PTR *PFNGLCOLORP4UIPROC)(GLenum type, GLuint color);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD1SVPROC)(GLenum target, const GLshort *v);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB4FVPROC)(GLuint index, const GLfloat *v);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB4DVPROC)(GLuint index, const GLdouble *v);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXP4UIPROC)(GLenum type, GLuint value);
+	typedef void(GLAD_API_PTR *PFNGLRECTFVPROC)(const GLfloat *v1, const GLfloat *v2);
+	typedef void(GLAD_API_PTR *PFNGLBEGINTRANSFORMFEEDBACKPROC)(GLenum primitiveMode);
+	typedef void(GLAD_API_PTR *PFNGLARRAYELEMENTPROC)(GLint i);
+	typedef void(GLAD_API_PTR *PFNGLNAMEDFRAMEBUFFERTEXTURELAYERPROC)(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer);
+	typedef void(GLAD_API_PTR *PFNGLBEGINPROC)(GLenum mode);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORDPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void *pointer);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD3DPROC)(GLdouble s, GLdouble t, GLdouble r);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM1FVPROC)(GLint location, GLsizei count, const GLfloat *value);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB2SVPROC)(GLuint index, const GLshort *v);
+	typedef void(GLAD_API_PTR *PFNGLGETPROGRAMPIPELINEINFOLOGPROC)(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+	typedef void(GLAD_API_PTR *PFNGLPOLYGONOFFSETPROC)(GLfloat factor, GLfloat units);
+	typedef void(GLAD_API_PTR *PFNGLGETSHADERPRECISIONFORMATPROC)(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM3DPROC)(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
+	typedef void(GLAD_API_PTR *PFNGLBINDTRANSFORMFEEDBACKPROC)(GLenum target, GLuint id);
+	typedef void(GLAD_API_PTR *PFNGLPROVOKINGVERTEXPROC)(GLenum mode);
+	typedef void(GLAD_API_PTR *PFNGLDISABLEVERTEXARRAYATTRIBPROC)(GLuint vaobj, GLuint index);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD4FVPROC)(GLenum target, const GLfloat *v);
+	typedef void(GLAD_API_PTR *PFNGLUNIFORM1DPROC)(GLint location, GLdouble x);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBFORMATPROC)(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);
+	typedef void(GLAD_API_PTR *PFNGLMEMORYBARRIERBYREGIONPROC)(GLbitfield barriers);
+	typedef void(GLAD_API_PTR *PFNGLPOPDEBUGGROUPPROC)(void);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR4BPROC)(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
+	typedef void(GLAD_API_PTR *PFNGLTEXTUREBUFFERPROC)(GLuint texture, GLenum internalformat, GLuint buffer);
+	typedef void(GLAD_API_PTR *PFNGLGETSHADERIVPROC)(GLuint shader, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLBEGINQUERYINDEXEDPROC)(GLenum target, GLuint index, GLuint id);
+	typedef void(GLAD_API_PTR *PFNGLCOPYNAMEDBUFFERSUBDATAPROC)(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXARRAYATTRIBFORMATPROC)(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);
+	typedef void *(GLAD_API_PTR *PFNGLMAPNAMEDBUFFERRANGEPROC)(GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR4UIVPROC)(const GLuint *v);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBP1UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value);
+	typedef void(GLAD_API_PTR *PFNGLWINDOWPOS3SVPROC)(const GLshort *v);
+	typedef void(GLAD_API_PTR *PFNGLFOGIVPROC)(GLenum pname, const GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLTEXTUREPARAMETERIIVPROC)(GLuint texture, GLenum pname, const GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLLISTBASEPROC)(GLuint base);
+	typedef void(GLAD_API_PTR *PFNGLCREATEFRAMEBUFFERSPROC)(GLsizei n, GLuint *framebuffers);
+	typedef void(GLAD_API_PTR *PFNGLEVALCOORD2FPROC)(GLfloat u, GLfloat v);
+	typedef void(GLAD_API_PTR *PFNGLVERTEX4DVPROC)(const GLdouble *v);
+	typedef void(GLAD_API_PTR *PFNGLDELETEPROGRAMPROC)(GLuint program);
+	typedef void(GLAD_API_PTR *PFNGLDRAWELEMENTSPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices);
+	typedef void(GLAD_API_PTR *PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC)(GLenum mode, GLuint id, GLuint stream);
+	typedef void(GLAD_API_PTR *PFNGLVALIDATEPROGRAMPROC)(GLuint program);
+	typedef void(GLAD_API_PTR *PFNGLDRAWELEMENTSINSTANCEDPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount);
+	typedef GLuint(GLAD_API_PTR *PFNGLGENLISTSPROC)(GLsizei range);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR4IPROC)(GLint red, GLint green, GLint blue, GLint alpha);
+	typedef void(GLAD_API_PTR *PFNGLCOLOR3UIPROC)(GLuint red, GLuint green, GLuint blue);
+	typedef void(GLAD_API_PTR *PFNGLCREATETEXTURESPROC)(GLenum target, GLsizei n, GLuint *textures);
+	typedef void(GLAD_API_PTR *PFNGLCOLORP4UIVPROC)(GLenum type, const GLuint *color);
+	typedef void(GLAD_API_PTR *PFNGLGETPROGRAMINFOLOGPROC)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBP3UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value);
+	typedef void(GLAD_API_PTR *PFNGLCLEARBUFFERFIPROC)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
+	typedef void(GLAD_API_PTR *PFNGLCOPYTEXTURESUBIMAGE3DPROC)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+	typedef void(GLAD_API_PTR *PFNGLEDGEFLAGPROC)(GLboolean flag);
+	typedef void(GLAD_API_PTR *PFNGLGETBUFFERPARAMETERI64VPROC)(GLenum target, GLenum pname, GLint64 *params);
+	typedef void(GLAD_API_PTR *PFNGLRASTERPOS2IVPROC)(const GLint *v);
+	typedef void(GLAD_API_PTR *PFNGLGETNMAPIVPROC)(GLenum target, GLenum query, GLsizei bufSize, GLint *v);
+	typedef void(GLAD_API_PTR *PFNGLRECTDVPROC)(const GLdouble *v1, const GLdouble *v2);
+	typedef void(GLAD_API_PTR *PFNGLGETBOOLEANI_VPROC)(GLenum target, GLuint index, GLboolean *data);
+	typedef void(GLAD_API_PTR *PFNGLENDLISTPROC)(void);
+	typedef void(GLAD_API_PTR *PFNGLFLUSHPROC)(void);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM4UIPROC)(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
+	typedef void(GLAD_API_PTR *PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTPROC)(GLenum mode, GLenum type, const void *indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride);
+	typedef void(GLAD_API_PTR *PFNGLGETINTEGER64VPROC)(GLenum pname, GLint64 *data);
+	typedef void(GLAD_API_PTR *PFNGLLIGHTMODELFPROC)(GLenum pname, GLfloat param);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB4NIVPROC)(GLuint index, const GLint *v);
+	typedef void(GLAD_API_PTR *PFNGLGETTEXTURELEVELPARAMETERIVPROC)(GLuint texture, GLint level, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLLOADMATRIXDPROC)(const GLdouble *m);
+	typedef void(GLAD_API_PTR *PFNGLBINDPROGRAMPIPELINEPROC)(GLuint pipeline);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORM1UIVPROC)(GLuint program, GLint location, GLsizei count, const GLuint *value);
+	typedef void(GLAD_API_PTR *PFNGLDISABLEVERTEXATTRIBARRAYPROC)(GLuint index);
+	typedef void(GLAD_API_PTR *PFNGLCLEARDEPTHPROC)(GLdouble depth);
+	typedef void(GLAD_API_PTR *PFNGLGETTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLWINDOWPOS3FVPROC)(const GLfloat *v);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIB3DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z);
+	typedef GLint(GLAD_API_PTR *PFNGLGETPROGRAMRESOURCELOCATIONPROC)(GLuint program, GLenum programInterface, const GLchar *name);
+	typedef void(GLAD_API_PTR *PFNGLTEXCOORD2DPROC)(GLdouble s, GLdouble t);
+	typedef void(GLAD_API_PTR *PFNGLACCUMPROC)(GLenum op, GLfloat value);
+	typedef void(GLAD_API_PTR *PFNGLSECONDARYCOLORP3UIPROC)(GLenum type, GLuint color);
+	typedef void(GLAD_API_PTR *PFNGLVERTEXATTRIBI2UIPROC)(GLuint index, GLuint x, GLuint y);
+	typedef void(GLAD_API_PTR *PFNGLGETNUNIFORMFVPROC)(GLuint program, GLint location, GLsizei bufSize, GLfloat *params);
+	typedef void(GLAD_API_PTR *PFNGLFOGIPROC)(GLenum pname, GLint param);
+	typedef void(GLAD_API_PTR *PFNGLCLEARBUFFERFVPROC)(GLenum buffer, GLint drawbuffer, const GLfloat *value);
+	typedef void(GLAD_API_PTR *PFNGLTEXENVIVPROC)(GLenum target, GLenum pname, const GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLTEXIMAGE2DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels);
+	typedef void(GLAD_API_PTR *PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC)(GLuint program, GLuint bufferIndex, GLenum pname, GLint *params);
+	typedef void(GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+	typedef void(GLAD_API_PTR *PFNGLMULTITEXCOORD1FVPROC)(GLenum target, const GLfloat *v);
+	typedef void(GLAD_API_PTR *PFNGLGETOBJECTPTRLABELPROC)(const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label);
+
+	GLAD_API_CALL PFNGLGETTEXTUREPARAMETERIIVPROC glad_glGetTextureParameterIiv;
+#define glGetTextureParameterIiv glad_glGetTextureParameterIiv
+	GLAD_API_CALL PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv;
+#define glTexCoordP1uiv glad_glTexCoordP1uiv
+	GLAD_API_CALL PFNGLTEXTURESTORAGE3DMULTISAMPLEPROC glad_glTextureStorage3DMultisample;
+#define glTextureStorage3DMultisample glad_glTextureStorage3DMultisample
+	GLAD_API_CALL PFNGLEVALPOINT2PROC glad_glEvalPoint2;
+#define glEvalPoint2 glad_glEvalPoint2
+	GLAD_API_CALL PFNGLVERTEXARRAYATTRIBBINDINGPROC glad_glVertexArrayAttribBinding;
+#define glVertexArrayAttribBinding glad_glVertexArrayAttribBinding
+	GLAD_API_CALL PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEPROC glad_glFlushMappedNamedBufferRange;
+#define glFlushMappedNamedBufferRange glad_glFlushMappedNamedBufferRange
+	GLAD_API_CALL PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVPROC glad_glGetNamedFramebufferParameteriv;
+#define glGetNamedFramebufferParameteriv glad_glGetNamedFramebufferParameteriv
+	GLAD_API_CALL PFNGLPIXELTRANSFERFPROC glad_glPixelTransferf;
+#define glPixelTransferf glad_glPixelTransferf
+	GLAD_API_CALL PFNGLGETFLOATI_VPROC glad_glGetFloati_v;
+#define glGetFloati_v glad_glGetFloati_v
+	GLAD_API_CALL PFNGLLOADNAMEPROC glad_glLoadName;
+#define glLoadName glad_glLoadName
+	GLAD_API_CALL PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv;
+#define glUniformMatrix4fv glad_glUniformMatrix4fv
+	GLAD_API_CALL PFNGLSECONDARYCOLOR3SVPROC glad_glSecondaryColor3sv;
+#define glSecondaryColor3sv glad_glSecondaryColor3sv
+	GLAD_API_CALL PFNGLCOPYTEXTURESUBIMAGE1DPROC glad_glCopyTextureSubImage1D;
+#define glCopyTextureSubImage1D glad_glCopyTextureSubImage1D
+	GLAD_API_CALL PFNGLSECONDARYCOLOR3UIVPROC glad_glSecondaryColor3uiv;
+#define glSecondaryColor3uiv glad_glSecondaryColor3uiv
+	GLAD_API_CALL PFNGLUNIFORM1DVPROC glad_glUniform1dv;
+#define glUniform1dv glad_glUniform1dv
+	GLAD_API_CALL PFNGLWINDOWPOS3DVPROC glad_glWindowPos3dv;
+#define glWindowPos3dv glad_glWindowPos3dv
+	GLAD_API_CALL PFNGLSECONDARYCOLOR3BVPROC glad_glSecondaryColor3bv;
+#define glSecondaryColor3bv glad_glSecondaryColor3bv
+	GLAD_API_CALL PFNGLSECONDARYCOLOR3UIPROC glad_glSecondaryColor3ui;
+#define glSecondaryColor3ui glad_glSecondaryColor3ui
+	GLAD_API_CALL PFNGLGETNCOLORTABLEPROC glad_glGetnColorTable;
+#define glGetnColorTable glad_glGetnColorTable
+	GLAD_API_CALL PFNGLRASTERPOS3IPROC glad_glRasterPos3i;
+#define glRasterPos3i glad_glRasterPos3i
+	GLAD_API_CALL PFNGLACTIVETEXTUREPROC glad_glActiveTexture;
+#define glActiveTexture glad_glActiveTexture
+	GLAD_API_CALL PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv;
+#define glVertexAttrib4Nuiv glad_glVertexAttrib4Nuiv
+	GLAD_API_CALL PFNGLCLEARNAMEDBUFFERDATAPROC glad_glClearNamedBufferData;
+#define glClearNamedBufferData glad_glClearNamedBufferData
+	GLAD_API_CALL PFNGLNORMAL3DPROC glad_glNormal3d;
+#define glNormal3d glad_glNormal3d
+	GLAD_API_CALL PFNGLINVALIDATENAMEDFRAMEBUFFERSUBDATAPROC glad_glInvalidateNamedFramebufferSubData;
+#define glInvalidateNamedFramebufferSubData glad_glInvalidateNamedFramebufferSubData
+	GLAD_API_CALL PFNGLBINDBUFFERSBASEPROC glad_glBindBuffersBase;
+#define glBindBuffersBase glad_glBindBuffersBase
+	GLAD_API_CALL PFNGLEVALCOORD1DPROC glad_glEvalCoord1d;
+#define glEvalCoord1d glad_glEvalCoord1d
+	GLAD_API_CALL PFNGLGETMAPFVPROC glad_glGetMapfv;
+#define glGetMapfv glad_glGetMapfv
+	GLAD_API_CALL PFNGLISSYNCPROC glad_glIsSync;
+#define glIsSync glad_glIsSync
+	GLAD_API_CALL PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D;
+#define glTexSubImage2D glad_glTexSubImage2D
+	GLAD_API_CALL PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation;
+#define glGetAttribLocation glad_glGetAttribLocation
+	GLAD_API_CALL PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D;
+#define glCopyTexImage1D glad_glCopyTexImage1D
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM4IPROC glad_glProgramUniform4i;
+#define glProgramUniform4i glad_glProgramUniform4i
+	GLAD_API_CALL PFNGLGETPIXELMAPFVPROC glad_glGetPixelMapfv;
+#define glGetPixelMapfv glad_glGetPixelMapfv
+	GLAD_API_CALL PFNGLVERTEX4SVPROC glad_glVertex4sv;
+#define glVertex4sv glad_glVertex4sv
+	GLAD_API_CALL PFNGLTEXSTORAGE2DPROC glad_glTexStorage2D;
+#define glTexStorage2D glad_glTexStorage2D
+	GLAD_API_CALL PFNGLTEXCOORD2FVPROC glad_glTexCoord2fv;
+#define glTexCoord2fv glad_glTexCoord2fv
+	GLAD_API_CALL PFNGLUNIFORMMATRIX3X2DVPROC glad_glUniformMatrix3x2dv;
+#define glUniformMatrix3x2dv glad_glUniformMatrix3x2dv
+	GLAD_API_CALL PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv;
+#define glGetVertexAttribIuiv glad_glGetVertexAttribIuiv
+	GLAD_API_CALL PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv;
+#define glVertexAttrib3sv glad_glVertexAttrib3sv
+	GLAD_API_CALL PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex;
+#define glDrawRangeElementsBaseVertex glad_glDrawRangeElementsBaseVertex
+	GLAD_API_CALL PFNGLDEPTHRANGEINDEXEDPROC glad_glDepthRangeIndexed;
+#define glDepthRangeIndexed glad_glDepthRangeIndexed
+	GLAD_API_CALL PFNGLISQUERYPROC glad_glIsQuery;
+#define glIsQuery glad_glIsQuery
+	GLAD_API_CALL PFNGLDELETEPROGRAMPIPELINESPROC glad_glDeleteProgramPipelines;
+#define glDeleteProgramPipelines glad_glDeleteProgramPipelines
+	GLAD_API_CALL PFNGLGETTEXTURELEVELPARAMETERFVPROC glad_glGetTextureLevelParameterfv;
+#define glGetTextureLevelParameterfv glad_glGetTextureLevelParameterfv
+	GLAD_API_CALL PFNGLUNIFORMMATRIX4X3DVPROC glad_glUniformMatrix4x3dv;
+#define glUniformMatrix4x3dv glad_glUniformMatrix4x3dv
+	GLAD_API_CALL PFNGLBLITNAMEDFRAMEBUFFERPROC glad_glBlitNamedFramebuffer;
+#define glBlitNamedFramebuffer glad_glBlitNamedFramebuffer
+	GLAD_API_CALL PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui;
+#define glMultiTexCoordP1ui glad_glMultiTexCoordP1ui
+	GLAD_API_CALL PFNGLINDEXSPROC glad_glIndexs;
+#define glIndexs glad_glIndexs
+	GLAD_API_CALL PFNGLCOLORP3UIPROC glad_glColorP3ui;
+#define glColorP3ui glad_glColorP3ui
+	GLAD_API_CALL PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui;
+#define glMultiTexCoordP4ui glad_glMultiTexCoordP4ui
+	GLAD_API_CALL PFNGLCREATESHADERPROC glad_glCreateShader;
+#define glCreateShader glad_glCreateShader
+	GLAD_API_CALL PFNGLCLEARNAMEDFRAMEBUFFERFIPROC glad_glClearNamedFramebufferfi;
+#define glClearNamedFramebufferfi glad_glClearNamedFramebufferfi
+	GLAD_API_CALL PFNGLGETCOMPRESSEDTEXTUREIMAGEPROC glad_glGetCompressedTextureImage;
+#define glGetCompressedTextureImage glad_glGetCompressedTextureImage
+	GLAD_API_CALL PFNGLCOLOR4SVPROC glad_glColor4sv;
+#define glColor4sv glad_glColor4sv
+	GLAD_API_CALL PFNGLDEBUGMESSAGEINSERTPROC glad_glDebugMessageInsert;
+#define glDebugMessageInsert glad_glDebugMessageInsert
+	GLAD_API_CALL PFNGLRECTFPROC glad_glRectf;
+#define glRectf glad_glRectf
+	GLAD_API_CALL PFNGLGETDEBUGMESSAGELOGPROC glad_glGetDebugMessageLog;
+#define glGetDebugMessageLog glad_glGetDebugMessageLog
+	GLAD_API_CALL PFNGLWINDOWPOS3SPROC glad_glWindowPos3s;
+#define glWindowPos3s glad_glWindowPos3s
+	GLAD_API_CALL PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer;
+#define glIsFramebuffer glad_glIsFramebuffer
+	GLAD_API_CALL PFNGLCOPYIMAGESUBDATAPROC glad_glCopyImageSubData;
+#define glCopyImageSubData glad_glCopyImageSubData
+	GLAD_API_CALL PFNGLCOLORPOINTERPROC glad_glColorPointer;
+#define glColorPointer glad_glColorPointer
+	GLAD_API_CALL PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv;
+#define glUniformMatrix4x3fv glad_glUniformMatrix4x3fv
+	GLAD_API_CALL PFNGLGETMATERIALFVPROC glad_glGetMaterialfv;
+#define glGetMaterialfv glad_glGetMaterialfv
+	GLAD_API_CALL PFNGLMULTITEXCOORD4IVPROC glad_glMultiTexCoord4iv;
+#define glMultiTexCoord4iv glad_glMultiTexCoord4iv
+	GLAD_API_CALL PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers;
+#define glDeleteSamplers glad_glDeleteSamplers
+	GLAD_API_CALL PFNGLGETMATERIALIVPROC glad_glGetMaterialiv;
+#define glGetMaterialiv glad_glGetMaterialiv
+	GLAD_API_CALL PFNGLBLENDFUNCPROC glad_glBlendFunc;
+#define glBlendFunc glad_glBlendFunc
+	GLAD_API_CALL PFNGLNAMEDFRAMEBUFFERRENDERBUFFERPROC glad_glNamedFramebufferRenderbuffer;
+#define glNamedFramebufferRenderbuffer glad_glNamedFramebufferRenderbuffer
+	GLAD_API_CALL PFNGLNAMEDBUFFERDATAPROC glad_glNamedBufferData;
+#define glNamedBufferData glad_glNamedBufferData
+	GLAD_API_CALL PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements;
+#define glMultiDrawElements glad_glMultiDrawElements
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM3IPROC glad_glProgramUniform3i;
+#define glProgramUniform3i glad_glProgramUniform3i
+	GLAD_API_CALL PFNGLGETPROGRAMSTAGEIVPROC glad_glGetProgramStageiv;
+#define glGetProgramStageiv glad_glGetProgramStageiv
+	GLAD_API_CALL PFNGLVERTEXATTRIBLFORMATPROC glad_glVertexAttribLFormat;
+#define glVertexAttribLFormat glad_glVertexAttribLFormat
+	GLAD_API_CALL PFNGLVERTEX2SVPROC glad_glVertex2sv;
+#define glVertex2sv glad_glVertex2sv
+	GLAD_API_CALL PFNGLRECTSVPROC glad_glRectsv;
+#define glRectsv glad_glRectsv
+	GLAD_API_CALL PFNGLTEXTURESTORAGE2DPROC glad_glTextureStorage2D;
+#define glTextureStorage2D glad_glTextureStorage2D
+	GLAD_API_CALL PFNGLUNIFORM3FPROC glad_glUniform3f;
+#define glUniform3f glad_glUniform3f
+	GLAD_API_CALL PFNGLDRAWBUFFERPROC glad_glDrawBuffer;
+#define glDrawBuffer glad_glDrawBuffer
+	GLAD_API_CALL PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D;
+#define glTexSubImage1D glad_glTexSubImage1D
+	GLAD_API_CALL PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv;
+#define glTexCoordP2uiv glad_glTexCoordP2uiv
+	GLAD_API_CALL PFNGLUNIFORM4FPROC glad_glUniform4f;
+#define glUniform4f glad_glUniform4f
+	GLAD_API_CALL PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d;
+#define glVertexAttrib2d glad_glVertexAttrib2d
+	GLAD_API_CALL PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f;
+#define glVertexAttrib2f glad_glVertexAttrib2f
+	GLAD_API_CALL PFNGLSECONDARYCOLOR3UBVPROC glad_glSecondaryColor3ubv;
+#define glSecondaryColor3ubv glad_glSecondaryColor3ubv
+	GLAD_API_CALL PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers;
+#define glDeleteFramebuffers glad_glDeleteFramebuffers
+	GLAD_API_CALL PFNGLCLEARCOLORPROC glad_glClearColor;
+#define glClearColor glad_glClearColor
+	GLAD_API_CALL PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer;
+#define glFramebufferRenderbuffer glad_glFramebufferRenderbuffer
+	GLAD_API_CALL PFNGLGETTEXGENFVPROC glad_glGetTexGenfv;
+#define glGetTexGenfv glad_glGetTexGenfv
+	GLAD_API_CALL PFNGLCOLOR4DVPROC glad_glColor4dv;
+#define glColor4dv glad_glColor4dv
+	GLAD_API_CALL PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv;
+#define glMultiTexCoordP4uiv glad_glMultiTexCoordP4uiv
+	GLAD_API_CALL PFNGLACTIVESHADERPROGRAMPROC glad_glActiveShaderProgram;
+#define glActiveShaderProgram glad_glActiveShaderProgram
+	GLAD_API_CALL PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender;
+#define glBeginConditionalRender glad_glBeginConditionalRender
+	GLAD_API_CALL PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample;
+#define glTexImage3DMultisample glad_glTexImage3DMultisample
+	GLAD_API_CALL PFNGLVIEWPORTINDEXEDFVPROC glad_glViewportIndexedfv;
+#define glViewportIndexedfv glad_glViewportIndexedfv
+	GLAD_API_CALL PFNGLMAPGRID1FPROC glad_glMapGrid1f;
+#define glMapGrid1f glad_glMapGrid1f
+	GLAD_API_CALL PFNGLMULTITEXCOORD3DPROC glad_glMultiTexCoord3d;
+#define glMultiTexCoord3d glad_glMultiTexCoord3d
+	GLAD_API_CALL PFNGLWINDOWPOS2DVPROC glad_glWindowPos2dv;
+#define glWindowPos2dv glad_glWindowPos2dv
+	GLAD_API_CALL PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv;
+#define glGetBufferPointerv glad_glGetBufferPointerv
+	GLAD_API_CALL PFNGLTEXGENFVPROC glad_glTexGenfv;
+#define glTexGenfv glad_glTexGenfv
+	GLAD_API_CALL PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv;
+#define glVertexAttribP4uiv glad_glVertexAttribP4uiv
+	GLAD_API_CALL PFNGLROTATEDPROC glad_glRotated;
+#define glRotated glad_glRotated
+	GLAD_API_CALL PFNGLCREATEQUERIESPROC glad_glCreateQueries;
+#define glCreateQueries glad_glCreateQueries
+	GLAD_API_CALL PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv;
+#define glUniformMatrix3x2fv glad_glUniformMatrix3x2fv
+	GLAD_API_CALL PFNGLTEXIMAGE1DPROC glad_glTexImage1D;
+#define glTexImage1D glad_glTexImage1D
+	GLAD_API_CALL PFNGLWINDOWPOS3IPROC glad_glWindowPos3i;
+#define glWindowPos3i glad_glWindowPos3i
+	GLAD_API_CALL PFNGLCLAMPCOLORPROC glad_glClampColor;
+#define glClampColor glad_glClampColor
+	GLAD_API_CALL PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv;
+#define glUniformMatrix4x2fv glad_glUniformMatrix4x2fv
+	GLAD_API_CALL PFNGLVERTEX4FPROC glad_glVertex4f;
+#define glVertex4f glad_glVertex4f
+	GLAD_API_CALL PFNGLNORMAL3FPROC glad_glNormal3f;
+#define glNormal3f glad_glNormal3f
+	GLAD_API_CALL PFNGLCOLOR3UBPROC glad_glColor3ub;
+#define glColor3ub glad_glColor3ub
+	GLAD_API_CALL PFNGLSCISSORINDEXEDPROC glad_glScissorIndexed;
+#define glScissorIndexed glad_glScissorIndexed
+	GLAD_API_CALL PFNGLPUSHCLIENTATTRIBPROC glad_glPushClientAttrib;
+#define glPushClientAttrib glad_glPushClientAttrib
+	GLAD_API_CALL PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d;
+#define glVertexAttrib4d glad_glVertexAttrib4d
+	GLAD_API_CALL PFNGLUSEPROGRAMSTAGESPROC glad_glUseProgramStages;
+#define glUseProgramStages glad_glUseProgramStages
+	GLAD_API_CALL PFNGLTEXCOORD3SPROC glad_glTexCoord3s;
+#define glTexCoord3s glad_glTexCoord3s
+	GLAD_API_CALL PFNGLLIGHTFPROC glad_glLightf;
+#define glLightf glad_glLightf
+	GLAD_API_CALL PFNGLTEXCOORD3FVPROC glad_glTexCoord3fv;
+#define glTexCoord3fv glad_glTexCoord3fv
+	GLAD_API_CALL PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv;
+#define glVertexAttrib4Nubv glad_glVertexAttrib4Nubv
+	GLAD_API_CALL PFNGLVERTEXATTRIBL2DPROC glad_glVertexAttribL2d;
+#define glVertexAttribL2d glad_glVertexAttribL2d
+	GLAD_API_CALL PFNGLFOGCOORDDPROC glad_glFogCoordd;
+#define glFogCoordd glad_glFogCoordd
+	GLAD_API_CALL PFNGLGETNPIXELMAPUIVPROC glad_glGetnPixelMapuiv;
+#define glGetnPixelMapuiv glad_glGetnPixelMapuiv
+	GLAD_API_CALL PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample;
+#define glTexImage2DMultisample glad_glTexImage2DMultisample
+	GLAD_API_CALL PFNGLGETQUERYBUFFEROBJECTIVPROC glad_glGetQueryBufferObjectiv;
+#define glGetQueryBufferObjectiv glad_glGetQueryBufferObjectiv
+	GLAD_API_CALL PFNGLGETSTRINGIPROC glad_glGetStringi;
+#define glGetStringi glad_glGetStringi
+	GLAD_API_CALL PFNGLRASTERPOS4SPROC glad_glRasterPos4s;
+#define glRasterPos4s glad_glRasterPos4s
+	GLAD_API_CALL PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui;
+#define glVertexAttribP2ui glad_glVertexAttribP2ui
+	GLAD_API_CALL PFNGLGETQUERYIVPROC glad_glGetQueryiv;
+#define glGetQueryiv glad_glGetQueryiv
+	GLAD_API_CALL PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray;
+#define glBindVertexArray glad_glBindVertexArray
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM3DVPROC glad_glProgramUniform3dv;
+#define glProgramUniform3dv glad_glProgramUniform3dv
+	GLAD_API_CALL PFNGLTEXPARAMETERFPROC glad_glTexParameterf;
+#define glTexParameterf glad_glTexParameterf
+	GLAD_API_CALL PFNGLWINDOWPOS3DPROC glad_glWindowPos3d;
+#define glWindowPos3d glad_glWindowPos3d
+	GLAD_API_CALL PFNGLGENERATETEXTUREMIPMAPPROC glad_glGenerateTextureMipmap;
+#define glGenerateTextureMipmap glad_glGenerateTextureMipmap
+	GLAD_API_CALL PFNGLDELETESYNCPROC glad_glDeleteSync;
+#define glDeleteSync glad_glDeleteSync
+	GLAD_API_CALL PFNGLBINDBUFFERPROC glad_glBindBuffer;
+#define glBindBuffer glad_glBindBuffer
+	GLAD_API_CALL PFNGLPUSHDEBUGGROUPPROC glad_glPushDebugGroup;
+#define glPushDebugGroup glad_glPushDebugGroup
+	GLAD_API_CALL PFNGLRASTERPOS2IPROC glad_glRasterPos2i;
+#define glRasterPos2i glad_glRasterPos2i
+	GLAD_API_CALL PFNGLBINDIMAGETEXTUREPROC glad_glBindImageTexture;
+#define glBindImageTexture glad_glBindImageTexture
+	GLAD_API_CALL PFNGLFEEDBACKBUFFERPROC glad_glFeedbackBuffer;
+#define glFeedbackBuffer glad_glFeedbackBuffer
+	GLAD_API_CALL PFNGLEVALMESH2PROC glad_glEvalMesh2;
+#define glEvalMesh2 glad_glEvalMesh2
+	GLAD_API_CALL PFNGLLINKPROGRAMPROC glad_glLinkProgram;
+#define glLinkProgram glad_glLinkProgram
+	GLAD_API_CALL PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D;
+#define glCompressedTexSubImage2D glad_glCompressedTexSubImage2D
+	GLAD_API_CALL PFNGLPUSHMATRIXPROC glad_glPushMatrix;
+#define glPushMatrix glad_glPushMatrix
+	GLAD_API_CALL PFNGLFRAMEBUFFERPARAMETERIPROC glad_glFramebufferParameteri;
+#define glFramebufferParameteri glad_glFramebufferParameteri
+	GLAD_API_CALL PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName;
+#define glGetActiveUniformBlockName glad_glGetActiveUniformBlockName
+	GLAD_API_CALL PFNGLUNIFORM3DPROC glad_glUniform3d;
+#define glUniform3d glad_glUniform3d
+	GLAD_API_CALL PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv;
+#define glVertexAttrib4ubv glad_glVertexAttrib4ubv
+	GLAD_API_CALL PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D;
+#define glCompressedTexImage1D glad_glCompressedTexImage1D
+	GLAD_API_CALL PFNGLGETTRANSFORMFEEDBACKI64_VPROC glad_glGetTransformFeedbacki64_v;
+#define glGetTransformFeedbacki64_v glad_glGetTransformFeedbacki64_v
+	GLAD_API_CALL PFNGLCOMPILESHADERPROC glad_glCompileShader;
+#define glCompileShader glad_glCompileShader
+	GLAD_API_CALL PFNGLGETLIGHTFVPROC glad_glGetLightfv;
+#define glGetLightfv glad_glGetLightfv
+	GLAD_API_CALL PFNGLPIXELMAPUSVPROC glad_glPixelMapusv;
+#define glPixelMapusv glad_glPixelMapusv
+	GLAD_API_CALL PFNGLRASTERPOS4IPROC glad_glRasterPos4i;
+#define glRasterPos4i glad_glRasterPos4i
+	GLAD_API_CALL PFNGLUNIFORMMATRIX4X2DVPROC glad_glUniformMatrix4x2dv;
+#define glUniformMatrix4x2dv glad_glUniformMatrix4x2dv
+	GLAD_API_CALL PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D;
+#define glFramebufferTexture1D glad_glFramebufferTexture1D
+	GLAD_API_CALL PFNGLINITNAMESPROC glad_glInitNames;
+#define glInitNames glad_glInitNames
+	GLAD_API_CALL PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui;
+#define glVertexAttribI1ui glad_glVertexAttribI1ui
+	GLAD_API_CALL PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv;
+#define glClearBufferiv glad_glClearBufferiv
+	GLAD_API_CALL PFNGLMAP1FPROC glad_glMap1f;
+#define glMap1f glad_glMap1f
+	GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX4DVPROC glad_glProgramUniformMatrix4dv;
+#define glProgramUniformMatrix4dv glad_glProgramUniformMatrix4dv
+	GLAD_API_CALL PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv;
+#define glGetVertexAttribfv glad_glGetVertexAttribfv
+	GLAD_API_CALL PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv;
+#define glGetActiveUniformBlockiv glad_glGetActiveUniformBlockiv
+	GLAD_API_CALL PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample;
+#define glRenderbufferStorageMultisample glad_glRenderbufferStorageMultisample
+	GLAD_API_CALL PFNGLGETVERTEXARRAYINDEXEDIVPROC glad_glGetVertexArrayIndexediv;
+#define glGetVertexArrayIndexediv glad_glGetVertexArrayIndexediv
+	GLAD_API_CALL PFNGLVERTEXARRAYELEMENTBUFFERPROC glad_glVertexArrayElementBuffer;
+#define glVertexArrayElementBuffer glad_glVertexArrayElementBuffer
+	GLAD_API_CALL PFNGLGETTEXGENDVPROC glad_glGetTexGendv;
+#define glGetTexGendv glad_glGetTexGendv
+	GLAD_API_CALL PFNGLCLEARNAMEDFRAMEBUFFERFVPROC glad_glClearNamedFramebufferfv;
+#define glClearNamedFramebufferfv glad_glClearNamedFramebufferfv
+	GLAD_API_CALL PFNGLSECONDARYCOLOR3FPROC glad_glSecondaryColor3f;
+#define glSecondaryColor3f glad_glSecondaryColor3f
+	GLAD_API_CALL PFNGLSHADERBINARYPROC glad_glShaderBinary;
+#define glShaderBinary glad_glShaderBinary
+	GLAD_API_CALL PFNGLMAP1DPROC glad_glMap1d;
+#define glMap1d glad_glMap1d
+	GLAD_API_CALL PFNGLVERTEXATTRIBL2DVPROC glad_glVertexAttribL2dv;
+#define glVertexAttribL2dv glad_glVertexAttribL2dv
+	GLAD_API_CALL PFNGLMULTITEXCOORD4DPROC glad_glMultiTexCoord4d;
+#define glMultiTexCoord4d glad_glMultiTexCoord4d
+	GLAD_API_CALL PFNGLTEXCOORD1DVPROC glad_glTexCoord1dv;
+#define glTexCoord1dv glad_glTexCoord1dv
+	GLAD_API_CALL PFNGLTEXSTORAGE2DMULTISAMPLEPROC glad_glTexStorage2DMultisample;
+#define glTexStorage2DMultisample glad_glTexStorage2DMultisample
+	GLAD_API_CALL PFNGLGENTRANSFORMFEEDBACKSPROC glad_glGenTransformFeedbacks;
+#define glGenTransformFeedbacks glad_glGenTransformFeedbacks
+	GLAD_API_CALL PFNGLCLEARBUFFERSUBDATAPROC glad_glClearBufferSubData;
+#define glClearBufferSubData glad_glClearBufferSubData
+	GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX2FVPROC glad_glProgramUniformMatrix2fv;
+#define glProgramUniformMatrix2fv glad_glProgramUniformMatrix2fv
+	GLAD_API_CALL PFNGLGETFRAMEBUFFERPARAMETERIVPROC glad_glGetFramebufferParameteriv;
+#define glGetFramebufferParameteriv glad_glGetFramebufferParameteriv
+	GLAD_API_CALL PFNGLPIXELMAPFVPROC glad_glPixelMapfv;
+#define glPixelMapfv glad_glPixelMapfv
+	GLAD_API_CALL PFNGLCOLOR3FPROC glad_glColor3f;
+#define glColor3f glad_glColor3f
+	GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC glad_glProgramUniformMatrix4x3dv;
+#define glProgramUniformMatrix4x3dv glad_glProgramUniformMatrix4x3dv
+	GLAD_API_CALL PFNGLMULTMATRIXDPROC glad_glMultMatrixd;
+#define glMultMatrixd glad_glMultMatrixd
+	GLAD_API_CALL PFNGLCOPYPIXELSPROC glad_glCopyPixels;
+#define glCopyPixels glad_glCopyPixels
+	GLAD_API_CALL PFNGLUNIFORM2DVPROC glad_glUniform2dv;
+#define glUniform2dv glad_glUniform2dv
+	GLAD_API_CALL PFNGLCOLOR3SVPROC glad_glColor3sv;
+#define glColor3sv glad_glColor3sv
+	GLAD_API_CALL PFNGLOBJECTLABELPROC glad_glObjectLabel;
+#define glObjectLabel glad_glObjectLabel
+	GLAD_API_CALL PFNGLGETOBJECTLABELPROC glad_glGetObjectLabel;
+#define glGetObjectLabel glad_glGetObjectLabel
+	GLAD_API_CALL PFNGLINDEXFVPROC glad_glIndexfv;
+#define glIndexfv glad_glIndexfv
+	GLAD_API_CALL PFNGLCOMPRESSEDTEXTURESUBIMAGE3DPROC glad_glCompressedTextureSubImage3D;
+#define glCompressedTextureSubImage3D glad_glCompressedTextureSubImage3D
+	GLAD_API_CALL PFNGLMAPGRID1DPROC glad_glMapGrid1d;
+#define glMapGrid1d glad_glMapGrid1d
+	GLAD_API_CALL PFNGLGETQUERYBUFFEROBJECTUIVPROC glad_glGetQueryBufferObjectuiv;
+#define glGetQueryBufferObjectuiv glad_glGetQueryBufferObjectuiv
+	GLAD_API_CALL PFNGLRASTERPOS3SVPROC glad_glRasterPos3sv;
+#define glRasterPos3sv glad_glRasterPos3sv
+	GLAD_API_CALL PFNGLSELECTBUFFERPROC glad_glSelectBuffer;
+#define glSelectBuffer glad_glSelectBuffer
+	GLAD_API_CALL PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv;
+#define glVertexAttribI3iv glad_glVertexAttribI3iv
+	GLAD_API_CALL PFNGLPATCHPARAMETERIPROC glad_glPatchParameteri;
+#define glPatchParameteri glad_glPatchParameteri
+	GLAD_API_CALL PFNGLGETTEXTUREPARAMETERIUIVPROC glad_glGetTextureParameterIuiv;
+#define glGetTextureParameterIuiv glad_glGetTextureParameterIuiv
+	GLAD_API_CALL PFNGLCOLOR3IVPROC glad_glColor3iv;
+#define glColor3iv glad_glColor3iv
+	GLAD_API_CALL PFNGLMAPBUFFERPROC glad_glMapBuffer;
+#define glMapBuffer glad_glMapBuffer
+	GLAD_API_CALL PFNGLNORMALP3UIPROC glad_glNormalP3ui;
+#define glNormalP3ui glad_glNormalP3ui
+	GLAD_API_CALL PFNGLVERTEXPOINTERPROC glad_glVertexPointer;
+#define glVertexPointer glad_glVertexPointer
+	GLAD_API_CALL PFNGLGETTEXTUREPARAMETERFVPROC glad_glGetTextureParameterfv;
+#define glGetTextureParameterfv glad_glGetTextureParameterfv
+	GLAD_API_CALL PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer;
+#define glVertexAttribPointer glad_glVertexAttribPointer
+	GLAD_API_CALL PFNGLDEPTHRANGEFPROC glad_glDepthRangef;
+#define glDepthRangef glad_glDepthRangef
+	GLAD_API_CALL PFNGLTEXTUREPARAMETERIVPROC glad_glTextureParameteriv;
+#define glTextureParameteriv glad_glTextureParameteriv
+	GLAD_API_CALL PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv;
+#define glVertexP2uiv glad_glVertexP2uiv
+	GLAD_API_CALL PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv;
+#define glVertexAttribI4usv glad_glVertexAttribI4usv
+	GLAD_API_CALL PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv;
+#define glTexParameteriv glad_glTexParameteriv
+	GLAD_API_CALL PFNGLBINDVERTEXBUFFERSPROC glad_glBindVertexBuffers;
+#define glBindVertexBuffers glad_glBindVertexBuffers
+	GLAD_API_CALL PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv;
+#define glVertexP3uiv glad_glVertexP3uiv
+	GLAD_API_CALL PFNGLINDEXIPROC glad_glIndexi;
+#define glIndexi glad_glIndexi
+	GLAD_API_CALL PFNGLGETACTIVESUBROUTINENAMEPROC glad_glGetActiveSubroutineName;
+#define glGetActiveSubroutineName glad_glGetActiveSubroutineName
+	GLAD_API_CALL PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D;
+#define glCompressedTexSubImage3D glad_glCompressedTexSubImage3D
+	GLAD_API_CALL PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv;
+#define glGetVertexAttribPointerv glad_glGetVertexAttribPointerv
+	GLAD_API_CALL PFNGLGETPIXELMAPUIVPROC glad_glGetPixelMapuiv;
+#define glGetPixelMapuiv glad_glGetPixelMapuiv
+	GLAD_API_CALL PFNGLGETTEXGENIVPROC glad_glGetTexGeniv;
+#define glGetTexGeniv glad_glGetTexGeniv
+	GLAD_API_CALL PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s;
+#define glVertexAttrib3s glad_glVertexAttrib3s
+	GLAD_API_CALL PFNGLPOINTSIZEPROC glad_glPointSize;
+#define glPointSize glad_glPointSize
+	GLAD_API_CALL PFNGLVERTEXP2UIPROC glad_glVertexP2ui;
+#define glVertexP2ui glad_glVertexP2ui
+	GLAD_API_CALL PFNGLMULTIDRAWARRAYSINDIRECTCOUNTPROC glad_glMultiDrawArraysIndirectCount;
+#define glMultiDrawArraysIndirectCount glad_glMultiDrawArraysIndirectCount
+	GLAD_API_CALL PFNGLGETNTEXIMAGEPROC glad_glGetnTexImage;
+#define glGetnTexImage glad_glGetnTexImage
+	GLAD_API_CALL PFNGLCULLFACEPROC glad_glCullFace;
+#define glCullFace glad_glCullFace
+	GLAD_API_CALL PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri;
+#define glSamplerParameteri glad_glSamplerParameteri
+	GLAD_API_CALL PFNGLTEXTUREBARRIERPROC glad_glTextureBarrier;
+#define glTextureBarrier glad_glTextureBarrier
+	GLAD_API_CALL PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer;
+#define glIsRenderbuffer glad_glIsRenderbuffer
+	GLAD_API_CALL PFNGLBEGINQUERYPROC glad_glBeginQuery;
+#define glBeginQuery glad_glBeginQuery
+	GLAD_API_CALL PFNGLCOLOR4USPROC glad_glColor4us;
+#define glColor4us glad_glColor4us
+	GLAD_API_CALL PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv;
+#define glGetVertexAttribdv glad_glGetVertexAttribdv
+	GLAD_API_CALL PFNGLTEXCOORD4IVPROC glad_glTexCoord4iv;
+#define glTexCoord4iv glad_glTexCoord4iv
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM1FVPROC glad_glProgramUniform1fv;
+#define glProgramUniform1fv glad_glProgramUniform1fv
+	GLAD_API_CALL PFNGLDELETETEXTURESPROC glad_glDeleteTextures;
+#define glDeleteTextures glad_glDeleteTextures
+	GLAD_API_CALL PFNGLWINDOWPOS2IVPROC glad_glWindowPos2iv;
+#define glWindowPos2iv glad_glWindowPos2iv
+	GLAD_API_CALL PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer;
+#define glVertexAttribIPointer glad_glVertexAttribIPointer
+	GLAD_API_CALL PFNGLCREATEVERTEXARRAYSPROC glad_glCreateVertexArrays;
+#define glCreateVertexArrays glad_glCreateVertexArrays
+	GLAD_API_CALL PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i;
+#define glVertexAttribI1i glad_glVertexAttribI1i
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM3UIPROC glad_glProgramUniform3ui;
+#define glProgramUniform3ui glad_glProgramUniform3ui
+	GLAD_API_CALL PFNGLCOMPRESSEDTEXTURESUBIMAGE2DPROC glad_glCompressedTextureSubImage2D;
+#define glCompressedTextureSubImage2D glad_glCompressedTextureSubImage2D
+	GLAD_API_CALL PFNGLRECTDPROC glad_glRectd;
+#define glRectd glad_glRectd
+	GLAD_API_CALL PFNGLMULTTRANSPOSEMATRIXDPROC glad_glMultTransposeMatrixd;
+#define glMultTransposeMatrixd glad_glMultTransposeMatrixd
+	GLAD_API_CALL PFNGLTEXENVFPROC glad_glTexEnvf;
+#define glTexEnvf glad_glTexEnvf
+	GLAD_API_CALL PFNGLNORMAL3IPROC glad_glNormal3i;
+#define glNormal3i glad_glNormal3i
+	GLAD_API_CALL PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation;
+#define glBindAttribLocation glad_glBindAttribLocation
+	GLAD_API_CALL PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate;
+#define glStencilMaskSeparate glad_glStencilMaskSeparate
+	GLAD_API_CALL PFNGLGETINTEGERVPROC glad_glGetIntegerv;
+#define glGetIntegerv glad_glGetIntegerv
+	GLAD_API_CALL PFNGLUSEPROGRAMPROC glad_glUseProgram;
+#define glUseProgram glad_glUseProgram
+	GLAD_API_CALL PFNGLNORMAL3BVPROC glad_glNormal3bv;
+#define glNormal3bv glad_glNormal3bv
+	GLAD_API_CALL PFNGLPIXELSTOREIPROC glad_glPixelStorei;
+#define glPixelStorei glad_glPixelStorei
+	GLAD_API_CALL PFNGLNORMAL3SPROC glad_glNormal3s;
+#define glNormal3s glad_glNormal3s
+	GLAD_API_CALL PFNGLCOLOR4IVPROC glad_glColor4iv;
+#define glColor4iv glad_glColor4iv
+	GLAD_API_CALL PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv;
+#define glMultiTexCoordP2uiv glad_glMultiTexCoordP2uiv
+	GLAD_API_CALL PFNGLARETEXTURESRESIDENTPROC glad_glAreTexturesResident;
+#define glAreTexturesResident glad_glAreTexturesResident
+	GLAD_API_CALL PFNGLGETUNIFORMFVPROC glad_glGetUniformfv;
+#define glGetUniformfv glad_glGetUniformfv
+	GLAD_API_CALL PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC glad_glGetActiveSubroutineUniformName;
+#define glGetActiveSubroutineUniformName glad_glGetActiveSubroutineUniformName
+	GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC glad_glProgramUniformMatrix2x4fv;
+#define glProgramUniformMatrix2x4fv glad_glProgramUniformMatrix2x4fv
+	GLAD_API_CALL PFNGLTEXSTORAGE3DPROC glad_glTexStorage3D;
+#define glTexStorage3D glad_glTexStorage3D
+	GLAD_API_CALL PFNGLTEXCOORD1IPROC glad_glTexCoord1i;
+#define glTexCoord1i glad_glTexCoord1i
+	GLAD_API_CALL PFNGLGETCOMPRESSEDTEXTURESUBIMAGEPROC glad_glGetCompressedTextureSubImage;
+#define glGetCompressedTextureSubImage glad_glGetCompressedTextureSubImage
+	GLAD_API_CALL PFNGLVERTEXARRAYVERTEXBUFFERSPROC glad_glVertexArrayVertexBuffers;
+#define glVertexArrayVertexBuffers glad_glVertexArrayVertexBuffers
+	GLAD_API_CALL PFNGLSECONDARYCOLOR3DPROC glad_glSecondaryColor3d;
+#define glSecondaryColor3d glad_glSecondaryColor3d
+	GLAD_API_CALL PFNGLINTERLEAVEDARRAYSPROC glad_glInterleavedArrays;
+#define glInterleavedArrays glad_glInterleavedArrays
+	GLAD_API_CALL PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer;
+#define glUnmapBuffer glad_glUnmapBuffer
+	GLAD_API_CALL PFNGLISENABLEDIPROC glad_glIsEnabledi;
+#define glIsEnabledi glad_glIsEnabledi
+	GLAD_API_CALL PFNGLBINDSAMPLERSPROC glad_glBindSamplers;
+#define glBindSamplers glad_glBindSamplers
+	GLAD_API_CALL PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D;
+#define glCompressedTexSubImage1D glad_glCompressedTexSubImage1D
+	GLAD_API_CALL PFNGLPRIORITIZETEXTURESPROC glad_glPrioritizeTextures;
+#define glPrioritizeTextures glad_glPrioritizeTextures
+	GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC glad_glProgramUniformMatrix4x2fv;
+#define glProgramUniformMatrix4x2fv glad_glProgramUniformMatrix4x2fv
+	GLAD_API_CALL PFNGLRASTERPOS4DPROC glad_glRasterPos4d;
+#define glRasterPos4d glad_glRasterPos4d
+	GLAD_API_CALL PFNGLSECONDARYCOLOR3USVPROC glad_glSecondaryColor3usv;
+#define glSecondaryColor3usv glad_glSecondaryColor3usv
+	GLAD_API_CALL PFNGLGETSYNCIVPROC glad_glGetSynciv;
+#define glGetSynciv glad_glGetSynciv
+	GLAD_API_CALL PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv;
+#define glSamplerParameterIiv glad_glSamplerParameterIiv
+	GLAD_API_CALL PFNGLLIGHTMODELFVPROC glad_glLightModelfv;
+#define glLightModelfv glad_glLightModelfv
+	GLAD_API_CALL PFNGLTEXTURESTORAGE3DPROC glad_glTextureStorage3D;
+#define glTextureStorage3D glad_glTextureStorage3D
+	GLAD_API_CALL PFNGLRESUMETRANSFORMFEEDBACKPROC glad_glResumeTransformFeedback;
+#define glResumeTransformFeedback glad_glResumeTransformFeedback
+	GLAD_API_CALL PFNGLGENPROGRAMPIPELINESPROC glad_glGenProgramPipelines;
+#define glGenProgramPipelines glad_glGenProgramPipelines
+	GLAD_API_CALL PFNGLVERTEX4FVPROC glad_glVertex4fv;
+#define glVertex4fv glad_glVertex4fv
+	GLAD_API_CALL PFNGLLIGHTIVPROC glad_glLightiv;
+#define glLightiv glad_glLightiv
+	GLAD_API_CALL PFNGLCLEARNAMEDFRAMEBUFFERIVPROC glad_glClearNamedFramebufferiv;
+#define glClearNamedFramebufferiv glad_glClearNamedFramebufferiv
+	GLAD_API_CALL PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv;
+#define glGetTexParameteriv glad_glGetTexParameteriv
+	GLAD_API_CALL PFNGLTEXCOORD3DVPROC glad_glTexCoord3dv;
+#define glTexCoord3dv glad_glTexCoord3dv
+	GLAD_API_CALL PFNGLFOGCOORDPOINTERPROC glad_glFogCoordPointer;
+#define glFogCoordPointer glad_glFogCoordPointer
+	GLAD_API_CALL PFNGLUNIFORM2IPROC glad_glUniform2i;
+#define glUniform2i glad_glUniform2i
+	GLAD_API_CALL PFNGLTEXTURESUBIMAGE3DPROC glad_glTextureSubImage3D;
+#define glTextureSubImage3D glad_glTextureSubImage3D
+	GLAD_API_CALL PFNGLGETDOUBLEI_VPROC glad_glGetDoublei_v;
+#define glGetDoublei_v glad_glGetDoublei_v
+	GLAD_API_CALL PFNGLCLEARBUFFERDATAPROC glad_glClearBufferData;
+#define glClearBufferData glad_glClearBufferData
+	GLAD_API_CALL PFNGLBINDTEXTUREPROC glad_glBindTexture;
+#define glBindTexture glad_glBindTexture
+	GLAD_API_CALL PFNGLTEXTUREBUFFERRANGEPROC glad_glTextureBufferRange;
+#define glTextureBufferRange glad_glTextureBufferRange
+	GLAD_API_CALL PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv;
+#define glGetTexLevelParameterfv glad_glGetTexLevelParameterfv
+	GLAD_API_CALL PFNGLSAMPLEMASKIPROC glad_glSampleMaski;
+#define glSampleMaski glad_glSampleMaski
+	GLAD_API_CALL PFNGLCLEARACCUMPROC glad_glClearAccum;
+#define glClearAccum glad_glClearAccum
+	GLAD_API_CALL PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform;
+#define glGetActiveUniform glad_glGetActiveUniform
+	GLAD_API_CALL PFNGLGETPROGRAMBINARYPROC glad_glGetProgramBinary;
+#define glGetProgramBinary glad_glGetProgramBinary
+	GLAD_API_CALL PFNGLDETACHSHADERPROC glad_glDetachShader;
+#define glDetachShader glad_glDetachShader
+	GLAD_API_CALL PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s;
+#define glVertexAttrib4s glad_glVertexAttrib4s
+	GLAD_API_CALL PFNGLTEXTUREPARAMETERIPROC glad_glTextureParameteri;
+#define glTextureParameteri glad_glTextureParameteri
+	GLAD_API_CALL PFNGLCOLOR3DVPROC glad_glColor3dv;
+#define glColor3dv glad_glColor3dv
+	GLAD_API_CALL PFNGLBINDSAMPLERPROC glad_glBindSampler;
+#define glBindSampler glad_glBindSampler
+	GLAD_API_CALL PFNGLCHECKNAMEDFRAMEBUFFERSTATUSPROC glad_glCheckNamedFramebufferStatus;
+#define glCheckNamedFramebufferStatus glad_glCheckNamedFramebufferStatus
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM1IVPROC glad_glProgramUniform1iv;
+#define glProgramUniform1iv glad_glProgramUniform1iv
+	GLAD_API_CALL PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays;
+#define glMultiDrawArrays glad_glMultiDrawArrays
+	GLAD_API_CALL PFNGLRASTERPOS4DVPROC glad_glRasterPos4dv;
+#define glRasterPos4dv glad_glRasterPos4dv
+	GLAD_API_CALL PFNGLGETFLOATVPROC glad_glGetFloatv;
+#define glGetFloatv glad_glGetFloatv
+	GLAD_API_CALL PFNGLPROGRAMPARAMETERIPROC glad_glProgramParameteri;
+#define glProgramParameteri glad_glProgramParameteri
+	GLAD_API_CALL PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers;
+#define glDeleteRenderbuffers glad_glDeleteRenderbuffers
+	GLAD_API_CALL PFNGLSECONDARYCOLORPOINTERPROC glad_glSecondaryColorPointer;
+#define glSecondaryColorPointer glad_glSecondaryColorPointer
+	GLAD_API_CALL PFNGLISSAMPLERPROC glad_glIsSampler;
+#define glIsSampler glad_glIsSampler
+	GLAD_API_CALL PFNGLMULTITEXCOORD1DVPROC glad_glMultiTexCoord1dv;
+#define glMultiTexCoord1dv glad_glMultiTexCoord1dv
+	GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC glad_glProgramUniformMatrix2x3fv;
+#define glProgramUniformMatrix2x3fv glad_glProgramUniformMatrix2x3fv
+	GLAD_API_CALL PFNGLDEBUGMESSAGECONTROLPROC glad_glDebugMessageControl;
+#define glDebugMessageControl glad_glDebugMessageControl
+	GLAD_API_CALL PFNGLBINDBUFFERSRANGEPROC glad_glBindBuffersRange;
+#define glBindBuffersRange glad_glBindBuffersRange
+	GLAD_API_CALL PFNGLMULTIDRAWARRAYSINDIRECTPROC glad_glMultiDrawArraysIndirect;
+#define glMultiDrawArraysIndirect glad_glMultiDrawArraysIndirect
+	GLAD_API_CALL PFNGLGETMAPDVPROC glad_glGetMapdv;
+#define glGetMapdv glad_glGetMapdv
+	GLAD_API_CALL PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui;
+#define glTexCoordP3ui glad_glTexCoordP3ui
+	GLAD_API_CALL PFNGLVERTEXATTRIBIFORMATPROC glad_glVertexAttribIFormat;
+#define glVertexAttribIFormat glad_glVertexAttribIFormat
+	GLAD_API_CALL PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC glad_glDrawTransformFeedbackStreamInstanced;
+#define glDrawTransformFeedbackStreamInstanced glad_glDrawTransformFeedbackStreamInstanced
+	GLAD_API_CALL PFNGLTRANSFORMFEEDBACKBUFFERBASEPROC glad_glTransformFeedbackBufferBase;
+#define glTransformFeedbackBufferBase glad_glTransformFeedbackBufferBase
+	GLAD_API_CALL PFNGLGETTEXENVIVPROC glad_glGetTexEnviv;
+#define glGetTexEnviv glad_glGetTexEnviv
+	GLAD_API_CALL PFNGLCOLORP3UIVPROC glad_glColorP3uiv;
+#define glColorP3uiv glad_glColorP3uiv
+	GLAD_API_CALL PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f;
+#define glVertexAttrib1f glad_glVertexAttrib1f
+	GLAD_API_CALL PFNGLPOPCLIENTATTRIBPROC glad_glPopClientAttrib;
+#define glPopClientAttrib glad_glPopClientAttrib
+	GLAD_API_CALL PFNGLGETTEXIMAGEPROC glad_glGetTexImage;
+#define glGetTexImage glad_glGetTexImage
+	GLAD_API_CALL PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage;
+#define glRenderbufferStorage glad_glRenderbufferStorage
+	GLAD_API_CALL PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers;
+#define glDeleteBuffers glad_glDeleteBuffers
+	GLAD_API_CALL PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync;
+#define glClientWaitSync glad_glClientWaitSync
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM1DVPROC glad_glProgramUniform1dv;
+#define glProgramUniform1dv glad_glProgramUniform1dv
+	GLAD_API_CALL PFNGLCLEARTEXIMAGEPROC glad_glClearTexImage;
+#define glClearTexImage glad_glClearTexImage
+	GLAD_API_CALL PFNGLMULTITEXCOORD2FVPROC glad_glMultiTexCoord2fv;
+#define glMultiTexCoord2fv glad_glMultiTexCoord2fv
+	GLAD_API_CALL PFNGLUNIFORM3UIVPROC glad_glUniform3uiv;
+#define glUniform3uiv glad_glUniform3uiv
+	GLAD_API_CALL PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName;
+#define glGetActiveUniformName glad_glGetActiveUniformName
+	GLAD_API_CALL PFNGLEVALPOINT1PROC glad_glEvalPoint1;
+#define glEvalPoint1 glad_glEvalPoint1
+	GLAD_API_CALL PFNGLCOLOR3USPROC glad_glColor3us;
+#define glColor3us glad_glColor3us
+	GLAD_API_CALL PFNGLGETTEXTURESUBIMAGEPROC glad_glGetTextureSubImage;
+#define glGetTextureSubImage glad_glGetTextureSubImage
+	GLAD_API_CALL PFNGLCOLOR3IPROC glad_glColor3i;
+#define glColor3i glad_glColor3i
+	GLAD_API_CALL PFNGLSECONDARYCOLOR3DVPROC glad_glSecondaryColor3dv;
+#define glSecondaryColor3dv glad_glSecondaryColor3dv
+	GLAD_API_CALL PFNGLEVALCOORD1FVPROC glad_glEvalCoord1fv;
+#define glEvalCoord1fv glad_glEvalCoord1fv
+	GLAD_API_CALL PFNGLVIEWPORTARRAYVPROC glad_glViewportArrayv;
+#define glViewportArrayv glad_glViewportArrayv
+	GLAD_API_CALL PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i;
+#define glVertexAttribI4i glad_glVertexAttribI4i
+	GLAD_API_CALL PFNGLVERTEXATTRIBL4DPROC glad_glVertexAttribL4d;
+#define glVertexAttribL4d glad_glVertexAttribL4d
+	GLAD_API_CALL PFNGLCOLOR4DPROC glad_glColor4d;
+#define glColor4d glad_glColor4d
+	GLAD_API_CALL PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation;
+#define glGetFragDataLocation glad_glGetFragDataLocation
+	GLAD_API_CALL PFNGLCOLOR4UBVPROC glad_glColor4ubv;
+#define glColor4ubv glad_glColor4ubv
+	GLAD_API_CALL PFNGLUNIFORMMATRIX4DVPROC glad_glUniformMatrix4dv;
+#define glUniformMatrix4dv glad_glUniformMatrix4dv
+	GLAD_API_CALL PFNGLUNIFORMMATRIX3X4DVPROC glad_glUniformMatrix3x4dv;
+#define glUniformMatrix3x4dv glad_glUniformMatrix3x4dv
+	GLAD_API_CALL PFNGLSCISSORPROC glad_glScissor;
+#define glScissor glad_glScissor
+	GLAD_API_CALL PFNGLUNIFORMSUBROUTINESUIVPROC glad_glUniformSubroutinesuiv;
+#define glUniformSubroutinesuiv glad_glUniformSubroutinesuiv
+	GLAD_API_CALL PFNGLVERTEX4IVPROC glad_glVertex4iv;
+#define glVertex4iv glad_glVertex4iv
+	GLAD_API_CALL PFNGLCOLORMASKPROC glad_glColorMask;
+#define glColorMask glad_glColorMask
+	GLAD_API_CALL PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate;
+#define glStencilOpSeparate glad_glStencilOpSeparate
+	GLAD_API_CALL PFNGLGETBOOLEANVPROC glad_glGetBooleanv;
+#define glGetBooleanv glad_glGetBooleanv
+	GLAD_API_CALL PFNGLVERTEX3DPROC glad_glVertex3d;
+#define glVertex3d glad_glVertex3d
+	GLAD_API_CALL PFNGLGETNAMEDBUFFERPOINTERVPROC glad_glGetNamedBufferPointerv;
+#define glGetNamedBufferPointerv glad_glGetNamedBufferPointerv
+	GLAD_API_CALL PFNGLVERTEXARRAYVERTEXBUFFERPROC glad_glVertexArrayVertexBuffer;
+#define glVertexArrayVertexBuffer glad_glVertexArrayVertexBuffer
+	GLAD_API_CALL PFNGLGETPOLYGONSTIPPLEPROC glad_glGetPolygonStipple;
+#define glGetPolygonStipple glad_glGetPolygonStipple
+	GLAD_API_CALL PFNGLSTENCILOPPROC glad_glStencilOp;
+#define glStencilOp glad_glStencilOp
+	GLAD_API_CALL PFNGLVIEWPORTPROC glad_glViewport;
+#define glViewport glad_glViewport
+	GLAD_API_CALL PFNGLGETNPOLYGONSTIPPLEPROC glad_glGetnPolygonStipple;
+#define glGetnPolygonStipple glad_glGetnPolygonStipple
+	GLAD_API_CALL PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv;
+#define glVertexAttrib4usv glad_glVertexAttrib4usv
+	GLAD_API_CALL PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback;
+#define glEndTransformFeedback glad_glEndTransformFeedback
+	GLAD_API_CALL PFNGLCREATEPROGRAMPROC glad_glCreateProgram;
+#define glCreateProgram glad_glCreateProgram
+	GLAD_API_CALL PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog;
+#define glGetShaderInfoLog glad_glGetShaderInfoLog
+	GLAD_API_CALL PFNGLGETVERTEXARRAYINDEXED64IVPROC glad_glGetVertexArrayIndexed64iv;
+#define glGetVertexArrayIndexed64iv glad_glGetVertexArrayIndexed64iv
+	GLAD_API_CALL PFNGLTEXGENDPROC glad_glTexGend;
+#define glTexGend glad_glTexGend
+	GLAD_API_CALL PFNGLINDEXUBPROC glad_glIndexub;
+#define glIndexub glad_glIndexub
+	GLAD_API_CALL PFNGLMULTMATRIXFPROC glad_glMultMatrixf;
+#define glMultMatrixf glad_glMultMatrixf
+	GLAD_API_CALL PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui;
+#define glMultiTexCoordP2ui glad_glMultiTexCoordP2ui
+	GLAD_API_CALL PFNGLTEXIMAGE3DPROC glad_glTexImage3D;
+#define glTexImage3D glad_glTexImage3D
+	GLAD_API_CALL PFNGLGETNUNIFORMDVPROC glad_glGetnUniformdv;
+#define glGetnUniformdv glad_glGetnUniformdv
+	GLAD_API_CALL PFNGLRECTIVPROC glad_glRectiv;
+#define glRectiv glad_glRectiv
+	GLAD_API_CALL PFNGLTEXCOORD4SPROC glad_glTexCoord4s;
+#define glTexCoord4s glad_glTexCoord4s
+	GLAD_API_CALL PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D;
+#define glCopyTexImage2D glad_glCopyTexImage2D
+	GLAD_API_CALL PFNGLLOGICOPPROC glad_glLogicOp;
+#define glLogicOp glad_glLogicOp
+	GLAD_API_CALL PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv;
+#define glUniformMatrix2fv glad_glUniformMatrix2fv
+	GLAD_API_CALL PFNGLSECONDARYCOLOR3FVPROC glad_glSecondaryColor3fv;
+#define glSecondaryColor3fv glad_glSecondaryColor3fv
+	GLAD_API_CALL PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer;
+#define glBindRenderbuffer glad_glBindRenderbuffer
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM4UIVPROC glad_glProgramUniform4uiv;
+#define glProgramUniform4uiv glad_glProgramUniform4uiv
+	GLAD_API_CALL PFNGLCREATESAMPLERSPROC glad_glCreateSamplers;
+#define glCreateSamplers glad_glCreateSamplers
+	GLAD_API_CALL PFNGLPIXELMAPUIVPROC glad_glPixelMapuiv;
+#define glPixelMapuiv glad_glPixelMapuiv
+	GLAD_API_CALL PFNGLBLENDCOLORPROC glad_glBlendColor;
+#define glBlendColor glad_glBlendColor
+	GLAD_API_CALL PFNGLLIGHTMODELIPROC glad_glLightModeli;
+#define glLightModeli glad_glLightModeli
+	GLAD_API_CALL PFNGLPOINTPARAMETERIPROC glad_glPointParameteri;
+#define glPointParameteri glad_glPointParameteri
+	GLAD_API_CALL PFNGLGENQUERIESPROC glad_glGenQueries;
+#define glGenQueries glad_glGenQueries
+	GLAD_API_CALL PFNGLNAMEDFRAMEBUFFERTEXTUREPROC glad_glNamedFramebufferTexture;
+#define glNamedFramebufferTexture glad_glNamedFramebufferTexture
+	GLAD_API_CALL PFNGLGETNSEPARABLEFILTERPROC glad_glGetnSeparableFilter;
+#define glGetnSeparableFilter glad_glGetnSeparableFilter
+	GLAD_API_CALL PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv;
+#define glGetQueryObjectuiv glad_glGetQueryObjectuiv
+	GLAD_API_CALL PFNGLCOLOR4FVPROC glad_glColor4fv;
+#define glColor4fv glad_glColor4fv
+	GLAD_API_CALL PFNGLGETVERTEXARRAYIVPROC glad_glGetVertexArrayiv;
+#define glGetVertexArrayiv glad_glGetVertexArrayiv
+	GLAD_API_CALL PFNGLUNIFORM1UIPROC glad_glUniform1ui;
+#define glUniform1ui glad_glUniform1ui
+	GLAD_API_CALL PFNGLGETNMAPFVPROC glad_glGetnMapfv;
+#define glGetnMapfv glad_glGetnMapfv
+	GLAD_API_CALL PFNGLUNIFORM4FVPROC glad_glUniform4fv;
+#define glUniform4fv glad_glUniform4fv
+	GLAD_API_CALL PFNGLTEXGENFPROC glad_glTexGenf;
+#define glTexGenf glad_glTexGenf
+	GLAD_API_CALL PFNGLINDEXIVPROC glad_glIndexiv;
+#define glIndexiv glad_glIndexiv
+	GLAD_API_CALL PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv;
+#define glVertexAttrib1fv glad_glVertexAttrib1fv
+	GLAD_API_CALL PFNGLMULTITEXCOORD3IPROC glad_glMultiTexCoord3i;
+#define glMultiTexCoord3i glad_glMultiTexCoord3i
+	GLAD_API_CALL PFNGLCOLOR4USVPROC glad_glColor4usv;
+#define glColor4usv glad_glColor4usv
+	GLAD_API_CALL PFNGLDRAWBUFFERSPROC glad_glDrawBuffers;
+#define glDrawBuffers glad_glDrawBuffers
+	GLAD_API_CALL PFNGLWINDOWPOS2IPROC glad_glWindowPos2i;
+#define glWindowPos2i glad_glWindowPos2i
+	GLAD_API_CALL PFNGLTEXBUFFERRANGEPROC glad_glTexBufferRange;
+#define glTexBufferRange glad_glTexBufferRange
+	GLAD_API_CALL PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv;
+#define glMultiTexCoordP1uiv glad_glMultiTexCoordP1uiv
+	GLAD_API_CALL PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv;
+#define glVertexAttribI2iv glad_glVertexAttribI2iv
+	GLAD_API_CALL PFNGLMULTIDRAWELEMENTSINDIRECTPROC glad_glMultiDrawElementsIndirect;
+#define glMultiDrawElementsIndirect glad_glMultiDrawElementsIndirect
+	GLAD_API_CALL PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv;
+#define glUniformMatrix2x4fv glad_glUniformMatrix2x4fv
+	GLAD_API_CALL PFNGLUNIFORM3IPROC glad_glUniform3i;
+#define glUniform3i glad_glUniform3i
+	GLAD_API_CALL PFNGLGETCLIPPLANEPROC glad_glGetClipPlane;
+#define glGetClipPlane glad_glGetClipPlane
+	GLAD_API_CALL PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv;
+#define glVertexAttribP2uiv glad_glVertexAttribP2uiv
+	GLAD_API_CALL PFNGLTEXCOORD2IPROC glad_glTexCoord2i;
+#define glTexCoord2i glad_glTexCoord2i
+	GLAD_API_CALL PFNGLUNIFORM4UIPROC glad_glUniform4ui;
+#define glUniform4ui glad_glUniform4ui
+	GLAD_API_CALL PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC glad_glDrawElementsInstancedBaseVertexBaseInstance;
+#define glDrawElementsInstancedBaseVertexBaseInstance glad_glDrawElementsInstancedBaseVertexBaseInstance
+	GLAD_API_CALL PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv;
+#define glVertexAttrib4Nusv glad_glVertexAttrib4Nusv
+	GLAD_API_CALL PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d;
+#define glVertexAttrib1d glad_glVertexAttrib1d
+	GLAD_API_CALL PFNGLGETLIGHTIVPROC glad_glGetLightiv;
+#define glGetLightiv glad_glGetLightiv
+	GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC glad_glProgramUniformMatrix3x4dv;
+#define glProgramUniformMatrix3x4dv glad_glProgramUniformMatrix3x4dv
+	GLAD_API_CALL PFNGLTEXTURESTORAGE1DPROC glad_glTextureStorage1D;
+#define glTextureStorage1D glad_glTextureStorage1D
+	GLAD_API_CALL PFNGLSTENCILMASKPROC glad_glStencilMask;
+#define glStencilMask glad_glStencilMask
+	GLAD_API_CALL PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv;
+#define glGetRenderbufferParameteriv glad_glGetRenderbufferParameteriv
+	GLAD_API_CALL PFNGLMULTITEXCOORD4FPROC glad_glMultiTexCoord4f;
+#define glMultiTexCoord4f glad_glMultiTexCoord4f
+	GLAD_API_CALL PFNGLINDEXDPROC glad_glIndexd;
+#define glIndexd glad_glIndexd
+	GLAD_API_CALL PFNGLNORMALP3UIVPROC glad_glNormalP3uiv;
+#define glNormalP3uiv glad_glNormalP3uiv
+	GLAD_API_CALL PFNGLEVALMESH1PROC glad_glEvalMesh1;
+#define glEvalMesh1 glad_glEvalMesh1
+	GLAD_API_CALL PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv;
+#define glTexCoordP3uiv glad_glTexCoordP3uiv
+	GLAD_API_CALL PFNGLVERTEXATTRIBL4DVPROC glad_glVertexAttribL4dv;
+#define glVertexAttribL4dv glad_glVertexAttribL4dv
+	GLAD_API_CALL PFNGLCLIENTACTIVETEXTUREPROC glad_glClientActiveTexture;
+#define glClientActiveTexture glad_glClientActiveTexture
+	GLAD_API_CALL PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s;
+#define glVertexAttrib2s glad_glVertexAttrib2s
+	GLAD_API_CALL PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv;
+#define glVertexAttrib3dv glad_glVertexAttrib3dv
+	GLAD_API_CALL PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv;
+#define glTexParameterIiv glad_glTexParameterIiv
+	GLAD_API_CALL PFNGLRASTERPOS3DPROC glad_glRasterPos3d;
+#define glRasterPos3d glad_glRasterPos3d
+	GLAD_API_CALL PFNGLEVALCOORD2FVPROC glad_glEvalCoord2fv;
+#define glEvalCoord2fv glad_glEvalCoord2fv
+	GLAD_API_CALL PFNGLBINDTEXTUREUNITPROC glad_glBindTextureUnit;
+#define glBindTextureUnit glad_glBindTextureUnit
+	GLAD_API_CALL PFNGLWAITSYNCPROC glad_glWaitSync;
+#define glWaitSync glad_glWaitSync
+	GLAD_API_CALL PFNGLMATERIALFVPROC glad_glMaterialfv;
+#define glMaterialfv glad_glMaterialfv
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM2IPROC glad_glProgramUniform2i;
+#define glProgramUniform2i glad_glProgramUniform2i
+	GLAD_API_CALL PFNGLRASTERPOS2SPROC glad_glRasterPos2s;
+#define glRasterPos2s glad_glRasterPos2s
+	GLAD_API_CALL PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv;
+#define glVertexAttribI4bv glad_glVertexAttribI4bv
+	GLAD_API_CALL PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv;
+#define glVertexAttribI4sv glad_glVertexAttribI4sv
+	GLAD_API_CALL PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate;
+#define glBlendEquationSeparate glad_glBlendEquationSeparate
+	GLAD_API_CALL PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv;
+#define glVertexAttribI3uiv glad_glVertexAttribI3uiv
+	GLAD_API_CALL PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv;
+#define glVertexAttribI2uiv glad_glVertexAttribI2uiv
+	GLAD_API_CALL PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv;
+#define glVertexP4uiv glad_glVertexP4uiv
+	GLAD_API_CALL PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex;
+#define glGetUniformBlockIndex glad_glGetUniformBlockIndex
+	GLAD_API_CALL PFNGLDEPTHFUNCPROC glad_glDepthFunc;
+#define glDepthFunc glad_glDepthFunc
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM4FPROC glad_glProgramUniform4f;
+#define glProgramUniform4f glad_glProgramUniform4f
+	GLAD_API_CALL PFNGLSHADERSOURCEPROC glad_glShaderSource;
+#define glShaderSource glad_glShaderSource
+	GLAD_API_CALL PFNGLVERTEX2IVPROC glad_glVertex2iv;
+#define glVertex2iv glad_glVertex2iv
+	GLAD_API_CALL PFNGLMAPNAMEDBUFFERPROC glad_glMapNamedBuffer;
+#define glMapNamedBuffer glad_glMapNamedBuffer
+	GLAD_API_CALL PFNGLCLEARDEPTHFPROC glad_glClearDepthf;
+#define glClearDepthf glad_glClearDepthf
+	GLAD_API_CALL PFNGLUNIFORM1FPROC glad_glUniform1f;
+#define glUniform1f glad_glUniform1f
+	GLAD_API_CALL PFNGLMULTITEXCOORD1DPROC glad_glMultiTexCoord1d;
+#define glMultiTexCoord1d glad_glMultiTexCoord1d
+	GLAD_API_CALL PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v;
+#define glGetQueryObjectui64v glad_glGetQueryObjectui64v
+	GLAD_API_CALL PFNGLNAMEDFRAMEBUFFERDRAWBUFFERSPROC glad_glNamedFramebufferDrawBuffers;
+#define glNamedFramebufferDrawBuffers glad_glNamedFramebufferDrawBuffers
+	GLAD_API_CALL PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D;
+#define glTexSubImage3D glad_glTexSubImage3D
+	GLAD_API_CALL PFNGLDELETETRANSFORMFEEDBACKSPROC glad_glDeleteTransformFeedbacks;
+#define glDeleteTransformFeedbacks glad_glDeleteTransformFeedbacks
+	GLAD_API_CALL PFNGLVERTEX3IVPROC glad_glVertex3iv;
+#define glVertex3iv glad_glVertex3iv
+	GLAD_API_CALL PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv;
+#define glUniformMatrix2x3fv glad_glUniformMatrix2x3fv
+	GLAD_API_CALL PFNGLISTEXTUREPROC glad_glIsTexture;
+#define glIsTexture glad_glIsTexture
+	GLAD_API_CALL PFNGLMULTTRANSPOSEMATRIXFPROC glad_glMultTransposeMatrixf;
+#define glMultTransposeMatrixf glad_glMultTransposeMatrixf
+	GLAD_API_CALL PFNGLNEWLISTPROC glad_glNewList;
+#define glNewList glad_glNewList
+	GLAD_API_CALL PFNGLSCALEFPROC glad_glScalef;
+#define glScalef glad_glScalef
+	GLAD_API_CALL PFNGLVERTEX3FPROC glad_glVertex3f;
+#define glVertex3f glad_glVertex3f
+	GLAD_API_CALL PFNGLTEXCOORD1IVPROC glad_glTexCoord1iv;
+#define glTexCoord1iv glad_glTexCoord1iv
+	GLAD_API_CALL PFNGLFOGCOORDFVPROC glad_glFogCoordfv;
+#define glFogCoordfv glad_glFogCoordfv
+	GLAD_API_CALL PFNGLMAPGRID2DPROC glad_glMapGrid2d;
+#define glMapGrid2d glad_glMapGrid2d
+	GLAD_API_CALL PFNGLWINDOWPOS2FVPROC glad_glWindowPos2fv;
+#define glWindowPos2fv glad_glWindowPos2fv
+	GLAD_API_CALL PFNGLREADPIXELSPROC glad_glReadPixels;
+#define glReadPixels glad_glReadPixels
+	GLAD_API_CALL PFNGLINVALIDATETEXSUBIMAGEPROC glad_glInvalidateTexSubImage;
+#define glInvalidateTexSubImage glad_glInvalidateTexSubImage
+	GLAD_API_CALL PFNGLORTHOPROC glad_glOrtho;
+#define glOrtho glad_glOrtho
+	GLAD_API_CALL PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv;
+#define glGetQueryObjectiv glad_glGetQueryObjectiv
+	GLAD_API_CALL PFNGLWINDOWPOS2SVPROC glad_glWindowPos2sv;
+#define glWindowPos2sv glad_glWindowPos2sv
+	GLAD_API_CALL PFNGLFOGFPROC glad_glFogf;
+#define glFogf glad_glFogf
+	GLAD_API_CALL PFNGLCOLOR3SPROC glad_glColor3s;
+#define glColor3s glad_glColor3s
+	GLAD_API_CALL PFNGLUNIFORM2UIVPROC glad_glUniform2uiv;
+#define glUniform2uiv glad_glUniform2uiv
+	GLAD_API_CALL PFNGLPIXELZOOMPROC glad_glPixelZoom;
+#define glPixelZoom glad_glPixelZoom
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM3FPROC glad_glProgramUniform3f;
+#define glProgramUniform3f glad_glProgramUniform3f
+	GLAD_API_CALL PFNGLEVALCOORD2DVPROC glad_glEvalCoord2dv;
+#define glEvalCoord2dv glad_glEvalCoord2dv
+	GLAD_API_CALL PFNGLVERTEX3DVPROC glad_glVertex3dv;
+#define glVertex3dv glad_glVertex3dv
+	GLAD_API_CALL PFNGLUNIFORM3FVPROC glad_glUniform3fv;
+#define glUniform3fv glad_glUniform3fv
+	GLAD_API_CALL PFNGLENABLEPROC glad_glEnable;
+#define glEnable glad_glEnable
+	GLAD_API_CALL PFNGLTEXTUREPARAMETERIUIVPROC glad_glTextureParameterIuiv;
+#define glTextureParameterIuiv glad_glTextureParameterIuiv
+	GLAD_API_CALL PFNGLFOGCOORDDVPROC glad_glFogCoorddv;
+#define glFogCoorddv glad_glFogCoorddv
+	GLAD_API_CALL PFNGLBUFFERDATAPROC glad_glBufferData;
+#define glBufferData glad_glBufferData
+	GLAD_API_CALL PFNGLPOPATTRIBPROC glad_glPopAttrib;
+#define glPopAttrib glad_glPopAttrib
+	GLAD_API_CALL PFNGLNORMAL3DVPROC glad_glNormal3dv;
+#define glNormal3dv glad_glNormal3dv
+	GLAD_API_CALL PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex;
+#define glGetFragDataIndex glad_glGetFragDataIndex
+	GLAD_API_CALL PFNGLPASSTHROUGHPROC glad_glPassThrough;
+#define glPassThrough glad_glPassThrough
+	GLAD_API_CALL PFNGLTEXCOORD2DVPROC glad_glTexCoord2dv;
+#define glTexCoord2dv glad_glTexCoord2dv
+	GLAD_API_CALL PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv;
+#define glTexCoordP4uiv glad_glTexCoordP4uiv
+	GLAD_API_CALL PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv;
+#define glClearBufferuiv glad_glClearBufferuiv
+	GLAD_API_CALL PFNGLUNIFORM3DVPROC glad_glUniform3dv;
+#define glUniform3dv glad_glUniform3dv
+	GLAD_API_CALL PFNGLBLENDEQUATIONIPROC glad_glBlendEquationi;
+#define glBlendEquationi glad_glBlendEquationi
+	GLAD_API_CALL PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui;
+#define glVertexAttribI4ui glad_glVertexAttribI4ui
+	GLAD_API_CALL PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv;
+#define glGetTexLevelParameteriv glad_glGetTexLevelParameteriv
+	GLAD_API_CALL PFNGLVERTEX4IPROC glad_glVertex4i;
+#define glVertex4i glad_glVertex4i
+	GLAD_API_CALL PFNGLUNIFORM4UIVPROC glad_glUniform4uiv;
+#define glUniform4uiv glad_glUniform4uiv
+	GLAD_API_CALL PFNGLTEXENVFVPROC glad_glTexEnvfv;
+#define glTexEnvfv glad_glTexEnvfv
+	GLAD_API_CALL PFNGLMULTITEXCOORD4DVPROC glad_glMultiTexCoord4dv;
+#define glMultiTexCoord4dv glad_glMultiTexCoord4dv
+	GLAD_API_CALL PFNGLCLEARTEXSUBIMAGEPROC glad_glClearTexSubImage;
+#define glClearTexSubImage glad_glClearTexSubImage
+	GLAD_API_CALL PFNGLTRANSLATEDPROC glad_glTranslated;
+#define glTranslated glad_glTranslated
+	GLAD_API_CALL PFNGLPOINTPARAMETERFPROC glad_glPointParameterf;
+#define glPointParameterf glad_glPointParameterf
+	GLAD_API_CALL PFNGLSCISSORINDEXEDVPROC glad_glScissorIndexedv;
+#define glScissorIndexedv glad_glScissorIndexedv
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM2DVPROC glad_glProgramUniform2dv;
+#define glProgramUniform2dv glad_glProgramUniform2dv
+	GLAD_API_CALL PFNGLREADBUFFERPROC glad_glReadBuffer;
+#define glReadBuffer glad_glReadBuffer
+	GLAD_API_CALL PFNGLENDPROC glad_glEnd;
+#define glEnd glad_glEnd
+	GLAD_API_CALL PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced;
+#define glDrawArraysInstanced glad_glDrawArraysInstanced
+	GLAD_API_CALL PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv;
+#define glVertexAttrib4uiv glad_glVertexAttrib4uiv
+	GLAD_API_CALL PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv;
+#define glVertexAttribI4ubv glad_glVertexAttribI4ubv
+	GLAD_API_CALL PFNGLCOMPRESSEDTEXTURESUBIMAGE1DPROC glad_glCompressedTextureSubImage1D;
+#define glCompressedTextureSubImage1D glad_glCompressedTextureSubImage1D
+	GLAD_API_CALL PFNGLVERTEX2DVPROC glad_glVertex2dv;
+#define glVertex2dv glad_glVertex2dv
+	GLAD_API_CALL PFNGLPUSHNAMEPROC glad_glPushName;
+#define glPushName glad_glPushName
+	GLAD_API_CALL PFNGLINVALIDATEBUFFERDATAPROC glad_glInvalidateBufferData;
+#define glInvalidateBufferData glad_glInvalidateBufferData
+	GLAD_API_CALL PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv;
+#define glPointParameteriv glad_glPointParameteriv
+	GLAD_API_CALL PFNGLGENTEXTURESPROC glad_glGenTextures;
+#define glGenTextures glad_glGenTextures
+	GLAD_API_CALL PFNGLTEXCOORD4FVPROC glad_glTexCoord4fv;
+#define glTexCoord4fv glad_glTexCoord4fv
+	GLAD_API_CALL PFNGLDISPATCHCOMPUTEPROC glad_glDispatchCompute;
+#define glDispatchCompute glad_glDispatchCompute
+	GLAD_API_CALL PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv;
+#define glGetUniformuiv glad_glGetUniformuiv
+	GLAD_API_CALL PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv;
+#define glGetActiveUniformsiv glad_glGetActiveUniformsiv
+	GLAD_API_CALL PFNGLGETPROGRAMRESOURCENAMEPROC glad_glGetProgramResourceName;
+#define glGetProgramResourceName glad_glGetProgramResourceName
+	GLAD_API_CALL PFNGLVERTEX2FVPROC glad_glVertex2fv;
+#define glVertex2fv glad_glVertex2fv
+	GLAD_API_CALL PFNGLCOLOR4UBPROC glad_glColor4ub;
+#define glColor4ub glad_glColor4ub
+	GLAD_API_CALL PFNGLUNIFORM3IVPROC glad_glUniform3iv;
+#define glUniform3iv glad_glUniform3iv
+	GLAD_API_CALL PFNGLCLIPPLANEPROC glad_glClipPlane;
+#define glClipPlane glad_glClipPlane
+	GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC glad_glProgramUniformMatrix3x2fv;
+#define glProgramUniformMatrix3x2fv glad_glProgramUniformMatrix3x2fv
+	GLAD_API_CALL PFNGLUNIFORM4IPROC glad_glUniform4i;
+#define glUniform4i glad_glUniform4i
+	GLAD_API_CALL PFNGLWINDOWPOS3IVPROC glad_glWindowPos3iv;
+#define glWindowPos3iv glad_glWindowPos3iv
+	GLAD_API_CALL PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv;
+#define glSamplerParameteriv glad_glSamplerParameteriv
+	GLAD_API_CALL PFNGLUNIFORM2DPROC glad_glUniform2d;
+#define glUniform2d glad_glUniform2d
+	GLAD_API_CALL PFNGLPOPMATRIXPROC glad_glPopMatrix;
+#define glPopMatrix glad_glPopMatrix
+	GLAD_API_CALL PFNGLVALIDATEPROGRAMPIPELINEPROC glad_glValidateProgramPipeline;
+#define glValidateProgramPipeline glad_glValidateProgramPipeline
+	GLAD_API_CALL PFNGLRASTERPOS3DVPROC glad_glRasterPos3dv;
+#define glRasterPos3dv glad_glRasterPos3dv
+	GLAD_API_CALL PFNGLTEXCOORD1FVPROC glad_glTexCoord1fv;
+#define glTexCoord1fv glad_glTexCoord1fv
+	GLAD_API_CALL PFNGLTEXCOORD2IVPROC glad_glTexCoord2iv;
+#define glTexCoord2iv glad_glTexCoord2iv
+	GLAD_API_CALL PFNGLCOPYTEXTURESUBIMAGE2DPROC glad_glCopyTextureSubImage2D;
+#define glCopyTextureSubImage2D glad_glCopyTextureSubImage2D
+	GLAD_API_CALL PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders;
+#define glGetAttachedShaders glad_glGetAttachedShaders
+	GLAD_API_CALL PFNGLGETTRANSFORMFEEDBACKI_VPROC glad_glGetTransformFeedbacki_v;
+#define glGetTransformFeedbacki_v glad_glGetTransformFeedbacki_v
+	GLAD_API_CALL PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv;
+#define glGetFramebufferAttachmentParameteriv glad_glGetFramebufferAttachmentParameteriv
+	GLAD_API_CALL PFNGLVERTEXARRAYATTRIBIFORMATPROC glad_glVertexArrayAttribIFormat;
+#define glVertexArrayAttribIFormat glad_glVertexArrayAttribIFormat
+	GLAD_API_CALL PFNGLOBJECTPTRLABELPROC glad_glObjectPtrLabel;
+#define glObjectPtrLabel glad_glObjectPtrLabel
+	GLAD_API_CALL PFNGLGETNPIXELMAPUSVPROC glad_glGetnPixelMapusv;
+#define glGetnPixelMapusv glad_glGetnPixelMapusv
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM1FPROC glad_glProgramUniform1f;
+#define glProgramUniform1f glad_glProgramUniform1f
+	GLAD_API_CALL PFNGLCLEARSTENCILPROC glad_glClearStencil;
+#define glClearStencil glad_glClearStencil
+	GLAD_API_CALL PFNGLDISABLEPROC glad_glDisable;
+#define glDisable glad_glDisable
+	GLAD_API_CALL PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f;
+#define glVertexAttrib4f glad_glVertexAttrib4f
+	GLAD_API_CALL PFNGLGETSUBROUTINEINDEXPROC glad_glGetSubroutineIndex;
+#define glGetSubroutineIndex glad_glGetSubroutineIndex
+	GLAD_API_CALL PFNGLMULTITEXCOORD2DPROC glad_glMultiTexCoord2d;
+#define glMultiTexCoord2d glad_glMultiTexCoord2d
+	GLAD_API_CALL PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv;
+#define glMultiTexCoordP3uiv glad_glMultiTexCoordP3uiv
+	GLAD_API_CALL PFNGLMULTITEXCOORD3FVPROC glad_glMultiTexCoord3fv;
+#define glMultiTexCoord3fv glad_glMultiTexCoord3fv
+	GLAD_API_CALL PFNGLUNIFORM4IVPROC glad_glUniform4iv;
+#define glUniform4iv glad_glUniform4iv
+	GLAD_API_CALL PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor;
+#define glVertexAttribDivisor glad_glVertexAttribDivisor
+	GLAD_API_CALL PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation;
+#define glBindFragDataLocation glad_glBindFragDataLocation
+	GLAD_API_CALL PFNGLGETNCOMPRESSEDTEXIMAGEPROC glad_glGetnCompressedTexImage;
+#define glGetnCompressedTexImage glad_glGetnCompressedTexImage
+	GLAD_API_CALL PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv;
+#define glUniformMatrix3fv glad_glUniformMatrix3fv
+	GLAD_API_CALL PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv;
+#define glVertexAttrib2fv glad_glVertexAttrib2fv
+	GLAD_API_CALL PFNGLEVALCOORD2DPROC glad_glEvalCoord2d;
+#define glEvalCoord2d glad_glEvalCoord2d
+	GLAD_API_CALL PFNGLGETPOINTERVPROC glad_glGetPointerv;
+#define glGetPointerv glad_glGetPointerv
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM4DPROC glad_glProgramUniform4d;
+#define glProgramUniform4d glad_glProgramUniform4d
+	GLAD_API_CALL PFNGLTEXCOORD2FPROC glad_glTexCoord2f;
+#define glTexCoord2f glad_glTexCoord2f
+	GLAD_API_CALL PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData;
+#define glCopyBufferSubData glad_glCopyBufferSubData
+	GLAD_API_CALL PFNGLUNIFORMMATRIX3DVPROC glad_glUniformMatrix3dv;
+#define glUniformMatrix3dv glad_glUniformMatrix3dv
+	GLAD_API_CALL PFNGLSECONDARYCOLOR3IVPROC glad_glSecondaryColor3iv;
+#define glSecondaryColor3iv glad_glSecondaryColor3iv
+	GLAD_API_CALL PFNGLFINISHPROC glad_glFinish;
+#define glFinish glad_glFinish
+	GLAD_API_CALL PFNGLISPROGRAMPIPELINEPROC glad_glIsProgramPipeline;
+#define glIsProgramPipeline glad_glIsProgramPipeline
+	GLAD_API_CALL PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv;
+#define glVertexAttribP1uiv glad_glVertexAttribP1uiv
+	GLAD_API_CALL PFNGLGETNMAPDVPROC glad_glGetnMapdv;
+#define glGetnMapdv glad_glGetnMapdv
+	GLAD_API_CALL PFNGLBINDTEXTURESPROC glad_glBindTextures;
+#define glBindTextures glad_glBindTextures
+	GLAD_API_CALL PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui;
+#define glMultiTexCoordP3ui glad_glMultiTexCoordP3ui
+	GLAD_API_CALL PFNGLCOLORMASKIPROC glad_glColorMaski;
+#define glColorMaski glad_glColorMaski
+	GLAD_API_CALL PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v;
+#define glGetQueryObjecti64v glad_glGetQueryObjecti64v
+	GLAD_API_CALL PFNGLMULTITEXCOORD3SPROC glad_glMultiTexCoord3s;
+#define glMultiTexCoord3s glad_glMultiTexCoord3s
+	GLAD_API_CALL PFNGLWINDOWPOS2DPROC glad_glWindowPos2d;
+#define glWindowPos2d glad_glWindowPos2d
+	GLAD_API_CALL PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC glad_glDrawArraysInstancedBaseInstance;
+#define glDrawArraysInstancedBaseInstance glad_glDrawArraysInstancedBaseInstance
+	GLAD_API_CALL PFNGLDRAWTRANSFORMFEEDBACKPROC glad_glDrawTransformFeedback;
+#define glDrawTransformFeedback glad_glDrawTransformFeedback
+	GLAD_API_CALL PFNGLWINDOWPOS2FPROC glad_glWindowPos2f;
+#define glWindowPos2f glad_glWindowPos2f
+	GLAD_API_CALL PFNGLVERTEXATTRIBLPOINTERPROC glad_glVertexAttribLPointer;
+#define glVertexAttribLPointer glad_glVertexAttribLPointer
+	GLAD_API_CALL PFNGLTEXCOORD4FPROC glad_glTexCoord4f;
+#define glTexCoord4f glad_glTexCoord4f
+	GLAD_API_CALL PFNGLLIGHTMODELIVPROC glad_glLightModeliv;
+#define glLightModeliv glad_glLightModeliv
+	GLAD_API_CALL PFNGLUNIFORM2UIPROC glad_glUniform2ui;
+#define glUniform2ui glad_glUniform2ui
+	GLAD_API_CALL PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays;
+#define glDeleteVertexArrays glad_glDeleteVertexArrays
+	GLAD_API_CALL PFNGLTEXBUFFERPROC glad_glTexBuffer;
+#define glTexBuffer glad_glTexBuffer
+	GLAD_API_CALL PFNGLUNIFORM2FPROC glad_glUniform2f;
+#define glUniform2f glad_glUniform2f
+	GLAD_API_CALL PFNGLTEXCOORD1DPROC glad_glTexCoord1d;
+#define glTexCoord1d glad_glTexCoord1d
+	GLAD_API_CALL PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D;
+#define glCompressedTexImage2D glad_glCompressedTexImage2D
+	GLAD_API_CALL PFNGLGETGRAPHICSRESETSTATUSPROC glad_glGetGraphicsResetStatus;
+#define glGetGraphicsResetStatus glad_glGetGraphicsResetStatus
+	GLAD_API_CALL PFNGLTEXCOORD1SPROC glad_glTexCoord1s;
+#define glTexCoord1s glad_glTexCoord1s
+	GLAD_API_CALL PFNGLINDEXSVPROC glad_glIndexsv;
+#define glIndexsv glad_glIndexsv
+	GLAD_API_CALL PFNGLRASTERPOS4IVPROC glad_glRasterPos4iv;
+#define glRasterPos4iv glad_glRasterPos4iv
+	GLAD_API_CALL PFNGLSECONDARYCOLOR3IPROC glad_glSecondaryColor3i;
+#define glSecondaryColor3i glad_glSecondaryColor3i
+	GLAD_API_CALL PFNGLCALLLISTPROC glad_glCallList;
+#define glCallList glad_glCallList
+	GLAD_API_CALL PFNGLINDEXUBVPROC glad_glIndexubv;
+#define glIndexubv glad_glIndexubv
+	GLAD_API_CALL PFNGLPOLYGONMODEPROC glad_glPolygonMode;
+#define glPolygonMode glad_glPolygonMode
+	GLAD_API_CALL PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture;
+#define glFramebufferTexture glad_glFramebufferTexture
+	GLAD_API_CALL PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv;
+#define glUniformMatrix3x4fv glad_glUniformMatrix3x4fv
+	GLAD_API_CALL PFNGLISTRANSFORMFEEDBACKPROC glad_glIsTransformFeedback;
+#define glIsTransformFeedback glad_glIsTransformFeedback
+	GLAD_API_CALL PFNGLNAMEDBUFFERSUBDATAPROC glad_glNamedBufferSubData;
+#define glNamedBufferSubData glad_glNamedBufferSubData
+	GLAD_API_CALL PFNGLGETPROGRAMINTERFACEIVPROC glad_glGetProgramInterfaceiv;
+#define glGetProgramInterfaceiv glad_glGetProgramInterfaceiv
+	GLAD_API_CALL PFNGLDISABLECLIENTSTATEPROC glad_glDisableClientState;
+#define glDisableClientState glad_glDisableClientState
+	GLAD_API_CALL PFNGLCLEARNAMEDFRAMEBUFFERUIVPROC glad_glClearNamedFramebufferuiv;
+#define glClearNamedFramebufferuiv glad_glClearNamedFramebufferuiv
+	GLAD_API_CALL PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv;
+#define glGetTexParameterfv glad_glGetTexParameterfv
+	GLAD_API_CALL PFNGLVERTEXARRAYATTRIBLFORMATPROC glad_glVertexArrayAttribLFormat;
+#define glVertexArrayAttribLFormat glad_glVertexArrayAttribLFormat
+	GLAD_API_CALL PFNGLVERTEX4DPROC glad_glVertex4d;
+#define glVertex4d glad_glVertex4d
+	GLAD_API_CALL PFNGLNORMAL3SVPROC glad_glNormal3sv;
+#define glNormal3sv glad_glNormal3sv
+	GLAD_API_CALL PFNGLRASTERPOS4FPROC glad_glRasterPos4f;
+#define glRasterPos4f glad_glRasterPos4f
+	GLAD_API_CALL PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui;
+#define glTexCoordP4ui glad_glTexCoordP4ui
+	GLAD_API_CALL PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers;
+#define glGenRenderbuffers glad_glGenRenderbuffers
+	GLAD_API_CALL PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings;
+#define glTransformFeedbackVaryings glad_glTransformFeedbackVaryings
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM4FVPROC glad_glProgramUniform4fv;
+#define glProgramUniform4fv glad_glProgramUniform4fv
+	GLAD_API_CALL PFNGLNAMEDFRAMEBUFFERREADBUFFERPROC glad_glNamedFramebufferReadBuffer;
+#define glNamedFramebufferReadBuffer glad_glNamedFramebufferReadBuffer
+	GLAD_API_CALL PFNGLUNIFORMMATRIX2X3DVPROC glad_glUniformMatrix2x3dv;
+#define glUniformMatrix2x3dv glad_glUniformMatrix2x3dv
+	GLAD_API_CALL PFNGLVERTEXATTRIBL3DVPROC glad_glVertexAttribL3dv;
+#define glVertexAttribL3dv glad_glVertexAttribL3dv
+	GLAD_API_CALL PFNGLUNIFORM1UIVPROC glad_glUniform1uiv;
+#define glUniform1uiv glad_glUniform1uiv
+	GLAD_API_CALL PFNGLTEXCOORD1SVPROC glad_glTexCoord1sv;
+#define glTexCoord1sv glad_glTexCoord1sv
+	GLAD_API_CALL PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v;
+#define glGetIntegeri_v glad_glGetIntegeri_v
+	GLAD_API_CALL PFNGLTEXTURESUBIMAGE2DPROC glad_glTextureSubImage2D;
+#define glTextureSubImage2D glad_glTextureSubImage2D
+	GLAD_API_CALL PFNGLNAMEDRENDERBUFFERSTORAGEPROC glad_glNamedRenderbufferStorage;
+#define glNamedRenderbufferStorage glad_glNamedRenderbufferStorage
+	GLAD_API_CALL PFNGLGETMAPIVPROC glad_glGetMapiv;
+#define glGetMapiv glad_glGetMapiv
+	GLAD_API_CALL PFNGLMATRIXMODEPROC glad_glMatrixMode;
+#define glMatrixMode glad_glMatrixMode
+	GLAD_API_CALL PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv;
+#define glVertexAttribI4uiv glad_glVertexAttribI4uiv
+	GLAD_API_CALL PFNGLVERTEXATTRIBL1DVPROC glad_glVertexAttribL1dv;
+#define glVertexAttribL1dv glad_glVertexAttribL1dv
+	GLAD_API_CALL PFNGLGETNAMEDBUFFERSUBDATAPROC glad_glGetNamedBufferSubData;
+#define glGetNamedBufferSubData glad_glGetNamedBufferSubData
+	GLAD_API_CALL PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays;
+#define glGenVertexArrays glad_glGenVertexArrays
+	GLAD_API_CALL PFNGLGETTEXTUREPARAMETERIVPROC glad_glGetTextureParameteriv;
+#define glGetTextureParameteriv glad_glGetTextureParameteriv
+	GLAD_API_CALL PFNGLVERTEX3FVPROC glad_glVertex3fv;
+#define glVertex3fv glad_glVertex3fv
+	GLAD_API_CALL PFNGLMATERIALIVPROC glad_glMaterialiv;
+#define glMaterialiv glad_glMaterialiv
+	GLAD_API_CALL PFNGLPIXELTRANSFERIPROC glad_glPixelTransferi;
+#define glPixelTransferi glad_glPixelTransferi
+	GLAD_API_CALL PFNGLGETNHISTOGRAMPROC glad_glGetnHistogram;
+#define glGetnHistogram glad_glGetnHistogram
+	GLAD_API_CALL PFNGLCREATESHADERPROGRAMVPROC glad_glCreateShaderProgramv;
+#define glCreateShaderProgramv glad_glCreateShaderProgramv
+	GLAD_API_CALL PFNGLENABLEVERTEXARRAYATTRIBPROC glad_glEnableVertexArrayAttrib;
+#define glEnableVertexArrayAttrib glad_glEnableVertexArrayAttrib
+	GLAD_API_CALL PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender;
+#define glEndConditionalRender glad_glEndConditionalRender
+	GLAD_API_CALL PFNGLDELETELISTSPROC glad_glDeleteLists;
+#define glDeleteLists glad_glDeleteLists
+	GLAD_API_CALL PFNGLTEXCOORD2SVPROC glad_glTexCoord2sv;
+#define glTexCoord2sv glad_glTexCoord2sv
+	GLAD_API_CALL PFNGLDEBUGMESSAGECALLBACKPROC glad_glDebugMessageCallback;
+#define glDebugMessageCallback glad_glDebugMessageCallback
+	GLAD_API_CALL PFNGLMULTITEXCOORD1FPROC glad_glMultiTexCoord1f;
+#define glMultiTexCoord1f glad_glMultiTexCoord1f
+	GLAD_API_CALL PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage;
+#define glGetCompressedTexImage glad_glGetCompressedTexImage
+	GLAD_API_CALL PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus;
+#define glCheckFramebufferStatus glad_glCheckFramebufferStatus
+	GLAD_API_CALL PFNGLGETINTERNALFORMATI64VPROC glad_glGetInternalformati64v;
+#define glGetInternalformati64v glad_glGetInternalformati64v
+	GLAD_API_CALL PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap;
+#define glGenerateMipmap glad_glGenerateMipmap
+	GLAD_API_CALL PFNGLDELETEQUERIESPROC glad_glDeleteQueries;
+#define glDeleteQueries glad_glDeleteQueries
+	GLAD_API_CALL PFNGLNAMEDFRAMEBUFFERPARAMETERIPROC glad_glNamedFramebufferParameteri;
+#define glNamedFramebufferParameteri glad_glNamedFramebufferParameteri
+	GLAD_API_CALL PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex;
+#define glDrawElementsBaseVertex glad_glDrawElementsBaseVertex
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM1DPROC glad_glProgramUniform1d;
+#define glProgramUniform1d glad_glProgramUniform1d
+	GLAD_API_CALL PFNGLALPHAFUNCPROC glad_glAlphaFunc;
+#define glAlphaFunc glad_glAlphaFunc
+	GLAD_API_CALL PFNGLTRANSFORMFEEDBACKBUFFERRANGEPROC glad_glTransformFeedbackBufferRange;
+#define glTransformFeedbackBufferRange glad_glTransformFeedbackBufferRange
+	GLAD_API_CALL PFNGLLINESTIPPLEPROC glad_glLineStipple;
+#define glLineStipple glad_glLineStipple
+	GLAD_API_CALL PFNGLTEXGENIPROC glad_glTexGeni;
+#define glTexGeni glad_glTexGeni
+	GLAD_API_CALL PFNGLTEXSTORAGE3DMULTISAMPLEPROC glad_glTexStorage3DMultisample;
+#define glTexStorage3DMultisample glad_glTexStorage3DMultisample
+	GLAD_API_CALL PFNGLISVERTEXARRAYPROC glad_glIsVertexArray;
+#define glIsVertexArray glad_glIsVertexArray
+	GLAD_API_CALL PFNGLGETNAMEDRENDERBUFFERPARAMETERIVPROC glad_glGetNamedRenderbufferParameteriv;
+#define glGetNamedRenderbufferParameteriv glad_glGetNamedRenderbufferParameteriv
+	GLAD_API_CALL PFNGLINVALIDATEFRAMEBUFFERPROC glad_glInvalidateFramebuffer;
+#define glInvalidateFramebuffer glad_glInvalidateFramebuffer
+	GLAD_API_CALL PFNGLPROGRAMBINARYPROC glad_glProgramBinary;
+#define glProgramBinary glad_glProgramBinary
+	GLAD_API_CALL PFNGLTEXCOORD4DVPROC glad_glTexCoord4dv;
+#define glTexCoord4dv glad_glTexCoord4dv
+	GLAD_API_CALL PFNGLVERTEX3IPROC glad_glVertex3i;
+#define glVertex3i glad_glVertex3i
+	GLAD_API_CALL PFNGLSECONDARYCOLOR3BPROC glad_glSecondaryColor3b;
+#define glSecondaryColor3b glad_glSecondaryColor3b
+	GLAD_API_CALL PFNGLRASTERPOS4SVPROC glad_glRasterPos4sv;
+#define glRasterPos4sv glad_glRasterPos4sv
+	GLAD_API_CALL PFNGLDISABLEIPROC glad_glDisablei;
+#define glDisablei glad_glDisablei
+	GLAD_API_CALL PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv;
+#define glVertexAttrib1sv glad_glVertexAttrib1sv
+	GLAD_API_CALL PFNGLINVALIDATETEXIMAGEPROC glad_glInvalidateTexImage;
+#define glInvalidateTexImage glad_glInvalidateTexImage
+	GLAD_API_CALL PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i;
+#define glVertexAttribI2i glad_glVertexAttribI2i
+	GLAD_API_CALL PFNGLINDEXFPROC glad_glIndexf;
+#define glIndexf glad_glIndexf
+	GLAD_API_CALL PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex;
+#define glPrimitiveRestartIndex glad_glPrimitiveRestartIndex
+	GLAD_API_CALL PFNGLGETNCONVOLUTIONFILTERPROC glad_glGetnConvolutionFilter;
+#define glGetnConvolutionFilter glad_glGetnConvolutionFilter
+	GLAD_API_CALL PFNGLGETERRORPROC glad_glGetError;
+#define glGetError glad_glGetError
+	GLAD_API_CALL PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv;
+#define glVertexAttrib4bv glad_glVertexAttrib4bv
+	GLAD_API_CALL PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange;
+#define glFlushMappedBufferRange glad_glFlushMappedBufferRange
+	GLAD_API_CALL PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui;
+#define glTexCoordP1ui glad_glTexCoordP1ui
+	GLAD_API_CALL PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage;
+#define glSampleCoverage glad_glSampleCoverage
+	GLAD_API_CALL PFNGLMULTITEXCOORD2IVPROC glad_glMultiTexCoord2iv;
+#define glMultiTexCoord2iv glad_glMultiTexCoord2iv
+	GLAD_API_CALL PFNGLISPROGRAMPROC glad_glIsProgram;
+#define glIsProgram glad_glIsProgram
+	GLAD_API_CALL PFNGLISLISTPROC glad_glIsList;
+#define glIsList glad_glIsList
+	GLAD_API_CALL PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv;
+#define glVertexAttrib2dv glad_glVertexAttrib2dv
+	GLAD_API_CALL PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f;
+#define glVertexAttrib3f glad_glVertexAttrib3f
+	GLAD_API_CALL PFNGLTEXPARAMETERIPROC glad_glTexParameteri;
+#define glTexParameteri glad_glTexParameteri
+	GLAD_API_CALL PFNGLPUSHATTRIBPROC glad_glPushAttrib;
+#define glPushAttrib glad_glPushAttrib
+	GLAD_API_CALL PFNGLFRONTFACEPROC glad_glFrontFace;
+#define glFrontFace glad_glFrontFace
+	GLAD_API_CALL PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC glad_glDrawElementsInstancedBaseInstance;
+#define glDrawElementsInstancedBaseInstance glad_glDrawElementsInstancedBaseInstance
+	GLAD_API_CALL PFNGLMULTITEXCOORD1SPROC glad_glMultiTexCoord1s;
+#define glMultiTexCoord1s glad_glMultiTexCoord1s
+	GLAD_API_CALL PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i;
+#define glVertexAttribI3i glad_glVertexAttribI3i
+	GLAD_API_CALL PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D;
+#define glCopyTexSubImage1D glad_glCopyTexSubImage1D
+	GLAD_API_CALL PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D;
+#define glFramebufferTexture3D glad_glFramebufferTexture3D
+	GLAD_API_CALL PFNGLGENSAMPLERSPROC glad_glGenSamplers;
+#define glGenSamplers glad_glGenSamplers
+	GLAD_API_CALL PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf;
+#define glSamplerParameterf glad_glSamplerParameterf
+	GLAD_API_CALL PFNGLRASTERPOS4FVPROC glad_glRasterPos4fv;
+#define glRasterPos4fv glad_glRasterPos4fv
+	GLAD_API_CALL PFNGLPAUSETRANSFORMFEEDBACKPROC glad_glPauseTransformFeedback;
+#define glPauseTransformFeedback glad_glPauseTransformFeedback
+	GLAD_API_CALL PFNGLPOPNAMEPROC glad_glPopName;
+#define glPopName glad_glPopName
+	GLAD_API_CALL PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv;
+#define glVertexAttribI1iv glad_glVertexAttribI1iv
+	GLAD_API_CALL PFNGLEVALCOORD1FPROC glad_glEvalCoord1f;
+#define glEvalCoord1f glad_glEvalCoord1f
+	GLAD_API_CALL PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers;
+#define glGenFramebuffers glad_glGenFramebuffers
+	GLAD_API_CALL PFNGLLIGHTIPROC glad_glLighti;
+#define glLighti glad_glLighti
+	GLAD_API_CALL PFNGLTEXTUREVIEWPROC glad_glTextureView;
+#define glTextureView glad_glTextureView
+	GLAD_API_CALL PFNGLLOADTRANSPOSEMATRIXDPROC glad_glLoadTransposeMatrixd;
+#define glLoadTransposeMatrixd glad_glLoadTransposeMatrixd
+	GLAD_API_CALL PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetNamedFramebufferAttachmentParameteriv;
+#define glGetNamedFramebufferAttachmentParameteriv glad_glGetNamedFramebufferAttachmentParameteriv
+	GLAD_API_CALL PFNGLUNIFORM4DPROC glad_glUniform4d;
+#define glUniform4d glad_glUniform4d
+	GLAD_API_CALL PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui;
+#define glVertexAttribI3ui glad_glVertexAttribI3ui
+	GLAD_API_CALL PFNGLEDGEFLAGPOINTERPROC glad_glEdgeFlagPointer;
+#define glEdgeFlagPointer glad_glEdgeFlagPointer
+	GLAD_API_CALL PFNGLSTENCILFUNCPROC glad_glStencilFunc;
+#define glStencilFunc glad_glStencilFunc
+	GLAD_API_CALL PFNGLUNIFORM1IPROC glad_glUniform1i;
+#define glUniform1i glad_glUniform1i
+	GLAD_API_CALL PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv;
+#define glGetTexParameterIuiv glad_glGetTexParameterIuiv
+	GLAD_API_CALL PFNGLINVALIDATENAMEDFRAMEBUFFERDATAPROC glad_glInvalidateNamedFramebufferData;
+#define glInvalidateNamedFramebufferData glad_glInvalidateNamedFramebufferData
+	GLAD_API_CALL PFNGLPATCHPARAMETERFVPROC glad_glPatchParameterfv;
+#define glPatchParameterfv glad_glPatchParameterfv
+	GLAD_API_CALL PFNGLFOGFVPROC glad_glFogfv;
+#define glFogfv glad_glFogfv
+	GLAD_API_CALL PFNGLVERTEXP3UIPROC glad_glVertexP3ui;
+#define glVertexP3ui glad_glVertexP3ui
+	GLAD_API_CALL PFNGLREADNPIXELSPROC glad_glReadnPixels;
+#define glReadnPixels glad_glReadnPixels
+	GLAD_API_CALL PFNGLMULTITEXCOORD1IPROC glad_glMultiTexCoord1i;
+#define glMultiTexCoord1i glad_glMultiTexCoord1i
+	GLAD_API_CALL PFNGLVERTEXATTRIBBINDINGPROC glad_glVertexAttribBinding;
+#define glVertexAttribBinding glad_glVertexAttribBinding
+	GLAD_API_CALL PFNGLMULTITEXCOORD3DVPROC glad_glMultiTexCoord3dv;
+#define glMultiTexCoord3dv glad_glMultiTexCoord3dv
+	GLAD_API_CALL PFNGLVERTEX4SPROC glad_glVertex4s;
+#define glVertex4s glad_glVertex4s
+	GLAD_API_CALL PFNGLVERTEXBINDINGDIVISORPROC glad_glVertexBindingDivisor;
+#define glVertexBindingDivisor glad_glVertexBindingDivisor
+	GLAD_API_CALL PFNGLTEXTUREPARAMETERFVPROC glad_glTextureParameterfv;
+#define glTextureParameterfv glad_glTextureParameterfv
+	GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC glad_glProgramUniformMatrix3x4fv;
+#define glProgramUniformMatrix3x4fv glad_glProgramUniformMatrix3x4fv
+	GLAD_API_CALL PFNGLNORMAL3BPROC glad_glNormal3b;
+#define glNormal3b glad_glNormal3b
+	GLAD_API_CALL PFNGLGETUNIFORMSUBROUTINEUIVPROC glad_glGetUniformSubroutineuiv;
+#define glGetUniformSubroutineuiv glad_glGetUniformSubroutineuiv
+	GLAD_API_CALL PFNGLVERTEX3SVPROC glad_glVertex3sv;
+#define glVertex3sv glad_glVertex3sv
+	GLAD_API_CALL PFNGLMULTITEXCOORD3SVPROC glad_glMultiTexCoord3sv;
+#define glMultiTexCoord3sv glad_glMultiTexCoord3sv
+	GLAD_API_CALL PFNGLGETNAMEDBUFFERPARAMETERI64VPROC glad_glGetNamedBufferParameteri64v;
+#define glGetNamedBufferParameteri64v glad_glGetNamedBufferParameteri64v
+	GLAD_API_CALL PFNGLDRAWPIXELSPROC glad_glDrawPixels;
+#define glDrawPixels glad_glDrawPixels
+	GLAD_API_CALL PFNGLCALLLISTSPROC glad_glCallLists;
+#define glCallLists glad_glCallLists
+	GLAD_API_CALL PFNGLTEXCOORD3IPROC glad_glTexCoord3i;
+#define glTexCoord3i glad_glTexCoord3i
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM2UIPROC glad_glProgramUniform2ui;
+#define glProgramUniform2ui glad_glProgramUniform2ui
+	GLAD_API_CALL PFNGLQUERYCOUNTERPROC glad_glQueryCounter;
+#define glQueryCounter glad_glQueryCounter
+	GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC glad_glProgramUniformMatrix2x3dv;
+#define glProgramUniformMatrix2x3dv glad_glProgramUniformMatrix2x3dv
+	GLAD_API_CALL PFNGLUNIFORM1IVPROC glad_glUniform1iv;
+#define glUniform1iv glad_glUniform1iv
+	GLAD_API_CALL PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate;
+#define glStencilFuncSeparate glad_glStencilFuncSeparate
+	GLAD_API_CALL PFNGLGETNAMEDBUFFERPARAMETERIVPROC glad_glGetNamedBufferParameteriv;
+#define glGetNamedBufferParameteriv glad_glGetNamedBufferParameteriv
+	GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX2DVPROC glad_glProgramUniformMatrix2dv;
+#define glProgramUniformMatrix2dv glad_glProgramUniformMatrix2dv
+	GLAD_API_CALL PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib;
+#define glGetActiveAttrib glad_glGetActiveAttrib
+	GLAD_API_CALL PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray;
+#define glEnableVertexAttribArray glad_glEnableVertexAttribArray
+	GLAD_API_CALL PFNGLMATERIALIPROC glad_glMateriali;
+#define glMateriali glad_glMateriali
+	GLAD_API_CALL PFNGLUNIFORM2FVPROC glad_glUniform2fv;
+#define glUniform2fv glad_glUniform2fv
+	GLAD_API_CALL PFNGLRASTERPOS3FVPROC glad_glRasterPos3fv;
+#define glRasterPos3fv glad_glRasterPos3fv
+	GLAD_API_CALL PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC glad_glGetProgramResourceLocationIndex;
+#define glGetProgramResourceLocationIndex glad_glGetProgramResourceLocationIndex
+	GLAD_API_CALL PFNGLGETDOUBLEVPROC glad_glGetDoublev;
+#define glGetDoublev glad_glGetDoublev
+	GLAD_API_CALL PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex;
+#define glDrawElementsInstancedBaseVertex glad_glDrawElementsInstancedBaseVertex
+	GLAD_API_CALL PFNGLUNIFORMMATRIX2X4DVPROC glad_glUniformMatrix2x4dv;
+#define glUniformMatrix2x4dv glad_glUniformMatrix2x4dv
+	GLAD_API_CALL PFNGLCOLOR4BVPROC glad_glColor4bv;
+#define glColor4bv glad_glColor4bv
+	GLAD_API_CALL PFNGLGETINTERNALFORMATIVPROC glad_glGetInternalformativ;
+#define glGetInternalformativ glad_glGetInternalformativ
+	GLAD_API_CALL PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC glad_glGetActiveSubroutineUniformiv;
+#define glGetActiveSubroutineUniformiv glad_glGetActiveSubroutineUniformiv
+	GLAD_API_CALL PFNGLGETQUERYINDEXEDIVPROC glad_glGetQueryIndexediv;
+#define glGetQueryIndexediv glad_glGetQueryIndexediv
+	GLAD_API_CALL PFNGLBINDVERTEXBUFFERPROC glad_glBindVertexBuffer;
+#define glBindVertexBuffer glad_glBindVertexBuffer
+	GLAD_API_CALL PFNGLTEXCOORD3FPROC glad_glTexCoord3f;
+#define glTexCoord3f glad_glTexCoord3f
+	GLAD_API_CALL PFNGLCOLOR3UIVPROC glad_glColor3uiv;
+#define glColor3uiv glad_glColor3uiv
+	GLAD_API_CALL PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv;
+#define glVertexAttrib4Nbv glad_glVertexAttrib4Nbv
+	GLAD_API_CALL PFNGLCLEARPROC glad_glClear;
+#define glClear glad_glClear
+	GLAD_API_CALL PFNGLRASTERPOS2DVPROC glad_glRasterPos2dv;
+#define glRasterPos2dv glad_glRasterPos2dv
+	GLAD_API_CALL PFNGLTEXCOORD2SPROC glad_glTexCoord2s;
+#define glTexCoord2s glad_glTexCoord2s
+	GLAD_API_CALL PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui;
+#define glVertexAttribP4ui glad_glVertexAttribP4ui
+	GLAD_API_CALL PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer;
+#define glFramebufferTextureLayer glad_glFramebufferTextureLayer
+	GLAD_API_CALL PFNGLTEXENVIPROC glad_glTexEnvi;
+#define glTexEnvi glad_glTexEnvi
+	GLAD_API_CALL PFNGLTEXTUREPARAMETERFPROC glad_glTextureParameterf;
+#define glTextureParameterf glad_glTextureParameterf
+	GLAD_API_CALL PFNGLMATERIALFPROC glad_glMaterialf;
+#define glMaterialf glad_glMaterialf
+	GLAD_API_CALL PFNGLGETUNIFORMDVPROC glad_glGetUniformdv;
+#define glGetUniformdv glad_glGetUniformdv
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM3IVPROC glad_glProgramUniform3iv;
+#define glProgramUniform3iv glad_glProgramUniform3iv
+	GLAD_API_CALL PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv;
+#define glTexParameterIuiv glad_glTexParameterIuiv
+	GLAD_API_CALL PFNGLCLEARINDEXPROC glad_glClearIndex;
+#define glClearIndex glad_glClearIndex
+	GLAD_API_CALL PFNGLDISPATCHCOMPUTEINDIRECTPROC glad_glDispatchComputeIndirect;
+#define glDispatchComputeIndirect glad_glDispatchComputeIndirect
+	GLAD_API_CALL PFNGLROTATEFPROC glad_glRotatef;
+#define glRotatef glad_glRotatef
+	GLAD_API_CALL PFNGLTEXTURESUBIMAGE1DPROC glad_glTextureSubImage1D;
+#define glTextureSubImage1D glad_glTextureSubImage1D
+	GLAD_API_CALL PFNGLPOLYGONOFFSETCLAMPPROC glad_glPolygonOffsetClamp;
+#define glPolygonOffsetClamp glad_glPolygonOffsetClamp
+	GLAD_API_CALL PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv;
+#define glSamplerParameterIuiv glad_glSamplerParameterIuiv
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM4IVPROC glad_glProgramUniform4iv;
+#define glProgramUniform4iv glad_glProgramUniform4iv
+	GLAD_API_CALL PFNGLSECONDARYCOLOR3SPROC glad_glSecondaryColor3s;
+#define glSecondaryColor3s glad_glSecondaryColor3s
+	GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC glad_glProgramUniformMatrix2x4dv;
+#define glProgramUniformMatrix2x4dv glad_glProgramUniformMatrix2x4dv
+	GLAD_API_CALL PFNGLGETVERTEXATTRIBLDVPROC glad_glGetVertexAttribLdv;
+#define glGetVertexAttribLdv glad_glGetVertexAttribLdv
+	GLAD_API_CALL PFNGLRASTERPOS2FVPROC glad_glRasterPos2fv;
+#define glRasterPos2fv glad_glRasterPos2fv
+	GLAD_API_CALL PFNGLSHADEMODELPROC glad_glShadeModel;
+#define glShadeModel glad_glShadeModel
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM4DVPROC glad_glProgramUniform4dv;
+#define glProgramUniform4dv glad_glProgramUniform4dv
+	GLAD_API_CALL PFNGLNORMAL3FVPROC glad_glNormal3fv;
+#define glNormal3fv glad_glNormal3fv
+	GLAD_API_CALL PFNGLISBUFFERPROC glad_glIsBuffer;
+#define glIsBuffer glad_glIsBuffer
+	GLAD_API_CALL PFNGLMULTITEXCOORD3FPROC glad_glMultiTexCoord3f;
+#define glMultiTexCoord3f glad_glMultiTexCoord3f
+	GLAD_API_CALL PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer;
+#define glBindFramebuffer glad_glBindFramebuffer
+	GLAD_API_CALL PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed;
+#define glBindFragDataLocationIndexed glad_glBindFragDataLocationIndexed
+	GLAD_API_CALL PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase;
+#define glBindBufferBase glad_glBindBufferBase
+	GLAD_API_CALL PFNGLGENBUFFERSPROC glad_glGenBuffers;
+#define glGenBuffers glad_glGenBuffers
+	GLAD_API_CALL PFNGLTEXCOORD1FPROC glad_glTexCoord1f;
+#define glTexCoord1f glad_glTexCoord1f
+	GLAD_API_CALL PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData;
+#define glGetBufferSubData glad_glGetBufferSubData
+	GLAD_API_CALL PFNGLCREATETRANSFORMFEEDBACKSPROC glad_glCreateTransformFeedbacks;
+#define glCreateTransformFeedbacks glad_glCreateTransformFeedbacks
+	GLAD_API_CALL PFNGLMAP2FPROC glad_glMap2f;
+#define glMap2f glad_glMap2f
+	GLAD_API_CALL PFNGLCREATEBUFFERSPROC glad_glCreateBuffers;
+#define glCreateBuffers glad_glCreateBuffers
+	GLAD_API_CALL PFNGLCOLOR3USVPROC glad_glColor3usv;
+#define glColor3usv glad_glColor3usv
+	GLAD_API_CALL PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv;
+#define glGetSamplerParameterfv glad_glGetSamplerParameterfv
+	GLAD_API_CALL PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation;
+#define glGetUniformLocation glad_glGetUniformLocation
+	GLAD_API_CALL PFNGLVERTEX2DPROC glad_glVertex2d;
+#define glVertex2d glad_glVertex2d
+	GLAD_API_CALL PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC glad_glGetSubroutineUniformLocation;
+#define glGetSubroutineUniformLocation glad_glGetSubroutineUniformLocation
+	GLAD_API_CALL PFNGLINVALIDATEBUFFERSUBDATAPROC glad_glInvalidateBufferSubData;
+#define glInvalidateBufferSubData glad_glInvalidateBufferSubData
+	GLAD_API_CALL PFNGLUNIFORMMATRIX2DVPROC glad_glUniformMatrix2dv;
+#define glUniformMatrix2dv glad_glUniformMatrix2dv
+	GLAD_API_CALL PFNGLCLEARNAMEDBUFFERSUBDATAPROC glad_glClearNamedBufferSubData;
+#define glClearNamedBufferSubData glad_glClearNamedBufferSubData
+	GLAD_API_CALL PFNGLGETPROGRAMIVPROC glad_glGetProgramiv;
+#define glGetProgramiv glad_glGetProgramiv
+	GLAD_API_CALL PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements;
+#define glDrawRangeElements glad_glDrawRangeElements
+	GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX4FVPROC glad_glProgramUniformMatrix4fv;
+#define glProgramUniformMatrix4fv glad_glProgramUniformMatrix4fv
+	GLAD_API_CALL PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v;
+#define glGetInteger64i_v glad_glGetInteger64i_v
+	GLAD_API_CALL PFNGLVERTEXATTRIBL1DPROC glad_glVertexAttribL1d;
+#define glVertexAttribL1d glad_glVertexAttribL1d
+	GLAD_API_CALL PFNGLGETTEXTUREIMAGEPROC glad_glGetTextureImage;
+#define glGetTextureImage glad_glGetTextureImage
+	GLAD_API_CALL PFNGLGETNUNIFORMIVPROC glad_glGetnUniformiv;
+#define glGetnUniformiv glad_glGetnUniformiv
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM1IPROC glad_glProgramUniform1i;
+#define glProgramUniform1i glad_glProgramUniform1i
+	GLAD_API_CALL PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC glad_glDrawTransformFeedbackInstanced;
+#define glDrawTransformFeedbackInstanced glad_glDrawTransformFeedbackInstanced
+	GLAD_API_CALL PFNGLGETPROGRAMRESOURCEINDEXPROC glad_glGetProgramResourceIndex;
+#define glGetProgramResourceIndex glad_glGetProgramResourceIndex
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM2DPROC glad_glProgramUniform2d;
+#define glProgramUniform2d glad_glProgramUniform2d
+	GLAD_API_CALL PFNGLUNMAPNAMEDBUFFERPROC glad_glUnmapNamedBuffer;
+#define glUnmapNamedBuffer glad_glUnmapNamedBuffer
+	GLAD_API_CALL PFNGLMULTITEXCOORD2FPROC glad_glMultiTexCoord2f;
+#define glMultiTexCoord2f glad_glMultiTexCoord2f
+	GLAD_API_CALL PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv;
+#define glPointParameterfv glad_glPointParameterfv
+	GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX3FVPROC glad_glProgramUniformMatrix3fv;
+#define glProgramUniformMatrix3fv glad_glProgramUniformMatrix3fv
+	GLAD_API_CALL PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange;
+#define glBindBufferRange glad_glBindBufferRange
+	GLAD_API_CALL PFNGLMULTITEXCOORD2DVPROC glad_glMultiTexCoord2dv;
+#define glMultiTexCoord2dv glad_glMultiTexCoord2dv
+	GLAD_API_CALL PFNGLCOLORMATERIALPROC glad_glColorMaterial;
+#define glColorMaterial glad_glColorMaterial
+	GLAD_API_CALL PFNGLBLENDEQUATIONPROC glad_glBlendEquation;
+#define glBlendEquation glad_glBlendEquation
+	GLAD_API_CALL PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer;
+#define glBlitFramebuffer glad_glBlitFramebuffer
+	GLAD_API_CALL PFNGLCOLOR3DPROC glad_glColor3d;
+#define glColor3d glad_glColor3d
+	GLAD_API_CALL PFNGLMULTITEXCOORD3IVPROC glad_glMultiTexCoord3iv;
+#define glMultiTexCoord3iv glad_glMultiTexCoord3iv
+	GLAD_API_CALL PFNGLLIGHTFVPROC glad_glLightfv;
+#define glLightfv glad_glLightfv
+	GLAD_API_CALL PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv;
+#define glVertexAttrib1dv glad_glVertexAttrib1dv
+	GLAD_API_CALL PFNGLDEPTHMASKPROC glad_glDepthMask;
+#define glDepthMask glad_glDepthMask
+	GLAD_API_CALL PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying;
+#define glGetTransformFeedbackVarying glad_glGetTransformFeedbackVarying
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM1UIPROC glad_glProgramUniform1ui;
+#define glProgramUniform1ui glad_glProgramUniform1ui
+	GLAD_API_CALL PFNGLVERTEXATTRIBL3DPROC glad_glVertexAttribL3d;
+#define glVertexAttribL3d glad_glVertexAttribL3d
+	GLAD_API_CALL PFNGLDRAWELEMENTSINDIRECTPROC glad_glDrawElementsIndirect;
+#define glDrawElementsIndirect glad_glDrawElementsIndirect
+	GLAD_API_CALL PFNGLLOADTRANSPOSEMATRIXFPROC glad_glLoadTransposeMatrixf;
+#define glLoadTransposeMatrixf glad_glLoadTransposeMatrixf
+	GLAD_API_CALL PFNGLENDQUERYINDEXEDPROC glad_glEndQueryIndexed;
+#define glEndQueryIndexed glad_glEndQueryIndexed
+	GLAD_API_CALL PFNGLSECONDARYCOLOR3USPROC glad_glSecondaryColor3us;
+#define glSecondaryColor3us glad_glSecondaryColor3us
+	GLAD_API_CALL PFNGLTEXTURESTORAGE2DMULTISAMPLEPROC glad_glTextureStorage2DMultisample;
+#define glTextureStorage2DMultisample glad_glTextureStorage2DMultisample
+	GLAD_API_CALL PFNGLPIXELSTOREFPROC glad_glPixelStoref;
+#define glPixelStoref glad_glPixelStoref
+	GLAD_API_CALL PFNGLUNIFORM2IVPROC glad_glUniform2iv;
+#define glUniform2iv glad_glUniform2iv
+	GLAD_API_CALL PFNGLRASTERPOS2SVPROC glad_glRasterPos2sv;
+#define glRasterPos2sv glad_glRasterPos2sv
+	GLAD_API_CALL PFNGLVERTEX2IPROC glad_glVertex2i;
+#define glVertex2i glad_glVertex2i
+	GLAD_API_CALL PFNGLFRUSTUMPROC glad_glFrustum;
+#define glFrustum glad_glFrustum
+	GLAD_API_CALL PFNGLMEMORYBARRIERPROC glad_glMemoryBarrier;
+#define glMemoryBarrier glad_glMemoryBarrier
+	GLAD_API_CALL PFNGLGETSTRINGPROC glad_glGetString;
+#define glGetString glad_glGetString
+	GLAD_API_CALL PFNGLLINEWIDTHPROC glad_glLineWidth;
+#define glLineWidth glad_glLineWidth
+	GLAD_API_CALL PFNGLNORMALPOINTERPROC glad_glNormalPointer;
+#define glNormalPointer glad_glNormalPointer
+	GLAD_API_CALL PFNGLGETNUNIFORMUIVPROC glad_glGetnUniformuiv;
+#define glGetnUniformuiv glad_glGetnUniformuiv
+	GLAD_API_CALL PFNGLDEPTHRANGEARRAYVPROC glad_glDepthRangeArrayv;
+#define glDepthRangeArrayv glad_glDepthRangeArrayv
+	GLAD_API_CALL PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui;
+#define glTexCoordP2ui glad_glTexCoordP2ui
+	GLAD_API_CALL PFNGLATTACHSHADERPROC glad_glAttachShader;
+#define glAttachShader glad_glAttachShader
+	GLAD_API_CALL PFNGLDRAWARRAYSPROC glad_glDrawArrays;
+#define glDrawArrays glad_glDrawArrays
+	GLAD_API_CALL PFNGLCOLOR4SPROC glad_glColor4s;
+#define glColor4s glad_glColor4s
+	GLAD_API_CALL PFNGLTEXGENDVPROC glad_glTexGendv;
+#define glTexGendv glad_glTexGendv
+	GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC glad_glProgramUniformMatrix3x2dv;
+#define glProgramUniformMatrix3x2dv glad_glProgramUniformMatrix3x2dv
+	GLAD_API_CALL PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv;
+#define glGetSamplerParameterIuiv glad_glGetSamplerParameterIuiv
+	GLAD_API_CALL PFNGLENDQUERYPROC glad_glEndQuery;
+#define glEndQuery glad_glEndQuery
+	GLAD_API_CALL PFNGLWINDOWPOS2SPROC glad_glWindowPos2s;
+#define glWindowPos2s glad_glWindowPos2s
+	GLAD_API_CALL PFNGLDRAWARRAYSINDIRECTPROC glad_glDrawArraysIndirect;
+#define glDrawArraysIndirect glad_glDrawArraysIndirect
+	GLAD_API_CALL PFNGLRASTERPOS3SPROC glad_glRasterPos3s;
+#define glRasterPos3s glad_glRasterPos3s
+	GLAD_API_CALL PFNGLGETNPIXELMAPFVPROC glad_glGetnPixelMapfv;
+#define glGetnPixelMapfv glad_glGetnPixelMapfv
+	GLAD_API_CALL PFNGLTEXCOORD3SVPROC glad_glTexCoord3sv;
+#define glTexCoord3sv glad_glTexCoord3sv
+	GLAD_API_CALL PFNGLRECTIPROC glad_glRecti;
+#define glRecti glad_glRecti
+	GLAD_API_CALL PFNGLUNIFORM4DVPROC glad_glUniform4dv;
+#define glUniform4dv glad_glUniform4dv
+	GLAD_API_CALL PFNGLBLENDEQUATIONSEPARATEIPROC glad_glBlendEquationSeparatei;
+#define glBlendEquationSeparatei glad_glBlendEquationSeparatei
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM3FVPROC glad_glProgramUniform3fv;
+#define glProgramUniform3fv glad_glProgramUniform3fv
+	GLAD_API_CALL PFNGLGETPROGRAMRESOURCEIVPROC glad_glGetProgramResourceiv;
+#define glGetProgramResourceiv glad_glGetProgramResourceiv
+	GLAD_API_CALL PFNGLINVALIDATESUBFRAMEBUFFERPROC glad_glInvalidateSubFramebuffer;
+#define glInvalidateSubFramebuffer glad_glInvalidateSubFramebuffer
+	GLAD_API_CALL PFNGLFENCESYNCPROC glad_glFenceSync;
+#define glFenceSync glad_glFenceSync
+	GLAD_API_CALL PFNGLUNIFORM3UIPROC glad_glUniform3ui;
+#define glUniform3ui glad_glUniform3ui
+	GLAD_API_CALL PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv;
+#define glSecondaryColorP3uiv glad_glSecondaryColorP3uiv
+	GLAD_API_CALL PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s;
+#define glVertexAttrib1s glad_glVertexAttrib1s
+	GLAD_API_CALL PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv;
+#define glVertexAttrib4Nsv glad_glVertexAttrib4Nsv
+	GLAD_API_CALL PFNGLLOADMATRIXFPROC glad_glLoadMatrixf;
+#define glLoadMatrixf glad_glLoadMatrixf
+	GLAD_API_CALL PFNGLTRANSLATEFPROC glad_glTranslatef;
+#define glTranslatef glad_glTranslatef
+	GLAD_API_CALL PFNGLMULTITEXCOORD4SVPROC glad_glMultiTexCoord4sv;
+#define glMultiTexCoord4sv glad_glMultiTexCoord4sv
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM2IVPROC glad_glProgramUniform2iv;
+#define glProgramUniform2iv glad_glProgramUniform2iv
+	GLAD_API_CALL PFNGLMAPGRID2FPROC glad_glMapGrid2f;
+#define glMapGrid2f glad_glMapGrid2f
+	GLAD_API_CALL PFNGLENABLECLIENTSTATEPROC glad_glEnableClientState;
+#define glEnableClientState glad_glEnableClientState
+	GLAD_API_CALL PFNGLGETUNIFORMIVPROC glad_glGetUniformiv;
+#define glGetUniformiv glad_glGetUniformiv
+	GLAD_API_CALL PFNGLEVALCOORD1DVPROC glad_glEvalCoord1dv;
+#define glEvalCoord1dv glad_glEvalCoord1dv
+	GLAD_API_CALL PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv;
+#define glVertexAttribI4iv glad_glVertexAttribI4iv
+	GLAD_API_CALL PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv;
+#define glVertexAttrib4sv glad_glVertexAttrib4sv
+	GLAD_API_CALL PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv;
+#define glGetMultisamplefv glad_glGetMultisamplefv
+	GLAD_API_CALL PFNGLINDEXDVPROC glad_glIndexdv;
+#define glIndexdv glad_glIndexdv
+	GLAD_API_CALL PFNGLBLENDFUNCIPROC glad_glBlendFunci;
+#define glBlendFunci glad_glBlendFunci
+	GLAD_API_CALL PFNGLISENABLEDPROC glad_glIsEnabled;
+#define glIsEnabled glad_glIsEnabled
+	GLAD_API_CALL PFNGLGETPIXELMAPUSVPROC glad_glGetPixelMapusv;
+#define glGetPixelMapusv glad_glGetPixelMapusv
+	GLAD_API_CALL PFNGLRASTERPOS3IVPROC glad_glRasterPos3iv;
+#define glRasterPos3iv glad_glRasterPos3iv
+	GLAD_API_CALL PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange;
+#define glMapBufferRange glad_glMapBufferRange
+	GLAD_API_CALL PFNGLMULTITEXCOORD2SPROC glad_glMultiTexCoord2s;
+#define glMultiTexCoord2s glad_glMultiTexCoord2s
+	GLAD_API_CALL PFNGLRASTERPOS2FPROC glad_glRasterPos2f;
+#define glRasterPos2f glad_glRasterPos2f
+	GLAD_API_CALL PFNGLMINSAMPLESHADINGPROC glad_glMinSampleShading;
+#define glMinSampleShading glad_glMinSampleShading
+	GLAD_API_CALL PFNGLGETQUERYBUFFEROBJECTUI64VPROC glad_glGetQueryBufferObjectui64v;
+#define glGetQueryBufferObjectui64v glad_glGetQueryBufferObjectui64v
+	GLAD_API_CALL PFNGLMULTITEXCOORD2IPROC glad_glMultiTexCoord2i;
+#define glMultiTexCoord2i glad_glMultiTexCoord2i
+	GLAD_API_CALL PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv;
+#define glVertexAttribP3uiv glad_glVertexAttribP3uiv
+	GLAD_API_CALL PFNGLVERTEX2FPROC glad_glVertex2f;
+#define glVertex2f glad_glVertex2f
+	GLAD_API_CALL PFNGLVERTEXARRAYBINDINGDIVISORPROC glad_glVertexArrayBindingDivisor;
+#define glVertexArrayBindingDivisor glad_glVertexArrayBindingDivisor
+	GLAD_API_CALL PFNGLINDEXPOINTERPROC glad_glIndexPointer;
+#define glIndexPointer glad_glIndexPointer
+	GLAD_API_CALL PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding;
+#define glUniformBlockBinding glad_glUniformBlockBinding
+	GLAD_API_CALL PFNGLRENDERMODEPROC glad_glRenderMode;
+#define glRenderMode glad_glRenderMode
+	GLAD_API_CALL PFNGLTEXSTORAGE1DPROC glad_glTexStorage1D;
+#define glTexStorage1D glad_glTexStorage1D
+	GLAD_API_CALL PFNGLBUFFERSUBDATAPROC glad_glBufferSubData;
+#define glBufferSubData glad_glBufferSubData
+	GLAD_API_CALL PFNGLCOLOR3FVPROC glad_glColor3fv;
+#define glColor3fv glad_glColor3fv
+	GLAD_API_CALL PFNGLBITMAPPROC glad_glBitmap;
+#define glBitmap glad_glBitmap
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM3UIVPROC glad_glProgramUniform3uiv;
+#define glProgramUniform3uiv glad_glProgramUniform3uiv
+	GLAD_API_CALL PFNGLVIEWPORTINDEXEDFPROC glad_glViewportIndexedf;
+#define glViewportIndexedf glad_glViewportIndexedf
+	GLAD_API_CALL PFNGLRASTERPOS2DPROC glad_glRasterPos2d;
+#define glRasterPos2d glad_glRasterPos2d
+	GLAD_API_CALL PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices;
+#define glGetUniformIndices glad_glGetUniformIndices
+	GLAD_API_CALL PFNGLENABLEIPROC glad_glEnablei;
+#define glEnablei glad_glEnablei
+	GLAD_API_CALL PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D;
+#define glFramebufferTexture2D glad_glFramebufferTexture2D
+	GLAD_API_CALL PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate;
+#define glBlendFuncSeparate glad_glBlendFuncSeparate
+	GLAD_API_CALL PFNGLNAMEDBUFFERSTORAGEPROC glad_glNamedBufferStorage;
+#define glNamedBufferStorage glad_glNamedBufferStorage
+	GLAD_API_CALL PFNGLRECTSPROC glad_glRects;
+#define glRects glad_glRects
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM2FVPROC glad_glProgramUniform2fv;
+#define glProgramUniform2fv glad_glProgramUniform2fv
+	GLAD_API_CALL PFNGLPOLYGONSTIPPLEPROC glad_glPolygonStipple;
+#define glPolygonStipple glad_glPolygonStipple
+	GLAD_API_CALL PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D;
+#define glCopyTexSubImage3D glad_glCopyTexSubImage3D
+	GLAD_API_CALL PFNGLSECONDARYCOLOR3UBPROC glad_glSecondaryColor3ub;
+#define glSecondaryColor3ub glad_glSecondaryColor3ub
+	GLAD_API_CALL PFNGLWINDOWPOS3FPROC glad_glWindowPos3f;
+#define glWindowPos3f glad_glWindowPos3f
+	GLAD_API_CALL PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv;
+#define glGetSamplerParameteriv glad_glGetSamplerParameteriv
+	GLAD_API_CALL PFNGLSHADERSTORAGEBLOCKBINDINGPROC glad_glShaderStorageBlockBinding;
+#define glShaderStorageBlockBinding glad_glShaderStorageBlockBinding
+	GLAD_API_CALL PFNGLLOADIDENTITYPROC glad_glLoadIdentity;
+#define glLoadIdentity glad_glLoadIdentity
+	GLAD_API_CALL PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex;
+#define glMultiDrawElementsBaseVertex glad_glMultiDrawElementsBaseVertex
+	GLAD_API_CALL PFNGLVERTEX2SPROC glad_glVertex2s;
+#define glVertex2s glad_glVertex2s
+	GLAD_API_CALL PFNGLMULTITEXCOORD1IVPROC glad_glMultiTexCoord1iv;
+#define glMultiTexCoord1iv glad_glMultiTexCoord1iv
+	GLAD_API_CALL PFNGLMULTITEXCOORD4SPROC glad_glMultiTexCoord4s;
+#define glMultiTexCoord4s glad_glMultiTexCoord4s
+	GLAD_API_CALL PFNGLRELEASESHADERCOMPILERPROC glad_glReleaseShaderCompiler;
+#define glReleaseShaderCompiler glad_glReleaseShaderCompiler
+	GLAD_API_CALL PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource;
+#define glGetShaderSource glad_glGetShaderSource
+	GLAD_API_CALL PFNGLMULTITEXCOORD2SVPROC glad_glMultiTexCoord2sv;
+#define glMultiTexCoord2sv glad_glMultiTexCoord2sv
+	GLAD_API_CALL PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv;
+#define glTexParameterfv glad_glTexParameterfv
+	GLAD_API_CALL PFNGLISSHADERPROC glad_glIsShader;
+#define glIsShader glad_glIsShader
+	GLAD_API_CALL PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv;
+#define glVertexAttrib4iv glad_glVertexAttrib4iv
+	GLAD_API_CALL PFNGLTEXCOORD4IPROC glad_glTexCoord4i;
+#define glTexCoord4i glad_glTexCoord4i
+	GLAD_API_CALL PFNGLCOLOR4UIPROC glad_glColor4ui;
+#define glColor4ui glad_glColor4ui
+	GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX3DVPROC glad_glProgramUniformMatrix3dv;
+#define glProgramUniformMatrix3dv glad_glProgramUniformMatrix3dv
+	GLAD_API_CALL PFNGLGETTEXENVFVPROC glad_glGetTexEnvfv;
+#define glGetTexEnvfv glad_glGetTexEnvfv
+	GLAD_API_CALL PFNGLTEXCOORD4DPROC glad_glTexCoord4d;
+#define glTexCoord4d glad_glTexCoord4d
+	GLAD_API_CALL PFNGLSCISSORARRAYVPROC glad_glScissorArrayv;
+#define glScissorArrayv glad_glScissorArrayv
+	GLAD_API_CALL PFNGLCREATERENDERBUFFERSPROC glad_glCreateRenderbuffers;
+#define glCreateRenderbuffers glad_glCreateRenderbuffers
+	GLAD_API_CALL PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv;
+#define glVertexAttrib3fv glad_glVertexAttrib3fv
+	GLAD_API_CALL PFNGLCOLOR4FPROC glad_glColor4f;
+#define glColor4f glad_glColor4f
+	GLAD_API_CALL PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub;
+#define glVertexAttrib4Nub glad_glVertexAttrib4Nub
+	GLAD_API_CALL PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv;
+#define glGetSamplerParameterIiv glad_glGetSamplerParameterIiv
+	GLAD_API_CALL PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D;
+#define glCopyTexSubImage2D glad_glCopyTexSubImage2D
+	GLAD_API_CALL PFNGLNORMAL3IVPROC glad_glNormal3iv;
+#define glNormal3iv glad_glNormal3iv
+	GLAD_API_CALL PFNGLBINDIMAGETEXTURESPROC glad_glBindImageTextures;
+#define glBindImageTextures glad_glBindImageTextures
+	GLAD_API_CALL PFNGLTEXGENIVPROC glad_glTexGeniv;
+#define glTexGeniv glad_glTexGeniv
+	GLAD_API_CALL PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D;
+#define glCompressedTexImage3D glad_glCompressedTexImage3D
+	GLAD_API_CALL PFNGLSCALEDPROC glad_glScaled;
+#define glScaled glad_glScaled
+	GLAD_API_CALL PFNGLCREATEPROGRAMPIPELINESPROC glad_glCreateProgramPipelines;
+#define glCreateProgramPipelines glad_glCreateProgramPipelines
+	GLAD_API_CALL PFNGLBLENDFUNCSEPARATEIPROC glad_glBlendFuncSeparatei;
+#define glBlendFuncSeparatei glad_glBlendFuncSeparatei
+	GLAD_API_CALL PFNGLHINTPROC glad_glHint;
+#define glHint glad_glHint
+	GLAD_API_CALL PFNGLMULTITEXCOORD4IPROC glad_glMultiTexCoord4i;
+#define glMultiTexCoord4i glad_glMultiTexCoord4i
+	GLAD_API_CALL PFNGLINDEXMASKPROC glad_glIndexMask;
+#define glIndexMask glad_glIndexMask
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM2FPROC glad_glProgramUniform2f;
+#define glProgramUniform2f glad_glProgramUniform2f
+	GLAD_API_CALL PFNGLCOLOR3BPROC glad_glColor3b;
+#define glColor3b glad_glColor3b
+	GLAD_API_CALL PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv;
+#define glVertexAttribI1uiv glad_glVertexAttribI1uiv
+	GLAD_API_CALL PFNGLSPECIALIZESHADERPROC glad_glSpecializeShader;
+#define glSpecializeShader glad_glSpecializeShader
+	GLAD_API_CALL PFNGLNAMEDFRAMEBUFFERDRAWBUFFERPROC glad_glNamedFramebufferDrawBuffer;
+#define glNamedFramebufferDrawBuffer glad_glNamedFramebufferDrawBuffer
+	GLAD_API_CALL PFNGLGETQUERYBUFFEROBJECTI64VPROC glad_glGetQueryBufferObjecti64v;
+#define glGetQueryBufferObjecti64v glad_glGetQueryBufferObjecti64v
+	GLAD_API_CALL PFNGLTEXCOORD3IVPROC glad_glTexCoord3iv;
+#define glTexCoord3iv glad_glTexCoord3iv
+	GLAD_API_CALL PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv;
+#define glSamplerParameterfv glad_glSamplerParameterfv
+	GLAD_API_CALL PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv;
+#define glGetVertexAttribIiv glad_glGetVertexAttribIiv
+	GLAD_API_CALL PFNGLBUFFERSTORAGEPROC glad_glBufferStorage;
+#define glBufferStorage glad_glBufferStorage
+	GLAD_API_CALL PFNGLVERTEX3SPROC glad_glVertex3s;
+#define glVertex3s glad_glVertex3s
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM2UIVPROC glad_glProgramUniform2uiv;
+#define glProgramUniform2uiv glad_glProgramUniform2uiv
+	GLAD_API_CALL PFNGLDEPTHRANGEPROC glad_glDepthRange;
+#define glDepthRange glad_glDepthRange
+	GLAD_API_CALL PFNGLRASTERPOS3FPROC glad_glRasterPos3f;
+#define glRasterPos3f glad_glRasterPos3f
+	GLAD_API_CALL PFNGLDELETESHADERPROC glad_glDeleteShader;
+#define glDeleteShader glad_glDeleteShader
+	GLAD_API_CALL PFNGLCOLOR3BVPROC glad_glColor3bv;
+#define glColor3bv glad_glColor3bv
+	GLAD_API_CALL PFNGLCOLOR3UBVPROC glad_glColor3ubv;
+#define glColor3ubv glad_glColor3ubv
+	GLAD_API_CALL PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv;
+#define glGetVertexAttribiv glad_glGetVertexAttribiv
+	GLAD_API_CALL PFNGLTEXCOORD4SVPROC glad_glTexCoord4sv;
+#define glTexCoord4sv glad_glTexCoord4sv
+	GLAD_API_CALL PFNGLMAP2DPROC glad_glMap2d;
+#define glMap2d glad_glMap2d
+	GLAD_API_CALL PFNGLFOGCOORDFPROC glad_glFogCoordf;
+#define glFogCoordf glad_glFogCoordf
+	GLAD_API_CALL PFNGLEDGEFLAGVPROC glad_glEdgeFlagv;
+#define glEdgeFlagv glad_glEdgeFlagv
+	GLAD_API_CALL PFNGLCLIPCONTROLPROC glad_glClipControl;
+#define glClipControl glad_glClipControl
+	GLAD_API_CALL PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv;
+#define glGetBufferParameteriv glad_glGetBufferParameteriv
+	GLAD_API_CALL PFNGLGETTRANSFORMFEEDBACKIVPROC glad_glGetTransformFeedbackiv;
+#define glGetTransformFeedbackiv glad_glGetTransformFeedbackiv
+	GLAD_API_CALL PFNGLGETPROGRAMPIPELINEIVPROC glad_glGetProgramPipelineiv;
+#define glGetProgramPipelineiv glad_glGetProgramPipelineiv
+	GLAD_API_CALL PFNGLGETNMINMAXPROC glad_glGetnMinmax;
+#define glGetnMinmax glad_glGetnMinmax
+	GLAD_API_CALL PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glNamedRenderbufferStorageMultisample;
+#define glNamedRenderbufferStorageMultisample glad_glNamedRenderbufferStorageMultisample
+	GLAD_API_CALL PFNGLCOLORP4UIPROC glad_glColorP4ui;
+#define glColorP4ui glad_glColorP4ui
+	GLAD_API_CALL PFNGLMULTITEXCOORD1SVPROC glad_glMultiTexCoord1sv;
+#define glMultiTexCoord1sv glad_glMultiTexCoord1sv
+	GLAD_API_CALL PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv;
+#define glVertexAttrib4fv glad_glVertexAttrib4fv
+	GLAD_API_CALL PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv;
+#define glVertexAttrib4dv glad_glVertexAttrib4dv
+	GLAD_API_CALL PFNGLVERTEXP4UIPROC glad_glVertexP4ui;
+#define glVertexP4ui glad_glVertexP4ui
+	GLAD_API_CALL PFNGLRECTFVPROC glad_glRectfv;
+#define glRectfv glad_glRectfv
+	GLAD_API_CALL PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback;
+#define glBeginTransformFeedback glad_glBeginTransformFeedback
+	GLAD_API_CALL PFNGLARRAYELEMENTPROC glad_glArrayElement;
+#define glArrayElement glad_glArrayElement
+	GLAD_API_CALL PFNGLNAMEDFRAMEBUFFERTEXTURELAYERPROC glad_glNamedFramebufferTextureLayer;
+#define glNamedFramebufferTextureLayer glad_glNamedFramebufferTextureLayer
+	GLAD_API_CALL PFNGLBEGINPROC glad_glBegin;
+#define glBegin glad_glBegin
+	GLAD_API_CALL PFNGLTEXCOORDPOINTERPROC glad_glTexCoordPointer;
+#define glTexCoordPointer glad_glTexCoordPointer
+	GLAD_API_CALL PFNGLTEXCOORD3DPROC glad_glTexCoord3d;
+#define glTexCoord3d glad_glTexCoord3d
+	GLAD_API_CALL PFNGLUNIFORM1FVPROC glad_glUniform1fv;
+#define glUniform1fv glad_glUniform1fv
+	GLAD_API_CALL PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv;
+#define glVertexAttrib2sv glad_glVertexAttrib2sv
+	GLAD_API_CALL PFNGLGETPROGRAMPIPELINEINFOLOGPROC glad_glGetProgramPipelineInfoLog;
+#define glGetProgramPipelineInfoLog glad_glGetProgramPipelineInfoLog
+	GLAD_API_CALL PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset;
+#define glPolygonOffset glad_glPolygonOffset
+	GLAD_API_CALL PFNGLGETSHADERPRECISIONFORMATPROC glad_glGetShaderPrecisionFormat;
+#define glGetShaderPrecisionFormat glad_glGetShaderPrecisionFormat
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM3DPROC glad_glProgramUniform3d;
+#define glProgramUniform3d glad_glProgramUniform3d
+	GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC glad_glProgramUniformMatrix4x2dv;
+#define glProgramUniformMatrix4x2dv glad_glProgramUniformMatrix4x2dv
+	GLAD_API_CALL PFNGLBINDTRANSFORMFEEDBACKPROC glad_glBindTransformFeedback;
+#define glBindTransformFeedback glad_glBindTransformFeedback
+	GLAD_API_CALL PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex;
+#define glProvokingVertex glad_glProvokingVertex
+	GLAD_API_CALL PFNGLDISABLEVERTEXARRAYATTRIBPROC glad_glDisableVertexArrayAttrib;
+#define glDisableVertexArrayAttrib glad_glDisableVertexArrayAttrib
+	GLAD_API_CALL PFNGLMULTITEXCOORD4FVPROC glad_glMultiTexCoord4fv;
+#define glMultiTexCoord4fv glad_glMultiTexCoord4fv
+	GLAD_API_CALL PFNGLUNIFORM1DPROC glad_glUniform1d;
+#define glUniform1d glad_glUniform1d
+	GLAD_API_CALL PFNGLVERTEXATTRIBFORMATPROC glad_glVertexAttribFormat;
+#define glVertexAttribFormat glad_glVertexAttribFormat
+	GLAD_API_CALL PFNGLMEMORYBARRIERBYREGIONPROC glad_glMemoryBarrierByRegion;
+#define glMemoryBarrierByRegion glad_glMemoryBarrierByRegion
+	GLAD_API_CALL PFNGLPOPDEBUGGROUPPROC glad_glPopDebugGroup;
+#define glPopDebugGroup glad_glPopDebugGroup
+	GLAD_API_CALL PFNGLCOLOR4BPROC glad_glColor4b;
+#define glColor4b glad_glColor4b
+	GLAD_API_CALL PFNGLTEXTUREBUFFERPROC glad_glTextureBuffer;
+#define glTextureBuffer glad_glTextureBuffer
+	GLAD_API_CALL PFNGLGETSHADERIVPROC glad_glGetShaderiv;
+#define glGetShaderiv glad_glGetShaderiv
+	GLAD_API_CALL PFNGLBEGINQUERYINDEXEDPROC glad_glBeginQueryIndexed;
+#define glBeginQueryIndexed glad_glBeginQueryIndexed
+	GLAD_API_CALL PFNGLCOPYNAMEDBUFFERSUBDATAPROC glad_glCopyNamedBufferSubData;
+#define glCopyNamedBufferSubData glad_glCopyNamedBufferSubData
+	GLAD_API_CALL PFNGLVERTEXARRAYATTRIBFORMATPROC glad_glVertexArrayAttribFormat;
+#define glVertexArrayAttribFormat glad_glVertexArrayAttribFormat
+	GLAD_API_CALL PFNGLMAPNAMEDBUFFERRANGEPROC glad_glMapNamedBufferRange;
+#define glMapNamedBufferRange glad_glMapNamedBufferRange
+	GLAD_API_CALL PFNGLCOLOR4UIVPROC glad_glColor4uiv;
+#define glColor4uiv glad_glColor4uiv
+	GLAD_API_CALL PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui;
+#define glVertexAttribP1ui glad_glVertexAttribP1ui
+	GLAD_API_CALL PFNGLWINDOWPOS3SVPROC glad_glWindowPos3sv;
+#define glWindowPos3sv glad_glWindowPos3sv
+	GLAD_API_CALL PFNGLFOGIVPROC glad_glFogiv;
+#define glFogiv glad_glFogiv
+	GLAD_API_CALL PFNGLTEXTUREPARAMETERIIVPROC glad_glTextureParameterIiv;
+#define glTextureParameterIiv glad_glTextureParameterIiv
+	GLAD_API_CALL PFNGLLISTBASEPROC glad_glListBase;
+#define glListBase glad_glListBase
+	GLAD_API_CALL PFNGLCREATEFRAMEBUFFERSPROC glad_glCreateFramebuffers;
+#define glCreateFramebuffers glad_glCreateFramebuffers
+	GLAD_API_CALL PFNGLEVALCOORD2FPROC glad_glEvalCoord2f;
+#define glEvalCoord2f glad_glEvalCoord2f
+	GLAD_API_CALL PFNGLVERTEX4DVPROC glad_glVertex4dv;
+#define glVertex4dv glad_glVertex4dv
+	GLAD_API_CALL PFNGLDELETEPROGRAMPROC glad_glDeleteProgram;
+#define glDeleteProgram glad_glDeleteProgram
+	GLAD_API_CALL PFNGLDRAWELEMENTSPROC glad_glDrawElements;
+#define glDrawElements glad_glDrawElements
+	GLAD_API_CALL PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC glad_glDrawTransformFeedbackStream;
+#define glDrawTransformFeedbackStream glad_glDrawTransformFeedbackStream
+	GLAD_API_CALL PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram;
+#define glValidateProgram glad_glValidateProgram
+	GLAD_API_CALL PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced;
+#define glDrawElementsInstanced glad_glDrawElementsInstanced
+	GLAD_API_CALL PFNGLGENLISTSPROC glad_glGenLists;
+#define glGenLists glad_glGenLists
+	GLAD_API_CALL PFNGLCOLOR4IPROC glad_glColor4i;
+#define glColor4i glad_glColor4i
+	GLAD_API_CALL PFNGLCOLOR3UIPROC glad_glColor3ui;
+#define glColor3ui glad_glColor3ui
+	GLAD_API_CALL PFNGLCREATETEXTURESPROC glad_glCreateTextures;
+#define glCreateTextures glad_glCreateTextures
+	GLAD_API_CALL PFNGLCOLORP4UIVPROC glad_glColorP4uiv;
+#define glColorP4uiv glad_glColorP4uiv
+	GLAD_API_CALL PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog;
+#define glGetProgramInfoLog glad_glGetProgramInfoLog
+	GLAD_API_CALL PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui;
+#define glVertexAttribP3ui glad_glVertexAttribP3ui
+	GLAD_API_CALL PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi;
+#define glClearBufferfi glad_glClearBufferfi
+	GLAD_API_CALL PFNGLCOPYTEXTURESUBIMAGE3DPROC glad_glCopyTextureSubImage3D;
+#define glCopyTextureSubImage3D glad_glCopyTextureSubImage3D
+	GLAD_API_CALL PFNGLEDGEFLAGPROC glad_glEdgeFlag;
+#define glEdgeFlag glad_glEdgeFlag
+	GLAD_API_CALL PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v;
+#define glGetBufferParameteri64v glad_glGetBufferParameteri64v
+	GLAD_API_CALL PFNGLRASTERPOS2IVPROC glad_glRasterPos2iv;
+#define glRasterPos2iv glad_glRasterPos2iv
+	GLAD_API_CALL PFNGLGETNMAPIVPROC glad_glGetnMapiv;
+#define glGetnMapiv glad_glGetnMapiv
+	GLAD_API_CALL PFNGLRECTDVPROC glad_glRectdv;
+#define glRectdv glad_glRectdv
+	GLAD_API_CALL PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v;
+#define glGetBooleani_v glad_glGetBooleani_v
+	GLAD_API_CALL PFNGLENDLISTPROC glad_glEndList;
+#define glEndList glad_glEndList
+	GLAD_API_CALL PFNGLFLUSHPROC glad_glFlush;
+#define glFlush glad_glFlush
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM4UIPROC glad_glProgramUniform4ui;
+#define glProgramUniform4ui glad_glProgramUniform4ui
+	GLAD_API_CALL PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTPROC glad_glMultiDrawElementsIndirectCount;
+#define glMultiDrawElementsIndirectCount glad_glMultiDrawElementsIndirectCount
+	GLAD_API_CALL PFNGLGETINTEGER64VPROC glad_glGetInteger64v;
+#define glGetInteger64v glad_glGetInteger64v
+	GLAD_API_CALL PFNGLLIGHTMODELFPROC glad_glLightModelf;
+#define glLightModelf glad_glLightModelf
+	GLAD_API_CALL PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv;
+#define glVertexAttrib4Niv glad_glVertexAttrib4Niv
+	GLAD_API_CALL PFNGLGETTEXTURELEVELPARAMETERIVPROC glad_glGetTextureLevelParameteriv;
+#define glGetTextureLevelParameteriv glad_glGetTextureLevelParameteriv
+	GLAD_API_CALL PFNGLLOADMATRIXDPROC glad_glLoadMatrixd;
+#define glLoadMatrixd glad_glLoadMatrixd
+	GLAD_API_CALL PFNGLBINDPROGRAMPIPELINEPROC glad_glBindProgramPipeline;
+#define glBindProgramPipeline glad_glBindProgramPipeline
+	GLAD_API_CALL PFNGLPROGRAMUNIFORM1UIVPROC glad_glProgramUniform1uiv;
+#define glProgramUniform1uiv glad_glProgramUniform1uiv
+	GLAD_API_CALL PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray;
+#define glDisableVertexAttribArray glad_glDisableVertexAttribArray
+	GLAD_API_CALL PFNGLCLEARDEPTHPROC glad_glClearDepth;
+#define glClearDepth glad_glClearDepth
+	GLAD_API_CALL PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv;
+#define glGetTexParameterIiv glad_glGetTexParameterIiv
+	GLAD_API_CALL PFNGLWINDOWPOS3FVPROC glad_glWindowPos3fv;
+#define glWindowPos3fv glad_glWindowPos3fv
+	GLAD_API_CALL PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d;
+#define glVertexAttrib3d glad_glVertexAttrib3d
+	GLAD_API_CALL PFNGLGETPROGRAMRESOURCELOCATIONPROC glad_glGetProgramResourceLocation;
+#define glGetProgramResourceLocation glad_glGetProgramResourceLocation
+	GLAD_API_CALL PFNGLTEXCOORD2DPROC glad_glTexCoord2d;
+#define glTexCoord2d glad_glTexCoord2d
+	GLAD_API_CALL PFNGLACCUMPROC glad_glAccum;
+#define glAccum glad_glAccum
+	GLAD_API_CALL PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui;
+#define glSecondaryColorP3ui glad_glSecondaryColorP3ui
+	GLAD_API_CALL PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui;
+#define glVertexAttribI2ui glad_glVertexAttribI2ui
+	GLAD_API_CALL PFNGLGETNUNIFORMFVPROC glad_glGetnUniformfv;
+#define glGetnUniformfv glad_glGetnUniformfv
+	GLAD_API_CALL PFNGLFOGIPROC glad_glFogi;
+#define glFogi glad_glFogi
+	GLAD_API_CALL PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv;
+#define glClearBufferfv glad_glClearBufferfv
+	GLAD_API_CALL PFNGLTEXENVIVPROC glad_glTexEnviv;
+#define glTexEnviv glad_glTexEnviv
+	GLAD_API_CALL PFNGLTEXIMAGE2DPROC glad_glTexImage2D;
+#define glTexImage2D glad_glTexImage2D
+	GLAD_API_CALL PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC glad_glGetActiveAtomicCounterBufferiv;
+#define glGetActiveAtomicCounterBufferiv glad_glGetActiveAtomicCounterBufferiv
+	GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC glad_glProgramUniformMatrix4x3fv;
+#define glProgramUniformMatrix4x3fv glad_glProgramUniformMatrix4x3fv
+	GLAD_API_CALL PFNGLMULTITEXCOORD1FVPROC glad_glMultiTexCoord1fv;
+#define glMultiTexCoord1fv glad_glMultiTexCoord1fv
+	GLAD_API_CALL PFNGLGETOBJECTPTRLABELPROC glad_glGetObjectPtrLabel;
+#define glGetObjectPtrLabel glad_glGetObjectPtrLabel
+
+	GLAD_API_CALL int gladLoadGLUserPtr(GLADuserptrloadfunc load, void *userptr);
+	GLAD_API_CALL int gladLoadGL(GLADloadfunc load);
+
+#ifdef GLAD_GL
+
+	GLAD_API_CALL int gladLoaderLoadGL(void);
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/glad/glad/glx.h b/engine/inc/bullet/ThirdPartyLibs/glad/glad/glx.h
new file mode 100644
index 00000000..a0401e83
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/glad/glad/glx.h
@@ -0,0 +1,1111 @@
+/**
+ * Loader generated by glad 0.1.11a0 on Wed Jun 13 07:59:53 2018
+ *
+ * Generator: C/C++
+ * Specification: glx
+ * Extensions: 63
+ *
+ * APIs:
+ *  - glx=1.4
+ *
+ * Options:
+ *  - MX = False
+ *  - DEBUG = False
+ *  - MX_GLOBAL = False
+ *  - HEADER_ONLY = False
+ *  - LOADER = True
+ *  - ALIAS = False
+ *
+ * Commandline:
+ *    --api='glx=1.4' --extensions='GLX_MESA_copy_sub_buffer,GLX_EXT_create_context_es_profile,GLX_SGIX_pbuffer,GLX_SGI_make_current_read,GLX_OML_sync_control,GLX_SGIX_hyperpipe,GLX_INTEL_swap_event,GLX_EXT_swap_control,GLX_NV_robustness_video_memory_purge,GLX_MESA_pixmap_colormap,GLX_ARB_fbconfig_float,GLX_EXT_fbconfig_packed_float,GLX_OML_swap_method,GLX_NV_video_capture,GLX_ARB_robustness_application_isolation,GLX_ARB_create_context_robustness,GLX_EXT_visual_rating,GLX_NV_swap_group,GLX_EXT_texture_from_pixmap,GLX_SUN_get_transparent_index,GLX_MESA_release_buffers,GLX_NV_delay_before_swap,GLX_EXT_buffer_age,GLX_MESA_agp_offset,GLX_EXT_visual_info,GLX_SGI_swap_control,GLX_EXT_import_context,GLX_SGI_video_sync,GLX_3DFX_multisample,GLX_ARB_multisample,GLX_EXT_framebuffer_sRGB,GLX_SGI_cushion,GLX_ARB_robustness_share_group_isolation,GLX_SGIX_fbconfig,GLX_NV_copy_buffer,GLX_SGIX_visual_select_group,GLX_EXT_swap_control_tear,GLX_ARB_create_context,GLX_AMD_gpu_association,GLX_MESA_query_renderer,GLX_EXT_create_context_es2_profile,GLX_MESA_swap_control,GLX_SGIX_video_resize,GLX_ARB_context_flush_control,GLX_NV_video_out,GLX_EXT_no_config_context,GLX_SGIS_blended_overlay,GLX_EXT_stereo_tree,GLX_ARB_create_context_no_error,GLX_EXT_libglvnd,GLX_ARB_create_context_profile,GLX_NV_float_buffer,GLX_MESA_set_3dfx_mode,GLX_ARB_framebuffer_sRGB,GLX_ARB_get_proc_address,GLX_SGIS_shared_multisample,GLX_NV_copy_image,GLX_NV_present_video,GLX_SGIX_swap_barrier,GLX_SGIS_multisample,GLX_SGIX_swap_group,GLX_ARB_vertex_buffer_object,GLX_NV_multisample_coverage' c --loader
+ *
+ * Online:
+ *    http://glad2.dav1d.de/#merge=off&api=glx%3D1.4&extensions=GLX_MESA_copy_sub_buffer%2CGLX_EXT_create_context_es_profile%2CGLX_SGIX_pbuffer%2CGLX_SGI_make_current_read%2CGLX_OML_sync_control%2CGLX_SGIX_hyperpipe%2CGLX_INTEL_swap_event%2CGLX_EXT_swap_control%2CGLX_NV_robustness_video_memory_purge%2CGLX_MESA_pixmap_colormap%2CGLX_ARB_fbconfig_float%2CGLX_EXT_fbconfig_packed_float%2CGLX_OML_swap_method%2CGLX_NV_video_capture%2CGLX_ARB_robustness_application_isolation%2CGLX_ARB_create_context_robustness%2CGLX_EXT_visual_rating%2CGLX_NV_swap_group%2CGLX_EXT_texture_from_pixmap%2CGLX_SUN_get_transparent_index%2CGLX_MESA_release_buffers%2CGLX_NV_delay_before_swap%2CGLX_EXT_buffer_age%2CGLX_MESA_agp_offset%2CGLX_EXT_visual_info%2CGLX_SGI_swap_control%2CGLX_EXT_import_context%2CGLX_SGI_video_sync%2CGLX_3DFX_multisample%2CGLX_ARB_multisample%2CGLX_EXT_framebuffer_sRGB%2CGLX_SGI_cushion%2CGLX_ARB_robustness_share_group_isolation%2CGLX_SGIX_fbconfig%2CGLX_NV_copy_buffer%2CGLX_SGIX_visual_select_group%2CGLX_EXT_swap_control_tear%2CGLX_ARB_create_context%2CGLX_AMD_gpu_association%2CGLX_MESA_query_renderer%2CGLX_EXT_create_context_es2_profile%2CGLX_MESA_swap_control%2CGLX_SGIX_video_resize%2CGLX_ARB_context_flush_control%2CGLX_NV_video_out%2CGLX_EXT_no_config_context%2CGLX_SGIS_blended_overlay%2CGLX_EXT_stereo_tree%2CGLX_ARB_create_context_no_error%2CGLX_EXT_libglvnd%2CGLX_ARB_create_context_profile%2CGLX_NV_float_buffer%2CGLX_MESA_set_3dfx_mode%2CGLX_ARB_framebuffer_sRGB%2CGLX_ARB_get_proc_address%2CGLX_SGIS_shared_multisample%2CGLX_NV_copy_image%2CGLX_NV_present_video%2CGLX_SGIX_swap_barrier%2CGLX_SGIS_multisample%2CGLX_SGIX_swap_group%2CGLX_ARB_vertex_buffer_object%2CGLX_NV_multisample_coverage&generator=c&mx=off&debug=off&mx_global=off&header_only=off&loader=on&alias=off
+ *
+ */
+
+#ifndef GLAD_GLX_H_
+#define GLAD_GLX_H_
+
+#ifdef GLX_H
+#error GLX header already included (API: glx), remove previous include!
+#endif
+#define GLX_H 1
+
+#include <X11/X.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+
+#include <glad/gl.h>
+
+#define GLAD_GLX
+#define GLAD_OPTION_GLX_LOADER
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#ifndef GLAD_PLATFORM_H_
+#define GLAD_PLATFORM_H_
+
+#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__MINGW32__)
+#define GLAD_PLATFORM_WIN32 1
+#else
+#define GLAD_PLATFORM_WIN32 0
+#endif
+
+#ifndef GLAD_PLATFORM_UWP
+#if defined(_MSC_VER) && !defined(GLAD_INTERNAL_HAVE_WINAPIFAMILY)
+#ifdef __has_include
+#if __has_include(<winapifamily.h>)
+#define GLAD_INTERNAL_HAVE_WINAPIFAMILY 1
+#endif
+#elif _MSC_VER >= 1700 && !_USING_V110_SDK71_
+#define GLAD_INTERNAL_HAVE_WINAPIFAMILY 1
+#endif
+#endif
+
+#ifdef GLAD_INTERNAL_HAVE_WINAPIFAMILY
+#include <winapifamily.h>
+#if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
+#define GLAD_PLATFORM_UWP 1
+#endif
+#endif
+
+#ifndef GLAD_PLATFORM_UWP
+#define GLAD_PLATFORM_UWP 0
+#endif
+#endif
+
+#ifdef __GNUC__
+#define GLAD_GNUC_EXTENSION __extension__
+#else
+#define GLAD_GNUC_EXTENSION
+#endif
+
+#ifndef GLAD_API_CALL
+#if defined(GLAD_API_CALL_EXPORT)
+#if GLAD_PLATFORM_WIN32 || defined(__CYGWIN__)
+#if defined(GLAD_API_CALL_EXPORT_BUILD)
+#if defined(__GNUC__)
+#define GLAD_API_CALL __attribute__((dllexport)) extern
+#else
+#define GLAD_API_CALL __declspec(dllexport) extern
+#endif
+#else
+#if defined(__GNUC__)
+#define GLAD_API_CALL __attribute__((dllimport)) extern
+#else
+#define GLAD_API_CALL __declspec(dllimport) extern
+#endif
+#endif
+#elif defined(__GNUC__) && defined(GLAD_API_CALL_EXPORT_BUILD)
+#define GLAD_API_CALL __attribute__((visibility("default"))) extern
+#else
+#define GLAD_API_CALL extern
+#endif
+#else
+#define GLAD_API_CALL extern
+#endif
+#endif
+
+#ifdef APIENTRY
+#define GLAD_API_PTR APIENTRY
+#elif GLAD_PLATFORM_WIN32
+#define GLAD_API_PTR __stdcall
+#else
+#define GLAD_API_PTR
+#endif
+
+#define GLAD_MAKE_VERSION(major, minor) (major * 10000 + minor)
+#define GLAD_VERSION_MAJOR(version) (version / 10000)
+#define GLAD_VERSION_MINOR(version) (version % 10000)
+
+	typedef void (*GLADapiproc)(void);
+
+	typedef GLADapiproc (*GLADloadfunc)(const char *name);
+	typedef GLADapiproc (*GLADuserptrloadfunc)(const char *name, void *userptr);
+
+	typedef void (*GLADprecallback)(const char *name, GLADapiproc apiproc, int len_args, ...);
+	typedef void (*GLADpostcallback)(void *ret, const char *name, GLADapiproc apiproc, int len_args, ...);
+
+#endif /* GLAD_PLATFORM_H_ */
+
+#define GLX_RGBA_FLOAT_BIT_ARB 0x00000004
+#define __GLX_NUMBER_EVENTS 17
+#define GLX_X_VISUAL_TYPE 0x22
+#define GLX_PRESERVED_CONTENTS 0x801B
+#define GLX_CONTEXT_ES_PROFILE_BIT_EXT 0x00000004
+#define GLX_3DFX_WINDOW_MODE_MESA 0x1
+#define GLX_RENDERER_VERSION_MESA 0x8185
+#define GLX_TRANSPARENT_GREEN_VALUE 0x26
+#define GLX_VIDEO_OUT_STACKED_FIELDS_1_2_NV 0x20CB
+#define GLX_RENDER_TYPE_SGIX 0x8011
+#define GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK 0x04000000
+#define GLX_TRANSPARENT_ALPHA_VALUE 0x28
+#define GLX_AUX2_EXT 0x20E4
+#define GLX_FRONT_LEFT_EXT 0x20DE
+#define GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
+#define GLX_NO_EXTENSION 3
+#define GLX_DIRECT_COLOR_EXT 0x8003
+#define GLX_BAD_VISUAL 4
+#define GLX_BAD_CONTEXT 5
+#define GLX_VIDEO_OUT_FIELD_2_NV 0x20CA
+#define GLX_STEREO_NOTIFY_EXT 0x00000000
+#define GLX_ACCUM_BLUE_SIZE 16
+#define GLX_COVERAGE_SAMPLES_NV 100001
+#define GLX_BACK_BUFFER_AGE_EXT 0x20F4
+#define GLX_SLOW_VISUAL_EXT 0x8001
+#define GLX_GPU_FASTEST_TARGET_GPUS_AMD 0x21A2
+#define GLX_EVENT_MASK 0x801F
+#define GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB 0x8256
+#define GLX_SAMPLE_BUFFERS_3DFX 0x8050
+#define GLX_MAX_PBUFFER_PIXELS_SGIX 0x8018
+#define GLX_USE_GL 1
+#define GLX_PIXMAP_BIT 0x00000002
+#define GLX_HYPERPIPE_STEREO_SGIX 0x00000003
+#define GLX_TRANSPARENT_RGB 0x8008
+#define GLX_PRESERVED_CONTENTS_SGIX 0x801B
+#define GLX_GPU_NUM_PIPES_AMD 0x21A5
+#define GLX_RENDER_TYPE 0x8011
+#define GLX_MAX_PBUFFER_WIDTH_SGIX 0x8016
+#define GLX_X_VISUAL_TYPE_EXT 0x22
+#define GLX_FRONT_EXT GLX_FRONT_LEFT_EXT
+#define GLX_TRANSPARENT_TYPE_EXT 0x23
+#define GLX_HYPERPIPE_ID_SGIX 0x8030
+#define GLX_GPU_OPENGL_VERSION_STRING_AMD 0x1F02
+#define GLX_RENDERER_ACCELERATED_MESA 0x8186
+#define GLX_DAMAGED_SGIX 0x8020
+#define GLX_STEREO 6
+#define GLX_FLOAT_COMPONENTS_NV 0x20B0
+#define GLX_GPU_RENDERER_STRING_AMD 0x1F01
+#define GLX_SWAP_UNDEFINED_OML 0x8063
+#define GLX_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB 0x2098
+#define GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x00000002
+#define GLX_TRUE_COLOR 0x8002
+#define GLX_SAVED 0x8021
+#define GLX_RENDERER_DEVICE_ID_MESA 0x8184
+#define GLX_RENDERER_OPENGL_ES_PROFILE_VERSION_MESA 0x818C
+#define GLX_BIND_TO_TEXTURE_TARGETS_EXT 0x20D3
+#define GLX_TRANSPARENT_RED_VALUE_EXT 0x25
+#define GLX_VIDEO_OUT_COLOR_AND_DEPTH_NV 0x20C7
+#define GLX_WINDOW_SGIX 0x8022
+#define GLX_TRANSPARENT_INDEX_VALUE 0x24
+#define GLX_NONE_EXT 0x8000
+#define GLX_FRONT_RIGHT_BUFFER_BIT 0x00000002
+#define GLX_SAMPLE_BUFFERS_ARB 100000
+#define GLX_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001
+#define GLX_VIDEO_OUT_DEPTH_NV 0x20C5
+#define GLX_RENDERER_VIDEO_MEMORY_MESA 0x8187
+#define GLX_MULTISAMPLE_SUB_RECT_WIDTH_SGIS 0x8026
+#define GLX_TEXTURE_1D_EXT 0x20DB
+#define GLX_SYNC_SWAP_SGIX 0x00000001
+#define GLX_SAMPLE_BUFFERS_BIT_SGIX 0x00000100
+#define GLX_VIDEO_OUT_COLOR_NV 0x20C3
+#define GLX_DEPTH_BUFFER_BIT 0x00000020
+#define GLX_AUX_BUFFERS_BIT 0x00000010
+#define GLX_BLENDED_RGBA_SGIS 0x8025
+#define GLX_DRAWABLE_TYPE_SGIX 0x8010
+#define GLX_DEPTH_SIZE 12
+#define GLX_SAMPLES_ARB 100001
+#define GLX_VISUAL_ID_EXT 0x800B
+#define GLX_STEREO_TREE_EXT 0x20F5
+#define GLX_NON_CONFORMANT_CONFIG 0x800D
+#define GLX_GPU_VENDOR_AMD 0x1F00
+#define GLX_WINDOW_BIT 0x00000001
+#define GLX_CONTEXT_PROFILE_MASK_ARB 0x9126
+#define GLX_SAMPLES_3DFX 0x8051
+#define GLX_BUFFER_SIZE 2
+#define GLX_TEXTURE_2D_BIT_EXT 0x00000002
+#define GLX_VIDEO_OUT_FIELD_1_NV 0x20C9
+#define GLX_CONTEXT_ES2_PROFILE_BIT_EXT GLX_CONTEXT_ES_PROFILE_BIT_EXT
+#define GLX_DEVICE_ID_NV 0x20CD
+#define GLX_WINDOW 0x8022
+#define GLX_TEXTURE_2D_EXT 0x20DC
+#define GLX_PSEUDO_COLOR 0x8004
+#define GLX_BIND_TO_TEXTURE_RGBA_EXT 0x20D1
+#define GLX_RENDERER_OPENGL_CORE_PROFILE_VERSION_MESA 0x818A
+#define GLX_TEXTURE_TARGET_EXT 0x20D6
+#define GLX_AUX_BUFFERS_BIT_SGIX 0x00000010
+#define GLX_AUX4_EXT 0x20E6
+#define GLX_STATIC_COLOR_EXT 0x8005
+#define GLX_TRANSPARENT_INDEX_VALUE_EXT 0x24
+#define GLX_TEXTURE_FORMAT_RGB_EXT 0x20D9
+#define GLX_GPU_CLOCK_AMD 0x21A4
+#define GLX_GPU_NUM_RB_AMD 0x21A7
+#define GLX_BACK_RIGHT_BUFFER_BIT_SGIX 0x00000008
+#define GLX_VENDOR_NAMES_EXT 0x20F6
+#define GLX_CONTEXT_MINOR_VERSION_ARB 0x2092
+#define GLX_HYPERPIPE_DISPLAY_PIPE_SGIX 0x00000001
+#define GLX_ACCUM_GREEN_SIZE 15
+#define GLX_MAX_SWAP_INTERVAL_EXT 0x20F2
+#define GLX_PBUFFER 0x8023
+#define GLX_RGBA_TYPE_SGIX 0x8014
+#define GLX_PBUFFER_BIT 0x00000004
+#define GLX_RENDERER_OPENGL_ES2_PROFILE_VERSION_MESA 0x818D
+#define GLX_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB 0
+#define GLX_TRANSPARENT_INDEX_EXT 0x8009
+#define GLX_COPY_COMPLETE_INTEL 0x8181
+#define GLX_NONE 0x8000
+#define GLX_PbufferClobber 0
+#define GLX_RGBA 4
+#define GLX_HEIGHT_SGIX 0x801E
+#define GLX_BAD_HYPERPIPE_CONFIG_SGIX 91
+#define GLX_SWAP_COPY_OML 0x8062
+#define GLX_BACK_RIGHT_EXT 0x20E1
+#define GLX_CONTEXT_RELEASE_BEHAVIOR_ARB 0x2097
+#define GLX_SLOW_CONFIG 0x8001
+#define GLX_RENDERER_PREFERRED_PROFILE_MESA 0x8189
+#define GLX_Y_INVERTED_EXT 0x20D4
+#define GLX_MULTISAMPLE_SUB_RECT_HEIGHT_SGIS 0x8027
+#define GLX_TEXTURE_RECTANGLE_BIT_EXT 0x00000004
+#define GLX_AUX8_EXT 0x20EA
+#define GLX_EXCHANGE_COMPLETE_INTEL 0x8180
+#define GLX_CONTEXT_FLAGS_ARB 0x2094
+#define GLX_RGBA_FLOAT_TYPE_ARB 0x20B9
+#define GLX_CONTEXT_RESET_ISOLATION_BIT_ARB 0x00000008
+#define GLX_PBUFFER_CLOBBER_MASK 0x08000000
+#define GLX_FLIP_COMPLETE_INTEL 0x8182
+#define GLX_BAD_ENUM 7
+#define GLX_AUX3_EXT 0x20E5
+#define GLX_DONT_CARE 0xFFFFFFFF
+#define GLX_SAMPLE_BUFFERS_SGIS 100000
+#define GLX_SWAP_INTERVAL_EXT 0x20F1
+#define GLX_RENDERER_ID_MESA 0x818E
+#define GLX_STENCIL_SIZE 13
+#define GLX_FRONT_RIGHT_BUFFER_BIT_SGIX 0x00000002
+#define GLX_X_RENDERABLE 0x8012
+#define GLX_VENDOR 0x1
+#define GLX_ACCUM_BUFFER_BIT_SGIX 0x00000080
+#define GLX_UNIQUE_ID_NV 0x20CE
+#define GLX_WINDOW_BIT_SGIX 0x00000001
+#define GLX_LEVEL 3
+#define GLX_COLOR_SAMPLES_NV 0x20B3
+#define GLX_DIRECT_COLOR 0x8003
+#define GLX_TEXTURE_FORMAT_NONE_EXT 0x20D8
+#define GLX_BIND_TO_TEXTURE_RGB_EXT 0x20D0
+#define GLX_LOSE_CONTEXT_ON_RESET_ARB 0x8252
+#define GLX_VIDEO_OUT_ALPHA_NV 0x20C4
+#define GLX_PIXMAP_BIT_SGIX 0x00000002
+#define GLX_TRANSPARENT_BLUE_VALUE_EXT 0x27
+#define GLX_AUX6_EXT 0x20E8
+#define GLX_BufferSwapComplete 1
+#define GLX_COLOR_INDEX_BIT 0x00000002
+#define GLX_STENCIL_BUFFER_BIT 0x00000040
+#define GLX_MAX_PBUFFER_HEIGHT 0x8017
+#define GLX_ACCUM_BUFFER_BIT 0x00000080
+#define GLX_SWAP_METHOD_OML 0x8060
+#define GLX_EXTENSIONS 0x3
+#define GLX_NUM_VIDEO_SLOTS_NV 0x20F0
+#define GLX_CONTEXT_DEBUG_BIT_ARB 0x00000001
+#define GLX_SYNC_FRAME_SGIX 0x00000000
+#define GLX_VIDEO_OUT_STACKED_FIELDS_2_1_NV 0x20CC
+#define GLX_PBUFFER_WIDTH 0x8041
+#define GLX_BLUE_SIZE 10
+#define GLX_GRAY_SCALE 0x8006
+#define GLX_STEREO_NOTIFY_MASK_EXT 0x00000001
+#define GLX_AUX9_EXT 0x20EB
+#define GLX_VIDEO_OUT_COLOR_AND_ALPHA_NV 0x20C6
+#define GLX_EXTENSION_NAME "GLX"
+#define GLX_NON_CONFORMANT_VISUAL_EXT 0x800D
+#define GLX_VIDEO_OUT_FRAME_NV 0x20C8
+#define GLX_PBUFFER_BIT_SGIX 0x00000004
+#define GLX_AUX5_EXT 0x20E7
+#define GLX_HEIGHT 0x801E
+#define GLX_PBUFFER_HEIGHT 0x8040
+#define GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20B2
+#define GLX_TRANSPARENT_ALPHA_VALUE_EXT 0x28
+#define GLX_COLOR_INDEX_BIT_SGIX 0x00000002
+#define GLX_NO_RESET_NOTIFICATION_ARB 0x8261
+#define GLX_DOUBLEBUFFER 5
+#define GLX_SHARE_CONTEXT_EXT 0x800A
+#define GLX_X_RENDERABLE_SGIX 0x8012
+#define GLX_RENDERER_UNIFIED_MEMORY_ARCHITECTURE_MESA 0x8188
+#define GLX_DRAWABLE_TYPE 0x8010
+#define GLX_FRONT_LEFT_BUFFER_BIT 0x00000001
+#define GLX_SAMPLES 100001
+#define GLX_TEXTURE_RECTANGLE_EXT 0x20DD
+#define GLX_TRANSPARENT_RGB_EXT 0x8008
+#define GLX_SCREEN_EXT 0x800C
+#define GLX_STATIC_COLOR 0x8005
+#define GLX_RED_SIZE 8
+#define GLX_TRANSPARENT_RED_VALUE 0x25
+#define GLX_GREEN_SIZE 9
+#define GLX_HYPERPIPE_RENDER_PIPE_SGIX 0x00000002
+#define GLX_BACK_RIGHT_BUFFER_BIT 0x00000008
+#define GLX_BIND_TO_MIPMAP_TEXTURE_EXT 0x20D2
+#define GLX_GPU_NUM_SPI_AMD 0x21A8
+#define GLX_BUFFER_CLOBBER_MASK_SGIX 0x08000000
+#define GLX_COLOR_INDEX_TYPE_SGIX 0x8015
+#define GLX_TEXTURE_FORMAT_EXT 0x20D5
+#define GLX_RGBA_TYPE 0x8014
+#define GLX_RENDERER_VENDOR_ID_MESA 0x8183
+#define GLX_BAD_HYPERPIPE_SGIX 92
+#define GLX_TRANSPARENT_INDEX 0x8009
+#define GLX_BAD_ATTRIBUTE 2
+#define GLX_FRONT_RIGHT_EXT 0x20DF
+#define GLX_STATIC_GRAY 0x8007
+#define GLX_GENERATE_RESET_ON_VIDEO_MEMORY_PURGE_NV 0x20F7
+#define GLX_BACK_LEFT_BUFFER_BIT 0x00000004
+#define GLX_VISUAL_SELECT_GROUP_SGIX 0x8028
+#define GLX_FBCONFIG_ID_SGIX 0x8013
+#define GLX_GRAY_SCALE_EXT 0x8006
+#define GLX_TRANSPARENT_GREEN_VALUE_EXT 0x26
+#define GLX_GPU_RAM_AMD 0x21A3
+#define GLX_TEXTURE_1D_BIT_EXT 0x00000001
+#define GLX_FRONT_LEFT_BUFFER_BIT_SGIX 0x00000001
+#define GLX_RGBA_BIT_SGIX 0x00000001
+#define GLX_PIPE_RECT_SGIX 0x00000001
+#define GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB 0x00000004
+#define GLX_PIPE_RECT_LIMITS_SGIX 0x00000002
+#define GLX_PBUFFER_SGIX 0x8023
+#define GLX_AUX_BUFFERS 7
+#define GLX_TEXTURE_FORMAT_RGBA_EXT 0x20DA
+#define GLX_BAD_VALUE 6
+#define GLX_LARGEST_PBUFFER 0x801C
+#define GLX_AUX0_EXT 0x20E2
+#define GLX_BACK_LEFT_BUFFER_BIT_SGIX 0x00000004
+#define GLX_PSEUDO_COLOR_EXT 0x8004
+#define GLX_COLOR_INDEX_TYPE 0x8015
+#define GLX_SAVED_SGIX 0x8021
+#define GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT 0x20B1
+#define GLX_STENCIL_BUFFER_BIT_SGIX 0x00000040
+#define GLX_CONTEXT_MAJOR_VERSION_ARB 0x2091
+#define GLX_HYPERPIPE_PIXEL_AVERAGE_SGIX 0x00000004
+#define GLX_MIPMAP_TEXTURE_EXT 0x20D7
+#define GLX_ACCUM_ALPHA_SIZE 17
+#define GLX_TRANSPARENT_BLUE_VALUE 0x27
+#define GLX_WIDTH 0x801D
+#define GLX_AUX7_EXT 0x20E9
+#define GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX 0x801A
+#define GLX_STATIC_GRAY_EXT 0x8007
+#define GLX_MAX_PBUFFER_WIDTH 0x8016
+#define GLX_CONFIG_CAVEAT 0x20
+#define GLX_EVENT_MASK_SGIX 0x801F
+#define GLX_MAX_PBUFFER_HEIGHT_SGIX 0x8017
+#define GLX_TRANSPARENT_TYPE 0x23
+#define GLX_ALPHA_SIZE 11
+#define GLX_SAMPLE_BUFFERS 100000
+#define GLX_VISUAL_ID 0x800B
+#define GLX_LARGEST_PBUFFER_SGIX 0x801C
+#define GLX_SWAP_EXCHANGE_OML 0x8061
+#define GLX_WIDTH_SGIX 0x801D
+#define GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT 0x00000008
+#define GLX_SCREEN 0x800C
+#define GLX_CONTEXT_ALLOW_BUFFER_BYTE_ORDER_MISMATCH_ARB 0x2095
+#define GLX_ACCUM_RED_SIZE 14
+#define GLX_3DFX_FULLSCREEN_MODE_MESA 0x2
+#define GLX_BAD_SCREEN 1
+#define GLX_VISUAL_CAVEAT_EXT 0x20
+#define GLX_BACK_LEFT_EXT 0x20E0
+#define GLX_MAX_PBUFFER_PIXELS 0x8018
+#define GLX_AUX1_EXT 0x20E3
+#define GLX_CONTEXT_OPENGL_NO_ERROR_ARB 0x31B3
+#define GLX_SAMPLES_SGIS 100001
+#define GLX_TRUE_COLOR_EXT 0x8002
+#define GLX_DEPTH_BUFFER_BIT_SGIX 0x00000020
+#define GLX_RENDERER_OPENGL_COMPATIBILITY_PROFILE_VERSION_MESA 0x818B
+#define GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX 80
+#define GLX_BACK_EXT GLX_BACK_LEFT_EXT
+#define GLX_OPTIMAL_PBUFFER_WIDTH_SGIX 0x8019
+#define GLX_DAMAGED 0x8020
+#define GLX_NUM_VIDEO_CAPTURE_SLOTS_NV 0x20CF
+#define GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT 0x20B2
+#define GLX_LATE_SWAPS_TEAR_EXT 0x20F3
+#define GLX_FBCONFIG_ID 0x8013
+#define GLX_GPU_NUM_SIMD_AMD 0x21A6
+#define GLX_RGBA_BIT 0x00000001
+#define GLX_VERSION 0x2
+
+#ifndef GLEXT_64_TYPES_DEFINED
+/* This code block is duplicated in glext.h, so must be protected */
+#define GLEXT_64_TYPES_DEFINED
+/* Define int32_t, int64_t, and uint64_t types for UST/MSC */
+/* (as used in the GLX_OML_sync_control extension). */
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+#include <inttypes.h>
+#elif defined(__sun__) || defined(__digital__)
+#include <inttypes.h>
+#if defined(__STDC__)
+#if defined(__arch64__) || defined(_LP64)
+	typedef long int int64_t;
+	typedef unsigned long int uint64_t;
+#else
+	typedef long long int int64_t;
+	typedef unsigned long long int uint64_t;
+#endif /* __arch64__ */
+#endif /* __STDC__ */
+#elif defined(__VMS) || defined(__sgi)
+#include <inttypes.h>
+#elif defined(__SCO__) || defined(__USLC__)
+#include <stdint.h>
+#elif defined(__UNIXOS2__) || defined(__SOL64__)
+	typedef long int int32_t;
+	typedef long long int int64_t;
+	typedef unsigned long long int uint64_t;
+#elif defined(_WIN32) && defined(__GNUC__)
+#include <stdint.h>
+#elif defined(_WIN32)
+	typedef __int32 int32_t;
+	typedef __int64 int64_t;
+	typedef unsigned __int64 uint64_t;
+#else
+/* Fallback if nothing above works */
+#include <inttypes.h>
+#endif
+#endif
+
+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060)
+
+#else
+
+#endif
+
+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060)
+
+#else
+
+#endif
+
+	typedef XID GLXFBConfigID;
+	typedef struct __GLXFBConfigRec *GLXFBConfig;
+	typedef XID GLXContextID;
+	typedef struct __GLXcontextRec *GLXContext;
+	typedef XID GLXPixmap;
+	typedef XID GLXDrawable;
+	typedef XID GLXWindow;
+	typedef XID GLXPbuffer;
+	typedef void(GLAD_API_PTR *__GLXextFuncPtr)(void);
+	typedef XID GLXVideoCaptureDeviceNV;
+	typedef unsigned int GLXVideoDeviceNV;
+	typedef XID GLXVideoSourceSGIX;
+	typedef XID GLXFBConfigIDSGIX;
+	typedef struct __GLXFBConfigRec *GLXFBConfigSGIX;
+	typedef XID GLXPbufferSGIX;
+	typedef struct
+	{
+		int event_type;           /* GLX_DAMAGED or GLX_SAVED */
+		int draw_type;            /* GLX_WINDOW or GLX_PBUFFER */
+		unsigned long serial;     /* # of last request processed by server */
+		Bool send_event;          /* true if this came for SendEvent request */
+		Display *display;         /* display the event was read from */
+		GLXDrawable drawable;     /* XID of Drawable */
+		unsigned int buffer_mask; /* mask indicating which buffers are affected */
+		unsigned int aux_buffer;  /* which aux buffer was affected */
+		int x, y;
+		int width, height;
+		int count; /* if nonzero, at least this many more */
+	} GLXPbufferClobberEvent;
+	typedef struct
+	{
+		int type;
+		unsigned long serial; /* # of last request processed by server */
+		Bool send_event;      /* true if this came from a SendEvent request */
+		Display *display;     /* Display the event was read from */
+		GLXDrawable drawable; /* drawable on which event was requested in event mask */
+		int event_type;
+		int64_t ust;
+		int64_t msc;
+		int64_t sbc;
+	} GLXBufferSwapComplete;
+	typedef union __GLXEvent {
+		GLXPbufferClobberEvent glxpbufferclobber;
+		GLXBufferSwapComplete glxbufferswapcomplete;
+		long pad[24];
+	} GLXEvent;
+	typedef struct
+	{
+		int type;
+		unsigned long serial;
+		Bool send_event;
+		Display *display;
+		int extension;
+		int evtype;
+		GLXDrawable window;
+		Bool stereo_tree;
+	} GLXStereoNotifyEventEXT;
+	typedef struct
+	{
+		int type;
+		unsigned long serial; /* # of last request processed by server */
+		Bool send_event;      /* true if this came for SendEvent request */
+		Display *display;     /* display the event was read from */
+		GLXDrawable drawable; /* i.d. of Drawable */
+		int event_type;       /* GLX_DAMAGED_SGIX or GLX_SAVED_SGIX */
+		int draw_type;        /* GLX_WINDOW_SGIX or GLX_PBUFFER_SGIX */
+		unsigned int mask;    /* mask indicating which buffers are affected*/
+		int x, y;
+		int width, height;
+		int count; /* if nonzero, at least this many more */
+	} GLXBufferClobberEventSGIX;
+	typedef struct
+	{
+		char pipeName[80]; /* Should be [GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX] */
+		int networkId;
+	} GLXHyperpipeNetworkSGIX;
+	typedef struct
+	{
+		char pipeName[80]; /* Should be [GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX] */
+		int channel;
+		unsigned int participationType;
+		int timeSlice;
+	} GLXHyperpipeConfigSGIX;
+	typedef struct
+	{
+		char pipeName[80]; /* Should be [GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX] */
+		int srcXOrigin, srcYOrigin, srcWidth, srcHeight;
+		int destXOrigin, destYOrigin, destWidth, destHeight;
+	} GLXPipeRect;
+	typedef struct
+	{
+		char pipeName[80]; /* Should be [GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX] */
+		int XOrigin, YOrigin, maxHeight, maxWidth;
+	} GLXPipeRectLimits;
+
+#define GLX_VERSION_1_0 1
+	GLAD_API_CALL int GLAD_GLX_VERSION_1_0;
+#define GLX_VERSION_1_1 1
+	GLAD_API_CALL int GLAD_GLX_VERSION_1_1;
+#define GLX_VERSION_1_2 1
+	GLAD_API_CALL int GLAD_GLX_VERSION_1_2;
+#define GLX_VERSION_1_3 1
+	GLAD_API_CALL int GLAD_GLX_VERSION_1_3;
+#define GLX_VERSION_1_4 1
+	GLAD_API_CALL int GLAD_GLX_VERSION_1_4;
+#define GLX_MESA_copy_sub_buffer 1
+	GLAD_API_CALL int GLAD_GLX_MESA_copy_sub_buffer;
+#define GLX_EXT_create_context_es_profile 1
+	GLAD_API_CALL int GLAD_GLX_EXT_create_context_es_profile;
+#define GLX_SGIX_pbuffer 1
+	GLAD_API_CALL int GLAD_GLX_SGIX_pbuffer;
+#define GLX_SGI_make_current_read 1
+	GLAD_API_CALL int GLAD_GLX_SGI_make_current_read;
+#define GLX_OML_sync_control 1
+	GLAD_API_CALL int GLAD_GLX_OML_sync_control;
+#define GLX_SGIX_hyperpipe 1
+	GLAD_API_CALL int GLAD_GLX_SGIX_hyperpipe;
+#define GLX_INTEL_swap_event 1
+	GLAD_API_CALL int GLAD_GLX_INTEL_swap_event;
+#define GLX_EXT_swap_control 1
+	GLAD_API_CALL int GLAD_GLX_EXT_swap_control;
+#define GLX_NV_robustness_video_memory_purge 1
+	GLAD_API_CALL int GLAD_GLX_NV_robustness_video_memory_purge;
+#define GLX_MESA_pixmap_colormap 1
+	GLAD_API_CALL int GLAD_GLX_MESA_pixmap_colormap;
+#define GLX_ARB_fbconfig_float 1
+	GLAD_API_CALL int GLAD_GLX_ARB_fbconfig_float;
+#define GLX_EXT_fbconfig_packed_float 1
+	GLAD_API_CALL int GLAD_GLX_EXT_fbconfig_packed_float;
+#define GLX_OML_swap_method 1
+	GLAD_API_CALL int GLAD_GLX_OML_swap_method;
+#define GLX_NV_video_capture 1
+	GLAD_API_CALL int GLAD_GLX_NV_video_capture;
+#define GLX_ARB_robustness_application_isolation 1
+	GLAD_API_CALL int GLAD_GLX_ARB_robustness_application_isolation;
+#define GLX_ARB_create_context_robustness 1
+	GLAD_API_CALL int GLAD_GLX_ARB_create_context_robustness;
+#define GLX_EXT_visual_rating 1
+	GLAD_API_CALL int GLAD_GLX_EXT_visual_rating;
+#define GLX_NV_swap_group 1
+	GLAD_API_CALL int GLAD_GLX_NV_swap_group;
+#define GLX_EXT_texture_from_pixmap 1
+	GLAD_API_CALL int GLAD_GLX_EXT_texture_from_pixmap;
+#define GLX_SUN_get_transparent_index 1
+	GLAD_API_CALL int GLAD_GLX_SUN_get_transparent_index;
+#define GLX_MESA_release_buffers 1
+	GLAD_API_CALL int GLAD_GLX_MESA_release_buffers;
+#define GLX_NV_delay_before_swap 1
+	GLAD_API_CALL int GLAD_GLX_NV_delay_before_swap;
+#define GLX_EXT_buffer_age 1
+	GLAD_API_CALL int GLAD_GLX_EXT_buffer_age;
+#define GLX_MESA_agp_offset 1
+	GLAD_API_CALL int GLAD_GLX_MESA_agp_offset;
+#define GLX_EXT_visual_info 1
+	GLAD_API_CALL int GLAD_GLX_EXT_visual_info;
+#define GLX_SGI_swap_control 1
+	GLAD_API_CALL int GLAD_GLX_SGI_swap_control;
+#define GLX_EXT_import_context 1
+	GLAD_API_CALL int GLAD_GLX_EXT_import_context;
+#define GLX_SGI_video_sync 1
+	GLAD_API_CALL int GLAD_GLX_SGI_video_sync;
+#define GLX_3DFX_multisample 1
+	GLAD_API_CALL int GLAD_GLX_3DFX_multisample;
+#define GLX_ARB_multisample 1
+	GLAD_API_CALL int GLAD_GLX_ARB_multisample;
+#define GLX_EXT_framebuffer_sRGB 1
+	GLAD_API_CALL int GLAD_GLX_EXT_framebuffer_sRGB;
+#define GLX_SGI_cushion 1
+	GLAD_API_CALL int GLAD_GLX_SGI_cushion;
+#define GLX_ARB_robustness_share_group_isolation 1
+	GLAD_API_CALL int GLAD_GLX_ARB_robustness_share_group_isolation;
+#define GLX_SGIX_fbconfig 1
+	GLAD_API_CALL int GLAD_GLX_SGIX_fbconfig;
+#define GLX_NV_copy_buffer 1
+	GLAD_API_CALL int GLAD_GLX_NV_copy_buffer;
+#define GLX_SGIX_visual_select_group 1
+	GLAD_API_CALL int GLAD_GLX_SGIX_visual_select_group;
+#define GLX_EXT_swap_control_tear 1
+	GLAD_API_CALL int GLAD_GLX_EXT_swap_control_tear;
+#define GLX_ARB_create_context 1
+	GLAD_API_CALL int GLAD_GLX_ARB_create_context;
+#define GLX_AMD_gpu_association 1
+	GLAD_API_CALL int GLAD_GLX_AMD_gpu_association;
+#define GLX_MESA_query_renderer 1
+	GLAD_API_CALL int GLAD_GLX_MESA_query_renderer;
+#define GLX_EXT_create_context_es2_profile 1
+	GLAD_API_CALL int GLAD_GLX_EXT_create_context_es2_profile;
+#define GLX_MESA_swap_control 1
+	GLAD_API_CALL int GLAD_GLX_MESA_swap_control;
+#define GLX_SGIX_video_resize 1
+	GLAD_API_CALL int GLAD_GLX_SGIX_video_resize;
+#define GLX_ARB_context_flush_control 1
+	GLAD_API_CALL int GLAD_GLX_ARB_context_flush_control;
+#define GLX_NV_video_out 1
+	GLAD_API_CALL int GLAD_GLX_NV_video_out;
+#define GLX_EXT_no_config_context 1
+	GLAD_API_CALL int GLAD_GLX_EXT_no_config_context;
+#define GLX_SGIS_blended_overlay 1
+	GLAD_API_CALL int GLAD_GLX_SGIS_blended_overlay;
+#define GLX_EXT_stereo_tree 1
+	GLAD_API_CALL int GLAD_GLX_EXT_stereo_tree;
+#define GLX_ARB_create_context_no_error 1
+	GLAD_API_CALL int GLAD_GLX_ARB_create_context_no_error;
+#define GLX_EXT_libglvnd 1
+	GLAD_API_CALL int GLAD_GLX_EXT_libglvnd;
+#define GLX_ARB_create_context_profile 1
+	GLAD_API_CALL int GLAD_GLX_ARB_create_context_profile;
+#define GLX_NV_float_buffer 1
+	GLAD_API_CALL int GLAD_GLX_NV_float_buffer;
+#define GLX_MESA_set_3dfx_mode 1
+	GLAD_API_CALL int GLAD_GLX_MESA_set_3dfx_mode;
+#define GLX_ARB_framebuffer_sRGB 1
+	GLAD_API_CALL int GLAD_GLX_ARB_framebuffer_sRGB;
+#define GLX_ARB_get_proc_address 1
+	GLAD_API_CALL int GLAD_GLX_ARB_get_proc_address;
+#define GLX_SGIS_shared_multisample 1
+	GLAD_API_CALL int GLAD_GLX_SGIS_shared_multisample;
+#define GLX_NV_copy_image 1
+	GLAD_API_CALL int GLAD_GLX_NV_copy_image;
+#define GLX_NV_present_video 1
+	GLAD_API_CALL int GLAD_GLX_NV_present_video;
+#define GLX_SGIX_swap_barrier 1
+	GLAD_API_CALL int GLAD_GLX_SGIX_swap_barrier;
+#define GLX_SGIS_multisample 1
+	GLAD_API_CALL int GLAD_GLX_SGIS_multisample;
+#define GLX_SGIX_swap_group 1
+	GLAD_API_CALL int GLAD_GLX_SGIX_swap_group;
+#define GLX_ARB_vertex_buffer_object 1
+	GLAD_API_CALL int GLAD_GLX_ARB_vertex_buffer_object;
+#define GLX_NV_multisample_coverage 1
+	GLAD_API_CALL int GLAD_GLX_NV_multisample_coverage;
+
+	typedef void(GLAD_API_PTR *PFNGLXCUSHIONSGIPROC)(Display *dpy, Window window, float cushion);
+	typedef void(GLAD_API_PTR *PFNGLXDESTROYGLXPBUFFERSGIXPROC)(Display *dpy, GLXPbufferSGIX pbuf);
+	typedef int(GLAD_API_PTR *PFNGLXSENDPBUFFERTOVIDEONVPROC)(Display *dpy, GLXPbuffer pbuf, int iBufferType, unsigned long *pulCounterPbuffer, GLboolean bBlock);
+	typedef __GLXextFuncPtr(GLAD_API_PTR *PFNGLXGETPROCADDRESSARBPROC)(const GLubyte *procName);
+	typedef GLXContext(GLAD_API_PTR *PFNGLXCREATECONTEXTATTRIBSARBPROC)(Display *dpy, GLXFBConfig config, GLXContext share_context, Bool direct, const int *attrib_list);
+	typedef void(GLAD_API_PTR *PFNGLXJOINSWAPGROUPSGIXPROC)(Display *dpy, GLXDrawable drawable, GLXDrawable member);
+	typedef void(GLAD_API_PTR *PFNGLXSWAPINTERVALEXTPROC)(Display *dpy, GLXDrawable drawable, int interval);
+	typedef GLXHyperpipeConfigSGIX *(GLAD_API_PTR *PFNGLXQUERYHYPERPIPECONFIGSGIXPROC)(Display *dpy, int hpId, int *npipes);
+	typedef int(GLAD_API_PTR *PFNGLXGETGPUINFOAMDPROC)(unsigned int id, int property, GLenum dataType, unsigned int size, void *data);
+	typedef Status(GLAD_API_PTR *PFNGLXGETTRANSPARENTINDEXSUNPROC)(Display *dpy, Window overlay, Window underlay, long *pTransparentIndex);
+	typedef GLXHyperpipeNetworkSGIX *(GLAD_API_PTR *PFNGLXQUERYHYPERPIPENETWORKSGIXPROC)(Display *dpy, int *npipes);
+	typedef int(GLAD_API_PTR *PFNGLXQUERYGLXPBUFFERSGIXPROC)(Display *dpy, GLXPbufferSGIX pbuf, int attribute, unsigned int *value);
+	typedef GLXPixmap(GLAD_API_PTR *PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC)(Display *dpy, GLXFBConfigSGIX config, Pixmap pixmap);
+	typedef void(GLAD_API_PTR *PFNGLXCOPYCONTEXTPROC)(Display *dpy, GLXContext src, GLXContext dst, unsigned long mask);
+	typedef GLXPbufferSGIX(GLAD_API_PTR *PFNGLXCREATEGLXPBUFFERSGIXPROC)(Display *dpy, GLXFBConfigSGIX config, unsigned int width, unsigned int height, int *attrib_list);
+	typedef unsigned int(GLAD_API_PTR *PFNGLXGETGPUIDSAMDPROC)(unsigned int maxCount, unsigned int *ids);
+	typedef Bool(GLAD_API_PTR *PFNGLXDELETEASSOCIATEDCONTEXTAMDPROC)(GLXContext ctx);
+	typedef int(GLAD_API_PTR *PFNGLXGETVIDEODEVICENVPROC)(Display *dpy, int screen, int numVideoDevices, GLXVideoDeviceNV *pVideoDevice);
+	typedef void(GLAD_API_PTR *PFNGLXWAITGLPROC)(void);
+	typedef int(GLAD_API_PTR *PFNGLXGETVIDEOSYNCSGIPROC)(unsigned int *count);
+	typedef int(GLAD_API_PTR *PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC)(Display *dpy, int hpId);
+	typedef int(GLAD_API_PTR *PFNGLXHYPERPIPECONFIGSGIXPROC)(Display *dpy, int networkId, int npipes, GLXHyperpipeConfigSGIX *cfg, int *hpId);
+	typedef int64_t(GLAD_API_PTR *PFNGLXSWAPBUFFERSMSCOMLPROC)(Display *dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder);
+	typedef GLXFBConfigSGIX *(GLAD_API_PTR *PFNGLXCHOOSEFBCONFIGSGIXPROC)(Display *dpy, int screen, int *attrib_list, int *nelements);
+	typedef int(GLAD_API_PTR *PFNGLXWAITVIDEOSYNCSGIPROC)(int divisor, int remainder, unsigned int *count);
+	typedef Bool(GLAD_API_PTR *PFNGLXWAITFORSBCOMLPROC)(Display *dpy, GLXDrawable drawable, int64_t target_sbc, int64_t *ust, int64_t *msc, int64_t *sbc);
+	typedef __GLXextFuncPtr(GLAD_API_PTR *PFNGLXGETPROCADDRESSPROC)(const GLubyte *procName);
+	typedef int(GLAD_API_PTR *PFNGLXGETSWAPINTERVALMESAPROC)(void);
+	typedef int(GLAD_API_PTR *PFNGLXCHANNELRECTSGIXPROC)(Display *display, int screen, int channel, int x, int y, int w, int h);
+	typedef void(GLAD_API_PTR *PFNGLXWAITXPROC)(void);
+	typedef const char *(GLAD_API_PTR *PFNGLXQUERYSERVERSTRINGPROC)(Display *dpy, int screen, int name);
+	typedef GLXPixmap(GLAD_API_PTR *PFNGLXCREATEGLXPIXMAPPROC)(Display *dpy, XVisualInfo *visual, Pixmap pixmap);
+	typedef Bool(GLAD_API_PTR *PFNGLXBINDSWAPBARRIERNVPROC)(Display *dpy, GLuint group, GLuint barrier);
+	typedef const char *(GLAD_API_PTR *PFNGLXQUERYRENDERERSTRINGMESAPROC)(Display *dpy, int screen, int renderer, int attribute);
+	typedef void(GLAD_API_PTR *PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC)(Display *dpy, GLXVideoCaptureDeviceNV device);
+	typedef Bool(GLAD_API_PTR *PFNGLXWAITFORMSCOMLPROC)(Display *dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder, int64_t *ust, int64_t *msc, int64_t *sbc);
+	typedef void(GLAD_API_PTR *PFNGLXCOPYSUBBUFFERMESAPROC)(Display *dpy, GLXDrawable drawable, int x, int y, int width, int height);
+	typedef GLXContext(GLAD_API_PTR *PFNGLXGETCURRENTCONTEXTPROC)(void);
+	typedef void(GLAD_API_PTR *PFNGLXSELECTEVENTPROC)(Display *dpy, GLXDrawable draw, unsigned long event_mask);
+	typedef int(GLAD_API_PTR *PFNGLXSWAPINTERVALSGIPROC)(int interval);
+	typedef Bool(GLAD_API_PTR *PFNGLXQUERYSWAPGROUPNVPROC)(Display *dpy, GLXDrawable drawable, GLuint *group, GLuint *barrier);
+	typedef Bool(GLAD_API_PTR *PFNGLXMAKECURRENTREADSGIPROC)(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
+	typedef void(GLAD_API_PTR *PFNGLXQUERYDRAWABLEPROC)(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value);
+	typedef void(GLAD_API_PTR *PFNGLXCOPYBUFFERSUBDATANVPROC)(Display *dpy, GLXContext readCtx, GLXContext writeCtx, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
+	typedef int(GLAD_API_PTR *PFNGLXQUERYCONTEXTPROC)(Display *dpy, GLXContext ctx, int attribute, int *value);
+	typedef int(GLAD_API_PTR *PFNGLXGETCONFIGPROC)(Display *dpy, XVisualInfo *visual, int attrib, int *value);
+	typedef Bool(GLAD_API_PTR *PFNGLXSET3DFXMODEMESAPROC)(int mode);
+	typedef int(GLAD_API_PTR *PFNGLXGETVIDEOINFONVPROC)(Display *dpy, int screen, GLXVideoDeviceNV VideoDevice, unsigned long *pulCounterOutputPbuffer, unsigned long *pulCounterOutputVideo);
+	typedef Bool(GLAD_API_PTR *PFNGLXISDIRECTPROC)(Display *dpy, GLXContext ctx);
+	typedef int(GLAD_API_PTR *PFNGLXGETFBCONFIGATTRIBPROC)(Display *dpy, GLXFBConfig config, int attribute, int *value);
+	typedef XVisualInfo *(GLAD_API_PTR *PFNGLXGETVISUALFROMFBCONFIGPROC)(Display *dpy, GLXFBConfig config);
+	typedef void(GLAD_API_PTR *PFNGLXBINDTEXIMAGEEXTPROC)(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list);
+	typedef void(GLAD_API_PTR *PFNGLXBLITCONTEXTFRAMEBUFFERAMDPROC)(GLXContext dstCtx, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+	typedef Bool(GLAD_API_PTR *PFNGLXQUERYVERSIONPROC)(Display *dpy, int *maj, int *min);
+	typedef void(GLAD_API_PTR *PFNGLXSELECTEVENTSGIXPROC)(Display *dpy, GLXDrawable drawable, unsigned long mask);
+	typedef Bool(GLAD_API_PTR *PFNGLXGETMSCRATEOMLPROC)(Display *dpy, GLXDrawable drawable, int32_t *numerator, int32_t *denominator);
+	typedef Bool(GLAD_API_PTR *PFNGLXQUERYRENDERERINTEGERMESAPROC)(Display *dpy, int screen, int renderer, int attribute, unsigned int *value);
+	typedef GLXWindow(GLAD_API_PTR *PFNGLXCREATEWINDOWPROC)(Display *dpy, GLXFBConfig config, Window win, const int *attrib_list);
+	typedef void(GLAD_API_PTR *PFNGLXCOPYIMAGESUBDATANVPROC)(Display *dpy, GLXContext srcCtx, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLXContext dstCtx, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth);
+	typedef int(GLAD_API_PTR *PFNGLXSWAPINTERVALMESAPROC)(unsigned int interval);
+	typedef int(GLAD_API_PTR *PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC)(Display *dpy, int timeSlice, int attrib, int size, void *returnAttribList);
+	typedef int(GLAD_API_PTR *PFNGLXBINDVIDEOCAPTUREDEVICENVPROC)(Display *dpy, unsigned int video_capture_slot, GLXVideoCaptureDeviceNV device);
+	typedef GLXContext(GLAD_API_PTR *PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC)(Display *dpy, GLXFBConfigSGIX config, int render_type, GLXContext share_list, Bool direct);
+	typedef unsigned int *(GLAD_API_PTR *PFNGLXENUMERATEVIDEODEVICESNVPROC)(Display *dpy, int screen, int *nelements);
+	typedef int(GLAD_API_PTR *PFNGLXHYPERPIPEATTRIBSGIXPROC)(Display *dpy, int timeSlice, int attrib, int size, void *attribList);
+	typedef void(GLAD_API_PTR *PFNGLXDESTROYPBUFFERPROC)(Display *dpy, GLXPbuffer pbuf);
+	typedef void(GLAD_API_PTR *PFNGLXNAMEDCOPYBUFFERSUBDATANVPROC)(Display *dpy, GLXContext readCtx, GLXContext writeCtx, GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
+	typedef GLXPbuffer(GLAD_API_PTR *PFNGLXCREATEPBUFFERPROC)(Display *dpy, GLXFBConfig config, const int *attrib_list);
+	typedef const char *(GLAD_API_PTR *PFNGLXQUERYCURRENTRENDERERSTRINGMESAPROC)(int attribute);
+	typedef int(GLAD_API_PTR *PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC)(Display *dpy, int timeSlice, int attrib, int size, void *attribList, void *returnAttribList);
+	typedef int(GLAD_API_PTR *PFNGLXGETFBCONFIGATTRIBSGIXPROC)(Display *dpy, GLXFBConfigSGIX config, int attribute, int *value);
+	typedef const char *(GLAD_API_PTR *PFNGLXQUERYEXTENSIONSSTRINGPROC)(Display *dpy, int screen);
+	typedef int(GLAD_API_PTR *PFNGLXBINDVIDEODEVICENVPROC)(Display *dpy, unsigned int video_slot, unsigned int video_device, const int *attrib_list);
+	typedef GLXContext(GLAD_API_PTR *PFNGLXCREATEASSOCIATEDCONTEXTAMDPROC)(unsigned int id, GLXContext share_list);
+	typedef int(GLAD_API_PTR *PFNGLXQUERYCONTEXTINFOEXTPROC)(Display *dpy, GLXContext context, int attribute, int *value);
+	typedef void(GLAD_API_PTR *PFNGLXGETSELECTEDEVENTPROC)(Display *dpy, GLXDrawable draw, unsigned long *event_mask);
+	typedef Display *(GLAD_API_PTR *PFNGLXGETCURRENTDISPLAYPROC)(void);
+	typedef void(GLAD_API_PTR *PFNGLXDESTROYPIXMAPPROC)(Display *dpy, GLXPixmap pixmap);
+	typedef void(GLAD_API_PTR *PFNGLXGETSELECTEDEVENTSGIXPROC)(Display *dpy, GLXDrawable drawable, unsigned long *mask);
+	typedef void(GLAD_API_PTR *PFNGLXRELEASETEXIMAGEEXTPROC)(Display *dpy, GLXDrawable drawable, int buffer);
+	typedef void(GLAD_API_PTR *PFNGLXUSEXFONTPROC)(Font font, int first, int count, int list);
+	typedef Bool(GLAD_API_PTR *PFNGLXGETSYNCVALUESOMLPROC)(Display *dpy, GLXDrawable drawable, int64_t *ust, int64_t *msc, int64_t *sbc);
+	typedef Bool(GLAD_API_PTR *PFNGLXJOINSWAPGROUPNVPROC)(Display *dpy, GLXDrawable drawable, GLuint group);
+	typedef void(GLAD_API_PTR *PFNGLXSWAPBUFFERSPROC)(Display *dpy, GLXDrawable drawable);
+	typedef Bool(GLAD_API_PTR *PFNGLXDELAYBEFORESWAPNVPROC)(Display *dpy, GLXDrawable drawable, GLfloat seconds);
+	typedef int(GLAD_API_PTR *PFNGLXBINDHYPERPIPESGIXPROC)(Display *dpy, int hpId);
+	typedef void(GLAD_API_PTR *PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC)(Display *dpy, GLXVideoCaptureDeviceNV device);
+	typedef Display *(GLAD_API_PTR *PFNGLXGETCURRENTDISPLAYEXTPROC)(void);
+	typedef GLXFBConfig *(GLAD_API_PTR *PFNGLXGETFBCONFIGSPROC)(Display *dpy, int screen, int *nelements);
+	typedef GLXDrawable(GLAD_API_PTR *PFNGLXGETCURRENTREADDRAWABLEPROC)(void);
+	typedef int(GLAD_API_PTR *PFNGLXRELEASEVIDEOIMAGENVPROC)(Display *dpy, GLXPbuffer pbuf);
+	typedef Bool(GLAD_API_PTR *PFNGLXQUERYEXTENSIONPROC)(Display *dpy, int *errorb, int *event);
+	typedef Bool(GLAD_API_PTR *PFNGLXMAKEASSOCIATEDCONTEXTCURRENTAMDPROC)(GLXContext ctx);
+	typedef XVisualInfo *(GLAD_API_PTR *PFNGLXCHOOSEVISUALPROC)(Display *dpy, int screen, int *attribList);
+	typedef void(GLAD_API_PTR *PFNGLXDESTROYCONTEXTPROC)(Display *dpy, GLXContext ctx);
+	typedef const char *(GLAD_API_PTR *PFNGLXGETCLIENTSTRINGPROC)(Display *dpy, int name);
+	typedef void(GLAD_API_PTR *PFNGLXDESTROYGLXPIXMAPPROC)(Display *dpy, GLXPixmap pixmap);
+	typedef Bool(GLAD_API_PTR *PFNGLXRESETFRAMECOUNTNVPROC)(Display *dpy, int screen);
+	typedef int(GLAD_API_PTR *PFNGLXRELEASEVIDEODEVICENVPROC)(Display *dpy, int screen, GLXVideoDeviceNV VideoDevice);
+	typedef GLXFBConfigSGIX(GLAD_API_PTR *PFNGLXGETFBCONFIGFROMVISUALSGIXPROC)(Display *dpy, XVisualInfo *vis);
+	typedef GLXContext(GLAD_API_PTR *PFNGLXCREATENEWCONTEXTPROC)(Display *dpy, GLXFBConfig config, int render_type, GLXContext share_list, Bool direct);
+	typedef Bool(GLAD_API_PTR *PFNGLXMAKECONTEXTCURRENTPROC)(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
+	typedef Bool(GLAD_API_PTR *PFNGLXQUERYMAXSWAPGROUPSNVPROC)(Display *dpy, int screen, GLuint *maxGroups, GLuint *maxBarriers);
+	typedef XVisualInfo *(GLAD_API_PTR *PFNGLXGETVISUALFROMFBCONFIGSGIXPROC)(Display *dpy, GLXFBConfigSGIX config);
+	typedef GLXDrawable(GLAD_API_PTR *PFNGLXGETCURRENTDRAWABLEPROC)(void);
+	typedef GLXDrawable(GLAD_API_PTR *PFNGLXGETCURRENTREADDRAWABLESGIPROC)(void);
+	typedef Bool(GLAD_API_PTR *PFNGLXQUERYFRAMECOUNTNVPROC)(Display *dpy, int screen, GLuint *count);
+	typedef unsigned int(GLAD_API_PTR *PFNGLXGETCONTEXTGPUIDAMDPROC)(GLXContext ctx);
+	typedef void(GLAD_API_PTR *PFNGLXBINDSWAPBARRIERSGIXPROC)(Display *dpy, GLXDrawable drawable, int barrier);
+	typedef Bool(GLAD_API_PTR *PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC)(Display *dpy, int screen, int *max);
+	typedef GLXPixmap(GLAD_API_PTR *PFNGLXCREATEGLXPIXMAPMESAPROC)(Display *dpy, XVisualInfo *visual, Pixmap pixmap, Colormap cmap);
+	typedef Bool(GLAD_API_PTR *PFNGLXMAKECURRENTPROC)(Display *dpy, GLXDrawable drawable, GLXContext ctx);
+	typedef void(GLAD_API_PTR *PFNGLXDESTROYWINDOWPROC)(Display *dpy, GLXWindow win);
+	typedef int(GLAD_API_PTR *PFNGLXBINDVIDEOIMAGENVPROC)(Display *dpy, GLXVideoDeviceNV VideoDevice, GLXPbuffer pbuf, int iVideoBuffer);
+	typedef int(GLAD_API_PTR *PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC)(Display *dpy, GLXVideoCaptureDeviceNV device, int attribute, int *value);
+	typedef int(GLAD_API_PTR *PFNGLXQUERYCHANNELDELTASSGIXPROC)(Display *display, int screen, int channel, int *x, int *y, int *w, int *h);
+	typedef GLXVideoCaptureDeviceNV *(GLAD_API_PTR *PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC)(Display *dpy, int screen, int *nelements);
+	typedef GLXContext(GLAD_API_PTR *PFNGLXCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC)(unsigned int id, GLXContext share_context, const int *attribList);
+	typedef GLXContext(GLAD_API_PTR *PFNGLXGETCURRENTASSOCIATEDCONTEXTAMDPROC)(void);
+	typedef int(GLAD_API_PTR *PFNGLXQUERYCHANNELRECTSGIXPROC)(Display *display, int screen, int channel, int *dx, int *dy, int *dw, int *dh);
+	typedef GLXContext(GLAD_API_PTR *PFNGLXCREATECONTEXTPROC)(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct);
+	typedef void(GLAD_API_PTR *PFNGLXFREECONTEXTEXTPROC)(Display *dpy, GLXContext context);
+	typedef GLXContextID(GLAD_API_PTR *PFNGLXGETCONTEXTIDEXTPROC)(const GLXContext context);
+	typedef Bool(GLAD_API_PTR *PFNGLXQUERYCURRENTRENDERERINTEGERMESAPROC)(int attribute, unsigned int *value);
+	typedef GLXFBConfig *(GLAD_API_PTR *PFNGLXCHOOSEFBCONFIGPROC)(Display *dpy, int screen, const int *attrib_list, int *nelements);
+	typedef int(GLAD_API_PTR *PFNGLXBINDCHANNELTOWINDOWSGIXPROC)(Display *display, int screen, int channel, Window window);
+	typedef int(GLAD_API_PTR *PFNGLXCHANNELRECTSYNCSGIXPROC)(Display *display, int screen, int channel, GLenum synctype);
+	typedef GLXContext(GLAD_API_PTR *PFNGLXIMPORTCONTEXTEXTPROC)(Display *dpy, GLXContextID contextID);
+	typedef Bool(GLAD_API_PTR *PFNGLXRELEASEBUFFERSMESAPROC)(Display *dpy, GLXDrawable drawable);
+	typedef GLXPixmap(GLAD_API_PTR *PFNGLXCREATEPIXMAPPROC)(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attrib_list);
+	typedef unsigned int(GLAD_API_PTR *PFNGLXGETAGPOFFSETMESAPROC)(const void *pointer);
+
+	GLAD_API_CALL PFNGLXCUSHIONSGIPROC glad_glXCushionSGI;
+#define glXCushionSGI glad_glXCushionSGI
+	GLAD_API_CALL PFNGLXDESTROYGLXPBUFFERSGIXPROC glad_glXDestroyGLXPbufferSGIX;
+#define glXDestroyGLXPbufferSGIX glad_glXDestroyGLXPbufferSGIX
+	GLAD_API_CALL PFNGLXSENDPBUFFERTOVIDEONVPROC glad_glXSendPbufferToVideoNV;
+#define glXSendPbufferToVideoNV glad_glXSendPbufferToVideoNV
+	GLAD_API_CALL PFNGLXGETPROCADDRESSARBPROC glad_glXGetProcAddressARB;
+#define glXGetProcAddressARB glad_glXGetProcAddressARB
+	GLAD_API_CALL PFNGLXCREATECONTEXTATTRIBSARBPROC glad_glXCreateContextAttribsARB;
+#define glXCreateContextAttribsARB glad_glXCreateContextAttribsARB
+	GLAD_API_CALL PFNGLXJOINSWAPGROUPSGIXPROC glad_glXJoinSwapGroupSGIX;
+#define glXJoinSwapGroupSGIX glad_glXJoinSwapGroupSGIX
+	GLAD_API_CALL PFNGLXSWAPINTERVALEXTPROC glad_glXSwapIntervalEXT;
+#define glXSwapIntervalEXT glad_glXSwapIntervalEXT
+	GLAD_API_CALL PFNGLXQUERYHYPERPIPECONFIGSGIXPROC glad_glXQueryHyperpipeConfigSGIX;
+#define glXQueryHyperpipeConfigSGIX glad_glXQueryHyperpipeConfigSGIX
+	GLAD_API_CALL PFNGLXGETGPUINFOAMDPROC glad_glXGetGPUInfoAMD;
+#define glXGetGPUInfoAMD glad_glXGetGPUInfoAMD
+	GLAD_API_CALL PFNGLXGETTRANSPARENTINDEXSUNPROC glad_glXGetTransparentIndexSUN;
+#define glXGetTransparentIndexSUN glad_glXGetTransparentIndexSUN
+	GLAD_API_CALL PFNGLXQUERYHYPERPIPENETWORKSGIXPROC glad_glXQueryHyperpipeNetworkSGIX;
+#define glXQueryHyperpipeNetworkSGIX glad_glXQueryHyperpipeNetworkSGIX
+	GLAD_API_CALL PFNGLXQUERYGLXPBUFFERSGIXPROC glad_glXQueryGLXPbufferSGIX;
+#define glXQueryGLXPbufferSGIX glad_glXQueryGLXPbufferSGIX
+	GLAD_API_CALL PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC glad_glXCreateGLXPixmapWithConfigSGIX;
+#define glXCreateGLXPixmapWithConfigSGIX glad_glXCreateGLXPixmapWithConfigSGIX
+	GLAD_API_CALL PFNGLXCOPYCONTEXTPROC glad_glXCopyContext;
+#define glXCopyContext glad_glXCopyContext
+	GLAD_API_CALL PFNGLXCREATEGLXPBUFFERSGIXPROC glad_glXCreateGLXPbufferSGIX;
+#define glXCreateGLXPbufferSGIX glad_glXCreateGLXPbufferSGIX
+	GLAD_API_CALL PFNGLXGETGPUIDSAMDPROC glad_glXGetGPUIDsAMD;
+#define glXGetGPUIDsAMD glad_glXGetGPUIDsAMD
+	GLAD_API_CALL PFNGLXDELETEASSOCIATEDCONTEXTAMDPROC glad_glXDeleteAssociatedContextAMD;
+#define glXDeleteAssociatedContextAMD glad_glXDeleteAssociatedContextAMD
+	GLAD_API_CALL PFNGLXGETVIDEODEVICENVPROC glad_glXGetVideoDeviceNV;
+#define glXGetVideoDeviceNV glad_glXGetVideoDeviceNV
+	GLAD_API_CALL PFNGLXWAITGLPROC glad_glXWaitGL;
+#define glXWaitGL glad_glXWaitGL
+	GLAD_API_CALL PFNGLXGETVIDEOSYNCSGIPROC glad_glXGetVideoSyncSGI;
+#define glXGetVideoSyncSGI glad_glXGetVideoSyncSGI
+	GLAD_API_CALL PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC glad_glXDestroyHyperpipeConfigSGIX;
+#define glXDestroyHyperpipeConfigSGIX glad_glXDestroyHyperpipeConfigSGIX
+	GLAD_API_CALL PFNGLXHYPERPIPECONFIGSGIXPROC glad_glXHyperpipeConfigSGIX;
+#define glXHyperpipeConfigSGIX glad_glXHyperpipeConfigSGIX
+	GLAD_API_CALL PFNGLXSWAPBUFFERSMSCOMLPROC glad_glXSwapBuffersMscOML;
+#define glXSwapBuffersMscOML glad_glXSwapBuffersMscOML
+	GLAD_API_CALL PFNGLXCHOOSEFBCONFIGSGIXPROC glad_glXChooseFBConfigSGIX;
+#define glXChooseFBConfigSGIX glad_glXChooseFBConfigSGIX
+	GLAD_API_CALL PFNGLXWAITVIDEOSYNCSGIPROC glad_glXWaitVideoSyncSGI;
+#define glXWaitVideoSyncSGI glad_glXWaitVideoSyncSGI
+	GLAD_API_CALL PFNGLXWAITFORSBCOMLPROC glad_glXWaitForSbcOML;
+#define glXWaitForSbcOML glad_glXWaitForSbcOML
+	GLAD_API_CALL PFNGLXGETPROCADDRESSPROC glad_glXGetProcAddress;
+#define glXGetProcAddress glad_glXGetProcAddress
+	GLAD_API_CALL PFNGLXGETSWAPINTERVALMESAPROC glad_glXGetSwapIntervalMESA;
+#define glXGetSwapIntervalMESA glad_glXGetSwapIntervalMESA
+	GLAD_API_CALL PFNGLXCHANNELRECTSGIXPROC glad_glXChannelRectSGIX;
+#define glXChannelRectSGIX glad_glXChannelRectSGIX
+	GLAD_API_CALL PFNGLXWAITXPROC glad_glXWaitX;
+#define glXWaitX glad_glXWaitX
+	GLAD_API_CALL PFNGLXQUERYSERVERSTRINGPROC glad_glXQueryServerString;
+#define glXQueryServerString glad_glXQueryServerString
+	GLAD_API_CALL PFNGLXCREATEGLXPIXMAPPROC glad_glXCreateGLXPixmap;
+#define glXCreateGLXPixmap glad_glXCreateGLXPixmap
+	GLAD_API_CALL PFNGLXBINDSWAPBARRIERNVPROC glad_glXBindSwapBarrierNV;
+#define glXBindSwapBarrierNV glad_glXBindSwapBarrierNV
+	GLAD_API_CALL PFNGLXQUERYRENDERERSTRINGMESAPROC glad_glXQueryRendererStringMESA;
+#define glXQueryRendererStringMESA glad_glXQueryRendererStringMESA
+	GLAD_API_CALL PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC glad_glXReleaseVideoCaptureDeviceNV;
+#define glXReleaseVideoCaptureDeviceNV glad_glXReleaseVideoCaptureDeviceNV
+	GLAD_API_CALL PFNGLXWAITFORMSCOMLPROC glad_glXWaitForMscOML;
+#define glXWaitForMscOML glad_glXWaitForMscOML
+	GLAD_API_CALL PFNGLXCOPYSUBBUFFERMESAPROC glad_glXCopySubBufferMESA;
+#define glXCopySubBufferMESA glad_glXCopySubBufferMESA
+	GLAD_API_CALL PFNGLXGETCURRENTCONTEXTPROC glad_glXGetCurrentContext;
+#define glXGetCurrentContext glad_glXGetCurrentContext
+	GLAD_API_CALL PFNGLXSELECTEVENTPROC glad_glXSelectEvent;
+#define glXSelectEvent glad_glXSelectEvent
+	GLAD_API_CALL PFNGLXSWAPINTERVALSGIPROC glad_glXSwapIntervalSGI;
+#define glXSwapIntervalSGI glad_glXSwapIntervalSGI
+	GLAD_API_CALL PFNGLXQUERYSWAPGROUPNVPROC glad_glXQuerySwapGroupNV;
+#define glXQuerySwapGroupNV glad_glXQuerySwapGroupNV
+	GLAD_API_CALL PFNGLXMAKECURRENTREADSGIPROC glad_glXMakeCurrentReadSGI;
+#define glXMakeCurrentReadSGI glad_glXMakeCurrentReadSGI
+	GLAD_API_CALL PFNGLXQUERYDRAWABLEPROC glad_glXQueryDrawable;
+#define glXQueryDrawable glad_glXQueryDrawable
+	GLAD_API_CALL PFNGLXCOPYBUFFERSUBDATANVPROC glad_glXCopyBufferSubDataNV;
+#define glXCopyBufferSubDataNV glad_glXCopyBufferSubDataNV
+	GLAD_API_CALL PFNGLXQUERYCONTEXTPROC glad_glXQueryContext;
+#define glXQueryContext glad_glXQueryContext
+	GLAD_API_CALL PFNGLXGETCONFIGPROC glad_glXGetConfig;
+#define glXGetConfig glad_glXGetConfig
+	GLAD_API_CALL PFNGLXSET3DFXMODEMESAPROC glad_glXSet3DfxModeMESA;
+#define glXSet3DfxModeMESA glad_glXSet3DfxModeMESA
+	GLAD_API_CALL PFNGLXGETVIDEOINFONVPROC glad_glXGetVideoInfoNV;
+#define glXGetVideoInfoNV glad_glXGetVideoInfoNV
+	GLAD_API_CALL PFNGLXISDIRECTPROC glad_glXIsDirect;
+#define glXIsDirect glad_glXIsDirect
+	GLAD_API_CALL PFNGLXGETFBCONFIGATTRIBPROC glad_glXGetFBConfigAttrib;
+#define glXGetFBConfigAttrib glad_glXGetFBConfigAttrib
+	GLAD_API_CALL PFNGLXGETVISUALFROMFBCONFIGPROC glad_glXGetVisualFromFBConfig;
+#define glXGetVisualFromFBConfig glad_glXGetVisualFromFBConfig
+	GLAD_API_CALL PFNGLXBINDTEXIMAGEEXTPROC glad_glXBindTexImageEXT;
+#define glXBindTexImageEXT glad_glXBindTexImageEXT
+	GLAD_API_CALL PFNGLXBLITCONTEXTFRAMEBUFFERAMDPROC glad_glXBlitContextFramebufferAMD;
+#define glXBlitContextFramebufferAMD glad_glXBlitContextFramebufferAMD
+	GLAD_API_CALL PFNGLXQUERYVERSIONPROC glad_glXQueryVersion;
+#define glXQueryVersion glad_glXQueryVersion
+	GLAD_API_CALL PFNGLXSELECTEVENTSGIXPROC glad_glXSelectEventSGIX;
+#define glXSelectEventSGIX glad_glXSelectEventSGIX
+	GLAD_API_CALL PFNGLXGETMSCRATEOMLPROC glad_glXGetMscRateOML;
+#define glXGetMscRateOML glad_glXGetMscRateOML
+	GLAD_API_CALL PFNGLXQUERYRENDERERINTEGERMESAPROC glad_glXQueryRendererIntegerMESA;
+#define glXQueryRendererIntegerMESA glad_glXQueryRendererIntegerMESA
+	GLAD_API_CALL PFNGLXCREATEWINDOWPROC glad_glXCreateWindow;
+#define glXCreateWindow glad_glXCreateWindow
+	GLAD_API_CALL PFNGLXCOPYIMAGESUBDATANVPROC glad_glXCopyImageSubDataNV;
+#define glXCopyImageSubDataNV glad_glXCopyImageSubDataNV
+	GLAD_API_CALL PFNGLXSWAPINTERVALMESAPROC glad_glXSwapIntervalMESA;
+#define glXSwapIntervalMESA glad_glXSwapIntervalMESA
+	GLAD_API_CALL PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC glad_glXQueryHyperpipeAttribSGIX;
+#define glXQueryHyperpipeAttribSGIX glad_glXQueryHyperpipeAttribSGIX
+	GLAD_API_CALL PFNGLXBINDVIDEOCAPTUREDEVICENVPROC glad_glXBindVideoCaptureDeviceNV;
+#define glXBindVideoCaptureDeviceNV glad_glXBindVideoCaptureDeviceNV
+	GLAD_API_CALL PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC glad_glXCreateContextWithConfigSGIX;
+#define glXCreateContextWithConfigSGIX glad_glXCreateContextWithConfigSGIX
+	GLAD_API_CALL PFNGLXENUMERATEVIDEODEVICESNVPROC glad_glXEnumerateVideoDevicesNV;
+#define glXEnumerateVideoDevicesNV glad_glXEnumerateVideoDevicesNV
+	GLAD_API_CALL PFNGLXHYPERPIPEATTRIBSGIXPROC glad_glXHyperpipeAttribSGIX;
+#define glXHyperpipeAttribSGIX glad_glXHyperpipeAttribSGIX
+	GLAD_API_CALL PFNGLXDESTROYPBUFFERPROC glad_glXDestroyPbuffer;
+#define glXDestroyPbuffer glad_glXDestroyPbuffer
+	GLAD_API_CALL PFNGLXNAMEDCOPYBUFFERSUBDATANVPROC glad_glXNamedCopyBufferSubDataNV;
+#define glXNamedCopyBufferSubDataNV glad_glXNamedCopyBufferSubDataNV
+	GLAD_API_CALL PFNGLXCREATEPBUFFERPROC glad_glXCreatePbuffer;
+#define glXCreatePbuffer glad_glXCreatePbuffer
+	GLAD_API_CALL PFNGLXQUERYCURRENTRENDERERSTRINGMESAPROC glad_glXQueryCurrentRendererStringMESA;
+#define glXQueryCurrentRendererStringMESA glad_glXQueryCurrentRendererStringMESA
+	GLAD_API_CALL PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC glad_glXQueryHyperpipeBestAttribSGIX;
+#define glXQueryHyperpipeBestAttribSGIX glad_glXQueryHyperpipeBestAttribSGIX
+	GLAD_API_CALL PFNGLXGETFBCONFIGATTRIBSGIXPROC glad_glXGetFBConfigAttribSGIX;
+#define glXGetFBConfigAttribSGIX glad_glXGetFBConfigAttribSGIX
+	GLAD_API_CALL PFNGLXQUERYEXTENSIONSSTRINGPROC glad_glXQueryExtensionsString;
+#define glXQueryExtensionsString glad_glXQueryExtensionsString
+	GLAD_API_CALL PFNGLXBINDVIDEODEVICENVPROC glad_glXBindVideoDeviceNV;
+#define glXBindVideoDeviceNV glad_glXBindVideoDeviceNV
+	GLAD_API_CALL PFNGLXCREATEASSOCIATEDCONTEXTAMDPROC glad_glXCreateAssociatedContextAMD;
+#define glXCreateAssociatedContextAMD glad_glXCreateAssociatedContextAMD
+	GLAD_API_CALL PFNGLXQUERYCONTEXTINFOEXTPROC glad_glXQueryContextInfoEXT;
+#define glXQueryContextInfoEXT glad_glXQueryContextInfoEXT
+	GLAD_API_CALL PFNGLXGETSELECTEDEVENTPROC glad_glXGetSelectedEvent;
+#define glXGetSelectedEvent glad_glXGetSelectedEvent
+	GLAD_API_CALL PFNGLXGETCURRENTDISPLAYPROC glad_glXGetCurrentDisplay;
+#define glXGetCurrentDisplay glad_glXGetCurrentDisplay
+	GLAD_API_CALL PFNGLXDESTROYPIXMAPPROC glad_glXDestroyPixmap;
+#define glXDestroyPixmap glad_glXDestroyPixmap
+	GLAD_API_CALL PFNGLXGETSELECTEDEVENTSGIXPROC glad_glXGetSelectedEventSGIX;
+#define glXGetSelectedEventSGIX glad_glXGetSelectedEventSGIX
+	GLAD_API_CALL PFNGLXRELEASETEXIMAGEEXTPROC glad_glXReleaseTexImageEXT;
+#define glXReleaseTexImageEXT glad_glXReleaseTexImageEXT
+	GLAD_API_CALL PFNGLXUSEXFONTPROC glad_glXUseXFont;
+#define glXUseXFont glad_glXUseXFont
+	GLAD_API_CALL PFNGLXGETSYNCVALUESOMLPROC glad_glXGetSyncValuesOML;
+#define glXGetSyncValuesOML glad_glXGetSyncValuesOML
+	GLAD_API_CALL PFNGLXJOINSWAPGROUPNVPROC glad_glXJoinSwapGroupNV;
+#define glXJoinSwapGroupNV glad_glXJoinSwapGroupNV
+	GLAD_API_CALL PFNGLXSWAPBUFFERSPROC glad_glXSwapBuffers;
+#define glXSwapBuffers glad_glXSwapBuffers
+	GLAD_API_CALL PFNGLXDELAYBEFORESWAPNVPROC glad_glXDelayBeforeSwapNV;
+#define glXDelayBeforeSwapNV glad_glXDelayBeforeSwapNV
+	GLAD_API_CALL PFNGLXBINDHYPERPIPESGIXPROC glad_glXBindHyperpipeSGIX;
+#define glXBindHyperpipeSGIX glad_glXBindHyperpipeSGIX
+	GLAD_API_CALL PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC glad_glXLockVideoCaptureDeviceNV;
+#define glXLockVideoCaptureDeviceNV glad_glXLockVideoCaptureDeviceNV
+	GLAD_API_CALL PFNGLXGETCURRENTDISPLAYEXTPROC glad_glXGetCurrentDisplayEXT;
+#define glXGetCurrentDisplayEXT glad_glXGetCurrentDisplayEXT
+	GLAD_API_CALL PFNGLXGETFBCONFIGSPROC glad_glXGetFBConfigs;
+#define glXGetFBConfigs glad_glXGetFBConfigs
+	GLAD_API_CALL PFNGLXGETCURRENTREADDRAWABLEPROC glad_glXGetCurrentReadDrawable;
+#define glXGetCurrentReadDrawable glad_glXGetCurrentReadDrawable
+	GLAD_API_CALL PFNGLXRELEASEVIDEOIMAGENVPROC glad_glXReleaseVideoImageNV;
+#define glXReleaseVideoImageNV glad_glXReleaseVideoImageNV
+	GLAD_API_CALL PFNGLXQUERYEXTENSIONPROC glad_glXQueryExtension;
+#define glXQueryExtension glad_glXQueryExtension
+	GLAD_API_CALL PFNGLXMAKEASSOCIATEDCONTEXTCURRENTAMDPROC glad_glXMakeAssociatedContextCurrentAMD;
+#define glXMakeAssociatedContextCurrentAMD glad_glXMakeAssociatedContextCurrentAMD
+	GLAD_API_CALL PFNGLXCHOOSEVISUALPROC glad_glXChooseVisual;
+#define glXChooseVisual glad_glXChooseVisual
+	GLAD_API_CALL PFNGLXDESTROYCONTEXTPROC glad_glXDestroyContext;
+#define glXDestroyContext glad_glXDestroyContext
+	GLAD_API_CALL PFNGLXGETCLIENTSTRINGPROC glad_glXGetClientString;
+#define glXGetClientString glad_glXGetClientString
+	GLAD_API_CALL PFNGLXDESTROYGLXPIXMAPPROC glad_glXDestroyGLXPixmap;
+#define glXDestroyGLXPixmap glad_glXDestroyGLXPixmap
+	GLAD_API_CALL PFNGLXRESETFRAMECOUNTNVPROC glad_glXResetFrameCountNV;
+#define glXResetFrameCountNV glad_glXResetFrameCountNV
+	GLAD_API_CALL PFNGLXRELEASEVIDEODEVICENVPROC glad_glXReleaseVideoDeviceNV;
+#define glXReleaseVideoDeviceNV glad_glXReleaseVideoDeviceNV
+	GLAD_API_CALL PFNGLXGETFBCONFIGFROMVISUALSGIXPROC glad_glXGetFBConfigFromVisualSGIX;
+#define glXGetFBConfigFromVisualSGIX glad_glXGetFBConfigFromVisualSGIX
+	GLAD_API_CALL PFNGLXCREATENEWCONTEXTPROC glad_glXCreateNewContext;
+#define glXCreateNewContext glad_glXCreateNewContext
+	GLAD_API_CALL PFNGLXMAKECONTEXTCURRENTPROC glad_glXMakeContextCurrent;
+#define glXMakeContextCurrent glad_glXMakeContextCurrent
+	GLAD_API_CALL PFNGLXQUERYMAXSWAPGROUPSNVPROC glad_glXQueryMaxSwapGroupsNV;
+#define glXQueryMaxSwapGroupsNV glad_glXQueryMaxSwapGroupsNV
+	GLAD_API_CALL PFNGLXGETVISUALFROMFBCONFIGSGIXPROC glad_glXGetVisualFromFBConfigSGIX;
+#define glXGetVisualFromFBConfigSGIX glad_glXGetVisualFromFBConfigSGIX
+	GLAD_API_CALL PFNGLXGETCURRENTDRAWABLEPROC glad_glXGetCurrentDrawable;
+#define glXGetCurrentDrawable glad_glXGetCurrentDrawable
+	GLAD_API_CALL PFNGLXGETCURRENTREADDRAWABLESGIPROC glad_glXGetCurrentReadDrawableSGI;
+#define glXGetCurrentReadDrawableSGI glad_glXGetCurrentReadDrawableSGI
+	GLAD_API_CALL PFNGLXQUERYFRAMECOUNTNVPROC glad_glXQueryFrameCountNV;
+#define glXQueryFrameCountNV glad_glXQueryFrameCountNV
+	GLAD_API_CALL PFNGLXGETCONTEXTGPUIDAMDPROC glad_glXGetContextGPUIDAMD;
+#define glXGetContextGPUIDAMD glad_glXGetContextGPUIDAMD
+	GLAD_API_CALL PFNGLXBINDSWAPBARRIERSGIXPROC glad_glXBindSwapBarrierSGIX;
+#define glXBindSwapBarrierSGIX glad_glXBindSwapBarrierSGIX
+	GLAD_API_CALL PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC glad_glXQueryMaxSwapBarriersSGIX;
+#define glXQueryMaxSwapBarriersSGIX glad_glXQueryMaxSwapBarriersSGIX
+	GLAD_API_CALL PFNGLXCREATEGLXPIXMAPMESAPROC glad_glXCreateGLXPixmapMESA;
+#define glXCreateGLXPixmapMESA glad_glXCreateGLXPixmapMESA
+	GLAD_API_CALL PFNGLXMAKECURRENTPROC glad_glXMakeCurrent;
+#define glXMakeCurrent glad_glXMakeCurrent
+	GLAD_API_CALL PFNGLXDESTROYWINDOWPROC glad_glXDestroyWindow;
+#define glXDestroyWindow glad_glXDestroyWindow
+	GLAD_API_CALL PFNGLXBINDVIDEOIMAGENVPROC glad_glXBindVideoImageNV;
+#define glXBindVideoImageNV glad_glXBindVideoImageNV
+	GLAD_API_CALL PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC glad_glXQueryVideoCaptureDeviceNV;
+#define glXQueryVideoCaptureDeviceNV glad_glXQueryVideoCaptureDeviceNV
+	GLAD_API_CALL PFNGLXQUERYCHANNELDELTASSGIXPROC glad_glXQueryChannelDeltasSGIX;
+#define glXQueryChannelDeltasSGIX glad_glXQueryChannelDeltasSGIX
+	GLAD_API_CALL PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC glad_glXEnumerateVideoCaptureDevicesNV;
+#define glXEnumerateVideoCaptureDevicesNV glad_glXEnumerateVideoCaptureDevicesNV
+	GLAD_API_CALL PFNGLXCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC glad_glXCreateAssociatedContextAttribsAMD;
+#define glXCreateAssociatedContextAttribsAMD glad_glXCreateAssociatedContextAttribsAMD
+	GLAD_API_CALL PFNGLXGETCURRENTASSOCIATEDCONTEXTAMDPROC glad_glXGetCurrentAssociatedContextAMD;
+#define glXGetCurrentAssociatedContextAMD glad_glXGetCurrentAssociatedContextAMD
+	GLAD_API_CALL PFNGLXQUERYCHANNELRECTSGIXPROC glad_glXQueryChannelRectSGIX;
+#define glXQueryChannelRectSGIX glad_glXQueryChannelRectSGIX
+	GLAD_API_CALL PFNGLXCREATECONTEXTPROC glad_glXCreateContext;
+#define glXCreateContext glad_glXCreateContext
+	GLAD_API_CALL PFNGLXFREECONTEXTEXTPROC glad_glXFreeContextEXT;
+#define glXFreeContextEXT glad_glXFreeContextEXT
+	GLAD_API_CALL PFNGLXGETCONTEXTIDEXTPROC glad_glXGetContextIDEXT;
+#define glXGetContextIDEXT glad_glXGetContextIDEXT
+	GLAD_API_CALL PFNGLXQUERYCURRENTRENDERERINTEGERMESAPROC glad_glXQueryCurrentRendererIntegerMESA;
+#define glXQueryCurrentRendererIntegerMESA glad_glXQueryCurrentRendererIntegerMESA
+	GLAD_API_CALL PFNGLXCHOOSEFBCONFIGPROC glad_glXChooseFBConfig;
+#define glXChooseFBConfig glad_glXChooseFBConfig
+	GLAD_API_CALL PFNGLXBINDCHANNELTOWINDOWSGIXPROC glad_glXBindChannelToWindowSGIX;
+#define glXBindChannelToWindowSGIX glad_glXBindChannelToWindowSGIX
+	GLAD_API_CALL PFNGLXCHANNELRECTSYNCSGIXPROC glad_glXChannelRectSyncSGIX;
+#define glXChannelRectSyncSGIX glad_glXChannelRectSyncSGIX
+	GLAD_API_CALL PFNGLXIMPORTCONTEXTEXTPROC glad_glXImportContextEXT;
+#define glXImportContextEXT glad_glXImportContextEXT
+	GLAD_API_CALL PFNGLXRELEASEBUFFERSMESAPROC glad_glXReleaseBuffersMESA;
+#define glXReleaseBuffersMESA glad_glXReleaseBuffersMESA
+	GLAD_API_CALL PFNGLXCREATEPIXMAPPROC glad_glXCreatePixmap;
+#define glXCreatePixmap glad_glXCreatePixmap
+	GLAD_API_CALL PFNGLXGETAGPOFFSETMESAPROC glad_glXGetAGPOffsetMESA;
+#define glXGetAGPOffsetMESA glad_glXGetAGPOffsetMESA
+
+	GLAD_API_CALL int gladLoadGLXUserPtr(Display *display, int screen, GLADuserptrloadfunc load, void *userptr);
+	GLAD_API_CALL int gladLoadGLX(Display *display, int screen, GLADloadfunc load);
+
+#ifdef GLAD_GLX
+
+	GLAD_API_CALL int gladLoaderLoadGLX(Display *display, int screen);
+
+	GLAD_API_CALL void gladLoaderUnloadGLX(void);
+
+#endif
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/glad/linmath.h b/engine/inc/bullet/ThirdPartyLibs/glad/linmath.h
new file mode 100644
index 00000000..ef3e7968
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/glad/linmath.h
@@ -0,0 +1,583 @@
+#ifndef LINMATH_H
+#define LINMATH_H
+
+#include <math.h>
+
+#ifdef _MSC_VER
+#define inline __inline
+#endif
+
+#define LINMATH_H_DEFINE_VEC(n)                                                \
+	typedef float vec##n[n];                                                   \
+	static inline void vec##n##_add(vec##n r, vec##n const a, vec##n const b)  \
+	{                                                                          \
+		int i;                                                                 \
+		for (i = 0; i < n; ++i)                                                \
+			r[i] = a[i] + b[i];                                                \
+	}                                                                          \
+	static inline void vec##n##_sub(vec##n r, vec##n const a, vec##n const b)  \
+	{                                                                          \
+		int i;                                                                 \
+		for (i = 0; i < n; ++i)                                                \
+			r[i] = a[i] - b[i];                                                \
+	}                                                                          \
+	static inline void vec##n##_scale(vec##n r, vec##n const v, float const s) \
+	{                                                                          \
+		int i;                                                                 \
+		for (i = 0; i < n; ++i)                                                \
+			r[i] = v[i] * s;                                                   \
+	}                                                                          \
+	static inline float vec##n##_mul_inner(vec##n const a, vec##n const b)     \
+	{                                                                          \
+		float p = 0.;                                                          \
+		int i;                                                                 \
+		for (i = 0; i < n; ++i)                                                \
+			p += b[i] * a[i];                                                  \
+		return p;                                                              \
+	}                                                                          \
+	static inline float vec##n##_len(vec##n const v)                           \
+	{                                                                          \
+		return (float)sqrt(vec##n##_mul_inner(v, v));                          \
+	}                                                                          \
+	static inline void vec##n##_norm(vec##n r, vec##n const v)                 \
+	{                                                                          \
+		float k = 1.f / vec##n##_len(v);                                       \
+		vec##n##_scale(r, v, k);                                               \
+	}
+
+LINMATH_H_DEFINE_VEC(2)
+LINMATH_H_DEFINE_VEC(3)
+LINMATH_H_DEFINE_VEC(4)
+
+static inline void vec3_mul_cross(vec3 r, vec3 const a, vec3 const b)
+{
+	r[0] = a[1] * b[2] - a[2] * b[1];
+	r[1] = a[2] * b[0] - a[0] * b[2];
+	r[2] = a[0] * b[1] - a[1] * b[0];
+}
+
+static inline void vec3_reflect(vec3 r, vec3 const v, vec3 const n)
+{
+	float p = 2.f * vec3_mul_inner(v, n);
+	int i;
+	for (i = 0; i < 3; ++i)
+		r[i] = v[i] - p * n[i];
+}
+
+static inline void vec4_mul_cross(vec4 r, vec4 a, vec4 b)
+{
+	r[0] = a[1] * b[2] - a[2] * b[1];
+	r[1] = a[2] * b[0] - a[0] * b[2];
+	r[2] = a[0] * b[1] - a[1] * b[0];
+	r[3] = 1.f;
+}
+
+static inline void vec4_reflect(vec4 r, vec4 v, vec4 n)
+{
+	float p = 2.f * vec4_mul_inner(v, n);
+	int i;
+	for (i = 0; i < 4; ++i)
+		r[i] = v[i] - p * n[i];
+}
+
+typedef vec4 mat4x4[4];
+static inline void mat4x4_identity(mat4x4 M)
+{
+	int i, j;
+	for (i = 0; i < 4; ++i)
+		for (j = 0; j < 4; ++j)
+			M[i][j] = i == j ? 1.f : 0.f;
+}
+static inline void mat4x4_dup(mat4x4 M, mat4x4 N)
+{
+	int i, j;
+	for (i = 0; i < 4; ++i)
+		for (j = 0; j < 4; ++j)
+			M[i][j] = N[i][j];
+}
+static inline void mat4x4_row(vec4 r, mat4x4 M, int i)
+{
+	int k;
+	for (k = 0; k < 4; ++k)
+		r[k] = M[k][i];
+}
+static inline void mat4x4_col(vec4 r, mat4x4 M, int i)
+{
+	int k;
+	for (k = 0; k < 4; ++k)
+		r[k] = M[i][k];
+}
+static inline void mat4x4_transpose(mat4x4 M, mat4x4 N)
+{
+	int i, j;
+	for (j = 0; j < 4; ++j)
+		for (i = 0; i < 4; ++i)
+			M[i][j] = N[j][i];
+}
+static inline void mat4x4_add(mat4x4 M, mat4x4 a, mat4x4 b)
+{
+	int i;
+	for (i = 0; i < 4; ++i)
+		vec4_add(M[i], a[i], b[i]);
+}
+static inline void mat4x4_sub(mat4x4 M, mat4x4 a, mat4x4 b)
+{
+	int i;
+	for (i = 0; i < 4; ++i)
+		vec4_sub(M[i], a[i], b[i]);
+}
+static inline void mat4x4_scale(mat4x4 M, mat4x4 a, float k)
+{
+	int i;
+	for (i = 0; i < 4; ++i)
+		vec4_scale(M[i], a[i], k);
+}
+static inline void mat4x4_scale_aniso(mat4x4 M, mat4x4 a, float x, float y, float z)
+{
+	int i;
+	vec4_scale(M[0], a[0], x);
+	vec4_scale(M[1], a[1], y);
+	vec4_scale(M[2], a[2], z);
+	for (i = 0; i < 4; ++i)
+	{
+		M[3][i] = a[3][i];
+	}
+}
+static inline void mat4x4_mul(mat4x4 M, mat4x4 a, mat4x4 b)
+{
+	mat4x4 temp;
+	int k, r, c;
+	for (c = 0; c < 4; ++c)
+		for (r = 0; r < 4; ++r)
+		{
+			temp[c][r] = 0.f;
+			for (k = 0; k < 4; ++k)
+				temp[c][r] += a[k][r] * b[c][k];
+		}
+	mat4x4_dup(M, temp);
+}
+static inline void mat4x4_mul_vec4(vec4 r, mat4x4 M, vec4 v)
+{
+	int i, j;
+	for (j = 0; j < 4; ++j)
+	{
+		r[j] = 0.f;
+		for (i = 0; i < 4; ++i)
+			r[j] += M[i][j] * v[i];
+	}
+}
+static inline void mat4x4_translate(mat4x4 T, float x, float y, float z)
+{
+	mat4x4_identity(T);
+	T[3][0] = x;
+	T[3][1] = y;
+	T[3][2] = z;
+}
+static inline void mat4x4_translate_in_place(mat4x4 M, float x, float y, float z)
+{
+	vec4 t = {x, y, z, 0};
+	vec4 r;
+	int i;
+	for (i = 0; i < 4; ++i)
+	{
+		mat4x4_row(r, M, i);
+		M[3][i] += vec4_mul_inner(r, t);
+	}
+}
+static inline void mat4x4_from_vec3_mul_outer(mat4x4 M, vec3 a, vec3 b)
+{
+	int i, j;
+	for (i = 0; i < 4; ++i)
+		for (j = 0; j < 4; ++j)
+			M[i][j] = i < 3 && j < 3 ? a[i] * b[j] : 0.f;
+}
+static inline void mat4x4_rotate(mat4x4 R, mat4x4 M, float x, float y, float z, float angle)
+{
+	float s = sinf(angle);
+	float c = cosf(angle);
+	vec3 u = {x, y, z};
+
+	if (vec3_len(u) > 1e-4)
+	{
+		mat4x4 T, C, S = {{0}};
+
+		vec3_norm(u, u);
+		mat4x4_from_vec3_mul_outer(T, u, u);
+
+		S[1][2] = u[0];
+		S[2][1] = -u[0];
+		S[2][0] = u[1];
+		S[0][2] = -u[1];
+		S[0][1] = u[2];
+		S[1][0] = -u[2];
+
+		mat4x4_scale(S, S, s);
+
+		mat4x4_identity(C);
+		mat4x4_sub(C, C, T);
+
+		mat4x4_scale(C, C, c);
+
+		mat4x4_add(T, T, C);
+		mat4x4_add(T, T, S);
+
+		T[3][3] = 1.;
+		mat4x4_mul(R, M, T);
+	}
+	else
+	{
+		mat4x4_dup(R, M);
+	}
+}
+static inline void mat4x4_rotate_X(mat4x4 Q, mat4x4 M, float angle)
+{
+	float s = sinf(angle);
+	float c = cosf(angle);
+	mat4x4 R = {
+		{1.f, 0.f, 0.f, 0.f},
+		{0.f, c, s, 0.f},
+		{0.f, -s, c, 0.f},
+		{0.f, 0.f, 0.f, 1.f}};
+	mat4x4_mul(Q, M, R);
+}
+static inline void mat4x4_rotate_Y(mat4x4 Q, mat4x4 M, float angle)
+{
+	float s = sinf(angle);
+	float c = cosf(angle);
+	mat4x4 R = {
+		{c, 0.f, s, 0.f},
+		{0.f, 1.f, 0.f, 0.f},
+		{-s, 0.f, c, 0.f},
+		{0.f, 0.f, 0.f, 1.f}};
+	mat4x4_mul(Q, M, R);
+}
+static inline void mat4x4_rotate_Z(mat4x4 Q, mat4x4 M, float angle)
+{
+	float s = sinf(angle);
+	float c = cosf(angle);
+	mat4x4 R = {
+		{c, s, 0.f, 0.f},
+		{-s, c, 0.f, 0.f},
+		{0.f, 0.f, 1.f, 0.f},
+		{0.f, 0.f, 0.f, 1.f}};
+	mat4x4_mul(Q, M, R);
+}
+static inline void mat4x4_invert(mat4x4 T, mat4x4 M)
+{
+	float idet;
+	float s[6];
+	float c[6];
+	s[0] = M[0][0] * M[1][1] - M[1][0] * M[0][1];
+	s[1] = M[0][0] * M[1][2] - M[1][0] * M[0][2];
+	s[2] = M[0][0] * M[1][3] - M[1][0] * M[0][3];
+	s[3] = M[0][1] * M[1][2] - M[1][1] * M[0][2];
+	s[4] = M[0][1] * M[1][3] - M[1][1] * M[0][3];
+	s[5] = M[0][2] * M[1][3] - M[1][2] * M[0][3];
+
+	c[0] = M[2][0] * M[3][1] - M[3][0] * M[2][1];
+	c[1] = M[2][0] * M[3][2] - M[3][0] * M[2][2];
+	c[2] = M[2][0] * M[3][3] - M[3][0] * M[2][3];
+	c[3] = M[2][1] * M[3][2] - M[3][1] * M[2][2];
+	c[4] = M[2][1] * M[3][3] - M[3][1] * M[2][3];
+	c[5] = M[2][2] * M[3][3] - M[3][2] * M[2][3];
+
+	/* Assumes it is invertible */
+	idet = 1.0f / (s[0] * c[5] - s[1] * c[4] + s[2] * c[3] + s[3] * c[2] - s[4] * c[1] + s[5] * c[0]);
+
+	T[0][0] = (M[1][1] * c[5] - M[1][2] * c[4] + M[1][3] * c[3]) * idet;
+	T[0][1] = (-M[0][1] * c[5] + M[0][2] * c[4] - M[0][3] * c[3]) * idet;
+	T[0][2] = (M[3][1] * s[5] - M[3][2] * s[4] + M[3][3] * s[3]) * idet;
+	T[0][3] = (-M[2][1] * s[5] + M[2][2] * s[4] - M[2][3] * s[3]) * idet;
+
+	T[1][0] = (-M[1][0] * c[5] + M[1][2] * c[2] - M[1][3] * c[1]) * idet;
+	T[1][1] = (M[0][0] * c[5] - M[0][2] * c[2] + M[0][3] * c[1]) * idet;
+	T[1][2] = (-M[3][0] * s[5] + M[3][2] * s[2] - M[3][3] * s[1]) * idet;
+	T[1][3] = (M[2][0] * s[5] - M[2][2] * s[2] + M[2][3] * s[1]) * idet;
+
+	T[2][0] = (M[1][0] * c[4] - M[1][1] * c[2] + M[1][3] * c[0]) * idet;
+	T[2][1] = (-M[0][0] * c[4] + M[0][1] * c[2] - M[0][3] * c[0]) * idet;
+	T[2][2] = (M[3][0] * s[4] - M[3][1] * s[2] + M[3][3] * s[0]) * idet;
+	T[2][3] = (-M[2][0] * s[4] + M[2][1] * s[2] - M[2][3] * s[0]) * idet;
+
+	T[3][0] = (-M[1][0] * c[3] + M[1][1] * c[1] - M[1][2] * c[0]) * idet;
+	T[3][1] = (M[0][0] * c[3] - M[0][1] * c[1] + M[0][2] * c[0]) * idet;
+	T[3][2] = (-M[3][0] * s[3] + M[3][1] * s[1] - M[3][2] * s[0]) * idet;
+	T[3][3] = (M[2][0] * s[3] - M[2][1] * s[1] + M[2][2] * s[0]) * idet;
+}
+static inline void mat4x4_orthonormalize(mat4x4 R, mat4x4 M)
+{
+	float s = 1.;
+	vec3 h;
+
+	mat4x4_dup(R, M);
+	vec3_norm(R[2], R[2]);
+
+	s = vec3_mul_inner(R[1], R[2]);
+	vec3_scale(h, R[2], s);
+	vec3_sub(R[1], R[1], h);
+	vec3_norm(R[2], R[2]);
+
+	s = vec3_mul_inner(R[1], R[2]);
+	vec3_scale(h, R[2], s);
+	vec3_sub(R[1], R[1], h);
+	vec3_norm(R[1], R[1]);
+
+	s = vec3_mul_inner(R[0], R[1]);
+	vec3_scale(h, R[1], s);
+	vec3_sub(R[0], R[0], h);
+	vec3_norm(R[0], R[0]);
+}
+
+static inline void mat4x4_frustum(mat4x4 M, float l, float r, float b, float t, float n, float f)
+{
+	M[0][0] = 2.f * n / (r - l);
+	M[0][1] = M[0][2] = M[0][3] = 0.f;
+
+	M[1][1] = 2.f * n / (t - b);
+	M[1][0] = M[1][2] = M[1][3] = 0.f;
+
+	M[2][0] = (r + l) / (r - l);
+	M[2][1] = (t + b) / (t - b);
+	M[2][2] = -(f + n) / (f - n);
+	M[2][3] = -1.f;
+
+	M[3][2] = -2.f * (f * n) / (f - n);
+	M[3][0] = M[3][1] = M[3][3] = 0.f;
+}
+static inline void mat4x4_ortho(mat4x4 M, float l, float r, float b, float t, float n, float f)
+{
+	M[0][0] = 2.f / (r - l);
+	M[0][1] = M[0][2] = M[0][3] = 0.f;
+
+	M[1][1] = 2.f / (t - b);
+	M[1][0] = M[1][2] = M[1][3] = 0.f;
+
+	M[2][2] = -2.f / (f - n);
+	M[2][0] = M[2][1] = M[2][3] = 0.f;
+
+	M[3][0] = -(r + l) / (r - l);
+	M[3][1] = -(t + b) / (t - b);
+	M[3][2] = -(f + n) / (f - n);
+	M[3][3] = 1.f;
+}
+static inline void mat4x4_perspective(mat4x4 m, float y_fov, float aspect, float n, float f)
+{
+	/* NOTE: Degrees are an unhandy unit to work with.
+	 * linmath.h uses radians for everything! */
+	float const a = 1.f / (float)tan(y_fov / 2.f);
+
+	m[0][0] = a / aspect;
+	m[0][1] = 0.f;
+	m[0][2] = 0.f;
+	m[0][3] = 0.f;
+
+	m[1][0] = 0.f;
+	m[1][1] = a;
+	m[1][2] = 0.f;
+	m[1][3] = 0.f;
+
+	m[2][0] = 0.f;
+	m[2][1] = 0.f;
+	m[2][2] = -((f + n) / (f - n));
+	m[2][3] = -1.f;
+
+	m[3][0] = 0.f;
+	m[3][1] = 0.f;
+	m[3][2] = -((2.f * f * n) / (f - n));
+	m[3][3] = 0.f;
+}
+static inline void mat4x4_look_at(mat4x4 m, vec3 eye, vec3 center, vec3 up)
+{
+	/* Adapted from Android's OpenGL Matrix.java.                        */
+	/* See the OpenGL GLUT documentation for gluLookAt for a description */
+	/* of the algorithm. We implement it in a straightforward way:       */
+
+	/* TODO: The negation of of can be spared by swapping the order of
+	 *       operands in the following cross products in the right way. */
+	vec3 f;
+	vec3 s;
+	vec3 t;
+
+	vec3_sub(f, center, eye);
+	vec3_norm(f, f);
+
+	vec3_mul_cross(s, f, up);
+	vec3_norm(s, s);
+
+	vec3_mul_cross(t, s, f);
+
+	m[0][0] = s[0];
+	m[0][1] = t[0];
+	m[0][2] = -f[0];
+	m[0][3] = 0.f;
+
+	m[1][0] = s[1];
+	m[1][1] = t[1];
+	m[1][2] = -f[1];
+	m[1][3] = 0.f;
+
+	m[2][0] = s[2];
+	m[2][1] = t[2];
+	m[2][2] = -f[2];
+	m[2][3] = 0.f;
+
+	m[3][0] = 0.f;
+	m[3][1] = 0.f;
+	m[3][2] = 0.f;
+	m[3][3] = 1.f;
+
+	mat4x4_translate_in_place(m, -eye[0], -eye[1], -eye[2]);
+}
+
+typedef float quat[4];
+static inline void quat_identity(quat q)
+{
+	q[0] = q[1] = q[2] = 0.f;
+	q[3] = 1.f;
+}
+static inline void quat_add(quat r, quat a, quat b)
+{
+	int i;
+	for (i = 0; i < 4; ++i)
+		r[i] = a[i] + b[i];
+}
+static inline void quat_sub(quat r, quat a, quat b)
+{
+	int i;
+	for (i = 0; i < 4; ++i)
+		r[i] = a[i] - b[i];
+}
+static inline void quat_mul(quat r, quat p, quat q)
+{
+	vec3 w;
+	vec3_mul_cross(r, p, q);
+	vec3_scale(w, p, q[3]);
+	vec3_add(r, r, w);
+	vec3_scale(w, q, p[3]);
+	vec3_add(r, r, w);
+	r[3] = p[3] * q[3] - vec3_mul_inner(p, q);
+}
+static inline void quat_scale(quat r, quat v, float s)
+{
+	int i;
+	for (i = 0; i < 4; ++i)
+		r[i] = v[i] * s;
+}
+static inline float quat_inner_product(quat a, quat b)
+{
+	float p = 0.f;
+	int i;
+	for (i = 0; i < 4; ++i)
+		p += b[i] * a[i];
+	return p;
+}
+static inline void quat_conj(quat r, quat q)
+{
+	int i;
+	for (i = 0; i < 3; ++i)
+		r[i] = -q[i];
+	r[3] = q[3];
+}
+static inline void quat_rotate(quat r, float angle, vec3 axis)
+{
+	int i;
+	vec3 v;
+	vec3_scale(v, axis, sinf(angle / 2));
+	for (i = 0; i < 3; ++i)
+		r[i] = v[i];
+	r[3] = cosf(angle / 2);
+}
+#define quat_norm vec4_norm
+static inline void quat_mul_vec3(vec3 r, quat q, vec3 v)
+{
+	/*
+ * Method by Fabian 'ryg' Giessen (of Farbrausch)
+t = 2 * cross(q.xyz, v)
+v' = v + q.w * t + cross(q.xyz, t)
+ */
+	vec3 t = {q[0], q[1], q[2]};
+	vec3 u = {q[0], q[1], q[2]};
+
+	vec3_mul_cross(t, t, v);
+	vec3_scale(t, t, 2);
+
+	vec3_mul_cross(u, u, t);
+	vec3_scale(t, t, q[3]);
+
+	vec3_add(r, v, t);
+	vec3_add(r, r, u);
+}
+static inline void mat4x4_from_quat(mat4x4 M, quat q)
+{
+	float a = q[3];
+	float b = q[0];
+	float c = q[1];
+	float d = q[2];
+	float a2 = a * a;
+	float b2 = b * b;
+	float c2 = c * c;
+	float d2 = d * d;
+
+	M[0][0] = a2 + b2 - c2 - d2;
+	M[0][1] = 2.f * (b * c + a * d);
+	M[0][2] = 2.f * (b * d - a * c);
+	M[0][3] = 0.f;
+
+	M[1][0] = 2 * (b * c - a * d);
+	M[1][1] = a2 - b2 + c2 - d2;
+	M[1][2] = 2.f * (c * d + a * b);
+	M[1][3] = 0.f;
+
+	M[2][0] = 2.f * (b * d + a * c);
+	M[2][1] = 2.f * (c * d - a * b);
+	M[2][2] = a2 - b2 - c2 + d2;
+	M[2][3] = 0.f;
+
+	M[3][0] = M[3][1] = M[3][2] = 0.f;
+	M[3][3] = 1.f;
+}
+
+static inline void mat4x4o_mul_quat(mat4x4 R, mat4x4 M, quat q)
+{
+	/*  XXX: The way this is written only works for othogonal matrices. */
+	/* TODO: Take care of non-orthogonal case. */
+	quat_mul_vec3(R[0], q, M[0]);
+	quat_mul_vec3(R[1], q, M[1]);
+	quat_mul_vec3(R[2], q, M[2]);
+
+	R[3][0] = R[3][1] = R[3][2] = 0.f;
+	R[3][3] = 1.f;
+}
+static inline void quat_from_mat4x4(quat q, mat4x4 M)
+{
+	float r = 0.f;
+	int i;
+
+	int perm[] = {0, 1, 2, 0, 1};
+	int *p = perm;
+
+	for (i = 0; i < 3; i++)
+	{
+		float m = M[i][i];
+		if (m < r)
+			continue;
+		m = r;
+		p = &perm[i];
+	}
+
+	r = (float)sqrt(1.f + M[p[0]][p[0]] - M[p[1]][p[1]] - M[p[2]][p[2]]);
+
+	if (r < 1e-6)
+	{
+		q[0] = 1.f;
+		q[1] = q[2] = q[3] = 0.f;
+		return;
+	}
+
+	q[0] = r / 2.f;
+	q[1] = (M[p[0]][p[1]] - M[p[1]][p[0]]) / (2.f * r);
+	q[2] = (M[p[2]][p[0]] - M[p[0]][p[2]]) / (2.f * r);
+	q[3] = (M[p[2]][p[1]] - M[p[1]][p[2]]) / (2.f * r);
+}
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/imgui/imconfig.h b/engine/inc/bullet/ThirdPartyLibs/imgui/imconfig.h
new file mode 100644
index 00000000..c033aedd
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/imgui/imconfig.h
@@ -0,0 +1,63 @@
+//-----------------------------------------------------------------------------
+// COMPILE-TIME OPTIONS FOR DEAR IMGUI
+// Most options (memory allocation, clipboard callbacks, etc.) can be set at runtime via the ImGuiIO structure - ImGui::GetIO().
+//-----------------------------------------------------------------------------
+// A) You may edit imconfig.h (and not overwrite it when updating imgui, or maintain a patch/branch with your modifications to imconfig.h)
+// B) or add configuration directives in your own file and compile with #define IMGUI_USER_CONFIG "myfilename.h"
+// Note that options such as IMGUI_API, IM_VEC2_CLASS_EXTRA or ImDrawIdx needs to be defined consistently everywhere you include imgui.h, not only for the imgui*.cpp compilation units.
+//-----------------------------------------------------------------------------
+
+#pragma once
+
+//---- Define assertion handler. Defaults to calling assert().
+//#define IM_ASSERT(_EXPR)  MyAssert(_EXPR)
+
+//---- Define attributes of all API symbols declarations, e.g. for DLL under Windows.
+//#define IMGUI_API __declspec( dllexport )
+//#define IMGUI_API __declspec( dllimport )
+
+//---- Don't define obsolete functions names. Consider enabling from time to time or when updating to reduce likelihood of using already obsolete function/names
+//#define IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+
+//---- Don't implement default handlers for Windows (so as not to link with certain functions)
+//#define IMGUI_DISABLE_WIN32_DEFAULT_CLIPBOARD_FUNCTIONS   // Don't use and link with OpenClipboard/GetClipboardData/CloseClipboard etc.
+//#define IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCTIONS         // Don't use and link with ImmGetContext/ImmSetCompositionWindow.
+
+//---- Don't implement demo windows functionality (ShowDemoWindow()/ShowStyleEditor()/ShowUserGuide() methods will be empty)
+//---- It is very strongly recommended to NOT disable the demo windows. Please read the comment at the top of imgui_demo.cpp.
+//#define IMGUI_DISABLE_DEMO_WINDOWS
+
+//---- Don't implement ImFormatString(), ImFormatStringV() so you can reimplement them yourself.
+//#define IMGUI_DISABLE_FORMAT_STRING_FUNCTIONS
+
+//---- Include imgui_user.h at the end of imgui.h as a convenience
+//#define IMGUI_INCLUDE_IMGUI_USER_H
+
+//---- Pack colors to BGRA8 instead of RGBA8 (if you needed to convert from one to another anyway)
+//#define IMGUI_USE_BGRA_PACKED_COLOR
+
+//---- Implement STB libraries in a namespace to avoid linkage conflicts (defaults to global namespace)
+//#define IMGUI_STB_NAMESPACE     ImGuiStb
+
+//---- Define constructor and implicit cast operators to convert back<>forth from your math types and ImVec2/ImVec4.
+// This will be inlined as part of ImVec2 and ImVec4 class declarations.
+/*
+#define IM_VEC2_CLASS_EXTRA                                                 \
+        ImVec2(const MyVec2& f) { x = f.x; y = f.y; }                       \
+        operator MyVec2() const { return MyVec2(x,y); }
+
+#define IM_VEC4_CLASS_EXTRA                                                 \
+        ImVec4(const MyVec4& f) { x = f.x; y = f.y; z = f.z; w = f.w; }     \
+        operator MyVec4() const { return MyVec4(x,y,z,w); }
+*/
+
+//---- Use 32-bit vertex indices (instead of default 16-bit) to allow meshes with more than 64K vertices. Render function needs to support it.
+//#define ImDrawIdx unsigned int
+
+//---- Tip: You can add extra functions within the ImGui:: namespace, here or in your own headers files.
+/*
+namespace ImGui
+{
+    void MyFunction(const char* name, const MyMatrix44& v);
+}
+*/
diff --git a/engine/inc/bullet/ThirdPartyLibs/imgui/imgui.h b/engine/inc/bullet/ThirdPartyLibs/imgui/imgui.h
new file mode 100644
index 00000000..94c92374
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/imgui/imgui.h
@@ -0,0 +1,2076 @@
+// dear imgui, v1.60 WIP
+// (headers)
+
+// See imgui.cpp file for documentation.
+// Call and read ImGui::ShowDemoWindow() in imgui_demo.cpp for demo code.
+// Read 'Programmer guide' in imgui.cpp for notes on how to setup ImGui in your codebase.
+// Get latest version at https://github.com/ocornut/imgui
+
+#pragma once
+
+// User-editable configuration files (edit stock imconfig.h or define IMGUI_USER_CONFIG to your own filename)
+#ifdef IMGUI_USER_CONFIG
+#include IMGUI_USER_CONFIG
+#endif
+#if !defined(IMGUI_DISABLE_INCLUDE_IMCONFIG_H) || defined(IMGUI_INCLUDE_IMCONFIG_H)
+#include "imconfig.h"
+#endif
+
+#include <float.h>   // FLT_MAX
+#include <stdarg.h>  // va_list
+#include <stddef.h>  // ptrdiff_t, NULL
+#include <string.h>  // memset, memmove, memcpy, strlen, strchr, strcpy, strcmp
+
+#define IMGUI_VERSION "1.60 WIP"
+
+// Define attributes of all API symbols declarations, e.g. for DLL under Windows.
+#ifndef IMGUI_API
+#define IMGUI_API
+#endif
+
+// Define assertion handler.
+#ifndef IM_ASSERT
+#include <assert.h>
+#define IM_ASSERT(_EXPR) assert(_EXPR)
+#endif
+
+// Helpers
+// Some compilers support applying printf-style warnings to user functions.
+#if defined(__clang__) || defined(__GNUC__)
+#define IM_FMTARGS(FMT) __attribute__((format(printf, FMT, FMT + 1)))
+#define IM_FMTLIST(FMT) __attribute__((format(printf, FMT, 0)))
+#else
+#define IM_FMTARGS(FMT)
+#define IM_FMTLIST(FMT)
+#endif
+#define IM_ARRAYSIZE(_ARR) ((int)(sizeof(_ARR) / sizeof(*_ARR)))
+#define IM_OFFSETOF(_TYPE, _MEMBER) ((size_t) & (((_TYPE*)0)->_MEMBER))  // Offset of _MEMBER within _TYPE. Standardized as offsetof() in modern C++.
+
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wold-style-cast"
+#endif
+
+// Forward declarations
+struct ImDrawChannel;              // Temporary storage for outputting drawing commands out of order, used by ImDrawList::ChannelsSplit()
+struct ImDrawCmd;                  // A single draw command within a parent ImDrawList (generally maps to 1 GPU draw call)
+struct ImDrawData;                 // All draw command lists required to render the frame
+struct ImDrawList;                 // A single draw command list (generally one per window)
+struct ImDrawListSharedData;       // Data shared among multiple draw lists (typically owned by parent ImGui context, but you may create one yourself)
+struct ImDrawVert;                 // A single vertex (20 bytes by default, override layout with IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT)
+struct ImFont;                     // Runtime data for a single font within a parent ImFontAtlas
+struct ImFontAtlas;                // Runtime data for multiple fonts, bake multiple fonts into a single texture, TTF/OTF font loader
+struct ImFontConfig;               // Configuration data when adding a font or merging fonts
+struct ImColor;                    // Helper functions to create a color that can be converted to either u32 or float4
+struct ImGuiIO;                    // Main configuration and I/O between your application and ImGui
+struct ImGuiOnceUponAFrame;        // Simple helper for running a block of code not more than once a frame, used by IMGUI_ONCE_UPON_A_FRAME macro
+struct ImGuiStorage;               // Simple custom key value storage
+struct ImGuiStyle;                 // Runtime data for styling/colors
+struct ImGuiTextFilter;            // Parse and apply text filters. In format "aaaaa[,bbbb][,ccccc]"
+struct ImGuiTextBuffer;            // Text buffer for logging/accumulating text
+struct ImGuiTextEditCallbackData;  // Shared state of ImGui::InputText() when using custom ImGuiTextEditCallback (rare/advanced use)
+struct ImGuiSizeCallbackData;      // Structure used to constraint window size in custom ways when using custom ImGuiSizeCallback (rare/advanced use)
+struct ImGuiListClipper;           // Helper to manually clip large list of items
+struct ImGuiPayload;               // User data payload for drag and drop operations
+struct ImGuiContext;               // ImGui context (opaque)
+
+// Typedefs and Enumerations (declared as int for compatibility and to not pollute the top of this file)
+typedef unsigned int ImU32;        // 32-bit unsigned integer (typically used to store packed colors)
+typedef unsigned int ImGuiID;      // unique ID used by widgets (typically hashed from a stack of string)
+typedef unsigned short ImWchar;    // character for keyboard input/display
+typedef void* ImTextureID;         // user data to identify a texture (this is whatever to you want it to be! read the FAQ about ImTextureID in imgui.cpp)
+typedef int ImGuiCol;              // enum: a color identifier for styling     // enum ImGuiCol_
+typedef int ImGuiCond;             // enum: a condition for Set*()             // enum ImGuiCond_
+typedef int ImGuiKey;              // enum: a key identifier (ImGui-side enum) // enum ImGuiKey_
+typedef int ImGuiNavInput;         // enum: an input identifier for navigation // enum ImGuiNavInput_
+typedef int ImGuiMouseCursor;      // enum: a mouse cursor identifier          // enum ImGuiMouseCursor_
+typedef int ImGuiStyleVar;         // enum: a variable identifier for styling  // enum ImGuiStyleVar_
+typedef int ImDrawCornerFlags;     // flags: for ImDrawList::AddRect*() etc.   // enum ImDrawCornerFlags_
+typedef int ImDrawListFlags;       // flags: for ImDrawList                    // enum ImDrawListFlags_
+typedef int ImFontAtlasFlags;      // flags: for ImFontAtlas                   // enum ImFontAtlasFlags_
+typedef int ImGuiColorEditFlags;   // flags: for ColorEdit*(), ColorPicker*()  // enum ImGuiColorEditFlags_
+typedef int ImGuiColumnsFlags;     // flags: for *Columns*()                   // enum ImGuiColumnsFlags_
+typedef int ImGuiDragDropFlags;    // flags: for *DragDrop*()                  // enum ImGuiDragDropFlags_
+typedef int ImGuiComboFlags;       // flags: for BeginCombo()                  // enum ImGuiComboFlags_
+typedef int ImGuiFocusedFlags;     // flags: for IsWindowFocused()             // enum ImGuiFocusedFlags_
+typedef int ImGuiHoveredFlags;     // flags: for IsItemHovered() etc.          // enum ImGuiHoveredFlags_
+typedef int ImGuiInputTextFlags;   // flags: for InputText*()                  // enum ImGuiInputTextFlags_
+typedef int ImGuiNavFlags;         // flags: for io.NavFlags                   // enum ImGuiNavFlags_
+typedef int ImGuiSelectableFlags;  // flags: for Selectable()                  // enum ImGuiSelectableFlags_
+typedef int ImGuiTreeNodeFlags;    // flags: for TreeNode*(),CollapsingHeader()// enum ImGuiTreeNodeFlags_
+typedef int ImGuiWindowFlags;      // flags: for Begin*()                      // enum ImGuiWindowFlags_
+typedef int (*ImGuiTextEditCallback)(ImGuiTextEditCallbackData* data);
+typedef void (*ImGuiSizeCallback)(ImGuiSizeCallbackData* data);
+#if defined(_MSC_VER) && !defined(__clang__)
+typedef unsigned __int64 ImU64;  // 64-bit unsigned integer
+#else
+typedef unsigned long long ImU64;  // 64-bit unsigned integer
+#endif
+
+// Others helpers at bottom of the file:
+// class ImVector<>                 // Lightweight std::vector like class.
+// IMGUI_ONCE_UPON_A_FRAME          // Execute a block of code once per frame only (convenient for creating UI within deep-nested code that runs multiple times)
+
+struct ImVec2
+{
+	float x, y;
+	ImVec2() { x = y = 0.0f; }
+	ImVec2(float _x, float _y)
+	{
+		x = _x;
+		y = _y;
+	}
+	float operator[](size_t idx) const
+	{
+		IM_ASSERT(idx == 0 || idx == 1);
+		return (&x)[idx];
+	}                       // We very rarely use this [] operator, thus an assert is fine.
+#ifdef IM_VEC2_CLASS_EXTRA  // Define constructor and implicit cast operators in imconfig.h to convert back<>forth from your math types and ImVec2.
+	IM_VEC2_CLASS_EXTRA
+#endif
+};
+
+struct ImVec4
+{
+	float x, y, z, w;
+	ImVec4() { x = y = z = w = 0.0f; }
+	ImVec4(float _x, float _y, float _z, float _w)
+	{
+		x = _x;
+		y = _y;
+		z = _z;
+		w = _w;
+	}
+#ifdef IM_VEC4_CLASS_EXTRA  // Define constructor and implicit cast operators in imconfig.h to convert back<>forth from your math types and ImVec4.
+	IM_VEC4_CLASS_EXTRA
+#endif
+};
+
+// ImGui end-user API
+// In a namespace so that user can add extra functions in a separate file (e.g. Value() helpers for your vector or common types)
+namespace ImGui
+{
+// Context creation and access, if you want to use multiple context, share context between modules (e.g. DLL).
+// All contexts share a same ImFontAtlas by default. If you want different font atlas, you can new() them and overwrite the GetIO().Fonts variable of an ImGui context.
+// All those functions are not reliant on the current context.
+IMGUI_API ImGuiContext* CreateContext(ImFontAtlas* shared_font_atlas = NULL);
+IMGUI_API void DestroyContext(ImGuiContext* ctx = NULL);  // NULL = Destroy current context
+IMGUI_API ImGuiContext* GetCurrentContext();
+IMGUI_API void SetCurrentContext(ImGuiContext* ctx);
+
+// Main
+IMGUI_API ImGuiIO& GetIO();
+IMGUI_API ImGuiStyle& GetStyle();
+IMGUI_API void NewFrame();            // start a new ImGui frame, you can submit any command from this point until Render()/EndFrame().
+IMGUI_API void Render();              // ends the ImGui frame, finalize the draw data. (Obsolete: optionally call io.RenderDrawListsFn if set. Nowadays, prefer calling your render function yourself.)
+IMGUI_API ImDrawData* GetDrawData();  // valid after Render() and until the next call to NewFrame(). this is what you have to render. (Obsolete: this used to be passed to your io.RenderDrawListsFn() function.)
+IMGUI_API void EndFrame();            // ends the ImGui frame. automatically called by Render(), so most likely don't need to ever call that yourself directly. If you don't need to render you may call EndFrame() but you'll have wasted CPU already. If you don't need to render, better to not create any imgui windows instead!
+
+// Demo, Debug, Informations
+IMGUI_API void ShowDemoWindow(bool* p_open = NULL);      // create demo/test window (previously called ShowTestWindow). demonstrate most ImGui features. call this to learn about the library! try to make it always available in your application!
+IMGUI_API void ShowMetricsWindow(bool* p_open = NULL);   // create metrics window. display ImGui internals: draw commands (with individual draw calls and vertices), window list, basic internal state, etc.
+IMGUI_API void ShowStyleEditor(ImGuiStyle* ref = NULL);  // add style editor block (not a window). you can pass in a reference ImGuiStyle structure to compare to, revert to and save to (else it uses the default style)
+IMGUI_API bool ShowStyleSelector(const char* label);
+IMGUI_API void ShowFontSelector(const char* label);
+IMGUI_API void ShowUserGuide();  // add basic help/info block (not a window): how to manipulate ImGui as a end-user (mouse/keyboard controls).
+IMGUI_API const char* GetVersion();
+
+// Styles
+IMGUI_API void StyleColorsDark(ImGuiStyle* dst = NULL);     // New, recommended style
+IMGUI_API void StyleColorsClassic(ImGuiStyle* dst = NULL);  // Classic imgui style (default)
+IMGUI_API void StyleColorsLight(ImGuiStyle* dst = NULL);    // Best used with borders and a custom, thicker font
+
+// Window
+IMGUI_API bool Begin(const char* name, bool* p_open = NULL, ImGuiWindowFlags flags = 0);                                            // push window to the stack and start appending to it. see .cpp for details. return false when window is collapsed (so you can early out in your code) but you always need to call End() regardless. 'bool* p_open' creates a widget on the upper-right to close the window (which sets your bool to false).
+IMGUI_API void End();                                                                                                               // always call even if Begin() return false (which indicates a collapsed window)! finish appending to current window, pop it off the window stack.
+IMGUI_API bool BeginChild(const char* str_id, const ImVec2& size = ImVec2(0, 0), bool border = false, ImGuiWindowFlags flags = 0);  // begin a scrolling region. size==0.0f: use remaining window size, size<0.0f: use remaining window size minus abs(size). size>0.0f: fixed size. each axis can use a different mode, e.g. ImVec2(0,400).
+IMGUI_API bool BeginChild(ImGuiID id, const ImVec2& size = ImVec2(0, 0), bool border = false, ImGuiWindowFlags flags = 0);          // "
+IMGUI_API void EndChild();                                                                                                          // always call even if BeginChild() return false (which indicates a collapsed or clipping child window)
+IMGUI_API ImVec2 GetContentRegionMax();                                                                                             // current content boundaries (typically window boundaries including scrolling, or current column boundaries), in windows coordinates
+IMGUI_API ImVec2 GetContentRegionAvail();                                                                                           // == GetContentRegionMax() - GetCursorPos()
+IMGUI_API float GetContentRegionAvailWidth();                                                                                       //
+IMGUI_API ImVec2 GetWindowContentRegionMin();                                                                                       // content boundaries min (roughly (0,0)-Scroll), in window coordinates
+IMGUI_API ImVec2 GetWindowContentRegionMax();                                                                                       // content boundaries max (roughly (0,0)+Size-Scroll) where Size can be override with SetNextWindowContentSize(), in window coordinates
+IMGUI_API float GetWindowContentRegionWidth();                                                                                      //
+IMGUI_API ImDrawList* GetWindowDrawList();                                                                                          // get rendering command-list if you want to append your own draw primitives
+IMGUI_API ImVec2 GetWindowPos();                                                                                                    // get current window position in screen space (useful if you want to do your own drawing via the DrawList api)
+IMGUI_API ImVec2 GetWindowSize();                                                                                                   // get current window size
+IMGUI_API float GetWindowWidth();
+IMGUI_API float GetWindowHeight();
+IMGUI_API bool IsWindowCollapsed();
+IMGUI_API bool IsWindowAppearing();
+IMGUI_API void SetWindowFontScale(float scale);  // per-window font scale. Adjust IO.FontGlobalScale if you want to scale all windows
+
+IMGUI_API void SetNextWindowPos(const ImVec2& pos, ImGuiCond cond = 0, const ImVec2& pivot = ImVec2(0, 0));                                                                // set next window position. call before Begin(). use pivot=(0.5f,0.5f) to center on given point, etc.
+IMGUI_API void SetNextWindowSize(const ImVec2& size, ImGuiCond cond = 0);                                                                                                  // set next window size. set axis to 0.0f to force an auto-fit on this axis. call before Begin()
+IMGUI_API void SetNextWindowSizeConstraints(const ImVec2& size_min, const ImVec2& size_max, ImGuiSizeCallback custom_callback = NULL, void* custom_callback_data = NULL);  // set next window size limits. use -1,-1 on either X/Y axis to preserve the current size. Use callback to apply non-trivial programmatic constraints.
+IMGUI_API void SetNextWindowContentSize(const ImVec2& size);                                                                                                               // set next window content size (~ enforce the range of scrollbars). not including window decorations (title bar, menu bar, etc.). set an axis to 0.0f to leave it automatic. call before Begin()
+IMGUI_API void SetNextWindowCollapsed(bool collapsed, ImGuiCond cond = 0);                                                                                                 // set next window collapsed state. call before Begin()
+IMGUI_API void SetNextWindowFocus();                                                                                                                                       // set next window to be focused / front-most. call before Begin()
+IMGUI_API void SetNextWindowBgAlpha(float alpha);                                                                                                                          // set next window background color alpha. helper to easily modify ImGuiCol_WindowBg/ChildBg/PopupBg.
+IMGUI_API void SetWindowPos(const ImVec2& pos, ImGuiCond cond = 0);                                                                                                        // (not recommended) set current window position - call within Begin()/End(). prefer using SetNextWindowPos(), as this may incur tearing and side-effects.
+IMGUI_API void SetWindowSize(const ImVec2& size, ImGuiCond cond = 0);                                                                                                      // (not recommended) set current window size - call within Begin()/End(). set to ImVec2(0,0) to force an auto-fit. prefer using SetNextWindowSize(), as this may incur tearing and minor side-effects.
+IMGUI_API void SetWindowCollapsed(bool collapsed, ImGuiCond cond = 0);                                                                                                     // (not recommended) set current window collapsed state. prefer using SetNextWindowCollapsed().
+IMGUI_API void SetWindowFocus();                                                                                                                                           // (not recommended) set current window to be focused / front-most. prefer using SetNextWindowFocus().
+IMGUI_API void SetWindowPos(const char* name, const ImVec2& pos, ImGuiCond cond = 0);                                                                                      // set named window position.
+IMGUI_API void SetWindowSize(const char* name, const ImVec2& size, ImGuiCond cond = 0);                                                                                    // set named window size. set axis to 0.0f to force an auto-fit on this axis.
+IMGUI_API void SetWindowCollapsed(const char* name, bool collapsed, ImGuiCond cond = 0);                                                                                   // set named window collapsed state
+IMGUI_API void SetWindowFocus(const char* name);                                                                                                                           // set named window to be focused / front-most. use NULL to remove focus.
+
+IMGUI_API float GetScrollX();                                                // get scrolling amount [0..GetScrollMaxX()]
+IMGUI_API float GetScrollY();                                                // get scrolling amount [0..GetScrollMaxY()]
+IMGUI_API float GetScrollMaxX();                                             // get maximum scrolling amount ~~ ContentSize.X - WindowSize.X
+IMGUI_API float GetScrollMaxY();                                             // get maximum scrolling amount ~~ ContentSize.Y - WindowSize.Y
+IMGUI_API void SetScrollX(float scroll_x);                                   // set scrolling amount [0..GetScrollMaxX()]
+IMGUI_API void SetScrollY(float scroll_y);                                   // set scrolling amount [0..GetScrollMaxY()]
+IMGUI_API void SetScrollHere(float center_y_ratio = 0.5f);                   // adjust scrolling amount to make current cursor position visible. center_y_ratio=0.0: top, 0.5: center, 1.0: bottom. When using to make a "default/current item" visible, consider using SetItemDefaultFocus() instead.
+IMGUI_API void SetScrollFromPosY(float pos_y, float center_y_ratio = 0.5f);  // adjust scrolling amount to make given position valid. use GetCursorPos() or GetCursorStartPos()+offset to get valid positions.
+IMGUI_API void SetStateStorage(ImGuiStorage* tree);                          // replace tree state storage with our own (if you want to manipulate it yourself, typically clear subsection of it)
+IMGUI_API ImGuiStorage* GetStateStorage();
+
+// Parameters stacks (shared)
+IMGUI_API void PushFont(ImFont* font);  // use NULL as a shortcut to push default font
+IMGUI_API void PopFont();
+IMGUI_API void PushStyleColor(ImGuiCol idx, ImU32 col);
+IMGUI_API void PushStyleColor(ImGuiCol idx, const ImVec4& col);
+IMGUI_API void PopStyleColor(int count = 1);
+IMGUI_API void PushStyleVar(ImGuiStyleVar idx, float val);
+IMGUI_API void PushStyleVar(ImGuiStyleVar idx, const ImVec2& val);
+IMGUI_API void PopStyleVar(int count = 1);
+IMGUI_API const ImVec4& GetStyleColorVec4(ImGuiCol idx);            // retrieve style color as stored in ImGuiStyle structure. use to feed back into PushStyleColor(), otherwhise use GetColorU32() to get style color + style alpha.
+IMGUI_API ImFont* GetFont();                                        // get current font
+IMGUI_API float GetFontSize();                                      // get current font size (= height in pixels) of current font with current scale applied
+IMGUI_API ImVec2 GetFontTexUvWhitePixel();                          // get UV coordinate for a while pixel, useful to draw custom shapes via the ImDrawList API
+IMGUI_API ImU32 GetColorU32(ImGuiCol idx, float alpha_mul = 1.0f);  // retrieve given style color with style alpha applied and optional extra alpha multiplier
+IMGUI_API ImU32 GetColorU32(const ImVec4& col);                     // retrieve given color with style alpha applied
+IMGUI_API ImU32 GetColorU32(ImU32 col);                             // retrieve given color with style alpha applied
+
+// Parameters stacks (current window)
+IMGUI_API void PushItemWidth(float item_width);  // width of items for the common item+label case, pixels. 0.0f = default to ~2/3 of windows width, >0.0f: width in pixels, <0.0f align xx pixels to the right of window (so -1.0f always align width to the right side)
+IMGUI_API void PopItemWidth();
+IMGUI_API float CalcItemWidth();                          // width of item given pushed settings and current cursor position
+IMGUI_API void PushTextWrapPos(float wrap_pos_x = 0.0f);  // word-wrapping for Text*() commands. < 0.0f: no wrapping; 0.0f: wrap to end of window (or column); > 0.0f: wrap at 'wrap_pos_x' position in window local space
+IMGUI_API void PopTextWrapPos();
+IMGUI_API void PushAllowKeyboardFocus(bool allow_keyboard_focus);  // allow focusing using TAB/Shift-TAB, enabled by default but you can disable it for certain widgets
+IMGUI_API void PopAllowKeyboardFocus();
+IMGUI_API void PushButtonRepeat(bool repeat);  // in 'repeat' mode, Button*() functions return repeated true in a typematic manner (using io.KeyRepeatDelay/io.KeyRepeatRate setting). Note that you can call IsItemActive() after any Button() to tell if the button is held in the current frame.
+IMGUI_API void PopButtonRepeat();
+
+// Cursor / Layout
+IMGUI_API void Separator();                                            // separator, generally horizontal. inside a menu bar or in horizontal layout mode, this becomes a vertical separator.
+IMGUI_API void SameLine(float pos_x = 0.0f, float spacing_w = -1.0f);  // call between widgets or groups to layout them horizontally
+IMGUI_API void NewLine();                                              // undo a SameLine()
+IMGUI_API void Spacing();                                              // add vertical spacing
+IMGUI_API void Dummy(const ImVec2& size);                              // add a dummy item of given size
+IMGUI_API void Indent(float indent_w = 0.0f);                          // move content position toward the right, by style.IndentSpacing or indent_w if != 0
+IMGUI_API void Unindent(float indent_w = 0.0f);                        // move content position back to the left, by style.IndentSpacing or indent_w if != 0
+IMGUI_API void BeginGroup();                                           // lock horizontal starting position + capture group bounding box into one "item" (so you can use IsItemHovered() or layout primitives such as SameLine() on whole group, etc.)
+IMGUI_API void EndGroup();
+IMGUI_API ImVec2 GetCursorPos();                       // cursor position is relative to window position
+IMGUI_API float GetCursorPosX();                       // "
+IMGUI_API float GetCursorPosY();                       // "
+IMGUI_API void SetCursorPos(const ImVec2& local_pos);  // "
+IMGUI_API void SetCursorPosX(float x);                 // "
+IMGUI_API void SetCursorPosY(float y);                 // "
+IMGUI_API ImVec2 GetCursorStartPos();                  // initial cursor position
+IMGUI_API ImVec2 GetCursorScreenPos();                 // cursor position in absolute screen coordinates [0..io.DisplaySize] (useful to work with ImDrawList API)
+IMGUI_API void SetCursorScreenPos(const ImVec2& pos);  // cursor position in absolute screen coordinates [0..io.DisplaySize]
+IMGUI_API void AlignTextToFramePadding();              // vertically align/lower upcoming text to FramePadding.y so that it will aligns to upcoming widgets (call if you have text on a line before regular widgets)
+IMGUI_API float GetTextLineHeight();                   // ~ FontSize
+IMGUI_API float GetTextLineHeightWithSpacing();        // ~ FontSize + style.ItemSpacing.y (distance in pixels between 2 consecutive lines of text)
+IMGUI_API float GetFrameHeight();                      // ~ FontSize + style.FramePadding.y * 2
+IMGUI_API float GetFrameHeightWithSpacing();           // ~ FontSize + style.FramePadding.y * 2 + style.ItemSpacing.y (distance in pixels between 2 consecutive lines of framed widgets)
+
+// Columns
+// You can also use SameLine(pos_x) for simplified columns. The columns API is still work-in-progress and rather lacking.
+IMGUI_API void Columns(int count = 1, const char* id = NULL, bool border = true);
+IMGUI_API void NextColumn();                                       // next column, defaults to current row or next row if the current row is finished
+IMGUI_API int GetColumnIndex();                                    // get current column index
+IMGUI_API float GetColumnWidth(int column_index = -1);             // get column width (in pixels). pass -1 to use current column
+IMGUI_API void SetColumnWidth(int column_index, float width);      // set column width (in pixels). pass -1 to use current column
+IMGUI_API float GetColumnOffset(int column_index = -1);            // get position of column line (in pixels, from the left side of the contents region). pass -1 to use current column, otherwise 0..GetColumnsCount() inclusive. column 0 is typically 0.0f
+IMGUI_API void SetColumnOffset(int column_index, float offset_x);  // set position of column line (in pixels, from the left side of the contents region). pass -1 to use current column
+IMGUI_API int GetColumnsCount();
+
+// ID scopes
+// If you are creating widgets in a loop you most likely want to push a unique identifier (e.g. object pointer, loop index) so ImGui can differentiate them.
+// You can also use the "##foobar" syntax within widget label to distinguish them from each others. Read "A primer on the use of labels/IDs" in the FAQ for more details.
+IMGUI_API void PushID(const char* str_id);  // push identifier into the ID stack. IDs are hash of the entire stack!
+IMGUI_API void PushID(const char* str_id_begin, const char* str_id_end);
+IMGUI_API void PushID(const void* ptr_id);
+IMGUI_API void PushID(int int_id);
+IMGUI_API void PopID();
+IMGUI_API ImGuiID GetID(const char* str_id);  // calculate unique ID (hash of whole ID stack + given parameter). e.g. if you want to query into ImGuiStorage yourself
+IMGUI_API ImGuiID GetID(const char* str_id_begin, const char* str_id_end);
+IMGUI_API ImGuiID GetID(const void* ptr_id);
+
+// Widgets: Text
+IMGUI_API void TextUnformatted(const char* text, const char* text_end = NULL);  // raw text without formatting. Roughly equivalent to Text("%s", text) but: A) doesn't require null terminated string if 'text_end' is specified, B) it's faster, no memory copy is done, no buffer size limits, recommended for long chunks of text.
+IMGUI_API void Text(const char* fmt, ...) IM_FMTARGS(1);                        // simple formatted text
+IMGUI_API void TextV(const char* fmt, va_list args) IM_FMTLIST(1);
+IMGUI_API void TextColored(const ImVec4& col, const char* fmt, ...) IM_FMTARGS(2);  // shortcut for PushStyleColor(ImGuiCol_Text, col); Text(fmt, ...); PopStyleColor();
+IMGUI_API void TextColoredV(const ImVec4& col, const char* fmt, va_list args) IM_FMTLIST(2);
+IMGUI_API void TextDisabled(const char* fmt, ...) IM_FMTARGS(1);  // shortcut for PushStyleColor(ImGuiCol_Text, style.Colors[ImGuiCol_TextDisabled]); Text(fmt, ...); PopStyleColor();
+IMGUI_API void TextDisabledV(const char* fmt, va_list args) IM_FMTLIST(1);
+IMGUI_API void TextWrapped(const char* fmt, ...) IM_FMTARGS(1);  // shortcut for PushTextWrapPos(0.0f); Text(fmt, ...); PopTextWrapPos();. Note that this won't work on an auto-resizing window if there's no other widgets to extend the window width, yoy may need to set a size using SetNextWindowSize().
+IMGUI_API void TextWrappedV(const char* fmt, va_list args) IM_FMTLIST(1);
+IMGUI_API void LabelText(const char* label, const char* fmt, ...) IM_FMTARGS(2);  // display text+label aligned the same way as value+label widgets
+IMGUI_API void LabelTextV(const char* label, const char* fmt, va_list args) IM_FMTLIST(2);
+IMGUI_API void BulletText(const char* fmt, ...) IM_FMTARGS(1);  // shortcut for Bullet()+Text()
+IMGUI_API void BulletTextV(const char* fmt, va_list args) IM_FMTLIST(1);
+IMGUI_API void Bullet();  // draw a small circle and keep the cursor on the same line. advance cursor x position by GetTreeNodeToLabelSpacing(), same distance that TreeNode() uses
+
+// Widgets: Main
+IMGUI_API bool Button(const char* label, const ImVec2& size = ImVec2(0, 0));  // button
+IMGUI_API bool SmallButton(const char* label);                                // button with FramePadding=(0,0) to easily embed within text
+IMGUI_API bool InvisibleButton(const char* str_id, const ImVec2& size);       // button behavior without the visuals, useful to build custom behaviors using the public api (along with IsItemActive, IsItemHovered, etc.)
+IMGUI_API void Image(ImTextureID user_texture_id, const ImVec2& size, const ImVec2& uv0 = ImVec2(0, 0), const ImVec2& uv1 = ImVec2(1, 1), const ImVec4& tint_col = ImVec4(1, 1, 1, 1), const ImVec4& border_col = ImVec4(0, 0, 0, 0));
+IMGUI_API bool ImageButton(ImTextureID user_texture_id, const ImVec2& size, const ImVec2& uv0 = ImVec2(0, 0), const ImVec2& uv1 = ImVec2(1, 1), int frame_padding = -1, const ImVec4& bg_col = ImVec4(0, 0, 0, 0), const ImVec4& tint_col = ImVec4(1, 1, 1, 1));  // <0 frame_padding uses default frame padding settings. 0 for no padding
+IMGUI_API bool Checkbox(const char* label, bool* v);
+IMGUI_API bool CheckboxFlags(const char* label, unsigned int* flags, unsigned int flags_value);
+IMGUI_API bool RadioButton(const char* label, bool active);
+IMGUI_API bool RadioButton(const char* label, int* v, int v_button);
+IMGUI_API void PlotLines(const char* label, const float* values, int values_count, int values_offset = 0, const char* overlay_text = NULL, float scale_min = FLT_MAX, float scale_max = FLT_MAX, ImVec2 graph_size = ImVec2(0, 0), int stride = sizeof(float));
+IMGUI_API void PlotLines(const char* label, float (*values_getter)(void* data, int idx), void* data, int values_count, int values_offset = 0, const char* overlay_text = NULL, float scale_min = FLT_MAX, float scale_max = FLT_MAX, ImVec2 graph_size = ImVec2(0, 0));
+IMGUI_API void PlotHistogram(const char* label, const float* values, int values_count, int values_offset = 0, const char* overlay_text = NULL, float scale_min = FLT_MAX, float scale_max = FLT_MAX, ImVec2 graph_size = ImVec2(0, 0), int stride = sizeof(float));
+IMGUI_API void PlotHistogram(const char* label, float (*values_getter)(void* data, int idx), void* data, int values_count, int values_offset = 0, const char* overlay_text = NULL, float scale_min = FLT_MAX, float scale_max = FLT_MAX, ImVec2 graph_size = ImVec2(0, 0));
+IMGUI_API void ProgressBar(float fraction, const ImVec2& size_arg = ImVec2(-1, 0), const char* overlay = NULL);
+
+// Widgets: Combo Box
+// The new BeginCombo()/EndCombo() api allows you to manage your contents and selection state however you want it.
+// The old Combo() api are helpers over BeginCombo()/EndCombo() which are kept available for convenience purpose.
+IMGUI_API bool BeginCombo(const char* label, const char* preview_value, ImGuiComboFlags flags = 0);
+IMGUI_API void EndCombo();  // only call EndCombo() if BeginCombo() returns true!
+IMGUI_API bool Combo(const char* label, int* current_item, const char* const items[], int items_count, int popup_max_height_in_items = -1);
+IMGUI_API bool Combo(const char* label, int* current_item, const char* items_separated_by_zeros, int popup_max_height_in_items = -1);  // Separate items with \0 within a string, end item-list with \0\0. e.g. "One\0Two\0Three\0"
+IMGUI_API bool Combo(const char* label, int* current_item, bool (*items_getter)(void* data, int idx, const char** out_text), void* data, int items_count, int popup_max_height_in_items = -1);
+
+// Widgets: Drags (tip: ctrl+click on a drag box to input with keyboard. manually input values aren't clamped, can go off-bounds)
+// For all the Float2/Float3/Float4/Int2/Int3/Int4 versions of every functions, note that a 'float v[X]' function argument is the same as 'float* v', the array syntax is just a way to document the number of elements that are expected to be accessible. You can pass address of your first element out of a contiguous set, e.g. &myvector.x
+// Speed are per-pixel of mouse movement (v_speed=0.2f: mouse needs to move by 5 pixels to increase value by 1). For gamepad/keyboard navigation, minimum speed is Max(v_speed, minimum_step_at_given_precision).
+IMGUI_API bool DragFloat(const char* label, float* v, float v_speed = 1.0f, float v_min = 0.0f, float v_max = 0.0f, const char* display_format = "%.3f", float power = 1.0f);  // If v_min >= v_max we have no bound
+IMGUI_API bool DragFloat2(const char* label, float v[2], float v_speed = 1.0f, float v_min = 0.0f, float v_max = 0.0f, const char* display_format = "%.3f", float power = 1.0f);
+IMGUI_API bool DragFloat3(const char* label, float v[3], float v_speed = 1.0f, float v_min = 0.0f, float v_max = 0.0f, const char* display_format = "%.3f", float power = 1.0f);
+IMGUI_API bool DragFloat4(const char* label, float v[4], float v_speed = 1.0f, float v_min = 0.0f, float v_max = 0.0f, const char* display_format = "%.3f", float power = 1.0f);
+IMGUI_API bool DragFloatRange2(const char* label, float* v_current_min, float* v_current_max, float v_speed = 1.0f, float v_min = 0.0f, float v_max = 0.0f, const char* display_format = "%.3f", const char* display_format_max = NULL, float power = 1.0f);
+IMGUI_API bool DragInt(const char* label, int* v, float v_speed = 1.0f, int v_min = 0, int v_max = 0, const char* display_format = "%.0f");  // If v_min >= v_max we have no bound
+IMGUI_API bool DragInt2(const char* label, int v[2], float v_speed = 1.0f, int v_min = 0, int v_max = 0, const char* display_format = "%.0f");
+IMGUI_API bool DragInt3(const char* label, int v[3], float v_speed = 1.0f, int v_min = 0, int v_max = 0, const char* display_format = "%.0f");
+IMGUI_API bool DragInt4(const char* label, int v[4], float v_speed = 1.0f, int v_min = 0, int v_max = 0, const char* display_format = "%.0f");
+IMGUI_API bool DragIntRange2(const char* label, int* v_current_min, int* v_current_max, float v_speed = 1.0f, int v_min = 0, int v_max = 0, const char* display_format = "%.0f", const char* display_format_max = NULL);
+
+// Widgets: Input with Keyboard
+IMGUI_API bool InputText(const char* label, char* buf, size_t buf_size, ImGuiInputTextFlags flags = 0, ImGuiTextEditCallback callback = NULL, void* user_data = NULL);
+IMGUI_API bool InputTextMultiline(const char* label, char* buf, size_t buf_size, const ImVec2& size = ImVec2(0, 0), ImGuiInputTextFlags flags = 0, ImGuiTextEditCallback callback = NULL, void* user_data = NULL);
+IMGUI_API bool InputFloat(const char* label, float* v, float step = 0.0f, float step_fast = 0.0f, int decimal_precision = -1, ImGuiInputTextFlags extra_flags = 0);
+IMGUI_API bool InputFloat2(const char* label, float v[2], int decimal_precision = -1, ImGuiInputTextFlags extra_flags = 0);
+IMGUI_API bool InputFloat3(const char* label, float v[3], int decimal_precision = -1, ImGuiInputTextFlags extra_flags = 0);
+IMGUI_API bool InputFloat4(const char* label, float v[4], int decimal_precision = -1, ImGuiInputTextFlags extra_flags = 0);
+IMGUI_API bool InputInt(const char* label, int* v, int step = 1, int step_fast = 100, ImGuiInputTextFlags extra_flags = 0);
+IMGUI_API bool InputInt2(const char* label, int v[2], ImGuiInputTextFlags extra_flags = 0);
+IMGUI_API bool InputInt3(const char* label, int v[3], ImGuiInputTextFlags extra_flags = 0);
+IMGUI_API bool InputInt4(const char* label, int v[4], ImGuiInputTextFlags extra_flags = 0);
+
+// Widgets: Sliders (tip: ctrl+click on a slider to input with keyboard. manually input values aren't clamped, can go off-bounds)
+IMGUI_API bool SliderFloat(const char* label, float* v, float v_min, float v_max, const char* display_format = "%.3f", float power = 1.0f);  // adjust display_format to decorate the value with a prefix or a suffix for in-slider labels or unit display. Use power!=1.0 for logarithmic sliders
+IMGUI_API bool SliderFloat2(const char* label, float v[2], float v_min, float v_max, const char* display_format = "%.3f", float power = 1.0f);
+IMGUI_API bool SliderFloat3(const char* label, float v[3], float v_min, float v_max, const char* display_format = "%.3f", float power = 1.0f);
+IMGUI_API bool SliderFloat4(const char* label, float v[4], float v_min, float v_max, const char* display_format = "%.3f", float power = 1.0f);
+IMGUI_API bool SliderAngle(const char* label, float* v_rad, float v_degrees_min = -360.0f, float v_degrees_max = +360.0f);
+IMGUI_API bool SliderInt(const char* label, int* v, int v_min, int v_max, const char* display_format = "%.0f");
+IMGUI_API bool SliderInt2(const char* label, int v[2], int v_min, int v_max, const char* display_format = "%.0f");
+IMGUI_API bool SliderInt3(const char* label, int v[3], int v_min, int v_max, const char* display_format = "%.0f");
+IMGUI_API bool SliderInt4(const char* label, int v[4], int v_min, int v_max, const char* display_format = "%.0f");
+IMGUI_API bool VSliderFloat(const char* label, const ImVec2& size, float* v, float v_min, float v_max, const char* display_format = "%.3f", float power = 1.0f);
+IMGUI_API bool VSliderInt(const char* label, const ImVec2& size, int* v, int v_min, int v_max, const char* display_format = "%.0f");
+
+// Widgets: Color Editor/Picker (tip: the ColorEdit* functions have a little colored preview square that can be left-clicked to open a picker, and right-clicked to open an option menu.)
+// Note that a 'float v[X]' function argument is the same as 'float* v', the array syntax is just a way to document the number of elements that are expected to be accessible. You can the pass the address of a first float element out of a contiguous structure, e.g. &myvector.x
+IMGUI_API bool ColorEdit3(const char* label, float col[3], ImGuiColorEditFlags flags = 0);
+IMGUI_API bool ColorEdit4(const char* label, float col[4], ImGuiColorEditFlags flags = 0);
+IMGUI_API bool ColorPicker3(const char* label, float col[3], ImGuiColorEditFlags flags = 0);
+IMGUI_API bool ColorPicker4(const char* label, float col[4], ImGuiColorEditFlags flags = 0, const float* ref_col = NULL);
+IMGUI_API bool ColorButton(const char* desc_id, const ImVec4& col, ImGuiColorEditFlags flags = 0, ImVec2 size = ImVec2(0, 0));  // display a colored square/button, hover for details, return true when pressed.
+IMGUI_API void SetColorEditOptions(ImGuiColorEditFlags flags);                                                                  // initialize current options (generally on application startup) if you want to select a default format, picker type, etc. User will be able to change many settings, unless you pass the _NoOptions flag to your calls.
+
+// Widgets: Trees
+IMGUI_API bool TreeNode(const char* label);                                       // if returning 'true' the node is open and the tree id is pushed into the id stack. user is responsible for calling TreePop().
+IMGUI_API bool TreeNode(const char* str_id, const char* fmt, ...) IM_FMTARGS(2);  // read the FAQ about why and how to use ID. to align arbitrary text at the same level as a TreeNode() you can use Bullet().
+IMGUI_API bool TreeNode(const void* ptr_id, const char* fmt, ...) IM_FMTARGS(2);  // "
+IMGUI_API bool TreeNodeV(const char* str_id, const char* fmt, va_list args) IM_FMTLIST(2);
+IMGUI_API bool TreeNodeV(const void* ptr_id, const char* fmt, va_list args) IM_FMTLIST(2);
+IMGUI_API bool TreeNodeEx(const char* label, ImGuiTreeNodeFlags flags = 0);
+IMGUI_API bool TreeNodeEx(const char* str_id, ImGuiTreeNodeFlags flags, const char* fmt, ...) IM_FMTARGS(3);
+IMGUI_API bool TreeNodeEx(const void* ptr_id, ImGuiTreeNodeFlags flags, const char* fmt, ...) IM_FMTARGS(3);
+IMGUI_API bool TreeNodeExV(const char* str_id, ImGuiTreeNodeFlags flags, const char* fmt, va_list args) IM_FMTLIST(3);
+IMGUI_API bool TreeNodeExV(const void* ptr_id, ImGuiTreeNodeFlags flags, const char* fmt, va_list args) IM_FMTLIST(3);
+IMGUI_API void TreePush(const char* str_id);                                                     // ~ Indent()+PushId(). Already called by TreeNode() when returning true, but you can call Push/Pop yourself for layout purpose
+IMGUI_API void TreePush(const void* ptr_id = NULL);                                              // "
+IMGUI_API void TreePop();                                                                        // ~ Unindent()+PopId()
+IMGUI_API void TreeAdvanceToLabelPos();                                                          // advance cursor x position by GetTreeNodeToLabelSpacing()
+IMGUI_API float GetTreeNodeToLabelSpacing();                                                     // horizontal distance preceding label when using TreeNode*() or Bullet() == (g.FontSize + style.FramePadding.x*2) for a regular unframed TreeNode
+IMGUI_API void SetNextTreeNodeOpen(bool is_open, ImGuiCond cond = 0);                            // set next TreeNode/CollapsingHeader open state.
+IMGUI_API bool CollapsingHeader(const char* label, ImGuiTreeNodeFlags flags = 0);                // if returning 'true' the header is open. doesn't indent nor push on ID stack. user doesn't have to call TreePop().
+IMGUI_API bool CollapsingHeader(const char* label, bool* p_open, ImGuiTreeNodeFlags flags = 0);  // when 'p_open' isn't NULL, display an additional small close button on upper right of the header
+
+// Widgets: Selectable / Lists
+IMGUI_API bool Selectable(const char* label, bool selected = false, ImGuiSelectableFlags flags = 0, const ImVec2& size = ImVec2(0, 0));  // "bool selected" carry the selection state (read-only). Selectable() is clicked is returns true so you can modify your selection state. size.x==0.0: use remaining width, size.x>0.0: specify width. size.y==0.0: use label height, size.y>0.0: specify height
+IMGUI_API bool Selectable(const char* label, bool* p_selected, ImGuiSelectableFlags flags = 0, const ImVec2& size = ImVec2(0, 0));       // "bool* p_selected" point to the selection state (read-write), as a convenient helper.
+IMGUI_API bool ListBox(const char* label, int* current_item, const char* const items[], int items_count, int height_in_items = -1);
+IMGUI_API bool ListBox(const char* label, int* current_item, bool (*items_getter)(void* data, int idx, const char** out_text), void* data, int items_count, int height_in_items = -1);
+IMGUI_API bool ListBoxHeader(const char* label, const ImVec2& size = ImVec2(0, 0));          // use if you want to reimplement ListBox() will custom data or interactions. make sure to call ListBoxFooter() afterwards.
+IMGUI_API bool ListBoxHeader(const char* label, int items_count, int height_in_items = -1);  // "
+IMGUI_API void ListBoxFooter();                                                              // terminate the scrolling region
+
+// Widgets: Value() Helpers. Output single value in "name: value" format (tip: freely declare more in your code to handle your types. you can add functions to the ImGui namespace)
+IMGUI_API void Value(const char* prefix, bool b);
+IMGUI_API void Value(const char* prefix, int v);
+IMGUI_API void Value(const char* prefix, unsigned int v);
+IMGUI_API void Value(const char* prefix, float v, const char* float_format = NULL);
+
+// Tooltips
+IMGUI_API void SetTooltip(const char* fmt, ...) IM_FMTARGS(1);  // set text tooltip under mouse-cursor, typically use with ImGui::IsItemHovered(). overidde any previous call to SetTooltip().
+IMGUI_API void SetTooltipV(const char* fmt, va_list args) IM_FMTLIST(1);
+IMGUI_API void BeginTooltip();  // begin/append a tooltip window. to create full-featured tooltip (with any kind of contents).
+IMGUI_API void EndTooltip();
+
+// Menus
+IMGUI_API bool BeginMainMenuBar();                                                                                    // create and append to a full screen menu-bar.
+IMGUI_API void EndMainMenuBar();                                                                                      // only call EndMainMenuBar() if BeginMainMenuBar() returns true!
+IMGUI_API bool BeginMenuBar();                                                                                        // append to menu-bar of current window (requires ImGuiWindowFlags_MenuBar flag set on parent window).
+IMGUI_API void EndMenuBar();                                                                                          // only call EndMenuBar() if BeginMenuBar() returns true!
+IMGUI_API bool BeginMenu(const char* label, bool enabled = true);                                                     // create a sub-menu entry. only call EndMenu() if this returns true!
+IMGUI_API void EndMenu();                                                                                             // only call EndBegin() if BeginMenu() returns true!
+IMGUI_API bool MenuItem(const char* label, const char* shortcut = NULL, bool selected = false, bool enabled = true);  // return true when activated. shortcuts are displayed for convenience but not processed by ImGui at the moment
+IMGUI_API bool MenuItem(const char* label, const char* shortcut, bool* p_selected, bool enabled = true);              // return true when activated + toggle (*p_selected) if p_selected != NULL
+
+// Popups
+IMGUI_API void OpenPopup(const char* str_id);                                                                          // call to mark popup as open (don't call every frame!). popups are closed when user click outside, or if CloseCurrentPopup() is called within a BeginPopup()/EndPopup() block. By default, Selectable()/MenuItem() are calling CloseCurrentPopup(). Popup identifiers are relative to the current ID-stack (so OpenPopup and BeginPopup needs to be at the same level).
+IMGUI_API bool BeginPopup(const char* str_id, ImGuiWindowFlags flags = 0);                                             // return true if the popup is open, and you can start outputting to it. only call EndPopup() if BeginPopup() returns true!
+IMGUI_API bool BeginPopupContextItem(const char* str_id = NULL, int mouse_button = 1);                                 // helper to open and begin popup when clicked on last item. if you can pass a NULL str_id only if the previous item had an id. If you want to use that on a non-interactive item such as Text() you need to pass in an explicit ID here. read comments in .cpp!
+IMGUI_API bool BeginPopupContextWindow(const char* str_id = NULL, int mouse_button = 1, bool also_over_items = true);  // helper to open and begin popup when clicked on current window.
+IMGUI_API bool BeginPopupContextVoid(const char* str_id = NULL, int mouse_button = 1);                                 // helper to open and begin popup when clicked in void (where there are no imgui windows).
+IMGUI_API bool BeginPopupModal(const char* name, bool* p_open = NULL, ImGuiWindowFlags flags = 0);                     // modal dialog (regular window with title bar, block interactions behind the modal window, can't close the modal window by clicking outside)
+IMGUI_API void EndPopup();                                                                                             // only call EndPopup() if BeginPopupXXX() returns true!
+IMGUI_API bool OpenPopupOnItemClick(const char* str_id = NULL, int mouse_button = 1);                                  // helper to open popup when clicked on last item. return true when just opened.
+IMGUI_API bool IsPopupOpen(const char* str_id);                                                                        // return true if the popup is open
+IMGUI_API void CloseCurrentPopup();                                                                                    // close the popup we have begin-ed into. clicking on a MenuItem or Selectable automatically close the current popup.
+
+// Logging/Capture: all text output from interface is captured to tty/file/clipboard. By default, tree nodes are automatically opened during logging.
+IMGUI_API void LogToTTY(int max_depth = -1);                                // start logging to tty
+IMGUI_API void LogToFile(int max_depth = -1, const char* filename = NULL);  // start logging to file
+IMGUI_API void LogToClipboard(int max_depth = -1);                          // start logging to OS clipboard
+IMGUI_API void LogFinish();                                                 // stop logging (close file, etc.)
+IMGUI_API void LogButtons();                                                // helper to display buttons for logging to tty/file/clipboard
+IMGUI_API void LogText(const char* fmt, ...) IM_FMTARGS(1);                 // pass text data straight to log (without being displayed)
+
+// Drag and Drop
+// [BETA API] Missing Demo code. API may evolve.
+IMGUI_API bool BeginDragDropSource(ImGuiDragDropFlags flags = 0);                                        // call when the current item is active. If this return true, you can call SetDragDropPayload() + EndDragDropSource()
+IMGUI_API bool SetDragDropPayload(const char* type, const void* data, size_t size, ImGuiCond cond = 0);  // type is a user defined string of maximum 12 characters. Strings starting with '_' are reserved for dear imgui internal types. Data is copied and held by imgui.
+IMGUI_API void EndDragDropSource();                                                                      // only call EndDragDropSource() if BeginDragDropSource() returns true!
+IMGUI_API bool BeginDragDropTarget();                                                                    // call after submitting an item that may receive an item. If this returns true, you can call AcceptDragDropPayload() + EndDragDropTarget()
+IMGUI_API const ImGuiPayload* AcceptDragDropPayload(const char* type, ImGuiDragDropFlags flags = 0);     // accept contents of a given type. If ImGuiDragDropFlags_AcceptBeforeDelivery is set you can peek into the payload before the mouse button is released.
+IMGUI_API void EndDragDropTarget();                                                                      // only call EndDragDropTarget() if BeginDragDropTarget() returns true!
+
+// Clipping
+IMGUI_API void PushClipRect(const ImVec2& clip_rect_min, const ImVec2& clip_rect_max, bool intersect_with_current_clip_rect);
+IMGUI_API void PopClipRect();
+
+// Focus, Activation
+// (Prefer using "SetItemDefaultFocus()" over "if (IsWindowAppearing()) SetScrollHere()" when applicable, to make your code more forward compatible when navigation branch is merged)
+IMGUI_API void SetItemDefaultFocus();                 // make last item the default focused item of a window. Please use instead of "if (IsWindowAppearing()) SetScrollHere()" to signify "default item".
+IMGUI_API void SetKeyboardFocusHere(int offset = 0);  // focus keyboard on the next widget. Use positive 'offset' to access sub components of a multiple component widget. Use -1 to access previous widget.
+
+// Utilities
+IMGUI_API bool IsItemHovered(ImGuiHoveredFlags flags = 0);  // is the last item hovered? (and usable, aka not blocked by a popup, etc.). See ImGuiHoveredFlags for more options.
+IMGUI_API bool IsItemActive();                              // is the last item active? (e.g. button being held, text field being edited- items that don't interact will always return false)
+IMGUI_API bool IsItemFocused();                             // is the last item focused for keyboard/gamepad navigation?
+IMGUI_API bool IsItemClicked(int mouse_button = 0);         // is the last item clicked? (e.g. button/node just clicked on)
+IMGUI_API bool IsItemVisible();                             // is the last item visible? (aka not out of sight due to clipping/scrolling.)
+IMGUI_API bool IsAnyItemHovered();
+IMGUI_API bool IsAnyItemActive();
+IMGUI_API bool IsAnyItemFocused();
+IMGUI_API ImVec2 GetItemRectMin();                                             // get bounding rectangle of last item, in screen space
+IMGUI_API ImVec2 GetItemRectMax();                                             // "
+IMGUI_API ImVec2 GetItemRectSize();                                            // get size of last item, in screen space
+IMGUI_API void SetItemAllowOverlap();                                          // allow last item to be overlapped by a subsequent item. sometimes useful with invisible buttons, selectables, etc. to catch unused area.
+IMGUI_API bool IsWindowFocused(ImGuiFocusedFlags flags = 0);                   // is current window focused? or its root/child, depending on flags. see flags for options.
+IMGUI_API bool IsWindowHovered(ImGuiHoveredFlags flags = 0);                   // is current window hovered (and typically: not blocked by a popup/modal)? see flags for options.
+IMGUI_API bool IsRectVisible(const ImVec2& size);                              // test if rectangle (of given size, starting from cursor position) is visible / not clipped.
+IMGUI_API bool IsRectVisible(const ImVec2& rect_min, const ImVec2& rect_max);  // test if rectangle (in screen space) is visible / not clipped. to perform coarse clipping on user's side.
+IMGUI_API float GetTime();
+IMGUI_API int GetFrameCount();
+IMGUI_API ImDrawList* GetOverlayDrawList();  // this draw list will be the last rendered one, useful to quickly draw overlays shapes/text
+IMGUI_API ImDrawListSharedData* GetDrawListSharedData();
+IMGUI_API const char* GetStyleColorName(ImGuiCol idx);
+IMGUI_API ImVec2 CalcTextSize(const char* text, const char* text_end = NULL, bool hide_text_after_double_hash = false, float wrap_width = -1.0f);
+IMGUI_API void CalcListClipping(int items_count, float items_height, int* out_items_display_start, int* out_items_display_end);  // calculate coarse clipping for large list of evenly sized items. Prefer using the ImGuiListClipper higher-level helper if you can.
+
+IMGUI_API bool BeginChildFrame(ImGuiID id, const ImVec2& size, ImGuiWindowFlags flags = 0);  // helper to create a child window / scrolling region that looks like a normal widget frame
+IMGUI_API void EndChildFrame();                                                              // always call EndChildFrame() regardless of BeginChildFrame() return values (which indicates a collapsed/clipped window)
+
+IMGUI_API ImVec4 ColorConvertU32ToFloat4(ImU32 in);
+IMGUI_API ImU32 ColorConvertFloat4ToU32(const ImVec4& in);
+IMGUI_API void ColorConvertRGBtoHSV(float r, float g, float b, float& out_h, float& out_s, float& out_v);
+IMGUI_API void ColorConvertHSVtoRGB(float h, float s, float v, float& out_r, float& out_g, float& out_b);
+
+// Inputs
+IMGUI_API int GetKeyIndex(ImGuiKey imgui_key);                                                   // map ImGuiKey_* values into user's key index. == io.KeyMap[key]
+IMGUI_API bool IsKeyDown(int user_key_index);                                                    // is key being held. == io.KeysDown[user_key_index]. note that imgui doesn't know the semantic of each entry of io.KeyDown[]. Use your own indices/enums according to how your backend/engine stored them into KeyDown[]!
+IMGUI_API bool IsKeyPressed(int user_key_index, bool repeat = true);                             // was key pressed (went from !Down to Down). if repeat=true, uses io.KeyRepeatDelay / KeyRepeatRate
+IMGUI_API bool IsKeyReleased(int user_key_index);                                                // was key released (went from Down to !Down)..
+IMGUI_API int GetKeyPressedAmount(int key_index, float repeat_delay, float rate);                // uses provided repeat rate/delay. return a count, most often 0 or 1 but might be >1 if RepeatRate is small enough that DeltaTime > RepeatRate
+IMGUI_API bool IsMouseDown(int button);                                                          // is mouse button held
+IMGUI_API bool IsAnyMouseDown();                                                                 // is any mouse button held
+IMGUI_API bool IsMouseClicked(int button, bool repeat = false);                                  // did mouse button clicked (went from !Down to Down)
+IMGUI_API bool IsMouseDoubleClicked(int button);                                                 // did mouse button double-clicked. a double-click returns false in IsMouseClicked(). uses io.MouseDoubleClickTime.
+IMGUI_API bool IsMouseReleased(int button);                                                      // did mouse button released (went from Down to !Down)
+IMGUI_API bool IsMouseDragging(int button = 0, float lock_threshold = -1.0f);                    // is mouse dragging. if lock_threshold < -1.0f uses io.MouseDraggingThreshold
+IMGUI_API bool IsMouseHoveringRect(const ImVec2& r_min, const ImVec2& r_max, bool clip = true);  // is mouse hovering given bounding rect (in screen space). clipped by current clipping settings. disregarding of consideration of focus/window ordering/blocked by a popup.
+IMGUI_API bool IsMousePosValid(const ImVec2* mouse_pos = NULL);                                  //
+IMGUI_API ImVec2 GetMousePos();                                                                  // shortcut to ImGui::GetIO().MousePos provided by user, to be consistent with other calls
+IMGUI_API ImVec2 GetMousePosOnOpeningCurrentPopup();                                             // retrieve backup of mouse positioning at the time of opening popup we have BeginPopup() into
+IMGUI_API ImVec2 GetMouseDragDelta(int button = 0, float lock_threshold = -1.0f);                // dragging amount since clicking. if lock_threshold < -1.0f uses io.MouseDraggingThreshold
+IMGUI_API void ResetMouseDragDelta(int button = 0);                                              //
+IMGUI_API ImGuiMouseCursor GetMouseCursor();                                                     // get desired cursor type, reset in ImGui::NewFrame(), this is updated during the frame. valid before Render(). If you use software rendering by setting io.MouseDrawCursor ImGui will render those for you
+IMGUI_API void SetMouseCursor(ImGuiMouseCursor type);                                            // set desired cursor type
+IMGUI_API void CaptureKeyboardFromApp(bool capture = true);                                      // manually override io.WantCaptureKeyboard flag next frame (said flag is entirely left for your application handle). e.g. force capture keyboard when your widget is being hovered.
+IMGUI_API void CaptureMouseFromApp(bool capture = true);                                         // manually override io.WantCaptureMouse flag next frame (said flag is entirely left for your application handle).
+
+// Clipboard Utilities (also see the LogToClipboard() function to capture or output text data to the clipboard)
+IMGUI_API const char* GetClipboardText();
+IMGUI_API void SetClipboardText(const char* text);
+
+// Memory Utilities
+// All those functions are not reliant on the current context.
+// If you reload the contents of imgui.cpp at runtime, you may need to call SetCurrentContext() + SetAllocatorFunctions() again.
+IMGUI_API void SetAllocatorFunctions(void* (*alloc_func)(size_t sz, void* user_data), void (*free_func)(void* ptr, void* user_data), void* user_data = NULL);
+IMGUI_API void* MemAlloc(size_t size);
+IMGUI_API void MemFree(void* ptr);
+
+}  // namespace ImGui
+
+// Flags for ImGui::Begin()
+enum ImGuiWindowFlags_
+{
+	ImGuiWindowFlags_NoTitleBar = 1 << 0,         // Disable title-bar
+	ImGuiWindowFlags_NoResize = 1 << 1,           // Disable user resizing with the lower-right grip
+	ImGuiWindowFlags_NoMove = 1 << 2,             // Disable user moving the window
+	ImGuiWindowFlags_NoScrollbar = 1 << 3,        // Disable scrollbars (window can still scroll with mouse or programatically)
+	ImGuiWindowFlags_NoScrollWithMouse = 1 << 4,  // Disable user vertically scrolling with mouse wheel. On child window, mouse wheel will be forwarded to the parent unless NoScrollbar is also set.
+	ImGuiWindowFlags_NoCollapse = 1 << 5,         // Disable user collapsing window by double-clicking on it
+	ImGuiWindowFlags_AlwaysAutoResize = 1 << 6,   // Resize every window to its content every frame
+	//ImGuiWindowFlags_ShowBorders          = 1 << 7,   // Show borders around windows and items (OBSOLETE! Use e.g. style.FrameBorderSize=1.0f to enable borders).
+	ImGuiWindowFlags_NoSavedSettings = 1 << 8,             // Never load/save settings in .ini file
+	ImGuiWindowFlags_NoInputs = 1 << 9,                    // Disable catching mouse or keyboard inputs, hovering test with pass through.
+	ImGuiWindowFlags_MenuBar = 1 << 10,                    // Has a menu-bar
+	ImGuiWindowFlags_HorizontalScrollbar = 1 << 11,        // Allow horizontal scrollbar to appear (off by default). You may use SetNextWindowContentSize(ImVec2(width,0.0f)); prior to calling Begin() to specify width. Read code in imgui_demo in the "Horizontal Scrolling" section.
+	ImGuiWindowFlags_NoFocusOnAppearing = 1 << 12,         // Disable taking focus when transitioning from hidden to visible state
+	ImGuiWindowFlags_NoBringToFrontOnFocus = 1 << 13,      // Disable bringing window to front when taking focus (e.g. clicking on it or programatically giving it focus)
+	ImGuiWindowFlags_AlwaysVerticalScrollbar = 1 << 14,    // Always show vertical scrollbar (even if ContentSize.y < Size.y)
+	ImGuiWindowFlags_AlwaysHorizontalScrollbar = 1 << 15,  // Always show horizontal scrollbar (even if ContentSize.x < Size.x)
+	ImGuiWindowFlags_AlwaysUseWindowPadding = 1 << 16,     // Ensure child windows without border uses style.WindowPadding (ignored by default for non-bordered child windows, because more convenient)
+	ImGuiWindowFlags_ResizeFromAnySide = 1 << 17,          // (WIP) Enable resize from any corners and borders. Your back-end needs to honor the different values of io.MouseCursor set by imgui.
+	ImGuiWindowFlags_NoNavInputs = 1 << 18,                // No gamepad/keyboard navigation within the window
+	ImGuiWindowFlags_NoNavFocus = 1 << 19,                 // No focusing toward this window with gamepad/keyboard navigation (e.g. skipped by CTRL+TAB)
+	ImGuiWindowFlags_NoNav = ImGuiWindowFlags_NoNavInputs | ImGuiWindowFlags_NoNavFocus,
+
+	// [Internal]
+	ImGuiWindowFlags_NavFlattened = 1 << 23,  // (WIP) Allow gamepad/keyboard navigation to cross over parent border to this child (only use on child that have no scrolling!)
+	ImGuiWindowFlags_ChildWindow = 1 << 24,   // Don't use! For internal use by BeginChild()
+	ImGuiWindowFlags_Tooltip = 1 << 25,       // Don't use! For internal use by BeginTooltip()
+	ImGuiWindowFlags_Popup = 1 << 26,         // Don't use! For internal use by BeginPopup()
+	ImGuiWindowFlags_Modal = 1 << 27,         // Don't use! For internal use by BeginPopupModal()
+	ImGuiWindowFlags_ChildMenu = 1 << 28      // Don't use! For internal use by BeginMenu()
+};
+
+// Flags for ImGui::InputText()
+enum ImGuiInputTextFlags_
+{
+	ImGuiInputTextFlags_CharsDecimal = 1 << 0,          // Allow 0123456789.+-*/
+	ImGuiInputTextFlags_CharsHexadecimal = 1 << 1,      // Allow 0123456789ABCDEFabcdef
+	ImGuiInputTextFlags_CharsUppercase = 1 << 2,        // Turn a..z into A..Z
+	ImGuiInputTextFlags_CharsNoBlank = 1 << 3,          // Filter out spaces, tabs
+	ImGuiInputTextFlags_AutoSelectAll = 1 << 4,         // Select entire text when first taking mouse focus
+	ImGuiInputTextFlags_EnterReturnsTrue = 1 << 5,      // Return 'true' when Enter is pressed (as opposed to when the value was modified)
+	ImGuiInputTextFlags_CallbackCompletion = 1 << 6,    // Call user function on pressing TAB (for completion handling)
+	ImGuiInputTextFlags_CallbackHistory = 1 << 7,       // Call user function on pressing Up/Down arrows (for history handling)
+	ImGuiInputTextFlags_CallbackAlways = 1 << 8,        // Call user function every time. User code may query cursor position, modify text buffer.
+	ImGuiInputTextFlags_CallbackCharFilter = 1 << 9,    // Call user function to filter character. Modify data->EventChar to replace/filter input, or return 1 to discard character.
+	ImGuiInputTextFlags_AllowTabInput = 1 << 10,        // Pressing TAB input a '\t' character into the text field
+	ImGuiInputTextFlags_CtrlEnterForNewLine = 1 << 11,  // In multi-line mode, unfocus with Enter, add new line with Ctrl+Enter (default is opposite: unfocus with Ctrl+Enter, add line with Enter).
+	ImGuiInputTextFlags_NoHorizontalScroll = 1 << 12,   // Disable following the cursor horizontally
+	ImGuiInputTextFlags_AlwaysInsertMode = 1 << 13,     // Insert mode
+	ImGuiInputTextFlags_ReadOnly = 1 << 14,             // Read-only mode
+	ImGuiInputTextFlags_Password = 1 << 15,             // Password mode, display all characters as '*'
+	ImGuiInputTextFlags_NoUndoRedo = 1 << 16,           // Disable undo/redo. Note that input text owns the text data while active, if you want to provide your own undo/redo stack you need e.g. to call ClearActiveID().
+	// [Internal]
+	ImGuiInputTextFlags_Multiline = 1 << 20  // For internal use by InputTextMultiline()
+};
+
+// Flags for ImGui::TreeNodeEx(), ImGui::CollapsingHeader*()
+enum ImGuiTreeNodeFlags_
+{
+	ImGuiTreeNodeFlags_Selected = 1 << 0,           // Draw as selected
+	ImGuiTreeNodeFlags_Framed = 1 << 1,             // Full colored frame (e.g. for CollapsingHeader)
+	ImGuiTreeNodeFlags_AllowItemOverlap = 1 << 2,   // Hit testing to allow subsequent widgets to overlap this one
+	ImGuiTreeNodeFlags_NoTreePushOnOpen = 1 << 3,   // Don't do a TreePush() when open (e.g. for CollapsingHeader) = no extra indent nor pushing on ID stack
+	ImGuiTreeNodeFlags_NoAutoOpenOnLog = 1 << 4,    // Don't automatically and temporarily open node when Logging is active (by default logging will automatically open tree nodes)
+	ImGuiTreeNodeFlags_DefaultOpen = 1 << 5,        // Default node to be open
+	ImGuiTreeNodeFlags_OpenOnDoubleClick = 1 << 6,  // Need double-click to open node
+	ImGuiTreeNodeFlags_OpenOnArrow = 1 << 7,        // Only open when clicking on the arrow part. If ImGuiTreeNodeFlags_OpenOnDoubleClick is also set, single-click arrow or double-click all box to open.
+	ImGuiTreeNodeFlags_Leaf = 1 << 8,               // No collapsing, no arrow (use as a convenience for leaf nodes).
+	ImGuiTreeNodeFlags_Bullet = 1 << 9,             // Display a bullet instead of arrow
+	ImGuiTreeNodeFlags_FramePadding = 1 << 10,      // Use FramePadding (even for an unframed text node) to vertically align text baseline to regular widget height. Equivalent to calling AlignTextToFramePadding().
+	//ImGuITreeNodeFlags_SpanAllAvailWidth  = 1 << 11,  // FIXME: TODO: Extend hit box horizontally even if not framed
+	//ImGuiTreeNodeFlags_NoScrollOnOpen     = 1 << 12,  // FIXME: TODO: Disable automatic scroll on TreePop() if node got just open and contents is not visible
+	ImGuiTreeNodeFlags_NavCloseFromChild = 1 << 13,  // (WIP) Nav: left direction may close this TreeNode() when focusing on any child (items submitted between TreeNode and TreePop)
+	ImGuiTreeNodeFlags_CollapsingHeader = ImGuiTreeNodeFlags_Framed | ImGuiTreeNodeFlags_NoAutoOpenOnLog
+
+// Obsolete names (will be removed)
+#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+	,
+	ImGuiTreeNodeFlags_AllowOverlapMode = ImGuiTreeNodeFlags_AllowItemOverlap
+#endif
+};
+
+// Flags for ImGui::Selectable()
+enum ImGuiSelectableFlags_
+{
+	ImGuiSelectableFlags_DontClosePopups = 1 << 0,  // Clicking this don't close parent popup window
+	ImGuiSelectableFlags_SpanAllColumns = 1 << 1,   // Selectable frame can span all columns (text will still fit in current column)
+	ImGuiSelectableFlags_AllowDoubleClick = 1 << 2  // Generate press events on double clicks too
+};
+
+// Flags for ImGui::BeginCombo()
+enum ImGuiComboFlags_
+{
+	ImGuiComboFlags_PopupAlignLeft = 1 << 0,  // Align the popup toward the left by default
+	ImGuiComboFlags_HeightSmall = 1 << 1,     // Max ~4 items visible. Tip: If you want your combo popup to be a specific size you can use SetNextWindowSizeConstraints() prior to calling BeginCombo()
+	ImGuiComboFlags_HeightRegular = 1 << 2,   // Max ~8 items visible (default)
+	ImGuiComboFlags_HeightLarge = 1 << 3,     // Max ~20 items visible
+	ImGuiComboFlags_HeightLargest = 1 << 4,   // As many fitting items as possible
+	ImGuiComboFlags_HeightMask_ = ImGuiComboFlags_HeightSmall | ImGuiComboFlags_HeightRegular | ImGuiComboFlags_HeightLarge | ImGuiComboFlags_HeightLargest
+};
+
+// Flags for ImGui::IsWindowFocused()
+enum ImGuiFocusedFlags_
+{
+	ImGuiFocusedFlags_ChildWindows = 1 << 0,  // IsWindowFocused(): Return true if any children of the window is focused
+	ImGuiFocusedFlags_RootWindow = 1 << 1,    // IsWindowFocused(): Test from root window (top most parent of the current hierarchy)
+	ImGuiFocusedFlags_AnyWindow = 1 << 2,     // IsWindowFocused(): Return true if any window is focused
+	ImGuiFocusedFlags_RootAndChildWindows = ImGuiFocusedFlags_RootWindow | ImGuiFocusedFlags_ChildWindows
+};
+
+// Flags for ImGui::IsItemHovered(), ImGui::IsWindowHovered()
+enum ImGuiHoveredFlags_
+{
+	ImGuiHoveredFlags_Default = 0,                       // Return true if directly over the item/window, not obstructed by another window, not obstructed by an active popup or modal blocking inputs under them.
+	ImGuiHoveredFlags_ChildWindows = 1 << 0,             // IsWindowHovered() only: Return true if any children of the window is hovered
+	ImGuiHoveredFlags_RootWindow = 1 << 1,               // IsWindowHovered() only: Test from root window (top most parent of the current hierarchy)
+	ImGuiHoveredFlags_AnyWindow = 1 << 2,                // IsWindowHovered() only: Return true if any window is hovered
+	ImGuiHoveredFlags_AllowWhenBlockedByPopup = 1 << 3,  // Return true even if a popup window is normally blocking access to this item/window
+	//ImGuiHoveredFlags_AllowWhenBlockedByModal     = 1 << 4,   // Return true even if a modal popup window is normally blocking access to this item/window. FIXME-TODO: Unavailable yet.
+	ImGuiHoveredFlags_AllowWhenBlockedByActiveItem = 1 << 5,  // Return true even if an active item is blocking access to this item/window. Useful for Drag and Drop patterns.
+	ImGuiHoveredFlags_AllowWhenOverlapped = 1 << 6,           // Return true even if the position is overlapped by another window
+	ImGuiHoveredFlags_RectOnly = ImGuiHoveredFlags_AllowWhenBlockedByPopup | ImGuiHoveredFlags_AllowWhenBlockedByActiveItem | ImGuiHoveredFlags_AllowWhenOverlapped,
+	ImGuiHoveredFlags_RootAndChildWindows = ImGuiHoveredFlags_RootWindow | ImGuiHoveredFlags_ChildWindows
+};
+
+// Flags for ImGui::BeginDragDropSource(), ImGui::AcceptDragDropPayload()
+enum ImGuiDragDropFlags_
+{
+	// BeginDragDropSource() flags
+	ImGuiDragDropFlags_SourceNoPreviewTooltip = 1 << 0,    // By default, a successful call to BeginDragDropSource opens a tooltip so you can display a preview or description of the source contents. This flag disable this behavior.
+	ImGuiDragDropFlags_SourceNoDisableHover = 1 << 1,      // By default, when dragging we clear data so that IsItemHovered() will return true, to avoid subsequent user code submitting tooltips. This flag disable this behavior so you can still call IsItemHovered() on the source item.
+	ImGuiDragDropFlags_SourceNoHoldToOpenOthers = 1 << 2,  // Disable the behavior that allows to open tree nodes and collapsing header by holding over them while dragging a source item.
+	ImGuiDragDropFlags_SourceAllowNullID = 1 << 3,         // Allow items such as Text(), Image() that have no unique identifier to be used as drag source, by manufacturing a temporary identifier based on their window-relative position. This is extremely unusual within the dear imgui ecosystem and so we made it explicit.
+	ImGuiDragDropFlags_SourceExtern = 1 << 4,              // External source (from outside of imgui), won't attempt to read current item/window info. Will always return true. Only one Extern source can be active simultaneously.
+	// AcceptDragDropPayload() flags
+	ImGuiDragDropFlags_AcceptBeforeDelivery = 1 << 10,                                                                        // AcceptDragDropPayload() will returns true even before the mouse button is released. You can then call IsDelivery() to test if the payload needs to be delivered.
+	ImGuiDragDropFlags_AcceptNoDrawDefaultRect = 1 << 11,                                                                     // Do not draw the default highlight rectangle when hovering over target.
+	ImGuiDragDropFlags_AcceptPeekOnly = ImGuiDragDropFlags_AcceptBeforeDelivery | ImGuiDragDropFlags_AcceptNoDrawDefaultRect  // For peeking ahead and inspecting the payload before delivery.
+};
+
+// Standard Drag and Drop payload types. You can define you own payload types using 12-characters long strings. Types starting with '_' are defined by Dear ImGui.
+#define IMGUI_PAYLOAD_TYPE_COLOR_3F "_COL3F"  // float[3]     // Standard type for colors, without alpha. User code may use this type.
+#define IMGUI_PAYLOAD_TYPE_COLOR_4F "_COL4F"  // float[4]     // Standard type for colors. User code may use this type.
+
+// User fill ImGuiIO.KeyMap[] array with indices into the ImGuiIO.KeysDown[512] array
+enum ImGuiKey_
+{
+	ImGuiKey_Tab,
+	ImGuiKey_LeftArrow,
+	ImGuiKey_RightArrow,
+	ImGuiKey_UpArrow,
+	ImGuiKey_DownArrow,
+	ImGuiKey_PageUp,
+	ImGuiKey_PageDown,
+	ImGuiKey_Home,
+	ImGuiKey_End,
+	ImGuiKey_Insert,
+	ImGuiKey_Delete,
+	ImGuiKey_Backspace,
+	ImGuiKey_Space,
+	ImGuiKey_Enter,
+	ImGuiKey_Escape,
+	ImGuiKey_A,  // for text edit CTRL+A: select all
+	ImGuiKey_C,  // for text edit CTRL+C: copy
+	ImGuiKey_V,  // for text edit CTRL+V: paste
+	ImGuiKey_X,  // for text edit CTRL+X: cut
+	ImGuiKey_Y,  // for text edit CTRL+Y: redo
+	ImGuiKey_Z,  // for text edit CTRL+Z: undo
+	ImGuiKey_COUNT
+};
+
+// [BETA] Gamepad/Keyboard directional navigation
+// Keyboard: Set io.NavFlags |= ImGuiNavFlags_EnableKeyboard to enable. NewFrame() will automatically fill io.NavInputs[] based on your io.KeyDown[] + io.KeyMap[] arrays.
+// Gamepad:  Set io.NavFlags |= ImGuiNavFlags_EnableGamepad to enable. Fill the io.NavInputs[] fields before calling NewFrame(). Note that io.NavInputs[] is cleared by EndFrame().
+// Read instructions in imgui.cpp for more details.
+enum ImGuiNavInput_
+{
+	// Gamepad Mapping
+	ImGuiNavInput_Activate,     // activate / open / toggle / tweak value       // e.g. Circle (PS4), A (Xbox), B (Switch), Space (Keyboard)
+	ImGuiNavInput_Cancel,       // cancel / close / exit                        // e.g. Cross  (PS4), B (Xbox), A (Switch), Escape (Keyboard)
+	ImGuiNavInput_Input,        // text input / on-screen keyboard              // e.g. Triang.(PS4), Y (Xbox), X (Switch), Return (Keyboard)
+	ImGuiNavInput_Menu,         // tap: toggle menu / hold: focus, move, resize // e.g. Square (PS4), X (Xbox), Y (Switch), Alt (Keyboard)
+	ImGuiNavInput_DpadLeft,     // move / tweak / resize window (w/ PadMenu)    // e.g. D-pad Left/Right/Up/Down (Gamepads), Arrow keys (Keyboard)
+	ImGuiNavInput_DpadRight,    //
+	ImGuiNavInput_DpadUp,       //
+	ImGuiNavInput_DpadDown,     //
+	ImGuiNavInput_LStickLeft,   // scroll / move window (w/ PadMenu)            // e.g. Left Analog Stick Left/Right/Up/Down
+	ImGuiNavInput_LStickRight,  //
+	ImGuiNavInput_LStickUp,     //
+	ImGuiNavInput_LStickDown,   //
+	ImGuiNavInput_FocusPrev,    // next window (w/ PadMenu)                     // e.g. L1 or L2 (PS4), LB or LT (Xbox), L or ZL (Switch)
+	ImGuiNavInput_FocusNext,    // prev window (w/ PadMenu)                     // e.g. R1 or R2 (PS4), RB or RT (Xbox), R or ZL (Switch)
+	ImGuiNavInput_TweakSlow,    // slower tweaks                                // e.g. L1 or L2 (PS4), LB or LT (Xbox), L or ZL (Switch)
+	ImGuiNavInput_TweakFast,    // faster tweaks                                // e.g. R1 or R2 (PS4), RB or RT (Xbox), R or ZL (Switch)
+
+	// [Internal] Don't use directly! This is used internally to differentiate keyboard from gamepad inputs for behaviors that require to differentiate them.
+	// Keyboard behavior that have no corresponding gamepad mapping (e.g. CTRL+TAB) may be directly reading from io.KeyDown[] instead of io.NavInputs[].
+	ImGuiNavInput_KeyMenu_,   // toggle menu                                  // = io.KeyAlt
+	ImGuiNavInput_KeyLeft_,   // move left                                    // = Arrow keys
+	ImGuiNavInput_KeyRight_,  // move right
+	ImGuiNavInput_KeyUp_,     // move up
+	ImGuiNavInput_KeyDown_,   // move down
+	ImGuiNavInput_COUNT,
+	ImGuiNavInput_InternalStart_ = ImGuiNavInput_KeyMenu_
+};
+
+// [BETA] Gamepad/Keyboard directional navigation flags, stored in io.NavFlags
+enum ImGuiNavFlags_
+{
+	ImGuiNavFlags_EnableKeyboard = 1 << 0,    // Master keyboard navigation enable flag. NewFrame() will automatically fill io.NavInputs[] based on io.KeyDown[].
+	ImGuiNavFlags_EnableGamepad = 1 << 1,     // Master gamepad navigation enable flag. This is mostly to instruct your imgui back-end to fill io.NavInputs[].
+	ImGuiNavFlags_MoveMouse = 1 << 2,         // Request navigation to allow moving the mouse cursor. May be useful on TV/console systems where moving a virtual mouse is awkward. Will update io.MousePos and set io.WantMoveMouse=true. If enabled you MUST honor io.WantMoveMouse requests in your binding, otherwise ImGui will react as if the mouse is jumping around back and forth.
+	ImGuiNavFlags_NoCaptureKeyboard = 1 << 3  // Do not set the io.WantCaptureKeyboard flag with io.NavActive is set.
+};
+
+// Enumeration for PushStyleColor() / PopStyleColor()
+enum ImGuiCol_
+{
+	ImGuiCol_Text,
+	ImGuiCol_TextDisabled,
+	ImGuiCol_WindowBg,  // Background of normal windows
+	ImGuiCol_ChildBg,   // Background of child windows
+	ImGuiCol_PopupBg,   // Background of popups, menus, tooltips windows
+	ImGuiCol_Border,
+	ImGuiCol_BorderShadow,
+	ImGuiCol_FrameBg,  // Background of checkbox, radio button, plot, slider, text input
+	ImGuiCol_FrameBgHovered,
+	ImGuiCol_FrameBgActive,
+	ImGuiCol_TitleBg,
+	ImGuiCol_TitleBgActive,
+	ImGuiCol_TitleBgCollapsed,
+	ImGuiCol_MenuBarBg,
+	ImGuiCol_ScrollbarBg,
+	ImGuiCol_ScrollbarGrab,
+	ImGuiCol_ScrollbarGrabHovered,
+	ImGuiCol_ScrollbarGrabActive,
+	ImGuiCol_CheckMark,
+	ImGuiCol_SliderGrab,
+	ImGuiCol_SliderGrabActive,
+	ImGuiCol_Button,
+	ImGuiCol_ButtonHovered,
+	ImGuiCol_ButtonActive,
+	ImGuiCol_Header,
+	ImGuiCol_HeaderHovered,
+	ImGuiCol_HeaderActive,
+	ImGuiCol_Separator,
+	ImGuiCol_SeparatorHovered,
+	ImGuiCol_SeparatorActive,
+	ImGuiCol_ResizeGrip,
+	ImGuiCol_ResizeGripHovered,
+	ImGuiCol_ResizeGripActive,
+	ImGuiCol_CloseButton,
+	ImGuiCol_CloseButtonHovered,
+	ImGuiCol_CloseButtonActive,
+	ImGuiCol_PlotLines,
+	ImGuiCol_PlotLinesHovered,
+	ImGuiCol_PlotHistogram,
+	ImGuiCol_PlotHistogramHovered,
+	ImGuiCol_TextSelectedBg,
+	ImGuiCol_ModalWindowDarkening,  // darken entire screen when a modal window is active
+	ImGuiCol_DragDropTarget,
+	ImGuiCol_NavHighlight,           // gamepad/keyboard: current highlighted item
+	ImGuiCol_NavWindowingHighlight,  // gamepad/keyboard: when holding NavMenu to focus/move/resize windows
+	ImGuiCol_COUNT
+
+// Obsolete names (will be removed)
+#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+	//, ImGuiCol_ComboBg = ImGuiCol_PopupBg     // ComboBg has been merged with PopupBg, so a redirect isn't accurate.
+	,
+	ImGuiCol_ChildWindowBg = ImGuiCol_ChildBg,
+	ImGuiCol_Column = ImGuiCol_Separator,
+	ImGuiCol_ColumnHovered = ImGuiCol_SeparatorHovered,
+	ImGuiCol_ColumnActive = ImGuiCol_SeparatorActive
+#endif
+};
+
+// Enumeration for PushStyleVar() / PopStyleVar() to temporarily modify the ImGuiStyle structure.
+// NB: the enum only refers to fields of ImGuiStyle which makes sense to be pushed/popped inside UI code. During initialization, feel free to just poke into ImGuiStyle directly.
+// NB: if changing this enum, you need to update the associated internal table GStyleVarInfo[] accordingly. This is where we link enum values to members offset/type.
+enum ImGuiStyleVar_
+{
+	// Enum name ......................// Member in ImGuiStyle structure (see ImGuiStyle for descriptions)
+	ImGuiStyleVar_Alpha,              // float     Alpha
+	ImGuiStyleVar_WindowPadding,      // ImVec2    WindowPadding
+	ImGuiStyleVar_WindowRounding,     // float     WindowRounding
+	ImGuiStyleVar_WindowBorderSize,   // float     WindowBorderSize
+	ImGuiStyleVar_WindowMinSize,      // ImVec2    WindowMinSize
+	ImGuiStyleVar_WindowTitleAlign,   // ImVec2    WindowTitleAlign
+	ImGuiStyleVar_ChildRounding,      // float     ChildRounding
+	ImGuiStyleVar_ChildBorderSize,    // float     ChildBorderSize
+	ImGuiStyleVar_PopupRounding,      // float     PopupRounding
+	ImGuiStyleVar_PopupBorderSize,    // float     PopupBorderSize
+	ImGuiStyleVar_FramePadding,       // ImVec2    FramePadding
+	ImGuiStyleVar_FrameRounding,      // float     FrameRounding
+	ImGuiStyleVar_FrameBorderSize,    // float     FrameBorderSize
+	ImGuiStyleVar_ItemSpacing,        // ImVec2    ItemSpacing
+	ImGuiStyleVar_ItemInnerSpacing,   // ImVec2    ItemInnerSpacing
+	ImGuiStyleVar_IndentSpacing,      // float     IndentSpacing
+	ImGuiStyleVar_ScrollbarSize,      // float     ScrollbarSize
+	ImGuiStyleVar_ScrollbarRounding,  // float     ScrollbarRounding
+	ImGuiStyleVar_GrabMinSize,        // float     GrabMinSize
+	ImGuiStyleVar_GrabRounding,       // float     GrabRounding
+	ImGuiStyleVar_ButtonTextAlign,    // ImVec2    ButtonTextAlign
+	ImGuiStyleVar_Count_
+
+// Obsolete names (will be removed)
+#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+	,
+	ImGuiStyleVar_ChildWindowRounding = ImGuiStyleVar_ChildRounding
+#endif
+};
+
+// Enumeration for ColorEdit3() / ColorEdit4() / ColorPicker3() / ColorPicker4() / ColorButton()
+enum ImGuiColorEditFlags_
+{
+	ImGuiColorEditFlags_NoAlpha = 1 << 1,         //              // ColorEdit, ColorPicker, ColorButton: ignore Alpha component (read 3 components from the input pointer).
+	ImGuiColorEditFlags_NoPicker = 1 << 2,        //              // ColorEdit: disable picker when clicking on colored square.
+	ImGuiColorEditFlags_NoOptions = 1 << 3,       //              // ColorEdit: disable toggling options menu when right-clicking on inputs/small preview.
+	ImGuiColorEditFlags_NoSmallPreview = 1 << 4,  //              // ColorEdit, ColorPicker: disable colored square preview next to the inputs. (e.g. to show only the inputs)
+	ImGuiColorEditFlags_NoInputs = 1 << 5,        //              // ColorEdit, ColorPicker: disable inputs sliders/text widgets (e.g. to show only the small preview colored square).
+	ImGuiColorEditFlags_NoTooltip = 1 << 6,       //              // ColorEdit, ColorPicker, ColorButton: disable tooltip when hovering the preview.
+	ImGuiColorEditFlags_NoLabel = 1 << 7,         //              // ColorEdit, ColorPicker: disable display of inline text label (the label is still forwarded to the tooltip and picker).
+	ImGuiColorEditFlags_NoSidePreview = 1 << 8,   //              // ColorPicker: disable bigger color preview on right side of the picker, use small colored square preview instead.
+	// User Options (right-click on widget to change some of them). You can set application defaults using SetColorEditOptions(). The idea is that you probably don't want to override them in most of your calls, let the user choose and/or call SetColorEditOptions() during startup.
+	ImGuiColorEditFlags_AlphaBar = 1 << 9,           //              // ColorEdit, ColorPicker: show vertical alpha bar/gradient in picker.
+	ImGuiColorEditFlags_AlphaPreview = 1 << 10,      //              // ColorEdit, ColorPicker, ColorButton: display preview as a transparent color over a checkerboard, instead of opaque.
+	ImGuiColorEditFlags_AlphaPreviewHalf = 1 << 11,  //              // ColorEdit, ColorPicker, ColorButton: display half opaque / half checkerboard, instead of opaque.
+	ImGuiColorEditFlags_HDR = 1 << 12,               //              // (WIP) ColorEdit: Currently only disable 0.0f..1.0f limits in RGBA edition (note: you probably want to use ImGuiColorEditFlags_Float flag as well).
+	ImGuiColorEditFlags_RGB = 1 << 13,               // [Inputs]     // ColorEdit: choose one among RGB/HSV/HEX. ColorPicker: choose any combination using RGB/HSV/HEX.
+	ImGuiColorEditFlags_HSV = 1 << 14,               // [Inputs]     // "
+	ImGuiColorEditFlags_HEX = 1 << 15,               // [Inputs]     // "
+	ImGuiColorEditFlags_Uint8 = 1 << 16,             // [DataType]   // ColorEdit, ColorPicker, ColorButton: _display_ values formatted as 0..255.
+	ImGuiColorEditFlags_Float = 1 << 17,             // [DataType]   // ColorEdit, ColorPicker, ColorButton: _display_ values formatted as 0.0f..1.0f floats instead of 0..255 integers. No round-trip of value via integers.
+	ImGuiColorEditFlags_PickerHueBar = 1 << 18,      // [PickerMode] // ColorPicker: bar for Hue, rectangle for Sat/Value.
+	ImGuiColorEditFlags_PickerHueWheel = 1 << 19,    // [PickerMode] // ColorPicker: wheel for Hue, triangle for Sat/Value.
+	// Internals/Masks
+	ImGuiColorEditFlags__InputsMask = ImGuiColorEditFlags_RGB | ImGuiColorEditFlags_HSV | ImGuiColorEditFlags_HEX,
+	ImGuiColorEditFlags__DataTypeMask = ImGuiColorEditFlags_Uint8 | ImGuiColorEditFlags_Float,
+	ImGuiColorEditFlags__PickerMask = ImGuiColorEditFlags_PickerHueWheel | ImGuiColorEditFlags_PickerHueBar,
+	ImGuiColorEditFlags__OptionsDefault = ImGuiColorEditFlags_Uint8 | ImGuiColorEditFlags_RGB | ImGuiColorEditFlags_PickerHueBar  // Change application default using SetColorEditOptions()
+};
+
+// Enumeration for GetMouseCursor()
+enum ImGuiMouseCursor_
+{
+	ImGuiMouseCursor_None = -1,
+	ImGuiMouseCursor_Arrow = 0,
+	ImGuiMouseCursor_TextInput,   // When hovering over InputText, etc.
+	ImGuiMouseCursor_ResizeAll,   // Unused
+	ImGuiMouseCursor_ResizeNS,    // When hovering over an horizontal border
+	ImGuiMouseCursor_ResizeEW,    // When hovering over a vertical border or a column
+	ImGuiMouseCursor_ResizeNESW,  // When hovering over the bottom-left corner of a window
+	ImGuiMouseCursor_ResizeNWSE,  // When hovering over the bottom-right corner of a window
+	ImGuiMouseCursor_Count_
+};
+
+// Condition for ImGui::SetWindow***(), SetNextWindow***(), SetNextTreeNode***() functions
+// All those functions treat 0 as a shortcut to ImGuiCond_Always. From the point of view of the user use this as an enum (don't combine multiple values into flags).
+enum ImGuiCond_
+{
+	ImGuiCond_Always = 1 << 0,        // Set the variable
+	ImGuiCond_Once = 1 << 1,          // Set the variable once per runtime session (only the first call with succeed)
+	ImGuiCond_FirstUseEver = 1 << 2,  // Set the variable if the window has no saved data (if doesn't exist in the .ini file)
+	ImGuiCond_Appearing = 1 << 3      // Set the variable if the window is appearing after being hidden/inactive (or the first time)
+
+// Obsolete names (will be removed)
+#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+	,
+	ImGuiSetCond_Always = ImGuiCond_Always,
+	ImGuiSetCond_Once = ImGuiCond_Once,
+	ImGuiSetCond_FirstUseEver = ImGuiCond_FirstUseEver,
+	ImGuiSetCond_Appearing = ImGuiCond_Appearing
+#endif
+};
+
+// You may modify the ImGui::GetStyle() main instance during initialization and before NewFrame().
+// During the frame, prefer using ImGui::PushStyleVar(ImGuiStyleVar_XXXX)/PopStyleVar() to alter the main style values, and ImGui::PushStyleColor(ImGuiCol_XXX)/PopStyleColor() for colors.
+struct ImGuiStyle
+{
+	float Alpha;                    // Global alpha applies to everything in ImGui.
+	ImVec2 WindowPadding;           // Padding within a window.
+	float WindowRounding;           // Radius of window corners rounding. Set to 0.0f to have rectangular windows.
+	float WindowBorderSize;         // Thickness of border around windows. Generally set to 0.0f or 1.0f. (Other values are not well tested and more CPU/GPU costly).
+	ImVec2 WindowMinSize;           // Minimum window size. This is a global setting. If you want to constraint individual windows, use SetNextWindowSizeConstraints().
+	ImVec2 WindowTitleAlign;        // Alignment for title bar text. Defaults to (0.0f,0.5f) for left-aligned,vertically centered.
+	float ChildRounding;            // Radius of child window corners rounding. Set to 0.0f to have rectangular windows.
+	float ChildBorderSize;          // Thickness of border around child windows. Generally set to 0.0f or 1.0f. (Other values are not well tested and more CPU/GPU costly).
+	float PopupRounding;            // Radius of popup window corners rounding.
+	float PopupBorderSize;          // Thickness of border around popup windows. Generally set to 0.0f or 1.0f. (Other values are not well tested and more CPU/GPU costly).
+	ImVec2 FramePadding;            // Padding within a framed rectangle (used by most widgets).
+	float FrameRounding;            // Radius of frame corners rounding. Set to 0.0f to have rectangular frame (used by most widgets).
+	float FrameBorderSize;          // Thickness of border around frames. Generally set to 0.0f or 1.0f. (Other values are not well tested and more CPU/GPU costly).
+	ImVec2 ItemSpacing;             // Horizontal and vertical spacing between widgets/lines.
+	ImVec2 ItemInnerSpacing;        // Horizontal and vertical spacing between within elements of a composed widget (e.g. a slider and its label).
+	ImVec2 TouchExtraPadding;       // Expand reactive bounding box for touch-based system where touch position is not accurate enough. Unfortunately we don't sort widgets so priority on overlap will always be given to the first widget. So don't grow this too much!
+	float IndentSpacing;            // Horizontal indentation when e.g. entering a tree node. Generally == (FontSize + FramePadding.x*2).
+	float ColumnsMinSpacing;        // Minimum horizontal spacing between two columns.
+	float ScrollbarSize;            // Width of the vertical scrollbar, Height of the horizontal scrollbar.
+	float ScrollbarRounding;        // Radius of grab corners for scrollbar.
+	float GrabMinSize;              // Minimum width/height of a grab box for slider/scrollbar.
+	float GrabRounding;             // Radius of grabs corners rounding. Set to 0.0f to have rectangular slider grabs.
+	ImVec2 ButtonTextAlign;         // Alignment of button text when button is larger than text. Defaults to (0.5f,0.5f) for horizontally+vertically centered.
+	ImVec2 DisplayWindowPadding;    // Window positions are clamped to be visible within the display area by at least this amount. Only covers regular windows.
+	ImVec2 DisplaySafeAreaPadding;  // If you cannot see the edge of your screen (e.g. on a TV) increase the safe area padding. Covers popups/tooltips as well regular windows.
+	float MouseCursorScale;         // Scale software rendered mouse cursor (when io.MouseDrawCursor is enabled). May be removed later.
+	bool AntiAliasedLines;          // Enable anti-aliasing on lines/borders. Disable if you are really tight on CPU/GPU.
+	bool AntiAliasedFill;           // Enable anti-aliasing on filled shapes (rounded rectangles, circles, etc.)
+	float CurveTessellationTol;     // Tessellation tolerance when using PathBezierCurveTo() without a specific number of segments. Decrease for highly tessellated curves (higher quality, more polygons), increase to reduce quality.
+	ImVec4 Colors[ImGuiCol_COUNT];
+
+	IMGUI_API ImGuiStyle();
+	IMGUI_API void ScaleAllSizes(float scale_factor);
+};
+
+// This is where your app communicate with ImGui. Access via ImGui::GetIO().
+// Read 'Programmer guide' section in .cpp file for general usage.
+struct ImGuiIO
+{
+	//------------------------------------------------------------------
+	// Settings (fill once)                 // Default value:
+	//------------------------------------------------------------------
+
+	ImVec2 DisplaySize;             // <unset>              // Display size, in pixels. For clamping windows positions.
+	float DeltaTime;                // = 1.0f/60.0f         // Time elapsed since last frame, in seconds.
+	ImGuiNavFlags NavFlags;         // = 0x00               // See ImGuiNavFlags_. Gamepad/keyboard navigation options.
+	float IniSavingRate;            // = 5.0f               // Maximum time between saving positions/sizes to .ini file, in seconds.
+	const char* IniFilename;        // = "imgui.ini"        // Path to .ini file. NULL to disable .ini saving.
+	const char* LogFilename;        // = "imgui_log.txt"    // Path to .log file (default parameter to ImGui::LogToFile when no file is specified).
+	float MouseDoubleClickTime;     // = 0.30f              // Time for a double-click, in seconds.
+	float MouseDoubleClickMaxDist;  // = 6.0f               // Distance threshold to stay in to validate a double-click, in pixels.
+	float MouseDragThreshold;       // = 6.0f               // Distance threshold before considering we are dragging.
+	int KeyMap[ImGuiKey_COUNT];     // <unset>              // Map of indices into the KeysDown[512] entries array which represent your "native" keyboard state.
+	float KeyRepeatDelay;           // = 0.250f             // When holding a key/button, time before it starts repeating, in seconds (for buttons in Repeat mode, etc.).
+	float KeyRepeatRate;            // = 0.050f             // When holding a key/button, rate at which it repeats, in seconds.
+	void* UserData;                 // = NULL               // Store your own data for retrieval by callbacks.
+
+	ImFontAtlas* Fonts;              // <auto>               // Load and assemble one or more fonts into a single tightly packed texture. Output to Fonts array.
+	float FontGlobalScale;           // = 1.0f               // Global scale all fonts
+	bool FontAllowUserScaling;       // = false              // Allow user scaling text of individual window with CTRL+Wheel.
+	ImFont* FontDefault;             // = NULL               // Font to use on NewFrame(). Use NULL to uses Fonts->Fonts[0].
+	ImVec2 DisplayFramebufferScale;  // = (1.0f,1.0f)        // For retina display or other situations where window coordinates are different from framebuffer coordinates. User storage only, presently not used by ImGui.
+	ImVec2 DisplayVisibleMin;        // <unset> (0.0f,0.0f)  // If you use DisplaySize as a virtual space larger than your screen, set DisplayVisibleMin/Max to the visible area.
+	ImVec2 DisplayVisibleMax;        // <unset> (0.0f,0.0f)  // If the values are the same, we defaults to Min=(0.0f) and Max=DisplaySize
+
+	// Advanced/subtle behaviors
+	bool OptMacOSXBehaviors;  // = defined(__APPLE__) // OS X style: Text editing cursor movement using Alt instead of Ctrl, Shortcuts using Cmd/Super instead of Ctrl, Line/Text Start and End using Cmd+Arrows instead of Home/End, Double click selects by word instead of selecting whole text, Multi-selection in lists uses Cmd/Super instead of Ctrl
+	bool OptCursorBlink;      // = true               // Enable blinking cursor, for users who consider it annoying.
+
+	//------------------------------------------------------------------
+	// Settings (User Functions)
+	//------------------------------------------------------------------
+
+	// Optional: access OS clipboard
+	// (default to use native Win32 clipboard on Windows, otherwise uses a private clipboard. Override to access OS clipboard on other architectures)
+	const char* (*GetClipboardTextFn)(void* user_data);
+	void (*SetClipboardTextFn)(void* user_data, const char* text);
+	void* ClipboardUserData;
+
+	// Optional: notify OS Input Method Editor of the screen position of your cursor for text input position (e.g. when using Japanese/Chinese IME in Windows)
+	// (default to use native imm32 api on Windows)
+	void (*ImeSetInputScreenPosFn)(int x, int y);
+	void* ImeWindowHandle;  // (Windows) Set this to your HWND to get automatic IME cursor positioning.
+
+#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+	// [OBSOLETE] Rendering function, will be automatically called in Render(). Please call your rendering function yourself now! You can obtain the ImDrawData* by calling ImGui::GetDrawData() after Render().
+	// See example applications if you are unsure of how to implement this.
+	void (*RenderDrawListsFn)(ImDrawData* data);
+#endif
+
+	//------------------------------------------------------------------
+	// Input - Fill before calling NewFrame()
+	//------------------------------------------------------------------
+
+	ImVec2 MousePos;                       // Mouse position, in pixels. Set to ImVec2(-FLT_MAX,-FLT_MAX) if mouse is unavailable (on another screen, etc.)
+	bool MouseDown[5];                     // Mouse buttons: left, right, middle + extras. ImGui itself mostly only uses left button (BeginPopupContext** are using right button). Others buttons allows us to track if the mouse is being used by your application + available to user as a convenience via IsMouse** API.
+	float MouseWheel;                      // Mouse wheel: 1 unit scrolls about 5 lines text.
+	float MouseWheelH;                     // Mouse wheel (Horizontal). Most users don't have a mouse with an horizontal wheel, may not be filled by all back-ends.
+	bool MouseDrawCursor;                  // Request ImGui to draw a mouse cursor for you (if you are on a platform without a mouse cursor).
+	bool KeyCtrl;                          // Keyboard modifier pressed: Control
+	bool KeyShift;                         // Keyboard modifier pressed: Shift
+	bool KeyAlt;                           // Keyboard modifier pressed: Alt
+	bool KeySuper;                         // Keyboard modifier pressed: Cmd/Super/Windows
+	bool KeysDown[512];                    // Keyboard keys that are pressed (ideally left in the "native" order your engine has access to keyboard keys, so you can use your own defines/enums for keys).
+	ImWchar InputCharacters[16 + 1];       // List of characters input (translated by user from keypress+keyboard state). Fill using AddInputCharacter() helper.
+	float NavInputs[ImGuiNavInput_COUNT];  // Gamepad inputs (keyboard keys will be auto-mapped and be written here by ImGui::NewFrame)
+
+	// Functions
+	IMGUI_API void AddInputCharacter(ImWchar c);                    // Add new character into InputCharacters[]
+	IMGUI_API void AddInputCharactersUTF8(const char* utf8_chars);  // Add new characters into InputCharacters[] from an UTF-8 string
+	inline void ClearInputCharacters() { InputCharacters[0] = 0; }  // Clear the text input buffer manually
+
+	//------------------------------------------------------------------
+	// Output - Retrieve after calling NewFrame()
+	//------------------------------------------------------------------
+
+	bool WantCaptureMouse;      // When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application. This is set by ImGui when it wants to use your mouse (e.g. unclicked mouse is hovering a window, or a widget is active).
+	bool WantCaptureKeyboard;   // When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application. This is set by ImGui when it wants to use your keyboard inputs.
+	bool WantTextInput;         // Mobile/console: when io.WantTextInput is true, you may display an on-screen keyboard. This is set by ImGui when it wants textual keyboard input to happen (e.g. when a InputText widget is active).
+	bool WantMoveMouse;         // MousePos has been altered, back-end should reposition mouse on next frame. Set only when ImGuiNavFlags_MoveMouse flag is enabled in io.NavFlags.
+	bool NavActive;             // Directional navigation is currently allowed (will handle ImGuiKey_NavXXX events) = a window is focused and it doesn't use the ImGuiWindowFlags_NoNavInputs flag.
+	bool NavVisible;            // Directional navigation is visible and allowed (will handle ImGuiKey_NavXXX events).
+	float Framerate;            // Application framerate estimation, in frame per second. Solely for convenience. Rolling average estimation based on IO.DeltaTime over 120 frames
+	int MetricsRenderVertices;  // Vertices output during last call to Render()
+	int MetricsRenderIndices;   // Indices output during last call to Render() = number of triangles * 3
+	int MetricsActiveWindows;   // Number of visible root windows (exclude child windows)
+	ImVec2 MouseDelta;          // Mouse delta. Note that this is zero if either current or previous position are invalid (-FLT_MAX,-FLT_MAX), so a disappearing/reappearing mouse won't have a huge delta.
+
+	//------------------------------------------------------------------
+	// [Internal] ImGui will maintain those fields. Forward compatibility not guaranteed!
+	//------------------------------------------------------------------
+
+	ImVec2 MousePosPrev;                // Previous mouse position temporary storage (nb: not for public use, set to MousePos in NewFrame())
+	ImVec2 MouseClickedPos[5];          // Position at time of clicking
+	float MouseClickedTime[5];          // Time of last click (used to figure out double-click)
+	bool MouseClicked[5];               // Mouse button went from !Down to Down
+	bool MouseDoubleClicked[5];         // Has mouse button been double-clicked?
+	bool MouseReleased[5];              // Mouse button went from Down to !Down
+	bool MouseDownOwned[5];             // Track if button was clicked inside a window. We don't request mouse capture from the application if click started outside ImGui bounds.
+	float MouseDownDuration[5];         // Duration the mouse button has been down (0.0f == just clicked)
+	float MouseDownDurationPrev[5];     // Previous time the mouse button has been down
+	ImVec2 MouseDragMaxDistanceAbs[5];  // Maximum distance, absolute, on each axis, of how much mouse has traveled from the clicking point
+	float MouseDragMaxDistanceSqr[5];   // Squared maximum distance of how much mouse has traveled from the clicking point
+	float KeysDownDuration[512];        // Duration the keyboard key has been down (0.0f == just pressed)
+	float KeysDownDurationPrev[512];    // Previous duration the key has been down
+	float NavInputsDownDuration[ImGuiNavInput_COUNT];
+	float NavInputsDownDurationPrev[ImGuiNavInput_COUNT];
+
+	IMGUI_API ImGuiIO();
+};
+
+//-----------------------------------------------------------------------------
+// Obsolete functions (Will be removed! Read 'API BREAKING CHANGES' section in imgui.cpp for details)
+//-----------------------------------------------------------------------------
+
+#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+namespace ImGui
+{
+// OBSOLETED in 1.60 (from Dec 2017)
+static inline bool IsAnyWindowFocused() { return IsWindowFocused(ImGuiFocusedFlags_AnyWindow); }
+static inline bool IsAnyWindowHovered() { return IsWindowHovered(ImGuiHoveredFlags_AnyWindow); }
+static inline ImVec2 CalcItemRectClosestPoint(const ImVec2& pos, bool on_edge = false, float outward = 0.f)
+{
+	(void)on_edge;
+	(void)outward;
+	IM_ASSERT(0);
+	return pos;
+}
+// OBSOLETED in 1.53 (between Oct 2017 and Dec 2017)
+static inline void ShowTestWindow() { return ShowDemoWindow(); }
+static inline bool IsRootWindowFocused() { return IsWindowFocused(ImGuiFocusedFlags_RootWindow); }
+static inline bool IsRootWindowOrAnyChildFocused() { return IsWindowFocused(ImGuiFocusedFlags_RootAndChildWindows); }
+static inline void SetNextWindowContentWidth(float w) { SetNextWindowContentSize(ImVec2(w, 0.0f)); }
+static inline float GetItemsLineHeightWithSpacing() { return GetFrameHeightWithSpacing(); }
+// OBSOLETED in 1.52 (between Aug 2017 and Oct 2017)
+bool Begin(const char* name, bool* p_open, const ImVec2& size_on_first_use, float bg_alpha_override = -1.0f, ImGuiWindowFlags flags = 0);  // Use SetNextWindowSize(size, ImGuiCond_FirstUseEver) + SetNextWindowBgAlpha() instead.
+static inline bool IsRootWindowOrAnyChildHovered() { return IsWindowHovered(ImGuiHoveredFlags_RootAndChildWindows); }
+static inline void AlignFirstTextHeightToWidgets() { AlignTextToFramePadding(); }
+static inline void SetNextWindowPosCenter(ImGuiCond c = 0)
+{
+	ImGuiIO& io = GetIO();
+	SetNextWindowPos(ImVec2(io.DisplaySize.x * 0.5f, io.DisplaySize.y * 0.5f), c, ImVec2(0.5f, 0.5f));
+}
+// OBSOLETED in 1.51 (between Jun 2017 and Aug 2017)
+static inline bool IsItemHoveredRect() { return IsItemHovered(ImGuiHoveredFlags_RectOnly); }
+static inline bool IsPosHoveringAnyWindow(const ImVec2&)
+{
+	IM_ASSERT(0);
+	return false;
+}  // This was misleading and partly broken. You probably want to use the ImGui::GetIO().WantCaptureMouse flag instead.
+static inline bool IsMouseHoveringAnyWindow() { return IsWindowHovered(ImGuiHoveredFlags_AnyWindow); }
+static inline bool IsMouseHoveringWindow() { return IsWindowHovered(ImGuiHoveredFlags_AllowWhenBlockedByPopup | ImGuiHoveredFlags_AllowWhenBlockedByActiveItem); }
+// OBSOLETED IN 1.49 (between Apr 2016 and May 2016)
+static inline bool CollapsingHeader(const char* label, const char* str_id, bool framed = true, bool default_open = false)
+{
+	(void)str_id;
+	(void)framed;
+	ImGuiTreeNodeFlags default_open_flags = 1 << 5;
+	return CollapsingHeader(label, (default_open ? default_open_flags : 0));
+}
+}  // namespace ImGui
+#endif
+
+//-----------------------------------------------------------------------------
+// Helpers
+//-----------------------------------------------------------------------------
+
+// Lightweight std::vector<> like class to avoid dragging dependencies (also: windows implementation of STL with debug enabled is absurdly slow, so let's bypass it so our code runs fast in debug).
+// Our implementation does NOT call C++ constructors/destructors. This is intentional and we do not require it. Do not use this class as a straight std::vector replacement in your code!
+template <typename T>
+class ImVector
+{
+public:
+	int Size;
+	int Capacity;
+	T* Data;
+
+	typedef T value_type;
+	typedef value_type* iterator;
+	typedef const value_type* const_iterator;
+
+	inline ImVector()
+	{
+		Size = Capacity = 0;
+		Data = NULL;
+	}
+	inline ~ImVector()
+	{
+		if (Data) ImGui::MemFree(Data);
+	}
+
+	inline bool empty() const { return Size == 0; }
+	inline int size() const { return Size; }
+	inline int capacity() const { return Capacity; }
+
+	inline value_type& operator[](int i)
+	{
+		IM_ASSERT(i < Size);
+		return Data[i];
+	}
+	inline const value_type& operator[](int i) const
+	{
+		IM_ASSERT(i < Size);
+		return Data[i];
+	}
+
+	inline void clear()
+	{
+		if (Data)
+		{
+			Size = Capacity = 0;
+			ImGui::MemFree(Data);
+			Data = NULL;
+		}
+	}
+	inline iterator begin() { return Data; }
+	inline const_iterator begin() const { return Data; }
+	inline iterator end() { return Data + Size; }
+	inline const_iterator end() const { return Data + Size; }
+	inline value_type& front()
+	{
+		IM_ASSERT(Size > 0);
+		return Data[0];
+	}
+	inline const value_type& front() const
+	{
+		IM_ASSERT(Size > 0);
+		return Data[0];
+	}
+	inline value_type& back()
+	{
+		IM_ASSERT(Size > 0);
+		return Data[Size - 1];
+	}
+	inline const value_type& back() const
+	{
+		IM_ASSERT(Size > 0);
+		return Data[Size - 1];
+	}
+	inline void swap(ImVector<T>& rhs)
+	{
+		int rhs_size = rhs.Size;
+		rhs.Size = Size;
+		Size = rhs_size;
+		int rhs_cap = rhs.Capacity;
+		rhs.Capacity = Capacity;
+		Capacity = rhs_cap;
+		value_type* rhs_data = rhs.Data;
+		rhs.Data = Data;
+		Data = rhs_data;
+	}
+
+	inline int _grow_capacity(int sz) const
+	{
+		int new_capacity = Capacity ? (Capacity + Capacity / 2) : 8;
+		return new_capacity > sz ? new_capacity : sz;
+	}
+
+	inline void resize(int new_size)
+	{
+		if (new_size > Capacity) reserve(_grow_capacity(new_size));
+		Size = new_size;
+	}
+	inline void resize(int new_size, const T& v)
+	{
+		if (new_size > Capacity) reserve(_grow_capacity(new_size));
+		if (new_size > Size)
+			for (int n = Size; n < new_size; n++) Data[n] = v;
+		Size = new_size;
+	}
+	inline void reserve(int new_capacity)
+	{
+		if (new_capacity <= Capacity)
+			return;
+		T* new_data = (value_type*)ImGui::MemAlloc((size_t)new_capacity * sizeof(T));
+		if (Data)
+			memcpy(new_data, Data, (size_t)Size * sizeof(T));
+		ImGui::MemFree(Data);
+		Data = new_data;
+		Capacity = new_capacity;
+	}
+
+	// NB: &v cannot be pointing inside the ImVector Data itself! e.g. v.push_back(v[10]) is forbidden.
+	inline void push_back(const value_type& v)
+	{
+		if (Size == Capacity) reserve(_grow_capacity(Size + 1));
+		Data[Size++] = v;
+	}
+	inline void pop_back()
+	{
+		IM_ASSERT(Size > 0);
+		Size--;
+	}
+	inline void push_front(const value_type& v)
+	{
+		if (Size == 0)
+			push_back(v);
+		else
+			insert(Data, v);
+	}
+
+	inline iterator erase(const_iterator it)
+	{
+		IM_ASSERT(it >= Data && it < Data + Size);
+		const ptrdiff_t off = it - Data;
+		memmove(Data + off, Data + off + 1, ((size_t)Size - (size_t)off - 1) * sizeof(value_type));
+		Size--;
+		return Data + off;
+	}
+	inline iterator insert(const_iterator it, const value_type& v)
+	{
+		IM_ASSERT(it >= Data && it <= Data + Size);
+		const ptrdiff_t off = it - Data;
+		if (Size == Capacity) reserve(_grow_capacity(Size + 1));
+		if (off < (int)Size) memmove(Data + off + 1, Data + off, ((size_t)Size - (size_t)off) * sizeof(value_type));
+		Data[off] = v;
+		Size++;
+		return Data + off;
+	}
+	inline bool contains(const value_type& v) const
+	{
+		const T* data = Data;
+		const T* data_end = Data + Size;
+		while (data < data_end)
+			if (*data++ == v) return true;
+		return false;
+	}
+};
+
+// Helper: execute a block of code at maximum once a frame. Convenient if you want to quickly create an UI within deep-nested code that runs multiple times every frame.
+// Usage:
+//   static ImGuiOnceUponAFrame oaf;
+//   if (oaf)
+//       ImGui::Text("This will be called only once per frame");
+struct ImGuiOnceUponAFrame
+{
+	ImGuiOnceUponAFrame() { RefFrame = -1; }
+	mutable int RefFrame;
+	operator bool() const
+	{
+		int current_frame = ImGui::GetFrameCount();
+		if (RefFrame == current_frame) return false;
+		RefFrame = current_frame;
+		return true;
+	}
+};
+
+// Helper macro for ImGuiOnceUponAFrame. Attention: The macro expands into 2 statement so make sure you don't use it within e.g. an if() statement without curly braces.
+#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS  // Will obsolete
+#define IMGUI_ONCE_UPON_A_FRAME           \
+	static ImGuiOnceUponAFrame imgui_oaf; \
+	if (imgui_oaf)
+#endif
+
+// Helper: Parse and apply text filters. In format "aaaaa[,bbbb][,ccccc]"
+struct ImGuiTextFilter
+{
+	struct TextRange
+	{
+		const char* b;
+		const char* e;
+
+		TextRange() { b = e = NULL; }
+		TextRange(const char* _b, const char* _e)
+		{
+			b = _b;
+			e = _e;
+		}
+		const char* begin() const { return b; }
+		const char* end() const { return e; }
+		bool empty() const { return b == e; }
+		char front() const { return *b; }
+		static bool is_blank(char c) { return c == ' ' || c == '\t'; }
+		void trim_blanks()
+		{
+			while (b < e && is_blank(*b)) b++;
+			while (e > b && is_blank(*(e - 1))) e--;
+		}
+		IMGUI_API void split(char separator, ImVector<TextRange>& out);
+	};
+
+	char InputBuf[256];
+	ImVector<TextRange> Filters;
+	int CountGrep;
+
+	IMGUI_API ImGuiTextFilter(const char* default_filter = "");
+	IMGUI_API bool Draw(const char* label = "Filter (inc,-exc)", float width = 0.0f);  // Helper calling InputText+Build
+	IMGUI_API bool PassFilter(const char* text, const char* text_end = NULL) const;
+	IMGUI_API void Build();
+	void Clear()
+	{
+		InputBuf[0] = 0;
+		Build();
+	}
+	bool IsActive() const { return !Filters.empty(); }
+};
+
+// Helper: Text buffer for logging/accumulating text
+struct ImGuiTextBuffer
+{
+	ImVector<char> Buf;
+
+	ImGuiTextBuffer() { Buf.push_back(0); }
+	inline char operator[](int i) { return Buf.Data[i]; }
+	const char* begin() const { return &Buf.front(); }
+	const char* end() const { return &Buf.back(); }  // Buf is zero-terminated, so end() will point on the zero-terminator
+	int size() const { return Buf.Size - 1; }
+	bool empty() { return Buf.Size <= 1; }
+	void clear()
+	{
+		Buf.clear();
+		Buf.push_back(0);
+	}
+	void reserve(int capacity) { Buf.reserve(capacity); }
+	const char* c_str() const { return Buf.Data; }
+	IMGUI_API void appendf(const char* fmt, ...) IM_FMTARGS(2);
+	IMGUI_API void appendfv(const char* fmt, va_list args) IM_FMTLIST(2);
+};
+
+// Helper: Simple Key->value storage
+// Typically you don't have to worry about this since a storage is held within each Window.
+// We use it to e.g. store collapse state for a tree (Int 0/1), store color edit options.
+// This is optimized for efficient reading (dichotomy into a contiguous buffer), rare writing (typically tied to user interactions)
+// You can use it as custom user storage for temporary values. Declare your own storage if, for example:
+// - You want to manipulate the open/close state of a particular sub-tree in your interface (tree node uses Int 0/1 to store their state).
+// - You want to store custom debug data easily without adding or editing structures in your code (probably not efficient, but convenient)
+// Types are NOT stored, so it is up to you to make sure your Key don't collide with different types.
+struct ImGuiStorage
+{
+	struct Pair
+	{
+		ImGuiID key;
+		union {
+			int val_i;
+			float val_f;
+			void* val_p;
+		};
+		Pair(ImGuiID _key, int _val_i)
+		{
+			key = _key;
+			val_i = _val_i;
+		}
+		Pair(ImGuiID _key, float _val_f)
+		{
+			key = _key;
+			val_f = _val_f;
+		}
+		Pair(ImGuiID _key, void* _val_p)
+		{
+			key = _key;
+			val_p = _val_p;
+		}
+	};
+	ImVector<Pair> Data;
+
+	// - Get***() functions find pair, never add/allocate. Pairs are sorted so a query is O(log N)
+	// - Set***() functions find pair, insertion on demand if missing.
+	// - Sorted insertion is costly, paid once. A typical frame shouldn't need to insert any new pair.
+	void Clear() { Data.clear(); }
+	IMGUI_API int GetInt(ImGuiID key, int default_val = 0) const;
+	IMGUI_API void SetInt(ImGuiID key, int val);
+	IMGUI_API bool GetBool(ImGuiID key, bool default_val = false) const;
+	IMGUI_API void SetBool(ImGuiID key, bool val);
+	IMGUI_API float GetFloat(ImGuiID key, float default_val = 0.0f) const;
+	IMGUI_API void SetFloat(ImGuiID key, float val);
+	IMGUI_API void* GetVoidPtr(ImGuiID key) const;  // default_val is NULL
+	IMGUI_API void SetVoidPtr(ImGuiID key, void* val);
+
+	// - Get***Ref() functions finds pair, insert on demand if missing, return pointer. Useful if you intend to do Get+Set.
+	// - References are only valid until a new value is added to the storage. Calling a Set***() function or a Get***Ref() function invalidates the pointer.
+	// - A typical use case where this is convenient for quick hacking (e.g. add storage during a live Edit&Continue session if you can't modify existing struct)
+	//      float* pvar = ImGui::GetFloatRef(key); ImGui::SliderFloat("var", pvar, 0, 100.0f); some_var += *pvar;
+	IMGUI_API int* GetIntRef(ImGuiID key, int default_val = 0);
+	IMGUI_API bool* GetBoolRef(ImGuiID key, bool default_val = false);
+	IMGUI_API float* GetFloatRef(ImGuiID key, float default_val = 0.0f);
+	IMGUI_API void** GetVoidPtrRef(ImGuiID key, void* default_val = NULL);
+
+	// Use on your own storage if you know only integer are being stored (open/close all tree nodes)
+	IMGUI_API void SetAllInt(int val);
+
+	// For quicker full rebuild of a storage (instead of an incremental one), you may add all your contents and then sort once.
+	IMGUI_API void BuildSortByKey();
+};
+
+// Shared state of InputText(), passed to callback when a ImGuiInputTextFlags_Callback* flag is used and the corresponding callback is triggered.
+struct ImGuiTextEditCallbackData
+{
+	ImGuiInputTextFlags EventFlag;  // One of ImGuiInputTextFlags_Callback* // Read-only
+	ImGuiInputTextFlags Flags;      // What user passed to InputText()      // Read-only
+	void* UserData;                 // What user passed to InputText()      // Read-only
+	bool ReadOnly;                  // Read-only mode                       // Read-only
+
+	// CharFilter event:
+	ImWchar EventChar;  // Character input                      // Read-write (replace character or set to zero)
+
+	// Completion,History,Always events:
+	// If you modify the buffer contents make sure you update 'BufTextLen' and set 'BufDirty' to true.
+	ImGuiKey EventKey;   // Key pressed (Up/Down/TAB)            // Read-only
+	char* Buf;           // Current text buffer                  // Read-write (pointed data only, can't replace the actual pointer)
+	int BufTextLen;      // Current text length in bytes         // Read-write
+	int BufSize;         // Maximum text length in bytes         // Read-only
+	bool BufDirty;       // Set if you modify Buf/BufTextLen!!   // Write
+	int CursorPos;       //                                      // Read-write
+	int SelectionStart;  //                                      // Read-write (== to SelectionEnd when no selection)
+	int SelectionEnd;    //                                      // Read-write
+
+	// NB: Helper functions for text manipulation. Calling those function loses selection.
+	IMGUI_API void DeleteChars(int pos, int bytes_count);
+	IMGUI_API void InsertChars(int pos, const char* text, const char* text_end = NULL);
+	bool HasSelection() const { return SelectionStart != SelectionEnd; }
+};
+
+// Resizing callback data to apply custom constraint. As enabled by SetNextWindowSizeConstraints(). Callback is called during the next Begin().
+// NB: For basic min/max size constraint on each axis you don't need to use the callback! The SetNextWindowSizeConstraints() parameters are enough.
+struct ImGuiSizeCallbackData
+{
+	void* UserData;      // Read-only.   What user passed to SetNextWindowSizeConstraints()
+	ImVec2 Pos;          // Read-only.   Window position, for reference.
+	ImVec2 CurrentSize;  // Read-only.   Current window size.
+	ImVec2 DesiredSize;  // Read-write.  Desired size, based on user's mouse position. Write to this field to restrain resizing.
+};
+
+// Data payload for Drag and Drop operations
+struct ImGuiPayload
+{
+	// Members
+	const void* Data;  // Data (copied and owned by dear imgui)
+	int DataSize;      // Data size
+
+	// [Internal]
+	ImGuiID SourceId;        // Source item id
+	ImGuiID SourceParentId;  // Source parent id (if available)
+	int DataFrameCount;      // Data timestamp
+	char DataType[12 + 1];   // Data type tag (short user-supplied string, 12 characters max)
+	bool Preview;            // Set when AcceptDragDropPayload() was called and mouse has been hovering the target item (nb: handle overlapping drag targets)
+	bool Delivery;           // Set when AcceptDragDropPayload() was called and mouse button is released over the target item.
+
+	ImGuiPayload() { Clear(); }
+	void Clear()
+	{
+		SourceId = SourceParentId = 0;
+		Data = NULL;
+		DataSize = 0;
+		memset(DataType, 0, sizeof(DataType));
+		DataFrameCount = -1;
+		Preview = Delivery = false;
+	}
+	bool IsDataType(const char* type) const { return DataFrameCount != -1 && strcmp(type, DataType) == 0; }
+	bool IsPreview() const { return Preview; }
+	bool IsDelivery() const { return Delivery; }
+};
+
+// Helpers macros to generate 32-bits encoded colors
+#ifdef IMGUI_USE_BGRA_PACKED_COLOR
+#define IM_COL32_R_SHIFT 16
+#define IM_COL32_G_SHIFT 8
+#define IM_COL32_B_SHIFT 0
+#define IM_COL32_A_SHIFT 24
+#define IM_COL32_A_MASK 0xFF000000
+#else
+#define IM_COL32_R_SHIFT 0
+#define IM_COL32_G_SHIFT 8
+#define IM_COL32_B_SHIFT 16
+#define IM_COL32_A_SHIFT 24
+#define IM_COL32_A_MASK 0xFF000000
+#endif
+#define IM_COL32(R, G, B, A) (((ImU32)(A) << IM_COL32_A_SHIFT) | ((ImU32)(B) << IM_COL32_B_SHIFT) | ((ImU32)(G) << IM_COL32_G_SHIFT) | ((ImU32)(R) << IM_COL32_R_SHIFT))
+#define IM_COL32_WHITE IM_COL32(255, 255, 255, 255)  // Opaque white = 0xFFFFFFFF
+#define IM_COL32_BLACK IM_COL32(0, 0, 0, 255)        // Opaque black
+#define IM_COL32_BLACK_TRANS IM_COL32(0, 0, 0, 0)    // Transparent black = 0x00000000
+
+// ImColor() helper to implicity converts colors to either ImU32 (packed 4x1 byte) or ImVec4 (4x1 float)
+// Prefer using IM_COL32() macros if you want a guaranteed compile-time ImU32 for usage with ImDrawList API.
+// **Avoid storing ImColor! Store either u32 of ImVec4. This is not a full-featured color class. MAY OBSOLETE.
+// **None of the ImGui API are using ImColor directly but you can use it as a convenience to pass colors in either ImU32 or ImVec4 formats. Explicitly cast to ImU32 or ImVec4 if needed.
+struct ImColor
+{
+	ImVec4 Value;
+
+	ImColor() { Value.x = Value.y = Value.z = Value.w = 0.0f; }
+	ImColor(int r, int g, int b, int a = 255)
+	{
+		float sc = 1.0f / 255.0f;
+		Value.x = (float)r * sc;
+		Value.y = (float)g * sc;
+		Value.z = (float)b * sc;
+		Value.w = (float)a * sc;
+	}
+	ImColor(ImU32 rgba)
+	{
+		float sc = 1.0f / 255.0f;
+		Value.x = (float)((rgba >> IM_COL32_R_SHIFT) & 0xFF) * sc;
+		Value.y = (float)((rgba >> IM_COL32_G_SHIFT) & 0xFF) * sc;
+		Value.z = (float)((rgba >> IM_COL32_B_SHIFT) & 0xFF) * sc;
+		Value.w = (float)((rgba >> IM_COL32_A_SHIFT) & 0xFF) * sc;
+	}
+	ImColor(float r, float g, float b, float a = 1.0f)
+	{
+		Value.x = r;
+		Value.y = g;
+		Value.z = b;
+		Value.w = a;
+	}
+	ImColor(const ImVec4& col) { Value = col; }
+	inline operator ImU32() const { return ImGui::ColorConvertFloat4ToU32(Value); }
+	inline operator ImVec4() const { return Value; }
+
+	// FIXME-OBSOLETE: May need to obsolete/cleanup those helpers.
+	inline void SetHSV(float h, float s, float v, float a = 1.0f)
+	{
+		ImGui::ColorConvertHSVtoRGB(h, s, v, Value.x, Value.y, Value.z);
+		Value.w = a;
+	}
+	static ImColor HSV(float h, float s, float v, float a = 1.0f)
+	{
+		float r, g, b;
+		ImGui::ColorConvertHSVtoRGB(h, s, v, r, g, b);
+		return ImColor(r, g, b, a);
+	}
+};
+
+// Helper: Manually clip large list of items.
+// If you are submitting lots of evenly spaced items and you have a random access to the list, you can perform coarse clipping based on visibility to save yourself from processing those items at all.
+// The clipper calculates the range of visible items and advance the cursor to compensate for the non-visible items we have skipped.
+// ImGui already clip items based on their bounds but it needs to measure text size to do so. Coarse clipping before submission makes this cost and your own data fetching/submission cost null.
+// Usage:
+//     ImGuiListClipper clipper(1000);  // we have 1000 elements, evenly spaced.
+//     while (clipper.Step())
+//         for (int i = clipper.DisplayStart; i < clipper.DisplayEnd; i++)
+//             ImGui::Text("line number %d", i);
+// - Step 0: the clipper let you process the first element, regardless of it being visible or not, so we can measure the element height (step skipped if we passed a known height as second arg to constructor).
+// - Step 1: the clipper infer height from first element, calculate the actual range of elements to display, and position the cursor before the first element.
+// - (Step 2: dummy step only required if an explicit items_height was passed to constructor or Begin() and user call Step(). Does nothing and switch to Step 3.)
+// - Step 3: the clipper validate that we have reached the expected Y position (corresponding to element DisplayEnd), advance the cursor to the end of the list and then returns 'false' to end the loop.
+struct ImGuiListClipper
+{
+	float StartPosY;
+	float ItemsHeight;
+	int ItemsCount, StepNo, DisplayStart, DisplayEnd;
+
+	// items_count:  Use -1 to ignore (you can call Begin later). Use INT_MAX if you don't know how many items you have (in which case the cursor won't be advanced in the final step).
+	// items_height: Use -1.0f to be calculated automatically on first step. Otherwise pass in the distance between your items, typically GetTextLineHeightWithSpacing() or GetFrameHeightWithSpacing().
+	// If you don't specify an items_height, you NEED to call Step(). If you specify items_height you may call the old Begin()/End() api directly, but prefer calling Step().
+	ImGuiListClipper(int items_count = -1, float items_height = -1.0f) { Begin(items_count, items_height); }  // NB: Begin() initialize every fields (as we allow user to call Begin/End multiple times on a same instance if they want).
+	~ImGuiListClipper() { IM_ASSERT(ItemsCount == -1); }                                                      // Assert if user forgot to call End() or Step() until false.
+
+	IMGUI_API bool Step();                                              // Call until it returns false. The DisplayStart/DisplayEnd fields will be set and you can process/draw those items.
+	IMGUI_API void Begin(int items_count, float items_height = -1.0f);  // Automatically called by constructor if you passed 'items_count' or by Step() in Step 1.
+	IMGUI_API void End();                                               // Automatically called on the last call of Step() that returns false.
+};
+
+//-----------------------------------------------------------------------------
+// Draw List
+// Hold a series of drawing commands. The user provides a renderer for ImDrawData which essentially contains an array of ImDrawList.
+//-----------------------------------------------------------------------------
+
+// Draw callbacks for advanced uses.
+// NB- You most likely do NOT need to use draw callbacks just to create your own widget or customized UI rendering (you can poke into the draw list for that)
+// Draw callback may be useful for example, A) Change your GPU render state, B) render a complex 3D scene inside a UI element (without an intermediate texture/render target), etc.
+// The expected behavior from your rendering function is 'if (cmd.UserCallback != NULL) cmd.UserCallback(parent_list, cmd); else RenderTriangles()'
+typedef void (*ImDrawCallback)(const ImDrawList* parent_list, const ImDrawCmd* cmd);
+
+// Typically, 1 command = 1 GPU draw call (unless command is a callback)
+struct ImDrawCmd
+{
+	unsigned int ElemCount;       // Number of indices (multiple of 3) to be rendered as triangles. Vertices are stored in the callee ImDrawList's vtx_buffer[] array, indices in idx_buffer[].
+	ImVec4 ClipRect;              // Clipping rectangle (x1, y1, x2, y2)
+	ImTextureID TextureId;        // User-provided texture ID. Set by user in ImfontAtlas::SetTexID() for fonts or passed to Image*() functions. Ignore if never using images or multiple fonts atlas.
+	ImDrawCallback UserCallback;  // If != NULL, call the function instead of rendering the vertices. clip_rect and texture_id will be set normally.
+	void* UserCallbackData;       // The draw callback code can access this.
+
+	ImDrawCmd()
+	{
+		ElemCount = 0;
+		ClipRect.x = ClipRect.y = ClipRect.z = ClipRect.w = 0.0f;
+		TextureId = NULL;
+		UserCallback = NULL;
+		UserCallbackData = NULL;
+	}
+};
+
+// Vertex index (override with '#define ImDrawIdx unsigned int' inside in imconfig.h)
+#ifndef ImDrawIdx
+typedef unsigned short ImDrawIdx;
+#endif
+
+// Vertex layout
+#ifndef IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT
+struct ImDrawVert
+{
+	ImVec2 pos;
+	ImVec2 uv;
+	ImU32 col;
+};
+#else
+// You can override the vertex format layout by defining IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT in imconfig.h
+// The code expect ImVec2 pos (8 bytes), ImVec2 uv (8 bytes), ImU32 col (4 bytes), but you can re-order them or add other fields as needed to simplify integration in your engine.
+// The type has to be described within the macro (you can either declare the struct or use a typedef)
+// NOTE: IMGUI DOESN'T CLEAR THE STRUCTURE AND DOESN'T CALL A CONSTRUCTOR SO ANY CUSTOM FIELD WILL BE UNINITIALIZED. IF YOU ADD EXTRA FIELDS (SUCH AS A 'Z' COORDINATES) YOU WILL NEED TO CLEAR THEM DURING RENDER OR TO IGNORE THEM.
+IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT;
+#endif
+
+// Draw channels are used by the Columns API to "split" the render list into different channels while building, so items of each column can be batched together.
+// You can also use them to simulate drawing layers and submit primitives in a different order than how they will be rendered.
+struct ImDrawChannel
+{
+	ImVector<ImDrawCmd> CmdBuffer;
+	ImVector<ImDrawIdx> IdxBuffer;
+};
+
+enum ImDrawCornerFlags_
+{
+	ImDrawCornerFlags_TopLeft = 1 << 0,                                                 // 0x1
+	ImDrawCornerFlags_TopRight = 1 << 1,                                                // 0x2
+	ImDrawCornerFlags_BotLeft = 1 << 2,                                                 // 0x4
+	ImDrawCornerFlags_BotRight = 1 << 3,                                                // 0x8
+	ImDrawCornerFlags_Top = ImDrawCornerFlags_TopLeft | ImDrawCornerFlags_TopRight,     // 0x3
+	ImDrawCornerFlags_Bot = ImDrawCornerFlags_BotLeft | ImDrawCornerFlags_BotRight,     // 0xC
+	ImDrawCornerFlags_Left = ImDrawCornerFlags_TopLeft | ImDrawCornerFlags_BotLeft,     // 0x5
+	ImDrawCornerFlags_Right = ImDrawCornerFlags_TopRight | ImDrawCornerFlags_BotRight,  // 0xA
+	ImDrawCornerFlags_All = 0xF                                                         // In your function calls you may use ~0 (= all bits sets) instead of ImDrawCornerFlags_All, as a convenience
+};
+
+enum ImDrawListFlags_
+{
+	ImDrawListFlags_AntiAliasedLines = 1 << 0,
+	ImDrawListFlags_AntiAliasedFill = 1 << 1
+};
+
+// Draw command list
+// This is the low-level list of polygons that ImGui functions are filling. At the end of the frame, all command lists are passed to your ImGuiIO::RenderDrawListFn function for rendering.
+// Each ImGui window contains its own ImDrawList. You can use ImGui::GetWindowDrawList() to access the current window draw list and draw custom primitives.
+// You can interleave normal ImGui:: calls and adding primitives to the current draw list.
+// All positions are generally in pixel coordinates (top-left at (0,0), bottom-right at io.DisplaySize), however you are totally free to apply whatever transformation matrix to want to the data (if you apply such transformation you'll want to apply it to ClipRect as well)
+// Important: Primitives are always added to the list and not culled (culling is done at higher-level by ImGui:: functions), if you use this API a lot consider coarse culling your drawn objects.
+struct ImDrawList
+{
+	// This is what you have to render
+	ImVector<ImDrawCmd> CmdBuffer;   // Draw commands. Typically 1 command = 1 GPU draw call, unless the command is a callback.
+	ImVector<ImDrawIdx> IdxBuffer;   // Index buffer. Each command consume ImDrawCmd::ElemCount of those
+	ImVector<ImDrawVert> VtxBuffer;  // Vertex buffer.
+
+	// [Internal, used while building lists]
+	ImDrawListFlags Flags;                  // Flags, you may poke into these to adjust anti-aliasing settings per-primitive.
+	const ImDrawListSharedData* _Data;      // Pointer to shared draw data (you can use ImGui::GetDrawListSharedData() to get the one from current ImGui context)
+	const char* _OwnerName;                 // Pointer to owner window's name for debugging
+	unsigned int _VtxCurrentIdx;            // [Internal] == VtxBuffer.Size
+	ImDrawVert* _VtxWritePtr;               // [Internal] point within VtxBuffer.Data after each add command (to avoid using the ImVector<> operators too much)
+	ImDrawIdx* _IdxWritePtr;                // [Internal] point within IdxBuffer.Data after each add command (to avoid using the ImVector<> operators too much)
+	ImVector<ImVec4> _ClipRectStack;        // [Internal]
+	ImVector<ImTextureID> _TextureIdStack;  // [Internal]
+	ImVector<ImVec2> _Path;                 // [Internal] current path building
+	int _ChannelsCurrent;                   // [Internal] current channel number (0)
+	int _ChannelsCount;                     // [Internal] number of active channels (1+)
+	ImVector<ImDrawChannel> _Channels;      // [Internal] draw channels for columns API (not resized down so _ChannelsCount may be smaller than _Channels.Size)
+
+	// If you want to create ImDrawList instances, pass them ImGui::GetDrawListSharedData() or create and use your own ImDrawListSharedData (so you can use ImDrawList without ImGui)
+	ImDrawList(const ImDrawListSharedData* shared_data)
+	{
+		_Data = shared_data;
+		_OwnerName = NULL;
+		Clear();
+	}
+	~ImDrawList() { ClearFreeMemory(); }
+	IMGUI_API void PushClipRect(ImVec2 clip_rect_min, ImVec2 clip_rect_max, bool intersect_with_current_clip_rect = false);  // Render-level scissoring. This is passed down to your render function but not used for CPU-side coarse clipping. Prefer using higher-level ImGui::PushClipRect() to affect logic (hit-testing and widget culling)
+	IMGUI_API void PushClipRectFullScreen();
+	IMGUI_API void PopClipRect();
+	IMGUI_API void PushTextureID(ImTextureID texture_id);
+	IMGUI_API void PopTextureID();
+	inline ImVec2 GetClipRectMin() const
+	{
+		const ImVec4& cr = _ClipRectStack.back();
+		return ImVec2(cr.x, cr.y);
+	}
+	inline ImVec2 GetClipRectMax() const
+	{
+		const ImVec4& cr = _ClipRectStack.back();
+		return ImVec2(cr.z, cr.w);
+	}
+
+	// Primitives
+	IMGUI_API void AddLine(const ImVec2& a, const ImVec2& b, ImU32 col, float thickness = 1.0f);
+	IMGUI_API void AddRect(const ImVec2& a, const ImVec2& b, ImU32 col, float rounding = 0.0f, int rounding_corners_flags = ImDrawCornerFlags_All, float thickness = 1.0f);  // a: upper-left, b: lower-right, rounding_corners_flags: 4-bits corresponding to which corner to round
+	IMGUI_API void AddRectFilled(const ImVec2& a, const ImVec2& b, ImU32 col, float rounding = 0.0f, int rounding_corners_flags = ImDrawCornerFlags_All);                    // a: upper-left, b: lower-right
+	IMGUI_API void AddRectFilledMultiColor(const ImVec2& a, const ImVec2& b, ImU32 col_upr_left, ImU32 col_upr_right, ImU32 col_bot_right, ImU32 col_bot_left);
+	IMGUI_API void AddQuad(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& d, ImU32 col, float thickness = 1.0f);
+	IMGUI_API void AddQuadFilled(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& d, ImU32 col);
+	IMGUI_API void AddTriangle(const ImVec2& a, const ImVec2& b, const ImVec2& c, ImU32 col, float thickness = 1.0f);
+	IMGUI_API void AddTriangleFilled(const ImVec2& a, const ImVec2& b, const ImVec2& c, ImU32 col);
+	IMGUI_API void AddCircle(const ImVec2& centre, float radius, ImU32 col, int num_segments = 12, float thickness = 1.0f);
+	IMGUI_API void AddCircleFilled(const ImVec2& centre, float radius, ImU32 col, int num_segments = 12);
+	IMGUI_API void AddText(const ImVec2& pos, ImU32 col, const char* text_begin, const char* text_end = NULL);
+	IMGUI_API void AddText(const ImFont* font, float font_size, const ImVec2& pos, ImU32 col, const char* text_begin, const char* text_end = NULL, float wrap_width = 0.0f, const ImVec4* cpu_fine_clip_rect = NULL);
+	IMGUI_API void AddImage(ImTextureID user_texture_id, const ImVec2& a, const ImVec2& b, const ImVec2& uv_a = ImVec2(0, 0), const ImVec2& uv_b = ImVec2(1, 1), ImU32 col = 0xFFFFFFFF);
+	IMGUI_API void AddImageQuad(ImTextureID user_texture_id, const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& d, const ImVec2& uv_a = ImVec2(0, 0), const ImVec2& uv_b = ImVec2(1, 0), const ImVec2& uv_c = ImVec2(1, 1), const ImVec2& uv_d = ImVec2(0, 1), ImU32 col = 0xFFFFFFFF);
+	IMGUI_API void AddImageRounded(ImTextureID user_texture_id, const ImVec2& a, const ImVec2& b, const ImVec2& uv_a, const ImVec2& uv_b, ImU32 col, float rounding, int rounding_corners = ImDrawCornerFlags_All);
+	IMGUI_API void AddPolyline(const ImVec2* points, const int num_points, ImU32 col, bool closed, float thickness);
+	IMGUI_API void AddConvexPolyFilled(const ImVec2* points, const int num_points, ImU32 col);
+	IMGUI_API void AddBezierCurve(const ImVec2& pos0, const ImVec2& cp0, const ImVec2& cp1, const ImVec2& pos1, ImU32 col, float thickness, int num_segments = 0);
+
+	// Stateful path API, add points then finish with PathFill() or PathStroke()
+	inline void PathClear() { _Path.resize(0); }
+	inline void PathLineTo(const ImVec2& pos) { _Path.push_back(pos); }
+	inline void PathLineToMergeDuplicate(const ImVec2& pos)
+	{
+		if (_Path.Size == 0 || memcmp(&_Path[_Path.Size - 1], &pos, 8) != 0) _Path.push_back(pos);
+	}
+	inline void PathFillConvex(ImU32 col)
+	{
+		AddConvexPolyFilled(_Path.Data, _Path.Size, col);
+		PathClear();
+	}
+	inline void PathStroke(ImU32 col, bool closed, float thickness = 1.0f)
+	{
+		AddPolyline(_Path.Data, _Path.Size, col, closed, thickness);
+		PathClear();
+	}
+	IMGUI_API void PathArcTo(const ImVec2& centre, float radius, float a_min, float a_max, int num_segments = 10);
+	IMGUI_API void PathArcToFast(const ImVec2& centre, float radius, int a_min_of_12, int a_max_of_12);  // Use precomputed angles for a 12 steps circle
+	IMGUI_API void PathBezierCurveTo(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, int num_segments = 0);
+	IMGUI_API void PathRect(const ImVec2& rect_min, const ImVec2& rect_max, float rounding = 0.0f, int rounding_corners_flags = ImDrawCornerFlags_All);
+
+	// Channels
+	// - Use to simulate layers. By switching channels to can render out-of-order (e.g. submit foreground primitives before background primitives)
+	// - Use to minimize draw calls (e.g. if going back-and-forth between multiple non-overlapping clipping rectangles, prefer to append into separate channels then merge at the end)
+	IMGUI_API void ChannelsSplit(int channels_count);
+	IMGUI_API void ChannelsMerge();
+	IMGUI_API void ChannelsSetCurrent(int channel_index);
+
+	// Advanced
+	IMGUI_API void AddCallback(ImDrawCallback callback, void* callback_data);  // Your rendering function must check for 'UserCallback' in ImDrawCmd and call the function instead of rendering triangles.
+	IMGUI_API void AddDrawCmd();                                               // This is useful if you need to forcefully create a new draw call (to allow for dependent rendering / blending). Otherwise primitives are merged into the same draw-call as much as possible
+
+	// Internal helpers
+	// NB: all primitives needs to be reserved via PrimReserve() beforehand!
+	IMGUI_API void Clear();
+	IMGUI_API void ClearFreeMemory();
+	IMGUI_API void PrimReserve(int idx_count, int vtx_count);
+	IMGUI_API void PrimRect(const ImVec2& a, const ImVec2& b, ImU32 col);  // Axis aligned rectangle (composed of two triangles)
+	IMGUI_API void PrimRectUV(const ImVec2& a, const ImVec2& b, const ImVec2& uv_a, const ImVec2& uv_b, ImU32 col);
+	IMGUI_API void PrimQuadUV(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& d, const ImVec2& uv_a, const ImVec2& uv_b, const ImVec2& uv_c, const ImVec2& uv_d, ImU32 col);
+	inline void PrimWriteVtx(const ImVec2& pos, const ImVec2& uv, ImU32 col)
+	{
+		_VtxWritePtr->pos = pos;
+		_VtxWritePtr->uv = uv;
+		_VtxWritePtr->col = col;
+		_VtxWritePtr++;
+		_VtxCurrentIdx++;
+	}
+	inline void PrimWriteIdx(ImDrawIdx idx)
+	{
+		*_IdxWritePtr = idx;
+		_IdxWritePtr++;
+	}
+	inline void PrimVtx(const ImVec2& pos, const ImVec2& uv, ImU32 col)
+	{
+		PrimWriteIdx((ImDrawIdx)_VtxCurrentIdx);
+		PrimWriteVtx(pos, uv, col);
+	}
+	IMGUI_API void UpdateClipRect();
+	IMGUI_API void UpdateTextureID();
+};
+
+// All draw data to render an ImGui frame
+struct ImDrawData
+{
+	bool Valid;  // Only valid after Render() is called and before the next NewFrame() is called.
+	ImDrawList** CmdLists;
+	int CmdListsCount;
+	int TotalVtxCount;  // For convenience, sum of all cmd_lists vtx_buffer.Size
+	int TotalIdxCount;  // For convenience, sum of all cmd_lists idx_buffer.Size
+
+	// Functions
+	ImDrawData() { Clear(); }
+	void Clear()
+	{
+		Valid = false;
+		CmdLists = NULL;
+		CmdListsCount = TotalVtxCount = TotalIdxCount = 0;
+	}                                                 // Draw lists are owned by the ImGuiContext and only pointed to here.
+	IMGUI_API void DeIndexAllBuffers();               // For backward compatibility or convenience: convert all buffers from indexed to de-indexed, in case you cannot render indexed. Note: this is slow and most likely a waste of resources. Always prefer indexed rendering!
+	IMGUI_API void ScaleClipRects(const ImVec2& sc);  // Helper to scale the ClipRect field of each ImDrawCmd. Use if your final output buffer is at a different scale than ImGui expects, or if there is a difference between your window resolution and framebuffer resolution.
+};
+
+struct ImFontConfig
+{
+	void* FontData;                //          // TTF/OTF data
+	int FontDataSize;              //          // TTF/OTF data size
+	bool FontDataOwnedByAtlas;     // true     // TTF/OTF data ownership taken by the container ImFontAtlas (will delete memory itself).
+	int FontNo;                    // 0        // Index of font within TTF/OTF file
+	float SizePixels;              //          // Size in pixels for rasterizer.
+	int OversampleH, OversampleV;  // 3, 1     // Rasterize at higher quality for sub-pixel positioning. We don't use sub-pixel positions on the Y axis.
+	bool PixelSnapH;               // false    // Align every glyph to pixel boundary. Useful e.g. if you are merging a non-pixel aligned font with the default font. If enabled, you can set OversampleH/V to 1.
+	ImVec2 GlyphExtraSpacing;      // 0, 0     // Extra spacing (in pixels) between glyphs. Only X axis is supported for now.
+	ImVec2 GlyphOffset;            // 0, 0     // Offset all glyphs from this font input.
+	const ImWchar* GlyphRanges;    // NULL     // Pointer to a user-provided list of Unicode range (2 value per range, values are inclusive, zero-terminated list). THE ARRAY DATA NEEDS TO PERSIST AS LONG AS THE FONT IS ALIVE.
+	bool MergeMode;                // false    // Merge into previous ImFont, so you can combine multiple inputs font into one ImFont (e.g. ASCII font + icons + Japanese glyphs). You may want to use GlyphOffset.y when merge font of different heights.
+	unsigned int RasterizerFlags;  // 0x00     // Settings for custom font rasterizer (e.g. ImGuiFreeType). Leave as zero if you aren't using one.
+	float RasterizerMultiply;      // 1.0f     // Brighten (>1.0f) or darken (<1.0f) font output. Brightening small fonts may be a good workaround to make them more readable.
+
+	// [Internal]
+	char Name[32];  // Name (strictly to ease debugging)
+	ImFont* DstFont;
+
+	IMGUI_API ImFontConfig();
+};
+
+struct ImFontGlyph
+{
+	ImWchar Codepoint;     // 0x0000..0xFFFF
+	float AdvanceX;        // Distance to next character (= data from font + ImFontConfig::GlyphExtraSpacing.x baked in)
+	float X0, Y0, X1, Y1;  // Glyph corners
+	float U0, V0, U1, V1;  // Texture coordinates
+};
+
+enum ImFontAtlasFlags_
+{
+	ImFontAtlasFlags_NoPowerOfTwoHeight = 1 << 0,  // Don't round the height to next power of two
+	ImFontAtlasFlags_NoMouseCursors = 1 << 1       // Don't build software mouse cursors into the atlas
+};
+
+// Load and rasterize multiple TTF/OTF fonts into a same texture.
+// Sharing a texture for multiple fonts allows us to reduce the number of draw calls during rendering.
+// We also add custom graphic data into the texture that serves for ImGui.
+//  1. (Optional) Call AddFont*** functions. If you don't call any, the default font will be loaded for you.
+//  2. Call GetTexDataAsAlpha8() or GetTexDataAsRGBA32() to build and retrieve pixels data.
+//  3. Upload the pixels data into a texture within your graphics system.
+//  4. Call SetTexID(my_tex_id); and pass the pointer/identifier to your texture. This value will be passed back to you during rendering to identify the texture.
+// IMPORTANT: If you pass a 'glyph_ranges' array to AddFont*** functions, you need to make sure that your array persist up until the ImFont is build (when calling GetTextData*** or Build()). We only copy the pointer, not the data.
+struct ImFontAtlas
+{
+	IMGUI_API ImFontAtlas();
+	IMGUI_API ~ImFontAtlas();
+	IMGUI_API ImFont* AddFont(const ImFontConfig* font_cfg);
+	IMGUI_API ImFont* AddFontDefault(const ImFontConfig* font_cfg = NULL);
+	IMGUI_API ImFont* AddFontFromFileTTF(const char* filename, float size_pixels, const ImFontConfig* font_cfg = NULL, const ImWchar* glyph_ranges = NULL);
+	IMGUI_API ImFont* AddFontFromMemoryTTF(void* font_data, int font_size, float size_pixels, const ImFontConfig* font_cfg = NULL, const ImWchar* glyph_ranges = NULL);                                        // Note: Transfer ownership of 'ttf_data' to ImFontAtlas! Will be deleted after Build(). Set font_cfg->FontDataOwnedByAtlas to false to keep ownership.
+	IMGUI_API ImFont* AddFontFromMemoryCompressedTTF(const void* compressed_font_data, int compressed_font_size, float size_pixels, const ImFontConfig* font_cfg = NULL, const ImWchar* glyph_ranges = NULL);  // 'compressed_font_data' still owned by caller. Compress with binary_to_compressed_c.cpp.
+	IMGUI_API ImFont* AddFontFromMemoryCompressedBase85TTF(const char* compressed_font_data_base85, float size_pixels, const ImFontConfig* font_cfg = NULL, const ImWchar* glyph_ranges = NULL);               // 'compressed_font_data_base85' still owned by caller. Compress with binary_to_compressed_c.cpp with -base85 parameter.
+	IMGUI_API void ClearTexData();                                                                                                                                                                             // Clear the CPU-side texture data. Saves RAM once the texture has been copied to graphics memory.
+	IMGUI_API void ClearInputData();                                                                                                                                                                           // Clear the input TTF data (inc sizes, glyph ranges)
+	IMGUI_API void ClearFonts();                                                                                                                                                                               // Clear the ImGui-side font data (glyphs storage, UV coordinates)
+	IMGUI_API void Clear();                                                                                                                                                                                    // Clear all
+
+	// Build atlas, retrieve pixel data.
+	// User is in charge of copying the pixels into graphics memory (e.g. create a texture with your engine). Then store your texture handle with SetTexID().
+	// RGBA32 format is provided for convenience and compatibility, but note that unless you use CustomRect to draw color data, the RGB pixels emitted from Fonts will all be white (~75% of waste).
+	// Pitch = Width * BytesPerPixels
+	IMGUI_API bool Build();                                                                                                           // Build pixels data. This is called automatically for you by the GetTexData*** functions.
+	IMGUI_API void GetTexDataAsAlpha8(unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel = NULL);  // 1 byte per-pixel
+	IMGUI_API void GetTexDataAsRGBA32(unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel = NULL);  // 4 bytes-per-pixel
+	void SetTexID(ImTextureID id) { TexID = id; }
+
+	//-------------------------------------------
+	// Glyph Ranges
+	//-------------------------------------------
+
+	// Helpers to retrieve list of common Unicode ranges (2 value per range, values are inclusive, zero-terminated list)
+	// NB: Make sure that your string are UTF-8 and NOT in your local code page. In C++11, you can create UTF-8 string literal using the u8"Hello world" syntax. See FAQ for details.
+	IMGUI_API const ImWchar* GetGlyphRangesDefault();   // Basic Latin, Extended Latin
+	IMGUI_API const ImWchar* GetGlyphRangesKorean();    // Default + Korean characters
+	IMGUI_API const ImWchar* GetGlyphRangesJapanese();  // Default + Hiragana, Katakana, Half-Width, Selection of 1946 Ideographs
+	IMGUI_API const ImWchar* GetGlyphRangesChinese();   // Default + Japanese + full set of about 21000 CJK Unified Ideographs
+	IMGUI_API const ImWchar* GetGlyphRangesCyrillic();  // Default + about 400 Cyrillic characters
+	IMGUI_API const ImWchar* GetGlyphRangesThai();      // Default + Thai characters
+
+	// Helpers to build glyph ranges from text data. Feed your application strings/characters to it then call BuildRanges().
+	struct GlyphRangesBuilder
+	{
+		ImVector<unsigned char> UsedChars;  // Store 1-bit per Unicode code point (0=unused, 1=used)
+		GlyphRangesBuilder()
+		{
+			UsedChars.resize(0x10000 / 8);
+			memset(UsedChars.Data, 0, 0x10000 / 8);
+		}
+		bool GetBit(int n) { return (UsedChars[n >> 3] & (1 << (n & 7))) != 0; }
+		void SetBit(int n) { UsedChars[n >> 3] |= 1 << (n & 7); }               // Set bit 'c' in the array
+		void AddChar(ImWchar c) { SetBit(c); }                                  // Add character
+		IMGUI_API void AddText(const char* text, const char* text_end = NULL);  // Add string (each character of the UTF-8 string are added)
+		IMGUI_API void AddRanges(const ImWchar* ranges);                        // Add ranges, e.g. builder.AddRanges(ImFontAtlas::GetGlyphRangesDefault) to force add all of ASCII/Latin+Ext
+		IMGUI_API void BuildRanges(ImVector<ImWchar>* out_ranges);              // Output new ranges
+	};
+
+	//-------------------------------------------
+	// Custom Rectangles/Glyphs API
+	//-------------------------------------------
+
+	// You can request arbitrary rectangles to be packed into the atlas, for your own purposes. After calling Build(), you can query the rectangle position and render your pixels.
+	// You can also request your rectangles to be mapped as font glyph (given a font + Unicode point), so you can render e.g. custom colorful icons and use them as regular glyphs.
+	struct CustomRect
+	{
+		unsigned int ID;               // Input    // User ID. Use <0x10000 to map into a font glyph, >=0x10000 for other/internal/custom texture data.
+		unsigned short Width, Height;  // Input    // Desired rectangle dimension
+		unsigned short X, Y;           // Output   // Packed position in Atlas
+		float GlyphAdvanceX;           // Input    // For custom font glyphs only (ID<0x10000): glyph xadvance
+		ImVec2 GlyphOffset;            // Input    // For custom font glyphs only (ID<0x10000): glyph display offset
+		ImFont* Font;                  // Input    // For custom font glyphs only (ID<0x10000): target font
+		CustomRect()
+		{
+			ID = 0xFFFFFFFF;
+			Width = Height = 0;
+			X = Y = 0xFFFF;
+			GlyphAdvanceX = 0.0f;
+			GlyphOffset = ImVec2(0, 0);
+			Font = NULL;
+		}
+		bool IsPacked() const { return X != 0xFFFF; }
+	};
+
+	IMGUI_API int AddCustomRectRegular(unsigned int id, int width, int height);                                                                   // Id needs to be >= 0x10000. Id >= 0x80000000 are reserved for ImGui and ImDrawList
+	IMGUI_API int AddCustomRectFontGlyph(ImFont* font, ImWchar id, int width, int height, float advance_x, const ImVec2& offset = ImVec2(0, 0));  // Id needs to be < 0x10000 to register a rectangle to map into a specific font.
+	const CustomRect* GetCustomRectByIndex(int index) const
+	{
+		if (index < 0) return NULL;
+		return &CustomRects[index];
+	}
+
+	// Internals
+	IMGUI_API void CalcCustomRectUV(const CustomRect* rect, ImVec2* out_uv_min, ImVec2* out_uv_max);
+	IMGUI_API bool GetMouseCursorTexData(ImGuiMouseCursor cursor, ImVec2* out_offset, ImVec2* out_size, ImVec2 out_uv_border[2], ImVec2 out_uv_fill[2]);
+
+	//-------------------------------------------
+	// Members
+	//-------------------------------------------
+
+	ImFontAtlasFlags Flags;  // Build flags (see ImFontAtlasFlags_)
+	ImTextureID TexID;       // User data to refer to the texture once it has been uploaded to user's graphic systems. It is passed back to you during rendering via the ImDrawCmd structure.
+	int TexDesiredWidth;     // Texture width desired by user before Build(). Must be a power-of-two. If have many glyphs your graphics API have texture size restrictions you may want to increase texture width to decrease height.
+	int TexGlyphPadding;     // Padding between glyphs within texture in pixels. Defaults to 1.
+
+	// [Internal]
+	// NB: Access texture data via GetTexData*() calls! Which will setup a default font for you.
+	unsigned char* TexPixelsAlpha8;     // 1 component per pixel, each component is unsigned 8-bit. Total size = TexWidth * TexHeight
+	unsigned int* TexPixelsRGBA32;      // 4 component per pixel, each component is unsigned 8-bit. Total size = TexWidth * TexHeight * 4
+	int TexWidth;                       // Texture width calculated during Build().
+	int TexHeight;                      // Texture height calculated during Build().
+	ImVec2 TexUvScale;                  // = (1.0f/TexWidth, 1.0f/TexHeight)
+	ImVec2 TexUvWhitePixel;             // Texture coordinates to a white pixel
+	ImVector<ImFont*> Fonts;            // Hold all the fonts returned by AddFont*. Fonts[0] is the default font upon calling ImGui::NewFrame(), use ImGui::PushFont()/PopFont() to change the current font.
+	ImVector<CustomRect> CustomRects;   // Rectangles for packing custom texture data into the atlas.
+	ImVector<ImFontConfig> ConfigData;  // Internal data
+	int CustomRectIds[1];               // Identifiers of custom texture rectangle used by ImFontAtlas/ImDrawList
+};
+
+// Font runtime data and rendering
+// ImFontAtlas automatically loads a default embedded font for you when you call GetTexDataAsAlpha8() or GetTexDataAsRGBA32().
+struct ImFont
+{
+	// Members: Hot ~62/78 bytes
+	float FontSize;                        // <user set>   // Height of characters, set during loading (don't change after loading)
+	float Scale;                           // = 1.f        // Base font scale, multiplied by the per-window font scale which you can adjust with SetFontScale()
+	ImVec2 DisplayOffset;                  // = (0.f,1.f)  // Offset font rendering by xx pixels
+	ImVector<ImFontGlyph> Glyphs;          //              // All glyphs.
+	ImVector<float> IndexAdvanceX;         //              // Sparse. Glyphs->AdvanceX in a directly indexable way (more cache-friendly, for CalcTextSize functions which are often bottleneck in large UI).
+	ImVector<unsigned short> IndexLookup;  //              // Sparse. Index glyphs by Unicode code-point.
+	const ImFontGlyph* FallbackGlyph;      // == FindGlyph(FontFallbackChar)
+	float FallbackAdvanceX;                // == FallbackGlyph->AdvanceX
+	ImWchar FallbackChar;                  // = '?'        // Replacement glyph if one isn't found. Only set via SetFallbackChar()
+
+	// Members: Cold ~18/26 bytes
+	short ConfigDataCount;        // ~ 1          // Number of ImFontConfig involved in creating this font. Bigger than 1 when merging multiple font sources into one ImFont.
+	ImFontConfig* ConfigData;     //              // Pointer within ContainerAtlas->ConfigData
+	ImFontAtlas* ContainerAtlas;  //              // What we has been loaded into
+	float Ascent, Descent;        //              // Ascent: distance from top to bottom of e.g. 'A' [0..FontSize]
+	int MetricsTotalSurface;      //              // Total surface in pixels to get an idea of the font rasterization/texture cost (not exact, we approximate the cost of padding between glyphs)
+
+	// Methods
+	IMGUI_API ImFont();
+	IMGUI_API ~ImFont();
+	IMGUI_API void ClearOutputData();
+	IMGUI_API void BuildLookupTable();
+	IMGUI_API const ImFontGlyph* FindGlyph(ImWchar c) const;
+	IMGUI_API void SetFallbackChar(ImWchar c);
+	float GetCharAdvance(ImWchar c) const { return ((int)c < IndexAdvanceX.Size) ? IndexAdvanceX[(int)c] : FallbackAdvanceX; }
+	bool IsLoaded() const { return ContainerAtlas != NULL; }
+	const char* GetDebugName() const { return ConfigData ? ConfigData->Name : "<unknown>"; }
+
+	// 'max_width' stops rendering after a certain width (could be turned into a 2d size). FLT_MAX to disable.
+	// 'wrap_width' enable automatic word-wrapping across multiple lines to fit into given width. 0.0f to disable.
+	IMGUI_API ImVec2 CalcTextSizeA(float size, float max_width, float wrap_width, const char* text_begin, const char* text_end = NULL, const char** remaining = NULL) const;  // utf8
+	IMGUI_API const char* CalcWordWrapPositionA(float scale, const char* text, const char* text_end, float wrap_width) const;
+	IMGUI_API void RenderChar(ImDrawList* draw_list, float size, ImVec2 pos, ImU32 col, unsigned short c) const;
+	IMGUI_API void RenderText(ImDrawList* draw_list, float size, ImVec2 pos, ImU32 col, const ImVec4& clip_rect, const char* text_begin, const char* text_end, float wrap_width = 0.0f, bool cpu_fine_clip = false) const;
+
+	// [Internal]
+	IMGUI_API void GrowIndex(int new_size);
+	IMGUI_API void AddGlyph(ImWchar c, float x0, float y0, float x1, float y1, float u0, float v0, float u1, float v1, float advance_x);
+	IMGUI_API void AddRemapChar(ImWchar dst, ImWchar src, bool overwrite_dst = true);  // Makes 'dst' character/glyph points to 'src' character/glyph. Currently needs to be called AFTER fonts have been built.
+
+#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+	typedef ImFontGlyph Glyph;  // OBSOLETE 1.52+
+#endif
+};
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
+// Include imgui_user.h at the end of imgui.h (convenient for user to only explicitly include vanilla imgui.h)
+#ifdef IMGUI_INCLUDE_IMGUI_USER_H
+#include "imgui_user.h"
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/imgui/imgui_internal.h b/engine/inc/bullet/ThirdPartyLibs/imgui/imgui_internal.h
new file mode 100644
index 00000000..d2f53557
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/imgui/imgui_internal.h
@@ -0,0 +1,1346 @@
+// dear imgui, v1.60 WIP
+// (internals)
+
+// You may use this file to debug, understand or extend ImGui features but we don't provide any guarantee of forward compatibility!
+// Set:
+//   #define IMGUI_DEFINE_MATH_OPERATORS
+// To implement maths operators for ImVec2 (disabled by default to not collide with using IM_VEC2_CLASS_EXTRA along with your own math types+operators)
+
+#pragma once
+
+#ifndef IMGUI_VERSION
+#error Must include imgui.h before imgui_internal.h
+#endif
+
+#include <stdio.h>   // FILE*
+#include <math.h>    // sqrtf, fabsf, fmodf, powf, floorf, ceilf, cosf, sinf
+#include <limits.h>  // INT_MIN, INT_MAX
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4251)  // class 'xxx' needs to have dll-interface to be used by clients of struct 'xxx' // when IMGUI_API is set to__declspec(dllexport)
+#endif
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-function"     // for stb_textedit.h
+#pragma clang diagnostic ignored "-Wmissing-prototypes"  // for stb_textedit.h
+#pragma clang diagnostic ignored "-Wold-style-cast"
+#endif
+
+//-----------------------------------------------------------------------------
+// Forward Declarations
+//-----------------------------------------------------------------------------
+
+struct ImRect;
+struct ImGuiColMod;
+struct ImGuiStyleMod;
+struct ImGuiGroupData;
+struct ImGuiMenuColumns;
+struct ImGuiDrawContext;
+struct ImGuiTextEditState;
+struct ImGuiPopupRef;
+struct ImGuiWindow;
+struct ImGuiWindowSettings;
+
+typedef int ImGuiLayoutType;         // enum: horizontal or vertical             // enum ImGuiLayoutType_
+typedef int ImGuiButtonFlags;        // flags: for ButtonEx(), ButtonBehavior()  // enum ImGuiButtonFlags_
+typedef int ImGuiItemFlags;          // flags: for PushItemFlag()                // enum ImGuiItemFlags_
+typedef int ImGuiItemStatusFlags;    // flags: storage for DC.LastItemXXX        // enum ImGuiItemStatusFlags_
+typedef int ImGuiNavHighlightFlags;  // flags: for RenderNavHighlight()          // enum ImGuiNavHighlightFlags_
+typedef int ImGuiNavDirSourceFlags;  // flags: for GetNavInputAmount2d()         // enum ImGuiNavDirSourceFlags_
+typedef int ImGuiSeparatorFlags;     // flags: for Separator() - internal        // enum ImGuiSeparatorFlags_
+typedef int ImGuiSliderFlags;        // flags: for SliderBehavior()              // enum ImGuiSliderFlags_
+
+//-------------------------------------------------------------------------
+// STB libraries
+//-------------------------------------------------------------------------
+
+namespace ImGuiStb
+{
+#undef STB_TEXTEDIT_STRING
+#undef STB_TEXTEDIT_CHARTYPE
+#define STB_TEXTEDIT_STRING ImGuiTextEditState
+#define STB_TEXTEDIT_CHARTYPE ImWchar
+#define STB_TEXTEDIT_GETWIDTH_NEWLINE -1.0f
+#include "stb_textedit.h"
+
+}  // namespace ImGuiStb
+
+//-----------------------------------------------------------------------------
+// Context
+//-----------------------------------------------------------------------------
+
+#ifndef GImGui
+extern IMGUI_API ImGuiContext* GImGui;  // Current implicit ImGui context pointer
+#endif
+
+//-----------------------------------------------------------------------------
+// Helpers
+//-----------------------------------------------------------------------------
+
+#define IM_PI 3.14159265358979323846f
+
+// Helpers: UTF-8 <> wchar
+IMGUI_API int ImTextStrToUtf8(char* buf, int buf_size, const ImWchar* in_text, const ImWchar* in_text_end);                                   // return output UTF-8 bytes count
+IMGUI_API int ImTextCharFromUtf8(unsigned int* out_char, const char* in_text, const char* in_text_end);                                       // return input UTF-8 bytes count
+IMGUI_API int ImTextStrFromUtf8(ImWchar* buf, int buf_size, const char* in_text, const char* in_text_end, const char** in_remaining = NULL);  // return input UTF-8 bytes count
+IMGUI_API int ImTextCountCharsFromUtf8(const char* in_text, const char* in_text_end);                                                         // return number of UTF-8 code-points (NOT bytes count)
+IMGUI_API int ImTextCountUtf8BytesFromStr(const ImWchar* in_text, const ImWchar* in_text_end);                                                // return number of bytes to express string as UTF-8 code-points
+
+// Helpers: Misc
+IMGUI_API ImU32 ImHash(const void* data, int data_size, ImU32 seed = 0);  // Pass data_size==0 for zero-terminated strings
+IMGUI_API void* ImFileLoadToMemory(const char* filename, const char* file_open_mode, int* out_file_size = NULL, int padding_bytes = 0);
+IMGUI_API FILE* ImFileOpen(const char* filename, const char* file_open_mode);
+static inline bool ImCharIsSpace(int c) { return c == ' ' || c == '\t' || c == 0x3000; }
+static inline bool ImIsPowerOfTwo(int v) { return v != 0 && (v & (v - 1)) == 0; }
+static inline int ImUpperPowerOfTwo(int v)
+{
+	v--;
+	v |= v >> 1;
+	v |= v >> 2;
+	v |= v >> 4;
+	v |= v >> 8;
+	v |= v >> 16;
+	v++;
+	return v;
+}
+
+// Helpers: Geometry
+IMGUI_API ImVec2 ImLineClosestPoint(const ImVec2& a, const ImVec2& b, const ImVec2& p);
+IMGUI_API bool ImTriangleContainsPoint(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& p);
+IMGUI_API ImVec2 ImTriangleClosestPoint(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& p);
+IMGUI_API void ImTriangleBarycentricCoords(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& p, float& out_u, float& out_v, float& out_w);
+
+// Helpers: String
+IMGUI_API int ImStricmp(const char* str1, const char* str2);
+IMGUI_API int ImStrnicmp(const char* str1, const char* str2, size_t count);
+IMGUI_API void ImStrncpy(char* dst, const char* src, size_t count);
+IMGUI_API char* ImStrdup(const char* str);
+IMGUI_API char* ImStrchrRange(const char* str_begin, const char* str_end, char c);
+IMGUI_API int ImStrlenW(const ImWchar* str);
+IMGUI_API const ImWchar* ImStrbolW(const ImWchar* buf_mid_line, const ImWchar* buf_begin);  // Find beginning-of-line
+IMGUI_API const char* ImStristr(const char* haystack, const char* haystack_end, const char* needle, const char* needle_end);
+IMGUI_API int ImFormatString(char* buf, size_t buf_size, const char* fmt, ...) IM_FMTARGS(3);
+IMGUI_API int ImFormatStringV(char* buf, size_t buf_size, const char* fmt, va_list args) IM_FMTLIST(3);
+
+// Helpers: Math
+// We are keeping those not leaking to the user by default, in the case the user has implicit cast operators between ImVec2 and its own types (when IM_VEC2_CLASS_EXTRA is defined)
+#ifdef IMGUI_DEFINE_MATH_OPERATORS
+static inline ImVec2 operator*(const ImVec2& lhs, const float rhs)
+{
+	return ImVec2(lhs.x * rhs, lhs.y * rhs);
+}
+static inline ImVec2 operator/(const ImVec2& lhs, const float rhs) { return ImVec2(lhs.x / rhs, lhs.y / rhs); }
+static inline ImVec2 operator+(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x + rhs.x, lhs.y + rhs.y); }
+static inline ImVec2 operator-(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x - rhs.x, lhs.y - rhs.y); }
+static inline ImVec2 operator*(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x * rhs.x, lhs.y * rhs.y); }
+static inline ImVec2 operator/(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x / rhs.x, lhs.y / rhs.y); }
+static inline ImVec2& operator+=(ImVec2& lhs, const ImVec2& rhs)
+{
+	lhs.x += rhs.x;
+	lhs.y += rhs.y;
+	return lhs;
+}
+static inline ImVec2& operator-=(ImVec2& lhs, const ImVec2& rhs)
+{
+	lhs.x -= rhs.x;
+	lhs.y -= rhs.y;
+	return lhs;
+}
+static inline ImVec2& operator*=(ImVec2& lhs, const float rhs)
+{
+	lhs.x *= rhs;
+	lhs.y *= rhs;
+	return lhs;
+}
+static inline ImVec2& operator/=(ImVec2& lhs, const float rhs)
+{
+	lhs.x /= rhs;
+	lhs.y /= rhs;
+	return lhs;
+}
+static inline ImVec4 operator+(const ImVec4& lhs, const ImVec4& rhs) { return ImVec4(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z, lhs.w + rhs.w); }
+static inline ImVec4 operator-(const ImVec4& lhs, const ImVec4& rhs) { return ImVec4(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z, lhs.w - rhs.w); }
+static inline ImVec4 operator*(const ImVec4& lhs, const ImVec4& rhs) { return ImVec4(lhs.x * rhs.x, lhs.y * rhs.y, lhs.z * rhs.z, lhs.w * rhs.w); }
+#endif
+
+static inline int ImMin(int lhs, int rhs)
+{
+	return lhs < rhs ? lhs : rhs;
+}
+static inline int ImMax(int lhs, int rhs) { return lhs >= rhs ? lhs : rhs; }
+static inline float ImMin(float lhs, float rhs) { return lhs < rhs ? lhs : rhs; }
+static inline float ImMax(float lhs, float rhs) { return lhs >= rhs ? lhs : rhs; }
+static inline ImVec2 ImMin(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x < rhs.x ? lhs.x : rhs.x, lhs.y < rhs.y ? lhs.y : rhs.y); }
+static inline ImVec2 ImMax(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x >= rhs.x ? lhs.x : rhs.x, lhs.y >= rhs.y ? lhs.y : rhs.y); }
+static inline int ImClamp(int v, int mn, int mx) { return (v < mn) ? mn : (v > mx) ? mx : v; }
+static inline float ImClamp(float v, float mn, float mx) { return (v < mn) ? mn : (v > mx) ? mx : v; }
+static inline ImVec2 ImClamp(const ImVec2& f, const ImVec2& mn, ImVec2 mx) { return ImVec2(ImClamp(f.x, mn.x, mx.x), ImClamp(f.y, mn.y, mx.y)); }
+static inline float ImSaturate(float f) { return (f < 0.0f) ? 0.0f : (f > 1.0f) ? 1.0f : f; }
+static inline void ImSwap(int& a, int& b)
+{
+	int tmp = a;
+	a = b;
+	b = tmp;
+}
+static inline void ImSwap(float& a, float& b)
+{
+	float tmp = a;
+	a = b;
+	b = tmp;
+}
+static inline int ImLerp(int a, int b, float t) { return (int)(a + (b - a) * t); }
+static inline float ImLerp(float a, float b, float t) { return a + (b - a) * t; }
+static inline ImVec2 ImLerp(const ImVec2& a, const ImVec2& b, float t) { return ImVec2(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t); }
+static inline ImVec2 ImLerp(const ImVec2& a, const ImVec2& b, const ImVec2& t) { return ImVec2(a.x + (b.x - a.x) * t.x, a.y + (b.y - a.y) * t.y); }
+static inline ImVec4 ImLerp(const ImVec4& a, const ImVec4& b, float t) { return ImVec4(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t, a.w + (b.w - a.w) * t); }
+static inline float ImLengthSqr(const ImVec2& lhs) { return lhs.x * lhs.x + lhs.y * lhs.y; }
+static inline float ImLengthSqr(const ImVec4& lhs) { return lhs.x * lhs.x + lhs.y * lhs.y + lhs.z * lhs.z + lhs.w * lhs.w; }
+static inline float ImInvLength(const ImVec2& lhs, float fail_value)
+{
+	float d = lhs.x * lhs.x + lhs.y * lhs.y;
+	if (d > 0.0f) return 1.0f / sqrtf(d);
+	return fail_value;
+}
+static inline float ImFloor(float f) { return (float)(int)f; }
+static inline ImVec2 ImFloor(const ImVec2& v) { return ImVec2((float)(int)v.x, (float)(int)v.y); }
+static inline float ImDot(const ImVec2& a, const ImVec2& b) { return a.x * b.x + a.y * b.y; }
+static inline ImVec2 ImRotate(const ImVec2& v, float cos_a, float sin_a) { return ImVec2(v.x * cos_a - v.y * sin_a, v.x * sin_a + v.y * cos_a); }
+static inline float ImLinearSweep(float current, float target, float speed)
+{
+	if (current < target) return ImMin(current + speed, target);
+	if (current > target) return ImMax(current - speed, target);
+	return current;
+}
+static inline ImVec2 ImMul(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x * rhs.x, lhs.y * rhs.y); }
+
+// We call C++ constructor on own allocated memory via the placement "new(ptr) Type()" syntax.
+// Defining a custom placement new() with a dummy parameter allows us to bypass including <new> which on some platforms complains when user has disabled exceptions.
+struct ImNewPlacementDummy
+{
+};
+inline void* operator new(size_t, ImNewPlacementDummy, void* ptr) { return ptr; }
+inline void operator delete(void*, ImNewPlacementDummy, void*) {}  // This is only required so we can use the symetrical new()
+#define IM_PLACEMENT_NEW(_PTR) new (ImNewPlacementDummy(), _PTR)
+#define IM_NEW(_TYPE) new (ImNewPlacementDummy(), ImGui::MemAlloc(sizeof(_TYPE))) _TYPE
+template <typename T>
+void IM_DELETE(T*& p)
+{
+	if (p)
+	{
+		p->~T();
+		ImGui::MemFree(p);
+		p = NULL;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Types
+//-----------------------------------------------------------------------------
+
+enum ImGuiButtonFlags_
+{
+	ImGuiButtonFlags_Repeat = 1 << 0,                  // hold to repeat
+	ImGuiButtonFlags_PressedOnClickRelease = 1 << 1,   // return true on click + release on same item [DEFAULT if no PressedOn* flag is set]
+	ImGuiButtonFlags_PressedOnClick = 1 << 2,          // return true on click (default requires click+release)
+	ImGuiButtonFlags_PressedOnRelease = 1 << 3,        // return true on release (default requires click+release)
+	ImGuiButtonFlags_PressedOnDoubleClick = 1 << 4,    // return true on double-click (default requires click+release)
+	ImGuiButtonFlags_FlattenChildren = 1 << 5,         // allow interactions even if a child window is overlapping
+	ImGuiButtonFlags_AllowItemOverlap = 1 << 6,        // require previous frame HoveredId to either match id or be null before being usable, use along with SetItemAllowOverlap()
+	ImGuiButtonFlags_DontClosePopups = 1 << 7,         // disable automatically closing parent popup on press // [UNUSED]
+	ImGuiButtonFlags_Disabled = 1 << 8,                // disable interactions
+	ImGuiButtonFlags_AlignTextBaseLine = 1 << 9,       // vertically align button to match text baseline - ButtonEx() only // FIXME: Should be removed and handled by SmallButton(), not possible currently because of DC.CursorPosPrevLine
+	ImGuiButtonFlags_NoKeyModifiers = 1 << 10,         // disable interaction if a key modifier is held
+	ImGuiButtonFlags_NoHoldingActiveID = 1 << 11,      // don't set ActiveId while holding the mouse (ImGuiButtonFlags_PressedOnClick only)
+	ImGuiButtonFlags_PressedOnDragDropHold = 1 << 12,  // press when held into while we are drag and dropping another item (used by e.g. tree nodes, collapsing headers)
+	ImGuiButtonFlags_NoNavFocus = 1 << 13              // don't override navigation focus when activated
+};
+
+enum ImGuiSliderFlags_
+{
+	ImGuiSliderFlags_Vertical = 1 << 0
+};
+
+enum ImGuiColumnsFlags_
+{
+	// Default: 0
+	ImGuiColumnsFlags_NoBorder = 1 << 0,               // Disable column dividers
+	ImGuiColumnsFlags_NoResize = 1 << 1,               // Disable resizing columns when clicking on the dividers
+	ImGuiColumnsFlags_NoPreserveWidths = 1 << 2,       // Disable column width preservation when adjusting columns
+	ImGuiColumnsFlags_NoForceWithinWindow = 1 << 3,    // Disable forcing columns to fit within window
+	ImGuiColumnsFlags_GrowParentContentsSize = 1 << 4  // (WIP) Restore pre-1.51 behavior of extending the parent window contents size but _without affecting the columns width at all_. Will eventually remove.
+};
+
+enum ImGuiSelectableFlagsPrivate_
+{
+	// NB: need to be in sync with last value of ImGuiSelectableFlags_
+	ImGuiSelectableFlags_Menu = 1 << 3,      // -> PressedOnClick
+	ImGuiSelectableFlags_MenuItem = 1 << 4,  // -> PressedOnRelease
+	ImGuiSelectableFlags_Disabled = 1 << 5,
+	ImGuiSelectableFlags_DrawFillAvailWidth = 1 << 6
+};
+
+enum ImGuiSeparatorFlags_
+{
+	ImGuiSeparatorFlags_Horizontal = 1 << 0,  // Axis default to current layout type, so generally Horizontal unless e.g. in a menu bar
+	ImGuiSeparatorFlags_Vertical = 1 << 1
+};
+
+// Storage for LastItem data
+enum ImGuiItemStatusFlags_
+{
+	ImGuiItemStatusFlags_HoveredRect = 1 << 0,
+	ImGuiItemStatusFlags_HasDisplayRect = 1 << 1
+};
+
+// FIXME: this is in development, not exposed/functional as a generic feature yet.
+enum ImGuiLayoutType_
+{
+	ImGuiLayoutType_Vertical,
+	ImGuiLayoutType_Horizontal
+};
+
+enum ImGuiAxis
+{
+	ImGuiAxis_None = -1,
+	ImGuiAxis_X = 0,
+	ImGuiAxis_Y = 1
+};
+
+enum ImGuiPlotType
+{
+	ImGuiPlotType_Lines,
+	ImGuiPlotType_Histogram
+};
+
+enum ImGuiDataType
+{
+	ImGuiDataType_Int,
+	ImGuiDataType_Float,
+	ImGuiDataType_Float2
+};
+
+enum ImGuiDir
+{
+	ImGuiDir_None = -1,
+	ImGuiDir_Left = 0,
+	ImGuiDir_Right = 1,
+	ImGuiDir_Up = 2,
+	ImGuiDir_Down = 3,
+	ImGuiDir_Count_
+};
+
+enum ImGuiInputSource
+{
+	ImGuiInputSource_None = 0,
+	ImGuiInputSource_Mouse,
+	ImGuiInputSource_Nav,
+	ImGuiInputSource_NavKeyboard,  // Only used occasionally for storage, not tested/handled by most code
+	ImGuiInputSource_NavGamepad,   // "
+	ImGuiInputSource_Count_,
+};
+
+// FIXME-NAV: Clarify/expose various repeat delay/rate
+enum ImGuiInputReadMode
+{
+	ImGuiInputReadMode_Down,
+	ImGuiInputReadMode_Pressed,
+	ImGuiInputReadMode_Released,
+	ImGuiInputReadMode_Repeat,
+	ImGuiInputReadMode_RepeatSlow,
+	ImGuiInputReadMode_RepeatFast
+};
+
+enum ImGuiNavHighlightFlags_
+{
+	ImGuiNavHighlightFlags_TypeDefault = 1 << 0,
+	ImGuiNavHighlightFlags_TypeThin = 1 << 1,
+	ImGuiNavHighlightFlags_AlwaysDraw = 1 << 2,
+	ImGuiNavHighlightFlags_NoRounding = 1 << 3
+};
+
+enum ImGuiNavDirSourceFlags_
+{
+	ImGuiNavDirSourceFlags_Keyboard = 1 << 0,
+	ImGuiNavDirSourceFlags_PadDPad = 1 << 1,
+	ImGuiNavDirSourceFlags_PadLStick = 1 << 2
+};
+
+enum ImGuiNavForward
+{
+	ImGuiNavForward_None,
+	ImGuiNavForward_ForwardQueued,
+	ImGuiNavForward_ForwardActive
+};
+
+// 2D axis aligned bounding-box
+// NB: we can't rely on ImVec2 math operators being available here
+struct IMGUI_API ImRect
+{
+	ImVec2 Min;  // Upper-left
+	ImVec2 Max;  // Lower-right
+
+	ImRect() : Min(FLT_MAX, FLT_MAX), Max(-FLT_MAX, -FLT_MAX) {}
+	ImRect(const ImVec2& min, const ImVec2& max) : Min(min), Max(max) {}
+	ImRect(const ImVec4& v) : Min(v.x, v.y), Max(v.z, v.w) {}
+	ImRect(float x1, float y1, float x2, float y2) : Min(x1, y1), Max(x2, y2) {}
+
+	ImVec2 GetCenter() const { return ImVec2((Min.x + Max.x) * 0.5f, (Min.y + Max.y) * 0.5f); }
+	ImVec2 GetSize() const { return ImVec2(Max.x - Min.x, Max.y - Min.y); }
+	float GetWidth() const { return Max.x - Min.x; }
+	float GetHeight() const { return Max.y - Min.y; }
+	ImVec2 GetTL() const { return Min; }                   // Top-left
+	ImVec2 GetTR() const { return ImVec2(Max.x, Min.y); }  // Top-right
+	ImVec2 GetBL() const { return ImVec2(Min.x, Max.y); }  // Bottom-left
+	ImVec2 GetBR() const { return Max; }                   // Bottom-right
+	bool Contains(const ImVec2& p) const { return p.x >= Min.x && p.y >= Min.y && p.x < Max.x && p.y < Max.y; }
+	bool Contains(const ImRect& r) const { return r.Min.x >= Min.x && r.Min.y >= Min.y && r.Max.x <= Max.x && r.Max.y <= Max.y; }
+	bool Overlaps(const ImRect& r) const { return r.Min.y < Max.y && r.Max.y > Min.y && r.Min.x < Max.x && r.Max.x > Min.x; }
+	void Add(const ImVec2& p)
+	{
+		if (Min.x > p.x) Min.x = p.x;
+		if (Min.y > p.y) Min.y = p.y;
+		if (Max.x < p.x) Max.x = p.x;
+		if (Max.y < p.y) Max.y = p.y;
+	}
+	void Add(const ImRect& r)
+	{
+		if (Min.x > r.Min.x) Min.x = r.Min.x;
+		if (Min.y > r.Min.y) Min.y = r.Min.y;
+		if (Max.x < r.Max.x) Max.x = r.Max.x;
+		if (Max.y < r.Max.y) Max.y = r.Max.y;
+	}
+	void Expand(const float amount)
+	{
+		Min.x -= amount;
+		Min.y -= amount;
+		Max.x += amount;
+		Max.y += amount;
+	}
+	void Expand(const ImVec2& amount)
+	{
+		Min.x -= amount.x;
+		Min.y -= amount.y;
+		Max.x += amount.x;
+		Max.y += amount.y;
+	}
+	void Translate(const ImVec2& v)
+	{
+		Min.x += v.x;
+		Min.y += v.y;
+		Max.x += v.x;
+		Max.y += v.y;
+	}
+	void ClipWith(const ImRect& r)
+	{
+		Min = ImMax(Min, r.Min);
+		Max = ImMin(Max, r.Max);
+	}  // Simple version, may lead to an inverted rectangle, which is fine for Contains/Overlaps test but not for display.
+	void ClipWithFull(const ImRect& r)
+	{
+		Min = ImClamp(Min, r.Min, r.Max);
+		Max = ImClamp(Max, r.Min, r.Max);
+	}  // Full version, ensure both points are fully clipped.
+	void Floor()
+	{
+		Min.x = (float)(int)Min.x;
+		Min.y = (float)(int)Min.y;
+		Max.x = (float)(int)Max.x;
+		Max.y = (float)(int)Max.y;
+	}
+	void FixInverted()
+	{
+		if (Min.x > Max.x) ImSwap(Min.x, Max.x);
+		if (Min.y > Max.y) ImSwap(Min.y, Max.y);
+	}
+	bool IsInverted() const { return Min.x > Max.x || Min.y > Max.y; }
+	bool IsFinite() const { return Min.x != FLT_MAX; }
+};
+
+// Stacked color modifier, backup of modified data so we can restore it
+struct ImGuiColMod
+{
+	ImGuiCol Col;
+	ImVec4 BackupValue;
+};
+
+// Stacked style modifier, backup of modified data so we can restore it. Data type inferred from the variable.
+struct ImGuiStyleMod
+{
+	ImGuiStyleVar VarIdx;
+	union {
+		int BackupInt[2];
+		float BackupFloat[2];
+	};
+	ImGuiStyleMod(ImGuiStyleVar idx, int v)
+	{
+		VarIdx = idx;
+		BackupInt[0] = v;
+	}
+	ImGuiStyleMod(ImGuiStyleVar idx, float v)
+	{
+		VarIdx = idx;
+		BackupFloat[0] = v;
+	}
+	ImGuiStyleMod(ImGuiStyleVar idx, ImVec2 v)
+	{
+		VarIdx = idx;
+		BackupFloat[0] = v.x;
+		BackupFloat[1] = v.y;
+	}
+};
+
+// Stacked data for BeginGroup()/EndGroup()
+struct ImGuiGroupData
+{
+	ImVec2 BackupCursorPos;
+	ImVec2 BackupCursorMaxPos;
+	float BackupIndentX;
+	float BackupGroupOffsetX;
+	float BackupCurrentLineHeight;
+	float BackupCurrentLineTextBaseOffset;
+	float BackupLogLinePosY;
+	bool BackupActiveIdIsAlive;
+	bool AdvanceCursor;
+};
+
+// Simple column measurement currently used for MenuItem() only. This is very short-sighted/throw-away code and NOT a generic helper.
+struct IMGUI_API ImGuiMenuColumns
+{
+	int Count;
+	float Spacing;
+	float Width, NextWidth;
+	float Pos[4], NextWidths[4];
+
+	ImGuiMenuColumns();
+	void Update(int count, float spacing, bool clear);
+	float DeclColumns(float w0, float w1, float w2);
+	float CalcExtraSpace(float avail_w);
+};
+
+// Internal state of the currently focused/edited text input box
+struct IMGUI_API ImGuiTextEditState
+{
+	ImGuiID Id;                  // widget id owning the text state
+	ImVector<ImWchar> Text;      // edit buffer, we need to persist but can't guarantee the persistence of the user-provided buffer. so we copy into own buffer.
+	ImVector<char> InitialText;  // backup of end-user buffer at the time of focus (in UTF-8, unaltered)
+	ImVector<char> TempTextBuffer;
+	int CurLenA, CurLenW;  // we need to maintain our buffer length in both UTF-8 and wchar format.
+	int BufSizeA;          // end-user buffer size
+	float ScrollX;
+	ImGuiStb::STB_TexteditState StbState;
+	float CursorAnim;
+	bool CursorFollow;
+	bool SelectedAllMouseLock;
+
+	ImGuiTextEditState() { memset(this, 0, sizeof(*this)); }
+	void CursorAnimReset() { CursorAnim = -0.30f; }  // After a user-input the cursor stays on for a while without blinking
+	void CursorClamp()
+	{
+		StbState.cursor = ImMin(StbState.cursor, CurLenW);
+		StbState.select_start = ImMin(StbState.select_start, CurLenW);
+		StbState.select_end = ImMin(StbState.select_end, CurLenW);
+	}
+	bool HasSelection() const { return StbState.select_start != StbState.select_end; }
+	void ClearSelection() { StbState.select_start = StbState.select_end = StbState.cursor; }
+	void SelectAll()
+	{
+		StbState.select_start = 0;
+		StbState.cursor = StbState.select_end = CurLenW;
+		StbState.has_preferred_x = false;
+	}
+	void OnKeyPressed(int key);
+};
+
+// Data saved in imgui.ini file
+struct ImGuiWindowSettings
+{
+	char* Name;
+	ImGuiID Id;
+	ImVec2 Pos;
+	ImVec2 Size;
+	bool Collapsed;
+
+	ImGuiWindowSettings()
+	{
+		Name = NULL;
+		Id = 0;
+		Pos = Size = ImVec2(0, 0);
+		Collapsed = false;
+	}
+};
+
+struct ImGuiSettingsHandler
+{
+	const char* TypeName;  // Short description stored in .ini file. Disallowed characters: '[' ']'
+	ImGuiID TypeHash;      // == ImHash(TypeName, 0, 0)
+	void* (*ReadOpenFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler, const char* name);
+	void (*ReadLineFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler, void* entry, const char* line);
+	void (*WriteAllFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler, ImGuiTextBuffer* out_buf);
+	void* UserData;
+
+	ImGuiSettingsHandler() { memset(this, 0, sizeof(*this)); }
+};
+
+// Storage for current popup stack
+struct ImGuiPopupRef
+{
+	ImGuiID PopupId;            // Set on OpenPopup()
+	ImGuiWindow* Window;        // Resolved on BeginPopup() - may stay unresolved if user never calls OpenPopup()
+	ImGuiWindow* ParentWindow;  // Set on OpenPopup()
+	int OpenFrameCount;         // Set on OpenPopup()
+	ImGuiID OpenParentId;       // Set on OpenPopup(), we need this to differenciate multiple menu sets from each others (e.g. inside menu bar vs loose menu items)
+	ImVec2 OpenPopupPos;        // Set on OpenPopup(), preferred popup position (typically == OpenMousePos when using mouse)
+	ImVec2 OpenMousePos;        // Set on OpenPopup(), copy of mouse position at the time of opening popup
+};
+
+struct ImGuiColumnData
+{
+	float OffsetNorm;  // Column start offset, normalized 0.0 (far left) -> 1.0 (far right)
+	float OffsetNormBeforeResize;
+	ImGuiColumnsFlags Flags;  // Not exposed
+	ImRect ClipRect;
+
+	ImGuiColumnData()
+	{
+		OffsetNorm = OffsetNormBeforeResize = 0.0f;
+		Flags = 0;
+	}
+};
+
+struct ImGuiColumnsSet
+{
+	ImGuiID ID;
+	ImGuiColumnsFlags Flags;
+	bool IsFirstFrame;
+	bool IsBeingResized;
+	int Current;
+	int Count;
+	float MinX, MaxX;
+	float StartPosY;
+	float StartMaxPosX;  // Backup of CursorMaxPos
+	float CellMinY, CellMaxY;
+	ImVector<ImGuiColumnData> Columns;
+
+	ImGuiColumnsSet() { Clear(); }
+	void Clear()
+	{
+		ID = 0;
+		Flags = 0;
+		IsFirstFrame = false;
+		IsBeingResized = false;
+		Current = 0;
+		Count = 1;
+		MinX = MaxX = 0.0f;
+		StartPosY = 0.0f;
+		StartMaxPosX = 0.0f;
+		CellMinY = CellMaxY = 0.0f;
+		Columns.clear();
+	}
+};
+
+struct IMGUI_API ImDrawListSharedData
+{
+	ImVec2 TexUvWhitePixel;  // UV of white pixel in the atlas
+	ImFont* Font;            // Current/default font (optional, for simplified AddText overload)
+	float FontSize;          // Current/default font size (optional, for simplified AddText overload)
+	float CurveTessellationTol;
+	ImVec4 ClipRectFullscreen;  // Value for PushClipRectFullscreen()
+
+	// Const data
+	// FIXME: Bake rounded corners fill/borders in atlas
+	ImVec2 CircleVtx12[12];
+
+	ImDrawListSharedData();
+};
+
+struct ImDrawDataBuilder
+{
+	ImVector<ImDrawList*> Layers[2];  // Global layers for: regular, tooltip
+
+	void Clear()
+	{
+		for (int n = 0; n < IM_ARRAYSIZE(Layers); n++) Layers[n].resize(0);
+	}
+	void ClearFreeMemory()
+	{
+		for (int n = 0; n < IM_ARRAYSIZE(Layers); n++) Layers[n].clear();
+	}
+	IMGUI_API void FlattenIntoSingleLayer();
+};
+
+struct ImGuiNavMoveResult
+{
+	ImGuiID ID;           // Best candidate
+	ImGuiID ParentID;     // Best candidate window->IDStack.back() - to compare context
+	ImGuiWindow* Window;  // Best candidate window
+	float DistBox;        // Best candidate box distance to current NavId
+	float DistCenter;     // Best candidate center distance to current NavId
+	float DistAxial;
+	ImRect RectRel;  // Best candidate bounding box in window relative space
+
+	ImGuiNavMoveResult() { Clear(); }
+	void Clear()
+	{
+		ID = ParentID = 0;
+		Window = NULL;
+		DistBox = DistCenter = DistAxial = FLT_MAX;
+		RectRel = ImRect();
+	}
+};
+
+// Storage for SetNexWindow** functions
+struct ImGuiNextWindowData
+{
+	ImGuiCond PosCond;
+	ImGuiCond SizeCond;
+	ImGuiCond ContentSizeCond;
+	ImGuiCond CollapsedCond;
+	ImGuiCond SizeConstraintCond;
+	ImGuiCond FocusCond;
+	ImGuiCond BgAlphaCond;
+	ImVec2 PosVal;
+	ImVec2 PosPivotVal;
+	ImVec2 SizeVal;
+	ImVec2 ContentSizeVal;
+	bool CollapsedVal;
+	ImRect SizeConstraintRect;  // Valid if 'SetNextWindowSizeConstraint' is true
+	ImGuiSizeCallback SizeCallback;
+	void* SizeCallbackUserData;
+	float BgAlphaVal;
+
+	ImGuiNextWindowData()
+	{
+		PosCond = SizeCond = ContentSizeCond = CollapsedCond = SizeConstraintCond = FocusCond = BgAlphaCond = 0;
+		PosVal = PosPivotVal = SizeVal = ImVec2(0.0f, 0.0f);
+		ContentSizeVal = ImVec2(0.0f, 0.0f);
+		CollapsedVal = false;
+		SizeConstraintRect = ImRect();
+		SizeCallback = NULL;
+		SizeCallbackUserData = NULL;
+		BgAlphaVal = FLT_MAX;
+	}
+
+	void Clear()
+	{
+		PosCond = SizeCond = ContentSizeCond = CollapsedCond = SizeConstraintCond = FocusCond = BgAlphaCond = 0;
+	}
+};
+
+// Main state for ImGui
+struct ImGuiContext
+{
+	bool Initialized;
+	bool FontAtlasOwnedByContext;  // Io.Fonts-> is owned by the ImGuiContext and will be destructed along with it.
+	ImGuiIO IO;
+	ImGuiStyle Style;
+	ImFont* Font;        // (Shortcut) == FontStack.empty() ? IO.Font : FontStack.back()
+	float FontSize;      // (Shortcut) == FontBaseSize * g.CurrentWindow->FontWindowScale == window->FontSize(). Text height for current window.
+	float FontBaseSize;  // (Shortcut) == IO.FontGlobalScale * Font->Scale * Font->FontSize. Base text height.
+	ImDrawListSharedData DrawListSharedData;
+
+	float Time;
+	int FrameCount;
+	int FrameCountEnded;
+	int FrameCountRendered;
+	ImVector<ImGuiWindow*> Windows;
+	ImVector<ImGuiWindow*> WindowsSortBuffer;
+	ImVector<ImGuiWindow*> CurrentWindowStack;
+	ImGuiStorage WindowsById;
+	int WindowsActiveCount;
+	ImGuiWindow* CurrentWindow;      // Being drawn into
+	ImGuiWindow* HoveredWindow;      // Will catch mouse inputs
+	ImGuiWindow* HoveredRootWindow;  // Will catch mouse inputs (for focus/move only)
+	ImGuiID HoveredId;               // Hovered widget
+	bool HoveredIdAllowOverlap;
+	ImGuiID HoveredIdPreviousFrame;
+	float HoveredIdTimer;
+	ImGuiID ActiveId;  // Active widget
+	ImGuiID ActiveIdPreviousFrame;
+	float ActiveIdTimer;
+	bool ActiveIdIsAlive;          // Active widget has been seen this frame
+	bool ActiveIdIsJustActivated;  // Set at the time of activation for one frame
+	bool ActiveIdAllowOverlap;     // Active widget allows another widget to steal active id (generally for overlapping widgets, but not always)
+	int ActiveIdAllowNavDirFlags;  // Active widget allows using directional navigation (e.g. can activate a button and move away from it)
+	ImVec2 ActiveIdClickOffset;    // Clicked offset from upper-left corner, if applicable (currently only set by ButtonBehavior)
+	ImGuiWindow* ActiveIdWindow;
+	ImGuiInputSource ActiveIdSource;            // Activating with mouse or nav (gamepad/keyboard)
+	ImGuiWindow* MovingWindow;                  // Track the window we clicked on (in order to preserve focus). The actually window that is moved is generally MovingWindow->RootWindow.
+	ImVector<ImGuiColMod> ColorModifiers;       // Stack for PushStyleColor()/PopStyleColor()
+	ImVector<ImGuiStyleMod> StyleModifiers;     // Stack for PushStyleVar()/PopStyleVar()
+	ImVector<ImFont*> FontStack;                // Stack for PushFont()/PopFont()
+	ImVector<ImGuiPopupRef> OpenPopupStack;     // Which popups are open (persistent)
+	ImVector<ImGuiPopupRef> CurrentPopupStack;  // Which level of BeginPopup() we are in (reset every frame)
+	ImGuiNextWindowData NextWindowData;         // Storage for SetNextWindow** functions
+	bool NextTreeNodeOpenVal;                   // Storage for SetNextTreeNode** functions
+	ImGuiCond NextTreeNodeOpenCond;
+
+	// Navigation data (for gamepad/keyboard)
+	ImGuiWindow* NavWindow;           // Focused window for navigation. Could be called 'FocusWindow'
+	ImGuiID NavId;                    // Focused item for navigation
+	ImGuiID NavActivateId;            // ~~ (g.ActiveId == 0) && IsNavInputPressed(ImGuiNavInput_Activate) ? NavId : 0, also set when calling ActivateItem()
+	ImGuiID NavActivateDownId;        // ~~ IsNavInputDown(ImGuiNavInput_Activate) ? NavId : 0
+	ImGuiID NavActivatePressedId;     // ~~ IsNavInputPressed(ImGuiNavInput_Activate) ? NavId : 0
+	ImGuiID NavInputId;               // ~~ IsNavInputPressed(ImGuiNavInput_Input) ? NavId : 0
+	ImGuiID NavJustTabbedId;          // Just tabbed to this id.
+	ImGuiID NavNextActivateId;        // Set by ActivateItem(), queued until next frame
+	ImGuiID NavJustMovedToId;         // Just navigated to this id (result of a successfully MoveRequest)
+	ImRect NavScoringRectScreen;      // Rectangle used for scoring, in screen space. Based of window->DC.NavRefRectRel[], modified for directional navigation scoring.
+	int NavScoringCount;              // Metrics for debugging
+	ImGuiWindow* NavWindowingTarget;  // When selecting a window (holding Menu+FocusPrev/Next, or equivalent of CTRL-TAB) this window is temporarily displayed front-most.
+	float NavWindowingHighlightTimer;
+	float NavWindowingHighlightAlpha;
+	bool NavWindowingToggleLayer;
+	ImGuiInputSource NavWindowingInputSource;  // Gamepad or keyboard mode
+	int NavLayer;                              // Layer we are navigating on. For now the system is hard-coded for 0=main contents and 1=menu/title bar, may expose layers later.
+	int NavIdTabCounter;                       // == NavWindow->DC.FocusIdxTabCounter at time of NavId processing
+	bool NavIdIsAlive;                         // Nav widget has been seen this frame ~~ NavRefRectRel is valid
+	bool NavMousePosDirty;                     // When set we will update mouse position if (NavFlags & ImGuiNavFlags_MoveMouse) if set (NB: this not enabled by default)
+	bool NavDisableHighlight;                  // When user starts using mouse, we hide gamepad/keyboard highlight (nb: but they are still available, which is why NavDisableHighlight isn't always != NavDisableMouseHover)
+	bool NavDisableMouseHover;                 // When user starts using gamepad/keyboard, we hide mouse hovering highlight until mouse is touched again.
+	bool NavAnyRequest;                        // ~~ NavMoveRequest || NavInitRequest
+	bool NavInitRequest;                       // Init request for appearing window to select first item
+	bool NavInitRequestFromMove;
+	ImGuiID NavInitResultId;
+	ImRect NavInitResultRectRel;
+	bool NavMoveFromClampedRefRect;         // Set by manual scrolling, if we scroll to a point where NavId isn't visible we reset navigation from visible items
+	bool NavMoveRequest;                    // Move request for this frame
+	ImGuiNavForward NavMoveRequestForward;  // None / ForwardQueued / ForwardActive (this is used to navigate sibling parent menus from a child menu)
+	ImGuiDir NavMoveDir, NavMoveDirLast;    // Direction of the move request (left/right/up/down), direction of the previous move request
+	ImGuiNavMoveResult NavMoveResultLocal;  // Best move request candidate within NavWindow
+	ImGuiNavMoveResult NavMoveResultOther;  // Best move request candidate within NavWindow's flattened hierarchy (when using the NavFlattened flag)
+
+	// Render
+	ImDrawData DrawData;  // Main ImDrawData instance to pass render information to the user
+	ImDrawDataBuilder DrawDataBuilder;
+	float ModalWindowDarkeningRatio;
+	ImDrawList OverlayDrawList;  // Optional software render of mouse cursors, if io.MouseDrawCursor is set + a few debug overlays
+	ImGuiMouseCursor MouseCursor;
+
+	// Drag and Drop
+	bool DragDropActive;
+	ImGuiDragDropFlags DragDropSourceFlags;
+	int DragDropMouseButton;
+	ImGuiPayload DragDropPayload;
+	ImRect DragDropTargetRect;
+	ImGuiID DragDropTargetId;
+	float DragDropAcceptIdCurrRectSurface;
+	ImGuiID DragDropAcceptIdCurr;                    // Target item id (set at the time of accepting the payload)
+	ImGuiID DragDropAcceptIdPrev;                    // Target item id from previous frame (we need to store this to allow for overlapping drag and drop targets)
+	int DragDropAcceptFrameCount;                    // Last time a target expressed a desire to accept the source
+	ImVector<unsigned char> DragDropPayloadBufHeap;  // We don't expose the ImVector<> directly
+	unsigned char DragDropPayloadBufLocal[8];
+
+	// Widget state
+	ImGuiTextEditState InputTextState;
+	ImFont InputTextPasswordFont;
+	ImGuiID ScalarAsInputTextId;           // Temporary text input when CTRL+clicking on a slider, etc.
+	ImGuiColorEditFlags ColorEditOptions;  // Store user options for color edit widgets
+	ImVec4 ColorPickerRef;
+	float DragCurrentValue;  // Currently dragged value, always float, not rounded by end-user precision settings
+	ImVec2 DragLastMouseDelta;
+	float DragSpeedDefaultRatio;  // If speed == 0.0f, uses (max-min) * DragSpeedDefaultRatio
+	float DragSpeedScaleSlow;
+	float DragSpeedScaleFast;
+	ImVec2 ScrollbarClickDeltaToGrabCenter;  // Distance between mouse and center of grab box, normalized in parent space. Use storage?
+	int TooltipOverrideCount;
+	ImVector<char> PrivateClipboard;      // If no custom clipboard handler is defined
+	ImVec2 OsImePosRequest, OsImePosSet;  // Cursor position request & last passed to the OS Input Method Editor
+
+	// Settings
+	bool SettingsLoaded;
+	float SettingsDirtyTimer;                         // Save .ini Settings on disk when time reaches zero
+	ImVector<ImGuiWindowSettings> SettingsWindows;    // .ini settings for ImGuiWindow
+	ImVector<ImGuiSettingsHandler> SettingsHandlers;  // List of .ini settings handlers
+
+	// Logging
+	bool LogEnabled;
+	FILE* LogFile;                  // If != NULL log to stdout/ file
+	ImGuiTextBuffer* LogClipboard;  // Else log to clipboard. This is pointer so our GImGui static constructor doesn't call heap allocators.
+	int LogStartDepth;
+	int LogAutoExpandMaxDepth;
+
+	// Misc
+	float FramerateSecPerFrame[120];  // calculate estimate of framerate for user
+	int FramerateSecPerFrameIdx;
+	float FramerateSecPerFrameAccum;
+	int WantCaptureMouseNextFrame;  // explicit capture via CaptureInputs() sets those flags
+	int WantCaptureKeyboardNextFrame;
+	int WantTextInputNextFrame;
+	char TempBuffer[1024 * 3 + 1];  // temporary text buffer
+
+	ImGuiContext(ImFontAtlas* shared_font_atlas) : OverlayDrawList(NULL)
+	{
+		Initialized = false;
+		Font = NULL;
+		FontSize = FontBaseSize = 0.0f;
+		FontAtlasOwnedByContext = shared_font_atlas ? false : true;
+		IO.Fonts = shared_font_atlas ? shared_font_atlas : IM_NEW(ImFontAtlas)();
+
+		Time = 0.0f;
+		FrameCount = 0;
+		FrameCountEnded = FrameCountRendered = -1;
+		WindowsActiveCount = 0;
+		CurrentWindow = NULL;
+		HoveredWindow = NULL;
+		HoveredRootWindow = NULL;
+		HoveredId = 0;
+		HoveredIdAllowOverlap = false;
+		HoveredIdPreviousFrame = 0;
+		HoveredIdTimer = 0.0f;
+		ActiveId = 0;
+		ActiveIdPreviousFrame = 0;
+		ActiveIdTimer = 0.0f;
+		ActiveIdIsAlive = false;
+		ActiveIdIsJustActivated = false;
+		ActiveIdAllowOverlap = false;
+		ActiveIdAllowNavDirFlags = 0;
+		ActiveIdClickOffset = ImVec2(-1, -1);
+		ActiveIdWindow = NULL;
+		ActiveIdSource = ImGuiInputSource_None;
+		MovingWindow = NULL;
+		NextTreeNodeOpenVal = false;
+		NextTreeNodeOpenCond = 0;
+
+		NavWindow = NULL;
+		NavId = NavActivateId = NavActivateDownId = NavActivatePressedId = NavInputId = 0;
+		NavJustTabbedId = NavJustMovedToId = NavNextActivateId = 0;
+		NavScoringRectScreen = ImRect();
+		NavScoringCount = 0;
+		NavWindowingTarget = NULL;
+		NavWindowingHighlightTimer = NavWindowingHighlightAlpha = 0.0f;
+		NavWindowingToggleLayer = false;
+		NavWindowingInputSource = ImGuiInputSource_None;
+		NavLayer = 0;
+		NavIdTabCounter = INT_MAX;
+		NavIdIsAlive = false;
+		NavMousePosDirty = false;
+		NavDisableHighlight = true;
+		NavDisableMouseHover = false;
+		NavAnyRequest = false;
+		NavInitRequest = false;
+		NavInitRequestFromMove = false;
+		NavInitResultId = 0;
+		NavMoveFromClampedRefRect = false;
+		NavMoveRequest = false;
+		NavMoveRequestForward = ImGuiNavForward_None;
+		NavMoveDir = NavMoveDirLast = ImGuiDir_None;
+
+		ModalWindowDarkeningRatio = 0.0f;
+		OverlayDrawList._Data = &DrawListSharedData;
+		OverlayDrawList._OwnerName = "##Overlay";  // Give it a name for debugging
+		MouseCursor = ImGuiMouseCursor_Arrow;
+
+		DragDropActive = false;
+		DragDropSourceFlags = 0;
+		DragDropMouseButton = -1;
+		DragDropTargetId = 0;
+		DragDropAcceptIdCurrRectSurface = 0.0f;
+		DragDropAcceptIdPrev = DragDropAcceptIdCurr = 0;
+		DragDropAcceptFrameCount = -1;
+		memset(DragDropPayloadBufLocal, 0, sizeof(DragDropPayloadBufLocal));
+
+		ScalarAsInputTextId = 0;
+		ColorEditOptions = ImGuiColorEditFlags__OptionsDefault;
+		DragCurrentValue = 0.0f;
+		DragLastMouseDelta = ImVec2(0.0f, 0.0f);
+		DragSpeedDefaultRatio = 1.0f / 100.0f;
+		DragSpeedScaleSlow = 1.0f / 100.0f;
+		DragSpeedScaleFast = 10.0f;
+		ScrollbarClickDeltaToGrabCenter = ImVec2(0.0f, 0.0f);
+		TooltipOverrideCount = 0;
+		OsImePosRequest = OsImePosSet = ImVec2(-1.0f, -1.0f);
+
+		SettingsLoaded = false;
+		SettingsDirtyTimer = 0.0f;
+
+		LogEnabled = false;
+		LogFile = NULL;
+		LogClipboard = NULL;
+		LogStartDepth = 0;
+		LogAutoExpandMaxDepth = 2;
+
+		memset(FramerateSecPerFrame, 0, sizeof(FramerateSecPerFrame));
+		FramerateSecPerFrameIdx = 0;
+		FramerateSecPerFrameAccum = 0.0f;
+		WantCaptureMouseNextFrame = WantCaptureKeyboardNextFrame = WantTextInputNextFrame = -1;
+		memset(TempBuffer, 0, sizeof(TempBuffer));
+	}
+};
+
+// Transient per-window flags, reset at the beginning of the frame. For child window, inherited from parent on first Begin().
+// This is going to be exposed in imgui.h when stabilized enough.
+enum ImGuiItemFlags_
+{
+	ImGuiItemFlags_AllowKeyboardFocus = 1 << 0,        // true
+	ImGuiItemFlags_ButtonRepeat = 1 << 1,              // false    // Button() will return true multiple times based on io.KeyRepeatDelay and io.KeyRepeatRate settings.
+	ImGuiItemFlags_Disabled = 1 << 2,                  // false    // FIXME-WIP: Disable interactions but doesn't affect visuals. Should be: grey out and disable interactions with widgets that affect data + view widgets (WIP)
+	ImGuiItemFlags_NoNav = 1 << 3,                     // false
+	ImGuiItemFlags_NoNavDefaultFocus = 1 << 4,         // false
+	ImGuiItemFlags_SelectableDontClosePopup = 1 << 5,  // false    // MenuItem/Selectable() automatically closes current Popup window
+	ImGuiItemFlags_Default_ = ImGuiItemFlags_AllowKeyboardFocus
+};
+
+// Transient per-window data, reset at the beginning of the frame
+// FIXME: That's theory, in practice the delimitation between ImGuiWindow and ImGuiDrawContext is quite tenuous and could be reconsidered.
+struct IMGUI_API ImGuiDrawContext
+{
+	ImVec2 CursorPos;
+	ImVec2 CursorPosPrevLine;
+	ImVec2 CursorStartPos;
+	ImVec2 CursorMaxPos;  // Used to implicitly calculate the size of our contents, always growing during the frame. Turned into window->SizeContents at the beginning of next frame
+	float CurrentLineHeight;
+	float CurrentLineTextBaseOffset;
+	float PrevLineHeight;
+	float PrevLineTextBaseOffset;
+	float LogLinePosY;
+	int TreeDepth;
+	ImU32 TreeDepthMayCloseOnPop;  // Store a copy of !g.NavIdIsAlive for TreeDepth 0..31
+	ImGuiID LastItemId;
+	ImGuiItemStatusFlags LastItemStatusFlags;
+	ImRect LastItemRect;         // Interaction rect
+	ImRect LastItemDisplayRect;  // End-user display rect (only valid if LastItemStatusFlags & ImGuiItemStatusFlags_HasDisplayRect)
+	bool NavHideHighlightOneFrame;
+	bool NavHasScroll;           // Set when scrolling can be used (ScrollMax > 0.0f)
+	int NavLayerCurrent;         // Current layer, 0..31 (we currently only use 0..1)
+	int NavLayerCurrentMask;     // = (1 << NavLayerCurrent) used by ItemAdd prior to clipping.
+	int NavLayerActiveMask;      // Which layer have been written to (result from previous frame)
+	int NavLayerActiveMaskNext;  // Which layer have been written to (buffer for current frame)
+	bool MenuBarAppending;       // FIXME: Remove this
+	float MenuBarOffsetX;
+	ImVector<ImGuiWindow*> ChildWindows;
+	ImGuiStorage* StateStorage;
+	ImGuiLayoutType LayoutType;
+	ImGuiLayoutType ParentLayoutType;  // Layout type of parent window at the time of Begin()
+
+	// We store the current settings outside of the vectors to increase memory locality (reduce cache misses). The vectors are rarely modified. Also it allows us to not heap allocate for short-lived windows which are not using those settings.
+	ImGuiItemFlags ItemFlags;  // == ItemFlagsStack.back() [empty == ImGuiItemFlags_Default]
+	float ItemWidth;           // == ItemWidthStack.back(). 0.0: default, >0.0: width in pixels, <0.0: align xx pixels to the right of window
+	float TextWrapPos;         // == TextWrapPosStack.back() [empty == -1.0f]
+	ImVector<ImGuiItemFlags> ItemFlagsStack;
+	ImVector<float> ItemWidthStack;
+	ImVector<float> TextWrapPosStack;
+	ImVector<ImGuiGroupData> GroupStack;
+	int StackSizesBackup[6];  // Store size of various stacks for asserting
+
+	float IndentX;  // Indentation / start position from left of window (increased by TreePush/TreePop, etc.)
+	float GroupOffsetX;
+	float ColumnsOffsetX;         // Offset to the current column (if ColumnsCurrent > 0). FIXME: This and the above should be a stack to allow use cases like Tree->Column->Tree. Need revamp columns API.
+	ImGuiColumnsSet* ColumnsSet;  // Current columns set
+
+	ImGuiDrawContext()
+	{
+		CursorPos = CursorPosPrevLine = CursorStartPos = CursorMaxPos = ImVec2(0.0f, 0.0f);
+		CurrentLineHeight = PrevLineHeight = 0.0f;
+		CurrentLineTextBaseOffset = PrevLineTextBaseOffset = 0.0f;
+		LogLinePosY = -1.0f;
+		TreeDepth = 0;
+		TreeDepthMayCloseOnPop = 0x00;
+		LastItemId = 0;
+		LastItemStatusFlags = 0;
+		LastItemRect = LastItemDisplayRect = ImRect();
+		NavHideHighlightOneFrame = false;
+		NavHasScroll = false;
+		NavLayerActiveMask = NavLayerActiveMaskNext = 0x00;
+		NavLayerCurrent = 0;
+		NavLayerCurrentMask = 1 << 0;
+		MenuBarAppending = false;
+		MenuBarOffsetX = 0.0f;
+		StateStorage = NULL;
+		LayoutType = ParentLayoutType = ImGuiLayoutType_Vertical;
+		ItemWidth = 0.0f;
+		ItemFlags = ImGuiItemFlags_Default_;
+		TextWrapPos = -1.0f;
+		memset(StackSizesBackup, 0, sizeof(StackSizesBackup));
+
+		IndentX = 0.0f;
+		GroupOffsetX = 0.0f;
+		ColumnsOffsetX = 0.0f;
+		ColumnsSet = NULL;
+	}
+};
+
+// Windows data
+struct IMGUI_API ImGuiWindow
+{
+	char* Name;
+	ImGuiID ID;              // == ImHash(Name)
+	ImGuiWindowFlags Flags;  // See enum ImGuiWindowFlags_
+	ImVec2 PosFloat;
+	ImVec2 Pos;                   // Position rounded-up to nearest pixel
+	ImVec2 Size;                  // Current size (==SizeFull or collapsed title bar size)
+	ImVec2 SizeFull;              // Size when non collapsed
+	ImVec2 SizeFullAtLastBegin;   // Copy of SizeFull at the end of Begin. This is the reference value we'll use on the next frame to decide if we need scrollbars.
+	ImVec2 SizeContents;          // Size of contents (== extents reach of the drawing cursor) from previous frame. Include decoration, window title, border, menu, etc.
+	ImVec2 SizeContentsExplicit;  // Size of contents explicitly set by the user via SetNextWindowContentSize()
+	ImRect ContentsRegionRect;    // Maximum visible content position in window coordinates. ~~ (SizeContentsExplicit ? SizeContentsExplicit : Size - ScrollbarSizes) - CursorStartPos, per axis
+	ImVec2 WindowPadding;         // Window padding at the time of begin.
+	float WindowRounding;         // Window rounding at the time of begin.
+	float WindowBorderSize;       // Window border size at the time of begin.
+	ImGuiID MoveId;               // == window->GetID("#MOVE")
+	ImGuiID ChildId;              // Id of corresponding item in parent window (for child windows)
+	ImVec2 Scroll;
+	ImVec2 ScrollTarget;             // target scroll position. stored as cursor position with scrolling canceled out, so the highest point is always 0.0f. (FLT_MAX for no change)
+	ImVec2 ScrollTargetCenterRatio;  // 0.0f = scroll so that target position is at top, 0.5f = scroll so that target position is centered
+	bool ScrollbarX, ScrollbarY;
+	ImVec2 ScrollbarSizes;
+	bool Active;  // Set to true on Begin(), unless Collapsed
+	bool WasActive;
+	bool WriteAccessed;  // Set to true when any widget access the current window
+	bool Collapsed;      // Set when collapsing window to become only title-bar
+	bool CollapseToggleWanted;
+	bool SkipItems;               // Set when items can safely be all clipped (e.g. window not visible or collapsed)
+	bool Appearing;               // Set during the frame where the window is appearing (or re-appearing)
+	bool CloseButton;             // Set when the window has a close button (p_open != NULL)
+	int BeginOrderWithinParent;   // Order within immediate parent window, if we are a child window. Otherwise 0.
+	int BeginOrderWithinContext;  // Order within entire imgui context. This is mostly used for debugging submission order related issues.
+	int BeginCount;               // Number of Begin() during the current frame (generally 0 or 1, 1+ if appending via multiple Begin/End pairs)
+	ImGuiID PopupId;              // ID in the popup stack when this window is used as a popup/menu (because we use generic Name/ID for recycling)
+	int AutoFitFramesX, AutoFitFramesY;
+	bool AutoFitOnlyGrows;
+	int AutoFitChildAxises;
+	ImGuiDir AutoPosLastDirection;
+	int HiddenFrames;
+	ImGuiCond SetWindowPosAllowFlags;        // store condition flags for next SetWindowPos() call.
+	ImGuiCond SetWindowSizeAllowFlags;       // store condition flags for next SetWindowSize() call.
+	ImGuiCond SetWindowCollapsedAllowFlags;  // store condition flags for next SetWindowCollapsed() call.
+	ImVec2 SetWindowPosVal;                  // store window position when using a non-zero Pivot (position set needs to be processed when we know the window size)
+	ImVec2 SetWindowPosPivot;                // store window pivot for positioning. ImVec2(0,0) when positioning from top-left corner; ImVec2(0.5f,0.5f) for centering; ImVec2(1,1) for bottom right.
+
+	ImGuiDrawContext DC;        // Temporary per-window data, reset at the beginning of the frame
+	ImVector<ImGuiID> IDStack;  // ID stack. ID are hashes seeded with the value at the top of the stack
+	ImRect ClipRect;            // = DrawList->clip_rect_stack.back(). Scissoring / clipping rectangle. x1, y1, x2, y2.
+	ImRect WindowRectClipped;   // = WindowRect just after setup in Begin(). == window->Rect() for root window.
+	ImRect InnerRect;
+	int LastFrameActive;
+	float ItemWidthDefault;
+	ImGuiMenuColumns MenuColumns;  // Simplified columns storage for menu items
+	ImGuiStorage StateStorage;
+	ImVector<ImGuiColumnsSet> ColumnsStorage;
+	float FontWindowScale;  // Scale multiplier per-window
+	ImDrawList* DrawList;
+	ImGuiWindow* ParentWindow;                    // If we are a child _or_ popup window, this is pointing to our parent. Otherwise NULL.
+	ImGuiWindow* RootWindow;                      // Point to ourself or first ancestor that is not a child window.
+	ImGuiWindow* RootWindowForTitleBarHighlight;  // Point to ourself or first ancestor which will display TitleBgActive color when this window is active.
+	ImGuiWindow* RootWindowForTabbing;            // Point to ourself or first ancestor which can be CTRL-Tabbed into.
+	ImGuiWindow* RootWindowForNav;                // Point to ourself or first ancestor which doesn't have the NavFlattened flag.
+
+	ImGuiWindow* NavLastChildNavWindow;  // When going to the menu bar, we remember the child window we came from. (This could probably be made implicit if we kept g.Windows sorted by last focused including child window.)
+	ImGuiID NavLastIds[2];               // Last known NavId for this window, per layer (0/1)
+	ImRect NavRectRel[2];                // Reference rectangle, in window relative space
+
+	// Navigation / Focus
+	// FIXME-NAV: Merge all this with the new Nav system, at least the request variables should be moved to ImGuiContext
+	int FocusIdxAllCounter;         // Start at -1 and increase as assigned via FocusItemRegister()
+	int FocusIdxTabCounter;         // (same, but only count widgets which you can Tab through)
+	int FocusIdxAllRequestCurrent;  // Item being requested for focus
+	int FocusIdxTabRequestCurrent;  // Tab-able item being requested for focus
+	int FocusIdxAllRequestNext;     // Item being requested for focus, for next update (relies on layout to be stable between the frame pressing TAB and the next frame)
+	int FocusIdxTabRequestNext;     // "
+
+public:
+	ImGuiWindow(ImGuiContext* context, const char* name);
+	~ImGuiWindow();
+
+	ImGuiID GetID(const char* str, const char* str_end = NULL);
+	ImGuiID GetID(const void* ptr);
+	ImGuiID GetIDNoKeepAlive(const char* str, const char* str_end = NULL);
+	ImGuiID GetIDFromRectangle(const ImRect& r_abs);
+
+	// We don't use g.FontSize because the window may be != g.CurrentWidow.
+	ImRect Rect() const { return ImRect(Pos.x, Pos.y, Pos.x + Size.x, Pos.y + Size.y); }
+	float CalcFontSize() const { return GImGui->FontBaseSize * FontWindowScale; }
+	float TitleBarHeight() const { return (Flags & ImGuiWindowFlags_NoTitleBar) ? 0.0f : CalcFontSize() + GImGui->Style.FramePadding.y * 2.0f; }
+	ImRect TitleBarRect() const { return ImRect(Pos, ImVec2(Pos.x + SizeFull.x, Pos.y + TitleBarHeight())); }
+	float MenuBarHeight() const { return (Flags & ImGuiWindowFlags_MenuBar) ? CalcFontSize() + GImGui->Style.FramePadding.y * 2.0f : 0.0f; }
+	ImRect MenuBarRect() const
+	{
+		float y1 = Pos.y + TitleBarHeight();
+		return ImRect(Pos.x, y1, Pos.x + SizeFull.x, y1 + MenuBarHeight());
+	}
+};
+
+// Backup and restore just enough data to be able to use IsItemHovered() on item A after another B in the same window has overwritten the data.
+struct ImGuiItemHoveredDataBackup
+{
+	ImGuiID LastItemId;
+	ImGuiItemStatusFlags LastItemStatusFlags;
+	ImRect LastItemRect;
+	ImRect LastItemDisplayRect;
+
+	ImGuiItemHoveredDataBackup() { Backup(); }
+	void Backup()
+	{
+		ImGuiWindow* window = GImGui->CurrentWindow;
+		LastItemId = window->DC.LastItemId;
+		LastItemStatusFlags = window->DC.LastItemStatusFlags;
+		LastItemRect = window->DC.LastItemRect;
+		LastItemDisplayRect = window->DC.LastItemDisplayRect;
+	}
+	void Restore() const
+	{
+		ImGuiWindow* window = GImGui->CurrentWindow;
+		window->DC.LastItemId = LastItemId;
+		window->DC.LastItemStatusFlags = LastItemStatusFlags;
+		window->DC.LastItemRect = LastItemRect;
+		window->DC.LastItemDisplayRect = LastItemDisplayRect;
+	}
+};
+
+//-----------------------------------------------------------------------------
+// Internal API
+// No guarantee of forward compatibility here.
+//-----------------------------------------------------------------------------
+
+namespace ImGui
+{
+// We should always have a CurrentWindow in the stack (there is an implicit "Debug" window)
+// If this ever crash because g.CurrentWindow is NULL it means that either
+// - ImGui::NewFrame() has never been called, which is illegal.
+// - You are calling ImGui functions after ImGui::Render() and before the next ImGui::NewFrame(), which is also illegal.
+inline ImGuiWindow* GetCurrentWindowRead()
+{
+	ImGuiContext& g = *GImGui;
+	return g.CurrentWindow;
+}
+inline ImGuiWindow* GetCurrentWindow()
+{
+	ImGuiContext& g = *GImGui;
+	g.CurrentWindow->WriteAccessed = true;
+	return g.CurrentWindow;
+}
+IMGUI_API ImGuiWindow* FindWindowByName(const char* name);
+IMGUI_API void FocusWindow(ImGuiWindow* window);
+IMGUI_API void BringWindowToFront(ImGuiWindow* window);
+IMGUI_API void BringWindowToBack(ImGuiWindow* window);
+IMGUI_API bool IsWindowChildOf(ImGuiWindow* window, ImGuiWindow* potential_parent);
+IMGUI_API bool IsWindowNavFocusable(ImGuiWindow* window);
+
+IMGUI_API void Initialize(ImGuiContext* context);
+IMGUI_API void Shutdown(ImGuiContext* context);  // Since 1.60 this is a _private_ function. You can call DestroyContext() to destroy the context created by CreateContext().
+
+IMGUI_API void MarkIniSettingsDirty();
+IMGUI_API ImGuiSettingsHandler* FindSettingsHandler(const char* type_name);
+IMGUI_API ImGuiWindowSettings* FindWindowSettings(ImGuiID id);
+
+IMGUI_API void SetActiveID(ImGuiID id, ImGuiWindow* window);
+IMGUI_API ImGuiID GetActiveID();
+IMGUI_API void SetFocusID(ImGuiID id, ImGuiWindow* window);
+IMGUI_API void ClearActiveID();
+IMGUI_API void SetHoveredID(ImGuiID id);
+IMGUI_API ImGuiID GetHoveredID();
+IMGUI_API void KeepAliveID(ImGuiID id);
+
+IMGUI_API void ItemSize(const ImVec2& size, float text_offset_y = 0.0f);
+IMGUI_API void ItemSize(const ImRect& bb, float text_offset_y = 0.0f);
+IMGUI_API bool ItemAdd(const ImRect& bb, ImGuiID id, const ImRect* nav_bb = NULL);
+IMGUI_API bool ItemHoverable(const ImRect& bb, ImGuiID id);
+IMGUI_API bool IsClippedEx(const ImRect& bb, ImGuiID id, bool clip_even_when_logged);
+IMGUI_API bool FocusableItemRegister(ImGuiWindow* window, ImGuiID id, bool tab_stop = true);  // Return true if focus is requested
+IMGUI_API void FocusableItemUnregister(ImGuiWindow* window);
+IMGUI_API ImVec2 CalcItemSize(ImVec2 size, float default_x, float default_y);
+IMGUI_API float CalcWrapWidthForPos(const ImVec2& pos, float wrap_pos_x);
+IMGUI_API void PushMultiItemsWidths(int components, float width_full = 0.0f);
+IMGUI_API void PushItemFlag(ImGuiItemFlags option, bool enabled);
+IMGUI_API void PopItemFlag();
+
+IMGUI_API void SetCurrentFont(ImFont* font);
+
+IMGUI_API void OpenPopupEx(ImGuiID id);
+IMGUI_API void ClosePopup(ImGuiID id);
+IMGUI_API void ClosePopupsOverWindow(ImGuiWindow* ref_window);
+IMGUI_API bool IsPopupOpen(ImGuiID id);
+IMGUI_API bool BeginPopupEx(ImGuiID id, ImGuiWindowFlags extra_flags);
+IMGUI_API void BeginTooltipEx(ImGuiWindowFlags extra_flags, bool override_previous_tooltip = true);
+
+IMGUI_API void NavInitWindow(ImGuiWindow* window, bool force_reinit);
+IMGUI_API void NavMoveRequestCancel();
+IMGUI_API void ActivateItem(ImGuiID id);  // Remotely activate a button, checkbox, tree node etc. given its unique ID. activation is queued and processed on the next frame when the item is encountered again.
+
+IMGUI_API float GetNavInputAmount(ImGuiNavInput n, ImGuiInputReadMode mode);
+IMGUI_API ImVec2 GetNavInputAmount2d(ImGuiNavDirSourceFlags dir_sources, ImGuiInputReadMode mode, float slow_factor = 0.0f, float fast_factor = 0.0f);
+IMGUI_API int CalcTypematicPressedRepeatAmount(float t, float t_prev, float repeat_delay, float repeat_rate);
+
+IMGUI_API void Scrollbar(ImGuiLayoutType direction);
+IMGUI_API void VerticalSeparator();  // Vertical separator, for menu bars (use current line height). not exposed because it is misleading what it doesn't have an effect on regular layout.
+IMGUI_API bool SplitterBehavior(ImGuiID id, const ImRect& bb, ImGuiAxis axis, float* size1, float* size2, float min_size1, float min_size2, float hover_extend = 0.0f);
+
+IMGUI_API bool BeginDragDropTargetCustom(const ImRect& bb, ImGuiID id);
+IMGUI_API void ClearDragDrop();
+IMGUI_API bool IsDragDropPayloadBeingAccepted();
+
+// FIXME-WIP: New Columns API
+IMGUI_API void BeginColumns(const char* str_id, int count, ImGuiColumnsFlags flags = 0);  // setup number of columns. use an identifier to distinguish multiple column sets. close with EndColumns().
+IMGUI_API void EndColumns();                                                              // close columns
+IMGUI_API void PushColumnClipRect(int column_index = -1);
+
+// NB: All position are in absolute pixels coordinates (never using window coordinates internally)
+// AVOID USING OUTSIDE OF IMGUI.CPP! NOT FOR PUBLIC CONSUMPTION. THOSE FUNCTIONS ARE A MESS. THEIR SIGNATURE AND BEHAVIOR WILL CHANGE, THEY NEED TO BE REFACTORED INTO SOMETHING DECENT.
+IMGUI_API void RenderText(ImVec2 pos, const char* text, const char* text_end = NULL, bool hide_text_after_hash = true);
+IMGUI_API void RenderTextWrapped(ImVec2 pos, const char* text, const char* text_end, float wrap_width);
+IMGUI_API void RenderTextClipped(const ImVec2& pos_min, const ImVec2& pos_max, const char* text, const char* text_end, const ImVec2* text_size_if_known, const ImVec2& align = ImVec2(0, 0), const ImRect* clip_rect = NULL);
+IMGUI_API void RenderFrame(ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, bool border = true, float rounding = 0.0f);
+IMGUI_API void RenderFrameBorder(ImVec2 p_min, ImVec2 p_max, float rounding = 0.0f);
+IMGUI_API void RenderColorRectWithAlphaCheckerboard(ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, float grid_step, ImVec2 grid_off, float rounding = 0.0f, int rounding_corners_flags = ~0);
+IMGUI_API void RenderTriangle(ImVec2 pos, ImGuiDir dir, float scale = 1.0f);
+IMGUI_API void RenderBullet(ImVec2 pos);
+IMGUI_API void RenderCheckMark(ImVec2 pos, ImU32 col, float sz);
+IMGUI_API void RenderNavHighlight(const ImRect& bb, ImGuiID id, ImGuiNavHighlightFlags flags = ImGuiNavHighlightFlags_TypeDefault);  // Navigation highlight
+IMGUI_API void RenderRectFilledRangeH(ImDrawList* draw_list, const ImRect& rect, ImU32 col, float x_start_norm, float x_end_norm, float rounding);
+IMGUI_API const char* FindRenderedTextEnd(const char* text, const char* text_end = NULL);  // Find the optional ## from which we stop displaying text.
+
+IMGUI_API bool ButtonBehavior(const ImRect& bb, ImGuiID id, bool* out_hovered, bool* out_held, ImGuiButtonFlags flags = 0);
+IMGUI_API bool ButtonEx(const char* label, const ImVec2& size_arg = ImVec2(0, 0), ImGuiButtonFlags flags = 0);
+IMGUI_API bool CloseButton(ImGuiID id, const ImVec2& pos, float radius);
+IMGUI_API bool ArrowButton(ImGuiID id, ImGuiDir dir, ImVec2 padding, ImGuiButtonFlags flags = 0);
+
+IMGUI_API bool SliderBehavior(const ImRect& frame_bb, ImGuiID id, float* v, float v_min, float v_max, float power, int decimal_precision, ImGuiSliderFlags flags = 0);
+IMGUI_API bool SliderFloatN(const char* label, float* v, int components, float v_min, float v_max, const char* display_format, float power);
+IMGUI_API bool SliderIntN(const char* label, int* v, int components, int v_min, int v_max, const char* display_format);
+
+IMGUI_API bool DragBehavior(const ImRect& frame_bb, ImGuiID id, float* v, float v_speed, float v_min, float v_max, int decimal_precision, float power);
+IMGUI_API bool DragFloatN(const char* label, float* v, int components, float v_speed, float v_min, float v_max, const char* display_format, float power);
+IMGUI_API bool DragIntN(const char* label, int* v, int components, float v_speed, int v_min, int v_max, const char* display_format);
+
+IMGUI_API bool InputTextEx(const char* label, char* buf, int buf_size, const ImVec2& size_arg, ImGuiInputTextFlags flags, ImGuiTextEditCallback callback = NULL, void* user_data = NULL);
+IMGUI_API bool InputFloatN(const char* label, float* v, int components, int decimal_precision, ImGuiInputTextFlags extra_flags);
+IMGUI_API bool InputIntN(const char* label, int* v, int components, ImGuiInputTextFlags extra_flags);
+IMGUI_API bool InputScalarEx(const char* label, ImGuiDataType data_type, void* data_ptr, void* step_ptr, void* step_fast_ptr, const char* scalar_format, ImGuiInputTextFlags extra_flags);
+IMGUI_API bool InputScalarAsWidgetReplacement(const ImRect& aabb, const char* label, ImGuiDataType data_type, void* data_ptr, ImGuiID id, int decimal_precision);
+
+IMGUI_API void ColorTooltip(const char* text, const float* col, ImGuiColorEditFlags flags);
+IMGUI_API void ColorEditOptionsPopup(const float* col, ImGuiColorEditFlags flags);
+
+IMGUI_API bool TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char* label, const char* label_end = NULL);
+IMGUI_API bool TreeNodeBehaviorIsOpen(ImGuiID id, ImGuiTreeNodeFlags flags = 0);  // Consume previous SetNextTreeNodeOpened() data, if any. May return true when logging
+IMGUI_API void TreePushRawID(ImGuiID id);
+
+IMGUI_API void PlotEx(ImGuiPlotType plot_type, const char* label, float (*values_getter)(void* data, int idx), void* data, int values_count, int values_offset, const char* overlay_text, float scale_min, float scale_max, ImVec2 graph_size);
+
+IMGUI_API int ParseFormatPrecision(const char* fmt, int default_value);
+IMGUI_API float RoundScalar(float value, int decimal_precision);
+
+// Shade functions
+IMGUI_API void ShadeVertsLinearColorGradientKeepAlpha(ImDrawVert* vert_start, ImDrawVert* vert_end, ImVec2 gradient_p0, ImVec2 gradient_p1, ImU32 col0, ImU32 col1);
+IMGUI_API void ShadeVertsLinearAlphaGradientForLeftToRightText(ImDrawVert* vert_start, ImDrawVert* vert_end, float gradient_p0_x, float gradient_p1_x);
+IMGUI_API void ShadeVertsLinearUV(ImDrawVert* vert_start, ImDrawVert* vert_end, const ImVec2& a, const ImVec2& b, const ImVec2& uv_a, const ImVec2& uv_b, bool clamp);
+
+}  // namespace ImGui
+
+// ImFontAtlas internals
+IMGUI_API bool ImFontAtlasBuildWithStbTruetype(ImFontAtlas* atlas);
+IMGUI_API void ImFontAtlasBuildRegisterDefaultCustomRects(ImFontAtlas* atlas);
+IMGUI_API void ImFontAtlasBuildSetupFont(ImFontAtlas* atlas, ImFont* font, ImFontConfig* font_config, float ascent, float descent);
+IMGUI_API void ImFontAtlasBuildPackCustomRects(ImFontAtlas* atlas, void* spc);
+IMGUI_API void ImFontAtlasBuildFinish(ImFontAtlas* atlas);
+IMGUI_API void ImFontAtlasBuildMultiplyCalcLookupTable(unsigned char out_table[256], float in_multiply_factor);
+IMGUI_API void ImFontAtlasBuildMultiplyRectAlpha8(const unsigned char table[256], unsigned char* pixels, int x, int y, int w, int h, int stride);
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/imgui/stb_rect_pack.h b/engine/inc/bullet/ThirdPartyLibs/imgui/stb_rect_pack.h
new file mode 100644
index 00000000..95146ae5
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/imgui/stb_rect_pack.h
@@ -0,0 +1,657 @@
+// stb_rect_pack.h - v0.11 - public domain - rectangle packing
+// Sean Barrett 2014
+//
+// Useful for e.g. packing rectangular textures into an atlas.
+// Does not do rotation.
+//
+// Not necessarily the awesomest packing method, but better than
+// the totally naive one in stb_truetype (which is primarily what
+// this is meant to replace).
+//
+// Has only had a few tests run, may have issues.
+//
+// More docs to come.
+//
+// No memory allocations; uses qsort() and assert() from stdlib.
+// Can override those by defining STBRP_SORT and STBRP_ASSERT.
+//
+// This library currently uses the Skyline Bottom-Left algorithm.
+//
+// Please note: better rectangle packers are welcome! Please
+// implement them to the same API, but with a different init
+// function.
+//
+// Credits
+//
+//  Library
+//    Sean Barrett
+//  Minor features
+//    Martins Mozeiko
+//    github:IntellectualKitty
+//
+//  Bugfixes / warning fixes
+//    Jeremy Jaussaud
+//
+// Version history:
+//
+//     0.11  (2017-03-03)  return packing success/fail result
+//     0.10  (2016-10-25)  remove cast-away-const to avoid warnings
+//     0.09  (2016-08-27)  fix compiler warnings
+//     0.08  (2015-09-13)  really fix bug with empty rects (w=0 or h=0)
+//     0.07  (2015-09-13)  fix bug with empty rects (w=0 or h=0)
+//     0.06  (2015-04-15)  added STBRP_SORT to allow replacing qsort
+//     0.05:  added STBRP_ASSERT to allow replacing assert
+//     0.04:  fixed minor bug in STBRP_LARGE_RECTS support
+//     0.01:  initial release
+//
+// LICENSE
+//
+//   See end of file for license information.
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//       INCLUDE SECTION
+//
+
+#ifndef STB_INCLUDE_STB_RECT_PACK_H
+#define STB_INCLUDE_STB_RECT_PACK_H
+
+#define STB_RECT_PACK_VERSION 1
+
+#ifdef STBRP_STATIC
+#define STBRP_DEF static
+#else
+#define STBRP_DEF extern
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	typedef struct stbrp_context stbrp_context;
+	typedef struct stbrp_node stbrp_node;
+	typedef struct stbrp_rect stbrp_rect;
+
+#ifdef STBRP_LARGE_RECTS
+	typedef int stbrp_coord;
+#else
+typedef unsigned short stbrp_coord;
+#endif
+
+	STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects, int num_rects);
+	// Assign packed locations to rectangles. The rectangles are of type
+	// 'stbrp_rect' defined below, stored in the array 'rects', and there
+	// are 'num_rects' many of them.
+	//
+	// Rectangles which are successfully packed have the 'was_packed' flag
+	// set to a non-zero value and 'x' and 'y' store the minimum location
+	// on each axis (i.e. bottom-left in cartesian coordinates, top-left
+	// if you imagine y increasing downwards). Rectangles which do not fit
+	// have the 'was_packed' flag set to 0.
+	//
+	// You should not try to access the 'rects' array from another thread
+	// while this function is running, as the function temporarily reorders
+	// the array while it executes.
+	//
+	// To pack into another rectangle, you need to call stbrp_init_target
+	// again. To continue packing into the same rectangle, you can call
+	// this function again. Calling this multiple times with multiple rect
+	// arrays will probably produce worse packing results than calling it
+	// a single time with the full rectangle array, but the option is
+	// available.
+	//
+	// The function returns 1 if all of the rectangles were successfully
+	// packed and 0 otherwise.
+
+	struct stbrp_rect
+	{
+		// reserved for your use:
+		int id;
+
+		// input:
+		stbrp_coord w, h;
+
+		// output:
+		stbrp_coord x, y;
+		int was_packed;  // non-zero if valid packing
+
+	};  // 16 bytes, nominally
+
+	STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes);
+	// Initialize a rectangle packer to:
+	//    pack a rectangle that is 'width' by 'height' in dimensions
+	//    using temporary storage provided by the array 'nodes', which is 'num_nodes' long
+	//
+	// You must call this function every time you start packing into a new target.
+	//
+	// There is no "shutdown" function. The 'nodes' memory must stay valid for
+	// the following stbrp_pack_rects() call (or calls), but can be freed after
+	// the call (or calls) finish.
+	//
+	// Note: to guarantee best results, either:
+	//       1. make sure 'num_nodes' >= 'width'
+	//   or  2. call stbrp_allow_out_of_mem() defined below with 'allow_out_of_mem = 1'
+	//
+	// If you don't do either of the above things, widths will be quantized to multiples
+	// of small integers to guarantee the algorithm doesn't run out of temporary storage.
+	//
+	// If you do #2, then the non-quantized algorithm will be used, but the algorithm
+	// may run out of temporary storage and be unable to pack some rectangles.
+
+	STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context *context, int allow_out_of_mem);
+	// Optionally call this function after init but before doing any packing to
+	// change the handling of the out-of-temp-memory scenario, described above.
+	// If you call init again, this will be reset to the default (false).
+
+	STBRP_DEF void stbrp_setup_heuristic(stbrp_context *context, int heuristic);
+	// Optionally select which packing heuristic the library should use. Different
+	// heuristics will produce better/worse results for different data sets.
+	// If you call init again, this will be reset to the default.
+
+	enum
+	{
+		STBRP_HEURISTIC_Skyline_default = 0,
+		STBRP_HEURISTIC_Skyline_BL_sortHeight = STBRP_HEURISTIC_Skyline_default,
+		STBRP_HEURISTIC_Skyline_BF_sortHeight
+	};
+
+	//////////////////////////////////////////////////////////////////////////////
+	//
+	// the details of the following structures don't matter to you, but they must
+	// be visible so you can handle the memory allocations for them
+
+	struct stbrp_node
+	{
+		stbrp_coord x, y;
+		stbrp_node *next;
+	};
+
+	struct stbrp_context
+	{
+		int width;
+		int height;
+		int align;
+		int init_mode;
+		int heuristic;
+		int num_nodes;
+		stbrp_node *active_head;
+		stbrp_node *free_head;
+		stbrp_node extra[2];  // we allocate two extra nodes so optimal user-node-count is 'width' not 'width+2'
+	};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//     IMPLEMENTATION SECTION
+//
+
+#ifdef STB_RECT_PACK_IMPLEMENTATION
+#ifndef STBRP_SORT
+#include <stdlib.h>
+#define STBRP_SORT qsort
+#endif
+
+#ifndef STBRP_ASSERT
+#include <assert.h>
+#define STBRP_ASSERT assert
+#endif
+
+#ifdef _MSC_VER
+#define STBRP__NOTUSED(v) (void)(v)
+#define STBRP__CDECL __cdecl
+#else
+#define STBRP__NOTUSED(v) (void)sizeof(v)
+#define STBRP__CDECL
+#endif
+
+enum
+{
+	STBRP__INIT_skyline = 1
+};
+
+STBRP_DEF void stbrp_setup_heuristic(stbrp_context *context, int heuristic)
+{
+	switch (context->init_mode)
+	{
+		case STBRP__INIT_skyline:
+			STBRP_ASSERT(heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight || heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight);
+			context->heuristic = heuristic;
+			break;
+		default:
+			STBRP_ASSERT(0);
+	}
+}
+
+STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context *context, int allow_out_of_mem)
+{
+	if (allow_out_of_mem)
+		// if it's ok to run out of memory, then don't bother aligning them;
+		// this gives better packing, but may fail due to OOM (even though
+		// the rectangles easily fit). @TODO a smarter approach would be to only
+		// quantize once we've hit OOM, then we could get rid of this parameter.
+		context->align = 1;
+	else
+	{
+		// if it's not ok to run out of memory, then quantize the widths
+		// so that num_nodes is always enough nodes.
+		//
+		// I.e. num_nodes * align >= width
+		//                  align >= width / num_nodes
+		//                  align = ceil(width/num_nodes)
+
+		context->align = (context->width + context->num_nodes - 1) / context->num_nodes;
+	}
+}
+
+STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes)
+{
+	int i;
+#ifndef STBRP_LARGE_RECTS
+	STBRP_ASSERT(width <= 0xffff && height <= 0xffff);
+#endif
+
+	for (i = 0; i < num_nodes - 1; ++i)
+		nodes[i].next = &nodes[i + 1];
+	nodes[i].next = NULL;
+	context->init_mode = STBRP__INIT_skyline;
+	context->heuristic = STBRP_HEURISTIC_Skyline_default;
+	context->free_head = &nodes[0];
+	context->active_head = &context->extra[0];
+	context->width = width;
+	context->height = height;
+	context->num_nodes = num_nodes;
+	stbrp_setup_allow_out_of_mem(context, 0);
+
+	// node 0 is the full width, node 1 is the sentinel (lets us not store width explicitly)
+	context->extra[0].x = 0;
+	context->extra[0].y = 0;
+	context->extra[0].next = &context->extra[1];
+	context->extra[1].x = (stbrp_coord)width;
+#ifdef STBRP_LARGE_RECTS
+	context->extra[1].y = (1 << 30);
+#else
+	context->extra[1].y = 65535;
+#endif
+	context->extra[1].next = NULL;
+}
+
+// find minimum y position if it starts at x1
+static int stbrp__skyline_find_min_y(stbrp_context *c, stbrp_node *first, int x0, int width, int *pwaste)
+{
+	stbrp_node *node = first;
+	int x1 = x0 + width;
+	int min_y, visited_width, waste_area;
+
+	STBRP__NOTUSED(c);
+
+	STBRP_ASSERT(first->x <= x0);
+
+#if 0
+   // skip in case we're past the node
+   while (node->next->x <= x0)
+      ++node;
+#else
+	STBRP_ASSERT(node->next->x > x0);  // we ended up handling this in the caller for efficiency
+#endif
+
+	STBRP_ASSERT(node->x <= x0);
+
+	min_y = 0;
+	waste_area = 0;
+	visited_width = 0;
+	while (node->x < x1)
+	{
+		if (node->y > min_y)
+		{
+			// raise min_y higher.
+			// we've accounted for all waste up to min_y,
+			// but we'll now add more waste for everything we've visted
+			waste_area += visited_width * (node->y - min_y);
+			min_y = node->y;
+			// the first time through, visited_width might be reduced
+			if (node->x < x0)
+				visited_width += node->next->x - x0;
+			else
+				visited_width += node->next->x - node->x;
+		}
+		else
+		{
+			// add waste area
+			int under_width = node->next->x - node->x;
+			if (under_width + visited_width > width)
+				under_width = width - visited_width;
+			waste_area += under_width * (min_y - node->y);
+			visited_width += under_width;
+		}
+		node = node->next;
+	}
+
+	*pwaste = waste_area;
+	return min_y;
+}
+
+typedef struct
+{
+	int x, y;
+	stbrp_node **prev_link;
+} stbrp__findresult;
+
+static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, int width, int height)
+{
+	int best_waste = (1 << 30), best_x, best_y = (1 << 30);
+	stbrp__findresult fr;
+	stbrp_node **prev, *node, *tail, **best = NULL;
+
+	// align to multiple of c->align
+	width = (width + c->align - 1);
+	width -= width % c->align;
+	STBRP_ASSERT(width % c->align == 0);
+
+	node = c->active_head;
+	prev = &c->active_head;
+	while (node->x + width <= c->width)
+	{
+		int y, waste;
+		y = stbrp__skyline_find_min_y(c, node, node->x, width, &waste);
+		if (c->heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight)
+		{  // actually just want to test BL
+			// bottom left
+			if (y < best_y)
+			{
+				best_y = y;
+				best = prev;
+			}
+		}
+		else
+		{
+			// best-fit
+			if (y + height <= c->height)
+			{
+				// can only use it if it first vertically
+				if (y < best_y || (y == best_y && waste < best_waste))
+				{
+					best_y = y;
+					best_waste = waste;
+					best = prev;
+				}
+			}
+		}
+		prev = &node->next;
+		node = node->next;
+	}
+
+	best_x = (best == NULL) ? 0 : (*best)->x;
+
+	// if doing best-fit (BF), we also have to try aligning right edge to each node position
+	//
+	// e.g, if fitting
+	//
+	//     ____________________
+	//    |____________________|
+	//
+	//            into
+	//
+	//   |                         |
+	//   |             ____________|
+	//   |____________|
+	//
+	// then right-aligned reduces waste, but bottom-left BL is always chooses left-aligned
+	//
+	// This makes BF take about 2x the time
+
+	if (c->heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight)
+	{
+		tail = c->active_head;
+		node = c->active_head;
+		prev = &c->active_head;
+		// find first node that's admissible
+		while (tail->x < width)
+			tail = tail->next;
+		while (tail)
+		{
+			int xpos = tail->x - width;
+			int y, waste;
+			STBRP_ASSERT(xpos >= 0);
+			// find the left position that matches this
+			while (node->next->x <= xpos)
+			{
+				prev = &node->next;
+				node = node->next;
+			}
+			STBRP_ASSERT(node->next->x > xpos && node->x <= xpos);
+			y = stbrp__skyline_find_min_y(c, node, xpos, width, &waste);
+			if (y + height < c->height)
+			{
+				if (y <= best_y)
+				{
+					if (y < best_y || waste < best_waste || (waste == best_waste && xpos < best_x))
+					{
+						best_x = xpos;
+						STBRP_ASSERT(y <= best_y);
+						best_y = y;
+						best_waste = waste;
+						best = prev;
+					}
+				}
+			}
+			tail = tail->next;
+		}
+	}
+
+	fr.prev_link = best;
+	fr.x = best_x;
+	fr.y = best_y;
+	return fr;
+}
+
+static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context *context, int width, int height)
+{
+	// find best position according to heuristic
+	stbrp__findresult res = stbrp__skyline_find_best_pos(context, width, height);
+	stbrp_node *node, *cur;
+
+	// bail if:
+	//    1. it failed
+	//    2. the best node doesn't fit (we don't always check this)
+	//    3. we're out of memory
+	if (res.prev_link == NULL || res.y + height > context->height || context->free_head == NULL)
+	{
+		res.prev_link = NULL;
+		return res;
+	}
+
+	// on success, create new node
+	node = context->free_head;
+	node->x = (stbrp_coord)res.x;
+	node->y = (stbrp_coord)(res.y + height);
+
+	context->free_head = node->next;
+
+	// insert the new node into the right starting point, and
+	// let 'cur' point to the remaining nodes needing to be
+	// stiched back in
+
+	cur = *res.prev_link;
+	if (cur->x < res.x)
+	{
+		// preserve the existing one, so start testing with the next one
+		stbrp_node *next = cur->next;
+		cur->next = node;
+		cur = next;
+	}
+	else
+	{
+		*res.prev_link = node;
+	}
+
+	// from here, traverse cur and free the nodes, until we get to one
+	// that shouldn't be freed
+	while (cur->next && cur->next->x <= res.x + width)
+	{
+		stbrp_node *next = cur->next;
+		// move the current node to the free list
+		cur->next = context->free_head;
+		context->free_head = cur;
+		cur = next;
+	}
+
+	// stitch the list back in
+	node->next = cur;
+
+	if (cur->x < res.x + width)
+		cur->x = (stbrp_coord)(res.x + width);
+
+#ifdef _DEBUG
+	cur = context->active_head;
+	while (cur->x < context->width)
+	{
+		STBRP_ASSERT(cur->x < cur->next->x);
+		cur = cur->next;
+	}
+	STBRP_ASSERT(cur->next == NULL);
+
+	{
+		int count = 0;
+		cur = context->active_head;
+		while (cur)
+		{
+			cur = cur->next;
+			++count;
+		}
+		cur = context->free_head;
+		while (cur)
+		{
+			cur = cur->next;
+			++count;
+		}
+		STBRP_ASSERT(count == context->num_nodes + 2);
+	}
+#endif
+
+	return res;
+}
+
+static int STBRP__CDECL rect_height_compare(const void *a, const void *b)
+{
+	const stbrp_rect *p = (const stbrp_rect *)a;
+	const stbrp_rect *q = (const stbrp_rect *)b;
+	if (p->h > q->h)
+		return -1;
+	if (p->h < q->h)
+		return 1;
+	return (p->w > q->w) ? -1 : (p->w < q->w);
+}
+
+static int STBRP__CDECL rect_original_order(const void *a, const void *b)
+{
+	const stbrp_rect *p = (const stbrp_rect *)a;
+	const stbrp_rect *q = (const stbrp_rect *)b;
+	return (p->was_packed < q->was_packed) ? -1 : (p->was_packed > q->was_packed);
+}
+
+#ifdef STBRP_LARGE_RECTS
+#define STBRP__MAXVAL 0xffffffff
+#else
+#define STBRP__MAXVAL 0xffff
+#endif
+
+STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects, int num_rects)
+{
+	int i, all_rects_packed = 1;
+
+	// we use the 'was_packed' field internally to allow sorting/unsorting
+	for (i = 0; i < num_rects; ++i)
+	{
+		rects[i].was_packed = i;
+#ifndef STBRP_LARGE_RECTS
+		STBRP_ASSERT(rects[i].w <= 0xffff && rects[i].h <= 0xffff);
+#endif
+	}
+
+	// sort according to heuristic
+	STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_height_compare);
+
+	for (i = 0; i < num_rects; ++i)
+	{
+		if (rects[i].w == 0 || rects[i].h == 0)
+		{
+			rects[i].x = rects[i].y = 0;  // empty rect needs no space
+		}
+		else
+		{
+			stbrp__findresult fr = stbrp__skyline_pack_rectangle(context, rects[i].w, rects[i].h);
+			if (fr.prev_link)
+			{
+				rects[i].x = (stbrp_coord)fr.x;
+				rects[i].y = (stbrp_coord)fr.y;
+			}
+			else
+			{
+				rects[i].x = rects[i].y = STBRP__MAXVAL;
+			}
+		}
+	}
+
+	// unsort
+	STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_original_order);
+
+	// set was_packed flags and all_rects_packed status
+	for (i = 0; i < num_rects; ++i)
+	{
+		rects[i].was_packed = !(rects[i].x == STBRP__MAXVAL && rects[i].y == STBRP__MAXVAL);
+		if (!rects[i].was_packed)
+			all_rects_packed = 0;
+	}
+
+	// return the all_rects_packed status
+	return all_rects_packed;
+}
+#endif
+
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+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.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this 
+software, either in source code form or as a compiled binary, for any purpose, 
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this 
+software dedicate any and all copyright interest in the software to the public 
+domain. We make this dedication for the benefit of the public at large and to 
+the detriment of our heirs and successors. We intend this dedication to be an 
+overt act of relinquishment in perpetuity of all present and future rights to 
+this software under copyright law.
+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 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.
+------------------------------------------------------------------------------
+*/
diff --git a/engine/inc/bullet/ThirdPartyLibs/imgui/stb_textedit.h b/engine/inc/bullet/ThirdPartyLibs/imgui/stb_textedit.h
new file mode 100644
index 00000000..a2d76901
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/imgui/stb_textedit.h
@@ -0,0 +1,1383 @@
+// [ImGui] this is a slightly modified version of stb_truetype.h 1.9. Those changes would need to be pushed into nothings/sb
+// [ImGui] - fixed linestart handler when over last character of multi-line buffer + simplified existing code (#588, #815)
+// [ImGui] - fixed a state corruption/crash bug in stb_text_redo and stb_textedit_discard_redo (#715)
+// [ImGui] - fixed a crash bug in stb_textedit_discard_redo (#681)
+// [ImGui] - fixed some minor warnings
+
+// stb_textedit.h - v1.9  - public domain - Sean Barrett
+// Development of this library was sponsored by RAD Game Tools
+//
+// This C header file implements the guts of a multi-line text-editing
+// widget; you implement display, word-wrapping, and low-level string
+// insertion/deletion, and stb_textedit will map user inputs into
+// insertions & deletions, plus updates to the cursor position,
+// selection state, and undo state.
+//
+// It is intended for use in games and other systems that need to build
+// their own custom widgets and which do not have heavy text-editing
+// requirements (this library is not recommended for use for editing large
+// texts, as its performance does not scale and it has limited undo).
+//
+// Non-trivial behaviors are modelled after Windows text controls.
+//
+//
+// LICENSE
+//
+//   This software is dual-licensed to the public domain and under the following
+//   license: you are granted a perpetual, irrevocable license to copy, modify,
+//   publish, and distribute this file as you see fit.
+//
+//
+// DEPENDENCIES
+//
+// Uses the C runtime function 'memmove', which you can override
+// by defining STB_TEXTEDIT_memmove before the implementation.
+// Uses no other functions. Performs no runtime allocations.
+//
+//
+// VERSION HISTORY
+//
+//   1.9  (2016-08-27) customizable move-by-word
+//   1.8  (2016-04-02) better keyboard handling when mouse button is down
+//   1.7  (2015-09-13) change y range handling in case baseline is non-0
+//   1.6  (2015-04-15) allow STB_TEXTEDIT_memmove
+//   1.5  (2014-09-10) add support for secondary keys for OS X
+//   1.4  (2014-08-17) fix signed/unsigned warnings
+//   1.3  (2014-06-19) fix mouse clicking to round to nearest char boundary
+//   1.2  (2014-05-27) fix some RAD types that had crept into the new code
+//   1.1  (2013-12-15) move-by-word (requires STB_TEXTEDIT_IS_SPACE )
+//   1.0  (2012-07-26) improve documentation, initial public release
+//   0.3  (2012-02-24) bugfixes, single-line mode; insert mode
+//   0.2  (2011-11-28) fixes to undo/redo
+//   0.1  (2010-07-08) initial version
+//
+// ADDITIONAL CONTRIBUTORS
+//
+//   Ulf Winklemann: move-by-word in 1.1
+//   Fabian Giesen: secondary key inputs in 1.5
+//   Martins Mozeiko: STB_TEXTEDIT_memmove
+//
+//   Bugfixes:
+//      Scott Graham
+//      Daniel Keller
+//      Omar Cornut
+//
+// USAGE
+//
+// This file behaves differently depending on what symbols you define
+// before including it.
+//
+//
+// Header-file mode:
+//
+//   If you do not define STB_TEXTEDIT_IMPLEMENTATION before including this,
+//   it will operate in "header file" mode. In this mode, it declares a
+//   single public symbol, STB_TexteditState, which encapsulates the current
+//   state of a text widget (except for the string, which you will store
+//   separately).
+//
+//   To compile in this mode, you must define STB_TEXTEDIT_CHARTYPE to a
+//   primitive type that defines a single character (e.g. char, wchar_t, etc).
+//
+//   To save space or increase undo-ability, you can optionally define the
+//   following things that are used by the undo system:
+//
+//      STB_TEXTEDIT_POSITIONTYPE         small int type encoding a valid cursor position
+//      STB_TEXTEDIT_UNDOSTATECOUNT       the number of undo states to allow
+//      STB_TEXTEDIT_UNDOCHARCOUNT        the number of characters to store in the undo buffer
+//
+//   If you don't define these, they are set to permissive types and
+//   moderate sizes. The undo system does no memory allocations, so
+//   it grows STB_TexteditState by the worst-case storage which is (in bytes):
+//
+//        [4 + sizeof(STB_TEXTEDIT_POSITIONTYPE)] * STB_TEXTEDIT_UNDOSTATE_COUNT
+//      +      sizeof(STB_TEXTEDIT_CHARTYPE)      * STB_TEXTEDIT_UNDOCHAR_COUNT
+//
+//
+// Implementation mode:
+//
+//   If you define STB_TEXTEDIT_IMPLEMENTATION before including this, it
+//   will compile the implementation of the text edit widget, depending
+//   on a large number of symbols which must be defined before the include.
+//
+//   The implementation is defined only as static functions. You will then
+//   need to provide your own APIs in the same file which will access the
+//   static functions.
+//
+//   The basic concept is that you provide a "string" object which
+//   behaves like an array of characters. stb_textedit uses indices to
+//   refer to positions in the string, implicitly representing positions
+//   in the displayed textedit. This is true for both plain text and
+//   rich text; even with rich text stb_truetype interacts with your
+//   code as if there was an array of all the displayed characters.
+//
+// Symbols that must be the same in header-file and implementation mode:
+//
+//     STB_TEXTEDIT_CHARTYPE             the character type
+//     STB_TEXTEDIT_POSITIONTYPE         small type that a valid cursor position
+//     STB_TEXTEDIT_UNDOSTATECOUNT       the number of undo states to allow
+//     STB_TEXTEDIT_UNDOCHARCOUNT        the number of characters to store in the undo buffer
+//
+// Symbols you must define for implementation mode:
+//
+//    STB_TEXTEDIT_STRING               the type of object representing a string being edited,
+//                                      typically this is a wrapper object with other data you need
+//
+//    STB_TEXTEDIT_STRINGLEN(obj)       the length of the string (ideally O(1))
+//    STB_TEXTEDIT_LAYOUTROW(&r,obj,n)  returns the results of laying out a line of characters
+//                                        starting from character #n (see discussion below)
+//    STB_TEXTEDIT_GETWIDTH(obj,n,i)    returns the pixel delta from the xpos of the i'th character
+//                                        to the xpos of the i+1'th char for a line of characters
+//                                        starting at character #n (i.e. accounts for kerning
+//                                        with previous char)
+//    STB_TEXTEDIT_KEYTOTEXT(k)         maps a keyboard input to an insertable character
+//                                        (return type is int, -1 means not valid to insert)
+//    STB_TEXTEDIT_GETCHAR(obj,i)       returns the i'th character of obj, 0-based
+//    STB_TEXTEDIT_NEWLINE              the character returned by _GETCHAR() we recognize
+//                                        as manually wordwrapping for end-of-line positioning
+//
+//    STB_TEXTEDIT_DELETECHARS(obj,i,n)      delete n characters starting at i
+//    STB_TEXTEDIT_INSERTCHARS(obj,i,c*,n)   insert n characters at i (pointed to by STB_TEXTEDIT_CHARTYPE*)
+//
+//    STB_TEXTEDIT_K_SHIFT       a power of two that is or'd in to a keyboard input to represent the shift key
+//
+//    STB_TEXTEDIT_K_LEFT        keyboard input to move cursor left
+//    STB_TEXTEDIT_K_RIGHT       keyboard input to move cursor right
+//    STB_TEXTEDIT_K_UP          keyboard input to move cursor up
+//    STB_TEXTEDIT_K_DOWN        keyboard input to move cursor down
+//    STB_TEXTEDIT_K_LINESTART   keyboard input to move cursor to start of line  // e.g. HOME
+//    STB_TEXTEDIT_K_LINEEND     keyboard input to move cursor to end of line    // e.g. END
+//    STB_TEXTEDIT_K_TEXTSTART   keyboard input to move cursor to start of text  // e.g. ctrl-HOME
+//    STB_TEXTEDIT_K_TEXTEND     keyboard input to move cursor to end of text    // e.g. ctrl-END
+//    STB_TEXTEDIT_K_DELETE      keyboard input to delete selection or character under cursor
+//    STB_TEXTEDIT_K_BACKSPACE   keyboard input to delete selection or character left of cursor
+//    STB_TEXTEDIT_K_UNDO        keyboard input to perform undo
+//    STB_TEXTEDIT_K_REDO        keyboard input to perform redo
+//
+// Optional:
+//    STB_TEXTEDIT_K_INSERT              keyboard input to toggle insert mode
+//    STB_TEXTEDIT_IS_SPACE(ch)          true if character is whitespace (e.g. 'isspace'),
+//                                          required for default WORDLEFT/WORDRIGHT handlers
+//    STB_TEXTEDIT_MOVEWORDLEFT(obj,i)   custom handler for WORDLEFT, returns index to move cursor to
+//    STB_TEXTEDIT_MOVEWORDRIGHT(obj,i)  custom handler for WORDRIGHT, returns index to move cursor to
+//    STB_TEXTEDIT_K_WORDLEFT            keyboard input to move cursor left one word // e.g. ctrl-LEFT
+//    STB_TEXTEDIT_K_WORDRIGHT           keyboard input to move cursor right one word // e.g. ctrl-RIGHT
+//    STB_TEXTEDIT_K_LINESTART2          secondary keyboard input to move cursor to start of line
+//    STB_TEXTEDIT_K_LINEEND2            secondary keyboard input to move cursor to end of line
+//    STB_TEXTEDIT_K_TEXTSTART2          secondary keyboard input to move cursor to start of text
+//    STB_TEXTEDIT_K_TEXTEND2            secondary keyboard input to move cursor to end of text
+//
+// Todo:
+//    STB_TEXTEDIT_K_PGUP        keyboard input to move cursor up a page
+//    STB_TEXTEDIT_K_PGDOWN      keyboard input to move cursor down a page
+//
+// Keyboard input must be encoded as a single integer value; e.g. a character code
+// and some bitflags that represent shift states. to simplify the interface, SHIFT must
+// be a bitflag, so we can test the shifted state of cursor movements to allow selection,
+// i.e. (STB_TEXTED_K_RIGHT|STB_TEXTEDIT_K_SHIFT) should be shifted right-arrow.
+//
+// You can encode other things, such as CONTROL or ALT, in additional bits, and
+// then test for their presence in e.g. STB_TEXTEDIT_K_WORDLEFT. For example,
+// my Windows implementations add an additional CONTROL bit, and an additional KEYDOWN
+// bit. Then all of the STB_TEXTEDIT_K_ values bitwise-or in the KEYDOWN bit,
+// and I pass both WM_KEYDOWN and WM_CHAR events to the "key" function in the
+// API below. The control keys will only match WM_KEYDOWN events because of the
+// keydown bit I add, and STB_TEXTEDIT_KEYTOTEXT only tests for the KEYDOWN
+// bit so it only decodes WM_CHAR events.
+//
+// STB_TEXTEDIT_LAYOUTROW returns information about the shape of one displayed
+// row of characters assuming they start on the i'th character--the width and
+// the height and the number of characters consumed. This allows this library
+// to traverse the entire layout incrementally. You need to compute word-wrapping
+// here.
+//
+// Each textfield keeps its own insert mode state, which is not how normal
+// applications work. To keep an app-wide insert mode, update/copy the
+// "insert_mode" field of STB_TexteditState before/after calling API functions.
+//
+// API
+//
+//    void stb_textedit_initialize_state(STB_TexteditState *state, int is_single_line)
+//
+//    void stb_textedit_click(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)
+//    void stb_textedit_drag(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)
+//    int  stb_textedit_cut(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
+//    int  stb_textedit_paste(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_CHARTYPE *text, int len)
+//    void stb_textedit_key(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int key)
+//
+//    Each of these functions potentially updates the string and updates the
+//    state.
+//
+//      initialize_state:
+//          set the textedit state to a known good default state when initially
+//          constructing the textedit.
+//
+//      click:
+//          call this with the mouse x,y on a mouse down; it will update the cursor
+//          and reset the selection start/end to the cursor point. the x,y must
+//          be relative to the text widget, with (0,0) being the top left.
+//
+//      drag:
+//          call this with the mouse x,y on a mouse drag/up; it will update the
+//          cursor and the selection end point
+//
+//      cut:
+//          call this to delete the current selection; returns true if there was
+//          one. you should FIRST copy the current selection to the system paste buffer.
+//          (To copy, just copy the current selection out of the string yourself.)
+//
+//      paste:
+//          call this to paste text at the current cursor point or over the current
+//          selection if there is one.
+//
+//      key:
+//          call this for keyboard inputs sent to the textfield. you can use it
+//          for "key down" events or for "translated" key events. if you need to
+//          do both (as in Win32), or distinguish Unicode characters from control
+//          inputs, set a high bit to distinguish the two; then you can define the
+//          various definitions like STB_TEXTEDIT_K_LEFT have the is-key-event bit
+//          set, and make STB_TEXTEDIT_KEYTOCHAR check that the is-key-event bit is
+//          clear.
+//
+//   When rendering, you can read the cursor position and selection state from
+//   the STB_TexteditState.
+//
+//
+// Notes:
+//
+// This is designed to be usable in IMGUI, so it allows for the possibility of
+// running in an IMGUI that has NOT cached the multi-line layout. For this
+// reason, it provides an interface that is compatible with computing the
+// layout incrementally--we try to make sure we make as few passes through
+// as possible. (For example, to locate the mouse pointer in the text, we
+// could define functions that return the X and Y positions of characters
+// and binary search Y and then X, but if we're doing dynamic layout this
+// will run the layout algorithm many times, so instead we manually search
+// forward in one pass. Similar logic applies to e.g. up-arrow and
+// down-arrow movement.)
+//
+// If it's run in a widget that *has* cached the layout, then this is less
+// efficient, but it's not horrible on modern computers. But you wouldn't
+// want to edit million-line files with it.
+
+////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////
+////
+////   Header-file mode
+////
+////
+
+#ifndef INCLUDE_STB_TEXTEDIT_H
+#define INCLUDE_STB_TEXTEDIT_H
+
+////////////////////////////////////////////////////////////////////////
+//
+//     STB_TexteditState
+//
+// Definition of STB_TexteditState which you should store
+// per-textfield; it includes cursor position, selection state,
+// and undo state.
+//
+
+#ifndef STB_TEXTEDIT_UNDOSTATECOUNT
+#define STB_TEXTEDIT_UNDOSTATECOUNT 99
+#endif
+#ifndef STB_TEXTEDIT_UNDOCHARCOUNT
+#define STB_TEXTEDIT_UNDOCHARCOUNT 999
+#endif
+#ifndef STB_TEXTEDIT_CHARTYPE
+#define STB_TEXTEDIT_CHARTYPE int
+#endif
+#ifndef STB_TEXTEDIT_POSITIONTYPE
+#define STB_TEXTEDIT_POSITIONTYPE int
+#endif
+
+typedef struct
+{
+	// private data
+	STB_TEXTEDIT_POSITIONTYPE where;
+	short insert_length;
+	short delete_length;
+	short char_storage;
+} StbUndoRecord;
+
+typedef struct
+{
+	// private data
+	StbUndoRecord undo_rec[STB_TEXTEDIT_UNDOSTATECOUNT];
+	STB_TEXTEDIT_CHARTYPE undo_char[STB_TEXTEDIT_UNDOCHARCOUNT];
+	short undo_point, redo_point;
+	short undo_char_point, redo_char_point;
+} StbUndoState;
+
+typedef struct
+{
+	/////////////////////
+	//
+	// public data
+	//
+
+	int cursor;
+	// position of the text cursor within the string
+
+	int select_start;  // selection start point
+	int select_end;
+	// selection start and end point in characters; if equal, no selection.
+	// note that start may be less than or greater than end (e.g. when
+	// dragging the mouse, start is where the initial click was, and you
+	// can drag in either direction)
+
+	unsigned char insert_mode;
+	// each textfield keeps its own insert mode state. to keep an app-wide
+	// insert mode, copy this value in/out of the app state
+
+	/////////////////////
+	//
+	// private data
+	//
+	unsigned char cursor_at_end_of_line;  // not implemented yet
+	unsigned char initialized;
+	unsigned char has_preferred_x;
+	unsigned char single_line;
+	unsigned char padding1, padding2, padding3;
+	float preferred_x;  // this determines where the cursor up/down tries to seek to along x
+	StbUndoState undostate;
+} STB_TexteditState;
+
+////////////////////////////////////////////////////////////////////////
+//
+//     StbTexteditRow
+//
+// Result of layout query, used by stb_textedit to determine where
+// the text in each row is.
+
+// result of layout query
+typedef struct
+{
+	float x0, x1;            // starting x location, end x location (allows for align=right, etc)
+	float baseline_y_delta;  // position of baseline relative to previous row's baseline
+	float ymin, ymax;        // height of row above and below baseline
+	int num_chars;
+} StbTexteditRow;
+#endif  //INCLUDE_STB_TEXTEDIT_H
+
+////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////
+////
+////   Implementation mode
+////
+////
+
+// implementation isn't include-guarded, since it might have indirectly
+// included just the "header" portion
+#ifdef STB_TEXTEDIT_IMPLEMENTATION
+
+#ifndef STB_TEXTEDIT_memmove
+#include <string.h>
+#define STB_TEXTEDIT_memmove memmove
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+//
+//      Mouse input handling
+//
+
+// traverse the layout to locate the nearest character to a display position
+static int stb_text_locate_coord(STB_TEXTEDIT_STRING *str, float x, float y)
+{
+	StbTexteditRow r;
+	int n = STB_TEXTEDIT_STRINGLEN(str);
+	float base_y = 0, prev_x;
+	int i = 0, k;
+
+	r.x0 = r.x1 = 0;
+	r.ymin = r.ymax = 0;
+	r.num_chars = 0;
+
+	// search rows to find one that straddles 'y'
+	while (i < n)
+	{
+		STB_TEXTEDIT_LAYOUTROW(&r, str, i);
+		if (r.num_chars <= 0)
+			return n;
+
+		if (i == 0 && y < base_y + r.ymin)
+			return 0;
+
+		if (y < base_y + r.ymax)
+			break;
+
+		i += r.num_chars;
+		base_y += r.baseline_y_delta;
+	}
+
+	// below all text, return 'after' last character
+	if (i >= n)
+		return n;
+
+	// check if it's before the beginning of the line
+	if (x < r.x0)
+		return i;
+
+	// check if it's before the end of the line
+	if (x < r.x1)
+	{
+		// search characters in row for one that straddles 'x'
+		prev_x = r.x0;
+		for (k = 0; k < r.num_chars; ++k)
+		{
+			float w = STB_TEXTEDIT_GETWIDTH(str, i, k);
+			if (x < prev_x + w)
+			{
+				if (x < prev_x + w / 2)
+					return k + i;
+				else
+					return k + i + 1;
+			}
+			prev_x += w;
+		}
+		// shouldn't happen, but if it does, fall through to end-of-line case
+	}
+
+	// if the last character is a newline, return that. otherwise return 'after' the last character
+	if (STB_TEXTEDIT_GETCHAR(str, i + r.num_chars - 1) == STB_TEXTEDIT_NEWLINE)
+		return i + r.num_chars - 1;
+	else
+		return i + r.num_chars;
+}
+
+// API click: on mouse down, move the cursor to the clicked location, and reset the selection
+static void stb_textedit_click(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)
+{
+	state->cursor = stb_text_locate_coord(str, x, y);
+	state->select_start = state->cursor;
+	state->select_end = state->cursor;
+	state->has_preferred_x = 0;
+}
+
+// API drag: on mouse drag, move the cursor and selection endpoint to the clicked location
+static void stb_textedit_drag(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)
+{
+	int p = stb_text_locate_coord(str, x, y);
+	if (state->select_start == state->select_end)
+		state->select_start = state->cursor;
+	state->cursor = state->select_end = p;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+//
+//      Keyboard input handling
+//
+
+// forward declarations
+static void stb_text_undo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state);
+static void stb_text_redo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state);
+static void stb_text_makeundo_delete(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int length);
+static void stb_text_makeundo_insert(STB_TexteditState *state, int where, int length);
+static void stb_text_makeundo_replace(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int old_length, int new_length);
+
+typedef struct
+{
+	float x, y;              // position of n'th character
+	float height;            // height of line
+	int first_char, length;  // first char of row, and length
+	int prev_first;          // first char of previous row
+} StbFindState;
+
+// find the x/y location of a character, and remember info about the previous row in
+// case we get a move-up event (for page up, we'll have to rescan)
+static void stb_textedit_find_charpos(StbFindState *find, STB_TEXTEDIT_STRING *str, int n, int single_line)
+{
+	StbTexteditRow r;
+	int prev_start = 0;
+	int z = STB_TEXTEDIT_STRINGLEN(str);
+	int i = 0, first;
+
+	if (n == z)
+	{
+		// if it's at the end, then find the last line -- simpler than trying to
+		// explicitly handle this case in the regular code
+		if (single_line)
+		{
+			STB_TEXTEDIT_LAYOUTROW(&r, str, 0);
+			find->y = 0;
+			find->first_char = 0;
+			find->length = z;
+			find->height = r.ymax - r.ymin;
+			find->x = r.x1;
+		}
+		else
+		{
+			find->y = 0;
+			find->x = 0;
+			find->height = 1;
+			while (i < z)
+			{
+				STB_TEXTEDIT_LAYOUTROW(&r, str, i);
+				prev_start = i;
+				i += r.num_chars;
+			}
+			find->first_char = i;
+			find->length = 0;
+			find->prev_first = prev_start;
+		}
+		return;
+	}
+
+	// search rows to find the one that straddles character n
+	find->y = 0;
+
+	for (;;)
+	{
+		STB_TEXTEDIT_LAYOUTROW(&r, str, i);
+		if (n < i + r.num_chars)
+			break;
+		prev_start = i;
+		i += r.num_chars;
+		find->y += r.baseline_y_delta;
+	}
+
+	find->first_char = first = i;
+	find->length = r.num_chars;
+	find->height = r.ymax - r.ymin;
+	find->prev_first = prev_start;
+
+	// now scan to find xpos
+	find->x = r.x0;
+	i = 0;
+	for (i = 0; first + i < n; ++i)
+		find->x += STB_TEXTEDIT_GETWIDTH(str, first, i);
+}
+
+#define STB_TEXT_HAS_SELECTION(s) ((s)->select_start != (s)->select_end)
+
+// make the selection/cursor state valid if client altered the string
+static void stb_textedit_clamp(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
+{
+	int n = STB_TEXTEDIT_STRINGLEN(str);
+	if (STB_TEXT_HAS_SELECTION(state))
+	{
+		if (state->select_start > n) state->select_start = n;
+		if (state->select_end > n) state->select_end = n;
+		// if clamping forced them to be equal, move the cursor to match
+		if (state->select_start == state->select_end)
+			state->cursor = state->select_start;
+	}
+	if (state->cursor > n) state->cursor = n;
+}
+
+// delete characters while updating undo
+static void stb_textedit_delete(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int len)
+{
+	stb_text_makeundo_delete(str, state, where, len);
+	STB_TEXTEDIT_DELETECHARS(str, where, len);
+	state->has_preferred_x = 0;
+}
+
+// delete the section
+static void stb_textedit_delete_selection(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
+{
+	stb_textedit_clamp(str, state);
+	if (STB_TEXT_HAS_SELECTION(state))
+	{
+		if (state->select_start < state->select_end)
+		{
+			stb_textedit_delete(str, state, state->select_start, state->select_end - state->select_start);
+			state->select_end = state->cursor = state->select_start;
+		}
+		else
+		{
+			stb_textedit_delete(str, state, state->select_end, state->select_start - state->select_end);
+			state->select_start = state->cursor = state->select_end;
+		}
+		state->has_preferred_x = 0;
+	}
+}
+
+// canoncialize the selection so start <= end
+static void stb_textedit_sortselection(STB_TexteditState *state)
+{
+	if (state->select_end < state->select_start)
+	{
+		int temp = state->select_end;
+		state->select_end = state->select_start;
+		state->select_start = temp;
+	}
+}
+
+// move cursor to first character of selection
+static void stb_textedit_move_to_first(STB_TexteditState *state)
+{
+	if (STB_TEXT_HAS_SELECTION(state))
+	{
+		stb_textedit_sortselection(state);
+		state->cursor = state->select_start;
+		state->select_end = state->select_start;
+		state->has_preferred_x = 0;
+	}
+}
+
+// move cursor to last character of selection
+static void stb_textedit_move_to_last(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
+{
+	if (STB_TEXT_HAS_SELECTION(state))
+	{
+		stb_textedit_sortselection(state);
+		stb_textedit_clamp(str, state);
+		state->cursor = state->select_end;
+		state->select_start = state->select_end;
+		state->has_preferred_x = 0;
+	}
+}
+
+#ifdef STB_TEXTEDIT_IS_SPACE
+static int is_word_boundary(STB_TEXTEDIT_STRING *str, int idx)
+{
+	return idx > 0 ? (STB_TEXTEDIT_IS_SPACE(STB_TEXTEDIT_GETCHAR(str, idx - 1)) && !STB_TEXTEDIT_IS_SPACE(STB_TEXTEDIT_GETCHAR(str, idx))) : 1;
+}
+
+#ifndef STB_TEXTEDIT_MOVEWORDLEFT
+static int stb_textedit_move_to_word_previous(STB_TEXTEDIT_STRING *str, int c)
+{
+	--c;  // always move at least one character
+	while (c >= 0 && !is_word_boundary(str, c))
+		--c;
+
+	if (c < 0)
+		c = 0;
+
+	return c;
+}
+#define STB_TEXTEDIT_MOVEWORDLEFT stb_textedit_move_to_word_previous
+#endif
+
+#ifndef STB_TEXTEDIT_MOVEWORDRIGHT
+static int stb_textedit_move_to_word_next(STB_TEXTEDIT_STRING *str, int c)
+{
+	const int len = STB_TEXTEDIT_STRINGLEN(str);
+	++c;  // always move at least one character
+	while (c < len && !is_word_boundary(str, c))
+		++c;
+
+	if (c > len)
+		c = len;
+
+	return c;
+}
+#define STB_TEXTEDIT_MOVEWORDRIGHT stb_textedit_move_to_word_next
+#endif
+
+#endif
+
+// update selection and cursor to match each other
+static void stb_textedit_prep_selection_at_cursor(STB_TexteditState *state)
+{
+	if (!STB_TEXT_HAS_SELECTION(state))
+		state->select_start = state->select_end = state->cursor;
+	else
+		state->cursor = state->select_end;
+}
+
+// API cut: delete selection
+static int stb_textedit_cut(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
+{
+	if (STB_TEXT_HAS_SELECTION(state))
+	{
+		stb_textedit_delete_selection(str, state);  // implicity clamps
+		state->has_preferred_x = 0;
+		return 1;
+	}
+	return 0;
+}
+
+// API paste: replace existing selection with passed-in text
+static int stb_textedit_paste(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_CHARTYPE const *ctext, int len)
+{
+	STB_TEXTEDIT_CHARTYPE *text = (STB_TEXTEDIT_CHARTYPE *)ctext;
+	// if there's a selection, the paste should delete it
+	stb_textedit_clamp(str, state);
+	stb_textedit_delete_selection(str, state);
+	// try to insert the characters
+	if (STB_TEXTEDIT_INSERTCHARS(str, state->cursor, text, len))
+	{
+		stb_text_makeundo_insert(state, state->cursor, len);
+		state->cursor += len;
+		state->has_preferred_x = 0;
+		return 1;
+	}
+	// remove the undo since we didn't actually insert the characters
+	if (state->undostate.undo_point)
+		--state->undostate.undo_point;
+	return 0;
+}
+
+// API key: process a keyboard input
+static void stb_textedit_key(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int key)
+{
+retry:
+	switch (key)
+	{
+		default:
+		{
+			int c = STB_TEXTEDIT_KEYTOTEXT(key);
+			if (c > 0)
+			{
+				STB_TEXTEDIT_CHARTYPE ch = (STB_TEXTEDIT_CHARTYPE)c;
+
+				// can't add newline in single-line mode
+				if (c == '\n' && state->single_line)
+					break;
+
+				if (state->insert_mode && !STB_TEXT_HAS_SELECTION(state) && state->cursor < STB_TEXTEDIT_STRINGLEN(str))
+				{
+					stb_text_makeundo_replace(str, state, state->cursor, 1, 1);
+					STB_TEXTEDIT_DELETECHARS(str, state->cursor, 1);
+					if (STB_TEXTEDIT_INSERTCHARS(str, state->cursor, &ch, 1))
+					{
+						++state->cursor;
+						state->has_preferred_x = 0;
+					}
+				}
+				else
+				{
+					stb_textedit_delete_selection(str, state);  // implicity clamps
+					if (STB_TEXTEDIT_INSERTCHARS(str, state->cursor, &ch, 1))
+					{
+						stb_text_makeundo_insert(state, state->cursor, 1);
+						++state->cursor;
+						state->has_preferred_x = 0;
+					}
+				}
+			}
+			break;
+		}
+
+#ifdef STB_TEXTEDIT_K_INSERT
+		case STB_TEXTEDIT_K_INSERT:
+			state->insert_mode = !state->insert_mode;
+			break;
+#endif
+
+		case STB_TEXTEDIT_K_UNDO:
+			stb_text_undo(str, state);
+			state->has_preferred_x = 0;
+			break;
+
+		case STB_TEXTEDIT_K_REDO:
+			stb_text_redo(str, state);
+			state->has_preferred_x = 0;
+			break;
+
+		case STB_TEXTEDIT_K_LEFT:
+			// if currently there's a selection, move cursor to start of selection
+			if (STB_TEXT_HAS_SELECTION(state))
+				stb_textedit_move_to_first(state);
+			else if (state->cursor > 0)
+				--state->cursor;
+			state->has_preferred_x = 0;
+			break;
+
+		case STB_TEXTEDIT_K_RIGHT:
+			// if currently there's a selection, move cursor to end of selection
+			if (STB_TEXT_HAS_SELECTION(state))
+				stb_textedit_move_to_last(str, state);
+			else
+				++state->cursor;
+			stb_textedit_clamp(str, state);
+			state->has_preferred_x = 0;
+			break;
+
+		case STB_TEXTEDIT_K_LEFT | STB_TEXTEDIT_K_SHIFT:
+			stb_textedit_clamp(str, state);
+			stb_textedit_prep_selection_at_cursor(state);
+			// move selection left
+			if (state->select_end > 0)
+				--state->select_end;
+			state->cursor = state->select_end;
+			state->has_preferred_x = 0;
+			break;
+
+#ifdef STB_TEXTEDIT_MOVEWORDLEFT
+		case STB_TEXTEDIT_K_WORDLEFT:
+			if (STB_TEXT_HAS_SELECTION(state))
+				stb_textedit_move_to_first(state);
+			else
+			{
+				state->cursor = STB_TEXTEDIT_MOVEWORDLEFT(str, state->cursor);
+				stb_textedit_clamp(str, state);
+			}
+			break;
+
+		case STB_TEXTEDIT_K_WORDLEFT | STB_TEXTEDIT_K_SHIFT:
+			if (!STB_TEXT_HAS_SELECTION(state))
+				stb_textedit_prep_selection_at_cursor(state);
+
+			state->cursor = STB_TEXTEDIT_MOVEWORDLEFT(str, state->cursor);
+			state->select_end = state->cursor;
+
+			stb_textedit_clamp(str, state);
+			break;
+#endif
+
+#ifdef STB_TEXTEDIT_MOVEWORDRIGHT
+		case STB_TEXTEDIT_K_WORDRIGHT:
+			if (STB_TEXT_HAS_SELECTION(state))
+				stb_textedit_move_to_last(str, state);
+			else
+			{
+				state->cursor = STB_TEXTEDIT_MOVEWORDRIGHT(str, state->cursor);
+				stb_textedit_clamp(str, state);
+			}
+			break;
+
+		case STB_TEXTEDIT_K_WORDRIGHT | STB_TEXTEDIT_K_SHIFT:
+			if (!STB_TEXT_HAS_SELECTION(state))
+				stb_textedit_prep_selection_at_cursor(state);
+
+			state->cursor = STB_TEXTEDIT_MOVEWORDRIGHT(str, state->cursor);
+			state->select_end = state->cursor;
+
+			stb_textedit_clamp(str, state);
+			break;
+#endif
+
+		case STB_TEXTEDIT_K_RIGHT | STB_TEXTEDIT_K_SHIFT:
+			stb_textedit_prep_selection_at_cursor(state);
+			// move selection right
+			++state->select_end;
+			stb_textedit_clamp(str, state);
+			state->cursor = state->select_end;
+			state->has_preferred_x = 0;
+			break;
+
+		case STB_TEXTEDIT_K_DOWN:
+		case STB_TEXTEDIT_K_DOWN | STB_TEXTEDIT_K_SHIFT:
+		{
+			StbFindState find;
+			StbTexteditRow row;
+			int i, sel = (key & STB_TEXTEDIT_K_SHIFT) != 0;
+
+			if (state->single_line)
+			{
+				// on windows, up&down in single-line behave like left&right
+				key = STB_TEXTEDIT_K_RIGHT | (key & STB_TEXTEDIT_K_SHIFT);
+				goto retry;
+			}
+
+			if (sel)
+				stb_textedit_prep_selection_at_cursor(state);
+			else if (STB_TEXT_HAS_SELECTION(state))
+				stb_textedit_move_to_last(str, state);
+
+			// compute current position of cursor point
+			stb_textedit_clamp(str, state);
+			stb_textedit_find_charpos(&find, str, state->cursor, state->single_line);
+
+			// now find character position down a row
+			if (find.length)
+			{
+				float goal_x = state->has_preferred_x ? state->preferred_x : find.x;
+				float x;
+				int start = find.first_char + find.length;
+				state->cursor = start;
+				STB_TEXTEDIT_LAYOUTROW(&row, str, state->cursor);
+				x = row.x0;
+				for (i = 0; i < row.num_chars; ++i)
+				{
+					float dx = STB_TEXTEDIT_GETWIDTH(str, start, i);
+#ifdef STB_TEXTEDIT_GETWIDTH_NEWLINE
+					if (dx == STB_TEXTEDIT_GETWIDTH_NEWLINE)
+						break;
+#endif
+					x += dx;
+					if (x > goal_x)
+						break;
+					++state->cursor;
+				}
+				stb_textedit_clamp(str, state);
+
+				state->has_preferred_x = 1;
+				state->preferred_x = goal_x;
+
+				if (sel)
+					state->select_end = state->cursor;
+			}
+			break;
+		}
+
+		case STB_TEXTEDIT_K_UP:
+		case STB_TEXTEDIT_K_UP | STB_TEXTEDIT_K_SHIFT:
+		{
+			StbFindState find;
+			StbTexteditRow row;
+			int i, sel = (key & STB_TEXTEDIT_K_SHIFT) != 0;
+
+			if (state->single_line)
+			{
+				// on windows, up&down become left&right
+				key = STB_TEXTEDIT_K_LEFT | (key & STB_TEXTEDIT_K_SHIFT);
+				goto retry;
+			}
+
+			if (sel)
+				stb_textedit_prep_selection_at_cursor(state);
+			else if (STB_TEXT_HAS_SELECTION(state))
+				stb_textedit_move_to_first(state);
+
+			// compute current position of cursor point
+			stb_textedit_clamp(str, state);
+			stb_textedit_find_charpos(&find, str, state->cursor, state->single_line);
+
+			// can only go up if there's a previous row
+			if (find.prev_first != find.first_char)
+			{
+				// now find character position up a row
+				float goal_x = state->has_preferred_x ? state->preferred_x : find.x;
+				float x;
+				state->cursor = find.prev_first;
+				STB_TEXTEDIT_LAYOUTROW(&row, str, state->cursor);
+				x = row.x0;
+				for (i = 0; i < row.num_chars; ++i)
+				{
+					float dx = STB_TEXTEDIT_GETWIDTH(str, find.prev_first, i);
+#ifdef STB_TEXTEDIT_GETWIDTH_NEWLINE
+					if (dx == STB_TEXTEDIT_GETWIDTH_NEWLINE)
+						break;
+#endif
+					x += dx;
+					if (x > goal_x)
+						break;
+					++state->cursor;
+				}
+				stb_textedit_clamp(str, state);
+
+				state->has_preferred_x = 1;
+				state->preferred_x = goal_x;
+
+				if (sel)
+					state->select_end = state->cursor;
+			}
+			break;
+		}
+
+		case STB_TEXTEDIT_K_DELETE:
+		case STB_TEXTEDIT_K_DELETE | STB_TEXTEDIT_K_SHIFT:
+			if (STB_TEXT_HAS_SELECTION(state))
+				stb_textedit_delete_selection(str, state);
+			else
+			{
+				int n = STB_TEXTEDIT_STRINGLEN(str);
+				if (state->cursor < n)
+					stb_textedit_delete(str, state, state->cursor, 1);
+			}
+			state->has_preferred_x = 0;
+			break;
+
+		case STB_TEXTEDIT_K_BACKSPACE:
+		case STB_TEXTEDIT_K_BACKSPACE | STB_TEXTEDIT_K_SHIFT:
+			if (STB_TEXT_HAS_SELECTION(state))
+				stb_textedit_delete_selection(str, state);
+			else
+			{
+				stb_textedit_clamp(str, state);
+				if (state->cursor > 0)
+				{
+					stb_textedit_delete(str, state, state->cursor - 1, 1);
+					--state->cursor;
+				}
+			}
+			state->has_preferred_x = 0;
+			break;
+
+#ifdef STB_TEXTEDIT_K_TEXTSTART2
+		case STB_TEXTEDIT_K_TEXTSTART2:
+#endif
+		case STB_TEXTEDIT_K_TEXTSTART:
+			state->cursor = state->select_start = state->select_end = 0;
+			state->has_preferred_x = 0;
+			break;
+
+#ifdef STB_TEXTEDIT_K_TEXTEND2
+		case STB_TEXTEDIT_K_TEXTEND2:
+#endif
+		case STB_TEXTEDIT_K_TEXTEND:
+			state->cursor = STB_TEXTEDIT_STRINGLEN(str);
+			state->select_start = state->select_end = 0;
+			state->has_preferred_x = 0;
+			break;
+
+#ifdef STB_TEXTEDIT_K_TEXTSTART2
+		case STB_TEXTEDIT_K_TEXTSTART2 | STB_TEXTEDIT_K_SHIFT:
+#endif
+		case STB_TEXTEDIT_K_TEXTSTART | STB_TEXTEDIT_K_SHIFT:
+			stb_textedit_prep_selection_at_cursor(state);
+			state->cursor = state->select_end = 0;
+			state->has_preferred_x = 0;
+			break;
+
+#ifdef STB_TEXTEDIT_K_TEXTEND2
+		case STB_TEXTEDIT_K_TEXTEND2 | STB_TEXTEDIT_K_SHIFT:
+#endif
+		case STB_TEXTEDIT_K_TEXTEND | STB_TEXTEDIT_K_SHIFT:
+			stb_textedit_prep_selection_at_cursor(state);
+			state->cursor = state->select_end = STB_TEXTEDIT_STRINGLEN(str);
+			state->has_preferred_x = 0;
+			break;
+
+#ifdef STB_TEXTEDIT_K_LINESTART2
+		case STB_TEXTEDIT_K_LINESTART2:
+#endif
+		case STB_TEXTEDIT_K_LINESTART:
+			stb_textedit_clamp(str, state);
+			stb_textedit_move_to_first(state);
+			if (state->single_line)
+				state->cursor = 0;
+			else
+				while (state->cursor > 0 && STB_TEXTEDIT_GETCHAR(str, state->cursor - 1) != STB_TEXTEDIT_NEWLINE)
+					--state->cursor;
+			state->has_preferred_x = 0;
+			break;
+
+#ifdef STB_TEXTEDIT_K_LINEEND2
+		case STB_TEXTEDIT_K_LINEEND2:
+#endif
+		case STB_TEXTEDIT_K_LINEEND:
+		{
+			int n = STB_TEXTEDIT_STRINGLEN(str);
+			stb_textedit_clamp(str, state);
+			stb_textedit_move_to_first(state);
+			if (state->single_line)
+				state->cursor = n;
+			else
+				while (state->cursor < n && STB_TEXTEDIT_GETCHAR(str, state->cursor) != STB_TEXTEDIT_NEWLINE)
+					++state->cursor;
+			state->has_preferred_x = 0;
+			break;
+		}
+
+#ifdef STB_TEXTEDIT_K_LINESTART2
+		case STB_TEXTEDIT_K_LINESTART2 | STB_TEXTEDIT_K_SHIFT:
+#endif
+		case STB_TEXTEDIT_K_LINESTART | STB_TEXTEDIT_K_SHIFT:
+			stb_textedit_clamp(str, state);
+			stb_textedit_prep_selection_at_cursor(state);
+			if (state->single_line)
+				state->cursor = 0;
+			else
+				while (state->cursor > 0 && STB_TEXTEDIT_GETCHAR(str, state->cursor - 1) != STB_TEXTEDIT_NEWLINE)
+					--state->cursor;
+			state->select_end = state->cursor;
+			state->has_preferred_x = 0;
+			break;
+
+#ifdef STB_TEXTEDIT_K_LINEEND2
+		case STB_TEXTEDIT_K_LINEEND2 | STB_TEXTEDIT_K_SHIFT:
+#endif
+		case STB_TEXTEDIT_K_LINEEND | STB_TEXTEDIT_K_SHIFT:
+		{
+			int n = STB_TEXTEDIT_STRINGLEN(str);
+			stb_textedit_clamp(str, state);
+			stb_textedit_prep_selection_at_cursor(state);
+			if (state->single_line)
+				state->cursor = n;
+			else
+				while (state->cursor < n && STB_TEXTEDIT_GETCHAR(str, state->cursor) != STB_TEXTEDIT_NEWLINE)
+					++state->cursor;
+			state->select_end = state->cursor;
+			state->has_preferred_x = 0;
+			break;
+		}
+
+			// @TODO:
+			//    STB_TEXTEDIT_K_PGUP      - move cursor up a page
+			//    STB_TEXTEDIT_K_PGDOWN    - move cursor down a page
+	}
+}
+
+/////////////////////////////////////////////////////////////////////////////
+//
+//      Undo processing
+//
+// @OPTIMIZE: the undo/redo buffer should be circular
+
+static void stb_textedit_flush_redo(StbUndoState *state)
+{
+	state->redo_point = STB_TEXTEDIT_UNDOSTATECOUNT;
+	state->redo_char_point = STB_TEXTEDIT_UNDOCHARCOUNT;
+}
+
+// discard the oldest entry in the undo list
+static void stb_textedit_discard_undo(StbUndoState *state)
+{
+	if (state->undo_point > 0)
+	{
+		// if the 0th undo state has characters, clean those up
+		if (state->undo_rec[0].char_storage >= 0)
+		{
+			int n = state->undo_rec[0].insert_length, i;
+			// delete n characters from all other records
+			state->undo_char_point = state->undo_char_point - (short)n;  // vsnet05
+			STB_TEXTEDIT_memmove(state->undo_char, state->undo_char + n, (size_t)((size_t)state->undo_char_point * sizeof(STB_TEXTEDIT_CHARTYPE)));
+			for (i = 0; i < state->undo_point; ++i)
+				if (state->undo_rec[i].char_storage >= 0)
+					state->undo_rec[i].char_storage = state->undo_rec[i].char_storage - (short)n;  // vsnet05 // @OPTIMIZE: get rid of char_storage and infer it
+		}
+		--state->undo_point;
+		STB_TEXTEDIT_memmove(state->undo_rec, state->undo_rec + 1, (size_t)((size_t)state->undo_point * sizeof(state->undo_rec[0])));
+	}
+}
+
+// discard the oldest entry in the redo list--it's bad if this
+// ever happens, but because undo & redo have to store the actual
+// characters in different cases, the redo character buffer can
+// fill up even though the undo buffer didn't
+static void stb_textedit_discard_redo(StbUndoState *state)
+{
+	int k = STB_TEXTEDIT_UNDOSTATECOUNT - 1;
+
+	if (state->redo_point <= k)
+	{
+		// if the k'th undo state has characters, clean those up
+		if (state->undo_rec[k].char_storage >= 0)
+		{
+			int n = state->undo_rec[k].insert_length, i;
+			// delete n characters from all other records
+			state->redo_char_point = state->redo_char_point + (short)n;  // vsnet05
+			STB_TEXTEDIT_memmove(state->undo_char + state->redo_char_point, state->undo_char + state->redo_char_point - n, (size_t)((size_t)(STB_TEXTEDIT_UNDOCHARCOUNT - state->redo_char_point) * sizeof(STB_TEXTEDIT_CHARTYPE)));
+			for (i = state->redo_point; i < k; ++i)
+				if (state->undo_rec[i].char_storage >= 0)
+					state->undo_rec[i].char_storage = state->undo_rec[i].char_storage + (short)n;  // vsnet05
+		}
+		STB_TEXTEDIT_memmove(state->undo_rec + state->redo_point, state->undo_rec + state->redo_point - 1, (size_t)((size_t)(STB_TEXTEDIT_UNDOSTATECOUNT - state->redo_point) * sizeof(state->undo_rec[0])));
+		++state->redo_point;
+	}
+}
+
+static StbUndoRecord *stb_text_create_undo_record(StbUndoState *state, int numchars)
+{
+	// any time we create a new undo record, we discard redo
+	stb_textedit_flush_redo(state);
+
+	// if we have no free records, we have to make room, by sliding the
+	// existing records down
+	if (state->undo_point == STB_TEXTEDIT_UNDOSTATECOUNT)
+		stb_textedit_discard_undo(state);
+
+	// if the characters to store won't possibly fit in the buffer, we can't undo
+	if (numchars > STB_TEXTEDIT_UNDOCHARCOUNT)
+	{
+		state->undo_point = 0;
+		state->undo_char_point = 0;
+		return NULL;
+	}
+
+	// if we don't have enough free characters in the buffer, we have to make room
+	while (state->undo_char_point + numchars > STB_TEXTEDIT_UNDOCHARCOUNT)
+		stb_textedit_discard_undo(state);
+
+	return &state->undo_rec[state->undo_point++];
+}
+
+static STB_TEXTEDIT_CHARTYPE *stb_text_createundo(StbUndoState *state, int pos, int insert_len, int delete_len)
+{
+	StbUndoRecord *r = stb_text_create_undo_record(state, insert_len);
+	if (r == NULL)
+		return NULL;
+
+	r->where = pos;
+	r->insert_length = (short)insert_len;
+	r->delete_length = (short)delete_len;
+
+	if (insert_len == 0)
+	{
+		r->char_storage = -1;
+		return NULL;
+	}
+	else
+	{
+		r->char_storage = state->undo_char_point;
+		state->undo_char_point = state->undo_char_point + (short)insert_len;
+		return &state->undo_char[r->char_storage];
+	}
+}
+
+static void stb_text_undo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
+{
+	StbUndoState *s = &state->undostate;
+	StbUndoRecord u, *r;
+	if (s->undo_point == 0)
+		return;
+
+	// we need to do two things: apply the undo record, and create a redo record
+	u = s->undo_rec[s->undo_point - 1];
+	r = &s->undo_rec[s->redo_point - 1];
+	r->char_storage = -1;
+
+	r->insert_length = u.delete_length;
+	r->delete_length = u.insert_length;
+	r->where = u.where;
+
+	if (u.delete_length)
+	{
+		// if the undo record says to delete characters, then the redo record will
+		// need to re-insert the characters that get deleted, so we need to store
+		// them.
+
+		// there are three cases:
+		//    there's enough room to store the characters
+		//    characters stored for *redoing* don't leave room for redo
+		//    characters stored for *undoing* don't leave room for redo
+		// if the last is true, we have to bail
+
+		if (s->undo_char_point + u.delete_length >= STB_TEXTEDIT_UNDOCHARCOUNT)
+		{
+			// the undo records take up too much character space; there's no space to store the redo characters
+			r->insert_length = 0;
+		}
+		else
+		{
+			int i;
+
+			// there's definitely room to store the characters eventually
+			while (s->undo_char_point + u.delete_length > s->redo_char_point)
+			{
+				// there's currently not enough room, so discard a redo record
+				stb_textedit_discard_redo(s);
+				// should never happen:
+				if (s->redo_point == STB_TEXTEDIT_UNDOSTATECOUNT)
+					return;
+			}
+			r = &s->undo_rec[s->redo_point - 1];
+
+			r->char_storage = s->redo_char_point - u.delete_length;
+			s->redo_char_point = s->redo_char_point - (short)u.delete_length;
+
+			// now save the characters
+			for (i = 0; i < u.delete_length; ++i)
+				s->undo_char[r->char_storage + i] = STB_TEXTEDIT_GETCHAR(str, u.where + i);
+		}
+
+		// now we can carry out the deletion
+		STB_TEXTEDIT_DELETECHARS(str, u.where, u.delete_length);
+	}
+
+	// check type of recorded action:
+	if (u.insert_length)
+	{
+		// easy case: was a deletion, so we need to insert n characters
+		STB_TEXTEDIT_INSERTCHARS(str, u.where, &s->undo_char[u.char_storage], u.insert_length);
+		s->undo_char_point -= u.insert_length;
+	}
+
+	state->cursor = u.where + u.insert_length;
+
+	s->undo_point--;
+	s->redo_point--;
+}
+
+static void stb_text_redo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
+{
+	StbUndoState *s = &state->undostate;
+	StbUndoRecord *u, r;
+	if (s->redo_point == STB_TEXTEDIT_UNDOSTATECOUNT)
+		return;
+
+	// we need to do two things: apply the redo record, and create an undo record
+	u = &s->undo_rec[s->undo_point];
+	r = s->undo_rec[s->redo_point];
+
+	// we KNOW there must be room for the undo record, because the redo record
+	// was derived from an undo record
+
+	u->delete_length = r.insert_length;
+	u->insert_length = r.delete_length;
+	u->where = r.where;
+	u->char_storage = -1;
+
+	if (r.delete_length)
+	{
+		// the redo record requires us to delete characters, so the undo record
+		// needs to store the characters
+
+		if (s->undo_char_point + u->insert_length > s->redo_char_point)
+		{
+			u->insert_length = 0;
+			u->delete_length = 0;
+		}
+		else
+		{
+			int i;
+			u->char_storage = s->undo_char_point;
+			s->undo_char_point = s->undo_char_point + u->insert_length;
+
+			// now save the characters
+			for (i = 0; i < u->insert_length; ++i)
+				s->undo_char[u->char_storage + i] = STB_TEXTEDIT_GETCHAR(str, u->where + i);
+		}
+
+		STB_TEXTEDIT_DELETECHARS(str, r.where, r.delete_length);
+	}
+
+	if (r.insert_length)
+	{
+		// easy case: need to insert n characters
+		STB_TEXTEDIT_INSERTCHARS(str, r.where, &s->undo_char[r.char_storage], r.insert_length);
+		s->redo_char_point += r.insert_length;
+	}
+
+	state->cursor = r.where + r.insert_length;
+
+	s->undo_point++;
+	s->redo_point++;
+}
+
+static void stb_text_makeundo_insert(STB_TexteditState *state, int where, int length)
+{
+	stb_text_createundo(&state->undostate, where, 0, length);
+}
+
+static void stb_text_makeundo_delete(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int length)
+{
+	int i;
+	STB_TEXTEDIT_CHARTYPE *p = stb_text_createundo(&state->undostate, where, length, 0);
+	if (p)
+	{
+		for (i = 0; i < length; ++i)
+			p[i] = STB_TEXTEDIT_GETCHAR(str, where + i);
+	}
+}
+
+static void stb_text_makeundo_replace(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int old_length, int new_length)
+{
+	int i;
+	STB_TEXTEDIT_CHARTYPE *p = stb_text_createundo(&state->undostate, where, old_length, new_length);
+	if (p)
+	{
+		for (i = 0; i < old_length; ++i)
+			p[i] = STB_TEXTEDIT_GETCHAR(str, where + i);
+	}
+}
+
+// reset the state to default
+static void stb_textedit_clear_state(STB_TexteditState *state, int is_single_line)
+{
+	state->undostate.undo_point = 0;
+	state->undostate.undo_char_point = 0;
+	state->undostate.redo_point = STB_TEXTEDIT_UNDOSTATECOUNT;
+	state->undostate.redo_char_point = STB_TEXTEDIT_UNDOCHARCOUNT;
+	state->select_end = state->select_start = 0;
+	state->cursor = 0;
+	state->has_preferred_x = 0;
+	state->preferred_x = 0;
+	state->cursor_at_end_of_line = 0;
+	state->initialized = 1;
+	state->single_line = (unsigned char)is_single_line;
+	state->insert_mode = 0;
+}
+
+// API initialize
+static void stb_textedit_initialize_state(STB_TexteditState *state, int is_single_line)
+{
+	stb_textedit_clear_state(state, is_single_line);
+}
+#endif  //STB_TEXTEDIT_IMPLEMENTATION
diff --git a/engine/inc/bullet/ThirdPartyLibs/imgui/stb_truetype.h b/engine/inc/bullet/ThirdPartyLibs/imgui/stb_truetype.h
new file mode 100644
index 00000000..2e8b093b
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/imgui/stb_truetype.h
@@ -0,0 +1,5259 @@
+// stb_truetype.h - v1.19 - public domain
+// authored from 2009-2016 by Sean Barrett / RAD Game Tools
+//
+//   This library processes TrueType files:
+//        parse files
+//        extract glyph metrics
+//        extract glyph shapes
+//        render glyphs to one-channel bitmaps with antialiasing (box filter)
+//        render glyphs to one-channel SDF bitmaps (signed-distance field/function)
+//
+//   Todo:
+//        non-MS cmaps
+//        crashproof on bad data
+//        hinting? (no longer patented)
+//        cleartype-style AA?
+//        optimize: use simple memory allocator for intermediates
+//        optimize: build edge-list directly from curves
+//        optimize: rasterize directly from curves?
+//
+// ADDITIONAL CONTRIBUTORS
+//
+//   Mikko Mononen: compound shape support, more cmap formats
+//   Tor Andersson: kerning, subpixel rendering
+//   Dougall Johnson: OpenType / Type 2 font handling
+//   Daniel Ribeiro Maciel: basic GPOS-based kerning
+//
+//   Misc other:
+//       Ryan Gordon
+//       Simon Glass
+//       github:IntellectualKitty
+//       Imanol Celaya
+//       Daniel Ribeiro Maciel
+//
+//   Bug/warning reports/fixes:
+//       "Zer" on mollyrocket       Fabian "ryg" Giesen
+//       Cass Everitt               Martins Mozeiko
+//       stoiko (Haemimont Games)   Cap Petschulat
+//       Brian Hook                 Omar Cornut
+//       Walter van Niftrik         github:aloucks
+//       David Gow                  Peter LaValle
+//       David Given                Sergey Popov
+//       Ivan-Assen Ivanov          Giumo X. Clanjor
+//       Anthony Pesch              Higor Euripedes
+//       Johan Duparc               Thomas Fields
+//       Hou Qiming                 Derek Vinyard
+//       Rob Loach                  Cort Stratton
+//       Kenney Phillis Jr.         github:oyvindjam
+//       Brian Costabile            github:vassvik
+//
+// VERSION HISTORY
+//
+//   1.19 (2018-02-11) GPOS kerning, STBTT_fmod
+//   1.18 (2018-01-29) add missing function
+//   1.17 (2017-07-23) make more arguments const; doc fix
+//   1.16 (2017-07-12) SDF support
+//   1.15 (2017-03-03) make more arguments const
+//   1.14 (2017-01-16) num-fonts-in-TTC function
+//   1.13 (2017-01-02) support OpenType fonts, certain Apple fonts
+//   1.12 (2016-10-25) suppress warnings about casting away const with -Wcast-qual
+//   1.11 (2016-04-02) fix unused-variable warning
+//   1.10 (2016-04-02) user-defined fabs(); rare memory leak; remove duplicate typedef
+//   1.09 (2016-01-16) warning fix; avoid crash on outofmem; use allocation userdata properly
+//   1.08 (2015-09-13) document stbtt_Rasterize(); fixes for vertical & horizontal edges
+//   1.07 (2015-08-01) allow PackFontRanges to accept arrays of sparse codepoints;
+//                     variant PackFontRanges to pack and render in separate phases;
+//                     fix stbtt_GetFontOFfsetForIndex (never worked for non-0 input?);
+//                     fixed an assert() bug in the new rasterizer
+//                     replace assert() with STBTT_assert() in new rasterizer
+//
+//   Full history can be found at the end of this file.
+//
+// LICENSE
+//
+//   See end of file for license information.
+//
+// USAGE
+//
+//   Include this file in whatever places neeed to refer to it. In ONE C/C++
+//   file, write:
+//      #define STB_TRUETYPE_IMPLEMENTATION
+//   before the #include of this file. This expands out the actual
+//   implementation into that C/C++ file.
+//
+//   To make the implementation private to the file that generates the implementation,
+//      #define STBTT_STATIC
+//
+//   Simple 3D API (don't ship this, but it's fine for tools and quick start)
+//           stbtt_BakeFontBitmap()               -- bake a font to a bitmap for use as texture
+//           stbtt_GetBakedQuad()                 -- compute quad to draw for a given char
+//
+//   Improved 3D API (more shippable):
+//           #include "stb_rect_pack.h"           -- optional, but you really want it
+//           stbtt_PackBegin()
+//           stbtt_PackSetOversampling()          -- for improved quality on small fonts
+//           stbtt_PackFontRanges()               -- pack and renders
+//           stbtt_PackEnd()
+//           stbtt_GetPackedQuad()
+//
+//   "Load" a font file from a memory buffer (you have to keep the buffer loaded)
+//           stbtt_InitFont()
+//           stbtt_GetFontOffsetForIndex()        -- indexing for TTC font collections
+//           stbtt_GetNumberOfFonts()             -- number of fonts for TTC font collections
+//
+//   Render a unicode codepoint to a bitmap
+//           stbtt_GetCodepointBitmap()           -- allocates and returns a bitmap
+//           stbtt_MakeCodepointBitmap()          -- renders into bitmap you provide
+//           stbtt_GetCodepointBitmapBox()        -- how big the bitmap must be
+//
+//   Character advance/positioning
+//           stbtt_GetCodepointHMetrics()
+//           stbtt_GetFontVMetrics()
+//           stbtt_GetFontVMetricsOS2()
+//           stbtt_GetCodepointKernAdvance()
+//
+//   Starting with version 1.06, the rasterizer was replaced with a new,
+//   faster and generally-more-precise rasterizer. The new rasterizer more
+//   accurately measures pixel coverage for anti-aliasing, except in the case
+//   where multiple shapes overlap, in which case it overestimates the AA pixel
+//   coverage. Thus, anti-aliasing of intersecting shapes may look wrong. If
+//   this turns out to be a problem, you can re-enable the old rasterizer with
+//        #define STBTT_RASTERIZER_VERSION 1
+//   which will incur about a 15% speed hit.
+//
+// ADDITIONAL DOCUMENTATION
+//
+//   Immediately after this block comment are a series of sample programs.
+//
+//   After the sample programs is the "header file" section. This section
+//   includes documentation for each API function.
+//
+//   Some important concepts to understand to use this library:
+//
+//      Codepoint
+//         Characters are defined by unicode codepoints, e.g. 65 is
+//         uppercase A, 231 is lowercase c with a cedilla, 0x7e30 is
+//         the hiragana for "ma".
+//
+//      Glyph
+//         A visual character shape (every codepoint is rendered as
+//         some glyph)
+//
+//      Glyph index
+//         A font-specific integer ID representing a glyph
+//
+//      Baseline
+//         Glyph shapes are defined relative to a baseline, which is the
+//         bottom of uppercase characters. Characters extend both above
+//         and below the baseline.
+//
+//      Current Point
+//         As you draw text to the screen, you keep track of a "current point"
+//         which is the origin of each character. The current point's vertical
+//         position is the baseline. Even "baked fonts" use this model.
+//
+//      Vertical Font Metrics
+//         The vertical qualities of the font, used to vertically position
+//         and space the characters. See docs for stbtt_GetFontVMetrics.
+//
+//      Font Size in Pixels or Points
+//         The preferred interface for specifying font sizes in stb_truetype
+//         is to specify how tall the font's vertical extent should be in pixels.
+//         If that sounds good enough, skip the next paragraph.
+//
+//         Most font APIs instead use "points", which are a common typographic
+//         measurement for describing font size, defined as 72 points per inch.
+//         stb_truetype provides a point API for compatibility. However, true
+//         "per inch" conventions don't make much sense on computer displays
+//         since different monitors have different number of pixels per
+//         inch. For example, Windows traditionally uses a convention that
+//         there are 96 pixels per inch, thus making 'inch' measurements have
+//         nothing to do with inches, and thus effectively defining a point to
+//         be 1.333 pixels. Additionally, the TrueType font data provides
+//         an explicit scale factor to scale a given font's glyphs to points,
+//         but the author has observed that this scale factor is often wrong
+//         for non-commercial fonts, thus making fonts scaled in points
+//         according to the TrueType spec incoherently sized in practice.
+//
+// DETAILED USAGE:
+//
+//  Scale:
+//    Select how high you want the font to be, in points or pixels.
+//    Call ScaleForPixelHeight or ScaleForMappingEmToPixels to compute
+//    a scale factor SF that will be used by all other functions.
+//
+//  Baseline:
+//    You need to select a y-coordinate that is the baseline of where
+//    your text will appear. Call GetFontBoundingBox to get the baseline-relative
+//    bounding box for all characters. SF*-y0 will be the distance in pixels
+//    that the worst-case character could extend above the baseline, so if
+//    you want the top edge of characters to appear at the top of the
+//    screen where y=0, then you would set the baseline to SF*-y0.
+//
+//  Current point:
+//    Set the current point where the first character will appear. The
+//    first character could extend left of the current point; this is font
+//    dependent. You can either choose a current point that is the leftmost
+//    point and hope, or add some padding, or check the bounding box or
+//    left-side-bearing of the first character to be displayed and set
+//    the current point based on that.
+//
+//  Displaying a character:
+//    Compute the bounding box of the character. It will contain signed values
+//    relative to <current_point, baseline>. I.e. if it returns x0,y0,x1,y1,
+//    then the character should be displayed in the rectangle from
+//    <current_point+SF*x0, baseline+SF*y0> to <current_point+SF*x1,baseline+SF*y1).
+//
+//  Advancing for the next character:
+//    Call GlyphHMetrics, and compute 'current_point += SF * advance'.
+//
+//
+// ADVANCED USAGE
+//
+//   Quality:
+//
+//    - Use the functions with Subpixel at the end to allow your characters
+//      to have subpixel positioning. Since the font is anti-aliased, not
+//      hinted, this is very import for quality. (This is not possible with
+//      baked fonts.)
+//
+//    - Kerning is now supported, and if you're supporting subpixel rendering
+//      then kerning is worth using to give your text a polished look.
+//
+//   Performance:
+//
+//    - Convert Unicode codepoints to glyph indexes and operate on the glyphs;
+//      if you don't do this, stb_truetype is forced to do the conversion on
+//      every call.
+//
+//    - There are a lot of memory allocations. We should modify it to take
+//      a temp buffer and allocate from the temp buffer (without freeing),
+//      should help performance a lot.
+//
+// NOTES
+//
+//   The system uses the raw data found in the .ttf file without changing it
+//   and without building auxiliary data structures. This is a bit inefficient
+//   on little-endian systems (the data is big-endian), but assuming you're
+//   caching the bitmaps or glyph shapes this shouldn't be a big deal.
+//
+//   It appears to be very hard to programmatically determine what font a
+//   given file is in a general way. I provide an API for this, but I don't
+//   recommend it.
+//
+//
+// SOURCE STATISTICS (based on v0.6c, 2050 LOC)
+//
+//   Documentation & header file        520 LOC  \___ 660 LOC documentation
+//   Sample code                        140 LOC  /
+//   Truetype parsing                   620 LOC  ---- 620 LOC TrueType
+//   Software rasterization             240 LOC  \                           .
+//   Curve tesselation                  120 LOC   \__ 550 LOC Bitmap creation
+//   Bitmap management                  100 LOC   /
+//   Baked bitmap interface              70 LOC  /
+//   Font name matching & access        150 LOC  ---- 150
+//   C runtime library abstraction       60 LOC  ----  60
+//
+//
+// PERFORMANCE MEASUREMENTS FOR 1.06:
+//
+//                      32-bit     64-bit
+//   Previous release:  8.83 s     7.68 s
+//   Pool allocations:  7.72 s     6.34 s
+//   Inline sort     :  6.54 s     5.65 s
+//   New rasterizer  :  5.63 s     5.00 s
+
+//////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+////
+////  SAMPLE PROGRAMS
+////
+//
+//  Incomplete text-in-3d-api example, which draws quads properly aligned to be lossless
+//
+#if 0
+#define STB_TRUETYPE_IMPLEMENTATION  // force following include to generate implementation
+#include "stb_truetype.h"
+
+unsigned char ttf_buffer[1<<20];
+unsigned char temp_bitmap[512*512];
+
+stbtt_bakedchar cdata[96]; // ASCII 32..126 is 95 glyphs
+GLuint ftex;
+
+void my_stbtt_initfont(void)
+{
+   fread(ttf_buffer, 1, 1<<20, fopen("c:/windows/fonts/times.ttf", "rb"));
+   stbtt_BakeFontBitmap(ttf_buffer,0, 32.0, temp_bitmap,512,512, 32,96, cdata); // no guarantee this fits!
+   // can free ttf_buffer at this point
+   glGenTextures(1, &ftex);
+   glBindTexture(GL_TEXTURE_2D, ftex);
+   glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, 512,512, 0, GL_ALPHA, GL_UNSIGNED_BYTE, temp_bitmap);
+   // can free temp_bitmap at this point
+   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+}
+
+void my_stbtt_print(float x, float y, char *text)
+{
+   // assume orthographic projection with units = screen pixels, origin at top left
+   glEnable(GL_TEXTURE_2D);
+   glBindTexture(GL_TEXTURE_2D, ftex);
+   glBegin(GL_QUADS);
+   while (*text) {
+      if (*text >= 32 && *text < 128) {
+         stbtt_aligned_quad q;
+         stbtt_GetBakedQuad(cdata, 512,512, *text-32, &x,&y,&q,1);//1=opengl & d3d10+,0=d3d9
+         glTexCoord2f(q.s0,q.t1); glVertex2f(q.x0,q.y0);
+         glTexCoord2f(q.s1,q.t1); glVertex2f(q.x1,q.y0);
+         glTexCoord2f(q.s1,q.t0); glVertex2f(q.x1,q.y1);
+         glTexCoord2f(q.s0,q.t0); glVertex2f(q.x0,q.y1);
+      }
+      ++text;
+   }
+   glEnd();
+}
+#endif
+//
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// Complete program (this compiles): get a single bitmap, print as ASCII art
+//
+#if 0
+#include <stdio.h>
+#define STB_TRUETYPE_IMPLEMENTATION  // force following include to generate implementation
+#include "stb_truetype.h"
+
+char ttf_buffer[1<<25];
+
+int main(int argc, char **argv)
+{
+   stbtt_fontinfo font;
+   unsigned char *bitmap;
+   int w,h,i,j,c = (argc > 1 ? atoi(argv[1]) : 'a'), s = (argc > 2 ? atoi(argv[2]) : 20);
+
+   fread(ttf_buffer, 1, 1<<25, fopen(argc > 3 ? argv[3] : "c:/windows/fonts/arialbd.ttf", "rb"));
+
+   stbtt_InitFont(&font, ttf_buffer, stbtt_GetFontOffsetForIndex(ttf_buffer,0));
+   bitmap = stbtt_GetCodepointBitmap(&font, 0,stbtt_ScaleForPixelHeight(&font, s), c, &w, &h, 0,0);
+
+   for (j=0; j < h; ++j) {
+      for (i=0; i < w; ++i)
+         putchar(" .:ioVM@"[bitmap[j*w+i]>>5]);
+      putchar('\n');
+   }
+   return 0;
+}
+#endif
+//
+// Output:
+//
+//     .ii.
+//    @@@@@@.
+//   V@Mio@@o
+//   :i.  V@V
+//     :oM@@M
+//   :@@@MM@M
+//   @@o  o@M
+//  :@@.  M@M
+//   @@@o@@@@
+//   :M@@V:@@.
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// Complete program: print "Hello World!" banner, with bugs
+//
+#if 0
+char buffer[24<<20];
+unsigned char screen[20][79];
+
+int main(int arg, char **argv)
+{
+   stbtt_fontinfo font;
+   int i,j,ascent,baseline,ch=0;
+   float scale, xpos=2; // leave a little padding in case the character extends left
+   char *text = "Heljo World!"; // intentionally misspelled to show 'lj' brokenness
+
+   fread(buffer, 1, 1000000, fopen("c:/windows/fonts/arialbd.ttf", "rb"));
+   stbtt_InitFont(&font, buffer, 0);
+
+   scale = stbtt_ScaleForPixelHeight(&font, 15);
+   stbtt_GetFontVMetrics(&font, &ascent,0,0);
+   baseline = (int) (ascent*scale);
+
+   while (text[ch]) {
+      int advance,lsb,x0,y0,x1,y1;
+      float x_shift = xpos - (float) floor(xpos);
+      stbtt_GetCodepointHMetrics(&font, text[ch], &advance, &lsb);
+      stbtt_GetCodepointBitmapBoxSubpixel(&font, text[ch], scale,scale,x_shift,0, &x0,&y0,&x1,&y1);
+      stbtt_MakeCodepointBitmapSubpixel(&font, &screen[baseline + y0][(int) xpos + x0], x1-x0,y1-y0, 79, scale,scale,x_shift,0, text[ch]);
+      // note that this stomps the old data, so where character boxes overlap (e.g. 'lj') it's wrong
+      // because this API is really for baking character bitmaps into textures. if you want to render
+      // a sequence of characters, you really need to render each bitmap to a temp buffer, then
+      // "alpha blend" that into the working buffer
+      xpos += (advance * scale);
+      if (text[ch+1])
+         xpos += scale*stbtt_GetCodepointKernAdvance(&font, text[ch],text[ch+1]);
+      ++ch;
+   }
+
+   for (j=0; j < 20; ++j) {
+      for (i=0; i < 78; ++i)
+         putchar(" .:ioVM@"[screen[j][i]>>5]);
+      putchar('\n');
+   }
+
+   return 0;
+}
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+////
+////   INTEGRATION WITH YOUR CODEBASE
+////
+////   The following sections allow you to supply alternate definitions
+////   of C library functions used by stb_truetype, e.g. if you don't
+////   link with the C runtime library.
+
+#ifdef STB_TRUETYPE_IMPLEMENTATION
+// #define your own (u)stbtt_int8/16/32 before including to override this
+#ifndef stbtt_uint8
+typedef unsigned char stbtt_uint8;
+typedef signed char stbtt_int8;
+typedef unsigned short stbtt_uint16;
+typedef signed short stbtt_int16;
+typedef unsigned int stbtt_uint32;
+typedef signed int stbtt_int32;
+#endif
+
+typedef char stbtt__check_size32[sizeof(stbtt_int32) == 4 ? 1 : -1];
+typedef char stbtt__check_size16[sizeof(stbtt_int16) == 2 ? 1 : -1];
+
+// e.g. #define your own STBTT_ifloor/STBTT_iceil() to avoid math.h
+#ifndef STBTT_ifloor
+#include <math.h>
+#define STBTT_ifloor(x) ((int)floor(x))
+#define STBTT_iceil(x) ((int)ceil(x))
+#endif
+
+#ifndef STBTT_sqrt
+#include <math.h>
+#define STBTT_sqrt(x) sqrt(x)
+#define STBTT_pow(x, y) pow(x, y)
+#endif
+
+#ifndef STBTT_fmod
+#include <math.h>
+#define STBTT_fmod(x, y) fmod(x, y)
+#endif
+
+#ifndef STBTT_cos
+#include <math.h>
+#define STBTT_cos(x) cos(x)
+#define STBTT_acos(x) acos(x)
+#endif
+
+#ifndef STBTT_fabs
+#include <math.h>
+#define STBTT_fabs(x) fabs(x)
+#endif
+
+// #define your own functions "STBTT_malloc" / "STBTT_free" to avoid malloc.h
+#ifndef STBTT_malloc
+#include <stdlib.h>
+#define STBTT_malloc(x, u) ((void)(u), malloc(x))
+#define STBTT_free(x, u) ((void)(u), free(x))
+#endif
+
+#ifndef STBTT_assert
+#include <assert.h>
+#define STBTT_assert(x) assert(x)
+#endif
+
+#ifndef STBTT_strlen
+#include <string.h>
+#define STBTT_strlen(x) strlen(x)
+#endif
+
+#ifndef STBTT_memcpy
+#include <string.h>
+#define STBTT_memcpy memcpy
+#define STBTT_memset memset
+#endif
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+////
+////   INTERFACE
+////
+////
+
+#ifndef __STB_INCLUDE_STB_TRUETYPE_H__
+#define __STB_INCLUDE_STB_TRUETYPE_H__
+
+#ifdef STBTT_STATIC
+#define STBTT_DEF static
+#else
+#define STBTT_DEF extern
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	// private structure
+	typedef struct
+	{
+		unsigned char *data;
+		int cursor;
+		int size;
+	} stbtt__buf;
+
+	//////////////////////////////////////////////////////////////////////////////
+	//
+	// TEXTURE BAKING API
+	//
+	// If you use this API, you only have to call two functions ever.
+	//
+
+	typedef struct
+	{
+		unsigned short x0, y0, x1, y1;  // coordinates of bbox in bitmap
+		float xoff, yoff, xadvance;
+	} stbtt_bakedchar;
+
+	STBTT_DEF int stbtt_BakeFontBitmap(const unsigned char *data, int offset,  // font location (use offset=0 for plain .ttf)
+									   float pixel_height,                     // height of font in pixels
+									   unsigned char *pixels, int pw, int ph,  // bitmap to be filled in
+									   int first_char, int num_chars,          // characters to bake
+									   stbtt_bakedchar *chardata);             // you allocate this, it's num_chars long
+	// if return is positive, the first unused row of the bitmap
+	// if return is negative, returns the negative of the number of characters that fit
+	// if return is 0, no characters fit and no rows were used
+	// This uses a very crappy packing.
+
+	typedef struct
+	{
+		float x0, y0, s0, t0;  // top-left
+		float x1, y1, s1, t1;  // bottom-right
+	} stbtt_aligned_quad;
+
+	STBTT_DEF void stbtt_GetBakedQuad(const stbtt_bakedchar *chardata, int pw, int ph,  // same data as above
+									  int char_index,                                   // character to display
+									  float *xpos, float *ypos,                         // pointers to current position in screen pixel space
+									  stbtt_aligned_quad *q,                            // output: quad to draw
+									  int opengl_fillrule);                             // true if opengl fill rule; false if DX9 or earlier
+	// Call GetBakedQuad with char_index = 'character - first_char', and it
+	// creates the quad you need to draw and advances the current position.
+	//
+	// The coordinate system used assumes y increases downwards.
+	//
+	// Characters will extend both above and below the current position;
+	// see discussion of "BASELINE" above.
+	//
+	// It's inefficient; you might want to c&p it and optimize it.
+
+	//////////////////////////////////////////////////////////////////////////////
+	//
+	// NEW TEXTURE BAKING API
+	//
+	// This provides options for packing multiple fonts into one atlas, not
+	// perfectly but better than nothing.
+
+	typedef struct
+	{
+		unsigned short x0, y0, x1, y1;  // coordinates of bbox in bitmap
+		float xoff, yoff, xadvance;
+		float xoff2, yoff2;
+	} stbtt_packedchar;
+
+	typedef struct stbtt_pack_context stbtt_pack_context;
+	typedef struct stbtt_fontinfo stbtt_fontinfo;
+#ifndef STB_RECT_PACK_VERSION
+	typedef struct stbrp_rect stbrp_rect;
+#endif
+
+	STBTT_DEF int stbtt_PackBegin(stbtt_pack_context *spc, unsigned char *pixels, int width, int height, int stride_in_bytes, int padding, void *alloc_context);
+	// Initializes a packing context stored in the passed-in stbtt_pack_context.
+	// Future calls using this context will pack characters into the bitmap passed
+	// in here: a 1-channel bitmap that is width * height. stride_in_bytes is
+	// the distance from one row to the next (or 0 to mean they are packed tightly
+	// together). "padding" is the amount of padding to leave between each
+	// character (normally you want '1' for bitmaps you'll use as textures with
+	// bilinear filtering).
+	//
+	// Returns 0 on failure, 1 on success.
+
+	STBTT_DEF void stbtt_PackEnd(stbtt_pack_context *spc);
+	// Cleans up the packing context and frees all memory.
+
+#define STBTT_POINT_SIZE(x) (-(x))
+
+	STBTT_DEF int stbtt_PackFontRange(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, float font_size,
+									  int first_unicode_char_in_range, int num_chars_in_range, stbtt_packedchar *chardata_for_range);
+	// Creates character bitmaps from the font_index'th font found in fontdata (use
+	// font_index=0 if you don't know what that is). It creates num_chars_in_range
+	// bitmaps for characters with unicode values starting at first_unicode_char_in_range
+	// and increasing. Data for how to render them is stored in chardata_for_range;
+	// pass these to stbtt_GetPackedQuad to get back renderable quads.
+	//
+	// font_size is the full height of the character from ascender to descender,
+	// as computed by stbtt_ScaleForPixelHeight. To use a point size as computed
+	// by stbtt_ScaleForMappingEmToPixels, wrap the point size in STBTT_POINT_SIZE()
+	// and pass that result as 'font_size':
+	//       ...,                  20 , ... // font max minus min y is 20 pixels tall
+	//       ..., STBTT_POINT_SIZE(20), ... // 'M' is 20 pixels tall
+
+	typedef struct
+	{
+		float font_size;
+		int first_unicode_codepoint_in_range;  // if non-zero, then the chars are continuous, and this is the first codepoint
+		int *array_of_unicode_codepoints;      // if non-zero, then this is an array of unicode codepoints
+		int num_chars;
+		stbtt_packedchar *chardata_for_range;      // output
+		unsigned char h_oversample, v_oversample;  // don't set these, they're used internally
+	} stbtt_pack_range;
+
+	STBTT_DEF int stbtt_PackFontRanges(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, stbtt_pack_range *ranges, int num_ranges);
+	// Creates character bitmaps from multiple ranges of characters stored in
+	// ranges. This will usually create a better-packed bitmap than multiple
+	// calls to stbtt_PackFontRange. Note that you can call this multiple
+	// times within a single PackBegin/PackEnd.
+
+	STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsigned int h_oversample, unsigned int v_oversample);
+	// Oversampling a font increases the quality by allowing higher-quality subpixel
+	// positioning, and is especially valuable at smaller text sizes.
+	//
+	// This function sets the amount of oversampling for all following calls to
+	// stbtt_PackFontRange(s) or stbtt_PackFontRangesGatherRects for a given
+	// pack context. The default (no oversampling) is achieved by h_oversample=1
+	// and v_oversample=1. The total number of pixels required is
+	// h_oversample*v_oversample larger than the default; for example, 2x2
+	// oversampling requires 4x the storage of 1x1. For best results, render
+	// oversampled textures with bilinear filtering. Look at the readme in
+	// stb/tests/oversample for information about oversampled fonts
+	//
+	// To use with PackFontRangesGather etc., you must set it before calls
+	// call to PackFontRangesGatherRects.
+
+	STBTT_DEF void stbtt_GetPackedQuad(const stbtt_packedchar *chardata, int pw, int ph,  // same data as above
+									   int char_index,                                    // character to display
+									   float *xpos, float *ypos,                          // pointers to current position in screen pixel space
+									   stbtt_aligned_quad *q,                             // output: quad to draw
+									   int align_to_integer);
+
+	STBTT_DEF int stbtt_PackFontRangesGatherRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects);
+	STBTT_DEF void stbtt_PackFontRangesPackRects(stbtt_pack_context *spc, stbrp_rect *rects, int num_rects);
+	STBTT_DEF int stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects);
+	// Calling these functions in sequence is roughly equivalent to calling
+	// stbtt_PackFontRanges(). If you more control over the packing of multiple
+	// fonts, or if you want to pack custom data into a font texture, take a look
+	// at the source to of stbtt_PackFontRanges() and create a custom version
+	// using these functions, e.g. call GatherRects multiple times,
+	// building up a single array of rects, then call PackRects once,
+	// then call RenderIntoRects repeatedly. This may result in a
+	// better packing than calling PackFontRanges multiple times
+	// (or it may not).
+
+	// this is an opaque structure that you shouldn't mess with which holds
+	// all the context needed from PackBegin to PackEnd.
+	struct stbtt_pack_context
+	{
+		void *user_allocator_context;
+		void *pack_info;
+		int width;
+		int height;
+		int stride_in_bytes;
+		int padding;
+		unsigned int h_oversample, v_oversample;
+		unsigned char *pixels;
+		void *nodes;
+	};
+
+	//////////////////////////////////////////////////////////////////////////////
+	//
+	// FONT LOADING
+	//
+	//
+
+	STBTT_DEF int stbtt_GetNumberOfFonts(const unsigned char *data);
+	// This function will determine the number of fonts in a font file.  TrueType
+	// collection (.ttc) files may contain multiple fonts, while TrueType font
+	// (.ttf) files only contain one font. The number of fonts can be used for
+	// indexing with the previous function where the index is between zero and one
+	// less than the total fonts. If an error occurs, -1 is returned.
+
+	STBTT_DEF int stbtt_GetFontOffsetForIndex(const unsigned char *data, int index);
+	// Each .ttf/.ttc file may have more than one font. Each font has a sequential
+	// index number starting from 0. Call this function to get the font offset for
+	// a given index; it returns -1 if the index is out of range. A regular .ttf
+	// file will only define one font and it always be at offset 0, so it will
+	// return '0' for index 0, and -1 for all other indices.
+
+	// The following structure is defined publically so you can declare one on
+	// the stack or as a global or etc, but you should treat it as opaque.
+	struct stbtt_fontinfo
+	{
+		void *userdata;
+		unsigned char *data;  // pointer to .ttf file
+		int fontstart;        // offset of start of font
+
+		int numGlyphs;  // number of glyphs, needed for range checking
+
+		int loca, head, glyf, hhea, hmtx, kern, gpos;  // table locations as offset from start of .ttf
+		int index_map;                                 // a cmap mapping for our chosen character encoding
+		int indexToLocFormat;                          // format needed to map from glyph index to glyph
+
+		stbtt__buf cff;          // cff font data
+		stbtt__buf charstrings;  // the charstring index
+		stbtt__buf gsubrs;       // global charstring subroutines index
+		stbtt__buf subrs;        // private charstring subroutines index
+		stbtt__buf fontdicts;    // array of font dicts
+		stbtt__buf fdselect;     // map from glyph to fontdict
+	};
+
+	STBTT_DEF int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data, int offset);
+	// Given an offset into the file that defines a font, this function builds
+	// the necessary cached info for the rest of the system. You must allocate
+	// the stbtt_fontinfo yourself, and stbtt_InitFont will fill it out. You don't
+	// need to do anything special to free it, because the contents are pure
+	// value data with no additional data structures. Returns 0 on failure.
+
+	//////////////////////////////////////////////////////////////////////////////
+	//
+	// CHARACTER TO GLYPH-INDEX CONVERSIOn
+
+	STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint);
+	// If you're going to perform multiple operations on the same character
+	// and you want a speed-up, call this function with the character you're
+	// going to process, then use glyph-based functions instead of the
+	// codepoint-based functions.
+
+	//////////////////////////////////////////////////////////////////////////////
+	//
+	// CHARACTER PROPERTIES
+	//
+
+	STBTT_DEF float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float pixels);
+	// computes a scale factor to produce a font whose "height" is 'pixels' tall.
+	// Height is measured as the distance from the highest ascender to the lowest
+	// descender; in other words, it's equivalent to calling stbtt_GetFontVMetrics
+	// and computing:
+	//       scale = pixels / (ascent - descent)
+	// so if you prefer to measure height by the ascent only, use a similar calculation.
+
+	STBTT_DEF float stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *info, float pixels);
+	// computes a scale factor to produce a font whose EM size is mapped to
+	// 'pixels' tall. This is probably what traditional APIs compute, but
+	// I'm not positive.
+
+	STBTT_DEF void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap);
+	// ascent is the coordinate above the baseline the font extends; descent
+	// is the coordinate below the baseline the font extends (i.e. it is typically negative)
+	// lineGap is the spacing between one row's descent and the next row's ascent...
+	// so you should advance the vertical position by "*ascent - *descent + *lineGap"
+	//   these are expressed in unscaled coordinates, so you must multiply by
+	//   the scale factor for a given size
+
+	STBTT_DEF int stbtt_GetFontVMetricsOS2(const stbtt_fontinfo *info, int *typoAscent, int *typoDescent, int *typoLineGap);
+	// analogous to GetFontVMetrics, but returns the "typographic" values from the OS/2
+	// table (specific to MS/Windows TTF files).
+	//
+	// Returns 1 on success (table present), 0 on failure.
+
+	STBTT_DEF void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int *x0, int *y0, int *x1, int *y1);
+	// the bounding box around all possible characters
+
+	STBTT_DEF void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing);
+	// leftSideBearing is the offset from the current horizontal position to the left edge of the character
+	// advanceWidth is the offset from the current horizontal position to the next horizontal position
+	//   these are expressed in unscaled coordinates
+
+	STBTT_DEF int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2);
+	// an additional amount to add to the 'advance' value between ch1 and ch2
+
+	STBTT_DEF int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1);
+	// Gets the bounding box of the visible part of the glyph, in unscaled coordinates
+
+	STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing);
+	STBTT_DEF int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2);
+	STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1);
+	// as above, but takes one or more glyph indices for greater efficiency
+
+	//////////////////////////////////////////////////////////////////////////////
+	//
+	// GLYPH SHAPES (you probably don't need these, but they have to go before
+	// the bitmaps for C declaration-order reasons)
+	//
+
+#ifndef STBTT_vmove  // you can predefine these to use different values (but why?)
+	enum
+	{
+		STBTT_vmove = 1,
+		STBTT_vline,
+		STBTT_vcurve,
+		STBTT_vcubic
+	};
+#endif
+
+#ifndef stbtt_vertex             // you can predefine this to use different values \
+								 // (we share this with other code at RAD)
+#define stbtt_vertex_type short  // can't use stbtt_int16 because that's not visible in the header file
+	typedef struct
+	{
+		stbtt_vertex_type x, y, cx, cy, cx1, cy1;
+		unsigned char type, padding;
+	} stbtt_vertex;
+#endif
+
+	STBTT_DEF int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index);
+	// returns non-zero if nothing is drawn for this glyph
+
+	STBTT_DEF int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, stbtt_vertex **vertices);
+	STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **vertices);
+	// returns # of vertices and fills *vertices with the pointer to them
+	//   these are expressed in "unscaled" coordinates
+	//
+	// The shape is a series of countours. Each one starts with
+	// a STBTT_moveto, then consists of a series of mixed
+	// STBTT_lineto and STBTT_curveto segments. A lineto
+	// draws a line from previous endpoint to its x,y; a curveto
+	// draws a quadratic bezier from previous endpoint to
+	// its x,y, using cx,cy as the bezier control point.
+
+	STBTT_DEF void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *vertices);
+	// frees the data allocated above
+
+	//////////////////////////////////////////////////////////////////////////////
+	//
+	// BITMAP RENDERING
+	//
+
+	STBTT_DEF void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata);
+	// frees the bitmap allocated below
+
+	STBTT_DEF unsigned char *stbtt_GetCodepointBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int codepoint, int *width, int *height, int *xoff, int *yoff);
+	// allocates a large-enough single-channel 8bpp bitmap and renders the
+	// specified character/glyph at the specified scale into it, with
+	// antialiasing. 0 is no coverage (transparent), 255 is fully covered (opaque).
+	// *width & *height are filled out with the width & height of the bitmap,
+	// which is stored left-to-right, top-to-bottom.
+	//
+	// xoff/yoff are the offset it pixel space from the glyph origin to the top-left of the bitmap
+
+	STBTT_DEF unsigned char *stbtt_GetCodepointBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint, int *width, int *height, int *xoff, int *yoff);
+	// the same as stbtt_GetCodepoitnBitmap, but you can specify a subpixel
+	// shift for the character
+
+	STBTT_DEF void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int codepoint);
+	// the same as stbtt_GetCodepointBitmap, but you pass in storage for the bitmap
+	// in the form of 'output', with row spacing of 'out_stride' bytes. the bitmap
+	// is clipped to out_w/out_h bytes. Call stbtt_GetCodepointBitmapBox to get the
+	// width and height and positioning info for it first.
+
+	STBTT_DEF void stbtt_MakeCodepointBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint);
+	// same as stbtt_MakeCodepointBitmap, but you can specify a subpixel
+	// shift for the character
+
+	STBTT_DEF void stbtt_MakeCodepointBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float *sub_x, float *sub_y, int codepoint);
+	// same as stbtt_MakeCodepointBitmapSubpixel, but prefiltering
+	// is performed (see stbtt_PackSetOversampling)
+
+	STBTT_DEF void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1);
+	// get the bbox of the bitmap centered around the glyph origin; so the
+	// bitmap width is ix1-ix0, height is iy1-iy0, and location to place
+	// the bitmap top left is (leftSideBearing*scale,iy0).
+	// (Note that the bitmap uses y-increases-down, but the shape uses
+	// y-increases-up, so CodepointBitmapBox and CodepointBox are inverted.)
+
+	STBTT_DEF void stbtt_GetCodepointBitmapBoxSubpixel(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1);
+	// same as stbtt_GetCodepointBitmapBox, but you can specify a subpixel
+	// shift for the character
+
+	// the following functions are equivalent to the above functions, but operate
+	// on glyph indices instead of Unicode codepoints (for efficiency)
+	STBTT_DEF unsigned char *stbtt_GetGlyphBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int glyph, int *width, int *height, int *xoff, int *yoff);
+	STBTT_DEF unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int glyph, int *width, int *height, int *xoff, int *yoff);
+	STBTT_DEF void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int glyph);
+	STBTT_DEF void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int glyph);
+	STBTT_DEF void stbtt_MakeGlyphBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float *sub_x, float *sub_y, int glyph);
+	STBTT_DEF void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1);
+	STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1);
+
+	// @TODO: don't expose this structure
+	typedef struct
+	{
+		int w, h, stride;
+		unsigned char *pixels;
+	} stbtt__bitmap;
+
+	// rasterize a shape with quadratic beziers into a bitmap
+	STBTT_DEF void stbtt_Rasterize(stbtt__bitmap *result,         // 1-channel bitmap to draw into
+								   float flatness_in_pixels,      // allowable error of curve in pixels
+								   stbtt_vertex *vertices,        // array of vertices defining shape
+								   int num_verts,                 // number of vertices in above array
+								   float scale_x, float scale_y,  // scale applied to input vertices
+								   float shift_x, float shift_y,  // translation applied to input vertices
+								   int x_off, int y_off,          // another translation applied to input
+								   int invert,                    // if non-zero, vertically flip shape
+								   void *userdata);               // context for to STBTT_MALLOC
+
+	//////////////////////////////////////////////////////////////////////////////
+	//
+	// Signed Distance Function (or Field) rendering
+
+	STBTT_DEF void stbtt_FreeSDF(unsigned char *bitmap, void *userdata);
+	// frees the SDF bitmap allocated below
+
+	STBTT_DEF unsigned char *stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float scale, int glyph, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff);
+	STBTT_DEF unsigned char *stbtt_GetCodepointSDF(const stbtt_fontinfo *info, float scale, int codepoint, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff);
+	// These functions compute a discretized SDF field for a single character, suitable for storing
+	// in a single-channel texture, sampling with bilinear filtering, and testing against
+	// larger than some threshhold to produce scalable fonts.
+	//        info              --  the font
+	//        scale             --  controls the size of the resulting SDF bitmap, same as it would be creating a regular bitmap
+	//        glyph/codepoint   --  the character to generate the SDF for
+	//        padding           --  extra "pixels" around the character which are filled with the distance to the character (not 0),
+	//                                 which allows effects like bit outlines
+	//        onedge_value      --  value 0-255 to test the SDF against to reconstruct the character (i.e. the isocontour of the character)
+	//        pixel_dist_scale  --  what value the SDF should increase by when moving one SDF "pixel" away from the edge (on the 0..255 scale)
+	//                                 if positive, > onedge_value is inside; if negative, < onedge_value is inside
+	//        width,height      --  output height & width of the SDF bitmap (including padding)
+	//        xoff,yoff         --  output origin of the character
+	//        return value      --  a 2D array of bytes 0..255, width*height in size
+	//
+	// pixel_dist_scale & onedge_value are a scale & bias that allows you to make
+	// optimal use of the limited 0..255 for your application, trading off precision
+	// and special effects. SDF values outside the range 0..255 are clamped to 0..255.
+	//
+	// Example:
+	//      scale = stbtt_ScaleForPixelHeight(22)
+	//      padding = 5
+	//      onedge_value = 180
+	//      pixel_dist_scale = 180/5.0 = 36.0
+	//
+	//      This will create an SDF bitmap in which the character is about 22 pixels
+	//      high but the whole bitmap is about 22+5+5=32 pixels high. To produce a filled
+	//      shape, sample the SDF at each pixel and fill the pixel if the SDF value
+	//      is greater than or equal to 180/255. (You'll actually want to antialias,
+	//      which is beyond the scope of this example.) Additionally, you can compute
+	//      offset outlines (e.g. to stroke the character border inside & outside,
+	//      or only outside). For example, to fill outside the character up to 3 SDF
+	//      pixels, you would compare against (180-36.0*3)/255 = 72/255. The above
+	//      choice of variables maps a range from 5 pixels outside the shape to
+	//      2 pixels inside the shape to 0..255; this is intended primarily for apply
+	//      outside effects only (the interior range is needed to allow proper
+	//      antialiasing of the font at *smaller* sizes)
+	//
+	// The function computes the SDF analytically at each SDF pixel, not by e.g.
+	// building a higher-res bitmap and approximating it. In theory the quality
+	// should be as high as possible for an SDF of this size & representation, but
+	// unclear if this is true in practice (perhaps building a higher-res bitmap
+	// and computing from that can allow drop-out prevention).
+	//
+	// The algorithm has not been optimized at all, so expect it to be slow
+	// if computing lots of characters or very large sizes.
+
+	//////////////////////////////////////////////////////////////////////////////
+	//
+	// Finding the right font...
+	//
+	// You should really just solve this offline, keep your own tables
+	// of what font is what, and don't try to get it out of the .ttf file.
+	// That's because getting it out of the .ttf file is really hard, because
+	// the names in the file can appear in many possible encodings, in many
+	// possible languages, and e.g. if you need a case-insensitive comparison,
+	// the details of that depend on the encoding & language in a complex way
+	// (actually underspecified in truetype, but also gigantic).
+	//
+	// But you can use the provided functions in two possible ways:
+	//     stbtt_FindMatchingFont() will use *case-sensitive* comparisons on
+	//             unicode-encoded names to try to find the font you want;
+	//             you can run this before calling stbtt_InitFont()
+	//
+	//     stbtt_GetFontNameString() lets you get any of the various strings
+	//             from the file yourself and do your own comparisons on them.
+	//             You have to have called stbtt_InitFont() first.
+
+	STBTT_DEF int stbtt_FindMatchingFont(const unsigned char *fontdata, const char *name, int flags);
+// returns the offset (not index) of the font that matches, or -1 if none
+//   if you use STBTT_MACSTYLE_DONTCARE, use a font name like "Arial Bold".
+//   if you use any other flag, use a font name like "Arial"; this checks
+//     the 'macStyle' header field; i don't know if fonts set this consistently
+#define STBTT_MACSTYLE_DONTCARE 0
+#define STBTT_MACSTYLE_BOLD 1
+#define STBTT_MACSTYLE_ITALIC 2
+#define STBTT_MACSTYLE_UNDERSCORE 4
+#define STBTT_MACSTYLE_NONE 8  // <= not same as 0, this makes us check the bitfield is 0
+
+	STBTT_DEF int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2);
+	// returns 1/0 whether the first string interpreted as utf8 is identical to
+	// the second string interpreted as big-endian utf16... useful for strings from next func
+
+	STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID);
+	// returns the string (which may be big-endian double byte, e.g. for unicode)
+	// and puts the length in bytes in *length.
+	//
+	// some of the values for the IDs are below; for more see the truetype spec:
+	//     http://developer.apple.com/textfonts/TTRefMan/RM06/Chap6name.html
+	//     http://www.microsoft.com/typography/otspec/name.htm
+
+	enum
+	{  // platformID
+		STBTT_PLATFORM_ID_UNICODE = 0,
+		STBTT_PLATFORM_ID_MAC = 1,
+		STBTT_PLATFORM_ID_ISO = 2,
+		STBTT_PLATFORM_ID_MICROSOFT = 3
+	};
+
+	enum
+	{  // encodingID for STBTT_PLATFORM_ID_UNICODE
+		STBTT_UNICODE_EID_UNICODE_1_0 = 0,
+		STBTT_UNICODE_EID_UNICODE_1_1 = 1,
+		STBTT_UNICODE_EID_ISO_10646 = 2,
+		STBTT_UNICODE_EID_UNICODE_2_0_BMP = 3,
+		STBTT_UNICODE_EID_UNICODE_2_0_FULL = 4
+	};
+
+	enum
+	{  // encodingID for STBTT_PLATFORM_ID_MICROSOFT
+		STBTT_MS_EID_SYMBOL = 0,
+		STBTT_MS_EID_UNICODE_BMP = 1,
+		STBTT_MS_EID_SHIFTJIS = 2,
+		STBTT_MS_EID_UNICODE_FULL = 10
+	};
+
+	enum
+	{  // encodingID for STBTT_PLATFORM_ID_MAC; same as Script Manager codes
+		STBTT_MAC_EID_ROMAN = 0,
+		STBTT_MAC_EID_ARABIC = 4,
+		STBTT_MAC_EID_JAPANESE = 1,
+		STBTT_MAC_EID_HEBREW = 5,
+		STBTT_MAC_EID_CHINESE_TRAD = 2,
+		STBTT_MAC_EID_GREEK = 6,
+		STBTT_MAC_EID_KOREAN = 3,
+		STBTT_MAC_EID_RUSSIAN = 7
+	};
+
+	enum
+	{  // languageID for STBTT_PLATFORM_ID_MICROSOFT; same as LCID...
+		// problematic because there are e.g. 16 english LCIDs and 16 arabic LCIDs
+		STBTT_MS_LANG_ENGLISH = 0x0409,
+		STBTT_MS_LANG_ITALIAN = 0x0410,
+		STBTT_MS_LANG_CHINESE = 0x0804,
+		STBTT_MS_LANG_JAPANESE = 0x0411,
+		STBTT_MS_LANG_DUTCH = 0x0413,
+		STBTT_MS_LANG_KOREAN = 0x0412,
+		STBTT_MS_LANG_FRENCH = 0x040c,
+		STBTT_MS_LANG_RUSSIAN = 0x0419,
+		STBTT_MS_LANG_GERMAN = 0x0407,
+		STBTT_MS_LANG_SPANISH = 0x0409,
+		STBTT_MS_LANG_HEBREW = 0x040d,
+		STBTT_MS_LANG_SWEDISH = 0x041D
+	};
+
+	enum
+	{  // languageID for STBTT_PLATFORM_ID_MAC
+		STBTT_MAC_LANG_ENGLISH = 0,
+		STBTT_MAC_LANG_JAPANESE = 11,
+		STBTT_MAC_LANG_ARABIC = 12,
+		STBTT_MAC_LANG_KOREAN = 23,
+		STBTT_MAC_LANG_DUTCH = 4,
+		STBTT_MAC_LANG_RUSSIAN = 32,
+		STBTT_MAC_LANG_FRENCH = 1,
+		STBTT_MAC_LANG_SPANISH = 6,
+		STBTT_MAC_LANG_GERMAN = 2,
+		STBTT_MAC_LANG_SWEDISH = 5,
+		STBTT_MAC_LANG_HEBREW = 10,
+		STBTT_MAC_LANG_CHINESE_SIMPLIFIED = 33,
+		STBTT_MAC_LANG_ITALIAN = 3,
+		STBTT_MAC_LANG_CHINESE_TRAD = 19
+	};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // __STB_INCLUDE_STB_TRUETYPE_H__
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+////
+////   IMPLEMENTATION
+////
+////
+
+#ifdef STB_TRUETYPE_IMPLEMENTATION
+
+#ifndef STBTT_MAX_OVERSAMPLE
+#define STBTT_MAX_OVERSAMPLE 8
+#endif
+
+#if STBTT_MAX_OVERSAMPLE > 255
+#error "STBTT_MAX_OVERSAMPLE cannot be > 255"
+#endif
+
+typedef int stbtt__test_oversample_pow2[(STBTT_MAX_OVERSAMPLE & (STBTT_MAX_OVERSAMPLE - 1)) == 0 ? 1 : -1];
+
+#ifndef STBTT_RASTERIZER_VERSION
+#define STBTT_RASTERIZER_VERSION 2
+#endif
+
+#ifdef _MSC_VER
+#define STBTT__NOTUSED(v) (void)(v)
+#else
+#define STBTT__NOTUSED(v) (void)sizeof(v)
+#endif
+
+//////////////////////////////////////////////////////////////////////////
+//
+// stbtt__buf helpers to parse data from file
+//
+
+static stbtt_uint8 stbtt__buf_get8(stbtt__buf *b)
+{
+	if (b->cursor >= b->size)
+		return 0;
+	return b->data[b->cursor++];
+}
+
+static stbtt_uint8 stbtt__buf_peek8(stbtt__buf *b)
+{
+	if (b->cursor >= b->size)
+		return 0;
+	return b->data[b->cursor];
+}
+
+static void stbtt__buf_seek(stbtt__buf *b, int o)
+{
+	STBTT_assert(!(o > b->size || o < 0));
+	b->cursor = (o > b->size || o < 0) ? b->size : o;
+}
+
+static void stbtt__buf_skip(stbtt__buf *b, int o)
+{
+	stbtt__buf_seek(b, b->cursor + o);
+}
+
+static stbtt_uint32 stbtt__buf_get(stbtt__buf *b, int n)
+{
+	stbtt_uint32 v = 0;
+	int i;
+	STBTT_assert(n >= 1 && n <= 4);
+	for (i = 0; i < n; i++)
+		v = (v << 8) | stbtt__buf_get8(b);
+	return v;
+}
+
+static stbtt__buf stbtt__new_buf(const void *p, size_t size)
+{
+	stbtt__buf r;
+	STBTT_assert(size < 0x40000000);
+	r.data = (stbtt_uint8 *)p;
+	r.size = (int)size;
+	r.cursor = 0;
+	return r;
+}
+
+#define stbtt__buf_get16(b) stbtt__buf_get((b), 2)
+#define stbtt__buf_get32(b) stbtt__buf_get((b), 4)
+
+static stbtt__buf stbtt__buf_range(const stbtt__buf *b, int o, int s)
+{
+	stbtt__buf r = stbtt__new_buf(NULL, 0);
+	if (o < 0 || s < 0 || o > b->size || s > b->size - o) return r;
+	r.data = b->data + o;
+	r.size = s;
+	return r;
+}
+
+static stbtt__buf stbtt__cff_get_index(stbtt__buf *b)
+{
+	int count, start, offsize;
+	start = b->cursor;
+	count = stbtt__buf_get16(b);
+	if (count)
+	{
+		offsize = stbtt__buf_get8(b);
+		STBTT_assert(offsize >= 1 && offsize <= 4);
+		stbtt__buf_skip(b, offsize * count);
+		stbtt__buf_skip(b, stbtt__buf_get(b, offsize) - 1);
+	}
+	return stbtt__buf_range(b, start, b->cursor - start);
+}
+
+static stbtt_uint32 stbtt__cff_int(stbtt__buf *b)
+{
+	int b0 = stbtt__buf_get8(b);
+	if (b0 >= 32 && b0 <= 246)
+		return b0 - 139;
+	else if (b0 >= 247 && b0 <= 250)
+		return (b0 - 247) * 256 + stbtt__buf_get8(b) + 108;
+	else if (b0 >= 251 && b0 <= 254)
+		return -(b0 - 251) * 256 - stbtt__buf_get8(b) - 108;
+	else if (b0 == 28)
+		return stbtt__buf_get16(b);
+	else if (b0 == 29)
+		return stbtt__buf_get32(b);
+	STBTT_assert(0);
+	return 0;
+}
+
+static void stbtt__cff_skip_operand(stbtt__buf *b)
+{
+	int v, b0 = stbtt__buf_peek8(b);
+	STBTT_assert(b0 >= 28);
+	if (b0 == 30)
+	{
+		stbtt__buf_skip(b, 1);
+		while (b->cursor < b->size)
+		{
+			v = stbtt__buf_get8(b);
+			if ((v & 0xF) == 0xF || (v >> 4) == 0xF)
+				break;
+		}
+	}
+	else
+	{
+		stbtt__cff_int(b);
+	}
+}
+
+static stbtt__buf stbtt__dict_get(stbtt__buf *b, int key)
+{
+	stbtt__buf_seek(b, 0);
+	while (b->cursor < b->size)
+	{
+		int start = b->cursor, end, op;
+		while (stbtt__buf_peek8(b) >= 28)
+			stbtt__cff_skip_operand(b);
+		end = b->cursor;
+		op = stbtt__buf_get8(b);
+		if (op == 12) op = stbtt__buf_get8(b) | 0x100;
+		if (op == key) return stbtt__buf_range(b, start, end - start);
+	}
+	return stbtt__buf_range(b, 0, 0);
+}
+
+static void stbtt__dict_get_ints(stbtt__buf *b, int key, int outcount, stbtt_uint32 *out)
+{
+	int i;
+	stbtt__buf operands = stbtt__dict_get(b, key);
+	for (i = 0; i < outcount && operands.cursor < operands.size; i++)
+		out[i] = stbtt__cff_int(&operands);
+}
+
+static int stbtt__cff_index_count(stbtt__buf *b)
+{
+	stbtt__buf_seek(b, 0);
+	return stbtt__buf_get16(b);
+}
+
+static stbtt__buf stbtt__cff_index_get(stbtt__buf b, int i)
+{
+	int count, offsize, start, end;
+	stbtt__buf_seek(&b, 0);
+	count = stbtt__buf_get16(&b);
+	offsize = stbtt__buf_get8(&b);
+	STBTT_assert(i >= 0 && i < count);
+	STBTT_assert(offsize >= 1 && offsize <= 4);
+	stbtt__buf_skip(&b, i * offsize);
+	start = stbtt__buf_get(&b, offsize);
+	end = stbtt__buf_get(&b, offsize);
+	return stbtt__buf_range(&b, 2 + (count + 1) * offsize + start, end - start);
+}
+
+//////////////////////////////////////////////////////////////////////////
+//
+// accessors to parse data from file
+//
+
+// on platforms that don't allow misaligned reads, if we want to allow
+// truetype fonts that aren't padded to alignment, define ALLOW_UNALIGNED_TRUETYPE
+
+#define ttBYTE(p) (*(stbtt_uint8 *)(p))
+#define ttCHAR(p) (*(stbtt_int8 *)(p))
+#define ttFixed(p) ttLONG(p)
+
+static stbtt_uint16 ttUSHORT(stbtt_uint8 *p)
+{
+	return p[0] * 256 + p[1];
+}
+static stbtt_int16 ttSHORT(stbtt_uint8 *p) { return p[0] * 256 + p[1]; }
+static stbtt_uint32 ttULONG(stbtt_uint8 *p) { return (p[0] << 24) + (p[1] << 16) + (p[2] << 8) + p[3]; }
+static stbtt_int32 ttLONG(stbtt_uint8 *p) { return (p[0] << 24) + (p[1] << 16) + (p[2] << 8) + p[3]; }
+
+#define stbtt_tag4(p, c0, c1, c2, c3) ((p)[0] == (c0) && (p)[1] == (c1) && (p)[2] == (c2) && (p)[3] == (c3))
+#define stbtt_tag(p, str) stbtt_tag4(p, str[0], str[1], str[2], str[3])
+
+static int stbtt__isfont(stbtt_uint8 *font)
+{
+	// check the version number
+	if (stbtt_tag4(font, '1', 0, 0, 0)) return 1;  // TrueType 1
+	if (stbtt_tag(font, "typ1")) return 1;         // TrueType with type 1 font -- we don't support this!
+	if (stbtt_tag(font, "OTTO")) return 1;         // OpenType with CFF
+	if (stbtt_tag4(font, 0, 1, 0, 0)) return 1;    // OpenType 1.0
+	if (stbtt_tag(font, "true")) return 1;         // Apple specification for TrueType fonts
+	return 0;
+}
+
+// @OPTIMIZE: binary search
+static stbtt_uint32 stbtt__find_table(stbtt_uint8 *data, stbtt_uint32 fontstart, const char *tag)
+{
+	stbtt_int32 num_tables = ttUSHORT(data + fontstart + 4);
+	stbtt_uint32 tabledir = fontstart + 12;
+	stbtt_int32 i;
+	for (i = 0; i < num_tables; ++i)
+	{
+		stbtt_uint32 loc = tabledir + 16 * i;
+		if (stbtt_tag(data + loc + 0, tag))
+			return ttULONG(data + loc + 8);
+	}
+	return 0;
+}
+
+static int stbtt_GetFontOffsetForIndex_internal(unsigned char *font_collection, int index)
+{
+	// if it's just a font, there's only one valid index
+	if (stbtt__isfont(font_collection))
+		return index == 0 ? 0 : -1;
+
+	// check if it's a TTC
+	if (stbtt_tag(font_collection, "ttcf"))
+	{
+		// version 1?
+		if (ttULONG(font_collection + 4) == 0x00010000 || ttULONG(font_collection + 4) == 0x00020000)
+		{
+			stbtt_int32 n = ttLONG(font_collection + 8);
+			if (index >= n)
+				return -1;
+			return ttULONG(font_collection + 12 + index * 4);
+		}
+	}
+	return -1;
+}
+
+static int stbtt_GetNumberOfFonts_internal(unsigned char *font_collection)
+{
+	// if it's just a font, there's only one valid font
+	if (stbtt__isfont(font_collection))
+		return 1;
+
+	// check if it's a TTC
+	if (stbtt_tag(font_collection, "ttcf"))
+	{
+		// version 1?
+		if (ttULONG(font_collection + 4) == 0x00010000 || ttULONG(font_collection + 4) == 0x00020000)
+		{
+			return ttLONG(font_collection + 8);
+		}
+	}
+	return 0;
+}
+
+static stbtt__buf stbtt__get_subrs(stbtt__buf cff, stbtt__buf fontdict)
+{
+	stbtt_uint32 subrsoff = 0, private_loc[2] = {0, 0};
+	stbtt__buf pdict;
+	stbtt__dict_get_ints(&fontdict, 18, 2, private_loc);
+	if (!private_loc[1] || !private_loc[0]) return stbtt__new_buf(NULL, 0);
+	pdict = stbtt__buf_range(&cff, private_loc[1], private_loc[0]);
+	stbtt__dict_get_ints(&pdict, 19, 1, &subrsoff);
+	if (!subrsoff) return stbtt__new_buf(NULL, 0);
+	stbtt__buf_seek(&cff, private_loc[1] + subrsoff);
+	return stbtt__cff_get_index(&cff);
+}
+
+static int stbtt_InitFont_internal(stbtt_fontinfo *info, unsigned char *data, int fontstart)
+{
+	stbtt_uint32 cmap, t;
+	stbtt_int32 i, numTables;
+
+	info->data = data;
+	info->fontstart = fontstart;
+	info->cff = stbtt__new_buf(NULL, 0);
+
+	cmap = stbtt__find_table(data, fontstart, "cmap");        // required
+	info->loca = stbtt__find_table(data, fontstart, "loca");  // required
+	info->head = stbtt__find_table(data, fontstart, "head");  // required
+	info->glyf = stbtt__find_table(data, fontstart, "glyf");  // required
+	info->hhea = stbtt__find_table(data, fontstart, "hhea");  // required
+	info->hmtx = stbtt__find_table(data, fontstart, "hmtx");  // required
+	info->kern = stbtt__find_table(data, fontstart, "kern");  // not required
+	info->gpos = stbtt__find_table(data, fontstart, "GPOS");  // not required
+
+	if (!cmap || !info->head || !info->hhea || !info->hmtx)
+		return 0;
+	if (info->glyf)
+	{
+		// required for truetype
+		if (!info->loca) return 0;
+	}
+	else
+	{
+		// initialization for CFF / Type2 fonts (OTF)
+		stbtt__buf b, topdict, topdictidx;
+		stbtt_uint32 cstype = 2, charstrings = 0, fdarrayoff = 0, fdselectoff = 0;
+		stbtt_uint32 cff;
+
+		cff = stbtt__find_table(data, fontstart, "CFF ");
+		if (!cff) return 0;
+
+		info->fontdicts = stbtt__new_buf(NULL, 0);
+		info->fdselect = stbtt__new_buf(NULL, 0);
+
+		// @TODO this should use size from table (not 512MB)
+		info->cff = stbtt__new_buf(data + cff, 512 * 1024 * 1024);
+		b = info->cff;
+
+		// read the header
+		stbtt__buf_skip(&b, 2);
+		stbtt__buf_seek(&b, stbtt__buf_get8(&b));  // hdrsize
+
+		// @TODO the name INDEX could list multiple fonts,
+		// but we just use the first one.
+		stbtt__cff_get_index(&b);  // name INDEX
+		topdictidx = stbtt__cff_get_index(&b);
+		topdict = stbtt__cff_index_get(topdictidx, 0);
+		stbtt__cff_get_index(&b);  // string INDEX
+		info->gsubrs = stbtt__cff_get_index(&b);
+
+		stbtt__dict_get_ints(&topdict, 17, 1, &charstrings);
+		stbtt__dict_get_ints(&topdict, 0x100 | 6, 1, &cstype);
+		stbtt__dict_get_ints(&topdict, 0x100 | 36, 1, &fdarrayoff);
+		stbtt__dict_get_ints(&topdict, 0x100 | 37, 1, &fdselectoff);
+		info->subrs = stbtt__get_subrs(b, topdict);
+
+		// we only support Type 2 charstrings
+		if (cstype != 2) return 0;
+		if (charstrings == 0) return 0;
+
+		if (fdarrayoff)
+		{
+			// looks like a CID font
+			if (!fdselectoff) return 0;
+			stbtt__buf_seek(&b, fdarrayoff);
+			info->fontdicts = stbtt__cff_get_index(&b);
+			info->fdselect = stbtt__buf_range(&b, fdselectoff, b.size - fdselectoff);
+		}
+
+		stbtt__buf_seek(&b, charstrings);
+		info->charstrings = stbtt__cff_get_index(&b);
+	}
+
+	t = stbtt__find_table(data, fontstart, "maxp");
+	if (t)
+		info->numGlyphs = ttUSHORT(data + t + 4);
+	else
+		info->numGlyphs = 0xffff;
+
+	// find a cmap encoding table we understand *now* to avoid searching
+	// later. (todo: could make this installable)
+	// the same regardless of glyph.
+	numTables = ttUSHORT(data + cmap + 2);
+	info->index_map = 0;
+	for (i = 0; i < numTables; ++i)
+	{
+		stbtt_uint32 encoding_record = cmap + 4 + 8 * i;
+		// find an encoding we understand:
+		switch (ttUSHORT(data + encoding_record))
+		{
+			case STBTT_PLATFORM_ID_MICROSOFT:
+				switch (ttUSHORT(data + encoding_record + 2))
+				{
+					case STBTT_MS_EID_UNICODE_BMP:
+					case STBTT_MS_EID_UNICODE_FULL:
+						// MS/Unicode
+						info->index_map = cmap + ttULONG(data + encoding_record + 4);
+						break;
+				}
+				break;
+			case STBTT_PLATFORM_ID_UNICODE:
+				// Mac/iOS has these
+				// all the encodingIDs are unicode, so we don't bother to check it
+				info->index_map = cmap + ttULONG(data + encoding_record + 4);
+				break;
+		}
+	}
+	if (info->index_map == 0)
+		return 0;
+
+	info->indexToLocFormat = ttUSHORT(data + info->head + 50);
+	return 1;
+}
+
+STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint)
+{
+	stbtt_uint8 *data = info->data;
+	stbtt_uint32 index_map = info->index_map;
+
+	stbtt_uint16 format = ttUSHORT(data + index_map + 0);
+	if (format == 0)
+	{  // apple byte encoding
+		stbtt_int32 bytes = ttUSHORT(data + index_map + 2);
+		if (unicode_codepoint < bytes - 6)
+			return ttBYTE(data + index_map + 6 + unicode_codepoint);
+		return 0;
+	}
+	else if (format == 6)
+	{
+		stbtt_uint32 first = ttUSHORT(data + index_map + 6);
+		stbtt_uint32 count = ttUSHORT(data + index_map + 8);
+		if ((stbtt_uint32)unicode_codepoint >= first && (stbtt_uint32)unicode_codepoint < first + count)
+			return ttUSHORT(data + index_map + 10 + (unicode_codepoint - first) * 2);
+		return 0;
+	}
+	else if (format == 2)
+	{
+		STBTT_assert(0);  // @TODO: high-byte mapping for japanese/chinese/korean
+		return 0;
+	}
+	else if (format == 4)
+	{  // standard mapping for windows fonts: binary search collection of ranges
+		stbtt_uint16 segcount = ttUSHORT(data + index_map + 6) >> 1;
+		stbtt_uint16 searchRange = ttUSHORT(data + index_map + 8) >> 1;
+		stbtt_uint16 entrySelector = ttUSHORT(data + index_map + 10);
+		stbtt_uint16 rangeShift = ttUSHORT(data + index_map + 12) >> 1;
+
+		// do a binary search of the segments
+		stbtt_uint32 endCount = index_map + 14;
+		stbtt_uint32 search = endCount;
+
+		if (unicode_codepoint > 0xffff)
+			return 0;
+
+		// they lie from endCount .. endCount + segCount
+		// but searchRange is the nearest power of two, so...
+		if (unicode_codepoint >= ttUSHORT(data + search + rangeShift * 2))
+			search += rangeShift * 2;
+
+		// now decrement to bias correctly to find smallest
+		search -= 2;
+		while (entrySelector)
+		{
+			stbtt_uint16 end;
+			searchRange >>= 1;
+			end = ttUSHORT(data + search + searchRange * 2);
+			if (unicode_codepoint > end)
+				search += searchRange * 2;
+			--entrySelector;
+		}
+		search += 2;
+
+		{
+			stbtt_uint16 offset, start;
+			stbtt_uint16 item = (stbtt_uint16)((search - endCount) >> 1);
+
+			STBTT_assert(unicode_codepoint <= ttUSHORT(data + endCount + 2 * item));
+			start = ttUSHORT(data + index_map + 14 + segcount * 2 + 2 + 2 * item);
+			if (unicode_codepoint < start)
+				return 0;
+
+			offset = ttUSHORT(data + index_map + 14 + segcount * 6 + 2 + 2 * item);
+			if (offset == 0)
+				return (stbtt_uint16)(unicode_codepoint + ttSHORT(data + index_map + 14 + segcount * 4 + 2 + 2 * item));
+
+			return ttUSHORT(data + offset + (unicode_codepoint - start) * 2 + index_map + 14 + segcount * 6 + 2 + 2 * item);
+		}
+	}
+	else if (format == 12 || format == 13)
+	{
+		stbtt_uint32 ngroups = ttULONG(data + index_map + 12);
+		stbtt_int32 low, high;
+		low = 0;
+		high = (stbtt_int32)ngroups;
+		// Binary search the right group.
+		while (low < high)
+		{
+			stbtt_int32 mid = low + ((high - low) >> 1);  // rounds down, so low <= mid < high
+			stbtt_uint32 start_char = ttULONG(data + index_map + 16 + mid * 12);
+			stbtt_uint32 end_char = ttULONG(data + index_map + 16 + mid * 12 + 4);
+			if ((stbtt_uint32)unicode_codepoint < start_char)
+				high = mid;
+			else if ((stbtt_uint32)unicode_codepoint > end_char)
+				low = mid + 1;
+			else
+			{
+				stbtt_uint32 start_glyph = ttULONG(data + index_map + 16 + mid * 12 + 8);
+				if (format == 12)
+					return start_glyph + unicode_codepoint - start_char;
+				else  // format == 13
+					return start_glyph;
+			}
+		}
+		return 0;  // not found
+	}
+	// @TODO
+	STBTT_assert(0);
+	return 0;
+}
+
+STBTT_DEF int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, stbtt_vertex **vertices)
+{
+	return stbtt_GetGlyphShape(info, stbtt_FindGlyphIndex(info, unicode_codepoint), vertices);
+}
+
+static void stbtt_setvertex(stbtt_vertex *v, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy)
+{
+	v->type = type;
+	v->x = (stbtt_int16)x;
+	v->y = (stbtt_int16)y;
+	v->cx = (stbtt_int16)cx;
+	v->cy = (stbtt_int16)cy;
+}
+
+static int stbtt__GetGlyfOffset(const stbtt_fontinfo *info, int glyph_index)
+{
+	int g1, g2;
+
+	STBTT_assert(!info->cff.size);
+
+	if (glyph_index >= info->numGlyphs) return -1;  // glyph index out of range
+	if (info->indexToLocFormat >= 2) return -1;     // unknown index->glyph map format
+
+	if (info->indexToLocFormat == 0)
+	{
+		g1 = info->glyf + ttUSHORT(info->data + info->loca + glyph_index * 2) * 2;
+		g2 = info->glyf + ttUSHORT(info->data + info->loca + glyph_index * 2 + 2) * 2;
+	}
+	else
+	{
+		g1 = info->glyf + ttULONG(info->data + info->loca + glyph_index * 4);
+		g2 = info->glyf + ttULONG(info->data + info->loca + glyph_index * 4 + 4);
+	}
+
+	return g1 == g2 ? -1 : g1;  // if length is 0, return -1
+}
+
+static int stbtt__GetGlyphInfoT2(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1);
+
+STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1)
+{
+	if (info->cff.size)
+	{
+		stbtt__GetGlyphInfoT2(info, glyph_index, x0, y0, x1, y1);
+	}
+	else
+	{
+		int g = stbtt__GetGlyfOffset(info, glyph_index);
+		if (g < 0) return 0;
+
+		if (x0) *x0 = ttSHORT(info->data + g + 2);
+		if (y0) *y0 = ttSHORT(info->data + g + 4);
+		if (x1) *x1 = ttSHORT(info->data + g + 6);
+		if (y1) *y1 = ttSHORT(info->data + g + 8);
+	}
+	return 1;
+}
+
+STBTT_DEF int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1)
+{
+	return stbtt_GetGlyphBox(info, stbtt_FindGlyphIndex(info, codepoint), x0, y0, x1, y1);
+}
+
+STBTT_DEF int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index)
+{
+	stbtt_int16 numberOfContours;
+	int g;
+	if (info->cff.size)
+		return stbtt__GetGlyphInfoT2(info, glyph_index, NULL, NULL, NULL, NULL) == 0;
+	g = stbtt__GetGlyfOffset(info, glyph_index);
+	if (g < 0) return 1;
+	numberOfContours = ttSHORT(info->data + g);
+	return numberOfContours == 0;
+}
+
+static int stbtt__close_shape(stbtt_vertex *vertices, int num_vertices, int was_off, int start_off,
+							  stbtt_int32 sx, stbtt_int32 sy, stbtt_int32 scx, stbtt_int32 scy, stbtt_int32 cx, stbtt_int32 cy)
+{
+	if (start_off)
+	{
+		if (was_off)
+			stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx + scx) >> 1, (cy + scy) >> 1, cx, cy);
+		stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, sx, sy, scx, scy);
+	}
+	else
+	{
+		if (was_off)
+			stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, sx, sy, cx, cy);
+		else
+			stbtt_setvertex(&vertices[num_vertices++], STBTT_vline, sx, sy, 0, 0);
+	}
+	return num_vertices;
+}
+
+static int stbtt__GetGlyphShapeTT(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices)
+{
+	stbtt_int16 numberOfContours;
+	stbtt_uint8 *endPtsOfContours;
+	stbtt_uint8 *data = info->data;
+	stbtt_vertex *vertices = 0;
+	int num_vertices = 0;
+	int g = stbtt__GetGlyfOffset(info, glyph_index);
+
+	*pvertices = NULL;
+
+	if (g < 0) return 0;
+
+	numberOfContours = ttSHORT(data + g);
+
+	if (numberOfContours > 0)
+	{
+		stbtt_uint8 flags = 0, flagcount;
+		stbtt_int32 ins, i, j = 0, m, n, next_move, was_off = 0, off, start_off = 0;
+		stbtt_int32 x, y, cx, cy, sx, sy, scx, scy;
+		stbtt_uint8 *points;
+		endPtsOfContours = (data + g + 10);
+		ins = ttUSHORT(data + g + 10 + numberOfContours * 2);
+		points = data + g + 10 + numberOfContours * 2 + 2 + ins;
+
+		n = 1 + ttUSHORT(endPtsOfContours + numberOfContours * 2 - 2);
+
+		m = n + 2 * numberOfContours;  // a loose bound on how many vertices we might need
+		vertices = (stbtt_vertex *)STBTT_malloc(m * sizeof(vertices[0]), info->userdata);
+		if (vertices == 0)
+			return 0;
+
+		next_move = 0;
+		flagcount = 0;
+
+		// in first pass, we load uninterpreted data into the allocated array
+		// above, shifted to the end of the array so we won't overwrite it when
+		// we create our final data starting from the front
+
+		off = m - n;  // starting offset for uninterpreted data, regardless of how m ends up being calculated
+
+		// first load flags
+
+		for (i = 0; i < n; ++i)
+		{
+			if (flagcount == 0)
+			{
+				flags = *points++;
+				if (flags & 8)
+					flagcount = *points++;
+			}
+			else
+				--flagcount;
+			vertices[off + i].type = flags;
+		}
+
+		// now load x coordinates
+		x = 0;
+		for (i = 0; i < n; ++i)
+		{
+			flags = vertices[off + i].type;
+			if (flags & 2)
+			{
+				stbtt_int16 dx = *points++;
+				x += (flags & 16) ? dx : -dx;  // ???
+			}
+			else
+			{
+				if (!(flags & 16))
+				{
+					x = x + (stbtt_int16)(points[0] * 256 + points[1]);
+					points += 2;
+				}
+			}
+			vertices[off + i].x = (stbtt_int16)x;
+		}
+
+		// now load y coordinates
+		y = 0;
+		for (i = 0; i < n; ++i)
+		{
+			flags = vertices[off + i].type;
+			if (flags & 4)
+			{
+				stbtt_int16 dy = *points++;
+				y += (flags & 32) ? dy : -dy;  // ???
+			}
+			else
+			{
+				if (!(flags & 32))
+				{
+					y = y + (stbtt_int16)(points[0] * 256 + points[1]);
+					points += 2;
+				}
+			}
+			vertices[off + i].y = (stbtt_int16)y;
+		}
+
+		// now convert them to our format
+		num_vertices = 0;
+		sx = sy = cx = cy = scx = scy = 0;
+		for (i = 0; i < n; ++i)
+		{
+			flags = vertices[off + i].type;
+			x = (stbtt_int16)vertices[off + i].x;
+			y = (stbtt_int16)vertices[off + i].y;
+
+			if (next_move == i)
+			{
+				if (i != 0)
+					num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx, sy, scx, scy, cx, cy);
+
+				// now start the new one
+				start_off = !(flags & 1);
+				if (start_off)
+				{
+					// if we start off with an off-curve point, then when we need to find a point on the curve
+					// where we can start, and we need to save some state for when we wraparound.
+					scx = x;
+					scy = y;
+					if (!(vertices[off + i + 1].type & 1))
+					{
+						// next point is also a curve point, so interpolate an on-point curve
+						sx = (x + (stbtt_int32)vertices[off + i + 1].x) >> 1;
+						sy = (y + (stbtt_int32)vertices[off + i + 1].y) >> 1;
+					}
+					else
+					{
+						// otherwise just use the next point as our start point
+						sx = (stbtt_int32)vertices[off + i + 1].x;
+						sy = (stbtt_int32)vertices[off + i + 1].y;
+						++i;  // we're using point i+1 as the starting point, so skip it
+					}
+				}
+				else
+				{
+					sx = x;
+					sy = y;
+				}
+				stbtt_setvertex(&vertices[num_vertices++], STBTT_vmove, sx, sy, 0, 0);
+				was_off = 0;
+				next_move = 1 + ttUSHORT(endPtsOfContours + j * 2);
+				++j;
+			}
+			else
+			{
+				if (!(flags & 1))
+				{                 // if it's a curve
+					if (was_off)  // two off-curve control points in a row means interpolate an on-curve midpoint
+						stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx + x) >> 1, (cy + y) >> 1, cx, cy);
+					cx = x;
+					cy = y;
+					was_off = 1;
+				}
+				else
+				{
+					if (was_off)
+						stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, x, y, cx, cy);
+					else
+						stbtt_setvertex(&vertices[num_vertices++], STBTT_vline, x, y, 0, 0);
+					was_off = 0;
+				}
+			}
+		}
+		num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx, sy, scx, scy, cx, cy);
+	}
+	else if (numberOfContours == -1)
+	{
+		// Compound shapes.
+		int more = 1;
+		stbtt_uint8 *comp = data + g + 10;
+		num_vertices = 0;
+		vertices = 0;
+		while (more)
+		{
+			stbtt_uint16 flags, gidx;
+			int comp_num_verts = 0, i;
+			stbtt_vertex *comp_verts = 0, *tmp = 0;
+			float mtx[6] = {1, 0, 0, 1, 0, 0}, m, n;
+
+			flags = ttSHORT(comp);
+			comp += 2;
+			gidx = ttSHORT(comp);
+			comp += 2;
+
+			if (flags & 2)
+			{  // XY values
+				if (flags & 1)
+				{  // shorts
+					mtx[4] = ttSHORT(comp);
+					comp += 2;
+					mtx[5] = ttSHORT(comp);
+					comp += 2;
+				}
+				else
+				{
+					mtx[4] = ttCHAR(comp);
+					comp += 1;
+					mtx[5] = ttCHAR(comp);
+					comp += 1;
+				}
+			}
+			else
+			{
+				// @TODO handle matching point
+				STBTT_assert(0);
+			}
+			if (flags & (1 << 3))
+			{  // WE_HAVE_A_SCALE
+				mtx[0] = mtx[3] = ttSHORT(comp) / 16384.0f;
+				comp += 2;
+				mtx[1] = mtx[2] = 0;
+			}
+			else if (flags & (1 << 6))
+			{  // WE_HAVE_AN_X_AND_YSCALE
+				mtx[0] = ttSHORT(comp) / 16384.0f;
+				comp += 2;
+				mtx[1] = mtx[2] = 0;
+				mtx[3] = ttSHORT(comp) / 16384.0f;
+				comp += 2;
+			}
+			else if (flags & (1 << 7))
+			{  // WE_HAVE_A_TWO_BY_TWO
+				mtx[0] = ttSHORT(comp) / 16384.0f;
+				comp += 2;
+				mtx[1] = ttSHORT(comp) / 16384.0f;
+				comp += 2;
+				mtx[2] = ttSHORT(comp) / 16384.0f;
+				comp += 2;
+				mtx[3] = ttSHORT(comp) / 16384.0f;
+				comp += 2;
+			}
+
+			// Find transformation scales.
+			m = (float)STBTT_sqrt(mtx[0] * mtx[0] + mtx[1] * mtx[1]);
+			n = (float)STBTT_sqrt(mtx[2] * mtx[2] + mtx[3] * mtx[3]);
+
+			// Get indexed glyph.
+			comp_num_verts = stbtt_GetGlyphShape(info, gidx, &comp_verts);
+			if (comp_num_verts > 0)
+			{
+				// Transform vertices.
+				for (i = 0; i < comp_num_verts; ++i)
+				{
+					stbtt_vertex *v = &comp_verts[i];
+					stbtt_vertex_type x, y;
+					x = v->x;
+					y = v->y;
+					v->x = (stbtt_vertex_type)(m * (mtx[0] * x + mtx[2] * y + mtx[4]));
+					v->y = (stbtt_vertex_type)(n * (mtx[1] * x + mtx[3] * y + mtx[5]));
+					x = v->cx;
+					y = v->cy;
+					v->cx = (stbtt_vertex_type)(m * (mtx[0] * x + mtx[2] * y + mtx[4]));
+					v->cy = (stbtt_vertex_type)(n * (mtx[1] * x + mtx[3] * y + mtx[5]));
+				}
+				// Append vertices.
+				tmp = (stbtt_vertex *)STBTT_malloc((num_vertices + comp_num_verts) * sizeof(stbtt_vertex), info->userdata);
+				if (!tmp)
+				{
+					if (vertices) STBTT_free(vertices, info->userdata);
+					if (comp_verts) STBTT_free(comp_verts, info->userdata);
+					return 0;
+				}
+				if (num_vertices > 0) STBTT_memcpy(tmp, vertices, num_vertices * sizeof(stbtt_vertex));
+				STBTT_memcpy(tmp + num_vertices, comp_verts, comp_num_verts * sizeof(stbtt_vertex));
+				if (vertices) STBTT_free(vertices, info->userdata);
+				vertices = tmp;
+				STBTT_free(comp_verts, info->userdata);
+				num_vertices += comp_num_verts;
+			}
+			// More components ?
+			more = flags & (1 << 5);
+		}
+	}
+	else if (numberOfContours < 0)
+	{
+		// @TODO other compound variations?
+		STBTT_assert(0);
+	}
+	else
+	{
+		// numberOfCounters == 0, do nothing
+	}
+
+	*pvertices = vertices;
+	return num_vertices;
+}
+
+typedef struct
+{
+	int bounds;
+	int started;
+	float first_x, first_y;
+	float x, y;
+	stbtt_int32 min_x, max_x, min_y, max_y;
+
+	stbtt_vertex *pvertices;
+	int num_vertices;
+} stbtt__csctx;
+
+#define STBTT__CSCTX_INIT(bounds)                  \
+	{                                              \
+		bounds, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, 0 \
+	}
+
+static void stbtt__track_vertex(stbtt__csctx *c, stbtt_int32 x, stbtt_int32 y)
+{
+	if (x > c->max_x || !c->started) c->max_x = x;
+	if (y > c->max_y || !c->started) c->max_y = y;
+	if (x < c->min_x || !c->started) c->min_x = x;
+	if (y < c->min_y || !c->started) c->min_y = y;
+	c->started = 1;
+}
+
+static void stbtt__csctx_v(stbtt__csctx *c, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy, stbtt_int32 cx1, stbtt_int32 cy1)
+{
+	if (c->bounds)
+	{
+		stbtt__track_vertex(c, x, y);
+		if (type == STBTT_vcubic)
+		{
+			stbtt__track_vertex(c, cx, cy);
+			stbtt__track_vertex(c, cx1, cy1);
+		}
+	}
+	else
+	{
+		stbtt_setvertex(&c->pvertices[c->num_vertices], type, x, y, cx, cy);
+		c->pvertices[c->num_vertices].cx1 = (stbtt_int16)cx1;
+		c->pvertices[c->num_vertices].cy1 = (stbtt_int16)cy1;
+	}
+	c->num_vertices++;
+}
+
+static void stbtt__csctx_close_shape(stbtt__csctx *ctx)
+{
+	if (ctx->first_x != ctx->x || ctx->first_y != ctx->y)
+		stbtt__csctx_v(ctx, STBTT_vline, (int)ctx->first_x, (int)ctx->first_y, 0, 0, 0, 0);
+}
+
+static void stbtt__csctx_rmove_to(stbtt__csctx *ctx, float dx, float dy)
+{
+	stbtt__csctx_close_shape(ctx);
+	ctx->first_x = ctx->x = ctx->x + dx;
+	ctx->first_y = ctx->y = ctx->y + dy;
+	stbtt__csctx_v(ctx, STBTT_vmove, (int)ctx->x, (int)ctx->y, 0, 0, 0, 0);
+}
+
+static void stbtt__csctx_rline_to(stbtt__csctx *ctx, float dx, float dy)
+{
+	ctx->x += dx;
+	ctx->y += dy;
+	stbtt__csctx_v(ctx, STBTT_vline, (int)ctx->x, (int)ctx->y, 0, 0, 0, 0);
+}
+
+static void stbtt__csctx_rccurve_to(stbtt__csctx *ctx, float dx1, float dy1, float dx2, float dy2, float dx3, float dy3)
+{
+	float cx1 = ctx->x + dx1;
+	float cy1 = ctx->y + dy1;
+	float cx2 = cx1 + dx2;
+	float cy2 = cy1 + dy2;
+	ctx->x = cx2 + dx3;
+	ctx->y = cy2 + dy3;
+	stbtt__csctx_v(ctx, STBTT_vcubic, (int)ctx->x, (int)ctx->y, (int)cx1, (int)cy1, (int)cx2, (int)cy2);
+}
+
+static stbtt__buf stbtt__get_subr(stbtt__buf idx, int n)
+{
+	int count = stbtt__cff_index_count(&idx);
+	int bias = 107;
+	if (count >= 33900)
+		bias = 32768;
+	else if (count >= 1240)
+		bias = 1131;
+	n += bias;
+	if (n < 0 || n >= count)
+		return stbtt__new_buf(NULL, 0);
+	return stbtt__cff_index_get(idx, n);
+}
+
+static stbtt__buf stbtt__cid_get_glyph_subrs(const stbtt_fontinfo *info, int glyph_index)
+{
+	stbtt__buf fdselect = info->fdselect;
+	int nranges, start, end, v, fmt, fdselector = -1, i;
+
+	stbtt__buf_seek(&fdselect, 0);
+	fmt = stbtt__buf_get8(&fdselect);
+	if (fmt == 0)
+	{
+		// untested
+		stbtt__buf_skip(&fdselect, glyph_index);
+		fdselector = stbtt__buf_get8(&fdselect);
+	}
+	else if (fmt == 3)
+	{
+		nranges = stbtt__buf_get16(&fdselect);
+		start = stbtt__buf_get16(&fdselect);
+		for (i = 0; i < nranges; i++)
+		{
+			v = stbtt__buf_get8(&fdselect);
+			end = stbtt__buf_get16(&fdselect);
+			if (glyph_index >= start && glyph_index < end)
+			{
+				fdselector = v;
+				break;
+			}
+			start = end;
+		}
+	}
+	if (fdselector == -1) stbtt__new_buf(NULL, 0);
+	return stbtt__get_subrs(info->cff, stbtt__cff_index_get(info->fontdicts, fdselector));
+}
+
+static int stbtt__run_charstring(const stbtt_fontinfo *info, int glyph_index, stbtt__csctx *c)
+{
+	int in_header = 1, maskbits = 0, subr_stack_height = 0, sp = 0, v, i, b0;
+	int has_subrs = 0, clear_stack;
+	float s[48];
+	stbtt__buf subr_stack[10], subrs = info->subrs, b;
+	float f;
+
+#define STBTT__CSERR(s) (0)
+
+	// this currently ignores the initial width value, which isn't needed if we have hmtx
+	b = stbtt__cff_index_get(info->charstrings, glyph_index);
+	while (b.cursor < b.size)
+	{
+		i = 0;
+		clear_stack = 1;
+		b0 = stbtt__buf_get8(&b);
+		switch (b0)
+		{
+			// @TODO implement hinting
+			case 0x13:  // hintmask
+			case 0x14:  // cntrmask
+				if (in_header)
+					maskbits += (sp / 2);  // implicit "vstem"
+				in_header = 0;
+				stbtt__buf_skip(&b, (maskbits + 7) / 8);
+				break;
+
+			case 0x01:  // hstem
+			case 0x03:  // vstem
+			case 0x12:  // hstemhm
+			case 0x17:  // vstemhm
+				maskbits += (sp / 2);
+				break;
+
+			case 0x15:  // rmoveto
+				in_header = 0;
+				if (sp < 2) return STBTT__CSERR("rmoveto stack");
+				stbtt__csctx_rmove_to(c, s[sp - 2], s[sp - 1]);
+				break;
+			case 0x04:  // vmoveto
+				in_header = 0;
+				if (sp < 1) return STBTT__CSERR("vmoveto stack");
+				stbtt__csctx_rmove_to(c, 0, s[sp - 1]);
+				break;
+			case 0x16:  // hmoveto
+				in_header = 0;
+				if (sp < 1) return STBTT__CSERR("hmoveto stack");
+				stbtt__csctx_rmove_to(c, s[sp - 1], 0);
+				break;
+
+			case 0x05:  // rlineto
+				if (sp < 2) return STBTT__CSERR("rlineto stack");
+				for (; i + 1 < sp; i += 2)
+					stbtt__csctx_rline_to(c, s[i], s[i + 1]);
+				break;
+
+				// hlineto/vlineto and vhcurveto/hvcurveto alternate horizontal and vertical
+				// starting from a different place.
+
+			case 0x07:  // vlineto
+				if (sp < 1) return STBTT__CSERR("vlineto stack");
+				goto vlineto;
+			case 0x06:  // hlineto
+				if (sp < 1) return STBTT__CSERR("hlineto stack");
+				for (;;)
+				{
+					if (i >= sp) break;
+					stbtt__csctx_rline_to(c, s[i], 0);
+					i++;
+				vlineto:
+					if (i >= sp) break;
+					stbtt__csctx_rline_to(c, 0, s[i]);
+					i++;
+				}
+				break;
+
+			case 0x1F:  // hvcurveto
+				if (sp < 4) return STBTT__CSERR("hvcurveto stack");
+				goto hvcurveto;
+			case 0x1E:  // vhcurveto
+				if (sp < 4) return STBTT__CSERR("vhcurveto stack");
+				for (;;)
+				{
+					if (i + 3 >= sp) break;
+					stbtt__csctx_rccurve_to(c, 0, s[i], s[i + 1], s[i + 2], s[i + 3], (sp - i == 5) ? s[i + 4] : 0.0f);
+					i += 4;
+				hvcurveto:
+					if (i + 3 >= sp) break;
+					stbtt__csctx_rccurve_to(c, s[i], 0, s[i + 1], s[i + 2], (sp - i == 5) ? s[i + 4] : 0.0f, s[i + 3]);
+					i += 4;
+				}
+				break;
+
+			case 0x08:  // rrcurveto
+				if (sp < 6) return STBTT__CSERR("rcurveline stack");
+				for (; i + 5 < sp; i += 6)
+					stbtt__csctx_rccurve_to(c, s[i], s[i + 1], s[i + 2], s[i + 3], s[i + 4], s[i + 5]);
+				break;
+
+			case 0x18:  // rcurveline
+				if (sp < 8) return STBTT__CSERR("rcurveline stack");
+				for (; i + 5 < sp - 2; i += 6)
+					stbtt__csctx_rccurve_to(c, s[i], s[i + 1], s[i + 2], s[i + 3], s[i + 4], s[i + 5]);
+				if (i + 1 >= sp) return STBTT__CSERR("rcurveline stack");
+				stbtt__csctx_rline_to(c, s[i], s[i + 1]);
+				break;
+
+			case 0x19:  // rlinecurve
+				if (sp < 8) return STBTT__CSERR("rlinecurve stack");
+				for (; i + 1 < sp - 6; i += 2)
+					stbtt__csctx_rline_to(c, s[i], s[i + 1]);
+				if (i + 5 >= sp) return STBTT__CSERR("rlinecurve stack");
+				stbtt__csctx_rccurve_to(c, s[i], s[i + 1], s[i + 2], s[i + 3], s[i + 4], s[i + 5]);
+				break;
+
+			case 0x1A:  // vvcurveto
+			case 0x1B:  // hhcurveto
+				if (sp < 4) return STBTT__CSERR("(vv|hh)curveto stack");
+				f = 0.0;
+				if (sp & 1)
+				{
+					f = s[i];
+					i++;
+				}
+				for (; i + 3 < sp; i += 4)
+				{
+					if (b0 == 0x1B)
+						stbtt__csctx_rccurve_to(c, s[i], f, s[i + 1], s[i + 2], s[i + 3], 0.0);
+					else
+						stbtt__csctx_rccurve_to(c, f, s[i], s[i + 1], s[i + 2], 0.0, s[i + 3]);
+					f = 0.0;
+				}
+				break;
+
+			case 0x0A:  // callsubr
+				if (!has_subrs)
+				{
+					if (info->fdselect.size)
+						subrs = stbtt__cid_get_glyph_subrs(info, glyph_index);
+					has_subrs = 1;
+				}
+				// fallthrough
+			case 0x1D:  // callgsubr
+				if (sp < 1) return STBTT__CSERR("call(g|)subr stack");
+				v = (int)s[--sp];
+				if (subr_stack_height >= 10) return STBTT__CSERR("recursion limit");
+				subr_stack[subr_stack_height++] = b;
+				b = stbtt__get_subr(b0 == 0x0A ? subrs : info->gsubrs, v);
+				if (b.size == 0) return STBTT__CSERR("subr not found");
+				b.cursor = 0;
+				clear_stack = 0;
+				break;
+
+			case 0x0B:  // return
+				if (subr_stack_height <= 0) return STBTT__CSERR("return outside subr");
+				b = subr_stack[--subr_stack_height];
+				clear_stack = 0;
+				break;
+
+			case 0x0E:  // endchar
+				stbtt__csctx_close_shape(c);
+				return 1;
+
+			case 0x0C:
+			{  // two-byte escape
+				float dx1, dx2, dx3, dx4, dx5, dx6, dy1, dy2, dy3, dy4, dy5, dy6;
+				float dx, dy;
+				int b1 = stbtt__buf_get8(&b);
+				switch (b1)
+				{
+					// @TODO These "flex" implementations ignore the flex-depth and resolution,
+					// and always draw beziers.
+					case 0x22:  // hflex
+						if (sp < 7) return STBTT__CSERR("hflex stack");
+						dx1 = s[0];
+						dx2 = s[1];
+						dy2 = s[2];
+						dx3 = s[3];
+						dx4 = s[4];
+						dx5 = s[5];
+						dx6 = s[6];
+						stbtt__csctx_rccurve_to(c, dx1, 0, dx2, dy2, dx3, 0);
+						stbtt__csctx_rccurve_to(c, dx4, 0, dx5, -dy2, dx6, 0);
+						break;
+
+					case 0x23:  // flex
+						if (sp < 13) return STBTT__CSERR("flex stack");
+						dx1 = s[0];
+						dy1 = s[1];
+						dx2 = s[2];
+						dy2 = s[3];
+						dx3 = s[4];
+						dy3 = s[5];
+						dx4 = s[6];
+						dy4 = s[7];
+						dx5 = s[8];
+						dy5 = s[9];
+						dx6 = s[10];
+						dy6 = s[11];
+						//fd is s[12]
+						stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, dy3);
+						stbtt__csctx_rccurve_to(c, dx4, dy4, dx5, dy5, dx6, dy6);
+						break;
+
+					case 0x24:  // hflex1
+						if (sp < 9) return STBTT__CSERR("hflex1 stack");
+						dx1 = s[0];
+						dy1 = s[1];
+						dx2 = s[2];
+						dy2 = s[3];
+						dx3 = s[4];
+						dx4 = s[5];
+						dx5 = s[6];
+						dy5 = s[7];
+						dx6 = s[8];
+						stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, 0);
+						stbtt__csctx_rccurve_to(c, dx4, 0, dx5, dy5, dx6, -(dy1 + dy2 + dy5));
+						break;
+
+					case 0x25:  // flex1
+						if (sp < 11) return STBTT__CSERR("flex1 stack");
+						dx1 = s[0];
+						dy1 = s[1];
+						dx2 = s[2];
+						dy2 = s[3];
+						dx3 = s[4];
+						dy3 = s[5];
+						dx4 = s[6];
+						dy4 = s[7];
+						dx5 = s[8];
+						dy5 = s[9];
+						dx6 = dy6 = s[10];
+						dx = dx1 + dx2 + dx3 + dx4 + dx5;
+						dy = dy1 + dy2 + dy3 + dy4 + dy5;
+						if (STBTT_fabs(dx) > STBTT_fabs(dy))
+							dy6 = -dy;
+						else
+							dx6 = -dx;
+						stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, dy3);
+						stbtt__csctx_rccurve_to(c, dx4, dy4, dx5, dy5, dx6, dy6);
+						break;
+
+					default:
+						return STBTT__CSERR("unimplemented");
+				}
+			}
+			break;
+
+			default:
+				if (b0 != 255 && b0 != 28 && (b0 < 32 || b0 > 254))
+					return STBTT__CSERR("reserved operator");
+
+				// push immediate
+				if (b0 == 255)
+				{
+					f = (float)(stbtt_int32)stbtt__buf_get32(&b) / 0x10000;
+				}
+				else
+				{
+					stbtt__buf_skip(&b, -1);
+					f = (float)(stbtt_int16)stbtt__cff_int(&b);
+				}
+				if (sp >= 48) return STBTT__CSERR("push stack overflow");
+				s[sp++] = f;
+				clear_stack = 0;
+				break;
+		}
+		if (clear_stack) sp = 0;
+	}
+	return STBTT__CSERR("no endchar");
+
+#undef STBTT__CSERR
+}
+
+static int stbtt__GetGlyphShapeT2(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices)
+{
+	// runs the charstring twice, once to count and once to output (to avoid realloc)
+	stbtt__csctx count_ctx = STBTT__CSCTX_INIT(1);
+	stbtt__csctx output_ctx = STBTT__CSCTX_INIT(0);
+	if (stbtt__run_charstring(info, glyph_index, &count_ctx))
+	{
+		*pvertices = (stbtt_vertex *)STBTT_malloc(count_ctx.num_vertices * sizeof(stbtt_vertex), info->userdata);
+		output_ctx.pvertices = *pvertices;
+		if (stbtt__run_charstring(info, glyph_index, &output_ctx))
+		{
+			STBTT_assert(output_ctx.num_vertices == count_ctx.num_vertices);
+			return output_ctx.num_vertices;
+		}
+	}
+	*pvertices = NULL;
+	return 0;
+}
+
+static int stbtt__GetGlyphInfoT2(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1)
+{
+	stbtt__csctx c = STBTT__CSCTX_INIT(1);
+	int r = stbtt__run_charstring(info, glyph_index, &c);
+	if (x0) *x0 = r ? c.min_x : 0;
+	if (y0) *y0 = r ? c.min_y : 0;
+	if (x1) *x1 = r ? c.max_x : 0;
+	if (y1) *y1 = r ? c.max_y : 0;
+	return r ? c.num_vertices : 0;
+}
+
+STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices)
+{
+	if (!info->cff.size)
+		return stbtt__GetGlyphShapeTT(info, glyph_index, pvertices);
+	else
+		return stbtt__GetGlyphShapeT2(info, glyph_index, pvertices);
+}
+
+STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing)
+{
+	stbtt_uint16 numOfLongHorMetrics = ttUSHORT(info->data + info->hhea + 34);
+	if (glyph_index < numOfLongHorMetrics)
+	{
+		if (advanceWidth) *advanceWidth = ttSHORT(info->data + info->hmtx + 4 * glyph_index);
+		if (leftSideBearing) *leftSideBearing = ttSHORT(info->data + info->hmtx + 4 * glyph_index + 2);
+	}
+	else
+	{
+		if (advanceWidth) *advanceWidth = ttSHORT(info->data + info->hmtx + 4 * (numOfLongHorMetrics - 1));
+		if (leftSideBearing) *leftSideBearing = ttSHORT(info->data + info->hmtx + 4 * numOfLongHorMetrics + 2 * (glyph_index - numOfLongHorMetrics));
+	}
+}
+
+static int stbtt__GetGlyphKernInfoAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2)
+{
+	stbtt_uint8 *data = info->data + info->kern;
+	stbtt_uint32 needle, straw;
+	int l, r, m;
+
+	// we only look at the first table. it must be 'horizontal' and format 0.
+	if (!info->kern)
+		return 0;
+	if (ttUSHORT(data + 2) < 1)  // number of tables, need at least 1
+		return 0;
+	if (ttUSHORT(data + 8) != 1)  // horizontal flag must be set in format
+		return 0;
+
+	l = 0;
+	r = ttUSHORT(data + 10) - 1;
+	needle = glyph1 << 16 | glyph2;
+	while (l <= r)
+	{
+		m = (l + r) >> 1;
+		straw = ttULONG(data + 18 + (m * 6));  // note: unaligned read
+		if (needle < straw)
+			r = m - 1;
+		else if (needle > straw)
+			l = m + 1;
+		else
+			return ttSHORT(data + 22 + (m * 6));
+	}
+	return 0;
+}
+
+static stbtt_int32 stbtt__GetCoverageIndex(stbtt_uint8 *coverageTable, int glyph)
+{
+	stbtt_uint16 coverageFormat = ttUSHORT(coverageTable);
+	switch (coverageFormat)
+	{
+		case 1:
+		{
+			stbtt_uint16 glyphCount = ttUSHORT(coverageTable + 2);
+
+			// Binary search.
+			stbtt_int32 l = 0, r = glyphCount - 1, m;
+			int straw, needle = glyph;
+			while (l <= r)
+			{
+				stbtt_uint8 *glyphArray = coverageTable + 4;
+				stbtt_uint16 glyphID;
+				m = (l + r) >> 1;
+				glyphID = ttUSHORT(glyphArray + 2 * m);
+				straw = glyphID;
+				if (needle < straw)
+					r = m - 1;
+				else if (needle > straw)
+					l = m + 1;
+				else
+				{
+					return m;
+				}
+			}
+		}
+		break;
+
+		case 2:
+		{
+			stbtt_uint16 rangeCount = ttUSHORT(coverageTable + 2);
+			stbtt_uint8 *rangeArray = coverageTable + 4;
+
+			// Binary search.
+			stbtt_int32 l = 0, r = rangeCount - 1, m;
+			int strawStart, strawEnd, needle = glyph;
+			while (l <= r)
+			{
+				stbtt_uint8 *rangeRecord;
+				m = (l + r) >> 1;
+				rangeRecord = rangeArray + 6 * m;
+				strawStart = ttUSHORT(rangeRecord);
+				strawEnd = ttUSHORT(rangeRecord + 2);
+				if (needle < strawStart)
+					r = m - 1;
+				else if (needle > strawEnd)
+					l = m + 1;
+				else
+				{
+					stbtt_uint16 startCoverageIndex = ttUSHORT(rangeRecord + 4);
+					return startCoverageIndex + glyph - strawStart;
+				}
+			}
+		}
+		break;
+
+		default:
+		{
+			// There are no other cases.
+			STBTT_assert(0);
+		}
+		break;
+	}
+
+	return -1;
+}
+
+static stbtt_int32 stbtt__GetGlyphClass(stbtt_uint8 *classDefTable, int glyph)
+{
+	stbtt_uint16 classDefFormat = ttUSHORT(classDefTable);
+	switch (classDefFormat)
+	{
+		case 1:
+		{
+			stbtt_uint16 startGlyphID = ttUSHORT(classDefTable + 2);
+			stbtt_uint16 glyphCount = ttUSHORT(classDefTable + 4);
+			stbtt_uint8 *classDef1ValueArray = classDefTable + 6;
+
+			if (glyph >= startGlyphID && glyph < startGlyphID + glyphCount)
+				return (stbtt_int32)ttUSHORT(classDef1ValueArray + 2 * (glyph - startGlyphID));
+
+			classDefTable = classDef1ValueArray + 2 * glyphCount;
+		}
+		break;
+
+		case 2:
+		{
+			stbtt_uint16 classRangeCount = ttUSHORT(classDefTable + 2);
+			stbtt_uint8 *classRangeRecords = classDefTable + 4;
+
+			// Binary search.
+			stbtt_int32 l = 0, r = classRangeCount - 1, m;
+			int strawStart, strawEnd, needle = glyph;
+			while (l <= r)
+			{
+				stbtt_uint8 *classRangeRecord;
+				m = (l + r) >> 1;
+				classRangeRecord = classRangeRecords + 6 * m;
+				strawStart = ttUSHORT(classRangeRecord);
+				strawEnd = ttUSHORT(classRangeRecord + 2);
+				if (needle < strawStart)
+					r = m - 1;
+				else if (needle > strawEnd)
+					l = m + 1;
+				else
+					return (stbtt_int32)ttUSHORT(classRangeRecord + 4);
+			}
+
+			classDefTable = classRangeRecords + 6 * classRangeCount;
+		}
+		break;
+
+		default:
+		{
+			// There are no other cases.
+			STBTT_assert(0);
+		}
+		break;
+	}
+
+	return -1;
+}
+
+// Define to STBTT_assert(x) if you want to break on unimplemented formats.
+#define STBTT_GPOS_TODO_assert(x)
+
+static stbtt_int32 stbtt__GetGlyphGPOSInfoAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2)
+{
+	stbtt_uint16 lookupListOffset;
+	stbtt_uint8 *lookupList;
+	stbtt_uint16 lookupCount;
+	stbtt_uint8 *data;
+	stbtt_int32 i;
+
+	if (!info->gpos) return 0;
+
+	data = info->data + info->gpos;
+
+	if (ttUSHORT(data + 0) != 1) return 0;  // Major version 1
+	if (ttUSHORT(data + 2) != 0) return 0;  // Minor version 0
+
+	lookupListOffset = ttUSHORT(data + 8);
+	lookupList = data + lookupListOffset;
+	lookupCount = ttUSHORT(lookupList);
+
+	for (i = 0; i < lookupCount; ++i)
+	{
+		stbtt_uint16 lookupOffset = ttUSHORT(lookupList + 2 + 2 * i);
+		stbtt_uint8 *lookupTable = lookupList + lookupOffset;
+
+		stbtt_uint16 lookupType = ttUSHORT(lookupTable);
+		stbtt_uint16 subTableCount = ttUSHORT(lookupTable + 4);
+		stbtt_uint8 *subTableOffsets = lookupTable + 6;
+		switch (lookupType)
+		{
+			case 2:
+			{  // Pair Adjustment Positioning Subtable
+				stbtt_int32 sti;
+				for (sti = 0; sti < subTableCount; sti++)
+				{
+					stbtt_uint16 subtableOffset = ttUSHORT(subTableOffsets + 2 * sti);
+					stbtt_uint8 *table = lookupTable + subtableOffset;
+					stbtt_uint16 posFormat = ttUSHORT(table);
+					stbtt_uint16 coverageOffset = ttUSHORT(table + 2);
+					stbtt_int32 coverageIndex = stbtt__GetCoverageIndex(table + coverageOffset, glyph1);
+					if (coverageIndex == -1) continue;
+
+					switch (posFormat)
+					{
+						case 1:
+						{
+							stbtt_int32 l, r, m;
+							int straw, needle;
+							stbtt_uint16 valueFormat1 = ttUSHORT(table + 4);
+							stbtt_uint16 valueFormat2 = ttUSHORT(table + 6);
+							stbtt_int32 valueRecordPairSizeInBytes = 2;
+							stbtt_uint16 pairSetCount = ttUSHORT(table + 8);
+							stbtt_uint16 pairPosOffset = ttUSHORT(table + 10 + 2 * coverageIndex);
+							stbtt_uint8 *pairValueTable = table + pairPosOffset;
+							stbtt_uint16 pairValueCount = ttUSHORT(pairValueTable);
+							stbtt_uint8 *pairValueArray = pairValueTable + 2;
+							// TODO: Support more formats.
+							STBTT_GPOS_TODO_assert(valueFormat1 == 4);
+							if (valueFormat1 != 4) return 0;
+							STBTT_GPOS_TODO_assert(valueFormat2 == 0);
+							if (valueFormat2 != 0) return 0;
+
+							STBTT_assert(coverageIndex < pairSetCount);
+							STBTT__NOTUSED(pairSetCount);
+
+							needle = glyph2;
+							r = pairValueCount - 1;
+							l = 0;
+
+							// Binary search.
+							while (l <= r)
+							{
+								stbtt_uint16 secondGlyph;
+								stbtt_uint8 *pairValue;
+								m = (l + r) >> 1;
+								pairValue = pairValueArray + (2 + valueRecordPairSizeInBytes) * m;
+								secondGlyph = ttUSHORT(pairValue);
+								straw = secondGlyph;
+								if (needle < straw)
+									r = m - 1;
+								else if (needle > straw)
+									l = m + 1;
+								else
+								{
+									stbtt_int16 xAdvance = ttSHORT(pairValue + 2);
+									return xAdvance;
+								}
+							}
+						}
+						break;
+
+						case 2:
+						{
+							stbtt_uint16 valueFormat1 = ttUSHORT(table + 4);
+							stbtt_uint16 valueFormat2 = ttUSHORT(table + 6);
+
+							stbtt_uint16 classDef1Offset = ttUSHORT(table + 8);
+							stbtt_uint16 classDef2Offset = ttUSHORT(table + 10);
+							int glyph1class = stbtt__GetGlyphClass(table + classDef1Offset, glyph1);
+							int glyph2class = stbtt__GetGlyphClass(table + classDef2Offset, glyph2);
+
+							stbtt_uint16 class1Count = ttUSHORT(table + 12);
+							stbtt_uint16 class2Count = ttUSHORT(table + 14);
+							STBTT_assert(glyph1class < class1Count);
+							STBTT_assert(glyph2class < class2Count);
+
+							// TODO: Support more formats.
+							STBTT_GPOS_TODO_assert(valueFormat1 == 4);
+							if (valueFormat1 != 4) return 0;
+							STBTT_GPOS_TODO_assert(valueFormat2 == 0);
+							if (valueFormat2 != 0) return 0;
+
+							if (glyph1class >= 0 && glyph1class < class1Count && glyph2class >= 0 && glyph2class < class2Count)
+							{
+								stbtt_uint8 *class1Records = table + 16;
+								stbtt_uint8 *class2Records = class1Records + 2 * (glyph1class * class2Count);
+								stbtt_int16 xAdvance = ttSHORT(class2Records + 2 * glyph2class);
+								return xAdvance;
+							}
+						}
+						break;
+
+						default:
+						{
+							// There are no other cases.
+							STBTT_assert(0);
+							break;
+						};
+					}
+				}
+				break;
+			};
+
+			default:
+				// TODO: Implement other stuff.
+				break;
+		}
+	}
+
+	return 0;
+}
+
+STBTT_DEF int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int g1, int g2)
+{
+	int xAdvance = 0;
+
+	if (info->gpos)
+		xAdvance += stbtt__GetGlyphGPOSInfoAdvance(info, g1, g2);
+
+	if (info->kern)
+		xAdvance += stbtt__GetGlyphKernInfoAdvance(info, g1, g2);
+
+	return xAdvance;
+}
+
+STBTT_DEF int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2)
+{
+	if (!info->kern && !info->gpos)  // if no kerning table, don't waste time looking up both codepoint->glyphs
+		return 0;
+	return stbtt_GetGlyphKernAdvance(info, stbtt_FindGlyphIndex(info, ch1), stbtt_FindGlyphIndex(info, ch2));
+}
+
+STBTT_DEF void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing)
+{
+	stbtt_GetGlyphHMetrics(info, stbtt_FindGlyphIndex(info, codepoint), advanceWidth, leftSideBearing);
+}
+
+STBTT_DEF void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap)
+{
+	if (ascent) *ascent = ttSHORT(info->data + info->hhea + 4);
+	if (descent) *descent = ttSHORT(info->data + info->hhea + 6);
+	if (lineGap) *lineGap = ttSHORT(info->data + info->hhea + 8);
+}
+
+STBTT_DEF int stbtt_GetFontVMetricsOS2(const stbtt_fontinfo *info, int *typoAscent, int *typoDescent, int *typoLineGap)
+{
+	int tab = stbtt__find_table(info->data, info->fontstart, "OS/2");
+	if (!tab)
+		return 0;
+	if (typoAscent) *typoAscent = ttSHORT(info->data + tab + 68);
+	if (typoDescent) *typoDescent = ttSHORT(info->data + tab + 70);
+	if (typoLineGap) *typoLineGap = ttSHORT(info->data + tab + 72);
+	return 1;
+}
+
+STBTT_DEF void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int *x0, int *y0, int *x1, int *y1)
+{
+	*x0 = ttSHORT(info->data + info->head + 36);
+	*y0 = ttSHORT(info->data + info->head + 38);
+	*x1 = ttSHORT(info->data + info->head + 40);
+	*y1 = ttSHORT(info->data + info->head + 42);
+}
+
+STBTT_DEF float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float height)
+{
+	int fheight = ttSHORT(info->data + info->hhea + 4) - ttSHORT(info->data + info->hhea + 6);
+	return (float)height / fheight;
+}
+
+STBTT_DEF float stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *info, float pixels)
+{
+	int unitsPerEm = ttUSHORT(info->data + info->head + 18);
+	return pixels / unitsPerEm;
+}
+
+STBTT_DEF void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *v)
+{
+	STBTT_free(v, info->userdata);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// antialiasing software rasterizer
+//
+
+STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1)
+{
+	int x0 = 0, y0 = 0, x1, y1;  // =0 suppresses compiler warning
+	if (!stbtt_GetGlyphBox(font, glyph, &x0, &y0, &x1, &y1))
+	{
+		// e.g. space character
+		if (ix0) *ix0 = 0;
+		if (iy0) *iy0 = 0;
+		if (ix1) *ix1 = 0;
+		if (iy1) *iy1 = 0;
+	}
+	else
+	{
+		// move to integral bboxes (treating pixels as little squares, what pixels get touched)?
+		if (ix0) *ix0 = STBTT_ifloor(x0 * scale_x + shift_x);
+		if (iy0) *iy0 = STBTT_ifloor(-y1 * scale_y + shift_y);
+		if (ix1) *ix1 = STBTT_iceil(x1 * scale_x + shift_x);
+		if (iy1) *iy1 = STBTT_iceil(-y0 * scale_y + shift_y);
+	}
+}
+
+STBTT_DEF void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1)
+{
+	stbtt_GetGlyphBitmapBoxSubpixel(font, glyph, scale_x, scale_y, 0.0f, 0.0f, ix0, iy0, ix1, iy1);
+}
+
+STBTT_DEF void stbtt_GetCodepointBitmapBoxSubpixel(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1)
+{
+	stbtt_GetGlyphBitmapBoxSubpixel(font, stbtt_FindGlyphIndex(font, codepoint), scale_x, scale_y, shift_x, shift_y, ix0, iy0, ix1, iy1);
+}
+
+STBTT_DEF void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1)
+{
+	stbtt_GetCodepointBitmapBoxSubpixel(font, codepoint, scale_x, scale_y, 0.0f, 0.0f, ix0, iy0, ix1, iy1);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  Rasterizer
+
+typedef struct stbtt__hheap_chunk
+{
+	struct stbtt__hheap_chunk *next;
+} stbtt__hheap_chunk;
+
+typedef struct stbtt__hheap
+{
+	struct stbtt__hheap_chunk *head;
+	void *first_free;
+	int num_remaining_in_head_chunk;
+} stbtt__hheap;
+
+static void *stbtt__hheap_alloc(stbtt__hheap *hh, size_t size, void *userdata)
+{
+	if (hh->first_free)
+	{
+		void *p = hh->first_free;
+		hh->first_free = *(void **)p;
+		return p;
+	}
+	else
+	{
+		if (hh->num_remaining_in_head_chunk == 0)
+		{
+			int count = (size < 32 ? 2000 : size < 128 ? 800 : 100);
+			stbtt__hheap_chunk *c = (stbtt__hheap_chunk *)STBTT_malloc(sizeof(stbtt__hheap_chunk) + size * count, userdata);
+			if (c == NULL)
+				return NULL;
+			c->next = hh->head;
+			hh->head = c;
+			hh->num_remaining_in_head_chunk = count;
+		}
+		--hh->num_remaining_in_head_chunk;
+		return (char *)(hh->head) + sizeof(stbtt__hheap_chunk) + size * hh->num_remaining_in_head_chunk;
+	}
+}
+
+static void stbtt__hheap_free(stbtt__hheap *hh, void *p)
+{
+	*(void **)p = hh->first_free;
+	hh->first_free = p;
+}
+
+static void stbtt__hheap_cleanup(stbtt__hheap *hh, void *userdata)
+{
+	stbtt__hheap_chunk *c = hh->head;
+	while (c)
+	{
+		stbtt__hheap_chunk *n = c->next;
+		STBTT_free(c, userdata);
+		c = n;
+	}
+}
+
+typedef struct stbtt__edge
+{
+	float x0, y0, x1, y1;
+	int invert;
+} stbtt__edge;
+
+typedef struct stbtt__active_edge
+{
+	struct stbtt__active_edge *next;
+#if STBTT_RASTERIZER_VERSION == 1
+	int x, dx;
+	float ey;
+	int direction;
+#elif STBTT_RASTERIZER_VERSION == 2
+	float fx, fdx, fdy;
+	float direction;
+	float sy;
+	float ey;
+#else
+#error "Unrecognized value of STBTT_RASTERIZER_VERSION"
+#endif
+} stbtt__active_edge;
+
+#if STBTT_RASTERIZER_VERSION == 1
+#define STBTT_FIXSHIFT 10
+#define STBTT_FIX (1 << STBTT_FIXSHIFT)
+#define STBTT_FIXMASK (STBTT_FIX - 1)
+
+static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, int off_x, float start_point, void *userdata)
+{
+	stbtt__active_edge *z = (stbtt__active_edge *)stbtt__hheap_alloc(hh, sizeof(*z), userdata);
+	float dxdy = (e->x1 - e->x0) / (e->y1 - e->y0);
+	STBTT_assert(z != NULL);
+	if (!z) return z;
+
+	// round dx down to avoid overshooting
+	if (dxdy < 0)
+		z->dx = -STBTT_ifloor(STBTT_FIX * -dxdy);
+	else
+		z->dx = STBTT_ifloor(STBTT_FIX * dxdy);
+
+	z->x = STBTT_ifloor(STBTT_FIX * e->x0 + z->dx * (start_point - e->y0));  // use z->dx so when we offset later it's by the same amount
+	z->x -= off_x * STBTT_FIX;
+
+	z->ey = e->y1;
+	z->next = 0;
+	z->direction = e->invert ? 1 : -1;
+	return z;
+}
+#elif STBTT_RASTERIZER_VERSION == 2
+static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, int off_x, float start_point, void *userdata)
+{
+	stbtt__active_edge *z = (stbtt__active_edge *)stbtt__hheap_alloc(hh, sizeof(*z), userdata);
+	float dxdy = (e->x1 - e->x0) / (e->y1 - e->y0);
+	STBTT_assert(z != NULL);
+	//STBTT_assert(e->y0 <= start_point);
+	if (!z) return z;
+	z->fdx = dxdy;
+	z->fdy = dxdy != 0.0f ? (1.0f / dxdy) : 0.0f;
+	z->fx = e->x0 + dxdy * (start_point - e->y0);
+	z->fx -= off_x;
+	z->direction = e->invert ? 1.0f : -1.0f;
+	z->sy = e->y0;
+	z->ey = e->y1;
+	z->next = 0;
+	return z;
+}
+#else
+#error "Unrecognized value of STBTT_RASTERIZER_VERSION"
+#endif
+
+#if STBTT_RASTERIZER_VERSION == 1
+// note: this routine clips fills that extend off the edges... ideally this
+// wouldn't happen, but it could happen if the truetype glyph bounding boxes
+// are wrong, or if the user supplies a too-small bitmap
+static void stbtt__fill_active_edges(unsigned char *scanline, int len, stbtt__active_edge *e, int max_weight)
+{
+	// non-zero winding fill
+	int x0 = 0, w = 0;
+
+	while (e)
+	{
+		if (w == 0)
+		{
+			// if we're currently at zero, we need to record the edge start point
+			x0 = e->x;
+			w += e->direction;
+		}
+		else
+		{
+			int x1 = e->x;
+			w += e->direction;
+			// if we went to zero, we need to draw
+			if (w == 0)
+			{
+				int i = x0 >> STBTT_FIXSHIFT;
+				int j = x1 >> STBTT_FIXSHIFT;
+
+				if (i < len && j >= 0)
+				{
+					if (i == j)
+					{
+						// x0,x1 are the same pixel, so compute combined coverage
+						scanline[i] = scanline[i] + (stbtt_uint8)((x1 - x0) * max_weight >> STBTT_FIXSHIFT);
+					}
+					else
+					{
+						if (i >= 0)  // add antialiasing for x0
+							scanline[i] = scanline[i] + (stbtt_uint8)(((STBTT_FIX - (x0 & STBTT_FIXMASK)) * max_weight) >> STBTT_FIXSHIFT);
+						else
+							i = -1;  // clip
+
+						if (j < len)  // add antialiasing for x1
+							scanline[j] = scanline[j] + (stbtt_uint8)(((x1 & STBTT_FIXMASK) * max_weight) >> STBTT_FIXSHIFT);
+						else
+							j = len;  // clip
+
+						for (++i; i < j; ++i)  // fill pixels between x0 and x1
+							scanline[i] = scanline[i] + (stbtt_uint8)max_weight;
+					}
+				}
+			}
+		}
+
+		e = e->next;
+	}
+}
+
+static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, int n, int vsubsample, int off_x, int off_y, void *userdata)
+{
+	stbtt__hheap hh = {0, 0, 0};
+	stbtt__active_edge *active = NULL;
+	int y, j = 0;
+	int max_weight = (255 / vsubsample);  // weight per vertical scanline
+	int s;                                // vertical subsample index
+	unsigned char scanline_data[512], *scanline;
+
+	if (result->w > 512)
+		scanline = (unsigned char *)STBTT_malloc(result->w, userdata);
+	else
+		scanline = scanline_data;
+
+	y = off_y * vsubsample;
+	e[n].y0 = (off_y + result->h) * (float)vsubsample + 1;
+
+	while (j < result->h)
+	{
+		STBTT_memset(scanline, 0, result->w);
+		for (s = 0; s < vsubsample; ++s)
+		{
+			// find center of pixel for this scanline
+			float scan_y = y + 0.5f;
+			stbtt__active_edge **step = &active;
+
+			// update all active edges;
+			// remove all active edges that terminate before the center of this scanline
+			while (*step)
+			{
+				stbtt__active_edge *z = *step;
+				if (z->ey <= scan_y)
+				{
+					*step = z->next;  // delete from list
+					STBTT_assert(z->direction);
+					z->direction = 0;
+					stbtt__hheap_free(&hh, z);
+				}
+				else
+				{
+					z->x += z->dx;            // advance to position for current scanline
+					step = &((*step)->next);  // advance through list
+				}
+			}
+
+			// resort the list if needed
+			for (;;)
+			{
+				int changed = 0;
+				step = &active;
+				while (*step && (*step)->next)
+				{
+					if ((*step)->x > (*step)->next->x)
+					{
+						stbtt__active_edge *t = *step;
+						stbtt__active_edge *q = t->next;
+
+						t->next = q->next;
+						q->next = t;
+						*step = q;
+						changed = 1;
+					}
+					step = &(*step)->next;
+				}
+				if (!changed) break;
+			}
+
+			// insert all edges that start before the center of this scanline -- omit ones that also end on this scanline
+			while (e->y0 <= scan_y)
+			{
+				if (e->y1 > scan_y)
+				{
+					stbtt__active_edge *z = stbtt__new_active(&hh, e, off_x, scan_y, userdata);
+					if (z != NULL)
+					{
+						// find insertion point
+						if (active == NULL)
+							active = z;
+						else if (z->x < active->x)
+						{
+							// insert at front
+							z->next = active;
+							active = z;
+						}
+						else
+						{
+							// find thing to insert AFTER
+							stbtt__active_edge *p = active;
+							while (p->next && p->next->x < z->x)
+								p = p->next;
+							// at this point, p->next->x is NOT < z->x
+							z->next = p->next;
+							p->next = z;
+						}
+					}
+				}
+				++e;
+			}
+
+			// now process all active edges in XOR fashion
+			if (active)
+				stbtt__fill_active_edges(scanline, result->w, active, max_weight);
+
+			++y;
+		}
+		STBTT_memcpy(result->pixels + j * result->stride, scanline, result->w);
+		++j;
+	}
+
+	stbtt__hheap_cleanup(&hh, userdata);
+
+	if (scanline != scanline_data)
+		STBTT_free(scanline, userdata);
+}
+
+#elif STBTT_RASTERIZER_VERSION == 2
+
+// the edge passed in here does not cross the vertical line at x or the vertical line at x+1
+// (i.e. it has already been clipped to those)
+static void stbtt__handle_clipped_edge(float *scanline, int x, stbtt__active_edge *e, float x0, float y0, float x1, float y1)
+{
+	if (y0 == y1) return;
+	STBTT_assert(y0 < y1);
+	STBTT_assert(e->sy <= e->ey);
+	if (y0 > e->ey) return;
+	if (y1 < e->sy) return;
+	if (y0 < e->sy)
+	{
+		x0 += (x1 - x0) * (e->sy - y0) / (y1 - y0);
+		y0 = e->sy;
+	}
+	if (y1 > e->ey)
+	{
+		x1 += (x1 - x0) * (e->ey - y1) / (y1 - y0);
+		y1 = e->ey;
+	}
+
+	if (x0 == x)
+		STBTT_assert(x1 <= x + 1);
+	else if (x0 == x + 1)
+		STBTT_assert(x1 >= x);
+	else if (x0 <= x)
+		STBTT_assert(x1 <= x);
+	else if (x0 >= x + 1)
+		STBTT_assert(x1 >= x + 1);
+	else
+		STBTT_assert(x1 >= x && x1 <= x + 1);
+
+	if (x0 <= x && x1 <= x)
+		scanline[x] += e->direction * (y1 - y0);
+	else if (x0 >= x + 1 && x1 >= x + 1)
+		;
+	else
+	{
+		STBTT_assert(x0 >= x && x0 <= x + 1 && x1 >= x && x1 <= x + 1);
+		scanline[x] += e->direction * (y1 - y0) * (1 - ((x0 - x) + (x1 - x)) / 2);  // coverage = 1 - average x position
+	}
+}
+
+static void stbtt__fill_active_edges_new(float *scanline, float *scanline_fill, int len, stbtt__active_edge *e, float y_top)
+{
+	float y_bottom = y_top + 1;
+
+	while (e)
+	{
+		// brute force every pixel
+
+		// compute intersection points with top & bottom
+		STBTT_assert(e->ey >= y_top);
+
+		if (e->fdx == 0)
+		{
+			float x0 = e->fx;
+			if (x0 < len)
+			{
+				if (x0 >= 0)
+				{
+					stbtt__handle_clipped_edge(scanline, (int)x0, e, x0, y_top, x0, y_bottom);
+					stbtt__handle_clipped_edge(scanline_fill - 1, (int)x0 + 1, e, x0, y_top, x0, y_bottom);
+				}
+				else
+				{
+					stbtt__handle_clipped_edge(scanline_fill - 1, 0, e, x0, y_top, x0, y_bottom);
+				}
+			}
+		}
+		else
+		{
+			float x0 = e->fx;
+			float dx = e->fdx;
+			float xb = x0 + dx;
+			float x_top, x_bottom;
+			float sy0, sy1;
+			float dy = e->fdy;
+			STBTT_assert(e->sy <= y_bottom && e->ey >= y_top);
+
+			// compute endpoints of line segment clipped to this scanline (if the
+			// line segment starts on this scanline. x0 is the intersection of the
+			// line with y_top, but that may be off the line segment.
+			if (e->sy > y_top)
+			{
+				x_top = x0 + dx * (e->sy - y_top);
+				sy0 = e->sy;
+			}
+			else
+			{
+				x_top = x0;
+				sy0 = y_top;
+			}
+			if (e->ey < y_bottom)
+			{
+				x_bottom = x0 + dx * (e->ey - y_top);
+				sy1 = e->ey;
+			}
+			else
+			{
+				x_bottom = xb;
+				sy1 = y_bottom;
+			}
+
+			if (x_top >= 0 && x_bottom >= 0 && x_top < len && x_bottom < len)
+			{
+				// from here on, we don't have to range check x values
+
+				if ((int)x_top == (int)x_bottom)
+				{
+					float height;
+					// simple case, only spans one pixel
+					int x = (int)x_top;
+					height = sy1 - sy0;
+					STBTT_assert(x >= 0 && x < len);
+					scanline[x] += e->direction * (1 - ((x_top - x) + (x_bottom - x)) / 2) * height;
+					scanline_fill[x] += e->direction * height;  // everything right of this pixel is filled
+				}
+				else
+				{
+					int x, x1, x2;
+					float y_crossing, step, sign, area;
+					// covers 2+ pixels
+					if (x_top > x_bottom)
+					{
+						// flip scanline vertically; signed area is the same
+						float t;
+						sy0 = y_bottom - (sy0 - y_top);
+						sy1 = y_bottom - (sy1 - y_top);
+						t = sy0, sy0 = sy1, sy1 = t;
+						t = x_bottom, x_bottom = x_top, x_top = t;
+						dx = -dx;
+						dy = -dy;
+						t = x0, x0 = xb, xb = t;
+					}
+
+					x1 = (int)x_top;
+					x2 = (int)x_bottom;
+					// compute intersection with y axis at x1+1
+					y_crossing = (x1 + 1 - x0) * dy + y_top;
+
+					sign = e->direction;
+					// area of the rectangle covered from y0..y_crossing
+					area = sign * (y_crossing - sy0);
+					// area of the triangle (x_top,y0), (x+1,y0), (x+1,y_crossing)
+					scanline[x1] += area * (1 - ((x_top - x1) + (x1 + 1 - x1)) / 2);
+
+					step = sign * dy;
+					for (x = x1 + 1; x < x2; ++x)
+					{
+						scanline[x] += area + step / 2;
+						area += step;
+					}
+					y_crossing += dy * (x2 - (x1 + 1));
+
+					STBTT_assert(STBTT_fabs(area) <= 1.01f);
+
+					scanline[x2] += area + sign * (1 - ((x2 - x2) + (x_bottom - x2)) / 2) * (sy1 - y_crossing);
+
+					scanline_fill[x2] += sign * (sy1 - sy0);
+				}
+			}
+			else
+			{
+				// if edge goes outside of box we're drawing, we require
+				// clipping logic. since this does not match the intended use
+				// of this library, we use a different, very slow brute
+				// force implementation
+				int x;
+				for (x = 0; x < len; ++x)
+				{
+					// cases:
+					//
+					// there can be up to two intersections with the pixel. any intersection
+					// with left or right edges can be handled by splitting into two (or three)
+					// regions. intersections with top & bottom do not necessitate case-wise logic.
+					//
+					// the old way of doing this found the intersections with the left & right edges,
+					// then used some simple logic to produce up to three segments in sorted order
+					// from top-to-bottom. however, this had a problem: if an x edge was epsilon
+					// across the x border, then the corresponding y position might not be distinct
+					// from the other y segment, and it might ignored as an empty segment. to avoid
+					// that, we need to explicitly produce segments based on x positions.
+
+					// rename variables to clearly-defined pairs
+					float y0 = y_top;
+					float x1 = (float)(x);
+					float x2 = (float)(x + 1);
+					float x3 = xb;
+					float y3 = y_bottom;
+
+					// x = e->x + e->dx * (y-y_top)
+					// (y-y_top) = (x - e->x) / e->dx
+					// y = (x - e->x) / e->dx + y_top
+					float y1 = (x - x0) / dx + y_top;
+					float y2 = (x + 1 - x0) / dx + y_top;
+
+					if (x0 < x1 && x3 > x2)
+					{  // three segments descending down-right
+						stbtt__handle_clipped_edge(scanline, x, e, x0, y0, x1, y1);
+						stbtt__handle_clipped_edge(scanline, x, e, x1, y1, x2, y2);
+						stbtt__handle_clipped_edge(scanline, x, e, x2, y2, x3, y3);
+					}
+					else if (x3 < x1 && x0 > x2)
+					{  // three segments descending down-left
+						stbtt__handle_clipped_edge(scanline, x, e, x0, y0, x2, y2);
+						stbtt__handle_clipped_edge(scanline, x, e, x2, y2, x1, y1);
+						stbtt__handle_clipped_edge(scanline, x, e, x1, y1, x3, y3);
+					}
+					else if (x0 < x1 && x3 > x1)
+					{  // two segments across x, down-right
+						stbtt__handle_clipped_edge(scanline, x, e, x0, y0, x1, y1);
+						stbtt__handle_clipped_edge(scanline, x, e, x1, y1, x3, y3);
+					}
+					else if (x3 < x1 && x0 > x1)
+					{  // two segments across x, down-left
+						stbtt__handle_clipped_edge(scanline, x, e, x0, y0, x1, y1);
+						stbtt__handle_clipped_edge(scanline, x, e, x1, y1, x3, y3);
+					}
+					else if (x0 < x2 && x3 > x2)
+					{  // two segments across x+1, down-right
+						stbtt__handle_clipped_edge(scanline, x, e, x0, y0, x2, y2);
+						stbtt__handle_clipped_edge(scanline, x, e, x2, y2, x3, y3);
+					}
+					else if (x3 < x2 && x0 > x2)
+					{  // two segments across x+1, down-left
+						stbtt__handle_clipped_edge(scanline, x, e, x0, y0, x2, y2);
+						stbtt__handle_clipped_edge(scanline, x, e, x2, y2, x3, y3);
+					}
+					else
+					{  // one segment
+						stbtt__handle_clipped_edge(scanline, x, e, x0, y0, x3, y3);
+					}
+				}
+			}
+		}
+		e = e->next;
+	}
+}
+
+// directly AA rasterize edges w/o supersampling
+static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, int n, int vsubsample, int off_x, int off_y, void *userdata)
+{
+	stbtt__hheap hh = {0, 0, 0};
+	stbtt__active_edge *active = NULL;
+	int y, j = 0, i;
+	float scanline_data[129], *scanline, *scanline2;
+
+	STBTT__NOTUSED(vsubsample);
+
+	if (result->w > 64)
+		scanline = (float *)STBTT_malloc((result->w * 2 + 1) * sizeof(float), userdata);
+	else
+		scanline = scanline_data;
+
+	scanline2 = scanline + result->w;
+
+	y = off_y;
+	e[n].y0 = (float)(off_y + result->h) + 1;
+
+	while (j < result->h)
+	{
+		// find center of pixel for this scanline
+		float scan_y_top = y + 0.0f;
+		float scan_y_bottom = y + 1.0f;
+		stbtt__active_edge **step = &active;
+
+		STBTT_memset(scanline, 0, result->w * sizeof(scanline[0]));
+		STBTT_memset(scanline2, 0, (result->w + 1) * sizeof(scanline[0]));
+
+		// update all active edges;
+		// remove all active edges that terminate before the top of this scanline
+		while (*step)
+		{
+			stbtt__active_edge *z = *step;
+			if (z->ey <= scan_y_top)
+			{
+				*step = z->next;  // delete from list
+				STBTT_assert(z->direction);
+				z->direction = 0;
+				stbtt__hheap_free(&hh, z);
+			}
+			else
+			{
+				step = &((*step)->next);  // advance through list
+			}
+		}
+
+		// insert all edges that start before the bottom of this scanline
+		while (e->y0 <= scan_y_bottom)
+		{
+			if (e->y0 != e->y1)
+			{
+				stbtt__active_edge *z = stbtt__new_active(&hh, e, off_x, scan_y_top, userdata);
+				if (z != NULL)
+				{
+					STBTT_assert(z->ey >= scan_y_top);
+					// insert at front
+					z->next = active;
+					active = z;
+				}
+			}
+			++e;
+		}
+
+		// now process all active edges
+		if (active)
+			stbtt__fill_active_edges_new(scanline, scanline2 + 1, result->w, active, scan_y_top);
+
+		{
+			float sum = 0;
+			for (i = 0; i < result->w; ++i)
+			{
+				float k;
+				int m;
+				sum += scanline2[i];
+				k = scanline[i] + sum;
+				k = (float)STBTT_fabs(k) * 255 + 0.5f;
+				m = (int)k;
+				if (m > 255) m = 255;
+				result->pixels[j * result->stride + i] = (unsigned char)m;
+			}
+		}
+		// advance all the edges
+		step = &active;
+		while (*step)
+		{
+			stbtt__active_edge *z = *step;
+			z->fx += z->fdx;          // advance to position for current scanline
+			step = &((*step)->next);  // advance through list
+		}
+
+		++y;
+		++j;
+	}
+
+	stbtt__hheap_cleanup(&hh, userdata);
+
+	if (scanline != scanline_data)
+		STBTT_free(scanline, userdata);
+}
+#else
+#error "Unrecognized value of STBTT_RASTERIZER_VERSION"
+#endif
+
+#define STBTT__COMPARE(a, b) ((a)->y0 < (b)->y0)
+
+static void stbtt__sort_edges_ins_sort(stbtt__edge *p, int n)
+{
+	int i, j;
+	for (i = 1; i < n; ++i)
+	{
+		stbtt__edge t = p[i], *a = &t;
+		j = i;
+		while (j > 0)
+		{
+			stbtt__edge *b = &p[j - 1];
+			int c = STBTT__COMPARE(a, b);
+			if (!c) break;
+			p[j] = p[j - 1];
+			--j;
+		}
+		if (i != j)
+			p[j] = t;
+	}
+}
+
+static void stbtt__sort_edges_quicksort(stbtt__edge *p, int n)
+{
+	/* threshhold for transitioning to insertion sort */
+	while (n > 12)
+	{
+		stbtt__edge t;
+		int c01, c12, c, m, i, j;
+
+		/* compute median of three */
+		m = n >> 1;
+		c01 = STBTT__COMPARE(&p[0], &p[m]);
+		c12 = STBTT__COMPARE(&p[m], &p[n - 1]);
+		/* if 0 >= mid >= end, or 0 < mid < end, then use mid */
+		if (c01 != c12)
+		{
+			/* otherwise, we'll need to swap something else to middle */
+			int z;
+			c = STBTT__COMPARE(&p[0], &p[n - 1]);
+			/* 0>mid && mid<n:  0>n => n; 0<n => 0 */
+			/* 0<mid && mid>n:  0>n => 0; 0<n => n */
+			z = (c == c12) ? 0 : n - 1;
+			t = p[z];
+			p[z] = p[m];
+			p[m] = t;
+		}
+		/* now p[m] is the median-of-three */
+		/* swap it to the beginning so it won't move around */
+		t = p[0];
+		p[0] = p[m];
+		p[m] = t;
+
+		/* partition loop */
+		i = 1;
+		j = n - 1;
+		for (;;)
+		{
+			/* handling of equality is crucial here */
+			/* for sentinels & efficiency with duplicates */
+			for (;; ++i)
+			{
+				if (!STBTT__COMPARE(&p[i], &p[0])) break;
+			}
+			for (;; --j)
+			{
+				if (!STBTT__COMPARE(&p[0], &p[j])) break;
+			}
+			/* make sure we haven't crossed */
+			if (i >= j) break;
+			t = p[i];
+			p[i] = p[j];
+			p[j] = t;
+
+			++i;
+			--j;
+		}
+		/* recurse on smaller side, iterate on larger */
+		if (j < (n - i))
+		{
+			stbtt__sort_edges_quicksort(p, j);
+			p = p + i;
+			n = n - i;
+		}
+		else
+		{
+			stbtt__sort_edges_quicksort(p + i, n - i);
+			n = j;
+		}
+	}
+}
+
+static void stbtt__sort_edges(stbtt__edge *p, int n)
+{
+	stbtt__sort_edges_quicksort(p, n);
+	stbtt__sort_edges_ins_sort(p, n);
+}
+
+typedef struct
+{
+	float x, y;
+} stbtt__point;
+
+static void stbtt__rasterize(stbtt__bitmap *result, stbtt__point *pts, int *wcount, int windings, float scale_x, float scale_y, float shift_x, float shift_y, int off_x, int off_y, int invert, void *userdata)
+{
+	float y_scale_inv = invert ? -scale_y : scale_y;
+	stbtt__edge *e;
+	int n, i, j, k, m;
+#if STBTT_RASTERIZER_VERSION == 1
+	int vsubsample = result->h < 8 ? 15 : 5;
+#elif STBTT_RASTERIZER_VERSION == 2
+	int vsubsample = 1;
+#else
+#error "Unrecognized value of STBTT_RASTERIZER_VERSION"
+#endif
+	// vsubsample should divide 255 evenly; otherwise we won't reach full opacity
+
+	// now we have to blow out the windings into explicit edge lists
+	n = 0;
+	for (i = 0; i < windings; ++i)
+		n += wcount[i];
+
+	e = (stbtt__edge *)STBTT_malloc(sizeof(*e) * (n + 1), userdata);  // add an extra one as a sentinel
+	if (e == 0) return;
+	n = 0;
+
+	m = 0;
+	for (i = 0; i < windings; ++i)
+	{
+		stbtt__point *p = pts + m;
+		m += wcount[i];
+		j = wcount[i] - 1;
+		for (k = 0; k < wcount[i]; j = k++)
+		{
+			int a = k, b = j;
+			// skip the edge if horizontal
+			if (p[j].y == p[k].y)
+				continue;
+			// add edge from j to k to the list
+			e[n].invert = 0;
+			if (invert ? p[j].y > p[k].y : p[j].y < p[k].y)
+			{
+				e[n].invert = 1;
+				a = j, b = k;
+			}
+			e[n].x0 = p[a].x * scale_x + shift_x;
+			e[n].y0 = (p[a].y * y_scale_inv + shift_y) * vsubsample;
+			e[n].x1 = p[b].x * scale_x + shift_x;
+			e[n].y1 = (p[b].y * y_scale_inv + shift_y) * vsubsample;
+			++n;
+		}
+	}
+
+	// now sort the edges by their highest point (should snap to integer, and then by x)
+	//STBTT_sort(e, n, sizeof(e[0]), stbtt__edge_compare);
+	stbtt__sort_edges(e, n);
+
+	// now, traverse the scanlines and find the intersections on each scanline, use xor winding rule
+	stbtt__rasterize_sorted_edges(result, e, n, vsubsample, off_x, off_y, userdata);
+
+	STBTT_free(e, userdata);
+}
+
+static void stbtt__add_point(stbtt__point *points, int n, float x, float y)
+{
+	if (!points) return;  // during first pass, it's unallocated
+	points[n].x = x;
+	points[n].y = y;
+}
+
+// tesselate until threshhold p is happy... @TODO warped to compensate for non-linear stretching
+static int stbtt__tesselate_curve(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float objspace_flatness_squared, int n)
+{
+	// midpoint
+	float mx = (x0 + 2 * x1 + x2) / 4;
+	float my = (y0 + 2 * y1 + y2) / 4;
+	// versus directly drawn line
+	float dx = (x0 + x2) / 2 - mx;
+	float dy = (y0 + y2) / 2 - my;
+	if (n > 16)  // 65536 segments on one curve better be enough!
+		return 1;
+	if (dx * dx + dy * dy > objspace_flatness_squared)
+	{  // half-pixel error allowed... need to be smaller if AA
+		stbtt__tesselate_curve(points, num_points, x0, y0, (x0 + x1) / 2.0f, (y0 + y1) / 2.0f, mx, my, objspace_flatness_squared, n + 1);
+		stbtt__tesselate_curve(points, num_points, mx, my, (x1 + x2) / 2.0f, (y1 + y2) / 2.0f, x2, y2, objspace_flatness_squared, n + 1);
+	}
+	else
+	{
+		stbtt__add_point(points, *num_points, x2, y2);
+		*num_points = *num_points + 1;
+	}
+	return 1;
+}
+
+static void stbtt__tesselate_cubic(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float x3, float y3, float objspace_flatness_squared, int n)
+{
+	// @TODO this "flatness" calculation is just made-up nonsense that seems to work well enough
+	float dx0 = x1 - x0;
+	float dy0 = y1 - y0;
+	float dx1 = x2 - x1;
+	float dy1 = y2 - y1;
+	float dx2 = x3 - x2;
+	float dy2 = y3 - y2;
+	float dx = x3 - x0;
+	float dy = y3 - y0;
+	float longlen = (float)(STBTT_sqrt(dx0 * dx0 + dy0 * dy0) + STBTT_sqrt(dx1 * dx1 + dy1 * dy1) + STBTT_sqrt(dx2 * dx2 + dy2 * dy2));
+	float shortlen = (float)STBTT_sqrt(dx * dx + dy * dy);
+	float flatness_squared = longlen * longlen - shortlen * shortlen;
+
+	if (n > 16)  // 65536 segments on one curve better be enough!
+		return;
+
+	if (flatness_squared > objspace_flatness_squared)
+	{
+		float x01 = (x0 + x1) / 2;
+		float y01 = (y0 + y1) / 2;
+		float x12 = (x1 + x2) / 2;
+		float y12 = (y1 + y2) / 2;
+		float x23 = (x2 + x3) / 2;
+		float y23 = (y2 + y3) / 2;
+
+		float xa = (x01 + x12) / 2;
+		float ya = (y01 + y12) / 2;
+		float xb = (x12 + x23) / 2;
+		float yb = (y12 + y23) / 2;
+
+		float mx = (xa + xb) / 2;
+		float my = (ya + yb) / 2;
+
+		stbtt__tesselate_cubic(points, num_points, x0, y0, x01, y01, xa, ya, mx, my, objspace_flatness_squared, n + 1);
+		stbtt__tesselate_cubic(points, num_points, mx, my, xb, yb, x23, y23, x3, y3, objspace_flatness_squared, n + 1);
+	}
+	else
+	{
+		stbtt__add_point(points, *num_points, x3, y3);
+		*num_points = *num_points + 1;
+	}
+}
+
+// returns number of contours
+static stbtt__point *stbtt_FlattenCurves(stbtt_vertex *vertices, int num_verts, float objspace_flatness, int **contour_lengths, int *num_contours, void *userdata)
+{
+	stbtt__point *points = 0;
+	int num_points = 0;
+
+	float objspace_flatness_squared = objspace_flatness * objspace_flatness;
+	int i, n = 0, start = 0, pass;
+
+	// count how many "moves" there are to get the contour count
+	for (i = 0; i < num_verts; ++i)
+		if (vertices[i].type == STBTT_vmove)
+			++n;
+
+	*num_contours = n;
+	if (n == 0) return 0;
+
+	*contour_lengths = (int *)STBTT_malloc(sizeof(**contour_lengths) * n, userdata);
+
+	if (*contour_lengths == 0)
+	{
+		*num_contours = 0;
+		return 0;
+	}
+
+	// make two passes through the points so we don't need to realloc
+	for (pass = 0; pass < 2; ++pass)
+	{
+		float x = 0, y = 0;
+		if (pass == 1)
+		{
+			points = (stbtt__point *)STBTT_malloc(num_points * sizeof(points[0]), userdata);
+			if (points == NULL) goto error;
+		}
+		num_points = 0;
+		n = -1;
+		for (i = 0; i < num_verts; ++i)
+		{
+			switch (vertices[i].type)
+			{
+				case STBTT_vmove:
+					// start the next contour
+					if (n >= 0)
+						(*contour_lengths)[n] = num_points - start;
+					++n;
+					start = num_points;
+
+					x = vertices[i].x, y = vertices[i].y;
+					stbtt__add_point(points, num_points++, x, y);
+					break;
+				case STBTT_vline:
+					x = vertices[i].x, y = vertices[i].y;
+					stbtt__add_point(points, num_points++, x, y);
+					break;
+				case STBTT_vcurve:
+					stbtt__tesselate_curve(points, &num_points, x, y,
+										   vertices[i].cx, vertices[i].cy,
+										   vertices[i].x, vertices[i].y,
+										   objspace_flatness_squared, 0);
+					x = vertices[i].x, y = vertices[i].y;
+					break;
+				case STBTT_vcubic:
+					stbtt__tesselate_cubic(points, &num_points, x, y,
+										   vertices[i].cx, vertices[i].cy,
+										   vertices[i].cx1, vertices[i].cy1,
+										   vertices[i].x, vertices[i].y,
+										   objspace_flatness_squared, 0);
+					x = vertices[i].x, y = vertices[i].y;
+					break;
+			}
+		}
+		(*contour_lengths)[n] = num_points - start;
+	}
+
+	return points;
+error:
+	STBTT_free(points, userdata);
+	STBTT_free(*contour_lengths, userdata);
+	*contour_lengths = 0;
+	*num_contours = 0;
+	return NULL;
+}
+
+STBTT_DEF void stbtt_Rasterize(stbtt__bitmap *result, float flatness_in_pixels, stbtt_vertex *vertices, int num_verts, float scale_x, float scale_y, float shift_x, float shift_y, int x_off, int y_off, int invert, void *userdata)
+{
+	float scale = scale_x > scale_y ? scale_y : scale_x;
+	int winding_count = 0;
+	int *winding_lengths = NULL;
+	stbtt__point *windings = stbtt_FlattenCurves(vertices, num_verts, flatness_in_pixels / scale, &winding_lengths, &winding_count, userdata);
+	if (windings)
+	{
+		stbtt__rasterize(result, windings, winding_lengths, winding_count, scale_x, scale_y, shift_x, shift_y, x_off, y_off, invert, userdata);
+		STBTT_free(winding_lengths, userdata);
+		STBTT_free(windings, userdata);
+	}
+}
+
+STBTT_DEF void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata)
+{
+	STBTT_free(bitmap, userdata);
+}
+
+STBTT_DEF unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int glyph, int *width, int *height, int *xoff, int *yoff)
+{
+	int ix0, iy0, ix1, iy1;
+	stbtt__bitmap gbm;
+	stbtt_vertex *vertices;
+	int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices);
+
+	if (scale_x == 0) scale_x = scale_y;
+	if (scale_y == 0)
+	{
+		if (scale_x == 0)
+		{
+			STBTT_free(vertices, info->userdata);
+			return NULL;
+		}
+		scale_y = scale_x;
+	}
+
+	stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale_x, scale_y, shift_x, shift_y, &ix0, &iy0, &ix1, &iy1);
+
+	// now we get the size
+	gbm.w = (ix1 - ix0);
+	gbm.h = (iy1 - iy0);
+	gbm.pixels = NULL;  // in case we error
+
+	if (width) *width = gbm.w;
+	if (height) *height = gbm.h;
+	if (xoff) *xoff = ix0;
+	if (yoff) *yoff = iy0;
+
+	if (gbm.w && gbm.h)
+	{
+		gbm.pixels = (unsigned char *)STBTT_malloc(gbm.w * gbm.h, info->userdata);
+		if (gbm.pixels)
+		{
+			gbm.stride = gbm.w;
+
+			stbtt_Rasterize(&gbm, 0.35f, vertices, num_verts, scale_x, scale_y, shift_x, shift_y, ix0, iy0, 1, info->userdata);
+		}
+	}
+	STBTT_free(vertices, info->userdata);
+	return gbm.pixels;
+}
+
+STBTT_DEF unsigned char *stbtt_GetGlyphBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int glyph, int *width, int *height, int *xoff, int *yoff)
+{
+	return stbtt_GetGlyphBitmapSubpixel(info, scale_x, scale_y, 0.0f, 0.0f, glyph, width, height, xoff, yoff);
+}
+
+STBTT_DEF void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int glyph)
+{
+	int ix0, iy0;
+	stbtt_vertex *vertices;
+	int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices);
+	stbtt__bitmap gbm;
+
+	stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale_x, scale_y, shift_x, shift_y, &ix0, &iy0, 0, 0);
+	gbm.pixels = output;
+	gbm.w = out_w;
+	gbm.h = out_h;
+	gbm.stride = out_stride;
+
+	if (gbm.w && gbm.h)
+		stbtt_Rasterize(&gbm, 0.35f, vertices, num_verts, scale_x, scale_y, shift_x, shift_y, ix0, iy0, 1, info->userdata);
+
+	STBTT_free(vertices, info->userdata);
+}
+
+STBTT_DEF void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int glyph)
+{
+	stbtt_MakeGlyphBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, 0.0f, 0.0f, glyph);
+}
+
+STBTT_DEF unsigned char *stbtt_GetCodepointBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint, int *width, int *height, int *xoff, int *yoff)
+{
+	return stbtt_GetGlyphBitmapSubpixel(info, scale_x, scale_y, shift_x, shift_y, stbtt_FindGlyphIndex(info, codepoint), width, height, xoff, yoff);
+}
+
+STBTT_DEF void stbtt_MakeCodepointBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float *sub_x, float *sub_y, int codepoint)
+{
+	stbtt_MakeGlyphBitmapSubpixelPrefilter(info, output, out_w, out_h, out_stride, scale_x, scale_y, shift_x, shift_y, oversample_x, oversample_y, sub_x, sub_y, stbtt_FindGlyphIndex(info, codepoint));
+}
+
+STBTT_DEF void stbtt_MakeCodepointBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint)
+{
+	stbtt_MakeGlyphBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, shift_x, shift_y, stbtt_FindGlyphIndex(info, codepoint));
+}
+
+STBTT_DEF unsigned char *stbtt_GetCodepointBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int codepoint, int *width, int *height, int *xoff, int *yoff)
+{
+	return stbtt_GetCodepointBitmapSubpixel(info, scale_x, scale_y, 0.0f, 0.0f, codepoint, width, height, xoff, yoff);
+}
+
+STBTT_DEF void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int codepoint)
+{
+	stbtt_MakeCodepointBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, 0.0f, 0.0f, codepoint);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// bitmap baking
+//
+// This is SUPER-CRAPPY packing to keep source code small
+
+static int stbtt_BakeFontBitmap_internal(unsigned char *data, int offset,        // font location (use offset=0 for plain .ttf)
+										 float pixel_height,                     // height of font in pixels
+										 unsigned char *pixels, int pw, int ph,  // bitmap to be filled in
+										 int first_char, int num_chars,          // characters to bake
+										 stbtt_bakedchar *chardata)
+{
+	float scale;
+	int x, y, bottom_y, i;
+	stbtt_fontinfo f;
+	f.userdata = NULL;
+	if (!stbtt_InitFont(&f, data, offset))
+		return -1;
+	STBTT_memset(pixels, 0, pw * ph);  // background of 0 around pixels
+	x = y = 1;
+	bottom_y = 1;
+
+	scale = stbtt_ScaleForPixelHeight(&f, pixel_height);
+
+	for (i = 0; i < num_chars; ++i)
+	{
+		int advance, lsb, x0, y0, x1, y1, gw, gh;
+		int g = stbtt_FindGlyphIndex(&f, first_char + i);
+		stbtt_GetGlyphHMetrics(&f, g, &advance, &lsb);
+		stbtt_GetGlyphBitmapBox(&f, g, scale, scale, &x0, &y0, &x1, &y1);
+		gw = x1 - x0;
+		gh = y1 - y0;
+		if (x + gw + 1 >= pw)
+			y = bottom_y, x = 1;  // advance to next row
+		if (y + gh + 1 >= ph)     // check if it fits vertically AFTER potentially moving to next row
+			return -i;
+		STBTT_assert(x + gw < pw);
+		STBTT_assert(y + gh < ph);
+		stbtt_MakeGlyphBitmap(&f, pixels + x + y * pw, gw, gh, pw, scale, scale, g);
+		chardata[i].x0 = (stbtt_int16)x;
+		chardata[i].y0 = (stbtt_int16)y;
+		chardata[i].x1 = (stbtt_int16)(x + gw);
+		chardata[i].y1 = (stbtt_int16)(y + gh);
+		chardata[i].xadvance = scale * advance;
+		chardata[i].xoff = (float)x0;
+		chardata[i].yoff = (float)y0;
+		x = x + gw + 1;
+		if (y + gh + 1 > bottom_y)
+			bottom_y = y + gh + 1;
+	}
+	return bottom_y;
+}
+
+STBTT_DEF void stbtt_GetBakedQuad(const stbtt_bakedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int opengl_fillrule)
+{
+	float d3d_bias = opengl_fillrule ? 0 : -0.5f;
+	float ipw = 1.0f / pw, iph = 1.0f / ph;
+	const stbtt_bakedchar *b = chardata + char_index;
+	int round_x = STBTT_ifloor((*xpos + b->xoff) + 0.5f);
+	int round_y = STBTT_ifloor((*ypos + b->yoff) + 0.5f);
+
+	q->x0 = round_x + d3d_bias;
+	q->y0 = round_y + d3d_bias;
+	q->x1 = round_x + b->x1 - b->x0 + d3d_bias;
+	q->y1 = round_y + b->y1 - b->y0 + d3d_bias;
+
+	q->s0 = b->x0 * ipw;
+	q->t0 = b->y0 * iph;
+	q->s1 = b->x1 * ipw;
+	q->t1 = b->y1 * iph;
+
+	*xpos += b->xadvance;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// rectangle packing replacement routines if you don't have stb_rect_pack.h
+//
+
+#ifndef STB_RECT_PACK_VERSION
+
+typedef int stbrp_coord;
+
+////////////////////////////////////////////////////////////////////////////////////
+//                                                                                //
+//                                                                                //
+// COMPILER WARNING ?!?!?                                                         //
+//                                                                                //
+//                                                                                //
+// if you get a compile warning due to these symbols being defined more than      //
+// once, move #include "stb_rect_pack.h" before #include "stb_truetype.h"         //
+//                                                                                //
+////////////////////////////////////////////////////////////////////////////////////
+
+typedef struct
+{
+	int width, height;
+	int x, y, bottom_y;
+} stbrp_context;
+
+typedef struct
+{
+	unsigned char x;
+} stbrp_node;
+
+struct stbrp_rect
+{
+	stbrp_coord x, y;
+	int id, w, h, was_packed;
+};
+
+static void stbrp_init_target(stbrp_context *con, int pw, int ph, stbrp_node *nodes, int num_nodes)
+{
+	con->width = pw;
+	con->height = ph;
+	con->x = 0;
+	con->y = 0;
+	con->bottom_y = 0;
+	STBTT__NOTUSED(nodes);
+	STBTT__NOTUSED(num_nodes);
+}
+
+static void stbrp_pack_rects(stbrp_context *con, stbrp_rect *rects, int num_rects)
+{
+	int i;
+	for (i = 0; i < num_rects; ++i)
+	{
+		if (con->x + rects[i].w > con->width)
+		{
+			con->x = 0;
+			con->y = con->bottom_y;
+		}
+		if (con->y + rects[i].h > con->height)
+			break;
+		rects[i].x = con->x;
+		rects[i].y = con->y;
+		rects[i].was_packed = 1;
+		con->x += rects[i].w;
+		if (con->y + rects[i].h > con->bottom_y)
+			con->bottom_y = con->y + rects[i].h;
+	}
+	for (; i < num_rects; ++i)
+		rects[i].was_packed = 0;
+}
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// bitmap baking
+//
+// This is SUPER-AWESOME (tm Ryan Gordon) packing using stb_rect_pack.h. If
+// stb_rect_pack.h isn't available, it uses the BakeFontBitmap strategy.
+
+STBTT_DEF int stbtt_PackBegin(stbtt_pack_context *spc, unsigned char *pixels, int pw, int ph, int stride_in_bytes, int padding, void *alloc_context)
+{
+	stbrp_context *context = (stbrp_context *)STBTT_malloc(sizeof(*context), alloc_context);
+	int num_nodes = pw - padding;
+	stbrp_node *nodes = (stbrp_node *)STBTT_malloc(sizeof(*nodes) * num_nodes, alloc_context);
+
+	if (context == NULL || nodes == NULL)
+	{
+		if (context != NULL) STBTT_free(context, alloc_context);
+		if (nodes != NULL) STBTT_free(nodes, alloc_context);
+		return 0;
+	}
+
+	spc->user_allocator_context = alloc_context;
+	spc->width = pw;
+	spc->height = ph;
+	spc->pixels = pixels;
+	spc->pack_info = context;
+	spc->nodes = nodes;
+	spc->padding = padding;
+	spc->stride_in_bytes = stride_in_bytes != 0 ? stride_in_bytes : pw;
+	spc->h_oversample = 1;
+	spc->v_oversample = 1;
+
+	stbrp_init_target(context, pw - padding, ph - padding, nodes, num_nodes);
+
+	if (pixels)
+		STBTT_memset(pixels, 0, pw * ph);  // background of 0 around pixels
+
+	return 1;
+}
+
+STBTT_DEF void stbtt_PackEnd(stbtt_pack_context *spc)
+{
+	STBTT_free(spc->nodes, spc->user_allocator_context);
+	STBTT_free(spc->pack_info, spc->user_allocator_context);
+}
+
+STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsigned int h_oversample, unsigned int v_oversample)
+{
+	STBTT_assert(h_oversample <= STBTT_MAX_OVERSAMPLE);
+	STBTT_assert(v_oversample <= STBTT_MAX_OVERSAMPLE);
+	if (h_oversample <= STBTT_MAX_OVERSAMPLE)
+		spc->h_oversample = h_oversample;
+	if (v_oversample <= STBTT_MAX_OVERSAMPLE)
+		spc->v_oversample = v_oversample;
+}
+
+#define STBTT__OVER_MASK (STBTT_MAX_OVERSAMPLE - 1)
+
+static void stbtt__h_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes, unsigned int kernel_width)
+{
+	unsigned char buffer[STBTT_MAX_OVERSAMPLE];
+	int safe_w = w - kernel_width;
+	int j;
+	STBTT_memset(buffer, 0, STBTT_MAX_OVERSAMPLE);  // suppress bogus warning from VS2013 -analyze
+	for (j = 0; j < h; ++j)
+	{
+		int i;
+		unsigned int total;
+		STBTT_memset(buffer, 0, kernel_width);
+
+		total = 0;
+
+		// make kernel_width a constant in common cases so compiler can optimize out the divide
+		switch (kernel_width)
+		{
+			case 2:
+				for (i = 0; i <= safe_w; ++i)
+				{
+					total += pixels[i] - buffer[i & STBTT__OVER_MASK];
+					buffer[(i + kernel_width) & STBTT__OVER_MASK] = pixels[i];
+					pixels[i] = (unsigned char)(total / 2);
+				}
+				break;
+			case 3:
+				for (i = 0; i <= safe_w; ++i)
+				{
+					total += pixels[i] - buffer[i & STBTT__OVER_MASK];
+					buffer[(i + kernel_width) & STBTT__OVER_MASK] = pixels[i];
+					pixels[i] = (unsigned char)(total / 3);
+				}
+				break;
+			case 4:
+				for (i = 0; i <= safe_w; ++i)
+				{
+					total += pixels[i] - buffer[i & STBTT__OVER_MASK];
+					buffer[(i + kernel_width) & STBTT__OVER_MASK] = pixels[i];
+					pixels[i] = (unsigned char)(total / 4);
+				}
+				break;
+			case 5:
+				for (i = 0; i <= safe_w; ++i)
+				{
+					total += pixels[i] - buffer[i & STBTT__OVER_MASK];
+					buffer[(i + kernel_width) & STBTT__OVER_MASK] = pixels[i];
+					pixels[i] = (unsigned char)(total / 5);
+				}
+				break;
+			default:
+				for (i = 0; i <= safe_w; ++i)
+				{
+					total += pixels[i] - buffer[i & STBTT__OVER_MASK];
+					buffer[(i + kernel_width) & STBTT__OVER_MASK] = pixels[i];
+					pixels[i] = (unsigned char)(total / kernel_width);
+				}
+				break;
+		}
+
+		for (; i < w; ++i)
+		{
+			STBTT_assert(pixels[i] == 0);
+			total -= buffer[i & STBTT__OVER_MASK];
+			pixels[i] = (unsigned char)(total / kernel_width);
+		}
+
+		pixels += stride_in_bytes;
+	}
+}
+
+static void stbtt__v_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes, unsigned int kernel_width)
+{
+	unsigned char buffer[STBTT_MAX_OVERSAMPLE];
+	int safe_h = h - kernel_width;
+	int j;
+	STBTT_memset(buffer, 0, STBTT_MAX_OVERSAMPLE);  // suppress bogus warning from VS2013 -analyze
+	for (j = 0; j < w; ++j)
+	{
+		int i;
+		unsigned int total;
+		STBTT_memset(buffer, 0, kernel_width);
+
+		total = 0;
+
+		// make kernel_width a constant in common cases so compiler can optimize out the divide
+		switch (kernel_width)
+		{
+			case 2:
+				for (i = 0; i <= safe_h; ++i)
+				{
+					total += pixels[i * stride_in_bytes] - buffer[i & STBTT__OVER_MASK];
+					buffer[(i + kernel_width) & STBTT__OVER_MASK] = pixels[i * stride_in_bytes];
+					pixels[i * stride_in_bytes] = (unsigned char)(total / 2);
+				}
+				break;
+			case 3:
+				for (i = 0; i <= safe_h; ++i)
+				{
+					total += pixels[i * stride_in_bytes] - buffer[i & STBTT__OVER_MASK];
+					buffer[(i + kernel_width) & STBTT__OVER_MASK] = pixels[i * stride_in_bytes];
+					pixels[i * stride_in_bytes] = (unsigned char)(total / 3);
+				}
+				break;
+			case 4:
+				for (i = 0; i <= safe_h; ++i)
+				{
+					total += pixels[i * stride_in_bytes] - buffer[i & STBTT__OVER_MASK];
+					buffer[(i + kernel_width) & STBTT__OVER_MASK] = pixels[i * stride_in_bytes];
+					pixels[i * stride_in_bytes] = (unsigned char)(total / 4);
+				}
+				break;
+			case 5:
+				for (i = 0; i <= safe_h; ++i)
+				{
+					total += pixels[i * stride_in_bytes] - buffer[i & STBTT__OVER_MASK];
+					buffer[(i + kernel_width) & STBTT__OVER_MASK] = pixels[i * stride_in_bytes];
+					pixels[i * stride_in_bytes] = (unsigned char)(total / 5);
+				}
+				break;
+			default:
+				for (i = 0; i <= safe_h; ++i)
+				{
+					total += pixels[i * stride_in_bytes] - buffer[i & STBTT__OVER_MASK];
+					buffer[(i + kernel_width) & STBTT__OVER_MASK] = pixels[i * stride_in_bytes];
+					pixels[i * stride_in_bytes] = (unsigned char)(total / kernel_width);
+				}
+				break;
+		}
+
+		for (; i < h; ++i)
+		{
+			STBTT_assert(pixels[i * stride_in_bytes] == 0);
+			total -= buffer[i & STBTT__OVER_MASK];
+			pixels[i * stride_in_bytes] = (unsigned char)(total / kernel_width);
+		}
+
+		pixels += 1;
+	}
+}
+
+static float stbtt__oversample_shift(int oversample)
+{
+	if (!oversample)
+		return 0.0f;
+
+	// The prefilter is a box filter of width "oversample",
+	// which shifts phase by (oversample - 1)/2 pixels in
+	// oversampled space. We want to shift in the opposite
+	// direction to counter this.
+	return (float)-(oversample - 1) / (2.0f * (float)oversample);
+}
+
+// rects array must be big enough to accommodate all characters in the given ranges
+STBTT_DEF int stbtt_PackFontRangesGatherRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects)
+{
+	int i, j, k;
+
+	k = 0;
+	for (i = 0; i < num_ranges; ++i)
+	{
+		float fh = ranges[i].font_size;
+		float scale = fh > 0 ? stbtt_ScaleForPixelHeight(info, fh) : stbtt_ScaleForMappingEmToPixels(info, -fh);
+		ranges[i].h_oversample = (unsigned char)spc->h_oversample;
+		ranges[i].v_oversample = (unsigned char)spc->v_oversample;
+		for (j = 0; j < ranges[i].num_chars; ++j)
+		{
+			int x0, y0, x1, y1;
+			int codepoint = ranges[i].array_of_unicode_codepoints == NULL ? ranges[i].first_unicode_codepoint_in_range + j : ranges[i].array_of_unicode_codepoints[j];
+			int glyph = stbtt_FindGlyphIndex(info, codepoint);
+			stbtt_GetGlyphBitmapBoxSubpixel(info, glyph,
+											scale * spc->h_oversample,
+											scale * spc->v_oversample,
+											0, 0,
+											&x0, &y0, &x1, &y1);
+			rects[k].w = (stbrp_coord)(x1 - x0 + spc->padding + spc->h_oversample - 1);
+			rects[k].h = (stbrp_coord)(y1 - y0 + spc->padding + spc->v_oversample - 1);
+			++k;
+		}
+	}
+
+	return k;
+}
+
+STBTT_DEF void stbtt_MakeGlyphBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int prefilter_x, int prefilter_y, float *sub_x, float *sub_y, int glyph)
+{
+	stbtt_MakeGlyphBitmapSubpixel(info,
+								  output,
+								  out_w - (prefilter_x - 1),
+								  out_h - (prefilter_y - 1),
+								  out_stride,
+								  scale_x,
+								  scale_y,
+								  shift_x,
+								  shift_y,
+								  glyph);
+
+	if (prefilter_x > 1)
+		stbtt__h_prefilter(output, out_w, out_h, out_stride, prefilter_x);
+
+	if (prefilter_y > 1)
+		stbtt__v_prefilter(output, out_w, out_h, out_stride, prefilter_y);
+
+	*sub_x = stbtt__oversample_shift(prefilter_x);
+	*sub_y = stbtt__oversample_shift(prefilter_y);
+}
+
+// rects array must be big enough to accommodate all characters in the given ranges
+STBTT_DEF int stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects)
+{
+	int i, j, k, return_value = 1;
+
+	// save current values
+	int old_h_over = spc->h_oversample;
+	int old_v_over = spc->v_oversample;
+
+	k = 0;
+	for (i = 0; i < num_ranges; ++i)
+	{
+		float fh = ranges[i].font_size;
+		float scale = fh > 0 ? stbtt_ScaleForPixelHeight(info, fh) : stbtt_ScaleForMappingEmToPixels(info, -fh);
+		float recip_h, recip_v, sub_x, sub_y;
+		spc->h_oversample = ranges[i].h_oversample;
+		spc->v_oversample = ranges[i].v_oversample;
+		recip_h = 1.0f / spc->h_oversample;
+		recip_v = 1.0f / spc->v_oversample;
+		sub_x = stbtt__oversample_shift(spc->h_oversample);
+		sub_y = stbtt__oversample_shift(spc->v_oversample);
+		for (j = 0; j < ranges[i].num_chars; ++j)
+		{
+			stbrp_rect *r = &rects[k];
+			if (r->was_packed)
+			{
+				stbtt_packedchar *bc = &ranges[i].chardata_for_range[j];
+				int advance, lsb, x0, y0, x1, y1;
+				int codepoint = ranges[i].array_of_unicode_codepoints == NULL ? ranges[i].first_unicode_codepoint_in_range + j : ranges[i].array_of_unicode_codepoints[j];
+				int glyph = stbtt_FindGlyphIndex(info, codepoint);
+				stbrp_coord pad = (stbrp_coord)spc->padding;
+
+				// pad on left and top
+				r->x += pad;
+				r->y += pad;
+				r->w -= pad;
+				r->h -= pad;
+				stbtt_GetGlyphHMetrics(info, glyph, &advance, &lsb);
+				stbtt_GetGlyphBitmapBox(info, glyph,
+										scale * spc->h_oversample,
+										scale * spc->v_oversample,
+										&x0, &y0, &x1, &y1);
+				stbtt_MakeGlyphBitmapSubpixel(info,
+											  spc->pixels + r->x + r->y * spc->stride_in_bytes,
+											  r->w - spc->h_oversample + 1,
+											  r->h - spc->v_oversample + 1,
+											  spc->stride_in_bytes,
+											  scale * spc->h_oversample,
+											  scale * spc->v_oversample,
+											  0, 0,
+											  glyph);
+
+				if (spc->h_oversample > 1)
+					stbtt__h_prefilter(spc->pixels + r->x + r->y * spc->stride_in_bytes,
+									   r->w, r->h, spc->stride_in_bytes,
+									   spc->h_oversample);
+
+				if (spc->v_oversample > 1)
+					stbtt__v_prefilter(spc->pixels + r->x + r->y * spc->stride_in_bytes,
+									   r->w, r->h, spc->stride_in_bytes,
+									   spc->v_oversample);
+
+				bc->x0 = (stbtt_int16)r->x;
+				bc->y0 = (stbtt_int16)r->y;
+				bc->x1 = (stbtt_int16)(r->x + r->w);
+				bc->y1 = (stbtt_int16)(r->y + r->h);
+				bc->xadvance = scale * advance;
+				bc->xoff = (float)x0 * recip_h + sub_x;
+				bc->yoff = (float)y0 * recip_v + sub_y;
+				bc->xoff2 = (x0 + r->w) * recip_h + sub_x;
+				bc->yoff2 = (y0 + r->h) * recip_v + sub_y;
+			}
+			else
+			{
+				return_value = 0;  // if any fail, report failure
+			}
+
+			++k;
+		}
+	}
+
+	// restore original values
+	spc->h_oversample = old_h_over;
+	spc->v_oversample = old_v_over;
+
+	return return_value;
+}
+
+STBTT_DEF void stbtt_PackFontRangesPackRects(stbtt_pack_context *spc, stbrp_rect *rects, int num_rects)
+{
+	stbrp_pack_rects((stbrp_context *)spc->pack_info, rects, num_rects);
+}
+
+STBTT_DEF int stbtt_PackFontRanges(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, stbtt_pack_range *ranges, int num_ranges)
+{
+	stbtt_fontinfo info;
+	int i, j, n, return_value = 1;
+	//stbrp_context *context = (stbrp_context *) spc->pack_info;
+	stbrp_rect *rects;
+
+	// flag all characters as NOT packed
+	for (i = 0; i < num_ranges; ++i)
+		for (j = 0; j < ranges[i].num_chars; ++j)
+			ranges[i].chardata_for_range[j].x0 =
+				ranges[i].chardata_for_range[j].y0 =
+					ranges[i].chardata_for_range[j].x1 =
+						ranges[i].chardata_for_range[j].y1 = 0;
+
+	n = 0;
+	for (i = 0; i < num_ranges; ++i)
+		n += ranges[i].num_chars;
+
+	rects = (stbrp_rect *)STBTT_malloc(sizeof(*rects) * n, spc->user_allocator_context);
+	if (rects == NULL)
+		return 0;
+
+	info.userdata = spc->user_allocator_context;
+	stbtt_InitFont(&info, fontdata, stbtt_GetFontOffsetForIndex(fontdata, font_index));
+
+	n = stbtt_PackFontRangesGatherRects(spc, &info, ranges, num_ranges, rects);
+
+	stbtt_PackFontRangesPackRects(spc, rects, n);
+
+	return_value = stbtt_PackFontRangesRenderIntoRects(spc, &info, ranges, num_ranges, rects);
+
+	STBTT_free(rects, spc->user_allocator_context);
+	return return_value;
+}
+
+STBTT_DEF int stbtt_PackFontRange(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, float font_size,
+								  int first_unicode_codepoint_in_range, int num_chars_in_range, stbtt_packedchar *chardata_for_range)
+{
+	stbtt_pack_range range;
+	range.first_unicode_codepoint_in_range = first_unicode_codepoint_in_range;
+	range.array_of_unicode_codepoints = NULL;
+	range.num_chars = num_chars_in_range;
+	range.chardata_for_range = chardata_for_range;
+	range.font_size = font_size;
+	return stbtt_PackFontRanges(spc, fontdata, font_index, &range, 1);
+}
+
+STBTT_DEF void stbtt_GetPackedQuad(const stbtt_packedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int align_to_integer)
+{
+	float ipw = 1.0f / pw, iph = 1.0f / ph;
+	const stbtt_packedchar *b = chardata + char_index;
+
+	if (align_to_integer)
+	{
+		float x = (float)STBTT_ifloor((*xpos + b->xoff) + 0.5f);
+		float y = (float)STBTT_ifloor((*ypos + b->yoff) + 0.5f);
+		q->x0 = x;
+		q->y0 = y;
+		q->x1 = x + b->xoff2 - b->xoff;
+		q->y1 = y + b->yoff2 - b->yoff;
+	}
+	else
+	{
+		q->x0 = *xpos + b->xoff;
+		q->y0 = *ypos + b->yoff;
+		q->x1 = *xpos + b->xoff2;
+		q->y1 = *ypos + b->yoff2;
+	}
+
+	q->s0 = b->x0 * ipw;
+	q->t0 = b->y0 * iph;
+	q->s1 = b->x1 * ipw;
+	q->t1 = b->y1 * iph;
+
+	*xpos += b->xadvance;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// sdf computation
+//
+
+#define STBTT_min(a, b) ((a) < (b) ? (a) : (b))
+#define STBTT_max(a, b) ((a) < (b) ? (b) : (a))
+
+static int stbtt__ray_intersect_bezier(float orig[2], float ray[2], float q0[2], float q1[2], float q2[2], float hits[2][2])
+{
+	float q0perp = q0[1] * ray[0] - q0[0] * ray[1];
+	float q1perp = q1[1] * ray[0] - q1[0] * ray[1];
+	float q2perp = q2[1] * ray[0] - q2[0] * ray[1];
+	float roperp = orig[1] * ray[0] - orig[0] * ray[1];
+
+	float a = q0perp - 2 * q1perp + q2perp;
+	float b = q1perp - q0perp;
+	float c = q0perp - roperp;
+
+	float s0 = 0., s1 = 0.;
+	int num_s = 0;
+
+	if (a != 0.0)
+	{
+		float discr = b * b - a * c;
+		if (discr > 0.0)
+		{
+			float rcpna = -1 / a;
+			float d = (float)STBTT_sqrt(discr);
+			s0 = (b + d) * rcpna;
+			s1 = (b - d) * rcpna;
+			if (s0 >= 0.0 && s0 <= 1.0)
+				num_s = 1;
+			if (d > 0.0 && s1 >= 0.0 && s1 <= 1.0)
+			{
+				if (num_s == 0) s0 = s1;
+				++num_s;
+			}
+		}
+	}
+	else
+	{
+		// 2*b*s + c = 0
+		// s = -c / (2*b)
+		s0 = c / (-2 * b);
+		if (s0 >= 0.0 && s0 <= 1.0)
+			num_s = 1;
+	}
+
+	if (num_s == 0)
+		return 0;
+	else
+	{
+		float rcp_len2 = 1 / (ray[0] * ray[0] + ray[1] * ray[1]);
+		float rayn_x = ray[0] * rcp_len2, rayn_y = ray[1] * rcp_len2;
+
+		float q0d = q0[0] * rayn_x + q0[1] * rayn_y;
+		float q1d = q1[0] * rayn_x + q1[1] * rayn_y;
+		float q2d = q2[0] * rayn_x + q2[1] * rayn_y;
+		float rod = orig[0] * rayn_x + orig[1] * rayn_y;
+
+		float q10d = q1d - q0d;
+		float q20d = q2d - q0d;
+		float q0rd = q0d - rod;
+
+		hits[0][0] = q0rd + s0 * (2.0f - 2.0f * s0) * q10d + s0 * s0 * q20d;
+		hits[0][1] = a * s0 + b;
+
+		if (num_s > 1)
+		{
+			hits[1][0] = q0rd + s1 * (2.0f - 2.0f * s1) * q10d + s1 * s1 * q20d;
+			hits[1][1] = a * s1 + b;
+			return 2;
+		}
+		else
+		{
+			return 1;
+		}
+	}
+}
+
+static int equal(float *a, float *b)
+{
+	return (a[0] == b[0] && a[1] == b[1]);
+}
+
+static int stbtt__compute_crossings_x(float x, float y, int nverts, stbtt_vertex *verts)
+{
+	int i;
+	float orig[2], ray[2] = {1, 0};
+	float y_frac;
+	int winding = 0;
+
+	orig[0] = x;
+	orig[1] = y;
+
+	// make sure y never passes through a vertex of the shape
+	y_frac = (float)STBTT_fmod(y, 1.0f);
+	if (y_frac < 0.01f)
+		y += 0.01f;
+	else if (y_frac > 0.99f)
+		y -= 0.01f;
+	orig[1] = y;
+
+	// test a ray from (-infinity,y) to (x,y)
+	for (i = 0; i < nverts; ++i)
+	{
+		if (verts[i].type == STBTT_vline)
+		{
+			int x0 = (int)verts[i - 1].x, y0 = (int)verts[i - 1].y;
+			int x1 = (int)verts[i].x, y1 = (int)verts[i].y;
+			if (y > STBTT_min(y0, y1) && y < STBTT_max(y0, y1) && x > STBTT_min(x0, x1))
+			{
+				float x_inter = (y - y0) / (y1 - y0) * (x1 - x0) + x0;
+				if (x_inter < x)
+					winding += (y0 < y1) ? 1 : -1;
+			}
+		}
+		if (verts[i].type == STBTT_vcurve)
+		{
+			int x0 = (int)verts[i - 1].x, y0 = (int)verts[i - 1].y;
+			int x1 = (int)verts[i].cx, y1 = (int)verts[i].cy;
+			int x2 = (int)verts[i].x, y2 = (int)verts[i].y;
+			int ax = STBTT_min(x0, STBTT_min(x1, x2)), ay = STBTT_min(y0, STBTT_min(y1, y2));
+			int by = STBTT_max(y0, STBTT_max(y1, y2));
+			if (y > ay && y < by && x > ax)
+			{
+				float q0[2], q1[2], q2[2];
+				float hits[2][2];
+				q0[0] = (float)x0;
+				q0[1] = (float)y0;
+				q1[0] = (float)x1;
+				q1[1] = (float)y1;
+				q2[0] = (float)x2;
+				q2[1] = (float)y2;
+				if (equal(q0, q1) || equal(q1, q2))
+				{
+					x0 = (int)verts[i - 1].x;
+					y0 = (int)verts[i - 1].y;
+					x1 = (int)verts[i].x;
+					y1 = (int)verts[i].y;
+					if (y > STBTT_min(y0, y1) && y < STBTT_max(y0, y1) && x > STBTT_min(x0, x1))
+					{
+						float x_inter = (y - y0) / (y1 - y0) * (x1 - x0) + x0;
+						if (x_inter < x)
+							winding += (y0 < y1) ? 1 : -1;
+					}
+				}
+				else
+				{
+					int num_hits = stbtt__ray_intersect_bezier(orig, ray, q0, q1, q2, hits);
+					if (num_hits >= 1)
+						if (hits[0][0] < 0)
+							winding += (hits[0][1] < 0 ? -1 : 1);
+					if (num_hits >= 2)
+						if (hits[1][0] < 0)
+							winding += (hits[1][1] < 0 ? -1 : 1);
+				}
+			}
+		}
+	}
+	return winding;
+}
+
+static float stbtt__cuberoot(float x)
+{
+	if (x < 0)
+		return -(float)STBTT_pow(-x, 1.0f / 3.0f);
+	else
+		return (float)STBTT_pow(x, 1.0f / 3.0f);
+}
+
+// x^3 + c*x^2 + b*x + a = 0
+static int stbtt__solve_cubic(float a, float b, float c, float *r)
+{
+	float s = -a / 3;
+	float p = b - a * a / 3;
+	float q = a * (2 * a * a - 9 * b) / 27 + c;
+	float p3 = p * p * p;
+	float d = q * q + 4 * p3 / 27;
+	if (d >= 0)
+	{
+		float z = (float)STBTT_sqrt(d);
+		float u = (-q + z) / 2;
+		float v = (-q - z) / 2;
+		u = stbtt__cuberoot(u);
+		v = stbtt__cuberoot(v);
+		r[0] = s + u + v;
+		return 1;
+	}
+	else
+	{
+		float u = (float)STBTT_sqrt(-p / 3);
+		float v = (float)STBTT_acos(-STBTT_sqrt(-27 / p3) * q / 2) / 3;  // p3 must be negative, since d is negative
+		float m = (float)STBTT_cos(v);
+		float n = (float)STBTT_cos(v - 3.141592 / 2) * 1.732050808f;
+		r[0] = s + u * 2 * m;
+		r[1] = s - u * (m + n);
+		r[2] = s - u * (m - n);
+
+		//STBTT_assert( STBTT_fabs(((r[0]+a)*r[0]+b)*r[0]+c) < 0.05f);  // these asserts may not be safe at all scales, though they're in bezier t parameter units so maybe?
+		//STBTT_assert( STBTT_fabs(((r[1]+a)*r[1]+b)*r[1]+c) < 0.05f);
+		//STBTT_assert( STBTT_fabs(((r[2]+a)*r[2]+b)*r[2]+c) < 0.05f);
+		return 3;
+	}
+}
+
+STBTT_DEF unsigned char *stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float scale, int glyph, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff)
+{
+	float scale_x = scale, scale_y = scale;
+	int ix0, iy0, ix1, iy1;
+	int w, h;
+	unsigned char *data;
+
+	// if one scale is 0, use same scale for both
+	if (scale_x == 0) scale_x = scale_y;
+	if (scale_y == 0)
+	{
+		if (scale_x == 0) return NULL;  // if both scales are 0, return NULL
+		scale_y = scale_x;
+	}
+
+	stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale, scale, 0.0f, 0.0f, &ix0, &iy0, &ix1, &iy1);
+
+	// if empty, return NULL
+	if (ix0 == ix1 || iy0 == iy1)
+		return NULL;
+
+	ix0 -= padding;
+	iy0 -= padding;
+	ix1 += padding;
+	iy1 += padding;
+
+	w = (ix1 - ix0);
+	h = (iy1 - iy0);
+
+	if (width) *width = w;
+	if (height) *height = h;
+	if (xoff) *xoff = ix0;
+	if (yoff) *yoff = iy0;
+
+	// invert for y-downwards bitmaps
+	scale_y = -scale_y;
+
+	{
+		int x, y, i, j;
+		float *precompute;
+		stbtt_vertex *verts;
+		int num_verts = stbtt_GetGlyphShape(info, glyph, &verts);
+		data = (unsigned char *)STBTT_malloc(w * h, info->userdata);
+		precompute = (float *)STBTT_malloc(num_verts * sizeof(float), info->userdata);
+
+		for (i = 0, j = num_verts - 1; i < num_verts; j = i++)
+		{
+			if (verts[i].type == STBTT_vline)
+			{
+				float x0 = verts[i].x * scale_x, y0 = verts[i].y * scale_y;
+				float x1 = verts[j].x * scale_x, y1 = verts[j].y * scale_y;
+				float dist = (float)STBTT_sqrt((x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0));
+				precompute[i] = (dist == 0) ? 0.0f : 1.0f / dist;
+			}
+			else if (verts[i].type == STBTT_vcurve)
+			{
+				float x2 = verts[j].x * scale_x, y2 = verts[j].y * scale_y;
+				float x1 = verts[i].cx * scale_x, y1 = verts[i].cy * scale_y;
+				float x0 = verts[i].x * scale_x, y0 = verts[i].y * scale_y;
+				float bx = x0 - 2 * x1 + x2, by = y0 - 2 * y1 + y2;
+				float len2 = bx * bx + by * by;
+				if (len2 != 0.0f)
+					precompute[i] = 1.0f / (bx * bx + by * by);
+				else
+					precompute[i] = 0.0f;
+			}
+			else
+				precompute[i] = 0.0f;
+		}
+
+		for (y = iy0; y < iy1; ++y)
+		{
+			for (x = ix0; x < ix1; ++x)
+			{
+				float val;
+				float min_dist = 999999.0f;
+				float sx = (float)x + 0.5f;
+				float sy = (float)y + 0.5f;
+				float x_gspace = (sx / scale_x);
+				float y_gspace = (sy / scale_y);
+
+				int winding = stbtt__compute_crossings_x(x_gspace, y_gspace, num_verts, verts);  // @OPTIMIZE: this could just be a rasterization, but needs to be line vs. non-tesselated curves so a new path
+
+				for (i = 0; i < num_verts; ++i)
+				{
+					float x0 = verts[i].x * scale_x, y0 = verts[i].y * scale_y;
+
+					// check against every point here rather than inside line/curve primitives -- @TODO: wrong if multiple 'moves' in a row produce a garbage point, and given culling, probably more efficient to do within line/curve
+					float dist2 = (x0 - sx) * (x0 - sx) + (y0 - sy) * (y0 - sy);
+					if (dist2 < min_dist * min_dist)
+						min_dist = (float)STBTT_sqrt(dist2);
+
+					if (verts[i].type == STBTT_vline)
+					{
+						float x1 = verts[i - 1].x * scale_x, y1 = verts[i - 1].y * scale_y;
+
+						// coarse culling against bbox
+						//if (sx > STBTT_min(x0,x1)-min_dist && sx < STBTT_max(x0,x1)+min_dist &&
+						//    sy > STBTT_min(y0,y1)-min_dist && sy < STBTT_max(y0,y1)+min_dist)
+						float dist = (float)STBTT_fabs((x1 - x0) * (y0 - sy) - (y1 - y0) * (x0 - sx)) * precompute[i];
+						STBTT_assert(i != 0);
+						if (dist < min_dist)
+						{
+							// check position along line
+							// x' = x0 + t*(x1-x0), y' = y0 + t*(y1-y0)
+							// minimize (x'-sx)*(x'-sx)+(y'-sy)*(y'-sy)
+							float dx = x1 - x0, dy = y1 - y0;
+							float px = x0 - sx, py = y0 - sy;
+							// minimize (px+t*dx)^2 + (py+t*dy)^2 = px*px + 2*px*dx*t + t^2*dx*dx + py*py + 2*py*dy*t + t^2*dy*dy
+							// derivative: 2*px*dx + 2*py*dy + (2*dx*dx+2*dy*dy)*t, set to 0 and solve
+							float t = -(px * dx + py * dy) / (dx * dx + dy * dy);
+							if (t >= 0.0f && t <= 1.0f)
+								min_dist = dist;
+						}
+					}
+					else if (verts[i].type == STBTT_vcurve)
+					{
+						float x2 = verts[i - 1].x * scale_x, y2 = verts[i - 1].y * scale_y;
+						float x1 = verts[i].cx * scale_x, y1 = verts[i].cy * scale_y;
+						float box_x0 = STBTT_min(STBTT_min(x0, x1), x2);
+						float box_y0 = STBTT_min(STBTT_min(y0, y1), y2);
+						float box_x1 = STBTT_max(STBTT_max(x0, x1), x2);
+						float box_y1 = STBTT_max(STBTT_max(y0, y1), y2);
+						// coarse culling against bbox to avoid computing cubic unnecessarily
+						if (sx > box_x0 - min_dist && sx < box_x1 + min_dist && sy > box_y0 - min_dist && sy < box_y1 + min_dist)
+						{
+							int num = 0;
+							float ax = x1 - x0, ay = y1 - y0;
+							float bx = x0 - 2 * x1 + x2, by = y0 - 2 * y1 + y2;
+							float mx = x0 - sx, my = y0 - sy;
+							float res[3], px, py, t, it;
+							float a_inv = precompute[i];
+							if (a_inv == 0.0)
+							{  // if a_inv is 0, it's 2nd degree so use quadratic formula
+								float a = 3 * (ax * bx + ay * by);
+								float b = 2 * (ax * ax + ay * ay) + (mx * bx + my * by);
+								float c = mx * ax + my * ay;
+								if (a == 0.0)
+								{  // if a is 0, it's linear
+									if (b != 0.0)
+									{
+										res[num++] = -c / b;
+									}
+								}
+								else
+								{
+									float discriminant = b * b - 4 * a * c;
+									if (discriminant < 0)
+										num = 0;
+									else
+									{
+										float root = (float)STBTT_sqrt(discriminant);
+										res[0] = (-b - root) / (2 * a);
+										res[1] = (-b + root) / (2 * a);
+										num = 2;  // don't bother distinguishing 1-solution case, as code below will still work
+									}
+								}
+							}
+							else
+							{
+								float b = 3 * (ax * bx + ay * by) * a_inv;  // could precompute this as it doesn't depend on sample point
+								float c = (2 * (ax * ax + ay * ay) + (mx * bx + my * by)) * a_inv;
+								float d = (mx * ax + my * ay) * a_inv;
+								num = stbtt__solve_cubic(b, c, d, res);
+							}
+							if (num >= 1 && res[0] >= 0.0f && res[0] <= 1.0f)
+							{
+								t = res[0], it = 1.0f - t;
+								px = it * it * x0 + 2 * t * it * x1 + t * t * x2;
+								py = it * it * y0 + 2 * t * it * y1 + t * t * y2;
+								dist2 = (px - sx) * (px - sx) + (py - sy) * (py - sy);
+								if (dist2 < min_dist * min_dist)
+									min_dist = (float)STBTT_sqrt(dist2);
+							}
+							if (num >= 2 && res[1] >= 0.0f && res[1] <= 1.0f)
+							{
+								t = res[1], it = 1.0f - t;
+								px = it * it * x0 + 2 * t * it * x1 + t * t * x2;
+								py = it * it * y0 + 2 * t * it * y1 + t * t * y2;
+								dist2 = (px - sx) * (px - sx) + (py - sy) * (py - sy);
+								if (dist2 < min_dist * min_dist)
+									min_dist = (float)STBTT_sqrt(dist2);
+							}
+							if (num >= 3 && res[2] >= 0.0f && res[2] <= 1.0f)
+							{
+								t = res[2], it = 1.0f - t;
+								px = it * it * x0 + 2 * t * it * x1 + t * t * x2;
+								py = it * it * y0 + 2 * t * it * y1 + t * t * y2;
+								dist2 = (px - sx) * (px - sx) + (py - sy) * (py - sy);
+								if (dist2 < min_dist * min_dist)
+									min_dist = (float)STBTT_sqrt(dist2);
+							}
+						}
+					}
+				}
+				if (winding == 0)
+					min_dist = -min_dist;  // if outside the shape, value is negative
+				val = onedge_value + pixel_dist_scale * min_dist;
+				if (val < 0)
+					val = 0;
+				else if (val > 255)
+					val = 255;
+				data[(y - iy0) * w + (x - ix0)] = (unsigned char)val;
+			}
+		}
+		STBTT_free(precompute, info->userdata);
+		STBTT_free(verts, info->userdata);
+	}
+	return data;
+}
+
+STBTT_DEF unsigned char *stbtt_GetCodepointSDF(const stbtt_fontinfo *info, float scale, int codepoint, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff)
+{
+	return stbtt_GetGlyphSDF(info, scale, stbtt_FindGlyphIndex(info, codepoint), padding, onedge_value, pixel_dist_scale, width, height, xoff, yoff);
+}
+
+STBTT_DEF void stbtt_FreeSDF(unsigned char *bitmap, void *userdata)
+{
+	STBTT_free(bitmap, userdata);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// font name matching -- recommended not to use this
+//
+
+// check if a utf8 string contains a prefix which is the utf16 string; if so return length of matching utf8 string
+static stbtt_int32 stbtt__CompareUTF8toUTF16_bigendian_prefix(stbtt_uint8 *s1, stbtt_int32 len1, stbtt_uint8 *s2, stbtt_int32 len2)
+{
+	stbtt_int32 i = 0;
+
+	// convert utf16 to utf8 and compare the results while converting
+	while (len2)
+	{
+		stbtt_uint16 ch = s2[0] * 256 + s2[1];
+		if (ch < 0x80)
+		{
+			if (i >= len1) return -1;
+			if (s1[i++] != ch) return -1;
+		}
+		else if (ch < 0x800)
+		{
+			if (i + 1 >= len1) return -1;
+			if (s1[i++] != 0xc0 + (ch >> 6)) return -1;
+			if (s1[i++] != 0x80 + (ch & 0x3f)) return -1;
+		}
+		else if (ch >= 0xd800 && ch < 0xdc00)
+		{
+			stbtt_uint32 c;
+			stbtt_uint16 ch2 = s2[2] * 256 + s2[3];
+			if (i + 3 >= len1) return -1;
+			c = ((ch - 0xd800) << 10) + (ch2 - 0xdc00) + 0x10000;
+			if (s1[i++] != 0xf0 + (c >> 18)) return -1;
+			if (s1[i++] != 0x80 + ((c >> 12) & 0x3f)) return -1;
+			if (s1[i++] != 0x80 + ((c >> 6) & 0x3f)) return -1;
+			if (s1[i++] != 0x80 + ((c)&0x3f)) return -1;
+			s2 += 2;  // plus another 2 below
+			len2 -= 2;
+		}
+		else if (ch >= 0xdc00 && ch < 0xe000)
+		{
+			return -1;
+		}
+		else
+		{
+			if (i + 2 >= len1) return -1;
+			if (s1[i++] != 0xe0 + (ch >> 12)) return -1;
+			if (s1[i++] != 0x80 + ((ch >> 6) & 0x3f)) return -1;
+			if (s1[i++] != 0x80 + ((ch)&0x3f)) return -1;
+		}
+		s2 += 2;
+		len2 -= 2;
+	}
+	return i;
+}
+
+static int stbtt_CompareUTF8toUTF16_bigendian_internal(char *s1, int len1, char *s2, int len2)
+{
+	return len1 == stbtt__CompareUTF8toUTF16_bigendian_prefix((stbtt_uint8 *)s1, len1, (stbtt_uint8 *)s2, len2);
+}
+
+// returns results in whatever encoding you request... but note that 2-byte encodings
+// will be BIG-ENDIAN... use stbtt_CompareUTF8toUTF16_bigendian() to compare
+STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID)
+{
+	stbtt_int32 i, count, stringOffset;
+	stbtt_uint8 *fc = font->data;
+	stbtt_uint32 offset = font->fontstart;
+	stbtt_uint32 nm = stbtt__find_table(fc, offset, "name");
+	if (!nm) return NULL;
+
+	count = ttUSHORT(fc + nm + 2);
+	stringOffset = nm + ttUSHORT(fc + nm + 4);
+	for (i = 0; i < count; ++i)
+	{
+		stbtt_uint32 loc = nm + 6 + 12 * i;
+		if (platformID == ttUSHORT(fc + loc + 0) && encodingID == ttUSHORT(fc + loc + 2) && languageID == ttUSHORT(fc + loc + 4) && nameID == ttUSHORT(fc + loc + 6))
+		{
+			*length = ttUSHORT(fc + loc + 8);
+			return (const char *)(fc + stringOffset + ttUSHORT(fc + loc + 10));
+		}
+	}
+	return NULL;
+}
+
+static int stbtt__matchpair(stbtt_uint8 *fc, stbtt_uint32 nm, stbtt_uint8 *name, stbtt_int32 nlen, stbtt_int32 target_id, stbtt_int32 next_id)
+{
+	stbtt_int32 i;
+	stbtt_int32 count = ttUSHORT(fc + nm + 2);
+	stbtt_int32 stringOffset = nm + ttUSHORT(fc + nm + 4);
+
+	for (i = 0; i < count; ++i)
+	{
+		stbtt_uint32 loc = nm + 6 + 12 * i;
+		stbtt_int32 id = ttUSHORT(fc + loc + 6);
+		if (id == target_id)
+		{
+			// find the encoding
+			stbtt_int32 platform = ttUSHORT(fc + loc + 0), encoding = ttUSHORT(fc + loc + 2), language = ttUSHORT(fc + loc + 4);
+
+			// is this a Unicode encoding?
+			if (platform == 0 || (platform == 3 && encoding == 1) || (platform == 3 && encoding == 10))
+			{
+				stbtt_int32 slen = ttUSHORT(fc + loc + 8);
+				stbtt_int32 off = ttUSHORT(fc + loc + 10);
+
+				// check if there's a prefix match
+				stbtt_int32 matchlen = stbtt__CompareUTF8toUTF16_bigendian_prefix(name, nlen, fc + stringOffset + off, slen);
+				if (matchlen >= 0)
+				{
+					// check for target_id+1 immediately following, with same encoding & language
+					if (i + 1 < count && ttUSHORT(fc + loc + 12 + 6) == next_id && ttUSHORT(fc + loc + 12) == platform && ttUSHORT(fc + loc + 12 + 2) == encoding && ttUSHORT(fc + loc + 12 + 4) == language)
+					{
+						slen = ttUSHORT(fc + loc + 12 + 8);
+						off = ttUSHORT(fc + loc + 12 + 10);
+						if (slen == 0)
+						{
+							if (matchlen == nlen)
+								return 1;
+						}
+						else if (matchlen < nlen && name[matchlen] == ' ')
+						{
+							++matchlen;
+							if (stbtt_CompareUTF8toUTF16_bigendian_internal((char *)(name + matchlen), nlen - matchlen, (char *)(fc + stringOffset + off), slen))
+								return 1;
+						}
+					}
+					else
+					{
+						// if nothing immediately following
+						if (matchlen == nlen)
+							return 1;
+					}
+				}
+			}
+
+			// @TODO handle other encodings
+		}
+	}
+	return 0;
+}
+
+static int stbtt__matches(stbtt_uint8 *fc, stbtt_uint32 offset, stbtt_uint8 *name, stbtt_int32 flags)
+{
+	stbtt_int32 nlen = (stbtt_int32)STBTT_strlen((char *)name);
+	stbtt_uint32 nm, hd;
+	if (!stbtt__isfont(fc + offset)) return 0;
+
+	// check italics/bold/underline flags in macStyle...
+	if (flags)
+	{
+		hd = stbtt__find_table(fc, offset, "head");
+		if ((ttUSHORT(fc + hd + 44) & 7) != (flags & 7)) return 0;
+	}
+
+	nm = stbtt__find_table(fc, offset, "name");
+	if (!nm) return 0;
+
+	if (flags)
+	{
+		// if we checked the macStyle flags, then just check the family and ignore the subfamily
+		if (stbtt__matchpair(fc, nm, name, nlen, 16, -1)) return 1;
+		if (stbtt__matchpair(fc, nm, name, nlen, 1, -1)) return 1;
+		if (stbtt__matchpair(fc, nm, name, nlen, 3, -1)) return 1;
+	}
+	else
+	{
+		if (stbtt__matchpair(fc, nm, name, nlen, 16, 17)) return 1;
+		if (stbtt__matchpair(fc, nm, name, nlen, 1, 2)) return 1;
+		if (stbtt__matchpair(fc, nm, name, nlen, 3, -1)) return 1;
+	}
+
+	return 0;
+}
+
+static int stbtt_FindMatchingFont_internal(unsigned char *font_collection, char *name_utf8, stbtt_int32 flags)
+{
+	stbtt_int32 i;
+	for (i = 0;; ++i)
+	{
+		stbtt_int32 off = stbtt_GetFontOffsetForIndex(font_collection, i);
+		if (off < 0) return off;
+		if (stbtt__matches((stbtt_uint8 *)font_collection, off, (stbtt_uint8 *)name_utf8, flags))
+			return off;
+	}
+}
+
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-qual"
+#endif
+
+STBTT_DEF int stbtt_BakeFontBitmap(const unsigned char *data, int offset,
+								   float pixel_height, unsigned char *pixels, int pw, int ph,
+								   int first_char, int num_chars, stbtt_bakedchar *chardata)
+{
+	return stbtt_BakeFontBitmap_internal((unsigned char *)data, offset, pixel_height, pixels, pw, ph, first_char, num_chars, chardata);
+}
+
+STBTT_DEF int stbtt_GetFontOffsetForIndex(const unsigned char *data, int index)
+{
+	return stbtt_GetFontOffsetForIndex_internal((unsigned char *)data, index);
+}
+
+STBTT_DEF int stbtt_GetNumberOfFonts(const unsigned char *data)
+{
+	return stbtt_GetNumberOfFonts_internal((unsigned char *)data);
+}
+
+STBTT_DEF int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data, int offset)
+{
+	return stbtt_InitFont_internal(info, (unsigned char *)data, offset);
+}
+
+STBTT_DEF int stbtt_FindMatchingFont(const unsigned char *fontdata, const char *name, int flags)
+{
+	return stbtt_FindMatchingFont_internal((unsigned char *)fontdata, (char *)name, flags);
+}
+
+STBTT_DEF int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2)
+{
+	return stbtt_CompareUTF8toUTF16_bigendian_internal((char *)s1, len1, (char *)s2, len2);
+}
+
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+
+#endif  // STB_TRUETYPE_IMPLEMENTATION
+
+// FULL VERSION HISTORY
+//
+//   1.19 (2018-02-11) OpenType GPOS kerning (horizontal only), STBTT_fmod
+//   1.18 (2018-01-29) add missing function
+//   1.17 (2017-07-23) make more arguments const; doc fix
+//   1.16 (2017-07-12) SDF support
+//   1.15 (2017-03-03) make more arguments const
+//   1.14 (2017-01-16) num-fonts-in-TTC function
+//   1.13 (2017-01-02) support OpenType fonts, certain Apple fonts
+//   1.12 (2016-10-25) suppress warnings about casting away const with -Wcast-qual
+//   1.11 (2016-04-02) fix unused-variable warning
+//   1.10 (2016-04-02) allow user-defined fabs() replacement
+//                     fix memory leak if fontsize=0.0
+//                     fix warning from duplicate typedef
+//   1.09 (2016-01-16) warning fix; avoid crash on outofmem; use alloc userdata for PackFontRanges
+//   1.08 (2015-09-13) document stbtt_Rasterize(); fixes for vertical & horizontal edges
+//   1.07 (2015-08-01) allow PackFontRanges to accept arrays of sparse codepoints;
+//                     allow PackFontRanges to pack and render in separate phases;
+//                     fix stbtt_GetFontOFfsetForIndex (never worked for non-0 input?);
+//                     fixed an assert() bug in the new rasterizer
+//                     replace assert() with STBTT_assert() in new rasterizer
+//   1.06 (2015-07-14) performance improvements (~35% faster on x86 and x64 on test machine)
+//                     also more precise AA rasterizer, except if shapes overlap
+//                     remove need for STBTT_sort
+//   1.05 (2015-04-15) fix misplaced definitions for STBTT_STATIC
+//   1.04 (2015-04-15) typo in example
+//   1.03 (2015-04-12) STBTT_STATIC, fix memory leak in new packing, various fixes
+//   1.02 (2014-12-10) fix various warnings & compile issues w/ stb_rect_pack, C++
+//   1.01 (2014-12-08) fix subpixel position when oversampling to exactly match
+//                        non-oversampled; STBTT_POINT_SIZE for packed case only
+//   1.00 (2014-12-06) add new PackBegin etc. API, w/ support for oversampling
+//   0.99 (2014-09-18) fix multiple bugs with subpixel rendering (ryg)
+//   0.9  (2014-08-07) support certain mac/iOS fonts without an MS platformID
+//   0.8b (2014-07-07) fix a warning
+//   0.8  (2014-05-25) fix a few more warnings
+//   0.7  (2013-09-25) bugfix: subpixel glyph bug fixed in 0.5 had come back
+//   0.6c (2012-07-24) improve documentation
+//   0.6b (2012-07-20) fix a few more warnings
+//   0.6  (2012-07-17) fix warnings; added stbtt_ScaleForMappingEmToPixels,
+//                        stbtt_GetFontBoundingBox, stbtt_IsGlyphEmpty
+//   0.5  (2011-12-09) bugfixes:
+//                        subpixel glyph renderer computed wrong bounding box
+//                        first vertex of shape can be off-curve (FreeSans)
+//   0.4b (2011-12-03) fixed an error in the font baking example
+//   0.4  (2011-12-01) kerning, subpixel rendering (tor)
+//                    bugfixes for:
+//                        codepoint-to-glyph conversion using table fmt=12
+//                        codepoint-to-glyph conversion using table fmt=4
+//                        stbtt_GetBakedQuad with non-square texture (Zer)
+//                    updated Hello World! sample to use kerning and subpixel
+//                    fixed some warnings
+//   0.3  (2009-06-24) cmap fmt=12, compound shapes (MM)
+//                    userdata, malloc-from-userdata, non-zero fill (stb)
+//   0.2  (2009-03-11) Fix unsigned/signed char warnings
+//   0.1  (2009-03-09) First public release
+//
+
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+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.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this 
+software, either in source code form or as a compiled binary, for any purpose, 
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this 
+software dedicate any and all copyright interest in the software to the public 
+domain. We make this dedication for the benefit of the public at large and to 
+the detriment of our heirs and successors. We intend this dedication to be an 
+overt act of relinquishment in perpetuity of all present and future rights to 
+this software under copyright law.
+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 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.
+------------------------------------------------------------------------------
+*/
diff --git a/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lapi.h b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lapi.h
new file mode 100644
index 00000000..bf13633b
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lapi.h
@@ -0,0 +1,28 @@
+/*
+** $Id: lapi.h,v 2.7.1.1 2013/04/12 18:48:47 roberto Exp $
+** Auxiliary functions from Lua API
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lapi_h
+#define lapi_h
+
+#include "llimits.h"
+#include "lstate.h"
+
+#define api_incr_top(L)                    \
+	{                                      \
+		L->top++;                          \
+		api_check(L, L->top <= L->ci->top, \
+				  "stack overflow");       \
+	}
+
+#define adjustresults(L, nres)                                                 \
+	{                                                                          \
+		if ((nres) == LUA_MULTRET && L->ci->top < L->top) L->ci->top = L->top; \
+	}
+
+#define api_checknelems(L, n) api_check(L, (n) < (L->top - L->ci->func), \
+										"not enough elements in the stack")
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lauxlib.h b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lauxlib.h
new file mode 100644
index 00000000..88339d43
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lauxlib.h
@@ -0,0 +1,198 @@
+/*
+** $Id: lauxlib.h,v 1.120.1.1 2013/04/12 18:48:47 roberto Exp $
+** Auxiliary functions for building Lua libraries
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lauxlib_h
+#define lauxlib_h
+
+#include <stddef.h>
+#include <stdio.h>
+
+#include "lua.h"
+
+/* extra error code for `luaL_load' */
+#define LUA_ERRFILE (LUA_ERRERR + 1)
+
+typedef struct luaL_Reg
+{
+	const char *name;
+	lua_CFunction func;
+} luaL_Reg;
+
+LUALIB_API void(luaL_checkversion_)(lua_State *L, lua_Number ver);
+#define luaL_checkversion(L) luaL_checkversion_(L, LUA_VERSION_NUM)
+
+LUALIB_API int(luaL_getmetafield)(lua_State *L, int obj, const char *e);
+LUALIB_API int(luaL_callmeta)(lua_State *L, int obj, const char *e);
+LUALIB_API const char *(luaL_tolstring)(lua_State *L, int idx, size_t *len);
+LUALIB_API int(luaL_argerror)(lua_State *L, int numarg, const char *extramsg);
+LUALIB_API const char *(luaL_checklstring)(lua_State *L, int numArg,
+										   size_t *l);
+LUALIB_API const char *(luaL_optlstring)(lua_State *L, int numArg,
+										 const char *def, size_t *l);
+LUALIB_API lua_Number(luaL_checknumber)(lua_State *L, int numArg);
+LUALIB_API lua_Number(luaL_optnumber)(lua_State *L, int nArg, lua_Number def);
+
+LUALIB_API lua_Integer(luaL_checkinteger)(lua_State *L, int numArg);
+LUALIB_API lua_Integer(luaL_optinteger)(lua_State *L, int nArg,
+										lua_Integer def);
+LUALIB_API lua_Unsigned(luaL_checkunsigned)(lua_State *L, int numArg);
+LUALIB_API lua_Unsigned(luaL_optunsigned)(lua_State *L, int numArg,
+										  lua_Unsigned def);
+
+LUALIB_API void(luaL_checkstack)(lua_State *L, int sz, const char *msg);
+LUALIB_API void(luaL_checktype)(lua_State *L, int narg, int t);
+LUALIB_API void(luaL_checkany)(lua_State *L, int narg);
+
+LUALIB_API int(luaL_newmetatable)(lua_State *L, const char *tname);
+LUALIB_API void(luaL_setmetatable)(lua_State *L, const char *tname);
+LUALIB_API void *(luaL_testudata)(lua_State *L, int ud, const char *tname);
+LUALIB_API void *(luaL_checkudata)(lua_State *L, int ud, const char *tname);
+
+LUALIB_API void(luaL_where)(lua_State *L, int lvl);
+LUALIB_API int(luaL_error)(lua_State *L, const char *fmt, ...);
+
+LUALIB_API int(luaL_checkoption)(lua_State *L, int narg, const char *def,
+								 const char *const lst[]);
+
+LUALIB_API int(luaL_fileresult)(lua_State *L, int stat, const char *fname);
+LUALIB_API int(luaL_execresult)(lua_State *L, int stat);
+
+/* pre-defined references */
+#define LUA_NOREF (-2)
+#define LUA_REFNIL (-1)
+
+LUALIB_API int(luaL_ref)(lua_State *L, int t);
+LUALIB_API void(luaL_unref)(lua_State *L, int t, int ref);
+
+LUALIB_API int(luaL_loadfilex)(lua_State *L, const char *filename,
+							   const char *mode);
+
+#define luaL_loadfile(L, f) luaL_loadfilex(L, f, NULL)
+
+LUALIB_API int(luaL_loadbufferx)(lua_State *L, const char *buff, size_t sz,
+								 const char *name, const char *mode);
+LUALIB_API int(luaL_loadstring)(lua_State *L, const char *s);
+
+LUALIB_API lua_State *(luaL_newstate)(void);
+
+LUALIB_API int(luaL_len)(lua_State *L, int idx);
+
+LUALIB_API const char *(luaL_gsub)(lua_State *L, const char *s, const char *p,
+								   const char *r);
+
+LUALIB_API void(luaL_setfuncs)(lua_State *L, const luaL_Reg *l, int nup);
+
+LUALIB_API int(luaL_getsubtable)(lua_State *L, int idx, const char *fname);
+
+LUALIB_API void(luaL_traceback)(lua_State *L, lua_State *L1,
+								const char *msg, int level);
+
+LUALIB_API void(luaL_requiref)(lua_State *L, const char *modname,
+							   lua_CFunction openf, int glb);
+
+/*
+** ===============================================================
+** some useful macros
+** ===============================================================
+*/
+
+#define luaL_newlibtable(L, l) \
+	lua_createtable(L, 0, sizeof(l) / sizeof((l)[0]) - 1)
+
+#define luaL_newlib(L, l) (luaL_newlibtable(L, l), luaL_setfuncs(L, l, 0))
+
+#define luaL_argcheck(L, cond, numarg, extramsg) \
+	((void)((cond) || luaL_argerror(L, (numarg), (extramsg))))
+#define luaL_checkstring(L, n) (luaL_checklstring(L, (n), NULL))
+#define luaL_optstring(L, n, d) (luaL_optlstring(L, (n), (d), NULL))
+#define luaL_checkint(L, n) ((int)luaL_checkinteger(L, (n)))
+#define luaL_optint(L, n, d) ((int)luaL_optinteger(L, (n), (d)))
+#define luaL_checklong(L, n) ((long)luaL_checkinteger(L, (n)))
+#define luaL_optlong(L, n, d) ((long)luaL_optinteger(L, (n), (d)))
+
+#define luaL_typename(L, i) lua_typename(L, lua_type(L, (i)))
+
+#define luaL_dofile(L, fn) \
+	(luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))
+
+#define luaL_dostring(L, s) \
+	(luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0))
+
+#define luaL_getmetatable(L, n) (lua_getfield(L, LUA_REGISTRYINDEX, (n)))
+
+#define luaL_opt(L, f, n, d) (lua_isnoneornil(L, (n)) ? (d) : f(L, (n)))
+
+#define luaL_loadbuffer(L, s, sz, n) luaL_loadbufferx(L, s, sz, n, NULL)
+
+/*
+** {======================================================
+** Generic Buffer manipulation
+** =======================================================
+*/
+
+typedef struct luaL_Buffer
+{
+	char *b;     /* buffer address */
+	size_t size; /* buffer size */
+	size_t n;    /* number of characters in buffer */
+	lua_State *L;
+	char initb[LUAL_BUFFERSIZE]; /* initial buffer */
+} luaL_Buffer;
+
+#define luaL_addchar(B, c)                                    \
+	((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \
+	 ((B)->b[(B)->n++] = (c)))
+
+#define luaL_addsize(B, s) ((B)->n += (s))
+
+LUALIB_API void(luaL_buffinit)(lua_State *L, luaL_Buffer *B);
+LUALIB_API char *(luaL_prepbuffsize)(luaL_Buffer *B, size_t sz);
+LUALIB_API void(luaL_addlstring)(luaL_Buffer *B, const char *s, size_t l);
+LUALIB_API void(luaL_addstring)(luaL_Buffer *B, const char *s);
+LUALIB_API void(luaL_addvalue)(luaL_Buffer *B);
+LUALIB_API void(luaL_pushresult)(luaL_Buffer *B);
+LUALIB_API void(luaL_pushresultsize)(luaL_Buffer *B, size_t sz);
+LUALIB_API char *(luaL_buffinitsize)(lua_State *L, luaL_Buffer *B, size_t sz);
+
+#define luaL_prepbuffer(B) luaL_prepbuffsize(B, LUAL_BUFFERSIZE)
+
+/* }====================================================== */
+
+/*
+** {======================================================
+** File handles for IO library
+** =======================================================
+*/
+
+/*
+** A file handle is a userdata with metatable 'LUA_FILEHANDLE' and
+** initial structure 'luaL_Stream' (it may contain other fields
+** after that initial structure).
+*/
+
+#define LUA_FILEHANDLE "FILE*"
+
+typedef struct luaL_Stream
+{
+	FILE *f;              /* stream (NULL for incompletely created streams) */
+	lua_CFunction closef; /* to close stream (NULL for closed streams) */
+} luaL_Stream;
+
+/* }====================================================== */
+
+/* compatibility with old module system */
+#if defined(LUA_COMPAT_MODULE)
+
+LUALIB_API void(luaL_pushmodule)(lua_State *L, const char *modname,
+								 int sizehint);
+LUALIB_API void(luaL_openlib)(lua_State *L, const char *libname,
+							  const luaL_Reg *l, int nup);
+
+#define luaL_register(L, n, l) (luaL_openlib(L, (n), (l), 0))
+
+#endif
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lcode.h b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lcode.h
new file mode 100644
index 00000000..6ac8c548
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lcode.h
@@ -0,0 +1,95 @@
+/*
+** $Id: lcode.h,v 1.58.1.1 2013/04/12 18:48:47 roberto Exp $
+** Code generator for Lua
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lcode_h
+#define lcode_h
+
+#include "llex.h"
+#include "lobject.h"
+#include "lopcodes.h"
+#include "lparser.h"
+
+/*
+** Marks the end of a patch list. It is an invalid value both as an absolute
+** address, and as a list link (would link an element to itself).
+*/
+#define NO_JUMP (-1)
+
+/*
+** grep "ORDER OPR" if you change these enums  (ORDER OP)
+*/
+typedef enum BinOpr
+{
+	OPR_ADD,
+	OPR_SUB,
+	OPR_MUL,
+	OPR_DIV,
+	OPR_MOD,
+	OPR_POW,
+	OPR_CONCAT,
+	OPR_EQ,
+	OPR_LT,
+	OPR_LE,
+	OPR_NE,
+	OPR_GT,
+	OPR_GE,
+	OPR_AND,
+	OPR_OR,
+	OPR_NOBINOPR
+} BinOpr;
+
+typedef enum UnOpr
+{
+	OPR_MINUS,
+	OPR_NOT,
+	OPR_LEN,
+	OPR_NOUNOPR
+} UnOpr;
+
+#define getcode(fs, e) ((fs)->f->code[(e)->u.info])
+
+#define luaK_codeAsBx(fs, o, A, sBx) luaK_codeABx(fs, o, A, (sBx) + MAXARG_sBx)
+
+#define luaK_setmultret(fs, e) luaK_setreturns(fs, e, LUA_MULTRET)
+
+#define luaK_jumpto(fs, t) luaK_patchlist(fs, luaK_jump(fs), t)
+
+LUAI_FUNC int luaK_codeABx(FuncState *fs, OpCode o, int A, unsigned int Bx);
+LUAI_FUNC int luaK_codeABC(FuncState *fs, OpCode o, int A, int B, int C);
+LUAI_FUNC int luaK_codek(FuncState *fs, int reg, int k);
+LUAI_FUNC void luaK_fixline(FuncState *fs, int line);
+LUAI_FUNC void luaK_nil(FuncState *fs, int from, int n);
+LUAI_FUNC void luaK_reserveregs(FuncState *fs, int n);
+LUAI_FUNC void luaK_checkstack(FuncState *fs, int n);
+LUAI_FUNC int luaK_stringK(FuncState *fs, TString *s);
+LUAI_FUNC int luaK_numberK(FuncState *fs, lua_Number r);
+LUAI_FUNC void luaK_dischargevars(FuncState *fs, expdesc *e);
+LUAI_FUNC int luaK_exp2anyreg(FuncState *fs, expdesc *e);
+LUAI_FUNC void luaK_exp2anyregup(FuncState *fs, expdesc *e);
+LUAI_FUNC void luaK_exp2nextreg(FuncState *fs, expdesc *e);
+LUAI_FUNC void luaK_exp2val(FuncState *fs, expdesc *e);
+LUAI_FUNC int luaK_exp2RK(FuncState *fs, expdesc *e);
+LUAI_FUNC void luaK_self(FuncState *fs, expdesc *e, expdesc *key);
+LUAI_FUNC void luaK_indexed(FuncState *fs, expdesc *t, expdesc *k);
+LUAI_FUNC void luaK_goiftrue(FuncState *fs, expdesc *e);
+LUAI_FUNC void luaK_goiffalse(FuncState *fs, expdesc *e);
+LUAI_FUNC void luaK_storevar(FuncState *fs, expdesc *var, expdesc *e);
+LUAI_FUNC void luaK_setreturns(FuncState *fs, expdesc *e, int nresults);
+LUAI_FUNC void luaK_setoneret(FuncState *fs, expdesc *e);
+LUAI_FUNC int luaK_jump(FuncState *fs);
+LUAI_FUNC void luaK_ret(FuncState *fs, int first, int nret);
+LUAI_FUNC void luaK_patchlist(FuncState *fs, int list, int target);
+LUAI_FUNC void luaK_patchtohere(FuncState *fs, int list);
+LUAI_FUNC void luaK_patchclose(FuncState *fs, int list, int level);
+LUAI_FUNC void luaK_concat(FuncState *fs, int *l1, int l2);
+LUAI_FUNC int luaK_getlabel(FuncState *fs);
+LUAI_FUNC void luaK_prefix(FuncState *fs, UnOpr op, expdesc *v, int line);
+LUAI_FUNC void luaK_infix(FuncState *fs, BinOpr op, expdesc *v);
+LUAI_FUNC void luaK_posfix(FuncState *fs, BinOpr op, expdesc *v1,
+						   expdesc *v2, int line);
+LUAI_FUNC void luaK_setlist(FuncState *fs, int base, int nelems, int tostore);
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lctype.h b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lctype.h
new file mode 100644
index 00000000..10f34bb0
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lctype.h
@@ -0,0 +1,86 @@
+/*
+** $Id: lctype.h,v 1.12.1.1 2013/04/12 18:48:47 roberto Exp $
+** 'ctype' functions for Lua
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lctype_h
+#define lctype_h
+
+#include "lua.h"
+
+/*
+** WARNING: the functions defined here do not necessarily correspond
+** to the similar functions in the standard C ctype.h. They are
+** optimized for the specific needs of Lua
+*/
+
+#if !defined(LUA_USE_CTYPE)
+
+#if 'A' == 65 && '0' == 48
+/* ASCII case: can use its own tables; faster and fixed */
+#define LUA_USE_CTYPE 0
+#else
+/* must use standard C ctype */
+#define LUA_USE_CTYPE 1
+#endif
+
+#endif
+
+#if !LUA_USE_CTYPE /* { */
+
+#include <limits.h>
+
+#include "llimits.h"
+
+#define ALPHABIT 0
+#define DIGITBIT 1
+#define PRINTBIT 2
+#define SPACEBIT 3
+#define XDIGITBIT 4
+
+#define MASK(B) (1 << (B))
+
+/*
+** add 1 to char to allow index -1 (EOZ)
+*/
+#define testprop(c, p) (luai_ctype_[(c) + 1] & (p))
+
+/*
+** 'lalpha' (Lua alphabetic) and 'lalnum' (Lua alphanumeric) both include '_'
+*/
+#define lislalpha(c) testprop(c, MASK(ALPHABIT))
+#define lislalnum(c) testprop(c, (MASK(ALPHABIT) | MASK(DIGITBIT)))
+#define lisdigit(c) testprop(c, MASK(DIGITBIT))
+#define lisspace(c) testprop(c, MASK(SPACEBIT))
+#define lisprint(c) testprop(c, MASK(PRINTBIT))
+#define lisxdigit(c) testprop(c, MASK(XDIGITBIT))
+
+/*
+** this 'ltolower' only works for alphabetic characters
+*/
+#define ltolower(c) ((c) | ('A' ^ 'a'))
+
+/* two more entries for 0 and -1 (EOZ) */
+LUAI_DDEC const lu_byte luai_ctype_[UCHAR_MAX + 2];
+
+#else /* }{ */
+
+/*
+** use standard C ctypes
+*/
+
+#include <ctype.h>
+
+#define lislalpha(c) (isalpha(c) || (c) == '_')
+#define lislalnum(c) (isalnum(c) || (c) == '_')
+#define lisdigit(c) (isdigit(c))
+#define lisspace(c) (isspace(c))
+#define lisprint(c) (isprint(c))
+#define lisxdigit(c) (isxdigit(c))
+
+#define ltolower(c) (tolower(c))
+
+#endif /* } */
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/ldebug.h b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/ldebug.h
new file mode 100644
index 00000000..9514ee12
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/ldebug.h
@@ -0,0 +1,31 @@
+/*
+** $Id: ldebug.h,v 2.7.1.1 2013/04/12 18:48:47 roberto Exp $
+** Auxiliary functions from Debug Interface module
+** See Copyright Notice in lua.h
+*/
+
+#ifndef ldebug_h
+#define ldebug_h
+
+#include "lstate.h"
+
+#define pcRel(pc, p) (cast(int, (pc) - (p)->code) - 1)
+
+#define getfuncline(f, pc) (((f)->lineinfo) ? (f)->lineinfo[pc] : 0)
+
+#define resethookcount(L) (L->hookcount = L->basehookcount)
+
+/* Active Lua function (given call info) */
+#define ci_func(ci) (clLvalue((ci)->func))
+
+LUAI_FUNC l_noret luaG_typeerror(lua_State *L, const TValue *o,
+								 const char *opname);
+LUAI_FUNC l_noret luaG_concaterror(lua_State *L, StkId p1, StkId p2);
+LUAI_FUNC l_noret luaG_aritherror(lua_State *L, const TValue *p1,
+								  const TValue *p2);
+LUAI_FUNC l_noret luaG_ordererror(lua_State *L, const TValue *p1,
+								  const TValue *p2);
+LUAI_FUNC l_noret luaG_runerror(lua_State *L, const char *fmt, ...);
+LUAI_FUNC l_noret luaG_errormsg(lua_State *L);
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/ldo.h b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/ldo.h
new file mode 100644
index 00000000..09204d16
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/ldo.h
@@ -0,0 +1,48 @@
+/*
+** $Id: ldo.h,v 2.20.1.1 2013/04/12 18:48:47 roberto Exp $
+** Stack and Call structure of Lua
+** See Copyright Notice in lua.h
+*/
+
+#ifndef ldo_h
+#define ldo_h
+
+#include "lobject.h"
+#include "lstate.h"
+#include "lzio.h"
+
+#define luaD_checkstack(L, n)          \
+	if (L->stack_last - L->top <= (n)) \
+		luaD_growstack(L, n);          \
+	else                               \
+		condmovestack(L);
+
+#define incr_top(L)            \
+	{                          \
+		L->top++;              \
+		luaD_checkstack(L, 0); \
+	}
+
+#define savestack(L, p) ((char *)(p) - (char *)L->stack)
+#define restorestack(L, n) ((TValue *)((char *)L->stack + (n)))
+
+/* type of protected functions, to be ran by `runprotected' */
+typedef void (*Pfunc)(lua_State *L, void *ud);
+
+LUAI_FUNC int luaD_protectedparser(lua_State *L, ZIO *z, const char *name,
+								   const char *mode);
+LUAI_FUNC void luaD_hook(lua_State *L, int event, int line);
+LUAI_FUNC int luaD_precall(lua_State *L, StkId func, int nresults);
+LUAI_FUNC void luaD_call(lua_State *L, StkId func, int nResults,
+						 int allowyield);
+LUAI_FUNC int luaD_pcall(lua_State *L, Pfunc func, void *u,
+						 ptrdiff_t oldtop, ptrdiff_t ef);
+LUAI_FUNC int luaD_poscall(lua_State *L, StkId firstResult);
+LUAI_FUNC void luaD_reallocstack(lua_State *L, int newsize);
+LUAI_FUNC void luaD_growstack(lua_State *L, int n);
+LUAI_FUNC void luaD_shrinkstack(lua_State *L);
+
+LUAI_FUNC l_noret luaD_throw(lua_State *L, int errcode);
+LUAI_FUNC int luaD_rawrunprotected(lua_State *L, Pfunc f, void *ud);
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lfunc.h b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lfunc.h
new file mode 100644
index 00000000..d7d26e67
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lfunc.h
@@ -0,0 +1,29 @@
+/*
+** $Id: lfunc.h,v 2.8.1.1 2013/04/12 18:48:47 roberto Exp $
+** Auxiliary functions to manipulate prototypes and closures
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lfunc_h
+#define lfunc_h
+
+#include "lobject.h"
+
+#define sizeCclosure(n) (cast(int, sizeof(CClosure)) + \
+						 cast(int, sizeof(TValue) * ((n)-1)))
+
+#define sizeLclosure(n) (cast(int, sizeof(LClosure)) + \
+						 cast(int, sizeof(TValue *) * ((n)-1)))
+
+LUAI_FUNC Proto *luaF_newproto(lua_State *L);
+LUAI_FUNC Closure *luaF_newCclosure(lua_State *L, int nelems);
+LUAI_FUNC Closure *luaF_newLclosure(lua_State *L, int nelems);
+LUAI_FUNC UpVal *luaF_newupval(lua_State *L);
+LUAI_FUNC UpVal *luaF_findupval(lua_State *L, StkId level);
+LUAI_FUNC void luaF_close(lua_State *L, StkId level);
+LUAI_FUNC void luaF_freeproto(lua_State *L, Proto *f);
+LUAI_FUNC void luaF_freeupval(lua_State *L, UpVal *uv);
+LUAI_FUNC const char *luaF_getlocalname(const Proto *func, int local_number,
+										int pc);
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lgc.h b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lgc.h
new file mode 100644
index 00000000..e2514f4e
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lgc.h
@@ -0,0 +1,164 @@
+/*
+** $Id: lgc.h,v 2.58.1.1 2013/04/12 18:48:47 roberto Exp $
+** Garbage Collector
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lgc_h
+#define lgc_h
+
+#include "lobject.h"
+#include "lstate.h"
+
+/*
+** Collectable objects may have one of three colors: white, which
+** means the object is not marked; gray, which means the
+** object is marked, but its references may be not marked; and
+** black, which means that the object and all its references are marked.
+** The main invariant of the garbage collector, while marking objects,
+** is that a black object can never point to a white one. Moreover,
+** any gray object must be in a "gray list" (gray, grayagain, weak,
+** allweak, ephemeron) so that it can be visited again before finishing
+** the collection cycle. These lists have no meaning when the invariant
+** is not being enforced (e.g., sweep phase).
+*/
+
+/* how much to allocate before next GC step */
+#if !defined(GCSTEPSIZE)
+/* ~100 small strings */
+#define GCSTEPSIZE (cast_int(100 * sizeof(TString)))
+#endif
+
+/*
+** Possible states of the Garbage Collector
+*/
+#define GCSpropagate 0
+#define GCSatomic 1
+#define GCSsweepstring 2
+#define GCSsweepudata 3
+#define GCSsweep 4
+#define GCSpause 5
+
+#define issweepphase(g) \
+	(GCSsweepstring <= (g)->gcstate && (g)->gcstate <= GCSsweep)
+
+#define isgenerational(g) ((g)->gckind == KGC_GEN)
+
+/*
+** macros to tell when main invariant (white objects cannot point to black
+** ones) must be kept. During a non-generational collection, the sweep
+** phase may break the invariant, as objects turned white may point to
+** still-black objects. The invariant is restored when sweep ends and
+** all objects are white again. During a generational collection, the
+** invariant must be kept all times.
+*/
+
+#define keepinvariant(g) (isgenerational(g) || g->gcstate <= GCSatomic)
+
+/*
+** Outside the collector, the state in generational mode is kept in
+** 'propagate', so 'keepinvariant' is always true.
+*/
+#define keepinvariantout(g)                                     \
+	check_exp(g->gcstate == GCSpropagate || !isgenerational(g), \
+			  g->gcstate <= GCSatomic)
+
+/*
+** some useful bit tricks
+*/
+#define resetbits(x, m) ((x) &= cast(lu_byte, ~(m)))
+#define setbits(x, m) ((x) |= (m))
+#define testbits(x, m) ((x) & (m))
+#define bitmask(b) (1 << (b))
+#define bit2mask(b1, b2) (bitmask(b1) | bitmask(b2))
+#define l_setbit(x, b) setbits(x, bitmask(b))
+#define resetbit(x, b) resetbits(x, bitmask(b))
+#define testbit(x, b) testbits(x, bitmask(b))
+
+/* Layout for bit use in `marked' field: */
+#define WHITE0BIT 0    /* object is white (type 0) */
+#define WHITE1BIT 1    /* object is white (type 1) */
+#define BLACKBIT 2     /* object is black */
+#define FINALIZEDBIT 3 /* object has been separated for finalization */
+#define SEPARATED 4    /* object is in 'finobj' list or in 'tobefnz' */
+#define FIXEDBIT 5     /* object is fixed (should not be collected) */
+#define OLDBIT 6       /* object is old (only in generational mode) */
+/* bit 7 is currently used by tests (luaL_checkmemory) */
+
+#define WHITEBITS bit2mask(WHITE0BIT, WHITE1BIT)
+
+#define iswhite(x) testbits((x)->gch.marked, WHITEBITS)
+#define isblack(x) testbit((x)->gch.marked, BLACKBIT)
+#define isgray(x) /* neither white nor black */ \
+	(!testbits((x)->gch.marked, WHITEBITS | bitmask(BLACKBIT)))
+
+#define isold(x) testbit((x)->gch.marked, OLDBIT)
+
+/* MOVE OLD rule: whenever an object is moved to the beginning of
+   a GC list, its old bit must be cleared */
+#define resetoldbit(o) resetbit((o)->gch.marked, OLDBIT)
+
+#define otherwhite(g) (g->currentwhite ^ WHITEBITS)
+#define isdeadm(ow, m) (!(((m) ^ WHITEBITS) & (ow)))
+#define isdead(g, v) isdeadm(otherwhite(g), (v)->gch.marked)
+
+#define changewhite(x) ((x)->gch.marked ^= WHITEBITS)
+#define gray2black(x) l_setbit((x)->gch.marked, BLACKBIT)
+
+#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x)))
+
+#define luaC_white(g) cast(lu_byte, (g)->currentwhite &WHITEBITS)
+
+#define luaC_condGC(L, c)     \
+	{                         \
+		if (G(L)->GCdebt > 0) \
+		{                     \
+			c;                \
+		};                    \
+		condchangemem(L);     \
+	}
+#define luaC_checkGC(L) luaC_condGC(L, luaC_step(L);)
+
+#define luaC_barrier(L, p, v)                         \
+	{                                                 \
+		if (valiswhite(v) && isblack(obj2gco(p)))     \
+			luaC_barrier_(L, obj2gco(p), gcvalue(v)); \
+	}
+
+#define luaC_barrierback(L, p, v)                 \
+	{                                             \
+		if (valiswhite(v) && isblack(obj2gco(p))) \
+			luaC_barrierback_(L, p);              \
+	}
+
+#define luaC_objbarrier(L, p, o)                        \
+	{                                                   \
+		if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) \
+			luaC_barrier_(L, obj2gco(p), obj2gco(o));   \
+	}
+
+#define luaC_objbarrierback(L, p, o)                                             \
+	{                                                                            \
+		if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) luaC_barrierback_(L, p); \
+	}
+
+#define luaC_barrierproto(L, p, c)                            \
+	{                                                         \
+		if (isblack(obj2gco(p))) luaC_barrierproto_(L, p, c); \
+	}
+
+LUAI_FUNC void luaC_freeallobjects(lua_State *L);
+LUAI_FUNC void luaC_step(lua_State *L);
+LUAI_FUNC void luaC_forcestep(lua_State *L);
+LUAI_FUNC void luaC_runtilstate(lua_State *L, int statesmask);
+LUAI_FUNC void luaC_fullgc(lua_State *L, int isemergency);
+LUAI_FUNC GCObject *luaC_newobj(lua_State *L, int tt, size_t sz,
+								GCObject **list, int offset);
+LUAI_FUNC void luaC_barrier_(lua_State *L, GCObject *o, GCObject *v);
+LUAI_FUNC void luaC_barrierback_(lua_State *L, GCObject *o);
+LUAI_FUNC void luaC_barrierproto_(lua_State *L, Proto *p, Closure *c);
+LUAI_FUNC void luaC_checkfinalizer(lua_State *L, GCObject *o, Table *mt);
+LUAI_FUNC void luaC_checkupvalcolor(global_State *g, UpVal *uv);
+LUAI_FUNC void luaC_changemode(lua_State *L, int mode);
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/llex.h b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/llex.h
new file mode 100644
index 00000000..29c50b8b
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/llex.h
@@ -0,0 +1,100 @@
+/*
+** $Id: llex.h,v 1.72.1.1 2013/04/12 18:48:47 roberto Exp $
+** Lexical Analyzer
+** See Copyright Notice in lua.h
+*/
+
+#ifndef llex_h
+#define llex_h
+
+#include "lobject.h"
+#include "lzio.h"
+
+#define FIRST_RESERVED 257
+
+/*
+* WARNING: if you change the order of this enumeration,
+* grep "ORDER RESERVED"
+*/
+enum RESERVED
+{
+	/* terminal symbols denoted by reserved words */
+	TK_AND = FIRST_RESERVED,
+	TK_BREAK,
+	TK_DO,
+	TK_ELSE,
+	TK_ELSEIF,
+	TK_END,
+	TK_FALSE,
+	TK_FOR,
+	TK_FUNCTION,
+	TK_GOTO,
+	TK_IF,
+	TK_IN,
+	TK_LOCAL,
+	TK_NIL,
+	TK_NOT,
+	TK_OR,
+	TK_REPEAT,
+	TK_RETURN,
+	TK_THEN,
+	TK_TRUE,
+	TK_UNTIL,
+	TK_WHILE,
+	/* other terminal symbols */
+	TK_CONCAT,
+	TK_DOTS,
+	TK_EQ,
+	TK_GE,
+	TK_LE,
+	TK_NE,
+	TK_DBCOLON,
+	TK_EOS,
+	TK_NUMBER,
+	TK_NAME,
+	TK_STRING
+};
+
+/* number of reserved words */
+#define NUM_RESERVED (cast(int, TK_WHILE - FIRST_RESERVED + 1))
+
+typedef union {
+	lua_Number r;
+	TString *ts;
+} SemInfo; /* semantics information */
+
+typedef struct Token
+{
+	int token;
+	SemInfo seminfo;
+} Token;
+
+/* state of the lexer plus state of the parser when shared by all
+   functions */
+typedef struct LexState
+{
+	int current;          /* current character (charint) */
+	int linenumber;       /* input line counter */
+	int lastline;         /* line of last token `consumed' */
+	Token t;              /* current token */
+	Token lookahead;      /* look ahead token */
+	struct FuncState *fs; /* current function (parser) */
+	struct lua_State *L;
+	ZIO *z;              /* input stream */
+	Mbuffer *buff;       /* buffer for tokens */
+	struct Dyndata *dyd; /* dynamic structures used by the parser */
+	TString *source;     /* current source name */
+	TString *envn;       /* environment variable name */
+	char decpoint;       /* locale decimal point */
+} LexState;
+
+LUAI_FUNC void luaX_init(lua_State *L);
+LUAI_FUNC void luaX_setinput(lua_State *L, LexState *ls, ZIO *z,
+							 TString *source, int firstchar);
+LUAI_FUNC TString *luaX_newstring(LexState *ls, const char *str, size_t l);
+LUAI_FUNC void luaX_next(LexState *ls);
+LUAI_FUNC int luaX_lookahead(LexState *ls);
+LUAI_FUNC l_noret luaX_syntaxerror(LexState *ls, const char *s);
+LUAI_FUNC const char *luaX_token2str(LexState *ls, int token);
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/llimits.h b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/llimits.h
new file mode 100644
index 00000000..3ecd7afe
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/llimits.h
@@ -0,0 +1,308 @@
+/*
+** $Id: llimits.h,v 1.103.1.1 2013/04/12 18:48:47 roberto Exp $
+** Limits, basic types, and some other `installation-dependent' definitions
+** See Copyright Notice in lua.h
+*/
+
+#ifndef llimits_h
+#define llimits_h
+
+#include <limits.h>
+#include <stddef.h>
+
+#include "lua.h"
+
+typedef unsigned LUA_INT32 lu_int32;
+
+typedef LUAI_UMEM lu_mem;
+
+typedef LUAI_MEM l_mem;
+
+/* chars used as small naturals (so that `char' is reserved for characters) */
+typedef unsigned char lu_byte;
+
+#define MAX_SIZET ((size_t)(~(size_t)0) - 2)
+
+#define MAX_LUMEM ((lu_mem)(~(lu_mem)0) - 2)
+
+#define MAX_LMEM ((l_mem)((MAX_LUMEM >> 1) - 2))
+
+#define MAX_INT (INT_MAX - 2) /* maximum value of an int (-2 for safety) */
+
+/*
+** conversion of pointer to integer
+** this is for hashing only; there is no problem if the integer
+** cannot hold the whole pointer value
+*/
+#define IntPoint(p) ((unsigned int)(lu_mem)(p))
+
+/* type to ensure maximum alignment */
+#if !defined(LUAI_USER_ALIGNMENT_T)
+#define LUAI_USER_ALIGNMENT_T \
+	union {                   \
+		double u;             \
+		void *s;              \
+		long l;               \
+	}
+#endif
+
+typedef LUAI_USER_ALIGNMENT_T L_Umaxalign;
+
+/* result of a `usual argument conversion' over lua_Number */
+typedef LUAI_UACNUMBER l_uacNumber;
+
+/* internal assertions for in-house debugging */
+#if defined(lua_assert)
+#define check_exp(c, e) (lua_assert(c), (e))
+/* to avoid problems with conditions too long */
+#define lua_longassert(c)        \
+	{                            \
+		if (!(c)) lua_assert(0); \
+	}
+#else
+#define lua_assert(c) ((void)0)
+#define check_exp(c, e) (e)
+#define lua_longassert(c) ((void)0)
+#endif
+
+/*
+** assertion for checking API calls
+*/
+#if !defined(luai_apicheck)
+
+#if defined(LUA_USE_APICHECK)
+#include <assert.h>
+#define luai_apicheck(L, e) assert(e)
+#else
+#define luai_apicheck(L, e) lua_assert(e)
+#endif
+
+#endif
+
+#define api_check(l, e, msg) luai_apicheck(l, (e) && msg)
+
+#if !defined(UNUSED)
+#define UNUSED(x) ((void)(x)) /* to avoid warnings */
+#endif
+
+#define cast(t, exp) ((t)(exp))
+
+#define cast_byte(i) cast(lu_byte, (i))
+#define cast_num(i) cast(lua_Number, (i))
+#define cast_int(i) cast(int, (i))
+#define cast_uchar(i) cast(unsigned char, (i))
+
+/*
+** non-return type
+*/
+#if defined(__GNUC__)
+#define l_noret void __attribute__((noreturn))
+#elif defined(_MSC_VER)
+#define l_noret void __declspec(noreturn)
+#else
+#define l_noret void
+#endif
+
+/*
+** maximum depth for nested C calls and syntactical nested non-terminals
+** in a program. (Value must fit in an unsigned short int.)
+*/
+#if !defined(LUAI_MAXCCALLS)
+#define LUAI_MAXCCALLS 200
+#endif
+
+/*
+** maximum number of upvalues in a closure (both C and Lua). (Value
+** must fit in an unsigned char.)
+*/
+#define MAXUPVAL UCHAR_MAX
+
+/*
+** type for virtual-machine instructions
+** must be an unsigned with (at least) 4 bytes (see details in lopcodes.h)
+*/
+typedef lu_int32 Instruction;
+
+/* maximum stack for a Lua function */
+#define MAXSTACK 250
+
+/* minimum size for the string table (must be power of 2) */
+#if !defined(MINSTRTABSIZE)
+#define MINSTRTABSIZE 32
+#endif
+
+/* minimum size for string buffer */
+#if !defined(LUA_MINBUFFER)
+#define LUA_MINBUFFER 32
+#endif
+
+#if !defined(lua_lock)
+#define lua_lock(L) ((void)0)
+#define lua_unlock(L) ((void)0)
+#endif
+
+#if !defined(luai_threadyield)
+#define luai_threadyield(L) \
+	{                       \
+		lua_unlock(L);      \
+		lua_lock(L);        \
+	}
+#endif
+
+/*
+** these macros allow user-specific actions on threads when you defined
+** LUAI_EXTRASPACE and need to do something extra when a thread is
+** created/deleted/resumed/yielded.
+*/
+#if !defined(luai_userstateopen)
+#define luai_userstateopen(L) ((void)L)
+#endif
+
+#if !defined(luai_userstateclose)
+#define luai_userstateclose(L) ((void)L)
+#endif
+
+#if !defined(luai_userstatethread)
+#define luai_userstatethread(L, L1) ((void)L)
+#endif
+
+#if !defined(luai_userstatefree)
+#define luai_userstatefree(L, L1) ((void)L)
+#endif
+
+#if !defined(luai_userstateresume)
+#define luai_userstateresume(L, n) ((void)L)
+#endif
+
+#if !defined(luai_userstateyield)
+#define luai_userstateyield(L, n) ((void)L)
+#endif
+
+/*
+** lua_number2int is a macro to convert lua_Number to int.
+** lua_number2integer is a macro to convert lua_Number to lua_Integer.
+** lua_number2unsigned is a macro to convert a lua_Number to a lua_Unsigned.
+** lua_unsigned2number is a macro to convert a lua_Unsigned to a lua_Number.
+** luai_hashnum is a macro to hash a lua_Number value into an integer.
+** The hash must be deterministic and give reasonable values for
+** both small and large values (outside the range of integers).
+*/
+
+#if defined(MS_ASMTRICK) || defined(LUA_MSASMTRICK) /* { */
+/* trick with Microsoft assembler for X86 */
+
+#define lua_number2int(i, n) __asm {__asm fld n   __asm fistp i}
+#define lua_number2integer(i, n) lua_number2int(i, n)
+#define lua_number2unsigned(i, n)         \
+	{                                     \
+		__int64 l;                        \
+		__asm {__asm fld n   __asm fistp l} \
+		i = (unsigned int)l;              \
+	}
+
+#elif defined(LUA_IEEE754TRICK) /* }{ */
+/* the next trick should work on any machine using IEEE754 with
+   a 32-bit int type */
+
+union luai_Cast {
+	double l_d;
+	LUA_INT32 l_p[2];
+};
+
+#if !defined(LUA_IEEEENDIAN) /* { */
+#define LUAI_EXTRAIEEE \
+	static const union luai_Cast ieeeendian = {-(33.0 + 6755399441055744.0)};
+#define LUA_IEEEENDIANLOC (ieeeendian.l_p[1] == 33)
+#else
+#define LUA_IEEEENDIANLOC LUA_IEEEENDIAN
+#define LUAI_EXTRAIEEE /* empty */
+#endif                 /* } */
+
+#define lua_number2int32(i, n, t)          \
+	{                                      \
+		LUAI_EXTRAIEEE                     \
+		volatile union luai_Cast u;        \
+		u.l_d = (n) + 6755399441055744.0;  \
+		(i) = (t)u.l_p[LUA_IEEEENDIANLOC]; \
+	}
+
+#define luai_hashnum(i, n)                \
+	{                                     \
+		volatile union luai_Cast u;       \
+		u.l_d = (n) + 1.0; /* avoid -0 */ \
+		(i) = u.l_p[0];                   \
+		(i) += u.l_p[1];                  \
+	} /* add double bits for his hash */
+
+#define lua_number2int(i, n) lua_number2int32(i, n, int)
+#define lua_number2unsigned(i, n) lua_number2int32(i, n, lua_Unsigned)
+
+/* the trick can be expanded to lua_Integer when it is a 32-bit value */
+#if defined(LUA_IEEELL)
+#define lua_number2integer(i, n) lua_number2int32(i, n, lua_Integer)
+#endif
+
+#endif /* } */
+
+/* the following definitions always work, but may be slow */
+
+#if !defined(lua_number2int)
+#define lua_number2int(i, n) ((i) = (int)(n))
+#endif
+
+#if !defined(lua_number2integer)
+#define lua_number2integer(i, n) ((i) = (lua_Integer)(n))
+#endif
+
+#if !defined(lua_number2unsigned) /* { */
+/* the following definition assures proper modulo behavior */
+#if defined(LUA_NUMBER_DOUBLE) || defined(LUA_NUMBER_FLOAT)
+#include <math.h>
+#define SUPUNSIGNED ((lua_Number)(~(lua_Unsigned)0) + 1)
+#define lua_number2unsigned(i, n) \
+	((i) = (lua_Unsigned)((n)-floor((n) / SUPUNSIGNED) * SUPUNSIGNED))
+#else
+#define lua_number2unsigned(i, n) ((i) = (lua_Unsigned)(n))
+#endif
+#endif /* } */
+
+#if !defined(lua_unsigned2number)
+/* on several machines, coercion from unsigned to double is slow,
+   so it may be worth to avoid */
+#define lua_unsigned2number(u) \
+	(((u) <= (lua_Unsigned)INT_MAX) ? (lua_Number)(int)(u) : (lua_Number)(u))
+#endif
+
+#if defined(ltable_c) && !defined(luai_hashnum)
+
+#include <float.h>
+#include <math.h>
+
+#define luai_hashnum(i, n)                                                \
+	{                                                                     \
+		int e;                                                            \
+		n = l_mathop(frexp)(n, &e) * (lua_Number)(INT_MAX - DBL_MAX_EXP); \
+		lua_number2int(i, n);                                             \
+		i += e;                                                           \
+	}
+
+#endif
+
+/*
+** macro to control inclusion of some hard tests on stack reallocation
+*/
+#if !defined(HARDSTACKTESTS)
+#define condmovestack(L) ((void)0)
+#else
+/* realloc stack keeping its size */
+#define condmovestack(L) luaD_reallocstack((L), (L)->stacksize)
+#endif
+
+#if !defined(HARDMEMTESTS)
+#define condchangemem(L) condmovestack(L)
+#else
+#define condchangemem(L) \
+	((void)(!(G(L)->gcrunning) || (luaC_fullgc(L, 0), 1)))
+#endif
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lmem.h b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lmem.h
new file mode 100644
index 00000000..6c176f99
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lmem.h
@@ -0,0 +1,54 @@
+/*
+** $Id: lmem.h,v 1.40.1.1 2013/04/12 18:48:47 roberto Exp $
+** Interface to Memory Manager
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lmem_h
+#define lmem_h
+
+#include <stddef.h>
+
+#include "llimits.h"
+#include "lua.h"
+
+/*
+** This macro avoids the runtime division MAX_SIZET/(e), as 'e' is
+** always constant.
+** The macro is somewhat complex to avoid warnings:
+** +1 avoids warnings of "comparison has constant result";
+** cast to 'void' avoids warnings of "value unused".
+*/
+#define luaM_reallocv(L, b, on, n, e)                                           \
+	(cast(void,                                                                 \
+		  (cast(size_t, (n) + 1) > MAX_SIZET / (e)) ? (luaM_toobig(L), 0) : 0), \
+	 luaM_realloc_(L, (b), (on) * (e), (n) * (e)))
+
+#define luaM_freemem(L, b, s) luaM_realloc_(L, (b), (s), 0)
+#define luaM_free(L, b) luaM_realloc_(L, (b), sizeof(*(b)), 0)
+#define luaM_freearray(L, b, n) luaM_reallocv(L, (b), n, 0, sizeof((b)[0]))
+
+#define luaM_malloc(L, s) luaM_realloc_(L, NULL, 0, (s))
+#define luaM_new(L, t) cast(t *, luaM_malloc(L, sizeof(t)))
+#define luaM_newvector(L, n, t) \
+	cast(t *, luaM_reallocv(L, NULL, 0, n, sizeof(t)))
+
+#define luaM_newobject(L, tag, s) luaM_realloc_(L, NULL, tag, (s))
+
+#define luaM_growvector(L, v, nelems, size, t, limit, e) \
+	if ((nelems) + 1 > (size))                           \
+	((v) = cast(t *, luaM_growaux_(L, v, &(size), sizeof(t), limit, e)))
+
+#define luaM_reallocvector(L, v, oldn, n, t) \
+	((v) = cast(t *, luaM_reallocv(L, v, oldn, n, sizeof(t))))
+
+LUAI_FUNC l_noret luaM_toobig(lua_State *L);
+
+/* not to be called directly */
+LUAI_FUNC void *luaM_realloc_(lua_State *L, void *block, size_t oldsize,
+							  size_t size);
+LUAI_FUNC void *luaM_growaux_(lua_State *L, void *block, int *size,
+							  size_t size_elem, int limit,
+							  const char *what);
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lobject.h b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lobject.h
new file mode 100644
index 00000000..4d48cea3
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lobject.h
@@ -0,0 +1,641 @@
+/*
+** $Id: lobject.h,v 2.71.1.1 2013/04/12 18:48:47 roberto Exp $
+** Type definitions for Lua objects
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lobject_h
+#define lobject_h
+
+#include <stdarg.h>
+
+#include "llimits.h"
+#include "lua.h"
+
+/*
+** Extra tags for non-values
+*/
+#define LUA_TPROTO LUA_NUMTAGS
+#define LUA_TUPVAL (LUA_NUMTAGS + 1)
+#define LUA_TDEADKEY (LUA_NUMTAGS + 2)
+
+/*
+** number of all possible tags (including LUA_TNONE but excluding DEADKEY)
+*/
+#define LUA_TOTALTAGS (LUA_TUPVAL + 2)
+
+/*
+** tags for Tagged Values have the following use of bits:
+** bits 0-3: actual tag (a LUA_T* value)
+** bits 4-5: variant bits
+** bit 6: whether value is collectable
+*/
+
+#define VARBITS (3 << 4)
+
+/*
+** LUA_TFUNCTION variants:
+** 0 - Lua function
+** 1 - light C function
+** 2 - regular C function (closure)
+*/
+
+/* Variant tags for functions */
+#define LUA_TLCL (LUA_TFUNCTION | (0 << 4)) /* Lua closure */
+#define LUA_TLCF (LUA_TFUNCTION | (1 << 4)) /* light C function */
+#define LUA_TCCL (LUA_TFUNCTION | (2 << 4)) /* C closure */
+
+/* Variant tags for strings */
+#define LUA_TSHRSTR (LUA_TSTRING | (0 << 4)) /* short strings */
+#define LUA_TLNGSTR (LUA_TSTRING | (1 << 4)) /* long strings */
+
+/* Bit mark for collectable types */
+#define BIT_ISCOLLECTABLE (1 << 6)
+
+/* mark a tag as collectable */
+#define ctb(t) ((t) | BIT_ISCOLLECTABLE)
+
+/*
+** Union of all collectable objects
+*/
+typedef union GCObject GCObject;
+
+/*
+** Common Header for all collectable objects (in macro form, to be
+** included in other objects)
+*/
+#define CommonHeader \
+	GCObject *next;  \
+	lu_byte tt;      \
+	lu_byte marked
+
+/*
+** Common header in struct form
+*/
+typedef struct GCheader
+{
+	CommonHeader;
+} GCheader;
+
+/*
+** Union of all Lua values
+*/
+typedef union Value Value;
+
+#define numfield lua_Number n; /* numbers */
+
+/*
+** Tagged Values. This is the basic representation of values in Lua,
+** an actual value plus a tag with its type.
+*/
+
+#define TValuefields \
+	Value value_;    \
+	int tt_
+
+typedef struct lua_TValue TValue;
+
+/* macro defining a nil value */
+#define NILCONSTANT {NULL}, LUA_TNIL
+
+#define val_(o) ((o)->value_)
+#define num_(o) (val_(o).n)
+
+/* raw type tag of a TValue */
+#define rttype(o) ((o)->tt_)
+
+/* tag with no variants (bits 0-3) */
+#define novariant(x) ((x)&0x0F)
+
+/* type tag of a TValue (bits 0-3 for tags + variant bits 4-5) */
+#define ttype(o) (rttype(o) & 0x3F)
+
+/* type tag of a TValue with no variants (bits 0-3) */
+#define ttypenv(o) (novariant(rttype(o)))
+
+/* Macros to test type */
+#define checktag(o, t) (rttype(o) == (t))
+#define checktype(o, t) (ttypenv(o) == (t))
+#define ttisnumber(o) checktag((o), LUA_TNUMBER)
+#define ttisnil(o) checktag((o), LUA_TNIL)
+#define ttisboolean(o) checktag((o), LUA_TBOOLEAN)
+#define ttislightuserdata(o) checktag((o), LUA_TLIGHTUSERDATA)
+#define ttisstring(o) checktype((o), LUA_TSTRING)
+#define ttisshrstring(o) checktag((o), ctb(LUA_TSHRSTR))
+#define ttislngstring(o) checktag((o), ctb(LUA_TLNGSTR))
+#define ttistable(o) checktag((o), ctb(LUA_TTABLE))
+#define ttisfunction(o) checktype(o, LUA_TFUNCTION)
+#define ttisclosure(o) ((rttype(o) & 0x1F) == LUA_TFUNCTION)
+#define ttisCclosure(o) checktag((o), ctb(LUA_TCCL))
+#define ttisLclosure(o) checktag((o), ctb(LUA_TLCL))
+#define ttislcf(o) checktag((o), LUA_TLCF)
+#define ttisuserdata(o) checktag((o), ctb(LUA_TUSERDATA))
+#define ttisthread(o) checktag((o), ctb(LUA_TTHREAD))
+#define ttisdeadkey(o) checktag((o), LUA_TDEADKEY)
+
+#define ttisequal(o1, o2) (rttype(o1) == rttype(o2))
+
+/* Macros to access values */
+#define nvalue(o) check_exp(ttisnumber(o), num_(o))
+#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc)
+#define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p)
+#define rawtsvalue(o) check_exp(ttisstring(o), &val_(o).gc->ts)
+#define tsvalue(o) (&rawtsvalue(o)->tsv)
+#define rawuvalue(o) check_exp(ttisuserdata(o), &val_(o).gc->u)
+#define uvalue(o) (&rawuvalue(o)->uv)
+#define clvalue(o) check_exp(ttisclosure(o), &val_(o).gc->cl)
+#define clLvalue(o) check_exp(ttisLclosure(o), &val_(o).gc->cl.l)
+#define clCvalue(o) check_exp(ttisCclosure(o), &val_(o).gc->cl.c)
+#define fvalue(o) check_exp(ttislcf(o), val_(o).f)
+#define hvalue(o) check_exp(ttistable(o), &val_(o).gc->h)
+#define bvalue(o) check_exp(ttisboolean(o), val_(o).b)
+#define thvalue(o) check_exp(ttisthread(o), &val_(o).gc->th)
+/* a dead value may get the 'gc' field, but cannot access its contents */
+#define deadvalue(o) check_exp(ttisdeadkey(o), cast(void *, val_(o).gc))
+
+#define l_isfalse(o) (ttisnil(o) || (ttisboolean(o) && bvalue(o) == 0))
+
+#define iscollectable(o) (rttype(o) & BIT_ISCOLLECTABLE)
+
+/* Macros for internal tests */
+#define righttt(obj) (ttype(obj) == gcvalue(obj)->gch.tt)
+
+#define checkliveness(g, obj)             \
+	lua_longassert(!iscollectable(obj) || \
+				   (righttt(obj) && !isdead(g, gcvalue(obj))))
+
+/* Macros to set values */
+#define settt_(o, t) ((o)->tt_ = (t))
+
+#define setnvalue(obj, x)        \
+	{                            \
+		TValue *io = (obj);      \
+		num_(io) = (x);          \
+		settt_(io, LUA_TNUMBER); \
+	}
+
+#define setnilvalue(obj) settt_(obj, LUA_TNIL)
+
+#define setfvalue(obj, x)     \
+	{                         \
+		TValue *io = (obj);   \
+		val_(io).f = (x);     \
+		settt_(io, LUA_TLCF); \
+	}
+
+#define setpvalue(obj, x)               \
+	{                                   \
+		TValue *io = (obj);             \
+		val_(io).p = (x);               \
+		settt_(io, LUA_TLIGHTUSERDATA); \
+	}
+
+#define setbvalue(obj, x)         \
+	{                             \
+		TValue *io = (obj);       \
+		val_(io).b = (x);         \
+		settt_(io, LUA_TBOOLEAN); \
+	}
+
+#define setgcovalue(L, obj, x)         \
+	{                                  \
+		TValue *io = (obj);            \
+		GCObject *i_g = (x);           \
+		val_(io).gc = i_g;             \
+		settt_(io, ctb(gch(i_g)->tt)); \
+	}
+
+#define setsvalue(L, obj, x)                \
+	{                                       \
+		TValue *io = (obj);                 \
+		TString *x_ = (x);                  \
+		val_(io).gc = cast(GCObject *, x_); \
+		settt_(io, ctb(x_->tsv.tt));        \
+		checkliveness(G(L), io);            \
+	}
+
+#define setuvalue(L, obj, x)                 \
+	{                                        \
+		TValue *io = (obj);                  \
+		val_(io).gc = cast(GCObject *, (x)); \
+		settt_(io, ctb(LUA_TUSERDATA));      \
+		checkliveness(G(L), io);             \
+	}
+
+#define setthvalue(L, obj, x)                \
+	{                                        \
+		TValue *io = (obj);                  \
+		val_(io).gc = cast(GCObject *, (x)); \
+		settt_(io, ctb(LUA_TTHREAD));        \
+		checkliveness(G(L), io);             \
+	}
+
+#define setclLvalue(L, obj, x)               \
+	{                                        \
+		TValue *io = (obj);                  \
+		val_(io).gc = cast(GCObject *, (x)); \
+		settt_(io, ctb(LUA_TLCL));           \
+		checkliveness(G(L), io);             \
+	}
+
+#define setclCvalue(L, obj, x)               \
+	{                                        \
+		TValue *io = (obj);                  \
+		val_(io).gc = cast(GCObject *, (x)); \
+		settt_(io, ctb(LUA_TCCL));           \
+		checkliveness(G(L), io);             \
+	}
+
+#define sethvalue(L, obj, x)                 \
+	{                                        \
+		TValue *io = (obj);                  \
+		val_(io).gc = cast(GCObject *, (x)); \
+		settt_(io, ctb(LUA_TTABLE));         \
+		checkliveness(G(L), io);             \
+	}
+
+#define setdeadvalue(obj) settt_(obj, LUA_TDEADKEY)
+
+#define setobj(L, obj1, obj2)       \
+	{                               \
+		const TValue *io2 = (obj2); \
+		TValue *io1 = (obj1);       \
+		io1->value_ = io2->value_;  \
+		io1->tt_ = io2->tt_;        \
+		checkliveness(G(L), io1);   \
+	}
+
+/*
+** different types of assignments, according to destination
+*/
+
+/* from stack to (same) stack */
+#define setobjs2s setobj
+/* to stack (not from same stack) */
+#define setobj2s setobj
+#define setsvalue2s setsvalue
+#define sethvalue2s sethvalue
+#define setptvalue2s setptvalue
+/* from table to same table */
+#define setobjt2t setobj
+/* to table */
+#define setobj2t setobj
+/* to new object */
+#define setobj2n setobj
+#define setsvalue2n setsvalue
+
+/* check whether a number is valid (useful only for NaN trick) */
+#define luai_checknum(L, o, c) \
+	{ /* empty */              \
+	}
+
+/*
+** {======================================================
+** NaN Trick
+** =======================================================
+*/
+#if defined(LUA_NANTRICK)
+
+/*
+** numbers are represented in the 'd_' field. All other values have the
+** value (NNMARK | tag) in 'tt__'. A number with such pattern would be
+** a "signaled NaN", which is never generated by regular operations by
+** the CPU (nor by 'strtod')
+*/
+
+/* allows for external implementation for part of the trick */
+#if !defined(NNMARK) /* { */
+
+#if !defined(LUA_IEEEENDIAN)
+#error option 'LUA_NANTRICK' needs 'LUA_IEEEENDIAN'
+#endif
+
+#define NNMARK 0x7FF7A500
+#define NNMASK 0x7FFFFF00
+
+#undef TValuefields
+#undef NILCONSTANT
+
+#if (LUA_IEEEENDIAN == 0) /* { */
+
+/* little endian */
+#define TValuefields   \
+	union {            \
+		struct         \
+		{              \
+			Value v__; \
+			int tt__;  \
+		} i;           \
+		double d__;    \
+	} u
+#define NILCONSTANT                  \
+	{                                \
+		{                            \
+			{NULL}, tag2tt(LUA_TNIL) \
+		}                            \
+	}
+/* field-access macros */
+#define v_(o) ((o)->u.i.v__)
+#define d_(o) ((o)->u.d__)
+#define tt_(o) ((o)->u.i.tt__)
+
+#else /* }{ */
+
+/* big endian */
+#define TValuefields   \
+	union {            \
+		struct         \
+		{              \
+			int tt__;  \
+			Value v__; \
+		} i;           \
+		double d__;    \
+	} u
+#define NILCONSTANT                    \
+	{                                  \
+		{                              \
+			tag2tt(LUA_TNIL), { NULL } \
+		}                              \
+	}
+/* field-access macros */
+#define v_(o) ((o)->u.i.v__)
+#define d_(o) ((o)->u.d__)
+#define tt_(o) ((o)->u.i.tt__)
+
+#endif /* } */
+
+#endif /* } */
+
+/* correspondence with standard representation */
+#undef val_
+#define val_(o) v_(o)
+#undef num_
+#define num_(o) d_(o)
+
+#undef numfield
+#define numfield /* no such field; numbers are the entire struct */
+
+/* basic check to distinguish numbers from non-numbers */
+#undef ttisnumber
+#define ttisnumber(o) ((tt_(o) & NNMASK) != NNMARK)
+
+#define tag2tt(t) (NNMARK | (t))
+
+#undef rttype
+#define rttype(o) (ttisnumber(o) ? LUA_TNUMBER : tt_(o) & 0xff)
+
+#undef settt_
+#define settt_(o, t) (tt_(o) = tag2tt(t))
+
+#undef setnvalue
+#define setnvalue(obj, x)            \
+	{                                \
+		TValue *io_ = (obj);         \
+		num_(io_) = (x);             \
+		lua_assert(ttisnumber(io_)); \
+	}
+
+#undef setobj
+#define setobj(L, obj1, obj2)       \
+	{                               \
+		const TValue *o2_ = (obj2); \
+		TValue *o1_ = (obj1);       \
+		o1_->u = o2_->u;            \
+		checkliveness(G(L), o1_);   \
+	}
+
+/*
+** these redefinitions are not mandatory, but these forms are more efficient
+*/
+
+#undef checktag
+#undef checktype
+#define checktag(o, t) (tt_(o) == tag2tt(t))
+#define checktype(o, t) (ctb(tt_(o) | VARBITS) == ctb(tag2tt(t) | VARBITS))
+
+#undef ttisequal
+#define ttisequal(o1, o2) \
+	(ttisnumber(o1) ? ttisnumber(o2) : (tt_(o1) == tt_(o2)))
+
+#undef luai_checknum
+#define luai_checknum(L, o, c) \
+	{                          \
+		if (!ttisnumber(o)) c; \
+	}
+
+#endif
+/* }====================================================== */
+
+/*
+** {======================================================
+** types and prototypes
+** =======================================================
+*/
+
+union Value {
+	GCObject *gc;    /* collectable objects */
+	void *p;         /* light userdata */
+	int b;           /* booleans */
+	lua_CFunction f; /* light C functions */
+	numfield         /* numbers */
+};
+
+struct lua_TValue
+{
+	TValuefields;
+};
+
+typedef TValue *StkId; /* index to stack elements */
+
+/*
+** Header for string value; string bytes follow the end of this structure
+*/
+typedef union TString {
+	L_Umaxalign dummy; /* ensures maximum alignment for strings */
+	struct
+	{
+		CommonHeader;
+		lu_byte extra; /* reserved words for short strings; "has hash" for longs */
+		unsigned int hash;
+		size_t len; /* number of characters in string */
+	} tsv;
+} TString;
+
+/* get the actual string (array of bytes) from a TString */
+#define getstr(ts) cast(const char *, (ts) + 1)
+
+/* get the actual string (array of bytes) from a Lua value */
+#define svalue(o) getstr(rawtsvalue(o))
+
+/*
+** Header for userdata; memory area follows the end of this structure
+*/
+typedef union Udata {
+	L_Umaxalign dummy; /* ensures maximum alignment for `local' udata */
+	struct
+	{
+		CommonHeader;
+		struct Table *metatable;
+		struct Table *env;
+		size_t len; /* number of bytes */
+	} uv;
+} Udata;
+
+/*
+** Description of an upvalue for function prototypes
+*/
+typedef struct Upvaldesc
+{
+	TString *name;   /* upvalue name (for debug information) */
+	lu_byte instack; /* whether it is in stack */
+	lu_byte idx;     /* index of upvalue (in stack or in outer function's list) */
+} Upvaldesc;
+
+/*
+** Description of a local variable for function prototypes
+** (used for debug information)
+*/
+typedef struct LocVar
+{
+	TString *varname;
+	int startpc; /* first point where variable is active */
+	int endpc;   /* first point where variable is dead */
+} LocVar;
+
+/*
+** Function Prototypes
+*/
+typedef struct Proto
+{
+	CommonHeader;
+	TValue *k; /* constants used by the function */
+	Instruction *code;
+	struct Proto **p;     /* functions defined inside the function */
+	int *lineinfo;        /* map from opcodes to source lines (debug information) */
+	LocVar *locvars;      /* information about local variables (debug information) */
+	Upvaldesc *upvalues;  /* upvalue information */
+	union Closure *cache; /* last created closure with this prototype */
+	TString *source;      /* used for debug information */
+	int sizeupvalues;     /* size of 'upvalues' */
+	int sizek;            /* size of `k' */
+	int sizecode;
+	int sizelineinfo;
+	int sizep; /* size of `p' */
+	int sizelocvars;
+	int linedefined;
+	int lastlinedefined;
+	GCObject *gclist;
+	lu_byte numparams; /* number of fixed parameters */
+	lu_byte is_vararg;
+	lu_byte maxstacksize; /* maximum stack used by this function */
+} Proto;
+
+/*
+** Lua Upvalues
+*/
+typedef struct UpVal
+{
+	CommonHeader;
+	TValue *v; /* points to stack or to its own value */
+	union {
+		TValue value; /* the value (when closed) */
+		struct
+		{ /* double linked list (when open) */
+			struct UpVal *prev;
+			struct UpVal *next;
+		} l;
+	} u;
+} UpVal;
+
+/*
+** Closures
+*/
+
+#define ClosureHeader  \
+	CommonHeader;      \
+	lu_byte nupvalues; \
+	GCObject *gclist
+
+typedef struct CClosure
+{
+	ClosureHeader;
+	lua_CFunction f;
+	TValue upvalue[1]; /* list of upvalues */
+} CClosure;
+
+typedef struct LClosure
+{
+	ClosureHeader;
+	struct Proto *p;
+	UpVal *upvals[1]; /* list of upvalues */
+} LClosure;
+
+typedef union Closure {
+	CClosure c;
+	LClosure l;
+} Closure;
+
+#define isLfunction(o) ttisLclosure(o)
+
+#define getproto(o) (clLvalue(o)->p)
+
+/*
+** Tables
+*/
+
+typedef union TKey {
+	struct
+	{
+		TValuefields;
+		struct Node *next; /* for chaining */
+	} nk;
+	TValue tvk;
+} TKey;
+
+typedef struct Node
+{
+	TValue i_val;
+	TKey i_key;
+} Node;
+
+typedef struct Table
+{
+	CommonHeader;
+	lu_byte flags;     /* 1<<p means tagmethod(p) is not present */
+	lu_byte lsizenode; /* log2 of size of `node' array */
+	struct Table *metatable;
+	TValue *array; /* array part */
+	Node *node;
+	Node *lastfree; /* any free position is before this position */
+	GCObject *gclist;
+	int sizearray; /* size of `array' array */
+} Table;
+
+/*
+** `module' operation for hashing (size is always a power of 2)
+*/
+#define lmod(s, size) \
+	(check_exp((size & (size - 1)) == 0, (cast(int, (s) & ((size)-1)))))
+
+#define twoto(x) (1 << (x))
+#define sizenode(t) (twoto((t)->lsizenode))
+
+/*
+** (address of) a fixed nil value
+*/
+#define luaO_nilobject (&luaO_nilobject_)
+
+LUAI_DDEC const TValue luaO_nilobject_;
+
+LUAI_FUNC int luaO_int2fb(unsigned int x);
+LUAI_FUNC int luaO_fb2int(int x);
+LUAI_FUNC int luaO_ceillog2(unsigned int x);
+LUAI_FUNC lua_Number luaO_arith(int op, lua_Number v1, lua_Number v2);
+LUAI_FUNC int luaO_str2d(const char *s, size_t len, lua_Number *result);
+LUAI_FUNC int luaO_hexavalue(int c);
+LUAI_FUNC const char *luaO_pushvfstring(lua_State *L, const char *fmt,
+										va_list argp);
+LUAI_FUNC const char *luaO_pushfstring(lua_State *L, const char *fmt, ...);
+LUAI_FUNC void luaO_chunkid(char *out, const char *source, size_t len);
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lopcodes.h b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lopcodes.h
new file mode 100644
index 00000000..7ad89181
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lopcodes.h
@@ -0,0 +1,272 @@
+/*
+** $Id: lopcodes.h,v 1.142.1.1 2013/04/12 18:48:47 roberto Exp $
+** Opcodes for Lua virtual machine
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lopcodes_h
+#define lopcodes_h
+
+#include "llimits.h"
+
+/*===========================================================================
+  We assume that instructions are unsigned numbers.
+  All instructions have an opcode in the first 6 bits.
+  Instructions can have the following fields:
+	`A' : 8 bits
+	`B' : 9 bits
+	`C' : 9 bits
+	'Ax' : 26 bits ('A', 'B', and 'C' together)
+	`Bx' : 18 bits (`B' and `C' together)
+	`sBx' : signed Bx
+
+  A signed argument is represented in excess K; that is, the number
+  value is the unsigned value minus K. K is exactly the maximum value
+  for that argument (so that -max is represented by 0, and +max is
+  represented by 2*max), which is half the maximum for the corresponding
+  unsigned argument.
+===========================================================================*/
+
+enum OpMode
+{
+	iABC,
+	iABx,
+	iAsBx,
+	iAx
+}; /* basic instruction format */
+
+/*
+** size and position of opcode arguments.
+*/
+#define SIZE_C 9
+#define SIZE_B 9
+#define SIZE_Bx (SIZE_C + SIZE_B)
+#define SIZE_A 8
+#define SIZE_Ax (SIZE_C + SIZE_B + SIZE_A)
+
+#define SIZE_OP 6
+
+#define POS_OP 0
+#define POS_A (POS_OP + SIZE_OP)
+#define POS_C (POS_A + SIZE_A)
+#define POS_B (POS_C + SIZE_C)
+#define POS_Bx POS_C
+#define POS_Ax POS_A
+
+/*
+** limits for opcode arguments.
+** we use (signed) int to manipulate most arguments,
+** so they must fit in LUAI_BITSINT-1 bits (-1 for sign)
+*/
+#if SIZE_Bx < LUAI_BITSINT - 1
+#define MAXARG_Bx ((1 << SIZE_Bx) - 1)
+#define MAXARG_sBx (MAXARG_Bx >> 1) /* `sBx' is signed */
+#else
+#define MAXARG_Bx MAX_INT
+#define MAXARG_sBx MAX_INT
+#endif
+
+#if SIZE_Ax < LUAI_BITSINT - 1
+#define MAXARG_Ax ((1 << SIZE_Ax) - 1)
+#else
+#define MAXARG_Ax MAX_INT
+#endif
+
+#define MAXARG_A ((1 << SIZE_A) - 1)
+#define MAXARG_B ((1 << SIZE_B) - 1)
+#define MAXARG_C ((1 << SIZE_C) - 1)
+
+/* creates a mask with `n' 1 bits at position `p' */
+#define MASK1(n, p) ((~((~(Instruction)0) << (n))) << (p))
+
+/* creates a mask with `n' 0 bits at position `p' */
+#define MASK0(n, p) (~MASK1(n, p))
+
+/*
+** the following macros help to manipulate instructions
+*/
+
+#define GET_OPCODE(i) (cast(OpCode, ((i) >> POS_OP) & MASK1(SIZE_OP, 0)))
+#define SET_OPCODE(i, o) ((i) = (((i)&MASK0(SIZE_OP, POS_OP)) | \
+								 ((cast(Instruction, o) << POS_OP) & MASK1(SIZE_OP, POS_OP))))
+
+#define getarg(i, pos, size) (cast(int, ((i) >> pos) & MASK1(size, 0)))
+#define setarg(i, v, pos, size) ((i) = (((i)&MASK0(size, pos)) | \
+										((cast(Instruction, v) << pos) & MASK1(size, pos))))
+
+#define GETARG_A(i) getarg(i, POS_A, SIZE_A)
+#define SETARG_A(i, v) setarg(i, v, POS_A, SIZE_A)
+
+#define GETARG_B(i) getarg(i, POS_B, SIZE_B)
+#define SETARG_B(i, v) setarg(i, v, POS_B, SIZE_B)
+
+#define GETARG_C(i) getarg(i, POS_C, SIZE_C)
+#define SETARG_C(i, v) setarg(i, v, POS_C, SIZE_C)
+
+#define GETARG_Bx(i) getarg(i, POS_Bx, SIZE_Bx)
+#define SETARG_Bx(i, v) setarg(i, v, POS_Bx, SIZE_Bx)
+
+#define GETARG_Ax(i) getarg(i, POS_Ax, SIZE_Ax)
+#define SETARG_Ax(i, v) setarg(i, v, POS_Ax, SIZE_Ax)
+
+#define GETARG_sBx(i) (GETARG_Bx(i) - MAXARG_sBx)
+#define SETARG_sBx(i, b) SETARG_Bx((i), cast(unsigned int, (b) + MAXARG_sBx))
+
+#define CREATE_ABC(o, a, b, c) ((cast(Instruction, o) << POS_OP) | (cast(Instruction, a) << POS_A) | (cast(Instruction, b) << POS_B) | (cast(Instruction, c) << POS_C))
+
+#define CREATE_ABx(o, a, bc) ((cast(Instruction, o) << POS_OP) | (cast(Instruction, a) << POS_A) | (cast(Instruction, bc) << POS_Bx))
+
+#define CREATE_Ax(o, a) ((cast(Instruction, o) << POS_OP) | (cast(Instruction, a) << POS_Ax))
+
+/*
+** Macros to operate RK indices
+*/
+
+/* this bit 1 means constant (0 means register) */
+#define BITRK (1 << (SIZE_B - 1))
+
+/* test whether value is a constant */
+#define ISK(x) ((x)&BITRK)
+
+/* gets the index of the constant */
+#define INDEXK(r) ((int)(r) & ~BITRK)
+
+#define MAXINDEXRK (BITRK - 1)
+
+/* code a constant index as a RK value */
+#define RKASK(x) ((x) | BITRK)
+
+/*
+** invalid register that fits in 8 bits
+*/
+#define NO_REG MAXARG_A
+
+/*
+** R(x) - register
+** Kst(x) - constant (in constant table)
+** RK(x) == if ISK(x) then Kst(INDEXK(x)) else R(x)
+*/
+
+/*
+** grep "ORDER OP" if you change these enums
+*/
+
+typedef enum
+{
+	/*----------------------------------------------------------------------
+name		args	description
+------------------------------------------------------------------------*/
+	OP_MOVE,     /*	A B	R(A) := R(B)					*/
+	OP_LOADK,    /*	A Bx	R(A) := Kst(Bx)					*/
+	OP_LOADKX,   /*	A 	R(A) := Kst(extra arg)				*/
+	OP_LOADBOOL, /*	A B C	R(A) := (Bool)B; if (C) pc++			*/
+	OP_LOADNIL,  /*	A B	R(A), R(A+1), ..., R(A+B) := nil		*/
+	OP_GETUPVAL, /*	A B	R(A) := UpValue[B]				*/
+
+	OP_GETTABUP, /*	A B C	R(A) := UpValue[B][RK(C)]			*/
+	OP_GETTABLE, /*	A B C	R(A) := R(B)[RK(C)]				*/
+
+	OP_SETTABUP, /*	A B C	UpValue[A][RK(B)] := RK(C)			*/
+	OP_SETUPVAL, /*	A B	UpValue[B] := R(A)				*/
+	OP_SETTABLE, /*	A B C	R(A)[RK(B)] := RK(C)				*/
+
+	OP_NEWTABLE, /*	A B C	R(A) := {} (size = B,C)				*/
+
+	OP_SELF, /*	A B C	R(A+1) := R(B); R(A) := R(B)[RK(C)]		*/
+
+	OP_ADD, /*	A B C	R(A) := RK(B) + RK(C)				*/
+	OP_SUB, /*	A B C	R(A) := RK(B) - RK(C)				*/
+	OP_MUL, /*	A B C	R(A) := RK(B) * RK(C)				*/
+	OP_DIV, /*	A B C	R(A) := RK(B) / RK(C)				*/
+	OP_MOD, /*	A B C	R(A) := RK(B) % RK(C)				*/
+	OP_POW, /*	A B C	R(A) := RK(B) ^ RK(C)				*/
+	OP_UNM, /*	A B	R(A) := -R(B)					*/
+	OP_NOT, /*	A B	R(A) := not R(B)				*/
+	OP_LEN, /*	A B	R(A) := length of R(B)				*/
+
+	OP_CONCAT, /*	A B C	R(A) := R(B).. ... ..R(C)			*/
+
+	OP_JMP, /*	A sBx	pc+=sBx; if (A) close all upvalues >= R(A) + 1	*/
+	OP_EQ,  /*	A B C	if ((RK(B) == RK(C)) ~= A) then pc++		*/
+	OP_LT,  /*	A B C	if ((RK(B) <  RK(C)) ~= A) then pc++		*/
+	OP_LE,  /*	A B C	if ((RK(B) <= RK(C)) ~= A) then pc++		*/
+
+	OP_TEST,    /*	A C	if not (R(A) <=> C) then pc++			*/
+	OP_TESTSET, /*	A B C	if (R(B) <=> C) then R(A) := R(B) else pc++	*/
+
+	OP_CALL,     /*	A B C	R(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1)) */
+	OP_TAILCALL, /*	A B C	return R(A)(R(A+1), ... ,R(A+B-1))		*/
+	OP_RETURN,   /*	A B	return R(A), ... ,R(A+B-2)	(see note)	*/
+
+	OP_FORLOOP, /*	A sBx	R(A)+=R(A+2);
+			if R(A) <?= R(A+1) then { pc+=sBx; R(A+3)=R(A) }*/
+	OP_FORPREP, /*	A sBx	R(A)-=R(A+2); pc+=sBx				*/
+
+	OP_TFORCALL, /*	A C	R(A+3), ... ,R(A+2+C) := R(A)(R(A+1), R(A+2));	*/
+	OP_TFORLOOP, /*	A sBx	if R(A+1) ~= nil then { R(A)=R(A+1); pc += sBx }*/
+
+	OP_SETLIST, /*	A B C	R(A)[(C-1)*FPF+i] := R(A+i), 1 <= i <= B	*/
+
+	OP_CLOSURE, /*	A Bx	R(A) := closure(KPROTO[Bx])			*/
+
+	OP_VARARG, /*	A B	R(A), R(A+1), ..., R(A+B-2) = vararg		*/
+
+	OP_EXTRAARG /*	Ax	extra (larger) argument for previous opcode	*/
+} OpCode;
+
+#define NUM_OPCODES (cast(int, OP_EXTRAARG) + 1)
+
+/*===========================================================================
+  Notes:
+  (*) In OP_CALL, if (B == 0) then B = top. If (C == 0), then `top' is
+  set to last_result+1, so next open instruction (OP_CALL, OP_RETURN,
+  OP_SETLIST) may use `top'.
+
+  (*) In OP_VARARG, if (B == 0) then use actual number of varargs and
+  set top (like in OP_CALL with C == 0).
+
+  (*) In OP_RETURN, if (B == 0) then return up to `top'.
+
+  (*) In OP_SETLIST, if (B == 0) then B = `top'; if (C == 0) then next
+  'instruction' is EXTRAARG(real C).
+
+  (*) In OP_LOADKX, the next 'instruction' is always EXTRAARG.
+
+  (*) For comparisons, A specifies what condition the test should accept
+  (true or false).
+
+  (*) All `skips' (pc++) assume that next instruction is a jump.
+
+===========================================================================*/
+
+/*
+** masks for instruction properties. The format is:
+** bits 0-1: op mode
+** bits 2-3: C arg mode
+** bits 4-5: B arg mode
+** bit 6: instruction set register A
+** bit 7: operator is a test (next instruction must be a jump)
+*/
+
+enum OpArgMask
+{
+	OpArgN, /* argument is not used */
+	OpArgU, /* argument is used */
+	OpArgR, /* argument is a register or a jump offset */
+	OpArgK  /* argument is a constant or register/constant */
+};
+
+LUAI_DDEC const lu_byte luaP_opmodes[NUM_OPCODES];
+
+#define getOpMode(m) (cast(enum OpMode, luaP_opmodes[m] & 3))
+#define getBMode(m) (cast(enum OpArgMask, (luaP_opmodes[m] >> 4) & 3))
+#define getCMode(m) (cast(enum OpArgMask, (luaP_opmodes[m] >> 2) & 3))
+#define testAMode(m) (luaP_opmodes[m] & (1 << 6))
+#define testTMode(m) (luaP_opmodes[m] & (1 << 7))
+
+LUAI_DDEC const char *const luaP_opnames[NUM_OPCODES + 1]; /* opcode names */
+
+/* number of list items to accumulate before a SETLIST instruction */
+#define LFIELDS_PER_FLUSH 50
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lparser.h b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lparser.h
new file mode 100644
index 00000000..7c220090
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lparser.h
@@ -0,0 +1,118 @@
+/*
+** $Id: lparser.h,v 1.70.1.1 2013/04/12 18:48:47 roberto Exp $
+** Lua Parser
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lparser_h
+#define lparser_h
+
+#include "llimits.h"
+#include "lobject.h"
+#include "lzio.h"
+
+/*
+** Expression descriptor
+*/
+
+typedef enum
+{
+	VVOID, /* no value */
+	VNIL,
+	VTRUE,
+	VFALSE,
+	VK,         /* info = index of constant in `k' */
+	VKNUM,      /* nval = numerical value */
+	VNONRELOC,  /* info = result register */
+	VLOCAL,     /* info = local register */
+	VUPVAL,     /* info = index of upvalue in 'upvalues' */
+	VINDEXED,   /* t = table register/upvalue; idx = index R/K */
+	VJMP,       /* info = instruction pc */
+	VRELOCABLE, /* info = instruction pc */
+	VCALL,      /* info = instruction pc */
+	VVARARG     /* info = instruction pc */
+} expkind;
+
+#define vkisvar(k) (VLOCAL <= (k) && (k) <= VINDEXED)
+#define vkisinreg(k) ((k) == VNONRELOC || (k) == VLOCAL)
+
+typedef struct expdesc
+{
+	expkind k;
+	union {
+		struct
+		{               /* for indexed variables (VINDEXED) */
+			short idx;  /* index (R/K) */
+			lu_byte t;  /* table (register or upvalue) */
+			lu_byte vt; /* whether 't' is register (VLOCAL) or upvalue (VUPVAL) */
+		} ind;
+		int info;        /* for generic use */
+		lua_Number nval; /* for VKNUM */
+	} u;
+	int t; /* patch list of `exit when true' */
+	int f; /* patch list of `exit when false' */
+} expdesc;
+
+/* description of active local variable */
+typedef struct Vardesc
+{
+	short idx; /* variable index in stack */
+} Vardesc;
+
+/* description of pending goto statements and label statements */
+typedef struct Labeldesc
+{
+	TString *name;   /* label identifier */
+	int pc;          /* position in code */
+	int line;        /* line where it appeared */
+	lu_byte nactvar; /* local level where it appears in current block */
+} Labeldesc;
+
+/* list of labels or gotos */
+typedef struct Labellist
+{
+	Labeldesc *arr; /* array */
+	int n;          /* number of entries in use */
+	int size;       /* array size */
+} Labellist;
+
+/* dynamic structures used by the parser */
+typedef struct Dyndata
+{
+	struct
+	{ /* list of active local variables */
+		Vardesc *arr;
+		int n;
+		int size;
+	} actvar;
+	Labellist gt;    /* list of pending gotos */
+	Labellist label; /* list of active labels */
+} Dyndata;
+
+/* control of blocks */
+struct BlockCnt; /* defined in lparser.c */
+
+/* state needed to generate code for a given function */
+typedef struct FuncState
+{
+	Proto *f;               /* current function header */
+	Table *h;               /* table to find (and reuse) elements in `k' */
+	struct FuncState *prev; /* enclosing function */
+	struct LexState *ls;    /* lexical state */
+	struct BlockCnt *bl;    /* chain of current blocks */
+	int pc;                 /* next position to code (equivalent to `ncode') */
+	int lasttarget;         /* 'label' of last 'jump label' */
+	int jpc;                /* list of pending jumps to `pc' */
+	int nk;                 /* number of elements in `k' */
+	int np;                 /* number of elements in `p' */
+	int firstlocal;         /* index of first local var (in Dyndata array) */
+	short nlocvars;         /* number of elements in 'f->locvars' */
+	lu_byte nactvar;        /* number of active local variables */
+	lu_byte nups;           /* number of upvalues */
+	lu_byte freereg;        /* first free register */
+} FuncState;
+
+LUAI_FUNC Closure *luaY_parser(lua_State *L, ZIO *z, Mbuffer *buff,
+							   Dyndata *dyd, const char *name, int firstchar);
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lstate.h b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lstate.h
new file mode 100644
index 00000000..7e21b1d5
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lstate.h
@@ -0,0 +1,216 @@
+/*
+** $Id: lstate.h,v 2.82.1.1 2013/04/12 18:48:47 roberto Exp $
+** Global State
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lstate_h
+#define lstate_h
+
+#include "lua.h"
+
+#include "lobject.h"
+#include "ltm.h"
+#include "lzio.h"
+
+/*
+
+** Some notes about garbage-collected objects:  All objects in Lua must
+** be kept somehow accessible until being freed.
+**
+** Lua keeps most objects linked in list g->allgc. The link uses field
+** 'next' of the CommonHeader.
+**
+** Strings are kept in several lists headed by the array g->strt.hash.
+**
+** Open upvalues are not subject to independent garbage collection. They
+** are collected together with their respective threads. Lua keeps a
+** double-linked list with all open upvalues (g->uvhead) so that it can
+** mark objects referred by them. (They are always gray, so they must
+** be remarked in the atomic step. Usually their contents would be marked
+** when traversing the respective threads, but the thread may already be
+** dead, while the upvalue is still accessible through closures.)
+**
+** Objects with finalizers are kept in the list g->finobj.
+**
+** The list g->tobefnz links all objects being finalized.
+
+*/
+
+struct lua_longjmp; /* defined in ldo.c */
+
+/* extra stack space to handle TM calls and some other extras */
+#define EXTRA_STACK 5
+
+#define BASIC_STACK_SIZE (2 * LUA_MINSTACK)
+
+/* kinds of Garbage Collection */
+#define KGC_NORMAL 0
+#define KGC_EMERGENCY 1 /* gc was forced by an allocation failure */
+#define KGC_GEN 2       /* generational collection */
+
+typedef struct stringtable
+{
+	GCObject **hash;
+	lu_int32 nuse; /* number of elements */
+	int size;
+} stringtable;
+
+/*
+** information about a call
+*/
+typedef struct CallInfo
+{
+	StkId func;                       /* function index in the stack */
+	StkId top;                        /* top for this function */
+	struct CallInfo *previous, *next; /* dynamic call link */
+	short nresults;                   /* expected number of results from this function */
+	lu_byte callstatus;
+	ptrdiff_t extra;
+	union {
+		struct
+		{               /* only for Lua functions */
+			StkId base; /* base for this function */
+			const Instruction *savedpc;
+		} l;
+		struct
+		{                    /* only for C functions */
+			int ctx;         /* context info. in case of yields */
+			lua_CFunction k; /* continuation in case of yields */
+			ptrdiff_t old_errfunc;
+			lu_byte old_allowhook;
+			lu_byte status;
+		} c;
+	} u;
+} CallInfo;
+
+/*
+** Bits in CallInfo status
+*/
+#define CIST_LUA (1 << 0)       /* call is running a Lua function */
+#define CIST_HOOKED (1 << 1)    /* call is running a debug hook */
+#define CIST_REENTRY (1 << 2)   /* call is running on same invocation of
+                                   luaV_execute of previous call */
+#define CIST_YIELDED (1 << 3)   /* call reentered after suspension */
+#define CIST_YPCALL (1 << 4)    /* call is a yieldable protected call */
+#define CIST_STAT (1 << 5)      /* call has an error status (pcall) */
+#define CIST_TAIL (1 << 6)      /* call was tail called */
+#define CIST_HOOKYIELD (1 << 7) /* last hook called yielded */
+
+#define isLua(ci) ((ci)->callstatus & CIST_LUA)
+
+/*
+** `global state', shared by all threads of this state
+*/
+typedef struct global_State
+{
+	lua_Alloc frealloc; /* function to reallocate memory */
+	void *ud;           /* auxiliary data to `frealloc' */
+	lu_mem totalbytes;  /* number of bytes currently allocated - GCdebt */
+	l_mem GCdebt;       /* bytes allocated not yet compensated by the collector */
+	lu_mem GCmemtrav;   /* memory traversed by the GC */
+	lu_mem GCestimate;  /* an estimate of the non-garbage memory in use */
+	stringtable strt;   /* hash table for strings */
+	TValue l_registry;
+	unsigned int seed; /* randomized seed for hashes */
+	lu_byte currentwhite;
+	lu_byte gcstate;     /* state of garbage collector */
+	lu_byte gckind;      /* kind of GC running */
+	lu_byte gcrunning;   /* true if GC is running */
+	int sweepstrgc;      /* position of sweep in `strt' */
+	GCObject *allgc;     /* list of all collectable objects */
+	GCObject *finobj;    /* list of collectable objects with finalizers */
+	GCObject **sweepgc;  /* current position of sweep in list 'allgc' */
+	GCObject **sweepfin; /* current position of sweep in list 'finobj' */
+	GCObject *gray;      /* list of gray objects */
+	GCObject *grayagain; /* list of objects to be traversed atomically */
+	GCObject *weak;      /* list of tables with weak values */
+	GCObject *ephemeron; /* list of ephemeron tables (weak keys) */
+	GCObject *allweak;   /* list of all-weak tables */
+	GCObject *tobefnz;   /* list of userdata to be GC */
+	UpVal uvhead;        /* head of double-linked list of all open upvalues */
+	Mbuffer buff;        /* temporary buffer for string concatenation */
+	int gcpause;         /* size of pause between successive GCs */
+	int gcmajorinc;      /* pause between major collections (only in gen. mode) */
+	int gcstepmul;       /* GC `granularity' */
+	lua_CFunction panic; /* to be called in unprotected errors */
+	struct lua_State *mainthread;
+	const lua_Number *version;     /* pointer to version number */
+	TString *memerrmsg;            /* memory-error message */
+	TString *tmname[TM_N];         /* array with tag-method names */
+	struct Table *mt[LUA_NUMTAGS]; /* metatables for basic types */
+} global_State;
+
+/*
+** `per thread' state
+*/
+struct lua_State
+{
+	CommonHeader;
+	lu_byte status;
+	StkId top; /* first free slot in the stack */
+	global_State *l_G;
+	CallInfo *ci;             /* call info for current function */
+	const Instruction *oldpc; /* last pc traced */
+	StkId stack_last;         /* last free slot in the stack */
+	StkId stack;              /* stack base */
+	int stacksize;
+	unsigned short nny;     /* number of non-yieldable calls in stack */
+	unsigned short nCcalls; /* number of nested C calls */
+	lu_byte hookmask;
+	lu_byte allowhook;
+	int basehookcount;
+	int hookcount;
+	lua_Hook hook;
+	GCObject *openupval; /* list of open upvalues in this stack */
+	GCObject *gclist;
+	struct lua_longjmp *errorJmp; /* current error recover point */
+	ptrdiff_t errfunc;            /* current error handling function (stack index) */
+	CallInfo base_ci;             /* CallInfo for first level (C calling Lua) */
+};
+
+#define G(L) (L->l_G)
+
+/*
+** Union of all collectable objects
+*/
+union GCObject {
+	GCheader gch; /* common header */
+	union TString ts;
+	union Udata u;
+	union Closure cl;
+	struct Table h;
+	struct Proto p;
+	struct UpVal uv;
+	struct lua_State th; /* thread */
+};
+
+#define gch(o) (&(o)->gch)
+
+/* macros to convert a GCObject into a specific value */
+#define rawgco2ts(o) \
+	check_exp(novariant((o)->gch.tt) == LUA_TSTRING, &((o)->ts))
+#define gco2ts(o) (&rawgco2ts(o)->tsv)
+#define rawgco2u(o) check_exp((o)->gch.tt == LUA_TUSERDATA, &((o)->u))
+#define gco2u(o) (&rawgco2u(o)->uv)
+#define gco2lcl(o) check_exp((o)->gch.tt == LUA_TLCL, &((o)->cl.l))
+#define gco2ccl(o) check_exp((o)->gch.tt == LUA_TCCL, &((o)->cl.c))
+#define gco2cl(o) \
+	check_exp(novariant((o)->gch.tt) == LUA_TFUNCTION, &((o)->cl))
+#define gco2t(o) check_exp((o)->gch.tt == LUA_TTABLE, &((o)->h))
+#define gco2p(o) check_exp((o)->gch.tt == LUA_TPROTO, &((o)->p))
+#define gco2uv(o) check_exp((o)->gch.tt == LUA_TUPVAL, &((o)->uv))
+#define gco2th(o) check_exp((o)->gch.tt == LUA_TTHREAD, &((o)->th))
+
+/* macro to convert any Lua object into a GCObject */
+#define obj2gco(v) (cast(GCObject *, (v)))
+
+/* actual number of total bytes allocated */
+#define gettotalbytes(g) ((g)->totalbytes + (g)->GCdebt)
+
+LUAI_FUNC void luaE_setdebt(global_State *g, l_mem debt);
+LUAI_FUNC void luaE_freethread(lua_State *L, lua_State *L1);
+LUAI_FUNC CallInfo *luaE_extendCI(lua_State *L);
+LUAI_FUNC void luaE_freeCI(lua_State *L);
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lstring.h b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lstring.h
new file mode 100644
index 00000000..73f5dcef
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lstring.h
@@ -0,0 +1,41 @@
+/*
+** $Id: lstring.h,v 1.49.1.1 2013/04/12 18:48:47 roberto Exp $
+** String table (keep all strings handled by Lua)
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lstring_h
+#define lstring_h
+
+#include "lgc.h"
+#include "lobject.h"
+#include "lstate.h"
+
+#define sizestring(s) (sizeof(union TString) + ((s)->len + 1) * sizeof(char))
+
+#define sizeudata(u) (sizeof(union Udata) + (u)->len)
+
+#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \
+											(sizeof(s) / sizeof(char)) - 1))
+
+#define luaS_fix(s) l_setbit((s)->tsv.marked, FIXEDBIT)
+
+/*
+** test whether a string is a reserved word
+*/
+#define isreserved(s) ((s)->tsv.tt == LUA_TSHRSTR && (s)->tsv.extra > 0)
+
+/*
+** equality for short strings, which are always internalized
+*/
+#define eqshrstr(a, b) check_exp((a)->tsv.tt == LUA_TSHRSTR, (a) == (b))
+
+LUAI_FUNC unsigned int luaS_hash(const char *str, size_t l, unsigned int seed);
+LUAI_FUNC int luaS_eqlngstr(TString *a, TString *b);
+LUAI_FUNC int luaS_eqstr(TString *a, TString *b);
+LUAI_FUNC void luaS_resize(lua_State *L, int newsize);
+LUAI_FUNC Udata *luaS_newudata(lua_State *L, size_t s, Table *e);
+LUAI_FUNC TString *luaS_newlstr(lua_State *L, const char *str, size_t l);
+LUAI_FUNC TString *luaS_new(lua_State *L, const char *str);
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/ltable.h b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/ltable.h
new file mode 100644
index 00000000..e58e36c9
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/ltable.h
@@ -0,0 +1,41 @@
+/*
+** $Id: ltable.h,v 2.16.1.2 2013/08/30 15:49:41 roberto Exp $
+** Lua tables (hash)
+** See Copyright Notice in lua.h
+*/
+
+#ifndef ltable_h
+#define ltable_h
+
+#include "lobject.h"
+
+#define gnode(t, i) (&(t)->node[i])
+#define gkey(n) (&(n)->i_key.tvk)
+#define gval(n) (&(n)->i_val)
+#define gnext(n) ((n)->i_key.nk.next)
+
+#define invalidateTMcache(t) ((t)->flags = 0)
+
+/* returns the key, given the value of a table entry */
+#define keyfromval(v) \
+	(gkey(cast(Node *, cast(char *, (v)) - offsetof(Node, i_val))))
+
+LUAI_FUNC const TValue *luaH_getint(Table *t, int key);
+LUAI_FUNC void luaH_setint(lua_State *L, Table *t, int key, TValue *value);
+LUAI_FUNC const TValue *luaH_getstr(Table *t, TString *key);
+LUAI_FUNC const TValue *luaH_get(Table *t, const TValue *key);
+LUAI_FUNC TValue *luaH_newkey(lua_State *L, Table *t, const TValue *key);
+LUAI_FUNC TValue *luaH_set(lua_State *L, Table *t, const TValue *key);
+LUAI_FUNC Table *luaH_new(lua_State *L);
+LUAI_FUNC void luaH_resize(lua_State *L, Table *t, int nasize, int nhsize);
+LUAI_FUNC void luaH_resizearray(lua_State *L, Table *t, int nasize);
+LUAI_FUNC void luaH_free(lua_State *L, Table *t);
+LUAI_FUNC int luaH_next(lua_State *L, Table *t, StkId key);
+LUAI_FUNC int luaH_getn(Table *t);
+
+#if defined(LUA_DEBUG)
+LUAI_FUNC Node *luaH_mainposition(const Table *t, const TValue *key);
+LUAI_FUNC int luaH_isdummy(Node *n);
+#endif
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/ltm.h b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/ltm.h
new file mode 100644
index 00000000..13d0b789
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/ltm.h
@@ -0,0 +1,52 @@
+/*
+** $Id: ltm.h,v 2.11.1.1 2013/04/12 18:48:47 roberto Exp $
+** Tag methods
+** See Copyright Notice in lua.h
+*/
+
+#ifndef ltm_h
+#define ltm_h
+
+#include "lobject.h"
+
+/*
+* WARNING: if you change the order of this enumeration,
+* grep "ORDER TM"
+*/
+typedef enum
+{
+	TM_INDEX,
+	TM_NEWINDEX,
+	TM_GC,
+	TM_MODE,
+	TM_LEN,
+	TM_EQ, /* last tag method with `fast' access */
+	TM_ADD,
+	TM_SUB,
+	TM_MUL,
+	TM_DIV,
+	TM_MOD,
+	TM_POW,
+	TM_UNM,
+	TM_LT,
+	TM_LE,
+	TM_CONCAT,
+	TM_CALL,
+	TM_N /* number of elements in the enum */
+} TMS;
+
+#define gfasttm(g, et, e) ((et) == NULL ? NULL : ((et)->flags & (1u << (e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e]))
+
+#define fasttm(l, et, e) gfasttm(G(l), et, e)
+
+#define ttypename(x) luaT_typenames_[(x) + 1]
+#define objtypename(x) ttypename(ttypenv(x))
+
+LUAI_DDEC const char *const luaT_typenames_[LUA_TOTALTAGS];
+
+LUAI_FUNC const TValue *luaT_gettm(Table *events, TMS event, TString *ename);
+LUAI_FUNC const TValue *luaT_gettmbyobj(lua_State *L, const TValue *o,
+										TMS event);
+LUAI_FUNC void luaT_init(lua_State *L);
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lua.h b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lua.h
new file mode 100644
index 00000000..cd2e3636
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lua.h
@@ -0,0 +1,405 @@
+/*
+** $Id: lua.h,v 1.285.1.2 2013/11/11 12:09:16 roberto Exp $
+** Lua - A Scripting Language
+** Lua.org, PUC-Rio, Brazil (http://www.lua.org)
+** See Copyright Notice at the end of this file
+*/
+
+#ifndef lua_h
+#define lua_h
+
+#include <stdarg.h>
+#include <stddef.h>
+
+#include "luaconf.h"
+
+#define LUA_VERSION_MAJOR "5"
+#define LUA_VERSION_MINOR "2"
+#define LUA_VERSION_NUM 502
+#define LUA_VERSION_RELEASE "3"
+
+#define LUA_VERSION "Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
+#define LUA_RELEASE LUA_VERSION "." LUA_VERSION_RELEASE
+#define LUA_COPYRIGHT LUA_RELEASE "  Copyright (C) 1994-2013 Lua.org, PUC-Rio"
+#define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo, W. Celes"
+
+/* mark for precompiled code ('<esc>Lua') */
+#define LUA_SIGNATURE "\033Lua"
+
+/* option for multiple returns in 'lua_pcall' and 'lua_call' */
+#define LUA_MULTRET (-1)
+
+/*
+** pseudo-indices
+*/
+#define LUA_REGISTRYINDEX LUAI_FIRSTPSEUDOIDX
+#define lua_upvalueindex(i) (LUA_REGISTRYINDEX - (i))
+
+/* thread status */
+#define LUA_OK 0
+#define LUA_YIELD 1
+#define LUA_ERRRUN 2
+#define LUA_ERRSYNTAX 3
+#define LUA_ERRMEM 4
+#define LUA_ERRGCMM 5
+#define LUA_ERRERR 6
+
+typedef struct lua_State lua_State;
+
+typedef int (*lua_CFunction)(lua_State *L);
+
+/*
+** functions that read/write blocks when loading/dumping Lua chunks
+*/
+typedef const char *(*lua_Reader)(lua_State *L, void *ud, size_t *sz);
+
+typedef int (*lua_Writer)(lua_State *L, const void *p, size_t sz, void *ud);
+
+/*
+** prototype for memory-allocation functions
+*/
+typedef void *(*lua_Alloc)(void *ud, void *ptr, size_t osize, size_t nsize);
+
+/*
+** basic types
+*/
+#define LUA_TNONE (-1)
+
+#define LUA_TNIL 0
+#define LUA_TBOOLEAN 1
+#define LUA_TLIGHTUSERDATA 2
+#define LUA_TNUMBER 3
+#define LUA_TSTRING 4
+#define LUA_TTABLE 5
+#define LUA_TFUNCTION 6
+#define LUA_TUSERDATA 7
+#define LUA_TTHREAD 8
+
+#define LUA_NUMTAGS 9
+
+/* minimum Lua stack available to a C function */
+#define LUA_MINSTACK 20
+
+/* predefined values in the registry */
+#define LUA_RIDX_MAINTHREAD 1
+#define LUA_RIDX_GLOBALS 2
+#define LUA_RIDX_LAST LUA_RIDX_GLOBALS
+
+/* type of numbers in Lua */
+typedef LUA_NUMBER lua_Number;
+
+/* type for integer functions */
+typedef LUA_INTEGER lua_Integer;
+
+/* unsigned integer type */
+typedef LUA_UNSIGNED lua_Unsigned;
+
+/*
+** generic extra include file
+*/
+#if defined(LUA_USER_H)
+#include LUA_USER_H
+#endif
+
+/*
+** RCS ident string
+*/
+extern const char lua_ident[];
+
+/*
+** state manipulation
+*/
+LUA_API lua_State *(lua_newstate)(lua_Alloc f, void *ud);
+LUA_API void(lua_close)(lua_State *L);
+LUA_API lua_State *(lua_newthread)(lua_State *L);
+
+LUA_API lua_CFunction(lua_atpanic)(lua_State *L, lua_CFunction panicf);
+
+LUA_API const lua_Number *(lua_version)(lua_State *L);
+
+/*
+** basic stack manipulation
+*/
+LUA_API int(lua_absindex)(lua_State *L, int idx);
+LUA_API int(lua_gettop)(lua_State *L);
+LUA_API void(lua_settop)(lua_State *L, int idx);
+LUA_API void(lua_pushvalue)(lua_State *L, int idx);
+LUA_API void(lua_remove)(lua_State *L, int idx);
+LUA_API void(lua_insert)(lua_State *L, int idx);
+LUA_API void(lua_replace)(lua_State *L, int idx);
+LUA_API void(lua_copy)(lua_State *L, int fromidx, int toidx);
+LUA_API int(lua_checkstack)(lua_State *L, int sz);
+
+LUA_API void(lua_xmove)(lua_State *from, lua_State *to, int n);
+
+/*
+** access functions (stack -> C)
+*/
+
+LUA_API int(lua_isnumber)(lua_State *L, int idx);
+LUA_API int(lua_isstring)(lua_State *L, int idx);
+LUA_API int(lua_iscfunction)(lua_State *L, int idx);
+LUA_API int(lua_isuserdata)(lua_State *L, int idx);
+LUA_API int(lua_type)(lua_State *L, int idx);
+LUA_API const char *(lua_typename)(lua_State *L, int tp);
+
+LUA_API lua_Number(lua_tonumberx)(lua_State *L, int idx, int *isnum);
+LUA_API lua_Integer(lua_tointegerx)(lua_State *L, int idx, int *isnum);
+LUA_API lua_Unsigned(lua_tounsignedx)(lua_State *L, int idx, int *isnum);
+LUA_API int(lua_toboolean)(lua_State *L, int idx);
+LUA_API const char *(lua_tolstring)(lua_State *L, int idx, size_t *len);
+LUA_API size_t(lua_rawlen)(lua_State *L, int idx);
+LUA_API lua_CFunction(lua_tocfunction)(lua_State *L, int idx);
+LUA_API void *(lua_touserdata)(lua_State *L, int idx);
+LUA_API lua_State *(lua_tothread)(lua_State *L, int idx);
+LUA_API const void *(lua_topointer)(lua_State *L, int idx);
+
+/*
+** Comparison and arithmetic functions
+*/
+
+#define LUA_OPADD 0 /* ORDER TM */
+#define LUA_OPSUB 1
+#define LUA_OPMUL 2
+#define LUA_OPDIV 3
+#define LUA_OPMOD 4
+#define LUA_OPPOW 5
+#define LUA_OPUNM 6
+
+LUA_API void(lua_arith)(lua_State *L, int op);
+
+#define LUA_OPEQ 0
+#define LUA_OPLT 1
+#define LUA_OPLE 2
+
+LUA_API int(lua_rawequal)(lua_State *L, int idx1, int idx2);
+LUA_API int(lua_compare)(lua_State *L, int idx1, int idx2, int op);
+
+/*
+** push functions (C -> stack)
+*/
+LUA_API void(lua_pushnil)(lua_State *L);
+LUA_API void(lua_pushnumber)(lua_State *L, lua_Number n);
+LUA_API void(lua_pushinteger)(lua_State *L, lua_Integer n);
+LUA_API void(lua_pushunsigned)(lua_State *L, lua_Unsigned n);
+LUA_API const char *(lua_pushlstring)(lua_State *L, const char *s, size_t l);
+LUA_API const char *(lua_pushstring)(lua_State *L, const char *s);
+LUA_API const char *(lua_pushvfstring)(lua_State *L, const char *fmt,
+									   va_list argp);
+LUA_API const char *(lua_pushfstring)(lua_State *L, const char *fmt, ...);
+LUA_API void(lua_pushcclosure)(lua_State *L, lua_CFunction fn, int n);
+LUA_API void(lua_pushboolean)(lua_State *L, int b);
+LUA_API void(lua_pushlightuserdata)(lua_State *L, void *p);
+LUA_API int(lua_pushthread)(lua_State *L);
+
+/*
+** get functions (Lua -> stack)
+*/
+LUA_API void(lua_getglobal)(lua_State *L, const char *var);
+LUA_API void(lua_gettable)(lua_State *L, int idx);
+LUA_API void(lua_getfield)(lua_State *L, int idx, const char *k);
+LUA_API void(lua_rawget)(lua_State *L, int idx);
+LUA_API void(lua_rawgeti)(lua_State *L, int idx, int n);
+LUA_API void(lua_rawgetp)(lua_State *L, int idx, const void *p);
+LUA_API void(lua_createtable)(lua_State *L, int narr, int nrec);
+LUA_API void *(lua_newuserdata)(lua_State *L, size_t sz);
+LUA_API int(lua_getmetatable)(lua_State *L, int objindex);
+LUA_API void(lua_getuservalue)(lua_State *L, int idx);
+
+/*
+** set functions (stack -> Lua)
+*/
+LUA_API void(lua_setglobal)(lua_State *L, const char *var);
+LUA_API void(lua_settable)(lua_State *L, int idx);
+LUA_API void(lua_setfield)(lua_State *L, int idx, const char *k);
+LUA_API void(lua_rawset)(lua_State *L, int idx);
+LUA_API void(lua_rawseti)(lua_State *L, int idx, int n);
+LUA_API void(lua_rawsetp)(lua_State *L, int idx, const void *p);
+LUA_API int(lua_setmetatable)(lua_State *L, int objindex);
+LUA_API void(lua_setuservalue)(lua_State *L, int idx);
+
+/*
+** 'load' and 'call' functions (load and run Lua code)
+*/
+LUA_API void(lua_callk)(lua_State *L, int nargs, int nresults, int ctx,
+						lua_CFunction k);
+#define lua_call(L, n, r) lua_callk(L, (n), (r), 0, NULL)
+
+LUA_API int(lua_getctx)(lua_State *L, int *ctx);
+
+LUA_API int(lua_pcallk)(lua_State *L, int nargs, int nresults, int errfunc,
+						int ctx, lua_CFunction k);
+#define lua_pcall(L, n, r, f) lua_pcallk(L, (n), (r), (f), 0, NULL)
+
+LUA_API int(lua_load)(lua_State *L, lua_Reader reader, void *dt,
+					  const char *chunkname,
+					  const char *mode);
+
+LUA_API int(lua_dump)(lua_State *L, lua_Writer writer, void *data);
+
+/*
+** coroutine functions
+*/
+LUA_API int(lua_yieldk)(lua_State *L, int nresults, int ctx,
+						lua_CFunction k);
+#define lua_yield(L, n) lua_yieldk(L, (n), 0, NULL)
+LUA_API int(lua_resume)(lua_State *L, lua_State *from, int narg);
+LUA_API int(lua_status)(lua_State *L);
+
+/*
+** garbage-collection function and options
+*/
+
+#define LUA_GCSTOP 0
+#define LUA_GCRESTART 1
+#define LUA_GCCOLLECT 2
+#define LUA_GCCOUNT 3
+#define LUA_GCCOUNTB 4
+#define LUA_GCSTEP 5
+#define LUA_GCSETPAUSE 6
+#define LUA_GCSETSTEPMUL 7
+#define LUA_GCSETMAJORINC 8
+#define LUA_GCISRUNNING 9
+#define LUA_GCGEN 10
+#define LUA_GCINC 11
+
+LUA_API int(lua_gc)(lua_State *L, int what, int data);
+
+/*
+** miscellaneous functions
+*/
+
+LUA_API int(lua_error)(lua_State *L);
+
+LUA_API int(lua_next)(lua_State *L, int idx);
+
+LUA_API void(lua_concat)(lua_State *L, int n);
+LUA_API void(lua_len)(lua_State *L, int idx);
+
+LUA_API lua_Alloc(lua_getallocf)(lua_State *L, void **ud);
+LUA_API void(lua_setallocf)(lua_State *L, lua_Alloc f, void *ud);
+
+/*
+** ===============================================================
+** some useful macros
+** ===============================================================
+*/
+
+#define lua_tonumber(L, i) lua_tonumberx(L, i, NULL)
+#define lua_tointeger(L, i) lua_tointegerx(L, i, NULL)
+#define lua_tounsigned(L, i) lua_tounsignedx(L, i, NULL)
+
+#define lua_pop(L, n) lua_settop(L, -(n)-1)
+
+#define lua_newtable(L) lua_createtable(L, 0, 0)
+
+#define lua_register(L, n, f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
+
+#define lua_pushcfunction(L, f) lua_pushcclosure(L, (f), 0)
+
+#define lua_isfunction(L, n) (lua_type(L, (n)) == LUA_TFUNCTION)
+#define lua_istable(L, n) (lua_type(L, (n)) == LUA_TTABLE)
+#define lua_islightuserdata(L, n) (lua_type(L, (n)) == LUA_TLIGHTUSERDATA)
+#define lua_isnil(L, n) (lua_type(L, (n)) == LUA_TNIL)
+#define lua_isboolean(L, n) (lua_type(L, (n)) == LUA_TBOOLEAN)
+#define lua_isthread(L, n) (lua_type(L, (n)) == LUA_TTHREAD)
+#define lua_isnone(L, n) (lua_type(L, (n)) == LUA_TNONE)
+#define lua_isnoneornil(L, n) (lua_type(L, (n)) <= 0)
+
+#define lua_pushliteral(L, s) \
+	lua_pushlstring(L, "" s, (sizeof(s) / sizeof(char)) - 1)
+
+#define lua_pushglobaltable(L) \
+	lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS)
+
+#define lua_tostring(L, i) lua_tolstring(L, (i), NULL)
+
+/*
+** {======================================================================
+** Debug API
+** =======================================================================
+*/
+
+/*
+** Event codes
+*/
+#define LUA_HOOKCALL 0
+#define LUA_HOOKRET 1
+#define LUA_HOOKLINE 2
+#define LUA_HOOKCOUNT 3
+#define LUA_HOOKTAILCALL 4
+
+/*
+** Event masks
+*/
+#define LUA_MASKCALL (1 << LUA_HOOKCALL)
+#define LUA_MASKRET (1 << LUA_HOOKRET)
+#define LUA_MASKLINE (1 << LUA_HOOKLINE)
+#define LUA_MASKCOUNT (1 << LUA_HOOKCOUNT)
+
+typedef struct lua_Debug lua_Debug; /* activation record */
+
+/* Functions to be called by the debugger in specific events */
+typedef void (*lua_Hook)(lua_State *L, lua_Debug *ar);
+
+LUA_API int(lua_getstack)(lua_State *L, int level, lua_Debug *ar);
+LUA_API int(lua_getinfo)(lua_State *L, const char *what, lua_Debug *ar);
+LUA_API const char *(lua_getlocal)(lua_State *L, const lua_Debug *ar, int n);
+LUA_API const char *(lua_setlocal)(lua_State *L, const lua_Debug *ar, int n);
+LUA_API const char *(lua_getupvalue)(lua_State *L, int funcindex, int n);
+LUA_API const char *(lua_setupvalue)(lua_State *L, int funcindex, int n);
+
+LUA_API void *(lua_upvalueid)(lua_State *L, int fidx, int n);
+LUA_API void(lua_upvaluejoin)(lua_State *L, int fidx1, int n1,
+							  int fidx2, int n2);
+
+LUA_API int(lua_sethook)(lua_State *L, lua_Hook func, int mask, int count);
+LUA_API lua_Hook(lua_gethook)(lua_State *L);
+LUA_API int(lua_gethookmask)(lua_State *L);
+LUA_API int(lua_gethookcount)(lua_State *L);
+
+struct lua_Debug
+{
+	int event;
+	const char *name;           /* (n) */
+	const char *namewhat;       /* (n) 'global', 'local', 'field', 'method' */
+	const char *what;           /* (S) 'Lua', 'C', 'main', 'tail' */
+	const char *source;         /* (S) */
+	int currentline;            /* (l) */
+	int linedefined;            /* (S) */
+	int lastlinedefined;        /* (S) */
+	unsigned char nups;         /* (u) number of upvalues */
+	unsigned char nparams;      /* (u) number of parameters */
+	char isvararg;              /* (u) */
+	char istailcall;            /* (t) */
+	char short_src[LUA_IDSIZE]; /* (S) */
+	/* private part */
+	struct CallInfo *i_ci; /* active function */
+};
+
+/* }====================================================================== */
+
+/******************************************************************************
+* Copyright (C) 1994-2013 Lua.org, PUC-Rio.
+*
+* 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.
+******************************************************************************/
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lua.hpp b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lua.hpp
new file mode 100644
index 00000000..2239969c
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lua.hpp
@@ -0,0 +1,10 @@
+// lua.hpp
+// Lua header files for C++
+// <<extern "C">> not supplied automatically because Lua also compiles as C++
+
+extern "C"
+{
+#include "lua.h"
+#include "lualib.h"
+#include "lauxlib.h"
+}
diff --git a/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/luaconf.h b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/luaconf.h
new file mode 100644
index 00000000..a9f18c7c
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/luaconf.h
@@ -0,0 +1,509 @@
+/*
+** $Id: luaconf.h,v 1.176.1.1 2013/04/12 18:48:47 roberto Exp $
+** Configuration file for Lua
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lconfig_h
+#define lconfig_h
+
+#include <limits.h>
+#include <stddef.h>
+
+/*
+** ==================================================================
+** Search for "@@" to find all configurable definitions.
+** ===================================================================
+*/
+
+/*
+@@ LUA_ANSI controls the use of non-ansi features.
+** CHANGE it (define it) if you want Lua to avoid the use of any
+** non-ansi feature or library.
+*/
+#if !defined(LUA_ANSI) && defined(__STRICT_ANSI__)
+#define LUA_ANSI
+#endif
+
+#if !defined(LUA_ANSI) && defined(_WIN32) && !defined(_WIN32_WCE)
+#define LUA_WIN /* enable goodies for regular Windows platforms */
+#endif
+
+#if defined(LUA_WIN)
+#define LUA_DL_DLL
+#define LUA_USE_AFORMAT /* assume 'printf' handles 'aA' specifiers */
+#endif
+
+#if defined(LUA_USE_LINUX)
+#define LUA_USE_POSIX
+//#define LUA_USE_DLOPEN		/* needs an extra library: -ldl */
+//#define LUA_USE_READLINE	/* needs some extra libraries */
+#define LUA_USE_STRTODHEX /* assume 'strtod' handles hex formats */
+#define LUA_USE_AFORMAT   /* assume 'printf' handles 'aA' specifiers */
+#define LUA_USE_LONGLONG  /* assume support for long long */
+#endif
+
+#if defined(LUA_USE_MACOSX)
+#define LUA_USE_POSIX
+//#define LUA_USE_DLOPEN		/* does not need -ldl */
+//#define LUA_USE_READLINE	/* needs an extra library: -lreadline */
+#define LUA_USE_STRTODHEX /* assume 'strtod' handles hex formats */
+#define LUA_USE_AFORMAT   /* assume 'printf' handles 'aA' specifiers */
+#define LUA_USE_LONGLONG  /* assume support for long long */
+#endif
+
+/*
+@@ LUA_USE_POSIX includes all functionality listed as X/Open System
+@* Interfaces Extension (XSI).
+** CHANGE it (define it) if your system is XSI compatible.
+*/
+#if defined(LUA_USE_POSIX)
+#define LUA_USE_MKSTEMP
+#define LUA_USE_ISATTY
+#define LUA_USE_POPEN
+#define LUA_USE_ULONGJMP
+#define LUA_USE_GMTIME_R
+#endif
+
+/*
+@@ LUA_PATH_DEFAULT is the default path that Lua uses to look for
+@* Lua libraries.
+@@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for
+@* C libraries.
+** CHANGE them if your machine has a non-conventional directory
+** hierarchy or if you want to install your libraries in
+** non-conventional directories.
+*/
+#if defined(_WIN32) /* { */
+/*
+** In Windows, any exclamation mark ('!') in the path is replaced by the
+** path of the directory of the executable file of the current process.
+*/
+#define LUA_LDIR "!\\lua\\"
+#define LUA_CDIR "!\\"
+#define LUA_PATH_DEFAULT                                                 \
+	LUA_LDIR "?.lua;" LUA_LDIR "?\\init.lua;" LUA_CDIR "?.lua;" LUA_CDIR \
+			 "?\\init.lua;"                                              \
+			 ".\\?.lua"
+#define LUA_CPATH_DEFAULT      \
+	LUA_CDIR "?.dll;" LUA_CDIR \
+			 "loadall.dll;"    \
+			 ".\\?.dll"
+
+#else /* }{ */
+
+#define LUA_VDIR LUA_VERSION_MAJOR "." LUA_VERSION_MINOR "/"
+#define LUA_ROOT "/usr/local/"
+#define LUA_LDIR LUA_ROOT "share/lua/" LUA_VDIR
+#define LUA_CDIR LUA_ROOT "lib/lua/" LUA_VDIR
+#define LUA_PATH_DEFAULT                                                \
+	LUA_LDIR "?.lua;" LUA_LDIR "?/init.lua;" LUA_CDIR "?.lua;" LUA_CDIR \
+			 "?/init.lua;"                                              \
+			 "./?.lua"
+#define LUA_CPATH_DEFAULT     \
+	LUA_CDIR "?.so;" LUA_CDIR \
+			 "loadall.so;"    \
+			 "./?.so"
+#endif /* } */
+
+/*
+@@ LUA_DIRSEP is the directory separator (for submodules).
+** CHANGE it if your machine does not use "/" as the directory separator
+** and is not Windows. (On Windows Lua automatically uses "\".)
+*/
+#if defined(_WIN32)
+#define LUA_DIRSEP "\\"
+#else
+#define LUA_DIRSEP "/"
+#endif
+
+/*
+@@ LUA_ENV is the name of the variable that holds the current
+@@ environment, used to access global names.
+** CHANGE it if you do not like this name.
+*/
+#define LUA_ENV "_ENV"
+
+/*
+@@ LUA_API is a mark for all core API functions.
+@@ LUALIB_API is a mark for all auxiliary library functions.
+@@ LUAMOD_API is a mark for all standard library opening functions.
+** CHANGE them if you need to define those functions in some special way.
+** For instance, if you want to create one Windows DLL with the core and
+** the libraries, you may want to use the following definition (define
+** LUA_BUILD_AS_DLL to get it).
+*/
+#if defined(LUA_BUILD_AS_DLL) /* { */
+
+#if defined(LUA_CORE) || defined(LUA_LIB) /* { */
+#define LUA_API __declspec(dllexport)
+#else /* }{ */
+#define LUA_API __declspec(dllimport)
+#endif /* } */
+
+#else /* }{ */
+
+#define LUA_API extern
+
+#endif /* } */
+
+/* more often than not the libs go together with the core */
+#define LUALIB_API LUA_API
+#define LUAMOD_API LUALIB_API
+
+/*
+@@ LUAI_FUNC is a mark for all extern functions that are not to be
+@* exported to outside modules.
+@@ LUAI_DDEF and LUAI_DDEC are marks for all extern (const) variables
+@* that are not to be exported to outside modules (LUAI_DDEF for
+@* definitions and LUAI_DDEC for declarations).
+** CHANGE them if you need to mark them in some special way. Elf/gcc
+** (versions 3.2 and later) mark them as "hidden" to optimize access
+** when Lua is compiled as a shared library. Not all elf targets support
+** this attribute. Unfortunately, gcc does not offer a way to check
+** whether the target offers that support, and those without support
+** give a warning about it. To avoid these warnings, change to the
+** default definition.
+*/
+#if defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 302) && \
+	defined(__ELF__) /* { */
+#define LUAI_FUNC __attribute__((visibility("hidden"))) extern
+#define LUAI_DDEC LUAI_FUNC
+#define LUAI_DDEF /* empty */
+
+#else /* }{ */
+#define LUAI_FUNC extern
+#define LUAI_DDEC extern
+#define LUAI_DDEF /* empty */
+#endif            /* } */
+
+/*
+@@ LUA_QL describes how error messages quote program elements.
+** CHANGE it if you want a different appearance.
+*/
+#define LUA_QL(x) "'" x "'"
+#define LUA_QS LUA_QL("%s")
+
+/*
+@@ LUA_IDSIZE gives the maximum size for the description of the source
+@* of a function in debug information.
+** CHANGE it if you want a different size.
+*/
+#define LUA_IDSIZE 60
+
+/*
+@@ luai_writestring/luai_writeline define how 'print' prints its results.
+** They are only used in libraries and the stand-alone program. (The #if
+** avoids including 'stdio.h' everywhere.)
+*/
+#if defined(LUA_LIB) || defined(lua_c)
+#include <stdio.h>
+#define luai_writestring(s, l) fwrite((s), sizeof(char), (l), stdout)
+#define luai_writeline() (luai_writestring("\n", 1), fflush(stdout))
+#endif
+
+/*
+@@ luai_writestringerror defines how to print error messages.
+** (A format string with one argument is enough for Lua...)
+*/
+#define luai_writestringerror(s, p) \
+	(fprintf(stderr, (s), (p)), fflush(stderr))
+
+/*
+@@ LUAI_MAXSHORTLEN is the maximum length for short strings, that is,
+** strings that are internalized. (Cannot be smaller than reserved words
+** or tags for metamethods, as these strings must be internalized;
+** #("function") = 8, #("__newindex") = 10.)
+*/
+#define LUAI_MAXSHORTLEN 40
+
+/*
+** {==================================================================
+** Compatibility with previous versions
+** ===================================================================
+*/
+
+/*
+@@ LUA_COMPAT_ALL controls all compatibility options.
+** You can define it to get all options, or change specific options
+** to fit your specific needs.
+*/
+#if defined(LUA_COMPAT_ALL) /* { */
+
+/*
+@@ LUA_COMPAT_UNPACK controls the presence of global 'unpack'.
+** You can replace it with 'table.unpack'.
+*/
+#define LUA_COMPAT_UNPACK
+
+/*
+@@ LUA_COMPAT_LOADERS controls the presence of table 'package.loaders'.
+** You can replace it with 'package.searchers'.
+*/
+#define LUA_COMPAT_LOADERS
+
+/*
+@@ macro 'lua_cpcall' emulates deprecated function lua_cpcall.
+** You can call your C function directly (with light C functions).
+*/
+#define lua_cpcall(L, f, u)         \
+	(lua_pushcfunction(L, (f)),     \
+	 lua_pushlightuserdata(L, (u)), \
+	 lua_pcall(L, 1, 0, 0))
+
+/*
+@@ LUA_COMPAT_LOG10 defines the function 'log10' in the math library.
+** You can rewrite 'log10(x)' as 'log(x, 10)'.
+*/
+#define LUA_COMPAT_LOG10
+
+/*
+@@ LUA_COMPAT_LOADSTRING defines the function 'loadstring' in the base
+** library. You can rewrite 'loadstring(s)' as 'load(s)'.
+*/
+#define LUA_COMPAT_LOADSTRING
+
+/*
+@@ LUA_COMPAT_MAXN defines the function 'maxn' in the table library.
+*/
+#define LUA_COMPAT_MAXN
+
+/*
+@@ The following macros supply trivial compatibility for some
+** changes in the API. The macros themselves document how to
+** change your code to avoid using them.
+*/
+#define lua_strlen(L, i) lua_rawlen(L, (i))
+
+#define lua_objlen(L, i) lua_rawlen(L, (i))
+
+#define lua_equal(L, idx1, idx2) lua_compare(L, (idx1), (idx2), LUA_OPEQ)
+#define lua_lessthan(L, idx1, idx2) lua_compare(L, (idx1), (idx2), LUA_OPLT)
+
+/*
+@@ LUA_COMPAT_MODULE controls compatibility with previous
+** module functions 'module' (Lua) and 'luaL_register' (C).
+*/
+#define LUA_COMPAT_MODULE
+
+#endif /* } */
+
+/* }================================================================== */
+
+/*
+@@ LUAI_BITSINT defines the number of bits in an int.
+** CHANGE here if Lua cannot automatically detect the number of bits of
+** your machine. Probably you do not need to change this.
+*/
+/* avoid overflows in comparison */
+#if INT_MAX - 20 < 32760 /* { */
+#define LUAI_BITSINT 16
+#elif INT_MAX > 2147483640L /* }{ */
+/* int has at least 32 bits */
+#define LUAI_BITSINT 32
+#else /* }{ */
+#error "you must define LUA_BITSINT with number of bits in an integer"
+#endif /* } */
+
+/*
+@@ LUA_INT32 is an signed integer with exactly 32 bits.
+@@ LUAI_UMEM is an unsigned integer big enough to count the total
+@* memory used by Lua.
+@@ LUAI_MEM is a signed integer big enough to count the total memory
+@* used by Lua.
+** CHANGE here if for some weird reason the default definitions are not
+** good enough for your machine. Probably you do not need to change
+** this.
+*/
+#if LUAI_BITSINT >= 32 /* { */
+#define LUA_INT32 int
+#define LUAI_UMEM size_t
+#define LUAI_MEM ptrdiff_t
+#else /* }{ */
+/* 16-bit ints */
+#define LUA_INT32 long
+#define LUAI_UMEM unsigned long
+#define LUAI_MEM long
+#endif /* } */
+
+/*
+@@ LUAI_MAXSTACK limits the size of the Lua stack.
+** CHANGE it if you need a different limit. This limit is arbitrary;
+** its only purpose is to stop Lua to consume unlimited stack
+** space (and to reserve some numbers for pseudo-indices).
+*/
+#if LUAI_BITSINT >= 32
+#define LUAI_MAXSTACK 1000000
+#else
+#define LUAI_MAXSTACK 15000
+#endif
+
+/* reserve some space for error handling */
+#define LUAI_FIRSTPSEUDOIDX (-LUAI_MAXSTACK - 1000)
+
+/*
+@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.
+** CHANGE it if it uses too much C-stack space.
+*/
+#define LUAL_BUFFERSIZE BUFSIZ
+
+/*
+** {==================================================================
+@@ LUA_NUMBER is the type of numbers in Lua.
+** CHANGE the following definitions only if you want to build Lua
+** with a number type different from double. You may also need to
+** change lua_number2int & lua_number2integer.
+** ===================================================================
+*/
+
+#define LUA_NUMBER_DOUBLE
+#define LUA_NUMBER double
+
+/*
+@@ LUAI_UACNUMBER is the result of an 'usual argument conversion'
+@* over a number.
+*/
+#define LUAI_UACNUMBER double
+
+/*
+@@ LUA_NUMBER_SCAN is the format for reading numbers.
+@@ LUA_NUMBER_FMT is the format for writing numbers.
+@@ lua_number2str converts a number to a string.
+@@ LUAI_MAXNUMBER2STR is maximum size of previous conversion.
+*/
+#define LUA_NUMBER_SCAN "%lf"
+#define LUA_NUMBER_FMT "%.14g"
+#define lua_number2str(s, n) sprintf((s), LUA_NUMBER_FMT, (n))
+#define LUAI_MAXNUMBER2STR 32 /* 16 digits, sign, point, and \0 */
+
+/*
+@@ l_mathop allows the addition of an 'l' or 'f' to all math operations
+*/
+#define l_mathop(x) (x)
+
+/*
+@@ lua_str2number converts a decimal numeric string to a number.
+@@ lua_strx2number converts an hexadecimal numeric string to a number.
+** In C99, 'strtod' does both conversions. C89, however, has no function
+** to convert floating hexadecimal strings to numbers. For these
+** systems, you can leave 'lua_strx2number' undefined and Lua will
+** provide its own implementation.
+*/
+#define lua_str2number(s, p) strtod((s), (p))
+
+#if defined(LUA_USE_STRTODHEX)
+#define lua_strx2number(s, p) strtod((s), (p))
+#endif
+
+/*
+@@ The luai_num* macros define the primitive operations over numbers.
+*/
+
+/* the following operations need the math library */
+#if defined(lobject_c) || defined(lvm_c)
+#include <math.h>
+#define luai_nummod(L, a, b) ((a)-l_mathop(floor)((a) / (b)) * (b))
+#define luai_numpow(L, a, b) (l_mathop(pow)(a, b))
+#endif
+
+/* these are quite standard operations */
+#if defined(LUA_CORE)
+#define luai_numadd(L, a, b) ((a) + (b))
+#define luai_numsub(L, a, b) ((a) - (b))
+#define luai_nummul(L, a, b) ((a) * (b))
+#define luai_numdiv(L, a, b) ((a) / (b))
+#define luai_numunm(L, a) (-(a))
+#define luai_numeq(a, b) ((a) == (b))
+#define luai_numlt(L, a, b) ((a) < (b))
+#define luai_numle(L, a, b) ((a) <= (b))
+#define luai_numisnan(L, a) (!luai_numeq((a), (a)))
+#endif
+
+/*
+@@ LUA_INTEGER is the integral type used by lua_pushinteger/lua_tointeger.
+** CHANGE that if ptrdiff_t is not adequate on your machine. (On most
+** machines, ptrdiff_t gives a good choice between int or long.)
+*/
+#define LUA_INTEGER ptrdiff_t
+
+/*
+@@ LUA_UNSIGNED is the integral type used by lua_pushunsigned/lua_tounsigned.
+** It must have at least 32 bits.
+*/
+#define LUA_UNSIGNED unsigned LUA_INT32
+
+/*
+** Some tricks with doubles
+*/
+
+#if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI) /* { */
+/*
+** The next definitions activate some tricks to speed up the
+** conversion from doubles to integer types, mainly to LUA_UNSIGNED.
+**
+@@ LUA_MSASMTRICK uses Microsoft assembler to avoid clashes with a
+** DirectX idiosyncrasy.
+**
+@@ LUA_IEEE754TRICK uses a trick that should work on any machine
+** using IEEE754 with a 32-bit integer type.
+**
+@@ LUA_IEEELL extends the trick to LUA_INTEGER; should only be
+** defined when LUA_INTEGER is a 32-bit integer.
+**
+@@ LUA_IEEEENDIAN is the endianness of doubles in your machine
+** (0 for little endian, 1 for big endian); if not defined, Lua will
+** check it dynamically for LUA_IEEE754TRICK (but not for LUA_NANTRICK).
+**
+@@ LUA_NANTRICK controls the use of a trick to pack all types into
+** a single double value, using NaN values to represent non-number
+** values. The trick only works on 32-bit machines (ints and pointers
+** are 32-bit values) with numbers represented as IEEE 754-2008 doubles
+** with conventional endianess (12345678 or 87654321), in CPUs that do
+** not produce signaling NaN values (all NaNs are quiet).
+*/
+
+/* Microsoft compiler on a Pentium (32 bit) ? */
+#if defined(LUA_WIN) && defined(_MSC_VER) && defined(_M_IX86) /* { */
+
+#define LUA_MSASMTRICK
+#define LUA_IEEEENDIAN 0
+#define LUA_NANTRICK
+
+/* pentium 32 bits? */
+#elif defined(__i386__) || defined(__i386) || defined(__X86__) /* }{ */
+
+#define LUA_IEEE754TRICK
+#define LUA_IEEELL
+#define LUA_IEEEENDIAN 0
+#define LUA_NANTRICK
+
+/* pentium 64 bits? */
+#elif defined(__x86_64) /* }{ */
+
+#define LUA_IEEE754TRICK
+#define LUA_IEEEENDIAN 0
+
+#elif defined(__POWERPC__) || defined(__ppc__) /* }{ */
+
+#define LUA_IEEE754TRICK
+#define LUA_IEEEENDIAN 1
+
+#else /* }{ */
+
+/* assume IEEE754 and a 32-bit integer type */
+#define LUA_IEEE754TRICK
+
+#endif /* } */
+
+#endif /* } */
+
+/* }================================================================== */
+
+/* =================================================================== */
+
+/*
+** Local configuration. You can use this space to add your redefinitions
+** without modifying the main part of the file.
+*/
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lualib.h b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lualib.h
new file mode 100644
index 00000000..f183bab0
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lualib.h
@@ -0,0 +1,48 @@
+/*
+** $Id: lualib.h,v 1.43.1.1 2013/04/12 18:48:47 roberto Exp $
+** Lua standard libraries
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lualib_h
+#define lualib_h
+
+#include "lua.h"
+
+LUAMOD_API int(luaopen_base)(lua_State *L);
+
+#define LUA_COLIBNAME "coroutine"
+LUAMOD_API int(luaopen_coroutine)(lua_State *L);
+
+#define LUA_TABLIBNAME "table"
+LUAMOD_API int(luaopen_table)(lua_State *L);
+
+#define LUA_IOLIBNAME "io"
+LUAMOD_API int(luaopen_io)(lua_State *L);
+
+#define LUA_OSLIBNAME "os"
+LUAMOD_API int(luaopen_os)(lua_State *L);
+
+#define LUA_STRLIBNAME "string"
+LUAMOD_API int(luaopen_string)(lua_State *L);
+
+#define LUA_BITLIBNAME "bit32"
+LUAMOD_API int(luaopen_bit32)(lua_State *L);
+
+#define LUA_MATHLIBNAME "math"
+LUAMOD_API int(luaopen_math)(lua_State *L);
+
+#define LUA_DBLIBNAME "debug"
+LUAMOD_API int(luaopen_debug)(lua_State *L);
+
+#define LUA_LOADLIBNAME "package"
+LUAMOD_API int(luaopen_package)(lua_State *L);
+
+/* open all previous libraries */
+LUALIB_API void(luaL_openlibs)(lua_State *L);
+
+#if !defined(lua_assert)
+#define lua_assert(x) ((void)0)
+#endif
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lundump.h b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lundump.h
new file mode 100644
index 00000000..7a4c50e7
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lundump.h
@@ -0,0 +1,28 @@
+/*
+** $Id: lundump.h,v 1.39.1.1 2013/04/12 18:48:47 roberto Exp $
+** load precompiled Lua chunks
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lundump_h
+#define lundump_h
+
+#include "lobject.h"
+#include "lzio.h"
+
+/* load one chunk; from lundump.c */
+LUAI_FUNC Closure* luaU_undump(lua_State* L, ZIO* Z, Mbuffer* buff, const char* name);
+
+/* make header; from lundump.c */
+LUAI_FUNC void luaU_header(lu_byte* h);
+
+/* dump one chunk; from ldump.c */
+LUAI_FUNC int luaU_dump(lua_State* L, const Proto* f, lua_Writer w, void* data, int strip);
+
+/* data to catch conversion errors */
+#define LUAC_TAIL "\x19\x93\r\n\x1a\n"
+
+/* size in bytes of header of binary files */
+#define LUAC_HEADERSIZE (sizeof(LUA_SIGNATURE) - sizeof(char) + 2 + 6 + sizeof(LUAC_TAIL) - sizeof(char))
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lvm.h b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lvm.h
new file mode 100644
index 00000000..7332da4a
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lvm.h
@@ -0,0 +1,40 @@
+/*
+** $Id: lvm.h,v 2.18.1.1 2013/04/12 18:48:47 roberto Exp $
+** Lua virtual machine
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lvm_h
+#define lvm_h
+
+#include "ldo.h"
+#include "lobject.h"
+#include "ltm.h"
+
+#define tostring(L, o) (ttisstring(o) || (luaV_tostring(L, o)))
+
+#define tonumber(o, n) (ttisnumber(o) || (((o) = luaV_tonumber(o, n)) != NULL))
+
+#define equalobj(L, o1, o2) (ttisequal(o1, o2) && luaV_equalobj_(L, o1, o2))
+
+#define luaV_rawequalobj(o1, o2) equalobj(NULL, o1, o2)
+
+/* not to called directly */
+LUAI_FUNC int luaV_equalobj_(lua_State *L, const TValue *t1, const TValue *t2);
+
+LUAI_FUNC int luaV_lessthan(lua_State *L, const TValue *l, const TValue *r);
+LUAI_FUNC int luaV_lessequal(lua_State *L, const TValue *l, const TValue *r);
+LUAI_FUNC const TValue *luaV_tonumber(const TValue *obj, TValue *n);
+LUAI_FUNC int luaV_tostring(lua_State *L, StkId obj);
+LUAI_FUNC void luaV_gettable(lua_State *L, const TValue *t, TValue *key,
+							 StkId val);
+LUAI_FUNC void luaV_settable(lua_State *L, const TValue *t, TValue *key,
+							 StkId val);
+LUAI_FUNC void luaV_finishOp(lua_State *L);
+LUAI_FUNC void luaV_execute(lua_State *L);
+LUAI_FUNC void luaV_concat(lua_State *L, int total);
+LUAI_FUNC void luaV_arith(lua_State *L, StkId ra, const TValue *rb,
+						  const TValue *rc, TMS op);
+LUAI_FUNC void luaV_objlen(lua_State *L, StkId ra, const TValue *rb);
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lzio.h b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lzio.h
new file mode 100644
index 00000000..38c5f8a3
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/lua-5.2.3/src/lzio.h
@@ -0,0 +1,59 @@
+/*
+** $Id: lzio.h,v 1.26.1.1 2013/04/12 18:48:47 roberto Exp $
+** Buffered streams
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lzio_h
+#define lzio_h
+
+#include "lua.h"
+
+#include "lmem.h"
+
+#define EOZ (-1) /* end of stream */
+
+typedef struct Zio ZIO;
+
+#define zgetc(z) (((z)->n--) > 0 ? cast_uchar(*(z)->p++) : luaZ_fill(z))
+
+typedef struct Mbuffer
+{
+	char *buffer;
+	size_t n;
+	size_t buffsize;
+} Mbuffer;
+
+#define luaZ_initbuffer(L, buff) ((buff)->buffer = NULL, (buff)->buffsize = 0)
+
+#define luaZ_buffer(buff) ((buff)->buffer)
+#define luaZ_sizebuffer(buff) ((buff)->buffsize)
+#define luaZ_bufflen(buff) ((buff)->n)
+
+#define luaZ_resetbuffer(buff) ((buff)->n = 0)
+
+#define luaZ_resizebuffer(L, buff, size)                                  \
+	(luaM_reallocvector(L, (buff)->buffer, (buff)->buffsize, size, char), \
+	 (buff)->buffsize = size)
+
+#define luaZ_freebuffer(L, buff) luaZ_resizebuffer(L, buff, 0)
+
+LUAI_FUNC char *luaZ_openspace(lua_State *L, Mbuffer *buff, size_t n);
+LUAI_FUNC void luaZ_init(lua_State *L, ZIO *z, lua_Reader reader,
+						 void *data);
+LUAI_FUNC size_t luaZ_read(ZIO *z, void *b, size_t n); /* read next n bytes */
+
+/* --------- Private Part ------------------ */
+
+struct Zio
+{
+	size_t n;          /* bytes still unread */
+	const char *p;     /* current position in buffer */
+	lua_Reader reader; /* reader function */
+	void *data;        /* additional data */
+	lua_State *L;      /* Lua state (for reader) */
+};
+
+LUAI_FUNC int luaZ_fill(ZIO *z);
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/midi/RtError.h b/engine/inc/bullet/ThirdPartyLibs/midi/RtError.h
new file mode 100644
index 00000000..2ca17253
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/midi/RtError.h
@@ -0,0 +1,62 @@
+/************************************************************************/
+/*! \class RtError
+\brief Exception handling class for RtAudio & RtMidi.
+
+The RtError class is quite simple but it does allow errors to be
+"caught" by RtError::Type. See the RtAudio and RtMidi
+documentation to know which methods can throw an RtError.
+
+*/
+/************************************************************************/
+
+#ifndef RTERROR_H
+#define RTERROR_H
+
+#include <exception>
+#include <iostream>
+#include <string>
+
+class RtError : public std::exception
+{
+public:
+	//! Defined RtError types.
+	enum Type
+	{
+		WARNING,           /*!< A non-critical error. */
+		DEBUG_WARNING,     /*!< A non-critical error which might be useful for debugging. */
+		UNSPECIFIED,       /*!< The default, unspecified error type. */
+		NO_DEVICES_FOUND,  /*!< No devices found on system. */
+		INVALID_DEVICE,    /*!< An invalid device ID was specified. */
+		MEMORY_ERROR,      /*!< An error occured during memory allocation. */
+		INVALID_PARAMETER, /*!< An invalid parameter was specified to a function. */
+		INVALID_USE,       /*!< The function was called incorrectly. */
+		DRIVER_ERROR,      /*!< A system driver error occured. */
+		SYSTEM_ERROR,      /*!< A system error occured. */
+		THREAD_ERROR       /*!< A thread error occured. */
+	};
+
+	//! The constructor.
+	RtError(const std::string& message, Type type = RtError::UNSPECIFIED) throw() : message_(message), type_(type) {}
+
+	//! The destructor.
+	virtual ~RtError(void) throw() {}
+
+	//! Prints thrown error message to stderr.
+	virtual void printMessage(void) const throw() { std::cerr << '\n'
+															  << message_ << "\n\n"; }
+
+	//! Returns the thrown error message type.
+	virtual const Type& getType(void) const throw() { return type_; }
+
+	//! Returns the thrown error message string.
+	virtual const std::string& getMessage(void) const throw() { return message_; }
+
+	//! Returns the thrown error message as a c-style string.
+	virtual const char* what(void) const throw() { return message_.c_str(); }
+
+protected:
+	std::string message_;
+	Type type_;
+};
+
+#endif
\ No newline at end of file
diff --git a/engine/inc/bullet/ThirdPartyLibs/midi/RtMidi.h b/engine/inc/bullet/ThirdPartyLibs/midi/RtMidi.h
new file mode 100644
index 00000000..f780191e
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/midi/RtMidi.h
@@ -0,0 +1,677 @@
+/**********************************************************************/
+/*! \class RtMidi
+    \brief An abstract base class for realtime MIDI input/output.
+
+    This class implements some common functionality for the realtime
+    MIDI input/output subclasses RtMidiIn and RtMidiOut.
+
+    RtMidi WWW site: http://music.mcgill.ca/~gary/rtmidi/
+
+    RtMidi: realtime MIDI i/o C++ classes
+    Copyright (c) 2003-2012 Gary P. Scavone
+
+    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.
+
+    Any person wishing to distribute modifications to the Software is
+    asked to send the modifications to the original developer so that
+    they can be incorporated into the canonical version.  This is,
+    however, not a binding provision of this license.
+
+    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.
+*/
+/**********************************************************************/
+
+/*!
+  \file RtMidi.h
+ */
+
+// RtMidi: Version 2.0.1
+
+#ifndef RTMIDI_H
+#define RTMIDI_H
+
+#include "RtError.h"
+#include <string>
+#include <vector>
+
+class RtMidi
+{
+public:
+	//! MIDI API specifier arguments.
+	enum Api
+	{
+		UNSPECIFIED, /*!< Search for a working compiled API. */
+		MACOSX_CORE, /*!< Macintosh OS-X Core Midi API. */
+		LINUX_ALSA,  /*!< The Advanced Linux Sound Architecture API. */
+		UNIX_JACK,   /*!< The Jack Low-Latency MIDI Server API. */
+		WINDOWS_MM,  /*!< The Microsoft Multimedia MIDI API. */
+		WINDOWS_KS,  /*!< The Microsoft Kernel Streaming MIDI API. */
+		RTMIDI_DUMMY /*!< A compilable but non-functional API. */
+	};
+
+	//! A static function to determine the available compiled MIDI APIs.
+	/*!
+    The values returned in the std::vector can be compared against
+    the enumerated list values.  Note that there can be more than one
+    API compiled for certain operating systems.
+  */
+	static void getCompiledApi(std::vector<RtMidi::Api> &apis);
+
+	//! Pure virtual openPort() function.
+	virtual void openPort(unsigned int portNumber = 0, const std::string portName = std::string("RtMidi")) = 0;
+
+	//! Pure virtual openVirtualPort() function.
+	virtual void openVirtualPort(const std::string portName = std::string("RtMidi")) = 0;
+
+	//! Pure virtual getPortCount() function.
+	virtual unsigned int getPortCount() = 0;
+
+	//! Pure virtual getPortName() function.
+	virtual std::string getPortName(unsigned int portNumber = 0) = 0;
+
+	//! Pure virtual closePort() function.
+	virtual void closePort(void) = 0;
+
+	//! A basic error reporting function for RtMidi classes.
+	static void error(RtError::Type type, std::string errorString);
+
+protected:
+	RtMidi(){};
+	virtual ~RtMidi(){};
+};
+
+/**********************************************************************/
+/*! \class RtMidiIn
+    \brief A realtime MIDI input class.
+
+    This class provides a common, platform-independent API for
+    realtime MIDI input.  It allows access to a single MIDI input
+    port.  Incoming MIDI messages are either saved to a queue for
+    retrieval using the getMessage() function or immediately passed to
+    a user-specified callback function.  Create multiple instances of
+    this class to connect to more than one MIDI device at the same
+    time.  With the OS-X and Linux ALSA MIDI APIs, it is also possible
+    to open a virtual input port to which other MIDI software clients
+    can connect.
+
+    by Gary P. Scavone, 2003-2012.
+*/
+/**********************************************************************/
+
+// **************************************************************** //
+//
+// RtMidiIn and RtMidiOut class declarations.
+//
+// RtMidiIn / RtMidiOut are "controllers" used to select an available
+// MIDI input or output interface.  They present common APIs for the
+// user to call but all functionality is implemented by the classes
+// MidiInApi, MidiOutApi and their subclasses.  RtMidiIn and RtMidiOut
+// each create an instance of a MidiInApi or MidiOutApi subclass based
+// on the user's API choice.  If no choice is made, they attempt to
+// make a "logical" API selection.
+//
+// **************************************************************** //
+
+class MidiInApi;
+class MidiOutApi;
+
+class RtMidiIn : public RtMidi
+{
+public:
+	//! User callback function type definition.
+	typedef void (*RtMidiCallback)(double timeStamp, std::vector<unsigned char> *message, void *userData);
+
+	//! Default constructor that allows an optional api, client name and queue size.
+	/*!
+    An assert will be fired if a MIDI system initialization
+    error occurs.  The queue size defines the maximum number of
+    messages that can be held in the MIDI queue (when not using a
+    callback function).  If the queue size limit is reached,
+    incoming messages will be ignored.
+
+    If no API argument is specified and multiple API support has been
+    compiled, the default order of use is JACK, ALSA (Linux) and CORE,
+    Jack (OS-X).
+  */
+	RtMidiIn(RtMidi::Api api = UNSPECIFIED,
+			 const std::string clientName = std::string("RtMidi Input Client"),
+			 unsigned int queueSizeLimit = 100);
+
+	//! If a MIDI connection is still open, it will be closed by the destructor.
+	~RtMidiIn(void);
+
+	//! Returns the MIDI API specifier for the current instance of RtMidiIn.
+	RtMidi::Api getCurrentApi(void);
+
+	//! Open a MIDI input connection.
+	/*!
+    An optional port number greater than 0 can be specified.
+    Otherwise, the default or first port found is opened.
+  */
+	void openPort(unsigned int portNumber = 0, const std::string portName = std::string("RtMidi Input"));
+
+	//! Create a virtual input port, with optional name, to allow software connections (OS X and ALSA only).
+	/*!
+    This function creates a virtual MIDI input port to which other
+    software applications can connect.  This type of functionality
+    is currently only supported by the Macintosh OS-X and Linux ALSA
+    APIs (the function does nothing for the other APIs).
+  */
+	void openVirtualPort(const std::string portName = std::string("RtMidi Input"));
+
+	//! Set a callback function to be invoked for incoming MIDI messages.
+	/*!
+    The callback function will be called whenever an incoming MIDI
+    message is received.  While not absolutely necessary, it is best
+    to set the callback function before opening a MIDI port to avoid
+    leaving some messages in the queue.
+  */
+	void setCallback(RtMidiCallback callback, void *userData = 0);
+
+	//! Cancel use of the current callback function (if one exists).
+	/*!
+    Subsequent incoming MIDI messages will be written to the queue
+    and can be retrieved with the \e getMessage function.
+  */
+	void cancelCallback();
+
+	//! Close an open MIDI connection (if one exists).
+	void closePort(void);
+
+	//! Return the number of available MIDI input ports.
+	unsigned int getPortCount();
+
+	//! Return a string identifier for the specified MIDI input port number.
+	/*!
+    An empty string is returned if an invalid port specifier is provided.
+  */
+	std::string getPortName(unsigned int portNumber = 0);
+
+	//! Specify whether certain MIDI message types should be queued or ignored during input.
+	/*!
+    o      By default, MIDI timing and active sensing messages are ignored
+    during message input because of their relative high data rates.
+    MIDI sysex messages are ignored by default as well.  Variable
+    values of "true" imply that the respective message type will be
+    ignored.
+  */
+	void ignoreTypes(bool midiSysex = true, bool midiTime = true, bool midiSense = true);
+
+	//! Fill the user-provided vector with the data bytes for the next available MIDI message in the input queue and return the event delta-time in seconds.
+	/*!
+    This function returns immediately whether a new message is
+    available or not.  A valid message is indicated by a non-zero
+    vector size.  An assert is fired if an error occurs during
+    message retrieval or an input connection was not previously
+    established.
+  */
+	double getMessage(std::vector<unsigned char> *message);
+
+protected:
+	void openMidiApi(RtMidi::Api api, const std::string clientName, unsigned int queueSizeLimit);
+	MidiInApi *rtapi_;
+};
+
+/**********************************************************************/
+/*! \class RtMidiOut
+    \brief A realtime MIDI output class.
+
+    This class provides a common, platform-independent API for MIDI
+    output.  It allows one to probe available MIDI output ports, to
+    connect to one such port, and to send MIDI bytes immediately over
+    the connection.  Create multiple instances of this class to
+    connect to more than one MIDI device at the same time.  With the
+    OS-X and Linux ALSA MIDI APIs, it is also possible to open a
+    virtual port to which other MIDI software clients can connect.
+
+    by Gary P. Scavone, 2003-2012.
+*/
+/**********************************************************************/
+
+class RtMidiOut : public RtMidi
+{
+public:
+	//! Default constructor that allows an optional client name.
+	/*!
+    An exception will be thrown if a MIDI system initialization error occurs.
+
+    If no API argument is specified and multiple API support has been
+    compiled, the default order of use is JACK, ALSA (Linux) and CORE,
+    Jack (OS-X).
+  */
+	RtMidiOut(RtMidi::Api api = UNSPECIFIED,
+			  const std::string clientName = std::string("RtMidi Output Client"));
+
+	//! The destructor closes any open MIDI connections.
+	~RtMidiOut(void);
+
+	//! Returns the MIDI API specifier for the current instance of RtMidiOut.
+	RtMidi::Api getCurrentApi(void);
+
+	//! Open a MIDI output connection.
+	/*!
+      An optional port number greater than 0 can be specified.
+      Otherwise, the default or first port found is opened.  An
+      exception is thrown if an error occurs while attempting to make
+      the port connection.
+  */
+	void openPort(unsigned int portNumber = 0, const std::string portName = std::string("RtMidi Output"));
+
+	//! Close an open MIDI connection (if one exists).
+	void closePort(void);
+
+	//! Create a virtual output port, with optional name, to allow software connections (OS X and ALSA only).
+	/*!
+      This function creates a virtual MIDI output port to which other
+      software applications can connect.  This type of functionality
+      is currently only supported by the Macintosh OS-X and Linux ALSA
+      APIs (the function does nothing with the other APIs).  An
+      exception is thrown if an error occurs while attempting to create
+      the virtual port.
+  */
+	void openVirtualPort(const std::string portName = std::string("RtMidi Output"));
+
+	//! Return the number of available MIDI output ports.
+	unsigned int getPortCount(void);
+
+	//! Return a string identifier for the specified MIDI port type and number.
+	/*!
+      An empty string is returned if an invalid port specifier is provided.
+  */
+	std::string getPortName(unsigned int portNumber = 0);
+
+	//! Immediately send a single message out an open MIDI output port.
+	/*!
+      An exception is thrown if an error occurs during output or an
+      output connection was not previously established.
+  */
+	void sendMessage(std::vector<unsigned char> *message);
+
+protected:
+	void openMidiApi(RtMidi::Api api, const std::string clientName);
+	MidiOutApi *rtapi_;
+};
+
+// **************************************************************** //
+//
+// MidiInApi / MidiOutApi class declarations.
+//
+// Subclasses of MidiInApi and MidiOutApi contain all API- and
+// OS-specific code necessary to fully implement the RtMidi API.
+//
+// Note that MidiInApi and MidiOutApi are abstract base classes and
+// cannot be explicitly instantiated.  RtMidiIn and RtMidiOut will
+// create instances of a MidiInApi or MidiOutApi subclass.
+//
+// **************************************************************** //
+
+class MidiInApi
+{
+public:
+	MidiInApi(unsigned int queueSizeLimit);
+	virtual ~MidiInApi(void);
+	virtual RtMidi::Api getCurrentApi(void) = 0;
+	virtual void openPort(unsigned int portNumber, const std::string portName) = 0;
+	virtual void openVirtualPort(const std::string portName) = 0;
+	virtual void closePort(void) = 0;
+	void setCallback(RtMidiIn::RtMidiCallback callback, void *userData);
+	void cancelCallback(void);
+	virtual unsigned int getPortCount(void) = 0;
+	virtual std::string getPortName(unsigned int portNumber) = 0;
+	virtual void ignoreTypes(bool midiSysex, bool midiTime, bool midiSense);
+	double getMessage(std::vector<unsigned char> *message);
+
+	// A MIDI structure used internally by the class to store incoming
+	// messages.  Each message represents one and only one MIDI message.
+	struct MidiMessage
+	{
+		std::vector<unsigned char> bytes;
+		double timeStamp;
+
+		// Default constructor.
+		MidiMessage()
+			: bytes(0), timeStamp(0.0) {}
+	};
+
+	struct MidiQueue
+	{
+		unsigned int front;
+		unsigned int back;
+		unsigned int size;
+		unsigned int ringSize;
+		MidiMessage *ring;
+
+		// Default constructor.
+		MidiQueue()
+			: front(0), back(0), size(0), ringSize(0) {}
+	};
+
+	// The RtMidiInData structure is used to pass private class data to
+	// the MIDI input handling function or thread.
+	struct RtMidiInData
+	{
+		MidiQueue queue;
+		MidiMessage message;
+		unsigned char ignoreFlags;
+		bool doInput;
+		bool firstMessage;
+		void *apiData;
+		bool usingCallback;
+		void *userCallback;
+		void *userData;
+		bool continueSysex;
+
+		// Default constructor.
+		RtMidiInData()
+			: ignoreFlags(7), doInput(false), firstMessage(true), apiData(0), usingCallback(false), userCallback(0), userData(0), continueSysex(false) {}
+	};
+
+protected:
+	virtual void initialize(const std::string &clientName) = 0;
+	RtMidiInData inputData_;
+
+	void *apiData_;
+	bool connected_;
+	std::string errorString_;
+};
+
+class MidiOutApi
+{
+public:
+	MidiOutApi(void);
+	virtual ~MidiOutApi(void);
+	virtual RtMidi::Api getCurrentApi(void) = 0;
+	virtual void openPort(unsigned int portNumber, const std::string portName) = 0;
+	virtual void openVirtualPort(const std::string portName) = 0;
+	virtual void closePort(void) = 0;
+	virtual unsigned int getPortCount(void) = 0;
+	virtual std::string getPortName(unsigned int portNumber) = 0;
+	virtual void sendMessage(std::vector<unsigned char> *message) = 0;
+
+protected:
+	virtual void initialize(const std::string &clientName) = 0;
+
+	void *apiData_;
+	bool connected_;
+	std::string errorString_;
+};
+
+// **************************************************************** //
+//
+// Inline RtMidiIn and RtMidiOut definitions.
+//
+// **************************************************************** //
+
+inline RtMidi::Api RtMidiIn ::getCurrentApi(void) { return rtapi_->getCurrentApi(); }
+inline void RtMidiIn ::openPort(unsigned int portNumber, const std::string portName) { return rtapi_->openPort(portNumber, portName); }
+inline void RtMidiIn ::openVirtualPort(const std::string portName) { return rtapi_->openVirtualPort(portName); }
+inline void RtMidiIn ::closePort(void) { return rtapi_->closePort(); }
+inline void RtMidiIn ::setCallback(RtMidiCallback callback, void *userData) { return rtapi_->setCallback(callback, userData); }
+inline void RtMidiIn ::cancelCallback(void) { return rtapi_->cancelCallback(); }
+inline unsigned int RtMidiIn ::getPortCount(void) { return rtapi_->getPortCount(); }
+inline std::string RtMidiIn ::getPortName(unsigned int portNumber) { return rtapi_->getPortName(portNumber); }
+inline void RtMidiIn ::ignoreTypes(bool midiSysex, bool midiTime, bool midiSense) { return rtapi_->ignoreTypes(midiSysex, midiTime, midiSense); }
+inline double RtMidiIn ::getMessage(std::vector<unsigned char> *message) { return rtapi_->getMessage(message); }
+
+inline RtMidi::Api RtMidiOut ::getCurrentApi(void) { return rtapi_->getCurrentApi(); }
+inline void RtMidiOut ::openPort(unsigned int portNumber, const std::string portName) { return rtapi_->openPort(portNumber, portName); }
+inline void RtMidiOut ::openVirtualPort(const std::string portName) { return rtapi_->openVirtualPort(portName); }
+inline void RtMidiOut ::closePort(void) { return rtapi_->closePort(); }
+inline unsigned int RtMidiOut ::getPortCount(void) { return rtapi_->getPortCount(); }
+inline std::string RtMidiOut ::getPortName(unsigned int portNumber) { return rtapi_->getPortName(portNumber); }
+inline void RtMidiOut ::sendMessage(std::vector<unsigned char> *message) { return rtapi_->sendMessage(message); }
+
+// **************************************************************** //
+//
+// MidiInApi and MidiOutApi subclass prototypes.
+//
+// **************************************************************** //
+
+#if !defined(__LINUX_ALSA__) && !defined(__UNIX_JACK__) && !defined(__MACOSX_CORE__) && !defined(__WINDOWS_MM__) && !defined(__WINDOWS_KS__)
+#define __RTMIDI_DUMMY__
+#endif
+
+#if defined(__MACOSX_CORE__)
+
+class MidiInCore : public MidiInApi
+{
+public:
+	MidiInCore(const std::string clientName, unsigned int queueSizeLimit);
+	~MidiInCore(void);
+	RtMidi::Api getCurrentApi(void) { return RtMidi::MACOSX_CORE; };
+	void openPort(unsigned int portNumber, const std::string portName);
+	void openVirtualPort(const std::string portName);
+	void closePort(void);
+	unsigned int getPortCount(void);
+	std::string getPortName(unsigned int portNumber);
+
+protected:
+	void initialize(const std::string &clientName);
+};
+
+class MidiOutCore : public MidiOutApi
+{
+public:
+	MidiOutCore(const std::string clientName);
+	~MidiOutCore(void);
+	RtMidi::Api getCurrentApi(void) { return RtMidi::MACOSX_CORE; };
+	void openPort(unsigned int portNumber, const std::string portName);
+	void openVirtualPort(const std::string portName);
+	void closePort(void);
+	unsigned int getPortCount(void);
+	std::string getPortName(unsigned int portNumber);
+	void sendMessage(std::vector<unsigned char> *message);
+
+protected:
+	void initialize(const std::string &clientName);
+};
+
+#endif
+
+#if defined(__UNIX_JACK__)
+
+class MidiInJack : public MidiInApi
+{
+public:
+	MidiInJack(const std::string clientName, unsigned int queueSizeLimit);
+	~MidiInJack(void);
+	RtMidi::Api getCurrentApi(void) { return RtMidi::UNIX_JACK; };
+	void openPort(unsigned int portNumber, const std::string portName);
+	void openVirtualPort(const std::string portName);
+	void closePort(void);
+	unsigned int getPortCount(void);
+	std::string getPortName(unsigned int portNumber);
+
+protected:
+	void initialize(const std::string &clientName);
+};
+
+class MidiOutJack : public MidiOutApi
+{
+public:
+	MidiOutJack(const std::string clientName);
+	~MidiOutJack(void);
+	RtMidi::Api getCurrentApi(void) { return RtMidi::UNIX_JACK; };
+	void openPort(unsigned int portNumber, const std::string portName);
+	void openVirtualPort(const std::string portName);
+	void closePort(void);
+	unsigned int getPortCount(void);
+	std::string getPortName(unsigned int portNumber);
+	void sendMessage(std::vector<unsigned char> *message);
+
+protected:
+	void initialize(const std::string &clientName);
+};
+
+#endif
+
+#if defined(__LINUX_ALSA__)
+
+class MidiInAlsa : public MidiInApi
+{
+public:
+	MidiInAlsa(const std::string clientName, unsigned int queueSizeLimit);
+	~MidiInAlsa(void);
+	RtMidi::Api getCurrentApi(void) { return RtMidi::LINUX_ALSA; };
+	void openPort(unsigned int portNumber, const std::string portName);
+	void openVirtualPort(const std::string portName);
+	void closePort(void);
+	unsigned int getPortCount(void);
+	std::string getPortName(unsigned int portNumber);
+
+protected:
+	void initialize(const std::string &clientName);
+};
+
+class MidiOutAlsa : public MidiOutApi
+{
+public:
+	MidiOutAlsa(const std::string clientName);
+	~MidiOutAlsa(void);
+	RtMidi::Api getCurrentApi(void) { return RtMidi::LINUX_ALSA; };
+	void openPort(unsigned int portNumber, const std::string portName);
+	void openVirtualPort(const std::string portName);
+	void closePort(void);
+	unsigned int getPortCount(void);
+	std::string getPortName(unsigned int portNumber);
+	void sendMessage(std::vector<unsigned char> *message);
+
+protected:
+	void initialize(const std::string &clientName);
+};
+
+#endif
+
+#if defined(__WINDOWS_MM__)
+
+class MidiInWinMM : public MidiInApi
+{
+public:
+	MidiInWinMM(const std::string clientName, unsigned int queueSizeLimit);
+	~MidiInWinMM(void);
+	RtMidi::Api getCurrentApi(void) { return RtMidi::WINDOWS_MM; };
+	void openPort(unsigned int portNumber, const std::string portName);
+	void openVirtualPort(const std::string portName);
+	void closePort(void);
+	unsigned int getPortCount(void);
+	std::string getPortName(unsigned int portNumber);
+
+protected:
+	void initialize(const std::string &clientName);
+};
+
+class MidiOutWinMM : public MidiOutApi
+{
+public:
+	MidiOutWinMM(const std::string clientName);
+	~MidiOutWinMM(void);
+	RtMidi::Api getCurrentApi(void) { return RtMidi::WINDOWS_MM; };
+	void openPort(unsigned int portNumber, const std::string portName);
+	void openVirtualPort(const std::string portName);
+	void closePort(void);
+	unsigned int getPortCount(void);
+	std::string getPortName(unsigned int portNumber);
+	void sendMessage(std::vector<unsigned char> *message);
+
+protected:
+	void initialize(const std::string &clientName);
+};
+
+#endif
+
+#if defined(__WINDOWS_KS__)
+
+class MidiInWinKS : public MidiInApi
+{
+public:
+	MidiInWinKS(const std::string clientName, unsigned int queueSizeLimit);
+	~MidiInWinKS(void);
+	RtMidi::Api getCurrentApi(void) { return RtMidi::WINDOWS_KS; };
+	void openPort(unsigned int portNumber, const std::string portName);
+	void openVirtualPort(const std::string portName);
+	void closePort(void);
+	unsigned int getPortCount(void);
+	std::string getPortName(unsigned int portNumber);
+
+protected:
+	void initialize(const std::string &clientName);
+};
+
+class MidiOutWinKS : public MidiOutApi
+{
+public:
+	MidiOutWinKS(const std::string clientName);
+	~MidiOutWinKS(void);
+	RtMidi::Api getCurrentApi(void) { return RtMidi::WINDOWS_KS; };
+	void openPort(unsigned int portNumber, const std::string portName);
+	void openVirtualPort(const std::string portName);
+	void closePort(void);
+	unsigned int getPortCount(void);
+	std::string getPortName(unsigned int portNumber);
+	void sendMessage(std::vector<unsigned char> *message);
+
+protected:
+	void initialize(const std::string &clientName);
+};
+
+#endif
+
+#if defined(__RTMIDI_DUMMY__)
+
+class MidiInDummy : public MidiInApi
+{
+public:
+	MidiInDummy(const std::string clientName, unsigned int queueSizeLimit) : MidiInApi(queueSizeLimit)
+	{
+		errorString_ = "MidiInDummy: This class provides no functionality.";
+		RtMidi::error(RtError::WARNING, errorString_);
+	};
+	RtMidi::Api getCurrentApi(void) { return RtMidi::RTMIDI_DUMMY; };
+	void openPort(unsigned int portNumber, const std::string portName){};
+	void openVirtualPort(const std::string portName){};
+	void closePort(void){};
+	unsigned int getPortCount(void) { return 0; };
+	std::string getPortName(unsigned int portNumber) { return ""; };
+
+protected:
+	void initialize(const std::string &clientName){};
+};
+
+class MidiOutDummy : public MidiOutApi
+{
+public:
+	MidiOutDummy(const std::string clientName)
+	{
+		errorString_ = "MidiOutDummy: This class provides no functionality.";
+		RtMidi::error(RtError::WARNING, errorString_);
+	};
+	RtMidi::Api getCurrentApi(void) { return RtMidi::RTMIDI_DUMMY; };
+	void openPort(unsigned int portNumber, const std::string portName){};
+	void openVirtualPort(const std::string portName){};
+	void closePort(void){};
+	unsigned int getPortCount(void) { return 0; };
+	std::string getPortName(unsigned int portNumber) { return ""; };
+	void sendMessage(std::vector<unsigned char> *message){};
+
+protected:
+	void initialize(const std::string &clientName){};
+};
+
+#endif
+
+#endif
\ No newline at end of file
diff --git a/engine/inc/bullet/ThirdPartyLibs/minizip/crypt.h b/engine/inc/bullet/ThirdPartyLibs/minizip/crypt.h
new file mode 100644
index 00000000..55eccdaf
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/minizip/crypt.h
@@ -0,0 +1,133 @@
+/* crypt.h -- base code for crypt/uncrypt ZIPfile
+
+
+   Version 1.01e, February 12th, 2005
+
+   Copyright (C) 1998-2005 Gilles Vollant
+
+   This code is a modified version of crypting code in Infozip distribution
+
+   The encryption/decryption parts of this source code (as opposed to the
+   non-echoing password parts) were originally written in Europe.  The
+   whole source package can be freely distributed, including from the USA.
+   (Prior to January 2000, re-export from the US was a violation of US law.)
+
+   This encryption code is a direct transcription of the algorithm from
+   Roger Schlafly, described by Phil Katz in the file appnote.txt.  This
+   file (appnote.txt) is distributed with the PKZIP program (even in the
+   version without encryption capabilities).
+
+   If you don't need crypting in your application, just define symbols
+   NOCRYPT and NOUNCRYPT.
+
+   This code support the "Traditional PKWARE Encryption".
+
+   The new AES encryption added on Zip format by Winzip (see the page
+   http://www.winzip.com/aes_info.htm ) and PKWare PKZip 5.x Strong
+   Encryption is not supported.
+*/
+#define NOCRYPT
+#define NOUNCRYPT
+
+#define CRC32(c, b) ((*(pcrc_32_tab + (((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))
+
+/***********************************************************************
+ * Return the next byte in the pseudo-random sequence
+ */
+static int decrypt_byte(unsigned long* pkeys, const unsigned long* pcrc_32_tab)
+{
+	unsigned temp; /* POTENTIAL BUG:  temp*(temp^1) may overflow in an
+                     * unpredictable manner on 16-bit systems; not a problem
+                     * with any known compiler so far, though */
+
+	temp = ((unsigned)(*(pkeys + 2)) & 0xffff) | 2;
+	return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);
+}
+
+/***********************************************************************
+ * Update the encryption keys with the next byte of plain text
+ */
+static int update_keys(unsigned long* pkeys, const unsigned long* pcrc_32_tab, int c)
+{
+	(*(pkeys + 0)) = CRC32((*(pkeys + 0)), c);
+	(*(pkeys + 1)) += (*(pkeys + 0)) & 0xff;
+	(*(pkeys + 1)) = (*(pkeys + 1)) * 134775813L + 1;
+	{
+		register int keyshift = (int)((*(pkeys + 1)) >> 24);
+		(*(pkeys + 2)) = CRC32((*(pkeys + 2)), keyshift);
+	}
+	return c;
+}
+
+/***********************************************************************
+ * Initialize the encryption keys and the random header according to
+ * the given password.
+ */
+static void init_keys(const char* passwd, unsigned long* pkeys, const unsigned long* pcrc_32_tab)
+{
+	*(pkeys + 0) = 305419896L;
+	*(pkeys + 1) = 591751049L;
+	*(pkeys + 2) = 878082192L;
+	while (*passwd != '\0')
+	{
+		update_keys(pkeys, pcrc_32_tab, (int)*passwd);
+		passwd++;
+	}
+}
+
+#define zdecode(pkeys, pcrc_32_tab, c) \
+	(update_keys(pkeys, pcrc_32_tab, c ^= decrypt_byte(pkeys, pcrc_32_tab)))
+
+#define zencode(pkeys, pcrc_32_tab, c, t) \
+	(t = decrypt_byte(pkeys, pcrc_32_tab), update_keys(pkeys, pcrc_32_tab, c), t ^ (c))
+
+#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED
+
+#define RAND_HEAD_LEN 12
+/* "last resort" source for second part of crypt seed pattern */
+#ifndef ZCR_SEED2
+#define ZCR_SEED2 3141592654UL /* use PI as default pattern */
+#endif
+
+static int crypthead(const char* passwd, /* password string */
+					 unsigned char* buf, /* where to write header */
+					 int bufSize,
+					 unsigned long* pkeys,
+					 const unsigned long* pcrc_32_tab,
+					 unsigned long crcForCrypting)
+{
+	int n;                                   /* index in random header */
+	int t;                                   /* temporary */
+	int c;                                   /* random byte */
+	unsigned char header[RAND_HEAD_LEN - 2]; /* random header */
+	static unsigned calls = 0;               /* ensure different random header each time */
+
+	if (bufSize < RAND_HEAD_LEN)
+		return 0;
+
+	/* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the
+     * output of rand() to get less predictability, since rand() is
+     * often poorly implemented.
+     */
+	if (++calls == 1)
+	{
+		srand((unsigned)(time(NULL) ^ ZCR_SEED2));
+	}
+	init_keys(passwd, pkeys, pcrc_32_tab);
+	for (n = 0; n < RAND_HEAD_LEN - 2; n++)
+	{
+		c = (rand() >> 7) & 0xff;
+		header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t);
+	}
+	/* Encrypt random header (last two bytes is high word of crc) */
+	init_keys(passwd, pkeys, pcrc_32_tab);
+	for (n = 0; n < RAND_HEAD_LEN - 2; n++)
+	{
+		buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t);
+	}
+	buf[n++] = (unsigned char)zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t);
+	buf[n++] = (unsigned char)zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t);
+	return n;
+}
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/minizip/ioapi.h b/engine/inc/bullet/ThirdPartyLibs/minizip/ioapi.h
new file mode 100644
index 00000000..6c44d400
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/minizip/ioapi.h
@@ -0,0 +1,193 @@
+/* ioapi.h -- IO base function header for compress/uncompress .zip
+   part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Modifications for Zip64 support
+         Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
+
+         For more info read MiniZip_info.txt
+
+         Changes
+
+    Oct-2009 - Defined ZPOS64_T to fpos_t on windows and u_int64_t on linux. (might need to find a better why for this)
+    Oct-2009 - Change to fseeko64, ftello64 and fopen64 so large files would work on linux.
+               More if/def section may be needed to support other platforms
+    Oct-2009 - Defined fxxxx64 calls to normal fopen/ftell/fseek so they would compile on windows.
+                          (but you should use iowin32.c for windows instead)
+
+*/
+
+#ifndef _ZLIBIOAPI64_H
+#define _ZLIBIOAPI64_H
+
+#if (!defined(_WIN32)) && (!defined(WIN32))
+
+// Linux needs this to support file operation on files larger then 4+GB
+// But might need better if/def to select just the platforms that needs them.
+
+#ifndef __USE_FILE_OFFSET64
+#define __USE_FILE_OFFSET64
+#endif
+#ifndef __USE_LARGEFILE64
+#define __USE_LARGEFILE64
+#endif
+#ifndef _LARGEFILE64_SOURCE
+#define _LARGEFILE64_SOURCE
+#endif
+#ifndef _FILE_OFFSET_BIT
+#define _FILE_OFFSET_BIT 64
+#endif
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "../zlib/zlib.h"
+
+#if defined(USE_FILE32API)
+#define fopen64 fopen
+#define ftello64 ftell
+#define fseeko64 fseek
+#else
+#ifdef _MSC_VER
+#define fopen64 fopen
+#if (_MSC_VER >= 1400) && (!(defined(NO_MSCVER_FILE64_FUNC)))
+#define ftello64 _ftelli64
+#define fseeko64 _fseeki64
+#else  // old MSC
+#define ftello64 ftell
+#define fseeko64 fseek
+#endif
+#endif
+#endif
+
+/*
+#ifndef ZPOS64_T
+  #ifdef _WIN32
+                #define ZPOS64_T fpos_t
+  #else
+    #include <stdint.h>
+    #define ZPOS64_T uint64_t
+  #endif
+#endif
+*/
+
+#ifdef HAVE_MINIZIP64_CONF_H
+#include "mz64conf.h"
+#endif
+
+/* a type choosen by DEFINE */
+#ifdef HAVE_64BIT_INT_CUSTOM
+typedef 64BIT_INT_CUSTOM_TYPE ZPOS64_T;
+#else
+#ifdef HAS_STDINT_H
+#include "stdint.h"
+typedef uint64_t ZPOS64_T;
+#else
+
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+typedef unsigned __int64 ZPOS64_T;
+#else
+typedef unsigned long long int ZPOS64_T;
+#endif
+#endif
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#define ZLIB_FILEFUNC_SEEK_CUR (1)
+#define ZLIB_FILEFUNC_SEEK_END (2)
+#define ZLIB_FILEFUNC_SEEK_SET (0)
+
+#define ZLIB_FILEFUNC_MODE_READ (1)
+#define ZLIB_FILEFUNC_MODE_WRITE (2)
+#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3)
+
+#define ZLIB_FILEFUNC_MODE_EXISTING (4)
+#define ZLIB_FILEFUNC_MODE_CREATE (8)
+
+#ifndef ZCALLBACK
+#if (defined(WIN32) || defined(_WIN32) || defined(WINDOWS) || defined(_WINDOWS)) && defined(CALLBACK) && defined(USEWINDOWS_CALLBACK)
+#define ZCALLBACK CALLBACK
+#else
+#define ZCALLBACK
+#endif
+#endif
+
+	typedef voidpf(ZCALLBACK *open_file_func) OF((voidpf opaque, const char *filename, int mode));
+	typedef uLong(ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void *buf, uLong size));
+	typedef uLong(ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void *buf, uLong size));
+	typedef int(ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream));
+	typedef int(ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream));
+
+	typedef long(ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream));
+	typedef long(ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin));
+
+	/* here is the "old" 32 bits structure structure */
+	typedef struct zlib_filefunc_def_s
+	{
+		open_file_func zopen_file;
+		read_file_func zread_file;
+		write_file_func zwrite_file;
+		tell_file_func ztell_file;
+		seek_file_func zseek_file;
+		close_file_func zclose_file;
+		testerror_file_func zerror_file;
+		voidpf opaque;
+	} zlib_filefunc_def;
+
+	typedef ZPOS64_T(ZCALLBACK *tell64_file_func) OF((voidpf opaque, voidpf stream));
+	typedef long(ZCALLBACK *seek64_file_func) OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin));
+	typedef voidpf(ZCALLBACK *open64_file_func) OF((voidpf opaque, const void *filename, int mode));
+
+	typedef struct zlib_filefunc64_def_s
+	{
+		open64_file_func zopen64_file;
+		read_file_func zread_file;
+		write_file_func zwrite_file;
+		tell64_file_func ztell64_file;
+		seek64_file_func zseek64_file;
+		close_file_func zclose_file;
+		testerror_file_func zerror_file;
+		voidpf opaque;
+	} zlib_filefunc64_def;
+
+	void fill_fopen64_filefunc OF((zlib_filefunc64_def * pzlib_filefunc_def));
+	void fill_fopen_filefunc OF((zlib_filefunc_def * pzlib_filefunc_def));
+
+	/* now internal definition, only for zip.c and unzip.h */
+	typedef struct zlib_filefunc64_32_def_s
+	{
+		zlib_filefunc64_def zfile_func64;
+		open_file_func zopen32_file;
+		tell_file_func ztell32_file;
+		seek_file_func zseek32_file;
+	} zlib_filefunc64_32_def;
+
+#define ZREAD64(filefunc, filestream, buf, size) ((*((filefunc).zfile_func64.zread_file))((filefunc).zfile_func64.opaque, filestream, buf, size))
+#define ZWRITE64(filefunc, filestream, buf, size) ((*((filefunc).zfile_func64.zwrite_file))((filefunc).zfile_func64.opaque, filestream, buf, size))
+//#define ZTELL64(filefunc,filestream)            ((*((filefunc).ztell64_file)) ((filefunc).opaque,filestream))
+//#define ZSEEK64(filefunc,filestream,pos,mode)   ((*((filefunc).zseek64_file)) ((filefunc).opaque,filestream,pos,mode))
+#define ZCLOSE64(filefunc, filestream) ((*((filefunc).zfile_func64.zclose_file))((filefunc).zfile_func64.opaque, filestream))
+#define ZERROR64(filefunc, filestream) ((*((filefunc).zfile_func64.zerror_file))((filefunc).zfile_func64.opaque, filestream))
+
+	voidpf call_zopen64 OF((const zlib_filefunc64_32_def *pfilefunc, const void *filename, int mode));
+	long call_zseek64 OF((const zlib_filefunc64_32_def *pfilefunc, voidpf filestream, ZPOS64_T offset, int origin));
+	ZPOS64_T call_ztell64 OF((const zlib_filefunc64_32_def *pfilefunc, voidpf filestream));
+
+	void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def *p_filefunc64_32, const zlib_filefunc_def *p_filefunc32);
+
+#define ZOPEN64(filefunc, filename, mode) (call_zopen64((&(filefunc)), (filename), (mode)))
+#define ZTELL64(filefunc, filestream) (call_ztell64((&(filefunc)), (filestream)))
+#define ZSEEK64(filefunc, filestream, pos, mode) (call_zseek64((&(filefunc)), (filestream), (pos), (mode)))
+
+extern void* ZEXPORT mem_simple_create_file(zlib_filefunc_def* api, void* buffer, size_t buf_len);
+extern void ZEXPORT mem_simple_destroy_file(void* handle_ptr);
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/minizip/unzip.h b/engine/inc/bullet/ThirdPartyLibs/minizip/unzip.h
new file mode 100644
index 00000000..29cf2c04
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/minizip/unzip.h
@@ -0,0 +1,433 @@
+/* unzip.h -- IO for uncompress .zip files using zlib
+   Version 1.1, February 14h, 2010
+   part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Modifications of Unzip for Zip64
+         Copyright (C) 2007-2008 Even Rouault
+
+         Modifications for Zip64 support on both zip and unzip
+         Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
+
+         For more info read MiniZip_info.txt
+
+         ---------------------------------------------------------------------------------
+
+        Condition of use and distribution are the same than zlib :
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  ---------------------------------------------------------------------------------
+
+        Changes
+
+        See header of unzip64.c
+
+*/
+
+#ifndef _unz64_H
+#define _unz64_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#ifndef _ZLIB_H
+#include "../zlib/zlib.h"
+#endif
+
+#ifndef _ZLIBIOAPI_H
+#include "ioapi.h"
+#endif
+
+#ifdef HAVE_BZIP2
+#include "bzlib.h"
+#endif
+
+#define Z_BZIP2ED 12
+
+#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP)
+	/* like the STRICT of WIN32, we define a pointer that cannot be converted
+    from (void*) without cast */
+	typedef struct TagunzFile__
+	{
+		int unused;
+	} unzFile__;
+	typedef unzFile__ *unzFile;
+#else
+typedef voidp unzFile;
+#endif
+
+#define UNZ_OK (0)
+#define UNZ_END_OF_LIST_OF_FILE (-100)
+#define UNZ_ERRNO (Z_ERRNO)
+#define UNZ_EOF (0)
+#define UNZ_PARAMERROR (-102)
+#define UNZ_BADZIPFILE (-103)
+#define UNZ_INTERNALERROR (-104)
+#define UNZ_CRCERROR (-105)
+
+	/* tm_unz contain date/time info */
+	typedef struct tm_unz_s
+	{
+		uInt tm_sec;  /* seconds after the minute - [0,59] */
+		uInt tm_min;  /* minutes after the hour - [0,59] */
+		uInt tm_hour; /* hours since midnight - [0,23] */
+		uInt tm_mday; /* day of the month - [1,31] */
+		uInt tm_mon;  /* months since January - [0,11] */
+		uInt tm_year; /* years - [1980..2044] */
+	} tm_unz;
+
+	/* unz_global_info structure contain global data about the ZIPfile
+   These data comes from the end of central dir */
+	typedef struct unz_global_info64_s
+	{
+		ZPOS64_T number_entry; /* total number of entries in
+                                     the central dir on this disk */
+		uLong size_comment;    /* size of the global comment of the zipfile */
+	} unz_global_info64;
+
+	typedef struct unz_global_info_s
+	{
+		uLong number_entry; /* total number of entries in
+                                     the central dir on this disk */
+		uLong size_comment; /* size of the global comment of the zipfile */
+	} unz_global_info;
+
+	/* unz_file_info contain information about a file in the zipfile */
+	typedef struct unz_file_info64_s
+	{
+		uLong version;              /* version made by                 2 bytes */
+		uLong version_needed;       /* version needed to extract       2 bytes */
+		uLong flag;                 /* general purpose bit flag        2 bytes */
+		uLong compression_method;   /* compression method              2 bytes */
+		uLong dosDate;              /* last mod file date in Dos fmt   4 bytes */
+		uLong crc;                  /* crc-32                          4 bytes */
+		ZPOS64_T compressed_size;   /* compressed size                 8 bytes */
+		ZPOS64_T uncompressed_size; /* uncompressed size               8 bytes */
+		uLong size_filename;        /* filename length                 2 bytes */
+		uLong size_file_extra;      /* extra field length              2 bytes */
+		uLong size_file_comment;    /* file comment length             2 bytes */
+
+		uLong disk_num_start; /* disk number start               2 bytes */
+		uLong internal_fa;    /* internal file attributes        2 bytes */
+		uLong external_fa;    /* external file attributes        4 bytes */
+
+		tm_unz tmu_date;
+	} unz_file_info64;
+
+	typedef struct unz_file_info_s
+	{
+		uLong version;            /* version made by                 2 bytes */
+		uLong version_needed;     /* version needed to extract       2 bytes */
+		uLong flag;               /* general purpose bit flag        2 bytes */
+		uLong compression_method; /* compression method              2 bytes */
+		uLong dosDate;            /* last mod file date in Dos fmt   4 bytes */
+		uLong crc;                /* crc-32                          4 bytes */
+		uLong compressed_size;    /* compressed size                 4 bytes */
+		uLong uncompressed_size;  /* uncompressed size               4 bytes */
+		uLong size_filename;      /* filename length                 2 bytes */
+		uLong size_file_extra;    /* extra field length              2 bytes */
+		uLong size_file_comment;  /* file comment length             2 bytes */
+
+		uLong disk_num_start; /* disk number start               2 bytes */
+		uLong internal_fa;    /* internal file attributes        2 bytes */
+		uLong external_fa;    /* external file attributes        4 bytes */
+
+		tm_unz tmu_date;
+	} unz_file_info;
+
+	extern int ZEXPORT unzStringFileNameCompare OF((const char *fileName1,
+													const char *fileName2,
+													int iCaseSensitivity));
+	/*
+   Compare two filename (fileName1,fileName2).
+   If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
+   If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
+                                or strcasecmp)
+   If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
+    (like 1 on Unix, 2 on Windows)
+*/
+
+	extern unzFile ZEXPORT unzOpen OF((const char *path));
+	extern unzFile ZEXPORT unzOpen64 OF((const void *path));
+	/*
+  Open a Zip file. path contain the full pathname (by example,
+     on a Windows XP computer "c:\\zlib\\zlib113.zip" or on an Unix computer
+     "zlib/zlib113.zip".
+     If the zipfile cannot be opened (file don't exist or in not valid), the
+       return value is NULL.
+     Else, the return value is a unzFile Handle, usable with other function
+       of this unzip package.
+     the "64" function take a const void* pointer, because the path is just the
+       value passed to the open64_file_func callback.
+     Under Windows, if UNICODE is defined, using fill_fopen64_filefunc, the path
+       is a pointer to a wide unicode string (LPCTSTR is LPCWSTR), so const char*
+       does not describe the reality
+*/
+
+	extern unzFile ZEXPORT unzOpen2 OF((const char *path,
+										zlib_filefunc_def *pzlib_filefunc_def));
+	/*
+   Open a Zip file, like unzOpen, but provide a set of file low level API
+      for read/write the zip file (see ioapi.h)
+*/
+
+	extern unzFile ZEXPORT unzOpen2_64 OF((const void *path,
+										   zlib_filefunc64_def *pzlib_filefunc_def));
+	/*
+   Open a Zip file, like unz64Open, but provide a set of file low level API
+      for read/write the zip file (see ioapi.h)
+*/
+
+	extern int ZEXPORT unzClose OF((unzFile file));
+	/*
+  Close a ZipFile opened with unzipOpen.
+  If there is files inside the .Zip opened with unzOpenCurrentFile (see later),
+    these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
+  return UNZ_OK if there is no problem. */
+
+	extern int ZEXPORT unzGetGlobalInfo OF((unzFile file,
+											unz_global_info *pglobal_info));
+
+	extern int ZEXPORT unzGetGlobalInfo64 OF((unzFile file,
+											  unz_global_info64 *pglobal_info));
+	/*
+  Write info about the ZipFile in the *pglobal_info structure.
+  No preparation of the structure is needed
+  return UNZ_OK if there is no problem. */
+
+	extern int ZEXPORT unzGetGlobalComment OF((unzFile file,
+											   char *szComment,
+											   uLong uSizeBuf));
+	/*
+  Get the global comment string of the ZipFile, in the szComment buffer.
+  uSizeBuf is the size of the szComment buffer.
+  return the number of byte copied or an error code <0
+*/
+
+	/***************************************************************************/
+	/* Unzip package allow you browse the directory of the zipfile */
+
+	extern int ZEXPORT unzGoToFirstFile OF((unzFile file));
+	/*
+  Set the current file of the zipfile to the first file.
+  return UNZ_OK if there is no problem
+*/
+
+	extern int ZEXPORT unzGoToNextFile OF((unzFile file));
+	/*
+  Set the current file of the zipfile to the next file.
+  return UNZ_OK if there is no problem
+  return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
+*/
+
+	extern int ZEXPORT unzLocateFile OF((unzFile file,
+										 const char *szFileName,
+										 int iCaseSensitivity));
+	/*
+  Try locate the file szFileName in the zipfile.
+  For the iCaseSensitivity signification, see unzStringFileNameCompare
+
+  return value :
+  UNZ_OK if the file is found. It becomes the current file.
+  UNZ_END_OF_LIST_OF_FILE if the file is not found
+*/
+
+	/* ****************************************** */
+	/* Ryan supplied functions */
+	/* unz_file_info contain information about a file in the zipfile */
+	typedef struct unz_file_pos_s
+	{
+		uLong pos_in_zip_directory; /* offset in zip file directory */
+		uLong num_of_file;          /* # of file */
+	} unz_file_pos;
+
+	extern int ZEXPORT unzGetFilePos(
+		unzFile file,
+		unz_file_pos *file_pos);
+
+	extern int ZEXPORT unzGoToFilePos(
+		unzFile file,
+		unz_file_pos *file_pos);
+
+	typedef struct unz64_file_pos_s
+	{
+		ZPOS64_T pos_in_zip_directory; /* offset in zip file directory */
+		ZPOS64_T num_of_file;          /* # of file */
+	} unz64_file_pos;
+
+	extern int ZEXPORT unzGetFilePos64(
+		unzFile file,
+		unz64_file_pos *file_pos);
+
+	extern int ZEXPORT unzGoToFilePos64(
+		unzFile file,
+		const unz64_file_pos *file_pos);
+
+	/* ****************************************** */
+
+	extern int ZEXPORT unzGetCurrentFileInfo64 OF((unzFile file,
+												   unz_file_info64 *pfile_info,
+												   char *szFileName,
+												   uLong fileNameBufferSize,
+												   void *extraField,
+												   uLong extraFieldBufferSize,
+												   char *szComment,
+												   uLong commentBufferSize));
+
+	extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file,
+												 unz_file_info *pfile_info,
+												 char *szFileName,
+												 uLong fileNameBufferSize,
+												 void *extraField,
+												 uLong extraFieldBufferSize,
+												 char *szComment,
+												 uLong commentBufferSize));
+	/*
+  Get Info about the current file
+  if pfile_info!=NULL, the *pfile_info structure will contain somes info about
+        the current file
+  if szFileName!=NULL, the filemane string will be copied in szFileName
+            (fileNameBufferSize is the size of the buffer)
+  if extraField!=NULL, the extra field information will be copied in extraField
+            (extraFieldBufferSize is the size of the buffer).
+            This is the Central-header version of the extra field
+  if szComment!=NULL, the comment string of the file will be copied in szComment
+            (commentBufferSize is the size of the buffer)
+*/
+
+	/** Addition for GDAL : START */
+
+	extern ZPOS64_T ZEXPORT unzGetCurrentFileZStreamPos64 OF((unzFile file));
+
+	/** Addition for GDAL : END */
+
+	/***************************************************************************/
+	/* for reading the content of the current zipfile, you can open it, read data
+   from it, and close it (you can close it before reading all the file)
+   */
+
+	extern int ZEXPORT unzOpenCurrentFile OF((unzFile file));
+	/*
+  Open for reading data the current file in the zipfile.
+  If there is no error, the return value is UNZ_OK.
+*/
+
+	extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file,
+													  const char *password));
+	/*
+  Open for reading data the current file in the zipfile.
+  password is a crypting password
+  If there is no error, the return value is UNZ_OK.
+*/
+
+	extern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file,
+											   int *method,
+											   int *level,
+											   int raw));
+	/*
+  Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
+    if raw==1
+  *method will receive method of compression, *level will receive level of
+     compression
+  note : you can set level parameter as NULL (if you did not want known level,
+         but you CANNOT set method parameter as NULL
+*/
+
+	extern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file,
+											   int *method,
+											   int *level,
+											   int raw,
+											   const char *password));
+	/*
+  Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
+    if raw==1
+  *method will receive method of compression, *level will receive level of
+     compression
+  note : you can set level parameter as NULL (if you did not want known level,
+         but you CANNOT set method parameter as NULL
+*/
+
+	extern int ZEXPORT unzCloseCurrentFile OF((unzFile file));
+	/*
+  Close the file in zip opened with unzOpenCurrentFile
+  Return UNZ_CRCERROR if all the file was read but the CRC is not good
+*/
+
+	extern int ZEXPORT unzReadCurrentFile OF((unzFile file,
+											  voidp buf,
+											  unsigned len));
+	/*
+  Read bytes from the current file (opened by unzOpenCurrentFile)
+  buf contain buffer where data must be copied
+  len the size of buf.
+
+  return the number of byte copied if somes bytes are copied
+  return 0 if the end of file was reached
+  return <0 with error code if there is an error
+    (UNZ_ERRNO for IO error, or zLib error for uncompress error)
+*/
+
+	extern z_off_t ZEXPORT unztell OF((unzFile file));
+
+	extern ZPOS64_T ZEXPORT unztell64 OF((unzFile file));
+	/*
+  Give the current position in uncompressed data
+*/
+
+	extern int ZEXPORT unzeof OF((unzFile file));
+	/*
+  return 1 if the end of file was reached, 0 elsewhere
+*/
+
+	extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file,
+												 voidp buf,
+												 unsigned len));
+	/*
+  Read extra field from the current file (opened by unzOpenCurrentFile)
+  This is the local-header version of the extra field (sometimes, there is
+    more info in the local-header version than in the central-header)
+
+  if buf==NULL, it return the size of the local extra field
+
+  if buf!=NULL, len is the size of the buffer, the extra header is copied in
+    buf.
+  the return value is the number of bytes copied in buf, or (if <0)
+    the error code
+*/
+
+	/***************************************************************************/
+
+	/* Get the current file offset */
+	extern ZPOS64_T ZEXPORT unzGetOffset64(unzFile file);
+	extern uLong ZEXPORT unzGetOffset(unzFile file);
+
+	/* Set the current file offset */
+	extern int ZEXPORT unzSetOffset64(unzFile file, ZPOS64_T pos);
+	extern int ZEXPORT unzSetOffset(unzFile file, uLong pos);
+
+	ZEXTERN voidpf ZEXPORT unzDetach OF((unzFile* file));
+	ZEXTERN unzFile ZEXPORT unzAttach OF((voidpf stream, zlib_filefunc_def*));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _unz64_H */
diff --git a/engine/inc/bullet/ThirdPartyLibs/minizip/zip.h b/engine/inc/bullet/ThirdPartyLibs/minizip/zip.h
new file mode 100644
index 00000000..4aa5ffa4
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/minizip/zip.h
@@ -0,0 +1,357 @@
+/* zip.h -- IO on .zip files using zlib
+   Version 1.1, February 14h, 2010
+   part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Modifications for Zip64 support
+         Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
+
+         For more info read MiniZip_info.txt
+
+         ---------------------------------------------------------------------------
+
+   Condition of use and distribution are the same than zlib :
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+        ---------------------------------------------------------------------------
+
+        Changes
+
+        See header of zip.h
+
+*/
+
+#ifndef _zip12_H
+#define _zip12_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	//#define HAVE_BZIP2
+
+#ifndef _ZLIB_H
+#include "../zlib/zlib.h"
+#endif
+
+#ifndef _ZLIBIOAPI_H
+#include "ioapi.h"
+#endif
+
+#ifdef HAVE_BZIP2
+#include "bzlib.h"
+#endif
+
+#define Z_BZIP2ED 12
+
+#if defined(STRICTZIP) || defined(STRICTZIPUNZIP)
+	/* like the STRICT of WIN32, we define a pointer that cannot be converted
+    from (void*) without cast */
+	typedef struct TagzipFile__
+	{
+		int unused;
+	} zipFile__;
+	typedef zipFile__* zipFile;
+#else
+typedef voidp zipFile;
+#endif
+
+#define ZIP_OK (0)
+#define ZIP_EOF (0)
+#define ZIP_ERRNO (Z_ERRNO)
+#define ZIP_PARAMERROR (-102)
+#define ZIP_BADZIPFILE (-103)
+#define ZIP_INTERNALERROR (-104)
+
+#ifndef DEF_MEM_LEVEL
+#if MAX_MEM_LEVEL >= 8
+#define DEF_MEM_LEVEL 8
+#else
+#define DEF_MEM_LEVEL MAX_MEM_LEVEL
+#endif
+#endif
+	/* default memLevel */
+
+	/* tm_zip contain date/time info */
+	typedef struct tm_zip_s
+	{
+		uInt tm_sec;  /* seconds after the minute - [0,59] */
+		uInt tm_min;  /* minutes after the hour - [0,59] */
+		uInt tm_hour; /* hours since midnight - [0,23] */
+		uInt tm_mday; /* day of the month - [1,31] */
+		uInt tm_mon;  /* months since January - [0,11] */
+		uInt tm_year; /* years - [1980..2044] */
+	} tm_zip;
+
+	typedef struct
+	{
+		tm_zip tmz_date;                  /* date in understandable format           */
+		uLong dosDate;                    /* if dos_date == 0, tmu_date is used      */
+		/*    uLong       flag;        */ /* general purpose bit flag        2 bytes */
+
+		uLong internal_fa; /* internal file attributes        2 bytes */
+		uLong external_fa; /* external file attributes        4 bytes */
+	} zip_fileinfo;
+
+	typedef const char* zipcharpc;
+
+#define APPEND_STATUS_CREATE (0)
+#define APPEND_STATUS_CREATEAFTER (1)
+#define APPEND_STATUS_ADDINZIP (2)
+
+	extern zipFile ZEXPORT zipOpen OF((const char* pathname, int append));
+	extern zipFile ZEXPORT zipOpen64 OF((const void* pathname, int append));
+	/*
+  Create a zipfile.
+     pathname contain on Windows XP a filename like "c:\\zlib\\zlib113.zip" or on
+       an Unix computer "zlib/zlib113.zip".
+     if the file pathname exist and append==APPEND_STATUS_CREATEAFTER, the zip
+       will be created at the end of the file.
+         (useful if the file contain a self extractor code)
+     if the file pathname exist and append==APPEND_STATUS_ADDINZIP, we will
+       add files in existing zip (be sure you don't add file that doesn't exist)
+     If the zipfile cannot be opened, the return value is NULL.
+     Else, the return value is a zipFile Handle, usable with other function
+       of this zip package.
+*/
+
+	/* Note : there is no delete function into a zipfile.
+   If you want delete file into a zipfile, you must open a zipfile, and create another
+   Of couse, you can use RAW reading and writing to copy the file you did not want delte
+*/
+
+	extern zipFile ZEXPORT zipOpen2 OF((const char* pathname,
+										int append,
+										zipcharpc* globalcomment,
+										zlib_filefunc_def* pzlib_filefunc_def));
+
+	extern zipFile ZEXPORT zipOpen2_64 OF((const void* pathname,
+										   int append,
+										   zipcharpc* globalcomment,
+										   zlib_filefunc64_def* pzlib_filefunc_def));
+
+	extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file,
+											   const char* filename,
+											   const zip_fileinfo* zipfi,
+											   const void* extrafield_local,
+											   uInt size_extrafield_local,
+											   const void* extrafield_global,
+											   uInt size_extrafield_global,
+											   const char* comment,
+											   int method,
+											   int level));
+
+	extern int ZEXPORT zipOpenNewFileInZip64 OF((zipFile file,
+												 const char* filename,
+												 const zip_fileinfo* zipfi,
+												 const void* extrafield_local,
+												 uInt size_extrafield_local,
+												 const void* extrafield_global,
+												 uInt size_extrafield_global,
+												 const char* comment,
+												 int method,
+												 int level,
+												 int zip64));
+
+	/*
+  Open a file in the ZIP for writing.
+  filename : the filename in zip (if NULL, '-' without quote will be used
+  *zipfi contain supplemental information
+  if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local
+    contains the extrafield data the the local header
+  if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global
+    contains the extrafield data the the local header
+  if comment != NULL, comment contain the comment string
+  method contain the compression method (0 for store, Z_DEFLATED for deflate)
+  level contain the level of compression (can be Z_DEFAULT_COMPRESSION)
+  zip64 is set to 1 if a zip64 extended information block should be added to the local file header.
+                    this MUST be '1' if the uncompressed size is >= 0xffffffff.
+
+*/
+
+	extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file,
+												const char* filename,
+												const zip_fileinfo* zipfi,
+												const void* extrafield_local,
+												uInt size_extrafield_local,
+												const void* extrafield_global,
+												uInt size_extrafield_global,
+												const char* comment,
+												int method,
+												int level,
+												int raw));
+
+	extern int ZEXPORT zipOpenNewFileInZip2_64 OF((zipFile file,
+												   const char* filename,
+												   const zip_fileinfo* zipfi,
+												   const void* extrafield_local,
+												   uInt size_extrafield_local,
+												   const void* extrafield_global,
+												   uInt size_extrafield_global,
+												   const char* comment,
+												   int method,
+												   int level,
+												   int raw,
+												   int zip64));
+	/*
+  Same than zipOpenNewFileInZip, except if raw=1, we write raw file
+ */
+
+	extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file,
+												const char* filename,
+												const zip_fileinfo* zipfi,
+												const void* extrafield_local,
+												uInt size_extrafield_local,
+												const void* extrafield_global,
+												uInt size_extrafield_global,
+												const char* comment,
+												int method,
+												int level,
+												int raw,
+												int windowBits,
+												int memLevel,
+												int strategy,
+												const char* password,
+												uLong crcForCrypting));
+
+	extern int ZEXPORT zipOpenNewFileInZip3_64 OF((zipFile file,
+												   const char* filename,
+												   const zip_fileinfo* zipfi,
+												   const void* extrafield_local,
+												   uInt size_extrafield_local,
+												   const void* extrafield_global,
+												   uInt size_extrafield_global,
+												   const char* comment,
+												   int method,
+												   int level,
+												   int raw,
+												   int windowBits,
+												   int memLevel,
+												   int strategy,
+												   const char* password,
+												   uLong crcForCrypting,
+												   int zip64));
+
+	/*
+  Same than zipOpenNewFileInZip2, except
+    windowBits,memLevel,,strategy : see parameter strategy in deflateInit2
+    password : crypting password (NULL for no crypting)
+    crcForCrypting : crc of file to compress (needed for crypting)
+ */
+
+	extern int ZEXPORT zipOpenNewFileInZip4 OF((zipFile file,
+												const char* filename,
+												const zip_fileinfo* zipfi,
+												const void* extrafield_local,
+												uInt size_extrafield_local,
+												const void* extrafield_global,
+												uInt size_extrafield_global,
+												const char* comment,
+												int method,
+												int level,
+												int raw,
+												int windowBits,
+												int memLevel,
+												int strategy,
+												const char* password,
+												uLong crcForCrypting,
+												uLong versionMadeBy,
+												uLong flagBase));
+
+	extern int ZEXPORT zipOpenNewFileInZip4_64 OF((zipFile file,
+												   const char* filename,
+												   const zip_fileinfo* zipfi,
+												   const void* extrafield_local,
+												   uInt size_extrafield_local,
+												   const void* extrafield_global,
+												   uInt size_extrafield_global,
+												   const char* comment,
+												   int method,
+												   int level,
+												   int raw,
+												   int windowBits,
+												   int memLevel,
+												   int strategy,
+												   const char* password,
+												   uLong crcForCrypting,
+												   uLong versionMadeBy,
+												   uLong flagBase,
+												   int zip64));
+	/*
+  Same than zipOpenNewFileInZip4, except
+    versionMadeBy : value for Version made by field
+    flag : value for flag field (compression level info will be added)
+ */
+
+	extern int ZEXPORT zipWriteInFileInZip OF((zipFile file,
+											   const void* buf,
+											   unsigned len));
+	/*
+  Write data in the zipfile
+*/
+
+	extern int ZEXPORT zipCloseFileInZip OF((zipFile file));
+	/*
+  Close the current file in the zipfile
+*/
+
+	extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file,
+												uLong uncompressed_size,
+												uLong crc32));
+
+	extern int ZEXPORT zipCloseFileInZipRaw64 OF((zipFile file,
+												  ZPOS64_T uncompressed_size,
+												  uLong crc32));
+
+	/*
+  Close the current file in the zipfile, for file opened with
+    parameter raw=1 in zipOpenNewFileInZip2
+  uncompressed_size and crc32 are value for the uncompressed size
+*/
+
+	extern int ZEXPORT zipClose OF((zipFile file,
+									const char* global_comment));
+	/*
+  Close the zipfile
+*/
+
+	extern int ZEXPORT zipRemoveExtraInfoBlock OF((char* pData, int* dataLen, short sHeader));
+	/*
+  zipRemoveExtraInfoBlock -  Added by Mathias Svensson
+
+  Remove extra information block from a extra information data for the local file header or central directory header
+
+  It is needed to remove ZIP64 extra information blocks when before data is written if using RAW mode.
+
+  0x0001 is the signature header for the ZIP64 extra information blocks
+
+  usage.
+                        Remove ZIP64 Extra information from a central director extra field data
+              zipRemoveExtraInfoBlock(pCenDirExtraFieldData, &nCenDirExtraFieldDataLen, 0x0001);
+
+                        Remove ZIP64 Extra information from a Local File Header extra field data
+        zipRemoveExtraInfoBlock(pLocalHeaderExtraFieldData, &nLocalHeaderExtraFieldDataLen, 0x0001);
+*/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _zip64_H */
diff --git a/engine/inc/bullet/ThirdPartyLibs/openvr/bin/osx64/OpenVR.framework/Headers/openvr.h b/engine/inc/bullet/ThirdPartyLibs/openvr/bin/osx64/OpenVR.framework/Headers/openvr.h
new file mode 100644
index 00000000..80461f96
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/openvr/bin/osx64/OpenVR.framework/Headers/openvr.h
@@ -0,0 +1,3698 @@
+#pragma once
+
+// openvr.h
+//========= Copyright Valve Corporation ============//
+// Dynamically generated file. Do not modify this file directly.
+
+#ifndef _OPENVR_API
+#define _OPENVR_API
+
+#include <stdint.h>
+
+// vrtypes.h
+#ifndef _INCLUDE_VRTYPES_H
+#define _INCLUDE_VRTYPES_H
+
+// Forward declarations to avoid requiring vulkan.h
+struct VkDevice_T;
+struct VkPhysicalDevice_T;
+struct VkInstance_T;
+struct VkQueue_T;
+
+// Forward declarations to avoid requiring d3d12.h
+struct ID3D12Resource;
+struct ID3D12CommandQueue;
+
+namespace vr
+{
+#pragma pack(push, 8)
+
+typedef void *glSharedTextureHandle_t;
+typedef int32_t glInt_t;
+typedef uint32_t glUInt_t;
+
+// right-handed system
+// +y is up
+// +x is to the right
+// -z is going away from you
+// Distance unit is  meters
+struct HmdMatrix34_t
+{
+	float m[3][4];
+};
+
+struct HmdMatrix44_t
+{
+	float m[4][4];
+};
+
+struct HmdVector3_t
+{
+	float v[3];
+};
+
+struct HmdVector4_t
+{
+	float v[4];
+};
+
+struct HmdVector3d_t
+{
+	double v[3];
+};
+
+struct HmdVector2_t
+{
+	float v[2];
+};
+
+struct HmdQuaternion_t
+{
+	double w, x, y, z;
+};
+
+struct HmdColor_t
+{
+	float r, g, b, a;
+};
+
+struct HmdQuad_t
+{
+	HmdVector3_t vCorners[4];
+};
+
+struct HmdRect2_t
+{
+	HmdVector2_t vTopLeft;
+	HmdVector2_t vBottomRight;
+};
+
+/** Used to return the post-distortion UVs for each color channel. 
+* UVs range from 0 to 1 with 0,0 in the upper left corner of the 
+* source render target. The 0,0 to 1,1 range covers a single eye. */
+struct DistortionCoordinates_t
+{
+	float rfRed[2];
+	float rfGreen[2];
+	float rfBlue[2];
+};
+
+enum EVREye
+{
+	Eye_Left = 0,
+	Eye_Right = 1
+};
+
+enum ETextureType
+{
+	TextureType_DirectX = 0,    // Handle is an ID3D11Texture
+	TextureType_OpenGL = 1,     // Handle is an OpenGL texture name or an OpenGL render buffer name, depending on submit flags
+	TextureType_Vulkan = 2,     // Handle is a pointer to a VRVulkanTextureData_t structure
+	TextureType_IOSurface = 3,  // Handle is a macOS cross-process-sharable IOSurfaceRef
+	TextureType_DirectX12 = 4,  // Handle is a pointer to a D3D12TextureData_t structure
+};
+
+enum EColorSpace
+{
+	ColorSpace_Auto = 0,    // Assumes 'gamma' for 8-bit per component formats, otherwise 'linear'.  This mirrors the DXGI formats which have _SRGB variants.
+	ColorSpace_Gamma = 1,   // Texture data can be displayed directly on the display without any conversion (a.k.a. display native format).
+	ColorSpace_Linear = 2,  // Same as gamma but has been converted to a linear representation using DXGI's sRGB conversion algorithm.
+};
+
+struct Texture_t
+{
+	void *handle;  // See ETextureType definition above
+	ETextureType eType;
+	EColorSpace eColorSpace;
+};
+
+// Handle to a shared texture (HANDLE on Windows obtained using OpenSharedResource).
+typedef uint64_t SharedTextureHandle_t;
+#define INVALID_SHARED_TEXTURE_HANDLE ((vr::SharedTextureHandle_t)0)
+
+enum ETrackingResult
+{
+	TrackingResult_Uninitialized = 1,
+
+	TrackingResult_Calibrating_InProgress = 100,
+	TrackingResult_Calibrating_OutOfRange = 101,
+
+	TrackingResult_Running_OK = 200,
+	TrackingResult_Running_OutOfRange = 201,
+};
+
+typedef uint32_t DriverId_t;
+static const uint32_t k_nDriverNone = 0xFFFFFFFF;
+
+static const uint32_t k_unMaxDriverDebugResponseSize = 32768;
+
+/** Used to pass device IDs to API calls */
+typedef uint32_t TrackedDeviceIndex_t;
+static const uint32_t k_unTrackedDeviceIndex_Hmd = 0;
+static const uint32_t k_unMaxTrackedDeviceCount = 16;
+static const uint32_t k_unTrackedDeviceIndexOther = 0xFFFFFFFE;
+static const uint32_t k_unTrackedDeviceIndexInvalid = 0xFFFFFFFF;
+
+/** Describes what kind of object is being tracked at a given ID */
+enum ETrackedDeviceClass
+{
+	TrackedDeviceClass_Invalid = 0,            // the ID was not valid.
+	TrackedDeviceClass_HMD = 1,                // Head-Mounted Displays
+	TrackedDeviceClass_Controller = 2,         // Tracked controllers
+	TrackedDeviceClass_GenericTracker = 3,     // Generic trackers, similar to controllers
+	TrackedDeviceClass_TrackingReference = 4,  // Camera and base stations that serve as tracking reference points
+	TrackedDeviceClass_DisplayRedirect = 5,    // Accessories that aren't necessarily tracked themselves, but may redirect video output from other tracked devices
+};
+
+/** Describes what specific role associated with a tracked device */
+enum ETrackedControllerRole
+{
+	TrackedControllerRole_Invalid = 0,    // Invalid value for controller type
+	TrackedControllerRole_LeftHand = 1,   // Tracked device associated with the left hand
+	TrackedControllerRole_RightHand = 2,  // Tracked device associated with the right hand
+};
+
+/** describes a single pose for a tracked object */
+struct TrackedDevicePose_t
+{
+	HmdMatrix34_t mDeviceToAbsoluteTracking;
+	HmdVector3_t vVelocity;         // velocity in tracker space in m/s
+	HmdVector3_t vAngularVelocity;  // angular velocity in radians/s (?)
+	ETrackingResult eTrackingResult;
+	bool bPoseIsValid;
+
+	// This indicates that there is a device connected for this spot in the pose array.
+	// It could go from true to false if the user unplugs the device.
+	bool bDeviceIsConnected;
+};
+
+/** Identifies which style of tracking origin the application wants to use
+* for the poses it is requesting */
+enum ETrackingUniverseOrigin
+{
+	TrackingUniverseSeated = 0,              // Poses are provided relative to the seated zero pose
+	TrackingUniverseStanding = 1,            // Poses are provided relative to the safe bounds configured by the user
+	TrackingUniverseRawAndUncalibrated = 2,  // Poses are provided in the coordinate system defined by the driver.  It has Y up and is unified for devices of the same driver. You usually don't want this one.
+};
+
+// Refers to a single container of properties
+typedef uint64_t PropertyContainerHandle_t;
+typedef uint32_t PropertyTypeTag_t;
+
+static const PropertyContainerHandle_t k_ulInvalidPropertyContainer = 0;
+static const PropertyTypeTag_t k_unInvalidPropertyTag = 0;
+
+// Use these tags to set/get common types as struct properties
+static const PropertyTypeTag_t k_unFloatPropertyTag = 1;
+static const PropertyTypeTag_t k_unInt32PropertyTag = 2;
+static const PropertyTypeTag_t k_unUint64PropertyTag = 3;
+static const PropertyTypeTag_t k_unBoolPropertyTag = 4;
+static const PropertyTypeTag_t k_unStringPropertyTag = 5;
+
+static const PropertyTypeTag_t k_unHmdMatrix34PropertyTag = 20;
+static const PropertyTypeTag_t k_unHmdMatrix44PropertyTag = 21;
+static const PropertyTypeTag_t k_unHmdVector3PropertyTag = 22;
+static const PropertyTypeTag_t k_unHmdVector4PropertyTag = 23;
+
+static const PropertyTypeTag_t k_unHiddenAreaPropertyTag = 30;
+
+static const PropertyTypeTag_t k_unOpenVRInternalReserved_Start = 1000;
+static const PropertyTypeTag_t k_unOpenVRInternalReserved_End = 10000;
+
+/** Each entry in this enum represents a property that can be retrieved about a
+* tracked device. Many fields are only valid for one ETrackedDeviceClass. */
+enum ETrackedDeviceProperty
+{
+	Prop_Invalid = 0,
+
+	// general properties that apply to all device classes
+	Prop_TrackingSystemName_String = 1000,
+	Prop_ModelNumber_String = 1001,
+	Prop_SerialNumber_String = 1002,
+	Prop_RenderModelName_String = 1003,
+	Prop_WillDriftInYaw_Bool = 1004,
+	Prop_ManufacturerName_String = 1005,
+	Prop_TrackingFirmwareVersion_String = 1006,
+	Prop_HardwareRevision_String = 1007,
+	Prop_AllWirelessDongleDescriptions_String = 1008,
+	Prop_ConnectedWirelessDongle_String = 1009,
+	Prop_DeviceIsWireless_Bool = 1010,
+	Prop_DeviceIsCharging_Bool = 1011,
+	Prop_DeviceBatteryPercentage_Float = 1012,  // 0 is empty, 1 is full
+	Prop_StatusDisplayTransform_Matrix34 = 1013,
+	Prop_Firmware_UpdateAvailable_Bool = 1014,
+	Prop_Firmware_ManualUpdate_Bool = 1015,
+	Prop_Firmware_ManualUpdateURL_String = 1016,
+	Prop_HardwareRevision_Uint64 = 1017,
+	Prop_FirmwareVersion_Uint64 = 1018,
+	Prop_FPGAVersion_Uint64 = 1019,
+	Prop_VRCVersion_Uint64 = 1020,
+	Prop_RadioVersion_Uint64 = 1021,
+	Prop_DongleVersion_Uint64 = 1022,
+	Prop_BlockServerShutdown_Bool = 1023,
+	Prop_CanUnifyCoordinateSystemWithHmd_Bool = 1024,
+	Prop_ContainsProximitySensor_Bool = 1025,
+	Prop_DeviceProvidesBatteryStatus_Bool = 1026,
+	Prop_DeviceCanPowerOff_Bool = 1027,
+	Prop_Firmware_ProgrammingTarget_String = 1028,
+	Prop_DeviceClass_Int32 = 1029,
+	Prop_HasCamera_Bool = 1030,
+	Prop_DriverVersion_String = 1031,
+	Prop_Firmware_ForceUpdateRequired_Bool = 1032,
+	Prop_ViveSystemButtonFixRequired_Bool = 1033,
+	Prop_ParentDriver_Uint64 = 1034,
+	Prop_ResourceRoot_String = 1035,
+
+	// Properties that are unique to TrackedDeviceClass_HMD
+	Prop_ReportsTimeSinceVSync_Bool = 2000,
+	Prop_SecondsFromVsyncToPhotons_Float = 2001,
+	Prop_DisplayFrequency_Float = 2002,
+	Prop_UserIpdMeters_Float = 2003,
+	Prop_CurrentUniverseId_Uint64 = 2004,
+	Prop_PreviousUniverseId_Uint64 = 2005,
+	Prop_DisplayFirmwareVersion_Uint64 = 2006,
+	Prop_IsOnDesktop_Bool = 2007,
+	Prop_DisplayMCType_Int32 = 2008,
+	Prop_DisplayMCOffset_Float = 2009,
+	Prop_DisplayMCScale_Float = 2010,
+	Prop_EdidVendorID_Int32 = 2011,
+	Prop_DisplayMCImageLeft_String = 2012,
+	Prop_DisplayMCImageRight_String = 2013,
+	Prop_DisplayGCBlackClamp_Float = 2014,
+	Prop_EdidProductID_Int32 = 2015,
+	Prop_CameraToHeadTransform_Matrix34 = 2016,
+	Prop_DisplayGCType_Int32 = 2017,
+	Prop_DisplayGCOffset_Float = 2018,
+	Prop_DisplayGCScale_Float = 2019,
+	Prop_DisplayGCPrescale_Float = 2020,
+	Prop_DisplayGCImage_String = 2021,
+	Prop_LensCenterLeftU_Float = 2022,
+	Prop_LensCenterLeftV_Float = 2023,
+	Prop_LensCenterRightU_Float = 2024,
+	Prop_LensCenterRightV_Float = 2025,
+	Prop_UserHeadToEyeDepthMeters_Float = 2026,
+	Prop_CameraFirmwareVersion_Uint64 = 2027,
+	Prop_CameraFirmwareDescription_String = 2028,
+	Prop_DisplayFPGAVersion_Uint64 = 2029,
+	Prop_DisplayBootloaderVersion_Uint64 = 2030,
+	Prop_DisplayHardwareVersion_Uint64 = 2031,
+	Prop_AudioFirmwareVersion_Uint64 = 2032,
+	Prop_CameraCompatibilityMode_Int32 = 2033,
+	Prop_ScreenshotHorizontalFieldOfViewDegrees_Float = 2034,
+	Prop_ScreenshotVerticalFieldOfViewDegrees_Float = 2035,
+	Prop_DisplaySuppressed_Bool = 2036,
+	Prop_DisplayAllowNightMode_Bool = 2037,
+	Prop_DisplayMCImageWidth_Int32 = 2038,
+	Prop_DisplayMCImageHeight_Int32 = 2039,
+	Prop_DisplayMCImageNumChannels_Int32 = 2040,
+	Prop_DisplayMCImageData_Binary = 2041,
+	Prop_SecondsFromPhotonsToVblank_Float = 2042,
+	Prop_DriverDirectModeSendsVsyncEvents_Bool = 2043,
+	Prop_DisplayDebugMode_Bool = 2044,
+	Prop_GraphicsAdapterLuid_Uint64 = 2045,
+	Prop_DriverProvidedChaperonePath_String = 2048,
+
+	// Properties that are unique to TrackedDeviceClass_Controller
+	Prop_AttachedDeviceId_String = 3000,
+	Prop_SupportedButtons_Uint64 = 3001,
+	Prop_Axis0Type_Int32 = 3002,           // Return value is of type EVRControllerAxisType
+	Prop_Axis1Type_Int32 = 3003,           // Return value is of type EVRControllerAxisType
+	Prop_Axis2Type_Int32 = 3004,           // Return value is of type EVRControllerAxisType
+	Prop_Axis3Type_Int32 = 3005,           // Return value is of type EVRControllerAxisType
+	Prop_Axis4Type_Int32 = 3006,           // Return value is of type EVRControllerAxisType
+	Prop_ControllerRoleHint_Int32 = 3007,  // Return value is of type ETrackedControllerRole
+
+	// Properties that are unique to TrackedDeviceClass_TrackingReference
+	Prop_FieldOfViewLeftDegrees_Float = 4000,
+	Prop_FieldOfViewRightDegrees_Float = 4001,
+	Prop_FieldOfViewTopDegrees_Float = 4002,
+	Prop_FieldOfViewBottomDegrees_Float = 4003,
+	Prop_TrackingRangeMinimumMeters_Float = 4004,
+	Prop_TrackingRangeMaximumMeters_Float = 4005,
+	Prop_ModeLabel_String = 4006,
+
+	// Properties that are used for user interface like icons names
+	Prop_IconPathName_String = 5000,                       // DEPRECATED. Value not referenced. Now expected to be part of icon path properties.
+	Prop_NamedIconPathDeviceOff_String = 5001,             // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceSearching_String = 5002,       // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceSearchingAlert_String = 5003,  // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceReady_String = 5004,           // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceReadyAlert_String = 5005,      // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceNotReady_String = 5006,        // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceStandby_String = 5007,         // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceAlertLow_String = 5008,        // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+
+	// Properties that are used by helpers, but are opaque to applications
+	Prop_DisplayHiddenArea_Binary_Start = 5100,
+	Prop_DisplayHiddenArea_Binary_End = 5150,
+
+	// Properties that are unique to drivers
+	Prop_UserConfigPath_String = 6000,
+	Prop_InstallPath_String = 6001,
+	Prop_HasDisplayComponent_Bool = 6002,
+	Prop_HasControllerComponent_Bool = 6003,
+	Prop_HasCameraComponent_Bool = 6004,
+	Prop_HasDriverDirectModeComponent_Bool = 6005,
+	Prop_HasVirtualDisplayComponent_Bool = 6006,
+
+	// Vendors are free to expose private debug data in this reserved region
+	Prop_VendorSpecific_Reserved_Start = 10000,
+	Prop_VendorSpecific_Reserved_End = 10999,
+};
+
+/** No string property will ever be longer than this length */
+static const uint32_t k_unMaxPropertyStringSize = 32 * 1024;
+
+/** Used to return errors that occur when reading properties. */
+enum ETrackedPropertyError
+{
+	TrackedProp_Success = 0,
+	TrackedProp_WrongDataType = 1,
+	TrackedProp_WrongDeviceClass = 2,
+	TrackedProp_BufferTooSmall = 3,
+	TrackedProp_UnknownProperty = 4,  // Driver has not set the property (and may not ever).
+	TrackedProp_InvalidDevice = 5,
+	TrackedProp_CouldNotContactServer = 6,
+	TrackedProp_ValueNotProvidedByDevice = 7,
+	TrackedProp_StringExceedsMaximumLength = 8,
+	TrackedProp_NotYetAvailable = 9,  // The property value isn't known yet, but is expected soon. Call again later.
+	TrackedProp_PermissionDenied = 10,
+	TrackedProp_InvalidOperation = 11,
+};
+
+/** Allows the application to control what part of the provided texture will be used in the
+* frame buffer. */
+struct VRTextureBounds_t
+{
+	float uMin, vMin;
+	float uMax, vMax;
+};
+
+/** Allows specifying pose used to render provided scene texture (if different from value returned by WaitGetPoses). */
+struct VRTextureWithPose_t : public Texture_t
+{
+	HmdMatrix34_t mDeviceToAbsoluteTracking;  // Actual pose used to render scene textures.
+};
+
+/** Allows the application to control how scene textures are used by the compositor when calling Submit. */
+enum EVRSubmitFlags
+{
+	// Simple render path. App submits rendered left and right eye images with no lens distortion correction applied.
+	Submit_Default = 0x00,
+
+	// App submits final left and right eye images with lens distortion already applied (lens distortion makes the images appear
+	// barrel distorted with chromatic aberration correction applied). The app would have used the data returned by
+	// vr::IVRSystem::ComputeDistortion() to apply the correct distortion to the rendered images before calling Submit().
+	Submit_LensDistortionAlreadyApplied = 0x01,
+
+	// If the texture pointer passed in is actually a renderbuffer (e.g. for MSAA in OpenGL) then set this flag.
+	Submit_GlRenderBuffer = 0x02,
+
+	// Do not use
+	Submit_Reserved = 0x04,
+
+	// Set to indicate that pTexture is a pointer to a VRTextureWithPose_t.
+	Submit_TextureWithPose = 0x08,
+};
+
+/** Data required for passing Vulkan textures to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. */
+struct VRVulkanTextureData_t
+{
+	uint64_t m_nImage;  // VkImage
+	VkDevice_T *m_pDevice;
+	VkPhysicalDevice_T *m_pPhysicalDevice;
+	VkInstance_T *m_pInstance;
+	VkQueue_T *m_pQueue;
+	uint32_t m_nQueueFamilyIndex;
+	uint32_t m_nWidth, m_nHeight, m_nFormat, m_nSampleCount;
+};
+
+/** Data required for passing D3D12 textures to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. */
+struct D3D12TextureData_t
+{
+	ID3D12Resource *m_pResource;
+	ID3D12CommandQueue *m_pCommandQueue;
+	uint32_t m_nNodeMask;
+};
+
+/** Status of the overall system or tracked objects */
+enum EVRState
+{
+	VRState_Undefined = -1,
+	VRState_Off = 0,
+	VRState_Searching = 1,
+	VRState_Searching_Alert = 2,
+	VRState_Ready = 3,
+	VRState_Ready_Alert = 4,
+	VRState_NotReady = 5,
+	VRState_Standby = 6,
+	VRState_Ready_Alert_Low = 7,
+};
+
+/** The types of events that could be posted (and what the parameters mean for each event type) */
+enum EVREventType
+{
+	VREvent_None = 0,
+
+	VREvent_TrackedDeviceActivated = 100,
+	VREvent_TrackedDeviceDeactivated = 101,
+	VREvent_TrackedDeviceUpdated = 102,
+	VREvent_TrackedDeviceUserInteractionStarted = 103,
+	VREvent_TrackedDeviceUserInteractionEnded = 104,
+	VREvent_IpdChanged = 105,
+	VREvent_EnterStandbyMode = 106,
+	VREvent_LeaveStandbyMode = 107,
+	VREvent_TrackedDeviceRoleChanged = 108,
+	VREvent_WatchdogWakeUpRequested = 109,
+	VREvent_LensDistortionChanged = 110,
+	VREvent_PropertyChanged = 111,
+	VREvent_WirelessDisconnect = 112,
+	VREvent_WirelessReconnect = 113,
+
+	VREvent_ButtonPress = 200,    // data is controller
+	VREvent_ButtonUnpress = 201,  // data is controller
+	VREvent_ButtonTouch = 202,    // data is controller
+	VREvent_ButtonUntouch = 203,  // data is controller
+
+	VREvent_MouseMove = 300,            // data is mouse
+	VREvent_MouseButtonDown = 301,      // data is mouse
+	VREvent_MouseButtonUp = 302,        // data is mouse
+	VREvent_FocusEnter = 303,           // data is overlay
+	VREvent_FocusLeave = 304,           // data is overlay
+	VREvent_Scroll = 305,               // data is mouse
+	VREvent_TouchPadMove = 306,         // data is mouse
+	VREvent_OverlayFocusChanged = 307,  // data is overlay, global event
+
+	VREvent_InputFocusCaptured = 400,                         // data is process DEPRECATED
+	VREvent_InputFocusReleased = 401,                         // data is process DEPRECATED
+	VREvent_SceneFocusLost = 402,                             // data is process
+	VREvent_SceneFocusGained = 403,                           // data is process
+	VREvent_SceneApplicationChanged = 404,                    // data is process - The App actually drawing the scene changed (usually to or from the compositor)
+	VREvent_SceneFocusChanged = 405,                          // data is process - New app got access to draw the scene
+	VREvent_InputFocusChanged = 406,                          // data is process
+	VREvent_SceneApplicationSecondaryRenderingStarted = 407,  // data is process
+
+	VREvent_HideRenderModels = 410,  // Sent to the scene application to request hiding render models temporarily
+	VREvent_ShowRenderModels = 411,  // Sent to the scene application to request restoring render model visibility
+
+	VREvent_OverlayShown = 500,
+	VREvent_OverlayHidden = 501,
+	VREvent_DashboardActivated = 502,
+	VREvent_DashboardDeactivated = 503,
+	VREvent_DashboardThumbSelected = 504,     // Sent to the overlay manager - data is overlay
+	VREvent_DashboardRequested = 505,         // Sent to the overlay manager - data is overlay
+	VREvent_ResetDashboard = 506,             // Send to the overlay manager
+	VREvent_RenderToast = 507,                // Send to the dashboard to render a toast - data is the notification ID
+	VREvent_ImageLoaded = 508,                // Sent to overlays when a SetOverlayRaw or SetOverlayFromFile call finishes loading
+	VREvent_ShowKeyboard = 509,               // Sent to keyboard renderer in the dashboard to invoke it
+	VREvent_HideKeyboard = 510,               // Sent to keyboard renderer in the dashboard to hide it
+	VREvent_OverlayGamepadFocusGained = 511,  // Sent to an overlay when IVROverlay::SetFocusOverlay is called on it
+	VREvent_OverlayGamepadFocusLost = 512,    // Send to an overlay when it previously had focus and IVROverlay::SetFocusOverlay is called on something else
+	VREvent_OverlaySharedTextureChanged = 513,
+	VREvent_DashboardGuideButtonDown = 514,
+	VREvent_DashboardGuideButtonUp = 515,
+	VREvent_ScreenshotTriggered = 516,  // Screenshot button combo was pressed, Dashboard should request a screenshot
+	VREvent_ImageFailed = 517,          // Sent to overlays when a SetOverlayRaw or SetOverlayfromFail fails to load
+	VREvent_DashboardOverlayCreated = 518,
+
+	// Screenshot API
+	VREvent_RequestScreenshot = 520,              // Sent by vrclient application to compositor to take a screenshot
+	VREvent_ScreenshotTaken = 521,                // Sent by compositor to the application that the screenshot has been taken
+	VREvent_ScreenshotFailed = 522,               // Sent by compositor to the application that the screenshot failed to be taken
+	VREvent_SubmitScreenshotToDashboard = 523,    // Sent by compositor to the dashboard that a completed screenshot was submitted
+	VREvent_ScreenshotProgressToDashboard = 524,  // Sent by compositor to the dashboard that a completed screenshot was submitted
+
+	VREvent_PrimaryDashboardDeviceChanged = 525,
+
+	VREvent_Notification_Shown = 600,
+	VREvent_Notification_Hidden = 601,
+	VREvent_Notification_BeginInteraction = 602,
+	VREvent_Notification_Destroyed = 603,
+
+	VREvent_Quit = 700,                    // data is process
+	VREvent_ProcessQuit = 701,             // data is process
+	VREvent_QuitAborted_UserPrompt = 702,  // data is process
+	VREvent_QuitAcknowledged = 703,        // data is process
+	VREvent_DriverRequestedQuit = 704,     // The driver has requested that SteamVR shut down
+
+	VREvent_ChaperoneDataHasChanged = 800,
+	VREvent_ChaperoneUniverseHasChanged = 801,
+	VREvent_ChaperoneTempDataHasChanged = 802,
+	VREvent_ChaperoneSettingsHaveChanged = 803,
+	VREvent_SeatedZeroPoseReset = 804,
+
+	VREvent_AudioSettingsHaveChanged = 820,
+
+	VREvent_BackgroundSettingHasChanged = 850,
+	VREvent_CameraSettingsHaveChanged = 851,
+	VREvent_ReprojectionSettingHasChanged = 852,
+	VREvent_ModelSkinSettingsHaveChanged = 853,
+	VREvent_EnvironmentSettingsHaveChanged = 854,
+	VREvent_PowerSettingsHaveChanged = 855,
+	VREvent_EnableHomeAppSettingsHaveChanged = 856,
+
+	VREvent_StatusUpdate = 900,
+
+	VREvent_MCImageUpdated = 1000,
+
+	VREvent_FirmwareUpdateStarted = 1100,
+	VREvent_FirmwareUpdateFinished = 1101,
+
+	VREvent_KeyboardClosed = 1200,
+	VREvent_KeyboardCharInput = 1201,
+	VREvent_KeyboardDone = 1202,  // Sent when DONE button clicked on keyboard
+
+	VREvent_ApplicationTransitionStarted = 1300,
+	VREvent_ApplicationTransitionAborted = 1301,
+	VREvent_ApplicationTransitionNewAppStarted = 1302,
+	VREvent_ApplicationListUpdated = 1303,
+	VREvent_ApplicationMimeTypeLoad = 1304,
+	VREvent_ApplicationTransitionNewAppLaunchComplete = 1305,
+	VREvent_ProcessConnected = 1306,
+	VREvent_ProcessDisconnected = 1307,
+
+	VREvent_Compositor_MirrorWindowShown = 1400,
+	VREvent_Compositor_MirrorWindowHidden = 1401,
+	VREvent_Compositor_ChaperoneBoundsShown = 1410,
+	VREvent_Compositor_ChaperoneBoundsHidden = 1411,
+
+	VREvent_TrackedCamera_StartVideoStream = 1500,
+	VREvent_TrackedCamera_StopVideoStream = 1501,
+	VREvent_TrackedCamera_PauseVideoStream = 1502,
+	VREvent_TrackedCamera_ResumeVideoStream = 1503,
+	VREvent_TrackedCamera_EditingSurface = 1550,
+
+	VREvent_PerformanceTest_EnableCapture = 1600,
+	VREvent_PerformanceTest_DisableCapture = 1601,
+	VREvent_PerformanceTest_FidelityLevel = 1602,
+
+	VREvent_MessageOverlay_Closed = 1650,
+	VREvent_MessageOverlayCloseRequested = 1651,
+
+	// Vendors are free to expose private events in this reserved region
+	VREvent_VendorSpecific_Reserved_Start = 10000,
+	VREvent_VendorSpecific_Reserved_End = 19999,
+};
+
+/** Level of Hmd activity */
+// UserInteraction_Timeout means the device is in the process of timing out.
+// InUse = ( k_EDeviceActivityLevel_UserInteraction || k_EDeviceActivityLevel_UserInteraction_Timeout )
+// VREvent_TrackedDeviceUserInteractionStarted fires when the devices transitions from Standby -> UserInteraction or Idle -> UserInteraction.
+// VREvent_TrackedDeviceUserInteractionEnded fires when the devices transitions from UserInteraction_Timeout -> Idle
+enum EDeviceActivityLevel
+{
+	k_EDeviceActivityLevel_Unknown = -1,
+	k_EDeviceActivityLevel_Idle = 0,                     // No activity for the last 10 seconds
+	k_EDeviceActivityLevel_UserInteraction = 1,          // Activity (movement or prox sensor) is happening now
+	k_EDeviceActivityLevel_UserInteraction_Timeout = 2,  // No activity for the last 0.5 seconds
+	k_EDeviceActivityLevel_Standby = 3,                  // Idle for at least 5 seconds (configurable in Settings -> Power Management)
+};
+
+/** VR controller button and axis IDs */
+enum EVRButtonId
+{
+	k_EButton_System = 0,
+	k_EButton_ApplicationMenu = 1,
+	k_EButton_Grip = 2,
+	k_EButton_DPad_Left = 3,
+	k_EButton_DPad_Up = 4,
+	k_EButton_DPad_Right = 5,
+	k_EButton_DPad_Down = 6,
+	k_EButton_A = 7,
+
+	k_EButton_ProximitySensor = 31,
+
+	k_EButton_Axis0 = 32,
+	k_EButton_Axis1 = 33,
+	k_EButton_Axis2 = 34,
+	k_EButton_Axis3 = 35,
+	k_EButton_Axis4 = 36,
+
+	// aliases for well known controllers
+	k_EButton_SteamVR_Touchpad = k_EButton_Axis0,
+	k_EButton_SteamVR_Trigger = k_EButton_Axis1,
+
+	k_EButton_Dashboard_Back = k_EButton_Grip,
+
+	k_EButton_Max = 64
+};
+
+inline uint64_t ButtonMaskFromId(EVRButtonId id) { return 1ull << id; }
+
+/** used for controller button events */
+struct VREvent_Controller_t
+{
+	uint32_t button;  // EVRButtonId enum
+};
+
+/** used for simulated mouse events in overlay space */
+enum EVRMouseButton
+{
+	VRMouseButton_Left = 0x0001,
+	VRMouseButton_Right = 0x0002,
+	VRMouseButton_Middle = 0x0004,
+};
+
+/** used for simulated mouse events in overlay space */
+struct VREvent_Mouse_t
+{
+	float x, y;       // co-ords are in GL space, bottom left of the texture is 0,0
+	uint32_t button;  // EVRMouseButton enum
+};
+
+/** used for simulated mouse wheel scroll in overlay space */
+struct VREvent_Scroll_t
+{
+	float xdelta, ydelta;  // movement in fraction of the pad traversed since last delta, 1.0 for a full swipe
+	uint32_t repeatCount;
+};
+
+/** when in mouse input mode you can receive data from the touchpad, these events are only sent if the users finger
+   is on the touchpad (or just released from it) 
+**/
+struct VREvent_TouchPadMove_t
+{
+	// true if the users finger is detected on the touch pad
+	bool bFingerDown;
+
+	// How long the finger has been down in seconds
+	float flSecondsFingerDown;
+
+	// These values indicate the starting finger position (so you can do some basic swipe stuff)
+	float fValueXFirst;
+	float fValueYFirst;
+
+	// This is the raw sampled coordinate without deadzoning
+	float fValueXRaw;
+	float fValueYRaw;
+};
+
+/** notification related events. Details will still change at this point */
+struct VREvent_Notification_t
+{
+	uint64_t ulUserValue;
+	uint32_t notificationId;
+};
+
+/** Used for events about processes */
+struct VREvent_Process_t
+{
+	uint32_t pid;
+	uint32_t oldPid;
+	bool bForced;
+};
+
+/** Used for a few events about overlays */
+struct VREvent_Overlay_t
+{
+	uint64_t overlayHandle;
+};
+
+/** Used for a few events about overlays */
+struct VREvent_Status_t
+{
+	uint32_t statusState;  // EVRState enum
+};
+
+/** Used for keyboard events **/
+struct VREvent_Keyboard_t
+{
+	char cNewInput[8];    // Up to 11 bytes of new input
+	uint64_t uUserValue;  // Possible flags about the new input
+};
+
+struct VREvent_Ipd_t
+{
+	float ipdMeters;
+};
+
+struct VREvent_Chaperone_t
+{
+	uint64_t m_nPreviousUniverse;
+	uint64_t m_nCurrentUniverse;
+};
+
+/** Not actually used for any events */
+struct VREvent_Reserved_t
+{
+	uint64_t reserved0;
+	uint64_t reserved1;
+};
+
+struct VREvent_PerformanceTest_t
+{
+	uint32_t m_nFidelityLevel;
+};
+
+struct VREvent_SeatedZeroPoseReset_t
+{
+	bool bResetBySystemMenu;
+};
+
+struct VREvent_Screenshot_t
+{
+	uint32_t handle;
+	uint32_t type;
+};
+
+struct VREvent_ScreenshotProgress_t
+{
+	float progress;
+};
+
+struct VREvent_ApplicationLaunch_t
+{
+	uint32_t pid;
+	uint32_t unArgsHandle;
+};
+
+struct VREvent_EditingCameraSurface_t
+{
+	uint64_t overlayHandle;
+	uint32_t nVisualMode;
+};
+
+struct VREvent_MessageOverlay_t
+{
+	uint32_t unVRMessageOverlayResponse;  // vr::VRMessageOverlayResponse enum
+};
+
+struct VREvent_Property_t
+{
+	PropertyContainerHandle_t container;
+	ETrackedDeviceProperty prop;
+};
+
+/** NOTE!!! If you change this you MUST manually update openvr_interop.cs.py */
+typedef union {
+	VREvent_Reserved_t reserved;
+	VREvent_Controller_t controller;
+	VREvent_Mouse_t mouse;
+	VREvent_Scroll_t scroll;
+	VREvent_Process_t process;
+	VREvent_Notification_t notification;
+	VREvent_Overlay_t overlay;
+	VREvent_Status_t status;
+	VREvent_Keyboard_t keyboard;
+	VREvent_Ipd_t ipd;
+	VREvent_Chaperone_t chaperone;
+	VREvent_PerformanceTest_t performanceTest;
+	VREvent_TouchPadMove_t touchPadMove;
+	VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset;
+	VREvent_Screenshot_t screenshot;
+	VREvent_ScreenshotProgress_t screenshotProgress;
+	VREvent_ApplicationLaunch_t applicationLaunch;
+	VREvent_EditingCameraSurface_t cameraSurface;
+	VREvent_MessageOverlay_t messageOverlay;
+	VREvent_Property_t property;
+} VREvent_Data_t;
+
+#if defined(__linux__) || defined(__APPLE__)
+// This structure was originally defined mis-packed on Linux, preserved for
+// compatibility.
+#pragma pack(push, 4)
+#endif
+
+/** An event posted by the server to all running applications */
+struct VREvent_t
+{
+	uint32_t eventType;  // EVREventType enum
+	TrackedDeviceIndex_t trackedDeviceIndex;
+	float eventAgeSeconds;
+	// event data must be the end of the struct as its size is variable
+	VREvent_Data_t data;
+};
+
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+
+/** The mesh to draw into the stencil (or depth) buffer to perform 
+* early stencil (or depth) kills of pixels that will never appear on the HMD.
+* This mesh draws on all the pixels that will be hidden after distortion. 
+*
+* If the HMD does not provide a visible area mesh pVertexData will be
+* NULL and unTriangleCount will be 0. */
+struct HiddenAreaMesh_t
+{
+	const HmdVector2_t *pVertexData;
+	uint32_t unTriangleCount;
+};
+
+enum EHiddenAreaMeshType
+{
+	k_eHiddenAreaMesh_Standard = 0,
+	k_eHiddenAreaMesh_Inverse = 1,
+	k_eHiddenAreaMesh_LineLoop = 2,
+
+	k_eHiddenAreaMesh_Max = 3,
+};
+
+/** Identifies what kind of axis is on the controller at index n. Read this type 
+* with pVRSystem->Get( nControllerDeviceIndex, Prop_Axis0Type_Int32 + n );
+*/
+enum EVRControllerAxisType
+{
+	k_eControllerAxis_None = 0,
+	k_eControllerAxis_TrackPad = 1,
+	k_eControllerAxis_Joystick = 2,
+	k_eControllerAxis_Trigger = 3,  // Analog trigger data is in the X axis
+};
+
+/** contains information about one axis on the controller */
+struct VRControllerAxis_t
+{
+	float x;  // Ranges from -1.0 to 1.0 for joysticks and track pads. Ranges from 0.0 to 1.0 for triggers were 0 is fully released.
+	float y;  // Ranges from -1.0 to 1.0 for joysticks and track pads. Is always 0.0 for triggers.
+};
+
+/** the number of axes in the controller state */
+static const uint32_t k_unControllerStateAxisCount = 5;
+
+#if defined(__linux__) || defined(__APPLE__)
+// This structure was originally defined mis-packed on Linux, preserved for
+// compatibility.
+#pragma pack(push, 4)
+#endif
+
+/** Holds all the state of a controller at one moment in time. */
+struct VRControllerState001_t
+{
+	// If packet num matches that on your prior call, then the controller state hasn't been changed since
+	// your last call and there is no need to process it
+	uint32_t unPacketNum;
+
+	// bit flags for each of the buttons. Use ButtonMaskFromId to turn an ID into a mask
+	uint64_t ulButtonPressed;
+	uint64_t ulButtonTouched;
+
+	// Axis data for the controller's analog inputs
+	VRControllerAxis_t rAxis[k_unControllerStateAxisCount];
+};
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+
+typedef VRControllerState001_t VRControllerState_t;
+
+/** determines how to provide output to the application of various event processing functions. */
+enum EVRControllerEventOutputType
+{
+	ControllerEventOutput_OSEvents = 0,
+	ControllerEventOutput_VREvents = 1,
+};
+
+/** Collision Bounds Style */
+enum ECollisionBoundsStyle
+{
+	COLLISION_BOUNDS_STYLE_BEGINNER = 0,
+	COLLISION_BOUNDS_STYLE_INTERMEDIATE,
+	COLLISION_BOUNDS_STYLE_SQUARES,
+	COLLISION_BOUNDS_STYLE_ADVANCED,
+	COLLISION_BOUNDS_STYLE_NONE,
+
+	COLLISION_BOUNDS_STYLE_COUNT
+};
+
+/** Allows the application to customize how the overlay appears in the compositor */
+struct Compositor_OverlaySettings
+{
+	uint32_t size;  // sizeof(Compositor_OverlaySettings)
+	bool curved, antialias;
+	float scale, distance, alpha;
+	float uOffset, vOffset, uScale, vScale;
+	float gridDivs, gridWidth, gridScale;
+	HmdMatrix44_t transform;
+};
+
+/** used to refer to a single VR overlay */
+typedef uint64_t VROverlayHandle_t;
+
+static const VROverlayHandle_t k_ulOverlayHandleInvalid = 0;
+
+/** Errors that can occur around VR overlays */
+enum EVROverlayError
+{
+	VROverlayError_None = 0,
+
+	VROverlayError_UnknownOverlay = 10,
+	VROverlayError_InvalidHandle = 11,
+	VROverlayError_PermissionDenied = 12,
+	VROverlayError_OverlayLimitExceeded = 13,  // No more overlays could be created because the maximum number already exist
+	VROverlayError_WrongVisibilityType = 14,
+	VROverlayError_KeyTooLong = 15,
+	VROverlayError_NameTooLong = 16,
+	VROverlayError_KeyInUse = 17,
+	VROverlayError_WrongTransformType = 18,
+	VROverlayError_InvalidTrackedDevice = 19,
+	VROverlayError_InvalidParameter = 20,
+	VROverlayError_ThumbnailCantBeDestroyed = 21,
+	VROverlayError_ArrayTooSmall = 22,
+	VROverlayError_RequestFailed = 23,
+	VROverlayError_InvalidTexture = 24,
+	VROverlayError_UnableToLoadFile = 25,
+	VROverlayError_KeyboardAlreadyInUse = 26,
+	VROverlayError_NoNeighbor = 27,
+	VROverlayError_TooManyMaskPrimitives = 29,
+	VROverlayError_BadMaskPrimitive = 30,
+};
+
+/** enum values to pass in to VR_Init to identify whether the application will 
+* draw a 3D scene. */
+enum EVRApplicationType
+{
+	VRApplication_Other = 0,          // Some other kind of application that isn't covered by the other entries
+	VRApplication_Scene = 1,          // Application will submit 3D frames
+	VRApplication_Overlay = 2,        // Application only interacts with overlays
+	VRApplication_Background = 3,     // Application should not start SteamVR if it's not already running, and should not
+									  // keep it running if everything else quits.
+	VRApplication_Utility = 4,        // Init should not try to load any drivers. The application needs access to utility
+									  // interfaces (like IVRSettings and IVRApplications) but not hardware.
+	VRApplication_VRMonitor = 5,      // Reserved for vrmonitor
+	VRApplication_SteamWatchdog = 6,  // Reserved for Steam
+	VRApplication_Bootstrapper = 7,   // Start up SteamVR
+
+	VRApplication_Max
+};
+
+/** error codes for firmware */
+enum EVRFirmwareError
+{
+	VRFirmwareError_None = 0,
+	VRFirmwareError_Success = 1,
+	VRFirmwareError_Fail = 2,
+};
+
+/** error codes for notifications */
+enum EVRNotificationError
+{
+	VRNotificationError_OK = 0,
+	VRNotificationError_InvalidNotificationId = 100,
+	VRNotificationError_NotificationQueueFull = 101,
+	VRNotificationError_InvalidOverlayHandle = 102,
+	VRNotificationError_SystemWithUserValueAlreadyExists = 103,
+};
+
+/** error codes returned by Vr_Init */
+
+// Please add adequate error description to https://developer.valvesoftware.com/w/index.php?title=Category:SteamVRHelp
+enum EVRInitError
+{
+	VRInitError_None = 0,
+	VRInitError_Unknown = 1,
+
+	VRInitError_Init_InstallationNotFound = 100,
+	VRInitError_Init_InstallationCorrupt = 101,
+	VRInitError_Init_VRClientDLLNotFound = 102,
+	VRInitError_Init_FileNotFound = 103,
+	VRInitError_Init_FactoryNotFound = 104,
+	VRInitError_Init_InterfaceNotFound = 105,
+	VRInitError_Init_InvalidInterface = 106,
+	VRInitError_Init_UserConfigDirectoryInvalid = 107,
+	VRInitError_Init_HmdNotFound = 108,
+	VRInitError_Init_NotInitialized = 109,
+	VRInitError_Init_PathRegistryNotFound = 110,
+	VRInitError_Init_NoConfigPath = 111,
+	VRInitError_Init_NoLogPath = 112,
+	VRInitError_Init_PathRegistryNotWritable = 113,
+	VRInitError_Init_AppInfoInitFailed = 114,
+	VRInitError_Init_Retry = 115,               // Used internally to cause retries to vrserver
+	VRInitError_Init_InitCanceledByUser = 116,  // The calling application should silently exit. The user canceled app startup
+	VRInitError_Init_AnotherAppLaunching = 117,
+	VRInitError_Init_SettingsInitFailed = 118,
+	VRInitError_Init_ShuttingDown = 119,
+	VRInitError_Init_TooManyObjects = 120,
+	VRInitError_Init_NoServerForBackgroundApp = 121,
+	VRInitError_Init_NotSupportedWithCompositor = 122,
+	VRInitError_Init_NotAvailableToUtilityApps = 123,
+	VRInitError_Init_Internal = 124,
+	VRInitError_Init_HmdDriverIdIsNone = 125,
+	VRInitError_Init_HmdNotFoundPresenceFailed = 126,
+	VRInitError_Init_VRMonitorNotFound = 127,
+	VRInitError_Init_VRMonitorStartupFailed = 128,
+	VRInitError_Init_LowPowerWatchdogNotSupported = 129,
+	VRInitError_Init_InvalidApplicationType = 130,
+	VRInitError_Init_NotAvailableToWatchdogApps = 131,
+	VRInitError_Init_WatchdogDisabledInSettings = 132,
+	VRInitError_Init_VRDashboardNotFound = 133,
+	VRInitError_Init_VRDashboardStartupFailed = 134,
+	VRInitError_Init_VRHomeNotFound = 135,
+	VRInitError_Init_VRHomeStartupFailed = 136,
+	VRInitError_Init_RebootingBusy = 137,
+	VRInitError_Init_FirmwareUpdateBusy = 138,
+	VRInitError_Init_FirmwareRecoveryBusy = 139,
+
+	VRInitError_Driver_Failed = 200,
+	VRInitError_Driver_Unknown = 201,
+	VRInitError_Driver_HmdUnknown = 202,
+	VRInitError_Driver_NotLoaded = 203,
+	VRInitError_Driver_RuntimeOutOfDate = 204,
+	VRInitError_Driver_HmdInUse = 205,
+	VRInitError_Driver_NotCalibrated = 206,
+	VRInitError_Driver_CalibrationInvalid = 207,
+	VRInitError_Driver_HmdDisplayNotFound = 208,
+	VRInitError_Driver_TrackedDeviceInterfaceUnknown = 209,
+	// VRInitError_Driver_HmdDisplayNotFoundAfterFix = 210, // not needed: here for historic reasons
+	VRInitError_Driver_HmdDriverIdOutOfBounds = 211,
+	VRInitError_Driver_HmdDisplayMirrored = 212,
+
+	VRInitError_IPC_ServerInitFailed = 300,
+	VRInitError_IPC_ConnectFailed = 301,
+	VRInitError_IPC_SharedStateInitFailed = 302,
+	VRInitError_IPC_CompositorInitFailed = 303,
+	VRInitError_IPC_MutexInitFailed = 304,
+	VRInitError_IPC_Failed = 305,
+	VRInitError_IPC_CompositorConnectFailed = 306,
+	VRInitError_IPC_CompositorInvalidConnectResponse = 307,
+	VRInitError_IPC_ConnectFailedAfterMultipleAttempts = 308,
+
+	VRInitError_Compositor_Failed = 400,
+	VRInitError_Compositor_D3D11HardwareRequired = 401,
+	VRInitError_Compositor_FirmwareRequiresUpdate = 402,
+	VRInitError_Compositor_OverlayInitFailed = 403,
+	VRInitError_Compositor_ScreenshotsInitFailed = 404,
+	VRInitError_Compositor_UnableToCreateDevice = 405,
+
+	VRInitError_VendorSpecific_UnableToConnectToOculusRuntime = 1000,
+
+	VRInitError_VendorSpecific_HmdFound_CantOpenDevice = 1101,
+	VRInitError_VendorSpecific_HmdFound_UnableToRequestConfigStart = 1102,
+	VRInitError_VendorSpecific_HmdFound_NoStoredConfig = 1103,
+	VRInitError_VendorSpecific_HmdFound_ConfigTooBig = 1104,
+	VRInitError_VendorSpecific_HmdFound_ConfigTooSmall = 1105,
+	VRInitError_VendorSpecific_HmdFound_UnableToInitZLib = 1106,
+	VRInitError_VendorSpecific_HmdFound_CantReadFirmwareVersion = 1107,
+	VRInitError_VendorSpecific_HmdFound_UnableToSendUserDataStart = 1108,
+	VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataStart = 1109,
+	VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataNext = 1110,
+	VRInitError_VendorSpecific_HmdFound_UserDataAddressRange = 1111,
+	VRInitError_VendorSpecific_HmdFound_UserDataError = 1112,
+	VRInitError_VendorSpecific_HmdFound_ConfigFailedSanityCheck = 1113,
+
+	VRInitError_Steam_SteamInstallationNotFound = 2000,
+};
+
+enum EVRScreenshotType
+{
+	VRScreenshotType_None = 0,
+	VRScreenshotType_Mono = 1,  // left eye only
+	VRScreenshotType_Stereo = 2,
+	VRScreenshotType_Cubemap = 3,
+	VRScreenshotType_MonoPanorama = 4,
+	VRScreenshotType_StereoPanorama = 5
+};
+
+enum EVRScreenshotPropertyFilenames
+{
+	VRScreenshotPropertyFilenames_Preview = 0,
+	VRScreenshotPropertyFilenames_VR = 1,
+};
+
+enum EVRTrackedCameraError
+{
+	VRTrackedCameraError_None = 0,
+	VRTrackedCameraError_OperationFailed = 100,
+	VRTrackedCameraError_InvalidHandle = 101,
+	VRTrackedCameraError_InvalidFrameHeaderVersion = 102,
+	VRTrackedCameraError_OutOfHandles = 103,
+	VRTrackedCameraError_IPCFailure = 104,
+	VRTrackedCameraError_NotSupportedForThisDevice = 105,
+	VRTrackedCameraError_SharedMemoryFailure = 106,
+	VRTrackedCameraError_FrameBufferingFailure = 107,
+	VRTrackedCameraError_StreamSetupFailure = 108,
+	VRTrackedCameraError_InvalidGLTextureId = 109,
+	VRTrackedCameraError_InvalidSharedTextureHandle = 110,
+	VRTrackedCameraError_FailedToGetGLTextureId = 111,
+	VRTrackedCameraError_SharedTextureFailure = 112,
+	VRTrackedCameraError_NoFrameAvailable = 113,
+	VRTrackedCameraError_InvalidArgument = 114,
+	VRTrackedCameraError_InvalidFrameBufferSize = 115,
+};
+
+enum EVRTrackedCameraFrameType
+{
+	VRTrackedCameraFrameType_Distorted = 0,       // This is the camera video frame size in pixels, still distorted.
+	VRTrackedCameraFrameType_Undistorted,         // In pixels, an undistorted inscribed rectangle region without invalid regions. This size is subject to changes shortly.
+	VRTrackedCameraFrameType_MaximumUndistorted,  // In pixels, maximum undistorted with invalid regions. Non zero alpha component identifies valid regions.
+	MAX_CAMERA_FRAME_TYPES
+};
+
+typedef uint64_t TrackedCameraHandle_t;
+#define INVALID_TRACKED_CAMERA_HANDLE ((vr::TrackedCameraHandle_t)0)
+
+struct CameraVideoStreamFrameHeader_t
+{
+	EVRTrackedCameraFrameType eFrameType;
+
+	uint32_t nWidth;
+	uint32_t nHeight;
+	uint32_t nBytesPerPixel;
+
+	uint32_t nFrameSequence;
+
+	TrackedDevicePose_t standingTrackedDevicePose;
+};
+
+// Screenshot types
+typedef uint32_t ScreenshotHandle_t;
+
+static const uint32_t k_unScreenshotHandleInvalid = 0;
+
+#pragma pack(pop)
+
+// figure out how to import from the VR API dll
+#if defined(_WIN32)
+
+#ifdef VR_API_EXPORT
+#define VR_INTERFACE extern "C" __declspec(dllexport)
+#else
+#define VR_INTERFACE extern "C" __declspec(dllimport)
+#endif
+
+#elif defined(__GNUC__) || defined(COMPILER_GCC) || defined(__APPLE__)
+
+#ifdef VR_API_EXPORT
+#define VR_INTERFACE extern "C" __attribute__((visibility("default")))
+#else
+#define VR_INTERFACE extern "C"
+#endif
+
+#else
+#error "Unsupported Platform."
+#endif
+
+#if defined(_WIN32)
+#define VR_CALLTYPE __cdecl
+#else
+#define VR_CALLTYPE
+#endif
+
+}  // namespace vr
+
+#endif  // _INCLUDE_VRTYPES_H
+
+// vrannotation.h
+#ifdef API_GEN
+#define VR_CLANG_ATTR(ATTR) __attribute__((annotate(ATTR)))
+#else
+#define VR_CLANG_ATTR(ATTR)
+#endif
+
+#define VR_METHOD_DESC(DESC) VR_CLANG_ATTR("desc:" #DESC ";")
+#define VR_IGNOREATTR() VR_CLANG_ATTR("ignore")
+#define VR_OUT_STRUCT() VR_CLANG_ATTR("out_struct: ;")
+#define VR_OUT_STRING() VR_CLANG_ATTR("out_string: ;")
+#define VR_OUT_ARRAY_CALL(COUNTER, FUNCTION, PARAMS) VR_CLANG_ATTR("out_array_call:" #COUNTER "," #FUNCTION "," #PARAMS ";")
+#define VR_OUT_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR("out_array_count:" #COUNTER ";")
+#define VR_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR("array_count:" #COUNTER ";")
+#define VR_ARRAY_COUNT_D(COUNTER, DESC) VR_CLANG_ATTR("array_count:" #COUNTER ";desc:" #DESC)
+#define VR_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR("buffer_count:" #COUNTER ";")
+#define VR_OUT_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR("out_buffer_count:" #COUNTER ";")
+#define VR_OUT_STRING_COUNT(COUNTER) VR_CLANG_ATTR("out_string_count:" #COUNTER ";")
+
+// ivrsystem.h
+namespace vr
+{
+class IVRSystem
+{
+public:
+	// ------------------------------------
+	// Display Methods
+	// ------------------------------------
+
+	/** Suggested size for the intermediate render target that the distortion pulls from. */
+	virtual void GetRecommendedRenderTargetSize(uint32_t *pnWidth, uint32_t *pnHeight) = 0;
+
+	/** The projection matrix for the specified eye */
+	virtual HmdMatrix44_t GetProjectionMatrix(EVREye eEye, float fNearZ, float fFarZ) = 0;
+
+	/** The components necessary to build your own projection matrix in case your
+	* application is doing something fancy like infinite Z */
+	virtual void GetProjectionRaw(EVREye eEye, float *pfLeft, float *pfRight, float *pfTop, float *pfBottom) = 0;
+
+	/** Gets the result of the distortion function for the specified eye and input UVs. UVs go from 0,0 in 
+	* the upper left of that eye's viewport and 1,1 in the lower right of that eye's viewport.
+	* Returns true for success. Otherwise, returns false, and distortion coordinates are not suitable. */
+	virtual bool ComputeDistortion(EVREye eEye, float fU, float fV, DistortionCoordinates_t *pDistortionCoordinates) = 0;
+
+	/** Returns the transform from eye space to the head space. Eye space is the per-eye flavor of head
+	* space that provides stereo disparity. Instead of Model * View * Projection the sequence is Model * View * Eye^-1 * Projection. 
+	* Normally View and Eye^-1 will be multiplied together and treated as View in your application. 
+	*/
+	virtual HmdMatrix34_t GetEyeToHeadTransform(EVREye eEye) = 0;
+
+	/** Returns the number of elapsed seconds since the last recorded vsync event. This 
+	*	will come from a vsync timer event in the timer if possible or from the application-reported
+	*   time if that is not available. If no vsync times are available the function will 
+	*   return zero for vsync time and frame counter and return false from the method. */
+	virtual bool GetTimeSinceLastVsync(float *pfSecondsSinceLastVsync, uint64_t *pulFrameCounter) = 0;
+
+	/** [D3D9 Only]
+	* Returns the adapter index that the user should pass into CreateDevice to set up D3D9 in such
+	* a way that it can go full screen exclusive on the HMD. Returns -1 if there was an error.
+	*/
+	virtual int32_t GetD3D9AdapterIndex() = 0;
+
+	/** [D3D10/11 Only]
+	* Returns the adapter index that the user should pass into EnumAdapters to create the device 
+	* and swap chain in DX10 and DX11. If an error occurs the index will be set to -1.
+	*/
+	virtual void GetDXGIOutputInfo(int32_t *pnAdapterIndex) = 0;
+
+	/**
+	 * Returns platform- and texture-type specific adapter identification so that applications and the
+	 * compositor are creating textures and swap chains on the same GPU. If an error occurs the device
+	 * will be set to 0.
+	 * pInstance is an optional parameter that is required only when textureType is TextureType_Vulkan.
+	 * [D3D10/11/12 Only (D3D9 Not Supported)]
+	 *  Returns the adapter LUID that identifies the GPU attached to the HMD. The user should
+	 *  enumerate all adapters using IDXGIFactory::EnumAdapters and IDXGIAdapter::GetDesc to find
+	 *  the adapter with the matching LUID, or use IDXGIFactory4::EnumAdapterByLuid.
+	 *  The discovered IDXGIAdapter should be used to create the device and swap chain.
+	 * [Vulkan Only]
+	 *  Returns the VkPhysicalDevice that should be used by the application.
+	 *  pInstance must be the instance the application will use to query for the VkPhysicalDevice.  The application
+	 *  must create the VkInstance with extensions returned by IVRCompositor::GetVulkanInstanceExtensionsRequired enabled.
+	 * [macOS Only]
+	 *  Returns an id<MTLDevice> that should be used by the application.
+	 */
+	virtual void GetOutputDevice(uint64_t *pnDevice, ETextureType textureType, VkInstance_T *pInstance = nullptr) = 0;
+
+	// ------------------------------------
+	// Display Mode methods
+	// ------------------------------------
+
+	/** Use to determine if the headset display is part of the desktop (i.e. extended) or hidden (i.e. direct mode). */
+	virtual bool IsDisplayOnDesktop() = 0;
+
+	/** Set the display visibility (true = extended, false = direct mode).  Return value of true indicates that the change was successful. */
+	virtual bool SetDisplayVisibility(bool bIsVisibleOnDesktop) = 0;
+
+	// ------------------------------------
+	// Tracking Methods
+	// ------------------------------------
+
+	/** The pose that the tracker thinks that the HMD will be in at the specified number of seconds into the 
+	* future. Pass 0 to get the state at the instant the method is called. Most of the time the application should
+	* calculate the time until the photons will be emitted from the display and pass that time into the method.
+	*
+	* This is roughly analogous to the inverse of the view matrix in most applications, though 
+	* many games will need to do some additional rotation or translation on top of the rotation
+	* and translation provided by the head pose.
+	*
+	* For devices where bPoseIsValid is true the application can use the pose to position the device
+	* in question. The provided array can be any size up to k_unMaxTrackedDeviceCount. 
+	*
+	* Seated experiences should call this method with TrackingUniverseSeated and receive poses relative
+	* to the seated zero pose. Standing experiences should call this method with TrackingUniverseStanding 
+	* and receive poses relative to the Chaperone Play Area. TrackingUniverseRawAndUncalibrated should 
+	* probably not be used unless the application is the Chaperone calibration tool itself, but will provide
+	* poses relative to the hardware-specific coordinate system in the driver.
+	*/
+	virtual void GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, VR_ARRAY_COUNT(unTrackedDevicePoseArrayCount) TrackedDevicePose_t *pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = 0;
+
+	/** Sets the zero pose for the seated tracker coordinate system to the current position and yaw of the HMD. After 
+	* ResetSeatedZeroPose all GetDeviceToAbsoluteTrackingPose calls that pass TrackingUniverseSeated as the origin 
+	* will be relative to this new zero pose. The new zero coordinate system will not change the fact that the Y axis 
+	* is up in the real world, so the next pose returned from GetDeviceToAbsoluteTrackingPose after a call to 
+	* ResetSeatedZeroPose may not be exactly an identity matrix.
+	*
+	* NOTE: This function overrides the user's previously saved seated zero pose and should only be called as the result of a user action. 
+	* Users are also able to set their seated zero pose via the OpenVR Dashboard.
+	**/
+	virtual void ResetSeatedZeroPose() = 0;
+
+	/** Returns the transform from the seated zero pose to the standing absolute tracking system. This allows 
+	* applications to represent the seated origin to used or transform object positions from one coordinate
+	* system to the other. 
+	*
+	* The seated origin may or may not be inside the Play Area or Collision Bounds returned by IVRChaperone. Its position 
+	* depends on what the user has set from the Dashboard settings and previous calls to ResetSeatedZeroPose. */
+	virtual HmdMatrix34_t GetSeatedZeroPoseToStandingAbsoluteTrackingPose() = 0;
+
+	/** Returns the transform from the tracking origin to the standing absolute tracking system. This allows
+	* applications to convert from raw tracking space to the calibrated standing coordinate system. */
+	virtual HmdMatrix34_t GetRawZeroPoseToStandingAbsoluteTrackingPose() = 0;
+
+	/** Get a sorted array of device indices of a given class of tracked devices (e.g. controllers).  Devices are sorted right to left
+	* relative to the specified tracked device (default: hmd -- pass in -1 for absolute tracking space).  Returns the number of devices
+	* in the list, or the size of the array needed if not large enough. */
+	virtual uint32_t GetSortedTrackedDeviceIndicesOfClass(ETrackedDeviceClass eTrackedDeviceClass, VR_ARRAY_COUNT(unTrackedDeviceIndexArrayCount) vr::TrackedDeviceIndex_t *punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, vr::TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex = k_unTrackedDeviceIndex_Hmd) = 0;
+
+	/** Returns the level of activity on the device. */
+	virtual EDeviceActivityLevel GetTrackedDeviceActivityLevel(vr::TrackedDeviceIndex_t unDeviceId) = 0;
+
+	/** Convenience utility to apply the specified transform to the specified pose.
+	*   This properly transforms all pose components, including velocity and angular velocity
+	*/
+	virtual void ApplyTransform(TrackedDevicePose_t *pOutputPose, const TrackedDevicePose_t *pTrackedDevicePose, const HmdMatrix34_t *pTransform) = 0;
+
+	/** Returns the device index associated with a specific role, for example the left hand or the right hand. */
+	virtual vr::TrackedDeviceIndex_t GetTrackedDeviceIndexForControllerRole(vr::ETrackedControllerRole unDeviceType) = 0;
+
+	/** Returns the controller type associated with a device index. */
+	virtual vr::ETrackedControllerRole GetControllerRoleForTrackedDeviceIndex(vr::TrackedDeviceIndex_t unDeviceIndex) = 0;
+
+	// ------------------------------------
+	// Property methods
+	// ------------------------------------
+
+	/** Returns the device class of a tracked device. If there has not been a device connected in this slot
+	* since the application started this function will return TrackedDevice_Invalid. For previous detected
+	* devices the function will return the previously observed device class. 
+	*
+	* To determine which devices exist on the system, just loop from 0 to k_unMaxTrackedDeviceCount and check
+	* the device class. Every device with something other than TrackedDevice_Invalid is associated with an 
+	* actual tracked device. */
+	virtual ETrackedDeviceClass GetTrackedDeviceClass(vr::TrackedDeviceIndex_t unDeviceIndex) = 0;
+
+	/** Returns true if there is a device connected in this slot. */
+	virtual bool IsTrackedDeviceConnected(vr::TrackedDeviceIndex_t unDeviceIndex) = 0;
+
+	/** Returns a bool property. If the device index is not valid or the property is not a bool type this function will return false. */
+	virtual bool GetBoolTrackedDeviceProperty(vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L) = 0;
+
+	/** Returns a float property. If the device index is not valid or the property is not a float type this function will return 0. */
+	virtual float GetFloatTrackedDeviceProperty(vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L) = 0;
+
+	/** Returns an int property. If the device index is not valid or the property is not a int type this function will return 0. */
+	virtual int32_t GetInt32TrackedDeviceProperty(vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L) = 0;
+
+	/** Returns a uint64 property. If the device index is not valid or the property is not a uint64 type this function will return 0. */
+	virtual uint64_t GetUint64TrackedDeviceProperty(vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L) = 0;
+
+	/** Returns a matrix property. If the device index is not valid or the property is not a matrix type, this function will return identity. */
+	virtual HmdMatrix34_t GetMatrix34TrackedDeviceProperty(vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L) = 0;
+
+	/** Returns a string property. If the device index is not valid or the property is not a string type this function will 
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters. */
+	virtual uint32_t GetStringTrackedDeviceProperty(vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError = 0L) = 0;
+
+	/** returns a string that corresponds with the specified property error. The string will be the name 
+	* of the error enum value for all valid error codes */
+	virtual const char *GetPropErrorNameFromEnum(ETrackedPropertyError error) = 0;
+
+	// ------------------------------------
+	// Event methods
+	// ------------------------------------
+
+	/** Returns true and fills the event with the next event on the queue if there is one. If there are no events
+	* this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct */
+	virtual bool PollNextEvent(VREvent_t *pEvent, uint32_t uncbVREvent) = 0;
+
+	/** Returns true and fills the event with the next event on the queue if there is one. If there are no events
+	* this method returns false. Fills in the pose of the associated tracked device in the provided pose struct. 
+	* This pose will always be older than the call to this function and should not be used to render the device. 
+	uncbVREvent should be the size in bytes of the VREvent_t struct */
+	virtual bool PollNextEventWithPose(ETrackingUniverseOrigin eOrigin, VREvent_t *pEvent, uint32_t uncbVREvent, vr::TrackedDevicePose_t *pTrackedDevicePose) = 0;
+
+	/** returns the name of an EVREvent enum value */
+	virtual const char *GetEventTypeNameFromEnum(EVREventType eType) = 0;
+
+	// ------------------------------------
+	// Rendering helper methods
+	// ------------------------------------
+
+	/** Returns the hidden area mesh for the current HMD. The pixels covered by this mesh will never be seen by the user after the lens distortion is
+	* applied based on visibility to the panels. If this HMD does not have a hidden area mesh, the vertex data and count will be NULL and 0 respectively.
+	* This mesh is meant to be rendered into the stencil buffer (or into the depth buffer setting nearz) before rendering each eye's view. 
+	* This will improve performance by letting the GPU early-reject pixels the user will never see before running the pixel shader.
+	* NOTE: Render this mesh with backface culling disabled since the winding order of the vertices can be different per-HMD or per-eye.
+	* Setting the bInverse argument to true will produce the visible area mesh that is commonly used in place of full-screen quads. The visible area mesh covers all of the pixels the hidden area mesh does not cover.
+	* Setting the bLineLoop argument will return a line loop of vertices in HiddenAreaMesh_t->pVertexData with HiddenAreaMesh_t->unTriangleCount set to the number of vertices.
+	*/
+	virtual HiddenAreaMesh_t GetHiddenAreaMesh(EVREye eEye, EHiddenAreaMeshType type = k_eHiddenAreaMesh_Standard) = 0;
+
+	// ------------------------------------
+	// Controller methods
+	// ------------------------------------
+
+	/** Fills the supplied struct with the current state of the controller. Returns false if the controller index
+	* is invalid. */
+	virtual bool GetControllerState(vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize) = 0;
+
+	/** fills the supplied struct with the current state of the controller and the provided pose with the pose of 
+	* the controller when the controller state was updated most recently. Use this form if you need a precise controller
+	* pose as input to your application when the user presses or releases a button. */
+	virtual bool GetControllerStateWithPose(ETrackingUniverseOrigin eOrigin, vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose) = 0;
+
+	/** Trigger a single haptic pulse on a controller. After this call the application may not trigger another haptic pulse on this controller
+	* and axis combination for 5ms. */
+	virtual void TriggerHapticPulse(vr::TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = 0;
+
+	/** returns the name of an EVRButtonId enum value */
+	virtual const char *GetButtonIdNameFromEnum(EVRButtonId eButtonId) = 0;
+
+	/** returns the name of an EVRControllerAxisType enum value */
+	virtual const char *GetControllerAxisTypeNameFromEnum(EVRControllerAxisType eAxisType) = 0;
+
+	/** Tells OpenVR that this process wants exclusive access to controller button states and button events. Other apps will be notified that 
+	* they have lost input focus with a VREvent_InputFocusCaptured event. Returns false if input focus could not be captured for
+	* some reason. */
+	virtual bool CaptureInputFocus() = 0;
+
+	/** Tells OpenVR that this process no longer wants exclusive access to button states and button events. Other apps will be notified 
+	* that input focus has been released with a VREvent_InputFocusReleased event. */
+	virtual void ReleaseInputFocus() = 0;
+
+	/** Returns true if input focus is captured by another process. */
+	virtual bool IsInputFocusCapturedByAnotherProcess() = 0;
+
+	// ------------------------------------
+	// Debug Methods
+	// ------------------------------------
+
+	/** Sends a request to the driver for the specified device and returns the response. The maximum response size is 32k,
+	* but this method can be called with a smaller buffer. If the response exceeds the size of the buffer, it is truncated. 
+	* The size of the response including its terminating null is returned. */
+	virtual uint32_t DriverDebugRequest(vr::TrackedDeviceIndex_t unDeviceIndex, const char *pchRequest, char *pchResponseBuffer, uint32_t unResponseBufferSize) = 0;
+
+	// ------------------------------------
+	// Firmware methods
+	// ------------------------------------
+
+	/** Performs the actual firmware update if applicable. 
+	 * The following events will be sent, if VRFirmwareError_None was returned: VREvent_FirmwareUpdateStarted, VREvent_FirmwareUpdateFinished 
+	 * Use the properties Prop_Firmware_UpdateAvailable_Bool, Prop_Firmware_ManualUpdate_Bool, and Prop_Firmware_ManualUpdateURL_String
+	 * to figure our whether a firmware update is available, and to figure out whether its a manual update 
+	 * Prop_Firmware_ManualUpdateURL_String should point to an URL describing the manual update process */
+	virtual vr::EVRFirmwareError PerformFirmwareUpdate(vr::TrackedDeviceIndex_t unDeviceIndex) = 0;
+
+	// ------------------------------------
+	// Application life cycle methods
+	// ------------------------------------
+
+	/** Call this to acknowledge to the system that VREvent_Quit has been received and that the process is exiting.
+	* This extends the timeout until the process is killed. */
+	virtual void AcknowledgeQuit_Exiting() = 0;
+
+	/** Call this to tell the system that the user is being prompted to save data. This
+	* halts the timeout and dismisses the dashboard (if it was up). Applications should be sure to actually 
+	* prompt the user to save and then exit afterward, otherwise the user will be left in a confusing state. */
+	virtual void AcknowledgeQuit_UserPrompt() = 0;
+};
+
+static const char *const IVRSystem_Version = "IVRSystem_017";
+
+}  // namespace vr
+
+// ivrapplications.h
+namespace vr
+{
+/** Used for all errors reported by the IVRApplications interface */
+enum EVRApplicationError
+{
+	VRApplicationError_None = 0,
+
+	VRApplicationError_AppKeyAlreadyExists = 100,  // Only one application can use any given key
+	VRApplicationError_NoManifest = 101,           // the running application does not have a manifest
+	VRApplicationError_NoApplication = 102,        // No application is running
+	VRApplicationError_InvalidIndex = 103,
+	VRApplicationError_UnknownApplication = 104,  // the application could not be found
+	VRApplicationError_IPCFailed = 105,           // An IPC failure caused the request to fail
+	VRApplicationError_ApplicationAlreadyRunning = 106,
+	VRApplicationError_InvalidManifest = 107,
+	VRApplicationError_InvalidApplication = 108,
+	VRApplicationError_LaunchFailed = 109,                // the process didn't start
+	VRApplicationError_ApplicationAlreadyStarting = 110,  // the system was already starting the same application
+	VRApplicationError_LaunchInProgress = 111,            // The system was already starting a different application
+	VRApplicationError_OldApplicationQuitting = 112,
+	VRApplicationError_TransitionAborted = 113,
+	VRApplicationError_IsTemplate = 114,  // error when you try to call LaunchApplication() on a template type app (use LaunchTemplateApplication)
+	VRApplicationError_SteamVRIsExiting = 115,
+
+	VRApplicationError_BufferTooSmall = 200,  // The provided buffer was too small to fit the requested data
+	VRApplicationError_PropertyNotSet = 201,  // The requested property was not set
+	VRApplicationError_UnknownProperty = 202,
+	VRApplicationError_InvalidParameter = 203,
+};
+
+/** The maximum length of an application key */
+static const uint32_t k_unMaxApplicationKeyLength = 128;
+
+/** these are the properties available on applications. */
+enum EVRApplicationProperty
+{
+	VRApplicationProperty_Name_String = 0,
+
+	VRApplicationProperty_LaunchType_String = 11,
+	VRApplicationProperty_WorkingDirectory_String = 12,
+	VRApplicationProperty_BinaryPath_String = 13,
+	VRApplicationProperty_Arguments_String = 14,
+	VRApplicationProperty_URL_String = 15,
+
+	VRApplicationProperty_Description_String = 50,
+	VRApplicationProperty_NewsURL_String = 51,
+	VRApplicationProperty_ImagePath_String = 52,
+	VRApplicationProperty_Source_String = 53,
+
+	VRApplicationProperty_IsDashboardOverlay_Bool = 60,
+	VRApplicationProperty_IsTemplate_Bool = 61,
+	VRApplicationProperty_IsInstanced_Bool = 62,
+	VRApplicationProperty_IsInternal_Bool = 63,
+	VRApplicationProperty_WantsCompositorPauseInStandby_Bool = 64,
+
+	VRApplicationProperty_LastLaunchTime_Uint64 = 70,
+};
+
+/** These are states the scene application startup process will go through. */
+enum EVRApplicationTransitionState
+{
+	VRApplicationTransition_None = 0,
+
+	VRApplicationTransition_OldAppQuitSent = 10,
+	VRApplicationTransition_WaitingForExternalLaunch = 11,
+
+	VRApplicationTransition_NewAppLaunched = 20,
+};
+
+struct AppOverrideKeys_t
+{
+	const char *pchKey;
+	const char *pchValue;
+};
+
+/** Currently recognized mime types */
+static const char *const k_pch_MimeType_HomeApp = "vr/home";
+static const char *const k_pch_MimeType_GameTheater = "vr/game_theater";
+
+class IVRApplications
+{
+public:
+	// ---------------  Application management  --------------- //
+
+	/** Adds an application manifest to the list to load when building the list of installed applications. 
+		* Temporary manifests are not automatically loaded */
+	virtual EVRApplicationError AddApplicationManifest(const char *pchApplicationManifestFullPath, bool bTemporary = false) = 0;
+
+	/** Removes an application manifest from the list to load when building the list of installed applications. */
+	virtual EVRApplicationError RemoveApplicationManifest(const char *pchApplicationManifestFullPath) = 0;
+
+	/** Returns true if an application is installed */
+	virtual bool IsApplicationInstalled(const char *pchAppKey) = 0;
+
+	/** Returns the number of applications available in the list */
+	virtual uint32_t GetApplicationCount() = 0;
+
+	/** Returns the key of the specified application. The index is at least 0 and is less than the return 
+		* value of GetApplicationCount(). The buffer should be at least k_unMaxApplicationKeyLength in order to 
+		* fit the key. */
+	virtual EVRApplicationError GetApplicationKeyByIndex(uint32_t unApplicationIndex, VR_OUT_STRING() char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = 0;
+
+	/** Returns the key of the application for the specified Process Id. The buffer should be at least 
+		* k_unMaxApplicationKeyLength in order to fit the key. */
+	virtual EVRApplicationError GetApplicationKeyByProcessId(uint32_t unProcessId, char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = 0;
+
+	/** Launches the application. The existing scene application will exit and then the new application will start.
+		* This call is not valid for dashboard overlay applications. */
+	virtual EVRApplicationError LaunchApplication(const char *pchAppKey) = 0;
+
+	/** Launches an instance of an application of type template, with its app key being pchNewAppKey (which must be unique) and optionally override sections
+		* from the manifest file via AppOverrideKeys_t
+		*/
+	virtual EVRApplicationError LaunchTemplateApplication(const char *pchTemplateAppKey, const char *pchNewAppKey, VR_ARRAY_COUNT(unKeys) const AppOverrideKeys_t *pKeys, uint32_t unKeys) = 0;
+
+	/** launches the application currently associated with this mime type and passes it the option args, typically the filename or object name of the item being launched */
+	virtual vr::EVRApplicationError LaunchApplicationFromMimeType(const char *pchMimeType, const char *pchArgs) = 0;
+
+	/** Launches the dashboard overlay application if it is not already running. This call is only valid for 
+		* dashboard overlay applications. */
+	virtual EVRApplicationError LaunchDashboardOverlay(const char *pchAppKey) = 0;
+
+	/** Cancel a pending launch for an application */
+	virtual bool CancelApplicationLaunch(const char *pchAppKey) = 0;
+
+	/** Identifies a running application. OpenVR can't always tell which process started in response
+		* to a URL. This function allows a URL handler (or the process itself) to identify the app key 
+		* for the now running application. Passing a process ID of 0 identifies the calling process. 
+		* The application must be one that's known to the system via a call to AddApplicationManifest. */
+	virtual EVRApplicationError IdentifyApplication(uint32_t unProcessId, const char *pchAppKey) = 0;
+
+	/** Returns the process ID for an application. Return 0 if the application was not found or is not running. */
+	virtual uint32_t GetApplicationProcessId(const char *pchAppKey) = 0;
+
+	/** Returns a string for an applications error */
+	virtual const char *GetApplicationsErrorNameFromEnum(EVRApplicationError error) = 0;
+
+	// ---------------  Application properties  --------------- //
+
+	/** Returns a value for an application property. The required buffer size to fit this value will be returned. */
+	virtual uint32_t GetApplicationPropertyString(const char *pchAppKey, EVRApplicationProperty eProperty, VR_OUT_STRING() char *pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError *peError = nullptr) = 0;
+
+	/** Returns a bool value for an application property. Returns false in all error cases. */
+	virtual bool GetApplicationPropertyBool(const char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError = nullptr) = 0;
+
+	/** Returns a uint64 value for an application property. Returns 0 in all error cases. */
+	virtual uint64_t GetApplicationPropertyUint64(const char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError = nullptr) = 0;
+
+	/** Sets the application auto-launch flag. This is only valid for applications which return true for VRApplicationProperty_IsDashboardOverlay_Bool. */
+	virtual EVRApplicationError SetApplicationAutoLaunch(const char *pchAppKey, bool bAutoLaunch) = 0;
+
+	/** Gets the application auto-launch flag. This is only valid for applications which return true for VRApplicationProperty_IsDashboardOverlay_Bool. */
+	virtual bool GetApplicationAutoLaunch(const char *pchAppKey) = 0;
+
+	/** Adds this mime-type to the list of supported mime types for this application*/
+	virtual EVRApplicationError SetDefaultApplicationForMimeType(const char *pchAppKey, const char *pchMimeType) = 0;
+
+	/** return the app key that will open this mime type */
+	virtual bool GetDefaultApplicationForMimeType(const char *pchMimeType, char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = 0;
+
+	/** Get the list of supported mime types for this application, comma-delimited */
+	virtual bool GetApplicationSupportedMimeTypes(const char *pchAppKey, char *pchMimeTypesBuffer, uint32_t unMimeTypesBuffer) = 0;
+
+	/** Get the list of app-keys that support this mime type, comma-delimited, the return value is number of bytes you need to return the full string */
+	virtual uint32_t GetApplicationsThatSupportMimeType(const char *pchMimeType, char *pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer) = 0;
+
+	/** Get the args list from an app launch that had the process already running, you call this when you get a VREvent_ApplicationMimeTypeLoad */
+	virtual uint32_t GetApplicationLaunchArguments(uint32_t unHandle, char *pchArgs, uint32_t unArgs) = 0;
+
+	// ---------------  Transition methods --------------- //
+
+	/** Returns the app key for the application that is starting up */
+	virtual EVRApplicationError GetStartingApplication(char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = 0;
+
+	/** Returns the application transition state */
+	virtual EVRApplicationTransitionState GetTransitionState() = 0;
+
+	/** Returns errors that would prevent the specified application from launching immediately. Calling this function will
+		* cause the current scene application to quit, so only call it when you are actually about to launch something else.
+		* What the caller should do about these failures depends on the failure:
+		*   VRApplicationError_OldApplicationQuitting - An existing application has been told to quit. Wait for a VREvent_ProcessQuit
+		*                                               and try again.
+		*   VRApplicationError_ApplicationAlreadyStarting - This application is already starting. This is a permanent failure.
+		*   VRApplicationError_LaunchInProgress	      - A different application is already starting. This is a permanent failure.
+		*   VRApplicationError_None                   - Go ahead and launch. Everything is clear.
+		*/
+	virtual EVRApplicationError PerformApplicationPrelaunchCheck(const char *pchAppKey) = 0;
+
+	/** Returns a string for an application transition state */
+	virtual const char *GetApplicationsTransitionStateNameFromEnum(EVRApplicationTransitionState state) = 0;
+
+	/** Returns true if the outgoing scene app has requested a save prompt before exiting */
+	virtual bool IsQuitUserPromptRequested() = 0;
+
+	/** Starts a subprocess within the calling application. This
+		* suppresses all application transition UI and automatically identifies the new executable 
+		* as part of the same application. On success the calling process should exit immediately. 
+		* If working directory is NULL or "" the directory portion of the binary path will be 
+		* the working directory. */
+	virtual EVRApplicationError LaunchInternalProcess(const char *pchBinaryPath, const char *pchArguments, const char *pchWorkingDirectory) = 0;
+
+	/** Returns the current scene process ID according to the application system. A scene process will get scene
+		* focus once it starts rendering, but it will appear here once it calls VR_Init with the Scene application
+		* type. */
+	virtual uint32_t GetCurrentSceneProcessId() = 0;
+};
+
+static const char *const IVRApplications_Version = "IVRApplications_006";
+
+}  // namespace vr
+
+// ivrsettings.h
+namespace vr
+{
+enum EVRSettingsError
+{
+	VRSettingsError_None = 0,
+	VRSettingsError_IPCFailed = 1,
+	VRSettingsError_WriteFailed = 2,
+	VRSettingsError_ReadFailed = 3,
+	VRSettingsError_JsonParseFailed = 4,
+	VRSettingsError_UnsetSettingHasNoDefault = 5,  // This will be returned if the setting does not appear in the appropriate default file and has not been set
+};
+
+// The maximum length of a settings key
+static const uint32_t k_unMaxSettingsKeyLength = 128;
+
+class IVRSettings
+{
+public:
+	virtual const char *GetSettingsErrorNameFromEnum(EVRSettingsError eError) = 0;
+
+	// Returns true if file sync occurred (force or settings dirty)
+	virtual bool Sync(bool bForce = false, EVRSettingsError *peError = nullptr) = 0;
+
+	virtual void SetBool(const char *pchSection, const char *pchSettingsKey, bool bValue, EVRSettingsError *peError = nullptr) = 0;
+	virtual void SetInt32(const char *pchSection, const char *pchSettingsKey, int32_t nValue, EVRSettingsError *peError = nullptr) = 0;
+	virtual void SetFloat(const char *pchSection, const char *pchSettingsKey, float flValue, EVRSettingsError *peError = nullptr) = 0;
+	virtual void SetString(const char *pchSection, const char *pchSettingsKey, const char *pchValue, EVRSettingsError *peError = nullptr) = 0;
+
+	// Users of the system need to provide a proper default in default.vrsettings in the resources/settings/ directory
+	// of either the runtime or the driver_xxx directory. Otherwise the default will be false, 0, 0.0 or ""
+	virtual bool GetBool(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+	virtual int32_t GetInt32(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+	virtual float GetFloat(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+	virtual void GetString(const char *pchSection, const char *pchSettingsKey, VR_OUT_STRING() char *pchValue, uint32_t unValueLen, EVRSettingsError *peError = nullptr) = 0;
+
+	virtual void RemoveSection(const char *pchSection, EVRSettingsError *peError = nullptr) = 0;
+	virtual void RemoveKeyInSection(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+};
+
+//-----------------------------------------------------------------------------
+static const char *const IVRSettings_Version = "IVRSettings_002";
+
+//-----------------------------------------------------------------------------
+// steamvr keys
+static const char *const k_pch_SteamVR_Section = "steamvr";
+static const char *const k_pch_SteamVR_RequireHmd_String = "requireHmd";
+static const char *const k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver";
+static const char *const k_pch_SteamVR_ForcedHmdKey_String = "forcedHmd";
+static const char *const k_pch_SteamVR_DisplayDebug_Bool = "displayDebug";
+static const char *const k_pch_SteamVR_DebugProcessPipe_String = "debugProcessPipe";
+static const char *const k_pch_SteamVR_DisplayDebugX_Int32 = "displayDebugX";
+static const char *const k_pch_SteamVR_DisplayDebugY_Int32 = "displayDebugY";
+static const char *const k_pch_SteamVR_SendSystemButtonToAllApps_Bool = "sendSystemButtonToAllApps";
+static const char *const k_pch_SteamVR_LogLevel_Int32 = "loglevel";
+static const char *const k_pch_SteamVR_IPD_Float = "ipd";
+static const char *const k_pch_SteamVR_Background_String = "background";
+static const char *const k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection";
+static const char *const k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight";
+static const char *const k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius";
+static const char *const k_pch_SteamVR_GridColor_String = "gridColor";
+static const char *const k_pch_SteamVR_PlayAreaColor_String = "playAreaColor";
+static const char *const k_pch_SteamVR_ShowStage_Bool = "showStage";
+static const char *const k_pch_SteamVR_ActivateMultipleDrivers_Bool = "activateMultipleDrivers";
+static const char *const k_pch_SteamVR_DirectMode_Bool = "directMode";
+static const char *const k_pch_SteamVR_DirectModeEdidVid_Int32 = "directModeEdidVid";
+static const char *const k_pch_SteamVR_DirectModeEdidPid_Int32 = "directModeEdidPid";
+static const char *const k_pch_SteamVR_UsingSpeakers_Bool = "usingSpeakers";
+static const char *const k_pch_SteamVR_SpeakersForwardYawOffsetDegrees_Float = "speakersForwardYawOffsetDegrees";
+static const char *const k_pch_SteamVR_BaseStationPowerManagement_Bool = "basestationPowerManagement";
+static const char *const k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses";
+static const char *const k_pch_SteamVR_SupersampleScale_Float = "supersampleScale";
+static const char *const k_pch_SteamVR_AllowAsyncReprojection_Bool = "allowAsyncReprojection";
+static const char *const k_pch_SteamVR_AllowReprojection_Bool = "allowInterleavedReprojection";
+static const char *const k_pch_SteamVR_ForceReprojection_Bool = "forceReprojection";
+static const char *const k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking";
+static const char *const k_pch_SteamVR_DefaultMirrorView_Int32 = "defaultMirrorView";
+static const char *const k_pch_SteamVR_ShowMirrorView_Bool = "showMirrorView";
+static const char *const k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry";
+static const char *const k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch";
+static const char *const k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch";
+static const char *const k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch";
+static const char *const k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard";
+static const char *const k_pch_SteamVR_EnableHomeApp = "enableHomeApp";
+static const char *const k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec";
+static const char *const k_pch_SteamVR_RetailDemo_Bool = "retailDemo";
+static const char *const k_pch_SteamVR_IpdOffset_Float = "ipdOffset";
+static const char *const k_pch_SteamVR_AllowSupersampleFiltering_Bool = "allowSupersampleFiltering";
+static const char *const k_pch_SteamVR_EnableLinuxVulkanAsync_Bool = "enableLinuxVulkanAsync";
+
+//-----------------------------------------------------------------------------
+// lighthouse keys
+static const char *const k_pch_Lighthouse_Section = "driver_lighthouse";
+static const char *const k_pch_Lighthouse_DisableIMU_Bool = "disableimu";
+static const char *const k_pch_Lighthouse_UseDisambiguation_String = "usedisambiguation";
+static const char *const k_pch_Lighthouse_DisambiguationDebug_Int32 = "disambiguationdebug";
+static const char *const k_pch_Lighthouse_PrimaryBasestation_Int32 = "primarybasestation";
+static const char *const k_pch_Lighthouse_DBHistory_Bool = "dbhistory";
+
+//-----------------------------------------------------------------------------
+// null keys
+static const char *const k_pch_Null_Section = "driver_null";
+static const char *const k_pch_Null_SerialNumber_String = "serialNumber";
+static const char *const k_pch_Null_ModelNumber_String = "modelNumber";
+static const char *const k_pch_Null_WindowX_Int32 = "windowX";
+static const char *const k_pch_Null_WindowY_Int32 = "windowY";
+static const char *const k_pch_Null_WindowWidth_Int32 = "windowWidth";
+static const char *const k_pch_Null_WindowHeight_Int32 = "windowHeight";
+static const char *const k_pch_Null_RenderWidth_Int32 = "renderWidth";
+static const char *const k_pch_Null_RenderHeight_Int32 = "renderHeight";
+static const char *const k_pch_Null_SecondsFromVsyncToPhotons_Float = "secondsFromVsyncToPhotons";
+static const char *const k_pch_Null_DisplayFrequency_Float = "displayFrequency";
+
+//-----------------------------------------------------------------------------
+// user interface keys
+static const char *const k_pch_UserInterface_Section = "userinterface";
+static const char *const k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop";
+static const char *const k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray";
+static const char *const k_pch_UserInterface_Screenshots_Bool = "screenshots";
+static const char *const k_pch_UserInterface_ScreenshotType_Int = "screenshotType";
+
+//-----------------------------------------------------------------------------
+// notification keys
+static const char *const k_pch_Notifications_Section = "notifications";
+static const char *const k_pch_Notifications_DoNotDisturb_Bool = "DoNotDisturb";
+
+//-----------------------------------------------------------------------------
+// keyboard keys
+static const char *const k_pch_Keyboard_Section = "keyboard";
+static const char *const k_pch_Keyboard_TutorialCompletions = "TutorialCompletions";
+static const char *const k_pch_Keyboard_ScaleX = "ScaleX";
+static const char *const k_pch_Keyboard_ScaleY = "ScaleY";
+static const char *const k_pch_Keyboard_OffsetLeftX = "OffsetLeftX";
+static const char *const k_pch_Keyboard_OffsetRightX = "OffsetRightX";
+static const char *const k_pch_Keyboard_OffsetY = "OffsetY";
+static const char *const k_pch_Keyboard_Smoothing = "Smoothing";
+
+//-----------------------------------------------------------------------------
+// perf keys
+static const char *const k_pch_Perf_Section = "perfcheck";
+static const char *const k_pch_Perf_HeuristicActive_Bool = "heuristicActive";
+static const char *const k_pch_Perf_NotifyInHMD_Bool = "warnInHMD";
+static const char *const k_pch_Perf_NotifyOnlyOnce_Bool = "warnOnlyOnce";
+static const char *const k_pch_Perf_AllowTimingStore_Bool = "allowTimingStore";
+static const char *const k_pch_Perf_SaveTimingsOnExit_Bool = "saveTimingsOnExit";
+static const char *const k_pch_Perf_TestData_Float = "perfTestData";
+static const char *const k_pch_Perf_LinuxGPUProfiling_Bool = "linuxGPUProfiling";
+
+//-----------------------------------------------------------------------------
+// collision bounds keys
+static const char *const k_pch_CollisionBounds_Section = "collisionBounds";
+static const char *const k_pch_CollisionBounds_Style_Int32 = "CollisionBoundsStyle";
+static const char *const k_pch_CollisionBounds_GroundPerimeterOn_Bool = "CollisionBoundsGroundPerimeterOn";
+static const char *const k_pch_CollisionBounds_CenterMarkerOn_Bool = "CollisionBoundsCenterMarkerOn";
+static const char *const k_pch_CollisionBounds_PlaySpaceOn_Bool = "CollisionBoundsPlaySpaceOn";
+static const char *const k_pch_CollisionBounds_FadeDistance_Float = "CollisionBoundsFadeDistance";
+static const char *const k_pch_CollisionBounds_ColorGammaR_Int32 = "CollisionBoundsColorGammaR";
+static const char *const k_pch_CollisionBounds_ColorGammaG_Int32 = "CollisionBoundsColorGammaG";
+static const char *const k_pch_CollisionBounds_ColorGammaB_Int32 = "CollisionBoundsColorGammaB";
+static const char *const k_pch_CollisionBounds_ColorGammaA_Int32 = "CollisionBoundsColorGammaA";
+
+//-----------------------------------------------------------------------------
+// camera keys
+static const char *const k_pch_Camera_Section = "camera";
+static const char *const k_pch_Camera_EnableCamera_Bool = "enableCamera";
+static const char *const k_pch_Camera_EnableCameraInDashboard_Bool = "enableCameraInDashboard";
+static const char *const k_pch_Camera_EnableCameraForCollisionBounds_Bool = "enableCameraForCollisionBounds";
+static const char *const k_pch_Camera_EnableCameraForRoomView_Bool = "enableCameraForRoomView";
+static const char *const k_pch_Camera_BoundsColorGammaR_Int32 = "cameraBoundsColorGammaR";
+static const char *const k_pch_Camera_BoundsColorGammaG_Int32 = "cameraBoundsColorGammaG";
+static const char *const k_pch_Camera_BoundsColorGammaB_Int32 = "cameraBoundsColorGammaB";
+static const char *const k_pch_Camera_BoundsColorGammaA_Int32 = "cameraBoundsColorGammaA";
+static const char *const k_pch_Camera_BoundsStrength_Int32 = "cameraBoundsStrength";
+
+//-----------------------------------------------------------------------------
+// audio keys
+static const char *const k_pch_audio_Section = "audio";
+static const char *const k_pch_audio_OnPlaybackDevice_String = "onPlaybackDevice";
+static const char *const k_pch_audio_OnRecordDevice_String = "onRecordDevice";
+static const char *const k_pch_audio_OnPlaybackMirrorDevice_String = "onPlaybackMirrorDevice";
+static const char *const k_pch_audio_OffPlaybackDevice_String = "offPlaybackDevice";
+static const char *const k_pch_audio_OffRecordDevice_String = "offRecordDevice";
+static const char *const k_pch_audio_VIVEHDMIGain = "viveHDMIGain";
+
+//-----------------------------------------------------------------------------
+// power management keys
+static const char *const k_pch_Power_Section = "power";
+static const char *const k_pch_Power_PowerOffOnExit_Bool = "powerOffOnExit";
+static const char *const k_pch_Power_TurnOffScreensTimeout_Float = "turnOffScreensTimeout";
+static const char *const k_pch_Power_TurnOffControllersTimeout_Float = "turnOffControllersTimeout";
+static const char *const k_pch_Power_ReturnToWatchdogTimeout_Float = "returnToWatchdogTimeout";
+static const char *const k_pch_Power_AutoLaunchSteamVROnButtonPress = "autoLaunchSteamVROnButtonPress";
+static const char *const k_pch_Power_PauseCompositorOnStandby_Bool = "pauseCompositorOnStandby";
+
+//-----------------------------------------------------------------------------
+// dashboard keys
+static const char *const k_pch_Dashboard_Section = "dashboard";
+static const char *const k_pch_Dashboard_EnableDashboard_Bool = "enableDashboard";
+static const char *const k_pch_Dashboard_ArcadeMode_Bool = "arcadeMode";
+
+//-----------------------------------------------------------------------------
+// model skin keys
+static const char *const k_pch_modelskin_Section = "modelskins";
+
+//-----------------------------------------------------------------------------
+// driver keys - These could be checked in any driver_<name> section
+static const char *const k_pch_Driver_Enable_Bool = "enable";
+
+}  // namespace vr
+
+// ivrchaperone.h
+namespace vr
+{
+#pragma pack(push, 8)
+
+enum ChaperoneCalibrationState
+{
+	// OK!
+	ChaperoneCalibrationState_OK = 1,  // Chaperone is fully calibrated and working correctly
+
+	// Warnings
+	ChaperoneCalibrationState_Warning = 100,
+	ChaperoneCalibrationState_Warning_BaseStationMayHaveMoved = 101,  // A base station thinks that it might have moved
+	ChaperoneCalibrationState_Warning_BaseStationRemoved = 102,       // There are less base stations than when calibrated
+	ChaperoneCalibrationState_Warning_SeatedBoundsInvalid = 103,      // Seated bounds haven't been calibrated for the current tracking center
+
+	// Errors
+	ChaperoneCalibrationState_Error = 200,                           // The UniverseID is invalid
+	ChaperoneCalibrationState_Error_BaseStationUninitialized = 201,  // Tracking center hasn't be calibrated for at least one of the base stations
+	ChaperoneCalibrationState_Error_BaseStationConflict = 202,       // Tracking center is calibrated, but base stations disagree on the tracking space
+	ChaperoneCalibrationState_Error_PlayAreaInvalid = 203,           // Play Area hasn't been calibrated for the current tracking center
+	ChaperoneCalibrationState_Error_CollisionBoundsInvalid = 204,    // Collision Bounds haven't been calibrated for the current tracking center
+};
+
+/** HIGH LEVEL TRACKING SPACE ASSUMPTIONS:
+* 0,0,0 is the preferred standing area center.
+* 0Y is the floor height.
+* -Z is the preferred forward facing direction. */
+class IVRChaperone
+{
+public:
+	/** Get the current state of Chaperone calibration. This state can change at any time during a session due to physical base station changes. **/
+	virtual ChaperoneCalibrationState GetCalibrationState() = 0;
+
+	/** Returns the width and depth of the Play Area (formerly named Soft Bounds) in X and Z. 
+	* Tracking space center (0,0,0) is the center of the Play Area. **/
+	virtual bool GetPlayAreaSize(float *pSizeX, float *pSizeZ) = 0;
+
+	/** Returns the 4 corner positions of the Play Area (formerly named Soft Bounds).
+	* Corners are in counter-clockwise order.
+	* Standing center (0,0,0) is the center of the Play Area.
+	* It's a rectangle.
+	* 2 sides are parallel to the X axis and 2 sides are parallel to the Z axis.
+	* Height of every corner is 0Y (on the floor). **/
+	virtual bool GetPlayAreaRect(HmdQuad_t *rect) = 0;
+
+	/** Reload Chaperone data from the .vrchap file on disk. */
+	virtual void ReloadInfo(void) = 0;
+
+	/** Optionally give the chaperone system a hit about the color and brightness in the scene **/
+	virtual void SetSceneColor(HmdColor_t color) = 0;
+
+	/** Get the current chaperone bounds draw color and brightness **/
+	virtual void GetBoundsColor(HmdColor_t *pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, HmdColor_t *pOutputCameraColor) = 0;
+
+	/** Determine whether the bounds are showing right now **/
+	virtual bool AreBoundsVisible() = 0;
+
+	/** Force the bounds to show, mostly for utilities **/
+	virtual void ForceBoundsVisible(bool bForce) = 0;
+};
+
+static const char *const IVRChaperone_Version = "IVRChaperone_003";
+
+#pragma pack(pop)
+
+}  // namespace vr
+
+// ivrchaperonesetup.h
+namespace vr
+{
+enum EChaperoneConfigFile
+{
+	EChaperoneConfigFile_Live = 1,  // The live chaperone config, used by most applications and games
+	EChaperoneConfigFile_Temp = 2,  // The temporary chaperone config, used to live-preview collision bounds in room setup
+};
+
+enum EChaperoneImportFlags
+{
+	EChaperoneImport_BoundsOnly = 0x0001,
+};
+
+/** Manages the working copy of the chaperone info. By default this will be the same as the 
+* live copy. Any changes made with this interface will stay in the working copy until 
+* CommitWorkingCopy() is called, at which point the working copy and the live copy will be 
+* the same again. */
+class IVRChaperoneSetup
+{
+public:
+	/** Saves the current working copy to disk */
+	virtual bool CommitWorkingCopy(EChaperoneConfigFile configFile) = 0;
+
+	/** Reverts the working copy to match the live chaperone calibration.
+	* To modify existing data this MUST be do WHILE getting a non-error ChaperoneCalibrationStatus.
+	* Only after this should you do gets and sets on the existing data. */
+	virtual void RevertWorkingCopy() = 0;
+
+	/** Returns the width and depth of the Play Area (formerly named Soft Bounds) in X and Z from the working copy.
+	* Tracking space center (0,0,0) is the center of the Play Area. */
+	virtual bool GetWorkingPlayAreaSize(float *pSizeX, float *pSizeZ) = 0;
+
+	/** Returns the 4 corner positions of the Play Area (formerly named Soft Bounds) from the working copy.
+	* Corners are in clockwise order.
+	* Tracking space center (0,0,0) is the center of the Play Area.
+	* It's a rectangle.
+	* 2 sides are parallel to the X axis and 2 sides are parallel to the Z axis.
+	* Height of every corner is 0Y (on the floor). **/
+	virtual bool GetWorkingPlayAreaRect(HmdQuad_t *rect) = 0;
+
+	/** Returns the number of Quads if the buffer points to null. Otherwise it returns Quads 
+	* into the buffer up to the max specified from the working copy. */
+	virtual bool GetWorkingCollisionBoundsInfo(VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t *punQuadsCount) = 0;
+
+	/** Returns the number of Quads if the buffer points to null. Otherwise it returns Quads 
+	* into the buffer up to the max specified. */
+	virtual bool GetLiveCollisionBoundsInfo(VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t *punQuadsCount) = 0;
+
+	/** Returns the preferred seated position from the working copy. */
+	virtual bool GetWorkingSeatedZeroPoseToRawTrackingPose(HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose) = 0;
+
+	/** Returns the standing origin from the working copy. */
+	virtual bool GetWorkingStandingZeroPoseToRawTrackingPose(HmdMatrix34_t *pmatStandingZeroPoseToRawTrackingPose) = 0;
+
+	/** Sets the Play Area in the working copy. */
+	virtual void SetWorkingPlayAreaSize(float sizeX, float sizeZ) = 0;
+
+	/** Sets the Collision Bounds in the working copy. */
+	virtual void SetWorkingCollisionBoundsInfo(VR_ARRAY_COUNT(unQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t unQuadsCount) = 0;
+
+	/** Sets the preferred seated position in the working copy. */
+	virtual void SetWorkingSeatedZeroPoseToRawTrackingPose(const HmdMatrix34_t *pMatSeatedZeroPoseToRawTrackingPose) = 0;
+
+	/** Sets the preferred standing position in the working copy. */
+	virtual void SetWorkingStandingZeroPoseToRawTrackingPose(const HmdMatrix34_t *pMatStandingZeroPoseToRawTrackingPose) = 0;
+
+	/** Tear everything down and reload it from the file on disk */
+	virtual void ReloadFromDisk(EChaperoneConfigFile configFile) = 0;
+
+	/** Returns the preferred seated position. */
+	virtual bool GetLiveSeatedZeroPoseToRawTrackingPose(HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose) = 0;
+
+	virtual void SetWorkingCollisionBoundsTagsInfo(VR_ARRAY_COUNT(unTagCount) uint8_t *pTagsBuffer, uint32_t unTagCount) = 0;
+	virtual bool GetLiveCollisionBoundsTagsInfo(VR_OUT_ARRAY_COUNT(punTagCount) uint8_t *pTagsBuffer, uint32_t *punTagCount) = 0;
+
+	virtual bool SetWorkingPhysicalBoundsInfo(VR_ARRAY_COUNT(unQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t unQuadsCount) = 0;
+	virtual bool GetLivePhysicalBoundsInfo(VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t *punQuadsCount) = 0;
+
+	virtual bool ExportLiveToBuffer(VR_OUT_STRING() char *pBuffer, uint32_t *pnBufferLength) = 0;
+	virtual bool ImportFromBufferToWorking(const char *pBuffer, uint32_t nImportFlags) = 0;
+};
+
+static const char *const IVRChaperoneSetup_Version = "IVRChaperoneSetup_005";
+
+}  // namespace vr
+
+// ivrcompositor.h
+namespace vr
+{
+#pragma pack(push, 8)
+
+/** Errors that can occur with the VR compositor */
+enum EVRCompositorError
+{
+	VRCompositorError_None = 0,
+	VRCompositorError_RequestFailed = 1,
+	VRCompositorError_IncompatibleVersion = 100,
+	VRCompositorError_DoNotHaveFocus = 101,
+	VRCompositorError_InvalidTexture = 102,
+	VRCompositorError_IsNotSceneApplication = 103,
+	VRCompositorError_TextureIsOnWrongDevice = 104,
+	VRCompositorError_TextureUsesUnsupportedFormat = 105,
+	VRCompositorError_SharedTexturesNotSupported = 106,
+	VRCompositorError_IndexOutOfRange = 107,
+	VRCompositorError_AlreadySubmitted = 108,
+	VRCompositorError_InvalidBounds = 109,
+};
+
+const uint32_t VRCompositor_ReprojectionReason_Cpu = 0x01;
+const uint32_t VRCompositor_ReprojectionReason_Gpu = 0x02;
+const uint32_t VRCompositor_ReprojectionAsync = 0x04;  // This flag indicates the async reprojection mode is active,
+													   // but does not indicate if reprojection actually happened or not.
+													   // Use the ReprojectionReason flags above to check if reprojection
+													   // was actually applied (i.e. scene texture was reused).
+													   // NumFramePresents > 1 also indicates the scene texture was reused,
+													   // and also the number of times that it was presented in total.
+
+/** Provides a single frame's timing information to the app */
+struct Compositor_FrameTiming
+{
+	uint32_t m_nSize;  // Set to sizeof( Compositor_FrameTiming )
+	uint32_t m_nFrameIndex;
+	uint32_t m_nNumFramePresents;  // number of times this frame was presented
+	uint32_t m_nNumMisPresented;   // number of times this frame was presented on a vsync other than it was originally predicted to
+	uint32_t m_nNumDroppedFrames;  // number of additional times previous frame was scanned out
+	uint32_t m_nReprojectionFlags;
+
+	/** Absolute time reference for comparing frames.  This aligns with the vsync that running start is relative to. */
+	double m_flSystemTimeInSeconds;
+
+	/** These times may include work from other processes due to OS scheduling.
+	* The fewer packets of work these are broken up into, the less likely this will happen.
+	* GPU work can be broken up by calling Flush.  This can sometimes be useful to get the GPU started
+	* processing that work earlier in the frame. */
+	float m_flPreSubmitGpuMs;         // time spent rendering the scene (gpu work submitted between WaitGetPoses and second Submit)
+	float m_flPostSubmitGpuMs;        // additional time spent rendering by application (e.g. companion window)
+	float m_flTotalRenderGpuMs;       // time between work submitted immediately after present (ideally vsync) until the end of compositor submitted work
+	float m_flCompositorRenderGpuMs;  // time spend performing distortion correction, rendering chaperone, overlays, etc.
+	float m_flCompositorRenderCpuMs;  // time spent on cpu submitting the above work for this frame
+	float m_flCompositorIdleCpuMs;    // time spent waiting for running start (application could have used this much more time)
+
+	/** Miscellaneous measured intervals. */
+	float m_flClientFrameIntervalMs;  // time between calls to WaitGetPoses
+	float m_flPresentCallCpuMs;       // time blocked on call to present (usually 0.0, but can go long)
+	float m_flWaitForPresentCpuMs;    // time spent spin-waiting for frame index to change (not near-zero indicates wait object failure)
+	float m_flSubmitFrameMs;          // time spent in IVRCompositor::Submit (not near-zero indicates driver issue)
+
+	/** The following are all relative to this frame's SystemTimeInSeconds */
+	float m_flWaitGetPosesCalledMs;
+	float m_flNewPosesReadyMs;
+	float m_flNewFrameReadyMs;  // second call to IVRCompositor::Submit
+	float m_flCompositorUpdateStartMs;
+	float m_flCompositorUpdateEndMs;
+	float m_flCompositorRenderStartMs;
+
+	vr::TrackedDevicePose_t m_HmdPose;  // pose used by app to render this frame
+};
+
+/** Cumulative stats for current application.  These are not cleared until a new app connects,
+* but they do stop accumulating once the associated app disconnects. */
+struct Compositor_CumulativeStats
+{
+	uint32_t m_nPid;                   // Process id associated with these stats (may no longer be running).
+	uint32_t m_nNumFramePresents;      // total number of times we called present (includes reprojected frames)
+	uint32_t m_nNumDroppedFrames;      // total number of times an old frame was re-scanned out (without reprojection)
+	uint32_t m_nNumReprojectedFrames;  // total number of times a frame was scanned out a second time (with reprojection)
+
+	/** Values recorded at startup before application has fully faded in the first time. */
+	uint32_t m_nNumFramePresentsOnStartup;
+	uint32_t m_nNumDroppedFramesOnStartup;
+	uint32_t m_nNumReprojectedFramesOnStartup;
+
+	/** Applications may explicitly fade to the compositor.  This is usually to handle level transitions, and loading often causes
+	* system wide hitches.  The following stats are collected during this period.  Does not include values recorded during startup. */
+	uint32_t m_nNumLoading;
+	uint32_t m_nNumFramePresentsLoading;
+	uint32_t m_nNumDroppedFramesLoading;
+	uint32_t m_nNumReprojectedFramesLoading;
+
+	/** If we don't get a new frame from the app in less than 2.5 frames, then we assume the app has hung and start
+	* fading back to the compositor.  The following stats are a result of this, and are a subset of those recorded above.
+	* Does not include values recorded during start up or loading. */
+	uint32_t m_nNumTimedOut;
+	uint32_t m_nNumFramePresentsTimedOut;
+	uint32_t m_nNumDroppedFramesTimedOut;
+	uint32_t m_nNumReprojectedFramesTimedOut;
+};
+
+#pragma pack(pop)
+
+/** Allows the application to interact with the compositor */
+class IVRCompositor
+{
+public:
+	/** Sets tracking space returned by WaitGetPoses */
+	virtual void SetTrackingSpace(ETrackingUniverseOrigin eOrigin) = 0;
+
+	/** Gets current tracking space returned by WaitGetPoses */
+	virtual ETrackingUniverseOrigin GetTrackingSpace() = 0;
+
+	/** Scene applications should call this function to get poses to render with (and optionally poses predicted an additional frame out to use for gameplay).
+	* This function will block until "running start" milliseconds before the start of the frame, and should be called at the last moment before needing to
+	* start rendering.
+	*
+	* Return codes:
+	*	- IsNotSceneApplication (make sure to call VR_Init with VRApplicaiton_Scene)
+	*	- DoNotHaveFocus (some other app has taken focus - this will throttle the call to 10hz to reduce the impact on that app)
+	*/
+	virtual EVRCompositorError WaitGetPoses(VR_ARRAY_COUNT(unRenderPoseArrayCount) TrackedDevicePose_t *pRenderPoseArray, uint32_t unRenderPoseArrayCount,
+											VR_ARRAY_COUNT(unGamePoseArrayCount) TrackedDevicePose_t *pGamePoseArray, uint32_t unGamePoseArrayCount) = 0;
+
+	/** Get the last set of poses returned by WaitGetPoses. */
+	virtual EVRCompositorError GetLastPoses(VR_ARRAY_COUNT(unRenderPoseArrayCount) TrackedDevicePose_t *pRenderPoseArray, uint32_t unRenderPoseArrayCount,
+											VR_ARRAY_COUNT(unGamePoseArrayCount) TrackedDevicePose_t *pGamePoseArray, uint32_t unGamePoseArrayCount) = 0;
+
+	/** Interface for accessing last set of poses returned by WaitGetPoses one at a time.
+	* Returns VRCompositorError_IndexOutOfRange if unDeviceIndex not less than k_unMaxTrackedDeviceCount otherwise VRCompositorError_None.
+	* It is okay to pass NULL for either pose if you only want one of the values. */
+	virtual EVRCompositorError GetLastPoseForTrackedDeviceIndex(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t *pOutputPose, TrackedDevicePose_t *pOutputGamePose) = 0;
+
+	/** Updated scene texture to display. If pBounds is NULL the entire texture will be used.  If called from an OpenGL app, consider adding a glFlush after
+	* Submitting both frames to signal the driver to start processing, otherwise it may wait until the command buffer fills up, causing the app to miss frames.
+	*
+	* OpenGL dirty state:
+	*	glBindTexture
+	*
+	* Return codes:
+	*	- IsNotSceneApplication (make sure to call VR_Init with VRApplicaiton_Scene)
+	*	- DoNotHaveFocus (some other app has taken focus)
+	*	- TextureIsOnWrongDevice (application did not use proper AdapterIndex - see IVRSystem.GetDXGIOutputInfo)
+	*	- SharedTexturesNotSupported (application needs to call CreateDXGIFactory1 or later before creating DX device)
+	*	- TextureUsesUnsupportedFormat (scene textures must be compatible with DXGI sharing rules - e.g. uncompressed, no mips, etc.)
+	*	- InvalidTexture (usually means bad arguments passed in)
+	*	- AlreadySubmitted (app has submitted two left textures or two right textures in a single frame - i.e. before calling WaitGetPoses again)
+	*/
+	virtual EVRCompositorError Submit(EVREye eEye, const Texture_t *pTexture, const VRTextureBounds_t *pBounds = 0, EVRSubmitFlags nSubmitFlags = Submit_Default) = 0;
+
+	/** Clears the frame that was sent with the last call to Submit. This will cause the 
+	* compositor to show the grid until Submit is called again. */
+	virtual void ClearLastSubmittedFrame() = 0;
+
+	/** Call immediately after presenting your app's window (i.e. companion window) to unblock the compositor.
+	* This is an optional call, which only needs to be used if you can't instead call WaitGetPoses immediately after Present.
+	* For example, if your engine's render and game loop are not on separate threads, or blocking the render thread until 3ms before the next vsync would
+	* introduce a deadlock of some sort.  This function tells the compositor that you have finished all rendering after having Submitted buffers for both
+	* eyes, and it is free to start its rendering work.  This should only be called from the same thread you are rendering on. */
+	virtual void PostPresentHandoff() = 0;
+
+	/** Returns true if timing data is filled it.  Sets oldest timing info if nFramesAgo is larger than the stored history.
+	* Be sure to set timing.size = sizeof(Compositor_FrameTiming) on struct passed in before calling this function. */
+	virtual bool GetFrameTiming(Compositor_FrameTiming *pTiming, uint32_t unFramesAgo = 0) = 0;
+
+	/** Interface for copying a range of timing data.  Frames are returned in ascending order (oldest to newest) with the last being the most recent frame.
+	* Only the first entry's m_nSize needs to be set, as the rest will be inferred from that.  Returns total number of entries filled out. */
+	virtual uint32_t GetFrameTimings(Compositor_FrameTiming *pTiming, uint32_t nFrames) = 0;
+
+	/** Returns the time in seconds left in the current (as identified by FrameTiming's frameIndex) frame.
+	* Due to "running start", this value may roll over to the next frame before ever reaching 0.0. */
+	virtual float GetFrameTimeRemaining() = 0;
+
+	/** Fills out stats accumulated for the last connected application.  Pass in sizeof( Compositor_CumulativeStats ) as second parameter. */
+	virtual void GetCumulativeStats(Compositor_CumulativeStats *pStats, uint32_t nStatsSizeInBytes) = 0;
+
+	/** Fades the view on the HMD to the specified color. The fade will take fSeconds, and the color values are between
+	* 0.0 and 1.0. This color is faded on top of the scene based on the alpha parameter. Removing the fade color instantly 
+	* would be FadeToColor( 0.0, 0.0, 0.0, 0.0, 0.0 ).  Values are in un-premultiplied alpha space. */
+	virtual void FadeToColor(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground = false) = 0;
+
+	/** Get current fade color value. */
+	virtual HmdColor_t GetCurrentFadeColor(bool bBackground = false) = 0;
+
+	/** Fading the Grid in or out in fSeconds */
+	virtual void FadeGrid(float fSeconds, bool bFadeIn) = 0;
+
+	/** Get current alpha value of grid. */
+	virtual float GetCurrentGridAlpha() = 0;
+
+	/** Override the skybox used in the compositor (e.g. for during level loads when the app can't feed scene images fast enough)
+	* Order is Front, Back, Left, Right, Top, Bottom.  If only a single texture is passed, it is assumed in lat-long format.
+	* If two are passed, it is assumed a lat-long stereo pair. */
+	virtual EVRCompositorError SetSkyboxOverride(VR_ARRAY_COUNT(unTextureCount) const Texture_t *pTextures, uint32_t unTextureCount) = 0;
+
+	/** Resets compositor skybox back to defaults. */
+	virtual void ClearSkyboxOverride() = 0;
+
+	/** Brings the compositor window to the front. This is useful for covering any other window that may be on the HMD
+	* and is obscuring the compositor window. */
+	virtual void CompositorBringToFront() = 0;
+
+	/** Pushes the compositor window to the back. This is useful for allowing other applications to draw directly to the HMD. */
+	virtual void CompositorGoToBack() = 0;
+
+	/** Tells the compositor process to clean up and exit. You do not need to call this function at shutdown. Under normal 
+	* circumstances the compositor will manage its own life cycle based on what applications are running. */
+	virtual void CompositorQuit() = 0;
+
+	/** Return whether the compositor is fullscreen */
+	virtual bool IsFullscreen() = 0;
+
+	/** Returns the process ID of the process that is currently rendering the scene */
+	virtual uint32_t GetCurrentSceneFocusProcess() = 0;
+
+	/** Returns the process ID of the process that rendered the last frame (or 0 if the compositor itself rendered the frame.)
+	* Returns 0 when fading out from an app and the app's process Id when fading into an app. */
+	virtual uint32_t GetLastFrameRenderer() = 0;
+
+	/** Returns true if the current process has the scene focus */
+	virtual bool CanRenderScene() = 0;
+
+	/** Creates a window on the primary monitor to display what is being shown in the headset. */
+	virtual void ShowMirrorWindow() = 0;
+
+	/** Closes the mirror window. */
+	virtual void HideMirrorWindow() = 0;
+
+	/** Returns true if the mirror window is shown. */
+	virtual bool IsMirrorWindowVisible() = 0;
+
+	/** Writes all images that the compositor knows about (including overlays) to a 'screenshots' folder in the SteamVR runtime root. */
+	virtual void CompositorDumpImages() = 0;
+
+	/** Let an app know it should be rendering with low resources. */
+	virtual bool ShouldAppRenderWithLowResources() = 0;
+
+	/** Override interleaved reprojection logic to force on. */
+	virtual void ForceInterleavedReprojectionOn(bool bOverride) = 0;
+
+	/** Force reconnecting to the compositor process. */
+	virtual void ForceReconnectProcess() = 0;
+
+	/** Temporarily suspends rendering (useful for finer control over scene transitions). */
+	virtual void SuspendRendering(bool bSuspend) = 0;
+
+	/** Opens a shared D3D11 texture with the undistorted composited image for each eye.  Use ReleaseMirrorTextureD3D11 when finished
+	* instead of calling Release on the resource itself. */
+	virtual vr::EVRCompositorError GetMirrorTextureD3D11(vr::EVREye eEye, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView) = 0;
+	virtual void ReleaseMirrorTextureD3D11(void *pD3D11ShaderResourceView) = 0;
+
+	/** Access to mirror textures from OpenGL. */
+	virtual vr::EVRCompositorError GetMirrorTextureGL(vr::EVREye eEye, vr::glUInt_t *pglTextureId, vr::glSharedTextureHandle_t *pglSharedTextureHandle) = 0;
+	virtual bool ReleaseSharedGLTexture(vr::glUInt_t glTextureId, vr::glSharedTextureHandle_t glSharedTextureHandle) = 0;
+	virtual void LockGLSharedTextureForAccess(vr::glSharedTextureHandle_t glSharedTextureHandle) = 0;
+	virtual void UnlockGLSharedTextureForAccess(vr::glSharedTextureHandle_t glSharedTextureHandle) = 0;
+
+	/** [Vulkan Only]
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null.  The string will be a space separated list of-required instance extensions to enable in VkCreateInstance */
+	virtual uint32_t GetVulkanInstanceExtensionsRequired(VR_OUT_STRING() char *pchValue, uint32_t unBufferSize) = 0;
+
+	/** [Vulkan only]
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null.  The string will be a space separated list of required device extensions to enable in VkCreateDevice */
+	virtual uint32_t GetVulkanDeviceExtensionsRequired(VkPhysicalDevice_T *pPhysicalDevice, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize) = 0;
+
+	/** [ Vulkan/D3D12 Only ]
+	* There are two purposes for SetExplicitTimingMode:
+	*	1. To get a more accurate GPU timestamp for when the frame begins in Vulkan/D3D12 applications.
+	*	2. (Optional) To avoid having WaitGetPoses access the Vulkan queue so that the queue can be accessed from
+	*	another thread while WaitGetPoses is executing.
+	*
+	* More accurate GPU timestamp for the start of the frame is achieved by the application calling
+	* SubmitExplicitTimingData immediately before its first submission to the Vulkan/D3D12 queue.
+	* This is more accurate because normally this GPU timestamp is recorded during WaitGetPoses.  In D3D11, 
+	* WaitGetPoses queues a GPU timestamp write, but it does not actually get submitted to the GPU until the 
+	* application flushes.  By using SubmitExplicitTimingData, the timestamp is recorded at the same place for 
+	* Vulkan/D3D12 as it is for D3D11, resulting in a more accurate GPU time measurement for the frame.
+	*
+	* Avoiding WaitGetPoses accessing the Vulkan queue can be achieved using SetExplicitTimingMode as well.  If this is desired,
+	* the application *MUST* call PostPresentHandoff itself prior to WaitGetPoses.  If SetExplicitTimingMode is true and the
+	* application calls PostPresentHandoff, then WaitGetPoses is guaranteed not to access the queue.  Note that PostPresentHandoff
+	* and SubmitExplicitTimingData will access the queue, so only WaitGetPoses becomes safe for accessing the queue from another
+	* thread. */
+	virtual void SetExplicitTimingMode(bool bExplicitTimingMode) = 0;
+
+	/** [ Vulkan/D3D12 Only ]
+	* Submit explicit timing data.  When SetExplicitTimingMode is true, this must be called immediately before
+	* the application's first vkQueueSubmit (Vulkan) or ID3D12CommandQueue::ExecuteCommandLists (D3D12) of each frame.
+	* This function will insert a GPU timestamp write just before the application starts its rendering.  This function
+	* will perform a vkQueueSubmit on Vulkan so must not be done simultaneously with VkQueue operations on another thread.
+	* Returns VRCompositorError_RequestFailed if SetExplicitTimingMode is not enabled. */
+	virtual EVRCompositorError SubmitExplicitTimingData() = 0;
+};
+
+static const char *const IVRCompositor_Version = "IVRCompositor_021";
+
+}  // namespace vr
+
+// ivrnotifications.h
+namespace vr
+{
+#pragma pack(push, 8)
+
+// Used for passing graphic data
+struct NotificationBitmap_t
+{
+	NotificationBitmap_t()
+		: m_pImageData(nullptr), m_nWidth(0), m_nHeight(0), m_nBytesPerPixel(0){};
+
+	void *m_pImageData;
+	int32_t m_nWidth;
+	int32_t m_nHeight;
+	int32_t m_nBytesPerPixel;
+};
+
+/** Be aware that the notification type is used as 'priority' to pick the next notification */
+enum EVRNotificationType
+{
+	/** Transient notifications are automatically hidden after a period of time set by the user. 
+	* They are used for things like information and chat messages that do not require user interaction. */
+	EVRNotificationType_Transient = 0,
+
+	/** Persistent notifications are shown to the user until they are hidden by calling RemoveNotification().
+	* They are used for things like phone calls and alarms that require user interaction. */
+	EVRNotificationType_Persistent = 1,
+
+	/** System notifications are shown no matter what. It is expected, that the ulUserValue is used as ID.
+	 * If there is already a system notification in the queue with that ID it is not accepted into the queue
+	 * to prevent spamming with system notification */
+	EVRNotificationType_Transient_SystemWithUserValue = 2,
+};
+
+enum EVRNotificationStyle
+{
+	/** Creates a notification with minimal external styling. */
+	EVRNotificationStyle_None = 0,
+
+	/** Used for notifications about overlay-level status. In Steam this is used for events like downloads completing. */
+	EVRNotificationStyle_Application = 100,
+
+	/** Used for notifications about contacts that are unknown or not available. In Steam this is used for friend invitations and offline friends. */
+	EVRNotificationStyle_Contact_Disabled = 200,
+
+	/** Used for notifications about contacts that are available but inactive. In Steam this is used for friends that are online but not playing a game. */
+	EVRNotificationStyle_Contact_Enabled = 201,
+
+	/** Used for notifications about contacts that are available and active. In Steam this is used for friends that are online and currently running a game. */
+	EVRNotificationStyle_Contact_Active = 202,
+};
+
+static const uint32_t k_unNotificationTextMaxSize = 256;
+
+typedef uint32_t VRNotificationId;
+
+#pragma pack(pop)
+
+/** Allows notification sources to interact with the VR system
+	This current interface is not yet implemented. Do not use yet. */
+class IVRNotifications
+{
+public:
+	/** Create a notification and enqueue it to be shown to the user.
+	* An overlay handle is required to create a notification, as otherwise it would be impossible for a user to act on it.
+	* To create a two-line notification, use a line break ('\n') to split the text into two lines.
+	* The pImage argument may be NULL, in which case the specified overlay's icon will be used instead. */
+	virtual EVRNotificationError CreateNotification(VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, EVRNotificationType type, const char *pchText, EVRNotificationStyle style, const NotificationBitmap_t *pImage, /* out */ VRNotificationId *pNotificationId) = 0;
+
+	/** Destroy a notification, hiding it first if it currently shown to the user. */
+	virtual EVRNotificationError RemoveNotification(VRNotificationId notificationId) = 0;
+};
+
+static const char *const IVRNotifications_Version = "IVRNotifications_002";
+
+}  // namespace vr
+
+// ivroverlay.h
+namespace vr
+{
+/** The maximum length of an overlay key in bytes, counting the terminating null character. */
+static const uint32_t k_unVROverlayMaxKeyLength = 128;
+
+/** The maximum length of an overlay name in bytes, counting the terminating null character. */
+static const uint32_t k_unVROverlayMaxNameLength = 128;
+
+/** The maximum number of overlays that can exist in the system at one time. */
+static const uint32_t k_unMaxOverlayCount = 64;
+
+/** The maximum number of overlay intersection mask primitives per overlay */
+static const uint32_t k_unMaxOverlayIntersectionMaskPrimitivesCount = 32;
+
+/** Types of input supported by VR Overlays */
+enum VROverlayInputMethod
+{
+	VROverlayInputMethod_None = 0,   // No input events will be generated automatically for this overlay
+	VROverlayInputMethod_Mouse = 1,  // Tracked controllers will get mouse events automatically
+};
+
+/** Allows the caller to figure out which overlay transform getter to call. */
+enum VROverlayTransformType
+{
+	VROverlayTransform_Absolute = 0,
+	VROverlayTransform_TrackedDeviceRelative = 1,
+	VROverlayTransform_SystemOverlay = 2,
+	VROverlayTransform_TrackedComponent = 3,
+};
+
+/** Overlay control settings */
+enum VROverlayFlags
+{
+	VROverlayFlags_None = 0,
+
+	// The following only take effect when rendered using the high quality render path (see SetHighQualityOverlay).
+	VROverlayFlags_Curved = 1,
+	VROverlayFlags_RGSS4X = 2,
+
+	// Set this flag on a dashboard overlay to prevent a tab from showing up for that overlay
+	VROverlayFlags_NoDashboardTab = 3,
+
+	// Set this flag on a dashboard that is able to deal with gamepad focus events
+	VROverlayFlags_AcceptsGamepadEvents = 4,
+
+	// Indicates that the overlay should dim/brighten to show gamepad focus
+	VROverlayFlags_ShowGamepadFocus = 5,
+
+	// When in VROverlayInputMethod_Mouse you can optionally enable sending VRScroll_t
+	VROverlayFlags_SendVRScrollEvents = 6,
+	VROverlayFlags_SendVRTouchpadEvents = 7,
+
+	// If set this will render a vertical scroll wheel on the primary controller,
+	//  only needed if not using VROverlayFlags_SendVRScrollEvents but you still want to represent a scroll wheel
+	VROverlayFlags_ShowTouchPadScrollWheel = 8,
+
+	// If this is set ownership and render access to the overlay are transferred
+	// to the new scene process on a call to IVRApplications::LaunchInternalProcess
+	VROverlayFlags_TransferOwnershipToInternalProcess = 9,
+
+	// If set, renders 50% of the texture in each eye, side by side
+	VROverlayFlags_SideBySide_Parallel = 10,  // Texture is left/right
+	VROverlayFlags_SideBySide_Crossed = 11,   // Texture is crossed and right/left
+
+	VROverlayFlags_Panorama = 12,        // Texture is a panorama
+	VROverlayFlags_StereoPanorama = 13,  // Texture is a stereo panorama
+
+	// If this is set on an overlay owned by the scene application that overlay
+	// will be sorted with the "Other" overlays on top of all other scene overlays
+	VROverlayFlags_SortWithNonSceneOverlays = 14,
+
+	// If set, the overlay will be shown in the dashboard, otherwise it will be hidden.
+	VROverlayFlags_VisibleInDashboard = 15,
+};
+
+enum VRMessageOverlayResponse
+{
+	VRMessageOverlayResponse_ButtonPress_0 = 0,
+	VRMessageOverlayResponse_ButtonPress_1 = 1,
+	VRMessageOverlayResponse_ButtonPress_2 = 2,
+	VRMessageOverlayResponse_ButtonPress_3 = 3,
+	VRMessageOverlayResponse_CouldntFindSystemOverlay = 4,
+	VRMessageOverlayResponse_CouldntFindOrCreateClientOverlay = 5,
+	VRMessageOverlayResponse_ApplicationQuit = 6
+};
+
+struct VROverlayIntersectionParams_t
+{
+	HmdVector3_t vSource;
+	HmdVector3_t vDirection;
+	ETrackingUniverseOrigin eOrigin;
+};
+
+struct VROverlayIntersectionResults_t
+{
+	HmdVector3_t vPoint;
+	HmdVector3_t vNormal;
+	HmdVector2_t vUVs;
+	float fDistance;
+};
+
+// Input modes for the Big Picture gamepad text entry
+enum EGamepadTextInputMode
+{
+	k_EGamepadTextInputModeNormal = 0,
+	k_EGamepadTextInputModePassword = 1,
+	k_EGamepadTextInputModeSubmit = 2,
+};
+
+// Controls number of allowed lines for the Big Picture gamepad text entry
+enum EGamepadTextInputLineMode
+{
+	k_EGamepadTextInputLineModeSingleLine = 0,
+	k_EGamepadTextInputLineModeMultipleLines = 1
+};
+
+/** Directions for changing focus between overlays with the gamepad */
+enum EOverlayDirection
+{
+	OverlayDirection_Up = 0,
+	OverlayDirection_Down = 1,
+	OverlayDirection_Left = 2,
+	OverlayDirection_Right = 3,
+
+	OverlayDirection_Count = 4,
+};
+
+enum EVROverlayIntersectionMaskPrimitiveType
+{
+	OverlayIntersectionPrimitiveType_Rectangle,
+	OverlayIntersectionPrimitiveType_Circle,
+};
+
+struct IntersectionMaskRectangle_t
+{
+	float m_flTopLeftX;
+	float m_flTopLeftY;
+	float m_flWidth;
+	float m_flHeight;
+};
+
+struct IntersectionMaskCircle_t
+{
+	float m_flCenterX;
+	float m_flCenterY;
+	float m_flRadius;
+};
+
+/** NOTE!!! If you change this you MUST manually update openvr_interop.cs.py and openvr_api_flat.h.py */
+typedef union {
+	IntersectionMaskRectangle_t m_Rectangle;
+	IntersectionMaskCircle_t m_Circle;
+} VROverlayIntersectionMaskPrimitive_Data_t;
+
+struct VROverlayIntersectionMaskPrimitive_t
+{
+	EVROverlayIntersectionMaskPrimitiveType m_nPrimitiveType;
+	VROverlayIntersectionMaskPrimitive_Data_t m_Primitive;
+};
+
+class IVROverlay
+{
+public:
+	// ---------------------------------------------
+	// Overlay management methods
+	// ---------------------------------------------
+
+	/** Finds an existing overlay with the specified key. */
+	virtual EVROverlayError FindOverlay(const char *pchOverlayKey, VROverlayHandle_t *pOverlayHandle) = 0;
+
+	/** Creates a new named overlay. All overlays start hidden and with default settings. */
+	virtual EVROverlayError CreateOverlay(const char *pchOverlayKey, const char *pchOverlayName, VROverlayHandle_t *pOverlayHandle) = 0;
+
+	/** Destroys the specified overlay. When an application calls VR_Shutdown all overlays created by that app are
+		* automatically destroyed. */
+	virtual EVROverlayError DestroyOverlay(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Specify which overlay to use the high quality render path.  This overlay will be composited in during the distortion pass which
+		* results in it drawing on top of everything else, but also at a higher quality as it samples the source texture directly rather than
+		* rasterizing into each eye's render texture first.  Because if this, only one of these is supported at any given time.  It is most useful
+		* for overlays that are expected to take up most of the user's view (e.g. streaming video).
+		* This mode does not support mouse input to your overlay. */
+	virtual EVROverlayError SetHighQualityOverlay(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Returns the overlay handle of the current overlay being rendered using the single high quality overlay render path.
+		* Otherwise it will return k_ulOverlayHandleInvalid. */
+	virtual vr::VROverlayHandle_t GetHighQualityOverlay() = 0;
+
+	/** Fills the provided buffer with the string key of the overlay. Returns the size of buffer required to store the key, including
+		* the terminating null character. k_unVROverlayMaxKeyLength will be enough bytes to fit the string. */
+	virtual uint32_t GetOverlayKey(VROverlayHandle_t ulOverlayHandle, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, EVROverlayError *pError = 0L) = 0;
+
+	/** Fills the provided buffer with the friendly name of the overlay. Returns the size of buffer required to store the key, including
+		* the terminating null character. k_unVROverlayMaxNameLength will be enough bytes to fit the string. */
+	virtual uint32_t GetOverlayName(VROverlayHandle_t ulOverlayHandle, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, EVROverlayError *pError = 0L) = 0;
+
+	/** set the name to use for this overlay */
+	virtual EVROverlayError SetOverlayName(VROverlayHandle_t ulOverlayHandle, const char *pchName) = 0;
+
+	/** Gets the raw image data from an overlay. Overlay image data is always returned as RGBA data, 4 bytes per pixel. If the buffer is not large enough, width and height 
+		* will be set and VROverlayError_ArrayTooSmall is returned. */
+	virtual EVROverlayError GetOverlayImageData(VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unBufferSize, uint32_t *punWidth, uint32_t *punHeight) = 0;
+
+	/** returns a string that corresponds with the specified overlay error. The string will be the name 
+		* of the error enum value for all valid error codes */
+	virtual const char *GetOverlayErrorNameFromEnum(EVROverlayError error) = 0;
+
+	// ---------------------------------------------
+	// Overlay rendering methods
+	// ---------------------------------------------
+
+	/** Sets the pid that is allowed to render to this overlay (the creator pid is always allow to render),
+		*	by default this is the pid of the process that made the overlay */
+	virtual EVROverlayError SetOverlayRenderingPid(VROverlayHandle_t ulOverlayHandle, uint32_t unPID) = 0;
+
+	/** Gets the pid that is allowed to render to this overlay */
+	virtual uint32_t GetOverlayRenderingPid(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Specify flag setting for a given overlay */
+	virtual EVROverlayError SetOverlayFlag(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = 0;
+
+	/** Sets flag setting for a given overlay */
+	virtual EVROverlayError GetOverlayFlag(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool *pbEnabled) = 0;
+
+	/** Sets the color tint of the overlay quad. Use 0.0 to 1.0 per channel. */
+	virtual EVROverlayError SetOverlayColor(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = 0;
+
+	/** Gets the color tint of the overlay quad. */
+	virtual EVROverlayError GetOverlayColor(VROverlayHandle_t ulOverlayHandle, float *pfRed, float *pfGreen, float *pfBlue) = 0;
+
+	/** Sets the alpha of the overlay quad. Use 1.0 for 100 percent opacity to 0.0 for 0 percent opacity. */
+	virtual EVROverlayError SetOverlayAlpha(VROverlayHandle_t ulOverlayHandle, float fAlpha) = 0;
+
+	/** Gets the alpha of the overlay quad. By default overlays are rendering at 100 percent alpha (1.0). */
+	virtual EVROverlayError GetOverlayAlpha(VROverlayHandle_t ulOverlayHandle, float *pfAlpha) = 0;
+
+	/** Sets the aspect ratio of the texels in the overlay. 1.0 means the texels are square. 2.0 means the texels
+		* are twice as wide as they are tall. Defaults to 1.0. */
+	virtual EVROverlayError SetOverlayTexelAspect(VROverlayHandle_t ulOverlayHandle, float fTexelAspect) = 0;
+
+	/** Gets the aspect ratio of the texels in the overlay. Defaults to 1.0 */
+	virtual EVROverlayError GetOverlayTexelAspect(VROverlayHandle_t ulOverlayHandle, float *pfTexelAspect) = 0;
+
+	/** Sets the rendering sort order for the overlay. Overlays are rendered this order:
+		*      Overlays owned by the scene application
+		*      Overlays owned by some other application
+		*
+		*	Within a category overlays are rendered lowest sort order to highest sort order. Overlays with the same 
+		*	sort order are rendered back to front base on distance from the HMD.
+		*
+		*	Sort order defaults to 0. */
+	virtual EVROverlayError SetOverlaySortOrder(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder) = 0;
+
+	/** Gets the sort order of the overlay. See SetOverlaySortOrder for how this works. */
+	virtual EVROverlayError GetOverlaySortOrder(VROverlayHandle_t ulOverlayHandle, uint32_t *punSortOrder) = 0;
+
+	/** Sets the width of the overlay quad in meters. By default overlays are rendered on a quad that is 1 meter across */
+	virtual EVROverlayError SetOverlayWidthInMeters(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = 0;
+
+	/** Returns the width of the overlay quad in meters. By default overlays are rendered on a quad that is 1 meter across */
+	virtual EVROverlayError GetOverlayWidthInMeters(VROverlayHandle_t ulOverlayHandle, float *pfWidthInMeters) = 0;
+
+	/** For high-quality curved overlays only, sets the distance range in meters from the overlay used to automatically curve
+		* the surface around the viewer.  Min is distance is when the surface will be most curved.  Max is when least curved. */
+	virtual EVROverlayError SetOverlayAutoCurveDistanceRangeInMeters(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = 0;
+
+	/** For high-quality curved overlays only, gets the distance range in meters from the overlay used to automatically curve
+		* the surface around the viewer.  Min is distance is when the surface will be most curved.  Max is when least curved. */
+	virtual EVROverlayError GetOverlayAutoCurveDistanceRangeInMeters(VROverlayHandle_t ulOverlayHandle, float *pfMinDistanceInMeters, float *pfMaxDistanceInMeters) = 0;
+
+	/** Sets the colorspace the overlay texture's data is in.  Defaults to 'auto'.
+		* If the texture needs to be resolved, you should call SetOverlayTexture with the appropriate colorspace instead. */
+	virtual EVROverlayError SetOverlayTextureColorSpace(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = 0;
+
+	/** Gets the overlay's current colorspace setting. */
+	virtual EVROverlayError GetOverlayTextureColorSpace(VROverlayHandle_t ulOverlayHandle, EColorSpace *peTextureColorSpace) = 0;
+
+	/** Sets the part of the texture to use for the overlay. UV Min is the upper left corner and UV Max is the lower right corner. */
+	virtual EVROverlayError SetOverlayTextureBounds(VROverlayHandle_t ulOverlayHandle, const VRTextureBounds_t *pOverlayTextureBounds) = 0;
+
+	/** Gets the part of the texture to use for the overlay. UV Min is the upper left corner and UV Max is the lower right corner. */
+	virtual EVROverlayError GetOverlayTextureBounds(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t *pOverlayTextureBounds) = 0;
+
+	/** Gets render model to draw behind this overlay */
+	virtual uint32_t GetOverlayRenderModel(vr::VROverlayHandle_t ulOverlayHandle, char *pchValue, uint32_t unBufferSize, HmdColor_t *pColor, vr::EVROverlayError *pError) = 0;
+
+	/** Sets render model to draw behind this overlay and the vertex color to use, pass null for pColor to match the overlays vertex color. 
+			The model is scaled by the same amount as the overlay, with a default of 1m. */
+	virtual vr::EVROverlayError SetOverlayRenderModel(vr::VROverlayHandle_t ulOverlayHandle, const char *pchRenderModel, const HmdColor_t *pColor) = 0;
+
+	/** Returns the transform type of this overlay. */
+	virtual EVROverlayError GetOverlayTransformType(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType *peTransformType) = 0;
+
+	/** Sets the transform to absolute tracking origin. */
+	virtual EVROverlayError SetOverlayTransformAbsolute(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, const HmdMatrix34_t *pmatTrackingOriginToOverlayTransform) = 0;
+
+	/** Gets the transform if it is absolute. Returns an error if the transform is some other type. */
+	virtual EVROverlayError GetOverlayTransformAbsolute(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin *peTrackingOrigin, HmdMatrix34_t *pmatTrackingOriginToOverlayTransform) = 0;
+
+	/** Sets the transform to relative to the transform of the specified tracked device. */
+	virtual EVROverlayError SetOverlayTransformTrackedDeviceRelative(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, const HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform) = 0;
+
+	/** Gets the transform if it is relative to a tracked device. Returns an error if the transform is some other type. */
+	virtual EVROverlayError GetOverlayTransformTrackedDeviceRelative(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punTrackedDevice, HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform) = 0;
+
+	/** Sets the transform to draw the overlay on a rendermodel component mesh instead of a quad. This will only draw when the system is
+		* drawing the device. Overlays with this transform type cannot receive mouse events. */
+	virtual EVROverlayError SetOverlayTransformTrackedDeviceComponent(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char *pchComponentName) = 0;
+
+	/** Gets the transform information when the overlay is rendering on a component. */
+	virtual EVROverlayError GetOverlayTransformTrackedDeviceComponent(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punDeviceIndex, char *pchComponentName, uint32_t unComponentNameSize) = 0;
+
+	/** Gets the transform if it is relative to another overlay. Returns an error if the transform is some other type. */
+	virtual vr::EVROverlayError GetOverlayTransformOverlayRelative(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t *ulOverlayHandleParent, HmdMatrix34_t *pmatParentOverlayToOverlayTransform) = 0;
+
+	/** Sets the transform to relative to the transform of the specified overlay. This overlays visibility will also track the parents visibility */
+	virtual vr::EVROverlayError SetOverlayTransformOverlayRelative(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, const HmdMatrix34_t *pmatParentOverlayToOverlayTransform) = 0;
+
+	/** Shows the VR overlay.  For dashboard overlays, only the Dashboard Manager is allowed to call this. */
+	virtual EVROverlayError ShowOverlay(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Hides the VR overlay.  For dashboard overlays, only the Dashboard Manager is allowed to call this. */
+	virtual EVROverlayError HideOverlay(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Returns true if the overlay is visible. */
+	virtual bool IsOverlayVisible(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Get the transform in 3d space associated with a specific 2d point in the overlay's coordinate space (where 0,0 is the lower left). -Z points out of the overlay */
+	virtual EVROverlayError GetTransformForOverlayCoordinates(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t *pmatTransform) = 0;
+
+	// ---------------------------------------------
+	// Overlay input methods
+	// ---------------------------------------------
+
+	/** Returns true and fills the event with the next event on the overlay's event queue, if there is one. 
+		* If there are no events this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct */
+	virtual bool PollNextOverlayEvent(VROverlayHandle_t ulOverlayHandle, VREvent_t *pEvent, uint32_t uncbVREvent) = 0;
+
+	/** Returns the current input settings for the specified overlay. */
+	virtual EVROverlayError GetOverlayInputMethod(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod *peInputMethod) = 0;
+
+	/** Sets the input settings for the specified overlay. */
+	virtual EVROverlayError SetOverlayInputMethod(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = 0;
+
+	/** Gets the mouse scaling factor that is used for mouse events. The actual texture may be a different size, but this is
+		* typically the size of the underlying UI in pixels. */
+	virtual EVROverlayError GetOverlayMouseScale(VROverlayHandle_t ulOverlayHandle, HmdVector2_t *pvecMouseScale) = 0;
+
+	/** Sets the mouse scaling factor that is used for mouse events. The actual texture may be a different size, but this is
+		* typically the size of the underlying UI in pixels (not in world space). */
+	virtual EVROverlayError SetOverlayMouseScale(VROverlayHandle_t ulOverlayHandle, const HmdVector2_t *pvecMouseScale) = 0;
+
+	/** Computes the overlay-space pixel coordinates of where the ray intersects the overlay with the
+		* specified settings. Returns false if there is no intersection. */
+	virtual bool ComputeOverlayIntersection(VROverlayHandle_t ulOverlayHandle, const VROverlayIntersectionParams_t *pParams, VROverlayIntersectionResults_t *pResults) = 0;
+
+	/** Processes mouse input from the specified controller as though it were a mouse pointed at a compositor overlay with the
+		* specified settings. The controller is treated like a laser pointer on the -z axis. The point where the laser pointer would
+		* intersect with the overlay is the mouse position, the trigger is left mouse, and the track pad is right mouse. 
+		*
+		* Return true if the controller is pointed at the overlay and an event was generated. */
+	virtual bool HandleControllerOverlayInteractionAsMouse(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = 0;
+
+	/** Returns true if the specified overlay is the hover target. An overlay is the hover target when it is the last overlay "moused over" 
+		* by the virtual mouse pointer */
+	virtual bool IsHoverTargetOverlay(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Returns the current Gamepad focus overlay */
+	virtual vr::VROverlayHandle_t GetGamepadFocusOverlay() = 0;
+
+	/** Sets the current Gamepad focus overlay */
+	virtual EVROverlayError SetGamepadFocusOverlay(VROverlayHandle_t ulNewFocusOverlay) = 0;
+
+	/** Sets an overlay's neighbor. This will also set the neighbor of the "to" overlay
+		* to point back to the "from" overlay. If an overlay's neighbor is set to invalid both
+		* ends will be cleared */
+	virtual EVROverlayError SetOverlayNeighbor(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo) = 0;
+
+	/** Changes the Gamepad focus from one overlay to one of its neighbors. Returns VROverlayError_NoNeighbor if there is no
+		* neighbor in that direction */
+	virtual EVROverlayError MoveGamepadFocusToNeighbor(EOverlayDirection eDirection, VROverlayHandle_t ulFrom) = 0;
+
+	// ---------------------------------------------
+	// Overlay texture methods
+	// ---------------------------------------------
+
+	/** Texture to draw for the overlay. This function can only be called by the overlay's creator or renderer process (see SetOverlayRenderingPid) .
+		*
+		* OpenGL dirty state:
+		*	glBindTexture
+		*/
+	virtual EVROverlayError SetOverlayTexture(VROverlayHandle_t ulOverlayHandle, const Texture_t *pTexture) = 0;
+
+	/** Use this to tell the overlay system to release the texture set for this overlay. */
+	virtual EVROverlayError ClearOverlayTexture(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Separate interface for providing the data as a stream of bytes, but there is an upper bound on data 
+		* that can be sent. This function can only be called by the overlay's renderer process. */
+	virtual EVROverlayError SetOverlayRaw(VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = 0;
+
+	/** Separate interface for providing the image through a filename: can be png or jpg, and should not be bigger than 1920x1080.
+		* This function can only be called by the overlay's renderer process */
+	virtual EVROverlayError SetOverlayFromFile(VROverlayHandle_t ulOverlayHandle, const char *pchFilePath) = 0;
+
+	/** Get the native texture handle/device for an overlay you have created.
+		* On windows this handle will be a ID3D11ShaderResourceView with a ID3D11Texture2D bound.
+		*
+		* The texture will always be sized to match the backing texture you supplied in SetOverlayTexture above.
+		*
+		* You MUST call ReleaseNativeOverlayHandle() with pNativeTextureHandle once you are done with this texture.
+		*
+		* pNativeTextureHandle is an OUTPUT, it will be a pointer to a ID3D11ShaderResourceView *.
+		* pNativeTextureRef is an INPUT and should be a ID3D11Resource *. The device used by pNativeTextureRef will be used to bind pNativeTextureHandle.
+		*/
+	virtual EVROverlayError GetOverlayTexture(VROverlayHandle_t ulOverlayHandle, void **pNativeTextureHandle, void *pNativeTextureRef, uint32_t *pWidth, uint32_t *pHeight, uint32_t *pNativeFormat, ETextureType *pAPIType, EColorSpace *pColorSpace, VRTextureBounds_t *pTextureBounds) = 0;
+
+	/** Release the pNativeTextureHandle provided from the GetOverlayTexture call, this allows the system to free the underlying GPU resources for this object,
+		* so only do it once you stop rendering this texture.
+		*/
+	virtual EVROverlayError ReleaseNativeOverlayHandle(VROverlayHandle_t ulOverlayHandle, void *pNativeTextureHandle) = 0;
+
+	/** Get the size of the overlay texture */
+	virtual EVROverlayError GetOverlayTextureSize(VROverlayHandle_t ulOverlayHandle, uint32_t *pWidth, uint32_t *pHeight) = 0;
+
+	// ----------------------------------------------
+	// Dashboard Overlay Methods
+	// ----------------------------------------------
+
+	/** Creates a dashboard overlay and returns its handle */
+	virtual EVROverlayError CreateDashboardOverlay(const char *pchOverlayKey, const char *pchOverlayFriendlyName, VROverlayHandle_t *pMainHandle, VROverlayHandle_t *pThumbnailHandle) = 0;
+
+	/** Returns true if the dashboard is visible */
+	virtual bool IsDashboardVisible() = 0;
+
+	/** returns true if the dashboard is visible and the specified overlay is the active system Overlay */
+	virtual bool IsActiveDashboardOverlay(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Sets the dashboard overlay to only appear when the specified process ID has scene focus */
+	virtual EVROverlayError SetDashboardOverlaySceneProcess(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = 0;
+
+	/** Gets the process ID that this dashboard overlay requires to have scene focus */
+	virtual EVROverlayError GetDashboardOverlaySceneProcess(VROverlayHandle_t ulOverlayHandle, uint32_t *punProcessId) = 0;
+
+	/** Shows the dashboard. */
+	virtual void ShowDashboard(const char *pchOverlayToShow) = 0;
+
+	/** Returns the tracked device that has the laser pointer in the dashboard */
+	virtual vr::TrackedDeviceIndex_t GetPrimaryDashboardDevice() = 0;
+
+	// ---------------------------------------------
+	// Keyboard methods
+	// ---------------------------------------------
+
+	/** Show the virtual keyboard to accept input **/
+	virtual EVROverlayError ShowKeyboard(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char *pchDescription, uint32_t unCharMax, const char *pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = 0;
+
+	virtual EVROverlayError ShowKeyboardForOverlay(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char *pchDescription, uint32_t unCharMax, const char *pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = 0;
+
+	/** Get the text that was entered into the text input **/
+	virtual uint32_t GetKeyboardText(VR_OUT_STRING() char *pchText, uint32_t cchText) = 0;
+
+	/** Hide the virtual keyboard **/
+	virtual void HideKeyboard() = 0;
+
+	/** Set the position of the keyboard in world space **/
+	virtual void SetKeyboardTransformAbsolute(ETrackingUniverseOrigin eTrackingOrigin, const HmdMatrix34_t *pmatTrackingOriginToKeyboardTransform) = 0;
+
+	/** Set the position of the keyboard in overlay space by telling it to avoid a rectangle in the overlay. Rectangle coords have (0,0) in the bottom left **/
+	virtual void SetKeyboardPositionForOverlay(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = 0;
+
+	// ---------------------------------------------
+	// Overlay input methods
+	// ---------------------------------------------
+
+	/** Sets a list of primitives to be used for controller ray intersection
+		* typically the size of the underlying UI in pixels (not in world space). */
+	virtual EVROverlayError SetOverlayIntersectionMask(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t *pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize = sizeof(VROverlayIntersectionMaskPrimitive_t)) = 0;
+
+	virtual EVROverlayError GetOverlayFlags(VROverlayHandle_t ulOverlayHandle, uint32_t *pFlags) = 0;
+
+	// ---------------------------------------------
+	// Message box methods
+	// ---------------------------------------------
+
+	/** Show the message overlay. This will block and return you a result. **/
+	virtual VRMessageOverlayResponse ShowMessageOverlay(const char *pchText, const char *pchCaption, const char *pchButton0Text, const char *pchButton1Text = nullptr, const char *pchButton2Text = nullptr, const char *pchButton3Text = nullptr) = 0;
+
+	/** If the calling process owns the overlay and it's open, this will close it. **/
+	virtual void CloseMessageOverlay() = 0;
+};
+
+static const char *const IVROverlay_Version = "IVROverlay_016";
+
+}  // namespace vr
+
+// ivrrendermodels.h
+namespace vr
+{
+static const char *const k_pch_Controller_Component_GDC2015 = "gdc2015";    // Canonical coordinate system of the gdc 2015 wired controller, provided for backwards compatibility
+static const char *const k_pch_Controller_Component_Base = "base";          // For controllers with an unambiguous 'base'.
+static const char *const k_pch_Controller_Component_Tip = "tip";            // For controllers with an unambiguous 'tip' (used for 'laser-pointing')
+static const char *const k_pch_Controller_Component_HandGrip = "handgrip";  // Neutral, ambidextrous hand-pose when holding controller. On plane between neutrally posed index finger and thumb
+static const char *const k_pch_Controller_Component_Status = "status";      // 1:1 aspect ratio status area, with canonical [0,1] uv mapping
+
+#pragma pack(push, 8)
+
+/** Errors that can occur with the VR compositor */
+enum EVRRenderModelError
+{
+	VRRenderModelError_None = 0,
+	VRRenderModelError_Loading = 100,
+	VRRenderModelError_NotSupported = 200,
+	VRRenderModelError_InvalidArg = 300,
+	VRRenderModelError_InvalidModel = 301,
+	VRRenderModelError_NoShapes = 302,
+	VRRenderModelError_MultipleShapes = 303,
+	VRRenderModelError_TooManyVertices = 304,
+	VRRenderModelError_MultipleTextures = 305,
+	VRRenderModelError_BufferTooSmall = 306,
+	VRRenderModelError_NotEnoughNormals = 307,
+	VRRenderModelError_NotEnoughTexCoords = 308,
+
+	VRRenderModelError_InvalidTexture = 400,
+};
+
+typedef uint32_t VRComponentProperties;
+
+enum EVRComponentProperty
+{
+	VRComponentProperty_IsStatic = (1 << 0),
+	VRComponentProperty_IsVisible = (1 << 1),
+	VRComponentProperty_IsTouched = (1 << 2),
+	VRComponentProperty_IsPressed = (1 << 3),
+	VRComponentProperty_IsScrolled = (1 << 4),
+};
+
+/** Describes state information about a render-model component, including transforms and other dynamic properties */
+struct RenderModel_ComponentState_t
+{
+	HmdMatrix34_t mTrackingToComponentRenderModel;  // Transform required when drawing the component render model
+	HmdMatrix34_t mTrackingToComponentLocal;        // Transform available for attaching to a local component coordinate system (-Z out from surface )
+	VRComponentProperties uProperties;
+};
+
+/** A single vertex in a render model */
+struct RenderModel_Vertex_t
+{
+	HmdVector3_t vPosition;  // position in meters in device space
+	HmdVector3_t vNormal;
+	float rfTextureCoord[2];
+};
+
+/** A texture map for use on a render model */
+#if defined(__linux__) || defined(__APPLE__)
+// This structure was originally defined mis-packed on Linux, preserved for
+// compatibility.
+#pragma pack(push, 4)
+#endif
+
+struct RenderModel_TextureMap_t
+{
+	uint16_t unWidth, unHeight;        // width and height of the texture map in pixels
+	const uint8_t *rubTextureMapData;  // Map texture data. All textures are RGBA with 8 bits per channel per pixel. Data size is width * height * 4ub
+};
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+
+/**  Session unique texture identifier. Rendermodels which share the same texture will have the same id.
+IDs <0 denote the texture is not present */
+
+typedef int32_t TextureID_t;
+
+const TextureID_t INVALID_TEXTURE_ID = -1;
+
+#if defined(__linux__) || defined(__APPLE__)
+// This structure was originally defined mis-packed on Linux, preserved for
+// compatibility.
+#pragma pack(push, 4)
+#endif
+
+struct RenderModel_t
+{
+	const RenderModel_Vertex_t *rVertexData;  // Vertex data for the mesh
+	uint32_t unVertexCount;                   // Number of vertices in the vertex data
+	const uint16_t *rIndexData;               // Indices into the vertex data for each triangle
+	uint32_t unTriangleCount;                 // Number of triangles in the mesh. Index count is 3 * TriangleCount
+	TextureID_t diffuseTextureId;             // Session unique texture identifier. Rendermodels which share the same texture will have the same id. <0 == texture not present
+};
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+
+struct RenderModel_ControllerMode_State_t
+{
+	bool bScrollWheelVisible;  // is this controller currently set to be in a scroll wheel mode
+};
+
+#pragma pack(pop)
+
+class IVRRenderModels
+{
+public:
+	/** Loads and returns a render model for use in the application. pchRenderModelName should be a render model name
+	* from the Prop_RenderModelName_String property or an absolute path name to a render model on disk. 
+	*
+	* The resulting render model is valid until VR_Shutdown() is called or until FreeRenderModel() is called. When the 
+	* application is finished with the render model it should call FreeRenderModel() to free the memory associated
+	* with the model.
+	*
+	* The method returns VRRenderModelError_Loading while the render model is still being loaded.
+	* The method returns VRRenderModelError_None once loaded successfully, otherwise will return an error. */
+	virtual EVRRenderModelError LoadRenderModel_Async(const char *pchRenderModelName, RenderModel_t **ppRenderModel) = 0;
+
+	/** Frees a previously returned render model
+	*   It is safe to call this on a null ptr. */
+	virtual void FreeRenderModel(RenderModel_t *pRenderModel) = 0;
+
+	/** Loads and returns a texture for use in the application. */
+	virtual EVRRenderModelError LoadTexture_Async(TextureID_t textureId, RenderModel_TextureMap_t **ppTexture) = 0;
+
+	/** Frees a previously returned texture
+	*   It is safe to call this on a null ptr. */
+	virtual void FreeTexture(RenderModel_TextureMap_t *pTexture) = 0;
+
+	/** Creates a D3D11 texture and loads data into it. */
+	virtual EVRRenderModelError LoadTextureD3D11_Async(TextureID_t textureId, void *pD3D11Device, void **ppD3D11Texture2D) = 0;
+
+	/** Helper function to copy the bits into an existing texture. */
+	virtual EVRRenderModelError LoadIntoTextureD3D11_Async(TextureID_t textureId, void *pDstTexture) = 0;
+
+	/** Use this to free textures created with LoadTextureD3D11_Async instead of calling Release on them. */
+	virtual void FreeTextureD3D11(void *pD3D11Texture2D) = 0;
+
+	/** Use this to get the names of available render models.  Index does not correlate to a tracked device index, but
+	* is only used for iterating over all available render models.  If the index is out of range, this function will return 0.
+	* Otherwise, it will return the size of the buffer required for the name. */
+	virtual uint32_t GetRenderModelName(uint32_t unRenderModelIndex, VR_OUT_STRING() char *pchRenderModelName, uint32_t unRenderModelNameLen) = 0;
+
+	/** Returns the number of available render models. */
+	virtual uint32_t GetRenderModelCount() = 0;
+
+	/** Returns the number of components of the specified render model.
+	*  Components are useful when client application wish to draw, label, or otherwise interact with components of tracked objects.
+	*  Examples controller components:
+	*   renderable things such as triggers, buttons
+	*   non-renderable things which include coordinate systems such as 'tip', 'base', a neutral controller agnostic hand-pose
+	*   If all controller components are enumerated and rendered, it will be equivalent to drawing the traditional render model
+	*   Returns 0 if components not supported, >0 otherwise */
+	virtual uint32_t GetComponentCount(const char *pchRenderModelName) = 0;
+
+	/** Use this to get the names of available components.  Index does not correlate to a tracked device index, but
+	* is only used for iterating over all available components.  If the index is out of range, this function will return 0.
+	* Otherwise, it will return the size of the buffer required for the name. */
+	virtual uint32_t GetComponentName(const char *pchRenderModelName, uint32_t unComponentIndex, VR_OUT_STRING() char *pchComponentName, uint32_t unComponentNameLen) = 0;
+
+	/** Get the button mask for all buttons associated with this component
+	*   If no buttons (or axes) are associated with this component, return 0
+	*   Note: multiple components may be associated with the same button. Ex: two grip buttons on a single controller.
+	*   Note: A single component may be associated with multiple buttons. Ex: A trackpad which also provides "D-pad" functionality */
+	virtual uint64_t GetComponentButtonMask(const char *pchRenderModelName, const char *pchComponentName) = 0;
+
+	/** Use this to get the render model name for the specified rendermode/component combination, to be passed to LoadRenderModel.
+	* If the component name is out of range, this function will return 0.
+	* Otherwise, it will return the size of the buffer required for the name. */
+	virtual uint32_t GetComponentRenderModelName(const char *pchRenderModelName, const char *pchComponentName, VR_OUT_STRING() char *pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen) = 0;
+
+	/** Use this to query information about the component, as a function of the controller state.
+	*
+	* For dynamic controller components (ex: trigger) values will reflect component motions
+	* For static components this will return a consistent value independent of the VRControllerState_t
+	*
+	* If the pchRenderModelName or pchComponentName is invalid, this will return false (and transforms will be set to identity).
+	* Otherwise, return true
+	* Note: For dynamic objects, visibility may be dynamic. (I.e., true/false will be returned based on controller state and controller mode state ) */
+	virtual bool GetComponentState(const char *pchRenderModelName, const char *pchComponentName, const vr::VRControllerState_t *pControllerState, const RenderModel_ControllerMode_State_t *pState, RenderModel_ComponentState_t *pComponentState) = 0;
+
+	/** Returns true if the render model has a component with the specified name */
+	virtual bool RenderModelHasComponent(const char *pchRenderModelName, const char *pchComponentName) = 0;
+
+	/** Returns the URL of the thumbnail image for this rendermodel */
+	virtual uint32_t GetRenderModelThumbnailURL(const char *pchRenderModelName, VR_OUT_STRING() char *pchThumbnailURL, uint32_t unThumbnailURLLen, vr::EVRRenderModelError *peError) = 0;
+
+	/** Provides a render model path that will load the unskinned model if the model name provided has been replace by the user. If the model
+	* hasn't been replaced the path value will still be a valid path to load the model. Pass this to LoadRenderModel_Async, etc. to load the
+	* model. */
+	virtual uint32_t GetRenderModelOriginalPath(const char *pchRenderModelName, VR_OUT_STRING() char *pchOriginalPath, uint32_t unOriginalPathLen, vr::EVRRenderModelError *peError) = 0;
+
+	/** Returns a string for a render model error */
+	virtual const char *GetRenderModelErrorNameFromEnum(vr::EVRRenderModelError error) = 0;
+};
+
+static const char *const IVRRenderModels_Version = "IVRRenderModels_005";
+
+}  // namespace vr
+
+// ivrextendeddisplay.h
+namespace vr
+{
+/** NOTE: Use of this interface is not recommended in production applications. It will not work for displays which use
+	* direct-to-display mode. Creating our own window is also incompatible with the VR compositor and is not available when the compositor is running. */
+class IVRExtendedDisplay
+{
+public:
+	/** Size and position that the window needs to be on the VR display. */
+	virtual void GetWindowBounds(int32_t *pnX, int32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight) = 0;
+
+	/** Gets the viewport in the frame buffer to draw the output of the distortion into */
+	virtual void GetEyeOutputViewport(EVREye eEye, uint32_t *pnX, uint32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight) = 0;
+
+	/** [D3D10/11 Only]
+		* Returns the adapter index and output index that the user should pass into EnumAdapters and EnumOutputs
+		* to create the device and swap chain in DX10 and DX11. If an error occurs both indices will be set to -1.
+		*/
+	virtual void GetDXGIOutputInfo(int32_t *pnAdapterIndex, int32_t *pnAdapterOutputIndex) = 0;
+};
+
+static const char *const IVRExtendedDisplay_Version = "IVRExtendedDisplay_001";
+
+}  // namespace vr
+
+// ivrtrackedcamera.h
+namespace vr
+{
+class IVRTrackedCamera
+{
+public:
+	/** Returns a string for an error */
+	virtual const char *GetCameraErrorNameFromEnum(vr::EVRTrackedCameraError eCameraError) = 0;
+
+	/** For convenience, same as tracked property request Prop_HasCamera_Bool */
+	virtual vr::EVRTrackedCameraError HasCamera(vr::TrackedDeviceIndex_t nDeviceIndex, bool *pHasCamera) = 0;
+
+	/** Gets size of the image frame. */
+	virtual vr::EVRTrackedCameraError GetCameraFrameSize(vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, uint32_t *pnWidth, uint32_t *pnHeight, uint32_t *pnFrameBufferSize) = 0;
+
+	virtual vr::EVRTrackedCameraError GetCameraIntrinsics(vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, vr::HmdVector2_t *pFocalLength, vr::HmdVector2_t *pCenter) = 0;
+
+	virtual vr::EVRTrackedCameraError GetCameraProjection(vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, vr::HmdMatrix44_t *pProjection) = 0;
+
+	/** Acquiring streaming service permits video streaming for the caller. Releasing hints the system that video services do not need to be maintained for this client.
+	* If the camera has not already been activated, a one time spin up may incur some auto exposure as well as initial streaming frame delays.
+	* The camera should be considered a global resource accessible for shared consumption but not exclusive to any caller.
+	* The camera may go inactive due to lack of active consumers or headset idleness. */
+	virtual vr::EVRTrackedCameraError AcquireVideoStreamingService(vr::TrackedDeviceIndex_t nDeviceIndex, vr::TrackedCameraHandle_t *pHandle) = 0;
+	virtual vr::EVRTrackedCameraError ReleaseVideoStreamingService(vr::TrackedCameraHandle_t hTrackedCamera) = 0;
+
+	/** Copies the image frame into a caller's provided buffer. The image data is currently provided as RGBA data, 4 bytes per pixel.
+	* A caller can provide null for the framebuffer or frameheader if not desired. Requesting the frame header first, followed by the frame buffer allows
+	* the caller to determine if the frame as advanced per the frame header sequence. 
+	* If there is no frame available yet, due to initial camera spinup or re-activation, the error will be VRTrackedCameraError_NoFrameAvailable.
+	* Ideally a caller should be polling at ~16ms intervals */
+	virtual vr::EVRTrackedCameraError GetVideoStreamFrameBuffer(vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, void *pFrameBuffer, uint32_t nFrameBufferSize, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize) = 0;
+
+	/** Gets size of the image frame. */
+	virtual vr::EVRTrackedCameraError GetVideoStreamTextureSize(vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, vr::VRTextureBounds_t *pTextureBounds, uint32_t *pnWidth, uint32_t *pnHeight) = 0;
+
+	/** Access a shared D3D11 texture for the specified tracked camera stream.
+	* The camera frame type VRTrackedCameraFrameType_Undistorted is not supported directly as a shared texture. It is an interior subregion of the shared texture VRTrackedCameraFrameType_MaximumUndistorted.
+	* Instead, use GetVideoStreamTextureSize() with VRTrackedCameraFrameType_Undistorted to determine the proper interior subregion bounds along with GetVideoStreamTextureD3D11() with
+	* VRTrackedCameraFrameType_MaximumUndistorted to provide the texture. The VRTrackedCameraFrameType_MaximumUndistorted will yield an image where the invalid regions are decoded
+	* by the alpha channel having a zero component. The valid regions all have a non-zero alpha component. The subregion as described by VRTrackedCameraFrameType_Undistorted 
+	* guarantees a rectangle where all pixels are valid. */
+	virtual vr::EVRTrackedCameraError GetVideoStreamTextureD3D11(vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize) = 0;
+
+	/** Access a shared GL texture for the specified tracked camera stream */
+	virtual vr::EVRTrackedCameraError GetVideoStreamTextureGL(vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, vr::glUInt_t *pglTextureId, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize) = 0;
+	virtual vr::EVRTrackedCameraError ReleaseVideoStreamTextureGL(vr::TrackedCameraHandle_t hTrackedCamera, vr::glUInt_t glTextureId) = 0;
+};
+
+static const char *const IVRTrackedCamera_Version = "IVRTrackedCamera_003";
+
+}  // namespace vr
+
+// ivrscreenshots.h
+namespace vr
+{
+/** Errors that can occur with the VR compositor */
+enum EVRScreenshotError
+{
+	VRScreenshotError_None = 0,
+	VRScreenshotError_RequestFailed = 1,
+	VRScreenshotError_IncompatibleVersion = 100,
+	VRScreenshotError_NotFound = 101,
+	VRScreenshotError_BufferTooSmall = 102,
+	VRScreenshotError_ScreenshotAlreadyInProgress = 108,
+};
+
+/** Allows the application to generate screenshots */
+class IVRScreenshots
+{
+public:
+	/** Request a screenshot of the requested type.
+	 *  A request of the VRScreenshotType_Stereo type will always
+	 *  work. Other types will depend on the underlying application
+	 *  support.
+	 *  The first file name is for the preview image and should be a
+	 *  regular screenshot (ideally from the left eye). The second
+	 *  is the VR screenshot in the correct format. They should be
+	 *  in the same aspect ratio.  Formats per type:
+	 *  VRScreenshotType_Mono: the VR filename is ignored (can be
+	 *  nullptr), this is a normal flat single shot.
+	 *  VRScreenshotType_Stereo:  The VR image should be a
+	 *  side-by-side with the left eye image on the left.
+	 *  VRScreenshotType_Cubemap: The VR image should be six square
+	 *  images composited horizontally.
+	 *  VRScreenshotType_StereoPanorama: above/below with left eye
+	 *  panorama being the above image.  Image is typically square
+	 *  with the panorama being 2x horizontal.
+	 *  
+	 *  Note that the VR dashboard will call this function when
+	 *  the user presses the screenshot binding (currently System
+	 *  Button + Trigger).  If Steam is running, the destination
+	 *  file names will be in %TEMP% and will be copied into
+	 *  Steam's screenshot library for the running application
+	 *  once SubmitScreenshot() is called.
+	 *  If Steam is not running, the paths will be in the user's
+	 *  documents folder under Documents\SteamVR\Screenshots.
+	 *  Other VR applications can call this to initiate a
+	 *  screenshot outside of user control.
+	 *  The destination file names do not need an extension,
+	 *  will be replaced with the correct one for the format
+	 *  which is currently .png. */
+	virtual vr::EVRScreenshotError RequestScreenshot(vr::ScreenshotHandle_t *pOutScreenshotHandle, vr::EVRScreenshotType type, const char *pchPreviewFilename, const char *pchVRFilename) = 0;
+
+	/** Called by the running VR application to indicate that it
+	 *  wishes to be in charge of screenshots.  If the
+	 *  application does not call this, the Compositor will only
+	 *  support VRScreenshotType_Stereo screenshots that will be
+	 *  captured without notification to the running app.
+	 *  Once hooked your application will receive a
+	 *  VREvent_RequestScreenshot event when the user presses the
+	 *  buttons to take a screenshot. */
+	virtual vr::EVRScreenshotError HookScreenshot(VR_ARRAY_COUNT(numTypes) const vr::EVRScreenshotType *pSupportedTypes, int numTypes) = 0;
+
+	/** When your application receives a
+	 *  VREvent_RequestScreenshot event, call these functions to get
+	 *  the details of the screenshot request. */
+	virtual vr::EVRScreenshotType GetScreenshotPropertyType(vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotError *pError) = 0;
+
+	/** Get the filename for the preview or vr image (see
+	 *  vr::EScreenshotPropertyFilenames).  The return value is
+	 *  the size of the string.   */
+	virtual uint32_t GetScreenshotPropertyFilename(vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotPropertyFilenames filenameType, VR_OUT_STRING() char *pchFilename, uint32_t cchFilename, vr::EVRScreenshotError *pError) = 0;
+
+	/** Call this if the application is taking the screen shot
+	 *  will take more than a few ms processing. This will result
+	 *  in an overlay being presented that shows a completion
+	 *  bar. */
+	virtual vr::EVRScreenshotError UpdateScreenshotProgress(vr::ScreenshotHandle_t screenshotHandle, float flProgress) = 0;
+
+	/** Tells the compositor to take an internal screenshot of
+	 *  type VRScreenshotType_Stereo. It will take the current
+	 *  submitted scene textures of the running application and
+	 *  write them into the preview image and a side-by-side file
+	 *  for the VR image.
+	 *  This is similar to request screenshot, but doesn't ever
+	 *  talk to the application, just takes the shot and submits. */
+	virtual vr::EVRScreenshotError TakeStereoScreenshot(vr::ScreenshotHandle_t *pOutScreenshotHandle, const char *pchPreviewFilename, const char *pchVRFilename) = 0;
+
+	/** Submit the completed screenshot.  If Steam is running
+	 *  this will call into the Steam client and upload the
+	 *  screenshot to the screenshots section of the library for
+	 *  the running application.  If Steam is not running, this
+	 *  function will display a notification to the user that the
+	 *  screenshot was taken. The paths should be full paths with
+	 *  extensions.
+	 *  File paths should be absolute including extensions.
+	 *  screenshotHandle can be k_unScreenshotHandleInvalid if this
+	 *  was a new shot taking by the app to be saved and not
+	 *  initiated by a user (achievement earned or something) */
+	virtual vr::EVRScreenshotError SubmitScreenshot(vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotType type, const char *pchSourcePreviewFilename, const char *pchSourceVRFilename) = 0;
+};
+
+static const char *const IVRScreenshots_Version = "IVRScreenshots_001";
+
+}  // namespace vr
+
+// ivrresources.h
+namespace vr
+{
+class IVRResources
+{
+public:
+	// ------------------------------------
+	// Shared Resource Methods
+	// ------------------------------------
+
+	/** Loads the specified resource into the provided buffer if large enough.
+	* Returns the size in bytes of the buffer required to hold the specified resource. */
+	virtual uint32_t LoadSharedResource(const char *pchResourceName, char *pchBuffer, uint32_t unBufferLen) = 0;
+
+	/** Provides the full path to the specified resource. Resource names can include named directories for
+	* drivers and other things, and this resolves all of those and returns the actual physical path. 
+	* pchResourceTypeDirectory is the subdirectory of resources to look in. */
+	virtual uint32_t GetResourceFullPath(const char *pchResourceName, const char *pchResourceTypeDirectory, char *pchPathBuffer, uint32_t unBufferLen) = 0;
+};
+
+static const char *const IVRResources_Version = "IVRResources_001";
+
+}  // namespace vr
+// ivrdrivermanager.h
+namespace vr
+{
+class IVRDriverManager
+{
+public:
+	virtual uint32_t GetDriverCount() const = 0;
+
+	/** Returns the length of the number of bytes necessary to hold this string including the trailing null. */
+	virtual uint32_t GetDriverName(vr::DriverId_t nDriver, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize) = 0;
+};
+
+static const char *const IVRDriverManager_Version = "IVRDriverManager_001";
+
+}  // namespace vr
+
+// End
+
+#endif  // _OPENVR_API
+
+namespace vr
+{
+/** Finds the active installation of the VR API and initializes it. The provided path must be absolute
+	* or relative to the current working directory. These are the local install versions of the equivalent
+	* functions in steamvr.h and will work without a local Steam install.
+	*
+	* This path is to the "root" of the VR API install. That's the directory with
+	* the "drivers" directory and a platform (i.e. "win32") directory in it, not the directory with the DLL itself.
+	*
+	* pStartupInfo is reserved for future use.
+	*/
+inline IVRSystem *VR_Init(EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo = nullptr);
+
+/** unloads vrclient.dll. Any interface pointers from the interface are
+	* invalid after this point */
+inline void VR_Shutdown();
+
+/** Returns true if there is an HMD attached. This check is as lightweight as possible and
+	* can be called outside of VR_Init/VR_Shutdown. It should be used when an application wants
+	* to know if initializing VR is a possibility but isn't ready to take that step yet.
+	*/
+VR_INTERFACE bool VR_CALLTYPE VR_IsHmdPresent();
+
+/** Returns true if the OpenVR runtime is installed. */
+VR_INTERFACE bool VR_CALLTYPE VR_IsRuntimeInstalled();
+
+/** Returns where the OpenVR runtime is installed. */
+VR_INTERFACE const char *VR_CALLTYPE VR_RuntimePath();
+
+/** Returns the name of the enum value for an EVRInitError. This function may be called outside of VR_Init()/VR_Shutdown(). */
+VR_INTERFACE const char *VR_CALLTYPE VR_GetVRInitErrorAsSymbol(EVRInitError error);
+
+/** Returns an English string for an EVRInitError. Applications should call VR_GetVRInitErrorAsSymbol instead and
+	* use that as a key to look up their own localized error message. This function may be called outside of VR_Init()/VR_Shutdown(). */
+VR_INTERFACE const char *VR_CALLTYPE VR_GetVRInitErrorAsEnglishDescription(EVRInitError error);
+
+/** Returns the interface of the specified version. This method must be called after VR_Init. The
+	* pointer returned is valid until VR_Shutdown is called.
+	*/
+VR_INTERFACE void *VR_CALLTYPE VR_GetGenericInterface(const char *pchInterfaceVersion, EVRInitError *peError);
+
+/** Returns whether the interface of the specified version exists.
+	*/
+VR_INTERFACE bool VR_CALLTYPE VR_IsInterfaceVersionValid(const char *pchInterfaceVersion);
+
+/** Returns a token that represents whether the VR interface handles need to be reloaded */
+VR_INTERFACE uint32_t VR_CALLTYPE VR_GetInitToken();
+
+// These typedefs allow old enum names from SDK 0.9.11 to be used in applications.
+// They will go away in the future.
+typedef EVRInitError HmdError;
+typedef EVREye Hmd_Eye;
+typedef EColorSpace ColorSpace;
+typedef ETrackingResult HmdTrackingResult;
+typedef ETrackedDeviceClass TrackedDeviceClass;
+typedef ETrackingUniverseOrigin TrackingUniverseOrigin;
+typedef ETrackedDeviceProperty TrackedDeviceProperty;
+typedef ETrackedPropertyError TrackedPropertyError;
+typedef EVRSubmitFlags VRSubmitFlags_t;
+typedef EVRState VRState_t;
+typedef ECollisionBoundsStyle CollisionBoundsStyle_t;
+typedef EVROverlayError VROverlayError;
+typedef EVRFirmwareError VRFirmwareError;
+typedef EVRCompositorError VRCompositorError;
+typedef EVRScreenshotError VRScreenshotsError;
+
+inline uint32_t &VRToken()
+{
+	static uint32_t token;
+	return token;
+}
+
+class COpenVRContext
+{
+public:
+	COpenVRContext() { Clear(); }
+	void Clear();
+
+	inline void CheckClear()
+	{
+		if (VRToken() != VR_GetInitToken())
+		{
+			Clear();
+			VRToken() = VR_GetInitToken();
+		}
+	}
+
+	IVRSystem *VRSystem()
+	{
+		CheckClear();
+		if (m_pVRSystem == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRSystem = (IVRSystem *)VR_GetGenericInterface(IVRSystem_Version, &eError);
+		}
+		return m_pVRSystem;
+	}
+	IVRChaperone *VRChaperone()
+	{
+		CheckClear();
+		if (m_pVRChaperone == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRChaperone = (IVRChaperone *)VR_GetGenericInterface(IVRChaperone_Version, &eError);
+		}
+		return m_pVRChaperone;
+	}
+
+	IVRChaperoneSetup *VRChaperoneSetup()
+	{
+		CheckClear();
+		if (m_pVRChaperoneSetup == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRChaperoneSetup = (IVRChaperoneSetup *)VR_GetGenericInterface(IVRChaperoneSetup_Version, &eError);
+		}
+		return m_pVRChaperoneSetup;
+	}
+
+	IVRCompositor *VRCompositor()
+	{
+		CheckClear();
+		if (m_pVRCompositor == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRCompositor = (IVRCompositor *)VR_GetGenericInterface(IVRCompositor_Version, &eError);
+		}
+		return m_pVRCompositor;
+	}
+
+	IVROverlay *VROverlay()
+	{
+		CheckClear();
+		if (m_pVROverlay == nullptr)
+		{
+			EVRInitError eError;
+			m_pVROverlay = (IVROverlay *)VR_GetGenericInterface(IVROverlay_Version, &eError);
+		}
+		return m_pVROverlay;
+	}
+
+	IVRResources *VRResources()
+	{
+		CheckClear();
+		if (m_pVRResources == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRResources = (IVRResources *)VR_GetGenericInterface(IVRResources_Version, &eError);
+		}
+		return m_pVRResources;
+	}
+
+	IVRScreenshots *VRScreenshots()
+	{
+		CheckClear();
+		if (m_pVRScreenshots == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRScreenshots = (IVRScreenshots *)VR_GetGenericInterface(IVRScreenshots_Version, &eError);
+		}
+		return m_pVRScreenshots;
+	}
+
+	IVRRenderModels *VRRenderModels()
+	{
+		CheckClear();
+		if (m_pVRRenderModels == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRRenderModels = (IVRRenderModels *)VR_GetGenericInterface(IVRRenderModels_Version, &eError);
+		}
+		return m_pVRRenderModels;
+	}
+
+	IVRExtendedDisplay *VRExtendedDisplay()
+	{
+		CheckClear();
+		if (m_pVRExtendedDisplay == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRExtendedDisplay = (IVRExtendedDisplay *)VR_GetGenericInterface(IVRExtendedDisplay_Version, &eError);
+		}
+		return m_pVRExtendedDisplay;
+	}
+
+	IVRSettings *VRSettings()
+	{
+		CheckClear();
+		if (m_pVRSettings == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRSettings = (IVRSettings *)VR_GetGenericInterface(IVRSettings_Version, &eError);
+		}
+		return m_pVRSettings;
+	}
+
+	IVRApplications *VRApplications()
+	{
+		CheckClear();
+		if (m_pVRApplications == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRApplications = (IVRApplications *)VR_GetGenericInterface(IVRApplications_Version, &eError);
+		}
+		return m_pVRApplications;
+	}
+
+	IVRTrackedCamera *VRTrackedCamera()
+	{
+		CheckClear();
+		if (m_pVRTrackedCamera == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRTrackedCamera = (IVRTrackedCamera *)VR_GetGenericInterface(IVRTrackedCamera_Version, &eError);
+		}
+		return m_pVRTrackedCamera;
+	}
+
+	IVRDriverManager *VRDriverManager()
+	{
+		CheckClear();
+		if (!m_pVRDriverManager)
+		{
+			EVRInitError eError;
+			m_pVRDriverManager = (IVRDriverManager *)VR_GetGenericInterface(IVRDriverManager_Version, &eError);
+		}
+		return m_pVRDriverManager;
+	}
+
+private:
+	IVRSystem *m_pVRSystem;
+	IVRChaperone *m_pVRChaperone;
+	IVRChaperoneSetup *m_pVRChaperoneSetup;
+	IVRCompositor *m_pVRCompositor;
+	IVROverlay *m_pVROverlay;
+	IVRResources *m_pVRResources;
+	IVRRenderModels *m_pVRRenderModels;
+	IVRExtendedDisplay *m_pVRExtendedDisplay;
+	IVRSettings *m_pVRSettings;
+	IVRApplications *m_pVRApplications;
+	IVRTrackedCamera *m_pVRTrackedCamera;
+	IVRScreenshots *m_pVRScreenshots;
+	IVRDriverManager *m_pVRDriverManager;
+};
+
+inline COpenVRContext &OpenVRInternal_ModuleContext()
+{
+	static void *ctx[sizeof(COpenVRContext) / sizeof(void *)];
+	return *(COpenVRContext *)ctx;  // bypass zero-init constructor
+}
+
+inline IVRSystem *VR_CALLTYPE VRSystem() { return OpenVRInternal_ModuleContext().VRSystem(); }
+inline IVRChaperone *VR_CALLTYPE VRChaperone() { return OpenVRInternal_ModuleContext().VRChaperone(); }
+inline IVRChaperoneSetup *VR_CALLTYPE VRChaperoneSetup() { return OpenVRInternal_ModuleContext().VRChaperoneSetup(); }
+inline IVRCompositor *VR_CALLTYPE VRCompositor() { return OpenVRInternal_ModuleContext().VRCompositor(); }
+inline IVROverlay *VR_CALLTYPE VROverlay() { return OpenVRInternal_ModuleContext().VROverlay(); }
+inline IVRScreenshots *VR_CALLTYPE VRScreenshots() { return OpenVRInternal_ModuleContext().VRScreenshots(); }
+inline IVRRenderModels *VR_CALLTYPE VRRenderModels() { return OpenVRInternal_ModuleContext().VRRenderModels(); }
+inline IVRApplications *VR_CALLTYPE VRApplications() { return OpenVRInternal_ModuleContext().VRApplications(); }
+inline IVRSettings *VR_CALLTYPE VRSettings() { return OpenVRInternal_ModuleContext().VRSettings(); }
+inline IVRResources *VR_CALLTYPE VRResources() { return OpenVRInternal_ModuleContext().VRResources(); }
+inline IVRExtendedDisplay *VR_CALLTYPE VRExtendedDisplay() { return OpenVRInternal_ModuleContext().VRExtendedDisplay(); }
+inline IVRTrackedCamera *VR_CALLTYPE VRTrackedCamera() { return OpenVRInternal_ModuleContext().VRTrackedCamera(); }
+inline IVRDriverManager *VR_CALLTYPE VRDriverManager() { return OpenVRInternal_ModuleContext().VRDriverManager(); }
+
+inline void COpenVRContext::Clear()
+{
+	m_pVRSystem = nullptr;
+	m_pVRChaperone = nullptr;
+	m_pVRChaperoneSetup = nullptr;
+	m_pVRCompositor = nullptr;
+	m_pVROverlay = nullptr;
+	m_pVRRenderModels = nullptr;
+	m_pVRExtendedDisplay = nullptr;
+	m_pVRSettings = nullptr;
+	m_pVRApplications = nullptr;
+	m_pVRTrackedCamera = nullptr;
+	m_pVRResources = nullptr;
+	m_pVRScreenshots = nullptr;
+	m_pVRDriverManager = nullptr;
+}
+
+VR_INTERFACE uint32_t VR_CALLTYPE VR_InitInternal2(EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo);
+VR_INTERFACE void VR_CALLTYPE VR_ShutdownInternal();
+
+/** Finds the active installation of vrclient.dll and initializes it */
+inline IVRSystem *VR_Init(EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo)
+{
+	IVRSystem *pVRSystem = nullptr;
+
+	EVRInitError eError;
+	VRToken() = VR_InitInternal2(&eError, eApplicationType, pStartupInfo);
+	COpenVRContext &ctx = OpenVRInternal_ModuleContext();
+	ctx.Clear();
+
+	if (eError == VRInitError_None)
+	{
+		if (VR_IsInterfaceVersionValid(IVRSystem_Version))
+		{
+			pVRSystem = VRSystem();
+		}
+		else
+		{
+			VR_ShutdownInternal();
+			eError = VRInitError_Init_InterfaceNotFound;
+		}
+	}
+
+	if (peError)
+		*peError = eError;
+	return pVRSystem;
+}
+
+/** unloads vrclient.dll. Any interface pointers from the interface are
+	* invalid after this point */
+inline void VR_Shutdown()
+{
+	VR_ShutdownInternal();
+}
+}  // namespace vr
diff --git a/engine/inc/bullet/ThirdPartyLibs/openvr/bin/osx64/OpenVR.framework/Headers/openvr_capi.h b/engine/inc/bullet/ThirdPartyLibs/openvr/bin/osx64/OpenVR.framework/Headers/openvr_capi.h
new file mode 100644
index 00000000..245365f4
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/openvr/bin/osx64/OpenVR.framework/Headers/openvr_capi.h
@@ -0,0 +1,1932 @@
+//======= Copyright (c) Valve Corporation, All rights reserved. ===============
+//
+// Purpose: Header for flatted SteamAPI. Use this for binding to other languages.
+// This file is auto-generated, do not edit it.
+//
+//=============================================================================
+
+#ifndef __OPENVR_API_FLAT_H__
+#define __OPENVR_API_FLAT_H__
+#if defined(_WIN32) || defined(__clang__)
+#pragma once
+#endif
+
+#ifdef __cplusplus
+#define EXTERN_C extern "C"
+#else
+#define EXTERN_C
+#endif
+
+#if defined(_WIN32)
+#define OPENVR_FNTABLE_CALLTYPE __stdcall
+#else
+#define OPENVR_FNTABLE_CALLTYPE
+#endif
+
+// OPENVR API export macro
+#if defined(_WIN32) && !defined(_X360)
+#if defined(OPENVR_API_EXPORTS)
+#define S_API EXTERN_C __declspec(dllexport)
+#elif defined(OPENVR_API_NODLL)
+#define S_API EXTERN_C
+#else
+#define S_API extern "C" __declspec(dllimport)
+#endif  // OPENVR_API_EXPORTS
+#elif defined(__GNUC__)
+#if defined(OPENVR_API_EXPORTS)
+#define S_API EXTERN_C __attribute__((visibility("default")))
+#else
+#define S_API EXTERN_C
+#endif  // OPENVR_API_EXPORTS
+#else   // !WIN32
+#if defined(OPENVR_API_EXPORTS)
+#define S_API EXTERN_C
+#else
+#define S_API EXTERN_C
+#endif  // OPENVR_API_EXPORTS
+#endif
+
+#include <stdint.h>
+
+#if defined(__WIN32)
+typedef char bool;
+#else
+#include <stdbool.h>
+#endif
+
+typedef uint64_t PropertyContainerHandle_t;
+typedef uint32_t PropertyTypeTag_t;
+typedef uint64_t VRActionHandle_t;
+typedef uint64_t VRActionSetHandle_t;
+typedef uint64_t VRInputOriginHandle_t;
+
+// OpenVR Constants
+
+static const unsigned int k_nDriverNone = 4294967295;
+static const unsigned int k_unMaxDriverDebugResponseSize = 32768;
+static const unsigned int k_unTrackedDeviceIndex_Hmd = 0;
+static const unsigned int k_unMaxTrackedDeviceCount = 16;
+static const unsigned int k_unTrackedDeviceIndexOther = 4294967294;
+static const unsigned int k_unTrackedDeviceIndexInvalid = 4294967295;
+static const unsigned long k_ulInvalidPropertyContainer = 0;
+static const unsigned int k_unInvalidPropertyTag = 0;
+static const unsigned int k_unFloatPropertyTag = 1;
+static const unsigned int k_unInt32PropertyTag = 2;
+static const unsigned int k_unUint64PropertyTag = 3;
+static const unsigned int k_unBoolPropertyTag = 4;
+static const unsigned int k_unStringPropertyTag = 5;
+static const unsigned int k_unHmdMatrix34PropertyTag = 20;
+static const unsigned int k_unHmdMatrix44PropertyTag = 21;
+static const unsigned int k_unHmdVector3PropertyTag = 22;
+static const unsigned int k_unHmdVector4PropertyTag = 23;
+static const unsigned int k_unHiddenAreaPropertyTag = 30;
+static const unsigned int k_unOpenVRInternalReserved_Start = 1000;
+static const unsigned int k_unOpenVRInternalReserved_End = 10000;
+static const unsigned int k_unMaxPropertyStringSize = 32768;
+static const unsigned int k_unControllerStateAxisCount = 5;
+static const unsigned long k_ulOverlayHandleInvalid = 0;
+static const unsigned int k_unScreenshotHandleInvalid = 0;
+static const char *IVRSystem_Version = "IVRSystem_017";
+static const char *IVRExtendedDisplay_Version = "IVRExtendedDisplay_001";
+static const char *IVRTrackedCamera_Version = "IVRTrackedCamera_003";
+static const unsigned int k_unMaxApplicationKeyLength = 128;
+static const char *k_pch_MimeType_HomeApp = "vr/home";
+static const char *k_pch_MimeType_GameTheater = "vr/game_theater";
+static const char *IVRApplications_Version = "IVRApplications_006";
+static const char *IVRChaperone_Version = "IVRChaperone_003";
+static const char *IVRChaperoneSetup_Version = "IVRChaperoneSetup_005";
+static const char *IVRCompositor_Version = "IVRCompositor_021";
+static const unsigned int k_unVROverlayMaxKeyLength = 128;
+static const unsigned int k_unVROverlayMaxNameLength = 128;
+static const unsigned int k_unMaxOverlayCount = 64;
+static const unsigned int k_unMaxOverlayIntersectionMaskPrimitivesCount = 32;
+static const char *IVROverlay_Version = "IVROverlay_016";
+static const char *k_pch_Controller_Component_GDC2015 = "gdc2015";
+static const char *k_pch_Controller_Component_Base = "base";
+static const char *k_pch_Controller_Component_Tip = "tip";
+static const char *k_pch_Controller_Component_HandGrip = "handgrip";
+static const char *k_pch_Controller_Component_Status = "status";
+static const char *IVRRenderModels_Version = "IVRRenderModels_005";
+static const unsigned int k_unNotificationTextMaxSize = 256;
+static const char *IVRNotifications_Version = "IVRNotifications_002";
+static const unsigned int k_unMaxSettingsKeyLength = 128;
+static const char *IVRSettings_Version = "IVRSettings_002";
+static const char *k_pch_SteamVR_Section = "steamvr";
+static const char *k_pch_SteamVR_RequireHmd_String = "requireHmd";
+static const char *k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver";
+static const char *k_pch_SteamVR_ForcedHmdKey_String = "forcedHmd";
+static const char *k_pch_SteamVR_DisplayDebug_Bool = "displayDebug";
+static const char *k_pch_SteamVR_DebugProcessPipe_String = "debugProcessPipe";
+static const char *k_pch_SteamVR_DisplayDebugX_Int32 = "displayDebugX";
+static const char *k_pch_SteamVR_DisplayDebugY_Int32 = "displayDebugY";
+static const char *k_pch_SteamVR_SendSystemButtonToAllApps_Bool = "sendSystemButtonToAllApps";
+static const char *k_pch_SteamVR_LogLevel_Int32 = "loglevel";
+static const char *k_pch_SteamVR_IPD_Float = "ipd";
+static const char *k_pch_SteamVR_Background_String = "background";
+static const char *k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection";
+static const char *k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight";
+static const char *k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius";
+static const char *k_pch_SteamVR_GridColor_String = "gridColor";
+static const char *k_pch_SteamVR_PlayAreaColor_String = "playAreaColor";
+static const char *k_pch_SteamVR_ShowStage_Bool = "showStage";
+static const char *k_pch_SteamVR_ActivateMultipleDrivers_Bool = "activateMultipleDrivers";
+static const char *k_pch_SteamVR_DirectMode_Bool = "directMode";
+static const char *k_pch_SteamVR_DirectModeEdidVid_Int32 = "directModeEdidVid";
+static const char *k_pch_SteamVR_DirectModeEdidPid_Int32 = "directModeEdidPid";
+static const char *k_pch_SteamVR_UsingSpeakers_Bool = "usingSpeakers";
+static const char *k_pch_SteamVR_SpeakersForwardYawOffsetDegrees_Float = "speakersForwardYawOffsetDegrees";
+static const char *k_pch_SteamVR_BaseStationPowerManagement_Bool = "basestationPowerManagement";
+static const char *k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses";
+static const char *k_pch_SteamVR_SupersampleScale_Float = "supersampleScale";
+static const char *k_pch_SteamVR_AllowAsyncReprojection_Bool = "allowAsyncReprojection";
+static const char *k_pch_SteamVR_AllowReprojection_Bool = "allowInterleavedReprojection";
+static const char *k_pch_SteamVR_ForceReprojection_Bool = "forceReprojection";
+static const char *k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking";
+static const char *k_pch_SteamVR_DefaultMirrorView_Int32 = "defaultMirrorView";
+static const char *k_pch_SteamVR_ShowMirrorView_Bool = "showMirrorView";
+static const char *k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry";
+static const char *k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch";
+static const char *k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch";
+static const char *k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch";
+static const char *k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard";
+static const char *k_pch_SteamVR_EnableHomeApp = "enableHomeApp";
+static const char *k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec";
+static const char *k_pch_SteamVR_RetailDemo_Bool = "retailDemo";
+static const char *k_pch_SteamVR_IpdOffset_Float = "ipdOffset";
+static const char *k_pch_SteamVR_AllowSupersampleFiltering_Bool = "allowSupersampleFiltering";
+static const char *k_pch_SteamVR_EnableLinuxVulkanAsync_Bool = "enableLinuxVulkanAsync";
+static const char *k_pch_Lighthouse_Section = "driver_lighthouse";
+static const char *k_pch_Lighthouse_DisableIMU_Bool = "disableimu";
+static const char *k_pch_Lighthouse_UseDisambiguation_String = "usedisambiguation";
+static const char *k_pch_Lighthouse_DisambiguationDebug_Int32 = "disambiguationdebug";
+static const char *k_pch_Lighthouse_PrimaryBasestation_Int32 = "primarybasestation";
+static const char *k_pch_Lighthouse_DBHistory_Bool = "dbhistory";
+static const char *k_pch_Null_Section = "driver_null";
+static const char *k_pch_Null_SerialNumber_String = "serialNumber";
+static const char *k_pch_Null_ModelNumber_String = "modelNumber";
+static const char *k_pch_Null_WindowX_Int32 = "windowX";
+static const char *k_pch_Null_WindowY_Int32 = "windowY";
+static const char *k_pch_Null_WindowWidth_Int32 = "windowWidth";
+static const char *k_pch_Null_WindowHeight_Int32 = "windowHeight";
+static const char *k_pch_Null_RenderWidth_Int32 = "renderWidth";
+static const char *k_pch_Null_RenderHeight_Int32 = "renderHeight";
+static const char *k_pch_Null_SecondsFromVsyncToPhotons_Float = "secondsFromVsyncToPhotons";
+static const char *k_pch_Null_DisplayFrequency_Float = "displayFrequency";
+static const char *k_pch_UserInterface_Section = "userinterface";
+static const char *k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop";
+static const char *k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray";
+static const char *k_pch_UserInterface_Screenshots_Bool = "screenshots";
+static const char *k_pch_UserInterface_ScreenshotType_Int = "screenshotType";
+static const char *k_pch_Notifications_Section = "notifications";
+static const char *k_pch_Notifications_DoNotDisturb_Bool = "DoNotDisturb";
+static const char *k_pch_Keyboard_Section = "keyboard";
+static const char *k_pch_Keyboard_TutorialCompletions = "TutorialCompletions";
+static const char *k_pch_Keyboard_ScaleX = "ScaleX";
+static const char *k_pch_Keyboard_ScaleY = "ScaleY";
+static const char *k_pch_Keyboard_OffsetLeftX = "OffsetLeftX";
+static const char *k_pch_Keyboard_OffsetRightX = "OffsetRightX";
+static const char *k_pch_Keyboard_OffsetY = "OffsetY";
+static const char *k_pch_Keyboard_Smoothing = "Smoothing";
+static const char *k_pch_Perf_Section = "perfcheck";
+static const char *k_pch_Perf_HeuristicActive_Bool = "heuristicActive";
+static const char *k_pch_Perf_NotifyInHMD_Bool = "warnInHMD";
+static const char *k_pch_Perf_NotifyOnlyOnce_Bool = "warnOnlyOnce";
+static const char *k_pch_Perf_AllowTimingStore_Bool = "allowTimingStore";
+static const char *k_pch_Perf_SaveTimingsOnExit_Bool = "saveTimingsOnExit";
+static const char *k_pch_Perf_TestData_Float = "perfTestData";
+static const char *k_pch_Perf_LinuxGPUProfiling_Bool = "linuxGPUProfiling";
+static const char *k_pch_CollisionBounds_Section = "collisionBounds";
+static const char *k_pch_CollisionBounds_Style_Int32 = "CollisionBoundsStyle";
+static const char *k_pch_CollisionBounds_GroundPerimeterOn_Bool = "CollisionBoundsGroundPerimeterOn";
+static const char *k_pch_CollisionBounds_CenterMarkerOn_Bool = "CollisionBoundsCenterMarkerOn";
+static const char *k_pch_CollisionBounds_PlaySpaceOn_Bool = "CollisionBoundsPlaySpaceOn";
+static const char *k_pch_CollisionBounds_FadeDistance_Float = "CollisionBoundsFadeDistance";
+static const char *k_pch_CollisionBounds_ColorGammaR_Int32 = "CollisionBoundsColorGammaR";
+static const char *k_pch_CollisionBounds_ColorGammaG_Int32 = "CollisionBoundsColorGammaG";
+static const char *k_pch_CollisionBounds_ColorGammaB_Int32 = "CollisionBoundsColorGammaB";
+static const char *k_pch_CollisionBounds_ColorGammaA_Int32 = "CollisionBoundsColorGammaA";
+static const char *k_pch_Camera_Section = "camera";
+static const char *k_pch_Camera_EnableCamera_Bool = "enableCamera";
+static const char *k_pch_Camera_EnableCameraInDashboard_Bool = "enableCameraInDashboard";
+static const char *k_pch_Camera_EnableCameraForCollisionBounds_Bool = "enableCameraForCollisionBounds";
+static const char *k_pch_Camera_EnableCameraForRoomView_Bool = "enableCameraForRoomView";
+static const char *k_pch_Camera_BoundsColorGammaR_Int32 = "cameraBoundsColorGammaR";
+static const char *k_pch_Camera_BoundsColorGammaG_Int32 = "cameraBoundsColorGammaG";
+static const char *k_pch_Camera_BoundsColorGammaB_Int32 = "cameraBoundsColorGammaB";
+static const char *k_pch_Camera_BoundsColorGammaA_Int32 = "cameraBoundsColorGammaA";
+static const char *k_pch_Camera_BoundsStrength_Int32 = "cameraBoundsStrength";
+static const char *k_pch_audio_Section = "audio";
+static const char *k_pch_audio_OnPlaybackDevice_String = "onPlaybackDevice";
+static const char *k_pch_audio_OnRecordDevice_String = "onRecordDevice";
+static const char *k_pch_audio_OnPlaybackMirrorDevice_String = "onPlaybackMirrorDevice";
+static const char *k_pch_audio_OffPlaybackDevice_String = "offPlaybackDevice";
+static const char *k_pch_audio_OffRecordDevice_String = "offRecordDevice";
+static const char *k_pch_audio_VIVEHDMIGain = "viveHDMIGain";
+static const char *k_pch_Power_Section = "power";
+static const char *k_pch_Power_PowerOffOnExit_Bool = "powerOffOnExit";
+static const char *k_pch_Power_TurnOffScreensTimeout_Float = "turnOffScreensTimeout";
+static const char *k_pch_Power_TurnOffControllersTimeout_Float = "turnOffControllersTimeout";
+static const char *k_pch_Power_ReturnToWatchdogTimeout_Float = "returnToWatchdogTimeout";
+static const char *k_pch_Power_AutoLaunchSteamVROnButtonPress = "autoLaunchSteamVROnButtonPress";
+static const char *k_pch_Power_PauseCompositorOnStandby_Bool = "pauseCompositorOnStandby";
+static const char *k_pch_Dashboard_Section = "dashboard";
+static const char *k_pch_Dashboard_EnableDashboard_Bool = "enableDashboard";
+static const char *k_pch_Dashboard_ArcadeMode_Bool = "arcadeMode";
+static const char *k_pch_modelskin_Section = "modelskins";
+static const char *k_pch_Driver_Enable_Bool = "enable";
+static const char *IVRScreenshots_Version = "IVRScreenshots_001";
+static const char *IVRResources_Version = "IVRResources_001";
+static const char *IVRDriverManager_Version = "IVRDriverManager_001";
+
+// OpenVR Enums
+
+typedef enum EVREye
+{
+	EVREye_Eye_Left = 0,
+	EVREye_Eye_Right = 1,
+} EVREye;
+
+typedef enum ETextureType
+{
+	ETextureType_TextureType_DirectX = 0,
+	ETextureType_TextureType_OpenGL = 1,
+	ETextureType_TextureType_Vulkan = 2,
+	ETextureType_TextureType_IOSurface = 3,
+	ETextureType_TextureType_DirectX12 = 4,
+} ETextureType;
+
+typedef enum EColorSpace
+{
+	EColorSpace_ColorSpace_Auto = 0,
+	EColorSpace_ColorSpace_Gamma = 1,
+	EColorSpace_ColorSpace_Linear = 2,
+} EColorSpace;
+
+typedef enum ETrackingResult
+{
+	ETrackingResult_TrackingResult_Uninitialized = 1,
+	ETrackingResult_TrackingResult_Calibrating_InProgress = 100,
+	ETrackingResult_TrackingResult_Calibrating_OutOfRange = 101,
+	ETrackingResult_TrackingResult_Running_OK = 200,
+	ETrackingResult_TrackingResult_Running_OutOfRange = 201,
+} ETrackingResult;
+
+typedef enum ETrackedDeviceClass
+{
+	ETrackedDeviceClass_TrackedDeviceClass_Invalid = 0,
+	ETrackedDeviceClass_TrackedDeviceClass_HMD = 1,
+	ETrackedDeviceClass_TrackedDeviceClass_Controller = 2,
+	ETrackedDeviceClass_TrackedDeviceClass_GenericTracker = 3,
+	ETrackedDeviceClass_TrackedDeviceClass_TrackingReference = 4,
+	ETrackedDeviceClass_TrackedDeviceClass_DisplayRedirect = 5,
+} ETrackedDeviceClass;
+
+typedef enum ETrackedControllerRole
+{
+	ETrackedControllerRole_TrackedControllerRole_Invalid = 0,
+	ETrackedControllerRole_TrackedControllerRole_LeftHand = 1,
+	ETrackedControllerRole_TrackedControllerRole_RightHand = 2,
+} ETrackedControllerRole;
+
+typedef enum ETrackingUniverseOrigin
+{
+	ETrackingUniverseOrigin_TrackingUniverseSeated = 0,
+	ETrackingUniverseOrigin_TrackingUniverseStanding = 1,
+	ETrackingUniverseOrigin_TrackingUniverseRawAndUncalibrated = 2,
+} ETrackingUniverseOrigin;
+
+typedef enum ETrackedDeviceProperty
+{
+	ETrackedDeviceProperty_Prop_Invalid = 0,
+	ETrackedDeviceProperty_Prop_TrackingSystemName_String = 1000,
+	ETrackedDeviceProperty_Prop_ModelNumber_String = 1001,
+	ETrackedDeviceProperty_Prop_SerialNumber_String = 1002,
+	ETrackedDeviceProperty_Prop_RenderModelName_String = 1003,
+	ETrackedDeviceProperty_Prop_WillDriftInYaw_Bool = 1004,
+	ETrackedDeviceProperty_Prop_ManufacturerName_String = 1005,
+	ETrackedDeviceProperty_Prop_TrackingFirmwareVersion_String = 1006,
+	ETrackedDeviceProperty_Prop_HardwareRevision_String = 1007,
+	ETrackedDeviceProperty_Prop_AllWirelessDongleDescriptions_String = 1008,
+	ETrackedDeviceProperty_Prop_ConnectedWirelessDongle_String = 1009,
+	ETrackedDeviceProperty_Prop_DeviceIsWireless_Bool = 1010,
+	ETrackedDeviceProperty_Prop_DeviceIsCharging_Bool = 1011,
+	ETrackedDeviceProperty_Prop_DeviceBatteryPercentage_Float = 1012,
+	ETrackedDeviceProperty_Prop_StatusDisplayTransform_Matrix34 = 1013,
+	ETrackedDeviceProperty_Prop_Firmware_UpdateAvailable_Bool = 1014,
+	ETrackedDeviceProperty_Prop_Firmware_ManualUpdate_Bool = 1015,
+	ETrackedDeviceProperty_Prop_Firmware_ManualUpdateURL_String = 1016,
+	ETrackedDeviceProperty_Prop_HardwareRevision_Uint64 = 1017,
+	ETrackedDeviceProperty_Prop_FirmwareVersion_Uint64 = 1018,
+	ETrackedDeviceProperty_Prop_FPGAVersion_Uint64 = 1019,
+	ETrackedDeviceProperty_Prop_VRCVersion_Uint64 = 1020,
+	ETrackedDeviceProperty_Prop_RadioVersion_Uint64 = 1021,
+	ETrackedDeviceProperty_Prop_DongleVersion_Uint64 = 1022,
+	ETrackedDeviceProperty_Prop_BlockServerShutdown_Bool = 1023,
+	ETrackedDeviceProperty_Prop_CanUnifyCoordinateSystemWithHmd_Bool = 1024,
+	ETrackedDeviceProperty_Prop_ContainsProximitySensor_Bool = 1025,
+	ETrackedDeviceProperty_Prop_DeviceProvidesBatteryStatus_Bool = 1026,
+	ETrackedDeviceProperty_Prop_DeviceCanPowerOff_Bool = 1027,
+	ETrackedDeviceProperty_Prop_Firmware_ProgrammingTarget_String = 1028,
+	ETrackedDeviceProperty_Prop_DeviceClass_Int32 = 1029,
+	ETrackedDeviceProperty_Prop_HasCamera_Bool = 1030,
+	ETrackedDeviceProperty_Prop_DriverVersion_String = 1031,
+	ETrackedDeviceProperty_Prop_Firmware_ForceUpdateRequired_Bool = 1032,
+	ETrackedDeviceProperty_Prop_ViveSystemButtonFixRequired_Bool = 1033,
+	ETrackedDeviceProperty_Prop_ParentDriver_Uint64 = 1034,
+	ETrackedDeviceProperty_Prop_ResourceRoot_String = 1035,
+	ETrackedDeviceProperty_Prop_ReportsTimeSinceVSync_Bool = 2000,
+	ETrackedDeviceProperty_Prop_SecondsFromVsyncToPhotons_Float = 2001,
+	ETrackedDeviceProperty_Prop_DisplayFrequency_Float = 2002,
+	ETrackedDeviceProperty_Prop_UserIpdMeters_Float = 2003,
+	ETrackedDeviceProperty_Prop_CurrentUniverseId_Uint64 = 2004,
+	ETrackedDeviceProperty_Prop_PreviousUniverseId_Uint64 = 2005,
+	ETrackedDeviceProperty_Prop_DisplayFirmwareVersion_Uint64 = 2006,
+	ETrackedDeviceProperty_Prop_IsOnDesktop_Bool = 2007,
+	ETrackedDeviceProperty_Prop_DisplayMCType_Int32 = 2008,
+	ETrackedDeviceProperty_Prop_DisplayMCOffset_Float = 2009,
+	ETrackedDeviceProperty_Prop_DisplayMCScale_Float = 2010,
+	ETrackedDeviceProperty_Prop_EdidVendorID_Int32 = 2011,
+	ETrackedDeviceProperty_Prop_DisplayMCImageLeft_String = 2012,
+	ETrackedDeviceProperty_Prop_DisplayMCImageRight_String = 2013,
+	ETrackedDeviceProperty_Prop_DisplayGCBlackClamp_Float = 2014,
+	ETrackedDeviceProperty_Prop_EdidProductID_Int32 = 2015,
+	ETrackedDeviceProperty_Prop_CameraToHeadTransform_Matrix34 = 2016,
+	ETrackedDeviceProperty_Prop_DisplayGCType_Int32 = 2017,
+	ETrackedDeviceProperty_Prop_DisplayGCOffset_Float = 2018,
+	ETrackedDeviceProperty_Prop_DisplayGCScale_Float = 2019,
+	ETrackedDeviceProperty_Prop_DisplayGCPrescale_Float = 2020,
+	ETrackedDeviceProperty_Prop_DisplayGCImage_String = 2021,
+	ETrackedDeviceProperty_Prop_LensCenterLeftU_Float = 2022,
+	ETrackedDeviceProperty_Prop_LensCenterLeftV_Float = 2023,
+	ETrackedDeviceProperty_Prop_LensCenterRightU_Float = 2024,
+	ETrackedDeviceProperty_Prop_LensCenterRightV_Float = 2025,
+	ETrackedDeviceProperty_Prop_UserHeadToEyeDepthMeters_Float = 2026,
+	ETrackedDeviceProperty_Prop_CameraFirmwareVersion_Uint64 = 2027,
+	ETrackedDeviceProperty_Prop_CameraFirmwareDescription_String = 2028,
+	ETrackedDeviceProperty_Prop_DisplayFPGAVersion_Uint64 = 2029,
+	ETrackedDeviceProperty_Prop_DisplayBootloaderVersion_Uint64 = 2030,
+	ETrackedDeviceProperty_Prop_DisplayHardwareVersion_Uint64 = 2031,
+	ETrackedDeviceProperty_Prop_AudioFirmwareVersion_Uint64 = 2032,
+	ETrackedDeviceProperty_Prop_CameraCompatibilityMode_Int32 = 2033,
+	ETrackedDeviceProperty_Prop_ScreenshotHorizontalFieldOfViewDegrees_Float = 2034,
+	ETrackedDeviceProperty_Prop_ScreenshotVerticalFieldOfViewDegrees_Float = 2035,
+	ETrackedDeviceProperty_Prop_DisplaySuppressed_Bool = 2036,
+	ETrackedDeviceProperty_Prop_DisplayAllowNightMode_Bool = 2037,
+	ETrackedDeviceProperty_Prop_DisplayMCImageWidth_Int32 = 2038,
+	ETrackedDeviceProperty_Prop_DisplayMCImageHeight_Int32 = 2039,
+	ETrackedDeviceProperty_Prop_DisplayMCImageNumChannels_Int32 = 2040,
+	ETrackedDeviceProperty_Prop_DisplayMCImageData_Binary = 2041,
+	ETrackedDeviceProperty_Prop_SecondsFromPhotonsToVblank_Float = 2042,
+	ETrackedDeviceProperty_Prop_DriverDirectModeSendsVsyncEvents_Bool = 2043,
+	ETrackedDeviceProperty_Prop_DisplayDebugMode_Bool = 2044,
+	ETrackedDeviceProperty_Prop_GraphicsAdapterLuid_Uint64 = 2045,
+	ETrackedDeviceProperty_Prop_DriverProvidedChaperonePath_String = 2048,
+	ETrackedDeviceProperty_Prop_AttachedDeviceId_String = 3000,
+	ETrackedDeviceProperty_Prop_SupportedButtons_Uint64 = 3001,
+	ETrackedDeviceProperty_Prop_Axis0Type_Int32 = 3002,
+	ETrackedDeviceProperty_Prop_Axis1Type_Int32 = 3003,
+	ETrackedDeviceProperty_Prop_Axis2Type_Int32 = 3004,
+	ETrackedDeviceProperty_Prop_Axis3Type_Int32 = 3005,
+	ETrackedDeviceProperty_Prop_Axis4Type_Int32 = 3006,
+	ETrackedDeviceProperty_Prop_ControllerRoleHint_Int32 = 3007,
+	ETrackedDeviceProperty_Prop_FieldOfViewLeftDegrees_Float = 4000,
+	ETrackedDeviceProperty_Prop_FieldOfViewRightDegrees_Float = 4001,
+	ETrackedDeviceProperty_Prop_FieldOfViewTopDegrees_Float = 4002,
+	ETrackedDeviceProperty_Prop_FieldOfViewBottomDegrees_Float = 4003,
+	ETrackedDeviceProperty_Prop_TrackingRangeMinimumMeters_Float = 4004,
+	ETrackedDeviceProperty_Prop_TrackingRangeMaximumMeters_Float = 4005,
+	ETrackedDeviceProperty_Prop_ModeLabel_String = 4006,
+	ETrackedDeviceProperty_Prop_IconPathName_String = 5000,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceOff_String = 5001,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceSearching_String = 5002,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceSearchingAlert_String = 5003,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceReady_String = 5004,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceReadyAlert_String = 5005,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceNotReady_String = 5006,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceStandby_String = 5007,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceAlertLow_String = 5008,
+	ETrackedDeviceProperty_Prop_DisplayHiddenArea_Binary_Start = 5100,
+	ETrackedDeviceProperty_Prop_DisplayHiddenArea_Binary_End = 5150,
+	ETrackedDeviceProperty_Prop_UserConfigPath_String = 6000,
+	ETrackedDeviceProperty_Prop_InstallPath_String = 6001,
+	ETrackedDeviceProperty_Prop_HasDisplayComponent_Bool = 6002,
+	ETrackedDeviceProperty_Prop_HasControllerComponent_Bool = 6003,
+	ETrackedDeviceProperty_Prop_HasCameraComponent_Bool = 6004,
+	ETrackedDeviceProperty_Prop_HasDriverDirectModeComponent_Bool = 6005,
+	ETrackedDeviceProperty_Prop_HasVirtualDisplayComponent_Bool = 6006,
+	ETrackedDeviceProperty_Prop_VendorSpecific_Reserved_Start = 10000,
+	ETrackedDeviceProperty_Prop_VendorSpecific_Reserved_End = 10999,
+} ETrackedDeviceProperty;
+
+typedef enum ETrackedPropertyError
+{
+	ETrackedPropertyError_TrackedProp_Success = 0,
+	ETrackedPropertyError_TrackedProp_WrongDataType = 1,
+	ETrackedPropertyError_TrackedProp_WrongDeviceClass = 2,
+	ETrackedPropertyError_TrackedProp_BufferTooSmall = 3,
+	ETrackedPropertyError_TrackedProp_UnknownProperty = 4,
+	ETrackedPropertyError_TrackedProp_InvalidDevice = 5,
+	ETrackedPropertyError_TrackedProp_CouldNotContactServer = 6,
+	ETrackedPropertyError_TrackedProp_ValueNotProvidedByDevice = 7,
+	ETrackedPropertyError_TrackedProp_StringExceedsMaximumLength = 8,
+	ETrackedPropertyError_TrackedProp_NotYetAvailable = 9,
+	ETrackedPropertyError_TrackedProp_PermissionDenied = 10,
+	ETrackedPropertyError_TrackedProp_InvalidOperation = 11,
+} ETrackedPropertyError;
+
+typedef enum EVRSubmitFlags
+{
+	EVRSubmitFlags_Submit_Default = 0,
+	EVRSubmitFlags_Submit_LensDistortionAlreadyApplied = 1,
+	EVRSubmitFlags_Submit_GlRenderBuffer = 2,
+	EVRSubmitFlags_Submit_Reserved = 4,
+	EVRSubmitFlags_Submit_TextureWithPose = 8,
+} EVRSubmitFlags;
+
+typedef enum EVRState
+{
+	EVRState_VRState_Undefined = -1,
+	EVRState_VRState_Off = 0,
+	EVRState_VRState_Searching = 1,
+	EVRState_VRState_Searching_Alert = 2,
+	EVRState_VRState_Ready = 3,
+	EVRState_VRState_Ready_Alert = 4,
+	EVRState_VRState_NotReady = 5,
+	EVRState_VRState_Standby = 6,
+	EVRState_VRState_Ready_Alert_Low = 7,
+} EVRState;
+
+typedef enum EVREventType
+{
+	EVREventType_VREvent_None = 0,
+	EVREventType_VREvent_TrackedDeviceActivated = 100,
+	EVREventType_VREvent_TrackedDeviceDeactivated = 101,
+	EVREventType_VREvent_TrackedDeviceUpdated = 102,
+	EVREventType_VREvent_TrackedDeviceUserInteractionStarted = 103,
+	EVREventType_VREvent_TrackedDeviceUserInteractionEnded = 104,
+	EVREventType_VREvent_IpdChanged = 105,
+	EVREventType_VREvent_EnterStandbyMode = 106,
+	EVREventType_VREvent_LeaveStandbyMode = 107,
+	EVREventType_VREvent_TrackedDeviceRoleChanged = 108,
+	EVREventType_VREvent_WatchdogWakeUpRequested = 109,
+	EVREventType_VREvent_LensDistortionChanged = 110,
+	EVREventType_VREvent_PropertyChanged = 111,
+	EVREventType_VREvent_WirelessDisconnect = 112,
+	EVREventType_VREvent_WirelessReconnect = 113,
+	EVREventType_VREvent_ButtonPress = 200,
+	EVREventType_VREvent_ButtonUnpress = 201,
+	EVREventType_VREvent_ButtonTouch = 202,
+	EVREventType_VREvent_ButtonUntouch = 203,
+	EVREventType_VREvent_MouseMove = 300,
+	EVREventType_VREvent_MouseButtonDown = 301,
+	EVREventType_VREvent_MouseButtonUp = 302,
+	EVREventType_VREvent_FocusEnter = 303,
+	EVREventType_VREvent_FocusLeave = 304,
+	EVREventType_VREvent_Scroll = 305,
+	EVREventType_VREvent_TouchPadMove = 306,
+	EVREventType_VREvent_OverlayFocusChanged = 307,
+	EVREventType_VREvent_InputFocusCaptured = 400,
+	EVREventType_VREvent_InputFocusReleased = 401,
+	EVREventType_VREvent_SceneFocusLost = 402,
+	EVREventType_VREvent_SceneFocusGained = 403,
+	EVREventType_VREvent_SceneApplicationChanged = 404,
+	EVREventType_VREvent_SceneFocusChanged = 405,
+	EVREventType_VREvent_InputFocusChanged = 406,
+	EVREventType_VREvent_SceneApplicationSecondaryRenderingStarted = 407,
+	EVREventType_VREvent_HideRenderModels = 410,
+	EVREventType_VREvent_ShowRenderModels = 411,
+	EVREventType_VREvent_OverlayShown = 500,
+	EVREventType_VREvent_OverlayHidden = 501,
+	EVREventType_VREvent_DashboardActivated = 502,
+	EVREventType_VREvent_DashboardDeactivated = 503,
+	EVREventType_VREvent_DashboardThumbSelected = 504,
+	EVREventType_VREvent_DashboardRequested = 505,
+	EVREventType_VREvent_ResetDashboard = 506,
+	EVREventType_VREvent_RenderToast = 507,
+	EVREventType_VREvent_ImageLoaded = 508,
+	EVREventType_VREvent_ShowKeyboard = 509,
+	EVREventType_VREvent_HideKeyboard = 510,
+	EVREventType_VREvent_OverlayGamepadFocusGained = 511,
+	EVREventType_VREvent_OverlayGamepadFocusLost = 512,
+	EVREventType_VREvent_OverlaySharedTextureChanged = 513,
+	EVREventType_VREvent_DashboardGuideButtonDown = 514,
+	EVREventType_VREvent_DashboardGuideButtonUp = 515,
+	EVREventType_VREvent_ScreenshotTriggered = 516,
+	EVREventType_VREvent_ImageFailed = 517,
+	EVREventType_VREvent_DashboardOverlayCreated = 518,
+	EVREventType_VREvent_RequestScreenshot = 520,
+	EVREventType_VREvent_ScreenshotTaken = 521,
+	EVREventType_VREvent_ScreenshotFailed = 522,
+	EVREventType_VREvent_SubmitScreenshotToDashboard = 523,
+	EVREventType_VREvent_ScreenshotProgressToDashboard = 524,
+	EVREventType_VREvent_PrimaryDashboardDeviceChanged = 525,
+	EVREventType_VREvent_Notification_Shown = 600,
+	EVREventType_VREvent_Notification_Hidden = 601,
+	EVREventType_VREvent_Notification_BeginInteraction = 602,
+	EVREventType_VREvent_Notification_Destroyed = 603,
+	EVREventType_VREvent_Quit = 700,
+	EVREventType_VREvent_ProcessQuit = 701,
+	EVREventType_VREvent_QuitAborted_UserPrompt = 702,
+	EVREventType_VREvent_QuitAcknowledged = 703,
+	EVREventType_VREvent_DriverRequestedQuit = 704,
+	EVREventType_VREvent_ChaperoneDataHasChanged = 800,
+	EVREventType_VREvent_ChaperoneUniverseHasChanged = 801,
+	EVREventType_VREvent_ChaperoneTempDataHasChanged = 802,
+	EVREventType_VREvent_ChaperoneSettingsHaveChanged = 803,
+	EVREventType_VREvent_SeatedZeroPoseReset = 804,
+	EVREventType_VREvent_AudioSettingsHaveChanged = 820,
+	EVREventType_VREvent_BackgroundSettingHasChanged = 850,
+	EVREventType_VREvent_CameraSettingsHaveChanged = 851,
+	EVREventType_VREvent_ReprojectionSettingHasChanged = 852,
+	EVREventType_VREvent_ModelSkinSettingsHaveChanged = 853,
+	EVREventType_VREvent_EnvironmentSettingsHaveChanged = 854,
+	EVREventType_VREvent_PowerSettingsHaveChanged = 855,
+	EVREventType_VREvent_EnableHomeAppSettingsHaveChanged = 856,
+	EVREventType_VREvent_StatusUpdate = 900,
+	EVREventType_VREvent_MCImageUpdated = 1000,
+	EVREventType_VREvent_FirmwareUpdateStarted = 1100,
+	EVREventType_VREvent_FirmwareUpdateFinished = 1101,
+	EVREventType_VREvent_KeyboardClosed = 1200,
+	EVREventType_VREvent_KeyboardCharInput = 1201,
+	EVREventType_VREvent_KeyboardDone = 1202,
+	EVREventType_VREvent_ApplicationTransitionStarted = 1300,
+	EVREventType_VREvent_ApplicationTransitionAborted = 1301,
+	EVREventType_VREvent_ApplicationTransitionNewAppStarted = 1302,
+	EVREventType_VREvent_ApplicationListUpdated = 1303,
+	EVREventType_VREvent_ApplicationMimeTypeLoad = 1304,
+	EVREventType_VREvent_ApplicationTransitionNewAppLaunchComplete = 1305,
+	EVREventType_VREvent_ProcessConnected = 1306,
+	EVREventType_VREvent_ProcessDisconnected = 1307,
+	EVREventType_VREvent_Compositor_MirrorWindowShown = 1400,
+	EVREventType_VREvent_Compositor_MirrorWindowHidden = 1401,
+	EVREventType_VREvent_Compositor_ChaperoneBoundsShown = 1410,
+	EVREventType_VREvent_Compositor_ChaperoneBoundsHidden = 1411,
+	EVREventType_VREvent_TrackedCamera_StartVideoStream = 1500,
+	EVREventType_VREvent_TrackedCamera_StopVideoStream = 1501,
+	EVREventType_VREvent_TrackedCamera_PauseVideoStream = 1502,
+	EVREventType_VREvent_TrackedCamera_ResumeVideoStream = 1503,
+	EVREventType_VREvent_TrackedCamera_EditingSurface = 1550,
+	EVREventType_VREvent_PerformanceTest_EnableCapture = 1600,
+	EVREventType_VREvent_PerformanceTest_DisableCapture = 1601,
+	EVREventType_VREvent_PerformanceTest_FidelityLevel = 1602,
+	EVREventType_VREvent_MessageOverlay_Closed = 1650,
+	EVREventType_VREvent_MessageOverlayCloseRequested = 1651,
+	EVREventType_VREvent_VendorSpecific_Reserved_Start = 10000,
+	EVREventType_VREvent_VendorSpecific_Reserved_End = 19999,
+} EVREventType;
+
+typedef enum EDeviceActivityLevel
+{
+	EDeviceActivityLevel_k_EDeviceActivityLevel_Unknown = -1,
+	EDeviceActivityLevel_k_EDeviceActivityLevel_Idle = 0,
+	EDeviceActivityLevel_k_EDeviceActivityLevel_UserInteraction = 1,
+	EDeviceActivityLevel_k_EDeviceActivityLevel_UserInteraction_Timeout = 2,
+	EDeviceActivityLevel_k_EDeviceActivityLevel_Standby = 3,
+} EDeviceActivityLevel;
+
+typedef enum EVRButtonId
+{
+	EVRButtonId_k_EButton_System = 0,
+	EVRButtonId_k_EButton_ApplicationMenu = 1,
+	EVRButtonId_k_EButton_Grip = 2,
+	EVRButtonId_k_EButton_DPad_Left = 3,
+	EVRButtonId_k_EButton_DPad_Up = 4,
+	EVRButtonId_k_EButton_DPad_Right = 5,
+	EVRButtonId_k_EButton_DPad_Down = 6,
+	EVRButtonId_k_EButton_A = 7,
+	EVRButtonId_k_EButton_ProximitySensor = 31,
+	EVRButtonId_k_EButton_Axis0 = 32,
+	EVRButtonId_k_EButton_Axis1 = 33,
+	EVRButtonId_k_EButton_Axis2 = 34,
+	EVRButtonId_k_EButton_Axis3 = 35,
+	EVRButtonId_k_EButton_Axis4 = 36,
+	EVRButtonId_k_EButton_SteamVR_Touchpad = 32,
+	EVRButtonId_k_EButton_SteamVR_Trigger = 33,
+	EVRButtonId_k_EButton_Dashboard_Back = 2,
+	EVRButtonId_k_EButton_Max = 64,
+} EVRButtonId;
+
+typedef enum EVRMouseButton
+{
+	EVRMouseButton_VRMouseButton_Left = 1,
+	EVRMouseButton_VRMouseButton_Right = 2,
+	EVRMouseButton_VRMouseButton_Middle = 4,
+} EVRMouseButton;
+
+typedef enum EHiddenAreaMeshType
+{
+	EHiddenAreaMeshType_k_eHiddenAreaMesh_Standard = 0,
+	EHiddenAreaMeshType_k_eHiddenAreaMesh_Inverse = 1,
+	EHiddenAreaMeshType_k_eHiddenAreaMesh_LineLoop = 2,
+	EHiddenAreaMeshType_k_eHiddenAreaMesh_Max = 3,
+} EHiddenAreaMeshType;
+
+typedef enum EVRControllerAxisType
+{
+	EVRControllerAxisType_k_eControllerAxis_None = 0,
+	EVRControllerAxisType_k_eControllerAxis_TrackPad = 1,
+	EVRControllerAxisType_k_eControllerAxis_Joystick = 2,
+	EVRControllerAxisType_k_eControllerAxis_Trigger = 3,
+} EVRControllerAxisType;
+
+typedef enum EVRControllerEventOutputType
+{
+	EVRControllerEventOutputType_ControllerEventOutput_OSEvents = 0,
+	EVRControllerEventOutputType_ControllerEventOutput_VREvents = 1,
+} EVRControllerEventOutputType;
+
+typedef enum ECollisionBoundsStyle
+{
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_BEGINNER = 0,
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_INTERMEDIATE = 1,
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_SQUARES = 2,
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_ADVANCED = 3,
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_NONE = 4,
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_COUNT = 5,
+} ECollisionBoundsStyle;
+
+typedef enum EVROverlayError
+{
+	EVROverlayError_VROverlayError_None = 0,
+	EVROverlayError_VROverlayError_UnknownOverlay = 10,
+	EVROverlayError_VROverlayError_InvalidHandle = 11,
+	EVROverlayError_VROverlayError_PermissionDenied = 12,
+	EVROverlayError_VROverlayError_OverlayLimitExceeded = 13,
+	EVROverlayError_VROverlayError_WrongVisibilityType = 14,
+	EVROverlayError_VROverlayError_KeyTooLong = 15,
+	EVROverlayError_VROverlayError_NameTooLong = 16,
+	EVROverlayError_VROverlayError_KeyInUse = 17,
+	EVROverlayError_VROverlayError_WrongTransformType = 18,
+	EVROverlayError_VROverlayError_InvalidTrackedDevice = 19,
+	EVROverlayError_VROverlayError_InvalidParameter = 20,
+	EVROverlayError_VROverlayError_ThumbnailCantBeDestroyed = 21,
+	EVROverlayError_VROverlayError_ArrayTooSmall = 22,
+	EVROverlayError_VROverlayError_RequestFailed = 23,
+	EVROverlayError_VROverlayError_InvalidTexture = 24,
+	EVROverlayError_VROverlayError_UnableToLoadFile = 25,
+	EVROverlayError_VROverlayError_KeyboardAlreadyInUse = 26,
+	EVROverlayError_VROverlayError_NoNeighbor = 27,
+	EVROverlayError_VROverlayError_TooManyMaskPrimitives = 29,
+	EVROverlayError_VROverlayError_BadMaskPrimitive = 30,
+} EVROverlayError;
+
+typedef enum EVRApplicationType
+{
+	EVRApplicationType_VRApplication_Other = 0,
+	EVRApplicationType_VRApplication_Scene = 1,
+	EVRApplicationType_VRApplication_Overlay = 2,
+	EVRApplicationType_VRApplication_Background = 3,
+	EVRApplicationType_VRApplication_Utility = 4,
+	EVRApplicationType_VRApplication_VRMonitor = 5,
+	EVRApplicationType_VRApplication_SteamWatchdog = 6,
+	EVRApplicationType_VRApplication_Bootstrapper = 7,
+	EVRApplicationType_VRApplication_Max = 8,
+} EVRApplicationType;
+
+typedef enum EVRFirmwareError
+{
+	EVRFirmwareError_VRFirmwareError_None = 0,
+	EVRFirmwareError_VRFirmwareError_Success = 1,
+	EVRFirmwareError_VRFirmwareError_Fail = 2,
+} EVRFirmwareError;
+
+typedef enum EVRNotificationError
+{
+	EVRNotificationError_VRNotificationError_OK = 0,
+	EVRNotificationError_VRNotificationError_InvalidNotificationId = 100,
+	EVRNotificationError_VRNotificationError_NotificationQueueFull = 101,
+	EVRNotificationError_VRNotificationError_InvalidOverlayHandle = 102,
+	EVRNotificationError_VRNotificationError_SystemWithUserValueAlreadyExists = 103,
+} EVRNotificationError;
+
+typedef enum EVRInitError
+{
+	EVRInitError_VRInitError_None = 0,
+	EVRInitError_VRInitError_Unknown = 1,
+	EVRInitError_VRInitError_Init_InstallationNotFound = 100,
+	EVRInitError_VRInitError_Init_InstallationCorrupt = 101,
+	EVRInitError_VRInitError_Init_VRClientDLLNotFound = 102,
+	EVRInitError_VRInitError_Init_FileNotFound = 103,
+	EVRInitError_VRInitError_Init_FactoryNotFound = 104,
+	EVRInitError_VRInitError_Init_InterfaceNotFound = 105,
+	EVRInitError_VRInitError_Init_InvalidInterface = 106,
+	EVRInitError_VRInitError_Init_UserConfigDirectoryInvalid = 107,
+	EVRInitError_VRInitError_Init_HmdNotFound = 108,
+	EVRInitError_VRInitError_Init_NotInitialized = 109,
+	EVRInitError_VRInitError_Init_PathRegistryNotFound = 110,
+	EVRInitError_VRInitError_Init_NoConfigPath = 111,
+	EVRInitError_VRInitError_Init_NoLogPath = 112,
+	EVRInitError_VRInitError_Init_PathRegistryNotWritable = 113,
+	EVRInitError_VRInitError_Init_AppInfoInitFailed = 114,
+	EVRInitError_VRInitError_Init_Retry = 115,
+	EVRInitError_VRInitError_Init_InitCanceledByUser = 116,
+	EVRInitError_VRInitError_Init_AnotherAppLaunching = 117,
+	EVRInitError_VRInitError_Init_SettingsInitFailed = 118,
+	EVRInitError_VRInitError_Init_ShuttingDown = 119,
+	EVRInitError_VRInitError_Init_TooManyObjects = 120,
+	EVRInitError_VRInitError_Init_NoServerForBackgroundApp = 121,
+	EVRInitError_VRInitError_Init_NotSupportedWithCompositor = 122,
+	EVRInitError_VRInitError_Init_NotAvailableToUtilityApps = 123,
+	EVRInitError_VRInitError_Init_Internal = 124,
+	EVRInitError_VRInitError_Init_HmdDriverIdIsNone = 125,
+	EVRInitError_VRInitError_Init_HmdNotFoundPresenceFailed = 126,
+	EVRInitError_VRInitError_Init_VRMonitorNotFound = 127,
+	EVRInitError_VRInitError_Init_VRMonitorStartupFailed = 128,
+	EVRInitError_VRInitError_Init_LowPowerWatchdogNotSupported = 129,
+	EVRInitError_VRInitError_Init_InvalidApplicationType = 130,
+	EVRInitError_VRInitError_Init_NotAvailableToWatchdogApps = 131,
+	EVRInitError_VRInitError_Init_WatchdogDisabledInSettings = 132,
+	EVRInitError_VRInitError_Init_VRDashboardNotFound = 133,
+	EVRInitError_VRInitError_Init_VRDashboardStartupFailed = 134,
+	EVRInitError_VRInitError_Init_VRHomeNotFound = 135,
+	EVRInitError_VRInitError_Init_VRHomeStartupFailed = 136,
+	EVRInitError_VRInitError_Init_RebootingBusy = 137,
+	EVRInitError_VRInitError_Init_FirmwareUpdateBusy = 138,
+	EVRInitError_VRInitError_Init_FirmwareRecoveryBusy = 139,
+	EVRInitError_VRInitError_Driver_Failed = 200,
+	EVRInitError_VRInitError_Driver_Unknown = 201,
+	EVRInitError_VRInitError_Driver_HmdUnknown = 202,
+	EVRInitError_VRInitError_Driver_NotLoaded = 203,
+	EVRInitError_VRInitError_Driver_RuntimeOutOfDate = 204,
+	EVRInitError_VRInitError_Driver_HmdInUse = 205,
+	EVRInitError_VRInitError_Driver_NotCalibrated = 206,
+	EVRInitError_VRInitError_Driver_CalibrationInvalid = 207,
+	EVRInitError_VRInitError_Driver_HmdDisplayNotFound = 208,
+	EVRInitError_VRInitError_Driver_TrackedDeviceInterfaceUnknown = 209,
+	EVRInitError_VRInitError_Driver_HmdDriverIdOutOfBounds = 211,
+	EVRInitError_VRInitError_Driver_HmdDisplayMirrored = 212,
+	EVRInitError_VRInitError_IPC_ServerInitFailed = 300,
+	EVRInitError_VRInitError_IPC_ConnectFailed = 301,
+	EVRInitError_VRInitError_IPC_SharedStateInitFailed = 302,
+	EVRInitError_VRInitError_IPC_CompositorInitFailed = 303,
+	EVRInitError_VRInitError_IPC_MutexInitFailed = 304,
+	EVRInitError_VRInitError_IPC_Failed = 305,
+	EVRInitError_VRInitError_IPC_CompositorConnectFailed = 306,
+	EVRInitError_VRInitError_IPC_CompositorInvalidConnectResponse = 307,
+	EVRInitError_VRInitError_IPC_ConnectFailedAfterMultipleAttempts = 308,
+	EVRInitError_VRInitError_Compositor_Failed = 400,
+	EVRInitError_VRInitError_Compositor_D3D11HardwareRequired = 401,
+	EVRInitError_VRInitError_Compositor_FirmwareRequiresUpdate = 402,
+	EVRInitError_VRInitError_Compositor_OverlayInitFailed = 403,
+	EVRInitError_VRInitError_Compositor_ScreenshotsInitFailed = 404,
+	EVRInitError_VRInitError_Compositor_UnableToCreateDevice = 405,
+	EVRInitError_VRInitError_VendorSpecific_UnableToConnectToOculusRuntime = 1000,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_CantOpenDevice = 1101,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToRequestConfigStart = 1102,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_NoStoredConfig = 1103,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_ConfigTooBig = 1104,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_ConfigTooSmall = 1105,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToInitZLib = 1106,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_CantReadFirmwareVersion = 1107,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToSendUserDataStart = 1108,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataStart = 1109,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataNext = 1110,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UserDataAddressRange = 1111,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UserDataError = 1112,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_ConfigFailedSanityCheck = 1113,
+	EVRInitError_VRInitError_Steam_SteamInstallationNotFound = 2000,
+} EVRInitError;
+
+typedef enum EVRScreenshotType
+{
+	EVRScreenshotType_VRScreenshotType_None = 0,
+	EVRScreenshotType_VRScreenshotType_Mono = 1,
+	EVRScreenshotType_VRScreenshotType_Stereo = 2,
+	EVRScreenshotType_VRScreenshotType_Cubemap = 3,
+	EVRScreenshotType_VRScreenshotType_MonoPanorama = 4,
+	EVRScreenshotType_VRScreenshotType_StereoPanorama = 5,
+} EVRScreenshotType;
+
+typedef enum EVRScreenshotPropertyFilenames
+{
+	EVRScreenshotPropertyFilenames_VRScreenshotPropertyFilenames_Preview = 0,
+	EVRScreenshotPropertyFilenames_VRScreenshotPropertyFilenames_VR = 1,
+} EVRScreenshotPropertyFilenames;
+
+typedef enum EVRTrackedCameraError
+{
+	EVRTrackedCameraError_VRTrackedCameraError_None = 0,
+	EVRTrackedCameraError_VRTrackedCameraError_OperationFailed = 100,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidHandle = 101,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidFrameHeaderVersion = 102,
+	EVRTrackedCameraError_VRTrackedCameraError_OutOfHandles = 103,
+	EVRTrackedCameraError_VRTrackedCameraError_IPCFailure = 104,
+	EVRTrackedCameraError_VRTrackedCameraError_NotSupportedForThisDevice = 105,
+	EVRTrackedCameraError_VRTrackedCameraError_SharedMemoryFailure = 106,
+	EVRTrackedCameraError_VRTrackedCameraError_FrameBufferingFailure = 107,
+	EVRTrackedCameraError_VRTrackedCameraError_StreamSetupFailure = 108,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidGLTextureId = 109,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidSharedTextureHandle = 110,
+	EVRTrackedCameraError_VRTrackedCameraError_FailedToGetGLTextureId = 111,
+	EVRTrackedCameraError_VRTrackedCameraError_SharedTextureFailure = 112,
+	EVRTrackedCameraError_VRTrackedCameraError_NoFrameAvailable = 113,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidArgument = 114,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidFrameBufferSize = 115,
+} EVRTrackedCameraError;
+
+typedef enum EVRTrackedCameraFrameType
+{
+	EVRTrackedCameraFrameType_VRTrackedCameraFrameType_Distorted = 0,
+	EVRTrackedCameraFrameType_VRTrackedCameraFrameType_Undistorted = 1,
+	EVRTrackedCameraFrameType_VRTrackedCameraFrameType_MaximumUndistorted = 2,
+	EVRTrackedCameraFrameType_MAX_CAMERA_FRAME_TYPES = 3,
+} EVRTrackedCameraFrameType;
+
+typedef enum EVRApplicationError
+{
+	EVRApplicationError_VRApplicationError_None = 0,
+	EVRApplicationError_VRApplicationError_AppKeyAlreadyExists = 100,
+	EVRApplicationError_VRApplicationError_NoManifest = 101,
+	EVRApplicationError_VRApplicationError_NoApplication = 102,
+	EVRApplicationError_VRApplicationError_InvalidIndex = 103,
+	EVRApplicationError_VRApplicationError_UnknownApplication = 104,
+	EVRApplicationError_VRApplicationError_IPCFailed = 105,
+	EVRApplicationError_VRApplicationError_ApplicationAlreadyRunning = 106,
+	EVRApplicationError_VRApplicationError_InvalidManifest = 107,
+	EVRApplicationError_VRApplicationError_InvalidApplication = 108,
+	EVRApplicationError_VRApplicationError_LaunchFailed = 109,
+	EVRApplicationError_VRApplicationError_ApplicationAlreadyStarting = 110,
+	EVRApplicationError_VRApplicationError_LaunchInProgress = 111,
+	EVRApplicationError_VRApplicationError_OldApplicationQuitting = 112,
+	EVRApplicationError_VRApplicationError_TransitionAborted = 113,
+	EVRApplicationError_VRApplicationError_IsTemplate = 114,
+	EVRApplicationError_VRApplicationError_SteamVRIsExiting = 115,
+	EVRApplicationError_VRApplicationError_BufferTooSmall = 200,
+	EVRApplicationError_VRApplicationError_PropertyNotSet = 201,
+	EVRApplicationError_VRApplicationError_UnknownProperty = 202,
+	EVRApplicationError_VRApplicationError_InvalidParameter = 203,
+} EVRApplicationError;
+
+typedef enum EVRApplicationProperty
+{
+	EVRApplicationProperty_VRApplicationProperty_Name_String = 0,
+	EVRApplicationProperty_VRApplicationProperty_LaunchType_String = 11,
+	EVRApplicationProperty_VRApplicationProperty_WorkingDirectory_String = 12,
+	EVRApplicationProperty_VRApplicationProperty_BinaryPath_String = 13,
+	EVRApplicationProperty_VRApplicationProperty_Arguments_String = 14,
+	EVRApplicationProperty_VRApplicationProperty_URL_String = 15,
+	EVRApplicationProperty_VRApplicationProperty_Description_String = 50,
+	EVRApplicationProperty_VRApplicationProperty_NewsURL_String = 51,
+	EVRApplicationProperty_VRApplicationProperty_ImagePath_String = 52,
+	EVRApplicationProperty_VRApplicationProperty_Source_String = 53,
+	EVRApplicationProperty_VRApplicationProperty_IsDashboardOverlay_Bool = 60,
+	EVRApplicationProperty_VRApplicationProperty_IsTemplate_Bool = 61,
+	EVRApplicationProperty_VRApplicationProperty_IsInstanced_Bool = 62,
+	EVRApplicationProperty_VRApplicationProperty_IsInternal_Bool = 63,
+	EVRApplicationProperty_VRApplicationProperty_WantsCompositorPauseInStandby_Bool = 64,
+	EVRApplicationProperty_VRApplicationProperty_LastLaunchTime_Uint64 = 70,
+} EVRApplicationProperty;
+
+typedef enum EVRApplicationTransitionState
+{
+	EVRApplicationTransitionState_VRApplicationTransition_None = 0,
+	EVRApplicationTransitionState_VRApplicationTransition_OldAppQuitSent = 10,
+	EVRApplicationTransitionState_VRApplicationTransition_WaitingForExternalLaunch = 11,
+	EVRApplicationTransitionState_VRApplicationTransition_NewAppLaunched = 20,
+} EVRApplicationTransitionState;
+
+typedef enum ChaperoneCalibrationState
+{
+	ChaperoneCalibrationState_OK = 1,
+	ChaperoneCalibrationState_Warning = 100,
+	ChaperoneCalibrationState_Warning_BaseStationMayHaveMoved = 101,
+	ChaperoneCalibrationState_Warning_BaseStationRemoved = 102,
+	ChaperoneCalibrationState_Warning_SeatedBoundsInvalid = 103,
+	ChaperoneCalibrationState_Error = 200,
+	ChaperoneCalibrationState_Error_BaseStationUninitialized = 201,
+	ChaperoneCalibrationState_Error_BaseStationConflict = 202,
+	ChaperoneCalibrationState_Error_PlayAreaInvalid = 203,
+	ChaperoneCalibrationState_Error_CollisionBoundsInvalid = 204,
+} ChaperoneCalibrationState;
+
+typedef enum EChaperoneConfigFile
+{
+	EChaperoneConfigFile_Live = 1,
+	EChaperoneConfigFile_Temp = 2,
+} EChaperoneConfigFile;
+
+typedef enum EChaperoneImportFlags
+{
+	EChaperoneImportFlags_EChaperoneImport_BoundsOnly = 1,
+} EChaperoneImportFlags;
+
+typedef enum EVRCompositorError
+{
+	EVRCompositorError_VRCompositorError_None = 0,
+	EVRCompositorError_VRCompositorError_RequestFailed = 1,
+	EVRCompositorError_VRCompositorError_IncompatibleVersion = 100,
+	EVRCompositorError_VRCompositorError_DoNotHaveFocus = 101,
+	EVRCompositorError_VRCompositorError_InvalidTexture = 102,
+	EVRCompositorError_VRCompositorError_IsNotSceneApplication = 103,
+	EVRCompositorError_VRCompositorError_TextureIsOnWrongDevice = 104,
+	EVRCompositorError_VRCompositorError_TextureUsesUnsupportedFormat = 105,
+	EVRCompositorError_VRCompositorError_SharedTexturesNotSupported = 106,
+	EVRCompositorError_VRCompositorError_IndexOutOfRange = 107,
+	EVRCompositorError_VRCompositorError_AlreadySubmitted = 108,
+	EVRCompositorError_VRCompositorError_InvalidBounds = 109,
+} EVRCompositorError;
+
+typedef enum VROverlayInputMethod
+{
+	VROverlayInputMethod_None = 0,
+	VROverlayInputMethod_Mouse = 1,
+} VROverlayInputMethod;
+
+typedef enum VROverlayTransformType
+{
+	VROverlayTransformType_VROverlayTransform_Absolute = 0,
+	VROverlayTransformType_VROverlayTransform_TrackedDeviceRelative = 1,
+	VROverlayTransformType_VROverlayTransform_SystemOverlay = 2,
+	VROverlayTransformType_VROverlayTransform_TrackedComponent = 3,
+} VROverlayTransformType;
+
+typedef enum VROverlayFlags
+{
+	VROverlayFlags_None = 0,
+	VROverlayFlags_Curved = 1,
+	VROverlayFlags_RGSS4X = 2,
+	VROverlayFlags_NoDashboardTab = 3,
+	VROverlayFlags_AcceptsGamepadEvents = 4,
+	VROverlayFlags_ShowGamepadFocus = 5,
+	VROverlayFlags_SendVRScrollEvents = 6,
+	VROverlayFlags_SendVRTouchpadEvents = 7,
+	VROverlayFlags_ShowTouchPadScrollWheel = 8,
+	VROverlayFlags_TransferOwnershipToInternalProcess = 9,
+	VROverlayFlags_SideBySide_Parallel = 10,
+	VROverlayFlags_SideBySide_Crossed = 11,
+	VROverlayFlags_Panorama = 12,
+	VROverlayFlags_StereoPanorama = 13,
+	VROverlayFlags_SortWithNonSceneOverlays = 14,
+	VROverlayFlags_VisibleInDashboard = 15,
+} VROverlayFlags;
+
+typedef enum VRMessageOverlayResponse
+{
+	VRMessageOverlayResponse_ButtonPress_0 = 0,
+	VRMessageOverlayResponse_ButtonPress_1 = 1,
+	VRMessageOverlayResponse_ButtonPress_2 = 2,
+	VRMessageOverlayResponse_ButtonPress_3 = 3,
+	VRMessageOverlayResponse_CouldntFindSystemOverlay = 4,
+	VRMessageOverlayResponse_CouldntFindOrCreateClientOverlay = 5,
+	VRMessageOverlayResponse_ApplicationQuit = 6,
+} VRMessageOverlayResponse;
+
+typedef enum EGamepadTextInputMode
+{
+	EGamepadTextInputMode_k_EGamepadTextInputModeNormal = 0,
+	EGamepadTextInputMode_k_EGamepadTextInputModePassword = 1,
+	EGamepadTextInputMode_k_EGamepadTextInputModeSubmit = 2,
+} EGamepadTextInputMode;
+
+typedef enum EGamepadTextInputLineMode
+{
+	EGamepadTextInputLineMode_k_EGamepadTextInputLineModeSingleLine = 0,
+	EGamepadTextInputLineMode_k_EGamepadTextInputLineModeMultipleLines = 1,
+} EGamepadTextInputLineMode;
+
+typedef enum EOverlayDirection
+{
+	EOverlayDirection_OverlayDirection_Up = 0,
+	EOverlayDirection_OverlayDirection_Down = 1,
+	EOverlayDirection_OverlayDirection_Left = 2,
+	EOverlayDirection_OverlayDirection_Right = 3,
+	EOverlayDirection_OverlayDirection_Count = 4,
+} EOverlayDirection;
+
+typedef enum EVROverlayIntersectionMaskPrimitiveType
+{
+	EVROverlayIntersectionMaskPrimitiveType_OverlayIntersectionPrimitiveType_Rectangle = 0,
+	EVROverlayIntersectionMaskPrimitiveType_OverlayIntersectionPrimitiveType_Circle = 1,
+} EVROverlayIntersectionMaskPrimitiveType;
+
+typedef enum EVRRenderModelError
+{
+	EVRRenderModelError_VRRenderModelError_None = 0,
+	EVRRenderModelError_VRRenderModelError_Loading = 100,
+	EVRRenderModelError_VRRenderModelError_NotSupported = 200,
+	EVRRenderModelError_VRRenderModelError_InvalidArg = 300,
+	EVRRenderModelError_VRRenderModelError_InvalidModel = 301,
+	EVRRenderModelError_VRRenderModelError_NoShapes = 302,
+	EVRRenderModelError_VRRenderModelError_MultipleShapes = 303,
+	EVRRenderModelError_VRRenderModelError_TooManyVertices = 304,
+	EVRRenderModelError_VRRenderModelError_MultipleTextures = 305,
+	EVRRenderModelError_VRRenderModelError_BufferTooSmall = 306,
+	EVRRenderModelError_VRRenderModelError_NotEnoughNormals = 307,
+	EVRRenderModelError_VRRenderModelError_NotEnoughTexCoords = 308,
+	EVRRenderModelError_VRRenderModelError_InvalidTexture = 400,
+} EVRRenderModelError;
+
+typedef enum EVRComponentProperty
+{
+	EVRComponentProperty_VRComponentProperty_IsStatic = 1,
+	EVRComponentProperty_VRComponentProperty_IsVisible = 2,
+	EVRComponentProperty_VRComponentProperty_IsTouched = 4,
+	EVRComponentProperty_VRComponentProperty_IsPressed = 8,
+	EVRComponentProperty_VRComponentProperty_IsScrolled = 16,
+} EVRComponentProperty;
+
+typedef enum EVRNotificationType
+{
+	EVRNotificationType_Transient = 0,
+	EVRNotificationType_Persistent = 1,
+	EVRNotificationType_Transient_SystemWithUserValue = 2,
+} EVRNotificationType;
+
+typedef enum EVRNotificationStyle
+{
+	EVRNotificationStyle_None = 0,
+	EVRNotificationStyle_Application = 100,
+	EVRNotificationStyle_Contact_Disabled = 200,
+	EVRNotificationStyle_Contact_Enabled = 201,
+	EVRNotificationStyle_Contact_Active = 202,
+} EVRNotificationStyle;
+
+typedef enum EVRSettingsError
+{
+	EVRSettingsError_VRSettingsError_None = 0,
+	EVRSettingsError_VRSettingsError_IPCFailed = 1,
+	EVRSettingsError_VRSettingsError_WriteFailed = 2,
+	EVRSettingsError_VRSettingsError_ReadFailed = 3,
+	EVRSettingsError_VRSettingsError_JsonParseFailed = 4,
+	EVRSettingsError_VRSettingsError_UnsetSettingHasNoDefault = 5,
+} EVRSettingsError;
+
+typedef enum EVRScreenshotError
+{
+	EVRScreenshotError_VRScreenshotError_None = 0,
+	EVRScreenshotError_VRScreenshotError_RequestFailed = 1,
+	EVRScreenshotError_VRScreenshotError_IncompatibleVersion = 100,
+	EVRScreenshotError_VRScreenshotError_NotFound = 101,
+	EVRScreenshotError_VRScreenshotError_BufferTooSmall = 102,
+	EVRScreenshotError_VRScreenshotError_ScreenshotAlreadyInProgress = 108,
+} EVRScreenshotError;
+
+// OpenVR typedefs
+
+typedef uint32_t TrackedDeviceIndex_t;
+typedef uint32_t VRNotificationId;
+typedef uint64_t VROverlayHandle_t;
+
+typedef void *glSharedTextureHandle_t;
+typedef int32_t glInt_t;
+typedef uint32_t glUInt_t;
+typedef uint64_t SharedTextureHandle_t;
+typedef uint32_t DriverId_t;
+typedef uint32_t TrackedDeviceIndex_t;
+typedef uint64_t PropertyContainerHandle_t;
+typedef uint32_t PropertyTypeTag_t;
+typedef uint64_t VROverlayHandle_t;
+typedef uint64_t TrackedCameraHandle_t;
+typedef uint32_t ScreenshotHandle_t;
+typedef uint32_t VRComponentProperties;
+typedef int32_t TextureID_t;
+typedef uint32_t VRNotificationId;
+typedef EVRInitError HmdError;
+typedef EVREye Hmd_Eye;
+typedef EColorSpace ColorSpace;
+typedef ETrackingResult HmdTrackingResult;
+typedef ETrackedDeviceClass TrackedDeviceClass;
+typedef ETrackingUniverseOrigin TrackingUniverseOrigin;
+typedef ETrackedDeviceProperty TrackedDeviceProperty;
+typedef ETrackedPropertyError TrackedPropertyError;
+typedef EVRSubmitFlags VRSubmitFlags_t;
+typedef EVRState VRState_t;
+typedef ECollisionBoundsStyle CollisionBoundsStyle_t;
+typedef EVROverlayError VROverlayError;
+typedef EVRFirmwareError VRFirmwareError;
+typedef EVRCompositorError VRCompositorError;
+typedef EVRScreenshotError VRScreenshotsError;
+
+// OpenVR Structs
+
+typedef struct HmdMatrix34_t
+{
+	float m[3][4];  //float[3][4]
+} HmdMatrix34_t;
+
+typedef struct HmdMatrix44_t
+{
+	float m[4][4];  //float[4][4]
+} HmdMatrix44_t;
+
+typedef struct HmdVector3_t
+{
+	float v[3];  //float[3]
+} HmdVector3_t;
+
+typedef struct HmdVector4_t
+{
+	float v[4];  //float[4]
+} HmdVector4_t;
+
+typedef struct HmdVector3d_t
+{
+	double v[3];  //double[3]
+} HmdVector3d_t;
+
+typedef struct HmdVector2_t
+{
+	float v[2];  //float[2]
+} HmdVector2_t;
+
+typedef struct HmdQuaternion_t
+{
+	double w;
+	double x;
+	double y;
+	double z;
+} HmdQuaternion_t;
+
+typedef struct HmdColor_t
+{
+	float r;
+	float g;
+	float b;
+	float a;
+} HmdColor_t;
+
+typedef struct HmdQuad_t
+{
+	struct HmdVector3_t vCorners[4];  //struct vr::HmdVector3_t[4]
+} HmdQuad_t;
+
+typedef struct HmdRect2_t
+{
+	struct HmdVector2_t vTopLeft;
+	struct HmdVector2_t vBottomRight;
+} HmdRect2_t;
+
+typedef struct DistortionCoordinates_t
+{
+	float rfRed[2];    //float[2]
+	float rfGreen[2];  //float[2]
+	float rfBlue[2];   //float[2]
+} DistortionCoordinates_t;
+
+typedef struct Texture_t
+{
+	void *handle;  // void *
+	enum ETextureType eType;
+	enum EColorSpace eColorSpace;
+} Texture_t;
+
+typedef struct TrackedDevicePose_t
+{
+	struct HmdMatrix34_t mDeviceToAbsoluteTracking;
+	struct HmdVector3_t vVelocity;
+	struct HmdVector3_t vAngularVelocity;
+	enum ETrackingResult eTrackingResult;
+	bool bPoseIsValid;
+	bool bDeviceIsConnected;
+} TrackedDevicePose_t;
+
+typedef struct VRTextureBounds_t
+{
+	float uMin;
+	float vMin;
+	float uMax;
+	float vMax;
+} VRTextureBounds_t;
+
+typedef struct VRTextureWithPose_t
+{
+	struct HmdMatrix34_t mDeviceToAbsoluteTracking;
+} VRTextureWithPose_t;
+
+typedef struct VRVulkanTextureData_t
+{
+	uint64_t m_nImage;
+	struct VkDevice_T *m_pDevice;                  // struct VkDevice_T *
+	struct VkPhysicalDevice_T *m_pPhysicalDevice;  // struct VkPhysicalDevice_T *
+	struct VkInstance_T *m_pInstance;              // struct VkInstance_T *
+	struct VkQueue_T *m_pQueue;                    // struct VkQueue_T *
+	uint32_t m_nQueueFamilyIndex;
+	uint32_t m_nWidth;
+	uint32_t m_nHeight;
+	uint32_t m_nFormat;
+	uint32_t m_nSampleCount;
+} VRVulkanTextureData_t;
+
+typedef struct D3D12TextureData_t
+{
+	struct ID3D12Resource *m_pResource;          // struct ID3D12Resource *
+	struct ID3D12CommandQueue *m_pCommandQueue;  // struct ID3D12CommandQueue *
+	uint32_t m_nNodeMask;
+} D3D12TextureData_t;
+
+typedef struct VREvent_Controller_t
+{
+	uint32_t button;
+} VREvent_Controller_t;
+
+typedef struct VREvent_Mouse_t
+{
+	float x;
+	float y;
+	uint32_t button;
+} VREvent_Mouse_t;
+
+typedef struct VREvent_Scroll_t
+{
+	float xdelta;
+	float ydelta;
+	uint32_t repeatCount;
+} VREvent_Scroll_t;
+
+typedef struct VREvent_TouchPadMove_t
+{
+	bool bFingerDown;
+	float flSecondsFingerDown;
+	float fValueXFirst;
+	float fValueYFirst;
+	float fValueXRaw;
+	float fValueYRaw;
+} VREvent_TouchPadMove_t;
+
+typedef struct VREvent_Notification_t
+{
+	uint64_t ulUserValue;
+	uint32_t notificationId;
+} VREvent_Notification_t;
+
+typedef struct VREvent_Process_t
+{
+	uint32_t pid;
+	uint32_t oldPid;
+	bool bForced;
+} VREvent_Process_t;
+
+typedef struct VREvent_Overlay_t
+{
+	uint64_t overlayHandle;
+} VREvent_Overlay_t;
+
+typedef struct VREvent_Status_t
+{
+	uint32_t statusState;
+} VREvent_Status_t;
+
+typedef struct VREvent_Keyboard_t
+{
+	char *cNewInput[8];  //char[8]
+	uint64_t uUserValue;
+} VREvent_Keyboard_t;
+
+typedef struct VREvent_Ipd_t
+{
+	float ipdMeters;
+} VREvent_Ipd_t;
+
+typedef struct VREvent_Chaperone_t
+{
+	uint64_t m_nPreviousUniverse;
+	uint64_t m_nCurrentUniverse;
+} VREvent_Chaperone_t;
+
+typedef struct VREvent_Reserved_t
+{
+	uint64_t reserved0;
+	uint64_t reserved1;
+} VREvent_Reserved_t;
+
+typedef struct VREvent_PerformanceTest_t
+{
+	uint32_t m_nFidelityLevel;
+} VREvent_PerformanceTest_t;
+
+typedef struct VREvent_SeatedZeroPoseReset_t
+{
+	bool bResetBySystemMenu;
+} VREvent_SeatedZeroPoseReset_t;
+
+typedef struct VREvent_Screenshot_t
+{
+	uint32_t handle;
+	uint32_t type;
+} VREvent_Screenshot_t;
+
+typedef struct VREvent_ScreenshotProgress_t
+{
+	float progress;
+} VREvent_ScreenshotProgress_t;
+
+typedef struct VREvent_ApplicationLaunch_t
+{
+	uint32_t pid;
+	uint32_t unArgsHandle;
+} VREvent_ApplicationLaunch_t;
+
+typedef struct VREvent_EditingCameraSurface_t
+{
+	uint64_t overlayHandle;
+	uint32_t nVisualMode;
+} VREvent_EditingCameraSurface_t;
+
+typedef struct VREvent_MessageOverlay_t
+{
+	uint32_t unVRMessageOverlayResponse;
+} VREvent_MessageOverlay_t;
+
+typedef struct VREvent_Property_t
+{
+	PropertyContainerHandle_t container;
+	enum ETrackedDeviceProperty prop;
+} VREvent_Property_t;
+
+typedef struct HiddenAreaMesh_t
+{
+	struct HmdVector2_t *pVertexData;  // const struct vr::HmdVector2_t *
+	uint32_t unTriangleCount;
+} HiddenAreaMesh_t;
+
+typedef struct VRControllerAxis_t
+{
+	float x;
+	float y;
+} VRControllerAxis_t;
+
+typedef struct VRControllerState_t
+{
+	uint32_t unPacketNum;
+	uint64_t ulButtonPressed;
+	uint64_t ulButtonTouched;
+	struct VRControllerAxis_t rAxis[5];  //struct vr::VRControllerAxis_t[5]
+} VRControllerState_t;
+
+typedef struct Compositor_OverlaySettings
+{
+	uint32_t size;
+	bool curved;
+	bool antialias;
+	float scale;
+	float distance;
+	float alpha;
+	float uOffset;
+	float vOffset;
+	float uScale;
+	float vScale;
+	float gridDivs;
+	float gridWidth;
+	float gridScale;
+	struct HmdMatrix44_t transform;
+} Compositor_OverlaySettings;
+
+typedef struct CameraVideoStreamFrameHeader_t
+{
+	enum EVRTrackedCameraFrameType eFrameType;
+	uint32_t nWidth;
+	uint32_t nHeight;
+	uint32_t nBytesPerPixel;
+	uint32_t nFrameSequence;
+	struct TrackedDevicePose_t standingTrackedDevicePose;
+} CameraVideoStreamFrameHeader_t;
+
+typedef struct AppOverrideKeys_t
+{
+	char *pchKey;    // const char *
+	char *pchValue;  // const char *
+} AppOverrideKeys_t;
+
+typedef struct Compositor_FrameTiming
+{
+	uint32_t m_nSize;
+	uint32_t m_nFrameIndex;
+	uint32_t m_nNumFramePresents;
+	uint32_t m_nNumMisPresented;
+	uint32_t m_nNumDroppedFrames;
+	uint32_t m_nReprojectionFlags;
+	double m_flSystemTimeInSeconds;
+	float m_flPreSubmitGpuMs;
+	float m_flPostSubmitGpuMs;
+	float m_flTotalRenderGpuMs;
+	float m_flCompositorRenderGpuMs;
+	float m_flCompositorRenderCpuMs;
+	float m_flCompositorIdleCpuMs;
+	float m_flClientFrameIntervalMs;
+	float m_flPresentCallCpuMs;
+	float m_flWaitForPresentCpuMs;
+	float m_flSubmitFrameMs;
+	float m_flWaitGetPosesCalledMs;
+	float m_flNewPosesReadyMs;
+	float m_flNewFrameReadyMs;
+	float m_flCompositorUpdateStartMs;
+	float m_flCompositorUpdateEndMs;
+	float m_flCompositorRenderStartMs;
+	TrackedDevicePose_t m_HmdPose;
+} Compositor_FrameTiming;
+
+typedef struct Compositor_CumulativeStats
+{
+	uint32_t m_nPid;
+	uint32_t m_nNumFramePresents;
+	uint32_t m_nNumDroppedFrames;
+	uint32_t m_nNumReprojectedFrames;
+	uint32_t m_nNumFramePresentsOnStartup;
+	uint32_t m_nNumDroppedFramesOnStartup;
+	uint32_t m_nNumReprojectedFramesOnStartup;
+	uint32_t m_nNumLoading;
+	uint32_t m_nNumFramePresentsLoading;
+	uint32_t m_nNumDroppedFramesLoading;
+	uint32_t m_nNumReprojectedFramesLoading;
+	uint32_t m_nNumTimedOut;
+	uint32_t m_nNumFramePresentsTimedOut;
+	uint32_t m_nNumDroppedFramesTimedOut;
+	uint32_t m_nNumReprojectedFramesTimedOut;
+} Compositor_CumulativeStats;
+
+typedef struct VROverlayIntersectionParams_t
+{
+	struct HmdVector3_t vSource;
+	struct HmdVector3_t vDirection;
+	enum ETrackingUniverseOrigin eOrigin;
+} VROverlayIntersectionParams_t;
+
+typedef struct VROverlayIntersectionResults_t
+{
+	struct HmdVector3_t vPoint;
+	struct HmdVector3_t vNormal;
+	struct HmdVector2_t vUVs;
+	float fDistance;
+} VROverlayIntersectionResults_t;
+
+typedef struct IntersectionMaskRectangle_t
+{
+	float m_flTopLeftX;
+	float m_flTopLeftY;
+	float m_flWidth;
+	float m_flHeight;
+} IntersectionMaskRectangle_t;
+
+typedef struct IntersectionMaskCircle_t
+{
+	float m_flCenterX;
+	float m_flCenterY;
+	float m_flRadius;
+} IntersectionMaskCircle_t;
+
+typedef struct RenderModel_ComponentState_t
+{
+	struct HmdMatrix34_t mTrackingToComponentRenderModel;
+	struct HmdMatrix34_t mTrackingToComponentLocal;
+	VRComponentProperties uProperties;
+} RenderModel_ComponentState_t;
+
+typedef struct RenderModel_Vertex_t
+{
+	struct HmdVector3_t vPosition;
+	struct HmdVector3_t vNormal;
+	float rfTextureCoord[2];  //float[2]
+} RenderModel_Vertex_t;
+
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(push, 4)
+#endif
+typedef struct RenderModel_TextureMap_t
+{
+	uint16_t unWidth;
+	uint16_t unHeight;
+	uint8_t *rubTextureMapData;  // const uint8_t *
+} RenderModel_TextureMap_t;
+
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(push, 4)
+#endif
+typedef struct RenderModel_t
+{
+	struct RenderModel_Vertex_t *rVertexData;  // const struct vr::RenderModel_Vertex_t *
+	uint32_t unVertexCount;
+	uint16_t *rIndexData;  // const uint16_t *
+	uint32_t unTriangleCount;
+	TextureID_t diffuseTextureId;
+} RenderModel_t;
+
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+typedef struct RenderModel_ControllerMode_State_t
+{
+	bool bScrollWheelVisible;
+} RenderModel_ControllerMode_State_t;
+
+typedef struct NotificationBitmap_t
+{
+	void *m_pImageData;  // void *
+	int32_t m_nWidth;
+	int32_t m_nHeight;
+	int32_t m_nBytesPerPixel;
+} NotificationBitmap_t;
+
+typedef struct COpenVRContext
+{
+	intptr_t m_pVRSystem;           // class vr::IVRSystem *
+	intptr_t m_pVRChaperone;        // class vr::IVRChaperone *
+	intptr_t m_pVRChaperoneSetup;   // class vr::IVRChaperoneSetup *
+	intptr_t m_pVRCompositor;       // class vr::IVRCompositor *
+	intptr_t m_pVROverlay;          // class vr::IVROverlay *
+	intptr_t m_pVRResources;        // class vr::IVRResources *
+	intptr_t m_pVRRenderModels;     // class vr::IVRRenderModels *
+	intptr_t m_pVRExtendedDisplay;  // class vr::IVRExtendedDisplay *
+	intptr_t m_pVRSettings;         // class vr::IVRSettings *
+	intptr_t m_pVRApplications;     // class vr::IVRApplications *
+	intptr_t m_pVRTrackedCamera;    // class vr::IVRTrackedCamera *
+	intptr_t m_pVRScreenshots;      // class vr::IVRScreenshots *
+	intptr_t m_pVRDriverManager;    // class vr::IVRDriverManager *
+} COpenVRContext;
+
+typedef union {
+	VREvent_Reserved_t reserved;
+	VREvent_Controller_t controller;
+	VREvent_Mouse_t mouse;
+	VREvent_Scroll_t scroll;
+	VREvent_Process_t process;
+	VREvent_Notification_t notification;
+	VREvent_Overlay_t overlay;
+	VREvent_Status_t status;
+	VREvent_Keyboard_t keyboard;
+	VREvent_Ipd_t ipd;
+	VREvent_Chaperone_t chaperone;
+	VREvent_PerformanceTest_t performanceTest;
+	VREvent_TouchPadMove_t touchPadMove;
+	VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset;
+} VREvent_Data_t;
+
+/** An event posted by the server to all running applications */
+struct VREvent_t
+{
+	uint32_t eventType;  // EVREventType enum
+	TrackedDeviceIndex_t trackedDeviceIndex;
+	float eventAgeSeconds;
+	// event data must be the end of the struct as its size is variable
+	VREvent_Data_t data;
+};
+
+typedef union {
+	IntersectionMaskRectangle_t m_Rectangle;
+	IntersectionMaskCircle_t m_Circle;
+} VROverlayIntersectionMaskPrimitive_Data_t;
+
+struct VROverlayIntersectionMaskPrimitive_t
+{
+	EVROverlayIntersectionMaskPrimitiveType m_nPrimitiveType;
+	VROverlayIntersectionMaskPrimitive_Data_t m_Primitive;
+};
+
+// OpenVR Function Pointer Tables
+
+struct VR_IVRSystem_FnTable
+{
+	void(OPENVR_FNTABLE_CALLTYPE *GetRecommendedRenderTargetSize)(uint32_t *pnWidth, uint32_t *pnHeight);
+	struct HmdMatrix44_t(OPENVR_FNTABLE_CALLTYPE *GetProjectionMatrix)(EVREye eEye, float fNearZ, float fFarZ);
+	void(OPENVR_FNTABLE_CALLTYPE *GetProjectionRaw)(EVREye eEye, float *pfLeft, float *pfRight, float *pfTop, float *pfBottom);
+	bool(OPENVR_FNTABLE_CALLTYPE *ComputeDistortion)(EVREye eEye, float fU, float fV, struct DistortionCoordinates_t *pDistortionCoordinates);
+	struct HmdMatrix34_t(OPENVR_FNTABLE_CALLTYPE *GetEyeToHeadTransform)(EVREye eEye);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetTimeSinceLastVsync)(float *pfSecondsSinceLastVsync, uint64_t *pulFrameCounter);
+	int32_t(OPENVR_FNTABLE_CALLTYPE *GetD3D9AdapterIndex)();
+	void(OPENVR_FNTABLE_CALLTYPE *GetDXGIOutputInfo)(int32_t *pnAdapterIndex);
+	void(OPENVR_FNTABLE_CALLTYPE *GetOutputDevice)(uint64_t *pnDevice, ETextureType textureType, struct VkInstance_T *pInstance);
+	bool(OPENVR_FNTABLE_CALLTYPE *IsDisplayOnDesktop)();
+	bool(OPENVR_FNTABLE_CALLTYPE *SetDisplayVisibility)(bool bIsVisibleOnDesktop);
+	void(OPENVR_FNTABLE_CALLTYPE *GetDeviceToAbsoluteTrackingPose)(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, struct TrackedDevicePose_t *pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount);
+	void(OPENVR_FNTABLE_CALLTYPE *ResetSeatedZeroPose)();
+	struct HmdMatrix34_t(OPENVR_FNTABLE_CALLTYPE *GetSeatedZeroPoseToStandingAbsoluteTrackingPose)();
+	struct HmdMatrix34_t(OPENVR_FNTABLE_CALLTYPE *GetRawZeroPoseToStandingAbsoluteTrackingPose)();
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetSortedTrackedDeviceIndicesOfClass)(ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t *punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex);
+	EDeviceActivityLevel(OPENVR_FNTABLE_CALLTYPE *GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId);
+	void(OPENVR_FNTABLE_CALLTYPE *ApplyTransform)(struct TrackedDevicePose_t *pOutputPose, struct TrackedDevicePose_t *pTrackedDevicePose, struct HmdMatrix34_t *pTransform);
+	TrackedDeviceIndex_t(OPENVR_FNTABLE_CALLTYPE *GetTrackedDeviceIndexForControllerRole)(ETrackedControllerRole unDeviceType);
+	ETrackedControllerRole(OPENVR_FNTABLE_CALLTYPE *GetControllerRoleForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex);
+	ETrackedDeviceClass(OPENVR_FNTABLE_CALLTYPE *GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex);
+	bool(OPENVR_FNTABLE_CALLTYPE *IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError);
+	float(OPENVR_FNTABLE_CALLTYPE *GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError);
+	int32_t(OPENVR_FNTABLE_CALLTYPE *GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError);
+	uint64_t(OPENVR_FNTABLE_CALLTYPE *GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError);
+	struct HmdMatrix34_t(OPENVR_FNTABLE_CALLTYPE *GetMatrix34TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetPropErrorNameFromEnum)(ETrackedPropertyError error);
+	bool(OPENVR_FNTABLE_CALLTYPE *PollNextEvent)(struct VREvent_t *pEvent, uint32_t uncbVREvent);
+	bool(OPENVR_FNTABLE_CALLTYPE *PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, struct VREvent_t *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetEventTypeNameFromEnum)(EVREventType eType);
+	struct HiddenAreaMesh_t(OPENVR_FNTABLE_CALLTYPE *GetHiddenAreaMesh)(EVREye eEye, EHiddenAreaMeshType type);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t *pControllerState, uint32_t unControllerStateSize);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t *pControllerState, uint32_t unControllerStateSize, struct TrackedDevicePose_t *pTrackedDevicePose);
+	void(OPENVR_FNTABLE_CALLTYPE *TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetButtonIdNameFromEnum)(EVRButtonId eButtonId);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType);
+	bool(OPENVR_FNTABLE_CALLTYPE *CaptureInputFocus)();
+	void(OPENVR_FNTABLE_CALLTYPE *ReleaseInputFocus)();
+	bool(OPENVR_FNTABLE_CALLTYPE *IsInputFocusCapturedByAnotherProcess)();
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, char *pchRequest, char *pchResponseBuffer, uint32_t unResponseBufferSize);
+	EVRFirmwareError(OPENVR_FNTABLE_CALLTYPE *PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex);
+	void(OPENVR_FNTABLE_CALLTYPE *AcknowledgeQuit_Exiting)();
+	void(OPENVR_FNTABLE_CALLTYPE *AcknowledgeQuit_UserPrompt)();
+};
+
+struct VR_IVRExtendedDisplay_FnTable
+{
+	void(OPENVR_FNTABLE_CALLTYPE *GetWindowBounds)(int32_t *pnX, int32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight);
+	void(OPENVR_FNTABLE_CALLTYPE *GetEyeOutputViewport)(EVREye eEye, uint32_t *pnX, uint32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight);
+	void(OPENVR_FNTABLE_CALLTYPE *GetDXGIOutputInfo)(int32_t *pnAdapterIndex, int32_t *pnAdapterOutputIndex);
+};
+
+struct VR_IVRTrackedCamera_FnTable
+{
+	char *(OPENVR_FNTABLE_CALLTYPE *GetCameraErrorNameFromEnum)(EVRTrackedCameraError eCameraError);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *HasCamera)(TrackedDeviceIndex_t nDeviceIndex, bool *pHasCamera);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *GetCameraFrameSize)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, uint32_t *pnWidth, uint32_t *pnHeight, uint32_t *pnFrameBufferSize);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *GetCameraIntrinsics)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, HmdVector2_t *pFocalLength, HmdVector2_t *pCenter);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *GetCameraProjection)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, HmdMatrix44_t *pProjection);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *AcquireVideoStreamingService)(TrackedDeviceIndex_t nDeviceIndex, TrackedCameraHandle_t *pHandle);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *ReleaseVideoStreamingService)(TrackedCameraHandle_t hTrackedCamera);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *GetVideoStreamFrameBuffer)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void *pFrameBuffer, uint32_t nFrameBufferSize, CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *GetVideoStreamTextureSize)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, VRTextureBounds_t *pTextureBounds, uint32_t *pnWidth, uint32_t *pnHeight);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *GetVideoStreamTextureD3D11)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView, CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *GetVideoStreamTextureGL)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t *pglTextureId, CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *ReleaseVideoStreamTextureGL)(TrackedCameraHandle_t hTrackedCamera, glUInt_t glTextureId);
+};
+
+struct VR_IVRApplications_FnTable
+{
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *AddApplicationManifest)(char *pchApplicationManifestFullPath, bool bTemporary);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *RemoveApplicationManifest)(char *pchApplicationManifestFullPath);
+	bool(OPENVR_FNTABLE_CALLTYPE *IsApplicationInstalled)(char *pchAppKey);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetApplicationCount)();
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *GetApplicationKeyByIndex)(uint32_t unApplicationIndex, char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *GetApplicationKeyByProcessId)(uint32_t unProcessId, char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *LaunchApplication)(char *pchAppKey);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *LaunchTemplateApplication)(char *pchTemplateAppKey, char *pchNewAppKey, struct AppOverrideKeys_t *pKeys, uint32_t unKeys);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *LaunchApplicationFromMimeType)(char *pchMimeType, char *pchArgs);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *LaunchDashboardOverlay)(char *pchAppKey);
+	bool(OPENVR_FNTABLE_CALLTYPE *CancelApplicationLaunch)(char *pchAppKey);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *IdentifyApplication)(uint32_t unProcessId, char *pchAppKey);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetApplicationProcessId)(char *pchAppKey);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetApplicationsErrorNameFromEnum)(EVRApplicationError error);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetApplicationPropertyString)(char *pchAppKey, EVRApplicationProperty eProperty, char *pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError *peError);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetApplicationPropertyBool)(char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError);
+	uint64_t(OPENVR_FNTABLE_CALLTYPE *GetApplicationPropertyUint64)(char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *SetApplicationAutoLaunch)(char *pchAppKey, bool bAutoLaunch);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetApplicationAutoLaunch)(char *pchAppKey);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *SetDefaultApplicationForMimeType)(char *pchAppKey, char *pchMimeType);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetDefaultApplicationForMimeType)(char *pchMimeType, char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetApplicationSupportedMimeTypes)(char *pchAppKey, char *pchMimeTypesBuffer, uint32_t unMimeTypesBuffer);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetApplicationsThatSupportMimeType)(char *pchMimeType, char *pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetApplicationLaunchArguments)(uint32_t unHandle, char *pchArgs, uint32_t unArgs);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *GetStartingApplication)(char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+	EVRApplicationTransitionState(OPENVR_FNTABLE_CALLTYPE *GetTransitionState)();
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *PerformApplicationPrelaunchCheck)(char *pchAppKey);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetApplicationsTransitionStateNameFromEnum)(EVRApplicationTransitionState state);
+	bool(OPENVR_FNTABLE_CALLTYPE *IsQuitUserPromptRequested)();
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *LaunchInternalProcess)(char *pchBinaryPath, char *pchArguments, char *pchWorkingDirectory);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetCurrentSceneProcessId)();
+};
+
+struct VR_IVRChaperone_FnTable
+{
+	ChaperoneCalibrationState(OPENVR_FNTABLE_CALLTYPE *GetCalibrationState)();
+	bool(OPENVR_FNTABLE_CALLTYPE *GetPlayAreaSize)(float *pSizeX, float *pSizeZ);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetPlayAreaRect)(struct HmdQuad_t *rect);
+	void(OPENVR_FNTABLE_CALLTYPE *ReloadInfo)();
+	void(OPENVR_FNTABLE_CALLTYPE *SetSceneColor)(struct HmdColor_t color);
+	void(OPENVR_FNTABLE_CALLTYPE *GetBoundsColor)(struct HmdColor_t *pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, struct HmdColor_t *pOutputCameraColor);
+	bool(OPENVR_FNTABLE_CALLTYPE *AreBoundsVisible)();
+	void(OPENVR_FNTABLE_CALLTYPE *ForceBoundsVisible)(bool bForce);
+};
+
+struct VR_IVRChaperoneSetup_FnTable
+{
+	bool(OPENVR_FNTABLE_CALLTYPE *CommitWorkingCopy)(EChaperoneConfigFile configFile);
+	void(OPENVR_FNTABLE_CALLTYPE *RevertWorkingCopy)();
+	bool(OPENVR_FNTABLE_CALLTYPE *GetWorkingPlayAreaSize)(float *pSizeX, float *pSizeZ);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetWorkingPlayAreaRect)(struct HmdQuad_t *rect);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetWorkingCollisionBoundsInfo)(struct HmdQuad_t *pQuadsBuffer, uint32_t *punQuadsCount);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetLiveCollisionBoundsInfo)(struct HmdQuad_t *pQuadsBuffer, uint32_t *punQuadsCount);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetWorkingSeatedZeroPoseToRawTrackingPose)(struct HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetWorkingStandingZeroPoseToRawTrackingPose)(struct HmdMatrix34_t *pmatStandingZeroPoseToRawTrackingPose);
+	void(OPENVR_FNTABLE_CALLTYPE *SetWorkingPlayAreaSize)(float sizeX, float sizeZ);
+	void(OPENVR_FNTABLE_CALLTYPE *SetWorkingCollisionBoundsInfo)(struct HmdQuad_t *pQuadsBuffer, uint32_t unQuadsCount);
+	void(OPENVR_FNTABLE_CALLTYPE *SetWorkingSeatedZeroPoseToRawTrackingPose)(struct HmdMatrix34_t *pMatSeatedZeroPoseToRawTrackingPose);
+	void(OPENVR_FNTABLE_CALLTYPE *SetWorkingStandingZeroPoseToRawTrackingPose)(struct HmdMatrix34_t *pMatStandingZeroPoseToRawTrackingPose);
+	void(OPENVR_FNTABLE_CALLTYPE *ReloadFromDisk)(EChaperoneConfigFile configFile);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetLiveSeatedZeroPoseToRawTrackingPose)(struct HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose);
+	void(OPENVR_FNTABLE_CALLTYPE *SetWorkingCollisionBoundsTagsInfo)(uint8_t *pTagsBuffer, uint32_t unTagCount);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetLiveCollisionBoundsTagsInfo)(uint8_t *pTagsBuffer, uint32_t *punTagCount);
+	bool(OPENVR_FNTABLE_CALLTYPE *SetWorkingPhysicalBoundsInfo)(struct HmdQuad_t *pQuadsBuffer, uint32_t unQuadsCount);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetLivePhysicalBoundsInfo)(struct HmdQuad_t *pQuadsBuffer, uint32_t *punQuadsCount);
+	bool(OPENVR_FNTABLE_CALLTYPE *ExportLiveToBuffer)(char *pBuffer, uint32_t *pnBufferLength);
+	bool(OPENVR_FNTABLE_CALLTYPE *ImportFromBufferToWorking)(char *pBuffer, uint32_t nImportFlags);
+};
+
+struct VR_IVRCompositor_FnTable
+{
+	void(OPENVR_FNTABLE_CALLTYPE *SetTrackingSpace)(ETrackingUniverseOrigin eOrigin);
+	ETrackingUniverseOrigin(OPENVR_FNTABLE_CALLTYPE *GetTrackingSpace)();
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *WaitGetPoses)(struct TrackedDevicePose_t *pRenderPoseArray, uint32_t unRenderPoseArrayCount, struct TrackedDevicePose_t *pGamePoseArray, uint32_t unGamePoseArrayCount);
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *GetLastPoses)(struct TrackedDevicePose_t *pRenderPoseArray, uint32_t unRenderPoseArrayCount, struct TrackedDevicePose_t *pGamePoseArray, uint32_t unGamePoseArrayCount);
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, struct TrackedDevicePose_t *pOutputPose, struct TrackedDevicePose_t *pOutputGamePose);
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *Submit)(EVREye eEye, struct Texture_t *pTexture, struct VRTextureBounds_t *pBounds, EVRSubmitFlags nSubmitFlags);
+	void(OPENVR_FNTABLE_CALLTYPE *ClearLastSubmittedFrame)();
+	void(OPENVR_FNTABLE_CALLTYPE *PostPresentHandoff)();
+	bool(OPENVR_FNTABLE_CALLTYPE *GetFrameTiming)(struct Compositor_FrameTiming *pTiming, uint32_t unFramesAgo);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetFrameTimings)(struct Compositor_FrameTiming *pTiming, uint32_t nFrames);
+	float(OPENVR_FNTABLE_CALLTYPE *GetFrameTimeRemaining)();
+	void(OPENVR_FNTABLE_CALLTYPE *GetCumulativeStats)(struct Compositor_CumulativeStats *pStats, uint32_t nStatsSizeInBytes);
+	void(OPENVR_FNTABLE_CALLTYPE *FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
+	struct HmdColor_t(OPENVR_FNTABLE_CALLTYPE *GetCurrentFadeColor)(bool bBackground);
+	void(OPENVR_FNTABLE_CALLTYPE *FadeGrid)(float fSeconds, bool bFadeIn);
+	float(OPENVR_FNTABLE_CALLTYPE *GetCurrentGridAlpha)();
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *SetSkyboxOverride)(struct Texture_t *pTextures, uint32_t unTextureCount);
+	void(OPENVR_FNTABLE_CALLTYPE *ClearSkyboxOverride)();
+	void(OPENVR_FNTABLE_CALLTYPE *CompositorBringToFront)();
+	void(OPENVR_FNTABLE_CALLTYPE *CompositorGoToBack)();
+	void(OPENVR_FNTABLE_CALLTYPE *CompositorQuit)();
+	bool(OPENVR_FNTABLE_CALLTYPE *IsFullscreen)();
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetCurrentSceneFocusProcess)();
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetLastFrameRenderer)();
+	bool(OPENVR_FNTABLE_CALLTYPE *CanRenderScene)();
+	void(OPENVR_FNTABLE_CALLTYPE *ShowMirrorWindow)();
+	void(OPENVR_FNTABLE_CALLTYPE *HideMirrorWindow)();
+	bool(OPENVR_FNTABLE_CALLTYPE *IsMirrorWindowVisible)();
+	void(OPENVR_FNTABLE_CALLTYPE *CompositorDumpImages)();
+	bool(OPENVR_FNTABLE_CALLTYPE *ShouldAppRenderWithLowResources)();
+	void(OPENVR_FNTABLE_CALLTYPE *ForceInterleavedReprojectionOn)(bool bOverride);
+	void(OPENVR_FNTABLE_CALLTYPE *ForceReconnectProcess)();
+	void(OPENVR_FNTABLE_CALLTYPE *SuspendRendering)(bool bSuspend);
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *GetMirrorTextureD3D11)(EVREye eEye, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView);
+	void(OPENVR_FNTABLE_CALLTYPE *ReleaseMirrorTextureD3D11)(void *pD3D11ShaderResourceView);
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *GetMirrorTextureGL)(EVREye eEye, glUInt_t *pglTextureId, glSharedTextureHandle_t *pglSharedTextureHandle);
+	bool(OPENVR_FNTABLE_CALLTYPE *ReleaseSharedGLTexture)(glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle);
+	void(OPENVR_FNTABLE_CALLTYPE *LockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle);
+	void(OPENVR_FNTABLE_CALLTYPE *UnlockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetVulkanInstanceExtensionsRequired)(char *pchValue, uint32_t unBufferSize);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetVulkanDeviceExtensionsRequired)(struct VkPhysicalDevice_T *pPhysicalDevice, char *pchValue, uint32_t unBufferSize);
+	void(OPENVR_FNTABLE_CALLTYPE *SetExplicitTimingMode)(bool bExplicitTimingMode);
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *SubmitExplicitTimingData)();
+};
+
+struct VR_IVROverlay_FnTable
+{
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *FindOverlay)(char *pchOverlayKey, VROverlayHandle_t *pOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *CreateOverlay)(char *pchOverlayKey, char *pchOverlayName, VROverlayHandle_t *pOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *DestroyOverlay)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle);
+	VROverlayHandle_t(OPENVR_FNTABLE_CALLTYPE *GetHighQualityOverlay)();
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char *pchValue, uint32_t unBufferSize, EVROverlayError *pError);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char *pchValue, uint32_t unBufferSize, EVROverlayError *pError);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayName)(VROverlayHandle_t ulOverlayHandle, char *pchName);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unBufferSize, uint32_t *punWidth, uint32_t *punHeight);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetOverlayErrorNameFromEnum)(EVROverlayError error);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool *pbEnabled);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float *pfRed, float *pfGreen, float *pfBlue);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float *pfAlpha);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float fTexelAspect);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float *pfTexelAspect);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t *punSortOrder);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float *pfWidthInMeters);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float *pfMinDistanceInMeters, float *pfMaxDistanceInMeters);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace *peTextureColorSpace);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, struct VRTextureBounds_t *pOverlayTextureBounds);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, struct VRTextureBounds_t *pOverlayTextureBounds);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, char *pchValue, uint32_t unBufferSize, struct HmdColor_t *pColor, EVROverlayError *pError);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, char *pchRenderModel, struct HmdColor_t *pColor);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType *peTransformType);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, struct HmdMatrix34_t *pmatTrackingOriginToOverlayTransform);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin *peTrackingOrigin, struct HmdMatrix34_t *pmatTrackingOriginToOverlayTransform);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, struct HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punTrackedDevice, struct HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, char *pchComponentName);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punDeviceIndex, char *pchComponentName, uint32_t unComponentNameSize);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t *ulOverlayHandleParent, struct HmdMatrix34_t *pmatParentOverlayToOverlayTransform);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, struct HmdMatrix34_t *pmatParentOverlayToOverlayTransform);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *ShowOverlay)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *HideOverlay)(VROverlayHandle_t ulOverlayHandle);
+	bool(OPENVR_FNTABLE_CALLTYPE *IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, struct HmdVector2_t coordinatesInOverlay, struct HmdMatrix34_t *pmatTransform);
+	bool(OPENVR_FNTABLE_CALLTYPE *PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, struct VREvent_t *pEvent, uint32_t uncbVREvent);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod *peInputMethod);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, struct HmdVector2_t *pvecMouseScale);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, struct HmdVector2_t *pvecMouseScale);
+	bool(OPENVR_FNTABLE_CALLTYPE *ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, struct VROverlayIntersectionParams_t *pParams, struct VROverlayIntersectionResults_t *pResults);
+	bool(OPENVR_FNTABLE_CALLTYPE *HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex);
+	bool(OPENVR_FNTABLE_CALLTYPE *IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle);
+	VROverlayHandle_t(OPENVR_FNTABLE_CALLTYPE *GetGamepadFocusOverlay)();
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetGamepadFocusOverlay)(VROverlayHandle_t ulNewFocusOverlay);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *MoveGamepadFocusToNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, struct Texture_t *pTexture);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, char *pchFilePath);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void **pNativeTextureHandle, void *pNativeTextureRef, uint32_t *pWidth, uint32_t *pHeight, uint32_t *pNativeFormat, ETextureType *pAPIType, EColorSpace *pColorSpace, struct VRTextureBounds_t *pTextureBounds);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void *pNativeTextureHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t *pWidth, uint32_t *pHeight);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *CreateDashboardOverlay)(char *pchOverlayKey, char *pchOverlayFriendlyName, VROverlayHandle_t *pMainHandle, VROverlayHandle_t *pThumbnailHandle);
+	bool(OPENVR_FNTABLE_CALLTYPE *IsDashboardVisible)();
+	bool(OPENVR_FNTABLE_CALLTYPE *IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t *punProcessId);
+	void(OPENVR_FNTABLE_CALLTYPE *ShowDashboard)(char *pchOverlayToShow);
+	TrackedDeviceIndex_t(OPENVR_FNTABLE_CALLTYPE *GetPrimaryDashboardDevice)();
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, char *pchDescription, uint32_t unCharMax, char *pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, char *pchDescription, uint32_t unCharMax, char *pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetKeyboardText)(char *pchText, uint32_t cchText);
+	void(OPENVR_FNTABLE_CALLTYPE *HideKeyboard)();
+	void(OPENVR_FNTABLE_CALLTYPE *SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, struct HmdMatrix34_t *pmatTrackingOriginToKeyboardTransform);
+	void(OPENVR_FNTABLE_CALLTYPE *SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, struct HmdRect2_t avoidRect);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayIntersectionMask)(VROverlayHandle_t ulOverlayHandle, struct VROverlayIntersectionMaskPrimitive_t *pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayFlags)(VROverlayHandle_t ulOverlayHandle, uint32_t *pFlags);
+	VRMessageOverlayResponse(OPENVR_FNTABLE_CALLTYPE *ShowMessageOverlay)(char *pchText, char *pchCaption, char *pchButton0Text, char *pchButton1Text, char *pchButton2Text, char *pchButton3Text);
+	void(OPENVR_FNTABLE_CALLTYPE *CloseMessageOverlay)();
+};
+
+struct VR_IVRRenderModels_FnTable
+{
+	EVRRenderModelError(OPENVR_FNTABLE_CALLTYPE *LoadRenderModel_Async)(char *pchRenderModelName, struct RenderModel_t **ppRenderModel);
+	void(OPENVR_FNTABLE_CALLTYPE *FreeRenderModel)(struct RenderModel_t *pRenderModel);
+	EVRRenderModelError(OPENVR_FNTABLE_CALLTYPE *LoadTexture_Async)(TextureID_t textureId, struct RenderModel_TextureMap_t **ppTexture);
+	void(OPENVR_FNTABLE_CALLTYPE *FreeTexture)(struct RenderModel_TextureMap_t *pTexture);
+	EVRRenderModelError(OPENVR_FNTABLE_CALLTYPE *LoadTextureD3D11_Async)(TextureID_t textureId, void *pD3D11Device, void **ppD3D11Texture2D);
+	EVRRenderModelError(OPENVR_FNTABLE_CALLTYPE *LoadIntoTextureD3D11_Async)(TextureID_t textureId, void *pDstTexture);
+	void(OPENVR_FNTABLE_CALLTYPE *FreeTextureD3D11)(void *pD3D11Texture2D);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetRenderModelName)(uint32_t unRenderModelIndex, char *pchRenderModelName, uint32_t unRenderModelNameLen);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetRenderModelCount)();
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetComponentCount)(char *pchRenderModelName);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetComponentName)(char *pchRenderModelName, uint32_t unComponentIndex, char *pchComponentName, uint32_t unComponentNameLen);
+	uint64_t(OPENVR_FNTABLE_CALLTYPE *GetComponentButtonMask)(char *pchRenderModelName, char *pchComponentName);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetComponentRenderModelName)(char *pchRenderModelName, char *pchComponentName, char *pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetComponentState)(char *pchRenderModelName, char *pchComponentName, VRControllerState_t *pControllerState, struct RenderModel_ControllerMode_State_t *pState, struct RenderModel_ComponentState_t *pComponentState);
+	bool(OPENVR_FNTABLE_CALLTYPE *RenderModelHasComponent)(char *pchRenderModelName, char *pchComponentName);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetRenderModelThumbnailURL)(char *pchRenderModelName, char *pchThumbnailURL, uint32_t unThumbnailURLLen, EVRRenderModelError *peError);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetRenderModelOriginalPath)(char *pchRenderModelName, char *pchOriginalPath, uint32_t unOriginalPathLen, EVRRenderModelError *peError);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetRenderModelErrorNameFromEnum)(EVRRenderModelError error);
+};
+
+struct VR_IVRNotifications_FnTable
+{
+	EVRNotificationError(OPENVR_FNTABLE_CALLTYPE *CreateNotification)(VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, EVRNotificationType type, char *pchText, EVRNotificationStyle style, struct NotificationBitmap_t *pImage, VRNotificationId *pNotificationId);
+	EVRNotificationError(OPENVR_FNTABLE_CALLTYPE *RemoveNotification)(VRNotificationId notificationId);
+};
+
+struct VR_IVRSettings_FnTable
+{
+	char *(OPENVR_FNTABLE_CALLTYPE *GetSettingsErrorNameFromEnum)(EVRSettingsError eError);
+	bool(OPENVR_FNTABLE_CALLTYPE *Sync)(bool bForce, EVRSettingsError *peError);
+	void(OPENVR_FNTABLE_CALLTYPE *SetBool)(char *pchSection, char *pchSettingsKey, bool bValue, EVRSettingsError *peError);
+	void(OPENVR_FNTABLE_CALLTYPE *SetInt32)(char *pchSection, char *pchSettingsKey, int32_t nValue, EVRSettingsError *peError);
+	void(OPENVR_FNTABLE_CALLTYPE *SetFloat)(char *pchSection, char *pchSettingsKey, float flValue, EVRSettingsError *peError);
+	void(OPENVR_FNTABLE_CALLTYPE *SetString)(char *pchSection, char *pchSettingsKey, char *pchValue, EVRSettingsError *peError);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetBool)(char *pchSection, char *pchSettingsKey, EVRSettingsError *peError);
+	int32_t(OPENVR_FNTABLE_CALLTYPE *GetInt32)(char *pchSection, char *pchSettingsKey, EVRSettingsError *peError);
+	float(OPENVR_FNTABLE_CALLTYPE *GetFloat)(char *pchSection, char *pchSettingsKey, EVRSettingsError *peError);
+	void(OPENVR_FNTABLE_CALLTYPE *GetString)(char *pchSection, char *pchSettingsKey, char *pchValue, uint32_t unValueLen, EVRSettingsError *peError);
+	void(OPENVR_FNTABLE_CALLTYPE *RemoveSection)(char *pchSection, EVRSettingsError *peError);
+	void(OPENVR_FNTABLE_CALLTYPE *RemoveKeyInSection)(char *pchSection, char *pchSettingsKey, EVRSettingsError *peError);
+};
+
+struct VR_IVRScreenshots_FnTable
+{
+	EVRScreenshotError(OPENVR_FNTABLE_CALLTYPE *RequestScreenshot)(ScreenshotHandle_t *pOutScreenshotHandle, EVRScreenshotType type, char *pchPreviewFilename, char *pchVRFilename);
+	EVRScreenshotError(OPENVR_FNTABLE_CALLTYPE *HookScreenshot)(EVRScreenshotType *pSupportedTypes, int numTypes);
+	EVRScreenshotType(OPENVR_FNTABLE_CALLTYPE *GetScreenshotPropertyType)(ScreenshotHandle_t screenshotHandle, EVRScreenshotError *pError);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetScreenshotPropertyFilename)(ScreenshotHandle_t screenshotHandle, EVRScreenshotPropertyFilenames filenameType, char *pchFilename, uint32_t cchFilename, EVRScreenshotError *pError);
+	EVRScreenshotError(OPENVR_FNTABLE_CALLTYPE *UpdateScreenshotProgress)(ScreenshotHandle_t screenshotHandle, float flProgress);
+	EVRScreenshotError(OPENVR_FNTABLE_CALLTYPE *TakeStereoScreenshot)(ScreenshotHandle_t *pOutScreenshotHandle, char *pchPreviewFilename, char *pchVRFilename);
+	EVRScreenshotError(OPENVR_FNTABLE_CALLTYPE *SubmitScreenshot)(ScreenshotHandle_t screenshotHandle, EVRScreenshotType type, char *pchSourcePreviewFilename, char *pchSourceVRFilename);
+};
+
+struct VR_IVRResources_FnTable
+{
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *LoadSharedResource)(char *pchResourceName, char *pchBuffer, uint32_t unBufferLen);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetResourceFullPath)(char *pchResourceName, char *pchResourceTypeDirectory, char *pchPathBuffer, uint32_t unBufferLen);
+};
+
+struct VR_IVRDriverManager_FnTable
+{
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetDriverCount)();
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetDriverName)(DriverId_t nDriver, char *pchValue, uint32_t unBufferSize);
+};
+
+#if 0
+// Global entry points
+S_API intptr_t VR_InitInternal( EVRInitError *peError, EVRApplicationType eType );
+S_API void VR_ShutdownInternal();
+S_API bool VR_IsHmdPresent();
+S_API intptr_t VR_GetGenericInterface( const char *pchInterfaceVersion, EVRInitError *peError );
+S_API bool VR_IsRuntimeInstalled();
+S_API const char * VR_GetVRInitErrorAsSymbol( EVRInitError error );
+S_API const char * VR_GetVRInitErrorAsEnglishDescription( EVRInitError error );
+#endif
+
+#endif  // __OPENVR_API_FLAT_H__
diff --git a/engine/inc/bullet/ThirdPartyLibs/openvr/bin/osx64/OpenVR.framework/Headers/openvr_driver.h b/engine/inc/bullet/ThirdPartyLibs/openvr/bin/osx64/OpenVR.framework/Headers/openvr_driver.h
new file mode 100644
index 00000000..b07699f8
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/openvr/bin/osx64/OpenVR.framework/Headers/openvr_driver.h
@@ -0,0 +1,2595 @@
+#pragma once
+
+// openvr_driver.h
+//========= Copyright Valve Corporation ============//
+// Dynamically generated file. Do not modify this file directly.
+
+#ifndef _OPENVR_DRIVER_API
+#define _OPENVR_DRIVER_API
+
+#include <stdint.h>
+
+// vrtypes.h
+#ifndef _INCLUDE_VRTYPES_H
+#define _INCLUDE_VRTYPES_H
+
+// Forward declarations to avoid requiring vulkan.h
+struct VkDevice_T;
+struct VkPhysicalDevice_T;
+struct VkInstance_T;
+struct VkQueue_T;
+
+// Forward declarations to avoid requiring d3d12.h
+struct ID3D12Resource;
+struct ID3D12CommandQueue;
+
+namespace vr
+{
+#pragma pack(push, 8)
+
+typedef void *glSharedTextureHandle_t;
+typedef int32_t glInt_t;
+typedef uint32_t glUInt_t;
+
+// right-handed system
+// +y is up
+// +x is to the right
+// -z is going away from you
+// Distance unit is  meters
+struct HmdMatrix34_t
+{
+	float m[3][4];
+};
+
+struct HmdMatrix44_t
+{
+	float m[4][4];
+};
+
+struct HmdVector3_t
+{
+	float v[3];
+};
+
+struct HmdVector4_t
+{
+	float v[4];
+};
+
+struct HmdVector3d_t
+{
+	double v[3];
+};
+
+struct HmdVector2_t
+{
+	float v[2];
+};
+
+struct HmdQuaternion_t
+{
+	double w, x, y, z;
+};
+
+struct HmdColor_t
+{
+	float r, g, b, a;
+};
+
+struct HmdQuad_t
+{
+	HmdVector3_t vCorners[4];
+};
+
+struct HmdRect2_t
+{
+	HmdVector2_t vTopLeft;
+	HmdVector2_t vBottomRight;
+};
+
+/** Used to return the post-distortion UVs for each color channel. 
+* UVs range from 0 to 1 with 0,0 in the upper left corner of the 
+* source render target. The 0,0 to 1,1 range covers a single eye. */
+struct DistortionCoordinates_t
+{
+	float rfRed[2];
+	float rfGreen[2];
+	float rfBlue[2];
+};
+
+enum EVREye
+{
+	Eye_Left = 0,
+	Eye_Right = 1
+};
+
+enum ETextureType
+{
+	TextureType_DirectX = 0,    // Handle is an ID3D11Texture
+	TextureType_OpenGL = 1,     // Handle is an OpenGL texture name or an OpenGL render buffer name, depending on submit flags
+	TextureType_Vulkan = 2,     // Handle is a pointer to a VRVulkanTextureData_t structure
+	TextureType_IOSurface = 3,  // Handle is a macOS cross-process-sharable IOSurfaceRef
+	TextureType_DirectX12 = 4,  // Handle is a pointer to a D3D12TextureData_t structure
+};
+
+enum EColorSpace
+{
+	ColorSpace_Auto = 0,    // Assumes 'gamma' for 8-bit per component formats, otherwise 'linear'.  This mirrors the DXGI formats which have _SRGB variants.
+	ColorSpace_Gamma = 1,   // Texture data can be displayed directly on the display without any conversion (a.k.a. display native format).
+	ColorSpace_Linear = 2,  // Same as gamma but has been converted to a linear representation using DXGI's sRGB conversion algorithm.
+};
+
+struct Texture_t
+{
+	void *handle;  // See ETextureType definition above
+	ETextureType eType;
+	EColorSpace eColorSpace;
+};
+
+// Handle to a shared texture (HANDLE on Windows obtained using OpenSharedResource).
+typedef uint64_t SharedTextureHandle_t;
+#define INVALID_SHARED_TEXTURE_HANDLE ((vr::SharedTextureHandle_t)0)
+
+enum ETrackingResult
+{
+	TrackingResult_Uninitialized = 1,
+
+	TrackingResult_Calibrating_InProgress = 100,
+	TrackingResult_Calibrating_OutOfRange = 101,
+
+	TrackingResult_Running_OK = 200,
+	TrackingResult_Running_OutOfRange = 201,
+};
+
+typedef uint32_t DriverId_t;
+static const uint32_t k_nDriverNone = 0xFFFFFFFF;
+
+static const uint32_t k_unMaxDriverDebugResponseSize = 32768;
+
+/** Used to pass device IDs to API calls */
+typedef uint32_t TrackedDeviceIndex_t;
+static const uint32_t k_unTrackedDeviceIndex_Hmd = 0;
+static const uint32_t k_unMaxTrackedDeviceCount = 16;
+static const uint32_t k_unTrackedDeviceIndexOther = 0xFFFFFFFE;
+static const uint32_t k_unTrackedDeviceIndexInvalid = 0xFFFFFFFF;
+
+/** Describes what kind of object is being tracked at a given ID */
+enum ETrackedDeviceClass
+{
+	TrackedDeviceClass_Invalid = 0,            // the ID was not valid.
+	TrackedDeviceClass_HMD = 1,                // Head-Mounted Displays
+	TrackedDeviceClass_Controller = 2,         // Tracked controllers
+	TrackedDeviceClass_GenericTracker = 3,     // Generic trackers, similar to controllers
+	TrackedDeviceClass_TrackingReference = 4,  // Camera and base stations that serve as tracking reference points
+	TrackedDeviceClass_DisplayRedirect = 5,    // Accessories that aren't necessarily tracked themselves, but may redirect video output from other tracked devices
+};
+
+/** Describes what specific role associated with a tracked device */
+enum ETrackedControllerRole
+{
+	TrackedControllerRole_Invalid = 0,    // Invalid value for controller type
+	TrackedControllerRole_LeftHand = 1,   // Tracked device associated with the left hand
+	TrackedControllerRole_RightHand = 2,  // Tracked device associated with the right hand
+};
+
+/** describes a single pose for a tracked object */
+struct TrackedDevicePose_t
+{
+	HmdMatrix34_t mDeviceToAbsoluteTracking;
+	HmdVector3_t vVelocity;         // velocity in tracker space in m/s
+	HmdVector3_t vAngularVelocity;  // angular velocity in radians/s (?)
+	ETrackingResult eTrackingResult;
+	bool bPoseIsValid;
+
+	// This indicates that there is a device connected for this spot in the pose array.
+	// It could go from true to false if the user unplugs the device.
+	bool bDeviceIsConnected;
+};
+
+/** Identifies which style of tracking origin the application wants to use
+* for the poses it is requesting */
+enum ETrackingUniverseOrigin
+{
+	TrackingUniverseSeated = 0,              // Poses are provided relative to the seated zero pose
+	TrackingUniverseStanding = 1,            // Poses are provided relative to the safe bounds configured by the user
+	TrackingUniverseRawAndUncalibrated = 2,  // Poses are provided in the coordinate system defined by the driver.  It has Y up and is unified for devices of the same driver. You usually don't want this one.
+};
+
+// Refers to a single container of properties
+typedef uint64_t PropertyContainerHandle_t;
+typedef uint32_t PropertyTypeTag_t;
+
+static const PropertyContainerHandle_t k_ulInvalidPropertyContainer = 0;
+static const PropertyTypeTag_t k_unInvalidPropertyTag = 0;
+
+// Use these tags to set/get common types as struct properties
+static const PropertyTypeTag_t k_unFloatPropertyTag = 1;
+static const PropertyTypeTag_t k_unInt32PropertyTag = 2;
+static const PropertyTypeTag_t k_unUint64PropertyTag = 3;
+static const PropertyTypeTag_t k_unBoolPropertyTag = 4;
+static const PropertyTypeTag_t k_unStringPropertyTag = 5;
+
+static const PropertyTypeTag_t k_unHmdMatrix34PropertyTag = 20;
+static const PropertyTypeTag_t k_unHmdMatrix44PropertyTag = 21;
+static const PropertyTypeTag_t k_unHmdVector3PropertyTag = 22;
+static const PropertyTypeTag_t k_unHmdVector4PropertyTag = 23;
+
+static const PropertyTypeTag_t k_unHiddenAreaPropertyTag = 30;
+
+static const PropertyTypeTag_t k_unOpenVRInternalReserved_Start = 1000;
+static const PropertyTypeTag_t k_unOpenVRInternalReserved_End = 10000;
+
+/** Each entry in this enum represents a property that can be retrieved about a
+* tracked device. Many fields are only valid for one ETrackedDeviceClass. */
+enum ETrackedDeviceProperty
+{
+	Prop_Invalid = 0,
+
+	// general properties that apply to all device classes
+	Prop_TrackingSystemName_String = 1000,
+	Prop_ModelNumber_String = 1001,
+	Prop_SerialNumber_String = 1002,
+	Prop_RenderModelName_String = 1003,
+	Prop_WillDriftInYaw_Bool = 1004,
+	Prop_ManufacturerName_String = 1005,
+	Prop_TrackingFirmwareVersion_String = 1006,
+	Prop_HardwareRevision_String = 1007,
+	Prop_AllWirelessDongleDescriptions_String = 1008,
+	Prop_ConnectedWirelessDongle_String = 1009,
+	Prop_DeviceIsWireless_Bool = 1010,
+	Prop_DeviceIsCharging_Bool = 1011,
+	Prop_DeviceBatteryPercentage_Float = 1012,  // 0 is empty, 1 is full
+	Prop_StatusDisplayTransform_Matrix34 = 1013,
+	Prop_Firmware_UpdateAvailable_Bool = 1014,
+	Prop_Firmware_ManualUpdate_Bool = 1015,
+	Prop_Firmware_ManualUpdateURL_String = 1016,
+	Prop_HardwareRevision_Uint64 = 1017,
+	Prop_FirmwareVersion_Uint64 = 1018,
+	Prop_FPGAVersion_Uint64 = 1019,
+	Prop_VRCVersion_Uint64 = 1020,
+	Prop_RadioVersion_Uint64 = 1021,
+	Prop_DongleVersion_Uint64 = 1022,
+	Prop_BlockServerShutdown_Bool = 1023,
+	Prop_CanUnifyCoordinateSystemWithHmd_Bool = 1024,
+	Prop_ContainsProximitySensor_Bool = 1025,
+	Prop_DeviceProvidesBatteryStatus_Bool = 1026,
+	Prop_DeviceCanPowerOff_Bool = 1027,
+	Prop_Firmware_ProgrammingTarget_String = 1028,
+	Prop_DeviceClass_Int32 = 1029,
+	Prop_HasCamera_Bool = 1030,
+	Prop_DriverVersion_String = 1031,
+	Prop_Firmware_ForceUpdateRequired_Bool = 1032,
+	Prop_ViveSystemButtonFixRequired_Bool = 1033,
+	Prop_ParentDriver_Uint64 = 1034,
+	Prop_ResourceRoot_String = 1035,
+
+	// Properties that are unique to TrackedDeviceClass_HMD
+	Prop_ReportsTimeSinceVSync_Bool = 2000,
+	Prop_SecondsFromVsyncToPhotons_Float = 2001,
+	Prop_DisplayFrequency_Float = 2002,
+	Prop_UserIpdMeters_Float = 2003,
+	Prop_CurrentUniverseId_Uint64 = 2004,
+	Prop_PreviousUniverseId_Uint64 = 2005,
+	Prop_DisplayFirmwareVersion_Uint64 = 2006,
+	Prop_IsOnDesktop_Bool = 2007,
+	Prop_DisplayMCType_Int32 = 2008,
+	Prop_DisplayMCOffset_Float = 2009,
+	Prop_DisplayMCScale_Float = 2010,
+	Prop_EdidVendorID_Int32 = 2011,
+	Prop_DisplayMCImageLeft_String = 2012,
+	Prop_DisplayMCImageRight_String = 2013,
+	Prop_DisplayGCBlackClamp_Float = 2014,
+	Prop_EdidProductID_Int32 = 2015,
+	Prop_CameraToHeadTransform_Matrix34 = 2016,
+	Prop_DisplayGCType_Int32 = 2017,
+	Prop_DisplayGCOffset_Float = 2018,
+	Prop_DisplayGCScale_Float = 2019,
+	Prop_DisplayGCPrescale_Float = 2020,
+	Prop_DisplayGCImage_String = 2021,
+	Prop_LensCenterLeftU_Float = 2022,
+	Prop_LensCenterLeftV_Float = 2023,
+	Prop_LensCenterRightU_Float = 2024,
+	Prop_LensCenterRightV_Float = 2025,
+	Prop_UserHeadToEyeDepthMeters_Float = 2026,
+	Prop_CameraFirmwareVersion_Uint64 = 2027,
+	Prop_CameraFirmwareDescription_String = 2028,
+	Prop_DisplayFPGAVersion_Uint64 = 2029,
+	Prop_DisplayBootloaderVersion_Uint64 = 2030,
+	Prop_DisplayHardwareVersion_Uint64 = 2031,
+	Prop_AudioFirmwareVersion_Uint64 = 2032,
+	Prop_CameraCompatibilityMode_Int32 = 2033,
+	Prop_ScreenshotHorizontalFieldOfViewDegrees_Float = 2034,
+	Prop_ScreenshotVerticalFieldOfViewDegrees_Float = 2035,
+	Prop_DisplaySuppressed_Bool = 2036,
+	Prop_DisplayAllowNightMode_Bool = 2037,
+	Prop_DisplayMCImageWidth_Int32 = 2038,
+	Prop_DisplayMCImageHeight_Int32 = 2039,
+	Prop_DisplayMCImageNumChannels_Int32 = 2040,
+	Prop_DisplayMCImageData_Binary = 2041,
+	Prop_SecondsFromPhotonsToVblank_Float = 2042,
+	Prop_DriverDirectModeSendsVsyncEvents_Bool = 2043,
+	Prop_DisplayDebugMode_Bool = 2044,
+	Prop_GraphicsAdapterLuid_Uint64 = 2045,
+	Prop_DriverProvidedChaperonePath_String = 2048,
+
+	// Properties that are unique to TrackedDeviceClass_Controller
+	Prop_AttachedDeviceId_String = 3000,
+	Prop_SupportedButtons_Uint64 = 3001,
+	Prop_Axis0Type_Int32 = 3002,           // Return value is of type EVRControllerAxisType
+	Prop_Axis1Type_Int32 = 3003,           // Return value is of type EVRControllerAxisType
+	Prop_Axis2Type_Int32 = 3004,           // Return value is of type EVRControllerAxisType
+	Prop_Axis3Type_Int32 = 3005,           // Return value is of type EVRControllerAxisType
+	Prop_Axis4Type_Int32 = 3006,           // Return value is of type EVRControllerAxisType
+	Prop_ControllerRoleHint_Int32 = 3007,  // Return value is of type ETrackedControllerRole
+
+	// Properties that are unique to TrackedDeviceClass_TrackingReference
+	Prop_FieldOfViewLeftDegrees_Float = 4000,
+	Prop_FieldOfViewRightDegrees_Float = 4001,
+	Prop_FieldOfViewTopDegrees_Float = 4002,
+	Prop_FieldOfViewBottomDegrees_Float = 4003,
+	Prop_TrackingRangeMinimumMeters_Float = 4004,
+	Prop_TrackingRangeMaximumMeters_Float = 4005,
+	Prop_ModeLabel_String = 4006,
+
+	// Properties that are used for user interface like icons names
+	Prop_IconPathName_String = 5000,                       // DEPRECATED. Value not referenced. Now expected to be part of icon path properties.
+	Prop_NamedIconPathDeviceOff_String = 5001,             // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceSearching_String = 5002,       // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceSearchingAlert_String = 5003,  // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceReady_String = 5004,           // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceReadyAlert_String = 5005,      // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceNotReady_String = 5006,        // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceStandby_String = 5007,         // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceAlertLow_String = 5008,        // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+
+	// Properties that are used by helpers, but are opaque to applications
+	Prop_DisplayHiddenArea_Binary_Start = 5100,
+	Prop_DisplayHiddenArea_Binary_End = 5150,
+
+	// Properties that are unique to drivers
+	Prop_UserConfigPath_String = 6000,
+	Prop_InstallPath_String = 6001,
+	Prop_HasDisplayComponent_Bool = 6002,
+	Prop_HasControllerComponent_Bool = 6003,
+	Prop_HasCameraComponent_Bool = 6004,
+	Prop_HasDriverDirectModeComponent_Bool = 6005,
+	Prop_HasVirtualDisplayComponent_Bool = 6006,
+
+	// Vendors are free to expose private debug data in this reserved region
+	Prop_VendorSpecific_Reserved_Start = 10000,
+	Prop_VendorSpecific_Reserved_End = 10999,
+};
+
+/** No string property will ever be longer than this length */
+static const uint32_t k_unMaxPropertyStringSize = 32 * 1024;
+
+/** Used to return errors that occur when reading properties. */
+enum ETrackedPropertyError
+{
+	TrackedProp_Success = 0,
+	TrackedProp_WrongDataType = 1,
+	TrackedProp_WrongDeviceClass = 2,
+	TrackedProp_BufferTooSmall = 3,
+	TrackedProp_UnknownProperty = 4,  // Driver has not set the property (and may not ever).
+	TrackedProp_InvalidDevice = 5,
+	TrackedProp_CouldNotContactServer = 6,
+	TrackedProp_ValueNotProvidedByDevice = 7,
+	TrackedProp_StringExceedsMaximumLength = 8,
+	TrackedProp_NotYetAvailable = 9,  // The property value isn't known yet, but is expected soon. Call again later.
+	TrackedProp_PermissionDenied = 10,
+	TrackedProp_InvalidOperation = 11,
+};
+
+/** Allows the application to control what part of the provided texture will be used in the
+* frame buffer. */
+struct VRTextureBounds_t
+{
+	float uMin, vMin;
+	float uMax, vMax;
+};
+
+/** Allows specifying pose used to render provided scene texture (if different from value returned by WaitGetPoses). */
+struct VRTextureWithPose_t : public Texture_t
+{
+	HmdMatrix34_t mDeviceToAbsoluteTracking;  // Actual pose used to render scene textures.
+};
+
+/** Allows the application to control how scene textures are used by the compositor when calling Submit. */
+enum EVRSubmitFlags
+{
+	// Simple render path. App submits rendered left and right eye images with no lens distortion correction applied.
+	Submit_Default = 0x00,
+
+	// App submits final left and right eye images with lens distortion already applied (lens distortion makes the images appear
+	// barrel distorted with chromatic aberration correction applied). The app would have used the data returned by
+	// vr::IVRSystem::ComputeDistortion() to apply the correct distortion to the rendered images before calling Submit().
+	Submit_LensDistortionAlreadyApplied = 0x01,
+
+	// If the texture pointer passed in is actually a renderbuffer (e.g. for MSAA in OpenGL) then set this flag.
+	Submit_GlRenderBuffer = 0x02,
+
+	// Do not use
+	Submit_Reserved = 0x04,
+
+	// Set to indicate that pTexture is a pointer to a VRTextureWithPose_t.
+	Submit_TextureWithPose = 0x08,
+};
+
+/** Data required for passing Vulkan textures to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. */
+struct VRVulkanTextureData_t
+{
+	uint64_t m_nImage;  // VkImage
+	VkDevice_T *m_pDevice;
+	VkPhysicalDevice_T *m_pPhysicalDevice;
+	VkInstance_T *m_pInstance;
+	VkQueue_T *m_pQueue;
+	uint32_t m_nQueueFamilyIndex;
+	uint32_t m_nWidth, m_nHeight, m_nFormat, m_nSampleCount;
+};
+
+/** Data required for passing D3D12 textures to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. */
+struct D3D12TextureData_t
+{
+	ID3D12Resource *m_pResource;
+	ID3D12CommandQueue *m_pCommandQueue;
+	uint32_t m_nNodeMask;
+};
+
+/** Status of the overall system or tracked objects */
+enum EVRState
+{
+	VRState_Undefined = -1,
+	VRState_Off = 0,
+	VRState_Searching = 1,
+	VRState_Searching_Alert = 2,
+	VRState_Ready = 3,
+	VRState_Ready_Alert = 4,
+	VRState_NotReady = 5,
+	VRState_Standby = 6,
+	VRState_Ready_Alert_Low = 7,
+};
+
+/** The types of events that could be posted (and what the parameters mean for each event type) */
+enum EVREventType
+{
+	VREvent_None = 0,
+
+	VREvent_TrackedDeviceActivated = 100,
+	VREvent_TrackedDeviceDeactivated = 101,
+	VREvent_TrackedDeviceUpdated = 102,
+	VREvent_TrackedDeviceUserInteractionStarted = 103,
+	VREvent_TrackedDeviceUserInteractionEnded = 104,
+	VREvent_IpdChanged = 105,
+	VREvent_EnterStandbyMode = 106,
+	VREvent_LeaveStandbyMode = 107,
+	VREvent_TrackedDeviceRoleChanged = 108,
+	VREvent_WatchdogWakeUpRequested = 109,
+	VREvent_LensDistortionChanged = 110,
+	VREvent_PropertyChanged = 111,
+	VREvent_WirelessDisconnect = 112,
+	VREvent_WirelessReconnect = 113,
+
+	VREvent_ButtonPress = 200,    // data is controller
+	VREvent_ButtonUnpress = 201,  // data is controller
+	VREvent_ButtonTouch = 202,    // data is controller
+	VREvent_ButtonUntouch = 203,  // data is controller
+
+	VREvent_MouseMove = 300,            // data is mouse
+	VREvent_MouseButtonDown = 301,      // data is mouse
+	VREvent_MouseButtonUp = 302,        // data is mouse
+	VREvent_FocusEnter = 303,           // data is overlay
+	VREvent_FocusLeave = 304,           // data is overlay
+	VREvent_Scroll = 305,               // data is mouse
+	VREvent_TouchPadMove = 306,         // data is mouse
+	VREvent_OverlayFocusChanged = 307,  // data is overlay, global event
+
+	VREvent_InputFocusCaptured = 400,                         // data is process DEPRECATED
+	VREvent_InputFocusReleased = 401,                         // data is process DEPRECATED
+	VREvent_SceneFocusLost = 402,                             // data is process
+	VREvent_SceneFocusGained = 403,                           // data is process
+	VREvent_SceneApplicationChanged = 404,                    // data is process - The App actually drawing the scene changed (usually to or from the compositor)
+	VREvent_SceneFocusChanged = 405,                          // data is process - New app got access to draw the scene
+	VREvent_InputFocusChanged = 406,                          // data is process
+	VREvent_SceneApplicationSecondaryRenderingStarted = 407,  // data is process
+
+	VREvent_HideRenderModels = 410,  // Sent to the scene application to request hiding render models temporarily
+	VREvent_ShowRenderModels = 411,  // Sent to the scene application to request restoring render model visibility
+
+	VREvent_OverlayShown = 500,
+	VREvent_OverlayHidden = 501,
+	VREvent_DashboardActivated = 502,
+	VREvent_DashboardDeactivated = 503,
+	VREvent_DashboardThumbSelected = 504,     // Sent to the overlay manager - data is overlay
+	VREvent_DashboardRequested = 505,         // Sent to the overlay manager - data is overlay
+	VREvent_ResetDashboard = 506,             // Send to the overlay manager
+	VREvent_RenderToast = 507,                // Send to the dashboard to render a toast - data is the notification ID
+	VREvent_ImageLoaded = 508,                // Sent to overlays when a SetOverlayRaw or SetOverlayFromFile call finishes loading
+	VREvent_ShowKeyboard = 509,               // Sent to keyboard renderer in the dashboard to invoke it
+	VREvent_HideKeyboard = 510,               // Sent to keyboard renderer in the dashboard to hide it
+	VREvent_OverlayGamepadFocusGained = 511,  // Sent to an overlay when IVROverlay::SetFocusOverlay is called on it
+	VREvent_OverlayGamepadFocusLost = 512,    // Send to an overlay when it previously had focus and IVROverlay::SetFocusOverlay is called on something else
+	VREvent_OverlaySharedTextureChanged = 513,
+	VREvent_DashboardGuideButtonDown = 514,
+	VREvent_DashboardGuideButtonUp = 515,
+	VREvent_ScreenshotTriggered = 516,  // Screenshot button combo was pressed, Dashboard should request a screenshot
+	VREvent_ImageFailed = 517,          // Sent to overlays when a SetOverlayRaw or SetOverlayfromFail fails to load
+	VREvent_DashboardOverlayCreated = 518,
+
+	// Screenshot API
+	VREvent_RequestScreenshot = 520,              // Sent by vrclient application to compositor to take a screenshot
+	VREvent_ScreenshotTaken = 521,                // Sent by compositor to the application that the screenshot has been taken
+	VREvent_ScreenshotFailed = 522,               // Sent by compositor to the application that the screenshot failed to be taken
+	VREvent_SubmitScreenshotToDashboard = 523,    // Sent by compositor to the dashboard that a completed screenshot was submitted
+	VREvent_ScreenshotProgressToDashboard = 524,  // Sent by compositor to the dashboard that a completed screenshot was submitted
+
+	VREvent_PrimaryDashboardDeviceChanged = 525,
+
+	VREvent_Notification_Shown = 600,
+	VREvent_Notification_Hidden = 601,
+	VREvent_Notification_BeginInteraction = 602,
+	VREvent_Notification_Destroyed = 603,
+
+	VREvent_Quit = 700,                    // data is process
+	VREvent_ProcessQuit = 701,             // data is process
+	VREvent_QuitAborted_UserPrompt = 702,  // data is process
+	VREvent_QuitAcknowledged = 703,        // data is process
+	VREvent_DriverRequestedQuit = 704,     // The driver has requested that SteamVR shut down
+
+	VREvent_ChaperoneDataHasChanged = 800,
+	VREvent_ChaperoneUniverseHasChanged = 801,
+	VREvent_ChaperoneTempDataHasChanged = 802,
+	VREvent_ChaperoneSettingsHaveChanged = 803,
+	VREvent_SeatedZeroPoseReset = 804,
+
+	VREvent_AudioSettingsHaveChanged = 820,
+
+	VREvent_BackgroundSettingHasChanged = 850,
+	VREvent_CameraSettingsHaveChanged = 851,
+	VREvent_ReprojectionSettingHasChanged = 852,
+	VREvent_ModelSkinSettingsHaveChanged = 853,
+	VREvent_EnvironmentSettingsHaveChanged = 854,
+	VREvent_PowerSettingsHaveChanged = 855,
+	VREvent_EnableHomeAppSettingsHaveChanged = 856,
+
+	VREvent_StatusUpdate = 900,
+
+	VREvent_MCImageUpdated = 1000,
+
+	VREvent_FirmwareUpdateStarted = 1100,
+	VREvent_FirmwareUpdateFinished = 1101,
+
+	VREvent_KeyboardClosed = 1200,
+	VREvent_KeyboardCharInput = 1201,
+	VREvent_KeyboardDone = 1202,  // Sent when DONE button clicked on keyboard
+
+	VREvent_ApplicationTransitionStarted = 1300,
+	VREvent_ApplicationTransitionAborted = 1301,
+	VREvent_ApplicationTransitionNewAppStarted = 1302,
+	VREvent_ApplicationListUpdated = 1303,
+	VREvent_ApplicationMimeTypeLoad = 1304,
+	VREvent_ApplicationTransitionNewAppLaunchComplete = 1305,
+	VREvent_ProcessConnected = 1306,
+	VREvent_ProcessDisconnected = 1307,
+
+	VREvent_Compositor_MirrorWindowShown = 1400,
+	VREvent_Compositor_MirrorWindowHidden = 1401,
+	VREvent_Compositor_ChaperoneBoundsShown = 1410,
+	VREvent_Compositor_ChaperoneBoundsHidden = 1411,
+
+	VREvent_TrackedCamera_StartVideoStream = 1500,
+	VREvent_TrackedCamera_StopVideoStream = 1501,
+	VREvent_TrackedCamera_PauseVideoStream = 1502,
+	VREvent_TrackedCamera_ResumeVideoStream = 1503,
+	VREvent_TrackedCamera_EditingSurface = 1550,
+
+	VREvent_PerformanceTest_EnableCapture = 1600,
+	VREvent_PerformanceTest_DisableCapture = 1601,
+	VREvent_PerformanceTest_FidelityLevel = 1602,
+
+	VREvent_MessageOverlay_Closed = 1650,
+	VREvent_MessageOverlayCloseRequested = 1651,
+
+	// Vendors are free to expose private events in this reserved region
+	VREvent_VendorSpecific_Reserved_Start = 10000,
+	VREvent_VendorSpecific_Reserved_End = 19999,
+};
+
+/** Level of Hmd activity */
+// UserInteraction_Timeout means the device is in the process of timing out.
+// InUse = ( k_EDeviceActivityLevel_UserInteraction || k_EDeviceActivityLevel_UserInteraction_Timeout )
+// VREvent_TrackedDeviceUserInteractionStarted fires when the devices transitions from Standby -> UserInteraction or Idle -> UserInteraction.
+// VREvent_TrackedDeviceUserInteractionEnded fires when the devices transitions from UserInteraction_Timeout -> Idle
+enum EDeviceActivityLevel
+{
+	k_EDeviceActivityLevel_Unknown = -1,
+	k_EDeviceActivityLevel_Idle = 0,                     // No activity for the last 10 seconds
+	k_EDeviceActivityLevel_UserInteraction = 1,          // Activity (movement or prox sensor) is happening now
+	k_EDeviceActivityLevel_UserInteraction_Timeout = 2,  // No activity for the last 0.5 seconds
+	k_EDeviceActivityLevel_Standby = 3,                  // Idle for at least 5 seconds (configurable in Settings -> Power Management)
+};
+
+/** VR controller button and axis IDs */
+enum EVRButtonId
+{
+	k_EButton_System = 0,
+	k_EButton_ApplicationMenu = 1,
+	k_EButton_Grip = 2,
+	k_EButton_DPad_Left = 3,
+	k_EButton_DPad_Up = 4,
+	k_EButton_DPad_Right = 5,
+	k_EButton_DPad_Down = 6,
+	k_EButton_A = 7,
+
+	k_EButton_ProximitySensor = 31,
+
+	k_EButton_Axis0 = 32,
+	k_EButton_Axis1 = 33,
+	k_EButton_Axis2 = 34,
+	k_EButton_Axis3 = 35,
+	k_EButton_Axis4 = 36,
+
+	// aliases for well known controllers
+	k_EButton_SteamVR_Touchpad = k_EButton_Axis0,
+	k_EButton_SteamVR_Trigger = k_EButton_Axis1,
+
+	k_EButton_Dashboard_Back = k_EButton_Grip,
+
+	k_EButton_Max = 64
+};
+
+inline uint64_t ButtonMaskFromId(EVRButtonId id) { return 1ull << id; }
+
+/** used for controller button events */
+struct VREvent_Controller_t
+{
+	uint32_t button;  // EVRButtonId enum
+};
+
+/** used for simulated mouse events in overlay space */
+enum EVRMouseButton
+{
+	VRMouseButton_Left = 0x0001,
+	VRMouseButton_Right = 0x0002,
+	VRMouseButton_Middle = 0x0004,
+};
+
+/** used for simulated mouse events in overlay space */
+struct VREvent_Mouse_t
+{
+	float x, y;       // co-ords are in GL space, bottom left of the texture is 0,0
+	uint32_t button;  // EVRMouseButton enum
+};
+
+/** used for simulated mouse wheel scroll in overlay space */
+struct VREvent_Scroll_t
+{
+	float xdelta, ydelta;  // movement in fraction of the pad traversed since last delta, 1.0 for a full swipe
+	uint32_t repeatCount;
+};
+
+/** when in mouse input mode you can receive data from the touchpad, these events are only sent if the users finger
+   is on the touchpad (or just released from it) 
+**/
+struct VREvent_TouchPadMove_t
+{
+	// true if the users finger is detected on the touch pad
+	bool bFingerDown;
+
+	// How long the finger has been down in seconds
+	float flSecondsFingerDown;
+
+	// These values indicate the starting finger position (so you can do some basic swipe stuff)
+	float fValueXFirst;
+	float fValueYFirst;
+
+	// This is the raw sampled coordinate without deadzoning
+	float fValueXRaw;
+	float fValueYRaw;
+};
+
+/** notification related events. Details will still change at this point */
+struct VREvent_Notification_t
+{
+	uint64_t ulUserValue;
+	uint32_t notificationId;
+};
+
+/** Used for events about processes */
+struct VREvent_Process_t
+{
+	uint32_t pid;
+	uint32_t oldPid;
+	bool bForced;
+};
+
+/** Used for a few events about overlays */
+struct VREvent_Overlay_t
+{
+	uint64_t overlayHandle;
+};
+
+/** Used for a few events about overlays */
+struct VREvent_Status_t
+{
+	uint32_t statusState;  // EVRState enum
+};
+
+/** Used for keyboard events **/
+struct VREvent_Keyboard_t
+{
+	char cNewInput[8];    // Up to 11 bytes of new input
+	uint64_t uUserValue;  // Possible flags about the new input
+};
+
+struct VREvent_Ipd_t
+{
+	float ipdMeters;
+};
+
+struct VREvent_Chaperone_t
+{
+	uint64_t m_nPreviousUniverse;
+	uint64_t m_nCurrentUniverse;
+};
+
+/** Not actually used for any events */
+struct VREvent_Reserved_t
+{
+	uint64_t reserved0;
+	uint64_t reserved1;
+};
+
+struct VREvent_PerformanceTest_t
+{
+	uint32_t m_nFidelityLevel;
+};
+
+struct VREvent_SeatedZeroPoseReset_t
+{
+	bool bResetBySystemMenu;
+};
+
+struct VREvent_Screenshot_t
+{
+	uint32_t handle;
+	uint32_t type;
+};
+
+struct VREvent_ScreenshotProgress_t
+{
+	float progress;
+};
+
+struct VREvent_ApplicationLaunch_t
+{
+	uint32_t pid;
+	uint32_t unArgsHandle;
+};
+
+struct VREvent_EditingCameraSurface_t
+{
+	uint64_t overlayHandle;
+	uint32_t nVisualMode;
+};
+
+struct VREvent_MessageOverlay_t
+{
+	uint32_t unVRMessageOverlayResponse;  // vr::VRMessageOverlayResponse enum
+};
+
+struct VREvent_Property_t
+{
+	PropertyContainerHandle_t container;
+	ETrackedDeviceProperty prop;
+};
+
+/** NOTE!!! If you change this you MUST manually update openvr_interop.cs.py */
+typedef union {
+	VREvent_Reserved_t reserved;
+	VREvent_Controller_t controller;
+	VREvent_Mouse_t mouse;
+	VREvent_Scroll_t scroll;
+	VREvent_Process_t process;
+	VREvent_Notification_t notification;
+	VREvent_Overlay_t overlay;
+	VREvent_Status_t status;
+	VREvent_Keyboard_t keyboard;
+	VREvent_Ipd_t ipd;
+	VREvent_Chaperone_t chaperone;
+	VREvent_PerformanceTest_t performanceTest;
+	VREvent_TouchPadMove_t touchPadMove;
+	VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset;
+	VREvent_Screenshot_t screenshot;
+	VREvent_ScreenshotProgress_t screenshotProgress;
+	VREvent_ApplicationLaunch_t applicationLaunch;
+	VREvent_EditingCameraSurface_t cameraSurface;
+	VREvent_MessageOverlay_t messageOverlay;
+	VREvent_Property_t property;
+} VREvent_Data_t;
+
+#if defined(__linux__) || defined(__APPLE__)
+// This structure was originally defined mis-packed on Linux, preserved for
+// compatibility.
+#pragma pack(push, 4)
+#endif
+
+/** An event posted by the server to all running applications */
+struct VREvent_t
+{
+	uint32_t eventType;  // EVREventType enum
+	TrackedDeviceIndex_t trackedDeviceIndex;
+	float eventAgeSeconds;
+	// event data must be the end of the struct as its size is variable
+	VREvent_Data_t data;
+};
+
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+
+/** The mesh to draw into the stencil (or depth) buffer to perform 
+* early stencil (or depth) kills of pixels that will never appear on the HMD.
+* This mesh draws on all the pixels that will be hidden after distortion. 
+*
+* If the HMD does not provide a visible area mesh pVertexData will be
+* NULL and unTriangleCount will be 0. */
+struct HiddenAreaMesh_t
+{
+	const HmdVector2_t *pVertexData;
+	uint32_t unTriangleCount;
+};
+
+enum EHiddenAreaMeshType
+{
+	k_eHiddenAreaMesh_Standard = 0,
+	k_eHiddenAreaMesh_Inverse = 1,
+	k_eHiddenAreaMesh_LineLoop = 2,
+
+	k_eHiddenAreaMesh_Max = 3,
+};
+
+/** Identifies what kind of axis is on the controller at index n. Read this type 
+* with pVRSystem->Get( nControllerDeviceIndex, Prop_Axis0Type_Int32 + n );
+*/
+enum EVRControllerAxisType
+{
+	k_eControllerAxis_None = 0,
+	k_eControllerAxis_TrackPad = 1,
+	k_eControllerAxis_Joystick = 2,
+	k_eControllerAxis_Trigger = 3,  // Analog trigger data is in the X axis
+};
+
+/** contains information about one axis on the controller */
+struct VRControllerAxis_t
+{
+	float x;  // Ranges from -1.0 to 1.0 for joysticks and track pads. Ranges from 0.0 to 1.0 for triggers were 0 is fully released.
+	float y;  // Ranges from -1.0 to 1.0 for joysticks and track pads. Is always 0.0 for triggers.
+};
+
+/** the number of axes in the controller state */
+static const uint32_t k_unControllerStateAxisCount = 5;
+
+#if defined(__linux__) || defined(__APPLE__)
+// This structure was originally defined mis-packed on Linux, preserved for
+// compatibility.
+#pragma pack(push, 4)
+#endif
+
+/** Holds all the state of a controller at one moment in time. */
+struct VRControllerState001_t
+{
+	// If packet num matches that on your prior call, then the controller state hasn't been changed since
+	// your last call and there is no need to process it
+	uint32_t unPacketNum;
+
+	// bit flags for each of the buttons. Use ButtonMaskFromId to turn an ID into a mask
+	uint64_t ulButtonPressed;
+	uint64_t ulButtonTouched;
+
+	// Axis data for the controller's analog inputs
+	VRControllerAxis_t rAxis[k_unControllerStateAxisCount];
+};
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+
+typedef VRControllerState001_t VRControllerState_t;
+
+/** determines how to provide output to the application of various event processing functions. */
+enum EVRControllerEventOutputType
+{
+	ControllerEventOutput_OSEvents = 0,
+	ControllerEventOutput_VREvents = 1,
+};
+
+/** Collision Bounds Style */
+enum ECollisionBoundsStyle
+{
+	COLLISION_BOUNDS_STYLE_BEGINNER = 0,
+	COLLISION_BOUNDS_STYLE_INTERMEDIATE,
+	COLLISION_BOUNDS_STYLE_SQUARES,
+	COLLISION_BOUNDS_STYLE_ADVANCED,
+	COLLISION_BOUNDS_STYLE_NONE,
+
+	COLLISION_BOUNDS_STYLE_COUNT
+};
+
+/** Allows the application to customize how the overlay appears in the compositor */
+struct Compositor_OverlaySettings
+{
+	uint32_t size;  // sizeof(Compositor_OverlaySettings)
+	bool curved, antialias;
+	float scale, distance, alpha;
+	float uOffset, vOffset, uScale, vScale;
+	float gridDivs, gridWidth, gridScale;
+	HmdMatrix44_t transform;
+};
+
+/** used to refer to a single VR overlay */
+typedef uint64_t VROverlayHandle_t;
+
+static const VROverlayHandle_t k_ulOverlayHandleInvalid = 0;
+
+/** Errors that can occur around VR overlays */
+enum EVROverlayError
+{
+	VROverlayError_None = 0,
+
+	VROverlayError_UnknownOverlay = 10,
+	VROverlayError_InvalidHandle = 11,
+	VROverlayError_PermissionDenied = 12,
+	VROverlayError_OverlayLimitExceeded = 13,  // No more overlays could be created because the maximum number already exist
+	VROverlayError_WrongVisibilityType = 14,
+	VROverlayError_KeyTooLong = 15,
+	VROverlayError_NameTooLong = 16,
+	VROverlayError_KeyInUse = 17,
+	VROverlayError_WrongTransformType = 18,
+	VROverlayError_InvalidTrackedDevice = 19,
+	VROverlayError_InvalidParameter = 20,
+	VROverlayError_ThumbnailCantBeDestroyed = 21,
+	VROverlayError_ArrayTooSmall = 22,
+	VROverlayError_RequestFailed = 23,
+	VROverlayError_InvalidTexture = 24,
+	VROverlayError_UnableToLoadFile = 25,
+	VROverlayError_KeyboardAlreadyInUse = 26,
+	VROverlayError_NoNeighbor = 27,
+	VROverlayError_TooManyMaskPrimitives = 29,
+	VROverlayError_BadMaskPrimitive = 30,
+};
+
+/** enum values to pass in to VR_Init to identify whether the application will 
+* draw a 3D scene. */
+enum EVRApplicationType
+{
+	VRApplication_Other = 0,          // Some other kind of application that isn't covered by the other entries
+	VRApplication_Scene = 1,          // Application will submit 3D frames
+	VRApplication_Overlay = 2,        // Application only interacts with overlays
+	VRApplication_Background = 3,     // Application should not start SteamVR if it's not already running, and should not
+									  // keep it running if everything else quits.
+	VRApplication_Utility = 4,        // Init should not try to load any drivers. The application needs access to utility
+									  // interfaces (like IVRSettings and IVRApplications) but not hardware.
+	VRApplication_VRMonitor = 5,      // Reserved for vrmonitor
+	VRApplication_SteamWatchdog = 6,  // Reserved for Steam
+	VRApplication_Bootstrapper = 7,   // Start up SteamVR
+
+	VRApplication_Max
+};
+
+/** error codes for firmware */
+enum EVRFirmwareError
+{
+	VRFirmwareError_None = 0,
+	VRFirmwareError_Success = 1,
+	VRFirmwareError_Fail = 2,
+};
+
+/** error codes for notifications */
+enum EVRNotificationError
+{
+	VRNotificationError_OK = 0,
+	VRNotificationError_InvalidNotificationId = 100,
+	VRNotificationError_NotificationQueueFull = 101,
+	VRNotificationError_InvalidOverlayHandle = 102,
+	VRNotificationError_SystemWithUserValueAlreadyExists = 103,
+};
+
+/** error codes returned by Vr_Init */
+
+// Please add adequate error description to https://developer.valvesoftware.com/w/index.php?title=Category:SteamVRHelp
+enum EVRInitError
+{
+	VRInitError_None = 0,
+	VRInitError_Unknown = 1,
+
+	VRInitError_Init_InstallationNotFound = 100,
+	VRInitError_Init_InstallationCorrupt = 101,
+	VRInitError_Init_VRClientDLLNotFound = 102,
+	VRInitError_Init_FileNotFound = 103,
+	VRInitError_Init_FactoryNotFound = 104,
+	VRInitError_Init_InterfaceNotFound = 105,
+	VRInitError_Init_InvalidInterface = 106,
+	VRInitError_Init_UserConfigDirectoryInvalid = 107,
+	VRInitError_Init_HmdNotFound = 108,
+	VRInitError_Init_NotInitialized = 109,
+	VRInitError_Init_PathRegistryNotFound = 110,
+	VRInitError_Init_NoConfigPath = 111,
+	VRInitError_Init_NoLogPath = 112,
+	VRInitError_Init_PathRegistryNotWritable = 113,
+	VRInitError_Init_AppInfoInitFailed = 114,
+	VRInitError_Init_Retry = 115,               // Used internally to cause retries to vrserver
+	VRInitError_Init_InitCanceledByUser = 116,  // The calling application should silently exit. The user canceled app startup
+	VRInitError_Init_AnotherAppLaunching = 117,
+	VRInitError_Init_SettingsInitFailed = 118,
+	VRInitError_Init_ShuttingDown = 119,
+	VRInitError_Init_TooManyObjects = 120,
+	VRInitError_Init_NoServerForBackgroundApp = 121,
+	VRInitError_Init_NotSupportedWithCompositor = 122,
+	VRInitError_Init_NotAvailableToUtilityApps = 123,
+	VRInitError_Init_Internal = 124,
+	VRInitError_Init_HmdDriverIdIsNone = 125,
+	VRInitError_Init_HmdNotFoundPresenceFailed = 126,
+	VRInitError_Init_VRMonitorNotFound = 127,
+	VRInitError_Init_VRMonitorStartupFailed = 128,
+	VRInitError_Init_LowPowerWatchdogNotSupported = 129,
+	VRInitError_Init_InvalidApplicationType = 130,
+	VRInitError_Init_NotAvailableToWatchdogApps = 131,
+	VRInitError_Init_WatchdogDisabledInSettings = 132,
+	VRInitError_Init_VRDashboardNotFound = 133,
+	VRInitError_Init_VRDashboardStartupFailed = 134,
+	VRInitError_Init_VRHomeNotFound = 135,
+	VRInitError_Init_VRHomeStartupFailed = 136,
+	VRInitError_Init_RebootingBusy = 137,
+	VRInitError_Init_FirmwareUpdateBusy = 138,
+	VRInitError_Init_FirmwareRecoveryBusy = 139,
+
+	VRInitError_Driver_Failed = 200,
+	VRInitError_Driver_Unknown = 201,
+	VRInitError_Driver_HmdUnknown = 202,
+	VRInitError_Driver_NotLoaded = 203,
+	VRInitError_Driver_RuntimeOutOfDate = 204,
+	VRInitError_Driver_HmdInUse = 205,
+	VRInitError_Driver_NotCalibrated = 206,
+	VRInitError_Driver_CalibrationInvalid = 207,
+	VRInitError_Driver_HmdDisplayNotFound = 208,
+	VRInitError_Driver_TrackedDeviceInterfaceUnknown = 209,
+	// VRInitError_Driver_HmdDisplayNotFoundAfterFix = 210, // not needed: here for historic reasons
+	VRInitError_Driver_HmdDriverIdOutOfBounds = 211,
+	VRInitError_Driver_HmdDisplayMirrored = 212,
+
+	VRInitError_IPC_ServerInitFailed = 300,
+	VRInitError_IPC_ConnectFailed = 301,
+	VRInitError_IPC_SharedStateInitFailed = 302,
+	VRInitError_IPC_CompositorInitFailed = 303,
+	VRInitError_IPC_MutexInitFailed = 304,
+	VRInitError_IPC_Failed = 305,
+	VRInitError_IPC_CompositorConnectFailed = 306,
+	VRInitError_IPC_CompositorInvalidConnectResponse = 307,
+	VRInitError_IPC_ConnectFailedAfterMultipleAttempts = 308,
+
+	VRInitError_Compositor_Failed = 400,
+	VRInitError_Compositor_D3D11HardwareRequired = 401,
+	VRInitError_Compositor_FirmwareRequiresUpdate = 402,
+	VRInitError_Compositor_OverlayInitFailed = 403,
+	VRInitError_Compositor_ScreenshotsInitFailed = 404,
+	VRInitError_Compositor_UnableToCreateDevice = 405,
+
+	VRInitError_VendorSpecific_UnableToConnectToOculusRuntime = 1000,
+
+	VRInitError_VendorSpecific_HmdFound_CantOpenDevice = 1101,
+	VRInitError_VendorSpecific_HmdFound_UnableToRequestConfigStart = 1102,
+	VRInitError_VendorSpecific_HmdFound_NoStoredConfig = 1103,
+	VRInitError_VendorSpecific_HmdFound_ConfigTooBig = 1104,
+	VRInitError_VendorSpecific_HmdFound_ConfigTooSmall = 1105,
+	VRInitError_VendorSpecific_HmdFound_UnableToInitZLib = 1106,
+	VRInitError_VendorSpecific_HmdFound_CantReadFirmwareVersion = 1107,
+	VRInitError_VendorSpecific_HmdFound_UnableToSendUserDataStart = 1108,
+	VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataStart = 1109,
+	VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataNext = 1110,
+	VRInitError_VendorSpecific_HmdFound_UserDataAddressRange = 1111,
+	VRInitError_VendorSpecific_HmdFound_UserDataError = 1112,
+	VRInitError_VendorSpecific_HmdFound_ConfigFailedSanityCheck = 1113,
+
+	VRInitError_Steam_SteamInstallationNotFound = 2000,
+};
+
+enum EVRScreenshotType
+{
+	VRScreenshotType_None = 0,
+	VRScreenshotType_Mono = 1,  // left eye only
+	VRScreenshotType_Stereo = 2,
+	VRScreenshotType_Cubemap = 3,
+	VRScreenshotType_MonoPanorama = 4,
+	VRScreenshotType_StereoPanorama = 5
+};
+
+enum EVRScreenshotPropertyFilenames
+{
+	VRScreenshotPropertyFilenames_Preview = 0,
+	VRScreenshotPropertyFilenames_VR = 1,
+};
+
+enum EVRTrackedCameraError
+{
+	VRTrackedCameraError_None = 0,
+	VRTrackedCameraError_OperationFailed = 100,
+	VRTrackedCameraError_InvalidHandle = 101,
+	VRTrackedCameraError_InvalidFrameHeaderVersion = 102,
+	VRTrackedCameraError_OutOfHandles = 103,
+	VRTrackedCameraError_IPCFailure = 104,
+	VRTrackedCameraError_NotSupportedForThisDevice = 105,
+	VRTrackedCameraError_SharedMemoryFailure = 106,
+	VRTrackedCameraError_FrameBufferingFailure = 107,
+	VRTrackedCameraError_StreamSetupFailure = 108,
+	VRTrackedCameraError_InvalidGLTextureId = 109,
+	VRTrackedCameraError_InvalidSharedTextureHandle = 110,
+	VRTrackedCameraError_FailedToGetGLTextureId = 111,
+	VRTrackedCameraError_SharedTextureFailure = 112,
+	VRTrackedCameraError_NoFrameAvailable = 113,
+	VRTrackedCameraError_InvalidArgument = 114,
+	VRTrackedCameraError_InvalidFrameBufferSize = 115,
+};
+
+enum EVRTrackedCameraFrameType
+{
+	VRTrackedCameraFrameType_Distorted = 0,       // This is the camera video frame size in pixels, still distorted.
+	VRTrackedCameraFrameType_Undistorted,         // In pixels, an undistorted inscribed rectangle region without invalid regions. This size is subject to changes shortly.
+	VRTrackedCameraFrameType_MaximumUndistorted,  // In pixels, maximum undistorted with invalid regions. Non zero alpha component identifies valid regions.
+	MAX_CAMERA_FRAME_TYPES
+};
+
+typedef uint64_t TrackedCameraHandle_t;
+#define INVALID_TRACKED_CAMERA_HANDLE ((vr::TrackedCameraHandle_t)0)
+
+struct CameraVideoStreamFrameHeader_t
+{
+	EVRTrackedCameraFrameType eFrameType;
+
+	uint32_t nWidth;
+	uint32_t nHeight;
+	uint32_t nBytesPerPixel;
+
+	uint32_t nFrameSequence;
+
+	TrackedDevicePose_t standingTrackedDevicePose;
+};
+
+// Screenshot types
+typedef uint32_t ScreenshotHandle_t;
+
+static const uint32_t k_unScreenshotHandleInvalid = 0;
+
+#pragma pack(pop)
+
+// figure out how to import from the VR API dll
+#if defined(_WIN32)
+
+#ifdef VR_API_EXPORT
+#define VR_INTERFACE extern "C" __declspec(dllexport)
+#else
+#define VR_INTERFACE extern "C" __declspec(dllimport)
+#endif
+
+#elif defined(__GNUC__) || defined(COMPILER_GCC) || defined(__APPLE__)
+
+#ifdef VR_API_EXPORT
+#define VR_INTERFACE extern "C" __attribute__((visibility("default")))
+#else
+#define VR_INTERFACE extern "C"
+#endif
+
+#else
+#error "Unsupported Platform."
+#endif
+
+#if defined(_WIN32)
+#define VR_CALLTYPE __cdecl
+#else
+#define VR_CALLTYPE
+#endif
+
+}  // namespace vr
+
+#endif  // _INCLUDE_VRTYPES_H
+
+// vrannotation.h
+#ifdef API_GEN
+#define VR_CLANG_ATTR(ATTR) __attribute__((annotate(ATTR)))
+#else
+#define VR_CLANG_ATTR(ATTR)
+#endif
+
+#define VR_METHOD_DESC(DESC) VR_CLANG_ATTR("desc:" #DESC ";")
+#define VR_IGNOREATTR() VR_CLANG_ATTR("ignore")
+#define VR_OUT_STRUCT() VR_CLANG_ATTR("out_struct: ;")
+#define VR_OUT_STRING() VR_CLANG_ATTR("out_string: ;")
+#define VR_OUT_ARRAY_CALL(COUNTER, FUNCTION, PARAMS) VR_CLANG_ATTR("out_array_call:" #COUNTER "," #FUNCTION "," #PARAMS ";")
+#define VR_OUT_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR("out_array_count:" #COUNTER ";")
+#define VR_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR("array_count:" #COUNTER ";")
+#define VR_ARRAY_COUNT_D(COUNTER, DESC) VR_CLANG_ATTR("array_count:" #COUNTER ";desc:" #DESC)
+#define VR_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR("buffer_count:" #COUNTER ";")
+#define VR_OUT_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR("out_buffer_count:" #COUNTER ";")
+#define VR_OUT_STRING_COUNT(COUNTER) VR_CLANG_ATTR("out_string_count:" #COUNTER ";")
+
+// vrtrackedcameratypes.h
+#ifndef _VRTRACKEDCAMERATYPES_H
+#define _VRTRACKEDCAMERATYPES_H
+
+namespace vr
+{
+#pragma pack(push, 8)
+
+enum ECameraVideoStreamFormat
+{
+	CVS_FORMAT_UNKNOWN = 0,
+	CVS_FORMAT_RAW10 = 1,  // 10 bits per pixel
+	CVS_FORMAT_NV12 = 2,   // 12 bits per pixel
+	CVS_FORMAT_RGB24 = 3,  // 24 bits per pixel
+	CVS_MAX_FORMATS
+};
+
+enum ECameraCompatibilityMode
+{
+	CAMERA_COMPAT_MODE_BULK_DEFAULT = 0,
+	CAMERA_COMPAT_MODE_BULK_64K_DMA,
+	CAMERA_COMPAT_MODE_BULK_16K_DMA,
+	CAMERA_COMPAT_MODE_BULK_8K_DMA,
+	CAMERA_COMPAT_MODE_ISO_52FPS,
+	CAMERA_COMPAT_MODE_ISO_50FPS,
+	CAMERA_COMPAT_MODE_ISO_48FPS,
+	CAMERA_COMPAT_MODE_ISO_46FPS,
+	CAMERA_COMPAT_MODE_ISO_44FPS,
+	CAMERA_COMPAT_MODE_ISO_42FPS,
+	CAMERA_COMPAT_MODE_ISO_40FPS,
+	CAMERA_COMPAT_MODE_ISO_35FPS,
+	CAMERA_COMPAT_MODE_ISO_30FPS,
+	MAX_CAMERA_COMPAT_MODES
+};
+
+#ifdef _MSC_VER
+#define VR_CAMERA_DECL_ALIGN(x) __declspec(align(x))
+#else
+#define VR_CAMERA_DECL_ALIGN(x)  //
+#endif
+
+#define MAX_CAMERA_FRAME_SHARED_HANDLES 4
+
+VR_CAMERA_DECL_ALIGN(8)
+struct CameraVideoStreamFrame_t
+{
+	ECameraVideoStreamFormat m_nStreamFormat;
+
+	uint32_t m_nWidth;
+	uint32_t m_nHeight;
+
+	uint32_t m_nImageDataSize;  // Based on stream format, width, height
+
+	uint32_t m_nFrameSequence;  // Starts from 0 when stream starts.
+
+	uint32_t m_nBufferIndex;  // Identifies which buffer the image data is hosted
+	uint32_t m_nBufferCount;  // Total number of configured buffers
+
+	uint32_t m_nExposureTime;
+
+	uint32_t m_nISPFrameTimeStamp;  // Driver provided time stamp per driver centric time base
+	uint32_t m_nISPReferenceTimeStamp;
+	uint32_t m_nSyncCounter;
+
+	uint32_t m_nCamSyncEvents;
+	uint32_t m_nISPSyncEvents;
+
+	double m_flReferenceCamSyncTime;
+
+	double m_flFrameElapsedTime;  // Starts from 0 when stream starts. In seconds.
+	double m_flFrameDeliveryRate;
+
+	double m_flFrameCaptureTime_DriverAbsolute;    // In USB time, via AuxEvent
+	double m_flFrameCaptureTime_ServerRelative;    // In System time within the server
+	uint64_t m_nFrameCaptureTicks_ServerAbsolute;  // In system ticks within the server
+	double m_flFrameCaptureTime_ClientRelative;    // At the client, relative to when the frame was exposed/captured.
+
+	double m_flSyncMarkerError;
+
+	TrackedDevicePose_t m_StandingTrackedDevicePose;  // Supplied by HMD layer when used as a tracked camera
+
+	uint64_t m_pImageData;
+};
+
+#pragma pack(pop)
+
+}  // namespace vr
+
+#endif  // _VRTRACKEDCAMERATYPES_H
+// ivrsettings.h
+namespace vr
+{
+enum EVRSettingsError
+{
+	VRSettingsError_None = 0,
+	VRSettingsError_IPCFailed = 1,
+	VRSettingsError_WriteFailed = 2,
+	VRSettingsError_ReadFailed = 3,
+	VRSettingsError_JsonParseFailed = 4,
+	VRSettingsError_UnsetSettingHasNoDefault = 5,  // This will be returned if the setting does not appear in the appropriate default file and has not been set
+};
+
+// The maximum length of a settings key
+static const uint32_t k_unMaxSettingsKeyLength = 128;
+
+class IVRSettings
+{
+public:
+	virtual const char *GetSettingsErrorNameFromEnum(EVRSettingsError eError) = 0;
+
+	// Returns true if file sync occurred (force or settings dirty)
+	virtual bool Sync(bool bForce = false, EVRSettingsError *peError = nullptr) = 0;
+
+	virtual void SetBool(const char *pchSection, const char *pchSettingsKey, bool bValue, EVRSettingsError *peError = nullptr) = 0;
+	virtual void SetInt32(const char *pchSection, const char *pchSettingsKey, int32_t nValue, EVRSettingsError *peError = nullptr) = 0;
+	virtual void SetFloat(const char *pchSection, const char *pchSettingsKey, float flValue, EVRSettingsError *peError = nullptr) = 0;
+	virtual void SetString(const char *pchSection, const char *pchSettingsKey, const char *pchValue, EVRSettingsError *peError = nullptr) = 0;
+
+	// Users of the system need to provide a proper default in default.vrsettings in the resources/settings/ directory
+	// of either the runtime or the driver_xxx directory. Otherwise the default will be false, 0, 0.0 or ""
+	virtual bool GetBool(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+	virtual int32_t GetInt32(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+	virtual float GetFloat(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+	virtual void GetString(const char *pchSection, const char *pchSettingsKey, VR_OUT_STRING() char *pchValue, uint32_t unValueLen, EVRSettingsError *peError = nullptr) = 0;
+
+	virtual void RemoveSection(const char *pchSection, EVRSettingsError *peError = nullptr) = 0;
+	virtual void RemoveKeyInSection(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+};
+
+//-----------------------------------------------------------------------------
+static const char *const IVRSettings_Version = "IVRSettings_002";
+
+//-----------------------------------------------------------------------------
+// steamvr keys
+static const char *const k_pch_SteamVR_Section = "steamvr";
+static const char *const k_pch_SteamVR_RequireHmd_String = "requireHmd";
+static const char *const k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver";
+static const char *const k_pch_SteamVR_ForcedHmdKey_String = "forcedHmd";
+static const char *const k_pch_SteamVR_DisplayDebug_Bool = "displayDebug";
+static const char *const k_pch_SteamVR_DebugProcessPipe_String = "debugProcessPipe";
+static const char *const k_pch_SteamVR_DisplayDebugX_Int32 = "displayDebugX";
+static const char *const k_pch_SteamVR_DisplayDebugY_Int32 = "displayDebugY";
+static const char *const k_pch_SteamVR_SendSystemButtonToAllApps_Bool = "sendSystemButtonToAllApps";
+static const char *const k_pch_SteamVR_LogLevel_Int32 = "loglevel";
+static const char *const k_pch_SteamVR_IPD_Float = "ipd";
+static const char *const k_pch_SteamVR_Background_String = "background";
+static const char *const k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection";
+static const char *const k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight";
+static const char *const k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius";
+static const char *const k_pch_SteamVR_GridColor_String = "gridColor";
+static const char *const k_pch_SteamVR_PlayAreaColor_String = "playAreaColor";
+static const char *const k_pch_SteamVR_ShowStage_Bool = "showStage";
+static const char *const k_pch_SteamVR_ActivateMultipleDrivers_Bool = "activateMultipleDrivers";
+static const char *const k_pch_SteamVR_DirectMode_Bool = "directMode";
+static const char *const k_pch_SteamVR_DirectModeEdidVid_Int32 = "directModeEdidVid";
+static const char *const k_pch_SteamVR_DirectModeEdidPid_Int32 = "directModeEdidPid";
+static const char *const k_pch_SteamVR_UsingSpeakers_Bool = "usingSpeakers";
+static const char *const k_pch_SteamVR_SpeakersForwardYawOffsetDegrees_Float = "speakersForwardYawOffsetDegrees";
+static const char *const k_pch_SteamVR_BaseStationPowerManagement_Bool = "basestationPowerManagement";
+static const char *const k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses";
+static const char *const k_pch_SteamVR_SupersampleScale_Float = "supersampleScale";
+static const char *const k_pch_SteamVR_AllowAsyncReprojection_Bool = "allowAsyncReprojection";
+static const char *const k_pch_SteamVR_AllowReprojection_Bool = "allowInterleavedReprojection";
+static const char *const k_pch_SteamVR_ForceReprojection_Bool = "forceReprojection";
+static const char *const k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking";
+static const char *const k_pch_SteamVR_DefaultMirrorView_Int32 = "defaultMirrorView";
+static const char *const k_pch_SteamVR_ShowMirrorView_Bool = "showMirrorView";
+static const char *const k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry";
+static const char *const k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch";
+static const char *const k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch";
+static const char *const k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch";
+static const char *const k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard";
+static const char *const k_pch_SteamVR_EnableHomeApp = "enableHomeApp";
+static const char *const k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec";
+static const char *const k_pch_SteamVR_RetailDemo_Bool = "retailDemo";
+static const char *const k_pch_SteamVR_IpdOffset_Float = "ipdOffset";
+static const char *const k_pch_SteamVR_AllowSupersampleFiltering_Bool = "allowSupersampleFiltering";
+static const char *const k_pch_SteamVR_EnableLinuxVulkanAsync_Bool = "enableLinuxVulkanAsync";
+
+//-----------------------------------------------------------------------------
+// lighthouse keys
+static const char *const k_pch_Lighthouse_Section = "driver_lighthouse";
+static const char *const k_pch_Lighthouse_DisableIMU_Bool = "disableimu";
+static const char *const k_pch_Lighthouse_UseDisambiguation_String = "usedisambiguation";
+static const char *const k_pch_Lighthouse_DisambiguationDebug_Int32 = "disambiguationdebug";
+static const char *const k_pch_Lighthouse_PrimaryBasestation_Int32 = "primarybasestation";
+static const char *const k_pch_Lighthouse_DBHistory_Bool = "dbhistory";
+
+//-----------------------------------------------------------------------------
+// null keys
+static const char *const k_pch_Null_Section = "driver_null";
+static const char *const k_pch_Null_SerialNumber_String = "serialNumber";
+static const char *const k_pch_Null_ModelNumber_String = "modelNumber";
+static const char *const k_pch_Null_WindowX_Int32 = "windowX";
+static const char *const k_pch_Null_WindowY_Int32 = "windowY";
+static const char *const k_pch_Null_WindowWidth_Int32 = "windowWidth";
+static const char *const k_pch_Null_WindowHeight_Int32 = "windowHeight";
+static const char *const k_pch_Null_RenderWidth_Int32 = "renderWidth";
+static const char *const k_pch_Null_RenderHeight_Int32 = "renderHeight";
+static const char *const k_pch_Null_SecondsFromVsyncToPhotons_Float = "secondsFromVsyncToPhotons";
+static const char *const k_pch_Null_DisplayFrequency_Float = "displayFrequency";
+
+//-----------------------------------------------------------------------------
+// user interface keys
+static const char *const k_pch_UserInterface_Section = "userinterface";
+static const char *const k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop";
+static const char *const k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray";
+static const char *const k_pch_UserInterface_Screenshots_Bool = "screenshots";
+static const char *const k_pch_UserInterface_ScreenshotType_Int = "screenshotType";
+
+//-----------------------------------------------------------------------------
+// notification keys
+static const char *const k_pch_Notifications_Section = "notifications";
+static const char *const k_pch_Notifications_DoNotDisturb_Bool = "DoNotDisturb";
+
+//-----------------------------------------------------------------------------
+// keyboard keys
+static const char *const k_pch_Keyboard_Section = "keyboard";
+static const char *const k_pch_Keyboard_TutorialCompletions = "TutorialCompletions";
+static const char *const k_pch_Keyboard_ScaleX = "ScaleX";
+static const char *const k_pch_Keyboard_ScaleY = "ScaleY";
+static const char *const k_pch_Keyboard_OffsetLeftX = "OffsetLeftX";
+static const char *const k_pch_Keyboard_OffsetRightX = "OffsetRightX";
+static const char *const k_pch_Keyboard_OffsetY = "OffsetY";
+static const char *const k_pch_Keyboard_Smoothing = "Smoothing";
+
+//-----------------------------------------------------------------------------
+// perf keys
+static const char *const k_pch_Perf_Section = "perfcheck";
+static const char *const k_pch_Perf_HeuristicActive_Bool = "heuristicActive";
+static const char *const k_pch_Perf_NotifyInHMD_Bool = "warnInHMD";
+static const char *const k_pch_Perf_NotifyOnlyOnce_Bool = "warnOnlyOnce";
+static const char *const k_pch_Perf_AllowTimingStore_Bool = "allowTimingStore";
+static const char *const k_pch_Perf_SaveTimingsOnExit_Bool = "saveTimingsOnExit";
+static const char *const k_pch_Perf_TestData_Float = "perfTestData";
+static const char *const k_pch_Perf_LinuxGPUProfiling_Bool = "linuxGPUProfiling";
+
+//-----------------------------------------------------------------------------
+// collision bounds keys
+static const char *const k_pch_CollisionBounds_Section = "collisionBounds";
+static const char *const k_pch_CollisionBounds_Style_Int32 = "CollisionBoundsStyle";
+static const char *const k_pch_CollisionBounds_GroundPerimeterOn_Bool = "CollisionBoundsGroundPerimeterOn";
+static const char *const k_pch_CollisionBounds_CenterMarkerOn_Bool = "CollisionBoundsCenterMarkerOn";
+static const char *const k_pch_CollisionBounds_PlaySpaceOn_Bool = "CollisionBoundsPlaySpaceOn";
+static const char *const k_pch_CollisionBounds_FadeDistance_Float = "CollisionBoundsFadeDistance";
+static const char *const k_pch_CollisionBounds_ColorGammaR_Int32 = "CollisionBoundsColorGammaR";
+static const char *const k_pch_CollisionBounds_ColorGammaG_Int32 = "CollisionBoundsColorGammaG";
+static const char *const k_pch_CollisionBounds_ColorGammaB_Int32 = "CollisionBoundsColorGammaB";
+static const char *const k_pch_CollisionBounds_ColorGammaA_Int32 = "CollisionBoundsColorGammaA";
+
+//-----------------------------------------------------------------------------
+// camera keys
+static const char *const k_pch_Camera_Section = "camera";
+static const char *const k_pch_Camera_EnableCamera_Bool = "enableCamera";
+static const char *const k_pch_Camera_EnableCameraInDashboard_Bool = "enableCameraInDashboard";
+static const char *const k_pch_Camera_EnableCameraForCollisionBounds_Bool = "enableCameraForCollisionBounds";
+static const char *const k_pch_Camera_EnableCameraForRoomView_Bool = "enableCameraForRoomView";
+static const char *const k_pch_Camera_BoundsColorGammaR_Int32 = "cameraBoundsColorGammaR";
+static const char *const k_pch_Camera_BoundsColorGammaG_Int32 = "cameraBoundsColorGammaG";
+static const char *const k_pch_Camera_BoundsColorGammaB_Int32 = "cameraBoundsColorGammaB";
+static const char *const k_pch_Camera_BoundsColorGammaA_Int32 = "cameraBoundsColorGammaA";
+static const char *const k_pch_Camera_BoundsStrength_Int32 = "cameraBoundsStrength";
+
+//-----------------------------------------------------------------------------
+// audio keys
+static const char *const k_pch_audio_Section = "audio";
+static const char *const k_pch_audio_OnPlaybackDevice_String = "onPlaybackDevice";
+static const char *const k_pch_audio_OnRecordDevice_String = "onRecordDevice";
+static const char *const k_pch_audio_OnPlaybackMirrorDevice_String = "onPlaybackMirrorDevice";
+static const char *const k_pch_audio_OffPlaybackDevice_String = "offPlaybackDevice";
+static const char *const k_pch_audio_OffRecordDevice_String = "offRecordDevice";
+static const char *const k_pch_audio_VIVEHDMIGain = "viveHDMIGain";
+
+//-----------------------------------------------------------------------------
+// power management keys
+static const char *const k_pch_Power_Section = "power";
+static const char *const k_pch_Power_PowerOffOnExit_Bool = "powerOffOnExit";
+static const char *const k_pch_Power_TurnOffScreensTimeout_Float = "turnOffScreensTimeout";
+static const char *const k_pch_Power_TurnOffControllersTimeout_Float = "turnOffControllersTimeout";
+static const char *const k_pch_Power_ReturnToWatchdogTimeout_Float = "returnToWatchdogTimeout";
+static const char *const k_pch_Power_AutoLaunchSteamVROnButtonPress = "autoLaunchSteamVROnButtonPress";
+static const char *const k_pch_Power_PauseCompositorOnStandby_Bool = "pauseCompositorOnStandby";
+
+//-----------------------------------------------------------------------------
+// dashboard keys
+static const char *const k_pch_Dashboard_Section = "dashboard";
+static const char *const k_pch_Dashboard_EnableDashboard_Bool = "enableDashboard";
+static const char *const k_pch_Dashboard_ArcadeMode_Bool = "arcadeMode";
+
+//-----------------------------------------------------------------------------
+// model skin keys
+static const char *const k_pch_modelskin_Section = "modelskins";
+
+//-----------------------------------------------------------------------------
+// driver keys - These could be checked in any driver_<name> section
+static const char *const k_pch_Driver_Enable_Bool = "enable";
+
+}  // namespace vr
+
+// iservertrackeddevicedriver.h
+namespace vr
+{
+struct DriverPoseQuaternion_t
+{
+	double w, x, y, z;
+};
+
+struct DriverPose_t
+{
+	/* Time offset of this pose, in seconds from the actual time of the pose,
+	 * relative to the time of the PoseUpdated() call made by the driver.
+	 */
+	double poseTimeOffset;
+
+	/* Generally, the pose maintained by a driver
+	 * is in an inertial coordinate system different
+	 * from the world system of x+ right, y+ up, z+ back.
+	 * Also, the driver is not usually tracking the "head" position,
+	 * but instead an internal IMU or another reference point in the HMD.
+	 * The following two transforms transform positions and orientations
+	 * to app world space from driver world space,
+	 * and to HMD head space from driver local body space. 
+	 *
+	 * We maintain the driver pose state in its internal coordinate system,
+	 * so we can do the pose prediction math without having to
+	 * use angular acceleration.  A driver's angular acceleration is generally not measured,
+	 * and is instead calculated from successive samples of angular velocity.
+	 * This leads to a noisy angular acceleration values, which are also
+	 * lagged due to the filtering required to reduce noise to an acceptable level.
+	 */
+	vr::HmdQuaternion_t qWorldFromDriverRotation;
+	double vecWorldFromDriverTranslation[3];
+
+	vr::HmdQuaternion_t qDriverFromHeadRotation;
+	double vecDriverFromHeadTranslation[3];
+
+	/* State of driver pose, in meters and radians. */
+	/* Position of the driver tracking reference in driver world space
+	* +[0] (x) is right
+	* +[1] (y) is up
+	* -[2] (z) is forward
+	*/
+	double vecPosition[3];
+
+	/* Velocity of the pose in meters/second */
+	double vecVelocity[3];
+
+	/* Acceleration of the pose in meters/second */
+	double vecAcceleration[3];
+
+	/* Orientation of the tracker, represented as a quaternion */
+	vr::HmdQuaternion_t qRotation;
+
+	/* Angular velocity of the pose in axis-angle 
+	* representation. The direction is the angle of
+	* rotation and the magnitude is the angle around
+	* that axis in radians/second. */
+	double vecAngularVelocity[3];
+
+	/* Angular acceleration of the pose in axis-angle 
+	* representation. The direction is the angle of
+	* rotation and the magnitude is the angle around
+	* that axis in radians/second^2. */
+	double vecAngularAcceleration[3];
+
+	ETrackingResult result;
+
+	bool poseIsValid;
+	bool willDriftInYaw;
+	bool shouldApplyHeadModel;
+	bool deviceIsConnected;
+};
+
+// ----------------------------------------------------------------------------------------------
+// Purpose: Represents a single tracked device in a driver
+// ----------------------------------------------------------------------------------------------
+class ITrackedDeviceServerDriver
+{
+public:
+	// ------------------------------------
+	// Management Methods
+	// ------------------------------------
+	/** This is called before an HMD is returned to the application. It will always be
+	* called before any display or tracking methods. Memory and processor use by the
+	* ITrackedDeviceServerDriver object should be kept to a minimum until it is activated.
+	* The pose listener is guaranteed to be valid until Deactivate is called, but
+	* should not be used after that point. */
+	virtual EVRInitError Activate(uint32_t unObjectId) = 0;
+
+	/** This is called when The VR system is switching from this Hmd being the active display
+	* to another Hmd being the active display. The driver should clean whatever memory
+	* and thread use it can when it is deactivated */
+	virtual void Deactivate() = 0;
+
+	/** Handles a request from the system to put this device into standby mode. What that means is defined per-device. */
+	virtual void EnterStandby() = 0;
+
+	/** Requests a component interface of the driver for device-specific functionality. The driver should return NULL
+	* if the requested interface or version is not supported. */
+	virtual void *GetComponent(const char *pchComponentNameAndVersion) = 0;
+
+	/** A VR Client has made this debug request of the driver. The set of valid requests is entirely
+	* up to the driver and the client to figure out, as is the format of the response. Responses that
+	* exceed the length of the supplied buffer should be truncated and null terminated */
+	virtual void DebugRequest(const char *pchRequest, char *pchResponseBuffer, uint32_t unResponseBufferSize) = 0;
+
+	// ------------------------------------
+	// Tracking Methods
+	// ------------------------------------
+	virtual DriverPose_t GetPose() = 0;
+};
+
+static const char *ITrackedDeviceServerDriver_Version = "ITrackedDeviceServerDriver_005";
+
+}  // namespace vr
+// ivrdisplaycomponent.h
+namespace vr
+{
+// ----------------------------------------------------------------------------------------------
+// Purpose: The display component on a single tracked device
+// ----------------------------------------------------------------------------------------------
+class IVRDisplayComponent
+{
+public:
+	// ------------------------------------
+	// Display Methods
+	// ------------------------------------
+
+	/** Size and position that the window needs to be on the VR display. */
+	virtual void GetWindowBounds(int32_t *pnX, int32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight) = 0;
+
+	/** Returns true if the display is extending the desktop. */
+	virtual bool IsDisplayOnDesktop() = 0;
+
+	/** Returns true if the display is real and not a fictional display. */
+	virtual bool IsDisplayRealDisplay() = 0;
+
+	/** Suggested size for the intermediate render target that the distortion pulls from. */
+	virtual void GetRecommendedRenderTargetSize(uint32_t *pnWidth, uint32_t *pnHeight) = 0;
+
+	/** Gets the viewport in the frame buffer to draw the output of the distortion into */
+	virtual void GetEyeOutputViewport(EVREye eEye, uint32_t *pnX, uint32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight) = 0;
+
+	/** The components necessary to build your own projection matrix in case your
+		* application is doing something fancy like infinite Z */
+	virtual void GetProjectionRaw(EVREye eEye, float *pfLeft, float *pfRight, float *pfTop, float *pfBottom) = 0;
+
+	/** Returns the result of the distortion function for the specified eye and input UVs. UVs go from 0,0 in
+		* the upper left of that eye's viewport and 1,1 in the lower right of that eye's viewport. */
+	virtual DistortionCoordinates_t ComputeDistortion(EVREye eEye, float fU, float fV) = 0;
+};
+
+static const char *IVRDisplayComponent_Version = "IVRDisplayComponent_002";
+
+}  // namespace vr
+
+// ivrdriverdirectmodecomponent.h
+namespace vr
+{
+// ----------------------------------------------------------------------------------------------
+// Purpose: This component is used for drivers that implement direct mode entirely on their own
+//			without allowing the VR Compositor to own the window/device. Chances are you don't
+//			need to implement this component in your driver.
+// ----------------------------------------------------------------------------------------------
+class IVRDriverDirectModeComponent
+{
+public:
+	// -----------------------------------
+	// Direct mode methods
+	// -----------------------------------
+
+	/** Specific to Oculus compositor support, textures supplied must be created using this method. */
+	virtual void CreateSwapTextureSet(uint32_t unPid, uint32_t unFormat, uint32_t unWidth, uint32_t unHeight, vr::SharedTextureHandle_t (*pSharedTextureHandles)[3]) {}
+
+	/** Used to textures created using CreateSwapTextureSet.  Only one of the set's handles needs to be used to destroy the entire set. */
+	virtual void DestroySwapTextureSet(vr::SharedTextureHandle_t sharedTextureHandle) {}
+
+	/** Used to purge all texture sets for a given process. */
+	virtual void DestroyAllSwapTextureSets(uint32_t unPid) {}
+
+	/** After Present returns, calls this to get the next index to use for rendering. */
+	virtual void GetNextSwapTextureSetIndex(vr::SharedTextureHandle_t sharedTextureHandles[2], uint32_t (*pIndices)[2]) {}
+
+	/** Call once per layer to draw for this frame.  One shared texture handle per eye.  Textures must be created
+		* using CreateSwapTextureSet and should be alternated per frame.  Call Present once all layers have been submitted. */
+	virtual void SubmitLayer(vr::SharedTextureHandle_t sharedTextureHandles[2], const vr::VRTextureBounds_t (&bounds)[2], const vr::HmdMatrix34_t *pPose) {}
+
+	/** Submits queued layers for display. */
+	virtual void Present(vr::SharedTextureHandle_t syncTexture) {}
+};
+
+static const char *IVRDriverDirectModeComponent_Version = "IVRDriverDirectModeComponent_002";
+
+}  // namespace vr
+
+// ivrcontrollercomponent.h
+namespace vr
+{
+// ----------------------------------------------------------------------------------------------
+// Purpose: Controller access on a single tracked device.
+// ----------------------------------------------------------------------------------------------
+class IVRControllerComponent
+{
+public:
+	// ------------------------------------
+	// Controller Methods
+	// ------------------------------------
+
+	/** Gets the current state of a controller. */
+	virtual VRControllerState_t GetControllerState() = 0;
+
+	/** Returns a uint64 property. If the property is not available this function will return 0. */
+	virtual bool TriggerHapticPulse(uint32_t unAxisId, uint16_t usPulseDurationMicroseconds) = 0;
+};
+
+static const char *IVRControllerComponent_Version = "IVRControllerComponent_001";
+
+}  // namespace vr
+// ivrcameracomponent.h
+namespace vr
+{
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+class ICameraVideoSinkCallback
+{
+public:
+	virtual void OnCameraVideoSinkCallback() = 0;
+};
+
+// ----------------------------------------------------------------------------------------------
+// Purpose: The camera on a single tracked device
+// ----------------------------------------------------------------------------------------------
+class IVRCameraComponent
+{
+public:
+	// ------------------------------------
+	// Camera Methods
+	// ------------------------------------
+	virtual bool GetCameraFrameDimensions(vr::ECameraVideoStreamFormat nVideoStreamFormat, uint32_t *pWidth, uint32_t *pHeight) = 0;
+	virtual bool GetCameraFrameBufferingRequirements(int *pDefaultFrameQueueSize, uint32_t *pFrameBufferDataSize) = 0;
+	virtual bool SetCameraFrameBuffering(int nFrameBufferCount, void **ppFrameBuffers, uint32_t nFrameBufferDataSize) = 0;
+	virtual bool SetCameraVideoStreamFormat(vr::ECameraVideoStreamFormat nVideoStreamFormat) = 0;
+	virtual vr::ECameraVideoStreamFormat GetCameraVideoStreamFormat() = 0;
+	virtual bool StartVideoStream() = 0;
+	virtual void StopVideoStream() = 0;
+	virtual bool IsVideoStreamActive(bool *pbPaused, float *pflElapsedTime) = 0;
+	virtual const vr::CameraVideoStreamFrame_t *GetVideoStreamFrame() = 0;
+	virtual void ReleaseVideoStreamFrame(const vr::CameraVideoStreamFrame_t *pFrameImage) = 0;
+	virtual bool SetAutoExposure(bool bEnable) = 0;
+	virtual bool PauseVideoStream() = 0;
+	virtual bool ResumeVideoStream() = 0;
+	virtual bool GetCameraDistortion(float flInputU, float flInputV, float *pflOutputU, float *pflOutputV) = 0;
+	virtual bool GetCameraProjection(vr::EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, vr::HmdMatrix44_t *pProjection) = 0;
+	virtual bool SetFrameRate(int nISPFrameRate, int nSensorFrameRate) = 0;
+	virtual bool SetCameraVideoSinkCallback(vr::ICameraVideoSinkCallback *pCameraVideoSinkCallback) = 0;
+	virtual bool GetCameraCompatibilityMode(vr::ECameraCompatibilityMode *pCameraCompatibilityMode) = 0;
+	virtual bool SetCameraCompatibilityMode(vr::ECameraCompatibilityMode nCameraCompatibilityMode) = 0;
+	virtual bool GetCameraFrameBounds(vr::EVRTrackedCameraFrameType eFrameType, uint32_t *pLeft, uint32_t *pTop, uint32_t *pWidth, uint32_t *pHeight) = 0;
+	virtual bool GetCameraIntrinsics(vr::EVRTrackedCameraFrameType eFrameType, HmdVector2_t *pFocalLength, HmdVector2_t *pCenter) = 0;
+};
+
+static const char *IVRCameraComponent_Version = "IVRCameraComponent_002";
+}  // namespace vr
+// itrackeddevicedriverprovider.h
+namespace vr
+{
+class ITrackedDeviceServerDriver;
+struct TrackedDeviceDriverInfo_t;
+struct DriverPose_t;
+typedef PropertyContainerHandle_t DriverHandle_t;
+
+/** This interface is provided by vrserver to allow the driver to notify 
+* the system when something changes about a device. These changes must
+* not change the serial number or class of the device because those values
+* are permanently associated with the device's index. */
+class IVRDriverContext
+{
+public:
+	/** Returns the requested interface. If the interface was not available it will return NULL and fill
+	* out the error. */
+	virtual void *GetGenericInterface(const char *pchInterfaceVersion, EVRInitError *peError = nullptr) = 0;
+
+	/** Returns the property container handle for this driver */
+	virtual DriverHandle_t GetDriverHandle() = 0;
+};
+
+/** This interface must be implemented in each driver. It will be loaded in vrserver.exe */
+class IServerTrackedDeviceProvider
+{
+public:
+	/** initializes the driver. This will be called before any other methods are called.
+	* If Init returns anything other than VRInitError_None the driver DLL will be unloaded.
+	*
+	* pDriverHost will never be NULL, and will always be a pointer to a IServerDriverHost interface
+	*
+	* pchUserDriverConfigDir - The absolute path of the directory where the driver should store user
+	*	config files.
+	* pchDriverInstallDir - The absolute path of the root directory for the driver.
+	*/
+	virtual EVRInitError Init(IVRDriverContext *pDriverContext) = 0;
+
+	/** cleans up the driver right before it is unloaded */
+	virtual void Cleanup() = 0;
+
+	/** Returns the version of the ITrackedDeviceServerDriver interface used by this driver */
+	virtual const char *const *GetInterfaceVersions() = 0;
+
+	/** Allows the driver do to some work in the main loop of the server. */
+	virtual void RunFrame() = 0;
+
+	// ------------  Power State Functions ----------------------- //
+
+	/** Returns true if the driver wants to block Standby mode. */
+	virtual bool ShouldBlockStandbyMode() = 0;
+
+	/** Called when the system is entering Standby mode. The driver should switch itself into whatever sort of low-power
+	* state it has. */
+	virtual void EnterStandby() = 0;
+
+	/** Called when the system is leaving Standby mode. The driver should switch itself back to
+	full operation. */
+	virtual void LeaveStandby() = 0;
+};
+
+static const char *IServerTrackedDeviceProvider_Version = "IServerTrackedDeviceProvider_004";
+
+/** This interface must be implemented in each driver. It will be loaded in vrclient.dll */
+class IVRWatchdogProvider
+{
+public:
+	/** initializes the driver in watchdog mode. */
+	virtual EVRInitError Init(IVRDriverContext *pDriverContext) = 0;
+
+	/** cleans up the driver right before it is unloaded */
+	virtual void Cleanup() = 0;
+};
+
+static const char *IVRWatchdogProvider_Version = "IVRWatchdogProvider_001";
+
+}  // namespace vr
+// ivrproperties.h
+#include <string>
+
+namespace vr
+{
+enum EPropertyWriteType
+{
+	PropertyWrite_Set = 0,
+	PropertyWrite_Erase = 1,
+	PropertyWrite_SetError = 2
+};
+
+struct PropertyWrite_t
+{
+	ETrackedDeviceProperty prop;
+	EPropertyWriteType writeType;
+	ETrackedPropertyError eSetError;
+	void *pvBuffer;
+	uint32_t unBufferSize;
+	PropertyTypeTag_t unTag;
+	ETrackedPropertyError eError;
+};
+
+struct PropertyRead_t
+{
+	ETrackedDeviceProperty prop;
+	void *pvBuffer;
+	uint32_t unBufferSize;
+	PropertyTypeTag_t unTag;
+	uint32_t unRequiredBufferSize;
+	ETrackedPropertyError eError;
+};
+
+class IVRProperties
+{
+public:
+	/** Reads a set of properties atomically. See the PropertyReadBatch_t struct for more information. */
+	virtual ETrackedPropertyError ReadPropertyBatch(PropertyContainerHandle_t ulContainerHandle, PropertyRead_t *pBatch, uint32_t unBatchEntryCount) = 0;
+
+	/** Writes a set of properties atomically. See the PropertyWriteBatch_t struct for more information. */
+	virtual ETrackedPropertyError WritePropertyBatch(PropertyContainerHandle_t ulContainerHandle, PropertyWrite_t *pBatch, uint32_t unBatchEntryCount) = 0;
+
+	/** returns a string that corresponds with the specified property error. The string will be the name
+	* of the error enum value for all valid error codes */
+	virtual const char *GetPropErrorNameFromEnum(ETrackedPropertyError error) = 0;
+
+	/** Returns a container handle given a tracked device index */
+	virtual PropertyContainerHandle_t TrackedDeviceToPropertyContainer(TrackedDeviceIndex_t nDevice) = 0;
+};
+
+static const char *const IVRProperties_Version = "IVRProperties_001";
+
+class CVRPropertyHelpers
+{
+public:
+	CVRPropertyHelpers(IVRProperties *pProperties) : m_pProperties(pProperties) {}
+
+	/** Returns a scaler property. If the device index is not valid or the property value type does not match,
+	* this function will return false. */
+	bool GetBoolProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L);
+	float GetFloatProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L);
+	int32_t GetInt32Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L);
+	uint64_t GetUint64Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L);
+
+	/** Returns a single typed property. If the device index is not valid or the property is not a string type this function will
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters. */
+	uint32_t GetProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, VR_OUT_STRING() void *pvBuffer, uint32_t unBufferSize, PropertyTypeTag_t *punTag, ETrackedPropertyError *pError = 0L);
+
+	/** Returns a string property. If the device index is not valid or the property is not a string type this function will
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters. */
+	uint32_t GetStringProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError = 0L);
+
+	/** Returns a string property as a std::string. If the device index is not valid or the property is not a string type this function will
+	* return an empty string. */
+	std::string GetStringProperty(vr::PropertyContainerHandle_t ulContainer, vr::ETrackedDeviceProperty prop, vr::ETrackedPropertyError *peError = nullptr);
+
+	/** Sets a scaler property. The new value will be returned on any subsequent call to get this property in any process. */
+	ETrackedPropertyError SetBoolProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, bool bNewValue);
+	ETrackedPropertyError SetFloatProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, float fNewValue);
+	ETrackedPropertyError SetInt32Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, int32_t nNewValue);
+	ETrackedPropertyError SetUint64Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, uint64_t ulNewValue);
+
+	/** Sets a string property. The new value will be returned on any subsequent call to get this property in any process. */
+	ETrackedPropertyError SetStringProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, const char *pchNewValue);
+
+	/** Sets a single typed property. The new value will be returned on any subsequent call to get this property in any process. */
+	ETrackedPropertyError SetProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, void *pvNewValue, uint32_t unNewValueSize, PropertyTypeTag_t unTag);
+
+	/** Sets the error return value for a property. This value will be returned on all subsequent requests to get the property */
+	ETrackedPropertyError SetPropertyError(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError eError);
+
+	/** Clears any value or error set for the property. */
+	ETrackedPropertyError EraseProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop);
+
+	/* Turns a device index into a property container handle. */
+	PropertyContainerHandle_t TrackedDeviceToPropertyContainer(TrackedDeviceIndex_t nDevice) { return m_pProperties->TrackedDeviceToPropertyContainer(nDevice); }
+
+private:
+	template <typename T>
+	T GetPropertyHelper(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError, T bDefault, PropertyTypeTag_t unTypeTag);
+
+	IVRProperties *m_pProperties;
+};
+
+inline uint32_t CVRPropertyHelpers::GetProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, VR_OUT_STRING() void *pvBuffer, uint32_t unBufferSize, PropertyTypeTag_t *punTag, ETrackedPropertyError *pError)
+{
+	PropertyRead_t batch;
+	batch.prop = prop;
+	batch.pvBuffer = pvBuffer;
+	batch.unBufferSize = unBufferSize;
+
+	m_pProperties->ReadPropertyBatch(ulContainerHandle, &batch, 1);
+
+	if (pError)
+	{
+		*pError = batch.eError;
+	}
+
+	if (punTag)
+	{
+		*punTag = batch.unTag;
+	}
+
+	return batch.unRequiredBufferSize;
+}
+
+/** Sets a single typed property. The new value will be returned on any subsequent call to get this property in any process. */
+inline ETrackedPropertyError CVRPropertyHelpers::SetProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, void *pvNewValue, uint32_t unNewValueSize, PropertyTypeTag_t unTag)
+{
+	PropertyWrite_t batch;
+	batch.writeType = PropertyWrite_Set;
+	batch.prop = prop;
+	batch.pvBuffer = pvNewValue;
+	batch.unBufferSize = unNewValueSize;
+	batch.unTag = unTag;
+
+	m_pProperties->WritePropertyBatch(ulContainerHandle, &batch, 1);
+
+	return batch.eError;
+}
+
+/** Returns a string property. If the device index is not valid or the property is not a string type this function will
+* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+* null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters. */
+inline uint32_t CVRPropertyHelpers::GetStringProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError)
+{
+	PropertyTypeTag_t unTag;
+	ETrackedPropertyError error;
+	uint32_t unRequiredSize = GetProperty(ulContainerHandle, prop, pchValue, unBufferSize, &unTag, &error);
+	if (unTag != k_unStringPropertyTag && error == TrackedProp_Success)
+	{
+		error = TrackedProp_WrongDataType;
+	}
+
+	if (pError)
+	{
+		*pError = error;
+	}
+
+	if (error != TrackedProp_Success)
+	{
+		if (pchValue && unBufferSize)
+		{
+			*pchValue = '\0';
+		}
+	}
+
+	return unRequiredSize;
+}
+
+/** Returns a string property as a std::string. If the device index is not valid or the property is not a string type this function will
+* return an empty string. */
+inline std::string CVRPropertyHelpers::GetStringProperty(vr::PropertyContainerHandle_t ulContainer, vr::ETrackedDeviceProperty prop, vr::ETrackedPropertyError *peError)
+{
+	char buf[1024];
+	vr::ETrackedPropertyError err;
+	uint32_t unRequiredBufferLen = GetStringProperty(ulContainer, prop, buf, sizeof(buf), &err);
+
+	std::string sResult;
+
+	if (err == TrackedProp_Success)
+	{
+		sResult = buf;
+	}
+	else if (err == TrackedProp_BufferTooSmall)
+	{
+		char *pchBuffer = new char[unRequiredBufferLen];
+		unRequiredBufferLen = GetStringProperty(ulContainer, prop, pchBuffer, unRequiredBufferLen, &err);
+		sResult = pchBuffer;
+		delete[] pchBuffer;
+	}
+
+	if (peError)
+	{
+		*peError = err;
+	}
+
+	return sResult;
+}
+
+/** Sets a string property. The new value will be returned on any subsequent call to get this property in any process. */
+inline ETrackedPropertyError CVRPropertyHelpers::SetStringProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, const char *pchNewValue)
+{
+	if (!pchNewValue)
+		return TrackedProp_InvalidOperation;
+
+	// this is strlen without the dependency on string.h
+	const char *pchCurr = pchNewValue;
+	while (*pchCurr)
+	{
+		pchCurr++;
+	}
+
+	return SetProperty(ulContainerHandle, prop, (void *)pchNewValue, (uint32_t)(pchCurr - pchNewValue) + 1, k_unStringPropertyTag);
+}
+
+template <typename T>
+inline T CVRPropertyHelpers::GetPropertyHelper(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError, T bDefault, PropertyTypeTag_t unTypeTag)
+{
+	T bValue;
+	ETrackedPropertyError eError;
+	PropertyTypeTag_t unReadTag;
+	GetProperty(ulContainerHandle, prop, &bValue, sizeof(bValue), &unReadTag, &eError);
+	if (unReadTag != unTypeTag && eError == TrackedProp_Success)
+	{
+		eError = TrackedProp_WrongDataType;
+	};
+
+	if (pError)
+		*pError = eError;
+	if (eError != TrackedProp_Success)
+	{
+		return bDefault;
+	}
+	else
+	{
+		return bValue;
+	}
+}
+
+inline bool CVRPropertyHelpers::GetBoolProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError)
+{
+	return GetPropertyHelper<bool>(ulContainerHandle, prop, pError, false, k_unBoolPropertyTag);
+}
+
+inline float CVRPropertyHelpers::GetFloatProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError)
+{
+	return GetPropertyHelper<float>(ulContainerHandle, prop, pError, 0.f, k_unFloatPropertyTag);
+}
+
+inline int32_t CVRPropertyHelpers::GetInt32Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError)
+{
+	return GetPropertyHelper<int32_t>(ulContainerHandle, prop, pError, 0, k_unInt32PropertyTag);
+}
+
+inline uint64_t CVRPropertyHelpers::GetUint64Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError)
+{
+	return GetPropertyHelper<uint64_t>(ulContainerHandle, prop, pError, 0, k_unUint64PropertyTag);
+}
+
+inline ETrackedPropertyError CVRPropertyHelpers::SetBoolProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, bool bNewValue)
+{
+	return SetProperty(ulContainerHandle, prop, &bNewValue, sizeof(bNewValue), k_unBoolPropertyTag);
+}
+
+inline ETrackedPropertyError CVRPropertyHelpers::SetFloatProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, float fNewValue)
+{
+	return SetProperty(ulContainerHandle, prop, &fNewValue, sizeof(fNewValue), k_unFloatPropertyTag);
+}
+
+inline ETrackedPropertyError CVRPropertyHelpers::SetInt32Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, int32_t nNewValue)
+{
+	return SetProperty(ulContainerHandle, prop, &nNewValue, sizeof(nNewValue), k_unInt32PropertyTag);
+}
+
+inline ETrackedPropertyError CVRPropertyHelpers::SetUint64Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, uint64_t ulNewValue)
+{
+	return SetProperty(ulContainerHandle, prop, &ulNewValue, sizeof(ulNewValue), k_unUint64PropertyTag);
+}
+
+/** Sets the error return value for a property. This value will be returned on all subsequent requests to get the property */
+inline ETrackedPropertyError CVRPropertyHelpers::SetPropertyError(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError eError)
+{
+	PropertyWrite_t batch;
+	batch.writeType = PropertyWrite_SetError;
+	batch.prop = prop;
+	batch.eSetError = eError;
+
+	m_pProperties->WritePropertyBatch(ulContainerHandle, &batch, 1);
+
+	return batch.eError;
+}
+
+/** Clears any value or error set for the property. */
+inline ETrackedPropertyError CVRPropertyHelpers::EraseProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop)
+{
+	PropertyWrite_t batch;
+	batch.writeType = PropertyWrite_Erase;
+	batch.prop = prop;
+
+	m_pProperties->WritePropertyBatch(ulContainerHandle, &batch, 1);
+
+	return batch.eError;
+}
+
+}  // namespace vr
+
+// ivrdriverlog.h
+namespace vr
+{
+class IVRDriverLog
+{
+public:
+	/** Writes a log message to the log file prefixed with the driver name */
+	virtual void Log(const char *pchLogMessage) = 0;
+};
+
+static const char *IVRDriverLog_Version = "IVRDriverLog_001";
+
+}  // namespace vr
+// ivrserverdriverhost.h
+namespace vr
+{
+class ITrackedDeviceServerDriver;
+struct TrackedDeviceDriverInfo_t;
+struct DriverPose_t;
+
+/** This interface is provided by vrserver to allow the driver to notify 
+* the system when something changes about a device. These changes must
+* not change the serial number or class of the device because those values
+* are permanently associated with the device's index. */
+class IVRServerDriverHost
+{
+public:
+	/** Notifies the server that a tracked device has been added. If this function returns true
+	* the server will call Activate on the device. If it returns false some kind of error
+	* has occurred and the device will not be activated. */
+	virtual bool TrackedDeviceAdded(const char *pchDeviceSerialNumber, ETrackedDeviceClass eDeviceClass, ITrackedDeviceServerDriver *pDriver) = 0;
+
+	/** Notifies the server that a tracked device's pose has been updated */
+	virtual void TrackedDevicePoseUpdated(uint32_t unWhichDevice, const DriverPose_t &newPose, uint32_t unPoseStructSize) = 0;
+
+	/** Notifies the server that vsync has occurred on the the display attached to the device. This is
+	* only permitted on devices of the HMD class. */
+	virtual void VsyncEvent(double vsyncTimeOffsetSeconds) = 0;
+
+	/** notifies the server that the button was pressed */
+	virtual void TrackedDeviceButtonPressed(uint32_t unWhichDevice, EVRButtonId eButtonId, double eventTimeOffset) = 0;
+
+	/** notifies the server that the button was unpressed */
+	virtual void TrackedDeviceButtonUnpressed(uint32_t unWhichDevice, EVRButtonId eButtonId, double eventTimeOffset) = 0;
+
+	/** notifies the server that the button was pressed */
+	virtual void TrackedDeviceButtonTouched(uint32_t unWhichDevice, EVRButtonId eButtonId, double eventTimeOffset) = 0;
+
+	/** notifies the server that the button was unpressed */
+	virtual void TrackedDeviceButtonUntouched(uint32_t unWhichDevice, EVRButtonId eButtonId, double eventTimeOffset) = 0;
+
+	/** notifies the server than a controller axis changed */
+	virtual void TrackedDeviceAxisUpdated(uint32_t unWhichDevice, uint32_t unWhichAxis, const VRControllerAxis_t &axisState) = 0;
+
+	/** Notifies the server that the proximity sensor on the specified device  */
+	virtual void ProximitySensorState(uint32_t unWhichDevice, bool bProximitySensorTriggered) = 0;
+
+	/** Sends a vendor specific event (VREvent_VendorSpecific_Reserved_Start..VREvent_VendorSpecific_Reserved_End */
+	virtual void VendorSpecificEvent(uint32_t unWhichDevice, vr::EVREventType eventType, const VREvent_Data_t &eventData, double eventTimeOffset) = 0;
+
+	/** Returns true if SteamVR is exiting */
+	virtual bool IsExiting() = 0;
+
+	/** Returns true and fills the event with the next event on the queue if there is one. If there are no events
+	* this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct */
+	virtual bool PollNextEvent(VREvent_t *pEvent, uint32_t uncbVREvent) = 0;
+
+	/** Provides access to device poses for drivers.  Poses are in their "raw" tracking space which is uniquely
+	* defined by each driver providing poses for its devices.  It is up to clients of this function to correlate
+	* poses across different drivers.  Poses are indexed by their device id, and their associated driver and
+	* other properties can be looked up via IVRProperties. */
+	virtual void GetRawTrackedDevicePoses(float fPredictedSecondsFromNow, TrackedDevicePose_t *pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = 0;
+
+	/** Notifies the server that a tracked device's display component transforms have been updated. */
+	virtual void TrackedDeviceDisplayTransformUpdated(uint32_t unWhichDevice, HmdMatrix34_t eyeToHeadLeft, HmdMatrix34_t eyeToHeadRight) = 0;
+};
+
+static const char *IVRServerDriverHost_Version = "IVRServerDriverHost_004";
+
+}  // namespace vr
+
+// ivrhiddenarea.h
+namespace vr
+{
+class CVRHiddenAreaHelpers
+{
+public:
+	CVRHiddenAreaHelpers(IVRProperties *pProperties) : m_pProperties(pProperties) {}
+
+	/** Stores a hidden area mesh in a property */
+	ETrackedPropertyError SetHiddenArea(EVREye eEye, EHiddenAreaMeshType type, HmdVector2_t *pVerts, uint32_t unVertCount);
+
+	/** retrieves a hidden area mesh from a property. Returns the vert count read out of the property.  */
+	uint32_t GetHiddenArea(EVREye eEye, EHiddenAreaMeshType type, HmdVector2_t *pVerts, uint32_t unVertCount, ETrackedPropertyError *peError);
+
+private:
+	ETrackedDeviceProperty GetPropertyEnum(EVREye eEye, EHiddenAreaMeshType type)
+	{
+		return (ETrackedDeviceProperty)(Prop_DisplayHiddenArea_Binary_Start + ((int)type * 2) + (int)eEye);
+	}
+
+	IVRProperties *m_pProperties;
+};
+
+inline ETrackedPropertyError CVRHiddenAreaHelpers::SetHiddenArea(EVREye eEye, EHiddenAreaMeshType type, HmdVector2_t *pVerts, uint32_t unVertCount)
+{
+	ETrackedDeviceProperty prop = GetPropertyEnum(eEye, type);
+	CVRPropertyHelpers propHelpers(m_pProperties);
+	return propHelpers.SetProperty(propHelpers.TrackedDeviceToPropertyContainer(k_unTrackedDeviceIndex_Hmd), prop, pVerts, sizeof(HmdVector2_t) * unVertCount, k_unHiddenAreaPropertyTag);
+}
+
+inline uint32_t CVRHiddenAreaHelpers::GetHiddenArea(EVREye eEye, EHiddenAreaMeshType type, HmdVector2_t *pVerts, uint32_t unVertCount, ETrackedPropertyError *peError)
+{
+	ETrackedDeviceProperty prop = GetPropertyEnum(eEye, type);
+	CVRPropertyHelpers propHelpers(m_pProperties);
+	ETrackedPropertyError propError;
+	PropertyTypeTag_t unTag;
+	uint32_t unBytesNeeded = propHelpers.GetProperty(propHelpers.TrackedDeviceToPropertyContainer(k_unTrackedDeviceIndex_Hmd), prop, pVerts, sizeof(HmdVector2_t) * unVertCount, &unTag, &propError);
+	if (propError == TrackedProp_Success && unTag != k_unHiddenAreaPropertyTag)
+	{
+		propError = TrackedProp_WrongDataType;
+		unBytesNeeded = 0;
+	}
+
+	if (peError)
+	{
+		*peError = propError;
+	}
+
+	return unBytesNeeded / sizeof(HmdVector2_t);
+}
+
+}  // namespace vr
+// ivrwatchdoghost.h
+namespace vr
+{
+/** This interface is provided by vrclient to allow the driver to make everything wake up */
+class IVRWatchdogHost
+{
+public:
+	/** Client drivers in watchdog mode should call this when they have received a signal from hardware that should
+	* cause SteamVR to start */
+	virtual void WatchdogWakeUp() = 0;
+};
+
+static const char *IVRWatchdogHost_Version = "IVRWatchdogHost_001";
+
+};  // namespace vr
+
+// ivrvirtualdisplay.h
+namespace vr
+{
+// ----------------------------------------------------------------------------------------------
+// Purpose: This component is used for drivers that implement a virtual display (e.g. wireless).
+// ----------------------------------------------------------------------------------------------
+class IVRVirtualDisplay
+{
+public:
+	/** Submits final backbuffer for display. */
+	virtual void Present(vr::SharedTextureHandle_t backbufferTextureHandle) = 0;
+
+	/** Block until the last presented buffer start scanning out. */
+	virtual void WaitForPresent() = 0;
+
+	/** Provides timing data for synchronizing with display. */
+	virtual bool GetTimeSinceLastVsync(float *pfSecondsSinceLastVsync, uint64_t *pulFrameCounter) = 0;
+};
+
+static const char *IVRVirtualDisplay_Version = "IVRVirtualDisplay_001";
+
+/** Returns the current IVRVirtualDisplay pointer or NULL the interface could not be found. */
+VR_INTERFACE vr::IVRVirtualDisplay *VR_CALLTYPE VRVirtualDisplay();
+}  // namespace vr
+
+// ivrresources.h
+namespace vr
+{
+class IVRResources
+{
+public:
+	// ------------------------------------
+	// Shared Resource Methods
+	// ------------------------------------
+
+	/** Loads the specified resource into the provided buffer if large enough.
+	* Returns the size in bytes of the buffer required to hold the specified resource. */
+	virtual uint32_t LoadSharedResource(const char *pchResourceName, char *pchBuffer, uint32_t unBufferLen) = 0;
+
+	/** Provides the full path to the specified resource. Resource names can include named directories for
+	* drivers and other things, and this resolves all of those and returns the actual physical path. 
+	* pchResourceTypeDirectory is the subdirectory of resources to look in. */
+	virtual uint32_t GetResourceFullPath(const char *pchResourceName, const char *pchResourceTypeDirectory, char *pchPathBuffer, uint32_t unBufferLen) = 0;
+};
+
+static const char *const IVRResources_Version = "IVRResources_001";
+
+}  // namespace vr
+// ivrdrivermanager.h
+namespace vr
+{
+class IVRDriverManager
+{
+public:
+	virtual uint32_t GetDriverCount() const = 0;
+
+	/** Returns the length of the number of bytes necessary to hold this string including the trailing null. */
+	virtual uint32_t GetDriverName(vr::DriverId_t nDriver, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize) = 0;
+};
+
+static const char *const IVRDriverManager_Version = "IVRDriverManager_001";
+
+}  // namespace vr
+
+namespace vr
+{
+static const char *const k_InterfaceVersions[] =
+	{
+		IVRSettings_Version,
+		ITrackedDeviceServerDriver_Version,
+		IVRDisplayComponent_Version,
+		IVRDriverDirectModeComponent_Version,
+		IVRControllerComponent_Version,
+		IVRCameraComponent_Version,
+		IServerTrackedDeviceProvider_Version,
+		IVRWatchdogProvider_Version,
+		IVRVirtualDisplay_Version,
+		IVRDriverManager_Version,
+		IVRResources_Version,
+		nullptr};
+
+inline IVRDriverContext *&VRDriverContext()
+{
+	static IVRDriverContext *pHost;
+	return pHost;
+}
+
+class COpenVRDriverContext
+{
+public:
+	COpenVRDriverContext() : m_propertyHelpers(nullptr), m_hiddenAreaHelpers(nullptr) { Clear(); }
+	void Clear();
+
+	EVRInitError InitServer();
+	EVRInitError InitWatchdog();
+
+	IVRSettings *VRSettings()
+	{
+		if (m_pVRSettings == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRSettings = (IVRSettings *)VRDriverContext()->GetGenericInterface(IVRSettings_Version, &eError);
+		}
+		return m_pVRSettings;
+	}
+
+	IVRProperties *VRPropertiesRaw()
+	{
+		if (m_pVRProperties == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRProperties = (IVRProperties *)VRDriverContext()->GetGenericInterface(IVRProperties_Version, &eError);
+			m_propertyHelpers = CVRPropertyHelpers(m_pVRProperties);
+			m_hiddenAreaHelpers = CVRHiddenAreaHelpers(m_pVRProperties);
+		}
+		return m_pVRProperties;
+	}
+
+	CVRPropertyHelpers *VRProperties()
+	{
+		VRPropertiesRaw();
+		return &m_propertyHelpers;
+	}
+
+	CVRHiddenAreaHelpers *VRHiddenArea()
+	{
+		VRPropertiesRaw();
+		return &m_hiddenAreaHelpers;
+	}
+
+	IVRServerDriverHost *VRServerDriverHost()
+	{
+		if (m_pVRServerDriverHost == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRServerDriverHost = (IVRServerDriverHost *)VRDriverContext()->GetGenericInterface(IVRServerDriverHost_Version, &eError);
+		}
+		return m_pVRServerDriverHost;
+	}
+
+	IVRWatchdogHost *VRWatchdogHost()
+	{
+		if (m_pVRWatchdogHost == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRWatchdogHost = (IVRWatchdogHost *)VRDriverContext()->GetGenericInterface(IVRWatchdogHost_Version, &eError);
+		}
+		return m_pVRWatchdogHost;
+	}
+
+	IVRDriverLog *VRDriverLog()
+	{
+		if (m_pVRDriverLog == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRDriverLog = (IVRDriverLog *)VRDriverContext()->GetGenericInterface(IVRDriverLog_Version, &eError);
+		}
+		return m_pVRDriverLog;
+	}
+
+	DriverHandle_t VR_CALLTYPE VRDriverHandle()
+	{
+		return VRDriverContext()->GetDriverHandle();
+	}
+
+	IVRDriverManager *VRDriverManager()
+	{
+		if (!m_pVRDriverManager)
+		{
+			EVRInitError eError;
+			m_pVRDriverManager = (IVRDriverManager *)VRDriverContext()->GetGenericInterface(IVRDriverManager_Version, &eError);
+		}
+		return m_pVRDriverManager;
+	}
+
+	IVRResources *VRResources()
+	{
+		if (!m_pVRResources)
+		{
+			EVRInitError eError;
+			m_pVRResources = (IVRResources *)VRDriverContext()->GetGenericInterface(IVRResources_Version, &eError);
+		}
+		return m_pVRResources;
+	}
+
+private:
+	CVRPropertyHelpers m_propertyHelpers;
+	CVRHiddenAreaHelpers m_hiddenAreaHelpers;
+
+	IVRSettings *m_pVRSettings;
+	IVRProperties *m_pVRProperties;
+	IVRServerDriverHost *m_pVRServerDriverHost;
+	IVRWatchdogHost *m_pVRWatchdogHost;
+	IVRDriverLog *m_pVRDriverLog;
+	IVRDriverManager *m_pVRDriverManager;
+	IVRResources *m_pVRResources;
+};
+
+inline COpenVRDriverContext &OpenVRInternal_ModuleServerDriverContext()
+{
+	static void *ctx[sizeof(COpenVRDriverContext) / sizeof(void *)];
+	return *(COpenVRDriverContext *)ctx;  // bypass zero-init constructor
+}
+
+inline IVRSettings *VR_CALLTYPE VRSettings() { return OpenVRInternal_ModuleServerDriverContext().VRSettings(); }
+inline IVRProperties *VR_CALLTYPE VRPropertiesRaw() { return OpenVRInternal_ModuleServerDriverContext().VRPropertiesRaw(); }
+inline CVRPropertyHelpers *VR_CALLTYPE VRProperties() { return OpenVRInternal_ModuleServerDriverContext().VRProperties(); }
+inline CVRHiddenAreaHelpers *VR_CALLTYPE VRHiddenArea() { return OpenVRInternal_ModuleServerDriverContext().VRHiddenArea(); }
+inline IVRDriverLog *VR_CALLTYPE VRDriverLog() { return OpenVRInternal_ModuleServerDriverContext().VRDriverLog(); }
+inline IVRServerDriverHost *VR_CALLTYPE VRServerDriverHost() { return OpenVRInternal_ModuleServerDriverContext().VRServerDriverHost(); }
+inline IVRWatchdogHost *VR_CALLTYPE VRWatchdogHost() { return OpenVRInternal_ModuleServerDriverContext().VRWatchdogHost(); }
+inline DriverHandle_t VR_CALLTYPE VRDriverHandle() { return OpenVRInternal_ModuleServerDriverContext().VRDriverHandle(); }
+inline IVRDriverManager *VR_CALLTYPE VRDriverManager() { return OpenVRInternal_ModuleServerDriverContext().VRDriverManager(); }
+inline IVRResources *VR_CALLTYPE VRResources() { return OpenVRInternal_ModuleServerDriverContext().VRResources(); }
+
+inline void COpenVRDriverContext::Clear()
+{
+	m_pVRSettings = nullptr;
+	m_pVRProperties = nullptr;
+	m_pVRServerDriverHost = nullptr;
+	m_pVRDriverLog = nullptr;
+	m_pVRWatchdogHost = nullptr;
+	m_pVRDriverManager = nullptr;
+	m_pVRResources = nullptr;
+}
+
+inline EVRInitError COpenVRDriverContext::InitServer()
+{
+	Clear();
+	if (!VRServerDriverHost() || !VRSettings() || !VRProperties() || !VRDriverLog() || !VRDriverManager() || !VRResources())
+		return VRInitError_Init_InterfaceNotFound;
+	return VRInitError_None;
+}
+
+inline EVRInitError COpenVRDriverContext::InitWatchdog()
+{
+	Clear();
+	if (!VRWatchdogHost() || !VRSettings() || !VRDriverLog())
+		return VRInitError_Init_InterfaceNotFound;
+	return VRInitError_None;
+}
+
+inline EVRInitError InitServerDriverContext(IVRDriverContext *pContext)
+{
+	VRDriverContext() = pContext;
+	return OpenVRInternal_ModuleServerDriverContext().InitServer();
+}
+
+inline EVRInitError InitWatchdogDriverContext(IVRDriverContext *pContext)
+{
+	VRDriverContext() = pContext;
+	return OpenVRInternal_ModuleServerDriverContext().InitWatchdog();
+}
+
+inline void CleanupDriverContext()
+{
+	VRDriverContext() = nullptr;
+	OpenVRInternal_ModuleServerDriverContext().Clear();
+}
+
+#define VR_INIT_SERVER_DRIVER_CONTEXT(pContext)                          \
+	{                                                                    \
+		vr::EVRInitError eError = vr::InitServerDriverContext(pContext); \
+		if (eError != vr::VRInitError_None)                              \
+			return eError;                                               \
+	}
+
+#define VR_CLEANUP_SERVER_DRIVER_CONTEXT() \
+	vr::CleanupDriverContext();
+
+#define VR_INIT_WATCHDOG_DRIVER_CONTEXT(pContext)                          \
+	{                                                                      \
+		vr::EVRInitError eError = vr::InitWatchdogDriverContext(pContext); \
+		if (eError != vr::VRInitError_None)                                \
+			return eError;                                                 \
+	}
+
+#define VR_CLEANUP_WATCHDOG_DRIVER_CONTEXT() \
+	vr::CleanupDriverContext();
+}  // namespace vr
+// End
+
+#endif  // _OPENVR_DRIVER_API
diff --git a/engine/inc/bullet/ThirdPartyLibs/openvr/bin/osx64/OpenVR.framework/Versions/A/Headers/openvr.h b/engine/inc/bullet/ThirdPartyLibs/openvr/bin/osx64/OpenVR.framework/Versions/A/Headers/openvr.h
new file mode 100644
index 00000000..80461f96
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/openvr/bin/osx64/OpenVR.framework/Versions/A/Headers/openvr.h
@@ -0,0 +1,3698 @@
+#pragma once
+
+// openvr.h
+//========= Copyright Valve Corporation ============//
+// Dynamically generated file. Do not modify this file directly.
+
+#ifndef _OPENVR_API
+#define _OPENVR_API
+
+#include <stdint.h>
+
+// vrtypes.h
+#ifndef _INCLUDE_VRTYPES_H
+#define _INCLUDE_VRTYPES_H
+
+// Forward declarations to avoid requiring vulkan.h
+struct VkDevice_T;
+struct VkPhysicalDevice_T;
+struct VkInstance_T;
+struct VkQueue_T;
+
+// Forward declarations to avoid requiring d3d12.h
+struct ID3D12Resource;
+struct ID3D12CommandQueue;
+
+namespace vr
+{
+#pragma pack(push, 8)
+
+typedef void *glSharedTextureHandle_t;
+typedef int32_t glInt_t;
+typedef uint32_t glUInt_t;
+
+// right-handed system
+// +y is up
+// +x is to the right
+// -z is going away from you
+// Distance unit is  meters
+struct HmdMatrix34_t
+{
+	float m[3][4];
+};
+
+struct HmdMatrix44_t
+{
+	float m[4][4];
+};
+
+struct HmdVector3_t
+{
+	float v[3];
+};
+
+struct HmdVector4_t
+{
+	float v[4];
+};
+
+struct HmdVector3d_t
+{
+	double v[3];
+};
+
+struct HmdVector2_t
+{
+	float v[2];
+};
+
+struct HmdQuaternion_t
+{
+	double w, x, y, z;
+};
+
+struct HmdColor_t
+{
+	float r, g, b, a;
+};
+
+struct HmdQuad_t
+{
+	HmdVector3_t vCorners[4];
+};
+
+struct HmdRect2_t
+{
+	HmdVector2_t vTopLeft;
+	HmdVector2_t vBottomRight;
+};
+
+/** Used to return the post-distortion UVs for each color channel. 
+* UVs range from 0 to 1 with 0,0 in the upper left corner of the 
+* source render target. The 0,0 to 1,1 range covers a single eye. */
+struct DistortionCoordinates_t
+{
+	float rfRed[2];
+	float rfGreen[2];
+	float rfBlue[2];
+};
+
+enum EVREye
+{
+	Eye_Left = 0,
+	Eye_Right = 1
+};
+
+enum ETextureType
+{
+	TextureType_DirectX = 0,    // Handle is an ID3D11Texture
+	TextureType_OpenGL = 1,     // Handle is an OpenGL texture name or an OpenGL render buffer name, depending on submit flags
+	TextureType_Vulkan = 2,     // Handle is a pointer to a VRVulkanTextureData_t structure
+	TextureType_IOSurface = 3,  // Handle is a macOS cross-process-sharable IOSurfaceRef
+	TextureType_DirectX12 = 4,  // Handle is a pointer to a D3D12TextureData_t structure
+};
+
+enum EColorSpace
+{
+	ColorSpace_Auto = 0,    // Assumes 'gamma' for 8-bit per component formats, otherwise 'linear'.  This mirrors the DXGI formats which have _SRGB variants.
+	ColorSpace_Gamma = 1,   // Texture data can be displayed directly on the display without any conversion (a.k.a. display native format).
+	ColorSpace_Linear = 2,  // Same as gamma but has been converted to a linear representation using DXGI's sRGB conversion algorithm.
+};
+
+struct Texture_t
+{
+	void *handle;  // See ETextureType definition above
+	ETextureType eType;
+	EColorSpace eColorSpace;
+};
+
+// Handle to a shared texture (HANDLE on Windows obtained using OpenSharedResource).
+typedef uint64_t SharedTextureHandle_t;
+#define INVALID_SHARED_TEXTURE_HANDLE ((vr::SharedTextureHandle_t)0)
+
+enum ETrackingResult
+{
+	TrackingResult_Uninitialized = 1,
+
+	TrackingResult_Calibrating_InProgress = 100,
+	TrackingResult_Calibrating_OutOfRange = 101,
+
+	TrackingResult_Running_OK = 200,
+	TrackingResult_Running_OutOfRange = 201,
+};
+
+typedef uint32_t DriverId_t;
+static const uint32_t k_nDriverNone = 0xFFFFFFFF;
+
+static const uint32_t k_unMaxDriverDebugResponseSize = 32768;
+
+/** Used to pass device IDs to API calls */
+typedef uint32_t TrackedDeviceIndex_t;
+static const uint32_t k_unTrackedDeviceIndex_Hmd = 0;
+static const uint32_t k_unMaxTrackedDeviceCount = 16;
+static const uint32_t k_unTrackedDeviceIndexOther = 0xFFFFFFFE;
+static const uint32_t k_unTrackedDeviceIndexInvalid = 0xFFFFFFFF;
+
+/** Describes what kind of object is being tracked at a given ID */
+enum ETrackedDeviceClass
+{
+	TrackedDeviceClass_Invalid = 0,            // the ID was not valid.
+	TrackedDeviceClass_HMD = 1,                // Head-Mounted Displays
+	TrackedDeviceClass_Controller = 2,         // Tracked controllers
+	TrackedDeviceClass_GenericTracker = 3,     // Generic trackers, similar to controllers
+	TrackedDeviceClass_TrackingReference = 4,  // Camera and base stations that serve as tracking reference points
+	TrackedDeviceClass_DisplayRedirect = 5,    // Accessories that aren't necessarily tracked themselves, but may redirect video output from other tracked devices
+};
+
+/** Describes what specific role associated with a tracked device */
+enum ETrackedControllerRole
+{
+	TrackedControllerRole_Invalid = 0,    // Invalid value for controller type
+	TrackedControllerRole_LeftHand = 1,   // Tracked device associated with the left hand
+	TrackedControllerRole_RightHand = 2,  // Tracked device associated with the right hand
+};
+
+/** describes a single pose for a tracked object */
+struct TrackedDevicePose_t
+{
+	HmdMatrix34_t mDeviceToAbsoluteTracking;
+	HmdVector3_t vVelocity;         // velocity in tracker space in m/s
+	HmdVector3_t vAngularVelocity;  // angular velocity in radians/s (?)
+	ETrackingResult eTrackingResult;
+	bool bPoseIsValid;
+
+	// This indicates that there is a device connected for this spot in the pose array.
+	// It could go from true to false if the user unplugs the device.
+	bool bDeviceIsConnected;
+};
+
+/** Identifies which style of tracking origin the application wants to use
+* for the poses it is requesting */
+enum ETrackingUniverseOrigin
+{
+	TrackingUniverseSeated = 0,              // Poses are provided relative to the seated zero pose
+	TrackingUniverseStanding = 1,            // Poses are provided relative to the safe bounds configured by the user
+	TrackingUniverseRawAndUncalibrated = 2,  // Poses are provided in the coordinate system defined by the driver.  It has Y up and is unified for devices of the same driver. You usually don't want this one.
+};
+
+// Refers to a single container of properties
+typedef uint64_t PropertyContainerHandle_t;
+typedef uint32_t PropertyTypeTag_t;
+
+static const PropertyContainerHandle_t k_ulInvalidPropertyContainer = 0;
+static const PropertyTypeTag_t k_unInvalidPropertyTag = 0;
+
+// Use these tags to set/get common types as struct properties
+static const PropertyTypeTag_t k_unFloatPropertyTag = 1;
+static const PropertyTypeTag_t k_unInt32PropertyTag = 2;
+static const PropertyTypeTag_t k_unUint64PropertyTag = 3;
+static const PropertyTypeTag_t k_unBoolPropertyTag = 4;
+static const PropertyTypeTag_t k_unStringPropertyTag = 5;
+
+static const PropertyTypeTag_t k_unHmdMatrix34PropertyTag = 20;
+static const PropertyTypeTag_t k_unHmdMatrix44PropertyTag = 21;
+static const PropertyTypeTag_t k_unHmdVector3PropertyTag = 22;
+static const PropertyTypeTag_t k_unHmdVector4PropertyTag = 23;
+
+static const PropertyTypeTag_t k_unHiddenAreaPropertyTag = 30;
+
+static const PropertyTypeTag_t k_unOpenVRInternalReserved_Start = 1000;
+static const PropertyTypeTag_t k_unOpenVRInternalReserved_End = 10000;
+
+/** Each entry in this enum represents a property that can be retrieved about a
+* tracked device. Many fields are only valid for one ETrackedDeviceClass. */
+enum ETrackedDeviceProperty
+{
+	Prop_Invalid = 0,
+
+	// general properties that apply to all device classes
+	Prop_TrackingSystemName_String = 1000,
+	Prop_ModelNumber_String = 1001,
+	Prop_SerialNumber_String = 1002,
+	Prop_RenderModelName_String = 1003,
+	Prop_WillDriftInYaw_Bool = 1004,
+	Prop_ManufacturerName_String = 1005,
+	Prop_TrackingFirmwareVersion_String = 1006,
+	Prop_HardwareRevision_String = 1007,
+	Prop_AllWirelessDongleDescriptions_String = 1008,
+	Prop_ConnectedWirelessDongle_String = 1009,
+	Prop_DeviceIsWireless_Bool = 1010,
+	Prop_DeviceIsCharging_Bool = 1011,
+	Prop_DeviceBatteryPercentage_Float = 1012,  // 0 is empty, 1 is full
+	Prop_StatusDisplayTransform_Matrix34 = 1013,
+	Prop_Firmware_UpdateAvailable_Bool = 1014,
+	Prop_Firmware_ManualUpdate_Bool = 1015,
+	Prop_Firmware_ManualUpdateURL_String = 1016,
+	Prop_HardwareRevision_Uint64 = 1017,
+	Prop_FirmwareVersion_Uint64 = 1018,
+	Prop_FPGAVersion_Uint64 = 1019,
+	Prop_VRCVersion_Uint64 = 1020,
+	Prop_RadioVersion_Uint64 = 1021,
+	Prop_DongleVersion_Uint64 = 1022,
+	Prop_BlockServerShutdown_Bool = 1023,
+	Prop_CanUnifyCoordinateSystemWithHmd_Bool = 1024,
+	Prop_ContainsProximitySensor_Bool = 1025,
+	Prop_DeviceProvidesBatteryStatus_Bool = 1026,
+	Prop_DeviceCanPowerOff_Bool = 1027,
+	Prop_Firmware_ProgrammingTarget_String = 1028,
+	Prop_DeviceClass_Int32 = 1029,
+	Prop_HasCamera_Bool = 1030,
+	Prop_DriverVersion_String = 1031,
+	Prop_Firmware_ForceUpdateRequired_Bool = 1032,
+	Prop_ViveSystemButtonFixRequired_Bool = 1033,
+	Prop_ParentDriver_Uint64 = 1034,
+	Prop_ResourceRoot_String = 1035,
+
+	// Properties that are unique to TrackedDeviceClass_HMD
+	Prop_ReportsTimeSinceVSync_Bool = 2000,
+	Prop_SecondsFromVsyncToPhotons_Float = 2001,
+	Prop_DisplayFrequency_Float = 2002,
+	Prop_UserIpdMeters_Float = 2003,
+	Prop_CurrentUniverseId_Uint64 = 2004,
+	Prop_PreviousUniverseId_Uint64 = 2005,
+	Prop_DisplayFirmwareVersion_Uint64 = 2006,
+	Prop_IsOnDesktop_Bool = 2007,
+	Prop_DisplayMCType_Int32 = 2008,
+	Prop_DisplayMCOffset_Float = 2009,
+	Prop_DisplayMCScale_Float = 2010,
+	Prop_EdidVendorID_Int32 = 2011,
+	Prop_DisplayMCImageLeft_String = 2012,
+	Prop_DisplayMCImageRight_String = 2013,
+	Prop_DisplayGCBlackClamp_Float = 2014,
+	Prop_EdidProductID_Int32 = 2015,
+	Prop_CameraToHeadTransform_Matrix34 = 2016,
+	Prop_DisplayGCType_Int32 = 2017,
+	Prop_DisplayGCOffset_Float = 2018,
+	Prop_DisplayGCScale_Float = 2019,
+	Prop_DisplayGCPrescale_Float = 2020,
+	Prop_DisplayGCImage_String = 2021,
+	Prop_LensCenterLeftU_Float = 2022,
+	Prop_LensCenterLeftV_Float = 2023,
+	Prop_LensCenterRightU_Float = 2024,
+	Prop_LensCenterRightV_Float = 2025,
+	Prop_UserHeadToEyeDepthMeters_Float = 2026,
+	Prop_CameraFirmwareVersion_Uint64 = 2027,
+	Prop_CameraFirmwareDescription_String = 2028,
+	Prop_DisplayFPGAVersion_Uint64 = 2029,
+	Prop_DisplayBootloaderVersion_Uint64 = 2030,
+	Prop_DisplayHardwareVersion_Uint64 = 2031,
+	Prop_AudioFirmwareVersion_Uint64 = 2032,
+	Prop_CameraCompatibilityMode_Int32 = 2033,
+	Prop_ScreenshotHorizontalFieldOfViewDegrees_Float = 2034,
+	Prop_ScreenshotVerticalFieldOfViewDegrees_Float = 2035,
+	Prop_DisplaySuppressed_Bool = 2036,
+	Prop_DisplayAllowNightMode_Bool = 2037,
+	Prop_DisplayMCImageWidth_Int32 = 2038,
+	Prop_DisplayMCImageHeight_Int32 = 2039,
+	Prop_DisplayMCImageNumChannels_Int32 = 2040,
+	Prop_DisplayMCImageData_Binary = 2041,
+	Prop_SecondsFromPhotonsToVblank_Float = 2042,
+	Prop_DriverDirectModeSendsVsyncEvents_Bool = 2043,
+	Prop_DisplayDebugMode_Bool = 2044,
+	Prop_GraphicsAdapterLuid_Uint64 = 2045,
+	Prop_DriverProvidedChaperonePath_String = 2048,
+
+	// Properties that are unique to TrackedDeviceClass_Controller
+	Prop_AttachedDeviceId_String = 3000,
+	Prop_SupportedButtons_Uint64 = 3001,
+	Prop_Axis0Type_Int32 = 3002,           // Return value is of type EVRControllerAxisType
+	Prop_Axis1Type_Int32 = 3003,           // Return value is of type EVRControllerAxisType
+	Prop_Axis2Type_Int32 = 3004,           // Return value is of type EVRControllerAxisType
+	Prop_Axis3Type_Int32 = 3005,           // Return value is of type EVRControllerAxisType
+	Prop_Axis4Type_Int32 = 3006,           // Return value is of type EVRControllerAxisType
+	Prop_ControllerRoleHint_Int32 = 3007,  // Return value is of type ETrackedControllerRole
+
+	// Properties that are unique to TrackedDeviceClass_TrackingReference
+	Prop_FieldOfViewLeftDegrees_Float = 4000,
+	Prop_FieldOfViewRightDegrees_Float = 4001,
+	Prop_FieldOfViewTopDegrees_Float = 4002,
+	Prop_FieldOfViewBottomDegrees_Float = 4003,
+	Prop_TrackingRangeMinimumMeters_Float = 4004,
+	Prop_TrackingRangeMaximumMeters_Float = 4005,
+	Prop_ModeLabel_String = 4006,
+
+	// Properties that are used for user interface like icons names
+	Prop_IconPathName_String = 5000,                       // DEPRECATED. Value not referenced. Now expected to be part of icon path properties.
+	Prop_NamedIconPathDeviceOff_String = 5001,             // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceSearching_String = 5002,       // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceSearchingAlert_String = 5003,  // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceReady_String = 5004,           // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceReadyAlert_String = 5005,      // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceNotReady_String = 5006,        // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceStandby_String = 5007,         // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceAlertLow_String = 5008,        // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+
+	// Properties that are used by helpers, but are opaque to applications
+	Prop_DisplayHiddenArea_Binary_Start = 5100,
+	Prop_DisplayHiddenArea_Binary_End = 5150,
+
+	// Properties that are unique to drivers
+	Prop_UserConfigPath_String = 6000,
+	Prop_InstallPath_String = 6001,
+	Prop_HasDisplayComponent_Bool = 6002,
+	Prop_HasControllerComponent_Bool = 6003,
+	Prop_HasCameraComponent_Bool = 6004,
+	Prop_HasDriverDirectModeComponent_Bool = 6005,
+	Prop_HasVirtualDisplayComponent_Bool = 6006,
+
+	// Vendors are free to expose private debug data in this reserved region
+	Prop_VendorSpecific_Reserved_Start = 10000,
+	Prop_VendorSpecific_Reserved_End = 10999,
+};
+
+/** No string property will ever be longer than this length */
+static const uint32_t k_unMaxPropertyStringSize = 32 * 1024;
+
+/** Used to return errors that occur when reading properties. */
+enum ETrackedPropertyError
+{
+	TrackedProp_Success = 0,
+	TrackedProp_WrongDataType = 1,
+	TrackedProp_WrongDeviceClass = 2,
+	TrackedProp_BufferTooSmall = 3,
+	TrackedProp_UnknownProperty = 4,  // Driver has not set the property (and may not ever).
+	TrackedProp_InvalidDevice = 5,
+	TrackedProp_CouldNotContactServer = 6,
+	TrackedProp_ValueNotProvidedByDevice = 7,
+	TrackedProp_StringExceedsMaximumLength = 8,
+	TrackedProp_NotYetAvailable = 9,  // The property value isn't known yet, but is expected soon. Call again later.
+	TrackedProp_PermissionDenied = 10,
+	TrackedProp_InvalidOperation = 11,
+};
+
+/** Allows the application to control what part of the provided texture will be used in the
+* frame buffer. */
+struct VRTextureBounds_t
+{
+	float uMin, vMin;
+	float uMax, vMax;
+};
+
+/** Allows specifying pose used to render provided scene texture (if different from value returned by WaitGetPoses). */
+struct VRTextureWithPose_t : public Texture_t
+{
+	HmdMatrix34_t mDeviceToAbsoluteTracking;  // Actual pose used to render scene textures.
+};
+
+/** Allows the application to control how scene textures are used by the compositor when calling Submit. */
+enum EVRSubmitFlags
+{
+	// Simple render path. App submits rendered left and right eye images with no lens distortion correction applied.
+	Submit_Default = 0x00,
+
+	// App submits final left and right eye images with lens distortion already applied (lens distortion makes the images appear
+	// barrel distorted with chromatic aberration correction applied). The app would have used the data returned by
+	// vr::IVRSystem::ComputeDistortion() to apply the correct distortion to the rendered images before calling Submit().
+	Submit_LensDistortionAlreadyApplied = 0x01,
+
+	// If the texture pointer passed in is actually a renderbuffer (e.g. for MSAA in OpenGL) then set this flag.
+	Submit_GlRenderBuffer = 0x02,
+
+	// Do not use
+	Submit_Reserved = 0x04,
+
+	// Set to indicate that pTexture is a pointer to a VRTextureWithPose_t.
+	Submit_TextureWithPose = 0x08,
+};
+
+/** Data required for passing Vulkan textures to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. */
+struct VRVulkanTextureData_t
+{
+	uint64_t m_nImage;  // VkImage
+	VkDevice_T *m_pDevice;
+	VkPhysicalDevice_T *m_pPhysicalDevice;
+	VkInstance_T *m_pInstance;
+	VkQueue_T *m_pQueue;
+	uint32_t m_nQueueFamilyIndex;
+	uint32_t m_nWidth, m_nHeight, m_nFormat, m_nSampleCount;
+};
+
+/** Data required for passing D3D12 textures to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. */
+struct D3D12TextureData_t
+{
+	ID3D12Resource *m_pResource;
+	ID3D12CommandQueue *m_pCommandQueue;
+	uint32_t m_nNodeMask;
+};
+
+/** Status of the overall system or tracked objects */
+enum EVRState
+{
+	VRState_Undefined = -1,
+	VRState_Off = 0,
+	VRState_Searching = 1,
+	VRState_Searching_Alert = 2,
+	VRState_Ready = 3,
+	VRState_Ready_Alert = 4,
+	VRState_NotReady = 5,
+	VRState_Standby = 6,
+	VRState_Ready_Alert_Low = 7,
+};
+
+/** The types of events that could be posted (and what the parameters mean for each event type) */
+enum EVREventType
+{
+	VREvent_None = 0,
+
+	VREvent_TrackedDeviceActivated = 100,
+	VREvent_TrackedDeviceDeactivated = 101,
+	VREvent_TrackedDeviceUpdated = 102,
+	VREvent_TrackedDeviceUserInteractionStarted = 103,
+	VREvent_TrackedDeviceUserInteractionEnded = 104,
+	VREvent_IpdChanged = 105,
+	VREvent_EnterStandbyMode = 106,
+	VREvent_LeaveStandbyMode = 107,
+	VREvent_TrackedDeviceRoleChanged = 108,
+	VREvent_WatchdogWakeUpRequested = 109,
+	VREvent_LensDistortionChanged = 110,
+	VREvent_PropertyChanged = 111,
+	VREvent_WirelessDisconnect = 112,
+	VREvent_WirelessReconnect = 113,
+
+	VREvent_ButtonPress = 200,    // data is controller
+	VREvent_ButtonUnpress = 201,  // data is controller
+	VREvent_ButtonTouch = 202,    // data is controller
+	VREvent_ButtonUntouch = 203,  // data is controller
+
+	VREvent_MouseMove = 300,            // data is mouse
+	VREvent_MouseButtonDown = 301,      // data is mouse
+	VREvent_MouseButtonUp = 302,        // data is mouse
+	VREvent_FocusEnter = 303,           // data is overlay
+	VREvent_FocusLeave = 304,           // data is overlay
+	VREvent_Scroll = 305,               // data is mouse
+	VREvent_TouchPadMove = 306,         // data is mouse
+	VREvent_OverlayFocusChanged = 307,  // data is overlay, global event
+
+	VREvent_InputFocusCaptured = 400,                         // data is process DEPRECATED
+	VREvent_InputFocusReleased = 401,                         // data is process DEPRECATED
+	VREvent_SceneFocusLost = 402,                             // data is process
+	VREvent_SceneFocusGained = 403,                           // data is process
+	VREvent_SceneApplicationChanged = 404,                    // data is process - The App actually drawing the scene changed (usually to or from the compositor)
+	VREvent_SceneFocusChanged = 405,                          // data is process - New app got access to draw the scene
+	VREvent_InputFocusChanged = 406,                          // data is process
+	VREvent_SceneApplicationSecondaryRenderingStarted = 407,  // data is process
+
+	VREvent_HideRenderModels = 410,  // Sent to the scene application to request hiding render models temporarily
+	VREvent_ShowRenderModels = 411,  // Sent to the scene application to request restoring render model visibility
+
+	VREvent_OverlayShown = 500,
+	VREvent_OverlayHidden = 501,
+	VREvent_DashboardActivated = 502,
+	VREvent_DashboardDeactivated = 503,
+	VREvent_DashboardThumbSelected = 504,     // Sent to the overlay manager - data is overlay
+	VREvent_DashboardRequested = 505,         // Sent to the overlay manager - data is overlay
+	VREvent_ResetDashboard = 506,             // Send to the overlay manager
+	VREvent_RenderToast = 507,                // Send to the dashboard to render a toast - data is the notification ID
+	VREvent_ImageLoaded = 508,                // Sent to overlays when a SetOverlayRaw or SetOverlayFromFile call finishes loading
+	VREvent_ShowKeyboard = 509,               // Sent to keyboard renderer in the dashboard to invoke it
+	VREvent_HideKeyboard = 510,               // Sent to keyboard renderer in the dashboard to hide it
+	VREvent_OverlayGamepadFocusGained = 511,  // Sent to an overlay when IVROverlay::SetFocusOverlay is called on it
+	VREvent_OverlayGamepadFocusLost = 512,    // Send to an overlay when it previously had focus and IVROverlay::SetFocusOverlay is called on something else
+	VREvent_OverlaySharedTextureChanged = 513,
+	VREvent_DashboardGuideButtonDown = 514,
+	VREvent_DashboardGuideButtonUp = 515,
+	VREvent_ScreenshotTriggered = 516,  // Screenshot button combo was pressed, Dashboard should request a screenshot
+	VREvent_ImageFailed = 517,          // Sent to overlays when a SetOverlayRaw or SetOverlayfromFail fails to load
+	VREvent_DashboardOverlayCreated = 518,
+
+	// Screenshot API
+	VREvent_RequestScreenshot = 520,              // Sent by vrclient application to compositor to take a screenshot
+	VREvent_ScreenshotTaken = 521,                // Sent by compositor to the application that the screenshot has been taken
+	VREvent_ScreenshotFailed = 522,               // Sent by compositor to the application that the screenshot failed to be taken
+	VREvent_SubmitScreenshotToDashboard = 523,    // Sent by compositor to the dashboard that a completed screenshot was submitted
+	VREvent_ScreenshotProgressToDashboard = 524,  // Sent by compositor to the dashboard that a completed screenshot was submitted
+
+	VREvent_PrimaryDashboardDeviceChanged = 525,
+
+	VREvent_Notification_Shown = 600,
+	VREvent_Notification_Hidden = 601,
+	VREvent_Notification_BeginInteraction = 602,
+	VREvent_Notification_Destroyed = 603,
+
+	VREvent_Quit = 700,                    // data is process
+	VREvent_ProcessQuit = 701,             // data is process
+	VREvent_QuitAborted_UserPrompt = 702,  // data is process
+	VREvent_QuitAcknowledged = 703,        // data is process
+	VREvent_DriverRequestedQuit = 704,     // The driver has requested that SteamVR shut down
+
+	VREvent_ChaperoneDataHasChanged = 800,
+	VREvent_ChaperoneUniverseHasChanged = 801,
+	VREvent_ChaperoneTempDataHasChanged = 802,
+	VREvent_ChaperoneSettingsHaveChanged = 803,
+	VREvent_SeatedZeroPoseReset = 804,
+
+	VREvent_AudioSettingsHaveChanged = 820,
+
+	VREvent_BackgroundSettingHasChanged = 850,
+	VREvent_CameraSettingsHaveChanged = 851,
+	VREvent_ReprojectionSettingHasChanged = 852,
+	VREvent_ModelSkinSettingsHaveChanged = 853,
+	VREvent_EnvironmentSettingsHaveChanged = 854,
+	VREvent_PowerSettingsHaveChanged = 855,
+	VREvent_EnableHomeAppSettingsHaveChanged = 856,
+
+	VREvent_StatusUpdate = 900,
+
+	VREvent_MCImageUpdated = 1000,
+
+	VREvent_FirmwareUpdateStarted = 1100,
+	VREvent_FirmwareUpdateFinished = 1101,
+
+	VREvent_KeyboardClosed = 1200,
+	VREvent_KeyboardCharInput = 1201,
+	VREvent_KeyboardDone = 1202,  // Sent when DONE button clicked on keyboard
+
+	VREvent_ApplicationTransitionStarted = 1300,
+	VREvent_ApplicationTransitionAborted = 1301,
+	VREvent_ApplicationTransitionNewAppStarted = 1302,
+	VREvent_ApplicationListUpdated = 1303,
+	VREvent_ApplicationMimeTypeLoad = 1304,
+	VREvent_ApplicationTransitionNewAppLaunchComplete = 1305,
+	VREvent_ProcessConnected = 1306,
+	VREvent_ProcessDisconnected = 1307,
+
+	VREvent_Compositor_MirrorWindowShown = 1400,
+	VREvent_Compositor_MirrorWindowHidden = 1401,
+	VREvent_Compositor_ChaperoneBoundsShown = 1410,
+	VREvent_Compositor_ChaperoneBoundsHidden = 1411,
+
+	VREvent_TrackedCamera_StartVideoStream = 1500,
+	VREvent_TrackedCamera_StopVideoStream = 1501,
+	VREvent_TrackedCamera_PauseVideoStream = 1502,
+	VREvent_TrackedCamera_ResumeVideoStream = 1503,
+	VREvent_TrackedCamera_EditingSurface = 1550,
+
+	VREvent_PerformanceTest_EnableCapture = 1600,
+	VREvent_PerformanceTest_DisableCapture = 1601,
+	VREvent_PerformanceTest_FidelityLevel = 1602,
+
+	VREvent_MessageOverlay_Closed = 1650,
+	VREvent_MessageOverlayCloseRequested = 1651,
+
+	// Vendors are free to expose private events in this reserved region
+	VREvent_VendorSpecific_Reserved_Start = 10000,
+	VREvent_VendorSpecific_Reserved_End = 19999,
+};
+
+/** Level of Hmd activity */
+// UserInteraction_Timeout means the device is in the process of timing out.
+// InUse = ( k_EDeviceActivityLevel_UserInteraction || k_EDeviceActivityLevel_UserInteraction_Timeout )
+// VREvent_TrackedDeviceUserInteractionStarted fires when the devices transitions from Standby -> UserInteraction or Idle -> UserInteraction.
+// VREvent_TrackedDeviceUserInteractionEnded fires when the devices transitions from UserInteraction_Timeout -> Idle
+enum EDeviceActivityLevel
+{
+	k_EDeviceActivityLevel_Unknown = -1,
+	k_EDeviceActivityLevel_Idle = 0,                     // No activity for the last 10 seconds
+	k_EDeviceActivityLevel_UserInteraction = 1,          // Activity (movement or prox sensor) is happening now
+	k_EDeviceActivityLevel_UserInteraction_Timeout = 2,  // No activity for the last 0.5 seconds
+	k_EDeviceActivityLevel_Standby = 3,                  // Idle for at least 5 seconds (configurable in Settings -> Power Management)
+};
+
+/** VR controller button and axis IDs */
+enum EVRButtonId
+{
+	k_EButton_System = 0,
+	k_EButton_ApplicationMenu = 1,
+	k_EButton_Grip = 2,
+	k_EButton_DPad_Left = 3,
+	k_EButton_DPad_Up = 4,
+	k_EButton_DPad_Right = 5,
+	k_EButton_DPad_Down = 6,
+	k_EButton_A = 7,
+
+	k_EButton_ProximitySensor = 31,
+
+	k_EButton_Axis0 = 32,
+	k_EButton_Axis1 = 33,
+	k_EButton_Axis2 = 34,
+	k_EButton_Axis3 = 35,
+	k_EButton_Axis4 = 36,
+
+	// aliases for well known controllers
+	k_EButton_SteamVR_Touchpad = k_EButton_Axis0,
+	k_EButton_SteamVR_Trigger = k_EButton_Axis1,
+
+	k_EButton_Dashboard_Back = k_EButton_Grip,
+
+	k_EButton_Max = 64
+};
+
+inline uint64_t ButtonMaskFromId(EVRButtonId id) { return 1ull << id; }
+
+/** used for controller button events */
+struct VREvent_Controller_t
+{
+	uint32_t button;  // EVRButtonId enum
+};
+
+/** used for simulated mouse events in overlay space */
+enum EVRMouseButton
+{
+	VRMouseButton_Left = 0x0001,
+	VRMouseButton_Right = 0x0002,
+	VRMouseButton_Middle = 0x0004,
+};
+
+/** used for simulated mouse events in overlay space */
+struct VREvent_Mouse_t
+{
+	float x, y;       // co-ords are in GL space, bottom left of the texture is 0,0
+	uint32_t button;  // EVRMouseButton enum
+};
+
+/** used for simulated mouse wheel scroll in overlay space */
+struct VREvent_Scroll_t
+{
+	float xdelta, ydelta;  // movement in fraction of the pad traversed since last delta, 1.0 for a full swipe
+	uint32_t repeatCount;
+};
+
+/** when in mouse input mode you can receive data from the touchpad, these events are only sent if the users finger
+   is on the touchpad (or just released from it) 
+**/
+struct VREvent_TouchPadMove_t
+{
+	// true if the users finger is detected on the touch pad
+	bool bFingerDown;
+
+	// How long the finger has been down in seconds
+	float flSecondsFingerDown;
+
+	// These values indicate the starting finger position (so you can do some basic swipe stuff)
+	float fValueXFirst;
+	float fValueYFirst;
+
+	// This is the raw sampled coordinate without deadzoning
+	float fValueXRaw;
+	float fValueYRaw;
+};
+
+/** notification related events. Details will still change at this point */
+struct VREvent_Notification_t
+{
+	uint64_t ulUserValue;
+	uint32_t notificationId;
+};
+
+/** Used for events about processes */
+struct VREvent_Process_t
+{
+	uint32_t pid;
+	uint32_t oldPid;
+	bool bForced;
+};
+
+/** Used for a few events about overlays */
+struct VREvent_Overlay_t
+{
+	uint64_t overlayHandle;
+};
+
+/** Used for a few events about overlays */
+struct VREvent_Status_t
+{
+	uint32_t statusState;  // EVRState enum
+};
+
+/** Used for keyboard events **/
+struct VREvent_Keyboard_t
+{
+	char cNewInput[8];    // Up to 11 bytes of new input
+	uint64_t uUserValue;  // Possible flags about the new input
+};
+
+struct VREvent_Ipd_t
+{
+	float ipdMeters;
+};
+
+struct VREvent_Chaperone_t
+{
+	uint64_t m_nPreviousUniverse;
+	uint64_t m_nCurrentUniverse;
+};
+
+/** Not actually used for any events */
+struct VREvent_Reserved_t
+{
+	uint64_t reserved0;
+	uint64_t reserved1;
+};
+
+struct VREvent_PerformanceTest_t
+{
+	uint32_t m_nFidelityLevel;
+};
+
+struct VREvent_SeatedZeroPoseReset_t
+{
+	bool bResetBySystemMenu;
+};
+
+struct VREvent_Screenshot_t
+{
+	uint32_t handle;
+	uint32_t type;
+};
+
+struct VREvent_ScreenshotProgress_t
+{
+	float progress;
+};
+
+struct VREvent_ApplicationLaunch_t
+{
+	uint32_t pid;
+	uint32_t unArgsHandle;
+};
+
+struct VREvent_EditingCameraSurface_t
+{
+	uint64_t overlayHandle;
+	uint32_t nVisualMode;
+};
+
+struct VREvent_MessageOverlay_t
+{
+	uint32_t unVRMessageOverlayResponse;  // vr::VRMessageOverlayResponse enum
+};
+
+struct VREvent_Property_t
+{
+	PropertyContainerHandle_t container;
+	ETrackedDeviceProperty prop;
+};
+
+/** NOTE!!! If you change this you MUST manually update openvr_interop.cs.py */
+typedef union {
+	VREvent_Reserved_t reserved;
+	VREvent_Controller_t controller;
+	VREvent_Mouse_t mouse;
+	VREvent_Scroll_t scroll;
+	VREvent_Process_t process;
+	VREvent_Notification_t notification;
+	VREvent_Overlay_t overlay;
+	VREvent_Status_t status;
+	VREvent_Keyboard_t keyboard;
+	VREvent_Ipd_t ipd;
+	VREvent_Chaperone_t chaperone;
+	VREvent_PerformanceTest_t performanceTest;
+	VREvent_TouchPadMove_t touchPadMove;
+	VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset;
+	VREvent_Screenshot_t screenshot;
+	VREvent_ScreenshotProgress_t screenshotProgress;
+	VREvent_ApplicationLaunch_t applicationLaunch;
+	VREvent_EditingCameraSurface_t cameraSurface;
+	VREvent_MessageOverlay_t messageOverlay;
+	VREvent_Property_t property;
+} VREvent_Data_t;
+
+#if defined(__linux__) || defined(__APPLE__)
+// This structure was originally defined mis-packed on Linux, preserved for
+// compatibility.
+#pragma pack(push, 4)
+#endif
+
+/** An event posted by the server to all running applications */
+struct VREvent_t
+{
+	uint32_t eventType;  // EVREventType enum
+	TrackedDeviceIndex_t trackedDeviceIndex;
+	float eventAgeSeconds;
+	// event data must be the end of the struct as its size is variable
+	VREvent_Data_t data;
+};
+
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+
+/** The mesh to draw into the stencil (or depth) buffer to perform 
+* early stencil (or depth) kills of pixels that will never appear on the HMD.
+* This mesh draws on all the pixels that will be hidden after distortion. 
+*
+* If the HMD does not provide a visible area mesh pVertexData will be
+* NULL and unTriangleCount will be 0. */
+struct HiddenAreaMesh_t
+{
+	const HmdVector2_t *pVertexData;
+	uint32_t unTriangleCount;
+};
+
+enum EHiddenAreaMeshType
+{
+	k_eHiddenAreaMesh_Standard = 0,
+	k_eHiddenAreaMesh_Inverse = 1,
+	k_eHiddenAreaMesh_LineLoop = 2,
+
+	k_eHiddenAreaMesh_Max = 3,
+};
+
+/** Identifies what kind of axis is on the controller at index n. Read this type 
+* with pVRSystem->Get( nControllerDeviceIndex, Prop_Axis0Type_Int32 + n );
+*/
+enum EVRControllerAxisType
+{
+	k_eControllerAxis_None = 0,
+	k_eControllerAxis_TrackPad = 1,
+	k_eControllerAxis_Joystick = 2,
+	k_eControllerAxis_Trigger = 3,  // Analog trigger data is in the X axis
+};
+
+/** contains information about one axis on the controller */
+struct VRControllerAxis_t
+{
+	float x;  // Ranges from -1.0 to 1.0 for joysticks and track pads. Ranges from 0.0 to 1.0 for triggers were 0 is fully released.
+	float y;  // Ranges from -1.0 to 1.0 for joysticks and track pads. Is always 0.0 for triggers.
+};
+
+/** the number of axes in the controller state */
+static const uint32_t k_unControllerStateAxisCount = 5;
+
+#if defined(__linux__) || defined(__APPLE__)
+// This structure was originally defined mis-packed on Linux, preserved for
+// compatibility.
+#pragma pack(push, 4)
+#endif
+
+/** Holds all the state of a controller at one moment in time. */
+struct VRControllerState001_t
+{
+	// If packet num matches that on your prior call, then the controller state hasn't been changed since
+	// your last call and there is no need to process it
+	uint32_t unPacketNum;
+
+	// bit flags for each of the buttons. Use ButtonMaskFromId to turn an ID into a mask
+	uint64_t ulButtonPressed;
+	uint64_t ulButtonTouched;
+
+	// Axis data for the controller's analog inputs
+	VRControllerAxis_t rAxis[k_unControllerStateAxisCount];
+};
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+
+typedef VRControllerState001_t VRControllerState_t;
+
+/** determines how to provide output to the application of various event processing functions. */
+enum EVRControllerEventOutputType
+{
+	ControllerEventOutput_OSEvents = 0,
+	ControllerEventOutput_VREvents = 1,
+};
+
+/** Collision Bounds Style */
+enum ECollisionBoundsStyle
+{
+	COLLISION_BOUNDS_STYLE_BEGINNER = 0,
+	COLLISION_BOUNDS_STYLE_INTERMEDIATE,
+	COLLISION_BOUNDS_STYLE_SQUARES,
+	COLLISION_BOUNDS_STYLE_ADVANCED,
+	COLLISION_BOUNDS_STYLE_NONE,
+
+	COLLISION_BOUNDS_STYLE_COUNT
+};
+
+/** Allows the application to customize how the overlay appears in the compositor */
+struct Compositor_OverlaySettings
+{
+	uint32_t size;  // sizeof(Compositor_OverlaySettings)
+	bool curved, antialias;
+	float scale, distance, alpha;
+	float uOffset, vOffset, uScale, vScale;
+	float gridDivs, gridWidth, gridScale;
+	HmdMatrix44_t transform;
+};
+
+/** used to refer to a single VR overlay */
+typedef uint64_t VROverlayHandle_t;
+
+static const VROverlayHandle_t k_ulOverlayHandleInvalid = 0;
+
+/** Errors that can occur around VR overlays */
+enum EVROverlayError
+{
+	VROverlayError_None = 0,
+
+	VROverlayError_UnknownOverlay = 10,
+	VROverlayError_InvalidHandle = 11,
+	VROverlayError_PermissionDenied = 12,
+	VROverlayError_OverlayLimitExceeded = 13,  // No more overlays could be created because the maximum number already exist
+	VROverlayError_WrongVisibilityType = 14,
+	VROverlayError_KeyTooLong = 15,
+	VROverlayError_NameTooLong = 16,
+	VROverlayError_KeyInUse = 17,
+	VROverlayError_WrongTransformType = 18,
+	VROverlayError_InvalidTrackedDevice = 19,
+	VROverlayError_InvalidParameter = 20,
+	VROverlayError_ThumbnailCantBeDestroyed = 21,
+	VROverlayError_ArrayTooSmall = 22,
+	VROverlayError_RequestFailed = 23,
+	VROverlayError_InvalidTexture = 24,
+	VROverlayError_UnableToLoadFile = 25,
+	VROverlayError_KeyboardAlreadyInUse = 26,
+	VROverlayError_NoNeighbor = 27,
+	VROverlayError_TooManyMaskPrimitives = 29,
+	VROverlayError_BadMaskPrimitive = 30,
+};
+
+/** enum values to pass in to VR_Init to identify whether the application will 
+* draw a 3D scene. */
+enum EVRApplicationType
+{
+	VRApplication_Other = 0,          // Some other kind of application that isn't covered by the other entries
+	VRApplication_Scene = 1,          // Application will submit 3D frames
+	VRApplication_Overlay = 2,        // Application only interacts with overlays
+	VRApplication_Background = 3,     // Application should not start SteamVR if it's not already running, and should not
+									  // keep it running if everything else quits.
+	VRApplication_Utility = 4,        // Init should not try to load any drivers. The application needs access to utility
+									  // interfaces (like IVRSettings and IVRApplications) but not hardware.
+	VRApplication_VRMonitor = 5,      // Reserved for vrmonitor
+	VRApplication_SteamWatchdog = 6,  // Reserved for Steam
+	VRApplication_Bootstrapper = 7,   // Start up SteamVR
+
+	VRApplication_Max
+};
+
+/** error codes for firmware */
+enum EVRFirmwareError
+{
+	VRFirmwareError_None = 0,
+	VRFirmwareError_Success = 1,
+	VRFirmwareError_Fail = 2,
+};
+
+/** error codes for notifications */
+enum EVRNotificationError
+{
+	VRNotificationError_OK = 0,
+	VRNotificationError_InvalidNotificationId = 100,
+	VRNotificationError_NotificationQueueFull = 101,
+	VRNotificationError_InvalidOverlayHandle = 102,
+	VRNotificationError_SystemWithUserValueAlreadyExists = 103,
+};
+
+/** error codes returned by Vr_Init */
+
+// Please add adequate error description to https://developer.valvesoftware.com/w/index.php?title=Category:SteamVRHelp
+enum EVRInitError
+{
+	VRInitError_None = 0,
+	VRInitError_Unknown = 1,
+
+	VRInitError_Init_InstallationNotFound = 100,
+	VRInitError_Init_InstallationCorrupt = 101,
+	VRInitError_Init_VRClientDLLNotFound = 102,
+	VRInitError_Init_FileNotFound = 103,
+	VRInitError_Init_FactoryNotFound = 104,
+	VRInitError_Init_InterfaceNotFound = 105,
+	VRInitError_Init_InvalidInterface = 106,
+	VRInitError_Init_UserConfigDirectoryInvalid = 107,
+	VRInitError_Init_HmdNotFound = 108,
+	VRInitError_Init_NotInitialized = 109,
+	VRInitError_Init_PathRegistryNotFound = 110,
+	VRInitError_Init_NoConfigPath = 111,
+	VRInitError_Init_NoLogPath = 112,
+	VRInitError_Init_PathRegistryNotWritable = 113,
+	VRInitError_Init_AppInfoInitFailed = 114,
+	VRInitError_Init_Retry = 115,               // Used internally to cause retries to vrserver
+	VRInitError_Init_InitCanceledByUser = 116,  // The calling application should silently exit. The user canceled app startup
+	VRInitError_Init_AnotherAppLaunching = 117,
+	VRInitError_Init_SettingsInitFailed = 118,
+	VRInitError_Init_ShuttingDown = 119,
+	VRInitError_Init_TooManyObjects = 120,
+	VRInitError_Init_NoServerForBackgroundApp = 121,
+	VRInitError_Init_NotSupportedWithCompositor = 122,
+	VRInitError_Init_NotAvailableToUtilityApps = 123,
+	VRInitError_Init_Internal = 124,
+	VRInitError_Init_HmdDriverIdIsNone = 125,
+	VRInitError_Init_HmdNotFoundPresenceFailed = 126,
+	VRInitError_Init_VRMonitorNotFound = 127,
+	VRInitError_Init_VRMonitorStartupFailed = 128,
+	VRInitError_Init_LowPowerWatchdogNotSupported = 129,
+	VRInitError_Init_InvalidApplicationType = 130,
+	VRInitError_Init_NotAvailableToWatchdogApps = 131,
+	VRInitError_Init_WatchdogDisabledInSettings = 132,
+	VRInitError_Init_VRDashboardNotFound = 133,
+	VRInitError_Init_VRDashboardStartupFailed = 134,
+	VRInitError_Init_VRHomeNotFound = 135,
+	VRInitError_Init_VRHomeStartupFailed = 136,
+	VRInitError_Init_RebootingBusy = 137,
+	VRInitError_Init_FirmwareUpdateBusy = 138,
+	VRInitError_Init_FirmwareRecoveryBusy = 139,
+
+	VRInitError_Driver_Failed = 200,
+	VRInitError_Driver_Unknown = 201,
+	VRInitError_Driver_HmdUnknown = 202,
+	VRInitError_Driver_NotLoaded = 203,
+	VRInitError_Driver_RuntimeOutOfDate = 204,
+	VRInitError_Driver_HmdInUse = 205,
+	VRInitError_Driver_NotCalibrated = 206,
+	VRInitError_Driver_CalibrationInvalid = 207,
+	VRInitError_Driver_HmdDisplayNotFound = 208,
+	VRInitError_Driver_TrackedDeviceInterfaceUnknown = 209,
+	// VRInitError_Driver_HmdDisplayNotFoundAfterFix = 210, // not needed: here for historic reasons
+	VRInitError_Driver_HmdDriverIdOutOfBounds = 211,
+	VRInitError_Driver_HmdDisplayMirrored = 212,
+
+	VRInitError_IPC_ServerInitFailed = 300,
+	VRInitError_IPC_ConnectFailed = 301,
+	VRInitError_IPC_SharedStateInitFailed = 302,
+	VRInitError_IPC_CompositorInitFailed = 303,
+	VRInitError_IPC_MutexInitFailed = 304,
+	VRInitError_IPC_Failed = 305,
+	VRInitError_IPC_CompositorConnectFailed = 306,
+	VRInitError_IPC_CompositorInvalidConnectResponse = 307,
+	VRInitError_IPC_ConnectFailedAfterMultipleAttempts = 308,
+
+	VRInitError_Compositor_Failed = 400,
+	VRInitError_Compositor_D3D11HardwareRequired = 401,
+	VRInitError_Compositor_FirmwareRequiresUpdate = 402,
+	VRInitError_Compositor_OverlayInitFailed = 403,
+	VRInitError_Compositor_ScreenshotsInitFailed = 404,
+	VRInitError_Compositor_UnableToCreateDevice = 405,
+
+	VRInitError_VendorSpecific_UnableToConnectToOculusRuntime = 1000,
+
+	VRInitError_VendorSpecific_HmdFound_CantOpenDevice = 1101,
+	VRInitError_VendorSpecific_HmdFound_UnableToRequestConfigStart = 1102,
+	VRInitError_VendorSpecific_HmdFound_NoStoredConfig = 1103,
+	VRInitError_VendorSpecific_HmdFound_ConfigTooBig = 1104,
+	VRInitError_VendorSpecific_HmdFound_ConfigTooSmall = 1105,
+	VRInitError_VendorSpecific_HmdFound_UnableToInitZLib = 1106,
+	VRInitError_VendorSpecific_HmdFound_CantReadFirmwareVersion = 1107,
+	VRInitError_VendorSpecific_HmdFound_UnableToSendUserDataStart = 1108,
+	VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataStart = 1109,
+	VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataNext = 1110,
+	VRInitError_VendorSpecific_HmdFound_UserDataAddressRange = 1111,
+	VRInitError_VendorSpecific_HmdFound_UserDataError = 1112,
+	VRInitError_VendorSpecific_HmdFound_ConfigFailedSanityCheck = 1113,
+
+	VRInitError_Steam_SteamInstallationNotFound = 2000,
+};
+
+enum EVRScreenshotType
+{
+	VRScreenshotType_None = 0,
+	VRScreenshotType_Mono = 1,  // left eye only
+	VRScreenshotType_Stereo = 2,
+	VRScreenshotType_Cubemap = 3,
+	VRScreenshotType_MonoPanorama = 4,
+	VRScreenshotType_StereoPanorama = 5
+};
+
+enum EVRScreenshotPropertyFilenames
+{
+	VRScreenshotPropertyFilenames_Preview = 0,
+	VRScreenshotPropertyFilenames_VR = 1,
+};
+
+enum EVRTrackedCameraError
+{
+	VRTrackedCameraError_None = 0,
+	VRTrackedCameraError_OperationFailed = 100,
+	VRTrackedCameraError_InvalidHandle = 101,
+	VRTrackedCameraError_InvalidFrameHeaderVersion = 102,
+	VRTrackedCameraError_OutOfHandles = 103,
+	VRTrackedCameraError_IPCFailure = 104,
+	VRTrackedCameraError_NotSupportedForThisDevice = 105,
+	VRTrackedCameraError_SharedMemoryFailure = 106,
+	VRTrackedCameraError_FrameBufferingFailure = 107,
+	VRTrackedCameraError_StreamSetupFailure = 108,
+	VRTrackedCameraError_InvalidGLTextureId = 109,
+	VRTrackedCameraError_InvalidSharedTextureHandle = 110,
+	VRTrackedCameraError_FailedToGetGLTextureId = 111,
+	VRTrackedCameraError_SharedTextureFailure = 112,
+	VRTrackedCameraError_NoFrameAvailable = 113,
+	VRTrackedCameraError_InvalidArgument = 114,
+	VRTrackedCameraError_InvalidFrameBufferSize = 115,
+};
+
+enum EVRTrackedCameraFrameType
+{
+	VRTrackedCameraFrameType_Distorted = 0,       // This is the camera video frame size in pixels, still distorted.
+	VRTrackedCameraFrameType_Undistorted,         // In pixels, an undistorted inscribed rectangle region without invalid regions. This size is subject to changes shortly.
+	VRTrackedCameraFrameType_MaximumUndistorted,  // In pixels, maximum undistorted with invalid regions. Non zero alpha component identifies valid regions.
+	MAX_CAMERA_FRAME_TYPES
+};
+
+typedef uint64_t TrackedCameraHandle_t;
+#define INVALID_TRACKED_CAMERA_HANDLE ((vr::TrackedCameraHandle_t)0)
+
+struct CameraVideoStreamFrameHeader_t
+{
+	EVRTrackedCameraFrameType eFrameType;
+
+	uint32_t nWidth;
+	uint32_t nHeight;
+	uint32_t nBytesPerPixel;
+
+	uint32_t nFrameSequence;
+
+	TrackedDevicePose_t standingTrackedDevicePose;
+};
+
+// Screenshot types
+typedef uint32_t ScreenshotHandle_t;
+
+static const uint32_t k_unScreenshotHandleInvalid = 0;
+
+#pragma pack(pop)
+
+// figure out how to import from the VR API dll
+#if defined(_WIN32)
+
+#ifdef VR_API_EXPORT
+#define VR_INTERFACE extern "C" __declspec(dllexport)
+#else
+#define VR_INTERFACE extern "C" __declspec(dllimport)
+#endif
+
+#elif defined(__GNUC__) || defined(COMPILER_GCC) || defined(__APPLE__)
+
+#ifdef VR_API_EXPORT
+#define VR_INTERFACE extern "C" __attribute__((visibility("default")))
+#else
+#define VR_INTERFACE extern "C"
+#endif
+
+#else
+#error "Unsupported Platform."
+#endif
+
+#if defined(_WIN32)
+#define VR_CALLTYPE __cdecl
+#else
+#define VR_CALLTYPE
+#endif
+
+}  // namespace vr
+
+#endif  // _INCLUDE_VRTYPES_H
+
+// vrannotation.h
+#ifdef API_GEN
+#define VR_CLANG_ATTR(ATTR) __attribute__((annotate(ATTR)))
+#else
+#define VR_CLANG_ATTR(ATTR)
+#endif
+
+#define VR_METHOD_DESC(DESC) VR_CLANG_ATTR("desc:" #DESC ";")
+#define VR_IGNOREATTR() VR_CLANG_ATTR("ignore")
+#define VR_OUT_STRUCT() VR_CLANG_ATTR("out_struct: ;")
+#define VR_OUT_STRING() VR_CLANG_ATTR("out_string: ;")
+#define VR_OUT_ARRAY_CALL(COUNTER, FUNCTION, PARAMS) VR_CLANG_ATTR("out_array_call:" #COUNTER "," #FUNCTION "," #PARAMS ";")
+#define VR_OUT_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR("out_array_count:" #COUNTER ";")
+#define VR_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR("array_count:" #COUNTER ";")
+#define VR_ARRAY_COUNT_D(COUNTER, DESC) VR_CLANG_ATTR("array_count:" #COUNTER ";desc:" #DESC)
+#define VR_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR("buffer_count:" #COUNTER ";")
+#define VR_OUT_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR("out_buffer_count:" #COUNTER ";")
+#define VR_OUT_STRING_COUNT(COUNTER) VR_CLANG_ATTR("out_string_count:" #COUNTER ";")
+
+// ivrsystem.h
+namespace vr
+{
+class IVRSystem
+{
+public:
+	// ------------------------------------
+	// Display Methods
+	// ------------------------------------
+
+	/** Suggested size for the intermediate render target that the distortion pulls from. */
+	virtual void GetRecommendedRenderTargetSize(uint32_t *pnWidth, uint32_t *pnHeight) = 0;
+
+	/** The projection matrix for the specified eye */
+	virtual HmdMatrix44_t GetProjectionMatrix(EVREye eEye, float fNearZ, float fFarZ) = 0;
+
+	/** The components necessary to build your own projection matrix in case your
+	* application is doing something fancy like infinite Z */
+	virtual void GetProjectionRaw(EVREye eEye, float *pfLeft, float *pfRight, float *pfTop, float *pfBottom) = 0;
+
+	/** Gets the result of the distortion function for the specified eye and input UVs. UVs go from 0,0 in 
+	* the upper left of that eye's viewport and 1,1 in the lower right of that eye's viewport.
+	* Returns true for success. Otherwise, returns false, and distortion coordinates are not suitable. */
+	virtual bool ComputeDistortion(EVREye eEye, float fU, float fV, DistortionCoordinates_t *pDistortionCoordinates) = 0;
+
+	/** Returns the transform from eye space to the head space. Eye space is the per-eye flavor of head
+	* space that provides stereo disparity. Instead of Model * View * Projection the sequence is Model * View * Eye^-1 * Projection. 
+	* Normally View and Eye^-1 will be multiplied together and treated as View in your application. 
+	*/
+	virtual HmdMatrix34_t GetEyeToHeadTransform(EVREye eEye) = 0;
+
+	/** Returns the number of elapsed seconds since the last recorded vsync event. This 
+	*	will come from a vsync timer event in the timer if possible or from the application-reported
+	*   time if that is not available. If no vsync times are available the function will 
+	*   return zero for vsync time and frame counter and return false from the method. */
+	virtual bool GetTimeSinceLastVsync(float *pfSecondsSinceLastVsync, uint64_t *pulFrameCounter) = 0;
+
+	/** [D3D9 Only]
+	* Returns the adapter index that the user should pass into CreateDevice to set up D3D9 in such
+	* a way that it can go full screen exclusive on the HMD. Returns -1 if there was an error.
+	*/
+	virtual int32_t GetD3D9AdapterIndex() = 0;
+
+	/** [D3D10/11 Only]
+	* Returns the adapter index that the user should pass into EnumAdapters to create the device 
+	* and swap chain in DX10 and DX11. If an error occurs the index will be set to -1.
+	*/
+	virtual void GetDXGIOutputInfo(int32_t *pnAdapterIndex) = 0;
+
+	/**
+	 * Returns platform- and texture-type specific adapter identification so that applications and the
+	 * compositor are creating textures and swap chains on the same GPU. If an error occurs the device
+	 * will be set to 0.
+	 * pInstance is an optional parameter that is required only when textureType is TextureType_Vulkan.
+	 * [D3D10/11/12 Only (D3D9 Not Supported)]
+	 *  Returns the adapter LUID that identifies the GPU attached to the HMD. The user should
+	 *  enumerate all adapters using IDXGIFactory::EnumAdapters and IDXGIAdapter::GetDesc to find
+	 *  the adapter with the matching LUID, or use IDXGIFactory4::EnumAdapterByLuid.
+	 *  The discovered IDXGIAdapter should be used to create the device and swap chain.
+	 * [Vulkan Only]
+	 *  Returns the VkPhysicalDevice that should be used by the application.
+	 *  pInstance must be the instance the application will use to query for the VkPhysicalDevice.  The application
+	 *  must create the VkInstance with extensions returned by IVRCompositor::GetVulkanInstanceExtensionsRequired enabled.
+	 * [macOS Only]
+	 *  Returns an id<MTLDevice> that should be used by the application.
+	 */
+	virtual void GetOutputDevice(uint64_t *pnDevice, ETextureType textureType, VkInstance_T *pInstance = nullptr) = 0;
+
+	// ------------------------------------
+	// Display Mode methods
+	// ------------------------------------
+
+	/** Use to determine if the headset display is part of the desktop (i.e. extended) or hidden (i.e. direct mode). */
+	virtual bool IsDisplayOnDesktop() = 0;
+
+	/** Set the display visibility (true = extended, false = direct mode).  Return value of true indicates that the change was successful. */
+	virtual bool SetDisplayVisibility(bool bIsVisibleOnDesktop) = 0;
+
+	// ------------------------------------
+	// Tracking Methods
+	// ------------------------------------
+
+	/** The pose that the tracker thinks that the HMD will be in at the specified number of seconds into the 
+	* future. Pass 0 to get the state at the instant the method is called. Most of the time the application should
+	* calculate the time until the photons will be emitted from the display and pass that time into the method.
+	*
+	* This is roughly analogous to the inverse of the view matrix in most applications, though 
+	* many games will need to do some additional rotation or translation on top of the rotation
+	* and translation provided by the head pose.
+	*
+	* For devices where bPoseIsValid is true the application can use the pose to position the device
+	* in question. The provided array can be any size up to k_unMaxTrackedDeviceCount. 
+	*
+	* Seated experiences should call this method with TrackingUniverseSeated and receive poses relative
+	* to the seated zero pose. Standing experiences should call this method with TrackingUniverseStanding 
+	* and receive poses relative to the Chaperone Play Area. TrackingUniverseRawAndUncalibrated should 
+	* probably not be used unless the application is the Chaperone calibration tool itself, but will provide
+	* poses relative to the hardware-specific coordinate system in the driver.
+	*/
+	virtual void GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, VR_ARRAY_COUNT(unTrackedDevicePoseArrayCount) TrackedDevicePose_t *pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = 0;
+
+	/** Sets the zero pose for the seated tracker coordinate system to the current position and yaw of the HMD. After 
+	* ResetSeatedZeroPose all GetDeviceToAbsoluteTrackingPose calls that pass TrackingUniverseSeated as the origin 
+	* will be relative to this new zero pose. The new zero coordinate system will not change the fact that the Y axis 
+	* is up in the real world, so the next pose returned from GetDeviceToAbsoluteTrackingPose after a call to 
+	* ResetSeatedZeroPose may not be exactly an identity matrix.
+	*
+	* NOTE: This function overrides the user's previously saved seated zero pose and should only be called as the result of a user action. 
+	* Users are also able to set their seated zero pose via the OpenVR Dashboard.
+	**/
+	virtual void ResetSeatedZeroPose() = 0;
+
+	/** Returns the transform from the seated zero pose to the standing absolute tracking system. This allows 
+	* applications to represent the seated origin to used or transform object positions from one coordinate
+	* system to the other. 
+	*
+	* The seated origin may or may not be inside the Play Area or Collision Bounds returned by IVRChaperone. Its position 
+	* depends on what the user has set from the Dashboard settings and previous calls to ResetSeatedZeroPose. */
+	virtual HmdMatrix34_t GetSeatedZeroPoseToStandingAbsoluteTrackingPose() = 0;
+
+	/** Returns the transform from the tracking origin to the standing absolute tracking system. This allows
+	* applications to convert from raw tracking space to the calibrated standing coordinate system. */
+	virtual HmdMatrix34_t GetRawZeroPoseToStandingAbsoluteTrackingPose() = 0;
+
+	/** Get a sorted array of device indices of a given class of tracked devices (e.g. controllers).  Devices are sorted right to left
+	* relative to the specified tracked device (default: hmd -- pass in -1 for absolute tracking space).  Returns the number of devices
+	* in the list, or the size of the array needed if not large enough. */
+	virtual uint32_t GetSortedTrackedDeviceIndicesOfClass(ETrackedDeviceClass eTrackedDeviceClass, VR_ARRAY_COUNT(unTrackedDeviceIndexArrayCount) vr::TrackedDeviceIndex_t *punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, vr::TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex = k_unTrackedDeviceIndex_Hmd) = 0;
+
+	/** Returns the level of activity on the device. */
+	virtual EDeviceActivityLevel GetTrackedDeviceActivityLevel(vr::TrackedDeviceIndex_t unDeviceId) = 0;
+
+	/** Convenience utility to apply the specified transform to the specified pose.
+	*   This properly transforms all pose components, including velocity and angular velocity
+	*/
+	virtual void ApplyTransform(TrackedDevicePose_t *pOutputPose, const TrackedDevicePose_t *pTrackedDevicePose, const HmdMatrix34_t *pTransform) = 0;
+
+	/** Returns the device index associated with a specific role, for example the left hand or the right hand. */
+	virtual vr::TrackedDeviceIndex_t GetTrackedDeviceIndexForControllerRole(vr::ETrackedControllerRole unDeviceType) = 0;
+
+	/** Returns the controller type associated with a device index. */
+	virtual vr::ETrackedControllerRole GetControllerRoleForTrackedDeviceIndex(vr::TrackedDeviceIndex_t unDeviceIndex) = 0;
+
+	// ------------------------------------
+	// Property methods
+	// ------------------------------------
+
+	/** Returns the device class of a tracked device. If there has not been a device connected in this slot
+	* since the application started this function will return TrackedDevice_Invalid. For previous detected
+	* devices the function will return the previously observed device class. 
+	*
+	* To determine which devices exist on the system, just loop from 0 to k_unMaxTrackedDeviceCount and check
+	* the device class. Every device with something other than TrackedDevice_Invalid is associated with an 
+	* actual tracked device. */
+	virtual ETrackedDeviceClass GetTrackedDeviceClass(vr::TrackedDeviceIndex_t unDeviceIndex) = 0;
+
+	/** Returns true if there is a device connected in this slot. */
+	virtual bool IsTrackedDeviceConnected(vr::TrackedDeviceIndex_t unDeviceIndex) = 0;
+
+	/** Returns a bool property. If the device index is not valid or the property is not a bool type this function will return false. */
+	virtual bool GetBoolTrackedDeviceProperty(vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L) = 0;
+
+	/** Returns a float property. If the device index is not valid or the property is not a float type this function will return 0. */
+	virtual float GetFloatTrackedDeviceProperty(vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L) = 0;
+
+	/** Returns an int property. If the device index is not valid or the property is not a int type this function will return 0. */
+	virtual int32_t GetInt32TrackedDeviceProperty(vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L) = 0;
+
+	/** Returns a uint64 property. If the device index is not valid or the property is not a uint64 type this function will return 0. */
+	virtual uint64_t GetUint64TrackedDeviceProperty(vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L) = 0;
+
+	/** Returns a matrix property. If the device index is not valid or the property is not a matrix type, this function will return identity. */
+	virtual HmdMatrix34_t GetMatrix34TrackedDeviceProperty(vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L) = 0;
+
+	/** Returns a string property. If the device index is not valid or the property is not a string type this function will 
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters. */
+	virtual uint32_t GetStringTrackedDeviceProperty(vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError = 0L) = 0;
+
+	/** returns a string that corresponds with the specified property error. The string will be the name 
+	* of the error enum value for all valid error codes */
+	virtual const char *GetPropErrorNameFromEnum(ETrackedPropertyError error) = 0;
+
+	// ------------------------------------
+	// Event methods
+	// ------------------------------------
+
+	/** Returns true and fills the event with the next event on the queue if there is one. If there are no events
+	* this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct */
+	virtual bool PollNextEvent(VREvent_t *pEvent, uint32_t uncbVREvent) = 0;
+
+	/** Returns true and fills the event with the next event on the queue if there is one. If there are no events
+	* this method returns false. Fills in the pose of the associated tracked device in the provided pose struct. 
+	* This pose will always be older than the call to this function and should not be used to render the device. 
+	uncbVREvent should be the size in bytes of the VREvent_t struct */
+	virtual bool PollNextEventWithPose(ETrackingUniverseOrigin eOrigin, VREvent_t *pEvent, uint32_t uncbVREvent, vr::TrackedDevicePose_t *pTrackedDevicePose) = 0;
+
+	/** returns the name of an EVREvent enum value */
+	virtual const char *GetEventTypeNameFromEnum(EVREventType eType) = 0;
+
+	// ------------------------------------
+	// Rendering helper methods
+	// ------------------------------------
+
+	/** Returns the hidden area mesh for the current HMD. The pixels covered by this mesh will never be seen by the user after the lens distortion is
+	* applied based on visibility to the panels. If this HMD does not have a hidden area mesh, the vertex data and count will be NULL and 0 respectively.
+	* This mesh is meant to be rendered into the stencil buffer (or into the depth buffer setting nearz) before rendering each eye's view. 
+	* This will improve performance by letting the GPU early-reject pixels the user will never see before running the pixel shader.
+	* NOTE: Render this mesh with backface culling disabled since the winding order of the vertices can be different per-HMD or per-eye.
+	* Setting the bInverse argument to true will produce the visible area mesh that is commonly used in place of full-screen quads. The visible area mesh covers all of the pixels the hidden area mesh does not cover.
+	* Setting the bLineLoop argument will return a line loop of vertices in HiddenAreaMesh_t->pVertexData with HiddenAreaMesh_t->unTriangleCount set to the number of vertices.
+	*/
+	virtual HiddenAreaMesh_t GetHiddenAreaMesh(EVREye eEye, EHiddenAreaMeshType type = k_eHiddenAreaMesh_Standard) = 0;
+
+	// ------------------------------------
+	// Controller methods
+	// ------------------------------------
+
+	/** Fills the supplied struct with the current state of the controller. Returns false if the controller index
+	* is invalid. */
+	virtual bool GetControllerState(vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize) = 0;
+
+	/** fills the supplied struct with the current state of the controller and the provided pose with the pose of 
+	* the controller when the controller state was updated most recently. Use this form if you need a precise controller
+	* pose as input to your application when the user presses or releases a button. */
+	virtual bool GetControllerStateWithPose(ETrackingUniverseOrigin eOrigin, vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose) = 0;
+
+	/** Trigger a single haptic pulse on a controller. After this call the application may not trigger another haptic pulse on this controller
+	* and axis combination for 5ms. */
+	virtual void TriggerHapticPulse(vr::TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = 0;
+
+	/** returns the name of an EVRButtonId enum value */
+	virtual const char *GetButtonIdNameFromEnum(EVRButtonId eButtonId) = 0;
+
+	/** returns the name of an EVRControllerAxisType enum value */
+	virtual const char *GetControllerAxisTypeNameFromEnum(EVRControllerAxisType eAxisType) = 0;
+
+	/** Tells OpenVR that this process wants exclusive access to controller button states and button events. Other apps will be notified that 
+	* they have lost input focus with a VREvent_InputFocusCaptured event. Returns false if input focus could not be captured for
+	* some reason. */
+	virtual bool CaptureInputFocus() = 0;
+
+	/** Tells OpenVR that this process no longer wants exclusive access to button states and button events. Other apps will be notified 
+	* that input focus has been released with a VREvent_InputFocusReleased event. */
+	virtual void ReleaseInputFocus() = 0;
+
+	/** Returns true if input focus is captured by another process. */
+	virtual bool IsInputFocusCapturedByAnotherProcess() = 0;
+
+	// ------------------------------------
+	// Debug Methods
+	// ------------------------------------
+
+	/** Sends a request to the driver for the specified device and returns the response. The maximum response size is 32k,
+	* but this method can be called with a smaller buffer. If the response exceeds the size of the buffer, it is truncated. 
+	* The size of the response including its terminating null is returned. */
+	virtual uint32_t DriverDebugRequest(vr::TrackedDeviceIndex_t unDeviceIndex, const char *pchRequest, char *pchResponseBuffer, uint32_t unResponseBufferSize) = 0;
+
+	// ------------------------------------
+	// Firmware methods
+	// ------------------------------------
+
+	/** Performs the actual firmware update if applicable. 
+	 * The following events will be sent, if VRFirmwareError_None was returned: VREvent_FirmwareUpdateStarted, VREvent_FirmwareUpdateFinished 
+	 * Use the properties Prop_Firmware_UpdateAvailable_Bool, Prop_Firmware_ManualUpdate_Bool, and Prop_Firmware_ManualUpdateURL_String
+	 * to figure our whether a firmware update is available, and to figure out whether its a manual update 
+	 * Prop_Firmware_ManualUpdateURL_String should point to an URL describing the manual update process */
+	virtual vr::EVRFirmwareError PerformFirmwareUpdate(vr::TrackedDeviceIndex_t unDeviceIndex) = 0;
+
+	// ------------------------------------
+	// Application life cycle methods
+	// ------------------------------------
+
+	/** Call this to acknowledge to the system that VREvent_Quit has been received and that the process is exiting.
+	* This extends the timeout until the process is killed. */
+	virtual void AcknowledgeQuit_Exiting() = 0;
+
+	/** Call this to tell the system that the user is being prompted to save data. This
+	* halts the timeout and dismisses the dashboard (if it was up). Applications should be sure to actually 
+	* prompt the user to save and then exit afterward, otherwise the user will be left in a confusing state. */
+	virtual void AcknowledgeQuit_UserPrompt() = 0;
+};
+
+static const char *const IVRSystem_Version = "IVRSystem_017";
+
+}  // namespace vr
+
+// ivrapplications.h
+namespace vr
+{
+/** Used for all errors reported by the IVRApplications interface */
+enum EVRApplicationError
+{
+	VRApplicationError_None = 0,
+
+	VRApplicationError_AppKeyAlreadyExists = 100,  // Only one application can use any given key
+	VRApplicationError_NoManifest = 101,           // the running application does not have a manifest
+	VRApplicationError_NoApplication = 102,        // No application is running
+	VRApplicationError_InvalidIndex = 103,
+	VRApplicationError_UnknownApplication = 104,  // the application could not be found
+	VRApplicationError_IPCFailed = 105,           // An IPC failure caused the request to fail
+	VRApplicationError_ApplicationAlreadyRunning = 106,
+	VRApplicationError_InvalidManifest = 107,
+	VRApplicationError_InvalidApplication = 108,
+	VRApplicationError_LaunchFailed = 109,                // the process didn't start
+	VRApplicationError_ApplicationAlreadyStarting = 110,  // the system was already starting the same application
+	VRApplicationError_LaunchInProgress = 111,            // The system was already starting a different application
+	VRApplicationError_OldApplicationQuitting = 112,
+	VRApplicationError_TransitionAborted = 113,
+	VRApplicationError_IsTemplate = 114,  // error when you try to call LaunchApplication() on a template type app (use LaunchTemplateApplication)
+	VRApplicationError_SteamVRIsExiting = 115,
+
+	VRApplicationError_BufferTooSmall = 200,  // The provided buffer was too small to fit the requested data
+	VRApplicationError_PropertyNotSet = 201,  // The requested property was not set
+	VRApplicationError_UnknownProperty = 202,
+	VRApplicationError_InvalidParameter = 203,
+};
+
+/** The maximum length of an application key */
+static const uint32_t k_unMaxApplicationKeyLength = 128;
+
+/** these are the properties available on applications. */
+enum EVRApplicationProperty
+{
+	VRApplicationProperty_Name_String = 0,
+
+	VRApplicationProperty_LaunchType_String = 11,
+	VRApplicationProperty_WorkingDirectory_String = 12,
+	VRApplicationProperty_BinaryPath_String = 13,
+	VRApplicationProperty_Arguments_String = 14,
+	VRApplicationProperty_URL_String = 15,
+
+	VRApplicationProperty_Description_String = 50,
+	VRApplicationProperty_NewsURL_String = 51,
+	VRApplicationProperty_ImagePath_String = 52,
+	VRApplicationProperty_Source_String = 53,
+
+	VRApplicationProperty_IsDashboardOverlay_Bool = 60,
+	VRApplicationProperty_IsTemplate_Bool = 61,
+	VRApplicationProperty_IsInstanced_Bool = 62,
+	VRApplicationProperty_IsInternal_Bool = 63,
+	VRApplicationProperty_WantsCompositorPauseInStandby_Bool = 64,
+
+	VRApplicationProperty_LastLaunchTime_Uint64 = 70,
+};
+
+/** These are states the scene application startup process will go through. */
+enum EVRApplicationTransitionState
+{
+	VRApplicationTransition_None = 0,
+
+	VRApplicationTransition_OldAppQuitSent = 10,
+	VRApplicationTransition_WaitingForExternalLaunch = 11,
+
+	VRApplicationTransition_NewAppLaunched = 20,
+};
+
+struct AppOverrideKeys_t
+{
+	const char *pchKey;
+	const char *pchValue;
+};
+
+/** Currently recognized mime types */
+static const char *const k_pch_MimeType_HomeApp = "vr/home";
+static const char *const k_pch_MimeType_GameTheater = "vr/game_theater";
+
+class IVRApplications
+{
+public:
+	// ---------------  Application management  --------------- //
+
+	/** Adds an application manifest to the list to load when building the list of installed applications. 
+		* Temporary manifests are not automatically loaded */
+	virtual EVRApplicationError AddApplicationManifest(const char *pchApplicationManifestFullPath, bool bTemporary = false) = 0;
+
+	/** Removes an application manifest from the list to load when building the list of installed applications. */
+	virtual EVRApplicationError RemoveApplicationManifest(const char *pchApplicationManifestFullPath) = 0;
+
+	/** Returns true if an application is installed */
+	virtual bool IsApplicationInstalled(const char *pchAppKey) = 0;
+
+	/** Returns the number of applications available in the list */
+	virtual uint32_t GetApplicationCount() = 0;
+
+	/** Returns the key of the specified application. The index is at least 0 and is less than the return 
+		* value of GetApplicationCount(). The buffer should be at least k_unMaxApplicationKeyLength in order to 
+		* fit the key. */
+	virtual EVRApplicationError GetApplicationKeyByIndex(uint32_t unApplicationIndex, VR_OUT_STRING() char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = 0;
+
+	/** Returns the key of the application for the specified Process Id. The buffer should be at least 
+		* k_unMaxApplicationKeyLength in order to fit the key. */
+	virtual EVRApplicationError GetApplicationKeyByProcessId(uint32_t unProcessId, char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = 0;
+
+	/** Launches the application. The existing scene application will exit and then the new application will start.
+		* This call is not valid for dashboard overlay applications. */
+	virtual EVRApplicationError LaunchApplication(const char *pchAppKey) = 0;
+
+	/** Launches an instance of an application of type template, with its app key being pchNewAppKey (which must be unique) and optionally override sections
+		* from the manifest file via AppOverrideKeys_t
+		*/
+	virtual EVRApplicationError LaunchTemplateApplication(const char *pchTemplateAppKey, const char *pchNewAppKey, VR_ARRAY_COUNT(unKeys) const AppOverrideKeys_t *pKeys, uint32_t unKeys) = 0;
+
+	/** launches the application currently associated with this mime type and passes it the option args, typically the filename or object name of the item being launched */
+	virtual vr::EVRApplicationError LaunchApplicationFromMimeType(const char *pchMimeType, const char *pchArgs) = 0;
+
+	/** Launches the dashboard overlay application if it is not already running. This call is only valid for 
+		* dashboard overlay applications. */
+	virtual EVRApplicationError LaunchDashboardOverlay(const char *pchAppKey) = 0;
+
+	/** Cancel a pending launch for an application */
+	virtual bool CancelApplicationLaunch(const char *pchAppKey) = 0;
+
+	/** Identifies a running application. OpenVR can't always tell which process started in response
+		* to a URL. This function allows a URL handler (or the process itself) to identify the app key 
+		* for the now running application. Passing a process ID of 0 identifies the calling process. 
+		* The application must be one that's known to the system via a call to AddApplicationManifest. */
+	virtual EVRApplicationError IdentifyApplication(uint32_t unProcessId, const char *pchAppKey) = 0;
+
+	/** Returns the process ID for an application. Return 0 if the application was not found or is not running. */
+	virtual uint32_t GetApplicationProcessId(const char *pchAppKey) = 0;
+
+	/** Returns a string for an applications error */
+	virtual const char *GetApplicationsErrorNameFromEnum(EVRApplicationError error) = 0;
+
+	// ---------------  Application properties  --------------- //
+
+	/** Returns a value for an application property. The required buffer size to fit this value will be returned. */
+	virtual uint32_t GetApplicationPropertyString(const char *pchAppKey, EVRApplicationProperty eProperty, VR_OUT_STRING() char *pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError *peError = nullptr) = 0;
+
+	/** Returns a bool value for an application property. Returns false in all error cases. */
+	virtual bool GetApplicationPropertyBool(const char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError = nullptr) = 0;
+
+	/** Returns a uint64 value for an application property. Returns 0 in all error cases. */
+	virtual uint64_t GetApplicationPropertyUint64(const char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError = nullptr) = 0;
+
+	/** Sets the application auto-launch flag. This is only valid for applications which return true for VRApplicationProperty_IsDashboardOverlay_Bool. */
+	virtual EVRApplicationError SetApplicationAutoLaunch(const char *pchAppKey, bool bAutoLaunch) = 0;
+
+	/** Gets the application auto-launch flag. This is only valid for applications which return true for VRApplicationProperty_IsDashboardOverlay_Bool. */
+	virtual bool GetApplicationAutoLaunch(const char *pchAppKey) = 0;
+
+	/** Adds this mime-type to the list of supported mime types for this application*/
+	virtual EVRApplicationError SetDefaultApplicationForMimeType(const char *pchAppKey, const char *pchMimeType) = 0;
+
+	/** return the app key that will open this mime type */
+	virtual bool GetDefaultApplicationForMimeType(const char *pchMimeType, char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = 0;
+
+	/** Get the list of supported mime types for this application, comma-delimited */
+	virtual bool GetApplicationSupportedMimeTypes(const char *pchAppKey, char *pchMimeTypesBuffer, uint32_t unMimeTypesBuffer) = 0;
+
+	/** Get the list of app-keys that support this mime type, comma-delimited, the return value is number of bytes you need to return the full string */
+	virtual uint32_t GetApplicationsThatSupportMimeType(const char *pchMimeType, char *pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer) = 0;
+
+	/** Get the args list from an app launch that had the process already running, you call this when you get a VREvent_ApplicationMimeTypeLoad */
+	virtual uint32_t GetApplicationLaunchArguments(uint32_t unHandle, char *pchArgs, uint32_t unArgs) = 0;
+
+	// ---------------  Transition methods --------------- //
+
+	/** Returns the app key for the application that is starting up */
+	virtual EVRApplicationError GetStartingApplication(char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = 0;
+
+	/** Returns the application transition state */
+	virtual EVRApplicationTransitionState GetTransitionState() = 0;
+
+	/** Returns errors that would prevent the specified application from launching immediately. Calling this function will
+		* cause the current scene application to quit, so only call it when you are actually about to launch something else.
+		* What the caller should do about these failures depends on the failure:
+		*   VRApplicationError_OldApplicationQuitting - An existing application has been told to quit. Wait for a VREvent_ProcessQuit
+		*                                               and try again.
+		*   VRApplicationError_ApplicationAlreadyStarting - This application is already starting. This is a permanent failure.
+		*   VRApplicationError_LaunchInProgress	      - A different application is already starting. This is a permanent failure.
+		*   VRApplicationError_None                   - Go ahead and launch. Everything is clear.
+		*/
+	virtual EVRApplicationError PerformApplicationPrelaunchCheck(const char *pchAppKey) = 0;
+
+	/** Returns a string for an application transition state */
+	virtual const char *GetApplicationsTransitionStateNameFromEnum(EVRApplicationTransitionState state) = 0;
+
+	/** Returns true if the outgoing scene app has requested a save prompt before exiting */
+	virtual bool IsQuitUserPromptRequested() = 0;
+
+	/** Starts a subprocess within the calling application. This
+		* suppresses all application transition UI and automatically identifies the new executable 
+		* as part of the same application. On success the calling process should exit immediately. 
+		* If working directory is NULL or "" the directory portion of the binary path will be 
+		* the working directory. */
+	virtual EVRApplicationError LaunchInternalProcess(const char *pchBinaryPath, const char *pchArguments, const char *pchWorkingDirectory) = 0;
+
+	/** Returns the current scene process ID according to the application system. A scene process will get scene
+		* focus once it starts rendering, but it will appear here once it calls VR_Init with the Scene application
+		* type. */
+	virtual uint32_t GetCurrentSceneProcessId() = 0;
+};
+
+static const char *const IVRApplications_Version = "IVRApplications_006";
+
+}  // namespace vr
+
+// ivrsettings.h
+namespace vr
+{
+enum EVRSettingsError
+{
+	VRSettingsError_None = 0,
+	VRSettingsError_IPCFailed = 1,
+	VRSettingsError_WriteFailed = 2,
+	VRSettingsError_ReadFailed = 3,
+	VRSettingsError_JsonParseFailed = 4,
+	VRSettingsError_UnsetSettingHasNoDefault = 5,  // This will be returned if the setting does not appear in the appropriate default file and has not been set
+};
+
+// The maximum length of a settings key
+static const uint32_t k_unMaxSettingsKeyLength = 128;
+
+class IVRSettings
+{
+public:
+	virtual const char *GetSettingsErrorNameFromEnum(EVRSettingsError eError) = 0;
+
+	// Returns true if file sync occurred (force or settings dirty)
+	virtual bool Sync(bool bForce = false, EVRSettingsError *peError = nullptr) = 0;
+
+	virtual void SetBool(const char *pchSection, const char *pchSettingsKey, bool bValue, EVRSettingsError *peError = nullptr) = 0;
+	virtual void SetInt32(const char *pchSection, const char *pchSettingsKey, int32_t nValue, EVRSettingsError *peError = nullptr) = 0;
+	virtual void SetFloat(const char *pchSection, const char *pchSettingsKey, float flValue, EVRSettingsError *peError = nullptr) = 0;
+	virtual void SetString(const char *pchSection, const char *pchSettingsKey, const char *pchValue, EVRSettingsError *peError = nullptr) = 0;
+
+	// Users of the system need to provide a proper default in default.vrsettings in the resources/settings/ directory
+	// of either the runtime or the driver_xxx directory. Otherwise the default will be false, 0, 0.0 or ""
+	virtual bool GetBool(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+	virtual int32_t GetInt32(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+	virtual float GetFloat(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+	virtual void GetString(const char *pchSection, const char *pchSettingsKey, VR_OUT_STRING() char *pchValue, uint32_t unValueLen, EVRSettingsError *peError = nullptr) = 0;
+
+	virtual void RemoveSection(const char *pchSection, EVRSettingsError *peError = nullptr) = 0;
+	virtual void RemoveKeyInSection(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+};
+
+//-----------------------------------------------------------------------------
+static const char *const IVRSettings_Version = "IVRSettings_002";
+
+//-----------------------------------------------------------------------------
+// steamvr keys
+static const char *const k_pch_SteamVR_Section = "steamvr";
+static const char *const k_pch_SteamVR_RequireHmd_String = "requireHmd";
+static const char *const k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver";
+static const char *const k_pch_SteamVR_ForcedHmdKey_String = "forcedHmd";
+static const char *const k_pch_SteamVR_DisplayDebug_Bool = "displayDebug";
+static const char *const k_pch_SteamVR_DebugProcessPipe_String = "debugProcessPipe";
+static const char *const k_pch_SteamVR_DisplayDebugX_Int32 = "displayDebugX";
+static const char *const k_pch_SteamVR_DisplayDebugY_Int32 = "displayDebugY";
+static const char *const k_pch_SteamVR_SendSystemButtonToAllApps_Bool = "sendSystemButtonToAllApps";
+static const char *const k_pch_SteamVR_LogLevel_Int32 = "loglevel";
+static const char *const k_pch_SteamVR_IPD_Float = "ipd";
+static const char *const k_pch_SteamVR_Background_String = "background";
+static const char *const k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection";
+static const char *const k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight";
+static const char *const k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius";
+static const char *const k_pch_SteamVR_GridColor_String = "gridColor";
+static const char *const k_pch_SteamVR_PlayAreaColor_String = "playAreaColor";
+static const char *const k_pch_SteamVR_ShowStage_Bool = "showStage";
+static const char *const k_pch_SteamVR_ActivateMultipleDrivers_Bool = "activateMultipleDrivers";
+static const char *const k_pch_SteamVR_DirectMode_Bool = "directMode";
+static const char *const k_pch_SteamVR_DirectModeEdidVid_Int32 = "directModeEdidVid";
+static const char *const k_pch_SteamVR_DirectModeEdidPid_Int32 = "directModeEdidPid";
+static const char *const k_pch_SteamVR_UsingSpeakers_Bool = "usingSpeakers";
+static const char *const k_pch_SteamVR_SpeakersForwardYawOffsetDegrees_Float = "speakersForwardYawOffsetDegrees";
+static const char *const k_pch_SteamVR_BaseStationPowerManagement_Bool = "basestationPowerManagement";
+static const char *const k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses";
+static const char *const k_pch_SteamVR_SupersampleScale_Float = "supersampleScale";
+static const char *const k_pch_SteamVR_AllowAsyncReprojection_Bool = "allowAsyncReprojection";
+static const char *const k_pch_SteamVR_AllowReprojection_Bool = "allowInterleavedReprojection";
+static const char *const k_pch_SteamVR_ForceReprojection_Bool = "forceReprojection";
+static const char *const k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking";
+static const char *const k_pch_SteamVR_DefaultMirrorView_Int32 = "defaultMirrorView";
+static const char *const k_pch_SteamVR_ShowMirrorView_Bool = "showMirrorView";
+static const char *const k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry";
+static const char *const k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch";
+static const char *const k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch";
+static const char *const k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch";
+static const char *const k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard";
+static const char *const k_pch_SteamVR_EnableHomeApp = "enableHomeApp";
+static const char *const k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec";
+static const char *const k_pch_SteamVR_RetailDemo_Bool = "retailDemo";
+static const char *const k_pch_SteamVR_IpdOffset_Float = "ipdOffset";
+static const char *const k_pch_SteamVR_AllowSupersampleFiltering_Bool = "allowSupersampleFiltering";
+static const char *const k_pch_SteamVR_EnableLinuxVulkanAsync_Bool = "enableLinuxVulkanAsync";
+
+//-----------------------------------------------------------------------------
+// lighthouse keys
+static const char *const k_pch_Lighthouse_Section = "driver_lighthouse";
+static const char *const k_pch_Lighthouse_DisableIMU_Bool = "disableimu";
+static const char *const k_pch_Lighthouse_UseDisambiguation_String = "usedisambiguation";
+static const char *const k_pch_Lighthouse_DisambiguationDebug_Int32 = "disambiguationdebug";
+static const char *const k_pch_Lighthouse_PrimaryBasestation_Int32 = "primarybasestation";
+static const char *const k_pch_Lighthouse_DBHistory_Bool = "dbhistory";
+
+//-----------------------------------------------------------------------------
+// null keys
+static const char *const k_pch_Null_Section = "driver_null";
+static const char *const k_pch_Null_SerialNumber_String = "serialNumber";
+static const char *const k_pch_Null_ModelNumber_String = "modelNumber";
+static const char *const k_pch_Null_WindowX_Int32 = "windowX";
+static const char *const k_pch_Null_WindowY_Int32 = "windowY";
+static const char *const k_pch_Null_WindowWidth_Int32 = "windowWidth";
+static const char *const k_pch_Null_WindowHeight_Int32 = "windowHeight";
+static const char *const k_pch_Null_RenderWidth_Int32 = "renderWidth";
+static const char *const k_pch_Null_RenderHeight_Int32 = "renderHeight";
+static const char *const k_pch_Null_SecondsFromVsyncToPhotons_Float = "secondsFromVsyncToPhotons";
+static const char *const k_pch_Null_DisplayFrequency_Float = "displayFrequency";
+
+//-----------------------------------------------------------------------------
+// user interface keys
+static const char *const k_pch_UserInterface_Section = "userinterface";
+static const char *const k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop";
+static const char *const k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray";
+static const char *const k_pch_UserInterface_Screenshots_Bool = "screenshots";
+static const char *const k_pch_UserInterface_ScreenshotType_Int = "screenshotType";
+
+//-----------------------------------------------------------------------------
+// notification keys
+static const char *const k_pch_Notifications_Section = "notifications";
+static const char *const k_pch_Notifications_DoNotDisturb_Bool = "DoNotDisturb";
+
+//-----------------------------------------------------------------------------
+// keyboard keys
+static const char *const k_pch_Keyboard_Section = "keyboard";
+static const char *const k_pch_Keyboard_TutorialCompletions = "TutorialCompletions";
+static const char *const k_pch_Keyboard_ScaleX = "ScaleX";
+static const char *const k_pch_Keyboard_ScaleY = "ScaleY";
+static const char *const k_pch_Keyboard_OffsetLeftX = "OffsetLeftX";
+static const char *const k_pch_Keyboard_OffsetRightX = "OffsetRightX";
+static const char *const k_pch_Keyboard_OffsetY = "OffsetY";
+static const char *const k_pch_Keyboard_Smoothing = "Smoothing";
+
+//-----------------------------------------------------------------------------
+// perf keys
+static const char *const k_pch_Perf_Section = "perfcheck";
+static const char *const k_pch_Perf_HeuristicActive_Bool = "heuristicActive";
+static const char *const k_pch_Perf_NotifyInHMD_Bool = "warnInHMD";
+static const char *const k_pch_Perf_NotifyOnlyOnce_Bool = "warnOnlyOnce";
+static const char *const k_pch_Perf_AllowTimingStore_Bool = "allowTimingStore";
+static const char *const k_pch_Perf_SaveTimingsOnExit_Bool = "saveTimingsOnExit";
+static const char *const k_pch_Perf_TestData_Float = "perfTestData";
+static const char *const k_pch_Perf_LinuxGPUProfiling_Bool = "linuxGPUProfiling";
+
+//-----------------------------------------------------------------------------
+// collision bounds keys
+static const char *const k_pch_CollisionBounds_Section = "collisionBounds";
+static const char *const k_pch_CollisionBounds_Style_Int32 = "CollisionBoundsStyle";
+static const char *const k_pch_CollisionBounds_GroundPerimeterOn_Bool = "CollisionBoundsGroundPerimeterOn";
+static const char *const k_pch_CollisionBounds_CenterMarkerOn_Bool = "CollisionBoundsCenterMarkerOn";
+static const char *const k_pch_CollisionBounds_PlaySpaceOn_Bool = "CollisionBoundsPlaySpaceOn";
+static const char *const k_pch_CollisionBounds_FadeDistance_Float = "CollisionBoundsFadeDistance";
+static const char *const k_pch_CollisionBounds_ColorGammaR_Int32 = "CollisionBoundsColorGammaR";
+static const char *const k_pch_CollisionBounds_ColorGammaG_Int32 = "CollisionBoundsColorGammaG";
+static const char *const k_pch_CollisionBounds_ColorGammaB_Int32 = "CollisionBoundsColorGammaB";
+static const char *const k_pch_CollisionBounds_ColorGammaA_Int32 = "CollisionBoundsColorGammaA";
+
+//-----------------------------------------------------------------------------
+// camera keys
+static const char *const k_pch_Camera_Section = "camera";
+static const char *const k_pch_Camera_EnableCamera_Bool = "enableCamera";
+static const char *const k_pch_Camera_EnableCameraInDashboard_Bool = "enableCameraInDashboard";
+static const char *const k_pch_Camera_EnableCameraForCollisionBounds_Bool = "enableCameraForCollisionBounds";
+static const char *const k_pch_Camera_EnableCameraForRoomView_Bool = "enableCameraForRoomView";
+static const char *const k_pch_Camera_BoundsColorGammaR_Int32 = "cameraBoundsColorGammaR";
+static const char *const k_pch_Camera_BoundsColorGammaG_Int32 = "cameraBoundsColorGammaG";
+static const char *const k_pch_Camera_BoundsColorGammaB_Int32 = "cameraBoundsColorGammaB";
+static const char *const k_pch_Camera_BoundsColorGammaA_Int32 = "cameraBoundsColorGammaA";
+static const char *const k_pch_Camera_BoundsStrength_Int32 = "cameraBoundsStrength";
+
+//-----------------------------------------------------------------------------
+// audio keys
+static const char *const k_pch_audio_Section = "audio";
+static const char *const k_pch_audio_OnPlaybackDevice_String = "onPlaybackDevice";
+static const char *const k_pch_audio_OnRecordDevice_String = "onRecordDevice";
+static const char *const k_pch_audio_OnPlaybackMirrorDevice_String = "onPlaybackMirrorDevice";
+static const char *const k_pch_audio_OffPlaybackDevice_String = "offPlaybackDevice";
+static const char *const k_pch_audio_OffRecordDevice_String = "offRecordDevice";
+static const char *const k_pch_audio_VIVEHDMIGain = "viveHDMIGain";
+
+//-----------------------------------------------------------------------------
+// power management keys
+static const char *const k_pch_Power_Section = "power";
+static const char *const k_pch_Power_PowerOffOnExit_Bool = "powerOffOnExit";
+static const char *const k_pch_Power_TurnOffScreensTimeout_Float = "turnOffScreensTimeout";
+static const char *const k_pch_Power_TurnOffControllersTimeout_Float = "turnOffControllersTimeout";
+static const char *const k_pch_Power_ReturnToWatchdogTimeout_Float = "returnToWatchdogTimeout";
+static const char *const k_pch_Power_AutoLaunchSteamVROnButtonPress = "autoLaunchSteamVROnButtonPress";
+static const char *const k_pch_Power_PauseCompositorOnStandby_Bool = "pauseCompositorOnStandby";
+
+//-----------------------------------------------------------------------------
+// dashboard keys
+static const char *const k_pch_Dashboard_Section = "dashboard";
+static const char *const k_pch_Dashboard_EnableDashboard_Bool = "enableDashboard";
+static const char *const k_pch_Dashboard_ArcadeMode_Bool = "arcadeMode";
+
+//-----------------------------------------------------------------------------
+// model skin keys
+static const char *const k_pch_modelskin_Section = "modelskins";
+
+//-----------------------------------------------------------------------------
+// driver keys - These could be checked in any driver_<name> section
+static const char *const k_pch_Driver_Enable_Bool = "enable";
+
+}  // namespace vr
+
+// ivrchaperone.h
+namespace vr
+{
+#pragma pack(push, 8)
+
+enum ChaperoneCalibrationState
+{
+	// OK!
+	ChaperoneCalibrationState_OK = 1,  // Chaperone is fully calibrated and working correctly
+
+	// Warnings
+	ChaperoneCalibrationState_Warning = 100,
+	ChaperoneCalibrationState_Warning_BaseStationMayHaveMoved = 101,  // A base station thinks that it might have moved
+	ChaperoneCalibrationState_Warning_BaseStationRemoved = 102,       // There are less base stations than when calibrated
+	ChaperoneCalibrationState_Warning_SeatedBoundsInvalid = 103,      // Seated bounds haven't been calibrated for the current tracking center
+
+	// Errors
+	ChaperoneCalibrationState_Error = 200,                           // The UniverseID is invalid
+	ChaperoneCalibrationState_Error_BaseStationUninitialized = 201,  // Tracking center hasn't be calibrated for at least one of the base stations
+	ChaperoneCalibrationState_Error_BaseStationConflict = 202,       // Tracking center is calibrated, but base stations disagree on the tracking space
+	ChaperoneCalibrationState_Error_PlayAreaInvalid = 203,           // Play Area hasn't been calibrated for the current tracking center
+	ChaperoneCalibrationState_Error_CollisionBoundsInvalid = 204,    // Collision Bounds haven't been calibrated for the current tracking center
+};
+
+/** HIGH LEVEL TRACKING SPACE ASSUMPTIONS:
+* 0,0,0 is the preferred standing area center.
+* 0Y is the floor height.
+* -Z is the preferred forward facing direction. */
+class IVRChaperone
+{
+public:
+	/** Get the current state of Chaperone calibration. This state can change at any time during a session due to physical base station changes. **/
+	virtual ChaperoneCalibrationState GetCalibrationState() = 0;
+
+	/** Returns the width and depth of the Play Area (formerly named Soft Bounds) in X and Z. 
+	* Tracking space center (0,0,0) is the center of the Play Area. **/
+	virtual bool GetPlayAreaSize(float *pSizeX, float *pSizeZ) = 0;
+
+	/** Returns the 4 corner positions of the Play Area (formerly named Soft Bounds).
+	* Corners are in counter-clockwise order.
+	* Standing center (0,0,0) is the center of the Play Area.
+	* It's a rectangle.
+	* 2 sides are parallel to the X axis and 2 sides are parallel to the Z axis.
+	* Height of every corner is 0Y (on the floor). **/
+	virtual bool GetPlayAreaRect(HmdQuad_t *rect) = 0;
+
+	/** Reload Chaperone data from the .vrchap file on disk. */
+	virtual void ReloadInfo(void) = 0;
+
+	/** Optionally give the chaperone system a hit about the color and brightness in the scene **/
+	virtual void SetSceneColor(HmdColor_t color) = 0;
+
+	/** Get the current chaperone bounds draw color and brightness **/
+	virtual void GetBoundsColor(HmdColor_t *pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, HmdColor_t *pOutputCameraColor) = 0;
+
+	/** Determine whether the bounds are showing right now **/
+	virtual bool AreBoundsVisible() = 0;
+
+	/** Force the bounds to show, mostly for utilities **/
+	virtual void ForceBoundsVisible(bool bForce) = 0;
+};
+
+static const char *const IVRChaperone_Version = "IVRChaperone_003";
+
+#pragma pack(pop)
+
+}  // namespace vr
+
+// ivrchaperonesetup.h
+namespace vr
+{
+enum EChaperoneConfigFile
+{
+	EChaperoneConfigFile_Live = 1,  // The live chaperone config, used by most applications and games
+	EChaperoneConfigFile_Temp = 2,  // The temporary chaperone config, used to live-preview collision bounds in room setup
+};
+
+enum EChaperoneImportFlags
+{
+	EChaperoneImport_BoundsOnly = 0x0001,
+};
+
+/** Manages the working copy of the chaperone info. By default this will be the same as the 
+* live copy. Any changes made with this interface will stay in the working copy until 
+* CommitWorkingCopy() is called, at which point the working copy and the live copy will be 
+* the same again. */
+class IVRChaperoneSetup
+{
+public:
+	/** Saves the current working copy to disk */
+	virtual bool CommitWorkingCopy(EChaperoneConfigFile configFile) = 0;
+
+	/** Reverts the working copy to match the live chaperone calibration.
+	* To modify existing data this MUST be do WHILE getting a non-error ChaperoneCalibrationStatus.
+	* Only after this should you do gets and sets on the existing data. */
+	virtual void RevertWorkingCopy() = 0;
+
+	/** Returns the width and depth of the Play Area (formerly named Soft Bounds) in X and Z from the working copy.
+	* Tracking space center (0,0,0) is the center of the Play Area. */
+	virtual bool GetWorkingPlayAreaSize(float *pSizeX, float *pSizeZ) = 0;
+
+	/** Returns the 4 corner positions of the Play Area (formerly named Soft Bounds) from the working copy.
+	* Corners are in clockwise order.
+	* Tracking space center (0,0,0) is the center of the Play Area.
+	* It's a rectangle.
+	* 2 sides are parallel to the X axis and 2 sides are parallel to the Z axis.
+	* Height of every corner is 0Y (on the floor). **/
+	virtual bool GetWorkingPlayAreaRect(HmdQuad_t *rect) = 0;
+
+	/** Returns the number of Quads if the buffer points to null. Otherwise it returns Quads 
+	* into the buffer up to the max specified from the working copy. */
+	virtual bool GetWorkingCollisionBoundsInfo(VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t *punQuadsCount) = 0;
+
+	/** Returns the number of Quads if the buffer points to null. Otherwise it returns Quads 
+	* into the buffer up to the max specified. */
+	virtual bool GetLiveCollisionBoundsInfo(VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t *punQuadsCount) = 0;
+
+	/** Returns the preferred seated position from the working copy. */
+	virtual bool GetWorkingSeatedZeroPoseToRawTrackingPose(HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose) = 0;
+
+	/** Returns the standing origin from the working copy. */
+	virtual bool GetWorkingStandingZeroPoseToRawTrackingPose(HmdMatrix34_t *pmatStandingZeroPoseToRawTrackingPose) = 0;
+
+	/** Sets the Play Area in the working copy. */
+	virtual void SetWorkingPlayAreaSize(float sizeX, float sizeZ) = 0;
+
+	/** Sets the Collision Bounds in the working copy. */
+	virtual void SetWorkingCollisionBoundsInfo(VR_ARRAY_COUNT(unQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t unQuadsCount) = 0;
+
+	/** Sets the preferred seated position in the working copy. */
+	virtual void SetWorkingSeatedZeroPoseToRawTrackingPose(const HmdMatrix34_t *pMatSeatedZeroPoseToRawTrackingPose) = 0;
+
+	/** Sets the preferred standing position in the working copy. */
+	virtual void SetWorkingStandingZeroPoseToRawTrackingPose(const HmdMatrix34_t *pMatStandingZeroPoseToRawTrackingPose) = 0;
+
+	/** Tear everything down and reload it from the file on disk */
+	virtual void ReloadFromDisk(EChaperoneConfigFile configFile) = 0;
+
+	/** Returns the preferred seated position. */
+	virtual bool GetLiveSeatedZeroPoseToRawTrackingPose(HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose) = 0;
+
+	virtual void SetWorkingCollisionBoundsTagsInfo(VR_ARRAY_COUNT(unTagCount) uint8_t *pTagsBuffer, uint32_t unTagCount) = 0;
+	virtual bool GetLiveCollisionBoundsTagsInfo(VR_OUT_ARRAY_COUNT(punTagCount) uint8_t *pTagsBuffer, uint32_t *punTagCount) = 0;
+
+	virtual bool SetWorkingPhysicalBoundsInfo(VR_ARRAY_COUNT(unQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t unQuadsCount) = 0;
+	virtual bool GetLivePhysicalBoundsInfo(VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t *punQuadsCount) = 0;
+
+	virtual bool ExportLiveToBuffer(VR_OUT_STRING() char *pBuffer, uint32_t *pnBufferLength) = 0;
+	virtual bool ImportFromBufferToWorking(const char *pBuffer, uint32_t nImportFlags) = 0;
+};
+
+static const char *const IVRChaperoneSetup_Version = "IVRChaperoneSetup_005";
+
+}  // namespace vr
+
+// ivrcompositor.h
+namespace vr
+{
+#pragma pack(push, 8)
+
+/** Errors that can occur with the VR compositor */
+enum EVRCompositorError
+{
+	VRCompositorError_None = 0,
+	VRCompositorError_RequestFailed = 1,
+	VRCompositorError_IncompatibleVersion = 100,
+	VRCompositorError_DoNotHaveFocus = 101,
+	VRCompositorError_InvalidTexture = 102,
+	VRCompositorError_IsNotSceneApplication = 103,
+	VRCompositorError_TextureIsOnWrongDevice = 104,
+	VRCompositorError_TextureUsesUnsupportedFormat = 105,
+	VRCompositorError_SharedTexturesNotSupported = 106,
+	VRCompositorError_IndexOutOfRange = 107,
+	VRCompositorError_AlreadySubmitted = 108,
+	VRCompositorError_InvalidBounds = 109,
+};
+
+const uint32_t VRCompositor_ReprojectionReason_Cpu = 0x01;
+const uint32_t VRCompositor_ReprojectionReason_Gpu = 0x02;
+const uint32_t VRCompositor_ReprojectionAsync = 0x04;  // This flag indicates the async reprojection mode is active,
+													   // but does not indicate if reprojection actually happened or not.
+													   // Use the ReprojectionReason flags above to check if reprojection
+													   // was actually applied (i.e. scene texture was reused).
+													   // NumFramePresents > 1 also indicates the scene texture was reused,
+													   // and also the number of times that it was presented in total.
+
+/** Provides a single frame's timing information to the app */
+struct Compositor_FrameTiming
+{
+	uint32_t m_nSize;  // Set to sizeof( Compositor_FrameTiming )
+	uint32_t m_nFrameIndex;
+	uint32_t m_nNumFramePresents;  // number of times this frame was presented
+	uint32_t m_nNumMisPresented;   // number of times this frame was presented on a vsync other than it was originally predicted to
+	uint32_t m_nNumDroppedFrames;  // number of additional times previous frame was scanned out
+	uint32_t m_nReprojectionFlags;
+
+	/** Absolute time reference for comparing frames.  This aligns with the vsync that running start is relative to. */
+	double m_flSystemTimeInSeconds;
+
+	/** These times may include work from other processes due to OS scheduling.
+	* The fewer packets of work these are broken up into, the less likely this will happen.
+	* GPU work can be broken up by calling Flush.  This can sometimes be useful to get the GPU started
+	* processing that work earlier in the frame. */
+	float m_flPreSubmitGpuMs;         // time spent rendering the scene (gpu work submitted between WaitGetPoses and second Submit)
+	float m_flPostSubmitGpuMs;        // additional time spent rendering by application (e.g. companion window)
+	float m_flTotalRenderGpuMs;       // time between work submitted immediately after present (ideally vsync) until the end of compositor submitted work
+	float m_flCompositorRenderGpuMs;  // time spend performing distortion correction, rendering chaperone, overlays, etc.
+	float m_flCompositorRenderCpuMs;  // time spent on cpu submitting the above work for this frame
+	float m_flCompositorIdleCpuMs;    // time spent waiting for running start (application could have used this much more time)
+
+	/** Miscellaneous measured intervals. */
+	float m_flClientFrameIntervalMs;  // time between calls to WaitGetPoses
+	float m_flPresentCallCpuMs;       // time blocked on call to present (usually 0.0, but can go long)
+	float m_flWaitForPresentCpuMs;    // time spent spin-waiting for frame index to change (not near-zero indicates wait object failure)
+	float m_flSubmitFrameMs;          // time spent in IVRCompositor::Submit (not near-zero indicates driver issue)
+
+	/** The following are all relative to this frame's SystemTimeInSeconds */
+	float m_flWaitGetPosesCalledMs;
+	float m_flNewPosesReadyMs;
+	float m_flNewFrameReadyMs;  // second call to IVRCompositor::Submit
+	float m_flCompositorUpdateStartMs;
+	float m_flCompositorUpdateEndMs;
+	float m_flCompositorRenderStartMs;
+
+	vr::TrackedDevicePose_t m_HmdPose;  // pose used by app to render this frame
+};
+
+/** Cumulative stats for current application.  These are not cleared until a new app connects,
+* but they do stop accumulating once the associated app disconnects. */
+struct Compositor_CumulativeStats
+{
+	uint32_t m_nPid;                   // Process id associated with these stats (may no longer be running).
+	uint32_t m_nNumFramePresents;      // total number of times we called present (includes reprojected frames)
+	uint32_t m_nNumDroppedFrames;      // total number of times an old frame was re-scanned out (without reprojection)
+	uint32_t m_nNumReprojectedFrames;  // total number of times a frame was scanned out a second time (with reprojection)
+
+	/** Values recorded at startup before application has fully faded in the first time. */
+	uint32_t m_nNumFramePresentsOnStartup;
+	uint32_t m_nNumDroppedFramesOnStartup;
+	uint32_t m_nNumReprojectedFramesOnStartup;
+
+	/** Applications may explicitly fade to the compositor.  This is usually to handle level transitions, and loading often causes
+	* system wide hitches.  The following stats are collected during this period.  Does not include values recorded during startup. */
+	uint32_t m_nNumLoading;
+	uint32_t m_nNumFramePresentsLoading;
+	uint32_t m_nNumDroppedFramesLoading;
+	uint32_t m_nNumReprojectedFramesLoading;
+
+	/** If we don't get a new frame from the app in less than 2.5 frames, then we assume the app has hung and start
+	* fading back to the compositor.  The following stats are a result of this, and are a subset of those recorded above.
+	* Does not include values recorded during start up or loading. */
+	uint32_t m_nNumTimedOut;
+	uint32_t m_nNumFramePresentsTimedOut;
+	uint32_t m_nNumDroppedFramesTimedOut;
+	uint32_t m_nNumReprojectedFramesTimedOut;
+};
+
+#pragma pack(pop)
+
+/** Allows the application to interact with the compositor */
+class IVRCompositor
+{
+public:
+	/** Sets tracking space returned by WaitGetPoses */
+	virtual void SetTrackingSpace(ETrackingUniverseOrigin eOrigin) = 0;
+
+	/** Gets current tracking space returned by WaitGetPoses */
+	virtual ETrackingUniverseOrigin GetTrackingSpace() = 0;
+
+	/** Scene applications should call this function to get poses to render with (and optionally poses predicted an additional frame out to use for gameplay).
+	* This function will block until "running start" milliseconds before the start of the frame, and should be called at the last moment before needing to
+	* start rendering.
+	*
+	* Return codes:
+	*	- IsNotSceneApplication (make sure to call VR_Init with VRApplicaiton_Scene)
+	*	- DoNotHaveFocus (some other app has taken focus - this will throttle the call to 10hz to reduce the impact on that app)
+	*/
+	virtual EVRCompositorError WaitGetPoses(VR_ARRAY_COUNT(unRenderPoseArrayCount) TrackedDevicePose_t *pRenderPoseArray, uint32_t unRenderPoseArrayCount,
+											VR_ARRAY_COUNT(unGamePoseArrayCount) TrackedDevicePose_t *pGamePoseArray, uint32_t unGamePoseArrayCount) = 0;
+
+	/** Get the last set of poses returned by WaitGetPoses. */
+	virtual EVRCompositorError GetLastPoses(VR_ARRAY_COUNT(unRenderPoseArrayCount) TrackedDevicePose_t *pRenderPoseArray, uint32_t unRenderPoseArrayCount,
+											VR_ARRAY_COUNT(unGamePoseArrayCount) TrackedDevicePose_t *pGamePoseArray, uint32_t unGamePoseArrayCount) = 0;
+
+	/** Interface for accessing last set of poses returned by WaitGetPoses one at a time.
+	* Returns VRCompositorError_IndexOutOfRange if unDeviceIndex not less than k_unMaxTrackedDeviceCount otherwise VRCompositorError_None.
+	* It is okay to pass NULL for either pose if you only want one of the values. */
+	virtual EVRCompositorError GetLastPoseForTrackedDeviceIndex(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t *pOutputPose, TrackedDevicePose_t *pOutputGamePose) = 0;
+
+	/** Updated scene texture to display. If pBounds is NULL the entire texture will be used.  If called from an OpenGL app, consider adding a glFlush after
+	* Submitting both frames to signal the driver to start processing, otherwise it may wait until the command buffer fills up, causing the app to miss frames.
+	*
+	* OpenGL dirty state:
+	*	glBindTexture
+	*
+	* Return codes:
+	*	- IsNotSceneApplication (make sure to call VR_Init with VRApplicaiton_Scene)
+	*	- DoNotHaveFocus (some other app has taken focus)
+	*	- TextureIsOnWrongDevice (application did not use proper AdapterIndex - see IVRSystem.GetDXGIOutputInfo)
+	*	- SharedTexturesNotSupported (application needs to call CreateDXGIFactory1 or later before creating DX device)
+	*	- TextureUsesUnsupportedFormat (scene textures must be compatible with DXGI sharing rules - e.g. uncompressed, no mips, etc.)
+	*	- InvalidTexture (usually means bad arguments passed in)
+	*	- AlreadySubmitted (app has submitted two left textures or two right textures in a single frame - i.e. before calling WaitGetPoses again)
+	*/
+	virtual EVRCompositorError Submit(EVREye eEye, const Texture_t *pTexture, const VRTextureBounds_t *pBounds = 0, EVRSubmitFlags nSubmitFlags = Submit_Default) = 0;
+
+	/** Clears the frame that was sent with the last call to Submit. This will cause the 
+	* compositor to show the grid until Submit is called again. */
+	virtual void ClearLastSubmittedFrame() = 0;
+
+	/** Call immediately after presenting your app's window (i.e. companion window) to unblock the compositor.
+	* This is an optional call, which only needs to be used if you can't instead call WaitGetPoses immediately after Present.
+	* For example, if your engine's render and game loop are not on separate threads, or blocking the render thread until 3ms before the next vsync would
+	* introduce a deadlock of some sort.  This function tells the compositor that you have finished all rendering after having Submitted buffers for both
+	* eyes, and it is free to start its rendering work.  This should only be called from the same thread you are rendering on. */
+	virtual void PostPresentHandoff() = 0;
+
+	/** Returns true if timing data is filled it.  Sets oldest timing info if nFramesAgo is larger than the stored history.
+	* Be sure to set timing.size = sizeof(Compositor_FrameTiming) on struct passed in before calling this function. */
+	virtual bool GetFrameTiming(Compositor_FrameTiming *pTiming, uint32_t unFramesAgo = 0) = 0;
+
+	/** Interface for copying a range of timing data.  Frames are returned in ascending order (oldest to newest) with the last being the most recent frame.
+	* Only the first entry's m_nSize needs to be set, as the rest will be inferred from that.  Returns total number of entries filled out. */
+	virtual uint32_t GetFrameTimings(Compositor_FrameTiming *pTiming, uint32_t nFrames) = 0;
+
+	/** Returns the time in seconds left in the current (as identified by FrameTiming's frameIndex) frame.
+	* Due to "running start", this value may roll over to the next frame before ever reaching 0.0. */
+	virtual float GetFrameTimeRemaining() = 0;
+
+	/** Fills out stats accumulated for the last connected application.  Pass in sizeof( Compositor_CumulativeStats ) as second parameter. */
+	virtual void GetCumulativeStats(Compositor_CumulativeStats *pStats, uint32_t nStatsSizeInBytes) = 0;
+
+	/** Fades the view on the HMD to the specified color. The fade will take fSeconds, and the color values are between
+	* 0.0 and 1.0. This color is faded on top of the scene based on the alpha parameter. Removing the fade color instantly 
+	* would be FadeToColor( 0.0, 0.0, 0.0, 0.0, 0.0 ).  Values are in un-premultiplied alpha space. */
+	virtual void FadeToColor(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground = false) = 0;
+
+	/** Get current fade color value. */
+	virtual HmdColor_t GetCurrentFadeColor(bool bBackground = false) = 0;
+
+	/** Fading the Grid in or out in fSeconds */
+	virtual void FadeGrid(float fSeconds, bool bFadeIn) = 0;
+
+	/** Get current alpha value of grid. */
+	virtual float GetCurrentGridAlpha() = 0;
+
+	/** Override the skybox used in the compositor (e.g. for during level loads when the app can't feed scene images fast enough)
+	* Order is Front, Back, Left, Right, Top, Bottom.  If only a single texture is passed, it is assumed in lat-long format.
+	* If two are passed, it is assumed a lat-long stereo pair. */
+	virtual EVRCompositorError SetSkyboxOverride(VR_ARRAY_COUNT(unTextureCount) const Texture_t *pTextures, uint32_t unTextureCount) = 0;
+
+	/** Resets compositor skybox back to defaults. */
+	virtual void ClearSkyboxOverride() = 0;
+
+	/** Brings the compositor window to the front. This is useful for covering any other window that may be on the HMD
+	* and is obscuring the compositor window. */
+	virtual void CompositorBringToFront() = 0;
+
+	/** Pushes the compositor window to the back. This is useful for allowing other applications to draw directly to the HMD. */
+	virtual void CompositorGoToBack() = 0;
+
+	/** Tells the compositor process to clean up and exit. You do not need to call this function at shutdown. Under normal 
+	* circumstances the compositor will manage its own life cycle based on what applications are running. */
+	virtual void CompositorQuit() = 0;
+
+	/** Return whether the compositor is fullscreen */
+	virtual bool IsFullscreen() = 0;
+
+	/** Returns the process ID of the process that is currently rendering the scene */
+	virtual uint32_t GetCurrentSceneFocusProcess() = 0;
+
+	/** Returns the process ID of the process that rendered the last frame (or 0 if the compositor itself rendered the frame.)
+	* Returns 0 when fading out from an app and the app's process Id when fading into an app. */
+	virtual uint32_t GetLastFrameRenderer() = 0;
+
+	/** Returns true if the current process has the scene focus */
+	virtual bool CanRenderScene() = 0;
+
+	/** Creates a window on the primary monitor to display what is being shown in the headset. */
+	virtual void ShowMirrorWindow() = 0;
+
+	/** Closes the mirror window. */
+	virtual void HideMirrorWindow() = 0;
+
+	/** Returns true if the mirror window is shown. */
+	virtual bool IsMirrorWindowVisible() = 0;
+
+	/** Writes all images that the compositor knows about (including overlays) to a 'screenshots' folder in the SteamVR runtime root. */
+	virtual void CompositorDumpImages() = 0;
+
+	/** Let an app know it should be rendering with low resources. */
+	virtual bool ShouldAppRenderWithLowResources() = 0;
+
+	/** Override interleaved reprojection logic to force on. */
+	virtual void ForceInterleavedReprojectionOn(bool bOverride) = 0;
+
+	/** Force reconnecting to the compositor process. */
+	virtual void ForceReconnectProcess() = 0;
+
+	/** Temporarily suspends rendering (useful for finer control over scene transitions). */
+	virtual void SuspendRendering(bool bSuspend) = 0;
+
+	/** Opens a shared D3D11 texture with the undistorted composited image for each eye.  Use ReleaseMirrorTextureD3D11 when finished
+	* instead of calling Release on the resource itself. */
+	virtual vr::EVRCompositorError GetMirrorTextureD3D11(vr::EVREye eEye, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView) = 0;
+	virtual void ReleaseMirrorTextureD3D11(void *pD3D11ShaderResourceView) = 0;
+
+	/** Access to mirror textures from OpenGL. */
+	virtual vr::EVRCompositorError GetMirrorTextureGL(vr::EVREye eEye, vr::glUInt_t *pglTextureId, vr::glSharedTextureHandle_t *pglSharedTextureHandle) = 0;
+	virtual bool ReleaseSharedGLTexture(vr::glUInt_t glTextureId, vr::glSharedTextureHandle_t glSharedTextureHandle) = 0;
+	virtual void LockGLSharedTextureForAccess(vr::glSharedTextureHandle_t glSharedTextureHandle) = 0;
+	virtual void UnlockGLSharedTextureForAccess(vr::glSharedTextureHandle_t glSharedTextureHandle) = 0;
+
+	/** [Vulkan Only]
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null.  The string will be a space separated list of-required instance extensions to enable in VkCreateInstance */
+	virtual uint32_t GetVulkanInstanceExtensionsRequired(VR_OUT_STRING() char *pchValue, uint32_t unBufferSize) = 0;
+
+	/** [Vulkan only]
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null.  The string will be a space separated list of required device extensions to enable in VkCreateDevice */
+	virtual uint32_t GetVulkanDeviceExtensionsRequired(VkPhysicalDevice_T *pPhysicalDevice, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize) = 0;
+
+	/** [ Vulkan/D3D12 Only ]
+	* There are two purposes for SetExplicitTimingMode:
+	*	1. To get a more accurate GPU timestamp for when the frame begins in Vulkan/D3D12 applications.
+	*	2. (Optional) To avoid having WaitGetPoses access the Vulkan queue so that the queue can be accessed from
+	*	another thread while WaitGetPoses is executing.
+	*
+	* More accurate GPU timestamp for the start of the frame is achieved by the application calling
+	* SubmitExplicitTimingData immediately before its first submission to the Vulkan/D3D12 queue.
+	* This is more accurate because normally this GPU timestamp is recorded during WaitGetPoses.  In D3D11, 
+	* WaitGetPoses queues a GPU timestamp write, but it does not actually get submitted to the GPU until the 
+	* application flushes.  By using SubmitExplicitTimingData, the timestamp is recorded at the same place for 
+	* Vulkan/D3D12 as it is for D3D11, resulting in a more accurate GPU time measurement for the frame.
+	*
+	* Avoiding WaitGetPoses accessing the Vulkan queue can be achieved using SetExplicitTimingMode as well.  If this is desired,
+	* the application *MUST* call PostPresentHandoff itself prior to WaitGetPoses.  If SetExplicitTimingMode is true and the
+	* application calls PostPresentHandoff, then WaitGetPoses is guaranteed not to access the queue.  Note that PostPresentHandoff
+	* and SubmitExplicitTimingData will access the queue, so only WaitGetPoses becomes safe for accessing the queue from another
+	* thread. */
+	virtual void SetExplicitTimingMode(bool bExplicitTimingMode) = 0;
+
+	/** [ Vulkan/D3D12 Only ]
+	* Submit explicit timing data.  When SetExplicitTimingMode is true, this must be called immediately before
+	* the application's first vkQueueSubmit (Vulkan) or ID3D12CommandQueue::ExecuteCommandLists (D3D12) of each frame.
+	* This function will insert a GPU timestamp write just before the application starts its rendering.  This function
+	* will perform a vkQueueSubmit on Vulkan so must not be done simultaneously with VkQueue operations on another thread.
+	* Returns VRCompositorError_RequestFailed if SetExplicitTimingMode is not enabled. */
+	virtual EVRCompositorError SubmitExplicitTimingData() = 0;
+};
+
+static const char *const IVRCompositor_Version = "IVRCompositor_021";
+
+}  // namespace vr
+
+// ivrnotifications.h
+namespace vr
+{
+#pragma pack(push, 8)
+
+// Used for passing graphic data
+struct NotificationBitmap_t
+{
+	NotificationBitmap_t()
+		: m_pImageData(nullptr), m_nWidth(0), m_nHeight(0), m_nBytesPerPixel(0){};
+
+	void *m_pImageData;
+	int32_t m_nWidth;
+	int32_t m_nHeight;
+	int32_t m_nBytesPerPixel;
+};
+
+/** Be aware that the notification type is used as 'priority' to pick the next notification */
+enum EVRNotificationType
+{
+	/** Transient notifications are automatically hidden after a period of time set by the user. 
+	* They are used for things like information and chat messages that do not require user interaction. */
+	EVRNotificationType_Transient = 0,
+
+	/** Persistent notifications are shown to the user until they are hidden by calling RemoveNotification().
+	* They are used for things like phone calls and alarms that require user interaction. */
+	EVRNotificationType_Persistent = 1,
+
+	/** System notifications are shown no matter what. It is expected, that the ulUserValue is used as ID.
+	 * If there is already a system notification in the queue with that ID it is not accepted into the queue
+	 * to prevent spamming with system notification */
+	EVRNotificationType_Transient_SystemWithUserValue = 2,
+};
+
+enum EVRNotificationStyle
+{
+	/** Creates a notification with minimal external styling. */
+	EVRNotificationStyle_None = 0,
+
+	/** Used for notifications about overlay-level status. In Steam this is used for events like downloads completing. */
+	EVRNotificationStyle_Application = 100,
+
+	/** Used for notifications about contacts that are unknown or not available. In Steam this is used for friend invitations and offline friends. */
+	EVRNotificationStyle_Contact_Disabled = 200,
+
+	/** Used for notifications about contacts that are available but inactive. In Steam this is used for friends that are online but not playing a game. */
+	EVRNotificationStyle_Contact_Enabled = 201,
+
+	/** Used for notifications about contacts that are available and active. In Steam this is used for friends that are online and currently running a game. */
+	EVRNotificationStyle_Contact_Active = 202,
+};
+
+static const uint32_t k_unNotificationTextMaxSize = 256;
+
+typedef uint32_t VRNotificationId;
+
+#pragma pack(pop)
+
+/** Allows notification sources to interact with the VR system
+	This current interface is not yet implemented. Do not use yet. */
+class IVRNotifications
+{
+public:
+	/** Create a notification and enqueue it to be shown to the user.
+	* An overlay handle is required to create a notification, as otherwise it would be impossible for a user to act on it.
+	* To create a two-line notification, use a line break ('\n') to split the text into two lines.
+	* The pImage argument may be NULL, in which case the specified overlay's icon will be used instead. */
+	virtual EVRNotificationError CreateNotification(VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, EVRNotificationType type, const char *pchText, EVRNotificationStyle style, const NotificationBitmap_t *pImage, /* out */ VRNotificationId *pNotificationId) = 0;
+
+	/** Destroy a notification, hiding it first if it currently shown to the user. */
+	virtual EVRNotificationError RemoveNotification(VRNotificationId notificationId) = 0;
+};
+
+static const char *const IVRNotifications_Version = "IVRNotifications_002";
+
+}  // namespace vr
+
+// ivroverlay.h
+namespace vr
+{
+/** The maximum length of an overlay key in bytes, counting the terminating null character. */
+static const uint32_t k_unVROverlayMaxKeyLength = 128;
+
+/** The maximum length of an overlay name in bytes, counting the terminating null character. */
+static const uint32_t k_unVROverlayMaxNameLength = 128;
+
+/** The maximum number of overlays that can exist in the system at one time. */
+static const uint32_t k_unMaxOverlayCount = 64;
+
+/** The maximum number of overlay intersection mask primitives per overlay */
+static const uint32_t k_unMaxOverlayIntersectionMaskPrimitivesCount = 32;
+
+/** Types of input supported by VR Overlays */
+enum VROverlayInputMethod
+{
+	VROverlayInputMethod_None = 0,   // No input events will be generated automatically for this overlay
+	VROverlayInputMethod_Mouse = 1,  // Tracked controllers will get mouse events automatically
+};
+
+/** Allows the caller to figure out which overlay transform getter to call. */
+enum VROverlayTransformType
+{
+	VROverlayTransform_Absolute = 0,
+	VROverlayTransform_TrackedDeviceRelative = 1,
+	VROverlayTransform_SystemOverlay = 2,
+	VROverlayTransform_TrackedComponent = 3,
+};
+
+/** Overlay control settings */
+enum VROverlayFlags
+{
+	VROverlayFlags_None = 0,
+
+	// The following only take effect when rendered using the high quality render path (see SetHighQualityOverlay).
+	VROverlayFlags_Curved = 1,
+	VROverlayFlags_RGSS4X = 2,
+
+	// Set this flag on a dashboard overlay to prevent a tab from showing up for that overlay
+	VROverlayFlags_NoDashboardTab = 3,
+
+	// Set this flag on a dashboard that is able to deal with gamepad focus events
+	VROverlayFlags_AcceptsGamepadEvents = 4,
+
+	// Indicates that the overlay should dim/brighten to show gamepad focus
+	VROverlayFlags_ShowGamepadFocus = 5,
+
+	// When in VROverlayInputMethod_Mouse you can optionally enable sending VRScroll_t
+	VROverlayFlags_SendVRScrollEvents = 6,
+	VROverlayFlags_SendVRTouchpadEvents = 7,
+
+	// If set this will render a vertical scroll wheel on the primary controller,
+	//  only needed if not using VROverlayFlags_SendVRScrollEvents but you still want to represent a scroll wheel
+	VROverlayFlags_ShowTouchPadScrollWheel = 8,
+
+	// If this is set ownership and render access to the overlay are transferred
+	// to the new scene process on a call to IVRApplications::LaunchInternalProcess
+	VROverlayFlags_TransferOwnershipToInternalProcess = 9,
+
+	// If set, renders 50% of the texture in each eye, side by side
+	VROverlayFlags_SideBySide_Parallel = 10,  // Texture is left/right
+	VROverlayFlags_SideBySide_Crossed = 11,   // Texture is crossed and right/left
+
+	VROverlayFlags_Panorama = 12,        // Texture is a panorama
+	VROverlayFlags_StereoPanorama = 13,  // Texture is a stereo panorama
+
+	// If this is set on an overlay owned by the scene application that overlay
+	// will be sorted with the "Other" overlays on top of all other scene overlays
+	VROverlayFlags_SortWithNonSceneOverlays = 14,
+
+	// If set, the overlay will be shown in the dashboard, otherwise it will be hidden.
+	VROverlayFlags_VisibleInDashboard = 15,
+};
+
+enum VRMessageOverlayResponse
+{
+	VRMessageOverlayResponse_ButtonPress_0 = 0,
+	VRMessageOverlayResponse_ButtonPress_1 = 1,
+	VRMessageOverlayResponse_ButtonPress_2 = 2,
+	VRMessageOverlayResponse_ButtonPress_3 = 3,
+	VRMessageOverlayResponse_CouldntFindSystemOverlay = 4,
+	VRMessageOverlayResponse_CouldntFindOrCreateClientOverlay = 5,
+	VRMessageOverlayResponse_ApplicationQuit = 6
+};
+
+struct VROverlayIntersectionParams_t
+{
+	HmdVector3_t vSource;
+	HmdVector3_t vDirection;
+	ETrackingUniverseOrigin eOrigin;
+};
+
+struct VROverlayIntersectionResults_t
+{
+	HmdVector3_t vPoint;
+	HmdVector3_t vNormal;
+	HmdVector2_t vUVs;
+	float fDistance;
+};
+
+// Input modes for the Big Picture gamepad text entry
+enum EGamepadTextInputMode
+{
+	k_EGamepadTextInputModeNormal = 0,
+	k_EGamepadTextInputModePassword = 1,
+	k_EGamepadTextInputModeSubmit = 2,
+};
+
+// Controls number of allowed lines for the Big Picture gamepad text entry
+enum EGamepadTextInputLineMode
+{
+	k_EGamepadTextInputLineModeSingleLine = 0,
+	k_EGamepadTextInputLineModeMultipleLines = 1
+};
+
+/** Directions for changing focus between overlays with the gamepad */
+enum EOverlayDirection
+{
+	OverlayDirection_Up = 0,
+	OverlayDirection_Down = 1,
+	OverlayDirection_Left = 2,
+	OverlayDirection_Right = 3,
+
+	OverlayDirection_Count = 4,
+};
+
+enum EVROverlayIntersectionMaskPrimitiveType
+{
+	OverlayIntersectionPrimitiveType_Rectangle,
+	OverlayIntersectionPrimitiveType_Circle,
+};
+
+struct IntersectionMaskRectangle_t
+{
+	float m_flTopLeftX;
+	float m_flTopLeftY;
+	float m_flWidth;
+	float m_flHeight;
+};
+
+struct IntersectionMaskCircle_t
+{
+	float m_flCenterX;
+	float m_flCenterY;
+	float m_flRadius;
+};
+
+/** NOTE!!! If you change this you MUST manually update openvr_interop.cs.py and openvr_api_flat.h.py */
+typedef union {
+	IntersectionMaskRectangle_t m_Rectangle;
+	IntersectionMaskCircle_t m_Circle;
+} VROverlayIntersectionMaskPrimitive_Data_t;
+
+struct VROverlayIntersectionMaskPrimitive_t
+{
+	EVROverlayIntersectionMaskPrimitiveType m_nPrimitiveType;
+	VROverlayIntersectionMaskPrimitive_Data_t m_Primitive;
+};
+
+class IVROverlay
+{
+public:
+	// ---------------------------------------------
+	// Overlay management methods
+	// ---------------------------------------------
+
+	/** Finds an existing overlay with the specified key. */
+	virtual EVROverlayError FindOverlay(const char *pchOverlayKey, VROverlayHandle_t *pOverlayHandle) = 0;
+
+	/** Creates a new named overlay. All overlays start hidden and with default settings. */
+	virtual EVROverlayError CreateOverlay(const char *pchOverlayKey, const char *pchOverlayName, VROverlayHandle_t *pOverlayHandle) = 0;
+
+	/** Destroys the specified overlay. When an application calls VR_Shutdown all overlays created by that app are
+		* automatically destroyed. */
+	virtual EVROverlayError DestroyOverlay(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Specify which overlay to use the high quality render path.  This overlay will be composited in during the distortion pass which
+		* results in it drawing on top of everything else, but also at a higher quality as it samples the source texture directly rather than
+		* rasterizing into each eye's render texture first.  Because if this, only one of these is supported at any given time.  It is most useful
+		* for overlays that are expected to take up most of the user's view (e.g. streaming video).
+		* This mode does not support mouse input to your overlay. */
+	virtual EVROverlayError SetHighQualityOverlay(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Returns the overlay handle of the current overlay being rendered using the single high quality overlay render path.
+		* Otherwise it will return k_ulOverlayHandleInvalid. */
+	virtual vr::VROverlayHandle_t GetHighQualityOverlay() = 0;
+
+	/** Fills the provided buffer with the string key of the overlay. Returns the size of buffer required to store the key, including
+		* the terminating null character. k_unVROverlayMaxKeyLength will be enough bytes to fit the string. */
+	virtual uint32_t GetOverlayKey(VROverlayHandle_t ulOverlayHandle, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, EVROverlayError *pError = 0L) = 0;
+
+	/** Fills the provided buffer with the friendly name of the overlay. Returns the size of buffer required to store the key, including
+		* the terminating null character. k_unVROverlayMaxNameLength will be enough bytes to fit the string. */
+	virtual uint32_t GetOverlayName(VROverlayHandle_t ulOverlayHandle, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, EVROverlayError *pError = 0L) = 0;
+
+	/** set the name to use for this overlay */
+	virtual EVROverlayError SetOverlayName(VROverlayHandle_t ulOverlayHandle, const char *pchName) = 0;
+
+	/** Gets the raw image data from an overlay. Overlay image data is always returned as RGBA data, 4 bytes per pixel. If the buffer is not large enough, width and height 
+		* will be set and VROverlayError_ArrayTooSmall is returned. */
+	virtual EVROverlayError GetOverlayImageData(VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unBufferSize, uint32_t *punWidth, uint32_t *punHeight) = 0;
+
+	/** returns a string that corresponds with the specified overlay error. The string will be the name 
+		* of the error enum value for all valid error codes */
+	virtual const char *GetOverlayErrorNameFromEnum(EVROverlayError error) = 0;
+
+	// ---------------------------------------------
+	// Overlay rendering methods
+	// ---------------------------------------------
+
+	/** Sets the pid that is allowed to render to this overlay (the creator pid is always allow to render),
+		*	by default this is the pid of the process that made the overlay */
+	virtual EVROverlayError SetOverlayRenderingPid(VROverlayHandle_t ulOverlayHandle, uint32_t unPID) = 0;
+
+	/** Gets the pid that is allowed to render to this overlay */
+	virtual uint32_t GetOverlayRenderingPid(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Specify flag setting for a given overlay */
+	virtual EVROverlayError SetOverlayFlag(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = 0;
+
+	/** Sets flag setting for a given overlay */
+	virtual EVROverlayError GetOverlayFlag(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool *pbEnabled) = 0;
+
+	/** Sets the color tint of the overlay quad. Use 0.0 to 1.0 per channel. */
+	virtual EVROverlayError SetOverlayColor(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = 0;
+
+	/** Gets the color tint of the overlay quad. */
+	virtual EVROverlayError GetOverlayColor(VROverlayHandle_t ulOverlayHandle, float *pfRed, float *pfGreen, float *pfBlue) = 0;
+
+	/** Sets the alpha of the overlay quad. Use 1.0 for 100 percent opacity to 0.0 for 0 percent opacity. */
+	virtual EVROverlayError SetOverlayAlpha(VROverlayHandle_t ulOverlayHandle, float fAlpha) = 0;
+
+	/** Gets the alpha of the overlay quad. By default overlays are rendering at 100 percent alpha (1.0). */
+	virtual EVROverlayError GetOverlayAlpha(VROverlayHandle_t ulOverlayHandle, float *pfAlpha) = 0;
+
+	/** Sets the aspect ratio of the texels in the overlay. 1.0 means the texels are square. 2.0 means the texels
+		* are twice as wide as they are tall. Defaults to 1.0. */
+	virtual EVROverlayError SetOverlayTexelAspect(VROverlayHandle_t ulOverlayHandle, float fTexelAspect) = 0;
+
+	/** Gets the aspect ratio of the texels in the overlay. Defaults to 1.0 */
+	virtual EVROverlayError GetOverlayTexelAspect(VROverlayHandle_t ulOverlayHandle, float *pfTexelAspect) = 0;
+
+	/** Sets the rendering sort order for the overlay. Overlays are rendered this order:
+		*      Overlays owned by the scene application
+		*      Overlays owned by some other application
+		*
+		*	Within a category overlays are rendered lowest sort order to highest sort order. Overlays with the same 
+		*	sort order are rendered back to front base on distance from the HMD.
+		*
+		*	Sort order defaults to 0. */
+	virtual EVROverlayError SetOverlaySortOrder(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder) = 0;
+
+	/** Gets the sort order of the overlay. See SetOverlaySortOrder for how this works. */
+	virtual EVROverlayError GetOverlaySortOrder(VROverlayHandle_t ulOverlayHandle, uint32_t *punSortOrder) = 0;
+
+	/** Sets the width of the overlay quad in meters. By default overlays are rendered on a quad that is 1 meter across */
+	virtual EVROverlayError SetOverlayWidthInMeters(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = 0;
+
+	/** Returns the width of the overlay quad in meters. By default overlays are rendered on a quad that is 1 meter across */
+	virtual EVROverlayError GetOverlayWidthInMeters(VROverlayHandle_t ulOverlayHandle, float *pfWidthInMeters) = 0;
+
+	/** For high-quality curved overlays only, sets the distance range in meters from the overlay used to automatically curve
+		* the surface around the viewer.  Min is distance is when the surface will be most curved.  Max is when least curved. */
+	virtual EVROverlayError SetOverlayAutoCurveDistanceRangeInMeters(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = 0;
+
+	/** For high-quality curved overlays only, gets the distance range in meters from the overlay used to automatically curve
+		* the surface around the viewer.  Min is distance is when the surface will be most curved.  Max is when least curved. */
+	virtual EVROverlayError GetOverlayAutoCurveDistanceRangeInMeters(VROverlayHandle_t ulOverlayHandle, float *pfMinDistanceInMeters, float *pfMaxDistanceInMeters) = 0;
+
+	/** Sets the colorspace the overlay texture's data is in.  Defaults to 'auto'.
+		* If the texture needs to be resolved, you should call SetOverlayTexture with the appropriate colorspace instead. */
+	virtual EVROverlayError SetOverlayTextureColorSpace(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = 0;
+
+	/** Gets the overlay's current colorspace setting. */
+	virtual EVROverlayError GetOverlayTextureColorSpace(VROverlayHandle_t ulOverlayHandle, EColorSpace *peTextureColorSpace) = 0;
+
+	/** Sets the part of the texture to use for the overlay. UV Min is the upper left corner and UV Max is the lower right corner. */
+	virtual EVROverlayError SetOverlayTextureBounds(VROverlayHandle_t ulOverlayHandle, const VRTextureBounds_t *pOverlayTextureBounds) = 0;
+
+	/** Gets the part of the texture to use for the overlay. UV Min is the upper left corner and UV Max is the lower right corner. */
+	virtual EVROverlayError GetOverlayTextureBounds(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t *pOverlayTextureBounds) = 0;
+
+	/** Gets render model to draw behind this overlay */
+	virtual uint32_t GetOverlayRenderModel(vr::VROverlayHandle_t ulOverlayHandle, char *pchValue, uint32_t unBufferSize, HmdColor_t *pColor, vr::EVROverlayError *pError) = 0;
+
+	/** Sets render model to draw behind this overlay and the vertex color to use, pass null for pColor to match the overlays vertex color. 
+			The model is scaled by the same amount as the overlay, with a default of 1m. */
+	virtual vr::EVROverlayError SetOverlayRenderModel(vr::VROverlayHandle_t ulOverlayHandle, const char *pchRenderModel, const HmdColor_t *pColor) = 0;
+
+	/** Returns the transform type of this overlay. */
+	virtual EVROverlayError GetOverlayTransformType(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType *peTransformType) = 0;
+
+	/** Sets the transform to absolute tracking origin. */
+	virtual EVROverlayError SetOverlayTransformAbsolute(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, const HmdMatrix34_t *pmatTrackingOriginToOverlayTransform) = 0;
+
+	/** Gets the transform if it is absolute. Returns an error if the transform is some other type. */
+	virtual EVROverlayError GetOverlayTransformAbsolute(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin *peTrackingOrigin, HmdMatrix34_t *pmatTrackingOriginToOverlayTransform) = 0;
+
+	/** Sets the transform to relative to the transform of the specified tracked device. */
+	virtual EVROverlayError SetOverlayTransformTrackedDeviceRelative(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, const HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform) = 0;
+
+	/** Gets the transform if it is relative to a tracked device. Returns an error if the transform is some other type. */
+	virtual EVROverlayError GetOverlayTransformTrackedDeviceRelative(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punTrackedDevice, HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform) = 0;
+
+	/** Sets the transform to draw the overlay on a rendermodel component mesh instead of a quad. This will only draw when the system is
+		* drawing the device. Overlays with this transform type cannot receive mouse events. */
+	virtual EVROverlayError SetOverlayTransformTrackedDeviceComponent(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char *pchComponentName) = 0;
+
+	/** Gets the transform information when the overlay is rendering on a component. */
+	virtual EVROverlayError GetOverlayTransformTrackedDeviceComponent(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punDeviceIndex, char *pchComponentName, uint32_t unComponentNameSize) = 0;
+
+	/** Gets the transform if it is relative to another overlay. Returns an error if the transform is some other type. */
+	virtual vr::EVROverlayError GetOverlayTransformOverlayRelative(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t *ulOverlayHandleParent, HmdMatrix34_t *pmatParentOverlayToOverlayTransform) = 0;
+
+	/** Sets the transform to relative to the transform of the specified overlay. This overlays visibility will also track the parents visibility */
+	virtual vr::EVROverlayError SetOverlayTransformOverlayRelative(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, const HmdMatrix34_t *pmatParentOverlayToOverlayTransform) = 0;
+
+	/** Shows the VR overlay.  For dashboard overlays, only the Dashboard Manager is allowed to call this. */
+	virtual EVROverlayError ShowOverlay(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Hides the VR overlay.  For dashboard overlays, only the Dashboard Manager is allowed to call this. */
+	virtual EVROverlayError HideOverlay(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Returns true if the overlay is visible. */
+	virtual bool IsOverlayVisible(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Get the transform in 3d space associated with a specific 2d point in the overlay's coordinate space (where 0,0 is the lower left). -Z points out of the overlay */
+	virtual EVROverlayError GetTransformForOverlayCoordinates(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t *pmatTransform) = 0;
+
+	// ---------------------------------------------
+	// Overlay input methods
+	// ---------------------------------------------
+
+	/** Returns true and fills the event with the next event on the overlay's event queue, if there is one. 
+		* If there are no events this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct */
+	virtual bool PollNextOverlayEvent(VROverlayHandle_t ulOverlayHandle, VREvent_t *pEvent, uint32_t uncbVREvent) = 0;
+
+	/** Returns the current input settings for the specified overlay. */
+	virtual EVROverlayError GetOverlayInputMethod(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod *peInputMethod) = 0;
+
+	/** Sets the input settings for the specified overlay. */
+	virtual EVROverlayError SetOverlayInputMethod(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = 0;
+
+	/** Gets the mouse scaling factor that is used for mouse events. The actual texture may be a different size, but this is
+		* typically the size of the underlying UI in pixels. */
+	virtual EVROverlayError GetOverlayMouseScale(VROverlayHandle_t ulOverlayHandle, HmdVector2_t *pvecMouseScale) = 0;
+
+	/** Sets the mouse scaling factor that is used for mouse events. The actual texture may be a different size, but this is
+		* typically the size of the underlying UI in pixels (not in world space). */
+	virtual EVROverlayError SetOverlayMouseScale(VROverlayHandle_t ulOverlayHandle, const HmdVector2_t *pvecMouseScale) = 0;
+
+	/** Computes the overlay-space pixel coordinates of where the ray intersects the overlay with the
+		* specified settings. Returns false if there is no intersection. */
+	virtual bool ComputeOverlayIntersection(VROverlayHandle_t ulOverlayHandle, const VROverlayIntersectionParams_t *pParams, VROverlayIntersectionResults_t *pResults) = 0;
+
+	/** Processes mouse input from the specified controller as though it were a mouse pointed at a compositor overlay with the
+		* specified settings. The controller is treated like a laser pointer on the -z axis. The point where the laser pointer would
+		* intersect with the overlay is the mouse position, the trigger is left mouse, and the track pad is right mouse. 
+		*
+		* Return true if the controller is pointed at the overlay and an event was generated. */
+	virtual bool HandleControllerOverlayInteractionAsMouse(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = 0;
+
+	/** Returns true if the specified overlay is the hover target. An overlay is the hover target when it is the last overlay "moused over" 
+		* by the virtual mouse pointer */
+	virtual bool IsHoverTargetOverlay(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Returns the current Gamepad focus overlay */
+	virtual vr::VROverlayHandle_t GetGamepadFocusOverlay() = 0;
+
+	/** Sets the current Gamepad focus overlay */
+	virtual EVROverlayError SetGamepadFocusOverlay(VROverlayHandle_t ulNewFocusOverlay) = 0;
+
+	/** Sets an overlay's neighbor. This will also set the neighbor of the "to" overlay
+		* to point back to the "from" overlay. If an overlay's neighbor is set to invalid both
+		* ends will be cleared */
+	virtual EVROverlayError SetOverlayNeighbor(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo) = 0;
+
+	/** Changes the Gamepad focus from one overlay to one of its neighbors. Returns VROverlayError_NoNeighbor if there is no
+		* neighbor in that direction */
+	virtual EVROverlayError MoveGamepadFocusToNeighbor(EOverlayDirection eDirection, VROverlayHandle_t ulFrom) = 0;
+
+	// ---------------------------------------------
+	// Overlay texture methods
+	// ---------------------------------------------
+
+	/** Texture to draw for the overlay. This function can only be called by the overlay's creator or renderer process (see SetOverlayRenderingPid) .
+		*
+		* OpenGL dirty state:
+		*	glBindTexture
+		*/
+	virtual EVROverlayError SetOverlayTexture(VROverlayHandle_t ulOverlayHandle, const Texture_t *pTexture) = 0;
+
+	/** Use this to tell the overlay system to release the texture set for this overlay. */
+	virtual EVROverlayError ClearOverlayTexture(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Separate interface for providing the data as a stream of bytes, but there is an upper bound on data 
+		* that can be sent. This function can only be called by the overlay's renderer process. */
+	virtual EVROverlayError SetOverlayRaw(VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = 0;
+
+	/** Separate interface for providing the image through a filename: can be png or jpg, and should not be bigger than 1920x1080.
+		* This function can only be called by the overlay's renderer process */
+	virtual EVROverlayError SetOverlayFromFile(VROverlayHandle_t ulOverlayHandle, const char *pchFilePath) = 0;
+
+	/** Get the native texture handle/device for an overlay you have created.
+		* On windows this handle will be a ID3D11ShaderResourceView with a ID3D11Texture2D bound.
+		*
+		* The texture will always be sized to match the backing texture you supplied in SetOverlayTexture above.
+		*
+		* You MUST call ReleaseNativeOverlayHandle() with pNativeTextureHandle once you are done with this texture.
+		*
+		* pNativeTextureHandle is an OUTPUT, it will be a pointer to a ID3D11ShaderResourceView *.
+		* pNativeTextureRef is an INPUT and should be a ID3D11Resource *. The device used by pNativeTextureRef will be used to bind pNativeTextureHandle.
+		*/
+	virtual EVROverlayError GetOverlayTexture(VROverlayHandle_t ulOverlayHandle, void **pNativeTextureHandle, void *pNativeTextureRef, uint32_t *pWidth, uint32_t *pHeight, uint32_t *pNativeFormat, ETextureType *pAPIType, EColorSpace *pColorSpace, VRTextureBounds_t *pTextureBounds) = 0;
+
+	/** Release the pNativeTextureHandle provided from the GetOverlayTexture call, this allows the system to free the underlying GPU resources for this object,
+		* so only do it once you stop rendering this texture.
+		*/
+	virtual EVROverlayError ReleaseNativeOverlayHandle(VROverlayHandle_t ulOverlayHandle, void *pNativeTextureHandle) = 0;
+
+	/** Get the size of the overlay texture */
+	virtual EVROverlayError GetOverlayTextureSize(VROverlayHandle_t ulOverlayHandle, uint32_t *pWidth, uint32_t *pHeight) = 0;
+
+	// ----------------------------------------------
+	// Dashboard Overlay Methods
+	// ----------------------------------------------
+
+	/** Creates a dashboard overlay and returns its handle */
+	virtual EVROverlayError CreateDashboardOverlay(const char *pchOverlayKey, const char *pchOverlayFriendlyName, VROverlayHandle_t *pMainHandle, VROverlayHandle_t *pThumbnailHandle) = 0;
+
+	/** Returns true if the dashboard is visible */
+	virtual bool IsDashboardVisible() = 0;
+
+	/** returns true if the dashboard is visible and the specified overlay is the active system Overlay */
+	virtual bool IsActiveDashboardOverlay(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Sets the dashboard overlay to only appear when the specified process ID has scene focus */
+	virtual EVROverlayError SetDashboardOverlaySceneProcess(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = 0;
+
+	/** Gets the process ID that this dashboard overlay requires to have scene focus */
+	virtual EVROverlayError GetDashboardOverlaySceneProcess(VROverlayHandle_t ulOverlayHandle, uint32_t *punProcessId) = 0;
+
+	/** Shows the dashboard. */
+	virtual void ShowDashboard(const char *pchOverlayToShow) = 0;
+
+	/** Returns the tracked device that has the laser pointer in the dashboard */
+	virtual vr::TrackedDeviceIndex_t GetPrimaryDashboardDevice() = 0;
+
+	// ---------------------------------------------
+	// Keyboard methods
+	// ---------------------------------------------
+
+	/** Show the virtual keyboard to accept input **/
+	virtual EVROverlayError ShowKeyboard(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char *pchDescription, uint32_t unCharMax, const char *pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = 0;
+
+	virtual EVROverlayError ShowKeyboardForOverlay(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char *pchDescription, uint32_t unCharMax, const char *pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = 0;
+
+	/** Get the text that was entered into the text input **/
+	virtual uint32_t GetKeyboardText(VR_OUT_STRING() char *pchText, uint32_t cchText) = 0;
+
+	/** Hide the virtual keyboard **/
+	virtual void HideKeyboard() = 0;
+
+	/** Set the position of the keyboard in world space **/
+	virtual void SetKeyboardTransformAbsolute(ETrackingUniverseOrigin eTrackingOrigin, const HmdMatrix34_t *pmatTrackingOriginToKeyboardTransform) = 0;
+
+	/** Set the position of the keyboard in overlay space by telling it to avoid a rectangle in the overlay. Rectangle coords have (0,0) in the bottom left **/
+	virtual void SetKeyboardPositionForOverlay(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = 0;
+
+	// ---------------------------------------------
+	// Overlay input methods
+	// ---------------------------------------------
+
+	/** Sets a list of primitives to be used for controller ray intersection
+		* typically the size of the underlying UI in pixels (not in world space). */
+	virtual EVROverlayError SetOverlayIntersectionMask(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t *pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize = sizeof(VROverlayIntersectionMaskPrimitive_t)) = 0;
+
+	virtual EVROverlayError GetOverlayFlags(VROverlayHandle_t ulOverlayHandle, uint32_t *pFlags) = 0;
+
+	// ---------------------------------------------
+	// Message box methods
+	// ---------------------------------------------
+
+	/** Show the message overlay. This will block and return you a result. **/
+	virtual VRMessageOverlayResponse ShowMessageOverlay(const char *pchText, const char *pchCaption, const char *pchButton0Text, const char *pchButton1Text = nullptr, const char *pchButton2Text = nullptr, const char *pchButton3Text = nullptr) = 0;
+
+	/** If the calling process owns the overlay and it's open, this will close it. **/
+	virtual void CloseMessageOverlay() = 0;
+};
+
+static const char *const IVROverlay_Version = "IVROverlay_016";
+
+}  // namespace vr
+
+// ivrrendermodels.h
+namespace vr
+{
+static const char *const k_pch_Controller_Component_GDC2015 = "gdc2015";    // Canonical coordinate system of the gdc 2015 wired controller, provided for backwards compatibility
+static const char *const k_pch_Controller_Component_Base = "base";          // For controllers with an unambiguous 'base'.
+static const char *const k_pch_Controller_Component_Tip = "tip";            // For controllers with an unambiguous 'tip' (used for 'laser-pointing')
+static const char *const k_pch_Controller_Component_HandGrip = "handgrip";  // Neutral, ambidextrous hand-pose when holding controller. On plane between neutrally posed index finger and thumb
+static const char *const k_pch_Controller_Component_Status = "status";      // 1:1 aspect ratio status area, with canonical [0,1] uv mapping
+
+#pragma pack(push, 8)
+
+/** Errors that can occur with the VR compositor */
+enum EVRRenderModelError
+{
+	VRRenderModelError_None = 0,
+	VRRenderModelError_Loading = 100,
+	VRRenderModelError_NotSupported = 200,
+	VRRenderModelError_InvalidArg = 300,
+	VRRenderModelError_InvalidModel = 301,
+	VRRenderModelError_NoShapes = 302,
+	VRRenderModelError_MultipleShapes = 303,
+	VRRenderModelError_TooManyVertices = 304,
+	VRRenderModelError_MultipleTextures = 305,
+	VRRenderModelError_BufferTooSmall = 306,
+	VRRenderModelError_NotEnoughNormals = 307,
+	VRRenderModelError_NotEnoughTexCoords = 308,
+
+	VRRenderModelError_InvalidTexture = 400,
+};
+
+typedef uint32_t VRComponentProperties;
+
+enum EVRComponentProperty
+{
+	VRComponentProperty_IsStatic = (1 << 0),
+	VRComponentProperty_IsVisible = (1 << 1),
+	VRComponentProperty_IsTouched = (1 << 2),
+	VRComponentProperty_IsPressed = (1 << 3),
+	VRComponentProperty_IsScrolled = (1 << 4),
+};
+
+/** Describes state information about a render-model component, including transforms and other dynamic properties */
+struct RenderModel_ComponentState_t
+{
+	HmdMatrix34_t mTrackingToComponentRenderModel;  // Transform required when drawing the component render model
+	HmdMatrix34_t mTrackingToComponentLocal;        // Transform available for attaching to a local component coordinate system (-Z out from surface )
+	VRComponentProperties uProperties;
+};
+
+/** A single vertex in a render model */
+struct RenderModel_Vertex_t
+{
+	HmdVector3_t vPosition;  // position in meters in device space
+	HmdVector3_t vNormal;
+	float rfTextureCoord[2];
+};
+
+/** A texture map for use on a render model */
+#if defined(__linux__) || defined(__APPLE__)
+// This structure was originally defined mis-packed on Linux, preserved for
+// compatibility.
+#pragma pack(push, 4)
+#endif
+
+struct RenderModel_TextureMap_t
+{
+	uint16_t unWidth, unHeight;        // width and height of the texture map in pixels
+	const uint8_t *rubTextureMapData;  // Map texture data. All textures are RGBA with 8 bits per channel per pixel. Data size is width * height * 4ub
+};
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+
+/**  Session unique texture identifier. Rendermodels which share the same texture will have the same id.
+IDs <0 denote the texture is not present */
+
+typedef int32_t TextureID_t;
+
+const TextureID_t INVALID_TEXTURE_ID = -1;
+
+#if defined(__linux__) || defined(__APPLE__)
+// This structure was originally defined mis-packed on Linux, preserved for
+// compatibility.
+#pragma pack(push, 4)
+#endif
+
+struct RenderModel_t
+{
+	const RenderModel_Vertex_t *rVertexData;  // Vertex data for the mesh
+	uint32_t unVertexCount;                   // Number of vertices in the vertex data
+	const uint16_t *rIndexData;               // Indices into the vertex data for each triangle
+	uint32_t unTriangleCount;                 // Number of triangles in the mesh. Index count is 3 * TriangleCount
+	TextureID_t diffuseTextureId;             // Session unique texture identifier. Rendermodels which share the same texture will have the same id. <0 == texture not present
+};
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+
+struct RenderModel_ControllerMode_State_t
+{
+	bool bScrollWheelVisible;  // is this controller currently set to be in a scroll wheel mode
+};
+
+#pragma pack(pop)
+
+class IVRRenderModels
+{
+public:
+	/** Loads and returns a render model for use in the application. pchRenderModelName should be a render model name
+	* from the Prop_RenderModelName_String property or an absolute path name to a render model on disk. 
+	*
+	* The resulting render model is valid until VR_Shutdown() is called or until FreeRenderModel() is called. When the 
+	* application is finished with the render model it should call FreeRenderModel() to free the memory associated
+	* with the model.
+	*
+	* The method returns VRRenderModelError_Loading while the render model is still being loaded.
+	* The method returns VRRenderModelError_None once loaded successfully, otherwise will return an error. */
+	virtual EVRRenderModelError LoadRenderModel_Async(const char *pchRenderModelName, RenderModel_t **ppRenderModel) = 0;
+
+	/** Frees a previously returned render model
+	*   It is safe to call this on a null ptr. */
+	virtual void FreeRenderModel(RenderModel_t *pRenderModel) = 0;
+
+	/** Loads and returns a texture for use in the application. */
+	virtual EVRRenderModelError LoadTexture_Async(TextureID_t textureId, RenderModel_TextureMap_t **ppTexture) = 0;
+
+	/** Frees a previously returned texture
+	*   It is safe to call this on a null ptr. */
+	virtual void FreeTexture(RenderModel_TextureMap_t *pTexture) = 0;
+
+	/** Creates a D3D11 texture and loads data into it. */
+	virtual EVRRenderModelError LoadTextureD3D11_Async(TextureID_t textureId, void *pD3D11Device, void **ppD3D11Texture2D) = 0;
+
+	/** Helper function to copy the bits into an existing texture. */
+	virtual EVRRenderModelError LoadIntoTextureD3D11_Async(TextureID_t textureId, void *pDstTexture) = 0;
+
+	/** Use this to free textures created with LoadTextureD3D11_Async instead of calling Release on them. */
+	virtual void FreeTextureD3D11(void *pD3D11Texture2D) = 0;
+
+	/** Use this to get the names of available render models.  Index does not correlate to a tracked device index, but
+	* is only used for iterating over all available render models.  If the index is out of range, this function will return 0.
+	* Otherwise, it will return the size of the buffer required for the name. */
+	virtual uint32_t GetRenderModelName(uint32_t unRenderModelIndex, VR_OUT_STRING() char *pchRenderModelName, uint32_t unRenderModelNameLen) = 0;
+
+	/** Returns the number of available render models. */
+	virtual uint32_t GetRenderModelCount() = 0;
+
+	/** Returns the number of components of the specified render model.
+	*  Components are useful when client application wish to draw, label, or otherwise interact with components of tracked objects.
+	*  Examples controller components:
+	*   renderable things such as triggers, buttons
+	*   non-renderable things which include coordinate systems such as 'tip', 'base', a neutral controller agnostic hand-pose
+	*   If all controller components are enumerated and rendered, it will be equivalent to drawing the traditional render model
+	*   Returns 0 if components not supported, >0 otherwise */
+	virtual uint32_t GetComponentCount(const char *pchRenderModelName) = 0;
+
+	/** Use this to get the names of available components.  Index does not correlate to a tracked device index, but
+	* is only used for iterating over all available components.  If the index is out of range, this function will return 0.
+	* Otherwise, it will return the size of the buffer required for the name. */
+	virtual uint32_t GetComponentName(const char *pchRenderModelName, uint32_t unComponentIndex, VR_OUT_STRING() char *pchComponentName, uint32_t unComponentNameLen) = 0;
+
+	/** Get the button mask for all buttons associated with this component
+	*   If no buttons (or axes) are associated with this component, return 0
+	*   Note: multiple components may be associated with the same button. Ex: two grip buttons on a single controller.
+	*   Note: A single component may be associated with multiple buttons. Ex: A trackpad which also provides "D-pad" functionality */
+	virtual uint64_t GetComponentButtonMask(const char *pchRenderModelName, const char *pchComponentName) = 0;
+
+	/** Use this to get the render model name for the specified rendermode/component combination, to be passed to LoadRenderModel.
+	* If the component name is out of range, this function will return 0.
+	* Otherwise, it will return the size of the buffer required for the name. */
+	virtual uint32_t GetComponentRenderModelName(const char *pchRenderModelName, const char *pchComponentName, VR_OUT_STRING() char *pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen) = 0;
+
+	/** Use this to query information about the component, as a function of the controller state.
+	*
+	* For dynamic controller components (ex: trigger) values will reflect component motions
+	* For static components this will return a consistent value independent of the VRControllerState_t
+	*
+	* If the pchRenderModelName or pchComponentName is invalid, this will return false (and transforms will be set to identity).
+	* Otherwise, return true
+	* Note: For dynamic objects, visibility may be dynamic. (I.e., true/false will be returned based on controller state and controller mode state ) */
+	virtual bool GetComponentState(const char *pchRenderModelName, const char *pchComponentName, const vr::VRControllerState_t *pControllerState, const RenderModel_ControllerMode_State_t *pState, RenderModel_ComponentState_t *pComponentState) = 0;
+
+	/** Returns true if the render model has a component with the specified name */
+	virtual bool RenderModelHasComponent(const char *pchRenderModelName, const char *pchComponentName) = 0;
+
+	/** Returns the URL of the thumbnail image for this rendermodel */
+	virtual uint32_t GetRenderModelThumbnailURL(const char *pchRenderModelName, VR_OUT_STRING() char *pchThumbnailURL, uint32_t unThumbnailURLLen, vr::EVRRenderModelError *peError) = 0;
+
+	/** Provides a render model path that will load the unskinned model if the model name provided has been replace by the user. If the model
+	* hasn't been replaced the path value will still be a valid path to load the model. Pass this to LoadRenderModel_Async, etc. to load the
+	* model. */
+	virtual uint32_t GetRenderModelOriginalPath(const char *pchRenderModelName, VR_OUT_STRING() char *pchOriginalPath, uint32_t unOriginalPathLen, vr::EVRRenderModelError *peError) = 0;
+
+	/** Returns a string for a render model error */
+	virtual const char *GetRenderModelErrorNameFromEnum(vr::EVRRenderModelError error) = 0;
+};
+
+static const char *const IVRRenderModels_Version = "IVRRenderModels_005";
+
+}  // namespace vr
+
+// ivrextendeddisplay.h
+namespace vr
+{
+/** NOTE: Use of this interface is not recommended in production applications. It will not work for displays which use
+	* direct-to-display mode. Creating our own window is also incompatible with the VR compositor and is not available when the compositor is running. */
+class IVRExtendedDisplay
+{
+public:
+	/** Size and position that the window needs to be on the VR display. */
+	virtual void GetWindowBounds(int32_t *pnX, int32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight) = 0;
+
+	/** Gets the viewport in the frame buffer to draw the output of the distortion into */
+	virtual void GetEyeOutputViewport(EVREye eEye, uint32_t *pnX, uint32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight) = 0;
+
+	/** [D3D10/11 Only]
+		* Returns the adapter index and output index that the user should pass into EnumAdapters and EnumOutputs
+		* to create the device and swap chain in DX10 and DX11. If an error occurs both indices will be set to -1.
+		*/
+	virtual void GetDXGIOutputInfo(int32_t *pnAdapterIndex, int32_t *pnAdapterOutputIndex) = 0;
+};
+
+static const char *const IVRExtendedDisplay_Version = "IVRExtendedDisplay_001";
+
+}  // namespace vr
+
+// ivrtrackedcamera.h
+namespace vr
+{
+class IVRTrackedCamera
+{
+public:
+	/** Returns a string for an error */
+	virtual const char *GetCameraErrorNameFromEnum(vr::EVRTrackedCameraError eCameraError) = 0;
+
+	/** For convenience, same as tracked property request Prop_HasCamera_Bool */
+	virtual vr::EVRTrackedCameraError HasCamera(vr::TrackedDeviceIndex_t nDeviceIndex, bool *pHasCamera) = 0;
+
+	/** Gets size of the image frame. */
+	virtual vr::EVRTrackedCameraError GetCameraFrameSize(vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, uint32_t *pnWidth, uint32_t *pnHeight, uint32_t *pnFrameBufferSize) = 0;
+
+	virtual vr::EVRTrackedCameraError GetCameraIntrinsics(vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, vr::HmdVector2_t *pFocalLength, vr::HmdVector2_t *pCenter) = 0;
+
+	virtual vr::EVRTrackedCameraError GetCameraProjection(vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, vr::HmdMatrix44_t *pProjection) = 0;
+
+	/** Acquiring streaming service permits video streaming for the caller. Releasing hints the system that video services do not need to be maintained for this client.
+	* If the camera has not already been activated, a one time spin up may incur some auto exposure as well as initial streaming frame delays.
+	* The camera should be considered a global resource accessible for shared consumption but not exclusive to any caller.
+	* The camera may go inactive due to lack of active consumers or headset idleness. */
+	virtual vr::EVRTrackedCameraError AcquireVideoStreamingService(vr::TrackedDeviceIndex_t nDeviceIndex, vr::TrackedCameraHandle_t *pHandle) = 0;
+	virtual vr::EVRTrackedCameraError ReleaseVideoStreamingService(vr::TrackedCameraHandle_t hTrackedCamera) = 0;
+
+	/** Copies the image frame into a caller's provided buffer. The image data is currently provided as RGBA data, 4 bytes per pixel.
+	* A caller can provide null for the framebuffer or frameheader if not desired. Requesting the frame header first, followed by the frame buffer allows
+	* the caller to determine if the frame as advanced per the frame header sequence. 
+	* If there is no frame available yet, due to initial camera spinup or re-activation, the error will be VRTrackedCameraError_NoFrameAvailable.
+	* Ideally a caller should be polling at ~16ms intervals */
+	virtual vr::EVRTrackedCameraError GetVideoStreamFrameBuffer(vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, void *pFrameBuffer, uint32_t nFrameBufferSize, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize) = 0;
+
+	/** Gets size of the image frame. */
+	virtual vr::EVRTrackedCameraError GetVideoStreamTextureSize(vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, vr::VRTextureBounds_t *pTextureBounds, uint32_t *pnWidth, uint32_t *pnHeight) = 0;
+
+	/** Access a shared D3D11 texture for the specified tracked camera stream.
+	* The camera frame type VRTrackedCameraFrameType_Undistorted is not supported directly as a shared texture. It is an interior subregion of the shared texture VRTrackedCameraFrameType_MaximumUndistorted.
+	* Instead, use GetVideoStreamTextureSize() with VRTrackedCameraFrameType_Undistorted to determine the proper interior subregion bounds along with GetVideoStreamTextureD3D11() with
+	* VRTrackedCameraFrameType_MaximumUndistorted to provide the texture. The VRTrackedCameraFrameType_MaximumUndistorted will yield an image where the invalid regions are decoded
+	* by the alpha channel having a zero component. The valid regions all have a non-zero alpha component. The subregion as described by VRTrackedCameraFrameType_Undistorted 
+	* guarantees a rectangle where all pixels are valid. */
+	virtual vr::EVRTrackedCameraError GetVideoStreamTextureD3D11(vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize) = 0;
+
+	/** Access a shared GL texture for the specified tracked camera stream */
+	virtual vr::EVRTrackedCameraError GetVideoStreamTextureGL(vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, vr::glUInt_t *pglTextureId, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize) = 0;
+	virtual vr::EVRTrackedCameraError ReleaseVideoStreamTextureGL(vr::TrackedCameraHandle_t hTrackedCamera, vr::glUInt_t glTextureId) = 0;
+};
+
+static const char *const IVRTrackedCamera_Version = "IVRTrackedCamera_003";
+
+}  // namespace vr
+
+// ivrscreenshots.h
+namespace vr
+{
+/** Errors that can occur with the VR compositor */
+enum EVRScreenshotError
+{
+	VRScreenshotError_None = 0,
+	VRScreenshotError_RequestFailed = 1,
+	VRScreenshotError_IncompatibleVersion = 100,
+	VRScreenshotError_NotFound = 101,
+	VRScreenshotError_BufferTooSmall = 102,
+	VRScreenshotError_ScreenshotAlreadyInProgress = 108,
+};
+
+/** Allows the application to generate screenshots */
+class IVRScreenshots
+{
+public:
+	/** Request a screenshot of the requested type.
+	 *  A request of the VRScreenshotType_Stereo type will always
+	 *  work. Other types will depend on the underlying application
+	 *  support.
+	 *  The first file name is for the preview image and should be a
+	 *  regular screenshot (ideally from the left eye). The second
+	 *  is the VR screenshot in the correct format. They should be
+	 *  in the same aspect ratio.  Formats per type:
+	 *  VRScreenshotType_Mono: the VR filename is ignored (can be
+	 *  nullptr), this is a normal flat single shot.
+	 *  VRScreenshotType_Stereo:  The VR image should be a
+	 *  side-by-side with the left eye image on the left.
+	 *  VRScreenshotType_Cubemap: The VR image should be six square
+	 *  images composited horizontally.
+	 *  VRScreenshotType_StereoPanorama: above/below with left eye
+	 *  panorama being the above image.  Image is typically square
+	 *  with the panorama being 2x horizontal.
+	 *  
+	 *  Note that the VR dashboard will call this function when
+	 *  the user presses the screenshot binding (currently System
+	 *  Button + Trigger).  If Steam is running, the destination
+	 *  file names will be in %TEMP% and will be copied into
+	 *  Steam's screenshot library for the running application
+	 *  once SubmitScreenshot() is called.
+	 *  If Steam is not running, the paths will be in the user's
+	 *  documents folder under Documents\SteamVR\Screenshots.
+	 *  Other VR applications can call this to initiate a
+	 *  screenshot outside of user control.
+	 *  The destination file names do not need an extension,
+	 *  will be replaced with the correct one for the format
+	 *  which is currently .png. */
+	virtual vr::EVRScreenshotError RequestScreenshot(vr::ScreenshotHandle_t *pOutScreenshotHandle, vr::EVRScreenshotType type, const char *pchPreviewFilename, const char *pchVRFilename) = 0;
+
+	/** Called by the running VR application to indicate that it
+	 *  wishes to be in charge of screenshots.  If the
+	 *  application does not call this, the Compositor will only
+	 *  support VRScreenshotType_Stereo screenshots that will be
+	 *  captured without notification to the running app.
+	 *  Once hooked your application will receive a
+	 *  VREvent_RequestScreenshot event when the user presses the
+	 *  buttons to take a screenshot. */
+	virtual vr::EVRScreenshotError HookScreenshot(VR_ARRAY_COUNT(numTypes) const vr::EVRScreenshotType *pSupportedTypes, int numTypes) = 0;
+
+	/** When your application receives a
+	 *  VREvent_RequestScreenshot event, call these functions to get
+	 *  the details of the screenshot request. */
+	virtual vr::EVRScreenshotType GetScreenshotPropertyType(vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotError *pError) = 0;
+
+	/** Get the filename for the preview or vr image (see
+	 *  vr::EScreenshotPropertyFilenames).  The return value is
+	 *  the size of the string.   */
+	virtual uint32_t GetScreenshotPropertyFilename(vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotPropertyFilenames filenameType, VR_OUT_STRING() char *pchFilename, uint32_t cchFilename, vr::EVRScreenshotError *pError) = 0;
+
+	/** Call this if the application is taking the screen shot
+	 *  will take more than a few ms processing. This will result
+	 *  in an overlay being presented that shows a completion
+	 *  bar. */
+	virtual vr::EVRScreenshotError UpdateScreenshotProgress(vr::ScreenshotHandle_t screenshotHandle, float flProgress) = 0;
+
+	/** Tells the compositor to take an internal screenshot of
+	 *  type VRScreenshotType_Stereo. It will take the current
+	 *  submitted scene textures of the running application and
+	 *  write them into the preview image and a side-by-side file
+	 *  for the VR image.
+	 *  This is similar to request screenshot, but doesn't ever
+	 *  talk to the application, just takes the shot and submits. */
+	virtual vr::EVRScreenshotError TakeStereoScreenshot(vr::ScreenshotHandle_t *pOutScreenshotHandle, const char *pchPreviewFilename, const char *pchVRFilename) = 0;
+
+	/** Submit the completed screenshot.  If Steam is running
+	 *  this will call into the Steam client and upload the
+	 *  screenshot to the screenshots section of the library for
+	 *  the running application.  If Steam is not running, this
+	 *  function will display a notification to the user that the
+	 *  screenshot was taken. The paths should be full paths with
+	 *  extensions.
+	 *  File paths should be absolute including extensions.
+	 *  screenshotHandle can be k_unScreenshotHandleInvalid if this
+	 *  was a new shot taking by the app to be saved and not
+	 *  initiated by a user (achievement earned or something) */
+	virtual vr::EVRScreenshotError SubmitScreenshot(vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotType type, const char *pchSourcePreviewFilename, const char *pchSourceVRFilename) = 0;
+};
+
+static const char *const IVRScreenshots_Version = "IVRScreenshots_001";
+
+}  // namespace vr
+
+// ivrresources.h
+namespace vr
+{
+class IVRResources
+{
+public:
+	// ------------------------------------
+	// Shared Resource Methods
+	// ------------------------------------
+
+	/** Loads the specified resource into the provided buffer if large enough.
+	* Returns the size in bytes of the buffer required to hold the specified resource. */
+	virtual uint32_t LoadSharedResource(const char *pchResourceName, char *pchBuffer, uint32_t unBufferLen) = 0;
+
+	/** Provides the full path to the specified resource. Resource names can include named directories for
+	* drivers and other things, and this resolves all of those and returns the actual physical path. 
+	* pchResourceTypeDirectory is the subdirectory of resources to look in. */
+	virtual uint32_t GetResourceFullPath(const char *pchResourceName, const char *pchResourceTypeDirectory, char *pchPathBuffer, uint32_t unBufferLen) = 0;
+};
+
+static const char *const IVRResources_Version = "IVRResources_001";
+
+}  // namespace vr
+// ivrdrivermanager.h
+namespace vr
+{
+class IVRDriverManager
+{
+public:
+	virtual uint32_t GetDriverCount() const = 0;
+
+	/** Returns the length of the number of bytes necessary to hold this string including the trailing null. */
+	virtual uint32_t GetDriverName(vr::DriverId_t nDriver, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize) = 0;
+};
+
+static const char *const IVRDriverManager_Version = "IVRDriverManager_001";
+
+}  // namespace vr
+
+// End
+
+#endif  // _OPENVR_API
+
+namespace vr
+{
+/** Finds the active installation of the VR API and initializes it. The provided path must be absolute
+	* or relative to the current working directory. These are the local install versions of the equivalent
+	* functions in steamvr.h and will work without a local Steam install.
+	*
+	* This path is to the "root" of the VR API install. That's the directory with
+	* the "drivers" directory and a platform (i.e. "win32") directory in it, not the directory with the DLL itself.
+	*
+	* pStartupInfo is reserved for future use.
+	*/
+inline IVRSystem *VR_Init(EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo = nullptr);
+
+/** unloads vrclient.dll. Any interface pointers from the interface are
+	* invalid after this point */
+inline void VR_Shutdown();
+
+/** Returns true if there is an HMD attached. This check is as lightweight as possible and
+	* can be called outside of VR_Init/VR_Shutdown. It should be used when an application wants
+	* to know if initializing VR is a possibility but isn't ready to take that step yet.
+	*/
+VR_INTERFACE bool VR_CALLTYPE VR_IsHmdPresent();
+
+/** Returns true if the OpenVR runtime is installed. */
+VR_INTERFACE bool VR_CALLTYPE VR_IsRuntimeInstalled();
+
+/** Returns where the OpenVR runtime is installed. */
+VR_INTERFACE const char *VR_CALLTYPE VR_RuntimePath();
+
+/** Returns the name of the enum value for an EVRInitError. This function may be called outside of VR_Init()/VR_Shutdown(). */
+VR_INTERFACE const char *VR_CALLTYPE VR_GetVRInitErrorAsSymbol(EVRInitError error);
+
+/** Returns an English string for an EVRInitError. Applications should call VR_GetVRInitErrorAsSymbol instead and
+	* use that as a key to look up their own localized error message. This function may be called outside of VR_Init()/VR_Shutdown(). */
+VR_INTERFACE const char *VR_CALLTYPE VR_GetVRInitErrorAsEnglishDescription(EVRInitError error);
+
+/** Returns the interface of the specified version. This method must be called after VR_Init. The
+	* pointer returned is valid until VR_Shutdown is called.
+	*/
+VR_INTERFACE void *VR_CALLTYPE VR_GetGenericInterface(const char *pchInterfaceVersion, EVRInitError *peError);
+
+/** Returns whether the interface of the specified version exists.
+	*/
+VR_INTERFACE bool VR_CALLTYPE VR_IsInterfaceVersionValid(const char *pchInterfaceVersion);
+
+/** Returns a token that represents whether the VR interface handles need to be reloaded */
+VR_INTERFACE uint32_t VR_CALLTYPE VR_GetInitToken();
+
+// These typedefs allow old enum names from SDK 0.9.11 to be used in applications.
+// They will go away in the future.
+typedef EVRInitError HmdError;
+typedef EVREye Hmd_Eye;
+typedef EColorSpace ColorSpace;
+typedef ETrackingResult HmdTrackingResult;
+typedef ETrackedDeviceClass TrackedDeviceClass;
+typedef ETrackingUniverseOrigin TrackingUniverseOrigin;
+typedef ETrackedDeviceProperty TrackedDeviceProperty;
+typedef ETrackedPropertyError TrackedPropertyError;
+typedef EVRSubmitFlags VRSubmitFlags_t;
+typedef EVRState VRState_t;
+typedef ECollisionBoundsStyle CollisionBoundsStyle_t;
+typedef EVROverlayError VROverlayError;
+typedef EVRFirmwareError VRFirmwareError;
+typedef EVRCompositorError VRCompositorError;
+typedef EVRScreenshotError VRScreenshotsError;
+
+inline uint32_t &VRToken()
+{
+	static uint32_t token;
+	return token;
+}
+
+class COpenVRContext
+{
+public:
+	COpenVRContext() { Clear(); }
+	void Clear();
+
+	inline void CheckClear()
+	{
+		if (VRToken() != VR_GetInitToken())
+		{
+			Clear();
+			VRToken() = VR_GetInitToken();
+		}
+	}
+
+	IVRSystem *VRSystem()
+	{
+		CheckClear();
+		if (m_pVRSystem == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRSystem = (IVRSystem *)VR_GetGenericInterface(IVRSystem_Version, &eError);
+		}
+		return m_pVRSystem;
+	}
+	IVRChaperone *VRChaperone()
+	{
+		CheckClear();
+		if (m_pVRChaperone == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRChaperone = (IVRChaperone *)VR_GetGenericInterface(IVRChaperone_Version, &eError);
+		}
+		return m_pVRChaperone;
+	}
+
+	IVRChaperoneSetup *VRChaperoneSetup()
+	{
+		CheckClear();
+		if (m_pVRChaperoneSetup == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRChaperoneSetup = (IVRChaperoneSetup *)VR_GetGenericInterface(IVRChaperoneSetup_Version, &eError);
+		}
+		return m_pVRChaperoneSetup;
+	}
+
+	IVRCompositor *VRCompositor()
+	{
+		CheckClear();
+		if (m_pVRCompositor == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRCompositor = (IVRCompositor *)VR_GetGenericInterface(IVRCompositor_Version, &eError);
+		}
+		return m_pVRCompositor;
+	}
+
+	IVROverlay *VROverlay()
+	{
+		CheckClear();
+		if (m_pVROverlay == nullptr)
+		{
+			EVRInitError eError;
+			m_pVROverlay = (IVROverlay *)VR_GetGenericInterface(IVROverlay_Version, &eError);
+		}
+		return m_pVROverlay;
+	}
+
+	IVRResources *VRResources()
+	{
+		CheckClear();
+		if (m_pVRResources == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRResources = (IVRResources *)VR_GetGenericInterface(IVRResources_Version, &eError);
+		}
+		return m_pVRResources;
+	}
+
+	IVRScreenshots *VRScreenshots()
+	{
+		CheckClear();
+		if (m_pVRScreenshots == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRScreenshots = (IVRScreenshots *)VR_GetGenericInterface(IVRScreenshots_Version, &eError);
+		}
+		return m_pVRScreenshots;
+	}
+
+	IVRRenderModels *VRRenderModels()
+	{
+		CheckClear();
+		if (m_pVRRenderModels == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRRenderModels = (IVRRenderModels *)VR_GetGenericInterface(IVRRenderModels_Version, &eError);
+		}
+		return m_pVRRenderModels;
+	}
+
+	IVRExtendedDisplay *VRExtendedDisplay()
+	{
+		CheckClear();
+		if (m_pVRExtendedDisplay == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRExtendedDisplay = (IVRExtendedDisplay *)VR_GetGenericInterface(IVRExtendedDisplay_Version, &eError);
+		}
+		return m_pVRExtendedDisplay;
+	}
+
+	IVRSettings *VRSettings()
+	{
+		CheckClear();
+		if (m_pVRSettings == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRSettings = (IVRSettings *)VR_GetGenericInterface(IVRSettings_Version, &eError);
+		}
+		return m_pVRSettings;
+	}
+
+	IVRApplications *VRApplications()
+	{
+		CheckClear();
+		if (m_pVRApplications == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRApplications = (IVRApplications *)VR_GetGenericInterface(IVRApplications_Version, &eError);
+		}
+		return m_pVRApplications;
+	}
+
+	IVRTrackedCamera *VRTrackedCamera()
+	{
+		CheckClear();
+		if (m_pVRTrackedCamera == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRTrackedCamera = (IVRTrackedCamera *)VR_GetGenericInterface(IVRTrackedCamera_Version, &eError);
+		}
+		return m_pVRTrackedCamera;
+	}
+
+	IVRDriverManager *VRDriverManager()
+	{
+		CheckClear();
+		if (!m_pVRDriverManager)
+		{
+			EVRInitError eError;
+			m_pVRDriverManager = (IVRDriverManager *)VR_GetGenericInterface(IVRDriverManager_Version, &eError);
+		}
+		return m_pVRDriverManager;
+	}
+
+private:
+	IVRSystem *m_pVRSystem;
+	IVRChaperone *m_pVRChaperone;
+	IVRChaperoneSetup *m_pVRChaperoneSetup;
+	IVRCompositor *m_pVRCompositor;
+	IVROverlay *m_pVROverlay;
+	IVRResources *m_pVRResources;
+	IVRRenderModels *m_pVRRenderModels;
+	IVRExtendedDisplay *m_pVRExtendedDisplay;
+	IVRSettings *m_pVRSettings;
+	IVRApplications *m_pVRApplications;
+	IVRTrackedCamera *m_pVRTrackedCamera;
+	IVRScreenshots *m_pVRScreenshots;
+	IVRDriverManager *m_pVRDriverManager;
+};
+
+inline COpenVRContext &OpenVRInternal_ModuleContext()
+{
+	static void *ctx[sizeof(COpenVRContext) / sizeof(void *)];
+	return *(COpenVRContext *)ctx;  // bypass zero-init constructor
+}
+
+inline IVRSystem *VR_CALLTYPE VRSystem() { return OpenVRInternal_ModuleContext().VRSystem(); }
+inline IVRChaperone *VR_CALLTYPE VRChaperone() { return OpenVRInternal_ModuleContext().VRChaperone(); }
+inline IVRChaperoneSetup *VR_CALLTYPE VRChaperoneSetup() { return OpenVRInternal_ModuleContext().VRChaperoneSetup(); }
+inline IVRCompositor *VR_CALLTYPE VRCompositor() { return OpenVRInternal_ModuleContext().VRCompositor(); }
+inline IVROverlay *VR_CALLTYPE VROverlay() { return OpenVRInternal_ModuleContext().VROverlay(); }
+inline IVRScreenshots *VR_CALLTYPE VRScreenshots() { return OpenVRInternal_ModuleContext().VRScreenshots(); }
+inline IVRRenderModels *VR_CALLTYPE VRRenderModels() { return OpenVRInternal_ModuleContext().VRRenderModels(); }
+inline IVRApplications *VR_CALLTYPE VRApplications() { return OpenVRInternal_ModuleContext().VRApplications(); }
+inline IVRSettings *VR_CALLTYPE VRSettings() { return OpenVRInternal_ModuleContext().VRSettings(); }
+inline IVRResources *VR_CALLTYPE VRResources() { return OpenVRInternal_ModuleContext().VRResources(); }
+inline IVRExtendedDisplay *VR_CALLTYPE VRExtendedDisplay() { return OpenVRInternal_ModuleContext().VRExtendedDisplay(); }
+inline IVRTrackedCamera *VR_CALLTYPE VRTrackedCamera() { return OpenVRInternal_ModuleContext().VRTrackedCamera(); }
+inline IVRDriverManager *VR_CALLTYPE VRDriverManager() { return OpenVRInternal_ModuleContext().VRDriverManager(); }
+
+inline void COpenVRContext::Clear()
+{
+	m_pVRSystem = nullptr;
+	m_pVRChaperone = nullptr;
+	m_pVRChaperoneSetup = nullptr;
+	m_pVRCompositor = nullptr;
+	m_pVROverlay = nullptr;
+	m_pVRRenderModels = nullptr;
+	m_pVRExtendedDisplay = nullptr;
+	m_pVRSettings = nullptr;
+	m_pVRApplications = nullptr;
+	m_pVRTrackedCamera = nullptr;
+	m_pVRResources = nullptr;
+	m_pVRScreenshots = nullptr;
+	m_pVRDriverManager = nullptr;
+}
+
+VR_INTERFACE uint32_t VR_CALLTYPE VR_InitInternal2(EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo);
+VR_INTERFACE void VR_CALLTYPE VR_ShutdownInternal();
+
+/** Finds the active installation of vrclient.dll and initializes it */
+inline IVRSystem *VR_Init(EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo)
+{
+	IVRSystem *pVRSystem = nullptr;
+
+	EVRInitError eError;
+	VRToken() = VR_InitInternal2(&eError, eApplicationType, pStartupInfo);
+	COpenVRContext &ctx = OpenVRInternal_ModuleContext();
+	ctx.Clear();
+
+	if (eError == VRInitError_None)
+	{
+		if (VR_IsInterfaceVersionValid(IVRSystem_Version))
+		{
+			pVRSystem = VRSystem();
+		}
+		else
+		{
+			VR_ShutdownInternal();
+			eError = VRInitError_Init_InterfaceNotFound;
+		}
+	}
+
+	if (peError)
+		*peError = eError;
+	return pVRSystem;
+}
+
+/** unloads vrclient.dll. Any interface pointers from the interface are
+	* invalid after this point */
+inline void VR_Shutdown()
+{
+	VR_ShutdownInternal();
+}
+}  // namespace vr
diff --git a/engine/inc/bullet/ThirdPartyLibs/openvr/bin/osx64/OpenVR.framework/Versions/A/Headers/openvr_capi.h b/engine/inc/bullet/ThirdPartyLibs/openvr/bin/osx64/OpenVR.framework/Versions/A/Headers/openvr_capi.h
new file mode 100644
index 00000000..245365f4
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/openvr/bin/osx64/OpenVR.framework/Versions/A/Headers/openvr_capi.h
@@ -0,0 +1,1932 @@
+//======= Copyright (c) Valve Corporation, All rights reserved. ===============
+//
+// Purpose: Header for flatted SteamAPI. Use this for binding to other languages.
+// This file is auto-generated, do not edit it.
+//
+//=============================================================================
+
+#ifndef __OPENVR_API_FLAT_H__
+#define __OPENVR_API_FLAT_H__
+#if defined(_WIN32) || defined(__clang__)
+#pragma once
+#endif
+
+#ifdef __cplusplus
+#define EXTERN_C extern "C"
+#else
+#define EXTERN_C
+#endif
+
+#if defined(_WIN32)
+#define OPENVR_FNTABLE_CALLTYPE __stdcall
+#else
+#define OPENVR_FNTABLE_CALLTYPE
+#endif
+
+// OPENVR API export macro
+#if defined(_WIN32) && !defined(_X360)
+#if defined(OPENVR_API_EXPORTS)
+#define S_API EXTERN_C __declspec(dllexport)
+#elif defined(OPENVR_API_NODLL)
+#define S_API EXTERN_C
+#else
+#define S_API extern "C" __declspec(dllimport)
+#endif  // OPENVR_API_EXPORTS
+#elif defined(__GNUC__)
+#if defined(OPENVR_API_EXPORTS)
+#define S_API EXTERN_C __attribute__((visibility("default")))
+#else
+#define S_API EXTERN_C
+#endif  // OPENVR_API_EXPORTS
+#else   // !WIN32
+#if defined(OPENVR_API_EXPORTS)
+#define S_API EXTERN_C
+#else
+#define S_API EXTERN_C
+#endif  // OPENVR_API_EXPORTS
+#endif
+
+#include <stdint.h>
+
+#if defined(__WIN32)
+typedef char bool;
+#else
+#include <stdbool.h>
+#endif
+
+typedef uint64_t PropertyContainerHandle_t;
+typedef uint32_t PropertyTypeTag_t;
+typedef uint64_t VRActionHandle_t;
+typedef uint64_t VRActionSetHandle_t;
+typedef uint64_t VRInputOriginHandle_t;
+
+// OpenVR Constants
+
+static const unsigned int k_nDriverNone = 4294967295;
+static const unsigned int k_unMaxDriverDebugResponseSize = 32768;
+static const unsigned int k_unTrackedDeviceIndex_Hmd = 0;
+static const unsigned int k_unMaxTrackedDeviceCount = 16;
+static const unsigned int k_unTrackedDeviceIndexOther = 4294967294;
+static const unsigned int k_unTrackedDeviceIndexInvalid = 4294967295;
+static const unsigned long k_ulInvalidPropertyContainer = 0;
+static const unsigned int k_unInvalidPropertyTag = 0;
+static const unsigned int k_unFloatPropertyTag = 1;
+static const unsigned int k_unInt32PropertyTag = 2;
+static const unsigned int k_unUint64PropertyTag = 3;
+static const unsigned int k_unBoolPropertyTag = 4;
+static const unsigned int k_unStringPropertyTag = 5;
+static const unsigned int k_unHmdMatrix34PropertyTag = 20;
+static const unsigned int k_unHmdMatrix44PropertyTag = 21;
+static const unsigned int k_unHmdVector3PropertyTag = 22;
+static const unsigned int k_unHmdVector4PropertyTag = 23;
+static const unsigned int k_unHiddenAreaPropertyTag = 30;
+static const unsigned int k_unOpenVRInternalReserved_Start = 1000;
+static const unsigned int k_unOpenVRInternalReserved_End = 10000;
+static const unsigned int k_unMaxPropertyStringSize = 32768;
+static const unsigned int k_unControllerStateAxisCount = 5;
+static const unsigned long k_ulOverlayHandleInvalid = 0;
+static const unsigned int k_unScreenshotHandleInvalid = 0;
+static const char *IVRSystem_Version = "IVRSystem_017";
+static const char *IVRExtendedDisplay_Version = "IVRExtendedDisplay_001";
+static const char *IVRTrackedCamera_Version = "IVRTrackedCamera_003";
+static const unsigned int k_unMaxApplicationKeyLength = 128;
+static const char *k_pch_MimeType_HomeApp = "vr/home";
+static const char *k_pch_MimeType_GameTheater = "vr/game_theater";
+static const char *IVRApplications_Version = "IVRApplications_006";
+static const char *IVRChaperone_Version = "IVRChaperone_003";
+static const char *IVRChaperoneSetup_Version = "IVRChaperoneSetup_005";
+static const char *IVRCompositor_Version = "IVRCompositor_021";
+static const unsigned int k_unVROverlayMaxKeyLength = 128;
+static const unsigned int k_unVROverlayMaxNameLength = 128;
+static const unsigned int k_unMaxOverlayCount = 64;
+static const unsigned int k_unMaxOverlayIntersectionMaskPrimitivesCount = 32;
+static const char *IVROverlay_Version = "IVROverlay_016";
+static const char *k_pch_Controller_Component_GDC2015 = "gdc2015";
+static const char *k_pch_Controller_Component_Base = "base";
+static const char *k_pch_Controller_Component_Tip = "tip";
+static const char *k_pch_Controller_Component_HandGrip = "handgrip";
+static const char *k_pch_Controller_Component_Status = "status";
+static const char *IVRRenderModels_Version = "IVRRenderModels_005";
+static const unsigned int k_unNotificationTextMaxSize = 256;
+static const char *IVRNotifications_Version = "IVRNotifications_002";
+static const unsigned int k_unMaxSettingsKeyLength = 128;
+static const char *IVRSettings_Version = "IVRSettings_002";
+static const char *k_pch_SteamVR_Section = "steamvr";
+static const char *k_pch_SteamVR_RequireHmd_String = "requireHmd";
+static const char *k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver";
+static const char *k_pch_SteamVR_ForcedHmdKey_String = "forcedHmd";
+static const char *k_pch_SteamVR_DisplayDebug_Bool = "displayDebug";
+static const char *k_pch_SteamVR_DebugProcessPipe_String = "debugProcessPipe";
+static const char *k_pch_SteamVR_DisplayDebugX_Int32 = "displayDebugX";
+static const char *k_pch_SteamVR_DisplayDebugY_Int32 = "displayDebugY";
+static const char *k_pch_SteamVR_SendSystemButtonToAllApps_Bool = "sendSystemButtonToAllApps";
+static const char *k_pch_SteamVR_LogLevel_Int32 = "loglevel";
+static const char *k_pch_SteamVR_IPD_Float = "ipd";
+static const char *k_pch_SteamVR_Background_String = "background";
+static const char *k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection";
+static const char *k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight";
+static const char *k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius";
+static const char *k_pch_SteamVR_GridColor_String = "gridColor";
+static const char *k_pch_SteamVR_PlayAreaColor_String = "playAreaColor";
+static const char *k_pch_SteamVR_ShowStage_Bool = "showStage";
+static const char *k_pch_SteamVR_ActivateMultipleDrivers_Bool = "activateMultipleDrivers";
+static const char *k_pch_SteamVR_DirectMode_Bool = "directMode";
+static const char *k_pch_SteamVR_DirectModeEdidVid_Int32 = "directModeEdidVid";
+static const char *k_pch_SteamVR_DirectModeEdidPid_Int32 = "directModeEdidPid";
+static const char *k_pch_SteamVR_UsingSpeakers_Bool = "usingSpeakers";
+static const char *k_pch_SteamVR_SpeakersForwardYawOffsetDegrees_Float = "speakersForwardYawOffsetDegrees";
+static const char *k_pch_SteamVR_BaseStationPowerManagement_Bool = "basestationPowerManagement";
+static const char *k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses";
+static const char *k_pch_SteamVR_SupersampleScale_Float = "supersampleScale";
+static const char *k_pch_SteamVR_AllowAsyncReprojection_Bool = "allowAsyncReprojection";
+static const char *k_pch_SteamVR_AllowReprojection_Bool = "allowInterleavedReprojection";
+static const char *k_pch_SteamVR_ForceReprojection_Bool = "forceReprojection";
+static const char *k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking";
+static const char *k_pch_SteamVR_DefaultMirrorView_Int32 = "defaultMirrorView";
+static const char *k_pch_SteamVR_ShowMirrorView_Bool = "showMirrorView";
+static const char *k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry";
+static const char *k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch";
+static const char *k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch";
+static const char *k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch";
+static const char *k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard";
+static const char *k_pch_SteamVR_EnableHomeApp = "enableHomeApp";
+static const char *k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec";
+static const char *k_pch_SteamVR_RetailDemo_Bool = "retailDemo";
+static const char *k_pch_SteamVR_IpdOffset_Float = "ipdOffset";
+static const char *k_pch_SteamVR_AllowSupersampleFiltering_Bool = "allowSupersampleFiltering";
+static const char *k_pch_SteamVR_EnableLinuxVulkanAsync_Bool = "enableLinuxVulkanAsync";
+static const char *k_pch_Lighthouse_Section = "driver_lighthouse";
+static const char *k_pch_Lighthouse_DisableIMU_Bool = "disableimu";
+static const char *k_pch_Lighthouse_UseDisambiguation_String = "usedisambiguation";
+static const char *k_pch_Lighthouse_DisambiguationDebug_Int32 = "disambiguationdebug";
+static const char *k_pch_Lighthouse_PrimaryBasestation_Int32 = "primarybasestation";
+static const char *k_pch_Lighthouse_DBHistory_Bool = "dbhistory";
+static const char *k_pch_Null_Section = "driver_null";
+static const char *k_pch_Null_SerialNumber_String = "serialNumber";
+static const char *k_pch_Null_ModelNumber_String = "modelNumber";
+static const char *k_pch_Null_WindowX_Int32 = "windowX";
+static const char *k_pch_Null_WindowY_Int32 = "windowY";
+static const char *k_pch_Null_WindowWidth_Int32 = "windowWidth";
+static const char *k_pch_Null_WindowHeight_Int32 = "windowHeight";
+static const char *k_pch_Null_RenderWidth_Int32 = "renderWidth";
+static const char *k_pch_Null_RenderHeight_Int32 = "renderHeight";
+static const char *k_pch_Null_SecondsFromVsyncToPhotons_Float = "secondsFromVsyncToPhotons";
+static const char *k_pch_Null_DisplayFrequency_Float = "displayFrequency";
+static const char *k_pch_UserInterface_Section = "userinterface";
+static const char *k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop";
+static const char *k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray";
+static const char *k_pch_UserInterface_Screenshots_Bool = "screenshots";
+static const char *k_pch_UserInterface_ScreenshotType_Int = "screenshotType";
+static const char *k_pch_Notifications_Section = "notifications";
+static const char *k_pch_Notifications_DoNotDisturb_Bool = "DoNotDisturb";
+static const char *k_pch_Keyboard_Section = "keyboard";
+static const char *k_pch_Keyboard_TutorialCompletions = "TutorialCompletions";
+static const char *k_pch_Keyboard_ScaleX = "ScaleX";
+static const char *k_pch_Keyboard_ScaleY = "ScaleY";
+static const char *k_pch_Keyboard_OffsetLeftX = "OffsetLeftX";
+static const char *k_pch_Keyboard_OffsetRightX = "OffsetRightX";
+static const char *k_pch_Keyboard_OffsetY = "OffsetY";
+static const char *k_pch_Keyboard_Smoothing = "Smoothing";
+static const char *k_pch_Perf_Section = "perfcheck";
+static const char *k_pch_Perf_HeuristicActive_Bool = "heuristicActive";
+static const char *k_pch_Perf_NotifyInHMD_Bool = "warnInHMD";
+static const char *k_pch_Perf_NotifyOnlyOnce_Bool = "warnOnlyOnce";
+static const char *k_pch_Perf_AllowTimingStore_Bool = "allowTimingStore";
+static const char *k_pch_Perf_SaveTimingsOnExit_Bool = "saveTimingsOnExit";
+static const char *k_pch_Perf_TestData_Float = "perfTestData";
+static const char *k_pch_Perf_LinuxGPUProfiling_Bool = "linuxGPUProfiling";
+static const char *k_pch_CollisionBounds_Section = "collisionBounds";
+static const char *k_pch_CollisionBounds_Style_Int32 = "CollisionBoundsStyle";
+static const char *k_pch_CollisionBounds_GroundPerimeterOn_Bool = "CollisionBoundsGroundPerimeterOn";
+static const char *k_pch_CollisionBounds_CenterMarkerOn_Bool = "CollisionBoundsCenterMarkerOn";
+static const char *k_pch_CollisionBounds_PlaySpaceOn_Bool = "CollisionBoundsPlaySpaceOn";
+static const char *k_pch_CollisionBounds_FadeDistance_Float = "CollisionBoundsFadeDistance";
+static const char *k_pch_CollisionBounds_ColorGammaR_Int32 = "CollisionBoundsColorGammaR";
+static const char *k_pch_CollisionBounds_ColorGammaG_Int32 = "CollisionBoundsColorGammaG";
+static const char *k_pch_CollisionBounds_ColorGammaB_Int32 = "CollisionBoundsColorGammaB";
+static const char *k_pch_CollisionBounds_ColorGammaA_Int32 = "CollisionBoundsColorGammaA";
+static const char *k_pch_Camera_Section = "camera";
+static const char *k_pch_Camera_EnableCamera_Bool = "enableCamera";
+static const char *k_pch_Camera_EnableCameraInDashboard_Bool = "enableCameraInDashboard";
+static const char *k_pch_Camera_EnableCameraForCollisionBounds_Bool = "enableCameraForCollisionBounds";
+static const char *k_pch_Camera_EnableCameraForRoomView_Bool = "enableCameraForRoomView";
+static const char *k_pch_Camera_BoundsColorGammaR_Int32 = "cameraBoundsColorGammaR";
+static const char *k_pch_Camera_BoundsColorGammaG_Int32 = "cameraBoundsColorGammaG";
+static const char *k_pch_Camera_BoundsColorGammaB_Int32 = "cameraBoundsColorGammaB";
+static const char *k_pch_Camera_BoundsColorGammaA_Int32 = "cameraBoundsColorGammaA";
+static const char *k_pch_Camera_BoundsStrength_Int32 = "cameraBoundsStrength";
+static const char *k_pch_audio_Section = "audio";
+static const char *k_pch_audio_OnPlaybackDevice_String = "onPlaybackDevice";
+static const char *k_pch_audio_OnRecordDevice_String = "onRecordDevice";
+static const char *k_pch_audio_OnPlaybackMirrorDevice_String = "onPlaybackMirrorDevice";
+static const char *k_pch_audio_OffPlaybackDevice_String = "offPlaybackDevice";
+static const char *k_pch_audio_OffRecordDevice_String = "offRecordDevice";
+static const char *k_pch_audio_VIVEHDMIGain = "viveHDMIGain";
+static const char *k_pch_Power_Section = "power";
+static const char *k_pch_Power_PowerOffOnExit_Bool = "powerOffOnExit";
+static const char *k_pch_Power_TurnOffScreensTimeout_Float = "turnOffScreensTimeout";
+static const char *k_pch_Power_TurnOffControllersTimeout_Float = "turnOffControllersTimeout";
+static const char *k_pch_Power_ReturnToWatchdogTimeout_Float = "returnToWatchdogTimeout";
+static const char *k_pch_Power_AutoLaunchSteamVROnButtonPress = "autoLaunchSteamVROnButtonPress";
+static const char *k_pch_Power_PauseCompositorOnStandby_Bool = "pauseCompositorOnStandby";
+static const char *k_pch_Dashboard_Section = "dashboard";
+static const char *k_pch_Dashboard_EnableDashboard_Bool = "enableDashboard";
+static const char *k_pch_Dashboard_ArcadeMode_Bool = "arcadeMode";
+static const char *k_pch_modelskin_Section = "modelskins";
+static const char *k_pch_Driver_Enable_Bool = "enable";
+static const char *IVRScreenshots_Version = "IVRScreenshots_001";
+static const char *IVRResources_Version = "IVRResources_001";
+static const char *IVRDriverManager_Version = "IVRDriverManager_001";
+
+// OpenVR Enums
+
+typedef enum EVREye
+{
+	EVREye_Eye_Left = 0,
+	EVREye_Eye_Right = 1,
+} EVREye;
+
+typedef enum ETextureType
+{
+	ETextureType_TextureType_DirectX = 0,
+	ETextureType_TextureType_OpenGL = 1,
+	ETextureType_TextureType_Vulkan = 2,
+	ETextureType_TextureType_IOSurface = 3,
+	ETextureType_TextureType_DirectX12 = 4,
+} ETextureType;
+
+typedef enum EColorSpace
+{
+	EColorSpace_ColorSpace_Auto = 0,
+	EColorSpace_ColorSpace_Gamma = 1,
+	EColorSpace_ColorSpace_Linear = 2,
+} EColorSpace;
+
+typedef enum ETrackingResult
+{
+	ETrackingResult_TrackingResult_Uninitialized = 1,
+	ETrackingResult_TrackingResult_Calibrating_InProgress = 100,
+	ETrackingResult_TrackingResult_Calibrating_OutOfRange = 101,
+	ETrackingResult_TrackingResult_Running_OK = 200,
+	ETrackingResult_TrackingResult_Running_OutOfRange = 201,
+} ETrackingResult;
+
+typedef enum ETrackedDeviceClass
+{
+	ETrackedDeviceClass_TrackedDeviceClass_Invalid = 0,
+	ETrackedDeviceClass_TrackedDeviceClass_HMD = 1,
+	ETrackedDeviceClass_TrackedDeviceClass_Controller = 2,
+	ETrackedDeviceClass_TrackedDeviceClass_GenericTracker = 3,
+	ETrackedDeviceClass_TrackedDeviceClass_TrackingReference = 4,
+	ETrackedDeviceClass_TrackedDeviceClass_DisplayRedirect = 5,
+} ETrackedDeviceClass;
+
+typedef enum ETrackedControllerRole
+{
+	ETrackedControllerRole_TrackedControllerRole_Invalid = 0,
+	ETrackedControllerRole_TrackedControllerRole_LeftHand = 1,
+	ETrackedControllerRole_TrackedControllerRole_RightHand = 2,
+} ETrackedControllerRole;
+
+typedef enum ETrackingUniverseOrigin
+{
+	ETrackingUniverseOrigin_TrackingUniverseSeated = 0,
+	ETrackingUniverseOrigin_TrackingUniverseStanding = 1,
+	ETrackingUniverseOrigin_TrackingUniverseRawAndUncalibrated = 2,
+} ETrackingUniverseOrigin;
+
+typedef enum ETrackedDeviceProperty
+{
+	ETrackedDeviceProperty_Prop_Invalid = 0,
+	ETrackedDeviceProperty_Prop_TrackingSystemName_String = 1000,
+	ETrackedDeviceProperty_Prop_ModelNumber_String = 1001,
+	ETrackedDeviceProperty_Prop_SerialNumber_String = 1002,
+	ETrackedDeviceProperty_Prop_RenderModelName_String = 1003,
+	ETrackedDeviceProperty_Prop_WillDriftInYaw_Bool = 1004,
+	ETrackedDeviceProperty_Prop_ManufacturerName_String = 1005,
+	ETrackedDeviceProperty_Prop_TrackingFirmwareVersion_String = 1006,
+	ETrackedDeviceProperty_Prop_HardwareRevision_String = 1007,
+	ETrackedDeviceProperty_Prop_AllWirelessDongleDescriptions_String = 1008,
+	ETrackedDeviceProperty_Prop_ConnectedWirelessDongle_String = 1009,
+	ETrackedDeviceProperty_Prop_DeviceIsWireless_Bool = 1010,
+	ETrackedDeviceProperty_Prop_DeviceIsCharging_Bool = 1011,
+	ETrackedDeviceProperty_Prop_DeviceBatteryPercentage_Float = 1012,
+	ETrackedDeviceProperty_Prop_StatusDisplayTransform_Matrix34 = 1013,
+	ETrackedDeviceProperty_Prop_Firmware_UpdateAvailable_Bool = 1014,
+	ETrackedDeviceProperty_Prop_Firmware_ManualUpdate_Bool = 1015,
+	ETrackedDeviceProperty_Prop_Firmware_ManualUpdateURL_String = 1016,
+	ETrackedDeviceProperty_Prop_HardwareRevision_Uint64 = 1017,
+	ETrackedDeviceProperty_Prop_FirmwareVersion_Uint64 = 1018,
+	ETrackedDeviceProperty_Prop_FPGAVersion_Uint64 = 1019,
+	ETrackedDeviceProperty_Prop_VRCVersion_Uint64 = 1020,
+	ETrackedDeviceProperty_Prop_RadioVersion_Uint64 = 1021,
+	ETrackedDeviceProperty_Prop_DongleVersion_Uint64 = 1022,
+	ETrackedDeviceProperty_Prop_BlockServerShutdown_Bool = 1023,
+	ETrackedDeviceProperty_Prop_CanUnifyCoordinateSystemWithHmd_Bool = 1024,
+	ETrackedDeviceProperty_Prop_ContainsProximitySensor_Bool = 1025,
+	ETrackedDeviceProperty_Prop_DeviceProvidesBatteryStatus_Bool = 1026,
+	ETrackedDeviceProperty_Prop_DeviceCanPowerOff_Bool = 1027,
+	ETrackedDeviceProperty_Prop_Firmware_ProgrammingTarget_String = 1028,
+	ETrackedDeviceProperty_Prop_DeviceClass_Int32 = 1029,
+	ETrackedDeviceProperty_Prop_HasCamera_Bool = 1030,
+	ETrackedDeviceProperty_Prop_DriverVersion_String = 1031,
+	ETrackedDeviceProperty_Prop_Firmware_ForceUpdateRequired_Bool = 1032,
+	ETrackedDeviceProperty_Prop_ViveSystemButtonFixRequired_Bool = 1033,
+	ETrackedDeviceProperty_Prop_ParentDriver_Uint64 = 1034,
+	ETrackedDeviceProperty_Prop_ResourceRoot_String = 1035,
+	ETrackedDeviceProperty_Prop_ReportsTimeSinceVSync_Bool = 2000,
+	ETrackedDeviceProperty_Prop_SecondsFromVsyncToPhotons_Float = 2001,
+	ETrackedDeviceProperty_Prop_DisplayFrequency_Float = 2002,
+	ETrackedDeviceProperty_Prop_UserIpdMeters_Float = 2003,
+	ETrackedDeviceProperty_Prop_CurrentUniverseId_Uint64 = 2004,
+	ETrackedDeviceProperty_Prop_PreviousUniverseId_Uint64 = 2005,
+	ETrackedDeviceProperty_Prop_DisplayFirmwareVersion_Uint64 = 2006,
+	ETrackedDeviceProperty_Prop_IsOnDesktop_Bool = 2007,
+	ETrackedDeviceProperty_Prop_DisplayMCType_Int32 = 2008,
+	ETrackedDeviceProperty_Prop_DisplayMCOffset_Float = 2009,
+	ETrackedDeviceProperty_Prop_DisplayMCScale_Float = 2010,
+	ETrackedDeviceProperty_Prop_EdidVendorID_Int32 = 2011,
+	ETrackedDeviceProperty_Prop_DisplayMCImageLeft_String = 2012,
+	ETrackedDeviceProperty_Prop_DisplayMCImageRight_String = 2013,
+	ETrackedDeviceProperty_Prop_DisplayGCBlackClamp_Float = 2014,
+	ETrackedDeviceProperty_Prop_EdidProductID_Int32 = 2015,
+	ETrackedDeviceProperty_Prop_CameraToHeadTransform_Matrix34 = 2016,
+	ETrackedDeviceProperty_Prop_DisplayGCType_Int32 = 2017,
+	ETrackedDeviceProperty_Prop_DisplayGCOffset_Float = 2018,
+	ETrackedDeviceProperty_Prop_DisplayGCScale_Float = 2019,
+	ETrackedDeviceProperty_Prop_DisplayGCPrescale_Float = 2020,
+	ETrackedDeviceProperty_Prop_DisplayGCImage_String = 2021,
+	ETrackedDeviceProperty_Prop_LensCenterLeftU_Float = 2022,
+	ETrackedDeviceProperty_Prop_LensCenterLeftV_Float = 2023,
+	ETrackedDeviceProperty_Prop_LensCenterRightU_Float = 2024,
+	ETrackedDeviceProperty_Prop_LensCenterRightV_Float = 2025,
+	ETrackedDeviceProperty_Prop_UserHeadToEyeDepthMeters_Float = 2026,
+	ETrackedDeviceProperty_Prop_CameraFirmwareVersion_Uint64 = 2027,
+	ETrackedDeviceProperty_Prop_CameraFirmwareDescription_String = 2028,
+	ETrackedDeviceProperty_Prop_DisplayFPGAVersion_Uint64 = 2029,
+	ETrackedDeviceProperty_Prop_DisplayBootloaderVersion_Uint64 = 2030,
+	ETrackedDeviceProperty_Prop_DisplayHardwareVersion_Uint64 = 2031,
+	ETrackedDeviceProperty_Prop_AudioFirmwareVersion_Uint64 = 2032,
+	ETrackedDeviceProperty_Prop_CameraCompatibilityMode_Int32 = 2033,
+	ETrackedDeviceProperty_Prop_ScreenshotHorizontalFieldOfViewDegrees_Float = 2034,
+	ETrackedDeviceProperty_Prop_ScreenshotVerticalFieldOfViewDegrees_Float = 2035,
+	ETrackedDeviceProperty_Prop_DisplaySuppressed_Bool = 2036,
+	ETrackedDeviceProperty_Prop_DisplayAllowNightMode_Bool = 2037,
+	ETrackedDeviceProperty_Prop_DisplayMCImageWidth_Int32 = 2038,
+	ETrackedDeviceProperty_Prop_DisplayMCImageHeight_Int32 = 2039,
+	ETrackedDeviceProperty_Prop_DisplayMCImageNumChannels_Int32 = 2040,
+	ETrackedDeviceProperty_Prop_DisplayMCImageData_Binary = 2041,
+	ETrackedDeviceProperty_Prop_SecondsFromPhotonsToVblank_Float = 2042,
+	ETrackedDeviceProperty_Prop_DriverDirectModeSendsVsyncEvents_Bool = 2043,
+	ETrackedDeviceProperty_Prop_DisplayDebugMode_Bool = 2044,
+	ETrackedDeviceProperty_Prop_GraphicsAdapterLuid_Uint64 = 2045,
+	ETrackedDeviceProperty_Prop_DriverProvidedChaperonePath_String = 2048,
+	ETrackedDeviceProperty_Prop_AttachedDeviceId_String = 3000,
+	ETrackedDeviceProperty_Prop_SupportedButtons_Uint64 = 3001,
+	ETrackedDeviceProperty_Prop_Axis0Type_Int32 = 3002,
+	ETrackedDeviceProperty_Prop_Axis1Type_Int32 = 3003,
+	ETrackedDeviceProperty_Prop_Axis2Type_Int32 = 3004,
+	ETrackedDeviceProperty_Prop_Axis3Type_Int32 = 3005,
+	ETrackedDeviceProperty_Prop_Axis4Type_Int32 = 3006,
+	ETrackedDeviceProperty_Prop_ControllerRoleHint_Int32 = 3007,
+	ETrackedDeviceProperty_Prop_FieldOfViewLeftDegrees_Float = 4000,
+	ETrackedDeviceProperty_Prop_FieldOfViewRightDegrees_Float = 4001,
+	ETrackedDeviceProperty_Prop_FieldOfViewTopDegrees_Float = 4002,
+	ETrackedDeviceProperty_Prop_FieldOfViewBottomDegrees_Float = 4003,
+	ETrackedDeviceProperty_Prop_TrackingRangeMinimumMeters_Float = 4004,
+	ETrackedDeviceProperty_Prop_TrackingRangeMaximumMeters_Float = 4005,
+	ETrackedDeviceProperty_Prop_ModeLabel_String = 4006,
+	ETrackedDeviceProperty_Prop_IconPathName_String = 5000,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceOff_String = 5001,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceSearching_String = 5002,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceSearchingAlert_String = 5003,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceReady_String = 5004,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceReadyAlert_String = 5005,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceNotReady_String = 5006,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceStandby_String = 5007,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceAlertLow_String = 5008,
+	ETrackedDeviceProperty_Prop_DisplayHiddenArea_Binary_Start = 5100,
+	ETrackedDeviceProperty_Prop_DisplayHiddenArea_Binary_End = 5150,
+	ETrackedDeviceProperty_Prop_UserConfigPath_String = 6000,
+	ETrackedDeviceProperty_Prop_InstallPath_String = 6001,
+	ETrackedDeviceProperty_Prop_HasDisplayComponent_Bool = 6002,
+	ETrackedDeviceProperty_Prop_HasControllerComponent_Bool = 6003,
+	ETrackedDeviceProperty_Prop_HasCameraComponent_Bool = 6004,
+	ETrackedDeviceProperty_Prop_HasDriverDirectModeComponent_Bool = 6005,
+	ETrackedDeviceProperty_Prop_HasVirtualDisplayComponent_Bool = 6006,
+	ETrackedDeviceProperty_Prop_VendorSpecific_Reserved_Start = 10000,
+	ETrackedDeviceProperty_Prop_VendorSpecific_Reserved_End = 10999,
+} ETrackedDeviceProperty;
+
+typedef enum ETrackedPropertyError
+{
+	ETrackedPropertyError_TrackedProp_Success = 0,
+	ETrackedPropertyError_TrackedProp_WrongDataType = 1,
+	ETrackedPropertyError_TrackedProp_WrongDeviceClass = 2,
+	ETrackedPropertyError_TrackedProp_BufferTooSmall = 3,
+	ETrackedPropertyError_TrackedProp_UnknownProperty = 4,
+	ETrackedPropertyError_TrackedProp_InvalidDevice = 5,
+	ETrackedPropertyError_TrackedProp_CouldNotContactServer = 6,
+	ETrackedPropertyError_TrackedProp_ValueNotProvidedByDevice = 7,
+	ETrackedPropertyError_TrackedProp_StringExceedsMaximumLength = 8,
+	ETrackedPropertyError_TrackedProp_NotYetAvailable = 9,
+	ETrackedPropertyError_TrackedProp_PermissionDenied = 10,
+	ETrackedPropertyError_TrackedProp_InvalidOperation = 11,
+} ETrackedPropertyError;
+
+typedef enum EVRSubmitFlags
+{
+	EVRSubmitFlags_Submit_Default = 0,
+	EVRSubmitFlags_Submit_LensDistortionAlreadyApplied = 1,
+	EVRSubmitFlags_Submit_GlRenderBuffer = 2,
+	EVRSubmitFlags_Submit_Reserved = 4,
+	EVRSubmitFlags_Submit_TextureWithPose = 8,
+} EVRSubmitFlags;
+
+typedef enum EVRState
+{
+	EVRState_VRState_Undefined = -1,
+	EVRState_VRState_Off = 0,
+	EVRState_VRState_Searching = 1,
+	EVRState_VRState_Searching_Alert = 2,
+	EVRState_VRState_Ready = 3,
+	EVRState_VRState_Ready_Alert = 4,
+	EVRState_VRState_NotReady = 5,
+	EVRState_VRState_Standby = 6,
+	EVRState_VRState_Ready_Alert_Low = 7,
+} EVRState;
+
+typedef enum EVREventType
+{
+	EVREventType_VREvent_None = 0,
+	EVREventType_VREvent_TrackedDeviceActivated = 100,
+	EVREventType_VREvent_TrackedDeviceDeactivated = 101,
+	EVREventType_VREvent_TrackedDeviceUpdated = 102,
+	EVREventType_VREvent_TrackedDeviceUserInteractionStarted = 103,
+	EVREventType_VREvent_TrackedDeviceUserInteractionEnded = 104,
+	EVREventType_VREvent_IpdChanged = 105,
+	EVREventType_VREvent_EnterStandbyMode = 106,
+	EVREventType_VREvent_LeaveStandbyMode = 107,
+	EVREventType_VREvent_TrackedDeviceRoleChanged = 108,
+	EVREventType_VREvent_WatchdogWakeUpRequested = 109,
+	EVREventType_VREvent_LensDistortionChanged = 110,
+	EVREventType_VREvent_PropertyChanged = 111,
+	EVREventType_VREvent_WirelessDisconnect = 112,
+	EVREventType_VREvent_WirelessReconnect = 113,
+	EVREventType_VREvent_ButtonPress = 200,
+	EVREventType_VREvent_ButtonUnpress = 201,
+	EVREventType_VREvent_ButtonTouch = 202,
+	EVREventType_VREvent_ButtonUntouch = 203,
+	EVREventType_VREvent_MouseMove = 300,
+	EVREventType_VREvent_MouseButtonDown = 301,
+	EVREventType_VREvent_MouseButtonUp = 302,
+	EVREventType_VREvent_FocusEnter = 303,
+	EVREventType_VREvent_FocusLeave = 304,
+	EVREventType_VREvent_Scroll = 305,
+	EVREventType_VREvent_TouchPadMove = 306,
+	EVREventType_VREvent_OverlayFocusChanged = 307,
+	EVREventType_VREvent_InputFocusCaptured = 400,
+	EVREventType_VREvent_InputFocusReleased = 401,
+	EVREventType_VREvent_SceneFocusLost = 402,
+	EVREventType_VREvent_SceneFocusGained = 403,
+	EVREventType_VREvent_SceneApplicationChanged = 404,
+	EVREventType_VREvent_SceneFocusChanged = 405,
+	EVREventType_VREvent_InputFocusChanged = 406,
+	EVREventType_VREvent_SceneApplicationSecondaryRenderingStarted = 407,
+	EVREventType_VREvent_HideRenderModels = 410,
+	EVREventType_VREvent_ShowRenderModels = 411,
+	EVREventType_VREvent_OverlayShown = 500,
+	EVREventType_VREvent_OverlayHidden = 501,
+	EVREventType_VREvent_DashboardActivated = 502,
+	EVREventType_VREvent_DashboardDeactivated = 503,
+	EVREventType_VREvent_DashboardThumbSelected = 504,
+	EVREventType_VREvent_DashboardRequested = 505,
+	EVREventType_VREvent_ResetDashboard = 506,
+	EVREventType_VREvent_RenderToast = 507,
+	EVREventType_VREvent_ImageLoaded = 508,
+	EVREventType_VREvent_ShowKeyboard = 509,
+	EVREventType_VREvent_HideKeyboard = 510,
+	EVREventType_VREvent_OverlayGamepadFocusGained = 511,
+	EVREventType_VREvent_OverlayGamepadFocusLost = 512,
+	EVREventType_VREvent_OverlaySharedTextureChanged = 513,
+	EVREventType_VREvent_DashboardGuideButtonDown = 514,
+	EVREventType_VREvent_DashboardGuideButtonUp = 515,
+	EVREventType_VREvent_ScreenshotTriggered = 516,
+	EVREventType_VREvent_ImageFailed = 517,
+	EVREventType_VREvent_DashboardOverlayCreated = 518,
+	EVREventType_VREvent_RequestScreenshot = 520,
+	EVREventType_VREvent_ScreenshotTaken = 521,
+	EVREventType_VREvent_ScreenshotFailed = 522,
+	EVREventType_VREvent_SubmitScreenshotToDashboard = 523,
+	EVREventType_VREvent_ScreenshotProgressToDashboard = 524,
+	EVREventType_VREvent_PrimaryDashboardDeviceChanged = 525,
+	EVREventType_VREvent_Notification_Shown = 600,
+	EVREventType_VREvent_Notification_Hidden = 601,
+	EVREventType_VREvent_Notification_BeginInteraction = 602,
+	EVREventType_VREvent_Notification_Destroyed = 603,
+	EVREventType_VREvent_Quit = 700,
+	EVREventType_VREvent_ProcessQuit = 701,
+	EVREventType_VREvent_QuitAborted_UserPrompt = 702,
+	EVREventType_VREvent_QuitAcknowledged = 703,
+	EVREventType_VREvent_DriverRequestedQuit = 704,
+	EVREventType_VREvent_ChaperoneDataHasChanged = 800,
+	EVREventType_VREvent_ChaperoneUniverseHasChanged = 801,
+	EVREventType_VREvent_ChaperoneTempDataHasChanged = 802,
+	EVREventType_VREvent_ChaperoneSettingsHaveChanged = 803,
+	EVREventType_VREvent_SeatedZeroPoseReset = 804,
+	EVREventType_VREvent_AudioSettingsHaveChanged = 820,
+	EVREventType_VREvent_BackgroundSettingHasChanged = 850,
+	EVREventType_VREvent_CameraSettingsHaveChanged = 851,
+	EVREventType_VREvent_ReprojectionSettingHasChanged = 852,
+	EVREventType_VREvent_ModelSkinSettingsHaveChanged = 853,
+	EVREventType_VREvent_EnvironmentSettingsHaveChanged = 854,
+	EVREventType_VREvent_PowerSettingsHaveChanged = 855,
+	EVREventType_VREvent_EnableHomeAppSettingsHaveChanged = 856,
+	EVREventType_VREvent_StatusUpdate = 900,
+	EVREventType_VREvent_MCImageUpdated = 1000,
+	EVREventType_VREvent_FirmwareUpdateStarted = 1100,
+	EVREventType_VREvent_FirmwareUpdateFinished = 1101,
+	EVREventType_VREvent_KeyboardClosed = 1200,
+	EVREventType_VREvent_KeyboardCharInput = 1201,
+	EVREventType_VREvent_KeyboardDone = 1202,
+	EVREventType_VREvent_ApplicationTransitionStarted = 1300,
+	EVREventType_VREvent_ApplicationTransitionAborted = 1301,
+	EVREventType_VREvent_ApplicationTransitionNewAppStarted = 1302,
+	EVREventType_VREvent_ApplicationListUpdated = 1303,
+	EVREventType_VREvent_ApplicationMimeTypeLoad = 1304,
+	EVREventType_VREvent_ApplicationTransitionNewAppLaunchComplete = 1305,
+	EVREventType_VREvent_ProcessConnected = 1306,
+	EVREventType_VREvent_ProcessDisconnected = 1307,
+	EVREventType_VREvent_Compositor_MirrorWindowShown = 1400,
+	EVREventType_VREvent_Compositor_MirrorWindowHidden = 1401,
+	EVREventType_VREvent_Compositor_ChaperoneBoundsShown = 1410,
+	EVREventType_VREvent_Compositor_ChaperoneBoundsHidden = 1411,
+	EVREventType_VREvent_TrackedCamera_StartVideoStream = 1500,
+	EVREventType_VREvent_TrackedCamera_StopVideoStream = 1501,
+	EVREventType_VREvent_TrackedCamera_PauseVideoStream = 1502,
+	EVREventType_VREvent_TrackedCamera_ResumeVideoStream = 1503,
+	EVREventType_VREvent_TrackedCamera_EditingSurface = 1550,
+	EVREventType_VREvent_PerformanceTest_EnableCapture = 1600,
+	EVREventType_VREvent_PerformanceTest_DisableCapture = 1601,
+	EVREventType_VREvent_PerformanceTest_FidelityLevel = 1602,
+	EVREventType_VREvent_MessageOverlay_Closed = 1650,
+	EVREventType_VREvent_MessageOverlayCloseRequested = 1651,
+	EVREventType_VREvent_VendorSpecific_Reserved_Start = 10000,
+	EVREventType_VREvent_VendorSpecific_Reserved_End = 19999,
+} EVREventType;
+
+typedef enum EDeviceActivityLevel
+{
+	EDeviceActivityLevel_k_EDeviceActivityLevel_Unknown = -1,
+	EDeviceActivityLevel_k_EDeviceActivityLevel_Idle = 0,
+	EDeviceActivityLevel_k_EDeviceActivityLevel_UserInteraction = 1,
+	EDeviceActivityLevel_k_EDeviceActivityLevel_UserInteraction_Timeout = 2,
+	EDeviceActivityLevel_k_EDeviceActivityLevel_Standby = 3,
+} EDeviceActivityLevel;
+
+typedef enum EVRButtonId
+{
+	EVRButtonId_k_EButton_System = 0,
+	EVRButtonId_k_EButton_ApplicationMenu = 1,
+	EVRButtonId_k_EButton_Grip = 2,
+	EVRButtonId_k_EButton_DPad_Left = 3,
+	EVRButtonId_k_EButton_DPad_Up = 4,
+	EVRButtonId_k_EButton_DPad_Right = 5,
+	EVRButtonId_k_EButton_DPad_Down = 6,
+	EVRButtonId_k_EButton_A = 7,
+	EVRButtonId_k_EButton_ProximitySensor = 31,
+	EVRButtonId_k_EButton_Axis0 = 32,
+	EVRButtonId_k_EButton_Axis1 = 33,
+	EVRButtonId_k_EButton_Axis2 = 34,
+	EVRButtonId_k_EButton_Axis3 = 35,
+	EVRButtonId_k_EButton_Axis4 = 36,
+	EVRButtonId_k_EButton_SteamVR_Touchpad = 32,
+	EVRButtonId_k_EButton_SteamVR_Trigger = 33,
+	EVRButtonId_k_EButton_Dashboard_Back = 2,
+	EVRButtonId_k_EButton_Max = 64,
+} EVRButtonId;
+
+typedef enum EVRMouseButton
+{
+	EVRMouseButton_VRMouseButton_Left = 1,
+	EVRMouseButton_VRMouseButton_Right = 2,
+	EVRMouseButton_VRMouseButton_Middle = 4,
+} EVRMouseButton;
+
+typedef enum EHiddenAreaMeshType
+{
+	EHiddenAreaMeshType_k_eHiddenAreaMesh_Standard = 0,
+	EHiddenAreaMeshType_k_eHiddenAreaMesh_Inverse = 1,
+	EHiddenAreaMeshType_k_eHiddenAreaMesh_LineLoop = 2,
+	EHiddenAreaMeshType_k_eHiddenAreaMesh_Max = 3,
+} EHiddenAreaMeshType;
+
+typedef enum EVRControllerAxisType
+{
+	EVRControllerAxisType_k_eControllerAxis_None = 0,
+	EVRControllerAxisType_k_eControllerAxis_TrackPad = 1,
+	EVRControllerAxisType_k_eControllerAxis_Joystick = 2,
+	EVRControllerAxisType_k_eControllerAxis_Trigger = 3,
+} EVRControllerAxisType;
+
+typedef enum EVRControllerEventOutputType
+{
+	EVRControllerEventOutputType_ControllerEventOutput_OSEvents = 0,
+	EVRControllerEventOutputType_ControllerEventOutput_VREvents = 1,
+} EVRControllerEventOutputType;
+
+typedef enum ECollisionBoundsStyle
+{
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_BEGINNER = 0,
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_INTERMEDIATE = 1,
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_SQUARES = 2,
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_ADVANCED = 3,
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_NONE = 4,
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_COUNT = 5,
+} ECollisionBoundsStyle;
+
+typedef enum EVROverlayError
+{
+	EVROverlayError_VROverlayError_None = 0,
+	EVROverlayError_VROverlayError_UnknownOverlay = 10,
+	EVROverlayError_VROverlayError_InvalidHandle = 11,
+	EVROverlayError_VROverlayError_PermissionDenied = 12,
+	EVROverlayError_VROverlayError_OverlayLimitExceeded = 13,
+	EVROverlayError_VROverlayError_WrongVisibilityType = 14,
+	EVROverlayError_VROverlayError_KeyTooLong = 15,
+	EVROverlayError_VROverlayError_NameTooLong = 16,
+	EVROverlayError_VROverlayError_KeyInUse = 17,
+	EVROverlayError_VROverlayError_WrongTransformType = 18,
+	EVROverlayError_VROverlayError_InvalidTrackedDevice = 19,
+	EVROverlayError_VROverlayError_InvalidParameter = 20,
+	EVROverlayError_VROverlayError_ThumbnailCantBeDestroyed = 21,
+	EVROverlayError_VROverlayError_ArrayTooSmall = 22,
+	EVROverlayError_VROverlayError_RequestFailed = 23,
+	EVROverlayError_VROverlayError_InvalidTexture = 24,
+	EVROverlayError_VROverlayError_UnableToLoadFile = 25,
+	EVROverlayError_VROverlayError_KeyboardAlreadyInUse = 26,
+	EVROverlayError_VROverlayError_NoNeighbor = 27,
+	EVROverlayError_VROverlayError_TooManyMaskPrimitives = 29,
+	EVROverlayError_VROverlayError_BadMaskPrimitive = 30,
+} EVROverlayError;
+
+typedef enum EVRApplicationType
+{
+	EVRApplicationType_VRApplication_Other = 0,
+	EVRApplicationType_VRApplication_Scene = 1,
+	EVRApplicationType_VRApplication_Overlay = 2,
+	EVRApplicationType_VRApplication_Background = 3,
+	EVRApplicationType_VRApplication_Utility = 4,
+	EVRApplicationType_VRApplication_VRMonitor = 5,
+	EVRApplicationType_VRApplication_SteamWatchdog = 6,
+	EVRApplicationType_VRApplication_Bootstrapper = 7,
+	EVRApplicationType_VRApplication_Max = 8,
+} EVRApplicationType;
+
+typedef enum EVRFirmwareError
+{
+	EVRFirmwareError_VRFirmwareError_None = 0,
+	EVRFirmwareError_VRFirmwareError_Success = 1,
+	EVRFirmwareError_VRFirmwareError_Fail = 2,
+} EVRFirmwareError;
+
+typedef enum EVRNotificationError
+{
+	EVRNotificationError_VRNotificationError_OK = 0,
+	EVRNotificationError_VRNotificationError_InvalidNotificationId = 100,
+	EVRNotificationError_VRNotificationError_NotificationQueueFull = 101,
+	EVRNotificationError_VRNotificationError_InvalidOverlayHandle = 102,
+	EVRNotificationError_VRNotificationError_SystemWithUserValueAlreadyExists = 103,
+} EVRNotificationError;
+
+typedef enum EVRInitError
+{
+	EVRInitError_VRInitError_None = 0,
+	EVRInitError_VRInitError_Unknown = 1,
+	EVRInitError_VRInitError_Init_InstallationNotFound = 100,
+	EVRInitError_VRInitError_Init_InstallationCorrupt = 101,
+	EVRInitError_VRInitError_Init_VRClientDLLNotFound = 102,
+	EVRInitError_VRInitError_Init_FileNotFound = 103,
+	EVRInitError_VRInitError_Init_FactoryNotFound = 104,
+	EVRInitError_VRInitError_Init_InterfaceNotFound = 105,
+	EVRInitError_VRInitError_Init_InvalidInterface = 106,
+	EVRInitError_VRInitError_Init_UserConfigDirectoryInvalid = 107,
+	EVRInitError_VRInitError_Init_HmdNotFound = 108,
+	EVRInitError_VRInitError_Init_NotInitialized = 109,
+	EVRInitError_VRInitError_Init_PathRegistryNotFound = 110,
+	EVRInitError_VRInitError_Init_NoConfigPath = 111,
+	EVRInitError_VRInitError_Init_NoLogPath = 112,
+	EVRInitError_VRInitError_Init_PathRegistryNotWritable = 113,
+	EVRInitError_VRInitError_Init_AppInfoInitFailed = 114,
+	EVRInitError_VRInitError_Init_Retry = 115,
+	EVRInitError_VRInitError_Init_InitCanceledByUser = 116,
+	EVRInitError_VRInitError_Init_AnotherAppLaunching = 117,
+	EVRInitError_VRInitError_Init_SettingsInitFailed = 118,
+	EVRInitError_VRInitError_Init_ShuttingDown = 119,
+	EVRInitError_VRInitError_Init_TooManyObjects = 120,
+	EVRInitError_VRInitError_Init_NoServerForBackgroundApp = 121,
+	EVRInitError_VRInitError_Init_NotSupportedWithCompositor = 122,
+	EVRInitError_VRInitError_Init_NotAvailableToUtilityApps = 123,
+	EVRInitError_VRInitError_Init_Internal = 124,
+	EVRInitError_VRInitError_Init_HmdDriverIdIsNone = 125,
+	EVRInitError_VRInitError_Init_HmdNotFoundPresenceFailed = 126,
+	EVRInitError_VRInitError_Init_VRMonitorNotFound = 127,
+	EVRInitError_VRInitError_Init_VRMonitorStartupFailed = 128,
+	EVRInitError_VRInitError_Init_LowPowerWatchdogNotSupported = 129,
+	EVRInitError_VRInitError_Init_InvalidApplicationType = 130,
+	EVRInitError_VRInitError_Init_NotAvailableToWatchdogApps = 131,
+	EVRInitError_VRInitError_Init_WatchdogDisabledInSettings = 132,
+	EVRInitError_VRInitError_Init_VRDashboardNotFound = 133,
+	EVRInitError_VRInitError_Init_VRDashboardStartupFailed = 134,
+	EVRInitError_VRInitError_Init_VRHomeNotFound = 135,
+	EVRInitError_VRInitError_Init_VRHomeStartupFailed = 136,
+	EVRInitError_VRInitError_Init_RebootingBusy = 137,
+	EVRInitError_VRInitError_Init_FirmwareUpdateBusy = 138,
+	EVRInitError_VRInitError_Init_FirmwareRecoveryBusy = 139,
+	EVRInitError_VRInitError_Driver_Failed = 200,
+	EVRInitError_VRInitError_Driver_Unknown = 201,
+	EVRInitError_VRInitError_Driver_HmdUnknown = 202,
+	EVRInitError_VRInitError_Driver_NotLoaded = 203,
+	EVRInitError_VRInitError_Driver_RuntimeOutOfDate = 204,
+	EVRInitError_VRInitError_Driver_HmdInUse = 205,
+	EVRInitError_VRInitError_Driver_NotCalibrated = 206,
+	EVRInitError_VRInitError_Driver_CalibrationInvalid = 207,
+	EVRInitError_VRInitError_Driver_HmdDisplayNotFound = 208,
+	EVRInitError_VRInitError_Driver_TrackedDeviceInterfaceUnknown = 209,
+	EVRInitError_VRInitError_Driver_HmdDriverIdOutOfBounds = 211,
+	EVRInitError_VRInitError_Driver_HmdDisplayMirrored = 212,
+	EVRInitError_VRInitError_IPC_ServerInitFailed = 300,
+	EVRInitError_VRInitError_IPC_ConnectFailed = 301,
+	EVRInitError_VRInitError_IPC_SharedStateInitFailed = 302,
+	EVRInitError_VRInitError_IPC_CompositorInitFailed = 303,
+	EVRInitError_VRInitError_IPC_MutexInitFailed = 304,
+	EVRInitError_VRInitError_IPC_Failed = 305,
+	EVRInitError_VRInitError_IPC_CompositorConnectFailed = 306,
+	EVRInitError_VRInitError_IPC_CompositorInvalidConnectResponse = 307,
+	EVRInitError_VRInitError_IPC_ConnectFailedAfterMultipleAttempts = 308,
+	EVRInitError_VRInitError_Compositor_Failed = 400,
+	EVRInitError_VRInitError_Compositor_D3D11HardwareRequired = 401,
+	EVRInitError_VRInitError_Compositor_FirmwareRequiresUpdate = 402,
+	EVRInitError_VRInitError_Compositor_OverlayInitFailed = 403,
+	EVRInitError_VRInitError_Compositor_ScreenshotsInitFailed = 404,
+	EVRInitError_VRInitError_Compositor_UnableToCreateDevice = 405,
+	EVRInitError_VRInitError_VendorSpecific_UnableToConnectToOculusRuntime = 1000,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_CantOpenDevice = 1101,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToRequestConfigStart = 1102,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_NoStoredConfig = 1103,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_ConfigTooBig = 1104,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_ConfigTooSmall = 1105,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToInitZLib = 1106,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_CantReadFirmwareVersion = 1107,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToSendUserDataStart = 1108,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataStart = 1109,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataNext = 1110,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UserDataAddressRange = 1111,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UserDataError = 1112,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_ConfigFailedSanityCheck = 1113,
+	EVRInitError_VRInitError_Steam_SteamInstallationNotFound = 2000,
+} EVRInitError;
+
+typedef enum EVRScreenshotType
+{
+	EVRScreenshotType_VRScreenshotType_None = 0,
+	EVRScreenshotType_VRScreenshotType_Mono = 1,
+	EVRScreenshotType_VRScreenshotType_Stereo = 2,
+	EVRScreenshotType_VRScreenshotType_Cubemap = 3,
+	EVRScreenshotType_VRScreenshotType_MonoPanorama = 4,
+	EVRScreenshotType_VRScreenshotType_StereoPanorama = 5,
+} EVRScreenshotType;
+
+typedef enum EVRScreenshotPropertyFilenames
+{
+	EVRScreenshotPropertyFilenames_VRScreenshotPropertyFilenames_Preview = 0,
+	EVRScreenshotPropertyFilenames_VRScreenshotPropertyFilenames_VR = 1,
+} EVRScreenshotPropertyFilenames;
+
+typedef enum EVRTrackedCameraError
+{
+	EVRTrackedCameraError_VRTrackedCameraError_None = 0,
+	EVRTrackedCameraError_VRTrackedCameraError_OperationFailed = 100,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidHandle = 101,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidFrameHeaderVersion = 102,
+	EVRTrackedCameraError_VRTrackedCameraError_OutOfHandles = 103,
+	EVRTrackedCameraError_VRTrackedCameraError_IPCFailure = 104,
+	EVRTrackedCameraError_VRTrackedCameraError_NotSupportedForThisDevice = 105,
+	EVRTrackedCameraError_VRTrackedCameraError_SharedMemoryFailure = 106,
+	EVRTrackedCameraError_VRTrackedCameraError_FrameBufferingFailure = 107,
+	EVRTrackedCameraError_VRTrackedCameraError_StreamSetupFailure = 108,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidGLTextureId = 109,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidSharedTextureHandle = 110,
+	EVRTrackedCameraError_VRTrackedCameraError_FailedToGetGLTextureId = 111,
+	EVRTrackedCameraError_VRTrackedCameraError_SharedTextureFailure = 112,
+	EVRTrackedCameraError_VRTrackedCameraError_NoFrameAvailable = 113,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidArgument = 114,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidFrameBufferSize = 115,
+} EVRTrackedCameraError;
+
+typedef enum EVRTrackedCameraFrameType
+{
+	EVRTrackedCameraFrameType_VRTrackedCameraFrameType_Distorted = 0,
+	EVRTrackedCameraFrameType_VRTrackedCameraFrameType_Undistorted = 1,
+	EVRTrackedCameraFrameType_VRTrackedCameraFrameType_MaximumUndistorted = 2,
+	EVRTrackedCameraFrameType_MAX_CAMERA_FRAME_TYPES = 3,
+} EVRTrackedCameraFrameType;
+
+typedef enum EVRApplicationError
+{
+	EVRApplicationError_VRApplicationError_None = 0,
+	EVRApplicationError_VRApplicationError_AppKeyAlreadyExists = 100,
+	EVRApplicationError_VRApplicationError_NoManifest = 101,
+	EVRApplicationError_VRApplicationError_NoApplication = 102,
+	EVRApplicationError_VRApplicationError_InvalidIndex = 103,
+	EVRApplicationError_VRApplicationError_UnknownApplication = 104,
+	EVRApplicationError_VRApplicationError_IPCFailed = 105,
+	EVRApplicationError_VRApplicationError_ApplicationAlreadyRunning = 106,
+	EVRApplicationError_VRApplicationError_InvalidManifest = 107,
+	EVRApplicationError_VRApplicationError_InvalidApplication = 108,
+	EVRApplicationError_VRApplicationError_LaunchFailed = 109,
+	EVRApplicationError_VRApplicationError_ApplicationAlreadyStarting = 110,
+	EVRApplicationError_VRApplicationError_LaunchInProgress = 111,
+	EVRApplicationError_VRApplicationError_OldApplicationQuitting = 112,
+	EVRApplicationError_VRApplicationError_TransitionAborted = 113,
+	EVRApplicationError_VRApplicationError_IsTemplate = 114,
+	EVRApplicationError_VRApplicationError_SteamVRIsExiting = 115,
+	EVRApplicationError_VRApplicationError_BufferTooSmall = 200,
+	EVRApplicationError_VRApplicationError_PropertyNotSet = 201,
+	EVRApplicationError_VRApplicationError_UnknownProperty = 202,
+	EVRApplicationError_VRApplicationError_InvalidParameter = 203,
+} EVRApplicationError;
+
+typedef enum EVRApplicationProperty
+{
+	EVRApplicationProperty_VRApplicationProperty_Name_String = 0,
+	EVRApplicationProperty_VRApplicationProperty_LaunchType_String = 11,
+	EVRApplicationProperty_VRApplicationProperty_WorkingDirectory_String = 12,
+	EVRApplicationProperty_VRApplicationProperty_BinaryPath_String = 13,
+	EVRApplicationProperty_VRApplicationProperty_Arguments_String = 14,
+	EVRApplicationProperty_VRApplicationProperty_URL_String = 15,
+	EVRApplicationProperty_VRApplicationProperty_Description_String = 50,
+	EVRApplicationProperty_VRApplicationProperty_NewsURL_String = 51,
+	EVRApplicationProperty_VRApplicationProperty_ImagePath_String = 52,
+	EVRApplicationProperty_VRApplicationProperty_Source_String = 53,
+	EVRApplicationProperty_VRApplicationProperty_IsDashboardOverlay_Bool = 60,
+	EVRApplicationProperty_VRApplicationProperty_IsTemplate_Bool = 61,
+	EVRApplicationProperty_VRApplicationProperty_IsInstanced_Bool = 62,
+	EVRApplicationProperty_VRApplicationProperty_IsInternal_Bool = 63,
+	EVRApplicationProperty_VRApplicationProperty_WantsCompositorPauseInStandby_Bool = 64,
+	EVRApplicationProperty_VRApplicationProperty_LastLaunchTime_Uint64 = 70,
+} EVRApplicationProperty;
+
+typedef enum EVRApplicationTransitionState
+{
+	EVRApplicationTransitionState_VRApplicationTransition_None = 0,
+	EVRApplicationTransitionState_VRApplicationTransition_OldAppQuitSent = 10,
+	EVRApplicationTransitionState_VRApplicationTransition_WaitingForExternalLaunch = 11,
+	EVRApplicationTransitionState_VRApplicationTransition_NewAppLaunched = 20,
+} EVRApplicationTransitionState;
+
+typedef enum ChaperoneCalibrationState
+{
+	ChaperoneCalibrationState_OK = 1,
+	ChaperoneCalibrationState_Warning = 100,
+	ChaperoneCalibrationState_Warning_BaseStationMayHaveMoved = 101,
+	ChaperoneCalibrationState_Warning_BaseStationRemoved = 102,
+	ChaperoneCalibrationState_Warning_SeatedBoundsInvalid = 103,
+	ChaperoneCalibrationState_Error = 200,
+	ChaperoneCalibrationState_Error_BaseStationUninitialized = 201,
+	ChaperoneCalibrationState_Error_BaseStationConflict = 202,
+	ChaperoneCalibrationState_Error_PlayAreaInvalid = 203,
+	ChaperoneCalibrationState_Error_CollisionBoundsInvalid = 204,
+} ChaperoneCalibrationState;
+
+typedef enum EChaperoneConfigFile
+{
+	EChaperoneConfigFile_Live = 1,
+	EChaperoneConfigFile_Temp = 2,
+} EChaperoneConfigFile;
+
+typedef enum EChaperoneImportFlags
+{
+	EChaperoneImportFlags_EChaperoneImport_BoundsOnly = 1,
+} EChaperoneImportFlags;
+
+typedef enum EVRCompositorError
+{
+	EVRCompositorError_VRCompositorError_None = 0,
+	EVRCompositorError_VRCompositorError_RequestFailed = 1,
+	EVRCompositorError_VRCompositorError_IncompatibleVersion = 100,
+	EVRCompositorError_VRCompositorError_DoNotHaveFocus = 101,
+	EVRCompositorError_VRCompositorError_InvalidTexture = 102,
+	EVRCompositorError_VRCompositorError_IsNotSceneApplication = 103,
+	EVRCompositorError_VRCompositorError_TextureIsOnWrongDevice = 104,
+	EVRCompositorError_VRCompositorError_TextureUsesUnsupportedFormat = 105,
+	EVRCompositorError_VRCompositorError_SharedTexturesNotSupported = 106,
+	EVRCompositorError_VRCompositorError_IndexOutOfRange = 107,
+	EVRCompositorError_VRCompositorError_AlreadySubmitted = 108,
+	EVRCompositorError_VRCompositorError_InvalidBounds = 109,
+} EVRCompositorError;
+
+typedef enum VROverlayInputMethod
+{
+	VROverlayInputMethod_None = 0,
+	VROverlayInputMethod_Mouse = 1,
+} VROverlayInputMethod;
+
+typedef enum VROverlayTransformType
+{
+	VROverlayTransformType_VROverlayTransform_Absolute = 0,
+	VROverlayTransformType_VROverlayTransform_TrackedDeviceRelative = 1,
+	VROverlayTransformType_VROverlayTransform_SystemOverlay = 2,
+	VROverlayTransformType_VROverlayTransform_TrackedComponent = 3,
+} VROverlayTransformType;
+
+typedef enum VROverlayFlags
+{
+	VROverlayFlags_None = 0,
+	VROverlayFlags_Curved = 1,
+	VROverlayFlags_RGSS4X = 2,
+	VROverlayFlags_NoDashboardTab = 3,
+	VROverlayFlags_AcceptsGamepadEvents = 4,
+	VROverlayFlags_ShowGamepadFocus = 5,
+	VROverlayFlags_SendVRScrollEvents = 6,
+	VROverlayFlags_SendVRTouchpadEvents = 7,
+	VROverlayFlags_ShowTouchPadScrollWheel = 8,
+	VROverlayFlags_TransferOwnershipToInternalProcess = 9,
+	VROverlayFlags_SideBySide_Parallel = 10,
+	VROverlayFlags_SideBySide_Crossed = 11,
+	VROverlayFlags_Panorama = 12,
+	VROverlayFlags_StereoPanorama = 13,
+	VROverlayFlags_SortWithNonSceneOverlays = 14,
+	VROverlayFlags_VisibleInDashboard = 15,
+} VROverlayFlags;
+
+typedef enum VRMessageOverlayResponse
+{
+	VRMessageOverlayResponse_ButtonPress_0 = 0,
+	VRMessageOverlayResponse_ButtonPress_1 = 1,
+	VRMessageOverlayResponse_ButtonPress_2 = 2,
+	VRMessageOverlayResponse_ButtonPress_3 = 3,
+	VRMessageOverlayResponse_CouldntFindSystemOverlay = 4,
+	VRMessageOverlayResponse_CouldntFindOrCreateClientOverlay = 5,
+	VRMessageOverlayResponse_ApplicationQuit = 6,
+} VRMessageOverlayResponse;
+
+typedef enum EGamepadTextInputMode
+{
+	EGamepadTextInputMode_k_EGamepadTextInputModeNormal = 0,
+	EGamepadTextInputMode_k_EGamepadTextInputModePassword = 1,
+	EGamepadTextInputMode_k_EGamepadTextInputModeSubmit = 2,
+} EGamepadTextInputMode;
+
+typedef enum EGamepadTextInputLineMode
+{
+	EGamepadTextInputLineMode_k_EGamepadTextInputLineModeSingleLine = 0,
+	EGamepadTextInputLineMode_k_EGamepadTextInputLineModeMultipleLines = 1,
+} EGamepadTextInputLineMode;
+
+typedef enum EOverlayDirection
+{
+	EOverlayDirection_OverlayDirection_Up = 0,
+	EOverlayDirection_OverlayDirection_Down = 1,
+	EOverlayDirection_OverlayDirection_Left = 2,
+	EOverlayDirection_OverlayDirection_Right = 3,
+	EOverlayDirection_OverlayDirection_Count = 4,
+} EOverlayDirection;
+
+typedef enum EVROverlayIntersectionMaskPrimitiveType
+{
+	EVROverlayIntersectionMaskPrimitiveType_OverlayIntersectionPrimitiveType_Rectangle = 0,
+	EVROverlayIntersectionMaskPrimitiveType_OverlayIntersectionPrimitiveType_Circle = 1,
+} EVROverlayIntersectionMaskPrimitiveType;
+
+typedef enum EVRRenderModelError
+{
+	EVRRenderModelError_VRRenderModelError_None = 0,
+	EVRRenderModelError_VRRenderModelError_Loading = 100,
+	EVRRenderModelError_VRRenderModelError_NotSupported = 200,
+	EVRRenderModelError_VRRenderModelError_InvalidArg = 300,
+	EVRRenderModelError_VRRenderModelError_InvalidModel = 301,
+	EVRRenderModelError_VRRenderModelError_NoShapes = 302,
+	EVRRenderModelError_VRRenderModelError_MultipleShapes = 303,
+	EVRRenderModelError_VRRenderModelError_TooManyVertices = 304,
+	EVRRenderModelError_VRRenderModelError_MultipleTextures = 305,
+	EVRRenderModelError_VRRenderModelError_BufferTooSmall = 306,
+	EVRRenderModelError_VRRenderModelError_NotEnoughNormals = 307,
+	EVRRenderModelError_VRRenderModelError_NotEnoughTexCoords = 308,
+	EVRRenderModelError_VRRenderModelError_InvalidTexture = 400,
+} EVRRenderModelError;
+
+typedef enum EVRComponentProperty
+{
+	EVRComponentProperty_VRComponentProperty_IsStatic = 1,
+	EVRComponentProperty_VRComponentProperty_IsVisible = 2,
+	EVRComponentProperty_VRComponentProperty_IsTouched = 4,
+	EVRComponentProperty_VRComponentProperty_IsPressed = 8,
+	EVRComponentProperty_VRComponentProperty_IsScrolled = 16,
+} EVRComponentProperty;
+
+typedef enum EVRNotificationType
+{
+	EVRNotificationType_Transient = 0,
+	EVRNotificationType_Persistent = 1,
+	EVRNotificationType_Transient_SystemWithUserValue = 2,
+} EVRNotificationType;
+
+typedef enum EVRNotificationStyle
+{
+	EVRNotificationStyle_None = 0,
+	EVRNotificationStyle_Application = 100,
+	EVRNotificationStyle_Contact_Disabled = 200,
+	EVRNotificationStyle_Contact_Enabled = 201,
+	EVRNotificationStyle_Contact_Active = 202,
+} EVRNotificationStyle;
+
+typedef enum EVRSettingsError
+{
+	EVRSettingsError_VRSettingsError_None = 0,
+	EVRSettingsError_VRSettingsError_IPCFailed = 1,
+	EVRSettingsError_VRSettingsError_WriteFailed = 2,
+	EVRSettingsError_VRSettingsError_ReadFailed = 3,
+	EVRSettingsError_VRSettingsError_JsonParseFailed = 4,
+	EVRSettingsError_VRSettingsError_UnsetSettingHasNoDefault = 5,
+} EVRSettingsError;
+
+typedef enum EVRScreenshotError
+{
+	EVRScreenshotError_VRScreenshotError_None = 0,
+	EVRScreenshotError_VRScreenshotError_RequestFailed = 1,
+	EVRScreenshotError_VRScreenshotError_IncompatibleVersion = 100,
+	EVRScreenshotError_VRScreenshotError_NotFound = 101,
+	EVRScreenshotError_VRScreenshotError_BufferTooSmall = 102,
+	EVRScreenshotError_VRScreenshotError_ScreenshotAlreadyInProgress = 108,
+} EVRScreenshotError;
+
+// OpenVR typedefs
+
+typedef uint32_t TrackedDeviceIndex_t;
+typedef uint32_t VRNotificationId;
+typedef uint64_t VROverlayHandle_t;
+
+typedef void *glSharedTextureHandle_t;
+typedef int32_t glInt_t;
+typedef uint32_t glUInt_t;
+typedef uint64_t SharedTextureHandle_t;
+typedef uint32_t DriverId_t;
+typedef uint32_t TrackedDeviceIndex_t;
+typedef uint64_t PropertyContainerHandle_t;
+typedef uint32_t PropertyTypeTag_t;
+typedef uint64_t VROverlayHandle_t;
+typedef uint64_t TrackedCameraHandle_t;
+typedef uint32_t ScreenshotHandle_t;
+typedef uint32_t VRComponentProperties;
+typedef int32_t TextureID_t;
+typedef uint32_t VRNotificationId;
+typedef EVRInitError HmdError;
+typedef EVREye Hmd_Eye;
+typedef EColorSpace ColorSpace;
+typedef ETrackingResult HmdTrackingResult;
+typedef ETrackedDeviceClass TrackedDeviceClass;
+typedef ETrackingUniverseOrigin TrackingUniverseOrigin;
+typedef ETrackedDeviceProperty TrackedDeviceProperty;
+typedef ETrackedPropertyError TrackedPropertyError;
+typedef EVRSubmitFlags VRSubmitFlags_t;
+typedef EVRState VRState_t;
+typedef ECollisionBoundsStyle CollisionBoundsStyle_t;
+typedef EVROverlayError VROverlayError;
+typedef EVRFirmwareError VRFirmwareError;
+typedef EVRCompositorError VRCompositorError;
+typedef EVRScreenshotError VRScreenshotsError;
+
+// OpenVR Structs
+
+typedef struct HmdMatrix34_t
+{
+	float m[3][4];  //float[3][4]
+} HmdMatrix34_t;
+
+typedef struct HmdMatrix44_t
+{
+	float m[4][4];  //float[4][4]
+} HmdMatrix44_t;
+
+typedef struct HmdVector3_t
+{
+	float v[3];  //float[3]
+} HmdVector3_t;
+
+typedef struct HmdVector4_t
+{
+	float v[4];  //float[4]
+} HmdVector4_t;
+
+typedef struct HmdVector3d_t
+{
+	double v[3];  //double[3]
+} HmdVector3d_t;
+
+typedef struct HmdVector2_t
+{
+	float v[2];  //float[2]
+} HmdVector2_t;
+
+typedef struct HmdQuaternion_t
+{
+	double w;
+	double x;
+	double y;
+	double z;
+} HmdQuaternion_t;
+
+typedef struct HmdColor_t
+{
+	float r;
+	float g;
+	float b;
+	float a;
+} HmdColor_t;
+
+typedef struct HmdQuad_t
+{
+	struct HmdVector3_t vCorners[4];  //struct vr::HmdVector3_t[4]
+} HmdQuad_t;
+
+typedef struct HmdRect2_t
+{
+	struct HmdVector2_t vTopLeft;
+	struct HmdVector2_t vBottomRight;
+} HmdRect2_t;
+
+typedef struct DistortionCoordinates_t
+{
+	float rfRed[2];    //float[2]
+	float rfGreen[2];  //float[2]
+	float rfBlue[2];   //float[2]
+} DistortionCoordinates_t;
+
+typedef struct Texture_t
+{
+	void *handle;  // void *
+	enum ETextureType eType;
+	enum EColorSpace eColorSpace;
+} Texture_t;
+
+typedef struct TrackedDevicePose_t
+{
+	struct HmdMatrix34_t mDeviceToAbsoluteTracking;
+	struct HmdVector3_t vVelocity;
+	struct HmdVector3_t vAngularVelocity;
+	enum ETrackingResult eTrackingResult;
+	bool bPoseIsValid;
+	bool bDeviceIsConnected;
+} TrackedDevicePose_t;
+
+typedef struct VRTextureBounds_t
+{
+	float uMin;
+	float vMin;
+	float uMax;
+	float vMax;
+} VRTextureBounds_t;
+
+typedef struct VRTextureWithPose_t
+{
+	struct HmdMatrix34_t mDeviceToAbsoluteTracking;
+} VRTextureWithPose_t;
+
+typedef struct VRVulkanTextureData_t
+{
+	uint64_t m_nImage;
+	struct VkDevice_T *m_pDevice;                  // struct VkDevice_T *
+	struct VkPhysicalDevice_T *m_pPhysicalDevice;  // struct VkPhysicalDevice_T *
+	struct VkInstance_T *m_pInstance;              // struct VkInstance_T *
+	struct VkQueue_T *m_pQueue;                    // struct VkQueue_T *
+	uint32_t m_nQueueFamilyIndex;
+	uint32_t m_nWidth;
+	uint32_t m_nHeight;
+	uint32_t m_nFormat;
+	uint32_t m_nSampleCount;
+} VRVulkanTextureData_t;
+
+typedef struct D3D12TextureData_t
+{
+	struct ID3D12Resource *m_pResource;          // struct ID3D12Resource *
+	struct ID3D12CommandQueue *m_pCommandQueue;  // struct ID3D12CommandQueue *
+	uint32_t m_nNodeMask;
+} D3D12TextureData_t;
+
+typedef struct VREvent_Controller_t
+{
+	uint32_t button;
+} VREvent_Controller_t;
+
+typedef struct VREvent_Mouse_t
+{
+	float x;
+	float y;
+	uint32_t button;
+} VREvent_Mouse_t;
+
+typedef struct VREvent_Scroll_t
+{
+	float xdelta;
+	float ydelta;
+	uint32_t repeatCount;
+} VREvent_Scroll_t;
+
+typedef struct VREvent_TouchPadMove_t
+{
+	bool bFingerDown;
+	float flSecondsFingerDown;
+	float fValueXFirst;
+	float fValueYFirst;
+	float fValueXRaw;
+	float fValueYRaw;
+} VREvent_TouchPadMove_t;
+
+typedef struct VREvent_Notification_t
+{
+	uint64_t ulUserValue;
+	uint32_t notificationId;
+} VREvent_Notification_t;
+
+typedef struct VREvent_Process_t
+{
+	uint32_t pid;
+	uint32_t oldPid;
+	bool bForced;
+} VREvent_Process_t;
+
+typedef struct VREvent_Overlay_t
+{
+	uint64_t overlayHandle;
+} VREvent_Overlay_t;
+
+typedef struct VREvent_Status_t
+{
+	uint32_t statusState;
+} VREvent_Status_t;
+
+typedef struct VREvent_Keyboard_t
+{
+	char *cNewInput[8];  //char[8]
+	uint64_t uUserValue;
+} VREvent_Keyboard_t;
+
+typedef struct VREvent_Ipd_t
+{
+	float ipdMeters;
+} VREvent_Ipd_t;
+
+typedef struct VREvent_Chaperone_t
+{
+	uint64_t m_nPreviousUniverse;
+	uint64_t m_nCurrentUniverse;
+} VREvent_Chaperone_t;
+
+typedef struct VREvent_Reserved_t
+{
+	uint64_t reserved0;
+	uint64_t reserved1;
+} VREvent_Reserved_t;
+
+typedef struct VREvent_PerformanceTest_t
+{
+	uint32_t m_nFidelityLevel;
+} VREvent_PerformanceTest_t;
+
+typedef struct VREvent_SeatedZeroPoseReset_t
+{
+	bool bResetBySystemMenu;
+} VREvent_SeatedZeroPoseReset_t;
+
+typedef struct VREvent_Screenshot_t
+{
+	uint32_t handle;
+	uint32_t type;
+} VREvent_Screenshot_t;
+
+typedef struct VREvent_ScreenshotProgress_t
+{
+	float progress;
+} VREvent_ScreenshotProgress_t;
+
+typedef struct VREvent_ApplicationLaunch_t
+{
+	uint32_t pid;
+	uint32_t unArgsHandle;
+} VREvent_ApplicationLaunch_t;
+
+typedef struct VREvent_EditingCameraSurface_t
+{
+	uint64_t overlayHandle;
+	uint32_t nVisualMode;
+} VREvent_EditingCameraSurface_t;
+
+typedef struct VREvent_MessageOverlay_t
+{
+	uint32_t unVRMessageOverlayResponse;
+} VREvent_MessageOverlay_t;
+
+typedef struct VREvent_Property_t
+{
+	PropertyContainerHandle_t container;
+	enum ETrackedDeviceProperty prop;
+} VREvent_Property_t;
+
+typedef struct HiddenAreaMesh_t
+{
+	struct HmdVector2_t *pVertexData;  // const struct vr::HmdVector2_t *
+	uint32_t unTriangleCount;
+} HiddenAreaMesh_t;
+
+typedef struct VRControllerAxis_t
+{
+	float x;
+	float y;
+} VRControllerAxis_t;
+
+typedef struct VRControllerState_t
+{
+	uint32_t unPacketNum;
+	uint64_t ulButtonPressed;
+	uint64_t ulButtonTouched;
+	struct VRControllerAxis_t rAxis[5];  //struct vr::VRControllerAxis_t[5]
+} VRControllerState_t;
+
+typedef struct Compositor_OverlaySettings
+{
+	uint32_t size;
+	bool curved;
+	bool antialias;
+	float scale;
+	float distance;
+	float alpha;
+	float uOffset;
+	float vOffset;
+	float uScale;
+	float vScale;
+	float gridDivs;
+	float gridWidth;
+	float gridScale;
+	struct HmdMatrix44_t transform;
+} Compositor_OverlaySettings;
+
+typedef struct CameraVideoStreamFrameHeader_t
+{
+	enum EVRTrackedCameraFrameType eFrameType;
+	uint32_t nWidth;
+	uint32_t nHeight;
+	uint32_t nBytesPerPixel;
+	uint32_t nFrameSequence;
+	struct TrackedDevicePose_t standingTrackedDevicePose;
+} CameraVideoStreamFrameHeader_t;
+
+typedef struct AppOverrideKeys_t
+{
+	char *pchKey;    // const char *
+	char *pchValue;  // const char *
+} AppOverrideKeys_t;
+
+typedef struct Compositor_FrameTiming
+{
+	uint32_t m_nSize;
+	uint32_t m_nFrameIndex;
+	uint32_t m_nNumFramePresents;
+	uint32_t m_nNumMisPresented;
+	uint32_t m_nNumDroppedFrames;
+	uint32_t m_nReprojectionFlags;
+	double m_flSystemTimeInSeconds;
+	float m_flPreSubmitGpuMs;
+	float m_flPostSubmitGpuMs;
+	float m_flTotalRenderGpuMs;
+	float m_flCompositorRenderGpuMs;
+	float m_flCompositorRenderCpuMs;
+	float m_flCompositorIdleCpuMs;
+	float m_flClientFrameIntervalMs;
+	float m_flPresentCallCpuMs;
+	float m_flWaitForPresentCpuMs;
+	float m_flSubmitFrameMs;
+	float m_flWaitGetPosesCalledMs;
+	float m_flNewPosesReadyMs;
+	float m_flNewFrameReadyMs;
+	float m_flCompositorUpdateStartMs;
+	float m_flCompositorUpdateEndMs;
+	float m_flCompositorRenderStartMs;
+	TrackedDevicePose_t m_HmdPose;
+} Compositor_FrameTiming;
+
+typedef struct Compositor_CumulativeStats
+{
+	uint32_t m_nPid;
+	uint32_t m_nNumFramePresents;
+	uint32_t m_nNumDroppedFrames;
+	uint32_t m_nNumReprojectedFrames;
+	uint32_t m_nNumFramePresentsOnStartup;
+	uint32_t m_nNumDroppedFramesOnStartup;
+	uint32_t m_nNumReprojectedFramesOnStartup;
+	uint32_t m_nNumLoading;
+	uint32_t m_nNumFramePresentsLoading;
+	uint32_t m_nNumDroppedFramesLoading;
+	uint32_t m_nNumReprojectedFramesLoading;
+	uint32_t m_nNumTimedOut;
+	uint32_t m_nNumFramePresentsTimedOut;
+	uint32_t m_nNumDroppedFramesTimedOut;
+	uint32_t m_nNumReprojectedFramesTimedOut;
+} Compositor_CumulativeStats;
+
+typedef struct VROverlayIntersectionParams_t
+{
+	struct HmdVector3_t vSource;
+	struct HmdVector3_t vDirection;
+	enum ETrackingUniverseOrigin eOrigin;
+} VROverlayIntersectionParams_t;
+
+typedef struct VROverlayIntersectionResults_t
+{
+	struct HmdVector3_t vPoint;
+	struct HmdVector3_t vNormal;
+	struct HmdVector2_t vUVs;
+	float fDistance;
+} VROverlayIntersectionResults_t;
+
+typedef struct IntersectionMaskRectangle_t
+{
+	float m_flTopLeftX;
+	float m_flTopLeftY;
+	float m_flWidth;
+	float m_flHeight;
+} IntersectionMaskRectangle_t;
+
+typedef struct IntersectionMaskCircle_t
+{
+	float m_flCenterX;
+	float m_flCenterY;
+	float m_flRadius;
+} IntersectionMaskCircle_t;
+
+typedef struct RenderModel_ComponentState_t
+{
+	struct HmdMatrix34_t mTrackingToComponentRenderModel;
+	struct HmdMatrix34_t mTrackingToComponentLocal;
+	VRComponentProperties uProperties;
+} RenderModel_ComponentState_t;
+
+typedef struct RenderModel_Vertex_t
+{
+	struct HmdVector3_t vPosition;
+	struct HmdVector3_t vNormal;
+	float rfTextureCoord[2];  //float[2]
+} RenderModel_Vertex_t;
+
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(push, 4)
+#endif
+typedef struct RenderModel_TextureMap_t
+{
+	uint16_t unWidth;
+	uint16_t unHeight;
+	uint8_t *rubTextureMapData;  // const uint8_t *
+} RenderModel_TextureMap_t;
+
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(push, 4)
+#endif
+typedef struct RenderModel_t
+{
+	struct RenderModel_Vertex_t *rVertexData;  // const struct vr::RenderModel_Vertex_t *
+	uint32_t unVertexCount;
+	uint16_t *rIndexData;  // const uint16_t *
+	uint32_t unTriangleCount;
+	TextureID_t diffuseTextureId;
+} RenderModel_t;
+
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+typedef struct RenderModel_ControllerMode_State_t
+{
+	bool bScrollWheelVisible;
+} RenderModel_ControllerMode_State_t;
+
+typedef struct NotificationBitmap_t
+{
+	void *m_pImageData;  // void *
+	int32_t m_nWidth;
+	int32_t m_nHeight;
+	int32_t m_nBytesPerPixel;
+} NotificationBitmap_t;
+
+typedef struct COpenVRContext
+{
+	intptr_t m_pVRSystem;           // class vr::IVRSystem *
+	intptr_t m_pVRChaperone;        // class vr::IVRChaperone *
+	intptr_t m_pVRChaperoneSetup;   // class vr::IVRChaperoneSetup *
+	intptr_t m_pVRCompositor;       // class vr::IVRCompositor *
+	intptr_t m_pVROverlay;          // class vr::IVROverlay *
+	intptr_t m_pVRResources;        // class vr::IVRResources *
+	intptr_t m_pVRRenderModels;     // class vr::IVRRenderModels *
+	intptr_t m_pVRExtendedDisplay;  // class vr::IVRExtendedDisplay *
+	intptr_t m_pVRSettings;         // class vr::IVRSettings *
+	intptr_t m_pVRApplications;     // class vr::IVRApplications *
+	intptr_t m_pVRTrackedCamera;    // class vr::IVRTrackedCamera *
+	intptr_t m_pVRScreenshots;      // class vr::IVRScreenshots *
+	intptr_t m_pVRDriverManager;    // class vr::IVRDriverManager *
+} COpenVRContext;
+
+typedef union {
+	VREvent_Reserved_t reserved;
+	VREvent_Controller_t controller;
+	VREvent_Mouse_t mouse;
+	VREvent_Scroll_t scroll;
+	VREvent_Process_t process;
+	VREvent_Notification_t notification;
+	VREvent_Overlay_t overlay;
+	VREvent_Status_t status;
+	VREvent_Keyboard_t keyboard;
+	VREvent_Ipd_t ipd;
+	VREvent_Chaperone_t chaperone;
+	VREvent_PerformanceTest_t performanceTest;
+	VREvent_TouchPadMove_t touchPadMove;
+	VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset;
+} VREvent_Data_t;
+
+/** An event posted by the server to all running applications */
+struct VREvent_t
+{
+	uint32_t eventType;  // EVREventType enum
+	TrackedDeviceIndex_t trackedDeviceIndex;
+	float eventAgeSeconds;
+	// event data must be the end of the struct as its size is variable
+	VREvent_Data_t data;
+};
+
+typedef union {
+	IntersectionMaskRectangle_t m_Rectangle;
+	IntersectionMaskCircle_t m_Circle;
+} VROverlayIntersectionMaskPrimitive_Data_t;
+
+struct VROverlayIntersectionMaskPrimitive_t
+{
+	EVROverlayIntersectionMaskPrimitiveType m_nPrimitiveType;
+	VROverlayIntersectionMaskPrimitive_Data_t m_Primitive;
+};
+
+// OpenVR Function Pointer Tables
+
+struct VR_IVRSystem_FnTable
+{
+	void(OPENVR_FNTABLE_CALLTYPE *GetRecommendedRenderTargetSize)(uint32_t *pnWidth, uint32_t *pnHeight);
+	struct HmdMatrix44_t(OPENVR_FNTABLE_CALLTYPE *GetProjectionMatrix)(EVREye eEye, float fNearZ, float fFarZ);
+	void(OPENVR_FNTABLE_CALLTYPE *GetProjectionRaw)(EVREye eEye, float *pfLeft, float *pfRight, float *pfTop, float *pfBottom);
+	bool(OPENVR_FNTABLE_CALLTYPE *ComputeDistortion)(EVREye eEye, float fU, float fV, struct DistortionCoordinates_t *pDistortionCoordinates);
+	struct HmdMatrix34_t(OPENVR_FNTABLE_CALLTYPE *GetEyeToHeadTransform)(EVREye eEye);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetTimeSinceLastVsync)(float *pfSecondsSinceLastVsync, uint64_t *pulFrameCounter);
+	int32_t(OPENVR_FNTABLE_CALLTYPE *GetD3D9AdapterIndex)();
+	void(OPENVR_FNTABLE_CALLTYPE *GetDXGIOutputInfo)(int32_t *pnAdapterIndex);
+	void(OPENVR_FNTABLE_CALLTYPE *GetOutputDevice)(uint64_t *pnDevice, ETextureType textureType, struct VkInstance_T *pInstance);
+	bool(OPENVR_FNTABLE_CALLTYPE *IsDisplayOnDesktop)();
+	bool(OPENVR_FNTABLE_CALLTYPE *SetDisplayVisibility)(bool bIsVisibleOnDesktop);
+	void(OPENVR_FNTABLE_CALLTYPE *GetDeviceToAbsoluteTrackingPose)(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, struct TrackedDevicePose_t *pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount);
+	void(OPENVR_FNTABLE_CALLTYPE *ResetSeatedZeroPose)();
+	struct HmdMatrix34_t(OPENVR_FNTABLE_CALLTYPE *GetSeatedZeroPoseToStandingAbsoluteTrackingPose)();
+	struct HmdMatrix34_t(OPENVR_FNTABLE_CALLTYPE *GetRawZeroPoseToStandingAbsoluteTrackingPose)();
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetSortedTrackedDeviceIndicesOfClass)(ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t *punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex);
+	EDeviceActivityLevel(OPENVR_FNTABLE_CALLTYPE *GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId);
+	void(OPENVR_FNTABLE_CALLTYPE *ApplyTransform)(struct TrackedDevicePose_t *pOutputPose, struct TrackedDevicePose_t *pTrackedDevicePose, struct HmdMatrix34_t *pTransform);
+	TrackedDeviceIndex_t(OPENVR_FNTABLE_CALLTYPE *GetTrackedDeviceIndexForControllerRole)(ETrackedControllerRole unDeviceType);
+	ETrackedControllerRole(OPENVR_FNTABLE_CALLTYPE *GetControllerRoleForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex);
+	ETrackedDeviceClass(OPENVR_FNTABLE_CALLTYPE *GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex);
+	bool(OPENVR_FNTABLE_CALLTYPE *IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError);
+	float(OPENVR_FNTABLE_CALLTYPE *GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError);
+	int32_t(OPENVR_FNTABLE_CALLTYPE *GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError);
+	uint64_t(OPENVR_FNTABLE_CALLTYPE *GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError);
+	struct HmdMatrix34_t(OPENVR_FNTABLE_CALLTYPE *GetMatrix34TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetPropErrorNameFromEnum)(ETrackedPropertyError error);
+	bool(OPENVR_FNTABLE_CALLTYPE *PollNextEvent)(struct VREvent_t *pEvent, uint32_t uncbVREvent);
+	bool(OPENVR_FNTABLE_CALLTYPE *PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, struct VREvent_t *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetEventTypeNameFromEnum)(EVREventType eType);
+	struct HiddenAreaMesh_t(OPENVR_FNTABLE_CALLTYPE *GetHiddenAreaMesh)(EVREye eEye, EHiddenAreaMeshType type);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t *pControllerState, uint32_t unControllerStateSize);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t *pControllerState, uint32_t unControllerStateSize, struct TrackedDevicePose_t *pTrackedDevicePose);
+	void(OPENVR_FNTABLE_CALLTYPE *TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetButtonIdNameFromEnum)(EVRButtonId eButtonId);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType);
+	bool(OPENVR_FNTABLE_CALLTYPE *CaptureInputFocus)();
+	void(OPENVR_FNTABLE_CALLTYPE *ReleaseInputFocus)();
+	bool(OPENVR_FNTABLE_CALLTYPE *IsInputFocusCapturedByAnotherProcess)();
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, char *pchRequest, char *pchResponseBuffer, uint32_t unResponseBufferSize);
+	EVRFirmwareError(OPENVR_FNTABLE_CALLTYPE *PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex);
+	void(OPENVR_FNTABLE_CALLTYPE *AcknowledgeQuit_Exiting)();
+	void(OPENVR_FNTABLE_CALLTYPE *AcknowledgeQuit_UserPrompt)();
+};
+
+struct VR_IVRExtendedDisplay_FnTable
+{
+	void(OPENVR_FNTABLE_CALLTYPE *GetWindowBounds)(int32_t *pnX, int32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight);
+	void(OPENVR_FNTABLE_CALLTYPE *GetEyeOutputViewport)(EVREye eEye, uint32_t *pnX, uint32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight);
+	void(OPENVR_FNTABLE_CALLTYPE *GetDXGIOutputInfo)(int32_t *pnAdapterIndex, int32_t *pnAdapterOutputIndex);
+};
+
+struct VR_IVRTrackedCamera_FnTable
+{
+	char *(OPENVR_FNTABLE_CALLTYPE *GetCameraErrorNameFromEnum)(EVRTrackedCameraError eCameraError);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *HasCamera)(TrackedDeviceIndex_t nDeviceIndex, bool *pHasCamera);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *GetCameraFrameSize)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, uint32_t *pnWidth, uint32_t *pnHeight, uint32_t *pnFrameBufferSize);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *GetCameraIntrinsics)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, HmdVector2_t *pFocalLength, HmdVector2_t *pCenter);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *GetCameraProjection)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, HmdMatrix44_t *pProjection);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *AcquireVideoStreamingService)(TrackedDeviceIndex_t nDeviceIndex, TrackedCameraHandle_t *pHandle);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *ReleaseVideoStreamingService)(TrackedCameraHandle_t hTrackedCamera);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *GetVideoStreamFrameBuffer)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void *pFrameBuffer, uint32_t nFrameBufferSize, CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *GetVideoStreamTextureSize)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, VRTextureBounds_t *pTextureBounds, uint32_t *pnWidth, uint32_t *pnHeight);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *GetVideoStreamTextureD3D11)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView, CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *GetVideoStreamTextureGL)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t *pglTextureId, CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *ReleaseVideoStreamTextureGL)(TrackedCameraHandle_t hTrackedCamera, glUInt_t glTextureId);
+};
+
+struct VR_IVRApplications_FnTable
+{
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *AddApplicationManifest)(char *pchApplicationManifestFullPath, bool bTemporary);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *RemoveApplicationManifest)(char *pchApplicationManifestFullPath);
+	bool(OPENVR_FNTABLE_CALLTYPE *IsApplicationInstalled)(char *pchAppKey);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetApplicationCount)();
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *GetApplicationKeyByIndex)(uint32_t unApplicationIndex, char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *GetApplicationKeyByProcessId)(uint32_t unProcessId, char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *LaunchApplication)(char *pchAppKey);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *LaunchTemplateApplication)(char *pchTemplateAppKey, char *pchNewAppKey, struct AppOverrideKeys_t *pKeys, uint32_t unKeys);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *LaunchApplicationFromMimeType)(char *pchMimeType, char *pchArgs);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *LaunchDashboardOverlay)(char *pchAppKey);
+	bool(OPENVR_FNTABLE_CALLTYPE *CancelApplicationLaunch)(char *pchAppKey);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *IdentifyApplication)(uint32_t unProcessId, char *pchAppKey);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetApplicationProcessId)(char *pchAppKey);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetApplicationsErrorNameFromEnum)(EVRApplicationError error);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetApplicationPropertyString)(char *pchAppKey, EVRApplicationProperty eProperty, char *pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError *peError);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetApplicationPropertyBool)(char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError);
+	uint64_t(OPENVR_FNTABLE_CALLTYPE *GetApplicationPropertyUint64)(char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *SetApplicationAutoLaunch)(char *pchAppKey, bool bAutoLaunch);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetApplicationAutoLaunch)(char *pchAppKey);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *SetDefaultApplicationForMimeType)(char *pchAppKey, char *pchMimeType);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetDefaultApplicationForMimeType)(char *pchMimeType, char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetApplicationSupportedMimeTypes)(char *pchAppKey, char *pchMimeTypesBuffer, uint32_t unMimeTypesBuffer);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetApplicationsThatSupportMimeType)(char *pchMimeType, char *pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetApplicationLaunchArguments)(uint32_t unHandle, char *pchArgs, uint32_t unArgs);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *GetStartingApplication)(char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+	EVRApplicationTransitionState(OPENVR_FNTABLE_CALLTYPE *GetTransitionState)();
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *PerformApplicationPrelaunchCheck)(char *pchAppKey);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetApplicationsTransitionStateNameFromEnum)(EVRApplicationTransitionState state);
+	bool(OPENVR_FNTABLE_CALLTYPE *IsQuitUserPromptRequested)();
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *LaunchInternalProcess)(char *pchBinaryPath, char *pchArguments, char *pchWorkingDirectory);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetCurrentSceneProcessId)();
+};
+
+struct VR_IVRChaperone_FnTable
+{
+	ChaperoneCalibrationState(OPENVR_FNTABLE_CALLTYPE *GetCalibrationState)();
+	bool(OPENVR_FNTABLE_CALLTYPE *GetPlayAreaSize)(float *pSizeX, float *pSizeZ);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetPlayAreaRect)(struct HmdQuad_t *rect);
+	void(OPENVR_FNTABLE_CALLTYPE *ReloadInfo)();
+	void(OPENVR_FNTABLE_CALLTYPE *SetSceneColor)(struct HmdColor_t color);
+	void(OPENVR_FNTABLE_CALLTYPE *GetBoundsColor)(struct HmdColor_t *pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, struct HmdColor_t *pOutputCameraColor);
+	bool(OPENVR_FNTABLE_CALLTYPE *AreBoundsVisible)();
+	void(OPENVR_FNTABLE_CALLTYPE *ForceBoundsVisible)(bool bForce);
+};
+
+struct VR_IVRChaperoneSetup_FnTable
+{
+	bool(OPENVR_FNTABLE_CALLTYPE *CommitWorkingCopy)(EChaperoneConfigFile configFile);
+	void(OPENVR_FNTABLE_CALLTYPE *RevertWorkingCopy)();
+	bool(OPENVR_FNTABLE_CALLTYPE *GetWorkingPlayAreaSize)(float *pSizeX, float *pSizeZ);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetWorkingPlayAreaRect)(struct HmdQuad_t *rect);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetWorkingCollisionBoundsInfo)(struct HmdQuad_t *pQuadsBuffer, uint32_t *punQuadsCount);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetLiveCollisionBoundsInfo)(struct HmdQuad_t *pQuadsBuffer, uint32_t *punQuadsCount);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetWorkingSeatedZeroPoseToRawTrackingPose)(struct HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetWorkingStandingZeroPoseToRawTrackingPose)(struct HmdMatrix34_t *pmatStandingZeroPoseToRawTrackingPose);
+	void(OPENVR_FNTABLE_CALLTYPE *SetWorkingPlayAreaSize)(float sizeX, float sizeZ);
+	void(OPENVR_FNTABLE_CALLTYPE *SetWorkingCollisionBoundsInfo)(struct HmdQuad_t *pQuadsBuffer, uint32_t unQuadsCount);
+	void(OPENVR_FNTABLE_CALLTYPE *SetWorkingSeatedZeroPoseToRawTrackingPose)(struct HmdMatrix34_t *pMatSeatedZeroPoseToRawTrackingPose);
+	void(OPENVR_FNTABLE_CALLTYPE *SetWorkingStandingZeroPoseToRawTrackingPose)(struct HmdMatrix34_t *pMatStandingZeroPoseToRawTrackingPose);
+	void(OPENVR_FNTABLE_CALLTYPE *ReloadFromDisk)(EChaperoneConfigFile configFile);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetLiveSeatedZeroPoseToRawTrackingPose)(struct HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose);
+	void(OPENVR_FNTABLE_CALLTYPE *SetWorkingCollisionBoundsTagsInfo)(uint8_t *pTagsBuffer, uint32_t unTagCount);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetLiveCollisionBoundsTagsInfo)(uint8_t *pTagsBuffer, uint32_t *punTagCount);
+	bool(OPENVR_FNTABLE_CALLTYPE *SetWorkingPhysicalBoundsInfo)(struct HmdQuad_t *pQuadsBuffer, uint32_t unQuadsCount);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetLivePhysicalBoundsInfo)(struct HmdQuad_t *pQuadsBuffer, uint32_t *punQuadsCount);
+	bool(OPENVR_FNTABLE_CALLTYPE *ExportLiveToBuffer)(char *pBuffer, uint32_t *pnBufferLength);
+	bool(OPENVR_FNTABLE_CALLTYPE *ImportFromBufferToWorking)(char *pBuffer, uint32_t nImportFlags);
+};
+
+struct VR_IVRCompositor_FnTable
+{
+	void(OPENVR_FNTABLE_CALLTYPE *SetTrackingSpace)(ETrackingUniverseOrigin eOrigin);
+	ETrackingUniverseOrigin(OPENVR_FNTABLE_CALLTYPE *GetTrackingSpace)();
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *WaitGetPoses)(struct TrackedDevicePose_t *pRenderPoseArray, uint32_t unRenderPoseArrayCount, struct TrackedDevicePose_t *pGamePoseArray, uint32_t unGamePoseArrayCount);
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *GetLastPoses)(struct TrackedDevicePose_t *pRenderPoseArray, uint32_t unRenderPoseArrayCount, struct TrackedDevicePose_t *pGamePoseArray, uint32_t unGamePoseArrayCount);
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, struct TrackedDevicePose_t *pOutputPose, struct TrackedDevicePose_t *pOutputGamePose);
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *Submit)(EVREye eEye, struct Texture_t *pTexture, struct VRTextureBounds_t *pBounds, EVRSubmitFlags nSubmitFlags);
+	void(OPENVR_FNTABLE_CALLTYPE *ClearLastSubmittedFrame)();
+	void(OPENVR_FNTABLE_CALLTYPE *PostPresentHandoff)();
+	bool(OPENVR_FNTABLE_CALLTYPE *GetFrameTiming)(struct Compositor_FrameTiming *pTiming, uint32_t unFramesAgo);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetFrameTimings)(struct Compositor_FrameTiming *pTiming, uint32_t nFrames);
+	float(OPENVR_FNTABLE_CALLTYPE *GetFrameTimeRemaining)();
+	void(OPENVR_FNTABLE_CALLTYPE *GetCumulativeStats)(struct Compositor_CumulativeStats *pStats, uint32_t nStatsSizeInBytes);
+	void(OPENVR_FNTABLE_CALLTYPE *FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
+	struct HmdColor_t(OPENVR_FNTABLE_CALLTYPE *GetCurrentFadeColor)(bool bBackground);
+	void(OPENVR_FNTABLE_CALLTYPE *FadeGrid)(float fSeconds, bool bFadeIn);
+	float(OPENVR_FNTABLE_CALLTYPE *GetCurrentGridAlpha)();
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *SetSkyboxOverride)(struct Texture_t *pTextures, uint32_t unTextureCount);
+	void(OPENVR_FNTABLE_CALLTYPE *ClearSkyboxOverride)();
+	void(OPENVR_FNTABLE_CALLTYPE *CompositorBringToFront)();
+	void(OPENVR_FNTABLE_CALLTYPE *CompositorGoToBack)();
+	void(OPENVR_FNTABLE_CALLTYPE *CompositorQuit)();
+	bool(OPENVR_FNTABLE_CALLTYPE *IsFullscreen)();
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetCurrentSceneFocusProcess)();
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetLastFrameRenderer)();
+	bool(OPENVR_FNTABLE_CALLTYPE *CanRenderScene)();
+	void(OPENVR_FNTABLE_CALLTYPE *ShowMirrorWindow)();
+	void(OPENVR_FNTABLE_CALLTYPE *HideMirrorWindow)();
+	bool(OPENVR_FNTABLE_CALLTYPE *IsMirrorWindowVisible)();
+	void(OPENVR_FNTABLE_CALLTYPE *CompositorDumpImages)();
+	bool(OPENVR_FNTABLE_CALLTYPE *ShouldAppRenderWithLowResources)();
+	void(OPENVR_FNTABLE_CALLTYPE *ForceInterleavedReprojectionOn)(bool bOverride);
+	void(OPENVR_FNTABLE_CALLTYPE *ForceReconnectProcess)();
+	void(OPENVR_FNTABLE_CALLTYPE *SuspendRendering)(bool bSuspend);
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *GetMirrorTextureD3D11)(EVREye eEye, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView);
+	void(OPENVR_FNTABLE_CALLTYPE *ReleaseMirrorTextureD3D11)(void *pD3D11ShaderResourceView);
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *GetMirrorTextureGL)(EVREye eEye, glUInt_t *pglTextureId, glSharedTextureHandle_t *pglSharedTextureHandle);
+	bool(OPENVR_FNTABLE_CALLTYPE *ReleaseSharedGLTexture)(glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle);
+	void(OPENVR_FNTABLE_CALLTYPE *LockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle);
+	void(OPENVR_FNTABLE_CALLTYPE *UnlockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetVulkanInstanceExtensionsRequired)(char *pchValue, uint32_t unBufferSize);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetVulkanDeviceExtensionsRequired)(struct VkPhysicalDevice_T *pPhysicalDevice, char *pchValue, uint32_t unBufferSize);
+	void(OPENVR_FNTABLE_CALLTYPE *SetExplicitTimingMode)(bool bExplicitTimingMode);
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *SubmitExplicitTimingData)();
+};
+
+struct VR_IVROverlay_FnTable
+{
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *FindOverlay)(char *pchOverlayKey, VROverlayHandle_t *pOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *CreateOverlay)(char *pchOverlayKey, char *pchOverlayName, VROverlayHandle_t *pOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *DestroyOverlay)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle);
+	VROverlayHandle_t(OPENVR_FNTABLE_CALLTYPE *GetHighQualityOverlay)();
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char *pchValue, uint32_t unBufferSize, EVROverlayError *pError);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char *pchValue, uint32_t unBufferSize, EVROverlayError *pError);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayName)(VROverlayHandle_t ulOverlayHandle, char *pchName);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unBufferSize, uint32_t *punWidth, uint32_t *punHeight);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetOverlayErrorNameFromEnum)(EVROverlayError error);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool *pbEnabled);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float *pfRed, float *pfGreen, float *pfBlue);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float *pfAlpha);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float fTexelAspect);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float *pfTexelAspect);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t *punSortOrder);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float *pfWidthInMeters);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float *pfMinDistanceInMeters, float *pfMaxDistanceInMeters);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace *peTextureColorSpace);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, struct VRTextureBounds_t *pOverlayTextureBounds);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, struct VRTextureBounds_t *pOverlayTextureBounds);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, char *pchValue, uint32_t unBufferSize, struct HmdColor_t *pColor, EVROverlayError *pError);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, char *pchRenderModel, struct HmdColor_t *pColor);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType *peTransformType);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, struct HmdMatrix34_t *pmatTrackingOriginToOverlayTransform);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin *peTrackingOrigin, struct HmdMatrix34_t *pmatTrackingOriginToOverlayTransform);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, struct HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punTrackedDevice, struct HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, char *pchComponentName);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punDeviceIndex, char *pchComponentName, uint32_t unComponentNameSize);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t *ulOverlayHandleParent, struct HmdMatrix34_t *pmatParentOverlayToOverlayTransform);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, struct HmdMatrix34_t *pmatParentOverlayToOverlayTransform);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *ShowOverlay)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *HideOverlay)(VROverlayHandle_t ulOverlayHandle);
+	bool(OPENVR_FNTABLE_CALLTYPE *IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, struct HmdVector2_t coordinatesInOverlay, struct HmdMatrix34_t *pmatTransform);
+	bool(OPENVR_FNTABLE_CALLTYPE *PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, struct VREvent_t *pEvent, uint32_t uncbVREvent);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod *peInputMethod);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, struct HmdVector2_t *pvecMouseScale);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, struct HmdVector2_t *pvecMouseScale);
+	bool(OPENVR_FNTABLE_CALLTYPE *ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, struct VROverlayIntersectionParams_t *pParams, struct VROverlayIntersectionResults_t *pResults);
+	bool(OPENVR_FNTABLE_CALLTYPE *HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex);
+	bool(OPENVR_FNTABLE_CALLTYPE *IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle);
+	VROverlayHandle_t(OPENVR_FNTABLE_CALLTYPE *GetGamepadFocusOverlay)();
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetGamepadFocusOverlay)(VROverlayHandle_t ulNewFocusOverlay);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *MoveGamepadFocusToNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, struct Texture_t *pTexture);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, char *pchFilePath);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void **pNativeTextureHandle, void *pNativeTextureRef, uint32_t *pWidth, uint32_t *pHeight, uint32_t *pNativeFormat, ETextureType *pAPIType, EColorSpace *pColorSpace, struct VRTextureBounds_t *pTextureBounds);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void *pNativeTextureHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t *pWidth, uint32_t *pHeight);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *CreateDashboardOverlay)(char *pchOverlayKey, char *pchOverlayFriendlyName, VROverlayHandle_t *pMainHandle, VROverlayHandle_t *pThumbnailHandle);
+	bool(OPENVR_FNTABLE_CALLTYPE *IsDashboardVisible)();
+	bool(OPENVR_FNTABLE_CALLTYPE *IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t *punProcessId);
+	void(OPENVR_FNTABLE_CALLTYPE *ShowDashboard)(char *pchOverlayToShow);
+	TrackedDeviceIndex_t(OPENVR_FNTABLE_CALLTYPE *GetPrimaryDashboardDevice)();
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, char *pchDescription, uint32_t unCharMax, char *pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, char *pchDescription, uint32_t unCharMax, char *pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetKeyboardText)(char *pchText, uint32_t cchText);
+	void(OPENVR_FNTABLE_CALLTYPE *HideKeyboard)();
+	void(OPENVR_FNTABLE_CALLTYPE *SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, struct HmdMatrix34_t *pmatTrackingOriginToKeyboardTransform);
+	void(OPENVR_FNTABLE_CALLTYPE *SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, struct HmdRect2_t avoidRect);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayIntersectionMask)(VROverlayHandle_t ulOverlayHandle, struct VROverlayIntersectionMaskPrimitive_t *pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayFlags)(VROverlayHandle_t ulOverlayHandle, uint32_t *pFlags);
+	VRMessageOverlayResponse(OPENVR_FNTABLE_CALLTYPE *ShowMessageOverlay)(char *pchText, char *pchCaption, char *pchButton0Text, char *pchButton1Text, char *pchButton2Text, char *pchButton3Text);
+	void(OPENVR_FNTABLE_CALLTYPE *CloseMessageOverlay)();
+};
+
+struct VR_IVRRenderModels_FnTable
+{
+	EVRRenderModelError(OPENVR_FNTABLE_CALLTYPE *LoadRenderModel_Async)(char *pchRenderModelName, struct RenderModel_t **ppRenderModel);
+	void(OPENVR_FNTABLE_CALLTYPE *FreeRenderModel)(struct RenderModel_t *pRenderModel);
+	EVRRenderModelError(OPENVR_FNTABLE_CALLTYPE *LoadTexture_Async)(TextureID_t textureId, struct RenderModel_TextureMap_t **ppTexture);
+	void(OPENVR_FNTABLE_CALLTYPE *FreeTexture)(struct RenderModel_TextureMap_t *pTexture);
+	EVRRenderModelError(OPENVR_FNTABLE_CALLTYPE *LoadTextureD3D11_Async)(TextureID_t textureId, void *pD3D11Device, void **ppD3D11Texture2D);
+	EVRRenderModelError(OPENVR_FNTABLE_CALLTYPE *LoadIntoTextureD3D11_Async)(TextureID_t textureId, void *pDstTexture);
+	void(OPENVR_FNTABLE_CALLTYPE *FreeTextureD3D11)(void *pD3D11Texture2D);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetRenderModelName)(uint32_t unRenderModelIndex, char *pchRenderModelName, uint32_t unRenderModelNameLen);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetRenderModelCount)();
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetComponentCount)(char *pchRenderModelName);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetComponentName)(char *pchRenderModelName, uint32_t unComponentIndex, char *pchComponentName, uint32_t unComponentNameLen);
+	uint64_t(OPENVR_FNTABLE_CALLTYPE *GetComponentButtonMask)(char *pchRenderModelName, char *pchComponentName);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetComponentRenderModelName)(char *pchRenderModelName, char *pchComponentName, char *pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetComponentState)(char *pchRenderModelName, char *pchComponentName, VRControllerState_t *pControllerState, struct RenderModel_ControllerMode_State_t *pState, struct RenderModel_ComponentState_t *pComponentState);
+	bool(OPENVR_FNTABLE_CALLTYPE *RenderModelHasComponent)(char *pchRenderModelName, char *pchComponentName);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetRenderModelThumbnailURL)(char *pchRenderModelName, char *pchThumbnailURL, uint32_t unThumbnailURLLen, EVRRenderModelError *peError);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetRenderModelOriginalPath)(char *pchRenderModelName, char *pchOriginalPath, uint32_t unOriginalPathLen, EVRRenderModelError *peError);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetRenderModelErrorNameFromEnum)(EVRRenderModelError error);
+};
+
+struct VR_IVRNotifications_FnTable
+{
+	EVRNotificationError(OPENVR_FNTABLE_CALLTYPE *CreateNotification)(VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, EVRNotificationType type, char *pchText, EVRNotificationStyle style, struct NotificationBitmap_t *pImage, VRNotificationId *pNotificationId);
+	EVRNotificationError(OPENVR_FNTABLE_CALLTYPE *RemoveNotification)(VRNotificationId notificationId);
+};
+
+struct VR_IVRSettings_FnTable
+{
+	char *(OPENVR_FNTABLE_CALLTYPE *GetSettingsErrorNameFromEnum)(EVRSettingsError eError);
+	bool(OPENVR_FNTABLE_CALLTYPE *Sync)(bool bForce, EVRSettingsError *peError);
+	void(OPENVR_FNTABLE_CALLTYPE *SetBool)(char *pchSection, char *pchSettingsKey, bool bValue, EVRSettingsError *peError);
+	void(OPENVR_FNTABLE_CALLTYPE *SetInt32)(char *pchSection, char *pchSettingsKey, int32_t nValue, EVRSettingsError *peError);
+	void(OPENVR_FNTABLE_CALLTYPE *SetFloat)(char *pchSection, char *pchSettingsKey, float flValue, EVRSettingsError *peError);
+	void(OPENVR_FNTABLE_CALLTYPE *SetString)(char *pchSection, char *pchSettingsKey, char *pchValue, EVRSettingsError *peError);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetBool)(char *pchSection, char *pchSettingsKey, EVRSettingsError *peError);
+	int32_t(OPENVR_FNTABLE_CALLTYPE *GetInt32)(char *pchSection, char *pchSettingsKey, EVRSettingsError *peError);
+	float(OPENVR_FNTABLE_CALLTYPE *GetFloat)(char *pchSection, char *pchSettingsKey, EVRSettingsError *peError);
+	void(OPENVR_FNTABLE_CALLTYPE *GetString)(char *pchSection, char *pchSettingsKey, char *pchValue, uint32_t unValueLen, EVRSettingsError *peError);
+	void(OPENVR_FNTABLE_CALLTYPE *RemoveSection)(char *pchSection, EVRSettingsError *peError);
+	void(OPENVR_FNTABLE_CALLTYPE *RemoveKeyInSection)(char *pchSection, char *pchSettingsKey, EVRSettingsError *peError);
+};
+
+struct VR_IVRScreenshots_FnTable
+{
+	EVRScreenshotError(OPENVR_FNTABLE_CALLTYPE *RequestScreenshot)(ScreenshotHandle_t *pOutScreenshotHandle, EVRScreenshotType type, char *pchPreviewFilename, char *pchVRFilename);
+	EVRScreenshotError(OPENVR_FNTABLE_CALLTYPE *HookScreenshot)(EVRScreenshotType *pSupportedTypes, int numTypes);
+	EVRScreenshotType(OPENVR_FNTABLE_CALLTYPE *GetScreenshotPropertyType)(ScreenshotHandle_t screenshotHandle, EVRScreenshotError *pError);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetScreenshotPropertyFilename)(ScreenshotHandle_t screenshotHandle, EVRScreenshotPropertyFilenames filenameType, char *pchFilename, uint32_t cchFilename, EVRScreenshotError *pError);
+	EVRScreenshotError(OPENVR_FNTABLE_CALLTYPE *UpdateScreenshotProgress)(ScreenshotHandle_t screenshotHandle, float flProgress);
+	EVRScreenshotError(OPENVR_FNTABLE_CALLTYPE *TakeStereoScreenshot)(ScreenshotHandle_t *pOutScreenshotHandle, char *pchPreviewFilename, char *pchVRFilename);
+	EVRScreenshotError(OPENVR_FNTABLE_CALLTYPE *SubmitScreenshot)(ScreenshotHandle_t screenshotHandle, EVRScreenshotType type, char *pchSourcePreviewFilename, char *pchSourceVRFilename);
+};
+
+struct VR_IVRResources_FnTable
+{
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *LoadSharedResource)(char *pchResourceName, char *pchBuffer, uint32_t unBufferLen);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetResourceFullPath)(char *pchResourceName, char *pchResourceTypeDirectory, char *pchPathBuffer, uint32_t unBufferLen);
+};
+
+struct VR_IVRDriverManager_FnTable
+{
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetDriverCount)();
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetDriverName)(DriverId_t nDriver, char *pchValue, uint32_t unBufferSize);
+};
+
+#if 0
+// Global entry points
+S_API intptr_t VR_InitInternal( EVRInitError *peError, EVRApplicationType eType );
+S_API void VR_ShutdownInternal();
+S_API bool VR_IsHmdPresent();
+S_API intptr_t VR_GetGenericInterface( const char *pchInterfaceVersion, EVRInitError *peError );
+S_API bool VR_IsRuntimeInstalled();
+S_API const char * VR_GetVRInitErrorAsSymbol( EVRInitError error );
+S_API const char * VR_GetVRInitErrorAsEnglishDescription( EVRInitError error );
+#endif
+
+#endif  // __OPENVR_API_FLAT_H__
diff --git a/engine/inc/bullet/ThirdPartyLibs/openvr/bin/osx64/OpenVR.framework/Versions/A/Headers/openvr_driver.h b/engine/inc/bullet/ThirdPartyLibs/openvr/bin/osx64/OpenVR.framework/Versions/A/Headers/openvr_driver.h
new file mode 100644
index 00000000..b07699f8
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/openvr/bin/osx64/OpenVR.framework/Versions/A/Headers/openvr_driver.h
@@ -0,0 +1,2595 @@
+#pragma once
+
+// openvr_driver.h
+//========= Copyright Valve Corporation ============//
+// Dynamically generated file. Do not modify this file directly.
+
+#ifndef _OPENVR_DRIVER_API
+#define _OPENVR_DRIVER_API
+
+#include <stdint.h>
+
+// vrtypes.h
+#ifndef _INCLUDE_VRTYPES_H
+#define _INCLUDE_VRTYPES_H
+
+// Forward declarations to avoid requiring vulkan.h
+struct VkDevice_T;
+struct VkPhysicalDevice_T;
+struct VkInstance_T;
+struct VkQueue_T;
+
+// Forward declarations to avoid requiring d3d12.h
+struct ID3D12Resource;
+struct ID3D12CommandQueue;
+
+namespace vr
+{
+#pragma pack(push, 8)
+
+typedef void *glSharedTextureHandle_t;
+typedef int32_t glInt_t;
+typedef uint32_t glUInt_t;
+
+// right-handed system
+// +y is up
+// +x is to the right
+// -z is going away from you
+// Distance unit is  meters
+struct HmdMatrix34_t
+{
+	float m[3][4];
+};
+
+struct HmdMatrix44_t
+{
+	float m[4][4];
+};
+
+struct HmdVector3_t
+{
+	float v[3];
+};
+
+struct HmdVector4_t
+{
+	float v[4];
+};
+
+struct HmdVector3d_t
+{
+	double v[3];
+};
+
+struct HmdVector2_t
+{
+	float v[2];
+};
+
+struct HmdQuaternion_t
+{
+	double w, x, y, z;
+};
+
+struct HmdColor_t
+{
+	float r, g, b, a;
+};
+
+struct HmdQuad_t
+{
+	HmdVector3_t vCorners[4];
+};
+
+struct HmdRect2_t
+{
+	HmdVector2_t vTopLeft;
+	HmdVector2_t vBottomRight;
+};
+
+/** Used to return the post-distortion UVs for each color channel. 
+* UVs range from 0 to 1 with 0,0 in the upper left corner of the 
+* source render target. The 0,0 to 1,1 range covers a single eye. */
+struct DistortionCoordinates_t
+{
+	float rfRed[2];
+	float rfGreen[2];
+	float rfBlue[2];
+};
+
+enum EVREye
+{
+	Eye_Left = 0,
+	Eye_Right = 1
+};
+
+enum ETextureType
+{
+	TextureType_DirectX = 0,    // Handle is an ID3D11Texture
+	TextureType_OpenGL = 1,     // Handle is an OpenGL texture name or an OpenGL render buffer name, depending on submit flags
+	TextureType_Vulkan = 2,     // Handle is a pointer to a VRVulkanTextureData_t structure
+	TextureType_IOSurface = 3,  // Handle is a macOS cross-process-sharable IOSurfaceRef
+	TextureType_DirectX12 = 4,  // Handle is a pointer to a D3D12TextureData_t structure
+};
+
+enum EColorSpace
+{
+	ColorSpace_Auto = 0,    // Assumes 'gamma' for 8-bit per component formats, otherwise 'linear'.  This mirrors the DXGI formats which have _SRGB variants.
+	ColorSpace_Gamma = 1,   // Texture data can be displayed directly on the display without any conversion (a.k.a. display native format).
+	ColorSpace_Linear = 2,  // Same as gamma but has been converted to a linear representation using DXGI's sRGB conversion algorithm.
+};
+
+struct Texture_t
+{
+	void *handle;  // See ETextureType definition above
+	ETextureType eType;
+	EColorSpace eColorSpace;
+};
+
+// Handle to a shared texture (HANDLE on Windows obtained using OpenSharedResource).
+typedef uint64_t SharedTextureHandle_t;
+#define INVALID_SHARED_TEXTURE_HANDLE ((vr::SharedTextureHandle_t)0)
+
+enum ETrackingResult
+{
+	TrackingResult_Uninitialized = 1,
+
+	TrackingResult_Calibrating_InProgress = 100,
+	TrackingResult_Calibrating_OutOfRange = 101,
+
+	TrackingResult_Running_OK = 200,
+	TrackingResult_Running_OutOfRange = 201,
+};
+
+typedef uint32_t DriverId_t;
+static const uint32_t k_nDriverNone = 0xFFFFFFFF;
+
+static const uint32_t k_unMaxDriverDebugResponseSize = 32768;
+
+/** Used to pass device IDs to API calls */
+typedef uint32_t TrackedDeviceIndex_t;
+static const uint32_t k_unTrackedDeviceIndex_Hmd = 0;
+static const uint32_t k_unMaxTrackedDeviceCount = 16;
+static const uint32_t k_unTrackedDeviceIndexOther = 0xFFFFFFFE;
+static const uint32_t k_unTrackedDeviceIndexInvalid = 0xFFFFFFFF;
+
+/** Describes what kind of object is being tracked at a given ID */
+enum ETrackedDeviceClass
+{
+	TrackedDeviceClass_Invalid = 0,            // the ID was not valid.
+	TrackedDeviceClass_HMD = 1,                // Head-Mounted Displays
+	TrackedDeviceClass_Controller = 2,         // Tracked controllers
+	TrackedDeviceClass_GenericTracker = 3,     // Generic trackers, similar to controllers
+	TrackedDeviceClass_TrackingReference = 4,  // Camera and base stations that serve as tracking reference points
+	TrackedDeviceClass_DisplayRedirect = 5,    // Accessories that aren't necessarily tracked themselves, but may redirect video output from other tracked devices
+};
+
+/** Describes what specific role associated with a tracked device */
+enum ETrackedControllerRole
+{
+	TrackedControllerRole_Invalid = 0,    // Invalid value for controller type
+	TrackedControllerRole_LeftHand = 1,   // Tracked device associated with the left hand
+	TrackedControllerRole_RightHand = 2,  // Tracked device associated with the right hand
+};
+
+/** describes a single pose for a tracked object */
+struct TrackedDevicePose_t
+{
+	HmdMatrix34_t mDeviceToAbsoluteTracking;
+	HmdVector3_t vVelocity;         // velocity in tracker space in m/s
+	HmdVector3_t vAngularVelocity;  // angular velocity in radians/s (?)
+	ETrackingResult eTrackingResult;
+	bool bPoseIsValid;
+
+	// This indicates that there is a device connected for this spot in the pose array.
+	// It could go from true to false if the user unplugs the device.
+	bool bDeviceIsConnected;
+};
+
+/** Identifies which style of tracking origin the application wants to use
+* for the poses it is requesting */
+enum ETrackingUniverseOrigin
+{
+	TrackingUniverseSeated = 0,              // Poses are provided relative to the seated zero pose
+	TrackingUniverseStanding = 1,            // Poses are provided relative to the safe bounds configured by the user
+	TrackingUniverseRawAndUncalibrated = 2,  // Poses are provided in the coordinate system defined by the driver.  It has Y up and is unified for devices of the same driver. You usually don't want this one.
+};
+
+// Refers to a single container of properties
+typedef uint64_t PropertyContainerHandle_t;
+typedef uint32_t PropertyTypeTag_t;
+
+static const PropertyContainerHandle_t k_ulInvalidPropertyContainer = 0;
+static const PropertyTypeTag_t k_unInvalidPropertyTag = 0;
+
+// Use these tags to set/get common types as struct properties
+static const PropertyTypeTag_t k_unFloatPropertyTag = 1;
+static const PropertyTypeTag_t k_unInt32PropertyTag = 2;
+static const PropertyTypeTag_t k_unUint64PropertyTag = 3;
+static const PropertyTypeTag_t k_unBoolPropertyTag = 4;
+static const PropertyTypeTag_t k_unStringPropertyTag = 5;
+
+static const PropertyTypeTag_t k_unHmdMatrix34PropertyTag = 20;
+static const PropertyTypeTag_t k_unHmdMatrix44PropertyTag = 21;
+static const PropertyTypeTag_t k_unHmdVector3PropertyTag = 22;
+static const PropertyTypeTag_t k_unHmdVector4PropertyTag = 23;
+
+static const PropertyTypeTag_t k_unHiddenAreaPropertyTag = 30;
+
+static const PropertyTypeTag_t k_unOpenVRInternalReserved_Start = 1000;
+static const PropertyTypeTag_t k_unOpenVRInternalReserved_End = 10000;
+
+/** Each entry in this enum represents a property that can be retrieved about a
+* tracked device. Many fields are only valid for one ETrackedDeviceClass. */
+enum ETrackedDeviceProperty
+{
+	Prop_Invalid = 0,
+
+	// general properties that apply to all device classes
+	Prop_TrackingSystemName_String = 1000,
+	Prop_ModelNumber_String = 1001,
+	Prop_SerialNumber_String = 1002,
+	Prop_RenderModelName_String = 1003,
+	Prop_WillDriftInYaw_Bool = 1004,
+	Prop_ManufacturerName_String = 1005,
+	Prop_TrackingFirmwareVersion_String = 1006,
+	Prop_HardwareRevision_String = 1007,
+	Prop_AllWirelessDongleDescriptions_String = 1008,
+	Prop_ConnectedWirelessDongle_String = 1009,
+	Prop_DeviceIsWireless_Bool = 1010,
+	Prop_DeviceIsCharging_Bool = 1011,
+	Prop_DeviceBatteryPercentage_Float = 1012,  // 0 is empty, 1 is full
+	Prop_StatusDisplayTransform_Matrix34 = 1013,
+	Prop_Firmware_UpdateAvailable_Bool = 1014,
+	Prop_Firmware_ManualUpdate_Bool = 1015,
+	Prop_Firmware_ManualUpdateURL_String = 1016,
+	Prop_HardwareRevision_Uint64 = 1017,
+	Prop_FirmwareVersion_Uint64 = 1018,
+	Prop_FPGAVersion_Uint64 = 1019,
+	Prop_VRCVersion_Uint64 = 1020,
+	Prop_RadioVersion_Uint64 = 1021,
+	Prop_DongleVersion_Uint64 = 1022,
+	Prop_BlockServerShutdown_Bool = 1023,
+	Prop_CanUnifyCoordinateSystemWithHmd_Bool = 1024,
+	Prop_ContainsProximitySensor_Bool = 1025,
+	Prop_DeviceProvidesBatteryStatus_Bool = 1026,
+	Prop_DeviceCanPowerOff_Bool = 1027,
+	Prop_Firmware_ProgrammingTarget_String = 1028,
+	Prop_DeviceClass_Int32 = 1029,
+	Prop_HasCamera_Bool = 1030,
+	Prop_DriverVersion_String = 1031,
+	Prop_Firmware_ForceUpdateRequired_Bool = 1032,
+	Prop_ViveSystemButtonFixRequired_Bool = 1033,
+	Prop_ParentDriver_Uint64 = 1034,
+	Prop_ResourceRoot_String = 1035,
+
+	// Properties that are unique to TrackedDeviceClass_HMD
+	Prop_ReportsTimeSinceVSync_Bool = 2000,
+	Prop_SecondsFromVsyncToPhotons_Float = 2001,
+	Prop_DisplayFrequency_Float = 2002,
+	Prop_UserIpdMeters_Float = 2003,
+	Prop_CurrentUniverseId_Uint64 = 2004,
+	Prop_PreviousUniverseId_Uint64 = 2005,
+	Prop_DisplayFirmwareVersion_Uint64 = 2006,
+	Prop_IsOnDesktop_Bool = 2007,
+	Prop_DisplayMCType_Int32 = 2008,
+	Prop_DisplayMCOffset_Float = 2009,
+	Prop_DisplayMCScale_Float = 2010,
+	Prop_EdidVendorID_Int32 = 2011,
+	Prop_DisplayMCImageLeft_String = 2012,
+	Prop_DisplayMCImageRight_String = 2013,
+	Prop_DisplayGCBlackClamp_Float = 2014,
+	Prop_EdidProductID_Int32 = 2015,
+	Prop_CameraToHeadTransform_Matrix34 = 2016,
+	Prop_DisplayGCType_Int32 = 2017,
+	Prop_DisplayGCOffset_Float = 2018,
+	Prop_DisplayGCScale_Float = 2019,
+	Prop_DisplayGCPrescale_Float = 2020,
+	Prop_DisplayGCImage_String = 2021,
+	Prop_LensCenterLeftU_Float = 2022,
+	Prop_LensCenterLeftV_Float = 2023,
+	Prop_LensCenterRightU_Float = 2024,
+	Prop_LensCenterRightV_Float = 2025,
+	Prop_UserHeadToEyeDepthMeters_Float = 2026,
+	Prop_CameraFirmwareVersion_Uint64 = 2027,
+	Prop_CameraFirmwareDescription_String = 2028,
+	Prop_DisplayFPGAVersion_Uint64 = 2029,
+	Prop_DisplayBootloaderVersion_Uint64 = 2030,
+	Prop_DisplayHardwareVersion_Uint64 = 2031,
+	Prop_AudioFirmwareVersion_Uint64 = 2032,
+	Prop_CameraCompatibilityMode_Int32 = 2033,
+	Prop_ScreenshotHorizontalFieldOfViewDegrees_Float = 2034,
+	Prop_ScreenshotVerticalFieldOfViewDegrees_Float = 2035,
+	Prop_DisplaySuppressed_Bool = 2036,
+	Prop_DisplayAllowNightMode_Bool = 2037,
+	Prop_DisplayMCImageWidth_Int32 = 2038,
+	Prop_DisplayMCImageHeight_Int32 = 2039,
+	Prop_DisplayMCImageNumChannels_Int32 = 2040,
+	Prop_DisplayMCImageData_Binary = 2041,
+	Prop_SecondsFromPhotonsToVblank_Float = 2042,
+	Prop_DriverDirectModeSendsVsyncEvents_Bool = 2043,
+	Prop_DisplayDebugMode_Bool = 2044,
+	Prop_GraphicsAdapterLuid_Uint64 = 2045,
+	Prop_DriverProvidedChaperonePath_String = 2048,
+
+	// Properties that are unique to TrackedDeviceClass_Controller
+	Prop_AttachedDeviceId_String = 3000,
+	Prop_SupportedButtons_Uint64 = 3001,
+	Prop_Axis0Type_Int32 = 3002,           // Return value is of type EVRControllerAxisType
+	Prop_Axis1Type_Int32 = 3003,           // Return value is of type EVRControllerAxisType
+	Prop_Axis2Type_Int32 = 3004,           // Return value is of type EVRControllerAxisType
+	Prop_Axis3Type_Int32 = 3005,           // Return value is of type EVRControllerAxisType
+	Prop_Axis4Type_Int32 = 3006,           // Return value is of type EVRControllerAxisType
+	Prop_ControllerRoleHint_Int32 = 3007,  // Return value is of type ETrackedControllerRole
+
+	// Properties that are unique to TrackedDeviceClass_TrackingReference
+	Prop_FieldOfViewLeftDegrees_Float = 4000,
+	Prop_FieldOfViewRightDegrees_Float = 4001,
+	Prop_FieldOfViewTopDegrees_Float = 4002,
+	Prop_FieldOfViewBottomDegrees_Float = 4003,
+	Prop_TrackingRangeMinimumMeters_Float = 4004,
+	Prop_TrackingRangeMaximumMeters_Float = 4005,
+	Prop_ModeLabel_String = 4006,
+
+	// Properties that are used for user interface like icons names
+	Prop_IconPathName_String = 5000,                       // DEPRECATED. Value not referenced. Now expected to be part of icon path properties.
+	Prop_NamedIconPathDeviceOff_String = 5001,             // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceSearching_String = 5002,       // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceSearchingAlert_String = 5003,  // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceReady_String = 5004,           // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceReadyAlert_String = 5005,      // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceNotReady_String = 5006,        // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceStandby_String = 5007,         // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceAlertLow_String = 5008,        // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+
+	// Properties that are used by helpers, but are opaque to applications
+	Prop_DisplayHiddenArea_Binary_Start = 5100,
+	Prop_DisplayHiddenArea_Binary_End = 5150,
+
+	// Properties that are unique to drivers
+	Prop_UserConfigPath_String = 6000,
+	Prop_InstallPath_String = 6001,
+	Prop_HasDisplayComponent_Bool = 6002,
+	Prop_HasControllerComponent_Bool = 6003,
+	Prop_HasCameraComponent_Bool = 6004,
+	Prop_HasDriverDirectModeComponent_Bool = 6005,
+	Prop_HasVirtualDisplayComponent_Bool = 6006,
+
+	// Vendors are free to expose private debug data in this reserved region
+	Prop_VendorSpecific_Reserved_Start = 10000,
+	Prop_VendorSpecific_Reserved_End = 10999,
+};
+
+/** No string property will ever be longer than this length */
+static const uint32_t k_unMaxPropertyStringSize = 32 * 1024;
+
+/** Used to return errors that occur when reading properties. */
+enum ETrackedPropertyError
+{
+	TrackedProp_Success = 0,
+	TrackedProp_WrongDataType = 1,
+	TrackedProp_WrongDeviceClass = 2,
+	TrackedProp_BufferTooSmall = 3,
+	TrackedProp_UnknownProperty = 4,  // Driver has not set the property (and may not ever).
+	TrackedProp_InvalidDevice = 5,
+	TrackedProp_CouldNotContactServer = 6,
+	TrackedProp_ValueNotProvidedByDevice = 7,
+	TrackedProp_StringExceedsMaximumLength = 8,
+	TrackedProp_NotYetAvailable = 9,  // The property value isn't known yet, but is expected soon. Call again later.
+	TrackedProp_PermissionDenied = 10,
+	TrackedProp_InvalidOperation = 11,
+};
+
+/** Allows the application to control what part of the provided texture will be used in the
+* frame buffer. */
+struct VRTextureBounds_t
+{
+	float uMin, vMin;
+	float uMax, vMax;
+};
+
+/** Allows specifying pose used to render provided scene texture (if different from value returned by WaitGetPoses). */
+struct VRTextureWithPose_t : public Texture_t
+{
+	HmdMatrix34_t mDeviceToAbsoluteTracking;  // Actual pose used to render scene textures.
+};
+
+/** Allows the application to control how scene textures are used by the compositor when calling Submit. */
+enum EVRSubmitFlags
+{
+	// Simple render path. App submits rendered left and right eye images with no lens distortion correction applied.
+	Submit_Default = 0x00,
+
+	// App submits final left and right eye images with lens distortion already applied (lens distortion makes the images appear
+	// barrel distorted with chromatic aberration correction applied). The app would have used the data returned by
+	// vr::IVRSystem::ComputeDistortion() to apply the correct distortion to the rendered images before calling Submit().
+	Submit_LensDistortionAlreadyApplied = 0x01,
+
+	// If the texture pointer passed in is actually a renderbuffer (e.g. for MSAA in OpenGL) then set this flag.
+	Submit_GlRenderBuffer = 0x02,
+
+	// Do not use
+	Submit_Reserved = 0x04,
+
+	// Set to indicate that pTexture is a pointer to a VRTextureWithPose_t.
+	Submit_TextureWithPose = 0x08,
+};
+
+/** Data required for passing Vulkan textures to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. */
+struct VRVulkanTextureData_t
+{
+	uint64_t m_nImage;  // VkImage
+	VkDevice_T *m_pDevice;
+	VkPhysicalDevice_T *m_pPhysicalDevice;
+	VkInstance_T *m_pInstance;
+	VkQueue_T *m_pQueue;
+	uint32_t m_nQueueFamilyIndex;
+	uint32_t m_nWidth, m_nHeight, m_nFormat, m_nSampleCount;
+};
+
+/** Data required for passing D3D12 textures to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. */
+struct D3D12TextureData_t
+{
+	ID3D12Resource *m_pResource;
+	ID3D12CommandQueue *m_pCommandQueue;
+	uint32_t m_nNodeMask;
+};
+
+/** Status of the overall system or tracked objects */
+enum EVRState
+{
+	VRState_Undefined = -1,
+	VRState_Off = 0,
+	VRState_Searching = 1,
+	VRState_Searching_Alert = 2,
+	VRState_Ready = 3,
+	VRState_Ready_Alert = 4,
+	VRState_NotReady = 5,
+	VRState_Standby = 6,
+	VRState_Ready_Alert_Low = 7,
+};
+
+/** The types of events that could be posted (and what the parameters mean for each event type) */
+enum EVREventType
+{
+	VREvent_None = 0,
+
+	VREvent_TrackedDeviceActivated = 100,
+	VREvent_TrackedDeviceDeactivated = 101,
+	VREvent_TrackedDeviceUpdated = 102,
+	VREvent_TrackedDeviceUserInteractionStarted = 103,
+	VREvent_TrackedDeviceUserInteractionEnded = 104,
+	VREvent_IpdChanged = 105,
+	VREvent_EnterStandbyMode = 106,
+	VREvent_LeaveStandbyMode = 107,
+	VREvent_TrackedDeviceRoleChanged = 108,
+	VREvent_WatchdogWakeUpRequested = 109,
+	VREvent_LensDistortionChanged = 110,
+	VREvent_PropertyChanged = 111,
+	VREvent_WirelessDisconnect = 112,
+	VREvent_WirelessReconnect = 113,
+
+	VREvent_ButtonPress = 200,    // data is controller
+	VREvent_ButtonUnpress = 201,  // data is controller
+	VREvent_ButtonTouch = 202,    // data is controller
+	VREvent_ButtonUntouch = 203,  // data is controller
+
+	VREvent_MouseMove = 300,            // data is mouse
+	VREvent_MouseButtonDown = 301,      // data is mouse
+	VREvent_MouseButtonUp = 302,        // data is mouse
+	VREvent_FocusEnter = 303,           // data is overlay
+	VREvent_FocusLeave = 304,           // data is overlay
+	VREvent_Scroll = 305,               // data is mouse
+	VREvent_TouchPadMove = 306,         // data is mouse
+	VREvent_OverlayFocusChanged = 307,  // data is overlay, global event
+
+	VREvent_InputFocusCaptured = 400,                         // data is process DEPRECATED
+	VREvent_InputFocusReleased = 401,                         // data is process DEPRECATED
+	VREvent_SceneFocusLost = 402,                             // data is process
+	VREvent_SceneFocusGained = 403,                           // data is process
+	VREvent_SceneApplicationChanged = 404,                    // data is process - The App actually drawing the scene changed (usually to or from the compositor)
+	VREvent_SceneFocusChanged = 405,                          // data is process - New app got access to draw the scene
+	VREvent_InputFocusChanged = 406,                          // data is process
+	VREvent_SceneApplicationSecondaryRenderingStarted = 407,  // data is process
+
+	VREvent_HideRenderModels = 410,  // Sent to the scene application to request hiding render models temporarily
+	VREvent_ShowRenderModels = 411,  // Sent to the scene application to request restoring render model visibility
+
+	VREvent_OverlayShown = 500,
+	VREvent_OverlayHidden = 501,
+	VREvent_DashboardActivated = 502,
+	VREvent_DashboardDeactivated = 503,
+	VREvent_DashboardThumbSelected = 504,     // Sent to the overlay manager - data is overlay
+	VREvent_DashboardRequested = 505,         // Sent to the overlay manager - data is overlay
+	VREvent_ResetDashboard = 506,             // Send to the overlay manager
+	VREvent_RenderToast = 507,                // Send to the dashboard to render a toast - data is the notification ID
+	VREvent_ImageLoaded = 508,                // Sent to overlays when a SetOverlayRaw or SetOverlayFromFile call finishes loading
+	VREvent_ShowKeyboard = 509,               // Sent to keyboard renderer in the dashboard to invoke it
+	VREvent_HideKeyboard = 510,               // Sent to keyboard renderer in the dashboard to hide it
+	VREvent_OverlayGamepadFocusGained = 511,  // Sent to an overlay when IVROverlay::SetFocusOverlay is called on it
+	VREvent_OverlayGamepadFocusLost = 512,    // Send to an overlay when it previously had focus and IVROverlay::SetFocusOverlay is called on something else
+	VREvent_OverlaySharedTextureChanged = 513,
+	VREvent_DashboardGuideButtonDown = 514,
+	VREvent_DashboardGuideButtonUp = 515,
+	VREvent_ScreenshotTriggered = 516,  // Screenshot button combo was pressed, Dashboard should request a screenshot
+	VREvent_ImageFailed = 517,          // Sent to overlays when a SetOverlayRaw or SetOverlayfromFail fails to load
+	VREvent_DashboardOverlayCreated = 518,
+
+	// Screenshot API
+	VREvent_RequestScreenshot = 520,              // Sent by vrclient application to compositor to take a screenshot
+	VREvent_ScreenshotTaken = 521,                // Sent by compositor to the application that the screenshot has been taken
+	VREvent_ScreenshotFailed = 522,               // Sent by compositor to the application that the screenshot failed to be taken
+	VREvent_SubmitScreenshotToDashboard = 523,    // Sent by compositor to the dashboard that a completed screenshot was submitted
+	VREvent_ScreenshotProgressToDashboard = 524,  // Sent by compositor to the dashboard that a completed screenshot was submitted
+
+	VREvent_PrimaryDashboardDeviceChanged = 525,
+
+	VREvent_Notification_Shown = 600,
+	VREvent_Notification_Hidden = 601,
+	VREvent_Notification_BeginInteraction = 602,
+	VREvent_Notification_Destroyed = 603,
+
+	VREvent_Quit = 700,                    // data is process
+	VREvent_ProcessQuit = 701,             // data is process
+	VREvent_QuitAborted_UserPrompt = 702,  // data is process
+	VREvent_QuitAcknowledged = 703,        // data is process
+	VREvent_DriverRequestedQuit = 704,     // The driver has requested that SteamVR shut down
+
+	VREvent_ChaperoneDataHasChanged = 800,
+	VREvent_ChaperoneUniverseHasChanged = 801,
+	VREvent_ChaperoneTempDataHasChanged = 802,
+	VREvent_ChaperoneSettingsHaveChanged = 803,
+	VREvent_SeatedZeroPoseReset = 804,
+
+	VREvent_AudioSettingsHaveChanged = 820,
+
+	VREvent_BackgroundSettingHasChanged = 850,
+	VREvent_CameraSettingsHaveChanged = 851,
+	VREvent_ReprojectionSettingHasChanged = 852,
+	VREvent_ModelSkinSettingsHaveChanged = 853,
+	VREvent_EnvironmentSettingsHaveChanged = 854,
+	VREvent_PowerSettingsHaveChanged = 855,
+	VREvent_EnableHomeAppSettingsHaveChanged = 856,
+
+	VREvent_StatusUpdate = 900,
+
+	VREvent_MCImageUpdated = 1000,
+
+	VREvent_FirmwareUpdateStarted = 1100,
+	VREvent_FirmwareUpdateFinished = 1101,
+
+	VREvent_KeyboardClosed = 1200,
+	VREvent_KeyboardCharInput = 1201,
+	VREvent_KeyboardDone = 1202,  // Sent when DONE button clicked on keyboard
+
+	VREvent_ApplicationTransitionStarted = 1300,
+	VREvent_ApplicationTransitionAborted = 1301,
+	VREvent_ApplicationTransitionNewAppStarted = 1302,
+	VREvent_ApplicationListUpdated = 1303,
+	VREvent_ApplicationMimeTypeLoad = 1304,
+	VREvent_ApplicationTransitionNewAppLaunchComplete = 1305,
+	VREvent_ProcessConnected = 1306,
+	VREvent_ProcessDisconnected = 1307,
+
+	VREvent_Compositor_MirrorWindowShown = 1400,
+	VREvent_Compositor_MirrorWindowHidden = 1401,
+	VREvent_Compositor_ChaperoneBoundsShown = 1410,
+	VREvent_Compositor_ChaperoneBoundsHidden = 1411,
+
+	VREvent_TrackedCamera_StartVideoStream = 1500,
+	VREvent_TrackedCamera_StopVideoStream = 1501,
+	VREvent_TrackedCamera_PauseVideoStream = 1502,
+	VREvent_TrackedCamera_ResumeVideoStream = 1503,
+	VREvent_TrackedCamera_EditingSurface = 1550,
+
+	VREvent_PerformanceTest_EnableCapture = 1600,
+	VREvent_PerformanceTest_DisableCapture = 1601,
+	VREvent_PerformanceTest_FidelityLevel = 1602,
+
+	VREvent_MessageOverlay_Closed = 1650,
+	VREvent_MessageOverlayCloseRequested = 1651,
+
+	// Vendors are free to expose private events in this reserved region
+	VREvent_VendorSpecific_Reserved_Start = 10000,
+	VREvent_VendorSpecific_Reserved_End = 19999,
+};
+
+/** Level of Hmd activity */
+// UserInteraction_Timeout means the device is in the process of timing out.
+// InUse = ( k_EDeviceActivityLevel_UserInteraction || k_EDeviceActivityLevel_UserInteraction_Timeout )
+// VREvent_TrackedDeviceUserInteractionStarted fires when the devices transitions from Standby -> UserInteraction or Idle -> UserInteraction.
+// VREvent_TrackedDeviceUserInteractionEnded fires when the devices transitions from UserInteraction_Timeout -> Idle
+enum EDeviceActivityLevel
+{
+	k_EDeviceActivityLevel_Unknown = -1,
+	k_EDeviceActivityLevel_Idle = 0,                     // No activity for the last 10 seconds
+	k_EDeviceActivityLevel_UserInteraction = 1,          // Activity (movement or prox sensor) is happening now
+	k_EDeviceActivityLevel_UserInteraction_Timeout = 2,  // No activity for the last 0.5 seconds
+	k_EDeviceActivityLevel_Standby = 3,                  // Idle for at least 5 seconds (configurable in Settings -> Power Management)
+};
+
+/** VR controller button and axis IDs */
+enum EVRButtonId
+{
+	k_EButton_System = 0,
+	k_EButton_ApplicationMenu = 1,
+	k_EButton_Grip = 2,
+	k_EButton_DPad_Left = 3,
+	k_EButton_DPad_Up = 4,
+	k_EButton_DPad_Right = 5,
+	k_EButton_DPad_Down = 6,
+	k_EButton_A = 7,
+
+	k_EButton_ProximitySensor = 31,
+
+	k_EButton_Axis0 = 32,
+	k_EButton_Axis1 = 33,
+	k_EButton_Axis2 = 34,
+	k_EButton_Axis3 = 35,
+	k_EButton_Axis4 = 36,
+
+	// aliases for well known controllers
+	k_EButton_SteamVR_Touchpad = k_EButton_Axis0,
+	k_EButton_SteamVR_Trigger = k_EButton_Axis1,
+
+	k_EButton_Dashboard_Back = k_EButton_Grip,
+
+	k_EButton_Max = 64
+};
+
+inline uint64_t ButtonMaskFromId(EVRButtonId id) { return 1ull << id; }
+
+/** used for controller button events */
+struct VREvent_Controller_t
+{
+	uint32_t button;  // EVRButtonId enum
+};
+
+/** used for simulated mouse events in overlay space */
+enum EVRMouseButton
+{
+	VRMouseButton_Left = 0x0001,
+	VRMouseButton_Right = 0x0002,
+	VRMouseButton_Middle = 0x0004,
+};
+
+/** used for simulated mouse events in overlay space */
+struct VREvent_Mouse_t
+{
+	float x, y;       // co-ords are in GL space, bottom left of the texture is 0,0
+	uint32_t button;  // EVRMouseButton enum
+};
+
+/** used for simulated mouse wheel scroll in overlay space */
+struct VREvent_Scroll_t
+{
+	float xdelta, ydelta;  // movement in fraction of the pad traversed since last delta, 1.0 for a full swipe
+	uint32_t repeatCount;
+};
+
+/** when in mouse input mode you can receive data from the touchpad, these events are only sent if the users finger
+   is on the touchpad (or just released from it) 
+**/
+struct VREvent_TouchPadMove_t
+{
+	// true if the users finger is detected on the touch pad
+	bool bFingerDown;
+
+	// How long the finger has been down in seconds
+	float flSecondsFingerDown;
+
+	// These values indicate the starting finger position (so you can do some basic swipe stuff)
+	float fValueXFirst;
+	float fValueYFirst;
+
+	// This is the raw sampled coordinate without deadzoning
+	float fValueXRaw;
+	float fValueYRaw;
+};
+
+/** notification related events. Details will still change at this point */
+struct VREvent_Notification_t
+{
+	uint64_t ulUserValue;
+	uint32_t notificationId;
+};
+
+/** Used for events about processes */
+struct VREvent_Process_t
+{
+	uint32_t pid;
+	uint32_t oldPid;
+	bool bForced;
+};
+
+/** Used for a few events about overlays */
+struct VREvent_Overlay_t
+{
+	uint64_t overlayHandle;
+};
+
+/** Used for a few events about overlays */
+struct VREvent_Status_t
+{
+	uint32_t statusState;  // EVRState enum
+};
+
+/** Used for keyboard events **/
+struct VREvent_Keyboard_t
+{
+	char cNewInput[8];    // Up to 11 bytes of new input
+	uint64_t uUserValue;  // Possible flags about the new input
+};
+
+struct VREvent_Ipd_t
+{
+	float ipdMeters;
+};
+
+struct VREvent_Chaperone_t
+{
+	uint64_t m_nPreviousUniverse;
+	uint64_t m_nCurrentUniverse;
+};
+
+/** Not actually used for any events */
+struct VREvent_Reserved_t
+{
+	uint64_t reserved0;
+	uint64_t reserved1;
+};
+
+struct VREvent_PerformanceTest_t
+{
+	uint32_t m_nFidelityLevel;
+};
+
+struct VREvent_SeatedZeroPoseReset_t
+{
+	bool bResetBySystemMenu;
+};
+
+struct VREvent_Screenshot_t
+{
+	uint32_t handle;
+	uint32_t type;
+};
+
+struct VREvent_ScreenshotProgress_t
+{
+	float progress;
+};
+
+struct VREvent_ApplicationLaunch_t
+{
+	uint32_t pid;
+	uint32_t unArgsHandle;
+};
+
+struct VREvent_EditingCameraSurface_t
+{
+	uint64_t overlayHandle;
+	uint32_t nVisualMode;
+};
+
+struct VREvent_MessageOverlay_t
+{
+	uint32_t unVRMessageOverlayResponse;  // vr::VRMessageOverlayResponse enum
+};
+
+struct VREvent_Property_t
+{
+	PropertyContainerHandle_t container;
+	ETrackedDeviceProperty prop;
+};
+
+/** NOTE!!! If you change this you MUST manually update openvr_interop.cs.py */
+typedef union {
+	VREvent_Reserved_t reserved;
+	VREvent_Controller_t controller;
+	VREvent_Mouse_t mouse;
+	VREvent_Scroll_t scroll;
+	VREvent_Process_t process;
+	VREvent_Notification_t notification;
+	VREvent_Overlay_t overlay;
+	VREvent_Status_t status;
+	VREvent_Keyboard_t keyboard;
+	VREvent_Ipd_t ipd;
+	VREvent_Chaperone_t chaperone;
+	VREvent_PerformanceTest_t performanceTest;
+	VREvent_TouchPadMove_t touchPadMove;
+	VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset;
+	VREvent_Screenshot_t screenshot;
+	VREvent_ScreenshotProgress_t screenshotProgress;
+	VREvent_ApplicationLaunch_t applicationLaunch;
+	VREvent_EditingCameraSurface_t cameraSurface;
+	VREvent_MessageOverlay_t messageOverlay;
+	VREvent_Property_t property;
+} VREvent_Data_t;
+
+#if defined(__linux__) || defined(__APPLE__)
+// This structure was originally defined mis-packed on Linux, preserved for
+// compatibility.
+#pragma pack(push, 4)
+#endif
+
+/** An event posted by the server to all running applications */
+struct VREvent_t
+{
+	uint32_t eventType;  // EVREventType enum
+	TrackedDeviceIndex_t trackedDeviceIndex;
+	float eventAgeSeconds;
+	// event data must be the end of the struct as its size is variable
+	VREvent_Data_t data;
+};
+
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+
+/** The mesh to draw into the stencil (or depth) buffer to perform 
+* early stencil (or depth) kills of pixels that will never appear on the HMD.
+* This mesh draws on all the pixels that will be hidden after distortion. 
+*
+* If the HMD does not provide a visible area mesh pVertexData will be
+* NULL and unTriangleCount will be 0. */
+struct HiddenAreaMesh_t
+{
+	const HmdVector2_t *pVertexData;
+	uint32_t unTriangleCount;
+};
+
+enum EHiddenAreaMeshType
+{
+	k_eHiddenAreaMesh_Standard = 0,
+	k_eHiddenAreaMesh_Inverse = 1,
+	k_eHiddenAreaMesh_LineLoop = 2,
+
+	k_eHiddenAreaMesh_Max = 3,
+};
+
+/** Identifies what kind of axis is on the controller at index n. Read this type 
+* with pVRSystem->Get( nControllerDeviceIndex, Prop_Axis0Type_Int32 + n );
+*/
+enum EVRControllerAxisType
+{
+	k_eControllerAxis_None = 0,
+	k_eControllerAxis_TrackPad = 1,
+	k_eControllerAxis_Joystick = 2,
+	k_eControllerAxis_Trigger = 3,  // Analog trigger data is in the X axis
+};
+
+/** contains information about one axis on the controller */
+struct VRControllerAxis_t
+{
+	float x;  // Ranges from -1.0 to 1.0 for joysticks and track pads. Ranges from 0.0 to 1.0 for triggers were 0 is fully released.
+	float y;  // Ranges from -1.0 to 1.0 for joysticks and track pads. Is always 0.0 for triggers.
+};
+
+/** the number of axes in the controller state */
+static const uint32_t k_unControllerStateAxisCount = 5;
+
+#if defined(__linux__) || defined(__APPLE__)
+// This structure was originally defined mis-packed on Linux, preserved for
+// compatibility.
+#pragma pack(push, 4)
+#endif
+
+/** Holds all the state of a controller at one moment in time. */
+struct VRControllerState001_t
+{
+	// If packet num matches that on your prior call, then the controller state hasn't been changed since
+	// your last call and there is no need to process it
+	uint32_t unPacketNum;
+
+	// bit flags for each of the buttons. Use ButtonMaskFromId to turn an ID into a mask
+	uint64_t ulButtonPressed;
+	uint64_t ulButtonTouched;
+
+	// Axis data for the controller's analog inputs
+	VRControllerAxis_t rAxis[k_unControllerStateAxisCount];
+};
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+
+typedef VRControllerState001_t VRControllerState_t;
+
+/** determines how to provide output to the application of various event processing functions. */
+enum EVRControllerEventOutputType
+{
+	ControllerEventOutput_OSEvents = 0,
+	ControllerEventOutput_VREvents = 1,
+};
+
+/** Collision Bounds Style */
+enum ECollisionBoundsStyle
+{
+	COLLISION_BOUNDS_STYLE_BEGINNER = 0,
+	COLLISION_BOUNDS_STYLE_INTERMEDIATE,
+	COLLISION_BOUNDS_STYLE_SQUARES,
+	COLLISION_BOUNDS_STYLE_ADVANCED,
+	COLLISION_BOUNDS_STYLE_NONE,
+
+	COLLISION_BOUNDS_STYLE_COUNT
+};
+
+/** Allows the application to customize how the overlay appears in the compositor */
+struct Compositor_OverlaySettings
+{
+	uint32_t size;  // sizeof(Compositor_OverlaySettings)
+	bool curved, antialias;
+	float scale, distance, alpha;
+	float uOffset, vOffset, uScale, vScale;
+	float gridDivs, gridWidth, gridScale;
+	HmdMatrix44_t transform;
+};
+
+/** used to refer to a single VR overlay */
+typedef uint64_t VROverlayHandle_t;
+
+static const VROverlayHandle_t k_ulOverlayHandleInvalid = 0;
+
+/** Errors that can occur around VR overlays */
+enum EVROverlayError
+{
+	VROverlayError_None = 0,
+
+	VROverlayError_UnknownOverlay = 10,
+	VROverlayError_InvalidHandle = 11,
+	VROverlayError_PermissionDenied = 12,
+	VROverlayError_OverlayLimitExceeded = 13,  // No more overlays could be created because the maximum number already exist
+	VROverlayError_WrongVisibilityType = 14,
+	VROverlayError_KeyTooLong = 15,
+	VROverlayError_NameTooLong = 16,
+	VROverlayError_KeyInUse = 17,
+	VROverlayError_WrongTransformType = 18,
+	VROverlayError_InvalidTrackedDevice = 19,
+	VROverlayError_InvalidParameter = 20,
+	VROverlayError_ThumbnailCantBeDestroyed = 21,
+	VROverlayError_ArrayTooSmall = 22,
+	VROverlayError_RequestFailed = 23,
+	VROverlayError_InvalidTexture = 24,
+	VROverlayError_UnableToLoadFile = 25,
+	VROverlayError_KeyboardAlreadyInUse = 26,
+	VROverlayError_NoNeighbor = 27,
+	VROverlayError_TooManyMaskPrimitives = 29,
+	VROverlayError_BadMaskPrimitive = 30,
+};
+
+/** enum values to pass in to VR_Init to identify whether the application will 
+* draw a 3D scene. */
+enum EVRApplicationType
+{
+	VRApplication_Other = 0,          // Some other kind of application that isn't covered by the other entries
+	VRApplication_Scene = 1,          // Application will submit 3D frames
+	VRApplication_Overlay = 2,        // Application only interacts with overlays
+	VRApplication_Background = 3,     // Application should not start SteamVR if it's not already running, and should not
+									  // keep it running if everything else quits.
+	VRApplication_Utility = 4,        // Init should not try to load any drivers. The application needs access to utility
+									  // interfaces (like IVRSettings and IVRApplications) but not hardware.
+	VRApplication_VRMonitor = 5,      // Reserved for vrmonitor
+	VRApplication_SteamWatchdog = 6,  // Reserved for Steam
+	VRApplication_Bootstrapper = 7,   // Start up SteamVR
+
+	VRApplication_Max
+};
+
+/** error codes for firmware */
+enum EVRFirmwareError
+{
+	VRFirmwareError_None = 0,
+	VRFirmwareError_Success = 1,
+	VRFirmwareError_Fail = 2,
+};
+
+/** error codes for notifications */
+enum EVRNotificationError
+{
+	VRNotificationError_OK = 0,
+	VRNotificationError_InvalidNotificationId = 100,
+	VRNotificationError_NotificationQueueFull = 101,
+	VRNotificationError_InvalidOverlayHandle = 102,
+	VRNotificationError_SystemWithUserValueAlreadyExists = 103,
+};
+
+/** error codes returned by Vr_Init */
+
+// Please add adequate error description to https://developer.valvesoftware.com/w/index.php?title=Category:SteamVRHelp
+enum EVRInitError
+{
+	VRInitError_None = 0,
+	VRInitError_Unknown = 1,
+
+	VRInitError_Init_InstallationNotFound = 100,
+	VRInitError_Init_InstallationCorrupt = 101,
+	VRInitError_Init_VRClientDLLNotFound = 102,
+	VRInitError_Init_FileNotFound = 103,
+	VRInitError_Init_FactoryNotFound = 104,
+	VRInitError_Init_InterfaceNotFound = 105,
+	VRInitError_Init_InvalidInterface = 106,
+	VRInitError_Init_UserConfigDirectoryInvalid = 107,
+	VRInitError_Init_HmdNotFound = 108,
+	VRInitError_Init_NotInitialized = 109,
+	VRInitError_Init_PathRegistryNotFound = 110,
+	VRInitError_Init_NoConfigPath = 111,
+	VRInitError_Init_NoLogPath = 112,
+	VRInitError_Init_PathRegistryNotWritable = 113,
+	VRInitError_Init_AppInfoInitFailed = 114,
+	VRInitError_Init_Retry = 115,               // Used internally to cause retries to vrserver
+	VRInitError_Init_InitCanceledByUser = 116,  // The calling application should silently exit. The user canceled app startup
+	VRInitError_Init_AnotherAppLaunching = 117,
+	VRInitError_Init_SettingsInitFailed = 118,
+	VRInitError_Init_ShuttingDown = 119,
+	VRInitError_Init_TooManyObjects = 120,
+	VRInitError_Init_NoServerForBackgroundApp = 121,
+	VRInitError_Init_NotSupportedWithCompositor = 122,
+	VRInitError_Init_NotAvailableToUtilityApps = 123,
+	VRInitError_Init_Internal = 124,
+	VRInitError_Init_HmdDriverIdIsNone = 125,
+	VRInitError_Init_HmdNotFoundPresenceFailed = 126,
+	VRInitError_Init_VRMonitorNotFound = 127,
+	VRInitError_Init_VRMonitorStartupFailed = 128,
+	VRInitError_Init_LowPowerWatchdogNotSupported = 129,
+	VRInitError_Init_InvalidApplicationType = 130,
+	VRInitError_Init_NotAvailableToWatchdogApps = 131,
+	VRInitError_Init_WatchdogDisabledInSettings = 132,
+	VRInitError_Init_VRDashboardNotFound = 133,
+	VRInitError_Init_VRDashboardStartupFailed = 134,
+	VRInitError_Init_VRHomeNotFound = 135,
+	VRInitError_Init_VRHomeStartupFailed = 136,
+	VRInitError_Init_RebootingBusy = 137,
+	VRInitError_Init_FirmwareUpdateBusy = 138,
+	VRInitError_Init_FirmwareRecoveryBusy = 139,
+
+	VRInitError_Driver_Failed = 200,
+	VRInitError_Driver_Unknown = 201,
+	VRInitError_Driver_HmdUnknown = 202,
+	VRInitError_Driver_NotLoaded = 203,
+	VRInitError_Driver_RuntimeOutOfDate = 204,
+	VRInitError_Driver_HmdInUse = 205,
+	VRInitError_Driver_NotCalibrated = 206,
+	VRInitError_Driver_CalibrationInvalid = 207,
+	VRInitError_Driver_HmdDisplayNotFound = 208,
+	VRInitError_Driver_TrackedDeviceInterfaceUnknown = 209,
+	// VRInitError_Driver_HmdDisplayNotFoundAfterFix = 210, // not needed: here for historic reasons
+	VRInitError_Driver_HmdDriverIdOutOfBounds = 211,
+	VRInitError_Driver_HmdDisplayMirrored = 212,
+
+	VRInitError_IPC_ServerInitFailed = 300,
+	VRInitError_IPC_ConnectFailed = 301,
+	VRInitError_IPC_SharedStateInitFailed = 302,
+	VRInitError_IPC_CompositorInitFailed = 303,
+	VRInitError_IPC_MutexInitFailed = 304,
+	VRInitError_IPC_Failed = 305,
+	VRInitError_IPC_CompositorConnectFailed = 306,
+	VRInitError_IPC_CompositorInvalidConnectResponse = 307,
+	VRInitError_IPC_ConnectFailedAfterMultipleAttempts = 308,
+
+	VRInitError_Compositor_Failed = 400,
+	VRInitError_Compositor_D3D11HardwareRequired = 401,
+	VRInitError_Compositor_FirmwareRequiresUpdate = 402,
+	VRInitError_Compositor_OverlayInitFailed = 403,
+	VRInitError_Compositor_ScreenshotsInitFailed = 404,
+	VRInitError_Compositor_UnableToCreateDevice = 405,
+
+	VRInitError_VendorSpecific_UnableToConnectToOculusRuntime = 1000,
+
+	VRInitError_VendorSpecific_HmdFound_CantOpenDevice = 1101,
+	VRInitError_VendorSpecific_HmdFound_UnableToRequestConfigStart = 1102,
+	VRInitError_VendorSpecific_HmdFound_NoStoredConfig = 1103,
+	VRInitError_VendorSpecific_HmdFound_ConfigTooBig = 1104,
+	VRInitError_VendorSpecific_HmdFound_ConfigTooSmall = 1105,
+	VRInitError_VendorSpecific_HmdFound_UnableToInitZLib = 1106,
+	VRInitError_VendorSpecific_HmdFound_CantReadFirmwareVersion = 1107,
+	VRInitError_VendorSpecific_HmdFound_UnableToSendUserDataStart = 1108,
+	VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataStart = 1109,
+	VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataNext = 1110,
+	VRInitError_VendorSpecific_HmdFound_UserDataAddressRange = 1111,
+	VRInitError_VendorSpecific_HmdFound_UserDataError = 1112,
+	VRInitError_VendorSpecific_HmdFound_ConfigFailedSanityCheck = 1113,
+
+	VRInitError_Steam_SteamInstallationNotFound = 2000,
+};
+
+enum EVRScreenshotType
+{
+	VRScreenshotType_None = 0,
+	VRScreenshotType_Mono = 1,  // left eye only
+	VRScreenshotType_Stereo = 2,
+	VRScreenshotType_Cubemap = 3,
+	VRScreenshotType_MonoPanorama = 4,
+	VRScreenshotType_StereoPanorama = 5
+};
+
+enum EVRScreenshotPropertyFilenames
+{
+	VRScreenshotPropertyFilenames_Preview = 0,
+	VRScreenshotPropertyFilenames_VR = 1,
+};
+
+enum EVRTrackedCameraError
+{
+	VRTrackedCameraError_None = 0,
+	VRTrackedCameraError_OperationFailed = 100,
+	VRTrackedCameraError_InvalidHandle = 101,
+	VRTrackedCameraError_InvalidFrameHeaderVersion = 102,
+	VRTrackedCameraError_OutOfHandles = 103,
+	VRTrackedCameraError_IPCFailure = 104,
+	VRTrackedCameraError_NotSupportedForThisDevice = 105,
+	VRTrackedCameraError_SharedMemoryFailure = 106,
+	VRTrackedCameraError_FrameBufferingFailure = 107,
+	VRTrackedCameraError_StreamSetupFailure = 108,
+	VRTrackedCameraError_InvalidGLTextureId = 109,
+	VRTrackedCameraError_InvalidSharedTextureHandle = 110,
+	VRTrackedCameraError_FailedToGetGLTextureId = 111,
+	VRTrackedCameraError_SharedTextureFailure = 112,
+	VRTrackedCameraError_NoFrameAvailable = 113,
+	VRTrackedCameraError_InvalidArgument = 114,
+	VRTrackedCameraError_InvalidFrameBufferSize = 115,
+};
+
+enum EVRTrackedCameraFrameType
+{
+	VRTrackedCameraFrameType_Distorted = 0,       // This is the camera video frame size in pixels, still distorted.
+	VRTrackedCameraFrameType_Undistorted,         // In pixels, an undistorted inscribed rectangle region without invalid regions. This size is subject to changes shortly.
+	VRTrackedCameraFrameType_MaximumUndistorted,  // In pixels, maximum undistorted with invalid regions. Non zero alpha component identifies valid regions.
+	MAX_CAMERA_FRAME_TYPES
+};
+
+typedef uint64_t TrackedCameraHandle_t;
+#define INVALID_TRACKED_CAMERA_HANDLE ((vr::TrackedCameraHandle_t)0)
+
+struct CameraVideoStreamFrameHeader_t
+{
+	EVRTrackedCameraFrameType eFrameType;
+
+	uint32_t nWidth;
+	uint32_t nHeight;
+	uint32_t nBytesPerPixel;
+
+	uint32_t nFrameSequence;
+
+	TrackedDevicePose_t standingTrackedDevicePose;
+};
+
+// Screenshot types
+typedef uint32_t ScreenshotHandle_t;
+
+static const uint32_t k_unScreenshotHandleInvalid = 0;
+
+#pragma pack(pop)
+
+// figure out how to import from the VR API dll
+#if defined(_WIN32)
+
+#ifdef VR_API_EXPORT
+#define VR_INTERFACE extern "C" __declspec(dllexport)
+#else
+#define VR_INTERFACE extern "C" __declspec(dllimport)
+#endif
+
+#elif defined(__GNUC__) || defined(COMPILER_GCC) || defined(__APPLE__)
+
+#ifdef VR_API_EXPORT
+#define VR_INTERFACE extern "C" __attribute__((visibility("default")))
+#else
+#define VR_INTERFACE extern "C"
+#endif
+
+#else
+#error "Unsupported Platform."
+#endif
+
+#if defined(_WIN32)
+#define VR_CALLTYPE __cdecl
+#else
+#define VR_CALLTYPE
+#endif
+
+}  // namespace vr
+
+#endif  // _INCLUDE_VRTYPES_H
+
+// vrannotation.h
+#ifdef API_GEN
+#define VR_CLANG_ATTR(ATTR) __attribute__((annotate(ATTR)))
+#else
+#define VR_CLANG_ATTR(ATTR)
+#endif
+
+#define VR_METHOD_DESC(DESC) VR_CLANG_ATTR("desc:" #DESC ";")
+#define VR_IGNOREATTR() VR_CLANG_ATTR("ignore")
+#define VR_OUT_STRUCT() VR_CLANG_ATTR("out_struct: ;")
+#define VR_OUT_STRING() VR_CLANG_ATTR("out_string: ;")
+#define VR_OUT_ARRAY_CALL(COUNTER, FUNCTION, PARAMS) VR_CLANG_ATTR("out_array_call:" #COUNTER "," #FUNCTION "," #PARAMS ";")
+#define VR_OUT_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR("out_array_count:" #COUNTER ";")
+#define VR_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR("array_count:" #COUNTER ";")
+#define VR_ARRAY_COUNT_D(COUNTER, DESC) VR_CLANG_ATTR("array_count:" #COUNTER ";desc:" #DESC)
+#define VR_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR("buffer_count:" #COUNTER ";")
+#define VR_OUT_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR("out_buffer_count:" #COUNTER ";")
+#define VR_OUT_STRING_COUNT(COUNTER) VR_CLANG_ATTR("out_string_count:" #COUNTER ";")
+
+// vrtrackedcameratypes.h
+#ifndef _VRTRACKEDCAMERATYPES_H
+#define _VRTRACKEDCAMERATYPES_H
+
+namespace vr
+{
+#pragma pack(push, 8)
+
+enum ECameraVideoStreamFormat
+{
+	CVS_FORMAT_UNKNOWN = 0,
+	CVS_FORMAT_RAW10 = 1,  // 10 bits per pixel
+	CVS_FORMAT_NV12 = 2,   // 12 bits per pixel
+	CVS_FORMAT_RGB24 = 3,  // 24 bits per pixel
+	CVS_MAX_FORMATS
+};
+
+enum ECameraCompatibilityMode
+{
+	CAMERA_COMPAT_MODE_BULK_DEFAULT = 0,
+	CAMERA_COMPAT_MODE_BULK_64K_DMA,
+	CAMERA_COMPAT_MODE_BULK_16K_DMA,
+	CAMERA_COMPAT_MODE_BULK_8K_DMA,
+	CAMERA_COMPAT_MODE_ISO_52FPS,
+	CAMERA_COMPAT_MODE_ISO_50FPS,
+	CAMERA_COMPAT_MODE_ISO_48FPS,
+	CAMERA_COMPAT_MODE_ISO_46FPS,
+	CAMERA_COMPAT_MODE_ISO_44FPS,
+	CAMERA_COMPAT_MODE_ISO_42FPS,
+	CAMERA_COMPAT_MODE_ISO_40FPS,
+	CAMERA_COMPAT_MODE_ISO_35FPS,
+	CAMERA_COMPAT_MODE_ISO_30FPS,
+	MAX_CAMERA_COMPAT_MODES
+};
+
+#ifdef _MSC_VER
+#define VR_CAMERA_DECL_ALIGN(x) __declspec(align(x))
+#else
+#define VR_CAMERA_DECL_ALIGN(x)  //
+#endif
+
+#define MAX_CAMERA_FRAME_SHARED_HANDLES 4
+
+VR_CAMERA_DECL_ALIGN(8)
+struct CameraVideoStreamFrame_t
+{
+	ECameraVideoStreamFormat m_nStreamFormat;
+
+	uint32_t m_nWidth;
+	uint32_t m_nHeight;
+
+	uint32_t m_nImageDataSize;  // Based on stream format, width, height
+
+	uint32_t m_nFrameSequence;  // Starts from 0 when stream starts.
+
+	uint32_t m_nBufferIndex;  // Identifies which buffer the image data is hosted
+	uint32_t m_nBufferCount;  // Total number of configured buffers
+
+	uint32_t m_nExposureTime;
+
+	uint32_t m_nISPFrameTimeStamp;  // Driver provided time stamp per driver centric time base
+	uint32_t m_nISPReferenceTimeStamp;
+	uint32_t m_nSyncCounter;
+
+	uint32_t m_nCamSyncEvents;
+	uint32_t m_nISPSyncEvents;
+
+	double m_flReferenceCamSyncTime;
+
+	double m_flFrameElapsedTime;  // Starts from 0 when stream starts. In seconds.
+	double m_flFrameDeliveryRate;
+
+	double m_flFrameCaptureTime_DriverAbsolute;    // In USB time, via AuxEvent
+	double m_flFrameCaptureTime_ServerRelative;    // In System time within the server
+	uint64_t m_nFrameCaptureTicks_ServerAbsolute;  // In system ticks within the server
+	double m_flFrameCaptureTime_ClientRelative;    // At the client, relative to when the frame was exposed/captured.
+
+	double m_flSyncMarkerError;
+
+	TrackedDevicePose_t m_StandingTrackedDevicePose;  // Supplied by HMD layer when used as a tracked camera
+
+	uint64_t m_pImageData;
+};
+
+#pragma pack(pop)
+
+}  // namespace vr
+
+#endif  // _VRTRACKEDCAMERATYPES_H
+// ivrsettings.h
+namespace vr
+{
+enum EVRSettingsError
+{
+	VRSettingsError_None = 0,
+	VRSettingsError_IPCFailed = 1,
+	VRSettingsError_WriteFailed = 2,
+	VRSettingsError_ReadFailed = 3,
+	VRSettingsError_JsonParseFailed = 4,
+	VRSettingsError_UnsetSettingHasNoDefault = 5,  // This will be returned if the setting does not appear in the appropriate default file and has not been set
+};
+
+// The maximum length of a settings key
+static const uint32_t k_unMaxSettingsKeyLength = 128;
+
+class IVRSettings
+{
+public:
+	virtual const char *GetSettingsErrorNameFromEnum(EVRSettingsError eError) = 0;
+
+	// Returns true if file sync occurred (force or settings dirty)
+	virtual bool Sync(bool bForce = false, EVRSettingsError *peError = nullptr) = 0;
+
+	virtual void SetBool(const char *pchSection, const char *pchSettingsKey, bool bValue, EVRSettingsError *peError = nullptr) = 0;
+	virtual void SetInt32(const char *pchSection, const char *pchSettingsKey, int32_t nValue, EVRSettingsError *peError = nullptr) = 0;
+	virtual void SetFloat(const char *pchSection, const char *pchSettingsKey, float flValue, EVRSettingsError *peError = nullptr) = 0;
+	virtual void SetString(const char *pchSection, const char *pchSettingsKey, const char *pchValue, EVRSettingsError *peError = nullptr) = 0;
+
+	// Users of the system need to provide a proper default in default.vrsettings in the resources/settings/ directory
+	// of either the runtime or the driver_xxx directory. Otherwise the default will be false, 0, 0.0 or ""
+	virtual bool GetBool(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+	virtual int32_t GetInt32(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+	virtual float GetFloat(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+	virtual void GetString(const char *pchSection, const char *pchSettingsKey, VR_OUT_STRING() char *pchValue, uint32_t unValueLen, EVRSettingsError *peError = nullptr) = 0;
+
+	virtual void RemoveSection(const char *pchSection, EVRSettingsError *peError = nullptr) = 0;
+	virtual void RemoveKeyInSection(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+};
+
+//-----------------------------------------------------------------------------
+static const char *const IVRSettings_Version = "IVRSettings_002";
+
+//-----------------------------------------------------------------------------
+// steamvr keys
+static const char *const k_pch_SteamVR_Section = "steamvr";
+static const char *const k_pch_SteamVR_RequireHmd_String = "requireHmd";
+static const char *const k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver";
+static const char *const k_pch_SteamVR_ForcedHmdKey_String = "forcedHmd";
+static const char *const k_pch_SteamVR_DisplayDebug_Bool = "displayDebug";
+static const char *const k_pch_SteamVR_DebugProcessPipe_String = "debugProcessPipe";
+static const char *const k_pch_SteamVR_DisplayDebugX_Int32 = "displayDebugX";
+static const char *const k_pch_SteamVR_DisplayDebugY_Int32 = "displayDebugY";
+static const char *const k_pch_SteamVR_SendSystemButtonToAllApps_Bool = "sendSystemButtonToAllApps";
+static const char *const k_pch_SteamVR_LogLevel_Int32 = "loglevel";
+static const char *const k_pch_SteamVR_IPD_Float = "ipd";
+static const char *const k_pch_SteamVR_Background_String = "background";
+static const char *const k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection";
+static const char *const k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight";
+static const char *const k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius";
+static const char *const k_pch_SteamVR_GridColor_String = "gridColor";
+static const char *const k_pch_SteamVR_PlayAreaColor_String = "playAreaColor";
+static const char *const k_pch_SteamVR_ShowStage_Bool = "showStage";
+static const char *const k_pch_SteamVR_ActivateMultipleDrivers_Bool = "activateMultipleDrivers";
+static const char *const k_pch_SteamVR_DirectMode_Bool = "directMode";
+static const char *const k_pch_SteamVR_DirectModeEdidVid_Int32 = "directModeEdidVid";
+static const char *const k_pch_SteamVR_DirectModeEdidPid_Int32 = "directModeEdidPid";
+static const char *const k_pch_SteamVR_UsingSpeakers_Bool = "usingSpeakers";
+static const char *const k_pch_SteamVR_SpeakersForwardYawOffsetDegrees_Float = "speakersForwardYawOffsetDegrees";
+static const char *const k_pch_SteamVR_BaseStationPowerManagement_Bool = "basestationPowerManagement";
+static const char *const k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses";
+static const char *const k_pch_SteamVR_SupersampleScale_Float = "supersampleScale";
+static const char *const k_pch_SteamVR_AllowAsyncReprojection_Bool = "allowAsyncReprojection";
+static const char *const k_pch_SteamVR_AllowReprojection_Bool = "allowInterleavedReprojection";
+static const char *const k_pch_SteamVR_ForceReprojection_Bool = "forceReprojection";
+static const char *const k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking";
+static const char *const k_pch_SteamVR_DefaultMirrorView_Int32 = "defaultMirrorView";
+static const char *const k_pch_SteamVR_ShowMirrorView_Bool = "showMirrorView";
+static const char *const k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry";
+static const char *const k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch";
+static const char *const k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch";
+static const char *const k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch";
+static const char *const k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard";
+static const char *const k_pch_SteamVR_EnableHomeApp = "enableHomeApp";
+static const char *const k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec";
+static const char *const k_pch_SteamVR_RetailDemo_Bool = "retailDemo";
+static const char *const k_pch_SteamVR_IpdOffset_Float = "ipdOffset";
+static const char *const k_pch_SteamVR_AllowSupersampleFiltering_Bool = "allowSupersampleFiltering";
+static const char *const k_pch_SteamVR_EnableLinuxVulkanAsync_Bool = "enableLinuxVulkanAsync";
+
+//-----------------------------------------------------------------------------
+// lighthouse keys
+static const char *const k_pch_Lighthouse_Section = "driver_lighthouse";
+static const char *const k_pch_Lighthouse_DisableIMU_Bool = "disableimu";
+static const char *const k_pch_Lighthouse_UseDisambiguation_String = "usedisambiguation";
+static const char *const k_pch_Lighthouse_DisambiguationDebug_Int32 = "disambiguationdebug";
+static const char *const k_pch_Lighthouse_PrimaryBasestation_Int32 = "primarybasestation";
+static const char *const k_pch_Lighthouse_DBHistory_Bool = "dbhistory";
+
+//-----------------------------------------------------------------------------
+// null keys
+static const char *const k_pch_Null_Section = "driver_null";
+static const char *const k_pch_Null_SerialNumber_String = "serialNumber";
+static const char *const k_pch_Null_ModelNumber_String = "modelNumber";
+static const char *const k_pch_Null_WindowX_Int32 = "windowX";
+static const char *const k_pch_Null_WindowY_Int32 = "windowY";
+static const char *const k_pch_Null_WindowWidth_Int32 = "windowWidth";
+static const char *const k_pch_Null_WindowHeight_Int32 = "windowHeight";
+static const char *const k_pch_Null_RenderWidth_Int32 = "renderWidth";
+static const char *const k_pch_Null_RenderHeight_Int32 = "renderHeight";
+static const char *const k_pch_Null_SecondsFromVsyncToPhotons_Float = "secondsFromVsyncToPhotons";
+static const char *const k_pch_Null_DisplayFrequency_Float = "displayFrequency";
+
+//-----------------------------------------------------------------------------
+// user interface keys
+static const char *const k_pch_UserInterface_Section = "userinterface";
+static const char *const k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop";
+static const char *const k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray";
+static const char *const k_pch_UserInterface_Screenshots_Bool = "screenshots";
+static const char *const k_pch_UserInterface_ScreenshotType_Int = "screenshotType";
+
+//-----------------------------------------------------------------------------
+// notification keys
+static const char *const k_pch_Notifications_Section = "notifications";
+static const char *const k_pch_Notifications_DoNotDisturb_Bool = "DoNotDisturb";
+
+//-----------------------------------------------------------------------------
+// keyboard keys
+static const char *const k_pch_Keyboard_Section = "keyboard";
+static const char *const k_pch_Keyboard_TutorialCompletions = "TutorialCompletions";
+static const char *const k_pch_Keyboard_ScaleX = "ScaleX";
+static const char *const k_pch_Keyboard_ScaleY = "ScaleY";
+static const char *const k_pch_Keyboard_OffsetLeftX = "OffsetLeftX";
+static const char *const k_pch_Keyboard_OffsetRightX = "OffsetRightX";
+static const char *const k_pch_Keyboard_OffsetY = "OffsetY";
+static const char *const k_pch_Keyboard_Smoothing = "Smoothing";
+
+//-----------------------------------------------------------------------------
+// perf keys
+static const char *const k_pch_Perf_Section = "perfcheck";
+static const char *const k_pch_Perf_HeuristicActive_Bool = "heuristicActive";
+static const char *const k_pch_Perf_NotifyInHMD_Bool = "warnInHMD";
+static const char *const k_pch_Perf_NotifyOnlyOnce_Bool = "warnOnlyOnce";
+static const char *const k_pch_Perf_AllowTimingStore_Bool = "allowTimingStore";
+static const char *const k_pch_Perf_SaveTimingsOnExit_Bool = "saveTimingsOnExit";
+static const char *const k_pch_Perf_TestData_Float = "perfTestData";
+static const char *const k_pch_Perf_LinuxGPUProfiling_Bool = "linuxGPUProfiling";
+
+//-----------------------------------------------------------------------------
+// collision bounds keys
+static const char *const k_pch_CollisionBounds_Section = "collisionBounds";
+static const char *const k_pch_CollisionBounds_Style_Int32 = "CollisionBoundsStyle";
+static const char *const k_pch_CollisionBounds_GroundPerimeterOn_Bool = "CollisionBoundsGroundPerimeterOn";
+static const char *const k_pch_CollisionBounds_CenterMarkerOn_Bool = "CollisionBoundsCenterMarkerOn";
+static const char *const k_pch_CollisionBounds_PlaySpaceOn_Bool = "CollisionBoundsPlaySpaceOn";
+static const char *const k_pch_CollisionBounds_FadeDistance_Float = "CollisionBoundsFadeDistance";
+static const char *const k_pch_CollisionBounds_ColorGammaR_Int32 = "CollisionBoundsColorGammaR";
+static const char *const k_pch_CollisionBounds_ColorGammaG_Int32 = "CollisionBoundsColorGammaG";
+static const char *const k_pch_CollisionBounds_ColorGammaB_Int32 = "CollisionBoundsColorGammaB";
+static const char *const k_pch_CollisionBounds_ColorGammaA_Int32 = "CollisionBoundsColorGammaA";
+
+//-----------------------------------------------------------------------------
+// camera keys
+static const char *const k_pch_Camera_Section = "camera";
+static const char *const k_pch_Camera_EnableCamera_Bool = "enableCamera";
+static const char *const k_pch_Camera_EnableCameraInDashboard_Bool = "enableCameraInDashboard";
+static const char *const k_pch_Camera_EnableCameraForCollisionBounds_Bool = "enableCameraForCollisionBounds";
+static const char *const k_pch_Camera_EnableCameraForRoomView_Bool = "enableCameraForRoomView";
+static const char *const k_pch_Camera_BoundsColorGammaR_Int32 = "cameraBoundsColorGammaR";
+static const char *const k_pch_Camera_BoundsColorGammaG_Int32 = "cameraBoundsColorGammaG";
+static const char *const k_pch_Camera_BoundsColorGammaB_Int32 = "cameraBoundsColorGammaB";
+static const char *const k_pch_Camera_BoundsColorGammaA_Int32 = "cameraBoundsColorGammaA";
+static const char *const k_pch_Camera_BoundsStrength_Int32 = "cameraBoundsStrength";
+
+//-----------------------------------------------------------------------------
+// audio keys
+static const char *const k_pch_audio_Section = "audio";
+static const char *const k_pch_audio_OnPlaybackDevice_String = "onPlaybackDevice";
+static const char *const k_pch_audio_OnRecordDevice_String = "onRecordDevice";
+static const char *const k_pch_audio_OnPlaybackMirrorDevice_String = "onPlaybackMirrorDevice";
+static const char *const k_pch_audio_OffPlaybackDevice_String = "offPlaybackDevice";
+static const char *const k_pch_audio_OffRecordDevice_String = "offRecordDevice";
+static const char *const k_pch_audio_VIVEHDMIGain = "viveHDMIGain";
+
+//-----------------------------------------------------------------------------
+// power management keys
+static const char *const k_pch_Power_Section = "power";
+static const char *const k_pch_Power_PowerOffOnExit_Bool = "powerOffOnExit";
+static const char *const k_pch_Power_TurnOffScreensTimeout_Float = "turnOffScreensTimeout";
+static const char *const k_pch_Power_TurnOffControllersTimeout_Float = "turnOffControllersTimeout";
+static const char *const k_pch_Power_ReturnToWatchdogTimeout_Float = "returnToWatchdogTimeout";
+static const char *const k_pch_Power_AutoLaunchSteamVROnButtonPress = "autoLaunchSteamVROnButtonPress";
+static const char *const k_pch_Power_PauseCompositorOnStandby_Bool = "pauseCompositorOnStandby";
+
+//-----------------------------------------------------------------------------
+// dashboard keys
+static const char *const k_pch_Dashboard_Section = "dashboard";
+static const char *const k_pch_Dashboard_EnableDashboard_Bool = "enableDashboard";
+static const char *const k_pch_Dashboard_ArcadeMode_Bool = "arcadeMode";
+
+//-----------------------------------------------------------------------------
+// model skin keys
+static const char *const k_pch_modelskin_Section = "modelskins";
+
+//-----------------------------------------------------------------------------
+// driver keys - These could be checked in any driver_<name> section
+static const char *const k_pch_Driver_Enable_Bool = "enable";
+
+}  // namespace vr
+
+// iservertrackeddevicedriver.h
+namespace vr
+{
+struct DriverPoseQuaternion_t
+{
+	double w, x, y, z;
+};
+
+struct DriverPose_t
+{
+	/* Time offset of this pose, in seconds from the actual time of the pose,
+	 * relative to the time of the PoseUpdated() call made by the driver.
+	 */
+	double poseTimeOffset;
+
+	/* Generally, the pose maintained by a driver
+	 * is in an inertial coordinate system different
+	 * from the world system of x+ right, y+ up, z+ back.
+	 * Also, the driver is not usually tracking the "head" position,
+	 * but instead an internal IMU or another reference point in the HMD.
+	 * The following two transforms transform positions and orientations
+	 * to app world space from driver world space,
+	 * and to HMD head space from driver local body space. 
+	 *
+	 * We maintain the driver pose state in its internal coordinate system,
+	 * so we can do the pose prediction math without having to
+	 * use angular acceleration.  A driver's angular acceleration is generally not measured,
+	 * and is instead calculated from successive samples of angular velocity.
+	 * This leads to a noisy angular acceleration values, which are also
+	 * lagged due to the filtering required to reduce noise to an acceptable level.
+	 */
+	vr::HmdQuaternion_t qWorldFromDriverRotation;
+	double vecWorldFromDriverTranslation[3];
+
+	vr::HmdQuaternion_t qDriverFromHeadRotation;
+	double vecDriverFromHeadTranslation[3];
+
+	/* State of driver pose, in meters and radians. */
+	/* Position of the driver tracking reference in driver world space
+	* +[0] (x) is right
+	* +[1] (y) is up
+	* -[2] (z) is forward
+	*/
+	double vecPosition[3];
+
+	/* Velocity of the pose in meters/second */
+	double vecVelocity[3];
+
+	/* Acceleration of the pose in meters/second */
+	double vecAcceleration[3];
+
+	/* Orientation of the tracker, represented as a quaternion */
+	vr::HmdQuaternion_t qRotation;
+
+	/* Angular velocity of the pose in axis-angle 
+	* representation. The direction is the angle of
+	* rotation and the magnitude is the angle around
+	* that axis in radians/second. */
+	double vecAngularVelocity[3];
+
+	/* Angular acceleration of the pose in axis-angle 
+	* representation. The direction is the angle of
+	* rotation and the magnitude is the angle around
+	* that axis in radians/second^2. */
+	double vecAngularAcceleration[3];
+
+	ETrackingResult result;
+
+	bool poseIsValid;
+	bool willDriftInYaw;
+	bool shouldApplyHeadModel;
+	bool deviceIsConnected;
+};
+
+// ----------------------------------------------------------------------------------------------
+// Purpose: Represents a single tracked device in a driver
+// ----------------------------------------------------------------------------------------------
+class ITrackedDeviceServerDriver
+{
+public:
+	// ------------------------------------
+	// Management Methods
+	// ------------------------------------
+	/** This is called before an HMD is returned to the application. It will always be
+	* called before any display or tracking methods. Memory and processor use by the
+	* ITrackedDeviceServerDriver object should be kept to a minimum until it is activated.
+	* The pose listener is guaranteed to be valid until Deactivate is called, but
+	* should not be used after that point. */
+	virtual EVRInitError Activate(uint32_t unObjectId) = 0;
+
+	/** This is called when The VR system is switching from this Hmd being the active display
+	* to another Hmd being the active display. The driver should clean whatever memory
+	* and thread use it can when it is deactivated */
+	virtual void Deactivate() = 0;
+
+	/** Handles a request from the system to put this device into standby mode. What that means is defined per-device. */
+	virtual void EnterStandby() = 0;
+
+	/** Requests a component interface of the driver for device-specific functionality. The driver should return NULL
+	* if the requested interface or version is not supported. */
+	virtual void *GetComponent(const char *pchComponentNameAndVersion) = 0;
+
+	/** A VR Client has made this debug request of the driver. The set of valid requests is entirely
+	* up to the driver and the client to figure out, as is the format of the response. Responses that
+	* exceed the length of the supplied buffer should be truncated and null terminated */
+	virtual void DebugRequest(const char *pchRequest, char *pchResponseBuffer, uint32_t unResponseBufferSize) = 0;
+
+	// ------------------------------------
+	// Tracking Methods
+	// ------------------------------------
+	virtual DriverPose_t GetPose() = 0;
+};
+
+static const char *ITrackedDeviceServerDriver_Version = "ITrackedDeviceServerDriver_005";
+
+}  // namespace vr
+// ivrdisplaycomponent.h
+namespace vr
+{
+// ----------------------------------------------------------------------------------------------
+// Purpose: The display component on a single tracked device
+// ----------------------------------------------------------------------------------------------
+class IVRDisplayComponent
+{
+public:
+	// ------------------------------------
+	// Display Methods
+	// ------------------------------------
+
+	/** Size and position that the window needs to be on the VR display. */
+	virtual void GetWindowBounds(int32_t *pnX, int32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight) = 0;
+
+	/** Returns true if the display is extending the desktop. */
+	virtual bool IsDisplayOnDesktop() = 0;
+
+	/** Returns true if the display is real and not a fictional display. */
+	virtual bool IsDisplayRealDisplay() = 0;
+
+	/** Suggested size for the intermediate render target that the distortion pulls from. */
+	virtual void GetRecommendedRenderTargetSize(uint32_t *pnWidth, uint32_t *pnHeight) = 0;
+
+	/** Gets the viewport in the frame buffer to draw the output of the distortion into */
+	virtual void GetEyeOutputViewport(EVREye eEye, uint32_t *pnX, uint32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight) = 0;
+
+	/** The components necessary to build your own projection matrix in case your
+		* application is doing something fancy like infinite Z */
+	virtual void GetProjectionRaw(EVREye eEye, float *pfLeft, float *pfRight, float *pfTop, float *pfBottom) = 0;
+
+	/** Returns the result of the distortion function for the specified eye and input UVs. UVs go from 0,0 in
+		* the upper left of that eye's viewport and 1,1 in the lower right of that eye's viewport. */
+	virtual DistortionCoordinates_t ComputeDistortion(EVREye eEye, float fU, float fV) = 0;
+};
+
+static const char *IVRDisplayComponent_Version = "IVRDisplayComponent_002";
+
+}  // namespace vr
+
+// ivrdriverdirectmodecomponent.h
+namespace vr
+{
+// ----------------------------------------------------------------------------------------------
+// Purpose: This component is used for drivers that implement direct mode entirely on their own
+//			without allowing the VR Compositor to own the window/device. Chances are you don't
+//			need to implement this component in your driver.
+// ----------------------------------------------------------------------------------------------
+class IVRDriverDirectModeComponent
+{
+public:
+	// -----------------------------------
+	// Direct mode methods
+	// -----------------------------------
+
+	/** Specific to Oculus compositor support, textures supplied must be created using this method. */
+	virtual void CreateSwapTextureSet(uint32_t unPid, uint32_t unFormat, uint32_t unWidth, uint32_t unHeight, vr::SharedTextureHandle_t (*pSharedTextureHandles)[3]) {}
+
+	/** Used to textures created using CreateSwapTextureSet.  Only one of the set's handles needs to be used to destroy the entire set. */
+	virtual void DestroySwapTextureSet(vr::SharedTextureHandle_t sharedTextureHandle) {}
+
+	/** Used to purge all texture sets for a given process. */
+	virtual void DestroyAllSwapTextureSets(uint32_t unPid) {}
+
+	/** After Present returns, calls this to get the next index to use for rendering. */
+	virtual void GetNextSwapTextureSetIndex(vr::SharedTextureHandle_t sharedTextureHandles[2], uint32_t (*pIndices)[2]) {}
+
+	/** Call once per layer to draw for this frame.  One shared texture handle per eye.  Textures must be created
+		* using CreateSwapTextureSet and should be alternated per frame.  Call Present once all layers have been submitted. */
+	virtual void SubmitLayer(vr::SharedTextureHandle_t sharedTextureHandles[2], const vr::VRTextureBounds_t (&bounds)[2], const vr::HmdMatrix34_t *pPose) {}
+
+	/** Submits queued layers for display. */
+	virtual void Present(vr::SharedTextureHandle_t syncTexture) {}
+};
+
+static const char *IVRDriverDirectModeComponent_Version = "IVRDriverDirectModeComponent_002";
+
+}  // namespace vr
+
+// ivrcontrollercomponent.h
+namespace vr
+{
+// ----------------------------------------------------------------------------------------------
+// Purpose: Controller access on a single tracked device.
+// ----------------------------------------------------------------------------------------------
+class IVRControllerComponent
+{
+public:
+	// ------------------------------------
+	// Controller Methods
+	// ------------------------------------
+
+	/** Gets the current state of a controller. */
+	virtual VRControllerState_t GetControllerState() = 0;
+
+	/** Returns a uint64 property. If the property is not available this function will return 0. */
+	virtual bool TriggerHapticPulse(uint32_t unAxisId, uint16_t usPulseDurationMicroseconds) = 0;
+};
+
+static const char *IVRControllerComponent_Version = "IVRControllerComponent_001";
+
+}  // namespace vr
+// ivrcameracomponent.h
+namespace vr
+{
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+class ICameraVideoSinkCallback
+{
+public:
+	virtual void OnCameraVideoSinkCallback() = 0;
+};
+
+// ----------------------------------------------------------------------------------------------
+// Purpose: The camera on a single tracked device
+// ----------------------------------------------------------------------------------------------
+class IVRCameraComponent
+{
+public:
+	// ------------------------------------
+	// Camera Methods
+	// ------------------------------------
+	virtual bool GetCameraFrameDimensions(vr::ECameraVideoStreamFormat nVideoStreamFormat, uint32_t *pWidth, uint32_t *pHeight) = 0;
+	virtual bool GetCameraFrameBufferingRequirements(int *pDefaultFrameQueueSize, uint32_t *pFrameBufferDataSize) = 0;
+	virtual bool SetCameraFrameBuffering(int nFrameBufferCount, void **ppFrameBuffers, uint32_t nFrameBufferDataSize) = 0;
+	virtual bool SetCameraVideoStreamFormat(vr::ECameraVideoStreamFormat nVideoStreamFormat) = 0;
+	virtual vr::ECameraVideoStreamFormat GetCameraVideoStreamFormat() = 0;
+	virtual bool StartVideoStream() = 0;
+	virtual void StopVideoStream() = 0;
+	virtual bool IsVideoStreamActive(bool *pbPaused, float *pflElapsedTime) = 0;
+	virtual const vr::CameraVideoStreamFrame_t *GetVideoStreamFrame() = 0;
+	virtual void ReleaseVideoStreamFrame(const vr::CameraVideoStreamFrame_t *pFrameImage) = 0;
+	virtual bool SetAutoExposure(bool bEnable) = 0;
+	virtual bool PauseVideoStream() = 0;
+	virtual bool ResumeVideoStream() = 0;
+	virtual bool GetCameraDistortion(float flInputU, float flInputV, float *pflOutputU, float *pflOutputV) = 0;
+	virtual bool GetCameraProjection(vr::EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, vr::HmdMatrix44_t *pProjection) = 0;
+	virtual bool SetFrameRate(int nISPFrameRate, int nSensorFrameRate) = 0;
+	virtual bool SetCameraVideoSinkCallback(vr::ICameraVideoSinkCallback *pCameraVideoSinkCallback) = 0;
+	virtual bool GetCameraCompatibilityMode(vr::ECameraCompatibilityMode *pCameraCompatibilityMode) = 0;
+	virtual bool SetCameraCompatibilityMode(vr::ECameraCompatibilityMode nCameraCompatibilityMode) = 0;
+	virtual bool GetCameraFrameBounds(vr::EVRTrackedCameraFrameType eFrameType, uint32_t *pLeft, uint32_t *pTop, uint32_t *pWidth, uint32_t *pHeight) = 0;
+	virtual bool GetCameraIntrinsics(vr::EVRTrackedCameraFrameType eFrameType, HmdVector2_t *pFocalLength, HmdVector2_t *pCenter) = 0;
+};
+
+static const char *IVRCameraComponent_Version = "IVRCameraComponent_002";
+}  // namespace vr
+// itrackeddevicedriverprovider.h
+namespace vr
+{
+class ITrackedDeviceServerDriver;
+struct TrackedDeviceDriverInfo_t;
+struct DriverPose_t;
+typedef PropertyContainerHandle_t DriverHandle_t;
+
+/** This interface is provided by vrserver to allow the driver to notify 
+* the system when something changes about a device. These changes must
+* not change the serial number or class of the device because those values
+* are permanently associated with the device's index. */
+class IVRDriverContext
+{
+public:
+	/** Returns the requested interface. If the interface was not available it will return NULL and fill
+	* out the error. */
+	virtual void *GetGenericInterface(const char *pchInterfaceVersion, EVRInitError *peError = nullptr) = 0;
+
+	/** Returns the property container handle for this driver */
+	virtual DriverHandle_t GetDriverHandle() = 0;
+};
+
+/** This interface must be implemented in each driver. It will be loaded in vrserver.exe */
+class IServerTrackedDeviceProvider
+{
+public:
+	/** initializes the driver. This will be called before any other methods are called.
+	* If Init returns anything other than VRInitError_None the driver DLL will be unloaded.
+	*
+	* pDriverHost will never be NULL, and will always be a pointer to a IServerDriverHost interface
+	*
+	* pchUserDriverConfigDir - The absolute path of the directory where the driver should store user
+	*	config files.
+	* pchDriverInstallDir - The absolute path of the root directory for the driver.
+	*/
+	virtual EVRInitError Init(IVRDriverContext *pDriverContext) = 0;
+
+	/** cleans up the driver right before it is unloaded */
+	virtual void Cleanup() = 0;
+
+	/** Returns the version of the ITrackedDeviceServerDriver interface used by this driver */
+	virtual const char *const *GetInterfaceVersions() = 0;
+
+	/** Allows the driver do to some work in the main loop of the server. */
+	virtual void RunFrame() = 0;
+
+	// ------------  Power State Functions ----------------------- //
+
+	/** Returns true if the driver wants to block Standby mode. */
+	virtual bool ShouldBlockStandbyMode() = 0;
+
+	/** Called when the system is entering Standby mode. The driver should switch itself into whatever sort of low-power
+	* state it has. */
+	virtual void EnterStandby() = 0;
+
+	/** Called when the system is leaving Standby mode. The driver should switch itself back to
+	full operation. */
+	virtual void LeaveStandby() = 0;
+};
+
+static const char *IServerTrackedDeviceProvider_Version = "IServerTrackedDeviceProvider_004";
+
+/** This interface must be implemented in each driver. It will be loaded in vrclient.dll */
+class IVRWatchdogProvider
+{
+public:
+	/** initializes the driver in watchdog mode. */
+	virtual EVRInitError Init(IVRDriverContext *pDriverContext) = 0;
+
+	/** cleans up the driver right before it is unloaded */
+	virtual void Cleanup() = 0;
+};
+
+static const char *IVRWatchdogProvider_Version = "IVRWatchdogProvider_001";
+
+}  // namespace vr
+// ivrproperties.h
+#include <string>
+
+namespace vr
+{
+enum EPropertyWriteType
+{
+	PropertyWrite_Set = 0,
+	PropertyWrite_Erase = 1,
+	PropertyWrite_SetError = 2
+};
+
+struct PropertyWrite_t
+{
+	ETrackedDeviceProperty prop;
+	EPropertyWriteType writeType;
+	ETrackedPropertyError eSetError;
+	void *pvBuffer;
+	uint32_t unBufferSize;
+	PropertyTypeTag_t unTag;
+	ETrackedPropertyError eError;
+};
+
+struct PropertyRead_t
+{
+	ETrackedDeviceProperty prop;
+	void *pvBuffer;
+	uint32_t unBufferSize;
+	PropertyTypeTag_t unTag;
+	uint32_t unRequiredBufferSize;
+	ETrackedPropertyError eError;
+};
+
+class IVRProperties
+{
+public:
+	/** Reads a set of properties atomically. See the PropertyReadBatch_t struct for more information. */
+	virtual ETrackedPropertyError ReadPropertyBatch(PropertyContainerHandle_t ulContainerHandle, PropertyRead_t *pBatch, uint32_t unBatchEntryCount) = 0;
+
+	/** Writes a set of properties atomically. See the PropertyWriteBatch_t struct for more information. */
+	virtual ETrackedPropertyError WritePropertyBatch(PropertyContainerHandle_t ulContainerHandle, PropertyWrite_t *pBatch, uint32_t unBatchEntryCount) = 0;
+
+	/** returns a string that corresponds with the specified property error. The string will be the name
+	* of the error enum value for all valid error codes */
+	virtual const char *GetPropErrorNameFromEnum(ETrackedPropertyError error) = 0;
+
+	/** Returns a container handle given a tracked device index */
+	virtual PropertyContainerHandle_t TrackedDeviceToPropertyContainer(TrackedDeviceIndex_t nDevice) = 0;
+};
+
+static const char *const IVRProperties_Version = "IVRProperties_001";
+
+class CVRPropertyHelpers
+{
+public:
+	CVRPropertyHelpers(IVRProperties *pProperties) : m_pProperties(pProperties) {}
+
+	/** Returns a scaler property. If the device index is not valid or the property value type does not match,
+	* this function will return false. */
+	bool GetBoolProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L);
+	float GetFloatProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L);
+	int32_t GetInt32Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L);
+	uint64_t GetUint64Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L);
+
+	/** Returns a single typed property. If the device index is not valid or the property is not a string type this function will
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters. */
+	uint32_t GetProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, VR_OUT_STRING() void *pvBuffer, uint32_t unBufferSize, PropertyTypeTag_t *punTag, ETrackedPropertyError *pError = 0L);
+
+	/** Returns a string property. If the device index is not valid or the property is not a string type this function will
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters. */
+	uint32_t GetStringProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError = 0L);
+
+	/** Returns a string property as a std::string. If the device index is not valid or the property is not a string type this function will
+	* return an empty string. */
+	std::string GetStringProperty(vr::PropertyContainerHandle_t ulContainer, vr::ETrackedDeviceProperty prop, vr::ETrackedPropertyError *peError = nullptr);
+
+	/** Sets a scaler property. The new value will be returned on any subsequent call to get this property in any process. */
+	ETrackedPropertyError SetBoolProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, bool bNewValue);
+	ETrackedPropertyError SetFloatProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, float fNewValue);
+	ETrackedPropertyError SetInt32Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, int32_t nNewValue);
+	ETrackedPropertyError SetUint64Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, uint64_t ulNewValue);
+
+	/** Sets a string property. The new value will be returned on any subsequent call to get this property in any process. */
+	ETrackedPropertyError SetStringProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, const char *pchNewValue);
+
+	/** Sets a single typed property. The new value will be returned on any subsequent call to get this property in any process. */
+	ETrackedPropertyError SetProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, void *pvNewValue, uint32_t unNewValueSize, PropertyTypeTag_t unTag);
+
+	/** Sets the error return value for a property. This value will be returned on all subsequent requests to get the property */
+	ETrackedPropertyError SetPropertyError(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError eError);
+
+	/** Clears any value or error set for the property. */
+	ETrackedPropertyError EraseProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop);
+
+	/* Turns a device index into a property container handle. */
+	PropertyContainerHandle_t TrackedDeviceToPropertyContainer(TrackedDeviceIndex_t nDevice) { return m_pProperties->TrackedDeviceToPropertyContainer(nDevice); }
+
+private:
+	template <typename T>
+	T GetPropertyHelper(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError, T bDefault, PropertyTypeTag_t unTypeTag);
+
+	IVRProperties *m_pProperties;
+};
+
+inline uint32_t CVRPropertyHelpers::GetProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, VR_OUT_STRING() void *pvBuffer, uint32_t unBufferSize, PropertyTypeTag_t *punTag, ETrackedPropertyError *pError)
+{
+	PropertyRead_t batch;
+	batch.prop = prop;
+	batch.pvBuffer = pvBuffer;
+	batch.unBufferSize = unBufferSize;
+
+	m_pProperties->ReadPropertyBatch(ulContainerHandle, &batch, 1);
+
+	if (pError)
+	{
+		*pError = batch.eError;
+	}
+
+	if (punTag)
+	{
+		*punTag = batch.unTag;
+	}
+
+	return batch.unRequiredBufferSize;
+}
+
+/** Sets a single typed property. The new value will be returned on any subsequent call to get this property in any process. */
+inline ETrackedPropertyError CVRPropertyHelpers::SetProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, void *pvNewValue, uint32_t unNewValueSize, PropertyTypeTag_t unTag)
+{
+	PropertyWrite_t batch;
+	batch.writeType = PropertyWrite_Set;
+	batch.prop = prop;
+	batch.pvBuffer = pvNewValue;
+	batch.unBufferSize = unNewValueSize;
+	batch.unTag = unTag;
+
+	m_pProperties->WritePropertyBatch(ulContainerHandle, &batch, 1);
+
+	return batch.eError;
+}
+
+/** Returns a string property. If the device index is not valid or the property is not a string type this function will
+* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+* null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters. */
+inline uint32_t CVRPropertyHelpers::GetStringProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError)
+{
+	PropertyTypeTag_t unTag;
+	ETrackedPropertyError error;
+	uint32_t unRequiredSize = GetProperty(ulContainerHandle, prop, pchValue, unBufferSize, &unTag, &error);
+	if (unTag != k_unStringPropertyTag && error == TrackedProp_Success)
+	{
+		error = TrackedProp_WrongDataType;
+	}
+
+	if (pError)
+	{
+		*pError = error;
+	}
+
+	if (error != TrackedProp_Success)
+	{
+		if (pchValue && unBufferSize)
+		{
+			*pchValue = '\0';
+		}
+	}
+
+	return unRequiredSize;
+}
+
+/** Returns a string property as a std::string. If the device index is not valid or the property is not a string type this function will
+* return an empty string. */
+inline std::string CVRPropertyHelpers::GetStringProperty(vr::PropertyContainerHandle_t ulContainer, vr::ETrackedDeviceProperty prop, vr::ETrackedPropertyError *peError)
+{
+	char buf[1024];
+	vr::ETrackedPropertyError err;
+	uint32_t unRequiredBufferLen = GetStringProperty(ulContainer, prop, buf, sizeof(buf), &err);
+
+	std::string sResult;
+
+	if (err == TrackedProp_Success)
+	{
+		sResult = buf;
+	}
+	else if (err == TrackedProp_BufferTooSmall)
+	{
+		char *pchBuffer = new char[unRequiredBufferLen];
+		unRequiredBufferLen = GetStringProperty(ulContainer, prop, pchBuffer, unRequiredBufferLen, &err);
+		sResult = pchBuffer;
+		delete[] pchBuffer;
+	}
+
+	if (peError)
+	{
+		*peError = err;
+	}
+
+	return sResult;
+}
+
+/** Sets a string property. The new value will be returned on any subsequent call to get this property in any process. */
+inline ETrackedPropertyError CVRPropertyHelpers::SetStringProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, const char *pchNewValue)
+{
+	if (!pchNewValue)
+		return TrackedProp_InvalidOperation;
+
+	// this is strlen without the dependency on string.h
+	const char *pchCurr = pchNewValue;
+	while (*pchCurr)
+	{
+		pchCurr++;
+	}
+
+	return SetProperty(ulContainerHandle, prop, (void *)pchNewValue, (uint32_t)(pchCurr - pchNewValue) + 1, k_unStringPropertyTag);
+}
+
+template <typename T>
+inline T CVRPropertyHelpers::GetPropertyHelper(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError, T bDefault, PropertyTypeTag_t unTypeTag)
+{
+	T bValue;
+	ETrackedPropertyError eError;
+	PropertyTypeTag_t unReadTag;
+	GetProperty(ulContainerHandle, prop, &bValue, sizeof(bValue), &unReadTag, &eError);
+	if (unReadTag != unTypeTag && eError == TrackedProp_Success)
+	{
+		eError = TrackedProp_WrongDataType;
+	};
+
+	if (pError)
+		*pError = eError;
+	if (eError != TrackedProp_Success)
+	{
+		return bDefault;
+	}
+	else
+	{
+		return bValue;
+	}
+}
+
+inline bool CVRPropertyHelpers::GetBoolProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError)
+{
+	return GetPropertyHelper<bool>(ulContainerHandle, prop, pError, false, k_unBoolPropertyTag);
+}
+
+inline float CVRPropertyHelpers::GetFloatProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError)
+{
+	return GetPropertyHelper<float>(ulContainerHandle, prop, pError, 0.f, k_unFloatPropertyTag);
+}
+
+inline int32_t CVRPropertyHelpers::GetInt32Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError)
+{
+	return GetPropertyHelper<int32_t>(ulContainerHandle, prop, pError, 0, k_unInt32PropertyTag);
+}
+
+inline uint64_t CVRPropertyHelpers::GetUint64Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError)
+{
+	return GetPropertyHelper<uint64_t>(ulContainerHandle, prop, pError, 0, k_unUint64PropertyTag);
+}
+
+inline ETrackedPropertyError CVRPropertyHelpers::SetBoolProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, bool bNewValue)
+{
+	return SetProperty(ulContainerHandle, prop, &bNewValue, sizeof(bNewValue), k_unBoolPropertyTag);
+}
+
+inline ETrackedPropertyError CVRPropertyHelpers::SetFloatProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, float fNewValue)
+{
+	return SetProperty(ulContainerHandle, prop, &fNewValue, sizeof(fNewValue), k_unFloatPropertyTag);
+}
+
+inline ETrackedPropertyError CVRPropertyHelpers::SetInt32Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, int32_t nNewValue)
+{
+	return SetProperty(ulContainerHandle, prop, &nNewValue, sizeof(nNewValue), k_unInt32PropertyTag);
+}
+
+inline ETrackedPropertyError CVRPropertyHelpers::SetUint64Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, uint64_t ulNewValue)
+{
+	return SetProperty(ulContainerHandle, prop, &ulNewValue, sizeof(ulNewValue), k_unUint64PropertyTag);
+}
+
+/** Sets the error return value for a property. This value will be returned on all subsequent requests to get the property */
+inline ETrackedPropertyError CVRPropertyHelpers::SetPropertyError(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError eError)
+{
+	PropertyWrite_t batch;
+	batch.writeType = PropertyWrite_SetError;
+	batch.prop = prop;
+	batch.eSetError = eError;
+
+	m_pProperties->WritePropertyBatch(ulContainerHandle, &batch, 1);
+
+	return batch.eError;
+}
+
+/** Clears any value or error set for the property. */
+inline ETrackedPropertyError CVRPropertyHelpers::EraseProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop)
+{
+	PropertyWrite_t batch;
+	batch.writeType = PropertyWrite_Erase;
+	batch.prop = prop;
+
+	m_pProperties->WritePropertyBatch(ulContainerHandle, &batch, 1);
+
+	return batch.eError;
+}
+
+}  // namespace vr
+
+// ivrdriverlog.h
+namespace vr
+{
+class IVRDriverLog
+{
+public:
+	/** Writes a log message to the log file prefixed with the driver name */
+	virtual void Log(const char *pchLogMessage) = 0;
+};
+
+static const char *IVRDriverLog_Version = "IVRDriverLog_001";
+
+}  // namespace vr
+// ivrserverdriverhost.h
+namespace vr
+{
+class ITrackedDeviceServerDriver;
+struct TrackedDeviceDriverInfo_t;
+struct DriverPose_t;
+
+/** This interface is provided by vrserver to allow the driver to notify 
+* the system when something changes about a device. These changes must
+* not change the serial number or class of the device because those values
+* are permanently associated with the device's index. */
+class IVRServerDriverHost
+{
+public:
+	/** Notifies the server that a tracked device has been added. If this function returns true
+	* the server will call Activate on the device. If it returns false some kind of error
+	* has occurred and the device will not be activated. */
+	virtual bool TrackedDeviceAdded(const char *pchDeviceSerialNumber, ETrackedDeviceClass eDeviceClass, ITrackedDeviceServerDriver *pDriver) = 0;
+
+	/** Notifies the server that a tracked device's pose has been updated */
+	virtual void TrackedDevicePoseUpdated(uint32_t unWhichDevice, const DriverPose_t &newPose, uint32_t unPoseStructSize) = 0;
+
+	/** Notifies the server that vsync has occurred on the the display attached to the device. This is
+	* only permitted on devices of the HMD class. */
+	virtual void VsyncEvent(double vsyncTimeOffsetSeconds) = 0;
+
+	/** notifies the server that the button was pressed */
+	virtual void TrackedDeviceButtonPressed(uint32_t unWhichDevice, EVRButtonId eButtonId, double eventTimeOffset) = 0;
+
+	/** notifies the server that the button was unpressed */
+	virtual void TrackedDeviceButtonUnpressed(uint32_t unWhichDevice, EVRButtonId eButtonId, double eventTimeOffset) = 0;
+
+	/** notifies the server that the button was pressed */
+	virtual void TrackedDeviceButtonTouched(uint32_t unWhichDevice, EVRButtonId eButtonId, double eventTimeOffset) = 0;
+
+	/** notifies the server that the button was unpressed */
+	virtual void TrackedDeviceButtonUntouched(uint32_t unWhichDevice, EVRButtonId eButtonId, double eventTimeOffset) = 0;
+
+	/** notifies the server than a controller axis changed */
+	virtual void TrackedDeviceAxisUpdated(uint32_t unWhichDevice, uint32_t unWhichAxis, const VRControllerAxis_t &axisState) = 0;
+
+	/** Notifies the server that the proximity sensor on the specified device  */
+	virtual void ProximitySensorState(uint32_t unWhichDevice, bool bProximitySensorTriggered) = 0;
+
+	/** Sends a vendor specific event (VREvent_VendorSpecific_Reserved_Start..VREvent_VendorSpecific_Reserved_End */
+	virtual void VendorSpecificEvent(uint32_t unWhichDevice, vr::EVREventType eventType, const VREvent_Data_t &eventData, double eventTimeOffset) = 0;
+
+	/** Returns true if SteamVR is exiting */
+	virtual bool IsExiting() = 0;
+
+	/** Returns true and fills the event with the next event on the queue if there is one. If there are no events
+	* this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct */
+	virtual bool PollNextEvent(VREvent_t *pEvent, uint32_t uncbVREvent) = 0;
+
+	/** Provides access to device poses for drivers.  Poses are in their "raw" tracking space which is uniquely
+	* defined by each driver providing poses for its devices.  It is up to clients of this function to correlate
+	* poses across different drivers.  Poses are indexed by their device id, and their associated driver and
+	* other properties can be looked up via IVRProperties. */
+	virtual void GetRawTrackedDevicePoses(float fPredictedSecondsFromNow, TrackedDevicePose_t *pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = 0;
+
+	/** Notifies the server that a tracked device's display component transforms have been updated. */
+	virtual void TrackedDeviceDisplayTransformUpdated(uint32_t unWhichDevice, HmdMatrix34_t eyeToHeadLeft, HmdMatrix34_t eyeToHeadRight) = 0;
+};
+
+static const char *IVRServerDriverHost_Version = "IVRServerDriverHost_004";
+
+}  // namespace vr
+
+// ivrhiddenarea.h
+namespace vr
+{
+class CVRHiddenAreaHelpers
+{
+public:
+	CVRHiddenAreaHelpers(IVRProperties *pProperties) : m_pProperties(pProperties) {}
+
+	/** Stores a hidden area mesh in a property */
+	ETrackedPropertyError SetHiddenArea(EVREye eEye, EHiddenAreaMeshType type, HmdVector2_t *pVerts, uint32_t unVertCount);
+
+	/** retrieves a hidden area mesh from a property. Returns the vert count read out of the property.  */
+	uint32_t GetHiddenArea(EVREye eEye, EHiddenAreaMeshType type, HmdVector2_t *pVerts, uint32_t unVertCount, ETrackedPropertyError *peError);
+
+private:
+	ETrackedDeviceProperty GetPropertyEnum(EVREye eEye, EHiddenAreaMeshType type)
+	{
+		return (ETrackedDeviceProperty)(Prop_DisplayHiddenArea_Binary_Start + ((int)type * 2) + (int)eEye);
+	}
+
+	IVRProperties *m_pProperties;
+};
+
+inline ETrackedPropertyError CVRHiddenAreaHelpers::SetHiddenArea(EVREye eEye, EHiddenAreaMeshType type, HmdVector2_t *pVerts, uint32_t unVertCount)
+{
+	ETrackedDeviceProperty prop = GetPropertyEnum(eEye, type);
+	CVRPropertyHelpers propHelpers(m_pProperties);
+	return propHelpers.SetProperty(propHelpers.TrackedDeviceToPropertyContainer(k_unTrackedDeviceIndex_Hmd), prop, pVerts, sizeof(HmdVector2_t) * unVertCount, k_unHiddenAreaPropertyTag);
+}
+
+inline uint32_t CVRHiddenAreaHelpers::GetHiddenArea(EVREye eEye, EHiddenAreaMeshType type, HmdVector2_t *pVerts, uint32_t unVertCount, ETrackedPropertyError *peError)
+{
+	ETrackedDeviceProperty prop = GetPropertyEnum(eEye, type);
+	CVRPropertyHelpers propHelpers(m_pProperties);
+	ETrackedPropertyError propError;
+	PropertyTypeTag_t unTag;
+	uint32_t unBytesNeeded = propHelpers.GetProperty(propHelpers.TrackedDeviceToPropertyContainer(k_unTrackedDeviceIndex_Hmd), prop, pVerts, sizeof(HmdVector2_t) * unVertCount, &unTag, &propError);
+	if (propError == TrackedProp_Success && unTag != k_unHiddenAreaPropertyTag)
+	{
+		propError = TrackedProp_WrongDataType;
+		unBytesNeeded = 0;
+	}
+
+	if (peError)
+	{
+		*peError = propError;
+	}
+
+	return unBytesNeeded / sizeof(HmdVector2_t);
+}
+
+}  // namespace vr
+// ivrwatchdoghost.h
+namespace vr
+{
+/** This interface is provided by vrclient to allow the driver to make everything wake up */
+class IVRWatchdogHost
+{
+public:
+	/** Client drivers in watchdog mode should call this when they have received a signal from hardware that should
+	* cause SteamVR to start */
+	virtual void WatchdogWakeUp() = 0;
+};
+
+static const char *IVRWatchdogHost_Version = "IVRWatchdogHost_001";
+
+};  // namespace vr
+
+// ivrvirtualdisplay.h
+namespace vr
+{
+// ----------------------------------------------------------------------------------------------
+// Purpose: This component is used for drivers that implement a virtual display (e.g. wireless).
+// ----------------------------------------------------------------------------------------------
+class IVRVirtualDisplay
+{
+public:
+	/** Submits final backbuffer for display. */
+	virtual void Present(vr::SharedTextureHandle_t backbufferTextureHandle) = 0;
+
+	/** Block until the last presented buffer start scanning out. */
+	virtual void WaitForPresent() = 0;
+
+	/** Provides timing data for synchronizing with display. */
+	virtual bool GetTimeSinceLastVsync(float *pfSecondsSinceLastVsync, uint64_t *pulFrameCounter) = 0;
+};
+
+static const char *IVRVirtualDisplay_Version = "IVRVirtualDisplay_001";
+
+/** Returns the current IVRVirtualDisplay pointer or NULL the interface could not be found. */
+VR_INTERFACE vr::IVRVirtualDisplay *VR_CALLTYPE VRVirtualDisplay();
+}  // namespace vr
+
+// ivrresources.h
+namespace vr
+{
+class IVRResources
+{
+public:
+	// ------------------------------------
+	// Shared Resource Methods
+	// ------------------------------------
+
+	/** Loads the specified resource into the provided buffer if large enough.
+	* Returns the size in bytes of the buffer required to hold the specified resource. */
+	virtual uint32_t LoadSharedResource(const char *pchResourceName, char *pchBuffer, uint32_t unBufferLen) = 0;
+
+	/** Provides the full path to the specified resource. Resource names can include named directories for
+	* drivers and other things, and this resolves all of those and returns the actual physical path. 
+	* pchResourceTypeDirectory is the subdirectory of resources to look in. */
+	virtual uint32_t GetResourceFullPath(const char *pchResourceName, const char *pchResourceTypeDirectory, char *pchPathBuffer, uint32_t unBufferLen) = 0;
+};
+
+static const char *const IVRResources_Version = "IVRResources_001";
+
+}  // namespace vr
+// ivrdrivermanager.h
+namespace vr
+{
+class IVRDriverManager
+{
+public:
+	virtual uint32_t GetDriverCount() const = 0;
+
+	/** Returns the length of the number of bytes necessary to hold this string including the trailing null. */
+	virtual uint32_t GetDriverName(vr::DriverId_t nDriver, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize) = 0;
+};
+
+static const char *const IVRDriverManager_Version = "IVRDriverManager_001";
+
+}  // namespace vr
+
+namespace vr
+{
+static const char *const k_InterfaceVersions[] =
+	{
+		IVRSettings_Version,
+		ITrackedDeviceServerDriver_Version,
+		IVRDisplayComponent_Version,
+		IVRDriverDirectModeComponent_Version,
+		IVRControllerComponent_Version,
+		IVRCameraComponent_Version,
+		IServerTrackedDeviceProvider_Version,
+		IVRWatchdogProvider_Version,
+		IVRVirtualDisplay_Version,
+		IVRDriverManager_Version,
+		IVRResources_Version,
+		nullptr};
+
+inline IVRDriverContext *&VRDriverContext()
+{
+	static IVRDriverContext *pHost;
+	return pHost;
+}
+
+class COpenVRDriverContext
+{
+public:
+	COpenVRDriverContext() : m_propertyHelpers(nullptr), m_hiddenAreaHelpers(nullptr) { Clear(); }
+	void Clear();
+
+	EVRInitError InitServer();
+	EVRInitError InitWatchdog();
+
+	IVRSettings *VRSettings()
+	{
+		if (m_pVRSettings == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRSettings = (IVRSettings *)VRDriverContext()->GetGenericInterface(IVRSettings_Version, &eError);
+		}
+		return m_pVRSettings;
+	}
+
+	IVRProperties *VRPropertiesRaw()
+	{
+		if (m_pVRProperties == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRProperties = (IVRProperties *)VRDriverContext()->GetGenericInterface(IVRProperties_Version, &eError);
+			m_propertyHelpers = CVRPropertyHelpers(m_pVRProperties);
+			m_hiddenAreaHelpers = CVRHiddenAreaHelpers(m_pVRProperties);
+		}
+		return m_pVRProperties;
+	}
+
+	CVRPropertyHelpers *VRProperties()
+	{
+		VRPropertiesRaw();
+		return &m_propertyHelpers;
+	}
+
+	CVRHiddenAreaHelpers *VRHiddenArea()
+	{
+		VRPropertiesRaw();
+		return &m_hiddenAreaHelpers;
+	}
+
+	IVRServerDriverHost *VRServerDriverHost()
+	{
+		if (m_pVRServerDriverHost == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRServerDriverHost = (IVRServerDriverHost *)VRDriverContext()->GetGenericInterface(IVRServerDriverHost_Version, &eError);
+		}
+		return m_pVRServerDriverHost;
+	}
+
+	IVRWatchdogHost *VRWatchdogHost()
+	{
+		if (m_pVRWatchdogHost == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRWatchdogHost = (IVRWatchdogHost *)VRDriverContext()->GetGenericInterface(IVRWatchdogHost_Version, &eError);
+		}
+		return m_pVRWatchdogHost;
+	}
+
+	IVRDriverLog *VRDriverLog()
+	{
+		if (m_pVRDriverLog == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRDriverLog = (IVRDriverLog *)VRDriverContext()->GetGenericInterface(IVRDriverLog_Version, &eError);
+		}
+		return m_pVRDriverLog;
+	}
+
+	DriverHandle_t VR_CALLTYPE VRDriverHandle()
+	{
+		return VRDriverContext()->GetDriverHandle();
+	}
+
+	IVRDriverManager *VRDriverManager()
+	{
+		if (!m_pVRDriverManager)
+		{
+			EVRInitError eError;
+			m_pVRDriverManager = (IVRDriverManager *)VRDriverContext()->GetGenericInterface(IVRDriverManager_Version, &eError);
+		}
+		return m_pVRDriverManager;
+	}
+
+	IVRResources *VRResources()
+	{
+		if (!m_pVRResources)
+		{
+			EVRInitError eError;
+			m_pVRResources = (IVRResources *)VRDriverContext()->GetGenericInterface(IVRResources_Version, &eError);
+		}
+		return m_pVRResources;
+	}
+
+private:
+	CVRPropertyHelpers m_propertyHelpers;
+	CVRHiddenAreaHelpers m_hiddenAreaHelpers;
+
+	IVRSettings *m_pVRSettings;
+	IVRProperties *m_pVRProperties;
+	IVRServerDriverHost *m_pVRServerDriverHost;
+	IVRWatchdogHost *m_pVRWatchdogHost;
+	IVRDriverLog *m_pVRDriverLog;
+	IVRDriverManager *m_pVRDriverManager;
+	IVRResources *m_pVRResources;
+};
+
+inline COpenVRDriverContext &OpenVRInternal_ModuleServerDriverContext()
+{
+	static void *ctx[sizeof(COpenVRDriverContext) / sizeof(void *)];
+	return *(COpenVRDriverContext *)ctx;  // bypass zero-init constructor
+}
+
+inline IVRSettings *VR_CALLTYPE VRSettings() { return OpenVRInternal_ModuleServerDriverContext().VRSettings(); }
+inline IVRProperties *VR_CALLTYPE VRPropertiesRaw() { return OpenVRInternal_ModuleServerDriverContext().VRPropertiesRaw(); }
+inline CVRPropertyHelpers *VR_CALLTYPE VRProperties() { return OpenVRInternal_ModuleServerDriverContext().VRProperties(); }
+inline CVRHiddenAreaHelpers *VR_CALLTYPE VRHiddenArea() { return OpenVRInternal_ModuleServerDriverContext().VRHiddenArea(); }
+inline IVRDriverLog *VR_CALLTYPE VRDriverLog() { return OpenVRInternal_ModuleServerDriverContext().VRDriverLog(); }
+inline IVRServerDriverHost *VR_CALLTYPE VRServerDriverHost() { return OpenVRInternal_ModuleServerDriverContext().VRServerDriverHost(); }
+inline IVRWatchdogHost *VR_CALLTYPE VRWatchdogHost() { return OpenVRInternal_ModuleServerDriverContext().VRWatchdogHost(); }
+inline DriverHandle_t VR_CALLTYPE VRDriverHandle() { return OpenVRInternal_ModuleServerDriverContext().VRDriverHandle(); }
+inline IVRDriverManager *VR_CALLTYPE VRDriverManager() { return OpenVRInternal_ModuleServerDriverContext().VRDriverManager(); }
+inline IVRResources *VR_CALLTYPE VRResources() { return OpenVRInternal_ModuleServerDriverContext().VRResources(); }
+
+inline void COpenVRDriverContext::Clear()
+{
+	m_pVRSettings = nullptr;
+	m_pVRProperties = nullptr;
+	m_pVRServerDriverHost = nullptr;
+	m_pVRDriverLog = nullptr;
+	m_pVRWatchdogHost = nullptr;
+	m_pVRDriverManager = nullptr;
+	m_pVRResources = nullptr;
+}
+
+inline EVRInitError COpenVRDriverContext::InitServer()
+{
+	Clear();
+	if (!VRServerDriverHost() || !VRSettings() || !VRProperties() || !VRDriverLog() || !VRDriverManager() || !VRResources())
+		return VRInitError_Init_InterfaceNotFound;
+	return VRInitError_None;
+}
+
+inline EVRInitError COpenVRDriverContext::InitWatchdog()
+{
+	Clear();
+	if (!VRWatchdogHost() || !VRSettings() || !VRDriverLog())
+		return VRInitError_Init_InterfaceNotFound;
+	return VRInitError_None;
+}
+
+inline EVRInitError InitServerDriverContext(IVRDriverContext *pContext)
+{
+	VRDriverContext() = pContext;
+	return OpenVRInternal_ModuleServerDriverContext().InitServer();
+}
+
+inline EVRInitError InitWatchdogDriverContext(IVRDriverContext *pContext)
+{
+	VRDriverContext() = pContext;
+	return OpenVRInternal_ModuleServerDriverContext().InitWatchdog();
+}
+
+inline void CleanupDriverContext()
+{
+	VRDriverContext() = nullptr;
+	OpenVRInternal_ModuleServerDriverContext().Clear();
+}
+
+#define VR_INIT_SERVER_DRIVER_CONTEXT(pContext)                          \
+	{                                                                    \
+		vr::EVRInitError eError = vr::InitServerDriverContext(pContext); \
+		if (eError != vr::VRInitError_None)                              \
+			return eError;                                               \
+	}
+
+#define VR_CLEANUP_SERVER_DRIVER_CONTEXT() \
+	vr::CleanupDriverContext();
+
+#define VR_INIT_WATCHDOG_DRIVER_CONTEXT(pContext)                          \
+	{                                                                      \
+		vr::EVRInitError eError = vr::InitWatchdogDriverContext(pContext); \
+		if (eError != vr::VRInitError_None)                                \
+			return eError;                                                 \
+	}
+
+#define VR_CLEANUP_WATCHDOG_DRIVER_CONTEXT() \
+	vr::CleanupDriverContext();
+}  // namespace vr
+// End
+
+#endif  // _OPENVR_DRIVER_API
diff --git a/engine/inc/bullet/ThirdPartyLibs/openvr/bin/osx64/OpenVR.framework/Versions/Current/Headers/openvr.h b/engine/inc/bullet/ThirdPartyLibs/openvr/bin/osx64/OpenVR.framework/Versions/Current/Headers/openvr.h
new file mode 100644
index 00000000..80461f96
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/openvr/bin/osx64/OpenVR.framework/Versions/Current/Headers/openvr.h
@@ -0,0 +1,3698 @@
+#pragma once
+
+// openvr.h
+//========= Copyright Valve Corporation ============//
+// Dynamically generated file. Do not modify this file directly.
+
+#ifndef _OPENVR_API
+#define _OPENVR_API
+
+#include <stdint.h>
+
+// vrtypes.h
+#ifndef _INCLUDE_VRTYPES_H
+#define _INCLUDE_VRTYPES_H
+
+// Forward declarations to avoid requiring vulkan.h
+struct VkDevice_T;
+struct VkPhysicalDevice_T;
+struct VkInstance_T;
+struct VkQueue_T;
+
+// Forward declarations to avoid requiring d3d12.h
+struct ID3D12Resource;
+struct ID3D12CommandQueue;
+
+namespace vr
+{
+#pragma pack(push, 8)
+
+typedef void *glSharedTextureHandle_t;
+typedef int32_t glInt_t;
+typedef uint32_t glUInt_t;
+
+// right-handed system
+// +y is up
+// +x is to the right
+// -z is going away from you
+// Distance unit is  meters
+struct HmdMatrix34_t
+{
+	float m[3][4];
+};
+
+struct HmdMatrix44_t
+{
+	float m[4][4];
+};
+
+struct HmdVector3_t
+{
+	float v[3];
+};
+
+struct HmdVector4_t
+{
+	float v[4];
+};
+
+struct HmdVector3d_t
+{
+	double v[3];
+};
+
+struct HmdVector2_t
+{
+	float v[2];
+};
+
+struct HmdQuaternion_t
+{
+	double w, x, y, z;
+};
+
+struct HmdColor_t
+{
+	float r, g, b, a;
+};
+
+struct HmdQuad_t
+{
+	HmdVector3_t vCorners[4];
+};
+
+struct HmdRect2_t
+{
+	HmdVector2_t vTopLeft;
+	HmdVector2_t vBottomRight;
+};
+
+/** Used to return the post-distortion UVs for each color channel. 
+* UVs range from 0 to 1 with 0,0 in the upper left corner of the 
+* source render target. The 0,0 to 1,1 range covers a single eye. */
+struct DistortionCoordinates_t
+{
+	float rfRed[2];
+	float rfGreen[2];
+	float rfBlue[2];
+};
+
+enum EVREye
+{
+	Eye_Left = 0,
+	Eye_Right = 1
+};
+
+enum ETextureType
+{
+	TextureType_DirectX = 0,    // Handle is an ID3D11Texture
+	TextureType_OpenGL = 1,     // Handle is an OpenGL texture name or an OpenGL render buffer name, depending on submit flags
+	TextureType_Vulkan = 2,     // Handle is a pointer to a VRVulkanTextureData_t structure
+	TextureType_IOSurface = 3,  // Handle is a macOS cross-process-sharable IOSurfaceRef
+	TextureType_DirectX12 = 4,  // Handle is a pointer to a D3D12TextureData_t structure
+};
+
+enum EColorSpace
+{
+	ColorSpace_Auto = 0,    // Assumes 'gamma' for 8-bit per component formats, otherwise 'linear'.  This mirrors the DXGI formats which have _SRGB variants.
+	ColorSpace_Gamma = 1,   // Texture data can be displayed directly on the display without any conversion (a.k.a. display native format).
+	ColorSpace_Linear = 2,  // Same as gamma but has been converted to a linear representation using DXGI's sRGB conversion algorithm.
+};
+
+struct Texture_t
+{
+	void *handle;  // See ETextureType definition above
+	ETextureType eType;
+	EColorSpace eColorSpace;
+};
+
+// Handle to a shared texture (HANDLE on Windows obtained using OpenSharedResource).
+typedef uint64_t SharedTextureHandle_t;
+#define INVALID_SHARED_TEXTURE_HANDLE ((vr::SharedTextureHandle_t)0)
+
+enum ETrackingResult
+{
+	TrackingResult_Uninitialized = 1,
+
+	TrackingResult_Calibrating_InProgress = 100,
+	TrackingResult_Calibrating_OutOfRange = 101,
+
+	TrackingResult_Running_OK = 200,
+	TrackingResult_Running_OutOfRange = 201,
+};
+
+typedef uint32_t DriverId_t;
+static const uint32_t k_nDriverNone = 0xFFFFFFFF;
+
+static const uint32_t k_unMaxDriverDebugResponseSize = 32768;
+
+/** Used to pass device IDs to API calls */
+typedef uint32_t TrackedDeviceIndex_t;
+static const uint32_t k_unTrackedDeviceIndex_Hmd = 0;
+static const uint32_t k_unMaxTrackedDeviceCount = 16;
+static const uint32_t k_unTrackedDeviceIndexOther = 0xFFFFFFFE;
+static const uint32_t k_unTrackedDeviceIndexInvalid = 0xFFFFFFFF;
+
+/** Describes what kind of object is being tracked at a given ID */
+enum ETrackedDeviceClass
+{
+	TrackedDeviceClass_Invalid = 0,            // the ID was not valid.
+	TrackedDeviceClass_HMD = 1,                // Head-Mounted Displays
+	TrackedDeviceClass_Controller = 2,         // Tracked controllers
+	TrackedDeviceClass_GenericTracker = 3,     // Generic trackers, similar to controllers
+	TrackedDeviceClass_TrackingReference = 4,  // Camera and base stations that serve as tracking reference points
+	TrackedDeviceClass_DisplayRedirect = 5,    // Accessories that aren't necessarily tracked themselves, but may redirect video output from other tracked devices
+};
+
+/** Describes what specific role associated with a tracked device */
+enum ETrackedControllerRole
+{
+	TrackedControllerRole_Invalid = 0,    // Invalid value for controller type
+	TrackedControllerRole_LeftHand = 1,   // Tracked device associated with the left hand
+	TrackedControllerRole_RightHand = 2,  // Tracked device associated with the right hand
+};
+
+/** describes a single pose for a tracked object */
+struct TrackedDevicePose_t
+{
+	HmdMatrix34_t mDeviceToAbsoluteTracking;
+	HmdVector3_t vVelocity;         // velocity in tracker space in m/s
+	HmdVector3_t vAngularVelocity;  // angular velocity in radians/s (?)
+	ETrackingResult eTrackingResult;
+	bool bPoseIsValid;
+
+	// This indicates that there is a device connected for this spot in the pose array.
+	// It could go from true to false if the user unplugs the device.
+	bool bDeviceIsConnected;
+};
+
+/** Identifies which style of tracking origin the application wants to use
+* for the poses it is requesting */
+enum ETrackingUniverseOrigin
+{
+	TrackingUniverseSeated = 0,              // Poses are provided relative to the seated zero pose
+	TrackingUniverseStanding = 1,            // Poses are provided relative to the safe bounds configured by the user
+	TrackingUniverseRawAndUncalibrated = 2,  // Poses are provided in the coordinate system defined by the driver.  It has Y up and is unified for devices of the same driver. You usually don't want this one.
+};
+
+// Refers to a single container of properties
+typedef uint64_t PropertyContainerHandle_t;
+typedef uint32_t PropertyTypeTag_t;
+
+static const PropertyContainerHandle_t k_ulInvalidPropertyContainer = 0;
+static const PropertyTypeTag_t k_unInvalidPropertyTag = 0;
+
+// Use these tags to set/get common types as struct properties
+static const PropertyTypeTag_t k_unFloatPropertyTag = 1;
+static const PropertyTypeTag_t k_unInt32PropertyTag = 2;
+static const PropertyTypeTag_t k_unUint64PropertyTag = 3;
+static const PropertyTypeTag_t k_unBoolPropertyTag = 4;
+static const PropertyTypeTag_t k_unStringPropertyTag = 5;
+
+static const PropertyTypeTag_t k_unHmdMatrix34PropertyTag = 20;
+static const PropertyTypeTag_t k_unHmdMatrix44PropertyTag = 21;
+static const PropertyTypeTag_t k_unHmdVector3PropertyTag = 22;
+static const PropertyTypeTag_t k_unHmdVector4PropertyTag = 23;
+
+static const PropertyTypeTag_t k_unHiddenAreaPropertyTag = 30;
+
+static const PropertyTypeTag_t k_unOpenVRInternalReserved_Start = 1000;
+static const PropertyTypeTag_t k_unOpenVRInternalReserved_End = 10000;
+
+/** Each entry in this enum represents a property that can be retrieved about a
+* tracked device. Many fields are only valid for one ETrackedDeviceClass. */
+enum ETrackedDeviceProperty
+{
+	Prop_Invalid = 0,
+
+	// general properties that apply to all device classes
+	Prop_TrackingSystemName_String = 1000,
+	Prop_ModelNumber_String = 1001,
+	Prop_SerialNumber_String = 1002,
+	Prop_RenderModelName_String = 1003,
+	Prop_WillDriftInYaw_Bool = 1004,
+	Prop_ManufacturerName_String = 1005,
+	Prop_TrackingFirmwareVersion_String = 1006,
+	Prop_HardwareRevision_String = 1007,
+	Prop_AllWirelessDongleDescriptions_String = 1008,
+	Prop_ConnectedWirelessDongle_String = 1009,
+	Prop_DeviceIsWireless_Bool = 1010,
+	Prop_DeviceIsCharging_Bool = 1011,
+	Prop_DeviceBatteryPercentage_Float = 1012,  // 0 is empty, 1 is full
+	Prop_StatusDisplayTransform_Matrix34 = 1013,
+	Prop_Firmware_UpdateAvailable_Bool = 1014,
+	Prop_Firmware_ManualUpdate_Bool = 1015,
+	Prop_Firmware_ManualUpdateURL_String = 1016,
+	Prop_HardwareRevision_Uint64 = 1017,
+	Prop_FirmwareVersion_Uint64 = 1018,
+	Prop_FPGAVersion_Uint64 = 1019,
+	Prop_VRCVersion_Uint64 = 1020,
+	Prop_RadioVersion_Uint64 = 1021,
+	Prop_DongleVersion_Uint64 = 1022,
+	Prop_BlockServerShutdown_Bool = 1023,
+	Prop_CanUnifyCoordinateSystemWithHmd_Bool = 1024,
+	Prop_ContainsProximitySensor_Bool = 1025,
+	Prop_DeviceProvidesBatteryStatus_Bool = 1026,
+	Prop_DeviceCanPowerOff_Bool = 1027,
+	Prop_Firmware_ProgrammingTarget_String = 1028,
+	Prop_DeviceClass_Int32 = 1029,
+	Prop_HasCamera_Bool = 1030,
+	Prop_DriverVersion_String = 1031,
+	Prop_Firmware_ForceUpdateRequired_Bool = 1032,
+	Prop_ViveSystemButtonFixRequired_Bool = 1033,
+	Prop_ParentDriver_Uint64 = 1034,
+	Prop_ResourceRoot_String = 1035,
+
+	// Properties that are unique to TrackedDeviceClass_HMD
+	Prop_ReportsTimeSinceVSync_Bool = 2000,
+	Prop_SecondsFromVsyncToPhotons_Float = 2001,
+	Prop_DisplayFrequency_Float = 2002,
+	Prop_UserIpdMeters_Float = 2003,
+	Prop_CurrentUniverseId_Uint64 = 2004,
+	Prop_PreviousUniverseId_Uint64 = 2005,
+	Prop_DisplayFirmwareVersion_Uint64 = 2006,
+	Prop_IsOnDesktop_Bool = 2007,
+	Prop_DisplayMCType_Int32 = 2008,
+	Prop_DisplayMCOffset_Float = 2009,
+	Prop_DisplayMCScale_Float = 2010,
+	Prop_EdidVendorID_Int32 = 2011,
+	Prop_DisplayMCImageLeft_String = 2012,
+	Prop_DisplayMCImageRight_String = 2013,
+	Prop_DisplayGCBlackClamp_Float = 2014,
+	Prop_EdidProductID_Int32 = 2015,
+	Prop_CameraToHeadTransform_Matrix34 = 2016,
+	Prop_DisplayGCType_Int32 = 2017,
+	Prop_DisplayGCOffset_Float = 2018,
+	Prop_DisplayGCScale_Float = 2019,
+	Prop_DisplayGCPrescale_Float = 2020,
+	Prop_DisplayGCImage_String = 2021,
+	Prop_LensCenterLeftU_Float = 2022,
+	Prop_LensCenterLeftV_Float = 2023,
+	Prop_LensCenterRightU_Float = 2024,
+	Prop_LensCenterRightV_Float = 2025,
+	Prop_UserHeadToEyeDepthMeters_Float = 2026,
+	Prop_CameraFirmwareVersion_Uint64 = 2027,
+	Prop_CameraFirmwareDescription_String = 2028,
+	Prop_DisplayFPGAVersion_Uint64 = 2029,
+	Prop_DisplayBootloaderVersion_Uint64 = 2030,
+	Prop_DisplayHardwareVersion_Uint64 = 2031,
+	Prop_AudioFirmwareVersion_Uint64 = 2032,
+	Prop_CameraCompatibilityMode_Int32 = 2033,
+	Prop_ScreenshotHorizontalFieldOfViewDegrees_Float = 2034,
+	Prop_ScreenshotVerticalFieldOfViewDegrees_Float = 2035,
+	Prop_DisplaySuppressed_Bool = 2036,
+	Prop_DisplayAllowNightMode_Bool = 2037,
+	Prop_DisplayMCImageWidth_Int32 = 2038,
+	Prop_DisplayMCImageHeight_Int32 = 2039,
+	Prop_DisplayMCImageNumChannels_Int32 = 2040,
+	Prop_DisplayMCImageData_Binary = 2041,
+	Prop_SecondsFromPhotonsToVblank_Float = 2042,
+	Prop_DriverDirectModeSendsVsyncEvents_Bool = 2043,
+	Prop_DisplayDebugMode_Bool = 2044,
+	Prop_GraphicsAdapterLuid_Uint64 = 2045,
+	Prop_DriverProvidedChaperonePath_String = 2048,
+
+	// Properties that are unique to TrackedDeviceClass_Controller
+	Prop_AttachedDeviceId_String = 3000,
+	Prop_SupportedButtons_Uint64 = 3001,
+	Prop_Axis0Type_Int32 = 3002,           // Return value is of type EVRControllerAxisType
+	Prop_Axis1Type_Int32 = 3003,           // Return value is of type EVRControllerAxisType
+	Prop_Axis2Type_Int32 = 3004,           // Return value is of type EVRControllerAxisType
+	Prop_Axis3Type_Int32 = 3005,           // Return value is of type EVRControllerAxisType
+	Prop_Axis4Type_Int32 = 3006,           // Return value is of type EVRControllerAxisType
+	Prop_ControllerRoleHint_Int32 = 3007,  // Return value is of type ETrackedControllerRole
+
+	// Properties that are unique to TrackedDeviceClass_TrackingReference
+	Prop_FieldOfViewLeftDegrees_Float = 4000,
+	Prop_FieldOfViewRightDegrees_Float = 4001,
+	Prop_FieldOfViewTopDegrees_Float = 4002,
+	Prop_FieldOfViewBottomDegrees_Float = 4003,
+	Prop_TrackingRangeMinimumMeters_Float = 4004,
+	Prop_TrackingRangeMaximumMeters_Float = 4005,
+	Prop_ModeLabel_String = 4006,
+
+	// Properties that are used for user interface like icons names
+	Prop_IconPathName_String = 5000,                       // DEPRECATED. Value not referenced. Now expected to be part of icon path properties.
+	Prop_NamedIconPathDeviceOff_String = 5001,             // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceSearching_String = 5002,       // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceSearchingAlert_String = 5003,  // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceReady_String = 5004,           // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceReadyAlert_String = 5005,      // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceNotReady_String = 5006,        // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceStandby_String = 5007,         // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceAlertLow_String = 5008,        // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+
+	// Properties that are used by helpers, but are opaque to applications
+	Prop_DisplayHiddenArea_Binary_Start = 5100,
+	Prop_DisplayHiddenArea_Binary_End = 5150,
+
+	// Properties that are unique to drivers
+	Prop_UserConfigPath_String = 6000,
+	Prop_InstallPath_String = 6001,
+	Prop_HasDisplayComponent_Bool = 6002,
+	Prop_HasControllerComponent_Bool = 6003,
+	Prop_HasCameraComponent_Bool = 6004,
+	Prop_HasDriverDirectModeComponent_Bool = 6005,
+	Prop_HasVirtualDisplayComponent_Bool = 6006,
+
+	// Vendors are free to expose private debug data in this reserved region
+	Prop_VendorSpecific_Reserved_Start = 10000,
+	Prop_VendorSpecific_Reserved_End = 10999,
+};
+
+/** No string property will ever be longer than this length */
+static const uint32_t k_unMaxPropertyStringSize = 32 * 1024;
+
+/** Used to return errors that occur when reading properties. */
+enum ETrackedPropertyError
+{
+	TrackedProp_Success = 0,
+	TrackedProp_WrongDataType = 1,
+	TrackedProp_WrongDeviceClass = 2,
+	TrackedProp_BufferTooSmall = 3,
+	TrackedProp_UnknownProperty = 4,  // Driver has not set the property (and may not ever).
+	TrackedProp_InvalidDevice = 5,
+	TrackedProp_CouldNotContactServer = 6,
+	TrackedProp_ValueNotProvidedByDevice = 7,
+	TrackedProp_StringExceedsMaximumLength = 8,
+	TrackedProp_NotYetAvailable = 9,  // The property value isn't known yet, but is expected soon. Call again later.
+	TrackedProp_PermissionDenied = 10,
+	TrackedProp_InvalidOperation = 11,
+};
+
+/** Allows the application to control what part of the provided texture will be used in the
+* frame buffer. */
+struct VRTextureBounds_t
+{
+	float uMin, vMin;
+	float uMax, vMax;
+};
+
+/** Allows specifying pose used to render provided scene texture (if different from value returned by WaitGetPoses). */
+struct VRTextureWithPose_t : public Texture_t
+{
+	HmdMatrix34_t mDeviceToAbsoluteTracking;  // Actual pose used to render scene textures.
+};
+
+/** Allows the application to control how scene textures are used by the compositor when calling Submit. */
+enum EVRSubmitFlags
+{
+	// Simple render path. App submits rendered left and right eye images with no lens distortion correction applied.
+	Submit_Default = 0x00,
+
+	// App submits final left and right eye images with lens distortion already applied (lens distortion makes the images appear
+	// barrel distorted with chromatic aberration correction applied). The app would have used the data returned by
+	// vr::IVRSystem::ComputeDistortion() to apply the correct distortion to the rendered images before calling Submit().
+	Submit_LensDistortionAlreadyApplied = 0x01,
+
+	// If the texture pointer passed in is actually a renderbuffer (e.g. for MSAA in OpenGL) then set this flag.
+	Submit_GlRenderBuffer = 0x02,
+
+	// Do not use
+	Submit_Reserved = 0x04,
+
+	// Set to indicate that pTexture is a pointer to a VRTextureWithPose_t.
+	Submit_TextureWithPose = 0x08,
+};
+
+/** Data required for passing Vulkan textures to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. */
+struct VRVulkanTextureData_t
+{
+	uint64_t m_nImage;  // VkImage
+	VkDevice_T *m_pDevice;
+	VkPhysicalDevice_T *m_pPhysicalDevice;
+	VkInstance_T *m_pInstance;
+	VkQueue_T *m_pQueue;
+	uint32_t m_nQueueFamilyIndex;
+	uint32_t m_nWidth, m_nHeight, m_nFormat, m_nSampleCount;
+};
+
+/** Data required for passing D3D12 textures to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. */
+struct D3D12TextureData_t
+{
+	ID3D12Resource *m_pResource;
+	ID3D12CommandQueue *m_pCommandQueue;
+	uint32_t m_nNodeMask;
+};
+
+/** Status of the overall system or tracked objects */
+enum EVRState
+{
+	VRState_Undefined = -1,
+	VRState_Off = 0,
+	VRState_Searching = 1,
+	VRState_Searching_Alert = 2,
+	VRState_Ready = 3,
+	VRState_Ready_Alert = 4,
+	VRState_NotReady = 5,
+	VRState_Standby = 6,
+	VRState_Ready_Alert_Low = 7,
+};
+
+/** The types of events that could be posted (and what the parameters mean for each event type) */
+enum EVREventType
+{
+	VREvent_None = 0,
+
+	VREvent_TrackedDeviceActivated = 100,
+	VREvent_TrackedDeviceDeactivated = 101,
+	VREvent_TrackedDeviceUpdated = 102,
+	VREvent_TrackedDeviceUserInteractionStarted = 103,
+	VREvent_TrackedDeviceUserInteractionEnded = 104,
+	VREvent_IpdChanged = 105,
+	VREvent_EnterStandbyMode = 106,
+	VREvent_LeaveStandbyMode = 107,
+	VREvent_TrackedDeviceRoleChanged = 108,
+	VREvent_WatchdogWakeUpRequested = 109,
+	VREvent_LensDistortionChanged = 110,
+	VREvent_PropertyChanged = 111,
+	VREvent_WirelessDisconnect = 112,
+	VREvent_WirelessReconnect = 113,
+
+	VREvent_ButtonPress = 200,    // data is controller
+	VREvent_ButtonUnpress = 201,  // data is controller
+	VREvent_ButtonTouch = 202,    // data is controller
+	VREvent_ButtonUntouch = 203,  // data is controller
+
+	VREvent_MouseMove = 300,            // data is mouse
+	VREvent_MouseButtonDown = 301,      // data is mouse
+	VREvent_MouseButtonUp = 302,        // data is mouse
+	VREvent_FocusEnter = 303,           // data is overlay
+	VREvent_FocusLeave = 304,           // data is overlay
+	VREvent_Scroll = 305,               // data is mouse
+	VREvent_TouchPadMove = 306,         // data is mouse
+	VREvent_OverlayFocusChanged = 307,  // data is overlay, global event
+
+	VREvent_InputFocusCaptured = 400,                         // data is process DEPRECATED
+	VREvent_InputFocusReleased = 401,                         // data is process DEPRECATED
+	VREvent_SceneFocusLost = 402,                             // data is process
+	VREvent_SceneFocusGained = 403,                           // data is process
+	VREvent_SceneApplicationChanged = 404,                    // data is process - The App actually drawing the scene changed (usually to or from the compositor)
+	VREvent_SceneFocusChanged = 405,                          // data is process - New app got access to draw the scene
+	VREvent_InputFocusChanged = 406,                          // data is process
+	VREvent_SceneApplicationSecondaryRenderingStarted = 407,  // data is process
+
+	VREvent_HideRenderModels = 410,  // Sent to the scene application to request hiding render models temporarily
+	VREvent_ShowRenderModels = 411,  // Sent to the scene application to request restoring render model visibility
+
+	VREvent_OverlayShown = 500,
+	VREvent_OverlayHidden = 501,
+	VREvent_DashboardActivated = 502,
+	VREvent_DashboardDeactivated = 503,
+	VREvent_DashboardThumbSelected = 504,     // Sent to the overlay manager - data is overlay
+	VREvent_DashboardRequested = 505,         // Sent to the overlay manager - data is overlay
+	VREvent_ResetDashboard = 506,             // Send to the overlay manager
+	VREvent_RenderToast = 507,                // Send to the dashboard to render a toast - data is the notification ID
+	VREvent_ImageLoaded = 508,                // Sent to overlays when a SetOverlayRaw or SetOverlayFromFile call finishes loading
+	VREvent_ShowKeyboard = 509,               // Sent to keyboard renderer in the dashboard to invoke it
+	VREvent_HideKeyboard = 510,               // Sent to keyboard renderer in the dashboard to hide it
+	VREvent_OverlayGamepadFocusGained = 511,  // Sent to an overlay when IVROverlay::SetFocusOverlay is called on it
+	VREvent_OverlayGamepadFocusLost = 512,    // Send to an overlay when it previously had focus and IVROverlay::SetFocusOverlay is called on something else
+	VREvent_OverlaySharedTextureChanged = 513,
+	VREvent_DashboardGuideButtonDown = 514,
+	VREvent_DashboardGuideButtonUp = 515,
+	VREvent_ScreenshotTriggered = 516,  // Screenshot button combo was pressed, Dashboard should request a screenshot
+	VREvent_ImageFailed = 517,          // Sent to overlays when a SetOverlayRaw or SetOverlayfromFail fails to load
+	VREvent_DashboardOverlayCreated = 518,
+
+	// Screenshot API
+	VREvent_RequestScreenshot = 520,              // Sent by vrclient application to compositor to take a screenshot
+	VREvent_ScreenshotTaken = 521,                // Sent by compositor to the application that the screenshot has been taken
+	VREvent_ScreenshotFailed = 522,               // Sent by compositor to the application that the screenshot failed to be taken
+	VREvent_SubmitScreenshotToDashboard = 523,    // Sent by compositor to the dashboard that a completed screenshot was submitted
+	VREvent_ScreenshotProgressToDashboard = 524,  // Sent by compositor to the dashboard that a completed screenshot was submitted
+
+	VREvent_PrimaryDashboardDeviceChanged = 525,
+
+	VREvent_Notification_Shown = 600,
+	VREvent_Notification_Hidden = 601,
+	VREvent_Notification_BeginInteraction = 602,
+	VREvent_Notification_Destroyed = 603,
+
+	VREvent_Quit = 700,                    // data is process
+	VREvent_ProcessQuit = 701,             // data is process
+	VREvent_QuitAborted_UserPrompt = 702,  // data is process
+	VREvent_QuitAcknowledged = 703,        // data is process
+	VREvent_DriverRequestedQuit = 704,     // The driver has requested that SteamVR shut down
+
+	VREvent_ChaperoneDataHasChanged = 800,
+	VREvent_ChaperoneUniverseHasChanged = 801,
+	VREvent_ChaperoneTempDataHasChanged = 802,
+	VREvent_ChaperoneSettingsHaveChanged = 803,
+	VREvent_SeatedZeroPoseReset = 804,
+
+	VREvent_AudioSettingsHaveChanged = 820,
+
+	VREvent_BackgroundSettingHasChanged = 850,
+	VREvent_CameraSettingsHaveChanged = 851,
+	VREvent_ReprojectionSettingHasChanged = 852,
+	VREvent_ModelSkinSettingsHaveChanged = 853,
+	VREvent_EnvironmentSettingsHaveChanged = 854,
+	VREvent_PowerSettingsHaveChanged = 855,
+	VREvent_EnableHomeAppSettingsHaveChanged = 856,
+
+	VREvent_StatusUpdate = 900,
+
+	VREvent_MCImageUpdated = 1000,
+
+	VREvent_FirmwareUpdateStarted = 1100,
+	VREvent_FirmwareUpdateFinished = 1101,
+
+	VREvent_KeyboardClosed = 1200,
+	VREvent_KeyboardCharInput = 1201,
+	VREvent_KeyboardDone = 1202,  // Sent when DONE button clicked on keyboard
+
+	VREvent_ApplicationTransitionStarted = 1300,
+	VREvent_ApplicationTransitionAborted = 1301,
+	VREvent_ApplicationTransitionNewAppStarted = 1302,
+	VREvent_ApplicationListUpdated = 1303,
+	VREvent_ApplicationMimeTypeLoad = 1304,
+	VREvent_ApplicationTransitionNewAppLaunchComplete = 1305,
+	VREvent_ProcessConnected = 1306,
+	VREvent_ProcessDisconnected = 1307,
+
+	VREvent_Compositor_MirrorWindowShown = 1400,
+	VREvent_Compositor_MirrorWindowHidden = 1401,
+	VREvent_Compositor_ChaperoneBoundsShown = 1410,
+	VREvent_Compositor_ChaperoneBoundsHidden = 1411,
+
+	VREvent_TrackedCamera_StartVideoStream = 1500,
+	VREvent_TrackedCamera_StopVideoStream = 1501,
+	VREvent_TrackedCamera_PauseVideoStream = 1502,
+	VREvent_TrackedCamera_ResumeVideoStream = 1503,
+	VREvent_TrackedCamera_EditingSurface = 1550,
+
+	VREvent_PerformanceTest_EnableCapture = 1600,
+	VREvent_PerformanceTest_DisableCapture = 1601,
+	VREvent_PerformanceTest_FidelityLevel = 1602,
+
+	VREvent_MessageOverlay_Closed = 1650,
+	VREvent_MessageOverlayCloseRequested = 1651,
+
+	// Vendors are free to expose private events in this reserved region
+	VREvent_VendorSpecific_Reserved_Start = 10000,
+	VREvent_VendorSpecific_Reserved_End = 19999,
+};
+
+/** Level of Hmd activity */
+// UserInteraction_Timeout means the device is in the process of timing out.
+// InUse = ( k_EDeviceActivityLevel_UserInteraction || k_EDeviceActivityLevel_UserInteraction_Timeout )
+// VREvent_TrackedDeviceUserInteractionStarted fires when the devices transitions from Standby -> UserInteraction or Idle -> UserInteraction.
+// VREvent_TrackedDeviceUserInteractionEnded fires when the devices transitions from UserInteraction_Timeout -> Idle
+enum EDeviceActivityLevel
+{
+	k_EDeviceActivityLevel_Unknown = -1,
+	k_EDeviceActivityLevel_Idle = 0,                     // No activity for the last 10 seconds
+	k_EDeviceActivityLevel_UserInteraction = 1,          // Activity (movement or prox sensor) is happening now
+	k_EDeviceActivityLevel_UserInteraction_Timeout = 2,  // No activity for the last 0.5 seconds
+	k_EDeviceActivityLevel_Standby = 3,                  // Idle for at least 5 seconds (configurable in Settings -> Power Management)
+};
+
+/** VR controller button and axis IDs */
+enum EVRButtonId
+{
+	k_EButton_System = 0,
+	k_EButton_ApplicationMenu = 1,
+	k_EButton_Grip = 2,
+	k_EButton_DPad_Left = 3,
+	k_EButton_DPad_Up = 4,
+	k_EButton_DPad_Right = 5,
+	k_EButton_DPad_Down = 6,
+	k_EButton_A = 7,
+
+	k_EButton_ProximitySensor = 31,
+
+	k_EButton_Axis0 = 32,
+	k_EButton_Axis1 = 33,
+	k_EButton_Axis2 = 34,
+	k_EButton_Axis3 = 35,
+	k_EButton_Axis4 = 36,
+
+	// aliases for well known controllers
+	k_EButton_SteamVR_Touchpad = k_EButton_Axis0,
+	k_EButton_SteamVR_Trigger = k_EButton_Axis1,
+
+	k_EButton_Dashboard_Back = k_EButton_Grip,
+
+	k_EButton_Max = 64
+};
+
+inline uint64_t ButtonMaskFromId(EVRButtonId id) { return 1ull << id; }
+
+/** used for controller button events */
+struct VREvent_Controller_t
+{
+	uint32_t button;  // EVRButtonId enum
+};
+
+/** used for simulated mouse events in overlay space */
+enum EVRMouseButton
+{
+	VRMouseButton_Left = 0x0001,
+	VRMouseButton_Right = 0x0002,
+	VRMouseButton_Middle = 0x0004,
+};
+
+/** used for simulated mouse events in overlay space */
+struct VREvent_Mouse_t
+{
+	float x, y;       // co-ords are in GL space, bottom left of the texture is 0,0
+	uint32_t button;  // EVRMouseButton enum
+};
+
+/** used for simulated mouse wheel scroll in overlay space */
+struct VREvent_Scroll_t
+{
+	float xdelta, ydelta;  // movement in fraction of the pad traversed since last delta, 1.0 for a full swipe
+	uint32_t repeatCount;
+};
+
+/** when in mouse input mode you can receive data from the touchpad, these events are only sent if the users finger
+   is on the touchpad (or just released from it) 
+**/
+struct VREvent_TouchPadMove_t
+{
+	// true if the users finger is detected on the touch pad
+	bool bFingerDown;
+
+	// How long the finger has been down in seconds
+	float flSecondsFingerDown;
+
+	// These values indicate the starting finger position (so you can do some basic swipe stuff)
+	float fValueXFirst;
+	float fValueYFirst;
+
+	// This is the raw sampled coordinate without deadzoning
+	float fValueXRaw;
+	float fValueYRaw;
+};
+
+/** notification related events. Details will still change at this point */
+struct VREvent_Notification_t
+{
+	uint64_t ulUserValue;
+	uint32_t notificationId;
+};
+
+/** Used for events about processes */
+struct VREvent_Process_t
+{
+	uint32_t pid;
+	uint32_t oldPid;
+	bool bForced;
+};
+
+/** Used for a few events about overlays */
+struct VREvent_Overlay_t
+{
+	uint64_t overlayHandle;
+};
+
+/** Used for a few events about overlays */
+struct VREvent_Status_t
+{
+	uint32_t statusState;  // EVRState enum
+};
+
+/** Used for keyboard events **/
+struct VREvent_Keyboard_t
+{
+	char cNewInput[8];    // Up to 11 bytes of new input
+	uint64_t uUserValue;  // Possible flags about the new input
+};
+
+struct VREvent_Ipd_t
+{
+	float ipdMeters;
+};
+
+struct VREvent_Chaperone_t
+{
+	uint64_t m_nPreviousUniverse;
+	uint64_t m_nCurrentUniverse;
+};
+
+/** Not actually used for any events */
+struct VREvent_Reserved_t
+{
+	uint64_t reserved0;
+	uint64_t reserved1;
+};
+
+struct VREvent_PerformanceTest_t
+{
+	uint32_t m_nFidelityLevel;
+};
+
+struct VREvent_SeatedZeroPoseReset_t
+{
+	bool bResetBySystemMenu;
+};
+
+struct VREvent_Screenshot_t
+{
+	uint32_t handle;
+	uint32_t type;
+};
+
+struct VREvent_ScreenshotProgress_t
+{
+	float progress;
+};
+
+struct VREvent_ApplicationLaunch_t
+{
+	uint32_t pid;
+	uint32_t unArgsHandle;
+};
+
+struct VREvent_EditingCameraSurface_t
+{
+	uint64_t overlayHandle;
+	uint32_t nVisualMode;
+};
+
+struct VREvent_MessageOverlay_t
+{
+	uint32_t unVRMessageOverlayResponse;  // vr::VRMessageOverlayResponse enum
+};
+
+struct VREvent_Property_t
+{
+	PropertyContainerHandle_t container;
+	ETrackedDeviceProperty prop;
+};
+
+/** NOTE!!! If you change this you MUST manually update openvr_interop.cs.py */
+typedef union {
+	VREvent_Reserved_t reserved;
+	VREvent_Controller_t controller;
+	VREvent_Mouse_t mouse;
+	VREvent_Scroll_t scroll;
+	VREvent_Process_t process;
+	VREvent_Notification_t notification;
+	VREvent_Overlay_t overlay;
+	VREvent_Status_t status;
+	VREvent_Keyboard_t keyboard;
+	VREvent_Ipd_t ipd;
+	VREvent_Chaperone_t chaperone;
+	VREvent_PerformanceTest_t performanceTest;
+	VREvent_TouchPadMove_t touchPadMove;
+	VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset;
+	VREvent_Screenshot_t screenshot;
+	VREvent_ScreenshotProgress_t screenshotProgress;
+	VREvent_ApplicationLaunch_t applicationLaunch;
+	VREvent_EditingCameraSurface_t cameraSurface;
+	VREvent_MessageOverlay_t messageOverlay;
+	VREvent_Property_t property;
+} VREvent_Data_t;
+
+#if defined(__linux__) || defined(__APPLE__)
+// This structure was originally defined mis-packed on Linux, preserved for
+// compatibility.
+#pragma pack(push, 4)
+#endif
+
+/** An event posted by the server to all running applications */
+struct VREvent_t
+{
+	uint32_t eventType;  // EVREventType enum
+	TrackedDeviceIndex_t trackedDeviceIndex;
+	float eventAgeSeconds;
+	// event data must be the end of the struct as its size is variable
+	VREvent_Data_t data;
+};
+
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+
+/** The mesh to draw into the stencil (or depth) buffer to perform 
+* early stencil (or depth) kills of pixels that will never appear on the HMD.
+* This mesh draws on all the pixels that will be hidden after distortion. 
+*
+* If the HMD does not provide a visible area mesh pVertexData will be
+* NULL and unTriangleCount will be 0. */
+struct HiddenAreaMesh_t
+{
+	const HmdVector2_t *pVertexData;
+	uint32_t unTriangleCount;
+};
+
+enum EHiddenAreaMeshType
+{
+	k_eHiddenAreaMesh_Standard = 0,
+	k_eHiddenAreaMesh_Inverse = 1,
+	k_eHiddenAreaMesh_LineLoop = 2,
+
+	k_eHiddenAreaMesh_Max = 3,
+};
+
+/** Identifies what kind of axis is on the controller at index n. Read this type 
+* with pVRSystem->Get( nControllerDeviceIndex, Prop_Axis0Type_Int32 + n );
+*/
+enum EVRControllerAxisType
+{
+	k_eControllerAxis_None = 0,
+	k_eControllerAxis_TrackPad = 1,
+	k_eControllerAxis_Joystick = 2,
+	k_eControllerAxis_Trigger = 3,  // Analog trigger data is in the X axis
+};
+
+/** contains information about one axis on the controller */
+struct VRControllerAxis_t
+{
+	float x;  // Ranges from -1.0 to 1.0 for joysticks and track pads. Ranges from 0.0 to 1.0 for triggers were 0 is fully released.
+	float y;  // Ranges from -1.0 to 1.0 for joysticks and track pads. Is always 0.0 for triggers.
+};
+
+/** the number of axes in the controller state */
+static const uint32_t k_unControllerStateAxisCount = 5;
+
+#if defined(__linux__) || defined(__APPLE__)
+// This structure was originally defined mis-packed on Linux, preserved for
+// compatibility.
+#pragma pack(push, 4)
+#endif
+
+/** Holds all the state of a controller at one moment in time. */
+struct VRControllerState001_t
+{
+	// If packet num matches that on your prior call, then the controller state hasn't been changed since
+	// your last call and there is no need to process it
+	uint32_t unPacketNum;
+
+	// bit flags for each of the buttons. Use ButtonMaskFromId to turn an ID into a mask
+	uint64_t ulButtonPressed;
+	uint64_t ulButtonTouched;
+
+	// Axis data for the controller's analog inputs
+	VRControllerAxis_t rAxis[k_unControllerStateAxisCount];
+};
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+
+typedef VRControllerState001_t VRControllerState_t;
+
+/** determines how to provide output to the application of various event processing functions. */
+enum EVRControllerEventOutputType
+{
+	ControllerEventOutput_OSEvents = 0,
+	ControllerEventOutput_VREvents = 1,
+};
+
+/** Collision Bounds Style */
+enum ECollisionBoundsStyle
+{
+	COLLISION_BOUNDS_STYLE_BEGINNER = 0,
+	COLLISION_BOUNDS_STYLE_INTERMEDIATE,
+	COLLISION_BOUNDS_STYLE_SQUARES,
+	COLLISION_BOUNDS_STYLE_ADVANCED,
+	COLLISION_BOUNDS_STYLE_NONE,
+
+	COLLISION_BOUNDS_STYLE_COUNT
+};
+
+/** Allows the application to customize how the overlay appears in the compositor */
+struct Compositor_OverlaySettings
+{
+	uint32_t size;  // sizeof(Compositor_OverlaySettings)
+	bool curved, antialias;
+	float scale, distance, alpha;
+	float uOffset, vOffset, uScale, vScale;
+	float gridDivs, gridWidth, gridScale;
+	HmdMatrix44_t transform;
+};
+
+/** used to refer to a single VR overlay */
+typedef uint64_t VROverlayHandle_t;
+
+static const VROverlayHandle_t k_ulOverlayHandleInvalid = 0;
+
+/** Errors that can occur around VR overlays */
+enum EVROverlayError
+{
+	VROverlayError_None = 0,
+
+	VROverlayError_UnknownOverlay = 10,
+	VROverlayError_InvalidHandle = 11,
+	VROverlayError_PermissionDenied = 12,
+	VROverlayError_OverlayLimitExceeded = 13,  // No more overlays could be created because the maximum number already exist
+	VROverlayError_WrongVisibilityType = 14,
+	VROverlayError_KeyTooLong = 15,
+	VROverlayError_NameTooLong = 16,
+	VROverlayError_KeyInUse = 17,
+	VROverlayError_WrongTransformType = 18,
+	VROverlayError_InvalidTrackedDevice = 19,
+	VROverlayError_InvalidParameter = 20,
+	VROverlayError_ThumbnailCantBeDestroyed = 21,
+	VROverlayError_ArrayTooSmall = 22,
+	VROverlayError_RequestFailed = 23,
+	VROverlayError_InvalidTexture = 24,
+	VROverlayError_UnableToLoadFile = 25,
+	VROverlayError_KeyboardAlreadyInUse = 26,
+	VROverlayError_NoNeighbor = 27,
+	VROverlayError_TooManyMaskPrimitives = 29,
+	VROverlayError_BadMaskPrimitive = 30,
+};
+
+/** enum values to pass in to VR_Init to identify whether the application will 
+* draw a 3D scene. */
+enum EVRApplicationType
+{
+	VRApplication_Other = 0,          // Some other kind of application that isn't covered by the other entries
+	VRApplication_Scene = 1,          // Application will submit 3D frames
+	VRApplication_Overlay = 2,        // Application only interacts with overlays
+	VRApplication_Background = 3,     // Application should not start SteamVR if it's not already running, and should not
+									  // keep it running if everything else quits.
+	VRApplication_Utility = 4,        // Init should not try to load any drivers. The application needs access to utility
+									  // interfaces (like IVRSettings and IVRApplications) but not hardware.
+	VRApplication_VRMonitor = 5,      // Reserved for vrmonitor
+	VRApplication_SteamWatchdog = 6,  // Reserved for Steam
+	VRApplication_Bootstrapper = 7,   // Start up SteamVR
+
+	VRApplication_Max
+};
+
+/** error codes for firmware */
+enum EVRFirmwareError
+{
+	VRFirmwareError_None = 0,
+	VRFirmwareError_Success = 1,
+	VRFirmwareError_Fail = 2,
+};
+
+/** error codes for notifications */
+enum EVRNotificationError
+{
+	VRNotificationError_OK = 0,
+	VRNotificationError_InvalidNotificationId = 100,
+	VRNotificationError_NotificationQueueFull = 101,
+	VRNotificationError_InvalidOverlayHandle = 102,
+	VRNotificationError_SystemWithUserValueAlreadyExists = 103,
+};
+
+/** error codes returned by Vr_Init */
+
+// Please add adequate error description to https://developer.valvesoftware.com/w/index.php?title=Category:SteamVRHelp
+enum EVRInitError
+{
+	VRInitError_None = 0,
+	VRInitError_Unknown = 1,
+
+	VRInitError_Init_InstallationNotFound = 100,
+	VRInitError_Init_InstallationCorrupt = 101,
+	VRInitError_Init_VRClientDLLNotFound = 102,
+	VRInitError_Init_FileNotFound = 103,
+	VRInitError_Init_FactoryNotFound = 104,
+	VRInitError_Init_InterfaceNotFound = 105,
+	VRInitError_Init_InvalidInterface = 106,
+	VRInitError_Init_UserConfigDirectoryInvalid = 107,
+	VRInitError_Init_HmdNotFound = 108,
+	VRInitError_Init_NotInitialized = 109,
+	VRInitError_Init_PathRegistryNotFound = 110,
+	VRInitError_Init_NoConfigPath = 111,
+	VRInitError_Init_NoLogPath = 112,
+	VRInitError_Init_PathRegistryNotWritable = 113,
+	VRInitError_Init_AppInfoInitFailed = 114,
+	VRInitError_Init_Retry = 115,               // Used internally to cause retries to vrserver
+	VRInitError_Init_InitCanceledByUser = 116,  // The calling application should silently exit. The user canceled app startup
+	VRInitError_Init_AnotherAppLaunching = 117,
+	VRInitError_Init_SettingsInitFailed = 118,
+	VRInitError_Init_ShuttingDown = 119,
+	VRInitError_Init_TooManyObjects = 120,
+	VRInitError_Init_NoServerForBackgroundApp = 121,
+	VRInitError_Init_NotSupportedWithCompositor = 122,
+	VRInitError_Init_NotAvailableToUtilityApps = 123,
+	VRInitError_Init_Internal = 124,
+	VRInitError_Init_HmdDriverIdIsNone = 125,
+	VRInitError_Init_HmdNotFoundPresenceFailed = 126,
+	VRInitError_Init_VRMonitorNotFound = 127,
+	VRInitError_Init_VRMonitorStartupFailed = 128,
+	VRInitError_Init_LowPowerWatchdogNotSupported = 129,
+	VRInitError_Init_InvalidApplicationType = 130,
+	VRInitError_Init_NotAvailableToWatchdogApps = 131,
+	VRInitError_Init_WatchdogDisabledInSettings = 132,
+	VRInitError_Init_VRDashboardNotFound = 133,
+	VRInitError_Init_VRDashboardStartupFailed = 134,
+	VRInitError_Init_VRHomeNotFound = 135,
+	VRInitError_Init_VRHomeStartupFailed = 136,
+	VRInitError_Init_RebootingBusy = 137,
+	VRInitError_Init_FirmwareUpdateBusy = 138,
+	VRInitError_Init_FirmwareRecoveryBusy = 139,
+
+	VRInitError_Driver_Failed = 200,
+	VRInitError_Driver_Unknown = 201,
+	VRInitError_Driver_HmdUnknown = 202,
+	VRInitError_Driver_NotLoaded = 203,
+	VRInitError_Driver_RuntimeOutOfDate = 204,
+	VRInitError_Driver_HmdInUse = 205,
+	VRInitError_Driver_NotCalibrated = 206,
+	VRInitError_Driver_CalibrationInvalid = 207,
+	VRInitError_Driver_HmdDisplayNotFound = 208,
+	VRInitError_Driver_TrackedDeviceInterfaceUnknown = 209,
+	// VRInitError_Driver_HmdDisplayNotFoundAfterFix = 210, // not needed: here for historic reasons
+	VRInitError_Driver_HmdDriverIdOutOfBounds = 211,
+	VRInitError_Driver_HmdDisplayMirrored = 212,
+
+	VRInitError_IPC_ServerInitFailed = 300,
+	VRInitError_IPC_ConnectFailed = 301,
+	VRInitError_IPC_SharedStateInitFailed = 302,
+	VRInitError_IPC_CompositorInitFailed = 303,
+	VRInitError_IPC_MutexInitFailed = 304,
+	VRInitError_IPC_Failed = 305,
+	VRInitError_IPC_CompositorConnectFailed = 306,
+	VRInitError_IPC_CompositorInvalidConnectResponse = 307,
+	VRInitError_IPC_ConnectFailedAfterMultipleAttempts = 308,
+
+	VRInitError_Compositor_Failed = 400,
+	VRInitError_Compositor_D3D11HardwareRequired = 401,
+	VRInitError_Compositor_FirmwareRequiresUpdate = 402,
+	VRInitError_Compositor_OverlayInitFailed = 403,
+	VRInitError_Compositor_ScreenshotsInitFailed = 404,
+	VRInitError_Compositor_UnableToCreateDevice = 405,
+
+	VRInitError_VendorSpecific_UnableToConnectToOculusRuntime = 1000,
+
+	VRInitError_VendorSpecific_HmdFound_CantOpenDevice = 1101,
+	VRInitError_VendorSpecific_HmdFound_UnableToRequestConfigStart = 1102,
+	VRInitError_VendorSpecific_HmdFound_NoStoredConfig = 1103,
+	VRInitError_VendorSpecific_HmdFound_ConfigTooBig = 1104,
+	VRInitError_VendorSpecific_HmdFound_ConfigTooSmall = 1105,
+	VRInitError_VendorSpecific_HmdFound_UnableToInitZLib = 1106,
+	VRInitError_VendorSpecific_HmdFound_CantReadFirmwareVersion = 1107,
+	VRInitError_VendorSpecific_HmdFound_UnableToSendUserDataStart = 1108,
+	VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataStart = 1109,
+	VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataNext = 1110,
+	VRInitError_VendorSpecific_HmdFound_UserDataAddressRange = 1111,
+	VRInitError_VendorSpecific_HmdFound_UserDataError = 1112,
+	VRInitError_VendorSpecific_HmdFound_ConfigFailedSanityCheck = 1113,
+
+	VRInitError_Steam_SteamInstallationNotFound = 2000,
+};
+
+enum EVRScreenshotType
+{
+	VRScreenshotType_None = 0,
+	VRScreenshotType_Mono = 1,  // left eye only
+	VRScreenshotType_Stereo = 2,
+	VRScreenshotType_Cubemap = 3,
+	VRScreenshotType_MonoPanorama = 4,
+	VRScreenshotType_StereoPanorama = 5
+};
+
+enum EVRScreenshotPropertyFilenames
+{
+	VRScreenshotPropertyFilenames_Preview = 0,
+	VRScreenshotPropertyFilenames_VR = 1,
+};
+
+enum EVRTrackedCameraError
+{
+	VRTrackedCameraError_None = 0,
+	VRTrackedCameraError_OperationFailed = 100,
+	VRTrackedCameraError_InvalidHandle = 101,
+	VRTrackedCameraError_InvalidFrameHeaderVersion = 102,
+	VRTrackedCameraError_OutOfHandles = 103,
+	VRTrackedCameraError_IPCFailure = 104,
+	VRTrackedCameraError_NotSupportedForThisDevice = 105,
+	VRTrackedCameraError_SharedMemoryFailure = 106,
+	VRTrackedCameraError_FrameBufferingFailure = 107,
+	VRTrackedCameraError_StreamSetupFailure = 108,
+	VRTrackedCameraError_InvalidGLTextureId = 109,
+	VRTrackedCameraError_InvalidSharedTextureHandle = 110,
+	VRTrackedCameraError_FailedToGetGLTextureId = 111,
+	VRTrackedCameraError_SharedTextureFailure = 112,
+	VRTrackedCameraError_NoFrameAvailable = 113,
+	VRTrackedCameraError_InvalidArgument = 114,
+	VRTrackedCameraError_InvalidFrameBufferSize = 115,
+};
+
+enum EVRTrackedCameraFrameType
+{
+	VRTrackedCameraFrameType_Distorted = 0,       // This is the camera video frame size in pixels, still distorted.
+	VRTrackedCameraFrameType_Undistorted,         // In pixels, an undistorted inscribed rectangle region without invalid regions. This size is subject to changes shortly.
+	VRTrackedCameraFrameType_MaximumUndistorted,  // In pixels, maximum undistorted with invalid regions. Non zero alpha component identifies valid regions.
+	MAX_CAMERA_FRAME_TYPES
+};
+
+typedef uint64_t TrackedCameraHandle_t;
+#define INVALID_TRACKED_CAMERA_HANDLE ((vr::TrackedCameraHandle_t)0)
+
+struct CameraVideoStreamFrameHeader_t
+{
+	EVRTrackedCameraFrameType eFrameType;
+
+	uint32_t nWidth;
+	uint32_t nHeight;
+	uint32_t nBytesPerPixel;
+
+	uint32_t nFrameSequence;
+
+	TrackedDevicePose_t standingTrackedDevicePose;
+};
+
+// Screenshot types
+typedef uint32_t ScreenshotHandle_t;
+
+static const uint32_t k_unScreenshotHandleInvalid = 0;
+
+#pragma pack(pop)
+
+// figure out how to import from the VR API dll
+#if defined(_WIN32)
+
+#ifdef VR_API_EXPORT
+#define VR_INTERFACE extern "C" __declspec(dllexport)
+#else
+#define VR_INTERFACE extern "C" __declspec(dllimport)
+#endif
+
+#elif defined(__GNUC__) || defined(COMPILER_GCC) || defined(__APPLE__)
+
+#ifdef VR_API_EXPORT
+#define VR_INTERFACE extern "C" __attribute__((visibility("default")))
+#else
+#define VR_INTERFACE extern "C"
+#endif
+
+#else
+#error "Unsupported Platform."
+#endif
+
+#if defined(_WIN32)
+#define VR_CALLTYPE __cdecl
+#else
+#define VR_CALLTYPE
+#endif
+
+}  // namespace vr
+
+#endif  // _INCLUDE_VRTYPES_H
+
+// vrannotation.h
+#ifdef API_GEN
+#define VR_CLANG_ATTR(ATTR) __attribute__((annotate(ATTR)))
+#else
+#define VR_CLANG_ATTR(ATTR)
+#endif
+
+#define VR_METHOD_DESC(DESC) VR_CLANG_ATTR("desc:" #DESC ";")
+#define VR_IGNOREATTR() VR_CLANG_ATTR("ignore")
+#define VR_OUT_STRUCT() VR_CLANG_ATTR("out_struct: ;")
+#define VR_OUT_STRING() VR_CLANG_ATTR("out_string: ;")
+#define VR_OUT_ARRAY_CALL(COUNTER, FUNCTION, PARAMS) VR_CLANG_ATTR("out_array_call:" #COUNTER "," #FUNCTION "," #PARAMS ";")
+#define VR_OUT_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR("out_array_count:" #COUNTER ";")
+#define VR_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR("array_count:" #COUNTER ";")
+#define VR_ARRAY_COUNT_D(COUNTER, DESC) VR_CLANG_ATTR("array_count:" #COUNTER ";desc:" #DESC)
+#define VR_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR("buffer_count:" #COUNTER ";")
+#define VR_OUT_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR("out_buffer_count:" #COUNTER ";")
+#define VR_OUT_STRING_COUNT(COUNTER) VR_CLANG_ATTR("out_string_count:" #COUNTER ";")
+
+// ivrsystem.h
+namespace vr
+{
+class IVRSystem
+{
+public:
+	// ------------------------------------
+	// Display Methods
+	// ------------------------------------
+
+	/** Suggested size for the intermediate render target that the distortion pulls from. */
+	virtual void GetRecommendedRenderTargetSize(uint32_t *pnWidth, uint32_t *pnHeight) = 0;
+
+	/** The projection matrix for the specified eye */
+	virtual HmdMatrix44_t GetProjectionMatrix(EVREye eEye, float fNearZ, float fFarZ) = 0;
+
+	/** The components necessary to build your own projection matrix in case your
+	* application is doing something fancy like infinite Z */
+	virtual void GetProjectionRaw(EVREye eEye, float *pfLeft, float *pfRight, float *pfTop, float *pfBottom) = 0;
+
+	/** Gets the result of the distortion function for the specified eye and input UVs. UVs go from 0,0 in 
+	* the upper left of that eye's viewport and 1,1 in the lower right of that eye's viewport.
+	* Returns true for success. Otherwise, returns false, and distortion coordinates are not suitable. */
+	virtual bool ComputeDistortion(EVREye eEye, float fU, float fV, DistortionCoordinates_t *pDistortionCoordinates) = 0;
+
+	/** Returns the transform from eye space to the head space. Eye space is the per-eye flavor of head
+	* space that provides stereo disparity. Instead of Model * View * Projection the sequence is Model * View * Eye^-1 * Projection. 
+	* Normally View and Eye^-1 will be multiplied together and treated as View in your application. 
+	*/
+	virtual HmdMatrix34_t GetEyeToHeadTransform(EVREye eEye) = 0;
+
+	/** Returns the number of elapsed seconds since the last recorded vsync event. This 
+	*	will come from a vsync timer event in the timer if possible or from the application-reported
+	*   time if that is not available. If no vsync times are available the function will 
+	*   return zero for vsync time and frame counter and return false from the method. */
+	virtual bool GetTimeSinceLastVsync(float *pfSecondsSinceLastVsync, uint64_t *pulFrameCounter) = 0;
+
+	/** [D3D9 Only]
+	* Returns the adapter index that the user should pass into CreateDevice to set up D3D9 in such
+	* a way that it can go full screen exclusive on the HMD. Returns -1 if there was an error.
+	*/
+	virtual int32_t GetD3D9AdapterIndex() = 0;
+
+	/** [D3D10/11 Only]
+	* Returns the adapter index that the user should pass into EnumAdapters to create the device 
+	* and swap chain in DX10 and DX11. If an error occurs the index will be set to -1.
+	*/
+	virtual void GetDXGIOutputInfo(int32_t *pnAdapterIndex) = 0;
+
+	/**
+	 * Returns platform- and texture-type specific adapter identification so that applications and the
+	 * compositor are creating textures and swap chains on the same GPU. If an error occurs the device
+	 * will be set to 0.
+	 * pInstance is an optional parameter that is required only when textureType is TextureType_Vulkan.
+	 * [D3D10/11/12 Only (D3D9 Not Supported)]
+	 *  Returns the adapter LUID that identifies the GPU attached to the HMD. The user should
+	 *  enumerate all adapters using IDXGIFactory::EnumAdapters and IDXGIAdapter::GetDesc to find
+	 *  the adapter with the matching LUID, or use IDXGIFactory4::EnumAdapterByLuid.
+	 *  The discovered IDXGIAdapter should be used to create the device and swap chain.
+	 * [Vulkan Only]
+	 *  Returns the VkPhysicalDevice that should be used by the application.
+	 *  pInstance must be the instance the application will use to query for the VkPhysicalDevice.  The application
+	 *  must create the VkInstance with extensions returned by IVRCompositor::GetVulkanInstanceExtensionsRequired enabled.
+	 * [macOS Only]
+	 *  Returns an id<MTLDevice> that should be used by the application.
+	 */
+	virtual void GetOutputDevice(uint64_t *pnDevice, ETextureType textureType, VkInstance_T *pInstance = nullptr) = 0;
+
+	// ------------------------------------
+	// Display Mode methods
+	// ------------------------------------
+
+	/** Use to determine if the headset display is part of the desktop (i.e. extended) or hidden (i.e. direct mode). */
+	virtual bool IsDisplayOnDesktop() = 0;
+
+	/** Set the display visibility (true = extended, false = direct mode).  Return value of true indicates that the change was successful. */
+	virtual bool SetDisplayVisibility(bool bIsVisibleOnDesktop) = 0;
+
+	// ------------------------------------
+	// Tracking Methods
+	// ------------------------------------
+
+	/** The pose that the tracker thinks that the HMD will be in at the specified number of seconds into the 
+	* future. Pass 0 to get the state at the instant the method is called. Most of the time the application should
+	* calculate the time until the photons will be emitted from the display and pass that time into the method.
+	*
+	* This is roughly analogous to the inverse of the view matrix in most applications, though 
+	* many games will need to do some additional rotation or translation on top of the rotation
+	* and translation provided by the head pose.
+	*
+	* For devices where bPoseIsValid is true the application can use the pose to position the device
+	* in question. The provided array can be any size up to k_unMaxTrackedDeviceCount. 
+	*
+	* Seated experiences should call this method with TrackingUniverseSeated and receive poses relative
+	* to the seated zero pose. Standing experiences should call this method with TrackingUniverseStanding 
+	* and receive poses relative to the Chaperone Play Area. TrackingUniverseRawAndUncalibrated should 
+	* probably not be used unless the application is the Chaperone calibration tool itself, but will provide
+	* poses relative to the hardware-specific coordinate system in the driver.
+	*/
+	virtual void GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, VR_ARRAY_COUNT(unTrackedDevicePoseArrayCount) TrackedDevicePose_t *pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = 0;
+
+	/** Sets the zero pose for the seated tracker coordinate system to the current position and yaw of the HMD. After 
+	* ResetSeatedZeroPose all GetDeviceToAbsoluteTrackingPose calls that pass TrackingUniverseSeated as the origin 
+	* will be relative to this new zero pose. The new zero coordinate system will not change the fact that the Y axis 
+	* is up in the real world, so the next pose returned from GetDeviceToAbsoluteTrackingPose after a call to 
+	* ResetSeatedZeroPose may not be exactly an identity matrix.
+	*
+	* NOTE: This function overrides the user's previously saved seated zero pose and should only be called as the result of a user action. 
+	* Users are also able to set their seated zero pose via the OpenVR Dashboard.
+	**/
+	virtual void ResetSeatedZeroPose() = 0;
+
+	/** Returns the transform from the seated zero pose to the standing absolute tracking system. This allows 
+	* applications to represent the seated origin to used or transform object positions from one coordinate
+	* system to the other. 
+	*
+	* The seated origin may or may not be inside the Play Area or Collision Bounds returned by IVRChaperone. Its position 
+	* depends on what the user has set from the Dashboard settings and previous calls to ResetSeatedZeroPose. */
+	virtual HmdMatrix34_t GetSeatedZeroPoseToStandingAbsoluteTrackingPose() = 0;
+
+	/** Returns the transform from the tracking origin to the standing absolute tracking system. This allows
+	* applications to convert from raw tracking space to the calibrated standing coordinate system. */
+	virtual HmdMatrix34_t GetRawZeroPoseToStandingAbsoluteTrackingPose() = 0;
+
+	/** Get a sorted array of device indices of a given class of tracked devices (e.g. controllers).  Devices are sorted right to left
+	* relative to the specified tracked device (default: hmd -- pass in -1 for absolute tracking space).  Returns the number of devices
+	* in the list, or the size of the array needed if not large enough. */
+	virtual uint32_t GetSortedTrackedDeviceIndicesOfClass(ETrackedDeviceClass eTrackedDeviceClass, VR_ARRAY_COUNT(unTrackedDeviceIndexArrayCount) vr::TrackedDeviceIndex_t *punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, vr::TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex = k_unTrackedDeviceIndex_Hmd) = 0;
+
+	/** Returns the level of activity on the device. */
+	virtual EDeviceActivityLevel GetTrackedDeviceActivityLevel(vr::TrackedDeviceIndex_t unDeviceId) = 0;
+
+	/** Convenience utility to apply the specified transform to the specified pose.
+	*   This properly transforms all pose components, including velocity and angular velocity
+	*/
+	virtual void ApplyTransform(TrackedDevicePose_t *pOutputPose, const TrackedDevicePose_t *pTrackedDevicePose, const HmdMatrix34_t *pTransform) = 0;
+
+	/** Returns the device index associated with a specific role, for example the left hand or the right hand. */
+	virtual vr::TrackedDeviceIndex_t GetTrackedDeviceIndexForControllerRole(vr::ETrackedControllerRole unDeviceType) = 0;
+
+	/** Returns the controller type associated with a device index. */
+	virtual vr::ETrackedControllerRole GetControllerRoleForTrackedDeviceIndex(vr::TrackedDeviceIndex_t unDeviceIndex) = 0;
+
+	// ------------------------------------
+	// Property methods
+	// ------------------------------------
+
+	/** Returns the device class of a tracked device. If there has not been a device connected in this slot
+	* since the application started this function will return TrackedDevice_Invalid. For previous detected
+	* devices the function will return the previously observed device class. 
+	*
+	* To determine which devices exist on the system, just loop from 0 to k_unMaxTrackedDeviceCount and check
+	* the device class. Every device with something other than TrackedDevice_Invalid is associated with an 
+	* actual tracked device. */
+	virtual ETrackedDeviceClass GetTrackedDeviceClass(vr::TrackedDeviceIndex_t unDeviceIndex) = 0;
+
+	/** Returns true if there is a device connected in this slot. */
+	virtual bool IsTrackedDeviceConnected(vr::TrackedDeviceIndex_t unDeviceIndex) = 0;
+
+	/** Returns a bool property. If the device index is not valid or the property is not a bool type this function will return false. */
+	virtual bool GetBoolTrackedDeviceProperty(vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L) = 0;
+
+	/** Returns a float property. If the device index is not valid or the property is not a float type this function will return 0. */
+	virtual float GetFloatTrackedDeviceProperty(vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L) = 0;
+
+	/** Returns an int property. If the device index is not valid or the property is not a int type this function will return 0. */
+	virtual int32_t GetInt32TrackedDeviceProperty(vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L) = 0;
+
+	/** Returns a uint64 property. If the device index is not valid or the property is not a uint64 type this function will return 0. */
+	virtual uint64_t GetUint64TrackedDeviceProperty(vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L) = 0;
+
+	/** Returns a matrix property. If the device index is not valid or the property is not a matrix type, this function will return identity. */
+	virtual HmdMatrix34_t GetMatrix34TrackedDeviceProperty(vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L) = 0;
+
+	/** Returns a string property. If the device index is not valid or the property is not a string type this function will 
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters. */
+	virtual uint32_t GetStringTrackedDeviceProperty(vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError = 0L) = 0;
+
+	/** returns a string that corresponds with the specified property error. The string will be the name 
+	* of the error enum value for all valid error codes */
+	virtual const char *GetPropErrorNameFromEnum(ETrackedPropertyError error) = 0;
+
+	// ------------------------------------
+	// Event methods
+	// ------------------------------------
+
+	/** Returns true and fills the event with the next event on the queue if there is one. If there are no events
+	* this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct */
+	virtual bool PollNextEvent(VREvent_t *pEvent, uint32_t uncbVREvent) = 0;
+
+	/** Returns true and fills the event with the next event on the queue if there is one. If there are no events
+	* this method returns false. Fills in the pose of the associated tracked device in the provided pose struct. 
+	* This pose will always be older than the call to this function and should not be used to render the device. 
+	uncbVREvent should be the size in bytes of the VREvent_t struct */
+	virtual bool PollNextEventWithPose(ETrackingUniverseOrigin eOrigin, VREvent_t *pEvent, uint32_t uncbVREvent, vr::TrackedDevicePose_t *pTrackedDevicePose) = 0;
+
+	/** returns the name of an EVREvent enum value */
+	virtual const char *GetEventTypeNameFromEnum(EVREventType eType) = 0;
+
+	// ------------------------------------
+	// Rendering helper methods
+	// ------------------------------------
+
+	/** Returns the hidden area mesh for the current HMD. The pixels covered by this mesh will never be seen by the user after the lens distortion is
+	* applied based on visibility to the panels. If this HMD does not have a hidden area mesh, the vertex data and count will be NULL and 0 respectively.
+	* This mesh is meant to be rendered into the stencil buffer (or into the depth buffer setting nearz) before rendering each eye's view. 
+	* This will improve performance by letting the GPU early-reject pixels the user will never see before running the pixel shader.
+	* NOTE: Render this mesh with backface culling disabled since the winding order of the vertices can be different per-HMD or per-eye.
+	* Setting the bInverse argument to true will produce the visible area mesh that is commonly used in place of full-screen quads. The visible area mesh covers all of the pixels the hidden area mesh does not cover.
+	* Setting the bLineLoop argument will return a line loop of vertices in HiddenAreaMesh_t->pVertexData with HiddenAreaMesh_t->unTriangleCount set to the number of vertices.
+	*/
+	virtual HiddenAreaMesh_t GetHiddenAreaMesh(EVREye eEye, EHiddenAreaMeshType type = k_eHiddenAreaMesh_Standard) = 0;
+
+	// ------------------------------------
+	// Controller methods
+	// ------------------------------------
+
+	/** Fills the supplied struct with the current state of the controller. Returns false if the controller index
+	* is invalid. */
+	virtual bool GetControllerState(vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize) = 0;
+
+	/** fills the supplied struct with the current state of the controller and the provided pose with the pose of 
+	* the controller when the controller state was updated most recently. Use this form if you need a precise controller
+	* pose as input to your application when the user presses or releases a button. */
+	virtual bool GetControllerStateWithPose(ETrackingUniverseOrigin eOrigin, vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose) = 0;
+
+	/** Trigger a single haptic pulse on a controller. After this call the application may not trigger another haptic pulse on this controller
+	* and axis combination for 5ms. */
+	virtual void TriggerHapticPulse(vr::TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = 0;
+
+	/** returns the name of an EVRButtonId enum value */
+	virtual const char *GetButtonIdNameFromEnum(EVRButtonId eButtonId) = 0;
+
+	/** returns the name of an EVRControllerAxisType enum value */
+	virtual const char *GetControllerAxisTypeNameFromEnum(EVRControllerAxisType eAxisType) = 0;
+
+	/** Tells OpenVR that this process wants exclusive access to controller button states and button events. Other apps will be notified that 
+	* they have lost input focus with a VREvent_InputFocusCaptured event. Returns false if input focus could not be captured for
+	* some reason. */
+	virtual bool CaptureInputFocus() = 0;
+
+	/** Tells OpenVR that this process no longer wants exclusive access to button states and button events. Other apps will be notified 
+	* that input focus has been released with a VREvent_InputFocusReleased event. */
+	virtual void ReleaseInputFocus() = 0;
+
+	/** Returns true if input focus is captured by another process. */
+	virtual bool IsInputFocusCapturedByAnotherProcess() = 0;
+
+	// ------------------------------------
+	// Debug Methods
+	// ------------------------------------
+
+	/** Sends a request to the driver for the specified device and returns the response. The maximum response size is 32k,
+	* but this method can be called with a smaller buffer. If the response exceeds the size of the buffer, it is truncated. 
+	* The size of the response including its terminating null is returned. */
+	virtual uint32_t DriverDebugRequest(vr::TrackedDeviceIndex_t unDeviceIndex, const char *pchRequest, char *pchResponseBuffer, uint32_t unResponseBufferSize) = 0;
+
+	// ------------------------------------
+	// Firmware methods
+	// ------------------------------------
+
+	/** Performs the actual firmware update if applicable. 
+	 * The following events will be sent, if VRFirmwareError_None was returned: VREvent_FirmwareUpdateStarted, VREvent_FirmwareUpdateFinished 
+	 * Use the properties Prop_Firmware_UpdateAvailable_Bool, Prop_Firmware_ManualUpdate_Bool, and Prop_Firmware_ManualUpdateURL_String
+	 * to figure our whether a firmware update is available, and to figure out whether its a manual update 
+	 * Prop_Firmware_ManualUpdateURL_String should point to an URL describing the manual update process */
+	virtual vr::EVRFirmwareError PerformFirmwareUpdate(vr::TrackedDeviceIndex_t unDeviceIndex) = 0;
+
+	// ------------------------------------
+	// Application life cycle methods
+	// ------------------------------------
+
+	/** Call this to acknowledge to the system that VREvent_Quit has been received and that the process is exiting.
+	* This extends the timeout until the process is killed. */
+	virtual void AcknowledgeQuit_Exiting() = 0;
+
+	/** Call this to tell the system that the user is being prompted to save data. This
+	* halts the timeout and dismisses the dashboard (if it was up). Applications should be sure to actually 
+	* prompt the user to save and then exit afterward, otherwise the user will be left in a confusing state. */
+	virtual void AcknowledgeQuit_UserPrompt() = 0;
+};
+
+static const char *const IVRSystem_Version = "IVRSystem_017";
+
+}  // namespace vr
+
+// ivrapplications.h
+namespace vr
+{
+/** Used for all errors reported by the IVRApplications interface */
+enum EVRApplicationError
+{
+	VRApplicationError_None = 0,
+
+	VRApplicationError_AppKeyAlreadyExists = 100,  // Only one application can use any given key
+	VRApplicationError_NoManifest = 101,           // the running application does not have a manifest
+	VRApplicationError_NoApplication = 102,        // No application is running
+	VRApplicationError_InvalidIndex = 103,
+	VRApplicationError_UnknownApplication = 104,  // the application could not be found
+	VRApplicationError_IPCFailed = 105,           // An IPC failure caused the request to fail
+	VRApplicationError_ApplicationAlreadyRunning = 106,
+	VRApplicationError_InvalidManifest = 107,
+	VRApplicationError_InvalidApplication = 108,
+	VRApplicationError_LaunchFailed = 109,                // the process didn't start
+	VRApplicationError_ApplicationAlreadyStarting = 110,  // the system was already starting the same application
+	VRApplicationError_LaunchInProgress = 111,            // The system was already starting a different application
+	VRApplicationError_OldApplicationQuitting = 112,
+	VRApplicationError_TransitionAborted = 113,
+	VRApplicationError_IsTemplate = 114,  // error when you try to call LaunchApplication() on a template type app (use LaunchTemplateApplication)
+	VRApplicationError_SteamVRIsExiting = 115,
+
+	VRApplicationError_BufferTooSmall = 200,  // The provided buffer was too small to fit the requested data
+	VRApplicationError_PropertyNotSet = 201,  // The requested property was not set
+	VRApplicationError_UnknownProperty = 202,
+	VRApplicationError_InvalidParameter = 203,
+};
+
+/** The maximum length of an application key */
+static const uint32_t k_unMaxApplicationKeyLength = 128;
+
+/** these are the properties available on applications. */
+enum EVRApplicationProperty
+{
+	VRApplicationProperty_Name_String = 0,
+
+	VRApplicationProperty_LaunchType_String = 11,
+	VRApplicationProperty_WorkingDirectory_String = 12,
+	VRApplicationProperty_BinaryPath_String = 13,
+	VRApplicationProperty_Arguments_String = 14,
+	VRApplicationProperty_URL_String = 15,
+
+	VRApplicationProperty_Description_String = 50,
+	VRApplicationProperty_NewsURL_String = 51,
+	VRApplicationProperty_ImagePath_String = 52,
+	VRApplicationProperty_Source_String = 53,
+
+	VRApplicationProperty_IsDashboardOverlay_Bool = 60,
+	VRApplicationProperty_IsTemplate_Bool = 61,
+	VRApplicationProperty_IsInstanced_Bool = 62,
+	VRApplicationProperty_IsInternal_Bool = 63,
+	VRApplicationProperty_WantsCompositorPauseInStandby_Bool = 64,
+
+	VRApplicationProperty_LastLaunchTime_Uint64 = 70,
+};
+
+/** These are states the scene application startup process will go through. */
+enum EVRApplicationTransitionState
+{
+	VRApplicationTransition_None = 0,
+
+	VRApplicationTransition_OldAppQuitSent = 10,
+	VRApplicationTransition_WaitingForExternalLaunch = 11,
+
+	VRApplicationTransition_NewAppLaunched = 20,
+};
+
+struct AppOverrideKeys_t
+{
+	const char *pchKey;
+	const char *pchValue;
+};
+
+/** Currently recognized mime types */
+static const char *const k_pch_MimeType_HomeApp = "vr/home";
+static const char *const k_pch_MimeType_GameTheater = "vr/game_theater";
+
+class IVRApplications
+{
+public:
+	// ---------------  Application management  --------------- //
+
+	/** Adds an application manifest to the list to load when building the list of installed applications. 
+		* Temporary manifests are not automatically loaded */
+	virtual EVRApplicationError AddApplicationManifest(const char *pchApplicationManifestFullPath, bool bTemporary = false) = 0;
+
+	/** Removes an application manifest from the list to load when building the list of installed applications. */
+	virtual EVRApplicationError RemoveApplicationManifest(const char *pchApplicationManifestFullPath) = 0;
+
+	/** Returns true if an application is installed */
+	virtual bool IsApplicationInstalled(const char *pchAppKey) = 0;
+
+	/** Returns the number of applications available in the list */
+	virtual uint32_t GetApplicationCount() = 0;
+
+	/** Returns the key of the specified application. The index is at least 0 and is less than the return 
+		* value of GetApplicationCount(). The buffer should be at least k_unMaxApplicationKeyLength in order to 
+		* fit the key. */
+	virtual EVRApplicationError GetApplicationKeyByIndex(uint32_t unApplicationIndex, VR_OUT_STRING() char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = 0;
+
+	/** Returns the key of the application for the specified Process Id. The buffer should be at least 
+		* k_unMaxApplicationKeyLength in order to fit the key. */
+	virtual EVRApplicationError GetApplicationKeyByProcessId(uint32_t unProcessId, char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = 0;
+
+	/** Launches the application. The existing scene application will exit and then the new application will start.
+		* This call is not valid for dashboard overlay applications. */
+	virtual EVRApplicationError LaunchApplication(const char *pchAppKey) = 0;
+
+	/** Launches an instance of an application of type template, with its app key being pchNewAppKey (which must be unique) and optionally override sections
+		* from the manifest file via AppOverrideKeys_t
+		*/
+	virtual EVRApplicationError LaunchTemplateApplication(const char *pchTemplateAppKey, const char *pchNewAppKey, VR_ARRAY_COUNT(unKeys) const AppOverrideKeys_t *pKeys, uint32_t unKeys) = 0;
+
+	/** launches the application currently associated with this mime type and passes it the option args, typically the filename or object name of the item being launched */
+	virtual vr::EVRApplicationError LaunchApplicationFromMimeType(const char *pchMimeType, const char *pchArgs) = 0;
+
+	/** Launches the dashboard overlay application if it is not already running. This call is only valid for 
+		* dashboard overlay applications. */
+	virtual EVRApplicationError LaunchDashboardOverlay(const char *pchAppKey) = 0;
+
+	/** Cancel a pending launch for an application */
+	virtual bool CancelApplicationLaunch(const char *pchAppKey) = 0;
+
+	/** Identifies a running application. OpenVR can't always tell which process started in response
+		* to a URL. This function allows a URL handler (or the process itself) to identify the app key 
+		* for the now running application. Passing a process ID of 0 identifies the calling process. 
+		* The application must be one that's known to the system via a call to AddApplicationManifest. */
+	virtual EVRApplicationError IdentifyApplication(uint32_t unProcessId, const char *pchAppKey) = 0;
+
+	/** Returns the process ID for an application. Return 0 if the application was not found or is not running. */
+	virtual uint32_t GetApplicationProcessId(const char *pchAppKey) = 0;
+
+	/** Returns a string for an applications error */
+	virtual const char *GetApplicationsErrorNameFromEnum(EVRApplicationError error) = 0;
+
+	// ---------------  Application properties  --------------- //
+
+	/** Returns a value for an application property. The required buffer size to fit this value will be returned. */
+	virtual uint32_t GetApplicationPropertyString(const char *pchAppKey, EVRApplicationProperty eProperty, VR_OUT_STRING() char *pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError *peError = nullptr) = 0;
+
+	/** Returns a bool value for an application property. Returns false in all error cases. */
+	virtual bool GetApplicationPropertyBool(const char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError = nullptr) = 0;
+
+	/** Returns a uint64 value for an application property. Returns 0 in all error cases. */
+	virtual uint64_t GetApplicationPropertyUint64(const char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError = nullptr) = 0;
+
+	/** Sets the application auto-launch flag. This is only valid for applications which return true for VRApplicationProperty_IsDashboardOverlay_Bool. */
+	virtual EVRApplicationError SetApplicationAutoLaunch(const char *pchAppKey, bool bAutoLaunch) = 0;
+
+	/** Gets the application auto-launch flag. This is only valid for applications which return true for VRApplicationProperty_IsDashboardOverlay_Bool. */
+	virtual bool GetApplicationAutoLaunch(const char *pchAppKey) = 0;
+
+	/** Adds this mime-type to the list of supported mime types for this application*/
+	virtual EVRApplicationError SetDefaultApplicationForMimeType(const char *pchAppKey, const char *pchMimeType) = 0;
+
+	/** return the app key that will open this mime type */
+	virtual bool GetDefaultApplicationForMimeType(const char *pchMimeType, char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = 0;
+
+	/** Get the list of supported mime types for this application, comma-delimited */
+	virtual bool GetApplicationSupportedMimeTypes(const char *pchAppKey, char *pchMimeTypesBuffer, uint32_t unMimeTypesBuffer) = 0;
+
+	/** Get the list of app-keys that support this mime type, comma-delimited, the return value is number of bytes you need to return the full string */
+	virtual uint32_t GetApplicationsThatSupportMimeType(const char *pchMimeType, char *pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer) = 0;
+
+	/** Get the args list from an app launch that had the process already running, you call this when you get a VREvent_ApplicationMimeTypeLoad */
+	virtual uint32_t GetApplicationLaunchArguments(uint32_t unHandle, char *pchArgs, uint32_t unArgs) = 0;
+
+	// ---------------  Transition methods --------------- //
+
+	/** Returns the app key for the application that is starting up */
+	virtual EVRApplicationError GetStartingApplication(char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = 0;
+
+	/** Returns the application transition state */
+	virtual EVRApplicationTransitionState GetTransitionState() = 0;
+
+	/** Returns errors that would prevent the specified application from launching immediately. Calling this function will
+		* cause the current scene application to quit, so only call it when you are actually about to launch something else.
+		* What the caller should do about these failures depends on the failure:
+		*   VRApplicationError_OldApplicationQuitting - An existing application has been told to quit. Wait for a VREvent_ProcessQuit
+		*                                               and try again.
+		*   VRApplicationError_ApplicationAlreadyStarting - This application is already starting. This is a permanent failure.
+		*   VRApplicationError_LaunchInProgress	      - A different application is already starting. This is a permanent failure.
+		*   VRApplicationError_None                   - Go ahead and launch. Everything is clear.
+		*/
+	virtual EVRApplicationError PerformApplicationPrelaunchCheck(const char *pchAppKey) = 0;
+
+	/** Returns a string for an application transition state */
+	virtual const char *GetApplicationsTransitionStateNameFromEnum(EVRApplicationTransitionState state) = 0;
+
+	/** Returns true if the outgoing scene app has requested a save prompt before exiting */
+	virtual bool IsQuitUserPromptRequested() = 0;
+
+	/** Starts a subprocess within the calling application. This
+		* suppresses all application transition UI and automatically identifies the new executable 
+		* as part of the same application. On success the calling process should exit immediately. 
+		* If working directory is NULL or "" the directory portion of the binary path will be 
+		* the working directory. */
+	virtual EVRApplicationError LaunchInternalProcess(const char *pchBinaryPath, const char *pchArguments, const char *pchWorkingDirectory) = 0;
+
+	/** Returns the current scene process ID according to the application system. A scene process will get scene
+		* focus once it starts rendering, but it will appear here once it calls VR_Init with the Scene application
+		* type. */
+	virtual uint32_t GetCurrentSceneProcessId() = 0;
+};
+
+static const char *const IVRApplications_Version = "IVRApplications_006";
+
+}  // namespace vr
+
+// ivrsettings.h
+namespace vr
+{
+enum EVRSettingsError
+{
+	VRSettingsError_None = 0,
+	VRSettingsError_IPCFailed = 1,
+	VRSettingsError_WriteFailed = 2,
+	VRSettingsError_ReadFailed = 3,
+	VRSettingsError_JsonParseFailed = 4,
+	VRSettingsError_UnsetSettingHasNoDefault = 5,  // This will be returned if the setting does not appear in the appropriate default file and has not been set
+};
+
+// The maximum length of a settings key
+static const uint32_t k_unMaxSettingsKeyLength = 128;
+
+class IVRSettings
+{
+public:
+	virtual const char *GetSettingsErrorNameFromEnum(EVRSettingsError eError) = 0;
+
+	// Returns true if file sync occurred (force or settings dirty)
+	virtual bool Sync(bool bForce = false, EVRSettingsError *peError = nullptr) = 0;
+
+	virtual void SetBool(const char *pchSection, const char *pchSettingsKey, bool bValue, EVRSettingsError *peError = nullptr) = 0;
+	virtual void SetInt32(const char *pchSection, const char *pchSettingsKey, int32_t nValue, EVRSettingsError *peError = nullptr) = 0;
+	virtual void SetFloat(const char *pchSection, const char *pchSettingsKey, float flValue, EVRSettingsError *peError = nullptr) = 0;
+	virtual void SetString(const char *pchSection, const char *pchSettingsKey, const char *pchValue, EVRSettingsError *peError = nullptr) = 0;
+
+	// Users of the system need to provide a proper default in default.vrsettings in the resources/settings/ directory
+	// of either the runtime or the driver_xxx directory. Otherwise the default will be false, 0, 0.0 or ""
+	virtual bool GetBool(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+	virtual int32_t GetInt32(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+	virtual float GetFloat(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+	virtual void GetString(const char *pchSection, const char *pchSettingsKey, VR_OUT_STRING() char *pchValue, uint32_t unValueLen, EVRSettingsError *peError = nullptr) = 0;
+
+	virtual void RemoveSection(const char *pchSection, EVRSettingsError *peError = nullptr) = 0;
+	virtual void RemoveKeyInSection(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+};
+
+//-----------------------------------------------------------------------------
+static const char *const IVRSettings_Version = "IVRSettings_002";
+
+//-----------------------------------------------------------------------------
+// steamvr keys
+static const char *const k_pch_SteamVR_Section = "steamvr";
+static const char *const k_pch_SteamVR_RequireHmd_String = "requireHmd";
+static const char *const k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver";
+static const char *const k_pch_SteamVR_ForcedHmdKey_String = "forcedHmd";
+static const char *const k_pch_SteamVR_DisplayDebug_Bool = "displayDebug";
+static const char *const k_pch_SteamVR_DebugProcessPipe_String = "debugProcessPipe";
+static const char *const k_pch_SteamVR_DisplayDebugX_Int32 = "displayDebugX";
+static const char *const k_pch_SteamVR_DisplayDebugY_Int32 = "displayDebugY";
+static const char *const k_pch_SteamVR_SendSystemButtonToAllApps_Bool = "sendSystemButtonToAllApps";
+static const char *const k_pch_SteamVR_LogLevel_Int32 = "loglevel";
+static const char *const k_pch_SteamVR_IPD_Float = "ipd";
+static const char *const k_pch_SteamVR_Background_String = "background";
+static const char *const k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection";
+static const char *const k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight";
+static const char *const k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius";
+static const char *const k_pch_SteamVR_GridColor_String = "gridColor";
+static const char *const k_pch_SteamVR_PlayAreaColor_String = "playAreaColor";
+static const char *const k_pch_SteamVR_ShowStage_Bool = "showStage";
+static const char *const k_pch_SteamVR_ActivateMultipleDrivers_Bool = "activateMultipleDrivers";
+static const char *const k_pch_SteamVR_DirectMode_Bool = "directMode";
+static const char *const k_pch_SteamVR_DirectModeEdidVid_Int32 = "directModeEdidVid";
+static const char *const k_pch_SteamVR_DirectModeEdidPid_Int32 = "directModeEdidPid";
+static const char *const k_pch_SteamVR_UsingSpeakers_Bool = "usingSpeakers";
+static const char *const k_pch_SteamVR_SpeakersForwardYawOffsetDegrees_Float = "speakersForwardYawOffsetDegrees";
+static const char *const k_pch_SteamVR_BaseStationPowerManagement_Bool = "basestationPowerManagement";
+static const char *const k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses";
+static const char *const k_pch_SteamVR_SupersampleScale_Float = "supersampleScale";
+static const char *const k_pch_SteamVR_AllowAsyncReprojection_Bool = "allowAsyncReprojection";
+static const char *const k_pch_SteamVR_AllowReprojection_Bool = "allowInterleavedReprojection";
+static const char *const k_pch_SteamVR_ForceReprojection_Bool = "forceReprojection";
+static const char *const k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking";
+static const char *const k_pch_SteamVR_DefaultMirrorView_Int32 = "defaultMirrorView";
+static const char *const k_pch_SteamVR_ShowMirrorView_Bool = "showMirrorView";
+static const char *const k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry";
+static const char *const k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch";
+static const char *const k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch";
+static const char *const k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch";
+static const char *const k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard";
+static const char *const k_pch_SteamVR_EnableHomeApp = "enableHomeApp";
+static const char *const k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec";
+static const char *const k_pch_SteamVR_RetailDemo_Bool = "retailDemo";
+static const char *const k_pch_SteamVR_IpdOffset_Float = "ipdOffset";
+static const char *const k_pch_SteamVR_AllowSupersampleFiltering_Bool = "allowSupersampleFiltering";
+static const char *const k_pch_SteamVR_EnableLinuxVulkanAsync_Bool = "enableLinuxVulkanAsync";
+
+//-----------------------------------------------------------------------------
+// lighthouse keys
+static const char *const k_pch_Lighthouse_Section = "driver_lighthouse";
+static const char *const k_pch_Lighthouse_DisableIMU_Bool = "disableimu";
+static const char *const k_pch_Lighthouse_UseDisambiguation_String = "usedisambiguation";
+static const char *const k_pch_Lighthouse_DisambiguationDebug_Int32 = "disambiguationdebug";
+static const char *const k_pch_Lighthouse_PrimaryBasestation_Int32 = "primarybasestation";
+static const char *const k_pch_Lighthouse_DBHistory_Bool = "dbhistory";
+
+//-----------------------------------------------------------------------------
+// null keys
+static const char *const k_pch_Null_Section = "driver_null";
+static const char *const k_pch_Null_SerialNumber_String = "serialNumber";
+static const char *const k_pch_Null_ModelNumber_String = "modelNumber";
+static const char *const k_pch_Null_WindowX_Int32 = "windowX";
+static const char *const k_pch_Null_WindowY_Int32 = "windowY";
+static const char *const k_pch_Null_WindowWidth_Int32 = "windowWidth";
+static const char *const k_pch_Null_WindowHeight_Int32 = "windowHeight";
+static const char *const k_pch_Null_RenderWidth_Int32 = "renderWidth";
+static const char *const k_pch_Null_RenderHeight_Int32 = "renderHeight";
+static const char *const k_pch_Null_SecondsFromVsyncToPhotons_Float = "secondsFromVsyncToPhotons";
+static const char *const k_pch_Null_DisplayFrequency_Float = "displayFrequency";
+
+//-----------------------------------------------------------------------------
+// user interface keys
+static const char *const k_pch_UserInterface_Section = "userinterface";
+static const char *const k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop";
+static const char *const k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray";
+static const char *const k_pch_UserInterface_Screenshots_Bool = "screenshots";
+static const char *const k_pch_UserInterface_ScreenshotType_Int = "screenshotType";
+
+//-----------------------------------------------------------------------------
+// notification keys
+static const char *const k_pch_Notifications_Section = "notifications";
+static const char *const k_pch_Notifications_DoNotDisturb_Bool = "DoNotDisturb";
+
+//-----------------------------------------------------------------------------
+// keyboard keys
+static const char *const k_pch_Keyboard_Section = "keyboard";
+static const char *const k_pch_Keyboard_TutorialCompletions = "TutorialCompletions";
+static const char *const k_pch_Keyboard_ScaleX = "ScaleX";
+static const char *const k_pch_Keyboard_ScaleY = "ScaleY";
+static const char *const k_pch_Keyboard_OffsetLeftX = "OffsetLeftX";
+static const char *const k_pch_Keyboard_OffsetRightX = "OffsetRightX";
+static const char *const k_pch_Keyboard_OffsetY = "OffsetY";
+static const char *const k_pch_Keyboard_Smoothing = "Smoothing";
+
+//-----------------------------------------------------------------------------
+// perf keys
+static const char *const k_pch_Perf_Section = "perfcheck";
+static const char *const k_pch_Perf_HeuristicActive_Bool = "heuristicActive";
+static const char *const k_pch_Perf_NotifyInHMD_Bool = "warnInHMD";
+static const char *const k_pch_Perf_NotifyOnlyOnce_Bool = "warnOnlyOnce";
+static const char *const k_pch_Perf_AllowTimingStore_Bool = "allowTimingStore";
+static const char *const k_pch_Perf_SaveTimingsOnExit_Bool = "saveTimingsOnExit";
+static const char *const k_pch_Perf_TestData_Float = "perfTestData";
+static const char *const k_pch_Perf_LinuxGPUProfiling_Bool = "linuxGPUProfiling";
+
+//-----------------------------------------------------------------------------
+// collision bounds keys
+static const char *const k_pch_CollisionBounds_Section = "collisionBounds";
+static const char *const k_pch_CollisionBounds_Style_Int32 = "CollisionBoundsStyle";
+static const char *const k_pch_CollisionBounds_GroundPerimeterOn_Bool = "CollisionBoundsGroundPerimeterOn";
+static const char *const k_pch_CollisionBounds_CenterMarkerOn_Bool = "CollisionBoundsCenterMarkerOn";
+static const char *const k_pch_CollisionBounds_PlaySpaceOn_Bool = "CollisionBoundsPlaySpaceOn";
+static const char *const k_pch_CollisionBounds_FadeDistance_Float = "CollisionBoundsFadeDistance";
+static const char *const k_pch_CollisionBounds_ColorGammaR_Int32 = "CollisionBoundsColorGammaR";
+static const char *const k_pch_CollisionBounds_ColorGammaG_Int32 = "CollisionBoundsColorGammaG";
+static const char *const k_pch_CollisionBounds_ColorGammaB_Int32 = "CollisionBoundsColorGammaB";
+static const char *const k_pch_CollisionBounds_ColorGammaA_Int32 = "CollisionBoundsColorGammaA";
+
+//-----------------------------------------------------------------------------
+// camera keys
+static const char *const k_pch_Camera_Section = "camera";
+static const char *const k_pch_Camera_EnableCamera_Bool = "enableCamera";
+static const char *const k_pch_Camera_EnableCameraInDashboard_Bool = "enableCameraInDashboard";
+static const char *const k_pch_Camera_EnableCameraForCollisionBounds_Bool = "enableCameraForCollisionBounds";
+static const char *const k_pch_Camera_EnableCameraForRoomView_Bool = "enableCameraForRoomView";
+static const char *const k_pch_Camera_BoundsColorGammaR_Int32 = "cameraBoundsColorGammaR";
+static const char *const k_pch_Camera_BoundsColorGammaG_Int32 = "cameraBoundsColorGammaG";
+static const char *const k_pch_Camera_BoundsColorGammaB_Int32 = "cameraBoundsColorGammaB";
+static const char *const k_pch_Camera_BoundsColorGammaA_Int32 = "cameraBoundsColorGammaA";
+static const char *const k_pch_Camera_BoundsStrength_Int32 = "cameraBoundsStrength";
+
+//-----------------------------------------------------------------------------
+// audio keys
+static const char *const k_pch_audio_Section = "audio";
+static const char *const k_pch_audio_OnPlaybackDevice_String = "onPlaybackDevice";
+static const char *const k_pch_audio_OnRecordDevice_String = "onRecordDevice";
+static const char *const k_pch_audio_OnPlaybackMirrorDevice_String = "onPlaybackMirrorDevice";
+static const char *const k_pch_audio_OffPlaybackDevice_String = "offPlaybackDevice";
+static const char *const k_pch_audio_OffRecordDevice_String = "offRecordDevice";
+static const char *const k_pch_audio_VIVEHDMIGain = "viveHDMIGain";
+
+//-----------------------------------------------------------------------------
+// power management keys
+static const char *const k_pch_Power_Section = "power";
+static const char *const k_pch_Power_PowerOffOnExit_Bool = "powerOffOnExit";
+static const char *const k_pch_Power_TurnOffScreensTimeout_Float = "turnOffScreensTimeout";
+static const char *const k_pch_Power_TurnOffControllersTimeout_Float = "turnOffControllersTimeout";
+static const char *const k_pch_Power_ReturnToWatchdogTimeout_Float = "returnToWatchdogTimeout";
+static const char *const k_pch_Power_AutoLaunchSteamVROnButtonPress = "autoLaunchSteamVROnButtonPress";
+static const char *const k_pch_Power_PauseCompositorOnStandby_Bool = "pauseCompositorOnStandby";
+
+//-----------------------------------------------------------------------------
+// dashboard keys
+static const char *const k_pch_Dashboard_Section = "dashboard";
+static const char *const k_pch_Dashboard_EnableDashboard_Bool = "enableDashboard";
+static const char *const k_pch_Dashboard_ArcadeMode_Bool = "arcadeMode";
+
+//-----------------------------------------------------------------------------
+// model skin keys
+static const char *const k_pch_modelskin_Section = "modelskins";
+
+//-----------------------------------------------------------------------------
+// driver keys - These could be checked in any driver_<name> section
+static const char *const k_pch_Driver_Enable_Bool = "enable";
+
+}  // namespace vr
+
+// ivrchaperone.h
+namespace vr
+{
+#pragma pack(push, 8)
+
+enum ChaperoneCalibrationState
+{
+	// OK!
+	ChaperoneCalibrationState_OK = 1,  // Chaperone is fully calibrated and working correctly
+
+	// Warnings
+	ChaperoneCalibrationState_Warning = 100,
+	ChaperoneCalibrationState_Warning_BaseStationMayHaveMoved = 101,  // A base station thinks that it might have moved
+	ChaperoneCalibrationState_Warning_BaseStationRemoved = 102,       // There are less base stations than when calibrated
+	ChaperoneCalibrationState_Warning_SeatedBoundsInvalid = 103,      // Seated bounds haven't been calibrated for the current tracking center
+
+	// Errors
+	ChaperoneCalibrationState_Error = 200,                           // The UniverseID is invalid
+	ChaperoneCalibrationState_Error_BaseStationUninitialized = 201,  // Tracking center hasn't be calibrated for at least one of the base stations
+	ChaperoneCalibrationState_Error_BaseStationConflict = 202,       // Tracking center is calibrated, but base stations disagree on the tracking space
+	ChaperoneCalibrationState_Error_PlayAreaInvalid = 203,           // Play Area hasn't been calibrated for the current tracking center
+	ChaperoneCalibrationState_Error_CollisionBoundsInvalid = 204,    // Collision Bounds haven't been calibrated for the current tracking center
+};
+
+/** HIGH LEVEL TRACKING SPACE ASSUMPTIONS:
+* 0,0,0 is the preferred standing area center.
+* 0Y is the floor height.
+* -Z is the preferred forward facing direction. */
+class IVRChaperone
+{
+public:
+	/** Get the current state of Chaperone calibration. This state can change at any time during a session due to physical base station changes. **/
+	virtual ChaperoneCalibrationState GetCalibrationState() = 0;
+
+	/** Returns the width and depth of the Play Area (formerly named Soft Bounds) in X and Z. 
+	* Tracking space center (0,0,0) is the center of the Play Area. **/
+	virtual bool GetPlayAreaSize(float *pSizeX, float *pSizeZ) = 0;
+
+	/** Returns the 4 corner positions of the Play Area (formerly named Soft Bounds).
+	* Corners are in counter-clockwise order.
+	* Standing center (0,0,0) is the center of the Play Area.
+	* It's a rectangle.
+	* 2 sides are parallel to the X axis and 2 sides are parallel to the Z axis.
+	* Height of every corner is 0Y (on the floor). **/
+	virtual bool GetPlayAreaRect(HmdQuad_t *rect) = 0;
+
+	/** Reload Chaperone data from the .vrchap file on disk. */
+	virtual void ReloadInfo(void) = 0;
+
+	/** Optionally give the chaperone system a hit about the color and brightness in the scene **/
+	virtual void SetSceneColor(HmdColor_t color) = 0;
+
+	/** Get the current chaperone bounds draw color and brightness **/
+	virtual void GetBoundsColor(HmdColor_t *pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, HmdColor_t *pOutputCameraColor) = 0;
+
+	/** Determine whether the bounds are showing right now **/
+	virtual bool AreBoundsVisible() = 0;
+
+	/** Force the bounds to show, mostly for utilities **/
+	virtual void ForceBoundsVisible(bool bForce) = 0;
+};
+
+static const char *const IVRChaperone_Version = "IVRChaperone_003";
+
+#pragma pack(pop)
+
+}  // namespace vr
+
+// ivrchaperonesetup.h
+namespace vr
+{
+enum EChaperoneConfigFile
+{
+	EChaperoneConfigFile_Live = 1,  // The live chaperone config, used by most applications and games
+	EChaperoneConfigFile_Temp = 2,  // The temporary chaperone config, used to live-preview collision bounds in room setup
+};
+
+enum EChaperoneImportFlags
+{
+	EChaperoneImport_BoundsOnly = 0x0001,
+};
+
+/** Manages the working copy of the chaperone info. By default this will be the same as the 
+* live copy. Any changes made with this interface will stay in the working copy until 
+* CommitWorkingCopy() is called, at which point the working copy and the live copy will be 
+* the same again. */
+class IVRChaperoneSetup
+{
+public:
+	/** Saves the current working copy to disk */
+	virtual bool CommitWorkingCopy(EChaperoneConfigFile configFile) = 0;
+
+	/** Reverts the working copy to match the live chaperone calibration.
+	* To modify existing data this MUST be do WHILE getting a non-error ChaperoneCalibrationStatus.
+	* Only after this should you do gets and sets on the existing data. */
+	virtual void RevertWorkingCopy() = 0;
+
+	/** Returns the width and depth of the Play Area (formerly named Soft Bounds) in X and Z from the working copy.
+	* Tracking space center (0,0,0) is the center of the Play Area. */
+	virtual bool GetWorkingPlayAreaSize(float *pSizeX, float *pSizeZ) = 0;
+
+	/** Returns the 4 corner positions of the Play Area (formerly named Soft Bounds) from the working copy.
+	* Corners are in clockwise order.
+	* Tracking space center (0,0,0) is the center of the Play Area.
+	* It's a rectangle.
+	* 2 sides are parallel to the X axis and 2 sides are parallel to the Z axis.
+	* Height of every corner is 0Y (on the floor). **/
+	virtual bool GetWorkingPlayAreaRect(HmdQuad_t *rect) = 0;
+
+	/** Returns the number of Quads if the buffer points to null. Otherwise it returns Quads 
+	* into the buffer up to the max specified from the working copy. */
+	virtual bool GetWorkingCollisionBoundsInfo(VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t *punQuadsCount) = 0;
+
+	/** Returns the number of Quads if the buffer points to null. Otherwise it returns Quads 
+	* into the buffer up to the max specified. */
+	virtual bool GetLiveCollisionBoundsInfo(VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t *punQuadsCount) = 0;
+
+	/** Returns the preferred seated position from the working copy. */
+	virtual bool GetWorkingSeatedZeroPoseToRawTrackingPose(HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose) = 0;
+
+	/** Returns the standing origin from the working copy. */
+	virtual bool GetWorkingStandingZeroPoseToRawTrackingPose(HmdMatrix34_t *pmatStandingZeroPoseToRawTrackingPose) = 0;
+
+	/** Sets the Play Area in the working copy. */
+	virtual void SetWorkingPlayAreaSize(float sizeX, float sizeZ) = 0;
+
+	/** Sets the Collision Bounds in the working copy. */
+	virtual void SetWorkingCollisionBoundsInfo(VR_ARRAY_COUNT(unQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t unQuadsCount) = 0;
+
+	/** Sets the preferred seated position in the working copy. */
+	virtual void SetWorkingSeatedZeroPoseToRawTrackingPose(const HmdMatrix34_t *pMatSeatedZeroPoseToRawTrackingPose) = 0;
+
+	/** Sets the preferred standing position in the working copy. */
+	virtual void SetWorkingStandingZeroPoseToRawTrackingPose(const HmdMatrix34_t *pMatStandingZeroPoseToRawTrackingPose) = 0;
+
+	/** Tear everything down and reload it from the file on disk */
+	virtual void ReloadFromDisk(EChaperoneConfigFile configFile) = 0;
+
+	/** Returns the preferred seated position. */
+	virtual bool GetLiveSeatedZeroPoseToRawTrackingPose(HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose) = 0;
+
+	virtual void SetWorkingCollisionBoundsTagsInfo(VR_ARRAY_COUNT(unTagCount) uint8_t *pTagsBuffer, uint32_t unTagCount) = 0;
+	virtual bool GetLiveCollisionBoundsTagsInfo(VR_OUT_ARRAY_COUNT(punTagCount) uint8_t *pTagsBuffer, uint32_t *punTagCount) = 0;
+
+	virtual bool SetWorkingPhysicalBoundsInfo(VR_ARRAY_COUNT(unQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t unQuadsCount) = 0;
+	virtual bool GetLivePhysicalBoundsInfo(VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t *punQuadsCount) = 0;
+
+	virtual bool ExportLiveToBuffer(VR_OUT_STRING() char *pBuffer, uint32_t *pnBufferLength) = 0;
+	virtual bool ImportFromBufferToWorking(const char *pBuffer, uint32_t nImportFlags) = 0;
+};
+
+static const char *const IVRChaperoneSetup_Version = "IVRChaperoneSetup_005";
+
+}  // namespace vr
+
+// ivrcompositor.h
+namespace vr
+{
+#pragma pack(push, 8)
+
+/** Errors that can occur with the VR compositor */
+enum EVRCompositorError
+{
+	VRCompositorError_None = 0,
+	VRCompositorError_RequestFailed = 1,
+	VRCompositorError_IncompatibleVersion = 100,
+	VRCompositorError_DoNotHaveFocus = 101,
+	VRCompositorError_InvalidTexture = 102,
+	VRCompositorError_IsNotSceneApplication = 103,
+	VRCompositorError_TextureIsOnWrongDevice = 104,
+	VRCompositorError_TextureUsesUnsupportedFormat = 105,
+	VRCompositorError_SharedTexturesNotSupported = 106,
+	VRCompositorError_IndexOutOfRange = 107,
+	VRCompositorError_AlreadySubmitted = 108,
+	VRCompositorError_InvalidBounds = 109,
+};
+
+const uint32_t VRCompositor_ReprojectionReason_Cpu = 0x01;
+const uint32_t VRCompositor_ReprojectionReason_Gpu = 0x02;
+const uint32_t VRCompositor_ReprojectionAsync = 0x04;  // This flag indicates the async reprojection mode is active,
+													   // but does not indicate if reprojection actually happened or not.
+													   // Use the ReprojectionReason flags above to check if reprojection
+													   // was actually applied (i.e. scene texture was reused).
+													   // NumFramePresents > 1 also indicates the scene texture was reused,
+													   // and also the number of times that it was presented in total.
+
+/** Provides a single frame's timing information to the app */
+struct Compositor_FrameTiming
+{
+	uint32_t m_nSize;  // Set to sizeof( Compositor_FrameTiming )
+	uint32_t m_nFrameIndex;
+	uint32_t m_nNumFramePresents;  // number of times this frame was presented
+	uint32_t m_nNumMisPresented;   // number of times this frame was presented on a vsync other than it was originally predicted to
+	uint32_t m_nNumDroppedFrames;  // number of additional times previous frame was scanned out
+	uint32_t m_nReprojectionFlags;
+
+	/** Absolute time reference for comparing frames.  This aligns with the vsync that running start is relative to. */
+	double m_flSystemTimeInSeconds;
+
+	/** These times may include work from other processes due to OS scheduling.
+	* The fewer packets of work these are broken up into, the less likely this will happen.
+	* GPU work can be broken up by calling Flush.  This can sometimes be useful to get the GPU started
+	* processing that work earlier in the frame. */
+	float m_flPreSubmitGpuMs;         // time spent rendering the scene (gpu work submitted between WaitGetPoses and second Submit)
+	float m_flPostSubmitGpuMs;        // additional time spent rendering by application (e.g. companion window)
+	float m_flTotalRenderGpuMs;       // time between work submitted immediately after present (ideally vsync) until the end of compositor submitted work
+	float m_flCompositorRenderGpuMs;  // time spend performing distortion correction, rendering chaperone, overlays, etc.
+	float m_flCompositorRenderCpuMs;  // time spent on cpu submitting the above work for this frame
+	float m_flCompositorIdleCpuMs;    // time spent waiting for running start (application could have used this much more time)
+
+	/** Miscellaneous measured intervals. */
+	float m_flClientFrameIntervalMs;  // time between calls to WaitGetPoses
+	float m_flPresentCallCpuMs;       // time blocked on call to present (usually 0.0, but can go long)
+	float m_flWaitForPresentCpuMs;    // time spent spin-waiting for frame index to change (not near-zero indicates wait object failure)
+	float m_flSubmitFrameMs;          // time spent in IVRCompositor::Submit (not near-zero indicates driver issue)
+
+	/** The following are all relative to this frame's SystemTimeInSeconds */
+	float m_flWaitGetPosesCalledMs;
+	float m_flNewPosesReadyMs;
+	float m_flNewFrameReadyMs;  // second call to IVRCompositor::Submit
+	float m_flCompositorUpdateStartMs;
+	float m_flCompositorUpdateEndMs;
+	float m_flCompositorRenderStartMs;
+
+	vr::TrackedDevicePose_t m_HmdPose;  // pose used by app to render this frame
+};
+
+/** Cumulative stats for current application.  These are not cleared until a new app connects,
+* but they do stop accumulating once the associated app disconnects. */
+struct Compositor_CumulativeStats
+{
+	uint32_t m_nPid;                   // Process id associated with these stats (may no longer be running).
+	uint32_t m_nNumFramePresents;      // total number of times we called present (includes reprojected frames)
+	uint32_t m_nNumDroppedFrames;      // total number of times an old frame was re-scanned out (without reprojection)
+	uint32_t m_nNumReprojectedFrames;  // total number of times a frame was scanned out a second time (with reprojection)
+
+	/** Values recorded at startup before application has fully faded in the first time. */
+	uint32_t m_nNumFramePresentsOnStartup;
+	uint32_t m_nNumDroppedFramesOnStartup;
+	uint32_t m_nNumReprojectedFramesOnStartup;
+
+	/** Applications may explicitly fade to the compositor.  This is usually to handle level transitions, and loading often causes
+	* system wide hitches.  The following stats are collected during this period.  Does not include values recorded during startup. */
+	uint32_t m_nNumLoading;
+	uint32_t m_nNumFramePresentsLoading;
+	uint32_t m_nNumDroppedFramesLoading;
+	uint32_t m_nNumReprojectedFramesLoading;
+
+	/** If we don't get a new frame from the app in less than 2.5 frames, then we assume the app has hung and start
+	* fading back to the compositor.  The following stats are a result of this, and are a subset of those recorded above.
+	* Does not include values recorded during start up or loading. */
+	uint32_t m_nNumTimedOut;
+	uint32_t m_nNumFramePresentsTimedOut;
+	uint32_t m_nNumDroppedFramesTimedOut;
+	uint32_t m_nNumReprojectedFramesTimedOut;
+};
+
+#pragma pack(pop)
+
+/** Allows the application to interact with the compositor */
+class IVRCompositor
+{
+public:
+	/** Sets tracking space returned by WaitGetPoses */
+	virtual void SetTrackingSpace(ETrackingUniverseOrigin eOrigin) = 0;
+
+	/** Gets current tracking space returned by WaitGetPoses */
+	virtual ETrackingUniverseOrigin GetTrackingSpace() = 0;
+
+	/** Scene applications should call this function to get poses to render with (and optionally poses predicted an additional frame out to use for gameplay).
+	* This function will block until "running start" milliseconds before the start of the frame, and should be called at the last moment before needing to
+	* start rendering.
+	*
+	* Return codes:
+	*	- IsNotSceneApplication (make sure to call VR_Init with VRApplicaiton_Scene)
+	*	- DoNotHaveFocus (some other app has taken focus - this will throttle the call to 10hz to reduce the impact on that app)
+	*/
+	virtual EVRCompositorError WaitGetPoses(VR_ARRAY_COUNT(unRenderPoseArrayCount) TrackedDevicePose_t *pRenderPoseArray, uint32_t unRenderPoseArrayCount,
+											VR_ARRAY_COUNT(unGamePoseArrayCount) TrackedDevicePose_t *pGamePoseArray, uint32_t unGamePoseArrayCount) = 0;
+
+	/** Get the last set of poses returned by WaitGetPoses. */
+	virtual EVRCompositorError GetLastPoses(VR_ARRAY_COUNT(unRenderPoseArrayCount) TrackedDevicePose_t *pRenderPoseArray, uint32_t unRenderPoseArrayCount,
+											VR_ARRAY_COUNT(unGamePoseArrayCount) TrackedDevicePose_t *pGamePoseArray, uint32_t unGamePoseArrayCount) = 0;
+
+	/** Interface for accessing last set of poses returned by WaitGetPoses one at a time.
+	* Returns VRCompositorError_IndexOutOfRange if unDeviceIndex not less than k_unMaxTrackedDeviceCount otherwise VRCompositorError_None.
+	* It is okay to pass NULL for either pose if you only want one of the values. */
+	virtual EVRCompositorError GetLastPoseForTrackedDeviceIndex(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t *pOutputPose, TrackedDevicePose_t *pOutputGamePose) = 0;
+
+	/** Updated scene texture to display. If pBounds is NULL the entire texture will be used.  If called from an OpenGL app, consider adding a glFlush after
+	* Submitting both frames to signal the driver to start processing, otherwise it may wait until the command buffer fills up, causing the app to miss frames.
+	*
+	* OpenGL dirty state:
+	*	glBindTexture
+	*
+	* Return codes:
+	*	- IsNotSceneApplication (make sure to call VR_Init with VRApplicaiton_Scene)
+	*	- DoNotHaveFocus (some other app has taken focus)
+	*	- TextureIsOnWrongDevice (application did not use proper AdapterIndex - see IVRSystem.GetDXGIOutputInfo)
+	*	- SharedTexturesNotSupported (application needs to call CreateDXGIFactory1 or later before creating DX device)
+	*	- TextureUsesUnsupportedFormat (scene textures must be compatible with DXGI sharing rules - e.g. uncompressed, no mips, etc.)
+	*	- InvalidTexture (usually means bad arguments passed in)
+	*	- AlreadySubmitted (app has submitted two left textures or two right textures in a single frame - i.e. before calling WaitGetPoses again)
+	*/
+	virtual EVRCompositorError Submit(EVREye eEye, const Texture_t *pTexture, const VRTextureBounds_t *pBounds = 0, EVRSubmitFlags nSubmitFlags = Submit_Default) = 0;
+
+	/** Clears the frame that was sent with the last call to Submit. This will cause the 
+	* compositor to show the grid until Submit is called again. */
+	virtual void ClearLastSubmittedFrame() = 0;
+
+	/** Call immediately after presenting your app's window (i.e. companion window) to unblock the compositor.
+	* This is an optional call, which only needs to be used if you can't instead call WaitGetPoses immediately after Present.
+	* For example, if your engine's render and game loop are not on separate threads, or blocking the render thread until 3ms before the next vsync would
+	* introduce a deadlock of some sort.  This function tells the compositor that you have finished all rendering after having Submitted buffers for both
+	* eyes, and it is free to start its rendering work.  This should only be called from the same thread you are rendering on. */
+	virtual void PostPresentHandoff() = 0;
+
+	/** Returns true if timing data is filled it.  Sets oldest timing info if nFramesAgo is larger than the stored history.
+	* Be sure to set timing.size = sizeof(Compositor_FrameTiming) on struct passed in before calling this function. */
+	virtual bool GetFrameTiming(Compositor_FrameTiming *pTiming, uint32_t unFramesAgo = 0) = 0;
+
+	/** Interface for copying a range of timing data.  Frames are returned in ascending order (oldest to newest) with the last being the most recent frame.
+	* Only the first entry's m_nSize needs to be set, as the rest will be inferred from that.  Returns total number of entries filled out. */
+	virtual uint32_t GetFrameTimings(Compositor_FrameTiming *pTiming, uint32_t nFrames) = 0;
+
+	/** Returns the time in seconds left in the current (as identified by FrameTiming's frameIndex) frame.
+	* Due to "running start", this value may roll over to the next frame before ever reaching 0.0. */
+	virtual float GetFrameTimeRemaining() = 0;
+
+	/** Fills out stats accumulated for the last connected application.  Pass in sizeof( Compositor_CumulativeStats ) as second parameter. */
+	virtual void GetCumulativeStats(Compositor_CumulativeStats *pStats, uint32_t nStatsSizeInBytes) = 0;
+
+	/** Fades the view on the HMD to the specified color. The fade will take fSeconds, and the color values are between
+	* 0.0 and 1.0. This color is faded on top of the scene based on the alpha parameter. Removing the fade color instantly 
+	* would be FadeToColor( 0.0, 0.0, 0.0, 0.0, 0.0 ).  Values are in un-premultiplied alpha space. */
+	virtual void FadeToColor(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground = false) = 0;
+
+	/** Get current fade color value. */
+	virtual HmdColor_t GetCurrentFadeColor(bool bBackground = false) = 0;
+
+	/** Fading the Grid in or out in fSeconds */
+	virtual void FadeGrid(float fSeconds, bool bFadeIn) = 0;
+
+	/** Get current alpha value of grid. */
+	virtual float GetCurrentGridAlpha() = 0;
+
+	/** Override the skybox used in the compositor (e.g. for during level loads when the app can't feed scene images fast enough)
+	* Order is Front, Back, Left, Right, Top, Bottom.  If only a single texture is passed, it is assumed in lat-long format.
+	* If two are passed, it is assumed a lat-long stereo pair. */
+	virtual EVRCompositorError SetSkyboxOverride(VR_ARRAY_COUNT(unTextureCount) const Texture_t *pTextures, uint32_t unTextureCount) = 0;
+
+	/** Resets compositor skybox back to defaults. */
+	virtual void ClearSkyboxOverride() = 0;
+
+	/** Brings the compositor window to the front. This is useful for covering any other window that may be on the HMD
+	* and is obscuring the compositor window. */
+	virtual void CompositorBringToFront() = 0;
+
+	/** Pushes the compositor window to the back. This is useful for allowing other applications to draw directly to the HMD. */
+	virtual void CompositorGoToBack() = 0;
+
+	/** Tells the compositor process to clean up and exit. You do not need to call this function at shutdown. Under normal 
+	* circumstances the compositor will manage its own life cycle based on what applications are running. */
+	virtual void CompositorQuit() = 0;
+
+	/** Return whether the compositor is fullscreen */
+	virtual bool IsFullscreen() = 0;
+
+	/** Returns the process ID of the process that is currently rendering the scene */
+	virtual uint32_t GetCurrentSceneFocusProcess() = 0;
+
+	/** Returns the process ID of the process that rendered the last frame (or 0 if the compositor itself rendered the frame.)
+	* Returns 0 when fading out from an app and the app's process Id when fading into an app. */
+	virtual uint32_t GetLastFrameRenderer() = 0;
+
+	/** Returns true if the current process has the scene focus */
+	virtual bool CanRenderScene() = 0;
+
+	/** Creates a window on the primary monitor to display what is being shown in the headset. */
+	virtual void ShowMirrorWindow() = 0;
+
+	/** Closes the mirror window. */
+	virtual void HideMirrorWindow() = 0;
+
+	/** Returns true if the mirror window is shown. */
+	virtual bool IsMirrorWindowVisible() = 0;
+
+	/** Writes all images that the compositor knows about (including overlays) to a 'screenshots' folder in the SteamVR runtime root. */
+	virtual void CompositorDumpImages() = 0;
+
+	/** Let an app know it should be rendering with low resources. */
+	virtual bool ShouldAppRenderWithLowResources() = 0;
+
+	/** Override interleaved reprojection logic to force on. */
+	virtual void ForceInterleavedReprojectionOn(bool bOverride) = 0;
+
+	/** Force reconnecting to the compositor process. */
+	virtual void ForceReconnectProcess() = 0;
+
+	/** Temporarily suspends rendering (useful for finer control over scene transitions). */
+	virtual void SuspendRendering(bool bSuspend) = 0;
+
+	/** Opens a shared D3D11 texture with the undistorted composited image for each eye.  Use ReleaseMirrorTextureD3D11 when finished
+	* instead of calling Release on the resource itself. */
+	virtual vr::EVRCompositorError GetMirrorTextureD3D11(vr::EVREye eEye, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView) = 0;
+	virtual void ReleaseMirrorTextureD3D11(void *pD3D11ShaderResourceView) = 0;
+
+	/** Access to mirror textures from OpenGL. */
+	virtual vr::EVRCompositorError GetMirrorTextureGL(vr::EVREye eEye, vr::glUInt_t *pglTextureId, vr::glSharedTextureHandle_t *pglSharedTextureHandle) = 0;
+	virtual bool ReleaseSharedGLTexture(vr::glUInt_t glTextureId, vr::glSharedTextureHandle_t glSharedTextureHandle) = 0;
+	virtual void LockGLSharedTextureForAccess(vr::glSharedTextureHandle_t glSharedTextureHandle) = 0;
+	virtual void UnlockGLSharedTextureForAccess(vr::glSharedTextureHandle_t glSharedTextureHandle) = 0;
+
+	/** [Vulkan Only]
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null.  The string will be a space separated list of-required instance extensions to enable in VkCreateInstance */
+	virtual uint32_t GetVulkanInstanceExtensionsRequired(VR_OUT_STRING() char *pchValue, uint32_t unBufferSize) = 0;
+
+	/** [Vulkan only]
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null.  The string will be a space separated list of required device extensions to enable in VkCreateDevice */
+	virtual uint32_t GetVulkanDeviceExtensionsRequired(VkPhysicalDevice_T *pPhysicalDevice, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize) = 0;
+
+	/** [ Vulkan/D3D12 Only ]
+	* There are two purposes for SetExplicitTimingMode:
+	*	1. To get a more accurate GPU timestamp for when the frame begins in Vulkan/D3D12 applications.
+	*	2. (Optional) To avoid having WaitGetPoses access the Vulkan queue so that the queue can be accessed from
+	*	another thread while WaitGetPoses is executing.
+	*
+	* More accurate GPU timestamp for the start of the frame is achieved by the application calling
+	* SubmitExplicitTimingData immediately before its first submission to the Vulkan/D3D12 queue.
+	* This is more accurate because normally this GPU timestamp is recorded during WaitGetPoses.  In D3D11, 
+	* WaitGetPoses queues a GPU timestamp write, but it does not actually get submitted to the GPU until the 
+	* application flushes.  By using SubmitExplicitTimingData, the timestamp is recorded at the same place for 
+	* Vulkan/D3D12 as it is for D3D11, resulting in a more accurate GPU time measurement for the frame.
+	*
+	* Avoiding WaitGetPoses accessing the Vulkan queue can be achieved using SetExplicitTimingMode as well.  If this is desired,
+	* the application *MUST* call PostPresentHandoff itself prior to WaitGetPoses.  If SetExplicitTimingMode is true and the
+	* application calls PostPresentHandoff, then WaitGetPoses is guaranteed not to access the queue.  Note that PostPresentHandoff
+	* and SubmitExplicitTimingData will access the queue, so only WaitGetPoses becomes safe for accessing the queue from another
+	* thread. */
+	virtual void SetExplicitTimingMode(bool bExplicitTimingMode) = 0;
+
+	/** [ Vulkan/D3D12 Only ]
+	* Submit explicit timing data.  When SetExplicitTimingMode is true, this must be called immediately before
+	* the application's first vkQueueSubmit (Vulkan) or ID3D12CommandQueue::ExecuteCommandLists (D3D12) of each frame.
+	* This function will insert a GPU timestamp write just before the application starts its rendering.  This function
+	* will perform a vkQueueSubmit on Vulkan so must not be done simultaneously with VkQueue operations on another thread.
+	* Returns VRCompositorError_RequestFailed if SetExplicitTimingMode is not enabled. */
+	virtual EVRCompositorError SubmitExplicitTimingData() = 0;
+};
+
+static const char *const IVRCompositor_Version = "IVRCompositor_021";
+
+}  // namespace vr
+
+// ivrnotifications.h
+namespace vr
+{
+#pragma pack(push, 8)
+
+// Used for passing graphic data
+struct NotificationBitmap_t
+{
+	NotificationBitmap_t()
+		: m_pImageData(nullptr), m_nWidth(0), m_nHeight(0), m_nBytesPerPixel(0){};
+
+	void *m_pImageData;
+	int32_t m_nWidth;
+	int32_t m_nHeight;
+	int32_t m_nBytesPerPixel;
+};
+
+/** Be aware that the notification type is used as 'priority' to pick the next notification */
+enum EVRNotificationType
+{
+	/** Transient notifications are automatically hidden after a period of time set by the user. 
+	* They are used for things like information and chat messages that do not require user interaction. */
+	EVRNotificationType_Transient = 0,
+
+	/** Persistent notifications are shown to the user until they are hidden by calling RemoveNotification().
+	* They are used for things like phone calls and alarms that require user interaction. */
+	EVRNotificationType_Persistent = 1,
+
+	/** System notifications are shown no matter what. It is expected, that the ulUserValue is used as ID.
+	 * If there is already a system notification in the queue with that ID it is not accepted into the queue
+	 * to prevent spamming with system notification */
+	EVRNotificationType_Transient_SystemWithUserValue = 2,
+};
+
+enum EVRNotificationStyle
+{
+	/** Creates a notification with minimal external styling. */
+	EVRNotificationStyle_None = 0,
+
+	/** Used for notifications about overlay-level status. In Steam this is used for events like downloads completing. */
+	EVRNotificationStyle_Application = 100,
+
+	/** Used for notifications about contacts that are unknown or not available. In Steam this is used for friend invitations and offline friends. */
+	EVRNotificationStyle_Contact_Disabled = 200,
+
+	/** Used for notifications about contacts that are available but inactive. In Steam this is used for friends that are online but not playing a game. */
+	EVRNotificationStyle_Contact_Enabled = 201,
+
+	/** Used for notifications about contacts that are available and active. In Steam this is used for friends that are online and currently running a game. */
+	EVRNotificationStyle_Contact_Active = 202,
+};
+
+static const uint32_t k_unNotificationTextMaxSize = 256;
+
+typedef uint32_t VRNotificationId;
+
+#pragma pack(pop)
+
+/** Allows notification sources to interact with the VR system
+	This current interface is not yet implemented. Do not use yet. */
+class IVRNotifications
+{
+public:
+	/** Create a notification and enqueue it to be shown to the user.
+	* An overlay handle is required to create a notification, as otherwise it would be impossible for a user to act on it.
+	* To create a two-line notification, use a line break ('\n') to split the text into two lines.
+	* The pImage argument may be NULL, in which case the specified overlay's icon will be used instead. */
+	virtual EVRNotificationError CreateNotification(VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, EVRNotificationType type, const char *pchText, EVRNotificationStyle style, const NotificationBitmap_t *pImage, /* out */ VRNotificationId *pNotificationId) = 0;
+
+	/** Destroy a notification, hiding it first if it currently shown to the user. */
+	virtual EVRNotificationError RemoveNotification(VRNotificationId notificationId) = 0;
+};
+
+static const char *const IVRNotifications_Version = "IVRNotifications_002";
+
+}  // namespace vr
+
+// ivroverlay.h
+namespace vr
+{
+/** The maximum length of an overlay key in bytes, counting the terminating null character. */
+static const uint32_t k_unVROverlayMaxKeyLength = 128;
+
+/** The maximum length of an overlay name in bytes, counting the terminating null character. */
+static const uint32_t k_unVROverlayMaxNameLength = 128;
+
+/** The maximum number of overlays that can exist in the system at one time. */
+static const uint32_t k_unMaxOverlayCount = 64;
+
+/** The maximum number of overlay intersection mask primitives per overlay */
+static const uint32_t k_unMaxOverlayIntersectionMaskPrimitivesCount = 32;
+
+/** Types of input supported by VR Overlays */
+enum VROverlayInputMethod
+{
+	VROverlayInputMethod_None = 0,   // No input events will be generated automatically for this overlay
+	VROverlayInputMethod_Mouse = 1,  // Tracked controllers will get mouse events automatically
+};
+
+/** Allows the caller to figure out which overlay transform getter to call. */
+enum VROverlayTransformType
+{
+	VROverlayTransform_Absolute = 0,
+	VROverlayTransform_TrackedDeviceRelative = 1,
+	VROverlayTransform_SystemOverlay = 2,
+	VROverlayTransform_TrackedComponent = 3,
+};
+
+/** Overlay control settings */
+enum VROverlayFlags
+{
+	VROverlayFlags_None = 0,
+
+	// The following only take effect when rendered using the high quality render path (see SetHighQualityOverlay).
+	VROverlayFlags_Curved = 1,
+	VROverlayFlags_RGSS4X = 2,
+
+	// Set this flag on a dashboard overlay to prevent a tab from showing up for that overlay
+	VROverlayFlags_NoDashboardTab = 3,
+
+	// Set this flag on a dashboard that is able to deal with gamepad focus events
+	VROverlayFlags_AcceptsGamepadEvents = 4,
+
+	// Indicates that the overlay should dim/brighten to show gamepad focus
+	VROverlayFlags_ShowGamepadFocus = 5,
+
+	// When in VROverlayInputMethod_Mouse you can optionally enable sending VRScroll_t
+	VROverlayFlags_SendVRScrollEvents = 6,
+	VROverlayFlags_SendVRTouchpadEvents = 7,
+
+	// If set this will render a vertical scroll wheel on the primary controller,
+	//  only needed if not using VROverlayFlags_SendVRScrollEvents but you still want to represent a scroll wheel
+	VROverlayFlags_ShowTouchPadScrollWheel = 8,
+
+	// If this is set ownership and render access to the overlay are transferred
+	// to the new scene process on a call to IVRApplications::LaunchInternalProcess
+	VROverlayFlags_TransferOwnershipToInternalProcess = 9,
+
+	// If set, renders 50% of the texture in each eye, side by side
+	VROverlayFlags_SideBySide_Parallel = 10,  // Texture is left/right
+	VROverlayFlags_SideBySide_Crossed = 11,   // Texture is crossed and right/left
+
+	VROverlayFlags_Panorama = 12,        // Texture is a panorama
+	VROverlayFlags_StereoPanorama = 13,  // Texture is a stereo panorama
+
+	// If this is set on an overlay owned by the scene application that overlay
+	// will be sorted with the "Other" overlays on top of all other scene overlays
+	VROverlayFlags_SortWithNonSceneOverlays = 14,
+
+	// If set, the overlay will be shown in the dashboard, otherwise it will be hidden.
+	VROverlayFlags_VisibleInDashboard = 15,
+};
+
+enum VRMessageOverlayResponse
+{
+	VRMessageOverlayResponse_ButtonPress_0 = 0,
+	VRMessageOverlayResponse_ButtonPress_1 = 1,
+	VRMessageOverlayResponse_ButtonPress_2 = 2,
+	VRMessageOverlayResponse_ButtonPress_3 = 3,
+	VRMessageOverlayResponse_CouldntFindSystemOverlay = 4,
+	VRMessageOverlayResponse_CouldntFindOrCreateClientOverlay = 5,
+	VRMessageOverlayResponse_ApplicationQuit = 6
+};
+
+struct VROverlayIntersectionParams_t
+{
+	HmdVector3_t vSource;
+	HmdVector3_t vDirection;
+	ETrackingUniverseOrigin eOrigin;
+};
+
+struct VROverlayIntersectionResults_t
+{
+	HmdVector3_t vPoint;
+	HmdVector3_t vNormal;
+	HmdVector2_t vUVs;
+	float fDistance;
+};
+
+// Input modes for the Big Picture gamepad text entry
+enum EGamepadTextInputMode
+{
+	k_EGamepadTextInputModeNormal = 0,
+	k_EGamepadTextInputModePassword = 1,
+	k_EGamepadTextInputModeSubmit = 2,
+};
+
+// Controls number of allowed lines for the Big Picture gamepad text entry
+enum EGamepadTextInputLineMode
+{
+	k_EGamepadTextInputLineModeSingleLine = 0,
+	k_EGamepadTextInputLineModeMultipleLines = 1
+};
+
+/** Directions for changing focus between overlays with the gamepad */
+enum EOverlayDirection
+{
+	OverlayDirection_Up = 0,
+	OverlayDirection_Down = 1,
+	OverlayDirection_Left = 2,
+	OverlayDirection_Right = 3,
+
+	OverlayDirection_Count = 4,
+};
+
+enum EVROverlayIntersectionMaskPrimitiveType
+{
+	OverlayIntersectionPrimitiveType_Rectangle,
+	OverlayIntersectionPrimitiveType_Circle,
+};
+
+struct IntersectionMaskRectangle_t
+{
+	float m_flTopLeftX;
+	float m_flTopLeftY;
+	float m_flWidth;
+	float m_flHeight;
+};
+
+struct IntersectionMaskCircle_t
+{
+	float m_flCenterX;
+	float m_flCenterY;
+	float m_flRadius;
+};
+
+/** NOTE!!! If you change this you MUST manually update openvr_interop.cs.py and openvr_api_flat.h.py */
+typedef union {
+	IntersectionMaskRectangle_t m_Rectangle;
+	IntersectionMaskCircle_t m_Circle;
+} VROverlayIntersectionMaskPrimitive_Data_t;
+
+struct VROverlayIntersectionMaskPrimitive_t
+{
+	EVROverlayIntersectionMaskPrimitiveType m_nPrimitiveType;
+	VROverlayIntersectionMaskPrimitive_Data_t m_Primitive;
+};
+
+class IVROverlay
+{
+public:
+	// ---------------------------------------------
+	// Overlay management methods
+	// ---------------------------------------------
+
+	/** Finds an existing overlay with the specified key. */
+	virtual EVROverlayError FindOverlay(const char *pchOverlayKey, VROverlayHandle_t *pOverlayHandle) = 0;
+
+	/** Creates a new named overlay. All overlays start hidden and with default settings. */
+	virtual EVROverlayError CreateOverlay(const char *pchOverlayKey, const char *pchOverlayName, VROverlayHandle_t *pOverlayHandle) = 0;
+
+	/** Destroys the specified overlay. When an application calls VR_Shutdown all overlays created by that app are
+		* automatically destroyed. */
+	virtual EVROverlayError DestroyOverlay(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Specify which overlay to use the high quality render path.  This overlay will be composited in during the distortion pass which
+		* results in it drawing on top of everything else, but also at a higher quality as it samples the source texture directly rather than
+		* rasterizing into each eye's render texture first.  Because if this, only one of these is supported at any given time.  It is most useful
+		* for overlays that are expected to take up most of the user's view (e.g. streaming video).
+		* This mode does not support mouse input to your overlay. */
+	virtual EVROverlayError SetHighQualityOverlay(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Returns the overlay handle of the current overlay being rendered using the single high quality overlay render path.
+		* Otherwise it will return k_ulOverlayHandleInvalid. */
+	virtual vr::VROverlayHandle_t GetHighQualityOverlay() = 0;
+
+	/** Fills the provided buffer with the string key of the overlay. Returns the size of buffer required to store the key, including
+		* the terminating null character. k_unVROverlayMaxKeyLength will be enough bytes to fit the string. */
+	virtual uint32_t GetOverlayKey(VROverlayHandle_t ulOverlayHandle, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, EVROverlayError *pError = 0L) = 0;
+
+	/** Fills the provided buffer with the friendly name of the overlay. Returns the size of buffer required to store the key, including
+		* the terminating null character. k_unVROverlayMaxNameLength will be enough bytes to fit the string. */
+	virtual uint32_t GetOverlayName(VROverlayHandle_t ulOverlayHandle, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, EVROverlayError *pError = 0L) = 0;
+
+	/** set the name to use for this overlay */
+	virtual EVROverlayError SetOverlayName(VROverlayHandle_t ulOverlayHandle, const char *pchName) = 0;
+
+	/** Gets the raw image data from an overlay. Overlay image data is always returned as RGBA data, 4 bytes per pixel. If the buffer is not large enough, width and height 
+		* will be set and VROverlayError_ArrayTooSmall is returned. */
+	virtual EVROverlayError GetOverlayImageData(VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unBufferSize, uint32_t *punWidth, uint32_t *punHeight) = 0;
+
+	/** returns a string that corresponds with the specified overlay error. The string will be the name 
+		* of the error enum value for all valid error codes */
+	virtual const char *GetOverlayErrorNameFromEnum(EVROverlayError error) = 0;
+
+	// ---------------------------------------------
+	// Overlay rendering methods
+	// ---------------------------------------------
+
+	/** Sets the pid that is allowed to render to this overlay (the creator pid is always allow to render),
+		*	by default this is the pid of the process that made the overlay */
+	virtual EVROverlayError SetOverlayRenderingPid(VROverlayHandle_t ulOverlayHandle, uint32_t unPID) = 0;
+
+	/** Gets the pid that is allowed to render to this overlay */
+	virtual uint32_t GetOverlayRenderingPid(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Specify flag setting for a given overlay */
+	virtual EVROverlayError SetOverlayFlag(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = 0;
+
+	/** Sets flag setting for a given overlay */
+	virtual EVROverlayError GetOverlayFlag(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool *pbEnabled) = 0;
+
+	/** Sets the color tint of the overlay quad. Use 0.0 to 1.0 per channel. */
+	virtual EVROverlayError SetOverlayColor(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = 0;
+
+	/** Gets the color tint of the overlay quad. */
+	virtual EVROverlayError GetOverlayColor(VROverlayHandle_t ulOverlayHandle, float *pfRed, float *pfGreen, float *pfBlue) = 0;
+
+	/** Sets the alpha of the overlay quad. Use 1.0 for 100 percent opacity to 0.0 for 0 percent opacity. */
+	virtual EVROverlayError SetOverlayAlpha(VROverlayHandle_t ulOverlayHandle, float fAlpha) = 0;
+
+	/** Gets the alpha of the overlay quad. By default overlays are rendering at 100 percent alpha (1.0). */
+	virtual EVROverlayError GetOverlayAlpha(VROverlayHandle_t ulOverlayHandle, float *pfAlpha) = 0;
+
+	/** Sets the aspect ratio of the texels in the overlay. 1.0 means the texels are square. 2.0 means the texels
+		* are twice as wide as they are tall. Defaults to 1.0. */
+	virtual EVROverlayError SetOverlayTexelAspect(VROverlayHandle_t ulOverlayHandle, float fTexelAspect) = 0;
+
+	/** Gets the aspect ratio of the texels in the overlay. Defaults to 1.0 */
+	virtual EVROverlayError GetOverlayTexelAspect(VROverlayHandle_t ulOverlayHandle, float *pfTexelAspect) = 0;
+
+	/** Sets the rendering sort order for the overlay. Overlays are rendered this order:
+		*      Overlays owned by the scene application
+		*      Overlays owned by some other application
+		*
+		*	Within a category overlays are rendered lowest sort order to highest sort order. Overlays with the same 
+		*	sort order are rendered back to front base on distance from the HMD.
+		*
+		*	Sort order defaults to 0. */
+	virtual EVROverlayError SetOverlaySortOrder(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder) = 0;
+
+	/** Gets the sort order of the overlay. See SetOverlaySortOrder for how this works. */
+	virtual EVROverlayError GetOverlaySortOrder(VROverlayHandle_t ulOverlayHandle, uint32_t *punSortOrder) = 0;
+
+	/** Sets the width of the overlay quad in meters. By default overlays are rendered on a quad that is 1 meter across */
+	virtual EVROverlayError SetOverlayWidthInMeters(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = 0;
+
+	/** Returns the width of the overlay quad in meters. By default overlays are rendered on a quad that is 1 meter across */
+	virtual EVROverlayError GetOverlayWidthInMeters(VROverlayHandle_t ulOverlayHandle, float *pfWidthInMeters) = 0;
+
+	/** For high-quality curved overlays only, sets the distance range in meters from the overlay used to automatically curve
+		* the surface around the viewer.  Min is distance is when the surface will be most curved.  Max is when least curved. */
+	virtual EVROverlayError SetOverlayAutoCurveDistanceRangeInMeters(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = 0;
+
+	/** For high-quality curved overlays only, gets the distance range in meters from the overlay used to automatically curve
+		* the surface around the viewer.  Min is distance is when the surface will be most curved.  Max is when least curved. */
+	virtual EVROverlayError GetOverlayAutoCurveDistanceRangeInMeters(VROverlayHandle_t ulOverlayHandle, float *pfMinDistanceInMeters, float *pfMaxDistanceInMeters) = 0;
+
+	/** Sets the colorspace the overlay texture's data is in.  Defaults to 'auto'.
+		* If the texture needs to be resolved, you should call SetOverlayTexture with the appropriate colorspace instead. */
+	virtual EVROverlayError SetOverlayTextureColorSpace(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = 0;
+
+	/** Gets the overlay's current colorspace setting. */
+	virtual EVROverlayError GetOverlayTextureColorSpace(VROverlayHandle_t ulOverlayHandle, EColorSpace *peTextureColorSpace) = 0;
+
+	/** Sets the part of the texture to use for the overlay. UV Min is the upper left corner and UV Max is the lower right corner. */
+	virtual EVROverlayError SetOverlayTextureBounds(VROverlayHandle_t ulOverlayHandle, const VRTextureBounds_t *pOverlayTextureBounds) = 0;
+
+	/** Gets the part of the texture to use for the overlay. UV Min is the upper left corner and UV Max is the lower right corner. */
+	virtual EVROverlayError GetOverlayTextureBounds(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t *pOverlayTextureBounds) = 0;
+
+	/** Gets render model to draw behind this overlay */
+	virtual uint32_t GetOverlayRenderModel(vr::VROverlayHandle_t ulOverlayHandle, char *pchValue, uint32_t unBufferSize, HmdColor_t *pColor, vr::EVROverlayError *pError) = 0;
+
+	/** Sets render model to draw behind this overlay and the vertex color to use, pass null for pColor to match the overlays vertex color. 
+			The model is scaled by the same amount as the overlay, with a default of 1m. */
+	virtual vr::EVROverlayError SetOverlayRenderModel(vr::VROverlayHandle_t ulOverlayHandle, const char *pchRenderModel, const HmdColor_t *pColor) = 0;
+
+	/** Returns the transform type of this overlay. */
+	virtual EVROverlayError GetOverlayTransformType(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType *peTransformType) = 0;
+
+	/** Sets the transform to absolute tracking origin. */
+	virtual EVROverlayError SetOverlayTransformAbsolute(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, const HmdMatrix34_t *pmatTrackingOriginToOverlayTransform) = 0;
+
+	/** Gets the transform if it is absolute. Returns an error if the transform is some other type. */
+	virtual EVROverlayError GetOverlayTransformAbsolute(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin *peTrackingOrigin, HmdMatrix34_t *pmatTrackingOriginToOverlayTransform) = 0;
+
+	/** Sets the transform to relative to the transform of the specified tracked device. */
+	virtual EVROverlayError SetOverlayTransformTrackedDeviceRelative(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, const HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform) = 0;
+
+	/** Gets the transform if it is relative to a tracked device. Returns an error if the transform is some other type. */
+	virtual EVROverlayError GetOverlayTransformTrackedDeviceRelative(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punTrackedDevice, HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform) = 0;
+
+	/** Sets the transform to draw the overlay on a rendermodel component mesh instead of a quad. This will only draw when the system is
+		* drawing the device. Overlays with this transform type cannot receive mouse events. */
+	virtual EVROverlayError SetOverlayTransformTrackedDeviceComponent(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char *pchComponentName) = 0;
+
+	/** Gets the transform information when the overlay is rendering on a component. */
+	virtual EVROverlayError GetOverlayTransformTrackedDeviceComponent(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punDeviceIndex, char *pchComponentName, uint32_t unComponentNameSize) = 0;
+
+	/** Gets the transform if it is relative to another overlay. Returns an error if the transform is some other type. */
+	virtual vr::EVROverlayError GetOverlayTransformOverlayRelative(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t *ulOverlayHandleParent, HmdMatrix34_t *pmatParentOverlayToOverlayTransform) = 0;
+
+	/** Sets the transform to relative to the transform of the specified overlay. This overlays visibility will also track the parents visibility */
+	virtual vr::EVROverlayError SetOverlayTransformOverlayRelative(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, const HmdMatrix34_t *pmatParentOverlayToOverlayTransform) = 0;
+
+	/** Shows the VR overlay.  For dashboard overlays, only the Dashboard Manager is allowed to call this. */
+	virtual EVROverlayError ShowOverlay(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Hides the VR overlay.  For dashboard overlays, only the Dashboard Manager is allowed to call this. */
+	virtual EVROverlayError HideOverlay(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Returns true if the overlay is visible. */
+	virtual bool IsOverlayVisible(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Get the transform in 3d space associated with a specific 2d point in the overlay's coordinate space (where 0,0 is the lower left). -Z points out of the overlay */
+	virtual EVROverlayError GetTransformForOverlayCoordinates(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t *pmatTransform) = 0;
+
+	// ---------------------------------------------
+	// Overlay input methods
+	// ---------------------------------------------
+
+	/** Returns true and fills the event with the next event on the overlay's event queue, if there is one. 
+		* If there are no events this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct */
+	virtual bool PollNextOverlayEvent(VROverlayHandle_t ulOverlayHandle, VREvent_t *pEvent, uint32_t uncbVREvent) = 0;
+
+	/** Returns the current input settings for the specified overlay. */
+	virtual EVROverlayError GetOverlayInputMethod(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod *peInputMethod) = 0;
+
+	/** Sets the input settings for the specified overlay. */
+	virtual EVROverlayError SetOverlayInputMethod(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = 0;
+
+	/** Gets the mouse scaling factor that is used for mouse events. The actual texture may be a different size, but this is
+		* typically the size of the underlying UI in pixels. */
+	virtual EVROverlayError GetOverlayMouseScale(VROverlayHandle_t ulOverlayHandle, HmdVector2_t *pvecMouseScale) = 0;
+
+	/** Sets the mouse scaling factor that is used for mouse events. The actual texture may be a different size, but this is
+		* typically the size of the underlying UI in pixels (not in world space). */
+	virtual EVROverlayError SetOverlayMouseScale(VROverlayHandle_t ulOverlayHandle, const HmdVector2_t *pvecMouseScale) = 0;
+
+	/** Computes the overlay-space pixel coordinates of where the ray intersects the overlay with the
+		* specified settings. Returns false if there is no intersection. */
+	virtual bool ComputeOverlayIntersection(VROverlayHandle_t ulOverlayHandle, const VROverlayIntersectionParams_t *pParams, VROverlayIntersectionResults_t *pResults) = 0;
+
+	/** Processes mouse input from the specified controller as though it were a mouse pointed at a compositor overlay with the
+		* specified settings. The controller is treated like a laser pointer on the -z axis. The point where the laser pointer would
+		* intersect with the overlay is the mouse position, the trigger is left mouse, and the track pad is right mouse. 
+		*
+		* Return true if the controller is pointed at the overlay and an event was generated. */
+	virtual bool HandleControllerOverlayInteractionAsMouse(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = 0;
+
+	/** Returns true if the specified overlay is the hover target. An overlay is the hover target when it is the last overlay "moused over" 
+		* by the virtual mouse pointer */
+	virtual bool IsHoverTargetOverlay(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Returns the current Gamepad focus overlay */
+	virtual vr::VROverlayHandle_t GetGamepadFocusOverlay() = 0;
+
+	/** Sets the current Gamepad focus overlay */
+	virtual EVROverlayError SetGamepadFocusOverlay(VROverlayHandle_t ulNewFocusOverlay) = 0;
+
+	/** Sets an overlay's neighbor. This will also set the neighbor of the "to" overlay
+		* to point back to the "from" overlay. If an overlay's neighbor is set to invalid both
+		* ends will be cleared */
+	virtual EVROverlayError SetOverlayNeighbor(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo) = 0;
+
+	/** Changes the Gamepad focus from one overlay to one of its neighbors. Returns VROverlayError_NoNeighbor if there is no
+		* neighbor in that direction */
+	virtual EVROverlayError MoveGamepadFocusToNeighbor(EOverlayDirection eDirection, VROverlayHandle_t ulFrom) = 0;
+
+	// ---------------------------------------------
+	// Overlay texture methods
+	// ---------------------------------------------
+
+	/** Texture to draw for the overlay. This function can only be called by the overlay's creator or renderer process (see SetOverlayRenderingPid) .
+		*
+		* OpenGL dirty state:
+		*	glBindTexture
+		*/
+	virtual EVROverlayError SetOverlayTexture(VROverlayHandle_t ulOverlayHandle, const Texture_t *pTexture) = 0;
+
+	/** Use this to tell the overlay system to release the texture set for this overlay. */
+	virtual EVROverlayError ClearOverlayTexture(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Separate interface for providing the data as a stream of bytes, but there is an upper bound on data 
+		* that can be sent. This function can only be called by the overlay's renderer process. */
+	virtual EVROverlayError SetOverlayRaw(VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = 0;
+
+	/** Separate interface for providing the image through a filename: can be png or jpg, and should not be bigger than 1920x1080.
+		* This function can only be called by the overlay's renderer process */
+	virtual EVROverlayError SetOverlayFromFile(VROverlayHandle_t ulOverlayHandle, const char *pchFilePath) = 0;
+
+	/** Get the native texture handle/device for an overlay you have created.
+		* On windows this handle will be a ID3D11ShaderResourceView with a ID3D11Texture2D bound.
+		*
+		* The texture will always be sized to match the backing texture you supplied in SetOverlayTexture above.
+		*
+		* You MUST call ReleaseNativeOverlayHandle() with pNativeTextureHandle once you are done with this texture.
+		*
+		* pNativeTextureHandle is an OUTPUT, it will be a pointer to a ID3D11ShaderResourceView *.
+		* pNativeTextureRef is an INPUT and should be a ID3D11Resource *. The device used by pNativeTextureRef will be used to bind pNativeTextureHandle.
+		*/
+	virtual EVROverlayError GetOverlayTexture(VROverlayHandle_t ulOverlayHandle, void **pNativeTextureHandle, void *pNativeTextureRef, uint32_t *pWidth, uint32_t *pHeight, uint32_t *pNativeFormat, ETextureType *pAPIType, EColorSpace *pColorSpace, VRTextureBounds_t *pTextureBounds) = 0;
+
+	/** Release the pNativeTextureHandle provided from the GetOverlayTexture call, this allows the system to free the underlying GPU resources for this object,
+		* so only do it once you stop rendering this texture.
+		*/
+	virtual EVROverlayError ReleaseNativeOverlayHandle(VROverlayHandle_t ulOverlayHandle, void *pNativeTextureHandle) = 0;
+
+	/** Get the size of the overlay texture */
+	virtual EVROverlayError GetOverlayTextureSize(VROverlayHandle_t ulOverlayHandle, uint32_t *pWidth, uint32_t *pHeight) = 0;
+
+	// ----------------------------------------------
+	// Dashboard Overlay Methods
+	// ----------------------------------------------
+
+	/** Creates a dashboard overlay and returns its handle */
+	virtual EVROverlayError CreateDashboardOverlay(const char *pchOverlayKey, const char *pchOverlayFriendlyName, VROverlayHandle_t *pMainHandle, VROverlayHandle_t *pThumbnailHandle) = 0;
+
+	/** Returns true if the dashboard is visible */
+	virtual bool IsDashboardVisible() = 0;
+
+	/** returns true if the dashboard is visible and the specified overlay is the active system Overlay */
+	virtual bool IsActiveDashboardOverlay(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Sets the dashboard overlay to only appear when the specified process ID has scene focus */
+	virtual EVROverlayError SetDashboardOverlaySceneProcess(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = 0;
+
+	/** Gets the process ID that this dashboard overlay requires to have scene focus */
+	virtual EVROverlayError GetDashboardOverlaySceneProcess(VROverlayHandle_t ulOverlayHandle, uint32_t *punProcessId) = 0;
+
+	/** Shows the dashboard. */
+	virtual void ShowDashboard(const char *pchOverlayToShow) = 0;
+
+	/** Returns the tracked device that has the laser pointer in the dashboard */
+	virtual vr::TrackedDeviceIndex_t GetPrimaryDashboardDevice() = 0;
+
+	// ---------------------------------------------
+	// Keyboard methods
+	// ---------------------------------------------
+
+	/** Show the virtual keyboard to accept input **/
+	virtual EVROverlayError ShowKeyboard(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char *pchDescription, uint32_t unCharMax, const char *pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = 0;
+
+	virtual EVROverlayError ShowKeyboardForOverlay(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char *pchDescription, uint32_t unCharMax, const char *pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = 0;
+
+	/** Get the text that was entered into the text input **/
+	virtual uint32_t GetKeyboardText(VR_OUT_STRING() char *pchText, uint32_t cchText) = 0;
+
+	/** Hide the virtual keyboard **/
+	virtual void HideKeyboard() = 0;
+
+	/** Set the position of the keyboard in world space **/
+	virtual void SetKeyboardTransformAbsolute(ETrackingUniverseOrigin eTrackingOrigin, const HmdMatrix34_t *pmatTrackingOriginToKeyboardTransform) = 0;
+
+	/** Set the position of the keyboard in overlay space by telling it to avoid a rectangle in the overlay. Rectangle coords have (0,0) in the bottom left **/
+	virtual void SetKeyboardPositionForOverlay(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = 0;
+
+	// ---------------------------------------------
+	// Overlay input methods
+	// ---------------------------------------------
+
+	/** Sets a list of primitives to be used for controller ray intersection
+		* typically the size of the underlying UI in pixels (not in world space). */
+	virtual EVROverlayError SetOverlayIntersectionMask(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t *pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize = sizeof(VROverlayIntersectionMaskPrimitive_t)) = 0;
+
+	virtual EVROverlayError GetOverlayFlags(VROverlayHandle_t ulOverlayHandle, uint32_t *pFlags) = 0;
+
+	// ---------------------------------------------
+	// Message box methods
+	// ---------------------------------------------
+
+	/** Show the message overlay. This will block and return you a result. **/
+	virtual VRMessageOverlayResponse ShowMessageOverlay(const char *pchText, const char *pchCaption, const char *pchButton0Text, const char *pchButton1Text = nullptr, const char *pchButton2Text = nullptr, const char *pchButton3Text = nullptr) = 0;
+
+	/** If the calling process owns the overlay and it's open, this will close it. **/
+	virtual void CloseMessageOverlay() = 0;
+};
+
+static const char *const IVROverlay_Version = "IVROverlay_016";
+
+}  // namespace vr
+
+// ivrrendermodels.h
+namespace vr
+{
+static const char *const k_pch_Controller_Component_GDC2015 = "gdc2015";    // Canonical coordinate system of the gdc 2015 wired controller, provided for backwards compatibility
+static const char *const k_pch_Controller_Component_Base = "base";          // For controllers with an unambiguous 'base'.
+static const char *const k_pch_Controller_Component_Tip = "tip";            // For controllers with an unambiguous 'tip' (used for 'laser-pointing')
+static const char *const k_pch_Controller_Component_HandGrip = "handgrip";  // Neutral, ambidextrous hand-pose when holding controller. On plane between neutrally posed index finger and thumb
+static const char *const k_pch_Controller_Component_Status = "status";      // 1:1 aspect ratio status area, with canonical [0,1] uv mapping
+
+#pragma pack(push, 8)
+
+/** Errors that can occur with the VR compositor */
+enum EVRRenderModelError
+{
+	VRRenderModelError_None = 0,
+	VRRenderModelError_Loading = 100,
+	VRRenderModelError_NotSupported = 200,
+	VRRenderModelError_InvalidArg = 300,
+	VRRenderModelError_InvalidModel = 301,
+	VRRenderModelError_NoShapes = 302,
+	VRRenderModelError_MultipleShapes = 303,
+	VRRenderModelError_TooManyVertices = 304,
+	VRRenderModelError_MultipleTextures = 305,
+	VRRenderModelError_BufferTooSmall = 306,
+	VRRenderModelError_NotEnoughNormals = 307,
+	VRRenderModelError_NotEnoughTexCoords = 308,
+
+	VRRenderModelError_InvalidTexture = 400,
+};
+
+typedef uint32_t VRComponentProperties;
+
+enum EVRComponentProperty
+{
+	VRComponentProperty_IsStatic = (1 << 0),
+	VRComponentProperty_IsVisible = (1 << 1),
+	VRComponentProperty_IsTouched = (1 << 2),
+	VRComponentProperty_IsPressed = (1 << 3),
+	VRComponentProperty_IsScrolled = (1 << 4),
+};
+
+/** Describes state information about a render-model component, including transforms and other dynamic properties */
+struct RenderModel_ComponentState_t
+{
+	HmdMatrix34_t mTrackingToComponentRenderModel;  // Transform required when drawing the component render model
+	HmdMatrix34_t mTrackingToComponentLocal;        // Transform available for attaching to a local component coordinate system (-Z out from surface )
+	VRComponentProperties uProperties;
+};
+
+/** A single vertex in a render model */
+struct RenderModel_Vertex_t
+{
+	HmdVector3_t vPosition;  // position in meters in device space
+	HmdVector3_t vNormal;
+	float rfTextureCoord[2];
+};
+
+/** A texture map for use on a render model */
+#if defined(__linux__) || defined(__APPLE__)
+// This structure was originally defined mis-packed on Linux, preserved for
+// compatibility.
+#pragma pack(push, 4)
+#endif
+
+struct RenderModel_TextureMap_t
+{
+	uint16_t unWidth, unHeight;        // width and height of the texture map in pixels
+	const uint8_t *rubTextureMapData;  // Map texture data. All textures are RGBA with 8 bits per channel per pixel. Data size is width * height * 4ub
+};
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+
+/**  Session unique texture identifier. Rendermodels which share the same texture will have the same id.
+IDs <0 denote the texture is not present */
+
+typedef int32_t TextureID_t;
+
+const TextureID_t INVALID_TEXTURE_ID = -1;
+
+#if defined(__linux__) || defined(__APPLE__)
+// This structure was originally defined mis-packed on Linux, preserved for
+// compatibility.
+#pragma pack(push, 4)
+#endif
+
+struct RenderModel_t
+{
+	const RenderModel_Vertex_t *rVertexData;  // Vertex data for the mesh
+	uint32_t unVertexCount;                   // Number of vertices in the vertex data
+	const uint16_t *rIndexData;               // Indices into the vertex data for each triangle
+	uint32_t unTriangleCount;                 // Number of triangles in the mesh. Index count is 3 * TriangleCount
+	TextureID_t diffuseTextureId;             // Session unique texture identifier. Rendermodels which share the same texture will have the same id. <0 == texture not present
+};
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+
+struct RenderModel_ControllerMode_State_t
+{
+	bool bScrollWheelVisible;  // is this controller currently set to be in a scroll wheel mode
+};
+
+#pragma pack(pop)
+
+class IVRRenderModels
+{
+public:
+	/** Loads and returns a render model for use in the application. pchRenderModelName should be a render model name
+	* from the Prop_RenderModelName_String property or an absolute path name to a render model on disk. 
+	*
+	* The resulting render model is valid until VR_Shutdown() is called or until FreeRenderModel() is called. When the 
+	* application is finished with the render model it should call FreeRenderModel() to free the memory associated
+	* with the model.
+	*
+	* The method returns VRRenderModelError_Loading while the render model is still being loaded.
+	* The method returns VRRenderModelError_None once loaded successfully, otherwise will return an error. */
+	virtual EVRRenderModelError LoadRenderModel_Async(const char *pchRenderModelName, RenderModel_t **ppRenderModel) = 0;
+
+	/** Frees a previously returned render model
+	*   It is safe to call this on a null ptr. */
+	virtual void FreeRenderModel(RenderModel_t *pRenderModel) = 0;
+
+	/** Loads and returns a texture for use in the application. */
+	virtual EVRRenderModelError LoadTexture_Async(TextureID_t textureId, RenderModel_TextureMap_t **ppTexture) = 0;
+
+	/** Frees a previously returned texture
+	*   It is safe to call this on a null ptr. */
+	virtual void FreeTexture(RenderModel_TextureMap_t *pTexture) = 0;
+
+	/** Creates a D3D11 texture and loads data into it. */
+	virtual EVRRenderModelError LoadTextureD3D11_Async(TextureID_t textureId, void *pD3D11Device, void **ppD3D11Texture2D) = 0;
+
+	/** Helper function to copy the bits into an existing texture. */
+	virtual EVRRenderModelError LoadIntoTextureD3D11_Async(TextureID_t textureId, void *pDstTexture) = 0;
+
+	/** Use this to free textures created with LoadTextureD3D11_Async instead of calling Release on them. */
+	virtual void FreeTextureD3D11(void *pD3D11Texture2D) = 0;
+
+	/** Use this to get the names of available render models.  Index does not correlate to a tracked device index, but
+	* is only used for iterating over all available render models.  If the index is out of range, this function will return 0.
+	* Otherwise, it will return the size of the buffer required for the name. */
+	virtual uint32_t GetRenderModelName(uint32_t unRenderModelIndex, VR_OUT_STRING() char *pchRenderModelName, uint32_t unRenderModelNameLen) = 0;
+
+	/** Returns the number of available render models. */
+	virtual uint32_t GetRenderModelCount() = 0;
+
+	/** Returns the number of components of the specified render model.
+	*  Components are useful when client application wish to draw, label, or otherwise interact with components of tracked objects.
+	*  Examples controller components:
+	*   renderable things such as triggers, buttons
+	*   non-renderable things which include coordinate systems such as 'tip', 'base', a neutral controller agnostic hand-pose
+	*   If all controller components are enumerated and rendered, it will be equivalent to drawing the traditional render model
+	*   Returns 0 if components not supported, >0 otherwise */
+	virtual uint32_t GetComponentCount(const char *pchRenderModelName) = 0;
+
+	/** Use this to get the names of available components.  Index does not correlate to a tracked device index, but
+	* is only used for iterating over all available components.  If the index is out of range, this function will return 0.
+	* Otherwise, it will return the size of the buffer required for the name. */
+	virtual uint32_t GetComponentName(const char *pchRenderModelName, uint32_t unComponentIndex, VR_OUT_STRING() char *pchComponentName, uint32_t unComponentNameLen) = 0;
+
+	/** Get the button mask for all buttons associated with this component
+	*   If no buttons (or axes) are associated with this component, return 0
+	*   Note: multiple components may be associated with the same button. Ex: two grip buttons on a single controller.
+	*   Note: A single component may be associated with multiple buttons. Ex: A trackpad which also provides "D-pad" functionality */
+	virtual uint64_t GetComponentButtonMask(const char *pchRenderModelName, const char *pchComponentName) = 0;
+
+	/** Use this to get the render model name for the specified rendermode/component combination, to be passed to LoadRenderModel.
+	* If the component name is out of range, this function will return 0.
+	* Otherwise, it will return the size of the buffer required for the name. */
+	virtual uint32_t GetComponentRenderModelName(const char *pchRenderModelName, const char *pchComponentName, VR_OUT_STRING() char *pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen) = 0;
+
+	/** Use this to query information about the component, as a function of the controller state.
+	*
+	* For dynamic controller components (ex: trigger) values will reflect component motions
+	* For static components this will return a consistent value independent of the VRControllerState_t
+	*
+	* If the pchRenderModelName or pchComponentName is invalid, this will return false (and transforms will be set to identity).
+	* Otherwise, return true
+	* Note: For dynamic objects, visibility may be dynamic. (I.e., true/false will be returned based on controller state and controller mode state ) */
+	virtual bool GetComponentState(const char *pchRenderModelName, const char *pchComponentName, const vr::VRControllerState_t *pControllerState, const RenderModel_ControllerMode_State_t *pState, RenderModel_ComponentState_t *pComponentState) = 0;
+
+	/** Returns true if the render model has a component with the specified name */
+	virtual bool RenderModelHasComponent(const char *pchRenderModelName, const char *pchComponentName) = 0;
+
+	/** Returns the URL of the thumbnail image for this rendermodel */
+	virtual uint32_t GetRenderModelThumbnailURL(const char *pchRenderModelName, VR_OUT_STRING() char *pchThumbnailURL, uint32_t unThumbnailURLLen, vr::EVRRenderModelError *peError) = 0;
+
+	/** Provides a render model path that will load the unskinned model if the model name provided has been replace by the user. If the model
+	* hasn't been replaced the path value will still be a valid path to load the model. Pass this to LoadRenderModel_Async, etc. to load the
+	* model. */
+	virtual uint32_t GetRenderModelOriginalPath(const char *pchRenderModelName, VR_OUT_STRING() char *pchOriginalPath, uint32_t unOriginalPathLen, vr::EVRRenderModelError *peError) = 0;
+
+	/** Returns a string for a render model error */
+	virtual const char *GetRenderModelErrorNameFromEnum(vr::EVRRenderModelError error) = 0;
+};
+
+static const char *const IVRRenderModels_Version = "IVRRenderModels_005";
+
+}  // namespace vr
+
+// ivrextendeddisplay.h
+namespace vr
+{
+/** NOTE: Use of this interface is not recommended in production applications. It will not work for displays which use
+	* direct-to-display mode. Creating our own window is also incompatible with the VR compositor and is not available when the compositor is running. */
+class IVRExtendedDisplay
+{
+public:
+	/** Size and position that the window needs to be on the VR display. */
+	virtual void GetWindowBounds(int32_t *pnX, int32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight) = 0;
+
+	/** Gets the viewport in the frame buffer to draw the output of the distortion into */
+	virtual void GetEyeOutputViewport(EVREye eEye, uint32_t *pnX, uint32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight) = 0;
+
+	/** [D3D10/11 Only]
+		* Returns the adapter index and output index that the user should pass into EnumAdapters and EnumOutputs
+		* to create the device and swap chain in DX10 and DX11. If an error occurs both indices will be set to -1.
+		*/
+	virtual void GetDXGIOutputInfo(int32_t *pnAdapterIndex, int32_t *pnAdapterOutputIndex) = 0;
+};
+
+static const char *const IVRExtendedDisplay_Version = "IVRExtendedDisplay_001";
+
+}  // namespace vr
+
+// ivrtrackedcamera.h
+namespace vr
+{
+class IVRTrackedCamera
+{
+public:
+	/** Returns a string for an error */
+	virtual const char *GetCameraErrorNameFromEnum(vr::EVRTrackedCameraError eCameraError) = 0;
+
+	/** For convenience, same as tracked property request Prop_HasCamera_Bool */
+	virtual vr::EVRTrackedCameraError HasCamera(vr::TrackedDeviceIndex_t nDeviceIndex, bool *pHasCamera) = 0;
+
+	/** Gets size of the image frame. */
+	virtual vr::EVRTrackedCameraError GetCameraFrameSize(vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, uint32_t *pnWidth, uint32_t *pnHeight, uint32_t *pnFrameBufferSize) = 0;
+
+	virtual vr::EVRTrackedCameraError GetCameraIntrinsics(vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, vr::HmdVector2_t *pFocalLength, vr::HmdVector2_t *pCenter) = 0;
+
+	virtual vr::EVRTrackedCameraError GetCameraProjection(vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, vr::HmdMatrix44_t *pProjection) = 0;
+
+	/** Acquiring streaming service permits video streaming for the caller. Releasing hints the system that video services do not need to be maintained for this client.
+	* If the camera has not already been activated, a one time spin up may incur some auto exposure as well as initial streaming frame delays.
+	* The camera should be considered a global resource accessible for shared consumption but not exclusive to any caller.
+	* The camera may go inactive due to lack of active consumers or headset idleness. */
+	virtual vr::EVRTrackedCameraError AcquireVideoStreamingService(vr::TrackedDeviceIndex_t nDeviceIndex, vr::TrackedCameraHandle_t *pHandle) = 0;
+	virtual vr::EVRTrackedCameraError ReleaseVideoStreamingService(vr::TrackedCameraHandle_t hTrackedCamera) = 0;
+
+	/** Copies the image frame into a caller's provided buffer. The image data is currently provided as RGBA data, 4 bytes per pixel.
+	* A caller can provide null for the framebuffer or frameheader if not desired. Requesting the frame header first, followed by the frame buffer allows
+	* the caller to determine if the frame as advanced per the frame header sequence. 
+	* If there is no frame available yet, due to initial camera spinup or re-activation, the error will be VRTrackedCameraError_NoFrameAvailable.
+	* Ideally a caller should be polling at ~16ms intervals */
+	virtual vr::EVRTrackedCameraError GetVideoStreamFrameBuffer(vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, void *pFrameBuffer, uint32_t nFrameBufferSize, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize) = 0;
+
+	/** Gets size of the image frame. */
+	virtual vr::EVRTrackedCameraError GetVideoStreamTextureSize(vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, vr::VRTextureBounds_t *pTextureBounds, uint32_t *pnWidth, uint32_t *pnHeight) = 0;
+
+	/** Access a shared D3D11 texture for the specified tracked camera stream.
+	* The camera frame type VRTrackedCameraFrameType_Undistorted is not supported directly as a shared texture. It is an interior subregion of the shared texture VRTrackedCameraFrameType_MaximumUndistorted.
+	* Instead, use GetVideoStreamTextureSize() with VRTrackedCameraFrameType_Undistorted to determine the proper interior subregion bounds along with GetVideoStreamTextureD3D11() with
+	* VRTrackedCameraFrameType_MaximumUndistorted to provide the texture. The VRTrackedCameraFrameType_MaximumUndistorted will yield an image where the invalid regions are decoded
+	* by the alpha channel having a zero component. The valid regions all have a non-zero alpha component. The subregion as described by VRTrackedCameraFrameType_Undistorted 
+	* guarantees a rectangle where all pixels are valid. */
+	virtual vr::EVRTrackedCameraError GetVideoStreamTextureD3D11(vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize) = 0;
+
+	/** Access a shared GL texture for the specified tracked camera stream */
+	virtual vr::EVRTrackedCameraError GetVideoStreamTextureGL(vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, vr::glUInt_t *pglTextureId, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize) = 0;
+	virtual vr::EVRTrackedCameraError ReleaseVideoStreamTextureGL(vr::TrackedCameraHandle_t hTrackedCamera, vr::glUInt_t glTextureId) = 0;
+};
+
+static const char *const IVRTrackedCamera_Version = "IVRTrackedCamera_003";
+
+}  // namespace vr
+
+// ivrscreenshots.h
+namespace vr
+{
+/** Errors that can occur with the VR compositor */
+enum EVRScreenshotError
+{
+	VRScreenshotError_None = 0,
+	VRScreenshotError_RequestFailed = 1,
+	VRScreenshotError_IncompatibleVersion = 100,
+	VRScreenshotError_NotFound = 101,
+	VRScreenshotError_BufferTooSmall = 102,
+	VRScreenshotError_ScreenshotAlreadyInProgress = 108,
+};
+
+/** Allows the application to generate screenshots */
+class IVRScreenshots
+{
+public:
+	/** Request a screenshot of the requested type.
+	 *  A request of the VRScreenshotType_Stereo type will always
+	 *  work. Other types will depend on the underlying application
+	 *  support.
+	 *  The first file name is for the preview image and should be a
+	 *  regular screenshot (ideally from the left eye). The second
+	 *  is the VR screenshot in the correct format. They should be
+	 *  in the same aspect ratio.  Formats per type:
+	 *  VRScreenshotType_Mono: the VR filename is ignored (can be
+	 *  nullptr), this is a normal flat single shot.
+	 *  VRScreenshotType_Stereo:  The VR image should be a
+	 *  side-by-side with the left eye image on the left.
+	 *  VRScreenshotType_Cubemap: The VR image should be six square
+	 *  images composited horizontally.
+	 *  VRScreenshotType_StereoPanorama: above/below with left eye
+	 *  panorama being the above image.  Image is typically square
+	 *  with the panorama being 2x horizontal.
+	 *  
+	 *  Note that the VR dashboard will call this function when
+	 *  the user presses the screenshot binding (currently System
+	 *  Button + Trigger).  If Steam is running, the destination
+	 *  file names will be in %TEMP% and will be copied into
+	 *  Steam's screenshot library for the running application
+	 *  once SubmitScreenshot() is called.
+	 *  If Steam is not running, the paths will be in the user's
+	 *  documents folder under Documents\SteamVR\Screenshots.
+	 *  Other VR applications can call this to initiate a
+	 *  screenshot outside of user control.
+	 *  The destination file names do not need an extension,
+	 *  will be replaced with the correct one for the format
+	 *  which is currently .png. */
+	virtual vr::EVRScreenshotError RequestScreenshot(vr::ScreenshotHandle_t *pOutScreenshotHandle, vr::EVRScreenshotType type, const char *pchPreviewFilename, const char *pchVRFilename) = 0;
+
+	/** Called by the running VR application to indicate that it
+	 *  wishes to be in charge of screenshots.  If the
+	 *  application does not call this, the Compositor will only
+	 *  support VRScreenshotType_Stereo screenshots that will be
+	 *  captured without notification to the running app.
+	 *  Once hooked your application will receive a
+	 *  VREvent_RequestScreenshot event when the user presses the
+	 *  buttons to take a screenshot. */
+	virtual vr::EVRScreenshotError HookScreenshot(VR_ARRAY_COUNT(numTypes) const vr::EVRScreenshotType *pSupportedTypes, int numTypes) = 0;
+
+	/** When your application receives a
+	 *  VREvent_RequestScreenshot event, call these functions to get
+	 *  the details of the screenshot request. */
+	virtual vr::EVRScreenshotType GetScreenshotPropertyType(vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotError *pError) = 0;
+
+	/** Get the filename for the preview or vr image (see
+	 *  vr::EScreenshotPropertyFilenames).  The return value is
+	 *  the size of the string.   */
+	virtual uint32_t GetScreenshotPropertyFilename(vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotPropertyFilenames filenameType, VR_OUT_STRING() char *pchFilename, uint32_t cchFilename, vr::EVRScreenshotError *pError) = 0;
+
+	/** Call this if the application is taking the screen shot
+	 *  will take more than a few ms processing. This will result
+	 *  in an overlay being presented that shows a completion
+	 *  bar. */
+	virtual vr::EVRScreenshotError UpdateScreenshotProgress(vr::ScreenshotHandle_t screenshotHandle, float flProgress) = 0;
+
+	/** Tells the compositor to take an internal screenshot of
+	 *  type VRScreenshotType_Stereo. It will take the current
+	 *  submitted scene textures of the running application and
+	 *  write them into the preview image and a side-by-side file
+	 *  for the VR image.
+	 *  This is similar to request screenshot, but doesn't ever
+	 *  talk to the application, just takes the shot and submits. */
+	virtual vr::EVRScreenshotError TakeStereoScreenshot(vr::ScreenshotHandle_t *pOutScreenshotHandle, const char *pchPreviewFilename, const char *pchVRFilename) = 0;
+
+	/** Submit the completed screenshot.  If Steam is running
+	 *  this will call into the Steam client and upload the
+	 *  screenshot to the screenshots section of the library for
+	 *  the running application.  If Steam is not running, this
+	 *  function will display a notification to the user that the
+	 *  screenshot was taken. The paths should be full paths with
+	 *  extensions.
+	 *  File paths should be absolute including extensions.
+	 *  screenshotHandle can be k_unScreenshotHandleInvalid if this
+	 *  was a new shot taking by the app to be saved and not
+	 *  initiated by a user (achievement earned or something) */
+	virtual vr::EVRScreenshotError SubmitScreenshot(vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotType type, const char *pchSourcePreviewFilename, const char *pchSourceVRFilename) = 0;
+};
+
+static const char *const IVRScreenshots_Version = "IVRScreenshots_001";
+
+}  // namespace vr
+
+// ivrresources.h
+namespace vr
+{
+class IVRResources
+{
+public:
+	// ------------------------------------
+	// Shared Resource Methods
+	// ------------------------------------
+
+	/** Loads the specified resource into the provided buffer if large enough.
+	* Returns the size in bytes of the buffer required to hold the specified resource. */
+	virtual uint32_t LoadSharedResource(const char *pchResourceName, char *pchBuffer, uint32_t unBufferLen) = 0;
+
+	/** Provides the full path to the specified resource. Resource names can include named directories for
+	* drivers and other things, and this resolves all of those and returns the actual physical path. 
+	* pchResourceTypeDirectory is the subdirectory of resources to look in. */
+	virtual uint32_t GetResourceFullPath(const char *pchResourceName, const char *pchResourceTypeDirectory, char *pchPathBuffer, uint32_t unBufferLen) = 0;
+};
+
+static const char *const IVRResources_Version = "IVRResources_001";
+
+}  // namespace vr
+// ivrdrivermanager.h
+namespace vr
+{
+class IVRDriverManager
+{
+public:
+	virtual uint32_t GetDriverCount() const = 0;
+
+	/** Returns the length of the number of bytes necessary to hold this string including the trailing null. */
+	virtual uint32_t GetDriverName(vr::DriverId_t nDriver, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize) = 0;
+};
+
+static const char *const IVRDriverManager_Version = "IVRDriverManager_001";
+
+}  // namespace vr
+
+// End
+
+#endif  // _OPENVR_API
+
+namespace vr
+{
+/** Finds the active installation of the VR API and initializes it. The provided path must be absolute
+	* or relative to the current working directory. These are the local install versions of the equivalent
+	* functions in steamvr.h and will work without a local Steam install.
+	*
+	* This path is to the "root" of the VR API install. That's the directory with
+	* the "drivers" directory and a platform (i.e. "win32") directory in it, not the directory with the DLL itself.
+	*
+	* pStartupInfo is reserved for future use.
+	*/
+inline IVRSystem *VR_Init(EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo = nullptr);
+
+/** unloads vrclient.dll. Any interface pointers from the interface are
+	* invalid after this point */
+inline void VR_Shutdown();
+
+/** Returns true if there is an HMD attached. This check is as lightweight as possible and
+	* can be called outside of VR_Init/VR_Shutdown. It should be used when an application wants
+	* to know if initializing VR is a possibility but isn't ready to take that step yet.
+	*/
+VR_INTERFACE bool VR_CALLTYPE VR_IsHmdPresent();
+
+/** Returns true if the OpenVR runtime is installed. */
+VR_INTERFACE bool VR_CALLTYPE VR_IsRuntimeInstalled();
+
+/** Returns where the OpenVR runtime is installed. */
+VR_INTERFACE const char *VR_CALLTYPE VR_RuntimePath();
+
+/** Returns the name of the enum value for an EVRInitError. This function may be called outside of VR_Init()/VR_Shutdown(). */
+VR_INTERFACE const char *VR_CALLTYPE VR_GetVRInitErrorAsSymbol(EVRInitError error);
+
+/** Returns an English string for an EVRInitError. Applications should call VR_GetVRInitErrorAsSymbol instead and
+	* use that as a key to look up their own localized error message. This function may be called outside of VR_Init()/VR_Shutdown(). */
+VR_INTERFACE const char *VR_CALLTYPE VR_GetVRInitErrorAsEnglishDescription(EVRInitError error);
+
+/** Returns the interface of the specified version. This method must be called after VR_Init. The
+	* pointer returned is valid until VR_Shutdown is called.
+	*/
+VR_INTERFACE void *VR_CALLTYPE VR_GetGenericInterface(const char *pchInterfaceVersion, EVRInitError *peError);
+
+/** Returns whether the interface of the specified version exists.
+	*/
+VR_INTERFACE bool VR_CALLTYPE VR_IsInterfaceVersionValid(const char *pchInterfaceVersion);
+
+/** Returns a token that represents whether the VR interface handles need to be reloaded */
+VR_INTERFACE uint32_t VR_CALLTYPE VR_GetInitToken();
+
+// These typedefs allow old enum names from SDK 0.9.11 to be used in applications.
+// They will go away in the future.
+typedef EVRInitError HmdError;
+typedef EVREye Hmd_Eye;
+typedef EColorSpace ColorSpace;
+typedef ETrackingResult HmdTrackingResult;
+typedef ETrackedDeviceClass TrackedDeviceClass;
+typedef ETrackingUniverseOrigin TrackingUniverseOrigin;
+typedef ETrackedDeviceProperty TrackedDeviceProperty;
+typedef ETrackedPropertyError TrackedPropertyError;
+typedef EVRSubmitFlags VRSubmitFlags_t;
+typedef EVRState VRState_t;
+typedef ECollisionBoundsStyle CollisionBoundsStyle_t;
+typedef EVROverlayError VROverlayError;
+typedef EVRFirmwareError VRFirmwareError;
+typedef EVRCompositorError VRCompositorError;
+typedef EVRScreenshotError VRScreenshotsError;
+
+inline uint32_t &VRToken()
+{
+	static uint32_t token;
+	return token;
+}
+
+class COpenVRContext
+{
+public:
+	COpenVRContext() { Clear(); }
+	void Clear();
+
+	inline void CheckClear()
+	{
+		if (VRToken() != VR_GetInitToken())
+		{
+			Clear();
+			VRToken() = VR_GetInitToken();
+		}
+	}
+
+	IVRSystem *VRSystem()
+	{
+		CheckClear();
+		if (m_pVRSystem == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRSystem = (IVRSystem *)VR_GetGenericInterface(IVRSystem_Version, &eError);
+		}
+		return m_pVRSystem;
+	}
+	IVRChaperone *VRChaperone()
+	{
+		CheckClear();
+		if (m_pVRChaperone == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRChaperone = (IVRChaperone *)VR_GetGenericInterface(IVRChaperone_Version, &eError);
+		}
+		return m_pVRChaperone;
+	}
+
+	IVRChaperoneSetup *VRChaperoneSetup()
+	{
+		CheckClear();
+		if (m_pVRChaperoneSetup == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRChaperoneSetup = (IVRChaperoneSetup *)VR_GetGenericInterface(IVRChaperoneSetup_Version, &eError);
+		}
+		return m_pVRChaperoneSetup;
+	}
+
+	IVRCompositor *VRCompositor()
+	{
+		CheckClear();
+		if (m_pVRCompositor == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRCompositor = (IVRCompositor *)VR_GetGenericInterface(IVRCompositor_Version, &eError);
+		}
+		return m_pVRCompositor;
+	}
+
+	IVROverlay *VROverlay()
+	{
+		CheckClear();
+		if (m_pVROverlay == nullptr)
+		{
+			EVRInitError eError;
+			m_pVROverlay = (IVROverlay *)VR_GetGenericInterface(IVROverlay_Version, &eError);
+		}
+		return m_pVROverlay;
+	}
+
+	IVRResources *VRResources()
+	{
+		CheckClear();
+		if (m_pVRResources == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRResources = (IVRResources *)VR_GetGenericInterface(IVRResources_Version, &eError);
+		}
+		return m_pVRResources;
+	}
+
+	IVRScreenshots *VRScreenshots()
+	{
+		CheckClear();
+		if (m_pVRScreenshots == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRScreenshots = (IVRScreenshots *)VR_GetGenericInterface(IVRScreenshots_Version, &eError);
+		}
+		return m_pVRScreenshots;
+	}
+
+	IVRRenderModels *VRRenderModels()
+	{
+		CheckClear();
+		if (m_pVRRenderModels == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRRenderModels = (IVRRenderModels *)VR_GetGenericInterface(IVRRenderModels_Version, &eError);
+		}
+		return m_pVRRenderModels;
+	}
+
+	IVRExtendedDisplay *VRExtendedDisplay()
+	{
+		CheckClear();
+		if (m_pVRExtendedDisplay == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRExtendedDisplay = (IVRExtendedDisplay *)VR_GetGenericInterface(IVRExtendedDisplay_Version, &eError);
+		}
+		return m_pVRExtendedDisplay;
+	}
+
+	IVRSettings *VRSettings()
+	{
+		CheckClear();
+		if (m_pVRSettings == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRSettings = (IVRSettings *)VR_GetGenericInterface(IVRSettings_Version, &eError);
+		}
+		return m_pVRSettings;
+	}
+
+	IVRApplications *VRApplications()
+	{
+		CheckClear();
+		if (m_pVRApplications == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRApplications = (IVRApplications *)VR_GetGenericInterface(IVRApplications_Version, &eError);
+		}
+		return m_pVRApplications;
+	}
+
+	IVRTrackedCamera *VRTrackedCamera()
+	{
+		CheckClear();
+		if (m_pVRTrackedCamera == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRTrackedCamera = (IVRTrackedCamera *)VR_GetGenericInterface(IVRTrackedCamera_Version, &eError);
+		}
+		return m_pVRTrackedCamera;
+	}
+
+	IVRDriverManager *VRDriverManager()
+	{
+		CheckClear();
+		if (!m_pVRDriverManager)
+		{
+			EVRInitError eError;
+			m_pVRDriverManager = (IVRDriverManager *)VR_GetGenericInterface(IVRDriverManager_Version, &eError);
+		}
+		return m_pVRDriverManager;
+	}
+
+private:
+	IVRSystem *m_pVRSystem;
+	IVRChaperone *m_pVRChaperone;
+	IVRChaperoneSetup *m_pVRChaperoneSetup;
+	IVRCompositor *m_pVRCompositor;
+	IVROverlay *m_pVROverlay;
+	IVRResources *m_pVRResources;
+	IVRRenderModels *m_pVRRenderModels;
+	IVRExtendedDisplay *m_pVRExtendedDisplay;
+	IVRSettings *m_pVRSettings;
+	IVRApplications *m_pVRApplications;
+	IVRTrackedCamera *m_pVRTrackedCamera;
+	IVRScreenshots *m_pVRScreenshots;
+	IVRDriverManager *m_pVRDriverManager;
+};
+
+inline COpenVRContext &OpenVRInternal_ModuleContext()
+{
+	static void *ctx[sizeof(COpenVRContext) / sizeof(void *)];
+	return *(COpenVRContext *)ctx;  // bypass zero-init constructor
+}
+
+inline IVRSystem *VR_CALLTYPE VRSystem() { return OpenVRInternal_ModuleContext().VRSystem(); }
+inline IVRChaperone *VR_CALLTYPE VRChaperone() { return OpenVRInternal_ModuleContext().VRChaperone(); }
+inline IVRChaperoneSetup *VR_CALLTYPE VRChaperoneSetup() { return OpenVRInternal_ModuleContext().VRChaperoneSetup(); }
+inline IVRCompositor *VR_CALLTYPE VRCompositor() { return OpenVRInternal_ModuleContext().VRCompositor(); }
+inline IVROverlay *VR_CALLTYPE VROverlay() { return OpenVRInternal_ModuleContext().VROverlay(); }
+inline IVRScreenshots *VR_CALLTYPE VRScreenshots() { return OpenVRInternal_ModuleContext().VRScreenshots(); }
+inline IVRRenderModels *VR_CALLTYPE VRRenderModels() { return OpenVRInternal_ModuleContext().VRRenderModels(); }
+inline IVRApplications *VR_CALLTYPE VRApplications() { return OpenVRInternal_ModuleContext().VRApplications(); }
+inline IVRSettings *VR_CALLTYPE VRSettings() { return OpenVRInternal_ModuleContext().VRSettings(); }
+inline IVRResources *VR_CALLTYPE VRResources() { return OpenVRInternal_ModuleContext().VRResources(); }
+inline IVRExtendedDisplay *VR_CALLTYPE VRExtendedDisplay() { return OpenVRInternal_ModuleContext().VRExtendedDisplay(); }
+inline IVRTrackedCamera *VR_CALLTYPE VRTrackedCamera() { return OpenVRInternal_ModuleContext().VRTrackedCamera(); }
+inline IVRDriverManager *VR_CALLTYPE VRDriverManager() { return OpenVRInternal_ModuleContext().VRDriverManager(); }
+
+inline void COpenVRContext::Clear()
+{
+	m_pVRSystem = nullptr;
+	m_pVRChaperone = nullptr;
+	m_pVRChaperoneSetup = nullptr;
+	m_pVRCompositor = nullptr;
+	m_pVROverlay = nullptr;
+	m_pVRRenderModels = nullptr;
+	m_pVRExtendedDisplay = nullptr;
+	m_pVRSettings = nullptr;
+	m_pVRApplications = nullptr;
+	m_pVRTrackedCamera = nullptr;
+	m_pVRResources = nullptr;
+	m_pVRScreenshots = nullptr;
+	m_pVRDriverManager = nullptr;
+}
+
+VR_INTERFACE uint32_t VR_CALLTYPE VR_InitInternal2(EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo);
+VR_INTERFACE void VR_CALLTYPE VR_ShutdownInternal();
+
+/** Finds the active installation of vrclient.dll and initializes it */
+inline IVRSystem *VR_Init(EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo)
+{
+	IVRSystem *pVRSystem = nullptr;
+
+	EVRInitError eError;
+	VRToken() = VR_InitInternal2(&eError, eApplicationType, pStartupInfo);
+	COpenVRContext &ctx = OpenVRInternal_ModuleContext();
+	ctx.Clear();
+
+	if (eError == VRInitError_None)
+	{
+		if (VR_IsInterfaceVersionValid(IVRSystem_Version))
+		{
+			pVRSystem = VRSystem();
+		}
+		else
+		{
+			VR_ShutdownInternal();
+			eError = VRInitError_Init_InterfaceNotFound;
+		}
+	}
+
+	if (peError)
+		*peError = eError;
+	return pVRSystem;
+}
+
+/** unloads vrclient.dll. Any interface pointers from the interface are
+	* invalid after this point */
+inline void VR_Shutdown()
+{
+	VR_ShutdownInternal();
+}
+}  // namespace vr
diff --git a/engine/inc/bullet/ThirdPartyLibs/openvr/bin/osx64/OpenVR.framework/Versions/Current/Headers/openvr_capi.h b/engine/inc/bullet/ThirdPartyLibs/openvr/bin/osx64/OpenVR.framework/Versions/Current/Headers/openvr_capi.h
new file mode 100644
index 00000000..245365f4
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/openvr/bin/osx64/OpenVR.framework/Versions/Current/Headers/openvr_capi.h
@@ -0,0 +1,1932 @@
+//======= Copyright (c) Valve Corporation, All rights reserved. ===============
+//
+// Purpose: Header for flatted SteamAPI. Use this for binding to other languages.
+// This file is auto-generated, do not edit it.
+//
+//=============================================================================
+
+#ifndef __OPENVR_API_FLAT_H__
+#define __OPENVR_API_FLAT_H__
+#if defined(_WIN32) || defined(__clang__)
+#pragma once
+#endif
+
+#ifdef __cplusplus
+#define EXTERN_C extern "C"
+#else
+#define EXTERN_C
+#endif
+
+#if defined(_WIN32)
+#define OPENVR_FNTABLE_CALLTYPE __stdcall
+#else
+#define OPENVR_FNTABLE_CALLTYPE
+#endif
+
+// OPENVR API export macro
+#if defined(_WIN32) && !defined(_X360)
+#if defined(OPENVR_API_EXPORTS)
+#define S_API EXTERN_C __declspec(dllexport)
+#elif defined(OPENVR_API_NODLL)
+#define S_API EXTERN_C
+#else
+#define S_API extern "C" __declspec(dllimport)
+#endif  // OPENVR_API_EXPORTS
+#elif defined(__GNUC__)
+#if defined(OPENVR_API_EXPORTS)
+#define S_API EXTERN_C __attribute__((visibility("default")))
+#else
+#define S_API EXTERN_C
+#endif  // OPENVR_API_EXPORTS
+#else   // !WIN32
+#if defined(OPENVR_API_EXPORTS)
+#define S_API EXTERN_C
+#else
+#define S_API EXTERN_C
+#endif  // OPENVR_API_EXPORTS
+#endif
+
+#include <stdint.h>
+
+#if defined(__WIN32)
+typedef char bool;
+#else
+#include <stdbool.h>
+#endif
+
+typedef uint64_t PropertyContainerHandle_t;
+typedef uint32_t PropertyTypeTag_t;
+typedef uint64_t VRActionHandle_t;
+typedef uint64_t VRActionSetHandle_t;
+typedef uint64_t VRInputOriginHandle_t;
+
+// OpenVR Constants
+
+static const unsigned int k_nDriverNone = 4294967295;
+static const unsigned int k_unMaxDriverDebugResponseSize = 32768;
+static const unsigned int k_unTrackedDeviceIndex_Hmd = 0;
+static const unsigned int k_unMaxTrackedDeviceCount = 16;
+static const unsigned int k_unTrackedDeviceIndexOther = 4294967294;
+static const unsigned int k_unTrackedDeviceIndexInvalid = 4294967295;
+static const unsigned long k_ulInvalidPropertyContainer = 0;
+static const unsigned int k_unInvalidPropertyTag = 0;
+static const unsigned int k_unFloatPropertyTag = 1;
+static const unsigned int k_unInt32PropertyTag = 2;
+static const unsigned int k_unUint64PropertyTag = 3;
+static const unsigned int k_unBoolPropertyTag = 4;
+static const unsigned int k_unStringPropertyTag = 5;
+static const unsigned int k_unHmdMatrix34PropertyTag = 20;
+static const unsigned int k_unHmdMatrix44PropertyTag = 21;
+static const unsigned int k_unHmdVector3PropertyTag = 22;
+static const unsigned int k_unHmdVector4PropertyTag = 23;
+static const unsigned int k_unHiddenAreaPropertyTag = 30;
+static const unsigned int k_unOpenVRInternalReserved_Start = 1000;
+static const unsigned int k_unOpenVRInternalReserved_End = 10000;
+static const unsigned int k_unMaxPropertyStringSize = 32768;
+static const unsigned int k_unControllerStateAxisCount = 5;
+static const unsigned long k_ulOverlayHandleInvalid = 0;
+static const unsigned int k_unScreenshotHandleInvalid = 0;
+static const char *IVRSystem_Version = "IVRSystem_017";
+static const char *IVRExtendedDisplay_Version = "IVRExtendedDisplay_001";
+static const char *IVRTrackedCamera_Version = "IVRTrackedCamera_003";
+static const unsigned int k_unMaxApplicationKeyLength = 128;
+static const char *k_pch_MimeType_HomeApp = "vr/home";
+static const char *k_pch_MimeType_GameTheater = "vr/game_theater";
+static const char *IVRApplications_Version = "IVRApplications_006";
+static const char *IVRChaperone_Version = "IVRChaperone_003";
+static const char *IVRChaperoneSetup_Version = "IVRChaperoneSetup_005";
+static const char *IVRCompositor_Version = "IVRCompositor_021";
+static const unsigned int k_unVROverlayMaxKeyLength = 128;
+static const unsigned int k_unVROverlayMaxNameLength = 128;
+static const unsigned int k_unMaxOverlayCount = 64;
+static const unsigned int k_unMaxOverlayIntersectionMaskPrimitivesCount = 32;
+static const char *IVROverlay_Version = "IVROverlay_016";
+static const char *k_pch_Controller_Component_GDC2015 = "gdc2015";
+static const char *k_pch_Controller_Component_Base = "base";
+static const char *k_pch_Controller_Component_Tip = "tip";
+static const char *k_pch_Controller_Component_HandGrip = "handgrip";
+static const char *k_pch_Controller_Component_Status = "status";
+static const char *IVRRenderModels_Version = "IVRRenderModels_005";
+static const unsigned int k_unNotificationTextMaxSize = 256;
+static const char *IVRNotifications_Version = "IVRNotifications_002";
+static const unsigned int k_unMaxSettingsKeyLength = 128;
+static const char *IVRSettings_Version = "IVRSettings_002";
+static const char *k_pch_SteamVR_Section = "steamvr";
+static const char *k_pch_SteamVR_RequireHmd_String = "requireHmd";
+static const char *k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver";
+static const char *k_pch_SteamVR_ForcedHmdKey_String = "forcedHmd";
+static const char *k_pch_SteamVR_DisplayDebug_Bool = "displayDebug";
+static const char *k_pch_SteamVR_DebugProcessPipe_String = "debugProcessPipe";
+static const char *k_pch_SteamVR_DisplayDebugX_Int32 = "displayDebugX";
+static const char *k_pch_SteamVR_DisplayDebugY_Int32 = "displayDebugY";
+static const char *k_pch_SteamVR_SendSystemButtonToAllApps_Bool = "sendSystemButtonToAllApps";
+static const char *k_pch_SteamVR_LogLevel_Int32 = "loglevel";
+static const char *k_pch_SteamVR_IPD_Float = "ipd";
+static const char *k_pch_SteamVR_Background_String = "background";
+static const char *k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection";
+static const char *k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight";
+static const char *k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius";
+static const char *k_pch_SteamVR_GridColor_String = "gridColor";
+static const char *k_pch_SteamVR_PlayAreaColor_String = "playAreaColor";
+static const char *k_pch_SteamVR_ShowStage_Bool = "showStage";
+static const char *k_pch_SteamVR_ActivateMultipleDrivers_Bool = "activateMultipleDrivers";
+static const char *k_pch_SteamVR_DirectMode_Bool = "directMode";
+static const char *k_pch_SteamVR_DirectModeEdidVid_Int32 = "directModeEdidVid";
+static const char *k_pch_SteamVR_DirectModeEdidPid_Int32 = "directModeEdidPid";
+static const char *k_pch_SteamVR_UsingSpeakers_Bool = "usingSpeakers";
+static const char *k_pch_SteamVR_SpeakersForwardYawOffsetDegrees_Float = "speakersForwardYawOffsetDegrees";
+static const char *k_pch_SteamVR_BaseStationPowerManagement_Bool = "basestationPowerManagement";
+static const char *k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses";
+static const char *k_pch_SteamVR_SupersampleScale_Float = "supersampleScale";
+static const char *k_pch_SteamVR_AllowAsyncReprojection_Bool = "allowAsyncReprojection";
+static const char *k_pch_SteamVR_AllowReprojection_Bool = "allowInterleavedReprojection";
+static const char *k_pch_SteamVR_ForceReprojection_Bool = "forceReprojection";
+static const char *k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking";
+static const char *k_pch_SteamVR_DefaultMirrorView_Int32 = "defaultMirrorView";
+static const char *k_pch_SteamVR_ShowMirrorView_Bool = "showMirrorView";
+static const char *k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry";
+static const char *k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch";
+static const char *k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch";
+static const char *k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch";
+static const char *k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard";
+static const char *k_pch_SteamVR_EnableHomeApp = "enableHomeApp";
+static const char *k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec";
+static const char *k_pch_SteamVR_RetailDemo_Bool = "retailDemo";
+static const char *k_pch_SteamVR_IpdOffset_Float = "ipdOffset";
+static const char *k_pch_SteamVR_AllowSupersampleFiltering_Bool = "allowSupersampleFiltering";
+static const char *k_pch_SteamVR_EnableLinuxVulkanAsync_Bool = "enableLinuxVulkanAsync";
+static const char *k_pch_Lighthouse_Section = "driver_lighthouse";
+static const char *k_pch_Lighthouse_DisableIMU_Bool = "disableimu";
+static const char *k_pch_Lighthouse_UseDisambiguation_String = "usedisambiguation";
+static const char *k_pch_Lighthouse_DisambiguationDebug_Int32 = "disambiguationdebug";
+static const char *k_pch_Lighthouse_PrimaryBasestation_Int32 = "primarybasestation";
+static const char *k_pch_Lighthouse_DBHistory_Bool = "dbhistory";
+static const char *k_pch_Null_Section = "driver_null";
+static const char *k_pch_Null_SerialNumber_String = "serialNumber";
+static const char *k_pch_Null_ModelNumber_String = "modelNumber";
+static const char *k_pch_Null_WindowX_Int32 = "windowX";
+static const char *k_pch_Null_WindowY_Int32 = "windowY";
+static const char *k_pch_Null_WindowWidth_Int32 = "windowWidth";
+static const char *k_pch_Null_WindowHeight_Int32 = "windowHeight";
+static const char *k_pch_Null_RenderWidth_Int32 = "renderWidth";
+static const char *k_pch_Null_RenderHeight_Int32 = "renderHeight";
+static const char *k_pch_Null_SecondsFromVsyncToPhotons_Float = "secondsFromVsyncToPhotons";
+static const char *k_pch_Null_DisplayFrequency_Float = "displayFrequency";
+static const char *k_pch_UserInterface_Section = "userinterface";
+static const char *k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop";
+static const char *k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray";
+static const char *k_pch_UserInterface_Screenshots_Bool = "screenshots";
+static const char *k_pch_UserInterface_ScreenshotType_Int = "screenshotType";
+static const char *k_pch_Notifications_Section = "notifications";
+static const char *k_pch_Notifications_DoNotDisturb_Bool = "DoNotDisturb";
+static const char *k_pch_Keyboard_Section = "keyboard";
+static const char *k_pch_Keyboard_TutorialCompletions = "TutorialCompletions";
+static const char *k_pch_Keyboard_ScaleX = "ScaleX";
+static const char *k_pch_Keyboard_ScaleY = "ScaleY";
+static const char *k_pch_Keyboard_OffsetLeftX = "OffsetLeftX";
+static const char *k_pch_Keyboard_OffsetRightX = "OffsetRightX";
+static const char *k_pch_Keyboard_OffsetY = "OffsetY";
+static const char *k_pch_Keyboard_Smoothing = "Smoothing";
+static const char *k_pch_Perf_Section = "perfcheck";
+static const char *k_pch_Perf_HeuristicActive_Bool = "heuristicActive";
+static const char *k_pch_Perf_NotifyInHMD_Bool = "warnInHMD";
+static const char *k_pch_Perf_NotifyOnlyOnce_Bool = "warnOnlyOnce";
+static const char *k_pch_Perf_AllowTimingStore_Bool = "allowTimingStore";
+static const char *k_pch_Perf_SaveTimingsOnExit_Bool = "saveTimingsOnExit";
+static const char *k_pch_Perf_TestData_Float = "perfTestData";
+static const char *k_pch_Perf_LinuxGPUProfiling_Bool = "linuxGPUProfiling";
+static const char *k_pch_CollisionBounds_Section = "collisionBounds";
+static const char *k_pch_CollisionBounds_Style_Int32 = "CollisionBoundsStyle";
+static const char *k_pch_CollisionBounds_GroundPerimeterOn_Bool = "CollisionBoundsGroundPerimeterOn";
+static const char *k_pch_CollisionBounds_CenterMarkerOn_Bool = "CollisionBoundsCenterMarkerOn";
+static const char *k_pch_CollisionBounds_PlaySpaceOn_Bool = "CollisionBoundsPlaySpaceOn";
+static const char *k_pch_CollisionBounds_FadeDistance_Float = "CollisionBoundsFadeDistance";
+static const char *k_pch_CollisionBounds_ColorGammaR_Int32 = "CollisionBoundsColorGammaR";
+static const char *k_pch_CollisionBounds_ColorGammaG_Int32 = "CollisionBoundsColorGammaG";
+static const char *k_pch_CollisionBounds_ColorGammaB_Int32 = "CollisionBoundsColorGammaB";
+static const char *k_pch_CollisionBounds_ColorGammaA_Int32 = "CollisionBoundsColorGammaA";
+static const char *k_pch_Camera_Section = "camera";
+static const char *k_pch_Camera_EnableCamera_Bool = "enableCamera";
+static const char *k_pch_Camera_EnableCameraInDashboard_Bool = "enableCameraInDashboard";
+static const char *k_pch_Camera_EnableCameraForCollisionBounds_Bool = "enableCameraForCollisionBounds";
+static const char *k_pch_Camera_EnableCameraForRoomView_Bool = "enableCameraForRoomView";
+static const char *k_pch_Camera_BoundsColorGammaR_Int32 = "cameraBoundsColorGammaR";
+static const char *k_pch_Camera_BoundsColorGammaG_Int32 = "cameraBoundsColorGammaG";
+static const char *k_pch_Camera_BoundsColorGammaB_Int32 = "cameraBoundsColorGammaB";
+static const char *k_pch_Camera_BoundsColorGammaA_Int32 = "cameraBoundsColorGammaA";
+static const char *k_pch_Camera_BoundsStrength_Int32 = "cameraBoundsStrength";
+static const char *k_pch_audio_Section = "audio";
+static const char *k_pch_audio_OnPlaybackDevice_String = "onPlaybackDevice";
+static const char *k_pch_audio_OnRecordDevice_String = "onRecordDevice";
+static const char *k_pch_audio_OnPlaybackMirrorDevice_String = "onPlaybackMirrorDevice";
+static const char *k_pch_audio_OffPlaybackDevice_String = "offPlaybackDevice";
+static const char *k_pch_audio_OffRecordDevice_String = "offRecordDevice";
+static const char *k_pch_audio_VIVEHDMIGain = "viveHDMIGain";
+static const char *k_pch_Power_Section = "power";
+static const char *k_pch_Power_PowerOffOnExit_Bool = "powerOffOnExit";
+static const char *k_pch_Power_TurnOffScreensTimeout_Float = "turnOffScreensTimeout";
+static const char *k_pch_Power_TurnOffControllersTimeout_Float = "turnOffControllersTimeout";
+static const char *k_pch_Power_ReturnToWatchdogTimeout_Float = "returnToWatchdogTimeout";
+static const char *k_pch_Power_AutoLaunchSteamVROnButtonPress = "autoLaunchSteamVROnButtonPress";
+static const char *k_pch_Power_PauseCompositorOnStandby_Bool = "pauseCompositorOnStandby";
+static const char *k_pch_Dashboard_Section = "dashboard";
+static const char *k_pch_Dashboard_EnableDashboard_Bool = "enableDashboard";
+static const char *k_pch_Dashboard_ArcadeMode_Bool = "arcadeMode";
+static const char *k_pch_modelskin_Section = "modelskins";
+static const char *k_pch_Driver_Enable_Bool = "enable";
+static const char *IVRScreenshots_Version = "IVRScreenshots_001";
+static const char *IVRResources_Version = "IVRResources_001";
+static const char *IVRDriverManager_Version = "IVRDriverManager_001";
+
+// OpenVR Enums
+
+typedef enum EVREye
+{
+	EVREye_Eye_Left = 0,
+	EVREye_Eye_Right = 1,
+} EVREye;
+
+typedef enum ETextureType
+{
+	ETextureType_TextureType_DirectX = 0,
+	ETextureType_TextureType_OpenGL = 1,
+	ETextureType_TextureType_Vulkan = 2,
+	ETextureType_TextureType_IOSurface = 3,
+	ETextureType_TextureType_DirectX12 = 4,
+} ETextureType;
+
+typedef enum EColorSpace
+{
+	EColorSpace_ColorSpace_Auto = 0,
+	EColorSpace_ColorSpace_Gamma = 1,
+	EColorSpace_ColorSpace_Linear = 2,
+} EColorSpace;
+
+typedef enum ETrackingResult
+{
+	ETrackingResult_TrackingResult_Uninitialized = 1,
+	ETrackingResult_TrackingResult_Calibrating_InProgress = 100,
+	ETrackingResult_TrackingResult_Calibrating_OutOfRange = 101,
+	ETrackingResult_TrackingResult_Running_OK = 200,
+	ETrackingResult_TrackingResult_Running_OutOfRange = 201,
+} ETrackingResult;
+
+typedef enum ETrackedDeviceClass
+{
+	ETrackedDeviceClass_TrackedDeviceClass_Invalid = 0,
+	ETrackedDeviceClass_TrackedDeviceClass_HMD = 1,
+	ETrackedDeviceClass_TrackedDeviceClass_Controller = 2,
+	ETrackedDeviceClass_TrackedDeviceClass_GenericTracker = 3,
+	ETrackedDeviceClass_TrackedDeviceClass_TrackingReference = 4,
+	ETrackedDeviceClass_TrackedDeviceClass_DisplayRedirect = 5,
+} ETrackedDeviceClass;
+
+typedef enum ETrackedControllerRole
+{
+	ETrackedControllerRole_TrackedControllerRole_Invalid = 0,
+	ETrackedControllerRole_TrackedControllerRole_LeftHand = 1,
+	ETrackedControllerRole_TrackedControllerRole_RightHand = 2,
+} ETrackedControllerRole;
+
+typedef enum ETrackingUniverseOrigin
+{
+	ETrackingUniverseOrigin_TrackingUniverseSeated = 0,
+	ETrackingUniverseOrigin_TrackingUniverseStanding = 1,
+	ETrackingUniverseOrigin_TrackingUniverseRawAndUncalibrated = 2,
+} ETrackingUniverseOrigin;
+
+typedef enum ETrackedDeviceProperty
+{
+	ETrackedDeviceProperty_Prop_Invalid = 0,
+	ETrackedDeviceProperty_Prop_TrackingSystemName_String = 1000,
+	ETrackedDeviceProperty_Prop_ModelNumber_String = 1001,
+	ETrackedDeviceProperty_Prop_SerialNumber_String = 1002,
+	ETrackedDeviceProperty_Prop_RenderModelName_String = 1003,
+	ETrackedDeviceProperty_Prop_WillDriftInYaw_Bool = 1004,
+	ETrackedDeviceProperty_Prop_ManufacturerName_String = 1005,
+	ETrackedDeviceProperty_Prop_TrackingFirmwareVersion_String = 1006,
+	ETrackedDeviceProperty_Prop_HardwareRevision_String = 1007,
+	ETrackedDeviceProperty_Prop_AllWirelessDongleDescriptions_String = 1008,
+	ETrackedDeviceProperty_Prop_ConnectedWirelessDongle_String = 1009,
+	ETrackedDeviceProperty_Prop_DeviceIsWireless_Bool = 1010,
+	ETrackedDeviceProperty_Prop_DeviceIsCharging_Bool = 1011,
+	ETrackedDeviceProperty_Prop_DeviceBatteryPercentage_Float = 1012,
+	ETrackedDeviceProperty_Prop_StatusDisplayTransform_Matrix34 = 1013,
+	ETrackedDeviceProperty_Prop_Firmware_UpdateAvailable_Bool = 1014,
+	ETrackedDeviceProperty_Prop_Firmware_ManualUpdate_Bool = 1015,
+	ETrackedDeviceProperty_Prop_Firmware_ManualUpdateURL_String = 1016,
+	ETrackedDeviceProperty_Prop_HardwareRevision_Uint64 = 1017,
+	ETrackedDeviceProperty_Prop_FirmwareVersion_Uint64 = 1018,
+	ETrackedDeviceProperty_Prop_FPGAVersion_Uint64 = 1019,
+	ETrackedDeviceProperty_Prop_VRCVersion_Uint64 = 1020,
+	ETrackedDeviceProperty_Prop_RadioVersion_Uint64 = 1021,
+	ETrackedDeviceProperty_Prop_DongleVersion_Uint64 = 1022,
+	ETrackedDeviceProperty_Prop_BlockServerShutdown_Bool = 1023,
+	ETrackedDeviceProperty_Prop_CanUnifyCoordinateSystemWithHmd_Bool = 1024,
+	ETrackedDeviceProperty_Prop_ContainsProximitySensor_Bool = 1025,
+	ETrackedDeviceProperty_Prop_DeviceProvidesBatteryStatus_Bool = 1026,
+	ETrackedDeviceProperty_Prop_DeviceCanPowerOff_Bool = 1027,
+	ETrackedDeviceProperty_Prop_Firmware_ProgrammingTarget_String = 1028,
+	ETrackedDeviceProperty_Prop_DeviceClass_Int32 = 1029,
+	ETrackedDeviceProperty_Prop_HasCamera_Bool = 1030,
+	ETrackedDeviceProperty_Prop_DriverVersion_String = 1031,
+	ETrackedDeviceProperty_Prop_Firmware_ForceUpdateRequired_Bool = 1032,
+	ETrackedDeviceProperty_Prop_ViveSystemButtonFixRequired_Bool = 1033,
+	ETrackedDeviceProperty_Prop_ParentDriver_Uint64 = 1034,
+	ETrackedDeviceProperty_Prop_ResourceRoot_String = 1035,
+	ETrackedDeviceProperty_Prop_ReportsTimeSinceVSync_Bool = 2000,
+	ETrackedDeviceProperty_Prop_SecondsFromVsyncToPhotons_Float = 2001,
+	ETrackedDeviceProperty_Prop_DisplayFrequency_Float = 2002,
+	ETrackedDeviceProperty_Prop_UserIpdMeters_Float = 2003,
+	ETrackedDeviceProperty_Prop_CurrentUniverseId_Uint64 = 2004,
+	ETrackedDeviceProperty_Prop_PreviousUniverseId_Uint64 = 2005,
+	ETrackedDeviceProperty_Prop_DisplayFirmwareVersion_Uint64 = 2006,
+	ETrackedDeviceProperty_Prop_IsOnDesktop_Bool = 2007,
+	ETrackedDeviceProperty_Prop_DisplayMCType_Int32 = 2008,
+	ETrackedDeviceProperty_Prop_DisplayMCOffset_Float = 2009,
+	ETrackedDeviceProperty_Prop_DisplayMCScale_Float = 2010,
+	ETrackedDeviceProperty_Prop_EdidVendorID_Int32 = 2011,
+	ETrackedDeviceProperty_Prop_DisplayMCImageLeft_String = 2012,
+	ETrackedDeviceProperty_Prop_DisplayMCImageRight_String = 2013,
+	ETrackedDeviceProperty_Prop_DisplayGCBlackClamp_Float = 2014,
+	ETrackedDeviceProperty_Prop_EdidProductID_Int32 = 2015,
+	ETrackedDeviceProperty_Prop_CameraToHeadTransform_Matrix34 = 2016,
+	ETrackedDeviceProperty_Prop_DisplayGCType_Int32 = 2017,
+	ETrackedDeviceProperty_Prop_DisplayGCOffset_Float = 2018,
+	ETrackedDeviceProperty_Prop_DisplayGCScale_Float = 2019,
+	ETrackedDeviceProperty_Prop_DisplayGCPrescale_Float = 2020,
+	ETrackedDeviceProperty_Prop_DisplayGCImage_String = 2021,
+	ETrackedDeviceProperty_Prop_LensCenterLeftU_Float = 2022,
+	ETrackedDeviceProperty_Prop_LensCenterLeftV_Float = 2023,
+	ETrackedDeviceProperty_Prop_LensCenterRightU_Float = 2024,
+	ETrackedDeviceProperty_Prop_LensCenterRightV_Float = 2025,
+	ETrackedDeviceProperty_Prop_UserHeadToEyeDepthMeters_Float = 2026,
+	ETrackedDeviceProperty_Prop_CameraFirmwareVersion_Uint64 = 2027,
+	ETrackedDeviceProperty_Prop_CameraFirmwareDescription_String = 2028,
+	ETrackedDeviceProperty_Prop_DisplayFPGAVersion_Uint64 = 2029,
+	ETrackedDeviceProperty_Prop_DisplayBootloaderVersion_Uint64 = 2030,
+	ETrackedDeviceProperty_Prop_DisplayHardwareVersion_Uint64 = 2031,
+	ETrackedDeviceProperty_Prop_AudioFirmwareVersion_Uint64 = 2032,
+	ETrackedDeviceProperty_Prop_CameraCompatibilityMode_Int32 = 2033,
+	ETrackedDeviceProperty_Prop_ScreenshotHorizontalFieldOfViewDegrees_Float = 2034,
+	ETrackedDeviceProperty_Prop_ScreenshotVerticalFieldOfViewDegrees_Float = 2035,
+	ETrackedDeviceProperty_Prop_DisplaySuppressed_Bool = 2036,
+	ETrackedDeviceProperty_Prop_DisplayAllowNightMode_Bool = 2037,
+	ETrackedDeviceProperty_Prop_DisplayMCImageWidth_Int32 = 2038,
+	ETrackedDeviceProperty_Prop_DisplayMCImageHeight_Int32 = 2039,
+	ETrackedDeviceProperty_Prop_DisplayMCImageNumChannels_Int32 = 2040,
+	ETrackedDeviceProperty_Prop_DisplayMCImageData_Binary = 2041,
+	ETrackedDeviceProperty_Prop_SecondsFromPhotonsToVblank_Float = 2042,
+	ETrackedDeviceProperty_Prop_DriverDirectModeSendsVsyncEvents_Bool = 2043,
+	ETrackedDeviceProperty_Prop_DisplayDebugMode_Bool = 2044,
+	ETrackedDeviceProperty_Prop_GraphicsAdapterLuid_Uint64 = 2045,
+	ETrackedDeviceProperty_Prop_DriverProvidedChaperonePath_String = 2048,
+	ETrackedDeviceProperty_Prop_AttachedDeviceId_String = 3000,
+	ETrackedDeviceProperty_Prop_SupportedButtons_Uint64 = 3001,
+	ETrackedDeviceProperty_Prop_Axis0Type_Int32 = 3002,
+	ETrackedDeviceProperty_Prop_Axis1Type_Int32 = 3003,
+	ETrackedDeviceProperty_Prop_Axis2Type_Int32 = 3004,
+	ETrackedDeviceProperty_Prop_Axis3Type_Int32 = 3005,
+	ETrackedDeviceProperty_Prop_Axis4Type_Int32 = 3006,
+	ETrackedDeviceProperty_Prop_ControllerRoleHint_Int32 = 3007,
+	ETrackedDeviceProperty_Prop_FieldOfViewLeftDegrees_Float = 4000,
+	ETrackedDeviceProperty_Prop_FieldOfViewRightDegrees_Float = 4001,
+	ETrackedDeviceProperty_Prop_FieldOfViewTopDegrees_Float = 4002,
+	ETrackedDeviceProperty_Prop_FieldOfViewBottomDegrees_Float = 4003,
+	ETrackedDeviceProperty_Prop_TrackingRangeMinimumMeters_Float = 4004,
+	ETrackedDeviceProperty_Prop_TrackingRangeMaximumMeters_Float = 4005,
+	ETrackedDeviceProperty_Prop_ModeLabel_String = 4006,
+	ETrackedDeviceProperty_Prop_IconPathName_String = 5000,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceOff_String = 5001,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceSearching_String = 5002,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceSearchingAlert_String = 5003,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceReady_String = 5004,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceReadyAlert_String = 5005,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceNotReady_String = 5006,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceStandby_String = 5007,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceAlertLow_String = 5008,
+	ETrackedDeviceProperty_Prop_DisplayHiddenArea_Binary_Start = 5100,
+	ETrackedDeviceProperty_Prop_DisplayHiddenArea_Binary_End = 5150,
+	ETrackedDeviceProperty_Prop_UserConfigPath_String = 6000,
+	ETrackedDeviceProperty_Prop_InstallPath_String = 6001,
+	ETrackedDeviceProperty_Prop_HasDisplayComponent_Bool = 6002,
+	ETrackedDeviceProperty_Prop_HasControllerComponent_Bool = 6003,
+	ETrackedDeviceProperty_Prop_HasCameraComponent_Bool = 6004,
+	ETrackedDeviceProperty_Prop_HasDriverDirectModeComponent_Bool = 6005,
+	ETrackedDeviceProperty_Prop_HasVirtualDisplayComponent_Bool = 6006,
+	ETrackedDeviceProperty_Prop_VendorSpecific_Reserved_Start = 10000,
+	ETrackedDeviceProperty_Prop_VendorSpecific_Reserved_End = 10999,
+} ETrackedDeviceProperty;
+
+typedef enum ETrackedPropertyError
+{
+	ETrackedPropertyError_TrackedProp_Success = 0,
+	ETrackedPropertyError_TrackedProp_WrongDataType = 1,
+	ETrackedPropertyError_TrackedProp_WrongDeviceClass = 2,
+	ETrackedPropertyError_TrackedProp_BufferTooSmall = 3,
+	ETrackedPropertyError_TrackedProp_UnknownProperty = 4,
+	ETrackedPropertyError_TrackedProp_InvalidDevice = 5,
+	ETrackedPropertyError_TrackedProp_CouldNotContactServer = 6,
+	ETrackedPropertyError_TrackedProp_ValueNotProvidedByDevice = 7,
+	ETrackedPropertyError_TrackedProp_StringExceedsMaximumLength = 8,
+	ETrackedPropertyError_TrackedProp_NotYetAvailable = 9,
+	ETrackedPropertyError_TrackedProp_PermissionDenied = 10,
+	ETrackedPropertyError_TrackedProp_InvalidOperation = 11,
+} ETrackedPropertyError;
+
+typedef enum EVRSubmitFlags
+{
+	EVRSubmitFlags_Submit_Default = 0,
+	EVRSubmitFlags_Submit_LensDistortionAlreadyApplied = 1,
+	EVRSubmitFlags_Submit_GlRenderBuffer = 2,
+	EVRSubmitFlags_Submit_Reserved = 4,
+	EVRSubmitFlags_Submit_TextureWithPose = 8,
+} EVRSubmitFlags;
+
+typedef enum EVRState
+{
+	EVRState_VRState_Undefined = -1,
+	EVRState_VRState_Off = 0,
+	EVRState_VRState_Searching = 1,
+	EVRState_VRState_Searching_Alert = 2,
+	EVRState_VRState_Ready = 3,
+	EVRState_VRState_Ready_Alert = 4,
+	EVRState_VRState_NotReady = 5,
+	EVRState_VRState_Standby = 6,
+	EVRState_VRState_Ready_Alert_Low = 7,
+} EVRState;
+
+typedef enum EVREventType
+{
+	EVREventType_VREvent_None = 0,
+	EVREventType_VREvent_TrackedDeviceActivated = 100,
+	EVREventType_VREvent_TrackedDeviceDeactivated = 101,
+	EVREventType_VREvent_TrackedDeviceUpdated = 102,
+	EVREventType_VREvent_TrackedDeviceUserInteractionStarted = 103,
+	EVREventType_VREvent_TrackedDeviceUserInteractionEnded = 104,
+	EVREventType_VREvent_IpdChanged = 105,
+	EVREventType_VREvent_EnterStandbyMode = 106,
+	EVREventType_VREvent_LeaveStandbyMode = 107,
+	EVREventType_VREvent_TrackedDeviceRoleChanged = 108,
+	EVREventType_VREvent_WatchdogWakeUpRequested = 109,
+	EVREventType_VREvent_LensDistortionChanged = 110,
+	EVREventType_VREvent_PropertyChanged = 111,
+	EVREventType_VREvent_WirelessDisconnect = 112,
+	EVREventType_VREvent_WirelessReconnect = 113,
+	EVREventType_VREvent_ButtonPress = 200,
+	EVREventType_VREvent_ButtonUnpress = 201,
+	EVREventType_VREvent_ButtonTouch = 202,
+	EVREventType_VREvent_ButtonUntouch = 203,
+	EVREventType_VREvent_MouseMove = 300,
+	EVREventType_VREvent_MouseButtonDown = 301,
+	EVREventType_VREvent_MouseButtonUp = 302,
+	EVREventType_VREvent_FocusEnter = 303,
+	EVREventType_VREvent_FocusLeave = 304,
+	EVREventType_VREvent_Scroll = 305,
+	EVREventType_VREvent_TouchPadMove = 306,
+	EVREventType_VREvent_OverlayFocusChanged = 307,
+	EVREventType_VREvent_InputFocusCaptured = 400,
+	EVREventType_VREvent_InputFocusReleased = 401,
+	EVREventType_VREvent_SceneFocusLost = 402,
+	EVREventType_VREvent_SceneFocusGained = 403,
+	EVREventType_VREvent_SceneApplicationChanged = 404,
+	EVREventType_VREvent_SceneFocusChanged = 405,
+	EVREventType_VREvent_InputFocusChanged = 406,
+	EVREventType_VREvent_SceneApplicationSecondaryRenderingStarted = 407,
+	EVREventType_VREvent_HideRenderModels = 410,
+	EVREventType_VREvent_ShowRenderModels = 411,
+	EVREventType_VREvent_OverlayShown = 500,
+	EVREventType_VREvent_OverlayHidden = 501,
+	EVREventType_VREvent_DashboardActivated = 502,
+	EVREventType_VREvent_DashboardDeactivated = 503,
+	EVREventType_VREvent_DashboardThumbSelected = 504,
+	EVREventType_VREvent_DashboardRequested = 505,
+	EVREventType_VREvent_ResetDashboard = 506,
+	EVREventType_VREvent_RenderToast = 507,
+	EVREventType_VREvent_ImageLoaded = 508,
+	EVREventType_VREvent_ShowKeyboard = 509,
+	EVREventType_VREvent_HideKeyboard = 510,
+	EVREventType_VREvent_OverlayGamepadFocusGained = 511,
+	EVREventType_VREvent_OverlayGamepadFocusLost = 512,
+	EVREventType_VREvent_OverlaySharedTextureChanged = 513,
+	EVREventType_VREvent_DashboardGuideButtonDown = 514,
+	EVREventType_VREvent_DashboardGuideButtonUp = 515,
+	EVREventType_VREvent_ScreenshotTriggered = 516,
+	EVREventType_VREvent_ImageFailed = 517,
+	EVREventType_VREvent_DashboardOverlayCreated = 518,
+	EVREventType_VREvent_RequestScreenshot = 520,
+	EVREventType_VREvent_ScreenshotTaken = 521,
+	EVREventType_VREvent_ScreenshotFailed = 522,
+	EVREventType_VREvent_SubmitScreenshotToDashboard = 523,
+	EVREventType_VREvent_ScreenshotProgressToDashboard = 524,
+	EVREventType_VREvent_PrimaryDashboardDeviceChanged = 525,
+	EVREventType_VREvent_Notification_Shown = 600,
+	EVREventType_VREvent_Notification_Hidden = 601,
+	EVREventType_VREvent_Notification_BeginInteraction = 602,
+	EVREventType_VREvent_Notification_Destroyed = 603,
+	EVREventType_VREvent_Quit = 700,
+	EVREventType_VREvent_ProcessQuit = 701,
+	EVREventType_VREvent_QuitAborted_UserPrompt = 702,
+	EVREventType_VREvent_QuitAcknowledged = 703,
+	EVREventType_VREvent_DriverRequestedQuit = 704,
+	EVREventType_VREvent_ChaperoneDataHasChanged = 800,
+	EVREventType_VREvent_ChaperoneUniverseHasChanged = 801,
+	EVREventType_VREvent_ChaperoneTempDataHasChanged = 802,
+	EVREventType_VREvent_ChaperoneSettingsHaveChanged = 803,
+	EVREventType_VREvent_SeatedZeroPoseReset = 804,
+	EVREventType_VREvent_AudioSettingsHaveChanged = 820,
+	EVREventType_VREvent_BackgroundSettingHasChanged = 850,
+	EVREventType_VREvent_CameraSettingsHaveChanged = 851,
+	EVREventType_VREvent_ReprojectionSettingHasChanged = 852,
+	EVREventType_VREvent_ModelSkinSettingsHaveChanged = 853,
+	EVREventType_VREvent_EnvironmentSettingsHaveChanged = 854,
+	EVREventType_VREvent_PowerSettingsHaveChanged = 855,
+	EVREventType_VREvent_EnableHomeAppSettingsHaveChanged = 856,
+	EVREventType_VREvent_StatusUpdate = 900,
+	EVREventType_VREvent_MCImageUpdated = 1000,
+	EVREventType_VREvent_FirmwareUpdateStarted = 1100,
+	EVREventType_VREvent_FirmwareUpdateFinished = 1101,
+	EVREventType_VREvent_KeyboardClosed = 1200,
+	EVREventType_VREvent_KeyboardCharInput = 1201,
+	EVREventType_VREvent_KeyboardDone = 1202,
+	EVREventType_VREvent_ApplicationTransitionStarted = 1300,
+	EVREventType_VREvent_ApplicationTransitionAborted = 1301,
+	EVREventType_VREvent_ApplicationTransitionNewAppStarted = 1302,
+	EVREventType_VREvent_ApplicationListUpdated = 1303,
+	EVREventType_VREvent_ApplicationMimeTypeLoad = 1304,
+	EVREventType_VREvent_ApplicationTransitionNewAppLaunchComplete = 1305,
+	EVREventType_VREvent_ProcessConnected = 1306,
+	EVREventType_VREvent_ProcessDisconnected = 1307,
+	EVREventType_VREvent_Compositor_MirrorWindowShown = 1400,
+	EVREventType_VREvent_Compositor_MirrorWindowHidden = 1401,
+	EVREventType_VREvent_Compositor_ChaperoneBoundsShown = 1410,
+	EVREventType_VREvent_Compositor_ChaperoneBoundsHidden = 1411,
+	EVREventType_VREvent_TrackedCamera_StartVideoStream = 1500,
+	EVREventType_VREvent_TrackedCamera_StopVideoStream = 1501,
+	EVREventType_VREvent_TrackedCamera_PauseVideoStream = 1502,
+	EVREventType_VREvent_TrackedCamera_ResumeVideoStream = 1503,
+	EVREventType_VREvent_TrackedCamera_EditingSurface = 1550,
+	EVREventType_VREvent_PerformanceTest_EnableCapture = 1600,
+	EVREventType_VREvent_PerformanceTest_DisableCapture = 1601,
+	EVREventType_VREvent_PerformanceTest_FidelityLevel = 1602,
+	EVREventType_VREvent_MessageOverlay_Closed = 1650,
+	EVREventType_VREvent_MessageOverlayCloseRequested = 1651,
+	EVREventType_VREvent_VendorSpecific_Reserved_Start = 10000,
+	EVREventType_VREvent_VendorSpecific_Reserved_End = 19999,
+} EVREventType;
+
+typedef enum EDeviceActivityLevel
+{
+	EDeviceActivityLevel_k_EDeviceActivityLevel_Unknown = -1,
+	EDeviceActivityLevel_k_EDeviceActivityLevel_Idle = 0,
+	EDeviceActivityLevel_k_EDeviceActivityLevel_UserInteraction = 1,
+	EDeviceActivityLevel_k_EDeviceActivityLevel_UserInteraction_Timeout = 2,
+	EDeviceActivityLevel_k_EDeviceActivityLevel_Standby = 3,
+} EDeviceActivityLevel;
+
+typedef enum EVRButtonId
+{
+	EVRButtonId_k_EButton_System = 0,
+	EVRButtonId_k_EButton_ApplicationMenu = 1,
+	EVRButtonId_k_EButton_Grip = 2,
+	EVRButtonId_k_EButton_DPad_Left = 3,
+	EVRButtonId_k_EButton_DPad_Up = 4,
+	EVRButtonId_k_EButton_DPad_Right = 5,
+	EVRButtonId_k_EButton_DPad_Down = 6,
+	EVRButtonId_k_EButton_A = 7,
+	EVRButtonId_k_EButton_ProximitySensor = 31,
+	EVRButtonId_k_EButton_Axis0 = 32,
+	EVRButtonId_k_EButton_Axis1 = 33,
+	EVRButtonId_k_EButton_Axis2 = 34,
+	EVRButtonId_k_EButton_Axis3 = 35,
+	EVRButtonId_k_EButton_Axis4 = 36,
+	EVRButtonId_k_EButton_SteamVR_Touchpad = 32,
+	EVRButtonId_k_EButton_SteamVR_Trigger = 33,
+	EVRButtonId_k_EButton_Dashboard_Back = 2,
+	EVRButtonId_k_EButton_Max = 64,
+} EVRButtonId;
+
+typedef enum EVRMouseButton
+{
+	EVRMouseButton_VRMouseButton_Left = 1,
+	EVRMouseButton_VRMouseButton_Right = 2,
+	EVRMouseButton_VRMouseButton_Middle = 4,
+} EVRMouseButton;
+
+typedef enum EHiddenAreaMeshType
+{
+	EHiddenAreaMeshType_k_eHiddenAreaMesh_Standard = 0,
+	EHiddenAreaMeshType_k_eHiddenAreaMesh_Inverse = 1,
+	EHiddenAreaMeshType_k_eHiddenAreaMesh_LineLoop = 2,
+	EHiddenAreaMeshType_k_eHiddenAreaMesh_Max = 3,
+} EHiddenAreaMeshType;
+
+typedef enum EVRControllerAxisType
+{
+	EVRControllerAxisType_k_eControllerAxis_None = 0,
+	EVRControllerAxisType_k_eControllerAxis_TrackPad = 1,
+	EVRControllerAxisType_k_eControllerAxis_Joystick = 2,
+	EVRControllerAxisType_k_eControllerAxis_Trigger = 3,
+} EVRControllerAxisType;
+
+typedef enum EVRControllerEventOutputType
+{
+	EVRControllerEventOutputType_ControllerEventOutput_OSEvents = 0,
+	EVRControllerEventOutputType_ControllerEventOutput_VREvents = 1,
+} EVRControllerEventOutputType;
+
+typedef enum ECollisionBoundsStyle
+{
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_BEGINNER = 0,
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_INTERMEDIATE = 1,
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_SQUARES = 2,
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_ADVANCED = 3,
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_NONE = 4,
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_COUNT = 5,
+} ECollisionBoundsStyle;
+
+typedef enum EVROverlayError
+{
+	EVROverlayError_VROverlayError_None = 0,
+	EVROverlayError_VROverlayError_UnknownOverlay = 10,
+	EVROverlayError_VROverlayError_InvalidHandle = 11,
+	EVROverlayError_VROverlayError_PermissionDenied = 12,
+	EVROverlayError_VROverlayError_OverlayLimitExceeded = 13,
+	EVROverlayError_VROverlayError_WrongVisibilityType = 14,
+	EVROverlayError_VROverlayError_KeyTooLong = 15,
+	EVROverlayError_VROverlayError_NameTooLong = 16,
+	EVROverlayError_VROverlayError_KeyInUse = 17,
+	EVROverlayError_VROverlayError_WrongTransformType = 18,
+	EVROverlayError_VROverlayError_InvalidTrackedDevice = 19,
+	EVROverlayError_VROverlayError_InvalidParameter = 20,
+	EVROverlayError_VROverlayError_ThumbnailCantBeDestroyed = 21,
+	EVROverlayError_VROverlayError_ArrayTooSmall = 22,
+	EVROverlayError_VROverlayError_RequestFailed = 23,
+	EVROverlayError_VROverlayError_InvalidTexture = 24,
+	EVROverlayError_VROverlayError_UnableToLoadFile = 25,
+	EVROverlayError_VROverlayError_KeyboardAlreadyInUse = 26,
+	EVROverlayError_VROverlayError_NoNeighbor = 27,
+	EVROverlayError_VROverlayError_TooManyMaskPrimitives = 29,
+	EVROverlayError_VROverlayError_BadMaskPrimitive = 30,
+} EVROverlayError;
+
+typedef enum EVRApplicationType
+{
+	EVRApplicationType_VRApplication_Other = 0,
+	EVRApplicationType_VRApplication_Scene = 1,
+	EVRApplicationType_VRApplication_Overlay = 2,
+	EVRApplicationType_VRApplication_Background = 3,
+	EVRApplicationType_VRApplication_Utility = 4,
+	EVRApplicationType_VRApplication_VRMonitor = 5,
+	EVRApplicationType_VRApplication_SteamWatchdog = 6,
+	EVRApplicationType_VRApplication_Bootstrapper = 7,
+	EVRApplicationType_VRApplication_Max = 8,
+} EVRApplicationType;
+
+typedef enum EVRFirmwareError
+{
+	EVRFirmwareError_VRFirmwareError_None = 0,
+	EVRFirmwareError_VRFirmwareError_Success = 1,
+	EVRFirmwareError_VRFirmwareError_Fail = 2,
+} EVRFirmwareError;
+
+typedef enum EVRNotificationError
+{
+	EVRNotificationError_VRNotificationError_OK = 0,
+	EVRNotificationError_VRNotificationError_InvalidNotificationId = 100,
+	EVRNotificationError_VRNotificationError_NotificationQueueFull = 101,
+	EVRNotificationError_VRNotificationError_InvalidOverlayHandle = 102,
+	EVRNotificationError_VRNotificationError_SystemWithUserValueAlreadyExists = 103,
+} EVRNotificationError;
+
+typedef enum EVRInitError
+{
+	EVRInitError_VRInitError_None = 0,
+	EVRInitError_VRInitError_Unknown = 1,
+	EVRInitError_VRInitError_Init_InstallationNotFound = 100,
+	EVRInitError_VRInitError_Init_InstallationCorrupt = 101,
+	EVRInitError_VRInitError_Init_VRClientDLLNotFound = 102,
+	EVRInitError_VRInitError_Init_FileNotFound = 103,
+	EVRInitError_VRInitError_Init_FactoryNotFound = 104,
+	EVRInitError_VRInitError_Init_InterfaceNotFound = 105,
+	EVRInitError_VRInitError_Init_InvalidInterface = 106,
+	EVRInitError_VRInitError_Init_UserConfigDirectoryInvalid = 107,
+	EVRInitError_VRInitError_Init_HmdNotFound = 108,
+	EVRInitError_VRInitError_Init_NotInitialized = 109,
+	EVRInitError_VRInitError_Init_PathRegistryNotFound = 110,
+	EVRInitError_VRInitError_Init_NoConfigPath = 111,
+	EVRInitError_VRInitError_Init_NoLogPath = 112,
+	EVRInitError_VRInitError_Init_PathRegistryNotWritable = 113,
+	EVRInitError_VRInitError_Init_AppInfoInitFailed = 114,
+	EVRInitError_VRInitError_Init_Retry = 115,
+	EVRInitError_VRInitError_Init_InitCanceledByUser = 116,
+	EVRInitError_VRInitError_Init_AnotherAppLaunching = 117,
+	EVRInitError_VRInitError_Init_SettingsInitFailed = 118,
+	EVRInitError_VRInitError_Init_ShuttingDown = 119,
+	EVRInitError_VRInitError_Init_TooManyObjects = 120,
+	EVRInitError_VRInitError_Init_NoServerForBackgroundApp = 121,
+	EVRInitError_VRInitError_Init_NotSupportedWithCompositor = 122,
+	EVRInitError_VRInitError_Init_NotAvailableToUtilityApps = 123,
+	EVRInitError_VRInitError_Init_Internal = 124,
+	EVRInitError_VRInitError_Init_HmdDriverIdIsNone = 125,
+	EVRInitError_VRInitError_Init_HmdNotFoundPresenceFailed = 126,
+	EVRInitError_VRInitError_Init_VRMonitorNotFound = 127,
+	EVRInitError_VRInitError_Init_VRMonitorStartupFailed = 128,
+	EVRInitError_VRInitError_Init_LowPowerWatchdogNotSupported = 129,
+	EVRInitError_VRInitError_Init_InvalidApplicationType = 130,
+	EVRInitError_VRInitError_Init_NotAvailableToWatchdogApps = 131,
+	EVRInitError_VRInitError_Init_WatchdogDisabledInSettings = 132,
+	EVRInitError_VRInitError_Init_VRDashboardNotFound = 133,
+	EVRInitError_VRInitError_Init_VRDashboardStartupFailed = 134,
+	EVRInitError_VRInitError_Init_VRHomeNotFound = 135,
+	EVRInitError_VRInitError_Init_VRHomeStartupFailed = 136,
+	EVRInitError_VRInitError_Init_RebootingBusy = 137,
+	EVRInitError_VRInitError_Init_FirmwareUpdateBusy = 138,
+	EVRInitError_VRInitError_Init_FirmwareRecoveryBusy = 139,
+	EVRInitError_VRInitError_Driver_Failed = 200,
+	EVRInitError_VRInitError_Driver_Unknown = 201,
+	EVRInitError_VRInitError_Driver_HmdUnknown = 202,
+	EVRInitError_VRInitError_Driver_NotLoaded = 203,
+	EVRInitError_VRInitError_Driver_RuntimeOutOfDate = 204,
+	EVRInitError_VRInitError_Driver_HmdInUse = 205,
+	EVRInitError_VRInitError_Driver_NotCalibrated = 206,
+	EVRInitError_VRInitError_Driver_CalibrationInvalid = 207,
+	EVRInitError_VRInitError_Driver_HmdDisplayNotFound = 208,
+	EVRInitError_VRInitError_Driver_TrackedDeviceInterfaceUnknown = 209,
+	EVRInitError_VRInitError_Driver_HmdDriverIdOutOfBounds = 211,
+	EVRInitError_VRInitError_Driver_HmdDisplayMirrored = 212,
+	EVRInitError_VRInitError_IPC_ServerInitFailed = 300,
+	EVRInitError_VRInitError_IPC_ConnectFailed = 301,
+	EVRInitError_VRInitError_IPC_SharedStateInitFailed = 302,
+	EVRInitError_VRInitError_IPC_CompositorInitFailed = 303,
+	EVRInitError_VRInitError_IPC_MutexInitFailed = 304,
+	EVRInitError_VRInitError_IPC_Failed = 305,
+	EVRInitError_VRInitError_IPC_CompositorConnectFailed = 306,
+	EVRInitError_VRInitError_IPC_CompositorInvalidConnectResponse = 307,
+	EVRInitError_VRInitError_IPC_ConnectFailedAfterMultipleAttempts = 308,
+	EVRInitError_VRInitError_Compositor_Failed = 400,
+	EVRInitError_VRInitError_Compositor_D3D11HardwareRequired = 401,
+	EVRInitError_VRInitError_Compositor_FirmwareRequiresUpdate = 402,
+	EVRInitError_VRInitError_Compositor_OverlayInitFailed = 403,
+	EVRInitError_VRInitError_Compositor_ScreenshotsInitFailed = 404,
+	EVRInitError_VRInitError_Compositor_UnableToCreateDevice = 405,
+	EVRInitError_VRInitError_VendorSpecific_UnableToConnectToOculusRuntime = 1000,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_CantOpenDevice = 1101,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToRequestConfigStart = 1102,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_NoStoredConfig = 1103,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_ConfigTooBig = 1104,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_ConfigTooSmall = 1105,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToInitZLib = 1106,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_CantReadFirmwareVersion = 1107,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToSendUserDataStart = 1108,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataStart = 1109,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataNext = 1110,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UserDataAddressRange = 1111,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UserDataError = 1112,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_ConfigFailedSanityCheck = 1113,
+	EVRInitError_VRInitError_Steam_SteamInstallationNotFound = 2000,
+} EVRInitError;
+
+typedef enum EVRScreenshotType
+{
+	EVRScreenshotType_VRScreenshotType_None = 0,
+	EVRScreenshotType_VRScreenshotType_Mono = 1,
+	EVRScreenshotType_VRScreenshotType_Stereo = 2,
+	EVRScreenshotType_VRScreenshotType_Cubemap = 3,
+	EVRScreenshotType_VRScreenshotType_MonoPanorama = 4,
+	EVRScreenshotType_VRScreenshotType_StereoPanorama = 5,
+} EVRScreenshotType;
+
+typedef enum EVRScreenshotPropertyFilenames
+{
+	EVRScreenshotPropertyFilenames_VRScreenshotPropertyFilenames_Preview = 0,
+	EVRScreenshotPropertyFilenames_VRScreenshotPropertyFilenames_VR = 1,
+} EVRScreenshotPropertyFilenames;
+
+typedef enum EVRTrackedCameraError
+{
+	EVRTrackedCameraError_VRTrackedCameraError_None = 0,
+	EVRTrackedCameraError_VRTrackedCameraError_OperationFailed = 100,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidHandle = 101,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidFrameHeaderVersion = 102,
+	EVRTrackedCameraError_VRTrackedCameraError_OutOfHandles = 103,
+	EVRTrackedCameraError_VRTrackedCameraError_IPCFailure = 104,
+	EVRTrackedCameraError_VRTrackedCameraError_NotSupportedForThisDevice = 105,
+	EVRTrackedCameraError_VRTrackedCameraError_SharedMemoryFailure = 106,
+	EVRTrackedCameraError_VRTrackedCameraError_FrameBufferingFailure = 107,
+	EVRTrackedCameraError_VRTrackedCameraError_StreamSetupFailure = 108,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidGLTextureId = 109,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidSharedTextureHandle = 110,
+	EVRTrackedCameraError_VRTrackedCameraError_FailedToGetGLTextureId = 111,
+	EVRTrackedCameraError_VRTrackedCameraError_SharedTextureFailure = 112,
+	EVRTrackedCameraError_VRTrackedCameraError_NoFrameAvailable = 113,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidArgument = 114,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidFrameBufferSize = 115,
+} EVRTrackedCameraError;
+
+typedef enum EVRTrackedCameraFrameType
+{
+	EVRTrackedCameraFrameType_VRTrackedCameraFrameType_Distorted = 0,
+	EVRTrackedCameraFrameType_VRTrackedCameraFrameType_Undistorted = 1,
+	EVRTrackedCameraFrameType_VRTrackedCameraFrameType_MaximumUndistorted = 2,
+	EVRTrackedCameraFrameType_MAX_CAMERA_FRAME_TYPES = 3,
+} EVRTrackedCameraFrameType;
+
+typedef enum EVRApplicationError
+{
+	EVRApplicationError_VRApplicationError_None = 0,
+	EVRApplicationError_VRApplicationError_AppKeyAlreadyExists = 100,
+	EVRApplicationError_VRApplicationError_NoManifest = 101,
+	EVRApplicationError_VRApplicationError_NoApplication = 102,
+	EVRApplicationError_VRApplicationError_InvalidIndex = 103,
+	EVRApplicationError_VRApplicationError_UnknownApplication = 104,
+	EVRApplicationError_VRApplicationError_IPCFailed = 105,
+	EVRApplicationError_VRApplicationError_ApplicationAlreadyRunning = 106,
+	EVRApplicationError_VRApplicationError_InvalidManifest = 107,
+	EVRApplicationError_VRApplicationError_InvalidApplication = 108,
+	EVRApplicationError_VRApplicationError_LaunchFailed = 109,
+	EVRApplicationError_VRApplicationError_ApplicationAlreadyStarting = 110,
+	EVRApplicationError_VRApplicationError_LaunchInProgress = 111,
+	EVRApplicationError_VRApplicationError_OldApplicationQuitting = 112,
+	EVRApplicationError_VRApplicationError_TransitionAborted = 113,
+	EVRApplicationError_VRApplicationError_IsTemplate = 114,
+	EVRApplicationError_VRApplicationError_SteamVRIsExiting = 115,
+	EVRApplicationError_VRApplicationError_BufferTooSmall = 200,
+	EVRApplicationError_VRApplicationError_PropertyNotSet = 201,
+	EVRApplicationError_VRApplicationError_UnknownProperty = 202,
+	EVRApplicationError_VRApplicationError_InvalidParameter = 203,
+} EVRApplicationError;
+
+typedef enum EVRApplicationProperty
+{
+	EVRApplicationProperty_VRApplicationProperty_Name_String = 0,
+	EVRApplicationProperty_VRApplicationProperty_LaunchType_String = 11,
+	EVRApplicationProperty_VRApplicationProperty_WorkingDirectory_String = 12,
+	EVRApplicationProperty_VRApplicationProperty_BinaryPath_String = 13,
+	EVRApplicationProperty_VRApplicationProperty_Arguments_String = 14,
+	EVRApplicationProperty_VRApplicationProperty_URL_String = 15,
+	EVRApplicationProperty_VRApplicationProperty_Description_String = 50,
+	EVRApplicationProperty_VRApplicationProperty_NewsURL_String = 51,
+	EVRApplicationProperty_VRApplicationProperty_ImagePath_String = 52,
+	EVRApplicationProperty_VRApplicationProperty_Source_String = 53,
+	EVRApplicationProperty_VRApplicationProperty_IsDashboardOverlay_Bool = 60,
+	EVRApplicationProperty_VRApplicationProperty_IsTemplate_Bool = 61,
+	EVRApplicationProperty_VRApplicationProperty_IsInstanced_Bool = 62,
+	EVRApplicationProperty_VRApplicationProperty_IsInternal_Bool = 63,
+	EVRApplicationProperty_VRApplicationProperty_WantsCompositorPauseInStandby_Bool = 64,
+	EVRApplicationProperty_VRApplicationProperty_LastLaunchTime_Uint64 = 70,
+} EVRApplicationProperty;
+
+typedef enum EVRApplicationTransitionState
+{
+	EVRApplicationTransitionState_VRApplicationTransition_None = 0,
+	EVRApplicationTransitionState_VRApplicationTransition_OldAppQuitSent = 10,
+	EVRApplicationTransitionState_VRApplicationTransition_WaitingForExternalLaunch = 11,
+	EVRApplicationTransitionState_VRApplicationTransition_NewAppLaunched = 20,
+} EVRApplicationTransitionState;
+
+typedef enum ChaperoneCalibrationState
+{
+	ChaperoneCalibrationState_OK = 1,
+	ChaperoneCalibrationState_Warning = 100,
+	ChaperoneCalibrationState_Warning_BaseStationMayHaveMoved = 101,
+	ChaperoneCalibrationState_Warning_BaseStationRemoved = 102,
+	ChaperoneCalibrationState_Warning_SeatedBoundsInvalid = 103,
+	ChaperoneCalibrationState_Error = 200,
+	ChaperoneCalibrationState_Error_BaseStationUninitialized = 201,
+	ChaperoneCalibrationState_Error_BaseStationConflict = 202,
+	ChaperoneCalibrationState_Error_PlayAreaInvalid = 203,
+	ChaperoneCalibrationState_Error_CollisionBoundsInvalid = 204,
+} ChaperoneCalibrationState;
+
+typedef enum EChaperoneConfigFile
+{
+	EChaperoneConfigFile_Live = 1,
+	EChaperoneConfigFile_Temp = 2,
+} EChaperoneConfigFile;
+
+typedef enum EChaperoneImportFlags
+{
+	EChaperoneImportFlags_EChaperoneImport_BoundsOnly = 1,
+} EChaperoneImportFlags;
+
+typedef enum EVRCompositorError
+{
+	EVRCompositorError_VRCompositorError_None = 0,
+	EVRCompositorError_VRCompositorError_RequestFailed = 1,
+	EVRCompositorError_VRCompositorError_IncompatibleVersion = 100,
+	EVRCompositorError_VRCompositorError_DoNotHaveFocus = 101,
+	EVRCompositorError_VRCompositorError_InvalidTexture = 102,
+	EVRCompositorError_VRCompositorError_IsNotSceneApplication = 103,
+	EVRCompositorError_VRCompositorError_TextureIsOnWrongDevice = 104,
+	EVRCompositorError_VRCompositorError_TextureUsesUnsupportedFormat = 105,
+	EVRCompositorError_VRCompositorError_SharedTexturesNotSupported = 106,
+	EVRCompositorError_VRCompositorError_IndexOutOfRange = 107,
+	EVRCompositorError_VRCompositorError_AlreadySubmitted = 108,
+	EVRCompositorError_VRCompositorError_InvalidBounds = 109,
+} EVRCompositorError;
+
+typedef enum VROverlayInputMethod
+{
+	VROverlayInputMethod_None = 0,
+	VROverlayInputMethod_Mouse = 1,
+} VROverlayInputMethod;
+
+typedef enum VROverlayTransformType
+{
+	VROverlayTransformType_VROverlayTransform_Absolute = 0,
+	VROverlayTransformType_VROverlayTransform_TrackedDeviceRelative = 1,
+	VROverlayTransformType_VROverlayTransform_SystemOverlay = 2,
+	VROverlayTransformType_VROverlayTransform_TrackedComponent = 3,
+} VROverlayTransformType;
+
+typedef enum VROverlayFlags
+{
+	VROverlayFlags_None = 0,
+	VROverlayFlags_Curved = 1,
+	VROverlayFlags_RGSS4X = 2,
+	VROverlayFlags_NoDashboardTab = 3,
+	VROverlayFlags_AcceptsGamepadEvents = 4,
+	VROverlayFlags_ShowGamepadFocus = 5,
+	VROverlayFlags_SendVRScrollEvents = 6,
+	VROverlayFlags_SendVRTouchpadEvents = 7,
+	VROverlayFlags_ShowTouchPadScrollWheel = 8,
+	VROverlayFlags_TransferOwnershipToInternalProcess = 9,
+	VROverlayFlags_SideBySide_Parallel = 10,
+	VROverlayFlags_SideBySide_Crossed = 11,
+	VROverlayFlags_Panorama = 12,
+	VROverlayFlags_StereoPanorama = 13,
+	VROverlayFlags_SortWithNonSceneOverlays = 14,
+	VROverlayFlags_VisibleInDashboard = 15,
+} VROverlayFlags;
+
+typedef enum VRMessageOverlayResponse
+{
+	VRMessageOverlayResponse_ButtonPress_0 = 0,
+	VRMessageOverlayResponse_ButtonPress_1 = 1,
+	VRMessageOverlayResponse_ButtonPress_2 = 2,
+	VRMessageOverlayResponse_ButtonPress_3 = 3,
+	VRMessageOverlayResponse_CouldntFindSystemOverlay = 4,
+	VRMessageOverlayResponse_CouldntFindOrCreateClientOverlay = 5,
+	VRMessageOverlayResponse_ApplicationQuit = 6,
+} VRMessageOverlayResponse;
+
+typedef enum EGamepadTextInputMode
+{
+	EGamepadTextInputMode_k_EGamepadTextInputModeNormal = 0,
+	EGamepadTextInputMode_k_EGamepadTextInputModePassword = 1,
+	EGamepadTextInputMode_k_EGamepadTextInputModeSubmit = 2,
+} EGamepadTextInputMode;
+
+typedef enum EGamepadTextInputLineMode
+{
+	EGamepadTextInputLineMode_k_EGamepadTextInputLineModeSingleLine = 0,
+	EGamepadTextInputLineMode_k_EGamepadTextInputLineModeMultipleLines = 1,
+} EGamepadTextInputLineMode;
+
+typedef enum EOverlayDirection
+{
+	EOverlayDirection_OverlayDirection_Up = 0,
+	EOverlayDirection_OverlayDirection_Down = 1,
+	EOverlayDirection_OverlayDirection_Left = 2,
+	EOverlayDirection_OverlayDirection_Right = 3,
+	EOverlayDirection_OverlayDirection_Count = 4,
+} EOverlayDirection;
+
+typedef enum EVROverlayIntersectionMaskPrimitiveType
+{
+	EVROverlayIntersectionMaskPrimitiveType_OverlayIntersectionPrimitiveType_Rectangle = 0,
+	EVROverlayIntersectionMaskPrimitiveType_OverlayIntersectionPrimitiveType_Circle = 1,
+} EVROverlayIntersectionMaskPrimitiveType;
+
+typedef enum EVRRenderModelError
+{
+	EVRRenderModelError_VRRenderModelError_None = 0,
+	EVRRenderModelError_VRRenderModelError_Loading = 100,
+	EVRRenderModelError_VRRenderModelError_NotSupported = 200,
+	EVRRenderModelError_VRRenderModelError_InvalidArg = 300,
+	EVRRenderModelError_VRRenderModelError_InvalidModel = 301,
+	EVRRenderModelError_VRRenderModelError_NoShapes = 302,
+	EVRRenderModelError_VRRenderModelError_MultipleShapes = 303,
+	EVRRenderModelError_VRRenderModelError_TooManyVertices = 304,
+	EVRRenderModelError_VRRenderModelError_MultipleTextures = 305,
+	EVRRenderModelError_VRRenderModelError_BufferTooSmall = 306,
+	EVRRenderModelError_VRRenderModelError_NotEnoughNormals = 307,
+	EVRRenderModelError_VRRenderModelError_NotEnoughTexCoords = 308,
+	EVRRenderModelError_VRRenderModelError_InvalidTexture = 400,
+} EVRRenderModelError;
+
+typedef enum EVRComponentProperty
+{
+	EVRComponentProperty_VRComponentProperty_IsStatic = 1,
+	EVRComponentProperty_VRComponentProperty_IsVisible = 2,
+	EVRComponentProperty_VRComponentProperty_IsTouched = 4,
+	EVRComponentProperty_VRComponentProperty_IsPressed = 8,
+	EVRComponentProperty_VRComponentProperty_IsScrolled = 16,
+} EVRComponentProperty;
+
+typedef enum EVRNotificationType
+{
+	EVRNotificationType_Transient = 0,
+	EVRNotificationType_Persistent = 1,
+	EVRNotificationType_Transient_SystemWithUserValue = 2,
+} EVRNotificationType;
+
+typedef enum EVRNotificationStyle
+{
+	EVRNotificationStyle_None = 0,
+	EVRNotificationStyle_Application = 100,
+	EVRNotificationStyle_Contact_Disabled = 200,
+	EVRNotificationStyle_Contact_Enabled = 201,
+	EVRNotificationStyle_Contact_Active = 202,
+} EVRNotificationStyle;
+
+typedef enum EVRSettingsError
+{
+	EVRSettingsError_VRSettingsError_None = 0,
+	EVRSettingsError_VRSettingsError_IPCFailed = 1,
+	EVRSettingsError_VRSettingsError_WriteFailed = 2,
+	EVRSettingsError_VRSettingsError_ReadFailed = 3,
+	EVRSettingsError_VRSettingsError_JsonParseFailed = 4,
+	EVRSettingsError_VRSettingsError_UnsetSettingHasNoDefault = 5,
+} EVRSettingsError;
+
+typedef enum EVRScreenshotError
+{
+	EVRScreenshotError_VRScreenshotError_None = 0,
+	EVRScreenshotError_VRScreenshotError_RequestFailed = 1,
+	EVRScreenshotError_VRScreenshotError_IncompatibleVersion = 100,
+	EVRScreenshotError_VRScreenshotError_NotFound = 101,
+	EVRScreenshotError_VRScreenshotError_BufferTooSmall = 102,
+	EVRScreenshotError_VRScreenshotError_ScreenshotAlreadyInProgress = 108,
+} EVRScreenshotError;
+
+// OpenVR typedefs
+
+typedef uint32_t TrackedDeviceIndex_t;
+typedef uint32_t VRNotificationId;
+typedef uint64_t VROverlayHandle_t;
+
+typedef void *glSharedTextureHandle_t;
+typedef int32_t glInt_t;
+typedef uint32_t glUInt_t;
+typedef uint64_t SharedTextureHandle_t;
+typedef uint32_t DriverId_t;
+typedef uint32_t TrackedDeviceIndex_t;
+typedef uint64_t PropertyContainerHandle_t;
+typedef uint32_t PropertyTypeTag_t;
+typedef uint64_t VROverlayHandle_t;
+typedef uint64_t TrackedCameraHandle_t;
+typedef uint32_t ScreenshotHandle_t;
+typedef uint32_t VRComponentProperties;
+typedef int32_t TextureID_t;
+typedef uint32_t VRNotificationId;
+typedef EVRInitError HmdError;
+typedef EVREye Hmd_Eye;
+typedef EColorSpace ColorSpace;
+typedef ETrackingResult HmdTrackingResult;
+typedef ETrackedDeviceClass TrackedDeviceClass;
+typedef ETrackingUniverseOrigin TrackingUniverseOrigin;
+typedef ETrackedDeviceProperty TrackedDeviceProperty;
+typedef ETrackedPropertyError TrackedPropertyError;
+typedef EVRSubmitFlags VRSubmitFlags_t;
+typedef EVRState VRState_t;
+typedef ECollisionBoundsStyle CollisionBoundsStyle_t;
+typedef EVROverlayError VROverlayError;
+typedef EVRFirmwareError VRFirmwareError;
+typedef EVRCompositorError VRCompositorError;
+typedef EVRScreenshotError VRScreenshotsError;
+
+// OpenVR Structs
+
+typedef struct HmdMatrix34_t
+{
+	float m[3][4];  //float[3][4]
+} HmdMatrix34_t;
+
+typedef struct HmdMatrix44_t
+{
+	float m[4][4];  //float[4][4]
+} HmdMatrix44_t;
+
+typedef struct HmdVector3_t
+{
+	float v[3];  //float[3]
+} HmdVector3_t;
+
+typedef struct HmdVector4_t
+{
+	float v[4];  //float[4]
+} HmdVector4_t;
+
+typedef struct HmdVector3d_t
+{
+	double v[3];  //double[3]
+} HmdVector3d_t;
+
+typedef struct HmdVector2_t
+{
+	float v[2];  //float[2]
+} HmdVector2_t;
+
+typedef struct HmdQuaternion_t
+{
+	double w;
+	double x;
+	double y;
+	double z;
+} HmdQuaternion_t;
+
+typedef struct HmdColor_t
+{
+	float r;
+	float g;
+	float b;
+	float a;
+} HmdColor_t;
+
+typedef struct HmdQuad_t
+{
+	struct HmdVector3_t vCorners[4];  //struct vr::HmdVector3_t[4]
+} HmdQuad_t;
+
+typedef struct HmdRect2_t
+{
+	struct HmdVector2_t vTopLeft;
+	struct HmdVector2_t vBottomRight;
+} HmdRect2_t;
+
+typedef struct DistortionCoordinates_t
+{
+	float rfRed[2];    //float[2]
+	float rfGreen[2];  //float[2]
+	float rfBlue[2];   //float[2]
+} DistortionCoordinates_t;
+
+typedef struct Texture_t
+{
+	void *handle;  // void *
+	enum ETextureType eType;
+	enum EColorSpace eColorSpace;
+} Texture_t;
+
+typedef struct TrackedDevicePose_t
+{
+	struct HmdMatrix34_t mDeviceToAbsoluteTracking;
+	struct HmdVector3_t vVelocity;
+	struct HmdVector3_t vAngularVelocity;
+	enum ETrackingResult eTrackingResult;
+	bool bPoseIsValid;
+	bool bDeviceIsConnected;
+} TrackedDevicePose_t;
+
+typedef struct VRTextureBounds_t
+{
+	float uMin;
+	float vMin;
+	float uMax;
+	float vMax;
+} VRTextureBounds_t;
+
+typedef struct VRTextureWithPose_t
+{
+	struct HmdMatrix34_t mDeviceToAbsoluteTracking;
+} VRTextureWithPose_t;
+
+typedef struct VRVulkanTextureData_t
+{
+	uint64_t m_nImage;
+	struct VkDevice_T *m_pDevice;                  // struct VkDevice_T *
+	struct VkPhysicalDevice_T *m_pPhysicalDevice;  // struct VkPhysicalDevice_T *
+	struct VkInstance_T *m_pInstance;              // struct VkInstance_T *
+	struct VkQueue_T *m_pQueue;                    // struct VkQueue_T *
+	uint32_t m_nQueueFamilyIndex;
+	uint32_t m_nWidth;
+	uint32_t m_nHeight;
+	uint32_t m_nFormat;
+	uint32_t m_nSampleCount;
+} VRVulkanTextureData_t;
+
+typedef struct D3D12TextureData_t
+{
+	struct ID3D12Resource *m_pResource;          // struct ID3D12Resource *
+	struct ID3D12CommandQueue *m_pCommandQueue;  // struct ID3D12CommandQueue *
+	uint32_t m_nNodeMask;
+} D3D12TextureData_t;
+
+typedef struct VREvent_Controller_t
+{
+	uint32_t button;
+} VREvent_Controller_t;
+
+typedef struct VREvent_Mouse_t
+{
+	float x;
+	float y;
+	uint32_t button;
+} VREvent_Mouse_t;
+
+typedef struct VREvent_Scroll_t
+{
+	float xdelta;
+	float ydelta;
+	uint32_t repeatCount;
+} VREvent_Scroll_t;
+
+typedef struct VREvent_TouchPadMove_t
+{
+	bool bFingerDown;
+	float flSecondsFingerDown;
+	float fValueXFirst;
+	float fValueYFirst;
+	float fValueXRaw;
+	float fValueYRaw;
+} VREvent_TouchPadMove_t;
+
+typedef struct VREvent_Notification_t
+{
+	uint64_t ulUserValue;
+	uint32_t notificationId;
+} VREvent_Notification_t;
+
+typedef struct VREvent_Process_t
+{
+	uint32_t pid;
+	uint32_t oldPid;
+	bool bForced;
+} VREvent_Process_t;
+
+typedef struct VREvent_Overlay_t
+{
+	uint64_t overlayHandle;
+} VREvent_Overlay_t;
+
+typedef struct VREvent_Status_t
+{
+	uint32_t statusState;
+} VREvent_Status_t;
+
+typedef struct VREvent_Keyboard_t
+{
+	char *cNewInput[8];  //char[8]
+	uint64_t uUserValue;
+} VREvent_Keyboard_t;
+
+typedef struct VREvent_Ipd_t
+{
+	float ipdMeters;
+} VREvent_Ipd_t;
+
+typedef struct VREvent_Chaperone_t
+{
+	uint64_t m_nPreviousUniverse;
+	uint64_t m_nCurrentUniverse;
+} VREvent_Chaperone_t;
+
+typedef struct VREvent_Reserved_t
+{
+	uint64_t reserved0;
+	uint64_t reserved1;
+} VREvent_Reserved_t;
+
+typedef struct VREvent_PerformanceTest_t
+{
+	uint32_t m_nFidelityLevel;
+} VREvent_PerformanceTest_t;
+
+typedef struct VREvent_SeatedZeroPoseReset_t
+{
+	bool bResetBySystemMenu;
+} VREvent_SeatedZeroPoseReset_t;
+
+typedef struct VREvent_Screenshot_t
+{
+	uint32_t handle;
+	uint32_t type;
+} VREvent_Screenshot_t;
+
+typedef struct VREvent_ScreenshotProgress_t
+{
+	float progress;
+} VREvent_ScreenshotProgress_t;
+
+typedef struct VREvent_ApplicationLaunch_t
+{
+	uint32_t pid;
+	uint32_t unArgsHandle;
+} VREvent_ApplicationLaunch_t;
+
+typedef struct VREvent_EditingCameraSurface_t
+{
+	uint64_t overlayHandle;
+	uint32_t nVisualMode;
+} VREvent_EditingCameraSurface_t;
+
+typedef struct VREvent_MessageOverlay_t
+{
+	uint32_t unVRMessageOverlayResponse;
+} VREvent_MessageOverlay_t;
+
+typedef struct VREvent_Property_t
+{
+	PropertyContainerHandle_t container;
+	enum ETrackedDeviceProperty prop;
+} VREvent_Property_t;
+
+typedef struct HiddenAreaMesh_t
+{
+	struct HmdVector2_t *pVertexData;  // const struct vr::HmdVector2_t *
+	uint32_t unTriangleCount;
+} HiddenAreaMesh_t;
+
+typedef struct VRControllerAxis_t
+{
+	float x;
+	float y;
+} VRControllerAxis_t;
+
+typedef struct VRControllerState_t
+{
+	uint32_t unPacketNum;
+	uint64_t ulButtonPressed;
+	uint64_t ulButtonTouched;
+	struct VRControllerAxis_t rAxis[5];  //struct vr::VRControllerAxis_t[5]
+} VRControllerState_t;
+
+typedef struct Compositor_OverlaySettings
+{
+	uint32_t size;
+	bool curved;
+	bool antialias;
+	float scale;
+	float distance;
+	float alpha;
+	float uOffset;
+	float vOffset;
+	float uScale;
+	float vScale;
+	float gridDivs;
+	float gridWidth;
+	float gridScale;
+	struct HmdMatrix44_t transform;
+} Compositor_OverlaySettings;
+
+typedef struct CameraVideoStreamFrameHeader_t
+{
+	enum EVRTrackedCameraFrameType eFrameType;
+	uint32_t nWidth;
+	uint32_t nHeight;
+	uint32_t nBytesPerPixel;
+	uint32_t nFrameSequence;
+	struct TrackedDevicePose_t standingTrackedDevicePose;
+} CameraVideoStreamFrameHeader_t;
+
+typedef struct AppOverrideKeys_t
+{
+	char *pchKey;    // const char *
+	char *pchValue;  // const char *
+} AppOverrideKeys_t;
+
+typedef struct Compositor_FrameTiming
+{
+	uint32_t m_nSize;
+	uint32_t m_nFrameIndex;
+	uint32_t m_nNumFramePresents;
+	uint32_t m_nNumMisPresented;
+	uint32_t m_nNumDroppedFrames;
+	uint32_t m_nReprojectionFlags;
+	double m_flSystemTimeInSeconds;
+	float m_flPreSubmitGpuMs;
+	float m_flPostSubmitGpuMs;
+	float m_flTotalRenderGpuMs;
+	float m_flCompositorRenderGpuMs;
+	float m_flCompositorRenderCpuMs;
+	float m_flCompositorIdleCpuMs;
+	float m_flClientFrameIntervalMs;
+	float m_flPresentCallCpuMs;
+	float m_flWaitForPresentCpuMs;
+	float m_flSubmitFrameMs;
+	float m_flWaitGetPosesCalledMs;
+	float m_flNewPosesReadyMs;
+	float m_flNewFrameReadyMs;
+	float m_flCompositorUpdateStartMs;
+	float m_flCompositorUpdateEndMs;
+	float m_flCompositorRenderStartMs;
+	TrackedDevicePose_t m_HmdPose;
+} Compositor_FrameTiming;
+
+typedef struct Compositor_CumulativeStats
+{
+	uint32_t m_nPid;
+	uint32_t m_nNumFramePresents;
+	uint32_t m_nNumDroppedFrames;
+	uint32_t m_nNumReprojectedFrames;
+	uint32_t m_nNumFramePresentsOnStartup;
+	uint32_t m_nNumDroppedFramesOnStartup;
+	uint32_t m_nNumReprojectedFramesOnStartup;
+	uint32_t m_nNumLoading;
+	uint32_t m_nNumFramePresentsLoading;
+	uint32_t m_nNumDroppedFramesLoading;
+	uint32_t m_nNumReprojectedFramesLoading;
+	uint32_t m_nNumTimedOut;
+	uint32_t m_nNumFramePresentsTimedOut;
+	uint32_t m_nNumDroppedFramesTimedOut;
+	uint32_t m_nNumReprojectedFramesTimedOut;
+} Compositor_CumulativeStats;
+
+typedef struct VROverlayIntersectionParams_t
+{
+	struct HmdVector3_t vSource;
+	struct HmdVector3_t vDirection;
+	enum ETrackingUniverseOrigin eOrigin;
+} VROverlayIntersectionParams_t;
+
+typedef struct VROverlayIntersectionResults_t
+{
+	struct HmdVector3_t vPoint;
+	struct HmdVector3_t vNormal;
+	struct HmdVector2_t vUVs;
+	float fDistance;
+} VROverlayIntersectionResults_t;
+
+typedef struct IntersectionMaskRectangle_t
+{
+	float m_flTopLeftX;
+	float m_flTopLeftY;
+	float m_flWidth;
+	float m_flHeight;
+} IntersectionMaskRectangle_t;
+
+typedef struct IntersectionMaskCircle_t
+{
+	float m_flCenterX;
+	float m_flCenterY;
+	float m_flRadius;
+} IntersectionMaskCircle_t;
+
+typedef struct RenderModel_ComponentState_t
+{
+	struct HmdMatrix34_t mTrackingToComponentRenderModel;
+	struct HmdMatrix34_t mTrackingToComponentLocal;
+	VRComponentProperties uProperties;
+} RenderModel_ComponentState_t;
+
+typedef struct RenderModel_Vertex_t
+{
+	struct HmdVector3_t vPosition;
+	struct HmdVector3_t vNormal;
+	float rfTextureCoord[2];  //float[2]
+} RenderModel_Vertex_t;
+
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(push, 4)
+#endif
+typedef struct RenderModel_TextureMap_t
+{
+	uint16_t unWidth;
+	uint16_t unHeight;
+	uint8_t *rubTextureMapData;  // const uint8_t *
+} RenderModel_TextureMap_t;
+
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(push, 4)
+#endif
+typedef struct RenderModel_t
+{
+	struct RenderModel_Vertex_t *rVertexData;  // const struct vr::RenderModel_Vertex_t *
+	uint32_t unVertexCount;
+	uint16_t *rIndexData;  // const uint16_t *
+	uint32_t unTriangleCount;
+	TextureID_t diffuseTextureId;
+} RenderModel_t;
+
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+typedef struct RenderModel_ControllerMode_State_t
+{
+	bool bScrollWheelVisible;
+} RenderModel_ControllerMode_State_t;
+
+typedef struct NotificationBitmap_t
+{
+	void *m_pImageData;  // void *
+	int32_t m_nWidth;
+	int32_t m_nHeight;
+	int32_t m_nBytesPerPixel;
+} NotificationBitmap_t;
+
+typedef struct COpenVRContext
+{
+	intptr_t m_pVRSystem;           // class vr::IVRSystem *
+	intptr_t m_pVRChaperone;        // class vr::IVRChaperone *
+	intptr_t m_pVRChaperoneSetup;   // class vr::IVRChaperoneSetup *
+	intptr_t m_pVRCompositor;       // class vr::IVRCompositor *
+	intptr_t m_pVROverlay;          // class vr::IVROverlay *
+	intptr_t m_pVRResources;        // class vr::IVRResources *
+	intptr_t m_pVRRenderModels;     // class vr::IVRRenderModels *
+	intptr_t m_pVRExtendedDisplay;  // class vr::IVRExtendedDisplay *
+	intptr_t m_pVRSettings;         // class vr::IVRSettings *
+	intptr_t m_pVRApplications;     // class vr::IVRApplications *
+	intptr_t m_pVRTrackedCamera;    // class vr::IVRTrackedCamera *
+	intptr_t m_pVRScreenshots;      // class vr::IVRScreenshots *
+	intptr_t m_pVRDriverManager;    // class vr::IVRDriverManager *
+} COpenVRContext;
+
+typedef union {
+	VREvent_Reserved_t reserved;
+	VREvent_Controller_t controller;
+	VREvent_Mouse_t mouse;
+	VREvent_Scroll_t scroll;
+	VREvent_Process_t process;
+	VREvent_Notification_t notification;
+	VREvent_Overlay_t overlay;
+	VREvent_Status_t status;
+	VREvent_Keyboard_t keyboard;
+	VREvent_Ipd_t ipd;
+	VREvent_Chaperone_t chaperone;
+	VREvent_PerformanceTest_t performanceTest;
+	VREvent_TouchPadMove_t touchPadMove;
+	VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset;
+} VREvent_Data_t;
+
+/** An event posted by the server to all running applications */
+struct VREvent_t
+{
+	uint32_t eventType;  // EVREventType enum
+	TrackedDeviceIndex_t trackedDeviceIndex;
+	float eventAgeSeconds;
+	// event data must be the end of the struct as its size is variable
+	VREvent_Data_t data;
+};
+
+typedef union {
+	IntersectionMaskRectangle_t m_Rectangle;
+	IntersectionMaskCircle_t m_Circle;
+} VROverlayIntersectionMaskPrimitive_Data_t;
+
+struct VROverlayIntersectionMaskPrimitive_t
+{
+	EVROverlayIntersectionMaskPrimitiveType m_nPrimitiveType;
+	VROverlayIntersectionMaskPrimitive_Data_t m_Primitive;
+};
+
+// OpenVR Function Pointer Tables
+
+struct VR_IVRSystem_FnTable
+{
+	void(OPENVR_FNTABLE_CALLTYPE *GetRecommendedRenderTargetSize)(uint32_t *pnWidth, uint32_t *pnHeight);
+	struct HmdMatrix44_t(OPENVR_FNTABLE_CALLTYPE *GetProjectionMatrix)(EVREye eEye, float fNearZ, float fFarZ);
+	void(OPENVR_FNTABLE_CALLTYPE *GetProjectionRaw)(EVREye eEye, float *pfLeft, float *pfRight, float *pfTop, float *pfBottom);
+	bool(OPENVR_FNTABLE_CALLTYPE *ComputeDistortion)(EVREye eEye, float fU, float fV, struct DistortionCoordinates_t *pDistortionCoordinates);
+	struct HmdMatrix34_t(OPENVR_FNTABLE_CALLTYPE *GetEyeToHeadTransform)(EVREye eEye);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetTimeSinceLastVsync)(float *pfSecondsSinceLastVsync, uint64_t *pulFrameCounter);
+	int32_t(OPENVR_FNTABLE_CALLTYPE *GetD3D9AdapterIndex)();
+	void(OPENVR_FNTABLE_CALLTYPE *GetDXGIOutputInfo)(int32_t *pnAdapterIndex);
+	void(OPENVR_FNTABLE_CALLTYPE *GetOutputDevice)(uint64_t *pnDevice, ETextureType textureType, struct VkInstance_T *pInstance);
+	bool(OPENVR_FNTABLE_CALLTYPE *IsDisplayOnDesktop)();
+	bool(OPENVR_FNTABLE_CALLTYPE *SetDisplayVisibility)(bool bIsVisibleOnDesktop);
+	void(OPENVR_FNTABLE_CALLTYPE *GetDeviceToAbsoluteTrackingPose)(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, struct TrackedDevicePose_t *pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount);
+	void(OPENVR_FNTABLE_CALLTYPE *ResetSeatedZeroPose)();
+	struct HmdMatrix34_t(OPENVR_FNTABLE_CALLTYPE *GetSeatedZeroPoseToStandingAbsoluteTrackingPose)();
+	struct HmdMatrix34_t(OPENVR_FNTABLE_CALLTYPE *GetRawZeroPoseToStandingAbsoluteTrackingPose)();
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetSortedTrackedDeviceIndicesOfClass)(ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t *punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex);
+	EDeviceActivityLevel(OPENVR_FNTABLE_CALLTYPE *GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId);
+	void(OPENVR_FNTABLE_CALLTYPE *ApplyTransform)(struct TrackedDevicePose_t *pOutputPose, struct TrackedDevicePose_t *pTrackedDevicePose, struct HmdMatrix34_t *pTransform);
+	TrackedDeviceIndex_t(OPENVR_FNTABLE_CALLTYPE *GetTrackedDeviceIndexForControllerRole)(ETrackedControllerRole unDeviceType);
+	ETrackedControllerRole(OPENVR_FNTABLE_CALLTYPE *GetControllerRoleForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex);
+	ETrackedDeviceClass(OPENVR_FNTABLE_CALLTYPE *GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex);
+	bool(OPENVR_FNTABLE_CALLTYPE *IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError);
+	float(OPENVR_FNTABLE_CALLTYPE *GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError);
+	int32_t(OPENVR_FNTABLE_CALLTYPE *GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError);
+	uint64_t(OPENVR_FNTABLE_CALLTYPE *GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError);
+	struct HmdMatrix34_t(OPENVR_FNTABLE_CALLTYPE *GetMatrix34TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetPropErrorNameFromEnum)(ETrackedPropertyError error);
+	bool(OPENVR_FNTABLE_CALLTYPE *PollNextEvent)(struct VREvent_t *pEvent, uint32_t uncbVREvent);
+	bool(OPENVR_FNTABLE_CALLTYPE *PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, struct VREvent_t *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetEventTypeNameFromEnum)(EVREventType eType);
+	struct HiddenAreaMesh_t(OPENVR_FNTABLE_CALLTYPE *GetHiddenAreaMesh)(EVREye eEye, EHiddenAreaMeshType type);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t *pControllerState, uint32_t unControllerStateSize);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t *pControllerState, uint32_t unControllerStateSize, struct TrackedDevicePose_t *pTrackedDevicePose);
+	void(OPENVR_FNTABLE_CALLTYPE *TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetButtonIdNameFromEnum)(EVRButtonId eButtonId);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType);
+	bool(OPENVR_FNTABLE_CALLTYPE *CaptureInputFocus)();
+	void(OPENVR_FNTABLE_CALLTYPE *ReleaseInputFocus)();
+	bool(OPENVR_FNTABLE_CALLTYPE *IsInputFocusCapturedByAnotherProcess)();
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, char *pchRequest, char *pchResponseBuffer, uint32_t unResponseBufferSize);
+	EVRFirmwareError(OPENVR_FNTABLE_CALLTYPE *PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex);
+	void(OPENVR_FNTABLE_CALLTYPE *AcknowledgeQuit_Exiting)();
+	void(OPENVR_FNTABLE_CALLTYPE *AcknowledgeQuit_UserPrompt)();
+};
+
+struct VR_IVRExtendedDisplay_FnTable
+{
+	void(OPENVR_FNTABLE_CALLTYPE *GetWindowBounds)(int32_t *pnX, int32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight);
+	void(OPENVR_FNTABLE_CALLTYPE *GetEyeOutputViewport)(EVREye eEye, uint32_t *pnX, uint32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight);
+	void(OPENVR_FNTABLE_CALLTYPE *GetDXGIOutputInfo)(int32_t *pnAdapterIndex, int32_t *pnAdapterOutputIndex);
+};
+
+struct VR_IVRTrackedCamera_FnTable
+{
+	char *(OPENVR_FNTABLE_CALLTYPE *GetCameraErrorNameFromEnum)(EVRTrackedCameraError eCameraError);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *HasCamera)(TrackedDeviceIndex_t nDeviceIndex, bool *pHasCamera);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *GetCameraFrameSize)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, uint32_t *pnWidth, uint32_t *pnHeight, uint32_t *pnFrameBufferSize);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *GetCameraIntrinsics)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, HmdVector2_t *pFocalLength, HmdVector2_t *pCenter);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *GetCameraProjection)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, HmdMatrix44_t *pProjection);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *AcquireVideoStreamingService)(TrackedDeviceIndex_t nDeviceIndex, TrackedCameraHandle_t *pHandle);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *ReleaseVideoStreamingService)(TrackedCameraHandle_t hTrackedCamera);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *GetVideoStreamFrameBuffer)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void *pFrameBuffer, uint32_t nFrameBufferSize, CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *GetVideoStreamTextureSize)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, VRTextureBounds_t *pTextureBounds, uint32_t *pnWidth, uint32_t *pnHeight);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *GetVideoStreamTextureD3D11)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView, CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *GetVideoStreamTextureGL)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t *pglTextureId, CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *ReleaseVideoStreamTextureGL)(TrackedCameraHandle_t hTrackedCamera, glUInt_t glTextureId);
+};
+
+struct VR_IVRApplications_FnTable
+{
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *AddApplicationManifest)(char *pchApplicationManifestFullPath, bool bTemporary);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *RemoveApplicationManifest)(char *pchApplicationManifestFullPath);
+	bool(OPENVR_FNTABLE_CALLTYPE *IsApplicationInstalled)(char *pchAppKey);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetApplicationCount)();
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *GetApplicationKeyByIndex)(uint32_t unApplicationIndex, char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *GetApplicationKeyByProcessId)(uint32_t unProcessId, char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *LaunchApplication)(char *pchAppKey);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *LaunchTemplateApplication)(char *pchTemplateAppKey, char *pchNewAppKey, struct AppOverrideKeys_t *pKeys, uint32_t unKeys);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *LaunchApplicationFromMimeType)(char *pchMimeType, char *pchArgs);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *LaunchDashboardOverlay)(char *pchAppKey);
+	bool(OPENVR_FNTABLE_CALLTYPE *CancelApplicationLaunch)(char *pchAppKey);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *IdentifyApplication)(uint32_t unProcessId, char *pchAppKey);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetApplicationProcessId)(char *pchAppKey);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetApplicationsErrorNameFromEnum)(EVRApplicationError error);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetApplicationPropertyString)(char *pchAppKey, EVRApplicationProperty eProperty, char *pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError *peError);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetApplicationPropertyBool)(char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError);
+	uint64_t(OPENVR_FNTABLE_CALLTYPE *GetApplicationPropertyUint64)(char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *SetApplicationAutoLaunch)(char *pchAppKey, bool bAutoLaunch);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetApplicationAutoLaunch)(char *pchAppKey);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *SetDefaultApplicationForMimeType)(char *pchAppKey, char *pchMimeType);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetDefaultApplicationForMimeType)(char *pchMimeType, char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetApplicationSupportedMimeTypes)(char *pchAppKey, char *pchMimeTypesBuffer, uint32_t unMimeTypesBuffer);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetApplicationsThatSupportMimeType)(char *pchMimeType, char *pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetApplicationLaunchArguments)(uint32_t unHandle, char *pchArgs, uint32_t unArgs);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *GetStartingApplication)(char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+	EVRApplicationTransitionState(OPENVR_FNTABLE_CALLTYPE *GetTransitionState)();
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *PerformApplicationPrelaunchCheck)(char *pchAppKey);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetApplicationsTransitionStateNameFromEnum)(EVRApplicationTransitionState state);
+	bool(OPENVR_FNTABLE_CALLTYPE *IsQuitUserPromptRequested)();
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *LaunchInternalProcess)(char *pchBinaryPath, char *pchArguments, char *pchWorkingDirectory);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetCurrentSceneProcessId)();
+};
+
+struct VR_IVRChaperone_FnTable
+{
+	ChaperoneCalibrationState(OPENVR_FNTABLE_CALLTYPE *GetCalibrationState)();
+	bool(OPENVR_FNTABLE_CALLTYPE *GetPlayAreaSize)(float *pSizeX, float *pSizeZ);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetPlayAreaRect)(struct HmdQuad_t *rect);
+	void(OPENVR_FNTABLE_CALLTYPE *ReloadInfo)();
+	void(OPENVR_FNTABLE_CALLTYPE *SetSceneColor)(struct HmdColor_t color);
+	void(OPENVR_FNTABLE_CALLTYPE *GetBoundsColor)(struct HmdColor_t *pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, struct HmdColor_t *pOutputCameraColor);
+	bool(OPENVR_FNTABLE_CALLTYPE *AreBoundsVisible)();
+	void(OPENVR_FNTABLE_CALLTYPE *ForceBoundsVisible)(bool bForce);
+};
+
+struct VR_IVRChaperoneSetup_FnTable
+{
+	bool(OPENVR_FNTABLE_CALLTYPE *CommitWorkingCopy)(EChaperoneConfigFile configFile);
+	void(OPENVR_FNTABLE_CALLTYPE *RevertWorkingCopy)();
+	bool(OPENVR_FNTABLE_CALLTYPE *GetWorkingPlayAreaSize)(float *pSizeX, float *pSizeZ);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetWorkingPlayAreaRect)(struct HmdQuad_t *rect);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetWorkingCollisionBoundsInfo)(struct HmdQuad_t *pQuadsBuffer, uint32_t *punQuadsCount);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetLiveCollisionBoundsInfo)(struct HmdQuad_t *pQuadsBuffer, uint32_t *punQuadsCount);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetWorkingSeatedZeroPoseToRawTrackingPose)(struct HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetWorkingStandingZeroPoseToRawTrackingPose)(struct HmdMatrix34_t *pmatStandingZeroPoseToRawTrackingPose);
+	void(OPENVR_FNTABLE_CALLTYPE *SetWorkingPlayAreaSize)(float sizeX, float sizeZ);
+	void(OPENVR_FNTABLE_CALLTYPE *SetWorkingCollisionBoundsInfo)(struct HmdQuad_t *pQuadsBuffer, uint32_t unQuadsCount);
+	void(OPENVR_FNTABLE_CALLTYPE *SetWorkingSeatedZeroPoseToRawTrackingPose)(struct HmdMatrix34_t *pMatSeatedZeroPoseToRawTrackingPose);
+	void(OPENVR_FNTABLE_CALLTYPE *SetWorkingStandingZeroPoseToRawTrackingPose)(struct HmdMatrix34_t *pMatStandingZeroPoseToRawTrackingPose);
+	void(OPENVR_FNTABLE_CALLTYPE *ReloadFromDisk)(EChaperoneConfigFile configFile);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetLiveSeatedZeroPoseToRawTrackingPose)(struct HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose);
+	void(OPENVR_FNTABLE_CALLTYPE *SetWorkingCollisionBoundsTagsInfo)(uint8_t *pTagsBuffer, uint32_t unTagCount);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetLiveCollisionBoundsTagsInfo)(uint8_t *pTagsBuffer, uint32_t *punTagCount);
+	bool(OPENVR_FNTABLE_CALLTYPE *SetWorkingPhysicalBoundsInfo)(struct HmdQuad_t *pQuadsBuffer, uint32_t unQuadsCount);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetLivePhysicalBoundsInfo)(struct HmdQuad_t *pQuadsBuffer, uint32_t *punQuadsCount);
+	bool(OPENVR_FNTABLE_CALLTYPE *ExportLiveToBuffer)(char *pBuffer, uint32_t *pnBufferLength);
+	bool(OPENVR_FNTABLE_CALLTYPE *ImportFromBufferToWorking)(char *pBuffer, uint32_t nImportFlags);
+};
+
+struct VR_IVRCompositor_FnTable
+{
+	void(OPENVR_FNTABLE_CALLTYPE *SetTrackingSpace)(ETrackingUniverseOrigin eOrigin);
+	ETrackingUniverseOrigin(OPENVR_FNTABLE_CALLTYPE *GetTrackingSpace)();
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *WaitGetPoses)(struct TrackedDevicePose_t *pRenderPoseArray, uint32_t unRenderPoseArrayCount, struct TrackedDevicePose_t *pGamePoseArray, uint32_t unGamePoseArrayCount);
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *GetLastPoses)(struct TrackedDevicePose_t *pRenderPoseArray, uint32_t unRenderPoseArrayCount, struct TrackedDevicePose_t *pGamePoseArray, uint32_t unGamePoseArrayCount);
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, struct TrackedDevicePose_t *pOutputPose, struct TrackedDevicePose_t *pOutputGamePose);
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *Submit)(EVREye eEye, struct Texture_t *pTexture, struct VRTextureBounds_t *pBounds, EVRSubmitFlags nSubmitFlags);
+	void(OPENVR_FNTABLE_CALLTYPE *ClearLastSubmittedFrame)();
+	void(OPENVR_FNTABLE_CALLTYPE *PostPresentHandoff)();
+	bool(OPENVR_FNTABLE_CALLTYPE *GetFrameTiming)(struct Compositor_FrameTiming *pTiming, uint32_t unFramesAgo);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetFrameTimings)(struct Compositor_FrameTiming *pTiming, uint32_t nFrames);
+	float(OPENVR_FNTABLE_CALLTYPE *GetFrameTimeRemaining)();
+	void(OPENVR_FNTABLE_CALLTYPE *GetCumulativeStats)(struct Compositor_CumulativeStats *pStats, uint32_t nStatsSizeInBytes);
+	void(OPENVR_FNTABLE_CALLTYPE *FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
+	struct HmdColor_t(OPENVR_FNTABLE_CALLTYPE *GetCurrentFadeColor)(bool bBackground);
+	void(OPENVR_FNTABLE_CALLTYPE *FadeGrid)(float fSeconds, bool bFadeIn);
+	float(OPENVR_FNTABLE_CALLTYPE *GetCurrentGridAlpha)();
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *SetSkyboxOverride)(struct Texture_t *pTextures, uint32_t unTextureCount);
+	void(OPENVR_FNTABLE_CALLTYPE *ClearSkyboxOverride)();
+	void(OPENVR_FNTABLE_CALLTYPE *CompositorBringToFront)();
+	void(OPENVR_FNTABLE_CALLTYPE *CompositorGoToBack)();
+	void(OPENVR_FNTABLE_CALLTYPE *CompositorQuit)();
+	bool(OPENVR_FNTABLE_CALLTYPE *IsFullscreen)();
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetCurrentSceneFocusProcess)();
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetLastFrameRenderer)();
+	bool(OPENVR_FNTABLE_CALLTYPE *CanRenderScene)();
+	void(OPENVR_FNTABLE_CALLTYPE *ShowMirrorWindow)();
+	void(OPENVR_FNTABLE_CALLTYPE *HideMirrorWindow)();
+	bool(OPENVR_FNTABLE_CALLTYPE *IsMirrorWindowVisible)();
+	void(OPENVR_FNTABLE_CALLTYPE *CompositorDumpImages)();
+	bool(OPENVR_FNTABLE_CALLTYPE *ShouldAppRenderWithLowResources)();
+	void(OPENVR_FNTABLE_CALLTYPE *ForceInterleavedReprojectionOn)(bool bOverride);
+	void(OPENVR_FNTABLE_CALLTYPE *ForceReconnectProcess)();
+	void(OPENVR_FNTABLE_CALLTYPE *SuspendRendering)(bool bSuspend);
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *GetMirrorTextureD3D11)(EVREye eEye, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView);
+	void(OPENVR_FNTABLE_CALLTYPE *ReleaseMirrorTextureD3D11)(void *pD3D11ShaderResourceView);
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *GetMirrorTextureGL)(EVREye eEye, glUInt_t *pglTextureId, glSharedTextureHandle_t *pglSharedTextureHandle);
+	bool(OPENVR_FNTABLE_CALLTYPE *ReleaseSharedGLTexture)(glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle);
+	void(OPENVR_FNTABLE_CALLTYPE *LockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle);
+	void(OPENVR_FNTABLE_CALLTYPE *UnlockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetVulkanInstanceExtensionsRequired)(char *pchValue, uint32_t unBufferSize);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetVulkanDeviceExtensionsRequired)(struct VkPhysicalDevice_T *pPhysicalDevice, char *pchValue, uint32_t unBufferSize);
+	void(OPENVR_FNTABLE_CALLTYPE *SetExplicitTimingMode)(bool bExplicitTimingMode);
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *SubmitExplicitTimingData)();
+};
+
+struct VR_IVROverlay_FnTable
+{
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *FindOverlay)(char *pchOverlayKey, VROverlayHandle_t *pOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *CreateOverlay)(char *pchOverlayKey, char *pchOverlayName, VROverlayHandle_t *pOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *DestroyOverlay)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle);
+	VROverlayHandle_t(OPENVR_FNTABLE_CALLTYPE *GetHighQualityOverlay)();
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char *pchValue, uint32_t unBufferSize, EVROverlayError *pError);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char *pchValue, uint32_t unBufferSize, EVROverlayError *pError);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayName)(VROverlayHandle_t ulOverlayHandle, char *pchName);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unBufferSize, uint32_t *punWidth, uint32_t *punHeight);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetOverlayErrorNameFromEnum)(EVROverlayError error);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool *pbEnabled);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float *pfRed, float *pfGreen, float *pfBlue);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float *pfAlpha);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float fTexelAspect);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float *pfTexelAspect);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t *punSortOrder);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float *pfWidthInMeters);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float *pfMinDistanceInMeters, float *pfMaxDistanceInMeters);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace *peTextureColorSpace);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, struct VRTextureBounds_t *pOverlayTextureBounds);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, struct VRTextureBounds_t *pOverlayTextureBounds);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, char *pchValue, uint32_t unBufferSize, struct HmdColor_t *pColor, EVROverlayError *pError);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, char *pchRenderModel, struct HmdColor_t *pColor);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType *peTransformType);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, struct HmdMatrix34_t *pmatTrackingOriginToOverlayTransform);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin *peTrackingOrigin, struct HmdMatrix34_t *pmatTrackingOriginToOverlayTransform);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, struct HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punTrackedDevice, struct HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, char *pchComponentName);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punDeviceIndex, char *pchComponentName, uint32_t unComponentNameSize);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t *ulOverlayHandleParent, struct HmdMatrix34_t *pmatParentOverlayToOverlayTransform);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, struct HmdMatrix34_t *pmatParentOverlayToOverlayTransform);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *ShowOverlay)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *HideOverlay)(VROverlayHandle_t ulOverlayHandle);
+	bool(OPENVR_FNTABLE_CALLTYPE *IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, struct HmdVector2_t coordinatesInOverlay, struct HmdMatrix34_t *pmatTransform);
+	bool(OPENVR_FNTABLE_CALLTYPE *PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, struct VREvent_t *pEvent, uint32_t uncbVREvent);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod *peInputMethod);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, struct HmdVector2_t *pvecMouseScale);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, struct HmdVector2_t *pvecMouseScale);
+	bool(OPENVR_FNTABLE_CALLTYPE *ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, struct VROverlayIntersectionParams_t *pParams, struct VROverlayIntersectionResults_t *pResults);
+	bool(OPENVR_FNTABLE_CALLTYPE *HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex);
+	bool(OPENVR_FNTABLE_CALLTYPE *IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle);
+	VROverlayHandle_t(OPENVR_FNTABLE_CALLTYPE *GetGamepadFocusOverlay)();
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetGamepadFocusOverlay)(VROverlayHandle_t ulNewFocusOverlay);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *MoveGamepadFocusToNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, struct Texture_t *pTexture);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, char *pchFilePath);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void **pNativeTextureHandle, void *pNativeTextureRef, uint32_t *pWidth, uint32_t *pHeight, uint32_t *pNativeFormat, ETextureType *pAPIType, EColorSpace *pColorSpace, struct VRTextureBounds_t *pTextureBounds);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void *pNativeTextureHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t *pWidth, uint32_t *pHeight);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *CreateDashboardOverlay)(char *pchOverlayKey, char *pchOverlayFriendlyName, VROverlayHandle_t *pMainHandle, VROverlayHandle_t *pThumbnailHandle);
+	bool(OPENVR_FNTABLE_CALLTYPE *IsDashboardVisible)();
+	bool(OPENVR_FNTABLE_CALLTYPE *IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t *punProcessId);
+	void(OPENVR_FNTABLE_CALLTYPE *ShowDashboard)(char *pchOverlayToShow);
+	TrackedDeviceIndex_t(OPENVR_FNTABLE_CALLTYPE *GetPrimaryDashboardDevice)();
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, char *pchDescription, uint32_t unCharMax, char *pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, char *pchDescription, uint32_t unCharMax, char *pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetKeyboardText)(char *pchText, uint32_t cchText);
+	void(OPENVR_FNTABLE_CALLTYPE *HideKeyboard)();
+	void(OPENVR_FNTABLE_CALLTYPE *SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, struct HmdMatrix34_t *pmatTrackingOriginToKeyboardTransform);
+	void(OPENVR_FNTABLE_CALLTYPE *SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, struct HmdRect2_t avoidRect);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayIntersectionMask)(VROverlayHandle_t ulOverlayHandle, struct VROverlayIntersectionMaskPrimitive_t *pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayFlags)(VROverlayHandle_t ulOverlayHandle, uint32_t *pFlags);
+	VRMessageOverlayResponse(OPENVR_FNTABLE_CALLTYPE *ShowMessageOverlay)(char *pchText, char *pchCaption, char *pchButton0Text, char *pchButton1Text, char *pchButton2Text, char *pchButton3Text);
+	void(OPENVR_FNTABLE_CALLTYPE *CloseMessageOverlay)();
+};
+
+struct VR_IVRRenderModels_FnTable
+{
+	EVRRenderModelError(OPENVR_FNTABLE_CALLTYPE *LoadRenderModel_Async)(char *pchRenderModelName, struct RenderModel_t **ppRenderModel);
+	void(OPENVR_FNTABLE_CALLTYPE *FreeRenderModel)(struct RenderModel_t *pRenderModel);
+	EVRRenderModelError(OPENVR_FNTABLE_CALLTYPE *LoadTexture_Async)(TextureID_t textureId, struct RenderModel_TextureMap_t **ppTexture);
+	void(OPENVR_FNTABLE_CALLTYPE *FreeTexture)(struct RenderModel_TextureMap_t *pTexture);
+	EVRRenderModelError(OPENVR_FNTABLE_CALLTYPE *LoadTextureD3D11_Async)(TextureID_t textureId, void *pD3D11Device, void **ppD3D11Texture2D);
+	EVRRenderModelError(OPENVR_FNTABLE_CALLTYPE *LoadIntoTextureD3D11_Async)(TextureID_t textureId, void *pDstTexture);
+	void(OPENVR_FNTABLE_CALLTYPE *FreeTextureD3D11)(void *pD3D11Texture2D);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetRenderModelName)(uint32_t unRenderModelIndex, char *pchRenderModelName, uint32_t unRenderModelNameLen);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetRenderModelCount)();
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetComponentCount)(char *pchRenderModelName);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetComponentName)(char *pchRenderModelName, uint32_t unComponentIndex, char *pchComponentName, uint32_t unComponentNameLen);
+	uint64_t(OPENVR_FNTABLE_CALLTYPE *GetComponentButtonMask)(char *pchRenderModelName, char *pchComponentName);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetComponentRenderModelName)(char *pchRenderModelName, char *pchComponentName, char *pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetComponentState)(char *pchRenderModelName, char *pchComponentName, VRControllerState_t *pControllerState, struct RenderModel_ControllerMode_State_t *pState, struct RenderModel_ComponentState_t *pComponentState);
+	bool(OPENVR_FNTABLE_CALLTYPE *RenderModelHasComponent)(char *pchRenderModelName, char *pchComponentName);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetRenderModelThumbnailURL)(char *pchRenderModelName, char *pchThumbnailURL, uint32_t unThumbnailURLLen, EVRRenderModelError *peError);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetRenderModelOriginalPath)(char *pchRenderModelName, char *pchOriginalPath, uint32_t unOriginalPathLen, EVRRenderModelError *peError);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetRenderModelErrorNameFromEnum)(EVRRenderModelError error);
+};
+
+struct VR_IVRNotifications_FnTable
+{
+	EVRNotificationError(OPENVR_FNTABLE_CALLTYPE *CreateNotification)(VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, EVRNotificationType type, char *pchText, EVRNotificationStyle style, struct NotificationBitmap_t *pImage, VRNotificationId *pNotificationId);
+	EVRNotificationError(OPENVR_FNTABLE_CALLTYPE *RemoveNotification)(VRNotificationId notificationId);
+};
+
+struct VR_IVRSettings_FnTable
+{
+	char *(OPENVR_FNTABLE_CALLTYPE *GetSettingsErrorNameFromEnum)(EVRSettingsError eError);
+	bool(OPENVR_FNTABLE_CALLTYPE *Sync)(bool bForce, EVRSettingsError *peError);
+	void(OPENVR_FNTABLE_CALLTYPE *SetBool)(char *pchSection, char *pchSettingsKey, bool bValue, EVRSettingsError *peError);
+	void(OPENVR_FNTABLE_CALLTYPE *SetInt32)(char *pchSection, char *pchSettingsKey, int32_t nValue, EVRSettingsError *peError);
+	void(OPENVR_FNTABLE_CALLTYPE *SetFloat)(char *pchSection, char *pchSettingsKey, float flValue, EVRSettingsError *peError);
+	void(OPENVR_FNTABLE_CALLTYPE *SetString)(char *pchSection, char *pchSettingsKey, char *pchValue, EVRSettingsError *peError);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetBool)(char *pchSection, char *pchSettingsKey, EVRSettingsError *peError);
+	int32_t(OPENVR_FNTABLE_CALLTYPE *GetInt32)(char *pchSection, char *pchSettingsKey, EVRSettingsError *peError);
+	float(OPENVR_FNTABLE_CALLTYPE *GetFloat)(char *pchSection, char *pchSettingsKey, EVRSettingsError *peError);
+	void(OPENVR_FNTABLE_CALLTYPE *GetString)(char *pchSection, char *pchSettingsKey, char *pchValue, uint32_t unValueLen, EVRSettingsError *peError);
+	void(OPENVR_FNTABLE_CALLTYPE *RemoveSection)(char *pchSection, EVRSettingsError *peError);
+	void(OPENVR_FNTABLE_CALLTYPE *RemoveKeyInSection)(char *pchSection, char *pchSettingsKey, EVRSettingsError *peError);
+};
+
+struct VR_IVRScreenshots_FnTable
+{
+	EVRScreenshotError(OPENVR_FNTABLE_CALLTYPE *RequestScreenshot)(ScreenshotHandle_t *pOutScreenshotHandle, EVRScreenshotType type, char *pchPreviewFilename, char *pchVRFilename);
+	EVRScreenshotError(OPENVR_FNTABLE_CALLTYPE *HookScreenshot)(EVRScreenshotType *pSupportedTypes, int numTypes);
+	EVRScreenshotType(OPENVR_FNTABLE_CALLTYPE *GetScreenshotPropertyType)(ScreenshotHandle_t screenshotHandle, EVRScreenshotError *pError);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetScreenshotPropertyFilename)(ScreenshotHandle_t screenshotHandle, EVRScreenshotPropertyFilenames filenameType, char *pchFilename, uint32_t cchFilename, EVRScreenshotError *pError);
+	EVRScreenshotError(OPENVR_FNTABLE_CALLTYPE *UpdateScreenshotProgress)(ScreenshotHandle_t screenshotHandle, float flProgress);
+	EVRScreenshotError(OPENVR_FNTABLE_CALLTYPE *TakeStereoScreenshot)(ScreenshotHandle_t *pOutScreenshotHandle, char *pchPreviewFilename, char *pchVRFilename);
+	EVRScreenshotError(OPENVR_FNTABLE_CALLTYPE *SubmitScreenshot)(ScreenshotHandle_t screenshotHandle, EVRScreenshotType type, char *pchSourcePreviewFilename, char *pchSourceVRFilename);
+};
+
+struct VR_IVRResources_FnTable
+{
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *LoadSharedResource)(char *pchResourceName, char *pchBuffer, uint32_t unBufferLen);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetResourceFullPath)(char *pchResourceName, char *pchResourceTypeDirectory, char *pchPathBuffer, uint32_t unBufferLen);
+};
+
+struct VR_IVRDriverManager_FnTable
+{
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetDriverCount)();
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetDriverName)(DriverId_t nDriver, char *pchValue, uint32_t unBufferSize);
+};
+
+#if 0
+// Global entry points
+S_API intptr_t VR_InitInternal( EVRInitError *peError, EVRApplicationType eType );
+S_API void VR_ShutdownInternal();
+S_API bool VR_IsHmdPresent();
+S_API intptr_t VR_GetGenericInterface( const char *pchInterfaceVersion, EVRInitError *peError );
+S_API bool VR_IsRuntimeInstalled();
+S_API const char * VR_GetVRInitErrorAsSymbol( EVRInitError error );
+S_API const char * VR_GetVRInitErrorAsEnglishDescription( EVRInitError error );
+#endif
+
+#endif  // __OPENVR_API_FLAT_H__
diff --git a/engine/inc/bullet/ThirdPartyLibs/openvr/bin/osx64/OpenVR.framework/Versions/Current/Headers/openvr_driver.h b/engine/inc/bullet/ThirdPartyLibs/openvr/bin/osx64/OpenVR.framework/Versions/Current/Headers/openvr_driver.h
new file mode 100644
index 00000000..b07699f8
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/openvr/bin/osx64/OpenVR.framework/Versions/Current/Headers/openvr_driver.h
@@ -0,0 +1,2595 @@
+#pragma once
+
+// openvr_driver.h
+//========= Copyright Valve Corporation ============//
+// Dynamically generated file. Do not modify this file directly.
+
+#ifndef _OPENVR_DRIVER_API
+#define _OPENVR_DRIVER_API
+
+#include <stdint.h>
+
+// vrtypes.h
+#ifndef _INCLUDE_VRTYPES_H
+#define _INCLUDE_VRTYPES_H
+
+// Forward declarations to avoid requiring vulkan.h
+struct VkDevice_T;
+struct VkPhysicalDevice_T;
+struct VkInstance_T;
+struct VkQueue_T;
+
+// Forward declarations to avoid requiring d3d12.h
+struct ID3D12Resource;
+struct ID3D12CommandQueue;
+
+namespace vr
+{
+#pragma pack(push, 8)
+
+typedef void *glSharedTextureHandle_t;
+typedef int32_t glInt_t;
+typedef uint32_t glUInt_t;
+
+// right-handed system
+// +y is up
+// +x is to the right
+// -z is going away from you
+// Distance unit is  meters
+struct HmdMatrix34_t
+{
+	float m[3][4];
+};
+
+struct HmdMatrix44_t
+{
+	float m[4][4];
+};
+
+struct HmdVector3_t
+{
+	float v[3];
+};
+
+struct HmdVector4_t
+{
+	float v[4];
+};
+
+struct HmdVector3d_t
+{
+	double v[3];
+};
+
+struct HmdVector2_t
+{
+	float v[2];
+};
+
+struct HmdQuaternion_t
+{
+	double w, x, y, z;
+};
+
+struct HmdColor_t
+{
+	float r, g, b, a;
+};
+
+struct HmdQuad_t
+{
+	HmdVector3_t vCorners[4];
+};
+
+struct HmdRect2_t
+{
+	HmdVector2_t vTopLeft;
+	HmdVector2_t vBottomRight;
+};
+
+/** Used to return the post-distortion UVs for each color channel. 
+* UVs range from 0 to 1 with 0,0 in the upper left corner of the 
+* source render target. The 0,0 to 1,1 range covers a single eye. */
+struct DistortionCoordinates_t
+{
+	float rfRed[2];
+	float rfGreen[2];
+	float rfBlue[2];
+};
+
+enum EVREye
+{
+	Eye_Left = 0,
+	Eye_Right = 1
+};
+
+enum ETextureType
+{
+	TextureType_DirectX = 0,    // Handle is an ID3D11Texture
+	TextureType_OpenGL = 1,     // Handle is an OpenGL texture name or an OpenGL render buffer name, depending on submit flags
+	TextureType_Vulkan = 2,     // Handle is a pointer to a VRVulkanTextureData_t structure
+	TextureType_IOSurface = 3,  // Handle is a macOS cross-process-sharable IOSurfaceRef
+	TextureType_DirectX12 = 4,  // Handle is a pointer to a D3D12TextureData_t structure
+};
+
+enum EColorSpace
+{
+	ColorSpace_Auto = 0,    // Assumes 'gamma' for 8-bit per component formats, otherwise 'linear'.  This mirrors the DXGI formats which have _SRGB variants.
+	ColorSpace_Gamma = 1,   // Texture data can be displayed directly on the display without any conversion (a.k.a. display native format).
+	ColorSpace_Linear = 2,  // Same as gamma but has been converted to a linear representation using DXGI's sRGB conversion algorithm.
+};
+
+struct Texture_t
+{
+	void *handle;  // See ETextureType definition above
+	ETextureType eType;
+	EColorSpace eColorSpace;
+};
+
+// Handle to a shared texture (HANDLE on Windows obtained using OpenSharedResource).
+typedef uint64_t SharedTextureHandle_t;
+#define INVALID_SHARED_TEXTURE_HANDLE ((vr::SharedTextureHandle_t)0)
+
+enum ETrackingResult
+{
+	TrackingResult_Uninitialized = 1,
+
+	TrackingResult_Calibrating_InProgress = 100,
+	TrackingResult_Calibrating_OutOfRange = 101,
+
+	TrackingResult_Running_OK = 200,
+	TrackingResult_Running_OutOfRange = 201,
+};
+
+typedef uint32_t DriverId_t;
+static const uint32_t k_nDriverNone = 0xFFFFFFFF;
+
+static const uint32_t k_unMaxDriverDebugResponseSize = 32768;
+
+/** Used to pass device IDs to API calls */
+typedef uint32_t TrackedDeviceIndex_t;
+static const uint32_t k_unTrackedDeviceIndex_Hmd = 0;
+static const uint32_t k_unMaxTrackedDeviceCount = 16;
+static const uint32_t k_unTrackedDeviceIndexOther = 0xFFFFFFFE;
+static const uint32_t k_unTrackedDeviceIndexInvalid = 0xFFFFFFFF;
+
+/** Describes what kind of object is being tracked at a given ID */
+enum ETrackedDeviceClass
+{
+	TrackedDeviceClass_Invalid = 0,            // the ID was not valid.
+	TrackedDeviceClass_HMD = 1,                // Head-Mounted Displays
+	TrackedDeviceClass_Controller = 2,         // Tracked controllers
+	TrackedDeviceClass_GenericTracker = 3,     // Generic trackers, similar to controllers
+	TrackedDeviceClass_TrackingReference = 4,  // Camera and base stations that serve as tracking reference points
+	TrackedDeviceClass_DisplayRedirect = 5,    // Accessories that aren't necessarily tracked themselves, but may redirect video output from other tracked devices
+};
+
+/** Describes what specific role associated with a tracked device */
+enum ETrackedControllerRole
+{
+	TrackedControllerRole_Invalid = 0,    // Invalid value for controller type
+	TrackedControllerRole_LeftHand = 1,   // Tracked device associated with the left hand
+	TrackedControllerRole_RightHand = 2,  // Tracked device associated with the right hand
+};
+
+/** describes a single pose for a tracked object */
+struct TrackedDevicePose_t
+{
+	HmdMatrix34_t mDeviceToAbsoluteTracking;
+	HmdVector3_t vVelocity;         // velocity in tracker space in m/s
+	HmdVector3_t vAngularVelocity;  // angular velocity in radians/s (?)
+	ETrackingResult eTrackingResult;
+	bool bPoseIsValid;
+
+	// This indicates that there is a device connected for this spot in the pose array.
+	// It could go from true to false if the user unplugs the device.
+	bool bDeviceIsConnected;
+};
+
+/** Identifies which style of tracking origin the application wants to use
+* for the poses it is requesting */
+enum ETrackingUniverseOrigin
+{
+	TrackingUniverseSeated = 0,              // Poses are provided relative to the seated zero pose
+	TrackingUniverseStanding = 1,            // Poses are provided relative to the safe bounds configured by the user
+	TrackingUniverseRawAndUncalibrated = 2,  // Poses are provided in the coordinate system defined by the driver.  It has Y up and is unified for devices of the same driver. You usually don't want this one.
+};
+
+// Refers to a single container of properties
+typedef uint64_t PropertyContainerHandle_t;
+typedef uint32_t PropertyTypeTag_t;
+
+static const PropertyContainerHandle_t k_ulInvalidPropertyContainer = 0;
+static const PropertyTypeTag_t k_unInvalidPropertyTag = 0;
+
+// Use these tags to set/get common types as struct properties
+static const PropertyTypeTag_t k_unFloatPropertyTag = 1;
+static const PropertyTypeTag_t k_unInt32PropertyTag = 2;
+static const PropertyTypeTag_t k_unUint64PropertyTag = 3;
+static const PropertyTypeTag_t k_unBoolPropertyTag = 4;
+static const PropertyTypeTag_t k_unStringPropertyTag = 5;
+
+static const PropertyTypeTag_t k_unHmdMatrix34PropertyTag = 20;
+static const PropertyTypeTag_t k_unHmdMatrix44PropertyTag = 21;
+static const PropertyTypeTag_t k_unHmdVector3PropertyTag = 22;
+static const PropertyTypeTag_t k_unHmdVector4PropertyTag = 23;
+
+static const PropertyTypeTag_t k_unHiddenAreaPropertyTag = 30;
+
+static const PropertyTypeTag_t k_unOpenVRInternalReserved_Start = 1000;
+static const PropertyTypeTag_t k_unOpenVRInternalReserved_End = 10000;
+
+/** Each entry in this enum represents a property that can be retrieved about a
+* tracked device. Many fields are only valid for one ETrackedDeviceClass. */
+enum ETrackedDeviceProperty
+{
+	Prop_Invalid = 0,
+
+	// general properties that apply to all device classes
+	Prop_TrackingSystemName_String = 1000,
+	Prop_ModelNumber_String = 1001,
+	Prop_SerialNumber_String = 1002,
+	Prop_RenderModelName_String = 1003,
+	Prop_WillDriftInYaw_Bool = 1004,
+	Prop_ManufacturerName_String = 1005,
+	Prop_TrackingFirmwareVersion_String = 1006,
+	Prop_HardwareRevision_String = 1007,
+	Prop_AllWirelessDongleDescriptions_String = 1008,
+	Prop_ConnectedWirelessDongle_String = 1009,
+	Prop_DeviceIsWireless_Bool = 1010,
+	Prop_DeviceIsCharging_Bool = 1011,
+	Prop_DeviceBatteryPercentage_Float = 1012,  // 0 is empty, 1 is full
+	Prop_StatusDisplayTransform_Matrix34 = 1013,
+	Prop_Firmware_UpdateAvailable_Bool = 1014,
+	Prop_Firmware_ManualUpdate_Bool = 1015,
+	Prop_Firmware_ManualUpdateURL_String = 1016,
+	Prop_HardwareRevision_Uint64 = 1017,
+	Prop_FirmwareVersion_Uint64 = 1018,
+	Prop_FPGAVersion_Uint64 = 1019,
+	Prop_VRCVersion_Uint64 = 1020,
+	Prop_RadioVersion_Uint64 = 1021,
+	Prop_DongleVersion_Uint64 = 1022,
+	Prop_BlockServerShutdown_Bool = 1023,
+	Prop_CanUnifyCoordinateSystemWithHmd_Bool = 1024,
+	Prop_ContainsProximitySensor_Bool = 1025,
+	Prop_DeviceProvidesBatteryStatus_Bool = 1026,
+	Prop_DeviceCanPowerOff_Bool = 1027,
+	Prop_Firmware_ProgrammingTarget_String = 1028,
+	Prop_DeviceClass_Int32 = 1029,
+	Prop_HasCamera_Bool = 1030,
+	Prop_DriverVersion_String = 1031,
+	Prop_Firmware_ForceUpdateRequired_Bool = 1032,
+	Prop_ViveSystemButtonFixRequired_Bool = 1033,
+	Prop_ParentDriver_Uint64 = 1034,
+	Prop_ResourceRoot_String = 1035,
+
+	// Properties that are unique to TrackedDeviceClass_HMD
+	Prop_ReportsTimeSinceVSync_Bool = 2000,
+	Prop_SecondsFromVsyncToPhotons_Float = 2001,
+	Prop_DisplayFrequency_Float = 2002,
+	Prop_UserIpdMeters_Float = 2003,
+	Prop_CurrentUniverseId_Uint64 = 2004,
+	Prop_PreviousUniverseId_Uint64 = 2005,
+	Prop_DisplayFirmwareVersion_Uint64 = 2006,
+	Prop_IsOnDesktop_Bool = 2007,
+	Prop_DisplayMCType_Int32 = 2008,
+	Prop_DisplayMCOffset_Float = 2009,
+	Prop_DisplayMCScale_Float = 2010,
+	Prop_EdidVendorID_Int32 = 2011,
+	Prop_DisplayMCImageLeft_String = 2012,
+	Prop_DisplayMCImageRight_String = 2013,
+	Prop_DisplayGCBlackClamp_Float = 2014,
+	Prop_EdidProductID_Int32 = 2015,
+	Prop_CameraToHeadTransform_Matrix34 = 2016,
+	Prop_DisplayGCType_Int32 = 2017,
+	Prop_DisplayGCOffset_Float = 2018,
+	Prop_DisplayGCScale_Float = 2019,
+	Prop_DisplayGCPrescale_Float = 2020,
+	Prop_DisplayGCImage_String = 2021,
+	Prop_LensCenterLeftU_Float = 2022,
+	Prop_LensCenterLeftV_Float = 2023,
+	Prop_LensCenterRightU_Float = 2024,
+	Prop_LensCenterRightV_Float = 2025,
+	Prop_UserHeadToEyeDepthMeters_Float = 2026,
+	Prop_CameraFirmwareVersion_Uint64 = 2027,
+	Prop_CameraFirmwareDescription_String = 2028,
+	Prop_DisplayFPGAVersion_Uint64 = 2029,
+	Prop_DisplayBootloaderVersion_Uint64 = 2030,
+	Prop_DisplayHardwareVersion_Uint64 = 2031,
+	Prop_AudioFirmwareVersion_Uint64 = 2032,
+	Prop_CameraCompatibilityMode_Int32 = 2033,
+	Prop_ScreenshotHorizontalFieldOfViewDegrees_Float = 2034,
+	Prop_ScreenshotVerticalFieldOfViewDegrees_Float = 2035,
+	Prop_DisplaySuppressed_Bool = 2036,
+	Prop_DisplayAllowNightMode_Bool = 2037,
+	Prop_DisplayMCImageWidth_Int32 = 2038,
+	Prop_DisplayMCImageHeight_Int32 = 2039,
+	Prop_DisplayMCImageNumChannels_Int32 = 2040,
+	Prop_DisplayMCImageData_Binary = 2041,
+	Prop_SecondsFromPhotonsToVblank_Float = 2042,
+	Prop_DriverDirectModeSendsVsyncEvents_Bool = 2043,
+	Prop_DisplayDebugMode_Bool = 2044,
+	Prop_GraphicsAdapterLuid_Uint64 = 2045,
+	Prop_DriverProvidedChaperonePath_String = 2048,
+
+	// Properties that are unique to TrackedDeviceClass_Controller
+	Prop_AttachedDeviceId_String = 3000,
+	Prop_SupportedButtons_Uint64 = 3001,
+	Prop_Axis0Type_Int32 = 3002,           // Return value is of type EVRControllerAxisType
+	Prop_Axis1Type_Int32 = 3003,           // Return value is of type EVRControllerAxisType
+	Prop_Axis2Type_Int32 = 3004,           // Return value is of type EVRControllerAxisType
+	Prop_Axis3Type_Int32 = 3005,           // Return value is of type EVRControllerAxisType
+	Prop_Axis4Type_Int32 = 3006,           // Return value is of type EVRControllerAxisType
+	Prop_ControllerRoleHint_Int32 = 3007,  // Return value is of type ETrackedControllerRole
+
+	// Properties that are unique to TrackedDeviceClass_TrackingReference
+	Prop_FieldOfViewLeftDegrees_Float = 4000,
+	Prop_FieldOfViewRightDegrees_Float = 4001,
+	Prop_FieldOfViewTopDegrees_Float = 4002,
+	Prop_FieldOfViewBottomDegrees_Float = 4003,
+	Prop_TrackingRangeMinimumMeters_Float = 4004,
+	Prop_TrackingRangeMaximumMeters_Float = 4005,
+	Prop_ModeLabel_String = 4006,
+
+	// Properties that are used for user interface like icons names
+	Prop_IconPathName_String = 5000,                       // DEPRECATED. Value not referenced. Now expected to be part of icon path properties.
+	Prop_NamedIconPathDeviceOff_String = 5001,             // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceSearching_String = 5002,       // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceSearchingAlert_String = 5003,  // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceReady_String = 5004,           // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceReadyAlert_String = 5005,      // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceNotReady_String = 5006,        // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceStandby_String = 5007,         // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceAlertLow_String = 5008,        // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+
+	// Properties that are used by helpers, but are opaque to applications
+	Prop_DisplayHiddenArea_Binary_Start = 5100,
+	Prop_DisplayHiddenArea_Binary_End = 5150,
+
+	// Properties that are unique to drivers
+	Prop_UserConfigPath_String = 6000,
+	Prop_InstallPath_String = 6001,
+	Prop_HasDisplayComponent_Bool = 6002,
+	Prop_HasControllerComponent_Bool = 6003,
+	Prop_HasCameraComponent_Bool = 6004,
+	Prop_HasDriverDirectModeComponent_Bool = 6005,
+	Prop_HasVirtualDisplayComponent_Bool = 6006,
+
+	// Vendors are free to expose private debug data in this reserved region
+	Prop_VendorSpecific_Reserved_Start = 10000,
+	Prop_VendorSpecific_Reserved_End = 10999,
+};
+
+/** No string property will ever be longer than this length */
+static const uint32_t k_unMaxPropertyStringSize = 32 * 1024;
+
+/** Used to return errors that occur when reading properties. */
+enum ETrackedPropertyError
+{
+	TrackedProp_Success = 0,
+	TrackedProp_WrongDataType = 1,
+	TrackedProp_WrongDeviceClass = 2,
+	TrackedProp_BufferTooSmall = 3,
+	TrackedProp_UnknownProperty = 4,  // Driver has not set the property (and may not ever).
+	TrackedProp_InvalidDevice = 5,
+	TrackedProp_CouldNotContactServer = 6,
+	TrackedProp_ValueNotProvidedByDevice = 7,
+	TrackedProp_StringExceedsMaximumLength = 8,
+	TrackedProp_NotYetAvailable = 9,  // The property value isn't known yet, but is expected soon. Call again later.
+	TrackedProp_PermissionDenied = 10,
+	TrackedProp_InvalidOperation = 11,
+};
+
+/** Allows the application to control what part of the provided texture will be used in the
+* frame buffer. */
+struct VRTextureBounds_t
+{
+	float uMin, vMin;
+	float uMax, vMax;
+};
+
+/** Allows specifying pose used to render provided scene texture (if different from value returned by WaitGetPoses). */
+struct VRTextureWithPose_t : public Texture_t
+{
+	HmdMatrix34_t mDeviceToAbsoluteTracking;  // Actual pose used to render scene textures.
+};
+
+/** Allows the application to control how scene textures are used by the compositor when calling Submit. */
+enum EVRSubmitFlags
+{
+	// Simple render path. App submits rendered left and right eye images with no lens distortion correction applied.
+	Submit_Default = 0x00,
+
+	// App submits final left and right eye images with lens distortion already applied (lens distortion makes the images appear
+	// barrel distorted with chromatic aberration correction applied). The app would have used the data returned by
+	// vr::IVRSystem::ComputeDistortion() to apply the correct distortion to the rendered images before calling Submit().
+	Submit_LensDistortionAlreadyApplied = 0x01,
+
+	// If the texture pointer passed in is actually a renderbuffer (e.g. for MSAA in OpenGL) then set this flag.
+	Submit_GlRenderBuffer = 0x02,
+
+	// Do not use
+	Submit_Reserved = 0x04,
+
+	// Set to indicate that pTexture is a pointer to a VRTextureWithPose_t.
+	Submit_TextureWithPose = 0x08,
+};
+
+/** Data required for passing Vulkan textures to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. */
+struct VRVulkanTextureData_t
+{
+	uint64_t m_nImage;  // VkImage
+	VkDevice_T *m_pDevice;
+	VkPhysicalDevice_T *m_pPhysicalDevice;
+	VkInstance_T *m_pInstance;
+	VkQueue_T *m_pQueue;
+	uint32_t m_nQueueFamilyIndex;
+	uint32_t m_nWidth, m_nHeight, m_nFormat, m_nSampleCount;
+};
+
+/** Data required for passing D3D12 textures to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. */
+struct D3D12TextureData_t
+{
+	ID3D12Resource *m_pResource;
+	ID3D12CommandQueue *m_pCommandQueue;
+	uint32_t m_nNodeMask;
+};
+
+/** Status of the overall system or tracked objects */
+enum EVRState
+{
+	VRState_Undefined = -1,
+	VRState_Off = 0,
+	VRState_Searching = 1,
+	VRState_Searching_Alert = 2,
+	VRState_Ready = 3,
+	VRState_Ready_Alert = 4,
+	VRState_NotReady = 5,
+	VRState_Standby = 6,
+	VRState_Ready_Alert_Low = 7,
+};
+
+/** The types of events that could be posted (and what the parameters mean for each event type) */
+enum EVREventType
+{
+	VREvent_None = 0,
+
+	VREvent_TrackedDeviceActivated = 100,
+	VREvent_TrackedDeviceDeactivated = 101,
+	VREvent_TrackedDeviceUpdated = 102,
+	VREvent_TrackedDeviceUserInteractionStarted = 103,
+	VREvent_TrackedDeviceUserInteractionEnded = 104,
+	VREvent_IpdChanged = 105,
+	VREvent_EnterStandbyMode = 106,
+	VREvent_LeaveStandbyMode = 107,
+	VREvent_TrackedDeviceRoleChanged = 108,
+	VREvent_WatchdogWakeUpRequested = 109,
+	VREvent_LensDistortionChanged = 110,
+	VREvent_PropertyChanged = 111,
+	VREvent_WirelessDisconnect = 112,
+	VREvent_WirelessReconnect = 113,
+
+	VREvent_ButtonPress = 200,    // data is controller
+	VREvent_ButtonUnpress = 201,  // data is controller
+	VREvent_ButtonTouch = 202,    // data is controller
+	VREvent_ButtonUntouch = 203,  // data is controller
+
+	VREvent_MouseMove = 300,            // data is mouse
+	VREvent_MouseButtonDown = 301,      // data is mouse
+	VREvent_MouseButtonUp = 302,        // data is mouse
+	VREvent_FocusEnter = 303,           // data is overlay
+	VREvent_FocusLeave = 304,           // data is overlay
+	VREvent_Scroll = 305,               // data is mouse
+	VREvent_TouchPadMove = 306,         // data is mouse
+	VREvent_OverlayFocusChanged = 307,  // data is overlay, global event
+
+	VREvent_InputFocusCaptured = 400,                         // data is process DEPRECATED
+	VREvent_InputFocusReleased = 401,                         // data is process DEPRECATED
+	VREvent_SceneFocusLost = 402,                             // data is process
+	VREvent_SceneFocusGained = 403,                           // data is process
+	VREvent_SceneApplicationChanged = 404,                    // data is process - The App actually drawing the scene changed (usually to or from the compositor)
+	VREvent_SceneFocusChanged = 405,                          // data is process - New app got access to draw the scene
+	VREvent_InputFocusChanged = 406,                          // data is process
+	VREvent_SceneApplicationSecondaryRenderingStarted = 407,  // data is process
+
+	VREvent_HideRenderModels = 410,  // Sent to the scene application to request hiding render models temporarily
+	VREvent_ShowRenderModels = 411,  // Sent to the scene application to request restoring render model visibility
+
+	VREvent_OverlayShown = 500,
+	VREvent_OverlayHidden = 501,
+	VREvent_DashboardActivated = 502,
+	VREvent_DashboardDeactivated = 503,
+	VREvent_DashboardThumbSelected = 504,     // Sent to the overlay manager - data is overlay
+	VREvent_DashboardRequested = 505,         // Sent to the overlay manager - data is overlay
+	VREvent_ResetDashboard = 506,             // Send to the overlay manager
+	VREvent_RenderToast = 507,                // Send to the dashboard to render a toast - data is the notification ID
+	VREvent_ImageLoaded = 508,                // Sent to overlays when a SetOverlayRaw or SetOverlayFromFile call finishes loading
+	VREvent_ShowKeyboard = 509,               // Sent to keyboard renderer in the dashboard to invoke it
+	VREvent_HideKeyboard = 510,               // Sent to keyboard renderer in the dashboard to hide it
+	VREvent_OverlayGamepadFocusGained = 511,  // Sent to an overlay when IVROverlay::SetFocusOverlay is called on it
+	VREvent_OverlayGamepadFocusLost = 512,    // Send to an overlay when it previously had focus and IVROverlay::SetFocusOverlay is called on something else
+	VREvent_OverlaySharedTextureChanged = 513,
+	VREvent_DashboardGuideButtonDown = 514,
+	VREvent_DashboardGuideButtonUp = 515,
+	VREvent_ScreenshotTriggered = 516,  // Screenshot button combo was pressed, Dashboard should request a screenshot
+	VREvent_ImageFailed = 517,          // Sent to overlays when a SetOverlayRaw or SetOverlayfromFail fails to load
+	VREvent_DashboardOverlayCreated = 518,
+
+	// Screenshot API
+	VREvent_RequestScreenshot = 520,              // Sent by vrclient application to compositor to take a screenshot
+	VREvent_ScreenshotTaken = 521,                // Sent by compositor to the application that the screenshot has been taken
+	VREvent_ScreenshotFailed = 522,               // Sent by compositor to the application that the screenshot failed to be taken
+	VREvent_SubmitScreenshotToDashboard = 523,    // Sent by compositor to the dashboard that a completed screenshot was submitted
+	VREvent_ScreenshotProgressToDashboard = 524,  // Sent by compositor to the dashboard that a completed screenshot was submitted
+
+	VREvent_PrimaryDashboardDeviceChanged = 525,
+
+	VREvent_Notification_Shown = 600,
+	VREvent_Notification_Hidden = 601,
+	VREvent_Notification_BeginInteraction = 602,
+	VREvent_Notification_Destroyed = 603,
+
+	VREvent_Quit = 700,                    // data is process
+	VREvent_ProcessQuit = 701,             // data is process
+	VREvent_QuitAborted_UserPrompt = 702,  // data is process
+	VREvent_QuitAcknowledged = 703,        // data is process
+	VREvent_DriverRequestedQuit = 704,     // The driver has requested that SteamVR shut down
+
+	VREvent_ChaperoneDataHasChanged = 800,
+	VREvent_ChaperoneUniverseHasChanged = 801,
+	VREvent_ChaperoneTempDataHasChanged = 802,
+	VREvent_ChaperoneSettingsHaveChanged = 803,
+	VREvent_SeatedZeroPoseReset = 804,
+
+	VREvent_AudioSettingsHaveChanged = 820,
+
+	VREvent_BackgroundSettingHasChanged = 850,
+	VREvent_CameraSettingsHaveChanged = 851,
+	VREvent_ReprojectionSettingHasChanged = 852,
+	VREvent_ModelSkinSettingsHaveChanged = 853,
+	VREvent_EnvironmentSettingsHaveChanged = 854,
+	VREvent_PowerSettingsHaveChanged = 855,
+	VREvent_EnableHomeAppSettingsHaveChanged = 856,
+
+	VREvent_StatusUpdate = 900,
+
+	VREvent_MCImageUpdated = 1000,
+
+	VREvent_FirmwareUpdateStarted = 1100,
+	VREvent_FirmwareUpdateFinished = 1101,
+
+	VREvent_KeyboardClosed = 1200,
+	VREvent_KeyboardCharInput = 1201,
+	VREvent_KeyboardDone = 1202,  // Sent when DONE button clicked on keyboard
+
+	VREvent_ApplicationTransitionStarted = 1300,
+	VREvent_ApplicationTransitionAborted = 1301,
+	VREvent_ApplicationTransitionNewAppStarted = 1302,
+	VREvent_ApplicationListUpdated = 1303,
+	VREvent_ApplicationMimeTypeLoad = 1304,
+	VREvent_ApplicationTransitionNewAppLaunchComplete = 1305,
+	VREvent_ProcessConnected = 1306,
+	VREvent_ProcessDisconnected = 1307,
+
+	VREvent_Compositor_MirrorWindowShown = 1400,
+	VREvent_Compositor_MirrorWindowHidden = 1401,
+	VREvent_Compositor_ChaperoneBoundsShown = 1410,
+	VREvent_Compositor_ChaperoneBoundsHidden = 1411,
+
+	VREvent_TrackedCamera_StartVideoStream = 1500,
+	VREvent_TrackedCamera_StopVideoStream = 1501,
+	VREvent_TrackedCamera_PauseVideoStream = 1502,
+	VREvent_TrackedCamera_ResumeVideoStream = 1503,
+	VREvent_TrackedCamera_EditingSurface = 1550,
+
+	VREvent_PerformanceTest_EnableCapture = 1600,
+	VREvent_PerformanceTest_DisableCapture = 1601,
+	VREvent_PerformanceTest_FidelityLevel = 1602,
+
+	VREvent_MessageOverlay_Closed = 1650,
+	VREvent_MessageOverlayCloseRequested = 1651,
+
+	// Vendors are free to expose private events in this reserved region
+	VREvent_VendorSpecific_Reserved_Start = 10000,
+	VREvent_VendorSpecific_Reserved_End = 19999,
+};
+
+/** Level of Hmd activity */
+// UserInteraction_Timeout means the device is in the process of timing out.
+// InUse = ( k_EDeviceActivityLevel_UserInteraction || k_EDeviceActivityLevel_UserInteraction_Timeout )
+// VREvent_TrackedDeviceUserInteractionStarted fires when the devices transitions from Standby -> UserInteraction or Idle -> UserInteraction.
+// VREvent_TrackedDeviceUserInteractionEnded fires when the devices transitions from UserInteraction_Timeout -> Idle
+enum EDeviceActivityLevel
+{
+	k_EDeviceActivityLevel_Unknown = -1,
+	k_EDeviceActivityLevel_Idle = 0,                     // No activity for the last 10 seconds
+	k_EDeviceActivityLevel_UserInteraction = 1,          // Activity (movement or prox sensor) is happening now
+	k_EDeviceActivityLevel_UserInteraction_Timeout = 2,  // No activity for the last 0.5 seconds
+	k_EDeviceActivityLevel_Standby = 3,                  // Idle for at least 5 seconds (configurable in Settings -> Power Management)
+};
+
+/** VR controller button and axis IDs */
+enum EVRButtonId
+{
+	k_EButton_System = 0,
+	k_EButton_ApplicationMenu = 1,
+	k_EButton_Grip = 2,
+	k_EButton_DPad_Left = 3,
+	k_EButton_DPad_Up = 4,
+	k_EButton_DPad_Right = 5,
+	k_EButton_DPad_Down = 6,
+	k_EButton_A = 7,
+
+	k_EButton_ProximitySensor = 31,
+
+	k_EButton_Axis0 = 32,
+	k_EButton_Axis1 = 33,
+	k_EButton_Axis2 = 34,
+	k_EButton_Axis3 = 35,
+	k_EButton_Axis4 = 36,
+
+	// aliases for well known controllers
+	k_EButton_SteamVR_Touchpad = k_EButton_Axis0,
+	k_EButton_SteamVR_Trigger = k_EButton_Axis1,
+
+	k_EButton_Dashboard_Back = k_EButton_Grip,
+
+	k_EButton_Max = 64
+};
+
+inline uint64_t ButtonMaskFromId(EVRButtonId id) { return 1ull << id; }
+
+/** used for controller button events */
+struct VREvent_Controller_t
+{
+	uint32_t button;  // EVRButtonId enum
+};
+
+/** used for simulated mouse events in overlay space */
+enum EVRMouseButton
+{
+	VRMouseButton_Left = 0x0001,
+	VRMouseButton_Right = 0x0002,
+	VRMouseButton_Middle = 0x0004,
+};
+
+/** used for simulated mouse events in overlay space */
+struct VREvent_Mouse_t
+{
+	float x, y;       // co-ords are in GL space, bottom left of the texture is 0,0
+	uint32_t button;  // EVRMouseButton enum
+};
+
+/** used for simulated mouse wheel scroll in overlay space */
+struct VREvent_Scroll_t
+{
+	float xdelta, ydelta;  // movement in fraction of the pad traversed since last delta, 1.0 for a full swipe
+	uint32_t repeatCount;
+};
+
+/** when in mouse input mode you can receive data from the touchpad, these events are only sent if the users finger
+   is on the touchpad (or just released from it) 
+**/
+struct VREvent_TouchPadMove_t
+{
+	// true if the users finger is detected on the touch pad
+	bool bFingerDown;
+
+	// How long the finger has been down in seconds
+	float flSecondsFingerDown;
+
+	// These values indicate the starting finger position (so you can do some basic swipe stuff)
+	float fValueXFirst;
+	float fValueYFirst;
+
+	// This is the raw sampled coordinate without deadzoning
+	float fValueXRaw;
+	float fValueYRaw;
+};
+
+/** notification related events. Details will still change at this point */
+struct VREvent_Notification_t
+{
+	uint64_t ulUserValue;
+	uint32_t notificationId;
+};
+
+/** Used for events about processes */
+struct VREvent_Process_t
+{
+	uint32_t pid;
+	uint32_t oldPid;
+	bool bForced;
+};
+
+/** Used for a few events about overlays */
+struct VREvent_Overlay_t
+{
+	uint64_t overlayHandle;
+};
+
+/** Used for a few events about overlays */
+struct VREvent_Status_t
+{
+	uint32_t statusState;  // EVRState enum
+};
+
+/** Used for keyboard events **/
+struct VREvent_Keyboard_t
+{
+	char cNewInput[8];    // Up to 11 bytes of new input
+	uint64_t uUserValue;  // Possible flags about the new input
+};
+
+struct VREvent_Ipd_t
+{
+	float ipdMeters;
+};
+
+struct VREvent_Chaperone_t
+{
+	uint64_t m_nPreviousUniverse;
+	uint64_t m_nCurrentUniverse;
+};
+
+/** Not actually used for any events */
+struct VREvent_Reserved_t
+{
+	uint64_t reserved0;
+	uint64_t reserved1;
+};
+
+struct VREvent_PerformanceTest_t
+{
+	uint32_t m_nFidelityLevel;
+};
+
+struct VREvent_SeatedZeroPoseReset_t
+{
+	bool bResetBySystemMenu;
+};
+
+struct VREvent_Screenshot_t
+{
+	uint32_t handle;
+	uint32_t type;
+};
+
+struct VREvent_ScreenshotProgress_t
+{
+	float progress;
+};
+
+struct VREvent_ApplicationLaunch_t
+{
+	uint32_t pid;
+	uint32_t unArgsHandle;
+};
+
+struct VREvent_EditingCameraSurface_t
+{
+	uint64_t overlayHandle;
+	uint32_t nVisualMode;
+};
+
+struct VREvent_MessageOverlay_t
+{
+	uint32_t unVRMessageOverlayResponse;  // vr::VRMessageOverlayResponse enum
+};
+
+struct VREvent_Property_t
+{
+	PropertyContainerHandle_t container;
+	ETrackedDeviceProperty prop;
+};
+
+/** NOTE!!! If you change this you MUST manually update openvr_interop.cs.py */
+typedef union {
+	VREvent_Reserved_t reserved;
+	VREvent_Controller_t controller;
+	VREvent_Mouse_t mouse;
+	VREvent_Scroll_t scroll;
+	VREvent_Process_t process;
+	VREvent_Notification_t notification;
+	VREvent_Overlay_t overlay;
+	VREvent_Status_t status;
+	VREvent_Keyboard_t keyboard;
+	VREvent_Ipd_t ipd;
+	VREvent_Chaperone_t chaperone;
+	VREvent_PerformanceTest_t performanceTest;
+	VREvent_TouchPadMove_t touchPadMove;
+	VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset;
+	VREvent_Screenshot_t screenshot;
+	VREvent_ScreenshotProgress_t screenshotProgress;
+	VREvent_ApplicationLaunch_t applicationLaunch;
+	VREvent_EditingCameraSurface_t cameraSurface;
+	VREvent_MessageOverlay_t messageOverlay;
+	VREvent_Property_t property;
+} VREvent_Data_t;
+
+#if defined(__linux__) || defined(__APPLE__)
+// This structure was originally defined mis-packed on Linux, preserved for
+// compatibility.
+#pragma pack(push, 4)
+#endif
+
+/** An event posted by the server to all running applications */
+struct VREvent_t
+{
+	uint32_t eventType;  // EVREventType enum
+	TrackedDeviceIndex_t trackedDeviceIndex;
+	float eventAgeSeconds;
+	// event data must be the end of the struct as its size is variable
+	VREvent_Data_t data;
+};
+
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+
+/** The mesh to draw into the stencil (or depth) buffer to perform 
+* early stencil (or depth) kills of pixels that will never appear on the HMD.
+* This mesh draws on all the pixels that will be hidden after distortion. 
+*
+* If the HMD does not provide a visible area mesh pVertexData will be
+* NULL and unTriangleCount will be 0. */
+struct HiddenAreaMesh_t
+{
+	const HmdVector2_t *pVertexData;
+	uint32_t unTriangleCount;
+};
+
+enum EHiddenAreaMeshType
+{
+	k_eHiddenAreaMesh_Standard = 0,
+	k_eHiddenAreaMesh_Inverse = 1,
+	k_eHiddenAreaMesh_LineLoop = 2,
+
+	k_eHiddenAreaMesh_Max = 3,
+};
+
+/** Identifies what kind of axis is on the controller at index n. Read this type 
+* with pVRSystem->Get( nControllerDeviceIndex, Prop_Axis0Type_Int32 + n );
+*/
+enum EVRControllerAxisType
+{
+	k_eControllerAxis_None = 0,
+	k_eControllerAxis_TrackPad = 1,
+	k_eControllerAxis_Joystick = 2,
+	k_eControllerAxis_Trigger = 3,  // Analog trigger data is in the X axis
+};
+
+/** contains information about one axis on the controller */
+struct VRControllerAxis_t
+{
+	float x;  // Ranges from -1.0 to 1.0 for joysticks and track pads. Ranges from 0.0 to 1.0 for triggers were 0 is fully released.
+	float y;  // Ranges from -1.0 to 1.0 for joysticks and track pads. Is always 0.0 for triggers.
+};
+
+/** the number of axes in the controller state */
+static const uint32_t k_unControllerStateAxisCount = 5;
+
+#if defined(__linux__) || defined(__APPLE__)
+// This structure was originally defined mis-packed on Linux, preserved for
+// compatibility.
+#pragma pack(push, 4)
+#endif
+
+/** Holds all the state of a controller at one moment in time. */
+struct VRControllerState001_t
+{
+	// If packet num matches that on your prior call, then the controller state hasn't been changed since
+	// your last call and there is no need to process it
+	uint32_t unPacketNum;
+
+	// bit flags for each of the buttons. Use ButtonMaskFromId to turn an ID into a mask
+	uint64_t ulButtonPressed;
+	uint64_t ulButtonTouched;
+
+	// Axis data for the controller's analog inputs
+	VRControllerAxis_t rAxis[k_unControllerStateAxisCount];
+};
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+
+typedef VRControllerState001_t VRControllerState_t;
+
+/** determines how to provide output to the application of various event processing functions. */
+enum EVRControllerEventOutputType
+{
+	ControllerEventOutput_OSEvents = 0,
+	ControllerEventOutput_VREvents = 1,
+};
+
+/** Collision Bounds Style */
+enum ECollisionBoundsStyle
+{
+	COLLISION_BOUNDS_STYLE_BEGINNER = 0,
+	COLLISION_BOUNDS_STYLE_INTERMEDIATE,
+	COLLISION_BOUNDS_STYLE_SQUARES,
+	COLLISION_BOUNDS_STYLE_ADVANCED,
+	COLLISION_BOUNDS_STYLE_NONE,
+
+	COLLISION_BOUNDS_STYLE_COUNT
+};
+
+/** Allows the application to customize how the overlay appears in the compositor */
+struct Compositor_OverlaySettings
+{
+	uint32_t size;  // sizeof(Compositor_OverlaySettings)
+	bool curved, antialias;
+	float scale, distance, alpha;
+	float uOffset, vOffset, uScale, vScale;
+	float gridDivs, gridWidth, gridScale;
+	HmdMatrix44_t transform;
+};
+
+/** used to refer to a single VR overlay */
+typedef uint64_t VROverlayHandle_t;
+
+static const VROverlayHandle_t k_ulOverlayHandleInvalid = 0;
+
+/** Errors that can occur around VR overlays */
+enum EVROverlayError
+{
+	VROverlayError_None = 0,
+
+	VROverlayError_UnknownOverlay = 10,
+	VROverlayError_InvalidHandle = 11,
+	VROverlayError_PermissionDenied = 12,
+	VROverlayError_OverlayLimitExceeded = 13,  // No more overlays could be created because the maximum number already exist
+	VROverlayError_WrongVisibilityType = 14,
+	VROverlayError_KeyTooLong = 15,
+	VROverlayError_NameTooLong = 16,
+	VROverlayError_KeyInUse = 17,
+	VROverlayError_WrongTransformType = 18,
+	VROverlayError_InvalidTrackedDevice = 19,
+	VROverlayError_InvalidParameter = 20,
+	VROverlayError_ThumbnailCantBeDestroyed = 21,
+	VROverlayError_ArrayTooSmall = 22,
+	VROverlayError_RequestFailed = 23,
+	VROverlayError_InvalidTexture = 24,
+	VROverlayError_UnableToLoadFile = 25,
+	VROverlayError_KeyboardAlreadyInUse = 26,
+	VROverlayError_NoNeighbor = 27,
+	VROverlayError_TooManyMaskPrimitives = 29,
+	VROverlayError_BadMaskPrimitive = 30,
+};
+
+/** enum values to pass in to VR_Init to identify whether the application will 
+* draw a 3D scene. */
+enum EVRApplicationType
+{
+	VRApplication_Other = 0,          // Some other kind of application that isn't covered by the other entries
+	VRApplication_Scene = 1,          // Application will submit 3D frames
+	VRApplication_Overlay = 2,        // Application only interacts with overlays
+	VRApplication_Background = 3,     // Application should not start SteamVR if it's not already running, and should not
+									  // keep it running if everything else quits.
+	VRApplication_Utility = 4,        // Init should not try to load any drivers. The application needs access to utility
+									  // interfaces (like IVRSettings and IVRApplications) but not hardware.
+	VRApplication_VRMonitor = 5,      // Reserved for vrmonitor
+	VRApplication_SteamWatchdog = 6,  // Reserved for Steam
+	VRApplication_Bootstrapper = 7,   // Start up SteamVR
+
+	VRApplication_Max
+};
+
+/** error codes for firmware */
+enum EVRFirmwareError
+{
+	VRFirmwareError_None = 0,
+	VRFirmwareError_Success = 1,
+	VRFirmwareError_Fail = 2,
+};
+
+/** error codes for notifications */
+enum EVRNotificationError
+{
+	VRNotificationError_OK = 0,
+	VRNotificationError_InvalidNotificationId = 100,
+	VRNotificationError_NotificationQueueFull = 101,
+	VRNotificationError_InvalidOverlayHandle = 102,
+	VRNotificationError_SystemWithUserValueAlreadyExists = 103,
+};
+
+/** error codes returned by Vr_Init */
+
+// Please add adequate error description to https://developer.valvesoftware.com/w/index.php?title=Category:SteamVRHelp
+enum EVRInitError
+{
+	VRInitError_None = 0,
+	VRInitError_Unknown = 1,
+
+	VRInitError_Init_InstallationNotFound = 100,
+	VRInitError_Init_InstallationCorrupt = 101,
+	VRInitError_Init_VRClientDLLNotFound = 102,
+	VRInitError_Init_FileNotFound = 103,
+	VRInitError_Init_FactoryNotFound = 104,
+	VRInitError_Init_InterfaceNotFound = 105,
+	VRInitError_Init_InvalidInterface = 106,
+	VRInitError_Init_UserConfigDirectoryInvalid = 107,
+	VRInitError_Init_HmdNotFound = 108,
+	VRInitError_Init_NotInitialized = 109,
+	VRInitError_Init_PathRegistryNotFound = 110,
+	VRInitError_Init_NoConfigPath = 111,
+	VRInitError_Init_NoLogPath = 112,
+	VRInitError_Init_PathRegistryNotWritable = 113,
+	VRInitError_Init_AppInfoInitFailed = 114,
+	VRInitError_Init_Retry = 115,               // Used internally to cause retries to vrserver
+	VRInitError_Init_InitCanceledByUser = 116,  // The calling application should silently exit. The user canceled app startup
+	VRInitError_Init_AnotherAppLaunching = 117,
+	VRInitError_Init_SettingsInitFailed = 118,
+	VRInitError_Init_ShuttingDown = 119,
+	VRInitError_Init_TooManyObjects = 120,
+	VRInitError_Init_NoServerForBackgroundApp = 121,
+	VRInitError_Init_NotSupportedWithCompositor = 122,
+	VRInitError_Init_NotAvailableToUtilityApps = 123,
+	VRInitError_Init_Internal = 124,
+	VRInitError_Init_HmdDriverIdIsNone = 125,
+	VRInitError_Init_HmdNotFoundPresenceFailed = 126,
+	VRInitError_Init_VRMonitorNotFound = 127,
+	VRInitError_Init_VRMonitorStartupFailed = 128,
+	VRInitError_Init_LowPowerWatchdogNotSupported = 129,
+	VRInitError_Init_InvalidApplicationType = 130,
+	VRInitError_Init_NotAvailableToWatchdogApps = 131,
+	VRInitError_Init_WatchdogDisabledInSettings = 132,
+	VRInitError_Init_VRDashboardNotFound = 133,
+	VRInitError_Init_VRDashboardStartupFailed = 134,
+	VRInitError_Init_VRHomeNotFound = 135,
+	VRInitError_Init_VRHomeStartupFailed = 136,
+	VRInitError_Init_RebootingBusy = 137,
+	VRInitError_Init_FirmwareUpdateBusy = 138,
+	VRInitError_Init_FirmwareRecoveryBusy = 139,
+
+	VRInitError_Driver_Failed = 200,
+	VRInitError_Driver_Unknown = 201,
+	VRInitError_Driver_HmdUnknown = 202,
+	VRInitError_Driver_NotLoaded = 203,
+	VRInitError_Driver_RuntimeOutOfDate = 204,
+	VRInitError_Driver_HmdInUse = 205,
+	VRInitError_Driver_NotCalibrated = 206,
+	VRInitError_Driver_CalibrationInvalid = 207,
+	VRInitError_Driver_HmdDisplayNotFound = 208,
+	VRInitError_Driver_TrackedDeviceInterfaceUnknown = 209,
+	// VRInitError_Driver_HmdDisplayNotFoundAfterFix = 210, // not needed: here for historic reasons
+	VRInitError_Driver_HmdDriverIdOutOfBounds = 211,
+	VRInitError_Driver_HmdDisplayMirrored = 212,
+
+	VRInitError_IPC_ServerInitFailed = 300,
+	VRInitError_IPC_ConnectFailed = 301,
+	VRInitError_IPC_SharedStateInitFailed = 302,
+	VRInitError_IPC_CompositorInitFailed = 303,
+	VRInitError_IPC_MutexInitFailed = 304,
+	VRInitError_IPC_Failed = 305,
+	VRInitError_IPC_CompositorConnectFailed = 306,
+	VRInitError_IPC_CompositorInvalidConnectResponse = 307,
+	VRInitError_IPC_ConnectFailedAfterMultipleAttempts = 308,
+
+	VRInitError_Compositor_Failed = 400,
+	VRInitError_Compositor_D3D11HardwareRequired = 401,
+	VRInitError_Compositor_FirmwareRequiresUpdate = 402,
+	VRInitError_Compositor_OverlayInitFailed = 403,
+	VRInitError_Compositor_ScreenshotsInitFailed = 404,
+	VRInitError_Compositor_UnableToCreateDevice = 405,
+
+	VRInitError_VendorSpecific_UnableToConnectToOculusRuntime = 1000,
+
+	VRInitError_VendorSpecific_HmdFound_CantOpenDevice = 1101,
+	VRInitError_VendorSpecific_HmdFound_UnableToRequestConfigStart = 1102,
+	VRInitError_VendorSpecific_HmdFound_NoStoredConfig = 1103,
+	VRInitError_VendorSpecific_HmdFound_ConfigTooBig = 1104,
+	VRInitError_VendorSpecific_HmdFound_ConfigTooSmall = 1105,
+	VRInitError_VendorSpecific_HmdFound_UnableToInitZLib = 1106,
+	VRInitError_VendorSpecific_HmdFound_CantReadFirmwareVersion = 1107,
+	VRInitError_VendorSpecific_HmdFound_UnableToSendUserDataStart = 1108,
+	VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataStart = 1109,
+	VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataNext = 1110,
+	VRInitError_VendorSpecific_HmdFound_UserDataAddressRange = 1111,
+	VRInitError_VendorSpecific_HmdFound_UserDataError = 1112,
+	VRInitError_VendorSpecific_HmdFound_ConfigFailedSanityCheck = 1113,
+
+	VRInitError_Steam_SteamInstallationNotFound = 2000,
+};
+
+enum EVRScreenshotType
+{
+	VRScreenshotType_None = 0,
+	VRScreenshotType_Mono = 1,  // left eye only
+	VRScreenshotType_Stereo = 2,
+	VRScreenshotType_Cubemap = 3,
+	VRScreenshotType_MonoPanorama = 4,
+	VRScreenshotType_StereoPanorama = 5
+};
+
+enum EVRScreenshotPropertyFilenames
+{
+	VRScreenshotPropertyFilenames_Preview = 0,
+	VRScreenshotPropertyFilenames_VR = 1,
+};
+
+enum EVRTrackedCameraError
+{
+	VRTrackedCameraError_None = 0,
+	VRTrackedCameraError_OperationFailed = 100,
+	VRTrackedCameraError_InvalidHandle = 101,
+	VRTrackedCameraError_InvalidFrameHeaderVersion = 102,
+	VRTrackedCameraError_OutOfHandles = 103,
+	VRTrackedCameraError_IPCFailure = 104,
+	VRTrackedCameraError_NotSupportedForThisDevice = 105,
+	VRTrackedCameraError_SharedMemoryFailure = 106,
+	VRTrackedCameraError_FrameBufferingFailure = 107,
+	VRTrackedCameraError_StreamSetupFailure = 108,
+	VRTrackedCameraError_InvalidGLTextureId = 109,
+	VRTrackedCameraError_InvalidSharedTextureHandle = 110,
+	VRTrackedCameraError_FailedToGetGLTextureId = 111,
+	VRTrackedCameraError_SharedTextureFailure = 112,
+	VRTrackedCameraError_NoFrameAvailable = 113,
+	VRTrackedCameraError_InvalidArgument = 114,
+	VRTrackedCameraError_InvalidFrameBufferSize = 115,
+};
+
+enum EVRTrackedCameraFrameType
+{
+	VRTrackedCameraFrameType_Distorted = 0,       // This is the camera video frame size in pixels, still distorted.
+	VRTrackedCameraFrameType_Undistorted,         // In pixels, an undistorted inscribed rectangle region without invalid regions. This size is subject to changes shortly.
+	VRTrackedCameraFrameType_MaximumUndistorted,  // In pixels, maximum undistorted with invalid regions. Non zero alpha component identifies valid regions.
+	MAX_CAMERA_FRAME_TYPES
+};
+
+typedef uint64_t TrackedCameraHandle_t;
+#define INVALID_TRACKED_CAMERA_HANDLE ((vr::TrackedCameraHandle_t)0)
+
+struct CameraVideoStreamFrameHeader_t
+{
+	EVRTrackedCameraFrameType eFrameType;
+
+	uint32_t nWidth;
+	uint32_t nHeight;
+	uint32_t nBytesPerPixel;
+
+	uint32_t nFrameSequence;
+
+	TrackedDevicePose_t standingTrackedDevicePose;
+};
+
+// Screenshot types
+typedef uint32_t ScreenshotHandle_t;
+
+static const uint32_t k_unScreenshotHandleInvalid = 0;
+
+#pragma pack(pop)
+
+// figure out how to import from the VR API dll
+#if defined(_WIN32)
+
+#ifdef VR_API_EXPORT
+#define VR_INTERFACE extern "C" __declspec(dllexport)
+#else
+#define VR_INTERFACE extern "C" __declspec(dllimport)
+#endif
+
+#elif defined(__GNUC__) || defined(COMPILER_GCC) || defined(__APPLE__)
+
+#ifdef VR_API_EXPORT
+#define VR_INTERFACE extern "C" __attribute__((visibility("default")))
+#else
+#define VR_INTERFACE extern "C"
+#endif
+
+#else
+#error "Unsupported Platform."
+#endif
+
+#if defined(_WIN32)
+#define VR_CALLTYPE __cdecl
+#else
+#define VR_CALLTYPE
+#endif
+
+}  // namespace vr
+
+#endif  // _INCLUDE_VRTYPES_H
+
+// vrannotation.h
+#ifdef API_GEN
+#define VR_CLANG_ATTR(ATTR) __attribute__((annotate(ATTR)))
+#else
+#define VR_CLANG_ATTR(ATTR)
+#endif
+
+#define VR_METHOD_DESC(DESC) VR_CLANG_ATTR("desc:" #DESC ";")
+#define VR_IGNOREATTR() VR_CLANG_ATTR("ignore")
+#define VR_OUT_STRUCT() VR_CLANG_ATTR("out_struct: ;")
+#define VR_OUT_STRING() VR_CLANG_ATTR("out_string: ;")
+#define VR_OUT_ARRAY_CALL(COUNTER, FUNCTION, PARAMS) VR_CLANG_ATTR("out_array_call:" #COUNTER "," #FUNCTION "," #PARAMS ";")
+#define VR_OUT_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR("out_array_count:" #COUNTER ";")
+#define VR_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR("array_count:" #COUNTER ";")
+#define VR_ARRAY_COUNT_D(COUNTER, DESC) VR_CLANG_ATTR("array_count:" #COUNTER ";desc:" #DESC)
+#define VR_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR("buffer_count:" #COUNTER ";")
+#define VR_OUT_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR("out_buffer_count:" #COUNTER ";")
+#define VR_OUT_STRING_COUNT(COUNTER) VR_CLANG_ATTR("out_string_count:" #COUNTER ";")
+
+// vrtrackedcameratypes.h
+#ifndef _VRTRACKEDCAMERATYPES_H
+#define _VRTRACKEDCAMERATYPES_H
+
+namespace vr
+{
+#pragma pack(push, 8)
+
+enum ECameraVideoStreamFormat
+{
+	CVS_FORMAT_UNKNOWN = 0,
+	CVS_FORMAT_RAW10 = 1,  // 10 bits per pixel
+	CVS_FORMAT_NV12 = 2,   // 12 bits per pixel
+	CVS_FORMAT_RGB24 = 3,  // 24 bits per pixel
+	CVS_MAX_FORMATS
+};
+
+enum ECameraCompatibilityMode
+{
+	CAMERA_COMPAT_MODE_BULK_DEFAULT = 0,
+	CAMERA_COMPAT_MODE_BULK_64K_DMA,
+	CAMERA_COMPAT_MODE_BULK_16K_DMA,
+	CAMERA_COMPAT_MODE_BULK_8K_DMA,
+	CAMERA_COMPAT_MODE_ISO_52FPS,
+	CAMERA_COMPAT_MODE_ISO_50FPS,
+	CAMERA_COMPAT_MODE_ISO_48FPS,
+	CAMERA_COMPAT_MODE_ISO_46FPS,
+	CAMERA_COMPAT_MODE_ISO_44FPS,
+	CAMERA_COMPAT_MODE_ISO_42FPS,
+	CAMERA_COMPAT_MODE_ISO_40FPS,
+	CAMERA_COMPAT_MODE_ISO_35FPS,
+	CAMERA_COMPAT_MODE_ISO_30FPS,
+	MAX_CAMERA_COMPAT_MODES
+};
+
+#ifdef _MSC_VER
+#define VR_CAMERA_DECL_ALIGN(x) __declspec(align(x))
+#else
+#define VR_CAMERA_DECL_ALIGN(x)  //
+#endif
+
+#define MAX_CAMERA_FRAME_SHARED_HANDLES 4
+
+VR_CAMERA_DECL_ALIGN(8)
+struct CameraVideoStreamFrame_t
+{
+	ECameraVideoStreamFormat m_nStreamFormat;
+
+	uint32_t m_nWidth;
+	uint32_t m_nHeight;
+
+	uint32_t m_nImageDataSize;  // Based on stream format, width, height
+
+	uint32_t m_nFrameSequence;  // Starts from 0 when stream starts.
+
+	uint32_t m_nBufferIndex;  // Identifies which buffer the image data is hosted
+	uint32_t m_nBufferCount;  // Total number of configured buffers
+
+	uint32_t m_nExposureTime;
+
+	uint32_t m_nISPFrameTimeStamp;  // Driver provided time stamp per driver centric time base
+	uint32_t m_nISPReferenceTimeStamp;
+	uint32_t m_nSyncCounter;
+
+	uint32_t m_nCamSyncEvents;
+	uint32_t m_nISPSyncEvents;
+
+	double m_flReferenceCamSyncTime;
+
+	double m_flFrameElapsedTime;  // Starts from 0 when stream starts. In seconds.
+	double m_flFrameDeliveryRate;
+
+	double m_flFrameCaptureTime_DriverAbsolute;    // In USB time, via AuxEvent
+	double m_flFrameCaptureTime_ServerRelative;    // In System time within the server
+	uint64_t m_nFrameCaptureTicks_ServerAbsolute;  // In system ticks within the server
+	double m_flFrameCaptureTime_ClientRelative;    // At the client, relative to when the frame was exposed/captured.
+
+	double m_flSyncMarkerError;
+
+	TrackedDevicePose_t m_StandingTrackedDevicePose;  // Supplied by HMD layer when used as a tracked camera
+
+	uint64_t m_pImageData;
+};
+
+#pragma pack(pop)
+
+}  // namespace vr
+
+#endif  // _VRTRACKEDCAMERATYPES_H
+// ivrsettings.h
+namespace vr
+{
+enum EVRSettingsError
+{
+	VRSettingsError_None = 0,
+	VRSettingsError_IPCFailed = 1,
+	VRSettingsError_WriteFailed = 2,
+	VRSettingsError_ReadFailed = 3,
+	VRSettingsError_JsonParseFailed = 4,
+	VRSettingsError_UnsetSettingHasNoDefault = 5,  // This will be returned if the setting does not appear in the appropriate default file and has not been set
+};
+
+// The maximum length of a settings key
+static const uint32_t k_unMaxSettingsKeyLength = 128;
+
+class IVRSettings
+{
+public:
+	virtual const char *GetSettingsErrorNameFromEnum(EVRSettingsError eError) = 0;
+
+	// Returns true if file sync occurred (force or settings dirty)
+	virtual bool Sync(bool bForce = false, EVRSettingsError *peError = nullptr) = 0;
+
+	virtual void SetBool(const char *pchSection, const char *pchSettingsKey, bool bValue, EVRSettingsError *peError = nullptr) = 0;
+	virtual void SetInt32(const char *pchSection, const char *pchSettingsKey, int32_t nValue, EVRSettingsError *peError = nullptr) = 0;
+	virtual void SetFloat(const char *pchSection, const char *pchSettingsKey, float flValue, EVRSettingsError *peError = nullptr) = 0;
+	virtual void SetString(const char *pchSection, const char *pchSettingsKey, const char *pchValue, EVRSettingsError *peError = nullptr) = 0;
+
+	// Users of the system need to provide a proper default in default.vrsettings in the resources/settings/ directory
+	// of either the runtime or the driver_xxx directory. Otherwise the default will be false, 0, 0.0 or ""
+	virtual bool GetBool(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+	virtual int32_t GetInt32(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+	virtual float GetFloat(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+	virtual void GetString(const char *pchSection, const char *pchSettingsKey, VR_OUT_STRING() char *pchValue, uint32_t unValueLen, EVRSettingsError *peError = nullptr) = 0;
+
+	virtual void RemoveSection(const char *pchSection, EVRSettingsError *peError = nullptr) = 0;
+	virtual void RemoveKeyInSection(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+};
+
+//-----------------------------------------------------------------------------
+static const char *const IVRSettings_Version = "IVRSettings_002";
+
+//-----------------------------------------------------------------------------
+// steamvr keys
+static const char *const k_pch_SteamVR_Section = "steamvr";
+static const char *const k_pch_SteamVR_RequireHmd_String = "requireHmd";
+static const char *const k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver";
+static const char *const k_pch_SteamVR_ForcedHmdKey_String = "forcedHmd";
+static const char *const k_pch_SteamVR_DisplayDebug_Bool = "displayDebug";
+static const char *const k_pch_SteamVR_DebugProcessPipe_String = "debugProcessPipe";
+static const char *const k_pch_SteamVR_DisplayDebugX_Int32 = "displayDebugX";
+static const char *const k_pch_SteamVR_DisplayDebugY_Int32 = "displayDebugY";
+static const char *const k_pch_SteamVR_SendSystemButtonToAllApps_Bool = "sendSystemButtonToAllApps";
+static const char *const k_pch_SteamVR_LogLevel_Int32 = "loglevel";
+static const char *const k_pch_SteamVR_IPD_Float = "ipd";
+static const char *const k_pch_SteamVR_Background_String = "background";
+static const char *const k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection";
+static const char *const k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight";
+static const char *const k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius";
+static const char *const k_pch_SteamVR_GridColor_String = "gridColor";
+static const char *const k_pch_SteamVR_PlayAreaColor_String = "playAreaColor";
+static const char *const k_pch_SteamVR_ShowStage_Bool = "showStage";
+static const char *const k_pch_SteamVR_ActivateMultipleDrivers_Bool = "activateMultipleDrivers";
+static const char *const k_pch_SteamVR_DirectMode_Bool = "directMode";
+static const char *const k_pch_SteamVR_DirectModeEdidVid_Int32 = "directModeEdidVid";
+static const char *const k_pch_SteamVR_DirectModeEdidPid_Int32 = "directModeEdidPid";
+static const char *const k_pch_SteamVR_UsingSpeakers_Bool = "usingSpeakers";
+static const char *const k_pch_SteamVR_SpeakersForwardYawOffsetDegrees_Float = "speakersForwardYawOffsetDegrees";
+static const char *const k_pch_SteamVR_BaseStationPowerManagement_Bool = "basestationPowerManagement";
+static const char *const k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses";
+static const char *const k_pch_SteamVR_SupersampleScale_Float = "supersampleScale";
+static const char *const k_pch_SteamVR_AllowAsyncReprojection_Bool = "allowAsyncReprojection";
+static const char *const k_pch_SteamVR_AllowReprojection_Bool = "allowInterleavedReprojection";
+static const char *const k_pch_SteamVR_ForceReprojection_Bool = "forceReprojection";
+static const char *const k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking";
+static const char *const k_pch_SteamVR_DefaultMirrorView_Int32 = "defaultMirrorView";
+static const char *const k_pch_SteamVR_ShowMirrorView_Bool = "showMirrorView";
+static const char *const k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry";
+static const char *const k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch";
+static const char *const k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch";
+static const char *const k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch";
+static const char *const k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard";
+static const char *const k_pch_SteamVR_EnableHomeApp = "enableHomeApp";
+static const char *const k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec";
+static const char *const k_pch_SteamVR_RetailDemo_Bool = "retailDemo";
+static const char *const k_pch_SteamVR_IpdOffset_Float = "ipdOffset";
+static const char *const k_pch_SteamVR_AllowSupersampleFiltering_Bool = "allowSupersampleFiltering";
+static const char *const k_pch_SteamVR_EnableLinuxVulkanAsync_Bool = "enableLinuxVulkanAsync";
+
+//-----------------------------------------------------------------------------
+// lighthouse keys
+static const char *const k_pch_Lighthouse_Section = "driver_lighthouse";
+static const char *const k_pch_Lighthouse_DisableIMU_Bool = "disableimu";
+static const char *const k_pch_Lighthouse_UseDisambiguation_String = "usedisambiguation";
+static const char *const k_pch_Lighthouse_DisambiguationDebug_Int32 = "disambiguationdebug";
+static const char *const k_pch_Lighthouse_PrimaryBasestation_Int32 = "primarybasestation";
+static const char *const k_pch_Lighthouse_DBHistory_Bool = "dbhistory";
+
+//-----------------------------------------------------------------------------
+// null keys
+static const char *const k_pch_Null_Section = "driver_null";
+static const char *const k_pch_Null_SerialNumber_String = "serialNumber";
+static const char *const k_pch_Null_ModelNumber_String = "modelNumber";
+static const char *const k_pch_Null_WindowX_Int32 = "windowX";
+static const char *const k_pch_Null_WindowY_Int32 = "windowY";
+static const char *const k_pch_Null_WindowWidth_Int32 = "windowWidth";
+static const char *const k_pch_Null_WindowHeight_Int32 = "windowHeight";
+static const char *const k_pch_Null_RenderWidth_Int32 = "renderWidth";
+static const char *const k_pch_Null_RenderHeight_Int32 = "renderHeight";
+static const char *const k_pch_Null_SecondsFromVsyncToPhotons_Float = "secondsFromVsyncToPhotons";
+static const char *const k_pch_Null_DisplayFrequency_Float = "displayFrequency";
+
+//-----------------------------------------------------------------------------
+// user interface keys
+static const char *const k_pch_UserInterface_Section = "userinterface";
+static const char *const k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop";
+static const char *const k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray";
+static const char *const k_pch_UserInterface_Screenshots_Bool = "screenshots";
+static const char *const k_pch_UserInterface_ScreenshotType_Int = "screenshotType";
+
+//-----------------------------------------------------------------------------
+// notification keys
+static const char *const k_pch_Notifications_Section = "notifications";
+static const char *const k_pch_Notifications_DoNotDisturb_Bool = "DoNotDisturb";
+
+//-----------------------------------------------------------------------------
+// keyboard keys
+static const char *const k_pch_Keyboard_Section = "keyboard";
+static const char *const k_pch_Keyboard_TutorialCompletions = "TutorialCompletions";
+static const char *const k_pch_Keyboard_ScaleX = "ScaleX";
+static const char *const k_pch_Keyboard_ScaleY = "ScaleY";
+static const char *const k_pch_Keyboard_OffsetLeftX = "OffsetLeftX";
+static const char *const k_pch_Keyboard_OffsetRightX = "OffsetRightX";
+static const char *const k_pch_Keyboard_OffsetY = "OffsetY";
+static const char *const k_pch_Keyboard_Smoothing = "Smoothing";
+
+//-----------------------------------------------------------------------------
+// perf keys
+static const char *const k_pch_Perf_Section = "perfcheck";
+static const char *const k_pch_Perf_HeuristicActive_Bool = "heuristicActive";
+static const char *const k_pch_Perf_NotifyInHMD_Bool = "warnInHMD";
+static const char *const k_pch_Perf_NotifyOnlyOnce_Bool = "warnOnlyOnce";
+static const char *const k_pch_Perf_AllowTimingStore_Bool = "allowTimingStore";
+static const char *const k_pch_Perf_SaveTimingsOnExit_Bool = "saveTimingsOnExit";
+static const char *const k_pch_Perf_TestData_Float = "perfTestData";
+static const char *const k_pch_Perf_LinuxGPUProfiling_Bool = "linuxGPUProfiling";
+
+//-----------------------------------------------------------------------------
+// collision bounds keys
+static const char *const k_pch_CollisionBounds_Section = "collisionBounds";
+static const char *const k_pch_CollisionBounds_Style_Int32 = "CollisionBoundsStyle";
+static const char *const k_pch_CollisionBounds_GroundPerimeterOn_Bool = "CollisionBoundsGroundPerimeterOn";
+static const char *const k_pch_CollisionBounds_CenterMarkerOn_Bool = "CollisionBoundsCenterMarkerOn";
+static const char *const k_pch_CollisionBounds_PlaySpaceOn_Bool = "CollisionBoundsPlaySpaceOn";
+static const char *const k_pch_CollisionBounds_FadeDistance_Float = "CollisionBoundsFadeDistance";
+static const char *const k_pch_CollisionBounds_ColorGammaR_Int32 = "CollisionBoundsColorGammaR";
+static const char *const k_pch_CollisionBounds_ColorGammaG_Int32 = "CollisionBoundsColorGammaG";
+static const char *const k_pch_CollisionBounds_ColorGammaB_Int32 = "CollisionBoundsColorGammaB";
+static const char *const k_pch_CollisionBounds_ColorGammaA_Int32 = "CollisionBoundsColorGammaA";
+
+//-----------------------------------------------------------------------------
+// camera keys
+static const char *const k_pch_Camera_Section = "camera";
+static const char *const k_pch_Camera_EnableCamera_Bool = "enableCamera";
+static const char *const k_pch_Camera_EnableCameraInDashboard_Bool = "enableCameraInDashboard";
+static const char *const k_pch_Camera_EnableCameraForCollisionBounds_Bool = "enableCameraForCollisionBounds";
+static const char *const k_pch_Camera_EnableCameraForRoomView_Bool = "enableCameraForRoomView";
+static const char *const k_pch_Camera_BoundsColorGammaR_Int32 = "cameraBoundsColorGammaR";
+static const char *const k_pch_Camera_BoundsColorGammaG_Int32 = "cameraBoundsColorGammaG";
+static const char *const k_pch_Camera_BoundsColorGammaB_Int32 = "cameraBoundsColorGammaB";
+static const char *const k_pch_Camera_BoundsColorGammaA_Int32 = "cameraBoundsColorGammaA";
+static const char *const k_pch_Camera_BoundsStrength_Int32 = "cameraBoundsStrength";
+
+//-----------------------------------------------------------------------------
+// audio keys
+static const char *const k_pch_audio_Section = "audio";
+static const char *const k_pch_audio_OnPlaybackDevice_String = "onPlaybackDevice";
+static const char *const k_pch_audio_OnRecordDevice_String = "onRecordDevice";
+static const char *const k_pch_audio_OnPlaybackMirrorDevice_String = "onPlaybackMirrorDevice";
+static const char *const k_pch_audio_OffPlaybackDevice_String = "offPlaybackDevice";
+static const char *const k_pch_audio_OffRecordDevice_String = "offRecordDevice";
+static const char *const k_pch_audio_VIVEHDMIGain = "viveHDMIGain";
+
+//-----------------------------------------------------------------------------
+// power management keys
+static const char *const k_pch_Power_Section = "power";
+static const char *const k_pch_Power_PowerOffOnExit_Bool = "powerOffOnExit";
+static const char *const k_pch_Power_TurnOffScreensTimeout_Float = "turnOffScreensTimeout";
+static const char *const k_pch_Power_TurnOffControllersTimeout_Float = "turnOffControllersTimeout";
+static const char *const k_pch_Power_ReturnToWatchdogTimeout_Float = "returnToWatchdogTimeout";
+static const char *const k_pch_Power_AutoLaunchSteamVROnButtonPress = "autoLaunchSteamVROnButtonPress";
+static const char *const k_pch_Power_PauseCompositorOnStandby_Bool = "pauseCompositorOnStandby";
+
+//-----------------------------------------------------------------------------
+// dashboard keys
+static const char *const k_pch_Dashboard_Section = "dashboard";
+static const char *const k_pch_Dashboard_EnableDashboard_Bool = "enableDashboard";
+static const char *const k_pch_Dashboard_ArcadeMode_Bool = "arcadeMode";
+
+//-----------------------------------------------------------------------------
+// model skin keys
+static const char *const k_pch_modelskin_Section = "modelskins";
+
+//-----------------------------------------------------------------------------
+// driver keys - These could be checked in any driver_<name> section
+static const char *const k_pch_Driver_Enable_Bool = "enable";
+
+}  // namespace vr
+
+// iservertrackeddevicedriver.h
+namespace vr
+{
+struct DriverPoseQuaternion_t
+{
+	double w, x, y, z;
+};
+
+struct DriverPose_t
+{
+	/* Time offset of this pose, in seconds from the actual time of the pose,
+	 * relative to the time of the PoseUpdated() call made by the driver.
+	 */
+	double poseTimeOffset;
+
+	/* Generally, the pose maintained by a driver
+	 * is in an inertial coordinate system different
+	 * from the world system of x+ right, y+ up, z+ back.
+	 * Also, the driver is not usually tracking the "head" position,
+	 * but instead an internal IMU or another reference point in the HMD.
+	 * The following two transforms transform positions and orientations
+	 * to app world space from driver world space,
+	 * and to HMD head space from driver local body space. 
+	 *
+	 * We maintain the driver pose state in its internal coordinate system,
+	 * so we can do the pose prediction math without having to
+	 * use angular acceleration.  A driver's angular acceleration is generally not measured,
+	 * and is instead calculated from successive samples of angular velocity.
+	 * This leads to a noisy angular acceleration values, which are also
+	 * lagged due to the filtering required to reduce noise to an acceptable level.
+	 */
+	vr::HmdQuaternion_t qWorldFromDriverRotation;
+	double vecWorldFromDriverTranslation[3];
+
+	vr::HmdQuaternion_t qDriverFromHeadRotation;
+	double vecDriverFromHeadTranslation[3];
+
+	/* State of driver pose, in meters and radians. */
+	/* Position of the driver tracking reference in driver world space
+	* +[0] (x) is right
+	* +[1] (y) is up
+	* -[2] (z) is forward
+	*/
+	double vecPosition[3];
+
+	/* Velocity of the pose in meters/second */
+	double vecVelocity[3];
+
+	/* Acceleration of the pose in meters/second */
+	double vecAcceleration[3];
+
+	/* Orientation of the tracker, represented as a quaternion */
+	vr::HmdQuaternion_t qRotation;
+
+	/* Angular velocity of the pose in axis-angle 
+	* representation. The direction is the angle of
+	* rotation and the magnitude is the angle around
+	* that axis in radians/second. */
+	double vecAngularVelocity[3];
+
+	/* Angular acceleration of the pose in axis-angle 
+	* representation. The direction is the angle of
+	* rotation and the magnitude is the angle around
+	* that axis in radians/second^2. */
+	double vecAngularAcceleration[3];
+
+	ETrackingResult result;
+
+	bool poseIsValid;
+	bool willDriftInYaw;
+	bool shouldApplyHeadModel;
+	bool deviceIsConnected;
+};
+
+// ----------------------------------------------------------------------------------------------
+// Purpose: Represents a single tracked device in a driver
+// ----------------------------------------------------------------------------------------------
+class ITrackedDeviceServerDriver
+{
+public:
+	// ------------------------------------
+	// Management Methods
+	// ------------------------------------
+	/** This is called before an HMD is returned to the application. It will always be
+	* called before any display or tracking methods. Memory and processor use by the
+	* ITrackedDeviceServerDriver object should be kept to a minimum until it is activated.
+	* The pose listener is guaranteed to be valid until Deactivate is called, but
+	* should not be used after that point. */
+	virtual EVRInitError Activate(uint32_t unObjectId) = 0;
+
+	/** This is called when The VR system is switching from this Hmd being the active display
+	* to another Hmd being the active display. The driver should clean whatever memory
+	* and thread use it can when it is deactivated */
+	virtual void Deactivate() = 0;
+
+	/** Handles a request from the system to put this device into standby mode. What that means is defined per-device. */
+	virtual void EnterStandby() = 0;
+
+	/** Requests a component interface of the driver for device-specific functionality. The driver should return NULL
+	* if the requested interface or version is not supported. */
+	virtual void *GetComponent(const char *pchComponentNameAndVersion) = 0;
+
+	/** A VR Client has made this debug request of the driver. The set of valid requests is entirely
+	* up to the driver and the client to figure out, as is the format of the response. Responses that
+	* exceed the length of the supplied buffer should be truncated and null terminated */
+	virtual void DebugRequest(const char *pchRequest, char *pchResponseBuffer, uint32_t unResponseBufferSize) = 0;
+
+	// ------------------------------------
+	// Tracking Methods
+	// ------------------------------------
+	virtual DriverPose_t GetPose() = 0;
+};
+
+static const char *ITrackedDeviceServerDriver_Version = "ITrackedDeviceServerDriver_005";
+
+}  // namespace vr
+// ivrdisplaycomponent.h
+namespace vr
+{
+// ----------------------------------------------------------------------------------------------
+// Purpose: The display component on a single tracked device
+// ----------------------------------------------------------------------------------------------
+class IVRDisplayComponent
+{
+public:
+	// ------------------------------------
+	// Display Methods
+	// ------------------------------------
+
+	/** Size and position that the window needs to be on the VR display. */
+	virtual void GetWindowBounds(int32_t *pnX, int32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight) = 0;
+
+	/** Returns true if the display is extending the desktop. */
+	virtual bool IsDisplayOnDesktop() = 0;
+
+	/** Returns true if the display is real and not a fictional display. */
+	virtual bool IsDisplayRealDisplay() = 0;
+
+	/** Suggested size for the intermediate render target that the distortion pulls from. */
+	virtual void GetRecommendedRenderTargetSize(uint32_t *pnWidth, uint32_t *pnHeight) = 0;
+
+	/** Gets the viewport in the frame buffer to draw the output of the distortion into */
+	virtual void GetEyeOutputViewport(EVREye eEye, uint32_t *pnX, uint32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight) = 0;
+
+	/** The components necessary to build your own projection matrix in case your
+		* application is doing something fancy like infinite Z */
+	virtual void GetProjectionRaw(EVREye eEye, float *pfLeft, float *pfRight, float *pfTop, float *pfBottom) = 0;
+
+	/** Returns the result of the distortion function for the specified eye and input UVs. UVs go from 0,0 in
+		* the upper left of that eye's viewport and 1,1 in the lower right of that eye's viewport. */
+	virtual DistortionCoordinates_t ComputeDistortion(EVREye eEye, float fU, float fV) = 0;
+};
+
+static const char *IVRDisplayComponent_Version = "IVRDisplayComponent_002";
+
+}  // namespace vr
+
+// ivrdriverdirectmodecomponent.h
+namespace vr
+{
+// ----------------------------------------------------------------------------------------------
+// Purpose: This component is used for drivers that implement direct mode entirely on their own
+//			without allowing the VR Compositor to own the window/device. Chances are you don't
+//			need to implement this component in your driver.
+// ----------------------------------------------------------------------------------------------
+class IVRDriverDirectModeComponent
+{
+public:
+	// -----------------------------------
+	// Direct mode methods
+	// -----------------------------------
+
+	/** Specific to Oculus compositor support, textures supplied must be created using this method. */
+	virtual void CreateSwapTextureSet(uint32_t unPid, uint32_t unFormat, uint32_t unWidth, uint32_t unHeight, vr::SharedTextureHandle_t (*pSharedTextureHandles)[3]) {}
+
+	/** Used to textures created using CreateSwapTextureSet.  Only one of the set's handles needs to be used to destroy the entire set. */
+	virtual void DestroySwapTextureSet(vr::SharedTextureHandle_t sharedTextureHandle) {}
+
+	/** Used to purge all texture sets for a given process. */
+	virtual void DestroyAllSwapTextureSets(uint32_t unPid) {}
+
+	/** After Present returns, calls this to get the next index to use for rendering. */
+	virtual void GetNextSwapTextureSetIndex(vr::SharedTextureHandle_t sharedTextureHandles[2], uint32_t (*pIndices)[2]) {}
+
+	/** Call once per layer to draw for this frame.  One shared texture handle per eye.  Textures must be created
+		* using CreateSwapTextureSet and should be alternated per frame.  Call Present once all layers have been submitted. */
+	virtual void SubmitLayer(vr::SharedTextureHandle_t sharedTextureHandles[2], const vr::VRTextureBounds_t (&bounds)[2], const vr::HmdMatrix34_t *pPose) {}
+
+	/** Submits queued layers for display. */
+	virtual void Present(vr::SharedTextureHandle_t syncTexture) {}
+};
+
+static const char *IVRDriverDirectModeComponent_Version = "IVRDriverDirectModeComponent_002";
+
+}  // namespace vr
+
+// ivrcontrollercomponent.h
+namespace vr
+{
+// ----------------------------------------------------------------------------------------------
+// Purpose: Controller access on a single tracked device.
+// ----------------------------------------------------------------------------------------------
+class IVRControllerComponent
+{
+public:
+	// ------------------------------------
+	// Controller Methods
+	// ------------------------------------
+
+	/** Gets the current state of a controller. */
+	virtual VRControllerState_t GetControllerState() = 0;
+
+	/** Returns a uint64 property. If the property is not available this function will return 0. */
+	virtual bool TriggerHapticPulse(uint32_t unAxisId, uint16_t usPulseDurationMicroseconds) = 0;
+};
+
+static const char *IVRControllerComponent_Version = "IVRControllerComponent_001";
+
+}  // namespace vr
+// ivrcameracomponent.h
+namespace vr
+{
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+class ICameraVideoSinkCallback
+{
+public:
+	virtual void OnCameraVideoSinkCallback() = 0;
+};
+
+// ----------------------------------------------------------------------------------------------
+// Purpose: The camera on a single tracked device
+// ----------------------------------------------------------------------------------------------
+class IVRCameraComponent
+{
+public:
+	// ------------------------------------
+	// Camera Methods
+	// ------------------------------------
+	virtual bool GetCameraFrameDimensions(vr::ECameraVideoStreamFormat nVideoStreamFormat, uint32_t *pWidth, uint32_t *pHeight) = 0;
+	virtual bool GetCameraFrameBufferingRequirements(int *pDefaultFrameQueueSize, uint32_t *pFrameBufferDataSize) = 0;
+	virtual bool SetCameraFrameBuffering(int nFrameBufferCount, void **ppFrameBuffers, uint32_t nFrameBufferDataSize) = 0;
+	virtual bool SetCameraVideoStreamFormat(vr::ECameraVideoStreamFormat nVideoStreamFormat) = 0;
+	virtual vr::ECameraVideoStreamFormat GetCameraVideoStreamFormat() = 0;
+	virtual bool StartVideoStream() = 0;
+	virtual void StopVideoStream() = 0;
+	virtual bool IsVideoStreamActive(bool *pbPaused, float *pflElapsedTime) = 0;
+	virtual const vr::CameraVideoStreamFrame_t *GetVideoStreamFrame() = 0;
+	virtual void ReleaseVideoStreamFrame(const vr::CameraVideoStreamFrame_t *pFrameImage) = 0;
+	virtual bool SetAutoExposure(bool bEnable) = 0;
+	virtual bool PauseVideoStream() = 0;
+	virtual bool ResumeVideoStream() = 0;
+	virtual bool GetCameraDistortion(float flInputU, float flInputV, float *pflOutputU, float *pflOutputV) = 0;
+	virtual bool GetCameraProjection(vr::EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, vr::HmdMatrix44_t *pProjection) = 0;
+	virtual bool SetFrameRate(int nISPFrameRate, int nSensorFrameRate) = 0;
+	virtual bool SetCameraVideoSinkCallback(vr::ICameraVideoSinkCallback *pCameraVideoSinkCallback) = 0;
+	virtual bool GetCameraCompatibilityMode(vr::ECameraCompatibilityMode *pCameraCompatibilityMode) = 0;
+	virtual bool SetCameraCompatibilityMode(vr::ECameraCompatibilityMode nCameraCompatibilityMode) = 0;
+	virtual bool GetCameraFrameBounds(vr::EVRTrackedCameraFrameType eFrameType, uint32_t *pLeft, uint32_t *pTop, uint32_t *pWidth, uint32_t *pHeight) = 0;
+	virtual bool GetCameraIntrinsics(vr::EVRTrackedCameraFrameType eFrameType, HmdVector2_t *pFocalLength, HmdVector2_t *pCenter) = 0;
+};
+
+static const char *IVRCameraComponent_Version = "IVRCameraComponent_002";
+}  // namespace vr
+// itrackeddevicedriverprovider.h
+namespace vr
+{
+class ITrackedDeviceServerDriver;
+struct TrackedDeviceDriverInfo_t;
+struct DriverPose_t;
+typedef PropertyContainerHandle_t DriverHandle_t;
+
+/** This interface is provided by vrserver to allow the driver to notify 
+* the system when something changes about a device. These changes must
+* not change the serial number or class of the device because those values
+* are permanently associated with the device's index. */
+class IVRDriverContext
+{
+public:
+	/** Returns the requested interface. If the interface was not available it will return NULL and fill
+	* out the error. */
+	virtual void *GetGenericInterface(const char *pchInterfaceVersion, EVRInitError *peError = nullptr) = 0;
+
+	/** Returns the property container handle for this driver */
+	virtual DriverHandle_t GetDriverHandle() = 0;
+};
+
+/** This interface must be implemented in each driver. It will be loaded in vrserver.exe */
+class IServerTrackedDeviceProvider
+{
+public:
+	/** initializes the driver. This will be called before any other methods are called.
+	* If Init returns anything other than VRInitError_None the driver DLL will be unloaded.
+	*
+	* pDriverHost will never be NULL, and will always be a pointer to a IServerDriverHost interface
+	*
+	* pchUserDriverConfigDir - The absolute path of the directory where the driver should store user
+	*	config files.
+	* pchDriverInstallDir - The absolute path of the root directory for the driver.
+	*/
+	virtual EVRInitError Init(IVRDriverContext *pDriverContext) = 0;
+
+	/** cleans up the driver right before it is unloaded */
+	virtual void Cleanup() = 0;
+
+	/** Returns the version of the ITrackedDeviceServerDriver interface used by this driver */
+	virtual const char *const *GetInterfaceVersions() = 0;
+
+	/** Allows the driver do to some work in the main loop of the server. */
+	virtual void RunFrame() = 0;
+
+	// ------------  Power State Functions ----------------------- //
+
+	/** Returns true if the driver wants to block Standby mode. */
+	virtual bool ShouldBlockStandbyMode() = 0;
+
+	/** Called when the system is entering Standby mode. The driver should switch itself into whatever sort of low-power
+	* state it has. */
+	virtual void EnterStandby() = 0;
+
+	/** Called when the system is leaving Standby mode. The driver should switch itself back to
+	full operation. */
+	virtual void LeaveStandby() = 0;
+};
+
+static const char *IServerTrackedDeviceProvider_Version = "IServerTrackedDeviceProvider_004";
+
+/** This interface must be implemented in each driver. It will be loaded in vrclient.dll */
+class IVRWatchdogProvider
+{
+public:
+	/** initializes the driver in watchdog mode. */
+	virtual EVRInitError Init(IVRDriverContext *pDriverContext) = 0;
+
+	/** cleans up the driver right before it is unloaded */
+	virtual void Cleanup() = 0;
+};
+
+static const char *IVRWatchdogProvider_Version = "IVRWatchdogProvider_001";
+
+}  // namespace vr
+// ivrproperties.h
+#include <string>
+
+namespace vr
+{
+enum EPropertyWriteType
+{
+	PropertyWrite_Set = 0,
+	PropertyWrite_Erase = 1,
+	PropertyWrite_SetError = 2
+};
+
+struct PropertyWrite_t
+{
+	ETrackedDeviceProperty prop;
+	EPropertyWriteType writeType;
+	ETrackedPropertyError eSetError;
+	void *pvBuffer;
+	uint32_t unBufferSize;
+	PropertyTypeTag_t unTag;
+	ETrackedPropertyError eError;
+};
+
+struct PropertyRead_t
+{
+	ETrackedDeviceProperty prop;
+	void *pvBuffer;
+	uint32_t unBufferSize;
+	PropertyTypeTag_t unTag;
+	uint32_t unRequiredBufferSize;
+	ETrackedPropertyError eError;
+};
+
+class IVRProperties
+{
+public:
+	/** Reads a set of properties atomically. See the PropertyReadBatch_t struct for more information. */
+	virtual ETrackedPropertyError ReadPropertyBatch(PropertyContainerHandle_t ulContainerHandle, PropertyRead_t *pBatch, uint32_t unBatchEntryCount) = 0;
+
+	/** Writes a set of properties atomically. See the PropertyWriteBatch_t struct for more information. */
+	virtual ETrackedPropertyError WritePropertyBatch(PropertyContainerHandle_t ulContainerHandle, PropertyWrite_t *pBatch, uint32_t unBatchEntryCount) = 0;
+
+	/** returns a string that corresponds with the specified property error. The string will be the name
+	* of the error enum value for all valid error codes */
+	virtual const char *GetPropErrorNameFromEnum(ETrackedPropertyError error) = 0;
+
+	/** Returns a container handle given a tracked device index */
+	virtual PropertyContainerHandle_t TrackedDeviceToPropertyContainer(TrackedDeviceIndex_t nDevice) = 0;
+};
+
+static const char *const IVRProperties_Version = "IVRProperties_001";
+
+class CVRPropertyHelpers
+{
+public:
+	CVRPropertyHelpers(IVRProperties *pProperties) : m_pProperties(pProperties) {}
+
+	/** Returns a scaler property. If the device index is not valid or the property value type does not match,
+	* this function will return false. */
+	bool GetBoolProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L);
+	float GetFloatProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L);
+	int32_t GetInt32Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L);
+	uint64_t GetUint64Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L);
+
+	/** Returns a single typed property. If the device index is not valid or the property is not a string type this function will
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters. */
+	uint32_t GetProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, VR_OUT_STRING() void *pvBuffer, uint32_t unBufferSize, PropertyTypeTag_t *punTag, ETrackedPropertyError *pError = 0L);
+
+	/** Returns a string property. If the device index is not valid or the property is not a string type this function will
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters. */
+	uint32_t GetStringProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError = 0L);
+
+	/** Returns a string property as a std::string. If the device index is not valid or the property is not a string type this function will
+	* return an empty string. */
+	std::string GetStringProperty(vr::PropertyContainerHandle_t ulContainer, vr::ETrackedDeviceProperty prop, vr::ETrackedPropertyError *peError = nullptr);
+
+	/** Sets a scaler property. The new value will be returned on any subsequent call to get this property in any process. */
+	ETrackedPropertyError SetBoolProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, bool bNewValue);
+	ETrackedPropertyError SetFloatProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, float fNewValue);
+	ETrackedPropertyError SetInt32Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, int32_t nNewValue);
+	ETrackedPropertyError SetUint64Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, uint64_t ulNewValue);
+
+	/** Sets a string property. The new value will be returned on any subsequent call to get this property in any process. */
+	ETrackedPropertyError SetStringProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, const char *pchNewValue);
+
+	/** Sets a single typed property. The new value will be returned on any subsequent call to get this property in any process. */
+	ETrackedPropertyError SetProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, void *pvNewValue, uint32_t unNewValueSize, PropertyTypeTag_t unTag);
+
+	/** Sets the error return value for a property. This value will be returned on all subsequent requests to get the property */
+	ETrackedPropertyError SetPropertyError(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError eError);
+
+	/** Clears any value or error set for the property. */
+	ETrackedPropertyError EraseProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop);
+
+	/* Turns a device index into a property container handle. */
+	PropertyContainerHandle_t TrackedDeviceToPropertyContainer(TrackedDeviceIndex_t nDevice) { return m_pProperties->TrackedDeviceToPropertyContainer(nDevice); }
+
+private:
+	template <typename T>
+	T GetPropertyHelper(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError, T bDefault, PropertyTypeTag_t unTypeTag);
+
+	IVRProperties *m_pProperties;
+};
+
+inline uint32_t CVRPropertyHelpers::GetProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, VR_OUT_STRING() void *pvBuffer, uint32_t unBufferSize, PropertyTypeTag_t *punTag, ETrackedPropertyError *pError)
+{
+	PropertyRead_t batch;
+	batch.prop = prop;
+	batch.pvBuffer = pvBuffer;
+	batch.unBufferSize = unBufferSize;
+
+	m_pProperties->ReadPropertyBatch(ulContainerHandle, &batch, 1);
+
+	if (pError)
+	{
+		*pError = batch.eError;
+	}
+
+	if (punTag)
+	{
+		*punTag = batch.unTag;
+	}
+
+	return batch.unRequiredBufferSize;
+}
+
+/** Sets a single typed property. The new value will be returned on any subsequent call to get this property in any process. */
+inline ETrackedPropertyError CVRPropertyHelpers::SetProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, void *pvNewValue, uint32_t unNewValueSize, PropertyTypeTag_t unTag)
+{
+	PropertyWrite_t batch;
+	batch.writeType = PropertyWrite_Set;
+	batch.prop = prop;
+	batch.pvBuffer = pvNewValue;
+	batch.unBufferSize = unNewValueSize;
+	batch.unTag = unTag;
+
+	m_pProperties->WritePropertyBatch(ulContainerHandle, &batch, 1);
+
+	return batch.eError;
+}
+
+/** Returns a string property. If the device index is not valid or the property is not a string type this function will
+* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+* null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters. */
+inline uint32_t CVRPropertyHelpers::GetStringProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError)
+{
+	PropertyTypeTag_t unTag;
+	ETrackedPropertyError error;
+	uint32_t unRequiredSize = GetProperty(ulContainerHandle, prop, pchValue, unBufferSize, &unTag, &error);
+	if (unTag != k_unStringPropertyTag && error == TrackedProp_Success)
+	{
+		error = TrackedProp_WrongDataType;
+	}
+
+	if (pError)
+	{
+		*pError = error;
+	}
+
+	if (error != TrackedProp_Success)
+	{
+		if (pchValue && unBufferSize)
+		{
+			*pchValue = '\0';
+		}
+	}
+
+	return unRequiredSize;
+}
+
+/** Returns a string property as a std::string. If the device index is not valid or the property is not a string type this function will
+* return an empty string. */
+inline std::string CVRPropertyHelpers::GetStringProperty(vr::PropertyContainerHandle_t ulContainer, vr::ETrackedDeviceProperty prop, vr::ETrackedPropertyError *peError)
+{
+	char buf[1024];
+	vr::ETrackedPropertyError err;
+	uint32_t unRequiredBufferLen = GetStringProperty(ulContainer, prop, buf, sizeof(buf), &err);
+
+	std::string sResult;
+
+	if (err == TrackedProp_Success)
+	{
+		sResult = buf;
+	}
+	else if (err == TrackedProp_BufferTooSmall)
+	{
+		char *pchBuffer = new char[unRequiredBufferLen];
+		unRequiredBufferLen = GetStringProperty(ulContainer, prop, pchBuffer, unRequiredBufferLen, &err);
+		sResult = pchBuffer;
+		delete[] pchBuffer;
+	}
+
+	if (peError)
+	{
+		*peError = err;
+	}
+
+	return sResult;
+}
+
+/** Sets a string property. The new value will be returned on any subsequent call to get this property in any process. */
+inline ETrackedPropertyError CVRPropertyHelpers::SetStringProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, const char *pchNewValue)
+{
+	if (!pchNewValue)
+		return TrackedProp_InvalidOperation;
+
+	// this is strlen without the dependency on string.h
+	const char *pchCurr = pchNewValue;
+	while (*pchCurr)
+	{
+		pchCurr++;
+	}
+
+	return SetProperty(ulContainerHandle, prop, (void *)pchNewValue, (uint32_t)(pchCurr - pchNewValue) + 1, k_unStringPropertyTag);
+}
+
+template <typename T>
+inline T CVRPropertyHelpers::GetPropertyHelper(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError, T bDefault, PropertyTypeTag_t unTypeTag)
+{
+	T bValue;
+	ETrackedPropertyError eError;
+	PropertyTypeTag_t unReadTag;
+	GetProperty(ulContainerHandle, prop, &bValue, sizeof(bValue), &unReadTag, &eError);
+	if (unReadTag != unTypeTag && eError == TrackedProp_Success)
+	{
+		eError = TrackedProp_WrongDataType;
+	};
+
+	if (pError)
+		*pError = eError;
+	if (eError != TrackedProp_Success)
+	{
+		return bDefault;
+	}
+	else
+	{
+		return bValue;
+	}
+}
+
+inline bool CVRPropertyHelpers::GetBoolProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError)
+{
+	return GetPropertyHelper<bool>(ulContainerHandle, prop, pError, false, k_unBoolPropertyTag);
+}
+
+inline float CVRPropertyHelpers::GetFloatProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError)
+{
+	return GetPropertyHelper<float>(ulContainerHandle, prop, pError, 0.f, k_unFloatPropertyTag);
+}
+
+inline int32_t CVRPropertyHelpers::GetInt32Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError)
+{
+	return GetPropertyHelper<int32_t>(ulContainerHandle, prop, pError, 0, k_unInt32PropertyTag);
+}
+
+inline uint64_t CVRPropertyHelpers::GetUint64Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError)
+{
+	return GetPropertyHelper<uint64_t>(ulContainerHandle, prop, pError, 0, k_unUint64PropertyTag);
+}
+
+inline ETrackedPropertyError CVRPropertyHelpers::SetBoolProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, bool bNewValue)
+{
+	return SetProperty(ulContainerHandle, prop, &bNewValue, sizeof(bNewValue), k_unBoolPropertyTag);
+}
+
+inline ETrackedPropertyError CVRPropertyHelpers::SetFloatProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, float fNewValue)
+{
+	return SetProperty(ulContainerHandle, prop, &fNewValue, sizeof(fNewValue), k_unFloatPropertyTag);
+}
+
+inline ETrackedPropertyError CVRPropertyHelpers::SetInt32Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, int32_t nNewValue)
+{
+	return SetProperty(ulContainerHandle, prop, &nNewValue, sizeof(nNewValue), k_unInt32PropertyTag);
+}
+
+inline ETrackedPropertyError CVRPropertyHelpers::SetUint64Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, uint64_t ulNewValue)
+{
+	return SetProperty(ulContainerHandle, prop, &ulNewValue, sizeof(ulNewValue), k_unUint64PropertyTag);
+}
+
+/** Sets the error return value for a property. This value will be returned on all subsequent requests to get the property */
+inline ETrackedPropertyError CVRPropertyHelpers::SetPropertyError(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError eError)
+{
+	PropertyWrite_t batch;
+	batch.writeType = PropertyWrite_SetError;
+	batch.prop = prop;
+	batch.eSetError = eError;
+
+	m_pProperties->WritePropertyBatch(ulContainerHandle, &batch, 1);
+
+	return batch.eError;
+}
+
+/** Clears any value or error set for the property. */
+inline ETrackedPropertyError CVRPropertyHelpers::EraseProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop)
+{
+	PropertyWrite_t batch;
+	batch.writeType = PropertyWrite_Erase;
+	batch.prop = prop;
+
+	m_pProperties->WritePropertyBatch(ulContainerHandle, &batch, 1);
+
+	return batch.eError;
+}
+
+}  // namespace vr
+
+// ivrdriverlog.h
+namespace vr
+{
+class IVRDriverLog
+{
+public:
+	/** Writes a log message to the log file prefixed with the driver name */
+	virtual void Log(const char *pchLogMessage) = 0;
+};
+
+static const char *IVRDriverLog_Version = "IVRDriverLog_001";
+
+}  // namespace vr
+// ivrserverdriverhost.h
+namespace vr
+{
+class ITrackedDeviceServerDriver;
+struct TrackedDeviceDriverInfo_t;
+struct DriverPose_t;
+
+/** This interface is provided by vrserver to allow the driver to notify 
+* the system when something changes about a device. These changes must
+* not change the serial number or class of the device because those values
+* are permanently associated with the device's index. */
+class IVRServerDriverHost
+{
+public:
+	/** Notifies the server that a tracked device has been added. If this function returns true
+	* the server will call Activate on the device. If it returns false some kind of error
+	* has occurred and the device will not be activated. */
+	virtual bool TrackedDeviceAdded(const char *pchDeviceSerialNumber, ETrackedDeviceClass eDeviceClass, ITrackedDeviceServerDriver *pDriver) = 0;
+
+	/** Notifies the server that a tracked device's pose has been updated */
+	virtual void TrackedDevicePoseUpdated(uint32_t unWhichDevice, const DriverPose_t &newPose, uint32_t unPoseStructSize) = 0;
+
+	/** Notifies the server that vsync has occurred on the the display attached to the device. This is
+	* only permitted on devices of the HMD class. */
+	virtual void VsyncEvent(double vsyncTimeOffsetSeconds) = 0;
+
+	/** notifies the server that the button was pressed */
+	virtual void TrackedDeviceButtonPressed(uint32_t unWhichDevice, EVRButtonId eButtonId, double eventTimeOffset) = 0;
+
+	/** notifies the server that the button was unpressed */
+	virtual void TrackedDeviceButtonUnpressed(uint32_t unWhichDevice, EVRButtonId eButtonId, double eventTimeOffset) = 0;
+
+	/** notifies the server that the button was pressed */
+	virtual void TrackedDeviceButtonTouched(uint32_t unWhichDevice, EVRButtonId eButtonId, double eventTimeOffset) = 0;
+
+	/** notifies the server that the button was unpressed */
+	virtual void TrackedDeviceButtonUntouched(uint32_t unWhichDevice, EVRButtonId eButtonId, double eventTimeOffset) = 0;
+
+	/** notifies the server than a controller axis changed */
+	virtual void TrackedDeviceAxisUpdated(uint32_t unWhichDevice, uint32_t unWhichAxis, const VRControllerAxis_t &axisState) = 0;
+
+	/** Notifies the server that the proximity sensor on the specified device  */
+	virtual void ProximitySensorState(uint32_t unWhichDevice, bool bProximitySensorTriggered) = 0;
+
+	/** Sends a vendor specific event (VREvent_VendorSpecific_Reserved_Start..VREvent_VendorSpecific_Reserved_End */
+	virtual void VendorSpecificEvent(uint32_t unWhichDevice, vr::EVREventType eventType, const VREvent_Data_t &eventData, double eventTimeOffset) = 0;
+
+	/** Returns true if SteamVR is exiting */
+	virtual bool IsExiting() = 0;
+
+	/** Returns true and fills the event with the next event on the queue if there is one. If there are no events
+	* this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct */
+	virtual bool PollNextEvent(VREvent_t *pEvent, uint32_t uncbVREvent) = 0;
+
+	/** Provides access to device poses for drivers.  Poses are in their "raw" tracking space which is uniquely
+	* defined by each driver providing poses for its devices.  It is up to clients of this function to correlate
+	* poses across different drivers.  Poses are indexed by their device id, and their associated driver and
+	* other properties can be looked up via IVRProperties. */
+	virtual void GetRawTrackedDevicePoses(float fPredictedSecondsFromNow, TrackedDevicePose_t *pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = 0;
+
+	/** Notifies the server that a tracked device's display component transforms have been updated. */
+	virtual void TrackedDeviceDisplayTransformUpdated(uint32_t unWhichDevice, HmdMatrix34_t eyeToHeadLeft, HmdMatrix34_t eyeToHeadRight) = 0;
+};
+
+static const char *IVRServerDriverHost_Version = "IVRServerDriverHost_004";
+
+}  // namespace vr
+
+// ivrhiddenarea.h
+namespace vr
+{
+class CVRHiddenAreaHelpers
+{
+public:
+	CVRHiddenAreaHelpers(IVRProperties *pProperties) : m_pProperties(pProperties) {}
+
+	/** Stores a hidden area mesh in a property */
+	ETrackedPropertyError SetHiddenArea(EVREye eEye, EHiddenAreaMeshType type, HmdVector2_t *pVerts, uint32_t unVertCount);
+
+	/** retrieves a hidden area mesh from a property. Returns the vert count read out of the property.  */
+	uint32_t GetHiddenArea(EVREye eEye, EHiddenAreaMeshType type, HmdVector2_t *pVerts, uint32_t unVertCount, ETrackedPropertyError *peError);
+
+private:
+	ETrackedDeviceProperty GetPropertyEnum(EVREye eEye, EHiddenAreaMeshType type)
+	{
+		return (ETrackedDeviceProperty)(Prop_DisplayHiddenArea_Binary_Start + ((int)type * 2) + (int)eEye);
+	}
+
+	IVRProperties *m_pProperties;
+};
+
+inline ETrackedPropertyError CVRHiddenAreaHelpers::SetHiddenArea(EVREye eEye, EHiddenAreaMeshType type, HmdVector2_t *pVerts, uint32_t unVertCount)
+{
+	ETrackedDeviceProperty prop = GetPropertyEnum(eEye, type);
+	CVRPropertyHelpers propHelpers(m_pProperties);
+	return propHelpers.SetProperty(propHelpers.TrackedDeviceToPropertyContainer(k_unTrackedDeviceIndex_Hmd), prop, pVerts, sizeof(HmdVector2_t) * unVertCount, k_unHiddenAreaPropertyTag);
+}
+
+inline uint32_t CVRHiddenAreaHelpers::GetHiddenArea(EVREye eEye, EHiddenAreaMeshType type, HmdVector2_t *pVerts, uint32_t unVertCount, ETrackedPropertyError *peError)
+{
+	ETrackedDeviceProperty prop = GetPropertyEnum(eEye, type);
+	CVRPropertyHelpers propHelpers(m_pProperties);
+	ETrackedPropertyError propError;
+	PropertyTypeTag_t unTag;
+	uint32_t unBytesNeeded = propHelpers.GetProperty(propHelpers.TrackedDeviceToPropertyContainer(k_unTrackedDeviceIndex_Hmd), prop, pVerts, sizeof(HmdVector2_t) * unVertCount, &unTag, &propError);
+	if (propError == TrackedProp_Success && unTag != k_unHiddenAreaPropertyTag)
+	{
+		propError = TrackedProp_WrongDataType;
+		unBytesNeeded = 0;
+	}
+
+	if (peError)
+	{
+		*peError = propError;
+	}
+
+	return unBytesNeeded / sizeof(HmdVector2_t);
+}
+
+}  // namespace vr
+// ivrwatchdoghost.h
+namespace vr
+{
+/** This interface is provided by vrclient to allow the driver to make everything wake up */
+class IVRWatchdogHost
+{
+public:
+	/** Client drivers in watchdog mode should call this when they have received a signal from hardware that should
+	* cause SteamVR to start */
+	virtual void WatchdogWakeUp() = 0;
+};
+
+static const char *IVRWatchdogHost_Version = "IVRWatchdogHost_001";
+
+};  // namespace vr
+
+// ivrvirtualdisplay.h
+namespace vr
+{
+// ----------------------------------------------------------------------------------------------
+// Purpose: This component is used for drivers that implement a virtual display (e.g. wireless).
+// ----------------------------------------------------------------------------------------------
+class IVRVirtualDisplay
+{
+public:
+	/** Submits final backbuffer for display. */
+	virtual void Present(vr::SharedTextureHandle_t backbufferTextureHandle) = 0;
+
+	/** Block until the last presented buffer start scanning out. */
+	virtual void WaitForPresent() = 0;
+
+	/** Provides timing data for synchronizing with display. */
+	virtual bool GetTimeSinceLastVsync(float *pfSecondsSinceLastVsync, uint64_t *pulFrameCounter) = 0;
+};
+
+static const char *IVRVirtualDisplay_Version = "IVRVirtualDisplay_001";
+
+/** Returns the current IVRVirtualDisplay pointer or NULL the interface could not be found. */
+VR_INTERFACE vr::IVRVirtualDisplay *VR_CALLTYPE VRVirtualDisplay();
+}  // namespace vr
+
+// ivrresources.h
+namespace vr
+{
+class IVRResources
+{
+public:
+	// ------------------------------------
+	// Shared Resource Methods
+	// ------------------------------------
+
+	/** Loads the specified resource into the provided buffer if large enough.
+	* Returns the size in bytes of the buffer required to hold the specified resource. */
+	virtual uint32_t LoadSharedResource(const char *pchResourceName, char *pchBuffer, uint32_t unBufferLen) = 0;
+
+	/** Provides the full path to the specified resource. Resource names can include named directories for
+	* drivers and other things, and this resolves all of those and returns the actual physical path. 
+	* pchResourceTypeDirectory is the subdirectory of resources to look in. */
+	virtual uint32_t GetResourceFullPath(const char *pchResourceName, const char *pchResourceTypeDirectory, char *pchPathBuffer, uint32_t unBufferLen) = 0;
+};
+
+static const char *const IVRResources_Version = "IVRResources_001";
+
+}  // namespace vr
+// ivrdrivermanager.h
+namespace vr
+{
+class IVRDriverManager
+{
+public:
+	virtual uint32_t GetDriverCount() const = 0;
+
+	/** Returns the length of the number of bytes necessary to hold this string including the trailing null. */
+	virtual uint32_t GetDriverName(vr::DriverId_t nDriver, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize) = 0;
+};
+
+static const char *const IVRDriverManager_Version = "IVRDriverManager_001";
+
+}  // namespace vr
+
+namespace vr
+{
+static const char *const k_InterfaceVersions[] =
+	{
+		IVRSettings_Version,
+		ITrackedDeviceServerDriver_Version,
+		IVRDisplayComponent_Version,
+		IVRDriverDirectModeComponent_Version,
+		IVRControllerComponent_Version,
+		IVRCameraComponent_Version,
+		IServerTrackedDeviceProvider_Version,
+		IVRWatchdogProvider_Version,
+		IVRVirtualDisplay_Version,
+		IVRDriverManager_Version,
+		IVRResources_Version,
+		nullptr};
+
+inline IVRDriverContext *&VRDriverContext()
+{
+	static IVRDriverContext *pHost;
+	return pHost;
+}
+
+class COpenVRDriverContext
+{
+public:
+	COpenVRDriverContext() : m_propertyHelpers(nullptr), m_hiddenAreaHelpers(nullptr) { Clear(); }
+	void Clear();
+
+	EVRInitError InitServer();
+	EVRInitError InitWatchdog();
+
+	IVRSettings *VRSettings()
+	{
+		if (m_pVRSettings == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRSettings = (IVRSettings *)VRDriverContext()->GetGenericInterface(IVRSettings_Version, &eError);
+		}
+		return m_pVRSettings;
+	}
+
+	IVRProperties *VRPropertiesRaw()
+	{
+		if (m_pVRProperties == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRProperties = (IVRProperties *)VRDriverContext()->GetGenericInterface(IVRProperties_Version, &eError);
+			m_propertyHelpers = CVRPropertyHelpers(m_pVRProperties);
+			m_hiddenAreaHelpers = CVRHiddenAreaHelpers(m_pVRProperties);
+		}
+		return m_pVRProperties;
+	}
+
+	CVRPropertyHelpers *VRProperties()
+	{
+		VRPropertiesRaw();
+		return &m_propertyHelpers;
+	}
+
+	CVRHiddenAreaHelpers *VRHiddenArea()
+	{
+		VRPropertiesRaw();
+		return &m_hiddenAreaHelpers;
+	}
+
+	IVRServerDriverHost *VRServerDriverHost()
+	{
+		if (m_pVRServerDriverHost == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRServerDriverHost = (IVRServerDriverHost *)VRDriverContext()->GetGenericInterface(IVRServerDriverHost_Version, &eError);
+		}
+		return m_pVRServerDriverHost;
+	}
+
+	IVRWatchdogHost *VRWatchdogHost()
+	{
+		if (m_pVRWatchdogHost == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRWatchdogHost = (IVRWatchdogHost *)VRDriverContext()->GetGenericInterface(IVRWatchdogHost_Version, &eError);
+		}
+		return m_pVRWatchdogHost;
+	}
+
+	IVRDriverLog *VRDriverLog()
+	{
+		if (m_pVRDriverLog == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRDriverLog = (IVRDriverLog *)VRDriverContext()->GetGenericInterface(IVRDriverLog_Version, &eError);
+		}
+		return m_pVRDriverLog;
+	}
+
+	DriverHandle_t VR_CALLTYPE VRDriverHandle()
+	{
+		return VRDriverContext()->GetDriverHandle();
+	}
+
+	IVRDriverManager *VRDriverManager()
+	{
+		if (!m_pVRDriverManager)
+		{
+			EVRInitError eError;
+			m_pVRDriverManager = (IVRDriverManager *)VRDriverContext()->GetGenericInterface(IVRDriverManager_Version, &eError);
+		}
+		return m_pVRDriverManager;
+	}
+
+	IVRResources *VRResources()
+	{
+		if (!m_pVRResources)
+		{
+			EVRInitError eError;
+			m_pVRResources = (IVRResources *)VRDriverContext()->GetGenericInterface(IVRResources_Version, &eError);
+		}
+		return m_pVRResources;
+	}
+
+private:
+	CVRPropertyHelpers m_propertyHelpers;
+	CVRHiddenAreaHelpers m_hiddenAreaHelpers;
+
+	IVRSettings *m_pVRSettings;
+	IVRProperties *m_pVRProperties;
+	IVRServerDriverHost *m_pVRServerDriverHost;
+	IVRWatchdogHost *m_pVRWatchdogHost;
+	IVRDriverLog *m_pVRDriverLog;
+	IVRDriverManager *m_pVRDriverManager;
+	IVRResources *m_pVRResources;
+};
+
+inline COpenVRDriverContext &OpenVRInternal_ModuleServerDriverContext()
+{
+	static void *ctx[sizeof(COpenVRDriverContext) / sizeof(void *)];
+	return *(COpenVRDriverContext *)ctx;  // bypass zero-init constructor
+}
+
+inline IVRSettings *VR_CALLTYPE VRSettings() { return OpenVRInternal_ModuleServerDriverContext().VRSettings(); }
+inline IVRProperties *VR_CALLTYPE VRPropertiesRaw() { return OpenVRInternal_ModuleServerDriverContext().VRPropertiesRaw(); }
+inline CVRPropertyHelpers *VR_CALLTYPE VRProperties() { return OpenVRInternal_ModuleServerDriverContext().VRProperties(); }
+inline CVRHiddenAreaHelpers *VR_CALLTYPE VRHiddenArea() { return OpenVRInternal_ModuleServerDriverContext().VRHiddenArea(); }
+inline IVRDriverLog *VR_CALLTYPE VRDriverLog() { return OpenVRInternal_ModuleServerDriverContext().VRDriverLog(); }
+inline IVRServerDriverHost *VR_CALLTYPE VRServerDriverHost() { return OpenVRInternal_ModuleServerDriverContext().VRServerDriverHost(); }
+inline IVRWatchdogHost *VR_CALLTYPE VRWatchdogHost() { return OpenVRInternal_ModuleServerDriverContext().VRWatchdogHost(); }
+inline DriverHandle_t VR_CALLTYPE VRDriverHandle() { return OpenVRInternal_ModuleServerDriverContext().VRDriverHandle(); }
+inline IVRDriverManager *VR_CALLTYPE VRDriverManager() { return OpenVRInternal_ModuleServerDriverContext().VRDriverManager(); }
+inline IVRResources *VR_CALLTYPE VRResources() { return OpenVRInternal_ModuleServerDriverContext().VRResources(); }
+
+inline void COpenVRDriverContext::Clear()
+{
+	m_pVRSettings = nullptr;
+	m_pVRProperties = nullptr;
+	m_pVRServerDriverHost = nullptr;
+	m_pVRDriverLog = nullptr;
+	m_pVRWatchdogHost = nullptr;
+	m_pVRDriverManager = nullptr;
+	m_pVRResources = nullptr;
+}
+
+inline EVRInitError COpenVRDriverContext::InitServer()
+{
+	Clear();
+	if (!VRServerDriverHost() || !VRSettings() || !VRProperties() || !VRDriverLog() || !VRDriverManager() || !VRResources())
+		return VRInitError_Init_InterfaceNotFound;
+	return VRInitError_None;
+}
+
+inline EVRInitError COpenVRDriverContext::InitWatchdog()
+{
+	Clear();
+	if (!VRWatchdogHost() || !VRSettings() || !VRDriverLog())
+		return VRInitError_Init_InterfaceNotFound;
+	return VRInitError_None;
+}
+
+inline EVRInitError InitServerDriverContext(IVRDriverContext *pContext)
+{
+	VRDriverContext() = pContext;
+	return OpenVRInternal_ModuleServerDriverContext().InitServer();
+}
+
+inline EVRInitError InitWatchdogDriverContext(IVRDriverContext *pContext)
+{
+	VRDriverContext() = pContext;
+	return OpenVRInternal_ModuleServerDriverContext().InitWatchdog();
+}
+
+inline void CleanupDriverContext()
+{
+	VRDriverContext() = nullptr;
+	OpenVRInternal_ModuleServerDriverContext().Clear();
+}
+
+#define VR_INIT_SERVER_DRIVER_CONTEXT(pContext)                          \
+	{                                                                    \
+		vr::EVRInitError eError = vr::InitServerDriverContext(pContext); \
+		if (eError != vr::VRInitError_None)                              \
+			return eError;                                               \
+	}
+
+#define VR_CLEANUP_SERVER_DRIVER_CONTEXT() \
+	vr::CleanupDriverContext();
+
+#define VR_INIT_WATCHDOG_DRIVER_CONTEXT(pContext)                          \
+	{                                                                      \
+		vr::EVRInitError eError = vr::InitWatchdogDriverContext(pContext); \
+		if (eError != vr::VRInitError_None)                                \
+			return eError;                                                 \
+	}
+
+#define VR_CLEANUP_WATCHDOG_DRIVER_CONTEXT() \
+	vr::CleanupDriverContext();
+}  // namespace vr
+// End
+
+#endif  // _OPENVR_DRIVER_API
diff --git a/engine/inc/bullet/ThirdPartyLibs/openvr/headers/openvr.h b/engine/inc/bullet/ThirdPartyLibs/openvr/headers/openvr.h
new file mode 100644
index 00000000..80461f96
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/openvr/headers/openvr.h
@@ -0,0 +1,3698 @@
+#pragma once
+
+// openvr.h
+//========= Copyright Valve Corporation ============//
+// Dynamically generated file. Do not modify this file directly.
+
+#ifndef _OPENVR_API
+#define _OPENVR_API
+
+#include <stdint.h>
+
+// vrtypes.h
+#ifndef _INCLUDE_VRTYPES_H
+#define _INCLUDE_VRTYPES_H
+
+// Forward declarations to avoid requiring vulkan.h
+struct VkDevice_T;
+struct VkPhysicalDevice_T;
+struct VkInstance_T;
+struct VkQueue_T;
+
+// Forward declarations to avoid requiring d3d12.h
+struct ID3D12Resource;
+struct ID3D12CommandQueue;
+
+namespace vr
+{
+#pragma pack(push, 8)
+
+typedef void *glSharedTextureHandle_t;
+typedef int32_t glInt_t;
+typedef uint32_t glUInt_t;
+
+// right-handed system
+// +y is up
+// +x is to the right
+// -z is going away from you
+// Distance unit is  meters
+struct HmdMatrix34_t
+{
+	float m[3][4];
+};
+
+struct HmdMatrix44_t
+{
+	float m[4][4];
+};
+
+struct HmdVector3_t
+{
+	float v[3];
+};
+
+struct HmdVector4_t
+{
+	float v[4];
+};
+
+struct HmdVector3d_t
+{
+	double v[3];
+};
+
+struct HmdVector2_t
+{
+	float v[2];
+};
+
+struct HmdQuaternion_t
+{
+	double w, x, y, z;
+};
+
+struct HmdColor_t
+{
+	float r, g, b, a;
+};
+
+struct HmdQuad_t
+{
+	HmdVector3_t vCorners[4];
+};
+
+struct HmdRect2_t
+{
+	HmdVector2_t vTopLeft;
+	HmdVector2_t vBottomRight;
+};
+
+/** Used to return the post-distortion UVs for each color channel. 
+* UVs range from 0 to 1 with 0,0 in the upper left corner of the 
+* source render target. The 0,0 to 1,1 range covers a single eye. */
+struct DistortionCoordinates_t
+{
+	float rfRed[2];
+	float rfGreen[2];
+	float rfBlue[2];
+};
+
+enum EVREye
+{
+	Eye_Left = 0,
+	Eye_Right = 1
+};
+
+enum ETextureType
+{
+	TextureType_DirectX = 0,    // Handle is an ID3D11Texture
+	TextureType_OpenGL = 1,     // Handle is an OpenGL texture name or an OpenGL render buffer name, depending on submit flags
+	TextureType_Vulkan = 2,     // Handle is a pointer to a VRVulkanTextureData_t structure
+	TextureType_IOSurface = 3,  // Handle is a macOS cross-process-sharable IOSurfaceRef
+	TextureType_DirectX12 = 4,  // Handle is a pointer to a D3D12TextureData_t structure
+};
+
+enum EColorSpace
+{
+	ColorSpace_Auto = 0,    // Assumes 'gamma' for 8-bit per component formats, otherwise 'linear'.  This mirrors the DXGI formats which have _SRGB variants.
+	ColorSpace_Gamma = 1,   // Texture data can be displayed directly on the display without any conversion (a.k.a. display native format).
+	ColorSpace_Linear = 2,  // Same as gamma but has been converted to a linear representation using DXGI's sRGB conversion algorithm.
+};
+
+struct Texture_t
+{
+	void *handle;  // See ETextureType definition above
+	ETextureType eType;
+	EColorSpace eColorSpace;
+};
+
+// Handle to a shared texture (HANDLE on Windows obtained using OpenSharedResource).
+typedef uint64_t SharedTextureHandle_t;
+#define INVALID_SHARED_TEXTURE_HANDLE ((vr::SharedTextureHandle_t)0)
+
+enum ETrackingResult
+{
+	TrackingResult_Uninitialized = 1,
+
+	TrackingResult_Calibrating_InProgress = 100,
+	TrackingResult_Calibrating_OutOfRange = 101,
+
+	TrackingResult_Running_OK = 200,
+	TrackingResult_Running_OutOfRange = 201,
+};
+
+typedef uint32_t DriverId_t;
+static const uint32_t k_nDriverNone = 0xFFFFFFFF;
+
+static const uint32_t k_unMaxDriverDebugResponseSize = 32768;
+
+/** Used to pass device IDs to API calls */
+typedef uint32_t TrackedDeviceIndex_t;
+static const uint32_t k_unTrackedDeviceIndex_Hmd = 0;
+static const uint32_t k_unMaxTrackedDeviceCount = 16;
+static const uint32_t k_unTrackedDeviceIndexOther = 0xFFFFFFFE;
+static const uint32_t k_unTrackedDeviceIndexInvalid = 0xFFFFFFFF;
+
+/** Describes what kind of object is being tracked at a given ID */
+enum ETrackedDeviceClass
+{
+	TrackedDeviceClass_Invalid = 0,            // the ID was not valid.
+	TrackedDeviceClass_HMD = 1,                // Head-Mounted Displays
+	TrackedDeviceClass_Controller = 2,         // Tracked controllers
+	TrackedDeviceClass_GenericTracker = 3,     // Generic trackers, similar to controllers
+	TrackedDeviceClass_TrackingReference = 4,  // Camera and base stations that serve as tracking reference points
+	TrackedDeviceClass_DisplayRedirect = 5,    // Accessories that aren't necessarily tracked themselves, but may redirect video output from other tracked devices
+};
+
+/** Describes what specific role associated with a tracked device */
+enum ETrackedControllerRole
+{
+	TrackedControllerRole_Invalid = 0,    // Invalid value for controller type
+	TrackedControllerRole_LeftHand = 1,   // Tracked device associated with the left hand
+	TrackedControllerRole_RightHand = 2,  // Tracked device associated with the right hand
+};
+
+/** describes a single pose for a tracked object */
+struct TrackedDevicePose_t
+{
+	HmdMatrix34_t mDeviceToAbsoluteTracking;
+	HmdVector3_t vVelocity;         // velocity in tracker space in m/s
+	HmdVector3_t vAngularVelocity;  // angular velocity in radians/s (?)
+	ETrackingResult eTrackingResult;
+	bool bPoseIsValid;
+
+	// This indicates that there is a device connected for this spot in the pose array.
+	// It could go from true to false if the user unplugs the device.
+	bool bDeviceIsConnected;
+};
+
+/** Identifies which style of tracking origin the application wants to use
+* for the poses it is requesting */
+enum ETrackingUniverseOrigin
+{
+	TrackingUniverseSeated = 0,              // Poses are provided relative to the seated zero pose
+	TrackingUniverseStanding = 1,            // Poses are provided relative to the safe bounds configured by the user
+	TrackingUniverseRawAndUncalibrated = 2,  // Poses are provided in the coordinate system defined by the driver.  It has Y up and is unified for devices of the same driver. You usually don't want this one.
+};
+
+// Refers to a single container of properties
+typedef uint64_t PropertyContainerHandle_t;
+typedef uint32_t PropertyTypeTag_t;
+
+static const PropertyContainerHandle_t k_ulInvalidPropertyContainer = 0;
+static const PropertyTypeTag_t k_unInvalidPropertyTag = 0;
+
+// Use these tags to set/get common types as struct properties
+static const PropertyTypeTag_t k_unFloatPropertyTag = 1;
+static const PropertyTypeTag_t k_unInt32PropertyTag = 2;
+static const PropertyTypeTag_t k_unUint64PropertyTag = 3;
+static const PropertyTypeTag_t k_unBoolPropertyTag = 4;
+static const PropertyTypeTag_t k_unStringPropertyTag = 5;
+
+static const PropertyTypeTag_t k_unHmdMatrix34PropertyTag = 20;
+static const PropertyTypeTag_t k_unHmdMatrix44PropertyTag = 21;
+static const PropertyTypeTag_t k_unHmdVector3PropertyTag = 22;
+static const PropertyTypeTag_t k_unHmdVector4PropertyTag = 23;
+
+static const PropertyTypeTag_t k_unHiddenAreaPropertyTag = 30;
+
+static const PropertyTypeTag_t k_unOpenVRInternalReserved_Start = 1000;
+static const PropertyTypeTag_t k_unOpenVRInternalReserved_End = 10000;
+
+/** Each entry in this enum represents a property that can be retrieved about a
+* tracked device. Many fields are only valid for one ETrackedDeviceClass. */
+enum ETrackedDeviceProperty
+{
+	Prop_Invalid = 0,
+
+	// general properties that apply to all device classes
+	Prop_TrackingSystemName_String = 1000,
+	Prop_ModelNumber_String = 1001,
+	Prop_SerialNumber_String = 1002,
+	Prop_RenderModelName_String = 1003,
+	Prop_WillDriftInYaw_Bool = 1004,
+	Prop_ManufacturerName_String = 1005,
+	Prop_TrackingFirmwareVersion_String = 1006,
+	Prop_HardwareRevision_String = 1007,
+	Prop_AllWirelessDongleDescriptions_String = 1008,
+	Prop_ConnectedWirelessDongle_String = 1009,
+	Prop_DeviceIsWireless_Bool = 1010,
+	Prop_DeviceIsCharging_Bool = 1011,
+	Prop_DeviceBatteryPercentage_Float = 1012,  // 0 is empty, 1 is full
+	Prop_StatusDisplayTransform_Matrix34 = 1013,
+	Prop_Firmware_UpdateAvailable_Bool = 1014,
+	Prop_Firmware_ManualUpdate_Bool = 1015,
+	Prop_Firmware_ManualUpdateURL_String = 1016,
+	Prop_HardwareRevision_Uint64 = 1017,
+	Prop_FirmwareVersion_Uint64 = 1018,
+	Prop_FPGAVersion_Uint64 = 1019,
+	Prop_VRCVersion_Uint64 = 1020,
+	Prop_RadioVersion_Uint64 = 1021,
+	Prop_DongleVersion_Uint64 = 1022,
+	Prop_BlockServerShutdown_Bool = 1023,
+	Prop_CanUnifyCoordinateSystemWithHmd_Bool = 1024,
+	Prop_ContainsProximitySensor_Bool = 1025,
+	Prop_DeviceProvidesBatteryStatus_Bool = 1026,
+	Prop_DeviceCanPowerOff_Bool = 1027,
+	Prop_Firmware_ProgrammingTarget_String = 1028,
+	Prop_DeviceClass_Int32 = 1029,
+	Prop_HasCamera_Bool = 1030,
+	Prop_DriverVersion_String = 1031,
+	Prop_Firmware_ForceUpdateRequired_Bool = 1032,
+	Prop_ViveSystemButtonFixRequired_Bool = 1033,
+	Prop_ParentDriver_Uint64 = 1034,
+	Prop_ResourceRoot_String = 1035,
+
+	// Properties that are unique to TrackedDeviceClass_HMD
+	Prop_ReportsTimeSinceVSync_Bool = 2000,
+	Prop_SecondsFromVsyncToPhotons_Float = 2001,
+	Prop_DisplayFrequency_Float = 2002,
+	Prop_UserIpdMeters_Float = 2003,
+	Prop_CurrentUniverseId_Uint64 = 2004,
+	Prop_PreviousUniverseId_Uint64 = 2005,
+	Prop_DisplayFirmwareVersion_Uint64 = 2006,
+	Prop_IsOnDesktop_Bool = 2007,
+	Prop_DisplayMCType_Int32 = 2008,
+	Prop_DisplayMCOffset_Float = 2009,
+	Prop_DisplayMCScale_Float = 2010,
+	Prop_EdidVendorID_Int32 = 2011,
+	Prop_DisplayMCImageLeft_String = 2012,
+	Prop_DisplayMCImageRight_String = 2013,
+	Prop_DisplayGCBlackClamp_Float = 2014,
+	Prop_EdidProductID_Int32 = 2015,
+	Prop_CameraToHeadTransform_Matrix34 = 2016,
+	Prop_DisplayGCType_Int32 = 2017,
+	Prop_DisplayGCOffset_Float = 2018,
+	Prop_DisplayGCScale_Float = 2019,
+	Prop_DisplayGCPrescale_Float = 2020,
+	Prop_DisplayGCImage_String = 2021,
+	Prop_LensCenterLeftU_Float = 2022,
+	Prop_LensCenterLeftV_Float = 2023,
+	Prop_LensCenterRightU_Float = 2024,
+	Prop_LensCenterRightV_Float = 2025,
+	Prop_UserHeadToEyeDepthMeters_Float = 2026,
+	Prop_CameraFirmwareVersion_Uint64 = 2027,
+	Prop_CameraFirmwareDescription_String = 2028,
+	Prop_DisplayFPGAVersion_Uint64 = 2029,
+	Prop_DisplayBootloaderVersion_Uint64 = 2030,
+	Prop_DisplayHardwareVersion_Uint64 = 2031,
+	Prop_AudioFirmwareVersion_Uint64 = 2032,
+	Prop_CameraCompatibilityMode_Int32 = 2033,
+	Prop_ScreenshotHorizontalFieldOfViewDegrees_Float = 2034,
+	Prop_ScreenshotVerticalFieldOfViewDegrees_Float = 2035,
+	Prop_DisplaySuppressed_Bool = 2036,
+	Prop_DisplayAllowNightMode_Bool = 2037,
+	Prop_DisplayMCImageWidth_Int32 = 2038,
+	Prop_DisplayMCImageHeight_Int32 = 2039,
+	Prop_DisplayMCImageNumChannels_Int32 = 2040,
+	Prop_DisplayMCImageData_Binary = 2041,
+	Prop_SecondsFromPhotonsToVblank_Float = 2042,
+	Prop_DriverDirectModeSendsVsyncEvents_Bool = 2043,
+	Prop_DisplayDebugMode_Bool = 2044,
+	Prop_GraphicsAdapterLuid_Uint64 = 2045,
+	Prop_DriverProvidedChaperonePath_String = 2048,
+
+	// Properties that are unique to TrackedDeviceClass_Controller
+	Prop_AttachedDeviceId_String = 3000,
+	Prop_SupportedButtons_Uint64 = 3001,
+	Prop_Axis0Type_Int32 = 3002,           // Return value is of type EVRControllerAxisType
+	Prop_Axis1Type_Int32 = 3003,           // Return value is of type EVRControllerAxisType
+	Prop_Axis2Type_Int32 = 3004,           // Return value is of type EVRControllerAxisType
+	Prop_Axis3Type_Int32 = 3005,           // Return value is of type EVRControllerAxisType
+	Prop_Axis4Type_Int32 = 3006,           // Return value is of type EVRControllerAxisType
+	Prop_ControllerRoleHint_Int32 = 3007,  // Return value is of type ETrackedControllerRole
+
+	// Properties that are unique to TrackedDeviceClass_TrackingReference
+	Prop_FieldOfViewLeftDegrees_Float = 4000,
+	Prop_FieldOfViewRightDegrees_Float = 4001,
+	Prop_FieldOfViewTopDegrees_Float = 4002,
+	Prop_FieldOfViewBottomDegrees_Float = 4003,
+	Prop_TrackingRangeMinimumMeters_Float = 4004,
+	Prop_TrackingRangeMaximumMeters_Float = 4005,
+	Prop_ModeLabel_String = 4006,
+
+	// Properties that are used for user interface like icons names
+	Prop_IconPathName_String = 5000,                       // DEPRECATED. Value not referenced. Now expected to be part of icon path properties.
+	Prop_NamedIconPathDeviceOff_String = 5001,             // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceSearching_String = 5002,       // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceSearchingAlert_String = 5003,  // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceReady_String = 5004,           // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceReadyAlert_String = 5005,      // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceNotReady_String = 5006,        // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceStandby_String = 5007,         // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceAlertLow_String = 5008,        // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+
+	// Properties that are used by helpers, but are opaque to applications
+	Prop_DisplayHiddenArea_Binary_Start = 5100,
+	Prop_DisplayHiddenArea_Binary_End = 5150,
+
+	// Properties that are unique to drivers
+	Prop_UserConfigPath_String = 6000,
+	Prop_InstallPath_String = 6001,
+	Prop_HasDisplayComponent_Bool = 6002,
+	Prop_HasControllerComponent_Bool = 6003,
+	Prop_HasCameraComponent_Bool = 6004,
+	Prop_HasDriverDirectModeComponent_Bool = 6005,
+	Prop_HasVirtualDisplayComponent_Bool = 6006,
+
+	// Vendors are free to expose private debug data in this reserved region
+	Prop_VendorSpecific_Reserved_Start = 10000,
+	Prop_VendorSpecific_Reserved_End = 10999,
+};
+
+/** No string property will ever be longer than this length */
+static const uint32_t k_unMaxPropertyStringSize = 32 * 1024;
+
+/** Used to return errors that occur when reading properties. */
+enum ETrackedPropertyError
+{
+	TrackedProp_Success = 0,
+	TrackedProp_WrongDataType = 1,
+	TrackedProp_WrongDeviceClass = 2,
+	TrackedProp_BufferTooSmall = 3,
+	TrackedProp_UnknownProperty = 4,  // Driver has not set the property (and may not ever).
+	TrackedProp_InvalidDevice = 5,
+	TrackedProp_CouldNotContactServer = 6,
+	TrackedProp_ValueNotProvidedByDevice = 7,
+	TrackedProp_StringExceedsMaximumLength = 8,
+	TrackedProp_NotYetAvailable = 9,  // The property value isn't known yet, but is expected soon. Call again later.
+	TrackedProp_PermissionDenied = 10,
+	TrackedProp_InvalidOperation = 11,
+};
+
+/** Allows the application to control what part of the provided texture will be used in the
+* frame buffer. */
+struct VRTextureBounds_t
+{
+	float uMin, vMin;
+	float uMax, vMax;
+};
+
+/** Allows specifying pose used to render provided scene texture (if different from value returned by WaitGetPoses). */
+struct VRTextureWithPose_t : public Texture_t
+{
+	HmdMatrix34_t mDeviceToAbsoluteTracking;  // Actual pose used to render scene textures.
+};
+
+/** Allows the application to control how scene textures are used by the compositor when calling Submit. */
+enum EVRSubmitFlags
+{
+	// Simple render path. App submits rendered left and right eye images with no lens distortion correction applied.
+	Submit_Default = 0x00,
+
+	// App submits final left and right eye images with lens distortion already applied (lens distortion makes the images appear
+	// barrel distorted with chromatic aberration correction applied). The app would have used the data returned by
+	// vr::IVRSystem::ComputeDistortion() to apply the correct distortion to the rendered images before calling Submit().
+	Submit_LensDistortionAlreadyApplied = 0x01,
+
+	// If the texture pointer passed in is actually a renderbuffer (e.g. for MSAA in OpenGL) then set this flag.
+	Submit_GlRenderBuffer = 0x02,
+
+	// Do not use
+	Submit_Reserved = 0x04,
+
+	// Set to indicate that pTexture is a pointer to a VRTextureWithPose_t.
+	Submit_TextureWithPose = 0x08,
+};
+
+/** Data required for passing Vulkan textures to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. */
+struct VRVulkanTextureData_t
+{
+	uint64_t m_nImage;  // VkImage
+	VkDevice_T *m_pDevice;
+	VkPhysicalDevice_T *m_pPhysicalDevice;
+	VkInstance_T *m_pInstance;
+	VkQueue_T *m_pQueue;
+	uint32_t m_nQueueFamilyIndex;
+	uint32_t m_nWidth, m_nHeight, m_nFormat, m_nSampleCount;
+};
+
+/** Data required for passing D3D12 textures to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. */
+struct D3D12TextureData_t
+{
+	ID3D12Resource *m_pResource;
+	ID3D12CommandQueue *m_pCommandQueue;
+	uint32_t m_nNodeMask;
+};
+
+/** Status of the overall system or tracked objects */
+enum EVRState
+{
+	VRState_Undefined = -1,
+	VRState_Off = 0,
+	VRState_Searching = 1,
+	VRState_Searching_Alert = 2,
+	VRState_Ready = 3,
+	VRState_Ready_Alert = 4,
+	VRState_NotReady = 5,
+	VRState_Standby = 6,
+	VRState_Ready_Alert_Low = 7,
+};
+
+/** The types of events that could be posted (and what the parameters mean for each event type) */
+enum EVREventType
+{
+	VREvent_None = 0,
+
+	VREvent_TrackedDeviceActivated = 100,
+	VREvent_TrackedDeviceDeactivated = 101,
+	VREvent_TrackedDeviceUpdated = 102,
+	VREvent_TrackedDeviceUserInteractionStarted = 103,
+	VREvent_TrackedDeviceUserInteractionEnded = 104,
+	VREvent_IpdChanged = 105,
+	VREvent_EnterStandbyMode = 106,
+	VREvent_LeaveStandbyMode = 107,
+	VREvent_TrackedDeviceRoleChanged = 108,
+	VREvent_WatchdogWakeUpRequested = 109,
+	VREvent_LensDistortionChanged = 110,
+	VREvent_PropertyChanged = 111,
+	VREvent_WirelessDisconnect = 112,
+	VREvent_WirelessReconnect = 113,
+
+	VREvent_ButtonPress = 200,    // data is controller
+	VREvent_ButtonUnpress = 201,  // data is controller
+	VREvent_ButtonTouch = 202,    // data is controller
+	VREvent_ButtonUntouch = 203,  // data is controller
+
+	VREvent_MouseMove = 300,            // data is mouse
+	VREvent_MouseButtonDown = 301,      // data is mouse
+	VREvent_MouseButtonUp = 302,        // data is mouse
+	VREvent_FocusEnter = 303,           // data is overlay
+	VREvent_FocusLeave = 304,           // data is overlay
+	VREvent_Scroll = 305,               // data is mouse
+	VREvent_TouchPadMove = 306,         // data is mouse
+	VREvent_OverlayFocusChanged = 307,  // data is overlay, global event
+
+	VREvent_InputFocusCaptured = 400,                         // data is process DEPRECATED
+	VREvent_InputFocusReleased = 401,                         // data is process DEPRECATED
+	VREvent_SceneFocusLost = 402,                             // data is process
+	VREvent_SceneFocusGained = 403,                           // data is process
+	VREvent_SceneApplicationChanged = 404,                    // data is process - The App actually drawing the scene changed (usually to or from the compositor)
+	VREvent_SceneFocusChanged = 405,                          // data is process - New app got access to draw the scene
+	VREvent_InputFocusChanged = 406,                          // data is process
+	VREvent_SceneApplicationSecondaryRenderingStarted = 407,  // data is process
+
+	VREvent_HideRenderModels = 410,  // Sent to the scene application to request hiding render models temporarily
+	VREvent_ShowRenderModels = 411,  // Sent to the scene application to request restoring render model visibility
+
+	VREvent_OverlayShown = 500,
+	VREvent_OverlayHidden = 501,
+	VREvent_DashboardActivated = 502,
+	VREvent_DashboardDeactivated = 503,
+	VREvent_DashboardThumbSelected = 504,     // Sent to the overlay manager - data is overlay
+	VREvent_DashboardRequested = 505,         // Sent to the overlay manager - data is overlay
+	VREvent_ResetDashboard = 506,             // Send to the overlay manager
+	VREvent_RenderToast = 507,                // Send to the dashboard to render a toast - data is the notification ID
+	VREvent_ImageLoaded = 508,                // Sent to overlays when a SetOverlayRaw or SetOverlayFromFile call finishes loading
+	VREvent_ShowKeyboard = 509,               // Sent to keyboard renderer in the dashboard to invoke it
+	VREvent_HideKeyboard = 510,               // Sent to keyboard renderer in the dashboard to hide it
+	VREvent_OverlayGamepadFocusGained = 511,  // Sent to an overlay when IVROverlay::SetFocusOverlay is called on it
+	VREvent_OverlayGamepadFocusLost = 512,    // Send to an overlay when it previously had focus and IVROverlay::SetFocusOverlay is called on something else
+	VREvent_OverlaySharedTextureChanged = 513,
+	VREvent_DashboardGuideButtonDown = 514,
+	VREvent_DashboardGuideButtonUp = 515,
+	VREvent_ScreenshotTriggered = 516,  // Screenshot button combo was pressed, Dashboard should request a screenshot
+	VREvent_ImageFailed = 517,          // Sent to overlays when a SetOverlayRaw or SetOverlayfromFail fails to load
+	VREvent_DashboardOverlayCreated = 518,
+
+	// Screenshot API
+	VREvent_RequestScreenshot = 520,              // Sent by vrclient application to compositor to take a screenshot
+	VREvent_ScreenshotTaken = 521,                // Sent by compositor to the application that the screenshot has been taken
+	VREvent_ScreenshotFailed = 522,               // Sent by compositor to the application that the screenshot failed to be taken
+	VREvent_SubmitScreenshotToDashboard = 523,    // Sent by compositor to the dashboard that a completed screenshot was submitted
+	VREvent_ScreenshotProgressToDashboard = 524,  // Sent by compositor to the dashboard that a completed screenshot was submitted
+
+	VREvent_PrimaryDashboardDeviceChanged = 525,
+
+	VREvent_Notification_Shown = 600,
+	VREvent_Notification_Hidden = 601,
+	VREvent_Notification_BeginInteraction = 602,
+	VREvent_Notification_Destroyed = 603,
+
+	VREvent_Quit = 700,                    // data is process
+	VREvent_ProcessQuit = 701,             // data is process
+	VREvent_QuitAborted_UserPrompt = 702,  // data is process
+	VREvent_QuitAcknowledged = 703,        // data is process
+	VREvent_DriverRequestedQuit = 704,     // The driver has requested that SteamVR shut down
+
+	VREvent_ChaperoneDataHasChanged = 800,
+	VREvent_ChaperoneUniverseHasChanged = 801,
+	VREvent_ChaperoneTempDataHasChanged = 802,
+	VREvent_ChaperoneSettingsHaveChanged = 803,
+	VREvent_SeatedZeroPoseReset = 804,
+
+	VREvent_AudioSettingsHaveChanged = 820,
+
+	VREvent_BackgroundSettingHasChanged = 850,
+	VREvent_CameraSettingsHaveChanged = 851,
+	VREvent_ReprojectionSettingHasChanged = 852,
+	VREvent_ModelSkinSettingsHaveChanged = 853,
+	VREvent_EnvironmentSettingsHaveChanged = 854,
+	VREvent_PowerSettingsHaveChanged = 855,
+	VREvent_EnableHomeAppSettingsHaveChanged = 856,
+
+	VREvent_StatusUpdate = 900,
+
+	VREvent_MCImageUpdated = 1000,
+
+	VREvent_FirmwareUpdateStarted = 1100,
+	VREvent_FirmwareUpdateFinished = 1101,
+
+	VREvent_KeyboardClosed = 1200,
+	VREvent_KeyboardCharInput = 1201,
+	VREvent_KeyboardDone = 1202,  // Sent when DONE button clicked on keyboard
+
+	VREvent_ApplicationTransitionStarted = 1300,
+	VREvent_ApplicationTransitionAborted = 1301,
+	VREvent_ApplicationTransitionNewAppStarted = 1302,
+	VREvent_ApplicationListUpdated = 1303,
+	VREvent_ApplicationMimeTypeLoad = 1304,
+	VREvent_ApplicationTransitionNewAppLaunchComplete = 1305,
+	VREvent_ProcessConnected = 1306,
+	VREvent_ProcessDisconnected = 1307,
+
+	VREvent_Compositor_MirrorWindowShown = 1400,
+	VREvent_Compositor_MirrorWindowHidden = 1401,
+	VREvent_Compositor_ChaperoneBoundsShown = 1410,
+	VREvent_Compositor_ChaperoneBoundsHidden = 1411,
+
+	VREvent_TrackedCamera_StartVideoStream = 1500,
+	VREvent_TrackedCamera_StopVideoStream = 1501,
+	VREvent_TrackedCamera_PauseVideoStream = 1502,
+	VREvent_TrackedCamera_ResumeVideoStream = 1503,
+	VREvent_TrackedCamera_EditingSurface = 1550,
+
+	VREvent_PerformanceTest_EnableCapture = 1600,
+	VREvent_PerformanceTest_DisableCapture = 1601,
+	VREvent_PerformanceTest_FidelityLevel = 1602,
+
+	VREvent_MessageOverlay_Closed = 1650,
+	VREvent_MessageOverlayCloseRequested = 1651,
+
+	// Vendors are free to expose private events in this reserved region
+	VREvent_VendorSpecific_Reserved_Start = 10000,
+	VREvent_VendorSpecific_Reserved_End = 19999,
+};
+
+/** Level of Hmd activity */
+// UserInteraction_Timeout means the device is in the process of timing out.
+// InUse = ( k_EDeviceActivityLevel_UserInteraction || k_EDeviceActivityLevel_UserInteraction_Timeout )
+// VREvent_TrackedDeviceUserInteractionStarted fires when the devices transitions from Standby -> UserInteraction or Idle -> UserInteraction.
+// VREvent_TrackedDeviceUserInteractionEnded fires when the devices transitions from UserInteraction_Timeout -> Idle
+enum EDeviceActivityLevel
+{
+	k_EDeviceActivityLevel_Unknown = -1,
+	k_EDeviceActivityLevel_Idle = 0,                     // No activity for the last 10 seconds
+	k_EDeviceActivityLevel_UserInteraction = 1,          // Activity (movement or prox sensor) is happening now
+	k_EDeviceActivityLevel_UserInteraction_Timeout = 2,  // No activity for the last 0.5 seconds
+	k_EDeviceActivityLevel_Standby = 3,                  // Idle for at least 5 seconds (configurable in Settings -> Power Management)
+};
+
+/** VR controller button and axis IDs */
+enum EVRButtonId
+{
+	k_EButton_System = 0,
+	k_EButton_ApplicationMenu = 1,
+	k_EButton_Grip = 2,
+	k_EButton_DPad_Left = 3,
+	k_EButton_DPad_Up = 4,
+	k_EButton_DPad_Right = 5,
+	k_EButton_DPad_Down = 6,
+	k_EButton_A = 7,
+
+	k_EButton_ProximitySensor = 31,
+
+	k_EButton_Axis0 = 32,
+	k_EButton_Axis1 = 33,
+	k_EButton_Axis2 = 34,
+	k_EButton_Axis3 = 35,
+	k_EButton_Axis4 = 36,
+
+	// aliases for well known controllers
+	k_EButton_SteamVR_Touchpad = k_EButton_Axis0,
+	k_EButton_SteamVR_Trigger = k_EButton_Axis1,
+
+	k_EButton_Dashboard_Back = k_EButton_Grip,
+
+	k_EButton_Max = 64
+};
+
+inline uint64_t ButtonMaskFromId(EVRButtonId id) { return 1ull << id; }
+
+/** used for controller button events */
+struct VREvent_Controller_t
+{
+	uint32_t button;  // EVRButtonId enum
+};
+
+/** used for simulated mouse events in overlay space */
+enum EVRMouseButton
+{
+	VRMouseButton_Left = 0x0001,
+	VRMouseButton_Right = 0x0002,
+	VRMouseButton_Middle = 0x0004,
+};
+
+/** used for simulated mouse events in overlay space */
+struct VREvent_Mouse_t
+{
+	float x, y;       // co-ords are in GL space, bottom left of the texture is 0,0
+	uint32_t button;  // EVRMouseButton enum
+};
+
+/** used for simulated mouse wheel scroll in overlay space */
+struct VREvent_Scroll_t
+{
+	float xdelta, ydelta;  // movement in fraction of the pad traversed since last delta, 1.0 for a full swipe
+	uint32_t repeatCount;
+};
+
+/** when in mouse input mode you can receive data from the touchpad, these events are only sent if the users finger
+   is on the touchpad (or just released from it) 
+**/
+struct VREvent_TouchPadMove_t
+{
+	// true if the users finger is detected on the touch pad
+	bool bFingerDown;
+
+	// How long the finger has been down in seconds
+	float flSecondsFingerDown;
+
+	// These values indicate the starting finger position (so you can do some basic swipe stuff)
+	float fValueXFirst;
+	float fValueYFirst;
+
+	// This is the raw sampled coordinate without deadzoning
+	float fValueXRaw;
+	float fValueYRaw;
+};
+
+/** notification related events. Details will still change at this point */
+struct VREvent_Notification_t
+{
+	uint64_t ulUserValue;
+	uint32_t notificationId;
+};
+
+/** Used for events about processes */
+struct VREvent_Process_t
+{
+	uint32_t pid;
+	uint32_t oldPid;
+	bool bForced;
+};
+
+/** Used for a few events about overlays */
+struct VREvent_Overlay_t
+{
+	uint64_t overlayHandle;
+};
+
+/** Used for a few events about overlays */
+struct VREvent_Status_t
+{
+	uint32_t statusState;  // EVRState enum
+};
+
+/** Used for keyboard events **/
+struct VREvent_Keyboard_t
+{
+	char cNewInput[8];    // Up to 11 bytes of new input
+	uint64_t uUserValue;  // Possible flags about the new input
+};
+
+struct VREvent_Ipd_t
+{
+	float ipdMeters;
+};
+
+struct VREvent_Chaperone_t
+{
+	uint64_t m_nPreviousUniverse;
+	uint64_t m_nCurrentUniverse;
+};
+
+/** Not actually used for any events */
+struct VREvent_Reserved_t
+{
+	uint64_t reserved0;
+	uint64_t reserved1;
+};
+
+struct VREvent_PerformanceTest_t
+{
+	uint32_t m_nFidelityLevel;
+};
+
+struct VREvent_SeatedZeroPoseReset_t
+{
+	bool bResetBySystemMenu;
+};
+
+struct VREvent_Screenshot_t
+{
+	uint32_t handle;
+	uint32_t type;
+};
+
+struct VREvent_ScreenshotProgress_t
+{
+	float progress;
+};
+
+struct VREvent_ApplicationLaunch_t
+{
+	uint32_t pid;
+	uint32_t unArgsHandle;
+};
+
+struct VREvent_EditingCameraSurface_t
+{
+	uint64_t overlayHandle;
+	uint32_t nVisualMode;
+};
+
+struct VREvent_MessageOverlay_t
+{
+	uint32_t unVRMessageOverlayResponse;  // vr::VRMessageOverlayResponse enum
+};
+
+struct VREvent_Property_t
+{
+	PropertyContainerHandle_t container;
+	ETrackedDeviceProperty prop;
+};
+
+/** NOTE!!! If you change this you MUST manually update openvr_interop.cs.py */
+typedef union {
+	VREvent_Reserved_t reserved;
+	VREvent_Controller_t controller;
+	VREvent_Mouse_t mouse;
+	VREvent_Scroll_t scroll;
+	VREvent_Process_t process;
+	VREvent_Notification_t notification;
+	VREvent_Overlay_t overlay;
+	VREvent_Status_t status;
+	VREvent_Keyboard_t keyboard;
+	VREvent_Ipd_t ipd;
+	VREvent_Chaperone_t chaperone;
+	VREvent_PerformanceTest_t performanceTest;
+	VREvent_TouchPadMove_t touchPadMove;
+	VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset;
+	VREvent_Screenshot_t screenshot;
+	VREvent_ScreenshotProgress_t screenshotProgress;
+	VREvent_ApplicationLaunch_t applicationLaunch;
+	VREvent_EditingCameraSurface_t cameraSurface;
+	VREvent_MessageOverlay_t messageOverlay;
+	VREvent_Property_t property;
+} VREvent_Data_t;
+
+#if defined(__linux__) || defined(__APPLE__)
+// This structure was originally defined mis-packed on Linux, preserved for
+// compatibility.
+#pragma pack(push, 4)
+#endif
+
+/** An event posted by the server to all running applications */
+struct VREvent_t
+{
+	uint32_t eventType;  // EVREventType enum
+	TrackedDeviceIndex_t trackedDeviceIndex;
+	float eventAgeSeconds;
+	// event data must be the end of the struct as its size is variable
+	VREvent_Data_t data;
+};
+
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+
+/** The mesh to draw into the stencil (or depth) buffer to perform 
+* early stencil (or depth) kills of pixels that will never appear on the HMD.
+* This mesh draws on all the pixels that will be hidden after distortion. 
+*
+* If the HMD does not provide a visible area mesh pVertexData will be
+* NULL and unTriangleCount will be 0. */
+struct HiddenAreaMesh_t
+{
+	const HmdVector2_t *pVertexData;
+	uint32_t unTriangleCount;
+};
+
+enum EHiddenAreaMeshType
+{
+	k_eHiddenAreaMesh_Standard = 0,
+	k_eHiddenAreaMesh_Inverse = 1,
+	k_eHiddenAreaMesh_LineLoop = 2,
+
+	k_eHiddenAreaMesh_Max = 3,
+};
+
+/** Identifies what kind of axis is on the controller at index n. Read this type 
+* with pVRSystem->Get( nControllerDeviceIndex, Prop_Axis0Type_Int32 + n );
+*/
+enum EVRControllerAxisType
+{
+	k_eControllerAxis_None = 0,
+	k_eControllerAxis_TrackPad = 1,
+	k_eControllerAxis_Joystick = 2,
+	k_eControllerAxis_Trigger = 3,  // Analog trigger data is in the X axis
+};
+
+/** contains information about one axis on the controller */
+struct VRControllerAxis_t
+{
+	float x;  // Ranges from -1.0 to 1.0 for joysticks and track pads. Ranges from 0.0 to 1.0 for triggers were 0 is fully released.
+	float y;  // Ranges from -1.0 to 1.0 for joysticks and track pads. Is always 0.0 for triggers.
+};
+
+/** the number of axes in the controller state */
+static const uint32_t k_unControllerStateAxisCount = 5;
+
+#if defined(__linux__) || defined(__APPLE__)
+// This structure was originally defined mis-packed on Linux, preserved for
+// compatibility.
+#pragma pack(push, 4)
+#endif
+
+/** Holds all the state of a controller at one moment in time. */
+struct VRControllerState001_t
+{
+	// If packet num matches that on your prior call, then the controller state hasn't been changed since
+	// your last call and there is no need to process it
+	uint32_t unPacketNum;
+
+	// bit flags for each of the buttons. Use ButtonMaskFromId to turn an ID into a mask
+	uint64_t ulButtonPressed;
+	uint64_t ulButtonTouched;
+
+	// Axis data for the controller's analog inputs
+	VRControllerAxis_t rAxis[k_unControllerStateAxisCount];
+};
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+
+typedef VRControllerState001_t VRControllerState_t;
+
+/** determines how to provide output to the application of various event processing functions. */
+enum EVRControllerEventOutputType
+{
+	ControllerEventOutput_OSEvents = 0,
+	ControllerEventOutput_VREvents = 1,
+};
+
+/** Collision Bounds Style */
+enum ECollisionBoundsStyle
+{
+	COLLISION_BOUNDS_STYLE_BEGINNER = 0,
+	COLLISION_BOUNDS_STYLE_INTERMEDIATE,
+	COLLISION_BOUNDS_STYLE_SQUARES,
+	COLLISION_BOUNDS_STYLE_ADVANCED,
+	COLLISION_BOUNDS_STYLE_NONE,
+
+	COLLISION_BOUNDS_STYLE_COUNT
+};
+
+/** Allows the application to customize how the overlay appears in the compositor */
+struct Compositor_OverlaySettings
+{
+	uint32_t size;  // sizeof(Compositor_OverlaySettings)
+	bool curved, antialias;
+	float scale, distance, alpha;
+	float uOffset, vOffset, uScale, vScale;
+	float gridDivs, gridWidth, gridScale;
+	HmdMatrix44_t transform;
+};
+
+/** used to refer to a single VR overlay */
+typedef uint64_t VROverlayHandle_t;
+
+static const VROverlayHandle_t k_ulOverlayHandleInvalid = 0;
+
+/** Errors that can occur around VR overlays */
+enum EVROverlayError
+{
+	VROverlayError_None = 0,
+
+	VROverlayError_UnknownOverlay = 10,
+	VROverlayError_InvalidHandle = 11,
+	VROverlayError_PermissionDenied = 12,
+	VROverlayError_OverlayLimitExceeded = 13,  // No more overlays could be created because the maximum number already exist
+	VROverlayError_WrongVisibilityType = 14,
+	VROverlayError_KeyTooLong = 15,
+	VROverlayError_NameTooLong = 16,
+	VROverlayError_KeyInUse = 17,
+	VROverlayError_WrongTransformType = 18,
+	VROverlayError_InvalidTrackedDevice = 19,
+	VROverlayError_InvalidParameter = 20,
+	VROverlayError_ThumbnailCantBeDestroyed = 21,
+	VROverlayError_ArrayTooSmall = 22,
+	VROverlayError_RequestFailed = 23,
+	VROverlayError_InvalidTexture = 24,
+	VROverlayError_UnableToLoadFile = 25,
+	VROverlayError_KeyboardAlreadyInUse = 26,
+	VROverlayError_NoNeighbor = 27,
+	VROverlayError_TooManyMaskPrimitives = 29,
+	VROverlayError_BadMaskPrimitive = 30,
+};
+
+/** enum values to pass in to VR_Init to identify whether the application will 
+* draw a 3D scene. */
+enum EVRApplicationType
+{
+	VRApplication_Other = 0,          // Some other kind of application that isn't covered by the other entries
+	VRApplication_Scene = 1,          // Application will submit 3D frames
+	VRApplication_Overlay = 2,        // Application only interacts with overlays
+	VRApplication_Background = 3,     // Application should not start SteamVR if it's not already running, and should not
+									  // keep it running if everything else quits.
+	VRApplication_Utility = 4,        // Init should not try to load any drivers. The application needs access to utility
+									  // interfaces (like IVRSettings and IVRApplications) but not hardware.
+	VRApplication_VRMonitor = 5,      // Reserved for vrmonitor
+	VRApplication_SteamWatchdog = 6,  // Reserved for Steam
+	VRApplication_Bootstrapper = 7,   // Start up SteamVR
+
+	VRApplication_Max
+};
+
+/** error codes for firmware */
+enum EVRFirmwareError
+{
+	VRFirmwareError_None = 0,
+	VRFirmwareError_Success = 1,
+	VRFirmwareError_Fail = 2,
+};
+
+/** error codes for notifications */
+enum EVRNotificationError
+{
+	VRNotificationError_OK = 0,
+	VRNotificationError_InvalidNotificationId = 100,
+	VRNotificationError_NotificationQueueFull = 101,
+	VRNotificationError_InvalidOverlayHandle = 102,
+	VRNotificationError_SystemWithUserValueAlreadyExists = 103,
+};
+
+/** error codes returned by Vr_Init */
+
+// Please add adequate error description to https://developer.valvesoftware.com/w/index.php?title=Category:SteamVRHelp
+enum EVRInitError
+{
+	VRInitError_None = 0,
+	VRInitError_Unknown = 1,
+
+	VRInitError_Init_InstallationNotFound = 100,
+	VRInitError_Init_InstallationCorrupt = 101,
+	VRInitError_Init_VRClientDLLNotFound = 102,
+	VRInitError_Init_FileNotFound = 103,
+	VRInitError_Init_FactoryNotFound = 104,
+	VRInitError_Init_InterfaceNotFound = 105,
+	VRInitError_Init_InvalidInterface = 106,
+	VRInitError_Init_UserConfigDirectoryInvalid = 107,
+	VRInitError_Init_HmdNotFound = 108,
+	VRInitError_Init_NotInitialized = 109,
+	VRInitError_Init_PathRegistryNotFound = 110,
+	VRInitError_Init_NoConfigPath = 111,
+	VRInitError_Init_NoLogPath = 112,
+	VRInitError_Init_PathRegistryNotWritable = 113,
+	VRInitError_Init_AppInfoInitFailed = 114,
+	VRInitError_Init_Retry = 115,               // Used internally to cause retries to vrserver
+	VRInitError_Init_InitCanceledByUser = 116,  // The calling application should silently exit. The user canceled app startup
+	VRInitError_Init_AnotherAppLaunching = 117,
+	VRInitError_Init_SettingsInitFailed = 118,
+	VRInitError_Init_ShuttingDown = 119,
+	VRInitError_Init_TooManyObjects = 120,
+	VRInitError_Init_NoServerForBackgroundApp = 121,
+	VRInitError_Init_NotSupportedWithCompositor = 122,
+	VRInitError_Init_NotAvailableToUtilityApps = 123,
+	VRInitError_Init_Internal = 124,
+	VRInitError_Init_HmdDriverIdIsNone = 125,
+	VRInitError_Init_HmdNotFoundPresenceFailed = 126,
+	VRInitError_Init_VRMonitorNotFound = 127,
+	VRInitError_Init_VRMonitorStartupFailed = 128,
+	VRInitError_Init_LowPowerWatchdogNotSupported = 129,
+	VRInitError_Init_InvalidApplicationType = 130,
+	VRInitError_Init_NotAvailableToWatchdogApps = 131,
+	VRInitError_Init_WatchdogDisabledInSettings = 132,
+	VRInitError_Init_VRDashboardNotFound = 133,
+	VRInitError_Init_VRDashboardStartupFailed = 134,
+	VRInitError_Init_VRHomeNotFound = 135,
+	VRInitError_Init_VRHomeStartupFailed = 136,
+	VRInitError_Init_RebootingBusy = 137,
+	VRInitError_Init_FirmwareUpdateBusy = 138,
+	VRInitError_Init_FirmwareRecoveryBusy = 139,
+
+	VRInitError_Driver_Failed = 200,
+	VRInitError_Driver_Unknown = 201,
+	VRInitError_Driver_HmdUnknown = 202,
+	VRInitError_Driver_NotLoaded = 203,
+	VRInitError_Driver_RuntimeOutOfDate = 204,
+	VRInitError_Driver_HmdInUse = 205,
+	VRInitError_Driver_NotCalibrated = 206,
+	VRInitError_Driver_CalibrationInvalid = 207,
+	VRInitError_Driver_HmdDisplayNotFound = 208,
+	VRInitError_Driver_TrackedDeviceInterfaceUnknown = 209,
+	// VRInitError_Driver_HmdDisplayNotFoundAfterFix = 210, // not needed: here for historic reasons
+	VRInitError_Driver_HmdDriverIdOutOfBounds = 211,
+	VRInitError_Driver_HmdDisplayMirrored = 212,
+
+	VRInitError_IPC_ServerInitFailed = 300,
+	VRInitError_IPC_ConnectFailed = 301,
+	VRInitError_IPC_SharedStateInitFailed = 302,
+	VRInitError_IPC_CompositorInitFailed = 303,
+	VRInitError_IPC_MutexInitFailed = 304,
+	VRInitError_IPC_Failed = 305,
+	VRInitError_IPC_CompositorConnectFailed = 306,
+	VRInitError_IPC_CompositorInvalidConnectResponse = 307,
+	VRInitError_IPC_ConnectFailedAfterMultipleAttempts = 308,
+
+	VRInitError_Compositor_Failed = 400,
+	VRInitError_Compositor_D3D11HardwareRequired = 401,
+	VRInitError_Compositor_FirmwareRequiresUpdate = 402,
+	VRInitError_Compositor_OverlayInitFailed = 403,
+	VRInitError_Compositor_ScreenshotsInitFailed = 404,
+	VRInitError_Compositor_UnableToCreateDevice = 405,
+
+	VRInitError_VendorSpecific_UnableToConnectToOculusRuntime = 1000,
+
+	VRInitError_VendorSpecific_HmdFound_CantOpenDevice = 1101,
+	VRInitError_VendorSpecific_HmdFound_UnableToRequestConfigStart = 1102,
+	VRInitError_VendorSpecific_HmdFound_NoStoredConfig = 1103,
+	VRInitError_VendorSpecific_HmdFound_ConfigTooBig = 1104,
+	VRInitError_VendorSpecific_HmdFound_ConfigTooSmall = 1105,
+	VRInitError_VendorSpecific_HmdFound_UnableToInitZLib = 1106,
+	VRInitError_VendorSpecific_HmdFound_CantReadFirmwareVersion = 1107,
+	VRInitError_VendorSpecific_HmdFound_UnableToSendUserDataStart = 1108,
+	VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataStart = 1109,
+	VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataNext = 1110,
+	VRInitError_VendorSpecific_HmdFound_UserDataAddressRange = 1111,
+	VRInitError_VendorSpecific_HmdFound_UserDataError = 1112,
+	VRInitError_VendorSpecific_HmdFound_ConfigFailedSanityCheck = 1113,
+
+	VRInitError_Steam_SteamInstallationNotFound = 2000,
+};
+
+enum EVRScreenshotType
+{
+	VRScreenshotType_None = 0,
+	VRScreenshotType_Mono = 1,  // left eye only
+	VRScreenshotType_Stereo = 2,
+	VRScreenshotType_Cubemap = 3,
+	VRScreenshotType_MonoPanorama = 4,
+	VRScreenshotType_StereoPanorama = 5
+};
+
+enum EVRScreenshotPropertyFilenames
+{
+	VRScreenshotPropertyFilenames_Preview = 0,
+	VRScreenshotPropertyFilenames_VR = 1,
+};
+
+enum EVRTrackedCameraError
+{
+	VRTrackedCameraError_None = 0,
+	VRTrackedCameraError_OperationFailed = 100,
+	VRTrackedCameraError_InvalidHandle = 101,
+	VRTrackedCameraError_InvalidFrameHeaderVersion = 102,
+	VRTrackedCameraError_OutOfHandles = 103,
+	VRTrackedCameraError_IPCFailure = 104,
+	VRTrackedCameraError_NotSupportedForThisDevice = 105,
+	VRTrackedCameraError_SharedMemoryFailure = 106,
+	VRTrackedCameraError_FrameBufferingFailure = 107,
+	VRTrackedCameraError_StreamSetupFailure = 108,
+	VRTrackedCameraError_InvalidGLTextureId = 109,
+	VRTrackedCameraError_InvalidSharedTextureHandle = 110,
+	VRTrackedCameraError_FailedToGetGLTextureId = 111,
+	VRTrackedCameraError_SharedTextureFailure = 112,
+	VRTrackedCameraError_NoFrameAvailable = 113,
+	VRTrackedCameraError_InvalidArgument = 114,
+	VRTrackedCameraError_InvalidFrameBufferSize = 115,
+};
+
+enum EVRTrackedCameraFrameType
+{
+	VRTrackedCameraFrameType_Distorted = 0,       // This is the camera video frame size in pixels, still distorted.
+	VRTrackedCameraFrameType_Undistorted,         // In pixels, an undistorted inscribed rectangle region without invalid regions. This size is subject to changes shortly.
+	VRTrackedCameraFrameType_MaximumUndistorted,  // In pixels, maximum undistorted with invalid regions. Non zero alpha component identifies valid regions.
+	MAX_CAMERA_FRAME_TYPES
+};
+
+typedef uint64_t TrackedCameraHandle_t;
+#define INVALID_TRACKED_CAMERA_HANDLE ((vr::TrackedCameraHandle_t)0)
+
+struct CameraVideoStreamFrameHeader_t
+{
+	EVRTrackedCameraFrameType eFrameType;
+
+	uint32_t nWidth;
+	uint32_t nHeight;
+	uint32_t nBytesPerPixel;
+
+	uint32_t nFrameSequence;
+
+	TrackedDevicePose_t standingTrackedDevicePose;
+};
+
+// Screenshot types
+typedef uint32_t ScreenshotHandle_t;
+
+static const uint32_t k_unScreenshotHandleInvalid = 0;
+
+#pragma pack(pop)
+
+// figure out how to import from the VR API dll
+#if defined(_WIN32)
+
+#ifdef VR_API_EXPORT
+#define VR_INTERFACE extern "C" __declspec(dllexport)
+#else
+#define VR_INTERFACE extern "C" __declspec(dllimport)
+#endif
+
+#elif defined(__GNUC__) || defined(COMPILER_GCC) || defined(__APPLE__)
+
+#ifdef VR_API_EXPORT
+#define VR_INTERFACE extern "C" __attribute__((visibility("default")))
+#else
+#define VR_INTERFACE extern "C"
+#endif
+
+#else
+#error "Unsupported Platform."
+#endif
+
+#if defined(_WIN32)
+#define VR_CALLTYPE __cdecl
+#else
+#define VR_CALLTYPE
+#endif
+
+}  // namespace vr
+
+#endif  // _INCLUDE_VRTYPES_H
+
+// vrannotation.h
+#ifdef API_GEN
+#define VR_CLANG_ATTR(ATTR) __attribute__((annotate(ATTR)))
+#else
+#define VR_CLANG_ATTR(ATTR)
+#endif
+
+#define VR_METHOD_DESC(DESC) VR_CLANG_ATTR("desc:" #DESC ";")
+#define VR_IGNOREATTR() VR_CLANG_ATTR("ignore")
+#define VR_OUT_STRUCT() VR_CLANG_ATTR("out_struct: ;")
+#define VR_OUT_STRING() VR_CLANG_ATTR("out_string: ;")
+#define VR_OUT_ARRAY_CALL(COUNTER, FUNCTION, PARAMS) VR_CLANG_ATTR("out_array_call:" #COUNTER "," #FUNCTION "," #PARAMS ";")
+#define VR_OUT_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR("out_array_count:" #COUNTER ";")
+#define VR_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR("array_count:" #COUNTER ";")
+#define VR_ARRAY_COUNT_D(COUNTER, DESC) VR_CLANG_ATTR("array_count:" #COUNTER ";desc:" #DESC)
+#define VR_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR("buffer_count:" #COUNTER ";")
+#define VR_OUT_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR("out_buffer_count:" #COUNTER ";")
+#define VR_OUT_STRING_COUNT(COUNTER) VR_CLANG_ATTR("out_string_count:" #COUNTER ";")
+
+// ivrsystem.h
+namespace vr
+{
+class IVRSystem
+{
+public:
+	// ------------------------------------
+	// Display Methods
+	// ------------------------------------
+
+	/** Suggested size for the intermediate render target that the distortion pulls from. */
+	virtual void GetRecommendedRenderTargetSize(uint32_t *pnWidth, uint32_t *pnHeight) = 0;
+
+	/** The projection matrix for the specified eye */
+	virtual HmdMatrix44_t GetProjectionMatrix(EVREye eEye, float fNearZ, float fFarZ) = 0;
+
+	/** The components necessary to build your own projection matrix in case your
+	* application is doing something fancy like infinite Z */
+	virtual void GetProjectionRaw(EVREye eEye, float *pfLeft, float *pfRight, float *pfTop, float *pfBottom) = 0;
+
+	/** Gets the result of the distortion function for the specified eye and input UVs. UVs go from 0,0 in 
+	* the upper left of that eye's viewport and 1,1 in the lower right of that eye's viewport.
+	* Returns true for success. Otherwise, returns false, and distortion coordinates are not suitable. */
+	virtual bool ComputeDistortion(EVREye eEye, float fU, float fV, DistortionCoordinates_t *pDistortionCoordinates) = 0;
+
+	/** Returns the transform from eye space to the head space. Eye space is the per-eye flavor of head
+	* space that provides stereo disparity. Instead of Model * View * Projection the sequence is Model * View * Eye^-1 * Projection. 
+	* Normally View and Eye^-1 will be multiplied together and treated as View in your application. 
+	*/
+	virtual HmdMatrix34_t GetEyeToHeadTransform(EVREye eEye) = 0;
+
+	/** Returns the number of elapsed seconds since the last recorded vsync event. This 
+	*	will come from a vsync timer event in the timer if possible or from the application-reported
+	*   time if that is not available. If no vsync times are available the function will 
+	*   return zero for vsync time and frame counter and return false from the method. */
+	virtual bool GetTimeSinceLastVsync(float *pfSecondsSinceLastVsync, uint64_t *pulFrameCounter) = 0;
+
+	/** [D3D9 Only]
+	* Returns the adapter index that the user should pass into CreateDevice to set up D3D9 in such
+	* a way that it can go full screen exclusive on the HMD. Returns -1 if there was an error.
+	*/
+	virtual int32_t GetD3D9AdapterIndex() = 0;
+
+	/** [D3D10/11 Only]
+	* Returns the adapter index that the user should pass into EnumAdapters to create the device 
+	* and swap chain in DX10 and DX11. If an error occurs the index will be set to -1.
+	*/
+	virtual void GetDXGIOutputInfo(int32_t *pnAdapterIndex) = 0;
+
+	/**
+	 * Returns platform- and texture-type specific adapter identification so that applications and the
+	 * compositor are creating textures and swap chains on the same GPU. If an error occurs the device
+	 * will be set to 0.
+	 * pInstance is an optional parameter that is required only when textureType is TextureType_Vulkan.
+	 * [D3D10/11/12 Only (D3D9 Not Supported)]
+	 *  Returns the adapter LUID that identifies the GPU attached to the HMD. The user should
+	 *  enumerate all adapters using IDXGIFactory::EnumAdapters and IDXGIAdapter::GetDesc to find
+	 *  the adapter with the matching LUID, or use IDXGIFactory4::EnumAdapterByLuid.
+	 *  The discovered IDXGIAdapter should be used to create the device and swap chain.
+	 * [Vulkan Only]
+	 *  Returns the VkPhysicalDevice that should be used by the application.
+	 *  pInstance must be the instance the application will use to query for the VkPhysicalDevice.  The application
+	 *  must create the VkInstance with extensions returned by IVRCompositor::GetVulkanInstanceExtensionsRequired enabled.
+	 * [macOS Only]
+	 *  Returns an id<MTLDevice> that should be used by the application.
+	 */
+	virtual void GetOutputDevice(uint64_t *pnDevice, ETextureType textureType, VkInstance_T *pInstance = nullptr) = 0;
+
+	// ------------------------------------
+	// Display Mode methods
+	// ------------------------------------
+
+	/** Use to determine if the headset display is part of the desktop (i.e. extended) or hidden (i.e. direct mode). */
+	virtual bool IsDisplayOnDesktop() = 0;
+
+	/** Set the display visibility (true = extended, false = direct mode).  Return value of true indicates that the change was successful. */
+	virtual bool SetDisplayVisibility(bool bIsVisibleOnDesktop) = 0;
+
+	// ------------------------------------
+	// Tracking Methods
+	// ------------------------------------
+
+	/** The pose that the tracker thinks that the HMD will be in at the specified number of seconds into the 
+	* future. Pass 0 to get the state at the instant the method is called. Most of the time the application should
+	* calculate the time until the photons will be emitted from the display and pass that time into the method.
+	*
+	* This is roughly analogous to the inverse of the view matrix in most applications, though 
+	* many games will need to do some additional rotation or translation on top of the rotation
+	* and translation provided by the head pose.
+	*
+	* For devices where bPoseIsValid is true the application can use the pose to position the device
+	* in question. The provided array can be any size up to k_unMaxTrackedDeviceCount. 
+	*
+	* Seated experiences should call this method with TrackingUniverseSeated and receive poses relative
+	* to the seated zero pose. Standing experiences should call this method with TrackingUniverseStanding 
+	* and receive poses relative to the Chaperone Play Area. TrackingUniverseRawAndUncalibrated should 
+	* probably not be used unless the application is the Chaperone calibration tool itself, but will provide
+	* poses relative to the hardware-specific coordinate system in the driver.
+	*/
+	virtual void GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, VR_ARRAY_COUNT(unTrackedDevicePoseArrayCount) TrackedDevicePose_t *pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = 0;
+
+	/** Sets the zero pose for the seated tracker coordinate system to the current position and yaw of the HMD. After 
+	* ResetSeatedZeroPose all GetDeviceToAbsoluteTrackingPose calls that pass TrackingUniverseSeated as the origin 
+	* will be relative to this new zero pose. The new zero coordinate system will not change the fact that the Y axis 
+	* is up in the real world, so the next pose returned from GetDeviceToAbsoluteTrackingPose after a call to 
+	* ResetSeatedZeroPose may not be exactly an identity matrix.
+	*
+	* NOTE: This function overrides the user's previously saved seated zero pose and should only be called as the result of a user action. 
+	* Users are also able to set their seated zero pose via the OpenVR Dashboard.
+	**/
+	virtual void ResetSeatedZeroPose() = 0;
+
+	/** Returns the transform from the seated zero pose to the standing absolute tracking system. This allows 
+	* applications to represent the seated origin to used or transform object positions from one coordinate
+	* system to the other. 
+	*
+	* The seated origin may or may not be inside the Play Area or Collision Bounds returned by IVRChaperone. Its position 
+	* depends on what the user has set from the Dashboard settings and previous calls to ResetSeatedZeroPose. */
+	virtual HmdMatrix34_t GetSeatedZeroPoseToStandingAbsoluteTrackingPose() = 0;
+
+	/** Returns the transform from the tracking origin to the standing absolute tracking system. This allows
+	* applications to convert from raw tracking space to the calibrated standing coordinate system. */
+	virtual HmdMatrix34_t GetRawZeroPoseToStandingAbsoluteTrackingPose() = 0;
+
+	/** Get a sorted array of device indices of a given class of tracked devices (e.g. controllers).  Devices are sorted right to left
+	* relative to the specified tracked device (default: hmd -- pass in -1 for absolute tracking space).  Returns the number of devices
+	* in the list, or the size of the array needed if not large enough. */
+	virtual uint32_t GetSortedTrackedDeviceIndicesOfClass(ETrackedDeviceClass eTrackedDeviceClass, VR_ARRAY_COUNT(unTrackedDeviceIndexArrayCount) vr::TrackedDeviceIndex_t *punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, vr::TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex = k_unTrackedDeviceIndex_Hmd) = 0;
+
+	/** Returns the level of activity on the device. */
+	virtual EDeviceActivityLevel GetTrackedDeviceActivityLevel(vr::TrackedDeviceIndex_t unDeviceId) = 0;
+
+	/** Convenience utility to apply the specified transform to the specified pose.
+	*   This properly transforms all pose components, including velocity and angular velocity
+	*/
+	virtual void ApplyTransform(TrackedDevicePose_t *pOutputPose, const TrackedDevicePose_t *pTrackedDevicePose, const HmdMatrix34_t *pTransform) = 0;
+
+	/** Returns the device index associated with a specific role, for example the left hand or the right hand. */
+	virtual vr::TrackedDeviceIndex_t GetTrackedDeviceIndexForControllerRole(vr::ETrackedControllerRole unDeviceType) = 0;
+
+	/** Returns the controller type associated with a device index. */
+	virtual vr::ETrackedControllerRole GetControllerRoleForTrackedDeviceIndex(vr::TrackedDeviceIndex_t unDeviceIndex) = 0;
+
+	// ------------------------------------
+	// Property methods
+	// ------------------------------------
+
+	/** Returns the device class of a tracked device. If there has not been a device connected in this slot
+	* since the application started this function will return TrackedDevice_Invalid. For previous detected
+	* devices the function will return the previously observed device class. 
+	*
+	* To determine which devices exist on the system, just loop from 0 to k_unMaxTrackedDeviceCount and check
+	* the device class. Every device with something other than TrackedDevice_Invalid is associated with an 
+	* actual tracked device. */
+	virtual ETrackedDeviceClass GetTrackedDeviceClass(vr::TrackedDeviceIndex_t unDeviceIndex) = 0;
+
+	/** Returns true if there is a device connected in this slot. */
+	virtual bool IsTrackedDeviceConnected(vr::TrackedDeviceIndex_t unDeviceIndex) = 0;
+
+	/** Returns a bool property. If the device index is not valid or the property is not a bool type this function will return false. */
+	virtual bool GetBoolTrackedDeviceProperty(vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L) = 0;
+
+	/** Returns a float property. If the device index is not valid or the property is not a float type this function will return 0. */
+	virtual float GetFloatTrackedDeviceProperty(vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L) = 0;
+
+	/** Returns an int property. If the device index is not valid or the property is not a int type this function will return 0. */
+	virtual int32_t GetInt32TrackedDeviceProperty(vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L) = 0;
+
+	/** Returns a uint64 property. If the device index is not valid or the property is not a uint64 type this function will return 0. */
+	virtual uint64_t GetUint64TrackedDeviceProperty(vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L) = 0;
+
+	/** Returns a matrix property. If the device index is not valid or the property is not a matrix type, this function will return identity. */
+	virtual HmdMatrix34_t GetMatrix34TrackedDeviceProperty(vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L) = 0;
+
+	/** Returns a string property. If the device index is not valid or the property is not a string type this function will 
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters. */
+	virtual uint32_t GetStringTrackedDeviceProperty(vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError = 0L) = 0;
+
+	/** returns a string that corresponds with the specified property error. The string will be the name 
+	* of the error enum value for all valid error codes */
+	virtual const char *GetPropErrorNameFromEnum(ETrackedPropertyError error) = 0;
+
+	// ------------------------------------
+	// Event methods
+	// ------------------------------------
+
+	/** Returns true and fills the event with the next event on the queue if there is one. If there are no events
+	* this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct */
+	virtual bool PollNextEvent(VREvent_t *pEvent, uint32_t uncbVREvent) = 0;
+
+	/** Returns true and fills the event with the next event on the queue if there is one. If there are no events
+	* this method returns false. Fills in the pose of the associated tracked device in the provided pose struct. 
+	* This pose will always be older than the call to this function and should not be used to render the device. 
+	uncbVREvent should be the size in bytes of the VREvent_t struct */
+	virtual bool PollNextEventWithPose(ETrackingUniverseOrigin eOrigin, VREvent_t *pEvent, uint32_t uncbVREvent, vr::TrackedDevicePose_t *pTrackedDevicePose) = 0;
+
+	/** returns the name of an EVREvent enum value */
+	virtual const char *GetEventTypeNameFromEnum(EVREventType eType) = 0;
+
+	// ------------------------------------
+	// Rendering helper methods
+	// ------------------------------------
+
+	/** Returns the hidden area mesh for the current HMD. The pixels covered by this mesh will never be seen by the user after the lens distortion is
+	* applied based on visibility to the panels. If this HMD does not have a hidden area mesh, the vertex data and count will be NULL and 0 respectively.
+	* This mesh is meant to be rendered into the stencil buffer (or into the depth buffer setting nearz) before rendering each eye's view. 
+	* This will improve performance by letting the GPU early-reject pixels the user will never see before running the pixel shader.
+	* NOTE: Render this mesh with backface culling disabled since the winding order of the vertices can be different per-HMD or per-eye.
+	* Setting the bInverse argument to true will produce the visible area mesh that is commonly used in place of full-screen quads. The visible area mesh covers all of the pixels the hidden area mesh does not cover.
+	* Setting the bLineLoop argument will return a line loop of vertices in HiddenAreaMesh_t->pVertexData with HiddenAreaMesh_t->unTriangleCount set to the number of vertices.
+	*/
+	virtual HiddenAreaMesh_t GetHiddenAreaMesh(EVREye eEye, EHiddenAreaMeshType type = k_eHiddenAreaMesh_Standard) = 0;
+
+	// ------------------------------------
+	// Controller methods
+	// ------------------------------------
+
+	/** Fills the supplied struct with the current state of the controller. Returns false if the controller index
+	* is invalid. */
+	virtual bool GetControllerState(vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize) = 0;
+
+	/** fills the supplied struct with the current state of the controller and the provided pose with the pose of 
+	* the controller when the controller state was updated most recently. Use this form if you need a precise controller
+	* pose as input to your application when the user presses or releases a button. */
+	virtual bool GetControllerStateWithPose(ETrackingUniverseOrigin eOrigin, vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose) = 0;
+
+	/** Trigger a single haptic pulse on a controller. After this call the application may not trigger another haptic pulse on this controller
+	* and axis combination for 5ms. */
+	virtual void TriggerHapticPulse(vr::TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = 0;
+
+	/** returns the name of an EVRButtonId enum value */
+	virtual const char *GetButtonIdNameFromEnum(EVRButtonId eButtonId) = 0;
+
+	/** returns the name of an EVRControllerAxisType enum value */
+	virtual const char *GetControllerAxisTypeNameFromEnum(EVRControllerAxisType eAxisType) = 0;
+
+	/** Tells OpenVR that this process wants exclusive access to controller button states and button events. Other apps will be notified that 
+	* they have lost input focus with a VREvent_InputFocusCaptured event. Returns false if input focus could not be captured for
+	* some reason. */
+	virtual bool CaptureInputFocus() = 0;
+
+	/** Tells OpenVR that this process no longer wants exclusive access to button states and button events. Other apps will be notified 
+	* that input focus has been released with a VREvent_InputFocusReleased event. */
+	virtual void ReleaseInputFocus() = 0;
+
+	/** Returns true if input focus is captured by another process. */
+	virtual bool IsInputFocusCapturedByAnotherProcess() = 0;
+
+	// ------------------------------------
+	// Debug Methods
+	// ------------------------------------
+
+	/** Sends a request to the driver for the specified device and returns the response. The maximum response size is 32k,
+	* but this method can be called with a smaller buffer. If the response exceeds the size of the buffer, it is truncated. 
+	* The size of the response including its terminating null is returned. */
+	virtual uint32_t DriverDebugRequest(vr::TrackedDeviceIndex_t unDeviceIndex, const char *pchRequest, char *pchResponseBuffer, uint32_t unResponseBufferSize) = 0;
+
+	// ------------------------------------
+	// Firmware methods
+	// ------------------------------------
+
+	/** Performs the actual firmware update if applicable. 
+	 * The following events will be sent, if VRFirmwareError_None was returned: VREvent_FirmwareUpdateStarted, VREvent_FirmwareUpdateFinished 
+	 * Use the properties Prop_Firmware_UpdateAvailable_Bool, Prop_Firmware_ManualUpdate_Bool, and Prop_Firmware_ManualUpdateURL_String
+	 * to figure our whether a firmware update is available, and to figure out whether its a manual update 
+	 * Prop_Firmware_ManualUpdateURL_String should point to an URL describing the manual update process */
+	virtual vr::EVRFirmwareError PerformFirmwareUpdate(vr::TrackedDeviceIndex_t unDeviceIndex) = 0;
+
+	// ------------------------------------
+	// Application life cycle methods
+	// ------------------------------------
+
+	/** Call this to acknowledge to the system that VREvent_Quit has been received and that the process is exiting.
+	* This extends the timeout until the process is killed. */
+	virtual void AcknowledgeQuit_Exiting() = 0;
+
+	/** Call this to tell the system that the user is being prompted to save data. This
+	* halts the timeout and dismisses the dashboard (if it was up). Applications should be sure to actually 
+	* prompt the user to save and then exit afterward, otherwise the user will be left in a confusing state. */
+	virtual void AcknowledgeQuit_UserPrompt() = 0;
+};
+
+static const char *const IVRSystem_Version = "IVRSystem_017";
+
+}  // namespace vr
+
+// ivrapplications.h
+namespace vr
+{
+/** Used for all errors reported by the IVRApplications interface */
+enum EVRApplicationError
+{
+	VRApplicationError_None = 0,
+
+	VRApplicationError_AppKeyAlreadyExists = 100,  // Only one application can use any given key
+	VRApplicationError_NoManifest = 101,           // the running application does not have a manifest
+	VRApplicationError_NoApplication = 102,        // No application is running
+	VRApplicationError_InvalidIndex = 103,
+	VRApplicationError_UnknownApplication = 104,  // the application could not be found
+	VRApplicationError_IPCFailed = 105,           // An IPC failure caused the request to fail
+	VRApplicationError_ApplicationAlreadyRunning = 106,
+	VRApplicationError_InvalidManifest = 107,
+	VRApplicationError_InvalidApplication = 108,
+	VRApplicationError_LaunchFailed = 109,                // the process didn't start
+	VRApplicationError_ApplicationAlreadyStarting = 110,  // the system was already starting the same application
+	VRApplicationError_LaunchInProgress = 111,            // The system was already starting a different application
+	VRApplicationError_OldApplicationQuitting = 112,
+	VRApplicationError_TransitionAborted = 113,
+	VRApplicationError_IsTemplate = 114,  // error when you try to call LaunchApplication() on a template type app (use LaunchTemplateApplication)
+	VRApplicationError_SteamVRIsExiting = 115,
+
+	VRApplicationError_BufferTooSmall = 200,  // The provided buffer was too small to fit the requested data
+	VRApplicationError_PropertyNotSet = 201,  // The requested property was not set
+	VRApplicationError_UnknownProperty = 202,
+	VRApplicationError_InvalidParameter = 203,
+};
+
+/** The maximum length of an application key */
+static const uint32_t k_unMaxApplicationKeyLength = 128;
+
+/** these are the properties available on applications. */
+enum EVRApplicationProperty
+{
+	VRApplicationProperty_Name_String = 0,
+
+	VRApplicationProperty_LaunchType_String = 11,
+	VRApplicationProperty_WorkingDirectory_String = 12,
+	VRApplicationProperty_BinaryPath_String = 13,
+	VRApplicationProperty_Arguments_String = 14,
+	VRApplicationProperty_URL_String = 15,
+
+	VRApplicationProperty_Description_String = 50,
+	VRApplicationProperty_NewsURL_String = 51,
+	VRApplicationProperty_ImagePath_String = 52,
+	VRApplicationProperty_Source_String = 53,
+
+	VRApplicationProperty_IsDashboardOverlay_Bool = 60,
+	VRApplicationProperty_IsTemplate_Bool = 61,
+	VRApplicationProperty_IsInstanced_Bool = 62,
+	VRApplicationProperty_IsInternal_Bool = 63,
+	VRApplicationProperty_WantsCompositorPauseInStandby_Bool = 64,
+
+	VRApplicationProperty_LastLaunchTime_Uint64 = 70,
+};
+
+/** These are states the scene application startup process will go through. */
+enum EVRApplicationTransitionState
+{
+	VRApplicationTransition_None = 0,
+
+	VRApplicationTransition_OldAppQuitSent = 10,
+	VRApplicationTransition_WaitingForExternalLaunch = 11,
+
+	VRApplicationTransition_NewAppLaunched = 20,
+};
+
+struct AppOverrideKeys_t
+{
+	const char *pchKey;
+	const char *pchValue;
+};
+
+/** Currently recognized mime types */
+static const char *const k_pch_MimeType_HomeApp = "vr/home";
+static const char *const k_pch_MimeType_GameTheater = "vr/game_theater";
+
+class IVRApplications
+{
+public:
+	// ---------------  Application management  --------------- //
+
+	/** Adds an application manifest to the list to load when building the list of installed applications. 
+		* Temporary manifests are not automatically loaded */
+	virtual EVRApplicationError AddApplicationManifest(const char *pchApplicationManifestFullPath, bool bTemporary = false) = 0;
+
+	/** Removes an application manifest from the list to load when building the list of installed applications. */
+	virtual EVRApplicationError RemoveApplicationManifest(const char *pchApplicationManifestFullPath) = 0;
+
+	/** Returns true if an application is installed */
+	virtual bool IsApplicationInstalled(const char *pchAppKey) = 0;
+
+	/** Returns the number of applications available in the list */
+	virtual uint32_t GetApplicationCount() = 0;
+
+	/** Returns the key of the specified application. The index is at least 0 and is less than the return 
+		* value of GetApplicationCount(). The buffer should be at least k_unMaxApplicationKeyLength in order to 
+		* fit the key. */
+	virtual EVRApplicationError GetApplicationKeyByIndex(uint32_t unApplicationIndex, VR_OUT_STRING() char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = 0;
+
+	/** Returns the key of the application for the specified Process Id. The buffer should be at least 
+		* k_unMaxApplicationKeyLength in order to fit the key. */
+	virtual EVRApplicationError GetApplicationKeyByProcessId(uint32_t unProcessId, char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = 0;
+
+	/** Launches the application. The existing scene application will exit and then the new application will start.
+		* This call is not valid for dashboard overlay applications. */
+	virtual EVRApplicationError LaunchApplication(const char *pchAppKey) = 0;
+
+	/** Launches an instance of an application of type template, with its app key being pchNewAppKey (which must be unique) and optionally override sections
+		* from the manifest file via AppOverrideKeys_t
+		*/
+	virtual EVRApplicationError LaunchTemplateApplication(const char *pchTemplateAppKey, const char *pchNewAppKey, VR_ARRAY_COUNT(unKeys) const AppOverrideKeys_t *pKeys, uint32_t unKeys) = 0;
+
+	/** launches the application currently associated with this mime type and passes it the option args, typically the filename or object name of the item being launched */
+	virtual vr::EVRApplicationError LaunchApplicationFromMimeType(const char *pchMimeType, const char *pchArgs) = 0;
+
+	/** Launches the dashboard overlay application if it is not already running. This call is only valid for 
+		* dashboard overlay applications. */
+	virtual EVRApplicationError LaunchDashboardOverlay(const char *pchAppKey) = 0;
+
+	/** Cancel a pending launch for an application */
+	virtual bool CancelApplicationLaunch(const char *pchAppKey) = 0;
+
+	/** Identifies a running application. OpenVR can't always tell which process started in response
+		* to a URL. This function allows a URL handler (or the process itself) to identify the app key 
+		* for the now running application. Passing a process ID of 0 identifies the calling process. 
+		* The application must be one that's known to the system via a call to AddApplicationManifest. */
+	virtual EVRApplicationError IdentifyApplication(uint32_t unProcessId, const char *pchAppKey) = 0;
+
+	/** Returns the process ID for an application. Return 0 if the application was not found or is not running. */
+	virtual uint32_t GetApplicationProcessId(const char *pchAppKey) = 0;
+
+	/** Returns a string for an applications error */
+	virtual const char *GetApplicationsErrorNameFromEnum(EVRApplicationError error) = 0;
+
+	// ---------------  Application properties  --------------- //
+
+	/** Returns a value for an application property. The required buffer size to fit this value will be returned. */
+	virtual uint32_t GetApplicationPropertyString(const char *pchAppKey, EVRApplicationProperty eProperty, VR_OUT_STRING() char *pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError *peError = nullptr) = 0;
+
+	/** Returns a bool value for an application property. Returns false in all error cases. */
+	virtual bool GetApplicationPropertyBool(const char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError = nullptr) = 0;
+
+	/** Returns a uint64 value for an application property. Returns 0 in all error cases. */
+	virtual uint64_t GetApplicationPropertyUint64(const char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError = nullptr) = 0;
+
+	/** Sets the application auto-launch flag. This is only valid for applications which return true for VRApplicationProperty_IsDashboardOverlay_Bool. */
+	virtual EVRApplicationError SetApplicationAutoLaunch(const char *pchAppKey, bool bAutoLaunch) = 0;
+
+	/** Gets the application auto-launch flag. This is only valid for applications which return true for VRApplicationProperty_IsDashboardOverlay_Bool. */
+	virtual bool GetApplicationAutoLaunch(const char *pchAppKey) = 0;
+
+	/** Adds this mime-type to the list of supported mime types for this application*/
+	virtual EVRApplicationError SetDefaultApplicationForMimeType(const char *pchAppKey, const char *pchMimeType) = 0;
+
+	/** return the app key that will open this mime type */
+	virtual bool GetDefaultApplicationForMimeType(const char *pchMimeType, char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = 0;
+
+	/** Get the list of supported mime types for this application, comma-delimited */
+	virtual bool GetApplicationSupportedMimeTypes(const char *pchAppKey, char *pchMimeTypesBuffer, uint32_t unMimeTypesBuffer) = 0;
+
+	/** Get the list of app-keys that support this mime type, comma-delimited, the return value is number of bytes you need to return the full string */
+	virtual uint32_t GetApplicationsThatSupportMimeType(const char *pchMimeType, char *pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer) = 0;
+
+	/** Get the args list from an app launch that had the process already running, you call this when you get a VREvent_ApplicationMimeTypeLoad */
+	virtual uint32_t GetApplicationLaunchArguments(uint32_t unHandle, char *pchArgs, uint32_t unArgs) = 0;
+
+	// ---------------  Transition methods --------------- //
+
+	/** Returns the app key for the application that is starting up */
+	virtual EVRApplicationError GetStartingApplication(char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = 0;
+
+	/** Returns the application transition state */
+	virtual EVRApplicationTransitionState GetTransitionState() = 0;
+
+	/** Returns errors that would prevent the specified application from launching immediately. Calling this function will
+		* cause the current scene application to quit, so only call it when you are actually about to launch something else.
+		* What the caller should do about these failures depends on the failure:
+		*   VRApplicationError_OldApplicationQuitting - An existing application has been told to quit. Wait for a VREvent_ProcessQuit
+		*                                               and try again.
+		*   VRApplicationError_ApplicationAlreadyStarting - This application is already starting. This is a permanent failure.
+		*   VRApplicationError_LaunchInProgress	      - A different application is already starting. This is a permanent failure.
+		*   VRApplicationError_None                   - Go ahead and launch. Everything is clear.
+		*/
+	virtual EVRApplicationError PerformApplicationPrelaunchCheck(const char *pchAppKey) = 0;
+
+	/** Returns a string for an application transition state */
+	virtual const char *GetApplicationsTransitionStateNameFromEnum(EVRApplicationTransitionState state) = 0;
+
+	/** Returns true if the outgoing scene app has requested a save prompt before exiting */
+	virtual bool IsQuitUserPromptRequested() = 0;
+
+	/** Starts a subprocess within the calling application. This
+		* suppresses all application transition UI and automatically identifies the new executable 
+		* as part of the same application. On success the calling process should exit immediately. 
+		* If working directory is NULL or "" the directory portion of the binary path will be 
+		* the working directory. */
+	virtual EVRApplicationError LaunchInternalProcess(const char *pchBinaryPath, const char *pchArguments, const char *pchWorkingDirectory) = 0;
+
+	/** Returns the current scene process ID according to the application system. A scene process will get scene
+		* focus once it starts rendering, but it will appear here once it calls VR_Init with the Scene application
+		* type. */
+	virtual uint32_t GetCurrentSceneProcessId() = 0;
+};
+
+static const char *const IVRApplications_Version = "IVRApplications_006";
+
+}  // namespace vr
+
+// ivrsettings.h
+namespace vr
+{
+enum EVRSettingsError
+{
+	VRSettingsError_None = 0,
+	VRSettingsError_IPCFailed = 1,
+	VRSettingsError_WriteFailed = 2,
+	VRSettingsError_ReadFailed = 3,
+	VRSettingsError_JsonParseFailed = 4,
+	VRSettingsError_UnsetSettingHasNoDefault = 5,  // This will be returned if the setting does not appear in the appropriate default file and has not been set
+};
+
+// The maximum length of a settings key
+static const uint32_t k_unMaxSettingsKeyLength = 128;
+
+class IVRSettings
+{
+public:
+	virtual const char *GetSettingsErrorNameFromEnum(EVRSettingsError eError) = 0;
+
+	// Returns true if file sync occurred (force or settings dirty)
+	virtual bool Sync(bool bForce = false, EVRSettingsError *peError = nullptr) = 0;
+
+	virtual void SetBool(const char *pchSection, const char *pchSettingsKey, bool bValue, EVRSettingsError *peError = nullptr) = 0;
+	virtual void SetInt32(const char *pchSection, const char *pchSettingsKey, int32_t nValue, EVRSettingsError *peError = nullptr) = 0;
+	virtual void SetFloat(const char *pchSection, const char *pchSettingsKey, float flValue, EVRSettingsError *peError = nullptr) = 0;
+	virtual void SetString(const char *pchSection, const char *pchSettingsKey, const char *pchValue, EVRSettingsError *peError = nullptr) = 0;
+
+	// Users of the system need to provide a proper default in default.vrsettings in the resources/settings/ directory
+	// of either the runtime or the driver_xxx directory. Otherwise the default will be false, 0, 0.0 or ""
+	virtual bool GetBool(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+	virtual int32_t GetInt32(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+	virtual float GetFloat(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+	virtual void GetString(const char *pchSection, const char *pchSettingsKey, VR_OUT_STRING() char *pchValue, uint32_t unValueLen, EVRSettingsError *peError = nullptr) = 0;
+
+	virtual void RemoveSection(const char *pchSection, EVRSettingsError *peError = nullptr) = 0;
+	virtual void RemoveKeyInSection(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+};
+
+//-----------------------------------------------------------------------------
+static const char *const IVRSettings_Version = "IVRSettings_002";
+
+//-----------------------------------------------------------------------------
+// steamvr keys
+static const char *const k_pch_SteamVR_Section = "steamvr";
+static const char *const k_pch_SteamVR_RequireHmd_String = "requireHmd";
+static const char *const k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver";
+static const char *const k_pch_SteamVR_ForcedHmdKey_String = "forcedHmd";
+static const char *const k_pch_SteamVR_DisplayDebug_Bool = "displayDebug";
+static const char *const k_pch_SteamVR_DebugProcessPipe_String = "debugProcessPipe";
+static const char *const k_pch_SteamVR_DisplayDebugX_Int32 = "displayDebugX";
+static const char *const k_pch_SteamVR_DisplayDebugY_Int32 = "displayDebugY";
+static const char *const k_pch_SteamVR_SendSystemButtonToAllApps_Bool = "sendSystemButtonToAllApps";
+static const char *const k_pch_SteamVR_LogLevel_Int32 = "loglevel";
+static const char *const k_pch_SteamVR_IPD_Float = "ipd";
+static const char *const k_pch_SteamVR_Background_String = "background";
+static const char *const k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection";
+static const char *const k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight";
+static const char *const k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius";
+static const char *const k_pch_SteamVR_GridColor_String = "gridColor";
+static const char *const k_pch_SteamVR_PlayAreaColor_String = "playAreaColor";
+static const char *const k_pch_SteamVR_ShowStage_Bool = "showStage";
+static const char *const k_pch_SteamVR_ActivateMultipleDrivers_Bool = "activateMultipleDrivers";
+static const char *const k_pch_SteamVR_DirectMode_Bool = "directMode";
+static const char *const k_pch_SteamVR_DirectModeEdidVid_Int32 = "directModeEdidVid";
+static const char *const k_pch_SteamVR_DirectModeEdidPid_Int32 = "directModeEdidPid";
+static const char *const k_pch_SteamVR_UsingSpeakers_Bool = "usingSpeakers";
+static const char *const k_pch_SteamVR_SpeakersForwardYawOffsetDegrees_Float = "speakersForwardYawOffsetDegrees";
+static const char *const k_pch_SteamVR_BaseStationPowerManagement_Bool = "basestationPowerManagement";
+static const char *const k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses";
+static const char *const k_pch_SteamVR_SupersampleScale_Float = "supersampleScale";
+static const char *const k_pch_SteamVR_AllowAsyncReprojection_Bool = "allowAsyncReprojection";
+static const char *const k_pch_SteamVR_AllowReprojection_Bool = "allowInterleavedReprojection";
+static const char *const k_pch_SteamVR_ForceReprojection_Bool = "forceReprojection";
+static const char *const k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking";
+static const char *const k_pch_SteamVR_DefaultMirrorView_Int32 = "defaultMirrorView";
+static const char *const k_pch_SteamVR_ShowMirrorView_Bool = "showMirrorView";
+static const char *const k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry";
+static const char *const k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch";
+static const char *const k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch";
+static const char *const k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch";
+static const char *const k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard";
+static const char *const k_pch_SteamVR_EnableHomeApp = "enableHomeApp";
+static const char *const k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec";
+static const char *const k_pch_SteamVR_RetailDemo_Bool = "retailDemo";
+static const char *const k_pch_SteamVR_IpdOffset_Float = "ipdOffset";
+static const char *const k_pch_SteamVR_AllowSupersampleFiltering_Bool = "allowSupersampleFiltering";
+static const char *const k_pch_SteamVR_EnableLinuxVulkanAsync_Bool = "enableLinuxVulkanAsync";
+
+//-----------------------------------------------------------------------------
+// lighthouse keys
+static const char *const k_pch_Lighthouse_Section = "driver_lighthouse";
+static const char *const k_pch_Lighthouse_DisableIMU_Bool = "disableimu";
+static const char *const k_pch_Lighthouse_UseDisambiguation_String = "usedisambiguation";
+static const char *const k_pch_Lighthouse_DisambiguationDebug_Int32 = "disambiguationdebug";
+static const char *const k_pch_Lighthouse_PrimaryBasestation_Int32 = "primarybasestation";
+static const char *const k_pch_Lighthouse_DBHistory_Bool = "dbhistory";
+
+//-----------------------------------------------------------------------------
+// null keys
+static const char *const k_pch_Null_Section = "driver_null";
+static const char *const k_pch_Null_SerialNumber_String = "serialNumber";
+static const char *const k_pch_Null_ModelNumber_String = "modelNumber";
+static const char *const k_pch_Null_WindowX_Int32 = "windowX";
+static const char *const k_pch_Null_WindowY_Int32 = "windowY";
+static const char *const k_pch_Null_WindowWidth_Int32 = "windowWidth";
+static const char *const k_pch_Null_WindowHeight_Int32 = "windowHeight";
+static const char *const k_pch_Null_RenderWidth_Int32 = "renderWidth";
+static const char *const k_pch_Null_RenderHeight_Int32 = "renderHeight";
+static const char *const k_pch_Null_SecondsFromVsyncToPhotons_Float = "secondsFromVsyncToPhotons";
+static const char *const k_pch_Null_DisplayFrequency_Float = "displayFrequency";
+
+//-----------------------------------------------------------------------------
+// user interface keys
+static const char *const k_pch_UserInterface_Section = "userinterface";
+static const char *const k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop";
+static const char *const k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray";
+static const char *const k_pch_UserInterface_Screenshots_Bool = "screenshots";
+static const char *const k_pch_UserInterface_ScreenshotType_Int = "screenshotType";
+
+//-----------------------------------------------------------------------------
+// notification keys
+static const char *const k_pch_Notifications_Section = "notifications";
+static const char *const k_pch_Notifications_DoNotDisturb_Bool = "DoNotDisturb";
+
+//-----------------------------------------------------------------------------
+// keyboard keys
+static const char *const k_pch_Keyboard_Section = "keyboard";
+static const char *const k_pch_Keyboard_TutorialCompletions = "TutorialCompletions";
+static const char *const k_pch_Keyboard_ScaleX = "ScaleX";
+static const char *const k_pch_Keyboard_ScaleY = "ScaleY";
+static const char *const k_pch_Keyboard_OffsetLeftX = "OffsetLeftX";
+static const char *const k_pch_Keyboard_OffsetRightX = "OffsetRightX";
+static const char *const k_pch_Keyboard_OffsetY = "OffsetY";
+static const char *const k_pch_Keyboard_Smoothing = "Smoothing";
+
+//-----------------------------------------------------------------------------
+// perf keys
+static const char *const k_pch_Perf_Section = "perfcheck";
+static const char *const k_pch_Perf_HeuristicActive_Bool = "heuristicActive";
+static const char *const k_pch_Perf_NotifyInHMD_Bool = "warnInHMD";
+static const char *const k_pch_Perf_NotifyOnlyOnce_Bool = "warnOnlyOnce";
+static const char *const k_pch_Perf_AllowTimingStore_Bool = "allowTimingStore";
+static const char *const k_pch_Perf_SaveTimingsOnExit_Bool = "saveTimingsOnExit";
+static const char *const k_pch_Perf_TestData_Float = "perfTestData";
+static const char *const k_pch_Perf_LinuxGPUProfiling_Bool = "linuxGPUProfiling";
+
+//-----------------------------------------------------------------------------
+// collision bounds keys
+static const char *const k_pch_CollisionBounds_Section = "collisionBounds";
+static const char *const k_pch_CollisionBounds_Style_Int32 = "CollisionBoundsStyle";
+static const char *const k_pch_CollisionBounds_GroundPerimeterOn_Bool = "CollisionBoundsGroundPerimeterOn";
+static const char *const k_pch_CollisionBounds_CenterMarkerOn_Bool = "CollisionBoundsCenterMarkerOn";
+static const char *const k_pch_CollisionBounds_PlaySpaceOn_Bool = "CollisionBoundsPlaySpaceOn";
+static const char *const k_pch_CollisionBounds_FadeDistance_Float = "CollisionBoundsFadeDistance";
+static const char *const k_pch_CollisionBounds_ColorGammaR_Int32 = "CollisionBoundsColorGammaR";
+static const char *const k_pch_CollisionBounds_ColorGammaG_Int32 = "CollisionBoundsColorGammaG";
+static const char *const k_pch_CollisionBounds_ColorGammaB_Int32 = "CollisionBoundsColorGammaB";
+static const char *const k_pch_CollisionBounds_ColorGammaA_Int32 = "CollisionBoundsColorGammaA";
+
+//-----------------------------------------------------------------------------
+// camera keys
+static const char *const k_pch_Camera_Section = "camera";
+static const char *const k_pch_Camera_EnableCamera_Bool = "enableCamera";
+static const char *const k_pch_Camera_EnableCameraInDashboard_Bool = "enableCameraInDashboard";
+static const char *const k_pch_Camera_EnableCameraForCollisionBounds_Bool = "enableCameraForCollisionBounds";
+static const char *const k_pch_Camera_EnableCameraForRoomView_Bool = "enableCameraForRoomView";
+static const char *const k_pch_Camera_BoundsColorGammaR_Int32 = "cameraBoundsColorGammaR";
+static const char *const k_pch_Camera_BoundsColorGammaG_Int32 = "cameraBoundsColorGammaG";
+static const char *const k_pch_Camera_BoundsColorGammaB_Int32 = "cameraBoundsColorGammaB";
+static const char *const k_pch_Camera_BoundsColorGammaA_Int32 = "cameraBoundsColorGammaA";
+static const char *const k_pch_Camera_BoundsStrength_Int32 = "cameraBoundsStrength";
+
+//-----------------------------------------------------------------------------
+// audio keys
+static const char *const k_pch_audio_Section = "audio";
+static const char *const k_pch_audio_OnPlaybackDevice_String = "onPlaybackDevice";
+static const char *const k_pch_audio_OnRecordDevice_String = "onRecordDevice";
+static const char *const k_pch_audio_OnPlaybackMirrorDevice_String = "onPlaybackMirrorDevice";
+static const char *const k_pch_audio_OffPlaybackDevice_String = "offPlaybackDevice";
+static const char *const k_pch_audio_OffRecordDevice_String = "offRecordDevice";
+static const char *const k_pch_audio_VIVEHDMIGain = "viveHDMIGain";
+
+//-----------------------------------------------------------------------------
+// power management keys
+static const char *const k_pch_Power_Section = "power";
+static const char *const k_pch_Power_PowerOffOnExit_Bool = "powerOffOnExit";
+static const char *const k_pch_Power_TurnOffScreensTimeout_Float = "turnOffScreensTimeout";
+static const char *const k_pch_Power_TurnOffControllersTimeout_Float = "turnOffControllersTimeout";
+static const char *const k_pch_Power_ReturnToWatchdogTimeout_Float = "returnToWatchdogTimeout";
+static const char *const k_pch_Power_AutoLaunchSteamVROnButtonPress = "autoLaunchSteamVROnButtonPress";
+static const char *const k_pch_Power_PauseCompositorOnStandby_Bool = "pauseCompositorOnStandby";
+
+//-----------------------------------------------------------------------------
+// dashboard keys
+static const char *const k_pch_Dashboard_Section = "dashboard";
+static const char *const k_pch_Dashboard_EnableDashboard_Bool = "enableDashboard";
+static const char *const k_pch_Dashboard_ArcadeMode_Bool = "arcadeMode";
+
+//-----------------------------------------------------------------------------
+// model skin keys
+static const char *const k_pch_modelskin_Section = "modelskins";
+
+//-----------------------------------------------------------------------------
+// driver keys - These could be checked in any driver_<name> section
+static const char *const k_pch_Driver_Enable_Bool = "enable";
+
+}  // namespace vr
+
+// ivrchaperone.h
+namespace vr
+{
+#pragma pack(push, 8)
+
+enum ChaperoneCalibrationState
+{
+	// OK!
+	ChaperoneCalibrationState_OK = 1,  // Chaperone is fully calibrated and working correctly
+
+	// Warnings
+	ChaperoneCalibrationState_Warning = 100,
+	ChaperoneCalibrationState_Warning_BaseStationMayHaveMoved = 101,  // A base station thinks that it might have moved
+	ChaperoneCalibrationState_Warning_BaseStationRemoved = 102,       // There are less base stations than when calibrated
+	ChaperoneCalibrationState_Warning_SeatedBoundsInvalid = 103,      // Seated bounds haven't been calibrated for the current tracking center
+
+	// Errors
+	ChaperoneCalibrationState_Error = 200,                           // The UniverseID is invalid
+	ChaperoneCalibrationState_Error_BaseStationUninitialized = 201,  // Tracking center hasn't be calibrated for at least one of the base stations
+	ChaperoneCalibrationState_Error_BaseStationConflict = 202,       // Tracking center is calibrated, but base stations disagree on the tracking space
+	ChaperoneCalibrationState_Error_PlayAreaInvalid = 203,           // Play Area hasn't been calibrated for the current tracking center
+	ChaperoneCalibrationState_Error_CollisionBoundsInvalid = 204,    // Collision Bounds haven't been calibrated for the current tracking center
+};
+
+/** HIGH LEVEL TRACKING SPACE ASSUMPTIONS:
+* 0,0,0 is the preferred standing area center.
+* 0Y is the floor height.
+* -Z is the preferred forward facing direction. */
+class IVRChaperone
+{
+public:
+	/** Get the current state of Chaperone calibration. This state can change at any time during a session due to physical base station changes. **/
+	virtual ChaperoneCalibrationState GetCalibrationState() = 0;
+
+	/** Returns the width and depth of the Play Area (formerly named Soft Bounds) in X and Z. 
+	* Tracking space center (0,0,0) is the center of the Play Area. **/
+	virtual bool GetPlayAreaSize(float *pSizeX, float *pSizeZ) = 0;
+
+	/** Returns the 4 corner positions of the Play Area (formerly named Soft Bounds).
+	* Corners are in counter-clockwise order.
+	* Standing center (0,0,0) is the center of the Play Area.
+	* It's a rectangle.
+	* 2 sides are parallel to the X axis and 2 sides are parallel to the Z axis.
+	* Height of every corner is 0Y (on the floor). **/
+	virtual bool GetPlayAreaRect(HmdQuad_t *rect) = 0;
+
+	/** Reload Chaperone data from the .vrchap file on disk. */
+	virtual void ReloadInfo(void) = 0;
+
+	/** Optionally give the chaperone system a hit about the color and brightness in the scene **/
+	virtual void SetSceneColor(HmdColor_t color) = 0;
+
+	/** Get the current chaperone bounds draw color and brightness **/
+	virtual void GetBoundsColor(HmdColor_t *pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, HmdColor_t *pOutputCameraColor) = 0;
+
+	/** Determine whether the bounds are showing right now **/
+	virtual bool AreBoundsVisible() = 0;
+
+	/** Force the bounds to show, mostly for utilities **/
+	virtual void ForceBoundsVisible(bool bForce) = 0;
+};
+
+static const char *const IVRChaperone_Version = "IVRChaperone_003";
+
+#pragma pack(pop)
+
+}  // namespace vr
+
+// ivrchaperonesetup.h
+namespace vr
+{
+enum EChaperoneConfigFile
+{
+	EChaperoneConfigFile_Live = 1,  // The live chaperone config, used by most applications and games
+	EChaperoneConfigFile_Temp = 2,  // The temporary chaperone config, used to live-preview collision bounds in room setup
+};
+
+enum EChaperoneImportFlags
+{
+	EChaperoneImport_BoundsOnly = 0x0001,
+};
+
+/** Manages the working copy of the chaperone info. By default this will be the same as the 
+* live copy. Any changes made with this interface will stay in the working copy until 
+* CommitWorkingCopy() is called, at which point the working copy and the live copy will be 
+* the same again. */
+class IVRChaperoneSetup
+{
+public:
+	/** Saves the current working copy to disk */
+	virtual bool CommitWorkingCopy(EChaperoneConfigFile configFile) = 0;
+
+	/** Reverts the working copy to match the live chaperone calibration.
+	* To modify existing data this MUST be do WHILE getting a non-error ChaperoneCalibrationStatus.
+	* Only after this should you do gets and sets on the existing data. */
+	virtual void RevertWorkingCopy() = 0;
+
+	/** Returns the width and depth of the Play Area (formerly named Soft Bounds) in X and Z from the working copy.
+	* Tracking space center (0,0,0) is the center of the Play Area. */
+	virtual bool GetWorkingPlayAreaSize(float *pSizeX, float *pSizeZ) = 0;
+
+	/** Returns the 4 corner positions of the Play Area (formerly named Soft Bounds) from the working copy.
+	* Corners are in clockwise order.
+	* Tracking space center (0,0,0) is the center of the Play Area.
+	* It's a rectangle.
+	* 2 sides are parallel to the X axis and 2 sides are parallel to the Z axis.
+	* Height of every corner is 0Y (on the floor). **/
+	virtual bool GetWorkingPlayAreaRect(HmdQuad_t *rect) = 0;
+
+	/** Returns the number of Quads if the buffer points to null. Otherwise it returns Quads 
+	* into the buffer up to the max specified from the working copy. */
+	virtual bool GetWorkingCollisionBoundsInfo(VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t *punQuadsCount) = 0;
+
+	/** Returns the number of Quads if the buffer points to null. Otherwise it returns Quads 
+	* into the buffer up to the max specified. */
+	virtual bool GetLiveCollisionBoundsInfo(VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t *punQuadsCount) = 0;
+
+	/** Returns the preferred seated position from the working copy. */
+	virtual bool GetWorkingSeatedZeroPoseToRawTrackingPose(HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose) = 0;
+
+	/** Returns the standing origin from the working copy. */
+	virtual bool GetWorkingStandingZeroPoseToRawTrackingPose(HmdMatrix34_t *pmatStandingZeroPoseToRawTrackingPose) = 0;
+
+	/** Sets the Play Area in the working copy. */
+	virtual void SetWorkingPlayAreaSize(float sizeX, float sizeZ) = 0;
+
+	/** Sets the Collision Bounds in the working copy. */
+	virtual void SetWorkingCollisionBoundsInfo(VR_ARRAY_COUNT(unQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t unQuadsCount) = 0;
+
+	/** Sets the preferred seated position in the working copy. */
+	virtual void SetWorkingSeatedZeroPoseToRawTrackingPose(const HmdMatrix34_t *pMatSeatedZeroPoseToRawTrackingPose) = 0;
+
+	/** Sets the preferred standing position in the working copy. */
+	virtual void SetWorkingStandingZeroPoseToRawTrackingPose(const HmdMatrix34_t *pMatStandingZeroPoseToRawTrackingPose) = 0;
+
+	/** Tear everything down and reload it from the file on disk */
+	virtual void ReloadFromDisk(EChaperoneConfigFile configFile) = 0;
+
+	/** Returns the preferred seated position. */
+	virtual bool GetLiveSeatedZeroPoseToRawTrackingPose(HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose) = 0;
+
+	virtual void SetWorkingCollisionBoundsTagsInfo(VR_ARRAY_COUNT(unTagCount) uint8_t *pTagsBuffer, uint32_t unTagCount) = 0;
+	virtual bool GetLiveCollisionBoundsTagsInfo(VR_OUT_ARRAY_COUNT(punTagCount) uint8_t *pTagsBuffer, uint32_t *punTagCount) = 0;
+
+	virtual bool SetWorkingPhysicalBoundsInfo(VR_ARRAY_COUNT(unQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t unQuadsCount) = 0;
+	virtual bool GetLivePhysicalBoundsInfo(VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t *punQuadsCount) = 0;
+
+	virtual bool ExportLiveToBuffer(VR_OUT_STRING() char *pBuffer, uint32_t *pnBufferLength) = 0;
+	virtual bool ImportFromBufferToWorking(const char *pBuffer, uint32_t nImportFlags) = 0;
+};
+
+static const char *const IVRChaperoneSetup_Version = "IVRChaperoneSetup_005";
+
+}  // namespace vr
+
+// ivrcompositor.h
+namespace vr
+{
+#pragma pack(push, 8)
+
+/** Errors that can occur with the VR compositor */
+enum EVRCompositorError
+{
+	VRCompositorError_None = 0,
+	VRCompositorError_RequestFailed = 1,
+	VRCompositorError_IncompatibleVersion = 100,
+	VRCompositorError_DoNotHaveFocus = 101,
+	VRCompositorError_InvalidTexture = 102,
+	VRCompositorError_IsNotSceneApplication = 103,
+	VRCompositorError_TextureIsOnWrongDevice = 104,
+	VRCompositorError_TextureUsesUnsupportedFormat = 105,
+	VRCompositorError_SharedTexturesNotSupported = 106,
+	VRCompositorError_IndexOutOfRange = 107,
+	VRCompositorError_AlreadySubmitted = 108,
+	VRCompositorError_InvalidBounds = 109,
+};
+
+const uint32_t VRCompositor_ReprojectionReason_Cpu = 0x01;
+const uint32_t VRCompositor_ReprojectionReason_Gpu = 0x02;
+const uint32_t VRCompositor_ReprojectionAsync = 0x04;  // This flag indicates the async reprojection mode is active,
+													   // but does not indicate if reprojection actually happened or not.
+													   // Use the ReprojectionReason flags above to check if reprojection
+													   // was actually applied (i.e. scene texture was reused).
+													   // NumFramePresents > 1 also indicates the scene texture was reused,
+													   // and also the number of times that it was presented in total.
+
+/** Provides a single frame's timing information to the app */
+struct Compositor_FrameTiming
+{
+	uint32_t m_nSize;  // Set to sizeof( Compositor_FrameTiming )
+	uint32_t m_nFrameIndex;
+	uint32_t m_nNumFramePresents;  // number of times this frame was presented
+	uint32_t m_nNumMisPresented;   // number of times this frame was presented on a vsync other than it was originally predicted to
+	uint32_t m_nNumDroppedFrames;  // number of additional times previous frame was scanned out
+	uint32_t m_nReprojectionFlags;
+
+	/** Absolute time reference for comparing frames.  This aligns with the vsync that running start is relative to. */
+	double m_flSystemTimeInSeconds;
+
+	/** These times may include work from other processes due to OS scheduling.
+	* The fewer packets of work these are broken up into, the less likely this will happen.
+	* GPU work can be broken up by calling Flush.  This can sometimes be useful to get the GPU started
+	* processing that work earlier in the frame. */
+	float m_flPreSubmitGpuMs;         // time spent rendering the scene (gpu work submitted between WaitGetPoses and second Submit)
+	float m_flPostSubmitGpuMs;        // additional time spent rendering by application (e.g. companion window)
+	float m_flTotalRenderGpuMs;       // time between work submitted immediately after present (ideally vsync) until the end of compositor submitted work
+	float m_flCompositorRenderGpuMs;  // time spend performing distortion correction, rendering chaperone, overlays, etc.
+	float m_flCompositorRenderCpuMs;  // time spent on cpu submitting the above work for this frame
+	float m_flCompositorIdleCpuMs;    // time spent waiting for running start (application could have used this much more time)
+
+	/** Miscellaneous measured intervals. */
+	float m_flClientFrameIntervalMs;  // time between calls to WaitGetPoses
+	float m_flPresentCallCpuMs;       // time blocked on call to present (usually 0.0, but can go long)
+	float m_flWaitForPresentCpuMs;    // time spent spin-waiting for frame index to change (not near-zero indicates wait object failure)
+	float m_flSubmitFrameMs;          // time spent in IVRCompositor::Submit (not near-zero indicates driver issue)
+
+	/** The following are all relative to this frame's SystemTimeInSeconds */
+	float m_flWaitGetPosesCalledMs;
+	float m_flNewPosesReadyMs;
+	float m_flNewFrameReadyMs;  // second call to IVRCompositor::Submit
+	float m_flCompositorUpdateStartMs;
+	float m_flCompositorUpdateEndMs;
+	float m_flCompositorRenderStartMs;
+
+	vr::TrackedDevicePose_t m_HmdPose;  // pose used by app to render this frame
+};
+
+/** Cumulative stats for current application.  These are not cleared until a new app connects,
+* but they do stop accumulating once the associated app disconnects. */
+struct Compositor_CumulativeStats
+{
+	uint32_t m_nPid;                   // Process id associated with these stats (may no longer be running).
+	uint32_t m_nNumFramePresents;      // total number of times we called present (includes reprojected frames)
+	uint32_t m_nNumDroppedFrames;      // total number of times an old frame was re-scanned out (without reprojection)
+	uint32_t m_nNumReprojectedFrames;  // total number of times a frame was scanned out a second time (with reprojection)
+
+	/** Values recorded at startup before application has fully faded in the first time. */
+	uint32_t m_nNumFramePresentsOnStartup;
+	uint32_t m_nNumDroppedFramesOnStartup;
+	uint32_t m_nNumReprojectedFramesOnStartup;
+
+	/** Applications may explicitly fade to the compositor.  This is usually to handle level transitions, and loading often causes
+	* system wide hitches.  The following stats are collected during this period.  Does not include values recorded during startup. */
+	uint32_t m_nNumLoading;
+	uint32_t m_nNumFramePresentsLoading;
+	uint32_t m_nNumDroppedFramesLoading;
+	uint32_t m_nNumReprojectedFramesLoading;
+
+	/** If we don't get a new frame from the app in less than 2.5 frames, then we assume the app has hung and start
+	* fading back to the compositor.  The following stats are a result of this, and are a subset of those recorded above.
+	* Does not include values recorded during start up or loading. */
+	uint32_t m_nNumTimedOut;
+	uint32_t m_nNumFramePresentsTimedOut;
+	uint32_t m_nNumDroppedFramesTimedOut;
+	uint32_t m_nNumReprojectedFramesTimedOut;
+};
+
+#pragma pack(pop)
+
+/** Allows the application to interact with the compositor */
+class IVRCompositor
+{
+public:
+	/** Sets tracking space returned by WaitGetPoses */
+	virtual void SetTrackingSpace(ETrackingUniverseOrigin eOrigin) = 0;
+
+	/** Gets current tracking space returned by WaitGetPoses */
+	virtual ETrackingUniverseOrigin GetTrackingSpace() = 0;
+
+	/** Scene applications should call this function to get poses to render with (and optionally poses predicted an additional frame out to use for gameplay).
+	* This function will block until "running start" milliseconds before the start of the frame, and should be called at the last moment before needing to
+	* start rendering.
+	*
+	* Return codes:
+	*	- IsNotSceneApplication (make sure to call VR_Init with VRApplicaiton_Scene)
+	*	- DoNotHaveFocus (some other app has taken focus - this will throttle the call to 10hz to reduce the impact on that app)
+	*/
+	virtual EVRCompositorError WaitGetPoses(VR_ARRAY_COUNT(unRenderPoseArrayCount) TrackedDevicePose_t *pRenderPoseArray, uint32_t unRenderPoseArrayCount,
+											VR_ARRAY_COUNT(unGamePoseArrayCount) TrackedDevicePose_t *pGamePoseArray, uint32_t unGamePoseArrayCount) = 0;
+
+	/** Get the last set of poses returned by WaitGetPoses. */
+	virtual EVRCompositorError GetLastPoses(VR_ARRAY_COUNT(unRenderPoseArrayCount) TrackedDevicePose_t *pRenderPoseArray, uint32_t unRenderPoseArrayCount,
+											VR_ARRAY_COUNT(unGamePoseArrayCount) TrackedDevicePose_t *pGamePoseArray, uint32_t unGamePoseArrayCount) = 0;
+
+	/** Interface for accessing last set of poses returned by WaitGetPoses one at a time.
+	* Returns VRCompositorError_IndexOutOfRange if unDeviceIndex not less than k_unMaxTrackedDeviceCount otherwise VRCompositorError_None.
+	* It is okay to pass NULL for either pose if you only want one of the values. */
+	virtual EVRCompositorError GetLastPoseForTrackedDeviceIndex(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t *pOutputPose, TrackedDevicePose_t *pOutputGamePose) = 0;
+
+	/** Updated scene texture to display. If pBounds is NULL the entire texture will be used.  If called from an OpenGL app, consider adding a glFlush after
+	* Submitting both frames to signal the driver to start processing, otherwise it may wait until the command buffer fills up, causing the app to miss frames.
+	*
+	* OpenGL dirty state:
+	*	glBindTexture
+	*
+	* Return codes:
+	*	- IsNotSceneApplication (make sure to call VR_Init with VRApplicaiton_Scene)
+	*	- DoNotHaveFocus (some other app has taken focus)
+	*	- TextureIsOnWrongDevice (application did not use proper AdapterIndex - see IVRSystem.GetDXGIOutputInfo)
+	*	- SharedTexturesNotSupported (application needs to call CreateDXGIFactory1 or later before creating DX device)
+	*	- TextureUsesUnsupportedFormat (scene textures must be compatible with DXGI sharing rules - e.g. uncompressed, no mips, etc.)
+	*	- InvalidTexture (usually means bad arguments passed in)
+	*	- AlreadySubmitted (app has submitted two left textures or two right textures in a single frame - i.e. before calling WaitGetPoses again)
+	*/
+	virtual EVRCompositorError Submit(EVREye eEye, const Texture_t *pTexture, const VRTextureBounds_t *pBounds = 0, EVRSubmitFlags nSubmitFlags = Submit_Default) = 0;
+
+	/** Clears the frame that was sent with the last call to Submit. This will cause the 
+	* compositor to show the grid until Submit is called again. */
+	virtual void ClearLastSubmittedFrame() = 0;
+
+	/** Call immediately after presenting your app's window (i.e. companion window) to unblock the compositor.
+	* This is an optional call, which only needs to be used if you can't instead call WaitGetPoses immediately after Present.
+	* For example, if your engine's render and game loop are not on separate threads, or blocking the render thread until 3ms before the next vsync would
+	* introduce a deadlock of some sort.  This function tells the compositor that you have finished all rendering after having Submitted buffers for both
+	* eyes, and it is free to start its rendering work.  This should only be called from the same thread you are rendering on. */
+	virtual void PostPresentHandoff() = 0;
+
+	/** Returns true if timing data is filled it.  Sets oldest timing info if nFramesAgo is larger than the stored history.
+	* Be sure to set timing.size = sizeof(Compositor_FrameTiming) on struct passed in before calling this function. */
+	virtual bool GetFrameTiming(Compositor_FrameTiming *pTiming, uint32_t unFramesAgo = 0) = 0;
+
+	/** Interface for copying a range of timing data.  Frames are returned in ascending order (oldest to newest) with the last being the most recent frame.
+	* Only the first entry's m_nSize needs to be set, as the rest will be inferred from that.  Returns total number of entries filled out. */
+	virtual uint32_t GetFrameTimings(Compositor_FrameTiming *pTiming, uint32_t nFrames) = 0;
+
+	/** Returns the time in seconds left in the current (as identified by FrameTiming's frameIndex) frame.
+	* Due to "running start", this value may roll over to the next frame before ever reaching 0.0. */
+	virtual float GetFrameTimeRemaining() = 0;
+
+	/** Fills out stats accumulated for the last connected application.  Pass in sizeof( Compositor_CumulativeStats ) as second parameter. */
+	virtual void GetCumulativeStats(Compositor_CumulativeStats *pStats, uint32_t nStatsSizeInBytes) = 0;
+
+	/** Fades the view on the HMD to the specified color. The fade will take fSeconds, and the color values are between
+	* 0.0 and 1.0. This color is faded on top of the scene based on the alpha parameter. Removing the fade color instantly 
+	* would be FadeToColor( 0.0, 0.0, 0.0, 0.0, 0.0 ).  Values are in un-premultiplied alpha space. */
+	virtual void FadeToColor(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground = false) = 0;
+
+	/** Get current fade color value. */
+	virtual HmdColor_t GetCurrentFadeColor(bool bBackground = false) = 0;
+
+	/** Fading the Grid in or out in fSeconds */
+	virtual void FadeGrid(float fSeconds, bool bFadeIn) = 0;
+
+	/** Get current alpha value of grid. */
+	virtual float GetCurrentGridAlpha() = 0;
+
+	/** Override the skybox used in the compositor (e.g. for during level loads when the app can't feed scene images fast enough)
+	* Order is Front, Back, Left, Right, Top, Bottom.  If only a single texture is passed, it is assumed in lat-long format.
+	* If two are passed, it is assumed a lat-long stereo pair. */
+	virtual EVRCompositorError SetSkyboxOverride(VR_ARRAY_COUNT(unTextureCount) const Texture_t *pTextures, uint32_t unTextureCount) = 0;
+
+	/** Resets compositor skybox back to defaults. */
+	virtual void ClearSkyboxOverride() = 0;
+
+	/** Brings the compositor window to the front. This is useful for covering any other window that may be on the HMD
+	* and is obscuring the compositor window. */
+	virtual void CompositorBringToFront() = 0;
+
+	/** Pushes the compositor window to the back. This is useful for allowing other applications to draw directly to the HMD. */
+	virtual void CompositorGoToBack() = 0;
+
+	/** Tells the compositor process to clean up and exit. You do not need to call this function at shutdown. Under normal 
+	* circumstances the compositor will manage its own life cycle based on what applications are running. */
+	virtual void CompositorQuit() = 0;
+
+	/** Return whether the compositor is fullscreen */
+	virtual bool IsFullscreen() = 0;
+
+	/** Returns the process ID of the process that is currently rendering the scene */
+	virtual uint32_t GetCurrentSceneFocusProcess() = 0;
+
+	/** Returns the process ID of the process that rendered the last frame (or 0 if the compositor itself rendered the frame.)
+	* Returns 0 when fading out from an app and the app's process Id when fading into an app. */
+	virtual uint32_t GetLastFrameRenderer() = 0;
+
+	/** Returns true if the current process has the scene focus */
+	virtual bool CanRenderScene() = 0;
+
+	/** Creates a window on the primary monitor to display what is being shown in the headset. */
+	virtual void ShowMirrorWindow() = 0;
+
+	/** Closes the mirror window. */
+	virtual void HideMirrorWindow() = 0;
+
+	/** Returns true if the mirror window is shown. */
+	virtual bool IsMirrorWindowVisible() = 0;
+
+	/** Writes all images that the compositor knows about (including overlays) to a 'screenshots' folder in the SteamVR runtime root. */
+	virtual void CompositorDumpImages() = 0;
+
+	/** Let an app know it should be rendering with low resources. */
+	virtual bool ShouldAppRenderWithLowResources() = 0;
+
+	/** Override interleaved reprojection logic to force on. */
+	virtual void ForceInterleavedReprojectionOn(bool bOverride) = 0;
+
+	/** Force reconnecting to the compositor process. */
+	virtual void ForceReconnectProcess() = 0;
+
+	/** Temporarily suspends rendering (useful for finer control over scene transitions). */
+	virtual void SuspendRendering(bool bSuspend) = 0;
+
+	/** Opens a shared D3D11 texture with the undistorted composited image for each eye.  Use ReleaseMirrorTextureD3D11 when finished
+	* instead of calling Release on the resource itself. */
+	virtual vr::EVRCompositorError GetMirrorTextureD3D11(vr::EVREye eEye, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView) = 0;
+	virtual void ReleaseMirrorTextureD3D11(void *pD3D11ShaderResourceView) = 0;
+
+	/** Access to mirror textures from OpenGL. */
+	virtual vr::EVRCompositorError GetMirrorTextureGL(vr::EVREye eEye, vr::glUInt_t *pglTextureId, vr::glSharedTextureHandle_t *pglSharedTextureHandle) = 0;
+	virtual bool ReleaseSharedGLTexture(vr::glUInt_t glTextureId, vr::glSharedTextureHandle_t glSharedTextureHandle) = 0;
+	virtual void LockGLSharedTextureForAccess(vr::glSharedTextureHandle_t glSharedTextureHandle) = 0;
+	virtual void UnlockGLSharedTextureForAccess(vr::glSharedTextureHandle_t glSharedTextureHandle) = 0;
+
+	/** [Vulkan Only]
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null.  The string will be a space separated list of-required instance extensions to enable in VkCreateInstance */
+	virtual uint32_t GetVulkanInstanceExtensionsRequired(VR_OUT_STRING() char *pchValue, uint32_t unBufferSize) = 0;
+
+	/** [Vulkan only]
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null.  The string will be a space separated list of required device extensions to enable in VkCreateDevice */
+	virtual uint32_t GetVulkanDeviceExtensionsRequired(VkPhysicalDevice_T *pPhysicalDevice, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize) = 0;
+
+	/** [ Vulkan/D3D12 Only ]
+	* There are two purposes for SetExplicitTimingMode:
+	*	1. To get a more accurate GPU timestamp for when the frame begins in Vulkan/D3D12 applications.
+	*	2. (Optional) To avoid having WaitGetPoses access the Vulkan queue so that the queue can be accessed from
+	*	another thread while WaitGetPoses is executing.
+	*
+	* More accurate GPU timestamp for the start of the frame is achieved by the application calling
+	* SubmitExplicitTimingData immediately before its first submission to the Vulkan/D3D12 queue.
+	* This is more accurate because normally this GPU timestamp is recorded during WaitGetPoses.  In D3D11, 
+	* WaitGetPoses queues a GPU timestamp write, but it does not actually get submitted to the GPU until the 
+	* application flushes.  By using SubmitExplicitTimingData, the timestamp is recorded at the same place for 
+	* Vulkan/D3D12 as it is for D3D11, resulting in a more accurate GPU time measurement for the frame.
+	*
+	* Avoiding WaitGetPoses accessing the Vulkan queue can be achieved using SetExplicitTimingMode as well.  If this is desired,
+	* the application *MUST* call PostPresentHandoff itself prior to WaitGetPoses.  If SetExplicitTimingMode is true and the
+	* application calls PostPresentHandoff, then WaitGetPoses is guaranteed not to access the queue.  Note that PostPresentHandoff
+	* and SubmitExplicitTimingData will access the queue, so only WaitGetPoses becomes safe for accessing the queue from another
+	* thread. */
+	virtual void SetExplicitTimingMode(bool bExplicitTimingMode) = 0;
+
+	/** [ Vulkan/D3D12 Only ]
+	* Submit explicit timing data.  When SetExplicitTimingMode is true, this must be called immediately before
+	* the application's first vkQueueSubmit (Vulkan) or ID3D12CommandQueue::ExecuteCommandLists (D3D12) of each frame.
+	* This function will insert a GPU timestamp write just before the application starts its rendering.  This function
+	* will perform a vkQueueSubmit on Vulkan so must not be done simultaneously with VkQueue operations on another thread.
+	* Returns VRCompositorError_RequestFailed if SetExplicitTimingMode is not enabled. */
+	virtual EVRCompositorError SubmitExplicitTimingData() = 0;
+};
+
+static const char *const IVRCompositor_Version = "IVRCompositor_021";
+
+}  // namespace vr
+
+// ivrnotifications.h
+namespace vr
+{
+#pragma pack(push, 8)
+
+// Used for passing graphic data
+struct NotificationBitmap_t
+{
+	NotificationBitmap_t()
+		: m_pImageData(nullptr), m_nWidth(0), m_nHeight(0), m_nBytesPerPixel(0){};
+
+	void *m_pImageData;
+	int32_t m_nWidth;
+	int32_t m_nHeight;
+	int32_t m_nBytesPerPixel;
+};
+
+/** Be aware that the notification type is used as 'priority' to pick the next notification */
+enum EVRNotificationType
+{
+	/** Transient notifications are automatically hidden after a period of time set by the user. 
+	* They are used for things like information and chat messages that do not require user interaction. */
+	EVRNotificationType_Transient = 0,
+
+	/** Persistent notifications are shown to the user until they are hidden by calling RemoveNotification().
+	* They are used for things like phone calls and alarms that require user interaction. */
+	EVRNotificationType_Persistent = 1,
+
+	/** System notifications are shown no matter what. It is expected, that the ulUserValue is used as ID.
+	 * If there is already a system notification in the queue with that ID it is not accepted into the queue
+	 * to prevent spamming with system notification */
+	EVRNotificationType_Transient_SystemWithUserValue = 2,
+};
+
+enum EVRNotificationStyle
+{
+	/** Creates a notification with minimal external styling. */
+	EVRNotificationStyle_None = 0,
+
+	/** Used for notifications about overlay-level status. In Steam this is used for events like downloads completing. */
+	EVRNotificationStyle_Application = 100,
+
+	/** Used for notifications about contacts that are unknown or not available. In Steam this is used for friend invitations and offline friends. */
+	EVRNotificationStyle_Contact_Disabled = 200,
+
+	/** Used for notifications about contacts that are available but inactive. In Steam this is used for friends that are online but not playing a game. */
+	EVRNotificationStyle_Contact_Enabled = 201,
+
+	/** Used for notifications about contacts that are available and active. In Steam this is used for friends that are online and currently running a game. */
+	EVRNotificationStyle_Contact_Active = 202,
+};
+
+static const uint32_t k_unNotificationTextMaxSize = 256;
+
+typedef uint32_t VRNotificationId;
+
+#pragma pack(pop)
+
+/** Allows notification sources to interact with the VR system
+	This current interface is not yet implemented. Do not use yet. */
+class IVRNotifications
+{
+public:
+	/** Create a notification and enqueue it to be shown to the user.
+	* An overlay handle is required to create a notification, as otherwise it would be impossible for a user to act on it.
+	* To create a two-line notification, use a line break ('\n') to split the text into two lines.
+	* The pImage argument may be NULL, in which case the specified overlay's icon will be used instead. */
+	virtual EVRNotificationError CreateNotification(VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, EVRNotificationType type, const char *pchText, EVRNotificationStyle style, const NotificationBitmap_t *pImage, /* out */ VRNotificationId *pNotificationId) = 0;
+
+	/** Destroy a notification, hiding it first if it currently shown to the user. */
+	virtual EVRNotificationError RemoveNotification(VRNotificationId notificationId) = 0;
+};
+
+static const char *const IVRNotifications_Version = "IVRNotifications_002";
+
+}  // namespace vr
+
+// ivroverlay.h
+namespace vr
+{
+/** The maximum length of an overlay key in bytes, counting the terminating null character. */
+static const uint32_t k_unVROverlayMaxKeyLength = 128;
+
+/** The maximum length of an overlay name in bytes, counting the terminating null character. */
+static const uint32_t k_unVROverlayMaxNameLength = 128;
+
+/** The maximum number of overlays that can exist in the system at one time. */
+static const uint32_t k_unMaxOverlayCount = 64;
+
+/** The maximum number of overlay intersection mask primitives per overlay */
+static const uint32_t k_unMaxOverlayIntersectionMaskPrimitivesCount = 32;
+
+/** Types of input supported by VR Overlays */
+enum VROverlayInputMethod
+{
+	VROverlayInputMethod_None = 0,   // No input events will be generated automatically for this overlay
+	VROverlayInputMethod_Mouse = 1,  // Tracked controllers will get mouse events automatically
+};
+
+/** Allows the caller to figure out which overlay transform getter to call. */
+enum VROverlayTransformType
+{
+	VROverlayTransform_Absolute = 0,
+	VROverlayTransform_TrackedDeviceRelative = 1,
+	VROverlayTransform_SystemOverlay = 2,
+	VROverlayTransform_TrackedComponent = 3,
+};
+
+/** Overlay control settings */
+enum VROverlayFlags
+{
+	VROverlayFlags_None = 0,
+
+	// The following only take effect when rendered using the high quality render path (see SetHighQualityOverlay).
+	VROverlayFlags_Curved = 1,
+	VROverlayFlags_RGSS4X = 2,
+
+	// Set this flag on a dashboard overlay to prevent a tab from showing up for that overlay
+	VROverlayFlags_NoDashboardTab = 3,
+
+	// Set this flag on a dashboard that is able to deal with gamepad focus events
+	VROverlayFlags_AcceptsGamepadEvents = 4,
+
+	// Indicates that the overlay should dim/brighten to show gamepad focus
+	VROverlayFlags_ShowGamepadFocus = 5,
+
+	// When in VROverlayInputMethod_Mouse you can optionally enable sending VRScroll_t
+	VROverlayFlags_SendVRScrollEvents = 6,
+	VROverlayFlags_SendVRTouchpadEvents = 7,
+
+	// If set this will render a vertical scroll wheel on the primary controller,
+	//  only needed if not using VROverlayFlags_SendVRScrollEvents but you still want to represent a scroll wheel
+	VROverlayFlags_ShowTouchPadScrollWheel = 8,
+
+	// If this is set ownership and render access to the overlay are transferred
+	// to the new scene process on a call to IVRApplications::LaunchInternalProcess
+	VROverlayFlags_TransferOwnershipToInternalProcess = 9,
+
+	// If set, renders 50% of the texture in each eye, side by side
+	VROverlayFlags_SideBySide_Parallel = 10,  // Texture is left/right
+	VROverlayFlags_SideBySide_Crossed = 11,   // Texture is crossed and right/left
+
+	VROverlayFlags_Panorama = 12,        // Texture is a panorama
+	VROverlayFlags_StereoPanorama = 13,  // Texture is a stereo panorama
+
+	// If this is set on an overlay owned by the scene application that overlay
+	// will be sorted with the "Other" overlays on top of all other scene overlays
+	VROverlayFlags_SortWithNonSceneOverlays = 14,
+
+	// If set, the overlay will be shown in the dashboard, otherwise it will be hidden.
+	VROverlayFlags_VisibleInDashboard = 15,
+};
+
+enum VRMessageOverlayResponse
+{
+	VRMessageOverlayResponse_ButtonPress_0 = 0,
+	VRMessageOverlayResponse_ButtonPress_1 = 1,
+	VRMessageOverlayResponse_ButtonPress_2 = 2,
+	VRMessageOverlayResponse_ButtonPress_3 = 3,
+	VRMessageOverlayResponse_CouldntFindSystemOverlay = 4,
+	VRMessageOverlayResponse_CouldntFindOrCreateClientOverlay = 5,
+	VRMessageOverlayResponse_ApplicationQuit = 6
+};
+
+struct VROverlayIntersectionParams_t
+{
+	HmdVector3_t vSource;
+	HmdVector3_t vDirection;
+	ETrackingUniverseOrigin eOrigin;
+};
+
+struct VROverlayIntersectionResults_t
+{
+	HmdVector3_t vPoint;
+	HmdVector3_t vNormal;
+	HmdVector2_t vUVs;
+	float fDistance;
+};
+
+// Input modes for the Big Picture gamepad text entry
+enum EGamepadTextInputMode
+{
+	k_EGamepadTextInputModeNormal = 0,
+	k_EGamepadTextInputModePassword = 1,
+	k_EGamepadTextInputModeSubmit = 2,
+};
+
+// Controls number of allowed lines for the Big Picture gamepad text entry
+enum EGamepadTextInputLineMode
+{
+	k_EGamepadTextInputLineModeSingleLine = 0,
+	k_EGamepadTextInputLineModeMultipleLines = 1
+};
+
+/** Directions for changing focus between overlays with the gamepad */
+enum EOverlayDirection
+{
+	OverlayDirection_Up = 0,
+	OverlayDirection_Down = 1,
+	OverlayDirection_Left = 2,
+	OverlayDirection_Right = 3,
+
+	OverlayDirection_Count = 4,
+};
+
+enum EVROverlayIntersectionMaskPrimitiveType
+{
+	OverlayIntersectionPrimitiveType_Rectangle,
+	OverlayIntersectionPrimitiveType_Circle,
+};
+
+struct IntersectionMaskRectangle_t
+{
+	float m_flTopLeftX;
+	float m_flTopLeftY;
+	float m_flWidth;
+	float m_flHeight;
+};
+
+struct IntersectionMaskCircle_t
+{
+	float m_flCenterX;
+	float m_flCenterY;
+	float m_flRadius;
+};
+
+/** NOTE!!! If you change this you MUST manually update openvr_interop.cs.py and openvr_api_flat.h.py */
+typedef union {
+	IntersectionMaskRectangle_t m_Rectangle;
+	IntersectionMaskCircle_t m_Circle;
+} VROverlayIntersectionMaskPrimitive_Data_t;
+
+struct VROverlayIntersectionMaskPrimitive_t
+{
+	EVROverlayIntersectionMaskPrimitiveType m_nPrimitiveType;
+	VROverlayIntersectionMaskPrimitive_Data_t m_Primitive;
+};
+
+class IVROverlay
+{
+public:
+	// ---------------------------------------------
+	// Overlay management methods
+	// ---------------------------------------------
+
+	/** Finds an existing overlay with the specified key. */
+	virtual EVROverlayError FindOverlay(const char *pchOverlayKey, VROverlayHandle_t *pOverlayHandle) = 0;
+
+	/** Creates a new named overlay. All overlays start hidden and with default settings. */
+	virtual EVROverlayError CreateOverlay(const char *pchOverlayKey, const char *pchOverlayName, VROverlayHandle_t *pOverlayHandle) = 0;
+
+	/** Destroys the specified overlay. When an application calls VR_Shutdown all overlays created by that app are
+		* automatically destroyed. */
+	virtual EVROverlayError DestroyOverlay(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Specify which overlay to use the high quality render path.  This overlay will be composited in during the distortion pass which
+		* results in it drawing on top of everything else, but also at a higher quality as it samples the source texture directly rather than
+		* rasterizing into each eye's render texture first.  Because if this, only one of these is supported at any given time.  It is most useful
+		* for overlays that are expected to take up most of the user's view (e.g. streaming video).
+		* This mode does not support mouse input to your overlay. */
+	virtual EVROverlayError SetHighQualityOverlay(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Returns the overlay handle of the current overlay being rendered using the single high quality overlay render path.
+		* Otherwise it will return k_ulOverlayHandleInvalid. */
+	virtual vr::VROverlayHandle_t GetHighQualityOverlay() = 0;
+
+	/** Fills the provided buffer with the string key of the overlay. Returns the size of buffer required to store the key, including
+		* the terminating null character. k_unVROverlayMaxKeyLength will be enough bytes to fit the string. */
+	virtual uint32_t GetOverlayKey(VROverlayHandle_t ulOverlayHandle, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, EVROverlayError *pError = 0L) = 0;
+
+	/** Fills the provided buffer with the friendly name of the overlay. Returns the size of buffer required to store the key, including
+		* the terminating null character. k_unVROverlayMaxNameLength will be enough bytes to fit the string. */
+	virtual uint32_t GetOverlayName(VROverlayHandle_t ulOverlayHandle, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, EVROverlayError *pError = 0L) = 0;
+
+	/** set the name to use for this overlay */
+	virtual EVROverlayError SetOverlayName(VROverlayHandle_t ulOverlayHandle, const char *pchName) = 0;
+
+	/** Gets the raw image data from an overlay. Overlay image data is always returned as RGBA data, 4 bytes per pixel. If the buffer is not large enough, width and height 
+		* will be set and VROverlayError_ArrayTooSmall is returned. */
+	virtual EVROverlayError GetOverlayImageData(VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unBufferSize, uint32_t *punWidth, uint32_t *punHeight) = 0;
+
+	/** returns a string that corresponds with the specified overlay error. The string will be the name 
+		* of the error enum value for all valid error codes */
+	virtual const char *GetOverlayErrorNameFromEnum(EVROverlayError error) = 0;
+
+	// ---------------------------------------------
+	// Overlay rendering methods
+	// ---------------------------------------------
+
+	/** Sets the pid that is allowed to render to this overlay (the creator pid is always allow to render),
+		*	by default this is the pid of the process that made the overlay */
+	virtual EVROverlayError SetOverlayRenderingPid(VROverlayHandle_t ulOverlayHandle, uint32_t unPID) = 0;
+
+	/** Gets the pid that is allowed to render to this overlay */
+	virtual uint32_t GetOverlayRenderingPid(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Specify flag setting for a given overlay */
+	virtual EVROverlayError SetOverlayFlag(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = 0;
+
+	/** Sets flag setting for a given overlay */
+	virtual EVROverlayError GetOverlayFlag(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool *pbEnabled) = 0;
+
+	/** Sets the color tint of the overlay quad. Use 0.0 to 1.0 per channel. */
+	virtual EVROverlayError SetOverlayColor(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = 0;
+
+	/** Gets the color tint of the overlay quad. */
+	virtual EVROverlayError GetOverlayColor(VROverlayHandle_t ulOverlayHandle, float *pfRed, float *pfGreen, float *pfBlue) = 0;
+
+	/** Sets the alpha of the overlay quad. Use 1.0 for 100 percent opacity to 0.0 for 0 percent opacity. */
+	virtual EVROverlayError SetOverlayAlpha(VROverlayHandle_t ulOverlayHandle, float fAlpha) = 0;
+
+	/** Gets the alpha of the overlay quad. By default overlays are rendering at 100 percent alpha (1.0). */
+	virtual EVROverlayError GetOverlayAlpha(VROverlayHandle_t ulOverlayHandle, float *pfAlpha) = 0;
+
+	/** Sets the aspect ratio of the texels in the overlay. 1.0 means the texels are square. 2.0 means the texels
+		* are twice as wide as they are tall. Defaults to 1.0. */
+	virtual EVROverlayError SetOverlayTexelAspect(VROverlayHandle_t ulOverlayHandle, float fTexelAspect) = 0;
+
+	/** Gets the aspect ratio of the texels in the overlay. Defaults to 1.0 */
+	virtual EVROverlayError GetOverlayTexelAspect(VROverlayHandle_t ulOverlayHandle, float *pfTexelAspect) = 0;
+
+	/** Sets the rendering sort order for the overlay. Overlays are rendered this order:
+		*      Overlays owned by the scene application
+		*      Overlays owned by some other application
+		*
+		*	Within a category overlays are rendered lowest sort order to highest sort order. Overlays with the same 
+		*	sort order are rendered back to front base on distance from the HMD.
+		*
+		*	Sort order defaults to 0. */
+	virtual EVROverlayError SetOverlaySortOrder(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder) = 0;
+
+	/** Gets the sort order of the overlay. See SetOverlaySortOrder for how this works. */
+	virtual EVROverlayError GetOverlaySortOrder(VROverlayHandle_t ulOverlayHandle, uint32_t *punSortOrder) = 0;
+
+	/** Sets the width of the overlay quad in meters. By default overlays are rendered on a quad that is 1 meter across */
+	virtual EVROverlayError SetOverlayWidthInMeters(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = 0;
+
+	/** Returns the width of the overlay quad in meters. By default overlays are rendered on a quad that is 1 meter across */
+	virtual EVROverlayError GetOverlayWidthInMeters(VROverlayHandle_t ulOverlayHandle, float *pfWidthInMeters) = 0;
+
+	/** For high-quality curved overlays only, sets the distance range in meters from the overlay used to automatically curve
+		* the surface around the viewer.  Min is distance is when the surface will be most curved.  Max is when least curved. */
+	virtual EVROverlayError SetOverlayAutoCurveDistanceRangeInMeters(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = 0;
+
+	/** For high-quality curved overlays only, gets the distance range in meters from the overlay used to automatically curve
+		* the surface around the viewer.  Min is distance is when the surface will be most curved.  Max is when least curved. */
+	virtual EVROverlayError GetOverlayAutoCurveDistanceRangeInMeters(VROverlayHandle_t ulOverlayHandle, float *pfMinDistanceInMeters, float *pfMaxDistanceInMeters) = 0;
+
+	/** Sets the colorspace the overlay texture's data is in.  Defaults to 'auto'.
+		* If the texture needs to be resolved, you should call SetOverlayTexture with the appropriate colorspace instead. */
+	virtual EVROverlayError SetOverlayTextureColorSpace(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = 0;
+
+	/** Gets the overlay's current colorspace setting. */
+	virtual EVROverlayError GetOverlayTextureColorSpace(VROverlayHandle_t ulOverlayHandle, EColorSpace *peTextureColorSpace) = 0;
+
+	/** Sets the part of the texture to use for the overlay. UV Min is the upper left corner and UV Max is the lower right corner. */
+	virtual EVROverlayError SetOverlayTextureBounds(VROverlayHandle_t ulOverlayHandle, const VRTextureBounds_t *pOverlayTextureBounds) = 0;
+
+	/** Gets the part of the texture to use for the overlay. UV Min is the upper left corner and UV Max is the lower right corner. */
+	virtual EVROverlayError GetOverlayTextureBounds(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t *pOverlayTextureBounds) = 0;
+
+	/** Gets render model to draw behind this overlay */
+	virtual uint32_t GetOverlayRenderModel(vr::VROverlayHandle_t ulOverlayHandle, char *pchValue, uint32_t unBufferSize, HmdColor_t *pColor, vr::EVROverlayError *pError) = 0;
+
+	/** Sets render model to draw behind this overlay and the vertex color to use, pass null for pColor to match the overlays vertex color. 
+			The model is scaled by the same amount as the overlay, with a default of 1m. */
+	virtual vr::EVROverlayError SetOverlayRenderModel(vr::VROverlayHandle_t ulOverlayHandle, const char *pchRenderModel, const HmdColor_t *pColor) = 0;
+
+	/** Returns the transform type of this overlay. */
+	virtual EVROverlayError GetOverlayTransformType(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType *peTransformType) = 0;
+
+	/** Sets the transform to absolute tracking origin. */
+	virtual EVROverlayError SetOverlayTransformAbsolute(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, const HmdMatrix34_t *pmatTrackingOriginToOverlayTransform) = 0;
+
+	/** Gets the transform if it is absolute. Returns an error if the transform is some other type. */
+	virtual EVROverlayError GetOverlayTransformAbsolute(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin *peTrackingOrigin, HmdMatrix34_t *pmatTrackingOriginToOverlayTransform) = 0;
+
+	/** Sets the transform to relative to the transform of the specified tracked device. */
+	virtual EVROverlayError SetOverlayTransformTrackedDeviceRelative(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, const HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform) = 0;
+
+	/** Gets the transform if it is relative to a tracked device. Returns an error if the transform is some other type. */
+	virtual EVROverlayError GetOverlayTransformTrackedDeviceRelative(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punTrackedDevice, HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform) = 0;
+
+	/** Sets the transform to draw the overlay on a rendermodel component mesh instead of a quad. This will only draw when the system is
+		* drawing the device. Overlays with this transform type cannot receive mouse events. */
+	virtual EVROverlayError SetOverlayTransformTrackedDeviceComponent(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char *pchComponentName) = 0;
+
+	/** Gets the transform information when the overlay is rendering on a component. */
+	virtual EVROverlayError GetOverlayTransformTrackedDeviceComponent(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punDeviceIndex, char *pchComponentName, uint32_t unComponentNameSize) = 0;
+
+	/** Gets the transform if it is relative to another overlay. Returns an error if the transform is some other type. */
+	virtual vr::EVROverlayError GetOverlayTransformOverlayRelative(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t *ulOverlayHandleParent, HmdMatrix34_t *pmatParentOverlayToOverlayTransform) = 0;
+
+	/** Sets the transform to relative to the transform of the specified overlay. This overlays visibility will also track the parents visibility */
+	virtual vr::EVROverlayError SetOverlayTransformOverlayRelative(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, const HmdMatrix34_t *pmatParentOverlayToOverlayTransform) = 0;
+
+	/** Shows the VR overlay.  For dashboard overlays, only the Dashboard Manager is allowed to call this. */
+	virtual EVROverlayError ShowOverlay(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Hides the VR overlay.  For dashboard overlays, only the Dashboard Manager is allowed to call this. */
+	virtual EVROverlayError HideOverlay(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Returns true if the overlay is visible. */
+	virtual bool IsOverlayVisible(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Get the transform in 3d space associated with a specific 2d point in the overlay's coordinate space (where 0,0 is the lower left). -Z points out of the overlay */
+	virtual EVROverlayError GetTransformForOverlayCoordinates(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t *pmatTransform) = 0;
+
+	// ---------------------------------------------
+	// Overlay input methods
+	// ---------------------------------------------
+
+	/** Returns true and fills the event with the next event on the overlay's event queue, if there is one. 
+		* If there are no events this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct */
+	virtual bool PollNextOverlayEvent(VROverlayHandle_t ulOverlayHandle, VREvent_t *pEvent, uint32_t uncbVREvent) = 0;
+
+	/** Returns the current input settings for the specified overlay. */
+	virtual EVROverlayError GetOverlayInputMethod(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod *peInputMethod) = 0;
+
+	/** Sets the input settings for the specified overlay. */
+	virtual EVROverlayError SetOverlayInputMethod(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = 0;
+
+	/** Gets the mouse scaling factor that is used for mouse events. The actual texture may be a different size, but this is
+		* typically the size of the underlying UI in pixels. */
+	virtual EVROverlayError GetOverlayMouseScale(VROverlayHandle_t ulOverlayHandle, HmdVector2_t *pvecMouseScale) = 0;
+
+	/** Sets the mouse scaling factor that is used for mouse events. The actual texture may be a different size, but this is
+		* typically the size of the underlying UI in pixels (not in world space). */
+	virtual EVROverlayError SetOverlayMouseScale(VROverlayHandle_t ulOverlayHandle, const HmdVector2_t *pvecMouseScale) = 0;
+
+	/** Computes the overlay-space pixel coordinates of where the ray intersects the overlay with the
+		* specified settings. Returns false if there is no intersection. */
+	virtual bool ComputeOverlayIntersection(VROverlayHandle_t ulOverlayHandle, const VROverlayIntersectionParams_t *pParams, VROverlayIntersectionResults_t *pResults) = 0;
+
+	/** Processes mouse input from the specified controller as though it were a mouse pointed at a compositor overlay with the
+		* specified settings. The controller is treated like a laser pointer on the -z axis. The point where the laser pointer would
+		* intersect with the overlay is the mouse position, the trigger is left mouse, and the track pad is right mouse. 
+		*
+		* Return true if the controller is pointed at the overlay and an event was generated. */
+	virtual bool HandleControllerOverlayInteractionAsMouse(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = 0;
+
+	/** Returns true if the specified overlay is the hover target. An overlay is the hover target when it is the last overlay "moused over" 
+		* by the virtual mouse pointer */
+	virtual bool IsHoverTargetOverlay(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Returns the current Gamepad focus overlay */
+	virtual vr::VROverlayHandle_t GetGamepadFocusOverlay() = 0;
+
+	/** Sets the current Gamepad focus overlay */
+	virtual EVROverlayError SetGamepadFocusOverlay(VROverlayHandle_t ulNewFocusOverlay) = 0;
+
+	/** Sets an overlay's neighbor. This will also set the neighbor of the "to" overlay
+		* to point back to the "from" overlay. If an overlay's neighbor is set to invalid both
+		* ends will be cleared */
+	virtual EVROverlayError SetOverlayNeighbor(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo) = 0;
+
+	/** Changes the Gamepad focus from one overlay to one of its neighbors. Returns VROverlayError_NoNeighbor if there is no
+		* neighbor in that direction */
+	virtual EVROverlayError MoveGamepadFocusToNeighbor(EOverlayDirection eDirection, VROverlayHandle_t ulFrom) = 0;
+
+	// ---------------------------------------------
+	// Overlay texture methods
+	// ---------------------------------------------
+
+	/** Texture to draw for the overlay. This function can only be called by the overlay's creator or renderer process (see SetOverlayRenderingPid) .
+		*
+		* OpenGL dirty state:
+		*	glBindTexture
+		*/
+	virtual EVROverlayError SetOverlayTexture(VROverlayHandle_t ulOverlayHandle, const Texture_t *pTexture) = 0;
+
+	/** Use this to tell the overlay system to release the texture set for this overlay. */
+	virtual EVROverlayError ClearOverlayTexture(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Separate interface for providing the data as a stream of bytes, but there is an upper bound on data 
+		* that can be sent. This function can only be called by the overlay's renderer process. */
+	virtual EVROverlayError SetOverlayRaw(VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = 0;
+
+	/** Separate interface for providing the image through a filename: can be png or jpg, and should not be bigger than 1920x1080.
+		* This function can only be called by the overlay's renderer process */
+	virtual EVROverlayError SetOverlayFromFile(VROverlayHandle_t ulOverlayHandle, const char *pchFilePath) = 0;
+
+	/** Get the native texture handle/device for an overlay you have created.
+		* On windows this handle will be a ID3D11ShaderResourceView with a ID3D11Texture2D bound.
+		*
+		* The texture will always be sized to match the backing texture you supplied in SetOverlayTexture above.
+		*
+		* You MUST call ReleaseNativeOverlayHandle() with pNativeTextureHandle once you are done with this texture.
+		*
+		* pNativeTextureHandle is an OUTPUT, it will be a pointer to a ID3D11ShaderResourceView *.
+		* pNativeTextureRef is an INPUT and should be a ID3D11Resource *. The device used by pNativeTextureRef will be used to bind pNativeTextureHandle.
+		*/
+	virtual EVROverlayError GetOverlayTexture(VROverlayHandle_t ulOverlayHandle, void **pNativeTextureHandle, void *pNativeTextureRef, uint32_t *pWidth, uint32_t *pHeight, uint32_t *pNativeFormat, ETextureType *pAPIType, EColorSpace *pColorSpace, VRTextureBounds_t *pTextureBounds) = 0;
+
+	/** Release the pNativeTextureHandle provided from the GetOverlayTexture call, this allows the system to free the underlying GPU resources for this object,
+		* so only do it once you stop rendering this texture.
+		*/
+	virtual EVROverlayError ReleaseNativeOverlayHandle(VROverlayHandle_t ulOverlayHandle, void *pNativeTextureHandle) = 0;
+
+	/** Get the size of the overlay texture */
+	virtual EVROverlayError GetOverlayTextureSize(VROverlayHandle_t ulOverlayHandle, uint32_t *pWidth, uint32_t *pHeight) = 0;
+
+	// ----------------------------------------------
+	// Dashboard Overlay Methods
+	// ----------------------------------------------
+
+	/** Creates a dashboard overlay and returns its handle */
+	virtual EVROverlayError CreateDashboardOverlay(const char *pchOverlayKey, const char *pchOverlayFriendlyName, VROverlayHandle_t *pMainHandle, VROverlayHandle_t *pThumbnailHandle) = 0;
+
+	/** Returns true if the dashboard is visible */
+	virtual bool IsDashboardVisible() = 0;
+
+	/** returns true if the dashboard is visible and the specified overlay is the active system Overlay */
+	virtual bool IsActiveDashboardOverlay(VROverlayHandle_t ulOverlayHandle) = 0;
+
+	/** Sets the dashboard overlay to only appear when the specified process ID has scene focus */
+	virtual EVROverlayError SetDashboardOverlaySceneProcess(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = 0;
+
+	/** Gets the process ID that this dashboard overlay requires to have scene focus */
+	virtual EVROverlayError GetDashboardOverlaySceneProcess(VROverlayHandle_t ulOverlayHandle, uint32_t *punProcessId) = 0;
+
+	/** Shows the dashboard. */
+	virtual void ShowDashboard(const char *pchOverlayToShow) = 0;
+
+	/** Returns the tracked device that has the laser pointer in the dashboard */
+	virtual vr::TrackedDeviceIndex_t GetPrimaryDashboardDevice() = 0;
+
+	// ---------------------------------------------
+	// Keyboard methods
+	// ---------------------------------------------
+
+	/** Show the virtual keyboard to accept input **/
+	virtual EVROverlayError ShowKeyboard(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char *pchDescription, uint32_t unCharMax, const char *pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = 0;
+
+	virtual EVROverlayError ShowKeyboardForOverlay(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char *pchDescription, uint32_t unCharMax, const char *pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = 0;
+
+	/** Get the text that was entered into the text input **/
+	virtual uint32_t GetKeyboardText(VR_OUT_STRING() char *pchText, uint32_t cchText) = 0;
+
+	/** Hide the virtual keyboard **/
+	virtual void HideKeyboard() = 0;
+
+	/** Set the position of the keyboard in world space **/
+	virtual void SetKeyboardTransformAbsolute(ETrackingUniverseOrigin eTrackingOrigin, const HmdMatrix34_t *pmatTrackingOriginToKeyboardTransform) = 0;
+
+	/** Set the position of the keyboard in overlay space by telling it to avoid a rectangle in the overlay. Rectangle coords have (0,0) in the bottom left **/
+	virtual void SetKeyboardPositionForOverlay(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = 0;
+
+	// ---------------------------------------------
+	// Overlay input methods
+	// ---------------------------------------------
+
+	/** Sets a list of primitives to be used for controller ray intersection
+		* typically the size of the underlying UI in pixels (not in world space). */
+	virtual EVROverlayError SetOverlayIntersectionMask(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t *pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize = sizeof(VROverlayIntersectionMaskPrimitive_t)) = 0;
+
+	virtual EVROverlayError GetOverlayFlags(VROverlayHandle_t ulOverlayHandle, uint32_t *pFlags) = 0;
+
+	// ---------------------------------------------
+	// Message box methods
+	// ---------------------------------------------
+
+	/** Show the message overlay. This will block and return you a result. **/
+	virtual VRMessageOverlayResponse ShowMessageOverlay(const char *pchText, const char *pchCaption, const char *pchButton0Text, const char *pchButton1Text = nullptr, const char *pchButton2Text = nullptr, const char *pchButton3Text = nullptr) = 0;
+
+	/** If the calling process owns the overlay and it's open, this will close it. **/
+	virtual void CloseMessageOverlay() = 0;
+};
+
+static const char *const IVROverlay_Version = "IVROverlay_016";
+
+}  // namespace vr
+
+// ivrrendermodels.h
+namespace vr
+{
+static const char *const k_pch_Controller_Component_GDC2015 = "gdc2015";    // Canonical coordinate system of the gdc 2015 wired controller, provided for backwards compatibility
+static const char *const k_pch_Controller_Component_Base = "base";          // For controllers with an unambiguous 'base'.
+static const char *const k_pch_Controller_Component_Tip = "tip";            // For controllers with an unambiguous 'tip' (used for 'laser-pointing')
+static const char *const k_pch_Controller_Component_HandGrip = "handgrip";  // Neutral, ambidextrous hand-pose when holding controller. On plane between neutrally posed index finger and thumb
+static const char *const k_pch_Controller_Component_Status = "status";      // 1:1 aspect ratio status area, with canonical [0,1] uv mapping
+
+#pragma pack(push, 8)
+
+/** Errors that can occur with the VR compositor */
+enum EVRRenderModelError
+{
+	VRRenderModelError_None = 0,
+	VRRenderModelError_Loading = 100,
+	VRRenderModelError_NotSupported = 200,
+	VRRenderModelError_InvalidArg = 300,
+	VRRenderModelError_InvalidModel = 301,
+	VRRenderModelError_NoShapes = 302,
+	VRRenderModelError_MultipleShapes = 303,
+	VRRenderModelError_TooManyVertices = 304,
+	VRRenderModelError_MultipleTextures = 305,
+	VRRenderModelError_BufferTooSmall = 306,
+	VRRenderModelError_NotEnoughNormals = 307,
+	VRRenderModelError_NotEnoughTexCoords = 308,
+
+	VRRenderModelError_InvalidTexture = 400,
+};
+
+typedef uint32_t VRComponentProperties;
+
+enum EVRComponentProperty
+{
+	VRComponentProperty_IsStatic = (1 << 0),
+	VRComponentProperty_IsVisible = (1 << 1),
+	VRComponentProperty_IsTouched = (1 << 2),
+	VRComponentProperty_IsPressed = (1 << 3),
+	VRComponentProperty_IsScrolled = (1 << 4),
+};
+
+/** Describes state information about a render-model component, including transforms and other dynamic properties */
+struct RenderModel_ComponentState_t
+{
+	HmdMatrix34_t mTrackingToComponentRenderModel;  // Transform required when drawing the component render model
+	HmdMatrix34_t mTrackingToComponentLocal;        // Transform available for attaching to a local component coordinate system (-Z out from surface )
+	VRComponentProperties uProperties;
+};
+
+/** A single vertex in a render model */
+struct RenderModel_Vertex_t
+{
+	HmdVector3_t vPosition;  // position in meters in device space
+	HmdVector3_t vNormal;
+	float rfTextureCoord[2];
+};
+
+/** A texture map for use on a render model */
+#if defined(__linux__) || defined(__APPLE__)
+// This structure was originally defined mis-packed on Linux, preserved for
+// compatibility.
+#pragma pack(push, 4)
+#endif
+
+struct RenderModel_TextureMap_t
+{
+	uint16_t unWidth, unHeight;        // width and height of the texture map in pixels
+	const uint8_t *rubTextureMapData;  // Map texture data. All textures are RGBA with 8 bits per channel per pixel. Data size is width * height * 4ub
+};
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+
+/**  Session unique texture identifier. Rendermodels which share the same texture will have the same id.
+IDs <0 denote the texture is not present */
+
+typedef int32_t TextureID_t;
+
+const TextureID_t INVALID_TEXTURE_ID = -1;
+
+#if defined(__linux__) || defined(__APPLE__)
+// This structure was originally defined mis-packed on Linux, preserved for
+// compatibility.
+#pragma pack(push, 4)
+#endif
+
+struct RenderModel_t
+{
+	const RenderModel_Vertex_t *rVertexData;  // Vertex data for the mesh
+	uint32_t unVertexCount;                   // Number of vertices in the vertex data
+	const uint16_t *rIndexData;               // Indices into the vertex data for each triangle
+	uint32_t unTriangleCount;                 // Number of triangles in the mesh. Index count is 3 * TriangleCount
+	TextureID_t diffuseTextureId;             // Session unique texture identifier. Rendermodels which share the same texture will have the same id. <0 == texture not present
+};
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+
+struct RenderModel_ControllerMode_State_t
+{
+	bool bScrollWheelVisible;  // is this controller currently set to be in a scroll wheel mode
+};
+
+#pragma pack(pop)
+
+class IVRRenderModels
+{
+public:
+	/** Loads and returns a render model for use in the application. pchRenderModelName should be a render model name
+	* from the Prop_RenderModelName_String property or an absolute path name to a render model on disk. 
+	*
+	* The resulting render model is valid until VR_Shutdown() is called or until FreeRenderModel() is called. When the 
+	* application is finished with the render model it should call FreeRenderModel() to free the memory associated
+	* with the model.
+	*
+	* The method returns VRRenderModelError_Loading while the render model is still being loaded.
+	* The method returns VRRenderModelError_None once loaded successfully, otherwise will return an error. */
+	virtual EVRRenderModelError LoadRenderModel_Async(const char *pchRenderModelName, RenderModel_t **ppRenderModel) = 0;
+
+	/** Frees a previously returned render model
+	*   It is safe to call this on a null ptr. */
+	virtual void FreeRenderModel(RenderModel_t *pRenderModel) = 0;
+
+	/** Loads and returns a texture for use in the application. */
+	virtual EVRRenderModelError LoadTexture_Async(TextureID_t textureId, RenderModel_TextureMap_t **ppTexture) = 0;
+
+	/** Frees a previously returned texture
+	*   It is safe to call this on a null ptr. */
+	virtual void FreeTexture(RenderModel_TextureMap_t *pTexture) = 0;
+
+	/** Creates a D3D11 texture and loads data into it. */
+	virtual EVRRenderModelError LoadTextureD3D11_Async(TextureID_t textureId, void *pD3D11Device, void **ppD3D11Texture2D) = 0;
+
+	/** Helper function to copy the bits into an existing texture. */
+	virtual EVRRenderModelError LoadIntoTextureD3D11_Async(TextureID_t textureId, void *pDstTexture) = 0;
+
+	/** Use this to free textures created with LoadTextureD3D11_Async instead of calling Release on them. */
+	virtual void FreeTextureD3D11(void *pD3D11Texture2D) = 0;
+
+	/** Use this to get the names of available render models.  Index does not correlate to a tracked device index, but
+	* is only used for iterating over all available render models.  If the index is out of range, this function will return 0.
+	* Otherwise, it will return the size of the buffer required for the name. */
+	virtual uint32_t GetRenderModelName(uint32_t unRenderModelIndex, VR_OUT_STRING() char *pchRenderModelName, uint32_t unRenderModelNameLen) = 0;
+
+	/** Returns the number of available render models. */
+	virtual uint32_t GetRenderModelCount() = 0;
+
+	/** Returns the number of components of the specified render model.
+	*  Components are useful when client application wish to draw, label, or otherwise interact with components of tracked objects.
+	*  Examples controller components:
+	*   renderable things such as triggers, buttons
+	*   non-renderable things which include coordinate systems such as 'tip', 'base', a neutral controller agnostic hand-pose
+	*   If all controller components are enumerated and rendered, it will be equivalent to drawing the traditional render model
+	*   Returns 0 if components not supported, >0 otherwise */
+	virtual uint32_t GetComponentCount(const char *pchRenderModelName) = 0;
+
+	/** Use this to get the names of available components.  Index does not correlate to a tracked device index, but
+	* is only used for iterating over all available components.  If the index is out of range, this function will return 0.
+	* Otherwise, it will return the size of the buffer required for the name. */
+	virtual uint32_t GetComponentName(const char *pchRenderModelName, uint32_t unComponentIndex, VR_OUT_STRING() char *pchComponentName, uint32_t unComponentNameLen) = 0;
+
+	/** Get the button mask for all buttons associated with this component
+	*   If no buttons (or axes) are associated with this component, return 0
+	*   Note: multiple components may be associated with the same button. Ex: two grip buttons on a single controller.
+	*   Note: A single component may be associated with multiple buttons. Ex: A trackpad which also provides "D-pad" functionality */
+	virtual uint64_t GetComponentButtonMask(const char *pchRenderModelName, const char *pchComponentName) = 0;
+
+	/** Use this to get the render model name for the specified rendermode/component combination, to be passed to LoadRenderModel.
+	* If the component name is out of range, this function will return 0.
+	* Otherwise, it will return the size of the buffer required for the name. */
+	virtual uint32_t GetComponentRenderModelName(const char *pchRenderModelName, const char *pchComponentName, VR_OUT_STRING() char *pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen) = 0;
+
+	/** Use this to query information about the component, as a function of the controller state.
+	*
+	* For dynamic controller components (ex: trigger) values will reflect component motions
+	* For static components this will return a consistent value independent of the VRControllerState_t
+	*
+	* If the pchRenderModelName or pchComponentName is invalid, this will return false (and transforms will be set to identity).
+	* Otherwise, return true
+	* Note: For dynamic objects, visibility may be dynamic. (I.e., true/false will be returned based on controller state and controller mode state ) */
+	virtual bool GetComponentState(const char *pchRenderModelName, const char *pchComponentName, const vr::VRControllerState_t *pControllerState, const RenderModel_ControllerMode_State_t *pState, RenderModel_ComponentState_t *pComponentState) = 0;
+
+	/** Returns true if the render model has a component with the specified name */
+	virtual bool RenderModelHasComponent(const char *pchRenderModelName, const char *pchComponentName) = 0;
+
+	/** Returns the URL of the thumbnail image for this rendermodel */
+	virtual uint32_t GetRenderModelThumbnailURL(const char *pchRenderModelName, VR_OUT_STRING() char *pchThumbnailURL, uint32_t unThumbnailURLLen, vr::EVRRenderModelError *peError) = 0;
+
+	/** Provides a render model path that will load the unskinned model if the model name provided has been replace by the user. If the model
+	* hasn't been replaced the path value will still be a valid path to load the model. Pass this to LoadRenderModel_Async, etc. to load the
+	* model. */
+	virtual uint32_t GetRenderModelOriginalPath(const char *pchRenderModelName, VR_OUT_STRING() char *pchOriginalPath, uint32_t unOriginalPathLen, vr::EVRRenderModelError *peError) = 0;
+
+	/** Returns a string for a render model error */
+	virtual const char *GetRenderModelErrorNameFromEnum(vr::EVRRenderModelError error) = 0;
+};
+
+static const char *const IVRRenderModels_Version = "IVRRenderModels_005";
+
+}  // namespace vr
+
+// ivrextendeddisplay.h
+namespace vr
+{
+/** NOTE: Use of this interface is not recommended in production applications. It will not work for displays which use
+	* direct-to-display mode. Creating our own window is also incompatible with the VR compositor and is not available when the compositor is running. */
+class IVRExtendedDisplay
+{
+public:
+	/** Size and position that the window needs to be on the VR display. */
+	virtual void GetWindowBounds(int32_t *pnX, int32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight) = 0;
+
+	/** Gets the viewport in the frame buffer to draw the output of the distortion into */
+	virtual void GetEyeOutputViewport(EVREye eEye, uint32_t *pnX, uint32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight) = 0;
+
+	/** [D3D10/11 Only]
+		* Returns the adapter index and output index that the user should pass into EnumAdapters and EnumOutputs
+		* to create the device and swap chain in DX10 and DX11. If an error occurs both indices will be set to -1.
+		*/
+	virtual void GetDXGIOutputInfo(int32_t *pnAdapterIndex, int32_t *pnAdapterOutputIndex) = 0;
+};
+
+static const char *const IVRExtendedDisplay_Version = "IVRExtendedDisplay_001";
+
+}  // namespace vr
+
+// ivrtrackedcamera.h
+namespace vr
+{
+class IVRTrackedCamera
+{
+public:
+	/** Returns a string for an error */
+	virtual const char *GetCameraErrorNameFromEnum(vr::EVRTrackedCameraError eCameraError) = 0;
+
+	/** For convenience, same as tracked property request Prop_HasCamera_Bool */
+	virtual vr::EVRTrackedCameraError HasCamera(vr::TrackedDeviceIndex_t nDeviceIndex, bool *pHasCamera) = 0;
+
+	/** Gets size of the image frame. */
+	virtual vr::EVRTrackedCameraError GetCameraFrameSize(vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, uint32_t *pnWidth, uint32_t *pnHeight, uint32_t *pnFrameBufferSize) = 0;
+
+	virtual vr::EVRTrackedCameraError GetCameraIntrinsics(vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, vr::HmdVector2_t *pFocalLength, vr::HmdVector2_t *pCenter) = 0;
+
+	virtual vr::EVRTrackedCameraError GetCameraProjection(vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, vr::HmdMatrix44_t *pProjection) = 0;
+
+	/** Acquiring streaming service permits video streaming for the caller. Releasing hints the system that video services do not need to be maintained for this client.
+	* If the camera has not already been activated, a one time spin up may incur some auto exposure as well as initial streaming frame delays.
+	* The camera should be considered a global resource accessible for shared consumption but not exclusive to any caller.
+	* The camera may go inactive due to lack of active consumers or headset idleness. */
+	virtual vr::EVRTrackedCameraError AcquireVideoStreamingService(vr::TrackedDeviceIndex_t nDeviceIndex, vr::TrackedCameraHandle_t *pHandle) = 0;
+	virtual vr::EVRTrackedCameraError ReleaseVideoStreamingService(vr::TrackedCameraHandle_t hTrackedCamera) = 0;
+
+	/** Copies the image frame into a caller's provided buffer. The image data is currently provided as RGBA data, 4 bytes per pixel.
+	* A caller can provide null for the framebuffer or frameheader if not desired. Requesting the frame header first, followed by the frame buffer allows
+	* the caller to determine if the frame as advanced per the frame header sequence. 
+	* If there is no frame available yet, due to initial camera spinup or re-activation, the error will be VRTrackedCameraError_NoFrameAvailable.
+	* Ideally a caller should be polling at ~16ms intervals */
+	virtual vr::EVRTrackedCameraError GetVideoStreamFrameBuffer(vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, void *pFrameBuffer, uint32_t nFrameBufferSize, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize) = 0;
+
+	/** Gets size of the image frame. */
+	virtual vr::EVRTrackedCameraError GetVideoStreamTextureSize(vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, vr::VRTextureBounds_t *pTextureBounds, uint32_t *pnWidth, uint32_t *pnHeight) = 0;
+
+	/** Access a shared D3D11 texture for the specified tracked camera stream.
+	* The camera frame type VRTrackedCameraFrameType_Undistorted is not supported directly as a shared texture. It is an interior subregion of the shared texture VRTrackedCameraFrameType_MaximumUndistorted.
+	* Instead, use GetVideoStreamTextureSize() with VRTrackedCameraFrameType_Undistorted to determine the proper interior subregion bounds along with GetVideoStreamTextureD3D11() with
+	* VRTrackedCameraFrameType_MaximumUndistorted to provide the texture. The VRTrackedCameraFrameType_MaximumUndistorted will yield an image where the invalid regions are decoded
+	* by the alpha channel having a zero component. The valid regions all have a non-zero alpha component. The subregion as described by VRTrackedCameraFrameType_Undistorted 
+	* guarantees a rectangle where all pixels are valid. */
+	virtual vr::EVRTrackedCameraError GetVideoStreamTextureD3D11(vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize) = 0;
+
+	/** Access a shared GL texture for the specified tracked camera stream */
+	virtual vr::EVRTrackedCameraError GetVideoStreamTextureGL(vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, vr::glUInt_t *pglTextureId, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize) = 0;
+	virtual vr::EVRTrackedCameraError ReleaseVideoStreamTextureGL(vr::TrackedCameraHandle_t hTrackedCamera, vr::glUInt_t glTextureId) = 0;
+};
+
+static const char *const IVRTrackedCamera_Version = "IVRTrackedCamera_003";
+
+}  // namespace vr
+
+// ivrscreenshots.h
+namespace vr
+{
+/** Errors that can occur with the VR compositor */
+enum EVRScreenshotError
+{
+	VRScreenshotError_None = 0,
+	VRScreenshotError_RequestFailed = 1,
+	VRScreenshotError_IncompatibleVersion = 100,
+	VRScreenshotError_NotFound = 101,
+	VRScreenshotError_BufferTooSmall = 102,
+	VRScreenshotError_ScreenshotAlreadyInProgress = 108,
+};
+
+/** Allows the application to generate screenshots */
+class IVRScreenshots
+{
+public:
+	/** Request a screenshot of the requested type.
+	 *  A request of the VRScreenshotType_Stereo type will always
+	 *  work. Other types will depend on the underlying application
+	 *  support.
+	 *  The first file name is for the preview image and should be a
+	 *  regular screenshot (ideally from the left eye). The second
+	 *  is the VR screenshot in the correct format. They should be
+	 *  in the same aspect ratio.  Formats per type:
+	 *  VRScreenshotType_Mono: the VR filename is ignored (can be
+	 *  nullptr), this is a normal flat single shot.
+	 *  VRScreenshotType_Stereo:  The VR image should be a
+	 *  side-by-side with the left eye image on the left.
+	 *  VRScreenshotType_Cubemap: The VR image should be six square
+	 *  images composited horizontally.
+	 *  VRScreenshotType_StereoPanorama: above/below with left eye
+	 *  panorama being the above image.  Image is typically square
+	 *  with the panorama being 2x horizontal.
+	 *  
+	 *  Note that the VR dashboard will call this function when
+	 *  the user presses the screenshot binding (currently System
+	 *  Button + Trigger).  If Steam is running, the destination
+	 *  file names will be in %TEMP% and will be copied into
+	 *  Steam's screenshot library for the running application
+	 *  once SubmitScreenshot() is called.
+	 *  If Steam is not running, the paths will be in the user's
+	 *  documents folder under Documents\SteamVR\Screenshots.
+	 *  Other VR applications can call this to initiate a
+	 *  screenshot outside of user control.
+	 *  The destination file names do not need an extension,
+	 *  will be replaced with the correct one for the format
+	 *  which is currently .png. */
+	virtual vr::EVRScreenshotError RequestScreenshot(vr::ScreenshotHandle_t *pOutScreenshotHandle, vr::EVRScreenshotType type, const char *pchPreviewFilename, const char *pchVRFilename) = 0;
+
+	/** Called by the running VR application to indicate that it
+	 *  wishes to be in charge of screenshots.  If the
+	 *  application does not call this, the Compositor will only
+	 *  support VRScreenshotType_Stereo screenshots that will be
+	 *  captured without notification to the running app.
+	 *  Once hooked your application will receive a
+	 *  VREvent_RequestScreenshot event when the user presses the
+	 *  buttons to take a screenshot. */
+	virtual vr::EVRScreenshotError HookScreenshot(VR_ARRAY_COUNT(numTypes) const vr::EVRScreenshotType *pSupportedTypes, int numTypes) = 0;
+
+	/** When your application receives a
+	 *  VREvent_RequestScreenshot event, call these functions to get
+	 *  the details of the screenshot request. */
+	virtual vr::EVRScreenshotType GetScreenshotPropertyType(vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotError *pError) = 0;
+
+	/** Get the filename for the preview or vr image (see
+	 *  vr::EScreenshotPropertyFilenames).  The return value is
+	 *  the size of the string.   */
+	virtual uint32_t GetScreenshotPropertyFilename(vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotPropertyFilenames filenameType, VR_OUT_STRING() char *pchFilename, uint32_t cchFilename, vr::EVRScreenshotError *pError) = 0;
+
+	/** Call this if the application is taking the screen shot
+	 *  will take more than a few ms processing. This will result
+	 *  in an overlay being presented that shows a completion
+	 *  bar. */
+	virtual vr::EVRScreenshotError UpdateScreenshotProgress(vr::ScreenshotHandle_t screenshotHandle, float flProgress) = 0;
+
+	/** Tells the compositor to take an internal screenshot of
+	 *  type VRScreenshotType_Stereo. It will take the current
+	 *  submitted scene textures of the running application and
+	 *  write them into the preview image and a side-by-side file
+	 *  for the VR image.
+	 *  This is similar to request screenshot, but doesn't ever
+	 *  talk to the application, just takes the shot and submits. */
+	virtual vr::EVRScreenshotError TakeStereoScreenshot(vr::ScreenshotHandle_t *pOutScreenshotHandle, const char *pchPreviewFilename, const char *pchVRFilename) = 0;
+
+	/** Submit the completed screenshot.  If Steam is running
+	 *  this will call into the Steam client and upload the
+	 *  screenshot to the screenshots section of the library for
+	 *  the running application.  If Steam is not running, this
+	 *  function will display a notification to the user that the
+	 *  screenshot was taken. The paths should be full paths with
+	 *  extensions.
+	 *  File paths should be absolute including extensions.
+	 *  screenshotHandle can be k_unScreenshotHandleInvalid if this
+	 *  was a new shot taking by the app to be saved and not
+	 *  initiated by a user (achievement earned or something) */
+	virtual vr::EVRScreenshotError SubmitScreenshot(vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotType type, const char *pchSourcePreviewFilename, const char *pchSourceVRFilename) = 0;
+};
+
+static const char *const IVRScreenshots_Version = "IVRScreenshots_001";
+
+}  // namespace vr
+
+// ivrresources.h
+namespace vr
+{
+class IVRResources
+{
+public:
+	// ------------------------------------
+	// Shared Resource Methods
+	// ------------------------------------
+
+	/** Loads the specified resource into the provided buffer if large enough.
+	* Returns the size in bytes of the buffer required to hold the specified resource. */
+	virtual uint32_t LoadSharedResource(const char *pchResourceName, char *pchBuffer, uint32_t unBufferLen) = 0;
+
+	/** Provides the full path to the specified resource. Resource names can include named directories for
+	* drivers and other things, and this resolves all of those and returns the actual physical path. 
+	* pchResourceTypeDirectory is the subdirectory of resources to look in. */
+	virtual uint32_t GetResourceFullPath(const char *pchResourceName, const char *pchResourceTypeDirectory, char *pchPathBuffer, uint32_t unBufferLen) = 0;
+};
+
+static const char *const IVRResources_Version = "IVRResources_001";
+
+}  // namespace vr
+// ivrdrivermanager.h
+namespace vr
+{
+class IVRDriverManager
+{
+public:
+	virtual uint32_t GetDriverCount() const = 0;
+
+	/** Returns the length of the number of bytes necessary to hold this string including the trailing null. */
+	virtual uint32_t GetDriverName(vr::DriverId_t nDriver, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize) = 0;
+};
+
+static const char *const IVRDriverManager_Version = "IVRDriverManager_001";
+
+}  // namespace vr
+
+// End
+
+#endif  // _OPENVR_API
+
+namespace vr
+{
+/** Finds the active installation of the VR API and initializes it. The provided path must be absolute
+	* or relative to the current working directory. These are the local install versions of the equivalent
+	* functions in steamvr.h and will work without a local Steam install.
+	*
+	* This path is to the "root" of the VR API install. That's the directory with
+	* the "drivers" directory and a platform (i.e. "win32") directory in it, not the directory with the DLL itself.
+	*
+	* pStartupInfo is reserved for future use.
+	*/
+inline IVRSystem *VR_Init(EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo = nullptr);
+
+/** unloads vrclient.dll. Any interface pointers from the interface are
+	* invalid after this point */
+inline void VR_Shutdown();
+
+/** Returns true if there is an HMD attached. This check is as lightweight as possible and
+	* can be called outside of VR_Init/VR_Shutdown. It should be used when an application wants
+	* to know if initializing VR is a possibility but isn't ready to take that step yet.
+	*/
+VR_INTERFACE bool VR_CALLTYPE VR_IsHmdPresent();
+
+/** Returns true if the OpenVR runtime is installed. */
+VR_INTERFACE bool VR_CALLTYPE VR_IsRuntimeInstalled();
+
+/** Returns where the OpenVR runtime is installed. */
+VR_INTERFACE const char *VR_CALLTYPE VR_RuntimePath();
+
+/** Returns the name of the enum value for an EVRInitError. This function may be called outside of VR_Init()/VR_Shutdown(). */
+VR_INTERFACE const char *VR_CALLTYPE VR_GetVRInitErrorAsSymbol(EVRInitError error);
+
+/** Returns an English string for an EVRInitError. Applications should call VR_GetVRInitErrorAsSymbol instead and
+	* use that as a key to look up their own localized error message. This function may be called outside of VR_Init()/VR_Shutdown(). */
+VR_INTERFACE const char *VR_CALLTYPE VR_GetVRInitErrorAsEnglishDescription(EVRInitError error);
+
+/** Returns the interface of the specified version. This method must be called after VR_Init. The
+	* pointer returned is valid until VR_Shutdown is called.
+	*/
+VR_INTERFACE void *VR_CALLTYPE VR_GetGenericInterface(const char *pchInterfaceVersion, EVRInitError *peError);
+
+/** Returns whether the interface of the specified version exists.
+	*/
+VR_INTERFACE bool VR_CALLTYPE VR_IsInterfaceVersionValid(const char *pchInterfaceVersion);
+
+/** Returns a token that represents whether the VR interface handles need to be reloaded */
+VR_INTERFACE uint32_t VR_CALLTYPE VR_GetInitToken();
+
+// These typedefs allow old enum names from SDK 0.9.11 to be used in applications.
+// They will go away in the future.
+typedef EVRInitError HmdError;
+typedef EVREye Hmd_Eye;
+typedef EColorSpace ColorSpace;
+typedef ETrackingResult HmdTrackingResult;
+typedef ETrackedDeviceClass TrackedDeviceClass;
+typedef ETrackingUniverseOrigin TrackingUniverseOrigin;
+typedef ETrackedDeviceProperty TrackedDeviceProperty;
+typedef ETrackedPropertyError TrackedPropertyError;
+typedef EVRSubmitFlags VRSubmitFlags_t;
+typedef EVRState VRState_t;
+typedef ECollisionBoundsStyle CollisionBoundsStyle_t;
+typedef EVROverlayError VROverlayError;
+typedef EVRFirmwareError VRFirmwareError;
+typedef EVRCompositorError VRCompositorError;
+typedef EVRScreenshotError VRScreenshotsError;
+
+inline uint32_t &VRToken()
+{
+	static uint32_t token;
+	return token;
+}
+
+class COpenVRContext
+{
+public:
+	COpenVRContext() { Clear(); }
+	void Clear();
+
+	inline void CheckClear()
+	{
+		if (VRToken() != VR_GetInitToken())
+		{
+			Clear();
+			VRToken() = VR_GetInitToken();
+		}
+	}
+
+	IVRSystem *VRSystem()
+	{
+		CheckClear();
+		if (m_pVRSystem == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRSystem = (IVRSystem *)VR_GetGenericInterface(IVRSystem_Version, &eError);
+		}
+		return m_pVRSystem;
+	}
+	IVRChaperone *VRChaperone()
+	{
+		CheckClear();
+		if (m_pVRChaperone == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRChaperone = (IVRChaperone *)VR_GetGenericInterface(IVRChaperone_Version, &eError);
+		}
+		return m_pVRChaperone;
+	}
+
+	IVRChaperoneSetup *VRChaperoneSetup()
+	{
+		CheckClear();
+		if (m_pVRChaperoneSetup == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRChaperoneSetup = (IVRChaperoneSetup *)VR_GetGenericInterface(IVRChaperoneSetup_Version, &eError);
+		}
+		return m_pVRChaperoneSetup;
+	}
+
+	IVRCompositor *VRCompositor()
+	{
+		CheckClear();
+		if (m_pVRCompositor == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRCompositor = (IVRCompositor *)VR_GetGenericInterface(IVRCompositor_Version, &eError);
+		}
+		return m_pVRCompositor;
+	}
+
+	IVROverlay *VROverlay()
+	{
+		CheckClear();
+		if (m_pVROverlay == nullptr)
+		{
+			EVRInitError eError;
+			m_pVROverlay = (IVROverlay *)VR_GetGenericInterface(IVROverlay_Version, &eError);
+		}
+		return m_pVROverlay;
+	}
+
+	IVRResources *VRResources()
+	{
+		CheckClear();
+		if (m_pVRResources == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRResources = (IVRResources *)VR_GetGenericInterface(IVRResources_Version, &eError);
+		}
+		return m_pVRResources;
+	}
+
+	IVRScreenshots *VRScreenshots()
+	{
+		CheckClear();
+		if (m_pVRScreenshots == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRScreenshots = (IVRScreenshots *)VR_GetGenericInterface(IVRScreenshots_Version, &eError);
+		}
+		return m_pVRScreenshots;
+	}
+
+	IVRRenderModels *VRRenderModels()
+	{
+		CheckClear();
+		if (m_pVRRenderModels == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRRenderModels = (IVRRenderModels *)VR_GetGenericInterface(IVRRenderModels_Version, &eError);
+		}
+		return m_pVRRenderModels;
+	}
+
+	IVRExtendedDisplay *VRExtendedDisplay()
+	{
+		CheckClear();
+		if (m_pVRExtendedDisplay == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRExtendedDisplay = (IVRExtendedDisplay *)VR_GetGenericInterface(IVRExtendedDisplay_Version, &eError);
+		}
+		return m_pVRExtendedDisplay;
+	}
+
+	IVRSettings *VRSettings()
+	{
+		CheckClear();
+		if (m_pVRSettings == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRSettings = (IVRSettings *)VR_GetGenericInterface(IVRSettings_Version, &eError);
+		}
+		return m_pVRSettings;
+	}
+
+	IVRApplications *VRApplications()
+	{
+		CheckClear();
+		if (m_pVRApplications == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRApplications = (IVRApplications *)VR_GetGenericInterface(IVRApplications_Version, &eError);
+		}
+		return m_pVRApplications;
+	}
+
+	IVRTrackedCamera *VRTrackedCamera()
+	{
+		CheckClear();
+		if (m_pVRTrackedCamera == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRTrackedCamera = (IVRTrackedCamera *)VR_GetGenericInterface(IVRTrackedCamera_Version, &eError);
+		}
+		return m_pVRTrackedCamera;
+	}
+
+	IVRDriverManager *VRDriverManager()
+	{
+		CheckClear();
+		if (!m_pVRDriverManager)
+		{
+			EVRInitError eError;
+			m_pVRDriverManager = (IVRDriverManager *)VR_GetGenericInterface(IVRDriverManager_Version, &eError);
+		}
+		return m_pVRDriverManager;
+	}
+
+private:
+	IVRSystem *m_pVRSystem;
+	IVRChaperone *m_pVRChaperone;
+	IVRChaperoneSetup *m_pVRChaperoneSetup;
+	IVRCompositor *m_pVRCompositor;
+	IVROverlay *m_pVROverlay;
+	IVRResources *m_pVRResources;
+	IVRRenderModels *m_pVRRenderModels;
+	IVRExtendedDisplay *m_pVRExtendedDisplay;
+	IVRSettings *m_pVRSettings;
+	IVRApplications *m_pVRApplications;
+	IVRTrackedCamera *m_pVRTrackedCamera;
+	IVRScreenshots *m_pVRScreenshots;
+	IVRDriverManager *m_pVRDriverManager;
+};
+
+inline COpenVRContext &OpenVRInternal_ModuleContext()
+{
+	static void *ctx[sizeof(COpenVRContext) / sizeof(void *)];
+	return *(COpenVRContext *)ctx;  // bypass zero-init constructor
+}
+
+inline IVRSystem *VR_CALLTYPE VRSystem() { return OpenVRInternal_ModuleContext().VRSystem(); }
+inline IVRChaperone *VR_CALLTYPE VRChaperone() { return OpenVRInternal_ModuleContext().VRChaperone(); }
+inline IVRChaperoneSetup *VR_CALLTYPE VRChaperoneSetup() { return OpenVRInternal_ModuleContext().VRChaperoneSetup(); }
+inline IVRCompositor *VR_CALLTYPE VRCompositor() { return OpenVRInternal_ModuleContext().VRCompositor(); }
+inline IVROverlay *VR_CALLTYPE VROverlay() { return OpenVRInternal_ModuleContext().VROverlay(); }
+inline IVRScreenshots *VR_CALLTYPE VRScreenshots() { return OpenVRInternal_ModuleContext().VRScreenshots(); }
+inline IVRRenderModels *VR_CALLTYPE VRRenderModels() { return OpenVRInternal_ModuleContext().VRRenderModels(); }
+inline IVRApplications *VR_CALLTYPE VRApplications() { return OpenVRInternal_ModuleContext().VRApplications(); }
+inline IVRSettings *VR_CALLTYPE VRSettings() { return OpenVRInternal_ModuleContext().VRSettings(); }
+inline IVRResources *VR_CALLTYPE VRResources() { return OpenVRInternal_ModuleContext().VRResources(); }
+inline IVRExtendedDisplay *VR_CALLTYPE VRExtendedDisplay() { return OpenVRInternal_ModuleContext().VRExtendedDisplay(); }
+inline IVRTrackedCamera *VR_CALLTYPE VRTrackedCamera() { return OpenVRInternal_ModuleContext().VRTrackedCamera(); }
+inline IVRDriverManager *VR_CALLTYPE VRDriverManager() { return OpenVRInternal_ModuleContext().VRDriverManager(); }
+
+inline void COpenVRContext::Clear()
+{
+	m_pVRSystem = nullptr;
+	m_pVRChaperone = nullptr;
+	m_pVRChaperoneSetup = nullptr;
+	m_pVRCompositor = nullptr;
+	m_pVROverlay = nullptr;
+	m_pVRRenderModels = nullptr;
+	m_pVRExtendedDisplay = nullptr;
+	m_pVRSettings = nullptr;
+	m_pVRApplications = nullptr;
+	m_pVRTrackedCamera = nullptr;
+	m_pVRResources = nullptr;
+	m_pVRScreenshots = nullptr;
+	m_pVRDriverManager = nullptr;
+}
+
+VR_INTERFACE uint32_t VR_CALLTYPE VR_InitInternal2(EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo);
+VR_INTERFACE void VR_CALLTYPE VR_ShutdownInternal();
+
+/** Finds the active installation of vrclient.dll and initializes it */
+inline IVRSystem *VR_Init(EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo)
+{
+	IVRSystem *pVRSystem = nullptr;
+
+	EVRInitError eError;
+	VRToken() = VR_InitInternal2(&eError, eApplicationType, pStartupInfo);
+	COpenVRContext &ctx = OpenVRInternal_ModuleContext();
+	ctx.Clear();
+
+	if (eError == VRInitError_None)
+	{
+		if (VR_IsInterfaceVersionValid(IVRSystem_Version))
+		{
+			pVRSystem = VRSystem();
+		}
+		else
+		{
+			VR_ShutdownInternal();
+			eError = VRInitError_Init_InterfaceNotFound;
+		}
+	}
+
+	if (peError)
+		*peError = eError;
+	return pVRSystem;
+}
+
+/** unloads vrclient.dll. Any interface pointers from the interface are
+	* invalid after this point */
+inline void VR_Shutdown()
+{
+	VR_ShutdownInternal();
+}
+}  // namespace vr
diff --git a/engine/inc/bullet/ThirdPartyLibs/openvr/headers/openvr_capi.h b/engine/inc/bullet/ThirdPartyLibs/openvr/headers/openvr_capi.h
new file mode 100644
index 00000000..245365f4
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/openvr/headers/openvr_capi.h
@@ -0,0 +1,1932 @@
+//======= Copyright (c) Valve Corporation, All rights reserved. ===============
+//
+// Purpose: Header for flatted SteamAPI. Use this for binding to other languages.
+// This file is auto-generated, do not edit it.
+//
+//=============================================================================
+
+#ifndef __OPENVR_API_FLAT_H__
+#define __OPENVR_API_FLAT_H__
+#if defined(_WIN32) || defined(__clang__)
+#pragma once
+#endif
+
+#ifdef __cplusplus
+#define EXTERN_C extern "C"
+#else
+#define EXTERN_C
+#endif
+
+#if defined(_WIN32)
+#define OPENVR_FNTABLE_CALLTYPE __stdcall
+#else
+#define OPENVR_FNTABLE_CALLTYPE
+#endif
+
+// OPENVR API export macro
+#if defined(_WIN32) && !defined(_X360)
+#if defined(OPENVR_API_EXPORTS)
+#define S_API EXTERN_C __declspec(dllexport)
+#elif defined(OPENVR_API_NODLL)
+#define S_API EXTERN_C
+#else
+#define S_API extern "C" __declspec(dllimport)
+#endif  // OPENVR_API_EXPORTS
+#elif defined(__GNUC__)
+#if defined(OPENVR_API_EXPORTS)
+#define S_API EXTERN_C __attribute__((visibility("default")))
+#else
+#define S_API EXTERN_C
+#endif  // OPENVR_API_EXPORTS
+#else   // !WIN32
+#if defined(OPENVR_API_EXPORTS)
+#define S_API EXTERN_C
+#else
+#define S_API EXTERN_C
+#endif  // OPENVR_API_EXPORTS
+#endif
+
+#include <stdint.h>
+
+#if defined(__WIN32)
+typedef char bool;
+#else
+#include <stdbool.h>
+#endif
+
+typedef uint64_t PropertyContainerHandle_t;
+typedef uint32_t PropertyTypeTag_t;
+typedef uint64_t VRActionHandle_t;
+typedef uint64_t VRActionSetHandle_t;
+typedef uint64_t VRInputOriginHandle_t;
+
+// OpenVR Constants
+
+static const unsigned int k_nDriverNone = 4294967295;
+static const unsigned int k_unMaxDriverDebugResponseSize = 32768;
+static const unsigned int k_unTrackedDeviceIndex_Hmd = 0;
+static const unsigned int k_unMaxTrackedDeviceCount = 16;
+static const unsigned int k_unTrackedDeviceIndexOther = 4294967294;
+static const unsigned int k_unTrackedDeviceIndexInvalid = 4294967295;
+static const unsigned long k_ulInvalidPropertyContainer = 0;
+static const unsigned int k_unInvalidPropertyTag = 0;
+static const unsigned int k_unFloatPropertyTag = 1;
+static const unsigned int k_unInt32PropertyTag = 2;
+static const unsigned int k_unUint64PropertyTag = 3;
+static const unsigned int k_unBoolPropertyTag = 4;
+static const unsigned int k_unStringPropertyTag = 5;
+static const unsigned int k_unHmdMatrix34PropertyTag = 20;
+static const unsigned int k_unHmdMatrix44PropertyTag = 21;
+static const unsigned int k_unHmdVector3PropertyTag = 22;
+static const unsigned int k_unHmdVector4PropertyTag = 23;
+static const unsigned int k_unHiddenAreaPropertyTag = 30;
+static const unsigned int k_unOpenVRInternalReserved_Start = 1000;
+static const unsigned int k_unOpenVRInternalReserved_End = 10000;
+static const unsigned int k_unMaxPropertyStringSize = 32768;
+static const unsigned int k_unControllerStateAxisCount = 5;
+static const unsigned long k_ulOverlayHandleInvalid = 0;
+static const unsigned int k_unScreenshotHandleInvalid = 0;
+static const char *IVRSystem_Version = "IVRSystem_017";
+static const char *IVRExtendedDisplay_Version = "IVRExtendedDisplay_001";
+static const char *IVRTrackedCamera_Version = "IVRTrackedCamera_003";
+static const unsigned int k_unMaxApplicationKeyLength = 128;
+static const char *k_pch_MimeType_HomeApp = "vr/home";
+static const char *k_pch_MimeType_GameTheater = "vr/game_theater";
+static const char *IVRApplications_Version = "IVRApplications_006";
+static const char *IVRChaperone_Version = "IVRChaperone_003";
+static const char *IVRChaperoneSetup_Version = "IVRChaperoneSetup_005";
+static const char *IVRCompositor_Version = "IVRCompositor_021";
+static const unsigned int k_unVROverlayMaxKeyLength = 128;
+static const unsigned int k_unVROverlayMaxNameLength = 128;
+static const unsigned int k_unMaxOverlayCount = 64;
+static const unsigned int k_unMaxOverlayIntersectionMaskPrimitivesCount = 32;
+static const char *IVROverlay_Version = "IVROverlay_016";
+static const char *k_pch_Controller_Component_GDC2015 = "gdc2015";
+static const char *k_pch_Controller_Component_Base = "base";
+static const char *k_pch_Controller_Component_Tip = "tip";
+static const char *k_pch_Controller_Component_HandGrip = "handgrip";
+static const char *k_pch_Controller_Component_Status = "status";
+static const char *IVRRenderModels_Version = "IVRRenderModels_005";
+static const unsigned int k_unNotificationTextMaxSize = 256;
+static const char *IVRNotifications_Version = "IVRNotifications_002";
+static const unsigned int k_unMaxSettingsKeyLength = 128;
+static const char *IVRSettings_Version = "IVRSettings_002";
+static const char *k_pch_SteamVR_Section = "steamvr";
+static const char *k_pch_SteamVR_RequireHmd_String = "requireHmd";
+static const char *k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver";
+static const char *k_pch_SteamVR_ForcedHmdKey_String = "forcedHmd";
+static const char *k_pch_SteamVR_DisplayDebug_Bool = "displayDebug";
+static const char *k_pch_SteamVR_DebugProcessPipe_String = "debugProcessPipe";
+static const char *k_pch_SteamVR_DisplayDebugX_Int32 = "displayDebugX";
+static const char *k_pch_SteamVR_DisplayDebugY_Int32 = "displayDebugY";
+static const char *k_pch_SteamVR_SendSystemButtonToAllApps_Bool = "sendSystemButtonToAllApps";
+static const char *k_pch_SteamVR_LogLevel_Int32 = "loglevel";
+static const char *k_pch_SteamVR_IPD_Float = "ipd";
+static const char *k_pch_SteamVR_Background_String = "background";
+static const char *k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection";
+static const char *k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight";
+static const char *k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius";
+static const char *k_pch_SteamVR_GridColor_String = "gridColor";
+static const char *k_pch_SteamVR_PlayAreaColor_String = "playAreaColor";
+static const char *k_pch_SteamVR_ShowStage_Bool = "showStage";
+static const char *k_pch_SteamVR_ActivateMultipleDrivers_Bool = "activateMultipleDrivers";
+static const char *k_pch_SteamVR_DirectMode_Bool = "directMode";
+static const char *k_pch_SteamVR_DirectModeEdidVid_Int32 = "directModeEdidVid";
+static const char *k_pch_SteamVR_DirectModeEdidPid_Int32 = "directModeEdidPid";
+static const char *k_pch_SteamVR_UsingSpeakers_Bool = "usingSpeakers";
+static const char *k_pch_SteamVR_SpeakersForwardYawOffsetDegrees_Float = "speakersForwardYawOffsetDegrees";
+static const char *k_pch_SteamVR_BaseStationPowerManagement_Bool = "basestationPowerManagement";
+static const char *k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses";
+static const char *k_pch_SteamVR_SupersampleScale_Float = "supersampleScale";
+static const char *k_pch_SteamVR_AllowAsyncReprojection_Bool = "allowAsyncReprojection";
+static const char *k_pch_SteamVR_AllowReprojection_Bool = "allowInterleavedReprojection";
+static const char *k_pch_SteamVR_ForceReprojection_Bool = "forceReprojection";
+static const char *k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking";
+static const char *k_pch_SteamVR_DefaultMirrorView_Int32 = "defaultMirrorView";
+static const char *k_pch_SteamVR_ShowMirrorView_Bool = "showMirrorView";
+static const char *k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry";
+static const char *k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch";
+static const char *k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch";
+static const char *k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch";
+static const char *k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard";
+static const char *k_pch_SteamVR_EnableHomeApp = "enableHomeApp";
+static const char *k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec";
+static const char *k_pch_SteamVR_RetailDemo_Bool = "retailDemo";
+static const char *k_pch_SteamVR_IpdOffset_Float = "ipdOffset";
+static const char *k_pch_SteamVR_AllowSupersampleFiltering_Bool = "allowSupersampleFiltering";
+static const char *k_pch_SteamVR_EnableLinuxVulkanAsync_Bool = "enableLinuxVulkanAsync";
+static const char *k_pch_Lighthouse_Section = "driver_lighthouse";
+static const char *k_pch_Lighthouse_DisableIMU_Bool = "disableimu";
+static const char *k_pch_Lighthouse_UseDisambiguation_String = "usedisambiguation";
+static const char *k_pch_Lighthouse_DisambiguationDebug_Int32 = "disambiguationdebug";
+static const char *k_pch_Lighthouse_PrimaryBasestation_Int32 = "primarybasestation";
+static const char *k_pch_Lighthouse_DBHistory_Bool = "dbhistory";
+static const char *k_pch_Null_Section = "driver_null";
+static const char *k_pch_Null_SerialNumber_String = "serialNumber";
+static const char *k_pch_Null_ModelNumber_String = "modelNumber";
+static const char *k_pch_Null_WindowX_Int32 = "windowX";
+static const char *k_pch_Null_WindowY_Int32 = "windowY";
+static const char *k_pch_Null_WindowWidth_Int32 = "windowWidth";
+static const char *k_pch_Null_WindowHeight_Int32 = "windowHeight";
+static const char *k_pch_Null_RenderWidth_Int32 = "renderWidth";
+static const char *k_pch_Null_RenderHeight_Int32 = "renderHeight";
+static const char *k_pch_Null_SecondsFromVsyncToPhotons_Float = "secondsFromVsyncToPhotons";
+static const char *k_pch_Null_DisplayFrequency_Float = "displayFrequency";
+static const char *k_pch_UserInterface_Section = "userinterface";
+static const char *k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop";
+static const char *k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray";
+static const char *k_pch_UserInterface_Screenshots_Bool = "screenshots";
+static const char *k_pch_UserInterface_ScreenshotType_Int = "screenshotType";
+static const char *k_pch_Notifications_Section = "notifications";
+static const char *k_pch_Notifications_DoNotDisturb_Bool = "DoNotDisturb";
+static const char *k_pch_Keyboard_Section = "keyboard";
+static const char *k_pch_Keyboard_TutorialCompletions = "TutorialCompletions";
+static const char *k_pch_Keyboard_ScaleX = "ScaleX";
+static const char *k_pch_Keyboard_ScaleY = "ScaleY";
+static const char *k_pch_Keyboard_OffsetLeftX = "OffsetLeftX";
+static const char *k_pch_Keyboard_OffsetRightX = "OffsetRightX";
+static const char *k_pch_Keyboard_OffsetY = "OffsetY";
+static const char *k_pch_Keyboard_Smoothing = "Smoothing";
+static const char *k_pch_Perf_Section = "perfcheck";
+static const char *k_pch_Perf_HeuristicActive_Bool = "heuristicActive";
+static const char *k_pch_Perf_NotifyInHMD_Bool = "warnInHMD";
+static const char *k_pch_Perf_NotifyOnlyOnce_Bool = "warnOnlyOnce";
+static const char *k_pch_Perf_AllowTimingStore_Bool = "allowTimingStore";
+static const char *k_pch_Perf_SaveTimingsOnExit_Bool = "saveTimingsOnExit";
+static const char *k_pch_Perf_TestData_Float = "perfTestData";
+static const char *k_pch_Perf_LinuxGPUProfiling_Bool = "linuxGPUProfiling";
+static const char *k_pch_CollisionBounds_Section = "collisionBounds";
+static const char *k_pch_CollisionBounds_Style_Int32 = "CollisionBoundsStyle";
+static const char *k_pch_CollisionBounds_GroundPerimeterOn_Bool = "CollisionBoundsGroundPerimeterOn";
+static const char *k_pch_CollisionBounds_CenterMarkerOn_Bool = "CollisionBoundsCenterMarkerOn";
+static const char *k_pch_CollisionBounds_PlaySpaceOn_Bool = "CollisionBoundsPlaySpaceOn";
+static const char *k_pch_CollisionBounds_FadeDistance_Float = "CollisionBoundsFadeDistance";
+static const char *k_pch_CollisionBounds_ColorGammaR_Int32 = "CollisionBoundsColorGammaR";
+static const char *k_pch_CollisionBounds_ColorGammaG_Int32 = "CollisionBoundsColorGammaG";
+static const char *k_pch_CollisionBounds_ColorGammaB_Int32 = "CollisionBoundsColorGammaB";
+static const char *k_pch_CollisionBounds_ColorGammaA_Int32 = "CollisionBoundsColorGammaA";
+static const char *k_pch_Camera_Section = "camera";
+static const char *k_pch_Camera_EnableCamera_Bool = "enableCamera";
+static const char *k_pch_Camera_EnableCameraInDashboard_Bool = "enableCameraInDashboard";
+static const char *k_pch_Camera_EnableCameraForCollisionBounds_Bool = "enableCameraForCollisionBounds";
+static const char *k_pch_Camera_EnableCameraForRoomView_Bool = "enableCameraForRoomView";
+static const char *k_pch_Camera_BoundsColorGammaR_Int32 = "cameraBoundsColorGammaR";
+static const char *k_pch_Camera_BoundsColorGammaG_Int32 = "cameraBoundsColorGammaG";
+static const char *k_pch_Camera_BoundsColorGammaB_Int32 = "cameraBoundsColorGammaB";
+static const char *k_pch_Camera_BoundsColorGammaA_Int32 = "cameraBoundsColorGammaA";
+static const char *k_pch_Camera_BoundsStrength_Int32 = "cameraBoundsStrength";
+static const char *k_pch_audio_Section = "audio";
+static const char *k_pch_audio_OnPlaybackDevice_String = "onPlaybackDevice";
+static const char *k_pch_audio_OnRecordDevice_String = "onRecordDevice";
+static const char *k_pch_audio_OnPlaybackMirrorDevice_String = "onPlaybackMirrorDevice";
+static const char *k_pch_audio_OffPlaybackDevice_String = "offPlaybackDevice";
+static const char *k_pch_audio_OffRecordDevice_String = "offRecordDevice";
+static const char *k_pch_audio_VIVEHDMIGain = "viveHDMIGain";
+static const char *k_pch_Power_Section = "power";
+static const char *k_pch_Power_PowerOffOnExit_Bool = "powerOffOnExit";
+static const char *k_pch_Power_TurnOffScreensTimeout_Float = "turnOffScreensTimeout";
+static const char *k_pch_Power_TurnOffControllersTimeout_Float = "turnOffControllersTimeout";
+static const char *k_pch_Power_ReturnToWatchdogTimeout_Float = "returnToWatchdogTimeout";
+static const char *k_pch_Power_AutoLaunchSteamVROnButtonPress = "autoLaunchSteamVROnButtonPress";
+static const char *k_pch_Power_PauseCompositorOnStandby_Bool = "pauseCompositorOnStandby";
+static const char *k_pch_Dashboard_Section = "dashboard";
+static const char *k_pch_Dashboard_EnableDashboard_Bool = "enableDashboard";
+static const char *k_pch_Dashboard_ArcadeMode_Bool = "arcadeMode";
+static const char *k_pch_modelskin_Section = "modelskins";
+static const char *k_pch_Driver_Enable_Bool = "enable";
+static const char *IVRScreenshots_Version = "IVRScreenshots_001";
+static const char *IVRResources_Version = "IVRResources_001";
+static const char *IVRDriverManager_Version = "IVRDriverManager_001";
+
+// OpenVR Enums
+
+typedef enum EVREye
+{
+	EVREye_Eye_Left = 0,
+	EVREye_Eye_Right = 1,
+} EVREye;
+
+typedef enum ETextureType
+{
+	ETextureType_TextureType_DirectX = 0,
+	ETextureType_TextureType_OpenGL = 1,
+	ETextureType_TextureType_Vulkan = 2,
+	ETextureType_TextureType_IOSurface = 3,
+	ETextureType_TextureType_DirectX12 = 4,
+} ETextureType;
+
+typedef enum EColorSpace
+{
+	EColorSpace_ColorSpace_Auto = 0,
+	EColorSpace_ColorSpace_Gamma = 1,
+	EColorSpace_ColorSpace_Linear = 2,
+} EColorSpace;
+
+typedef enum ETrackingResult
+{
+	ETrackingResult_TrackingResult_Uninitialized = 1,
+	ETrackingResult_TrackingResult_Calibrating_InProgress = 100,
+	ETrackingResult_TrackingResult_Calibrating_OutOfRange = 101,
+	ETrackingResult_TrackingResult_Running_OK = 200,
+	ETrackingResult_TrackingResult_Running_OutOfRange = 201,
+} ETrackingResult;
+
+typedef enum ETrackedDeviceClass
+{
+	ETrackedDeviceClass_TrackedDeviceClass_Invalid = 0,
+	ETrackedDeviceClass_TrackedDeviceClass_HMD = 1,
+	ETrackedDeviceClass_TrackedDeviceClass_Controller = 2,
+	ETrackedDeviceClass_TrackedDeviceClass_GenericTracker = 3,
+	ETrackedDeviceClass_TrackedDeviceClass_TrackingReference = 4,
+	ETrackedDeviceClass_TrackedDeviceClass_DisplayRedirect = 5,
+} ETrackedDeviceClass;
+
+typedef enum ETrackedControllerRole
+{
+	ETrackedControllerRole_TrackedControllerRole_Invalid = 0,
+	ETrackedControllerRole_TrackedControllerRole_LeftHand = 1,
+	ETrackedControllerRole_TrackedControllerRole_RightHand = 2,
+} ETrackedControllerRole;
+
+typedef enum ETrackingUniverseOrigin
+{
+	ETrackingUniverseOrigin_TrackingUniverseSeated = 0,
+	ETrackingUniverseOrigin_TrackingUniverseStanding = 1,
+	ETrackingUniverseOrigin_TrackingUniverseRawAndUncalibrated = 2,
+} ETrackingUniverseOrigin;
+
+typedef enum ETrackedDeviceProperty
+{
+	ETrackedDeviceProperty_Prop_Invalid = 0,
+	ETrackedDeviceProperty_Prop_TrackingSystemName_String = 1000,
+	ETrackedDeviceProperty_Prop_ModelNumber_String = 1001,
+	ETrackedDeviceProperty_Prop_SerialNumber_String = 1002,
+	ETrackedDeviceProperty_Prop_RenderModelName_String = 1003,
+	ETrackedDeviceProperty_Prop_WillDriftInYaw_Bool = 1004,
+	ETrackedDeviceProperty_Prop_ManufacturerName_String = 1005,
+	ETrackedDeviceProperty_Prop_TrackingFirmwareVersion_String = 1006,
+	ETrackedDeviceProperty_Prop_HardwareRevision_String = 1007,
+	ETrackedDeviceProperty_Prop_AllWirelessDongleDescriptions_String = 1008,
+	ETrackedDeviceProperty_Prop_ConnectedWirelessDongle_String = 1009,
+	ETrackedDeviceProperty_Prop_DeviceIsWireless_Bool = 1010,
+	ETrackedDeviceProperty_Prop_DeviceIsCharging_Bool = 1011,
+	ETrackedDeviceProperty_Prop_DeviceBatteryPercentage_Float = 1012,
+	ETrackedDeviceProperty_Prop_StatusDisplayTransform_Matrix34 = 1013,
+	ETrackedDeviceProperty_Prop_Firmware_UpdateAvailable_Bool = 1014,
+	ETrackedDeviceProperty_Prop_Firmware_ManualUpdate_Bool = 1015,
+	ETrackedDeviceProperty_Prop_Firmware_ManualUpdateURL_String = 1016,
+	ETrackedDeviceProperty_Prop_HardwareRevision_Uint64 = 1017,
+	ETrackedDeviceProperty_Prop_FirmwareVersion_Uint64 = 1018,
+	ETrackedDeviceProperty_Prop_FPGAVersion_Uint64 = 1019,
+	ETrackedDeviceProperty_Prop_VRCVersion_Uint64 = 1020,
+	ETrackedDeviceProperty_Prop_RadioVersion_Uint64 = 1021,
+	ETrackedDeviceProperty_Prop_DongleVersion_Uint64 = 1022,
+	ETrackedDeviceProperty_Prop_BlockServerShutdown_Bool = 1023,
+	ETrackedDeviceProperty_Prop_CanUnifyCoordinateSystemWithHmd_Bool = 1024,
+	ETrackedDeviceProperty_Prop_ContainsProximitySensor_Bool = 1025,
+	ETrackedDeviceProperty_Prop_DeviceProvidesBatteryStatus_Bool = 1026,
+	ETrackedDeviceProperty_Prop_DeviceCanPowerOff_Bool = 1027,
+	ETrackedDeviceProperty_Prop_Firmware_ProgrammingTarget_String = 1028,
+	ETrackedDeviceProperty_Prop_DeviceClass_Int32 = 1029,
+	ETrackedDeviceProperty_Prop_HasCamera_Bool = 1030,
+	ETrackedDeviceProperty_Prop_DriverVersion_String = 1031,
+	ETrackedDeviceProperty_Prop_Firmware_ForceUpdateRequired_Bool = 1032,
+	ETrackedDeviceProperty_Prop_ViveSystemButtonFixRequired_Bool = 1033,
+	ETrackedDeviceProperty_Prop_ParentDriver_Uint64 = 1034,
+	ETrackedDeviceProperty_Prop_ResourceRoot_String = 1035,
+	ETrackedDeviceProperty_Prop_ReportsTimeSinceVSync_Bool = 2000,
+	ETrackedDeviceProperty_Prop_SecondsFromVsyncToPhotons_Float = 2001,
+	ETrackedDeviceProperty_Prop_DisplayFrequency_Float = 2002,
+	ETrackedDeviceProperty_Prop_UserIpdMeters_Float = 2003,
+	ETrackedDeviceProperty_Prop_CurrentUniverseId_Uint64 = 2004,
+	ETrackedDeviceProperty_Prop_PreviousUniverseId_Uint64 = 2005,
+	ETrackedDeviceProperty_Prop_DisplayFirmwareVersion_Uint64 = 2006,
+	ETrackedDeviceProperty_Prop_IsOnDesktop_Bool = 2007,
+	ETrackedDeviceProperty_Prop_DisplayMCType_Int32 = 2008,
+	ETrackedDeviceProperty_Prop_DisplayMCOffset_Float = 2009,
+	ETrackedDeviceProperty_Prop_DisplayMCScale_Float = 2010,
+	ETrackedDeviceProperty_Prop_EdidVendorID_Int32 = 2011,
+	ETrackedDeviceProperty_Prop_DisplayMCImageLeft_String = 2012,
+	ETrackedDeviceProperty_Prop_DisplayMCImageRight_String = 2013,
+	ETrackedDeviceProperty_Prop_DisplayGCBlackClamp_Float = 2014,
+	ETrackedDeviceProperty_Prop_EdidProductID_Int32 = 2015,
+	ETrackedDeviceProperty_Prop_CameraToHeadTransform_Matrix34 = 2016,
+	ETrackedDeviceProperty_Prop_DisplayGCType_Int32 = 2017,
+	ETrackedDeviceProperty_Prop_DisplayGCOffset_Float = 2018,
+	ETrackedDeviceProperty_Prop_DisplayGCScale_Float = 2019,
+	ETrackedDeviceProperty_Prop_DisplayGCPrescale_Float = 2020,
+	ETrackedDeviceProperty_Prop_DisplayGCImage_String = 2021,
+	ETrackedDeviceProperty_Prop_LensCenterLeftU_Float = 2022,
+	ETrackedDeviceProperty_Prop_LensCenterLeftV_Float = 2023,
+	ETrackedDeviceProperty_Prop_LensCenterRightU_Float = 2024,
+	ETrackedDeviceProperty_Prop_LensCenterRightV_Float = 2025,
+	ETrackedDeviceProperty_Prop_UserHeadToEyeDepthMeters_Float = 2026,
+	ETrackedDeviceProperty_Prop_CameraFirmwareVersion_Uint64 = 2027,
+	ETrackedDeviceProperty_Prop_CameraFirmwareDescription_String = 2028,
+	ETrackedDeviceProperty_Prop_DisplayFPGAVersion_Uint64 = 2029,
+	ETrackedDeviceProperty_Prop_DisplayBootloaderVersion_Uint64 = 2030,
+	ETrackedDeviceProperty_Prop_DisplayHardwareVersion_Uint64 = 2031,
+	ETrackedDeviceProperty_Prop_AudioFirmwareVersion_Uint64 = 2032,
+	ETrackedDeviceProperty_Prop_CameraCompatibilityMode_Int32 = 2033,
+	ETrackedDeviceProperty_Prop_ScreenshotHorizontalFieldOfViewDegrees_Float = 2034,
+	ETrackedDeviceProperty_Prop_ScreenshotVerticalFieldOfViewDegrees_Float = 2035,
+	ETrackedDeviceProperty_Prop_DisplaySuppressed_Bool = 2036,
+	ETrackedDeviceProperty_Prop_DisplayAllowNightMode_Bool = 2037,
+	ETrackedDeviceProperty_Prop_DisplayMCImageWidth_Int32 = 2038,
+	ETrackedDeviceProperty_Prop_DisplayMCImageHeight_Int32 = 2039,
+	ETrackedDeviceProperty_Prop_DisplayMCImageNumChannels_Int32 = 2040,
+	ETrackedDeviceProperty_Prop_DisplayMCImageData_Binary = 2041,
+	ETrackedDeviceProperty_Prop_SecondsFromPhotonsToVblank_Float = 2042,
+	ETrackedDeviceProperty_Prop_DriverDirectModeSendsVsyncEvents_Bool = 2043,
+	ETrackedDeviceProperty_Prop_DisplayDebugMode_Bool = 2044,
+	ETrackedDeviceProperty_Prop_GraphicsAdapterLuid_Uint64 = 2045,
+	ETrackedDeviceProperty_Prop_DriverProvidedChaperonePath_String = 2048,
+	ETrackedDeviceProperty_Prop_AttachedDeviceId_String = 3000,
+	ETrackedDeviceProperty_Prop_SupportedButtons_Uint64 = 3001,
+	ETrackedDeviceProperty_Prop_Axis0Type_Int32 = 3002,
+	ETrackedDeviceProperty_Prop_Axis1Type_Int32 = 3003,
+	ETrackedDeviceProperty_Prop_Axis2Type_Int32 = 3004,
+	ETrackedDeviceProperty_Prop_Axis3Type_Int32 = 3005,
+	ETrackedDeviceProperty_Prop_Axis4Type_Int32 = 3006,
+	ETrackedDeviceProperty_Prop_ControllerRoleHint_Int32 = 3007,
+	ETrackedDeviceProperty_Prop_FieldOfViewLeftDegrees_Float = 4000,
+	ETrackedDeviceProperty_Prop_FieldOfViewRightDegrees_Float = 4001,
+	ETrackedDeviceProperty_Prop_FieldOfViewTopDegrees_Float = 4002,
+	ETrackedDeviceProperty_Prop_FieldOfViewBottomDegrees_Float = 4003,
+	ETrackedDeviceProperty_Prop_TrackingRangeMinimumMeters_Float = 4004,
+	ETrackedDeviceProperty_Prop_TrackingRangeMaximumMeters_Float = 4005,
+	ETrackedDeviceProperty_Prop_ModeLabel_String = 4006,
+	ETrackedDeviceProperty_Prop_IconPathName_String = 5000,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceOff_String = 5001,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceSearching_String = 5002,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceSearchingAlert_String = 5003,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceReady_String = 5004,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceReadyAlert_String = 5005,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceNotReady_String = 5006,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceStandby_String = 5007,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceAlertLow_String = 5008,
+	ETrackedDeviceProperty_Prop_DisplayHiddenArea_Binary_Start = 5100,
+	ETrackedDeviceProperty_Prop_DisplayHiddenArea_Binary_End = 5150,
+	ETrackedDeviceProperty_Prop_UserConfigPath_String = 6000,
+	ETrackedDeviceProperty_Prop_InstallPath_String = 6001,
+	ETrackedDeviceProperty_Prop_HasDisplayComponent_Bool = 6002,
+	ETrackedDeviceProperty_Prop_HasControllerComponent_Bool = 6003,
+	ETrackedDeviceProperty_Prop_HasCameraComponent_Bool = 6004,
+	ETrackedDeviceProperty_Prop_HasDriverDirectModeComponent_Bool = 6005,
+	ETrackedDeviceProperty_Prop_HasVirtualDisplayComponent_Bool = 6006,
+	ETrackedDeviceProperty_Prop_VendorSpecific_Reserved_Start = 10000,
+	ETrackedDeviceProperty_Prop_VendorSpecific_Reserved_End = 10999,
+} ETrackedDeviceProperty;
+
+typedef enum ETrackedPropertyError
+{
+	ETrackedPropertyError_TrackedProp_Success = 0,
+	ETrackedPropertyError_TrackedProp_WrongDataType = 1,
+	ETrackedPropertyError_TrackedProp_WrongDeviceClass = 2,
+	ETrackedPropertyError_TrackedProp_BufferTooSmall = 3,
+	ETrackedPropertyError_TrackedProp_UnknownProperty = 4,
+	ETrackedPropertyError_TrackedProp_InvalidDevice = 5,
+	ETrackedPropertyError_TrackedProp_CouldNotContactServer = 6,
+	ETrackedPropertyError_TrackedProp_ValueNotProvidedByDevice = 7,
+	ETrackedPropertyError_TrackedProp_StringExceedsMaximumLength = 8,
+	ETrackedPropertyError_TrackedProp_NotYetAvailable = 9,
+	ETrackedPropertyError_TrackedProp_PermissionDenied = 10,
+	ETrackedPropertyError_TrackedProp_InvalidOperation = 11,
+} ETrackedPropertyError;
+
+typedef enum EVRSubmitFlags
+{
+	EVRSubmitFlags_Submit_Default = 0,
+	EVRSubmitFlags_Submit_LensDistortionAlreadyApplied = 1,
+	EVRSubmitFlags_Submit_GlRenderBuffer = 2,
+	EVRSubmitFlags_Submit_Reserved = 4,
+	EVRSubmitFlags_Submit_TextureWithPose = 8,
+} EVRSubmitFlags;
+
+typedef enum EVRState
+{
+	EVRState_VRState_Undefined = -1,
+	EVRState_VRState_Off = 0,
+	EVRState_VRState_Searching = 1,
+	EVRState_VRState_Searching_Alert = 2,
+	EVRState_VRState_Ready = 3,
+	EVRState_VRState_Ready_Alert = 4,
+	EVRState_VRState_NotReady = 5,
+	EVRState_VRState_Standby = 6,
+	EVRState_VRState_Ready_Alert_Low = 7,
+} EVRState;
+
+typedef enum EVREventType
+{
+	EVREventType_VREvent_None = 0,
+	EVREventType_VREvent_TrackedDeviceActivated = 100,
+	EVREventType_VREvent_TrackedDeviceDeactivated = 101,
+	EVREventType_VREvent_TrackedDeviceUpdated = 102,
+	EVREventType_VREvent_TrackedDeviceUserInteractionStarted = 103,
+	EVREventType_VREvent_TrackedDeviceUserInteractionEnded = 104,
+	EVREventType_VREvent_IpdChanged = 105,
+	EVREventType_VREvent_EnterStandbyMode = 106,
+	EVREventType_VREvent_LeaveStandbyMode = 107,
+	EVREventType_VREvent_TrackedDeviceRoleChanged = 108,
+	EVREventType_VREvent_WatchdogWakeUpRequested = 109,
+	EVREventType_VREvent_LensDistortionChanged = 110,
+	EVREventType_VREvent_PropertyChanged = 111,
+	EVREventType_VREvent_WirelessDisconnect = 112,
+	EVREventType_VREvent_WirelessReconnect = 113,
+	EVREventType_VREvent_ButtonPress = 200,
+	EVREventType_VREvent_ButtonUnpress = 201,
+	EVREventType_VREvent_ButtonTouch = 202,
+	EVREventType_VREvent_ButtonUntouch = 203,
+	EVREventType_VREvent_MouseMove = 300,
+	EVREventType_VREvent_MouseButtonDown = 301,
+	EVREventType_VREvent_MouseButtonUp = 302,
+	EVREventType_VREvent_FocusEnter = 303,
+	EVREventType_VREvent_FocusLeave = 304,
+	EVREventType_VREvent_Scroll = 305,
+	EVREventType_VREvent_TouchPadMove = 306,
+	EVREventType_VREvent_OverlayFocusChanged = 307,
+	EVREventType_VREvent_InputFocusCaptured = 400,
+	EVREventType_VREvent_InputFocusReleased = 401,
+	EVREventType_VREvent_SceneFocusLost = 402,
+	EVREventType_VREvent_SceneFocusGained = 403,
+	EVREventType_VREvent_SceneApplicationChanged = 404,
+	EVREventType_VREvent_SceneFocusChanged = 405,
+	EVREventType_VREvent_InputFocusChanged = 406,
+	EVREventType_VREvent_SceneApplicationSecondaryRenderingStarted = 407,
+	EVREventType_VREvent_HideRenderModels = 410,
+	EVREventType_VREvent_ShowRenderModels = 411,
+	EVREventType_VREvent_OverlayShown = 500,
+	EVREventType_VREvent_OverlayHidden = 501,
+	EVREventType_VREvent_DashboardActivated = 502,
+	EVREventType_VREvent_DashboardDeactivated = 503,
+	EVREventType_VREvent_DashboardThumbSelected = 504,
+	EVREventType_VREvent_DashboardRequested = 505,
+	EVREventType_VREvent_ResetDashboard = 506,
+	EVREventType_VREvent_RenderToast = 507,
+	EVREventType_VREvent_ImageLoaded = 508,
+	EVREventType_VREvent_ShowKeyboard = 509,
+	EVREventType_VREvent_HideKeyboard = 510,
+	EVREventType_VREvent_OverlayGamepadFocusGained = 511,
+	EVREventType_VREvent_OverlayGamepadFocusLost = 512,
+	EVREventType_VREvent_OverlaySharedTextureChanged = 513,
+	EVREventType_VREvent_DashboardGuideButtonDown = 514,
+	EVREventType_VREvent_DashboardGuideButtonUp = 515,
+	EVREventType_VREvent_ScreenshotTriggered = 516,
+	EVREventType_VREvent_ImageFailed = 517,
+	EVREventType_VREvent_DashboardOverlayCreated = 518,
+	EVREventType_VREvent_RequestScreenshot = 520,
+	EVREventType_VREvent_ScreenshotTaken = 521,
+	EVREventType_VREvent_ScreenshotFailed = 522,
+	EVREventType_VREvent_SubmitScreenshotToDashboard = 523,
+	EVREventType_VREvent_ScreenshotProgressToDashboard = 524,
+	EVREventType_VREvent_PrimaryDashboardDeviceChanged = 525,
+	EVREventType_VREvent_Notification_Shown = 600,
+	EVREventType_VREvent_Notification_Hidden = 601,
+	EVREventType_VREvent_Notification_BeginInteraction = 602,
+	EVREventType_VREvent_Notification_Destroyed = 603,
+	EVREventType_VREvent_Quit = 700,
+	EVREventType_VREvent_ProcessQuit = 701,
+	EVREventType_VREvent_QuitAborted_UserPrompt = 702,
+	EVREventType_VREvent_QuitAcknowledged = 703,
+	EVREventType_VREvent_DriverRequestedQuit = 704,
+	EVREventType_VREvent_ChaperoneDataHasChanged = 800,
+	EVREventType_VREvent_ChaperoneUniverseHasChanged = 801,
+	EVREventType_VREvent_ChaperoneTempDataHasChanged = 802,
+	EVREventType_VREvent_ChaperoneSettingsHaveChanged = 803,
+	EVREventType_VREvent_SeatedZeroPoseReset = 804,
+	EVREventType_VREvent_AudioSettingsHaveChanged = 820,
+	EVREventType_VREvent_BackgroundSettingHasChanged = 850,
+	EVREventType_VREvent_CameraSettingsHaveChanged = 851,
+	EVREventType_VREvent_ReprojectionSettingHasChanged = 852,
+	EVREventType_VREvent_ModelSkinSettingsHaveChanged = 853,
+	EVREventType_VREvent_EnvironmentSettingsHaveChanged = 854,
+	EVREventType_VREvent_PowerSettingsHaveChanged = 855,
+	EVREventType_VREvent_EnableHomeAppSettingsHaveChanged = 856,
+	EVREventType_VREvent_StatusUpdate = 900,
+	EVREventType_VREvent_MCImageUpdated = 1000,
+	EVREventType_VREvent_FirmwareUpdateStarted = 1100,
+	EVREventType_VREvent_FirmwareUpdateFinished = 1101,
+	EVREventType_VREvent_KeyboardClosed = 1200,
+	EVREventType_VREvent_KeyboardCharInput = 1201,
+	EVREventType_VREvent_KeyboardDone = 1202,
+	EVREventType_VREvent_ApplicationTransitionStarted = 1300,
+	EVREventType_VREvent_ApplicationTransitionAborted = 1301,
+	EVREventType_VREvent_ApplicationTransitionNewAppStarted = 1302,
+	EVREventType_VREvent_ApplicationListUpdated = 1303,
+	EVREventType_VREvent_ApplicationMimeTypeLoad = 1304,
+	EVREventType_VREvent_ApplicationTransitionNewAppLaunchComplete = 1305,
+	EVREventType_VREvent_ProcessConnected = 1306,
+	EVREventType_VREvent_ProcessDisconnected = 1307,
+	EVREventType_VREvent_Compositor_MirrorWindowShown = 1400,
+	EVREventType_VREvent_Compositor_MirrorWindowHidden = 1401,
+	EVREventType_VREvent_Compositor_ChaperoneBoundsShown = 1410,
+	EVREventType_VREvent_Compositor_ChaperoneBoundsHidden = 1411,
+	EVREventType_VREvent_TrackedCamera_StartVideoStream = 1500,
+	EVREventType_VREvent_TrackedCamera_StopVideoStream = 1501,
+	EVREventType_VREvent_TrackedCamera_PauseVideoStream = 1502,
+	EVREventType_VREvent_TrackedCamera_ResumeVideoStream = 1503,
+	EVREventType_VREvent_TrackedCamera_EditingSurface = 1550,
+	EVREventType_VREvent_PerformanceTest_EnableCapture = 1600,
+	EVREventType_VREvent_PerformanceTest_DisableCapture = 1601,
+	EVREventType_VREvent_PerformanceTest_FidelityLevel = 1602,
+	EVREventType_VREvent_MessageOverlay_Closed = 1650,
+	EVREventType_VREvent_MessageOverlayCloseRequested = 1651,
+	EVREventType_VREvent_VendorSpecific_Reserved_Start = 10000,
+	EVREventType_VREvent_VendorSpecific_Reserved_End = 19999,
+} EVREventType;
+
+typedef enum EDeviceActivityLevel
+{
+	EDeviceActivityLevel_k_EDeviceActivityLevel_Unknown = -1,
+	EDeviceActivityLevel_k_EDeviceActivityLevel_Idle = 0,
+	EDeviceActivityLevel_k_EDeviceActivityLevel_UserInteraction = 1,
+	EDeviceActivityLevel_k_EDeviceActivityLevel_UserInteraction_Timeout = 2,
+	EDeviceActivityLevel_k_EDeviceActivityLevel_Standby = 3,
+} EDeviceActivityLevel;
+
+typedef enum EVRButtonId
+{
+	EVRButtonId_k_EButton_System = 0,
+	EVRButtonId_k_EButton_ApplicationMenu = 1,
+	EVRButtonId_k_EButton_Grip = 2,
+	EVRButtonId_k_EButton_DPad_Left = 3,
+	EVRButtonId_k_EButton_DPad_Up = 4,
+	EVRButtonId_k_EButton_DPad_Right = 5,
+	EVRButtonId_k_EButton_DPad_Down = 6,
+	EVRButtonId_k_EButton_A = 7,
+	EVRButtonId_k_EButton_ProximitySensor = 31,
+	EVRButtonId_k_EButton_Axis0 = 32,
+	EVRButtonId_k_EButton_Axis1 = 33,
+	EVRButtonId_k_EButton_Axis2 = 34,
+	EVRButtonId_k_EButton_Axis3 = 35,
+	EVRButtonId_k_EButton_Axis4 = 36,
+	EVRButtonId_k_EButton_SteamVR_Touchpad = 32,
+	EVRButtonId_k_EButton_SteamVR_Trigger = 33,
+	EVRButtonId_k_EButton_Dashboard_Back = 2,
+	EVRButtonId_k_EButton_Max = 64,
+} EVRButtonId;
+
+typedef enum EVRMouseButton
+{
+	EVRMouseButton_VRMouseButton_Left = 1,
+	EVRMouseButton_VRMouseButton_Right = 2,
+	EVRMouseButton_VRMouseButton_Middle = 4,
+} EVRMouseButton;
+
+typedef enum EHiddenAreaMeshType
+{
+	EHiddenAreaMeshType_k_eHiddenAreaMesh_Standard = 0,
+	EHiddenAreaMeshType_k_eHiddenAreaMesh_Inverse = 1,
+	EHiddenAreaMeshType_k_eHiddenAreaMesh_LineLoop = 2,
+	EHiddenAreaMeshType_k_eHiddenAreaMesh_Max = 3,
+} EHiddenAreaMeshType;
+
+typedef enum EVRControllerAxisType
+{
+	EVRControllerAxisType_k_eControllerAxis_None = 0,
+	EVRControllerAxisType_k_eControllerAxis_TrackPad = 1,
+	EVRControllerAxisType_k_eControllerAxis_Joystick = 2,
+	EVRControllerAxisType_k_eControllerAxis_Trigger = 3,
+} EVRControllerAxisType;
+
+typedef enum EVRControllerEventOutputType
+{
+	EVRControllerEventOutputType_ControllerEventOutput_OSEvents = 0,
+	EVRControllerEventOutputType_ControllerEventOutput_VREvents = 1,
+} EVRControllerEventOutputType;
+
+typedef enum ECollisionBoundsStyle
+{
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_BEGINNER = 0,
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_INTERMEDIATE = 1,
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_SQUARES = 2,
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_ADVANCED = 3,
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_NONE = 4,
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_COUNT = 5,
+} ECollisionBoundsStyle;
+
+typedef enum EVROverlayError
+{
+	EVROverlayError_VROverlayError_None = 0,
+	EVROverlayError_VROverlayError_UnknownOverlay = 10,
+	EVROverlayError_VROverlayError_InvalidHandle = 11,
+	EVROverlayError_VROverlayError_PermissionDenied = 12,
+	EVROverlayError_VROverlayError_OverlayLimitExceeded = 13,
+	EVROverlayError_VROverlayError_WrongVisibilityType = 14,
+	EVROverlayError_VROverlayError_KeyTooLong = 15,
+	EVROverlayError_VROverlayError_NameTooLong = 16,
+	EVROverlayError_VROverlayError_KeyInUse = 17,
+	EVROverlayError_VROverlayError_WrongTransformType = 18,
+	EVROverlayError_VROverlayError_InvalidTrackedDevice = 19,
+	EVROverlayError_VROverlayError_InvalidParameter = 20,
+	EVROverlayError_VROverlayError_ThumbnailCantBeDestroyed = 21,
+	EVROverlayError_VROverlayError_ArrayTooSmall = 22,
+	EVROverlayError_VROverlayError_RequestFailed = 23,
+	EVROverlayError_VROverlayError_InvalidTexture = 24,
+	EVROverlayError_VROverlayError_UnableToLoadFile = 25,
+	EVROverlayError_VROverlayError_KeyboardAlreadyInUse = 26,
+	EVROverlayError_VROverlayError_NoNeighbor = 27,
+	EVROverlayError_VROverlayError_TooManyMaskPrimitives = 29,
+	EVROverlayError_VROverlayError_BadMaskPrimitive = 30,
+} EVROverlayError;
+
+typedef enum EVRApplicationType
+{
+	EVRApplicationType_VRApplication_Other = 0,
+	EVRApplicationType_VRApplication_Scene = 1,
+	EVRApplicationType_VRApplication_Overlay = 2,
+	EVRApplicationType_VRApplication_Background = 3,
+	EVRApplicationType_VRApplication_Utility = 4,
+	EVRApplicationType_VRApplication_VRMonitor = 5,
+	EVRApplicationType_VRApplication_SteamWatchdog = 6,
+	EVRApplicationType_VRApplication_Bootstrapper = 7,
+	EVRApplicationType_VRApplication_Max = 8,
+} EVRApplicationType;
+
+typedef enum EVRFirmwareError
+{
+	EVRFirmwareError_VRFirmwareError_None = 0,
+	EVRFirmwareError_VRFirmwareError_Success = 1,
+	EVRFirmwareError_VRFirmwareError_Fail = 2,
+} EVRFirmwareError;
+
+typedef enum EVRNotificationError
+{
+	EVRNotificationError_VRNotificationError_OK = 0,
+	EVRNotificationError_VRNotificationError_InvalidNotificationId = 100,
+	EVRNotificationError_VRNotificationError_NotificationQueueFull = 101,
+	EVRNotificationError_VRNotificationError_InvalidOverlayHandle = 102,
+	EVRNotificationError_VRNotificationError_SystemWithUserValueAlreadyExists = 103,
+} EVRNotificationError;
+
+typedef enum EVRInitError
+{
+	EVRInitError_VRInitError_None = 0,
+	EVRInitError_VRInitError_Unknown = 1,
+	EVRInitError_VRInitError_Init_InstallationNotFound = 100,
+	EVRInitError_VRInitError_Init_InstallationCorrupt = 101,
+	EVRInitError_VRInitError_Init_VRClientDLLNotFound = 102,
+	EVRInitError_VRInitError_Init_FileNotFound = 103,
+	EVRInitError_VRInitError_Init_FactoryNotFound = 104,
+	EVRInitError_VRInitError_Init_InterfaceNotFound = 105,
+	EVRInitError_VRInitError_Init_InvalidInterface = 106,
+	EVRInitError_VRInitError_Init_UserConfigDirectoryInvalid = 107,
+	EVRInitError_VRInitError_Init_HmdNotFound = 108,
+	EVRInitError_VRInitError_Init_NotInitialized = 109,
+	EVRInitError_VRInitError_Init_PathRegistryNotFound = 110,
+	EVRInitError_VRInitError_Init_NoConfigPath = 111,
+	EVRInitError_VRInitError_Init_NoLogPath = 112,
+	EVRInitError_VRInitError_Init_PathRegistryNotWritable = 113,
+	EVRInitError_VRInitError_Init_AppInfoInitFailed = 114,
+	EVRInitError_VRInitError_Init_Retry = 115,
+	EVRInitError_VRInitError_Init_InitCanceledByUser = 116,
+	EVRInitError_VRInitError_Init_AnotherAppLaunching = 117,
+	EVRInitError_VRInitError_Init_SettingsInitFailed = 118,
+	EVRInitError_VRInitError_Init_ShuttingDown = 119,
+	EVRInitError_VRInitError_Init_TooManyObjects = 120,
+	EVRInitError_VRInitError_Init_NoServerForBackgroundApp = 121,
+	EVRInitError_VRInitError_Init_NotSupportedWithCompositor = 122,
+	EVRInitError_VRInitError_Init_NotAvailableToUtilityApps = 123,
+	EVRInitError_VRInitError_Init_Internal = 124,
+	EVRInitError_VRInitError_Init_HmdDriverIdIsNone = 125,
+	EVRInitError_VRInitError_Init_HmdNotFoundPresenceFailed = 126,
+	EVRInitError_VRInitError_Init_VRMonitorNotFound = 127,
+	EVRInitError_VRInitError_Init_VRMonitorStartupFailed = 128,
+	EVRInitError_VRInitError_Init_LowPowerWatchdogNotSupported = 129,
+	EVRInitError_VRInitError_Init_InvalidApplicationType = 130,
+	EVRInitError_VRInitError_Init_NotAvailableToWatchdogApps = 131,
+	EVRInitError_VRInitError_Init_WatchdogDisabledInSettings = 132,
+	EVRInitError_VRInitError_Init_VRDashboardNotFound = 133,
+	EVRInitError_VRInitError_Init_VRDashboardStartupFailed = 134,
+	EVRInitError_VRInitError_Init_VRHomeNotFound = 135,
+	EVRInitError_VRInitError_Init_VRHomeStartupFailed = 136,
+	EVRInitError_VRInitError_Init_RebootingBusy = 137,
+	EVRInitError_VRInitError_Init_FirmwareUpdateBusy = 138,
+	EVRInitError_VRInitError_Init_FirmwareRecoveryBusy = 139,
+	EVRInitError_VRInitError_Driver_Failed = 200,
+	EVRInitError_VRInitError_Driver_Unknown = 201,
+	EVRInitError_VRInitError_Driver_HmdUnknown = 202,
+	EVRInitError_VRInitError_Driver_NotLoaded = 203,
+	EVRInitError_VRInitError_Driver_RuntimeOutOfDate = 204,
+	EVRInitError_VRInitError_Driver_HmdInUse = 205,
+	EVRInitError_VRInitError_Driver_NotCalibrated = 206,
+	EVRInitError_VRInitError_Driver_CalibrationInvalid = 207,
+	EVRInitError_VRInitError_Driver_HmdDisplayNotFound = 208,
+	EVRInitError_VRInitError_Driver_TrackedDeviceInterfaceUnknown = 209,
+	EVRInitError_VRInitError_Driver_HmdDriverIdOutOfBounds = 211,
+	EVRInitError_VRInitError_Driver_HmdDisplayMirrored = 212,
+	EVRInitError_VRInitError_IPC_ServerInitFailed = 300,
+	EVRInitError_VRInitError_IPC_ConnectFailed = 301,
+	EVRInitError_VRInitError_IPC_SharedStateInitFailed = 302,
+	EVRInitError_VRInitError_IPC_CompositorInitFailed = 303,
+	EVRInitError_VRInitError_IPC_MutexInitFailed = 304,
+	EVRInitError_VRInitError_IPC_Failed = 305,
+	EVRInitError_VRInitError_IPC_CompositorConnectFailed = 306,
+	EVRInitError_VRInitError_IPC_CompositorInvalidConnectResponse = 307,
+	EVRInitError_VRInitError_IPC_ConnectFailedAfterMultipleAttempts = 308,
+	EVRInitError_VRInitError_Compositor_Failed = 400,
+	EVRInitError_VRInitError_Compositor_D3D11HardwareRequired = 401,
+	EVRInitError_VRInitError_Compositor_FirmwareRequiresUpdate = 402,
+	EVRInitError_VRInitError_Compositor_OverlayInitFailed = 403,
+	EVRInitError_VRInitError_Compositor_ScreenshotsInitFailed = 404,
+	EVRInitError_VRInitError_Compositor_UnableToCreateDevice = 405,
+	EVRInitError_VRInitError_VendorSpecific_UnableToConnectToOculusRuntime = 1000,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_CantOpenDevice = 1101,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToRequestConfigStart = 1102,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_NoStoredConfig = 1103,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_ConfigTooBig = 1104,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_ConfigTooSmall = 1105,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToInitZLib = 1106,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_CantReadFirmwareVersion = 1107,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToSendUserDataStart = 1108,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataStart = 1109,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataNext = 1110,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UserDataAddressRange = 1111,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UserDataError = 1112,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_ConfigFailedSanityCheck = 1113,
+	EVRInitError_VRInitError_Steam_SteamInstallationNotFound = 2000,
+} EVRInitError;
+
+typedef enum EVRScreenshotType
+{
+	EVRScreenshotType_VRScreenshotType_None = 0,
+	EVRScreenshotType_VRScreenshotType_Mono = 1,
+	EVRScreenshotType_VRScreenshotType_Stereo = 2,
+	EVRScreenshotType_VRScreenshotType_Cubemap = 3,
+	EVRScreenshotType_VRScreenshotType_MonoPanorama = 4,
+	EVRScreenshotType_VRScreenshotType_StereoPanorama = 5,
+} EVRScreenshotType;
+
+typedef enum EVRScreenshotPropertyFilenames
+{
+	EVRScreenshotPropertyFilenames_VRScreenshotPropertyFilenames_Preview = 0,
+	EVRScreenshotPropertyFilenames_VRScreenshotPropertyFilenames_VR = 1,
+} EVRScreenshotPropertyFilenames;
+
+typedef enum EVRTrackedCameraError
+{
+	EVRTrackedCameraError_VRTrackedCameraError_None = 0,
+	EVRTrackedCameraError_VRTrackedCameraError_OperationFailed = 100,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidHandle = 101,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidFrameHeaderVersion = 102,
+	EVRTrackedCameraError_VRTrackedCameraError_OutOfHandles = 103,
+	EVRTrackedCameraError_VRTrackedCameraError_IPCFailure = 104,
+	EVRTrackedCameraError_VRTrackedCameraError_NotSupportedForThisDevice = 105,
+	EVRTrackedCameraError_VRTrackedCameraError_SharedMemoryFailure = 106,
+	EVRTrackedCameraError_VRTrackedCameraError_FrameBufferingFailure = 107,
+	EVRTrackedCameraError_VRTrackedCameraError_StreamSetupFailure = 108,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidGLTextureId = 109,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidSharedTextureHandle = 110,
+	EVRTrackedCameraError_VRTrackedCameraError_FailedToGetGLTextureId = 111,
+	EVRTrackedCameraError_VRTrackedCameraError_SharedTextureFailure = 112,
+	EVRTrackedCameraError_VRTrackedCameraError_NoFrameAvailable = 113,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidArgument = 114,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidFrameBufferSize = 115,
+} EVRTrackedCameraError;
+
+typedef enum EVRTrackedCameraFrameType
+{
+	EVRTrackedCameraFrameType_VRTrackedCameraFrameType_Distorted = 0,
+	EVRTrackedCameraFrameType_VRTrackedCameraFrameType_Undistorted = 1,
+	EVRTrackedCameraFrameType_VRTrackedCameraFrameType_MaximumUndistorted = 2,
+	EVRTrackedCameraFrameType_MAX_CAMERA_FRAME_TYPES = 3,
+} EVRTrackedCameraFrameType;
+
+typedef enum EVRApplicationError
+{
+	EVRApplicationError_VRApplicationError_None = 0,
+	EVRApplicationError_VRApplicationError_AppKeyAlreadyExists = 100,
+	EVRApplicationError_VRApplicationError_NoManifest = 101,
+	EVRApplicationError_VRApplicationError_NoApplication = 102,
+	EVRApplicationError_VRApplicationError_InvalidIndex = 103,
+	EVRApplicationError_VRApplicationError_UnknownApplication = 104,
+	EVRApplicationError_VRApplicationError_IPCFailed = 105,
+	EVRApplicationError_VRApplicationError_ApplicationAlreadyRunning = 106,
+	EVRApplicationError_VRApplicationError_InvalidManifest = 107,
+	EVRApplicationError_VRApplicationError_InvalidApplication = 108,
+	EVRApplicationError_VRApplicationError_LaunchFailed = 109,
+	EVRApplicationError_VRApplicationError_ApplicationAlreadyStarting = 110,
+	EVRApplicationError_VRApplicationError_LaunchInProgress = 111,
+	EVRApplicationError_VRApplicationError_OldApplicationQuitting = 112,
+	EVRApplicationError_VRApplicationError_TransitionAborted = 113,
+	EVRApplicationError_VRApplicationError_IsTemplate = 114,
+	EVRApplicationError_VRApplicationError_SteamVRIsExiting = 115,
+	EVRApplicationError_VRApplicationError_BufferTooSmall = 200,
+	EVRApplicationError_VRApplicationError_PropertyNotSet = 201,
+	EVRApplicationError_VRApplicationError_UnknownProperty = 202,
+	EVRApplicationError_VRApplicationError_InvalidParameter = 203,
+} EVRApplicationError;
+
+typedef enum EVRApplicationProperty
+{
+	EVRApplicationProperty_VRApplicationProperty_Name_String = 0,
+	EVRApplicationProperty_VRApplicationProperty_LaunchType_String = 11,
+	EVRApplicationProperty_VRApplicationProperty_WorkingDirectory_String = 12,
+	EVRApplicationProperty_VRApplicationProperty_BinaryPath_String = 13,
+	EVRApplicationProperty_VRApplicationProperty_Arguments_String = 14,
+	EVRApplicationProperty_VRApplicationProperty_URL_String = 15,
+	EVRApplicationProperty_VRApplicationProperty_Description_String = 50,
+	EVRApplicationProperty_VRApplicationProperty_NewsURL_String = 51,
+	EVRApplicationProperty_VRApplicationProperty_ImagePath_String = 52,
+	EVRApplicationProperty_VRApplicationProperty_Source_String = 53,
+	EVRApplicationProperty_VRApplicationProperty_IsDashboardOverlay_Bool = 60,
+	EVRApplicationProperty_VRApplicationProperty_IsTemplate_Bool = 61,
+	EVRApplicationProperty_VRApplicationProperty_IsInstanced_Bool = 62,
+	EVRApplicationProperty_VRApplicationProperty_IsInternal_Bool = 63,
+	EVRApplicationProperty_VRApplicationProperty_WantsCompositorPauseInStandby_Bool = 64,
+	EVRApplicationProperty_VRApplicationProperty_LastLaunchTime_Uint64 = 70,
+} EVRApplicationProperty;
+
+typedef enum EVRApplicationTransitionState
+{
+	EVRApplicationTransitionState_VRApplicationTransition_None = 0,
+	EVRApplicationTransitionState_VRApplicationTransition_OldAppQuitSent = 10,
+	EVRApplicationTransitionState_VRApplicationTransition_WaitingForExternalLaunch = 11,
+	EVRApplicationTransitionState_VRApplicationTransition_NewAppLaunched = 20,
+} EVRApplicationTransitionState;
+
+typedef enum ChaperoneCalibrationState
+{
+	ChaperoneCalibrationState_OK = 1,
+	ChaperoneCalibrationState_Warning = 100,
+	ChaperoneCalibrationState_Warning_BaseStationMayHaveMoved = 101,
+	ChaperoneCalibrationState_Warning_BaseStationRemoved = 102,
+	ChaperoneCalibrationState_Warning_SeatedBoundsInvalid = 103,
+	ChaperoneCalibrationState_Error = 200,
+	ChaperoneCalibrationState_Error_BaseStationUninitialized = 201,
+	ChaperoneCalibrationState_Error_BaseStationConflict = 202,
+	ChaperoneCalibrationState_Error_PlayAreaInvalid = 203,
+	ChaperoneCalibrationState_Error_CollisionBoundsInvalid = 204,
+} ChaperoneCalibrationState;
+
+typedef enum EChaperoneConfigFile
+{
+	EChaperoneConfigFile_Live = 1,
+	EChaperoneConfigFile_Temp = 2,
+} EChaperoneConfigFile;
+
+typedef enum EChaperoneImportFlags
+{
+	EChaperoneImportFlags_EChaperoneImport_BoundsOnly = 1,
+} EChaperoneImportFlags;
+
+typedef enum EVRCompositorError
+{
+	EVRCompositorError_VRCompositorError_None = 0,
+	EVRCompositorError_VRCompositorError_RequestFailed = 1,
+	EVRCompositorError_VRCompositorError_IncompatibleVersion = 100,
+	EVRCompositorError_VRCompositorError_DoNotHaveFocus = 101,
+	EVRCompositorError_VRCompositorError_InvalidTexture = 102,
+	EVRCompositorError_VRCompositorError_IsNotSceneApplication = 103,
+	EVRCompositorError_VRCompositorError_TextureIsOnWrongDevice = 104,
+	EVRCompositorError_VRCompositorError_TextureUsesUnsupportedFormat = 105,
+	EVRCompositorError_VRCompositorError_SharedTexturesNotSupported = 106,
+	EVRCompositorError_VRCompositorError_IndexOutOfRange = 107,
+	EVRCompositorError_VRCompositorError_AlreadySubmitted = 108,
+	EVRCompositorError_VRCompositorError_InvalidBounds = 109,
+} EVRCompositorError;
+
+typedef enum VROverlayInputMethod
+{
+	VROverlayInputMethod_None = 0,
+	VROverlayInputMethod_Mouse = 1,
+} VROverlayInputMethod;
+
+typedef enum VROverlayTransformType
+{
+	VROverlayTransformType_VROverlayTransform_Absolute = 0,
+	VROverlayTransformType_VROverlayTransform_TrackedDeviceRelative = 1,
+	VROverlayTransformType_VROverlayTransform_SystemOverlay = 2,
+	VROverlayTransformType_VROverlayTransform_TrackedComponent = 3,
+} VROverlayTransformType;
+
+typedef enum VROverlayFlags
+{
+	VROverlayFlags_None = 0,
+	VROverlayFlags_Curved = 1,
+	VROverlayFlags_RGSS4X = 2,
+	VROverlayFlags_NoDashboardTab = 3,
+	VROverlayFlags_AcceptsGamepadEvents = 4,
+	VROverlayFlags_ShowGamepadFocus = 5,
+	VROverlayFlags_SendVRScrollEvents = 6,
+	VROverlayFlags_SendVRTouchpadEvents = 7,
+	VROverlayFlags_ShowTouchPadScrollWheel = 8,
+	VROverlayFlags_TransferOwnershipToInternalProcess = 9,
+	VROverlayFlags_SideBySide_Parallel = 10,
+	VROverlayFlags_SideBySide_Crossed = 11,
+	VROverlayFlags_Panorama = 12,
+	VROverlayFlags_StereoPanorama = 13,
+	VROverlayFlags_SortWithNonSceneOverlays = 14,
+	VROverlayFlags_VisibleInDashboard = 15,
+} VROverlayFlags;
+
+typedef enum VRMessageOverlayResponse
+{
+	VRMessageOverlayResponse_ButtonPress_0 = 0,
+	VRMessageOverlayResponse_ButtonPress_1 = 1,
+	VRMessageOverlayResponse_ButtonPress_2 = 2,
+	VRMessageOverlayResponse_ButtonPress_3 = 3,
+	VRMessageOverlayResponse_CouldntFindSystemOverlay = 4,
+	VRMessageOverlayResponse_CouldntFindOrCreateClientOverlay = 5,
+	VRMessageOverlayResponse_ApplicationQuit = 6,
+} VRMessageOverlayResponse;
+
+typedef enum EGamepadTextInputMode
+{
+	EGamepadTextInputMode_k_EGamepadTextInputModeNormal = 0,
+	EGamepadTextInputMode_k_EGamepadTextInputModePassword = 1,
+	EGamepadTextInputMode_k_EGamepadTextInputModeSubmit = 2,
+} EGamepadTextInputMode;
+
+typedef enum EGamepadTextInputLineMode
+{
+	EGamepadTextInputLineMode_k_EGamepadTextInputLineModeSingleLine = 0,
+	EGamepadTextInputLineMode_k_EGamepadTextInputLineModeMultipleLines = 1,
+} EGamepadTextInputLineMode;
+
+typedef enum EOverlayDirection
+{
+	EOverlayDirection_OverlayDirection_Up = 0,
+	EOverlayDirection_OverlayDirection_Down = 1,
+	EOverlayDirection_OverlayDirection_Left = 2,
+	EOverlayDirection_OverlayDirection_Right = 3,
+	EOverlayDirection_OverlayDirection_Count = 4,
+} EOverlayDirection;
+
+typedef enum EVROverlayIntersectionMaskPrimitiveType
+{
+	EVROverlayIntersectionMaskPrimitiveType_OverlayIntersectionPrimitiveType_Rectangle = 0,
+	EVROverlayIntersectionMaskPrimitiveType_OverlayIntersectionPrimitiveType_Circle = 1,
+} EVROverlayIntersectionMaskPrimitiveType;
+
+typedef enum EVRRenderModelError
+{
+	EVRRenderModelError_VRRenderModelError_None = 0,
+	EVRRenderModelError_VRRenderModelError_Loading = 100,
+	EVRRenderModelError_VRRenderModelError_NotSupported = 200,
+	EVRRenderModelError_VRRenderModelError_InvalidArg = 300,
+	EVRRenderModelError_VRRenderModelError_InvalidModel = 301,
+	EVRRenderModelError_VRRenderModelError_NoShapes = 302,
+	EVRRenderModelError_VRRenderModelError_MultipleShapes = 303,
+	EVRRenderModelError_VRRenderModelError_TooManyVertices = 304,
+	EVRRenderModelError_VRRenderModelError_MultipleTextures = 305,
+	EVRRenderModelError_VRRenderModelError_BufferTooSmall = 306,
+	EVRRenderModelError_VRRenderModelError_NotEnoughNormals = 307,
+	EVRRenderModelError_VRRenderModelError_NotEnoughTexCoords = 308,
+	EVRRenderModelError_VRRenderModelError_InvalidTexture = 400,
+} EVRRenderModelError;
+
+typedef enum EVRComponentProperty
+{
+	EVRComponentProperty_VRComponentProperty_IsStatic = 1,
+	EVRComponentProperty_VRComponentProperty_IsVisible = 2,
+	EVRComponentProperty_VRComponentProperty_IsTouched = 4,
+	EVRComponentProperty_VRComponentProperty_IsPressed = 8,
+	EVRComponentProperty_VRComponentProperty_IsScrolled = 16,
+} EVRComponentProperty;
+
+typedef enum EVRNotificationType
+{
+	EVRNotificationType_Transient = 0,
+	EVRNotificationType_Persistent = 1,
+	EVRNotificationType_Transient_SystemWithUserValue = 2,
+} EVRNotificationType;
+
+typedef enum EVRNotificationStyle
+{
+	EVRNotificationStyle_None = 0,
+	EVRNotificationStyle_Application = 100,
+	EVRNotificationStyle_Contact_Disabled = 200,
+	EVRNotificationStyle_Contact_Enabled = 201,
+	EVRNotificationStyle_Contact_Active = 202,
+} EVRNotificationStyle;
+
+typedef enum EVRSettingsError
+{
+	EVRSettingsError_VRSettingsError_None = 0,
+	EVRSettingsError_VRSettingsError_IPCFailed = 1,
+	EVRSettingsError_VRSettingsError_WriteFailed = 2,
+	EVRSettingsError_VRSettingsError_ReadFailed = 3,
+	EVRSettingsError_VRSettingsError_JsonParseFailed = 4,
+	EVRSettingsError_VRSettingsError_UnsetSettingHasNoDefault = 5,
+} EVRSettingsError;
+
+typedef enum EVRScreenshotError
+{
+	EVRScreenshotError_VRScreenshotError_None = 0,
+	EVRScreenshotError_VRScreenshotError_RequestFailed = 1,
+	EVRScreenshotError_VRScreenshotError_IncompatibleVersion = 100,
+	EVRScreenshotError_VRScreenshotError_NotFound = 101,
+	EVRScreenshotError_VRScreenshotError_BufferTooSmall = 102,
+	EVRScreenshotError_VRScreenshotError_ScreenshotAlreadyInProgress = 108,
+} EVRScreenshotError;
+
+// OpenVR typedefs
+
+typedef uint32_t TrackedDeviceIndex_t;
+typedef uint32_t VRNotificationId;
+typedef uint64_t VROverlayHandle_t;
+
+typedef void *glSharedTextureHandle_t;
+typedef int32_t glInt_t;
+typedef uint32_t glUInt_t;
+typedef uint64_t SharedTextureHandle_t;
+typedef uint32_t DriverId_t;
+typedef uint32_t TrackedDeviceIndex_t;
+typedef uint64_t PropertyContainerHandle_t;
+typedef uint32_t PropertyTypeTag_t;
+typedef uint64_t VROverlayHandle_t;
+typedef uint64_t TrackedCameraHandle_t;
+typedef uint32_t ScreenshotHandle_t;
+typedef uint32_t VRComponentProperties;
+typedef int32_t TextureID_t;
+typedef uint32_t VRNotificationId;
+typedef EVRInitError HmdError;
+typedef EVREye Hmd_Eye;
+typedef EColorSpace ColorSpace;
+typedef ETrackingResult HmdTrackingResult;
+typedef ETrackedDeviceClass TrackedDeviceClass;
+typedef ETrackingUniverseOrigin TrackingUniverseOrigin;
+typedef ETrackedDeviceProperty TrackedDeviceProperty;
+typedef ETrackedPropertyError TrackedPropertyError;
+typedef EVRSubmitFlags VRSubmitFlags_t;
+typedef EVRState VRState_t;
+typedef ECollisionBoundsStyle CollisionBoundsStyle_t;
+typedef EVROverlayError VROverlayError;
+typedef EVRFirmwareError VRFirmwareError;
+typedef EVRCompositorError VRCompositorError;
+typedef EVRScreenshotError VRScreenshotsError;
+
+// OpenVR Structs
+
+typedef struct HmdMatrix34_t
+{
+	float m[3][4];  //float[3][4]
+} HmdMatrix34_t;
+
+typedef struct HmdMatrix44_t
+{
+	float m[4][4];  //float[4][4]
+} HmdMatrix44_t;
+
+typedef struct HmdVector3_t
+{
+	float v[3];  //float[3]
+} HmdVector3_t;
+
+typedef struct HmdVector4_t
+{
+	float v[4];  //float[4]
+} HmdVector4_t;
+
+typedef struct HmdVector3d_t
+{
+	double v[3];  //double[3]
+} HmdVector3d_t;
+
+typedef struct HmdVector2_t
+{
+	float v[2];  //float[2]
+} HmdVector2_t;
+
+typedef struct HmdQuaternion_t
+{
+	double w;
+	double x;
+	double y;
+	double z;
+} HmdQuaternion_t;
+
+typedef struct HmdColor_t
+{
+	float r;
+	float g;
+	float b;
+	float a;
+} HmdColor_t;
+
+typedef struct HmdQuad_t
+{
+	struct HmdVector3_t vCorners[4];  //struct vr::HmdVector3_t[4]
+} HmdQuad_t;
+
+typedef struct HmdRect2_t
+{
+	struct HmdVector2_t vTopLeft;
+	struct HmdVector2_t vBottomRight;
+} HmdRect2_t;
+
+typedef struct DistortionCoordinates_t
+{
+	float rfRed[2];    //float[2]
+	float rfGreen[2];  //float[2]
+	float rfBlue[2];   //float[2]
+} DistortionCoordinates_t;
+
+typedef struct Texture_t
+{
+	void *handle;  // void *
+	enum ETextureType eType;
+	enum EColorSpace eColorSpace;
+} Texture_t;
+
+typedef struct TrackedDevicePose_t
+{
+	struct HmdMatrix34_t mDeviceToAbsoluteTracking;
+	struct HmdVector3_t vVelocity;
+	struct HmdVector3_t vAngularVelocity;
+	enum ETrackingResult eTrackingResult;
+	bool bPoseIsValid;
+	bool bDeviceIsConnected;
+} TrackedDevicePose_t;
+
+typedef struct VRTextureBounds_t
+{
+	float uMin;
+	float vMin;
+	float uMax;
+	float vMax;
+} VRTextureBounds_t;
+
+typedef struct VRTextureWithPose_t
+{
+	struct HmdMatrix34_t mDeviceToAbsoluteTracking;
+} VRTextureWithPose_t;
+
+typedef struct VRVulkanTextureData_t
+{
+	uint64_t m_nImage;
+	struct VkDevice_T *m_pDevice;                  // struct VkDevice_T *
+	struct VkPhysicalDevice_T *m_pPhysicalDevice;  // struct VkPhysicalDevice_T *
+	struct VkInstance_T *m_pInstance;              // struct VkInstance_T *
+	struct VkQueue_T *m_pQueue;                    // struct VkQueue_T *
+	uint32_t m_nQueueFamilyIndex;
+	uint32_t m_nWidth;
+	uint32_t m_nHeight;
+	uint32_t m_nFormat;
+	uint32_t m_nSampleCount;
+} VRVulkanTextureData_t;
+
+typedef struct D3D12TextureData_t
+{
+	struct ID3D12Resource *m_pResource;          // struct ID3D12Resource *
+	struct ID3D12CommandQueue *m_pCommandQueue;  // struct ID3D12CommandQueue *
+	uint32_t m_nNodeMask;
+} D3D12TextureData_t;
+
+typedef struct VREvent_Controller_t
+{
+	uint32_t button;
+} VREvent_Controller_t;
+
+typedef struct VREvent_Mouse_t
+{
+	float x;
+	float y;
+	uint32_t button;
+} VREvent_Mouse_t;
+
+typedef struct VREvent_Scroll_t
+{
+	float xdelta;
+	float ydelta;
+	uint32_t repeatCount;
+} VREvent_Scroll_t;
+
+typedef struct VREvent_TouchPadMove_t
+{
+	bool bFingerDown;
+	float flSecondsFingerDown;
+	float fValueXFirst;
+	float fValueYFirst;
+	float fValueXRaw;
+	float fValueYRaw;
+} VREvent_TouchPadMove_t;
+
+typedef struct VREvent_Notification_t
+{
+	uint64_t ulUserValue;
+	uint32_t notificationId;
+} VREvent_Notification_t;
+
+typedef struct VREvent_Process_t
+{
+	uint32_t pid;
+	uint32_t oldPid;
+	bool bForced;
+} VREvent_Process_t;
+
+typedef struct VREvent_Overlay_t
+{
+	uint64_t overlayHandle;
+} VREvent_Overlay_t;
+
+typedef struct VREvent_Status_t
+{
+	uint32_t statusState;
+} VREvent_Status_t;
+
+typedef struct VREvent_Keyboard_t
+{
+	char *cNewInput[8];  //char[8]
+	uint64_t uUserValue;
+} VREvent_Keyboard_t;
+
+typedef struct VREvent_Ipd_t
+{
+	float ipdMeters;
+} VREvent_Ipd_t;
+
+typedef struct VREvent_Chaperone_t
+{
+	uint64_t m_nPreviousUniverse;
+	uint64_t m_nCurrentUniverse;
+} VREvent_Chaperone_t;
+
+typedef struct VREvent_Reserved_t
+{
+	uint64_t reserved0;
+	uint64_t reserved1;
+} VREvent_Reserved_t;
+
+typedef struct VREvent_PerformanceTest_t
+{
+	uint32_t m_nFidelityLevel;
+} VREvent_PerformanceTest_t;
+
+typedef struct VREvent_SeatedZeroPoseReset_t
+{
+	bool bResetBySystemMenu;
+} VREvent_SeatedZeroPoseReset_t;
+
+typedef struct VREvent_Screenshot_t
+{
+	uint32_t handle;
+	uint32_t type;
+} VREvent_Screenshot_t;
+
+typedef struct VREvent_ScreenshotProgress_t
+{
+	float progress;
+} VREvent_ScreenshotProgress_t;
+
+typedef struct VREvent_ApplicationLaunch_t
+{
+	uint32_t pid;
+	uint32_t unArgsHandle;
+} VREvent_ApplicationLaunch_t;
+
+typedef struct VREvent_EditingCameraSurface_t
+{
+	uint64_t overlayHandle;
+	uint32_t nVisualMode;
+} VREvent_EditingCameraSurface_t;
+
+typedef struct VREvent_MessageOverlay_t
+{
+	uint32_t unVRMessageOverlayResponse;
+} VREvent_MessageOverlay_t;
+
+typedef struct VREvent_Property_t
+{
+	PropertyContainerHandle_t container;
+	enum ETrackedDeviceProperty prop;
+} VREvent_Property_t;
+
+typedef struct HiddenAreaMesh_t
+{
+	struct HmdVector2_t *pVertexData;  // const struct vr::HmdVector2_t *
+	uint32_t unTriangleCount;
+} HiddenAreaMesh_t;
+
+typedef struct VRControllerAxis_t
+{
+	float x;
+	float y;
+} VRControllerAxis_t;
+
+typedef struct VRControllerState_t
+{
+	uint32_t unPacketNum;
+	uint64_t ulButtonPressed;
+	uint64_t ulButtonTouched;
+	struct VRControllerAxis_t rAxis[5];  //struct vr::VRControllerAxis_t[5]
+} VRControllerState_t;
+
+typedef struct Compositor_OverlaySettings
+{
+	uint32_t size;
+	bool curved;
+	bool antialias;
+	float scale;
+	float distance;
+	float alpha;
+	float uOffset;
+	float vOffset;
+	float uScale;
+	float vScale;
+	float gridDivs;
+	float gridWidth;
+	float gridScale;
+	struct HmdMatrix44_t transform;
+} Compositor_OverlaySettings;
+
+typedef struct CameraVideoStreamFrameHeader_t
+{
+	enum EVRTrackedCameraFrameType eFrameType;
+	uint32_t nWidth;
+	uint32_t nHeight;
+	uint32_t nBytesPerPixel;
+	uint32_t nFrameSequence;
+	struct TrackedDevicePose_t standingTrackedDevicePose;
+} CameraVideoStreamFrameHeader_t;
+
+typedef struct AppOverrideKeys_t
+{
+	char *pchKey;    // const char *
+	char *pchValue;  // const char *
+} AppOverrideKeys_t;
+
+typedef struct Compositor_FrameTiming
+{
+	uint32_t m_nSize;
+	uint32_t m_nFrameIndex;
+	uint32_t m_nNumFramePresents;
+	uint32_t m_nNumMisPresented;
+	uint32_t m_nNumDroppedFrames;
+	uint32_t m_nReprojectionFlags;
+	double m_flSystemTimeInSeconds;
+	float m_flPreSubmitGpuMs;
+	float m_flPostSubmitGpuMs;
+	float m_flTotalRenderGpuMs;
+	float m_flCompositorRenderGpuMs;
+	float m_flCompositorRenderCpuMs;
+	float m_flCompositorIdleCpuMs;
+	float m_flClientFrameIntervalMs;
+	float m_flPresentCallCpuMs;
+	float m_flWaitForPresentCpuMs;
+	float m_flSubmitFrameMs;
+	float m_flWaitGetPosesCalledMs;
+	float m_flNewPosesReadyMs;
+	float m_flNewFrameReadyMs;
+	float m_flCompositorUpdateStartMs;
+	float m_flCompositorUpdateEndMs;
+	float m_flCompositorRenderStartMs;
+	TrackedDevicePose_t m_HmdPose;
+} Compositor_FrameTiming;
+
+typedef struct Compositor_CumulativeStats
+{
+	uint32_t m_nPid;
+	uint32_t m_nNumFramePresents;
+	uint32_t m_nNumDroppedFrames;
+	uint32_t m_nNumReprojectedFrames;
+	uint32_t m_nNumFramePresentsOnStartup;
+	uint32_t m_nNumDroppedFramesOnStartup;
+	uint32_t m_nNumReprojectedFramesOnStartup;
+	uint32_t m_nNumLoading;
+	uint32_t m_nNumFramePresentsLoading;
+	uint32_t m_nNumDroppedFramesLoading;
+	uint32_t m_nNumReprojectedFramesLoading;
+	uint32_t m_nNumTimedOut;
+	uint32_t m_nNumFramePresentsTimedOut;
+	uint32_t m_nNumDroppedFramesTimedOut;
+	uint32_t m_nNumReprojectedFramesTimedOut;
+} Compositor_CumulativeStats;
+
+typedef struct VROverlayIntersectionParams_t
+{
+	struct HmdVector3_t vSource;
+	struct HmdVector3_t vDirection;
+	enum ETrackingUniverseOrigin eOrigin;
+} VROverlayIntersectionParams_t;
+
+typedef struct VROverlayIntersectionResults_t
+{
+	struct HmdVector3_t vPoint;
+	struct HmdVector3_t vNormal;
+	struct HmdVector2_t vUVs;
+	float fDistance;
+} VROverlayIntersectionResults_t;
+
+typedef struct IntersectionMaskRectangle_t
+{
+	float m_flTopLeftX;
+	float m_flTopLeftY;
+	float m_flWidth;
+	float m_flHeight;
+} IntersectionMaskRectangle_t;
+
+typedef struct IntersectionMaskCircle_t
+{
+	float m_flCenterX;
+	float m_flCenterY;
+	float m_flRadius;
+} IntersectionMaskCircle_t;
+
+typedef struct RenderModel_ComponentState_t
+{
+	struct HmdMatrix34_t mTrackingToComponentRenderModel;
+	struct HmdMatrix34_t mTrackingToComponentLocal;
+	VRComponentProperties uProperties;
+} RenderModel_ComponentState_t;
+
+typedef struct RenderModel_Vertex_t
+{
+	struct HmdVector3_t vPosition;
+	struct HmdVector3_t vNormal;
+	float rfTextureCoord[2];  //float[2]
+} RenderModel_Vertex_t;
+
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(push, 4)
+#endif
+typedef struct RenderModel_TextureMap_t
+{
+	uint16_t unWidth;
+	uint16_t unHeight;
+	uint8_t *rubTextureMapData;  // const uint8_t *
+} RenderModel_TextureMap_t;
+
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(push, 4)
+#endif
+typedef struct RenderModel_t
+{
+	struct RenderModel_Vertex_t *rVertexData;  // const struct vr::RenderModel_Vertex_t *
+	uint32_t unVertexCount;
+	uint16_t *rIndexData;  // const uint16_t *
+	uint32_t unTriangleCount;
+	TextureID_t diffuseTextureId;
+} RenderModel_t;
+
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+typedef struct RenderModel_ControllerMode_State_t
+{
+	bool bScrollWheelVisible;
+} RenderModel_ControllerMode_State_t;
+
+typedef struct NotificationBitmap_t
+{
+	void *m_pImageData;  // void *
+	int32_t m_nWidth;
+	int32_t m_nHeight;
+	int32_t m_nBytesPerPixel;
+} NotificationBitmap_t;
+
+typedef struct COpenVRContext
+{
+	intptr_t m_pVRSystem;           // class vr::IVRSystem *
+	intptr_t m_pVRChaperone;        // class vr::IVRChaperone *
+	intptr_t m_pVRChaperoneSetup;   // class vr::IVRChaperoneSetup *
+	intptr_t m_pVRCompositor;       // class vr::IVRCompositor *
+	intptr_t m_pVROverlay;          // class vr::IVROverlay *
+	intptr_t m_pVRResources;        // class vr::IVRResources *
+	intptr_t m_pVRRenderModels;     // class vr::IVRRenderModels *
+	intptr_t m_pVRExtendedDisplay;  // class vr::IVRExtendedDisplay *
+	intptr_t m_pVRSettings;         // class vr::IVRSettings *
+	intptr_t m_pVRApplications;     // class vr::IVRApplications *
+	intptr_t m_pVRTrackedCamera;    // class vr::IVRTrackedCamera *
+	intptr_t m_pVRScreenshots;      // class vr::IVRScreenshots *
+	intptr_t m_pVRDriverManager;    // class vr::IVRDriverManager *
+} COpenVRContext;
+
+typedef union {
+	VREvent_Reserved_t reserved;
+	VREvent_Controller_t controller;
+	VREvent_Mouse_t mouse;
+	VREvent_Scroll_t scroll;
+	VREvent_Process_t process;
+	VREvent_Notification_t notification;
+	VREvent_Overlay_t overlay;
+	VREvent_Status_t status;
+	VREvent_Keyboard_t keyboard;
+	VREvent_Ipd_t ipd;
+	VREvent_Chaperone_t chaperone;
+	VREvent_PerformanceTest_t performanceTest;
+	VREvent_TouchPadMove_t touchPadMove;
+	VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset;
+} VREvent_Data_t;
+
+/** An event posted by the server to all running applications */
+struct VREvent_t
+{
+	uint32_t eventType;  // EVREventType enum
+	TrackedDeviceIndex_t trackedDeviceIndex;
+	float eventAgeSeconds;
+	// event data must be the end of the struct as its size is variable
+	VREvent_Data_t data;
+};
+
+typedef union {
+	IntersectionMaskRectangle_t m_Rectangle;
+	IntersectionMaskCircle_t m_Circle;
+} VROverlayIntersectionMaskPrimitive_Data_t;
+
+struct VROverlayIntersectionMaskPrimitive_t
+{
+	EVROverlayIntersectionMaskPrimitiveType m_nPrimitiveType;
+	VROverlayIntersectionMaskPrimitive_Data_t m_Primitive;
+};
+
+// OpenVR Function Pointer Tables
+
+struct VR_IVRSystem_FnTable
+{
+	void(OPENVR_FNTABLE_CALLTYPE *GetRecommendedRenderTargetSize)(uint32_t *pnWidth, uint32_t *pnHeight);
+	struct HmdMatrix44_t(OPENVR_FNTABLE_CALLTYPE *GetProjectionMatrix)(EVREye eEye, float fNearZ, float fFarZ);
+	void(OPENVR_FNTABLE_CALLTYPE *GetProjectionRaw)(EVREye eEye, float *pfLeft, float *pfRight, float *pfTop, float *pfBottom);
+	bool(OPENVR_FNTABLE_CALLTYPE *ComputeDistortion)(EVREye eEye, float fU, float fV, struct DistortionCoordinates_t *pDistortionCoordinates);
+	struct HmdMatrix34_t(OPENVR_FNTABLE_CALLTYPE *GetEyeToHeadTransform)(EVREye eEye);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetTimeSinceLastVsync)(float *pfSecondsSinceLastVsync, uint64_t *pulFrameCounter);
+	int32_t(OPENVR_FNTABLE_CALLTYPE *GetD3D9AdapterIndex)();
+	void(OPENVR_FNTABLE_CALLTYPE *GetDXGIOutputInfo)(int32_t *pnAdapterIndex);
+	void(OPENVR_FNTABLE_CALLTYPE *GetOutputDevice)(uint64_t *pnDevice, ETextureType textureType, struct VkInstance_T *pInstance);
+	bool(OPENVR_FNTABLE_CALLTYPE *IsDisplayOnDesktop)();
+	bool(OPENVR_FNTABLE_CALLTYPE *SetDisplayVisibility)(bool bIsVisibleOnDesktop);
+	void(OPENVR_FNTABLE_CALLTYPE *GetDeviceToAbsoluteTrackingPose)(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, struct TrackedDevicePose_t *pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount);
+	void(OPENVR_FNTABLE_CALLTYPE *ResetSeatedZeroPose)();
+	struct HmdMatrix34_t(OPENVR_FNTABLE_CALLTYPE *GetSeatedZeroPoseToStandingAbsoluteTrackingPose)();
+	struct HmdMatrix34_t(OPENVR_FNTABLE_CALLTYPE *GetRawZeroPoseToStandingAbsoluteTrackingPose)();
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetSortedTrackedDeviceIndicesOfClass)(ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t *punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex);
+	EDeviceActivityLevel(OPENVR_FNTABLE_CALLTYPE *GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId);
+	void(OPENVR_FNTABLE_CALLTYPE *ApplyTransform)(struct TrackedDevicePose_t *pOutputPose, struct TrackedDevicePose_t *pTrackedDevicePose, struct HmdMatrix34_t *pTransform);
+	TrackedDeviceIndex_t(OPENVR_FNTABLE_CALLTYPE *GetTrackedDeviceIndexForControllerRole)(ETrackedControllerRole unDeviceType);
+	ETrackedControllerRole(OPENVR_FNTABLE_CALLTYPE *GetControllerRoleForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex);
+	ETrackedDeviceClass(OPENVR_FNTABLE_CALLTYPE *GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex);
+	bool(OPENVR_FNTABLE_CALLTYPE *IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError);
+	float(OPENVR_FNTABLE_CALLTYPE *GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError);
+	int32_t(OPENVR_FNTABLE_CALLTYPE *GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError);
+	uint64_t(OPENVR_FNTABLE_CALLTYPE *GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError);
+	struct HmdMatrix34_t(OPENVR_FNTABLE_CALLTYPE *GetMatrix34TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetPropErrorNameFromEnum)(ETrackedPropertyError error);
+	bool(OPENVR_FNTABLE_CALLTYPE *PollNextEvent)(struct VREvent_t *pEvent, uint32_t uncbVREvent);
+	bool(OPENVR_FNTABLE_CALLTYPE *PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, struct VREvent_t *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetEventTypeNameFromEnum)(EVREventType eType);
+	struct HiddenAreaMesh_t(OPENVR_FNTABLE_CALLTYPE *GetHiddenAreaMesh)(EVREye eEye, EHiddenAreaMeshType type);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t *pControllerState, uint32_t unControllerStateSize);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t *pControllerState, uint32_t unControllerStateSize, struct TrackedDevicePose_t *pTrackedDevicePose);
+	void(OPENVR_FNTABLE_CALLTYPE *TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetButtonIdNameFromEnum)(EVRButtonId eButtonId);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType);
+	bool(OPENVR_FNTABLE_CALLTYPE *CaptureInputFocus)();
+	void(OPENVR_FNTABLE_CALLTYPE *ReleaseInputFocus)();
+	bool(OPENVR_FNTABLE_CALLTYPE *IsInputFocusCapturedByAnotherProcess)();
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, char *pchRequest, char *pchResponseBuffer, uint32_t unResponseBufferSize);
+	EVRFirmwareError(OPENVR_FNTABLE_CALLTYPE *PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex);
+	void(OPENVR_FNTABLE_CALLTYPE *AcknowledgeQuit_Exiting)();
+	void(OPENVR_FNTABLE_CALLTYPE *AcknowledgeQuit_UserPrompt)();
+};
+
+struct VR_IVRExtendedDisplay_FnTable
+{
+	void(OPENVR_FNTABLE_CALLTYPE *GetWindowBounds)(int32_t *pnX, int32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight);
+	void(OPENVR_FNTABLE_CALLTYPE *GetEyeOutputViewport)(EVREye eEye, uint32_t *pnX, uint32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight);
+	void(OPENVR_FNTABLE_CALLTYPE *GetDXGIOutputInfo)(int32_t *pnAdapterIndex, int32_t *pnAdapterOutputIndex);
+};
+
+struct VR_IVRTrackedCamera_FnTable
+{
+	char *(OPENVR_FNTABLE_CALLTYPE *GetCameraErrorNameFromEnum)(EVRTrackedCameraError eCameraError);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *HasCamera)(TrackedDeviceIndex_t nDeviceIndex, bool *pHasCamera);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *GetCameraFrameSize)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, uint32_t *pnWidth, uint32_t *pnHeight, uint32_t *pnFrameBufferSize);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *GetCameraIntrinsics)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, HmdVector2_t *pFocalLength, HmdVector2_t *pCenter);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *GetCameraProjection)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, HmdMatrix44_t *pProjection);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *AcquireVideoStreamingService)(TrackedDeviceIndex_t nDeviceIndex, TrackedCameraHandle_t *pHandle);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *ReleaseVideoStreamingService)(TrackedCameraHandle_t hTrackedCamera);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *GetVideoStreamFrameBuffer)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void *pFrameBuffer, uint32_t nFrameBufferSize, CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *GetVideoStreamTextureSize)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, VRTextureBounds_t *pTextureBounds, uint32_t *pnWidth, uint32_t *pnHeight);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *GetVideoStreamTextureD3D11)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView, CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *GetVideoStreamTextureGL)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t *pglTextureId, CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize);
+	EVRTrackedCameraError(OPENVR_FNTABLE_CALLTYPE *ReleaseVideoStreamTextureGL)(TrackedCameraHandle_t hTrackedCamera, glUInt_t glTextureId);
+};
+
+struct VR_IVRApplications_FnTable
+{
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *AddApplicationManifest)(char *pchApplicationManifestFullPath, bool bTemporary);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *RemoveApplicationManifest)(char *pchApplicationManifestFullPath);
+	bool(OPENVR_FNTABLE_CALLTYPE *IsApplicationInstalled)(char *pchAppKey);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetApplicationCount)();
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *GetApplicationKeyByIndex)(uint32_t unApplicationIndex, char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *GetApplicationKeyByProcessId)(uint32_t unProcessId, char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *LaunchApplication)(char *pchAppKey);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *LaunchTemplateApplication)(char *pchTemplateAppKey, char *pchNewAppKey, struct AppOverrideKeys_t *pKeys, uint32_t unKeys);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *LaunchApplicationFromMimeType)(char *pchMimeType, char *pchArgs);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *LaunchDashboardOverlay)(char *pchAppKey);
+	bool(OPENVR_FNTABLE_CALLTYPE *CancelApplicationLaunch)(char *pchAppKey);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *IdentifyApplication)(uint32_t unProcessId, char *pchAppKey);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetApplicationProcessId)(char *pchAppKey);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetApplicationsErrorNameFromEnum)(EVRApplicationError error);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetApplicationPropertyString)(char *pchAppKey, EVRApplicationProperty eProperty, char *pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError *peError);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetApplicationPropertyBool)(char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError);
+	uint64_t(OPENVR_FNTABLE_CALLTYPE *GetApplicationPropertyUint64)(char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *SetApplicationAutoLaunch)(char *pchAppKey, bool bAutoLaunch);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetApplicationAutoLaunch)(char *pchAppKey);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *SetDefaultApplicationForMimeType)(char *pchAppKey, char *pchMimeType);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetDefaultApplicationForMimeType)(char *pchMimeType, char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetApplicationSupportedMimeTypes)(char *pchAppKey, char *pchMimeTypesBuffer, uint32_t unMimeTypesBuffer);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetApplicationsThatSupportMimeType)(char *pchMimeType, char *pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetApplicationLaunchArguments)(uint32_t unHandle, char *pchArgs, uint32_t unArgs);
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *GetStartingApplication)(char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+	EVRApplicationTransitionState(OPENVR_FNTABLE_CALLTYPE *GetTransitionState)();
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *PerformApplicationPrelaunchCheck)(char *pchAppKey);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetApplicationsTransitionStateNameFromEnum)(EVRApplicationTransitionState state);
+	bool(OPENVR_FNTABLE_CALLTYPE *IsQuitUserPromptRequested)();
+	EVRApplicationError(OPENVR_FNTABLE_CALLTYPE *LaunchInternalProcess)(char *pchBinaryPath, char *pchArguments, char *pchWorkingDirectory);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetCurrentSceneProcessId)();
+};
+
+struct VR_IVRChaperone_FnTable
+{
+	ChaperoneCalibrationState(OPENVR_FNTABLE_CALLTYPE *GetCalibrationState)();
+	bool(OPENVR_FNTABLE_CALLTYPE *GetPlayAreaSize)(float *pSizeX, float *pSizeZ);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetPlayAreaRect)(struct HmdQuad_t *rect);
+	void(OPENVR_FNTABLE_CALLTYPE *ReloadInfo)();
+	void(OPENVR_FNTABLE_CALLTYPE *SetSceneColor)(struct HmdColor_t color);
+	void(OPENVR_FNTABLE_CALLTYPE *GetBoundsColor)(struct HmdColor_t *pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, struct HmdColor_t *pOutputCameraColor);
+	bool(OPENVR_FNTABLE_CALLTYPE *AreBoundsVisible)();
+	void(OPENVR_FNTABLE_CALLTYPE *ForceBoundsVisible)(bool bForce);
+};
+
+struct VR_IVRChaperoneSetup_FnTable
+{
+	bool(OPENVR_FNTABLE_CALLTYPE *CommitWorkingCopy)(EChaperoneConfigFile configFile);
+	void(OPENVR_FNTABLE_CALLTYPE *RevertWorkingCopy)();
+	bool(OPENVR_FNTABLE_CALLTYPE *GetWorkingPlayAreaSize)(float *pSizeX, float *pSizeZ);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetWorkingPlayAreaRect)(struct HmdQuad_t *rect);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetWorkingCollisionBoundsInfo)(struct HmdQuad_t *pQuadsBuffer, uint32_t *punQuadsCount);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetLiveCollisionBoundsInfo)(struct HmdQuad_t *pQuadsBuffer, uint32_t *punQuadsCount);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetWorkingSeatedZeroPoseToRawTrackingPose)(struct HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetWorkingStandingZeroPoseToRawTrackingPose)(struct HmdMatrix34_t *pmatStandingZeroPoseToRawTrackingPose);
+	void(OPENVR_FNTABLE_CALLTYPE *SetWorkingPlayAreaSize)(float sizeX, float sizeZ);
+	void(OPENVR_FNTABLE_CALLTYPE *SetWorkingCollisionBoundsInfo)(struct HmdQuad_t *pQuadsBuffer, uint32_t unQuadsCount);
+	void(OPENVR_FNTABLE_CALLTYPE *SetWorkingSeatedZeroPoseToRawTrackingPose)(struct HmdMatrix34_t *pMatSeatedZeroPoseToRawTrackingPose);
+	void(OPENVR_FNTABLE_CALLTYPE *SetWorkingStandingZeroPoseToRawTrackingPose)(struct HmdMatrix34_t *pMatStandingZeroPoseToRawTrackingPose);
+	void(OPENVR_FNTABLE_CALLTYPE *ReloadFromDisk)(EChaperoneConfigFile configFile);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetLiveSeatedZeroPoseToRawTrackingPose)(struct HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose);
+	void(OPENVR_FNTABLE_CALLTYPE *SetWorkingCollisionBoundsTagsInfo)(uint8_t *pTagsBuffer, uint32_t unTagCount);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetLiveCollisionBoundsTagsInfo)(uint8_t *pTagsBuffer, uint32_t *punTagCount);
+	bool(OPENVR_FNTABLE_CALLTYPE *SetWorkingPhysicalBoundsInfo)(struct HmdQuad_t *pQuadsBuffer, uint32_t unQuadsCount);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetLivePhysicalBoundsInfo)(struct HmdQuad_t *pQuadsBuffer, uint32_t *punQuadsCount);
+	bool(OPENVR_FNTABLE_CALLTYPE *ExportLiveToBuffer)(char *pBuffer, uint32_t *pnBufferLength);
+	bool(OPENVR_FNTABLE_CALLTYPE *ImportFromBufferToWorking)(char *pBuffer, uint32_t nImportFlags);
+};
+
+struct VR_IVRCompositor_FnTable
+{
+	void(OPENVR_FNTABLE_CALLTYPE *SetTrackingSpace)(ETrackingUniverseOrigin eOrigin);
+	ETrackingUniverseOrigin(OPENVR_FNTABLE_CALLTYPE *GetTrackingSpace)();
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *WaitGetPoses)(struct TrackedDevicePose_t *pRenderPoseArray, uint32_t unRenderPoseArrayCount, struct TrackedDevicePose_t *pGamePoseArray, uint32_t unGamePoseArrayCount);
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *GetLastPoses)(struct TrackedDevicePose_t *pRenderPoseArray, uint32_t unRenderPoseArrayCount, struct TrackedDevicePose_t *pGamePoseArray, uint32_t unGamePoseArrayCount);
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, struct TrackedDevicePose_t *pOutputPose, struct TrackedDevicePose_t *pOutputGamePose);
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *Submit)(EVREye eEye, struct Texture_t *pTexture, struct VRTextureBounds_t *pBounds, EVRSubmitFlags nSubmitFlags);
+	void(OPENVR_FNTABLE_CALLTYPE *ClearLastSubmittedFrame)();
+	void(OPENVR_FNTABLE_CALLTYPE *PostPresentHandoff)();
+	bool(OPENVR_FNTABLE_CALLTYPE *GetFrameTiming)(struct Compositor_FrameTiming *pTiming, uint32_t unFramesAgo);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetFrameTimings)(struct Compositor_FrameTiming *pTiming, uint32_t nFrames);
+	float(OPENVR_FNTABLE_CALLTYPE *GetFrameTimeRemaining)();
+	void(OPENVR_FNTABLE_CALLTYPE *GetCumulativeStats)(struct Compositor_CumulativeStats *pStats, uint32_t nStatsSizeInBytes);
+	void(OPENVR_FNTABLE_CALLTYPE *FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
+	struct HmdColor_t(OPENVR_FNTABLE_CALLTYPE *GetCurrentFadeColor)(bool bBackground);
+	void(OPENVR_FNTABLE_CALLTYPE *FadeGrid)(float fSeconds, bool bFadeIn);
+	float(OPENVR_FNTABLE_CALLTYPE *GetCurrentGridAlpha)();
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *SetSkyboxOverride)(struct Texture_t *pTextures, uint32_t unTextureCount);
+	void(OPENVR_FNTABLE_CALLTYPE *ClearSkyboxOverride)();
+	void(OPENVR_FNTABLE_CALLTYPE *CompositorBringToFront)();
+	void(OPENVR_FNTABLE_CALLTYPE *CompositorGoToBack)();
+	void(OPENVR_FNTABLE_CALLTYPE *CompositorQuit)();
+	bool(OPENVR_FNTABLE_CALLTYPE *IsFullscreen)();
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetCurrentSceneFocusProcess)();
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetLastFrameRenderer)();
+	bool(OPENVR_FNTABLE_CALLTYPE *CanRenderScene)();
+	void(OPENVR_FNTABLE_CALLTYPE *ShowMirrorWindow)();
+	void(OPENVR_FNTABLE_CALLTYPE *HideMirrorWindow)();
+	bool(OPENVR_FNTABLE_CALLTYPE *IsMirrorWindowVisible)();
+	void(OPENVR_FNTABLE_CALLTYPE *CompositorDumpImages)();
+	bool(OPENVR_FNTABLE_CALLTYPE *ShouldAppRenderWithLowResources)();
+	void(OPENVR_FNTABLE_CALLTYPE *ForceInterleavedReprojectionOn)(bool bOverride);
+	void(OPENVR_FNTABLE_CALLTYPE *ForceReconnectProcess)();
+	void(OPENVR_FNTABLE_CALLTYPE *SuspendRendering)(bool bSuspend);
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *GetMirrorTextureD3D11)(EVREye eEye, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView);
+	void(OPENVR_FNTABLE_CALLTYPE *ReleaseMirrorTextureD3D11)(void *pD3D11ShaderResourceView);
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *GetMirrorTextureGL)(EVREye eEye, glUInt_t *pglTextureId, glSharedTextureHandle_t *pglSharedTextureHandle);
+	bool(OPENVR_FNTABLE_CALLTYPE *ReleaseSharedGLTexture)(glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle);
+	void(OPENVR_FNTABLE_CALLTYPE *LockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle);
+	void(OPENVR_FNTABLE_CALLTYPE *UnlockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetVulkanInstanceExtensionsRequired)(char *pchValue, uint32_t unBufferSize);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetVulkanDeviceExtensionsRequired)(struct VkPhysicalDevice_T *pPhysicalDevice, char *pchValue, uint32_t unBufferSize);
+	void(OPENVR_FNTABLE_CALLTYPE *SetExplicitTimingMode)(bool bExplicitTimingMode);
+	EVRCompositorError(OPENVR_FNTABLE_CALLTYPE *SubmitExplicitTimingData)();
+};
+
+struct VR_IVROverlay_FnTable
+{
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *FindOverlay)(char *pchOverlayKey, VROverlayHandle_t *pOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *CreateOverlay)(char *pchOverlayKey, char *pchOverlayName, VROverlayHandle_t *pOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *DestroyOverlay)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle);
+	VROverlayHandle_t(OPENVR_FNTABLE_CALLTYPE *GetHighQualityOverlay)();
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char *pchValue, uint32_t unBufferSize, EVROverlayError *pError);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char *pchValue, uint32_t unBufferSize, EVROverlayError *pError);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayName)(VROverlayHandle_t ulOverlayHandle, char *pchName);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unBufferSize, uint32_t *punWidth, uint32_t *punHeight);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetOverlayErrorNameFromEnum)(EVROverlayError error);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool *pbEnabled);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float *pfRed, float *pfGreen, float *pfBlue);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float *pfAlpha);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float fTexelAspect);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float *pfTexelAspect);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t *punSortOrder);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float *pfWidthInMeters);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float *pfMinDistanceInMeters, float *pfMaxDistanceInMeters);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace *peTextureColorSpace);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, struct VRTextureBounds_t *pOverlayTextureBounds);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, struct VRTextureBounds_t *pOverlayTextureBounds);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, char *pchValue, uint32_t unBufferSize, struct HmdColor_t *pColor, EVROverlayError *pError);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, char *pchRenderModel, struct HmdColor_t *pColor);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType *peTransformType);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, struct HmdMatrix34_t *pmatTrackingOriginToOverlayTransform);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin *peTrackingOrigin, struct HmdMatrix34_t *pmatTrackingOriginToOverlayTransform);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, struct HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punTrackedDevice, struct HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, char *pchComponentName);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punDeviceIndex, char *pchComponentName, uint32_t unComponentNameSize);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t *ulOverlayHandleParent, struct HmdMatrix34_t *pmatParentOverlayToOverlayTransform);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, struct HmdMatrix34_t *pmatParentOverlayToOverlayTransform);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *ShowOverlay)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *HideOverlay)(VROverlayHandle_t ulOverlayHandle);
+	bool(OPENVR_FNTABLE_CALLTYPE *IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, struct HmdVector2_t coordinatesInOverlay, struct HmdMatrix34_t *pmatTransform);
+	bool(OPENVR_FNTABLE_CALLTYPE *PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, struct VREvent_t *pEvent, uint32_t uncbVREvent);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod *peInputMethod);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, struct HmdVector2_t *pvecMouseScale);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, struct HmdVector2_t *pvecMouseScale);
+	bool(OPENVR_FNTABLE_CALLTYPE *ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, struct VROverlayIntersectionParams_t *pParams, struct VROverlayIntersectionResults_t *pResults);
+	bool(OPENVR_FNTABLE_CALLTYPE *HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex);
+	bool(OPENVR_FNTABLE_CALLTYPE *IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle);
+	VROverlayHandle_t(OPENVR_FNTABLE_CALLTYPE *GetGamepadFocusOverlay)();
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetGamepadFocusOverlay)(VROverlayHandle_t ulNewFocusOverlay);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *MoveGamepadFocusToNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, struct Texture_t *pTexture);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, char *pchFilePath);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void **pNativeTextureHandle, void *pNativeTextureRef, uint32_t *pWidth, uint32_t *pHeight, uint32_t *pNativeFormat, ETextureType *pAPIType, EColorSpace *pColorSpace, struct VRTextureBounds_t *pTextureBounds);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void *pNativeTextureHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t *pWidth, uint32_t *pHeight);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *CreateDashboardOverlay)(char *pchOverlayKey, char *pchOverlayFriendlyName, VROverlayHandle_t *pMainHandle, VROverlayHandle_t *pThumbnailHandle);
+	bool(OPENVR_FNTABLE_CALLTYPE *IsDashboardVisible)();
+	bool(OPENVR_FNTABLE_CALLTYPE *IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t *punProcessId);
+	void(OPENVR_FNTABLE_CALLTYPE *ShowDashboard)(char *pchOverlayToShow);
+	TrackedDeviceIndex_t(OPENVR_FNTABLE_CALLTYPE *GetPrimaryDashboardDevice)();
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, char *pchDescription, uint32_t unCharMax, char *pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, char *pchDescription, uint32_t unCharMax, char *pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetKeyboardText)(char *pchText, uint32_t cchText);
+	void(OPENVR_FNTABLE_CALLTYPE *HideKeyboard)();
+	void(OPENVR_FNTABLE_CALLTYPE *SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, struct HmdMatrix34_t *pmatTrackingOriginToKeyboardTransform);
+	void(OPENVR_FNTABLE_CALLTYPE *SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, struct HmdRect2_t avoidRect);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *SetOverlayIntersectionMask)(VROverlayHandle_t ulOverlayHandle, struct VROverlayIntersectionMaskPrimitive_t *pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
+	EVROverlayError(OPENVR_FNTABLE_CALLTYPE *GetOverlayFlags)(VROverlayHandle_t ulOverlayHandle, uint32_t *pFlags);
+	VRMessageOverlayResponse(OPENVR_FNTABLE_CALLTYPE *ShowMessageOverlay)(char *pchText, char *pchCaption, char *pchButton0Text, char *pchButton1Text, char *pchButton2Text, char *pchButton3Text);
+	void(OPENVR_FNTABLE_CALLTYPE *CloseMessageOverlay)();
+};
+
+struct VR_IVRRenderModels_FnTable
+{
+	EVRRenderModelError(OPENVR_FNTABLE_CALLTYPE *LoadRenderModel_Async)(char *pchRenderModelName, struct RenderModel_t **ppRenderModel);
+	void(OPENVR_FNTABLE_CALLTYPE *FreeRenderModel)(struct RenderModel_t *pRenderModel);
+	EVRRenderModelError(OPENVR_FNTABLE_CALLTYPE *LoadTexture_Async)(TextureID_t textureId, struct RenderModel_TextureMap_t **ppTexture);
+	void(OPENVR_FNTABLE_CALLTYPE *FreeTexture)(struct RenderModel_TextureMap_t *pTexture);
+	EVRRenderModelError(OPENVR_FNTABLE_CALLTYPE *LoadTextureD3D11_Async)(TextureID_t textureId, void *pD3D11Device, void **ppD3D11Texture2D);
+	EVRRenderModelError(OPENVR_FNTABLE_CALLTYPE *LoadIntoTextureD3D11_Async)(TextureID_t textureId, void *pDstTexture);
+	void(OPENVR_FNTABLE_CALLTYPE *FreeTextureD3D11)(void *pD3D11Texture2D);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetRenderModelName)(uint32_t unRenderModelIndex, char *pchRenderModelName, uint32_t unRenderModelNameLen);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetRenderModelCount)();
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetComponentCount)(char *pchRenderModelName);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetComponentName)(char *pchRenderModelName, uint32_t unComponentIndex, char *pchComponentName, uint32_t unComponentNameLen);
+	uint64_t(OPENVR_FNTABLE_CALLTYPE *GetComponentButtonMask)(char *pchRenderModelName, char *pchComponentName);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetComponentRenderModelName)(char *pchRenderModelName, char *pchComponentName, char *pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetComponentState)(char *pchRenderModelName, char *pchComponentName, VRControllerState_t *pControllerState, struct RenderModel_ControllerMode_State_t *pState, struct RenderModel_ComponentState_t *pComponentState);
+	bool(OPENVR_FNTABLE_CALLTYPE *RenderModelHasComponent)(char *pchRenderModelName, char *pchComponentName);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetRenderModelThumbnailURL)(char *pchRenderModelName, char *pchThumbnailURL, uint32_t unThumbnailURLLen, EVRRenderModelError *peError);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetRenderModelOriginalPath)(char *pchRenderModelName, char *pchOriginalPath, uint32_t unOriginalPathLen, EVRRenderModelError *peError);
+	char *(OPENVR_FNTABLE_CALLTYPE *GetRenderModelErrorNameFromEnum)(EVRRenderModelError error);
+};
+
+struct VR_IVRNotifications_FnTable
+{
+	EVRNotificationError(OPENVR_FNTABLE_CALLTYPE *CreateNotification)(VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, EVRNotificationType type, char *pchText, EVRNotificationStyle style, struct NotificationBitmap_t *pImage, VRNotificationId *pNotificationId);
+	EVRNotificationError(OPENVR_FNTABLE_CALLTYPE *RemoveNotification)(VRNotificationId notificationId);
+};
+
+struct VR_IVRSettings_FnTable
+{
+	char *(OPENVR_FNTABLE_CALLTYPE *GetSettingsErrorNameFromEnum)(EVRSettingsError eError);
+	bool(OPENVR_FNTABLE_CALLTYPE *Sync)(bool bForce, EVRSettingsError *peError);
+	void(OPENVR_FNTABLE_CALLTYPE *SetBool)(char *pchSection, char *pchSettingsKey, bool bValue, EVRSettingsError *peError);
+	void(OPENVR_FNTABLE_CALLTYPE *SetInt32)(char *pchSection, char *pchSettingsKey, int32_t nValue, EVRSettingsError *peError);
+	void(OPENVR_FNTABLE_CALLTYPE *SetFloat)(char *pchSection, char *pchSettingsKey, float flValue, EVRSettingsError *peError);
+	void(OPENVR_FNTABLE_CALLTYPE *SetString)(char *pchSection, char *pchSettingsKey, char *pchValue, EVRSettingsError *peError);
+	bool(OPENVR_FNTABLE_CALLTYPE *GetBool)(char *pchSection, char *pchSettingsKey, EVRSettingsError *peError);
+	int32_t(OPENVR_FNTABLE_CALLTYPE *GetInt32)(char *pchSection, char *pchSettingsKey, EVRSettingsError *peError);
+	float(OPENVR_FNTABLE_CALLTYPE *GetFloat)(char *pchSection, char *pchSettingsKey, EVRSettingsError *peError);
+	void(OPENVR_FNTABLE_CALLTYPE *GetString)(char *pchSection, char *pchSettingsKey, char *pchValue, uint32_t unValueLen, EVRSettingsError *peError);
+	void(OPENVR_FNTABLE_CALLTYPE *RemoveSection)(char *pchSection, EVRSettingsError *peError);
+	void(OPENVR_FNTABLE_CALLTYPE *RemoveKeyInSection)(char *pchSection, char *pchSettingsKey, EVRSettingsError *peError);
+};
+
+struct VR_IVRScreenshots_FnTable
+{
+	EVRScreenshotError(OPENVR_FNTABLE_CALLTYPE *RequestScreenshot)(ScreenshotHandle_t *pOutScreenshotHandle, EVRScreenshotType type, char *pchPreviewFilename, char *pchVRFilename);
+	EVRScreenshotError(OPENVR_FNTABLE_CALLTYPE *HookScreenshot)(EVRScreenshotType *pSupportedTypes, int numTypes);
+	EVRScreenshotType(OPENVR_FNTABLE_CALLTYPE *GetScreenshotPropertyType)(ScreenshotHandle_t screenshotHandle, EVRScreenshotError *pError);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetScreenshotPropertyFilename)(ScreenshotHandle_t screenshotHandle, EVRScreenshotPropertyFilenames filenameType, char *pchFilename, uint32_t cchFilename, EVRScreenshotError *pError);
+	EVRScreenshotError(OPENVR_FNTABLE_CALLTYPE *UpdateScreenshotProgress)(ScreenshotHandle_t screenshotHandle, float flProgress);
+	EVRScreenshotError(OPENVR_FNTABLE_CALLTYPE *TakeStereoScreenshot)(ScreenshotHandle_t *pOutScreenshotHandle, char *pchPreviewFilename, char *pchVRFilename);
+	EVRScreenshotError(OPENVR_FNTABLE_CALLTYPE *SubmitScreenshot)(ScreenshotHandle_t screenshotHandle, EVRScreenshotType type, char *pchSourcePreviewFilename, char *pchSourceVRFilename);
+};
+
+struct VR_IVRResources_FnTable
+{
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *LoadSharedResource)(char *pchResourceName, char *pchBuffer, uint32_t unBufferLen);
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetResourceFullPath)(char *pchResourceName, char *pchResourceTypeDirectory, char *pchPathBuffer, uint32_t unBufferLen);
+};
+
+struct VR_IVRDriverManager_FnTable
+{
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetDriverCount)();
+	uint32_t(OPENVR_FNTABLE_CALLTYPE *GetDriverName)(DriverId_t nDriver, char *pchValue, uint32_t unBufferSize);
+};
+
+#if 0
+// Global entry points
+S_API intptr_t VR_InitInternal( EVRInitError *peError, EVRApplicationType eType );
+S_API void VR_ShutdownInternal();
+S_API bool VR_IsHmdPresent();
+S_API intptr_t VR_GetGenericInterface( const char *pchInterfaceVersion, EVRInitError *peError );
+S_API bool VR_IsRuntimeInstalled();
+S_API const char * VR_GetVRInitErrorAsSymbol( EVRInitError error );
+S_API const char * VR_GetVRInitErrorAsEnglishDescription( EVRInitError error );
+#endif
+
+#endif  // __OPENVR_API_FLAT_H__
diff --git a/engine/inc/bullet/ThirdPartyLibs/openvr/headers/openvr_driver.h b/engine/inc/bullet/ThirdPartyLibs/openvr/headers/openvr_driver.h
new file mode 100644
index 00000000..b07699f8
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/openvr/headers/openvr_driver.h
@@ -0,0 +1,2595 @@
+#pragma once
+
+// openvr_driver.h
+//========= Copyright Valve Corporation ============//
+// Dynamically generated file. Do not modify this file directly.
+
+#ifndef _OPENVR_DRIVER_API
+#define _OPENVR_DRIVER_API
+
+#include <stdint.h>
+
+// vrtypes.h
+#ifndef _INCLUDE_VRTYPES_H
+#define _INCLUDE_VRTYPES_H
+
+// Forward declarations to avoid requiring vulkan.h
+struct VkDevice_T;
+struct VkPhysicalDevice_T;
+struct VkInstance_T;
+struct VkQueue_T;
+
+// Forward declarations to avoid requiring d3d12.h
+struct ID3D12Resource;
+struct ID3D12CommandQueue;
+
+namespace vr
+{
+#pragma pack(push, 8)
+
+typedef void *glSharedTextureHandle_t;
+typedef int32_t glInt_t;
+typedef uint32_t glUInt_t;
+
+// right-handed system
+// +y is up
+// +x is to the right
+// -z is going away from you
+// Distance unit is  meters
+struct HmdMatrix34_t
+{
+	float m[3][4];
+};
+
+struct HmdMatrix44_t
+{
+	float m[4][4];
+};
+
+struct HmdVector3_t
+{
+	float v[3];
+};
+
+struct HmdVector4_t
+{
+	float v[4];
+};
+
+struct HmdVector3d_t
+{
+	double v[3];
+};
+
+struct HmdVector2_t
+{
+	float v[2];
+};
+
+struct HmdQuaternion_t
+{
+	double w, x, y, z;
+};
+
+struct HmdColor_t
+{
+	float r, g, b, a;
+};
+
+struct HmdQuad_t
+{
+	HmdVector3_t vCorners[4];
+};
+
+struct HmdRect2_t
+{
+	HmdVector2_t vTopLeft;
+	HmdVector2_t vBottomRight;
+};
+
+/** Used to return the post-distortion UVs for each color channel. 
+* UVs range from 0 to 1 with 0,0 in the upper left corner of the 
+* source render target. The 0,0 to 1,1 range covers a single eye. */
+struct DistortionCoordinates_t
+{
+	float rfRed[2];
+	float rfGreen[2];
+	float rfBlue[2];
+};
+
+enum EVREye
+{
+	Eye_Left = 0,
+	Eye_Right = 1
+};
+
+enum ETextureType
+{
+	TextureType_DirectX = 0,    // Handle is an ID3D11Texture
+	TextureType_OpenGL = 1,     // Handle is an OpenGL texture name or an OpenGL render buffer name, depending on submit flags
+	TextureType_Vulkan = 2,     // Handle is a pointer to a VRVulkanTextureData_t structure
+	TextureType_IOSurface = 3,  // Handle is a macOS cross-process-sharable IOSurfaceRef
+	TextureType_DirectX12 = 4,  // Handle is a pointer to a D3D12TextureData_t structure
+};
+
+enum EColorSpace
+{
+	ColorSpace_Auto = 0,    // Assumes 'gamma' for 8-bit per component formats, otherwise 'linear'.  This mirrors the DXGI formats which have _SRGB variants.
+	ColorSpace_Gamma = 1,   // Texture data can be displayed directly on the display without any conversion (a.k.a. display native format).
+	ColorSpace_Linear = 2,  // Same as gamma but has been converted to a linear representation using DXGI's sRGB conversion algorithm.
+};
+
+struct Texture_t
+{
+	void *handle;  // See ETextureType definition above
+	ETextureType eType;
+	EColorSpace eColorSpace;
+};
+
+// Handle to a shared texture (HANDLE on Windows obtained using OpenSharedResource).
+typedef uint64_t SharedTextureHandle_t;
+#define INVALID_SHARED_TEXTURE_HANDLE ((vr::SharedTextureHandle_t)0)
+
+enum ETrackingResult
+{
+	TrackingResult_Uninitialized = 1,
+
+	TrackingResult_Calibrating_InProgress = 100,
+	TrackingResult_Calibrating_OutOfRange = 101,
+
+	TrackingResult_Running_OK = 200,
+	TrackingResult_Running_OutOfRange = 201,
+};
+
+typedef uint32_t DriverId_t;
+static const uint32_t k_nDriverNone = 0xFFFFFFFF;
+
+static const uint32_t k_unMaxDriverDebugResponseSize = 32768;
+
+/** Used to pass device IDs to API calls */
+typedef uint32_t TrackedDeviceIndex_t;
+static const uint32_t k_unTrackedDeviceIndex_Hmd = 0;
+static const uint32_t k_unMaxTrackedDeviceCount = 16;
+static const uint32_t k_unTrackedDeviceIndexOther = 0xFFFFFFFE;
+static const uint32_t k_unTrackedDeviceIndexInvalid = 0xFFFFFFFF;
+
+/** Describes what kind of object is being tracked at a given ID */
+enum ETrackedDeviceClass
+{
+	TrackedDeviceClass_Invalid = 0,            // the ID was not valid.
+	TrackedDeviceClass_HMD = 1,                // Head-Mounted Displays
+	TrackedDeviceClass_Controller = 2,         // Tracked controllers
+	TrackedDeviceClass_GenericTracker = 3,     // Generic trackers, similar to controllers
+	TrackedDeviceClass_TrackingReference = 4,  // Camera and base stations that serve as tracking reference points
+	TrackedDeviceClass_DisplayRedirect = 5,    // Accessories that aren't necessarily tracked themselves, but may redirect video output from other tracked devices
+};
+
+/** Describes what specific role associated with a tracked device */
+enum ETrackedControllerRole
+{
+	TrackedControllerRole_Invalid = 0,    // Invalid value for controller type
+	TrackedControllerRole_LeftHand = 1,   // Tracked device associated with the left hand
+	TrackedControllerRole_RightHand = 2,  // Tracked device associated with the right hand
+};
+
+/** describes a single pose for a tracked object */
+struct TrackedDevicePose_t
+{
+	HmdMatrix34_t mDeviceToAbsoluteTracking;
+	HmdVector3_t vVelocity;         // velocity in tracker space in m/s
+	HmdVector3_t vAngularVelocity;  // angular velocity in radians/s (?)
+	ETrackingResult eTrackingResult;
+	bool bPoseIsValid;
+
+	// This indicates that there is a device connected for this spot in the pose array.
+	// It could go from true to false if the user unplugs the device.
+	bool bDeviceIsConnected;
+};
+
+/** Identifies which style of tracking origin the application wants to use
+* for the poses it is requesting */
+enum ETrackingUniverseOrigin
+{
+	TrackingUniverseSeated = 0,              // Poses are provided relative to the seated zero pose
+	TrackingUniverseStanding = 1,            // Poses are provided relative to the safe bounds configured by the user
+	TrackingUniverseRawAndUncalibrated = 2,  // Poses are provided in the coordinate system defined by the driver.  It has Y up and is unified for devices of the same driver. You usually don't want this one.
+};
+
+// Refers to a single container of properties
+typedef uint64_t PropertyContainerHandle_t;
+typedef uint32_t PropertyTypeTag_t;
+
+static const PropertyContainerHandle_t k_ulInvalidPropertyContainer = 0;
+static const PropertyTypeTag_t k_unInvalidPropertyTag = 0;
+
+// Use these tags to set/get common types as struct properties
+static const PropertyTypeTag_t k_unFloatPropertyTag = 1;
+static const PropertyTypeTag_t k_unInt32PropertyTag = 2;
+static const PropertyTypeTag_t k_unUint64PropertyTag = 3;
+static const PropertyTypeTag_t k_unBoolPropertyTag = 4;
+static const PropertyTypeTag_t k_unStringPropertyTag = 5;
+
+static const PropertyTypeTag_t k_unHmdMatrix34PropertyTag = 20;
+static const PropertyTypeTag_t k_unHmdMatrix44PropertyTag = 21;
+static const PropertyTypeTag_t k_unHmdVector3PropertyTag = 22;
+static const PropertyTypeTag_t k_unHmdVector4PropertyTag = 23;
+
+static const PropertyTypeTag_t k_unHiddenAreaPropertyTag = 30;
+
+static const PropertyTypeTag_t k_unOpenVRInternalReserved_Start = 1000;
+static const PropertyTypeTag_t k_unOpenVRInternalReserved_End = 10000;
+
+/** Each entry in this enum represents a property that can be retrieved about a
+* tracked device. Many fields are only valid for one ETrackedDeviceClass. */
+enum ETrackedDeviceProperty
+{
+	Prop_Invalid = 0,
+
+	// general properties that apply to all device classes
+	Prop_TrackingSystemName_String = 1000,
+	Prop_ModelNumber_String = 1001,
+	Prop_SerialNumber_String = 1002,
+	Prop_RenderModelName_String = 1003,
+	Prop_WillDriftInYaw_Bool = 1004,
+	Prop_ManufacturerName_String = 1005,
+	Prop_TrackingFirmwareVersion_String = 1006,
+	Prop_HardwareRevision_String = 1007,
+	Prop_AllWirelessDongleDescriptions_String = 1008,
+	Prop_ConnectedWirelessDongle_String = 1009,
+	Prop_DeviceIsWireless_Bool = 1010,
+	Prop_DeviceIsCharging_Bool = 1011,
+	Prop_DeviceBatteryPercentage_Float = 1012,  // 0 is empty, 1 is full
+	Prop_StatusDisplayTransform_Matrix34 = 1013,
+	Prop_Firmware_UpdateAvailable_Bool = 1014,
+	Prop_Firmware_ManualUpdate_Bool = 1015,
+	Prop_Firmware_ManualUpdateURL_String = 1016,
+	Prop_HardwareRevision_Uint64 = 1017,
+	Prop_FirmwareVersion_Uint64 = 1018,
+	Prop_FPGAVersion_Uint64 = 1019,
+	Prop_VRCVersion_Uint64 = 1020,
+	Prop_RadioVersion_Uint64 = 1021,
+	Prop_DongleVersion_Uint64 = 1022,
+	Prop_BlockServerShutdown_Bool = 1023,
+	Prop_CanUnifyCoordinateSystemWithHmd_Bool = 1024,
+	Prop_ContainsProximitySensor_Bool = 1025,
+	Prop_DeviceProvidesBatteryStatus_Bool = 1026,
+	Prop_DeviceCanPowerOff_Bool = 1027,
+	Prop_Firmware_ProgrammingTarget_String = 1028,
+	Prop_DeviceClass_Int32 = 1029,
+	Prop_HasCamera_Bool = 1030,
+	Prop_DriverVersion_String = 1031,
+	Prop_Firmware_ForceUpdateRequired_Bool = 1032,
+	Prop_ViveSystemButtonFixRequired_Bool = 1033,
+	Prop_ParentDriver_Uint64 = 1034,
+	Prop_ResourceRoot_String = 1035,
+
+	// Properties that are unique to TrackedDeviceClass_HMD
+	Prop_ReportsTimeSinceVSync_Bool = 2000,
+	Prop_SecondsFromVsyncToPhotons_Float = 2001,
+	Prop_DisplayFrequency_Float = 2002,
+	Prop_UserIpdMeters_Float = 2003,
+	Prop_CurrentUniverseId_Uint64 = 2004,
+	Prop_PreviousUniverseId_Uint64 = 2005,
+	Prop_DisplayFirmwareVersion_Uint64 = 2006,
+	Prop_IsOnDesktop_Bool = 2007,
+	Prop_DisplayMCType_Int32 = 2008,
+	Prop_DisplayMCOffset_Float = 2009,
+	Prop_DisplayMCScale_Float = 2010,
+	Prop_EdidVendorID_Int32 = 2011,
+	Prop_DisplayMCImageLeft_String = 2012,
+	Prop_DisplayMCImageRight_String = 2013,
+	Prop_DisplayGCBlackClamp_Float = 2014,
+	Prop_EdidProductID_Int32 = 2015,
+	Prop_CameraToHeadTransform_Matrix34 = 2016,
+	Prop_DisplayGCType_Int32 = 2017,
+	Prop_DisplayGCOffset_Float = 2018,
+	Prop_DisplayGCScale_Float = 2019,
+	Prop_DisplayGCPrescale_Float = 2020,
+	Prop_DisplayGCImage_String = 2021,
+	Prop_LensCenterLeftU_Float = 2022,
+	Prop_LensCenterLeftV_Float = 2023,
+	Prop_LensCenterRightU_Float = 2024,
+	Prop_LensCenterRightV_Float = 2025,
+	Prop_UserHeadToEyeDepthMeters_Float = 2026,
+	Prop_CameraFirmwareVersion_Uint64 = 2027,
+	Prop_CameraFirmwareDescription_String = 2028,
+	Prop_DisplayFPGAVersion_Uint64 = 2029,
+	Prop_DisplayBootloaderVersion_Uint64 = 2030,
+	Prop_DisplayHardwareVersion_Uint64 = 2031,
+	Prop_AudioFirmwareVersion_Uint64 = 2032,
+	Prop_CameraCompatibilityMode_Int32 = 2033,
+	Prop_ScreenshotHorizontalFieldOfViewDegrees_Float = 2034,
+	Prop_ScreenshotVerticalFieldOfViewDegrees_Float = 2035,
+	Prop_DisplaySuppressed_Bool = 2036,
+	Prop_DisplayAllowNightMode_Bool = 2037,
+	Prop_DisplayMCImageWidth_Int32 = 2038,
+	Prop_DisplayMCImageHeight_Int32 = 2039,
+	Prop_DisplayMCImageNumChannels_Int32 = 2040,
+	Prop_DisplayMCImageData_Binary = 2041,
+	Prop_SecondsFromPhotonsToVblank_Float = 2042,
+	Prop_DriverDirectModeSendsVsyncEvents_Bool = 2043,
+	Prop_DisplayDebugMode_Bool = 2044,
+	Prop_GraphicsAdapterLuid_Uint64 = 2045,
+	Prop_DriverProvidedChaperonePath_String = 2048,
+
+	// Properties that are unique to TrackedDeviceClass_Controller
+	Prop_AttachedDeviceId_String = 3000,
+	Prop_SupportedButtons_Uint64 = 3001,
+	Prop_Axis0Type_Int32 = 3002,           // Return value is of type EVRControllerAxisType
+	Prop_Axis1Type_Int32 = 3003,           // Return value is of type EVRControllerAxisType
+	Prop_Axis2Type_Int32 = 3004,           // Return value is of type EVRControllerAxisType
+	Prop_Axis3Type_Int32 = 3005,           // Return value is of type EVRControllerAxisType
+	Prop_Axis4Type_Int32 = 3006,           // Return value is of type EVRControllerAxisType
+	Prop_ControllerRoleHint_Int32 = 3007,  // Return value is of type ETrackedControllerRole
+
+	// Properties that are unique to TrackedDeviceClass_TrackingReference
+	Prop_FieldOfViewLeftDegrees_Float = 4000,
+	Prop_FieldOfViewRightDegrees_Float = 4001,
+	Prop_FieldOfViewTopDegrees_Float = 4002,
+	Prop_FieldOfViewBottomDegrees_Float = 4003,
+	Prop_TrackingRangeMinimumMeters_Float = 4004,
+	Prop_TrackingRangeMaximumMeters_Float = 4005,
+	Prop_ModeLabel_String = 4006,
+
+	// Properties that are used for user interface like icons names
+	Prop_IconPathName_String = 5000,                       // DEPRECATED. Value not referenced. Now expected to be part of icon path properties.
+	Prop_NamedIconPathDeviceOff_String = 5001,             // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceSearching_String = 5002,       // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceSearchingAlert_String = 5003,  // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceReady_String = 5004,           // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceReadyAlert_String = 5005,      // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceNotReady_String = 5006,        // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceStandby_String = 5007,         // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceAlertLow_String = 5008,        // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+
+	// Properties that are used by helpers, but are opaque to applications
+	Prop_DisplayHiddenArea_Binary_Start = 5100,
+	Prop_DisplayHiddenArea_Binary_End = 5150,
+
+	// Properties that are unique to drivers
+	Prop_UserConfigPath_String = 6000,
+	Prop_InstallPath_String = 6001,
+	Prop_HasDisplayComponent_Bool = 6002,
+	Prop_HasControllerComponent_Bool = 6003,
+	Prop_HasCameraComponent_Bool = 6004,
+	Prop_HasDriverDirectModeComponent_Bool = 6005,
+	Prop_HasVirtualDisplayComponent_Bool = 6006,
+
+	// Vendors are free to expose private debug data in this reserved region
+	Prop_VendorSpecific_Reserved_Start = 10000,
+	Prop_VendorSpecific_Reserved_End = 10999,
+};
+
+/** No string property will ever be longer than this length */
+static const uint32_t k_unMaxPropertyStringSize = 32 * 1024;
+
+/** Used to return errors that occur when reading properties. */
+enum ETrackedPropertyError
+{
+	TrackedProp_Success = 0,
+	TrackedProp_WrongDataType = 1,
+	TrackedProp_WrongDeviceClass = 2,
+	TrackedProp_BufferTooSmall = 3,
+	TrackedProp_UnknownProperty = 4,  // Driver has not set the property (and may not ever).
+	TrackedProp_InvalidDevice = 5,
+	TrackedProp_CouldNotContactServer = 6,
+	TrackedProp_ValueNotProvidedByDevice = 7,
+	TrackedProp_StringExceedsMaximumLength = 8,
+	TrackedProp_NotYetAvailable = 9,  // The property value isn't known yet, but is expected soon. Call again later.
+	TrackedProp_PermissionDenied = 10,
+	TrackedProp_InvalidOperation = 11,
+};
+
+/** Allows the application to control what part of the provided texture will be used in the
+* frame buffer. */
+struct VRTextureBounds_t
+{
+	float uMin, vMin;
+	float uMax, vMax;
+};
+
+/** Allows specifying pose used to render provided scene texture (if different from value returned by WaitGetPoses). */
+struct VRTextureWithPose_t : public Texture_t
+{
+	HmdMatrix34_t mDeviceToAbsoluteTracking;  // Actual pose used to render scene textures.
+};
+
+/** Allows the application to control how scene textures are used by the compositor when calling Submit. */
+enum EVRSubmitFlags
+{
+	// Simple render path. App submits rendered left and right eye images with no lens distortion correction applied.
+	Submit_Default = 0x00,
+
+	// App submits final left and right eye images with lens distortion already applied (lens distortion makes the images appear
+	// barrel distorted with chromatic aberration correction applied). The app would have used the data returned by
+	// vr::IVRSystem::ComputeDistortion() to apply the correct distortion to the rendered images before calling Submit().
+	Submit_LensDistortionAlreadyApplied = 0x01,
+
+	// If the texture pointer passed in is actually a renderbuffer (e.g. for MSAA in OpenGL) then set this flag.
+	Submit_GlRenderBuffer = 0x02,
+
+	// Do not use
+	Submit_Reserved = 0x04,
+
+	// Set to indicate that pTexture is a pointer to a VRTextureWithPose_t.
+	Submit_TextureWithPose = 0x08,
+};
+
+/** Data required for passing Vulkan textures to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. */
+struct VRVulkanTextureData_t
+{
+	uint64_t m_nImage;  // VkImage
+	VkDevice_T *m_pDevice;
+	VkPhysicalDevice_T *m_pPhysicalDevice;
+	VkInstance_T *m_pInstance;
+	VkQueue_T *m_pQueue;
+	uint32_t m_nQueueFamilyIndex;
+	uint32_t m_nWidth, m_nHeight, m_nFormat, m_nSampleCount;
+};
+
+/** Data required for passing D3D12 textures to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. */
+struct D3D12TextureData_t
+{
+	ID3D12Resource *m_pResource;
+	ID3D12CommandQueue *m_pCommandQueue;
+	uint32_t m_nNodeMask;
+};
+
+/** Status of the overall system or tracked objects */
+enum EVRState
+{
+	VRState_Undefined = -1,
+	VRState_Off = 0,
+	VRState_Searching = 1,
+	VRState_Searching_Alert = 2,
+	VRState_Ready = 3,
+	VRState_Ready_Alert = 4,
+	VRState_NotReady = 5,
+	VRState_Standby = 6,
+	VRState_Ready_Alert_Low = 7,
+};
+
+/** The types of events that could be posted (and what the parameters mean for each event type) */
+enum EVREventType
+{
+	VREvent_None = 0,
+
+	VREvent_TrackedDeviceActivated = 100,
+	VREvent_TrackedDeviceDeactivated = 101,
+	VREvent_TrackedDeviceUpdated = 102,
+	VREvent_TrackedDeviceUserInteractionStarted = 103,
+	VREvent_TrackedDeviceUserInteractionEnded = 104,
+	VREvent_IpdChanged = 105,
+	VREvent_EnterStandbyMode = 106,
+	VREvent_LeaveStandbyMode = 107,
+	VREvent_TrackedDeviceRoleChanged = 108,
+	VREvent_WatchdogWakeUpRequested = 109,
+	VREvent_LensDistortionChanged = 110,
+	VREvent_PropertyChanged = 111,
+	VREvent_WirelessDisconnect = 112,
+	VREvent_WirelessReconnect = 113,
+
+	VREvent_ButtonPress = 200,    // data is controller
+	VREvent_ButtonUnpress = 201,  // data is controller
+	VREvent_ButtonTouch = 202,    // data is controller
+	VREvent_ButtonUntouch = 203,  // data is controller
+
+	VREvent_MouseMove = 300,            // data is mouse
+	VREvent_MouseButtonDown = 301,      // data is mouse
+	VREvent_MouseButtonUp = 302,        // data is mouse
+	VREvent_FocusEnter = 303,           // data is overlay
+	VREvent_FocusLeave = 304,           // data is overlay
+	VREvent_Scroll = 305,               // data is mouse
+	VREvent_TouchPadMove = 306,         // data is mouse
+	VREvent_OverlayFocusChanged = 307,  // data is overlay, global event
+
+	VREvent_InputFocusCaptured = 400,                         // data is process DEPRECATED
+	VREvent_InputFocusReleased = 401,                         // data is process DEPRECATED
+	VREvent_SceneFocusLost = 402,                             // data is process
+	VREvent_SceneFocusGained = 403,                           // data is process
+	VREvent_SceneApplicationChanged = 404,                    // data is process - The App actually drawing the scene changed (usually to or from the compositor)
+	VREvent_SceneFocusChanged = 405,                          // data is process - New app got access to draw the scene
+	VREvent_InputFocusChanged = 406,                          // data is process
+	VREvent_SceneApplicationSecondaryRenderingStarted = 407,  // data is process
+
+	VREvent_HideRenderModels = 410,  // Sent to the scene application to request hiding render models temporarily
+	VREvent_ShowRenderModels = 411,  // Sent to the scene application to request restoring render model visibility
+
+	VREvent_OverlayShown = 500,
+	VREvent_OverlayHidden = 501,
+	VREvent_DashboardActivated = 502,
+	VREvent_DashboardDeactivated = 503,
+	VREvent_DashboardThumbSelected = 504,     // Sent to the overlay manager - data is overlay
+	VREvent_DashboardRequested = 505,         // Sent to the overlay manager - data is overlay
+	VREvent_ResetDashboard = 506,             // Send to the overlay manager
+	VREvent_RenderToast = 507,                // Send to the dashboard to render a toast - data is the notification ID
+	VREvent_ImageLoaded = 508,                // Sent to overlays when a SetOverlayRaw or SetOverlayFromFile call finishes loading
+	VREvent_ShowKeyboard = 509,               // Sent to keyboard renderer in the dashboard to invoke it
+	VREvent_HideKeyboard = 510,               // Sent to keyboard renderer in the dashboard to hide it
+	VREvent_OverlayGamepadFocusGained = 511,  // Sent to an overlay when IVROverlay::SetFocusOverlay is called on it
+	VREvent_OverlayGamepadFocusLost = 512,    // Send to an overlay when it previously had focus and IVROverlay::SetFocusOverlay is called on something else
+	VREvent_OverlaySharedTextureChanged = 513,
+	VREvent_DashboardGuideButtonDown = 514,
+	VREvent_DashboardGuideButtonUp = 515,
+	VREvent_ScreenshotTriggered = 516,  // Screenshot button combo was pressed, Dashboard should request a screenshot
+	VREvent_ImageFailed = 517,          // Sent to overlays when a SetOverlayRaw or SetOverlayfromFail fails to load
+	VREvent_DashboardOverlayCreated = 518,
+
+	// Screenshot API
+	VREvent_RequestScreenshot = 520,              // Sent by vrclient application to compositor to take a screenshot
+	VREvent_ScreenshotTaken = 521,                // Sent by compositor to the application that the screenshot has been taken
+	VREvent_ScreenshotFailed = 522,               // Sent by compositor to the application that the screenshot failed to be taken
+	VREvent_SubmitScreenshotToDashboard = 523,    // Sent by compositor to the dashboard that a completed screenshot was submitted
+	VREvent_ScreenshotProgressToDashboard = 524,  // Sent by compositor to the dashboard that a completed screenshot was submitted
+
+	VREvent_PrimaryDashboardDeviceChanged = 525,
+
+	VREvent_Notification_Shown = 600,
+	VREvent_Notification_Hidden = 601,
+	VREvent_Notification_BeginInteraction = 602,
+	VREvent_Notification_Destroyed = 603,
+
+	VREvent_Quit = 700,                    // data is process
+	VREvent_ProcessQuit = 701,             // data is process
+	VREvent_QuitAborted_UserPrompt = 702,  // data is process
+	VREvent_QuitAcknowledged = 703,        // data is process
+	VREvent_DriverRequestedQuit = 704,     // The driver has requested that SteamVR shut down
+
+	VREvent_ChaperoneDataHasChanged = 800,
+	VREvent_ChaperoneUniverseHasChanged = 801,
+	VREvent_ChaperoneTempDataHasChanged = 802,
+	VREvent_ChaperoneSettingsHaveChanged = 803,
+	VREvent_SeatedZeroPoseReset = 804,
+
+	VREvent_AudioSettingsHaveChanged = 820,
+
+	VREvent_BackgroundSettingHasChanged = 850,
+	VREvent_CameraSettingsHaveChanged = 851,
+	VREvent_ReprojectionSettingHasChanged = 852,
+	VREvent_ModelSkinSettingsHaveChanged = 853,
+	VREvent_EnvironmentSettingsHaveChanged = 854,
+	VREvent_PowerSettingsHaveChanged = 855,
+	VREvent_EnableHomeAppSettingsHaveChanged = 856,
+
+	VREvent_StatusUpdate = 900,
+
+	VREvent_MCImageUpdated = 1000,
+
+	VREvent_FirmwareUpdateStarted = 1100,
+	VREvent_FirmwareUpdateFinished = 1101,
+
+	VREvent_KeyboardClosed = 1200,
+	VREvent_KeyboardCharInput = 1201,
+	VREvent_KeyboardDone = 1202,  // Sent when DONE button clicked on keyboard
+
+	VREvent_ApplicationTransitionStarted = 1300,
+	VREvent_ApplicationTransitionAborted = 1301,
+	VREvent_ApplicationTransitionNewAppStarted = 1302,
+	VREvent_ApplicationListUpdated = 1303,
+	VREvent_ApplicationMimeTypeLoad = 1304,
+	VREvent_ApplicationTransitionNewAppLaunchComplete = 1305,
+	VREvent_ProcessConnected = 1306,
+	VREvent_ProcessDisconnected = 1307,
+
+	VREvent_Compositor_MirrorWindowShown = 1400,
+	VREvent_Compositor_MirrorWindowHidden = 1401,
+	VREvent_Compositor_ChaperoneBoundsShown = 1410,
+	VREvent_Compositor_ChaperoneBoundsHidden = 1411,
+
+	VREvent_TrackedCamera_StartVideoStream = 1500,
+	VREvent_TrackedCamera_StopVideoStream = 1501,
+	VREvent_TrackedCamera_PauseVideoStream = 1502,
+	VREvent_TrackedCamera_ResumeVideoStream = 1503,
+	VREvent_TrackedCamera_EditingSurface = 1550,
+
+	VREvent_PerformanceTest_EnableCapture = 1600,
+	VREvent_PerformanceTest_DisableCapture = 1601,
+	VREvent_PerformanceTest_FidelityLevel = 1602,
+
+	VREvent_MessageOverlay_Closed = 1650,
+	VREvent_MessageOverlayCloseRequested = 1651,
+
+	// Vendors are free to expose private events in this reserved region
+	VREvent_VendorSpecific_Reserved_Start = 10000,
+	VREvent_VendorSpecific_Reserved_End = 19999,
+};
+
+/** Level of Hmd activity */
+// UserInteraction_Timeout means the device is in the process of timing out.
+// InUse = ( k_EDeviceActivityLevel_UserInteraction || k_EDeviceActivityLevel_UserInteraction_Timeout )
+// VREvent_TrackedDeviceUserInteractionStarted fires when the devices transitions from Standby -> UserInteraction or Idle -> UserInteraction.
+// VREvent_TrackedDeviceUserInteractionEnded fires when the devices transitions from UserInteraction_Timeout -> Idle
+enum EDeviceActivityLevel
+{
+	k_EDeviceActivityLevel_Unknown = -1,
+	k_EDeviceActivityLevel_Idle = 0,                     // No activity for the last 10 seconds
+	k_EDeviceActivityLevel_UserInteraction = 1,          // Activity (movement or prox sensor) is happening now
+	k_EDeviceActivityLevel_UserInteraction_Timeout = 2,  // No activity for the last 0.5 seconds
+	k_EDeviceActivityLevel_Standby = 3,                  // Idle for at least 5 seconds (configurable in Settings -> Power Management)
+};
+
+/** VR controller button and axis IDs */
+enum EVRButtonId
+{
+	k_EButton_System = 0,
+	k_EButton_ApplicationMenu = 1,
+	k_EButton_Grip = 2,
+	k_EButton_DPad_Left = 3,
+	k_EButton_DPad_Up = 4,
+	k_EButton_DPad_Right = 5,
+	k_EButton_DPad_Down = 6,
+	k_EButton_A = 7,
+
+	k_EButton_ProximitySensor = 31,
+
+	k_EButton_Axis0 = 32,
+	k_EButton_Axis1 = 33,
+	k_EButton_Axis2 = 34,
+	k_EButton_Axis3 = 35,
+	k_EButton_Axis4 = 36,
+
+	// aliases for well known controllers
+	k_EButton_SteamVR_Touchpad = k_EButton_Axis0,
+	k_EButton_SteamVR_Trigger = k_EButton_Axis1,
+
+	k_EButton_Dashboard_Back = k_EButton_Grip,
+
+	k_EButton_Max = 64
+};
+
+inline uint64_t ButtonMaskFromId(EVRButtonId id) { return 1ull << id; }
+
+/** used for controller button events */
+struct VREvent_Controller_t
+{
+	uint32_t button;  // EVRButtonId enum
+};
+
+/** used for simulated mouse events in overlay space */
+enum EVRMouseButton
+{
+	VRMouseButton_Left = 0x0001,
+	VRMouseButton_Right = 0x0002,
+	VRMouseButton_Middle = 0x0004,
+};
+
+/** used for simulated mouse events in overlay space */
+struct VREvent_Mouse_t
+{
+	float x, y;       // co-ords are in GL space, bottom left of the texture is 0,0
+	uint32_t button;  // EVRMouseButton enum
+};
+
+/** used for simulated mouse wheel scroll in overlay space */
+struct VREvent_Scroll_t
+{
+	float xdelta, ydelta;  // movement in fraction of the pad traversed since last delta, 1.0 for a full swipe
+	uint32_t repeatCount;
+};
+
+/** when in mouse input mode you can receive data from the touchpad, these events are only sent if the users finger
+   is on the touchpad (or just released from it) 
+**/
+struct VREvent_TouchPadMove_t
+{
+	// true if the users finger is detected on the touch pad
+	bool bFingerDown;
+
+	// How long the finger has been down in seconds
+	float flSecondsFingerDown;
+
+	// These values indicate the starting finger position (so you can do some basic swipe stuff)
+	float fValueXFirst;
+	float fValueYFirst;
+
+	// This is the raw sampled coordinate without deadzoning
+	float fValueXRaw;
+	float fValueYRaw;
+};
+
+/** notification related events. Details will still change at this point */
+struct VREvent_Notification_t
+{
+	uint64_t ulUserValue;
+	uint32_t notificationId;
+};
+
+/** Used for events about processes */
+struct VREvent_Process_t
+{
+	uint32_t pid;
+	uint32_t oldPid;
+	bool bForced;
+};
+
+/** Used for a few events about overlays */
+struct VREvent_Overlay_t
+{
+	uint64_t overlayHandle;
+};
+
+/** Used for a few events about overlays */
+struct VREvent_Status_t
+{
+	uint32_t statusState;  // EVRState enum
+};
+
+/** Used for keyboard events **/
+struct VREvent_Keyboard_t
+{
+	char cNewInput[8];    // Up to 11 bytes of new input
+	uint64_t uUserValue;  // Possible flags about the new input
+};
+
+struct VREvent_Ipd_t
+{
+	float ipdMeters;
+};
+
+struct VREvent_Chaperone_t
+{
+	uint64_t m_nPreviousUniverse;
+	uint64_t m_nCurrentUniverse;
+};
+
+/** Not actually used for any events */
+struct VREvent_Reserved_t
+{
+	uint64_t reserved0;
+	uint64_t reserved1;
+};
+
+struct VREvent_PerformanceTest_t
+{
+	uint32_t m_nFidelityLevel;
+};
+
+struct VREvent_SeatedZeroPoseReset_t
+{
+	bool bResetBySystemMenu;
+};
+
+struct VREvent_Screenshot_t
+{
+	uint32_t handle;
+	uint32_t type;
+};
+
+struct VREvent_ScreenshotProgress_t
+{
+	float progress;
+};
+
+struct VREvent_ApplicationLaunch_t
+{
+	uint32_t pid;
+	uint32_t unArgsHandle;
+};
+
+struct VREvent_EditingCameraSurface_t
+{
+	uint64_t overlayHandle;
+	uint32_t nVisualMode;
+};
+
+struct VREvent_MessageOverlay_t
+{
+	uint32_t unVRMessageOverlayResponse;  // vr::VRMessageOverlayResponse enum
+};
+
+struct VREvent_Property_t
+{
+	PropertyContainerHandle_t container;
+	ETrackedDeviceProperty prop;
+};
+
+/** NOTE!!! If you change this you MUST manually update openvr_interop.cs.py */
+typedef union {
+	VREvent_Reserved_t reserved;
+	VREvent_Controller_t controller;
+	VREvent_Mouse_t mouse;
+	VREvent_Scroll_t scroll;
+	VREvent_Process_t process;
+	VREvent_Notification_t notification;
+	VREvent_Overlay_t overlay;
+	VREvent_Status_t status;
+	VREvent_Keyboard_t keyboard;
+	VREvent_Ipd_t ipd;
+	VREvent_Chaperone_t chaperone;
+	VREvent_PerformanceTest_t performanceTest;
+	VREvent_TouchPadMove_t touchPadMove;
+	VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset;
+	VREvent_Screenshot_t screenshot;
+	VREvent_ScreenshotProgress_t screenshotProgress;
+	VREvent_ApplicationLaunch_t applicationLaunch;
+	VREvent_EditingCameraSurface_t cameraSurface;
+	VREvent_MessageOverlay_t messageOverlay;
+	VREvent_Property_t property;
+} VREvent_Data_t;
+
+#if defined(__linux__) || defined(__APPLE__)
+// This structure was originally defined mis-packed on Linux, preserved for
+// compatibility.
+#pragma pack(push, 4)
+#endif
+
+/** An event posted by the server to all running applications */
+struct VREvent_t
+{
+	uint32_t eventType;  // EVREventType enum
+	TrackedDeviceIndex_t trackedDeviceIndex;
+	float eventAgeSeconds;
+	// event data must be the end of the struct as its size is variable
+	VREvent_Data_t data;
+};
+
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+
+/** The mesh to draw into the stencil (or depth) buffer to perform 
+* early stencil (or depth) kills of pixels that will never appear on the HMD.
+* This mesh draws on all the pixels that will be hidden after distortion. 
+*
+* If the HMD does not provide a visible area mesh pVertexData will be
+* NULL and unTriangleCount will be 0. */
+struct HiddenAreaMesh_t
+{
+	const HmdVector2_t *pVertexData;
+	uint32_t unTriangleCount;
+};
+
+enum EHiddenAreaMeshType
+{
+	k_eHiddenAreaMesh_Standard = 0,
+	k_eHiddenAreaMesh_Inverse = 1,
+	k_eHiddenAreaMesh_LineLoop = 2,
+
+	k_eHiddenAreaMesh_Max = 3,
+};
+
+/** Identifies what kind of axis is on the controller at index n. Read this type 
+* with pVRSystem->Get( nControllerDeviceIndex, Prop_Axis0Type_Int32 + n );
+*/
+enum EVRControllerAxisType
+{
+	k_eControllerAxis_None = 0,
+	k_eControllerAxis_TrackPad = 1,
+	k_eControllerAxis_Joystick = 2,
+	k_eControllerAxis_Trigger = 3,  // Analog trigger data is in the X axis
+};
+
+/** contains information about one axis on the controller */
+struct VRControllerAxis_t
+{
+	float x;  // Ranges from -1.0 to 1.0 for joysticks and track pads. Ranges from 0.0 to 1.0 for triggers were 0 is fully released.
+	float y;  // Ranges from -1.0 to 1.0 for joysticks and track pads. Is always 0.0 for triggers.
+};
+
+/** the number of axes in the controller state */
+static const uint32_t k_unControllerStateAxisCount = 5;
+
+#if defined(__linux__) || defined(__APPLE__)
+// This structure was originally defined mis-packed on Linux, preserved for
+// compatibility.
+#pragma pack(push, 4)
+#endif
+
+/** Holds all the state of a controller at one moment in time. */
+struct VRControllerState001_t
+{
+	// If packet num matches that on your prior call, then the controller state hasn't been changed since
+	// your last call and there is no need to process it
+	uint32_t unPacketNum;
+
+	// bit flags for each of the buttons. Use ButtonMaskFromId to turn an ID into a mask
+	uint64_t ulButtonPressed;
+	uint64_t ulButtonTouched;
+
+	// Axis data for the controller's analog inputs
+	VRControllerAxis_t rAxis[k_unControllerStateAxisCount];
+};
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack(pop)
+#endif
+
+typedef VRControllerState001_t VRControllerState_t;
+
+/** determines how to provide output to the application of various event processing functions. */
+enum EVRControllerEventOutputType
+{
+	ControllerEventOutput_OSEvents = 0,
+	ControllerEventOutput_VREvents = 1,
+};
+
+/** Collision Bounds Style */
+enum ECollisionBoundsStyle
+{
+	COLLISION_BOUNDS_STYLE_BEGINNER = 0,
+	COLLISION_BOUNDS_STYLE_INTERMEDIATE,
+	COLLISION_BOUNDS_STYLE_SQUARES,
+	COLLISION_BOUNDS_STYLE_ADVANCED,
+	COLLISION_BOUNDS_STYLE_NONE,
+
+	COLLISION_BOUNDS_STYLE_COUNT
+};
+
+/** Allows the application to customize how the overlay appears in the compositor */
+struct Compositor_OverlaySettings
+{
+	uint32_t size;  // sizeof(Compositor_OverlaySettings)
+	bool curved, antialias;
+	float scale, distance, alpha;
+	float uOffset, vOffset, uScale, vScale;
+	float gridDivs, gridWidth, gridScale;
+	HmdMatrix44_t transform;
+};
+
+/** used to refer to a single VR overlay */
+typedef uint64_t VROverlayHandle_t;
+
+static const VROverlayHandle_t k_ulOverlayHandleInvalid = 0;
+
+/** Errors that can occur around VR overlays */
+enum EVROverlayError
+{
+	VROverlayError_None = 0,
+
+	VROverlayError_UnknownOverlay = 10,
+	VROverlayError_InvalidHandle = 11,
+	VROverlayError_PermissionDenied = 12,
+	VROverlayError_OverlayLimitExceeded = 13,  // No more overlays could be created because the maximum number already exist
+	VROverlayError_WrongVisibilityType = 14,
+	VROverlayError_KeyTooLong = 15,
+	VROverlayError_NameTooLong = 16,
+	VROverlayError_KeyInUse = 17,
+	VROverlayError_WrongTransformType = 18,
+	VROverlayError_InvalidTrackedDevice = 19,
+	VROverlayError_InvalidParameter = 20,
+	VROverlayError_ThumbnailCantBeDestroyed = 21,
+	VROverlayError_ArrayTooSmall = 22,
+	VROverlayError_RequestFailed = 23,
+	VROverlayError_InvalidTexture = 24,
+	VROverlayError_UnableToLoadFile = 25,
+	VROverlayError_KeyboardAlreadyInUse = 26,
+	VROverlayError_NoNeighbor = 27,
+	VROverlayError_TooManyMaskPrimitives = 29,
+	VROverlayError_BadMaskPrimitive = 30,
+};
+
+/** enum values to pass in to VR_Init to identify whether the application will 
+* draw a 3D scene. */
+enum EVRApplicationType
+{
+	VRApplication_Other = 0,          // Some other kind of application that isn't covered by the other entries
+	VRApplication_Scene = 1,          // Application will submit 3D frames
+	VRApplication_Overlay = 2,        // Application only interacts with overlays
+	VRApplication_Background = 3,     // Application should not start SteamVR if it's not already running, and should not
+									  // keep it running if everything else quits.
+	VRApplication_Utility = 4,        // Init should not try to load any drivers. The application needs access to utility
+									  // interfaces (like IVRSettings and IVRApplications) but not hardware.
+	VRApplication_VRMonitor = 5,      // Reserved for vrmonitor
+	VRApplication_SteamWatchdog = 6,  // Reserved for Steam
+	VRApplication_Bootstrapper = 7,   // Start up SteamVR
+
+	VRApplication_Max
+};
+
+/** error codes for firmware */
+enum EVRFirmwareError
+{
+	VRFirmwareError_None = 0,
+	VRFirmwareError_Success = 1,
+	VRFirmwareError_Fail = 2,
+};
+
+/** error codes for notifications */
+enum EVRNotificationError
+{
+	VRNotificationError_OK = 0,
+	VRNotificationError_InvalidNotificationId = 100,
+	VRNotificationError_NotificationQueueFull = 101,
+	VRNotificationError_InvalidOverlayHandle = 102,
+	VRNotificationError_SystemWithUserValueAlreadyExists = 103,
+};
+
+/** error codes returned by Vr_Init */
+
+// Please add adequate error description to https://developer.valvesoftware.com/w/index.php?title=Category:SteamVRHelp
+enum EVRInitError
+{
+	VRInitError_None = 0,
+	VRInitError_Unknown = 1,
+
+	VRInitError_Init_InstallationNotFound = 100,
+	VRInitError_Init_InstallationCorrupt = 101,
+	VRInitError_Init_VRClientDLLNotFound = 102,
+	VRInitError_Init_FileNotFound = 103,
+	VRInitError_Init_FactoryNotFound = 104,
+	VRInitError_Init_InterfaceNotFound = 105,
+	VRInitError_Init_InvalidInterface = 106,
+	VRInitError_Init_UserConfigDirectoryInvalid = 107,
+	VRInitError_Init_HmdNotFound = 108,
+	VRInitError_Init_NotInitialized = 109,
+	VRInitError_Init_PathRegistryNotFound = 110,
+	VRInitError_Init_NoConfigPath = 111,
+	VRInitError_Init_NoLogPath = 112,
+	VRInitError_Init_PathRegistryNotWritable = 113,
+	VRInitError_Init_AppInfoInitFailed = 114,
+	VRInitError_Init_Retry = 115,               // Used internally to cause retries to vrserver
+	VRInitError_Init_InitCanceledByUser = 116,  // The calling application should silently exit. The user canceled app startup
+	VRInitError_Init_AnotherAppLaunching = 117,
+	VRInitError_Init_SettingsInitFailed = 118,
+	VRInitError_Init_ShuttingDown = 119,
+	VRInitError_Init_TooManyObjects = 120,
+	VRInitError_Init_NoServerForBackgroundApp = 121,
+	VRInitError_Init_NotSupportedWithCompositor = 122,
+	VRInitError_Init_NotAvailableToUtilityApps = 123,
+	VRInitError_Init_Internal = 124,
+	VRInitError_Init_HmdDriverIdIsNone = 125,
+	VRInitError_Init_HmdNotFoundPresenceFailed = 126,
+	VRInitError_Init_VRMonitorNotFound = 127,
+	VRInitError_Init_VRMonitorStartupFailed = 128,
+	VRInitError_Init_LowPowerWatchdogNotSupported = 129,
+	VRInitError_Init_InvalidApplicationType = 130,
+	VRInitError_Init_NotAvailableToWatchdogApps = 131,
+	VRInitError_Init_WatchdogDisabledInSettings = 132,
+	VRInitError_Init_VRDashboardNotFound = 133,
+	VRInitError_Init_VRDashboardStartupFailed = 134,
+	VRInitError_Init_VRHomeNotFound = 135,
+	VRInitError_Init_VRHomeStartupFailed = 136,
+	VRInitError_Init_RebootingBusy = 137,
+	VRInitError_Init_FirmwareUpdateBusy = 138,
+	VRInitError_Init_FirmwareRecoveryBusy = 139,
+
+	VRInitError_Driver_Failed = 200,
+	VRInitError_Driver_Unknown = 201,
+	VRInitError_Driver_HmdUnknown = 202,
+	VRInitError_Driver_NotLoaded = 203,
+	VRInitError_Driver_RuntimeOutOfDate = 204,
+	VRInitError_Driver_HmdInUse = 205,
+	VRInitError_Driver_NotCalibrated = 206,
+	VRInitError_Driver_CalibrationInvalid = 207,
+	VRInitError_Driver_HmdDisplayNotFound = 208,
+	VRInitError_Driver_TrackedDeviceInterfaceUnknown = 209,
+	// VRInitError_Driver_HmdDisplayNotFoundAfterFix = 210, // not needed: here for historic reasons
+	VRInitError_Driver_HmdDriverIdOutOfBounds = 211,
+	VRInitError_Driver_HmdDisplayMirrored = 212,
+
+	VRInitError_IPC_ServerInitFailed = 300,
+	VRInitError_IPC_ConnectFailed = 301,
+	VRInitError_IPC_SharedStateInitFailed = 302,
+	VRInitError_IPC_CompositorInitFailed = 303,
+	VRInitError_IPC_MutexInitFailed = 304,
+	VRInitError_IPC_Failed = 305,
+	VRInitError_IPC_CompositorConnectFailed = 306,
+	VRInitError_IPC_CompositorInvalidConnectResponse = 307,
+	VRInitError_IPC_ConnectFailedAfterMultipleAttempts = 308,
+
+	VRInitError_Compositor_Failed = 400,
+	VRInitError_Compositor_D3D11HardwareRequired = 401,
+	VRInitError_Compositor_FirmwareRequiresUpdate = 402,
+	VRInitError_Compositor_OverlayInitFailed = 403,
+	VRInitError_Compositor_ScreenshotsInitFailed = 404,
+	VRInitError_Compositor_UnableToCreateDevice = 405,
+
+	VRInitError_VendorSpecific_UnableToConnectToOculusRuntime = 1000,
+
+	VRInitError_VendorSpecific_HmdFound_CantOpenDevice = 1101,
+	VRInitError_VendorSpecific_HmdFound_UnableToRequestConfigStart = 1102,
+	VRInitError_VendorSpecific_HmdFound_NoStoredConfig = 1103,
+	VRInitError_VendorSpecific_HmdFound_ConfigTooBig = 1104,
+	VRInitError_VendorSpecific_HmdFound_ConfigTooSmall = 1105,
+	VRInitError_VendorSpecific_HmdFound_UnableToInitZLib = 1106,
+	VRInitError_VendorSpecific_HmdFound_CantReadFirmwareVersion = 1107,
+	VRInitError_VendorSpecific_HmdFound_UnableToSendUserDataStart = 1108,
+	VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataStart = 1109,
+	VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataNext = 1110,
+	VRInitError_VendorSpecific_HmdFound_UserDataAddressRange = 1111,
+	VRInitError_VendorSpecific_HmdFound_UserDataError = 1112,
+	VRInitError_VendorSpecific_HmdFound_ConfigFailedSanityCheck = 1113,
+
+	VRInitError_Steam_SteamInstallationNotFound = 2000,
+};
+
+enum EVRScreenshotType
+{
+	VRScreenshotType_None = 0,
+	VRScreenshotType_Mono = 1,  // left eye only
+	VRScreenshotType_Stereo = 2,
+	VRScreenshotType_Cubemap = 3,
+	VRScreenshotType_MonoPanorama = 4,
+	VRScreenshotType_StereoPanorama = 5
+};
+
+enum EVRScreenshotPropertyFilenames
+{
+	VRScreenshotPropertyFilenames_Preview = 0,
+	VRScreenshotPropertyFilenames_VR = 1,
+};
+
+enum EVRTrackedCameraError
+{
+	VRTrackedCameraError_None = 0,
+	VRTrackedCameraError_OperationFailed = 100,
+	VRTrackedCameraError_InvalidHandle = 101,
+	VRTrackedCameraError_InvalidFrameHeaderVersion = 102,
+	VRTrackedCameraError_OutOfHandles = 103,
+	VRTrackedCameraError_IPCFailure = 104,
+	VRTrackedCameraError_NotSupportedForThisDevice = 105,
+	VRTrackedCameraError_SharedMemoryFailure = 106,
+	VRTrackedCameraError_FrameBufferingFailure = 107,
+	VRTrackedCameraError_StreamSetupFailure = 108,
+	VRTrackedCameraError_InvalidGLTextureId = 109,
+	VRTrackedCameraError_InvalidSharedTextureHandle = 110,
+	VRTrackedCameraError_FailedToGetGLTextureId = 111,
+	VRTrackedCameraError_SharedTextureFailure = 112,
+	VRTrackedCameraError_NoFrameAvailable = 113,
+	VRTrackedCameraError_InvalidArgument = 114,
+	VRTrackedCameraError_InvalidFrameBufferSize = 115,
+};
+
+enum EVRTrackedCameraFrameType
+{
+	VRTrackedCameraFrameType_Distorted = 0,       // This is the camera video frame size in pixels, still distorted.
+	VRTrackedCameraFrameType_Undistorted,         // In pixels, an undistorted inscribed rectangle region without invalid regions. This size is subject to changes shortly.
+	VRTrackedCameraFrameType_MaximumUndistorted,  // In pixels, maximum undistorted with invalid regions. Non zero alpha component identifies valid regions.
+	MAX_CAMERA_FRAME_TYPES
+};
+
+typedef uint64_t TrackedCameraHandle_t;
+#define INVALID_TRACKED_CAMERA_HANDLE ((vr::TrackedCameraHandle_t)0)
+
+struct CameraVideoStreamFrameHeader_t
+{
+	EVRTrackedCameraFrameType eFrameType;
+
+	uint32_t nWidth;
+	uint32_t nHeight;
+	uint32_t nBytesPerPixel;
+
+	uint32_t nFrameSequence;
+
+	TrackedDevicePose_t standingTrackedDevicePose;
+};
+
+// Screenshot types
+typedef uint32_t ScreenshotHandle_t;
+
+static const uint32_t k_unScreenshotHandleInvalid = 0;
+
+#pragma pack(pop)
+
+// figure out how to import from the VR API dll
+#if defined(_WIN32)
+
+#ifdef VR_API_EXPORT
+#define VR_INTERFACE extern "C" __declspec(dllexport)
+#else
+#define VR_INTERFACE extern "C" __declspec(dllimport)
+#endif
+
+#elif defined(__GNUC__) || defined(COMPILER_GCC) || defined(__APPLE__)
+
+#ifdef VR_API_EXPORT
+#define VR_INTERFACE extern "C" __attribute__((visibility("default")))
+#else
+#define VR_INTERFACE extern "C"
+#endif
+
+#else
+#error "Unsupported Platform."
+#endif
+
+#if defined(_WIN32)
+#define VR_CALLTYPE __cdecl
+#else
+#define VR_CALLTYPE
+#endif
+
+}  // namespace vr
+
+#endif  // _INCLUDE_VRTYPES_H
+
+// vrannotation.h
+#ifdef API_GEN
+#define VR_CLANG_ATTR(ATTR) __attribute__((annotate(ATTR)))
+#else
+#define VR_CLANG_ATTR(ATTR)
+#endif
+
+#define VR_METHOD_DESC(DESC) VR_CLANG_ATTR("desc:" #DESC ";")
+#define VR_IGNOREATTR() VR_CLANG_ATTR("ignore")
+#define VR_OUT_STRUCT() VR_CLANG_ATTR("out_struct: ;")
+#define VR_OUT_STRING() VR_CLANG_ATTR("out_string: ;")
+#define VR_OUT_ARRAY_CALL(COUNTER, FUNCTION, PARAMS) VR_CLANG_ATTR("out_array_call:" #COUNTER "," #FUNCTION "," #PARAMS ";")
+#define VR_OUT_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR("out_array_count:" #COUNTER ";")
+#define VR_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR("array_count:" #COUNTER ";")
+#define VR_ARRAY_COUNT_D(COUNTER, DESC) VR_CLANG_ATTR("array_count:" #COUNTER ";desc:" #DESC)
+#define VR_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR("buffer_count:" #COUNTER ";")
+#define VR_OUT_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR("out_buffer_count:" #COUNTER ";")
+#define VR_OUT_STRING_COUNT(COUNTER) VR_CLANG_ATTR("out_string_count:" #COUNTER ";")
+
+// vrtrackedcameratypes.h
+#ifndef _VRTRACKEDCAMERATYPES_H
+#define _VRTRACKEDCAMERATYPES_H
+
+namespace vr
+{
+#pragma pack(push, 8)
+
+enum ECameraVideoStreamFormat
+{
+	CVS_FORMAT_UNKNOWN = 0,
+	CVS_FORMAT_RAW10 = 1,  // 10 bits per pixel
+	CVS_FORMAT_NV12 = 2,   // 12 bits per pixel
+	CVS_FORMAT_RGB24 = 3,  // 24 bits per pixel
+	CVS_MAX_FORMATS
+};
+
+enum ECameraCompatibilityMode
+{
+	CAMERA_COMPAT_MODE_BULK_DEFAULT = 0,
+	CAMERA_COMPAT_MODE_BULK_64K_DMA,
+	CAMERA_COMPAT_MODE_BULK_16K_DMA,
+	CAMERA_COMPAT_MODE_BULK_8K_DMA,
+	CAMERA_COMPAT_MODE_ISO_52FPS,
+	CAMERA_COMPAT_MODE_ISO_50FPS,
+	CAMERA_COMPAT_MODE_ISO_48FPS,
+	CAMERA_COMPAT_MODE_ISO_46FPS,
+	CAMERA_COMPAT_MODE_ISO_44FPS,
+	CAMERA_COMPAT_MODE_ISO_42FPS,
+	CAMERA_COMPAT_MODE_ISO_40FPS,
+	CAMERA_COMPAT_MODE_ISO_35FPS,
+	CAMERA_COMPAT_MODE_ISO_30FPS,
+	MAX_CAMERA_COMPAT_MODES
+};
+
+#ifdef _MSC_VER
+#define VR_CAMERA_DECL_ALIGN(x) __declspec(align(x))
+#else
+#define VR_CAMERA_DECL_ALIGN(x)  //
+#endif
+
+#define MAX_CAMERA_FRAME_SHARED_HANDLES 4
+
+VR_CAMERA_DECL_ALIGN(8)
+struct CameraVideoStreamFrame_t
+{
+	ECameraVideoStreamFormat m_nStreamFormat;
+
+	uint32_t m_nWidth;
+	uint32_t m_nHeight;
+
+	uint32_t m_nImageDataSize;  // Based on stream format, width, height
+
+	uint32_t m_nFrameSequence;  // Starts from 0 when stream starts.
+
+	uint32_t m_nBufferIndex;  // Identifies which buffer the image data is hosted
+	uint32_t m_nBufferCount;  // Total number of configured buffers
+
+	uint32_t m_nExposureTime;
+
+	uint32_t m_nISPFrameTimeStamp;  // Driver provided time stamp per driver centric time base
+	uint32_t m_nISPReferenceTimeStamp;
+	uint32_t m_nSyncCounter;
+
+	uint32_t m_nCamSyncEvents;
+	uint32_t m_nISPSyncEvents;
+
+	double m_flReferenceCamSyncTime;
+
+	double m_flFrameElapsedTime;  // Starts from 0 when stream starts. In seconds.
+	double m_flFrameDeliveryRate;
+
+	double m_flFrameCaptureTime_DriverAbsolute;    // In USB time, via AuxEvent
+	double m_flFrameCaptureTime_ServerRelative;    // In System time within the server
+	uint64_t m_nFrameCaptureTicks_ServerAbsolute;  // In system ticks within the server
+	double m_flFrameCaptureTime_ClientRelative;    // At the client, relative to when the frame was exposed/captured.
+
+	double m_flSyncMarkerError;
+
+	TrackedDevicePose_t m_StandingTrackedDevicePose;  // Supplied by HMD layer when used as a tracked camera
+
+	uint64_t m_pImageData;
+};
+
+#pragma pack(pop)
+
+}  // namespace vr
+
+#endif  // _VRTRACKEDCAMERATYPES_H
+// ivrsettings.h
+namespace vr
+{
+enum EVRSettingsError
+{
+	VRSettingsError_None = 0,
+	VRSettingsError_IPCFailed = 1,
+	VRSettingsError_WriteFailed = 2,
+	VRSettingsError_ReadFailed = 3,
+	VRSettingsError_JsonParseFailed = 4,
+	VRSettingsError_UnsetSettingHasNoDefault = 5,  // This will be returned if the setting does not appear in the appropriate default file and has not been set
+};
+
+// The maximum length of a settings key
+static const uint32_t k_unMaxSettingsKeyLength = 128;
+
+class IVRSettings
+{
+public:
+	virtual const char *GetSettingsErrorNameFromEnum(EVRSettingsError eError) = 0;
+
+	// Returns true if file sync occurred (force or settings dirty)
+	virtual bool Sync(bool bForce = false, EVRSettingsError *peError = nullptr) = 0;
+
+	virtual void SetBool(const char *pchSection, const char *pchSettingsKey, bool bValue, EVRSettingsError *peError = nullptr) = 0;
+	virtual void SetInt32(const char *pchSection, const char *pchSettingsKey, int32_t nValue, EVRSettingsError *peError = nullptr) = 0;
+	virtual void SetFloat(const char *pchSection, const char *pchSettingsKey, float flValue, EVRSettingsError *peError = nullptr) = 0;
+	virtual void SetString(const char *pchSection, const char *pchSettingsKey, const char *pchValue, EVRSettingsError *peError = nullptr) = 0;
+
+	// Users of the system need to provide a proper default in default.vrsettings in the resources/settings/ directory
+	// of either the runtime or the driver_xxx directory. Otherwise the default will be false, 0, 0.0 or ""
+	virtual bool GetBool(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+	virtual int32_t GetInt32(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+	virtual float GetFloat(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+	virtual void GetString(const char *pchSection, const char *pchSettingsKey, VR_OUT_STRING() char *pchValue, uint32_t unValueLen, EVRSettingsError *peError = nullptr) = 0;
+
+	virtual void RemoveSection(const char *pchSection, EVRSettingsError *peError = nullptr) = 0;
+	virtual void RemoveKeyInSection(const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr) = 0;
+};
+
+//-----------------------------------------------------------------------------
+static const char *const IVRSettings_Version = "IVRSettings_002";
+
+//-----------------------------------------------------------------------------
+// steamvr keys
+static const char *const k_pch_SteamVR_Section = "steamvr";
+static const char *const k_pch_SteamVR_RequireHmd_String = "requireHmd";
+static const char *const k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver";
+static const char *const k_pch_SteamVR_ForcedHmdKey_String = "forcedHmd";
+static const char *const k_pch_SteamVR_DisplayDebug_Bool = "displayDebug";
+static const char *const k_pch_SteamVR_DebugProcessPipe_String = "debugProcessPipe";
+static const char *const k_pch_SteamVR_DisplayDebugX_Int32 = "displayDebugX";
+static const char *const k_pch_SteamVR_DisplayDebugY_Int32 = "displayDebugY";
+static const char *const k_pch_SteamVR_SendSystemButtonToAllApps_Bool = "sendSystemButtonToAllApps";
+static const char *const k_pch_SteamVR_LogLevel_Int32 = "loglevel";
+static const char *const k_pch_SteamVR_IPD_Float = "ipd";
+static const char *const k_pch_SteamVR_Background_String = "background";
+static const char *const k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection";
+static const char *const k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight";
+static const char *const k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius";
+static const char *const k_pch_SteamVR_GridColor_String = "gridColor";
+static const char *const k_pch_SteamVR_PlayAreaColor_String = "playAreaColor";
+static const char *const k_pch_SteamVR_ShowStage_Bool = "showStage";
+static const char *const k_pch_SteamVR_ActivateMultipleDrivers_Bool = "activateMultipleDrivers";
+static const char *const k_pch_SteamVR_DirectMode_Bool = "directMode";
+static const char *const k_pch_SteamVR_DirectModeEdidVid_Int32 = "directModeEdidVid";
+static const char *const k_pch_SteamVR_DirectModeEdidPid_Int32 = "directModeEdidPid";
+static const char *const k_pch_SteamVR_UsingSpeakers_Bool = "usingSpeakers";
+static const char *const k_pch_SteamVR_SpeakersForwardYawOffsetDegrees_Float = "speakersForwardYawOffsetDegrees";
+static const char *const k_pch_SteamVR_BaseStationPowerManagement_Bool = "basestationPowerManagement";
+static const char *const k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses";
+static const char *const k_pch_SteamVR_SupersampleScale_Float = "supersampleScale";
+static const char *const k_pch_SteamVR_AllowAsyncReprojection_Bool = "allowAsyncReprojection";
+static const char *const k_pch_SteamVR_AllowReprojection_Bool = "allowInterleavedReprojection";
+static const char *const k_pch_SteamVR_ForceReprojection_Bool = "forceReprojection";
+static const char *const k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking";
+static const char *const k_pch_SteamVR_DefaultMirrorView_Int32 = "defaultMirrorView";
+static const char *const k_pch_SteamVR_ShowMirrorView_Bool = "showMirrorView";
+static const char *const k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry";
+static const char *const k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch";
+static const char *const k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch";
+static const char *const k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch";
+static const char *const k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard";
+static const char *const k_pch_SteamVR_EnableHomeApp = "enableHomeApp";
+static const char *const k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec";
+static const char *const k_pch_SteamVR_RetailDemo_Bool = "retailDemo";
+static const char *const k_pch_SteamVR_IpdOffset_Float = "ipdOffset";
+static const char *const k_pch_SteamVR_AllowSupersampleFiltering_Bool = "allowSupersampleFiltering";
+static const char *const k_pch_SteamVR_EnableLinuxVulkanAsync_Bool = "enableLinuxVulkanAsync";
+
+//-----------------------------------------------------------------------------
+// lighthouse keys
+static const char *const k_pch_Lighthouse_Section = "driver_lighthouse";
+static const char *const k_pch_Lighthouse_DisableIMU_Bool = "disableimu";
+static const char *const k_pch_Lighthouse_UseDisambiguation_String = "usedisambiguation";
+static const char *const k_pch_Lighthouse_DisambiguationDebug_Int32 = "disambiguationdebug";
+static const char *const k_pch_Lighthouse_PrimaryBasestation_Int32 = "primarybasestation";
+static const char *const k_pch_Lighthouse_DBHistory_Bool = "dbhistory";
+
+//-----------------------------------------------------------------------------
+// null keys
+static const char *const k_pch_Null_Section = "driver_null";
+static const char *const k_pch_Null_SerialNumber_String = "serialNumber";
+static const char *const k_pch_Null_ModelNumber_String = "modelNumber";
+static const char *const k_pch_Null_WindowX_Int32 = "windowX";
+static const char *const k_pch_Null_WindowY_Int32 = "windowY";
+static const char *const k_pch_Null_WindowWidth_Int32 = "windowWidth";
+static const char *const k_pch_Null_WindowHeight_Int32 = "windowHeight";
+static const char *const k_pch_Null_RenderWidth_Int32 = "renderWidth";
+static const char *const k_pch_Null_RenderHeight_Int32 = "renderHeight";
+static const char *const k_pch_Null_SecondsFromVsyncToPhotons_Float = "secondsFromVsyncToPhotons";
+static const char *const k_pch_Null_DisplayFrequency_Float = "displayFrequency";
+
+//-----------------------------------------------------------------------------
+// user interface keys
+static const char *const k_pch_UserInterface_Section = "userinterface";
+static const char *const k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop";
+static const char *const k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray";
+static const char *const k_pch_UserInterface_Screenshots_Bool = "screenshots";
+static const char *const k_pch_UserInterface_ScreenshotType_Int = "screenshotType";
+
+//-----------------------------------------------------------------------------
+// notification keys
+static const char *const k_pch_Notifications_Section = "notifications";
+static const char *const k_pch_Notifications_DoNotDisturb_Bool = "DoNotDisturb";
+
+//-----------------------------------------------------------------------------
+// keyboard keys
+static const char *const k_pch_Keyboard_Section = "keyboard";
+static const char *const k_pch_Keyboard_TutorialCompletions = "TutorialCompletions";
+static const char *const k_pch_Keyboard_ScaleX = "ScaleX";
+static const char *const k_pch_Keyboard_ScaleY = "ScaleY";
+static const char *const k_pch_Keyboard_OffsetLeftX = "OffsetLeftX";
+static const char *const k_pch_Keyboard_OffsetRightX = "OffsetRightX";
+static const char *const k_pch_Keyboard_OffsetY = "OffsetY";
+static const char *const k_pch_Keyboard_Smoothing = "Smoothing";
+
+//-----------------------------------------------------------------------------
+// perf keys
+static const char *const k_pch_Perf_Section = "perfcheck";
+static const char *const k_pch_Perf_HeuristicActive_Bool = "heuristicActive";
+static const char *const k_pch_Perf_NotifyInHMD_Bool = "warnInHMD";
+static const char *const k_pch_Perf_NotifyOnlyOnce_Bool = "warnOnlyOnce";
+static const char *const k_pch_Perf_AllowTimingStore_Bool = "allowTimingStore";
+static const char *const k_pch_Perf_SaveTimingsOnExit_Bool = "saveTimingsOnExit";
+static const char *const k_pch_Perf_TestData_Float = "perfTestData";
+static const char *const k_pch_Perf_LinuxGPUProfiling_Bool = "linuxGPUProfiling";
+
+//-----------------------------------------------------------------------------
+// collision bounds keys
+static const char *const k_pch_CollisionBounds_Section = "collisionBounds";
+static const char *const k_pch_CollisionBounds_Style_Int32 = "CollisionBoundsStyle";
+static const char *const k_pch_CollisionBounds_GroundPerimeterOn_Bool = "CollisionBoundsGroundPerimeterOn";
+static const char *const k_pch_CollisionBounds_CenterMarkerOn_Bool = "CollisionBoundsCenterMarkerOn";
+static const char *const k_pch_CollisionBounds_PlaySpaceOn_Bool = "CollisionBoundsPlaySpaceOn";
+static const char *const k_pch_CollisionBounds_FadeDistance_Float = "CollisionBoundsFadeDistance";
+static const char *const k_pch_CollisionBounds_ColorGammaR_Int32 = "CollisionBoundsColorGammaR";
+static const char *const k_pch_CollisionBounds_ColorGammaG_Int32 = "CollisionBoundsColorGammaG";
+static const char *const k_pch_CollisionBounds_ColorGammaB_Int32 = "CollisionBoundsColorGammaB";
+static const char *const k_pch_CollisionBounds_ColorGammaA_Int32 = "CollisionBoundsColorGammaA";
+
+//-----------------------------------------------------------------------------
+// camera keys
+static const char *const k_pch_Camera_Section = "camera";
+static const char *const k_pch_Camera_EnableCamera_Bool = "enableCamera";
+static const char *const k_pch_Camera_EnableCameraInDashboard_Bool = "enableCameraInDashboard";
+static const char *const k_pch_Camera_EnableCameraForCollisionBounds_Bool = "enableCameraForCollisionBounds";
+static const char *const k_pch_Camera_EnableCameraForRoomView_Bool = "enableCameraForRoomView";
+static const char *const k_pch_Camera_BoundsColorGammaR_Int32 = "cameraBoundsColorGammaR";
+static const char *const k_pch_Camera_BoundsColorGammaG_Int32 = "cameraBoundsColorGammaG";
+static const char *const k_pch_Camera_BoundsColorGammaB_Int32 = "cameraBoundsColorGammaB";
+static const char *const k_pch_Camera_BoundsColorGammaA_Int32 = "cameraBoundsColorGammaA";
+static const char *const k_pch_Camera_BoundsStrength_Int32 = "cameraBoundsStrength";
+
+//-----------------------------------------------------------------------------
+// audio keys
+static const char *const k_pch_audio_Section = "audio";
+static const char *const k_pch_audio_OnPlaybackDevice_String = "onPlaybackDevice";
+static const char *const k_pch_audio_OnRecordDevice_String = "onRecordDevice";
+static const char *const k_pch_audio_OnPlaybackMirrorDevice_String = "onPlaybackMirrorDevice";
+static const char *const k_pch_audio_OffPlaybackDevice_String = "offPlaybackDevice";
+static const char *const k_pch_audio_OffRecordDevice_String = "offRecordDevice";
+static const char *const k_pch_audio_VIVEHDMIGain = "viveHDMIGain";
+
+//-----------------------------------------------------------------------------
+// power management keys
+static const char *const k_pch_Power_Section = "power";
+static const char *const k_pch_Power_PowerOffOnExit_Bool = "powerOffOnExit";
+static const char *const k_pch_Power_TurnOffScreensTimeout_Float = "turnOffScreensTimeout";
+static const char *const k_pch_Power_TurnOffControllersTimeout_Float = "turnOffControllersTimeout";
+static const char *const k_pch_Power_ReturnToWatchdogTimeout_Float = "returnToWatchdogTimeout";
+static const char *const k_pch_Power_AutoLaunchSteamVROnButtonPress = "autoLaunchSteamVROnButtonPress";
+static const char *const k_pch_Power_PauseCompositorOnStandby_Bool = "pauseCompositorOnStandby";
+
+//-----------------------------------------------------------------------------
+// dashboard keys
+static const char *const k_pch_Dashboard_Section = "dashboard";
+static const char *const k_pch_Dashboard_EnableDashboard_Bool = "enableDashboard";
+static const char *const k_pch_Dashboard_ArcadeMode_Bool = "arcadeMode";
+
+//-----------------------------------------------------------------------------
+// model skin keys
+static const char *const k_pch_modelskin_Section = "modelskins";
+
+//-----------------------------------------------------------------------------
+// driver keys - These could be checked in any driver_<name> section
+static const char *const k_pch_Driver_Enable_Bool = "enable";
+
+}  // namespace vr
+
+// iservertrackeddevicedriver.h
+namespace vr
+{
+struct DriverPoseQuaternion_t
+{
+	double w, x, y, z;
+};
+
+struct DriverPose_t
+{
+	/* Time offset of this pose, in seconds from the actual time of the pose,
+	 * relative to the time of the PoseUpdated() call made by the driver.
+	 */
+	double poseTimeOffset;
+
+	/* Generally, the pose maintained by a driver
+	 * is in an inertial coordinate system different
+	 * from the world system of x+ right, y+ up, z+ back.
+	 * Also, the driver is not usually tracking the "head" position,
+	 * but instead an internal IMU or another reference point in the HMD.
+	 * The following two transforms transform positions and orientations
+	 * to app world space from driver world space,
+	 * and to HMD head space from driver local body space. 
+	 *
+	 * We maintain the driver pose state in its internal coordinate system,
+	 * so we can do the pose prediction math without having to
+	 * use angular acceleration.  A driver's angular acceleration is generally not measured,
+	 * and is instead calculated from successive samples of angular velocity.
+	 * This leads to a noisy angular acceleration values, which are also
+	 * lagged due to the filtering required to reduce noise to an acceptable level.
+	 */
+	vr::HmdQuaternion_t qWorldFromDriverRotation;
+	double vecWorldFromDriverTranslation[3];
+
+	vr::HmdQuaternion_t qDriverFromHeadRotation;
+	double vecDriverFromHeadTranslation[3];
+
+	/* State of driver pose, in meters and radians. */
+	/* Position of the driver tracking reference in driver world space
+	* +[0] (x) is right
+	* +[1] (y) is up
+	* -[2] (z) is forward
+	*/
+	double vecPosition[3];
+
+	/* Velocity of the pose in meters/second */
+	double vecVelocity[3];
+
+	/* Acceleration of the pose in meters/second */
+	double vecAcceleration[3];
+
+	/* Orientation of the tracker, represented as a quaternion */
+	vr::HmdQuaternion_t qRotation;
+
+	/* Angular velocity of the pose in axis-angle 
+	* representation. The direction is the angle of
+	* rotation and the magnitude is the angle around
+	* that axis in radians/second. */
+	double vecAngularVelocity[3];
+
+	/* Angular acceleration of the pose in axis-angle 
+	* representation. The direction is the angle of
+	* rotation and the magnitude is the angle around
+	* that axis in radians/second^2. */
+	double vecAngularAcceleration[3];
+
+	ETrackingResult result;
+
+	bool poseIsValid;
+	bool willDriftInYaw;
+	bool shouldApplyHeadModel;
+	bool deviceIsConnected;
+};
+
+// ----------------------------------------------------------------------------------------------
+// Purpose: Represents a single tracked device in a driver
+// ----------------------------------------------------------------------------------------------
+class ITrackedDeviceServerDriver
+{
+public:
+	// ------------------------------------
+	// Management Methods
+	// ------------------------------------
+	/** This is called before an HMD is returned to the application. It will always be
+	* called before any display or tracking methods. Memory and processor use by the
+	* ITrackedDeviceServerDriver object should be kept to a minimum until it is activated.
+	* The pose listener is guaranteed to be valid until Deactivate is called, but
+	* should not be used after that point. */
+	virtual EVRInitError Activate(uint32_t unObjectId) = 0;
+
+	/** This is called when The VR system is switching from this Hmd being the active display
+	* to another Hmd being the active display. The driver should clean whatever memory
+	* and thread use it can when it is deactivated */
+	virtual void Deactivate() = 0;
+
+	/** Handles a request from the system to put this device into standby mode. What that means is defined per-device. */
+	virtual void EnterStandby() = 0;
+
+	/** Requests a component interface of the driver for device-specific functionality. The driver should return NULL
+	* if the requested interface or version is not supported. */
+	virtual void *GetComponent(const char *pchComponentNameAndVersion) = 0;
+
+	/** A VR Client has made this debug request of the driver. The set of valid requests is entirely
+	* up to the driver and the client to figure out, as is the format of the response. Responses that
+	* exceed the length of the supplied buffer should be truncated and null terminated */
+	virtual void DebugRequest(const char *pchRequest, char *pchResponseBuffer, uint32_t unResponseBufferSize) = 0;
+
+	// ------------------------------------
+	// Tracking Methods
+	// ------------------------------------
+	virtual DriverPose_t GetPose() = 0;
+};
+
+static const char *ITrackedDeviceServerDriver_Version = "ITrackedDeviceServerDriver_005";
+
+}  // namespace vr
+// ivrdisplaycomponent.h
+namespace vr
+{
+// ----------------------------------------------------------------------------------------------
+// Purpose: The display component on a single tracked device
+// ----------------------------------------------------------------------------------------------
+class IVRDisplayComponent
+{
+public:
+	// ------------------------------------
+	// Display Methods
+	// ------------------------------------
+
+	/** Size and position that the window needs to be on the VR display. */
+	virtual void GetWindowBounds(int32_t *pnX, int32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight) = 0;
+
+	/** Returns true if the display is extending the desktop. */
+	virtual bool IsDisplayOnDesktop() = 0;
+
+	/** Returns true if the display is real and not a fictional display. */
+	virtual bool IsDisplayRealDisplay() = 0;
+
+	/** Suggested size for the intermediate render target that the distortion pulls from. */
+	virtual void GetRecommendedRenderTargetSize(uint32_t *pnWidth, uint32_t *pnHeight) = 0;
+
+	/** Gets the viewport in the frame buffer to draw the output of the distortion into */
+	virtual void GetEyeOutputViewport(EVREye eEye, uint32_t *pnX, uint32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight) = 0;
+
+	/** The components necessary to build your own projection matrix in case your
+		* application is doing something fancy like infinite Z */
+	virtual void GetProjectionRaw(EVREye eEye, float *pfLeft, float *pfRight, float *pfTop, float *pfBottom) = 0;
+
+	/** Returns the result of the distortion function for the specified eye and input UVs. UVs go from 0,0 in
+		* the upper left of that eye's viewport and 1,1 in the lower right of that eye's viewport. */
+	virtual DistortionCoordinates_t ComputeDistortion(EVREye eEye, float fU, float fV) = 0;
+};
+
+static const char *IVRDisplayComponent_Version = "IVRDisplayComponent_002";
+
+}  // namespace vr
+
+// ivrdriverdirectmodecomponent.h
+namespace vr
+{
+// ----------------------------------------------------------------------------------------------
+// Purpose: This component is used for drivers that implement direct mode entirely on their own
+//			without allowing the VR Compositor to own the window/device. Chances are you don't
+//			need to implement this component in your driver.
+// ----------------------------------------------------------------------------------------------
+class IVRDriverDirectModeComponent
+{
+public:
+	// -----------------------------------
+	// Direct mode methods
+	// -----------------------------------
+
+	/** Specific to Oculus compositor support, textures supplied must be created using this method. */
+	virtual void CreateSwapTextureSet(uint32_t unPid, uint32_t unFormat, uint32_t unWidth, uint32_t unHeight, vr::SharedTextureHandle_t (*pSharedTextureHandles)[3]) {}
+
+	/** Used to textures created using CreateSwapTextureSet.  Only one of the set's handles needs to be used to destroy the entire set. */
+	virtual void DestroySwapTextureSet(vr::SharedTextureHandle_t sharedTextureHandle) {}
+
+	/** Used to purge all texture sets for a given process. */
+	virtual void DestroyAllSwapTextureSets(uint32_t unPid) {}
+
+	/** After Present returns, calls this to get the next index to use for rendering. */
+	virtual void GetNextSwapTextureSetIndex(vr::SharedTextureHandle_t sharedTextureHandles[2], uint32_t (*pIndices)[2]) {}
+
+	/** Call once per layer to draw for this frame.  One shared texture handle per eye.  Textures must be created
+		* using CreateSwapTextureSet and should be alternated per frame.  Call Present once all layers have been submitted. */
+	virtual void SubmitLayer(vr::SharedTextureHandle_t sharedTextureHandles[2], const vr::VRTextureBounds_t (&bounds)[2], const vr::HmdMatrix34_t *pPose) {}
+
+	/** Submits queued layers for display. */
+	virtual void Present(vr::SharedTextureHandle_t syncTexture) {}
+};
+
+static const char *IVRDriverDirectModeComponent_Version = "IVRDriverDirectModeComponent_002";
+
+}  // namespace vr
+
+// ivrcontrollercomponent.h
+namespace vr
+{
+// ----------------------------------------------------------------------------------------------
+// Purpose: Controller access on a single tracked device.
+// ----------------------------------------------------------------------------------------------
+class IVRControllerComponent
+{
+public:
+	// ------------------------------------
+	// Controller Methods
+	// ------------------------------------
+
+	/** Gets the current state of a controller. */
+	virtual VRControllerState_t GetControllerState() = 0;
+
+	/** Returns a uint64 property. If the property is not available this function will return 0. */
+	virtual bool TriggerHapticPulse(uint32_t unAxisId, uint16_t usPulseDurationMicroseconds) = 0;
+};
+
+static const char *IVRControllerComponent_Version = "IVRControllerComponent_001";
+
+}  // namespace vr
+// ivrcameracomponent.h
+namespace vr
+{
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+class ICameraVideoSinkCallback
+{
+public:
+	virtual void OnCameraVideoSinkCallback() = 0;
+};
+
+// ----------------------------------------------------------------------------------------------
+// Purpose: The camera on a single tracked device
+// ----------------------------------------------------------------------------------------------
+class IVRCameraComponent
+{
+public:
+	// ------------------------------------
+	// Camera Methods
+	// ------------------------------------
+	virtual bool GetCameraFrameDimensions(vr::ECameraVideoStreamFormat nVideoStreamFormat, uint32_t *pWidth, uint32_t *pHeight) = 0;
+	virtual bool GetCameraFrameBufferingRequirements(int *pDefaultFrameQueueSize, uint32_t *pFrameBufferDataSize) = 0;
+	virtual bool SetCameraFrameBuffering(int nFrameBufferCount, void **ppFrameBuffers, uint32_t nFrameBufferDataSize) = 0;
+	virtual bool SetCameraVideoStreamFormat(vr::ECameraVideoStreamFormat nVideoStreamFormat) = 0;
+	virtual vr::ECameraVideoStreamFormat GetCameraVideoStreamFormat() = 0;
+	virtual bool StartVideoStream() = 0;
+	virtual void StopVideoStream() = 0;
+	virtual bool IsVideoStreamActive(bool *pbPaused, float *pflElapsedTime) = 0;
+	virtual const vr::CameraVideoStreamFrame_t *GetVideoStreamFrame() = 0;
+	virtual void ReleaseVideoStreamFrame(const vr::CameraVideoStreamFrame_t *pFrameImage) = 0;
+	virtual bool SetAutoExposure(bool bEnable) = 0;
+	virtual bool PauseVideoStream() = 0;
+	virtual bool ResumeVideoStream() = 0;
+	virtual bool GetCameraDistortion(float flInputU, float flInputV, float *pflOutputU, float *pflOutputV) = 0;
+	virtual bool GetCameraProjection(vr::EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, vr::HmdMatrix44_t *pProjection) = 0;
+	virtual bool SetFrameRate(int nISPFrameRate, int nSensorFrameRate) = 0;
+	virtual bool SetCameraVideoSinkCallback(vr::ICameraVideoSinkCallback *pCameraVideoSinkCallback) = 0;
+	virtual bool GetCameraCompatibilityMode(vr::ECameraCompatibilityMode *pCameraCompatibilityMode) = 0;
+	virtual bool SetCameraCompatibilityMode(vr::ECameraCompatibilityMode nCameraCompatibilityMode) = 0;
+	virtual bool GetCameraFrameBounds(vr::EVRTrackedCameraFrameType eFrameType, uint32_t *pLeft, uint32_t *pTop, uint32_t *pWidth, uint32_t *pHeight) = 0;
+	virtual bool GetCameraIntrinsics(vr::EVRTrackedCameraFrameType eFrameType, HmdVector2_t *pFocalLength, HmdVector2_t *pCenter) = 0;
+};
+
+static const char *IVRCameraComponent_Version = "IVRCameraComponent_002";
+}  // namespace vr
+// itrackeddevicedriverprovider.h
+namespace vr
+{
+class ITrackedDeviceServerDriver;
+struct TrackedDeviceDriverInfo_t;
+struct DriverPose_t;
+typedef PropertyContainerHandle_t DriverHandle_t;
+
+/** This interface is provided by vrserver to allow the driver to notify 
+* the system when something changes about a device. These changes must
+* not change the serial number or class of the device because those values
+* are permanently associated with the device's index. */
+class IVRDriverContext
+{
+public:
+	/** Returns the requested interface. If the interface was not available it will return NULL and fill
+	* out the error. */
+	virtual void *GetGenericInterface(const char *pchInterfaceVersion, EVRInitError *peError = nullptr) = 0;
+
+	/** Returns the property container handle for this driver */
+	virtual DriverHandle_t GetDriverHandle() = 0;
+};
+
+/** This interface must be implemented in each driver. It will be loaded in vrserver.exe */
+class IServerTrackedDeviceProvider
+{
+public:
+	/** initializes the driver. This will be called before any other methods are called.
+	* If Init returns anything other than VRInitError_None the driver DLL will be unloaded.
+	*
+	* pDriverHost will never be NULL, and will always be a pointer to a IServerDriverHost interface
+	*
+	* pchUserDriverConfigDir - The absolute path of the directory where the driver should store user
+	*	config files.
+	* pchDriverInstallDir - The absolute path of the root directory for the driver.
+	*/
+	virtual EVRInitError Init(IVRDriverContext *pDriverContext) = 0;
+
+	/** cleans up the driver right before it is unloaded */
+	virtual void Cleanup() = 0;
+
+	/** Returns the version of the ITrackedDeviceServerDriver interface used by this driver */
+	virtual const char *const *GetInterfaceVersions() = 0;
+
+	/** Allows the driver do to some work in the main loop of the server. */
+	virtual void RunFrame() = 0;
+
+	// ------------  Power State Functions ----------------------- //
+
+	/** Returns true if the driver wants to block Standby mode. */
+	virtual bool ShouldBlockStandbyMode() = 0;
+
+	/** Called when the system is entering Standby mode. The driver should switch itself into whatever sort of low-power
+	* state it has. */
+	virtual void EnterStandby() = 0;
+
+	/** Called when the system is leaving Standby mode. The driver should switch itself back to
+	full operation. */
+	virtual void LeaveStandby() = 0;
+};
+
+static const char *IServerTrackedDeviceProvider_Version = "IServerTrackedDeviceProvider_004";
+
+/** This interface must be implemented in each driver. It will be loaded in vrclient.dll */
+class IVRWatchdogProvider
+{
+public:
+	/** initializes the driver in watchdog mode. */
+	virtual EVRInitError Init(IVRDriverContext *pDriverContext) = 0;
+
+	/** cleans up the driver right before it is unloaded */
+	virtual void Cleanup() = 0;
+};
+
+static const char *IVRWatchdogProvider_Version = "IVRWatchdogProvider_001";
+
+}  // namespace vr
+// ivrproperties.h
+#include <string>
+
+namespace vr
+{
+enum EPropertyWriteType
+{
+	PropertyWrite_Set = 0,
+	PropertyWrite_Erase = 1,
+	PropertyWrite_SetError = 2
+};
+
+struct PropertyWrite_t
+{
+	ETrackedDeviceProperty prop;
+	EPropertyWriteType writeType;
+	ETrackedPropertyError eSetError;
+	void *pvBuffer;
+	uint32_t unBufferSize;
+	PropertyTypeTag_t unTag;
+	ETrackedPropertyError eError;
+};
+
+struct PropertyRead_t
+{
+	ETrackedDeviceProperty prop;
+	void *pvBuffer;
+	uint32_t unBufferSize;
+	PropertyTypeTag_t unTag;
+	uint32_t unRequiredBufferSize;
+	ETrackedPropertyError eError;
+};
+
+class IVRProperties
+{
+public:
+	/** Reads a set of properties atomically. See the PropertyReadBatch_t struct for more information. */
+	virtual ETrackedPropertyError ReadPropertyBatch(PropertyContainerHandle_t ulContainerHandle, PropertyRead_t *pBatch, uint32_t unBatchEntryCount) = 0;
+
+	/** Writes a set of properties atomically. See the PropertyWriteBatch_t struct for more information. */
+	virtual ETrackedPropertyError WritePropertyBatch(PropertyContainerHandle_t ulContainerHandle, PropertyWrite_t *pBatch, uint32_t unBatchEntryCount) = 0;
+
+	/** returns a string that corresponds with the specified property error. The string will be the name
+	* of the error enum value for all valid error codes */
+	virtual const char *GetPropErrorNameFromEnum(ETrackedPropertyError error) = 0;
+
+	/** Returns a container handle given a tracked device index */
+	virtual PropertyContainerHandle_t TrackedDeviceToPropertyContainer(TrackedDeviceIndex_t nDevice) = 0;
+};
+
+static const char *const IVRProperties_Version = "IVRProperties_001";
+
+class CVRPropertyHelpers
+{
+public:
+	CVRPropertyHelpers(IVRProperties *pProperties) : m_pProperties(pProperties) {}
+
+	/** Returns a scaler property. If the device index is not valid or the property value type does not match,
+	* this function will return false. */
+	bool GetBoolProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L);
+	float GetFloatProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L);
+	int32_t GetInt32Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L);
+	uint64_t GetUint64Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L);
+
+	/** Returns a single typed property. If the device index is not valid or the property is not a string type this function will
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters. */
+	uint32_t GetProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, VR_OUT_STRING() void *pvBuffer, uint32_t unBufferSize, PropertyTypeTag_t *punTag, ETrackedPropertyError *pError = 0L);
+
+	/** Returns a string property. If the device index is not valid or the property is not a string type this function will
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters. */
+	uint32_t GetStringProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError = 0L);
+
+	/** Returns a string property as a std::string. If the device index is not valid or the property is not a string type this function will
+	* return an empty string. */
+	std::string GetStringProperty(vr::PropertyContainerHandle_t ulContainer, vr::ETrackedDeviceProperty prop, vr::ETrackedPropertyError *peError = nullptr);
+
+	/** Sets a scaler property. The new value will be returned on any subsequent call to get this property in any process. */
+	ETrackedPropertyError SetBoolProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, bool bNewValue);
+	ETrackedPropertyError SetFloatProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, float fNewValue);
+	ETrackedPropertyError SetInt32Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, int32_t nNewValue);
+	ETrackedPropertyError SetUint64Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, uint64_t ulNewValue);
+
+	/** Sets a string property. The new value will be returned on any subsequent call to get this property in any process. */
+	ETrackedPropertyError SetStringProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, const char *pchNewValue);
+
+	/** Sets a single typed property. The new value will be returned on any subsequent call to get this property in any process. */
+	ETrackedPropertyError SetProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, void *pvNewValue, uint32_t unNewValueSize, PropertyTypeTag_t unTag);
+
+	/** Sets the error return value for a property. This value will be returned on all subsequent requests to get the property */
+	ETrackedPropertyError SetPropertyError(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError eError);
+
+	/** Clears any value or error set for the property. */
+	ETrackedPropertyError EraseProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop);
+
+	/* Turns a device index into a property container handle. */
+	PropertyContainerHandle_t TrackedDeviceToPropertyContainer(TrackedDeviceIndex_t nDevice) { return m_pProperties->TrackedDeviceToPropertyContainer(nDevice); }
+
+private:
+	template <typename T>
+	T GetPropertyHelper(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError, T bDefault, PropertyTypeTag_t unTypeTag);
+
+	IVRProperties *m_pProperties;
+};
+
+inline uint32_t CVRPropertyHelpers::GetProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, VR_OUT_STRING() void *pvBuffer, uint32_t unBufferSize, PropertyTypeTag_t *punTag, ETrackedPropertyError *pError)
+{
+	PropertyRead_t batch;
+	batch.prop = prop;
+	batch.pvBuffer = pvBuffer;
+	batch.unBufferSize = unBufferSize;
+
+	m_pProperties->ReadPropertyBatch(ulContainerHandle, &batch, 1);
+
+	if (pError)
+	{
+		*pError = batch.eError;
+	}
+
+	if (punTag)
+	{
+		*punTag = batch.unTag;
+	}
+
+	return batch.unRequiredBufferSize;
+}
+
+/** Sets a single typed property. The new value will be returned on any subsequent call to get this property in any process. */
+inline ETrackedPropertyError CVRPropertyHelpers::SetProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, void *pvNewValue, uint32_t unNewValueSize, PropertyTypeTag_t unTag)
+{
+	PropertyWrite_t batch;
+	batch.writeType = PropertyWrite_Set;
+	batch.prop = prop;
+	batch.pvBuffer = pvNewValue;
+	batch.unBufferSize = unNewValueSize;
+	batch.unTag = unTag;
+
+	m_pProperties->WritePropertyBatch(ulContainerHandle, &batch, 1);
+
+	return batch.eError;
+}
+
+/** Returns a string property. If the device index is not valid or the property is not a string type this function will
+* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+* null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters. */
+inline uint32_t CVRPropertyHelpers::GetStringProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError)
+{
+	PropertyTypeTag_t unTag;
+	ETrackedPropertyError error;
+	uint32_t unRequiredSize = GetProperty(ulContainerHandle, prop, pchValue, unBufferSize, &unTag, &error);
+	if (unTag != k_unStringPropertyTag && error == TrackedProp_Success)
+	{
+		error = TrackedProp_WrongDataType;
+	}
+
+	if (pError)
+	{
+		*pError = error;
+	}
+
+	if (error != TrackedProp_Success)
+	{
+		if (pchValue && unBufferSize)
+		{
+			*pchValue = '\0';
+		}
+	}
+
+	return unRequiredSize;
+}
+
+/** Returns a string property as a std::string. If the device index is not valid or the property is not a string type this function will
+* return an empty string. */
+inline std::string CVRPropertyHelpers::GetStringProperty(vr::PropertyContainerHandle_t ulContainer, vr::ETrackedDeviceProperty prop, vr::ETrackedPropertyError *peError)
+{
+	char buf[1024];
+	vr::ETrackedPropertyError err;
+	uint32_t unRequiredBufferLen = GetStringProperty(ulContainer, prop, buf, sizeof(buf), &err);
+
+	std::string sResult;
+
+	if (err == TrackedProp_Success)
+	{
+		sResult = buf;
+	}
+	else if (err == TrackedProp_BufferTooSmall)
+	{
+		char *pchBuffer = new char[unRequiredBufferLen];
+		unRequiredBufferLen = GetStringProperty(ulContainer, prop, pchBuffer, unRequiredBufferLen, &err);
+		sResult = pchBuffer;
+		delete[] pchBuffer;
+	}
+
+	if (peError)
+	{
+		*peError = err;
+	}
+
+	return sResult;
+}
+
+/** Sets a string property. The new value will be returned on any subsequent call to get this property in any process. */
+inline ETrackedPropertyError CVRPropertyHelpers::SetStringProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, const char *pchNewValue)
+{
+	if (!pchNewValue)
+		return TrackedProp_InvalidOperation;
+
+	// this is strlen without the dependency on string.h
+	const char *pchCurr = pchNewValue;
+	while (*pchCurr)
+	{
+		pchCurr++;
+	}
+
+	return SetProperty(ulContainerHandle, prop, (void *)pchNewValue, (uint32_t)(pchCurr - pchNewValue) + 1, k_unStringPropertyTag);
+}
+
+template <typename T>
+inline T CVRPropertyHelpers::GetPropertyHelper(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError, T bDefault, PropertyTypeTag_t unTypeTag)
+{
+	T bValue;
+	ETrackedPropertyError eError;
+	PropertyTypeTag_t unReadTag;
+	GetProperty(ulContainerHandle, prop, &bValue, sizeof(bValue), &unReadTag, &eError);
+	if (unReadTag != unTypeTag && eError == TrackedProp_Success)
+	{
+		eError = TrackedProp_WrongDataType;
+	};
+
+	if (pError)
+		*pError = eError;
+	if (eError != TrackedProp_Success)
+	{
+		return bDefault;
+	}
+	else
+	{
+		return bValue;
+	}
+}
+
+inline bool CVRPropertyHelpers::GetBoolProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError)
+{
+	return GetPropertyHelper<bool>(ulContainerHandle, prop, pError, false, k_unBoolPropertyTag);
+}
+
+inline float CVRPropertyHelpers::GetFloatProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError)
+{
+	return GetPropertyHelper<float>(ulContainerHandle, prop, pError, 0.f, k_unFloatPropertyTag);
+}
+
+inline int32_t CVRPropertyHelpers::GetInt32Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError)
+{
+	return GetPropertyHelper<int32_t>(ulContainerHandle, prop, pError, 0, k_unInt32PropertyTag);
+}
+
+inline uint64_t CVRPropertyHelpers::GetUint64Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError)
+{
+	return GetPropertyHelper<uint64_t>(ulContainerHandle, prop, pError, 0, k_unUint64PropertyTag);
+}
+
+inline ETrackedPropertyError CVRPropertyHelpers::SetBoolProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, bool bNewValue)
+{
+	return SetProperty(ulContainerHandle, prop, &bNewValue, sizeof(bNewValue), k_unBoolPropertyTag);
+}
+
+inline ETrackedPropertyError CVRPropertyHelpers::SetFloatProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, float fNewValue)
+{
+	return SetProperty(ulContainerHandle, prop, &fNewValue, sizeof(fNewValue), k_unFloatPropertyTag);
+}
+
+inline ETrackedPropertyError CVRPropertyHelpers::SetInt32Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, int32_t nNewValue)
+{
+	return SetProperty(ulContainerHandle, prop, &nNewValue, sizeof(nNewValue), k_unInt32PropertyTag);
+}
+
+inline ETrackedPropertyError CVRPropertyHelpers::SetUint64Property(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, uint64_t ulNewValue)
+{
+	return SetProperty(ulContainerHandle, prop, &ulNewValue, sizeof(ulNewValue), k_unUint64PropertyTag);
+}
+
+/** Sets the error return value for a property. This value will be returned on all subsequent requests to get the property */
+inline ETrackedPropertyError CVRPropertyHelpers::SetPropertyError(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError eError)
+{
+	PropertyWrite_t batch;
+	batch.writeType = PropertyWrite_SetError;
+	batch.prop = prop;
+	batch.eSetError = eError;
+
+	m_pProperties->WritePropertyBatch(ulContainerHandle, &batch, 1);
+
+	return batch.eError;
+}
+
+/** Clears any value or error set for the property. */
+inline ETrackedPropertyError CVRPropertyHelpers::EraseProperty(PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop)
+{
+	PropertyWrite_t batch;
+	batch.writeType = PropertyWrite_Erase;
+	batch.prop = prop;
+
+	m_pProperties->WritePropertyBatch(ulContainerHandle, &batch, 1);
+
+	return batch.eError;
+}
+
+}  // namespace vr
+
+// ivrdriverlog.h
+namespace vr
+{
+class IVRDriverLog
+{
+public:
+	/** Writes a log message to the log file prefixed with the driver name */
+	virtual void Log(const char *pchLogMessage) = 0;
+};
+
+static const char *IVRDriverLog_Version = "IVRDriverLog_001";
+
+}  // namespace vr
+// ivrserverdriverhost.h
+namespace vr
+{
+class ITrackedDeviceServerDriver;
+struct TrackedDeviceDriverInfo_t;
+struct DriverPose_t;
+
+/** This interface is provided by vrserver to allow the driver to notify 
+* the system when something changes about a device. These changes must
+* not change the serial number or class of the device because those values
+* are permanently associated with the device's index. */
+class IVRServerDriverHost
+{
+public:
+	/** Notifies the server that a tracked device has been added. If this function returns true
+	* the server will call Activate on the device. If it returns false some kind of error
+	* has occurred and the device will not be activated. */
+	virtual bool TrackedDeviceAdded(const char *pchDeviceSerialNumber, ETrackedDeviceClass eDeviceClass, ITrackedDeviceServerDriver *pDriver) = 0;
+
+	/** Notifies the server that a tracked device's pose has been updated */
+	virtual void TrackedDevicePoseUpdated(uint32_t unWhichDevice, const DriverPose_t &newPose, uint32_t unPoseStructSize) = 0;
+
+	/** Notifies the server that vsync has occurred on the the display attached to the device. This is
+	* only permitted on devices of the HMD class. */
+	virtual void VsyncEvent(double vsyncTimeOffsetSeconds) = 0;
+
+	/** notifies the server that the button was pressed */
+	virtual void TrackedDeviceButtonPressed(uint32_t unWhichDevice, EVRButtonId eButtonId, double eventTimeOffset) = 0;
+
+	/** notifies the server that the button was unpressed */
+	virtual void TrackedDeviceButtonUnpressed(uint32_t unWhichDevice, EVRButtonId eButtonId, double eventTimeOffset) = 0;
+
+	/** notifies the server that the button was pressed */
+	virtual void TrackedDeviceButtonTouched(uint32_t unWhichDevice, EVRButtonId eButtonId, double eventTimeOffset) = 0;
+
+	/** notifies the server that the button was unpressed */
+	virtual void TrackedDeviceButtonUntouched(uint32_t unWhichDevice, EVRButtonId eButtonId, double eventTimeOffset) = 0;
+
+	/** notifies the server than a controller axis changed */
+	virtual void TrackedDeviceAxisUpdated(uint32_t unWhichDevice, uint32_t unWhichAxis, const VRControllerAxis_t &axisState) = 0;
+
+	/** Notifies the server that the proximity sensor on the specified device  */
+	virtual void ProximitySensorState(uint32_t unWhichDevice, bool bProximitySensorTriggered) = 0;
+
+	/** Sends a vendor specific event (VREvent_VendorSpecific_Reserved_Start..VREvent_VendorSpecific_Reserved_End */
+	virtual void VendorSpecificEvent(uint32_t unWhichDevice, vr::EVREventType eventType, const VREvent_Data_t &eventData, double eventTimeOffset) = 0;
+
+	/** Returns true if SteamVR is exiting */
+	virtual bool IsExiting() = 0;
+
+	/** Returns true and fills the event with the next event on the queue if there is one. If there are no events
+	* this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct */
+	virtual bool PollNextEvent(VREvent_t *pEvent, uint32_t uncbVREvent) = 0;
+
+	/** Provides access to device poses for drivers.  Poses are in their "raw" tracking space which is uniquely
+	* defined by each driver providing poses for its devices.  It is up to clients of this function to correlate
+	* poses across different drivers.  Poses are indexed by their device id, and their associated driver and
+	* other properties can be looked up via IVRProperties. */
+	virtual void GetRawTrackedDevicePoses(float fPredictedSecondsFromNow, TrackedDevicePose_t *pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = 0;
+
+	/** Notifies the server that a tracked device's display component transforms have been updated. */
+	virtual void TrackedDeviceDisplayTransformUpdated(uint32_t unWhichDevice, HmdMatrix34_t eyeToHeadLeft, HmdMatrix34_t eyeToHeadRight) = 0;
+};
+
+static const char *IVRServerDriverHost_Version = "IVRServerDriverHost_004";
+
+}  // namespace vr
+
+// ivrhiddenarea.h
+namespace vr
+{
+class CVRHiddenAreaHelpers
+{
+public:
+	CVRHiddenAreaHelpers(IVRProperties *pProperties) : m_pProperties(pProperties) {}
+
+	/** Stores a hidden area mesh in a property */
+	ETrackedPropertyError SetHiddenArea(EVREye eEye, EHiddenAreaMeshType type, HmdVector2_t *pVerts, uint32_t unVertCount);
+
+	/** retrieves a hidden area mesh from a property. Returns the vert count read out of the property.  */
+	uint32_t GetHiddenArea(EVREye eEye, EHiddenAreaMeshType type, HmdVector2_t *pVerts, uint32_t unVertCount, ETrackedPropertyError *peError);
+
+private:
+	ETrackedDeviceProperty GetPropertyEnum(EVREye eEye, EHiddenAreaMeshType type)
+	{
+		return (ETrackedDeviceProperty)(Prop_DisplayHiddenArea_Binary_Start + ((int)type * 2) + (int)eEye);
+	}
+
+	IVRProperties *m_pProperties;
+};
+
+inline ETrackedPropertyError CVRHiddenAreaHelpers::SetHiddenArea(EVREye eEye, EHiddenAreaMeshType type, HmdVector2_t *pVerts, uint32_t unVertCount)
+{
+	ETrackedDeviceProperty prop = GetPropertyEnum(eEye, type);
+	CVRPropertyHelpers propHelpers(m_pProperties);
+	return propHelpers.SetProperty(propHelpers.TrackedDeviceToPropertyContainer(k_unTrackedDeviceIndex_Hmd), prop, pVerts, sizeof(HmdVector2_t) * unVertCount, k_unHiddenAreaPropertyTag);
+}
+
+inline uint32_t CVRHiddenAreaHelpers::GetHiddenArea(EVREye eEye, EHiddenAreaMeshType type, HmdVector2_t *pVerts, uint32_t unVertCount, ETrackedPropertyError *peError)
+{
+	ETrackedDeviceProperty prop = GetPropertyEnum(eEye, type);
+	CVRPropertyHelpers propHelpers(m_pProperties);
+	ETrackedPropertyError propError;
+	PropertyTypeTag_t unTag;
+	uint32_t unBytesNeeded = propHelpers.GetProperty(propHelpers.TrackedDeviceToPropertyContainer(k_unTrackedDeviceIndex_Hmd), prop, pVerts, sizeof(HmdVector2_t) * unVertCount, &unTag, &propError);
+	if (propError == TrackedProp_Success && unTag != k_unHiddenAreaPropertyTag)
+	{
+		propError = TrackedProp_WrongDataType;
+		unBytesNeeded = 0;
+	}
+
+	if (peError)
+	{
+		*peError = propError;
+	}
+
+	return unBytesNeeded / sizeof(HmdVector2_t);
+}
+
+}  // namespace vr
+// ivrwatchdoghost.h
+namespace vr
+{
+/** This interface is provided by vrclient to allow the driver to make everything wake up */
+class IVRWatchdogHost
+{
+public:
+	/** Client drivers in watchdog mode should call this when they have received a signal from hardware that should
+	* cause SteamVR to start */
+	virtual void WatchdogWakeUp() = 0;
+};
+
+static const char *IVRWatchdogHost_Version = "IVRWatchdogHost_001";
+
+};  // namespace vr
+
+// ivrvirtualdisplay.h
+namespace vr
+{
+// ----------------------------------------------------------------------------------------------
+// Purpose: This component is used for drivers that implement a virtual display (e.g. wireless).
+// ----------------------------------------------------------------------------------------------
+class IVRVirtualDisplay
+{
+public:
+	/** Submits final backbuffer for display. */
+	virtual void Present(vr::SharedTextureHandle_t backbufferTextureHandle) = 0;
+
+	/** Block until the last presented buffer start scanning out. */
+	virtual void WaitForPresent() = 0;
+
+	/** Provides timing data for synchronizing with display. */
+	virtual bool GetTimeSinceLastVsync(float *pfSecondsSinceLastVsync, uint64_t *pulFrameCounter) = 0;
+};
+
+static const char *IVRVirtualDisplay_Version = "IVRVirtualDisplay_001";
+
+/** Returns the current IVRVirtualDisplay pointer or NULL the interface could not be found. */
+VR_INTERFACE vr::IVRVirtualDisplay *VR_CALLTYPE VRVirtualDisplay();
+}  // namespace vr
+
+// ivrresources.h
+namespace vr
+{
+class IVRResources
+{
+public:
+	// ------------------------------------
+	// Shared Resource Methods
+	// ------------------------------------
+
+	/** Loads the specified resource into the provided buffer if large enough.
+	* Returns the size in bytes of the buffer required to hold the specified resource. */
+	virtual uint32_t LoadSharedResource(const char *pchResourceName, char *pchBuffer, uint32_t unBufferLen) = 0;
+
+	/** Provides the full path to the specified resource. Resource names can include named directories for
+	* drivers and other things, and this resolves all of those and returns the actual physical path. 
+	* pchResourceTypeDirectory is the subdirectory of resources to look in. */
+	virtual uint32_t GetResourceFullPath(const char *pchResourceName, const char *pchResourceTypeDirectory, char *pchPathBuffer, uint32_t unBufferLen) = 0;
+};
+
+static const char *const IVRResources_Version = "IVRResources_001";
+
+}  // namespace vr
+// ivrdrivermanager.h
+namespace vr
+{
+class IVRDriverManager
+{
+public:
+	virtual uint32_t GetDriverCount() const = 0;
+
+	/** Returns the length of the number of bytes necessary to hold this string including the trailing null. */
+	virtual uint32_t GetDriverName(vr::DriverId_t nDriver, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize) = 0;
+};
+
+static const char *const IVRDriverManager_Version = "IVRDriverManager_001";
+
+}  // namespace vr
+
+namespace vr
+{
+static const char *const k_InterfaceVersions[] =
+	{
+		IVRSettings_Version,
+		ITrackedDeviceServerDriver_Version,
+		IVRDisplayComponent_Version,
+		IVRDriverDirectModeComponent_Version,
+		IVRControllerComponent_Version,
+		IVRCameraComponent_Version,
+		IServerTrackedDeviceProvider_Version,
+		IVRWatchdogProvider_Version,
+		IVRVirtualDisplay_Version,
+		IVRDriverManager_Version,
+		IVRResources_Version,
+		nullptr};
+
+inline IVRDriverContext *&VRDriverContext()
+{
+	static IVRDriverContext *pHost;
+	return pHost;
+}
+
+class COpenVRDriverContext
+{
+public:
+	COpenVRDriverContext() : m_propertyHelpers(nullptr), m_hiddenAreaHelpers(nullptr) { Clear(); }
+	void Clear();
+
+	EVRInitError InitServer();
+	EVRInitError InitWatchdog();
+
+	IVRSettings *VRSettings()
+	{
+		if (m_pVRSettings == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRSettings = (IVRSettings *)VRDriverContext()->GetGenericInterface(IVRSettings_Version, &eError);
+		}
+		return m_pVRSettings;
+	}
+
+	IVRProperties *VRPropertiesRaw()
+	{
+		if (m_pVRProperties == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRProperties = (IVRProperties *)VRDriverContext()->GetGenericInterface(IVRProperties_Version, &eError);
+			m_propertyHelpers = CVRPropertyHelpers(m_pVRProperties);
+			m_hiddenAreaHelpers = CVRHiddenAreaHelpers(m_pVRProperties);
+		}
+		return m_pVRProperties;
+	}
+
+	CVRPropertyHelpers *VRProperties()
+	{
+		VRPropertiesRaw();
+		return &m_propertyHelpers;
+	}
+
+	CVRHiddenAreaHelpers *VRHiddenArea()
+	{
+		VRPropertiesRaw();
+		return &m_hiddenAreaHelpers;
+	}
+
+	IVRServerDriverHost *VRServerDriverHost()
+	{
+		if (m_pVRServerDriverHost == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRServerDriverHost = (IVRServerDriverHost *)VRDriverContext()->GetGenericInterface(IVRServerDriverHost_Version, &eError);
+		}
+		return m_pVRServerDriverHost;
+	}
+
+	IVRWatchdogHost *VRWatchdogHost()
+	{
+		if (m_pVRWatchdogHost == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRWatchdogHost = (IVRWatchdogHost *)VRDriverContext()->GetGenericInterface(IVRWatchdogHost_Version, &eError);
+		}
+		return m_pVRWatchdogHost;
+	}
+
+	IVRDriverLog *VRDriverLog()
+	{
+		if (m_pVRDriverLog == nullptr)
+		{
+			EVRInitError eError;
+			m_pVRDriverLog = (IVRDriverLog *)VRDriverContext()->GetGenericInterface(IVRDriverLog_Version, &eError);
+		}
+		return m_pVRDriverLog;
+	}
+
+	DriverHandle_t VR_CALLTYPE VRDriverHandle()
+	{
+		return VRDriverContext()->GetDriverHandle();
+	}
+
+	IVRDriverManager *VRDriverManager()
+	{
+		if (!m_pVRDriverManager)
+		{
+			EVRInitError eError;
+			m_pVRDriverManager = (IVRDriverManager *)VRDriverContext()->GetGenericInterface(IVRDriverManager_Version, &eError);
+		}
+		return m_pVRDriverManager;
+	}
+
+	IVRResources *VRResources()
+	{
+		if (!m_pVRResources)
+		{
+			EVRInitError eError;
+			m_pVRResources = (IVRResources *)VRDriverContext()->GetGenericInterface(IVRResources_Version, &eError);
+		}
+		return m_pVRResources;
+	}
+
+private:
+	CVRPropertyHelpers m_propertyHelpers;
+	CVRHiddenAreaHelpers m_hiddenAreaHelpers;
+
+	IVRSettings *m_pVRSettings;
+	IVRProperties *m_pVRProperties;
+	IVRServerDriverHost *m_pVRServerDriverHost;
+	IVRWatchdogHost *m_pVRWatchdogHost;
+	IVRDriverLog *m_pVRDriverLog;
+	IVRDriverManager *m_pVRDriverManager;
+	IVRResources *m_pVRResources;
+};
+
+inline COpenVRDriverContext &OpenVRInternal_ModuleServerDriverContext()
+{
+	static void *ctx[sizeof(COpenVRDriverContext) / sizeof(void *)];
+	return *(COpenVRDriverContext *)ctx;  // bypass zero-init constructor
+}
+
+inline IVRSettings *VR_CALLTYPE VRSettings() { return OpenVRInternal_ModuleServerDriverContext().VRSettings(); }
+inline IVRProperties *VR_CALLTYPE VRPropertiesRaw() { return OpenVRInternal_ModuleServerDriverContext().VRPropertiesRaw(); }
+inline CVRPropertyHelpers *VR_CALLTYPE VRProperties() { return OpenVRInternal_ModuleServerDriverContext().VRProperties(); }
+inline CVRHiddenAreaHelpers *VR_CALLTYPE VRHiddenArea() { return OpenVRInternal_ModuleServerDriverContext().VRHiddenArea(); }
+inline IVRDriverLog *VR_CALLTYPE VRDriverLog() { return OpenVRInternal_ModuleServerDriverContext().VRDriverLog(); }
+inline IVRServerDriverHost *VR_CALLTYPE VRServerDriverHost() { return OpenVRInternal_ModuleServerDriverContext().VRServerDriverHost(); }
+inline IVRWatchdogHost *VR_CALLTYPE VRWatchdogHost() { return OpenVRInternal_ModuleServerDriverContext().VRWatchdogHost(); }
+inline DriverHandle_t VR_CALLTYPE VRDriverHandle() { return OpenVRInternal_ModuleServerDriverContext().VRDriverHandle(); }
+inline IVRDriverManager *VR_CALLTYPE VRDriverManager() { return OpenVRInternal_ModuleServerDriverContext().VRDriverManager(); }
+inline IVRResources *VR_CALLTYPE VRResources() { return OpenVRInternal_ModuleServerDriverContext().VRResources(); }
+
+inline void COpenVRDriverContext::Clear()
+{
+	m_pVRSettings = nullptr;
+	m_pVRProperties = nullptr;
+	m_pVRServerDriverHost = nullptr;
+	m_pVRDriverLog = nullptr;
+	m_pVRWatchdogHost = nullptr;
+	m_pVRDriverManager = nullptr;
+	m_pVRResources = nullptr;
+}
+
+inline EVRInitError COpenVRDriverContext::InitServer()
+{
+	Clear();
+	if (!VRServerDriverHost() || !VRSettings() || !VRProperties() || !VRDriverLog() || !VRDriverManager() || !VRResources())
+		return VRInitError_Init_InterfaceNotFound;
+	return VRInitError_None;
+}
+
+inline EVRInitError COpenVRDriverContext::InitWatchdog()
+{
+	Clear();
+	if (!VRWatchdogHost() || !VRSettings() || !VRDriverLog())
+		return VRInitError_Init_InterfaceNotFound;
+	return VRInitError_None;
+}
+
+inline EVRInitError InitServerDriverContext(IVRDriverContext *pContext)
+{
+	VRDriverContext() = pContext;
+	return OpenVRInternal_ModuleServerDriverContext().InitServer();
+}
+
+inline EVRInitError InitWatchdogDriverContext(IVRDriverContext *pContext)
+{
+	VRDriverContext() = pContext;
+	return OpenVRInternal_ModuleServerDriverContext().InitWatchdog();
+}
+
+inline void CleanupDriverContext()
+{
+	VRDriverContext() = nullptr;
+	OpenVRInternal_ModuleServerDriverContext().Clear();
+}
+
+#define VR_INIT_SERVER_DRIVER_CONTEXT(pContext)                          \
+	{                                                                    \
+		vr::EVRInitError eError = vr::InitServerDriverContext(pContext); \
+		if (eError != vr::VRInitError_None)                              \
+			return eError;                                               \
+	}
+
+#define VR_CLEANUP_SERVER_DRIVER_CONTEXT() \
+	vr::CleanupDriverContext();
+
+#define VR_INIT_WATCHDOG_DRIVER_CONTEXT(pContext)                          \
+	{                                                                      \
+		vr::EVRInitError eError = vr::InitWatchdogDriverContext(pContext); \
+		if (eError != vr::VRInitError_None)                                \
+			return eError;                                                 \
+	}
+
+#define VR_CLEANUP_WATCHDOG_DRIVER_CONTEXT() \
+	vr::CleanupDriverContext();
+}  // namespace vr
+// End
+
+#endif  // _OPENVR_DRIVER_API
diff --git a/engine/inc/bullet/ThirdPartyLibs/openvr/samples/shared/Matrices.h b/engine/inc/bullet/ThirdPartyLibs/openvr/samples/shared/Matrices.h
new file mode 100644
index 00000000..6d1cf432
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/openvr/samples/shared/Matrices.h
@@ -0,0 +1,855 @@
+///////////////////////////////////////////////////////////////////////////////
+// Matrice.h
+// =========
+// NxN Matrix Math classes
+//
+// The elements of the matrix are stored as column major order.
+// | 0 2 |    | 0 3 6 |    |  0  4  8 12 |
+// | 1 3 |    | 1 4 7 |    |  1  5  9 13 |
+//            | 2 5 8 |    |  2  6 10 14 |
+//                         |  3  7 11 15 |
+//
+//  AUTHOR: Song Ho Ahn (song.ahn@gmail.com)
+// CREATED: 2005-06-24
+// UPDATED: 2013-09-30
+//
+// Copyright (C) 2005 Song Ho Ahn
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef MATH_MATRICES_H
+#define MATH_MATRICES_H
+
+#include <iostream>
+#include <iomanip>
+#include "Vectors.h"
+
+///////////////////////////////////////////////////////////////////////////
+// 2x2 matrix
+///////////////////////////////////////////////////////////////////////////
+class Matrix2
+{
+public:
+	// constructors
+	Matrix2();  // init with identity
+	Matrix2(const float src[4]);
+	Matrix2(float m0, float m1, float m2, float m3);
+
+	void set(const float src[4]);
+	void set(float m0, float m1, float m2, float m3);
+	void setRow(int index, const float row[2]);
+	void setRow(int index, const Vector2& v);
+	void setColumn(int index, const float col[2]);
+	void setColumn(int index, const Vector2& v);
+
+	const float* get() const;
+	float getDeterminant();
+
+	Matrix2& identity();
+	Matrix2& transpose();  // transpose itself and return reference
+	Matrix2& invert();
+
+	// operators
+	Matrix2 operator+(const Matrix2& rhs) const;  // add rhs
+	Matrix2 operator-(const Matrix2& rhs) const;  // subtract rhs
+	Matrix2& operator+=(const Matrix2& rhs);      // add rhs and update this object
+	Matrix2& operator-=(const Matrix2& rhs);      // subtract rhs and update this object
+	Vector2 operator*(const Vector2& rhs) const;  // multiplication: v' = M * v
+	Matrix2 operator*(const Matrix2& rhs) const;  // multiplication: M3 = M1 * M2
+	Matrix2& operator*=(const Matrix2& rhs);      // multiplication: M1' = M1 * M2
+	bool operator==(const Matrix2& rhs) const;    // exact compare, no epsilon
+	bool operator!=(const Matrix2& rhs) const;    // exact compare, no epsilon
+	float operator[](int index) const;            // subscript operator v[0], v[1]
+	float& operator[](int index);                 // subscript operator v[0], v[1]
+
+	friend Matrix2 operator-(const Matrix2& m);                      // unary operator (-)
+	friend Matrix2 operator*(float scalar, const Matrix2& m);        // pre-multiplication
+	friend Vector2 operator*(const Vector2& vec, const Matrix2& m);  // pre-multiplication
+	friend std::ostream& operator<<(std::ostream& os, const Matrix2& m);
+
+protected:
+private:
+	float m[4];
+};
+
+///////////////////////////////////////////////////////////////////////////
+// 3x3 matrix
+///////////////////////////////////////////////////////////////////////////
+class Matrix3
+{
+public:
+	// constructors
+	Matrix3();  // init with identity
+	Matrix3(const float src[9]);
+	Matrix3(float m0, float m1, float m2,   // 1st column
+			float m3, float m4, float m5,   // 2nd column
+			float m6, float m7, float m8);  // 3rd column
+
+	void set(const float src[9]);
+	void set(float m0, float m1, float m2,   // 1st column
+			 float m3, float m4, float m5,   // 2nd column
+			 float m6, float m7, float m8);  // 3rd column
+	void setRow(int index, const float row[3]);
+	void setRow(int index, const Vector3& v);
+	void setColumn(int index, const float col[3]);
+	void setColumn(int index, const Vector3& v);
+
+	const float* get() const;
+	float getDeterminant();
+
+	Matrix3& identity();
+	Matrix3& transpose();  // transpose itself and return reference
+	Matrix3& invert();
+
+	// operators
+	Matrix3 operator+(const Matrix3& rhs) const;  // add rhs
+	Matrix3 operator-(const Matrix3& rhs) const;  // subtract rhs
+	Matrix3& operator+=(const Matrix3& rhs);      // add rhs and update this object
+	Matrix3& operator-=(const Matrix3& rhs);      // subtract rhs and update this object
+	Vector3 operator*(const Vector3& rhs) const;  // multiplication: v' = M * v
+	Matrix3 operator*(const Matrix3& rhs) const;  // multiplication: M3 = M1 * M2
+	Matrix3& operator*=(const Matrix3& rhs);      // multiplication: M1' = M1 * M2
+	bool operator==(const Matrix3& rhs) const;    // exact compare, no epsilon
+	bool operator!=(const Matrix3& rhs) const;    // exact compare, no epsilon
+	float operator[](int index) const;            // subscript operator v[0], v[1]
+	float& operator[](int index);                 // subscript operator v[0], v[1]
+
+	friend Matrix3 operator-(const Matrix3& m);                      // unary operator (-)
+	friend Matrix3 operator*(float scalar, const Matrix3& m);        // pre-multiplication
+	friend Vector3 operator*(const Vector3& vec, const Matrix3& m);  // pre-multiplication
+	friend std::ostream& operator<<(std::ostream& os, const Matrix3& m);
+
+protected:
+private:
+	float m[9];
+};
+
+///////////////////////////////////////////////////////////////////////////
+// 4x4 matrix
+///////////////////////////////////////////////////////////////////////////
+class Matrix4
+{
+public:
+	// constructors
+	Matrix4();  // init with identity
+	Matrix4(const float src[16]);
+	Matrix4(float m00, float m01, float m02, float m03,   // 1st column
+			float m04, float m05, float m06, float m07,   // 2nd column
+			float m08, float m09, float m10, float m11,   // 3rd column
+			float m12, float m13, float m14, float m15);  // 4th column
+
+	void set(const float src[16]);
+	void set(float m00, float m01, float m02, float m03,   // 1st column
+			 float m04, float m05, float m06, float m07,   // 2nd column
+			 float m08, float m09, float m10, float m11,   // 3rd column
+			 float m12, float m13, float m14, float m15);  // 4th column
+	void setRow(int index, const float row[4]);
+	void setRow(int index, const Vector4& v);
+	void setRow(int index, const Vector3& v);
+	void setColumn(int index, const float col[4]);
+	void setColumn(int index, const Vector4& v);
+	void setColumn(int index, const Vector3& v);
+
+	const float* get() const;
+	const float* getTranspose();  // return transposed matrix
+	float getDeterminant();
+
+	Matrix4& identity();
+	Matrix4& transpose();         // transpose itself and return reference
+	Matrix4& invert();            // check best inverse method before inverse
+	Matrix4& invertEuclidean();   // inverse of Euclidean transform matrix
+	Matrix4& invertAffine();      // inverse of affine transform matrix
+	Matrix4& invertProjective();  // inverse of projective matrix using partitioning
+	Matrix4& invertGeneral();     // inverse of generic matrix
+
+	// transform matrix
+	Matrix4& translate(float x, float y, float z);      // translation by (x,y,z)
+	Matrix4& translate(const Vector3& v);               //
+	Matrix4& rotate(float angle, const Vector3& axis);  // rotate angle(degree) along the given axix
+	Matrix4& rotate(float angle, float x, float y, float z);
+	Matrix4& rotateX(float angle);                 // rotate on X-axis with degree
+	Matrix4& rotateY(float angle);                 // rotate on Y-axis with degree
+	Matrix4& rotateZ(float angle);                 // rotate on Z-axis with degree
+	Matrix4& scale(float scale);                   // uniform scale
+	Matrix4& scale(float sx, float sy, float sz);  // scale by (sx, sy, sz) on each axis
+
+	// operators
+	Matrix4 operator+(const Matrix4& rhs) const;  // add rhs
+	Matrix4 operator-(const Matrix4& rhs) const;  // subtract rhs
+	Matrix4& operator+=(const Matrix4& rhs);      // add rhs and update this object
+	Matrix4& operator-=(const Matrix4& rhs);      // subtract rhs and update this object
+	Vector4 operator*(const Vector4& rhs) const;  // multiplication: v' = M * v
+	Vector3 operator*(const Vector3& rhs) const;  // multiplication: v' = M * v
+	Matrix4 operator*(const Matrix4& rhs) const;  // multiplication: M3 = M1 * M2
+	Matrix4& operator*=(const Matrix4& rhs);      // multiplication: M1' = M1 * M2
+	bool operator==(const Matrix4& rhs) const;    // exact compare, no epsilon
+	bool operator!=(const Matrix4& rhs) const;    // exact compare, no epsilon
+	float operator[](int index) const;            // subscript operator v[0], v[1]
+	float& operator[](int index);                 // subscript operator v[0], v[1]
+
+	friend Matrix4 operator-(const Matrix4& m);                      // unary operator (-)
+	friend Matrix4 operator*(float scalar, const Matrix4& m);        // pre-multiplication
+	friend Vector3 operator*(const Vector3& vec, const Matrix4& m);  // pre-multiplication
+	friend Vector4 operator*(const Vector4& vec, const Matrix4& m);  // pre-multiplication
+	friend std::ostream& operator<<(std::ostream& os, const Matrix4& m);
+
+protected:
+private:
+	float getCofactor(float m0, float m1, float m2,
+					  float m3, float m4, float m5,
+					  float m6, float m7, float m8);
+
+	float m[16];
+	float tm[16];  // transpose m
+};
+
+///////////////////////////////////////////////////////////////////////////
+// inline functions for Matrix2
+///////////////////////////////////////////////////////////////////////////
+inline Matrix2::Matrix2()
+{
+	// initially identity matrix
+	identity();
+}
+
+inline Matrix2::Matrix2(const float src[4])
+{
+	set(src);
+}
+
+inline Matrix2::Matrix2(float m0, float m1, float m2, float m3)
+{
+	set(m0, m1, m2, m3);
+}
+
+inline void Matrix2::set(const float src[4])
+{
+	m[0] = src[0];
+	m[1] = src[1];
+	m[2] = src[2];
+	m[3] = src[3];
+}
+
+inline void Matrix2::set(float m0, float m1, float m2, float m3)
+{
+	m[0] = m0;
+	m[1] = m1;
+	m[2] = m2;
+	m[3] = m3;
+}
+
+inline void Matrix2::setRow(int index, const float row[2])
+{
+	m[index] = row[0];
+	m[index + 2] = row[1];
+}
+
+inline void Matrix2::setRow(int index, const Vector2& v)
+{
+	m[index] = v.x;
+	m[index + 2] = v.y;
+}
+
+inline void Matrix2::setColumn(int index, const float col[2])
+{
+	m[index * 2] = col[0];
+	m[index * 2 + 1] = col[1];
+}
+
+inline void Matrix2::setColumn(int index, const Vector2& v)
+{
+	m[index * 2] = v.x;
+	m[index * 2 + 1] = v.y;
+}
+
+inline const float* Matrix2::get() const
+{
+	return m;
+}
+
+inline Matrix2& Matrix2::identity()
+{
+	m[0] = m[3] = 1.0f;
+	m[1] = m[2] = 0.0f;
+	return *this;
+}
+
+inline Matrix2 Matrix2::operator+(const Matrix2& rhs) const
+{
+	return Matrix2(m[0] + rhs[0], m[1] + rhs[1], m[2] + rhs[2], m[3] + rhs[3]);
+}
+
+inline Matrix2 Matrix2::operator-(const Matrix2& rhs) const
+{
+	return Matrix2(m[0] - rhs[0], m[1] - rhs[1], m[2] - rhs[2], m[3] - rhs[3]);
+}
+
+inline Matrix2& Matrix2::operator+=(const Matrix2& rhs)
+{
+	m[0] += rhs[0];
+	m[1] += rhs[1];
+	m[2] += rhs[2];
+	m[3] += rhs[3];
+	return *this;
+}
+
+inline Matrix2& Matrix2::operator-=(const Matrix2& rhs)
+{
+	m[0] -= rhs[0];
+	m[1] -= rhs[1];
+	m[2] -= rhs[2];
+	m[3] -= rhs[3];
+	return *this;
+}
+
+inline Vector2 Matrix2::operator*(const Vector2& rhs) const
+{
+	return Vector2(m[0] * rhs.x + m[2] * rhs.y, m[1] * rhs.x + m[3] * rhs.y);
+}
+
+inline Matrix2 Matrix2::operator*(const Matrix2& rhs) const
+{
+	return Matrix2(m[0] * rhs[0] + m[2] * rhs[1], m[1] * rhs[0] + m[3] * rhs[1],
+				   m[0] * rhs[2] + m[2] * rhs[3], m[1] * rhs[2] + m[3] * rhs[3]);
+}
+
+inline Matrix2& Matrix2::operator*=(const Matrix2& rhs)
+{
+	*this = *this * rhs;
+	return *this;
+}
+
+inline bool Matrix2::operator==(const Matrix2& rhs) const
+{
+	return (m[0] == rhs[0]) && (m[1] == rhs[1]) && (m[2] == rhs[2]) && (m[3] == rhs[3]);
+}
+
+inline bool Matrix2::operator!=(const Matrix2& rhs) const
+{
+	return (m[0] != rhs[0]) || (m[1] != rhs[1]) || (m[2] != rhs[2]) || (m[3] != rhs[3]);
+}
+
+inline float Matrix2::operator[](int index) const
+{
+	return m[index];
+}
+
+inline float& Matrix2::operator[](int index)
+{
+	return m[index];
+}
+
+inline Matrix2 operator-(const Matrix2& rhs)
+{
+	return Matrix2(-rhs[0], -rhs[1], -rhs[2], -rhs[3]);
+}
+
+inline Matrix2 operator*(float s, const Matrix2& rhs)
+{
+	return Matrix2(s * rhs[0], s * rhs[1], s * rhs[2], s * rhs[3]);
+}
+
+inline Vector2 operator*(const Vector2& v, const Matrix2& rhs)
+{
+	return Vector2(v.x * rhs[0] + v.y * rhs[1], v.x * rhs[2] + v.y * rhs[3]);
+}
+
+inline std::ostream& operator<<(std::ostream& os, const Matrix2& m)
+{
+	os << std::fixed << std::setprecision(5);
+	os << "[" << std::setw(10) << m[0] << " " << std::setw(10) << m[2] << "]\n"
+	   << "[" << std::setw(10) << m[1] << " " << std::setw(10) << m[3] << "]\n";
+	os << std::resetiosflags(std::ios_base::fixed | std::ios_base::floatfield);
+	return os;
+}
+// END OF MATRIX2 INLINE //////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////
+// inline functions for Matrix3
+///////////////////////////////////////////////////////////////////////////
+inline Matrix3::Matrix3()
+{
+	// initially identity matrix
+	identity();
+}
+
+inline Matrix3::Matrix3(const float src[9])
+{
+	set(src);
+}
+
+inline Matrix3::Matrix3(float m0, float m1, float m2,
+						float m3, float m4, float m5,
+						float m6, float m7, float m8)
+{
+	set(m0, m1, m2, m3, m4, m5, m6, m7, m8);
+}
+
+inline void Matrix3::set(const float src[9])
+{
+	m[0] = src[0];
+	m[1] = src[1];
+	m[2] = src[2];
+	m[3] = src[3];
+	m[4] = src[4];
+	m[5] = src[5];
+	m[6] = src[6];
+	m[7] = src[7];
+	m[8] = src[8];
+}
+
+inline void Matrix3::set(float m0, float m1, float m2,
+						 float m3, float m4, float m5,
+						 float m6, float m7, float m8)
+{
+	m[0] = m0;
+	m[1] = m1;
+	m[2] = m2;
+	m[3] = m3;
+	m[4] = m4;
+	m[5] = m5;
+	m[6] = m6;
+	m[7] = m7;
+	m[8] = m8;
+}
+
+inline void Matrix3::setRow(int index, const float row[3])
+{
+	m[index] = row[0];
+	m[index + 3] = row[1];
+	m[index + 6] = row[2];
+}
+
+inline void Matrix3::setRow(int index, const Vector3& v)
+{
+	m[index] = v.x;
+	m[index + 3] = v.y;
+	m[index + 6] = v.z;
+}
+
+inline void Matrix3::setColumn(int index, const float col[3])
+{
+	m[index * 3] = col[0];
+	m[index * 3 + 1] = col[1];
+	m[index * 3 + 2] = col[2];
+}
+
+inline void Matrix3::setColumn(int index, const Vector3& v)
+{
+	m[index * 3] = v.x;
+	m[index * 3 + 1] = v.y;
+	m[index * 3 + 2] = v.z;
+}
+
+inline const float* Matrix3::get() const
+{
+	return m;
+}
+
+inline Matrix3& Matrix3::identity()
+{
+	m[0] = m[4] = m[8] = 1.0f;
+	m[1] = m[2] = m[3] = m[5] = m[6] = m[7] = 0.0f;
+	return *this;
+}
+
+inline Matrix3 Matrix3::operator+(const Matrix3& rhs) const
+{
+	return Matrix3(m[0] + rhs[0], m[1] + rhs[1], m[2] + rhs[2],
+				   m[3] + rhs[3], m[4] + rhs[4], m[5] + rhs[5],
+				   m[6] + rhs[6], m[7] + rhs[7], m[8] + rhs[8]);
+}
+
+inline Matrix3 Matrix3::operator-(const Matrix3& rhs) const
+{
+	return Matrix3(m[0] - rhs[0], m[1] - rhs[1], m[2] - rhs[2],
+				   m[3] - rhs[3], m[4] - rhs[4], m[5] - rhs[5],
+				   m[6] - rhs[6], m[7] - rhs[7], m[8] - rhs[8]);
+}
+
+inline Matrix3& Matrix3::operator+=(const Matrix3& rhs)
+{
+	m[0] += rhs[0];
+	m[1] += rhs[1];
+	m[2] += rhs[2];
+	m[3] += rhs[3];
+	m[4] += rhs[4];
+	m[5] += rhs[5];
+	m[6] += rhs[6];
+	m[7] += rhs[7];
+	m[8] += rhs[8];
+	return *this;
+}
+
+inline Matrix3& Matrix3::operator-=(const Matrix3& rhs)
+{
+	m[0] -= rhs[0];
+	m[1] -= rhs[1];
+	m[2] -= rhs[2];
+	m[3] -= rhs[3];
+	m[4] -= rhs[4];
+	m[5] -= rhs[5];
+	m[6] -= rhs[6];
+	m[7] -= rhs[7];
+	m[8] -= rhs[8];
+	return *this;
+}
+
+inline Vector3 Matrix3::operator*(const Vector3& rhs) const
+{
+	return Vector3(m[0] * rhs.x + m[3] * rhs.y + m[6] * rhs.z,
+				   m[1] * rhs.x + m[4] * rhs.y + m[7] * rhs.z,
+				   m[2] * rhs.x + m[5] * rhs.y + m[8] * rhs.z);
+}
+
+inline Matrix3 Matrix3::operator*(const Matrix3& rhs) const
+{
+	return Matrix3(m[0] * rhs[0] + m[3] * rhs[1] + m[6] * rhs[2], m[1] * rhs[0] + m[4] * rhs[1] + m[7] * rhs[2], m[2] * rhs[0] + m[5] * rhs[1] + m[8] * rhs[2],
+				   m[0] * rhs[3] + m[3] * rhs[4] + m[6] * rhs[5], m[1] * rhs[3] + m[4] * rhs[4] + m[7] * rhs[5], m[2] * rhs[3] + m[5] * rhs[4] + m[8] * rhs[5],
+				   m[0] * rhs[6] + m[3] * rhs[7] + m[6] * rhs[8], m[1] * rhs[6] + m[4] * rhs[7] + m[7] * rhs[8], m[2] * rhs[6] + m[5] * rhs[7] + m[8] * rhs[8]);
+}
+
+inline Matrix3& Matrix3::operator*=(const Matrix3& rhs)
+{
+	*this = *this * rhs;
+	return *this;
+}
+
+inline bool Matrix3::operator==(const Matrix3& rhs) const
+{
+	return (m[0] == rhs[0]) && (m[1] == rhs[1]) && (m[2] == rhs[2]) &&
+		   (m[3] == rhs[3]) && (m[4] == rhs[4]) && (m[5] == rhs[5]) &&
+		   (m[6] == rhs[6]) && (m[7] == rhs[7]) && (m[8] == rhs[8]);
+}
+
+inline bool Matrix3::operator!=(const Matrix3& rhs) const
+{
+	return (m[0] != rhs[0]) || (m[1] != rhs[1]) || (m[2] != rhs[2]) ||
+		   (m[3] != rhs[3]) || (m[4] != rhs[4]) || (m[5] != rhs[5]) ||
+		   (m[6] != rhs[6]) || (m[7] != rhs[7]) || (m[8] != rhs[8]);
+}
+
+inline float Matrix3::operator[](int index) const
+{
+	return m[index];
+}
+
+inline float& Matrix3::operator[](int index)
+{
+	return m[index];
+}
+
+inline Matrix3 operator-(const Matrix3& rhs)
+{
+	return Matrix3(-rhs[0], -rhs[1], -rhs[2], -rhs[3], -rhs[4], -rhs[5], -rhs[6], -rhs[7], -rhs[8]);
+}
+
+inline Matrix3 operator*(float s, const Matrix3& rhs)
+{
+	return Matrix3(s * rhs[0], s * rhs[1], s * rhs[2], s * rhs[3], s * rhs[4], s * rhs[5], s * rhs[6], s * rhs[7], s * rhs[8]);
+}
+
+inline Vector3 operator*(const Vector3& v, const Matrix3& m)
+{
+	return Vector3(v.x * m[0] + v.y * m[1] + v.z * m[2], v.x * m[3] + v.y * m[4] + v.z * m[5], v.x * m[6] + v.y * m[7] + v.z * m[8]);
+}
+
+inline std::ostream& operator<<(std::ostream& os, const Matrix3& m)
+{
+	os << std::fixed << std::setprecision(5);
+	os << "[" << std::setw(10) << m[0] << " " << std::setw(10) << m[3] << " " << std::setw(10) << m[6] << "]\n"
+	   << "[" << std::setw(10) << m[1] << " " << std::setw(10) << m[4] << " " << std::setw(10) << m[7] << "]\n"
+	   << "[" << std::setw(10) << m[2] << " " << std::setw(10) << m[5] << " " << std::setw(10) << m[8] << "]\n";
+	os << std::resetiosflags(std::ios_base::fixed | std::ios_base::floatfield);
+	return os;
+}
+// END OF MATRIX3 INLINE //////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////
+// inline functions for Matrix4
+///////////////////////////////////////////////////////////////////////////
+inline Matrix4::Matrix4()
+{
+	// initially identity matrix
+	identity();
+}
+
+inline Matrix4::Matrix4(const float src[16])
+{
+	set(src);
+}
+
+inline Matrix4::Matrix4(float m00, float m01, float m02, float m03,
+						float m04, float m05, float m06, float m07,
+						float m08, float m09, float m10, float m11,
+						float m12, float m13, float m14, float m15)
+{
+	set(m00, m01, m02, m03, m04, m05, m06, m07, m08, m09, m10, m11, m12, m13, m14, m15);
+}
+
+inline void Matrix4::set(const float src[16])
+{
+	m[0] = src[0];
+	m[1] = src[1];
+	m[2] = src[2];
+	m[3] = src[3];
+	m[4] = src[4];
+	m[5] = src[5];
+	m[6] = src[6];
+	m[7] = src[7];
+	m[8] = src[8];
+	m[9] = src[9];
+	m[10] = src[10];
+	m[11] = src[11];
+	m[12] = src[12];
+	m[13] = src[13];
+	m[14] = src[14];
+	m[15] = src[15];
+}
+
+inline void Matrix4::set(float m00, float m01, float m02, float m03,
+						 float m04, float m05, float m06, float m07,
+						 float m08, float m09, float m10, float m11,
+						 float m12, float m13, float m14, float m15)
+{
+	m[0] = m00;
+	m[1] = m01;
+	m[2] = m02;
+	m[3] = m03;
+	m[4] = m04;
+	m[5] = m05;
+	m[6] = m06;
+	m[7] = m07;
+	m[8] = m08;
+	m[9] = m09;
+	m[10] = m10;
+	m[11] = m11;
+	m[12] = m12;
+	m[13] = m13;
+	m[14] = m14;
+	m[15] = m15;
+}
+
+inline void Matrix4::setRow(int index, const float row[4])
+{
+	m[index] = row[0];
+	m[index + 4] = row[1];
+	m[index + 8] = row[2];
+	m[index + 12] = row[3];
+}
+
+inline void Matrix4::setRow(int index, const Vector4& v)
+{
+	m[index] = v.x;
+	m[index + 4] = v.y;
+	m[index + 8] = v.z;
+	m[index + 12] = v.w;
+}
+
+inline void Matrix4::setRow(int index, const Vector3& v)
+{
+	m[index] = v.x;
+	m[index + 4] = v.y;
+	m[index + 8] = v.z;
+}
+
+inline void Matrix4::setColumn(int index, const float col[4])
+{
+	m[index * 4] = col[0];
+	m[index * 4 + 1] = col[1];
+	m[index * 4 + 2] = col[2];
+	m[index * 4 + 3] = col[3];
+}
+
+inline void Matrix4::setColumn(int index, const Vector4& v)
+{
+	m[index * 4] = v.x;
+	m[index * 4 + 1] = v.y;
+	m[index * 4 + 2] = v.z;
+	m[index * 4 + 3] = v.w;
+}
+
+inline void Matrix4::setColumn(int index, const Vector3& v)
+{
+	m[index * 4] = v.x;
+	m[index * 4 + 1] = v.y;
+	m[index * 4 + 2] = v.z;
+}
+
+inline const float* Matrix4::get() const
+{
+	return m;
+}
+
+inline const float* Matrix4::getTranspose()
+{
+	tm[0] = m[0];
+	tm[1] = m[4];
+	tm[2] = m[8];
+	tm[3] = m[12];
+	tm[4] = m[1];
+	tm[5] = m[5];
+	tm[6] = m[9];
+	tm[7] = m[13];
+	tm[8] = m[2];
+	tm[9] = m[6];
+	tm[10] = m[10];
+	tm[11] = m[14];
+	tm[12] = m[3];
+	tm[13] = m[7];
+	tm[14] = m[11];
+	tm[15] = m[15];
+	return tm;
+}
+
+inline Matrix4& Matrix4::identity()
+{
+	m[0] = m[5] = m[10] = m[15] = 1.0f;
+	m[1] = m[2] = m[3] = m[4] = m[6] = m[7] = m[8] = m[9] = m[11] = m[12] = m[13] = m[14] = 0.0f;
+	return *this;
+}
+
+inline Matrix4 Matrix4::operator+(const Matrix4& rhs) const
+{
+	return Matrix4(m[0] + rhs[0], m[1] + rhs[1], m[2] + rhs[2], m[3] + rhs[3],
+				   m[4] + rhs[4], m[5] + rhs[5], m[6] + rhs[6], m[7] + rhs[7],
+				   m[8] + rhs[8], m[9] + rhs[9], m[10] + rhs[10], m[11] + rhs[11],
+				   m[12] + rhs[12], m[13] + rhs[13], m[14] + rhs[14], m[15] + rhs[15]);
+}
+
+inline Matrix4 Matrix4::operator-(const Matrix4& rhs) const
+{
+	return Matrix4(m[0] - rhs[0], m[1] - rhs[1], m[2] - rhs[2], m[3] - rhs[3],
+				   m[4] - rhs[4], m[5] - rhs[5], m[6] - rhs[6], m[7] - rhs[7],
+				   m[8] - rhs[8], m[9] - rhs[9], m[10] - rhs[10], m[11] - rhs[11],
+				   m[12] - rhs[12], m[13] - rhs[13], m[14] - rhs[14], m[15] - rhs[15]);
+}
+
+inline Matrix4& Matrix4::operator+=(const Matrix4& rhs)
+{
+	m[0] += rhs[0];
+	m[1] += rhs[1];
+	m[2] += rhs[2];
+	m[3] += rhs[3];
+	m[4] += rhs[4];
+	m[5] += rhs[5];
+	m[6] += rhs[6];
+	m[7] += rhs[7];
+	m[8] += rhs[8];
+	m[9] += rhs[9];
+	m[10] += rhs[10];
+	m[11] += rhs[11];
+	m[12] += rhs[12];
+	m[13] += rhs[13];
+	m[14] += rhs[14];
+	m[15] += rhs[15];
+	return *this;
+}
+
+inline Matrix4& Matrix4::operator-=(const Matrix4& rhs)
+{
+	m[0] -= rhs[0];
+	m[1] -= rhs[1];
+	m[2] -= rhs[2];
+	m[3] -= rhs[3];
+	m[4] -= rhs[4];
+	m[5] -= rhs[5];
+	m[6] -= rhs[6];
+	m[7] -= rhs[7];
+	m[8] -= rhs[8];
+	m[9] -= rhs[9];
+	m[10] -= rhs[10];
+	m[11] -= rhs[11];
+	m[12] -= rhs[12];
+	m[13] -= rhs[13];
+	m[14] -= rhs[14];
+	m[15] -= rhs[15];
+	return *this;
+}
+
+inline Vector4 Matrix4::operator*(const Vector4& rhs) const
+{
+	return Vector4(m[0] * rhs.x + m[4] * rhs.y + m[8] * rhs.z + m[12] * rhs.w,
+				   m[1] * rhs.x + m[5] * rhs.y + m[9] * rhs.z + m[13] * rhs.w,
+				   m[2] * rhs.x + m[6] * rhs.y + m[10] * rhs.z + m[14] * rhs.w,
+				   m[3] * rhs.x + m[7] * rhs.y + m[11] * rhs.z + m[15] * rhs.w);
+}
+
+inline Vector3 Matrix4::operator*(const Vector3& rhs) const
+{
+	return Vector3(m[0] * rhs.x + m[4] * rhs.y + m[8] * rhs.z,
+				   m[1] * rhs.x + m[5] * rhs.y + m[9] * rhs.z,
+				   m[2] * rhs.x + m[6] * rhs.y + m[10] * rhs.z);
+}
+
+inline Matrix4 Matrix4::operator*(const Matrix4& n) const
+{
+	return Matrix4(m[0] * n[0] + m[4] * n[1] + m[8] * n[2] + m[12] * n[3], m[1] * n[0] + m[5] * n[1] + m[9] * n[2] + m[13] * n[3], m[2] * n[0] + m[6] * n[1] + m[10] * n[2] + m[14] * n[3], m[3] * n[0] + m[7] * n[1] + m[11] * n[2] + m[15] * n[3],
+				   m[0] * n[4] + m[4] * n[5] + m[8] * n[6] + m[12] * n[7], m[1] * n[4] + m[5] * n[5] + m[9] * n[6] + m[13] * n[7], m[2] * n[4] + m[6] * n[5] + m[10] * n[6] + m[14] * n[7], m[3] * n[4] + m[7] * n[5] + m[11] * n[6] + m[15] * n[7],
+				   m[0] * n[8] + m[4] * n[9] + m[8] * n[10] + m[12] * n[11], m[1] * n[8] + m[5] * n[9] + m[9] * n[10] + m[13] * n[11], m[2] * n[8] + m[6] * n[9] + m[10] * n[10] + m[14] * n[11], m[3] * n[8] + m[7] * n[9] + m[11] * n[10] + m[15] * n[11],
+				   m[0] * n[12] + m[4] * n[13] + m[8] * n[14] + m[12] * n[15], m[1] * n[12] + m[5] * n[13] + m[9] * n[14] + m[13] * n[15], m[2] * n[12] + m[6] * n[13] + m[10] * n[14] + m[14] * n[15], m[3] * n[12] + m[7] * n[13] + m[11] * n[14] + m[15] * n[15]);
+}
+
+inline Matrix4& Matrix4::operator*=(const Matrix4& rhs)
+{
+	*this = *this * rhs;
+	return *this;
+}
+
+inline bool Matrix4::operator==(const Matrix4& n) const
+{
+	return (m[0] == n[0]) && (m[1] == n[1]) && (m[2] == n[2]) && (m[3] == n[3]) &&
+		   (m[4] == n[4]) && (m[5] == n[5]) && (m[6] == n[6]) && (m[7] == n[7]) &&
+		   (m[8] == n[8]) && (m[9] == n[9]) && (m[10] == n[10]) && (m[11] == n[11]) &&
+		   (m[12] == n[12]) && (m[13] == n[13]) && (m[14] == n[14]) && (m[15] == n[15]);
+}
+
+inline bool Matrix4::operator!=(const Matrix4& n) const
+{
+	return (m[0] != n[0]) || (m[1] != n[1]) || (m[2] != n[2]) || (m[3] != n[3]) ||
+		   (m[4] != n[4]) || (m[5] != n[5]) || (m[6] != n[6]) || (m[7] != n[7]) ||
+		   (m[8] != n[8]) || (m[9] != n[9]) || (m[10] != n[10]) || (m[11] != n[11]) ||
+		   (m[12] != n[12]) || (m[13] != n[13]) || (m[14] != n[14]) || (m[15] != n[15]);
+}
+
+inline float Matrix4::operator[](int index) const
+{
+	return m[index];
+}
+
+inline float& Matrix4::operator[](int index)
+{
+	return m[index];
+}
+
+inline Matrix4 operator-(const Matrix4& rhs)
+{
+	return Matrix4(-rhs[0], -rhs[1], -rhs[2], -rhs[3], -rhs[4], -rhs[5], -rhs[6], -rhs[7], -rhs[8], -rhs[9], -rhs[10], -rhs[11], -rhs[12], -rhs[13], -rhs[14], -rhs[15]);
+}
+
+inline Matrix4 operator*(float s, const Matrix4& rhs)
+{
+	return Matrix4(s * rhs[0], s * rhs[1], s * rhs[2], s * rhs[3], s * rhs[4], s * rhs[5], s * rhs[6], s * rhs[7], s * rhs[8], s * rhs[9], s * rhs[10], s * rhs[11], s * rhs[12], s * rhs[13], s * rhs[14], s * rhs[15]);
+}
+
+inline Vector4 operator*(const Vector4& v, const Matrix4& m)
+{
+	return Vector4(v.x * m[0] + v.y * m[1] + v.z * m[2] + v.w * m[3], v.x * m[4] + v.y * m[5] + v.z * m[6] + v.w * m[7], v.x * m[8] + v.y * m[9] + v.z * m[10] + v.w * m[11], v.x * m[12] + v.y * m[13] + v.z * m[14] + v.w * m[15]);
+}
+
+inline Vector3 operator*(const Vector3& v, const Matrix4& m)
+{
+	return Vector3(v.x * m[0] + v.y * m[1] + v.z * m[2], v.x * m[4] + v.y * m[5] + v.z * m[6], v.x * m[8] + v.y * m[9] + v.z * m[10]);
+}
+
+inline std::ostream& operator<<(std::ostream& os, const Matrix4& m)
+{
+	os << std::fixed << std::setprecision(5);
+	os << "[" << std::setw(10) << m[0] << " " << std::setw(10) << m[4] << " " << std::setw(10) << m[8] << " " << std::setw(10) << m[12] << "]\n"
+	   << "[" << std::setw(10) << m[1] << " " << std::setw(10) << m[5] << " " << std::setw(10) << m[9] << " " << std::setw(10) << m[13] << "]\n"
+	   << "[" << std::setw(10) << m[2] << " " << std::setw(10) << m[6] << " " << std::setw(10) << m[10] << " " << std::setw(10) << m[14] << "]\n"
+	   << "[" << std::setw(10) << m[3] << " " << std::setw(10) << m[7] << " " << std::setw(10) << m[11] << " " << std::setw(10) << m[15] << "]\n";
+	os << std::resetiosflags(std::ios_base::fixed | std::ios_base::floatfield);
+	return os;
+}
+// END OF MATRIX4 INLINE //////////////////////////////////////////////////////
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/openvr/samples/shared/Vectors.h b/engine/inc/bullet/ThirdPartyLibs/openvr/samples/shared/Vectors.h
new file mode 100644
index 00000000..f0b346c9
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/openvr/samples/shared/Vectors.h
@@ -0,0 +1,640 @@
+///////////////////////////////////////////////////////////////////////////////
+// Vectors.h
+// =========
+// 2D/3D/4D vectors
+//
+//  AUTHOR: Song Ho Ahn (song.ahn@gmail.com)
+// CREATED: 2007-02-14
+// UPDATED: 2013-01-20
+//
+// Copyright (C) 2007-2013 Song Ho Ahn
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef VECTORS_H_DEF
+#define VECTORS_H_DEF
+
+#include <cmath>
+#include <iostream>
+
+///////////////////////////////////////////////////////////////////////////////
+// 2D vector
+///////////////////////////////////////////////////////////////////////////////
+struct Vector2
+{
+	float x;
+	float y;
+
+	// ctors
+	Vector2() : x(0), y(0){};
+	Vector2(float x, float y) : x(x), y(y){};
+
+	// utils functions
+	void set(float x, float y);
+	float length() const;                           //
+	float distance(const Vector2& vec) const;       // distance between two vectors
+	Vector2& normalize();                           //
+	float dot(const Vector2& vec) const;            // dot product
+	bool equal(const Vector2& vec, float e) const;  // compare with epsilon
+
+	// operators
+	Vector2 operator-() const;                    // unary operator (negate)
+	Vector2 operator+(const Vector2& rhs) const;  // add rhs
+	Vector2 operator-(const Vector2& rhs) const;  // subtract rhs
+	Vector2& operator+=(const Vector2& rhs);      // add rhs and update this object
+	Vector2& operator-=(const Vector2& rhs);      // subtract rhs and update this object
+	Vector2 operator*(const float scale) const;   // scale
+	Vector2 operator*(const Vector2& rhs) const;  // multiply each element
+	Vector2& operator*=(const float scale);       // scale and update this object
+	Vector2& operator*=(const Vector2& rhs);      // multiply each element and update this object
+	Vector2 operator/(const float scale) const;   // inverse scale
+	Vector2& operator/=(const float scale);       // scale and update this object
+	bool operator==(const Vector2& rhs) const;    // exact compare, no epsilon
+	bool operator!=(const Vector2& rhs) const;    // exact compare, no epsilon
+	bool operator<(const Vector2& rhs) const;     // comparison for sort
+	float operator[](int index) const;            // subscript operator v[0], v[1]
+	float& operator[](int index);                 // subscript operator v[0], v[1]
+
+	friend Vector2 operator*(const float a, const Vector2 vec);
+	friend std::ostream& operator<<(std::ostream& os, const Vector2& vec);
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// 3D vector
+///////////////////////////////////////////////////////////////////////////////
+struct Vector3
+{
+	float x;
+	float y;
+	float z;
+
+	// ctors
+	Vector3() : x(0), y(0), z(0){};
+	Vector3(float x, float y, float z) : x(x), y(y), z(z){};
+
+	// utils functions
+	void set(float x, float y, float z);
+	float length() const;                           //
+	float distance(const Vector3& vec) const;       // distance between two vectors
+	Vector3& normalize();                           //
+	float dot(const Vector3& vec) const;            // dot product
+	Vector3 cross(const Vector3& vec) const;        // cross product
+	bool equal(const Vector3& vec, float e) const;  // compare with epsilon
+
+	// operators
+	Vector3 operator-() const;                    // unary operator (negate)
+	Vector3 operator+(const Vector3& rhs) const;  // add rhs
+	Vector3 operator-(const Vector3& rhs) const;  // subtract rhs
+	Vector3& operator+=(const Vector3& rhs);      // add rhs and update this object
+	Vector3& operator-=(const Vector3& rhs);      // subtract rhs and update this object
+	Vector3 operator*(const float scale) const;   // scale
+	Vector3 operator*(const Vector3& rhs) const;  // multiplay each element
+	Vector3& operator*=(const float scale);       // scale and update this object
+	Vector3& operator*=(const Vector3& rhs);      // product each element and update this object
+	Vector3 operator/(const float scale) const;   // inverse scale
+	Vector3& operator/=(const float scale);       // scale and update this object
+	bool operator==(const Vector3& rhs) const;    // exact compare, no epsilon
+	bool operator!=(const Vector3& rhs) const;    // exact compare, no epsilon
+	bool operator<(const Vector3& rhs) const;     // comparison for sort
+	float operator[](int index) const;            // subscript operator v[0], v[1]
+	float& operator[](int index);                 // subscript operator v[0], v[1]
+
+	friend Vector3 operator*(const float a, const Vector3 vec);
+	friend std::ostream& operator<<(std::ostream& os, const Vector3& vec);
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// 4D vector
+///////////////////////////////////////////////////////////////////////////////
+struct Vector4
+{
+	float x;
+	float y;
+	float z;
+	float w;
+
+	// ctors
+	Vector4() : x(0), y(0), z(0), w(0){};
+	Vector4(float x, float y, float z, float w) : x(x), y(y), z(z), w(w){};
+
+	// utils functions
+	void set(float x, float y, float z, float w);
+	float length() const;                           //
+	float distance(const Vector4& vec) const;       // distance between two vectors
+	Vector4& normalize();                           //
+	float dot(const Vector4& vec) const;            // dot product
+	bool equal(const Vector4& vec, float e) const;  // compare with epsilon
+
+	// operators
+	Vector4 operator-() const;                    // unary operator (negate)
+	Vector4 operator+(const Vector4& rhs) const;  // add rhs
+	Vector4 operator-(const Vector4& rhs) const;  // subtract rhs
+	Vector4& operator+=(const Vector4& rhs);      // add rhs and update this object
+	Vector4& operator-=(const Vector4& rhs);      // subtract rhs and update this object
+	Vector4 operator*(const float scale) const;   // scale
+	Vector4 operator*(const Vector4& rhs) const;  // multiply each element
+	Vector4& operator*=(const float scale);       // scale and update this object
+	Vector4& operator*=(const Vector4& rhs);      // multiply each element and update this object
+	Vector4 operator/(const float scale) const;   // inverse scale
+	Vector4& operator/=(const float scale);       // scale and update this object
+	bool operator==(const Vector4& rhs) const;    // exact compare, no epsilon
+	bool operator!=(const Vector4& rhs) const;    // exact compare, no epsilon
+	bool operator<(const Vector4& rhs) const;     // comparison for sort
+	float operator[](int index) const;            // subscript operator v[0], v[1]
+	float& operator[](int index);                 // subscript operator v[0], v[1]
+
+	friend Vector4 operator*(const float a, const Vector4 vec);
+	friend std::ostream& operator<<(std::ostream& os, const Vector4& vec);
+};
+
+// fast math routines from Doom3 SDK
+inline float invSqrt(float x)
+{
+	float xhalf = 0.5f * x;
+	int i = *(int*)&x;               // get bits for floating value
+	i = 0x5f3759df - (i >> 1);       // gives initial guess
+	x = *(float*)&i;                 // convert bits back to float
+	x = x * (1.5f - xhalf * x * x);  // Newton step
+	return x;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// inline functions for Vector2
+///////////////////////////////////////////////////////////////////////////////
+inline Vector2 Vector2::operator-() const
+{
+	return Vector2(-x, -y);
+}
+
+inline Vector2 Vector2::operator+(const Vector2& rhs) const
+{
+	return Vector2(x + rhs.x, y + rhs.y);
+}
+
+inline Vector2 Vector2::operator-(const Vector2& rhs) const
+{
+	return Vector2(x - rhs.x, y - rhs.y);
+}
+
+inline Vector2& Vector2::operator+=(const Vector2& rhs)
+{
+	x += rhs.x;
+	y += rhs.y;
+	return *this;
+}
+
+inline Vector2& Vector2::operator-=(const Vector2& rhs)
+{
+	x -= rhs.x;
+	y -= rhs.y;
+	return *this;
+}
+
+inline Vector2 Vector2::operator*(const float a) const
+{
+	return Vector2(x * a, y * a);
+}
+
+inline Vector2 Vector2::operator*(const Vector2& rhs) const
+{
+	return Vector2(x * rhs.x, y * rhs.y);
+}
+
+inline Vector2& Vector2::operator*=(const float a)
+{
+	x *= a;
+	y *= a;
+	return *this;
+}
+
+inline Vector2& Vector2::operator*=(const Vector2& rhs)
+{
+	x *= rhs.x;
+	y *= rhs.y;
+	return *this;
+}
+
+inline Vector2 Vector2::operator/(const float a) const
+{
+	return Vector2(x / a, y / a);
+}
+
+inline Vector2& Vector2::operator/=(const float a)
+{
+	x /= a;
+	y /= a;
+	return *this;
+}
+
+inline bool Vector2::operator==(const Vector2& rhs) const
+{
+	return (x == rhs.x) && (y == rhs.y);
+}
+
+inline bool Vector2::operator!=(const Vector2& rhs) const
+{
+	return (x != rhs.x) || (y != rhs.y);
+}
+
+inline bool Vector2::operator<(const Vector2& rhs) const
+{
+	if (x < rhs.x) return true;
+	if (x > rhs.x) return false;
+	if (y < rhs.y) return true;
+	if (y > rhs.y) return false;
+	return false;
+}
+
+inline float Vector2::operator[](int index) const
+{
+	return (&x)[index];
+}
+
+inline float& Vector2::operator[](int index)
+{
+	return (&x)[index];
+}
+
+inline void Vector2::set(float x, float y)
+{
+	this->x = x;
+	this->y = y;
+}
+
+inline float Vector2::length() const
+{
+	return sqrtf(x * x + y * y);
+}
+
+inline float Vector2::distance(const Vector2& vec) const
+{
+	return sqrtf((vec.x - x) * (vec.x - x) + (vec.y - y) * (vec.y - y));
+}
+
+inline Vector2& Vector2::normalize()
+{
+	//@@const float EPSILON = 0.000001f;
+	float xxyy = x * x + y * y;
+	//@@if(xxyy < EPSILON)
+	//@@    return *this;
+
+	//float invLength = invSqrt(xxyy);
+	float invLength = 1.0f / sqrtf(xxyy);
+	x *= invLength;
+	y *= invLength;
+	return *this;
+}
+
+inline float Vector2::dot(const Vector2& rhs) const
+{
+	return (x * rhs.x + y * rhs.y);
+}
+
+inline bool Vector2::equal(const Vector2& rhs, float epsilon) const
+{
+	return fabs(x - rhs.x) < epsilon && fabs(y - rhs.y) < epsilon;
+}
+
+inline Vector2 operator*(const float a, const Vector2 vec)
+{
+	return Vector2(a * vec.x, a * vec.y);
+}
+
+inline std::ostream& operator<<(std::ostream& os, const Vector2& vec)
+{
+	os << "(" << vec.x << ", " << vec.y << ")";
+	return os;
+}
+// END OF VECTOR2 /////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// inline functions for Vector3
+///////////////////////////////////////////////////////////////////////////////
+inline Vector3 Vector3::operator-() const
+{
+	return Vector3(-x, -y, -z);
+}
+
+inline Vector3 Vector3::operator+(const Vector3& rhs) const
+{
+	return Vector3(x + rhs.x, y + rhs.y, z + rhs.z);
+}
+
+inline Vector3 Vector3::operator-(const Vector3& rhs) const
+{
+	return Vector3(x - rhs.x, y - rhs.y, z - rhs.z);
+}
+
+inline Vector3& Vector3::operator+=(const Vector3& rhs)
+{
+	x += rhs.x;
+	y += rhs.y;
+	z += rhs.z;
+	return *this;
+}
+
+inline Vector3& Vector3::operator-=(const Vector3& rhs)
+{
+	x -= rhs.x;
+	y -= rhs.y;
+	z -= rhs.z;
+	return *this;
+}
+
+inline Vector3 Vector3::operator*(const float a) const
+{
+	return Vector3(x * a, y * a, z * a);
+}
+
+inline Vector3 Vector3::operator*(const Vector3& rhs) const
+{
+	return Vector3(x * rhs.x, y * rhs.y, z * rhs.z);
+}
+
+inline Vector3& Vector3::operator*=(const float a)
+{
+	x *= a;
+	y *= a;
+	z *= a;
+	return *this;
+}
+
+inline Vector3& Vector3::operator*=(const Vector3& rhs)
+{
+	x *= rhs.x;
+	y *= rhs.y;
+	z *= rhs.z;
+	return *this;
+}
+
+inline Vector3 Vector3::operator/(const float a) const
+{
+	return Vector3(x / a, y / a, z / a);
+}
+
+inline Vector3& Vector3::operator/=(const float a)
+{
+	x /= a;
+	y /= a;
+	z /= a;
+	return *this;
+}
+
+inline bool Vector3::operator==(const Vector3& rhs) const
+{
+	return (x == rhs.x) && (y == rhs.y) && (z == rhs.z);
+}
+
+inline bool Vector3::operator!=(const Vector3& rhs) const
+{
+	return (x != rhs.x) || (y != rhs.y) || (z != rhs.z);
+}
+
+inline bool Vector3::operator<(const Vector3& rhs) const
+{
+	if (x < rhs.x) return true;
+	if (x > rhs.x) return false;
+	if (y < rhs.y) return true;
+	if (y > rhs.y) return false;
+	if (z < rhs.z) return true;
+	if (z > rhs.z) return false;
+	return false;
+}
+
+inline float Vector3::operator[](int index) const
+{
+	return (&x)[index];
+}
+
+inline float& Vector3::operator[](int index)
+{
+	return (&x)[index];
+}
+
+inline void Vector3::set(float x, float y, float z)
+{
+	this->x = x;
+	this->y = y;
+	this->z = z;
+}
+
+inline float Vector3::length() const
+{
+	return sqrtf(x * x + y * y + z * z);
+}
+
+inline float Vector3::distance(const Vector3& vec) const
+{
+	return sqrtf((vec.x - x) * (vec.x - x) + (vec.y - y) * (vec.y - y) + (vec.z - z) * (vec.z - z));
+}
+
+inline Vector3& Vector3::normalize()
+{
+	//@@const float EPSILON = 0.000001f;
+	float xxyyzz = x * x + y * y + z * z;
+	//@@if(xxyyzz < EPSILON)
+	//@@    return *this; // do nothing if it is ~zero vector
+
+	//float invLength = invSqrt(xxyyzz);
+	float invLength = 1.0f / sqrtf(xxyyzz);
+	x *= invLength;
+	y *= invLength;
+	z *= invLength;
+	return *this;
+}
+
+inline float Vector3::dot(const Vector3& rhs) const
+{
+	return (x * rhs.x + y * rhs.y + z * rhs.z);
+}
+
+inline Vector3 Vector3::cross(const Vector3& rhs) const
+{
+	return Vector3(y * rhs.z - z * rhs.y, z * rhs.x - x * rhs.z, x * rhs.y - y * rhs.x);
+}
+
+inline bool Vector3::equal(const Vector3& rhs, float epsilon) const
+{
+	return fabs(x - rhs.x) < epsilon && fabs(y - rhs.y) < epsilon && fabs(z - rhs.z) < epsilon;
+}
+
+inline Vector3 operator*(const float a, const Vector3 vec)
+{
+	return Vector3(a * vec.x, a * vec.y, a * vec.z);
+}
+
+inline std::ostream& operator<<(std::ostream& os, const Vector3& vec)
+{
+	os << "(" << vec.x << ", " << vec.y << ", " << vec.z << ")";
+	return os;
+}
+// END OF VECTOR3 /////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// inline functions for Vector4
+///////////////////////////////////////////////////////////////////////////////
+inline Vector4 Vector4::operator-() const
+{
+	return Vector4(-x, -y, -z, -w);
+}
+
+inline Vector4 Vector4::operator+(const Vector4& rhs) const
+{
+	return Vector4(x + rhs.x, y + rhs.y, z + rhs.z, w + rhs.w);
+}
+
+inline Vector4 Vector4::operator-(const Vector4& rhs) const
+{
+	return Vector4(x - rhs.x, y - rhs.y, z - rhs.z, w - rhs.w);
+}
+
+inline Vector4& Vector4::operator+=(const Vector4& rhs)
+{
+	x += rhs.x;
+	y += rhs.y;
+	z += rhs.z;
+	w += rhs.w;
+	return *this;
+}
+
+inline Vector4& Vector4::operator-=(const Vector4& rhs)
+{
+	x -= rhs.x;
+	y -= rhs.y;
+	z -= rhs.z;
+	w -= rhs.w;
+	return *this;
+}
+
+inline Vector4 Vector4::operator*(const float a) const
+{
+	return Vector4(x * a, y * a, z * a, w * a);
+}
+
+inline Vector4 Vector4::operator*(const Vector4& rhs) const
+{
+	return Vector4(x * rhs.x, y * rhs.y, z * rhs.z, w * rhs.w);
+}
+
+inline Vector4& Vector4::operator*=(const float a)
+{
+	x *= a;
+	y *= a;
+	z *= a;
+	w *= a;
+	return *this;
+}
+
+inline Vector4& Vector4::operator*=(const Vector4& rhs)
+{
+	x *= rhs.x;
+	y *= rhs.y;
+	z *= rhs.z;
+	w *= rhs.w;
+	return *this;
+}
+
+inline Vector4 Vector4::operator/(const float a) const
+{
+	return Vector4(x / a, y / a, z / a, w / a);
+}
+
+inline Vector4& Vector4::operator/=(const float a)
+{
+	x /= a;
+	y /= a;
+	z /= a;
+	w /= a;
+	return *this;
+}
+
+inline bool Vector4::operator==(const Vector4& rhs) const
+{
+	return (x == rhs.x) && (y == rhs.y) && (z == rhs.z) && (w == rhs.w);
+}
+
+inline bool Vector4::operator!=(const Vector4& rhs) const
+{
+	return (x != rhs.x) || (y != rhs.y) || (z != rhs.z) || (w != rhs.w);
+}
+
+inline bool Vector4::operator<(const Vector4& rhs) const
+{
+	if (x < rhs.x) return true;
+	if (x > rhs.x) return false;
+	if (y < rhs.y) return true;
+	if (y > rhs.y) return false;
+	if (z < rhs.z) return true;
+	if (z > rhs.z) return false;
+	if (w < rhs.w) return true;
+	if (w > rhs.w) return false;
+	return false;
+}
+
+inline float Vector4::operator[](int index) const
+{
+	return (&x)[index];
+}
+
+inline float& Vector4::operator[](int index)
+{
+	return (&x)[index];
+}
+
+inline void Vector4::set(float x, float y, float z, float w)
+{
+	this->x = x;
+	this->y = y;
+	this->z = z;
+	this->w = w;
+}
+
+inline float Vector4::length() const
+{
+	return sqrtf(x * x + y * y + z * z + w * w);
+}
+
+inline float Vector4::distance(const Vector4& vec) const
+{
+	return sqrtf((vec.x - x) * (vec.x - x) + (vec.y - y) * (vec.y - y) + (vec.z - z) * (vec.z - z) + (vec.w - w) * (vec.w - w));
+}
+
+inline Vector4& Vector4::normalize()
+{
+	//NOTE: leave w-component untouched
+	//@@const float EPSILON = 0.000001f;
+	float xxyyzz = x * x + y * y + z * z;
+	//@@if(xxyyzz < EPSILON)
+	//@@    return *this; // do nothing if it is zero vector
+
+	//float invLength = invSqrt(xxyyzz);
+	float invLength = 1.0f / sqrtf(xxyyzz);
+	x *= invLength;
+	y *= invLength;
+	z *= invLength;
+	return *this;
+}
+
+inline float Vector4::dot(const Vector4& rhs) const
+{
+	return (x * rhs.x + y * rhs.y + z * rhs.z + w * rhs.w);
+}
+
+inline bool Vector4::equal(const Vector4& rhs, float epsilon) const
+{
+	return fabs(x - rhs.x) < epsilon && fabs(y - rhs.y) < epsilon &&
+		   fabs(z - rhs.z) < epsilon && fabs(w - rhs.w) < epsilon;
+}
+
+inline Vector4 operator*(const float a, const Vector4 vec)
+{
+	return Vector4(a * vec.x, a * vec.y, a * vec.z, a * vec.w);
+}
+
+inline std::ostream& operator<<(std::ostream& os, const Vector4& vec)
+{
+	os << "(" << vec.x << ", " << vec.y << ", " << vec.z << ", " << vec.w << ")";
+	return os;
+}
+// END OF VECTOR4 /////////////////////////////////////////////////////////////
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/openvr/samples/shared/compat.h b/engine/inc/bullet/ThirdPartyLibs/openvr/samples/shared/compat.h
new file mode 100644
index 00000000..a3b2f321
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/openvr/samples/shared/compat.h
@@ -0,0 +1,28 @@
+#ifndef OPENVR_SAMPLES_SHARED_COMPAT_H_
+#define OPENVR_SAMPLES_SHARED_COMPAT_H_
+
+#include <cstdio>
+#include <cstring>
+#include <cassert>
+
+// Handle non standard code.
+#ifndef _WIN32
+
+#include <cstdbool>
+#include <unistd.h>
+
+#define sprintf_s snprintf
+#define vsprintf_s sprintf
+#define _stricmp strcmp
+#define stricmp strcmp
+#define strnicmp strncasecmp
+#define strcpy_s(dst, n, src) int(strncpy(dst, src, n) != nullptr)
+#define fopen_s(fd, path, mode) int((*fd = fopen(path, mode)) != nullptr)
+#define _vsnprintf_s(buffer, size, fmt, ap) vsnprintf(buffer, size, fmt, ap)
+#define OutputDebugStringA(x) fprintf(stderr, "%s\n", x)
+
+typedef int errno_t;
+
+#endif  // _WIN32
+
+#endif  // OPENVR_SAMPLES_SHARED_COMPAT_H_
diff --git a/engine/inc/bullet/ThirdPartyLibs/openvr/samples/shared/lodepng.h b/engine/inc/bullet/ThirdPartyLibs/openvr/samples/shared/lodepng.h
new file mode 100644
index 00000000..68eeef9a
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/openvr/samples/shared/lodepng.h
@@ -0,0 +1,1696 @@
+/*
+LodePNG version 20140823
+
+Copyright (c) 2005-2014 Lode Vandevenne
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+    1. The origin of this software must not be misrepresented; you must not
+    claim that you wrote the original software. If you use this software
+    in a product, an acknowledgment in the product documentation would be
+    appreciated but is not required.
+
+    2. Altered source versions must be plainly marked as such, and must not be
+    misrepresented as being the original software.
+
+    3. This notice may not be removed or altered from any source
+    distribution.
+*/
+
+#ifndef LODEPNG_H
+#define LODEPNG_H
+
+#include <string.h> /*for size_t*/
+
+#ifdef __cplusplus
+#include <vector>
+#include <string>
+#endif /*__cplusplus*/
+
+/*
+The following #defines are used to create code sections. They can be disabled
+to disable code sections, which can give faster compile time and smaller binary.
+The "NO_COMPILE" defines are designed to be used to pass as defines to the
+compiler command to disable them without modifying this header, e.g.
+-DLODEPNG_NO_COMPILE_ZLIB for gcc.
+*/
+/*deflate & zlib. If disabled, you must specify alternative zlib functions in
+the custom_zlib field of the compress and decompress settings*/
+#ifndef LODEPNG_NO_COMPILE_ZLIB
+#define LODEPNG_COMPILE_ZLIB
+#endif
+/*png encoder and png decoder*/
+#ifndef LODEPNG_NO_COMPILE_PNG
+#define LODEPNG_COMPILE_PNG
+#endif
+/*deflate&zlib decoder and png decoder*/
+#ifndef LODEPNG_NO_COMPILE_DECODER
+#define LODEPNG_COMPILE_DECODER
+#endif
+/*deflate&zlib encoder and png encoder*/
+#ifndef LODEPNG_NO_COMPILE_ENCODER
+#define LODEPNG_COMPILE_ENCODER
+#endif
+/*the optional built in harddisk file loading and saving functions*/
+#ifndef LODEPNG_NO_COMPILE_DISK
+#define LODEPNG_COMPILE_DISK
+#endif
+/*support for chunks other than IHDR, IDAT, PLTE, tRNS, IEND: ancillary and unknown chunks*/
+#ifndef LODEPNG_NO_COMPILE_ANCILLARY_CHUNKS
+#define LODEPNG_COMPILE_ANCILLARY_CHUNKS
+#endif
+/*ability to convert error numerical codes to English text string*/
+#ifndef LODEPNG_NO_COMPILE_ERROR_TEXT
+#define LODEPNG_COMPILE_ERROR_TEXT
+#endif
+/*Compile the default allocators (C's free, malloc and realloc). If you disable this,
+you can define the functions lodepng_free, lodepng_malloc and lodepng_realloc in your
+source files with custom allocators.*/
+#ifndef LODEPNG_NO_COMPILE_ALLOCATORS
+#define LODEPNG_COMPILE_ALLOCATORS
+#endif
+/*compile the C++ version (you can disable the C++ wrapper here even when compiling for C++)*/
+#ifdef __cplusplus
+#ifndef LODEPNG_NO_COMPILE_CPP
+#define LODEPNG_COMPILE_CPP
+#endif
+#endif
+
+#ifdef LODEPNG_COMPILE_PNG
+/*The PNG color types (also used for raw).*/
+typedef enum LodePNGColorType
+{
+	LCT_GREY = 0,       /*greyscale: 1,2,4,8,16 bit*/
+	LCT_RGB = 2,        /*RGB: 8,16 bit*/
+	LCT_PALETTE = 3,    /*palette: 1,2,4,8 bit*/
+	LCT_GREY_ALPHA = 4, /*greyscale with alpha: 8,16 bit*/
+	LCT_RGBA = 6        /*RGB with alpha: 8,16 bit*/
+} LodePNGColorType;
+
+#ifdef LODEPNG_COMPILE_DECODER
+/*
+Converts PNG data in memory to raw pixel data.
+out: Output parameter. Pointer to buffer that will contain the raw pixel data.
+     After decoding, its size is w * h * (bytes per pixel) bytes larger than
+     initially. Bytes per pixel depends on colortype and bitdepth.
+     Must be freed after usage with free(*out).
+     Note: for 16-bit per channel colors, uses big endian format like PNG does.
+w: Output parameter. Pointer to width of pixel data.
+h: Output parameter. Pointer to height of pixel data.
+in: Memory buffer with the PNG file.
+insize: size of the in buffer.
+colortype: the desired color type for the raw output image. See explanation on PNG color types.
+bitdepth: the desired bit depth for the raw output image. See explanation on PNG color types.
+Return value: LodePNG error code (0 means no error).
+*/
+unsigned lodepng_decode_memory(unsigned char** out, unsigned* w, unsigned* h,
+							   const unsigned char* in, size_t insize,
+							   LodePNGColorType colortype, unsigned bitdepth);
+
+/*Same as lodepng_decode_memory, but always decodes to 32-bit RGBA raw image*/
+unsigned lodepng_decode32(unsigned char** out, unsigned* w, unsigned* h,
+						  const unsigned char* in, size_t insize);
+
+/*Same as lodepng_decode_memory, but always decodes to 24-bit RGB raw image*/
+unsigned lodepng_decode24(unsigned char** out, unsigned* w, unsigned* h,
+						  const unsigned char* in, size_t insize);
+
+#ifdef LODEPNG_COMPILE_DISK
+/*
+Load PNG from disk, from file with given name.
+Same as the other decode functions, but instead takes a filename as input.
+*/
+unsigned lodepng_decode_file(unsigned char** out, unsigned* w, unsigned* h,
+							 const char* filename,
+							 LodePNGColorType colortype, unsigned bitdepth);
+
+/*Same as lodepng_decode_file, but always decodes to 32-bit RGBA raw image.*/
+unsigned lodepng_decode32_file(unsigned char** out, unsigned* w, unsigned* h,
+							   const char* filename);
+
+/*Same as lodepng_decode_file, but always decodes to 24-bit RGB raw image.*/
+unsigned lodepng_decode24_file(unsigned char** out, unsigned* w, unsigned* h,
+							   const char* filename);
+#endif /*LODEPNG_COMPILE_DISK*/
+#endif /*LODEPNG_COMPILE_DECODER*/
+
+#ifdef LODEPNG_COMPILE_ENCODER
+/*
+Converts raw pixel data into a PNG image in memory. The colortype and bitdepth
+  of the output PNG image cannot be chosen, they are automatically determined
+  by the colortype, bitdepth and content of the input pixel data.
+  Note: for 16-bit per channel colors, needs big endian format like PNG does.
+out: Output parameter. Pointer to buffer that will contain the PNG image data.
+     Must be freed after usage with free(*out).
+outsize: Output parameter. Pointer to the size in bytes of the out buffer.
+image: The raw pixel data to encode. The size of this buffer should be
+       w * h * (bytes per pixel), bytes per pixel depends on colortype and bitdepth.
+w: width of the raw pixel data in pixels.
+h: height of the raw pixel data in pixels.
+colortype: the color type of the raw input image. See explanation on PNG color types.
+bitdepth: the bit depth of the raw input image. See explanation on PNG color types.
+Return value: LodePNG error code (0 means no error).
+*/
+unsigned lodepng_encode_memory(unsigned char** out, size_t* outsize,
+							   const unsigned char* image, unsigned w, unsigned h,
+							   LodePNGColorType colortype, unsigned bitdepth);
+
+/*Same as lodepng_encode_memory, but always encodes from 32-bit RGBA raw image.*/
+unsigned lodepng_encode32(unsigned char** out, size_t* outsize,
+						  const unsigned char* image, unsigned w, unsigned h);
+
+/*Same as lodepng_encode_memory, but always encodes from 24-bit RGB raw image.*/
+unsigned lodepng_encode24(unsigned char** out, size_t* outsize,
+						  const unsigned char* image, unsigned w, unsigned h);
+
+#ifdef LODEPNG_COMPILE_DISK
+/*
+Converts raw pixel data into a PNG file on disk.
+Same as the other encode functions, but instead takes a filename as output.
+NOTE: This overwrites existing files without warning!
+*/
+unsigned lodepng_encode_file(const char* filename,
+							 const unsigned char* image, unsigned w, unsigned h,
+							 LodePNGColorType colortype, unsigned bitdepth);
+
+/*Same as lodepng_encode_file, but always encodes from 32-bit RGBA raw image.*/
+unsigned lodepng_encode32_file(const char* filename,
+							   const unsigned char* image, unsigned w, unsigned h);
+
+/*Same as lodepng_encode_file, but always encodes from 24-bit RGB raw image.*/
+unsigned lodepng_encode24_file(const char* filename,
+							   const unsigned char* image, unsigned w, unsigned h);
+#endif /*LODEPNG_COMPILE_DISK*/
+#endif /*LODEPNG_COMPILE_ENCODER*/
+
+#ifdef LODEPNG_COMPILE_CPP
+namespace lodepng
+{
+#ifdef LODEPNG_COMPILE_DECODER
+/*Same as lodepng_decode_memory, but decodes to an std::vector. The colortype
+is the format to output the pixels to. Default is RGBA 8-bit per channel.*/
+unsigned decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h,
+				const unsigned char* in, size_t insize,
+				LodePNGColorType colortype = LCT_RGBA, unsigned bitdepth = 8);
+unsigned decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h,
+				const std::vector<unsigned char>& in,
+				LodePNGColorType colortype = LCT_RGBA, unsigned bitdepth = 8);
+#ifdef LODEPNG_COMPILE_DISK
+/*
+Converts PNG file from disk to raw pixel data in memory.
+Same as the other decode functions, but instead takes a filename as input.
+*/
+unsigned decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h,
+				const std::string& filename,
+				LodePNGColorType colortype = LCT_RGBA, unsigned bitdepth = 8);
+#endif  //LODEPNG_COMPILE_DISK
+#endif  //LODEPNG_COMPILE_DECODER
+
+#ifdef LODEPNG_COMPILE_ENCODER
+/*Same as lodepng_encode_memory, but encodes to an std::vector. colortype
+is that of the raw input data. The output PNG color type will be auto chosen.*/
+unsigned encode(std::vector<unsigned char>& out,
+				const unsigned char* in, unsigned w, unsigned h,
+				LodePNGColorType colortype = LCT_RGBA, unsigned bitdepth = 8);
+unsigned encode(std::vector<unsigned char>& out,
+				const std::vector<unsigned char>& in, unsigned w, unsigned h,
+				LodePNGColorType colortype = LCT_RGBA, unsigned bitdepth = 8);
+#ifdef LODEPNG_COMPILE_DISK
+/*
+Converts 32-bit RGBA raw pixel data into a PNG file on disk.
+Same as the other encode functions, but instead takes a filename as output.
+NOTE: This overwrites existing files without warning!
+*/
+unsigned encode(const std::string& filename,
+				const unsigned char* in, unsigned w, unsigned h,
+				LodePNGColorType colortype = LCT_RGBA, unsigned bitdepth = 8);
+unsigned encode(const std::string& filename,
+				const std::vector<unsigned char>& in, unsigned w, unsigned h,
+				LodePNGColorType colortype = LCT_RGBA, unsigned bitdepth = 8);
+#endif  //LODEPNG_COMPILE_DISK
+#endif  //LODEPNG_COMPILE_ENCODER
+}  //namespace lodepng
+#endif /*LODEPNG_COMPILE_CPP*/
+#endif /*LODEPNG_COMPILE_PNG*/
+
+#ifdef LODEPNG_COMPILE_ERROR_TEXT
+/*Returns an English description of the numerical error code.*/
+const char* lodepng_error_text(unsigned code);
+#endif /*LODEPNG_COMPILE_ERROR_TEXT*/
+
+#ifdef LODEPNG_COMPILE_DECODER
+/*Settings for zlib decompression*/
+typedef struct LodePNGDecompressSettings LodePNGDecompressSettings;
+struct LodePNGDecompressSettings
+{
+	unsigned ignore_adler32; /*if 1, continue and don't give an error message if the Adler32 checksum is corrupted*/
+
+	/*use custom zlib decoder instead of built in one (default: null)*/
+	unsigned (*custom_zlib)(unsigned char**, size_t*,
+							const unsigned char*, size_t,
+							const LodePNGDecompressSettings*);
+	/*use custom deflate decoder instead of built in one (default: null)
+  if custom_zlib is used, custom_deflate is ignored since only the built in
+  zlib function will call custom_deflate*/
+	unsigned (*custom_inflate)(unsigned char**, size_t*,
+							   const unsigned char*, size_t,
+							   const LodePNGDecompressSettings*);
+
+	const void* custom_context; /*optional custom settings for custom functions*/
+};
+
+extern const LodePNGDecompressSettings lodepng_default_decompress_settings;
+void lodepng_decompress_settings_init(LodePNGDecompressSettings* settings);
+#endif /*LODEPNG_COMPILE_DECODER*/
+
+#ifdef LODEPNG_COMPILE_ENCODER
+/*
+Settings for zlib compression. Tweaking these settings tweaks the balance
+between speed and compression ratio.
+*/
+typedef struct LodePNGCompressSettings LodePNGCompressSettings;
+struct LodePNGCompressSettings /*deflate = compress*/
+{
+	/*LZ77 related settings*/
+	unsigned btype;        /*the block type for LZ (0, 1, 2 or 3, see zlib standard). Should be 2 for proper compression.*/
+	unsigned use_lz77;     /*whether or not to use LZ77. Should be 1 for proper compression.*/
+	unsigned windowsize;   /*must be a power of two <= 32768. higher compresses more but is slower. Default value: 2048.*/
+	unsigned minmatch;     /*mininum lz77 length. 3 is normally best, 6 can be better for some PNGs. Default: 0*/
+	unsigned nicematch;    /*stop searching if >= this length found. Set to 258 for best compression. Default: 128*/
+	unsigned lazymatching; /*use lazy matching: better compression but a bit slower. Default: true*/
+
+	/*use custom zlib encoder instead of built in one (default: null)*/
+	unsigned (*custom_zlib)(unsigned char**, size_t*,
+							const unsigned char*, size_t,
+							const LodePNGCompressSettings*);
+	/*use custom deflate encoder instead of built in one (default: null)
+  if custom_zlib is used, custom_deflate is ignored since only the built in
+  zlib function will call custom_deflate*/
+	unsigned (*custom_deflate)(unsigned char**, size_t*,
+							   const unsigned char*, size_t,
+							   const LodePNGCompressSettings*);
+
+	const void* custom_context; /*optional custom settings for custom functions*/
+};
+
+extern const LodePNGCompressSettings lodepng_default_compress_settings;
+void lodepng_compress_settings_init(LodePNGCompressSettings* settings);
+#endif /*LODEPNG_COMPILE_ENCODER*/
+
+#ifdef LODEPNG_COMPILE_PNG
+/*
+Color mode of an image. Contains all information required to decode the pixel
+bits to RGBA colors. This information is the same as used in the PNG file
+format, and is used both for PNG and raw image data in LodePNG.
+*/
+typedef struct LodePNGColorMode
+{
+	/*header (IHDR)*/
+	LodePNGColorType colortype; /*color type, see PNG standard or documentation further in this header file*/
+	unsigned bitdepth;          /*bits per sample, see PNG standard or documentation further in this header file*/
+
+	/*
+  palette (PLTE and tRNS)
+
+  Dynamically allocated with the colors of the palette, including alpha.
+  When encoding a PNG, to store your colors in the palette of the LodePNGColorMode, first use
+  lodepng_palette_clear, then for each color use lodepng_palette_add.
+  If you encode an image without alpha with palette, don't forget to put value 255 in each A byte of the palette.
+
+  When decoding, by default you can ignore this palette, since LodePNG already
+  fills the palette colors in the pixels of the raw RGBA output.
+
+  The palette is only supported for color type 3.
+  */
+	unsigned char* palette; /*palette in RGBARGBA... order. When allocated, must be either 0, or have size 1024*/
+	size_t palettesize;     /*palette size in number of colors (amount of bytes is 4 * palettesize)*/
+
+	/*
+  transparent color key (tRNS)
+
+  This color uses the same bit depth as the bitdepth value in this struct, which can be 1-bit to 16-bit.
+  For greyscale PNGs, r, g and b will all 3 be set to the same.
+
+  When decoding, by default you can ignore this information, since LodePNG sets
+  pixels with this key to transparent already in the raw RGBA output.
+
+  The color key is only supported for color types 0 and 2.
+  */
+	unsigned key_defined; /*is a transparent color key given? 0 = false, 1 = true*/
+	unsigned key_r;       /*red/greyscale component of color key*/
+	unsigned key_g;       /*green component of color key*/
+	unsigned key_b;       /*blue component of color key*/
+} LodePNGColorMode;
+
+/*init, cleanup and copy functions to use with this struct*/
+void lodepng_color_mode_init(LodePNGColorMode* info);
+void lodepng_color_mode_cleanup(LodePNGColorMode* info);
+/*return value is error code (0 means no error)*/
+unsigned lodepng_color_mode_copy(LodePNGColorMode* dest, const LodePNGColorMode* source);
+
+void lodepng_palette_clear(LodePNGColorMode* info);
+/*add 1 color to the palette*/
+unsigned lodepng_palette_add(LodePNGColorMode* info,
+							 unsigned char r, unsigned char g, unsigned char b, unsigned char a);
+
+/*get the total amount of bits per pixel, based on colortype and bitdepth in the struct*/
+unsigned lodepng_get_bpp(const LodePNGColorMode* info);
+/*get the amount of color channels used, based on colortype in the struct.
+If a palette is used, it counts as 1 channel.*/
+unsigned lodepng_get_channels(const LodePNGColorMode* info);
+/*is it a greyscale type? (only colortype 0 or 4)*/
+unsigned lodepng_is_greyscale_type(const LodePNGColorMode* info);
+/*has it got an alpha channel? (only colortype 2 or 6)*/
+unsigned lodepng_is_alpha_type(const LodePNGColorMode* info);
+/*has it got a palette? (only colortype 3)*/
+unsigned lodepng_is_palette_type(const LodePNGColorMode* info);
+/*only returns true if there is a palette and there is a value in the palette with alpha < 255.
+Loops through the palette to check this.*/
+unsigned lodepng_has_palette_alpha(const LodePNGColorMode* info);
+/*
+Check if the given color info indicates the possibility of having non-opaque pixels in the PNG image.
+Returns true if the image can have translucent or invisible pixels (it still be opaque if it doesn't use such pixels).
+Returns false if the image can only have opaque pixels.
+In detail, it returns true only if it's a color type with alpha, or has a palette with non-opaque values,
+or if "key_defined" is true.
+*/
+unsigned lodepng_can_have_alpha(const LodePNGColorMode* info);
+/*Returns the byte size of a raw image buffer with given width, height and color mode*/
+size_t lodepng_get_raw_size(unsigned w, unsigned h, const LodePNGColorMode* color);
+
+#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
+/*The information of a Time chunk in PNG.*/
+typedef struct LodePNGTime
+{
+	unsigned year;   /*2 bytes used (0-65535)*/
+	unsigned month;  /*1-12*/
+	unsigned day;    /*1-31*/
+	unsigned hour;   /*0-23*/
+	unsigned minute; /*0-59*/
+	unsigned second; /*0-60 (to allow for leap seconds)*/
+} LodePNGTime;
+#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
+
+/*Information about the PNG image, except pixels, width and height.*/
+typedef struct LodePNGInfo
+{
+	/*header (IHDR), palette (PLTE) and transparency (tRNS) chunks*/
+	unsigned compression_method; /*compression method of the original file. Always 0.*/
+	unsigned filter_method;      /*filter method of the original file*/
+	unsigned interlace_method;   /*interlace method of the original file*/
+	LodePNGColorMode color;      /*color type and bits, palette and transparency of the PNG file*/
+
+#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
+	/*
+  suggested background color chunk (bKGD)
+  This color uses the same color mode as the PNG (except alpha channel), which can be 1-bit to 16-bit.
+
+  For greyscale PNGs, r, g and b will all 3 be set to the same. When encoding
+  the encoder writes the red one. For palette PNGs: When decoding, the RGB value
+  will be stored, not a palette index. But when encoding, specify the index of
+  the palette in background_r, the other two are then ignored.
+
+  The decoder does not use this background color to edit the color of pixels.
+  */
+	unsigned background_defined; /*is a suggested background color given?*/
+	unsigned background_r;       /*red component of suggested background color*/
+	unsigned background_g;       /*green component of suggested background color*/
+	unsigned background_b;       /*blue component of suggested background color*/
+
+	/*
+  non-international text chunks (tEXt and zTXt)
+
+  The char** arrays each contain num strings. The actual messages are in
+  text_strings, while text_keys are keywords that give a short description what
+  the actual text represents, e.g. Title, Author, Description, or anything else.
+
+  A keyword is minimum 1 character and maximum 79 characters long. It's
+  discouraged to use a single line length longer than 79 characters for texts.
+
+  Don't allocate these text buffers yourself. Use the init/cleanup functions
+  correctly and use lodepng_add_text and lodepng_clear_text.
+  */
+	size_t text_num;     /*the amount of texts in these char** buffers (there may be more texts in itext)*/
+	char** text_keys;    /*the keyword of a text chunk (e.g. "Comment")*/
+	char** text_strings; /*the actual text*/
+
+	/*
+  international text chunks (iTXt)
+  Similar to the non-international text chunks, but with additional strings
+  "langtags" and "transkeys".
+  */
+	size_t itext_num;       /*the amount of international texts in this PNG*/
+	char** itext_keys;      /*the English keyword of the text chunk (e.g. "Comment")*/
+	char** itext_langtags;  /*language tag for this text's language, ISO/IEC 646 string, e.g. ISO 639 language tag*/
+	char** itext_transkeys; /*keyword translated to the international language - UTF-8 string*/
+	char** itext_strings;   /*the actual international text - UTF-8 string*/
+
+	/*time chunk (tIME)*/
+	unsigned time_defined; /*set to 1 to make the encoder generate a tIME chunk*/
+	LodePNGTime time;
+
+	/*phys chunk (pHYs)*/
+	unsigned phys_defined; /*if 0, there is no pHYs chunk and the values below are undefined, if 1 else there is one*/
+	unsigned phys_x;       /*pixels per unit in x direction*/
+	unsigned phys_y;       /*pixels per unit in y direction*/
+	unsigned phys_unit;    /*may be 0 (unknown unit) or 1 (metre)*/
+
+	/*
+  unknown chunks
+  There are 3 buffers, one for each position in the PNG where unknown chunks can appear
+  each buffer contains all unknown chunks for that position consecutively
+  The 3 buffers are the unknown chunks between certain critical chunks:
+  0: IHDR-PLTE, 1: PLTE-IDAT, 2: IDAT-IEND
+  Do not allocate or traverse this data yourself. Use the chunk traversing functions declared
+  later, such as lodepng_chunk_next and lodepng_chunk_append, to read/write this struct.
+  */
+	unsigned char* unknown_chunks_data[3];
+	size_t unknown_chunks_size[3]; /*size in bytes of the unknown chunks, given for protection*/
+#endif                             /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
+} LodePNGInfo;
+
+/*init, cleanup and copy functions to use with this struct*/
+void lodepng_info_init(LodePNGInfo* info);
+void lodepng_info_cleanup(LodePNGInfo* info);
+/*return value is error code (0 means no error)*/
+unsigned lodepng_info_copy(LodePNGInfo* dest, const LodePNGInfo* source);
+
+#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
+void lodepng_clear_text(LodePNGInfo* info);                                     /*use this to clear the texts again after you filled them in*/
+unsigned lodepng_add_text(LodePNGInfo* info, const char* key, const char* str); /*push back both texts at once*/
+
+void lodepng_clear_itext(LodePNGInfo* info); /*use this to clear the itexts again after you filled them in*/
+unsigned lodepng_add_itext(LodePNGInfo* info, const char* key, const char* langtag,
+						   const char* transkey, const char* str); /*push back the 4 texts of 1 chunk at once*/
+#endif                                                             /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
+
+/*
+Converts raw buffer from one color type to another color type, based on
+LodePNGColorMode structs to describe the input and output color type.
+See the reference manual at the end of this header file to see which color conversions are supported.
+return value = LodePNG error code (0 if all went ok, an error if the conversion isn't supported)
+The out buffer must have size (w * h * bpp + 7) / 8, where bpp is the bits per pixel
+of the output color type (lodepng_get_bpp).
+For < 8 bpp images, there should not be padding bits at the end of scanlines.
+For 16-bit per channel colors, uses big endian format like PNG does.
+Return value is LodePNG error code
+*/
+unsigned lodepng_convert(unsigned char* out, const unsigned char* in,
+						 LodePNGColorMode* mode_out, const LodePNGColorMode* mode_in,
+						 unsigned w, unsigned h);
+
+#ifdef LODEPNG_COMPILE_DECODER
+/*
+Settings for the decoder. This contains settings for the PNG and the Zlib
+decoder, but not the Info settings from the Info structs.
+*/
+typedef struct LodePNGDecoderSettings
+{
+	LodePNGDecompressSettings zlibsettings; /*in here is the setting to ignore Adler32 checksums*/
+
+	unsigned ignore_crc; /*ignore CRC checksums*/
+
+	unsigned color_convert; /*whether to convert the PNG to the color type you want. Default: yes*/
+
+#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
+	unsigned read_text_chunks; /*if false but remember_unknown_chunks is true, they're stored in the unknown chunks*/
+	/*store all bytes from unknown chunks in the LodePNGInfo (off by default, useful for a png editor)*/
+	unsigned remember_unknown_chunks;
+#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
+} LodePNGDecoderSettings;
+
+void lodepng_decoder_settings_init(LodePNGDecoderSettings* settings);
+#endif /*LODEPNG_COMPILE_DECODER*/
+
+#ifdef LODEPNG_COMPILE_ENCODER
+/*automatically use color type with less bits per pixel if losslessly possible. Default: AUTO*/
+typedef enum LodePNGFilterStrategy
+{
+	/*every filter at zero*/
+	LFS_ZERO,
+	/*Use filter that gives minumum sum, as described in the official PNG filter heuristic.*/
+	LFS_MINSUM,
+	/*Use the filter type that gives smallest Shannon entropy for this scanline. Depending
+  on the image, this is better or worse than minsum.*/
+	LFS_ENTROPY,
+	/*
+  Brute-force-search PNG filters by compressing each filter for each scanline.
+  Experimental, very slow, and only rarely gives better compression than MINSUM.
+  */
+	LFS_BRUTE_FORCE,
+	/*use predefined_filters buffer: you specify the filter type for each scanline*/
+	LFS_PREDEFINED
+} LodePNGFilterStrategy;
+
+/*Gives characteristics about the colors of the image, which helps decide which color model to use for encoding.
+Used internally by default if "auto_convert" is enabled. Public because it's useful for custom algorithms.*/
+typedef struct LodePNGColorProfile
+{
+	unsigned colored;     /*not greyscale*/
+	unsigned key;         /*if true, image is not opaque. Only if true and alpha is false, color key is possible.*/
+	unsigned short key_r; /*these values are always in 16-bit bitdepth in the profile*/
+	unsigned short key_g;
+	unsigned short key_b;
+	unsigned alpha;              /*alpha channel or alpha palette required*/
+	unsigned numcolors;          /*amount of colors, up to 257. Not valid if bits == 16.*/
+	unsigned char palette[1024]; /*Remembers up to the first 256 RGBA colors, in no particular order*/
+	unsigned bits;               /*bits per channel (not for palette). 1,2 or 4 for greyscale only. 16 if 16-bit per channel required.*/
+} LodePNGColorProfile;
+
+void lodepng_color_profile_init(LodePNGColorProfile* profile);
+
+/*Get a LodePNGColorProfile of the image.*/
+unsigned get_color_profile(LodePNGColorProfile* profile,
+						   const unsigned char* image, unsigned w, unsigned h,
+						   const LodePNGColorMode* mode_in);
+/*The function LodePNG uses internally to decide the PNG color with auto_convert.
+Chooses an optimal color model, e.g. grey if only grey pixels, palette if < 256 colors, ...*/
+unsigned lodepng_auto_choose_color(LodePNGColorMode* mode_out,
+								   const unsigned char* image, unsigned w, unsigned h,
+								   const LodePNGColorMode* mode_in);
+
+/*Settings for the encoder.*/
+typedef struct LodePNGEncoderSettings
+{
+	LodePNGCompressSettings zlibsettings; /*settings for the zlib encoder, such as window size, ...*/
+
+	unsigned auto_convert; /*automatically choose output PNG color type. Default: true*/
+
+	/*If true, follows the official PNG heuristic: if the PNG uses a palette or lower than
+  8 bit depth, set all filters to zero. Otherwise use the filter_strategy. Note that to
+  completely follow the official PNG heuristic, filter_palette_zero must be true and
+  filter_strategy must be LFS_MINSUM*/
+	unsigned filter_palette_zero;
+	/*Which filter strategy to use when not using zeroes due to filter_palette_zero.
+  Set filter_palette_zero to 0 to ensure always using your chosen strategy. Default: LFS_MINSUM*/
+	LodePNGFilterStrategy filter_strategy;
+	/*used if filter_strategy is LFS_PREDEFINED. In that case, this must point to a buffer with
+  the same length as the amount of scanlines in the image, and each value must <= 5. You
+  have to cleanup this buffer, LodePNG will never free it. Don't forget that filter_palette_zero
+  must be set to 0 to ensure this is also used on palette or low bitdepth images.*/
+	const unsigned char* predefined_filters;
+
+	/*force creating a PLTE chunk if colortype is 2 or 6 (= a suggested palette).
+  If colortype is 3, PLTE is _always_ created.*/
+	unsigned force_palette;
+#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
+	/*add LodePNG identifier and version as a text chunk, for debugging*/
+	unsigned add_id;
+	/*encode text chunks as zTXt chunks instead of tEXt chunks, and use compression in iTXt chunks*/
+	unsigned text_compression;
+#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
+} LodePNGEncoderSettings;
+
+void lodepng_encoder_settings_init(LodePNGEncoderSettings* settings);
+#endif /*LODEPNG_COMPILE_ENCODER*/
+
+#if defined(LODEPNG_COMPILE_DECODER) || defined(LODEPNG_COMPILE_ENCODER)
+/*The settings, state and information for extended encoding and decoding.*/
+typedef struct LodePNGState
+{
+#ifdef LODEPNG_COMPILE_DECODER
+	LodePNGDecoderSettings decoder; /*the decoding settings*/
+#endif                              /*LODEPNG_COMPILE_DECODER*/
+#ifdef LODEPNG_COMPILE_ENCODER
+	LodePNGEncoderSettings encoder; /*the encoding settings*/
+#endif                              /*LODEPNG_COMPILE_ENCODER*/
+	LodePNGColorMode info_raw;      /*specifies the format in which you would like to get the raw pixel buffer*/
+	LodePNGInfo info_png;           /*info of the PNG image obtained after decoding*/
+	unsigned error;
+#ifdef LODEPNG_COMPILE_CPP
+	//For the lodepng::State subclass.
+	virtual ~LodePNGState() {}
+#endif
+} LodePNGState;
+
+/*init, cleanup and copy functions to use with this struct*/
+void lodepng_state_init(LodePNGState* state);
+void lodepng_state_cleanup(LodePNGState* state);
+void lodepng_state_copy(LodePNGState* dest, const LodePNGState* source);
+#endif /* defined(LODEPNG_COMPILE_DECODER) || defined(LODEPNG_COMPILE_ENCODER) */
+
+#ifdef LODEPNG_COMPILE_DECODER
+/*
+Same as lodepng_decode_memory, but uses a LodePNGState to allow custom settings and
+getting much more information about the PNG image and color mode.
+*/
+unsigned lodepng_decode(unsigned char** out, unsigned* w, unsigned* h,
+						LodePNGState* state,
+						const unsigned char* in, size_t insize);
+
+/*
+Read the PNG header, but not the actual data. This returns only the information
+that is in the header chunk of the PNG, such as width, height and color type. The
+information is placed in the info_png field of the LodePNGState.
+*/
+unsigned lodepng_inspect(unsigned* w, unsigned* h,
+						 LodePNGState* state,
+						 const unsigned char* in, size_t insize);
+#endif /*LODEPNG_COMPILE_DECODER*/
+
+#ifdef LODEPNG_COMPILE_ENCODER
+/*This function allocates the out buffer with standard malloc and stores the size in *outsize.*/
+unsigned lodepng_encode(unsigned char** out, size_t* outsize,
+						const unsigned char* image, unsigned w, unsigned h,
+						LodePNGState* state);
+#endif /*LODEPNG_COMPILE_ENCODER*/
+
+/*
+The lodepng_chunk functions are normally not needed, except to traverse the
+unknown chunks stored in the LodePNGInfo struct, or add new ones to it.
+It also allows traversing the chunks of an encoded PNG file yourself.
+
+PNG standard chunk naming conventions:
+First byte: uppercase = critical, lowercase = ancillary
+Second byte: uppercase = public, lowercase = private
+Third byte: must be uppercase
+Fourth byte: uppercase = unsafe to copy, lowercase = safe to copy
+*/
+
+/*get the length of the data of the chunk. Total chunk length has 12 bytes more.*/
+unsigned lodepng_chunk_length(const unsigned char* chunk);
+
+/*puts the 4-byte type in null terminated string*/
+void lodepng_chunk_type(char type[5], const unsigned char* chunk);
+
+/*check if the type is the given type*/
+unsigned char lodepng_chunk_type_equals(const unsigned char* chunk, const char* type);
+
+/*0: it's one of the critical chunk types, 1: it's an ancillary chunk (see PNG standard)*/
+unsigned char lodepng_chunk_ancillary(const unsigned char* chunk);
+
+/*0: public, 1: private (see PNG standard)*/
+unsigned char lodepng_chunk_private(const unsigned char* chunk);
+
+/*0: the chunk is unsafe to copy, 1: the chunk is safe to copy (see PNG standard)*/
+unsigned char lodepng_chunk_safetocopy(const unsigned char* chunk);
+
+/*get pointer to the data of the chunk, where the input points to the header of the chunk*/
+unsigned char* lodepng_chunk_data(unsigned char* chunk);
+const unsigned char* lodepng_chunk_data_const(const unsigned char* chunk);
+
+/*returns 0 if the crc is correct, 1 if it's incorrect (0 for OK as usual!)*/
+unsigned lodepng_chunk_check_crc(const unsigned char* chunk);
+
+/*generates the correct CRC from the data and puts it in the last 4 bytes of the chunk*/
+void lodepng_chunk_generate_crc(unsigned char* chunk);
+
+/*iterate to next chunks. don't use on IEND chunk, as there is no next chunk then*/
+unsigned char* lodepng_chunk_next(unsigned char* chunk);
+const unsigned char* lodepng_chunk_next_const(const unsigned char* chunk);
+
+/*
+Appends chunk to the data in out. The given chunk should already have its chunk header.
+The out variable and outlength are updated to reflect the new reallocated buffer.
+Returns error code (0 if it went ok)
+*/
+unsigned lodepng_chunk_append(unsigned char** out, size_t* outlength, const unsigned char* chunk);
+
+/*
+Appends new chunk to out. The chunk to append is given by giving its length, type
+and data separately. The type is a 4-letter string.
+The out variable and outlength are updated to reflect the new reallocated buffer.
+Returne error code (0 if it went ok)
+*/
+unsigned lodepng_chunk_create(unsigned char** out, size_t* outlength, unsigned length,
+							  const char* type, const unsigned char* data);
+
+/*Calculate CRC32 of buffer*/
+unsigned lodepng_crc32(const unsigned char* buf, size_t len);
+#endif /*LODEPNG_COMPILE_PNG*/
+
+#ifdef LODEPNG_COMPILE_ZLIB
+/*
+This zlib part can be used independently to zlib compress and decompress a
+buffer. It cannot be used to create gzip files however, and it only supports the
+part of zlib that is required for PNG, it does not support dictionaries.
+*/
+
+#ifdef LODEPNG_COMPILE_DECODER
+/*Inflate a buffer. Inflate is the decompression step of deflate. Out buffer must be freed after use.*/
+unsigned lodepng_inflate(unsigned char** out, size_t* outsize,
+						 const unsigned char* in, size_t insize,
+						 const LodePNGDecompressSettings* settings);
+
+/*
+Decompresses Zlib data. Reallocates the out buffer and appends the data. The
+data must be according to the zlib specification.
+Either, *out must be NULL and *outsize must be 0, or, *out must be a valid
+buffer and *outsize its size in bytes. out must be freed by user after usage.
+*/
+unsigned lodepng_zlib_decompress(unsigned char** out, size_t* outsize,
+								 const unsigned char* in, size_t insize,
+								 const LodePNGDecompressSettings* settings);
+#endif /*LODEPNG_COMPILE_DECODER*/
+
+#ifdef LODEPNG_COMPILE_ENCODER
+/*
+Compresses data with Zlib. Reallocates the out buffer and appends the data.
+Zlib adds a small header and trailer around the deflate data.
+The data is output in the format of the zlib specification.
+Either, *out must be NULL and *outsize must be 0, or, *out must be a valid
+buffer and *outsize its size in bytes. out must be freed by user after usage.
+*/
+unsigned lodepng_zlib_compress(unsigned char** out, size_t* outsize,
+							   const unsigned char* in, size_t insize,
+							   const LodePNGCompressSettings* settings);
+
+/*
+Find length-limited Huffman code for given frequencies. This function is in the
+public interface only for tests, it's used internally by lodepng_deflate.
+*/
+unsigned lodepng_huffman_code_lengths(unsigned* lengths, const unsigned* frequencies,
+									  size_t numcodes, unsigned maxbitlen);
+
+/*Compress a buffer with deflate. See RFC 1951. Out buffer must be freed after use.*/
+unsigned lodepng_deflate(unsigned char** out, size_t* outsize,
+						 const unsigned char* in, size_t insize,
+						 const LodePNGCompressSettings* settings);
+
+#endif /*LODEPNG_COMPILE_ENCODER*/
+#endif /*LODEPNG_COMPILE_ZLIB*/
+
+#ifdef LODEPNG_COMPILE_DISK
+/*
+Load a file from disk into buffer. The function allocates the out buffer, and
+after usage you should free it.
+out: output parameter, contains pointer to loaded buffer.
+outsize: output parameter, size of the allocated out buffer
+filename: the path to the file to load
+return value: error code (0 means ok)
+*/
+unsigned lodepng_load_file(unsigned char** out, size_t* outsize, const char* filename);
+
+/*
+Save a file from buffer to disk. Warning, if it exists, this function overwrites
+the file without warning!
+buffer: the buffer to write
+buffersize: size of the buffer to write
+filename: the path to the file to save to
+return value: error code (0 means ok)
+*/
+unsigned lodepng_save_file(const unsigned char* buffer, size_t buffersize, const char* filename);
+#endif /*LODEPNG_COMPILE_DISK*/
+
+#ifdef LODEPNG_COMPILE_CPP
+//The LodePNG C++ wrapper uses std::vectors instead of manually allocated memory buffers.
+namespace lodepng
+{
+#ifdef LODEPNG_COMPILE_PNG
+class State : public LodePNGState
+{
+public:
+	State();
+	State(const State& other);
+	virtual ~State();
+	State& operator=(const State& other);
+};
+
+#ifdef LODEPNG_COMPILE_DECODER
+//Same as other lodepng::decode, but using a State for more settings and information.
+unsigned decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h,
+				State& state,
+				const unsigned char* in, size_t insize);
+unsigned decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h,
+				State& state,
+				const std::vector<unsigned char>& in);
+#endif /*LODEPNG_COMPILE_DECODER*/
+
+#ifdef LODEPNG_COMPILE_ENCODER
+//Same as other lodepng::encode, but using a State for more settings and information.
+unsigned encode(std::vector<unsigned char>& out,
+				const unsigned char* in, unsigned w, unsigned h,
+				State& state);
+unsigned encode(std::vector<unsigned char>& out,
+				const std::vector<unsigned char>& in, unsigned w, unsigned h,
+				State& state);
+#endif /*LODEPNG_COMPILE_ENCODER*/
+
+#ifdef LODEPNG_COMPILE_DISK
+/*
+Load a file from disk into an std::vector. If the vector is empty, then either
+the file doesn't exist or is an empty file.
+*/
+void load_file(std::vector<unsigned char>& buffer, const std::string& filename);
+
+/*
+Save the binary data in an std::vector to a file on disk. The file is overwritten
+without warning.
+*/
+void save_file(const std::vector<unsigned char>& buffer, const std::string& filename);
+#endif  //LODEPNG_COMPILE_DISK
+#endif  //LODEPNG_COMPILE_PNG
+
+#ifdef LODEPNG_COMPILE_ZLIB
+#ifdef LODEPNG_COMPILE_DECODER
+//Zlib-decompress an unsigned char buffer
+unsigned decompress(std::vector<unsigned char>& out, const unsigned char* in, size_t insize,
+					const LodePNGDecompressSettings& settings = lodepng_default_decompress_settings);
+
+//Zlib-decompress an std::vector
+unsigned decompress(std::vector<unsigned char>& out, const std::vector<unsigned char>& in,
+					const LodePNGDecompressSettings& settings = lodepng_default_decompress_settings);
+#endif  //LODEPNG_COMPILE_DECODER
+
+#ifdef LODEPNG_COMPILE_ENCODER
+//Zlib-compress an unsigned char buffer
+unsigned compress(std::vector<unsigned char>& out, const unsigned char* in, size_t insize,
+				  const LodePNGCompressSettings& settings = lodepng_default_compress_settings);
+
+//Zlib-compress an std::vector
+unsigned compress(std::vector<unsigned char>& out, const std::vector<unsigned char>& in,
+				  const LodePNGCompressSettings& settings = lodepng_default_compress_settings);
+#endif  //LODEPNG_COMPILE_ENCODER
+#endif  //LODEPNG_COMPILE_ZLIB
+}  //namespace lodepng
+#endif /*LODEPNG_COMPILE_CPP*/
+
+/*
+TODO:
+[.] test if there are no memory leaks or security exploits - done a lot but needs to be checked often
+[.] check compatibility with vareous compilers  - done but needs to be redone for every newer version
+[X] converting color to 16-bit per channel types
+[ ] read all public PNG chunk types (but never let the color profile and gamma ones touch RGB values)
+[ ] make sure encoder generates no chunks with size > (2^31)-1
+[ ] partial decoding (stream processing)
+[X] let the "isFullyOpaque" function check color keys and transparent palettes too
+[X] better name for the variables "codes", "codesD", "codelengthcodes", "clcl" and "lldl"
+[ ] don't stop decoding on errors like 69, 57, 58 (make warnings)
+[ ] make option to choose if the raw image with non multiple of 8 bits per scanline should have padding bits or not
+[ ] let the C++ wrapper catch exceptions coming from the standard library and return LodePNG error codes
+*/
+
+#endif /*LODEPNG_H inclusion guard*/
+
+/*
+LodePNG Documentation
+---------------------
+
+0. table of contents
+--------------------
+
+  1. about
+   1.1. supported features
+   1.2. features not supported
+  2. C and C++ version
+  3. security
+  4. decoding
+  5. encoding
+  6. color conversions
+    6.1. PNG color types
+    6.2. color conversions
+    6.3. padding bits
+    6.4. A note about 16-bits per channel and endianness
+  7. error values
+  8. chunks and PNG editing
+  9. compiler support
+  10. examples
+   10.1. decoder C++ example
+   10.2. decoder C example
+  11. changes
+  12. contact information
+
+
+1. about
+--------
+
+PNG is a file format to store raster images losslessly with good compression,
+supporting different color types and alpha channel.
+
+LodePNG is a PNG codec according to the Portable Network Graphics (PNG)
+Specification (Second Edition) - W3C Recommendation 10 November 2003.
+
+The specifications used are:
+
+*) Portable Network Graphics (PNG) Specification (Second Edition):
+     http://www.w3.org/TR/2003/REC-PNG-20031110
+*) RFC 1950 ZLIB Compressed Data Format version 3.3:
+     http://www.gzip.org/zlib/rfc-zlib.html
+*) RFC 1951 DEFLATE Compressed Data Format Specification ver 1.3:
+     http://www.gzip.org/zlib/rfc-deflate.html
+
+The most recent version of LodePNG can currently be found at
+http://lodev.org/lodepng/
+
+LodePNG works both in C (ISO C90) and C++, with a C++ wrapper that adds
+extra functionality.
+
+LodePNG exists out of two files:
+-lodepng.h: the header file for both C and C++
+-lodepng.c(pp): give it the name lodepng.c or lodepng.cpp (or .cc) depending on your usage
+
+If you want to start using LodePNG right away without reading this doc, get the
+examples from the LodePNG website to see how to use it in code, or check the
+smaller examples in chapter 13 here.
+
+LodePNG is simple but only supports the basic requirements. To achieve
+simplicity, the following design choices were made: There are no dependencies
+on any external library. There are functions to decode and encode a PNG with
+a single function call, and extended versions of these functions taking a
+LodePNGState struct allowing to specify or get more information. By default
+the colors of the raw image are always RGB or RGBA, no matter what color type
+the PNG file uses. To read and write files, there are simple functions to
+convert the files to/from buffers in memory.
+
+This all makes LodePNG suitable for loading textures in games, demos and small
+programs, ... It's less suitable for full fledged image editors, loading PNGs
+over network (it requires all the image data to be available before decoding can
+begin), life-critical systems, ...
+
+1.1. supported features
+-----------------------
+
+The following features are supported by the decoder:
+
+*) decoding of PNGs with any color type, bit depth and interlace mode, to a 24- or 32-bit color raw image,
+   or the same color type as the PNG
+*) encoding of PNGs, from any raw image to 24- or 32-bit color, or the same color type as the raw image
+*) Adam7 interlace and deinterlace for any color type
+*) loading the image from harddisk or decoding it from a buffer from other sources than harddisk
+*) support for alpha channels, including RGBA color model, translucent palettes and color keying
+*) zlib decompression (inflate)
+*) zlib compression (deflate)
+*) CRC32 and ADLER32 checksums
+*) handling of unknown chunks, allowing making a PNG editor that stores custom and unknown chunks.
+*) the following chunks are supported (generated/interpreted) by both encoder and decoder:
+    IHDR: header information
+    PLTE: color palette
+    IDAT: pixel data
+    IEND: the final chunk
+    tRNS: transparency for palettized images
+    tEXt: textual information
+    zTXt: compressed textual information
+    iTXt: international textual information
+    bKGD: suggested background color
+    pHYs: physical dimensions
+    tIME: modification time
+
+1.2. features not supported
+---------------------------
+
+The following features are _not_ supported:
+
+*) some features needed to make a conformant PNG-Editor might be still missing.
+*) partial loading/stream processing. All data must be available and is processed in one call.
+*) The following public chunks are not supported but treated as unknown chunks by LodePNG
+    cHRM, gAMA, iCCP, sRGB, sBIT, hIST, sPLT
+   Some of these are not supported on purpose: LodePNG wants to provide the RGB values
+   stored in the pixels, not values modified by system dependent gamma or color models.
+
+
+2. C and C++ version
+--------------------
+
+The C version uses buffers allocated with alloc that you need to free()
+yourself. You need to use init and cleanup functions for each struct whenever
+using a struct from the C version to avoid exploits and memory leaks.
+
+The C++ version has extra functions with std::vectors in the interface and the
+lodepng::State class which is a LodePNGState with constructor and destructor.
+
+These files work without modification for both C and C++ compilers because all
+the additional C++ code is in "#ifdef __cplusplus" blocks that make C-compilers
+ignore it, and the C code is made to compile both with strict ISO C90 and C++.
+
+To use the C++ version, you need to rename the source file to lodepng.cpp
+(instead of lodepng.c), and compile it with a C++ compiler.
+
+To use the C version, you need to rename the source file to lodepng.c (instead
+of lodepng.cpp), and compile it with a C compiler.
+
+
+3. Security
+-----------
+
+Even if carefully designed, it's always possible that LodePNG contains possible
+exploits. If you discover one, please let me know, and it will be fixed.
+
+When using LodePNG, care has to be taken with the C version of LodePNG, as well
+as the C-style structs when working with C++. The following conventions are used
+for all C-style structs:
+
+-if a struct has a corresponding init function, always call the init function when making a new one
+-if a struct has a corresponding cleanup function, call it before the struct disappears to avoid memory leaks
+-if a struct has a corresponding copy function, use the copy function instead of "=".
+ The destination must also be inited already.
+
+
+4. Decoding
+-----------
+
+Decoding converts a PNG compressed image to a raw pixel buffer.
+
+Most documentation on using the decoder is at its declarations in the header
+above. For C, simple decoding can be done with functions such as
+lodepng_decode32, and more advanced decoding can be done with the struct
+LodePNGState and lodepng_decode. For C++, all decoding can be done with the
+various lodepng::decode functions, and lodepng::State can be used for advanced
+features.
+
+When using the LodePNGState, it uses the following fields for decoding:
+*) LodePNGInfo info_png: it stores extra information about the PNG (the input) in here
+*) LodePNGColorMode info_raw: here you can say what color mode of the raw image (the output) you want to get
+*) LodePNGDecoderSettings decoder: you can specify a few extra settings for the decoder to use
+
+LodePNGInfo info_png
+--------------------
+
+After decoding, this contains extra information of the PNG image, except the actual
+pixels, width and height because these are already gotten directly from the decoder
+functions.
+
+It contains for example the original color type of the PNG image, text comments,
+suggested background color, etc... More details about the LodePNGInfo struct are
+at its declaration documentation.
+
+LodePNGColorMode info_raw
+-------------------------
+
+When decoding, here you can specify which color type you want
+the resulting raw image to be. If this is different from the colortype of the
+PNG, then the decoder will automatically convert the result. This conversion
+always works, except if you want it to convert a color PNG to greyscale or to
+a palette with missing colors.
+
+By default, 32-bit color is used for the result.
+
+LodePNGDecoderSettings decoder
+------------------------------
+
+The settings can be used to ignore the errors created by invalid CRC and Adler32
+chunks, and to disable the decoding of tEXt chunks.
+
+There's also a setting color_convert, true by default. If false, no conversion
+is done, the resulting data will be as it was in the PNG (after decompression)
+and you'll have to puzzle the colors of the pixels together yourself using the
+color type information in the LodePNGInfo.
+
+
+5. Encoding
+-----------
+
+Encoding converts a raw pixel buffer to a PNG compressed image.
+
+Most documentation on using the encoder is at its declarations in the header
+above. For C, simple encoding can be done with functions such as
+lodepng_encode32, and more advanced decoding can be done with the struct
+LodePNGState and lodepng_encode. For C++, all encoding can be done with the
+various lodepng::encode functions, and lodepng::State can be used for advanced
+features.
+
+Like the decoder, the encoder can also give errors. However it gives less errors
+since the encoder input is trusted, the decoder input (a PNG image that could
+be forged by anyone) is not trusted.
+
+When using the LodePNGState, it uses the following fields for encoding:
+*) LodePNGInfo info_png: here you specify how you want the PNG (the output) to be.
+*) LodePNGColorMode info_raw: here you say what color type of the raw image (the input) has
+*) LodePNGEncoderSettings encoder: you can specify a few settings for the encoder to use
+
+LodePNGInfo info_png
+--------------------
+
+When encoding, you use this the opposite way as when decoding: for encoding,
+you fill in the values you want the PNG to have before encoding. By default it's
+not needed to specify a color type for the PNG since it's automatically chosen,
+but it's possible to choose it yourself given the right settings.
+
+The encoder will not always exactly match the LodePNGInfo struct you give,
+it tries as close as possible. Some things are ignored by the encoder. The
+encoder uses, for example, the following settings from it when applicable:
+colortype and bitdepth, text chunks, time chunk, the color key, the palette, the
+background color, the interlace method, unknown chunks, ...
+
+When encoding to a PNG with colortype 3, the encoder will generate a PLTE chunk.
+If the palette contains any colors for which the alpha channel is not 255 (so
+there are translucent colors in the palette), it'll add a tRNS chunk.
+
+LodePNGColorMode info_raw
+-------------------------
+
+You specify the color type of the raw image that you give to the input here,
+including a possible transparent color key and palette you happen to be using in
+your raw image data.
+
+By default, 32-bit color is assumed, meaning your input has to be in RGBA
+format with 4 bytes (unsigned chars) per pixel.
+
+LodePNGEncoderSettings encoder
+------------------------------
+
+The following settings are supported (some are in sub-structs):
+*) auto_convert: when this option is enabled, the encoder will
+automatically choose the smallest possible color mode (including color key) that
+can encode the colors of all pixels without information loss.
+*) btype: the block type for LZ77. 0 = uncompressed, 1 = fixed huffman tree,
+   2 = dynamic huffman tree (best compression). Should be 2 for proper
+   compression.
+*) use_lz77: whether or not to use LZ77 for compressed block types. Should be
+   true for proper compression.
+*) windowsize: the window size used by the LZ77 encoder (1 - 32768). Has value
+   2048 by default, but can be set to 32768 for better, but slow, compression.
+*) force_palette: if colortype is 2 or 6, you can make the encoder write a PLTE
+   chunk if force_palette is true. This can used as suggested palette to convert
+   to by viewers that don't support more than 256 colors (if those still exist)
+*) add_id: add text chunk "Encoder: LodePNG <version>" to the image.
+*) text_compression: default 1. If 1, it'll store texts as zTXt instead of tEXt chunks.
+  zTXt chunks use zlib compression on the text. This gives a smaller result on
+  large texts but a larger result on small texts (such as a single program name).
+  It's all tEXt or all zTXt though, there's no separate setting per text yet.
+
+
+6. color conversions
+--------------------
+
+An important thing to note about LodePNG, is that the color type of the PNG, and
+the color type of the raw image, are completely independent. By default, when
+you decode a PNG, you get the result as a raw image in the color type you want,
+no matter whether the PNG was encoded with a palette, greyscale or RGBA color.
+And if you encode an image, by default LodePNG will automatically choose the PNG
+color type that gives good compression based on the values of colors and amount
+of colors in the image. It can be configured to let you control it instead as
+well, though.
+
+To be able to do this, LodePNG does conversions from one color mode to another.
+It can convert from almost any color type to any other color type, except the
+following conversions: RGB to greyscale is not supported, and converting to a
+palette when the palette doesn't have a required color is not supported. This is
+not supported on purpose: this is information loss which requires a color
+reduction algorithm that is beyong the scope of a PNG encoder (yes, RGB to grey
+is easy, but there are multiple ways if you want to give some channels more
+weight).
+
+By default, when decoding, you get the raw image in 32-bit RGBA or 24-bit RGB
+color, no matter what color type the PNG has. And by default when encoding,
+LodePNG automatically picks the best color model for the output PNG, and expects
+the input image to be 32-bit RGBA or 24-bit RGB. So, unless you want to control
+the color format of the images yourself, you can skip this chapter.
+
+6.1. PNG color types
+--------------------
+
+A PNG image can have many color types, ranging from 1-bit color to 64-bit color,
+as well as palettized color modes. After the zlib decompression and unfiltering
+in the PNG image is done, the raw pixel data will have that color type and thus
+a certain amount of bits per pixel. If you want the output raw image after
+decoding to have another color type, a conversion is done by LodePNG.
+
+The PNG specification gives the following color types:
+
+0: greyscale, bit depths 1, 2, 4, 8, 16
+2: RGB, bit depths 8 and 16
+3: palette, bit depths 1, 2, 4 and 8
+4: greyscale with alpha, bit depths 8 and 16
+6: RGBA, bit depths 8 and 16
+
+Bit depth is the amount of bits per pixel per color channel. So the total amount
+of bits per pixel is: amount of channels * bitdepth.
+
+6.2. color conversions
+----------------------
+
+As explained in the sections about the encoder and decoder, you can specify
+color types and bit depths in info_png and info_raw to change the default
+behaviour.
+
+If, when decoding, you want the raw image to be something else than the default,
+you need to set the color type and bit depth you want in the LodePNGColorMode,
+or the parameters colortype and bitdepth of the simple decoding function.
+
+If, when encoding, you use another color type than the default in the raw input
+image, you need to specify its color type and bit depth in the LodePNGColorMode
+of the raw image, or use the parameters colortype and bitdepth of the simple
+encoding function.
+
+If, when encoding, you don't want LodePNG to choose the output PNG color type
+but control it yourself, you need to set auto_convert in the encoder settings
+to false, and specify the color type you want in the LodePNGInfo of the
+encoder (including palette: it can generate a palette if auto_convert is true,
+otherwise not).
+
+If the input and output color type differ (whether user chosen or auto chosen),
+LodePNG will do a color conversion, which follows the rules below, and may
+sometimes result in an error.
+
+To avoid some confusion:
+-the decoder converts from PNG to raw image
+-the encoder converts from raw image to PNG
+-the colortype and bitdepth in LodePNGColorMode info_raw, are those of the raw image
+-the colortype and bitdepth in the color field of LodePNGInfo info_png, are those of the PNG
+-when encoding, the color type in LodePNGInfo is ignored if auto_convert
+ is enabled, it is automatically generated instead
+-when decoding, the color type in LodePNGInfo is set by the decoder to that of the original
+ PNG image, but it can be ignored since the raw image has the color type you requested instead
+-if the color type of the LodePNGColorMode and PNG image aren't the same, a conversion
+ between the color types is done if the color types are supported. If it is not
+ supported, an error is returned. If the types are the same, no conversion is done.
+-even though some conversions aren't supported, LodePNG supports loading PNGs from any
+ colortype and saving PNGs to any colortype, sometimes it just requires preparing
+ the raw image correctly before encoding.
+-both encoder and decoder use the same color converter.
+
+Non supported color conversions:
+-color to greyscale: no error is thrown, but the result will look ugly because
+only the red channel is taken
+-anything to palette when that palette does not have that color in it: in this
+case an error is thrown
+
+Supported color conversions:
+-anything to 8-bit RGB, 8-bit RGBA, 16-bit RGB, 16-bit RGBA
+-any grey or grey+alpha, to grey or grey+alpha
+-anything to a palette, as long as the palette has the requested colors in it
+-removing alpha channel
+-higher to smaller bitdepth, and vice versa
+
+If you want no color conversion to be done (e.g. for speed or control):
+-In the encoder, you can make it save a PNG with any color type by giving the
+raw color mode and LodePNGInfo the same color mode, and setting auto_convert to
+false.
+-In the decoder, you can make it store the pixel data in the same color type
+as the PNG has, by setting the color_convert setting to false. Settings in
+info_raw are then ignored.
+
+The function lodepng_convert does the color conversion. It is available in the
+interface but normally isn't needed since the encoder and decoder already call
+it.
+
+6.3. padding bits
+-----------------
+
+In the PNG file format, if a less than 8-bit per pixel color type is used and the scanlines
+have a bit amount that isn't a multiple of 8, then padding bits are used so that each
+scanline starts at a fresh byte. But that is NOT true for the LodePNG raw input and output.
+The raw input image you give to the encoder, and the raw output image you get from the decoder
+will NOT have these padding bits, e.g. in the case of a 1-bit image with a width
+of 7 pixels, the first pixel of the second scanline will the the 8th bit of the first byte,
+not the first bit of a new byte.
+
+6.4. A note about 16-bits per channel and endianness
+----------------------------------------------------
+
+LodePNG uses unsigned char arrays for 16-bit per channel colors too, just like
+for any other color format. The 16-bit values are stored in big endian (most
+significant byte first) in these arrays. This is the opposite order of the
+little endian used by x86 CPU's.
+
+LodePNG always uses big endian because the PNG file format does so internally.
+Conversions to other formats than PNG uses internally are not supported by
+LodePNG on purpose, there are myriads of formats, including endianness of 16-bit
+colors, the order in which you store R, G, B and A, and so on. Supporting and
+converting to/from all that is outside the scope of LodePNG.
+
+This may mean that, depending on your use case, you may want to convert the big
+endian output of LodePNG to little endian with a for loop. This is certainly not
+always needed, many applications and libraries support big endian 16-bit colors
+anyway, but it means you cannot simply cast the unsigned char* buffer to an
+unsigned short* buffer on x86 CPUs.
+
+
+7. error values
+---------------
+
+All functions in LodePNG that return an error code, return 0 if everything went
+OK, or a non-zero code if there was an error.
+
+The meaning of the LodePNG error values can be retrieved with the function
+lodepng_error_text: given the numerical error code, it returns a description
+of the error in English as a string.
+
+Check the implementation of lodepng_error_text to see the meaning of each code.
+
+
+8. chunks and PNG editing
+-------------------------
+
+If you want to add extra chunks to a PNG you encode, or use LodePNG for a PNG
+editor that should follow the rules about handling of unknown chunks, or if your
+program is able to read other types of chunks than the ones handled by LodePNG,
+then that's possible with the chunk functions of LodePNG.
+
+A PNG chunk has the following layout:
+
+4 bytes length
+4 bytes type name
+length bytes data
+4 bytes CRC
+
+8.1. iterating through chunks
+-----------------------------
+
+If you have a buffer containing the PNG image data, then the first chunk (the
+IHDR chunk) starts at byte number 8 of that buffer. The first 8 bytes are the
+signature of the PNG and are not part of a chunk. But if you start at byte 8
+then you have a chunk, and can check the following things of it.
+
+NOTE: none of these functions check for memory buffer boundaries. To avoid
+exploits, always make sure the buffer contains all the data of the chunks.
+When using lodepng_chunk_next, make sure the returned value is within the
+allocated memory.
+
+unsigned lodepng_chunk_length(const unsigned char* chunk):
+
+Get the length of the chunk's data. The total chunk length is this length + 12.
+
+void lodepng_chunk_type(char type[5], const unsigned char* chunk):
+unsigned char lodepng_chunk_type_equals(const unsigned char* chunk, const char* type):
+
+Get the type of the chunk or compare if it's a certain type
+
+unsigned char lodepng_chunk_critical(const unsigned char* chunk):
+unsigned char lodepng_chunk_private(const unsigned char* chunk):
+unsigned char lodepng_chunk_safetocopy(const unsigned char* chunk):
+
+Check if the chunk is critical in the PNG standard (only IHDR, PLTE, IDAT and IEND are).
+Check if the chunk is private (public chunks are part of the standard, private ones not).
+Check if the chunk is safe to copy. If it's not, then, when modifying data in a critical
+chunk, unsafe to copy chunks of the old image may NOT be saved in the new one if your
+program doesn't handle that type of unknown chunk.
+
+unsigned char* lodepng_chunk_data(unsigned char* chunk):
+const unsigned char* lodepng_chunk_data_const(const unsigned char* chunk):
+
+Get a pointer to the start of the data of the chunk.
+
+unsigned lodepng_chunk_check_crc(const unsigned char* chunk):
+void lodepng_chunk_generate_crc(unsigned char* chunk):
+
+Check if the crc is correct or generate a correct one.
+
+unsigned char* lodepng_chunk_next(unsigned char* chunk):
+const unsigned char* lodepng_chunk_next_const(const unsigned char* chunk):
+
+Iterate to the next chunk. This works if you have a buffer with consecutive chunks. Note that these
+functions do no boundary checking of the allocated data whatsoever, so make sure there is enough
+data available in the buffer to be able to go to the next chunk.
+
+unsigned lodepng_chunk_append(unsigned char** out, size_t* outlength, const unsigned char* chunk):
+unsigned lodepng_chunk_create(unsigned char** out, size_t* outlength, unsigned length,
+                              const char* type, const unsigned char* data):
+
+These functions are used to create new chunks that are appended to the data in *out that has
+length *outlength. The append function appends an existing chunk to the new data. The create
+function creates a new chunk with the given parameters and appends it. Type is the 4-letter
+name of the chunk.
+
+8.2. chunks in info_png
+-----------------------
+
+The LodePNGInfo struct contains fields with the unknown chunk in it. It has 3
+buffers (each with size) to contain 3 types of unknown chunks:
+the ones that come before the PLTE chunk, the ones that come between the PLTE
+and the IDAT chunks, and the ones that come after the IDAT chunks.
+It's necessary to make the distionction between these 3 cases because the PNG
+standard forces to keep the ordering of unknown chunks compared to the critical
+chunks, but does not force any other ordering rules.
+
+info_png.unknown_chunks_data[0] is the chunks before PLTE
+info_png.unknown_chunks_data[1] is the chunks after PLTE, before IDAT
+info_png.unknown_chunks_data[2] is the chunks after IDAT
+
+The chunks in these 3 buffers can be iterated through and read by using the same
+way described in the previous subchapter.
+
+When using the decoder to decode a PNG, you can make it store all unknown chunks
+if you set the option settings.remember_unknown_chunks to 1. By default, this
+option is off (0).
+
+The encoder will always encode unknown chunks that are stored in the info_png.
+If you need it to add a particular chunk that isn't known by LodePNG, you can
+use lodepng_chunk_append or lodepng_chunk_create to the chunk data in
+info_png.unknown_chunks_data[x].
+
+Chunks that are known by LodePNG should not be added in that way. E.g. to make
+LodePNG add a bKGD chunk, set background_defined to true and add the correct
+parameters there instead.
+
+
+9. compiler support
+-------------------
+
+No libraries other than the current standard C library are needed to compile
+LodePNG. For the C++ version, only the standard C++ library is needed on top.
+Add the files lodepng.c(pp) and lodepng.h to your project, include
+lodepng.h where needed, and your program can read/write PNG files.
+
+It is compatible with C90 and up, and C++03 and up.
+
+If performance is important, use optimization when compiling! For both the
+encoder and decoder, this makes a large difference.
+
+Make sure that LodePNG is compiled with the same compiler of the same version
+and with the same settings as the rest of the program, or the interfaces with
+std::vectors and std::strings in C++ can be incompatible.
+
+CHAR_BITS must be 8 or higher, because LodePNG uses unsigned chars for octets.
+
+*) gcc and g++
+
+LodePNG is developed in gcc so this compiler is natively supported. It gives no
+warnings with compiler options "-Wall -Wextra -pedantic -ansi", with gcc and g++
+version 4.7.1 on Linux, 32-bit and 64-bit.
+
+*) Clang
+
+Fully supported and warning-free.
+
+*) Mingw
+
+The Mingw compiler (a port of gcc for Windows) should be fully supported by
+LodePNG.
+
+*) Visual Studio and Visual C++ Express Edition
+
+LodePNG should be warning-free with warning level W4. Two warnings were disabled
+with pragmas though: warning 4244 about implicit conversions, and warning 4996
+where it wants to use a non-standard function fopen_s instead of the standard C
+fopen.
+
+Visual Studio may want "stdafx.h" files to be included in each source file and
+give an error "unexpected end of file while looking for precompiled header".
+This is not standard C++ and will not be added to the stock LodePNG. You can
+disable it for lodepng.cpp only by right clicking it, Properties, C/C++,
+Precompiled Headers, and set it to Not Using Precompiled Headers there.
+
+NOTE: Modern versions of VS should be fully supported, but old versions, e.g.
+VS6, are not guaranteed to work.
+
+*) Compilers on Macintosh
+
+LodePNG has been reported to work both with gcc and LLVM for Macintosh, both for
+C and C++.
+
+*) Other Compilers
+
+If you encounter problems on any compilers, feel free to let me know and I may
+try to fix it if the compiler is modern and standards complient.
+
+
+10. examples
+------------
+
+This decoder example shows the most basic usage of LodePNG. More complex
+examples can be found on the LodePNG website.
+
+10.1. decoder C++ example
+-------------------------
+
+#include "lodepng.h"
+#include <iostream>
+
+int main(int argc, char *argv[])
+{
+  const char* filename = argc > 1 ? argv[1] : "test.png";
+
+  //load and decode
+  std::vector<unsigned char> image;
+  unsigned width, height;
+  unsigned error = lodepng::decode(image, width, height, filename);
+
+  //if there's an error, display it
+  if(error) std::cout << "decoder error " << error << ": " << lodepng_error_text(error) << std::endl;
+
+  //the pixels are now in the vector "image", 4 bytes per pixel, ordered RGBARGBA..., use it as texture, draw it, ...
+}
+
+10.2. decoder C example
+-----------------------
+
+#include "lodepng.h"
+
+int main(int argc, char *argv[])
+{
+  unsigned error;
+  unsigned char* image;
+  size_t width, height;
+  const char* filename = argc > 1 ? argv[1] : "test.png";
+
+  error = lodepng_decode32_file(&image, &width, &height, filename);
+
+  if(error) printf("decoder error %u: %s\n", error, lodepng_error_text(error));
+
+  / * use image here * /
+
+  free(image);
+  return 0;
+}
+
+
+11. changes
+-----------
+
+The version number of LodePNG is the date of the change given in the format
+yyyymmdd.
+
+Some changes aren't backwards compatible. Those are indicated with a (!)
+symbol.
+
+*) 23 aug 2014: Reduced needless memory usage of decoder.
+*) 28 jun 2014: Removed fix_png setting, always support palette OOB for
+    simplicity. Made ColorProfile public.
+*) 09 jun 2014: Faster encoder by fixing hash bug and more zeros optimization.
+*) 22 dec 2013: Power of two windowsize required for optimization.
+*) 15 apr 2013: Fixed bug with LAC_ALPHA and color key.
+*) 25 mar 2013: Added an optional feature to ignore some PNG errors (fix_png).
+*) 11 mar 2013 (!): Bugfix with custom free. Changed from "my" to "lodepng_"
+    prefix for the custom allocators and made it possible with a new #define to
+    use custom ones in your project without needing to change lodepng's code.
+*) 28 jan 2013: Bugfix with color key.
+*) 27 okt 2012: Tweaks in text chunk keyword length error handling.
+*) 8 okt 2012 (!): Added new filter strategy (entropy) and new auto color mode.
+    (no palette). Better deflate tree encoding. New compression tweak settings.
+    Faster color conversions while decoding. Some internal cleanups.
+*) 23 sep 2012: Reduced warnings in Visual Studio a little bit.
+*) 1 sep 2012 (!): Removed #define's for giving custom (de)compression functions
+    and made it work with function pointers instead.
+*) 23 jun 2012: Added more filter strategies. Made it easier to use custom alloc
+    and free functions and toggle #defines from compiler flags. Small fixes.
+*) 6 may 2012 (!): Made plugging in custom zlib/deflate functions more flexible.
+*) 22 apr 2012 (!): Made interface more consistent, renaming a lot. Removed
+    redundant C++ codec classes. Reduced amount of structs. Everything changed,
+    but it is cleaner now imho and functionality remains the same. Also fixed
+    several bugs and shrinked the implementation code. Made new samples.
+*) 6 nov 2011 (!): By default, the encoder now automatically chooses the best
+    PNG color model and bit depth, based on the amount and type of colors of the
+    raw image. For this, autoLeaveOutAlphaChannel replaced by auto_choose_color.
+*) 9 okt 2011: simpler hash chain implementation for the encoder.
+*) 8 sep 2011: lz77 encoder lazy matching instead of greedy matching.
+*) 23 aug 2011: tweaked the zlib compression parameters after benchmarking.
+    A bug with the PNG filtertype heuristic was fixed, so that it chooses much
+    better ones (it's quite significant). A setting to do an experimental, slow,
+    brute force search for PNG filter types is added.
+*) 17 aug 2011 (!): changed some C zlib related function names.
+*) 16 aug 2011: made the code less wide (max 120 characters per line).
+*) 17 apr 2011: code cleanup. Bugfixes. Convert low to 16-bit per sample colors.
+*) 21 feb 2011: fixed compiling for C90. Fixed compiling with sections disabled.
+*) 11 dec 2010: encoding is made faster, based on suggestion by Peter Eastman
+    to optimize long sequences of zeros.
+*) 13 nov 2010: added LodePNG_InfoColor_hasPaletteAlpha and
+    LodePNG_InfoColor_canHaveAlpha functions for convenience.
+*) 7 nov 2010: added LodePNG_error_text function to get error code description.
+*) 30 okt 2010: made decoding slightly faster
+*) 26 okt 2010: (!) changed some C function and struct names (more consistent).
+     Reorganized the documentation and the declaration order in the header.
+*) 08 aug 2010: only changed some comments and external samples.
+*) 05 jul 2010: fixed bug thanks to warnings in the new gcc version.
+*) 14 mar 2010: fixed bug where too much memory was allocated for char buffers.
+*) 02 sep 2008: fixed bug where it could create empty tree that linux apps could
+    read by ignoring the problem but windows apps couldn't.
+*) 06 jun 2008: added more error checks for out of memory cases.
+*) 26 apr 2008: added a few more checks here and there to ensure more safety.
+*) 06 mar 2008: crash with encoding of strings fixed
+*) 02 feb 2008: support for international text chunks added (iTXt)
+*) 23 jan 2008: small cleanups, and #defines to divide code in sections
+*) 20 jan 2008: support for unknown chunks allowing using LodePNG for an editor.
+*) 18 jan 2008: support for tIME and pHYs chunks added to encoder and decoder.
+*) 17 jan 2008: ability to encode and decode compressed zTXt chunks added
+    Also vareous fixes, such as in the deflate and the padding bits code.
+*) 13 jan 2008: Added ability to encode Adam7-interlaced images. Improved
+    filtering code of encoder.
+*) 07 jan 2008: (!) changed LodePNG to use ISO C90 instead of C++. A
+    C++ wrapper around this provides an interface almost identical to before.
+    Having LodePNG be pure ISO C90 makes it more portable. The C and C++ code
+    are together in these files but it works both for C and C++ compilers.
+*) 29 dec 2007: (!) changed most integer types to unsigned int + other tweaks
+*) 30 aug 2007: bug fixed which makes this Borland C++ compatible
+*) 09 aug 2007: some VS2005 warnings removed again
+*) 21 jul 2007: deflate code placed in new namespace separate from zlib code
+*) 08 jun 2007: fixed bug with 2- and 4-bit color, and small interlaced images
+*) 04 jun 2007: improved support for Visual Studio 2005: crash with accessing
+    invalid std::vector element [0] fixed, and level 3 and 4 warnings removed
+*) 02 jun 2007: made the encoder add a tag with version by default
+*) 27 may 2007: zlib and png code separated (but still in the same file),
+    simple encoder/decoder functions added for more simple usage cases
+*) 19 may 2007: minor fixes, some code cleaning, new error added (error 69),
+    moved some examples from here to lodepng_examples.cpp
+*) 12 may 2007: palette decoding bug fixed
+*) 24 apr 2007: changed the license from BSD to the zlib license
+*) 11 mar 2007: very simple addition: ability to encode bKGD chunks.
+*) 04 mar 2007: (!) tEXt chunk related fixes, and support for encoding
+    palettized PNG images. Plus little interface change with palette and texts.
+*) 03 mar 2007: Made it encode dynamic Huffman shorter with repeat codes.
+    Fixed a bug where the end code of a block had length 0 in the Huffman tree.
+*) 26 feb 2007: Huffman compression with dynamic trees (BTYPE 2) now implemented
+    and supported by the encoder, resulting in smaller PNGs at the output.
+*) 27 jan 2007: Made the Adler-32 test faster so that a timewaste is gone.
+*) 24 jan 2007: gave encoder an error interface. Added color conversion from any
+    greyscale type to 8-bit greyscale with or without alpha.
+*) 21 jan 2007: (!) Totally changed the interface. It allows more color types
+    to convert to and is more uniform. See the manual for how it works now.
+*) 07 jan 2007: Some cleanup & fixes, and a few changes over the last days:
+    encode/decode custom tEXt chunks, separate classes for zlib & deflate, and
+    at last made the decoder give errors for incorrect Adler32 or Crc.
+*) 01 jan 2007: Fixed bug with encoding PNGs with less than 8 bits per channel.
+*) 29 dec 2006: Added support for encoding images without alpha channel, and
+    cleaned out code as well as making certain parts faster.
+*) 28 dec 2006: Added "Settings" to the encoder.
+*) 26 dec 2006: The encoder now does LZ77 encoding and produces much smaller files now.
+    Removed some code duplication in the decoder. Fixed little bug in an example.
+*) 09 dec 2006: (!) Placed output parameters of public functions as first parameter.
+    Fixed a bug of the decoder with 16-bit per color.
+*) 15 okt 2006: Changed documentation structure
+*) 09 okt 2006: Encoder class added. It encodes a valid PNG image from the
+    given image buffer, however for now it's not compressed.
+*) 08 sep 2006: (!) Changed to interface with a Decoder class
+*) 30 jul 2006: (!) LodePNG_InfoPng , width and height are now retrieved in different
+    way. Renamed decodePNG to decodePNGGeneric.
+*) 29 jul 2006: (!) Changed the interface: image info is now returned as a
+    struct of type LodePNG::LodePNG_Info, instead of a vector, which was a bit clumsy.
+*) 28 jul 2006: Cleaned the code and added new error checks.
+    Corrected terminology "deflate" into "inflate".
+*) 23 jun 2006: Added SDL example in the documentation in the header, this
+    example allows easy debugging by displaying the PNG and its transparency.
+*) 22 jun 2006: (!) Changed way to obtain error value. Added
+    loadFile function for convenience. Made decodePNG32 faster.
+*) 21 jun 2006: (!) Changed type of info vector to unsigned.
+    Changed position of palette in info vector. Fixed an important bug that
+    happened on PNGs with an uncompressed block.
+*) 16 jun 2006: Internally changed unsigned into unsigned where
+    needed, and performed some optimizations.
+*) 07 jun 2006: (!) Renamed functions to decodePNG and placed them
+    in LodePNG namespace. Changed the order of the parameters. Rewrote the
+    documentation in the header. Renamed files to lodepng.cpp and lodepng.h
+*) 22 apr 2006: Optimized and improved some code
+*) 07 sep 2005: (!) Changed to std::vector interface
+*) 12 aug 2005: Initial release (C++, decoder only)
+
+
+12. contact information
+-----------------------
+
+Feel free to contact me with suggestions, problems, comments, ... concerning
+LodePNG. If you encounter a PNG image that doesn't work properly with this
+decoder, feel free to send it and I'll use it to find and fix the problem.
+
+My email address is (puzzle the account and domain together with an @ symbol):
+Domain: gmail dot com.
+Account: lode dot vandevenne.
+
+
+Copyright (c) 2005-2014 Lode Vandevenne
+*/
diff --git a/engine/inc/bullet/ThirdPartyLibs/openvr/samples/shared/pathtools.h b/engine/inc/bullet/ThirdPartyLibs/openvr/samples/shared/pathtools.h
new file mode 100644
index 00000000..0b2bc0e0
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/openvr/samples/shared/pathtools.h
@@ -0,0 +1,128 @@
+//========= Copyright Valve Corporation ============//
+#pragma once
+
+#include <string>
+#include <stdint.h>
+
+/** Returns the path (including filename) to the current executable */
+std::string Path_GetExecutablePath();
+
+/** Returns the path of the current working directory */
+std::string Path_GetWorkingDirectory();
+
+/** Sets the path of the current working directory. Returns true if this was successful. */
+bool Path_SetWorkingDirectory(const std::string &sPath);
+
+/** returns the path (including filename) of the current shared lib or DLL */
+std::string Path_GetThisModulePath();
+
+/** Returns the specified path without its filename.
+* If slash is unspecified the native path separator of the current platform
+* will be used. */
+std::string Path_StripFilename(const std::string &sPath, char slash = 0);
+
+/** returns just the filename from the provided full or relative path. */
+std::string Path_StripDirectory(const std::string &sPath, char slash = 0);
+
+/** returns just the filename with no extension of the provided filename. 
+* If there is a path the path is left intact. */
+std::string Path_StripExtension(const std::string &sPath);
+
+/** returns just extension of the provided filename (if any). */
+std::string Path_GetExtension(const std::string &sPath);
+
+/** Returns true if the path is absolute */
+bool Path_IsAbsolute(const std::string &sPath);
+
+/** Makes an absolute path from a relative path and a base path */
+std::string Path_MakeAbsolute(const std::string &sRelativePath, const std::string &sBasePath, char slash = 0);
+
+/** Fixes the directory separators for the current platform.
+* If slash is unspecified the native path separator of the current platform
+* will be used. */
+std::string Path_FixSlashes(const std::string &sPath, char slash = 0);
+
+/** Returns the path separator for the current platform */
+char Path_GetSlash();
+
+/** Jams two paths together with the right kind of slash */
+std::string Path_Join(const std::string &first, const std::string &second, char slash = 0);
+std::string Path_Join(const std::string &first, const std::string &second, const std::string &third, char slash = 0);
+std::string Path_Join(const std::string &first, const std::string &second, const std::string &third, const std::string &fourth, char slash = 0);
+std::string Path_Join(
+	const std::string &first,
+	const std::string &second,
+	const std::string &third,
+	const std::string &fourth,
+	const std::string &fifth,
+	char slash = 0);
+
+/** Removes redundant <dir>/.. elements in the path. Returns an empty path if the 
+* specified path has a broken number of directories for its number of ..s.
+* If slash is unspecified the native path separator of the current platform
+* will be used. */
+std::string Path_Compact(const std::string &sRawPath, char slash = 0);
+
+//** Removed trailing slashes */
+std::string Path_RemoveTrailingSlash(const std::string &sRawPath, char slash = 0);
+
+/** returns true if the specified path exists and is a directory */
+bool Path_IsDirectory(const std::string &sPath);
+
+/** returns true if the specified path represents an app bundle */
+bool Path_IsAppBundle(const std::string &sPath);
+
+/** returns true if the the path exists */
+bool Path_Exists(const std::string &sPath);
+
+/** Helper functions to find parent directories or subdirectories of parent directories */
+std::string Path_FindParentDirectoryRecursively(const std::string &strStartDirectory, const std::string &strDirectoryName);
+std::string Path_FindParentSubDirectoryRecursively(const std::string &strStartDirectory, const std::string &strDirectoryName);
+
+/** Path operations to read or write text/binary files */
+unsigned char *Path_ReadBinaryFile(const std::string &strFilename, int *pSize);
+uint32_t Path_ReadBinaryFile(const std::string &strFilename, unsigned char *pBuffer, uint32_t unSize);
+bool Path_WriteBinaryFile(const std::string &strFilename, unsigned char *pData, unsigned nSize);
+std::string Path_ReadTextFile(const std::string &strFilename);
+bool Path_WriteStringToTextFile(const std::string &strFilename, const char *pchData);
+bool Path_WriteStringToTextFileAtomic(const std::string &strFilename, const char *pchData);
+
+/** Returns a file:// url for paths, or an http or https url if that's what was provided */
+std::string Path_FilePathToUrl(const std::string &sRelativePath, const std::string &sBasePath);
+
+/** Strips off file:// off a URL and returns the path. For other kinds of URLs an empty string is returned */
+std::string Path_UrlToFilePath(const std::string &sFileUrl);
+
+/** Returns the root of the directory the system wants us to store user documents in */
+std::string GetUserDocumentsPath();
+
+#ifndef MAX_UNICODE_PATH
+#define MAX_UNICODE_PATH 32767
+#endif
+
+#ifndef MAX_UNICODE_PATH_IN_UTF8
+#define MAX_UNICODE_PATH_IN_UTF8 (MAX_UNICODE_PATH * 4)
+#endif
+
+//-----------------------------------------------------------------------------
+#if defined(_WIN32)
+#define DYNAMIC_LIB_EXT ".dll"
+#ifdef _WIN64
+#define PLATSUBDIR "win64"
+#else
+#define PLATSUBDIR "win32"
+#endif
+#elif defined(OSX)
+#define DYNAMIC_LIB_EXT ".dylib"
+#define PLATSUBDIR "osx32"
+#elif defined(LINUX)
+#define DYNAMIC_LIB_EXT ".so"
+#if defined(LINUX32)
+#define PLATSUBDIR "linux32"
+#else
+#define PLATSUBDIR "linux64"
+#endif
+#else
+#warning "Unknown platform for PLATSUBDIR"
+#define PLATSUBDIR "unknown_platform"
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/openvr/samples/shared/strtools.h b/engine/inc/bullet/ThirdPartyLibs/openvr/samples/shared/strtools.h
new file mode 100644
index 00000000..c3b310cc
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/openvr/samples/shared/strtools.h
@@ -0,0 +1,138 @@
+//========= Copyright Valve Corporation ============//
+#pragma once
+
+#include <string>
+#include <stdint.h>
+#include <sys/types.h>
+
+/** returns true if the string has the prefix */
+bool StringHasPrefix(const std::string &sString, const std::string &sPrefix);
+bool StringHasPrefixCaseSensitive(const std::string &sString, const std::string &sPrefix);
+
+/** returns if the string has the suffix */
+bool StringHasSuffix(const std::string &sString, const std::string &sSuffix);
+bool StringHasSuffixCaseSensitive(const std::string &sString, const std::string &sSuffix);
+
+/** converts a UTF-16 string to a UTF-8 string */
+std::string UTF16to8(const wchar_t *in);
+
+/** converts a UTF-8 string to a UTF-16 string */
+std::wstring UTF8to16(const char *in);
+#define Utf16FromUtf8 UTF8to16
+
+/** safely copy a string into a buffer */
+void strcpy_safe(char *pchBuffer, size_t unBufferSizeBytes, const char *pchSource);
+template <size_t bufferSize>
+void strcpy_safe(char (&buffer)[bufferSize], const char *pchSource)
+{
+	strcpy_safe(buffer, bufferSize, pchSource);
+}
+
+/** converts a string to upper case */
+std::string StringToUpper(const std::string &sString);
+
+/** converts a string to lower case */
+std::string StringToLower(const std::string &sString);
+
+// we stricmp (from WIN) but it isn't POSIX - OSX/LINUX have strcasecmp so just inline bridge to it
+#if defined(OSX) || defined(LINUX)
+#ifndef __THROW  // If __THROW is defined, these will clash with throw() versions on gcc
+#include <strings.h>
+inline int stricmp(const char *pStr1, const char *pStr2)
+{
+	return strcasecmp(pStr1, pStr2);
+}
+#ifndef _stricmp
+#define _stricmp stricmp
+#endif
+inline int strnicmp(const char *pStr1, const char *pStr2, size_t unBufferLen)
+{
+	return strncasecmp(pStr1, pStr2, unBufferLen);
+}
+#define _strnicmp strnicmp
+#endif
+
+#ifndef _vsnprintf_s
+#define _vsnprintf_s vsnprintf
+#endif
+
+#define _TRUNCATE ((size_t)-1)
+
+#endif  // defined( OSX ) || defined( LINUX )
+
+#if defined(OSX)
+// behaviors ensure NULL-termination at least as well as _TRUNCATE does, but
+// wcsncpy_s/strncpy_s can non-NULL-terminate, wcslcpy/strlcpy can not.
+inline errno_t wcsncpy_s(wchar_t *strDest, size_t numberOfElements, const wchar_t *strSource, size_t count)
+{
+	return wcslcpy(strDest, strSource, numberOfElements);
+}
+
+inline errno_t strncpy_s(char *strDest, size_t numberOfElements, const char *strSource, size_t count)
+{
+	return strlcpy(strDest, strSource, numberOfElements);
+}
+
+#endif
+
+#if defined(LINUX)
+// this implementation does not return whether or not the destination was
+// truncated, but that is straightforward to fix if anybody actually needs the
+// return code.
+#include "string.h"
+inline void wcsncpy_s(wchar_t *strDest, size_t numberOfElements, const wchar_t *strSource, size_t count)
+{
+	wcsncpy(strDest, strSource, numberOfElements);
+	strDest[numberOfElements - 1] = '\0';
+}
+
+inline void strncpy_s(char *strDest, size_t numberOfElements, const char *strSource, size_t count)
+{
+	strncpy(strDest, strSource, numberOfElements);
+	strDest[numberOfElements - 1] = '\0';
+}
+
+#endif
+
+#if defined(_WIN32) && _MSC_VER < 1800
+inline uint64_t strtoull(const char *str, char **endptr, int base)
+{
+	return _strtoui64(str, endptr, base);
+}
+#endif
+
+/* Handles copying a std::string into a buffer as would be provided in an API */
+uint32_t ReturnStdString(const std::string &sValue, char *pchBuffer, uint32_t unBufferLen);
+
+/* Handles copying a buffer into an std::string and auto adds null terminator */
+void BufferToStdString(std::string &sDest, const char *pchBuffer, uint32_t unBufferLen);
+
+/** Returns a std::string from a uint64_t */
+std::string Uint64ToString(uint64_t ulValue);
+
+/** returns a uint64_t from a string */
+uint64_t StringToUint64(const std::string &sValue);
+
+//-----------------------------------------------------------------------------
+// Purpose: Encodes a string (or binary data) from URL encoding format, see rfc1738 section 2.2.
+//          This version of the call isn't a strict RFC implementation, but uses + for space as is
+//          the standard in HTML form encoding, despite it not being part of the RFC.
+//
+//          Dest buffer should be at least as large as source buffer to guarantee room for decode.
+//-----------------------------------------------------------------------------
+void V_URLEncode(char *pchDest, int nDestLen, const char *pchSource, int nSourceLen);
+
+//-----------------------------------------------------------------------------
+// Purpose: Decodes a string (or binary data) from URL encoding format, see rfc1738 section 2.2.
+//          This version of the call isn't a strict RFC implementation, but uses + for space as is
+//          the standard in HTML form encoding, despite it not being part of the RFC.
+//
+//          Dest buffer should be at least as large as source buffer to guarantee room for decode.
+//			Dest buffer being the same as the source buffer (decode in-place) is explicitly allowed.
+//-----------------------------------------------------------------------------
+size_t V_URLDecode(char *pchDecodeDest, int nDecodeDestLen, const char *pchEncodedSource, int nEncodedSourceLen);
+
+//-----------------------------------------------------------------------------
+// Purpose: strip extension from a path
+//-----------------------------------------------------------------------------
+void V_StripExtension(std::string &in);
diff --git a/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/X.h b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/X.h
new file mode 100644
index 00000000..51566657
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/X.h
@@ -0,0 +1,711 @@
+/* Definitions for the X window system likely to be used by applications */
+
+#ifndef X_H
+#define X_H
+
+/***********************************************************
+
+Copyright 1987, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its 
+documentation for any purpose and without fee is hereby granted, 
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in 
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.  
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+
+#define X_PROTOCOL 11         /* current protocol version */
+#define X_PROTOCOL_REVISION 0 /* current minor version */
+
+/* Resources */
+
+/*
+ * _XSERVER64 must ONLY be defined when compiling X server sources on
+ * systems where unsigned long is not 32 bits, must NOT be used in
+ * client or library code.
+ */
+#ifndef _XSERVER64
+#ifndef _XTYPEDEF_XID
+#define _XTYPEDEF_XID
+typedef unsigned long XID;
+#endif
+#ifndef _XTYPEDEF_MASK
+#define _XTYPEDEF_MASK
+typedef unsigned long Mask;
+#endif
+#ifndef _XTYPEDEF_ATOM
+#define _XTYPEDEF_ATOM
+typedef unsigned long Atom; /* Also in Xdefs.h */
+#endif
+typedef unsigned long VisualID;
+typedef unsigned long Time;
+#else
+#include <X11/Xmd.h>
+#ifndef _XTYPEDEF_XID
+#define _XTYPEDEF_XID
+typedef CARD32 XID;
+#endif
+#ifndef _XTYPEDEF_MASK
+#define _XTYPEDEF_MASK
+typedef CARD32 Mask;
+#endif
+#ifndef _XTYPEDEF_ATOM
+#define _XTYPEDEF_ATOM
+typedef CARD32 Atom;
+#endif
+typedef CARD32 VisualID;
+typedef CARD32 Time;
+#endif
+
+typedef XID Window;
+typedef XID Drawable;
+#ifndef _XTYPEDEF_FONT
+#define _XTYPEDEF_FONT
+typedef XID Font;
+#endif
+typedef XID Pixmap;
+typedef XID Cursor;
+typedef XID Colormap;
+typedef XID GContext;
+typedef XID KeySym;
+
+typedef unsigned char KeyCode;
+
+/*****************************************************************
+ * RESERVED RESOURCE AND CONSTANT DEFINITIONS
+ *****************************************************************/
+
+#ifndef None
+#define None 0L /* universal null resource or null atom */
+#endif
+
+#define ParentRelative 1L /* background pixmap in CreateWindow
+				    and ChangeWindowAttributes */
+
+#define CopyFromParent 0L /* border pixmap in CreateWindow
+				       and ChangeWindowAttributes
+				   special VisualID and special window
+				       class passed to CreateWindow */
+
+#define PointerWindow 0L /* destination window in SendEvent */
+#define InputFocus 1L    /* destination window in SendEvent */
+
+#define PointerRoot 1L /* focus window in SetInputFocus */
+
+#define AnyPropertyType 0L /* special Atom, passed to GetProperty */
+
+#define AnyKey 0L /* special Key Code, passed to GrabKey */
+
+#define AnyButton 0L /* special Button Code, passed to GrabButton */
+
+#define AllTemporary 0L /* special Resource ID passed to KillClient */
+
+#define CurrentTime 0L /* special Time */
+
+#define NoSymbol 0L /* special KeySym */
+
+/***************************************************************** 
+ * EVENT DEFINITIONS 
+ *****************************************************************/
+
+/* Input Event Masks. Used as event-mask window attribute and as arguments
+   to Grab requests.  Not to be confused with event names.  */
+
+#define NoEventMask 0L
+#define KeyPressMask (1L << 0)
+#define KeyReleaseMask (1L << 1)
+#define ButtonPressMask (1L << 2)
+#define ButtonReleaseMask (1L << 3)
+#define EnterWindowMask (1L << 4)
+#define LeaveWindowMask (1L << 5)
+#define PointerMotionMask (1L << 6)
+#define PointerMotionHintMask (1L << 7)
+#define Button1MotionMask (1L << 8)
+#define Button2MotionMask (1L << 9)
+#define Button3MotionMask (1L << 10)
+#define Button4MotionMask (1L << 11)
+#define Button5MotionMask (1L << 12)
+#define ButtonMotionMask (1L << 13)
+#define KeymapStateMask (1L << 14)
+#define ExposureMask (1L << 15)
+#define VisibilityChangeMask (1L << 16)
+#define StructureNotifyMask (1L << 17)
+#define ResizeRedirectMask (1L << 18)
+#define SubstructureNotifyMask (1L << 19)
+#define SubstructureRedirectMask (1L << 20)
+#define FocusChangeMask (1L << 21)
+#define PropertyChangeMask (1L << 22)
+#define ColormapChangeMask (1L << 23)
+#define OwnerGrabButtonMask (1L << 24)
+
+/* Event names.  Used in "type" field in XEvent structures.  Not to be
+confused with event masks above.  They start from 2 because 0 and 1
+are reserved in the protocol for errors and replies. */
+
+#define KeyPress 2
+#define KeyRelease 3
+#define ButtonPress 4
+#define ButtonRelease 5
+#define MotionNotify 6
+#define EnterNotify 7
+#define LeaveNotify 8
+#define FocusIn 9
+#define FocusOut 10
+#define KeymapNotify 11
+#define Expose 12
+#define GraphicsExpose 13
+#define NoExpose 14
+#define VisibilityNotify 15
+#define CreateNotify 16
+#define DestroyNotify 17
+#define UnmapNotify 18
+#define MapNotify 19
+#define MapRequest 20
+#define ReparentNotify 21
+#define ConfigureNotify 22
+#define ConfigureRequest 23
+#define GravityNotify 24
+#define ResizeRequest 25
+#define CirculateNotify 26
+#define CirculateRequest 27
+#define PropertyNotify 28
+#define SelectionClear 29
+#define SelectionRequest 30
+#define SelectionNotify 31
+#define ColormapNotify 32
+#define ClientMessage 33
+#define MappingNotify 34
+#define GenericEvent 35
+#define LASTEvent 36 /* must be bigger than any event # */
+
+/* Key masks. Used as modifiers to GrabButton and GrabKey, results of QueryPointer,
+   state in various key-, mouse-, and button-related events. */
+
+#define ShiftMask (1 << 0)
+#define LockMask (1 << 1)
+#define ControlMask (1 << 2)
+#define Mod1Mask (1 << 3)
+#define Mod2Mask (1 << 4)
+#define Mod3Mask (1 << 5)
+#define Mod4Mask (1 << 6)
+#define Mod5Mask (1 << 7)
+
+/* modifier names.  Used to build a SetModifierMapping request or
+   to read a GetModifierMapping request.  These correspond to the
+   masks defined above. */
+#define ShiftMapIndex 0
+#define LockMapIndex 1
+#define ControlMapIndex 2
+#define Mod1MapIndex 3
+#define Mod2MapIndex 4
+#define Mod3MapIndex 5
+#define Mod4MapIndex 6
+#define Mod5MapIndex 7
+
+/* button masks.  Used in same manner as Key masks above. Not to be confused
+   with button names below. */
+
+#define Button1Mask (1 << 8)
+#define Button2Mask (1 << 9)
+#define Button3Mask (1 << 10)
+#define Button4Mask (1 << 11)
+#define Button5Mask (1 << 12)
+
+#define AnyModifier (1 << 15) /* used in GrabButton, GrabKey */
+
+/* button names. Used as arguments to GrabButton and as detail in ButtonPress
+   and ButtonRelease events.  Not to be confused with button masks above.
+   Note that 0 is already defined above as "AnyButton".  */
+
+#define Button1 1
+#define Button2 2
+#define Button3 3
+#define Button4 4
+#define Button5 5
+
+/* Notify modes */
+
+#define NotifyNormal 0
+#define NotifyGrab 1
+#define NotifyUngrab 2
+#define NotifyWhileGrabbed 3
+
+#define NotifyHint 1 /* for MotionNotify events */
+
+/* Notify detail */
+
+#define NotifyAncestor 0
+#define NotifyVirtual 1
+#define NotifyInferior 2
+#define NotifyNonlinear 3
+#define NotifyNonlinearVirtual 4
+#define NotifyPointer 5
+#define NotifyPointerRoot 6
+#define NotifyDetailNone 7
+
+/* Visibility notify */
+
+#define VisibilityUnobscured 0
+#define VisibilityPartiallyObscured 1
+#define VisibilityFullyObscured 2
+
+/* Circulation request */
+
+#define PlaceOnTop 0
+#define PlaceOnBottom 1
+
+/* protocol families */
+
+#define FamilyInternet 0 /* IPv4 */
+#define FamilyDECnet 1
+#define FamilyChaos 2
+#define FamilyInternet6 6 /* IPv6 */
+
+/* authentication families not tied to a specific protocol */
+#define FamilyServerInterpreted 5
+
+/* Property notification */
+
+#define PropertyNewValue 0
+#define PropertyDelete 1
+
+/* Color Map notification */
+
+#define ColormapUninstalled 0
+#define ColormapInstalled 1
+
+/* GrabPointer, GrabButton, GrabKeyboard, GrabKey Modes */
+
+#define GrabModeSync 0
+#define GrabModeAsync 1
+
+/* GrabPointer, GrabKeyboard reply status */
+
+#define GrabSuccess 0
+#define AlreadyGrabbed 1
+#define GrabInvalidTime 2
+#define GrabNotViewable 3
+#define GrabFrozen 4
+
+/* AllowEvents modes */
+
+#define AsyncPointer 0
+#define SyncPointer 1
+#define ReplayPointer 2
+#define AsyncKeyboard 3
+#define SyncKeyboard 4
+#define ReplayKeyboard 5
+#define AsyncBoth 6
+#define SyncBoth 7
+
+/* Used in SetInputFocus, GetInputFocus */
+
+#define RevertToNone (int)None
+#define RevertToPointerRoot (int)PointerRoot
+#define RevertToParent 2
+
+/*****************************************************************
+ * ERROR CODES 
+ *****************************************************************/
+
+#define Success 0            /* everything's okay */
+#define BadRequest 1         /* bad request code */
+#define BadValue 2           /* int parameter out of range */
+#define BadWindow 3          /* parameter not a Window */
+#define BadPixmap 4          /* parameter not a Pixmap */
+#define BadAtom 5            /* parameter not an Atom */
+#define BadCursor 6          /* parameter not a Cursor */
+#define BadFont 7            /* parameter not a Font */
+#define BadMatch 8           /* parameter mismatch */
+#define BadDrawable 9        /* parameter not a Pixmap or Window */
+#define BadAccess 10         /* depending on context:
+				 - key/button already grabbed
+				 - attempt to free an illegal 
+				   cmap entry 
+				- attempt to store into a read-only 
+				   color map entry.
+ 				- attempt to modify the access control
+				   list from other than the local host.
+				*/
+#define BadAlloc 11          /* insufficient resources */
+#define BadColor 12          /* no such colormap */
+#define BadGC 13             /* parameter not a GC */
+#define BadIDChoice 14       /* choice not in range or already used */
+#define BadName 15           /* font or color name doesn't exist */
+#define BadLength 16         /* Request length incorrect */
+#define BadImplementation 17 /* server is defective */
+
+#define FirstExtensionError 128
+#define LastExtensionError 255
+
+/*****************************************************************
+ * WINDOW DEFINITIONS 
+ *****************************************************************/
+
+/* Window classes used by CreateWindow */
+/* Note that CopyFromParent is already defined as 0 above */
+
+#define InputOutput 1
+#define InputOnly 2
+
+/* Window attributes for CreateWindow and ChangeWindowAttributes */
+
+#define CWBackPixmap (1L << 0)
+#define CWBackPixel (1L << 1)
+#define CWBorderPixmap (1L << 2)
+#define CWBorderPixel (1L << 3)
+#define CWBitGravity (1L << 4)
+#define CWWinGravity (1L << 5)
+#define CWBackingStore (1L << 6)
+#define CWBackingPlanes (1L << 7)
+#define CWBackingPixel (1L << 8)
+#define CWOverrideRedirect (1L << 9)
+#define CWSaveUnder (1L << 10)
+#define CWEventMask (1L << 11)
+#define CWDontPropagate (1L << 12)
+#define CWColormap (1L << 13)
+#define CWCursor (1L << 14)
+
+/* ConfigureWindow structure */
+
+#define CWX (1 << 0)
+#define CWY (1 << 1)
+#define CWWidth (1 << 2)
+#define CWHeight (1 << 3)
+#define CWBorderWidth (1 << 4)
+#define CWSibling (1 << 5)
+#define CWStackMode (1 << 6)
+
+/* Bit Gravity */
+
+#define ForgetGravity 0
+#define NorthWestGravity 1
+#define NorthGravity 2
+#define NorthEastGravity 3
+#define WestGravity 4
+#define CenterGravity 5
+#define EastGravity 6
+#define SouthWestGravity 7
+#define SouthGravity 8
+#define SouthEastGravity 9
+#define StaticGravity 10
+
+/* Window gravity + bit gravity above */
+
+#define UnmapGravity 0
+
+/* Used in CreateWindow for backing-store hint */
+
+#define NotUseful 0
+#define WhenMapped 1
+#define Always 2
+
+/* Used in GetWindowAttributes reply */
+
+#define IsUnmapped 0
+#define IsUnviewable 1
+#define IsViewable 2
+
+/* Used in ChangeSaveSet */
+
+#define SetModeInsert 0
+#define SetModeDelete 1
+
+/* Used in ChangeCloseDownMode */
+
+#define DestroyAll 0
+#define RetainPermanent 1
+#define RetainTemporary 2
+
+/* Window stacking method (in configureWindow) */
+
+#define Above 0
+#define Below 1
+#define TopIf 2
+#define BottomIf 3
+#define Opposite 4
+
+/* Circulation direction */
+
+#define RaiseLowest 0
+#define LowerHighest 1
+
+/* Property modes */
+
+#define PropModeReplace 0
+#define PropModePrepend 1
+#define PropModeAppend 2
+
+/*****************************************************************
+ * GRAPHICS DEFINITIONS
+ *****************************************************************/
+
+/* graphics functions, as in GC.alu */
+
+#define GXclear 0x0        /* 0 */
+#define GXand 0x1          /* src AND dst */
+#define GXandReverse 0x2   /* src AND NOT dst */
+#define GXcopy 0x3         /* src */
+#define GXandInverted 0x4  /* NOT src AND dst */
+#define GXnoop 0x5         /* dst */
+#define GXxor 0x6          /* src XOR dst */
+#define GXor 0x7           /* src OR dst */
+#define GXnor 0x8          /* NOT src AND NOT dst */
+#define GXequiv 0x9        /* NOT src XOR dst */
+#define GXinvert 0xa       /* NOT dst */
+#define GXorReverse 0xb    /* src OR NOT dst */
+#define GXcopyInverted 0xc /* NOT src */
+#define GXorInverted 0xd   /* NOT src OR dst */
+#define GXnand 0xe         /* NOT src OR NOT dst */
+#define GXset 0xf          /* 1 */
+
+/* LineStyle */
+
+#define LineSolid 0
+#define LineOnOffDash 1
+#define LineDoubleDash 2
+
+/* capStyle */
+
+#define CapNotLast 0
+#define CapButt 1
+#define CapRound 2
+#define CapProjecting 3
+
+/* joinStyle */
+
+#define JoinMiter 0
+#define JoinRound 1
+#define JoinBevel 2
+
+/* fillStyle */
+
+#define FillSolid 0
+#define FillTiled 1
+#define FillStippled 2
+#define FillOpaqueStippled 3
+
+/* fillRule */
+
+#define EvenOddRule 0
+#define WindingRule 1
+
+/* subwindow mode */
+
+#define ClipByChildren 0
+#define IncludeInferiors 1
+
+/* SetClipRectangles ordering */
+
+#define Unsorted 0
+#define YSorted 1
+#define YXSorted 2
+#define YXBanded 3
+
+/* CoordinateMode for drawing routines */
+
+#define CoordModeOrigin 0   /* relative to the origin */
+#define CoordModePrevious 1 /* relative to previous point */
+
+/* Polygon shapes */
+
+#define Complex 0   /* paths may intersect */
+#define Nonconvex 1 /* no paths intersect, but not convex */
+#define Convex 2    /* wholly convex */
+
+/* Arc modes for PolyFillArc */
+
+#define ArcChord 0    /* join endpoints of arc */
+#define ArcPieSlice 1 /* join endpoints to center of arc */
+
+/* GC components: masks used in CreateGC, CopyGC, ChangeGC, OR'ed into
+   GC.stateChanges */
+
+#define GCFunction (1L << 0)
+#define GCPlaneMask (1L << 1)
+#define GCForeground (1L << 2)
+#define GCBackground (1L << 3)
+#define GCLineWidth (1L << 4)
+#define GCLineStyle (1L << 5)
+#define GCCapStyle (1L << 6)
+#define GCJoinStyle (1L << 7)
+#define GCFillStyle (1L << 8)
+#define GCFillRule (1L << 9)
+#define GCTile (1L << 10)
+#define GCStipple (1L << 11)
+#define GCTileStipXOrigin (1L << 12)
+#define GCTileStipYOrigin (1L << 13)
+#define GCFont (1L << 14)
+#define GCSubwindowMode (1L << 15)
+#define GCGraphicsExposures (1L << 16)
+#define GCClipXOrigin (1L << 17)
+#define GCClipYOrigin (1L << 18)
+#define GCClipMask (1L << 19)
+#define GCDashOffset (1L << 20)
+#define GCDashList (1L << 21)
+#define GCArcMode (1L << 22)
+
+#define GCLastBit 22
+/*****************************************************************
+ * FONTS 
+ *****************************************************************/
+
+/* used in QueryFont -- draw direction */
+
+#define FontLeftToRight 0
+#define FontRightToLeft 1
+
+#define FontChange 255
+
+/*****************************************************************
+ *  IMAGING 
+ *****************************************************************/
+
+/* ImageFormat -- PutImage, GetImage */
+
+#define XYBitmap 0 /* depth 1, XYFormat */
+#define XYPixmap 1 /* depth == drawable depth */
+#define ZPixmap 2  /* depth == drawable depth */
+
+/*****************************************************************
+ *  COLOR MAP STUFF 
+ *****************************************************************/
+
+/* For CreateColormap */
+
+#define AllocNone 0 /* create map with no entries */
+#define AllocAll 1  /* allocate entire map writeable */
+
+/* Flags used in StoreNamedColor, StoreColors */
+
+#define DoRed (1 << 0)
+#define DoGreen (1 << 1)
+#define DoBlue (1 << 2)
+
+/*****************************************************************
+ * CURSOR STUFF
+ *****************************************************************/
+
+/* QueryBestSize Class */
+
+#define CursorShape 0  /* largest size that can be displayed */
+#define TileShape 1    /* size tiled fastest */
+#define StippleShape 2 /* size stippled fastest */
+
+/***************************************************************** 
+ * KEYBOARD/POINTER STUFF
+ *****************************************************************/
+
+#define AutoRepeatModeOff 0
+#define AutoRepeatModeOn 1
+#define AutoRepeatModeDefault 2
+
+#define LedModeOff 0
+#define LedModeOn 1
+
+/* masks for ChangeKeyboardControl */
+
+#define KBKeyClickPercent (1L << 0)
+#define KBBellPercent (1L << 1)
+#define KBBellPitch (1L << 2)
+#define KBBellDuration (1L << 3)
+#define KBLed (1L << 4)
+#define KBLedMode (1L << 5)
+#define KBKey (1L << 6)
+#define KBAutoRepeatMode (1L << 7)
+
+#define MappingSuccess 0
+#define MappingBusy 1
+#define MappingFailed 2
+
+#define MappingModifier 0
+#define MappingKeyboard 1
+#define MappingPointer 2
+
+/*****************************************************************
+ * SCREEN SAVER STUFF 
+ *****************************************************************/
+
+#define DontPreferBlanking 0
+#define PreferBlanking 1
+#define DefaultBlanking 2
+
+#define DisableScreenSaver 0
+#define DisableScreenInterval 0
+
+#define DontAllowExposures 0
+#define AllowExposures 1
+#define DefaultExposures 2
+
+/* for ForceScreenSaver */
+
+#define ScreenSaverReset 0
+#define ScreenSaverActive 1
+
+/*****************************************************************
+ * HOSTS AND CONNECTIONS
+ *****************************************************************/
+
+/* for ChangeHosts */
+
+#define HostInsert 0
+#define HostDelete 1
+
+/* for ChangeAccessControl */
+
+#define EnableAccess 1
+#define DisableAccess 0
+
+/* Display classes  used in opening the connection 
+ * Note that the statically allocated ones are even numbered and the
+ * dynamically changeable ones are odd numbered */
+
+#define StaticGray 0
+#define GrayScale 1
+#define StaticColor 2
+#define PseudoColor 3
+#define TrueColor 4
+#define DirectColor 5
+
+/* Byte order  used in imageByteOrder and bitmapBitOrder */
+
+#define LSBFirst 0
+#define MSBFirst 1
+
+#endif /* X_H */
diff --git a/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/XKBlib.h b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/XKBlib.h
new file mode 100644
index 00000000..3607db0c
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/XKBlib.h
@@ -0,0 +1,1157 @@
+/************************************************************
+Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
+
+Permission to use, copy, modify, and distribute this
+software and its documentation for any purpose and without
+fee is hereby granted, provided that the above copyright
+notice appear in all copies and that both that copyright
+notice and this permission notice appear in supporting
+documentation, and that the name of Silicon Graphics not be
+used in advertising or publicity pertaining to distribution
+of the software without specific prior written permission.
+Silicon Graphics makes no representation about the suitability
+of this software for any purpose. It is provided "as is"
+without any express or implied warranty.
+
+SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
+SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
+GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
+DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
+THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+********************************************************/
+
+#ifndef _X11_XKBLIB_H_
+#define _X11_XKBLIB_H_
+
+#include <X11/Xlib.h>
+#include <X11/extensions/XKBstr.h>
+
+typedef struct _XkbAnyEvent
+{
+	int type;             /* XkbAnyEvent */
+	unsigned long serial; /* # of last req processed by server */
+	Bool send_event;      /* is this from a SendEvent request? */
+	Display* display;     /* Display the event was read from */
+	Time time;            /* milliseconds */
+	int xkb_type;         /* XKB event minor code */
+	unsigned int device;  /* device ID */
+} XkbAnyEvent;
+
+typedef struct _XkbNewKeyboardNotify
+{
+	int type;             /* XkbAnyEvent */
+	unsigned long serial; /* of last req processed by server */
+	Bool send_event;      /* is this from a SendEvent request? */
+	Display* display;     /* Display the event was read from */
+	Time time;            /* milliseconds */
+	int xkb_type;         /* XkbNewKeyboardNotify */
+	int device;           /* device ID */
+	int old_device;       /* device ID of previous keyboard */
+	int min_key_code;     /* minimum key code */
+	int max_key_code;     /* maximum key code */
+	int old_min_key_code; /* min key code of previous kbd */
+	int old_max_key_code; /* max key code of previous kbd */
+	unsigned int changed; /* changed aspects of the keyboard */
+	char req_major;       /* major and minor opcode of req */
+	char req_minor;       /* that caused change, if applicable */
+} XkbNewKeyboardNotifyEvent;
+
+typedef struct _XkbMapNotifyEvent
+{
+	int type;             /* XkbAnyEvent */
+	unsigned long serial; /* of last req processed by server */
+	Bool send_event;      /* is this from a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Time time;            /* milliseconds */
+	int xkb_type;         /* XkbMapNotify */
+	int device;           /* device ID */
+	unsigned int changed; /* fields which have been changed */
+	unsigned int flags;   /* reserved */
+	int first_type;       /* first changed key type */
+	int num_types;        /* number of changed key types */
+	KeyCode min_key_code;
+	KeyCode max_key_code;
+	KeyCode first_key_sym;
+	KeyCode first_key_act;
+	KeyCode first_key_behavior;
+	KeyCode first_key_explicit;
+	KeyCode first_modmap_key;
+	KeyCode first_vmodmap_key;
+	int num_key_syms;
+	int num_key_acts;
+	int num_key_behaviors;
+	int num_key_explicit;
+	int num_modmap_keys;
+	int num_vmodmap_keys;
+	unsigned int vmods; /* mask of changed virtual mods */
+} XkbMapNotifyEvent;
+
+typedef struct _XkbStateNotifyEvent
+{
+	int type;                         /* XkbAnyEvent */
+	unsigned long serial;             /* # of last req processed by server */
+	Bool send_event;                  /* is this from a SendEvent request? */
+	Display* display;                 /* Display the event was read from */
+	Time time;                        /* milliseconds */
+	int xkb_type;                     /* XkbStateNotify */
+	int device;                       /* device ID */
+	unsigned int changed;             /* mask of changed state components */
+	int group;                        /* keyboard group */
+	int base_group;                   /* base keyboard group */
+	int latched_group;                /* latched keyboard group */
+	int locked_group;                 /* locked keyboard group */
+	unsigned int mods;                /* modifier state */
+	unsigned int base_mods;           /* base modifier state */
+	unsigned int latched_mods;        /* latched modifiers */
+	unsigned int locked_mods;         /* locked modifiers */
+	int compat_state;                 /* compatibility state */
+	unsigned char grab_mods;          /* mods used for grabs */
+	unsigned char compat_grab_mods;   /* grab mods for non-XKB clients */
+	unsigned char lookup_mods;        /* mods sent to clients */
+	unsigned char compat_lookup_mods; /* mods sent to non-XKB clients */
+	int ptr_buttons;                  /* pointer button state */
+	KeyCode keycode;                  /* keycode that caused the change */
+	char event_type;                  /* KeyPress or KeyRelease */
+	char req_major;                   /* Major opcode of request */
+	char req_minor;                   /* Minor opcode of request */
+} XkbStateNotifyEvent;
+
+typedef struct _XkbControlsNotify
+{
+	int type;                          /* XkbAnyEvent */
+	unsigned long serial;              /* of last req processed by server */
+	Bool send_event;                   /* is this from a SendEvent request? */
+	Display* display;                  /* Display the event was read from */
+	Time time;                         /* milliseconds */
+	int xkb_type;                      /* XkbControlsNotify */
+	int device;                        /* device ID */
+	unsigned int changed_ctrls;        /* controls with changed sub-values */
+	unsigned int enabled_ctrls;        /* controls currently enabled */
+	unsigned int enabled_ctrl_changes; /* controls just {en,dis}abled */
+	int num_groups;                    /* total groups on keyboard */
+	KeyCode keycode;                   /* key that caused change or 0 */
+	char event_type;                   /* type of event that caused change */
+	char req_major;                    /* if keycode==0, major and minor */
+	char req_minor;                    /* opcode of req that caused change */
+} XkbControlsNotifyEvent;
+
+typedef struct _XkbIndicatorNotify
+{
+	int type;             /* XkbAnyEvent */
+	unsigned long serial; /* of last req processed by server */
+	Bool send_event;      /* is this from a SendEvent request? */
+	Display* display;     /* Display the event was read from */
+	Time time;            /* milliseconds */
+	int xkb_type;         /* XkbIndicatorNotify */
+	int device;           /* device ID */
+	unsigned int changed; /* indicators with new state or map */
+	unsigned int state;   /* current state of all indicators */
+} XkbIndicatorNotifyEvent;
+
+typedef struct _XkbNamesNotify
+{
+	int type;                        /* XkbAnyEvent */
+	unsigned long serial;            /* of last req processed by server */
+	Bool send_event;                 /* is this from a SendEvent request? */
+	Display* display;                /* Display the event was read from */
+	Time time;                       /* milliseconds */
+	int xkb_type;                    /* XkbNamesNotify */
+	int device;                      /* device ID */
+	unsigned int changed;            /* names that have changed */
+	int first_type;                  /* first key type with new name */
+	int num_types;                   /* number of key types with new names */
+	int first_lvl;                   /* first key type new new level names */
+	int num_lvls;                    /* # of key types w/new level names */
+	int num_aliases;                 /* total number of key aliases*/
+	int num_radio_groups;            /* total number of radio groups */
+	unsigned int changed_vmods;      /* virtual modifiers with new names */
+	unsigned int changed_groups;     /* groups with new names */
+	unsigned int changed_indicators; /* indicators with new names */
+	int first_key;                   /* first key with new name */
+	int num_keys;                    /* number of keys with new names */
+} XkbNamesNotifyEvent;
+
+typedef struct _XkbCompatMapNotify
+{
+	int type;                    /* XkbAnyEvent */
+	unsigned long serial;        /* of last req processed by server */
+	Bool send_event;             /* is this from a SendEvent request? */
+	Display* display;            /* Display the event was read from */
+	Time time;                   /* milliseconds */
+	int xkb_type;                /* XkbCompatMapNotify */
+	int device;                  /* device ID */
+	unsigned int changed_groups; /* groups with new compat maps */
+	int first_si;                /* first new symbol interp */
+	int num_si;                  /* number of new symbol interps */
+	int num_total_si;            /* total # of symbol interps */
+} XkbCompatMapNotifyEvent;
+
+typedef struct _XkbBellNotify
+{
+	int type;             /* XkbAnyEvent */
+	unsigned long serial; /* of last req processed by server */
+	Bool send_event;      /* is this from a SendEvent request? */
+	Display* display;     /* Display the event was read from */
+	Time time;            /* milliseconds */
+	int xkb_type;         /* XkbBellNotify */
+	int device;           /* device ID */
+	int percent;          /* requested volume as a % of maximum */
+	int pitch;            /* requested pitch in Hz */
+	int duration;         /* requested duration in useconds */
+	int bell_class;       /* (input extension) feedback class */
+	int bell_id;          /* (input extension) ID of feedback */
+	Atom name;            /* "name" of requested bell */
+	Window window;        /* window associated with event */
+	Bool event_only;      /* "event only" requested */
+} XkbBellNotifyEvent;
+
+typedef struct _XkbActionMessage
+{
+	int type;               /* XkbAnyEvent */
+	unsigned long serial;   /* of last req processed by server */
+	Bool send_event;        /* is this from a SendEvent request? */
+	Display* display;       /* Display the event was read from */
+	Time time;              /* milliseconds */
+	int xkb_type;           /* XkbActionMessage */
+	int device;             /* device ID */
+	KeyCode keycode;        /* key that generated the event */
+	Bool press;             /* true if act caused by key press */
+	Bool key_event_follows; /* true if key event also generated */
+	int group;              /* effective group */
+	unsigned int mods;      /* effective mods */
+	char message[XkbActionMessageLength + 1];
+	/* message -- leave space for NUL */
+} XkbActionMessageEvent;
+
+typedef struct _XkbAccessXNotify
+{
+	int type;             /* XkbAnyEvent */
+	unsigned long serial; /* of last req processed by server */
+	Bool send_event;      /* is this from a SendEvent request? */
+	Display* display;     /* Display the event was read from */
+	Time time;            /* milliseconds */
+	int xkb_type;         /* XkbAccessXNotify */
+	int device;           /* device ID */
+	int detail;           /* XkbAXN_* */
+	int keycode;          /* key of event */
+	int sk_delay;         /* current slow keys delay */
+	int debounce_delay;   /* current debounce delay */
+} XkbAccessXNotifyEvent;
+
+typedef struct _XkbExtensionDeviceNotify
+{
+	int type;                 /* XkbAnyEvent */
+	unsigned long serial;     /* of last req processed by server */
+	Bool send_event;          /* is this from a SendEvent request? */
+	Display* display;         /* Display the event was read from */
+	Time time;                /* milliseconds */
+	int xkb_type;             /* XkbExtensionDeviceNotify */
+	int device;               /* device ID */
+	unsigned int reason;      /* reason for the event */
+	unsigned int supported;   /* mask of supported features */
+	unsigned int unsupported; /* mask of unsupported features */
+	/* that some app tried to use */
+	int first_btn;             /* first button that changed */
+	int num_btns;              /* range of buttons changed */
+	unsigned int leds_defined; /* indicators with names or maps */
+	unsigned int led_state;    /* current state of the indicators */
+	int led_class;             /* feedback class for led changes */
+	int led_id;                /* feedback id for led changes */
+} XkbExtensionDeviceNotifyEvent;
+
+typedef union _XkbEvent {
+	int type;
+	XkbAnyEvent any;
+	XkbNewKeyboardNotifyEvent new_kbd;
+	XkbMapNotifyEvent map;
+	XkbStateNotifyEvent state;
+	XkbControlsNotifyEvent ctrls;
+	XkbIndicatorNotifyEvent indicators;
+	XkbNamesNotifyEvent names;
+	XkbCompatMapNotifyEvent compat;
+	XkbBellNotifyEvent bell;
+	XkbActionMessageEvent message;
+	XkbAccessXNotifyEvent accessx;
+	XkbExtensionDeviceNotifyEvent device;
+	XEvent core;
+} XkbEvent;
+
+typedef struct _XkbKbdDpyState XkbKbdDpyStateRec, *XkbKbdDpyStatePtr;
+
+/* XkbOpenDisplay error codes */
+#define XkbOD_Success 0
+#define XkbOD_BadLibraryVersion 1
+#define XkbOD_ConnectionRefused 2
+#define XkbOD_NonXkbServer 3
+#define XkbOD_BadServerVersion 4
+
+/* Values for XlibFlags */
+#define XkbLC_ForceLatin1Lookup (1 << 0)
+#define XkbLC_ConsumeLookupMods (1 << 1)
+#define XkbLC_AlwaysConsumeShiftAndLock (1 << 2)
+#define XkbLC_IgnoreNewKeyboards (1 << 3)
+#define XkbLC_ControlFallback (1 << 4)
+#define XkbLC_ConsumeKeysOnComposeFail (1 << 29)
+#define XkbLC_ComposeLED (1 << 30)
+#define XkbLC_BeepOnComposeFail (1 << 31)
+
+#define XkbLC_AllComposeControls (0xc0000000)
+#define XkbLC_AllControls (0xc000001f)
+
+_XFUNCPROTOBEGIN
+
+extern Bool XkbIgnoreExtension(
+	Bool /* ignore */
+);
+
+extern Display* XkbOpenDisplay(
+	char* /* name */,
+	int* /* ev_rtrn */,
+	int* /* err_rtrn */,
+	int* /* major_rtrn */,
+	int* /* minor_rtrn */,
+	int* /* reason */
+);
+
+extern Bool XkbQueryExtension(
+	Display* /* dpy */,
+	int* /* opcodeReturn */,
+	int* /* eventBaseReturn */,
+	int* /* errorBaseReturn */,
+	int* /* majorRtrn */,
+	int* /* minorRtrn */
+);
+
+extern Bool XkbUseExtension(
+	Display* /* dpy */,
+	int* /* major_rtrn */,
+	int* /* minor_rtrn */
+);
+
+extern Bool XkbLibraryVersion(
+	int* /* libMajorRtrn */,
+	int* /* libMinorRtrn */
+);
+
+extern unsigned int XkbSetXlibControls(
+	Display* /* dpy */,
+	unsigned int /* affect */,
+	unsigned int /* values */
+);
+
+extern unsigned int XkbGetXlibControls(
+	Display* /* dpy */
+);
+
+extern unsigned int XkbXlibControlsImplemented(void);
+
+typedef Atom (*XkbInternAtomFunc)(
+	Display* /* dpy */,
+	_Xconst char* /* name */,
+	Bool /* only_if_exists */
+);
+
+typedef char* (*XkbGetAtomNameFunc)(
+	Display* /* dpy */,
+	Atom /* atom */
+);
+
+extern void XkbSetAtomFuncs(
+	XkbInternAtomFunc /* getAtom */,
+	XkbGetAtomNameFunc /* getName */
+);
+
+extern KeySym XkbKeycodeToKeysym(
+	Display* /* dpy */,
+#if NeedWidePrototypes
+	unsigned int /* kc */,
+#else
+	KeyCode /* kc */,
+#endif
+	int /* group */,
+	int /* level */
+);
+
+extern unsigned int XkbKeysymToModifiers(
+	Display* /* dpy */,
+	KeySym /* ks */
+);
+
+extern Bool XkbLookupKeySym(
+	Display* /* dpy */,
+	KeyCode /* keycode */,
+	unsigned int /* modifiers */,
+	unsigned int* /* modifiers_return */,
+	KeySym* /* keysym_return */
+);
+
+extern int XkbLookupKeyBinding(
+	Display* /* dpy */,
+	KeySym /* sym_rtrn */,
+	unsigned int /* mods */,
+	char* /* buffer */,
+	int /* nbytes */,
+	int* /* extra_rtrn */
+);
+
+extern Bool XkbTranslateKeyCode(
+	XkbDescPtr /* xkb */,
+	KeyCode /* keycode */,
+	unsigned int /* modifiers */,
+	unsigned int* /* modifiers_return */,
+	KeySym* /* keysym_return */
+);
+
+extern int XkbTranslateKeySym(
+	Display* /* dpy */,
+	register KeySym* /* sym_return */,
+	unsigned int /* modifiers */,
+	char* /* buffer */,
+	int /* nbytes */,
+	int* /* extra_rtrn */
+);
+
+extern Bool XkbSetAutoRepeatRate(
+	Display* /* dpy */,
+	unsigned int /* deviceSpec */,
+	unsigned int /* delay */,
+	unsigned int /* interval */
+);
+
+extern Bool XkbGetAutoRepeatRate(
+	Display* /* dpy */,
+	unsigned int /* deviceSpec */,
+	unsigned int* /* delayRtrn */,
+	unsigned int* /* intervalRtrn */
+);
+
+extern Bool XkbChangeEnabledControls(
+	Display* /* dpy */,
+	unsigned int /* deviceSpec */,
+	unsigned int /* affect */,
+	unsigned int /* values */
+);
+
+extern Bool XkbDeviceBell(
+	Display* /* dpy */,
+	Window /* win */,
+	int /* deviceSpec */,
+	int /* bellClass */,
+	int /* bellID */,
+	int /* percent */,
+	Atom /* name */
+);
+
+extern Bool XkbForceDeviceBell(
+	Display* /* dpy */,
+	int /* deviceSpec */,
+	int /* bellClass */,
+	int /* bellID */,
+	int /* percent */
+);
+
+extern Bool XkbDeviceBellEvent(
+	Display* /* dpy */,
+	Window /* win */,
+	int /* deviceSpec */,
+	int /* bellClass */,
+	int /* bellID */,
+	int /* percent */,
+	Atom /* name */
+);
+
+extern Bool XkbBell(
+	Display* /* dpy */,
+	Window /* win */,
+	int /* percent */,
+	Atom /* name */
+);
+
+extern Bool XkbForceBell(
+	Display* /* dpy */,
+	int /* percent */
+);
+
+extern Bool XkbBellEvent(
+	Display* /* dpy */,
+	Window /* win */,
+	int /* percent */,
+	Atom /* name */
+);
+
+extern Bool XkbSelectEvents(
+	Display* /* dpy */,
+	unsigned int /* deviceID */,
+	unsigned int /* affect */,
+	unsigned int /* values */
+);
+
+extern Bool XkbSelectEventDetails(
+	Display* /* dpy */,
+	unsigned int /* deviceID */,
+	unsigned int /* eventType */,
+	unsigned long /* affect */,
+	unsigned long /* details */
+);
+
+extern void XkbNoteMapChanges(
+	XkbMapChangesPtr /* old */,
+	XkbMapNotifyEvent* /* new */,
+	unsigned int /* wanted */
+);
+
+extern void XkbNoteNameChanges(
+	XkbNameChangesPtr /* old */,
+	XkbNamesNotifyEvent* /* new */,
+	unsigned int /* wanted */
+);
+
+extern Status XkbGetIndicatorState(
+	Display* /* dpy */,
+	unsigned int /* deviceSpec */,
+	unsigned int* /* pStateRtrn */
+);
+
+extern Status XkbGetDeviceIndicatorState(
+	Display* /* dpy */,
+	unsigned int /* deviceSpec */,
+	unsigned int /* ledClass */,
+	unsigned int /* ledID */,
+	unsigned int* /* pStateRtrn */
+);
+
+extern Status XkbGetIndicatorMap(
+	Display* /* dpy */,
+	unsigned long /* which */,
+	XkbDescPtr /* desc */
+);
+
+extern Bool XkbSetIndicatorMap(
+	Display* /* dpy */,
+	unsigned long /* which */,
+	XkbDescPtr /* desc */
+);
+
+#define XkbNoteIndicatorMapChanges(o, n, w) \
+	((o)->map_changes |= ((n)->map_changes & (w)))
+#define XkbNoteIndicatorStateChanges(o, n, w) \
+	((o)->state_changes |= ((n)->state_changes & (w)))
+#define XkbGetIndicatorMapChanges(d, x, c) \
+	(XkbGetIndicatorMap((d), (c)->map_changes, x))
+#define XkbChangeIndicatorMaps(d, x, c) \
+	(XkbSetIndicatorMap((d), (c)->map_changes, x))
+
+extern Bool XkbGetNamedIndicator(
+	Display* /* dpy */,
+	Atom /* name */,
+	int* /* pNdxRtrn */,
+	Bool* /* pStateRtrn */,
+	XkbIndicatorMapPtr /* pMapRtrn */,
+	Bool* /* pRealRtrn */
+);
+
+extern Bool XkbGetNamedDeviceIndicator(
+	Display* /* dpy */,
+	unsigned int /* deviceSpec */,
+	unsigned int /* ledClass */,
+	unsigned int /* ledID */,
+	Atom /* name */,
+	int* /* pNdxRtrn */,
+	Bool* /* pStateRtrn */,
+	XkbIndicatorMapPtr /* pMapRtrn */,
+	Bool* /* pRealRtrn */
+);
+
+extern Bool XkbSetNamedIndicator(
+	Display* /* dpy */,
+	Atom /* name */,
+	Bool /* changeState */,
+	Bool /* state */,
+	Bool /* createNewMap */,
+	XkbIndicatorMapPtr /* pMap */
+);
+
+extern Bool XkbSetNamedDeviceIndicator(
+	Display* /* dpy */,
+	unsigned int /* deviceSpec */,
+	unsigned int /* ledClass */,
+	unsigned int /* ledID */,
+	Atom /* name */,
+	Bool /* changeState */,
+	Bool /* state */,
+	Bool /* createNewMap */,
+	XkbIndicatorMapPtr /* pMap */
+);
+
+extern Bool XkbLockModifiers(
+	Display* /* dpy */,
+	unsigned int /* deviceSpec */,
+	unsigned int /* affect */,
+	unsigned int /* values */
+);
+
+extern Bool XkbLatchModifiers(
+	Display* /* dpy */,
+	unsigned int /* deviceSpec */,
+	unsigned int /* affect */,
+	unsigned int /* values */
+);
+
+extern Bool XkbLockGroup(
+	Display* /* dpy */,
+	unsigned int /* deviceSpec */,
+	unsigned int /* group */
+);
+
+extern Bool XkbLatchGroup(
+	Display* /* dpy */,
+	unsigned int /* deviceSpec */,
+	unsigned int /* group */
+);
+
+extern Bool XkbSetServerInternalMods(
+	Display* /* dpy */,
+	unsigned int /* deviceSpec */,
+	unsigned int /* affectReal */,
+	unsigned int /* realValues */,
+	unsigned int /* affectVirtual */,
+	unsigned int /* virtualValues */
+);
+
+extern Bool XkbSetIgnoreLockMods(
+	Display* /* dpy */,
+	unsigned int /* deviceSpec */,
+	unsigned int /* affectReal */,
+	unsigned int /* realValues */,
+	unsigned int /* affectVirtual */,
+	unsigned int /* virtualValues */
+);
+
+extern Bool XkbVirtualModsToReal(
+	XkbDescPtr /* xkb */,
+	unsigned int /* virtual_mask */,
+	unsigned int* /* mask_rtrn */
+);
+
+extern Bool XkbComputeEffectiveMap(
+	XkbDescPtr /* xkb */,
+	XkbKeyTypePtr /* type */,
+	unsigned char* /* map_rtrn */
+);
+
+extern Status XkbInitCanonicalKeyTypes(
+	XkbDescPtr /* xkb */,
+	unsigned int /* which */,
+	int /* keypadVMod */
+);
+
+extern XkbDescPtr XkbAllocKeyboard(
+	void);
+
+extern void XkbFreeKeyboard(
+	XkbDescPtr /* xkb */,
+	unsigned int /* which */,
+	Bool /* freeDesc */
+);
+
+extern Status XkbAllocClientMap(
+	XkbDescPtr /* xkb */,
+	unsigned int /* which */,
+	unsigned int /* nTypes */
+);
+
+extern Status XkbAllocServerMap(
+	XkbDescPtr /* xkb */,
+	unsigned int /* which */,
+	unsigned int /* nActions */
+);
+
+extern void XkbFreeClientMap(
+	XkbDescPtr /* xkb */,
+	unsigned int /* what */,
+	Bool /* freeMap */
+);
+
+extern void XkbFreeServerMap(
+	XkbDescPtr /* xkb */,
+	unsigned int /* what */,
+	Bool /* freeMap */
+);
+
+extern XkbKeyTypePtr XkbAddKeyType(
+	XkbDescPtr /* xkb */,
+	Atom /* name */,
+	int /* map_count */,
+	Bool /* want_preserve */,
+	int /* num_lvls */
+);
+
+extern Status XkbAllocIndicatorMaps(
+	XkbDescPtr /* xkb */
+);
+
+extern void XkbFreeIndicatorMaps(
+	XkbDescPtr /* xkb */
+);
+
+extern XkbDescPtr XkbGetMap(
+	Display* /* dpy */,
+	unsigned int /* which */,
+	unsigned int /* deviceSpec */
+);
+
+extern Status XkbGetUpdatedMap(
+	Display* /* dpy */,
+	unsigned int /* which */,
+	XkbDescPtr /* desc */
+);
+
+extern Status XkbGetMapChanges(
+	Display* /* dpy */,
+	XkbDescPtr /* xkb */,
+	XkbMapChangesPtr /* changes */
+);
+
+extern Status XkbRefreshKeyboardMapping(
+	XkbMapNotifyEvent* /* event */
+);
+
+extern Status XkbGetKeyTypes(
+	Display* /* dpy */,
+	unsigned int /* first */,
+	unsigned int /* num */,
+	XkbDescPtr /* xkb */
+);
+
+extern Status XkbGetKeySyms(
+	Display* /* dpy */,
+	unsigned int /* first */,
+	unsigned int /* num */,
+	XkbDescPtr /* xkb */
+);
+
+extern Status XkbGetKeyActions(
+	Display* /* dpy */,
+	unsigned int /* first */,
+	unsigned int /* num */,
+	XkbDescPtr /* xkb */
+);
+
+extern Status XkbGetKeyBehaviors(
+	Display* /* dpy */,
+	unsigned int /* firstKey */,
+	unsigned int /* nKeys */,
+	XkbDescPtr /* desc */
+);
+
+extern Status XkbGetVirtualMods(
+	Display* /* dpy */,
+	unsigned int /* which */,
+	XkbDescPtr /* desc */
+);
+
+extern Status XkbGetKeyExplicitComponents(
+	Display* /* dpy */,
+	unsigned int /* firstKey */,
+	unsigned int /* nKeys */,
+	XkbDescPtr /* desc */
+);
+
+extern Status XkbGetKeyModifierMap(
+	Display* /* dpy */,
+	unsigned int /* firstKey */,
+	unsigned int /* nKeys */,
+	XkbDescPtr /* desc */
+);
+
+extern Status XkbGetKeyVirtualModMap(
+	Display* /* dpy */,
+	unsigned int /* first */,
+	unsigned int /* num */,
+	XkbDescPtr /* xkb */
+);
+
+extern Status XkbAllocControls(
+	XkbDescPtr /* xkb */,
+	unsigned int /* which*/
+);
+
+extern void XkbFreeControls(
+	XkbDescPtr /* xkb */,
+	unsigned int /* which */,
+	Bool /* freeMap */
+);
+
+extern Status XkbGetControls(
+	Display* /* dpy */,
+	unsigned long /* which */,
+	XkbDescPtr /* desc */
+);
+
+extern Bool XkbSetControls(
+	Display* /* dpy */,
+	unsigned long /* which */,
+	XkbDescPtr /* desc */
+);
+
+extern void XkbNoteControlsChanges(
+	XkbControlsChangesPtr /* old */,
+	XkbControlsNotifyEvent* /* new */,
+	unsigned int /* wanted */
+);
+
+#define XkbGetControlsChanges(d, x, c) XkbGetControls(d, (c)->changed_ctrls, x)
+#define XkbChangeControls(d, x, c) XkbSetControls(d, (c)->changed_ctrls, x)
+
+extern Status XkbAllocCompatMap(
+	XkbDescPtr /* xkb */,
+	unsigned int /* which */,
+	unsigned int /* nInterpret */
+);
+
+extern void XkbFreeCompatMap(
+	XkbDescPtr /* xkb */,
+	unsigned int /* which */,
+	Bool /* freeMap */
+);
+
+extern Status XkbGetCompatMap(
+	Display* /* dpy */,
+	unsigned int /* which */,
+	XkbDescPtr /* xkb */
+);
+
+extern Bool XkbSetCompatMap(
+	Display* /* dpy */,
+	unsigned int /* which */,
+	XkbDescPtr /* xkb */,
+	Bool /* updateActions */
+);
+
+extern XkbSymInterpretPtr XkbAddSymInterpret(
+	XkbDescPtr /* xkb */,
+	XkbSymInterpretPtr /* si */,
+	Bool /* updateMap */,
+	XkbChangesPtr /* changes */
+);
+
+extern Status XkbAllocNames(
+	XkbDescPtr /* xkb */,
+	unsigned int /* which */,
+	int /* nTotalRG */,
+	int /* nTotalAliases */
+);
+
+extern Status XkbGetNames(
+	Display* /* dpy */,
+	unsigned int /* which */,
+	XkbDescPtr /* desc */
+);
+
+extern Bool XkbSetNames(
+	Display* /* dpy */,
+	unsigned int /* which */,
+	unsigned int /* firstType */,
+	unsigned int /* nTypes */,
+	XkbDescPtr /* desc */
+);
+
+extern Bool XkbChangeNames(
+	Display* /* dpy */,
+	XkbDescPtr /* xkb */,
+	XkbNameChangesPtr /* changes */
+);
+
+extern void XkbFreeNames(
+	XkbDescPtr /* xkb */,
+	unsigned int /* which */,
+	Bool /* freeMap */
+);
+
+extern Status XkbGetState(
+	Display* /* dpy */,
+	unsigned int /* deviceSpec */,
+	XkbStatePtr /* rtrnState */
+);
+
+extern Bool XkbSetMap(
+	Display* /* dpy */,
+	unsigned int /* which */,
+	XkbDescPtr /* desc */
+);
+
+extern Bool XkbChangeMap(
+	Display* /* dpy */,
+	XkbDescPtr /* desc */,
+	XkbMapChangesPtr /* changes */
+);
+
+extern Bool XkbSetDetectableAutoRepeat(
+	Display* /* dpy */,
+	Bool /* detectable */,
+	Bool* /* supported */
+);
+
+extern Bool XkbGetDetectableAutoRepeat(
+	Display* /* dpy */,
+	Bool* /* supported */
+);
+
+extern Bool XkbSetAutoResetControls(
+	Display* /* dpy */,
+	unsigned int /* changes */,
+	unsigned int* /* auto_ctrls */,
+	unsigned int* /* auto_values */
+);
+
+extern Bool XkbGetAutoResetControls(
+	Display* /* dpy */,
+	unsigned int* /* auto_ctrls */,
+	unsigned int* /* auto_ctrl_values */
+);
+
+extern Bool XkbSetPerClientControls(
+	Display* /* dpy */,
+	unsigned int /* change */,
+	unsigned int* /* values */
+);
+
+extern Bool XkbGetPerClientControls(
+	Display* /* dpy */,
+	unsigned int* /* ctrls */
+);
+
+extern Status XkbCopyKeyType(
+	XkbKeyTypePtr /* from */,
+	XkbKeyTypePtr /* into */
+);
+
+extern Status XkbCopyKeyTypes(
+	XkbKeyTypePtr /* from */,
+	XkbKeyTypePtr /* into */,
+	int /* num_types */
+);
+
+extern Status XkbResizeKeyType(
+	XkbDescPtr /* xkb */,
+	int /* type_ndx */,
+	int /* map_count */,
+	Bool /* want_preserve */,
+	int /* new_num_lvls */
+);
+
+extern KeySym* XkbResizeKeySyms(
+	XkbDescPtr /* desc */,
+	int /* forKey */,
+	int /* symsNeeded */
+);
+
+extern XkbAction* XkbResizeKeyActions(
+	XkbDescPtr /* desc */,
+	int /* forKey */,
+	int /* actsNeeded */
+);
+
+extern Status XkbChangeTypesOfKey(
+	XkbDescPtr /* xkb */,
+	int /* key */,
+	int /* num_groups */,
+	unsigned int /* groups */,
+	int* /* newTypes */,
+	XkbMapChangesPtr /* pChanges */
+);
+
+extern Status XkbChangeKeycodeRange(
+	XkbDescPtr /* xkb */,
+	int /* minKC */,
+	int /* maxKC */,
+	XkbChangesPtr /* changes */
+);
+
+/***====================================================================***/
+
+extern XkbComponentListPtr XkbListComponents(
+	Display* /* dpy */,
+	unsigned int /* deviceSpec */,
+	XkbComponentNamesPtr /* ptrns */,
+	int* /* max_inout */
+);
+
+extern void XkbFreeComponentList(
+	XkbComponentListPtr /* list */
+);
+
+extern XkbDescPtr XkbGetKeyboard(
+	Display* /* dpy */,
+	unsigned int /* which */,
+	unsigned int /* deviceSpec */
+);
+
+extern XkbDescPtr XkbGetKeyboardByName(
+	Display* /* dpy */,
+	unsigned int /* deviceSpec */,
+	XkbComponentNamesPtr /* names */,
+	unsigned int /* want */,
+	unsigned int /* need */,
+	Bool /* load */
+);
+
+/***====================================================================***/
+
+extern int XkbKeyTypesForCoreSymbols(                              /* returns # of groups */
+									 XkbDescPtr /* xkb */,         /* keyboard device */
+									 int /* map_width */,          /* width of core KeySym array */
+									 KeySym* /* core_syms */,      /* always mapWidth symbols */
+									 unsigned int /* protected */, /* explicit key types */
+									 int* /* types_inout */,       /* always four type indices */
+									 KeySym* /* xkb_syms_rtrn */   /* must have enough space */
+);
+
+extern Bool XkbApplyCompatMapToKey(                            /* False only on error */
+								   XkbDescPtr /* xkb */,       /* keymap to be edited */
+								   KeyCode /* key */,          /* key to be updated */
+								   XkbChangesPtr /* changes */ /* resulting changes to map */
+);
+
+extern Bool XkbUpdateMapFromCore(                            /* False only on error */
+								 XkbDescPtr /* xkb */,       /* XKB keyboard to be edited */
+								 KeyCode /* first_key */,    /* first changed key */
+								 int /* num_keys */,         /* number of changed keys */
+								 int /* map_width */,        /* width of core keymap */
+								 KeySym* /* core_keysyms */, /* symbols from core keymap */
+								 XkbChangesPtr /* changes */ /* resulting changes */
+);
+
+/***====================================================================***/
+
+extern XkbDeviceLedInfoPtr XkbAddDeviceLedInfo(
+	XkbDeviceInfoPtr /* devi */,
+	unsigned int /* ledClass */,
+	unsigned int /* ledId */
+);
+
+extern Status XkbResizeDeviceButtonActions(
+	XkbDeviceInfoPtr /* devi */,
+	unsigned int /* newTotal */
+);
+
+extern XkbDeviceInfoPtr XkbAllocDeviceInfo(
+	unsigned int /* deviceSpec */,
+	unsigned int /* nButtons */,
+	unsigned int /* szLeds */
+);
+
+extern void XkbFreeDeviceInfo(
+	XkbDeviceInfoPtr /* devi */,
+	unsigned int /* which */,
+	Bool /* freeDevI */
+);
+
+extern void XkbNoteDeviceChanges(
+	XkbDeviceChangesPtr /* old */,
+	XkbExtensionDeviceNotifyEvent* /* new */,
+	unsigned int /* wanted */
+);
+
+extern XkbDeviceInfoPtr XkbGetDeviceInfo(
+	Display* /* dpy */,
+	unsigned int /* which */,
+	unsigned int /* deviceSpec */,
+	unsigned int /* ledClass */,
+	unsigned int /* ledID */
+);
+
+extern Status XkbGetDeviceInfoChanges(
+	Display* /* dpy */,
+	XkbDeviceInfoPtr /* devi */,
+	XkbDeviceChangesPtr /* changes */
+);
+
+extern Status XkbGetDeviceButtonActions(
+	Display* /* dpy */,
+	XkbDeviceInfoPtr /* devi */,
+	Bool /* all */,
+	unsigned int /* first */,
+	unsigned int /* nBtns */
+);
+
+extern Status XkbGetDeviceLedInfo(
+	Display* /* dpy */,
+	XkbDeviceInfoPtr /* devi */,
+	unsigned int /* ledClass (class, XIDflt, XIAll) */,
+	unsigned int /* ledId (id, XIDflt, XIAll) */,
+	unsigned int /* which (XkbXI_Indicator{Names,Map}Mask */
+);
+
+extern Bool XkbSetDeviceInfo(
+	Display* /* dpy */,
+	unsigned int /* which */,
+	XkbDeviceInfoPtr /* devi */
+);
+
+extern Bool XkbChangeDeviceInfo(
+	Display* /* dpy */,
+	XkbDeviceInfoPtr /* desc */,
+	XkbDeviceChangesPtr /* changes */
+);
+
+extern Bool XkbSetDeviceLedInfo(
+	Display* /* dpy */,
+	XkbDeviceInfoPtr /* devi */,
+	unsigned int /* ledClass */,
+	unsigned int /* ledID */,
+	unsigned int /* which */
+);
+
+extern Bool XkbSetDeviceButtonActions(
+	Display* /* dpy */,
+	XkbDeviceInfoPtr /* devi */,
+	unsigned int /* first */,
+	unsigned int /* nBtns */
+);
+
+/***====================================================================***/
+
+extern char XkbToControl(
+	char /* c */
+);
+
+/***====================================================================***/
+
+extern Bool XkbSetDebuggingFlags(
+	Display* /* dpy */,
+	unsigned int /* mask */,
+	unsigned int /* flags */,
+	char* /* msg */,
+	unsigned int /* ctrls_mask */,
+	unsigned int /* ctrls */,
+	unsigned int* /* rtrn_flags */,
+	unsigned int* /* rtrn_ctrls */
+);
+
+extern Bool XkbApplyVirtualModChanges(
+	XkbDescPtr /* xkb */,
+	unsigned int /* changed */,
+	XkbChangesPtr /* changes */
+);
+
+extern Bool XkbUpdateActionVirtualMods(
+	XkbDescPtr /* xkb */,
+	XkbAction* /* act */,
+	unsigned int /* changed */
+);
+
+extern void XkbUpdateKeyTypeVirtualMods(
+	XkbDescPtr /* xkb */,
+	XkbKeyTypePtr /* type */,
+	unsigned int /* changed */,
+	XkbChangesPtr /* changes */
+);
+
+_XFUNCPROTOEND
+
+#endif /* _X11_XKBLIB_H_ */
diff --git a/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/Xatom.h b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/Xatom.h
new file mode 100644
index 00000000..c587d97c
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/Xatom.h
@@ -0,0 +1,79 @@
+#ifndef XATOM_H
+#define XATOM_H 1
+
+/* THIS IS A GENERATED FILE
+ *
+ * Do not change!  Changing this file implies a protocol change!
+ */
+
+#define XA_PRIMARY ((Atom)1)
+#define XA_SECONDARY ((Atom)2)
+#define XA_ARC ((Atom)3)
+#define XA_ATOM ((Atom)4)
+#define XA_BITMAP ((Atom)5)
+#define XA_CARDINAL ((Atom)6)
+#define XA_COLORMAP ((Atom)7)
+#define XA_CURSOR ((Atom)8)
+#define XA_CUT_BUFFER0 ((Atom)9)
+#define XA_CUT_BUFFER1 ((Atom)10)
+#define XA_CUT_BUFFER2 ((Atom)11)
+#define XA_CUT_BUFFER3 ((Atom)12)
+#define XA_CUT_BUFFER4 ((Atom)13)
+#define XA_CUT_BUFFER5 ((Atom)14)
+#define XA_CUT_BUFFER6 ((Atom)15)
+#define XA_CUT_BUFFER7 ((Atom)16)
+#define XA_DRAWABLE ((Atom)17)
+#define XA_FONT ((Atom)18)
+#define XA_INTEGER ((Atom)19)
+#define XA_PIXMAP ((Atom)20)
+#define XA_POINT ((Atom)21)
+#define XA_RECTANGLE ((Atom)22)
+#define XA_RESOURCE_MANAGER ((Atom)23)
+#define XA_RGB_COLOR_MAP ((Atom)24)
+#define XA_RGB_BEST_MAP ((Atom)25)
+#define XA_RGB_BLUE_MAP ((Atom)26)
+#define XA_RGB_DEFAULT_MAP ((Atom)27)
+#define XA_RGB_GRAY_MAP ((Atom)28)
+#define XA_RGB_GREEN_MAP ((Atom)29)
+#define XA_RGB_RED_MAP ((Atom)30)
+#define XA_STRING ((Atom)31)
+#define XA_VISUALID ((Atom)32)
+#define XA_WINDOW ((Atom)33)
+#define XA_WM_COMMAND ((Atom)34)
+#define XA_WM_HINTS ((Atom)35)
+#define XA_WM_CLIENT_MACHINE ((Atom)36)
+#define XA_WM_ICON_NAME ((Atom)37)
+#define XA_WM_ICON_SIZE ((Atom)38)
+#define XA_WM_NAME ((Atom)39)
+#define XA_WM_NORMAL_HINTS ((Atom)40)
+#define XA_WM_SIZE_HINTS ((Atom)41)
+#define XA_WM_ZOOM_HINTS ((Atom)42)
+#define XA_MIN_SPACE ((Atom)43)
+#define XA_NORM_SPACE ((Atom)44)
+#define XA_MAX_SPACE ((Atom)45)
+#define XA_END_SPACE ((Atom)46)
+#define XA_SUPERSCRIPT_X ((Atom)47)
+#define XA_SUPERSCRIPT_Y ((Atom)48)
+#define XA_SUBSCRIPT_X ((Atom)49)
+#define XA_SUBSCRIPT_Y ((Atom)50)
+#define XA_UNDERLINE_POSITION ((Atom)51)
+#define XA_UNDERLINE_THICKNESS ((Atom)52)
+#define XA_STRIKEOUT_ASCENT ((Atom)53)
+#define XA_STRIKEOUT_DESCENT ((Atom)54)
+#define XA_ITALIC_ANGLE ((Atom)55)
+#define XA_X_HEIGHT ((Atom)56)
+#define XA_QUAD_WIDTH ((Atom)57)
+#define XA_WEIGHT ((Atom)58)
+#define XA_POINT_SIZE ((Atom)59)
+#define XA_RESOLUTION ((Atom)60)
+#define XA_COPYRIGHT ((Atom)61)
+#define XA_NOTICE ((Atom)62)
+#define XA_FONT_NAME ((Atom)63)
+#define XA_FAMILY_NAME ((Atom)64)
+#define XA_FULL_NAME ((Atom)65)
+#define XA_CAP_HEIGHT ((Atom)66)
+#define XA_WM_CLASS ((Atom)67)
+#define XA_WM_TRANSIENT_FOR ((Atom)68)
+
+#define XA_LAST_PREDEFINED ((Atom)68)
+#endif /* XATOM_H */
diff --git a/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/Xfuncproto.h b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/Xfuncproto.h
new file mode 100644
index 00000000..db6d41f4
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/Xfuncproto.h
@@ -0,0 +1,176 @@
+/* Xfuncproto.h.  Generated from Xfuncproto.h.in by configure.  */
+/*
+ *
+Copyright 1989, 1991, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+ *
+ */
+
+/* Definitions to make function prototypes manageable */
+
+#ifndef _XFUNCPROTO_H_
+#define _XFUNCPROTO_H_
+
+#ifndef NeedFunctionPrototypes
+#define NeedFunctionPrototypes 1
+#endif /* NeedFunctionPrototypes */
+
+#ifndef NeedVarargsPrototypes
+#define NeedVarargsPrototypes 1
+#endif /* NeedVarargsPrototypes */
+
+#if NeedFunctionPrototypes
+
+#ifndef NeedNestedPrototypes
+#define NeedNestedPrototypes 1
+#endif /* NeedNestedPrototypes */
+
+#ifndef _Xconst
+#define _Xconst const
+#endif /* _Xconst */
+
+/* Function prototype configuration (see configure for more info) */
+#ifndef NARROWPROTO
+#define NARROWPROTO /**/
+#endif
+#ifndef FUNCPROTO
+#define FUNCPROTO 15
+#endif
+
+#ifndef NeedWidePrototypes
+#ifdef NARROWPROTO
+#define NeedWidePrototypes 0
+#else
+#define NeedWidePrototypes 1 /* default to make interropt. easier */
+#endif
+#endif /* NeedWidePrototypes */
+
+#endif /* NeedFunctionPrototypes */
+
+#ifndef _XFUNCPROTOBEGIN
+#if defined(__cplusplus) || defined(c_plusplus) /* for C++ V2.0 */
+#define _XFUNCPROTOBEGIN \
+	extern "C"           \
+	{ /* do not leave open across includes */
+#define _XFUNCPROTOEND }
+#else
+#define _XFUNCPROTOBEGIN
+#define _XFUNCPROTOEND
+#endif
+#endif /* _XFUNCPROTOBEGIN */
+
+/* Added in X11R6.9, so available in any version of modular xproto */
+#if defined(__GNUC__) && (__GNUC__ >= 4)
+#define _X_SENTINEL(x) __attribute__((__sentinel__(x)))
+#else
+#define _X_SENTINEL(x)
+#endif /* GNUC >= 4 */
+
+/* Added in X11R6.9, so available in any version of modular xproto */
+#if defined(__GNUC__) && (__GNUC__ >= 4) && !defined(__CYGWIN__) && !defined(__MINGW32__)
+#define _X_EXPORT __attribute__((visibility("default")))
+#define _X_HIDDEN __attribute__((visibility("hidden")))
+#define _X_INTERNAL __attribute__((visibility("internal")))
+#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550)
+#define _X_EXPORT __global
+#define _X_HIDDEN __hidden
+#define _X_INTERNAL __hidden
+#else /* not gcc >= 4 and not Sun Studio >= 8 */
+#define _X_EXPORT
+#define _X_HIDDEN
+#define _X_INTERNAL
+#endif /* GNUC >= 4 */
+
+/* requires xproto >= 7.0.9 */
+#if defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 303)
+#define _X_LIKELY(x) __builtin_expect(!!(x), 1)
+#define _X_UNLIKELY(x) __builtin_expect(!!(x), 0)
+#else /* not gcc >= 3.3 */
+#define _X_LIKELY(x) (x)
+#define _X_UNLIKELY(x) (x)
+#endif
+
+/* Added in X11R6.9, so available in any version of modular xproto */
+#if defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 301)
+#define _X_DEPRECATED __attribute__((deprecated))
+#else /* not gcc >= 3.1 */
+#define _X_DEPRECATED
+#endif
+
+/* requires xproto >= 7.0.17 */
+#if (defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 205)) || (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590))
+#define _X_NORETURN __attribute((noreturn))
+#else
+#define _X_NORETURN
+#endif /* GNUC  */
+
+/* Added in X11R6.9, so available in any version of modular xproto */
+#if defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 203)
+#define _X_ATTRIBUTE_PRINTF(x, y) __attribute__((__format__(__printf__, x, y)))
+#else /* not gcc >= 2.3 */
+#define _X_ATTRIBUTE_PRINTF(x, y)
+#endif
+
+/* requires xproto >= 7.0.22 - since this uses either gcc or C99 variable
+   argument macros, must be only used inside #ifdef _X_NONNULL guards, as
+   many legacy X clients are compiled in C89 mode still. */
+#if defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 303)
+#define _X_NONNULL(args...) __attribute__((nonnull(args)))
+#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ - 0 >= 199901L) /* C99 */
+#define _X_NONNULL(...)                                              /* */
+#endif
+
+/* requires xproto >= 7.0.22 */
+#if defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 205)
+#define _X_UNUSED __attribute__((__unused__))
+#else
+#define _X_UNUSED /* */
+#endif
+
+/* C99 keyword "inline" or equivalent extensions in pre-C99 compilers */
+/* requires xproto >= 7.0.9
+   (introduced in 7.0.8 but didn't support all compilers until 7.0.9) */
+#if defined(inline) /* assume autoconf set it correctly */ ||                     \
+	(defined(__STDC_VERSION__) && (__STDC_VERSION__ - 0 >= 199901L)) /* C99 */ || \
+	(defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550))
+#define _X_INLINE inline
+#elif defined(__GNUC__) && !defined(__STRICT_ANSI__) /* gcc w/C89+extensions */
+#define _X_INLINE __inline__
+#else
+#define _X_INLINE
+#endif
+
+/* C99 keyword "restrict" or equivalent extensions in pre-C99 compilers */
+/* requires xproto >= 7.0.21 */
+#ifndef _X_RESTRICT_KYWD
+#if defined(restrict) /* assume autoconf set it correctly */ ||               \
+	(defined(__STDC_VERSION__) && (__STDC_VERSION__ - 0 >= 199901L) /* C99 */ \
+	 && !defined(__cplusplus))                                      /* Workaround g++ issue on Solaris */
+#define _X_RESTRICT_KYWD restrict
+#elif defined(__GNUC__) && !defined(__STRICT_ANSI__) /* gcc w/C89+extensions */
+#define _X_RESTRICT_KYWD __restrict__
+#else
+#define _X_RESTRICT_KYWD
+#endif
+#endif
+
+#endif /* _XFUNCPROTO_H_ */
diff --git a/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/Xfuncs.h b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/Xfuncs.h
new file mode 100644
index 00000000..eef93a2d
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/Xfuncs.h
@@ -0,0 +1,69 @@
+/*
+ * 
+Copyright 1990, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+ *
+ */
+
+#ifndef _XFUNCS_H_
+#define _XFUNCS_H_
+
+#include <X11/Xosdefs.h>
+
+/* the old Xfuncs.h, for pre-R6 */
+#if !(defined(XFree86LOADER) && defined(IN_MODULE))
+
+#ifdef X_USEBFUNCS
+void bcopy();
+void bzero();
+int bcmp();
+#else
+#if defined(SYSV) && !defined(__SCO__) && !defined(__sun) && !defined(__UNIXWARE__)
+#include <memory.h>
+void bcopy();
+#define bzero(b, len) memset(b, 0, len)
+#define bcmp(b1, b2, len) memcmp(b1, b2, len)
+#else
+#include <string.h>
+#if defined(__SCO__) || defined(__sun) || defined(__UNIXWARE__) || defined(__CYGWIN__)
+#include <strings.h>
+#endif
+#define _XFUNCS_H_INCLUDED_STRING_H
+#endif
+#endif /* X_USEBFUNCS */
+
+/* the new Xfuncs.h */
+
+/* the ANSI C way */
+#ifndef _XFUNCS_H_INCLUDED_STRING_H
+#include <string.h>
+#endif
+#undef bzero
+#define bzero(b, len) memset(b, 0, len)
+
+#if defined WIN32 && defined __MINGW32__
+#define bcopy(b1, b2, len) memmove(b2, b1, (size_t)(len))
+#endif
+
+#endif /* !(defined(XFree86LOADER) && defined(IN_MODULE)) */
+
+#endif /* _XFUNCS_H_ */
diff --git a/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/Xlib.h b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/Xlib.h
new file mode 100644
index 00000000..3cd69177
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/Xlib.h
@@ -0,0 +1,4093 @@
+/*
+
+Copyright 1985, 1986, 1987, 1991, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+
+/*
+ *	Xlib.h - Header definition and support file for the C subroutine
+ *	interface library (Xlib) to the X Window System Protocol (V11).
+ *	Structures and symbols starting with "_" are private to the library.
+ */
+#ifndef _X11_XLIB_H_
+#define _X11_XLIB_H_
+
+#define XlibSpecificationRelease 6
+
+#include <sys/types.h>
+
+#if defined(__SCO__) || defined(__UNIXWARE__)
+#include <stdint.h>
+#endif
+
+#include <X11/X.h>
+
+/* applications should not depend on these two headers being included! */
+#include <X11/Xfuncproto.h>
+#include <X11/Xosdefs.h>
+
+#ifndef X_WCHAR
+#include <stddef.h>
+#else
+#ifdef __UNIXOS2__
+#include <stdlib.h>
+#else
+/* replace this with #include or typedef appropriate for your system */
+typedef unsigned long wchar_t;
+#endif
+#endif
+
+#if defined(ISC) && defined(USE_XMBTOWC)
+#define wctomb(a, b) _Xwctomb(a, b)
+#define mblen(a, b) _Xmblen(a, b)
+#ifndef USE_XWCHAR_STRING
+#define mbtowc(a, b, c) _Xmbtowc(a, b, c)
+#endif
+#endif
+
+extern int
+_Xmblen(
+#ifdef ISC
+	char const* str,
+	size_t len
+#else
+	char* str,
+	int len
+#endif
+);
+
+/* API mentioning "UTF8" or "utf8" is an XFree86 extension, introduced in
+   November 2000. Its presence is indicated through the following macro. */
+#define X_HAVE_UTF8_STRING 1
+
+/* The Xlib structs are full of implicit padding to properly align members.
+   We can't clean that up without breaking ABI, so tell clang not to bother
+   complaining about it. */
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+typedef char* XPointer;
+
+#define Bool int
+#define Status int
+#define True 1
+#define False 0
+
+#define QueuedAlready 0
+#define QueuedAfterReading 1
+#define QueuedAfterFlush 2
+
+#define ConnectionNumber(dpy) (((_XPrivDisplay)dpy)->fd)
+#define RootWindow(dpy, scr) (ScreenOfDisplay(dpy, scr)->root)
+#define DefaultScreen(dpy) (((_XPrivDisplay)dpy)->default_screen)
+#define DefaultRootWindow(dpy) (ScreenOfDisplay(dpy, DefaultScreen(dpy))->root)
+#define DefaultVisual(dpy, scr) (ScreenOfDisplay(dpy, scr)->root_visual)
+#define DefaultGC(dpy, scr) (ScreenOfDisplay(dpy, scr)->default_gc)
+#define BlackPixel(dpy, scr) (ScreenOfDisplay(dpy, scr)->black_pixel)
+#define WhitePixel(dpy, scr) (ScreenOfDisplay(dpy, scr)->white_pixel)
+#define AllPlanes ((unsigned long)~0L)
+#define QLength(dpy) (((_XPrivDisplay)dpy)->qlen)
+#define DisplayWidth(dpy, scr) (ScreenOfDisplay(dpy, scr)->width)
+#define DisplayHeight(dpy, scr) (ScreenOfDisplay(dpy, scr)->height)
+#define DisplayWidthMM(dpy, scr) (ScreenOfDisplay(dpy, scr)->mwidth)
+#define DisplayHeightMM(dpy, scr) (ScreenOfDisplay(dpy, scr)->mheight)
+#define DisplayPlanes(dpy, scr) (ScreenOfDisplay(dpy, scr)->root_depth)
+#define DisplayCells(dpy, scr) (DefaultVisual(dpy, scr)->map_entries)
+#define ScreenCount(dpy) (((_XPrivDisplay)dpy)->nscreens)
+#define ServerVendor(dpy) (((_XPrivDisplay)dpy)->vendor)
+#define ProtocolVersion(dpy) (((_XPrivDisplay)dpy)->proto_major_version)
+#define ProtocolRevision(dpy) (((_XPrivDisplay)dpy)->proto_minor_version)
+#define VendorRelease(dpy) (((_XPrivDisplay)dpy)->release)
+#define DisplayString(dpy) (((_XPrivDisplay)dpy)->display_name)
+#define DefaultDepth(dpy, scr) (ScreenOfDisplay(dpy, scr)->root_depth)
+#define DefaultColormap(dpy, scr) (ScreenOfDisplay(dpy, scr)->cmap)
+#define BitmapUnit(dpy) (((_XPrivDisplay)dpy)->bitmap_unit)
+#define BitmapBitOrder(dpy) (((_XPrivDisplay)dpy)->bitmap_bit_order)
+#define BitmapPad(dpy) (((_XPrivDisplay)dpy)->bitmap_pad)
+#define ImageByteOrder(dpy) (((_XPrivDisplay)dpy)->byte_order)
+#define NextRequest(dpy) (((_XPrivDisplay)dpy)->request + 1)
+#define LastKnownRequestProcessed(dpy) (((_XPrivDisplay)dpy)->last_request_read)
+
+/* macros for screen oriented applications (toolkit) */
+#define ScreenOfDisplay(dpy, scr) (&((_XPrivDisplay)dpy)->screens[scr])
+#define DefaultScreenOfDisplay(dpy) ScreenOfDisplay(dpy, DefaultScreen(dpy))
+#define DisplayOfScreen(s) ((s)->display)
+#define RootWindowOfScreen(s) ((s)->root)
+#define BlackPixelOfScreen(s) ((s)->black_pixel)
+#define WhitePixelOfScreen(s) ((s)->white_pixel)
+#define DefaultColormapOfScreen(s) ((s)->cmap)
+#define DefaultDepthOfScreen(s) ((s)->root_depth)
+#define DefaultGCOfScreen(s) ((s)->default_gc)
+#define DefaultVisualOfScreen(s) ((s)->root_visual)
+#define WidthOfScreen(s) ((s)->width)
+#define HeightOfScreen(s) ((s)->height)
+#define WidthMMOfScreen(s) ((s)->mwidth)
+#define HeightMMOfScreen(s) ((s)->mheight)
+#define PlanesOfScreen(s) ((s)->root_depth)
+#define CellsOfScreen(s) (DefaultVisualOfScreen((s))->map_entries)
+#define MinCmapsOfScreen(s) ((s)->min_maps)
+#define MaxCmapsOfScreen(s) ((s)->max_maps)
+#define DoesSaveUnders(s) ((s)->save_unders)
+#define DoesBackingStore(s) ((s)->backing_store)
+#define EventMaskOfScreen(s) ((s)->root_input_mask)
+
+/*
+ * Extensions need a way to hang private data on some structures.
+ */
+typedef struct _XExtData
+{
+	int number;             /* number returned by XRegisterExtension */
+	struct _XExtData* next; /* next item on list of data for structure */
+	int (*free_private)(    /* called to free private storage */
+						struct _XExtData* extension);
+	XPointer private_data; /* data private to this extension. */
+} XExtData;
+
+/*
+ * This file contains structures used by the extension mechanism.
+ */
+typedef struct
+{                     /* public to extension, cannot be changed */
+	int extension;    /* extension number */
+	int major_opcode; /* major op-code assigned by server */
+	int first_event;  /* first event number for the extension */
+	int first_error;  /* first error number for the extension */
+} XExtCodes;
+
+/*
+ * Data structure for retrieving info about pixmap formats.
+ */
+
+typedef struct
+{
+	int depth;
+	int bits_per_pixel;
+	int scanline_pad;
+} XPixmapFormatValues;
+
+/*
+ * Data structure for setting graphics context.
+ */
+typedef struct
+{
+	int function;             /* logical operation */
+	unsigned long plane_mask; /* plane mask */
+	unsigned long foreground; /* foreground pixel */
+	unsigned long background; /* background pixel */
+	int line_width;           /* line width */
+	int line_style;           /* LineSolid, LineOnOffDash, LineDoubleDash */
+	int cap_style;            /* CapNotLast, CapButt,
+				   CapRound, CapProjecting */
+	int join_style;           /* JoinMiter, JoinRound, JoinBevel */
+	int fill_style;           /* FillSolid, FillTiled,
+				   FillStippled, FillOpaeueStippled */
+	int fill_rule;            /* EvenOddRule, WindingRule */
+	int arc_mode;             /* ArcChord, ArcPieSlice */
+	Pixmap tile;              /* tile pixmap for tiling operations */
+	Pixmap stipple;           /* stipple 1 plane pixmap for stipping */
+	int ts_x_origin;          /* offset for tile or stipple operations */
+	int ts_y_origin;
+	Font font;               /* default text font for text operations */
+	int subwindow_mode;      /* ClipByChildren, IncludeInferiors */
+	Bool graphics_exposures; /* boolean, should exposures be generated */
+	int clip_x_origin;       /* origin for clipping */
+	int clip_y_origin;
+	Pixmap clip_mask; /* bitmap clipping; other calls for rects */
+	int dash_offset;  /* patterned/dashed line information */
+	char dashes;
+} XGCValues;
+
+/*
+ * Graphics context.  The contents of this structure are implementation
+ * dependent.  A GC should be treated as opaque by application code.
+ */
+
+typedef struct _XGC
+#ifdef XLIB_ILLEGAL_ACCESS
+{
+	XExtData* ext_data; /* hook for extension to hang data */
+	GContext gid;       /* protocol ID for graphics context */
+						/* there is more to this structure, but it is private to Xlib */
+}
+#endif
+	* GC;
+
+/*
+ * Visual structure; contains information about colormapping possible.
+ */
+typedef struct
+{
+	XExtData* ext_data; /* hook for extension to hang data */
+	VisualID visualid;  /* visual id of this visual */
+#if defined(__cplusplus) || defined(c_plusplus)
+	int c_class; /* C++ class of screen (monochrome, etc.) */
+#else
+	int class; /* class of screen (monochrome, etc.) */
+#endif
+	unsigned long red_mask, green_mask, blue_mask; /* mask values */
+	int bits_per_rgb;                              /* log base 2 of distinct color values */
+	int map_entries;                               /* color map entries */
+} Visual;
+
+/*
+ * Depth structure; contains information for each possible depth.
+ */
+typedef struct
+{
+	int depth;       /* this depth (Z) of the depth */
+	int nvisuals;    /* number of Visual types at this depth */
+	Visual* visuals; /* list of visuals possible at this depth */
+} Depth;
+
+/*
+ * Information about the screen.  The contents of this structure are
+ * implementation dependent.  A Screen should be treated as opaque
+ * by application code.
+ */
+
+struct _XDisplay; /* Forward declare before use for C++ */
+
+typedef struct
+{
+	XExtData* ext_data;        /* hook for extension to hang data */
+	struct _XDisplay* display; /* back pointer to display structure */
+	Window root;               /* Root window id. */
+	int width, height;         /* width and height of screen */
+	int mwidth, mheight;       /* width and height of  in millimeters */
+	int ndepths;               /* number of depths possible */
+	Depth* depths;             /* list of allowable depths on the screen */
+	int root_depth;            /* bits per pixel */
+	Visual* root_visual;       /* root visual */
+	GC default_gc;             /* GC for the root root visual */
+	Colormap cmap;             /* default color map */
+	unsigned long white_pixel;
+	unsigned long black_pixel; /* White and Black pixel values */
+	int max_maps, min_maps;    /* max and min color maps */
+	int backing_store;         /* Never, WhenMapped, Always */
+	Bool save_unders;
+	long root_input_mask; /* initial root input mask */
+} Screen;
+
+/*
+ * Format structure; describes ZFormat data the screen will understand.
+ */
+typedef struct
+{
+	XExtData* ext_data; /* hook for extension to hang data */
+	int depth;          /* depth of this image format */
+	int bits_per_pixel; /* bits/pixel at this depth */
+	int scanline_pad;   /* scanline must padded to this multiple */
+} ScreenFormat;
+
+/*
+ * Data structure for setting window attributes.
+ */
+typedef struct
+{
+	Pixmap background_pixmap;       /* background or None or ParentRelative */
+	unsigned long background_pixel; /* background pixel */
+	Pixmap border_pixmap;           /* border of the window */
+	unsigned long border_pixel;     /* border pixel value */
+	int bit_gravity;                /* one of bit gravity values */
+	int win_gravity;                /* one of the window gravity values */
+	int backing_store;              /* NotUseful, WhenMapped, Always */
+	unsigned long backing_planes;   /* planes to be preseved if possible */
+	unsigned long backing_pixel;    /* value to use in restoring planes */
+	Bool save_under;                /* should bits under be saved? (popups) */
+	long event_mask;                /* set of events that should be saved */
+	long do_not_propagate_mask;     /* set of events that should not propagate */
+	Bool override_redirect;         /* boolean value for override-redirect */
+	Colormap colormap;              /* color map to be associated with window */
+	Cursor cursor;                  /* cursor to be displayed (or None) */
+} XSetWindowAttributes;
+
+typedef struct
+{
+	int x, y;          /* location of window */
+	int width, height; /* width and height of window */
+	int border_width;  /* border width of window */
+	int depth;         /* depth of window */
+	Visual* visual;    /* the associated visual structure */
+	Window root;       /* root of screen containing window */
+#if defined(__cplusplus) || defined(c_plusplus)
+	int c_class; /* C++ InputOutput, InputOnly*/
+#else
+	int class; /* InputOutput, InputOnly*/
+#endif
+	int bit_gravity;              /* one of bit gravity values */
+	int win_gravity;              /* one of the window gravity values */
+	int backing_store;            /* NotUseful, WhenMapped, Always */
+	unsigned long backing_planes; /* planes to be preserved if possible */
+	unsigned long backing_pixel;  /* value to be used when restoring planes */
+	Bool save_under;              /* boolean, should bits under be saved? */
+	Colormap colormap;            /* color map to be associated with window */
+	Bool map_installed;           /* boolean, is color map currently installed*/
+	int map_state;                /* IsUnmapped, IsUnviewable, IsViewable */
+	long all_event_masks;         /* set of events all people have interest in*/
+	long your_event_mask;         /* my event mask */
+	long do_not_propagate_mask;   /* set of events that should not propagate */
+	Bool override_redirect;       /* boolean value for override-redirect */
+	Screen* screen;               /* back pointer to correct screen */
+} XWindowAttributes;
+
+/*
+ * Data structure for host setting; getting routines.
+ *
+ */
+
+typedef struct
+{
+	int family;    /* for example FamilyInternet */
+	int length;    /* length of address, in bytes */
+	char* address; /* pointer to where to find the bytes */
+} XHostAddress;
+
+/*
+ * Data structure for ServerFamilyInterpreted addresses in host routines
+ */
+typedef struct
+{
+	int typelength;  /* length of type string, in bytes */
+	int valuelength; /* length of value string, in bytes */
+	char* type;      /* pointer to where to find the type string */
+	char* value;     /* pointer to where to find the address */
+} XServerInterpretedAddress;
+
+/*
+ * Data structure for "image" data, used by image manipulation routines.
+ */
+typedef struct _XImage
+{
+	int width, height;      /* size of image */
+	int xoffset;            /* number of pixels offset in X direction */
+	int format;             /* XYBitmap, XYPixmap, ZPixmap */
+	char* data;             /* pointer to image data */
+	int byte_order;         /* data byte order, LSBFirst, MSBFirst */
+	int bitmap_unit;        /* quant. of scanline 8, 16, 32 */
+	int bitmap_bit_order;   /* LSBFirst, MSBFirst */
+	int bitmap_pad;         /* 8, 16, 32 either XY or ZPixmap */
+	int depth;              /* depth of image */
+	int bytes_per_line;     /* accelarator to next line */
+	int bits_per_pixel;     /* bits per pixel (ZPixmap) */
+	unsigned long red_mask; /* bits in z arrangment */
+	unsigned long green_mask;
+	unsigned long blue_mask;
+	XPointer obdata; /* hook for the object routines to hang on */
+	struct funcs
+	{ /* image manipulation routines */
+		struct _XImage* (*create_image)(
+			struct _XDisplay* /* display */,
+			Visual* /* visual */,
+			unsigned int /* depth */,
+			int /* format */,
+			int /* offset */,
+			char* /* data */,
+			unsigned int /* width */,
+			unsigned int /* height */,
+			int /* bitmap_pad */,
+			int /* bytes_per_line */);
+		int (*destroy_image)(struct _XImage*);
+		unsigned long (*get_pixel)(struct _XImage*, int, int);
+		int (*put_pixel)(struct _XImage*, int, int, unsigned long);
+		struct _XImage* (*sub_image)(struct _XImage*, int, int, unsigned int, unsigned int);
+		int (*add_pixel)(struct _XImage*, long);
+	} f;
+} XImage;
+
+/*
+ * Data structure for XReconfigureWindow
+ */
+typedef struct
+{
+	int x, y;
+	int width, height;
+	int border_width;
+	Window sibling;
+	int stack_mode;
+} XWindowChanges;
+
+/*
+ * Data structure used by color operations
+ */
+typedef struct
+{
+	unsigned long pixel;
+	unsigned short red, green, blue;
+	char flags; /* do_red, do_green, do_blue */
+	char pad;
+} XColor;
+
+/*
+ * Data structures for graphics operations.  On most machines, these are
+ * congruent with the wire protocol structures, so reformatting the data
+ * can be avoided on these architectures.
+ */
+typedef struct
+{
+	short x1, y1, x2, y2;
+} XSegment;
+
+typedef struct
+{
+	short x, y;
+} XPoint;
+
+typedef struct
+{
+	short x, y;
+	unsigned short width, height;
+} XRectangle;
+
+typedef struct
+{
+	short x, y;
+	unsigned short width, height;
+	short angle1, angle2;
+} XArc;
+
+/* Data structure for XChangeKeyboardControl */
+
+typedef struct
+{
+	int key_click_percent;
+	int bell_percent;
+	int bell_pitch;
+	int bell_duration;
+	int led;
+	int led_mode;
+	int key;
+	int auto_repeat_mode; /* On, Off, Default */
+} XKeyboardControl;
+
+/* Data structure for XGetKeyboardControl */
+
+typedef struct
+{
+	int key_click_percent;
+	int bell_percent;
+	unsigned int bell_pitch, bell_duration;
+	unsigned long led_mask;
+	int global_auto_repeat;
+	char auto_repeats[32];
+} XKeyboardState;
+
+/* Data structure for XGetMotionEvents.  */
+
+typedef struct
+{
+	Time time;
+	short x, y;
+} XTimeCoord;
+
+/* Data structure for X{Set,Get}ModifierMapping */
+
+typedef struct
+{
+	int max_keypermod;    /* The server's max # of keys per modifier */
+	KeyCode* modifiermap; /* An 8 by max_keypermod array of modifiers */
+} XModifierKeymap;
+
+/*
+ * Display datatype maintaining display specific data.
+ * The contents of this structure are implementation dependent.
+ * A Display should be treated as opaque by application code.
+ */
+#ifndef XLIB_ILLEGAL_ACCESS
+typedef struct _XDisplay Display;
+#endif
+
+struct _XPrivate; /* Forward declare before use for C++ */
+struct _XrmHashBucketRec;
+
+typedef struct
+#ifdef XLIB_ILLEGAL_ACCESS
+	_XDisplay
+#endif
+{
+	XExtData* ext_data; /* hook for extension to hang data */
+	struct _XPrivate* private1;
+	int fd; /* Network socket. */
+	int private2;
+	int proto_major_version; /* major version of server's X protocol */
+	int proto_minor_version; /* minor version of servers X protocol */
+	char* vendor;            /* vendor of the server hardware */
+	XID private3;
+	XID private4;
+	XID private5;
+	int private6;
+	XID(*resource_alloc)
+	(/* allocator function */
+	 struct _XDisplay*);
+	int byte_order;              /* screen byte order, LSBFirst, MSBFirst */
+	int bitmap_unit;             /* padding and data requirements */
+	int bitmap_pad;              /* padding requirements on bitmaps */
+	int bitmap_bit_order;        /* LeastSignificant or MostSignificant */
+	int nformats;                /* number of pixmap formats in list */
+	ScreenFormat* pixmap_format; /* pixmap format list */
+	int private8;
+	int release; /* release of the server */
+	struct _XPrivate *private9, *private10;
+	int qlen;                        /* Length of input event queue */
+	unsigned long last_request_read; /* seq number of last event read */
+	unsigned long request;           /* sequence number of last request. */
+	XPointer private11;
+	XPointer private12;
+	XPointer private13;
+	XPointer private14;
+	unsigned max_request_size; /* maximum number 32 bit words in request*/
+	struct _XrmHashBucketRec* db;
+	int (*private15)(
+		struct _XDisplay*);
+	char* display_name;          /* "host:display" string used on this connect*/
+	int default_screen;          /* default screen for operations */
+	int nscreens;                /* number of screens on this server*/
+	Screen* screens;             /* pointer to list of screens */
+	unsigned long motion_buffer; /* size of motion buffer */
+	unsigned long private16;
+	int min_keycode; /* minimum defined keycode */
+	int max_keycode; /* maximum defined keycode */
+	XPointer private17;
+	XPointer private18;
+	int private19;
+	char* xdefaults; /* contents of defaults from server */
+					 /* there is more to this structure, but it is private to Xlib */
+}
+#ifdef XLIB_ILLEGAL_ACCESS
+Display,
+#endif
+	*_XPrivDisplay;
+
+#undef _XEVENT_
+#ifndef _XEVENT_
+/*
+ * Definitions of specific events.
+ */
+typedef struct
+{
+	int type;             /* of event */
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came from a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Window window;        /* "event" window it is reported relative to */
+	Window root;          /* root window that the event occurred on */
+	Window subwindow;     /* child window */
+	Time time;            /* milliseconds */
+	int x, y;             /* pointer x, y coordinates in event window */
+	int x_root, y_root;   /* coordinates relative to root */
+	unsigned int state;   /* key or button mask */
+	unsigned int keycode; /* detail */
+	Bool same_screen;     /* same screen flag */
+} XKeyEvent;
+typedef XKeyEvent XKeyPressedEvent;
+typedef XKeyEvent XKeyReleasedEvent;
+
+typedef struct
+{
+	int type;             /* of event */
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came from a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Window window;        /* "event" window it is reported relative to */
+	Window root;          /* root window that the event occurred on */
+	Window subwindow;     /* child window */
+	Time time;            /* milliseconds */
+	int x, y;             /* pointer x, y coordinates in event window */
+	int x_root, y_root;   /* coordinates relative to root */
+	unsigned int state;   /* key or button mask */
+	unsigned int button;  /* detail */
+	Bool same_screen;     /* same screen flag */
+} XButtonEvent;
+typedef XButtonEvent XButtonPressedEvent;
+typedef XButtonEvent XButtonReleasedEvent;
+
+typedef struct
+{
+	int type;             /* of event */
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came from a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Window window;        /* "event" window reported relative to */
+	Window root;          /* root window that the event occurred on */
+	Window subwindow;     /* child window */
+	Time time;            /* milliseconds */
+	int x, y;             /* pointer x, y coordinates in event window */
+	int x_root, y_root;   /* coordinates relative to root */
+	unsigned int state;   /* key or button mask */
+	char is_hint;         /* detail */
+	Bool same_screen;     /* same screen flag */
+} XMotionEvent;
+typedef XMotionEvent XPointerMovedEvent;
+
+typedef struct
+{
+	int type;             /* of event */
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came from a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Window window;        /* "event" window reported relative to */
+	Window root;          /* root window that the event occurred on */
+	Window subwindow;     /* child window */
+	Time time;            /* milliseconds */
+	int x, y;             /* pointer x, y coordinates in event window */
+	int x_root, y_root;   /* coordinates relative to root */
+	int mode;             /* NotifyNormal, NotifyGrab, NotifyUngrab */
+	int detail;
+	/*
+	 * NotifyAncestor, NotifyVirtual, NotifyInferior,
+	 * NotifyNonlinear,NotifyNonlinearVirtual
+	 */
+	Bool same_screen;   /* same screen flag */
+	Bool focus;         /* boolean focus */
+	unsigned int state; /* key or button mask */
+} XCrossingEvent;
+typedef XCrossingEvent XEnterWindowEvent;
+typedef XCrossingEvent XLeaveWindowEvent;
+
+typedef struct
+{
+	int type;             /* FocusIn or FocusOut */
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came from a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Window window;        /* window of event */
+	int mode;             /* NotifyNormal, NotifyWhileGrabbed,
+				   NotifyGrab, NotifyUngrab */
+	int detail;
+	/*
+	 * NotifyAncestor, NotifyVirtual, NotifyInferior,
+	 * NotifyNonlinear,NotifyNonlinearVirtual, NotifyPointer,
+	 * NotifyPointerRoot, NotifyDetailNone
+	 */
+} XFocusChangeEvent;
+typedef XFocusChangeEvent XFocusInEvent;
+typedef XFocusChangeEvent XFocusOutEvent;
+
+/* generated on EnterWindow and FocusIn  when KeyMapState selected */
+typedef struct
+{
+	int type;
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came from a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Window window;
+	char key_vector[32];
+} XKeymapEvent;
+
+typedef struct
+{
+	int type;
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came from a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Window window;
+	int x, y;
+	int width, height;
+	int count; /* if non-zero, at least this many more */
+} XExposeEvent;
+
+typedef struct
+{
+	int type;
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came from a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Drawable drawable;
+	int x, y;
+	int width, height;
+	int count;      /* if non-zero, at least this many more */
+	int major_code; /* core is CopyArea or CopyPlane */
+	int minor_code; /* not defined in the core */
+} XGraphicsExposeEvent;
+
+typedef struct
+{
+	int type;
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came from a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Drawable drawable;
+	int major_code; /* core is CopyArea or CopyPlane */
+	int minor_code; /* not defined in the core */
+} XNoExposeEvent;
+
+typedef struct
+{
+	int type;
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came from a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Window window;
+	int state; /* Visibility state */
+} XVisibilityEvent;
+
+typedef struct
+{
+	int type;
+	unsigned long serial;   /* # of last request processed by server */
+	Bool send_event;        /* true if this came from a SendEvent request */
+	Display* display;       /* Display the event was read from */
+	Window parent;          /* parent of the window */
+	Window window;          /* window id of window created */
+	int x, y;               /* window location */
+	int width, height;      /* size of window */
+	int border_width;       /* border width */
+	Bool override_redirect; /* creation should be overridden */
+} XCreateWindowEvent;
+
+typedef struct
+{
+	int type;
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came from a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Window event;
+	Window window;
+} XDestroyWindowEvent;
+
+typedef struct
+{
+	int type;
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came from a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Window event;
+	Window window;
+	Bool from_configure;
+} XUnmapEvent;
+
+typedef struct
+{
+	int type;
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came from a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Window event;
+	Window window;
+	Bool override_redirect; /* boolean, is override set... */
+} XMapEvent;
+
+typedef struct
+{
+	int type;
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came from a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Window parent;
+	Window window;
+} XMapRequestEvent;
+
+typedef struct
+{
+	int type;
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came from a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Window event;
+	Window window;
+	Window parent;
+	int x, y;
+	Bool override_redirect;
+} XReparentEvent;
+
+typedef struct
+{
+	int type;
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came from a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Window event;
+	Window window;
+	int x, y;
+	int width, height;
+	int border_width;
+	Window above;
+	Bool override_redirect;
+} XConfigureEvent;
+
+typedef struct
+{
+	int type;
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came from a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Window event;
+	Window window;
+	int x, y;
+} XGravityEvent;
+
+typedef struct
+{
+	int type;
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came from a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Window window;
+	int width, height;
+} XResizeRequestEvent;
+
+typedef struct
+{
+	int type;
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came from a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Window parent;
+	Window window;
+	int x, y;
+	int width, height;
+	int border_width;
+	Window above;
+	int detail; /* Above, Below, TopIf, BottomIf, Opposite */
+	unsigned long value_mask;
+} XConfigureRequestEvent;
+
+typedef struct
+{
+	int type;
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came from a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Window event;
+	Window window;
+	int place; /* PlaceOnTop, PlaceOnBottom */
+} XCirculateEvent;
+
+typedef struct
+{
+	int type;
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came from a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Window parent;
+	Window window;
+	int place; /* PlaceOnTop, PlaceOnBottom */
+} XCirculateRequestEvent;
+
+typedef struct
+{
+	int type;
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came from a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Window window;
+	Atom atom;
+	Time time;
+	int state; /* NewValue, Deleted */
+} XPropertyEvent;
+
+typedef struct
+{
+	int type;
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came from a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Window window;
+	Atom selection;
+	Time time;
+} XSelectionClearEvent;
+
+typedef struct
+{
+	int type;
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came from a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Window owner;
+	Window requestor;
+	Atom selection;
+	Atom target;
+	Atom property;
+	Time time;
+} XSelectionRequestEvent;
+
+typedef struct
+{
+	int type;
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came from a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Window requestor;
+	Atom selection;
+	Atom target;
+	Atom property; /* ATOM or None */
+	Time time;
+} XSelectionEvent;
+
+typedef struct
+{
+	int type;
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came from a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Window window;
+	Colormap colormap; /* COLORMAP or None */
+#if defined(__cplusplus) || defined(c_plusplus)
+	Bool c_new; /* C++ */
+#else
+	Bool new;
+#endif
+	int state; /* ColormapInstalled, ColormapUninstalled */
+} XColormapEvent;
+
+typedef struct
+{
+	int type;
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came from a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Window window;
+	Atom message_type;
+	int format;
+	union {
+		char b[20];
+		short s[10];
+		long l[5];
+	} data;
+} XClientMessageEvent;
+
+typedef struct
+{
+	int type;
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came from a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Window window;        /* unused */
+	int request;          /* one of MappingModifier, MappingKeyboard,
+				   MappingPointer */
+	int first_keycode;    /* first keycode */
+	int count;            /* defines range of change w. first_keycode*/
+} XMappingEvent;
+
+typedef struct
+{
+	int type;
+	Display* display;           /* Display the event was read from */
+	XID resourceid;             /* resource id */
+	unsigned long serial;       /* serial number of failed request */
+	unsigned char error_code;   /* error code of failed request */
+	unsigned char request_code; /* Major op-code of failed request */
+	unsigned char minor_code;   /* Minor op-code of failed request */
+} XErrorEvent;
+
+typedef struct
+{
+	int type;
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came from a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Window window;        /* window on which event was requested in event mask */
+} XAnyEvent;
+
+/***************************************************************
+ *
+ * GenericEvent.  This event is the standard event for all newer extensions.
+ */
+
+typedef struct
+{
+	int type;             /* of event. Always GenericEvent */
+	unsigned long serial; /* # of last request processed */
+	Bool send_event;      /* true if from SendEvent request */
+	Display* display;     /* Display the event was read from */
+	int extension;        /* major opcode of extension that caused the event */
+	int evtype;           /* actual event type. */
+} XGenericEvent;
+
+typedef struct
+{
+	int type;             /* of event. Always GenericEvent */
+	unsigned long serial; /* # of last request processed */
+	Bool send_event;      /* true if from SendEvent request */
+	Display* display;     /* Display the event was read from */
+	int extension;        /* major opcode of extension that caused the event */
+	int evtype;           /* actual event type. */
+	unsigned int cookie;
+	void* data;
+} XGenericEventCookie;
+
+/*
+ * this union is defined so Xlib can always use the same sized
+ * event structure internally, to avoid memory fragmentation.
+ */
+typedef union _XEvent {
+	int type; /* must not be changed; first element */
+	XAnyEvent xany;
+	XKeyEvent xkey;
+	XButtonEvent xbutton;
+	XMotionEvent xmotion;
+	XCrossingEvent xcrossing;
+	XFocusChangeEvent xfocus;
+	XExposeEvent xexpose;
+	XGraphicsExposeEvent xgraphicsexpose;
+	XNoExposeEvent xnoexpose;
+	XVisibilityEvent xvisibility;
+	XCreateWindowEvent xcreatewindow;
+	XDestroyWindowEvent xdestroywindow;
+	XUnmapEvent xunmap;
+	XMapEvent xmap;
+	XMapRequestEvent xmaprequest;
+	XReparentEvent xreparent;
+	XConfigureEvent xconfigure;
+	XGravityEvent xgravity;
+	XResizeRequestEvent xresizerequest;
+	XConfigureRequestEvent xconfigurerequest;
+	XCirculateEvent xcirculate;
+	XCirculateRequestEvent xcirculaterequest;
+	XPropertyEvent xproperty;
+	XSelectionClearEvent xselectionclear;
+	XSelectionRequestEvent xselectionrequest;
+	XSelectionEvent xselection;
+	XColormapEvent xcolormap;
+	XClientMessageEvent xclient;
+	XMappingEvent xmapping;
+	XErrorEvent xerror;
+	XKeymapEvent xkeymap;
+	XGenericEvent xgeneric;
+	XGenericEventCookie xcookie;
+	long pad[24];
+} XEvent;
+#endif
+
+#define XAllocID(dpy) ((*((_XPrivDisplay)dpy)->resource_alloc)((dpy)))
+
+/*
+ * per character font metric information.
+ */
+typedef struct
+{
+	short lbearing;            /* origin to left edge of raster */
+	short rbearing;            /* origin to right edge of raster */
+	short width;               /* advance to next char's origin */
+	short ascent;              /* baseline to top edge of raster */
+	short descent;             /* baseline to bottom edge of raster */
+	unsigned short attributes; /* per char flags (not predefined) */
+} XCharStruct;
+
+/*
+ * To allow arbitrary information with fonts, there are additional properties
+ * returned.
+ */
+typedef struct
+{
+	Atom name;
+	unsigned long card32;
+} XFontProp;
+
+typedef struct
+{
+	XExtData* ext_data;         /* hook for extension to hang data */
+	Font fid;                   /* Font id for this font */
+	unsigned direction;         /* hint about direction the font is painted */
+	unsigned min_char_or_byte2; /* first character */
+	unsigned max_char_or_byte2; /* last character */
+	unsigned min_byte1;         /* first row that exists */
+	unsigned max_byte1;         /* last row that exists */
+	Bool all_chars_exist;       /* flag if all characters have non-zero size*/
+	unsigned default_char;      /* char to print for undefined character */
+	int n_properties;           /* how many properties there are */
+	XFontProp* properties;      /* pointer to array of additional properties*/
+	XCharStruct min_bounds;     /* minimum bounds over all existing char*/
+	XCharStruct max_bounds;     /* maximum bounds over all existing char*/
+	XCharStruct* per_char;      /* first_char to last_char information */
+	int ascent;                 /* log. extent above baseline for spacing */
+	int descent;                /* log. descent below baseline for spacing */
+} XFontStruct;
+
+/*
+ * PolyText routines take these as arguments.
+ */
+typedef struct
+{
+	char* chars; /* pointer to string */
+	int nchars;  /* number of characters */
+	int delta;   /* delta between strings */
+	Font font;   /* font to print it in, None don't change */
+} XTextItem;
+
+typedef struct
+{ /* normal 16 bit characters are two bytes */
+	unsigned char byte1;
+	unsigned char byte2;
+} XChar2b;
+
+typedef struct
+{
+	XChar2b* chars; /* two byte characters */
+	int nchars;     /* number of characters */
+	int delta;      /* delta between strings */
+	Font font;      /* font to print it in, None don't change */
+} XTextItem16;
+
+typedef union {
+	Display* display;
+	GC gc;
+	Visual* visual;
+	Screen* screen;
+	ScreenFormat* pixmap_format;
+	XFontStruct* font;
+} XEDataObject;
+
+typedef struct
+{
+	XRectangle max_ink_extent;
+	XRectangle max_logical_extent;
+} XFontSetExtents;
+
+/* unused:
+typedef void (*XOMProc)();
+ */
+
+typedef struct _XOM* XOM;
+typedef struct _XOC *XOC, *XFontSet;
+
+typedef struct
+{
+	char* chars;
+	int nchars;
+	int delta;
+	XFontSet font_set;
+} XmbTextItem;
+
+typedef struct
+{
+	wchar_t* chars;
+	int nchars;
+	int delta;
+	XFontSet font_set;
+} XwcTextItem;
+
+#define XNRequiredCharSet "requiredCharSet"
+#define XNQueryOrientation "queryOrientation"
+#define XNBaseFontName "baseFontName"
+#define XNOMAutomatic "omAutomatic"
+#define XNMissingCharSet "missingCharSet"
+#define XNDefaultString "defaultString"
+#define XNOrientation "orientation"
+#define XNDirectionalDependentDrawing "directionalDependentDrawing"
+#define XNContextualDrawing "contextualDrawing"
+#define XNFontInfo "fontInfo"
+
+typedef struct
+{
+	int charset_count;
+	char** charset_list;
+} XOMCharSetList;
+
+typedef enum
+{
+	XOMOrientation_LTR_TTB,
+	XOMOrientation_RTL_TTB,
+	XOMOrientation_TTB_LTR,
+	XOMOrientation_TTB_RTL,
+	XOMOrientation_Context
+} XOrientation;
+
+typedef struct
+{
+	int num_orientation;
+	XOrientation* orientation; /* Input Text description */
+} XOMOrientation;
+
+typedef struct
+{
+	int num_font;
+	XFontStruct** font_struct_list;
+	char** font_name_list;
+} XOMFontInfo;
+
+typedef struct _XIM* XIM;
+typedef struct _XIC* XIC;
+
+typedef void (*XIMProc)(
+	XIM,
+	XPointer,
+	XPointer);
+
+typedef Bool (*XICProc)(
+	XIC,
+	XPointer,
+	XPointer);
+
+typedef void (*XIDProc)(
+	Display*,
+	XPointer,
+	XPointer);
+
+typedef unsigned long XIMStyle;
+
+typedef struct
+{
+	unsigned short count_styles;
+	XIMStyle* supported_styles;
+} XIMStyles;
+
+#define XIMPreeditArea 0x0001L
+#define XIMPreeditCallbacks 0x0002L
+#define XIMPreeditPosition 0x0004L
+#define XIMPreeditNothing 0x0008L
+#define XIMPreeditNone 0x0010L
+#define XIMStatusArea 0x0100L
+#define XIMStatusCallbacks 0x0200L
+#define XIMStatusNothing 0x0400L
+#define XIMStatusNone 0x0800L
+
+#define XNVaNestedList "XNVaNestedList"
+#define XNQueryInputStyle "queryInputStyle"
+#define XNClientWindow "clientWindow"
+#define XNInputStyle "inputStyle"
+#define XNFocusWindow "focusWindow"
+#define XNResourceName "resourceName"
+#define XNResourceClass "resourceClass"
+#define XNGeometryCallback "geometryCallback"
+#define XNDestroyCallback "destroyCallback"
+#define XNFilterEvents "filterEvents"
+#define XNPreeditStartCallback "preeditStartCallback"
+#define XNPreeditDoneCallback "preeditDoneCallback"
+#define XNPreeditDrawCallback "preeditDrawCallback"
+#define XNPreeditCaretCallback "preeditCaretCallback"
+#define XNPreeditStateNotifyCallback "preeditStateNotifyCallback"
+#define XNPreeditAttributes "preeditAttributes"
+#define XNStatusStartCallback "statusStartCallback"
+#define XNStatusDoneCallback "statusDoneCallback"
+#define XNStatusDrawCallback "statusDrawCallback"
+#define XNStatusAttributes "statusAttributes"
+#define XNArea "area"
+#define XNAreaNeeded "areaNeeded"
+#define XNSpotLocation "spotLocation"
+#define XNColormap "colorMap"
+#define XNStdColormap "stdColorMap"
+#define XNForeground "foreground"
+#define XNBackground "background"
+#define XNBackgroundPixmap "backgroundPixmap"
+#define XNFontSet "fontSet"
+#define XNLineSpace "lineSpace"
+#define XNCursor "cursor"
+
+#define XNQueryIMValuesList "queryIMValuesList"
+#define XNQueryICValuesList "queryICValuesList"
+#define XNVisiblePosition "visiblePosition"
+#define XNR6PreeditCallback "r6PreeditCallback"
+#define XNStringConversionCallback "stringConversionCallback"
+#define XNStringConversion "stringConversion"
+#define XNResetState "resetState"
+#define XNHotKey "hotKey"
+#define XNHotKeyState "hotKeyState"
+#define XNPreeditState "preeditState"
+#define XNSeparatorofNestedList "separatorofNestedList"
+
+#define XBufferOverflow -1
+#define XLookupNone 1
+#define XLookupChars 2
+#define XLookupKeySym 3
+#define XLookupBoth 4
+
+typedef void* XVaNestedList;
+
+typedef struct
+{
+	XPointer client_data;
+	XIMProc callback;
+} XIMCallback;
+
+typedef struct
+{
+	XPointer client_data;
+	XICProc callback;
+} XICCallback;
+
+typedef unsigned long XIMFeedback;
+
+#define XIMReverse 1L
+#define XIMUnderline (1L << 1)
+#define XIMHighlight (1L << 2)
+#define XIMPrimary (1L << 5)
+#define XIMSecondary (1L << 6)
+#define XIMTertiary (1L << 7)
+#define XIMVisibleToForward (1L << 8)
+#define XIMVisibleToBackword (1L << 9)
+#define XIMVisibleToCenter (1L << 10)
+
+typedef struct _XIMText
+{
+	unsigned short length;
+	XIMFeedback* feedback;
+	Bool encoding_is_wchar;
+	union {
+		char* multi_byte;
+		wchar_t* wide_char;
+	} string;
+} XIMText;
+
+typedef unsigned long XIMPreeditState;
+
+#define XIMPreeditUnKnown 0L
+#define XIMPreeditEnable 1L
+#define XIMPreeditDisable (1L << 1)
+
+typedef struct _XIMPreeditStateNotifyCallbackStruct
+{
+	XIMPreeditState state;
+} XIMPreeditStateNotifyCallbackStruct;
+
+typedef unsigned long XIMResetState;
+
+#define XIMInitialState 1L
+#define XIMPreserveState (1L << 1)
+
+typedef unsigned long XIMStringConversionFeedback;
+
+#define XIMStringConversionLeftEdge (0x00000001)
+#define XIMStringConversionRightEdge (0x00000002)
+#define XIMStringConversionTopEdge (0x00000004)
+#define XIMStringConversionBottomEdge (0x00000008)
+#define XIMStringConversionConcealed (0x00000010)
+#define XIMStringConversionWrapped (0x00000020)
+
+typedef struct _XIMStringConversionText
+{
+	unsigned short length;
+	XIMStringConversionFeedback* feedback;
+	Bool encoding_is_wchar;
+	union {
+		char* mbs;
+		wchar_t* wcs;
+	} string;
+} XIMStringConversionText;
+
+typedef unsigned short XIMStringConversionPosition;
+
+typedef unsigned short XIMStringConversionType;
+
+#define XIMStringConversionBuffer (0x0001)
+#define XIMStringConversionLine (0x0002)
+#define XIMStringConversionWord (0x0003)
+#define XIMStringConversionChar (0x0004)
+
+typedef unsigned short XIMStringConversionOperation;
+
+#define XIMStringConversionSubstitution (0x0001)
+#define XIMStringConversionRetrieval (0x0002)
+
+typedef enum
+{
+	XIMForwardChar,
+	XIMBackwardChar,
+	XIMForwardWord,
+	XIMBackwardWord,
+	XIMCaretUp,
+	XIMCaretDown,
+	XIMNextLine,
+	XIMPreviousLine,
+	XIMLineStart,
+	XIMLineEnd,
+	XIMAbsolutePosition,
+	XIMDontChange
+} XIMCaretDirection;
+
+typedef struct _XIMStringConversionCallbackStruct
+{
+	XIMStringConversionPosition position;
+	XIMCaretDirection direction;
+	XIMStringConversionOperation operation;
+	unsigned short factor;
+	XIMStringConversionText* text;
+} XIMStringConversionCallbackStruct;
+
+typedef struct _XIMPreeditDrawCallbackStruct
+{
+	int caret;      /* Cursor offset within pre-edit string */
+	int chg_first;  /* Starting change position */
+	int chg_length; /* Length of the change in character count */
+	XIMText* text;
+} XIMPreeditDrawCallbackStruct;
+
+typedef enum
+{
+	XIMIsInvisible, /* Disable caret feedback */
+	XIMIsPrimary,   /* UI defined caret feedback */
+	XIMIsSecondary  /* UI defined caret feedback */
+} XIMCaretStyle;
+
+typedef struct _XIMPreeditCaretCallbackStruct
+{
+	int position;                /* Caret offset within pre-edit string */
+	XIMCaretDirection direction; /* Caret moves direction */
+	XIMCaretStyle style;         /* Feedback of the caret */
+} XIMPreeditCaretCallbackStruct;
+
+typedef enum
+{
+	XIMTextType,
+	XIMBitmapType
+} XIMStatusDataType;
+
+typedef struct _XIMStatusDrawCallbackStruct
+{
+	XIMStatusDataType type;
+	union {
+		XIMText* text;
+		Pixmap bitmap;
+	} data;
+} XIMStatusDrawCallbackStruct;
+
+typedef struct _XIMHotKeyTrigger
+{
+	KeySym keysym;
+	int modifier;
+	int modifier_mask;
+} XIMHotKeyTrigger;
+
+typedef struct _XIMHotKeyTriggers
+{
+	int num_hot_key;
+	XIMHotKeyTrigger* key;
+} XIMHotKeyTriggers;
+
+typedef unsigned long XIMHotKeyState;
+
+#define XIMHotKeyStateON (0x0001L)
+#define XIMHotKeyStateOFF (0x0002L)
+
+typedef struct
+{
+	unsigned short count_values;
+	char** supported_values;
+} XIMValuesList;
+
+_XFUNCPROTOBEGIN
+
+#if defined(WIN32) && !defined(_XLIBINT_)
+#define _Xdebug (*_Xdebug_p)
+#endif
+
+extern int _Xdebug;
+
+extern XFontStruct* XLoadQueryFont(
+	Display* /* display */,
+	_Xconst char* /* name */
+);
+
+extern XFontStruct* XQueryFont(
+	Display* /* display */,
+	XID /* font_ID */
+);
+
+extern XTimeCoord* XGetMotionEvents(
+	Display* /* display */,
+	Window /* w */,
+	Time /* start */,
+	Time /* stop */,
+	int* /* nevents_return */
+);
+
+extern XModifierKeymap* XDeleteModifiermapEntry(
+	XModifierKeymap* /* modmap */,
+#if NeedWidePrototypes
+	unsigned int /* keycode_entry */,
+#else
+	KeyCode /* keycode_entry */,
+#endif
+	int /* modifier */
+);
+
+extern XModifierKeymap* XGetModifierMapping(
+	Display* /* display */
+);
+
+extern XModifierKeymap* XInsertModifiermapEntry(
+	XModifierKeymap* /* modmap */,
+#if NeedWidePrototypes
+	unsigned int /* keycode_entry */,
+#else
+	KeyCode /* keycode_entry */,
+#endif
+	int /* modifier */
+);
+
+extern XModifierKeymap* XNewModifiermap(
+	int /* max_keys_per_mod */
+);
+
+extern XImage* XCreateImage(
+	Display* /* display */,
+	Visual* /* visual */,
+	unsigned int /* depth */,
+	int /* format */,
+	int /* offset */,
+	char* /* data */,
+	unsigned int /* width */,
+	unsigned int /* height */,
+	int /* bitmap_pad */,
+	int /* bytes_per_line */
+);
+extern Status XInitImage(
+	XImage* /* image */
+);
+extern XImage* XGetImage(
+	Display* /* display */,
+	Drawable /* d */,
+	int /* x */,
+	int /* y */,
+	unsigned int /* width */,
+	unsigned int /* height */,
+	unsigned long /* plane_mask */,
+	int /* format */
+);
+extern XImage* XGetSubImage(
+	Display* /* display */,
+	Drawable /* d */,
+	int /* x */,
+	int /* y */,
+	unsigned int /* width */,
+	unsigned int /* height */,
+	unsigned long /* plane_mask */,
+	int /* format */,
+	XImage* /* dest_image */,
+	int /* dest_x */,
+	int /* dest_y */
+);
+
+/*
+ * X function declarations.
+ */
+extern Display* XOpenDisplay(
+	_Xconst char* /* display_name */
+);
+
+extern void XrmInitialize(
+	void);
+
+extern char* XFetchBytes(
+	Display* /* display */,
+	int* /* nbytes_return */
+);
+extern char* XFetchBuffer(
+	Display* /* display */,
+	int* /* nbytes_return */,
+	int /* buffer */
+);
+extern char* XGetAtomName(
+	Display* /* display */,
+	Atom /* atom */
+);
+extern Status XGetAtomNames(
+	Display* /* dpy */,
+	Atom* /* atoms */,
+	int /* count */,
+	char** /* names_return */
+);
+extern char* XGetDefault(
+	Display* /* display */,
+	_Xconst char* /* program */,
+	_Xconst char* /* option */
+);
+extern char* XDisplayName(
+	_Xconst char* /* string */
+);
+extern char* XKeysymToString(
+	KeySym /* keysym */
+);
+
+extern int (*XSynchronize(
+	Display* /* display */,
+	Bool /* onoff */
+	))(
+	Display* /* display */
+);
+extern int (*XSetAfterFunction(
+	Display* /* display */,
+	int (*)(
+		Display* /* display */
+		)        /* procedure */
+	))(
+	Display* /* display */
+);
+extern Atom XInternAtom(
+	Display* /* display */,
+	_Xconst char* /* atom_name */,
+	Bool /* only_if_exists */
+);
+extern Status XInternAtoms(
+	Display* /* dpy */,
+	char** /* names */,
+	int /* count */,
+	Bool /* onlyIfExists */,
+	Atom* /* atoms_return */
+);
+extern Colormap XCopyColormapAndFree(
+	Display* /* display */,
+	Colormap /* colormap */
+);
+extern Colormap XCreateColormap(
+	Display* /* display */,
+	Window /* w */,
+	Visual* /* visual */,
+	int /* alloc */
+);
+extern Cursor XCreatePixmapCursor(
+	Display* /* display */,
+	Pixmap /* source */,
+	Pixmap /* mask */,
+	XColor* /* foreground_color */,
+	XColor* /* background_color */,
+	unsigned int /* x */,
+	unsigned int /* y */
+);
+extern Cursor XCreateGlyphCursor(
+	Display* /* display */,
+	Font /* source_font */,
+	Font /* mask_font */,
+	unsigned int /* source_char */,
+	unsigned int /* mask_char */,
+	XColor _Xconst* /* foreground_color */,
+	XColor _Xconst* /* background_color */
+);
+extern Cursor XCreateFontCursor(
+	Display* /* display */,
+	unsigned int /* shape */
+);
+extern Font XLoadFont(
+	Display* /* display */,
+	_Xconst char* /* name */
+);
+extern GC XCreateGC(
+	Display* /* display */,
+	Drawable /* d */,
+	unsigned long /* valuemask */,
+	XGCValues* /* values */
+);
+extern GContext XGContextFromGC(
+	GC /* gc */
+);
+extern void XFlushGC(
+	Display* /* display */,
+	GC /* gc */
+);
+extern Pixmap XCreatePixmap(
+	Display* /* display */,
+	Drawable /* d */,
+	unsigned int /* width */,
+	unsigned int /* height */,
+	unsigned int /* depth */
+);
+extern Pixmap XCreateBitmapFromData(
+	Display* /* display */,
+	Drawable /* d */,
+	_Xconst char* /* data */,
+	unsigned int /* width */,
+	unsigned int /* height */
+);
+extern Pixmap XCreatePixmapFromBitmapData(
+	Display* /* display */,
+	Drawable /* d */,
+	char* /* data */,
+	unsigned int /* width */,
+	unsigned int /* height */,
+	unsigned long /* fg */,
+	unsigned long /* bg */,
+	unsigned int /* depth */
+);
+extern Window XCreateSimpleWindow(
+	Display* /* display */,
+	Window /* parent */,
+	int /* x */,
+	int /* y */,
+	unsigned int /* width */,
+	unsigned int /* height */,
+	unsigned int /* border_width */,
+	unsigned long /* border */,
+	unsigned long /* background */
+);
+extern Window XGetSelectionOwner(
+	Display* /* display */,
+	Atom /* selection */
+);
+extern Window XCreateWindow(
+	Display* /* display */,
+	Window /* parent */,
+	int /* x */,
+	int /* y */,
+	unsigned int /* width */,
+	unsigned int /* height */,
+	unsigned int /* border_width */,
+	int /* depth */,
+	unsigned int /* class */,
+	Visual* /* visual */,
+	unsigned long /* valuemask */,
+	XSetWindowAttributes* /* attributes */
+);
+extern Colormap* XListInstalledColormaps(
+	Display* /* display */,
+	Window /* w */,
+	int* /* num_return */
+);
+extern char** XListFonts(
+	Display* /* display */,
+	_Xconst char* /* pattern */,
+	int /* maxnames */,
+	int* /* actual_count_return */
+);
+extern char** XListFontsWithInfo(
+	Display* /* display */,
+	_Xconst char* /* pattern */,
+	int /* maxnames */,
+	int* /* count_return */,
+	XFontStruct** /* info_return */
+);
+extern char** XGetFontPath(
+	Display* /* display */,
+	int* /* npaths_return */
+);
+extern char** XListExtensions(
+	Display* /* display */,
+	int* /* nextensions_return */
+);
+extern Atom* XListProperties(
+	Display* /* display */,
+	Window /* w */,
+	int* /* num_prop_return */
+);
+extern XHostAddress* XListHosts(
+	Display* /* display */,
+	int* /* nhosts_return */,
+	Bool* /* state_return */
+);
+_X_DEPRECATED
+extern KeySym XKeycodeToKeysym(
+	Display* /* display */,
+#if NeedWidePrototypes
+	unsigned int /* keycode */,
+#else
+	KeyCode /* keycode */,
+#endif
+	int /* index */
+);
+extern KeySym XLookupKeysym(
+	XKeyEvent* /* key_event */,
+	int /* index */
+);
+extern KeySym* XGetKeyboardMapping(
+	Display* /* display */,
+#if NeedWidePrototypes
+	unsigned int /* first_keycode */,
+#else
+	KeyCode /* first_keycode */,
+#endif
+	int /* keycode_count */,
+	int* /* keysyms_per_keycode_return */
+);
+extern KeySym XStringToKeysym(
+	_Xconst char* /* string */
+);
+extern long XMaxRequestSize(
+	Display* /* display */
+);
+extern long XExtendedMaxRequestSize(
+	Display* /* display */
+);
+extern char* XResourceManagerString(
+	Display* /* display */
+);
+extern char* XScreenResourceString(
+	Screen* /* screen */
+);
+extern unsigned long XDisplayMotionBufferSize(
+	Display* /* display */
+);
+extern VisualID XVisualIDFromVisual(
+	Visual* /* visual */
+);
+
+/* multithread routines */
+
+extern Status XInitThreads(
+	void);
+
+extern void XLockDisplay(
+	Display* /* display */
+);
+
+extern void XUnlockDisplay(
+	Display* /* display */
+);
+
+/* routines for dealing with extensions */
+
+extern XExtCodes* XInitExtension(
+	Display* /* display */,
+	_Xconst char* /* name */
+);
+
+extern XExtCodes* XAddExtension(
+	Display* /* display */
+);
+extern XExtData* XFindOnExtensionList(
+	XExtData** /* structure */,
+	int /* number */
+);
+extern XExtData** XEHeadOfExtensionList(
+	XEDataObject /* object */
+);
+
+/* these are routines for which there are also macros */
+extern Window XRootWindow(
+	Display* /* display */,
+	int /* screen_number */
+);
+extern Window XDefaultRootWindow(
+	Display* /* display */
+);
+extern Window XRootWindowOfScreen(
+	Screen* /* screen */
+);
+extern Visual* XDefaultVisual(
+	Display* /* display */,
+	int /* screen_number */
+);
+extern Visual* XDefaultVisualOfScreen(
+	Screen* /* screen */
+);
+extern GC XDefaultGC(
+	Display* /* display */,
+	int /* screen_number */
+);
+extern GC XDefaultGCOfScreen(
+	Screen* /* screen */
+);
+extern unsigned long XBlackPixel(
+	Display* /* display */,
+	int /* screen_number */
+);
+extern unsigned long XWhitePixel(
+	Display* /* display */,
+	int /* screen_number */
+);
+extern unsigned long XAllPlanes(
+	void);
+extern unsigned long XBlackPixelOfScreen(
+	Screen* /* screen */
+);
+extern unsigned long XWhitePixelOfScreen(
+	Screen* /* screen */
+);
+extern unsigned long XNextRequest(
+	Display* /* display */
+);
+extern unsigned long XLastKnownRequestProcessed(
+	Display* /* display */
+);
+extern char* XServerVendor(
+	Display* /* display */
+);
+extern char* XDisplayString(
+	Display* /* display */
+);
+extern Colormap XDefaultColormap(
+	Display* /* display */,
+	int /* screen_number */
+);
+extern Colormap XDefaultColormapOfScreen(
+	Screen* /* screen */
+);
+extern Display* XDisplayOfScreen(
+	Screen* /* screen */
+);
+extern Screen* XScreenOfDisplay(
+	Display* /* display */,
+	int /* screen_number */
+);
+extern Screen* XDefaultScreenOfDisplay(
+	Display* /* display */
+);
+extern long XEventMaskOfScreen(
+	Screen* /* screen */
+);
+
+extern int XScreenNumberOfScreen(
+	Screen* /* screen */
+);
+
+typedef int (*XErrorHandler)(/* WARNING, this type not in Xlib spec */
+							 Display* /* display */,
+							 XErrorEvent* /* error_event */
+);
+
+extern XErrorHandler XSetErrorHandler(
+	XErrorHandler /* handler */
+);
+
+typedef int (*XIOErrorHandler)(         /* WARNING, this type not in Xlib spec */
+							   Display* /* display */
+);
+
+extern XIOErrorHandler XSetIOErrorHandler(
+	XIOErrorHandler /* handler */
+);
+
+extern XPixmapFormatValues* XListPixmapFormats(
+	Display* /* display */,
+	int* /* count_return */
+);
+extern int* XListDepths(
+	Display* /* display */,
+	int /* screen_number */,
+	int* /* count_return */
+);
+
+/* ICCCM routines for things that don't require special include files; */
+/* other declarations are given in Xutil.h                             */
+extern Status XReconfigureWMWindow(
+	Display* /* display */,
+	Window /* w */,
+	int /* screen_number */,
+	unsigned int /* mask */,
+	XWindowChanges* /* changes */
+);
+
+extern Status XGetWMProtocols(
+	Display* /* display */,
+	Window /* w */,
+	Atom** /* protocols_return */,
+	int* /* count_return */
+);
+extern Status XSetWMProtocols(
+	Display* /* display */,
+	Window /* w */,
+	Atom* /* protocols */,
+	int /* count */
+);
+extern Status XIconifyWindow(
+	Display* /* display */,
+	Window /* w */,
+	int /* screen_number */
+);
+extern Status XWithdrawWindow(
+	Display* /* display */,
+	Window /* w */,
+	int /* screen_number */
+);
+extern Status XGetCommand(
+	Display* /* display */,
+	Window /* w */,
+	char*** /* argv_return */,
+	int* /* argc_return */
+);
+extern Status XGetWMColormapWindows(
+	Display* /* display */,
+	Window /* w */,
+	Window** /* windows_return */,
+	int* /* count_return */
+);
+extern Status XSetWMColormapWindows(
+	Display* /* display */,
+	Window /* w */,
+	Window* /* colormap_windows */,
+	int /* count */
+);
+extern void XFreeStringList(
+	char** /* list */
+);
+extern int XSetTransientForHint(
+	Display* /* display */,
+	Window /* w */,
+	Window /* prop_window */
+);
+
+/* The following are given in alphabetical order */
+
+extern int XActivateScreenSaver(
+	Display* /* display */
+);
+
+extern int XAddHost(
+	Display* /* display */,
+	XHostAddress* /* host */
+);
+
+extern int XAddHosts(
+	Display* /* display */,
+	XHostAddress* /* hosts */,
+	int /* num_hosts */
+);
+
+extern int XAddToExtensionList(
+	struct _XExtData** /* structure */,
+	XExtData* /* ext_data */
+);
+
+extern int XAddToSaveSet(
+	Display* /* display */,
+	Window /* w */
+);
+
+extern Status XAllocColor(
+	Display* /* display */,
+	Colormap /* colormap */,
+	XColor* /* screen_in_out */
+);
+
+extern Status XAllocColorCells(
+	Display* /* display */,
+	Colormap /* colormap */,
+	Bool /* contig */,
+	unsigned long* /* plane_masks_return */,
+	unsigned int /* nplanes */,
+	unsigned long* /* pixels_return */,
+	unsigned int /* npixels */
+);
+
+extern Status XAllocColorPlanes(
+	Display* /* display */,
+	Colormap /* colormap */,
+	Bool /* contig */,
+	unsigned long* /* pixels_return */,
+	int /* ncolors */,
+	int /* nreds */,
+	int /* ngreens */,
+	int /* nblues */,
+	unsigned long* /* rmask_return */,
+	unsigned long* /* gmask_return */,
+	unsigned long* /* bmask_return */
+);
+
+extern Status XAllocNamedColor(
+	Display* /* display */,
+	Colormap /* colormap */,
+	_Xconst char* /* color_name */,
+	XColor* /* screen_def_return */,
+	XColor* /* exact_def_return */
+);
+
+extern int XAllowEvents(
+	Display* /* display */,
+	int /* event_mode */,
+	Time /* time */
+);
+
+extern int XAutoRepeatOff(
+	Display* /* display */
+);
+
+extern int XAutoRepeatOn(
+	Display* /* display */
+);
+
+extern int XBell(
+	Display* /* display */,
+	int /* percent */
+);
+
+extern int XBitmapBitOrder(
+	Display* /* display */
+);
+
+extern int XBitmapPad(
+	Display* /* display */
+);
+
+extern int XBitmapUnit(
+	Display* /* display */
+);
+
+extern int XCellsOfScreen(
+	Screen* /* screen */
+);
+
+extern int XChangeActivePointerGrab(
+	Display* /* display */,
+	unsigned int /* event_mask */,
+	Cursor /* cursor */,
+	Time /* time */
+);
+
+extern int XChangeGC(
+	Display* /* display */,
+	GC /* gc */,
+	unsigned long /* valuemask */,
+	XGCValues* /* values */
+);
+
+extern int XChangeKeyboardControl(
+	Display* /* display */,
+	unsigned long /* value_mask */,
+	XKeyboardControl* /* values */
+);
+
+extern int XChangeKeyboardMapping(
+	Display* /* display */,
+	int /* first_keycode */,
+	int /* keysyms_per_keycode */,
+	KeySym* /* keysyms */,
+	int /* num_codes */
+);
+
+extern int XChangePointerControl(
+	Display* /* display */,
+	Bool /* do_accel */,
+	Bool /* do_threshold */,
+	int /* accel_numerator */,
+	int /* accel_denominator */,
+	int /* threshold */
+);
+
+extern int XChangeProperty(
+	Display* /* display */,
+	Window /* w */,
+	Atom /* property */,
+	Atom /* type */,
+	int /* format */,
+	int /* mode */,
+	_Xconst unsigned char* /* data */,
+	int /* nelements */
+);
+
+extern int XChangeSaveSet(
+	Display* /* display */,
+	Window /* w */,
+	int /* change_mode */
+);
+
+extern int XChangeWindowAttributes(
+	Display* /* display */,
+	Window /* w */,
+	unsigned long /* valuemask */,
+	XSetWindowAttributes* /* attributes */
+);
+
+extern Bool XCheckIfEvent(
+	Display* /* display */,
+	XEvent* /* event_return */,
+	Bool (*)(
+		Display* /* display */,
+		XEvent* /* event */,
+		XPointer /* arg */
+		) /* predicate */,
+	XPointer /* arg */
+);
+
+extern Bool XCheckMaskEvent(
+	Display* /* display */,
+	long /* event_mask */,
+	XEvent* /* event_return */
+);
+
+extern Bool XCheckTypedEvent(
+	Display* /* display */,
+	int /* event_type */,
+	XEvent* /* event_return */
+);
+
+extern Bool XCheckTypedWindowEvent(
+	Display* /* display */,
+	Window /* w */,
+	int /* event_type */,
+	XEvent* /* event_return */
+);
+
+extern Bool XCheckWindowEvent(
+	Display* /* display */,
+	Window /* w */,
+	long /* event_mask */,
+	XEvent* /* event_return */
+);
+
+extern int XCirculateSubwindows(
+	Display* /* display */,
+	Window /* w */,
+	int /* direction */
+);
+
+extern int XCirculateSubwindowsDown(
+	Display* /* display */,
+	Window /* w */
+);
+
+extern int XCirculateSubwindowsUp(
+	Display* /* display */,
+	Window /* w */
+);
+
+extern int XClearArea(
+	Display* /* display */,
+	Window /* w */,
+	int /* x */,
+	int /* y */,
+	unsigned int /* width */,
+	unsigned int /* height */,
+	Bool /* exposures */
+);
+
+extern int XClearWindow(
+	Display* /* display */,
+	Window /* w */
+);
+
+extern int XCloseDisplay(
+	Display* /* display */
+);
+
+extern int XConfigureWindow(
+	Display* /* display */,
+	Window /* w */,
+	unsigned int /* value_mask */,
+	XWindowChanges* /* values */
+);
+
+extern int XConnectionNumber(
+	Display* /* display */
+);
+
+extern int XConvertSelection(
+	Display* /* display */,
+	Atom /* selection */,
+	Atom /* target */,
+	Atom /* property */,
+	Window /* requestor */,
+	Time /* time */
+);
+
+extern int XCopyArea(
+	Display* /* display */,
+	Drawable /* src */,
+	Drawable /* dest */,
+	GC /* gc */,
+	int /* src_x */,
+	int /* src_y */,
+	unsigned int /* width */,
+	unsigned int /* height */,
+	int /* dest_x */,
+	int /* dest_y */
+);
+
+extern int XCopyGC(
+	Display* /* display */,
+	GC /* src */,
+	unsigned long /* valuemask */,
+	GC /* dest */
+);
+
+extern int XCopyPlane(
+	Display* /* display */,
+	Drawable /* src */,
+	Drawable /* dest */,
+	GC /* gc */,
+	int /* src_x */,
+	int /* src_y */,
+	unsigned int /* width */,
+	unsigned int /* height */,
+	int /* dest_x */,
+	int /* dest_y */,
+	unsigned long /* plane */
+);
+
+extern int XDefaultDepth(
+	Display* /* display */,
+	int /* screen_number */
+);
+
+extern int XDefaultDepthOfScreen(
+	Screen* /* screen */
+);
+
+extern int XDefaultScreen(
+	Display* /* display */
+);
+
+extern int XDefineCursor(
+	Display* /* display */,
+	Window /* w */,
+	Cursor /* cursor */
+);
+
+extern int XDeleteProperty(
+	Display* /* display */,
+	Window /* w */,
+	Atom /* property */
+);
+
+extern int XDestroyWindow(
+	Display* /* display */,
+	Window /* w */
+);
+
+extern int XDestroySubwindows(
+	Display* /* display */,
+	Window /* w */
+);
+
+extern int XDoesBackingStore(
+	Screen* /* screen */
+);
+
+extern Bool XDoesSaveUnders(
+	Screen* /* screen */
+);
+
+extern int XDisableAccessControl(
+	Display* /* display */
+);
+
+extern int XDisplayCells(
+	Display* /* display */,
+	int /* screen_number */
+);
+
+extern int XDisplayHeight(
+	Display* /* display */,
+	int /* screen_number */
+);
+
+extern int XDisplayHeightMM(
+	Display* /* display */,
+	int /* screen_number */
+);
+
+extern int XDisplayKeycodes(
+	Display* /* display */,
+	int* /* min_keycodes_return */,
+	int* /* max_keycodes_return */
+);
+
+extern int XDisplayPlanes(
+	Display* /* display */,
+	int /* screen_number */
+);
+
+extern int XDisplayWidth(
+	Display* /* display */,
+	int /* screen_number */
+);
+
+extern int XDisplayWidthMM(
+	Display* /* display */,
+	int /* screen_number */
+);
+
+extern int XDrawArc(
+	Display* /* display */,
+	Drawable /* d */,
+	GC /* gc */,
+	int /* x */,
+	int /* y */,
+	unsigned int /* width */,
+	unsigned int /* height */,
+	int /* angle1 */,
+	int /* angle2 */
+);
+
+extern int XDrawArcs(
+	Display* /* display */,
+	Drawable /* d */,
+	GC /* gc */,
+	XArc* /* arcs */,
+	int /* narcs */
+);
+
+extern int XDrawImageString(
+	Display* /* display */,
+	Drawable /* d */,
+	GC /* gc */,
+	int /* x */,
+	int /* y */,
+	_Xconst char* /* string */,
+	int /* length */
+);
+
+extern int XDrawImageString16(
+	Display* /* display */,
+	Drawable /* d */,
+	GC /* gc */,
+	int /* x */,
+	int /* y */,
+	_Xconst XChar2b* /* string */,
+	int /* length */
+);
+
+extern int XDrawLine(
+	Display* /* display */,
+	Drawable /* d */,
+	GC /* gc */,
+	int /* x1 */,
+	int /* y1 */,
+	int /* x2 */,
+	int /* y2 */
+);
+
+extern int XDrawLines(
+	Display* /* display */,
+	Drawable /* d */,
+	GC /* gc */,
+	XPoint* /* points */,
+	int /* npoints */,
+	int /* mode */
+);
+
+extern int XDrawPoint(
+	Display* /* display */,
+	Drawable /* d */,
+	GC /* gc */,
+	int /* x */,
+	int /* y */
+);
+
+extern int XDrawPoints(
+	Display* /* display */,
+	Drawable /* d */,
+	GC /* gc */,
+	XPoint* /* points */,
+	int /* npoints */,
+	int /* mode */
+);
+
+extern int XDrawRectangle(
+	Display* /* display */,
+	Drawable /* d */,
+	GC /* gc */,
+	int /* x */,
+	int /* y */,
+	unsigned int /* width */,
+	unsigned int /* height */
+);
+
+extern int XDrawRectangles(
+	Display* /* display */,
+	Drawable /* d */,
+	GC /* gc */,
+	XRectangle* /* rectangles */,
+	int /* nrectangles */
+);
+
+extern int XDrawSegments(
+	Display* /* display */,
+	Drawable /* d */,
+	GC /* gc */,
+	XSegment* /* segments */,
+	int /* nsegments */
+);
+
+extern int XDrawString(
+	Display* /* display */,
+	Drawable /* d */,
+	GC /* gc */,
+	int /* x */,
+	int /* y */,
+	_Xconst char* /* string */,
+	int /* length */
+);
+
+extern int XDrawString16(
+	Display* /* display */,
+	Drawable /* d */,
+	GC /* gc */,
+	int /* x */,
+	int /* y */,
+	_Xconst XChar2b* /* string */,
+	int /* length */
+);
+
+extern int XDrawText(
+	Display* /* display */,
+	Drawable /* d */,
+	GC /* gc */,
+	int /* x */,
+	int /* y */,
+	XTextItem* /* items */,
+	int /* nitems */
+);
+
+extern int XDrawText16(
+	Display* /* display */,
+	Drawable /* d */,
+	GC /* gc */,
+	int /* x */,
+	int /* y */,
+	XTextItem16* /* items */,
+	int /* nitems */
+);
+
+extern int XEnableAccessControl(
+	Display* /* display */
+);
+
+extern int XEventsQueued(
+	Display* /* display */,
+	int /* mode */
+);
+
+extern Status XFetchName(
+	Display* /* display */,
+	Window /* w */,
+	char** /* window_name_return */
+);
+
+extern int XFillArc(
+	Display* /* display */,
+	Drawable /* d */,
+	GC /* gc */,
+	int /* x */,
+	int /* y */,
+	unsigned int /* width */,
+	unsigned int /* height */,
+	int /* angle1 */,
+	int /* angle2 */
+);
+
+extern int XFillArcs(
+	Display* /* display */,
+	Drawable /* d */,
+	GC /* gc */,
+	XArc* /* arcs */,
+	int /* narcs */
+);
+
+extern int XFillPolygon(
+	Display* /* display */,
+	Drawable /* d */,
+	GC /* gc */,
+	XPoint* /* points */,
+	int /* npoints */,
+	int /* shape */,
+	int /* mode */
+);
+
+extern int XFillRectangle(
+	Display* /* display */,
+	Drawable /* d */,
+	GC /* gc */,
+	int /* x */,
+	int /* y */,
+	unsigned int /* width */,
+	unsigned int /* height */
+);
+
+extern int XFillRectangles(
+	Display* /* display */,
+	Drawable /* d */,
+	GC /* gc */,
+	XRectangle* /* rectangles */,
+	int /* nrectangles */
+);
+
+extern int XFlush(
+	Display* /* display */
+);
+
+extern int XForceScreenSaver(
+	Display* /* display */,
+	int /* mode */
+);
+
+extern int XFree(
+	void* /* data */
+);
+
+extern int XFreeColormap(
+	Display* /* display */,
+	Colormap /* colormap */
+);
+
+extern int XFreeColors(
+	Display* /* display */,
+	Colormap /* colormap */,
+	unsigned long* /* pixels */,
+	int /* npixels */,
+	unsigned long /* planes */
+);
+
+extern int XFreeCursor(
+	Display* /* display */,
+	Cursor /* cursor */
+);
+
+extern int XFreeExtensionList(
+	char** /* list */
+);
+
+extern int XFreeFont(
+	Display* /* display */,
+	XFontStruct* /* font_struct */
+);
+
+extern int XFreeFontInfo(
+	char** /* names */,
+	XFontStruct* /* free_info */,
+	int /* actual_count */
+);
+
+extern int XFreeFontNames(
+	char** /* list */
+);
+
+extern int XFreeFontPath(
+	char** /* list */
+);
+
+extern int XFreeGC(
+	Display* /* display */,
+	GC /* gc */
+);
+
+extern int XFreeModifiermap(
+	XModifierKeymap* /* modmap */
+);
+
+extern int XFreePixmap(
+	Display* /* display */,
+	Pixmap /* pixmap */
+);
+
+extern int XGeometry(
+	Display* /* display */,
+	int /* screen */,
+	_Xconst char* /* position */,
+	_Xconst char* /* default_position */,
+	unsigned int /* bwidth */,
+	unsigned int /* fwidth */,
+	unsigned int /* fheight */,
+	int /* xadder */,
+	int /* yadder */,
+	int* /* x_return */,
+	int* /* y_return */,
+	int* /* width_return */,
+	int* /* height_return */
+);
+
+extern int XGetErrorDatabaseText(
+	Display* /* display */,
+	_Xconst char* /* name */,
+	_Xconst char* /* message */,
+	_Xconst char* /* default_string */,
+	char* /* buffer_return */,
+	int /* length */
+);
+
+extern int XGetErrorText(
+	Display* /* display */,
+	int /* code */,
+	char* /* buffer_return */,
+	int /* length */
+);
+
+extern Bool XGetFontProperty(
+	XFontStruct* /* font_struct */,
+	Atom /* atom */,
+	unsigned long* /* value_return */
+);
+
+extern Status XGetGCValues(
+	Display* /* display */,
+	GC /* gc */,
+	unsigned long /* valuemask */,
+	XGCValues* /* values_return */
+);
+
+extern Status XGetGeometry(
+	Display* /* display */,
+	Drawable /* d */,
+	Window* /* root_return */,
+	int* /* x_return */,
+	int* /* y_return */,
+	unsigned int* /* width_return */,
+	unsigned int* /* height_return */,
+	unsigned int* /* border_width_return */,
+	unsigned int* /* depth_return */
+);
+
+extern Status XGetIconName(
+	Display* /* display */,
+	Window /* w */,
+	char** /* icon_name_return */
+);
+
+extern int XGetInputFocus(
+	Display* /* display */,
+	Window* /* focus_return */,
+	int* /* revert_to_return */
+);
+
+extern int XGetKeyboardControl(
+	Display* /* display */,
+	XKeyboardState* /* values_return */
+);
+
+extern int XGetPointerControl(
+	Display* /* display */,
+	int* /* accel_numerator_return */,
+	int* /* accel_denominator_return */,
+	int* /* threshold_return */
+);
+
+extern int XGetPointerMapping(
+	Display* /* display */,
+	unsigned char* /* map_return */,
+	int /* nmap */
+);
+
+extern int XGetScreenSaver(
+	Display* /* display */,
+	int* /* timeout_return */,
+	int* /* interval_return */,
+	int* /* prefer_blanking_return */,
+	int* /* allow_exposures_return */
+);
+
+extern Status XGetTransientForHint(
+	Display* /* display */,
+	Window /* w */,
+	Window* /* prop_window_return */
+);
+
+extern int XGetWindowProperty(
+	Display* /* display */,
+	Window /* w */,
+	Atom /* property */,
+	long /* long_offset */,
+	long /* long_length */,
+	Bool /* delete */,
+	Atom /* req_type */,
+	Atom* /* actual_type_return */,
+	int* /* actual_format_return */,
+	unsigned long* /* nitems_return */,
+	unsigned long* /* bytes_after_return */,
+	unsigned char** /* prop_return */
+);
+
+extern Status XGetWindowAttributes(
+	Display* /* display */,
+	Window /* w */,
+	XWindowAttributes* /* window_attributes_return */
+);
+
+extern int XGrabButton(
+	Display* /* display */,
+	unsigned int /* button */,
+	unsigned int /* modifiers */,
+	Window /* grab_window */,
+	Bool /* owner_events */,
+	unsigned int /* event_mask */,
+	int /* pointer_mode */,
+	int /* keyboard_mode */,
+	Window /* confine_to */,
+	Cursor /* cursor */
+);
+
+extern int XGrabKey(
+	Display* /* display */,
+	int /* keycode */,
+	unsigned int /* modifiers */,
+	Window /* grab_window */,
+	Bool /* owner_events */,
+	int /* pointer_mode */,
+	int /* keyboard_mode */
+);
+
+extern int XGrabKeyboard(
+	Display* /* display */,
+	Window /* grab_window */,
+	Bool /* owner_events */,
+	int /* pointer_mode */,
+	int /* keyboard_mode */,
+	Time /* time */
+);
+
+extern int XGrabPointer(
+	Display* /* display */,
+	Window /* grab_window */,
+	Bool /* owner_events */,
+	unsigned int /* event_mask */,
+	int /* pointer_mode */,
+	int /* keyboard_mode */,
+	Window /* confine_to */,
+	Cursor /* cursor */,
+	Time /* time */
+);
+
+extern int XGrabServer(
+	Display* /* display */
+);
+
+extern int XHeightMMOfScreen(
+	Screen* /* screen */
+);
+
+extern int XHeightOfScreen(
+	Screen* /* screen */
+);
+
+extern int XIfEvent(
+	Display* /* display */,
+	XEvent* /* event_return */,
+	Bool (*)(
+		Display* /* display */,
+		XEvent* /* event */,
+		XPointer /* arg */
+		) /* predicate */,
+	XPointer /* arg */
+);
+
+extern int XImageByteOrder(
+	Display* /* display */
+);
+
+extern int XInstallColormap(
+	Display* /* display */,
+	Colormap /* colormap */
+);
+
+extern KeyCode XKeysymToKeycode(
+	Display* /* display */,
+	KeySym /* keysym */
+);
+
+extern int XKillClient(
+	Display* /* display */,
+	XID /* resource */
+);
+
+extern Status XLookupColor(
+	Display* /* display */,
+	Colormap /* colormap */,
+	_Xconst char* /* color_name */,
+	XColor* /* exact_def_return */,
+	XColor* /* screen_def_return */
+);
+
+extern int XLowerWindow(
+	Display* /* display */,
+	Window /* w */
+);
+
+extern int XMapRaised(
+	Display* /* display */,
+	Window /* w */
+);
+
+extern int XMapSubwindows(
+	Display* /* display */,
+	Window /* w */
+);
+
+extern int XMapWindow(
+	Display* /* display */,
+	Window /* w */
+);
+
+extern int XMaskEvent(
+	Display* /* display */,
+	long /* event_mask */,
+	XEvent* /* event_return */
+);
+
+extern int XMaxCmapsOfScreen(
+	Screen* /* screen */
+);
+
+extern int XMinCmapsOfScreen(
+	Screen* /* screen */
+);
+
+extern int XMoveResizeWindow(
+	Display* /* display */,
+	Window /* w */,
+	int /* x */,
+	int /* y */,
+	unsigned int /* width */,
+	unsigned int /* height */
+);
+
+extern int XMoveWindow(
+	Display* /* display */,
+	Window /* w */,
+	int /* x */,
+	int /* y */
+);
+
+extern int XNextEvent(
+	Display* /* display */,
+	XEvent* /* event_return */
+);
+
+extern int XNoOp(
+	Display* /* display */
+);
+
+extern Status XParseColor(
+	Display* /* display */,
+	Colormap /* colormap */,
+	_Xconst char* /* spec */,
+	XColor* /* exact_def_return */
+);
+
+extern int XParseGeometry(
+	_Xconst char* /* parsestring */,
+	int* /* x_return */,
+	int* /* y_return */,
+	unsigned int* /* width_return */,
+	unsigned int* /* height_return */
+);
+
+extern int XPeekEvent(
+	Display* /* display */,
+	XEvent* /* event_return */
+);
+
+extern int XPeekIfEvent(
+	Display* /* display */,
+	XEvent* /* event_return */,
+	Bool (*)(
+		Display* /* display */,
+		XEvent* /* event */,
+		XPointer /* arg */
+		) /* predicate */,
+	XPointer /* arg */
+);
+
+extern int XPending(
+	Display* /* display */
+);
+
+extern int XPlanesOfScreen(
+	Screen* /* screen */
+);
+
+extern int XProtocolRevision(
+	Display* /* display */
+);
+
+extern int XProtocolVersion(
+	Display* /* display */
+);
+
+extern int XPutBackEvent(
+	Display* /* display */,
+	XEvent* /* event */
+);
+
+extern int XPutImage(
+	Display* /* display */,
+	Drawable /* d */,
+	GC /* gc */,
+	XImage* /* image */,
+	int /* src_x */,
+	int /* src_y */,
+	int /* dest_x */,
+	int /* dest_y */,
+	unsigned int /* width */,
+	unsigned int /* height */
+);
+
+extern int XQLength(
+	Display* /* display */
+);
+
+extern Status XQueryBestCursor(
+	Display* /* display */,
+	Drawable /* d */,
+	unsigned int /* width */,
+	unsigned int /* height */,
+	unsigned int* /* width_return */,
+	unsigned int* /* height_return */
+);
+
+extern Status XQueryBestSize(
+	Display* /* display */,
+	int /* class */,
+	Drawable /* which_screen */,
+	unsigned int /* width */,
+	unsigned int /* height */,
+	unsigned int* /* width_return */,
+	unsigned int* /* height_return */
+);
+
+extern Status XQueryBestStipple(
+	Display* /* display */,
+	Drawable /* which_screen */,
+	unsigned int /* width */,
+	unsigned int /* height */,
+	unsigned int* /* width_return */,
+	unsigned int* /* height_return */
+);
+
+extern Status XQueryBestTile(
+	Display* /* display */,
+	Drawable /* which_screen */,
+	unsigned int /* width */,
+	unsigned int /* height */,
+	unsigned int* /* width_return */,
+	unsigned int* /* height_return */
+);
+
+extern int XQueryColor(
+	Display* /* display */,
+	Colormap /* colormap */,
+	XColor* /* def_in_out */
+);
+
+extern int XQueryColors(
+	Display* /* display */,
+	Colormap /* colormap */,
+	XColor* /* defs_in_out */,
+	int /* ncolors */
+);
+
+extern Bool XQueryExtension(
+	Display* /* display */,
+	_Xconst char* /* name */,
+	int* /* major_opcode_return */,
+	int* /* first_event_return */,
+	int* /* first_error_return */
+);
+
+extern int XQueryKeymap(
+	Display* /* display */,
+	char[32] /* keys_return */
+);
+
+extern Bool XQueryPointer(
+	Display* /* display */,
+	Window /* w */,
+	Window* /* root_return */,
+	Window* /* child_return */,
+	int* /* root_x_return */,
+	int* /* root_y_return */,
+	int* /* win_x_return */,
+	int* /* win_y_return */,
+	unsigned int* /* mask_return */
+);
+
+extern int XQueryTextExtents(
+	Display* /* display */,
+	XID /* font_ID */,
+	_Xconst char* /* string */,
+	int /* nchars */,
+	int* /* direction_return */,
+	int* /* font_ascent_return */,
+	int* /* font_descent_return */,
+	XCharStruct* /* overall_return */
+);
+
+extern int XQueryTextExtents16(
+	Display* /* display */,
+	XID /* font_ID */,
+	_Xconst XChar2b* /* string */,
+	int /* nchars */,
+	int* /* direction_return */,
+	int* /* font_ascent_return */,
+	int* /* font_descent_return */,
+	XCharStruct* /* overall_return */
+);
+
+extern Status XQueryTree(
+	Display* /* display */,
+	Window /* w */,
+	Window* /* root_return */,
+	Window* /* parent_return */,
+	Window** /* children_return */,
+	unsigned int* /* nchildren_return */
+);
+
+extern int XRaiseWindow(
+	Display* /* display */,
+	Window /* w */
+);
+
+extern int XReadBitmapFile(
+	Display* /* display */,
+	Drawable /* d */,
+	_Xconst char* /* filename */,
+	unsigned int* /* width_return */,
+	unsigned int* /* height_return */,
+	Pixmap* /* bitmap_return */,
+	int* /* x_hot_return */,
+	int* /* y_hot_return */
+);
+
+extern int XReadBitmapFileData(
+	_Xconst char* /* filename */,
+	unsigned int* /* width_return */,
+	unsigned int* /* height_return */,
+	unsigned char** /* data_return */,
+	int* /* x_hot_return */,
+	int* /* y_hot_return */
+);
+
+extern int XRebindKeysym(
+	Display* /* display */,
+	KeySym /* keysym */,
+	KeySym* /* list */,
+	int /* mod_count */,
+	_Xconst unsigned char* /* string */,
+	int /* bytes_string */
+);
+
+extern int XRecolorCursor(
+	Display* /* display */,
+	Cursor /* cursor */,
+	XColor* /* foreground_color */,
+	XColor* /* background_color */
+);
+
+extern int XRefreshKeyboardMapping(
+	XMappingEvent* /* event_map */
+);
+
+extern int XRemoveFromSaveSet(
+	Display* /* display */,
+	Window /* w */
+);
+
+extern int XRemoveHost(
+	Display* /* display */,
+	XHostAddress* /* host */
+);
+
+extern int XRemoveHosts(
+	Display* /* display */,
+	XHostAddress* /* hosts */,
+	int /* num_hosts */
+);
+
+extern int XReparentWindow(
+	Display* /* display */,
+	Window /* w */,
+	Window /* parent */,
+	int /* x */,
+	int /* y */
+);
+
+extern int XResetScreenSaver(
+	Display* /* display */
+);
+
+extern int XResizeWindow(
+	Display* /* display */,
+	Window /* w */,
+	unsigned int /* width */,
+	unsigned int /* height */
+);
+
+extern int XRestackWindows(
+	Display* /* display */,
+	Window* /* windows */,
+	int /* nwindows */
+);
+
+extern int XRotateBuffers(
+	Display* /* display */,
+	int /* rotate */
+);
+
+extern int XRotateWindowProperties(
+	Display* /* display */,
+	Window /* w */,
+	Atom* /* properties */,
+	int /* num_prop */,
+	int /* npositions */
+);
+
+extern int XScreenCount(
+	Display* /* display */
+);
+
+extern int XSelectInput(
+	Display* /* display */,
+	Window /* w */,
+	long /* event_mask */
+);
+
+extern Status XSendEvent(
+	Display* /* display */,
+	Window /* w */,
+	Bool /* propagate */,
+	long /* event_mask */,
+	XEvent* /* event_send */
+);
+
+extern int XSetAccessControl(
+	Display* /* display */,
+	int /* mode */
+);
+
+extern int XSetArcMode(
+	Display* /* display */,
+	GC /* gc */,
+	int /* arc_mode */
+);
+
+extern int XSetBackground(
+	Display* /* display */,
+	GC /* gc */,
+	unsigned long /* background */
+);
+
+extern int XSetClipMask(
+	Display* /* display */,
+	GC /* gc */,
+	Pixmap /* pixmap */
+);
+
+extern int XSetClipOrigin(
+	Display* /* display */,
+	GC /* gc */,
+	int /* clip_x_origin */,
+	int /* clip_y_origin */
+);
+
+extern int XSetClipRectangles(
+	Display* /* display */,
+	GC /* gc */,
+	int /* clip_x_origin */,
+	int /* clip_y_origin */,
+	XRectangle* /* rectangles */,
+	int /* n */,
+	int /* ordering */
+);
+
+extern int XSetCloseDownMode(
+	Display* /* display */,
+	int /* close_mode */
+);
+
+extern int XSetCommand(
+	Display* /* display */,
+	Window /* w */,
+	char** /* argv */,
+	int /* argc */
+);
+
+extern int XSetDashes(
+	Display* /* display */,
+	GC /* gc */,
+	int /* dash_offset */,
+	_Xconst char* /* dash_list */,
+	int /* n */
+);
+
+extern int XSetFillRule(
+	Display* /* display */,
+	GC /* gc */,
+	int /* fill_rule */
+);
+
+extern int XSetFillStyle(
+	Display* /* display */,
+	GC /* gc */,
+	int /* fill_style */
+);
+
+extern int XSetFont(
+	Display* /* display */,
+	GC /* gc */,
+	Font /* font */
+);
+
+extern int XSetFontPath(
+	Display* /* display */,
+	char** /* directories */,
+	int /* ndirs */
+);
+
+extern int XSetForeground(
+	Display* /* display */,
+	GC /* gc */,
+	unsigned long /* foreground */
+);
+
+extern int XSetFunction(
+	Display* /* display */,
+	GC /* gc */,
+	int /* function */
+);
+
+extern int XSetGraphicsExposures(
+	Display* /* display */,
+	GC /* gc */,
+	Bool /* graphics_exposures */
+);
+
+extern int XSetIconName(
+	Display* /* display */,
+	Window /* w */,
+	_Xconst char* /* icon_name */
+);
+
+extern int XSetInputFocus(
+	Display* /* display */,
+	Window /* focus */,
+	int /* revert_to */,
+	Time /* time */
+);
+
+extern int XSetLineAttributes(
+	Display* /* display */,
+	GC /* gc */,
+	unsigned int /* line_width */,
+	int /* line_style */,
+	int /* cap_style */,
+	int /* join_style */
+);
+
+extern int XSetModifierMapping(
+	Display* /* display */,
+	XModifierKeymap* /* modmap */
+);
+
+extern int XSetPlaneMask(
+	Display* /* display */,
+	GC /* gc */,
+	unsigned long /* plane_mask */
+);
+
+extern int XSetPointerMapping(
+	Display* /* display */,
+	_Xconst unsigned char* /* map */,
+	int /* nmap */
+);
+
+extern int XSetScreenSaver(
+	Display* /* display */,
+	int /* timeout */,
+	int /* interval */,
+	int /* prefer_blanking */,
+	int /* allow_exposures */
+);
+
+extern int XSetSelectionOwner(
+	Display* /* display */,
+	Atom /* selection */,
+	Window /* owner */,
+	Time /* time */
+);
+
+extern int XSetState(
+	Display* /* display */,
+	GC /* gc */,
+	unsigned long /* foreground */,
+	unsigned long /* background */,
+	int /* function */,
+	unsigned long /* plane_mask */
+);
+
+extern int XSetStipple(
+	Display* /* display */,
+	GC /* gc */,
+	Pixmap /* stipple */
+);
+
+extern int XSetSubwindowMode(
+	Display* /* display */,
+	GC /* gc */,
+	int /* subwindow_mode */
+);
+
+extern int XSetTSOrigin(
+	Display* /* display */,
+	GC /* gc */,
+	int /* ts_x_origin */,
+	int /* ts_y_origin */
+);
+
+extern int XSetTile(
+	Display* /* display */,
+	GC /* gc */,
+	Pixmap /* tile */
+);
+
+extern int XSetWindowBackground(
+	Display* /* display */,
+	Window /* w */,
+	unsigned long /* background_pixel */
+);
+
+extern int XSetWindowBackgroundPixmap(
+	Display* /* display */,
+	Window /* w */,
+	Pixmap /* background_pixmap */
+);
+
+extern int XSetWindowBorder(
+	Display* /* display */,
+	Window /* w */,
+	unsigned long /* border_pixel */
+);
+
+extern int XSetWindowBorderPixmap(
+	Display* /* display */,
+	Window /* w */,
+	Pixmap /* border_pixmap */
+);
+
+extern int XSetWindowBorderWidth(
+	Display* /* display */,
+	Window /* w */,
+	unsigned int /* width */
+);
+
+extern int XSetWindowColormap(
+	Display* /* display */,
+	Window /* w */,
+	Colormap /* colormap */
+);
+
+extern int XStoreBuffer(
+	Display* /* display */,
+	_Xconst char* /* bytes */,
+	int /* nbytes */,
+	int /* buffer */
+);
+
+extern int XStoreBytes(
+	Display* /* display */,
+	_Xconst char* /* bytes */,
+	int /* nbytes */
+);
+
+extern int XStoreColor(
+	Display* /* display */,
+	Colormap /* colormap */,
+	XColor* /* color */
+);
+
+extern int XStoreColors(
+	Display* /* display */,
+	Colormap /* colormap */,
+	XColor* /* color */,
+	int /* ncolors */
+);
+
+extern int XStoreName(
+	Display* /* display */,
+	Window /* w */,
+	_Xconst char* /* window_name */
+);
+
+extern int XStoreNamedColor(
+	Display* /* display */,
+	Colormap /* colormap */,
+	_Xconst char* /* color */,
+	unsigned long /* pixel */,
+	int /* flags */
+);
+
+extern int XSync(
+	Display* /* display */,
+	Bool /* discard */
+);
+
+extern int XTextExtents(
+	XFontStruct* /* font_struct */,
+	_Xconst char* /* string */,
+	int /* nchars */,
+	int* /* direction_return */,
+	int* /* font_ascent_return */,
+	int* /* font_descent_return */,
+	XCharStruct* /* overall_return */
+);
+
+extern int XTextExtents16(
+	XFontStruct* /* font_struct */,
+	_Xconst XChar2b* /* string */,
+	int /* nchars */,
+	int* /* direction_return */,
+	int* /* font_ascent_return */,
+	int* /* font_descent_return */,
+	XCharStruct* /* overall_return */
+);
+
+extern int XTextWidth(
+	XFontStruct* /* font_struct */,
+	_Xconst char* /* string */,
+	int /* count */
+);
+
+extern int XTextWidth16(
+	XFontStruct* /* font_struct */,
+	_Xconst XChar2b* /* string */,
+	int /* count */
+);
+
+extern Bool XTranslateCoordinates(
+	Display* /* display */,
+	Window /* src_w */,
+	Window /* dest_w */,
+	int /* src_x */,
+	int /* src_y */,
+	int* /* dest_x_return */,
+	int* /* dest_y_return */,
+	Window* /* child_return */
+);
+
+extern int XUndefineCursor(
+	Display* /* display */,
+	Window /* w */
+);
+
+extern int XUngrabButton(
+	Display* /* display */,
+	unsigned int /* button */,
+	unsigned int /* modifiers */,
+	Window /* grab_window */
+);
+
+extern int XUngrabKey(
+	Display* /* display */,
+	int /* keycode */,
+	unsigned int /* modifiers */,
+	Window /* grab_window */
+);
+
+extern int XUngrabKeyboard(
+	Display* /* display */,
+	Time /* time */
+);
+
+extern int XUngrabPointer(
+	Display* /* display */,
+	Time /* time */
+);
+
+extern int XUngrabServer(
+	Display* /* display */
+);
+
+extern int XUninstallColormap(
+	Display* /* display */,
+	Colormap /* colormap */
+);
+
+extern int XUnloadFont(
+	Display* /* display */,
+	Font /* font */
+);
+
+extern int XUnmapSubwindows(
+	Display* /* display */,
+	Window /* w */
+);
+
+extern int XUnmapWindow(
+	Display* /* display */,
+	Window /* w */
+);
+
+extern int XVendorRelease(
+	Display* /* display */
+);
+
+extern int XWarpPointer(
+	Display* /* display */,
+	Window /* src_w */,
+	Window /* dest_w */,
+	int /* src_x */,
+	int /* src_y */,
+	unsigned int /* src_width */,
+	unsigned int /* src_height */,
+	int /* dest_x */,
+	int /* dest_y */
+);
+
+extern int XWidthMMOfScreen(
+	Screen* /* screen */
+);
+
+extern int XWidthOfScreen(
+	Screen* /* screen */
+);
+
+extern int XWindowEvent(
+	Display* /* display */,
+	Window /* w */,
+	long /* event_mask */,
+	XEvent* /* event_return */
+);
+
+extern int XWriteBitmapFile(
+	Display* /* display */,
+	_Xconst char* /* filename */,
+	Pixmap /* bitmap */,
+	unsigned int /* width */,
+	unsigned int /* height */,
+	int /* x_hot */,
+	int /* y_hot */
+);
+
+extern Bool XSupportsLocale(void);
+
+extern char* XSetLocaleModifiers(
+	const char* /* modifier_list */
+);
+
+extern XOM XOpenOM(
+	Display* /* display */,
+	struct _XrmHashBucketRec* /* rdb */,
+	_Xconst char* /* res_name */,
+	_Xconst char* /* res_class */
+);
+
+extern Status XCloseOM(
+	XOM /* om */
+);
+
+extern char* XSetOMValues(
+	XOM /* om */,
+	...) _X_SENTINEL(0);
+
+extern char* XGetOMValues(
+	XOM /* om */,
+	...) _X_SENTINEL(0);
+
+extern Display* XDisplayOfOM(
+	XOM /* om */
+);
+
+extern char* XLocaleOfOM(
+	XOM /* om */
+);
+
+extern XOC XCreateOC(
+	XOM /* om */,
+	...) _X_SENTINEL(0);
+
+extern void XDestroyOC(
+	XOC /* oc */
+);
+
+extern XOM XOMOfOC(
+	XOC /* oc */
+);
+
+extern char* XSetOCValues(
+	XOC /* oc */,
+	...) _X_SENTINEL(0);
+
+extern char* XGetOCValues(
+	XOC /* oc */,
+	...) _X_SENTINEL(0);
+
+extern XFontSet XCreateFontSet(
+	Display* /* display */,
+	_Xconst char* /* base_font_name_list */,
+	char*** /* missing_charset_list */,
+	int* /* missing_charset_count */,
+	char** /* def_string */
+);
+
+extern void XFreeFontSet(
+	Display* /* display */,
+	XFontSet /* font_set */
+);
+
+extern int XFontsOfFontSet(
+	XFontSet /* font_set */,
+	XFontStruct*** /* font_struct_list */,
+	char*** /* font_name_list */
+);
+
+extern char* XBaseFontNameListOfFontSet(
+	XFontSet /* font_set */
+);
+
+extern char* XLocaleOfFontSet(
+	XFontSet /* font_set */
+);
+
+extern Bool XContextDependentDrawing(
+	XFontSet /* font_set */
+);
+
+extern Bool XDirectionalDependentDrawing(
+	XFontSet /* font_set */
+);
+
+extern Bool XContextualDrawing(
+	XFontSet /* font_set */
+);
+
+extern XFontSetExtents* XExtentsOfFontSet(
+	XFontSet /* font_set */
+);
+
+extern int XmbTextEscapement(
+	XFontSet /* font_set */,
+	_Xconst char* /* text */,
+	int /* bytes_text */
+);
+
+extern int XwcTextEscapement(
+	XFontSet /* font_set */,
+	_Xconst wchar_t* /* text */,
+	int /* num_wchars */
+);
+
+extern int Xutf8TextEscapement(
+	XFontSet /* font_set */,
+	_Xconst char* /* text */,
+	int /* bytes_text */
+);
+
+extern int XmbTextExtents(
+	XFontSet /* font_set */,
+	_Xconst char* /* text */,
+	int /* bytes_text */,
+	XRectangle* /* overall_ink_return */,
+	XRectangle* /* overall_logical_return */
+);
+
+extern int XwcTextExtents(
+	XFontSet /* font_set */,
+	_Xconst wchar_t* /* text */,
+	int /* num_wchars */,
+	XRectangle* /* overall_ink_return */,
+	XRectangle* /* overall_logical_return */
+);
+
+extern int Xutf8TextExtents(
+	XFontSet /* font_set */,
+	_Xconst char* /* text */,
+	int /* bytes_text */,
+	XRectangle* /* overall_ink_return */,
+	XRectangle* /* overall_logical_return */
+);
+
+extern Status XmbTextPerCharExtents(
+	XFontSet /* font_set */,
+	_Xconst char* /* text */,
+	int /* bytes_text */,
+	XRectangle* /* ink_extents_buffer */,
+	XRectangle* /* logical_extents_buffer */,
+	int /* buffer_size */,
+	int* /* num_chars */,
+	XRectangle* /* overall_ink_return */,
+	XRectangle* /* overall_logical_return */
+);
+
+extern Status XwcTextPerCharExtents(
+	XFontSet /* font_set */,
+	_Xconst wchar_t* /* text */,
+	int /* num_wchars */,
+	XRectangle* /* ink_extents_buffer */,
+	XRectangle* /* logical_extents_buffer */,
+	int /* buffer_size */,
+	int* /* num_chars */,
+	XRectangle* /* overall_ink_return */,
+	XRectangle* /* overall_logical_return */
+);
+
+extern Status Xutf8TextPerCharExtents(
+	XFontSet /* font_set */,
+	_Xconst char* /* text */,
+	int /* bytes_text */,
+	XRectangle* /* ink_extents_buffer */,
+	XRectangle* /* logical_extents_buffer */,
+	int /* buffer_size */,
+	int* /* num_chars */,
+	XRectangle* /* overall_ink_return */,
+	XRectangle* /* overall_logical_return */
+);
+
+extern void XmbDrawText(
+	Display* /* display */,
+	Drawable /* d */,
+	GC /* gc */,
+	int /* x */,
+	int /* y */,
+	XmbTextItem* /* text_items */,
+	int /* nitems */
+);
+
+extern void XwcDrawText(
+	Display* /* display */,
+	Drawable /* d */,
+	GC /* gc */,
+	int /* x */,
+	int /* y */,
+	XwcTextItem* /* text_items */,
+	int /* nitems */
+);
+
+extern void Xutf8DrawText(
+	Display* /* display */,
+	Drawable /* d */,
+	GC /* gc */,
+	int /* x */,
+	int /* y */,
+	XmbTextItem* /* text_items */,
+	int /* nitems */
+);
+
+extern void XmbDrawString(
+	Display* /* display */,
+	Drawable /* d */,
+	XFontSet /* font_set */,
+	GC /* gc */,
+	int /* x */,
+	int /* y */,
+	_Xconst char* /* text */,
+	int /* bytes_text */
+);
+
+extern void XwcDrawString(
+	Display* /* display */,
+	Drawable /* d */,
+	XFontSet /* font_set */,
+	GC /* gc */,
+	int /* x */,
+	int /* y */,
+	_Xconst wchar_t* /* text */,
+	int /* num_wchars */
+);
+
+extern void Xutf8DrawString(
+	Display* /* display */,
+	Drawable /* d */,
+	XFontSet /* font_set */,
+	GC /* gc */,
+	int /* x */,
+	int /* y */,
+	_Xconst char* /* text */,
+	int /* bytes_text */
+);
+
+extern void XmbDrawImageString(
+	Display* /* display */,
+	Drawable /* d */,
+	XFontSet /* font_set */,
+	GC /* gc */,
+	int /* x */,
+	int /* y */,
+	_Xconst char* /* text */,
+	int /* bytes_text */
+);
+
+extern void XwcDrawImageString(
+	Display* /* display */,
+	Drawable /* d */,
+	XFontSet /* font_set */,
+	GC /* gc */,
+	int /* x */,
+	int /* y */,
+	_Xconst wchar_t* /* text */,
+	int /* num_wchars */
+);
+
+extern void Xutf8DrawImageString(
+	Display* /* display */,
+	Drawable /* d */,
+	XFontSet /* font_set */,
+	GC /* gc */,
+	int /* x */,
+	int /* y */,
+	_Xconst char* /* text */,
+	int /* bytes_text */
+);
+
+extern XIM XOpenIM(
+	Display* /* dpy */,
+	struct _XrmHashBucketRec* /* rdb */,
+	char* /* res_name */,
+	char* /* res_class */
+);
+
+extern Status XCloseIM(
+	XIM /* im */
+);
+
+extern char* XGetIMValues(
+	XIM /* im */, ...) _X_SENTINEL(0);
+
+extern char* XSetIMValues(
+	XIM /* im */, ...) _X_SENTINEL(0);
+
+extern Display* XDisplayOfIM(
+	XIM /* im */
+);
+
+extern char* XLocaleOfIM(
+	XIM /* im*/
+);
+
+extern XIC XCreateIC(
+	XIM /* im */, ...) _X_SENTINEL(0);
+
+extern void XDestroyIC(
+	XIC /* ic */
+);
+
+extern void XSetICFocus(
+	XIC /* ic */
+);
+
+extern void XUnsetICFocus(
+	XIC /* ic */
+);
+
+extern wchar_t* XwcResetIC(
+	XIC /* ic */
+);
+
+extern char* XmbResetIC(
+	XIC /* ic */
+);
+
+extern char* Xutf8ResetIC(
+	XIC /* ic */
+);
+
+extern char* XSetICValues(
+	XIC /* ic */, ...) _X_SENTINEL(0);
+
+extern char* XGetICValues(
+	XIC /* ic */, ...) _X_SENTINEL(0);
+
+extern XIM XIMOfIC(
+	XIC /* ic */
+);
+
+extern Bool XFilterEvent(
+	XEvent* /* event */,
+	Window /* window */
+);
+
+extern int XmbLookupString(
+	XIC /* ic */,
+	XKeyPressedEvent* /* event */,
+	char* /* buffer_return */,
+	int /* bytes_buffer */,
+	KeySym* /* keysym_return */,
+	Status* /* status_return */
+);
+
+extern int XwcLookupString(
+	XIC /* ic */,
+	XKeyPressedEvent* /* event */,
+	wchar_t* /* buffer_return */,
+	int /* wchars_buffer */,
+	KeySym* /* keysym_return */,
+	Status* /* status_return */
+);
+
+extern int Xutf8LookupString(
+	XIC /* ic */,
+	XKeyPressedEvent* /* event */,
+	char* /* buffer_return */,
+	int /* bytes_buffer */,
+	KeySym* /* keysym_return */,
+	Status* /* status_return */
+);
+
+extern XVaNestedList XVaCreateNestedList(
+	int /*unused*/, ...) _X_SENTINEL(0);
+
+/* internal connections for IMs */
+
+extern Bool XRegisterIMInstantiateCallback(
+	Display* /* dpy */,
+	struct _XrmHashBucketRec* /* rdb */,
+	char* /* res_name */,
+	char* /* res_class */,
+	XIDProc /* callback */,
+	XPointer /* client_data */
+);
+
+extern Bool XUnregisterIMInstantiateCallback(
+	Display* /* dpy */,
+	struct _XrmHashBucketRec* /* rdb */,
+	char* /* res_name */,
+	char* /* res_class */,
+	XIDProc /* callback */,
+	XPointer /* client_data */
+);
+
+typedef void (*XConnectionWatchProc)(
+	Display* /* dpy */,
+	XPointer /* client_data */,
+	int /* fd */,
+	Bool /* opening */,        /* open or close flag */
+	XPointer* /* watch_data */ /* open sets, close uses */
+);
+
+extern Status XInternalConnectionNumbers(
+	Display* /* dpy */,
+	int** /* fd_return */,
+	int* /* count_return */
+);
+
+extern void XProcessInternalConnection(
+	Display* /* dpy */,
+	int /* fd */
+);
+
+extern Status XAddConnectionWatch(
+	Display* /* dpy */,
+	XConnectionWatchProc /* callback */,
+	XPointer /* client_data */
+);
+
+extern void XRemoveConnectionWatch(
+	Display* /* dpy */,
+	XConnectionWatchProc /* callback */,
+	XPointer /* client_data */
+);
+
+extern void XSetAuthorization(
+	char* /* name */,
+	int /* namelen */,
+	char* /* data */,
+	int /* datalen */
+);
+
+extern int _Xmbtowc(
+	wchar_t* /* wstr */,
+#ifdef ISC
+	char const* /* str */,
+	size_t /* len */
+#else
+	char* /* str */,
+	int /* len */
+#endif
+);
+
+extern int _Xwctomb(
+	char* /* str */,
+	wchar_t /* wc */
+);
+
+extern Bool XGetEventData(
+	Display* /* dpy */,
+	XGenericEventCookie* /* cookie*/
+);
+
+extern void XFreeEventData(
+	Display* /* dpy */,
+	XGenericEventCookie* /* cookie*/
+);
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+_XFUNCPROTOEND
+
+#endif /* _X11_XLIB_H_ */
diff --git a/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/XlibConf.h b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/XlibConf.h
new file mode 100644
index 00000000..9f9b9403
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/XlibConf.h
@@ -0,0 +1,38 @@
+/* include/X11/XlibConf.h.  Generated from XlibConf.h.in by configure.  */
+/*
+ * Copyright © 2005 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef _XLIBCONF_H_
+#define _XLIBCONF_H_
+/*
+ * This header file exports defines necessary to correctly
+ * use Xlibint.h both inside Xlib and by external libraries
+ * such as extensions.
+ */
+
+/* Threading support? */
+#define XTHREADS 1
+
+/* Use multi-threaded libc functions? */
+#define XUSE_MTSAFE_API 1
+
+#endif /* _XLIBCONF_H_ */
diff --git a/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/Xlibint.h b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/Xlibint.h
new file mode 100644
index 00000000..f46bd1bd
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/Xlibint.h
@@ -0,0 +1,1346 @@
+
+/*
+
+Copyright 1984, 1985, 1987, 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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 OPEN GROUP 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.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+
+*/
+
+#ifndef _X11_XLIBINT_H_
+#define _X11_XLIBINT_H_ 1
+
+/*
+ *	Xlibint.h - Header definition and support file for the internal
+ *	support routines used by the C subroutine interface
+ *	library (Xlib) to the X Window System.
+ *
+ *	Warning, there be dragons here....
+ */
+
+#include <X11/Xlib.h>
+#include <X11/Xproto.h>   /* to declare xEvent */
+#include <X11/XlibConf.h> /* for configured options like XTHREADS */
+
+/* The Xlib structs are full of implicit padding to properly align members.
+   We can't clean that up without breaking ABI, so tell clang not to bother
+   complaining about it. */
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+#ifdef WIN32
+#define _XFlush _XFlushIt
+#endif
+
+/*
+ * If your BytesReadable correctly detects broken connections, then
+ * you should NOT define XCONN_CHECK_FREQ.
+ */
+#ifndef XCONN_CHECK_FREQ
+#define XCONN_CHECK_FREQ 256
+#endif
+
+struct _XGC
+{
+	XExtData* ext_data;  /* hook for extension to hang data */
+	GContext gid;        /* protocol ID for graphics context */
+	Bool rects;          /* boolean: TRUE if clipmask is list of rectangles */
+	Bool dashes;         /* boolean: TRUE if dash-list is really a list */
+	unsigned long dirty; /* cache dirty bits */
+	XGCValues values;    /* shadow structure of values */
+};
+
+struct _XDisplay
+{
+	XExtData* ext_data;             /* hook for extension to hang data */
+	struct _XFreeFuncs* free_funcs; /* internal free functions */
+	int fd;                         /* Network socket. */
+	int conn_checker;               /* ugly thing used by _XEventsQueued */
+	int proto_major_version;        /* maj. version of server's X protocol */
+	int proto_minor_version;        /* minor version of server's X protocol */
+	char* vendor;                   /* vendor of the server hardware */
+	XID resource_base;              /* resource ID base */
+	XID resource_mask;              /* resource ID mask bits */
+	XID resource_id;                /* allocator current ID */
+	int resource_shift;             /* allocator shift to correct bits */
+	XID(*resource_alloc)
+	(/* allocator function */
+	 struct _XDisplay*);
+	int byte_order;                  /* screen byte order, LSBFirst, MSBFirst */
+	int bitmap_unit;                 /* padding and data requirements */
+	int bitmap_pad;                  /* padding requirements on bitmaps */
+	int bitmap_bit_order;            /* LeastSignificant or MostSignificant */
+	int nformats;                    /* number of pixmap formats in list */
+	ScreenFormat* pixmap_format;     /* pixmap format list */
+	int vnumber;                     /* Xlib's X protocol version number. */
+	int release;                     /* release of the server */
+	struct _XSQEvent *head, *tail;   /* Input event queue. */
+	int qlen;                        /* Length of input event queue */
+	unsigned long last_request_read; /* seq number of last event read */
+	unsigned long request;           /* sequence number of last request. */
+	char* last_req;                  /* beginning of last request, or dummy */
+	char* buffer;                    /* Output buffer starting address. */
+	char* bufptr;                    /* Output buffer index pointer. */
+	char* bufmax;                    /* Output buffer maximum+1 address. */
+	unsigned max_request_size;       /* maximum number 32 bit words in request*/
+	struct _XrmHashBucketRec* db;
+	int (*synchandler)(/* Synchronization handler */
+					   struct _XDisplay*);
+	char* display_name;           /* "host:display" string used on this connect*/
+	int default_screen;           /* default screen for operations */
+	int nscreens;                 /* number of screens on this server*/
+	Screen* screens;              /* pointer to list of screens */
+	unsigned long motion_buffer;  /* size of motion buffer */
+	volatile unsigned long flags; /* internal connection flags */
+	int min_keycode;              /* minimum defined keycode */
+	int max_keycode;              /* maximum defined keycode */
+	KeySym* keysyms;              /* This server's keysyms */
+	XModifierKeymap* modifiermap; /* This server's modifier keymap */
+	int keysyms_per_keycode;      /* number of rows */
+	char* xdefaults;              /* contents of defaults from server */
+	char* scratch_buffer;         /* place to hang scratch buffer */
+	unsigned long scratch_length; /* length of scratch buffer */
+	int ext_number;               /* extension number on this display */
+	struct _XExten* ext_procs;    /* extensions initialized on this display */
+	/*
+	 * the following can be fixed size, as the protocol defines how
+	 * much address space is available.
+	 * While this could be done using the extension vector, there
+	 * may be MANY events processed, so a search through the extension
+	 * list to find the right procedure for each event might be
+	 * expensive if many extensions are being used.
+	 */
+	Bool (*event_vec[128])(/* vector for wire to event */
+						   Display* /* dpy */,
+						   XEvent* /* re */,
+						   xEvent* /* event */
+	);
+	Status (*wire_vec[128])(/* vector for event to wire */
+							Display* /* dpy */,
+							XEvent* /* re */,
+							xEvent* /* event */
+	);
+	KeySym lock_meaning;                    /* for XLookupString */
+	struct _XLockInfo* lock;                /* multi-thread state, display lock */
+	struct _XInternalAsync* async_handlers; /* for internal async */
+	unsigned long bigreq_size;              /* max size of big requests */
+	struct _XLockPtrs* lock_fns;            /* pointers to threads functions */
+	void (*idlist_alloc)(                   /* XID list allocator function */
+						 Display* /* dpy */,
+						 XID* /* ids */,
+						 int /* count */
+	);
+	/* things above this line should not move, for binary compatibility */
+	struct _XKeytrans* key_bindings; /* for XLookupString */
+	Font cursor_font;                /* for XCreateFontCursor */
+	struct _XDisplayAtoms* atoms;    /* for XInternAtom */
+	unsigned int mode_switch;        /* keyboard group modifiers */
+	unsigned int num_lock;           /* keyboard numlock modifiers */
+	struct _XContextDB* context_db;  /* context database */
+	Bool (**error_vec)(              /* vector for wire to error */
+					   Display* /* display */,
+					   XErrorEvent* /* he */,
+					   xError* /* we */
+	);
+	/*
+	 * Xcms information
+	 */
+	struct
+	{
+		XPointer defaultCCCs; /* pointer to an array of default XcmsCCC */
+		XPointer clientCmaps; /* pointer to linked list of XcmsCmapRec */
+		XPointer perVisualIntensityMaps;
+		/* linked list of XcmsIntensityMap */
+	} cms;
+	struct _XIMFilter* im_filters;
+	struct _XSQEvent* qfree;               /* unallocated event queue elements */
+	unsigned long next_event_serial_num;   /* inserted into next queue elt */
+	struct _XExten* flushes;               /* Flush hooks */
+	struct _XConnectionInfo* im_fd_info;   /* _XRegisterInternalConnection */
+	int im_fd_length;                      /* number of im_fd_info */
+	struct _XConnWatchInfo* conn_watchers; /* XAddConnectionWatch */
+	int watcher_count;                     /* number of conn_watchers */
+	XPointer filedes;                      /* struct pollfd cache for _XWaitForReadable */
+	int (*savedsynchandler)(               /* user synchandler when Xlib usurps */
+							Display*       /* dpy */
+	);
+	XID resource_max;                   /* allocator max ID */
+	int xcmisc_opcode;                  /* major opcode for XC-MISC */
+	struct _XkbInfoRec* xkb_info;       /* XKB info */
+	struct _XtransConnInfo* trans_conn; /* transport connection object */
+	struct _X11XCBPrivate* xcb;         /* XCB glue private data */
+
+	/* Generic event cookie handling */
+	unsigned int next_cookie; /* next event cookie */
+	/* vector for wire to generic event, index is (extension - 128) */
+	Bool (*generic_event_vec[128])(
+		Display* /* dpy */,
+		XGenericEventCookie* /* Xlib event */,
+		xEvent* /* wire event */);
+	/* vector for event copy, index is (extension - 128) */
+	Bool (*generic_event_copy_vec[128])(
+		Display* /* dpy */,
+		XGenericEventCookie* /* in */,
+		XGenericEventCookie* /* out*/);
+	void* cookiejar; /* cookie events returned but not claimed */
+};
+
+#define XAllocIDs(dpy, ids, n) (*(dpy)->idlist_alloc)(dpy, ids, n)
+
+#ifndef _XEVENT_
+/*
+ * _QEvent datatype for use in input queueing.
+ */
+typedef struct _XSQEvent
+{
+	struct _XSQEvent* next;
+	XEvent event;
+	unsigned long qserial_num; /* so multi-threaded code can find new ones */
+} _XQEvent;
+#endif
+
+#include <X11/Xproto.h>
+#ifdef __sgi
+#define _SGI_MP_SOURCE /* turn this on to get MP safe errno */
+#endif
+#include <errno.h>
+#define _XBCOPYFUNC _Xbcopy
+#include <X11/Xfuncs.h>
+#include <X11/Xosdefs.h>
+
+/* Utek leaves kernel macros around in include files (bleah) */
+#ifdef dirty
+#undef dirty
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <X11/Xfuncproto.h>
+
+_XFUNCPROTOBEGIN
+
+/*
+ * The following definitions can be used for locking requests in multi-threaded
+ * address spaces.
+ */
+#ifdef XTHREADS
+/* Author: Stephen Gildea, MIT X Consortium
+ *
+ * declarations for C Threads locking
+ */
+
+typedef struct _LockInfoRec* LockInfoPtr;
+
+/* interfaces for locking.c */
+struct _XLockPtrs
+{
+	/* used by all, including extensions; do not move */
+	void (*lock_display)(
+		Display* dpy
+#if defined(XTHREADS_WARN) || defined(XTHREADS_FILE_LINE)
+		,
+		char* file, int line
+#endif
+	);
+	void (*unlock_display)(
+		Display* dpy
+#if defined(XTHREADS_WARN) || defined(XTHREADS_FILE_LINE)
+		,
+		char* file, int line
+#endif
+	);
+};
+
+#if defined(WIN32) && !defined(_XLIBINT_)
+#define _XCreateMutex_fn (*_XCreateMutex_fn_p)
+#define _XFreeMutex_fn (*_XFreeMutex_fn_p)
+#define _XLockMutex_fn (*_XLockMutex_fn_p)
+#define _XUnlockMutex_fn (*_XUnlockMutex_fn_p)
+#define _Xglobal_lock (*_Xglobal_lock_p)
+#endif
+
+/* in XlibInt.c */
+extern void (*_XCreateMutex_fn)(
+	LockInfoPtr /* lock */
+);
+extern void (*_XFreeMutex_fn)(
+	LockInfoPtr /* lock */
+);
+extern void (*_XLockMutex_fn)(
+	LockInfoPtr /* lock */
+#if defined(XTHREADS_WARN) || defined(XTHREADS_FILE_LINE)
+	,
+	char* /* file */
+	,
+	int /* line */
+#endif
+);
+extern void (*_XUnlockMutex_fn)(
+	LockInfoPtr /* lock */
+#if defined(XTHREADS_WARN) || defined(XTHREADS_FILE_LINE)
+	,
+	char* /* file */
+	,
+	int /* line */
+#endif
+);
+
+extern LockInfoPtr _Xglobal_lock;
+
+#if defined(XTHREADS_WARN) || defined(XTHREADS_FILE_LINE)
+#define LockDisplay(d) \
+	if ((d)->lock_fns) (*(d)->lock_fns->lock_display)((d), __FILE__, __LINE__)
+#define UnlockDisplay(d) \
+	if ((d)->lock_fns) (*(d)->lock_fns->unlock_display)((d), __FILE__, __LINE__)
+#define _XLockMutex(lock) \
+	if (_XLockMutex_fn) (*_XLockMutex_fn)(lock, __FILE__, __LINE__)
+#define _XUnlockMutex(lock) \
+	if (_XUnlockMutex_fn) (*_XUnlockMutex_fn)(lock, __FILE__, __LINE__)
+#else
+/* used everywhere, so must be fast if not using threads */
+#define LockDisplay(d) \
+	if ((d)->lock_fns) (*(d)->lock_fns->lock_display)(d)
+#define UnlockDisplay(d) \
+	if ((d)->lock_fns) (*(d)->lock_fns->unlock_display)(d)
+#define _XLockMutex(lock) \
+	if (_XLockMutex_fn) (*_XLockMutex_fn)(lock)
+#define _XUnlockMutex(lock) \
+	if (_XUnlockMutex_fn) (*_XUnlockMutex_fn)(lock)
+#endif
+#define _XCreateMutex(lock) \
+	if (_XCreateMutex_fn) (*_XCreateMutex_fn)(lock);
+#define _XFreeMutex(lock) \
+	if (_XFreeMutex_fn) (*_XFreeMutex_fn)(lock);
+
+#else /* XTHREADS */
+#define LockDisplay(dis)
+#define _XLockMutex(lock)
+#define _XUnlockMutex(lock)
+#define UnlockDisplay(dis)
+#define _XCreateMutex(lock)
+#define _XFreeMutex(lock)
+#endif
+
+#define Xfree(ptr) free((ptr))
+
+/*
+ * Note that some machines do not return a valid pointer for malloc(0), in
+ * which case we provide an alternate under the control of the
+ * define MALLOC_0_RETURNS_NULL.  This is necessary because some
+ * Xlib code expects malloc(0) to return a valid pointer to storage.
+ */
+#if defined(MALLOC_0_RETURNS_NULL) || defined(__clang_analyzer__)
+
+#define Xmalloc(size) malloc(((size) == 0 ? 1 : (size)))
+#define Xrealloc(ptr, size) realloc((ptr), ((size) == 0 ? 1 : (size)))
+#define Xcalloc(nelem, elsize) calloc(((nelem) == 0 ? 1 : (nelem)), (elsize))
+
+#else
+
+#define Xmalloc(size) malloc((size))
+#define Xrealloc(ptr, size) realloc((ptr), (size))
+#define Xcalloc(nelem, elsize) calloc((nelem), (elsize))
+
+#endif
+
+#include <stddef.h>
+
+#define LOCKED 1
+#define UNLOCKED 0
+
+#ifndef BUFSIZE
+#define BUFSIZE 2048 /* X output buffer size. */
+#endif
+#ifndef PTSPERBATCH
+#define PTSPERBATCH 1024 /* point batching */
+#endif
+#ifndef WLNSPERBATCH
+#define WLNSPERBATCH 50 /* wide line batching */
+#endif
+#ifndef ZLNSPERBATCH
+#define ZLNSPERBATCH 1024 /* thin line batching */
+#endif
+#ifndef WRCTSPERBATCH
+#define WRCTSPERBATCH 10 /* wide line rectangle batching */
+#endif
+#ifndef ZRCTSPERBATCH
+#define ZRCTSPERBATCH 256 /* thin line rectangle batching */
+#endif
+#ifndef FRCTSPERBATCH
+#define FRCTSPERBATCH 256 /* filled rectangle batching */
+#endif
+#ifndef FARCSPERBATCH
+#define FARCSPERBATCH 256 /* filled arc batching */
+#endif
+#ifndef CURSORFONT
+#define CURSORFONT "cursor" /* standard cursor fonts */
+#endif
+
+/*
+ * Display flags
+ */
+#define XlibDisplayIOError (1L << 0)
+#define XlibDisplayClosing (1L << 1)
+#define XlibDisplayNoXkb (1L << 2)
+#define XlibDisplayPrivSync (1L << 3)
+#define XlibDisplayProcConni (1L << 4)  /* in _XProcessInternalConnection */
+#define XlibDisplayReadEvents (1L << 5) /* in _XReadEvents */
+#define XlibDisplayReply (1L << 5)      /* in _XReply */
+#define XlibDisplayWriting (1L << 6)    /* in _XFlushInt, _XSend */
+#define XlibDisplayDfltRMDB (1L << 7)   /* mark if RM db from XGetDefault */
+
+/*
+ * X Protocol packetizing macros.
+ */
+
+/* Leftover from CRAY support - was defined empty on all non-Cray systems */
+#define WORD64ALIGN
+
+/**
+ * Return a len-sized request buffer for the request type. This function may
+ * flush the output queue.
+ *
+ * @param dpy The display connection
+ * @param type The request type
+ * @param len Length of the request in bytes
+ *
+ * @returns A pointer to the request buffer with a few default values
+ * initialized.
+ */
+extern void* _XGetRequest(Display* dpy, CARD8 type, size_t len);
+
+/* GetReqSized is the same as GetReq but allows the caller to specify the
+ * size in bytes. 'sz' must be a multiple of 4! */
+
+#define GetReqSized(name, sz, req) \
+	req = (x##name##Req*)_XGetRequest(dpy, X_##name, sz)
+
+/*
+ * GetReq - Get the next available X request packet in the buffer and
+ * return it.
+ *
+ * "name" is the name of the request, e.g. CreatePixmap, OpenFont, etc.
+ * "req" is the name of the request pointer.
+ *
+ */
+
+#define GetReq(name, req) \
+	GetReqSized(name, SIZEOF(x##name##Req), req)
+
+/* GetReqExtra is the same as GetReq, but allocates "n" additional
+   bytes after the request. "n" must be a multiple of 4!  */
+
+#define GetReqExtra(name, n, req) \
+	GetReqSized(name, SIZEOF(x##name##Req) + n, req)
+
+/*
+ * GetResReq is for those requests that have a resource ID
+ * (Window, Pixmap, GContext, etc.) as their single argument.
+ * "rid" is the name of the resource.
+ */
+
+#define GetResReq(name, rid, req)                                           \
+	req = (xResourceReq*)_XGetRequest(dpy, X_##name, SIZEOF(xResourceReq)); \
+	req->id = (rid)
+
+/*
+ * GetEmptyReq is for those requests that have no arguments
+ * at all.
+ */
+
+#define GetEmptyReq(name, req) \
+	req = (xReq*)_XGetRequest(dpy, X_##name, SIZEOF(xReq))
+
+/*
+ * MakeBigReq sets the CARD16 "req->length" to 0 and inserts a new CARD32
+ * length, after req->length, before the data in the request.  The new length
+ * includes the "n" extra 32-bit words.
+ *
+ * Do not use MakeBigReq if there is no data already in the request.
+ * req->length must already be >= 2.
+ */
+#ifdef LONG64
+#define MakeBigReq(req, n)                                              \
+	{                                                                   \
+		CARD64 _BRdat;                                                  \
+		CARD32 _BRlen = req->length - 1;                                \
+		req->length = 0;                                                \
+		_BRdat = ((CARD32*)req)[_BRlen];                                \
+		memmove(((char*)req) + 8, ((char*)req) + 4, (_BRlen - 1) << 2); \
+		((CARD32*)req)[1] = _BRlen + n + 2;                             \
+		Data32(dpy, &_BRdat, 4);                                        \
+	}
+#else
+#define MakeBigReq(req, n)                                              \
+	{                                                                   \
+		CARD32 _BRdat;                                                  \
+		CARD32 _BRlen = req->length - 1;                                \
+		req->length = 0;                                                \
+		_BRdat = ((CARD32*)req)[_BRlen];                                \
+		memmove(((char*)req) + 8, ((char*)req) + 4, (_BRlen - 1) << 2); \
+		((CARD32*)req)[1] = _BRlen + n + 2;                             \
+		Data32(dpy, &_BRdat, 4);                                        \
+	}
+#endif
+
+/*
+ * SetReqLen increases the count of 32-bit words in the request by "n",
+ * or by "badlen" if "n" is too large.
+ *
+ * Do not use SetReqLen if "req" does not already have data after the
+ * xReq header.  req->length must already be >= 2.
+ */
+#ifndef __clang_analyzer__
+#define SetReqLen(req, n, badlen)            \
+	if ((req->length + n) > (unsigned)65535) \
+	{                                        \
+		if (dpy->bigreq_size)                \
+		{                                    \
+			MakeBigReq(req, n)               \
+		}                                    \
+		else                                 \
+		{                                    \
+			n = badlen;                      \
+			req->length += n;                \
+		}                                    \
+	}                                        \
+	else                                     \
+		req->length += n
+#else
+#define SetReqLen(req, n, badlen) \
+	req->length += n
+#endif
+
+#define SyncHandle() \
+	if (dpy->synchandler) (*dpy->synchandler)(dpy)
+
+extern void _XFlushGCCache(Display* dpy, GC gc);
+#define FlushGC(dpy, gc) \
+	if ((gc)->dirty) _XFlushGCCache((dpy), (gc))
+/*
+ * Data - Place data in the buffer and pad the end to provide
+ * 32 bit word alignment.  Transmit if the buffer fills.
+ *
+ * "dpy" is a pointer to a Display.
+ * "data" is a pointer to a data buffer.
+ * "len" is the length of the data buffer.
+ */
+#ifndef DataRoutineIsProcedure
+#define Data(dpy, data, len)                     \
+	{                                            \
+		if (dpy->bufptr + (len) <= dpy->bufmax)  \
+		{                                        \
+			memcpy(dpy->bufptr, data, (int)len); \
+			dpy->bufptr += ((len) + 3) & ~3;     \
+		}                                        \
+		else                                     \
+			_XSend(dpy, data, len);              \
+	}
+#endif /* DataRoutineIsProcedure */
+
+/* Allocate bytes from the buffer.  No padding is done, so if
+ * the length is not a multiple of 4, the caller must be
+ * careful to leave the buffer aligned after sending the
+ * current request.
+ *
+ * "type" is the type of the pointer being assigned to.
+ * "ptr" is the pointer being assigned to.
+ * "n" is the number of bytes to allocate.
+ *
+ * Example:
+ *    xTextElt *elt;
+ *    BufAlloc (xTextElt *, elt, nbytes)
+ */
+
+#define BufAlloc(type, ptr, n)           \
+	if (dpy->bufptr + (n) > dpy->bufmax) \
+		_XFlush(dpy);                    \
+	ptr = (type)dpy->bufptr;             \
+	memset(ptr, '\0', n);                \
+	dpy->bufptr += (n);
+
+#define Data16(dpy, data, len) Data((dpy), (_Xconst char*)(data), (len))
+#define _XRead16Pad(dpy, data, len) _XReadPad((dpy), (char*)(data), (len))
+#define _XRead16(dpy, data, len) _XRead((dpy), (char*)(data), (len))
+#ifdef LONG64
+#define Data32(dpy, data, len) _XData32(dpy, (_Xconst long*)data, len)
+extern int _XData32(
+	Display* dpy,
+	register _Xconst long* data,
+	unsigned len);
+extern void _XRead32(
+	Display* dpy,
+	register long* data,
+	long len);
+#else
+#define Data32(dpy, data, len) Data((dpy), (_Xconst char*)(data), (len))
+#define _XRead32(dpy, data, len) _XRead((dpy), (char*)(data), (len))
+#endif
+
+#define PackData16(dpy, data, len) Data16(dpy, data, len)
+#define PackData32(dpy, data, len) Data32(dpy, data, len)
+
+/* Xlib manual is bogus */
+#define PackData(dpy, data, len) PackData16(dpy, data, len)
+
+#define min(a, b) (((a) < (b)) ? (a) : (b))
+#define max(a, b) (((a) > (b)) ? (a) : (b))
+
+#define CI_NONEXISTCHAR(cs) (((cs)->width == 0) &&               \
+							 (((cs)->rbearing | (cs)->lbearing | \
+							   (cs)->ascent | (cs)->descent) == 0))
+
+/*
+ * CI_GET_CHAR_INFO_1D - return the charinfo struct for the indicated 8bit
+ * character.  If the character is in the column and exists, then return the
+ * appropriate metrics (note that fonts with common per-character metrics will
+ * return min_bounds).  If none of these hold true, try again with the default
+ * char.
+ */
+#define CI_GET_CHAR_INFO_1D(fs, col, def, cs)                             \
+	{                                                                     \
+		cs = def;                                                         \
+		if (col >= fs->min_char_or_byte2 && col <= fs->max_char_or_byte2) \
+		{                                                                 \
+			if (fs->per_char == NULL)                                     \
+			{                                                             \
+				cs = &fs->min_bounds;                                     \
+			}                                                             \
+			else                                                          \
+			{                                                             \
+				cs = &fs->per_char[(col - fs->min_char_or_byte2)];        \
+				if (CI_NONEXISTCHAR(cs)) cs = def;                        \
+			}                                                             \
+		}                                                                 \
+	}
+
+#define CI_GET_DEFAULT_INFO_1D(fs, cs) \
+	CI_GET_CHAR_INFO_1D(fs, fs->default_char, NULL, cs)
+
+/*
+ * CI_GET_CHAR_INFO_2D - return the charinfo struct for the indicated row and
+ * column.  This is used for fonts that have more than row zero.
+ */
+#define CI_GET_CHAR_INFO_2D(fs, row, col, def, cs)                        \
+	{                                                                     \
+		cs = def;                                                         \
+		if (row >= fs->min_byte1 && row <= fs->max_byte1 &&               \
+			col >= fs->min_char_or_byte2 && col <= fs->max_char_or_byte2) \
+		{                                                                 \
+			if (fs->per_char == NULL)                                     \
+			{                                                             \
+				cs = &fs->min_bounds;                                     \
+			}                                                             \
+			else                                                          \
+			{                                                             \
+				cs = &fs->per_char[((row - fs->min_byte1) *               \
+									(fs->max_char_or_byte2 -              \
+									 fs->min_char_or_byte2 + 1)) +        \
+								   (col - fs->min_char_or_byte2)];        \
+				if (CI_NONEXISTCHAR(cs)) cs = def;                        \
+			}                                                             \
+		}                                                                 \
+	}
+
+#define CI_GET_DEFAULT_INFO_2D(fs, cs)              \
+	{                                               \
+		unsigned int r = (fs->default_char >> 8);   \
+		unsigned int c = (fs->default_char & 0xff); \
+		CI_GET_CHAR_INFO_2D(fs, r, c, NULL, cs);    \
+	}
+
+/* srcvar must be a variable for large architecture version */
+#define OneDataCard32(dpy, dstaddr, srcvar) \
+	{                                       \
+		*(CARD32*)(dstaddr) = (srcvar);     \
+	}
+
+typedef struct _XInternalAsync
+{
+	struct _XInternalAsync* next;
+	/*
+     * handler arguments:
+     * rep is the generic reply that caused this handler
+     * to be invoked.  It must also be passed to _XGetAsyncReply.
+     * buf and len are opaque values that must be passed to
+     * _XGetAsyncReply or _XGetAsyncData.
+     * data is the closure stored in this struct.
+     * The handler returns True iff it handled this reply.
+     */
+	Bool (*handler)(
+		Display* /* dpy */,
+		xReply* /* rep */,
+		char* /* buf */,
+		int /* len */,
+		XPointer /* data */
+	);
+	XPointer data;
+} _XAsyncHandler;
+
+typedef struct _XAsyncEState
+{
+	unsigned long min_sequence_number;
+	unsigned long max_sequence_number;
+	unsigned char error_code;
+	unsigned char major_opcode;
+	unsigned short minor_opcode;
+	unsigned char last_error_received;
+	int error_count;
+} _XAsyncErrorState;
+
+extern void _XDeqAsyncHandler(Display* dpy, _XAsyncHandler* handler);
+#define DeqAsyncHandler(dpy, handler)              \
+	{                                              \
+		if (dpy->async_handlers == (handler))      \
+			dpy->async_handlers = (handler)->next; \
+		else                                       \
+			_XDeqAsyncHandler(dpy, handler);       \
+	}
+
+typedef void (*FreeFuncType)(
+	Display* /* display */
+);
+
+typedef int (*FreeModmapType)(
+	XModifierKeymap* /* modmap */
+);
+
+/*
+ * This structure is private to the library.
+ */
+typedef struct _XFreeFuncs
+{
+	FreeFuncType atoms;         /* _XFreeAtomTable */
+	FreeModmapType modifiermap; /* XFreeModifiermap */
+	FreeFuncType key_bindings;  /* _XFreeKeyBindings */
+	FreeFuncType context_db;    /* _XFreeContextDB */
+	FreeFuncType defaultCCCs;   /* _XcmsFreeDefaultCCCs */
+	FreeFuncType clientCmaps;   /* _XcmsFreeClientCmaps */
+	FreeFuncType intensityMaps; /* _XcmsFreeIntensityMaps */
+	FreeFuncType im_filters;    /* _XFreeIMFilters */
+	FreeFuncType xkb;           /* _XkbFreeInfo */
+} _XFreeFuncRec;
+
+/* types for InitExt.c */
+typedef int (*CreateGCType)(
+	Display* /* display */,
+	GC /* gc */,
+	XExtCodes* /* codes */
+);
+
+typedef int (*CopyGCType)(
+	Display* /* display */,
+	GC /* gc */,
+	XExtCodes* /* codes */
+);
+
+typedef int (*FlushGCType)(
+	Display* /* display */,
+	GC /* gc */,
+	XExtCodes* /* codes */
+);
+
+typedef int (*FreeGCType)(
+	Display* /* display */,
+	GC /* gc */,
+	XExtCodes* /* codes */
+);
+
+typedef int (*CreateFontType)(
+	Display* /* display */,
+	XFontStruct* /* fs */,
+	XExtCodes* /* codes */
+);
+
+typedef int (*FreeFontType)(
+	Display* /* display */,
+	XFontStruct* /* fs */,
+	XExtCodes* /* codes */
+);
+
+typedef int (*CloseDisplayType)(
+	Display* /* display */,
+	XExtCodes* /* codes */
+);
+
+typedef int (*ErrorType)(
+	Display* /* display */,
+	xError* /* err */,
+	XExtCodes* /* codes */,
+	int* /* ret_code */
+);
+
+typedef char* (*ErrorStringType)(
+	Display* /* display */,
+	int /* code */,
+	XExtCodes* /* codes */,
+	char* /* buffer */,
+	int /* nbytes */
+);
+
+typedef void (*PrintErrorType)(
+	Display* /* display */,
+	XErrorEvent* /* ev */,
+	void* /* fp */
+);
+
+typedef void (*BeforeFlushType)(
+	Display* /* display */,
+	XExtCodes* /* codes */,
+	_Xconst char* /* data */,
+	long /* len */
+);
+
+/*
+ * This structure is private to the library.
+ */
+typedef struct _XExten
+{                                   /* private to extension mechanism */
+	struct _XExten* next;           /* next in list */
+	XExtCodes codes;                /* public information, all extension told */
+	CreateGCType create_GC;         /* routine to call when GC created */
+	CopyGCType copy_GC;             /* routine to call when GC copied */
+	FlushGCType flush_GC;           /* routine to call when GC flushed */
+	FreeGCType free_GC;             /* routine to call when GC freed */
+	CreateFontType create_Font;     /* routine to call when Font created */
+	FreeFontType free_Font;         /* routine to call when Font freed */
+	CloseDisplayType close_display; /* routine to call when connection closed */
+	ErrorType error;                /* who to call when an error occurs */
+	ErrorStringType error_string;   /* routine to supply error string */
+	char* name;                     /* name of this extension */
+	PrintErrorType error_values;    /* routine to supply error values */
+	BeforeFlushType before_flush;   /* routine to call when sending data */
+	struct _XExten* next_flush;     /* next in list of those with flushes */
+} _XExtension;
+
+/* Temporary definition until we can depend on an xproto release with it */
+#ifdef _X_COLD
+#define _XLIB_COLD _X_COLD
+#elif defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 403) /* 4.3+ */
+#define _XLIB_COLD __attribute__((__cold__))
+#else
+#define _XLIB_COLD /* nothing */
+#endif
+
+/* extension hooks */
+
+#ifdef DataRoutineIsProcedure
+extern void Data(Display* dpy, char* data, long len);
+#endif
+extern int _XError(
+	Display* /* dpy */,
+	xError* /* rep */
+);
+extern int _XIOError(
+	Display* /* dpy */
+	) _X_NORETURN;
+extern int (*_XIOErrorFunction)(
+	Display* /* dpy */
+);
+extern int (*_XErrorFunction)(
+	Display* /* dpy */,
+	XErrorEvent* /* error_event */
+);
+extern void _XEatData(
+	Display* /* dpy */,
+	unsigned long /* n */
+	) _XLIB_COLD;
+extern void _XEatDataWords(
+	Display* /* dpy */,
+	unsigned long /* n */
+	) _XLIB_COLD;
+#if defined(__SUNPRO_C) /* Studio compiler alternative to "cold" attribute */
+#pragma rarely_called(_XEatData, _XEatDataWords)
+#endif
+extern char* _XAllocScratch(
+	Display* /* dpy */,
+	unsigned long /* nbytes */
+);
+extern char* _XAllocTemp(
+	Display* /* dpy */,
+	unsigned long /* nbytes */
+);
+extern void _XFreeTemp(
+	Display* /* dpy */,
+	char* /* buf */,
+	unsigned long /* nbytes */
+);
+extern Visual* _XVIDtoVisual(
+	Display* /* dpy */,
+	VisualID /* id */
+);
+extern unsigned long _XSetLastRequestRead(
+	Display* /* dpy */,
+	xGenericReply* /* rep */
+);
+extern int _XGetHostname(
+	char* /* buf */,
+	int /* maxlen */
+);
+extern Screen* _XScreenOfWindow(
+	Display* /* dpy */,
+	Window /* w */
+);
+extern Bool _XAsyncErrorHandler(
+	Display* /* dpy */,
+	xReply* /* rep */,
+	char* /* buf */,
+	int /* len */,
+	XPointer /* data */
+);
+extern char* _XGetAsyncReply(
+	Display* /* dpy */,
+	char* /* replbuf */,
+	xReply* /* rep */,
+	char* /* buf */,
+	int /* len */,
+	int /* extra */,
+	Bool /* discard */
+);
+extern void _XGetAsyncData(
+	Display* /* dpy */,
+	char* /* data */,
+	char* /* buf */,
+	int /* len */,
+	int /* skip */,
+	int /* datalen */,
+	int /* discardtotal */
+);
+extern void _XFlush(
+	Display* /* dpy */
+);
+extern int _XEventsQueued(
+	Display* /* dpy */,
+	int /* mode */
+);
+extern void _XReadEvents(
+	Display* /* dpy */
+);
+extern int _XRead(
+	Display* /* dpy */,
+	char* /* data */,
+	long /* size */
+);
+extern void _XReadPad(
+	Display* /* dpy */,
+	char* /* data */,
+	long /* size */
+);
+extern void _XSend(
+	Display* /* dpy */,
+	_Xconst char* /* data */,
+	long /* size */
+);
+extern Status _XReply(
+	Display* /* dpy */,
+	xReply* /* rep */,
+	int /* extra */,
+	Bool /* discard */
+);
+extern void _XEnq(
+	Display* /* dpy */,
+	xEvent* /* event */
+);
+extern void _XDeq(
+	Display* /* dpy */,
+	_XQEvent* /* prev */,
+	_XQEvent* /* qelt */
+);
+
+extern Bool _XUnknownWireEvent(
+	Display* /* dpy */,
+	XEvent* /* re */,
+	xEvent* /* event */
+);
+
+extern Bool _XUnknownWireEventCookie(
+	Display* /* dpy */,
+	XGenericEventCookie* /* re */,
+	xEvent* /* event */
+);
+
+extern Bool _XUnknownCopyEventCookie(
+	Display* /* dpy */,
+	XGenericEventCookie* /* in */,
+	XGenericEventCookie* /* out */
+);
+
+extern Status _XUnknownNativeEvent(
+	Display* /* dpy */,
+	XEvent* /* re */,
+	xEvent* /* event */
+);
+
+extern Bool _XWireToEvent(Display* dpy, XEvent* re, xEvent* event);
+extern Bool _XDefaultWireError(Display* display, XErrorEvent* he, xError* we);
+extern Bool _XPollfdCacheInit(Display* dpy);
+extern void _XPollfdCacheAdd(Display* dpy, int fd);
+extern void _XPollfdCacheDel(Display* dpy, int fd);
+extern XID _XAllocID(Display* dpy);
+extern void _XAllocIDs(Display* dpy, XID* ids, int count);
+
+extern int _XFreeExtData(
+	XExtData* /* extension */
+);
+
+extern int (*XESetCreateGC(
+	Display* /* display */,
+	int /* extension */,
+	int (*)(
+		Display* /* display */,
+		GC /* gc */,
+		XExtCodes* /* codes */
+		)          /* proc */
+	))(
+	Display*, GC, XExtCodes*);
+
+extern int (*XESetCopyGC(
+	Display* /* display */,
+	int /* extension */,
+	int (*)(
+		Display* /* display */,
+		GC /* gc */,
+		XExtCodes* /* codes */
+		)          /* proc */
+	))(
+	Display*, GC, XExtCodes*);
+
+extern int (*XESetFlushGC(
+	Display* /* display */,
+	int /* extension */,
+	int (*)(
+		Display* /* display */,
+		GC /* gc */,
+		XExtCodes* /* codes */
+		)          /* proc */
+	))(
+	Display*, GC, XExtCodes*);
+
+extern int (*XESetFreeGC(
+	Display* /* display */,
+	int /* extension */,
+	int (*)(
+		Display* /* display */,
+		GC /* gc */,
+		XExtCodes* /* codes */
+		)          /* proc */
+	))(
+	Display*, GC, XExtCodes*);
+
+extern int (*XESetCreateFont(
+	Display* /* display */,
+	int /* extension */,
+	int (*)(
+		Display* /* display */,
+		XFontStruct* /* fs */,
+		XExtCodes* /* codes */
+		)          /* proc */
+	))(
+	Display*, XFontStruct*, XExtCodes*);
+
+extern int (*XESetFreeFont(
+	Display* /* display */,
+	int /* extension */,
+	int (*)(
+		Display* /* display */,
+		XFontStruct* /* fs */,
+		XExtCodes* /* codes */
+		)          /* proc */
+	))(
+	Display*, XFontStruct*, XExtCodes*);
+
+extern int (*XESetCloseDisplay(
+	Display* /* display */,
+	int /* extension */,
+	int (*)(
+		Display* /* display */,
+		XExtCodes* /* codes */
+		)          /* proc */
+	))(
+	Display*, XExtCodes*);
+
+extern int (*XESetError(
+	Display* /* display */,
+	int /* extension */,
+	int (*)(
+		Display* /* display */,
+		xError* /* err */,
+		XExtCodes* /* codes */,
+		int* /* ret_code */
+		)    /* proc */
+	))(
+	Display*, xError*, XExtCodes*, int*);
+
+extern char* (*XESetErrorString(
+	Display* /* display */,
+	int /* extension */,
+	char* (*)(Display* /* display */,
+			  int /* code */,
+			  XExtCodes* /* codes */,
+			  char* /* buffer */,
+			  int /* nbytes */
+			  )   /* proc */
+	))(
+	Display*, int, XExtCodes*, char*, int);
+
+extern void (*XESetPrintErrorValues(
+	Display* /* display */,
+	int /* extension */,
+	void (*)(
+		Display* /* display */,
+		XErrorEvent* /* ev */,
+		void* /* fp */
+		)     /* proc */
+	))(
+	Display*, XErrorEvent*, void*);
+
+extern Bool (*XESetWireToEvent(
+	Display* /* display */,
+	int /* event_number */,
+	Bool (*)(
+		Display* /* display */,
+		XEvent* /* re */,
+		xEvent* /* event */
+		)       /* proc */
+	))(
+	Display*, XEvent*, xEvent*);
+
+extern Bool (*XESetWireToEventCookie(
+	Display* /* display */,
+	int /* extension */,
+	Bool (*)(
+		Display* /* display */,
+		XGenericEventCookie* /* re */,
+		xEvent* /* event */
+		)       /* proc */
+	))(
+	Display*, XGenericEventCookie*, xEvent*);
+
+extern Bool (*XESetCopyEventCookie(
+	Display* /* display */,
+	int /* extension */,
+	Bool (*)(
+		Display* /* display */,
+		XGenericEventCookie* /* in */,
+		XGenericEventCookie* /* out */
+		)                    /* proc */
+	))(
+	Display*, XGenericEventCookie*, XGenericEventCookie*);
+
+extern Status (*XESetEventToWire(
+	Display* /* display */,
+	int /* event_number */,
+	Status (*)(
+		Display* /* display */,
+		XEvent* /* re */,
+		xEvent* /* event */
+		)       /* proc */
+	))(
+	Display*, XEvent*, xEvent*);
+
+extern Bool (*XESetWireToError(
+	Display* /* display */,
+	int /* error_number */,
+	Bool (*)(
+		Display* /* display */,
+		XErrorEvent* /* he */,
+		xError* /* we */
+		)       /* proc */
+	))(
+	Display*, XErrorEvent*, xError*);
+
+extern void (*XESetBeforeFlush(
+	Display* /* display */,
+	int /* error_number */,
+	void (*)(
+		Display* /* display */,
+		XExtCodes* /* codes */,
+		_Xconst char* /* data */,
+		long /* len */
+		)    /* proc */
+	))(
+	Display*, XExtCodes*, _Xconst char*, long);
+
+/* internal connections for IMs */
+
+typedef void (*_XInternalConnectionProc)(
+	Display* /* dpy */,
+	int /* fd */,
+	XPointer /* call_data */
+);
+
+extern Status _XRegisterInternalConnection(
+	Display* /* dpy */,
+	int /* fd */,
+	_XInternalConnectionProc /* callback */,
+	XPointer /* call_data */
+);
+
+extern void _XUnregisterInternalConnection(
+	Display* /* dpy */,
+	int /* fd */
+);
+
+extern void _XProcessInternalConnection(
+	Display* /* dpy */,
+	struct _XConnectionInfo* /* conn_info */
+);
+
+/* Display structure has pointers to these */
+
+struct _XConnectionInfo
+{ /* info from _XRegisterInternalConnection */
+	int fd;
+	_XInternalConnectionProc read_callback;
+	XPointer call_data;
+	XPointer* watch_data; /* set/used by XConnectionWatchProc */
+	struct _XConnectionInfo* next;
+};
+
+struct _XConnWatchInfo
+{ /* info from XAddConnectionWatch */
+	XConnectionWatchProc fn;
+	XPointer client_data;
+	struct _XConnWatchInfo* next;
+};
+
+#ifdef __UNIXOS2__
+extern char* __XOS2RedirRoot(
+	char*);
+#endif
+
+extern int _XTextHeight(
+	XFontStruct* /* font_struct */,
+	_Xconst char* /* string */,
+	int /* count */
+);
+
+extern int _XTextHeight16(
+	XFontStruct* /* font_struct */,
+	_Xconst XChar2b* /* string */,
+	int /* count */
+);
+
+#if defined(WIN32)
+
+extern int _XOpenFile(
+	_Xconst char* /* path */,
+	int /* flags */
+);
+
+extern int _XOpenFileMode(
+	_Xconst char* /* path */,
+	int /* flags */,
+	mode_t /* mode */
+);
+
+extern void* _XFopenFile(
+	_Xconst char* /* path */,
+	_Xconst char* /* mode */
+);
+
+extern int _XAccessFile(
+	_Xconst char* /* path */
+);
+#else
+#define _XOpenFile(path, flags) open(path, flags)
+#define _XOpenFileMode(path, flags, mode) open(path, flags, mode)
+#define _XFopenFile(path, mode) fopen(path, mode)
+#endif
+
+/* EvToWire.c */
+extern Status _XEventToWire(Display* dpy, XEvent* re, xEvent* event);
+
+extern int _XF86LoadQueryLocaleFont(
+	Display* /* dpy */,
+	_Xconst char* /* name*/,
+	XFontStruct** /* xfp*/,
+	Font* /* fidp */
+);
+
+extern void _XProcessWindowAttributes(
+	register Display* dpy,
+	xChangeWindowAttributesReq* req,
+	register unsigned long valuemask,
+	register XSetWindowAttributes* attributes);
+
+extern int _XDefaultError(
+	Display* dpy,
+	XErrorEvent* event);
+
+extern int _XDefaultIOError(
+	Display* dpy);
+
+extern void _XSetClipRectangles(
+	register Display* dpy,
+	GC gc,
+	int clip_x_origin, int clip_y_origin,
+	XRectangle* rectangles,
+	int n,
+	int ordering);
+
+Status _XGetWindowAttributes(
+	register Display* dpy,
+	Window w,
+	XWindowAttributes* attr);
+
+int _XPutBackEvent(
+	register Display* dpy,
+	register XEvent* event);
+
+extern Bool _XIsEventCookie(
+	Display* dpy,
+	XEvent* ev);
+
+extern void _XFreeEventCookies(
+	Display* dpy);
+
+extern void _XStoreEventCookie(
+	Display* dpy,
+	XEvent* ev);
+
+extern Bool _XFetchEventCookie(
+	Display* dpy,
+	XGenericEventCookie* ev);
+
+extern Bool _XCopyEventCookie(
+	Display* dpy,
+	XGenericEventCookie* in,
+	XGenericEventCookie* out);
+
+/* lcFile.c */
+
+extern void xlocaledir(
+	char* buf,
+	int buf_len);
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+_XFUNCPROTOEND
+
+#endif /* _X11_XLIBINT_H_ */
diff --git a/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/Xmd.h b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/Xmd.h
new file mode 100644
index 00000000..874f5510
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/Xmd.h
@@ -0,0 +1,185 @@
+/***********************************************************
+
+Copyright 1987, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+#ifndef XMD_H
+#define XMD_H 1
+/*
+ *  Xmd.h: MACHINE DEPENDENT DECLARATIONS.
+ */
+
+/*
+ * Special per-machine configuration flags.
+ */
+#if defined(__sun) && defined(__SVR4)
+#include <sys/isa_defs.h> /* Solaris: defines _LP64 if necessary */
+#endif
+
+#if defined(_LP64) || defined(__LP64__) ||    \
+	defined(__alpha) || defined(__alpha__) || \
+	defined(__ia64__) || defined(ia64) ||     \
+	defined(__sparc64__) ||                   \
+	defined(__s390x__) ||                     \
+	defined(__amd64__) || defined(amd64) ||   \
+	defined(__powerpc64__) ||                 \
+	defined(__e2k__)
+#if !defined(__ILP32__) /* amd64-x32 is 32bit */
+#define LONG64          /* 32/64-bit architecture */
+#endif                  /* !__ILP32__ */
+#endif
+
+/*
+ * Stuff to handle large architecture machines; the constants were generated
+ * on a 32-bit machine and must correspond to the protocol.
+ */
+#ifdef WORD64
+#define MUSTCOPY
+#endif /* WORD64 */
+
+/*
+ * Definition of macro used to set constants for size of network structures;
+ * machines with preprocessors that can't handle all of the sz_ symbols
+ * can define this macro to be sizeof(x) if and only if their compiler doesn't
+ * pad out structures (esp. the xTextElt structure which contains only two
+ * one-byte fields).  Network structures should always define sz_symbols.
+ *
+ * The sz_ prefix is used instead of something more descriptive so that the
+ * symbols are no more than 32 characters long (which causes problems for some
+ * compilers and preprocessors).
+ *
+ * The extra indirection is to get macro arguments to expand correctly before
+ * the concatenation, rather than afterward.
+ */
+#define _SIZEOF(x) sz_##x
+#define SIZEOF(x) _SIZEOF(x)
+
+/*
+ * Bitfield suffixes for the protocol structure elements, if you
+ * need them.  Note that bitfields are not guaranteed to be signed
+ * (or even unsigned) according to ANSI C.
+ */
+#ifdef WORD64
+typedef long INT64;
+typedef unsigned long CARD64;
+#define B32 :32
+#define B16 :16
+#ifdef UNSIGNEDBITFIELDS
+typedef unsigned int INT32;
+typedef unsigned int INT16;
+#else
+typedef signed int INT32;
+typedef signed int INT16;
+#endif
+#else
+#define B32
+#define B16
+#ifdef LONG64
+typedef long INT64;
+typedef int INT32;
+#else
+typedef long INT32;
+#endif
+typedef short INT16;
+#endif
+
+typedef signed char INT8;
+
+#ifdef LONG64
+typedef unsigned long CARD64;
+typedef unsigned int CARD32;
+#else
+typedef unsigned long CARD32;
+#endif
+#if !defined(WORD64) && !defined(LONG64)
+typedef unsigned long long CARD64;
+#endif
+typedef unsigned short CARD16;
+typedef unsigned char CARD8;
+
+typedef CARD32 BITS32;
+typedef CARD16 BITS16;
+
+typedef CARD8 BYTE;
+typedef CARD8 BOOL;
+
+/*
+ * definitions for sign-extending bitfields on 64-bit architectures
+ */
+#if defined(WORD64) && defined(UNSIGNEDBITFIELDS)
+#define cvtINT8toInt(val) (((val)&0x00000080) ? ((val) | 0xffffffffffffff00) : (val))
+#define cvtINT16toInt(val) (((val)&0x00008000) ? ((val) | 0xffffffffffff0000) : (val))
+#define cvtINT32toInt(val) (((val)&0x80000000) ? ((val) | 0xffffffff00000000) : (val))
+#define cvtINT8toShort(val) cvtINT8toInt(val)
+#define cvtINT16toShort(val) cvtINT16toInt(val)
+#define cvtINT32toShort(val) cvtINT32toInt(val)
+#define cvtINT8toLong(val) cvtINT8toInt(val)
+#define cvtINT16toLong(val) cvtINT16toInt(val)
+#define cvtINT32toLong(val) cvtINT32toInt(val)
+#else
+#define cvtINT8toInt(val) (val)
+#define cvtINT16toInt(val) (val)
+#define cvtINT32toInt(val) (val)
+#define cvtINT8toShort(val) (val)
+#define cvtINT16toShort(val) (val)
+#define cvtINT32toShort(val) (val)
+#define cvtINT8toLong(val) (val)
+#define cvtINT16toLong(val) (val)
+#define cvtINT32toLong(val) (val)
+#endif /* WORD64 and UNSIGNEDBITFIELDS */
+
+#ifdef MUSTCOPY
+/*
+ * This macro must not cast or else pointers will get aligned and be wrong
+ */
+#define NEXTPTR(p, t) (((char *)p) + SIZEOF(t))
+#else /* else not MUSTCOPY, this is used for 32-bit machines */
+/*
+ * this version should leave result of type (t *), but that should only be
+ * used when not in MUSTCOPY
+ */
+#define NEXTPTR(p, t) (((t *)(p)) + 1)
+#endif /* MUSTCOPY - used machines whose C structs don't line up with proto */
+
+#endif /* XMD_H */
diff --git a/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/Xosdefs.h b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/Xosdefs.h
new file mode 100644
index 00000000..6314a809
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/Xosdefs.h
@@ -0,0 +1,112 @@
+/*
+ * O/S-dependent (mis)feature macro definitions
+ *
+Copyright 1991, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+ */
+
+#ifndef _XOSDEFS_H_
+#define _XOSDEFS_H_
+
+/*
+ * X_NOT_POSIX means does not have POSIX header files.  Lack of this
+ * symbol does NOT mean that the POSIX environment is the default.
+ * You may still have to define _POSIX_SOURCE to get it.
+ */
+
+#ifdef _SCO_DS
+#ifndef __SCO__
+#define __SCO__
+#endif
+#endif
+
+#ifdef __i386__
+#ifdef SYSV
+#if !defined(__SCO__) && \
+	!defined(__UNIXWARE__) && !defined(__sun)
+#if !defined(_POSIX_SOURCE)
+#define X_NOT_POSIX
+#endif
+#endif
+#endif
+#endif
+
+#ifdef __sun
+/* Imake configs define SVR4 on Solaris, but cc & gcc only define __SVR4
+ * This check allows non-Imake configured programs to build correctly.
+ */
+#if defined(__SVR4) && !defined(SVR4)
+#define SVR4 1
+#endif
+#ifdef SVR4
+/* define this to whatever it needs to be */
+#define X_POSIX_C_SOURCE 199300L
+#endif
+#endif
+
+#ifdef WIN32
+#ifndef _POSIX_
+#define X_NOT_POSIX
+#endif
+#endif
+
+#ifdef __APPLE__
+#define NULL_NOT_ZERO
+
+/* Defining any of these will sanitize the namespace to JUST want is defined by
+ * that particular standard.  If that happens, we don't get some expected
+ * prototypes, typedefs, etc (like fd_mask).  We can define _DARWIN_C_SOURCE to
+ * loosen our belts a tad.
+ */
+#if defined(_XOPEN_SOURCE) || defined(_POSIX_SOURCE) || defined(_POSIX_C_SOURCE)
+#ifndef _DARWIN_C_SOURCE
+#define _DARWIN_C_SOURCE
+#endif
+#endif
+
+#endif
+
+#ifdef __GNU__
+#ifndef PATH_MAX
+#define PATH_MAX 4096
+#endif
+#ifndef MAXPATHLEN
+#define MAXPATHLEN 4096
+#endif
+#endif
+
+#if defined(__SCO__) || defined(__UNIXWARE__)
+#ifndef PATH_MAX
+#define PATH_MAX 1024
+#endif
+#ifndef MAXPATHLEN
+#define MAXPATHLEN 1024
+#endif
+#endif
+
+#if defined(__OpenBSD__) || defined(__NetBSD__) || defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
+#ifndef CSRG_BASED
+#define CSRG_BASED
+#endif
+#endif
+
+#endif /* _XOSDEFS_H_ */
diff --git a/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/Xproto.h b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/Xproto.h
new file mode 100644
index 00000000..5c2b3d90
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/Xproto.h
@@ -0,0 +1,2298 @@
+/* Definitions for the X window system used by server and c bindings */
+
+/*
+ * This packet-construction scheme makes the following assumptions:
+ *
+ * 1. The compiler is able
+ * to generate code which addresses one- and two-byte quantities.
+ * In the worst case, this would be done with bit-fields.  If bit-fields
+ * are used it may be necessary to reorder the request fields in this file,
+ * depending on the order in which the machine assigns bit fields to
+ * machine words.  There may also be a problem with sign extension,
+ * as K+R specify that bitfields are always unsigned.
+ *
+ * 2. 2- and 4-byte fields in packet structures must be ordered by hand
+ * such that they are naturally-aligned, so that no compiler will ever
+ * insert padding bytes.
+ *
+ * 3. All packets are hand-padded to a multiple of 4 bytes, for
+ * the same reason.
+ */
+
+#ifndef XPROTO_H
+#define XPROTO_H
+
+/***********************************************************
+
+Copyright 1987, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its 
+documentation for any purpose and without fee is hereby granted, 
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in 
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.  
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+
+#include <X11/Xmd.h>
+#include <X11/Xprotostr.h>
+
+/*
+ * Define constants for the sizes of the network packets.  The sz_ prefix is
+ * used instead of something more descriptive so that the symbols are no more
+ * than 32 characters in length (which causes problems for some compilers).
+ */
+#define sz_xSegment 8
+#define sz_xPoint 4
+#define sz_xRectangle 8
+#define sz_xArc 12
+#define sz_xConnClientPrefix 12
+#define sz_xConnSetupPrefix 8
+#define sz_xConnSetup 32
+#define sz_xPixmapFormat 8
+#define sz_xDepth 8
+#define sz_xVisualType 24
+#define sz_xWindowRoot 40
+#define sz_xTimecoord 8
+#define sz_xHostEntry 4
+#define sz_xCharInfo 12
+#define sz_xFontProp 8
+#define sz_xTextElt 2
+#define sz_xColorItem 12
+#define sz_xrgb 8
+#define sz_xGenericReply 32
+#define sz_xGetWindowAttributesReply 44
+#define sz_xGetGeometryReply 32
+#define sz_xQueryTreeReply 32
+#define sz_xInternAtomReply 32
+#define sz_xGetAtomNameReply 32
+#define sz_xGetPropertyReply 32
+#define sz_xListPropertiesReply 32
+#define sz_xGetSelectionOwnerReply 32
+#define sz_xGrabPointerReply 32
+#define sz_xQueryPointerReply 32
+#define sz_xGetMotionEventsReply 32
+#define sz_xTranslateCoordsReply 32
+#define sz_xGetInputFocusReply 32
+#define sz_xQueryKeymapReply 40
+#define sz_xQueryFontReply 60
+#define sz_xQueryTextExtentsReply 32
+#define sz_xListFontsReply 32
+#define sz_xGetFontPathReply 32
+#define sz_xGetImageReply 32
+#define sz_xListInstalledColormapsReply 32
+#define sz_xAllocColorReply 32
+#define sz_xAllocNamedColorReply 32
+#define sz_xAllocColorCellsReply 32
+#define sz_xAllocColorPlanesReply 32
+#define sz_xQueryColorsReply 32
+#define sz_xLookupColorReply 32
+#define sz_xQueryBestSizeReply 32
+#define sz_xQueryExtensionReply 32
+#define sz_xListExtensionsReply 32
+#define sz_xSetMappingReply 32
+#define sz_xGetKeyboardControlReply 52
+#define sz_xGetPointerControlReply 32
+#define sz_xGetScreenSaverReply 32
+#define sz_xListHostsReply 32
+#define sz_xSetModifierMappingReply 32
+#define sz_xError 32
+#define sz_xEvent 32
+#define sz_xKeymapEvent 32
+#define sz_xReq 4
+#define sz_xResourceReq 8
+#define sz_xCreateWindowReq 32
+#define sz_xChangeWindowAttributesReq 12
+#define sz_xChangeSaveSetReq 8
+#define sz_xReparentWindowReq 16
+#define sz_xConfigureWindowReq 12
+#define sz_xCirculateWindowReq 8
+#define sz_xInternAtomReq 8
+#define sz_xChangePropertyReq 24
+#define sz_xDeletePropertyReq 12
+#define sz_xGetPropertyReq 24
+#define sz_xSetSelectionOwnerReq 16
+#define sz_xConvertSelectionReq 24
+#define sz_xSendEventReq 44
+#define sz_xGrabPointerReq 24
+#define sz_xGrabButtonReq 24
+#define sz_xUngrabButtonReq 12
+#define sz_xChangeActivePointerGrabReq 16
+#define sz_xGrabKeyboardReq 16
+#define sz_xGrabKeyReq 16
+#define sz_xUngrabKeyReq 12
+#define sz_xAllowEventsReq 8
+#define sz_xGetMotionEventsReq 16
+#define sz_xTranslateCoordsReq 16
+#define sz_xWarpPointerReq 24
+#define sz_xSetInputFocusReq 12
+#define sz_xOpenFontReq 12
+#define sz_xQueryTextExtentsReq 8
+#define sz_xListFontsReq 8
+#define sz_xSetFontPathReq 8
+#define sz_xCreatePixmapReq 16
+#define sz_xCreateGCReq 16
+#define sz_xChangeGCReq 12
+#define sz_xCopyGCReq 16
+#define sz_xSetDashesReq 12
+#define sz_xSetClipRectanglesReq 12
+#define sz_xCopyAreaReq 28
+#define sz_xCopyPlaneReq 32
+#define sz_xPolyPointReq 12
+#define sz_xPolySegmentReq 12
+#define sz_xFillPolyReq 16
+#define sz_xPutImageReq 24
+#define sz_xGetImageReq 20
+#define sz_xPolyTextReq 16
+#define sz_xImageTextReq 16
+#define sz_xCreateColormapReq 16
+#define sz_xCopyColormapAndFreeReq 12
+#define sz_xAllocColorReq 16
+#define sz_xAllocNamedColorReq 12
+#define sz_xAllocColorCellsReq 12
+#define sz_xAllocColorPlanesReq 16
+#define sz_xFreeColorsReq 12
+#define sz_xStoreColorsReq 8
+#define sz_xStoreNamedColorReq 16
+#define sz_xQueryColorsReq 8
+#define sz_xLookupColorReq 12
+#define sz_xCreateCursorReq 32
+#define sz_xCreateGlyphCursorReq 32
+#define sz_xRecolorCursorReq 20
+#define sz_xQueryBestSizeReq 12
+#define sz_xQueryExtensionReq 8
+#define sz_xChangeKeyboardControlReq 8
+#define sz_xBellReq 4
+#define sz_xChangePointerControlReq 12
+#define sz_xSetScreenSaverReq 12
+#define sz_xChangeHostsReq 8
+#define sz_xListHostsReq 4
+#define sz_xChangeModeReq 4
+#define sz_xRotatePropertiesReq 12
+#define sz_xReply 32
+#define sz_xGrabKeyboardReply 32
+#define sz_xListFontsWithInfoReply 60
+#define sz_xSetPointerMappingReply 32
+#define sz_xGetKeyboardMappingReply 32
+#define sz_xGetPointerMappingReply 32
+#define sz_xGetModifierMappingReply 32
+#define sz_xListFontsWithInfoReq 8
+#define sz_xPolyLineReq 12
+#define sz_xPolyArcReq 12
+#define sz_xPolyRectangleReq 12
+#define sz_xPolyFillRectangleReq 12
+#define sz_xPolyFillArcReq 12
+#define sz_xPolyText8Req 16
+#define sz_xPolyText16Req 16
+#define sz_xImageText8Req 16
+#define sz_xImageText16Req 16
+#define sz_xSetPointerMappingReq 4
+#define sz_xForceScreenSaverReq 4
+#define sz_xSetCloseDownModeReq 4
+#define sz_xClearAreaReq 16
+#define sz_xSetAccessControlReq 4
+#define sz_xGetKeyboardMappingReq 8
+#define sz_xSetModifierMappingReq 4
+#define sz_xPropIconSize 24
+#define sz_xChangeKeyboardMappingReq 8
+
+/* For the purpose of the structure definitions in this file,
+we must redefine the following types in terms of Xmd.h's types, which may
+include bit fields.  All of these are #undef'd at the end of this file,
+restoring the definitions in X.h.  */
+
+#define Window CARD32
+#define Drawable CARD32
+#define Font CARD32
+#define Pixmap CARD32
+#define Cursor CARD32
+#define Colormap CARD32
+#define GContext CARD32
+#define Atom CARD32
+#define VisualID CARD32
+#define Time CARD32
+#define KeyCode CARD8
+#define KeySym CARD32
+
+#define X_TCP_PORT 6000 /* add display number */
+
+#define xTrue 1
+#define xFalse 0
+
+typedef CARD16 KeyButMask;
+
+/***************** 
+   connection setup structure.  This is followed by
+   numRoots xWindowRoot structs.
+*****************/
+
+typedef struct
+{
+	CARD8 byteOrder;
+	BYTE pad;
+	CARD16 majorVersion B16, minorVersion B16;
+	CARD16 nbytesAuthProto B16;  /* Authorization protocol */
+	CARD16 nbytesAuthString B16; /* Authorization string */
+	CARD16 pad2 B16;
+} xConnClientPrefix;
+
+typedef struct
+{
+	CARD8 success;
+	BYTE lengthReason; /*num bytes in string following if failure */
+	CARD16 majorVersion B16,
+		minorVersion B16;
+	CARD16 length B16; /* 1/4 additional bytes in setup info */
+} xConnSetupPrefix;
+
+typedef struct
+{
+	CARD32 release B32;
+	CARD32 ridBase B32,
+		ridMask B32;
+	CARD32 motionBufferSize B32;
+	CARD16 nbytesVendor B16; /* number of bytes in vendor string */
+	CARD16 maxRequestSize B16;
+	CARD8 numRoots;           /* number of roots structs to follow */
+	CARD8 numFormats;         /* number of pixmap formats */
+	CARD8 imageByteOrder;     /* LSBFirst, MSBFirst */
+	CARD8 bitmapBitOrder;     /* LeastSignificant, MostSign...*/
+	CARD8 bitmapScanlineUnit, /* 8, 16, 32 */
+		bitmapScanlinePad;    /* 8, 16, 32 */
+	KeyCode minKeyCode, maxKeyCode;
+	CARD32 pad2 B32;
+} xConnSetup;
+
+typedef struct
+{
+	CARD8 depth;
+	CARD8 bitsPerPixel;
+	CARD8 scanLinePad;
+	CARD8 pad1;
+	CARD32 pad2 B32;
+} xPixmapFormat;
+
+/* window root */
+
+typedef struct
+{
+	CARD8 depth;
+	CARD8 pad1;
+	CARD16 nVisuals B16; /* number of xVisualType structures following */
+	CARD32 pad2 B32;
+} xDepth;
+
+typedef struct
+{
+	VisualID visualID B32;
+#if defined(__cplusplus) || defined(c_plusplus)
+	CARD8 c_class;
+#else
+	CARD8 class;
+#endif
+	CARD8 bitsPerRGB;
+	CARD16 colormapEntries B16;
+	CARD32 redMask B32, greenMask B32, blueMask B32;
+	CARD32 pad B32;
+} xVisualType;
+
+typedef struct
+{
+	Window windowId B32;
+	Colormap defaultColormap B32;
+	CARD32 whitePixel B32, blackPixel B32;
+	CARD32 currentInputMask B32;
+	CARD16 pixWidth B16, pixHeight B16;
+	CARD16 mmWidth B16, mmHeight B16;
+	CARD16 minInstalledMaps B16, maxInstalledMaps B16;
+	VisualID rootVisualID B32;
+	CARD8 backingStore;
+	BOOL saveUnders;
+	CARD8 rootDepth;
+	CARD8 nDepths; /* number of xDepth structures following */
+} xWindowRoot;
+
+/*****************************************************************
+ * Structure Defns
+ *   Structures needed for replies 
+ *****************************************************************/
+
+/* Used in GetMotionEvents */
+
+typedef struct
+{
+	CARD32 time B32;
+	INT16 x B16, y B16;
+} xTimecoord;
+
+typedef struct
+{
+	CARD8 family;
+	BYTE pad;
+	CARD16 length B16;
+} xHostEntry;
+
+typedef struct
+{
+	INT16 leftSideBearing B16,
+		rightSideBearing B16,
+		characterWidth B16,
+		ascent B16,
+		descent B16;
+	CARD16 attributes B16;
+} xCharInfo;
+
+typedef struct
+{
+	Atom name B32;
+	CARD32 value B32;
+} xFontProp;
+
+/*
+ * non-aligned big-endian font ID follows this struct
+ */
+typedef struct
+{              /* followed by string */
+	CARD8 len; /* number of *characters* in string, or FontChange (255)
+		   for font change, or 0 if just delta given */
+	INT8 delta;
+} xTextElt;
+
+typedef struct
+{
+	CARD32 pixel B32;
+	CARD16 red B16, green B16, blue B16;
+	CARD8 flags; /* DoRed, DoGreen, DoBlue booleans */
+	CARD8 pad;
+} xColorItem;
+
+typedef struct
+{
+	CARD16 red B16, green B16, blue B16, pad B16;
+} xrgb;
+
+typedef CARD8 KEYCODE;
+
+/*****************
+ * XRep:
+ *    meant to be 32 byte quantity 
+ *****************/
+
+/* GenericReply is the common format of all replies.  The "data" items
+   are specific to each individual reply type. */
+
+typedef struct
+{
+	BYTE type;                 /* X_Reply */
+	BYTE data1;                /* depends on reply type */
+	CARD16 sequenceNumber B16; /* of last request received by server */
+	CARD32 length B32;         /* 4 byte quantities beyond size of GenericReply */
+	CARD32 data00 B32;
+	CARD32 data01 B32;
+	CARD32 data02 B32;
+	CARD32 data03 B32;
+	CARD32 data04 B32;
+	CARD32 data05 B32;
+} xGenericReply;
+
+/* Individual reply formats. */
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	CARD8 backingStore;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32; /* NOT 0; this is an extra-large reply */
+	VisualID visualID B32;
+#if defined(__cplusplus) || defined(c_plusplus)
+	CARD16 c_class B16;
+#else
+	CARD16 class B16;
+#endif
+	CARD8 bitGravity;
+	CARD8 winGravity;
+	CARD32 backingBitPlanes B32;
+	CARD32 backingPixel B32;
+	BOOL saveUnder;
+	BOOL mapInstalled;
+	CARD8 mapState;
+	BOOL override;
+	Colormap colormap B32;
+	CARD32 allEventMasks B32;
+	CARD32 yourEventMask B32;
+	CARD16 doNotPropagateMask B16;
+	CARD16 pad B16;
+} xGetWindowAttributesReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	CARD8 depth;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32; /* 0 */
+	Window root B32;
+	INT16 x B16, y B16;
+	CARD16 width B16, height B16;
+	CARD16 borderWidth B16;
+	CARD16 pad1 B16;
+	CARD32 pad2 B32;
+	CARD32 pad3 B32;
+} xGetGeometryReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	BYTE pad1;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32;
+	Window root B32, parent B32;
+	CARD16 nChildren B16;
+	CARD16 pad2 B16;
+	CARD32 pad3 B32;
+	CARD32 pad4 B32;
+	CARD32 pad5 B32;
+} xQueryTreeReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	BYTE pad1;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32; /* 0 */
+	Atom atom B32;
+	CARD32 pad2 B32;
+	CARD32 pad3 B32;
+	CARD32 pad4 B32;
+	CARD32 pad5 B32;
+	CARD32 pad6 B32;
+} xInternAtomReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	BYTE pad1;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32;     /* of additional bytes */
+	CARD16 nameLength B16; /* # of characters in name */
+	CARD16 pad2 B16;
+	CARD32 pad3 B32;
+	CARD32 pad4 B32;
+	CARD32 pad5 B32;
+	CARD32 pad6 B32;
+	CARD32 pad7 B32;
+} xGetAtomNameReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	CARD8 format;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32; /* of additional bytes */
+	Atom propertyType B32;
+	CARD32 bytesAfter B32;
+	CARD32 nItems B32; /* # of 8, 16, or 32-bit entities in reply */
+	CARD32 pad1 B32;
+	CARD32 pad2 B32;
+	CARD32 pad3 B32;
+} xGetPropertyReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	BYTE pad1;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32;
+	CARD16 nProperties B16;
+	CARD16 pad2 B16;
+	CARD32 pad3 B32;
+	CARD32 pad4 B32;
+	CARD32 pad5 B32;
+	CARD32 pad6 B32;
+	CARD32 pad7 B32;
+} xListPropertiesReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	BYTE pad1;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32; /* 0 */
+	Window owner B32;
+	CARD32 pad2 B32;
+	CARD32 pad3 B32;
+	CARD32 pad4 B32;
+	CARD32 pad5 B32;
+	CARD32 pad6 B32;
+} xGetSelectionOwnerReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	BYTE status;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32; /* 0 */
+	CARD32 pad1 B32;
+	CARD32 pad2 B32;
+	CARD32 pad3 B32;
+	CARD32 pad4 B32;
+	CARD32 pad5 B32;
+	CARD32 pad6 B32;
+} xGrabPointerReply;
+
+typedef xGrabPointerReply xGrabKeyboardReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	BOOL sameScreen;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32; /* 0 */
+	Window root B32, child B32;
+	INT16 rootX B16, rootY B16, winX B16, winY B16;
+	CARD16 mask B16;
+	CARD16 pad1 B16;
+	CARD32 pad B32;
+} xQueryPointerReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	BYTE pad1;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32;
+	CARD32 nEvents B32;
+	CARD32 pad2 B32;
+	CARD32 pad3 B32;
+	CARD32 pad4 B32;
+	CARD32 pad5 B32;
+	CARD32 pad6 B32;
+} xGetMotionEventsReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	BOOL sameScreen;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32; /* 0 */
+	Window child B32;
+	INT16 dstX B16, dstY B16;
+	CARD32 pad2 B32;
+	CARD32 pad3 B32;
+	CARD32 pad4 B32;
+	CARD32 pad5 B32;
+} xTranslateCoordsReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	CARD8 revertTo;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32; /* 0 */
+	Window focus B32;
+	CARD32 pad1 B32;
+	CARD32 pad2 B32;
+	CARD32 pad3 B32;
+	CARD32 pad4 B32;
+	CARD32 pad5 B32;
+} xGetInputFocusReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	BYTE pad1;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32; /* 2, NOT 0; this is an extra-large reply */
+	BYTE map[32];
+} xQueryKeymapReply;
+
+/* Warning: this MUST match (up to component renaming) xListFontsWithInfoReply */
+typedef struct _xQueryFontReply
+{
+	BYTE type; /* X_Reply */
+	BYTE pad1;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32; /* definitely > 0, even if "nCharInfos" is 0 */
+	xCharInfo minBounds;
+#ifndef WORD64
+	CARD32 walign1 B32;
+#endif
+	xCharInfo maxBounds;
+#ifndef WORD64
+	CARD32 walign2 B32;
+#endif
+	CARD16 minCharOrByte2 B16, maxCharOrByte2 B16;
+	CARD16 defaultChar B16;
+	CARD16 nFontProps B16; /* followed by this many xFontProp structures */
+	CARD8 drawDirection;
+	CARD8 minByte1, maxByte1;
+	BOOL allCharsExist;
+	INT16 fontAscent B16, fontDescent B16;
+	CARD32 nCharInfos B32; /* followed by this many xCharInfo structures */
+} xQueryFontReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	CARD8 drawDirection;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32; /* 0 */
+	INT16 fontAscent B16, fontDescent B16;
+	INT16 overallAscent B16, overallDescent B16;
+	INT32 overallWidth B32, overallLeft B32, overallRight B32;
+	CARD32 pad B32;
+} xQueryTextExtentsReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	BYTE pad1;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32;
+	CARD16 nFonts B16;
+	CARD16 pad2 B16;
+	CARD32 pad3 B32;
+	CARD32 pad4 B32;
+	CARD32 pad5 B32;
+	CARD32 pad6 B32;
+	CARD32 pad7 B32;
+} xListFontsReply;
+
+/* Warning: this MUST match (up to component renaming) xQueryFontReply */
+typedef struct
+{
+	BYTE type;        /* X_Reply */
+	CARD8 nameLength; /* 0 indicates end-of-reply-sequence */
+	CARD16 sequenceNumber B16;
+	CARD32 length B32; /* definitely > 0, even if "nameLength" is 0 */
+	xCharInfo minBounds;
+#ifndef WORD64
+	CARD32 walign1 B32;
+#endif
+	xCharInfo maxBounds;
+#ifndef WORD64
+	CARD32 walign2 B32;
+#endif
+	CARD16 minCharOrByte2 B16, maxCharOrByte2 B16;
+	CARD16 defaultChar B16;
+	CARD16 nFontProps B16; /* followed by this many xFontProp structures */
+	CARD8 drawDirection;
+	CARD8 minByte1, maxByte1;
+	BOOL allCharsExist;
+	INT16 fontAscent B16, fontDescent B16;
+	CARD32 nReplies B32; /* hint as to how many more replies might be coming */
+} xListFontsWithInfoReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	BYTE pad1;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32;
+	CARD16 nPaths B16;
+	CARD16 pad2 B16;
+	CARD32 pad3 B32;
+	CARD32 pad4 B32;
+	CARD32 pad5 B32;
+	CARD32 pad6 B32;
+	CARD32 pad7 B32;
+} xGetFontPathReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	CARD8 depth;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32;
+	VisualID visual B32;
+	CARD32 pad3 B32;
+	CARD32 pad4 B32;
+	CARD32 pad5 B32;
+	CARD32 pad6 B32;
+	CARD32 pad7 B32;
+} xGetImageReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	BYTE pad1;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32;
+	CARD16 nColormaps B16;
+	CARD16 pad2 B16;
+	CARD32 pad3 B32;
+	CARD32 pad4 B32;
+	CARD32 pad5 B32;
+	CARD32 pad6 B32;
+	CARD32 pad7 B32;
+} xListInstalledColormapsReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	BYTE pad1;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32; /* 0 */
+	CARD16 red B16, green B16, blue B16;
+	CARD16 pad2 B16;
+	CARD32 pixel B32;
+	CARD32 pad3 B32;
+	CARD32 pad4 B32;
+	CARD32 pad5 B32;
+} xAllocColorReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	BYTE pad1;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32; /* 0 */
+	CARD32 pixel B32;
+	CARD16 exactRed B16, exactGreen B16, exactBlue B16;
+	CARD16 screenRed B16, screenGreen B16, screenBlue B16;
+	CARD32 pad2 B32;
+	CARD32 pad3 B32;
+} xAllocNamedColorReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	BYTE pad1;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32;
+	CARD16 nPixels B16, nMasks B16;
+	CARD32 pad3 B32;
+	CARD32 pad4 B32;
+	CARD32 pad5 B32;
+	CARD32 pad6 B32;
+	CARD32 pad7 B32;
+} xAllocColorCellsReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	BYTE pad1;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32;
+	CARD16 nPixels B16;
+	CARD16 pad2 B16;
+	CARD32 redMask B32, greenMask B32, blueMask B32;
+	CARD32 pad3 B32;
+	CARD32 pad4 B32;
+} xAllocColorPlanesReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	BYTE pad1;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32;
+	CARD16 nColors B16;
+	CARD16 pad2 B16;
+	CARD32 pad3 B32;
+	CARD32 pad4 B32;
+	CARD32 pad5 B32;
+	CARD32 pad6 B32;
+	CARD32 pad7 B32;
+} xQueryColorsReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	BYTE pad1;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32; /* 0 */
+	CARD16 exactRed B16, exactGreen B16, exactBlue B16;
+	CARD16 screenRed B16, screenGreen B16, screenBlue B16;
+	CARD32 pad3 B32;
+	CARD32 pad4 B32;
+	CARD32 pad5 B32;
+} xLookupColorReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	BYTE pad1;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32; /* 0 */
+	CARD16 width B16, height B16;
+	CARD32 pad3 B32;
+	CARD32 pad4 B32;
+	CARD32 pad5 B32;
+	CARD32 pad6 B32;
+	CARD32 pad7 B32;
+} xQueryBestSizeReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	BYTE pad1;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32; /* 0 */
+	BOOL present;
+	CARD8 major_opcode;
+	CARD8 first_event;
+	CARD8 first_error;
+	CARD32 pad3 B32;
+	CARD32 pad4 B32;
+	CARD32 pad5 B32;
+	CARD32 pad6 B32;
+	CARD32 pad7 B32;
+} xQueryExtensionReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	CARD8 nExtensions;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32;
+	CARD32 pad2 B32;
+	CARD32 pad3 B32;
+	CARD32 pad4 B32;
+	CARD32 pad5 B32;
+	CARD32 pad6 B32;
+	CARD32 pad7 B32;
+} xListExtensionsReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	CARD8 success;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32;
+	CARD32 pad2 B32;
+	CARD32 pad3 B32;
+	CARD32 pad4 B32;
+	CARD32 pad5 B32;
+	CARD32 pad6 B32;
+	CARD32 pad7 B32;
+} xSetMappingReply;
+typedef xSetMappingReply xSetPointerMappingReply;
+typedef xSetMappingReply xSetModifierMappingReply;
+
+typedef struct
+{
+	BYTE type;   /* X_Reply */
+	CARD8 nElts; /* how many elements does the map have */
+	CARD16 sequenceNumber B16;
+	CARD32 length B32;
+	CARD32 pad2 B32;
+	CARD32 pad3 B32;
+	CARD32 pad4 B32;
+	CARD32 pad5 B32;
+	CARD32 pad6 B32;
+	CARD32 pad7 B32;
+} xGetPointerMappingReply;
+
+typedef struct
+{
+	BYTE type;
+	CARD8 keySymsPerKeyCode;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32;
+	CARD32 pad2 B32;
+	CARD32 pad3 B32;
+	CARD32 pad4 B32;
+	CARD32 pad5 B32;
+	CARD32 pad6 B32;
+	CARD32 pad7 B32;
+} xGetKeyboardMappingReply;
+
+typedef struct
+{
+	BYTE type;
+	CARD8 numKeyPerModifier;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32;
+	CARD32 pad1 B32;
+	CARD32 pad2 B32;
+	CARD32 pad3 B32;
+	CARD32 pad4 B32;
+	CARD32 pad5 B32;
+	CARD32 pad6 B32;
+} xGetModifierMappingReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	BOOL globalAutoRepeat;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32; /* 5 */
+	CARD32 ledMask B32;
+	CARD8 keyClickPercent, bellPercent;
+	CARD16 bellPitch B16, bellDuration B16;
+	CARD16 pad B16;
+	BYTE map[32]; /* bit masks start here */
+} xGetKeyboardControlReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	BYTE pad1;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32; /* 0 */
+	CARD16 accelNumerator B16, accelDenominator B16;
+	CARD16 threshold B16;
+	CARD16 pad2 B16;
+	CARD32 pad3 B32;
+	CARD32 pad4 B32;
+	CARD32 pad5 B32;
+	CARD32 pad6 B32;
+} xGetPointerControlReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	BYTE pad1;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32; /* 0 */
+	CARD16 timeout B16, interval B16;
+	BOOL preferBlanking;
+	BOOL allowExposures;
+	CARD16 pad2 B16;
+	CARD32 pad3 B32;
+	CARD32 pad4 B32;
+	CARD32 pad5 B32;
+	CARD32 pad6 B32;
+} xGetScreenSaverReply;
+
+typedef struct
+{
+	BYTE type; /* X_Reply */
+	BOOL enabled;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32;
+	CARD16 nHosts B16;
+	CARD16 pad1 B16;
+	CARD32 pad3 B32;
+	CARD32 pad4 B32;
+	CARD32 pad5 B32;
+	CARD32 pad6 B32;
+	CARD32 pad7 B32;
+} xListHostsReply;
+
+/*****************************************************************
+ * Xerror
+ *    All errors  are 32 bytes 
+ *****************************************************************/
+
+typedef struct
+{
+	BYTE type; /* X_Error */
+	BYTE errorCode;
+	CARD16 sequenceNumber B16; /* the nth request from this client */
+	CARD32 resourceID B32;
+	CARD16 minorCode B16;
+	CARD8 majorCode;
+	BYTE pad1;
+	CARD32 pad3 B32;
+	CARD32 pad4 B32;
+	CARD32 pad5 B32;
+	CARD32 pad6 B32;
+	CARD32 pad7 B32;
+} xError;
+
+/*****************************************************************
+ * xEvent
+ *    All events are 32 bytes
+ *****************************************************************/
+
+typedef struct _xEvent
+{
+	union {
+		struct
+		{
+			BYTE type;
+			BYTE detail;
+			CARD16 sequenceNumber B16;
+		} u;
+		struct
+		{
+			CARD32 pad00 B32;
+			Time time B32;
+			Window root B32, event B32, child B32;
+			INT16 rootX B16, rootY B16, eventX B16, eventY B16;
+			KeyButMask state B16;
+			BOOL sameScreen;
+			BYTE pad1;
+		} keyButtonPointer;
+		struct
+		{
+			CARD32 pad00 B32;
+			Time time B32;
+			Window root B32, event B32, child B32;
+			INT16 rootX B16, rootY B16, eventX B16, eventY B16;
+			KeyButMask state B16;
+			BYTE mode;  /* really XMode */
+			BYTE flags; /* sameScreen and focus booleans, packed together */
+#define ELFlagFocus (1 << 0)
+#define ELFlagSameScreen (1 << 1)
+		} enterLeave;
+		struct
+		{
+			CARD32 pad00 B32;
+			Window window B32;
+			BYTE mode; /* really XMode */
+			BYTE pad1, pad2, pad3;
+		} focus;
+		struct
+		{
+			CARD32 pad00 B32;
+			Window window B32;
+			CARD16 x B16, y B16, width B16, height B16;
+			CARD16 count B16;
+			CARD16 pad2 B16;
+		} expose;
+		struct
+		{
+			CARD32 pad00 B32;
+			Drawable drawable B32;
+			CARD16 x B16, y B16, width B16, height B16;
+			CARD16 minorEvent B16;
+			CARD16 count B16;
+			BYTE majorEvent;
+			BYTE pad1, pad2, pad3;
+		} graphicsExposure;
+		struct
+		{
+			CARD32 pad00 B32;
+			Drawable drawable B32;
+			CARD16 minorEvent B16;
+			BYTE majorEvent;
+			BYTE bpad;
+		} noExposure;
+		struct
+		{
+			CARD32 pad00 B32;
+			Window window B32;
+			CARD8 state;
+			BYTE pad1, pad2, pad3;
+		} visibility;
+		struct
+		{
+			CARD32 pad00 B32;
+			Window parent B32, window B32;
+			INT16 x B16, y B16;
+			CARD16 width B16, height B16, borderWidth B16;
+			BOOL override;
+			BYTE bpad;
+		} createNotify;
+		/*
+ * The event fields in the structures for DestroyNotify, UnmapNotify,
+ * MapNotify, ReparentNotify, ConfigureNotify, CirculateNotify, GravityNotify,
+ * must be at the same offset because server internal code is depending upon
+ * this to patch up the events before they are delivered.
+ * Also note that MapRequest, ConfigureRequest and CirculateRequest have
+ * the same offset for the event window.
+ */
+		struct
+		{
+			CARD32 pad00 B32;
+			Window event B32, window B32;
+		} destroyNotify;
+		struct
+		{
+			CARD32 pad00 B32;
+			Window event B32, window B32;
+			BOOL fromConfigure;
+			BYTE pad1, pad2, pad3;
+		} unmapNotify;
+		struct
+		{
+			CARD32 pad00 B32;
+			Window event B32, window B32;
+			BOOL override;
+			BYTE pad1, pad2, pad3;
+		} mapNotify;
+		struct
+		{
+			CARD32 pad00 B32;
+			Window parent B32, window B32;
+		} mapRequest;
+		struct
+		{
+			CARD32 pad00 B32;
+			Window event B32, window B32, parent B32;
+			INT16 x B16, y B16;
+			BOOL override;
+			BYTE pad1, pad2, pad3;
+		} reparent;
+		struct
+		{
+			CARD32 pad00 B32;
+			Window event B32, window B32, aboveSibling B32;
+			INT16 x B16, y B16;
+			CARD16 width B16, height B16, borderWidth B16;
+			BOOL override;
+			BYTE bpad;
+		} configureNotify;
+		struct
+		{
+			CARD32 pad00 B32;
+			Window parent B32, window B32, sibling B32;
+			INT16 x B16, y B16;
+			CARD16 width B16, height B16, borderWidth B16;
+			CARD16 valueMask B16;
+			CARD32 pad1 B32;
+		} configureRequest;
+		struct
+		{
+			CARD32 pad00 B32;
+			Window event B32, window B32;
+			INT16 x B16, y B16;
+			CARD32 pad1 B32, pad2 B32, pad3 B32, pad4 B32;
+		} gravity;
+		struct
+		{
+			CARD32 pad00 B32;
+			Window window B32;
+			CARD16 width B16, height B16;
+		} resizeRequest;
+		struct
+		{
+			/* The event field in the circulate record is really the parent when this
+   is used as a CirculateRequest instead of a CirculateNotify */
+			CARD32 pad00 B32;
+			Window event B32, window B32, parent B32;
+			BYTE place; /* Top or Bottom */
+			BYTE pad1, pad2, pad3;
+		} circulate;
+		struct
+		{
+			CARD32 pad00 B32;
+			Window window B32;
+			Atom atom B32;
+			Time time B32;
+			BYTE state; /* NewValue or Deleted */
+			BYTE pad1;
+			CARD16 pad2 B16;
+		} property;
+		struct
+		{
+			CARD32 pad00 B32;
+			Time time B32;
+			Window window B32;
+			Atom atom B32;
+		} selectionClear;
+		struct
+		{
+			CARD32 pad00 B32;
+			Time time B32;
+			Window owner B32, requestor B32;
+			Atom selection B32, target B32, property B32;
+		} selectionRequest;
+		struct
+		{
+			CARD32 pad00 B32;
+			Time time B32;
+			Window requestor B32;
+			Atom selection B32, target B32, property B32;
+		} selectionNotify;
+		struct
+		{
+			CARD32 pad00 B32;
+			Window window B32;
+			Colormap colormap B32;
+#if defined(__cplusplus) || defined(c_plusplus)
+			BOOL c_new;
+#else
+			BOOL new;
+#endif
+			BYTE state; /* Installed or UnInstalled */
+			BYTE pad1, pad2;
+		} colormap;
+		struct
+		{
+			CARD32 pad00 B32;
+			CARD8 request;
+			KeyCode firstKeyCode;
+			CARD8 count;
+			BYTE pad1;
+		} mappingNotify;
+		struct
+		{
+			CARD32 pad00 B32;
+			Window window B32;
+			union {
+				struct
+				{
+					Atom type B32;
+					INT32 longs0 B32;
+					INT32 longs1 B32;
+					INT32 longs2 B32;
+					INT32 longs3 B32;
+					INT32 longs4 B32;
+				} l;
+				struct
+				{
+					Atom type B32;
+					INT16 shorts0 B16;
+					INT16 shorts1 B16;
+					INT16 shorts2 B16;
+					INT16 shorts3 B16;
+					INT16 shorts4 B16;
+					INT16 shorts5 B16;
+					INT16 shorts6 B16;
+					INT16 shorts7 B16;
+					INT16 shorts8 B16;
+					INT16 shorts9 B16;
+				} s;
+				struct
+				{
+					Atom type B32;
+					INT8 bytes[20];
+				} b;
+			} u;
+		} clientMessage;
+	} u;
+} xEvent;
+
+/*********************************************************
+ *
+ * Generic event
+ * 
+ * Those events are not part of the core protocol spec and can be used by
+ * various extensions.
+ * type is always GenericEvent
+ * extension is the minor opcode of the extension the event belongs to.
+ * evtype is the actual event type, unique __per extension__. 
+ *
+ * GenericEvents can be longer than 32 bytes, with the length field
+ * specifying the number of 4 byte blocks after the first 32 bytes. 
+ *
+ *
+ */
+typedef struct
+{
+	BYTE type;
+	CARD8 extension;
+	CARD16 sequenceNumber B16;
+	CARD32 length B32;
+	CARD16 evtype B16;
+	CARD16 pad2 B16;
+	CARD32 pad3 B32;
+	CARD32 pad4 B32;
+	CARD32 pad5 B32;
+	CARD32 pad6 B32;
+	CARD32 pad7 B32;
+} xGenericEvent;
+
+/* KeymapNotify events are not included in the above union because they
+   are different from all other events: they do not have a "detail"
+   or "sequenceNumber", so there is room for a 248-bit key mask. */
+
+typedef struct
+{
+	BYTE type;
+	BYTE map[31];
+} xKeymapEvent;
+
+#define XEventSize (sizeof(xEvent))
+
+/* XReply is the union of all the replies above whose "fixed part"
+fits in 32 bytes.  It does NOT include GetWindowAttributesReply,
+QueryFontReply, QueryKeymapReply, or GetKeyboardControlReply 
+ListFontsWithInfoReply */
+
+typedef union {
+	xGenericReply generic;
+	xGetGeometryReply geom;
+	xQueryTreeReply tree;
+	xInternAtomReply atom;
+	xGetAtomNameReply atomName;
+	xGetPropertyReply property;
+	xListPropertiesReply listProperties;
+	xGetSelectionOwnerReply selection;
+	xGrabPointerReply grabPointer;
+	xGrabKeyboardReply grabKeyboard;
+	xQueryPointerReply pointer;
+	xGetMotionEventsReply motionEvents;
+	xTranslateCoordsReply coords;
+	xGetInputFocusReply inputFocus;
+	xQueryTextExtentsReply textExtents;
+	xListFontsReply fonts;
+	xGetFontPathReply fontPath;
+	xGetImageReply image;
+	xListInstalledColormapsReply colormaps;
+	xAllocColorReply allocColor;
+	xAllocNamedColorReply allocNamedColor;
+	xAllocColorCellsReply colorCells;
+	xAllocColorPlanesReply colorPlanes;
+	xQueryColorsReply colors;
+	xLookupColorReply lookupColor;
+	xQueryBestSizeReply bestSize;
+	xQueryExtensionReply extension;
+	xListExtensionsReply extensions;
+	xSetModifierMappingReply setModifierMapping;
+	xGetModifierMappingReply getModifierMapping;
+	xSetPointerMappingReply setPointerMapping;
+	xGetKeyboardMappingReply getKeyboardMapping;
+	xGetPointerMappingReply getPointerMapping;
+	xGetPointerControlReply pointerControl;
+	xGetScreenSaverReply screenSaver;
+	xListHostsReply hosts;
+	xError error;
+	xEvent event;
+} xReply;
+
+/*****************************************************************
+ * REQUESTS
+ *****************************************************************/
+
+/* Request structure */
+
+typedef struct _xReq
+{
+	CARD8 reqType;
+	CARD8 data;        /* meaning depends on request type */
+	CARD16 length B16; /* length in 4 bytes quantities 
+				  of whole request, including this header */
+} xReq;
+
+/*****************************************************************
+ *  structures that follow request. 
+ *****************************************************************/
+
+/* ResourceReq is used for any request which has a resource ID 
+   (or Atom or Time) as its one and only argument.  */
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	CARD32 id B32; /* a Window, Drawable, Font, GContext, Pixmap, etc. */
+} xResourceReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	CARD8 depth;
+	CARD16 length B16;
+	Window wid B32, parent B32;
+	INT16 x B16, y B16;
+	CARD16 width B16, height B16, borderWidth B16;
+#if defined(__cplusplus) || defined(c_plusplus)
+	CARD16 c_class B16;
+#else
+	CARD16 class B16;
+#endif
+	VisualID visual B32;
+	CARD32 mask B32;
+} xCreateWindowReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	Window window B32;
+	CARD32 valueMask B32;
+} xChangeWindowAttributesReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE mode;
+	CARD16 length B16;
+	Window window B32;
+} xChangeSaveSetReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	Window window B32, parent B32;
+	INT16 x B16, y B16;
+} xReparentWindowReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	CARD8 pad;
+	CARD16 length B16;
+	Window window B32;
+	CARD16 mask B16;
+	CARD16 pad2 B16;
+} xConfigureWindowReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	CARD8 direction;
+	CARD16 length B16;
+	Window window B32;
+} xCirculateWindowReq;
+
+typedef struct
+{ /* followed by padded string */
+	CARD8 reqType;
+	BOOL onlyIfExists;
+	CARD16 length B16;
+	CARD16 nbytes B16; /* number of bytes in string */
+	CARD16 pad B16;
+} xInternAtomReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	CARD8 mode;
+	CARD16 length B16;
+	Window window B32;
+	Atom property B32, type B32;
+	CARD8 format;
+	BYTE pad[3];
+	CARD32 nUnits B32; /* length of stuff following, depends on format */
+} xChangePropertyReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	Window window B32;
+	Atom property B32;
+} xDeletePropertyReq;
+
+typedef struct
+{
+	CARD8 reqType;
+#if defined(__cplusplus) || defined(c_plusplus)
+	BOOL c_delete;
+#else
+	BOOL delete;
+#endif
+	CARD16 length B16;
+	Window window B32;
+	Atom property B32, type B32;
+	CARD32 longOffset B32;
+	CARD32 longLength B32;
+} xGetPropertyReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	Window window B32;
+	Atom selection B32;
+	Time time B32;
+} xSetSelectionOwnerReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	Window requestor B32;
+	Atom selection B32, target B32, property B32;
+	Time time B32;
+} xConvertSelectionReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BOOL propagate;
+	CARD16 length B16;
+	Window destination B32;
+	CARD32 eventMask B32;
+#ifdef WORD64
+	/* the structure should have been quad-aligned */
+	BYTE eventdata[SIZEOF(xEvent)];
+#else
+	xEvent event;
+#endif /* WORD64 */
+} xSendEventReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BOOL ownerEvents;
+	CARD16 length B16;
+	Window grabWindow B32;
+	CARD16 eventMask B16;
+	BYTE pointerMode, keyboardMode;
+	Window confineTo B32;
+	Cursor cursor B32;
+	Time time B32;
+} xGrabPointerReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BOOL ownerEvents;
+	CARD16 length B16;
+	Window grabWindow B32;
+	CARD16 eventMask B16;
+	BYTE pointerMode, keyboardMode;
+	Window confineTo B32;
+	Cursor cursor B32;
+	CARD8 button;
+	BYTE pad;
+	CARD16 modifiers B16;
+} xGrabButtonReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	CARD8 button;
+	CARD16 length B16;
+	Window grabWindow B32;
+	CARD16 modifiers B16;
+	CARD16 pad B16;
+} xUngrabButtonReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	Cursor cursor B32;
+	Time time B32;
+	CARD16 eventMask B16;
+	CARD16 pad2 B16;
+} xChangeActivePointerGrabReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BOOL ownerEvents;
+	CARD16 length B16;
+	Window grabWindow B32;
+	Time time B32;
+	BYTE pointerMode, keyboardMode;
+	CARD16 pad B16;
+} xGrabKeyboardReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BOOL ownerEvents;
+	CARD16 length B16;
+	Window grabWindow B32;
+	CARD16 modifiers B16;
+	CARD8 key;
+	BYTE pointerMode, keyboardMode;
+	BYTE pad1, pad2, pad3;
+} xGrabKeyReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	CARD8 key;
+	CARD16 length B16;
+	Window grabWindow B32;
+	CARD16 modifiers B16;
+	CARD16 pad B16;
+} xUngrabKeyReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	CARD8 mode;
+	CARD16 length B16;
+	Time time B32;
+} xAllowEventsReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	Window window B32;
+	Time start B32, stop B32;
+} xGetMotionEventsReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	Window srcWid B32, dstWid B32;
+	INT16 srcX B16, srcY B16;
+} xTranslateCoordsReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	Window srcWid B32, dstWid B32;
+	INT16 srcX B16, srcY B16;
+	CARD16 srcWidth B16, srcHeight B16;
+	INT16 dstX B16, dstY B16;
+} xWarpPointerReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	CARD8 revertTo;
+	CARD16 length B16;
+	Window focus B32;
+	Time time B32;
+} xSetInputFocusReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	Font fid B32;
+	CARD16 nbytes B16;
+	BYTE pad1, pad2; /* string follows on word boundary */
+} xOpenFontReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BOOL oddLength;
+	CARD16 length B16;
+	Font fid B32;
+} xQueryTextExtentsReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	CARD16 maxNames B16;
+	CARD16 nbytes B16; /* followed immediately by string bytes */
+} xListFontsReq;
+
+typedef xListFontsReq xListFontsWithInfoReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	CARD16 nFonts B16;
+	BYTE pad1, pad2; /* LISTofSTRING8 follows on word boundary */
+} xSetFontPathReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	CARD8 depth;
+	CARD16 length B16;
+	Pixmap pid B32;
+	Drawable drawable B32;
+	CARD16 width B16, height B16;
+} xCreatePixmapReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	GContext gc B32;
+	Drawable drawable B32;
+	CARD32 mask B32;
+} xCreateGCReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	GContext gc B32;
+	CARD32 mask B32;
+} xChangeGCReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	GContext srcGC B32, dstGC B32;
+	CARD32 mask B32;
+} xCopyGCReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	GContext gc B32;
+	CARD16 dashOffset B16;
+	CARD16 nDashes B16; /* length LISTofCARD8 of values following */
+} xSetDashesReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE ordering;
+	CARD16 length B16;
+	GContext gc B32;
+	INT16 xOrigin B16, yOrigin B16;
+} xSetClipRectanglesReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BOOL exposures;
+	CARD16 length B16;
+	Window window B32;
+	INT16 x B16, y B16;
+	CARD16 width B16, height B16;
+} xClearAreaReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	Drawable srcDrawable B32, dstDrawable B32;
+	GContext gc B32;
+	INT16 srcX B16, srcY B16, dstX B16, dstY B16;
+	CARD16 width B16, height B16;
+} xCopyAreaReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	Drawable srcDrawable B32, dstDrawable B32;
+	GContext gc B32;
+	INT16 srcX B16, srcY B16, dstX B16, dstY B16;
+	CARD16 width B16, height B16;
+	CARD32 bitPlane B32;
+} xCopyPlaneReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE coordMode;
+	CARD16 length B16;
+	Drawable drawable B32;
+	GContext gc B32;
+} xPolyPointReq;
+
+typedef xPolyPointReq xPolyLineReq; /* same request structure */
+
+/* The following used for PolySegment, PolyRectangle, PolyArc, PolyFillRectangle, PolyFillArc */
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	Drawable drawable B32;
+	GContext gc B32;
+} xPolySegmentReq;
+
+typedef xPolySegmentReq xPolyArcReq;
+typedef xPolySegmentReq xPolyRectangleReq;
+typedef xPolySegmentReq xPolyFillRectangleReq;
+typedef xPolySegmentReq xPolyFillArcReq;
+
+typedef struct _FillPolyReq
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	Drawable drawable B32;
+	GContext gc B32;
+	BYTE shape;
+	BYTE coordMode;
+	CARD16 pad1 B16;
+} xFillPolyReq;
+
+typedef struct _PutImageReq
+{
+	CARD8 reqType;
+	CARD8 format;
+	CARD16 length B16;
+	Drawable drawable B32;
+	GContext gc B32;
+	CARD16 width B16, height B16;
+	INT16 dstX B16, dstY B16;
+	CARD8 leftPad;
+	CARD8 depth;
+	CARD16 pad B16;
+} xPutImageReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	CARD8 format;
+	CARD16 length B16;
+	Drawable drawable B32;
+	INT16 x B16, y B16;
+	CARD16 width B16, height B16;
+	CARD32 planeMask B32;
+} xGetImageReq;
+
+/* the following used by PolyText8 and PolyText16 */
+
+typedef struct
+{
+	CARD8 reqType;
+	CARD8 pad;
+	CARD16 length B16;
+	Drawable drawable B32;
+	GContext gc B32;
+	INT16 x B16, y B16; /* items (xTextElt) start after struct */
+} xPolyTextReq;
+
+typedef xPolyTextReq xPolyText8Req;
+typedef xPolyTextReq xPolyText16Req;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE nChars;
+	CARD16 length B16;
+	Drawable drawable B32;
+	GContext gc B32;
+	INT16 x B16, y B16;
+} xImageTextReq;
+
+typedef xImageTextReq xImageText8Req;
+typedef xImageTextReq xImageText16Req;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE alloc;
+	CARD16 length B16;
+	Colormap mid B32;
+	Window window B32;
+	VisualID visual B32;
+} xCreateColormapReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	Colormap mid B32;
+	Colormap srcCmap B32;
+} xCopyColormapAndFreeReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	Colormap cmap B32;
+	CARD16 red B16, green B16, blue B16;
+	CARD16 pad2 B16;
+} xAllocColorReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	Colormap cmap B32;
+	CARD16 nbytes B16; /* followed by structure */
+	BYTE pad1, pad2;
+} xAllocNamedColorReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BOOL contiguous;
+	CARD16 length B16;
+	Colormap cmap B32;
+	CARD16 colors B16, planes B16;
+} xAllocColorCellsReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BOOL contiguous;
+	CARD16 length B16;
+	Colormap cmap B32;
+	CARD16 colors B16, red B16, green B16, blue B16;
+} xAllocColorPlanesReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	Colormap cmap B32;
+	CARD32 planeMask B32;
+} xFreeColorsReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	Colormap cmap B32;
+} xStoreColorsReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	CARD8 flags; /* DoRed, DoGreen, DoBlue, as in xColorItem */
+	CARD16 length B16;
+	Colormap cmap B32;
+	CARD32 pixel B32;
+	CARD16 nbytes B16; /* number of name string bytes following structure */
+	BYTE pad1, pad2;
+} xStoreNamedColorReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	Colormap cmap B32;
+} xQueryColorsReq;
+
+typedef struct
+{ /* followed  by string of length len */
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	Colormap cmap B32;
+	CARD16 nbytes B16; /* number of string bytes following structure*/
+	BYTE pad1, pad2;
+} xLookupColorReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	Cursor cid B32;
+	Pixmap source B32, mask B32;
+	CARD16 foreRed B16, foreGreen B16, foreBlue B16;
+	CARD16 backRed B16, backGreen B16, backBlue B16;
+	CARD16 x B16, y B16;
+} xCreateCursorReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	Cursor cid B32;
+	Font source B32, mask B32;
+	CARD16 sourceChar B16, maskChar B16;
+	CARD16 foreRed B16, foreGreen B16, foreBlue B16;
+	CARD16 backRed B16, backGreen B16, backBlue B16;
+} xCreateGlyphCursorReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	Cursor cursor B32;
+	CARD16 foreRed B16, foreGreen B16, foreBlue B16;
+	CARD16 backRed B16, backGreen B16, backBlue B16;
+} xRecolorCursorReq;
+
+typedef struct
+{
+	CARD8 reqType;
+#if defined(__cplusplus) || defined(c_plusplus)
+	CARD8 c_class;
+#else
+	CARD8 class;
+#endif
+	CARD16 length B16;
+	Drawable drawable B32;
+	CARD16 width B16, height B16;
+} xQueryBestSizeReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	CARD16 nbytes B16; /* number of string bytes following structure */
+	BYTE pad1, pad2;
+} xQueryExtensionReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	CARD8 numKeyPerModifier;
+	CARD16 length B16;
+} xSetModifierMappingReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	CARD8 nElts; /* how many elements in the map */
+	CARD16 length B16;
+} xSetPointerMappingReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	KeyCode firstKeyCode;
+	CARD8 count;
+	CARD16 pad1 B16;
+} xGetKeyboardMappingReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	CARD8 keyCodes;
+	CARD16 length B16;
+	KeyCode firstKeyCode;
+	CARD8 keySymsPerKeyCode;
+	CARD16 pad1 B16;
+} xChangeKeyboardMappingReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	CARD32 mask B32;
+} xChangeKeyboardControlReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	INT8 percent; /* -100 to 100 */
+	CARD16 length B16;
+} xBellReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	INT16 accelNum B16, accelDenum B16;
+	INT16 threshold B16;
+	BOOL doAccel, doThresh;
+} xChangePointerControlReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	INT16 timeout B16, interval B16;
+	BYTE preferBlank, allowExpose;
+	CARD16 pad2 B16;
+} xSetScreenSaverReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE mode;
+	CARD16 length B16;
+	CARD8 hostFamily;
+	BYTE pad;
+	CARD16 hostLength B16;
+} xChangeHostsReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+} xListHostsReq;
+
+typedef struct
+{
+	CARD8 reqType;
+	BYTE mode;
+	CARD16 length B16;
+} xChangeModeReq;
+
+typedef xChangeModeReq xSetAccessControlReq;
+typedef xChangeModeReq xSetCloseDownModeReq;
+typedef xChangeModeReq xForceScreenSaverReq;
+
+typedef struct
+{ /* followed by LIST of ATOM */
+	CARD8 reqType;
+	BYTE pad;
+	CARD16 length B16;
+	Window window B32;
+	CARD16 nAtoms B16;
+	INT16 nPositions B16;
+} xRotatePropertiesReq;
+
+/* Reply codes */
+
+#define X_Reply 1 /* Normal reply */
+#define X_Error 0 /* Error */
+
+/* Request codes */
+
+#define X_CreateWindow 1
+#define X_ChangeWindowAttributes 2
+#define X_GetWindowAttributes 3
+#define X_DestroyWindow 4
+#define X_DestroySubwindows 5
+#define X_ChangeSaveSet 6
+#define X_ReparentWindow 7
+#define X_MapWindow 8
+#define X_MapSubwindows 9
+#define X_UnmapWindow 10
+#define X_UnmapSubwindows 11
+#define X_ConfigureWindow 12
+#define X_CirculateWindow 13
+#define X_GetGeometry 14
+#define X_QueryTree 15
+#define X_InternAtom 16
+#define X_GetAtomName 17
+#define X_ChangeProperty 18
+#define X_DeleteProperty 19
+#define X_GetProperty 20
+#define X_ListProperties 21
+#define X_SetSelectionOwner 22
+#define X_GetSelectionOwner 23
+#define X_ConvertSelection 24
+#define X_SendEvent 25
+#define X_GrabPointer 26
+#define X_UngrabPointer 27
+#define X_GrabButton 28
+#define X_UngrabButton 29
+#define X_ChangeActivePointerGrab 30
+#define X_GrabKeyboard 31
+#define X_UngrabKeyboard 32
+#define X_GrabKey 33
+#define X_UngrabKey 34
+#define X_AllowEvents 35
+#define X_GrabServer 36
+#define X_UngrabServer 37
+#define X_QueryPointer 38
+#define X_GetMotionEvents 39
+#define X_TranslateCoords 40
+#define X_WarpPointer 41
+#define X_SetInputFocus 42
+#define X_GetInputFocus 43
+#define X_QueryKeymap 44
+#define X_OpenFont 45
+#define X_CloseFont 46
+#define X_QueryFont 47
+#define X_QueryTextExtents 48
+#define X_ListFonts 49
+#define X_ListFontsWithInfo 50
+#define X_SetFontPath 51
+#define X_GetFontPath 52
+#define X_CreatePixmap 53
+#define X_FreePixmap 54
+#define X_CreateGC 55
+#define X_ChangeGC 56
+#define X_CopyGC 57
+#define X_SetDashes 58
+#define X_SetClipRectangles 59
+#define X_FreeGC 60
+#define X_ClearArea 61
+#define X_CopyArea 62
+#define X_CopyPlane 63
+#define X_PolyPoint 64
+#define X_PolyLine 65
+#define X_PolySegment 66
+#define X_PolyRectangle 67
+#define X_PolyArc 68
+#define X_FillPoly 69
+#define X_PolyFillRectangle 70
+#define X_PolyFillArc 71
+#define X_PutImage 72
+#define X_GetImage 73
+#define X_PolyText8 74
+#define X_PolyText16 75
+#define X_ImageText8 76
+#define X_ImageText16 77
+#define X_CreateColormap 78
+#define X_FreeColormap 79
+#define X_CopyColormapAndFree 80
+#define X_InstallColormap 81
+#define X_UninstallColormap 82
+#define X_ListInstalledColormaps 83
+#define X_AllocColor 84
+#define X_AllocNamedColor 85
+#define X_AllocColorCells 86
+#define X_AllocColorPlanes 87
+#define X_FreeColors 88
+#define X_StoreColors 89
+#define X_StoreNamedColor 90
+#define X_QueryColors 91
+#define X_LookupColor 92
+#define X_CreateCursor 93
+#define X_CreateGlyphCursor 94
+#define X_FreeCursor 95
+#define X_RecolorCursor 96
+#define X_QueryBestSize 97
+#define X_QueryExtension 98
+#define X_ListExtensions 99
+#define X_ChangeKeyboardMapping 100
+#define X_GetKeyboardMapping 101
+#define X_ChangeKeyboardControl 102
+#define X_GetKeyboardControl 103
+#define X_Bell 104
+#define X_ChangePointerControl 105
+#define X_GetPointerControl 106
+#define X_SetScreenSaver 107
+#define X_GetScreenSaver 108
+#define X_ChangeHosts 109
+#define X_ListHosts 110
+#define X_SetAccessControl 111
+#define X_SetCloseDownMode 112
+#define X_KillClient 113
+#define X_RotateProperties 114
+#define X_ForceScreenSaver 115
+#define X_SetPointerMapping 116
+#define X_GetPointerMapping 117
+#define X_SetModifierMapping 118
+#define X_GetModifierMapping 119
+#define X_NoOperation 127
+
+/* restore these definitions back to the typedefs in X.h */
+#undef Window
+#undef Drawable
+#undef Font
+#undef Pixmap
+#undef Cursor
+#undef Colormap
+#undef GContext
+#undef Atom
+#undef VisualID
+#undef Time
+#undef KeyCode
+#undef KeySym
+
+#endif /* XPROTO_H */
diff --git a/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/Xprotostr.h b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/Xprotostr.h
new file mode 100644
index 00000000..a07861e4
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/Xprotostr.h
@@ -0,0 +1,81 @@
+#ifndef XPROTOSTRUCTS_H
+#define XPROTOSTRUCTS_H
+
+/***********************************************************
+
+Copyright 1987, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its 
+documentation for any purpose and without fee is hereby granted, 
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in 
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.  
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+#include <X11/Xmd.h>
+
+/* Used by PolySegment */
+
+typedef struct _xSegment
+{
+	INT16 x1 B16, y1 B16, x2 B16, y2 B16;
+} xSegment;
+
+/* POINT */
+
+typedef struct _xPoint
+{
+	INT16 x B16, y B16;
+} xPoint;
+
+typedef struct _xRectangle
+{
+	INT16 x B16, y B16;
+	CARD16 width B16, height B16;
+} xRectangle;
+
+/*  ARC  */
+
+typedef struct _xArc
+{
+	INT16 x B16, y B16;
+	CARD16 width B16, height B16;
+	INT16 angle1 B16, angle2 B16;
+} xArc;
+
+#endif /* XPROTOSTRUCTS_H */
diff --git a/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/Xutil.h b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/Xutil.h
new file mode 100644
index 00000000..b2c828c4
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/Xutil.h
@@ -0,0 +1,823 @@
+
+/***********************************************************
+
+Copyright 1987, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+
+#ifndef _X11_XUTIL_H_
+#define _X11_XUTIL_H_
+
+/* You must include <X11/Xlib.h> before including this file */
+#include <X11/Xlib.h>
+#include <X11/keysym.h>
+
+/* The Xlib structs are full of implicit padding to properly align members.
+   We can't clean that up without breaking ABI, so tell clang not to bother
+   complaining about it. */
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+/*
+ * Bitmask returned by XParseGeometry().  Each bit tells if the corresponding
+ * value (x, y, width, height) was found in the parsed string.
+ */
+#define NoValue 0x0000
+#define XValue 0x0001
+#define YValue 0x0002
+#define WidthValue 0x0004
+#define HeightValue 0x0008
+#define AllValues 0x000F
+#define XNegative 0x0010
+#define YNegative 0x0020
+
+/*
+ * new version containing base_width, base_height, and win_gravity fields;
+ * used with WM_NORMAL_HINTS.
+ */
+typedef struct
+{
+	long flags;        /* marks which fields in this structure are defined */
+	int x, y;          /* obsolete for new window mgrs, but clients */
+	int width, height; /* should set so old wm's don't mess up */
+	int min_width, min_height;
+	int max_width, max_height;
+	int width_inc, height_inc;
+	struct
+	{
+		int x; /* numerator */
+		int y; /* denominator */
+	} min_aspect, max_aspect;
+	int base_width, base_height; /* added by ICCCM version 1 */
+	int win_gravity;             /* added by ICCCM version 1 */
+} XSizeHints;
+
+/*
+ * The next block of definitions are for window manager properties that
+ * clients and applications use for communication.
+ */
+
+/* flags argument in size hints */
+#define USPosition (1L << 0) /* user specified x, y */
+#define USSize (1L << 1)     /* user specified width, height */
+
+#define PPosition (1L << 2)   /* program specified position */
+#define PSize (1L << 3)       /* program specified size */
+#define PMinSize (1L << 4)    /* program specified minimum size */
+#define PMaxSize (1L << 5)    /* program specified maximum size */
+#define PResizeInc (1L << 6)  /* program specified resize increments */
+#define PAspect (1L << 7)     /* program specified min and max aspect ratios */
+#define PBaseSize (1L << 8)   /* program specified base for incrementing */
+#define PWinGravity (1L << 9) /* program specified window gravity */
+
+/* obsolete */
+#define PAllHints (PPosition | PSize | PMinSize | PMaxSize | PResizeInc | PAspect)
+
+typedef struct
+{
+	long flags;         /* marks which fields in this structure are defined */
+	Bool input;         /* does this application rely on the window manager to
+			get keyboard input? */
+	int initial_state;  /* see below */
+	Pixmap icon_pixmap; /* pixmap to be used as icon */
+	Window icon_window; /* window to be used as icon */
+	int icon_x, icon_y; /* initial position of icon */
+	Pixmap icon_mask;   /* icon mask bitmap */
+	XID window_group;   /* id of related window group */
+						/* this structure may be extended in the future */
+} XWMHints;
+
+/* definition for flags of XWMHints */
+
+#define InputHint (1L << 0)
+#define StateHint (1L << 1)
+#define IconPixmapHint (1L << 2)
+#define IconWindowHint (1L << 3)
+#define IconPositionHint (1L << 4)
+#define IconMaskHint (1L << 5)
+#define WindowGroupHint (1L << 6)
+#define AllHints (InputHint | StateHint | IconPixmapHint | IconWindowHint | \
+				  IconPositionHint | IconMaskHint | WindowGroupHint)
+#define XUrgencyHint (1L << 8)
+
+/* definitions for initial window state */
+#define WithdrawnState 0 /* for windows that are not mapped */
+#define NormalState 1    /* most applications want to start this way */
+#define IconicState 3    /* application wants to start as an icon */
+
+/*
+ * Obsolete states no longer defined by ICCCM
+ */
+#define DontCareState 0 /* don't know or care */
+#define ZoomState 2     /* application wants to start zoomed */
+#define InactiveState 4 /* application believes it is seldom used; */
+						/* some wm's may put it on inactive menu */
+
+/*
+ * new structure for manipulating TEXT properties; used with WM_NAME,
+ * WM_ICON_NAME, WM_CLIENT_MACHINE, and WM_COMMAND.
+ */
+typedef struct
+{
+	unsigned char* value; /* same as Property routines */
+	Atom encoding;        /* prop type */
+	int format;           /* prop data format: 8, 16, or 32 */
+	unsigned long nitems; /* number of data items in value */
+} XTextProperty;
+
+#define XNoMemory -1
+#define XLocaleNotSupported -2
+#define XConverterNotFound -3
+
+typedef enum
+{
+	XStringStyle,       /* STRING */
+	XCompoundTextStyle, /* COMPOUND_TEXT */
+	XTextStyle,         /* text in owner's encoding (current locale)*/
+	XStdICCTextStyle,   /* STRING, else COMPOUND_TEXT */
+	/* The following is an XFree86 extension, introduced in November 2000 */
+	XUTF8StringStyle /* UTF8_STRING */
+} XICCEncodingStyle;
+
+typedef struct
+{
+	int min_width, min_height;
+	int max_width, max_height;
+	int width_inc, height_inc;
+} XIconSize;
+
+typedef struct
+{
+	char* res_name;
+	char* res_class;
+} XClassHint;
+
+#ifdef XUTIL_DEFINE_FUNCTIONS
+extern int XDestroyImage(
+	XImage* ximage);
+extern unsigned long XGetPixel(
+	XImage* ximage,
+	int x, int y);
+extern int XPutPixel(
+	XImage* ximage,
+	int x, int y,
+	unsigned long pixel);
+extern XImage* XSubImage(
+	XImage* ximage,
+	int x, int y,
+	unsigned int width, unsigned int height);
+extern int XAddPixel(
+	XImage* ximage,
+	long value);
+#else
+/*
+ * These macros are used to give some sugar to the image routines so that
+ * naive people are more comfortable with them.
+ */
+#define XDestroyImage(ximage) \
+	((*((ximage)->f.destroy_image))((ximage)))
+#define XGetPixel(ximage, x, y) \
+	((*((ximage)->f.get_pixel))((ximage), (x), (y)))
+#define XPutPixel(ximage, x, y, pixel) \
+	((*((ximage)->f.put_pixel))((ximage), (x), (y), (pixel)))
+#define XSubImage(ximage, x, y, width, height) \
+	((*((ximage)->f.sub_image))((ximage), (x), (y), (width), (height)))
+#define XAddPixel(ximage, value) \
+	((*((ximage)->f.add_pixel))((ximage), (value)))
+#endif
+
+/*
+ * Compose sequence status structure, used in calling XLookupString.
+ */
+typedef struct _XComposeStatus
+{
+	XPointer compose_ptr; /* state table pointer */
+	int chars_matched;    /* match state */
+} XComposeStatus;
+
+/*
+ * Keysym macros, used on Keysyms to test for classes of symbols
+ */
+#define IsKeypadKey(keysym) \
+	(((KeySym)(keysym) >= XK_KP_Space) && ((KeySym)(keysym) <= XK_KP_Equal))
+
+#define IsPrivateKeypadKey(keysym) \
+	(((KeySym)(keysym) >= 0x11000000) && ((KeySym)(keysym) <= 0x1100FFFF))
+
+#define IsCursorKey(keysym) \
+	(((KeySym)(keysym) >= XK_Home) && ((KeySym)(keysym) < XK_Select))
+
+#define IsPFKey(keysym) \
+	(((KeySym)(keysym) >= XK_KP_F1) && ((KeySym)(keysym) <= XK_KP_F4))
+
+#define IsFunctionKey(keysym) \
+	(((KeySym)(keysym) >= XK_F1) && ((KeySym)(keysym) <= XK_F35))
+
+#define IsMiscFunctionKey(keysym) \
+	(((KeySym)(keysym) >= XK_Select) && ((KeySym)(keysym) <= XK_Break))
+
+#ifdef XK_XKB_KEYS
+#define IsModifierKey(keysym) \
+	((((KeySym)(keysym) >= XK_Shift_L) && ((KeySym)(keysym) <= XK_Hyper_R)) || (((KeySym)(keysym) >= XK_ISO_Lock) && ((KeySym)(keysym) <= XK_ISO_Level5_Lock)) || ((KeySym)(keysym) == XK_Mode_switch) || ((KeySym)(keysym) == XK_Num_Lock))
+#else
+#define IsModifierKey(keysym) \
+	((((KeySym)(keysym) >= XK_Shift_L) && ((KeySym)(keysym) <= XK_Hyper_R)) || ((KeySym)(keysym) == XK_Mode_switch) || ((KeySym)(keysym) == XK_Num_Lock))
+#endif
+/*
+ * opaque reference to Region data type
+ */
+typedef struct _XRegion* Region;
+
+/* Return values from XRectInRegion() */
+
+#define RectangleOut 0
+#define RectangleIn 1
+#define RectanglePart 2
+
+/*
+ * Information used by the visual utility routines to find desired visual
+ * type from the many visuals a display may support.
+ */
+
+typedef struct
+{
+	Visual* visual;
+	VisualID visualid;
+	int screen;
+	int depth;
+#if defined(__cplusplus) || defined(c_plusplus)
+	int c_class; /* C++ */
+#else
+	int class;
+#endif
+	unsigned long red_mask;
+	unsigned long green_mask;
+	unsigned long blue_mask;
+	int colormap_size;
+	int bits_per_rgb;
+} XVisualInfo;
+
+#define VisualNoMask 0x0
+#define VisualIDMask 0x1
+#define VisualScreenMask 0x2
+#define VisualDepthMask 0x4
+#define VisualClassMask 0x8
+#define VisualRedMaskMask 0x10
+#define VisualGreenMaskMask 0x20
+#define VisualBlueMaskMask 0x40
+#define VisualColormapSizeMask 0x80
+#define VisualBitsPerRGBMask 0x100
+#define VisualAllMask 0x1FF
+
+/*
+ * This defines a window manager property that clients may use to
+ * share standard color maps of type RGB_COLOR_MAP:
+ */
+typedef struct
+{
+	Colormap colormap;
+	unsigned long red_max;
+	unsigned long red_mult;
+	unsigned long green_max;
+	unsigned long green_mult;
+	unsigned long blue_max;
+	unsigned long blue_mult;
+	unsigned long base_pixel;
+	VisualID visualid; /* added by ICCCM version 1 */
+	XID killid;        /* added by ICCCM version 1 */
+} XStandardColormap;
+
+#define ReleaseByFreeingColormap ((XID)1L) /* for killid field above */
+
+/*
+ * return codes for XReadBitmapFile and XWriteBitmapFile
+ */
+#define BitmapSuccess 0
+#define BitmapOpenFailed 1
+#define BitmapFileInvalid 2
+#define BitmapNoMemory 3
+
+/****************************************************************
+ *
+ * Context Management
+ *
+ ****************************************************************/
+
+/* Associative lookup table return codes */
+
+#define XCSUCCESS 0 /* No error. */
+#define XCNOMEM 1   /* Out of memory */
+#define XCNOENT 2   /* No entry in table */
+
+typedef int XContext;
+
+#define XUniqueContext() ((XContext)XrmUniqueQuark())
+#define XStringToContext(string) ((XContext)XrmStringToQuark(string))
+
+_XFUNCPROTOBEGIN
+
+/* The following declarations are alphabetized. */
+
+extern XClassHint* XAllocClassHint(
+	void);
+
+extern XIconSize* XAllocIconSize(
+	void);
+
+extern XSizeHints* XAllocSizeHints(
+	void);
+
+extern XStandardColormap* XAllocStandardColormap(
+	void);
+
+extern XWMHints* XAllocWMHints(
+	void);
+
+extern int XClipBox(
+	Region /* r */,
+	XRectangle* /* rect_return */
+);
+
+extern Region XCreateRegion(
+	void);
+
+extern const char* XDefaultString(void);
+
+extern int XDeleteContext(
+	Display* /* display */,
+	XID /* rid */,
+	XContext /* context */
+);
+
+extern int XDestroyRegion(
+	Region /* r */
+);
+
+extern int XEmptyRegion(
+	Region /* r */
+);
+
+extern int XEqualRegion(
+	Region /* r1 */,
+	Region /* r2 */
+);
+
+extern int XFindContext(
+	Display* /* display */,
+	XID /* rid */,
+	XContext /* context */,
+	XPointer* /* data_return */
+);
+
+extern Status XGetClassHint(
+	Display* /* display */,
+	Window /* w */,
+	XClassHint* /* class_hints_return */
+);
+
+extern Status XGetIconSizes(
+	Display* /* display */,
+	Window /* w */,
+	XIconSize** /* size_list_return */,
+	int* /* count_return */
+);
+
+extern Status XGetNormalHints(
+	Display* /* display */,
+	Window /* w */,
+	XSizeHints* /* hints_return */
+);
+
+extern Status XGetRGBColormaps(
+	Display* /* display */,
+	Window /* w */,
+	XStandardColormap** /* stdcmap_return */,
+	int* /* count_return */,
+	Atom /* property */
+);
+
+extern Status XGetSizeHints(
+	Display* /* display */,
+	Window /* w */,
+	XSizeHints* /* hints_return */,
+	Atom /* property */
+);
+
+extern Status XGetStandardColormap(
+	Display* /* display */,
+	Window /* w */,
+	XStandardColormap* /* colormap_return */,
+	Atom /* property */
+);
+
+extern Status XGetTextProperty(
+	Display* /* display */,
+	Window /* window */,
+	XTextProperty* /* text_prop_return */,
+	Atom /* property */
+);
+
+extern XVisualInfo* XGetVisualInfo(
+	Display* /* display */,
+	long /* vinfo_mask */,
+	XVisualInfo* /* vinfo_template */,
+	int* /* nitems_return */
+);
+
+extern Status XGetWMClientMachine(
+	Display* /* display */,
+	Window /* w */,
+	XTextProperty* /* text_prop_return */
+);
+
+extern XWMHints* XGetWMHints(
+	Display* /* display */,
+	Window /* w */
+);
+
+extern Status XGetWMIconName(
+	Display* /* display */,
+	Window /* w */,
+	XTextProperty* /* text_prop_return */
+);
+
+extern Status XGetWMName(
+	Display* /* display */,
+	Window /* w */,
+	XTextProperty* /* text_prop_return */
+);
+
+extern Status XGetWMNormalHints(
+	Display* /* display */,
+	Window /* w */,
+	XSizeHints* /* hints_return */,
+	long* /* supplied_return */
+);
+
+extern Status XGetWMSizeHints(
+	Display* /* display */,
+	Window /* w */,
+	XSizeHints* /* hints_return */,
+	long* /* supplied_return */,
+	Atom /* property */
+);
+
+extern Status XGetZoomHints(
+	Display* /* display */,
+	Window /* w */,
+	XSizeHints* /* zhints_return */
+);
+
+extern int XIntersectRegion(
+	Region /* sra */,
+	Region /* srb */,
+	Region /* dr_return */
+);
+
+extern void XConvertCase(
+	KeySym /* sym */,
+	KeySym* /* lower */,
+	KeySym* /* upper */
+);
+
+extern int XLookupString(
+	XKeyEvent* /* event_struct */,
+	char* /* buffer_return */,
+	int /* bytes_buffer */,
+	KeySym* /* keysym_return */,
+	XComposeStatus* /* status_in_out */
+);
+
+extern Status XMatchVisualInfo(
+	Display* /* display */,
+	int /* screen */,
+	int /* depth */,
+	int /* class */,
+	XVisualInfo* /* vinfo_return */
+);
+
+extern int XOffsetRegion(
+	Region /* r */,
+	int /* dx */,
+	int /* dy */
+);
+
+extern Bool XPointInRegion(
+	Region /* r */,
+	int /* x */,
+	int /* y */
+);
+
+extern Region XPolygonRegion(
+	XPoint* /* points */,
+	int /* n */,
+	int /* fill_rule */
+);
+
+extern int XRectInRegion(
+	Region /* r */,
+	int /* x */,
+	int /* y */,
+	unsigned int /* width */,
+	unsigned int /* height */
+);
+
+extern int XSaveContext(
+	Display* /* display */,
+	XID /* rid */,
+	XContext /* context */,
+	_Xconst char* /* data */
+);
+
+extern int XSetClassHint(
+	Display* /* display */,
+	Window /* w */,
+	XClassHint* /* class_hints */
+);
+
+extern int XSetIconSizes(
+	Display* /* display */,
+	Window /* w */,
+	XIconSize* /* size_list */,
+	int /* count */
+);
+
+extern int XSetNormalHints(
+	Display* /* display */,
+	Window /* w */,
+	XSizeHints* /* hints */
+);
+
+extern void XSetRGBColormaps(
+	Display* /* display */,
+	Window /* w */,
+	XStandardColormap* /* stdcmaps */,
+	int /* count */,
+	Atom /* property */
+);
+
+extern int XSetSizeHints(
+	Display* /* display */,
+	Window /* w */,
+	XSizeHints* /* hints */,
+	Atom /* property */
+);
+
+extern int XSetStandardProperties(
+	Display* /* display */,
+	Window /* w */,
+	_Xconst char* /* window_name */,
+	_Xconst char* /* icon_name */,
+	Pixmap /* icon_pixmap */,
+	char** /* argv */,
+	int /* argc */,
+	XSizeHints* /* hints */
+);
+
+extern void XSetTextProperty(
+	Display* /* display */,
+	Window /* w */,
+	XTextProperty* /* text_prop */,
+	Atom /* property */
+);
+
+extern void XSetWMClientMachine(
+	Display* /* display */,
+	Window /* w */,
+	XTextProperty* /* text_prop */
+);
+
+extern int XSetWMHints(
+	Display* /* display */,
+	Window /* w */,
+	XWMHints* /* wm_hints */
+);
+
+extern void XSetWMIconName(
+	Display* /* display */,
+	Window /* w */,
+	XTextProperty* /* text_prop */
+);
+
+extern void XSetWMName(
+	Display* /* display */,
+	Window /* w */,
+	XTextProperty* /* text_prop */
+);
+
+extern void XSetWMNormalHints(
+	Display* /* display */,
+	Window /* w */,
+	XSizeHints* /* hints */
+);
+
+extern void XSetWMProperties(
+	Display* /* display */,
+	Window /* w */,
+	XTextProperty* /* window_name */,
+	XTextProperty* /* icon_name */,
+	char** /* argv */,
+	int /* argc */,
+	XSizeHints* /* normal_hints */,
+	XWMHints* /* wm_hints */,
+	XClassHint* /* class_hints */
+);
+
+extern void XmbSetWMProperties(
+	Display* /* display */,
+	Window /* w */,
+	_Xconst char* /* window_name */,
+	_Xconst char* /* icon_name */,
+	char** /* argv */,
+	int /* argc */,
+	XSizeHints* /* normal_hints */,
+	XWMHints* /* wm_hints */,
+	XClassHint* /* class_hints */
+);
+
+extern void Xutf8SetWMProperties(
+	Display* /* display */,
+	Window /* w */,
+	_Xconst char* /* window_name */,
+	_Xconst char* /* icon_name */,
+	char** /* argv */,
+	int /* argc */,
+	XSizeHints* /* normal_hints */,
+	XWMHints* /* wm_hints */,
+	XClassHint* /* class_hints */
+);
+
+extern void XSetWMSizeHints(
+	Display* /* display */,
+	Window /* w */,
+	XSizeHints* /* hints */,
+	Atom /* property */
+);
+
+extern int XSetRegion(
+	Display* /* display */,
+	GC /* gc */,
+	Region /* r */
+);
+
+extern void XSetStandardColormap(
+	Display* /* display */,
+	Window /* w */,
+	XStandardColormap* /* colormap */,
+	Atom /* property */
+);
+
+extern int XSetZoomHints(
+	Display* /* display */,
+	Window /* w */,
+	XSizeHints* /* zhints */
+);
+
+extern int XShrinkRegion(
+	Region /* r */,
+	int /* dx */,
+	int /* dy */
+);
+
+extern Status XStringListToTextProperty(
+	char** /* list */,
+	int /* count */,
+	XTextProperty* /* text_prop_return */
+);
+
+extern int XSubtractRegion(
+	Region /* sra */,
+	Region /* srb */,
+	Region /* dr_return */
+);
+
+extern int XmbTextListToTextProperty(
+	Display* display,
+	char** list,
+	int count,
+	XICCEncodingStyle style,
+	XTextProperty* text_prop_return);
+
+extern int XwcTextListToTextProperty(
+	Display* display,
+	wchar_t** list,
+	int count,
+	XICCEncodingStyle style,
+	XTextProperty* text_prop_return);
+
+extern int Xutf8TextListToTextProperty(
+	Display* display,
+	char** list,
+	int count,
+	XICCEncodingStyle style,
+	XTextProperty* text_prop_return);
+
+extern void XwcFreeStringList(
+	wchar_t** list);
+
+extern Status XTextPropertyToStringList(
+	XTextProperty* /* text_prop */,
+	char*** /* list_return */,
+	int* /* count_return */
+);
+
+extern int XmbTextPropertyToTextList(
+	Display* display,
+	const XTextProperty* text_prop,
+	char*** list_return,
+	int* count_return);
+
+extern int XwcTextPropertyToTextList(
+	Display* display,
+	const XTextProperty* text_prop,
+	wchar_t*** list_return,
+	int* count_return);
+
+extern int Xutf8TextPropertyToTextList(
+	Display* display,
+	const XTextProperty* text_prop,
+	char*** list_return,
+	int* count_return);
+
+extern int XUnionRectWithRegion(
+	XRectangle* /* rectangle */,
+	Region /* src_region */,
+	Region /* dest_region_return */
+);
+
+extern int XUnionRegion(
+	Region /* sra */,
+	Region /* srb */,
+	Region /* dr_return */
+);
+
+extern int XWMGeometry(
+	Display* /* display */,
+	int /* screen_number */,
+	_Xconst char* /* user_geometry */,
+	_Xconst char* /* default_geometry */,
+	unsigned int /* border_width */,
+	XSizeHints* /* hints */,
+	int* /* x_return */,
+	int* /* y_return */,
+	int* /* width_return */,
+	int* /* height_return */,
+	int* /* gravity_return */
+);
+
+extern int XXorRegion(
+	Region /* sra */,
+	Region /* srb */,
+	Region /* dr_return */
+);
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+_XFUNCPROTOEND
+
+#endif /* _X11_XUTIL_H_ */
diff --git a/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/cursorfont.h b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/cursorfont.h
new file mode 100644
index 00000000..c69d508f
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/cursorfont.h
@@ -0,0 +1,111 @@
+/*
+
+Copyright 1987, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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 OPEN GROUP 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.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+
+*/
+
+#ifndef _X11_CURSORFONT_H_
+#define _X11_CURSORFONT_H_
+
+#define XC_num_glyphs 154
+#define XC_X_cursor 0
+#define XC_arrow 2
+#define XC_based_arrow_down 4
+#define XC_based_arrow_up 6
+#define XC_boat 8
+#define XC_bogosity 10
+#define XC_bottom_left_corner 12
+#define XC_bottom_right_corner 14
+#define XC_bottom_side 16
+#define XC_bottom_tee 18
+#define XC_box_spiral 20
+#define XC_center_ptr 22
+#define XC_circle 24
+#define XC_clock 26
+#define XC_coffee_mug 28
+#define XC_cross 30
+#define XC_cross_reverse 32
+#define XC_crosshair 34
+#define XC_diamond_cross 36
+#define XC_dot 38
+#define XC_dotbox 40
+#define XC_double_arrow 42
+#define XC_draft_large 44
+#define XC_draft_small 46
+#define XC_draped_box 48
+#define XC_exchange 50
+#define XC_fleur 52
+#define XC_gobbler 54
+#define XC_gumby 56
+#define XC_hand1 58
+#define XC_hand2 60
+#define XC_heart 62
+#define XC_icon 64
+#define XC_iron_cross 66
+#define XC_left_ptr 68
+#define XC_left_side 70
+#define XC_left_tee 72
+#define XC_leftbutton 74
+#define XC_ll_angle 76
+#define XC_lr_angle 78
+#define XC_man 80
+#define XC_middlebutton 82
+#define XC_mouse 84
+#define XC_pencil 86
+#define XC_pirate 88
+#define XC_plus 90
+#define XC_question_arrow 92
+#define XC_right_ptr 94
+#define XC_right_side 96
+#define XC_right_tee 98
+#define XC_rightbutton 100
+#define XC_rtl_logo 102
+#define XC_sailboat 104
+#define XC_sb_down_arrow 106
+#define XC_sb_h_double_arrow 108
+#define XC_sb_left_arrow 110
+#define XC_sb_right_arrow 112
+#define XC_sb_up_arrow 114
+#define XC_sb_v_double_arrow 116
+#define XC_shuttle 118
+#define XC_sizing 120
+#define XC_spider 122
+#define XC_spraycan 124
+#define XC_star 126
+#define XC_target 128
+#define XC_tcross 130
+#define XC_top_left_arrow 132
+#define XC_top_left_corner 134
+#define XC_top_right_corner 136
+#define XC_top_side 138
+#define XC_top_tee 140
+#define XC_trek 142
+#define XC_ul_angle 144
+#define XC_umbrella 146
+#define XC_ur_angle 148
+#define XC_watch 150
+#define XC_xterm 152
+
+#endif /* _X11_CURSORFONT_H_ */
diff --git a/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/extensions/XKB.h b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/extensions/XKB.h
new file mode 100644
index 00000000..6b1c54eb
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/extensions/XKB.h
@@ -0,0 +1,784 @@
+/************************************************************
+Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
+
+Permission to use, copy, modify, and distribute this
+software and its documentation for any purpose and without
+fee is hereby granted, provided that the above copyright
+notice appear in all copies and that both that copyright
+notice and this permission notice appear in supporting
+documentation, and that the name of Silicon Graphics not be 
+used in advertising or publicity pertaining to distribution 
+of the software without specific prior written permission.
+Silicon Graphics makes no representation about the suitability 
+of this software for any purpose. It is provided "as is"
+without any express or implied warranty.
+
+SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS 
+SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 
+AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
+GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL 
+DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, 
+DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE 
+OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
+THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+********************************************************/
+
+#ifndef _XKB_H_
+#define _XKB_H_
+
+/*
+     * XKB request codes, used in:
+     *  -  xkbReqType field of all requests
+     *  -  requestMinor field of some events
+     */
+#define X_kbUseExtension 0
+#define X_kbSelectEvents 1
+#define X_kbBell 3
+#define X_kbGetState 4
+#define X_kbLatchLockState 5
+#define X_kbGetControls 6
+#define X_kbSetControls 7
+#define X_kbGetMap 8
+#define X_kbSetMap 9
+#define X_kbGetCompatMap 10
+#define X_kbSetCompatMap 11
+#define X_kbGetIndicatorState 12
+#define X_kbGetIndicatorMap 13
+#define X_kbSetIndicatorMap 14
+#define X_kbGetNamedIndicator 15
+#define X_kbSetNamedIndicator 16
+#define X_kbGetNames 17
+#define X_kbSetNames 18
+#define X_kbGetGeometry 19
+#define X_kbSetGeometry 20
+#define X_kbPerClientFlags 21
+#define X_kbListComponents 22
+#define X_kbGetKbdByName 23
+#define X_kbGetDeviceInfo 24
+#define X_kbSetDeviceInfo 25
+#define X_kbSetDebuggingFlags 101
+
+/*
+     * In the X sense, XKB reports only one event.
+     * The type field of all XKB events is XkbEventCode
+     */
+#define XkbEventCode 0
+#define XkbNumberEvents (XkbEventCode + 1)
+
+/*
+     * XKB has a minor event code so it can use one X event code for 
+     * multiple purposes.  
+     *  - reported in the xkbType field of all XKB events.
+     *  - XkbSelectEventDetails: Indicates the event for which event details 
+     *    are being changed
+     */
+#define XkbNewKeyboardNotify 0
+#define XkbMapNotify 1
+#define XkbStateNotify 2
+#define XkbControlsNotify 3
+#define XkbIndicatorStateNotify 4
+#define XkbIndicatorMapNotify 5
+#define XkbNamesNotify 6
+#define XkbCompatMapNotify 7
+#define XkbBellNotify 8
+#define XkbActionMessage 9
+#define XkbAccessXNotify 10
+#define XkbExtensionDeviceNotify 11
+
+/*
+     * Event Mask:
+     *  - XkbSelectEvents:  Specifies event interest.
+     */
+#define XkbNewKeyboardNotifyMask (1L << 0)
+#define XkbMapNotifyMask (1L << 1)
+#define XkbStateNotifyMask (1L << 2)
+#define XkbControlsNotifyMask (1L << 3)
+#define XkbIndicatorStateNotifyMask (1L << 4)
+#define XkbIndicatorMapNotifyMask (1L << 5)
+#define XkbNamesNotifyMask (1L << 6)
+#define XkbCompatMapNotifyMask (1L << 7)
+#define XkbBellNotifyMask (1L << 8)
+#define XkbActionMessageMask (1L << 9)
+#define XkbAccessXNotifyMask (1L << 10)
+#define XkbExtensionDeviceNotifyMask (1L << 11)
+#define XkbAllEventsMask (0xFFF)
+
+/*
+     * NewKeyboardNotify event details:
+     */
+#define XkbNKN_KeycodesMask (1L << 0)
+#define XkbNKN_GeometryMask (1L << 1)
+#define XkbNKN_DeviceIDMask (1L << 2)
+#define XkbAllNewKeyboardEventsMask (0x7)
+
+/*
+     * AccessXNotify event types:
+     *  - The 'what' field of AccessXNotify events reports the
+     *    reason that the event was generated.
+     */
+#define XkbAXN_SKPress 0
+#define XkbAXN_SKAccept 1
+#define XkbAXN_SKReject 2
+#define XkbAXN_SKRelease 3
+#define XkbAXN_BKAccept 4
+#define XkbAXN_BKReject 5
+#define XkbAXN_AXKWarning 6
+
+/*
+     * AccessXNotify details:
+     * - Used as an event detail mask to limit the conditions under which
+     *   AccessXNotify events are reported
+     */
+#define XkbAXN_SKPressMask (1L << 0)
+#define XkbAXN_SKAcceptMask (1L << 1)
+#define XkbAXN_SKRejectMask (1L << 2)
+#define XkbAXN_SKReleaseMask (1L << 3)
+#define XkbAXN_BKAcceptMask (1L << 4)
+#define XkbAXN_BKRejectMask (1L << 5)
+#define XkbAXN_AXKWarningMask (1L << 6)
+#define XkbAllAccessXEventsMask (0x7f)
+
+/*
+     * Miscellaneous event details:
+     * - event detail masks for assorted events that don't reall
+     *   have any details.
+     */
+#define XkbAllStateEventsMask XkbAllStateComponentsMask
+#define XkbAllMapEventsMask XkbAllMapComponentsMask
+#define XkbAllControlEventsMask XkbAllControlsMask
+#define XkbAllIndicatorEventsMask XkbAllIndicatorsMask
+#define XkbAllNameEventsMask XkbAllNamesMask
+#define XkbAllCompatMapEventsMask XkbAllCompatMask
+#define XkbAllBellEventsMask (1L << 0)
+#define XkbAllActionMessagesMask (1L << 0)
+
+/*
+     * XKB reports one error:  BadKeyboard
+     * A further reason for the error is encoded into to most significant
+     * byte of the resourceID for the error:
+     *    XkbErr_BadDevice - the device in question was not found
+     *    XkbErr_BadClass  - the device was found but it doesn't belong to 
+     *                       the appropriate class.
+     *    XkbErr_BadId     - the device was found and belongs to the right
+     *                       class, but not feedback with a matching id was
+     *                       found.
+     * The low byte of the resourceID for this error contains the device
+     * id, class specifier or feedback id that failed.
+     */
+#define XkbKeyboard 0
+#define XkbNumberErrors 1
+
+#define XkbErr_BadDevice 0xff
+#define XkbErr_BadClass 0xfe
+#define XkbErr_BadId 0xfd
+
+/*
+     * Keyboard Components Mask:
+     * - Specifies the components that follow a GetKeyboardByNameReply
+     */
+#define XkbClientMapMask (1L << 0)
+#define XkbServerMapMask (1L << 1)
+#define XkbCompatMapMask (1L << 2)
+#define XkbIndicatorMapMask (1L << 3)
+#define XkbNamesMask (1L << 4)
+#define XkbGeometryMask (1L << 5)
+#define XkbControlsMask (1L << 6)
+#define XkbAllComponentsMask (0x7f)
+
+/*
+     * State detail mask:
+     *  - The 'changed' field of StateNotify events reports which of
+     *    the keyboard state components have changed.
+     *  - Used as an event detail mask to limit the conditions under
+     *    which StateNotify events are reported.
+     */
+#define XkbModifierStateMask (1L << 0)
+#define XkbModifierBaseMask (1L << 1)
+#define XkbModifierLatchMask (1L << 2)
+#define XkbModifierLockMask (1L << 3)
+#define XkbGroupStateMask (1L << 4)
+#define XkbGroupBaseMask (1L << 5)
+#define XkbGroupLatchMask (1L << 6)
+#define XkbGroupLockMask (1L << 7)
+#define XkbCompatStateMask (1L << 8)
+#define XkbGrabModsMask (1L << 9)
+#define XkbCompatGrabModsMask (1L << 10)
+#define XkbLookupModsMask (1L << 11)
+#define XkbCompatLookupModsMask (1L << 12)
+#define XkbPointerButtonMask (1L << 13)
+#define XkbAllStateComponentsMask (0x3fff)
+
+/*
+     * Controls detail masks:
+     *  The controls specified in XkbAllControlsMask:
+     *  - The 'changed' field of ControlsNotify events reports which of 
+     *    the keyboard controls have changed.
+     *  - The 'changeControls' field of the SetControls request specifies
+     *    the controls for which values are to be changed.
+     *  - Used as an event detail mask to limit the conditions under 
+     *    which ControlsNotify events are reported.
+     *
+     *  The controls specified in the XkbAllBooleanCtrlsMask:
+     *  - The 'enabledControls' field of ControlsNotify events reports the
+     *    current status of the boolean controls.
+     *  - The 'enabledControlsChanges' field of ControlsNotify events reports
+     *    any boolean controls that have been turned on or off.
+     *  - The 'affectEnabledControls' and 'enabledControls' fields of the
+     *    kbSetControls request change the set of enabled controls.
+     *  - The 'accessXTimeoutMask' and 'accessXTimeoutValues' fields of
+     *    an XkbControlsRec specify the controls to be changed if the keyboard
+     *    times out and the values to which they should be changed.
+     *  - The 'autoCtrls' and 'autoCtrlsValues' fields of the PerClientFlags 
+     *    request specifies the specify the controls to be reset when the
+     *    client exits and the values to which they should be reset.
+     *  - The 'ctrls' field of an indicator map specifies the controls
+     *    that drive the indicator.
+     *  - Specifies the boolean controls affected by the SetControls and
+     *    LockControls key actions.
+     */
+#define XkbRepeatKeysMask (1L << 0)
+#define XkbSlowKeysMask (1L << 1)
+#define XkbBounceKeysMask (1L << 2)
+#define XkbStickyKeysMask (1L << 3)
+#define XkbMouseKeysMask (1L << 4)
+#define XkbMouseKeysAccelMask (1L << 5)
+#define XkbAccessXKeysMask (1L << 6)
+#define XkbAccessXTimeoutMask (1L << 7)
+#define XkbAccessXFeedbackMask (1L << 8)
+#define XkbAudibleBellMask (1L << 9)
+#define XkbOverlay1Mask (1L << 10)
+#define XkbOverlay2Mask (1L << 11)
+#define XkbIgnoreGroupLockMask (1L << 12)
+#define XkbGroupsWrapMask (1L << 27)
+#define XkbInternalModsMask (1L << 28)
+#define XkbIgnoreLockModsMask (1L << 29)
+#define XkbPerKeyRepeatMask (1L << 30)
+#define XkbControlsEnabledMask (1L << 31)
+
+#define XkbAccessXOptionsMask (XkbStickyKeysMask | XkbAccessXFeedbackMask)
+
+#define XkbAllBooleanCtrlsMask (0x00001FFF)
+#define XkbAllControlsMask (0xF8001FFF)
+#define XkbAllControlEventsMask XkbAllControlsMask
+
+/*
+     * AccessX Options Mask
+     *  - The 'accessXOptions' field of an XkbControlsRec specifies the
+     *    AccessX options that are currently in effect.
+     *  - The 'accessXTimeoutOptionsMask' and 'accessXTimeoutOptionsValues'
+     *    fields of an XkbControlsRec specify the Access X options to be 
+     *    changed if the keyboard times out and the values to which they 
+     *    should be changed.
+     */
+#define XkbAX_SKPressFBMask (1L << 0)
+#define XkbAX_SKAcceptFBMask (1L << 1)
+#define XkbAX_FeatureFBMask (1L << 2)
+#define XkbAX_SlowWarnFBMask (1L << 3)
+#define XkbAX_IndicatorFBMask (1L << 4)
+#define XkbAX_StickyKeysFBMask (1L << 5)
+#define XkbAX_TwoKeysMask (1L << 6)
+#define XkbAX_LatchToLockMask (1L << 7)
+#define XkbAX_SKReleaseFBMask (1L << 8)
+#define XkbAX_SKRejectFBMask (1L << 9)
+#define XkbAX_BKRejectFBMask (1L << 10)
+#define XkbAX_DumbBellFBMask (1L << 11)
+#define XkbAX_FBOptionsMask (0xF3F)
+#define XkbAX_SKOptionsMask (0x0C0)
+#define XkbAX_AllOptionsMask (0xFFF)
+
+/*
+     * XkbUseCoreKbd is used to specify the core keyboard without having
+     * 			to look up its X input extension identifier.
+     * XkbUseCorePtr is used to specify the core pointer without having
+     *			to look up its X input extension identifier.
+     * XkbDfltXIClass is used to specify "don't care" any place that the
+     *			XKB protocol is looking for an X Input Extension 
+     *			device class.
+     * XkbDfltXIId is used to specify "don't care" any place that the
+     *			XKB protocol is looking for an X Input Extension
+     *			feedback identifier.
+     * XkbAllXIClasses is used to get information about all device indicators,
+     *			whether they're part of the indicator feedback class
+     *			or the keyboard feedback class.
+     * XkbAllXIIds is used to get information about all device indicator
+     *			feedbacks without having to list them.
+     * XkbXINone is used to indicate that no class or id has been specified.
+     * XkbLegalXILedClass(c)  True if 'c' specifies a legal class with LEDs
+     * XkbLegalXIBellClass(c) True if 'c' specifies a legal class with bells
+     * XkbExplicitXIDevice(d) True if 'd' explicitly specifies a device
+     * XkbExplicitXIClass(c)  True if 'c' explicitly specifies a device class
+     * XkbExplicitXIId(c)     True if 'i' explicitly specifies a device id
+     * XkbSingleXIClass(c)    True if 'c' specifies exactly one device class, 
+     *                        including the default.
+     * XkbSingleXIId(i)       True if 'i' specifies exactly one device 
+     *	                      identifier, including the default.
+     */
+#define XkbUseCoreKbd 0x0100
+#define XkbUseCorePtr 0x0200
+#define XkbDfltXIClass 0x0300
+#define XkbDfltXIId 0x0400
+#define XkbAllXIClasses 0x0500
+#define XkbAllXIIds 0x0600
+#define XkbXINone 0xff00
+
+#define XkbLegalXILedClass(c) (((c) == KbdFeedbackClass) || \
+							   ((c) == LedFeedbackClass) || \
+							   ((c) == XkbDfltXIClass) ||   \
+							   ((c) == XkbAllXIClasses))
+#define XkbLegalXIBellClass(c) (((c) == KbdFeedbackClass) ||  \
+								((c) == BellFeedbackClass) || \
+								((c) == XkbDfltXIClass) ||    \
+								((c) == XkbAllXIClasses))
+#define XkbExplicitXIDevice(c) (((c) & (~0xff)) == 0)
+#define XkbExplicitXIClass(c) (((c) & (~0xff)) == 0)
+#define XkbExplicitXIId(c) (((c) & (~0xff)) == 0)
+#define XkbSingleXIClass(c) ((((c) & (~0xff)) == 0) || ((c) == XkbDfltXIClass))
+#define XkbSingleXIId(c) ((((c) & (~0xff)) == 0) || ((c) == XkbDfltXIId))
+
+#define XkbNoModifier 0xff
+#define XkbNoShiftLevel 0xff
+#define XkbNoShape 0xff
+#define XkbNoIndicator 0xff
+
+#define XkbNoModifierMask 0
+#define XkbAllModifiersMask 0xff
+#define XkbAllVirtualModsMask 0xffff
+
+#define XkbNumKbdGroups 4
+#define XkbMaxKbdGroup (XkbNumKbdGroups - 1)
+
+#define XkbMaxMouseKeysBtn 4
+
+/*
+     * Group Index and Mask:
+     *  - Indices into the kt_index array of a key type.
+     *  - Mask specifies types to be changed for XkbChangeTypesOfKey
+     */
+#define XkbGroup1Index 0
+#define XkbGroup2Index 1
+#define XkbGroup3Index 2
+#define XkbGroup4Index 3
+#define XkbAnyGroup 254
+#define XkbAllGroups 255
+
+#define XkbGroup1Mask (1 << 0)
+#define XkbGroup2Mask (1 << 1)
+#define XkbGroup3Mask (1 << 2)
+#define XkbGroup4Mask (1 << 3)
+#define XkbAnyGroupMask (1 << 7)
+#define XkbAllGroupsMask (0xf)
+
+/*
+     * BuildCoreState: Given a keyboard group and a modifier state,
+     *                 construct the value to be reported an event.
+     * GroupForCoreState:  Given the state reported in an event,
+     *                 determine the keyboard group.
+     * IsLegalGroup:   Returns TRUE if 'g' is a valid group index.
+     */
+#define XkbBuildCoreState(m, g) ((((g)&0x3) << 13) | ((m)&0xff))
+#define XkbGroupForCoreState(s) (((s) >> 13) & 0x3)
+#define XkbIsLegalGroup(g) (((g) >= 0) && ((g) < XkbNumKbdGroups))
+
+/*
+     * GroupsWrap values:
+     *  - The 'groupsWrap' field of an XkbControlsRec specifies the
+     *    treatment of out of range groups.
+     *  - Bits 6 and 7 of the group info field of a key symbol map
+     *    specify the interpretation of out of range groups for the
+     *    corresponding key.
+     */
+#define XkbWrapIntoRange (0x00)
+#define XkbClampIntoRange (0x40)
+#define XkbRedirectIntoRange (0x80)
+
+/*
+     * Action flags:  Reported in the 'flags' field of most key actions.
+     * Interpretation depends on the type of the action; not all actions
+     * accept all flags.
+     *
+     * Option			Used for Actions
+     * ------			----------------
+     * ClearLocks		SetMods, LatchMods, SetGroup, LatchGroup
+     * LatchToLock		SetMods, LatchMods, SetGroup, LatchGroup
+     * LockNoLock		LockMods, ISOLock, LockPtrBtn, LockDeviceBtn
+     * LockNoUnlock		LockMods, ISOLock, LockPtrBtn, LockDeviceBtn
+     * UseModMapMods		SetMods, LatchMods, LockMods, ISOLock
+     * GroupAbsolute		SetGroup, LatchGroup, LockGroup, ISOLock
+     * UseDfltButton		PtrBtn, LockPtrBtn
+     * NoAcceleration		MovePtr
+     * MoveAbsoluteX		MovePtr
+     * MoveAbsoluteY		MovePtr
+     * ISODfltIsGroup		ISOLock
+     * ISONoAffectMods		ISOLock
+     * ISONoAffectGroup		ISOLock
+     * ISONoAffectPtr		ISOLock
+     * ISONoAffectCtrls		ISOLock
+     * MessageOnPress		ActionMessage
+     * MessageOnRelease		ActionMessage
+     * MessageGenKeyEvent	ActionMessage
+     * AffectDfltBtn		SetPtrDflt
+     * DfltBtnAbsolute		SetPtrDflt
+     * SwitchApplication	SwitchScreen
+     * SwitchAbsolute		SwitchScreen
+     */
+
+#define XkbSA_ClearLocks (1L << 0)
+#define XkbSA_LatchToLock (1L << 1)
+
+#define XkbSA_LockNoLock (1L << 0)
+#define XkbSA_LockNoUnlock (1L << 1)
+
+#define XkbSA_UseModMapMods (1L << 2)
+
+#define XkbSA_GroupAbsolute (1L << 2)
+#define XkbSA_UseDfltButton 0
+
+#define XkbSA_NoAcceleration (1L << 0)
+#define XkbSA_MoveAbsoluteX (1L << 1)
+#define XkbSA_MoveAbsoluteY (1L << 2)
+
+#define XkbSA_ISODfltIsGroup (1L << 7)
+#define XkbSA_ISONoAffectMods (1L << 6)
+#define XkbSA_ISONoAffectGroup (1L << 5)
+#define XkbSA_ISONoAffectPtr (1L << 4)
+#define XkbSA_ISONoAffectCtrls (1L << 3)
+#define XkbSA_ISOAffectMask (0x78)
+
+#define XkbSA_MessageOnPress (1L << 0)
+#define XkbSA_MessageOnRelease (1L << 1)
+#define XkbSA_MessageGenKeyEvent (1L << 2)
+
+#define XkbSA_AffectDfltBtn 1
+#define XkbSA_DfltBtnAbsolute (1L << 2)
+
+#define XkbSA_SwitchApplication (1L << 0)
+#define XkbSA_SwitchAbsolute (1L << 2)
+
+/*
+     * The following values apply to the SA_DeviceValuator 
+     * action only.  Valuator operations specify the action 
+     * to be taken.   Values specified in the action are 
+     * multiplied by 2^scale before they are applied.
+     */
+#define XkbSA_IgnoreVal (0x00)
+#define XkbSA_SetValMin (0x10)
+#define XkbSA_SetValCenter (0x20)
+#define XkbSA_SetValMax (0x30)
+#define XkbSA_SetValRelative (0x40)
+#define XkbSA_SetValAbsolute (0x50)
+#define XkbSA_ValOpMask (0x70)
+#define XkbSA_ValScaleMask (0x07)
+#define XkbSA_ValOp(a) ((a)&XkbSA_ValOpMask)
+#define XkbSA_ValScale(a) ((a)&XkbSA_ValScaleMask)
+
+/*
+     * Action types: specifies the type of a key action.  Reported in the
+     * type field of all key actions.
+     */
+#define XkbSA_NoAction 0x00
+#define XkbSA_SetMods 0x01
+#define XkbSA_LatchMods 0x02
+#define XkbSA_LockMods 0x03
+#define XkbSA_SetGroup 0x04
+#define XkbSA_LatchGroup 0x05
+#define XkbSA_LockGroup 0x06
+#define XkbSA_MovePtr 0x07
+#define XkbSA_PtrBtn 0x08
+#define XkbSA_LockPtrBtn 0x09
+#define XkbSA_SetPtrDflt 0x0a
+#define XkbSA_ISOLock 0x0b
+#define XkbSA_Terminate 0x0c
+#define XkbSA_SwitchScreen 0x0d
+#define XkbSA_SetControls 0x0e
+#define XkbSA_LockControls 0x0f
+#define XkbSA_ActionMessage 0x10
+#define XkbSA_RedirectKey 0x11
+#define XkbSA_DeviceBtn 0x12
+#define XkbSA_LockDeviceBtn 0x13
+#define XkbSA_DeviceValuator 0x14
+#define XkbSA_LastAction XkbSA_DeviceValuator
+#define XkbSA_NumActions (XkbSA_LastAction + 1)
+
+#define XkbSA_XFree86Private 0x86
+
+/*
+     * Specifies the key actions that clear latched groups or modifiers.
+     */
+#define XkbSA_BreakLatch                                                             \
+	((1 << XkbSA_NoAction) | (1 << XkbSA_PtrBtn) | (1 << XkbSA_LockPtrBtn) |         \
+	 (1 << XkbSA_Terminate) | (1 << XkbSA_SwitchScreen) | (1 << XkbSA_SetControls) | \
+	 (1 << XkbSA_LockControls) | (1 << XkbSA_ActionMessage) |                        \
+	 (1 << XkbSA_RedirectKey) | (1 << XkbSA_DeviceBtn) | (1 << XkbSA_LockDeviceBtn))
+
+/*
+     * Macros to classify key actions
+     */
+#define XkbIsModAction(a) (((a)->type >= Xkb_SASetMods) && ((a)->type <= XkbSA_LockMods))
+#define XkbIsGroupAction(a) (((a)->type >= XkbSA_SetGroup) && ((a)->type <= XkbSA_LockGroup))
+#define XkbIsPtrAction(a) (((a)->type >= XkbSA_MovePtr) && ((a)->type <= XkbSA_SetPtrDflt))
+
+/*
+     * Key Behavior Qualifier:
+     *    KB_Permanent indicates that the behavior describes an unalterable
+     *    characteristic of the keyboard, not an XKB software-simulation of
+     *    the listed behavior.
+     * Key Behavior Types:  
+     *    Specifies the behavior of the underlying key.
+     */
+#define XkbKB_Permanent 0x80
+#define XkbKB_OpMask 0x7f
+
+#define XkbKB_Default 0x00
+#define XkbKB_Lock 0x01
+#define XkbKB_RadioGroup 0x02
+#define XkbKB_Overlay1 0x03
+#define XkbKB_Overlay2 0x04
+
+#define XkbKB_RGAllowNone 0x80
+
+/*
+     * Various macros which describe the range of legal keycodes.
+     */
+#define XkbMinLegalKeyCode 8
+#define XkbMaxLegalKeyCode 255
+#define XkbMaxKeyCount (XkbMaxLegalKeyCode - XkbMinLegalKeyCode + 1)
+#define XkbPerKeyBitArraySize ((XkbMaxLegalKeyCode + 1) / 8)
+/* Seems kinda silly to check that an unsigned char is <= 255... */
+#define XkbIsLegalKeycode(k) ((k) >= XkbMinLegalKeyCode)
+
+/*
+     * Assorted constants and limits.
+     */
+#define XkbNumModifiers 8
+#define XkbNumVirtualMods 16
+#define XkbNumIndicators 32
+#define XkbAllIndicatorsMask (0xffffffff)
+#define XkbMaxRadioGroups 32
+#define XkbAllRadioGroupsMask (0xffffffff)
+#define XkbMaxShiftLevel 63
+#define XkbMaxSymsPerKey (XkbMaxShiftLevel * XkbNumKbdGroups)
+#define XkbRGMaxMembers 12
+#define XkbActionMessageLength 6
+#define XkbKeyNameLength 4
+#define XkbMaxRedirectCount 8
+
+#define XkbGeomPtsPerMM 10
+#define XkbGeomMaxColors 32
+#define XkbGeomMaxLabelColors 3
+#define XkbGeomMaxPriority 255
+
+/*
+     * Key Type index and mask for the four standard key types.
+     */
+#define XkbOneLevelIndex 0
+#define XkbTwoLevelIndex 1
+#define XkbAlphabeticIndex 2
+#define XkbKeypadIndex 3
+#define XkbLastRequiredType XkbKeypadIndex
+#define XkbNumRequiredTypes (XkbLastRequiredType + 1)
+#define XkbMaxKeyTypes 255
+
+#define XkbOneLevelMask (1 << 0)
+#define XkbTwoLevelMask (1 << 1)
+#define XkbAlphabeticMask (1 << 2)
+#define XkbKeypadMask (1 << 3)
+#define XkbAllRequiredTypes (0xf)
+
+#define XkbShiftLevel(n) ((n)-1)
+#define XkbShiftLevelMask(n) (1 << ((n)-1))
+
+/*
+     * Extension name and version information
+     */
+#define XkbName "XKEYBOARD"
+#define XkbMajorVersion 1
+#define XkbMinorVersion 0
+
+/*
+     * Explicit map components:
+     *  - Used in the 'explicit' field of an XkbServerMap.  Specifies
+     *    the keyboard components that should _not_ be updated automatically
+     *    in response to core protocol keyboard mapping requests.
+     */
+#define XkbExplicitKeyTypesMask (0x0f)
+#define XkbExplicitKeyType1Mask (1 << 0)
+#define XkbExplicitKeyType2Mask (1 << 1)
+#define XkbExplicitKeyType3Mask (1 << 2)
+#define XkbExplicitKeyType4Mask (1 << 3)
+#define XkbExplicitInterpretMask (1 << 4)
+#define XkbExplicitAutoRepeatMask (1 << 5)
+#define XkbExplicitBehaviorMask (1 << 6)
+#define XkbExplicitVModMapMask (1 << 7)
+#define XkbAllExplicitMask (0xff)
+
+/*
+     * Map components masks:
+     * Those in AllMapComponentsMask:
+     *  - Specifies the individual fields to be loaded or changed for the
+     *    GetMap and SetMap requests.
+     * Those in ClientInfoMask:
+     *  - Specifies the components to be allocated by XkbAllocClientMap.
+     * Those in ServerInfoMask:
+     *  - Specifies the components to be allocated by XkbAllocServerMap.
+     */
+#define XkbKeyTypesMask (1 << 0)
+#define XkbKeySymsMask (1 << 1)
+#define XkbModifierMapMask (1 << 2)
+#define XkbExplicitComponentsMask (1 << 3)
+#define XkbKeyActionsMask (1 << 4)
+#define XkbKeyBehaviorsMask (1 << 5)
+#define XkbVirtualModsMask (1 << 6)
+#define XkbVirtualModMapMask (1 << 7)
+
+#define XkbAllClientInfoMask (XkbKeyTypesMask | XkbKeySymsMask | XkbModifierMapMask)
+#define XkbAllServerInfoMask (XkbExplicitComponentsMask | XkbKeyActionsMask | XkbKeyBehaviorsMask | XkbVirtualModsMask | XkbVirtualModMapMask)
+#define XkbAllMapComponentsMask (XkbAllClientInfoMask | XkbAllServerInfoMask)
+
+/*
+     * Symbol interpretations flags:
+     *  - Used in the flags field of a symbol interpretation
+     */
+#define XkbSI_AutoRepeat (1 << 0)
+#define XkbSI_LockingKey (1 << 1)
+
+/*
+     * Symbol interpretations match specification:
+     *  - Used in the match field of a symbol interpretation to specify 
+     *    the conditions under which an interpretation is used.
+     */
+#define XkbSI_LevelOneOnly (0x80)
+#define XkbSI_OpMask (0x7f)
+#define XkbSI_NoneOf (0)
+#define XkbSI_AnyOfOrNone (1)
+#define XkbSI_AnyOf (2)
+#define XkbSI_AllOf (3)
+#define XkbSI_Exactly (4)
+
+/*
+     * Indicator map flags:
+     *  - Used in the flags field of an indicator map to indicate the
+     *    conditions under which and indicator can be changed and the
+     *    effects of changing the indicator.
+     */
+#define XkbIM_NoExplicit (1L << 7)
+#define XkbIM_NoAutomatic (1L << 6)
+#define XkbIM_LEDDrivesKB (1L << 5)
+
+/*
+     * Indicator map component specifications:
+     *  - Used by the 'which_groups' and 'which_mods' fields of an indicator
+     *    map to specify which keyboard components should be used to drive
+     *    the indicator.
+     */
+#define XkbIM_UseBase (1L << 0)
+#define XkbIM_UseLatched (1L << 1)
+#define XkbIM_UseLocked (1L << 2)
+#define XkbIM_UseEffective (1L << 3)
+#define XkbIM_UseCompat (1L << 4)
+
+#define XkbIM_UseNone 0
+#define XkbIM_UseAnyGroup (XkbIM_UseBase | XkbIM_UseLatched | XkbIM_UseLocked | XkbIM_UseEffective)
+#define XkbIM_UseAnyMods (XkbIM_UseAnyGroup | XkbIM_UseCompat)
+
+/*
+     * Compatibility Map Compontents:
+     *  - Specifies the components to be allocated in XkbAllocCompatMap.
+     */
+#define XkbSymInterpMask (1 << 0)
+#define XkbGroupCompatMask (1 << 1)
+#define XkbAllCompatMask (0x3)
+
+/*
+     * Names component mask:
+     *  - Specifies the names to be loaded or changed for the GetNames and
+     *    SetNames requests.
+     *  - Specifies the names that have changed in a NamesNotify event.
+     *  - Specifies the names components to be allocated by XkbAllocNames.
+     */
+#define XkbKeycodesNameMask (1 << 0)
+#define XkbGeometryNameMask (1 << 1)
+#define XkbSymbolsNameMask (1 << 2)
+#define XkbPhysSymbolsNameMask (1 << 3)
+#define XkbTypesNameMask (1 << 4)
+#define XkbCompatNameMask (1 << 5)
+#define XkbKeyTypeNamesMask (1 << 6)
+#define XkbKTLevelNamesMask (1 << 7)
+#define XkbIndicatorNamesMask (1 << 8)
+#define XkbKeyNamesMask (1 << 9)
+#define XkbKeyAliasesMask (1 << 10)
+#define XkbVirtualModNamesMask (1 << 11)
+#define XkbGroupNamesMask (1 << 12)
+#define XkbRGNamesMask (1 << 13)
+#define XkbComponentNamesMask (0x3f)
+#define XkbAllNamesMask (0x3fff)
+
+/*
+     * GetByName components:
+     *  - Specifies desired or necessary components to GetKbdByName request.
+     *  - Reports the components that were found in a GetKbdByNameReply
+     */
+#define XkbGBN_TypesMask (1L << 0)
+#define XkbGBN_CompatMapMask (1L << 1)
+#define XkbGBN_ClientSymbolsMask (1L << 2)
+#define XkbGBN_ServerSymbolsMask (1L << 3)
+#define XkbGBN_SymbolsMask (XkbGBN_ClientSymbolsMask | XkbGBN_ServerSymbolsMask)
+#define XkbGBN_IndicatorMapMask (1L << 4)
+#define XkbGBN_KeyNamesMask (1L << 5)
+#define XkbGBN_GeometryMask (1L << 6)
+#define XkbGBN_OtherNamesMask (1L << 7)
+#define XkbGBN_AllComponentsMask (0xff)
+
+/*
+      * ListComponents flags
+      */
+#define XkbLC_Hidden (1L << 0)
+#define XkbLC_Default (1L << 1)
+#define XkbLC_Partial (1L << 2)
+
+#define XkbLC_AlphanumericKeys (1L << 8)
+#define XkbLC_ModifierKeys (1L << 9)
+#define XkbLC_KeypadKeys (1L << 10)
+#define XkbLC_FunctionKeys (1L << 11)
+#define XkbLC_AlternateGroup (1L << 12)
+
+/*
+     * X Input Extension Interactions
+     * - Specifies the possible interactions between XKB and the X input
+     *   extension
+     * - Used to request (XkbGetDeviceInfo) or change (XKbSetDeviceInfo)
+     *   XKB information about an extension device.
+     * - Reports the list of supported optional features in the reply to
+     *   XkbGetDeviceInfo or in an XkbExtensionDeviceNotify event.
+     * XkbXI_UnsupportedFeature is reported in XkbExtensionDeviceNotify
+     * events to indicate an attempt to use an unsupported feature.
+     */
+#define XkbXI_KeyboardsMask (1L << 0)
+#define XkbXI_ButtonActionsMask (1L << 1)
+#define XkbXI_IndicatorNamesMask (1L << 2)
+#define XkbXI_IndicatorMapsMask (1L << 3)
+#define XkbXI_IndicatorStateMask (1L << 4)
+#define XkbXI_UnsupportedFeatureMask (1L << 15)
+#define XkbXI_AllFeaturesMask (0x001f)
+#define XkbXI_AllDeviceFeaturesMask (0x001e)
+
+#define XkbXI_IndicatorsMask (0x001c)
+#define XkbAllExtensionDeviceEventsMask (0x801f)
+
+/*
+     * Per-Client Flags:
+     *  - Specifies flags to be changed by the PerClientFlags request.
+     */
+#define XkbPCF_DetectableAutoRepeatMask (1L << 0)
+#define XkbPCF_GrabsUseXKBStateMask (1L << 1)
+#define XkbPCF_AutoResetControlsMask (1L << 2)
+#define XkbPCF_LookupStateWhenGrabbed (1L << 3)
+#define XkbPCF_SendEventUsesXKBState (1L << 4)
+#define XkbPCF_AllFlagsMask (0x1F)
+
+/*
+     * Debugging flags and controls
+     */
+#define XkbDF_DisableLocks (1 << 0)
+
+#endif /* _XKB_H_ */
diff --git a/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/extensions/XKBstr.h b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/extensions/XKBstr.h
new file mode 100644
index 00000000..138431af
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/extensions/XKBstr.h
@@ -0,0 +1,652 @@
+/************************************************************
+Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
+
+Permission to use, copy, modify, and distribute this
+software and its documentation for any purpose and without
+fee is hereby granted, provided that the above copyright
+notice appear in all copies and that both that copyright
+notice and this permission notice appear in supporting
+documentation, and that the name of Silicon Graphics not be 
+used in advertising or publicity pertaining to distribution 
+of the software without specific prior written permission.
+Silicon Graphics makes no representation about the suitability 
+of this software for any purpose. It is provided "as is"
+without any express or implied warranty.
+
+SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS 
+SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 
+AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
+GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL 
+DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, 
+DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE 
+OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
+THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+********************************************************/
+
+#ifndef _XKBSTR_H_
+#define _XKBSTR_H_
+
+#include <X11/extensions/XKB.h>
+
+#define XkbCharToInt(v) ((v)&0x80 ? (int)((v) | (~0xff)) : (int)((v)&0x7f))
+#define XkbIntTo2Chars(i, h, l) (((h) = ((i >> 8) & 0xff)), ((l) = ((i)&0xff)))
+
+#if defined(WORD64) && defined(UNSIGNEDBITFIELDS)
+#define Xkb2CharsToInt(h, l) ((h)&0x80 ? (int)(((h) << 8) | (l) | (~0xffff)) : (int)(((h) << 8) | (l)&0x7fff))
+#else
+#define Xkb2CharsToInt(h, l) ((short)(((h) << 8) | (l)))
+#endif
+
+/*
+	 * Common data structures and access macros
+	 */
+
+typedef struct _XkbStateRec
+{
+	unsigned char group;
+	unsigned char locked_group;
+	unsigned short base_group;
+	unsigned short latched_group;
+	unsigned char mods;
+	unsigned char base_mods;
+	unsigned char latched_mods;
+	unsigned char locked_mods;
+	unsigned char compat_state;
+	unsigned char grab_mods;
+	unsigned char compat_grab_mods;
+	unsigned char lookup_mods;
+	unsigned char compat_lookup_mods;
+	unsigned short ptr_buttons;
+} XkbStateRec, *XkbStatePtr;
+#define XkbModLocks(s) ((s)->locked_mods)
+#define XkbStateMods(s) ((s)->base_mods | (s)->latched_mods | XkbModLocks(s))
+#define XkbGroupLock(s) ((s)->locked_group)
+#define XkbStateGroup(s) ((s)->base_group + (s)->latched_group + XkbGroupLock(s))
+#define XkbStateFieldFromRec(s) XkbBuildCoreState((s)->lookup_mods, (s)->group)
+#define XkbGrabStateFromRec(s) XkbBuildCoreState((s)->grab_mods, (s)->group)
+
+typedef struct _XkbMods
+{
+	unsigned char mask; /* effective mods */
+	unsigned char real_mods;
+	unsigned short vmods;
+} XkbModsRec, *XkbModsPtr;
+
+typedef struct _XkbKTMapEntry
+{
+	Bool active;
+	unsigned char level;
+	XkbModsRec mods;
+} XkbKTMapEntryRec, *XkbKTMapEntryPtr;
+
+typedef struct _XkbKeyType
+{
+	XkbModsRec mods;
+	unsigned char num_levels;
+	unsigned char map_count;
+	XkbKTMapEntryPtr map;
+	XkbModsPtr preserve;
+	Atom name;
+	Atom *level_names;
+} XkbKeyTypeRec, *XkbKeyTypePtr;
+
+#define XkbNumGroups(g) ((g)&0x0f)
+#define XkbOutOfRangeGroupInfo(g) ((g)&0xf0)
+#define XkbOutOfRangeGroupAction(g) ((g)&0xc0)
+#define XkbOutOfRangeGroupNumber(g) (((g)&0x30) >> 4)
+#define XkbSetGroupInfo(g, w, n) (((w)&0xc0) | (((n)&3) << 4) | ((g)&0x0f))
+#define XkbSetNumGroups(g, n) (((g)&0xf0) | ((n)&0x0f))
+
+/*
+	 * Structures and access macros used primarily by the server
+	 */
+
+typedef struct _XkbBehavior
+{
+	unsigned char type;
+	unsigned char data;
+} XkbBehavior;
+
+#define XkbAnyActionDataSize 7
+typedef struct _XkbAnyAction
+{
+	unsigned char type;
+	unsigned char data[XkbAnyActionDataSize];
+} XkbAnyAction;
+
+typedef struct _XkbModAction
+{
+	unsigned char type;
+	unsigned char flags;
+	unsigned char mask;
+	unsigned char real_mods;
+	unsigned char vmods1;
+	unsigned char vmods2;
+} XkbModAction;
+#define XkbModActionVMods(a) \
+	((short)(((a)->vmods1 << 8) | ((a)->vmods2)))
+#define XkbSetModActionVMods(a, v) \
+	(((a)->vmods1 = (((v) >> 8) & 0xff)), (a)->vmods2 = ((v)&0xff))
+
+typedef struct _XkbGroupAction
+{
+	unsigned char type;
+	unsigned char flags;
+	char group_XXX;
+} XkbGroupAction;
+#define XkbSAGroup(a) (XkbCharToInt((a)->group_XXX))
+#define XkbSASetGroup(a, g) ((a)->group_XXX = (g))
+
+typedef struct _XkbISOAction
+{
+	unsigned char type;
+	unsigned char flags;
+	unsigned char mask;
+	unsigned char real_mods;
+	char group_XXX;
+	unsigned char affect;
+	unsigned char vmods1;
+	unsigned char vmods2;
+} XkbISOAction;
+
+typedef struct _XkbPtrAction
+{
+	unsigned char type;
+	unsigned char flags;
+	unsigned char high_XXX;
+	unsigned char low_XXX;
+	unsigned char high_YYY;
+	unsigned char low_YYY;
+} XkbPtrAction;
+#define XkbPtrActionX(a) (Xkb2CharsToInt((a)->high_XXX, (a)->low_XXX))
+#define XkbPtrActionY(a) (Xkb2CharsToInt((a)->high_YYY, (a)->low_YYY))
+#define XkbSetPtrActionX(a, x) (XkbIntTo2Chars(x, (a)->high_XXX, (a)->low_XXX))
+#define XkbSetPtrActionY(a, y) (XkbIntTo2Chars(y, (a)->high_YYY, (a)->low_YYY))
+
+typedef struct _XkbPtrBtnAction
+{
+	unsigned char type;
+	unsigned char flags;
+	unsigned char count;
+	unsigned char button;
+} XkbPtrBtnAction;
+
+typedef struct _XkbPtrDfltAction
+{
+	unsigned char type;
+	unsigned char flags;
+	unsigned char affect;
+	char valueXXX;
+} XkbPtrDfltAction;
+#define XkbSAPtrDfltValue(a) (XkbCharToInt((a)->valueXXX))
+#define XkbSASetPtrDfltValue(a, c) ((a)->valueXXX = ((c)&0xff))
+
+typedef struct _XkbSwitchScreenAction
+{
+	unsigned char type;
+	unsigned char flags;
+	char screenXXX;
+} XkbSwitchScreenAction;
+#define XkbSAScreen(a) (XkbCharToInt((a)->screenXXX))
+#define XkbSASetScreen(a, s) ((a)->screenXXX = ((s)&0xff))
+
+typedef struct _XkbCtrlsAction
+{
+	unsigned char type;
+	unsigned char flags;
+	unsigned char ctrls3;
+	unsigned char ctrls2;
+	unsigned char ctrls1;
+	unsigned char ctrls0;
+} XkbCtrlsAction;
+#define XkbActionSetCtrls(a, c) (((a)->ctrls3 = (((c) >> 24) & 0xff)), \
+								 ((a)->ctrls2 = (((c) >> 16) & 0xff)), \
+								 ((a)->ctrls1 = (((c) >> 8) & 0xff)),  \
+								 ((a)->ctrls0 = ((c)&0xff)))
+#define XkbActionCtrls(a) ((((unsigned int)(a)->ctrls3) << 24) | \
+						   (((unsigned int)(a)->ctrls2) << 16) | \
+						   (((unsigned int)(a)->ctrls1) << 8) |  \
+						   ((unsigned int)((a)->ctrls0)))
+
+typedef struct _XkbMessageAction
+{
+	unsigned char type;
+	unsigned char flags;
+	unsigned char message[6];
+} XkbMessageAction;
+
+typedef struct _XkbRedirectKeyAction
+{
+	unsigned char type;
+	unsigned char new_key;
+	unsigned char mods_mask;
+	unsigned char mods;
+	unsigned char vmods_mask0;
+	unsigned char vmods_mask1;
+	unsigned char vmods0;
+	unsigned char vmods1;
+} XkbRedirectKeyAction;
+
+#define XkbSARedirectVMods(a) ((((unsigned int)(a)->vmods1) << 8) | \
+							   ((unsigned int)(a)->vmods0))
+#define XkbSARedirectSetVMods(a, m) (((a)->vmods_mask1 = (((m) >> 8) & 0xff)), \
+									 ((a)->vmods_mask0 = ((m)&0xff)))
+#define XkbSARedirectVModsMask(a) ((((unsigned int)(a)->vmods_mask1) << 8) | \
+								   ((unsigned int)(a)->vmods_mask0))
+#define XkbSARedirectSetVModsMask(a, m) (((a)->vmods_mask1 = (((m) >> 8) & 0xff)), \
+										 ((a)->vmods_mask0 = ((m)&0xff)))
+
+typedef struct _XkbDeviceBtnAction
+{
+	unsigned char type;
+	unsigned char flags;
+	unsigned char count;
+	unsigned char button;
+	unsigned char device;
+} XkbDeviceBtnAction;
+
+typedef struct _XkbDeviceValuatorAction
+{
+	unsigned char type;
+	unsigned char device;
+	unsigned char v1_what;
+	unsigned char v1_ndx;
+	unsigned char v1_value;
+	unsigned char v2_what;
+	unsigned char v2_ndx;
+	unsigned char v2_value;
+} XkbDeviceValuatorAction;
+
+typedef union _XkbAction {
+	XkbAnyAction any;
+	XkbModAction mods;
+	XkbGroupAction group;
+	XkbISOAction iso;
+	XkbPtrAction ptr;
+	XkbPtrBtnAction btn;
+	XkbPtrDfltAction dflt;
+	XkbSwitchScreenAction screen;
+	XkbCtrlsAction ctrls;
+	XkbMessageAction msg;
+	XkbRedirectKeyAction redirect;
+	XkbDeviceBtnAction devbtn;
+	XkbDeviceValuatorAction devval;
+	unsigned char type;
+} XkbAction;
+
+typedef struct _XkbControls
+{
+	unsigned char mk_dflt_btn;
+	unsigned char num_groups;
+	unsigned char groups_wrap;
+	XkbModsRec internal;
+	XkbModsRec ignore_lock;
+	unsigned int enabled_ctrls;
+	unsigned short repeat_delay;
+	unsigned short repeat_interval;
+	unsigned short slow_keys_delay;
+	unsigned short debounce_delay;
+	unsigned short mk_delay;
+	unsigned short mk_interval;
+	unsigned short mk_time_to_max;
+	unsigned short mk_max_speed;
+	short mk_curve;
+	unsigned short ax_options;
+	unsigned short ax_timeout;
+	unsigned short axt_opts_mask;
+	unsigned short axt_opts_values;
+	unsigned int axt_ctrls_mask;
+	unsigned int axt_ctrls_values;
+	unsigned char per_key_repeat[XkbPerKeyBitArraySize];
+} XkbControlsRec, *XkbControlsPtr;
+
+#define XkbAX_AnyFeedback(c) ((c)->enabled_ctrls & XkbAccessXFeedbackMask)
+#define XkbAX_NeedOption(c, w) ((c)->ax_options & (w))
+#define XkbAX_NeedFeedback(c, w) (XkbAX_AnyFeedback(c) && XkbAX_NeedOption(c, w))
+
+typedef struct _XkbServerMapRec
+{
+	unsigned short num_acts;
+	unsigned short size_acts;
+	XkbAction *acts;
+
+	XkbBehavior *behaviors;
+	unsigned short *key_acts;
+#if defined(__cplusplus) || defined(c_plusplus)
+	/* explicit is a C++ reserved word */
+	unsigned char *c_explicit;
+#else
+	unsigned char *explicit;
+#endif
+	unsigned char vmods[XkbNumVirtualMods];
+	unsigned short *vmodmap;
+} XkbServerMapRec, *XkbServerMapPtr;
+
+#define XkbSMKeyActionsPtr(m, k) (&(m)->acts[(m)->key_acts[k]])
+
+/*
+	 * Structures and access macros used primarily by clients
+	 */
+
+typedef struct _XkbSymMapRec
+{
+	unsigned char kt_index[XkbNumKbdGroups];
+	unsigned char group_info;
+	unsigned char width;
+	unsigned short offset;
+} XkbSymMapRec, *XkbSymMapPtr;
+
+typedef struct _XkbClientMapRec
+{
+	unsigned char size_types;
+	unsigned char num_types;
+	XkbKeyTypePtr types;
+
+	unsigned short size_syms;
+	unsigned short num_syms;
+	KeySym *syms;
+	XkbSymMapPtr key_sym_map;
+
+	unsigned char *modmap;
+} XkbClientMapRec, *XkbClientMapPtr;
+
+#define XkbCMKeyGroupInfo(m, k) ((m)->key_sym_map[k].group_info)
+#define XkbCMKeyNumGroups(m, k) (XkbNumGroups((m)->key_sym_map[k].group_info))
+#define XkbCMKeyGroupWidth(m, k, g) (XkbCMKeyType(m, k, g)->num_levels)
+#define XkbCMKeyGroupsWidth(m, k) ((m)->key_sym_map[k].width)
+#define XkbCMKeyTypeIndex(m, k, g) ((m)->key_sym_map[k].kt_index[g & 0x3])
+#define XkbCMKeyType(m, k, g) (&(m)->types[XkbCMKeyTypeIndex(m, k, g)])
+#define XkbCMKeyNumSyms(m, k) (XkbCMKeyGroupsWidth(m, k) * XkbCMKeyNumGroups(m, k))
+#define XkbCMKeySymsOffset(m, k) ((m)->key_sym_map[k].offset)
+#define XkbCMKeySymsPtr(m, k) (&(m)->syms[XkbCMKeySymsOffset(m, k)])
+
+/*
+	 * Compatibility structures and access macros
+	 */
+
+typedef struct _XkbSymInterpretRec
+{
+	KeySym sym;
+	unsigned char flags;
+	unsigned char match;
+	unsigned char mods;
+	unsigned char virtual_mod;
+	XkbAnyAction act;
+} XkbSymInterpretRec, *XkbSymInterpretPtr;
+
+typedef struct _XkbCompatMapRec
+{
+	XkbSymInterpretPtr sym_interpret;
+	XkbModsRec groups[XkbNumKbdGroups];
+	unsigned short num_si;
+	unsigned short size_si;
+} XkbCompatMapRec, *XkbCompatMapPtr;
+
+typedef struct _XkbIndicatorMapRec
+{
+	unsigned char flags;
+	unsigned char which_groups;
+	unsigned char groups;
+	unsigned char which_mods;
+	XkbModsRec mods;
+	unsigned int ctrls;
+} XkbIndicatorMapRec, *XkbIndicatorMapPtr;
+
+#define XkbIM_IsAuto(i) ((((i)->flags & XkbIM_NoAutomatic) == 0) && \
+						 (((i)->which_groups && (i)->groups) ||     \
+						  ((i)->which_mods && (i)->mods.mask) ||    \
+						  ((i)->ctrls)))
+#define XkbIM_InUse(i) (((i)->flags) || ((i)->which_groups) || \
+						((i)->which_mods) || ((i)->ctrls))
+
+typedef struct _XkbIndicatorRec
+{
+	unsigned long phys_indicators;
+	XkbIndicatorMapRec maps[XkbNumIndicators];
+} XkbIndicatorRec, *XkbIndicatorPtr;
+
+typedef struct _XkbKeyNameRec
+{
+	char name[XkbKeyNameLength];
+} XkbKeyNameRec, *XkbKeyNamePtr;
+
+typedef struct _XkbKeyAliasRec
+{
+	char real[XkbKeyNameLength];
+	char alias[XkbKeyNameLength];
+} XkbKeyAliasRec, *XkbKeyAliasPtr;
+
+/*
+	 * Names for everything 
+	 */
+typedef struct _XkbNamesRec
+{
+	Atom keycodes;
+	Atom geometry;
+	Atom symbols;
+	Atom types;
+	Atom compat;
+	Atom vmods[XkbNumVirtualMods];
+	Atom indicators[XkbNumIndicators];
+	Atom groups[XkbNumKbdGroups];
+	XkbKeyNamePtr keys;
+	XkbKeyAliasPtr key_aliases;
+	Atom *radio_groups;
+	Atom phys_symbols;
+
+	unsigned char num_keys;
+	unsigned char num_key_aliases;
+	unsigned short num_rg;
+} XkbNamesRec, *XkbNamesPtr;
+
+typedef struct _XkbGeometry *XkbGeometryPtr;
+/*
+	 * Tie it all together into one big keyboard description
+	 */
+typedef struct _XkbDesc
+{
+	struct _XDisplay *dpy;
+	unsigned short flags;
+	unsigned short device_spec;
+	KeyCode min_key_code;
+	KeyCode max_key_code;
+
+	XkbControlsPtr ctrls;
+	XkbServerMapPtr server;
+	XkbClientMapPtr map;
+	XkbIndicatorPtr indicators;
+	XkbNamesPtr names;
+	XkbCompatMapPtr compat;
+	XkbGeometryPtr geom;
+} XkbDescRec, *XkbDescPtr;
+#define XkbKeyKeyTypeIndex(d, k, g) (XkbCMKeyTypeIndex((d)->map, k, g))
+#define XkbKeyKeyType(d, k, g) (XkbCMKeyType((d)->map, k, g))
+#define XkbKeyGroupWidth(d, k, g) (XkbCMKeyGroupWidth((d)->map, k, g))
+#define XkbKeyGroupsWidth(d, k) (XkbCMKeyGroupsWidth((d)->map, k))
+#define XkbKeyGroupInfo(d, k) (XkbCMKeyGroupInfo((d)->map, (k)))
+#define XkbKeyNumGroups(d, k) (XkbCMKeyNumGroups((d)->map, (k)))
+#define XkbKeyNumSyms(d, k) (XkbCMKeyNumSyms((d)->map, (k)))
+#define XkbKeySymsPtr(d, k) (XkbCMKeySymsPtr((d)->map, (k)))
+#define XkbKeySym(d, k, n) (XkbKeySymsPtr(d, k)[n])
+#define XkbKeySymEntry(d, k, sl, g) \
+	(XkbKeySym(d, k, ((XkbKeyGroupsWidth(d, k) * (g)) + (sl))))
+#define XkbKeyAction(d, k, n) \
+	(XkbKeyHasActions(d, k) ? &XkbKeyActionsPtr(d, k)[n] : NULL)
+#define XkbKeyActionEntry(d, k, sl, g) \
+	(XkbKeyHasActions(d, k) ? XkbKeyAction(d, k, ((XkbKeyGroupsWidth(d, k) * (g)) + (sl))) : NULL)
+
+#define XkbKeyHasActions(d, k) ((d)->server->key_acts[k] != 0)
+#define XkbKeyNumActions(d, k) (XkbKeyHasActions(d, k) ? XkbKeyNumSyms(d, k) : 1)
+#define XkbKeyActionsPtr(d, k) (XkbSMKeyActionsPtr((d)->server, k))
+#define XkbKeycodeInRange(d, k) (((k) >= (d)->min_key_code) && \
+								 ((k) <= (d)->max_key_code))
+#define XkbNumKeys(d) ((d)->max_key_code - (d)->min_key_code + 1)
+
+/*
+	 * The following structures can be used to track changes
+	 * to a keyboard device
+	 */
+typedef struct _XkbMapChanges
+{
+	unsigned short changed;
+	KeyCode min_key_code;
+	KeyCode max_key_code;
+	unsigned char first_type;
+	unsigned char num_types;
+	KeyCode first_key_sym;
+	unsigned char num_key_syms;
+	KeyCode first_key_act;
+	unsigned char num_key_acts;
+	KeyCode first_key_behavior;
+	unsigned char num_key_behaviors;
+	KeyCode first_key_explicit;
+	unsigned char num_key_explicit;
+	KeyCode first_modmap_key;
+	unsigned char num_modmap_keys;
+	KeyCode first_vmodmap_key;
+	unsigned char num_vmodmap_keys;
+	unsigned char pad;
+	unsigned short vmods;
+} XkbMapChangesRec, *XkbMapChangesPtr;
+
+typedef struct _XkbControlsChanges
+{
+	unsigned int changed_ctrls;
+	unsigned int enabled_ctrls_changes;
+	Bool num_groups_changed;
+} XkbControlsChangesRec, *XkbControlsChangesPtr;
+
+typedef struct _XkbIndicatorChanges
+{
+	unsigned int state_changes;
+	unsigned int map_changes;
+} XkbIndicatorChangesRec, *XkbIndicatorChangesPtr;
+
+typedef struct _XkbNameChanges
+{
+	unsigned int changed;
+	unsigned char first_type;
+	unsigned char num_types;
+	unsigned char first_lvl;
+	unsigned char num_lvls;
+	unsigned char num_aliases;
+	unsigned char num_rg;
+	unsigned char first_key;
+	unsigned char num_keys;
+	unsigned short changed_vmods;
+	unsigned long changed_indicators;
+	unsigned char changed_groups;
+} XkbNameChangesRec, *XkbNameChangesPtr;
+
+typedef struct _XkbCompatChanges
+{
+	unsigned char changed_groups;
+	unsigned short first_si;
+	unsigned short num_si;
+} XkbCompatChangesRec, *XkbCompatChangesPtr;
+
+typedef struct _XkbChanges
+{
+	unsigned short device_spec;
+	unsigned short state_changes;
+	XkbMapChangesRec map;
+	XkbControlsChangesRec ctrls;
+	XkbIndicatorChangesRec indicators;
+	XkbNameChangesRec names;
+	XkbCompatChangesRec compat;
+} XkbChangesRec, *XkbChangesPtr;
+
+/*
+	 * These data structures are used to construct a keymap from 
+	 * a set of components or to list components in the server
+	 * database.
+	 */
+typedef struct _XkbComponentNames
+{
+	char *keymap;
+	char *keycodes;
+	char *types;
+	char *compat;
+	char *symbols;
+	char *geometry;
+} XkbComponentNamesRec, *XkbComponentNamesPtr;
+
+typedef struct _XkbComponentName
+{
+	unsigned short flags;
+	char *name;
+} XkbComponentNameRec, *XkbComponentNamePtr;
+
+typedef struct _XkbComponentList
+{
+	int num_keymaps;
+	int num_keycodes;
+	int num_types;
+	int num_compat;
+	int num_symbols;
+	int num_geometry;
+	XkbComponentNamePtr keymaps;
+	XkbComponentNamePtr keycodes;
+	XkbComponentNamePtr types;
+	XkbComponentNamePtr compat;
+	XkbComponentNamePtr symbols;
+	XkbComponentNamePtr geometry;
+} XkbComponentListRec, *XkbComponentListPtr;
+
+/*
+	 * The following data structures describe and track changes to a 
+	 * non-keyboard extension device 
+	 */
+typedef struct _XkbDeviceLedInfo
+{
+	unsigned short led_class;
+	unsigned short led_id;
+	unsigned int phys_indicators;
+	unsigned int maps_present;
+	unsigned int names_present;
+	unsigned int state;
+	Atom names[XkbNumIndicators];
+	XkbIndicatorMapRec maps[XkbNumIndicators];
+} XkbDeviceLedInfoRec, *XkbDeviceLedInfoPtr;
+
+typedef struct _XkbDeviceInfo
+{
+	char *name;
+	Atom type;
+	unsigned short device_spec;
+	Bool has_own_state;
+	unsigned short supported;
+	unsigned short unsupported;
+
+	unsigned short num_btns;
+	XkbAction *btn_acts;
+
+	unsigned short sz_leds;
+	unsigned short num_leds;
+	unsigned short dflt_kbd_fb;
+	unsigned short dflt_led_fb;
+	XkbDeviceLedInfoPtr leds;
+} XkbDeviceInfoRec, *XkbDeviceInfoPtr;
+
+#define XkbXI_DevHasBtnActs(d) (((d)->num_btns > 0) && ((d)->btn_acts != NULL))
+#define XkbXI_LegalDevBtn(d, b) (XkbXI_DevHasBtnActs(d) && ((b) < (d)->num_btns))
+#define XkbXI_DevHasLeds(d) (((d)->num_leds > 0) && ((d)->leds != NULL))
+
+typedef struct _XkbDeviceLedChanges
+{
+	unsigned short led_class;
+	unsigned short led_id;
+	unsigned int defined; /* names or maps changed */
+	struct _XkbDeviceLedChanges *next;
+} XkbDeviceLedChangesRec, *XkbDeviceLedChangesPtr;
+
+typedef struct _XkbDeviceChanges
+{
+	unsigned int changed;
+	unsigned short first_btn;
+	unsigned short num_btns;
+	XkbDeviceLedChangesRec leds;
+} XkbDeviceChangesRec, *XkbDeviceChangesPtr;
+
+#endif /* _XKBSTR_H_ */
diff --git a/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/extensions/XShm.h b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/extensions/XShm.h
new file mode 100644
index 00000000..54e95cad
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/extensions/XShm.h
@@ -0,0 +1,137 @@
+/************************************************************
+
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+********************************************************/
+
+/* THIS IS NOT AN X CONSORTIUM STANDARD OR AN X PROJECT TEAM SPECIFICATION */
+
+#ifndef _XSHM_H_
+#define _XSHM_H_
+
+#include <X11/Xfuncproto.h>
+#include <X11/extensions/shm.h>
+
+#ifndef _XSHM_SERVER_
+typedef unsigned long ShmSeg;
+
+typedef struct
+{
+	int type;             /* of event */
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came frome a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Drawable drawable;    /* drawable of request */
+	int major_code;       /* ShmReqCode */
+	int minor_code;       /* X_ShmPutImage */
+	ShmSeg shmseg;        /* the ShmSeg used in the request */
+	unsigned long offset; /* the offset into ShmSeg used in the request */
+} XShmCompletionEvent;
+
+typedef struct
+{
+	ShmSeg shmseg; /* resource id */
+	int shmid;     /* kernel id */
+	char* shmaddr; /* address in client */
+	Bool readOnly; /* how the server should attach it */
+} XShmSegmentInfo;
+
+_XFUNCPROTOBEGIN
+
+Bool XShmQueryExtension(
+	Display* /* dpy */
+);
+
+int XShmGetEventBase(
+	Display* /* dpy */
+);
+
+Bool XShmQueryVersion(
+	Display* /* dpy */,
+	int* /* majorVersion */,
+	int* /* minorVersion */,
+	Bool* /* sharedPixmaps */
+);
+
+int XShmPixmapFormat(
+	Display* /* dpy */
+);
+
+Bool XShmAttach(
+	Display* /* dpy */,
+	XShmSegmentInfo* /* shminfo */
+);
+
+Bool XShmDetach(
+	Display* /* dpy */,
+	XShmSegmentInfo* /* shminfo */
+);
+
+Bool XShmPutImage(
+	Display* /* dpy */,
+	Drawable /* d */,
+	GC /* gc */,
+	XImage* /* image */,
+	int /* src_x */,
+	int /* src_y */,
+	int /* dst_x */,
+	int /* dst_y */,
+	unsigned int /* src_width */,
+	unsigned int /* src_height */,
+	Bool /* send_event */
+);
+
+Bool XShmGetImage(
+	Display* /* dpy */,
+	Drawable /* d */,
+	XImage* /* image */,
+	int /* x */,
+	int /* y */,
+	unsigned long /* plane_mask */
+);
+
+XImage* XShmCreateImage(
+	Display* /* dpy */,
+	Visual* /* visual */,
+	unsigned int /* depth */,
+	int /* format */,
+	char* /* data */,
+	XShmSegmentInfo* /* shminfo */,
+	unsigned int /* width */,
+	unsigned int /* height */
+);
+
+Pixmap XShmCreatePixmap(
+	Display* /* dpy */,
+	Drawable /* d */,
+	char* /* data */,
+	XShmSegmentInfo* /* shminfo */,
+	unsigned int /* width */,
+	unsigned int /* height */,
+	unsigned int /* depth */
+);
+
+_XFUNCPROTOEND
+#endif /* _XSHM_SERVER_ */
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/extensions/Xext.h b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/extensions/Xext.h
new file mode 100644
index 00000000..0cbda02e
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/extensions/Xext.h
@@ -0,0 +1,53 @@
+/*
+ *
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+ */
+
+#ifndef _XEXT_H_
+#define _XEXT_H_
+
+#include <X11/Xfuncproto.h>
+
+_XFUNCPROTOBEGIN
+
+typedef int (*XextErrorHandler)(
+	Display* /* dpy */,
+	_Xconst char* /* ext_name */,
+	_Xconst char* /* reason */
+);
+
+extern XextErrorHandler XSetExtensionErrorHandler(
+	XextErrorHandler /* handler */
+);
+
+extern int XMissingExtension(
+	Display* /* dpy */,
+	_Xconst char* /* ext_name */
+);
+
+_XFUNCPROTOEND
+
+#define X_EXTENSION_UNKNOWN "unknown"
+#define X_EXTENSION_MISSING "missing"
+
+#endif /* _XEXT_H_ */
diff --git a/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/extensions/extutil.h b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/extensions/extutil.h
new file mode 100644
index 00000000..7abe5ac1
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/extensions/extutil.h
@@ -0,0 +1,203 @@
+/*
+ *
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+ *
+ * Author:  Jim Fulton, MIT The Open Group
+ *
+ *                     Xlib Extension-Writing Utilities
+ *
+ * This package contains utilities for writing the client API for various
+ * protocol extensions.  THESE INTERFACES ARE NOT PART OF THE X STANDARD AND
+ * ARE SUBJECT TO CHANGE!
+ */
+
+#ifndef _EXTUTIL_H_
+#define _EXTUTIL_H_
+
+#include <X11/extensions/Xext.h>
+
+/*
+ * We need to keep a list of open displays since the Xlib display list isn't
+ * public.  We also have to per-display info in a separate block since it isn't
+ * stored directly in the Display structure.
+ */
+typedef struct _XExtDisplayInfo
+{
+	struct _XExtDisplayInfo* next; /* keep a linked list */
+	Display* display;              /* which display this is */
+	XExtCodes* codes;              /* the extension protocol codes */
+	XPointer data;                 /* extra data for extension to use */
+} XExtDisplayInfo;
+
+typedef struct _XExtensionInfo
+{
+	XExtDisplayInfo* head; /* start of list */
+	XExtDisplayInfo* cur;  /* most recently used */
+	int ndisplays;         /* number of displays */
+} XExtensionInfo;
+
+typedef struct _XExtensionHooks
+{
+	int (*create_gc)(
+		Display* /* display */,
+		GC /* gc */,
+		XExtCodes* /* codes */
+	);
+	int (*copy_gc)(
+		Display* /* display */,
+		GC /* gc */,
+		XExtCodes* /* codes */
+	);
+	int (*flush_gc)(
+		Display* /* display */,
+		GC /* gc */,
+		XExtCodes* /* codes */
+	);
+	int (*free_gc)(
+		Display* /* display */,
+		GC /* gc */,
+		XExtCodes* /* codes */
+	);
+	int (*create_font)(
+		Display* /* display */,
+		XFontStruct* /* fs */,
+		XExtCodes* /* codes */
+	);
+	int (*free_font)(
+		Display* /* display */,
+		XFontStruct* /* fs */,
+		XExtCodes* /* codes */
+	);
+	int (*close_display)(
+		Display* /* display */,
+		XExtCodes* /* codes */
+	);
+	Bool (*wire_to_event)(
+		Display* /* display */,
+		XEvent* /* re */,
+		xEvent* /* event */
+	);
+	Status (*event_to_wire)(
+		Display* /* display */,
+		XEvent* /* re */,
+		xEvent* /* event */
+	);
+	int (*error)(
+		Display* /* display */,
+		xError* /* err */,
+		XExtCodes* /* codes */,
+		int* /* ret_code */
+	);
+	char* (*error_string)(
+		Display* /* display */,
+		int /* code */,
+		XExtCodes* /* codes */,
+		char* /* buffer */,
+		int /* nbytes */
+	);
+} XExtensionHooks;
+
+extern XExtensionInfo* XextCreateExtension(
+	void);
+extern void XextDestroyExtension(
+	XExtensionInfo* /* info */
+);
+extern XExtDisplayInfo* XextAddDisplay(
+	XExtensionInfo* /* extinfo */,
+	Display* /* dpy */,
+	_Xconst char* /* ext_name */,
+	XExtensionHooks* /* hooks */,
+	int /* nevents */,
+	XPointer /* data */
+);
+extern int XextRemoveDisplay(
+	XExtensionInfo* /* extinfo */,
+	Display* /* dpy */
+);
+extern XExtDisplayInfo* XextFindDisplay(
+	XExtensionInfo* /* extinfo */,
+	Display* /* dpy */
+);
+
+#define XextHasExtension(i) ((i) && ((i)->codes))
+#define XextCheckExtension(dpy, i, name, val) \
+	if (!XextHasExtension(i))                 \
+	{                                         \
+		XMissingExtension(dpy, name);         \
+		return val;                           \
+	}
+#define XextSimpleCheckExtension(dpy, i, name) \
+	if (!XextHasExtension(i))                  \
+	{                                          \
+		XMissingExtension(dpy, name);          \
+		return;                                \
+	}
+
+/*
+ * helper macros to generate code that is common to all extensions; caller
+ * should prefix it with static if extension source is in one file; this
+ * could be a utility function, but have to stack 6 unused arguments for
+ * something that is called many, many times would be bad.
+ */
+#define XEXT_GENERATE_FIND_DISPLAY(proc, extinfo, extname, hooks, nev, data)   \
+	XExtDisplayInfo* proc(Display* dpy)                                        \
+	{                                                                          \
+		XExtDisplayInfo* dpyinfo;                                              \
+		if (!extinfo)                                                          \
+		{                                                                      \
+			if (!(extinfo = XextCreateExtension())) return NULL;               \
+		}                                                                      \
+		if (!(dpyinfo = XextFindDisplay(extinfo, dpy)))                        \
+			dpyinfo = XextAddDisplay(extinfo, dpy, extname, hooks, nev, data); \
+		return dpyinfo;                                                        \
+	}
+
+#define XEXT_FIND_DISPLAY_PROTO(proc) \
+	XExtDisplayInfo* proc(Display* dpy)
+
+#define XEXT_GENERATE_CLOSE_DISPLAY(proc, extinfo) \
+	int proc(Display* dpy, XExtCodes* codes)       \
+	{                                              \
+		return XextRemoveDisplay(extinfo, dpy);    \
+	}
+
+#define XEXT_CLOSE_DISPLAY_PROTO(proc) \
+	int proc(Display* dpy, XExtCodes* codes)
+
+#define XEXT_GENERATE_ERROR_STRING(proc, extname, nerr, errl)                   \
+	char* proc(Display* dpy, int code, XExtCodes* codes, char* buf, int n)      \
+	{                                                                           \
+		code -= codes->first_error;                                             \
+		if (code >= 0 && code < nerr)                                           \
+		{                                                                       \
+			char tmp[256];                                                      \
+			sprintf(tmp, "%s.%d", extname, code);                               \
+			XGetErrorDatabaseText(dpy, "XProtoError", tmp, errl[code], buf, n); \
+			return buf;                                                         \
+		}                                                                       \
+		return (char*)0;                                                        \
+	}
+
+#define XEXT_ERROR_STRING_PROTO(proc) \
+	char* proc(Display* dpy, int code, XExtCodes* codes, char* buf, int n)
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/extensions/shape.h b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/extensions/shape.h
new file mode 100644
index 00000000..b2887bab
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/extensions/shape.h
@@ -0,0 +1,153 @@
+/************************************************************
+
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+********************************************************/
+
+#ifndef _SHAPE_H_
+#define _SHAPE_H_
+
+#include <X11/Xfuncproto.h>
+#include <X11/extensions/shapeconst.h>
+
+#ifndef _SHAPE_SERVER_
+#include <X11/Xutil.h>
+
+typedef struct
+{
+	int type;             /* of event */
+	unsigned long serial; /* # of last request processed by server */
+	Bool send_event;      /* true if this came frome a SendEvent request */
+	Display* display;     /* Display the event was read from */
+	Window window;        /* window of event */
+	int kind;             /* ShapeBounding or ShapeClip */
+	int x, y;             /* extents of new region */
+	unsigned width, height;
+	Time time;   /* server timestamp when region changed */
+	Bool shaped; /* true if the region exists */
+} XShapeEvent;
+
+_XFUNCPROTOBEGIN
+
+extern Bool XShapeQueryExtension(
+	Display* /* display */,
+	int* /* event_base */,
+	int* /* error_base */
+);
+
+extern Status XShapeQueryVersion(
+	Display* /* display */,
+	int* /* major_version */,
+	int* /* minor_version */
+);
+
+extern void XShapeCombineRegion(
+	Display* /* display */,
+	Window /* dest */,
+	int /* dest_kind */,
+	int /* x_off */,
+	int /* y_off */,
+	Region /* region */,
+	int /* op */
+);
+
+extern void XShapeCombineRectangles(
+	Display* /* display */,
+	Window /* dest */,
+	int /* dest_kind */,
+	int /* x_off */,
+	int /* y_off */,
+	XRectangle* /* rectangles */,
+	int /* n_rects */,
+	int /* op */,
+	int /* ordering */
+);
+
+extern void XShapeCombineMask(
+	Display* /* display */,
+	Window /* dest */,
+	int /* dest_kind */,
+	int /* x_off */,
+	int /* y_off */,
+	Pixmap /* src */,
+	int /* op */
+);
+
+extern void XShapeCombineShape(
+	Display* /* display */,
+	Window /* dest */,
+	int /* dest_kind */,
+	int /* x_off */,
+	int /* y_off */,
+	Window /* src */,
+	int /* src_kind */,
+	int /* op */
+);
+
+extern void XShapeOffsetShape(
+	Display* /* display */,
+	Window /* dest */,
+	int /* dest_kind */,
+	int /* x_off */,
+	int /* y_off */
+);
+
+extern Status XShapeQueryExtents(
+	Display* /* display */,
+	Window /* window */,
+	Bool* /* bounding_shaped */,
+	int* /* x_bounding */,
+	int* /* y_bounding */,
+	unsigned int* /* w_bounding */,
+	unsigned int* /* h_bounding */,
+	Bool* /* clip_shaped */,
+	int* /* x_clip */,
+	int* /* y_clip */,
+	unsigned int* /* w_clip */,
+	unsigned int* /* h_clip */
+);
+
+extern void XShapeSelectInput(
+	Display* /* display */,
+	Window /* window */,
+	unsigned long /* mask */
+);
+
+extern unsigned long XShapeInputSelected(
+	Display* /* display */,
+	Window /* window */
+);
+
+extern XRectangle* XShapeGetRectangles(
+	Display* /* display */,
+	Window /* window */,
+	int /* kind */,
+	int* /* count */,
+	int* /* ordering */
+);
+
+_XFUNCPROTOEND
+
+#endif /* !_SHAPE_SERVER_ */
+
+#endif /* _SHAPE_H_ */
diff --git a/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/extensions/shapeconst.h b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/extensions/shapeconst.h
new file mode 100644
index 00000000..d0a5d2bb
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/extensions/shapeconst.h
@@ -0,0 +1,55 @@
+/************************************************************
+
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+********************************************************/
+
+#ifndef _SHAPECONST_H_
+#define _SHAPECONST_H_
+
+/*
+ * Protocol requests constants and alignment values
+ * These would really be in SHAPE's X.h and Xproto.h equivalents
+ */
+
+#define SHAPENAME "SHAPE"
+
+#define SHAPE_MAJOR_VERSION 1 /* current version numbers */
+#define SHAPE_MINOR_VERSION 1
+
+#define ShapeSet 0
+#define ShapeUnion 1
+#define ShapeIntersect 2
+#define ShapeSubtract 3
+#define ShapeInvert 4
+
+#define ShapeBounding 0
+#define ShapeClip 1
+#define ShapeInput 2
+
+#define ShapeNotifyMask (1L << 0)
+#define ShapeNotify 0
+
+#define ShapeNumberEvents (ShapeNotify + 1)
+
+#endif /* _SHAPECONST_H_ */
diff --git a/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/extensions/shm.h b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/extensions/shm.h
new file mode 100644
index 00000000..58bf5858
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/extensions/shm.h
@@ -0,0 +1,43 @@
+/************************************************************
+
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+********************************************************/
+
+/* THIS IS NOT AN X CONSORTIUM STANDARD OR AN X PROJECT TEAM SPECIFICATION */
+
+#ifndef _SHM_H_
+#define _SHM_H_
+
+#define SHMNAME "MIT-SHM"
+
+#define SHM_MAJOR_VERSION 1 /* current version numbers */
+#define SHM_MINOR_VERSION 2
+
+#define ShmCompletion 0
+#define ShmNumberEvents (ShmCompletion + 1)
+
+#define BadShmSeg 0
+#define ShmNumberErrors (BadShmSeg + 1)
+
+#endif /* _SHM_H_ */
diff --git a/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/keysym.h b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/keysym.h
new file mode 100644
index 00000000..c8c022e8
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/keysym.h
@@ -0,0 +1,73 @@
+/***********************************************************
+
+Copyright 1987, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its 
+documentation for any purpose and without fee is hereby granted, 
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in 
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.  
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+
+/* default keysyms */
+#define XK_MISCELLANY
+#define XK_XKB_KEYS
+#define XK_LATIN1
+#define XK_LATIN2
+#define XK_LATIN3
+#define XK_LATIN4
+#define XK_LATIN8
+#define XK_LATIN9
+#define XK_CAUCASUS
+#define XK_GREEK
+#define XK_KATAKANA
+#define XK_ARABIC
+#define XK_CYRILLIC
+#define XK_HEBREW
+#define XK_THAI
+#define XK_KOREAN
+#define XK_ARMENIAN
+#define XK_GEORGIAN
+#define XK_VIETNAMESE
+#define XK_CURRENCY
+#define XK_MATHEMATICAL
+#define XK_BRAILLE
+#define XK_SINHALA
+
+#include <X11/keysymdef.h>
diff --git a/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/keysymdef.h b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/keysymdef.h
new file mode 100644
index 00000000..f7b64c75
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/optionalX11/X11/keysymdef.h
@@ -0,0 +1,2485 @@
+/***********************************************************
+Copyright 1987, 1994, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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 OPEN GROUP 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.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+
+
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+
+/*
+ * The "X11 Window System Protocol" standard defines in Appendix A the
+ * keysym codes. These 29-bit integer values identify characters or
+ * functions associated with each key (e.g., via the visible
+ * engraving) of a keyboard layout. This file assigns mnemonic macro
+ * names for these keysyms.
+ *
+ * This file is also compiled (by src/util/makekeys.c in libX11) into
+ * hash tables that can be accessed with X11 library functions such as
+ * XStringToKeysym() and XKeysymToString().
+ *
+ * Where a keysym corresponds one-to-one to an ISO 10646 / Unicode
+ * character, this is noted in a comment that provides both the U+xxxx
+ * Unicode position, as well as the official Unicode name of the
+ * character.
+ *
+ * Where the correspondence is either not one-to-one or semantically
+ * unclear, the Unicode position and name are enclosed in
+ * parentheses. Such legacy keysyms should be considered deprecated
+ * and are not recommended for use in future keyboard mappings.
+ *
+ * For any future extension of the keysyms with characters already
+ * found in ISO 10646 / Unicode, the following algorithm shall be
+ * used. The new keysym code position will simply be the character's
+ * Unicode number plus 0x01000000. The keysym values in the range
+ * 0x01000100 to 0x0110ffff are reserved to represent Unicode
+ * characters in the range U+0100 to U+10FFFF.
+ * 
+ * While most newer Unicode-based X11 clients do already accept
+ * Unicode-mapped keysyms in the range 0x01000100 to 0x0110ffff, it
+ * will remain necessary for clients -- in the interest of
+ * compatibility with existing servers -- to also understand the
+ * existing legacy keysym values in the range 0x0100 to 0x20ff.
+ *
+ * Where several mnemonic names are defined for the same keysym in this
+ * file, all but the first one listed should be considered deprecated.
+ *
+ * Mnemonic names for keysyms are defined in this file with lines
+ * that match one of these Perl regular expressions:
+ *
+ *    /^\#define XK_([a-zA-Z_0-9]+)\s+0x([0-9a-f]+)\s*\/\* U+([0-9A-F]{4,6}) (.*) \*\/\s*$/
+ *    /^\#define XK_([a-zA-Z_0-9]+)\s+0x([0-9a-f]+)\s*\/\*\(U+([0-9A-F]{4,6}) (.*)\)\*\/\s*$/
+ *    /^\#define XK_([a-zA-Z_0-9]+)\s+0x([0-9a-f]+)\s*(\/\*\s*(.*)\s*\*\/)?\s*$/
+ *
+ * Before adding new keysyms, please do consider the following: In
+ * addition to the keysym names defined in this file, the
+ * XStringToKeysym() and XKeysymToString() functions will also handle
+ * any keysym string of the form "U0020" to "U007E" and "U00A0" to
+ * "U10FFFF" for all possible Unicode characters. In other words,
+ * every possible Unicode character has already a keysym string
+ * defined algorithmically, even if it is not listed here. Therefore,
+ * defining an additional keysym macro is only necessary where a
+ * non-hexadecimal mnemonic name is needed, or where the new keysym
+ * does not represent any existing Unicode character.
+ *
+ * When adding new keysyms to this file, do not forget to also update the
+ * following as needed:
+ *
+ *   - the mappings in src/KeyBind.c in the repo
+ *     git://anongit.freedesktop.org/xorg/lib/libX11.git
+ *
+ *   - the protocol specification in specs/keysyms.xml
+ *     in the repo git://anongit.freedesktop.org/xorg/proto/x11proto.git
+ *
+ */
+
+#define XK_VoidSymbol 0xffffff /* Void symbol */
+
+#ifdef XK_MISCELLANY
+/*
+ * TTY function keys, cleverly chosen to map to ASCII, for convenience of
+ * programming, but could have been arbitrary (at the cost of lookup
+ * tables in client code).
+ */
+
+#define XK_BackSpace 0xff08 /* Back space, back char */
+#define XK_Tab 0xff09
+#define XK_Linefeed 0xff0a /* Linefeed, LF */
+#define XK_Clear 0xff0b
+#define XK_Return 0xff0d /* Return, enter */
+#define XK_Pause 0xff13  /* Pause, hold */
+#define XK_Scroll_Lock 0xff14
+#define XK_Sys_Req 0xff15
+#define XK_Escape 0xff1b
+#define XK_Delete 0xffff /* Delete, rubout */
+
+/* International & multi-key character composition */
+
+#define XK_Multi_key 0xff20 /* Multi-key character compose */
+#define XK_Codeinput 0xff37
+#define XK_SingleCandidate 0xff3c
+#define XK_MultipleCandidate 0xff3d
+#define XK_PreviousCandidate 0xff3e
+
+/* Japanese keyboard support */
+
+#define XK_Kanji 0xff21             /* Kanji, Kanji convert */
+#define XK_Muhenkan 0xff22          /* Cancel Conversion */
+#define XK_Henkan_Mode 0xff23       /* Start/Stop Conversion */
+#define XK_Henkan 0xff23            /* Alias for Henkan_Mode */
+#define XK_Romaji 0xff24            /* to Romaji */
+#define XK_Hiragana 0xff25          /* to Hiragana */
+#define XK_Katakana 0xff26          /* to Katakana */
+#define XK_Hiragana_Katakana 0xff27 /* Hiragana/Katakana toggle */
+#define XK_Zenkaku 0xff28           /* to Zenkaku */
+#define XK_Hankaku 0xff29           /* to Hankaku */
+#define XK_Zenkaku_Hankaku 0xff2a   /* Zenkaku/Hankaku toggle */
+#define XK_Touroku 0xff2b           /* Add to Dictionary */
+#define XK_Massyo 0xff2c            /* Delete from Dictionary */
+#define XK_Kana_Lock 0xff2d         /* Kana Lock */
+#define XK_Kana_Shift 0xff2e        /* Kana Shift */
+#define XK_Eisu_Shift 0xff2f        /* Alphanumeric Shift */
+#define XK_Eisu_toggle 0xff30       /* Alphanumeric toggle */
+#define XK_Kanji_Bangou 0xff37      /* Codeinput */
+#define XK_Zen_Koho 0xff3d          /* Multiple/All Candidate(s) */
+#define XK_Mae_Koho 0xff3e          /* Previous Candidate */
+
+/* 0xff31 thru 0xff3f are under XK_KOREAN */
+
+/* Cursor control & motion */
+
+#define XK_Home 0xff50
+#define XK_Left 0xff51  /* Move left, left arrow */
+#define XK_Up 0xff52    /* Move up, up arrow */
+#define XK_Right 0xff53 /* Move right, right arrow */
+#define XK_Down 0xff54  /* Move down, down arrow */
+#define XK_Prior 0xff55 /* Prior, previous */
+#define XK_Page_Up 0xff55
+#define XK_Next 0xff56 /* Next */
+#define XK_Page_Down 0xff56
+#define XK_End 0xff57   /* EOL */
+#define XK_Begin 0xff58 /* BOL */
+
+/* Misc functions */
+
+#define XK_Select 0xff60 /* Select, mark */
+#define XK_Print 0xff61
+#define XK_Execute 0xff62 /* Execute, run, do */
+#define XK_Insert 0xff63  /* Insert, insert here */
+#define XK_Undo 0xff65
+#define XK_Redo 0xff66 /* Redo, again */
+#define XK_Menu 0xff67
+#define XK_Find 0xff68   /* Find, search */
+#define XK_Cancel 0xff69 /* Cancel, stop, abort, exit */
+#define XK_Help 0xff6a   /* Help */
+#define XK_Break 0xff6b
+#define XK_Mode_switch 0xff7e   /* Character set switch */
+#define XK_script_switch 0xff7e /* Alias for mode_switch */
+#define XK_Num_Lock 0xff7f
+
+/* Keypad functions, keypad numbers cleverly chosen to map to ASCII */
+
+#define XK_KP_Space 0xff80 /* Space */
+#define XK_KP_Tab 0xff89
+#define XK_KP_Enter 0xff8d /* Enter */
+#define XK_KP_F1 0xff91    /* PF1, KP_A, ... */
+#define XK_KP_F2 0xff92
+#define XK_KP_F3 0xff93
+#define XK_KP_F4 0xff94
+#define XK_KP_Home 0xff95
+#define XK_KP_Left 0xff96
+#define XK_KP_Up 0xff97
+#define XK_KP_Right 0xff98
+#define XK_KP_Down 0xff99
+#define XK_KP_Prior 0xff9a
+#define XK_KP_Page_Up 0xff9a
+#define XK_KP_Next 0xff9b
+#define XK_KP_Page_Down 0xff9b
+#define XK_KP_End 0xff9c
+#define XK_KP_Begin 0xff9d
+#define XK_KP_Insert 0xff9e
+#define XK_KP_Delete 0xff9f
+#define XK_KP_Equal 0xffbd /* Equals */
+#define XK_KP_Multiply 0xffaa
+#define XK_KP_Add 0xffab
+#define XK_KP_Separator 0xffac /* Separator, often comma */
+#define XK_KP_Subtract 0xffad
+#define XK_KP_Decimal 0xffae
+#define XK_KP_Divide 0xffaf
+
+#define XK_KP_0 0xffb0
+#define XK_KP_1 0xffb1
+#define XK_KP_2 0xffb2
+#define XK_KP_3 0xffb3
+#define XK_KP_4 0xffb4
+#define XK_KP_5 0xffb5
+#define XK_KP_6 0xffb6
+#define XK_KP_7 0xffb7
+#define XK_KP_8 0xffb8
+#define XK_KP_9 0xffb9
+
+/*
+ * Auxiliary functions; note the duplicate definitions for left and right
+ * function keys;  Sun keyboards and a few other manufacturers have such
+ * function key groups on the left and/or right sides of the keyboard.
+ * We've not found a keyboard with more than 35 function keys total.
+ */
+
+#define XK_F1 0xffbe
+#define XK_F2 0xffbf
+#define XK_F3 0xffc0
+#define XK_F4 0xffc1
+#define XK_F5 0xffc2
+#define XK_F6 0xffc3
+#define XK_F7 0xffc4
+#define XK_F8 0xffc5
+#define XK_F9 0xffc6
+#define XK_F10 0xffc7
+#define XK_F11 0xffc8
+#define XK_L1 0xffc8
+#define XK_F12 0xffc9
+#define XK_L2 0xffc9
+#define XK_F13 0xffca
+#define XK_L3 0xffca
+#define XK_F14 0xffcb
+#define XK_L4 0xffcb
+#define XK_F15 0xffcc
+#define XK_L5 0xffcc
+#define XK_F16 0xffcd
+#define XK_L6 0xffcd
+#define XK_F17 0xffce
+#define XK_L7 0xffce
+#define XK_F18 0xffcf
+#define XK_L8 0xffcf
+#define XK_F19 0xffd0
+#define XK_L9 0xffd0
+#define XK_F20 0xffd1
+#define XK_L10 0xffd1
+#define XK_F21 0xffd2
+#define XK_R1 0xffd2
+#define XK_F22 0xffd3
+#define XK_R2 0xffd3
+#define XK_F23 0xffd4
+#define XK_R3 0xffd4
+#define XK_F24 0xffd5
+#define XK_R4 0xffd5
+#define XK_F25 0xffd6
+#define XK_R5 0xffd6
+#define XK_F26 0xffd7
+#define XK_R6 0xffd7
+#define XK_F27 0xffd8
+#define XK_R7 0xffd8
+#define XK_F28 0xffd9
+#define XK_R8 0xffd9
+#define XK_F29 0xffda
+#define XK_R9 0xffda
+#define XK_F30 0xffdb
+#define XK_R10 0xffdb
+#define XK_F31 0xffdc
+#define XK_R11 0xffdc
+#define XK_F32 0xffdd
+#define XK_R12 0xffdd
+#define XK_F33 0xffde
+#define XK_R13 0xffde
+#define XK_F34 0xffdf
+#define XK_R14 0xffdf
+#define XK_F35 0xffe0
+#define XK_R15 0xffe0
+
+/* Modifiers */
+
+#define XK_Shift_L 0xffe1    /* Left shift */
+#define XK_Shift_R 0xffe2    /* Right shift */
+#define XK_Control_L 0xffe3  /* Left control */
+#define XK_Control_R 0xffe4  /* Right control */
+#define XK_Caps_Lock 0xffe5  /* Caps lock */
+#define XK_Shift_Lock 0xffe6 /* Shift lock */
+
+#define XK_Meta_L 0xffe7  /* Left meta */
+#define XK_Meta_R 0xffe8  /* Right meta */
+#define XK_Alt_L 0xffe9   /* Left alt */
+#define XK_Alt_R 0xffea   /* Right alt */
+#define XK_Super_L 0xffeb /* Left super */
+#define XK_Super_R 0xffec /* Right super */
+#define XK_Hyper_L 0xffed /* Left hyper */
+#define XK_Hyper_R 0xffee /* Right hyper */
+#endif                    /* XK_MISCELLANY */
+
+/*
+ * Keyboard (XKB) Extension function and modifier keys
+ * (from Appendix C of "The X Keyboard Extension: Protocol Specification")
+ * Byte 3 = 0xfe
+ */
+
+#ifdef XK_XKB_KEYS
+#define XK_ISO_Lock 0xfe01
+#define XK_ISO_Level2_Latch 0xfe02
+#define XK_ISO_Level3_Shift 0xfe03
+#define XK_ISO_Level3_Latch 0xfe04
+#define XK_ISO_Level3_Lock 0xfe05
+#define XK_ISO_Level5_Shift 0xfe11
+#define XK_ISO_Level5_Latch 0xfe12
+#define XK_ISO_Level5_Lock 0xfe13
+#define XK_ISO_Group_Shift 0xff7e /* Alias for mode_switch */
+#define XK_ISO_Group_Latch 0xfe06
+#define XK_ISO_Group_Lock 0xfe07
+#define XK_ISO_Next_Group 0xfe08
+#define XK_ISO_Next_Group_Lock 0xfe09
+#define XK_ISO_Prev_Group 0xfe0a
+#define XK_ISO_Prev_Group_Lock 0xfe0b
+#define XK_ISO_First_Group 0xfe0c
+#define XK_ISO_First_Group_Lock 0xfe0d
+#define XK_ISO_Last_Group 0xfe0e
+#define XK_ISO_Last_Group_Lock 0xfe0f
+
+#define XK_ISO_Left_Tab 0xfe20
+#define XK_ISO_Move_Line_Up 0xfe21
+#define XK_ISO_Move_Line_Down 0xfe22
+#define XK_ISO_Partial_Line_Up 0xfe23
+#define XK_ISO_Partial_Line_Down 0xfe24
+#define XK_ISO_Partial_Space_Left 0xfe25
+#define XK_ISO_Partial_Space_Right 0xfe26
+#define XK_ISO_Set_Margin_Left 0xfe27
+#define XK_ISO_Set_Margin_Right 0xfe28
+#define XK_ISO_Release_Margin_Left 0xfe29
+#define XK_ISO_Release_Margin_Right 0xfe2a
+#define XK_ISO_Release_Both_Margins 0xfe2b
+#define XK_ISO_Fast_Cursor_Left 0xfe2c
+#define XK_ISO_Fast_Cursor_Right 0xfe2d
+#define XK_ISO_Fast_Cursor_Up 0xfe2e
+#define XK_ISO_Fast_Cursor_Down 0xfe2f
+#define XK_ISO_Continuous_Underline 0xfe30
+#define XK_ISO_Discontinuous_Underline 0xfe31
+#define XK_ISO_Emphasize 0xfe32
+#define XK_ISO_Center_Object 0xfe33
+#define XK_ISO_Enter 0xfe34
+
+#define XK_dead_grave 0xfe50
+#define XK_dead_acute 0xfe51
+#define XK_dead_circumflex 0xfe52
+#define XK_dead_tilde 0xfe53
+#define XK_dead_perispomeni 0xfe53 /* alias for dead_tilde */
+#define XK_dead_macron 0xfe54
+#define XK_dead_breve 0xfe55
+#define XK_dead_abovedot 0xfe56
+#define XK_dead_diaeresis 0xfe57
+#define XK_dead_abovering 0xfe58
+#define XK_dead_doubleacute 0xfe59
+#define XK_dead_caron 0xfe5a
+#define XK_dead_cedilla 0xfe5b
+#define XK_dead_ogonek 0xfe5c
+#define XK_dead_iota 0xfe5d
+#define XK_dead_voiced_sound 0xfe5e
+#define XK_dead_semivoiced_sound 0xfe5f
+#define XK_dead_belowdot 0xfe60
+#define XK_dead_hook 0xfe61
+#define XK_dead_horn 0xfe62
+#define XK_dead_stroke 0xfe63
+#define XK_dead_abovecomma 0xfe64
+#define XK_dead_psili 0xfe64 /* alias for dead_abovecomma */
+#define XK_dead_abovereversedcomma 0xfe65
+#define XK_dead_dasia 0xfe65 /* alias for dead_abovereversedcomma */
+#define XK_dead_doublegrave 0xfe66
+#define XK_dead_belowring 0xfe67
+#define XK_dead_belowmacron 0xfe68
+#define XK_dead_belowcircumflex 0xfe69
+#define XK_dead_belowtilde 0xfe6a
+#define XK_dead_belowbreve 0xfe6b
+#define XK_dead_belowdiaeresis 0xfe6c
+#define XK_dead_invertedbreve 0xfe6d
+#define XK_dead_belowcomma 0xfe6e
+#define XK_dead_currency 0xfe6f
+
+/* dead vowels for universal syllable entry */
+#define XK_dead_a 0xfe80
+#define XK_dead_A 0xfe81
+#define XK_dead_e 0xfe82
+#define XK_dead_E 0xfe83
+#define XK_dead_i 0xfe84
+#define XK_dead_I 0xfe85
+#define XK_dead_o 0xfe86
+#define XK_dead_O 0xfe87
+#define XK_dead_u 0xfe88
+#define XK_dead_U 0xfe89
+#define XK_dead_small_schwa 0xfe8a
+#define XK_dead_capital_schwa 0xfe8b
+
+#define XK_dead_greek 0xfe8c
+
+#define XK_First_Virtual_Screen 0xfed0
+#define XK_Prev_Virtual_Screen 0xfed1
+#define XK_Next_Virtual_Screen 0xfed2
+#define XK_Last_Virtual_Screen 0xfed4
+#define XK_Terminate_Server 0xfed5
+
+#define XK_AccessX_Enable 0xfe70
+#define XK_AccessX_Feedback_Enable 0xfe71
+#define XK_RepeatKeys_Enable 0xfe72
+#define XK_SlowKeys_Enable 0xfe73
+#define XK_BounceKeys_Enable 0xfe74
+#define XK_StickyKeys_Enable 0xfe75
+#define XK_MouseKeys_Enable 0xfe76
+#define XK_MouseKeys_Accel_Enable 0xfe77
+#define XK_Overlay1_Enable 0xfe78
+#define XK_Overlay2_Enable 0xfe79
+#define XK_AudibleBell_Enable 0xfe7a
+
+#define XK_Pointer_Left 0xfee0
+#define XK_Pointer_Right 0xfee1
+#define XK_Pointer_Up 0xfee2
+#define XK_Pointer_Down 0xfee3
+#define XK_Pointer_UpLeft 0xfee4
+#define XK_Pointer_UpRight 0xfee5
+#define XK_Pointer_DownLeft 0xfee6
+#define XK_Pointer_DownRight 0xfee7
+#define XK_Pointer_Button_Dflt 0xfee8
+#define XK_Pointer_Button1 0xfee9
+#define XK_Pointer_Button2 0xfeea
+#define XK_Pointer_Button3 0xfeeb
+#define XK_Pointer_Button4 0xfeec
+#define XK_Pointer_Button5 0xfeed
+#define XK_Pointer_DblClick_Dflt 0xfeee
+#define XK_Pointer_DblClick1 0xfeef
+#define XK_Pointer_DblClick2 0xfef0
+#define XK_Pointer_DblClick3 0xfef1
+#define XK_Pointer_DblClick4 0xfef2
+#define XK_Pointer_DblClick5 0xfef3
+#define XK_Pointer_Drag_Dflt 0xfef4
+#define XK_Pointer_Drag1 0xfef5
+#define XK_Pointer_Drag2 0xfef6
+#define XK_Pointer_Drag3 0xfef7
+#define XK_Pointer_Drag4 0xfef8
+#define XK_Pointer_Drag5 0xfefd
+
+#define XK_Pointer_EnableKeys 0xfef9
+#define XK_Pointer_Accelerate 0xfefa
+#define XK_Pointer_DfltBtnNext 0xfefb
+#define XK_Pointer_DfltBtnPrev 0xfefc
+
+/* Single-Stroke Multiple-Character N-Graph Keysyms For The X Input Method */
+
+#define XK_ch 0xfea0
+#define XK_Ch 0xfea1
+#define XK_CH 0xfea2
+#define XK_c_h 0xfea3
+#define XK_C_h 0xfea4
+#define XK_C_H 0xfea5
+
+#endif /* XK_XKB_KEYS */
+
+/*
+ * 3270 Terminal Keys
+ * Byte 3 = 0xfd
+ */
+
+#ifdef XK_3270
+#define XK_3270_Duplicate 0xfd01
+#define XK_3270_FieldMark 0xfd02
+#define XK_3270_Right2 0xfd03
+#define XK_3270_Left2 0xfd04
+#define XK_3270_BackTab 0xfd05
+#define XK_3270_EraseEOF 0xfd06
+#define XK_3270_EraseInput 0xfd07
+#define XK_3270_Reset 0xfd08
+#define XK_3270_Quit 0xfd09
+#define XK_3270_PA1 0xfd0a
+#define XK_3270_PA2 0xfd0b
+#define XK_3270_PA3 0xfd0c
+#define XK_3270_Test 0xfd0d
+#define XK_3270_Attn 0xfd0e
+#define XK_3270_CursorBlink 0xfd0f
+#define XK_3270_AltCursor 0xfd10
+#define XK_3270_KeyClick 0xfd11
+#define XK_3270_Jump 0xfd12
+#define XK_3270_Ident 0xfd13
+#define XK_3270_Rule 0xfd14
+#define XK_3270_Copy 0xfd15
+#define XK_3270_Play 0xfd16
+#define XK_3270_Setup 0xfd17
+#define XK_3270_Record 0xfd18
+#define XK_3270_ChangeScreen 0xfd19
+#define XK_3270_DeleteWord 0xfd1a
+#define XK_3270_ExSelect 0xfd1b
+#define XK_3270_CursorSelect 0xfd1c
+#define XK_3270_PrintScreen 0xfd1d
+#define XK_3270_Enter 0xfd1e
+#endif /* XK_3270 */
+
+/*
+ * Latin 1
+ * (ISO/IEC 8859-1 = Unicode U+0020..U+00FF)
+ * Byte 3 = 0
+ */
+#ifdef XK_LATIN1
+#define XK_space 0x0020        /* U+0020 SPACE */
+#define XK_exclam 0x0021       /* U+0021 EXCLAMATION MARK */
+#define XK_quotedbl 0x0022     /* U+0022 QUOTATION MARK */
+#define XK_numbersign 0x0023   /* U+0023 NUMBER SIGN */
+#define XK_dollar 0x0024       /* U+0024 DOLLAR SIGN */
+#define XK_percent 0x0025      /* U+0025 PERCENT SIGN */
+#define XK_ampersand 0x0026    /* U+0026 AMPERSAND */
+#define XK_apostrophe 0x0027   /* U+0027 APOSTROPHE */
+#define XK_quoteright 0x0027   /* deprecated */
+#define XK_parenleft 0x0028    /* U+0028 LEFT PARENTHESIS */
+#define XK_parenright 0x0029   /* U+0029 RIGHT PARENTHESIS */
+#define XK_asterisk 0x002a     /* U+002A ASTERISK */
+#define XK_plus 0x002b         /* U+002B PLUS SIGN */
+#define XK_comma 0x002c        /* U+002C COMMA */
+#define XK_minus 0x002d        /* U+002D HYPHEN-MINUS */
+#define XK_period 0x002e       /* U+002E FULL STOP */
+#define XK_slash 0x002f        /* U+002F SOLIDUS */
+#define XK_0 0x0030            /* U+0030 DIGIT ZERO */
+#define XK_1 0x0031            /* U+0031 DIGIT ONE */
+#define XK_2 0x0032            /* U+0032 DIGIT TWO */
+#define XK_3 0x0033            /* U+0033 DIGIT THREE */
+#define XK_4 0x0034            /* U+0034 DIGIT FOUR */
+#define XK_5 0x0035            /* U+0035 DIGIT FIVE */
+#define XK_6 0x0036            /* U+0036 DIGIT SIX */
+#define XK_7 0x0037            /* U+0037 DIGIT SEVEN */
+#define XK_8 0x0038            /* U+0038 DIGIT EIGHT */
+#define XK_9 0x0039            /* U+0039 DIGIT NINE */
+#define XK_colon 0x003a        /* U+003A COLON */
+#define XK_semicolon 0x003b    /* U+003B SEMICOLON */
+#define XK_less 0x003c         /* U+003C LESS-THAN SIGN */
+#define XK_equal 0x003d        /* U+003D EQUALS SIGN */
+#define XK_greater 0x003e      /* U+003E GREATER-THAN SIGN */
+#define XK_question 0x003f     /* U+003F QUESTION MARK */
+#define XK_at 0x0040           /* U+0040 COMMERCIAL AT */
+#define XK_A 0x0041            /* U+0041 LATIN CAPITAL LETTER A */
+#define XK_B 0x0042            /* U+0042 LATIN CAPITAL LETTER B */
+#define XK_C 0x0043            /* U+0043 LATIN CAPITAL LETTER C */
+#define XK_D 0x0044            /* U+0044 LATIN CAPITAL LETTER D */
+#define XK_E 0x0045            /* U+0045 LATIN CAPITAL LETTER E */
+#define XK_F 0x0046            /* U+0046 LATIN CAPITAL LETTER F */
+#define XK_G 0x0047            /* U+0047 LATIN CAPITAL LETTER G */
+#define XK_H 0x0048            /* U+0048 LATIN CAPITAL LETTER H */
+#define XK_I 0x0049            /* U+0049 LATIN CAPITAL LETTER I */
+#define XK_J 0x004a            /* U+004A LATIN CAPITAL LETTER J */
+#define XK_K 0x004b            /* U+004B LATIN CAPITAL LETTER K */
+#define XK_L 0x004c            /* U+004C LATIN CAPITAL LETTER L */
+#define XK_M 0x004d            /* U+004D LATIN CAPITAL LETTER M */
+#define XK_N 0x004e            /* U+004E LATIN CAPITAL LETTER N */
+#define XK_O 0x004f            /* U+004F LATIN CAPITAL LETTER O */
+#define XK_P 0x0050            /* U+0050 LATIN CAPITAL LETTER P */
+#define XK_Q 0x0051            /* U+0051 LATIN CAPITAL LETTER Q */
+#define XK_R 0x0052            /* U+0052 LATIN CAPITAL LETTER R */
+#define XK_S 0x0053            /* U+0053 LATIN CAPITAL LETTER S */
+#define XK_T 0x0054            /* U+0054 LATIN CAPITAL LETTER T */
+#define XK_U 0x0055            /* U+0055 LATIN CAPITAL LETTER U */
+#define XK_V 0x0056            /* U+0056 LATIN CAPITAL LETTER V */
+#define XK_W 0x0057            /* U+0057 LATIN CAPITAL LETTER W */
+#define XK_X 0x0058            /* U+0058 LATIN CAPITAL LETTER X */
+#define XK_Y 0x0059            /* U+0059 LATIN CAPITAL LETTER Y */
+#define XK_Z 0x005a            /* U+005A LATIN CAPITAL LETTER Z */
+#define XK_bracketleft 0x005b  /* U+005B LEFT SQUARE BRACKET */
+#define XK_backslash 0x005c    /* U+005C REVERSE SOLIDUS */
+#define XK_bracketright 0x005d /* U+005D RIGHT SQUARE BRACKET */
+#define XK_asciicircum 0x005e  /* U+005E CIRCUMFLEX ACCENT */
+#define XK_underscore 0x005f   /* U+005F LOW LINE */
+#define XK_grave 0x0060        /* U+0060 GRAVE ACCENT */
+#define XK_quoteleft 0x0060    /* deprecated */
+#define XK_a 0x0061            /* U+0061 LATIN SMALL LETTER A */
+#define XK_b 0x0062            /* U+0062 LATIN SMALL LETTER B */
+#define XK_c 0x0063            /* U+0063 LATIN SMALL LETTER C */
+#define XK_d 0x0064            /* U+0064 LATIN SMALL LETTER D */
+#define XK_e 0x0065            /* U+0065 LATIN SMALL LETTER E */
+#define XK_f 0x0066            /* U+0066 LATIN SMALL LETTER F */
+#define XK_g 0x0067            /* U+0067 LATIN SMALL LETTER G */
+#define XK_h 0x0068            /* U+0068 LATIN SMALL LETTER H */
+#define XK_i 0x0069            /* U+0069 LATIN SMALL LETTER I */
+#define XK_j 0x006a            /* U+006A LATIN SMALL LETTER J */
+#define XK_k 0x006b            /* U+006B LATIN SMALL LETTER K */
+#define XK_l 0x006c            /* U+006C LATIN SMALL LETTER L */
+#define XK_m 0x006d            /* U+006D LATIN SMALL LETTER M */
+#define XK_n 0x006e            /* U+006E LATIN SMALL LETTER N */
+#define XK_o 0x006f            /* U+006F LATIN SMALL LETTER O */
+#define XK_p 0x0070            /* U+0070 LATIN SMALL LETTER P */
+#define XK_q 0x0071            /* U+0071 LATIN SMALL LETTER Q */
+#define XK_r 0x0072            /* U+0072 LATIN SMALL LETTER R */
+#define XK_s 0x0073            /* U+0073 LATIN SMALL LETTER S */
+#define XK_t 0x0074            /* U+0074 LATIN SMALL LETTER T */
+#define XK_u 0x0075            /* U+0075 LATIN SMALL LETTER U */
+#define XK_v 0x0076            /* U+0076 LATIN SMALL LETTER V */
+#define XK_w 0x0077            /* U+0077 LATIN SMALL LETTER W */
+#define XK_x 0x0078            /* U+0078 LATIN SMALL LETTER X */
+#define XK_y 0x0079            /* U+0079 LATIN SMALL LETTER Y */
+#define XK_z 0x007a            /* U+007A LATIN SMALL LETTER Z */
+#define XK_braceleft 0x007b    /* U+007B LEFT CURLY BRACKET */
+#define XK_bar 0x007c          /* U+007C VERTICAL LINE */
+#define XK_braceright 0x007d   /* U+007D RIGHT CURLY BRACKET */
+#define XK_asciitilde 0x007e   /* U+007E TILDE */
+
+#define XK_nobreakspace 0x00a0   /* U+00A0 NO-BREAK SPACE */
+#define XK_exclamdown 0x00a1     /* U+00A1 INVERTED EXCLAMATION MARK */
+#define XK_cent 0x00a2           /* U+00A2 CENT SIGN */
+#define XK_sterling 0x00a3       /* U+00A3 POUND SIGN */
+#define XK_currency 0x00a4       /* U+00A4 CURRENCY SIGN */
+#define XK_yen 0x00a5            /* U+00A5 YEN SIGN */
+#define XK_brokenbar 0x00a6      /* U+00A6 BROKEN BAR */
+#define XK_section 0x00a7        /* U+00A7 SECTION SIGN */
+#define XK_diaeresis 0x00a8      /* U+00A8 DIAERESIS */
+#define XK_copyright 0x00a9      /* U+00A9 COPYRIGHT SIGN */
+#define XK_ordfeminine 0x00aa    /* U+00AA FEMININE ORDINAL INDICATOR */
+#define XK_guillemotleft 0x00ab  /* U+00AB LEFT-POINTING DOUBLE ANGLE QUOTATION MARK */
+#define XK_notsign 0x00ac        /* U+00AC NOT SIGN */
+#define XK_hyphen 0x00ad         /* U+00AD SOFT HYPHEN */
+#define XK_registered 0x00ae     /* U+00AE REGISTERED SIGN */
+#define XK_macron 0x00af         /* U+00AF MACRON */
+#define XK_degree 0x00b0         /* U+00B0 DEGREE SIGN */
+#define XK_plusminus 0x00b1      /* U+00B1 PLUS-MINUS SIGN */
+#define XK_twosuperior 0x00b2    /* U+00B2 SUPERSCRIPT TWO */
+#define XK_threesuperior 0x00b3  /* U+00B3 SUPERSCRIPT THREE */
+#define XK_acute 0x00b4          /* U+00B4 ACUTE ACCENT */
+#define XK_mu 0x00b5             /* U+00B5 MICRO SIGN */
+#define XK_paragraph 0x00b6      /* U+00B6 PILCROW SIGN */
+#define XK_periodcentered 0x00b7 /* U+00B7 MIDDLE DOT */
+#define XK_cedilla 0x00b8        /* U+00B8 CEDILLA */
+#define XK_onesuperior 0x00b9    /* U+00B9 SUPERSCRIPT ONE */
+#define XK_masculine 0x00ba      /* U+00BA MASCULINE ORDINAL INDICATOR */
+#define XK_guillemotright 0x00bb /* U+00BB RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK */
+#define XK_onequarter 0x00bc     /* U+00BC VULGAR FRACTION ONE QUARTER */
+#define XK_onehalf 0x00bd        /* U+00BD VULGAR FRACTION ONE HALF */
+#define XK_threequarters 0x00be  /* U+00BE VULGAR FRACTION THREE QUARTERS */
+#define XK_questiondown 0x00bf   /* U+00BF INVERTED QUESTION MARK */
+#define XK_Agrave 0x00c0         /* U+00C0 LATIN CAPITAL LETTER A WITH GRAVE */
+#define XK_Aacute 0x00c1         /* U+00C1 LATIN CAPITAL LETTER A WITH ACUTE */
+#define XK_Acircumflex 0x00c2    /* U+00C2 LATIN CAPITAL LETTER A WITH CIRCUMFLEX */
+#define XK_Atilde 0x00c3         /* U+00C3 LATIN CAPITAL LETTER A WITH TILDE */
+#define XK_Adiaeresis 0x00c4     /* U+00C4 LATIN CAPITAL LETTER A WITH DIAERESIS */
+#define XK_Aring 0x00c5          /* U+00C5 LATIN CAPITAL LETTER A WITH RING ABOVE */
+#define XK_AE 0x00c6             /* U+00C6 LATIN CAPITAL LETTER AE */
+#define XK_Ccedilla 0x00c7       /* U+00C7 LATIN CAPITAL LETTER C WITH CEDILLA */
+#define XK_Egrave 0x00c8         /* U+00C8 LATIN CAPITAL LETTER E WITH GRAVE */
+#define XK_Eacute 0x00c9         /* U+00C9 LATIN CAPITAL LETTER E WITH ACUTE */
+#define XK_Ecircumflex 0x00ca    /* U+00CA LATIN CAPITAL LETTER E WITH CIRCUMFLEX */
+#define XK_Ediaeresis 0x00cb     /* U+00CB LATIN CAPITAL LETTER E WITH DIAERESIS */
+#define XK_Igrave 0x00cc         /* U+00CC LATIN CAPITAL LETTER I WITH GRAVE */
+#define XK_Iacute 0x00cd         /* U+00CD LATIN CAPITAL LETTER I WITH ACUTE */
+#define XK_Icircumflex 0x00ce    /* U+00CE LATIN CAPITAL LETTER I WITH CIRCUMFLEX */
+#define XK_Idiaeresis 0x00cf     /* U+00CF LATIN CAPITAL LETTER I WITH DIAERESIS */
+#define XK_ETH 0x00d0            /* U+00D0 LATIN CAPITAL LETTER ETH */
+#define XK_Eth 0x00d0            /* deprecated */
+#define XK_Ntilde 0x00d1         /* U+00D1 LATIN CAPITAL LETTER N WITH TILDE */
+#define XK_Ograve 0x00d2         /* U+00D2 LATIN CAPITAL LETTER O WITH GRAVE */
+#define XK_Oacute 0x00d3         /* U+00D3 LATIN CAPITAL LETTER O WITH ACUTE */
+#define XK_Ocircumflex 0x00d4    /* U+00D4 LATIN CAPITAL LETTER O WITH CIRCUMFLEX */
+#define XK_Otilde 0x00d5         /* U+00D5 LATIN CAPITAL LETTER O WITH TILDE */
+#define XK_Odiaeresis 0x00d6     /* U+00D6 LATIN CAPITAL LETTER O WITH DIAERESIS */
+#define XK_multiply 0x00d7       /* U+00D7 MULTIPLICATION SIGN */
+#define XK_Oslash 0x00d8         /* U+00D8 LATIN CAPITAL LETTER O WITH STROKE */
+#define XK_Ooblique 0x00d8       /* U+00D8 LATIN CAPITAL LETTER O WITH STROKE */
+#define XK_Ugrave 0x00d9         /* U+00D9 LATIN CAPITAL LETTER U WITH GRAVE */
+#define XK_Uacute 0x00da         /* U+00DA LATIN CAPITAL LETTER U WITH ACUTE */
+#define XK_Ucircumflex 0x00db    /* U+00DB LATIN CAPITAL LETTER U WITH CIRCUMFLEX */
+#define XK_Udiaeresis 0x00dc     /* U+00DC LATIN CAPITAL LETTER U WITH DIAERESIS */
+#define XK_Yacute 0x00dd         /* U+00DD LATIN CAPITAL LETTER Y WITH ACUTE */
+#define XK_THORN 0x00de          /* U+00DE LATIN CAPITAL LETTER THORN */
+#define XK_Thorn 0x00de          /* deprecated */
+#define XK_ssharp 0x00df         /* U+00DF LATIN SMALL LETTER SHARP S */
+#define XK_agrave 0x00e0         /* U+00E0 LATIN SMALL LETTER A WITH GRAVE */
+#define XK_aacute 0x00e1         /* U+00E1 LATIN SMALL LETTER A WITH ACUTE */
+#define XK_acircumflex 0x00e2    /* U+00E2 LATIN SMALL LETTER A WITH CIRCUMFLEX */
+#define XK_atilde 0x00e3         /* U+00E3 LATIN SMALL LETTER A WITH TILDE */
+#define XK_adiaeresis 0x00e4     /* U+00E4 LATIN SMALL LETTER A WITH DIAERESIS */
+#define XK_aring 0x00e5          /* U+00E5 LATIN SMALL LETTER A WITH RING ABOVE */
+#define XK_ae 0x00e6             /* U+00E6 LATIN SMALL LETTER AE */
+#define XK_ccedilla 0x00e7       /* U+00E7 LATIN SMALL LETTER C WITH CEDILLA */
+#define XK_egrave 0x00e8         /* U+00E8 LATIN SMALL LETTER E WITH GRAVE */
+#define XK_eacute 0x00e9         /* U+00E9 LATIN SMALL LETTER E WITH ACUTE */
+#define XK_ecircumflex 0x00ea    /* U+00EA LATIN SMALL LETTER E WITH CIRCUMFLEX */
+#define XK_ediaeresis 0x00eb     /* U+00EB LATIN SMALL LETTER E WITH DIAERESIS */
+#define XK_igrave 0x00ec         /* U+00EC LATIN SMALL LETTER I WITH GRAVE */
+#define XK_iacute 0x00ed         /* U+00ED LATIN SMALL LETTER I WITH ACUTE */
+#define XK_icircumflex 0x00ee    /* U+00EE LATIN SMALL LETTER I WITH CIRCUMFLEX */
+#define XK_idiaeresis 0x00ef     /* U+00EF LATIN SMALL LETTER I WITH DIAERESIS */
+#define XK_eth 0x00f0            /* U+00F0 LATIN SMALL LETTER ETH */
+#define XK_ntilde 0x00f1         /* U+00F1 LATIN SMALL LETTER N WITH TILDE */
+#define XK_ograve 0x00f2         /* U+00F2 LATIN SMALL LETTER O WITH GRAVE */
+#define XK_oacute 0x00f3         /* U+00F3 LATIN SMALL LETTER O WITH ACUTE */
+#define XK_ocircumflex 0x00f4    /* U+00F4 LATIN SMALL LETTER O WITH CIRCUMFLEX */
+#define XK_otilde 0x00f5         /* U+00F5 LATIN SMALL LETTER O WITH TILDE */
+#define XK_odiaeresis 0x00f6     /* U+00F6 LATIN SMALL LETTER O WITH DIAERESIS */
+#define XK_division 0x00f7       /* U+00F7 DIVISION SIGN */
+#define XK_oslash 0x00f8         /* U+00F8 LATIN SMALL LETTER O WITH STROKE */
+#define XK_ooblique 0x00f8       /* U+00F8 LATIN SMALL LETTER O WITH STROKE */
+#define XK_ugrave 0x00f9         /* U+00F9 LATIN SMALL LETTER U WITH GRAVE */
+#define XK_uacute 0x00fa         /* U+00FA LATIN SMALL LETTER U WITH ACUTE */
+#define XK_ucircumflex 0x00fb    /* U+00FB LATIN SMALL LETTER U WITH CIRCUMFLEX */
+#define XK_udiaeresis 0x00fc     /* U+00FC LATIN SMALL LETTER U WITH DIAERESIS */
+#define XK_yacute 0x00fd         /* U+00FD LATIN SMALL LETTER Y WITH ACUTE */
+#define XK_thorn 0x00fe          /* U+00FE LATIN SMALL LETTER THORN */
+#define XK_ydiaeresis 0x00ff     /* U+00FF LATIN SMALL LETTER Y WITH DIAERESIS */
+#endif                           /* XK_LATIN1 */
+
+/*
+ * Latin 2
+ * Byte 3 = 1
+ */
+
+#ifdef XK_LATIN2
+#define XK_Aogonek 0x01a1      /* U+0104 LATIN CAPITAL LETTER A WITH OGONEK */
+#define XK_breve 0x01a2        /* U+02D8 BREVE */
+#define XK_Lstroke 0x01a3      /* U+0141 LATIN CAPITAL LETTER L WITH STROKE */
+#define XK_Lcaron 0x01a5       /* U+013D LATIN CAPITAL LETTER L WITH CARON */
+#define XK_Sacute 0x01a6       /* U+015A LATIN CAPITAL LETTER S WITH ACUTE */
+#define XK_Scaron 0x01a9       /* U+0160 LATIN CAPITAL LETTER S WITH CARON */
+#define XK_Scedilla 0x01aa     /* U+015E LATIN CAPITAL LETTER S WITH CEDILLA */
+#define XK_Tcaron 0x01ab       /* U+0164 LATIN CAPITAL LETTER T WITH CARON */
+#define XK_Zacute 0x01ac       /* U+0179 LATIN CAPITAL LETTER Z WITH ACUTE */
+#define XK_Zcaron 0x01ae       /* U+017D LATIN CAPITAL LETTER Z WITH CARON */
+#define XK_Zabovedot 0x01af    /* U+017B LATIN CAPITAL LETTER Z WITH DOT ABOVE */
+#define XK_aogonek 0x01b1      /* U+0105 LATIN SMALL LETTER A WITH OGONEK */
+#define XK_ogonek 0x01b2       /* U+02DB OGONEK */
+#define XK_lstroke 0x01b3      /* U+0142 LATIN SMALL LETTER L WITH STROKE */
+#define XK_lcaron 0x01b5       /* U+013E LATIN SMALL LETTER L WITH CARON */
+#define XK_sacute 0x01b6       /* U+015B LATIN SMALL LETTER S WITH ACUTE */
+#define XK_caron 0x01b7        /* U+02C7 CARON */
+#define XK_scaron 0x01b9       /* U+0161 LATIN SMALL LETTER S WITH CARON */
+#define XK_scedilla 0x01ba     /* U+015F LATIN SMALL LETTER S WITH CEDILLA */
+#define XK_tcaron 0x01bb       /* U+0165 LATIN SMALL LETTER T WITH CARON */
+#define XK_zacute 0x01bc       /* U+017A LATIN SMALL LETTER Z WITH ACUTE */
+#define XK_doubleacute 0x01bd  /* U+02DD DOUBLE ACUTE ACCENT */
+#define XK_zcaron 0x01be       /* U+017E LATIN SMALL LETTER Z WITH CARON */
+#define XK_zabovedot 0x01bf    /* U+017C LATIN SMALL LETTER Z WITH DOT ABOVE */
+#define XK_Racute 0x01c0       /* U+0154 LATIN CAPITAL LETTER R WITH ACUTE */
+#define XK_Abreve 0x01c3       /* U+0102 LATIN CAPITAL LETTER A WITH BREVE */
+#define XK_Lacute 0x01c5       /* U+0139 LATIN CAPITAL LETTER L WITH ACUTE */
+#define XK_Cacute 0x01c6       /* U+0106 LATIN CAPITAL LETTER C WITH ACUTE */
+#define XK_Ccaron 0x01c8       /* U+010C LATIN CAPITAL LETTER C WITH CARON */
+#define XK_Eogonek 0x01ca      /* U+0118 LATIN CAPITAL LETTER E WITH OGONEK */
+#define XK_Ecaron 0x01cc       /* U+011A LATIN CAPITAL LETTER E WITH CARON */
+#define XK_Dcaron 0x01cf       /* U+010E LATIN CAPITAL LETTER D WITH CARON */
+#define XK_Dstroke 0x01d0      /* U+0110 LATIN CAPITAL LETTER D WITH STROKE */
+#define XK_Nacute 0x01d1       /* U+0143 LATIN CAPITAL LETTER N WITH ACUTE */
+#define XK_Ncaron 0x01d2       /* U+0147 LATIN CAPITAL LETTER N WITH CARON */
+#define XK_Odoubleacute 0x01d5 /* U+0150 LATIN CAPITAL LETTER O WITH DOUBLE ACUTE */
+#define XK_Rcaron 0x01d8       /* U+0158 LATIN CAPITAL LETTER R WITH CARON */
+#define XK_Uring 0x01d9        /* U+016E LATIN CAPITAL LETTER U WITH RING ABOVE */
+#define XK_Udoubleacute 0x01db /* U+0170 LATIN CAPITAL LETTER U WITH DOUBLE ACUTE */
+#define XK_Tcedilla 0x01de     /* U+0162 LATIN CAPITAL LETTER T WITH CEDILLA */
+#define XK_racute 0x01e0       /* U+0155 LATIN SMALL LETTER R WITH ACUTE */
+#define XK_abreve 0x01e3       /* U+0103 LATIN SMALL LETTER A WITH BREVE */
+#define XK_lacute 0x01e5       /* U+013A LATIN SMALL LETTER L WITH ACUTE */
+#define XK_cacute 0x01e6       /* U+0107 LATIN SMALL LETTER C WITH ACUTE */
+#define XK_ccaron 0x01e8       /* U+010D LATIN SMALL LETTER C WITH CARON */
+#define XK_eogonek 0x01ea      /* U+0119 LATIN SMALL LETTER E WITH OGONEK */
+#define XK_ecaron 0x01ec       /* U+011B LATIN SMALL LETTER E WITH CARON */
+#define XK_dcaron 0x01ef       /* U+010F LATIN SMALL LETTER D WITH CARON */
+#define XK_dstroke 0x01f0      /* U+0111 LATIN SMALL LETTER D WITH STROKE */
+#define XK_nacute 0x01f1       /* U+0144 LATIN SMALL LETTER N WITH ACUTE */
+#define XK_ncaron 0x01f2       /* U+0148 LATIN SMALL LETTER N WITH CARON */
+#define XK_odoubleacute 0x01f5 /* U+0151 LATIN SMALL LETTER O WITH DOUBLE ACUTE */
+#define XK_rcaron 0x01f8       /* U+0159 LATIN SMALL LETTER R WITH CARON */
+#define XK_uring 0x01f9        /* U+016F LATIN SMALL LETTER U WITH RING ABOVE */
+#define XK_udoubleacute 0x01fb /* U+0171 LATIN SMALL LETTER U WITH DOUBLE ACUTE */
+#define XK_tcedilla 0x01fe     /* U+0163 LATIN SMALL LETTER T WITH CEDILLA */
+#define XK_abovedot 0x01ff     /* U+02D9 DOT ABOVE */
+#endif                         /* XK_LATIN2 */
+
+/*
+ * Latin 3
+ * Byte 3 = 2
+ */
+
+#ifdef XK_LATIN3
+#define XK_Hstroke 0x02a1     /* U+0126 LATIN CAPITAL LETTER H WITH STROKE */
+#define XK_Hcircumflex 0x02a6 /* U+0124 LATIN CAPITAL LETTER H WITH CIRCUMFLEX */
+#define XK_Iabovedot 0x02a9   /* U+0130 LATIN CAPITAL LETTER I WITH DOT ABOVE */
+#define XK_Gbreve 0x02ab      /* U+011E LATIN CAPITAL LETTER G WITH BREVE */
+#define XK_Jcircumflex 0x02ac /* U+0134 LATIN CAPITAL LETTER J WITH CIRCUMFLEX */
+#define XK_hstroke 0x02b1     /* U+0127 LATIN SMALL LETTER H WITH STROKE */
+#define XK_hcircumflex 0x02b6 /* U+0125 LATIN SMALL LETTER H WITH CIRCUMFLEX */
+#define XK_idotless 0x02b9    /* U+0131 LATIN SMALL LETTER DOTLESS I */
+#define XK_gbreve 0x02bb      /* U+011F LATIN SMALL LETTER G WITH BREVE */
+#define XK_jcircumflex 0x02bc /* U+0135 LATIN SMALL LETTER J WITH CIRCUMFLEX */
+#define XK_Cabovedot 0x02c5   /* U+010A LATIN CAPITAL LETTER C WITH DOT ABOVE */
+#define XK_Ccircumflex 0x02c6 /* U+0108 LATIN CAPITAL LETTER C WITH CIRCUMFLEX */
+#define XK_Gabovedot 0x02d5   /* U+0120 LATIN CAPITAL LETTER G WITH DOT ABOVE */
+#define XK_Gcircumflex 0x02d8 /* U+011C LATIN CAPITAL LETTER G WITH CIRCUMFLEX */
+#define XK_Ubreve 0x02dd      /* U+016C LATIN CAPITAL LETTER U WITH BREVE */
+#define XK_Scircumflex 0x02de /* U+015C LATIN CAPITAL LETTER S WITH CIRCUMFLEX */
+#define XK_cabovedot 0x02e5   /* U+010B LATIN SMALL LETTER C WITH DOT ABOVE */
+#define XK_ccircumflex 0x02e6 /* U+0109 LATIN SMALL LETTER C WITH CIRCUMFLEX */
+#define XK_gabovedot 0x02f5   /* U+0121 LATIN SMALL LETTER G WITH DOT ABOVE */
+#define XK_gcircumflex 0x02f8 /* U+011D LATIN SMALL LETTER G WITH CIRCUMFLEX */
+#define XK_ubreve 0x02fd      /* U+016D LATIN SMALL LETTER U WITH BREVE */
+#define XK_scircumflex 0x02fe /* U+015D LATIN SMALL LETTER S WITH CIRCUMFLEX */
+#endif                        /* XK_LATIN3 */
+
+/*
+ * Latin 4
+ * Byte 3 = 3
+ */
+
+#ifdef XK_LATIN4
+#define XK_kra 0x03a2       /* U+0138 LATIN SMALL LETTER KRA */
+#define XK_kappa 0x03a2     /* deprecated */
+#define XK_Rcedilla 0x03a3  /* U+0156 LATIN CAPITAL LETTER R WITH CEDILLA */
+#define XK_Itilde 0x03a5    /* U+0128 LATIN CAPITAL LETTER I WITH TILDE */
+#define XK_Lcedilla 0x03a6  /* U+013B LATIN CAPITAL LETTER L WITH CEDILLA */
+#define XK_Emacron 0x03aa   /* U+0112 LATIN CAPITAL LETTER E WITH MACRON */
+#define XK_Gcedilla 0x03ab  /* U+0122 LATIN CAPITAL LETTER G WITH CEDILLA */
+#define XK_Tslash 0x03ac    /* U+0166 LATIN CAPITAL LETTER T WITH STROKE */
+#define XK_rcedilla 0x03b3  /* U+0157 LATIN SMALL LETTER R WITH CEDILLA */
+#define XK_itilde 0x03b5    /* U+0129 LATIN SMALL LETTER I WITH TILDE */
+#define XK_lcedilla 0x03b6  /* U+013C LATIN SMALL LETTER L WITH CEDILLA */
+#define XK_emacron 0x03ba   /* U+0113 LATIN SMALL LETTER E WITH MACRON */
+#define XK_gcedilla 0x03bb  /* U+0123 LATIN SMALL LETTER G WITH CEDILLA */
+#define XK_tslash 0x03bc    /* U+0167 LATIN SMALL LETTER T WITH STROKE */
+#define XK_ENG 0x03bd       /* U+014A LATIN CAPITAL LETTER ENG */
+#define XK_eng 0x03bf       /* U+014B LATIN SMALL LETTER ENG */
+#define XK_Amacron 0x03c0   /* U+0100 LATIN CAPITAL LETTER A WITH MACRON */
+#define XK_Iogonek 0x03c7   /* U+012E LATIN CAPITAL LETTER I WITH OGONEK */
+#define XK_Eabovedot 0x03cc /* U+0116 LATIN CAPITAL LETTER E WITH DOT ABOVE */
+#define XK_Imacron 0x03cf   /* U+012A LATIN CAPITAL LETTER I WITH MACRON */
+#define XK_Ncedilla 0x03d1  /* U+0145 LATIN CAPITAL LETTER N WITH CEDILLA */
+#define XK_Omacron 0x03d2   /* U+014C LATIN CAPITAL LETTER O WITH MACRON */
+#define XK_Kcedilla 0x03d3  /* U+0136 LATIN CAPITAL LETTER K WITH CEDILLA */
+#define XK_Uogonek 0x03d9   /* U+0172 LATIN CAPITAL LETTER U WITH OGONEK */
+#define XK_Utilde 0x03dd    /* U+0168 LATIN CAPITAL LETTER U WITH TILDE */
+#define XK_Umacron 0x03de   /* U+016A LATIN CAPITAL LETTER U WITH MACRON */
+#define XK_amacron 0x03e0   /* U+0101 LATIN SMALL LETTER A WITH MACRON */
+#define XK_iogonek 0x03e7   /* U+012F LATIN SMALL LETTER I WITH OGONEK */
+#define XK_eabovedot 0x03ec /* U+0117 LATIN SMALL LETTER E WITH DOT ABOVE */
+#define XK_imacron 0x03ef   /* U+012B LATIN SMALL LETTER I WITH MACRON */
+#define XK_ncedilla 0x03f1  /* U+0146 LATIN SMALL LETTER N WITH CEDILLA */
+#define XK_omacron 0x03f2   /* U+014D LATIN SMALL LETTER O WITH MACRON */
+#define XK_kcedilla 0x03f3  /* U+0137 LATIN SMALL LETTER K WITH CEDILLA */
+#define XK_uogonek 0x03f9   /* U+0173 LATIN SMALL LETTER U WITH OGONEK */
+#define XK_utilde 0x03fd    /* U+0169 LATIN SMALL LETTER U WITH TILDE */
+#define XK_umacron 0x03fe   /* U+016B LATIN SMALL LETTER U WITH MACRON */
+#endif                      /* XK_LATIN4 */
+
+/*
+ * Latin 8
+ */
+#ifdef XK_LATIN8
+#define XK_Wcircumflex 0x1000174 /* U+0174 LATIN CAPITAL LETTER W WITH CIRCUMFLEX */
+#define XK_wcircumflex 0x1000175 /* U+0175 LATIN SMALL LETTER W WITH CIRCUMFLEX */
+#define XK_Ycircumflex 0x1000176 /* U+0176 LATIN CAPITAL LETTER Y WITH CIRCUMFLEX */
+#define XK_ycircumflex 0x1000177 /* U+0177 LATIN SMALL LETTER Y WITH CIRCUMFLEX */
+#define XK_Babovedot 0x1001e02   /* U+1E02 LATIN CAPITAL LETTER B WITH DOT ABOVE */
+#define XK_babovedot 0x1001e03   /* U+1E03 LATIN SMALL LETTER B WITH DOT ABOVE */
+#define XK_Dabovedot 0x1001e0a   /* U+1E0A LATIN CAPITAL LETTER D WITH DOT ABOVE */
+#define XK_dabovedot 0x1001e0b   /* U+1E0B LATIN SMALL LETTER D WITH DOT ABOVE */
+#define XK_Fabovedot 0x1001e1e   /* U+1E1E LATIN CAPITAL LETTER F WITH DOT ABOVE */
+#define XK_fabovedot 0x1001e1f   /* U+1E1F LATIN SMALL LETTER F WITH DOT ABOVE */
+#define XK_Mabovedot 0x1001e40   /* U+1E40 LATIN CAPITAL LETTER M WITH DOT ABOVE */
+#define XK_mabovedot 0x1001e41   /* U+1E41 LATIN SMALL LETTER M WITH DOT ABOVE */
+#define XK_Pabovedot 0x1001e56   /* U+1E56 LATIN CAPITAL LETTER P WITH DOT ABOVE */
+#define XK_pabovedot 0x1001e57   /* U+1E57 LATIN SMALL LETTER P WITH DOT ABOVE */
+#define XK_Sabovedot 0x1001e60   /* U+1E60 LATIN CAPITAL LETTER S WITH DOT ABOVE */
+#define XK_sabovedot 0x1001e61   /* U+1E61 LATIN SMALL LETTER S WITH DOT ABOVE */
+#define XK_Tabovedot 0x1001e6a   /* U+1E6A LATIN CAPITAL LETTER T WITH DOT ABOVE */
+#define XK_tabovedot 0x1001e6b   /* U+1E6B LATIN SMALL LETTER T WITH DOT ABOVE */
+#define XK_Wgrave 0x1001e80      /* U+1E80 LATIN CAPITAL LETTER W WITH GRAVE */
+#define XK_wgrave 0x1001e81      /* U+1E81 LATIN SMALL LETTER W WITH GRAVE */
+#define XK_Wacute 0x1001e82      /* U+1E82 LATIN CAPITAL LETTER W WITH ACUTE */
+#define XK_wacute 0x1001e83      /* U+1E83 LATIN SMALL LETTER W WITH ACUTE */
+#define XK_Wdiaeresis 0x1001e84  /* U+1E84 LATIN CAPITAL LETTER W WITH DIAERESIS */
+#define XK_wdiaeresis 0x1001e85  /* U+1E85 LATIN SMALL LETTER W WITH DIAERESIS */
+#define XK_Ygrave 0x1001ef2      /* U+1EF2 LATIN CAPITAL LETTER Y WITH GRAVE */
+#define XK_ygrave 0x1001ef3      /* U+1EF3 LATIN SMALL LETTER Y WITH GRAVE */
+#endif                           /* XK_LATIN8 */
+
+/*
+ * Latin 9
+ * Byte 3 = 0x13
+ */
+
+#ifdef XK_LATIN9
+#define XK_OE 0x13bc         /* U+0152 LATIN CAPITAL LIGATURE OE */
+#define XK_oe 0x13bd         /* U+0153 LATIN SMALL LIGATURE OE */
+#define XK_Ydiaeresis 0x13be /* U+0178 LATIN CAPITAL LETTER Y WITH DIAERESIS */
+#endif                       /* XK_LATIN9 */
+
+/*
+ * Katakana
+ * Byte 3 = 4
+ */
+
+#ifdef XK_KATAKANA
+#define XK_overline 0x047e            /* U+203E OVERLINE */
+#define XK_kana_fullstop 0x04a1       /* U+3002 IDEOGRAPHIC FULL STOP */
+#define XK_kana_openingbracket 0x04a2 /* U+300C LEFT CORNER BRACKET */
+#define XK_kana_closingbracket 0x04a3 /* U+300D RIGHT CORNER BRACKET */
+#define XK_kana_comma 0x04a4          /* U+3001 IDEOGRAPHIC COMMA */
+#define XK_kana_conjunctive 0x04a5    /* U+30FB KATAKANA MIDDLE DOT */
+#define XK_kana_middledot 0x04a5      /* deprecated */
+#define XK_kana_WO 0x04a6             /* U+30F2 KATAKANA LETTER WO */
+#define XK_kana_a 0x04a7              /* U+30A1 KATAKANA LETTER SMALL A */
+#define XK_kana_i 0x04a8              /* U+30A3 KATAKANA LETTER SMALL I */
+#define XK_kana_u 0x04a9              /* U+30A5 KATAKANA LETTER SMALL U */
+#define XK_kana_e 0x04aa              /* U+30A7 KATAKANA LETTER SMALL E */
+#define XK_kana_o 0x04ab              /* U+30A9 KATAKANA LETTER SMALL O */
+#define XK_kana_ya 0x04ac             /* U+30E3 KATAKANA LETTER SMALL YA */
+#define XK_kana_yu 0x04ad             /* U+30E5 KATAKANA LETTER SMALL YU */
+#define XK_kana_yo 0x04ae             /* U+30E7 KATAKANA LETTER SMALL YO */
+#define XK_kana_tsu 0x04af            /* U+30C3 KATAKANA LETTER SMALL TU */
+#define XK_kana_tu 0x04af             /* deprecated */
+#define XK_prolongedsound 0x04b0      /* U+30FC KATAKANA-HIRAGANA PROLONGED SOUND MARK */
+#define XK_kana_A 0x04b1              /* U+30A2 KATAKANA LETTER A */
+#define XK_kana_I 0x04b2              /* U+30A4 KATAKANA LETTER I */
+#define XK_kana_U 0x04b3              /* U+30A6 KATAKANA LETTER U */
+#define XK_kana_E 0x04b4              /* U+30A8 KATAKANA LETTER E */
+#define XK_kana_O 0x04b5              /* U+30AA KATAKANA LETTER O */
+#define XK_kana_KA 0x04b6             /* U+30AB KATAKANA LETTER KA */
+#define XK_kana_KI 0x04b7             /* U+30AD KATAKANA LETTER KI */
+#define XK_kana_KU 0x04b8             /* U+30AF KATAKANA LETTER KU */
+#define XK_kana_KE 0x04b9             /* U+30B1 KATAKANA LETTER KE */
+#define XK_kana_KO 0x04ba             /* U+30B3 KATAKANA LETTER KO */
+#define XK_kana_SA 0x04bb             /* U+30B5 KATAKANA LETTER SA */
+#define XK_kana_SHI 0x04bc            /* U+30B7 KATAKANA LETTER SI */
+#define XK_kana_SU 0x04bd             /* U+30B9 KATAKANA LETTER SU */
+#define XK_kana_SE 0x04be             /* U+30BB KATAKANA LETTER SE */
+#define XK_kana_SO 0x04bf             /* U+30BD KATAKANA LETTER SO */
+#define XK_kana_TA 0x04c0             /* U+30BF KATAKANA LETTER TA */
+#define XK_kana_CHI 0x04c1            /* U+30C1 KATAKANA LETTER TI */
+#define XK_kana_TI 0x04c1             /* deprecated */
+#define XK_kana_TSU 0x04c2            /* U+30C4 KATAKANA LETTER TU */
+#define XK_kana_TU 0x04c2             /* deprecated */
+#define XK_kana_TE 0x04c3             /* U+30C6 KATAKANA LETTER TE */
+#define XK_kana_TO 0x04c4             /* U+30C8 KATAKANA LETTER TO */
+#define XK_kana_NA 0x04c5             /* U+30CA KATAKANA LETTER NA */
+#define XK_kana_NI 0x04c6             /* U+30CB KATAKANA LETTER NI */
+#define XK_kana_NU 0x04c7             /* U+30CC KATAKANA LETTER NU */
+#define XK_kana_NE 0x04c8             /* U+30CD KATAKANA LETTER NE */
+#define XK_kana_NO 0x04c9             /* U+30CE KATAKANA LETTER NO */
+#define XK_kana_HA 0x04ca             /* U+30CF KATAKANA LETTER HA */
+#define XK_kana_HI 0x04cb             /* U+30D2 KATAKANA LETTER HI */
+#define XK_kana_FU 0x04cc             /* U+30D5 KATAKANA LETTER HU */
+#define XK_kana_HU 0x04cc             /* deprecated */
+#define XK_kana_HE 0x04cd             /* U+30D8 KATAKANA LETTER HE */
+#define XK_kana_HO 0x04ce             /* U+30DB KATAKANA LETTER HO */
+#define XK_kana_MA 0x04cf             /* U+30DE KATAKANA LETTER MA */
+#define XK_kana_MI 0x04d0             /* U+30DF KATAKANA LETTER MI */
+#define XK_kana_MU 0x04d1             /* U+30E0 KATAKANA LETTER MU */
+#define XK_kana_ME 0x04d2             /* U+30E1 KATAKANA LETTER ME */
+#define XK_kana_MO 0x04d3             /* U+30E2 KATAKANA LETTER MO */
+#define XK_kana_YA 0x04d4             /* U+30E4 KATAKANA LETTER YA */
+#define XK_kana_YU 0x04d5             /* U+30E6 KATAKANA LETTER YU */
+#define XK_kana_YO 0x04d6             /* U+30E8 KATAKANA LETTER YO */
+#define XK_kana_RA 0x04d7             /* U+30E9 KATAKANA LETTER RA */
+#define XK_kana_RI 0x04d8             /* U+30EA KATAKANA LETTER RI */
+#define XK_kana_RU 0x04d9             /* U+30EB KATAKANA LETTER RU */
+#define XK_kana_RE 0x04da             /* U+30EC KATAKANA LETTER RE */
+#define XK_kana_RO 0x04db             /* U+30ED KATAKANA LETTER RO */
+#define XK_kana_WA 0x04dc             /* U+30EF KATAKANA LETTER WA */
+#define XK_kana_N 0x04dd              /* U+30F3 KATAKANA LETTER N */
+#define XK_voicedsound 0x04de         /* U+309B KATAKANA-HIRAGANA VOICED SOUND MARK */
+#define XK_semivoicedsound 0x04df     /* U+309C KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK */
+#define XK_kana_switch 0xff7e         /* Alias for mode_switch */
+#endif                                /* XK_KATAKANA */
+
+/*
+ * Arabic
+ * Byte 3 = 5
+ */
+
+#ifdef XK_ARABIC
+#define XK_Farsi_0 0x10006f0                 /* U+06F0 EXTENDED ARABIC-INDIC DIGIT ZERO */
+#define XK_Farsi_1 0x10006f1                 /* U+06F1 EXTENDED ARABIC-INDIC DIGIT ONE */
+#define XK_Farsi_2 0x10006f2                 /* U+06F2 EXTENDED ARABIC-INDIC DIGIT TWO */
+#define XK_Farsi_3 0x10006f3                 /* U+06F3 EXTENDED ARABIC-INDIC DIGIT THREE */
+#define XK_Farsi_4 0x10006f4                 /* U+06F4 EXTENDED ARABIC-INDIC DIGIT FOUR */
+#define XK_Farsi_5 0x10006f5                 /* U+06F5 EXTENDED ARABIC-INDIC DIGIT FIVE */
+#define XK_Farsi_6 0x10006f6                 /* U+06F6 EXTENDED ARABIC-INDIC DIGIT SIX */
+#define XK_Farsi_7 0x10006f7                 /* U+06F7 EXTENDED ARABIC-INDIC DIGIT SEVEN */
+#define XK_Farsi_8 0x10006f8                 /* U+06F8 EXTENDED ARABIC-INDIC DIGIT EIGHT */
+#define XK_Farsi_9 0x10006f9                 /* U+06F9 EXTENDED ARABIC-INDIC DIGIT NINE */
+#define XK_Arabic_percent 0x100066a          /* U+066A ARABIC PERCENT SIGN */
+#define XK_Arabic_superscript_alef 0x1000670 /* U+0670 ARABIC LETTER SUPERSCRIPT ALEF */
+#define XK_Arabic_tteh 0x1000679             /* U+0679 ARABIC LETTER TTEH */
+#define XK_Arabic_peh 0x100067e              /* U+067E ARABIC LETTER PEH */
+#define XK_Arabic_tcheh 0x1000686            /* U+0686 ARABIC LETTER TCHEH */
+#define XK_Arabic_ddal 0x1000688             /* U+0688 ARABIC LETTER DDAL */
+#define XK_Arabic_rreh 0x1000691             /* U+0691 ARABIC LETTER RREH */
+#define XK_Arabic_comma 0x05ac               /* U+060C ARABIC COMMA */
+#define XK_Arabic_fullstop 0x10006d4         /* U+06D4 ARABIC FULL STOP */
+#define XK_Arabic_0 0x1000660                /* U+0660 ARABIC-INDIC DIGIT ZERO */
+#define XK_Arabic_1 0x1000661                /* U+0661 ARABIC-INDIC DIGIT ONE */
+#define XK_Arabic_2 0x1000662                /* U+0662 ARABIC-INDIC DIGIT TWO */
+#define XK_Arabic_3 0x1000663                /* U+0663 ARABIC-INDIC DIGIT THREE */
+#define XK_Arabic_4 0x1000664                /* U+0664 ARABIC-INDIC DIGIT FOUR */
+#define XK_Arabic_5 0x1000665                /* U+0665 ARABIC-INDIC DIGIT FIVE */
+#define XK_Arabic_6 0x1000666                /* U+0666 ARABIC-INDIC DIGIT SIX */
+#define XK_Arabic_7 0x1000667                /* U+0667 ARABIC-INDIC DIGIT SEVEN */
+#define XK_Arabic_8 0x1000668                /* U+0668 ARABIC-INDIC DIGIT EIGHT */
+#define XK_Arabic_9 0x1000669                /* U+0669 ARABIC-INDIC DIGIT NINE */
+#define XK_Arabic_semicolon 0x05bb           /* U+061B ARABIC SEMICOLON */
+#define XK_Arabic_question_mark 0x05bf       /* U+061F ARABIC QUESTION MARK */
+#define XK_Arabic_hamza 0x05c1               /* U+0621 ARABIC LETTER HAMZA */
+#define XK_Arabic_maddaonalef 0x05c2         /* U+0622 ARABIC LETTER ALEF WITH MADDA ABOVE */
+#define XK_Arabic_hamzaonalef 0x05c3         /* U+0623 ARABIC LETTER ALEF WITH HAMZA ABOVE */
+#define XK_Arabic_hamzaonwaw 0x05c4          /* U+0624 ARABIC LETTER WAW WITH HAMZA ABOVE */
+#define XK_Arabic_hamzaunderalef 0x05c5      /* U+0625 ARABIC LETTER ALEF WITH HAMZA BELOW */
+#define XK_Arabic_hamzaonyeh 0x05c6          /* U+0626 ARABIC LETTER YEH WITH HAMZA ABOVE */
+#define XK_Arabic_alef 0x05c7                /* U+0627 ARABIC LETTER ALEF */
+#define XK_Arabic_beh 0x05c8                 /* U+0628 ARABIC LETTER BEH */
+#define XK_Arabic_tehmarbuta 0x05c9          /* U+0629 ARABIC LETTER TEH MARBUTA */
+#define XK_Arabic_teh 0x05ca                 /* U+062A ARABIC LETTER TEH */
+#define XK_Arabic_theh 0x05cb                /* U+062B ARABIC LETTER THEH */
+#define XK_Arabic_jeem 0x05cc                /* U+062C ARABIC LETTER JEEM */
+#define XK_Arabic_hah 0x05cd                 /* U+062D ARABIC LETTER HAH */
+#define XK_Arabic_khah 0x05ce                /* U+062E ARABIC LETTER KHAH */
+#define XK_Arabic_dal 0x05cf                 /* U+062F ARABIC LETTER DAL */
+#define XK_Arabic_thal 0x05d0                /* U+0630 ARABIC LETTER THAL */
+#define XK_Arabic_ra 0x05d1                  /* U+0631 ARABIC LETTER REH */
+#define XK_Arabic_zain 0x05d2                /* U+0632 ARABIC LETTER ZAIN */
+#define XK_Arabic_seen 0x05d3                /* U+0633 ARABIC LETTER SEEN */
+#define XK_Arabic_sheen 0x05d4               /* U+0634 ARABIC LETTER SHEEN */
+#define XK_Arabic_sad 0x05d5                 /* U+0635 ARABIC LETTER SAD */
+#define XK_Arabic_dad 0x05d6                 /* U+0636 ARABIC LETTER DAD */
+#define XK_Arabic_tah 0x05d7                 /* U+0637 ARABIC LETTER TAH */
+#define XK_Arabic_zah 0x05d8                 /* U+0638 ARABIC LETTER ZAH */
+#define XK_Arabic_ain 0x05d9                 /* U+0639 ARABIC LETTER AIN */
+#define XK_Arabic_ghain 0x05da               /* U+063A ARABIC LETTER GHAIN */
+#define XK_Arabic_tatweel 0x05e0             /* U+0640 ARABIC TATWEEL */
+#define XK_Arabic_feh 0x05e1                 /* U+0641 ARABIC LETTER FEH */
+#define XK_Arabic_qaf 0x05e2                 /* U+0642 ARABIC LETTER QAF */
+#define XK_Arabic_kaf 0x05e3                 /* U+0643 ARABIC LETTER KAF */
+#define XK_Arabic_lam 0x05e4                 /* U+0644 ARABIC LETTER LAM */
+#define XK_Arabic_meem 0x05e5                /* U+0645 ARABIC LETTER MEEM */
+#define XK_Arabic_noon 0x05e6                /* U+0646 ARABIC LETTER NOON */
+#define XK_Arabic_ha 0x05e7                  /* U+0647 ARABIC LETTER HEH */
+#define XK_Arabic_heh 0x05e7                 /* deprecated */
+#define XK_Arabic_waw 0x05e8                 /* U+0648 ARABIC LETTER WAW */
+#define XK_Arabic_alefmaksura 0x05e9         /* U+0649 ARABIC LETTER ALEF MAKSURA */
+#define XK_Arabic_yeh 0x05ea                 /* U+064A ARABIC LETTER YEH */
+#define XK_Arabic_fathatan 0x05eb            /* U+064B ARABIC FATHATAN */
+#define XK_Arabic_dammatan 0x05ec            /* U+064C ARABIC DAMMATAN */
+#define XK_Arabic_kasratan 0x05ed            /* U+064D ARABIC KASRATAN */
+#define XK_Arabic_fatha 0x05ee               /* U+064E ARABIC FATHA */
+#define XK_Arabic_damma 0x05ef               /* U+064F ARABIC DAMMA */
+#define XK_Arabic_kasra 0x05f0               /* U+0650 ARABIC KASRA */
+#define XK_Arabic_shadda 0x05f1              /* U+0651 ARABIC SHADDA */
+#define XK_Arabic_sukun 0x05f2               /* U+0652 ARABIC SUKUN */
+#define XK_Arabic_madda_above 0x1000653      /* U+0653 ARABIC MADDAH ABOVE */
+#define XK_Arabic_hamza_above 0x1000654      /* U+0654 ARABIC HAMZA ABOVE */
+#define XK_Arabic_hamza_below 0x1000655      /* U+0655 ARABIC HAMZA BELOW */
+#define XK_Arabic_jeh 0x1000698              /* U+0698 ARABIC LETTER JEH */
+#define XK_Arabic_veh 0x10006a4              /* U+06A4 ARABIC LETTER VEH */
+#define XK_Arabic_keheh 0x10006a9            /* U+06A9 ARABIC LETTER KEHEH */
+#define XK_Arabic_gaf 0x10006af              /* U+06AF ARABIC LETTER GAF */
+#define XK_Arabic_noon_ghunna 0x10006ba      /* U+06BA ARABIC LETTER NOON GHUNNA */
+#define XK_Arabic_heh_doachashmee 0x10006be  /* U+06BE ARABIC LETTER HEH DOACHASHMEE */
+#define XK_Farsi_yeh 0x10006cc               /* U+06CC ARABIC LETTER FARSI YEH */
+#define XK_Arabic_farsi_yeh 0x10006cc        /* U+06CC ARABIC LETTER FARSI YEH */
+#define XK_Arabic_yeh_baree 0x10006d2        /* U+06D2 ARABIC LETTER YEH BARREE */
+#define XK_Arabic_heh_goal 0x10006c1         /* U+06C1 ARABIC LETTER HEH GOAL */
+#define XK_Arabic_switch 0xff7e              /* Alias for mode_switch */
+#endif                                       /* XK_ARABIC */
+
+/*
+ * Cyrillic
+ * Byte 3 = 6
+ */
+#ifdef XK_CYRILLIC
+#define XK_Cyrillic_GHE_bar 0x1000492        /* U+0492 CYRILLIC CAPITAL LETTER GHE WITH STROKE */
+#define XK_Cyrillic_ghe_bar 0x1000493        /* U+0493 CYRILLIC SMALL LETTER GHE WITH STROKE */
+#define XK_Cyrillic_ZHE_descender 0x1000496  /* U+0496 CYRILLIC CAPITAL LETTER ZHE WITH DESCENDER */
+#define XK_Cyrillic_zhe_descender 0x1000497  /* U+0497 CYRILLIC SMALL LETTER ZHE WITH DESCENDER */
+#define XK_Cyrillic_KA_descender 0x100049a   /* U+049A CYRILLIC CAPITAL LETTER KA WITH DESCENDER */
+#define XK_Cyrillic_ka_descender 0x100049b   /* U+049B CYRILLIC SMALL LETTER KA WITH DESCENDER */
+#define XK_Cyrillic_KA_vertstroke 0x100049c  /* U+049C CYRILLIC CAPITAL LETTER KA WITH VERTICAL STROKE */
+#define XK_Cyrillic_ka_vertstroke 0x100049d  /* U+049D CYRILLIC SMALL LETTER KA WITH VERTICAL STROKE */
+#define XK_Cyrillic_EN_descender 0x10004a2   /* U+04A2 CYRILLIC CAPITAL LETTER EN WITH DESCENDER */
+#define XK_Cyrillic_en_descender 0x10004a3   /* U+04A3 CYRILLIC SMALL LETTER EN WITH DESCENDER */
+#define XK_Cyrillic_U_straight 0x10004ae     /* U+04AE CYRILLIC CAPITAL LETTER STRAIGHT U */
+#define XK_Cyrillic_u_straight 0x10004af     /* U+04AF CYRILLIC SMALL LETTER STRAIGHT U */
+#define XK_Cyrillic_U_straight_bar 0x10004b0 /* U+04B0 CYRILLIC CAPITAL LETTER STRAIGHT U WITH STROKE */
+#define XK_Cyrillic_u_straight_bar 0x10004b1 /* U+04B1 CYRILLIC SMALL LETTER STRAIGHT U WITH STROKE */
+#define XK_Cyrillic_HA_descender 0x10004b2   /* U+04B2 CYRILLIC CAPITAL LETTER HA WITH DESCENDER */
+#define XK_Cyrillic_ha_descender 0x10004b3   /* U+04B3 CYRILLIC SMALL LETTER HA WITH DESCENDER */
+#define XK_Cyrillic_CHE_descender 0x10004b6  /* U+04B6 CYRILLIC CAPITAL LETTER CHE WITH DESCENDER */
+#define XK_Cyrillic_che_descender 0x10004b7  /* U+04B7 CYRILLIC SMALL LETTER CHE WITH DESCENDER */
+#define XK_Cyrillic_CHE_vertstroke 0x10004b8 /* U+04B8 CYRILLIC CAPITAL LETTER CHE WITH VERTICAL STROKE */
+#define XK_Cyrillic_che_vertstroke 0x10004b9 /* U+04B9 CYRILLIC SMALL LETTER CHE WITH VERTICAL STROKE */
+#define XK_Cyrillic_SHHA 0x10004ba           /* U+04BA CYRILLIC CAPITAL LETTER SHHA */
+#define XK_Cyrillic_shha 0x10004bb           /* U+04BB CYRILLIC SMALL LETTER SHHA */
+
+#define XK_Cyrillic_SCHWA 0x10004d8    /* U+04D8 CYRILLIC CAPITAL LETTER SCHWA */
+#define XK_Cyrillic_schwa 0x10004d9    /* U+04D9 CYRILLIC SMALL LETTER SCHWA */
+#define XK_Cyrillic_I_macron 0x10004e2 /* U+04E2 CYRILLIC CAPITAL LETTER I WITH MACRON */
+#define XK_Cyrillic_i_macron 0x10004e3 /* U+04E3 CYRILLIC SMALL LETTER I WITH MACRON */
+#define XK_Cyrillic_O_bar 0x10004e8    /* U+04E8 CYRILLIC CAPITAL LETTER BARRED O */
+#define XK_Cyrillic_o_bar 0x10004e9    /* U+04E9 CYRILLIC SMALL LETTER BARRED O */
+#define XK_Cyrillic_U_macron 0x10004ee /* U+04EE CYRILLIC CAPITAL LETTER U WITH MACRON */
+#define XK_Cyrillic_u_macron 0x10004ef /* U+04EF CYRILLIC SMALL LETTER U WITH MACRON */
+
+#define XK_Serbian_dje 0x06a1               /* U+0452 CYRILLIC SMALL LETTER DJE */
+#define XK_Macedonia_gje 0x06a2             /* U+0453 CYRILLIC SMALL LETTER GJE */
+#define XK_Cyrillic_io 0x06a3               /* U+0451 CYRILLIC SMALL LETTER IO */
+#define XK_Ukrainian_ie 0x06a4              /* U+0454 CYRILLIC SMALL LETTER UKRAINIAN IE */
+#define XK_Ukranian_je 0x06a4               /* deprecated */
+#define XK_Macedonia_dse 0x06a5             /* U+0455 CYRILLIC SMALL LETTER DZE */
+#define XK_Ukrainian_i 0x06a6               /* U+0456 CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I */
+#define XK_Ukranian_i 0x06a6                /* deprecated */
+#define XK_Ukrainian_yi 0x06a7              /* U+0457 CYRILLIC SMALL LETTER YI */
+#define XK_Ukranian_yi 0x06a7               /* deprecated */
+#define XK_Cyrillic_je 0x06a8               /* U+0458 CYRILLIC SMALL LETTER JE */
+#define XK_Serbian_je 0x06a8                /* deprecated */
+#define XK_Cyrillic_lje 0x06a9              /* U+0459 CYRILLIC SMALL LETTER LJE */
+#define XK_Serbian_lje 0x06a9               /* deprecated */
+#define XK_Cyrillic_nje 0x06aa              /* U+045A CYRILLIC SMALL LETTER NJE */
+#define XK_Serbian_nje 0x06aa               /* deprecated */
+#define XK_Serbian_tshe 0x06ab              /* U+045B CYRILLIC SMALL LETTER TSHE */
+#define XK_Macedonia_kje 0x06ac             /* U+045C CYRILLIC SMALL LETTER KJE */
+#define XK_Ukrainian_ghe_with_upturn 0x06ad /* U+0491 CYRILLIC SMALL LETTER GHE WITH UPTURN */
+#define XK_Byelorussian_shortu 0x06ae       /* U+045E CYRILLIC SMALL LETTER SHORT U */
+#define XK_Cyrillic_dzhe 0x06af             /* U+045F CYRILLIC SMALL LETTER DZHE */
+#define XK_Serbian_dze 0x06af               /* deprecated */
+#define XK_numerosign 0x06b0                /* U+2116 NUMERO SIGN */
+#define XK_Serbian_DJE 0x06b1               /* U+0402 CYRILLIC CAPITAL LETTER DJE */
+#define XK_Macedonia_GJE 0x06b2             /* U+0403 CYRILLIC CAPITAL LETTER GJE */
+#define XK_Cyrillic_IO 0x06b3               /* U+0401 CYRILLIC CAPITAL LETTER IO */
+#define XK_Ukrainian_IE 0x06b4              /* U+0404 CYRILLIC CAPITAL LETTER UKRAINIAN IE */
+#define XK_Ukranian_JE 0x06b4               /* deprecated */
+#define XK_Macedonia_DSE 0x06b5             /* U+0405 CYRILLIC CAPITAL LETTER DZE */
+#define XK_Ukrainian_I 0x06b6               /* U+0406 CYRILLIC CAPITAL LETTER BYELORUSSIAN-UKRAINIAN I */
+#define XK_Ukranian_I 0x06b6                /* deprecated */
+#define XK_Ukrainian_YI 0x06b7              /* U+0407 CYRILLIC CAPITAL LETTER YI */
+#define XK_Ukranian_YI 0x06b7               /* deprecated */
+#define XK_Cyrillic_JE 0x06b8               /* U+0408 CYRILLIC CAPITAL LETTER JE */
+#define XK_Serbian_JE 0x06b8                /* deprecated */
+#define XK_Cyrillic_LJE 0x06b9              /* U+0409 CYRILLIC CAPITAL LETTER LJE */
+#define XK_Serbian_LJE 0x06b9               /* deprecated */
+#define XK_Cyrillic_NJE 0x06ba              /* U+040A CYRILLIC CAPITAL LETTER NJE */
+#define XK_Serbian_NJE 0x06ba               /* deprecated */
+#define XK_Serbian_TSHE 0x06bb              /* U+040B CYRILLIC CAPITAL LETTER TSHE */
+#define XK_Macedonia_KJE 0x06bc             /* U+040C CYRILLIC CAPITAL LETTER KJE */
+#define XK_Ukrainian_GHE_WITH_UPTURN 0x06bd /* U+0490 CYRILLIC CAPITAL LETTER GHE WITH UPTURN */
+#define XK_Byelorussian_SHORTU 0x06be       /* U+040E CYRILLIC CAPITAL LETTER SHORT U */
+#define XK_Cyrillic_DZHE 0x06bf             /* U+040F CYRILLIC CAPITAL LETTER DZHE */
+#define XK_Serbian_DZE 0x06bf               /* deprecated */
+#define XK_Cyrillic_yu 0x06c0               /* U+044E CYRILLIC SMALL LETTER YU */
+#define XK_Cyrillic_a 0x06c1                /* U+0430 CYRILLIC SMALL LETTER A */
+#define XK_Cyrillic_be 0x06c2               /* U+0431 CYRILLIC SMALL LETTER BE */
+#define XK_Cyrillic_tse 0x06c3              /* U+0446 CYRILLIC SMALL LETTER TSE */
+#define XK_Cyrillic_de 0x06c4               /* U+0434 CYRILLIC SMALL LETTER DE */
+#define XK_Cyrillic_ie 0x06c5               /* U+0435 CYRILLIC SMALL LETTER IE */
+#define XK_Cyrillic_ef 0x06c6               /* U+0444 CYRILLIC SMALL LETTER EF */
+#define XK_Cyrillic_ghe 0x06c7              /* U+0433 CYRILLIC SMALL LETTER GHE */
+#define XK_Cyrillic_ha 0x06c8               /* U+0445 CYRILLIC SMALL LETTER HA */
+#define XK_Cyrillic_i 0x06c9                /* U+0438 CYRILLIC SMALL LETTER I */
+#define XK_Cyrillic_shorti 0x06ca           /* U+0439 CYRILLIC SMALL LETTER SHORT I */
+#define XK_Cyrillic_ka 0x06cb               /* U+043A CYRILLIC SMALL LETTER KA */
+#define XK_Cyrillic_el 0x06cc               /* U+043B CYRILLIC SMALL LETTER EL */
+#define XK_Cyrillic_em 0x06cd               /* U+043C CYRILLIC SMALL LETTER EM */
+#define XK_Cyrillic_en 0x06ce               /* U+043D CYRILLIC SMALL LETTER EN */
+#define XK_Cyrillic_o 0x06cf                /* U+043E CYRILLIC SMALL LETTER O */
+#define XK_Cyrillic_pe 0x06d0               /* U+043F CYRILLIC SMALL LETTER PE */
+#define XK_Cyrillic_ya 0x06d1               /* U+044F CYRILLIC SMALL LETTER YA */
+#define XK_Cyrillic_er 0x06d2               /* U+0440 CYRILLIC SMALL LETTER ER */
+#define XK_Cyrillic_es 0x06d3               /* U+0441 CYRILLIC SMALL LETTER ES */
+#define XK_Cyrillic_te 0x06d4               /* U+0442 CYRILLIC SMALL LETTER TE */
+#define XK_Cyrillic_u 0x06d5                /* U+0443 CYRILLIC SMALL LETTER U */
+#define XK_Cyrillic_zhe 0x06d6              /* U+0436 CYRILLIC SMALL LETTER ZHE */
+#define XK_Cyrillic_ve 0x06d7               /* U+0432 CYRILLIC SMALL LETTER VE */
+#define XK_Cyrillic_softsign 0x06d8         /* U+044C CYRILLIC SMALL LETTER SOFT SIGN */
+#define XK_Cyrillic_yeru 0x06d9             /* U+044B CYRILLIC SMALL LETTER YERU */
+#define XK_Cyrillic_ze 0x06da               /* U+0437 CYRILLIC SMALL LETTER ZE */
+#define XK_Cyrillic_sha 0x06db              /* U+0448 CYRILLIC SMALL LETTER SHA */
+#define XK_Cyrillic_e 0x06dc                /* U+044D CYRILLIC SMALL LETTER E */
+#define XK_Cyrillic_shcha 0x06dd            /* U+0449 CYRILLIC SMALL LETTER SHCHA */
+#define XK_Cyrillic_che 0x06de              /* U+0447 CYRILLIC SMALL LETTER CHE */
+#define XK_Cyrillic_hardsign 0x06df         /* U+044A CYRILLIC SMALL LETTER HARD SIGN */
+#define XK_Cyrillic_YU 0x06e0               /* U+042E CYRILLIC CAPITAL LETTER YU */
+#define XK_Cyrillic_A 0x06e1                /* U+0410 CYRILLIC CAPITAL LETTER A */
+#define XK_Cyrillic_BE 0x06e2               /* U+0411 CYRILLIC CAPITAL LETTER BE */
+#define XK_Cyrillic_TSE 0x06e3              /* U+0426 CYRILLIC CAPITAL LETTER TSE */
+#define XK_Cyrillic_DE 0x06e4               /* U+0414 CYRILLIC CAPITAL LETTER DE */
+#define XK_Cyrillic_IE 0x06e5               /* U+0415 CYRILLIC CAPITAL LETTER IE */
+#define XK_Cyrillic_EF 0x06e6               /* U+0424 CYRILLIC CAPITAL LETTER EF */
+#define XK_Cyrillic_GHE 0x06e7              /* U+0413 CYRILLIC CAPITAL LETTER GHE */
+#define XK_Cyrillic_HA 0x06e8               /* U+0425 CYRILLIC CAPITAL LETTER HA */
+#define XK_Cyrillic_I 0x06e9                /* U+0418 CYRILLIC CAPITAL LETTER I */
+#define XK_Cyrillic_SHORTI 0x06ea           /* U+0419 CYRILLIC CAPITAL LETTER SHORT I */
+#define XK_Cyrillic_KA 0x06eb               /* U+041A CYRILLIC CAPITAL LETTER KA */
+#define XK_Cyrillic_EL 0x06ec               /* U+041B CYRILLIC CAPITAL LETTER EL */
+#define XK_Cyrillic_EM 0x06ed               /* U+041C CYRILLIC CAPITAL LETTER EM */
+#define XK_Cyrillic_EN 0x06ee               /* U+041D CYRILLIC CAPITAL LETTER EN */
+#define XK_Cyrillic_O 0x06ef                /* U+041E CYRILLIC CAPITAL LETTER O */
+#define XK_Cyrillic_PE 0x06f0               /* U+041F CYRILLIC CAPITAL LETTER PE */
+#define XK_Cyrillic_YA 0x06f1               /* U+042F CYRILLIC CAPITAL LETTER YA */
+#define XK_Cyrillic_ER 0x06f2               /* U+0420 CYRILLIC CAPITAL LETTER ER */
+#define XK_Cyrillic_ES 0x06f3               /* U+0421 CYRILLIC CAPITAL LETTER ES */
+#define XK_Cyrillic_TE 0x06f4               /* U+0422 CYRILLIC CAPITAL LETTER TE */
+#define XK_Cyrillic_U 0x06f5                /* U+0423 CYRILLIC CAPITAL LETTER U */
+#define XK_Cyrillic_ZHE 0x06f6              /* U+0416 CYRILLIC CAPITAL LETTER ZHE */
+#define XK_Cyrillic_VE 0x06f7               /* U+0412 CYRILLIC CAPITAL LETTER VE */
+#define XK_Cyrillic_SOFTSIGN 0x06f8         /* U+042C CYRILLIC CAPITAL LETTER SOFT SIGN */
+#define XK_Cyrillic_YERU 0x06f9             /* U+042B CYRILLIC CAPITAL LETTER YERU */
+#define XK_Cyrillic_ZE 0x06fa               /* U+0417 CYRILLIC CAPITAL LETTER ZE */
+#define XK_Cyrillic_SHA 0x06fb              /* U+0428 CYRILLIC CAPITAL LETTER SHA */
+#define XK_Cyrillic_E 0x06fc                /* U+042D CYRILLIC CAPITAL LETTER E */
+#define XK_Cyrillic_SHCHA 0x06fd            /* U+0429 CYRILLIC CAPITAL LETTER SHCHA */
+#define XK_Cyrillic_CHE 0x06fe              /* U+0427 CYRILLIC CAPITAL LETTER CHE */
+#define XK_Cyrillic_HARDSIGN 0x06ff         /* U+042A CYRILLIC CAPITAL LETTER HARD SIGN */
+#endif                                      /* XK_CYRILLIC */
+
+/*
+ * Greek
+ * (based on an early draft of, and not quite identical to, ISO/IEC 8859-7)
+ * Byte 3 = 7
+ */
+
+#ifdef XK_GREEK
+#define XK_Greek_ALPHAaccent 0x07a1           /* U+0386 GREEK CAPITAL LETTER ALPHA WITH TONOS */
+#define XK_Greek_EPSILONaccent 0x07a2         /* U+0388 GREEK CAPITAL LETTER EPSILON WITH TONOS */
+#define XK_Greek_ETAaccent 0x07a3             /* U+0389 GREEK CAPITAL LETTER ETA WITH TONOS */
+#define XK_Greek_IOTAaccent 0x07a4            /* U+038A GREEK CAPITAL LETTER IOTA WITH TONOS */
+#define XK_Greek_IOTAdieresis 0x07a5          /* U+03AA GREEK CAPITAL LETTER IOTA WITH DIALYTIKA */
+#define XK_Greek_IOTAdiaeresis 0x07a5         /* old typo */
+#define XK_Greek_OMICRONaccent 0x07a7         /* U+038C GREEK CAPITAL LETTER OMICRON WITH TONOS */
+#define XK_Greek_UPSILONaccent 0x07a8         /* U+038E GREEK CAPITAL LETTER UPSILON WITH TONOS */
+#define XK_Greek_UPSILONdieresis 0x07a9       /* U+03AB GREEK CAPITAL LETTER UPSILON WITH DIALYTIKA */
+#define XK_Greek_OMEGAaccent 0x07ab           /* U+038F GREEK CAPITAL LETTER OMEGA WITH TONOS */
+#define XK_Greek_accentdieresis 0x07ae        /* U+0385 GREEK DIALYTIKA TONOS */
+#define XK_Greek_horizbar 0x07af              /* U+2015 HORIZONTAL BAR */
+#define XK_Greek_alphaaccent 0x07b1           /* U+03AC GREEK SMALL LETTER ALPHA WITH TONOS */
+#define XK_Greek_epsilonaccent 0x07b2         /* U+03AD GREEK SMALL LETTER EPSILON WITH TONOS */
+#define XK_Greek_etaaccent 0x07b3             /* U+03AE GREEK SMALL LETTER ETA WITH TONOS */
+#define XK_Greek_iotaaccent 0x07b4            /* U+03AF GREEK SMALL LETTER IOTA WITH TONOS */
+#define XK_Greek_iotadieresis 0x07b5          /* U+03CA GREEK SMALL LETTER IOTA WITH DIALYTIKA */
+#define XK_Greek_iotaaccentdieresis 0x07b6    /* U+0390 GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS */
+#define XK_Greek_omicronaccent 0x07b7         /* U+03CC GREEK SMALL LETTER OMICRON WITH TONOS */
+#define XK_Greek_upsilonaccent 0x07b8         /* U+03CD GREEK SMALL LETTER UPSILON WITH TONOS */
+#define XK_Greek_upsilondieresis 0x07b9       /* U+03CB GREEK SMALL LETTER UPSILON WITH DIALYTIKA */
+#define XK_Greek_upsilonaccentdieresis 0x07ba /* U+03B0 GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS */
+#define XK_Greek_omegaaccent 0x07bb           /* U+03CE GREEK SMALL LETTER OMEGA WITH TONOS */
+#define XK_Greek_ALPHA 0x07c1                 /* U+0391 GREEK CAPITAL LETTER ALPHA */
+#define XK_Greek_BETA 0x07c2                  /* U+0392 GREEK CAPITAL LETTER BETA */
+#define XK_Greek_GAMMA 0x07c3                 /* U+0393 GREEK CAPITAL LETTER GAMMA */
+#define XK_Greek_DELTA 0x07c4                 /* U+0394 GREEK CAPITAL LETTER DELTA */
+#define XK_Greek_EPSILON 0x07c5               /* U+0395 GREEK CAPITAL LETTER EPSILON */
+#define XK_Greek_ZETA 0x07c6                  /* U+0396 GREEK CAPITAL LETTER ZETA */
+#define XK_Greek_ETA 0x07c7                   /* U+0397 GREEK CAPITAL LETTER ETA */
+#define XK_Greek_THETA 0x07c8                 /* U+0398 GREEK CAPITAL LETTER THETA */
+#define XK_Greek_IOTA 0x07c9                  /* U+0399 GREEK CAPITAL LETTER IOTA */
+#define XK_Greek_KAPPA 0x07ca                 /* U+039A GREEK CAPITAL LETTER KAPPA */
+#define XK_Greek_LAMDA 0x07cb                 /* U+039B GREEK CAPITAL LETTER LAMDA */
+#define XK_Greek_LAMBDA 0x07cb                /* U+039B GREEK CAPITAL LETTER LAMDA */
+#define XK_Greek_MU 0x07cc                    /* U+039C GREEK CAPITAL LETTER MU */
+#define XK_Greek_NU 0x07cd                    /* U+039D GREEK CAPITAL LETTER NU */
+#define XK_Greek_XI 0x07ce                    /* U+039E GREEK CAPITAL LETTER XI */
+#define XK_Greek_OMICRON 0x07cf               /* U+039F GREEK CAPITAL LETTER OMICRON */
+#define XK_Greek_PI 0x07d0                    /* U+03A0 GREEK CAPITAL LETTER PI */
+#define XK_Greek_RHO 0x07d1                   /* U+03A1 GREEK CAPITAL LETTER RHO */
+#define XK_Greek_SIGMA 0x07d2                 /* U+03A3 GREEK CAPITAL LETTER SIGMA */
+#define XK_Greek_TAU 0x07d4                   /* U+03A4 GREEK CAPITAL LETTER TAU */
+#define XK_Greek_UPSILON 0x07d5               /* U+03A5 GREEK CAPITAL LETTER UPSILON */
+#define XK_Greek_PHI 0x07d6                   /* U+03A6 GREEK CAPITAL LETTER PHI */
+#define XK_Greek_CHI 0x07d7                   /* U+03A7 GREEK CAPITAL LETTER CHI */
+#define XK_Greek_PSI 0x07d8                   /* U+03A8 GREEK CAPITAL LETTER PSI */
+#define XK_Greek_OMEGA 0x07d9                 /* U+03A9 GREEK CAPITAL LETTER OMEGA */
+#define XK_Greek_alpha 0x07e1                 /* U+03B1 GREEK SMALL LETTER ALPHA */
+#define XK_Greek_beta 0x07e2                  /* U+03B2 GREEK SMALL LETTER BETA */
+#define XK_Greek_gamma 0x07e3                 /* U+03B3 GREEK SMALL LETTER GAMMA */
+#define XK_Greek_delta 0x07e4                 /* U+03B4 GREEK SMALL LETTER DELTA */
+#define XK_Greek_epsilon 0x07e5               /* U+03B5 GREEK SMALL LETTER EPSILON */
+#define XK_Greek_zeta 0x07e6                  /* U+03B6 GREEK SMALL LETTER ZETA */
+#define XK_Greek_eta 0x07e7                   /* U+03B7 GREEK SMALL LETTER ETA */
+#define XK_Greek_theta 0x07e8                 /* U+03B8 GREEK SMALL LETTER THETA */
+#define XK_Greek_iota 0x07e9                  /* U+03B9 GREEK SMALL LETTER IOTA */
+#define XK_Greek_kappa 0x07ea                 /* U+03BA GREEK SMALL LETTER KAPPA */
+#define XK_Greek_lamda 0x07eb                 /* U+03BB GREEK SMALL LETTER LAMDA */
+#define XK_Greek_lambda 0x07eb                /* U+03BB GREEK SMALL LETTER LAMDA */
+#define XK_Greek_mu 0x07ec                    /* U+03BC GREEK SMALL LETTER MU */
+#define XK_Greek_nu 0x07ed                    /* U+03BD GREEK SMALL LETTER NU */
+#define XK_Greek_xi 0x07ee                    /* U+03BE GREEK SMALL LETTER XI */
+#define XK_Greek_omicron 0x07ef               /* U+03BF GREEK SMALL LETTER OMICRON */
+#define XK_Greek_pi 0x07f0                    /* U+03C0 GREEK SMALL LETTER PI */
+#define XK_Greek_rho 0x07f1                   /* U+03C1 GREEK SMALL LETTER RHO */
+#define XK_Greek_sigma 0x07f2                 /* U+03C3 GREEK SMALL LETTER SIGMA */
+#define XK_Greek_finalsmallsigma 0x07f3       /* U+03C2 GREEK SMALL LETTER FINAL SIGMA */
+#define XK_Greek_tau 0x07f4                   /* U+03C4 GREEK SMALL LETTER TAU */
+#define XK_Greek_upsilon 0x07f5               /* U+03C5 GREEK SMALL LETTER UPSILON */
+#define XK_Greek_phi 0x07f6                   /* U+03C6 GREEK SMALL LETTER PHI */
+#define XK_Greek_chi 0x07f7                   /* U+03C7 GREEK SMALL LETTER CHI */
+#define XK_Greek_psi 0x07f8                   /* U+03C8 GREEK SMALL LETTER PSI */
+#define XK_Greek_omega 0x07f9                 /* U+03C9 GREEK SMALL LETTER OMEGA */
+#define XK_Greek_switch 0xff7e                /* Alias for mode_switch */
+#endif                                        /* XK_GREEK */
+
+/*
+ * Technical
+ * (from the DEC VT330/VT420 Technical Character Set, http://vt100.net/charsets/technical.html)
+ * Byte 3 = 8
+ */
+
+#ifdef XK_TECHNICAL
+#define XK_leftradical 0x08a1           /* U+23B7 RADICAL SYMBOL BOTTOM */
+#define XK_topleftradical 0x08a2        /*(U+250C BOX DRAWINGS LIGHT DOWN AND RIGHT)*/
+#define XK_horizconnector 0x08a3        /*(U+2500 BOX DRAWINGS LIGHT HORIZONTAL)*/
+#define XK_topintegral 0x08a4           /* U+2320 TOP HALF INTEGRAL */
+#define XK_botintegral 0x08a5           /* U+2321 BOTTOM HALF INTEGRAL */
+#define XK_vertconnector 0x08a6         /*(U+2502 BOX DRAWINGS LIGHT VERTICAL)*/
+#define XK_topleftsqbracket 0x08a7      /* U+23A1 LEFT SQUARE BRACKET UPPER CORNER */
+#define XK_botleftsqbracket 0x08a8      /* U+23A3 LEFT SQUARE BRACKET LOWER CORNER */
+#define XK_toprightsqbracket 0x08a9     /* U+23A4 RIGHT SQUARE BRACKET UPPER CORNER */
+#define XK_botrightsqbracket 0x08aa     /* U+23A6 RIGHT SQUARE BRACKET LOWER CORNER */
+#define XK_topleftparens 0x08ab         /* U+239B LEFT PARENTHESIS UPPER HOOK */
+#define XK_botleftparens 0x08ac         /* U+239D LEFT PARENTHESIS LOWER HOOK */
+#define XK_toprightparens 0x08ad        /* U+239E RIGHT PARENTHESIS UPPER HOOK */
+#define XK_botrightparens 0x08ae        /* U+23A0 RIGHT PARENTHESIS LOWER HOOK */
+#define XK_leftmiddlecurlybrace 0x08af  /* U+23A8 LEFT CURLY BRACKET MIDDLE PIECE */
+#define XK_rightmiddlecurlybrace 0x08b0 /* U+23AC RIGHT CURLY BRACKET MIDDLE PIECE */
+#define XK_topleftsummation 0x08b1
+#define XK_botleftsummation 0x08b2
+#define XK_topvertsummationconnector 0x08b3
+#define XK_botvertsummationconnector 0x08b4
+#define XK_toprightsummation 0x08b5
+#define XK_botrightsummation 0x08b6
+#define XK_rightmiddlesummation 0x08b7
+#define XK_lessthanequal 0x08bc     /* U+2264 LESS-THAN OR EQUAL TO */
+#define XK_notequal 0x08bd          /* U+2260 NOT EQUAL TO */
+#define XK_greaterthanequal 0x08be  /* U+2265 GREATER-THAN OR EQUAL TO */
+#define XK_integral 0x08bf          /* U+222B INTEGRAL */
+#define XK_therefore 0x08c0         /* U+2234 THEREFORE */
+#define XK_variation 0x08c1         /* U+221D PROPORTIONAL TO */
+#define XK_infinity 0x08c2          /* U+221E INFINITY */
+#define XK_nabla 0x08c5             /* U+2207 NABLA */
+#define XK_approximate 0x08c8       /* U+223C TILDE OPERATOR */
+#define XK_similarequal 0x08c9      /* U+2243 ASYMPTOTICALLY EQUAL TO */
+#define XK_ifonlyif 0x08cd          /* U+21D4 LEFT RIGHT DOUBLE ARROW */
+#define XK_implies 0x08ce           /* U+21D2 RIGHTWARDS DOUBLE ARROW */
+#define XK_identical 0x08cf         /* U+2261 IDENTICAL TO */
+#define XK_radical 0x08d6           /* U+221A SQUARE ROOT */
+#define XK_includedin 0x08da        /* U+2282 SUBSET OF */
+#define XK_includes 0x08db          /* U+2283 SUPERSET OF */
+#define XK_intersection 0x08dc      /* U+2229 INTERSECTION */
+#define XK_union 0x08dd             /* U+222A UNION */
+#define XK_logicaland 0x08de        /* U+2227 LOGICAL AND */
+#define XK_logicalor 0x08df         /* U+2228 LOGICAL OR */
+#define XK_partialderivative 0x08ef /* U+2202 PARTIAL DIFFERENTIAL */
+#define XK_function 0x08f6          /* U+0192 LATIN SMALL LETTER F WITH HOOK */
+#define XK_leftarrow 0x08fb         /* U+2190 LEFTWARDS ARROW */
+#define XK_uparrow 0x08fc           /* U+2191 UPWARDS ARROW */
+#define XK_rightarrow 0x08fd        /* U+2192 RIGHTWARDS ARROW */
+#define XK_downarrow 0x08fe         /* U+2193 DOWNWARDS ARROW */
+#endif                              /* XK_TECHNICAL */
+
+/*
+ * Special
+ * (from the DEC VT100 Special Graphics Character Set)
+ * Byte 3 = 9
+ */
+
+#ifdef XK_SPECIAL
+#define XK_blank 0x09df
+#define XK_soliddiamond 0x09e0   /* U+25C6 BLACK DIAMOND */
+#define XK_checkerboard 0x09e1   /* U+2592 MEDIUM SHADE */
+#define XK_ht 0x09e2             /* U+2409 SYMBOL FOR HORIZONTAL TABULATION */
+#define XK_ff 0x09e3             /* U+240C SYMBOL FOR FORM FEED */
+#define XK_cr 0x09e4             /* U+240D SYMBOL FOR CARRIAGE RETURN */
+#define XK_lf 0x09e5             /* U+240A SYMBOL FOR LINE FEED */
+#define XK_nl 0x09e8             /* U+2424 SYMBOL FOR NEWLINE */
+#define XK_vt 0x09e9             /* U+240B SYMBOL FOR VERTICAL TABULATION */
+#define XK_lowrightcorner 0x09ea /* U+2518 BOX DRAWINGS LIGHT UP AND LEFT */
+#define XK_uprightcorner 0x09eb  /* U+2510 BOX DRAWINGS LIGHT DOWN AND LEFT */
+#define XK_upleftcorner 0x09ec   /* U+250C BOX DRAWINGS LIGHT DOWN AND RIGHT */
+#define XK_lowleftcorner 0x09ed  /* U+2514 BOX DRAWINGS LIGHT UP AND RIGHT */
+#define XK_crossinglines 0x09ee  /* U+253C BOX DRAWINGS LIGHT VERTICAL AND HORIZONTAL */
+#define XK_horizlinescan1 0x09ef /* U+23BA HORIZONTAL SCAN LINE-1 */
+#define XK_horizlinescan3 0x09f0 /* U+23BB HORIZONTAL SCAN LINE-3 */
+#define XK_horizlinescan5 0x09f1 /* U+2500 BOX DRAWINGS LIGHT HORIZONTAL */
+#define XK_horizlinescan7 0x09f2 /* U+23BC HORIZONTAL SCAN LINE-7 */
+#define XK_horizlinescan9 0x09f3 /* U+23BD HORIZONTAL SCAN LINE-9 */
+#define XK_leftt 0x09f4          /* U+251C BOX DRAWINGS LIGHT VERTICAL AND RIGHT */
+#define XK_rightt 0x09f5         /* U+2524 BOX DRAWINGS LIGHT VERTICAL AND LEFT */
+#define XK_bott 0x09f6           /* U+2534 BOX DRAWINGS LIGHT UP AND HORIZONTAL */
+#define XK_topt 0x09f7           /* U+252C BOX DRAWINGS LIGHT DOWN AND HORIZONTAL */
+#define XK_vertbar 0x09f8        /* U+2502 BOX DRAWINGS LIGHT VERTICAL */
+#endif                           /* XK_SPECIAL */
+
+/*
+ * Publishing
+ * (these are probably from a long forgotten DEC Publishing
+ * font that once shipped with DECwrite)
+ * Byte 3 = 0x0a
+ */
+
+#ifdef XK_PUBLISHING
+#define XK_emspace 0x0aa1           /* U+2003 EM SPACE */
+#define XK_enspace 0x0aa2           /* U+2002 EN SPACE */
+#define XK_em3space 0x0aa3          /* U+2004 THREE-PER-EM SPACE */
+#define XK_em4space 0x0aa4          /* U+2005 FOUR-PER-EM SPACE */
+#define XK_digitspace 0x0aa5        /* U+2007 FIGURE SPACE */
+#define XK_punctspace 0x0aa6        /* U+2008 PUNCTUATION SPACE */
+#define XK_thinspace 0x0aa7         /* U+2009 THIN SPACE */
+#define XK_hairspace 0x0aa8         /* U+200A HAIR SPACE */
+#define XK_emdash 0x0aa9            /* U+2014 EM DASH */
+#define XK_endash 0x0aaa            /* U+2013 EN DASH */
+#define XK_signifblank 0x0aac       /*(U+2423 OPEN BOX)*/
+#define XK_ellipsis 0x0aae          /* U+2026 HORIZONTAL ELLIPSIS */
+#define XK_doubbaselinedot 0x0aaf   /* U+2025 TWO DOT LEADER */
+#define XK_onethird 0x0ab0          /* U+2153 VULGAR FRACTION ONE THIRD */
+#define XK_twothirds 0x0ab1         /* U+2154 VULGAR FRACTION TWO THIRDS */
+#define XK_onefifth 0x0ab2          /* U+2155 VULGAR FRACTION ONE FIFTH */
+#define XK_twofifths 0x0ab3         /* U+2156 VULGAR FRACTION TWO FIFTHS */
+#define XK_threefifths 0x0ab4       /* U+2157 VULGAR FRACTION THREE FIFTHS */
+#define XK_fourfifths 0x0ab5        /* U+2158 VULGAR FRACTION FOUR FIFTHS */
+#define XK_onesixth 0x0ab6          /* U+2159 VULGAR FRACTION ONE SIXTH */
+#define XK_fivesixths 0x0ab7        /* U+215A VULGAR FRACTION FIVE SIXTHS */
+#define XK_careof 0x0ab8            /* U+2105 CARE OF */
+#define XK_figdash 0x0abb           /* U+2012 FIGURE DASH */
+#define XK_leftanglebracket 0x0abc  /*(U+27E8 MATHEMATICAL LEFT ANGLE BRACKET)*/
+#define XK_decimalpoint 0x0abd      /*(U+002E FULL STOP)*/
+#define XK_rightanglebracket 0x0abe /*(U+27E9 MATHEMATICAL RIGHT ANGLE BRACKET)*/
+#define XK_marker 0x0abf
+#define XK_oneeighth 0x0ac3     /* U+215B VULGAR FRACTION ONE EIGHTH */
+#define XK_threeeighths 0x0ac4  /* U+215C VULGAR FRACTION THREE EIGHTHS */
+#define XK_fiveeighths 0x0ac5   /* U+215D VULGAR FRACTION FIVE EIGHTHS */
+#define XK_seveneighths 0x0ac6  /* U+215E VULGAR FRACTION SEVEN EIGHTHS */
+#define XK_trademark 0x0ac9     /* U+2122 TRADE MARK SIGN */
+#define XK_signaturemark 0x0aca /*(U+2613 SALTIRE)*/
+#define XK_trademarkincircle 0x0acb
+#define XK_leftopentriangle 0x0acc     /*(U+25C1 WHITE LEFT-POINTING TRIANGLE)*/
+#define XK_rightopentriangle 0x0acd    /*(U+25B7 WHITE RIGHT-POINTING TRIANGLE)*/
+#define XK_emopencircle 0x0ace         /*(U+25CB WHITE CIRCLE)*/
+#define XK_emopenrectangle 0x0acf      /*(U+25AF WHITE VERTICAL RECTANGLE)*/
+#define XK_leftsinglequotemark 0x0ad0  /* U+2018 LEFT SINGLE QUOTATION MARK */
+#define XK_rightsinglequotemark 0x0ad1 /* U+2019 RIGHT SINGLE QUOTATION MARK */
+#define XK_leftdoublequotemark 0x0ad2  /* U+201C LEFT DOUBLE QUOTATION MARK */
+#define XK_rightdoublequotemark 0x0ad3 /* U+201D RIGHT DOUBLE QUOTATION MARK */
+#define XK_prescription 0x0ad4         /* U+211E PRESCRIPTION TAKE */
+#define XK_permille 0x0ad5             /* U+2030 PER MILLE SIGN */
+#define XK_minutes 0x0ad6              /* U+2032 PRIME */
+#define XK_seconds 0x0ad7              /* U+2033 DOUBLE PRIME */
+#define XK_latincross 0x0ad9           /* U+271D LATIN CROSS */
+#define XK_hexagram 0x0ada
+#define XK_filledrectbullet 0x0adb     /*(U+25AC BLACK RECTANGLE)*/
+#define XK_filledlefttribullet 0x0adc  /*(U+25C0 BLACK LEFT-POINTING TRIANGLE)*/
+#define XK_filledrighttribullet 0x0add /*(U+25B6 BLACK RIGHT-POINTING TRIANGLE)*/
+#define XK_emfilledcircle 0x0ade       /*(U+25CF BLACK CIRCLE)*/
+#define XK_emfilledrect 0x0adf         /*(U+25AE BLACK VERTICAL RECTANGLE)*/
+#define XK_enopencircbullet 0x0ae0     /*(U+25E6 WHITE BULLET)*/
+#define XK_enopensquarebullet 0x0ae1   /*(U+25AB WHITE SMALL SQUARE)*/
+#define XK_openrectbullet 0x0ae2       /*(U+25AD WHITE RECTANGLE)*/
+#define XK_opentribulletup 0x0ae3      /*(U+25B3 WHITE UP-POINTING TRIANGLE)*/
+#define XK_opentribulletdown 0x0ae4    /*(U+25BD WHITE DOWN-POINTING TRIANGLE)*/
+#define XK_openstar 0x0ae5             /*(U+2606 WHITE STAR)*/
+#define XK_enfilledcircbullet 0x0ae6   /*(U+2022 BULLET)*/
+#define XK_enfilledsqbullet 0x0ae7     /*(U+25AA BLACK SMALL SQUARE)*/
+#define XK_filledtribulletup 0x0ae8    /*(U+25B2 BLACK UP-POINTING TRIANGLE)*/
+#define XK_filledtribulletdown 0x0ae9  /*(U+25BC BLACK DOWN-POINTING TRIANGLE)*/
+#define XK_leftpointer 0x0aea          /*(U+261C WHITE LEFT POINTING INDEX)*/
+#define XK_rightpointer 0x0aeb         /*(U+261E WHITE RIGHT POINTING INDEX)*/
+#define XK_club 0x0aec                 /* U+2663 BLACK CLUB SUIT */
+#define XK_diamond 0x0aed              /* U+2666 BLACK DIAMOND SUIT */
+#define XK_heart 0x0aee                /* U+2665 BLACK HEART SUIT */
+#define XK_maltesecross 0x0af0         /* U+2720 MALTESE CROSS */
+#define XK_dagger 0x0af1               /* U+2020 DAGGER */
+#define XK_doubledagger 0x0af2         /* U+2021 DOUBLE DAGGER */
+#define XK_checkmark 0x0af3            /* U+2713 CHECK MARK */
+#define XK_ballotcross 0x0af4          /* U+2717 BALLOT X */
+#define XK_musicalsharp 0x0af5         /* U+266F MUSIC SHARP SIGN */
+#define XK_musicalflat 0x0af6          /* U+266D MUSIC FLAT SIGN */
+#define XK_malesymbol 0x0af7           /* U+2642 MALE SIGN */
+#define XK_femalesymbol 0x0af8         /* U+2640 FEMALE SIGN */
+#define XK_telephone 0x0af9            /* U+260E BLACK TELEPHONE */
+#define XK_telephonerecorder 0x0afa    /* U+2315 TELEPHONE RECORDER */
+#define XK_phonographcopyright 0x0afb  /* U+2117 SOUND RECORDING COPYRIGHT */
+#define XK_caret 0x0afc                /* U+2038 CARET */
+#define XK_singlelowquotemark 0x0afd   /* U+201A SINGLE LOW-9 QUOTATION MARK */
+#define XK_doublelowquotemark 0x0afe   /* U+201E DOUBLE LOW-9 QUOTATION MARK */
+#define XK_cursor 0x0aff
+#endif /* XK_PUBLISHING */
+
+/*
+ * APL
+ * Byte 3 = 0x0b
+ */
+
+#ifdef XK_APL
+#define XK_leftcaret 0x0ba3  /*(U+003C LESS-THAN SIGN)*/
+#define XK_rightcaret 0x0ba6 /*(U+003E GREATER-THAN SIGN)*/
+#define XK_downcaret 0x0ba8  /*(U+2228 LOGICAL OR)*/
+#define XK_upcaret 0x0ba9    /*(U+2227 LOGICAL AND)*/
+#define XK_overbar 0x0bc0    /*(U+00AF MACRON)*/
+#define XK_downtack 0x0bc2   /* U+22A4 DOWN TACK */
+#define XK_upshoe 0x0bc3     /*(U+2229 INTERSECTION)*/
+#define XK_downstile 0x0bc4  /* U+230A LEFT FLOOR */
+#define XK_underbar 0x0bc6   /*(U+005F LOW LINE)*/
+#define XK_jot 0x0bca        /* U+2218 RING OPERATOR */
+#define XK_quad 0x0bcc       /* U+2395 APL FUNCTIONAL SYMBOL QUAD */
+#define XK_uptack 0x0bce     /* U+22A5 UP TACK */
+#define XK_circle 0x0bcf     /* U+25CB WHITE CIRCLE */
+#define XK_upstile 0x0bd3    /* U+2308 LEFT CEILING */
+#define XK_downshoe 0x0bd6   /*(U+222A UNION)*/
+#define XK_rightshoe 0x0bd8  /*(U+2283 SUPERSET OF)*/
+#define XK_leftshoe 0x0bda   /*(U+2282 SUBSET OF)*/
+#define XK_lefttack 0x0bdc   /* U+22A3 LEFT TACK */
+#define XK_righttack 0x0bfc  /* U+22A2 RIGHT TACK */
+#endif                       /* XK_APL */
+
+/*
+ * Hebrew
+ * Byte 3 = 0x0c
+ */
+
+#ifdef XK_HEBREW
+#define XK_hebrew_doublelowline 0x0cdf /* U+2017 DOUBLE LOW LINE */
+#define XK_hebrew_aleph 0x0ce0         /* U+05D0 HEBREW LETTER ALEF */
+#define XK_hebrew_bet 0x0ce1           /* U+05D1 HEBREW LETTER BET */
+#define XK_hebrew_beth 0x0ce1          /* deprecated */
+#define XK_hebrew_gimel 0x0ce2         /* U+05D2 HEBREW LETTER GIMEL */
+#define XK_hebrew_gimmel 0x0ce2        /* deprecated */
+#define XK_hebrew_dalet 0x0ce3         /* U+05D3 HEBREW LETTER DALET */
+#define XK_hebrew_daleth 0x0ce3        /* deprecated */
+#define XK_hebrew_he 0x0ce4            /* U+05D4 HEBREW LETTER HE */
+#define XK_hebrew_waw 0x0ce5           /* U+05D5 HEBREW LETTER VAV */
+#define XK_hebrew_zain 0x0ce6          /* U+05D6 HEBREW LETTER ZAYIN */
+#define XK_hebrew_zayin 0x0ce6         /* deprecated */
+#define XK_hebrew_chet 0x0ce7          /* U+05D7 HEBREW LETTER HET */
+#define XK_hebrew_het 0x0ce7           /* deprecated */
+#define XK_hebrew_tet 0x0ce8           /* U+05D8 HEBREW LETTER TET */
+#define XK_hebrew_teth 0x0ce8          /* deprecated */
+#define XK_hebrew_yod 0x0ce9           /* U+05D9 HEBREW LETTER YOD */
+#define XK_hebrew_finalkaph 0x0cea     /* U+05DA HEBREW LETTER FINAL KAF */
+#define XK_hebrew_kaph 0x0ceb          /* U+05DB HEBREW LETTER KAF */
+#define XK_hebrew_lamed 0x0cec         /* U+05DC HEBREW LETTER LAMED */
+#define XK_hebrew_finalmem 0x0ced      /* U+05DD HEBREW LETTER FINAL MEM */
+#define XK_hebrew_mem 0x0cee           /* U+05DE HEBREW LETTER MEM */
+#define XK_hebrew_finalnun 0x0cef      /* U+05DF HEBREW LETTER FINAL NUN */
+#define XK_hebrew_nun 0x0cf0           /* U+05E0 HEBREW LETTER NUN */
+#define XK_hebrew_samech 0x0cf1        /* U+05E1 HEBREW LETTER SAMEKH */
+#define XK_hebrew_samekh 0x0cf1        /* deprecated */
+#define XK_hebrew_ayin 0x0cf2          /* U+05E2 HEBREW LETTER AYIN */
+#define XK_hebrew_finalpe 0x0cf3       /* U+05E3 HEBREW LETTER FINAL PE */
+#define XK_hebrew_pe 0x0cf4            /* U+05E4 HEBREW LETTER PE */
+#define XK_hebrew_finalzade 0x0cf5     /* U+05E5 HEBREW LETTER FINAL TSADI */
+#define XK_hebrew_finalzadi 0x0cf5     /* deprecated */
+#define XK_hebrew_zade 0x0cf6          /* U+05E6 HEBREW LETTER TSADI */
+#define XK_hebrew_zadi 0x0cf6          /* deprecated */
+#define XK_hebrew_qoph 0x0cf7          /* U+05E7 HEBREW LETTER QOF */
+#define XK_hebrew_kuf 0x0cf7           /* deprecated */
+#define XK_hebrew_resh 0x0cf8          /* U+05E8 HEBREW LETTER RESH */
+#define XK_hebrew_shin 0x0cf9          /* U+05E9 HEBREW LETTER SHIN */
+#define XK_hebrew_taw 0x0cfa           /* U+05EA HEBREW LETTER TAV */
+#define XK_hebrew_taf 0x0cfa           /* deprecated */
+#define XK_Hebrew_switch 0xff7e        /* Alias for mode_switch */
+#endif                                 /* XK_HEBREW */
+
+/*
+ * Thai
+ * Byte 3 = 0x0d
+ */
+
+#ifdef XK_THAI
+#define XK_Thai_kokai 0x0da1         /* U+0E01 THAI CHARACTER KO KAI */
+#define XK_Thai_khokhai 0x0da2       /* U+0E02 THAI CHARACTER KHO KHAI */
+#define XK_Thai_khokhuat 0x0da3      /* U+0E03 THAI CHARACTER KHO KHUAT */
+#define XK_Thai_khokhwai 0x0da4      /* U+0E04 THAI CHARACTER KHO KHWAI */
+#define XK_Thai_khokhon 0x0da5       /* U+0E05 THAI CHARACTER KHO KHON */
+#define XK_Thai_khorakhang 0x0da6    /* U+0E06 THAI CHARACTER KHO RAKHANG */
+#define XK_Thai_ngongu 0x0da7        /* U+0E07 THAI CHARACTER NGO NGU */
+#define XK_Thai_chochan 0x0da8       /* U+0E08 THAI CHARACTER CHO CHAN */
+#define XK_Thai_choching 0x0da9      /* U+0E09 THAI CHARACTER CHO CHING */
+#define XK_Thai_chochang 0x0daa      /* U+0E0A THAI CHARACTER CHO CHANG */
+#define XK_Thai_soso 0x0dab          /* U+0E0B THAI CHARACTER SO SO */
+#define XK_Thai_chochoe 0x0dac       /* U+0E0C THAI CHARACTER CHO CHOE */
+#define XK_Thai_yoying 0x0dad        /* U+0E0D THAI CHARACTER YO YING */
+#define XK_Thai_dochada 0x0dae       /* U+0E0E THAI CHARACTER DO CHADA */
+#define XK_Thai_topatak 0x0daf       /* U+0E0F THAI CHARACTER TO PATAK */
+#define XK_Thai_thothan 0x0db0       /* U+0E10 THAI CHARACTER THO THAN */
+#define XK_Thai_thonangmontho 0x0db1 /* U+0E11 THAI CHARACTER THO NANGMONTHO */
+#define XK_Thai_thophuthao 0x0db2    /* U+0E12 THAI CHARACTER THO PHUTHAO */
+#define XK_Thai_nonen 0x0db3         /* U+0E13 THAI CHARACTER NO NEN */
+#define XK_Thai_dodek 0x0db4         /* U+0E14 THAI CHARACTER DO DEK */
+#define XK_Thai_totao 0x0db5         /* U+0E15 THAI CHARACTER TO TAO */
+#define XK_Thai_thothung 0x0db6      /* U+0E16 THAI CHARACTER THO THUNG */
+#define XK_Thai_thothahan 0x0db7     /* U+0E17 THAI CHARACTER THO THAHAN */
+#define XK_Thai_thothong 0x0db8      /* U+0E18 THAI CHARACTER THO THONG */
+#define XK_Thai_nonu 0x0db9          /* U+0E19 THAI CHARACTER NO NU */
+#define XK_Thai_bobaimai 0x0dba      /* U+0E1A THAI CHARACTER BO BAIMAI */
+#define XK_Thai_popla 0x0dbb         /* U+0E1B THAI CHARACTER PO PLA */
+#define XK_Thai_phophung 0x0dbc      /* U+0E1C THAI CHARACTER PHO PHUNG */
+#define XK_Thai_fofa 0x0dbd          /* U+0E1D THAI CHARACTER FO FA */
+#define XK_Thai_phophan 0x0dbe       /* U+0E1E THAI CHARACTER PHO PHAN */
+#define XK_Thai_fofan 0x0dbf         /* U+0E1F THAI CHARACTER FO FAN */
+#define XK_Thai_phosamphao 0x0dc0    /* U+0E20 THAI CHARACTER PHO SAMPHAO */
+#define XK_Thai_moma 0x0dc1          /* U+0E21 THAI CHARACTER MO MA */
+#define XK_Thai_yoyak 0x0dc2         /* U+0E22 THAI CHARACTER YO YAK */
+#define XK_Thai_rorua 0x0dc3         /* U+0E23 THAI CHARACTER RO RUA */
+#define XK_Thai_ru 0x0dc4            /* U+0E24 THAI CHARACTER RU */
+#define XK_Thai_loling 0x0dc5        /* U+0E25 THAI CHARACTER LO LING */
+#define XK_Thai_lu 0x0dc6            /* U+0E26 THAI CHARACTER LU */
+#define XK_Thai_wowaen 0x0dc7        /* U+0E27 THAI CHARACTER WO WAEN */
+#define XK_Thai_sosala 0x0dc8        /* U+0E28 THAI CHARACTER SO SALA */
+#define XK_Thai_sorusi 0x0dc9        /* U+0E29 THAI CHARACTER SO RUSI */
+#define XK_Thai_sosua 0x0dca         /* U+0E2A THAI CHARACTER SO SUA */
+#define XK_Thai_hohip 0x0dcb         /* U+0E2B THAI CHARACTER HO HIP */
+#define XK_Thai_lochula 0x0dcc       /* U+0E2C THAI CHARACTER LO CHULA */
+#define XK_Thai_oang 0x0dcd          /* U+0E2D THAI CHARACTER O ANG */
+#define XK_Thai_honokhuk 0x0dce      /* U+0E2E THAI CHARACTER HO NOKHUK */
+#define XK_Thai_paiyannoi 0x0dcf     /* U+0E2F THAI CHARACTER PAIYANNOI */
+#define XK_Thai_saraa 0x0dd0         /* U+0E30 THAI CHARACTER SARA A */
+#define XK_Thai_maihanakat 0x0dd1    /* U+0E31 THAI CHARACTER MAI HAN-AKAT */
+#define XK_Thai_saraaa 0x0dd2        /* U+0E32 THAI CHARACTER SARA AA */
+#define XK_Thai_saraam 0x0dd3        /* U+0E33 THAI CHARACTER SARA AM */
+#define XK_Thai_sarai 0x0dd4         /* U+0E34 THAI CHARACTER SARA I */
+#define XK_Thai_saraii 0x0dd5        /* U+0E35 THAI CHARACTER SARA II */
+#define XK_Thai_saraue 0x0dd6        /* U+0E36 THAI CHARACTER SARA UE */
+#define XK_Thai_sarauee 0x0dd7       /* U+0E37 THAI CHARACTER SARA UEE */
+#define XK_Thai_sarau 0x0dd8         /* U+0E38 THAI CHARACTER SARA U */
+#define XK_Thai_sarauu 0x0dd9        /* U+0E39 THAI CHARACTER SARA UU */
+#define XK_Thai_phinthu 0x0dda       /* U+0E3A THAI CHARACTER PHINTHU */
+#define XK_Thai_maihanakat_maitho 0x0dde
+#define XK_Thai_baht 0x0ddf           /* U+0E3F THAI CURRENCY SYMBOL BAHT */
+#define XK_Thai_sarae 0x0de0          /* U+0E40 THAI CHARACTER SARA E */
+#define XK_Thai_saraae 0x0de1         /* U+0E41 THAI CHARACTER SARA AE */
+#define XK_Thai_sarao 0x0de2          /* U+0E42 THAI CHARACTER SARA O */
+#define XK_Thai_saraaimaimuan 0x0de3  /* U+0E43 THAI CHARACTER SARA AI MAIMUAN */
+#define XK_Thai_saraaimaimalai 0x0de4 /* U+0E44 THAI CHARACTER SARA AI MAIMALAI */
+#define XK_Thai_lakkhangyao 0x0de5    /* U+0E45 THAI CHARACTER LAKKHANGYAO */
+#define XK_Thai_maiyamok 0x0de6       /* U+0E46 THAI CHARACTER MAIYAMOK */
+#define XK_Thai_maitaikhu 0x0de7      /* U+0E47 THAI CHARACTER MAITAIKHU */
+#define XK_Thai_maiek 0x0de8          /* U+0E48 THAI CHARACTER MAI EK */
+#define XK_Thai_maitho 0x0de9         /* U+0E49 THAI CHARACTER MAI THO */
+#define XK_Thai_maitri 0x0dea         /* U+0E4A THAI CHARACTER MAI TRI */
+#define XK_Thai_maichattawa 0x0deb    /* U+0E4B THAI CHARACTER MAI CHATTAWA */
+#define XK_Thai_thanthakhat 0x0dec    /* U+0E4C THAI CHARACTER THANTHAKHAT */
+#define XK_Thai_nikhahit 0x0ded       /* U+0E4D THAI CHARACTER NIKHAHIT */
+#define XK_Thai_leksun 0x0df0         /* U+0E50 THAI DIGIT ZERO */
+#define XK_Thai_leknung 0x0df1        /* U+0E51 THAI DIGIT ONE */
+#define XK_Thai_leksong 0x0df2        /* U+0E52 THAI DIGIT TWO */
+#define XK_Thai_leksam 0x0df3         /* U+0E53 THAI DIGIT THREE */
+#define XK_Thai_leksi 0x0df4          /* U+0E54 THAI DIGIT FOUR */
+#define XK_Thai_lekha 0x0df5          /* U+0E55 THAI DIGIT FIVE */
+#define XK_Thai_lekhok 0x0df6         /* U+0E56 THAI DIGIT SIX */
+#define XK_Thai_lekchet 0x0df7        /* U+0E57 THAI DIGIT SEVEN */
+#define XK_Thai_lekpaet 0x0df8        /* U+0E58 THAI DIGIT EIGHT */
+#define XK_Thai_lekkao 0x0df9         /* U+0E59 THAI DIGIT NINE */
+#endif                                /* XK_THAI */
+
+/*
+ * Korean
+ * Byte 3 = 0x0e
+ */
+
+#ifdef XK_KOREAN
+
+#define XK_Hangul 0xff31                   /* Hangul start/stop(toggle) */
+#define XK_Hangul_Start 0xff32             /* Hangul start */
+#define XK_Hangul_End 0xff33               /* Hangul end, English start */
+#define XK_Hangul_Hanja 0xff34             /* Start Hangul->Hanja Conversion */
+#define XK_Hangul_Jamo 0xff35              /* Hangul Jamo mode */
+#define XK_Hangul_Romaja 0xff36            /* Hangul Romaja mode */
+#define XK_Hangul_Codeinput 0xff37         /* Hangul code input mode */
+#define XK_Hangul_Jeonja 0xff38            /* Jeonja mode */
+#define XK_Hangul_Banja 0xff39             /* Banja mode */
+#define XK_Hangul_PreHanja 0xff3a          /* Pre Hanja conversion */
+#define XK_Hangul_PostHanja 0xff3b         /* Post Hanja conversion */
+#define XK_Hangul_SingleCandidate 0xff3c   /* Single candidate */
+#define XK_Hangul_MultipleCandidate 0xff3d /* Multiple candidate */
+#define XK_Hangul_PreviousCandidate 0xff3e /* Previous candidate */
+#define XK_Hangul_Special 0xff3f           /* Special symbols */
+#define XK_Hangul_switch 0xff7e            /* Alias for mode_switch */
+
+/* Hangul Consonant Characters */
+#define XK_Hangul_Kiyeog 0x0ea1
+#define XK_Hangul_SsangKiyeog 0x0ea2
+#define XK_Hangul_KiyeogSios 0x0ea3
+#define XK_Hangul_Nieun 0x0ea4
+#define XK_Hangul_NieunJieuj 0x0ea5
+#define XK_Hangul_NieunHieuh 0x0ea6
+#define XK_Hangul_Dikeud 0x0ea7
+#define XK_Hangul_SsangDikeud 0x0ea8
+#define XK_Hangul_Rieul 0x0ea9
+#define XK_Hangul_RieulKiyeog 0x0eaa
+#define XK_Hangul_RieulMieum 0x0eab
+#define XK_Hangul_RieulPieub 0x0eac
+#define XK_Hangul_RieulSios 0x0ead
+#define XK_Hangul_RieulTieut 0x0eae
+#define XK_Hangul_RieulPhieuf 0x0eaf
+#define XK_Hangul_RieulHieuh 0x0eb0
+#define XK_Hangul_Mieum 0x0eb1
+#define XK_Hangul_Pieub 0x0eb2
+#define XK_Hangul_SsangPieub 0x0eb3
+#define XK_Hangul_PieubSios 0x0eb4
+#define XK_Hangul_Sios 0x0eb5
+#define XK_Hangul_SsangSios 0x0eb6
+#define XK_Hangul_Ieung 0x0eb7
+#define XK_Hangul_Jieuj 0x0eb8
+#define XK_Hangul_SsangJieuj 0x0eb9
+#define XK_Hangul_Cieuc 0x0eba
+#define XK_Hangul_Khieuq 0x0ebb
+#define XK_Hangul_Tieut 0x0ebc
+#define XK_Hangul_Phieuf 0x0ebd
+#define XK_Hangul_Hieuh 0x0ebe
+
+/* Hangul Vowel Characters */
+#define XK_Hangul_A 0x0ebf
+#define XK_Hangul_AE 0x0ec0
+#define XK_Hangul_YA 0x0ec1
+#define XK_Hangul_YAE 0x0ec2
+#define XK_Hangul_EO 0x0ec3
+#define XK_Hangul_E 0x0ec4
+#define XK_Hangul_YEO 0x0ec5
+#define XK_Hangul_YE 0x0ec6
+#define XK_Hangul_O 0x0ec7
+#define XK_Hangul_WA 0x0ec8
+#define XK_Hangul_WAE 0x0ec9
+#define XK_Hangul_OE 0x0eca
+#define XK_Hangul_YO 0x0ecb
+#define XK_Hangul_U 0x0ecc
+#define XK_Hangul_WEO 0x0ecd
+#define XK_Hangul_WE 0x0ece
+#define XK_Hangul_WI 0x0ecf
+#define XK_Hangul_YU 0x0ed0
+#define XK_Hangul_EU 0x0ed1
+#define XK_Hangul_YI 0x0ed2
+#define XK_Hangul_I 0x0ed3
+
+/* Hangul syllable-final (JongSeong) Characters */
+#define XK_Hangul_J_Kiyeog 0x0ed4
+#define XK_Hangul_J_SsangKiyeog 0x0ed5
+#define XK_Hangul_J_KiyeogSios 0x0ed6
+#define XK_Hangul_J_Nieun 0x0ed7
+#define XK_Hangul_J_NieunJieuj 0x0ed8
+#define XK_Hangul_J_NieunHieuh 0x0ed9
+#define XK_Hangul_J_Dikeud 0x0eda
+#define XK_Hangul_J_Rieul 0x0edb
+#define XK_Hangul_J_RieulKiyeog 0x0edc
+#define XK_Hangul_J_RieulMieum 0x0edd
+#define XK_Hangul_J_RieulPieub 0x0ede
+#define XK_Hangul_J_RieulSios 0x0edf
+#define XK_Hangul_J_RieulTieut 0x0ee0
+#define XK_Hangul_J_RieulPhieuf 0x0ee1
+#define XK_Hangul_J_RieulHieuh 0x0ee2
+#define XK_Hangul_J_Mieum 0x0ee3
+#define XK_Hangul_J_Pieub 0x0ee4
+#define XK_Hangul_J_PieubSios 0x0ee5
+#define XK_Hangul_J_Sios 0x0ee6
+#define XK_Hangul_J_SsangSios 0x0ee7
+#define XK_Hangul_J_Ieung 0x0ee8
+#define XK_Hangul_J_Jieuj 0x0ee9
+#define XK_Hangul_J_Cieuc 0x0eea
+#define XK_Hangul_J_Khieuq 0x0eeb
+#define XK_Hangul_J_Tieut 0x0eec
+#define XK_Hangul_J_Phieuf 0x0eed
+#define XK_Hangul_J_Hieuh 0x0eee
+
+/* Ancient Hangul Consonant Characters */
+#define XK_Hangul_RieulYeorinHieuh 0x0eef
+#define XK_Hangul_SunkyeongeumMieum 0x0ef0
+#define XK_Hangul_SunkyeongeumPieub 0x0ef1
+#define XK_Hangul_PanSios 0x0ef2
+#define XK_Hangul_KkogjiDalrinIeung 0x0ef3
+#define XK_Hangul_SunkyeongeumPhieuf 0x0ef4
+#define XK_Hangul_YeorinHieuh 0x0ef5
+
+/* Ancient Hangul Vowel Characters */
+#define XK_Hangul_AraeA 0x0ef6
+#define XK_Hangul_AraeAE 0x0ef7
+
+/* Ancient Hangul syllable-final (JongSeong) Characters */
+#define XK_Hangul_J_PanSios 0x0ef8
+#define XK_Hangul_J_KkogjiDalrinIeung 0x0ef9
+#define XK_Hangul_J_YeorinHieuh 0x0efa
+
+/* Korean currency symbol */
+#define XK_Korean_Won 0x0eff /*(U+20A9 WON SIGN)*/
+
+#endif /* XK_KOREAN */
+
+/*
+ * Armenian
+ */
+
+#ifdef XK_ARMENIAN
+#define XK_Armenian_ligature_ew 0x1000587     /* U+0587 ARMENIAN SMALL LIGATURE ECH YIWN */
+#define XK_Armenian_full_stop 0x1000589       /* U+0589 ARMENIAN FULL STOP */
+#define XK_Armenian_verjaket 0x1000589        /* U+0589 ARMENIAN FULL STOP */
+#define XK_Armenian_separation_mark 0x100055d /* U+055D ARMENIAN COMMA */
+#define XK_Armenian_but 0x100055d             /* U+055D ARMENIAN COMMA */
+#define XK_Armenian_hyphen 0x100058a          /* U+058A ARMENIAN HYPHEN */
+#define XK_Armenian_yentamna 0x100058a        /* U+058A ARMENIAN HYPHEN */
+#define XK_Armenian_exclam 0x100055c          /* U+055C ARMENIAN EXCLAMATION MARK */
+#define XK_Armenian_amanak 0x100055c          /* U+055C ARMENIAN EXCLAMATION MARK */
+#define XK_Armenian_accent 0x100055b          /* U+055B ARMENIAN EMPHASIS MARK */
+#define XK_Armenian_shesht 0x100055b          /* U+055B ARMENIAN EMPHASIS MARK */
+#define XK_Armenian_question 0x100055e        /* U+055E ARMENIAN QUESTION MARK */
+#define XK_Armenian_paruyk 0x100055e          /* U+055E ARMENIAN QUESTION MARK */
+#define XK_Armenian_AYB 0x1000531             /* U+0531 ARMENIAN CAPITAL LETTER AYB */
+#define XK_Armenian_ayb 0x1000561             /* U+0561 ARMENIAN SMALL LETTER AYB */
+#define XK_Armenian_BEN 0x1000532             /* U+0532 ARMENIAN CAPITAL LETTER BEN */
+#define XK_Armenian_ben 0x1000562             /* U+0562 ARMENIAN SMALL LETTER BEN */
+#define XK_Armenian_GIM 0x1000533             /* U+0533 ARMENIAN CAPITAL LETTER GIM */
+#define XK_Armenian_gim 0x1000563             /* U+0563 ARMENIAN SMALL LETTER GIM */
+#define XK_Armenian_DA 0x1000534              /* U+0534 ARMENIAN CAPITAL LETTER DA */
+#define XK_Armenian_da 0x1000564              /* U+0564 ARMENIAN SMALL LETTER DA */
+#define XK_Armenian_YECH 0x1000535            /* U+0535 ARMENIAN CAPITAL LETTER ECH */
+#define XK_Armenian_yech 0x1000565            /* U+0565 ARMENIAN SMALL LETTER ECH */
+#define XK_Armenian_ZA 0x1000536              /* U+0536 ARMENIAN CAPITAL LETTER ZA */
+#define XK_Armenian_za 0x1000566              /* U+0566 ARMENIAN SMALL LETTER ZA */
+#define XK_Armenian_E 0x1000537               /* U+0537 ARMENIAN CAPITAL LETTER EH */
+#define XK_Armenian_e 0x1000567               /* U+0567 ARMENIAN SMALL LETTER EH */
+#define XK_Armenian_AT 0x1000538              /* U+0538 ARMENIAN CAPITAL LETTER ET */
+#define XK_Armenian_at 0x1000568              /* U+0568 ARMENIAN SMALL LETTER ET */
+#define XK_Armenian_TO 0x1000539              /* U+0539 ARMENIAN CAPITAL LETTER TO */
+#define XK_Armenian_to 0x1000569              /* U+0569 ARMENIAN SMALL LETTER TO */
+#define XK_Armenian_ZHE 0x100053a             /* U+053A ARMENIAN CAPITAL LETTER ZHE */
+#define XK_Armenian_zhe 0x100056a             /* U+056A ARMENIAN SMALL LETTER ZHE */
+#define XK_Armenian_INI 0x100053b             /* U+053B ARMENIAN CAPITAL LETTER INI */
+#define XK_Armenian_ini 0x100056b             /* U+056B ARMENIAN SMALL LETTER INI */
+#define XK_Armenian_LYUN 0x100053c            /* U+053C ARMENIAN CAPITAL LETTER LIWN */
+#define XK_Armenian_lyun 0x100056c            /* U+056C ARMENIAN SMALL LETTER LIWN */
+#define XK_Armenian_KHE 0x100053d             /* U+053D ARMENIAN CAPITAL LETTER XEH */
+#define XK_Armenian_khe 0x100056d             /* U+056D ARMENIAN SMALL LETTER XEH */
+#define XK_Armenian_TSA 0x100053e             /* U+053E ARMENIAN CAPITAL LETTER CA */
+#define XK_Armenian_tsa 0x100056e             /* U+056E ARMENIAN SMALL LETTER CA */
+#define XK_Armenian_KEN 0x100053f             /* U+053F ARMENIAN CAPITAL LETTER KEN */
+#define XK_Armenian_ken 0x100056f             /* U+056F ARMENIAN SMALL LETTER KEN */
+#define XK_Armenian_HO 0x1000540              /* U+0540 ARMENIAN CAPITAL LETTER HO */
+#define XK_Armenian_ho 0x1000570              /* U+0570 ARMENIAN SMALL LETTER HO */
+#define XK_Armenian_DZA 0x1000541             /* U+0541 ARMENIAN CAPITAL LETTER JA */
+#define XK_Armenian_dza 0x1000571             /* U+0571 ARMENIAN SMALL LETTER JA */
+#define XK_Armenian_GHAT 0x1000542            /* U+0542 ARMENIAN CAPITAL LETTER GHAD */
+#define XK_Armenian_ghat 0x1000572            /* U+0572 ARMENIAN SMALL LETTER GHAD */
+#define XK_Armenian_TCHE 0x1000543            /* U+0543 ARMENIAN CAPITAL LETTER CHEH */
+#define XK_Armenian_tche 0x1000573            /* U+0573 ARMENIAN SMALL LETTER CHEH */
+#define XK_Armenian_MEN 0x1000544             /* U+0544 ARMENIAN CAPITAL LETTER MEN */
+#define XK_Armenian_men 0x1000574             /* U+0574 ARMENIAN SMALL LETTER MEN */
+#define XK_Armenian_HI 0x1000545              /* U+0545 ARMENIAN CAPITAL LETTER YI */
+#define XK_Armenian_hi 0x1000575              /* U+0575 ARMENIAN SMALL LETTER YI */
+#define XK_Armenian_NU 0x1000546              /* U+0546 ARMENIAN CAPITAL LETTER NOW */
+#define XK_Armenian_nu 0x1000576              /* U+0576 ARMENIAN SMALL LETTER NOW */
+#define XK_Armenian_SHA 0x1000547             /* U+0547 ARMENIAN CAPITAL LETTER SHA */
+#define XK_Armenian_sha 0x1000577             /* U+0577 ARMENIAN SMALL LETTER SHA */
+#define XK_Armenian_VO 0x1000548              /* U+0548 ARMENIAN CAPITAL LETTER VO */
+#define XK_Armenian_vo 0x1000578              /* U+0578 ARMENIAN SMALL LETTER VO */
+#define XK_Armenian_CHA 0x1000549             /* U+0549 ARMENIAN CAPITAL LETTER CHA */
+#define XK_Armenian_cha 0x1000579             /* U+0579 ARMENIAN SMALL LETTER CHA */
+#define XK_Armenian_PE 0x100054a              /* U+054A ARMENIAN CAPITAL LETTER PEH */
+#define XK_Armenian_pe 0x100057a              /* U+057A ARMENIAN SMALL LETTER PEH */
+#define XK_Armenian_JE 0x100054b              /* U+054B ARMENIAN CAPITAL LETTER JHEH */
+#define XK_Armenian_je 0x100057b              /* U+057B ARMENIAN SMALL LETTER JHEH */
+#define XK_Armenian_RA 0x100054c              /* U+054C ARMENIAN CAPITAL LETTER RA */
+#define XK_Armenian_ra 0x100057c              /* U+057C ARMENIAN SMALL LETTER RA */
+#define XK_Armenian_SE 0x100054d              /* U+054D ARMENIAN CAPITAL LETTER SEH */
+#define XK_Armenian_se 0x100057d              /* U+057D ARMENIAN SMALL LETTER SEH */
+#define XK_Armenian_VEV 0x100054e             /* U+054E ARMENIAN CAPITAL LETTER VEW */
+#define XK_Armenian_vev 0x100057e             /* U+057E ARMENIAN SMALL LETTER VEW */
+#define XK_Armenian_TYUN 0x100054f            /* U+054F ARMENIAN CAPITAL LETTER TIWN */
+#define XK_Armenian_tyun 0x100057f            /* U+057F ARMENIAN SMALL LETTER TIWN */
+#define XK_Armenian_RE 0x1000550              /* U+0550 ARMENIAN CAPITAL LETTER REH */
+#define XK_Armenian_re 0x1000580              /* U+0580 ARMENIAN SMALL LETTER REH */
+#define XK_Armenian_TSO 0x1000551             /* U+0551 ARMENIAN CAPITAL LETTER CO */
+#define XK_Armenian_tso 0x1000581             /* U+0581 ARMENIAN SMALL LETTER CO */
+#define XK_Armenian_VYUN 0x1000552            /* U+0552 ARMENIAN CAPITAL LETTER YIWN */
+#define XK_Armenian_vyun 0x1000582            /* U+0582 ARMENIAN SMALL LETTER YIWN */
+#define XK_Armenian_PYUR 0x1000553            /* U+0553 ARMENIAN CAPITAL LETTER PIWR */
+#define XK_Armenian_pyur 0x1000583            /* U+0583 ARMENIAN SMALL LETTER PIWR */
+#define XK_Armenian_KE 0x1000554              /* U+0554 ARMENIAN CAPITAL LETTER KEH */
+#define XK_Armenian_ke 0x1000584              /* U+0584 ARMENIAN SMALL LETTER KEH */
+#define XK_Armenian_O 0x1000555               /* U+0555 ARMENIAN CAPITAL LETTER OH */
+#define XK_Armenian_o 0x1000585               /* U+0585 ARMENIAN SMALL LETTER OH */
+#define XK_Armenian_FE 0x1000556              /* U+0556 ARMENIAN CAPITAL LETTER FEH */
+#define XK_Armenian_fe 0x1000586              /* U+0586 ARMENIAN SMALL LETTER FEH */
+#define XK_Armenian_apostrophe 0x100055a      /* U+055A ARMENIAN APOSTROPHE */
+#endif                                        /* XK_ARMENIAN */
+
+/*
+ * Georgian
+ */
+
+#ifdef XK_GEORGIAN
+#define XK_Georgian_an 0x10010d0   /* U+10D0 GEORGIAN LETTER AN */
+#define XK_Georgian_ban 0x10010d1  /* U+10D1 GEORGIAN LETTER BAN */
+#define XK_Georgian_gan 0x10010d2  /* U+10D2 GEORGIAN LETTER GAN */
+#define XK_Georgian_don 0x10010d3  /* U+10D3 GEORGIAN LETTER DON */
+#define XK_Georgian_en 0x10010d4   /* U+10D4 GEORGIAN LETTER EN */
+#define XK_Georgian_vin 0x10010d5  /* U+10D5 GEORGIAN LETTER VIN */
+#define XK_Georgian_zen 0x10010d6  /* U+10D6 GEORGIAN LETTER ZEN */
+#define XK_Georgian_tan 0x10010d7  /* U+10D7 GEORGIAN LETTER TAN */
+#define XK_Georgian_in 0x10010d8   /* U+10D8 GEORGIAN LETTER IN */
+#define XK_Georgian_kan 0x10010d9  /* U+10D9 GEORGIAN LETTER KAN */
+#define XK_Georgian_las 0x10010da  /* U+10DA GEORGIAN LETTER LAS */
+#define XK_Georgian_man 0x10010db  /* U+10DB GEORGIAN LETTER MAN */
+#define XK_Georgian_nar 0x10010dc  /* U+10DC GEORGIAN LETTER NAR */
+#define XK_Georgian_on 0x10010dd   /* U+10DD GEORGIAN LETTER ON */
+#define XK_Georgian_par 0x10010de  /* U+10DE GEORGIAN LETTER PAR */
+#define XK_Georgian_zhar 0x10010df /* U+10DF GEORGIAN LETTER ZHAR */
+#define XK_Georgian_rae 0x10010e0  /* U+10E0 GEORGIAN LETTER RAE */
+#define XK_Georgian_san 0x10010e1  /* U+10E1 GEORGIAN LETTER SAN */
+#define XK_Georgian_tar 0x10010e2  /* U+10E2 GEORGIAN LETTER TAR */
+#define XK_Georgian_un 0x10010e3   /* U+10E3 GEORGIAN LETTER UN */
+#define XK_Georgian_phar 0x10010e4 /* U+10E4 GEORGIAN LETTER PHAR */
+#define XK_Georgian_khar 0x10010e5 /* U+10E5 GEORGIAN LETTER KHAR */
+#define XK_Georgian_ghan 0x10010e6 /* U+10E6 GEORGIAN LETTER GHAN */
+#define XK_Georgian_qar 0x10010e7  /* U+10E7 GEORGIAN LETTER QAR */
+#define XK_Georgian_shin 0x10010e8 /* U+10E8 GEORGIAN LETTER SHIN */
+#define XK_Georgian_chin 0x10010e9 /* U+10E9 GEORGIAN LETTER CHIN */
+#define XK_Georgian_can 0x10010ea  /* U+10EA GEORGIAN LETTER CAN */
+#define XK_Georgian_jil 0x10010eb  /* U+10EB GEORGIAN LETTER JIL */
+#define XK_Georgian_cil 0x10010ec  /* U+10EC GEORGIAN LETTER CIL */
+#define XK_Georgian_char 0x10010ed /* U+10ED GEORGIAN LETTER CHAR */
+#define XK_Georgian_xan 0x10010ee  /* U+10EE GEORGIAN LETTER XAN */
+#define XK_Georgian_jhan 0x10010ef /* U+10EF GEORGIAN LETTER JHAN */
+#define XK_Georgian_hae 0x10010f0  /* U+10F0 GEORGIAN LETTER HAE */
+#define XK_Georgian_he 0x10010f1   /* U+10F1 GEORGIAN LETTER HE */
+#define XK_Georgian_hie 0x10010f2  /* U+10F2 GEORGIAN LETTER HIE */
+#define XK_Georgian_we 0x10010f3   /* U+10F3 GEORGIAN LETTER WE */
+#define XK_Georgian_har 0x10010f4  /* U+10F4 GEORGIAN LETTER HAR */
+#define XK_Georgian_hoe 0x10010f5  /* U+10F5 GEORGIAN LETTER HOE */
+#define XK_Georgian_fi 0x10010f6   /* U+10F6 GEORGIAN LETTER FI */
+#endif                             /* XK_GEORGIAN */
+
+/*
+ * Azeri (and other Turkic or Caucasian languages)
+ */
+
+#ifdef XK_CAUCASUS
+/* latin */
+#define XK_Xabovedot 0x1001e8a /* U+1E8A LATIN CAPITAL LETTER X WITH DOT ABOVE */
+#define XK_Ibreve 0x100012c    /* U+012C LATIN CAPITAL LETTER I WITH BREVE */
+#define XK_Zstroke 0x10001b5   /* U+01B5 LATIN CAPITAL LETTER Z WITH STROKE */
+#define XK_Gcaron 0x10001e6    /* U+01E6 LATIN CAPITAL LETTER G WITH CARON */
+#define XK_Ocaron 0x10001d1    /* U+01D2 LATIN CAPITAL LETTER O WITH CARON */
+#define XK_Obarred 0x100019f   /* U+019F LATIN CAPITAL LETTER O WITH MIDDLE TILDE */
+#define XK_xabovedot 0x1001e8b /* U+1E8B LATIN SMALL LETTER X WITH DOT ABOVE */
+#define XK_ibreve 0x100012d    /* U+012D LATIN SMALL LETTER I WITH BREVE */
+#define XK_zstroke 0x10001b6   /* U+01B6 LATIN SMALL LETTER Z WITH STROKE */
+#define XK_gcaron 0x10001e7    /* U+01E7 LATIN SMALL LETTER G WITH CARON */
+#define XK_ocaron 0x10001d2    /* U+01D2 LATIN SMALL LETTER O WITH CARON */
+#define XK_obarred 0x1000275   /* U+0275 LATIN SMALL LETTER BARRED O */
+#define XK_SCHWA 0x100018f     /* U+018F LATIN CAPITAL LETTER SCHWA */
+#define XK_schwa 0x1000259     /* U+0259 LATIN SMALL LETTER SCHWA */
+#define XK_EZH 0x10001b7       /* U+01B7 LATIN CAPITAL LETTER EZH */
+#define XK_ezh 0x1000292       /* U+0292 LATIN SMALL LETTER EZH */
+/* those are not really Caucasus */
+/* For Inupiak */
+#define XK_Lbelowdot 0x1001e36 /* U+1E36 LATIN CAPITAL LETTER L WITH DOT BELOW */
+#define XK_lbelowdot 0x1001e37 /* U+1E37 LATIN SMALL LETTER L WITH DOT BELOW */
+#endif                         /* XK_CAUCASUS */
+
+/*
+ * Vietnamese
+ */
+
+#ifdef XK_VIETNAMESE
+#define XK_Abelowdot 0x1001ea0           /* U+1EA0 LATIN CAPITAL LETTER A WITH DOT BELOW */
+#define XK_abelowdot 0x1001ea1           /* U+1EA1 LATIN SMALL LETTER A WITH DOT BELOW */
+#define XK_Ahook 0x1001ea2               /* U+1EA2 LATIN CAPITAL LETTER A WITH HOOK ABOVE */
+#define XK_ahook 0x1001ea3               /* U+1EA3 LATIN SMALL LETTER A WITH HOOK ABOVE */
+#define XK_Acircumflexacute 0x1001ea4    /* U+1EA4 LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND ACUTE */
+#define XK_acircumflexacute 0x1001ea5    /* U+1EA5 LATIN SMALL LETTER A WITH CIRCUMFLEX AND ACUTE */
+#define XK_Acircumflexgrave 0x1001ea6    /* U+1EA6 LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND GRAVE */
+#define XK_acircumflexgrave 0x1001ea7    /* U+1EA7 LATIN SMALL LETTER A WITH CIRCUMFLEX AND GRAVE */
+#define XK_Acircumflexhook 0x1001ea8     /* U+1EA8 LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE */
+#define XK_acircumflexhook 0x1001ea9     /* U+1EA9 LATIN SMALL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE */
+#define XK_Acircumflextilde 0x1001eaa    /* U+1EAA LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND TILDE */
+#define XK_acircumflextilde 0x1001eab    /* U+1EAB LATIN SMALL LETTER A WITH CIRCUMFLEX AND TILDE */
+#define XK_Acircumflexbelowdot 0x1001eac /* U+1EAC LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND DOT BELOW */
+#define XK_acircumflexbelowdot 0x1001ead /* U+1EAD LATIN SMALL LETTER A WITH CIRCUMFLEX AND DOT BELOW */
+#define XK_Abreveacute 0x1001eae         /* U+1EAE LATIN CAPITAL LETTER A WITH BREVE AND ACUTE */
+#define XK_abreveacute 0x1001eaf         /* U+1EAF LATIN SMALL LETTER A WITH BREVE AND ACUTE */
+#define XK_Abrevegrave 0x1001eb0         /* U+1EB0 LATIN CAPITAL LETTER A WITH BREVE AND GRAVE */
+#define XK_abrevegrave 0x1001eb1         /* U+1EB1 LATIN SMALL LETTER A WITH BREVE AND GRAVE */
+#define XK_Abrevehook 0x1001eb2          /* U+1EB2 LATIN CAPITAL LETTER A WITH BREVE AND HOOK ABOVE */
+#define XK_abrevehook 0x1001eb3          /* U+1EB3 LATIN SMALL LETTER A WITH BREVE AND HOOK ABOVE */
+#define XK_Abrevetilde 0x1001eb4         /* U+1EB4 LATIN CAPITAL LETTER A WITH BREVE AND TILDE */
+#define XK_abrevetilde 0x1001eb5         /* U+1EB5 LATIN SMALL LETTER A WITH BREVE AND TILDE */
+#define XK_Abrevebelowdot 0x1001eb6      /* U+1EB6 LATIN CAPITAL LETTER A WITH BREVE AND DOT BELOW */
+#define XK_abrevebelowdot 0x1001eb7      /* U+1EB7 LATIN SMALL LETTER A WITH BREVE AND DOT BELOW */
+#define XK_Ebelowdot 0x1001eb8           /* U+1EB8 LATIN CAPITAL LETTER E WITH DOT BELOW */
+#define XK_ebelowdot 0x1001eb9           /* U+1EB9 LATIN SMALL LETTER E WITH DOT BELOW */
+#define XK_Ehook 0x1001eba               /* U+1EBA LATIN CAPITAL LETTER E WITH HOOK ABOVE */
+#define XK_ehook 0x1001ebb               /* U+1EBB LATIN SMALL LETTER E WITH HOOK ABOVE */
+#define XK_Etilde 0x1001ebc              /* U+1EBC LATIN CAPITAL LETTER E WITH TILDE */
+#define XK_etilde 0x1001ebd              /* U+1EBD LATIN SMALL LETTER E WITH TILDE */
+#define XK_Ecircumflexacute 0x1001ebe    /* U+1EBE LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND ACUTE */
+#define XK_ecircumflexacute 0x1001ebf    /* U+1EBF LATIN SMALL LETTER E WITH CIRCUMFLEX AND ACUTE */
+#define XK_Ecircumflexgrave 0x1001ec0    /* U+1EC0 LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND GRAVE */
+#define XK_ecircumflexgrave 0x1001ec1    /* U+1EC1 LATIN SMALL LETTER E WITH CIRCUMFLEX AND GRAVE */
+#define XK_Ecircumflexhook 0x1001ec2     /* U+1EC2 LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE */
+#define XK_ecircumflexhook 0x1001ec3     /* U+1EC3 LATIN SMALL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE */
+#define XK_Ecircumflextilde 0x1001ec4    /* U+1EC4 LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND TILDE */
+#define XK_ecircumflextilde 0x1001ec5    /* U+1EC5 LATIN SMALL LETTER E WITH CIRCUMFLEX AND TILDE */
+#define XK_Ecircumflexbelowdot 0x1001ec6 /* U+1EC6 LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND DOT BELOW */
+#define XK_ecircumflexbelowdot 0x1001ec7 /* U+1EC7 LATIN SMALL LETTER E WITH CIRCUMFLEX AND DOT BELOW */
+#define XK_Ihook 0x1001ec8               /* U+1EC8 LATIN CAPITAL LETTER I WITH HOOK ABOVE */
+#define XK_ihook 0x1001ec9               /* U+1EC9 LATIN SMALL LETTER I WITH HOOK ABOVE */
+#define XK_Ibelowdot 0x1001eca           /* U+1ECA LATIN CAPITAL LETTER I WITH DOT BELOW */
+#define XK_ibelowdot 0x1001ecb           /* U+1ECB LATIN SMALL LETTER I WITH DOT BELOW */
+#define XK_Obelowdot 0x1001ecc           /* U+1ECC LATIN CAPITAL LETTER O WITH DOT BELOW */
+#define XK_obelowdot 0x1001ecd           /* U+1ECD LATIN SMALL LETTER O WITH DOT BELOW */
+#define XK_Ohook 0x1001ece               /* U+1ECE LATIN CAPITAL LETTER O WITH HOOK ABOVE */
+#define XK_ohook 0x1001ecf               /* U+1ECF LATIN SMALL LETTER O WITH HOOK ABOVE */
+#define XK_Ocircumflexacute 0x1001ed0    /* U+1ED0 LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND ACUTE */
+#define XK_ocircumflexacute 0x1001ed1    /* U+1ED1 LATIN SMALL LETTER O WITH CIRCUMFLEX AND ACUTE */
+#define XK_Ocircumflexgrave 0x1001ed2    /* U+1ED2 LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND GRAVE */
+#define XK_ocircumflexgrave 0x1001ed3    /* U+1ED3 LATIN SMALL LETTER O WITH CIRCUMFLEX AND GRAVE */
+#define XK_Ocircumflexhook 0x1001ed4     /* U+1ED4 LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE */
+#define XK_ocircumflexhook 0x1001ed5     /* U+1ED5 LATIN SMALL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE */
+#define XK_Ocircumflextilde 0x1001ed6    /* U+1ED6 LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND TILDE */
+#define XK_ocircumflextilde 0x1001ed7    /* U+1ED7 LATIN SMALL LETTER O WITH CIRCUMFLEX AND TILDE */
+#define XK_Ocircumflexbelowdot 0x1001ed8 /* U+1ED8 LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND DOT BELOW */
+#define XK_ocircumflexbelowdot 0x1001ed9 /* U+1ED9 LATIN SMALL LETTER O WITH CIRCUMFLEX AND DOT BELOW */
+#define XK_Ohornacute 0x1001eda          /* U+1EDA LATIN CAPITAL LETTER O WITH HORN AND ACUTE */
+#define XK_ohornacute 0x1001edb          /* U+1EDB LATIN SMALL LETTER O WITH HORN AND ACUTE */
+#define XK_Ohorngrave 0x1001edc          /* U+1EDC LATIN CAPITAL LETTER O WITH HORN AND GRAVE */
+#define XK_ohorngrave 0x1001edd          /* U+1EDD LATIN SMALL LETTER O WITH HORN AND GRAVE */
+#define XK_Ohornhook 0x1001ede           /* U+1EDE LATIN CAPITAL LETTER O WITH HORN AND HOOK ABOVE */
+#define XK_ohornhook 0x1001edf           /* U+1EDF LATIN SMALL LETTER O WITH HORN AND HOOK ABOVE */
+#define XK_Ohorntilde 0x1001ee0          /* U+1EE0 LATIN CAPITAL LETTER O WITH HORN AND TILDE */
+#define XK_ohorntilde 0x1001ee1          /* U+1EE1 LATIN SMALL LETTER O WITH HORN AND TILDE */
+#define XK_Ohornbelowdot 0x1001ee2       /* U+1EE2 LATIN CAPITAL LETTER O WITH HORN AND DOT BELOW */
+#define XK_ohornbelowdot 0x1001ee3       /* U+1EE3 LATIN SMALL LETTER O WITH HORN AND DOT BELOW */
+#define XK_Ubelowdot 0x1001ee4           /* U+1EE4 LATIN CAPITAL LETTER U WITH DOT BELOW */
+#define XK_ubelowdot 0x1001ee5           /* U+1EE5 LATIN SMALL LETTER U WITH DOT BELOW */
+#define XK_Uhook 0x1001ee6               /* U+1EE6 LATIN CAPITAL LETTER U WITH HOOK ABOVE */
+#define XK_uhook 0x1001ee7               /* U+1EE7 LATIN SMALL LETTER U WITH HOOK ABOVE */
+#define XK_Uhornacute 0x1001ee8          /* U+1EE8 LATIN CAPITAL LETTER U WITH HORN AND ACUTE */
+#define XK_uhornacute 0x1001ee9          /* U+1EE9 LATIN SMALL LETTER U WITH HORN AND ACUTE */
+#define XK_Uhorngrave 0x1001eea          /* U+1EEA LATIN CAPITAL LETTER U WITH HORN AND GRAVE */
+#define XK_uhorngrave 0x1001eeb          /* U+1EEB LATIN SMALL LETTER U WITH HORN AND GRAVE */
+#define XK_Uhornhook 0x1001eec           /* U+1EEC LATIN CAPITAL LETTER U WITH HORN AND HOOK ABOVE */
+#define XK_uhornhook 0x1001eed           /* U+1EED LATIN SMALL LETTER U WITH HORN AND HOOK ABOVE */
+#define XK_Uhorntilde 0x1001eee          /* U+1EEE LATIN CAPITAL LETTER U WITH HORN AND TILDE */
+#define XK_uhorntilde 0x1001eef          /* U+1EEF LATIN SMALL LETTER U WITH HORN AND TILDE */
+#define XK_Uhornbelowdot 0x1001ef0       /* U+1EF0 LATIN CAPITAL LETTER U WITH HORN AND DOT BELOW */
+#define XK_uhornbelowdot 0x1001ef1       /* U+1EF1 LATIN SMALL LETTER U WITH HORN AND DOT BELOW */
+#define XK_Ybelowdot 0x1001ef4           /* U+1EF4 LATIN CAPITAL LETTER Y WITH DOT BELOW */
+#define XK_ybelowdot 0x1001ef5           /* U+1EF5 LATIN SMALL LETTER Y WITH DOT BELOW */
+#define XK_Yhook 0x1001ef6               /* U+1EF6 LATIN CAPITAL LETTER Y WITH HOOK ABOVE */
+#define XK_yhook 0x1001ef7               /* U+1EF7 LATIN SMALL LETTER Y WITH HOOK ABOVE */
+#define XK_Ytilde 0x1001ef8              /* U+1EF8 LATIN CAPITAL LETTER Y WITH TILDE */
+#define XK_ytilde 0x1001ef9              /* U+1EF9 LATIN SMALL LETTER Y WITH TILDE */
+#define XK_Ohorn 0x10001a0               /* U+01A0 LATIN CAPITAL LETTER O WITH HORN */
+#define XK_ohorn 0x10001a1               /* U+01A1 LATIN SMALL LETTER O WITH HORN */
+#define XK_Uhorn 0x10001af               /* U+01AF LATIN CAPITAL LETTER U WITH HORN */
+#define XK_uhorn 0x10001b0               /* U+01B0 LATIN SMALL LETTER U WITH HORN */
+
+#endif /* XK_VIETNAMESE */
+
+#ifdef XK_CURRENCY
+#define XK_EcuSign 0x10020a0       /* U+20A0 EURO-CURRENCY SIGN */
+#define XK_ColonSign 0x10020a1     /* U+20A1 COLON SIGN */
+#define XK_CruzeiroSign 0x10020a2  /* U+20A2 CRUZEIRO SIGN */
+#define XK_FFrancSign 0x10020a3    /* U+20A3 FRENCH FRANC SIGN */
+#define XK_LiraSign 0x10020a4      /* U+20A4 LIRA SIGN */
+#define XK_MillSign 0x10020a5      /* U+20A5 MILL SIGN */
+#define XK_NairaSign 0x10020a6     /* U+20A6 NAIRA SIGN */
+#define XK_PesetaSign 0x10020a7    /* U+20A7 PESETA SIGN */
+#define XK_RupeeSign 0x10020a8     /* U+20A8 RUPEE SIGN */
+#define XK_WonSign 0x10020a9       /* U+20A9 WON SIGN */
+#define XK_NewSheqelSign 0x10020aa /* U+20AA NEW SHEQEL SIGN */
+#define XK_DongSign 0x10020ab      /* U+20AB DONG SIGN */
+#define XK_EuroSign 0x20ac         /* U+20AC EURO SIGN */
+#endif                             /* XK_CURRENCY */
+
+#ifdef XK_MATHEMATICAL
+/* one, two and three are defined above. */
+#define XK_zerosuperior 0x1002070     /* U+2070 SUPERSCRIPT ZERO */
+#define XK_foursuperior 0x1002074     /* U+2074 SUPERSCRIPT FOUR */
+#define XK_fivesuperior 0x1002075     /* U+2075 SUPERSCRIPT FIVE */
+#define XK_sixsuperior 0x1002076      /* U+2076 SUPERSCRIPT SIX */
+#define XK_sevensuperior 0x1002077    /* U+2077 SUPERSCRIPT SEVEN */
+#define XK_eightsuperior 0x1002078    /* U+2078 SUPERSCRIPT EIGHT */
+#define XK_ninesuperior 0x1002079     /* U+2079 SUPERSCRIPT NINE */
+#define XK_zerosubscript 0x1002080    /* U+2080 SUBSCRIPT ZERO */
+#define XK_onesubscript 0x1002081     /* U+2081 SUBSCRIPT ONE */
+#define XK_twosubscript 0x1002082     /* U+2082 SUBSCRIPT TWO */
+#define XK_threesubscript 0x1002083   /* U+2083 SUBSCRIPT THREE */
+#define XK_foursubscript 0x1002084    /* U+2084 SUBSCRIPT FOUR */
+#define XK_fivesubscript 0x1002085    /* U+2085 SUBSCRIPT FIVE */
+#define XK_sixsubscript 0x1002086     /* U+2086 SUBSCRIPT SIX */
+#define XK_sevensubscript 0x1002087   /* U+2087 SUBSCRIPT SEVEN */
+#define XK_eightsubscript 0x1002088   /* U+2088 SUBSCRIPT EIGHT */
+#define XK_ninesubscript 0x1002089    /* U+2089 SUBSCRIPT NINE */
+#define XK_partdifferential 0x1002202 /* U+2202 PARTIAL DIFFERENTIAL */
+#define XK_emptyset 0x1002205         /* U+2205 NULL SET */
+#define XK_elementof 0x1002208        /* U+2208 ELEMENT OF */
+#define XK_notelementof 0x1002209     /* U+2209 NOT AN ELEMENT OF */
+#define XK_containsas 0x100220B       /* U+220B CONTAINS AS MEMBER */
+#define XK_squareroot 0x100221A       /* U+221A SQUARE ROOT */
+#define XK_cuberoot 0x100221B         /* U+221B CUBE ROOT */
+#define XK_fourthroot 0x100221C       /* U+221C FOURTH ROOT */
+#define XK_dintegral 0x100222C        /* U+222C DOUBLE INTEGRAL */
+#define XK_tintegral 0x100222D        /* U+222D TRIPLE INTEGRAL */
+#define XK_because 0x1002235          /* U+2235 BECAUSE */
+#define XK_approxeq 0x1002248         /* U+2245 ALMOST EQUAL TO */
+#define XK_notapproxeq 0x1002247      /* U+2247 NOT ALMOST EQUAL TO */
+#define XK_notidentical 0x1002262     /* U+2262 NOT IDENTICAL TO */
+#define XK_stricteq 0x1002263         /* U+2263 STRICTLY EQUIVALENT TO */
+#endif                                /* XK_MATHEMATICAL */
+
+#ifdef XK_BRAILLE
+#define XK_braille_dot_1 0xfff1
+#define XK_braille_dot_2 0xfff2
+#define XK_braille_dot_3 0xfff3
+#define XK_braille_dot_4 0xfff4
+#define XK_braille_dot_5 0xfff5
+#define XK_braille_dot_6 0xfff6
+#define XK_braille_dot_7 0xfff7
+#define XK_braille_dot_8 0xfff8
+#define XK_braille_dot_9 0xfff9
+#define XK_braille_dot_10 0xfffa
+#define XK_braille_blank 0x1002800         /* U+2800 BRAILLE PATTERN BLANK */
+#define XK_braille_dots_1 0x1002801        /* U+2801 BRAILLE PATTERN DOTS-1 */
+#define XK_braille_dots_2 0x1002802        /* U+2802 BRAILLE PATTERN DOTS-2 */
+#define XK_braille_dots_12 0x1002803       /* U+2803 BRAILLE PATTERN DOTS-12 */
+#define XK_braille_dots_3 0x1002804        /* U+2804 BRAILLE PATTERN DOTS-3 */
+#define XK_braille_dots_13 0x1002805       /* U+2805 BRAILLE PATTERN DOTS-13 */
+#define XK_braille_dots_23 0x1002806       /* U+2806 BRAILLE PATTERN DOTS-23 */
+#define XK_braille_dots_123 0x1002807      /* U+2807 BRAILLE PATTERN DOTS-123 */
+#define XK_braille_dots_4 0x1002808        /* U+2808 BRAILLE PATTERN DOTS-4 */
+#define XK_braille_dots_14 0x1002809       /* U+2809 BRAILLE PATTERN DOTS-14 */
+#define XK_braille_dots_24 0x100280a       /* U+280a BRAILLE PATTERN DOTS-24 */
+#define XK_braille_dots_124 0x100280b      /* U+280b BRAILLE PATTERN DOTS-124 */
+#define XK_braille_dots_34 0x100280c       /* U+280c BRAILLE PATTERN DOTS-34 */
+#define XK_braille_dots_134 0x100280d      /* U+280d BRAILLE PATTERN DOTS-134 */
+#define XK_braille_dots_234 0x100280e      /* U+280e BRAILLE PATTERN DOTS-234 */
+#define XK_braille_dots_1234 0x100280f     /* U+280f BRAILLE PATTERN DOTS-1234 */
+#define XK_braille_dots_5 0x1002810        /* U+2810 BRAILLE PATTERN DOTS-5 */
+#define XK_braille_dots_15 0x1002811       /* U+2811 BRAILLE PATTERN DOTS-15 */
+#define XK_braille_dots_25 0x1002812       /* U+2812 BRAILLE PATTERN DOTS-25 */
+#define XK_braille_dots_125 0x1002813      /* U+2813 BRAILLE PATTERN DOTS-125 */
+#define XK_braille_dots_35 0x1002814       /* U+2814 BRAILLE PATTERN DOTS-35 */
+#define XK_braille_dots_135 0x1002815      /* U+2815 BRAILLE PATTERN DOTS-135 */
+#define XK_braille_dots_235 0x1002816      /* U+2816 BRAILLE PATTERN DOTS-235 */
+#define XK_braille_dots_1235 0x1002817     /* U+2817 BRAILLE PATTERN DOTS-1235 */
+#define XK_braille_dots_45 0x1002818       /* U+2818 BRAILLE PATTERN DOTS-45 */
+#define XK_braille_dots_145 0x1002819      /* U+2819 BRAILLE PATTERN DOTS-145 */
+#define XK_braille_dots_245 0x100281a      /* U+281a BRAILLE PATTERN DOTS-245 */
+#define XK_braille_dots_1245 0x100281b     /* U+281b BRAILLE PATTERN DOTS-1245 */
+#define XK_braille_dots_345 0x100281c      /* U+281c BRAILLE PATTERN DOTS-345 */
+#define XK_braille_dots_1345 0x100281d     /* U+281d BRAILLE PATTERN DOTS-1345 */
+#define XK_braille_dots_2345 0x100281e     /* U+281e BRAILLE PATTERN DOTS-2345 */
+#define XK_braille_dots_12345 0x100281f    /* U+281f BRAILLE PATTERN DOTS-12345 */
+#define XK_braille_dots_6 0x1002820        /* U+2820 BRAILLE PATTERN DOTS-6 */
+#define XK_braille_dots_16 0x1002821       /* U+2821 BRAILLE PATTERN DOTS-16 */
+#define XK_braille_dots_26 0x1002822       /* U+2822 BRAILLE PATTERN DOTS-26 */
+#define XK_braille_dots_126 0x1002823      /* U+2823 BRAILLE PATTERN DOTS-126 */
+#define XK_braille_dots_36 0x1002824       /* U+2824 BRAILLE PATTERN DOTS-36 */
+#define XK_braille_dots_136 0x1002825      /* U+2825 BRAILLE PATTERN DOTS-136 */
+#define XK_braille_dots_236 0x1002826      /* U+2826 BRAILLE PATTERN DOTS-236 */
+#define XK_braille_dots_1236 0x1002827     /* U+2827 BRAILLE PATTERN DOTS-1236 */
+#define XK_braille_dots_46 0x1002828       /* U+2828 BRAILLE PATTERN DOTS-46 */
+#define XK_braille_dots_146 0x1002829      /* U+2829 BRAILLE PATTERN DOTS-146 */
+#define XK_braille_dots_246 0x100282a      /* U+282a BRAILLE PATTERN DOTS-246 */
+#define XK_braille_dots_1246 0x100282b     /* U+282b BRAILLE PATTERN DOTS-1246 */
+#define XK_braille_dots_346 0x100282c      /* U+282c BRAILLE PATTERN DOTS-346 */
+#define XK_braille_dots_1346 0x100282d     /* U+282d BRAILLE PATTERN DOTS-1346 */
+#define XK_braille_dots_2346 0x100282e     /* U+282e BRAILLE PATTERN DOTS-2346 */
+#define XK_braille_dots_12346 0x100282f    /* U+282f BRAILLE PATTERN DOTS-12346 */
+#define XK_braille_dots_56 0x1002830       /* U+2830 BRAILLE PATTERN DOTS-56 */
+#define XK_braille_dots_156 0x1002831      /* U+2831 BRAILLE PATTERN DOTS-156 */
+#define XK_braille_dots_256 0x1002832      /* U+2832 BRAILLE PATTERN DOTS-256 */
+#define XK_braille_dots_1256 0x1002833     /* U+2833 BRAILLE PATTERN DOTS-1256 */
+#define XK_braille_dots_356 0x1002834      /* U+2834 BRAILLE PATTERN DOTS-356 */
+#define XK_braille_dots_1356 0x1002835     /* U+2835 BRAILLE PATTERN DOTS-1356 */
+#define XK_braille_dots_2356 0x1002836     /* U+2836 BRAILLE PATTERN DOTS-2356 */
+#define XK_braille_dots_12356 0x1002837    /* U+2837 BRAILLE PATTERN DOTS-12356 */
+#define XK_braille_dots_456 0x1002838      /* U+2838 BRAILLE PATTERN DOTS-456 */
+#define XK_braille_dots_1456 0x1002839     /* U+2839 BRAILLE PATTERN DOTS-1456 */
+#define XK_braille_dots_2456 0x100283a     /* U+283a BRAILLE PATTERN DOTS-2456 */
+#define XK_braille_dots_12456 0x100283b    /* U+283b BRAILLE PATTERN DOTS-12456 */
+#define XK_braille_dots_3456 0x100283c     /* U+283c BRAILLE PATTERN DOTS-3456 */
+#define XK_braille_dots_13456 0x100283d    /* U+283d BRAILLE PATTERN DOTS-13456 */
+#define XK_braille_dots_23456 0x100283e    /* U+283e BRAILLE PATTERN DOTS-23456 */
+#define XK_braille_dots_123456 0x100283f   /* U+283f BRAILLE PATTERN DOTS-123456 */
+#define XK_braille_dots_7 0x1002840        /* U+2840 BRAILLE PATTERN DOTS-7 */
+#define XK_braille_dots_17 0x1002841       /* U+2841 BRAILLE PATTERN DOTS-17 */
+#define XK_braille_dots_27 0x1002842       /* U+2842 BRAILLE PATTERN DOTS-27 */
+#define XK_braille_dots_127 0x1002843      /* U+2843 BRAILLE PATTERN DOTS-127 */
+#define XK_braille_dots_37 0x1002844       /* U+2844 BRAILLE PATTERN DOTS-37 */
+#define XK_braille_dots_137 0x1002845      /* U+2845 BRAILLE PATTERN DOTS-137 */
+#define XK_braille_dots_237 0x1002846      /* U+2846 BRAILLE PATTERN DOTS-237 */
+#define XK_braille_dots_1237 0x1002847     /* U+2847 BRAILLE PATTERN DOTS-1237 */
+#define XK_braille_dots_47 0x1002848       /* U+2848 BRAILLE PATTERN DOTS-47 */
+#define XK_braille_dots_147 0x1002849      /* U+2849 BRAILLE PATTERN DOTS-147 */
+#define XK_braille_dots_247 0x100284a      /* U+284a BRAILLE PATTERN DOTS-247 */
+#define XK_braille_dots_1247 0x100284b     /* U+284b BRAILLE PATTERN DOTS-1247 */
+#define XK_braille_dots_347 0x100284c      /* U+284c BRAILLE PATTERN DOTS-347 */
+#define XK_braille_dots_1347 0x100284d     /* U+284d BRAILLE PATTERN DOTS-1347 */
+#define XK_braille_dots_2347 0x100284e     /* U+284e BRAILLE PATTERN DOTS-2347 */
+#define XK_braille_dots_12347 0x100284f    /* U+284f BRAILLE PATTERN DOTS-12347 */
+#define XK_braille_dots_57 0x1002850       /* U+2850 BRAILLE PATTERN DOTS-57 */
+#define XK_braille_dots_157 0x1002851      /* U+2851 BRAILLE PATTERN DOTS-157 */
+#define XK_braille_dots_257 0x1002852      /* U+2852 BRAILLE PATTERN DOTS-257 */
+#define XK_braille_dots_1257 0x1002853     /* U+2853 BRAILLE PATTERN DOTS-1257 */
+#define XK_braille_dots_357 0x1002854      /* U+2854 BRAILLE PATTERN DOTS-357 */
+#define XK_braille_dots_1357 0x1002855     /* U+2855 BRAILLE PATTERN DOTS-1357 */
+#define XK_braille_dots_2357 0x1002856     /* U+2856 BRAILLE PATTERN DOTS-2357 */
+#define XK_braille_dots_12357 0x1002857    /* U+2857 BRAILLE PATTERN DOTS-12357 */
+#define XK_braille_dots_457 0x1002858      /* U+2858 BRAILLE PATTERN DOTS-457 */
+#define XK_braille_dots_1457 0x1002859     /* U+2859 BRAILLE PATTERN DOTS-1457 */
+#define XK_braille_dots_2457 0x100285a     /* U+285a BRAILLE PATTERN DOTS-2457 */
+#define XK_braille_dots_12457 0x100285b    /* U+285b BRAILLE PATTERN DOTS-12457 */
+#define XK_braille_dots_3457 0x100285c     /* U+285c BRAILLE PATTERN DOTS-3457 */
+#define XK_braille_dots_13457 0x100285d    /* U+285d BRAILLE PATTERN DOTS-13457 */
+#define XK_braille_dots_23457 0x100285e    /* U+285e BRAILLE PATTERN DOTS-23457 */
+#define XK_braille_dots_123457 0x100285f   /* U+285f BRAILLE PATTERN DOTS-123457 */
+#define XK_braille_dots_67 0x1002860       /* U+2860 BRAILLE PATTERN DOTS-67 */
+#define XK_braille_dots_167 0x1002861      /* U+2861 BRAILLE PATTERN DOTS-167 */
+#define XK_braille_dots_267 0x1002862      /* U+2862 BRAILLE PATTERN DOTS-267 */
+#define XK_braille_dots_1267 0x1002863     /* U+2863 BRAILLE PATTERN DOTS-1267 */
+#define XK_braille_dots_367 0x1002864      /* U+2864 BRAILLE PATTERN DOTS-367 */
+#define XK_braille_dots_1367 0x1002865     /* U+2865 BRAILLE PATTERN DOTS-1367 */
+#define XK_braille_dots_2367 0x1002866     /* U+2866 BRAILLE PATTERN DOTS-2367 */
+#define XK_braille_dots_12367 0x1002867    /* U+2867 BRAILLE PATTERN DOTS-12367 */
+#define XK_braille_dots_467 0x1002868      /* U+2868 BRAILLE PATTERN DOTS-467 */
+#define XK_braille_dots_1467 0x1002869     /* U+2869 BRAILLE PATTERN DOTS-1467 */
+#define XK_braille_dots_2467 0x100286a     /* U+286a BRAILLE PATTERN DOTS-2467 */
+#define XK_braille_dots_12467 0x100286b    /* U+286b BRAILLE PATTERN DOTS-12467 */
+#define XK_braille_dots_3467 0x100286c     /* U+286c BRAILLE PATTERN DOTS-3467 */
+#define XK_braille_dots_13467 0x100286d    /* U+286d BRAILLE PATTERN DOTS-13467 */
+#define XK_braille_dots_23467 0x100286e    /* U+286e BRAILLE PATTERN DOTS-23467 */
+#define XK_braille_dots_123467 0x100286f   /* U+286f BRAILLE PATTERN DOTS-123467 */
+#define XK_braille_dots_567 0x1002870      /* U+2870 BRAILLE PATTERN DOTS-567 */
+#define XK_braille_dots_1567 0x1002871     /* U+2871 BRAILLE PATTERN DOTS-1567 */
+#define XK_braille_dots_2567 0x1002872     /* U+2872 BRAILLE PATTERN DOTS-2567 */
+#define XK_braille_dots_12567 0x1002873    /* U+2873 BRAILLE PATTERN DOTS-12567 */
+#define XK_braille_dots_3567 0x1002874     /* U+2874 BRAILLE PATTERN DOTS-3567 */
+#define XK_braille_dots_13567 0x1002875    /* U+2875 BRAILLE PATTERN DOTS-13567 */
+#define XK_braille_dots_23567 0x1002876    /* U+2876 BRAILLE PATTERN DOTS-23567 */
+#define XK_braille_dots_123567 0x1002877   /* U+2877 BRAILLE PATTERN DOTS-123567 */
+#define XK_braille_dots_4567 0x1002878     /* U+2878 BRAILLE PATTERN DOTS-4567 */
+#define XK_braille_dots_14567 0x1002879    /* U+2879 BRAILLE PATTERN DOTS-14567 */
+#define XK_braille_dots_24567 0x100287a    /* U+287a BRAILLE PATTERN DOTS-24567 */
+#define XK_braille_dots_124567 0x100287b   /* U+287b BRAILLE PATTERN DOTS-124567 */
+#define XK_braille_dots_34567 0x100287c    /* U+287c BRAILLE PATTERN DOTS-34567 */
+#define XK_braille_dots_134567 0x100287d   /* U+287d BRAILLE PATTERN DOTS-134567 */
+#define XK_braille_dots_234567 0x100287e   /* U+287e BRAILLE PATTERN DOTS-234567 */
+#define XK_braille_dots_1234567 0x100287f  /* U+287f BRAILLE PATTERN DOTS-1234567 */
+#define XK_braille_dots_8 0x1002880        /* U+2880 BRAILLE PATTERN DOTS-8 */
+#define XK_braille_dots_18 0x1002881       /* U+2881 BRAILLE PATTERN DOTS-18 */
+#define XK_braille_dots_28 0x1002882       /* U+2882 BRAILLE PATTERN DOTS-28 */
+#define XK_braille_dots_128 0x1002883      /* U+2883 BRAILLE PATTERN DOTS-128 */
+#define XK_braille_dots_38 0x1002884       /* U+2884 BRAILLE PATTERN DOTS-38 */
+#define XK_braille_dots_138 0x1002885      /* U+2885 BRAILLE PATTERN DOTS-138 */
+#define XK_braille_dots_238 0x1002886      /* U+2886 BRAILLE PATTERN DOTS-238 */
+#define XK_braille_dots_1238 0x1002887     /* U+2887 BRAILLE PATTERN DOTS-1238 */
+#define XK_braille_dots_48 0x1002888       /* U+2888 BRAILLE PATTERN DOTS-48 */
+#define XK_braille_dots_148 0x1002889      /* U+2889 BRAILLE PATTERN DOTS-148 */
+#define XK_braille_dots_248 0x100288a      /* U+288a BRAILLE PATTERN DOTS-248 */
+#define XK_braille_dots_1248 0x100288b     /* U+288b BRAILLE PATTERN DOTS-1248 */
+#define XK_braille_dots_348 0x100288c      /* U+288c BRAILLE PATTERN DOTS-348 */
+#define XK_braille_dots_1348 0x100288d     /* U+288d BRAILLE PATTERN DOTS-1348 */
+#define XK_braille_dots_2348 0x100288e     /* U+288e BRAILLE PATTERN DOTS-2348 */
+#define XK_braille_dots_12348 0x100288f    /* U+288f BRAILLE PATTERN DOTS-12348 */
+#define XK_braille_dots_58 0x1002890       /* U+2890 BRAILLE PATTERN DOTS-58 */
+#define XK_braille_dots_158 0x1002891      /* U+2891 BRAILLE PATTERN DOTS-158 */
+#define XK_braille_dots_258 0x1002892      /* U+2892 BRAILLE PATTERN DOTS-258 */
+#define XK_braille_dots_1258 0x1002893     /* U+2893 BRAILLE PATTERN DOTS-1258 */
+#define XK_braille_dots_358 0x1002894      /* U+2894 BRAILLE PATTERN DOTS-358 */
+#define XK_braille_dots_1358 0x1002895     /* U+2895 BRAILLE PATTERN DOTS-1358 */
+#define XK_braille_dots_2358 0x1002896     /* U+2896 BRAILLE PATTERN DOTS-2358 */
+#define XK_braille_dots_12358 0x1002897    /* U+2897 BRAILLE PATTERN DOTS-12358 */
+#define XK_braille_dots_458 0x1002898      /* U+2898 BRAILLE PATTERN DOTS-458 */
+#define XK_braille_dots_1458 0x1002899     /* U+2899 BRAILLE PATTERN DOTS-1458 */
+#define XK_braille_dots_2458 0x100289a     /* U+289a BRAILLE PATTERN DOTS-2458 */
+#define XK_braille_dots_12458 0x100289b    /* U+289b BRAILLE PATTERN DOTS-12458 */
+#define XK_braille_dots_3458 0x100289c     /* U+289c BRAILLE PATTERN DOTS-3458 */
+#define XK_braille_dots_13458 0x100289d    /* U+289d BRAILLE PATTERN DOTS-13458 */
+#define XK_braille_dots_23458 0x100289e    /* U+289e BRAILLE PATTERN DOTS-23458 */
+#define XK_braille_dots_123458 0x100289f   /* U+289f BRAILLE PATTERN DOTS-123458 */
+#define XK_braille_dots_68 0x10028a0       /* U+28a0 BRAILLE PATTERN DOTS-68 */
+#define XK_braille_dots_168 0x10028a1      /* U+28a1 BRAILLE PATTERN DOTS-168 */
+#define XK_braille_dots_268 0x10028a2      /* U+28a2 BRAILLE PATTERN DOTS-268 */
+#define XK_braille_dots_1268 0x10028a3     /* U+28a3 BRAILLE PATTERN DOTS-1268 */
+#define XK_braille_dots_368 0x10028a4      /* U+28a4 BRAILLE PATTERN DOTS-368 */
+#define XK_braille_dots_1368 0x10028a5     /* U+28a5 BRAILLE PATTERN DOTS-1368 */
+#define XK_braille_dots_2368 0x10028a6     /* U+28a6 BRAILLE PATTERN DOTS-2368 */
+#define XK_braille_dots_12368 0x10028a7    /* U+28a7 BRAILLE PATTERN DOTS-12368 */
+#define XK_braille_dots_468 0x10028a8      /* U+28a8 BRAILLE PATTERN DOTS-468 */
+#define XK_braille_dots_1468 0x10028a9     /* U+28a9 BRAILLE PATTERN DOTS-1468 */
+#define XK_braille_dots_2468 0x10028aa     /* U+28aa BRAILLE PATTERN DOTS-2468 */
+#define XK_braille_dots_12468 0x10028ab    /* U+28ab BRAILLE PATTERN DOTS-12468 */
+#define XK_braille_dots_3468 0x10028ac     /* U+28ac BRAILLE PATTERN DOTS-3468 */
+#define XK_braille_dots_13468 0x10028ad    /* U+28ad BRAILLE PATTERN DOTS-13468 */
+#define XK_braille_dots_23468 0x10028ae    /* U+28ae BRAILLE PATTERN DOTS-23468 */
+#define XK_braille_dots_123468 0x10028af   /* U+28af BRAILLE PATTERN DOTS-123468 */
+#define XK_braille_dots_568 0x10028b0      /* U+28b0 BRAILLE PATTERN DOTS-568 */
+#define XK_braille_dots_1568 0x10028b1     /* U+28b1 BRAILLE PATTERN DOTS-1568 */
+#define XK_braille_dots_2568 0x10028b2     /* U+28b2 BRAILLE PATTERN DOTS-2568 */
+#define XK_braille_dots_12568 0x10028b3    /* U+28b3 BRAILLE PATTERN DOTS-12568 */
+#define XK_braille_dots_3568 0x10028b4     /* U+28b4 BRAILLE PATTERN DOTS-3568 */
+#define XK_braille_dots_13568 0x10028b5    /* U+28b5 BRAILLE PATTERN DOTS-13568 */
+#define XK_braille_dots_23568 0x10028b6    /* U+28b6 BRAILLE PATTERN DOTS-23568 */
+#define XK_braille_dots_123568 0x10028b7   /* U+28b7 BRAILLE PATTERN DOTS-123568 */
+#define XK_braille_dots_4568 0x10028b8     /* U+28b8 BRAILLE PATTERN DOTS-4568 */
+#define XK_braille_dots_14568 0x10028b9    /* U+28b9 BRAILLE PATTERN DOTS-14568 */
+#define XK_braille_dots_24568 0x10028ba    /* U+28ba BRAILLE PATTERN DOTS-24568 */
+#define XK_braille_dots_124568 0x10028bb   /* U+28bb BRAILLE PATTERN DOTS-124568 */
+#define XK_braille_dots_34568 0x10028bc    /* U+28bc BRAILLE PATTERN DOTS-34568 */
+#define XK_braille_dots_134568 0x10028bd   /* U+28bd BRAILLE PATTERN DOTS-134568 */
+#define XK_braille_dots_234568 0x10028be   /* U+28be BRAILLE PATTERN DOTS-234568 */
+#define XK_braille_dots_1234568 0x10028bf  /* U+28bf BRAILLE PATTERN DOTS-1234568 */
+#define XK_braille_dots_78 0x10028c0       /* U+28c0 BRAILLE PATTERN DOTS-78 */
+#define XK_braille_dots_178 0x10028c1      /* U+28c1 BRAILLE PATTERN DOTS-178 */
+#define XK_braille_dots_278 0x10028c2      /* U+28c2 BRAILLE PATTERN DOTS-278 */
+#define XK_braille_dots_1278 0x10028c3     /* U+28c3 BRAILLE PATTERN DOTS-1278 */
+#define XK_braille_dots_378 0x10028c4      /* U+28c4 BRAILLE PATTERN DOTS-378 */
+#define XK_braille_dots_1378 0x10028c5     /* U+28c5 BRAILLE PATTERN DOTS-1378 */
+#define XK_braille_dots_2378 0x10028c6     /* U+28c6 BRAILLE PATTERN DOTS-2378 */
+#define XK_braille_dots_12378 0x10028c7    /* U+28c7 BRAILLE PATTERN DOTS-12378 */
+#define XK_braille_dots_478 0x10028c8      /* U+28c8 BRAILLE PATTERN DOTS-478 */
+#define XK_braille_dots_1478 0x10028c9     /* U+28c9 BRAILLE PATTERN DOTS-1478 */
+#define XK_braille_dots_2478 0x10028ca     /* U+28ca BRAILLE PATTERN DOTS-2478 */
+#define XK_braille_dots_12478 0x10028cb    /* U+28cb BRAILLE PATTERN DOTS-12478 */
+#define XK_braille_dots_3478 0x10028cc     /* U+28cc BRAILLE PATTERN DOTS-3478 */
+#define XK_braille_dots_13478 0x10028cd    /* U+28cd BRAILLE PATTERN DOTS-13478 */
+#define XK_braille_dots_23478 0x10028ce    /* U+28ce BRAILLE PATTERN DOTS-23478 */
+#define XK_braille_dots_123478 0x10028cf   /* U+28cf BRAILLE PATTERN DOTS-123478 */
+#define XK_braille_dots_578 0x10028d0      /* U+28d0 BRAILLE PATTERN DOTS-578 */
+#define XK_braille_dots_1578 0x10028d1     /* U+28d1 BRAILLE PATTERN DOTS-1578 */
+#define XK_braille_dots_2578 0x10028d2     /* U+28d2 BRAILLE PATTERN DOTS-2578 */
+#define XK_braille_dots_12578 0x10028d3    /* U+28d3 BRAILLE PATTERN DOTS-12578 */
+#define XK_braille_dots_3578 0x10028d4     /* U+28d4 BRAILLE PATTERN DOTS-3578 */
+#define XK_braille_dots_13578 0x10028d5    /* U+28d5 BRAILLE PATTERN DOTS-13578 */
+#define XK_braille_dots_23578 0x10028d6    /* U+28d6 BRAILLE PATTERN DOTS-23578 */
+#define XK_braille_dots_123578 0x10028d7   /* U+28d7 BRAILLE PATTERN DOTS-123578 */
+#define XK_braille_dots_4578 0x10028d8     /* U+28d8 BRAILLE PATTERN DOTS-4578 */
+#define XK_braille_dots_14578 0x10028d9    /* U+28d9 BRAILLE PATTERN DOTS-14578 */
+#define XK_braille_dots_24578 0x10028da    /* U+28da BRAILLE PATTERN DOTS-24578 */
+#define XK_braille_dots_124578 0x10028db   /* U+28db BRAILLE PATTERN DOTS-124578 */
+#define XK_braille_dots_34578 0x10028dc    /* U+28dc BRAILLE PATTERN DOTS-34578 */
+#define XK_braille_dots_134578 0x10028dd   /* U+28dd BRAILLE PATTERN DOTS-134578 */
+#define XK_braille_dots_234578 0x10028de   /* U+28de BRAILLE PATTERN DOTS-234578 */
+#define XK_braille_dots_1234578 0x10028df  /* U+28df BRAILLE PATTERN DOTS-1234578 */
+#define XK_braille_dots_678 0x10028e0      /* U+28e0 BRAILLE PATTERN DOTS-678 */
+#define XK_braille_dots_1678 0x10028e1     /* U+28e1 BRAILLE PATTERN DOTS-1678 */
+#define XK_braille_dots_2678 0x10028e2     /* U+28e2 BRAILLE PATTERN DOTS-2678 */
+#define XK_braille_dots_12678 0x10028e3    /* U+28e3 BRAILLE PATTERN DOTS-12678 */
+#define XK_braille_dots_3678 0x10028e4     /* U+28e4 BRAILLE PATTERN DOTS-3678 */
+#define XK_braille_dots_13678 0x10028e5    /* U+28e5 BRAILLE PATTERN DOTS-13678 */
+#define XK_braille_dots_23678 0x10028e6    /* U+28e6 BRAILLE PATTERN DOTS-23678 */
+#define XK_braille_dots_123678 0x10028e7   /* U+28e7 BRAILLE PATTERN DOTS-123678 */
+#define XK_braille_dots_4678 0x10028e8     /* U+28e8 BRAILLE PATTERN DOTS-4678 */
+#define XK_braille_dots_14678 0x10028e9    /* U+28e9 BRAILLE PATTERN DOTS-14678 */
+#define XK_braille_dots_24678 0x10028ea    /* U+28ea BRAILLE PATTERN DOTS-24678 */
+#define XK_braille_dots_124678 0x10028eb   /* U+28eb BRAILLE PATTERN DOTS-124678 */
+#define XK_braille_dots_34678 0x10028ec    /* U+28ec BRAILLE PATTERN DOTS-34678 */
+#define XK_braille_dots_134678 0x10028ed   /* U+28ed BRAILLE PATTERN DOTS-134678 */
+#define XK_braille_dots_234678 0x10028ee   /* U+28ee BRAILLE PATTERN DOTS-234678 */
+#define XK_braille_dots_1234678 0x10028ef  /* U+28ef BRAILLE PATTERN DOTS-1234678 */
+#define XK_braille_dots_5678 0x10028f0     /* U+28f0 BRAILLE PATTERN DOTS-5678 */
+#define XK_braille_dots_15678 0x10028f1    /* U+28f1 BRAILLE PATTERN DOTS-15678 */
+#define XK_braille_dots_25678 0x10028f2    /* U+28f2 BRAILLE PATTERN DOTS-25678 */
+#define XK_braille_dots_125678 0x10028f3   /* U+28f3 BRAILLE PATTERN DOTS-125678 */
+#define XK_braille_dots_35678 0x10028f4    /* U+28f4 BRAILLE PATTERN DOTS-35678 */
+#define XK_braille_dots_135678 0x10028f5   /* U+28f5 BRAILLE PATTERN DOTS-135678 */
+#define XK_braille_dots_235678 0x10028f6   /* U+28f6 BRAILLE PATTERN DOTS-235678 */
+#define XK_braille_dots_1235678 0x10028f7  /* U+28f7 BRAILLE PATTERN DOTS-1235678 */
+#define XK_braille_dots_45678 0x10028f8    /* U+28f8 BRAILLE PATTERN DOTS-45678 */
+#define XK_braille_dots_145678 0x10028f9   /* U+28f9 BRAILLE PATTERN DOTS-145678 */
+#define XK_braille_dots_245678 0x10028fa   /* U+28fa BRAILLE PATTERN DOTS-245678 */
+#define XK_braille_dots_1245678 0x10028fb  /* U+28fb BRAILLE PATTERN DOTS-1245678 */
+#define XK_braille_dots_345678 0x10028fc   /* U+28fc BRAILLE PATTERN DOTS-345678 */
+#define XK_braille_dots_1345678 0x10028fd  /* U+28fd BRAILLE PATTERN DOTS-1345678 */
+#define XK_braille_dots_2345678 0x10028fe  /* U+28fe BRAILLE PATTERN DOTS-2345678 */
+#define XK_braille_dots_12345678 0x10028ff /* U+28ff BRAILLE PATTERN DOTS-12345678 */
+#endif                                     /* XK_BRAILLE */
+
+/*
+ * Sinhala (http://unicode.org/charts/PDF/U0D80.pdf)
+ * http://www.nongnu.org/sinhala/doc/transliteration/sinhala-transliteration_6.html
+ */
+
+#ifdef XK_SINHALA
+#define XK_Sinh_ng 0x1000d82         /* U+0D82 SINHALA ANUSVARAYA */
+#define XK_Sinh_h2 0x1000d83         /* U+0D83 SINHALA VISARGAYA */
+#define XK_Sinh_a 0x1000d85          /* U+0D85 SINHALA AYANNA */
+#define XK_Sinh_aa 0x1000d86         /* U+0D86 SINHALA AAYANNA */
+#define XK_Sinh_ae 0x1000d87         /* U+0D87 SINHALA AEYANNA */
+#define XK_Sinh_aee 0x1000d88        /* U+0D88 SINHALA AEEYANNA */
+#define XK_Sinh_i 0x1000d89          /* U+0D89 SINHALA IYANNA */
+#define XK_Sinh_ii 0x1000d8a         /* U+0D8A SINHALA IIYANNA */
+#define XK_Sinh_u 0x1000d8b          /* U+0D8B SINHALA UYANNA */
+#define XK_Sinh_uu 0x1000d8c         /* U+0D8C SINHALA UUYANNA */
+#define XK_Sinh_ri 0x1000d8d         /* U+0D8D SINHALA IRUYANNA */
+#define XK_Sinh_rii 0x1000d8e        /* U+0D8E SINHALA IRUUYANNA */
+#define XK_Sinh_lu 0x1000d8f         /* U+0D8F SINHALA ILUYANNA */
+#define XK_Sinh_luu 0x1000d90        /* U+0D90 SINHALA ILUUYANNA */
+#define XK_Sinh_e 0x1000d91          /* U+0D91 SINHALA EYANNA */
+#define XK_Sinh_ee 0x1000d92         /* U+0D92 SINHALA EEYANNA */
+#define XK_Sinh_ai 0x1000d93         /* U+0D93 SINHALA AIYANNA */
+#define XK_Sinh_o 0x1000d94          /* U+0D94 SINHALA OYANNA */
+#define XK_Sinh_oo 0x1000d95         /* U+0D95 SINHALA OOYANNA */
+#define XK_Sinh_au 0x1000d96         /* U+0D96 SINHALA AUYANNA */
+#define XK_Sinh_ka 0x1000d9a         /* U+0D9A SINHALA KAYANNA */
+#define XK_Sinh_kha 0x1000d9b        /* U+0D9B SINHALA MAHA. KAYANNA */
+#define XK_Sinh_ga 0x1000d9c         /* U+0D9C SINHALA GAYANNA */
+#define XK_Sinh_gha 0x1000d9d        /* U+0D9D SINHALA MAHA. GAYANNA */
+#define XK_Sinh_ng2 0x1000d9e        /* U+0D9E SINHALA KANTAJA NAASIKYAYA */
+#define XK_Sinh_nga 0x1000d9f        /* U+0D9F SINHALA SANYAKA GAYANNA */
+#define XK_Sinh_ca 0x1000da0         /* U+0DA0 SINHALA CAYANNA */
+#define XK_Sinh_cha 0x1000da1        /* U+0DA1 SINHALA MAHA. CAYANNA */
+#define XK_Sinh_ja 0x1000da2         /* U+0DA2 SINHALA JAYANNA */
+#define XK_Sinh_jha 0x1000da3        /* U+0DA3 SINHALA MAHA. JAYANNA */
+#define XK_Sinh_nya 0x1000da4        /* U+0DA4 SINHALA TAALUJA NAASIKYAYA */
+#define XK_Sinh_jnya 0x1000da5       /* U+0DA5 SINHALA TAALUJA SANYOOGA NAASIKYAYA */
+#define XK_Sinh_nja 0x1000da6        /* U+0DA6 SINHALA SANYAKA JAYANNA */
+#define XK_Sinh_tta 0x1000da7        /* U+0DA7 SINHALA TTAYANNA */
+#define XK_Sinh_ttha 0x1000da8       /* U+0DA8 SINHALA MAHA. TTAYANNA */
+#define XK_Sinh_dda 0x1000da9        /* U+0DA9 SINHALA DDAYANNA */
+#define XK_Sinh_ddha 0x1000daa       /* U+0DAA SINHALA MAHA. DDAYANNA */
+#define XK_Sinh_nna 0x1000dab        /* U+0DAB SINHALA MUURDHAJA NAYANNA */
+#define XK_Sinh_ndda 0x1000dac       /* U+0DAC SINHALA SANYAKA DDAYANNA */
+#define XK_Sinh_tha 0x1000dad        /* U+0DAD SINHALA TAYANNA */
+#define XK_Sinh_thha 0x1000dae       /* U+0DAE SINHALA MAHA. TAYANNA */
+#define XK_Sinh_dha 0x1000daf        /* U+0DAF SINHALA DAYANNA */
+#define XK_Sinh_dhha 0x1000db0       /* U+0DB0 SINHALA MAHA. DAYANNA */
+#define XK_Sinh_na 0x1000db1         /* U+0DB1 SINHALA DANTAJA NAYANNA */
+#define XK_Sinh_ndha 0x1000db3       /* U+0DB3 SINHALA SANYAKA DAYANNA */
+#define XK_Sinh_pa 0x1000db4         /* U+0DB4 SINHALA PAYANNA */
+#define XK_Sinh_pha 0x1000db5        /* U+0DB5 SINHALA MAHA. PAYANNA */
+#define XK_Sinh_ba 0x1000db6         /* U+0DB6 SINHALA BAYANNA */
+#define XK_Sinh_bha 0x1000db7        /* U+0DB7 SINHALA MAHA. BAYANNA */
+#define XK_Sinh_ma 0x1000db8         /* U+0DB8 SINHALA MAYANNA */
+#define XK_Sinh_mba 0x1000db9        /* U+0DB9 SINHALA AMBA BAYANNA */
+#define XK_Sinh_ya 0x1000dba         /* U+0DBA SINHALA YAYANNA */
+#define XK_Sinh_ra 0x1000dbb         /* U+0DBB SINHALA RAYANNA */
+#define XK_Sinh_la 0x1000dbd         /* U+0DBD SINHALA DANTAJA LAYANNA */
+#define XK_Sinh_va 0x1000dc0         /* U+0DC0 SINHALA VAYANNA */
+#define XK_Sinh_sha 0x1000dc1        /* U+0DC1 SINHALA TAALUJA SAYANNA */
+#define XK_Sinh_ssha 0x1000dc2       /* U+0DC2 SINHALA MUURDHAJA SAYANNA */
+#define XK_Sinh_sa 0x1000dc3         /* U+0DC3 SINHALA DANTAJA SAYANNA */
+#define XK_Sinh_ha 0x1000dc4         /* U+0DC4 SINHALA HAYANNA */
+#define XK_Sinh_lla 0x1000dc5        /* U+0DC5 SINHALA MUURDHAJA LAYANNA */
+#define XK_Sinh_fa 0x1000dc6         /* U+0DC6 SINHALA FAYANNA */
+#define XK_Sinh_al 0x1000dca         /* U+0DCA SINHALA AL-LAKUNA */
+#define XK_Sinh_aa2 0x1000dcf        /* U+0DCF SINHALA AELA-PILLA */
+#define XK_Sinh_ae2 0x1000dd0        /* U+0DD0 SINHALA AEDA-PILLA */
+#define XK_Sinh_aee2 0x1000dd1       /* U+0DD1 SINHALA DIGA AEDA-PILLA */
+#define XK_Sinh_i2 0x1000dd2         /* U+0DD2 SINHALA IS-PILLA */
+#define XK_Sinh_ii2 0x1000dd3        /* U+0DD3 SINHALA DIGA IS-PILLA */
+#define XK_Sinh_u2 0x1000dd4         /* U+0DD4 SINHALA PAA-PILLA */
+#define XK_Sinh_uu2 0x1000dd6        /* U+0DD6 SINHALA DIGA PAA-PILLA */
+#define XK_Sinh_ru2 0x1000dd8        /* U+0DD8 SINHALA GAETTA-PILLA */
+#define XK_Sinh_e2 0x1000dd9         /* U+0DD9 SINHALA KOMBUVA */
+#define XK_Sinh_ee2 0x1000dda        /* U+0DDA SINHALA DIGA KOMBUVA */
+#define XK_Sinh_ai2 0x1000ddb        /* U+0DDB SINHALA KOMBU DEKA */
+#define XK_Sinh_o2 0x1000ddc         /* U+0DDC SINHALA KOMBUVA HAA AELA-PILLA*/
+#define XK_Sinh_oo2 0x1000ddd        /* U+0DDD SINHALA KOMBUVA HAA DIGA AELA-PILLA*/
+#define XK_Sinh_au2 0x1000dde        /* U+0DDE SINHALA KOMBUVA HAA GAYANUKITTA */
+#define XK_Sinh_lu2 0x1000ddf        /* U+0DDF SINHALA GAYANUKITTA */
+#define XK_Sinh_ruu2 0x1000df2       /* U+0DF2 SINHALA DIGA GAETTA-PILLA */
+#define XK_Sinh_luu2 0x1000df3       /* U+0DF3 SINHALA DIGA GAYANUKITTA */
+#define XK_Sinh_kunddaliya 0x1000df4 /* U+0DF4 SINHALA KUNDDALIYA */
+#endif                               /* XK_SINHALA */
diff --git a/engine/inc/bullet/ThirdPartyLibs/serial/include/serial/impl/unix.h b/engine/inc/bullet/ThirdPartyLibs/serial/include/serial/impl/unix.h
new file mode 100644
index 00000000..94cf15cf
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/serial/include/serial/impl/unix.h
@@ -0,0 +1,223 @@
+/*!
+ * \file serial/impl/unix.h
+ * \author  William Woodall <wjwwood@gmail.com>
+ * \author  John Harrison <ash@greaterthaninfinity.com>
+ * \version 0.1
+ *
+ * \section LICENSE
+ *
+ * The MIT License
+ *
+ * Copyright (c) 2012 William Woodall, John Harrison
+ *
+ * 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.
+ *
+ * \section DESCRIPTION
+ *
+ * This provides a unix based pimpl for the Serial class. This implementation is
+ * based off termios.h and uses select for multiplexing the IO ports.
+ *
+ */
+
+#if !defined(_WIN32)
+
+#ifndef SERIAL_IMPL_UNIX_H
+#define SERIAL_IMPL_UNIX_H
+
+#include "serial/serial.h"
+
+#include <pthread.h>
+
+namespace serial
+{
+using std::invalid_argument;
+using std::size_t;
+using std::string;
+
+using serial::IOException;
+using serial::SerialException;
+
+class MillisecondTimer
+{
+public:
+	MillisecondTimer(const uint32_t millis);
+	int64_t remaining();
+
+private:
+	static timespec timespec_now();
+	timespec expiry;
+};
+
+class serial::Serial::SerialImpl
+{
+public:
+	SerialImpl(const string &port,
+			   unsigned long baudrate,
+			   bytesize_t bytesize,
+			   parity_t parity,
+			   stopbits_t stopbits,
+			   flowcontrol_t flowcontrol);
+
+	virtual ~SerialImpl();
+
+	void
+	open();
+
+	void
+	close();
+
+	bool
+	isOpen() const;
+
+	size_t
+	available();
+
+	bool
+	waitReadable(uint32_t timeout);
+
+	void
+	waitByteTimes(size_t count);
+
+	size_t
+	read(uint8_t *buf, size_t size = 1);
+
+	size_t
+	write(const uint8_t *data, size_t length);
+
+	void
+	flush();
+
+	void
+	flushInput();
+
+	void
+	flushOutput();
+
+	void
+	sendBreak(int duration);
+
+	void
+	setBreak(bool level);
+
+	void
+	setRTS(bool level);
+
+	void
+	setDTR(bool level);
+
+	bool
+	waitForChange();
+
+	bool
+	getCTS();
+
+	bool
+	getDSR();
+
+	bool
+	getRI();
+
+	bool
+	getCD();
+
+	void
+	setPort(const string &port);
+
+	string
+	getPort() const;
+
+	void
+	setTimeout(Timeout &timeout);
+
+	Timeout
+	getTimeout() const;
+
+	void
+	setBaudrate(unsigned long baudrate);
+
+	unsigned long
+	getBaudrate() const;
+
+	void
+	setBytesize(bytesize_t bytesize);
+
+	bytesize_t
+	getBytesize() const;
+
+	void
+	setParity(parity_t parity);
+
+	parity_t
+	getParity() const;
+
+	void
+	setStopbits(stopbits_t stopbits);
+
+	stopbits_t
+	getStopbits() const;
+
+	void
+	setFlowcontrol(flowcontrol_t flowcontrol);
+
+	flowcontrol_t
+	getFlowcontrol() const;
+
+	void
+	readLock();
+
+	void
+	readUnlock();
+
+	void
+	writeLock();
+
+	void
+	writeUnlock();
+
+protected:
+	void reconfigurePort();
+
+private:
+	string port_;  // Path to the file descriptor
+	int fd_;       // The current file descriptor
+
+	bool is_open_;
+	bool xonxoff_;
+	bool rtscts_;
+
+	Timeout timeout_;         // Timeout for read operations
+	unsigned long baudrate_;  // Baudrate
+	uint32_t byte_time_ns_;   // Nanoseconds to transmit/receive a single byte
+
+	parity_t parity_;            // Parity
+	bytesize_t bytesize_;        // Size of the bytes
+	stopbits_t stopbits_;        // Stop Bits
+	flowcontrol_t flowcontrol_;  // Flow Control
+
+	// Mutex used to lock the read functions
+	pthread_mutex_t read_mutex;
+	// Mutex used to lock the write functions
+	pthread_mutex_t write_mutex;
+};
+
+}  // namespace serial
+
+#endif  // SERIAL_IMPL_UNIX_H
+
+#endif  // !defined(_WIN32)
diff --git a/engine/inc/bullet/ThirdPartyLibs/serial/include/serial/impl/win.h b/engine/inc/bullet/ThirdPartyLibs/serial/include/serial/impl/win.h
new file mode 100644
index 00000000..2e7b9749
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/serial/include/serial/impl/win.h
@@ -0,0 +1,208 @@
+/*!
+ * \file serial/impl/windows.h
+ * \author  William Woodall <wjwwood@gmail.com>
+ * \author  John Harrison <ash@greaterthaninfinity.com>
+ * \version 0.1
+ *
+ * \section LICENSE
+ *
+ * The MIT License
+ *
+ * Copyright (c) 2012 William Woodall, John Harrison
+ *
+ * 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.
+ *
+ * \section DESCRIPTION
+ *
+ * This provides a windows implementation of the Serial class interface.
+ *
+ */
+
+#if defined(_WIN32)
+
+#ifndef SERIAL_IMPL_WINDOWS_H
+#define SERIAL_IMPL_WINDOWS_H
+
+#include "serial/serial.h"
+
+#include "windows.h"
+
+namespace serial
+{
+using std::invalid_argument;
+using std::string;
+using std::wstring;
+
+using serial::IOException;
+using serial::SerialException;
+
+class serial::Serial::SerialImpl
+{
+public:
+	SerialImpl(const string &port,
+			   unsigned long baudrate,
+			   bytesize_t bytesize,
+			   parity_t parity,
+			   stopbits_t stopbits,
+			   flowcontrol_t flowcontrol);
+
+	virtual ~SerialImpl();
+
+	void
+	open();
+
+	void
+	close();
+
+	bool
+	isOpen() const;
+
+	size_t
+	available();
+
+	bool
+	waitReadable(uint32_t timeout);
+
+	void
+	waitByteTimes(size_t count);
+
+	size_t
+	read(uint8_t *buf, size_t size = 1);
+
+	size_t
+	write(const uint8_t *data, size_t length);
+
+	void
+	flush();
+
+	void
+	flushInput();
+
+	void
+	flushOutput();
+
+	void
+	sendBreak(int duration);
+
+	void
+	setBreak(bool level);
+
+	void
+	setRTS(bool level);
+
+	void
+	setDTR(bool level);
+
+	bool
+	waitForChange();
+
+	bool
+	getCTS();
+
+	bool
+	getDSR();
+
+	bool
+	getRI();
+
+	bool
+	getCD();
+
+	void
+	setPort(const string &port);
+
+	string
+	getPort() const;
+
+	void
+	setTimeout(Timeout &timeout);
+
+	Timeout
+	getTimeout() const;
+
+	void
+	setBaudrate(unsigned long baudrate);
+
+	unsigned long
+	getBaudrate() const;
+
+	void
+	setBytesize(bytesize_t bytesize);
+
+	bytesize_t
+	getBytesize() const;
+
+	void
+	setParity(parity_t parity);
+
+	parity_t
+	getParity() const;
+
+	void
+	setStopbits(stopbits_t stopbits);
+
+	stopbits_t
+	getStopbits() const;
+
+	void
+	setFlowcontrol(flowcontrol_t flowcontrol);
+
+	flowcontrol_t
+	getFlowcontrol() const;
+
+	void
+	readLock();
+
+	void
+	readUnlock();
+
+	void
+	writeLock();
+
+	void
+	writeUnlock();
+
+protected:
+	void reconfigurePort();
+
+private:
+	wstring port_;  // Path to the file descriptor
+	HANDLE fd_;
+
+	bool is_open_;
+
+	Timeout timeout_;         // Timeout for read operations
+	unsigned long baudrate_;  // Baudrate
+
+	parity_t parity_;            // Parity
+	bytesize_t bytesize_;        // Size of the bytes
+	stopbits_t stopbits_;        // Stop Bits
+	flowcontrol_t flowcontrol_;  // Flow Control
+
+	// Mutex used to lock the read functions
+	HANDLE read_mutex;
+	// Mutex used to lock the write functions
+	HANDLE write_mutex;
+};
+
+}  // namespace serial
+
+#endif  // SERIAL_IMPL_WINDOWS_H
+
+#endif  // if defined(_WIN32)
diff --git a/engine/inc/bullet/ThirdPartyLibs/serial/include/serial/serial.h b/engine/inc/bullet/ThirdPartyLibs/serial/include/serial/serial.h
new file mode 100644
index 00000000..b38cb0a3
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/serial/include/serial/serial.h
@@ -0,0 +1,794 @@
+/*!
+ * \file serial/serial.h
+ * \author  William Woodall <wjwwood@gmail.com>
+ * \author  John Harrison   <ash.gti@gmail.com>
+ * \version 0.1
+ *
+ * \section LICENSE
+ *
+ * The MIT License
+ *
+ * Copyright (c) 2012 William Woodall
+ *
+ * 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.
+ *
+ * \section DESCRIPTION
+ *
+ * This provides a cross platform interface for interacting with Serial Ports.
+ */
+
+#ifndef SERIAL_H
+#define SERIAL_H
+
+#include <limits>
+#include <vector>
+#include <string>
+#include <cstring>
+#include <sstream>
+#include <exception>
+#include <stdexcept>
+#include <serial/v8stdint.h>
+
+#define THROW(exceptionClass, message) throw exceptionClass(__FILE__, \
+															__LINE__, (message))
+
+namespace serial
+{
+/*!
+ * Enumeration defines the possible bytesizes for the serial port.
+ */
+typedef enum
+{
+	fivebits = 5,
+	sixbits = 6,
+	sevenbits = 7,
+	eightbits = 8
+} bytesize_t;
+
+/*!
+ * Enumeration defines the possible parity types for the serial port.
+ */
+typedef enum
+{
+	parity_none = 0,
+	parity_odd = 1,
+	parity_even = 2,
+	parity_mark = 3,
+	parity_space = 4
+} parity_t;
+
+/*!
+ * Enumeration defines the possible stopbit types for the serial port.
+ */
+typedef enum
+{
+	stopbits_one = 1,
+	stopbits_two = 2,
+	stopbits_one_point_five
+} stopbits_t;
+
+/*!
+ * Enumeration defines the possible flowcontrol types for the serial port.
+ */
+typedef enum
+{
+	flowcontrol_none = 0,
+	flowcontrol_software,
+	flowcontrol_hardware
+} flowcontrol_t;
+
+/*!
+ * Structure for setting the timeout of the serial port, times are
+ * in milliseconds.
+ *
+ * In order to disable the interbyte timeout, set it to Timeout::max().
+ */
+struct Timeout
+{
+#ifdef max
+#undef max
+#endif
+	static uint32_t max()
+	{
+		return std::numeric_limits<uint32_t>::max();
+	}
+	/*!
+   * Convenience function to generate Timeout structs using a
+   * single absolute timeout.
+   *
+   * \param timeout A long that defines the time in milliseconds until a
+   * timeout occurs after a call to read or write is made.
+   *
+   * \return Timeout struct that represents this simple timeout provided.
+   */
+	static Timeout simpleTimeout(uint32_t timeout)
+	{
+		return Timeout(max(), timeout, 0, timeout, 0);
+	}
+
+	/*! Number of milliseconds between bytes received to timeout on. */
+	uint32_t inter_byte_timeout;
+	/*! A constant number of milliseconds to wait after calling read. */
+	uint32_t read_timeout_constant;
+	/*! A multiplier against the number of requested bytes to wait after
+   *  calling read.
+   */
+	uint32_t read_timeout_multiplier;
+	/*! A constant number of milliseconds to wait after calling write. */
+	uint32_t write_timeout_constant;
+	/*! A multiplier against the number of requested bytes to wait after
+   *  calling write.
+   */
+	uint32_t write_timeout_multiplier;
+
+	explicit Timeout(uint32_t inter_byte_timeout_ = 0,
+					 uint32_t read_timeout_constant_ = 0,
+					 uint32_t read_timeout_multiplier_ = 0,
+					 uint32_t write_timeout_constant_ = 0,
+					 uint32_t write_timeout_multiplier_ = 0)
+		: inter_byte_timeout(inter_byte_timeout_),
+		  read_timeout_constant(read_timeout_constant_),
+		  read_timeout_multiplier(read_timeout_multiplier_),
+		  write_timeout_constant(write_timeout_constant_),
+		  write_timeout_multiplier(write_timeout_multiplier_)
+	{
+	}
+};
+
+/*!
+ * Class that provides a portable serial port interface.
+ */
+class Serial
+{
+public:
+	/*!
+   * Creates a Serial object and opens the port if a port is specified,
+   * otherwise it remains closed until serial::Serial::open is called.
+   *
+   * \param port A std::string containing the address of the serial port,
+   *        which would be something like 'COM1' on Windows and '/dev/ttyS0'
+   *        on Linux.
+   *
+   * \param baudrate An unsigned 32-bit integer that represents the baudrate
+   *
+   * \param timeout A serial::Timeout struct that defines the timeout
+   * conditions for the serial port. \see serial::Timeout
+   *
+   * \param bytesize Size of each byte in the serial transmission of data,
+   * default is eightbits, possible values are: fivebits, sixbits, sevenbits,
+   * eightbits
+   *
+   * \param parity Method of parity, default is parity_none, possible values
+   * are: parity_none, parity_odd, parity_even
+   *
+   * \param stopbits Number of stop bits used, default is stopbits_one,
+   * possible values are: stopbits_one, stopbits_one_point_five, stopbits_two
+   *
+   * \param flowcontrol Type of flowcontrol used, default is
+   * flowcontrol_none, possible values are: flowcontrol_none,
+   * flowcontrol_software, flowcontrol_hardware
+   *
+   * \throw serial::PortNotOpenedException
+   * \throw serial::IOException
+   * \throw std::invalid_argument
+   */
+	Serial(const std::string &port = "",
+		   uint32_t baudrate = 9600,
+		   Timeout timeout = Timeout(),
+		   bytesize_t bytesize = eightbits,
+		   parity_t parity = parity_none,
+		   stopbits_t stopbits = stopbits_one,
+		   flowcontrol_t flowcontrol = flowcontrol_none);
+
+	/*! Destructor */
+	virtual ~Serial();
+
+	/*!
+   * Opens the serial port as long as the port is set and the port isn't
+   * already open.
+   *
+   * If the port is provided to the constructor then an explicit call to open
+   * is not needed.
+   *
+   * \see Serial::Serial
+   *
+   * \throw std::invalid_argument
+   * \throw serial::SerialException
+   * \throw serial::IOException
+   */
+	void
+	open();
+
+	/*! Gets the open status of the serial port.
+   *
+   * \return Returns true if the port is open, false otherwise.
+   */
+	bool
+	isOpen() const;
+
+	/*! Closes the serial port. */
+	void
+	close();
+
+	/*! Return the number of characters in the buffer. */
+	size_t
+	available();
+
+	/*! Block until there is serial data to read or read_timeout_constant
+   * number of milliseconds have elapsed. The return value is true when
+   * the function exits with the port in a readable state, false otherwise
+   * (due to timeout or select interruption). */
+	bool
+	waitReadable();
+
+	/*! Block for a period of time corresponding to the transmission time of
+   * count characters at present serial settings. This may be used in con-
+   * junction with waitReadable to read larger blocks of data from the
+   * port. */
+	void
+	waitByteTimes(size_t count);
+
+	/*! Read a given amount of bytes from the serial port into a given buffer.
+   *
+   * The read function will return in one of three cases:
+   *  * The number of requested bytes was read.
+   *    * In this case the number of bytes requested will match the size_t
+   *      returned by read.
+   *  * A timeout occurred, in this case the number of bytes read will not
+   *    match the amount requested, but no exception will be thrown.  One of
+   *    two possible timeouts occurred:
+   *    * The inter byte timeout expired, this means that number of
+   *      milliseconds elapsed between receiving bytes from the serial port
+   *      exceeded the inter byte timeout.
+   *    * The total timeout expired, which is calculated by multiplying the
+   *      read timeout multiplier by the number of requested bytes and then
+   *      added to the read timeout constant.  If that total number of
+   *      milliseconds elapses after the initial call to read a timeout will
+   *      occur.
+   *  * An exception occurred, in this case an actual exception will be thrown.
+   *
+   * \param buffer An uint8_t array of at least the requested size.
+   * \param size A size_t defining how many bytes to be read.
+   *
+   * \return A size_t representing the number of bytes read as a result of the
+   *         call to read.
+   *
+   * \throw serial::PortNotOpenedException
+   * \throw serial::SerialException
+   */
+	size_t
+	read(uint8_t *buffer, size_t size);
+
+	/*! Read a given amount of bytes from the serial port into a give buffer.
+   *
+   * \param buffer A reference to a std::vector of uint8_t.
+   * \param size A size_t defining how many bytes to be read.
+   *
+   * \return A size_t representing the number of bytes read as a result of the
+   *         call to read.
+   *
+   * \throw serial::PortNotOpenedException
+   * \throw serial::SerialException
+   */
+	size_t
+	read(std::vector<uint8_t> &buffer, size_t size = 1);
+
+	/*! Read a given amount of bytes from the serial port into a give buffer.
+   *
+   * \param buffer A reference to a std::string.
+   * \param size A size_t defining how many bytes to be read.
+   *
+   * \return A size_t representing the number of bytes read as a result of the
+   *         call to read.
+   *
+   * \throw serial::PortNotOpenedException
+   * \throw serial::SerialException
+   */
+	size_t
+	read(std::string &buffer, size_t size = 1);
+
+	/*! Read a given amount of bytes from the serial port and return a string
+   *  containing the data.
+   *
+   * \param size A size_t defining how many bytes to be read.
+   *
+   * \return A std::string containing the data read from the port.
+   *
+   * \throw serial::PortNotOpenedException
+   * \throw serial::SerialException
+   */
+	std::string
+	read(size_t size = 1);
+
+	/*! Reads in a line or until a given delimiter has been processed.
+   *
+   * Reads from the serial port until a single line has been read.
+   *
+   * \param buffer A std::string reference used to store the data.
+   * \param size A maximum length of a line, defaults to 65536 (2^16)
+   * \param eol A string to match against for the EOL.
+   *
+   * \return A size_t representing the number of bytes read.
+   *
+   * \throw serial::PortNotOpenedException
+   * \throw serial::SerialException
+   */
+	size_t
+	readline(std::string &buffer, size_t size = 65536, std::string eol = "\n");
+
+	/*! Reads in a line or until a given delimiter has been processed.
+   *
+   * Reads from the serial port until a single line has been read.
+   *
+   * \param size A maximum length of a line, defaults to 65536 (2^16)
+   * \param eol A string to match against for the EOL.
+   *
+   * \return A std::string containing the line.
+   *
+   * \throw serial::PortNotOpenedException
+   * \throw serial::SerialException
+   */
+	std::string
+	readline(size_t size = 65536, std::string eol = "\n");
+
+	/*! Reads in multiple lines until the serial port times out.
+   *
+   * This requires a timeout > 0 before it can be run. It will read until a
+   * timeout occurs and return a list of strings.
+   *
+   * \param size A maximum length of combined lines, defaults to 65536 (2^16)
+   *
+   * \param eol A string to match against for the EOL.
+   *
+   * \return A vector<string> containing the lines.
+   *
+   * \throw serial::PortNotOpenedException
+   * \throw serial::SerialException
+   */
+	std::vector<std::string>
+	readlines(size_t size = 65536, std::string eol = "\n");
+
+	/*! Write a string to the serial port.
+   *
+   * \param data A const reference containing the data to be written
+   * to the serial port.
+   *
+   * \param size A size_t that indicates how many bytes should be written from
+   * the given data buffer.
+   *
+   * \return A size_t representing the number of bytes actually written to
+   * the serial port.
+   *
+   * \throw serial::PortNotOpenedException
+   * \throw serial::SerialException
+   * \throw serial::IOException
+   */
+	size_t
+	write(const uint8_t *data, size_t size);
+
+	/*! Write a string to the serial port.
+   *
+   * \param data A const reference containing the data to be written
+   * to the serial port.
+   *
+   * \return A size_t representing the number of bytes actually written to
+   * the serial port.
+   *
+   * \throw serial::PortNotOpenedException
+   * \throw serial::SerialException
+   * \throw serial::IOException
+   */
+	size_t
+	write(const std::vector<uint8_t> &data);
+
+	/*! Write a string to the serial port.
+   *
+   * \param data A const reference containing the data to be written
+   * to the serial port.
+   *
+   * \return A size_t representing the number of bytes actually written to
+   * the serial port.
+   *
+   * \throw serial::PortNotOpenedException
+   * \throw serial::SerialException
+   * \throw serial::IOException
+   */
+	size_t
+	write(const std::string &data);
+
+	/*! Sets the serial port identifier.
+   *
+   * \param port A const std::string reference containing the address of the
+   * serial port, which would be something like 'COM1' on Windows and
+   * '/dev/ttyS0' on Linux.
+   *
+   * \throw std::invalid_argument
+   */
+	void
+	setPort(const std::string &port);
+
+	/*! Gets the serial port identifier.
+   *
+   * \see Serial::setPort
+   *
+   * \throw std::invalid_argument
+   */
+	std::string
+	getPort() const;
+
+	/*! Sets the timeout for reads and writes using the Timeout struct.
+   *
+   * There are two timeout conditions described here:
+   *  * The inter byte timeout:
+   *    * The inter_byte_timeout component of serial::Timeout defines the
+   *      maximum amount of time, in milliseconds, between receiving bytes on
+   *      the serial port that can pass before a timeout occurs.  Setting this
+   *      to zero will prevent inter byte timeouts from occurring.
+   *  * Total time timeout:
+   *    * The constant and multiplier component of this timeout condition,
+   *      for both read and write, are defined in serial::Timeout.  This
+   *      timeout occurs if the total time since the read or write call was
+   *      made exceeds the specified time in milliseconds.
+   *    * The limit is defined by multiplying the multiplier component by the
+   *      number of requested bytes and adding that product to the constant
+   *      component.  In this way if you want a read call, for example, to
+   *      timeout after exactly one second regardless of the number of bytes
+   *      you asked for then set the read_timeout_constant component of
+   *      serial::Timeout to 1000 and the read_timeout_multiplier to zero.
+   *      This timeout condition can be used in conjunction with the inter
+   *      byte timeout condition with out any problems, timeout will simply
+   *      occur when one of the two timeout conditions is met.  This allows
+   *      users to have maximum control over the trade-off between
+   *      responsiveness and efficiency.
+   *
+   * Read and write functions will return in one of three cases.  When the
+   * reading or writing is complete, when a timeout occurs, or when an
+   * exception occurs.
+   *
+   * A timeout of 0 enables non-blocking mode.
+   *
+   * \param timeout A serial::Timeout struct containing the inter byte
+   * timeout, and the read and write timeout constants and multipliers.
+   *
+   * \see serial::Timeout
+   */
+	void
+	setTimeout(Timeout &timeout);
+
+	/*! Sets the timeout for reads and writes. */
+	void
+	setTimeout(uint32_t inter_byte_timeout, uint32_t read_timeout_constant,
+			   uint32_t read_timeout_multiplier, uint32_t write_timeout_constant,
+			   uint32_t write_timeout_multiplier)
+	{
+		Timeout timeout(inter_byte_timeout, read_timeout_constant,
+						read_timeout_multiplier, write_timeout_constant,
+						write_timeout_multiplier);
+		return setTimeout(timeout);
+	}
+
+	/*! Gets the timeout for reads in seconds.
+   *
+   * \return A Timeout struct containing the inter_byte_timeout, and read
+   * and write timeout constants and multipliers.
+   *
+   * \see Serial::setTimeout
+   */
+	Timeout
+	getTimeout() const;
+
+	/*! Sets the baudrate for the serial port.
+   *
+   * Possible baudrates depends on the system but some safe baudrates include:
+   * 110, 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 56000,
+   * 57600, 115200
+   * Some other baudrates that are supported by some comports:
+   * 128000, 153600, 230400, 256000, 460800, 921600
+   *
+   * \param baudrate An integer that sets the baud rate for the serial port.
+   *
+   * \throw std::invalid_argument
+   */
+	void
+	setBaudrate(uint32_t baudrate);
+
+	/*! Gets the baudrate for the serial port.
+   *
+   * \return An integer that sets the baud rate for the serial port.
+   *
+   * \see Serial::setBaudrate
+   *
+   * \throw std::invalid_argument
+   */
+	uint32_t
+	getBaudrate() const;
+
+	/*! Sets the bytesize for the serial port.
+   *
+   * \param bytesize Size of each byte in the serial transmission of data,
+   * default is eightbits, possible values are: fivebits, sixbits, sevenbits,
+   * eightbits
+   *
+   * \throw std::invalid_argument
+   */
+	void
+	setBytesize(bytesize_t bytesize);
+
+	/*! Gets the bytesize for the serial port.
+   *
+   * \see Serial::setBytesize
+   *
+   * \throw std::invalid_argument
+   */
+	bytesize_t
+	getBytesize() const;
+
+	/*! Sets the parity for the serial port.
+   *
+   * \param parity Method of parity, default is parity_none, possible values
+   * are: parity_none, parity_odd, parity_even
+   *
+   * \throw std::invalid_argument
+   */
+	void
+	setParity(parity_t parity);
+
+	/*! Gets the parity for the serial port.
+   *
+   * \see Serial::setParity
+   *
+   * \throw std::invalid_argument
+   */
+	parity_t
+	getParity() const;
+
+	/*! Sets the stopbits for the serial port.
+   *
+   * \param stopbits Number of stop bits used, default is stopbits_one,
+   * possible values are: stopbits_one, stopbits_one_point_five, stopbits_two
+   *
+   * \throw std::invalid_argument
+   */
+	void
+	setStopbits(stopbits_t stopbits);
+
+	/*! Gets the stopbits for the serial port.
+   *
+   * \see Serial::setStopbits
+   *
+   * \throw std::invalid_argument
+   */
+	stopbits_t
+	getStopbits() const;
+
+	/*! Sets the flow control for the serial port.
+   *
+   * \param flowcontrol Type of flowcontrol used, default is flowcontrol_none,
+   * possible values are: flowcontrol_none, flowcontrol_software,
+   * flowcontrol_hardware
+   *
+   * \throw std::invalid_argument
+   */
+	void
+	setFlowcontrol(flowcontrol_t flowcontrol);
+
+	/*! Gets the flow control for the serial port.
+   *
+   * \see Serial::setFlowcontrol
+   *
+   * \throw std::invalid_argument
+   */
+	flowcontrol_t
+	getFlowcontrol() const;
+
+	/*! Flush the input and output buffers */
+	void
+	flush();
+
+	/*! Flush only the input buffer */
+	void
+	flushInput();
+
+	/*! Flush only the output buffer */
+	void
+	flushOutput();
+
+	/*! Sends the RS-232 break signal.  See tcsendbreak(3). */
+	void
+	sendBreak(int duration);
+
+	/*! Set the break condition to a given level.  Defaults to true. */
+	void
+	setBreak(bool level = true);
+
+	/*! Set the RTS handshaking line to the given level.  Defaults to true. */
+	void
+	setRTS(bool level = true);
+
+	/*! Set the DTR handshaking line to the given level.  Defaults to true. */
+	void
+	setDTR(bool level = true);
+
+	/*!
+   * Blocks until CTS, DSR, RI, CD changes or something interrupts it.
+   *
+   * Can throw an exception if an error occurs while waiting.
+   * You can check the status of CTS, DSR, RI, and CD once this returns.
+   * Uses TIOCMIWAIT via ioctl if available (mostly only on Linux) with a
+   * resolution of less than +-1ms and as good as +-0.2ms.  Otherwise a
+   * polling method is used which can give +-2ms.
+   *
+   * \return Returns true if one of the lines changed, false if something else
+   * occurred.
+   *
+   * \throw SerialException
+   */
+	bool
+	waitForChange();
+
+	/*! Returns the current status of the CTS line. */
+	bool
+	getCTS();
+
+	/*! Returns the current status of the DSR line. */
+	bool
+	getDSR();
+
+	/*! Returns the current status of the RI line. */
+	bool
+	getRI();
+
+	/*! Returns the current status of the CD line. */
+	bool
+	getCD();
+
+private:
+	// Disable copy constructors
+	Serial(const Serial &);
+	Serial &operator=(const Serial &);
+
+	// Pimpl idiom, d_pointer
+	class SerialImpl;
+	SerialImpl *pimpl_;
+
+	// Scoped Lock Classes
+	class ScopedReadLock;
+	class ScopedWriteLock;
+
+	// Read common function
+	size_t
+	read_(uint8_t *buffer, size_t size);
+	// Write common function
+	size_t
+	write_(const uint8_t *data, size_t length);
+};
+
+class SerialException : public std::exception
+{
+	// Disable copy constructors
+	SerialException &operator=(const SerialException &);
+	std::string e_what_;
+
+public:
+	SerialException(const char *description)
+	{
+		std::stringstream ss;
+		ss << "SerialException " << description << " failed.";
+		e_what_ = ss.str();
+	}
+	SerialException(const SerialException &other) : e_what_(other.e_what_) {}
+	virtual ~SerialException() throw() {}
+	virtual const char *what() const throw()
+	{
+		return e_what_.c_str();
+	}
+};
+
+class IOException : public std::exception
+{
+	// Disable copy constructors
+	IOException &operator=(const IOException &);
+	std::string file_;
+	int line_;
+	std::string e_what_;
+	int errno_;
+
+public:
+	explicit IOException(std::string file, int line, int errnum)
+		: file_(file), line_(line), errno_(errnum)
+	{
+		std::stringstream ss;
+#if defined(_WIN32) && !defined(__MINGW32__)
+		char error_str[1024];
+		strerror_s(error_str, 1024, errnum);
+#else
+		char *error_str = strerror(errnum);
+#endif
+		ss << "IO Exception (" << errno_ << "): " << error_str;
+		ss << ", file " << file_ << ", line " << line_ << ".";
+		e_what_ = ss.str();
+	}
+	explicit IOException(std::string file, int line, const char *description)
+		: file_(file), line_(line), errno_(0)
+	{
+		std::stringstream ss;
+		ss << "IO Exception: " << description;
+		ss << ", file " << file_ << ", line " << line_ << ".";
+		e_what_ = ss.str();
+	}
+	virtual ~IOException() throw() {}
+	IOException(const IOException &other) : line_(other.line_), e_what_(other.e_what_), errno_(other.errno_) {}
+
+	int getErrorNumber() const { return errno_; }
+
+	virtual const char *what() const throw()
+	{
+		return e_what_.c_str();
+	}
+};
+
+class PortNotOpenedException : public std::exception
+{
+	// Disable copy constructors
+	const PortNotOpenedException &operator=(PortNotOpenedException);
+	std::string e_what_;
+
+public:
+	PortNotOpenedException(const char *description)
+	{
+		std::stringstream ss;
+		ss << "PortNotOpenedException " << description << " failed.";
+		e_what_ = ss.str();
+	}
+	PortNotOpenedException(const PortNotOpenedException &other) : e_what_(other.e_what_) {}
+	virtual ~PortNotOpenedException() throw() {}
+	virtual const char *what() const throw()
+	{
+		return e_what_.c_str();
+	}
+};
+
+/*!
+ * Structure that describes a serial device.
+ */
+struct PortInfo
+{
+	/*! Address of the serial port (this can be passed to the constructor of Serial). */
+	std::string port;
+
+	/*! Human readable description of serial device if available. */
+	std::string description;
+
+	/*! Hardware ID (e.g. VID:PID of USB serial devices) or "n/a" if not available. */
+	std::string hardware_id;
+};
+
+/* Lists the serial ports available on the system
+ *
+ * Returns a vector of available serial ports, each represented
+ * by a serial::PortInfo data structure:
+ *
+ * \return vector of serial::PortInfo.
+ */
+std::vector<PortInfo>
+list_ports();
+
+}  // namespace serial
+
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/serial/include/serial/v8stdint.h b/engine/inc/bullet/ThirdPartyLibs/serial/include/serial/v8stdint.h
new file mode 100644
index 00000000..082e1ece
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/serial/include/serial/v8stdint.h
@@ -0,0 +1,57 @@
+// This header is from the v8 google project:
+// http://code.google.com/p/v8/source/browse/trunk/include/v8stdint.h
+
+// Copyright 2012 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Load definitions of standard types.
+
+#ifndef V8STDINT_H_
+#define V8STDINT_H_
+
+#include <stddef.h>
+#include <stdio.h>
+
+#if defined(_WIN32) && !defined(__MINGW32__)
+
+typedef signed char int8_t;
+typedef unsigned char uint8_t;
+typedef short int16_t;            // NOLINT
+typedef unsigned short uint16_t;  // NOLINT
+typedef int int32_t;
+typedef unsigned int uint32_t;
+typedef __int64 int64_t;
+typedef unsigned __int64 uint64_t;
+// intptr_t and friends are defined in crtdefs.h through stdio.h.
+
+#else
+
+#include <stdint.h>
+
+#endif
+
+#endif  // V8STDINT_H_
diff --git a/engine/inc/bullet/ThirdPartyLibs/stb_image/stb_image.h b/engine/inc/bullet/ThirdPartyLibs/stb_image/stb_image.h
new file mode 100644
index 00000000..f7245c7c
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/stb_image/stb_image.h
@@ -0,0 +1,326 @@
+/* stbi-1.33 - public domain JPEG/PNG reader - http://nothings.org/stb_image.c
+   when you control the images you're loading
+                                     no warranty implied; use at your own risk
+
+   QUICK NOTES:
+      Primarily of interest to game developers and other people who can
+          avoid problematic images and only need the trivial interface
+
+      JPEG baseline (no JPEG progressive)
+      PNG 8-bit only
+
+      TGA (not sure what subset, if a subset)
+      BMP non-1bpp, non-RLE
+      PSD (composited view only, no extra channels)
+
+      GIF (*comp always reports as 4-channel)
+      HDR (radiance rgbE format)
+      PIC (Softimage PIC)
+
+      - decode from memory or through FILE (define STBI_NO_STDIO to remove code)
+      - decode from arbitrary I/O callbacks
+      - overridable dequantizing-IDCT, YCbCr-to-RGB conversion (define STBI_SIMD)
+
+   Latest revisions:
+      1.33 (2011-07-14) minor fixes suggested by Dave Moore
+      1.32 (2011-07-13) info support for all filetypes (SpartanJ)
+      1.31 (2011-06-19) a few more leak fixes, bug in PNG handling (SpartanJ)
+      1.30 (2011-06-11) added ability to load files via io callbacks (Ben Wenger)
+      1.29 (2010-08-16) various warning fixes from Aurelien Pocheville 
+      1.28 (2010-08-01) fix bug in GIF palette transparency (SpartanJ)
+      1.27 (2010-08-01) cast-to-uint8 to fix warnings (Laurent Gomila)
+                        allow trailing 0s at end of image data (Laurent Gomila)
+      1.26 (2010-07-24) fix bug in file buffering for PNG reported by SpartanJ
+
+   See end of file for full revision history.
+
+   TODO:
+      stbi_info support for BMP,PSD,HDR,PIC
+
+
+ ============================    Contributors    =========================
+              
+ Image formats                                Optimizations & bugfixes
+    Sean Barrett (jpeg, png, bmp)                Fabian "ryg" Giesen
+    Nicolas Schulz (hdr, psd)                                                 
+    Jonathan Dummer (tga)                     Bug fixes & warning fixes           
+    Jean-Marc Lienher (gif)                      Marc LeBlanc               
+    Tom Seddon (pic)                             Christpher Lloyd           
+    Thatcher Ulrich (psd)                        Dave Moore                 
+                                                 Won Chun                   
+                                                 the Horde3D community      
+ Extensions, features                            Janez Zemva                
+    Jetro Lauha (stbi_info)                      Jonathan Blow              
+    James "moose2000" Brown (iPhone PNG)         Laurent Gomila                             
+    Ben "Disch" Wenger (io callbacks)            Aruelien Pocheville
+    Martin "SpartanJ" Golini                     Ryamond Barbiero
+                                                 David Woo
+                                                 
+
+ If your name should be here but isn't, let Sean know.
+
+*/
+
+#ifndef STBI_INCLUDE_STB_IMAGE_H
+#define STBI_INCLUDE_STB_IMAGE_H
+
+// To get a header file for this, either cut and paste the header,
+// or create stb_image.h, #define STBI_HEADER_FILE_ONLY, and
+// then include stb_image.c from it.
+
+////   begin header file  ////////////////////////////////////////////////////
+//
+// Limitations:
+//    - no jpeg progressive support
+//    - non-HDR formats support 8-bit samples only (jpeg, png)
+//    - no delayed line count (jpeg) -- IJG doesn't support either
+//    - no 1-bit BMP
+//    - GIF always returns *comp=4
+//
+// Basic usage (see HDR discussion below):
+//    int x,y,n;
+//    unsigned char *data = stbi_load(filename, &x, &y, &n, 0);
+//    // ... process data if not NULL ...
+//    // ... x = width, y = height, n = # 8-bit components per pixel ...
+//    // ... replace '0' with '1'..'4' to force that many components per pixel
+//    // ... but 'n' will always be the number that it would have been if you said 0
+//    stbi_image_free(data)
+//
+// Standard parameters:
+//    int *x       -- outputs image width in pixels
+//    int *y       -- outputs image height in pixels
+//    int *comp    -- outputs # of image components in image file
+//    int req_comp -- if non-zero, # of image components requested in result
+//
+// The return value from an image loader is an 'unsigned char *' which points
+// to the pixel data. The pixel data consists of *y scanlines of *x pixels,
+// with each pixel consisting of N interleaved 8-bit components; the first
+// pixel pointed to is top-left-most in the image. There is no padding between
+// image scanlines or between pixels, regardless of format. The number of
+// components N is 'req_comp' if req_comp is non-zero, or *comp otherwise.
+// If req_comp is non-zero, *comp has the number of components that _would_
+// have been output otherwise. E.g. if you set req_comp to 4, you will always
+// get RGBA output, but you can check *comp to easily see if it's opaque.
+//
+// An output image with N components has the following components interleaved
+// in this order in each pixel:
+//
+//     N=#comp     components
+//       1           grey
+//       2           grey, alpha
+//       3           red, green, blue
+//       4           red, green, blue, alpha
+//
+// If image loading fails for any reason, the return value will be NULL,
+// and *x, *y, *comp will be unchanged. The function stbi_failure_reason()
+// can be queried for an extremely brief, end-user unfriendly explanation
+// of why the load failed. Define STBI_NO_FAILURE_STRINGS to avoid
+// compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly
+// more user-friendly ones.
+//
+// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized.
+//
+// ===========================================================================
+//
+// iPhone PNG support:
+//
+// By default we convert iphone-formatted PNGs back to RGB; nominally they
+// would silently load as BGR, except the existing code should have just
+// failed on such iPhone PNGs. But you can disable this conversion by
+// by calling stbi_convert_iphone_png_to_rgb(0), in which case
+// you will always just get the native iphone "format" through.
+//
+// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per
+// pixel to remove any premultiplied alpha *only* if the image file explicitly
+// says there's premultiplied data (currently only happens in iPhone images,
+// and only if iPhone convert-to-rgb processing is on).
+//
+// ===========================================================================
+//
+// HDR image support   (disable by defining STBI_NO_HDR)
+//
+// stb_image now supports loading HDR images in general, and currently
+// the Radiance .HDR file format, although the support is provided
+// generically. You can still load any file through the existing interface;
+// if you attempt to load an HDR file, it will be automatically remapped to
+// LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1;
+// both of these constants can be reconfigured through this interface:
+//
+//     stbi_hdr_to_ldr_gamma(2.2f);
+//     stbi_hdr_to_ldr_scale(1.0f);
+//
+// (note, do not use _inverse_ constants; stbi_image will invert them
+// appropriately).
+//
+// Additionally, there is a new, parallel interface for loading files as
+// (linear) floats to preserve the full dynamic range:
+//
+//    float *data = stbi_loadf(filename, &x, &y, &n, 0);
+//
+// If you load LDR images through this interface, those images will
+// be promoted to floating point values, run through the inverse of
+// constants corresponding to the above:
+//
+//     stbi_ldr_to_hdr_scale(1.0f);
+//     stbi_ldr_to_hdr_gamma(2.2f);
+//
+// Finally, given a filename (or an open file or memory block--see header
+// file for details) containing image data, you can query for the "most
+// appropriate" interface to use (that is, whether the image is HDR or
+// not), using:
+//
+//     stbi_is_hdr(char *filename);
+//
+// ===========================================================================
+//
+// I/O callbacks
+//
+// I/O callbacks allow you to read from arbitrary sources, like packaged
+// files or some other source. Data read from callbacks are processed
+// through a small internal buffer (currently 128 bytes) to try to reduce
+// overhead.
+//
+// The three functions you must define are "read" (reads some bytes of data),
+// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end).
+
+#ifndef STBI_NO_STDIO
+
+#if defined(_MSC_VER) && _MSC_VER >= 0x1400
+#define _CRT_SECURE_NO_WARNINGS  // suppress bogus warnings about fopen()
+#endif
+
+#include <stdio.h>
+#endif
+
+#define STBI_VERSION 1
+
+enum
+{
+	STBI_default = 0,  // only used for req_comp
+
+	STBI_grey = 1,
+	STBI_grey_alpha = 2,
+	STBI_rgb = 3,
+	STBI_rgb_alpha = 4
+};
+
+typedef unsigned char stbi_uc;
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	//////////////////////////////////////////////////////////////////////////////
+	//
+	// PRIMARY API - works on images of any type
+	//
+
+	//
+	// load image by filename, open file, or memory buffer
+	//
+
+	extern stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
+
+#ifndef STBI_NO_STDIO
+	extern stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp);
+	extern stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp);
+// for stbi_load_from_file, file pointer is left pointing immediately after image
+#endif
+
+	typedef struct
+	{
+		int (*read)(void *user, char *data, int size);  // fill 'data' with 'size' bytes.  return number of bytes actually read
+		void (*skip)(void *user, unsigned n);           // skip the next 'n' bytes
+		int (*eof)(void *user);                         // returns nonzero if we are at end of file/data
+	} stbi_io_callbacks;
+
+	extern stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp);
+
+#ifndef STBI_NO_HDR
+	extern float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
+
+#ifndef STBI_NO_STDIO
+	extern float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp);
+	extern float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp);
+#endif
+
+	extern float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp);
+
+	extern void stbi_hdr_to_ldr_gamma(float gamma);
+	extern void stbi_hdr_to_ldr_scale(float scale);
+
+	extern void stbi_ldr_to_hdr_gamma(float gamma);
+	extern void stbi_ldr_to_hdr_scale(float scale);
+#endif  // STBI_NO_HDR
+
+	// stbi_is_hdr is always defined
+	extern int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user);
+	extern int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len);
+#ifndef STBI_NO_STDIO
+	extern int stbi_is_hdr(char const *filename);
+	extern int stbi_is_hdr_from_file(FILE *f);
+#endif  // STBI_NO_STDIO
+
+	// get a VERY brief reason for failure
+	// NOT THREADSAFE
+	extern const char *stbi_failure_reason(void);
+
+	// free the loaded image -- this is just free()
+	extern void stbi_image_free(void *retval_from_stbi_load);
+
+	// get image dimensions & components without fully decoding
+	extern int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);
+	extern int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp);
+
+#ifndef STBI_NO_STDIO
+	extern int stbi_info(char const *filename, int *x, int *y, int *comp);
+	extern int stbi_info_from_file(FILE *f, int *x, int *y, int *comp);
+
+#endif
+
+	// for image formats that explicitly notate that they have premultiplied alpha,
+	// we just return the colors as stored in the file. set this flag to force
+	// unpremultiplication. results are undefined if the unpremultiply overflow.
+	extern void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply);
+
+	// indicate whether we should process iphone images back to canonical format,
+	// or just pass them through "as-is"
+	extern void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert);
+
+	// ZLIB client - used by PNG, available for other purposes
+
+	extern char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen);
+	extern char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen);
+	extern int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
+
+	extern char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen);
+	extern int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
+
+// define faster low-level operations (typically SIMD support)
+#ifdef STBI_SIMD
+	typedef void (*stbi_idct_8x8)(stbi_uc *out, int out_stride, short data[64], unsigned short *dequantize);
+	// compute an integer IDCT on "input"
+	//     input[x] = data[x] * dequantize[x]
+	//     write results to 'out': 64 samples, each run of 8 spaced by 'out_stride'
+	//                             CLAMP results to 0..255
+	typedef void (*stbi_YCbCr_to_RGB_run)(stbi_uc *output, stbi_uc const *y, stbi_uc const *cb, stbi_uc const *cr, int count, int step);
+	// compute a conversion from YCbCr to RGB
+	//     'count' pixels
+	//     write pixels to 'output'; each pixel is 'step' bytes (either 3 or 4; if 4, write '255' as 4th), order R,G,B
+	//     y: Y input channel
+	//     cb: Cb input channel; scale/biased to be 0..255
+	//     cr: Cr input channel; scale/biased to be 0..255
+
+	extern void stbi_install_idct(stbi_idct_8x8 func);
+	extern void stbi_install_YCbCr_to_RGB(stbi_YCbCr_to_RGB_run func);
+#endif  // STBI_SIMD
+
+#ifdef __cplusplus
+}
+#endif
+
+//
+//
+////   end header file   /////////////////////////////////////////////////////
+#endif  // STBI_INCLUDE_STB_IMAGE_H
diff --git a/engine/inc/bullet/ThirdPartyLibs/stb_image/stb_image_write.h b/engine/inc/bullet/ThirdPartyLibs/stb_image/stb_image_write.h
new file mode 100644
index 00000000..50386388
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/stb_image/stb_image_write.h
@@ -0,0 +1,608 @@
+/* stbiw-0.92 - public domain - http://nothings.org/stb/stb_image_write.h
+   writes out PNG/BMP/TGA images to C stdio - Sean Barrett 2010
+                            no warranty implied; use at your own risk
+
+
+Before including,
+
+    #define STB_IMAGE_WRITE_IMPLEMENTATION
+
+in the file that you want to have the implementation.
+
+
+ABOUT:
+
+   This header file is a library for writing images to C stdio. It could be
+   adapted to write to memory or a general streaming interface; let me know.
+
+   The PNG output is not optimal; it is 20-50% larger than the file
+   written by a decent optimizing implementation. This library is designed
+   for source code compactness and simplicitly, not optimal image file size
+   or run-time performance.
+
+USAGE:
+
+   There are three functions, one for each image file format:
+
+     int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes);
+     int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data);
+     int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data);
+
+   Each function returns 0 on failure and non-0 on success.
+   
+   The functions create an image file defined by the parameters. The image
+   is a rectangle of pixels stored from left-to-right, top-to-bottom.
+   Each pixel contains 'comp' channels of data stored interleaved with 8-bits
+   per channel, in the following order: 1=Y, 2=YA, 3=RGB, 4=RGBA. (Y is
+   monochrome color.) The rectangle is 'w' pixels wide and 'h' pixels tall.
+   The *data pointer points to the first byte of the top-left-most pixel.
+   For PNG, "stride_in_bytes" is the distance in bytes from the first byte of
+   a row of pixels to the first byte of the next row of pixels.
+
+   PNG creates output files with the same number of components as the input.
+   The BMP and TGA formats expand Y to RGB in the file format. BMP does not
+   output alpha.
+   
+   PNG supports writing rectangles of data even when the bytes storing rows of
+   data are not consecutive in memory (e.g. sub-rectangles of a larger image),
+   by supplying the stride between the beginning of adjacent rows. The other
+   formats do not. (Thus you cannot write a native-format BMP through the BMP
+   writer, both because it is in BGR order and because it may have padding
+   at the end of the line.)
+*/
+
+#ifndef INCLUDE_STB_IMAGE_WRITE_H
+#define INCLUDE_STB_IMAGE_WRITE_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	extern int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes);
+	extern int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data);
+	extern int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  //INCLUDE_STB_IMAGE_WRITE_H
+
+#ifdef STB_IMAGE_WRITE_IMPLEMENTATION
+
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+typedef unsigned int stbiw_uint32;
+typedef int stb_image_write_test[sizeof(stbiw_uint32) == 4 ? 1 : -1];
+
+static void writefv(FILE *f, const char *fmt, va_list v)
+{
+	while (*fmt)
+	{
+		switch (*fmt++)
+		{
+			case ' ':
+				break;
+			case '1':
+			{
+				unsigned char x = (unsigned char)va_arg(v, int);
+				fputc(x, f);
+				break;
+			}
+			case '2':
+			{
+				int x = va_arg(v, int);
+				unsigned char b[2];
+				b[0] = (unsigned char)x;
+				b[1] = (unsigned char)(x >> 8);
+				fwrite(b, 2, 1, f);
+				break;
+			}
+			case '4':
+			{
+				stbiw_uint32 x = va_arg(v, int);
+				unsigned char b[4];
+				b[0] = (unsigned char)x;
+				b[1] = (unsigned char)(x >> 8);
+				b[2] = (unsigned char)(x >> 16);
+				b[3] = (unsigned char)(x >> 24);
+				fwrite(b, 4, 1, f);
+				break;
+			}
+			default:
+				assert(0);
+				return;
+		}
+	}
+}
+
+static void write3(FILE *f, unsigned char a, unsigned char b, unsigned char c)
+{
+	unsigned char arr[3];
+	arr[0] = a, arr[1] = b, arr[2] = c;
+	fwrite(arr, 3, 1, f);
+}
+
+static void write_pixels(FILE *f, int rgb_dir, int vdir, int x, int y, int comp, void *data, int write_alpha, int scanline_pad)
+{
+	unsigned char bg[3] = {255, 0, 255}, px[3];
+	stbiw_uint32 zero = 0;
+	int i, j, k, j_end;
+
+	if (y <= 0)
+		return;
+
+	if (vdir < 0)
+		j_end = -1, j = y - 1;
+	else
+		j_end = y, j = 0;
+
+	for (; j != j_end; j += vdir)
+	{
+		for (i = 0; i < x; ++i)
+		{
+			unsigned char *d = (unsigned char *)data + (j * x + i) * comp;
+			if (write_alpha < 0)
+				fwrite(&d[comp - 1], 1, 1, f);
+			switch (comp)
+			{
+				case 1:
+				case 2:
+					write3(f, d[0], d[0], d[0]);
+					break;
+				case 4:
+					if (!write_alpha)
+					{
+						// composite against pink background
+						for (k = 0; k < 3; ++k)
+							px[k] = bg[k] + ((d[k] - bg[k]) * d[3]) / 255;
+						write3(f, px[1 - rgb_dir], px[1], px[1 + rgb_dir]);
+						break;
+					}
+					/* FALLTHROUGH */
+				case 3:
+					write3(f, d[1 - rgb_dir], d[1], d[1 + rgb_dir]);
+					break;
+			}
+			if (write_alpha > 0)
+				fwrite(&d[comp - 1], 1, 1, f);
+		}
+		fwrite(&zero, scanline_pad, 1, f);
+	}
+}
+
+static int outfile(char const *filename, int rgb_dir, int vdir, int x, int y, int comp, void *data, int alpha, int pad, const char *fmt, ...)
+{
+	FILE *f;
+	if (y < 0 || x < 0) return 0;
+	f = fopen(filename, "wb");
+	if (f)
+	{
+		va_list v;
+		va_start(v, fmt);
+		writefv(f, fmt, v);
+		va_end(v);
+		write_pixels(f, rgb_dir, vdir, x, y, comp, data, alpha, pad);
+		fclose(f);
+	}
+	return f != NULL;
+}
+
+int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data)
+{
+	int pad = (-x * 3) & 3;
+	return outfile(filename, -1, -1, x, y, comp, (void *)data, 0, pad,
+				   "11 4 22 4"
+				   "4 44 22 444444",
+				   'B', 'M', 14 + 40 + (x * 3 + pad) * y, 0, 0, 14 + 40,  // file header
+				   40, x, y, 1, 24, 0, 0, 0, 0, 0, 0);                    // bitmap header
+}
+
+int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data)
+{
+	int has_alpha = !(comp & 1);
+	return outfile(filename, -1, -1, x, y, comp, (void *)data, has_alpha, 0,
+				   "111 221 2222 11", 0, 0, 2, 0, 0, 0, 0, 0, x, y, 24 + 8 * has_alpha, 8 * has_alpha);
+}
+
+// stretchy buffer; stbi__sbpush() == vector<>::push_back() -- stbi__sbcount() == vector<>::size()
+#define stbi__sbraw(a) ((int *)(a)-2)
+#define stbi__sbm(a) stbi__sbraw(a)[0]
+#define stbi__sbn(a) stbi__sbraw(a)[1]
+
+#define stbi__sbneedgrow(a, n) ((a) == 0 || stbi__sbn(a) + n >= stbi__sbm(a))
+#define stbi__sbmaybegrow(a, n) (stbi__sbneedgrow(a, (n)) ? stbi__sbgrow(a, n) : 0)
+#define stbi__sbgrow(a, n) stbi__sbgrowf((void **)&(a), (n), sizeof(*(a)))
+
+#define stbi__sbpush(a, v) (stbi__sbmaybegrow(a, 1), (a)[stbi__sbn(a)++] = (v))
+#define stbi__sbcount(a) ((a) ? stbi__sbn(a) : 0)
+#define stbi__sbfree(a) ((a) ? free(stbi__sbraw(a)), 0 : 0)
+
+static void *stbi__sbgrowf(void **arr, int increment, int itemsize)
+{
+	int m = *arr ? 2 * stbi__sbm(*arr) + increment : increment + 1;
+	void *p = realloc(*arr ? stbi__sbraw(*arr) : 0, itemsize * m + sizeof(int) * 2);
+	assert(p);
+	if (p)
+	{
+		if (!*arr) ((int *)p)[1] = 0;
+		*arr = (void *)((int *)p + 2);
+		stbi__sbm(*arr) = m;
+	}
+	return *arr;
+}
+
+static unsigned char *stbi__zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount)
+{
+	while (*bitcount >= 8)
+	{
+		stbi__sbpush(data, (unsigned char)*bitbuffer);
+		*bitbuffer >>= 8;
+		*bitcount -= 8;
+	}
+	return data;
+}
+
+static int stbi__zlib_bitrev(int code, int codebits)
+{
+	int res = 0;
+	while (codebits--)
+	{
+		res = (res << 1) | (code & 1);
+		code >>= 1;
+	}
+	return res;
+}
+
+static unsigned int stbi__zlib_countm(unsigned char *a, unsigned char *b, int limit)
+{
+	int i;
+	for (i = 0; i < limit && i < 258; ++i)
+		if (a[i] != b[i]) break;
+	return i;
+}
+
+static unsigned int stbi__zhash(unsigned char *data)
+{
+	stbiw_uint32 hash = data[0] + (data[1] << 8) + (data[2] << 16);
+	hash ^= hash << 3;
+	hash += hash >> 5;
+	hash ^= hash << 4;
+	hash += hash >> 17;
+	hash ^= hash << 25;
+	hash += hash >> 6;
+	return hash;
+}
+
+#define stbi__zlib_flush() (out = stbi__zlib_flushf(out, &bitbuf, &bitcount))
+#define stbi__zlib_add(code, codebits) \
+	(bitbuf |= (code) << bitcount, bitcount += (codebits), stbi__zlib_flush())
+#define stbi__zlib_huffa(b, c) stbi__zlib_add(stbi__zlib_bitrev(b, c), c)
+// default huffman tables
+#define stbi__zlib_huff1(n) stbi__zlib_huffa(0x30 + (n), 8)
+#define stbi__zlib_huff2(n) stbi__zlib_huffa(0x190 + (n)-144, 9)
+#define stbi__zlib_huff3(n) stbi__zlib_huffa(0 + (n)-256, 7)
+#define stbi__zlib_huff4(n) stbi__zlib_huffa(0xc0 + (n)-280, 8)
+#define stbi__zlib_huff(n) ((n) <= 143 ? stbi__zlib_huff1(n) : (n) <= 255 ? stbi__zlib_huff2(n) : (n) <= 279 ? stbi__zlib_huff3(n) : stbi__zlib_huff4(n))
+#define stbi__zlib_huffb(n) ((n) <= 143 ? stbi__zlib_huff1(n) : stbi__zlib_huff2(n))
+
+#define stbi__ZHASH 16384
+
+unsigned char *stbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality)
+{
+	static unsigned short lengthc[] = {3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 259};
+	static unsigned char lengtheb[] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0};
+	static unsigned short distc[] = {1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 32768};
+	static unsigned char disteb[] = {0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13};
+	unsigned int bitbuf = 0;
+	int i, j, bitcount = 0;
+	unsigned char *out = NULL;
+	unsigned char **hash_table[stbi__ZHASH];  // 64KB on the stack!
+	if (quality < 5) quality = 5;
+
+	stbi__sbpush(out, 0x78);  // DEFLATE 32K window
+	stbi__sbpush(out, 0x5e);  // FLEVEL = 1
+	stbi__zlib_add(1, 1);     // BFINAL = 1
+	stbi__zlib_add(1, 2);     // B3YPE = 1 -- fixed huffman
+
+	for (i = 0; i < stbi__ZHASH; ++i)
+		hash_table[i] = NULL;
+
+	i = 0;
+	while (i < data_len - 3)
+	{
+		// hash next 3 bytes of data to be compressed
+		int h = stbi__zhash(data + i) & (stbi__ZHASH - 1), best = 3;
+		unsigned char *bestloc = 0;
+		unsigned char **hlist = hash_table[h];
+		int n = stbi__sbcount(hlist);
+		for (j = 0; j < n; ++j)
+		{
+			if (hlist[j] - data > i - 32768)
+			{  // if entry lies within window
+				int d = stbi__zlib_countm(hlist[j], data + i, data_len - i);
+				if (d >= best) best = d, bestloc = hlist[j];
+			}
+		}
+		// when hash table entry is too long, delete half the entries
+		if (hash_table[h] && stbi__sbn(hash_table[h]) == 2 * quality)
+		{
+			memcpy(hash_table[h], hash_table[h] + quality, sizeof(hash_table[h][0]) * quality);
+			stbi__sbn(hash_table[h]) = quality;
+		}
+		stbi__sbpush(hash_table[h], data + i);
+
+		if (bestloc)
+		{
+			// "lazy matching" - check match at *next* byte, and if it's better, do cur byte as literal
+			h = stbi__zhash(data + i + 1) & (stbi__ZHASH - 1);
+			hlist = hash_table[h];
+			n = stbi__sbcount(hlist);
+			for (j = 0; j < n; ++j)
+			{
+				if (hlist[j] - data > i - 32767)
+				{
+					int e = stbi__zlib_countm(hlist[j], data + i + 1, data_len - i - 1);
+					if (e > best)
+					{  // if next match is better, bail on current match
+						bestloc = NULL;
+						break;
+					}
+				}
+			}
+		}
+
+		if (bestloc)
+		{
+			int d = data + i - bestloc;  // distance back
+			assert(d <= 32767 && best <= 258);
+			for (j = 0; best > lengthc[j + 1] - 1; ++j)
+				;
+			stbi__zlib_huff(j + 257);
+			if (lengtheb[j]) stbi__zlib_add(best - lengthc[j], lengtheb[j]);
+			for (j = 0; d > distc[j + 1] - 1; ++j)
+				;
+			stbi__zlib_add(stbi__zlib_bitrev(j, 5), 5);
+			if (disteb[j]) stbi__zlib_add(d - distc[j], disteb[j]);
+			i += best;
+		}
+		else
+		{
+			stbi__zlib_huffb(data[i]);
+			++i;
+		}
+	}
+	// write out final bytes
+	for (; i < data_len; ++i)
+		stbi__zlib_huffb(data[i]);
+	stbi__zlib_huff(256);  // end of block
+	// pad with 0 bits to byte boundary
+	while (bitcount)
+		stbi__zlib_add(0, 1);
+
+	for (i = 0; i < stbi__ZHASH; ++i)
+		(void)stbi__sbfree(hash_table[i]);
+
+	{
+		// compute adler32 on input
+		unsigned int i = 0, s1 = 1, s2 = 0, blocklen = data_len % 5552;
+		int j = 0;
+		while (j < data_len)
+		{
+			for (i = 0; i < blocklen; ++i) s1 += data[j + i], s2 += s1;
+			s1 %= 65521, s2 %= 65521;
+			j += blocklen;
+			blocklen = 5552;
+		}
+		stbi__sbpush(out, (unsigned char)(s2 >> 8));
+		stbi__sbpush(out, (unsigned char)s2);
+		stbi__sbpush(out, (unsigned char)(s1 >> 8));
+		stbi__sbpush(out, (unsigned char)s1);
+	}
+	*out_len = stbi__sbn(out);
+	// make returned pointer freeable
+	memmove(stbi__sbraw(out), out, *out_len);
+	return (unsigned char *)stbi__sbraw(out);
+}
+
+unsigned int stbi__crc32(unsigned char *buffer, int len)
+{
+	static unsigned int crc_table[256];
+	unsigned int crc = ~0u;
+	int i, j;
+	if (crc_table[1] == 0)
+		for (i = 0; i < 256; i++)
+			for (crc_table[i] = i, j = 0; j < 8; ++j)
+				crc_table[i] = (crc_table[i] >> 1) ^ (crc_table[i] & 1 ? 0xedb88320 : 0);
+	for (i = 0; i < len; ++i)
+		crc = (crc >> 8) ^ crc_table[buffer[i] ^ (crc & 0xff)];
+	return ~crc;
+}
+
+#define stbi__wpng4(o, a, b, c, d) ((o)[0] = (unsigned char)(a), (o)[1] = (unsigned char)(b), (o)[2] = (unsigned char)(c), (o)[3] = (unsigned char)(d), (o) += 4)
+#define stbi__wp32(data, v) stbi__wpng4(data, (v) >> 24, (v) >> 16, (v) >> 8, (v));
+#define stbi__wptag(data, s) stbi__wpng4(data, s[0], s[1], s[2], s[3])
+
+static void stbi__wpcrc(unsigned char **data, int len)
+{
+	unsigned int crc = stbi__crc32(*data - len - 4, len + 4);
+	stbi__wp32(*data, crc);
+}
+
+static unsigned char stbi__paeth(int a, int b, int c)
+{
+	int p = a + b - c, pa = abs(p - a), pb = abs(p - b), pc = abs(p - c);
+	if (pa <= pb && pa <= pc) return (unsigned char)a;
+	if (pb <= pc) return (unsigned char)b;
+	return (unsigned char)c;
+}
+
+unsigned char *stbi_write_png_to_mem(unsigned char *pixels, int stride_bytes, int x, int y, int n, int *out_len)
+{
+	int ctype[5] = {-1, 0, 4, 2, 6};
+	unsigned char sig[8] = {137, 80, 78, 71, 13, 10, 26, 10};
+	unsigned char *out, *o, *filt, *zlib;
+	signed char *line_buffer;
+	int i, j, k, p, zlen;
+
+	if (stride_bytes == 0)
+		stride_bytes = x * n;
+
+	filt = (unsigned char *)malloc((x * n + 1) * y);
+	if (!filt) return 0;
+	line_buffer = (signed char *)malloc(x * n);
+	if (!line_buffer)
+	{
+		free(filt);
+		return 0;
+	}
+	for (j = 0; j < y; ++j)
+	{
+		static int mapping[] = {0, 1, 2, 3, 4};
+		static int firstmap[] = {0, 1, 0, 5, 6};
+		int *mymap = j ? mapping : firstmap;
+		int best = 0, bestval = 0x7fffffff;
+		for (p = 0; p < 2; ++p)
+		{
+			for (k = p ? best : 0; k < 5; ++k)
+			{
+				int type = mymap[k], est = 0;
+				unsigned char *z = pixels + stride_bytes * j;
+				for (i = 0; i < n; ++i)
+					switch (type)
+					{
+						case 0:
+							line_buffer[i] = z[i];
+							break;
+						case 1:
+							line_buffer[i] = z[i];
+							break;
+						case 2:
+							line_buffer[i] = z[i] - z[i - stride_bytes];
+							break;
+						case 3:
+							line_buffer[i] = z[i] - (z[i - stride_bytes] >> 1);
+							break;
+						case 4:
+							line_buffer[i] = (signed char)(z[i] - stbi__paeth(0, z[i - stride_bytes], 0));
+							break;
+						case 5:
+							line_buffer[i] = z[i];
+							break;
+						case 6:
+							line_buffer[i] = z[i];
+							break;
+					}
+				for (i = n; i < x * n; ++i)
+				{
+					switch (type)
+					{
+						case 0:
+							line_buffer[i] = z[i];
+							break;
+						case 1:
+							line_buffer[i] = z[i] - z[i - n];
+							break;
+						case 2:
+							line_buffer[i] = z[i] - z[i - stride_bytes];
+							break;
+						case 3:
+							line_buffer[i] = z[i] - ((z[i - n] + z[i - stride_bytes]) >> 1);
+							break;
+						case 4:
+							line_buffer[i] = z[i] - stbi__paeth(z[i - n], z[i - stride_bytes], z[i - stride_bytes - n]);
+							break;
+						case 5:
+							line_buffer[i] = z[i] - (z[i - n] >> 1);
+							break;
+						case 6:
+							line_buffer[i] = z[i] - stbi__paeth(z[i - n], 0, 0);
+							break;
+					}
+				}
+				if (p) break;
+				for (i = 0; i < x * n; ++i)
+					est += abs((signed char)line_buffer[i]);
+				if (est < bestval)
+				{
+					bestval = est;
+					best = k;
+				}
+			}
+		}
+		// when we get here, best contains the filter type, and line_buffer contains the data
+		filt[j * (x * n + 1)] = (unsigned char)best;
+		memcpy(filt + j * (x * n + 1) + 1, line_buffer, x * n);
+	}
+	free(line_buffer);
+	zlib = stbi_zlib_compress(filt, y * (x * n + 1), &zlen, 8);  // increase 8 to get smaller but use more memory
+	free(filt);
+	if (!zlib) return 0;
+
+	// each tag requires 12 bytes of overhead
+	out = (unsigned char *)malloc(8 + 12 + 13 + 12 + zlen + 12);
+	if (!out) return 0;
+	*out_len = 8 + 12 + 13 + 12 + zlen + 12;
+
+	o = out;
+	memcpy(o, sig, 8);
+	o += 8;
+	stbi__wp32(o, 13);  // header length
+	stbi__wptag(o, "IHDR");
+	stbi__wp32(o, x);
+	stbi__wp32(o, y);
+	*o++ = 8;
+	*o++ = (unsigned char)ctype[n];
+	*o++ = 0;
+	*o++ = 0;
+	*o++ = 0;
+	stbi__wpcrc(&o, 13);
+
+	stbi__wp32(o, zlen);
+	stbi__wptag(o, "IDAT");
+	memcpy(o, zlib, zlen);
+	o += zlen;
+	free(zlib);
+	stbi__wpcrc(&o, zlen);
+
+	stbi__wp32(o, 0);
+	stbi__wptag(o, "IEND");
+	stbi__wpcrc(&o, 0);
+
+	assert(o == out + *out_len);
+
+	return out;
+}
+
+int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes)
+{
+	FILE *f;
+	int len;
+	unsigned char *png = stbi_write_png_to_mem((unsigned char *)data, stride_bytes, x, y, comp, &len);
+	if (!png) return 0;
+	f = fopen(filename, "wb");
+	if (!f)
+	{
+		free(png);
+		return 0;
+	}
+	fwrite(png, 1, len, f);
+	fclose(f);
+	free(png);
+	return 1;
+}
+#endif  // STB_IMAGE_WRITE_IMPLEMENTATION
+
+/* Revision history
+
+      0.92 (2010-08-01)
+             casts to unsigned char to fix warnings
+      0.91 (2010-07-17)
+             first public release
+      0.90   first internal release
+*/
diff --git a/engine/inc/bullet/ThirdPartyLibs/stb_image/stb_truetype.h b/engine/inc/bullet/ThirdPartyLibs/stb_image/stb_truetype.h
new file mode 100644
index 00000000..4d84eb17
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/stb_image/stb_truetype.h
@@ -0,0 +1,3360 @@
+// stb_truetype.h - v1.06 - public domain
+// authored from 2009-2014 by Sean Barrett / RAD Game Tools
+//
+//   This library processes TrueType files:
+//        parse files
+//        extract glyph metrics
+//        extract glyph shapes
+//        render glyphs to one-channel bitmaps with antialiasing (box filter)
+//
+//   Todo:
+//        non-MS cmaps
+//        crashproof on bad data
+//        hinting? (no longer patented)
+//        cleartype-style AA?
+//        optimize: use simple memory allocator for intermediates
+//        optimize: build edge-list directly from curves
+//        optimize: rasterize directly from curves?
+//
+// ADDITIONAL CONTRIBUTORS
+//
+//   Mikko Mononen: compound shape support, more cmap formats
+//   Tor Andersson: kerning, subpixel rendering
+//
+//   Bug/warning reports/fixes:
+//       "Zer" on mollyrocket (with fix)
+//       Cass Everitt
+//       stoiko (Haemimont Games)
+//       Brian Hook
+//       Walter van Niftrik
+//       David Gow
+//       David Given
+//       Ivan-Assen Ivanov
+//       Anthony Pesch
+//       Johan Duparc
+//       Hou Qiming
+//       Fabian "ryg" Giesen
+//       Martins Mozeiko
+//       Cap Petschulat
+//       Omar Cornut
+//       github:aloucks
+//       Peter LaValle
+//
+//   Misc other:
+//       Ryan Gordon
+//
+// VERSION HISTORY
+//
+//   1.06 (2015-07-14) performance improvements (~35% faster on x86 and x64 on test machine)
+//                     also more precise AA rasterizer, except if shapes overlap
+//                     remove need for STBTT_sort
+//   1.05 (2015-04-15) fix misplaced definitions for STBTT_STATIC
+//   1.04 (2015-04-15) typo in example
+//   1.03 (2015-04-12) STBTT_STATIC, fix memory leak in new packing, various fixes
+//   1.02 (2014-12-10) fix various warnings & compile issues w/ stb_rect_pack, C++
+//   1.01 (2014-12-08) fix subpixel position when oversampling to exactly match
+//                        non-oversampled; STBTT_POINT_SIZE for packed case only
+//   1.00 (2014-12-06) add new PackBegin etc. API, w/ support for oversampling
+//   0.99 (2014-09-18) fix multiple bugs with subpixel rendering (ryg)
+//   0.9  (2014-08-07) support certain mac/iOS fonts without an MS platformID
+//   0.8b (2014-07-07) fix a warning
+//   0.8  (2014-05-25) fix a few more warnings
+//   0.7  (2013-09-25) bugfix: subpixel glyph bug fixed in 0.5 had come back
+//   0.6c (2012-07-24) improve documentation
+//   0.6b (2012-07-20) fix a few more warnings
+//   0.6  (2012-07-17) fix warnings; added stbtt_ScaleForMappingEmToPixels,
+//                        stbtt_GetFontBoundingBox, stbtt_IsGlyphEmpty
+//   0.5  (2011-12-09) bugfixes:
+//                        subpixel glyph renderer computed wrong bounding box
+//                        first vertex of shape can be off-curve (FreeSans)
+//   0.4b (2011-12-03) fixed an error in the font baking example
+//   0.4  (2011-12-01) kerning, subpixel rendering (tor)
+//                    bugfixes for:
+//                        codepoint-to-glyph conversion using table fmt=12
+//                        codepoint-to-glyph conversion using table fmt=4
+//                        stbtt_GetBakedQuad with non-square texture (Zer)
+//                    updated Hello World! sample to use kerning and subpixel
+//                    fixed some warnings
+//   0.3  (2009-06-24) cmap fmt=12, compound shapes (MM)
+//                    userdata, malloc-from-userdata, non-zero fill (stb)
+//   0.2  (2009-03-11) Fix unsigned/signed char warnings
+//   0.1  (2009-03-09) First public release
+//
+// LICENSE
+//
+//   This software is in the public domain. Where that dedication is not
+//   recognized, you are granted a perpetual, irrevokable license to copy
+//   and modify this file as you see fit.
+//
+// USAGE
+//
+//   Include this file in whatever places neeed to refer to it. In ONE C/C++
+//   file, write:
+//      #define STB_TRUETYPE_IMPLEMENTATION
+//   before the #include of this file. This expands out the actual
+//   implementation into that C/C++ file.
+//
+//   To make the implementation private to the file that generates the implementation,
+//      #define STBTT_STATIC
+//
+//   Simple 3D API (don't ship this, but it's fine for tools and quick start)
+//           stbtt_BakeFontBitmap()               -- bake a font to a bitmap for use as texture
+//           stbtt_GetBakedQuad()                 -- compute quad to draw for a given char
+//
+//   Improved 3D API (more shippable):
+//           #include "stb_rect_pack.h"           -- optional, but you really want it
+//           stbtt_PackBegin()
+//           stbtt_PackSetOversample()            -- for improved quality on small fonts
+//           stbtt_PackFontRanges()
+//           stbtt_PackEnd()
+//           stbtt_GetPackedQuad()
+//
+//   "Load" a font file from a memory buffer (you have to keep the buffer loaded)
+//           stbtt_InitFont()
+//           stbtt_GetFontOffsetForIndex()        -- use for TTC font collections
+//
+//   Render a unicode codepoint to a bitmap
+//           stbtt_GetCodepointBitmap()           -- allocates and returns a bitmap
+//           stbtt_MakeCodepointBitmap()          -- renders into bitmap you provide
+//           stbtt_GetCodepointBitmapBox()        -- how big the bitmap must be
+//
+//   Character advance/positioning
+//           stbtt_GetCodepointHMetrics()
+//           stbtt_GetFontVMetrics()
+//           stbtt_GetCodepointKernAdvance()
+//
+//   Starting with version 1.06, the rasterizer was replaced with a new,
+//   faster and generally-more-precise rasterizer. The new rasterizer more
+//   accurately measures pixel coverage for anti-aliasing, except in the case
+//   where multiple shapes overlap, in which case it overestimates the AA pixel
+//   coverage. Thus, anti-aliasing of intersecting shapes may look wrong. If
+//   this turns out to be a problem, you can re-enable the old rasterizer with
+//        #define STBTT_RASTERIZER_VERSION 1
+//   which will incur about a 15% speed hit.
+//
+// ADDITIONAL DOCUMENTATION
+//
+//   Immediately after this block comment are a series of sample programs.
+//
+//   After the sample programs is the "header file" section. This section
+//   includes documentation for each API function.
+//
+//   Some important concepts to understand to use this library:
+//
+//      Codepoint
+//         Characters are defined by unicode codepoints, e.g. 65 is
+//         uppercase A, 231 is lowercase c with a cedilla, 0x7e30 is
+//         the hiragana for "ma".
+//
+//      Glyph
+//         A visual character shape (every codepoint is rendered as
+//         some glyph)
+//
+//      Glyph index
+//         A font-specific integer ID representing a glyph
+//
+//      Baseline
+//         Glyph shapes are defined relative to a baseline, which is the
+//         bottom of uppercase characters. Characters extend both above
+//         and below the baseline.
+//
+//      Current Point
+//         As you draw text to the screen, you keep track of a "current point"
+//         which is the origin of each character. The current point's vertical
+//         position is the baseline. Even "baked fonts" use this model.
+//
+//      Vertical Font Metrics
+//         The vertical qualities of the font, used to vertically position
+//         and space the characters. See docs for stbtt_GetFontVMetrics.
+//
+//      Font Size in Pixels or Points
+//         The preferred interface for specifying font sizes in stb_truetype
+//         is to specify how tall the font's vertical extent should be in pixels.
+//         If that sounds good enough, skip the next paragraph.
+//
+//         Most font APIs instead use "points", which are a common typographic
+//         measurement for describing font size, defined as 72 points per inch.
+//         stb_truetype provides a point API for compatibility. However, true
+//         "per inch" conventions don't make much sense on computer displays
+//         since they different monitors have different number of pixels per
+//         inch. For example, Windows traditionally uses a convention that
+//         there are 96 pixels per inch, thus making 'inch' measurements have
+//         nothing to do with inches, and thus effectively defining a point to
+//         be 1.333 pixels. Additionally, the TrueType font data provides
+//         an explicit scale factor to scale a given font's glyphs to points,
+//         but the author has observed that this scale factor is often wrong
+//         for non-commercial fonts, thus making fonts scaled in points
+//         according to the TrueType spec incoherently sized in practice.
+//
+// ADVANCED USAGE
+//
+//   Quality:
+//
+//    - Use the functions with Subpixel at the end to allow your characters
+//      to have subpixel positioning. Since the font is anti-aliased, not
+//      hinted, this is very import for quality. (This is not possible with
+//      baked fonts.)
+//
+//    - Kerning is now supported, and if you're supporting subpixel rendering
+//      then kerning is worth using to give your text a polished look.
+//
+//   Performance:
+//
+//    - Convert Unicode codepoints to glyph indexes and operate on the glyphs;
+//      if you don't do this, stb_truetype is forced to do the conversion on
+//      every call.
+//
+//    - There are a lot of memory allocations. We should modify it to take
+//      a temp buffer and allocate from the temp buffer (without freeing),
+//      should help performance a lot.
+//
+// NOTES
+//
+//   The system uses the raw data found in the .ttf file without changing it
+//   and without building auxiliary data structures. This is a bit inefficient
+//   on little-endian systems (the data is big-endian), but assuming you're
+//   caching the bitmaps or glyph shapes this shouldn't be a big deal.
+//
+//   It appears to be very hard to programmatically determine what font a
+//   given file is in a general way. I provide an API for this, but I don't
+//   recommend it.
+//
+//
+// SOURCE STATISTICS (based on v0.6c, 2050 LOC)
+//
+//   Documentation & header file        520 LOC  \___ 660 LOC documentation
+//   Sample code                        140 LOC  /
+//   Truetype parsing                   620 LOC  ---- 620 LOC TrueType
+//   Software rasterization             240 LOC  \                           .
+//   Curve tesselation                  120 LOC   \__ 550 LOC Bitmap creation
+//   Bitmap management                  100 LOC   /
+//   Baked bitmap interface              70 LOC  /
+//   Font name matching & access        150 LOC  ---- 150
+//   C runtime library abstraction       60 LOC  ----  60
+//
+//
+// PERFORMANCE MEASUREMENTS FOR 1.06:
+//
+//                      32-bit     64-bit
+//   Previous release:  8.83 s     7.68 s
+//   Pool allocations:  7.72 s     6.34 s
+//   Inline sort     :  6.54 s     5.65 s
+//   New rasterizer  :  5.63 s     5.00 s
+
+//////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+////
+////  SAMPLE PROGRAMS
+////
+//
+//  Incomplete text-in-3d-api example, which draws quads properly aligned to be lossless
+//
+#if 0
+#define STB_TRUETYPE_IMPLEMENTATION  // force following include to generate implementation
+#include "stb_truetype.h"
+
+unsigned char ttf_buffer[1<<20];
+unsigned char temp_bitmap[512*512];
+
+stbtt_bakedchar cdata[96]; // ASCII 32..126 is 95 glyphs
+GLuint ftex;
+
+void my_stbtt_initfont(void)
+{
+   fread(ttf_buffer, 1, 1<<20, fopen("c:/windows/fonts/times.ttf", "rb"));
+   stbtt_BakeFontBitmap(ttf_buffer,0, 32.0, temp_bitmap,512,512, 32,96, cdata); // no guarantee this fits!
+   // can free ttf_buffer at this point
+   glGenTextures(1, &ftex);
+   glBindTexture(GL_TEXTURE_2D, ftex);
+   glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, 512,512, 0, GL_ALPHA, GL_UNSIGNED_BYTE, temp_bitmap);
+   // can free temp_bitmap at this point
+   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+}
+
+void my_stbtt_print(float x, float y, char *text)
+{
+   // assume orthographic projection with units = screen pixels, origin at top left
+   glEnable(GL_TEXTURE_2D);
+   glBindTexture(GL_TEXTURE_2D, ftex);
+   glBegin(GL_QUADS);
+   while (*text) {
+      if (*text >= 32 && *text < 128) {
+         stbtt_aligned_quad q;
+         stbtt_GetBakedQuad(cdata, 512,512, *text-32, &x,&y,&q,1);//1=opengl & d3d10+,0=d3d9
+         glTexCoord2f(q.s0,q.t1); glVertex2f(q.x0,q.y0);
+         glTexCoord2f(q.s1,q.t1); glVertex2f(q.x1,q.y0);
+         glTexCoord2f(q.s1,q.t0); glVertex2f(q.x1,q.y1);
+         glTexCoord2f(q.s0,q.t0); glVertex2f(q.x0,q.y1);
+      }
+      ++text;
+   }
+   glEnd();
+}
+#endif
+//
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// Complete program (this compiles): get a single bitmap, print as ASCII art
+//
+#if 0
+#include <stdio.h>
+#define STB_TRUETYPE_IMPLEMENTATION  // force following include to generate implementation
+#include "stb_truetype.h"
+
+char ttf_buffer[1<<25];
+
+int main(int argc, char **argv)
+{
+   stbtt_fontinfo font;
+   unsigned char *bitmap;
+   int w,h,i,j,c = (argc > 1 ? atoi(argv[1]) : 'a'), s = (argc > 2 ? atoi(argv[2]) : 20);
+
+   fread(ttf_buffer, 1, 1<<25, fopen(argc > 3 ? argv[3] : "c:/windows/fonts/arialbd.ttf", "rb"));
+
+   stbtt_InitFont(&font, ttf_buffer, stbtt_GetFontOffsetForIndex(ttf_buffer,0));
+   bitmap = stbtt_GetCodepointBitmap(&font, 0,stbtt_ScaleForPixelHeight(&font, s), c, &w, &h, 0,0);
+
+   for (j=0; j < h; ++j) {
+      for (i=0; i < w; ++i)
+         putchar(" .:ioVM@"[bitmap[j*w+i]>>5]);
+      putchar('\n');
+   }
+   return 0;
+}
+#endif
+//
+// Output:
+//
+//     .ii.
+//    @@@@@@.
+//   V@Mio@@o
+//   :i.  V@V
+//     :oM@@M
+//   :@@@MM@M
+//   @@o  o@M
+//  :@@.  M@M
+//   @@@o@@@@
+//   :M@@V:@@.
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// Complete program: print "Hello World!" banner, with bugs
+//
+#if 0
+char buffer[24<<20];
+unsigned char screen[20][79];
+
+int main(int arg, char **argv)
+{
+   stbtt_fontinfo font;
+   int i,j,ascent,baseline,ch=0;
+   float scale, xpos=2; // leave a little padding in case the character extends left
+   char *text = "Heljo World!"; // intentionally misspelled to show 'lj' brokenness
+
+   fread(buffer, 1, 1000000, fopen("c:/windows/fonts/arialbd.ttf", "rb"));
+   stbtt_InitFont(&font, buffer, 0);
+
+   scale = stbtt_ScaleForPixelHeight(&font, 15);
+   stbtt_GetFontVMetrics(&font, &ascent,0,0);
+   baseline = (int) (ascent*scale);
+
+   while (text[ch]) {
+      int advance,lsb,x0,y0,x1,y1;
+      float x_shift = xpos - (float) floor(xpos);
+      stbtt_GetCodepointHMetrics(&font, text[ch], &advance, &lsb);
+      stbtt_GetCodepointBitmapBoxSubpixel(&font, text[ch], scale,scale,x_shift,0, &x0,&y0,&x1,&y1);
+      stbtt_MakeCodepointBitmapSubpixel(&font, &screen[baseline + y0][(int) xpos + x0], x1-x0,y1-y0, 79, scale,scale,x_shift,0, text[ch]);
+      // note that this stomps the old data, so where character boxes overlap (e.g. 'lj') it's wrong
+      // because this API is really for baking character bitmaps into textures. if you want to render
+      // a sequence of characters, you really need to render each bitmap to a temp buffer, then
+      // "alpha blend" that into the working buffer
+      xpos += (advance * scale);
+      if (text[ch+1])
+         xpos += scale*stbtt_GetCodepointKernAdvance(&font, text[ch],text[ch+1]);
+      ++ch;
+   }
+
+   for (j=0; j < 20; ++j) {
+      for (i=0; i < 78; ++i)
+         putchar(" .:ioVM@"[screen[j][i]>>5]);
+      putchar('\n');
+   }
+
+   return 0;
+}
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+////
+////   INTEGRATION WITH YOUR CODEBASE
+////
+////   The following sections allow you to supply alternate definitions
+////   of C library functions used by stb_truetype.
+
+#ifdef STB_TRUETYPE_IMPLEMENTATION
+// #define your own (u)stbtt_int8/16/32 before including to override this
+#ifndef stbtt_uint8
+typedef unsigned char stbtt_uint8;
+typedef signed char stbtt_int8;
+typedef unsigned short stbtt_uint16;
+typedef signed short stbtt_int16;
+typedef unsigned int stbtt_uint32;
+typedef signed int stbtt_int32;
+#endif
+
+typedef char stbtt__check_size32[sizeof(stbtt_int32) == 4 ? 1 : -1];
+typedef char stbtt__check_size16[sizeof(stbtt_int16) == 2 ? 1 : -1];
+
+// #define your own STBTT_ifloor/STBTT_iceil() to avoid math.h
+#ifndef STBTT_ifloor
+#include <math.h>
+#define STBTT_ifloor(x) ((int)floor(x))
+#define STBTT_iceil(x) ((int)ceil(x))
+#endif
+
+#ifndef STBTT_sqrt
+#include <math.h>
+#define STBTT_sqrt(x) sqrt(x)
+#endif
+
+// #define your own functions "STBTT_malloc" / "STBTT_free" to avoid malloc.h
+#ifndef STBTT_malloc
+#include <stdlib.h>
+#define STBTT_malloc(x, u) ((void)(u), malloc(x))
+#define STBTT_free(x, u) ((void)(u), free(x))
+#endif
+
+#ifndef STBTT_assert
+#include <assert.h>
+#define STBTT_assert(x) assert(x)
+#endif
+
+#ifndef STBTT_strlen
+#include <string.h>
+#define STBTT_strlen(x) strlen(x)
+#endif
+
+#ifndef STBTT_memcpy
+#include <memory.h>
+#define STBTT_memcpy memcpy
+#define STBTT_memset memset
+#endif
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+////
+////   INTERFACE
+////
+////
+
+#ifndef __STB_INCLUDE_STB_TRUETYPE_H__
+#define __STB_INCLUDE_STB_TRUETYPE_H__
+
+#ifdef STBTT_STATIC
+#define STBTT_DEF static
+#else
+#define STBTT_DEF extern
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	//////////////////////////////////////////////////////////////////////////////
+	//
+	// TEXTURE BAKING API
+	//
+	// If you use this API, you only have to call two functions ever.
+	//
+
+	typedef struct
+	{
+		unsigned short x0, y0, x1, y1;  // coordinates of bbox in bitmap
+		float xoff, yoff, xadvance;
+	} stbtt_bakedchar;
+
+	STBTT_DEF int stbtt_BakeFontBitmap(const unsigned char *data, int offset,  // font location (use offset=0 for plain .ttf)
+									   float pixel_height,                     // height of font in pixels
+									   unsigned char *pixels, int pw, int ph,  // bitmap to be filled in
+									   int first_char, int num_chars,          // characters to bake
+									   stbtt_bakedchar *chardata);             // you allocate this, it's num_chars long
+	// if return is positive, the first unused row of the bitmap
+	// if return is negative, returns the negative of the number of characters that fit
+	// if return is 0, no characters fit and no rows were used
+	// This uses a very crappy packing.
+
+	typedef struct
+	{
+		float x0, y0, s0, t0;  // top-left
+		float x1, y1, s1, t1;  // bottom-right
+	} stbtt_aligned_quad;
+
+	STBTT_DEF void stbtt_GetBakedQuad(stbtt_bakedchar *chardata, int pw, int ph,  // same data as above
+									  int char_index,                             // character to display
+									  float *xpos, float *ypos,                   // pointers to current position in screen pixel space
+									  stbtt_aligned_quad *q,                      // output: quad to draw
+									  int opengl_fillrule);                       // true if opengl fill rule; false if DX9 or earlier
+	// Call GetBakedQuad with char_index = 'character - first_char', and it
+	// creates the quad you need to draw and advances the current position.
+	//
+	// The coordinate system used assumes y increases downwards.
+	//
+	// Characters will extend both above and below the current position;
+	// see discussion of "BASELINE" above.
+	//
+	// It's inefficient; you might want to c&p it and optimize it.
+
+	//////////////////////////////////////////////////////////////////////////////
+	//
+	// NEW TEXTURE BAKING API
+	//
+	// This provides options for packing multiple fonts into one atlas, not
+	// perfectly but better than nothing.
+
+	typedef struct
+	{
+		unsigned short x0, y0, x1, y1;  // coordinates of bbox in bitmap
+		float xoff, yoff, xadvance;
+		float xoff2, yoff2;
+	} stbtt_packedchar;
+
+	typedef struct stbtt_pack_context stbtt_pack_context;
+
+	STBTT_DEF int stbtt_PackBegin(stbtt_pack_context *spc, unsigned char *pixels, int width, int height, int stride_in_bytes, int padding, void *alloc_context);
+	// Initializes a packing context stored in the passed-in stbtt_pack_context.
+	// Future calls using this context will pack characters into the bitmap passed
+	// in here: a 1-channel bitmap that is weight x height. stride_in_bytes is
+	// the distance from one row to the next (or 0 to mean they are packed tightly
+	// together). "padding" is // the amount of padding to leave between each
+	// character (normally you want '1' for bitmaps you'll use as textures with
+	// bilinear filtering).
+	//
+	// Returns 0 on failure, 1 on success.
+
+	STBTT_DEF void stbtt_PackEnd(stbtt_pack_context *spc);
+	// Cleans up the packing context and frees all memory.
+
+#define STBTT_POINT_SIZE(x) (-(x))
+
+	STBTT_DEF int stbtt_PackFontRange(stbtt_pack_context *spc, unsigned char *fontdata, int font_index, float font_size,
+									  int first_unicode_char_in_range, int num_chars_in_range, stbtt_packedchar *chardata_for_range);
+	// Creates character bitmaps from the font_index'th font found in fontdata (use
+	// font_index=0 if you don't know what that is). It creates num_chars_in_range
+	// bitmaps for characters with unicode values starting at first_unicode_char_in_range
+	// and increasing. Data for how to render them is stored in chardata_for_range;
+	// pass these to stbtt_GetPackedQuad to get back renderable quads.
+	//
+	// font_size is the full height of the character from ascender to descender,
+	// as computed by stbtt_ScaleForPixelHeight. To use a point size as computed
+	// by stbtt_ScaleForMappingEmToPixels, wrap the point size in STBTT_POINT_SIZE()
+	// and pass that result as 'font_size':
+	//       ...,                  20 , ... // font max minus min y is 20 pixels tall
+	//       ..., STBTT_POINT_SIZE(20), ... // 'M' is 20 pixels tall
+
+	typedef struct
+	{
+		float font_size;
+		int first_unicode_char_in_range;
+		int num_chars_in_range;
+		stbtt_packedchar *chardata_for_range;  // output
+	} stbtt_pack_range;
+
+	STBTT_DEF int stbtt_PackFontRanges(stbtt_pack_context *spc, unsigned char *fontdata, int font_index, stbtt_pack_range *ranges, int num_ranges);
+	// Creates character bitmaps from multiple ranges of characters stored in
+	// ranges. This will usually create a better-packed bitmap than multiple
+	// calls to stbtt_PackFontRange.
+
+	STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsigned int h_oversample, unsigned int v_oversample);
+	// Oversampling a font increases the quality by allowing higher-quality subpixel
+	// positioning, and is especially valuable at smaller text sizes.
+	//
+	// This function sets the amount of oversampling for all following calls to
+	// stbtt_PackFontRange(s). The default (no oversampling) is achieved by
+	// h_oversample=1, v_oversample=1. The total number of pixels required is
+	// h_oversample*v_oversample larger than the default; for example, 2x2
+	// oversampling requires 4x the storage of 1x1. For best results, render
+	// oversampled textures with bilinear filtering. Look at the readme in
+	// stb/tests/oversample for information about oversampled fonts
+
+	STBTT_DEF void stbtt_GetPackedQuad(stbtt_packedchar *chardata, int pw, int ph,  // same data as above
+									   int char_index,                              // character to display
+									   float *xpos, float *ypos,                    // pointers to current position in screen pixel space
+									   stbtt_aligned_quad *q,                       // output: quad to draw
+									   int align_to_integer);
+
+	// this is an opaque structure that you shouldn't mess with which holds
+	// all the context needed from PackBegin to PackEnd.
+	struct stbtt_pack_context
+	{
+		void *user_allocator_context;
+		void *pack_info;
+		int width;
+		int height;
+		int stride_in_bytes;
+		int padding;
+		unsigned int h_oversample, v_oversample;
+		unsigned char *pixels;
+		void *nodes;
+	};
+
+	//////////////////////////////////////////////////////////////////////////////
+	//
+	// FONT LOADING
+	//
+	//
+
+	STBTT_DEF int stbtt_GetFontOffsetForIndex(const unsigned char *data, int index);
+	// Each .ttf/.ttc file may have more than one font. Each font has a sequential
+	// index number starting from 0. Call this function to get the font offset for
+	// a given index; it returns -1 if the index is out of range. A regular .ttf
+	// file will only define one font and it always be at offset 0, so it will
+	// return '0' for index 0, and -1 for all other indices. You can just skip
+	// this step if you know it's that kind of font.
+
+	// The following structure is defined publically so you can declare one on
+	// the stack or as a global or etc, but you should treat it as opaque.
+	typedef struct stbtt_fontinfo
+	{
+		void *userdata;
+		unsigned char *data;  // pointer to .ttf file
+		int fontstart;        // offset of start of font
+
+		int numGlyphs;  // number of glyphs, needed for range checking
+
+		int loca, head, glyf, hhea, hmtx, kern;  // table locations as offset from start of .ttf
+		int index_map;                           // a cmap mapping for our chosen character encoding
+		int indexToLocFormat;                    // format needed to map from glyph index to glyph
+	} stbtt_fontinfo;
+
+	STBTT_DEF int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data, int offset);
+	// Given an offset into the file that defines a font, this function builds
+	// the necessary cached info for the rest of the system. You must allocate
+	// the stbtt_fontinfo yourself, and stbtt_InitFont will fill it out. You don't
+	// need to do anything special to free it, because the contents are pure
+	// value data with no additional data structures. Returns 0 on failure.
+
+	//////////////////////////////////////////////////////////////////////////////
+	//
+	// CHARACTER TO GLYPH-INDEX CONVERSIOn
+
+	STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint);
+	// If you're going to perform multiple operations on the same character
+	// and you want a speed-up, call this function with the character you're
+	// going to process, then use glyph-based functions instead of the
+	// codepoint-based functions.
+
+	//////////////////////////////////////////////////////////////////////////////
+	//
+	// CHARACTER PROPERTIES
+	//
+
+	STBTT_DEF float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float pixels);
+	// computes a scale factor to produce a font whose "height" is 'pixels' tall.
+	// Height is measured as the distance from the highest ascender to the lowest
+	// descender; in other words, it's equivalent to calling stbtt_GetFontVMetrics
+	// and computing:
+	//       scale = pixels / (ascent - descent)
+	// so if you prefer to measure height by the ascent only, use a similar calculation.
+
+	STBTT_DEF float stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *info, float pixels);
+	// computes a scale factor to produce a font whose EM size is mapped to
+	// 'pixels' tall. This is probably what traditional APIs compute, but
+	// I'm not positive.
+
+	STBTT_DEF void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap);
+	// ascent is the coordinate above the baseline the font extends; descent
+	// is the coordinate below the baseline the font extends (i.e. it is typically negative)
+	// lineGap is the spacing between one row's descent and the next row's ascent...
+	// so you should advance the vertical position by "*ascent - *descent + *lineGap"
+	//   these are expressed in unscaled coordinates, so you must multiply by
+	//   the scale factor for a given size
+
+	STBTT_DEF void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int *x0, int *y0, int *x1, int *y1);
+	// the bounding box around all possible characters
+
+	STBTT_DEF void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing);
+	// leftSideBearing is the offset from the current horizontal position to the left edge of the character
+	// advanceWidth is the offset from the current horizontal position to the next horizontal position
+	//   these are expressed in unscaled coordinates
+
+	STBTT_DEF int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2);
+	// an additional amount to add to the 'advance' value between ch1 and ch2
+
+	STBTT_DEF int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1);
+	// Gets the bounding box of the visible part of the glyph, in unscaled coordinates
+
+	STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing);
+	STBTT_DEF int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2);
+	STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1);
+	// as above, but takes one or more glyph indices for greater efficiency
+
+	//////////////////////////////////////////////////////////////////////////////
+	//
+	// GLYPH SHAPES (you probably don't need these, but they have to go before
+	// the bitmaps for C declaration-order reasons)
+	//
+
+#ifndef STBTT_vmove  // you can predefine these to use different values (but why?)
+	enum
+	{
+		STBTT_vmove = 1,
+		STBTT_vline,
+		STBTT_vcurve
+	};
+#endif
+
+#ifndef stbtt_vertex             // you can predefine this to use different values \
+								 // (we share this with other code at RAD)
+#define stbtt_vertex_type short  // can't use stbtt_int16 because that's not visible in the header file
+	typedef struct
+	{
+		stbtt_vertex_type x, y, cx, cy;
+		unsigned char type, padding;
+	} stbtt_vertex;
+#endif
+
+	STBTT_DEF int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index);
+	// returns non-zero if nothing is drawn for this glyph
+
+	STBTT_DEF int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, stbtt_vertex **vertices);
+	STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **vertices);
+	// returns # of vertices and fills *vertices with the pointer to them
+	//   these are expressed in "unscaled" coordinates
+	//
+	// The shape is a series of countours. Each one starts with
+	// a STBTT_moveto, then consists of a series of mixed
+	// STBTT_lineto and STBTT_curveto segments. A lineto
+	// draws a line from previous endpoint to its x,y; a curveto
+	// draws a quadratic bezier from previous endpoint to
+	// its x,y, using cx,cy as the bezier control point.
+
+	STBTT_DEF void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *vertices);
+	// frees the data allocated above
+
+	//////////////////////////////////////////////////////////////////////////////
+	//
+	// BITMAP RENDERING
+	//
+
+	STBTT_DEF void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata);
+	// frees the bitmap allocated below
+
+	STBTT_DEF unsigned char *stbtt_GetCodepointBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int codepoint, int *width, int *height, int *xoff, int *yoff);
+	// allocates a large-enough single-channel 8bpp bitmap and renders the
+	// specified character/glyph at the specified scale into it, with
+	// antialiasing. 0 is no coverage (transparent), 255 is fully covered (opaque).
+	// *width & *height are filled out with the width & height of the bitmap,
+	// which is stored left-to-right, top-to-bottom.
+	//
+	// xoff/yoff are the offset it pixel space from the glyph origin to the top-left of the bitmap
+
+	STBTT_DEF unsigned char *stbtt_GetCodepointBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint, int *width, int *height, int *xoff, int *yoff);
+	// the same as stbtt_GetCodepoitnBitmap, but you can specify a subpixel
+	// shift for the character
+
+	STBTT_DEF void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int codepoint);
+	// the same as stbtt_GetCodepointBitmap, but you pass in storage for the bitmap
+	// in the form of 'output', with row spacing of 'out_stride' bytes. the bitmap
+	// is clipped to out_w/out_h bytes. Call stbtt_GetCodepointBitmapBox to get the
+	// width and height and positioning info for it first.
+
+	STBTT_DEF void stbtt_MakeCodepointBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint);
+	// same as stbtt_MakeCodepointBitmap, but you can specify a subpixel
+	// shift for the character
+
+	STBTT_DEF void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1);
+	// get the bbox of the bitmap centered around the glyph origin; so the
+	// bitmap width is ix1-ix0, height is iy1-iy0, and location to place
+	// the bitmap top left is (leftSideBearing*scale,iy0).
+	// (Note that the bitmap uses y-increases-down, but the shape uses
+	// y-increases-up, so CodepointBitmapBox and CodepointBox are inverted.)
+
+	STBTT_DEF void stbtt_GetCodepointBitmapBoxSubpixel(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1);
+	// same as stbtt_GetCodepointBitmapBox, but you can specify a subpixel
+	// shift for the character
+
+	// the following functions are equivalent to the above functions, but operate
+	// on glyph indices instead of Unicode codepoints (for efficiency)
+	STBTT_DEF unsigned char *stbtt_GetGlyphBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int glyph, int *width, int *height, int *xoff, int *yoff);
+	STBTT_DEF unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int glyph, int *width, int *height, int *xoff, int *yoff);
+	STBTT_DEF void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int glyph);
+	STBTT_DEF void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int glyph);
+	STBTT_DEF void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1);
+	STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1);
+
+	// @TODO: don't expose this structure
+	typedef struct
+	{
+		int w, h, stride;
+		unsigned char *pixels;
+	} stbtt__bitmap;
+
+	STBTT_DEF void stbtt_Rasterize(stbtt__bitmap *result, float flatness_in_pixels, stbtt_vertex *vertices, int num_verts, float scale_x, float scale_y, float shift_x, float shift_y, int x_off, int y_off, int invert, void *userdata);
+
+	//////////////////////////////////////////////////////////////////////////////
+	//
+	// Finding the right font...
+	//
+	// You should really just solve this offline, keep your own tables
+	// of what font is what, and don't try to get it out of the .ttf file.
+	// That's because getting it out of the .ttf file is really hard, because
+	// the names in the file can appear in many possible encodings, in many
+	// possible languages, and e.g. if you need a case-insensitive comparison,
+	// the details of that depend on the encoding & language in a complex way
+	// (actually underspecified in truetype, but also gigantic).
+	//
+	// But you can use the provided functions in two possible ways:
+	//     stbtt_FindMatchingFont() will use *case-sensitive* comparisons on
+	//             unicode-encoded names to try to find the font you want;
+	//             you can run this before calling stbtt_InitFont()
+	//
+	//     stbtt_GetFontNameString() lets you get any of the various strings
+	//             from the file yourself and do your own comparisons on them.
+	//             You have to have called stbtt_InitFont() first.
+
+	STBTT_DEF int stbtt_FindMatchingFont(const unsigned char *fontdata, const char *name, int flags);
+// returns the offset (not index) of the font that matches, or -1 if none
+//   if you use STBTT_MACSTYLE_DONTCARE, use a font name like "Arial Bold".
+//   if you use any other flag, use a font name like "Arial"; this checks
+//     the 'macStyle' header field; i don't know if fonts set this consistently
+#define STBTT_MACSTYLE_DONTCARE 0
+#define STBTT_MACSTYLE_BOLD 1
+#define STBTT_MACSTYLE_ITALIC 2
+#define STBTT_MACSTYLE_UNDERSCORE 4
+#define STBTT_MACSTYLE_NONE 8  // <= not same as 0, this makes us check the bitfield is 0
+
+	STBTT_DEF int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2);
+	// returns 1/0 whether the first string interpreted as utf8 is identical to
+	// the second string interpreted as big-endian utf16... useful for strings from next func
+
+	STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID);
+	// returns the string (which may be big-endian double byte, e.g. for unicode)
+	// and puts the length in bytes in *length.
+	//
+	// some of the values for the IDs are below; for more see the truetype spec:
+	//     http://developer.apple.com/textfonts/TTRefMan/RM06/Chap6name.html
+	//     http://www.microsoft.com/typography/otspec/name.htm
+
+	enum
+	{  // platformID
+		STBTT_PLATFORM_ID_UNICODE = 0,
+		STBTT_PLATFORM_ID_MAC = 1,
+		STBTT_PLATFORM_ID_ISO = 2,
+		STBTT_PLATFORM_ID_MICROSOFT = 3
+	};
+
+	enum
+	{  // encodingID for STBTT_PLATFORM_ID_UNICODE
+		STBTT_UNICODE_EID_UNICODE_1_0 = 0,
+		STBTT_UNICODE_EID_UNICODE_1_1 = 1,
+		STBTT_UNICODE_EID_ISO_10646 = 2,
+		STBTT_UNICODE_EID_UNICODE_2_0_BMP = 3,
+		STBTT_UNICODE_EID_UNICODE_2_0_FULL = 4
+	};
+
+	enum
+	{  // encodingID for STBTT_PLATFORM_ID_MICROSOFT
+		STBTT_MS_EID_SYMBOL = 0,
+		STBTT_MS_EID_UNICODE_BMP = 1,
+		STBTT_MS_EID_SHIFTJIS = 2,
+		STBTT_MS_EID_UNICODE_FULL = 10
+	};
+
+	enum
+	{  // encodingID for STBTT_PLATFORM_ID_MAC; same as Script Manager codes
+		STBTT_MAC_EID_ROMAN = 0,
+		STBTT_MAC_EID_ARABIC = 4,
+		STBTT_MAC_EID_JAPANESE = 1,
+		STBTT_MAC_EID_HEBREW = 5,
+		STBTT_MAC_EID_CHINESE_TRAD = 2,
+		STBTT_MAC_EID_GREEK = 6,
+		STBTT_MAC_EID_KOREAN = 3,
+		STBTT_MAC_EID_RUSSIAN = 7
+	};
+
+	enum
+	{  // languageID for STBTT_PLATFORM_ID_MICROSOFT; same as LCID...
+		// problematic because there are e.g. 16 english LCIDs and 16 arabic LCIDs
+		STBTT_MS_LANG_ENGLISH = 0x0409,
+		STBTT_MS_LANG_ITALIAN = 0x0410,
+		STBTT_MS_LANG_CHINESE = 0x0804,
+		STBTT_MS_LANG_JAPANESE = 0x0411,
+		STBTT_MS_LANG_DUTCH = 0x0413,
+		STBTT_MS_LANG_KOREAN = 0x0412,
+		STBTT_MS_LANG_FRENCH = 0x040c,
+		STBTT_MS_LANG_RUSSIAN = 0x0419,
+		STBTT_MS_LANG_GERMAN = 0x0407,
+		STBTT_MS_LANG_SPANISH = 0x0409,
+		STBTT_MS_LANG_HEBREW = 0x040d,
+		STBTT_MS_LANG_SWEDISH = 0x041D
+	};
+
+	enum
+	{  // languageID for STBTT_PLATFORM_ID_MAC
+		STBTT_MAC_LANG_ENGLISH = 0,
+		STBTT_MAC_LANG_JAPANESE = 11,
+		STBTT_MAC_LANG_ARABIC = 12,
+		STBTT_MAC_LANG_KOREAN = 23,
+		STBTT_MAC_LANG_DUTCH = 4,
+		STBTT_MAC_LANG_RUSSIAN = 32,
+		STBTT_MAC_LANG_FRENCH = 1,
+		STBTT_MAC_LANG_SPANISH = 6,
+		STBTT_MAC_LANG_GERMAN = 2,
+		STBTT_MAC_LANG_SWEDISH = 5,
+		STBTT_MAC_LANG_HEBREW = 10,
+		STBTT_MAC_LANG_CHINESE_SIMPLIFIED = 33,
+		STBTT_MAC_LANG_ITALIAN = 3,
+		STBTT_MAC_LANG_CHINESE_TRAD = 19
+	};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // __STB_INCLUDE_STB_TRUETYPE_H__
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+////
+////   IMPLEMENTATION
+////
+////
+
+#ifdef STB_TRUETYPE_IMPLEMENTATION
+
+#ifndef STBTT_MAX_OVERSAMPLE
+#define STBTT_MAX_OVERSAMPLE 8
+#endif
+
+typedef int stbtt__test_oversample_pow2[(STBTT_MAX_OVERSAMPLE & (STBTT_MAX_OVERSAMPLE - 1)) == 0 ? 1 : -1];
+
+#ifndef STBTT_RASTERIZER_VERSION
+#define STBTT_RASTERIZER_VERSION 2
+#endif
+
+//////////////////////////////////////////////////////////////////////////
+//
+// accessors to parse data from file
+//
+
+// on platforms that don't allow misaligned reads, if we want to allow
+// truetype fonts that aren't padded to alignment, define ALLOW_UNALIGNED_TRUETYPE
+
+#define ttBYTE(p) (*(stbtt_uint8 *)(p))
+#define ttCHAR(p) (*(stbtt_int8 *)(p))
+#define ttFixed(p) ttLONG(p)
+
+#if defined(STB_TRUETYPE_BIGENDIAN) && !defined(ALLOW_UNALIGNED_TRUETYPE)
+
+#define ttUSHORT(p) (*(stbtt_uint16 *)(p))
+#define ttSHORT(p) (*(stbtt_int16 *)(p))
+#define ttULONG(p) (*(stbtt_uint32 *)(p))
+#define ttLONG(p) (*(stbtt_int32 *)(p))
+
+#else
+
+static stbtt_uint16 ttUSHORT(const stbtt_uint8 *p)
+{
+	return p[0] * 256 + p[1];
+}
+static stbtt_int16 ttSHORT(const stbtt_uint8 *p) { return p[0] * 256 + p[1]; }
+static stbtt_uint32 ttULONG(const stbtt_uint8 *p) { return (p[0] << 24) + (p[1] << 16) + (p[2] << 8) + p[3]; }
+static stbtt_int32 ttLONG(const stbtt_uint8 *p) { return (p[0] << 24) + (p[1] << 16) + (p[2] << 8) + p[3]; }
+
+#endif
+
+#define stbtt_tag4(p, c0, c1, c2, c3) ((p)[0] == (c0) && (p)[1] == (c1) && (p)[2] == (c2) && (p)[3] == (c3))
+#define stbtt_tag(p, str) stbtt_tag4(p, str[0], str[1], str[2], str[3])
+
+static int stbtt__isfont(const stbtt_uint8 *font)
+{
+	// check the version number
+	if (stbtt_tag4(font, '1', 0, 0, 0)) return 1;  // TrueType 1
+	if (stbtt_tag(font, "typ1")) return 1;         // TrueType with type 1 font -- we don't support this!
+	if (stbtt_tag(font, "OTTO")) return 1;         // OpenType with CFF
+	if (stbtt_tag4(font, 0, 1, 0, 0)) return 1;    // OpenType 1.0
+	return 0;
+}
+
+// @OPTIMIZE: binary search
+static stbtt_uint32 stbtt__find_table(stbtt_uint8 *data, stbtt_uint32 fontstart, const char *tag)
+{
+	stbtt_int32 num_tables = ttUSHORT(data + fontstart + 4);
+	stbtt_uint32 tabledir = fontstart + 12;
+	stbtt_int32 i;
+	for (i = 0; i < num_tables; ++i)
+	{
+		stbtt_uint32 loc = tabledir + 16 * i;
+		if (stbtt_tag(data + loc + 0, tag))
+			return ttULONG(data + loc + 8);
+	}
+	return 0;
+}
+
+STBTT_DEF int stbtt_GetFontOffsetForIndex(const unsigned char *font_collection, int index)
+{
+	// if it's just a font, there's only one valid index
+	if (stbtt__isfont(font_collection))
+		return index == 0 ? 0 : -1;
+
+	// check if it's a TTC
+	if (stbtt_tag(font_collection, "ttcf"))
+	{
+		// version 1?
+		if (ttULONG(font_collection + 4) == 0x00010000 || ttULONG(font_collection + 4) == 0x00020000)
+		{
+			stbtt_int32 n = ttLONG(font_collection + 8);
+			if (index >= n)
+				return -1;
+			return ttULONG(font_collection + 12 + index * 14);
+		}
+	}
+	return -1;
+}
+
+STBTT_DEF int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data2, int fontstart)
+{
+	stbtt_uint8 *data = (stbtt_uint8 *)data2;
+	stbtt_uint32 cmap, t;
+	stbtt_int32 i, numTables;
+
+	info->data = data;
+	info->fontstart = fontstart;
+
+	cmap = stbtt__find_table(data, fontstart, "cmap");        // required
+	info->loca = stbtt__find_table(data, fontstart, "loca");  // required
+	info->head = stbtt__find_table(data, fontstart, "head");  // required
+	info->glyf = stbtt__find_table(data, fontstart, "glyf");  // required
+	info->hhea = stbtt__find_table(data, fontstart, "hhea");  // required
+	info->hmtx = stbtt__find_table(data, fontstart, "hmtx");  // required
+	info->kern = stbtt__find_table(data, fontstart, "kern");  // not required
+	if (!cmap || !info->loca || !info->head || !info->glyf || !info->hhea || !info->hmtx)
+		return 0;
+
+	t = stbtt__find_table(data, fontstart, "maxp");
+	if (t)
+		info->numGlyphs = ttUSHORT(data + t + 4);
+	else
+		info->numGlyphs = 0xffff;
+
+	// find a cmap encoding table we understand *now* to avoid searching
+	// later. (todo: could make this installable)
+	// the same regardless of glyph.
+	numTables = ttUSHORT(data + cmap + 2);
+	info->index_map = 0;
+	for (i = 0; i < numTables; ++i)
+	{
+		stbtt_uint32 encoding_record = cmap + 4 + 8 * i;
+		// find an encoding we understand:
+		switch (ttUSHORT(data + encoding_record))
+		{
+			case STBTT_PLATFORM_ID_MICROSOFT:
+				switch (ttUSHORT(data + encoding_record + 2))
+				{
+					case STBTT_MS_EID_UNICODE_BMP:
+					case STBTT_MS_EID_UNICODE_FULL:
+						// MS/Unicode
+						info->index_map = cmap + ttULONG(data + encoding_record + 4);
+						break;
+				}
+				break;
+			case STBTT_PLATFORM_ID_UNICODE:
+				// Mac/iOS has these
+				// all the encodingIDs are unicode, so we don't bother to check it
+				info->index_map = cmap + ttULONG(data + encoding_record + 4);
+				break;
+		}
+	}
+	if (info->index_map == 0)
+		return 0;
+
+	info->indexToLocFormat = ttUSHORT(data + info->head + 50);
+	return 1;
+}
+
+STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint)
+{
+	stbtt_uint8 *data = info->data;
+	stbtt_uint32 index_map = info->index_map;
+
+	stbtt_uint16 format = ttUSHORT(data + index_map + 0);
+	if (format == 0)
+	{  // apple byte encoding
+		stbtt_int32 bytes = ttUSHORT(data + index_map + 2);
+		if (unicode_codepoint < bytes - 6)
+			return ttBYTE(data + index_map + 6 + unicode_codepoint);
+		return 0;
+	}
+	else if (format == 6)
+	{
+		stbtt_uint32 first = ttUSHORT(data + index_map + 6);
+		stbtt_uint32 count = ttUSHORT(data + index_map + 8);
+		if ((stbtt_uint32)unicode_codepoint >= first && (stbtt_uint32)unicode_codepoint < first + count)
+			return ttUSHORT(data + index_map + 10 + (unicode_codepoint - first) * 2);
+		return 0;
+	}
+	else if (format == 2)
+	{
+		STBTT_assert(0);  // @TODO: high-byte mapping for japanese/chinese/korean
+		return 0;
+	}
+	else if (format == 4)
+	{  // standard mapping for windows fonts: binary search collection of ranges
+		stbtt_uint16 segcount = ttUSHORT(data + index_map + 6) >> 1;
+		stbtt_uint16 searchRange = ttUSHORT(data + index_map + 8) >> 1;
+		stbtt_uint16 entrySelector = ttUSHORT(data + index_map + 10);
+		stbtt_uint16 rangeShift = ttUSHORT(data + index_map + 12) >> 1;
+
+		// do a binary search of the segments
+		stbtt_uint32 endCount = index_map + 14;
+		stbtt_uint32 search = endCount;
+
+		if (unicode_codepoint > 0xffff)
+			return 0;
+
+		// they lie from endCount .. endCount + segCount
+		// but searchRange is the nearest power of two, so...
+		if (unicode_codepoint >= ttUSHORT(data + search + rangeShift * 2))
+			search += rangeShift * 2;
+
+		// now decrement to bias correctly to find smallest
+		search -= 2;
+		while (entrySelector)
+		{
+			stbtt_uint16 end;
+			searchRange >>= 1;
+			end = ttUSHORT(data + search + searchRange * 2);
+			if (unicode_codepoint > end)
+				search += searchRange * 2;
+			--entrySelector;
+		}
+		search += 2;
+
+		{
+			stbtt_uint16 offset, start;
+			stbtt_uint16 item = (stbtt_uint16)((search - endCount) >> 1);
+
+			STBTT_assert(unicode_codepoint <= ttUSHORT(data + endCount + 2 * item));
+			start = ttUSHORT(data + index_map + 14 + segcount * 2 + 2 + 2 * item);
+			if (unicode_codepoint < start)
+				return 0;
+
+			offset = ttUSHORT(data + index_map + 14 + segcount * 6 + 2 + 2 * item);
+			if (offset == 0)
+				return (stbtt_uint16)(unicode_codepoint + ttSHORT(data + index_map + 14 + segcount * 4 + 2 + 2 * item));
+
+			return ttUSHORT(data + offset + (unicode_codepoint - start) * 2 + index_map + 14 + segcount * 6 + 2 + 2 * item);
+		}
+	}
+	else if (format == 12 || format == 13)
+	{
+		stbtt_uint32 ngroups = ttULONG(data + index_map + 12);
+		stbtt_int32 low, high;
+		low = 0;
+		high = (stbtt_int32)ngroups;
+		// Binary search the right group.
+		while (low < high)
+		{
+			stbtt_int32 mid = low + ((high - low) >> 1);  // rounds down, so low <= mid < high
+			stbtt_uint32 start_char = ttULONG(data + index_map + 16 + mid * 12);
+			stbtt_uint32 end_char = ttULONG(data + index_map + 16 + mid * 12 + 4);
+			if ((stbtt_uint32)unicode_codepoint < start_char)
+				high = mid;
+			else if ((stbtt_uint32)unicode_codepoint > end_char)
+				low = mid + 1;
+			else
+			{
+				stbtt_uint32 start_glyph = ttULONG(data + index_map + 16 + mid * 12 + 8);
+				if (format == 12)
+					return start_glyph + unicode_codepoint - start_char;
+				else  // format == 13
+					return start_glyph;
+			}
+		}
+		return 0;  // not found
+	}
+	// @TODO
+	STBTT_assert(0);
+	return 0;
+}
+
+STBTT_DEF int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, stbtt_vertex **vertices)
+{
+	return stbtt_GetGlyphShape(info, stbtt_FindGlyphIndex(info, unicode_codepoint), vertices);
+}
+
+static void stbtt_setvertex(stbtt_vertex *v, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy)
+{
+	v->type = type;
+	v->x = (stbtt_int16)x;
+	v->y = (stbtt_int16)y;
+	v->cx = (stbtt_int16)cx;
+	v->cy = (stbtt_int16)cy;
+}
+
+static int stbtt__GetGlyfOffset(const stbtt_fontinfo *info, int glyph_index)
+{
+	int g1, g2;
+
+	if (glyph_index >= info->numGlyphs) return -1;  // glyph index out of range
+	if (info->indexToLocFormat >= 2) return -1;     // unknown index->glyph map format
+
+	if (info->indexToLocFormat == 0)
+	{
+		g1 = info->glyf + ttUSHORT(info->data + info->loca + glyph_index * 2) * 2;
+		g2 = info->glyf + ttUSHORT(info->data + info->loca + glyph_index * 2 + 2) * 2;
+	}
+	else
+	{
+		g1 = info->glyf + ttULONG(info->data + info->loca + glyph_index * 4);
+		g2 = info->glyf + ttULONG(info->data + info->loca + glyph_index * 4 + 4);
+	}
+
+	return g1 == g2 ? -1 : g1;  // if length is 0, return -1
+}
+
+STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1)
+{
+	int g = stbtt__GetGlyfOffset(info, glyph_index);
+	if (g < 0) return 0;
+
+	if (x0) *x0 = ttSHORT(info->data + g + 2);
+	if (y0) *y0 = ttSHORT(info->data + g + 4);
+	if (x1) *x1 = ttSHORT(info->data + g + 6);
+	if (y1) *y1 = ttSHORT(info->data + g + 8);
+	return 1;
+}
+
+STBTT_DEF int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1)
+{
+	return stbtt_GetGlyphBox(info, stbtt_FindGlyphIndex(info, codepoint), x0, y0, x1, y1);
+}
+
+STBTT_DEF int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index)
+{
+	stbtt_int16 numberOfContours;
+	int g = stbtt__GetGlyfOffset(info, glyph_index);
+	if (g < 0) return 1;
+	numberOfContours = ttSHORT(info->data + g);
+	return numberOfContours == 0;
+}
+
+static int stbtt__close_shape(stbtt_vertex *vertices, int num_vertices, int was_off, int start_off,
+							  stbtt_int32 sx, stbtt_int32 sy, stbtt_int32 scx, stbtt_int32 scy, stbtt_int32 cx, stbtt_int32 cy)
+{
+	if (start_off)
+	{
+		if (was_off)
+			stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx + scx) >> 1, (cy + scy) >> 1, cx, cy);
+		stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, sx, sy, scx, scy);
+	}
+	else
+	{
+		if (was_off)
+			stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, sx, sy, cx, cy);
+		else
+			stbtt_setvertex(&vertices[num_vertices++], STBTT_vline, sx, sy, 0, 0);
+	}
+	return num_vertices;
+}
+
+STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices)
+{
+	stbtt_int16 numberOfContours;
+	stbtt_uint8 *endPtsOfContours;
+	stbtt_uint8 *data = info->data;
+	stbtt_vertex *vertices = 0;
+	int num_vertices = 0;
+	int g = stbtt__GetGlyfOffset(info, glyph_index);
+
+	*pvertices = NULL;
+
+	if (g < 0) return 0;
+
+	numberOfContours = ttSHORT(data + g);
+
+	if (numberOfContours > 0)
+	{
+		stbtt_uint8 flags = 0, flagcount;
+		stbtt_int32 ins, i, j = 0, m, n, next_move, was_off = 0, off, start_off = 0;
+		stbtt_int32 x, y, cx, cy, sx, sy, scx, scy;
+		stbtt_uint8 *points;
+		endPtsOfContours = (data + g + 10);
+		ins = ttUSHORT(data + g + 10 + numberOfContours * 2);
+		points = data + g + 10 + numberOfContours * 2 + 2 + ins;
+
+		n = 1 + ttUSHORT(endPtsOfContours + numberOfContours * 2 - 2);
+
+		m = n + 2 * numberOfContours;  // a loose bound on how many vertices we might need
+		vertices = (stbtt_vertex *)STBTT_malloc(m * sizeof(vertices[0]), info->userdata);
+		if (vertices == 0)
+			return 0;
+
+		next_move = 0;
+		flagcount = 0;
+
+		// in first pass, we load uninterpreted data into the allocated array
+		// above, shifted to the end of the array so we won't overwrite it when
+		// we create our final data starting from the front
+
+		off = m - n;  // starting offset for uninterpreted data, regardless of how m ends up being calculated
+
+		// first load flags
+
+		for (i = 0; i < n; ++i)
+		{
+			if (flagcount == 0)
+			{
+				flags = *points++;
+				if (flags & 8)
+					flagcount = *points++;
+			}
+			else
+				--flagcount;
+			vertices[off + i].type = flags;
+		}
+
+		// now load x coordinates
+		x = 0;
+		for (i = 0; i < n; ++i)
+		{
+			flags = vertices[off + i].type;
+			if (flags & 2)
+			{
+				stbtt_int16 dx = *points++;
+				x += (flags & 16) ? dx : -dx;  // ???
+			}
+			else
+			{
+				if (!(flags & 16))
+				{
+					x = x + (stbtt_int16)(points[0] * 256 + points[1]);
+					points += 2;
+				}
+			}
+			vertices[off + i].x = (stbtt_int16)x;
+		}
+
+		// now load y coordinates
+		y = 0;
+		for (i = 0; i < n; ++i)
+		{
+			flags = vertices[off + i].type;
+			if (flags & 4)
+			{
+				stbtt_int16 dy = *points++;
+				y += (flags & 32) ? dy : -dy;  // ???
+			}
+			else
+			{
+				if (!(flags & 32))
+				{
+					y = y + (stbtt_int16)(points[0] * 256 + points[1]);
+					points += 2;
+				}
+			}
+			vertices[off + i].y = (stbtt_int16)y;
+		}
+
+		// now convert them to our format
+		num_vertices = 0;
+		sx = sy = cx = cy = scx = scy = 0;
+		for (i = 0; i < n; ++i)
+		{
+			flags = vertices[off + i].type;
+			x = (stbtt_int16)vertices[off + i].x;
+			y = (stbtt_int16)vertices[off + i].y;
+
+			if (next_move == i)
+			{
+				if (i != 0)
+					num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx, sy, scx, scy, cx, cy);
+
+				// now start the new one
+				start_off = !(flags & 1);
+				if (start_off)
+				{
+					// if we start off with an off-curve point, then when we need to find a point on the curve
+					// where we can start, and we need to save some state for when we wraparound.
+					scx = x;
+					scy = y;
+					if (!(vertices[off + i + 1].type & 1))
+					{
+						// next point is also a curve point, so interpolate an on-point curve
+						sx = (x + (stbtt_int32)vertices[off + i + 1].x) >> 1;
+						sy = (y + (stbtt_int32)vertices[off + i + 1].y) >> 1;
+					}
+					else
+					{
+						// otherwise just use the next point as our start point
+						sx = (stbtt_int32)vertices[off + i + 1].x;
+						sy = (stbtt_int32)vertices[off + i + 1].y;
+						++i;  // we're using point i+1 as the starting point, so skip it
+					}
+				}
+				else
+				{
+					sx = x;
+					sy = y;
+				}
+				stbtt_setvertex(&vertices[num_vertices++], STBTT_vmove, sx, sy, 0, 0);
+				was_off = 0;
+				next_move = 1 + ttUSHORT(endPtsOfContours + j * 2);
+				++j;
+			}
+			else
+			{
+				if (!(flags & 1))
+				{                 // if it's a curve
+					if (was_off)  // two off-curve control points in a row means interpolate an on-curve midpoint
+						stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx + x) >> 1, (cy + y) >> 1, cx, cy);
+					cx = x;
+					cy = y;
+					was_off = 1;
+				}
+				else
+				{
+					if (was_off)
+						stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, x, y, cx, cy);
+					else
+						stbtt_setvertex(&vertices[num_vertices++], STBTT_vline, x, y, 0, 0);
+					was_off = 0;
+				}
+			}
+		}
+		num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx, sy, scx, scy, cx, cy);
+	}
+	else if (numberOfContours == -1)
+	{
+		// Compound shapes.
+		int more = 1;
+		stbtt_uint8 *comp = data + g + 10;
+		num_vertices = 0;
+		vertices = 0;
+		while (more)
+		{
+			stbtt_uint16 flags, gidx;
+			int comp_num_verts = 0, i;
+			stbtt_vertex *comp_verts = 0, *tmp = 0;
+			float mtx[6] = {1, 0, 0, 1, 0, 0}, m, n;
+
+			flags = ttSHORT(comp);
+			comp += 2;
+			gidx = ttSHORT(comp);
+			comp += 2;
+
+			if (flags & 2)
+			{  // XY values
+				if (flags & 1)
+				{  // shorts
+					mtx[4] = ttSHORT(comp);
+					comp += 2;
+					mtx[5] = ttSHORT(comp);
+					comp += 2;
+				}
+				else
+				{
+					mtx[4] = ttCHAR(comp);
+					comp += 1;
+					mtx[5] = ttCHAR(comp);
+					comp += 1;
+				}
+			}
+			else
+			{
+				// @TODO handle matching point
+				STBTT_assert(0);
+			}
+			if (flags & (1 << 3))
+			{  // WE_HAVE_A_SCALE
+				mtx[0] = mtx[3] = ttSHORT(comp) / 16384.0f;
+				comp += 2;
+				mtx[1] = mtx[2] = 0;
+			}
+			else if (flags & (1 << 6))
+			{  // WE_HAVE_AN_X_AND_YSCALE
+				mtx[0] = ttSHORT(comp) / 16384.0f;
+				comp += 2;
+				mtx[1] = mtx[2] = 0;
+				mtx[3] = ttSHORT(comp) / 16384.0f;
+				comp += 2;
+			}
+			else if (flags & (1 << 7))
+			{  // WE_HAVE_A_TWO_BY_TWO
+				mtx[0] = ttSHORT(comp) / 16384.0f;
+				comp += 2;
+				mtx[1] = ttSHORT(comp) / 16384.0f;
+				comp += 2;
+				mtx[2] = ttSHORT(comp) / 16384.0f;
+				comp += 2;
+				mtx[3] = ttSHORT(comp) / 16384.0f;
+				comp += 2;
+			}
+
+			// Find transformation scales.
+			m = (float)STBTT_sqrt(mtx[0] * mtx[0] + mtx[1] * mtx[1]);
+			n = (float)STBTT_sqrt(mtx[2] * mtx[2] + mtx[3] * mtx[3]);
+
+			// Get indexed glyph.
+			comp_num_verts = stbtt_GetGlyphShape(info, gidx, &comp_verts);
+			if (comp_num_verts > 0)
+			{
+				// Transform vertices.
+				for (i = 0; i < comp_num_verts; ++i)
+				{
+					stbtt_vertex *v = &comp_verts[i];
+					stbtt_vertex_type x, y;
+					x = v->x;
+					y = v->y;
+					v->x = (stbtt_vertex_type)(m * (mtx[0] * x + mtx[2] * y + mtx[4]));
+					v->y = (stbtt_vertex_type)(n * (mtx[1] * x + mtx[3] * y + mtx[5]));
+					x = v->cx;
+					y = v->cy;
+					v->cx = (stbtt_vertex_type)(m * (mtx[0] * x + mtx[2] * y + mtx[4]));
+					v->cy = (stbtt_vertex_type)(n * (mtx[1] * x + mtx[3] * y + mtx[5]));
+				}
+				// Append vertices.
+				tmp = (stbtt_vertex *)STBTT_malloc((num_vertices + comp_num_verts) * sizeof(stbtt_vertex), info->userdata);
+				if (!tmp)
+				{
+					if (vertices) STBTT_free(vertices, info->userdata);
+					if (comp_verts) STBTT_free(comp_verts, info->userdata);
+					return 0;
+				}
+				if (num_vertices > 0) STBTT_memcpy(tmp, vertices, num_vertices * sizeof(stbtt_vertex));
+				STBTT_memcpy(tmp + num_vertices, comp_verts, comp_num_verts * sizeof(stbtt_vertex));
+				if (vertices) STBTT_free(vertices, info->userdata);
+				vertices = tmp;
+				STBTT_free(comp_verts, info->userdata);
+				num_vertices += comp_num_verts;
+			}
+			// More components ?
+			more = flags & (1 << 5);
+		}
+	}
+	else if (numberOfContours < 0)
+	{
+		// @TODO other compound variations?
+		STBTT_assert(0);
+	}
+	else
+	{
+		// numberOfCounters == 0, do nothing
+	}
+
+	*pvertices = vertices;
+	return num_vertices;
+}
+
+STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing)
+{
+	stbtt_uint16 numOfLongHorMetrics = ttUSHORT(info->data + info->hhea + 34);
+	if (glyph_index < numOfLongHorMetrics)
+	{
+		if (advanceWidth) *advanceWidth = ttSHORT(info->data + info->hmtx + 4 * glyph_index);
+		if (leftSideBearing) *leftSideBearing = ttSHORT(info->data + info->hmtx + 4 * glyph_index + 2);
+	}
+	else
+	{
+		if (advanceWidth) *advanceWidth = ttSHORT(info->data + info->hmtx + 4 * (numOfLongHorMetrics - 1));
+		if (leftSideBearing) *leftSideBearing = ttSHORT(info->data + info->hmtx + 4 * numOfLongHorMetrics + 2 * (glyph_index - numOfLongHorMetrics));
+	}
+}
+
+STBTT_DEF int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2)
+{
+	stbtt_uint8 *data = info->data + info->kern;
+	stbtt_uint32 needle, straw;
+	int l, r, m;
+
+	// we only look at the first table. it must be 'horizontal' and format 0.
+	if (!info->kern)
+		return 0;
+	if (ttUSHORT(data + 2) < 1)  // number of tables, need at least 1
+		return 0;
+	if (ttUSHORT(data + 8) != 1)  // horizontal flag must be set in format
+		return 0;
+
+	l = 0;
+	r = ttUSHORT(data + 10) - 1;
+	needle = glyph1 << 16 | glyph2;
+	while (l <= r)
+	{
+		m = (l + r) >> 1;
+		straw = ttULONG(data + 18 + (m * 6));  // note: unaligned read
+		if (needle < straw)
+			r = m - 1;
+		else if (needle > straw)
+			l = m + 1;
+		else
+			return ttSHORT(data + 22 + (m * 6));
+	}
+	return 0;
+}
+
+STBTT_DEF int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2)
+{
+	if (!info->kern)  // if no kerning table, don't waste time looking up both codepoint->glyphs
+		return 0;
+	return stbtt_GetGlyphKernAdvance(info, stbtt_FindGlyphIndex(info, ch1), stbtt_FindGlyphIndex(info, ch2));
+}
+
+STBTT_DEF void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing)
+{
+	stbtt_GetGlyphHMetrics(info, stbtt_FindGlyphIndex(info, codepoint), advanceWidth, leftSideBearing);
+}
+
+STBTT_DEF void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap)
+{
+	if (ascent) *ascent = ttSHORT(info->data + info->hhea + 4);
+	if (descent) *descent = ttSHORT(info->data + info->hhea + 6);
+	if (lineGap) *lineGap = ttSHORT(info->data + info->hhea + 8);
+}
+
+STBTT_DEF void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int *x0, int *y0, int *x1, int *y1)
+{
+	*x0 = ttSHORT(info->data + info->head + 36);
+	*y0 = ttSHORT(info->data + info->head + 38);
+	*x1 = ttSHORT(info->data + info->head + 40);
+	*y1 = ttSHORT(info->data + info->head + 42);
+}
+
+STBTT_DEF float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float height)
+{
+	int fheight = ttSHORT(info->data + info->hhea + 4) - ttSHORT(info->data + info->hhea + 6);
+	return (float)height / fheight;
+}
+
+STBTT_DEF float stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *info, float pixels)
+{
+	int unitsPerEm = ttUSHORT(info->data + info->head + 18);
+	return pixels / unitsPerEm;
+}
+
+STBTT_DEF void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *v)
+{
+	STBTT_free(v, info->userdata);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// antialiasing software rasterizer
+//
+
+STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1)
+{
+	int x0, y0, x1, y1;
+	if (!stbtt_GetGlyphBox(font, glyph, &x0, &y0, &x1, &y1))
+	{
+		// e.g. space character
+		if (ix0) *ix0 = 0;
+		if (iy0) *iy0 = 0;
+		if (ix1) *ix1 = 0;
+		if (iy1) *iy1 = 0;
+	}
+	else
+	{
+		// move to integral bboxes (treating pixels as little squares, what pixels get touched)?
+		if (ix0) *ix0 = STBTT_ifloor(x0 * scale_x + shift_x);
+		if (iy0) *iy0 = STBTT_ifloor(-y1 * scale_y + shift_y);
+		if (ix1) *ix1 = STBTT_iceil(x1 * scale_x + shift_x);
+		if (iy1) *iy1 = STBTT_iceil(-y0 * scale_y + shift_y);
+	}
+}
+
+STBTT_DEF void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1)
+{
+	stbtt_GetGlyphBitmapBoxSubpixel(font, glyph, scale_x, scale_y, 0.0f, 0.0f, ix0, iy0, ix1, iy1);
+}
+
+STBTT_DEF void stbtt_GetCodepointBitmapBoxSubpixel(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1)
+{
+	stbtt_GetGlyphBitmapBoxSubpixel(font, stbtt_FindGlyphIndex(font, codepoint), scale_x, scale_y, shift_x, shift_y, ix0, iy0, ix1, iy1);
+}
+
+STBTT_DEF void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1)
+{
+	stbtt_GetCodepointBitmapBoxSubpixel(font, codepoint, scale_x, scale_y, 0.0f, 0.0f, ix0, iy0, ix1, iy1);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  Rasterizer
+
+typedef struct stbtt__hheap_chunk
+{
+	struct stbtt__hheap_chunk *next;
+} stbtt__hheap_chunk;
+
+typedef struct stbtt__hheap
+{
+	struct stbtt__hheap_chunk *head;
+	void *first_free;
+	int num_remaining_in_head_chunk;
+} stbtt__hheap;
+
+static void *stbtt__hheap_alloc(stbtt__hheap *hh, size_t size, void *userdata)
+{
+	if (hh->first_free)
+	{
+		void *p = hh->first_free;
+		hh->first_free = *(void **)p;
+		return p;
+	}
+	else
+	{
+		if (hh->num_remaining_in_head_chunk == 0)
+		{
+			int count = (size < 32 ? 2000 : size < 128 ? 800 : 100);
+			stbtt__hheap_chunk *c = (stbtt__hheap_chunk *)STBTT_malloc(sizeof(stbtt__hheap_chunk) + size * count, userdata);
+			if (c == NULL)
+				return NULL;
+			c->next = hh->head;
+			hh->head = c;
+			hh->num_remaining_in_head_chunk = count;
+		}
+		--hh->num_remaining_in_head_chunk;
+		return (char *)(hh->head) + size * hh->num_remaining_in_head_chunk;
+	}
+}
+
+static void stbtt__hheap_free(stbtt__hheap *hh, void *p)
+{
+	*(void **)p = hh->first_free;
+	hh->first_free = p;
+}
+
+static void stbtt__hheap_cleanup(stbtt__hheap *hh, void *userdata)
+{
+	stbtt__hheap_chunk *c = hh->head;
+	while (c)
+	{
+		stbtt__hheap_chunk *n = c->next;
+		STBTT_free(c, userdata);
+		c = n;
+	}
+}
+
+typedef struct stbtt__edge
+{
+	float x0, y0, x1, y1;
+	int invert;
+} stbtt__edge;
+
+typedef struct stbtt__active_edge
+{
+	struct stbtt__active_edge *next;
+#if STBTT_RASTERIZER_VERSION == 1
+	int x, dx;
+	float ey;
+	int direction;
+#elif STBTT_RASTERIZER_VERSION == 2
+	float fx, fdx, fdy;
+	float direction;
+	float sy;
+	float ey;
+#else
+#error "Unrecognized value of STBTT_RASTERIZER_VERSION"
+#endif
+} stbtt__active_edge;
+
+#if STBTT_RASTERIZER_VERSION == 1
+#define STBTT_FIXSHIFT 10
+#define STBTT_FIX (1 << STBTT_FIXSHIFT)
+#define STBTT_FIXMASK (STBTT_FIX - 1)
+
+static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, int off_x, float start_point, void *userdata)
+{
+	stbtt__active_edge *z = (stbtt__active_edge *)stbtt__hheap_alloc(hh, sizeof(*z), userdata);
+	float dxdy = (e->x1 - e->x0) / (e->y1 - e->y0);
+	if (!z) return z;
+
+	// round dx down to avoid overshooting
+	if (dxdy < 0)
+		z->dx = -STBTT_ifloor(STBTT_FIX * -dxdy);
+	else
+		z->dx = STBTT_ifloor(STBTT_FIX * dxdy);
+
+	z->x = STBTT_ifloor(STBTT_FIX * e->x0 + z->dx * (start_point - e->y0));  // use z->dx so when we offset later it's by the same amount
+	z->x -= off_x * STBTT_FIX;
+
+	z->ey = e->y1;
+	z->next = 0;
+	z->direction = e->invert ? 1 : -1;
+	return z;
+}
+#elif STBTT_RASTERIZER_VERSION == 2
+static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, int off_x, float start_point, void *userdata)
+{
+	stbtt__active_edge *z = (stbtt__active_edge *)stbtt__hheap_alloc(hh, sizeof(*z), userdata);
+	float dxdy = (e->x1 - e->x0) / (e->y1 - e->y0);
+	//STBTT_assert(e->y0 <= start_point);
+	if (!z) return z;
+	z->fdx = dxdy;
+	z->fdy = (1 / dxdy);
+	z->fx = e->x0 + dxdy * (start_point - e->y0);
+	z->fx -= off_x;
+	z->direction = e->invert ? 1.0f : -1.0f;
+	z->sy = e->y0;
+	z->ey = e->y1;
+	z->next = 0;
+	return z;
+}
+#else
+#error "Unrecognized value of STBTT_RASTERIZER_VERSION"
+#endif
+
+#if STBTT_RASTERIZER_VERSION == 1
+// note: this routine clips fills that extend off the edges... ideally this
+// wouldn't happen, but it could happen if the truetype glyph bounding boxes
+// are wrong, or if the user supplies a too-small bitmap
+static void stbtt__fill_active_edges(unsigned char *scanline, int len, stbtt__active_edge *e, int max_weight)
+{
+	// non-zero winding fill
+	int x0 = 0, w = 0;
+
+	while (e)
+	{
+		if (w == 0)
+		{
+			// if we're currently at zero, we need to record the edge start point
+			x0 = e->x;
+			w += e->direction;
+		}
+		else
+		{
+			int x1 = e->x;
+			w += e->direction;
+			// if we went to zero, we need to draw
+			if (w == 0)
+			{
+				int i = x0 >> STBTT_FIXSHIFT;
+				int j = x1 >> STBTT_FIXSHIFT;
+
+				if (i < len && j >= 0)
+				{
+					if (i == j)
+					{
+						// x0,x1 are the same pixel, so compute combined coverage
+						scanline[i] = scanline[i] + (stbtt_uint8)((x1 - x0) * max_weight >> STBTT_FIXSHIFT);
+					}
+					else
+					{
+						if (i >= 0)  // add antialiasing for x0
+							scanline[i] = scanline[i] + (stbtt_uint8)(((STBTT_FIX - (x0 & STBTT_FIXMASK)) * max_weight) >> STBTT_FIXSHIFT);
+						else
+							i = -1;  // clip
+
+						if (j < len)  // add antialiasing for x1
+							scanline[j] = scanline[j] + (stbtt_uint8)(((x1 & STBTT_FIXMASK) * max_weight) >> STBTT_FIXSHIFT);
+						else
+							j = len;  // clip
+
+						for (++i; i < j; ++i)  // fill pixels between x0 and x1
+							scanline[i] = scanline[i] + (stbtt_uint8)max_weight;
+					}
+				}
+			}
+		}
+
+		e = e->next;
+	}
+}
+
+static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, int n, int vsubsample, int off_x, int off_y, void *userdata)
+{
+	stbtt__hheap hh = {0};
+	stbtt__active_edge *active = NULL;
+	int y, j = 0;
+	int max_weight = (255 / vsubsample);  // weight per vertical scanline
+	int s;                                // vertical subsample index
+	unsigned char scanline_data[512], *scanline;
+
+	if (result->w > 512)
+		scanline = (unsigned char *)STBTT_malloc(result->w, userdata);
+	else
+		scanline = scanline_data;
+
+	y = off_y * vsubsample;
+	e[n].y0 = (off_y + result->h) * (float)vsubsample + 1;
+
+	while (j < result->h)
+	{
+		STBTT_memset(scanline, 0, result->w);
+		for (s = 0; s < vsubsample; ++s)
+		{
+			// find center of pixel for this scanline
+			float scan_y = y + 0.5f;
+			stbtt__active_edge **step = &active;
+
+			// update all active edges;
+			// remove all active edges that terminate before the center of this scanline
+			while (*step)
+			{
+				stbtt__active_edge *z = *step;
+				if (z->ey <= scan_y)
+				{
+					*step = z->next;  // delete from list
+					STBTT_assert(z->direction);
+					z->direction = 0;
+					stbtt__hheap_free(&hh, z);
+				}
+				else
+				{
+					z->x += z->dx;            // advance to position for current scanline
+					step = &((*step)->next);  // advance through list
+				}
+			}
+
+			// resort the list if needed
+			for (;;)
+			{
+				int changed = 0;
+				step = &active;
+				while (*step && (*step)->next)
+				{
+					if ((*step)->x > (*step)->next->x)
+					{
+						stbtt__active_edge *t = *step;
+						stbtt__active_edge *q = t->next;
+
+						t->next = q->next;
+						q->next = t;
+						*step = q;
+						changed = 1;
+					}
+					step = &(*step)->next;
+				}
+				if (!changed) break;
+			}
+
+			// insert all edges that start before the center of this scanline -- omit ones that also end on this scanline
+			while (e->y0 <= scan_y)
+			{
+				if (e->y1 > scan_y)
+				{
+					stbtt__active_edge *z = stbtt__new_active(&hh, e, off_x, scan_y, userdata);
+					// find insertion point
+					if (active == NULL)
+						active = z;
+					else if (z->x < active->x)
+					{
+						// insert at front
+						z->next = active;
+						active = z;
+					}
+					else
+					{
+						// find thing to insert AFTER
+						stbtt__active_edge *p = active;
+						while (p->next && p->next->x < z->x)
+							p = p->next;
+						// at this point, p->next->x is NOT < z->x
+						z->next = p->next;
+						p->next = z;
+					}
+				}
+				++e;
+			}
+
+			// now process all active edges in XOR fashion
+			if (active)
+				stbtt__fill_active_edges(scanline, result->w, active, max_weight);
+
+			++y;
+		}
+		STBTT_memcpy(result->pixels + j * result->stride, scanline, result->w);
+		++j;
+	}
+
+	stbtt__hheap_cleanup(&hh, userdata);
+
+	if (scanline != scanline_data)
+		STBTT_free(scanline, userdata);
+}
+
+#elif STBTT_RASTERIZER_VERSION == 2
+
+// the edge passed in here does not cross the vertical line at x or the vertical line at x+1
+// (i.e. it has already been clipped to those)
+static void stbtt__handle_clipped_edge(float *scanline, int x, stbtt__active_edge *e, float x0, float y0, float x1, float y1)
+{
+	if (y0 == y1) return;
+	assert(y0 < y1);
+	assert(e->sy <= e->ey);
+	if (y0 > e->ey) return;
+	if (y1 < e->sy) return;
+	if (y0 < e->sy)
+	{
+		x0 += (x1 - x0) * (e->sy - y0) / (y1 - y0);
+		y0 = e->sy;
+	}
+	if (y1 > e->ey)
+	{
+		x1 += (x1 - x0) * (e->ey - y1) / (y1 - y0);
+		y1 = e->ey;
+	}
+
+	if (x0 == x)
+		assert(x1 <= x + 1);
+	else if (x0 == x + 1)
+		assert(x1 >= x);
+	else if (x0 <= x)
+		assert(x1 <= x);
+	else if (x0 >= x + 1)
+		assert(x1 >= x + 1);
+	else
+		assert(x1 >= x && x1 <= x + 1);
+
+	if (x0 <= x && x1 <= x)
+		scanline[x] += e->direction * (y1 - y0);
+	else if (x0 >= x + 1 && x1 >= x + 1)
+		;
+	else
+	{
+		assert(x0 >= x && x0 <= x + 1 && x1 >= x && x1 <= x + 1);
+		scanline[x] += e->direction * (y1 - y0) * (1 - ((x0 - x) + (x1 - x)) / 2);  // coverage = 1 - average x position
+	}
+}
+
+static void stbtt__fill_active_edges_new(float *scanline, float *scanline_fill, int len, stbtt__active_edge *e, float y_top)
+{
+	float y_bottom = y_top + 1;
+
+	while (e)
+	{
+		// brute force every pixel
+
+		// compute intersection points with top & bottom
+		assert(e->ey >= y_top);
+
+		if (e->fdx == 0)
+		{
+			float x0 = e->fx;
+			if (x0 < len)
+			{
+				if (x0 >= 0)
+				{
+					stbtt__handle_clipped_edge(scanline, (int)x0, e, x0, y_top, x0, y_bottom);
+					stbtt__handle_clipped_edge(scanline_fill - 1, (int)x0 + 1, e, x0, y_top, x0, y_bottom);
+				}
+				else
+				{
+					stbtt__handle_clipped_edge(scanline_fill - 1, 0, e, x0, y_top, x0, y_bottom);
+				}
+			}
+		}
+		else
+		{
+			float x0 = e->fx;
+			float dx = e->fdx;
+			float xb = x0 + dx;
+			float x_top, x_bottom;
+			float y0, y1;
+			float dy = e->fdy;
+			assert(e->sy <= y_bottom && e->ey >= y_top);
+
+			// compute endpoints of line segment clipped to this scanline (if the
+			// line segment starts on this scanline. x0 is the intersection of the
+			// line with y_top, but that may be off the line segment.
+			if (e->sy > y_top)
+			{
+				x_top = x0 + dx * (e->sy - y_top);
+				y0 = e->sy;
+			}
+			else
+			{
+				x_top = x0;
+				y0 = y_top;
+			}
+			if (e->ey < y_bottom)
+			{
+				x_bottom = x0 + dx * (e->ey - y_top);
+				y1 = e->ey;
+			}
+			else
+			{
+				x_bottom = xb;
+				y1 = y_bottom;
+			}
+
+			if (x_top >= 0 && x_bottom >= 0 && x_top < len && x_bottom < len)
+			{
+				// from here on, we don't have to range check x values
+
+				if ((int)x_top == (int)x_bottom)
+				{
+					float height;
+					// simple case, only spans one pixel
+					int x = (int)x_top;
+					height = y1 - y0;
+					assert(x >= 0 && x < len);
+					scanline[x] += e->direction * (1 - ((x_top - x) + (x_bottom - x)) / 2) * height;
+					scanline_fill[x] += e->direction * height;  // everything right of this pixel is filled
+				}
+				else
+				{
+					int x, x1, x2;
+					float y_crossing, step, sign, area;
+					// covers 2+ pixels
+					if (x_top > x_bottom)
+					{
+						// flip scanline vertically; signed area is the same
+						float t;
+						y0 = y_bottom - (y0 - y_top);
+						y1 = y_bottom - (y1 - y_top);
+						t = y0, y0 = y1, y1 = t;
+						t = x_bottom, x_bottom = x_top, x_top = t;
+						dx = -dx;
+						dy = -dy;
+						t = x0, x0 = xb, xb = t;
+					}
+
+					x1 = (int)x_top;
+					x2 = (int)x_bottom;
+					// compute intersection with y axis at x1+1
+					y_crossing = (x1 + 1 - x0) * dy + y_top;
+
+					sign = e->direction;
+					// area of the rectangle covered from y0..y_crossing
+					area = sign * (y_crossing - y0);
+					// area of the triangle (x_top,y0), (x+1,y0), (x+1,y_crossing)
+					scanline[x1] += area * (1 - ((x_top - x1) + (x1 + 1 - x1)) / 2);
+
+					step = sign * dy;
+					for (x = x1 + 1; x < x2; ++x)
+					{
+						scanline[x] += area + step / 2;
+						area += step;
+					}
+					y_crossing += dy * (x2 - (x1 + 1));
+
+					assert(fabs(area) <= 1.01f);
+
+					scanline[x2] += area + sign * (1 - ((x2 - x2) + (x_bottom - x2)) / 2) * (y1 - y_crossing);
+
+					scanline_fill[x2] += sign * (y1 - y0);
+				}
+			}
+			else
+			{
+				// if edge goes outside of box we're drawing, we require
+				// clipping logic. since this does not match the intended use
+				// of this library, we use a different, very slow brute
+				// force implementation
+				int x;
+				for (x = 0; x < len; ++x)
+				{
+					// cases:
+					//
+					// there can be up to two intersections with the pixel. any intersection
+					// with left or right edges can be handled by splitting into two (or three)
+					// regions. intersections with top & bottom do not necessitate case-wise logic.
+					float y0, y1;
+					float y_cur = y_top, x_cur = x0;
+					// x = e->x + e->dx * (y-y_top)
+					// (y-y_top) = (x - e->x) / e->dx
+					// y = (x - e->x) / e->dx + y_top
+					y0 = (x - x0) / dx + y_top;
+					y1 = (x + 1 - x0) / dx + y_top;
+
+					if (y0 < y1)
+					{
+						if (y0 > y_top && y0 < y_bottom)
+						{
+							stbtt__handle_clipped_edge(scanline, x, e, x_cur, y_cur, (float)x, y0);
+							y_cur = y0;
+							x_cur = (float)x;
+						}
+						if (y1 >= y_cur && y1 < y_bottom)
+						{
+							stbtt__handle_clipped_edge(scanline, x, e, x_cur, y_cur, (float)x + 1, y1);
+							y_cur = y1;
+							x_cur = (float)x + 1;
+						}
+					}
+					else
+					{
+						if (y1 >= y_cur && y1 < y_bottom)
+						{
+							stbtt__handle_clipped_edge(scanline, x, e, x_cur, y_cur, (float)x + 1, y1);
+							y_cur = y1;
+							x_cur = (float)x + 1;
+						}
+						if (y0 > y_top && y0 < y_bottom)
+						{
+							stbtt__handle_clipped_edge(scanline, x, e, x_cur, y_cur, (float)x, y0);
+							y_cur = y0;
+							x_cur = (float)x;
+						}
+					}
+					stbtt__handle_clipped_edge(scanline, x, e, x_cur, y_cur, xb, y_bottom);
+				}
+			}
+		}
+		e = e->next;
+	}
+}
+
+// directly AA rasterize edges w/o supersampling
+static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, int n, int vsubsample, int off_x, int off_y, void *userdata)
+{
+	stbtt__hheap hh = {0};
+	stbtt__active_edge *active = NULL;
+	int y, j = 0, i;
+	float scanline_data[129], *scanline, *scanline2;
+
+	if (result->w > 64)
+		scanline = (float *)STBTT_malloc((result->w * 2 + 1) * sizeof(float), userdata);
+	else
+		scanline = scanline_data;
+
+	scanline2 = scanline + result->w;
+
+	y = off_y;
+	e[n].y0 = (float)(off_y + result->h) + 1;
+
+	while (j < result->h)
+	{
+		// find center of pixel for this scanline
+		float scan_y_top = y + 0.0f;
+		float scan_y_bottom = y + 1.0f;
+		stbtt__active_edge **step = &active;
+
+		STBTT_memset(scanline, 0, result->w * sizeof(scanline[0]));
+		STBTT_memset(scanline2, 0, (result->w + 1) * sizeof(scanline[0]));
+
+		// update all active edges;
+		// remove all active edges that terminate before the top of this scanline
+		while (*step)
+		{
+			stbtt__active_edge *z = *step;
+			if (z->ey <= scan_y_top)
+			{
+				*step = z->next;  // delete from list
+				STBTT_assert(z->direction);
+				z->direction = 0;
+				stbtt__hheap_free(&hh, z);
+			}
+			else
+			{
+				step = &((*step)->next);  // advance through list
+			}
+		}
+
+		// insert all edges that start before the bottom of this scanline
+		while (e->y0 <= scan_y_bottom)
+		{
+			stbtt__active_edge *z = stbtt__new_active(&hh, e, off_x, scan_y_top, userdata);
+			assert(z->ey >= scan_y_top);
+			// insert at front
+			z->next = active;
+			active = z;
+			++e;
+		}
+
+		// now process all active edges
+		if (active)
+			stbtt__fill_active_edges_new(scanline, scanline2 + 1, result->w, active, scan_y_top);
+
+		{
+			float sum = 0;
+			for (i = 0; i < result->w; ++i)
+			{
+				float k;
+				int m;
+				sum += scanline2[i];
+				k = scanline[i] + sum;
+				k = (float)fabs(k) * 255 + 0.5f;
+				m = (int)k;
+				if (m > 255) m = 255;
+				result->pixels[j * result->stride + i] = (unsigned char)m;
+			}
+		}
+		// advance all the edges
+		step = &active;
+		while (*step)
+		{
+			stbtt__active_edge *z = *step;
+			z->fx += z->fdx;          // advance to position for current scanline
+			step = &((*step)->next);  // advance through list
+		}
+
+		++y;
+		++j;
+	}
+
+	stbtt__hheap_cleanup(&hh, userdata);
+
+	if (scanline != scanline_data)
+		STBTT_free(scanline, userdata);
+}
+#else
+#error "Unrecognized value of STBTT_RASTERIZER_VERSION"
+#endif
+
+#define STBTT__COMPARE(a, b) ((a)->y0 < (b)->y0)
+
+static void stbtt__sort_edges_ins_sort(stbtt__edge *p, int n)
+{
+	int i, j;
+	for (i = 1; i < n; ++i)
+	{
+		stbtt__edge t = p[i], *a = &t;
+		j = i;
+		while (j > 0)
+		{
+			stbtt__edge *b = &p[j - 1];
+			int c = STBTT__COMPARE(a, b);
+			if (!c) break;
+			p[j] = p[j - 1];
+			--j;
+		}
+		if (i != j)
+			p[j] = t;
+	}
+}
+
+static void stbtt__sort_edges_quicksort(stbtt__edge *p, int n)
+{
+	/* threshhold for transitioning to insertion sort */
+	while (n > 12)
+	{
+		stbtt__edge t;
+		int c01, c12, c, m, i, j;
+
+		/* compute median of three */
+		m = n >> 1;
+		c01 = STBTT__COMPARE(&p[0], &p[m]);
+		c12 = STBTT__COMPARE(&p[m], &p[n - 1]);
+		/* if 0 >= mid >= end, or 0 < mid < end, then use mid */
+		if (c01 != c12)
+		{
+			/* otherwise, we'll need to swap something else to middle */
+			int z;
+			c = STBTT__COMPARE(&p[0], &p[n - 1]);
+			/* 0>mid && mid<n:  0>n => n; 0<n => 0 */
+			/* 0<mid && mid>n:  0>n => 0; 0<n => n */
+			z = (c == c12) ? 0 : n - 1;
+			t = p[z];
+			p[z] = p[m];
+			p[m] = t;
+		}
+		/* now p[m] is the median-of-three */
+		/* swap it to the beginning so it won't move around */
+		t = p[0];
+		p[0] = p[m];
+		p[m] = t;
+
+		/* partition loop */
+		i = 1;
+		j = n - 1;
+		for (;;)
+		{
+			/* handling of equality is crucial here */
+			/* for sentinels & efficiency with duplicates */
+			for (;; ++i)
+			{
+				if (!STBTT__COMPARE(&p[i], &p[0])) break;
+			}
+			for (;; --j)
+			{
+				if (!STBTT__COMPARE(&p[0], &p[j])) break;
+			}
+			/* make sure we haven't crossed */
+			if (i >= j) break;
+			t = p[i];
+			p[i] = p[j];
+			p[j] = t;
+
+			++i;
+			--j;
+		}
+		/* recurse on smaller side, iterate on larger */
+		if (j < (n - i))
+		{
+			stbtt__sort_edges_quicksort(p, j);
+			p = p + i;
+			n = n - i;
+		}
+		else
+		{
+			stbtt__sort_edges_quicksort(p + i, n - i);
+			n = j;
+		}
+	}
+}
+
+static void stbtt__sort_edges(stbtt__edge *p, int n)
+{
+	stbtt__sort_edges_quicksort(p, n);
+	stbtt__sort_edges_ins_sort(p, n);
+}
+
+typedef struct
+{
+	float x, y;
+} stbtt__point;
+
+static void stbtt__rasterize(stbtt__bitmap *result, stbtt__point *pts, int *wcount, int windings, float scale_x, float scale_y, float shift_x, float shift_y, int off_x, int off_y, int invert, void *userdata)
+{
+	float y_scale_inv = invert ? -scale_y : scale_y;
+	stbtt__edge *e;
+	int n, i, j, k, m;
+#if STBTT_RASTERIZER_VERSION == 1
+	int vsubsample = result->h < 8 ? 15 : 5;
+#elif STBTT_RASTERIZER_VERSION == 2
+	int vsubsample = 1;
+#else
+#error "Unrecognized value of STBTT_RASTERIZER_VERSION"
+#endif
+	// vsubsample should divide 255 evenly; otherwise we won't reach full opacity
+
+	// now we have to blow out the windings into explicit edge lists
+	n = 0;
+	for (i = 0; i < windings; ++i)
+		n += wcount[i];
+
+	e = (stbtt__edge *)STBTT_malloc(sizeof(*e) * (n + 1), userdata);  // add an extra one as a sentinel
+	if (e == 0) return;
+	n = 0;
+
+	m = 0;
+	for (i = 0; i < windings; ++i)
+	{
+		stbtt__point *p = pts + m;
+		m += wcount[i];
+		j = wcount[i] - 1;
+		for (k = 0; k < wcount[i]; j = k++)
+		{
+			int a = k, b = j;
+			// skip the edge if horizontal
+			if (p[j].y == p[k].y)
+				continue;
+			// add edge from j to k to the list
+			e[n].invert = 0;
+			if (invert ? p[j].y > p[k].y : p[j].y < p[k].y)
+			{
+				e[n].invert = 1;
+				a = j, b = k;
+			}
+			e[n].x0 = p[a].x * scale_x + shift_x;
+			e[n].y0 = (p[a].y * y_scale_inv + shift_y) * vsubsample;
+			e[n].x1 = p[b].x * scale_x + shift_x;
+			e[n].y1 = (p[b].y * y_scale_inv + shift_y) * vsubsample;
+			++n;
+		}
+	}
+
+	// now sort the edges by their highest point (should snap to integer, and then by x)
+	//STBTT_sort(e, n, sizeof(e[0]), stbtt__edge_compare);
+	stbtt__sort_edges(e, n);
+
+	// now, traverse the scanlines and find the intersections on each scanline, use xor winding rule
+	stbtt__rasterize_sorted_edges(result, e, n, vsubsample, off_x, off_y, userdata);
+
+	STBTT_free(e, userdata);
+}
+
+static void stbtt__add_point(stbtt__point *points, int n, float x, float y)
+{
+	if (!points) return;  // during first pass, it's unallocated
+	points[n].x = x;
+	points[n].y = y;
+}
+
+// tesselate until threshhold p is happy... @TODO warped to compensate for non-linear stretching
+static int stbtt__tesselate_curve(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float objspace_flatness_squared, int n)
+{
+	// midpoint
+	float mx = (x0 + 2 * x1 + x2) / 4;
+	float my = (y0 + 2 * y1 + y2) / 4;
+	// versus directly drawn line
+	float dx = (x0 + x2) / 2 - mx;
+	float dy = (y0 + y2) / 2 - my;
+	if (n > 16)  // 65536 segments on one curve better be enough!
+		return 1;
+	if (dx * dx + dy * dy > objspace_flatness_squared)
+	{  // half-pixel error allowed... need to be smaller if AA
+		stbtt__tesselate_curve(points, num_points, x0, y0, (x0 + x1) / 2.0f, (y0 + y1) / 2.0f, mx, my, objspace_flatness_squared, n + 1);
+		stbtt__tesselate_curve(points, num_points, mx, my, (x1 + x2) / 2.0f, (y1 + y2) / 2.0f, x2, y2, objspace_flatness_squared, n + 1);
+	}
+	else
+	{
+		stbtt__add_point(points, *num_points, x2, y2);
+		*num_points = *num_points + 1;
+	}
+	return 1;
+}
+
+// returns number of contours
+static stbtt__point *stbtt_FlattenCurves(stbtt_vertex *vertices, int num_verts, float objspace_flatness, int **contour_lengths, int *num_contours, void *userdata)
+{
+	stbtt__point *points = 0;
+	int num_points = 0;
+
+	float objspace_flatness_squared = objspace_flatness * objspace_flatness;
+	int i, n = 0, start = 0, pass;
+
+	// count how many "moves" there are to get the contour count
+	for (i = 0; i < num_verts; ++i)
+		if (vertices[i].type == STBTT_vmove)
+			++n;
+
+	*num_contours = n;
+	if (n == 0) return 0;
+
+	*contour_lengths = (int *)STBTT_malloc(sizeof(**contour_lengths) * n, userdata);
+
+	if (*contour_lengths == 0)
+	{
+		*num_contours = 0;
+		return 0;
+	}
+
+	// make two passes through the points so we don't need to realloc
+	for (pass = 0; pass < 2; ++pass)
+	{
+		float x = 0, y = 0;
+		if (pass == 1)
+		{
+			points = (stbtt__point *)STBTT_malloc(num_points * sizeof(points[0]), userdata);
+			if (points == NULL) goto error;
+		}
+		num_points = 0;
+		n = -1;
+		for (i = 0; i < num_verts; ++i)
+		{
+			switch (vertices[i].type)
+			{
+				case STBTT_vmove:
+					// start the next contour
+					if (n >= 0)
+						(*contour_lengths)[n] = num_points - start;
+					++n;
+					start = num_points;
+
+					x = vertices[i].x, y = vertices[i].y;
+					stbtt__add_point(points, num_points++, x, y);
+					break;
+				case STBTT_vline:
+					x = vertices[i].x, y = vertices[i].y;
+					stbtt__add_point(points, num_points++, x, y);
+					break;
+				case STBTT_vcurve:
+					stbtt__tesselate_curve(points, &num_points, x, y,
+										   vertices[i].cx, vertices[i].cy,
+										   vertices[i].x, vertices[i].y,
+										   objspace_flatness_squared, 0);
+					x = vertices[i].x, y = vertices[i].y;
+					break;
+			}
+		}
+		(*contour_lengths)[n] = num_points - start;
+	}
+
+	return points;
+error:
+	STBTT_free(points, userdata);
+	STBTT_free(*contour_lengths, userdata);
+	*contour_lengths = 0;
+	*num_contours = 0;
+	return NULL;
+}
+
+STBTT_DEF void stbtt_Rasterize(stbtt__bitmap *result, float flatness_in_pixels, stbtt_vertex *vertices, int num_verts, float scale_x, float scale_y, float shift_x, float shift_y, int x_off, int y_off, int invert, void *userdata)
+{
+	float scale = scale_x > scale_y ? scale_y : scale_x;
+	int winding_count, *winding_lengths;
+	stbtt__point *windings = stbtt_FlattenCurves(vertices, num_verts, flatness_in_pixels / scale, &winding_lengths, &winding_count, userdata);
+	if (windings)
+	{
+		stbtt__rasterize(result, windings, winding_lengths, winding_count, scale_x, scale_y, shift_x, shift_y, x_off, y_off, invert, userdata);
+		STBTT_free(winding_lengths, userdata);
+		STBTT_free(windings, userdata);
+	}
+}
+
+STBTT_DEF void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata)
+{
+	STBTT_free(bitmap, userdata);
+}
+
+STBTT_DEF unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int glyph, int *width, int *height, int *xoff, int *yoff)
+{
+	int ix0, iy0, ix1, iy1;
+	stbtt__bitmap gbm;
+	stbtt_vertex *vertices;
+	int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices);
+
+	if (scale_x == 0) scale_x = scale_y;
+	if (scale_y == 0)
+	{
+		if (scale_x == 0) return NULL;
+		scale_y = scale_x;
+	}
+
+	stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale_x, scale_y, shift_x, shift_y, &ix0, &iy0, &ix1, &iy1);
+
+	// now we get the size
+	gbm.w = (ix1 - ix0);
+	gbm.h = (iy1 - iy0);
+	gbm.pixels = NULL;  // in case we error
+
+	if (width) *width = gbm.w;
+	if (height) *height = gbm.h;
+	if (xoff) *xoff = ix0;
+	if (yoff) *yoff = iy0;
+
+	if (gbm.w && gbm.h)
+	{
+		gbm.pixels = (unsigned char *)STBTT_malloc(gbm.w * gbm.h, info->userdata);
+		if (gbm.pixels)
+		{
+			gbm.stride = gbm.w;
+
+			stbtt_Rasterize(&gbm, 0.35f, vertices, num_verts, scale_x, scale_y, shift_x, shift_y, ix0, iy0, 1, info->userdata);
+		}
+	}
+	STBTT_free(vertices, info->userdata);
+	return gbm.pixels;
+}
+
+STBTT_DEF unsigned char *stbtt_GetGlyphBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int glyph, int *width, int *height, int *xoff, int *yoff)
+{
+	return stbtt_GetGlyphBitmapSubpixel(info, scale_x, scale_y, 0.0f, 0.0f, glyph, width, height, xoff, yoff);
+}
+
+STBTT_DEF void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int glyph)
+{
+	int ix0, iy0;
+	stbtt_vertex *vertices;
+	int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices);
+	stbtt__bitmap gbm;
+
+	stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale_x, scale_y, shift_x, shift_y, &ix0, &iy0, 0, 0);
+	gbm.pixels = output;
+	gbm.w = out_w;
+	gbm.h = out_h;
+	gbm.stride = out_stride;
+
+	if (gbm.w && gbm.h)
+		stbtt_Rasterize(&gbm, 0.35f, vertices, num_verts, scale_x, scale_y, shift_x, shift_y, ix0, iy0, 1, info->userdata);
+
+	STBTT_free(vertices, info->userdata);
+}
+
+STBTT_DEF void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int glyph)
+{
+	stbtt_MakeGlyphBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, 0.0f, 0.0f, glyph);
+}
+
+STBTT_DEF unsigned char *stbtt_GetCodepointBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint, int *width, int *height, int *xoff, int *yoff)
+{
+	return stbtt_GetGlyphBitmapSubpixel(info, scale_x, scale_y, shift_x, shift_y, stbtt_FindGlyphIndex(info, codepoint), width, height, xoff, yoff);
+}
+
+STBTT_DEF void stbtt_MakeCodepointBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint)
+{
+	stbtt_MakeGlyphBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, shift_x, shift_y, stbtt_FindGlyphIndex(info, codepoint));
+}
+
+STBTT_DEF unsigned char *stbtt_GetCodepointBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int codepoint, int *width, int *height, int *xoff, int *yoff)
+{
+	return stbtt_GetCodepointBitmapSubpixel(info, scale_x, scale_y, 0.0f, 0.0f, codepoint, width, height, xoff, yoff);
+}
+
+STBTT_DEF void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int codepoint)
+{
+	stbtt_MakeCodepointBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, 0.0f, 0.0f, codepoint);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// bitmap baking
+//
+// This is SUPER-CRAPPY packing to keep source code small
+
+STBTT_DEF int stbtt_BakeFontBitmap(const unsigned char *data, int offset,  // font location (use offset=0 for plain .ttf)
+								   float pixel_height,                     // height of font in pixels
+								   unsigned char *pixels, int pw, int ph,  // bitmap to be filled in
+								   int first_char, int num_chars,          // characters to bake
+								   stbtt_bakedchar *chardata)
+{
+	float scale;
+	int x, y, bottom_y, i;
+	stbtt_fontinfo f;
+	if (!stbtt_InitFont(&f, data, offset))
+		return -1;
+	STBTT_memset(pixels, 0, pw * ph);  // background of 0 around pixels
+	x = y = 1;
+	bottom_y = 1;
+
+	scale = stbtt_ScaleForPixelHeight(&f, pixel_height);
+
+	for (i = 0; i < num_chars; ++i)
+	{
+		int advance, lsb, x0, y0, x1, y1, gw, gh;
+		int g = stbtt_FindGlyphIndex(&f, first_char + i);
+		stbtt_GetGlyphHMetrics(&f, g, &advance, &lsb);
+		stbtt_GetGlyphBitmapBox(&f, g, scale, scale, &x0, &y0, &x1, &y1);
+		gw = x1 - x0;
+		gh = y1 - y0;
+		if (x + gw + 1 >= pw)
+			y = bottom_y, x = 1;  // advance to next row
+		if (y + gh + 1 >= ph)     // check if it fits vertically AFTER potentially moving to next row
+			return -i;
+		STBTT_assert(x + gw < pw);
+		STBTT_assert(y + gh < ph);
+		stbtt_MakeGlyphBitmap(&f, pixels + x + y * pw, gw, gh, pw, scale, scale, g);
+		chardata[i].x0 = (stbtt_int16)x;
+		chardata[i].y0 = (stbtt_int16)y;
+		chardata[i].x1 = (stbtt_int16)(x + gw);
+		chardata[i].y1 = (stbtt_int16)(y + gh);
+		chardata[i].xadvance = scale * advance;
+		chardata[i].xoff = (float)x0;
+		chardata[i].yoff = (float)y0;
+		x = x + gw + 1;
+		if (y + gh + 1 > bottom_y)
+			bottom_y = y + gh + 1;
+	}
+	return bottom_y;
+}
+
+STBTT_DEF void stbtt_GetBakedQuad(stbtt_bakedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int opengl_fillrule)
+{
+	float d3d_bias = opengl_fillrule ? 0 : -0.5f;
+	float ipw = 1.0f / pw, iph = 1.0f / ph;
+	stbtt_bakedchar *b = chardata + char_index;
+	int round_x = STBTT_ifloor((*xpos + b->xoff) + 0.5f);
+	int round_y = STBTT_ifloor((*ypos + b->yoff) + 0.5f);
+
+	q->x0 = round_x + d3d_bias;
+	q->y0 = round_y + d3d_bias;
+	q->x1 = round_x + b->x1 - b->x0 + d3d_bias;
+	q->y1 = round_y + b->y1 - b->y0 + d3d_bias;
+
+	q->s0 = b->x0 * ipw;
+	q->t0 = b->y0 * iph;
+	q->s1 = b->x1 * ipw;
+	q->t1 = b->y1 * iph;
+
+	*xpos += b->xadvance;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// rectangle packing replacement routines if you don't have stb_rect_pack.h
+//
+
+#ifndef STB_RECT_PACK_VERSION
+#ifdef _MSC_VER
+#define STBTT__NOTUSED(v) (void)(v)
+#else
+#define STBTT__NOTUSED(v) (void)sizeof(v)
+#endif
+
+typedef int stbrp_coord;
+
+////////////////////////////////////////////////////////////////////////////////////
+//                                                                                //
+//                                                                                //
+// COMPILER WARNING ?!?!?                                                         //
+//                                                                                //
+//                                                                                //
+// if you get a compile warning due to these symbols being defined more than      //
+// once, move #include "stb_rect_pack.h" before #include "stb_truetype.h"         //
+//                                                                                //
+////////////////////////////////////////////////////////////////////////////////////
+
+typedef struct
+{
+	int width, height;
+	int x, y, bottom_y;
+} stbrp_context;
+
+typedef struct
+{
+	unsigned char x;
+} stbrp_node;
+
+typedef struct
+{
+	stbrp_coord x, y;
+	int id, w, h, was_packed;
+} stbrp_rect;
+
+static void stbrp_init_target(stbrp_context *con, int pw, int ph, stbrp_node *nodes, int num_nodes)
+{
+	con->width = pw;
+	con->height = ph;
+	con->x = 0;
+	con->y = 0;
+	con->bottom_y = 0;
+	STBTT__NOTUSED(nodes);
+	STBTT__NOTUSED(num_nodes);
+}
+
+static void stbrp_pack_rects(stbrp_context *con, stbrp_rect *rects, int num_rects)
+{
+	int i;
+	for (i = 0; i < num_rects; ++i)
+	{
+		if (con->x + rects[i].w > con->width)
+		{
+			con->x = 0;
+			con->y = con->bottom_y;
+		}
+		if (con->y + rects[i].h > con->height)
+			break;
+		rects[i].x = con->x;
+		rects[i].y = con->y;
+		rects[i].was_packed = 1;
+		con->x += rects[i].w;
+		if (con->y + rects[i].h > con->bottom_y)
+			con->bottom_y = con->y + rects[i].h;
+	}
+	for (; i < num_rects; ++i)
+		rects[i].was_packed = 0;
+}
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// bitmap baking
+//
+// This is SUPER-AWESOME (tm Ryan Gordon) packing using stb_rect_pack.h. If
+// stb_rect_pack.h isn't available, it uses the BakeFontBitmap strategy.
+
+STBTT_DEF int stbtt_PackBegin(stbtt_pack_context *spc, unsigned char *pixels, int pw, int ph, int stride_in_bytes, int padding, void *alloc_context)
+{
+	stbrp_context *context = (stbrp_context *)STBTT_malloc(sizeof(*context), alloc_context);
+	int num_nodes = pw - padding;
+	stbrp_node *nodes = (stbrp_node *)STBTT_malloc(sizeof(*nodes) * num_nodes, alloc_context);
+
+	if (context == NULL || nodes == NULL)
+	{
+		if (context != NULL) STBTT_free(context, alloc_context);
+		if (nodes != NULL) STBTT_free(nodes, alloc_context);
+		return 0;
+	}
+
+	spc->user_allocator_context = alloc_context;
+	spc->width = pw;
+	spc->height = ph;
+	spc->pixels = pixels;
+	spc->pack_info = context;
+	spc->nodes = nodes;
+	spc->padding = padding;
+	spc->stride_in_bytes = stride_in_bytes != 0 ? stride_in_bytes : pw;
+	spc->h_oversample = 1;
+	spc->v_oversample = 1;
+
+	stbrp_init_target(context, pw - padding, ph - padding, nodes, num_nodes);
+
+	STBTT_memset(pixels, 0, pw * ph);  // background of 0 around pixels
+
+	return 1;
+}
+
+STBTT_DEF void stbtt_PackEnd(stbtt_pack_context *spc)
+{
+	STBTT_free(spc->nodes, spc->user_allocator_context);
+	STBTT_free(spc->pack_info, spc->user_allocator_context);
+}
+
+STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsigned int h_oversample, unsigned int v_oversample)
+{
+	STBTT_assert(h_oversample <= STBTT_MAX_OVERSAMPLE);
+	STBTT_assert(v_oversample <= STBTT_MAX_OVERSAMPLE);
+	if (h_oversample <= STBTT_MAX_OVERSAMPLE)
+		spc->h_oversample = h_oversample;
+	if (v_oversample <= STBTT_MAX_OVERSAMPLE)
+		spc->v_oversample = v_oversample;
+}
+
+#define STBTT__OVER_MASK (STBTT_MAX_OVERSAMPLE - 1)
+
+static void stbtt__h_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes, unsigned int kernel_width)
+{
+	unsigned char buffer[STBTT_MAX_OVERSAMPLE];
+	int safe_w = w - kernel_width;
+	int j;
+	for (j = 0; j < h; ++j)
+	{
+		int i;
+		unsigned int total;
+		STBTT_memset(buffer, 0, kernel_width);
+
+		total = 0;
+
+		// make kernel_width a constant in common cases so compiler can optimize out the divide
+		switch (kernel_width)
+		{
+			case 2:
+				for (i = 0; i <= safe_w; ++i)
+				{
+					total += pixels[i] - buffer[i & STBTT__OVER_MASK];
+					buffer[(i + kernel_width) & STBTT__OVER_MASK] = pixels[i];
+					pixels[i] = (unsigned char)(total / 2);
+				}
+				break;
+			case 3:
+				for (i = 0; i <= safe_w; ++i)
+				{
+					total += pixels[i] - buffer[i & STBTT__OVER_MASK];
+					buffer[(i + kernel_width) & STBTT__OVER_MASK] = pixels[i];
+					pixels[i] = (unsigned char)(total / 3);
+				}
+				break;
+			case 4:
+				for (i = 0; i <= safe_w; ++i)
+				{
+					total += pixels[i] - buffer[i & STBTT__OVER_MASK];
+					buffer[(i + kernel_width) & STBTT__OVER_MASK] = pixels[i];
+					pixels[i] = (unsigned char)(total / 4);
+				}
+				break;
+			default:
+				for (i = 0; i <= safe_w; ++i)
+				{
+					total += pixels[i] - buffer[i & STBTT__OVER_MASK];
+					buffer[(i + kernel_width) & STBTT__OVER_MASK] = pixels[i];
+					pixels[i] = (unsigned char)(total / kernel_width);
+				}
+				break;
+		}
+
+		for (; i < w; ++i)
+		{
+			STBTT_assert(pixels[i] == 0);
+			total -= buffer[i & STBTT__OVER_MASK];
+			pixels[i] = (unsigned char)(total / kernel_width);
+		}
+
+		pixels += stride_in_bytes;
+	}
+}
+
+static void stbtt__v_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes, unsigned int kernel_width)
+{
+	unsigned char buffer[STBTT_MAX_OVERSAMPLE];
+	int safe_h = h - kernel_width;
+	int j;
+	for (j = 0; j < w; ++j)
+	{
+		int i;
+		unsigned int total;
+		STBTT_memset(buffer, 0, kernel_width);
+
+		total = 0;
+
+		// make kernel_width a constant in common cases so compiler can optimize out the divide
+		switch (kernel_width)
+		{
+			case 2:
+				for (i = 0; i <= safe_h; ++i)
+				{
+					total += pixels[i * stride_in_bytes] - buffer[i & STBTT__OVER_MASK];
+					buffer[(i + kernel_width) & STBTT__OVER_MASK] = pixels[i * stride_in_bytes];
+					pixels[i * stride_in_bytes] = (unsigned char)(total / 2);
+				}
+				break;
+			case 3:
+				for (i = 0; i <= safe_h; ++i)
+				{
+					total += pixels[i * stride_in_bytes] - buffer[i & STBTT__OVER_MASK];
+					buffer[(i + kernel_width) & STBTT__OVER_MASK] = pixels[i * stride_in_bytes];
+					pixels[i * stride_in_bytes] = (unsigned char)(total / 3);
+				}
+				break;
+			case 4:
+				for (i = 0; i <= safe_h; ++i)
+				{
+					total += pixels[i * stride_in_bytes] - buffer[i & STBTT__OVER_MASK];
+					buffer[(i + kernel_width) & STBTT__OVER_MASK] = pixels[i * stride_in_bytes];
+					pixels[i * stride_in_bytes] = (unsigned char)(total / 4);
+				}
+				break;
+			default:
+				for (i = 0; i <= safe_h; ++i)
+				{
+					total += pixels[i * stride_in_bytes] - buffer[i & STBTT__OVER_MASK];
+					buffer[(i + kernel_width) & STBTT__OVER_MASK] = pixels[i * stride_in_bytes];
+					pixels[i * stride_in_bytes] = (unsigned char)(total / kernel_width);
+				}
+				break;
+		}
+
+		for (; i < h; ++i)
+		{
+			STBTT_assert(pixels[i * stride_in_bytes] == 0);
+			total -= buffer[i & STBTT__OVER_MASK];
+			pixels[i * stride_in_bytes] = (unsigned char)(total / kernel_width);
+		}
+
+		pixels += 1;
+	}
+}
+
+static float stbtt__oversample_shift(int oversample)
+{
+	if (!oversample)
+		return 0.0f;
+
+	// The prefilter is a box filter of width "oversample",
+	// which shifts phase by (oversample - 1)/2 pixels in
+	// oversampled space. We want to shift in the opposite
+	// direction to counter this.
+	return (float)-(oversample - 1) / (2.0f * (float)oversample);
+}
+
+STBTT_DEF int stbtt_PackFontRanges(stbtt_pack_context *spc, unsigned char *fontdata, int font_index, stbtt_pack_range *ranges, int num_ranges)
+{
+	stbtt_fontinfo info;
+	float recip_h = 1.0f / spc->h_oversample;
+	float recip_v = 1.0f / spc->v_oversample;
+	float sub_x = stbtt__oversample_shift(spc->h_oversample);
+	float sub_y = stbtt__oversample_shift(spc->v_oversample);
+	int i, j, k, n, return_value = 1;
+	stbrp_context *context = (stbrp_context *)spc->pack_info;
+	stbrp_rect *rects;
+
+	// flag all characters as NOT packed
+	for (i = 0; i < num_ranges; ++i)
+		for (j = 0; j < ranges[i].num_chars_in_range; ++j)
+			ranges[i].chardata_for_range[j].x0 =
+				ranges[i].chardata_for_range[j].y0 =
+					ranges[i].chardata_for_range[j].x1 =
+						ranges[i].chardata_for_range[j].y1 = 0;
+
+	n = 0;
+	for (i = 0; i < num_ranges; ++i)
+		n += ranges[i].num_chars_in_range;
+
+	rects = (stbrp_rect *)STBTT_malloc(sizeof(*rects) * n, spc->user_allocator_context);
+	if (rects == NULL)
+		return 0;
+
+	stbtt_InitFont(&info, fontdata, stbtt_GetFontOffsetForIndex(fontdata, font_index));
+	k = 0;
+	for (i = 0; i < num_ranges; ++i)
+	{
+		float fh = ranges[i].font_size;
+		float scale = fh > 0 ? stbtt_ScaleForPixelHeight(&info, fh) : stbtt_ScaleForMappingEmToPixels(&info, -fh);
+		for (j = 0; j < ranges[i].num_chars_in_range; ++j)
+		{
+			int x0, y0, x1, y1;
+			stbtt_GetCodepointBitmapBoxSubpixel(&info, ranges[i].first_unicode_char_in_range + j,
+												scale * spc->h_oversample,
+												scale * spc->v_oversample,
+												0, 0,
+												&x0, &y0, &x1, &y1);
+			rects[k].w = (stbrp_coord)(x1 - x0 + spc->padding + spc->h_oversample - 1);
+			rects[k].h = (stbrp_coord)(y1 - y0 + spc->padding + spc->v_oversample - 1);
+			++k;
+		}
+	}
+
+	stbrp_pack_rects(context, rects, k);
+
+	k = 0;
+	for (i = 0; i < num_ranges; ++i)
+	{
+		float fh = ranges[i].font_size;
+		float scale = fh > 0 ? stbtt_ScaleForPixelHeight(&info, fh) : stbtt_ScaleForMappingEmToPixels(&info, -fh);
+		for (j = 0; j < ranges[i].num_chars_in_range; ++j)
+		{
+			stbrp_rect *r = &rects[k];
+			if (r->was_packed)
+			{
+				stbtt_packedchar *bc = &ranges[i].chardata_for_range[j];
+				int advance, lsb, x0, y0, x1, y1;
+				int glyph = stbtt_FindGlyphIndex(&info, ranges[i].first_unicode_char_in_range + j);
+				stbrp_coord pad = (stbrp_coord)spc->padding;
+
+				// pad on left and top
+				r->x += pad;
+				r->y += pad;
+				r->w -= pad;
+				r->h -= pad;
+				stbtt_GetGlyphHMetrics(&info, glyph, &advance, &lsb);
+				stbtt_GetGlyphBitmapBox(&info, glyph,
+										scale * spc->h_oversample,
+										scale * spc->v_oversample,
+										&x0, &y0, &x1, &y1);
+				stbtt_MakeGlyphBitmapSubpixel(&info,
+											  spc->pixels + r->x + r->y * spc->stride_in_bytes,
+											  r->w - spc->h_oversample + 1,
+											  r->h - spc->v_oversample + 1,
+											  spc->stride_in_bytes,
+											  scale * spc->h_oversample,
+											  scale * spc->v_oversample,
+											  0, 0,
+											  glyph);
+
+				if (spc->h_oversample > 1)
+					stbtt__h_prefilter(spc->pixels + r->x + r->y * spc->stride_in_bytes,
+									   r->w, r->h, spc->stride_in_bytes,
+									   spc->h_oversample);
+
+				if (spc->v_oversample > 1)
+					stbtt__v_prefilter(spc->pixels + r->x + r->y * spc->stride_in_bytes,
+									   r->w, r->h, spc->stride_in_bytes,
+									   spc->v_oversample);
+
+				bc->x0 = (stbtt_int16)r->x;
+				bc->y0 = (stbtt_int16)r->y;
+				bc->x1 = (stbtt_int16)(r->x + r->w);
+				bc->y1 = (stbtt_int16)(r->y + r->h);
+				bc->xadvance = scale * advance;
+				bc->xoff = (float)x0 * recip_h + sub_x;
+				bc->yoff = (float)y0 * recip_v + sub_y;
+				bc->xoff2 = (x0 + r->w) * recip_h + sub_x;
+				bc->yoff2 = (y0 + r->h) * recip_v + sub_y;
+			}
+			else
+			{
+				return_value = 0;  // if any fail, report failure
+			}
+
+			++k;
+		}
+	}
+
+	STBTT_free(rects, spc->user_allocator_context);
+	return return_value;
+}
+
+STBTT_DEF int stbtt_PackFontRange(stbtt_pack_context *spc, unsigned char *fontdata, int font_index, float font_size,
+								  int first_unicode_char_in_range, int num_chars_in_range, stbtt_packedchar *chardata_for_range)
+{
+	stbtt_pack_range range;
+	range.first_unicode_char_in_range = first_unicode_char_in_range;
+	range.num_chars_in_range = num_chars_in_range;
+	range.chardata_for_range = chardata_for_range;
+	range.font_size = font_size;
+	return stbtt_PackFontRanges(spc, fontdata, font_index, &range, 1);
+}
+
+STBTT_DEF void stbtt_GetPackedQuad(stbtt_packedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int align_to_integer)
+{
+	float ipw = 1.0f / pw, iph = 1.0f / ph;
+	stbtt_packedchar *b = chardata + char_index;
+
+	if (align_to_integer)
+	{
+		float x = (float)STBTT_ifloor((*xpos + b->xoff) + 0.5f);
+		float y = (float)STBTT_ifloor((*ypos + b->yoff) + 0.5f);
+		q->x0 = x;
+		q->y0 = y;
+		q->x1 = x + b->xoff2 - b->xoff;
+		q->y1 = y + b->yoff2 - b->yoff;
+	}
+	else
+	{
+		q->x0 = *xpos + b->xoff;
+		q->y0 = *ypos + b->yoff;
+		q->x1 = *xpos + b->xoff2;
+		q->y1 = *ypos + b->yoff2;
+	}
+
+	q->s0 = b->x0 * ipw;
+	q->t0 = b->y0 * iph;
+	q->s1 = b->x1 * ipw;
+	q->t1 = b->y1 * iph;
+
+	*xpos += b->xadvance;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// font name matching -- recommended not to use this
+//
+
+// check if a utf8 string contains a prefix which is the utf16 string; if so return length of matching utf8 string
+static stbtt_int32 stbtt__CompareUTF8toUTF16_bigendian_prefix(const stbtt_uint8 *s1, stbtt_int32 len1, const stbtt_uint8 *s2, stbtt_int32 len2)
+{
+	stbtt_int32 i = 0;
+
+	// convert utf16 to utf8 and compare the results while converting
+	while (len2)
+	{
+		stbtt_uint16 ch = s2[0] * 256 + s2[1];
+		if (ch < 0x80)
+		{
+			if (i >= len1) return -1;
+			if (s1[i++] != ch) return -1;
+		}
+		else if (ch < 0x800)
+		{
+			if (i + 1 >= len1) return -1;
+			if (s1[i++] != 0xc0 + (ch >> 6)) return -1;
+			if (s1[i++] != 0x80 + (ch & 0x3f)) return -1;
+		}
+		else if (ch >= 0xd800 && ch < 0xdc00)
+		{
+			stbtt_uint32 c;
+			stbtt_uint16 ch2 = s2[2] * 256 + s2[3];
+			if (i + 3 >= len1) return -1;
+			c = ((ch - 0xd800) << 10) + (ch2 - 0xdc00) + 0x10000;
+			if (s1[i++] != 0xf0 + (c >> 18)) return -1;
+			if (s1[i++] != 0x80 + ((c >> 12) & 0x3f)) return -1;
+			if (s1[i++] != 0x80 + ((c >> 6) & 0x3f)) return -1;
+			if (s1[i++] != 0x80 + ((c)&0x3f)) return -1;
+			s2 += 2;  // plus another 2 below
+			len2 -= 2;
+		}
+		else if (ch >= 0xdc00 && ch < 0xe000)
+		{
+			return -1;
+		}
+		else
+		{
+			if (i + 2 >= len1) return -1;
+			if (s1[i++] != 0xe0 + (ch >> 12)) return -1;
+			if (s1[i++] != 0x80 + ((ch >> 6) & 0x3f)) return -1;
+			if (s1[i++] != 0x80 + ((ch)&0x3f)) return -1;
+		}
+		s2 += 2;
+		len2 -= 2;
+	}
+	return i;
+}
+
+STBTT_DEF int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2)
+{
+	return len1 == stbtt__CompareUTF8toUTF16_bigendian_prefix((const stbtt_uint8 *)s1, len1, (const stbtt_uint8 *)s2, len2);
+}
+
+// returns results in whatever encoding you request... but note that 2-byte encodings
+// will be BIG-ENDIAN... use stbtt_CompareUTF8toUTF16_bigendian() to compare
+STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID)
+{
+	stbtt_int32 i, count, stringOffset;
+	stbtt_uint8 *fc = font->data;
+	stbtt_uint32 offset = font->fontstart;
+	stbtt_uint32 nm = stbtt__find_table(fc, offset, "name");
+	if (!nm) return NULL;
+
+	count = ttUSHORT(fc + nm + 2);
+	stringOffset = nm + ttUSHORT(fc + nm + 4);
+	for (i = 0; i < count; ++i)
+	{
+		stbtt_uint32 loc = nm + 6 + 12 * i;
+		if (platformID == ttUSHORT(fc + loc + 0) && encodingID == ttUSHORT(fc + loc + 2) && languageID == ttUSHORT(fc + loc + 4) && nameID == ttUSHORT(fc + loc + 6))
+		{
+			*length = ttUSHORT(fc + loc + 8);
+			return (const char *)(fc + stringOffset + ttUSHORT(fc + loc + 10));
+		}
+	}
+	return NULL;
+}
+
+static int stbtt__matchpair(stbtt_uint8 *fc, stbtt_uint32 nm, stbtt_uint8 *name, stbtt_int32 nlen, stbtt_int32 target_id, stbtt_int32 next_id)
+{
+	stbtt_int32 i;
+	stbtt_int32 count = ttUSHORT(fc + nm + 2);
+	stbtt_int32 stringOffset = nm + ttUSHORT(fc + nm + 4);
+
+	for (i = 0; i < count; ++i)
+	{
+		stbtt_uint32 loc = nm + 6 + 12 * i;
+		stbtt_int32 id = ttUSHORT(fc + loc + 6);
+		if (id == target_id)
+		{
+			// find the encoding
+			stbtt_int32 platform = ttUSHORT(fc + loc + 0), encoding = ttUSHORT(fc + loc + 2), language = ttUSHORT(fc + loc + 4);
+
+			// is this a Unicode encoding?
+			if (platform == 0 || (platform == 3 && encoding == 1) || (platform == 3 && encoding == 10))
+			{
+				stbtt_int32 slen = ttUSHORT(fc + loc + 8);
+				stbtt_int32 off = ttUSHORT(fc + loc + 10);
+
+				// check if there's a prefix match
+				stbtt_int32 matchlen = stbtt__CompareUTF8toUTF16_bigendian_prefix(name, nlen, fc + stringOffset + off, slen);
+				if (matchlen >= 0)
+				{
+					// check for target_id+1 immediately following, with same encoding & language
+					if (i + 1 < count && ttUSHORT(fc + loc + 12 + 6) == next_id && ttUSHORT(fc + loc + 12) == platform && ttUSHORT(fc + loc + 12 + 2) == encoding && ttUSHORT(fc + loc + 12 + 4) == language)
+					{
+						slen = ttUSHORT(fc + loc + 12 + 8);
+						off = ttUSHORT(fc + loc + 12 + 10);
+						if (slen == 0)
+						{
+							if (matchlen == nlen)
+								return 1;
+						}
+						else if (matchlen < nlen && name[matchlen] == ' ')
+						{
+							++matchlen;
+							if (stbtt_CompareUTF8toUTF16_bigendian((char *)(name + matchlen), nlen - matchlen, (char *)(fc + stringOffset + off), slen))
+								return 1;
+						}
+					}
+					else
+					{
+						// if nothing immediately following
+						if (matchlen == nlen)
+							return 1;
+					}
+				}
+			}
+
+			// @TODO handle other encodings
+		}
+	}
+	return 0;
+}
+
+static int stbtt__matches(stbtt_uint8 *fc, stbtt_uint32 offset, stbtt_uint8 *name, stbtt_int32 flags)
+{
+	stbtt_int32 nlen = (stbtt_int32)STBTT_strlen((char *)name);
+	stbtt_uint32 nm, hd;
+	if (!stbtt__isfont(fc + offset)) return 0;
+
+	// check italics/bold/underline flags in macStyle...
+	if (flags)
+	{
+		hd = stbtt__find_table(fc, offset, "head");
+		if ((ttUSHORT(fc + hd + 44) & 7) != (flags & 7)) return 0;
+	}
+
+	nm = stbtt__find_table(fc, offset, "name");
+	if (!nm) return 0;
+
+	if (flags)
+	{
+		// if we checked the macStyle flags, then just check the family and ignore the subfamily
+		if (stbtt__matchpair(fc, nm, name, nlen, 16, -1)) return 1;
+		if (stbtt__matchpair(fc, nm, name, nlen, 1, -1)) return 1;
+		if (stbtt__matchpair(fc, nm, name, nlen, 3, -1)) return 1;
+	}
+	else
+	{
+		if (stbtt__matchpair(fc, nm, name, nlen, 16, 17)) return 1;
+		if (stbtt__matchpair(fc, nm, name, nlen, 1, 2)) return 1;
+		if (stbtt__matchpair(fc, nm, name, nlen, 3, -1)) return 1;
+	}
+
+	return 0;
+}
+
+STBTT_DEF int stbtt_FindMatchingFont(const unsigned char *font_collection, const char *name_utf8, stbtt_int32 flags)
+{
+	stbtt_int32 i;
+	for (i = 0;; ++i)
+	{
+		stbtt_int32 off = stbtt_GetFontOffsetForIndex(font_collection, i);
+		if (off < 0) return off;
+		if (stbtt__matches((stbtt_uint8 *)font_collection, off, (stbtt_uint8 *)name_utf8, flags))
+			return off;
+	}
+}
+
+#endif  // STB_TRUETYPE_IMPLEMENTATION
diff --git a/engine/inc/bullet/ThirdPartyLibs/tinyxml2/tinyxml2.h b/engine/inc/bullet/ThirdPartyLibs/tinyxml2/tinyxml2.h
new file mode 100644
index 00000000..2073318f
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/tinyxml2/tinyxml2.h
@@ -0,0 +1,2531 @@
+/*
+Original code by Lee Thomason (www.grinninglizard.com)
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any
+damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any
+purpose, including commercial applications, and to alter it and
+redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must
+not claim that you wrote the original software. If you use this
+software in a product, an acknowledgment in the product documentation
+would be appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and
+must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source
+distribution.
+*/
+
+#ifndef TINYXML2_INCLUDED
+#define TINYXML2_INCLUDED
+
+#if defined(ANDROID_NDK) || defined(__BORLANDC__) || defined(__QNXNTO__)
+#include <ctype.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#if defined(__PS3__)
+#include <stddef.h>
+#endif
+#else
+#include <cctype>
+#include <climits>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#endif
+
+
+#ifdef __GNUC__
+#include <stdint.h>
+typedef int32_t xml_Int32a_t;
+typedef int64_t xml_Int64a_t;
+typedef uint32_t xml_Uint32a_t;
+typedef uint64_t xml_Uint64a_t;
+#elif defined(_MSC_VER)
+typedef __int32 xml_Int32a_t;
+typedef __int64 xml_Int64a_t;
+typedef unsigned __int32 xml_Uint32a_t;
+typedef unsigned __int64 xml_Uint64a_t;
+#else
+typedef int xml_Int32a_t;
+typedef long long int xml_Int64a_t;
+typedef unsigned int xml_Uint32a_t;
+typedef unsigned long long int xml_Uint64a_t;
+#endif
+
+
+
+/*
+   TODO: intern strings instead of allocation.
+*/
+/*
+	gcc:
+        g++ -Wall -DTINYXML2_DEBUG tinyxml2.cpp xmltest.cpp -o gccxmltest.exe
+
+    Formatting, Artistic Style:
+        AStyle.exe --style=1tbs --indent-switches --break-closing-brackets --indent-preprocessor tinyxml2.cpp tinyxml2.h
+*/
+
+#if defined(_DEBUG) || defined(__DEBUG__)
+#ifndef TINYXML2_DEBUG
+#define TINYXML2_DEBUG
+#endif
+#endif
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4251)
+#endif
+
+#ifdef _WIN32
+#ifdef TINYXML2_EXPORT
+#define TINYXML2_LIB __declspec(dllexport)
+#elif defined(TINYXML2_IMPORT)
+#define TINYXML2_LIB __declspec(dllimport)
+#else
+#define TINYXML2_LIB
+#endif
+#elif __GNUC__ >= 4
+#define TINYXML2_LIB __attribute__((visibility("default")))
+#else
+#define TINYXML2_LIB
+#endif
+
+#if defined(TINYXML2_DEBUG)
+#if defined(_MSC_VER)
+#// "(void)0," is for suppressing C4127 warning in "assert(false)", "assert(true)" and the like
+#define TIXMLASSERT(x)   \
+	if (!((void)0, (x))) \
+	{                    \
+		__debugbreak();  \
+	}
+#elif defined(ANDROID_NDK)
+#include <android/log.h>
+#define TIXMLASSERT(x)                                                                          \
+	if (!(x))                                                                                   \
+	{                                                                                           \
+		__android_log_assert("assert", "grinliz", "ASSERT in '%s' at %d.", __FILE__, __LINE__); \
+	}
+#else
+#include <assert.h>
+#define TIXMLASSERT assert
+#endif
+#else
+#define TIXMLASSERT(x) \
+	{                  \
+	}
+#endif
+
+/* Versioning, past 1.0.14:
+	http://semver.org/
+*/
+static const int TIXML2_MAJOR_VERSION = 6;
+static const int TIXML2_MINOR_VERSION = 2;
+static const int TIXML2_PATCH_VERSION = 0;
+
+#define TINYXML2_MAJOR_VERSION 6
+#define TINYXML2_MINOR_VERSION 2
+#define TINYXML2_PATCH_VERSION 0
+
+// A fixed element depth limit is problematic. There needs to be a
+// limit to avoid a stack overflow. However, that limit varies per
+// system, and the capacity of the stack. On the other hand, it's a trivial
+// attack that can result from ill, malicious, or even correctly formed XML,
+// so there needs to be a limit in place.
+static const int TINYXML2_MAX_ELEMENT_DEPTH = 100;
+
+namespace tinyxml2
+{
+class XMLDocument;
+class XMLElement;
+class XMLAttribute;
+class XMLComment;
+class XMLText;
+class XMLDeclaration;
+class XMLUnknown;
+class XMLPrinter;
+
+/*
+	A class that wraps strings. Normally stores the start and end
+	pointers into the XML file itself, and will apply normalization
+	and entity translation if actually read. Can also store (and memory
+	manage) a traditional char[]
+*/
+class StrPair
+{
+public:
+	enum
+	{
+		NEEDS_ENTITY_PROCESSING = 0x01,
+		NEEDS_NEWLINE_NORMALIZATION = 0x02,
+		NEEDS_WHITESPACE_COLLAPSING = 0x04,
+
+		TEXT_ELEMENT = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
+		TEXT_ELEMENT_LEAVE_ENTITIES = NEEDS_NEWLINE_NORMALIZATION,
+		ATTRIBUTE_NAME = 0,
+		ATTRIBUTE_VALUE = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
+		ATTRIBUTE_VALUE_LEAVE_ENTITIES = NEEDS_NEWLINE_NORMALIZATION,
+		COMMENT = NEEDS_NEWLINE_NORMALIZATION
+	};
+
+	StrPair() : _flags(0), _start(0), _end(0) {}
+	~StrPair();
+
+	void Set(char* start, char* end, int flags)
+	{
+		TIXMLASSERT(start);
+		TIXMLASSERT(end);
+		Reset();
+		_start = start;
+		_end = end;
+		_flags = flags | NEEDS_FLUSH;
+	}
+
+	const char* GetStr();
+
+	bool Empty() const
+	{
+		return _start == _end;
+	}
+
+	void SetInternedStr(const char* str)
+	{
+		Reset();
+		_start = const_cast<char*>(str);
+	}
+
+	void SetStr(const char* str, int flags = 0);
+
+	char* ParseText(char* in, const char* endTag, int strFlags, int* curLineNumPtr);
+	char* ParseName(char* in);
+
+	void TransferTo(StrPair* other);
+	void Reset();
+
+private:
+	void CollapseWhitespace();
+
+	enum
+	{
+		NEEDS_FLUSH = 0x100,
+		NEEDS_DELETE = 0x200
+	};
+
+	int _flags;
+	char* _start;
+	char* _end;
+
+	StrPair(const StrPair& other);   // not supported
+	void operator=(StrPair& other);  // not supported, use TransferTo()
+};
+
+/*
+	A dynamic array of Plain Old Data. Doesn't support constructors, etc.
+	Has a small initial memory pool, so that low or no usage will not
+	cause a call to new/delete
+*/
+template <class T, int INITIAL_SIZE>
+class DynArray
+{
+public:
+	DynArray() : _mem(_pool),
+				 _allocated(INITIAL_SIZE),
+				 _size(0)
+	{
+	}
+
+	~DynArray()
+	{
+		if (_mem != _pool)
+		{
+			delete[] _mem;
+		}
+	}
+
+	void Clear()
+	{
+		_size = 0;
+	}
+
+	void Push(T t)
+	{
+		TIXMLASSERT(_size < INT_MAX);
+		EnsureCapacity(_size + 1);
+		_mem[_size] = t;
+		++_size;
+	}
+
+	T* PushArr(int count)
+	{
+		TIXMLASSERT(count >= 0);
+		TIXMLASSERT(_size <= INT_MAX - count);
+		EnsureCapacity(_size + count);
+		T* ret = &_mem[_size];
+		_size += count;
+		return ret;
+	}
+
+	T Pop()
+	{
+		TIXMLASSERT(_size > 0);
+		--_size;
+		return _mem[_size];
+	}
+
+	void PopArr(int count)
+	{
+		TIXMLASSERT(_size >= count);
+		_size -= count;
+	}
+
+	bool Empty() const
+	{
+		return _size == 0;
+	}
+
+	T& operator[](int i)
+	{
+		TIXMLASSERT(i >= 0 && i < _size);
+		return _mem[i];
+	}
+
+	const T& operator[](int i) const
+	{
+		TIXMLASSERT(i >= 0 && i < _size);
+		return _mem[i];
+	}
+
+	const T& PeekTop() const
+	{
+		TIXMLASSERT(_size > 0);
+		return _mem[_size - 1];
+	}
+
+	int Size() const
+	{
+		TIXMLASSERT(_size >= 0);
+		return _size;
+	}
+
+	int Capacity() const
+	{
+		TIXMLASSERT(_allocated >= INITIAL_SIZE);
+		return _allocated;
+	}
+
+	void SwapRemove(int i)
+	{
+		TIXMLASSERT(i >= 0 && i < _size);
+		TIXMLASSERT(_size > 0);
+		_mem[i] = _mem[_size - 1];
+		--_size;
+	}
+
+	const T* Mem() const
+	{
+		TIXMLASSERT(_mem);
+		return _mem;
+	}
+
+	T* Mem()
+	{
+		TIXMLASSERT(_mem);
+		return _mem;
+	}
+
+private:
+	DynArray(const DynArray&);        // not supported
+	void operator=(const DynArray&);  // not supported
+
+	void EnsureCapacity(int cap)
+	{
+		TIXMLASSERT(cap > 0);
+		if (cap > _allocated)
+		{
+			TIXMLASSERT(cap <= INT_MAX / 2);
+			int newAllocated = cap * 2;
+			T* newMem = new T[newAllocated];
+			TIXMLASSERT(newAllocated >= _size);
+			memcpy(newMem, _mem, sizeof(T) * _size);  // warning: not using constructors, only works for PODs
+			if (_mem != _pool)
+			{
+				delete[] _mem;
+			}
+			_mem = newMem;
+			_allocated = newAllocated;
+		}
+	}
+
+	T* _mem;
+	T _pool[INITIAL_SIZE];
+	int _allocated;  // objects allocated
+	int _size;       // number objects in use
+};
+
+/*
+	Parent virtual class of a pool for fast allocation
+	and deallocation of objects.
+*/
+class MemPool
+{
+public:
+	MemPool() {}
+	virtual ~MemPool() {}
+
+	virtual int ItemSize() const = 0;
+	virtual void* Alloc() = 0;
+	virtual void Free(void*) = 0;
+	virtual void SetTracked() = 0;
+	virtual void Clear() = 0;
+};
+
+/*
+	Template child class to create pools of the correct type.
+*/
+template <int ITEM_SIZE>
+class MemPoolT : public MemPool
+{
+public:
+	MemPoolT() : _blockPtrs(), _root(0), _currentAllocs(0), _nAllocs(0), _maxAllocs(0), _nUntracked(0) {}
+	~MemPoolT()
+	{
+		Clear();
+	}
+
+	void Clear()
+	{
+		// Delete the blocks.
+		while (!_blockPtrs.Empty())
+		{
+			Block* lastBlock = _blockPtrs.Pop();
+			delete lastBlock;
+		}
+		_root = 0;
+		_currentAllocs = 0;
+		_nAllocs = 0;
+		_maxAllocs = 0;
+		_nUntracked = 0;
+	}
+
+	virtual int ItemSize() const
+	{
+		return ITEM_SIZE;
+	}
+	int CurrentAllocs() const
+	{
+		return _currentAllocs;
+	}
+
+	virtual void* Alloc()
+	{
+		if (!_root)
+		{
+			// Need a new block.
+			Block* block = new Block();
+			_blockPtrs.Push(block);
+
+			Item* blockItems = block->items;
+			for (int i = 0; i < ITEMS_PER_BLOCK - 1; ++i)
+			{
+				blockItems[i].next = &(blockItems[i + 1]);
+			}
+			blockItems[ITEMS_PER_BLOCK - 1].next = 0;
+			_root = blockItems;
+		}
+		Item* const result = _root;
+		TIXMLASSERT(result != 0);
+		_root = _root->next;
+
+		++_currentAllocs;
+		if (_currentAllocs > _maxAllocs)
+		{
+			_maxAllocs = _currentAllocs;
+		}
+		++_nAllocs;
+		++_nUntracked;
+		return result;
+	}
+
+	virtual void Free(void* mem)
+	{
+		if (!mem)
+		{
+			return;
+		}
+		--_currentAllocs;
+		Item* item = static_cast<Item*>(mem);
+#ifdef TINYXML2_DEBUG
+		memset(item, 0xfe, sizeof(*item));
+#endif
+		item->next = _root;
+		_root = item;
+	}
+	void Trace(const char* name)
+	{
+		printf("Mempool %s watermark=%d [%dk] current=%d size=%d nAlloc=%d blocks=%d\n",
+			   name, _maxAllocs, _maxAllocs * ITEM_SIZE / 1024, _currentAllocs,
+			   ITEM_SIZE, _nAllocs, _blockPtrs.Size());
+	}
+
+	void SetTracked()
+	{
+		--_nUntracked;
+	}
+
+	int Untracked() const
+	{
+		return _nUntracked;
+	}
+
+	// This number is perf sensitive. 4k seems like a good tradeoff on my machine.
+	// The test file is large, 170k.
+	// Release:		VS2010 gcc(no opt)
+	//		1k:		4000
+	//		2k:		4000
+	//		4k:		3900	21000
+	//		16k:	5200
+	//		32k:	4300
+	//		64k:	4000	21000
+	// Declared public because some compilers do not accept to use ITEMS_PER_BLOCK
+	// in private part if ITEMS_PER_BLOCK is private
+	enum
+	{
+		ITEMS_PER_BLOCK = (4 * 1024) / ITEM_SIZE
+	};
+
+private:
+	MemPoolT(const MemPoolT&);        // not supported
+	void operator=(const MemPoolT&);  // not supported
+
+	union Item {
+		Item* next;
+		char itemData[ITEM_SIZE];
+	};
+	struct Block
+	{
+		Item items[ITEMS_PER_BLOCK];
+	};
+	DynArray<Block*, 10> _blockPtrs;
+	Item* _root;
+
+	int _currentAllocs;
+	int _nAllocs;
+	int _maxAllocs;
+	int _nUntracked;
+};
+
+/**
+	Implements the interface to the "Visitor pattern" (see the Accept() method.)
+	If you call the Accept() method, it requires being passed a XMLVisitor
+	class to handle callbacks. For nodes that contain other nodes (Document, Element)
+	you will get called with a VisitEnter/VisitExit pair. Nodes that are always leafs
+	are simply called with Visit().
+
+	If you return 'true' from a Visit method, recursive parsing will continue. If you return
+	false, <b>no children of this node or its siblings</b> will be visited.
+
+	All flavors of Visit methods have a default implementation that returns 'true' (continue
+	visiting). You need to only override methods that are interesting to you.
+
+	Generally Accept() is called on the XMLDocument, although all nodes support visiting.
+
+	You should never change the document from a callback.
+
+	@sa XMLNode::Accept()
+*/
+class TINYXML2_LIB XMLVisitor
+{
+public:
+	virtual ~XMLVisitor() {}
+
+	/// Visit a document.
+	virtual bool VisitEnter(const XMLDocument& /*doc*/)
+	{
+		return true;
+	}
+	/// Visit a document.
+	virtual bool VisitExit(const XMLDocument& /*doc*/)
+	{
+		return true;
+	}
+
+	/// Visit an element.
+	virtual bool VisitEnter(const XMLElement& /*element*/, const XMLAttribute* /*firstAttribute*/)
+	{
+		return true;
+	}
+	/// Visit an element.
+	virtual bool VisitExit(const XMLElement& /*element*/)
+	{
+		return true;
+	}
+
+	/// Visit a declaration.
+	virtual bool Visit(const XMLDeclaration& /*declaration*/)
+	{
+		return true;
+	}
+	/// Visit a text node.
+	virtual bool Visit(const XMLText& /*text*/)
+	{
+		return true;
+	}
+	/// Visit a comment node.
+	virtual bool Visit(const XMLComment& /*comment*/)
+	{
+		return true;
+	}
+	/// Visit an unknown node.
+	virtual bool Visit(const XMLUnknown& /*unknown*/)
+	{
+		return true;
+	}
+};
+
+// WARNING: must match XMLDocument::_errorNames[]
+enum XMLError
+{
+	XML_SUCCESS = 0,
+	XML_NO_ATTRIBUTE,
+	XML_WRONG_ATTRIBUTE_TYPE,
+	XML_ERROR_FILE_NOT_FOUND,
+	XML_ERROR_FILE_COULD_NOT_BE_OPENED,
+	XML_ERROR_FILE_READ_ERROR,
+	UNUSED_XML_ERROR_ELEMENT_MISMATCH,  // remove at next major version
+	XML_ERROR_PARSING_ELEMENT,
+	XML_ERROR_PARSING_ATTRIBUTE,
+	UNUSED_XML_ERROR_IDENTIFYING_TAG,  // remove at next major version
+	XML_ERROR_PARSING_TEXT,
+	XML_ERROR_PARSING_CDATA,
+	XML_ERROR_PARSING_COMMENT,
+	XML_ERROR_PARSING_DECLARATION,
+	XML_ERROR_PARSING_UNKNOWN,
+	XML_ERROR_EMPTY_DOCUMENT,
+	XML_ERROR_MISMATCHED_ELEMENT,
+	XML_ERROR_PARSING,
+	XML_CAN_NOT_CONVERT_TEXT,
+	XML_NO_TEXT_NODE,
+	XML_ELEMENT_DEPTH_EXCEEDED,
+
+	XML_ERROR_COUNT
+};
+
+/*
+	Utility functionality.
+*/
+class TINYXML2_LIB XMLUtil
+{
+public:
+	static const char* SkipWhiteSpace(const char* p, int* curLineNumPtr)
+	{
+		TIXMLASSERT(p);
+
+		while (IsWhiteSpace(*p))
+		{
+			if (curLineNumPtr && *p == '\n')
+			{
+				++(*curLineNumPtr);
+			}
+			++p;
+		}
+		TIXMLASSERT(p);
+		return p;
+	}
+	static char* SkipWhiteSpace(char* p, int* curLineNumPtr)
+	{
+		return const_cast<char*>(SkipWhiteSpace(const_cast<const char*>(p), curLineNumPtr));
+	}
+
+	// Anything in the high order range of UTF-8 is assumed to not be whitespace. This isn't
+	// correct, but simple, and usually works.
+	static bool IsWhiteSpace(char p)
+	{
+		return !IsUTF8Continuation(p) && isspace(static_cast<unsigned char>(p));
+	}
+
+	inline static bool IsNameStartChar(unsigned char ch)
+	{
+		if (ch >= 128)
+		{
+			// This is a heuristic guess in attempt to not implement Unicode-aware isalpha()
+			return true;
+		}
+		if (isalpha(ch))
+		{
+			return true;
+		}
+		return ch == ':' || ch == '_';
+	}
+
+	inline static bool IsNameChar(unsigned char ch)
+	{
+		return IsNameStartChar(ch) || isdigit(ch) || ch == '.' || ch == '-';
+	}
+
+	inline static bool StringEqual(const char* p, const char* q, int nChar = INT_MAX)
+	{
+		if (p == q)
+		{
+			return true;
+		}
+		TIXMLASSERT(p);
+		TIXMLASSERT(q);
+		TIXMLASSERT(nChar >= 0);
+		return strncmp(p, q, nChar) == 0;
+	}
+
+	inline static bool IsUTF8Continuation(char p)
+	{
+		return (p & 0x80) != 0;
+	}
+
+	static const char* ReadBOM(const char* p, bool* hasBOM);
+	// p is the starting location,
+	// the UTF-8 value of the entity will be placed in value, and length filled in.
+	static const char* GetCharacterRef(const char* p, char* value, int* length);
+	static void ConvertUTF32ToUTF8(unsigned long input, char* output, int* length);
+
+	// converts primitive types to strings
+	static void ToStr(int v, char* buffer, int bufferSize);
+	static void ToStr(unsigned v, char* buffer, int bufferSize);
+	static void ToStr(bool v, char* buffer, int bufferSize);
+	static void ToStr(float v, char* buffer, int bufferSize);
+	static void ToStr(double v, char* buffer, int bufferSize);
+	static void ToStr(xml_Int64a_t v, char* buffer, int bufferSize);
+
+	// converts strings to primitive types
+	static bool ToInt(const char* str, int* value);
+	static bool ToUnsigned(const char* str, unsigned* value);
+	static bool ToBool(const char* str, bool* value);
+	static bool ToFloat(const char* str, float* value);
+	static bool ToDouble(const char* str, double* value);
+	static bool ToInt64(const char* str, xml_Int64a_t* value);
+
+	// Changes what is serialized for a boolean value.
+	// Default to "true" and "false". Shouldn't be changed
+	// unless you have a special testing or compatibility need.
+	// Be careful: static, global, & not thread safe.
+	// Be sure to set static const memory as parameters.
+	static void SetBoolSerialization(const char* writeTrue, const char* writeFalse);
+
+private:
+	static const char* writeBoolTrue;
+	static const char* writeBoolFalse;
+};
+
+/** XMLNode is a base class for every object that is in the
+	XML Document Object Model (DOM), except XMLAttributes.
+	Nodes have siblings, a parent, and children which can
+	be navigated. A node is always in a XMLDocument.
+	The type of a XMLNode can be queried, and it can
+	be cast to its more defined type.
+
+	A XMLDocument allocates memory for all its Nodes.
+	When the XMLDocument gets deleted, all its Nodes
+	will also be deleted.
+
+	@verbatim
+	A Document can contain:	Element	(container or leaf)
+							Comment (leaf)
+							Unknown (leaf)
+							Declaration( leaf )
+
+	An Element can contain:	Element (container or leaf)
+							Text	(leaf)
+							Attributes (not on tree)
+							Comment (leaf)
+							Unknown (leaf)
+
+	@endverbatim
+*/
+class TINYXML2_LIB XMLNode
+{
+	friend class XMLDocument;
+	friend class XMLElement;
+
+public:
+	/// Get the XMLDocument that owns this XMLNode.
+	const XMLDocument* GetDocument() const
+	{
+		TIXMLASSERT(_document);
+		return _document;
+	}
+	/// Get the XMLDocument that owns this XMLNode.
+	XMLDocument* GetDocument()
+	{
+		TIXMLASSERT(_document);
+		return _document;
+	}
+
+	/// Safely cast to an Element, or null.
+	virtual XMLElement* ToElement()
+	{
+		return 0;
+	}
+	/// Safely cast to Text, or null.
+	virtual XMLText* ToText()
+	{
+		return 0;
+	}
+	/// Safely cast to a Comment, or null.
+	virtual XMLComment* ToComment()
+	{
+		return 0;
+	}
+	/// Safely cast to a Document, or null.
+	virtual XMLDocument* ToDocument()
+	{
+		return 0;
+	}
+	/// Safely cast to a Declaration, or null.
+	virtual XMLDeclaration* ToDeclaration()
+	{
+		return 0;
+	}
+	/// Safely cast to an Unknown, or null.
+	virtual XMLUnknown* ToUnknown()
+	{
+		return 0;
+	}
+
+	virtual const XMLElement* ToElement() const
+	{
+		return 0;
+	}
+	virtual const XMLText* ToText() const
+	{
+		return 0;
+	}
+	virtual const XMLComment* ToComment() const
+	{
+		return 0;
+	}
+	virtual const XMLDocument* ToDocument() const
+	{
+		return 0;
+	}
+	virtual const XMLDeclaration* ToDeclaration() const
+	{
+		return 0;
+	}
+	virtual const XMLUnknown* ToUnknown() const
+	{
+		return 0;
+	}
+
+	/** The meaning of 'value' changes for the specific type.
+    	@verbatim
+    	Document:	empty (NULL is returned, not an empty string)
+    	Element:	name of the element
+    	Comment:	the comment text
+    	Unknown:	the tag contents
+    	Text:		the text string
+    	@endverbatim
+    */
+	const char* Value() const;
+
+	/** Set the Value of an XML node.
+    	@sa Value()
+    */
+	void SetValue(const char* val, bool staticMem = false);
+
+	/// Gets the line number the node is in, if the document was parsed from a file.
+	int GetLineNum() const { return _parseLineNum; }
+
+	/// Get the parent of this node on the DOM.
+	const XMLNode* Parent() const
+	{
+		return _parent;
+	}
+
+	XMLNode* Parent()
+	{
+		return _parent;
+	}
+
+	/// Returns true if this node has no children.
+	bool NoChildren() const
+	{
+		return !_firstChild;
+	}
+
+	/// Get the first child node, or null if none exists.
+	const XMLNode* FirstChild() const
+	{
+		return _firstChild;
+	}
+
+	XMLNode* FirstChild()
+	{
+		return _firstChild;
+	}
+
+	/** Get the first child element, or optionally the first child
+        element with the specified name.
+    */
+	const XMLElement* FirstChildElement(const char* name = 0) const;
+
+	XMLElement* FirstChildElement(const char* name = 0)
+	{
+		return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->FirstChildElement(name));
+	}
+
+	/// Get the last child node, or null if none exists.
+	const XMLNode* LastChild() const
+	{
+		return _lastChild;
+	}
+
+	XMLNode* LastChild()
+	{
+		return _lastChild;
+	}
+
+	/** Get the last child element or optionally the last child
+        element with the specified name.
+    */
+	const XMLElement* LastChildElement(const char* name = 0) const;
+
+	XMLElement* LastChildElement(const char* name = 0)
+	{
+		return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->LastChildElement(name));
+	}
+
+	/// Get the previous (left) sibling node of this node.
+	const XMLNode* PreviousSibling() const
+	{
+		return _prev;
+	}
+
+	XMLNode* PreviousSibling()
+	{
+		return _prev;
+	}
+
+	/// Get the previous (left) sibling element of this node, with an optionally supplied name.
+	const XMLElement* PreviousSiblingElement(const char* name = 0) const;
+
+	XMLElement* PreviousSiblingElement(const char* name = 0)
+	{
+		return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->PreviousSiblingElement(name));
+	}
+
+	/// Get the next (right) sibling node of this node.
+	const XMLNode* NextSibling() const
+	{
+		return _next;
+	}
+
+	XMLNode* NextSibling()
+	{
+		return _next;
+	}
+
+	/// Get the next (right) sibling element of this node, with an optionally supplied name.
+	const XMLElement* NextSiblingElement(const char* name = 0) const;
+
+	XMLElement* NextSiblingElement(const char* name = 0)
+	{
+		return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->NextSiblingElement(name));
+	}
+
+	/**
+    	Add a child node as the last (right) child.
+		If the child node is already part of the document,
+		it is moved from its old location to the new location.
+		Returns the addThis argument or 0 if the node does not
+		belong to the same document.
+    */
+	XMLNode* InsertEndChild(XMLNode* addThis);
+
+	XMLNode* LinkEndChild(XMLNode* addThis)
+	{
+		return InsertEndChild(addThis);
+	}
+	/**
+    	Add a child node as the first (left) child.
+		If the child node is already part of the document,
+		it is moved from its old location to the new location.
+		Returns the addThis argument or 0 if the node does not
+		belong to the same document.
+    */
+	XMLNode* InsertFirstChild(XMLNode* addThis);
+	/**
+    	Add a node after the specified child node.
+		If the child node is already part of the document,
+		it is moved from its old location to the new location.
+		Returns the addThis argument or 0 if the afterThis node
+		is not a child of this node, or if the node does not
+		belong to the same document.
+    */
+	XMLNode* InsertAfterChild(XMLNode* afterThis, XMLNode* addThis);
+
+	/**
+    	Delete all the children of this node.
+    */
+	void DeleteChildren();
+
+	/**
+    	Delete a child of this node.
+    */
+	void DeleteChild(XMLNode* node);
+
+	/**
+    	Make a copy of this node, but not its children.
+    	You may pass in a Document pointer that will be
+    	the owner of the new Node. If the 'document' is
+    	null, then the node returned will be allocated
+    	from the current Document. (this->GetDocument())
+
+    	Note: if called on a XMLDocument, this will return null.
+    */
+	virtual XMLNode* ShallowClone(XMLDocument* document) const = 0;
+
+	/**
+		Make a copy of this node and all its children.
+
+		If the 'target' is null, then the nodes will
+		be allocated in the current document. If 'target' 
+        is specified, the memory will be allocated is the 
+        specified XMLDocument.
+
+		NOTE: This is probably not the correct tool to 
+		copy a document, since XMLDocuments can have multiple
+		top level XMLNodes. You probably want to use
+        XMLDocument::DeepCopy()
+	*/
+	XMLNode* DeepClone(XMLDocument* target) const;
+
+	/**
+    	Test if 2 nodes are the same, but don't test children.
+    	The 2 nodes do not need to be in the same Document.
+
+    	Note: if called on a XMLDocument, this will return false.
+    */
+	virtual bool ShallowEqual(const XMLNode* compare) const = 0;
+
+	/** Accept a hierarchical visit of the nodes in the TinyXML-2 DOM. Every node in the
+    	XML tree will be conditionally visited and the host will be called back
+    	via the XMLVisitor interface.
+
+    	This is essentially a SAX interface for TinyXML-2. (Note however it doesn't re-parse
+    	the XML for the callbacks, so the performance of TinyXML-2 is unchanged by using this
+    	interface versus any other.)
+
+    	The interface has been based on ideas from:
+
+    	- http://www.saxproject.org/
+    	- http://c2.com/cgi/wiki?HierarchicalVisitorPattern
+
+    	Which are both good references for "visiting".
+
+    	An example of using Accept():
+    	@verbatim
+    	XMLPrinter printer;
+    	tinyxmlDoc.Accept( &printer );
+    	const char* xmlcstr = printer.CStr();
+    	@endverbatim
+    */
+	virtual bool Accept(XMLVisitor* visitor) const = 0;
+
+	/** 
+		Set user data into the XMLNode. TinyXML-2 in 
+		no way processes or interprets user data.
+		It is initially 0.
+	*/
+	void SetUserData(void* userData) { _userData = userData; }
+
+	/**
+		Get user data set into the XMLNode. TinyXML-2 in
+		no way processes or interprets user data.
+		It is initially 0.
+	*/
+	void* GetUserData() const { return _userData; }
+
+protected:
+	XMLNode(XMLDocument*);
+	virtual ~XMLNode();
+
+	virtual char* ParseDeep(char* p, StrPair* parentEndTag, int* curLineNumPtr);
+
+	XMLDocument* _document;
+	XMLNode* _parent;
+	mutable StrPair _value;
+	int _parseLineNum;
+
+	XMLNode* _firstChild;
+	XMLNode* _lastChild;
+
+	XMLNode* _prev;
+	XMLNode* _next;
+
+	void* _userData;
+
+private:
+	MemPool* _memPool;
+	void Unlink(XMLNode* child);
+	static void DeleteNode(XMLNode* node);
+	void InsertChildPreamble(XMLNode* insertThis) const;
+	const XMLElement* ToElementWithName(const char* name) const;
+
+	XMLNode(const XMLNode&);             // not supported
+	XMLNode& operator=(const XMLNode&);  // not supported
+};
+
+/** XML text.
+
+	Note that a text node can have child element nodes, for example:
+	@verbatim
+	<root>This is <b>bold</b></root>
+	@endverbatim
+
+	A text node can have 2 ways to output the next. "normal" output
+	and CDATA. It will default to the mode it was parsed from the XML file and
+	you generally want to leave it alone, but you can change the output mode with
+	SetCData() and query it with CData().
+*/
+class TINYXML2_LIB XMLText : public XMLNode
+{
+	friend class XMLDocument;
+
+public:
+	virtual bool Accept(XMLVisitor* visitor) const;
+
+	virtual XMLText* ToText()
+	{
+		return this;
+	}
+	virtual const XMLText* ToText() const
+	{
+		return this;
+	}
+
+	/// Declare whether this should be CDATA or standard text.
+	void SetCData(bool isCData)
+	{
+		_isCData = isCData;
+	}
+	/// Returns true if this is a CDATA text element.
+	bool CData() const
+	{
+		return _isCData;
+	}
+
+	virtual XMLNode* ShallowClone(XMLDocument* document) const;
+	virtual bool ShallowEqual(const XMLNode* compare) const;
+
+protected:
+	XMLText(XMLDocument* doc) : XMLNode(doc), _isCData(false) {}
+	virtual ~XMLText() {}
+
+	char* ParseDeep(char* p, StrPair* parentEndTag, int* curLineNumPtr);
+
+private:
+	bool _isCData;
+
+	XMLText(const XMLText&);             // not supported
+	XMLText& operator=(const XMLText&);  // not supported
+};
+
+/** An XML Comment. */
+class TINYXML2_LIB XMLComment : public XMLNode
+{
+	friend class XMLDocument;
+
+public:
+	virtual XMLComment* ToComment()
+	{
+		return this;
+	}
+	virtual const XMLComment* ToComment() const
+	{
+		return this;
+	}
+
+	virtual bool Accept(XMLVisitor* visitor) const;
+
+	virtual XMLNode* ShallowClone(XMLDocument* document) const;
+	virtual bool ShallowEqual(const XMLNode* compare) const;
+
+protected:
+	XMLComment(XMLDocument* doc);
+	virtual ~XMLComment();
+
+	char* ParseDeep(char* p, StrPair* parentEndTag, int* curLineNumPtr);
+
+private:
+	XMLComment(const XMLComment&);             // not supported
+	XMLComment& operator=(const XMLComment&);  // not supported
+};
+
+/** In correct XML the declaration is the first entry in the file.
+	@verbatim
+		<?xml version="1.0" standalone="yes"?>
+	@endverbatim
+
+	TinyXML-2 will happily read or write files without a declaration,
+	however.
+
+	The text of the declaration isn't interpreted. It is parsed
+	and written as a string.
+*/
+class TINYXML2_LIB XMLDeclaration : public XMLNode
+{
+	friend class XMLDocument;
+
+public:
+	virtual XMLDeclaration* ToDeclaration()
+	{
+		return this;
+	}
+	virtual const XMLDeclaration* ToDeclaration() const
+	{
+		return this;
+	}
+
+	virtual bool Accept(XMLVisitor* visitor) const;
+
+	virtual XMLNode* ShallowClone(XMLDocument* document) const;
+	virtual bool ShallowEqual(const XMLNode* compare) const;
+
+protected:
+	XMLDeclaration(XMLDocument* doc);
+	virtual ~XMLDeclaration();
+
+	char* ParseDeep(char* p, StrPair* parentEndTag, int* curLineNumPtr);
+
+private:
+	XMLDeclaration(const XMLDeclaration&);             // not supported
+	XMLDeclaration& operator=(const XMLDeclaration&);  // not supported
+};
+
+/** Any tag that TinyXML-2 doesn't recognize is saved as an
+	unknown. It is a tag of text, but should not be modified.
+	It will be written back to the XML, unchanged, when the file
+	is saved.
+
+	DTD tags get thrown into XMLUnknowns.
+*/
+class TINYXML2_LIB XMLUnknown : public XMLNode
+{
+	friend class XMLDocument;
+
+public:
+	virtual XMLUnknown* ToUnknown()
+	{
+		return this;
+	}
+	virtual const XMLUnknown* ToUnknown() const
+	{
+		return this;
+	}
+
+	virtual bool Accept(XMLVisitor* visitor) const;
+
+	virtual XMLNode* ShallowClone(XMLDocument* document) const;
+	virtual bool ShallowEqual(const XMLNode* compare) const;
+
+protected:
+	XMLUnknown(XMLDocument* doc);
+	virtual ~XMLUnknown();
+
+	char* ParseDeep(char* p, StrPair* parentEndTag, int* curLineNumPtr);
+
+private:
+	XMLUnknown(const XMLUnknown&);             // not supported
+	XMLUnknown& operator=(const XMLUnknown&);  // not supported
+};
+
+/** An attribute is a name-value pair. Elements have an arbitrary
+	number of attributes, each with a unique name.
+
+	@note The attributes are not XMLNodes. You may only query the
+	Next() attribute in a list.
+*/
+class TINYXML2_LIB XMLAttribute
+{
+	friend class XMLElement;
+
+public:
+	/// The name of the attribute.
+	const char* Name() const;
+
+	/// The value of the attribute.
+	const char* Value() const;
+
+	/// Gets the line number the attribute is in, if the document was parsed from a file.
+	int GetLineNum() const { return _parseLineNum; }
+
+	/// The next attribute in the list.
+	const XMLAttribute* Next() const
+	{
+		return _next;
+	}
+
+	/** IntValue interprets the attribute as an integer, and returns the value.
+        If the value isn't an integer, 0 will be returned. There is no error checking;
+    	use QueryIntValue() if you need error checking.
+    */
+	int IntValue() const
+	{
+		int i = 0;
+		QueryIntValue(&i);
+		return i;
+	}
+
+	xml_Int64a_t Int64Value() const
+	{
+		xml_Int64a_t i = 0;
+		QueryInt64Value(&i);
+		return i;
+	}
+
+	/// Query as an unsigned integer. See IntValue()
+	unsigned UnsignedValue() const
+	{
+		unsigned i = 0;
+		QueryUnsignedValue(&i);
+		return i;
+	}
+	/// Query as a boolean. See IntValue()
+	bool BoolValue() const
+	{
+		bool b = false;
+		QueryBoolValue(&b);
+		return b;
+	}
+	/// Query as a double. See IntValue()
+	double DoubleValue() const
+	{
+		double d = 0;
+		QueryDoubleValue(&d);
+		return d;
+	}
+	/// Query as a float. See IntValue()
+	float FloatValue() const
+	{
+		float f = 0;
+		QueryFloatValue(&f);
+		return f;
+	}
+
+	/** QueryIntValue interprets the attribute as an integer, and returns the value
+    	in the provided parameter. The function will return XML_SUCCESS on success,
+    	and XML_WRONG_ATTRIBUTE_TYPE if the conversion is not successful.
+    */
+	XMLError QueryIntValue(int* value) const;
+	/// See QueryIntValue
+	XMLError QueryUnsignedValue(unsigned int* value) const;
+	/// See QueryIntValue
+	XMLError QueryInt64Value(xml_Int64a_t* value) const;
+	/// See QueryIntValue
+	XMLError QueryBoolValue(bool* value) const;
+	/// See QueryIntValue
+	XMLError QueryDoubleValue(double* value) const;
+	/// See QueryIntValue
+	XMLError QueryFloatValue(float* value) const;
+
+	/// Set the attribute to a string value.
+	void SetAttribute(const char* value);
+	/// Set the attribute to value.
+	void SetAttribute(int value);
+	/// Set the attribute to value.
+	void SetAttribute(unsigned value);
+	/// Set the attribute to value.
+	void SetAttribute(xml_Int64a_t value);
+	/// Set the attribute to value.
+	void SetAttribute(bool value);
+	/// Set the attribute to value.
+	void SetAttribute(double value);
+	/// Set the attribute to value.
+	void SetAttribute(float value);
+
+private:
+	enum
+	{
+		BUF_SIZE = 200
+	};
+
+	XMLAttribute() : _name(), _value(), _parseLineNum(0), _next(0), _memPool(0) {}
+	virtual ~XMLAttribute() {}
+
+	XMLAttribute(const XMLAttribute&);    // not supported
+	void operator=(const XMLAttribute&);  // not supported
+	void SetName(const char* name);
+
+	char* ParseDeep(char* p, bool processEntities, int* curLineNumPtr);
+
+	mutable StrPair _name;
+	mutable StrPair _value;
+	int _parseLineNum;
+	XMLAttribute* _next;
+	MemPool* _memPool;
+};
+
+/** The element is a container class. It has a value, the element name,
+	and can contain other elements, text, comments, and unknowns.
+	Elements also contain an arbitrary number of attributes.
+*/
+class TINYXML2_LIB XMLElement : public XMLNode
+{
+	friend class XMLDocument;
+
+public:
+	/// Get the name of an element (which is the Value() of the node.)
+	const char* Name() const
+	{
+		return Value();
+	}
+	/// Set the name of the element.
+	void SetName(const char* str, bool staticMem = false)
+	{
+		SetValue(str, staticMem);
+	}
+
+	virtual XMLElement* ToElement()
+	{
+		return this;
+	}
+	virtual const XMLElement* ToElement() const
+	{
+		return this;
+	}
+	virtual bool Accept(XMLVisitor* visitor) const;
+
+	/** Given an attribute name, Attribute() returns the value
+    	for the attribute of that name, or null if none
+    	exists. For example:
+
+    	@verbatim
+    	const char* value = ele->Attribute( "foo" );
+    	@endverbatim
+
+    	The 'value' parameter is normally null. However, if specified,
+    	the attribute will only be returned if the 'name' and 'value'
+    	match. This allow you to write code:
+
+    	@verbatim
+    	if ( ele->Attribute( "foo", "bar" ) ) callFooIsBar();
+    	@endverbatim
+
+    	rather than:
+    	@verbatim
+    	if ( ele->Attribute( "foo" ) ) {
+    		if ( strcmp( ele->Attribute( "foo" ), "bar" ) == 0 ) callFooIsBar();
+    	}
+    	@endverbatim
+    */
+	const char* Attribute(const char* name, const char* value = 0) const;
+
+	/** Given an attribute name, IntAttribute() returns the value
+    	of the attribute interpreted as an integer. The default
+        value will be returned if the attribute isn't present,
+        or if there is an error. (For a method with error
+    	checking, see QueryIntAttribute()).
+    */
+	int IntAttribute(const char* name, int defaultValue = 0) const;
+	/// See IntAttribute()
+	unsigned UnsignedAttribute(const char* name, unsigned defaultValue = 0) const;
+	/// See IntAttribute()
+	xml_Int64a_t Int64Attribute(const char* name, xml_Int64a_t defaultValue = 0) const;
+	/// See IntAttribute()
+	bool BoolAttribute(const char* name, bool defaultValue = false) const;
+	/// See IntAttribute()
+	double DoubleAttribute(const char* name, double defaultValue = 0) const;
+	/// See IntAttribute()
+	float FloatAttribute(const char* name, float defaultValue = 0) const;
+
+	/** Given an attribute name, QueryIntAttribute() returns
+    	XML_SUCCESS, XML_WRONG_ATTRIBUTE_TYPE if the conversion
+    	can't be performed, or XML_NO_ATTRIBUTE if the attribute
+    	doesn't exist. If successful, the result of the conversion
+    	will be written to 'value'. If not successful, nothing will
+    	be written to 'value'. This allows you to provide default
+    	value:
+
+    	@verbatim
+    	int value = 10;
+    	QueryIntAttribute( "foo", &value );		// if "foo" isn't found, value will still be 10
+    	@endverbatim
+    */
+	XMLError QueryIntAttribute(const char* name, int* value) const
+	{
+		const XMLAttribute* a = FindAttribute(name);
+		if (!a)
+		{
+			return XML_NO_ATTRIBUTE;
+		}
+		return a->QueryIntValue(value);
+	}
+
+	/// See QueryIntAttribute()
+	XMLError QueryUnsignedAttribute(const char* name, unsigned int* value) const
+	{
+		const XMLAttribute* a = FindAttribute(name);
+		if (!a)
+		{
+			return XML_NO_ATTRIBUTE;
+		}
+		return a->QueryUnsignedValue(value);
+	}
+
+	/// See QueryIntAttribute()
+	XMLError QueryInt64Attribute(const char* name, xml_Int64a_t* value) const
+	{
+		const XMLAttribute* a = FindAttribute(name);
+		if (!a)
+		{
+			return XML_NO_ATTRIBUTE;
+		}
+		return a->QueryInt64Value(value);
+	}
+
+	/// See QueryIntAttribute()
+	XMLError QueryBoolAttribute(const char* name, bool* value) const
+	{
+		const XMLAttribute* a = FindAttribute(name);
+		if (!a)
+		{
+			return XML_NO_ATTRIBUTE;
+		}
+		return a->QueryBoolValue(value);
+	}
+	/// See QueryIntAttribute()
+	XMLError QueryDoubleAttribute(const char* name, double* value) const
+	{
+		const XMLAttribute* a = FindAttribute(name);
+		if (!a)
+		{
+			return XML_NO_ATTRIBUTE;
+		}
+		return a->QueryDoubleValue(value);
+	}
+	/// See QueryIntAttribute()
+	XMLError QueryFloatAttribute(const char* name, float* value) const
+	{
+		const XMLAttribute* a = FindAttribute(name);
+		if (!a)
+		{
+			return XML_NO_ATTRIBUTE;
+		}
+		return a->QueryFloatValue(value);
+	}
+
+	/// See QueryIntAttribute()
+	XMLError QueryStringAttribute(const char* name, const char** value) const
+	{
+		const XMLAttribute* a = FindAttribute(name);
+		if (!a)
+		{
+			return XML_NO_ATTRIBUTE;
+		}
+		*value = a->Value();
+		return XML_SUCCESS;
+	}
+
+	/** Given an attribute name, QueryAttribute() returns
+    	XML_SUCCESS, XML_WRONG_ATTRIBUTE_TYPE if the conversion
+    	can't be performed, or XML_NO_ATTRIBUTE if the attribute
+    	doesn't exist. It is overloaded for the primitive types,
+		and is a generally more convenient replacement of
+		QueryIntAttribute() and related functions.
+		
+		If successful, the result of the conversion
+    	will be written to 'value'. If not successful, nothing will
+    	be written to 'value'. This allows you to provide default
+    	value:
+
+    	@verbatim
+    	int value = 10;
+    	QueryAttribute( "foo", &value );		// if "foo" isn't found, value will still be 10
+    	@endverbatim
+    */
+	int QueryAttribute(const char* name, int* value) const
+	{
+		return QueryIntAttribute(name, value);
+	}
+
+	int QueryAttribute(const char* name, unsigned int* value) const
+	{
+		return QueryUnsignedAttribute(name, value);
+	}
+
+	int QueryAttribute(const char* name, xml_Int64a_t* value) const
+	{
+		return QueryInt64Attribute(name, value);
+	}
+
+	int QueryAttribute(const char* name, bool* value) const
+	{
+		return QueryBoolAttribute(name, value);
+	}
+
+	int QueryAttribute(const char* name, double* value) const
+	{
+		return QueryDoubleAttribute(name, value);
+	}
+
+	int QueryAttribute(const char* name, float* value) const
+	{
+		return QueryFloatAttribute(name, value);
+	}
+
+	/// Sets the named attribute to value.
+	void SetAttribute(const char* name, const char* value)
+	{
+		XMLAttribute* a = FindOrCreateAttribute(name);
+		a->SetAttribute(value);
+	}
+	/// Sets the named attribute to value.
+	void SetAttribute(const char* name, int value)
+	{
+		XMLAttribute* a = FindOrCreateAttribute(name);
+		a->SetAttribute(value);
+	}
+	/// Sets the named attribute to value.
+	void SetAttribute(const char* name, unsigned value)
+	{
+		XMLAttribute* a = FindOrCreateAttribute(name);
+		a->SetAttribute(value);
+	}
+
+	/// Sets the named attribute to value.
+	void SetAttribute(const char* name, xml_Int64a_t value)
+	{
+		XMLAttribute* a = FindOrCreateAttribute(name);
+		a->SetAttribute(value);
+	}
+
+	/// Sets the named attribute to value.
+	void SetAttribute(const char* name, bool value)
+	{
+		XMLAttribute* a = FindOrCreateAttribute(name);
+		a->SetAttribute(value);
+	}
+	/// Sets the named attribute to value.
+	void SetAttribute(const char* name, double value)
+	{
+		XMLAttribute* a = FindOrCreateAttribute(name);
+		a->SetAttribute(value);
+	}
+	/// Sets the named attribute to value.
+	void SetAttribute(const char* name, float value)
+	{
+		XMLAttribute* a = FindOrCreateAttribute(name);
+		a->SetAttribute(value);
+	}
+
+	/**
+    	Delete an attribute.
+    */
+	void DeleteAttribute(const char* name);
+
+	/// Return the first attribute in the list.
+	const XMLAttribute* FirstAttribute() const
+	{
+		return _rootAttribute;
+	}
+	/// Query a specific attribute in the list.
+	const XMLAttribute* FindAttribute(const char* name) const;
+
+	/** Convenience function for easy access to the text inside an element. Although easy
+    	and concise, GetText() is limited compared to getting the XMLText child
+    	and accessing it directly.
+
+    	If the first child of 'this' is a XMLText, the GetText()
+    	returns the character string of the Text node, else null is returned.
+
+    	This is a convenient method for getting the text of simple contained text:
+    	@verbatim
+    	<foo>This is text</foo>
+    		const char* str = fooElement->GetText();
+    	@endverbatim
+
+    	'str' will be a pointer to "This is text".
+
+    	Note that this function can be misleading. If the element foo was created from
+    	this XML:
+    	@verbatim
+    		<foo><b>This is text</b></foo>
+    	@endverbatim
+
+    	then the value of str would be null. The first child node isn't a text node, it is
+    	another element. From this XML:
+    	@verbatim
+    		<foo>This is <b>text</b></foo>
+    	@endverbatim
+    	GetText() will return "This is ".
+    */
+	const char* GetText() const;
+
+	/** Convenience function for easy access to the text inside an element. Although easy
+    	and concise, SetText() is limited compared to creating an XMLText child
+    	and mutating it directly.
+
+    	If the first child of 'this' is a XMLText, SetText() sets its value to
+		the given string, otherwise it will create a first child that is an XMLText.
+
+    	This is a convenient method for setting the text of simple contained text:
+    	@verbatim
+    	<foo>This is text</foo>
+    		fooElement->SetText( "Hullaballoo!" );
+     	<foo>Hullaballoo!</foo>
+		@endverbatim
+
+    	Note that this function can be misleading. If the element foo was created from
+    	this XML:
+    	@verbatim
+    		<foo><b>This is text</b></foo>
+    	@endverbatim
+
+    	then it will not change "This is text", but rather prefix it with a text element:
+    	@verbatim
+    		<foo>Hullaballoo!<b>This is text</b></foo>
+    	@endverbatim
+		
+		For this XML:
+    	@verbatim
+    		<foo />
+    	@endverbatim
+    	SetText() will generate
+    	@verbatim
+    		<foo>Hullaballoo!</foo>
+    	@endverbatim
+    */
+	void SetText(const char* inText);
+	/// Convenience method for setting text inside an element. See SetText() for important limitations.
+	void SetText(int value);
+	/// Convenience method for setting text inside an element. See SetText() for important limitations.
+	void SetText(unsigned value);
+	/// Convenience method for setting text inside an element. See SetText() for important limitations.
+	void SetText(xml_Int64a_t value);
+	/// Convenience method for setting text inside an element. See SetText() for important limitations.
+	void SetText(bool value);
+	/// Convenience method for setting text inside an element. See SetText() for important limitations.
+	void SetText(double value);
+	/// Convenience method for setting text inside an element. See SetText() for important limitations.
+	void SetText(float value);
+
+	/**
+    	Convenience method to query the value of a child text node. This is probably best
+    	shown by example. Given you have a document is this form:
+    	@verbatim
+    		<point>
+    			<x>1</x>
+    			<y>1.4</y>
+    		</point>
+    	@endverbatim
+
+    	The QueryIntText() and similar functions provide a safe and easier way to get to the
+    	"value" of x and y.
+
+    	@verbatim
+    		int x = 0;
+    		float y = 0;	// types of x and y are contrived for example
+    		const XMLElement* xElement = pointElement->FirstChildElement( "x" );
+    		const XMLElement* yElement = pointElement->FirstChildElement( "y" );
+    		xElement->QueryIntText( &x );
+    		yElement->QueryFloatText( &y );
+    	@endverbatim
+
+    	@returns XML_SUCCESS (0) on success, XML_CAN_NOT_CONVERT_TEXT if the text cannot be converted
+    			 to the requested type, and XML_NO_TEXT_NODE if there is no child text to query.
+
+    */
+	XMLError QueryIntText(int* ival) const;
+	/// See QueryIntText()
+	XMLError QueryUnsignedText(unsigned* uval) const;
+	/// See QueryIntText()
+	XMLError QueryInt64Text(xml_Int64a_t* uval) const;
+	/// See QueryIntText()
+	XMLError QueryBoolText(bool* bval) const;
+	/// See QueryIntText()
+	XMLError QueryDoubleText(double* dval) const;
+	/// See QueryIntText()
+	XMLError QueryFloatText(float* fval) const;
+
+	int IntText(int defaultValue = 0) const;
+
+	/// See QueryIntText()
+	unsigned UnsignedText(unsigned defaultValue = 0) const;
+	/// See QueryIntText()
+	xml_Int64a_t Int64Text(xml_Int64a_t defaultValue = 0) const;
+	/// See QueryIntText()
+	bool BoolText(bool defaultValue = false) const;
+	/// See QueryIntText()
+	double DoubleText(double defaultValue = 0) const;
+	/// See QueryIntText()
+	float FloatText(float defaultValue = 0) const;
+
+	// internal:
+	enum ElementClosingType
+	{
+		OPEN,    // <foo>
+		CLOSED,  // <foo/>
+		CLOSING  // </foo>
+	};
+	ElementClosingType ClosingType() const
+	{
+		return _closingType;
+	}
+	virtual XMLNode* ShallowClone(XMLDocument* document) const;
+	virtual bool ShallowEqual(const XMLNode* compare) const;
+
+protected:
+	char* ParseDeep(char* p, StrPair* parentEndTag, int* curLineNumPtr);
+
+private:
+	XMLElement(XMLDocument* doc);
+	virtual ~XMLElement();
+	XMLElement(const XMLElement&);      // not supported
+	void operator=(const XMLElement&);  // not supported
+
+	XMLAttribute* FindAttribute(const char* name)
+	{
+		return const_cast<XMLAttribute*>(const_cast<const XMLElement*>(this)->FindAttribute(name));
+	}
+	XMLAttribute* FindOrCreateAttribute(const char* name);
+	//void LinkAttribute( XMLAttribute* attrib );
+	char* ParseAttributes(char* p, int* curLineNumPtr);
+	static void DeleteAttribute(XMLAttribute* attribute);
+	XMLAttribute* CreateAttribute();
+
+	enum
+	{
+		BUF_SIZE = 200
+	};
+	ElementClosingType _closingType;
+	// The attribute list is ordered; there is no 'lastAttribute'
+	// because the list needs to be scanned for dupes before adding
+	// a new attribute.
+	XMLAttribute* _rootAttribute;
+};
+
+enum Whitespace
+{
+	PRESERVE_WHITESPACE,
+	COLLAPSE_WHITESPACE
+};
+
+/** A Document binds together all the functionality.
+	It can be saved, loaded, and printed to the screen.
+	All Nodes are connected and allocated to a Document.
+	If the Document is deleted, all its Nodes are also deleted.
+*/
+class TINYXML2_LIB XMLDocument : public XMLNode
+{
+	friend class XMLElement;
+	// Gives access to SetError and Push/PopDepth, but over-access for everything else.
+	// Wishing C++ had "internal" scope.
+	friend class XMLNode;
+	friend class XMLText;
+	friend class XMLComment;
+	friend class XMLDeclaration;
+	friend class XMLUnknown;
+
+public:
+	/// constructor
+	XMLDocument(bool processEntities = true, Whitespace whitespaceMode = PRESERVE_WHITESPACE);
+	~XMLDocument();
+
+	virtual XMLDocument* ToDocument()
+	{
+		TIXMLASSERT(this == _document);
+		return this;
+	}
+	virtual const XMLDocument* ToDocument() const
+	{
+		TIXMLASSERT(this == _document);
+		return this;
+	}
+
+	/**
+    	Parse an XML file from a character string.
+    	Returns XML_SUCCESS (0) on success, or
+    	an errorID.
+
+    	You may optionally pass in the 'nBytes', which is
+    	the number of bytes which will be parsed. If not
+    	specified, TinyXML-2 will assume 'xml' points to a
+    	null terminated string.
+    */
+	XMLError Parse(const char* xml, size_t nBytes = (size_t)(-1));
+
+	/**
+    	Load an XML file from disk.
+    	Returns XML_SUCCESS (0) on success, or
+    	an errorID.
+    */
+	XMLError LoadFile(const char* filename);
+
+	/**
+    	Load an XML file from disk. You are responsible
+    	for providing and closing the FILE*. 
+     
+        NOTE: The file should be opened as binary ("rb")
+        not text in order for TinyXML-2 to correctly
+        do newline normalization.
+
+    	Returns XML_SUCCESS (0) on success, or
+    	an errorID.
+    */
+	XMLError LoadFile(FILE*);
+
+	/**
+    	Save the XML file to disk.
+    	Returns XML_SUCCESS (0) on success, or
+    	an errorID.
+    */
+	XMLError SaveFile(const char* filename, bool compact = false);
+
+	/**
+    	Save the XML file to disk. You are responsible
+    	for providing and closing the FILE*.
+
+    	Returns XML_SUCCESS (0) on success, or
+    	an errorID.
+    */
+	XMLError SaveFile(FILE* fp, bool compact = false);
+
+	bool ProcessEntities() const
+	{
+		return _processEntities;
+	}
+	Whitespace WhitespaceMode() const
+	{
+		return _whitespaceMode;
+	}
+
+	/**
+    	Returns true if this document has a leading Byte Order Mark of UTF8.
+    */
+	bool HasBOM() const
+	{
+		return _writeBOM;
+	}
+	/** Sets whether to write the BOM when writing the file.
+    */
+	void SetBOM(bool useBOM)
+	{
+		_writeBOM = useBOM;
+	}
+
+	/** Return the root element of DOM. Equivalent to FirstChildElement().
+        To get the first node, use FirstChild().
+    */
+	XMLElement* RootElement()
+	{
+		return FirstChildElement();
+	}
+	const XMLElement* RootElement() const
+	{
+		return FirstChildElement();
+	}
+
+	/** Print the Document. If the Printer is not provided, it will
+        print to stdout. If you provide Printer, this can print to a file:
+    	@verbatim
+    	XMLPrinter printer( fp );
+    	doc.Print( &printer );
+    	@endverbatim
+
+    	Or you can use a printer to print to memory:
+    	@verbatim
+    	XMLPrinter printer;
+    	doc.Print( &printer );
+    	// printer.CStr() has a const char* to the XML
+    	@endverbatim
+    */
+	void Print(XMLPrinter* streamer = 0) const;
+	virtual bool Accept(XMLVisitor* visitor) const;
+
+	/**
+    	Create a new Element associated with
+    	this Document. The memory for the Element
+    	is managed by the Document.
+    */
+	XMLElement* NewElement(const char* name);
+	/**
+    	Create a new Comment associated with
+    	this Document. The memory for the Comment
+    	is managed by the Document.
+    */
+	XMLComment* NewComment(const char* comment);
+	/**
+    	Create a new Text associated with
+    	this Document. The memory for the Text
+    	is managed by the Document.
+    */
+	XMLText* NewText(const char* text);
+	/**
+    	Create a new Declaration associated with
+    	this Document. The memory for the object
+    	is managed by the Document.
+
+    	If the 'text' param is null, the standard
+    	declaration is used.:
+    	@verbatim
+    		<?xml version="1.0" encoding="UTF-8"?>
+    	@endverbatim
+    */
+	XMLDeclaration* NewDeclaration(const char* text = 0);
+	/**
+    	Create a new Unknown associated with
+    	this Document. The memory for the object
+    	is managed by the Document.
+    */
+	XMLUnknown* NewUnknown(const char* text);
+
+	/**
+    	Delete a node associated with this document.
+    	It will be unlinked from the DOM.
+    */
+	void DeleteNode(XMLNode* node);
+
+	void ClearError()
+	{
+		SetError(XML_SUCCESS, 0, 0);
+	}
+
+	/// Return true if there was an error parsing the document.
+	bool Error() const
+	{
+		return _errorID != XML_SUCCESS;
+	}
+	/// Return the errorID.
+	XMLError ErrorID() const
+	{
+		return _errorID;
+	}
+	const char* ErrorName() const;
+	static const char* ErrorIDToName(XMLError errorID);
+
+	/** Returns a "long form" error description. A hopefully helpful 
+        diagnostic with location, line number, and/or additional info.
+    */
+	const char* ErrorStr() const;
+
+	/// A (trivial) utility function that prints the ErrorStr() to stdout.
+	void PrintError() const;
+
+	/// Return the line where the error occured, or zero if unknown.
+	int ErrorLineNum() const
+	{
+		return _errorLineNum;
+	}
+
+	/// Clear the document, resetting it to the initial state.
+	void Clear();
+
+	/**
+		Copies this document to a target document.
+		The target will be completely cleared before the copy.
+		If you want to copy a sub-tree, see XMLNode::DeepClone().
+
+		NOTE: that the 'target' must be non-null.
+	*/
+	void DeepCopy(XMLDocument* target) const;
+
+	// internal
+	char* Identify(char* p, XMLNode** node);
+
+	// internal
+	void MarkInUse(XMLNode*);
+
+	virtual XMLNode* ShallowClone(XMLDocument* /*document*/) const
+	{
+		return 0;
+	}
+	virtual bool ShallowEqual(const XMLNode* /*compare*/) const
+	{
+		return false;
+	}
+
+private:
+	XMLDocument(const XMLDocument&);     // not supported
+	void operator=(const XMLDocument&);  // not supported
+
+	bool _writeBOM;
+	bool _processEntities;
+	XMLError _errorID;
+	Whitespace _whitespaceMode;
+	mutable StrPair _errorStr;
+	int _errorLineNum;
+	char* _charBuffer;
+	int _parseCurLineNum;
+	int _parsingDepth;
+	// Memory tracking does add some overhead.
+	// However, the code assumes that you don't
+	// have a bunch of unlinked nodes around.
+	// Therefore it takes less memory to track
+	// in the document vs. a linked list in the XMLNode,
+	// and the performance is the same.
+	DynArray<XMLNode*, 10> _unlinked;
+
+	MemPoolT<sizeof(XMLElement)> _elementPool;
+	MemPoolT<sizeof(XMLAttribute)> _attributePool;
+	MemPoolT<sizeof(XMLText)> _textPool;
+	MemPoolT<sizeof(XMLComment)> _commentPool;
+
+	static const char* _errorNames[XML_ERROR_COUNT];
+
+	void Parse();
+
+	void SetError(XMLError error, int lineNum, const char* format, ...);
+
+	// Something of an obvious security hole, once it was discovered.
+	// Either an ill-formed XML or an excessively deep one can overflow
+	// the stack. Track stack depth, and error out if needed.
+	class DepthTracker
+	{
+	public:
+		DepthTracker(XMLDocument* document)
+		{
+			this->_document = document;
+			document->PushDepth();
+		}
+		~DepthTracker()
+		{
+			_document->PopDepth();
+		}
+
+	private:
+		XMLDocument* _document;
+	};
+	void PushDepth();
+	void PopDepth();
+
+	template <class NodeType, int PoolElementSize>
+	NodeType* CreateUnlinkedNode(MemPoolT<PoolElementSize>& pool);
+};
+
+template <class NodeType, int PoolElementSize>
+inline NodeType* XMLDocument::CreateUnlinkedNode(MemPoolT<PoolElementSize>& pool)
+{
+	TIXMLASSERT(sizeof(NodeType) == PoolElementSize);
+	TIXMLASSERT(sizeof(NodeType) == pool.ItemSize());
+	NodeType* returnNode = new (pool.Alloc()) NodeType(this);
+	TIXMLASSERT(returnNode);
+	returnNode->_memPool = &pool;
+
+	_unlinked.Push(returnNode);
+	return returnNode;
+}
+
+/**
+	A XMLHandle is a class that wraps a node pointer with null checks; this is
+	an incredibly useful thing. Note that XMLHandle is not part of the TinyXML-2
+	DOM structure. It is a separate utility class.
+
+	Take an example:
+	@verbatim
+	<Document>
+		<Element attributeA = "valueA">
+			<Child attributeB = "value1" />
+			<Child attributeB = "value2" />
+		</Element>
+	</Document>
+	@endverbatim
+
+	Assuming you want the value of "attributeB" in the 2nd "Child" element, it's very
+	easy to write a *lot* of code that looks like:
+
+	@verbatim
+	XMLElement* root = document.FirstChildElement( "Document" );
+	if ( root )
+	{
+		XMLElement* element = root->FirstChildElement( "Element" );
+		if ( element )
+		{
+			XMLElement* child = element->FirstChildElement( "Child" );
+			if ( child )
+			{
+				XMLElement* child2 = child->NextSiblingElement( "Child" );
+				if ( child2 )
+				{
+					// Finally do something useful.
+	@endverbatim
+
+	And that doesn't even cover "else" cases. XMLHandle addresses the verbosity
+	of such code. A XMLHandle checks for null pointers so it is perfectly safe
+	and correct to use:
+
+	@verbatim
+	XMLHandle docHandle( &document );
+	XMLElement* child2 = docHandle.FirstChildElement( "Document" ).FirstChildElement( "Element" ).FirstChildElement().NextSiblingElement();
+	if ( child2 )
+	{
+		// do something useful
+	@endverbatim
+
+	Which is MUCH more concise and useful.
+
+	It is also safe to copy handles - internally they are nothing more than node pointers.
+	@verbatim
+	XMLHandle handleCopy = handle;
+	@endverbatim
+
+	See also XMLConstHandle, which is the same as XMLHandle, but operates on const objects.
+*/
+class TINYXML2_LIB XMLHandle
+{
+public:
+	/// Create a handle from any node (at any depth of the tree.) This can be a null pointer.
+	XMLHandle(XMLNode* node) : _node(node)
+	{
+	}
+	/// Create a handle from a node.
+	XMLHandle(XMLNode& node) : _node(&node)
+	{
+	}
+	/// Copy constructor
+	XMLHandle(const XMLHandle& ref) : _node(ref._node)
+	{
+	}
+	/// Assignment
+	XMLHandle& operator=(const XMLHandle& ref)
+	{
+		_node = ref._node;
+		return *this;
+	}
+
+	/// Get the first child of this handle.
+	XMLHandle FirstChild()
+	{
+		return XMLHandle(_node ? _node->FirstChild() : 0);
+	}
+	/// Get the first child element of this handle.
+	XMLHandle FirstChildElement(const char* name = 0)
+	{
+		return XMLHandle(_node ? _node->FirstChildElement(name) : 0);
+	}
+	/// Get the last child of this handle.
+	XMLHandle LastChild()
+	{
+		return XMLHandle(_node ? _node->LastChild() : 0);
+	}
+	/// Get the last child element of this handle.
+	XMLHandle LastChildElement(const char* name = 0)
+	{
+		return XMLHandle(_node ? _node->LastChildElement(name) : 0);
+	}
+	/// Get the previous sibling of this handle.
+	XMLHandle PreviousSibling()
+	{
+		return XMLHandle(_node ? _node->PreviousSibling() : 0);
+	}
+	/// Get the previous sibling element of this handle.
+	XMLHandle PreviousSiblingElement(const char* name = 0)
+	{
+		return XMLHandle(_node ? _node->PreviousSiblingElement(name) : 0);
+	}
+	/// Get the next sibling of this handle.
+	XMLHandle NextSibling()
+	{
+		return XMLHandle(_node ? _node->NextSibling() : 0);
+	}
+	/// Get the next sibling element of this handle.
+	XMLHandle NextSiblingElement(const char* name = 0)
+	{
+		return XMLHandle(_node ? _node->NextSiblingElement(name) : 0);
+	}
+
+	/// Safe cast to XMLNode. This can return null.
+	XMLNode* ToNode()
+	{
+		return _node;
+	}
+	/// Safe cast to XMLElement. This can return null.
+	XMLElement* ToElement()
+	{
+		return (_node ? _node->ToElement() : 0);
+	}
+	/// Safe cast to XMLText. This can return null.
+	XMLText* ToText()
+	{
+		return (_node ? _node->ToText() : 0);
+	}
+	/// Safe cast to XMLUnknown. This can return null.
+	XMLUnknown* ToUnknown()
+	{
+		return (_node ? _node->ToUnknown() : 0);
+	}
+	/// Safe cast to XMLDeclaration. This can return null.
+	XMLDeclaration* ToDeclaration()
+	{
+		return (_node ? _node->ToDeclaration() : 0);
+	}
+
+private:
+	XMLNode* _node;
+};
+
+/**
+	A variant of the XMLHandle class for working with const XMLNodes and Documents. It is the
+	same in all regards, except for the 'const' qualifiers. See XMLHandle for API.
+*/
+class TINYXML2_LIB XMLConstHandle
+{
+public:
+	XMLConstHandle(const XMLNode* node) : _node(node)
+	{
+	}
+	XMLConstHandle(const XMLNode& node) : _node(&node)
+	{
+	}
+	XMLConstHandle(const XMLConstHandle& ref) : _node(ref._node)
+	{
+	}
+
+	XMLConstHandle& operator=(const XMLConstHandle& ref)
+	{
+		_node = ref._node;
+		return *this;
+	}
+
+	const XMLConstHandle FirstChild() const
+	{
+		return XMLConstHandle(_node ? _node->FirstChild() : 0);
+	}
+	const XMLConstHandle FirstChildElement(const char* name = 0) const
+	{
+		return XMLConstHandle(_node ? _node->FirstChildElement(name) : 0);
+	}
+	const XMLConstHandle LastChild() const
+	{
+		return XMLConstHandle(_node ? _node->LastChild() : 0);
+	}
+	const XMLConstHandle LastChildElement(const char* name = 0) const
+	{
+		return XMLConstHandle(_node ? _node->LastChildElement(name) : 0);
+	}
+	const XMLConstHandle PreviousSibling() const
+	{
+		return XMLConstHandle(_node ? _node->PreviousSibling() : 0);
+	}
+	const XMLConstHandle PreviousSiblingElement(const char* name = 0) const
+	{
+		return XMLConstHandle(_node ? _node->PreviousSiblingElement(name) : 0);
+	}
+	const XMLConstHandle NextSibling() const
+	{
+		return XMLConstHandle(_node ? _node->NextSibling() : 0);
+	}
+	const XMLConstHandle NextSiblingElement(const char* name = 0) const
+	{
+		return XMLConstHandle(_node ? _node->NextSiblingElement(name) : 0);
+	}
+
+	const XMLNode* ToNode() const
+	{
+		return _node;
+	}
+	const XMLElement* ToElement() const
+	{
+		return (_node ? _node->ToElement() : 0);
+	}
+	const XMLText* ToText() const
+	{
+		return (_node ? _node->ToText() : 0);
+	}
+	const XMLUnknown* ToUnknown() const
+	{
+		return (_node ? _node->ToUnknown() : 0);
+	}
+	const XMLDeclaration* ToDeclaration() const
+	{
+		return (_node ? _node->ToDeclaration() : 0);
+	}
+
+private:
+	const XMLNode* _node;
+};
+
+/**
+	Printing functionality. The XMLPrinter gives you more
+	options than the XMLDocument::Print() method.
+
+	It can:
+	-# Print to memory.
+	-# Print to a file you provide.
+	-# Print XML without a XMLDocument.
+
+	Print to Memory
+
+	@verbatim
+	XMLPrinter printer;
+	doc.Print( &printer );
+	SomeFunction( printer.CStr() );
+	@endverbatim
+
+	Print to a File
+
+	You provide the file pointer.
+	@verbatim
+	XMLPrinter printer( fp );
+	doc.Print( &printer );
+	@endverbatim
+
+	Print without a XMLDocument
+
+	When loading, an XML parser is very useful. However, sometimes
+	when saving, it just gets in the way. The code is often set up
+	for streaming, and constructing the DOM is just overhead.
+
+	The Printer supports the streaming case. The following code
+	prints out a trivially simple XML file without ever creating
+	an XML document.
+
+	@verbatim
+	XMLPrinter printer( fp );
+	printer.OpenElement( "foo" );
+	printer.PushAttribute( "foo", "bar" );
+	printer.CloseElement();
+	@endverbatim
+*/
+class TINYXML2_LIB XMLPrinter : public XMLVisitor
+{
+public:
+	/** Construct the printer. If the FILE* is specified,
+    	this will print to the FILE. Else it will print
+    	to memory, and the result is available in CStr().
+    	If 'compact' is set to true, then output is created
+    	with only required whitespace and newlines.
+    */
+	XMLPrinter(FILE* file = 0, bool compact = false, int depth = 0);
+	virtual ~XMLPrinter() {}
+
+	/** If streaming, write the BOM and declaration. */
+	void PushHeader(bool writeBOM, bool writeDeclaration);
+	/** If streaming, start writing an element.
+        The element must be closed with CloseElement()
+    */
+	void OpenElement(const char* name, bool compactMode = false);
+	/// If streaming, add an attribute to an open element.
+	void PushAttribute(const char* name, const char* value);
+	void PushAttribute(const char* name, int value);
+	void PushAttribute(const char* name, unsigned value);
+	void PushAttribute(const char* name, xml_Int64a_t value);
+	void PushAttribute(const char* name, bool value);
+	void PushAttribute(const char* name, double value);
+	/// If streaming, close the Element.
+	virtual void CloseElement(bool compactMode = false);
+
+	/// Add a text node.
+	void PushText(const char* text, bool cdata = false);
+	/// Add a text node from an integer.
+	void PushText(int value);
+	/// Add a text node from an unsigned.
+	void PushText(unsigned value);
+	/// Add a text node from an unsigned.
+	void PushText(xml_Int64a_t value);
+	/// Add a text node from a bool.
+	void PushText(bool value);
+	/// Add a text node from a float.
+	void PushText(float value);
+	/// Add a text node from a double.
+	void PushText(double value);
+
+	/// Add a comment
+	void PushComment(const char* comment);
+
+	void PushDeclaration(const char* value);
+	void PushUnknown(const char* value);
+
+	virtual bool VisitEnter(const XMLDocument& /*doc*/);
+	virtual bool VisitExit(const XMLDocument& /*doc*/)
+	{
+		return true;
+	}
+
+	virtual bool VisitEnter(const XMLElement& element, const XMLAttribute* attribute);
+	virtual bool VisitExit(const XMLElement& element);
+
+	virtual bool Visit(const XMLText& text);
+	virtual bool Visit(const XMLComment& comment);
+	virtual bool Visit(const XMLDeclaration& declaration);
+	virtual bool Visit(const XMLUnknown& unknown);
+
+	/**
+    	If in print to memory mode, return a pointer to
+    	the XML file in memory.
+    */
+	const char* CStr() const
+	{
+		return _buffer.Mem();
+	}
+	/**
+    	If in print to memory mode, return the size
+    	of the XML file in memory. (Note the size returned
+    	includes the terminating null.)
+    */
+	int CStrSize() const
+	{
+		return _buffer.Size();
+	}
+	/**
+    	If in print to memory mode, reset the buffer to the
+    	beginning.
+    */
+	void ClearBuffer()
+	{
+		_buffer.Clear();
+		_buffer.Push(0);
+		_firstElement = true;
+	}
+
+protected:
+	virtual bool CompactMode(const XMLElement&) { return _compactMode; }
+
+	/** Prints out the space before an element. You may override to change
+	    the space and tabs used. A PrintSpace() override should call Print().
+	*/
+	virtual void PrintSpace(int depth);
+	void Print(const char* format, ...);
+	void Write(const char* data, size_t size);
+	inline void Write(const char* data) { Write(data, strlen(data)); }
+	void Putc(char ch);
+
+	void SealElementIfJustOpened();
+	bool _elementJustOpened;
+	DynArray<const char*, 10> _stack;
+
+private:
+	void PrintString(const char*, bool restrictedEntitySet);  // prints out, after detecting entities.
+
+	bool _firstElement;
+	FILE* _fp;
+	int _depth;
+	int _textDepth;
+	bool _processEntities;
+	bool _compactMode;
+
+	enum
+	{
+		ENTITY_RANGE = 64,
+		BUF_SIZE = 200
+	};
+	bool _entityFlag[ENTITY_RANGE];
+	bool _restrictedEntityFlag[ENTITY_RANGE];
+
+	DynArray<char, 20> _buffer;
+
+	// Prohibit cloning, intentionally not implemented
+	XMLPrinter(const XMLPrinter&);
+	XMLPrinter& operator=(const XMLPrinter&);
+};
+
+}  // namespace tinyxml2
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+#endif  // TINYXML2_INCLUDED
diff --git a/engine/inc/bullet/ThirdPartyLibs/zlib/crc32.h b/engine/inc/bullet/ThirdPartyLibs/zlib/crc32.h
new file mode 100644
index 00000000..1ba41ad8
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/zlib/crc32.h
@@ -0,0 +1,426 @@
+/* crc32.h -- tables for rapid CRC calculation
+ * Generated automatically by crc32.c
+ */
+
+local const z_crc_t FAR crc_table[TBLS][256] =
+	{
+		{0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
+		 0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
+		 0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,
+		 0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,
+		 0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,
+		 0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,
+		 0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,
+		 0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,
+		 0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,
+		 0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,
+		 0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,
+		 0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,
+		 0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,
+		 0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,
+		 0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,
+		 0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,
+		 0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,
+		 0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,
+		 0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,
+		 0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,
+		 0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,
+		 0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,
+		 0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,
+		 0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,
+		 0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,
+		 0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,
+		 0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,
+		 0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,
+		 0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,
+		 0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,
+		 0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,
+		 0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,
+		 0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,
+		 0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,
+		 0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,
+		 0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,
+		 0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,
+		 0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,
+		 0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,
+		 0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,
+		 0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,
+		 0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,
+		 0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,
+		 0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,
+		 0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,
+		 0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,
+		 0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,
+		 0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,
+		 0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,
+		 0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
+		 0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
+		 0x2d02ef8dUL
+#ifdef BYFOUR
+		},
+		{0x00000000UL, 0x191b3141UL, 0x32366282UL, 0x2b2d53c3UL, 0x646cc504UL,
+		 0x7d77f445UL, 0x565aa786UL, 0x4f4196c7UL, 0xc8d98a08UL, 0xd1c2bb49UL,
+		 0xfaefe88aUL, 0xe3f4d9cbUL, 0xacb54f0cUL, 0xb5ae7e4dUL, 0x9e832d8eUL,
+		 0x87981ccfUL, 0x4ac21251UL, 0x53d92310UL, 0x78f470d3UL, 0x61ef4192UL,
+		 0x2eaed755UL, 0x37b5e614UL, 0x1c98b5d7UL, 0x05838496UL, 0x821b9859UL,
+		 0x9b00a918UL, 0xb02dfadbUL, 0xa936cb9aUL, 0xe6775d5dUL, 0xff6c6c1cUL,
+		 0xd4413fdfUL, 0xcd5a0e9eUL, 0x958424a2UL, 0x8c9f15e3UL, 0xa7b24620UL,
+		 0xbea97761UL, 0xf1e8e1a6UL, 0xe8f3d0e7UL, 0xc3de8324UL, 0xdac5b265UL,
+		 0x5d5daeaaUL, 0x44469febUL, 0x6f6bcc28UL, 0x7670fd69UL, 0x39316baeUL,
+		 0x202a5aefUL, 0x0b07092cUL, 0x121c386dUL, 0xdf4636f3UL, 0xc65d07b2UL,
+		 0xed705471UL, 0xf46b6530UL, 0xbb2af3f7UL, 0xa231c2b6UL, 0x891c9175UL,
+		 0x9007a034UL, 0x179fbcfbUL, 0x0e848dbaUL, 0x25a9de79UL, 0x3cb2ef38UL,
+		 0x73f379ffUL, 0x6ae848beUL, 0x41c51b7dUL, 0x58de2a3cUL, 0xf0794f05UL,
+		 0xe9627e44UL, 0xc24f2d87UL, 0xdb541cc6UL, 0x94158a01UL, 0x8d0ebb40UL,
+		 0xa623e883UL, 0xbf38d9c2UL, 0x38a0c50dUL, 0x21bbf44cUL, 0x0a96a78fUL,
+		 0x138d96ceUL, 0x5ccc0009UL, 0x45d73148UL, 0x6efa628bUL, 0x77e153caUL,
+		 0xbabb5d54UL, 0xa3a06c15UL, 0x888d3fd6UL, 0x91960e97UL, 0xded79850UL,
+		 0xc7cca911UL, 0xece1fad2UL, 0xf5facb93UL, 0x7262d75cUL, 0x6b79e61dUL,
+		 0x4054b5deUL, 0x594f849fUL, 0x160e1258UL, 0x0f152319UL, 0x243870daUL,
+		 0x3d23419bUL, 0x65fd6ba7UL, 0x7ce65ae6UL, 0x57cb0925UL, 0x4ed03864UL,
+		 0x0191aea3UL, 0x188a9fe2UL, 0x33a7cc21UL, 0x2abcfd60UL, 0xad24e1afUL,
+		 0xb43fd0eeUL, 0x9f12832dUL, 0x8609b26cUL, 0xc94824abUL, 0xd05315eaUL,
+		 0xfb7e4629UL, 0xe2657768UL, 0x2f3f79f6UL, 0x362448b7UL, 0x1d091b74UL,
+		 0x04122a35UL, 0x4b53bcf2UL, 0x52488db3UL, 0x7965de70UL, 0x607eef31UL,
+		 0xe7e6f3feUL, 0xfefdc2bfUL, 0xd5d0917cUL, 0xcccba03dUL, 0x838a36faUL,
+		 0x9a9107bbUL, 0xb1bc5478UL, 0xa8a76539UL, 0x3b83984bUL, 0x2298a90aUL,
+		 0x09b5fac9UL, 0x10aecb88UL, 0x5fef5d4fUL, 0x46f46c0eUL, 0x6dd93fcdUL,
+		 0x74c20e8cUL, 0xf35a1243UL, 0xea412302UL, 0xc16c70c1UL, 0xd8774180UL,
+		 0x9736d747UL, 0x8e2de606UL, 0xa500b5c5UL, 0xbc1b8484UL, 0x71418a1aUL,
+		 0x685abb5bUL, 0x4377e898UL, 0x5a6cd9d9UL, 0x152d4f1eUL, 0x0c367e5fUL,
+		 0x271b2d9cUL, 0x3e001cddUL, 0xb9980012UL, 0xa0833153UL, 0x8bae6290UL,
+		 0x92b553d1UL, 0xddf4c516UL, 0xc4eff457UL, 0xefc2a794UL, 0xf6d996d5UL,
+		 0xae07bce9UL, 0xb71c8da8UL, 0x9c31de6bUL, 0x852aef2aUL, 0xca6b79edUL,
+		 0xd37048acUL, 0xf85d1b6fUL, 0xe1462a2eUL, 0x66de36e1UL, 0x7fc507a0UL,
+		 0x54e85463UL, 0x4df36522UL, 0x02b2f3e5UL, 0x1ba9c2a4UL, 0x30849167UL,
+		 0x299fa026UL, 0xe4c5aeb8UL, 0xfdde9ff9UL, 0xd6f3cc3aUL, 0xcfe8fd7bUL,
+		 0x80a96bbcUL, 0x99b25afdUL, 0xb29f093eUL, 0xab84387fUL, 0x2c1c24b0UL,
+		 0x350715f1UL, 0x1e2a4632UL, 0x07317773UL, 0x4870e1b4UL, 0x516bd0f5UL,
+		 0x7a468336UL, 0x635db277UL, 0xcbfad74eUL, 0xd2e1e60fUL, 0xf9ccb5ccUL,
+		 0xe0d7848dUL, 0xaf96124aUL, 0xb68d230bUL, 0x9da070c8UL, 0x84bb4189UL,
+		 0x03235d46UL, 0x1a386c07UL, 0x31153fc4UL, 0x280e0e85UL, 0x674f9842UL,
+		 0x7e54a903UL, 0x5579fac0UL, 0x4c62cb81UL, 0x8138c51fUL, 0x9823f45eUL,
+		 0xb30ea79dUL, 0xaa1596dcUL, 0xe554001bUL, 0xfc4f315aUL, 0xd7626299UL,
+		 0xce7953d8UL, 0x49e14f17UL, 0x50fa7e56UL, 0x7bd72d95UL, 0x62cc1cd4UL,
+		 0x2d8d8a13UL, 0x3496bb52UL, 0x1fbbe891UL, 0x06a0d9d0UL, 0x5e7ef3ecUL,
+		 0x4765c2adUL, 0x6c48916eUL, 0x7553a02fUL, 0x3a1236e8UL, 0x230907a9UL,
+		 0x0824546aUL, 0x113f652bUL, 0x96a779e4UL, 0x8fbc48a5UL, 0xa4911b66UL,
+		 0xbd8a2a27UL, 0xf2cbbce0UL, 0xebd08da1UL, 0xc0fdde62UL, 0xd9e6ef23UL,
+		 0x14bce1bdUL, 0x0da7d0fcUL, 0x268a833fUL, 0x3f91b27eUL, 0x70d024b9UL,
+		 0x69cb15f8UL, 0x42e6463bUL, 0x5bfd777aUL, 0xdc656bb5UL, 0xc57e5af4UL,
+		 0xee530937UL, 0xf7483876UL, 0xb809aeb1UL, 0xa1129ff0UL, 0x8a3fcc33UL,
+		 0x9324fd72UL},
+		{0x00000000UL, 0x01c26a37UL, 0x0384d46eUL, 0x0246be59UL, 0x0709a8dcUL,
+		 0x06cbc2ebUL, 0x048d7cb2UL, 0x054f1685UL, 0x0e1351b8UL, 0x0fd13b8fUL,
+		 0x0d9785d6UL, 0x0c55efe1UL, 0x091af964UL, 0x08d89353UL, 0x0a9e2d0aUL,
+		 0x0b5c473dUL, 0x1c26a370UL, 0x1de4c947UL, 0x1fa2771eUL, 0x1e601d29UL,
+		 0x1b2f0bacUL, 0x1aed619bUL, 0x18abdfc2UL, 0x1969b5f5UL, 0x1235f2c8UL,
+		 0x13f798ffUL, 0x11b126a6UL, 0x10734c91UL, 0x153c5a14UL, 0x14fe3023UL,
+		 0x16b88e7aUL, 0x177ae44dUL, 0x384d46e0UL, 0x398f2cd7UL, 0x3bc9928eUL,
+		 0x3a0bf8b9UL, 0x3f44ee3cUL, 0x3e86840bUL, 0x3cc03a52UL, 0x3d025065UL,
+		 0x365e1758UL, 0x379c7d6fUL, 0x35dac336UL, 0x3418a901UL, 0x3157bf84UL,
+		 0x3095d5b3UL, 0x32d36beaUL, 0x331101ddUL, 0x246be590UL, 0x25a98fa7UL,
+		 0x27ef31feUL, 0x262d5bc9UL, 0x23624d4cUL, 0x22a0277bUL, 0x20e69922UL,
+		 0x2124f315UL, 0x2a78b428UL, 0x2bbade1fUL, 0x29fc6046UL, 0x283e0a71UL,
+		 0x2d711cf4UL, 0x2cb376c3UL, 0x2ef5c89aUL, 0x2f37a2adUL, 0x709a8dc0UL,
+		 0x7158e7f7UL, 0x731e59aeUL, 0x72dc3399UL, 0x7793251cUL, 0x76514f2bUL,
+		 0x7417f172UL, 0x75d59b45UL, 0x7e89dc78UL, 0x7f4bb64fUL, 0x7d0d0816UL,
+		 0x7ccf6221UL, 0x798074a4UL, 0x78421e93UL, 0x7a04a0caUL, 0x7bc6cafdUL,
+		 0x6cbc2eb0UL, 0x6d7e4487UL, 0x6f38fadeUL, 0x6efa90e9UL, 0x6bb5866cUL,
+		 0x6a77ec5bUL, 0x68315202UL, 0x69f33835UL, 0x62af7f08UL, 0x636d153fUL,
+		 0x612bab66UL, 0x60e9c151UL, 0x65a6d7d4UL, 0x6464bde3UL, 0x662203baUL,
+		 0x67e0698dUL, 0x48d7cb20UL, 0x4915a117UL, 0x4b531f4eUL, 0x4a917579UL,
+		 0x4fde63fcUL, 0x4e1c09cbUL, 0x4c5ab792UL, 0x4d98dda5UL, 0x46c49a98UL,
+		 0x4706f0afUL, 0x45404ef6UL, 0x448224c1UL, 0x41cd3244UL, 0x400f5873UL,
+		 0x4249e62aUL, 0x438b8c1dUL, 0x54f16850UL, 0x55330267UL, 0x5775bc3eUL,
+		 0x56b7d609UL, 0x53f8c08cUL, 0x523aaabbUL, 0x507c14e2UL, 0x51be7ed5UL,
+		 0x5ae239e8UL, 0x5b2053dfUL, 0x5966ed86UL, 0x58a487b1UL, 0x5deb9134UL,
+		 0x5c29fb03UL, 0x5e6f455aUL, 0x5fad2f6dUL, 0xe1351b80UL, 0xe0f771b7UL,
+		 0xe2b1cfeeUL, 0xe373a5d9UL, 0xe63cb35cUL, 0xe7fed96bUL, 0xe5b86732UL,
+		 0xe47a0d05UL, 0xef264a38UL, 0xeee4200fUL, 0xeca29e56UL, 0xed60f461UL,
+		 0xe82fe2e4UL, 0xe9ed88d3UL, 0xebab368aUL, 0xea695cbdUL, 0xfd13b8f0UL,
+		 0xfcd1d2c7UL, 0xfe976c9eUL, 0xff5506a9UL, 0xfa1a102cUL, 0xfbd87a1bUL,
+		 0xf99ec442UL, 0xf85cae75UL, 0xf300e948UL, 0xf2c2837fUL, 0xf0843d26UL,
+		 0xf1465711UL, 0xf4094194UL, 0xf5cb2ba3UL, 0xf78d95faUL, 0xf64fffcdUL,
+		 0xd9785d60UL, 0xd8ba3757UL, 0xdafc890eUL, 0xdb3ee339UL, 0xde71f5bcUL,
+		 0xdfb39f8bUL, 0xddf521d2UL, 0xdc374be5UL, 0xd76b0cd8UL, 0xd6a966efUL,
+		 0xd4efd8b6UL, 0xd52db281UL, 0xd062a404UL, 0xd1a0ce33UL, 0xd3e6706aUL,
+		 0xd2241a5dUL, 0xc55efe10UL, 0xc49c9427UL, 0xc6da2a7eUL, 0xc7184049UL,
+		 0xc25756ccUL, 0xc3953cfbUL, 0xc1d382a2UL, 0xc011e895UL, 0xcb4dafa8UL,
+		 0xca8fc59fUL, 0xc8c97bc6UL, 0xc90b11f1UL, 0xcc440774UL, 0xcd866d43UL,
+		 0xcfc0d31aUL, 0xce02b92dUL, 0x91af9640UL, 0x906dfc77UL, 0x922b422eUL,
+		 0x93e92819UL, 0x96a63e9cUL, 0x976454abUL, 0x9522eaf2UL, 0x94e080c5UL,
+		 0x9fbcc7f8UL, 0x9e7eadcfUL, 0x9c381396UL, 0x9dfa79a1UL, 0x98b56f24UL,
+		 0x99770513UL, 0x9b31bb4aUL, 0x9af3d17dUL, 0x8d893530UL, 0x8c4b5f07UL,
+		 0x8e0de15eUL, 0x8fcf8b69UL, 0x8a809decUL, 0x8b42f7dbUL, 0x89044982UL,
+		 0x88c623b5UL, 0x839a6488UL, 0x82580ebfUL, 0x801eb0e6UL, 0x81dcdad1UL,
+		 0x8493cc54UL, 0x8551a663UL, 0x8717183aUL, 0x86d5720dUL, 0xa9e2d0a0UL,
+		 0xa820ba97UL, 0xaa6604ceUL, 0xaba46ef9UL, 0xaeeb787cUL, 0xaf29124bUL,
+		 0xad6fac12UL, 0xacadc625UL, 0xa7f18118UL, 0xa633eb2fUL, 0xa4755576UL,
+		 0xa5b73f41UL, 0xa0f829c4UL, 0xa13a43f3UL, 0xa37cfdaaUL, 0xa2be979dUL,
+		 0xb5c473d0UL, 0xb40619e7UL, 0xb640a7beUL, 0xb782cd89UL, 0xb2cddb0cUL,
+		 0xb30fb13bUL, 0xb1490f62UL, 0xb08b6555UL, 0xbbd72268UL, 0xba15485fUL,
+		 0xb853f606UL, 0xb9919c31UL, 0xbcde8ab4UL, 0xbd1ce083UL, 0xbf5a5edaUL,
+		 0xbe9834edUL},
+		{0x00000000UL, 0xb8bc6765UL, 0xaa09c88bUL, 0x12b5afeeUL, 0x8f629757UL,
+		 0x37def032UL, 0x256b5fdcUL, 0x9dd738b9UL, 0xc5b428efUL, 0x7d084f8aUL,
+		 0x6fbde064UL, 0xd7018701UL, 0x4ad6bfb8UL, 0xf26ad8ddUL, 0xe0df7733UL,
+		 0x58631056UL, 0x5019579fUL, 0xe8a530faUL, 0xfa109f14UL, 0x42acf871UL,
+		 0xdf7bc0c8UL, 0x67c7a7adUL, 0x75720843UL, 0xcdce6f26UL, 0x95ad7f70UL,
+		 0x2d111815UL, 0x3fa4b7fbUL, 0x8718d09eUL, 0x1acfe827UL, 0xa2738f42UL,
+		 0xb0c620acUL, 0x087a47c9UL, 0xa032af3eUL, 0x188ec85bUL, 0x0a3b67b5UL,
+		 0xb28700d0UL, 0x2f503869UL, 0x97ec5f0cUL, 0x8559f0e2UL, 0x3de59787UL,
+		 0x658687d1UL, 0xdd3ae0b4UL, 0xcf8f4f5aUL, 0x7733283fUL, 0xeae41086UL,
+		 0x525877e3UL, 0x40edd80dUL, 0xf851bf68UL, 0xf02bf8a1UL, 0x48979fc4UL,
+		 0x5a22302aUL, 0xe29e574fUL, 0x7f496ff6UL, 0xc7f50893UL, 0xd540a77dUL,
+		 0x6dfcc018UL, 0x359fd04eUL, 0x8d23b72bUL, 0x9f9618c5UL, 0x272a7fa0UL,
+		 0xbafd4719UL, 0x0241207cUL, 0x10f48f92UL, 0xa848e8f7UL, 0x9b14583dUL,
+		 0x23a83f58UL, 0x311d90b6UL, 0x89a1f7d3UL, 0x1476cf6aUL, 0xaccaa80fUL,
+		 0xbe7f07e1UL, 0x06c36084UL, 0x5ea070d2UL, 0xe61c17b7UL, 0xf4a9b859UL,
+		 0x4c15df3cUL, 0xd1c2e785UL, 0x697e80e0UL, 0x7bcb2f0eUL, 0xc377486bUL,
+		 0xcb0d0fa2UL, 0x73b168c7UL, 0x6104c729UL, 0xd9b8a04cUL, 0x446f98f5UL,
+		 0xfcd3ff90UL, 0xee66507eUL, 0x56da371bUL, 0x0eb9274dUL, 0xb6054028UL,
+		 0xa4b0efc6UL, 0x1c0c88a3UL, 0x81dbb01aUL, 0x3967d77fUL, 0x2bd27891UL,
+		 0x936e1ff4UL, 0x3b26f703UL, 0x839a9066UL, 0x912f3f88UL, 0x299358edUL,
+		 0xb4446054UL, 0x0cf80731UL, 0x1e4da8dfUL, 0xa6f1cfbaUL, 0xfe92dfecUL,
+		 0x462eb889UL, 0x549b1767UL, 0xec277002UL, 0x71f048bbUL, 0xc94c2fdeUL,
+		 0xdbf98030UL, 0x6345e755UL, 0x6b3fa09cUL, 0xd383c7f9UL, 0xc1366817UL,
+		 0x798a0f72UL, 0xe45d37cbUL, 0x5ce150aeUL, 0x4e54ff40UL, 0xf6e89825UL,
+		 0xae8b8873UL, 0x1637ef16UL, 0x048240f8UL, 0xbc3e279dUL, 0x21e91f24UL,
+		 0x99557841UL, 0x8be0d7afUL, 0x335cb0caUL, 0xed59b63bUL, 0x55e5d15eUL,
+		 0x47507eb0UL, 0xffec19d5UL, 0x623b216cUL, 0xda874609UL, 0xc832e9e7UL,
+		 0x708e8e82UL, 0x28ed9ed4UL, 0x9051f9b1UL, 0x82e4565fUL, 0x3a58313aUL,
+		 0xa78f0983UL, 0x1f336ee6UL, 0x0d86c108UL, 0xb53aa66dUL, 0xbd40e1a4UL,
+		 0x05fc86c1UL, 0x1749292fUL, 0xaff54e4aUL, 0x322276f3UL, 0x8a9e1196UL,
+		 0x982bbe78UL, 0x2097d91dUL, 0x78f4c94bUL, 0xc048ae2eUL, 0xd2fd01c0UL,
+		 0x6a4166a5UL, 0xf7965e1cUL, 0x4f2a3979UL, 0x5d9f9697UL, 0xe523f1f2UL,
+		 0x4d6b1905UL, 0xf5d77e60UL, 0xe762d18eUL, 0x5fdeb6ebUL, 0xc2098e52UL,
+		 0x7ab5e937UL, 0x680046d9UL, 0xd0bc21bcUL, 0x88df31eaUL, 0x3063568fUL,
+		 0x22d6f961UL, 0x9a6a9e04UL, 0x07bda6bdUL, 0xbf01c1d8UL, 0xadb46e36UL,
+		 0x15080953UL, 0x1d724e9aUL, 0xa5ce29ffUL, 0xb77b8611UL, 0x0fc7e174UL,
+		 0x9210d9cdUL, 0x2aacbea8UL, 0x38191146UL, 0x80a57623UL, 0xd8c66675UL,
+		 0x607a0110UL, 0x72cfaefeUL, 0xca73c99bUL, 0x57a4f122UL, 0xef189647UL,
+		 0xfdad39a9UL, 0x45115eccUL, 0x764dee06UL, 0xcef18963UL, 0xdc44268dUL,
+		 0x64f841e8UL, 0xf92f7951UL, 0x41931e34UL, 0x5326b1daUL, 0xeb9ad6bfUL,
+		 0xb3f9c6e9UL, 0x0b45a18cUL, 0x19f00e62UL, 0xa14c6907UL, 0x3c9b51beUL,
+		 0x842736dbUL, 0x96929935UL, 0x2e2efe50UL, 0x2654b999UL, 0x9ee8defcUL,
+		 0x8c5d7112UL, 0x34e11677UL, 0xa9362eceUL, 0x118a49abUL, 0x033fe645UL,
+		 0xbb838120UL, 0xe3e09176UL, 0x5b5cf613UL, 0x49e959fdUL, 0xf1553e98UL,
+		 0x6c820621UL, 0xd43e6144UL, 0xc68bceaaUL, 0x7e37a9cfUL, 0xd67f4138UL,
+		 0x6ec3265dUL, 0x7c7689b3UL, 0xc4caeed6UL, 0x591dd66fUL, 0xe1a1b10aUL,
+		 0xf3141ee4UL, 0x4ba87981UL, 0x13cb69d7UL, 0xab770eb2UL, 0xb9c2a15cUL,
+		 0x017ec639UL, 0x9ca9fe80UL, 0x241599e5UL, 0x36a0360bUL, 0x8e1c516eUL,
+		 0x866616a7UL, 0x3eda71c2UL, 0x2c6fde2cUL, 0x94d3b949UL, 0x090481f0UL,
+		 0xb1b8e695UL, 0xa30d497bUL, 0x1bb12e1eUL, 0x43d23e48UL, 0xfb6e592dUL,
+		 0xe9dbf6c3UL, 0x516791a6UL, 0xccb0a91fUL, 0x740cce7aUL, 0x66b96194UL,
+		 0xde0506f1UL},
+		{0x00000000UL, 0x96300777UL, 0x2c610eeeUL, 0xba510999UL, 0x19c46d07UL,
+		 0x8ff46a70UL, 0x35a563e9UL, 0xa395649eUL, 0x3288db0eUL, 0xa4b8dc79UL,
+		 0x1ee9d5e0UL, 0x88d9d297UL, 0x2b4cb609UL, 0xbd7cb17eUL, 0x072db8e7UL,
+		 0x911dbf90UL, 0x6410b71dUL, 0xf220b06aUL, 0x4871b9f3UL, 0xde41be84UL,
+		 0x7dd4da1aUL, 0xebe4dd6dUL, 0x51b5d4f4UL, 0xc785d383UL, 0x56986c13UL,
+		 0xc0a86b64UL, 0x7af962fdUL, 0xecc9658aUL, 0x4f5c0114UL, 0xd96c0663UL,
+		 0x633d0ffaUL, 0xf50d088dUL, 0xc8206e3bUL, 0x5e10694cUL, 0xe44160d5UL,
+		 0x727167a2UL, 0xd1e4033cUL, 0x47d4044bUL, 0xfd850dd2UL, 0x6bb50aa5UL,
+		 0xfaa8b535UL, 0x6c98b242UL, 0xd6c9bbdbUL, 0x40f9bcacUL, 0xe36cd832UL,
+		 0x755cdf45UL, 0xcf0dd6dcUL, 0x593dd1abUL, 0xac30d926UL, 0x3a00de51UL,
+		 0x8051d7c8UL, 0x1661d0bfUL, 0xb5f4b421UL, 0x23c4b356UL, 0x9995bacfUL,
+		 0x0fa5bdb8UL, 0x9eb80228UL, 0x0888055fUL, 0xb2d90cc6UL, 0x24e90bb1UL,
+		 0x877c6f2fUL, 0x114c6858UL, 0xab1d61c1UL, 0x3d2d66b6UL, 0x9041dc76UL,
+		 0x0671db01UL, 0xbc20d298UL, 0x2a10d5efUL, 0x8985b171UL, 0x1fb5b606UL,
+		 0xa5e4bf9fUL, 0x33d4b8e8UL, 0xa2c90778UL, 0x34f9000fUL, 0x8ea80996UL,
+		 0x18980ee1UL, 0xbb0d6a7fUL, 0x2d3d6d08UL, 0x976c6491UL, 0x015c63e6UL,
+		 0xf4516b6bUL, 0x62616c1cUL, 0xd8306585UL, 0x4e0062f2UL, 0xed95066cUL,
+		 0x7ba5011bUL, 0xc1f40882UL, 0x57c40ff5UL, 0xc6d9b065UL, 0x50e9b712UL,
+		 0xeab8be8bUL, 0x7c88b9fcUL, 0xdf1ddd62UL, 0x492dda15UL, 0xf37cd38cUL,
+		 0x654cd4fbUL, 0x5861b24dUL, 0xce51b53aUL, 0x7400bca3UL, 0xe230bbd4UL,
+		 0x41a5df4aUL, 0xd795d83dUL, 0x6dc4d1a4UL, 0xfbf4d6d3UL, 0x6ae96943UL,
+		 0xfcd96e34UL, 0x468867adUL, 0xd0b860daUL, 0x732d0444UL, 0xe51d0333UL,
+		 0x5f4c0aaaUL, 0xc97c0dddUL, 0x3c710550UL, 0xaa410227UL, 0x10100bbeUL,
+		 0x86200cc9UL, 0x25b56857UL, 0xb3856f20UL, 0x09d466b9UL, 0x9fe461ceUL,
+		 0x0ef9de5eUL, 0x98c9d929UL, 0x2298d0b0UL, 0xb4a8d7c7UL, 0x173db359UL,
+		 0x810db42eUL, 0x3b5cbdb7UL, 0xad6cbac0UL, 0x2083b8edUL, 0xb6b3bf9aUL,
+		 0x0ce2b603UL, 0x9ad2b174UL, 0x3947d5eaUL, 0xaf77d29dUL, 0x1526db04UL,
+		 0x8316dc73UL, 0x120b63e3UL, 0x843b6494UL, 0x3e6a6d0dUL, 0xa85a6a7aUL,
+		 0x0bcf0ee4UL, 0x9dff0993UL, 0x27ae000aUL, 0xb19e077dUL, 0x44930ff0UL,
+		 0xd2a30887UL, 0x68f2011eUL, 0xfec20669UL, 0x5d5762f7UL, 0xcb676580UL,
+		 0x71366c19UL, 0xe7066b6eUL, 0x761bd4feUL, 0xe02bd389UL, 0x5a7ada10UL,
+		 0xcc4add67UL, 0x6fdfb9f9UL, 0xf9efbe8eUL, 0x43beb717UL, 0xd58eb060UL,
+		 0xe8a3d6d6UL, 0x7e93d1a1UL, 0xc4c2d838UL, 0x52f2df4fUL, 0xf167bbd1UL,
+		 0x6757bca6UL, 0xdd06b53fUL, 0x4b36b248UL, 0xda2b0dd8UL, 0x4c1b0aafUL,
+		 0xf64a0336UL, 0x607a0441UL, 0xc3ef60dfUL, 0x55df67a8UL, 0xef8e6e31UL,
+		 0x79be6946UL, 0x8cb361cbUL, 0x1a8366bcUL, 0xa0d26f25UL, 0x36e26852UL,
+		 0x95770cccUL, 0x03470bbbUL, 0xb9160222UL, 0x2f260555UL, 0xbe3bbac5UL,
+		 0x280bbdb2UL, 0x925ab42bUL, 0x046ab35cUL, 0xa7ffd7c2UL, 0x31cfd0b5UL,
+		 0x8b9ed92cUL, 0x1daede5bUL, 0xb0c2649bUL, 0x26f263ecUL, 0x9ca36a75UL,
+		 0x0a936d02UL, 0xa906099cUL, 0x3f360eebUL, 0x85670772UL, 0x13570005UL,
+		 0x824abf95UL, 0x147ab8e2UL, 0xae2bb17bUL, 0x381bb60cUL, 0x9b8ed292UL,
+		 0x0dbed5e5UL, 0xb7efdc7cUL, 0x21dfdb0bUL, 0xd4d2d386UL, 0x42e2d4f1UL,
+		 0xf8b3dd68UL, 0x6e83da1fUL, 0xcd16be81UL, 0x5b26b9f6UL, 0xe177b06fUL,
+		 0x7747b718UL, 0xe65a0888UL, 0x706a0fffUL, 0xca3b0666UL, 0x5c0b0111UL,
+		 0xff9e658fUL, 0x69ae62f8UL, 0xd3ff6b61UL, 0x45cf6c16UL, 0x78e20aa0UL,
+		 0xeed20dd7UL, 0x5483044eUL, 0xc2b30339UL, 0x612667a7UL, 0xf71660d0UL,
+		 0x4d476949UL, 0xdb776e3eUL, 0x4a6ad1aeUL, 0xdc5ad6d9UL, 0x660bdf40UL,
+		 0xf03bd837UL, 0x53aebca9UL, 0xc59ebbdeUL, 0x7fcfb247UL, 0xe9ffb530UL,
+		 0x1cf2bdbdUL, 0x8ac2bacaUL, 0x3093b353UL, 0xa6a3b424UL, 0x0536d0baUL,
+		 0x9306d7cdUL, 0x2957de54UL, 0xbf67d923UL, 0x2e7a66b3UL, 0xb84a61c4UL,
+		 0x021b685dUL, 0x942b6f2aUL, 0x37be0bb4UL, 0xa18e0cc3UL, 0x1bdf055aUL,
+		 0x8def022dUL},
+		{0x00000000UL, 0x41311b19UL, 0x82623632UL, 0xc3532d2bUL, 0x04c56c64UL,
+		 0x45f4777dUL, 0x86a75a56UL, 0xc796414fUL, 0x088ad9c8UL, 0x49bbc2d1UL,
+		 0x8ae8effaUL, 0xcbd9f4e3UL, 0x0c4fb5acUL, 0x4d7eaeb5UL, 0x8e2d839eUL,
+		 0xcf1c9887UL, 0x5112c24aUL, 0x1023d953UL, 0xd370f478UL, 0x9241ef61UL,
+		 0x55d7ae2eUL, 0x14e6b537UL, 0xd7b5981cUL, 0x96848305UL, 0x59981b82UL,
+		 0x18a9009bUL, 0xdbfa2db0UL, 0x9acb36a9UL, 0x5d5d77e6UL, 0x1c6c6cffUL,
+		 0xdf3f41d4UL, 0x9e0e5acdUL, 0xa2248495UL, 0xe3159f8cUL, 0x2046b2a7UL,
+		 0x6177a9beUL, 0xa6e1e8f1UL, 0xe7d0f3e8UL, 0x2483dec3UL, 0x65b2c5daUL,
+		 0xaaae5d5dUL, 0xeb9f4644UL, 0x28cc6b6fUL, 0x69fd7076UL, 0xae6b3139UL,
+		 0xef5a2a20UL, 0x2c09070bUL, 0x6d381c12UL, 0xf33646dfUL, 0xb2075dc6UL,
+		 0x715470edUL, 0x30656bf4UL, 0xf7f32abbUL, 0xb6c231a2UL, 0x75911c89UL,
+		 0x34a00790UL, 0xfbbc9f17UL, 0xba8d840eUL, 0x79dea925UL, 0x38efb23cUL,
+		 0xff79f373UL, 0xbe48e86aUL, 0x7d1bc541UL, 0x3c2ade58UL, 0x054f79f0UL,
+		 0x447e62e9UL, 0x872d4fc2UL, 0xc61c54dbUL, 0x018a1594UL, 0x40bb0e8dUL,
+		 0x83e823a6UL, 0xc2d938bfUL, 0x0dc5a038UL, 0x4cf4bb21UL, 0x8fa7960aUL,
+		 0xce968d13UL, 0x0900cc5cUL, 0x4831d745UL, 0x8b62fa6eUL, 0xca53e177UL,
+		 0x545dbbbaUL, 0x156ca0a3UL, 0xd63f8d88UL, 0x970e9691UL, 0x5098d7deUL,
+		 0x11a9ccc7UL, 0xd2fae1ecUL, 0x93cbfaf5UL, 0x5cd76272UL, 0x1de6796bUL,
+		 0xdeb55440UL, 0x9f844f59UL, 0x58120e16UL, 0x1923150fUL, 0xda703824UL,
+		 0x9b41233dUL, 0xa76bfd65UL, 0xe65ae67cUL, 0x2509cb57UL, 0x6438d04eUL,
+		 0xa3ae9101UL, 0xe29f8a18UL, 0x21cca733UL, 0x60fdbc2aUL, 0xafe124adUL,
+		 0xeed03fb4UL, 0x2d83129fUL, 0x6cb20986UL, 0xab2448c9UL, 0xea1553d0UL,
+		 0x29467efbUL, 0x687765e2UL, 0xf6793f2fUL, 0xb7482436UL, 0x741b091dUL,
+		 0x352a1204UL, 0xf2bc534bUL, 0xb38d4852UL, 0x70de6579UL, 0x31ef7e60UL,
+		 0xfef3e6e7UL, 0xbfc2fdfeUL, 0x7c91d0d5UL, 0x3da0cbccUL, 0xfa368a83UL,
+		 0xbb07919aUL, 0x7854bcb1UL, 0x3965a7a8UL, 0x4b98833bUL, 0x0aa99822UL,
+		 0xc9fab509UL, 0x88cbae10UL, 0x4f5def5fUL, 0x0e6cf446UL, 0xcd3fd96dUL,
+		 0x8c0ec274UL, 0x43125af3UL, 0x022341eaUL, 0xc1706cc1UL, 0x804177d8UL,
+		 0x47d73697UL, 0x06e62d8eUL, 0xc5b500a5UL, 0x84841bbcUL, 0x1a8a4171UL,
+		 0x5bbb5a68UL, 0x98e87743UL, 0xd9d96c5aUL, 0x1e4f2d15UL, 0x5f7e360cUL,
+		 0x9c2d1b27UL, 0xdd1c003eUL, 0x120098b9UL, 0x533183a0UL, 0x9062ae8bUL,
+		 0xd153b592UL, 0x16c5f4ddUL, 0x57f4efc4UL, 0x94a7c2efUL, 0xd596d9f6UL,
+		 0xe9bc07aeUL, 0xa88d1cb7UL, 0x6bde319cUL, 0x2aef2a85UL, 0xed796bcaUL,
+		 0xac4870d3UL, 0x6f1b5df8UL, 0x2e2a46e1UL, 0xe136de66UL, 0xa007c57fUL,
+		 0x6354e854UL, 0x2265f34dUL, 0xe5f3b202UL, 0xa4c2a91bUL, 0x67918430UL,
+		 0x26a09f29UL, 0xb8aec5e4UL, 0xf99fdefdUL, 0x3accf3d6UL, 0x7bfde8cfUL,
+		 0xbc6ba980UL, 0xfd5ab299UL, 0x3e099fb2UL, 0x7f3884abUL, 0xb0241c2cUL,
+		 0xf1150735UL, 0x32462a1eUL, 0x73773107UL, 0xb4e17048UL, 0xf5d06b51UL,
+		 0x3683467aUL, 0x77b25d63UL, 0x4ed7facbUL, 0x0fe6e1d2UL, 0xccb5ccf9UL,
+		 0x8d84d7e0UL, 0x4a1296afUL, 0x0b238db6UL, 0xc870a09dUL, 0x8941bb84UL,
+		 0x465d2303UL, 0x076c381aUL, 0xc43f1531UL, 0x850e0e28UL, 0x42984f67UL,
+		 0x03a9547eUL, 0xc0fa7955UL, 0x81cb624cUL, 0x1fc53881UL, 0x5ef42398UL,
+		 0x9da70eb3UL, 0xdc9615aaUL, 0x1b0054e5UL, 0x5a314ffcUL, 0x996262d7UL,
+		 0xd85379ceUL, 0x174fe149UL, 0x567efa50UL, 0x952dd77bUL, 0xd41ccc62UL,
+		 0x138a8d2dUL, 0x52bb9634UL, 0x91e8bb1fUL, 0xd0d9a006UL, 0xecf37e5eUL,
+		 0xadc26547UL, 0x6e91486cUL, 0x2fa05375UL, 0xe836123aUL, 0xa9070923UL,
+		 0x6a542408UL, 0x2b653f11UL, 0xe479a796UL, 0xa548bc8fUL, 0x661b91a4UL,
+		 0x272a8abdUL, 0xe0bccbf2UL, 0xa18dd0ebUL, 0x62defdc0UL, 0x23efe6d9UL,
+		 0xbde1bc14UL, 0xfcd0a70dUL, 0x3f838a26UL, 0x7eb2913fUL, 0xb924d070UL,
+		 0xf815cb69UL, 0x3b46e642UL, 0x7a77fd5bUL, 0xb56b65dcUL, 0xf45a7ec5UL,
+		 0x370953eeUL, 0x763848f7UL, 0xb1ae09b8UL, 0xf09f12a1UL, 0x33cc3f8aUL,
+		 0x72fd2493UL},
+		{0x00000000UL, 0x376ac201UL, 0x6ed48403UL, 0x59be4602UL, 0xdca80907UL,
+		 0xebc2cb06UL, 0xb27c8d04UL, 0x85164f05UL, 0xb851130eUL, 0x8f3bd10fUL,
+		 0xd685970dUL, 0xe1ef550cUL, 0x64f91a09UL, 0x5393d808UL, 0x0a2d9e0aUL,
+		 0x3d475c0bUL, 0x70a3261cUL, 0x47c9e41dUL, 0x1e77a21fUL, 0x291d601eUL,
+		 0xac0b2f1bUL, 0x9b61ed1aUL, 0xc2dfab18UL, 0xf5b56919UL, 0xc8f23512UL,
+		 0xff98f713UL, 0xa626b111UL, 0x914c7310UL, 0x145a3c15UL, 0x2330fe14UL,
+		 0x7a8eb816UL, 0x4de47a17UL, 0xe0464d38UL, 0xd72c8f39UL, 0x8e92c93bUL,
+		 0xb9f80b3aUL, 0x3cee443fUL, 0x0b84863eUL, 0x523ac03cUL, 0x6550023dUL,
+		 0x58175e36UL, 0x6f7d9c37UL, 0x36c3da35UL, 0x01a91834UL, 0x84bf5731UL,
+		 0xb3d59530UL, 0xea6bd332UL, 0xdd011133UL, 0x90e56b24UL, 0xa78fa925UL,
+		 0xfe31ef27UL, 0xc95b2d26UL, 0x4c4d6223UL, 0x7b27a022UL, 0x2299e620UL,
+		 0x15f32421UL, 0x28b4782aUL, 0x1fdeba2bUL, 0x4660fc29UL, 0x710a3e28UL,
+		 0xf41c712dUL, 0xc376b32cUL, 0x9ac8f52eUL, 0xada2372fUL, 0xc08d9a70UL,
+		 0xf7e75871UL, 0xae591e73UL, 0x9933dc72UL, 0x1c259377UL, 0x2b4f5176UL,
+		 0x72f11774UL, 0x459bd575UL, 0x78dc897eUL, 0x4fb64b7fUL, 0x16080d7dUL,
+		 0x2162cf7cUL, 0xa4748079UL, 0x931e4278UL, 0xcaa0047aUL, 0xfdcac67bUL,
+		 0xb02ebc6cUL, 0x87447e6dUL, 0xdefa386fUL, 0xe990fa6eUL, 0x6c86b56bUL,
+		 0x5bec776aUL, 0x02523168UL, 0x3538f369UL, 0x087faf62UL, 0x3f156d63UL,
+		 0x66ab2b61UL, 0x51c1e960UL, 0xd4d7a665UL, 0xe3bd6464UL, 0xba032266UL,
+		 0x8d69e067UL, 0x20cbd748UL, 0x17a11549UL, 0x4e1f534bUL, 0x7975914aUL,
+		 0xfc63de4fUL, 0xcb091c4eUL, 0x92b75a4cUL, 0xa5dd984dUL, 0x989ac446UL,
+		 0xaff00647UL, 0xf64e4045UL, 0xc1248244UL, 0x4432cd41UL, 0x73580f40UL,
+		 0x2ae64942UL, 0x1d8c8b43UL, 0x5068f154UL, 0x67023355UL, 0x3ebc7557UL,
+		 0x09d6b756UL, 0x8cc0f853UL, 0xbbaa3a52UL, 0xe2147c50UL, 0xd57ebe51UL,
+		 0xe839e25aUL, 0xdf53205bUL, 0x86ed6659UL, 0xb187a458UL, 0x3491eb5dUL,
+		 0x03fb295cUL, 0x5a456f5eUL, 0x6d2fad5fUL, 0x801b35e1UL, 0xb771f7e0UL,
+		 0xeecfb1e2UL, 0xd9a573e3UL, 0x5cb33ce6UL, 0x6bd9fee7UL, 0x3267b8e5UL,
+		 0x050d7ae4UL, 0x384a26efUL, 0x0f20e4eeUL, 0x569ea2ecUL, 0x61f460edUL,
+		 0xe4e22fe8UL, 0xd388ede9UL, 0x8a36abebUL, 0xbd5c69eaUL, 0xf0b813fdUL,
+		 0xc7d2d1fcUL, 0x9e6c97feUL, 0xa90655ffUL, 0x2c101afaUL, 0x1b7ad8fbUL,
+		 0x42c49ef9UL, 0x75ae5cf8UL, 0x48e900f3UL, 0x7f83c2f2UL, 0x263d84f0UL,
+		 0x115746f1UL, 0x944109f4UL, 0xa32bcbf5UL, 0xfa958df7UL, 0xcdff4ff6UL,
+		 0x605d78d9UL, 0x5737bad8UL, 0x0e89fcdaUL, 0x39e33edbUL, 0xbcf571deUL,
+		 0x8b9fb3dfUL, 0xd221f5ddUL, 0xe54b37dcUL, 0xd80c6bd7UL, 0xef66a9d6UL,
+		 0xb6d8efd4UL, 0x81b22dd5UL, 0x04a462d0UL, 0x33cea0d1UL, 0x6a70e6d3UL,
+		 0x5d1a24d2UL, 0x10fe5ec5UL, 0x27949cc4UL, 0x7e2adac6UL, 0x494018c7UL,
+		 0xcc5657c2UL, 0xfb3c95c3UL, 0xa282d3c1UL, 0x95e811c0UL, 0xa8af4dcbUL,
+		 0x9fc58fcaUL, 0xc67bc9c8UL, 0xf1110bc9UL, 0x740744ccUL, 0x436d86cdUL,
+		 0x1ad3c0cfUL, 0x2db902ceUL, 0x4096af91UL, 0x77fc6d90UL, 0x2e422b92UL,
+		 0x1928e993UL, 0x9c3ea696UL, 0xab546497UL, 0xf2ea2295UL, 0xc580e094UL,
+		 0xf8c7bc9fUL, 0xcfad7e9eUL, 0x9613389cUL, 0xa179fa9dUL, 0x246fb598UL,
+		 0x13057799UL, 0x4abb319bUL, 0x7dd1f39aUL, 0x3035898dUL, 0x075f4b8cUL,
+		 0x5ee10d8eUL, 0x698bcf8fUL, 0xec9d808aUL, 0xdbf7428bUL, 0x82490489UL,
+		 0xb523c688UL, 0x88649a83UL, 0xbf0e5882UL, 0xe6b01e80UL, 0xd1dadc81UL,
+		 0x54cc9384UL, 0x63a65185UL, 0x3a181787UL, 0x0d72d586UL, 0xa0d0e2a9UL,
+		 0x97ba20a8UL, 0xce0466aaUL, 0xf96ea4abUL, 0x7c78ebaeUL, 0x4b1229afUL,
+		 0x12ac6fadUL, 0x25c6adacUL, 0x1881f1a7UL, 0x2feb33a6UL, 0x765575a4UL,
+		 0x413fb7a5UL, 0xc429f8a0UL, 0xf3433aa1UL, 0xaafd7ca3UL, 0x9d97bea2UL,
+		 0xd073c4b5UL, 0xe71906b4UL, 0xbea740b6UL, 0x89cd82b7UL, 0x0cdbcdb2UL,
+		 0x3bb10fb3UL, 0x620f49b1UL, 0x55658bb0UL, 0x6822d7bbUL, 0x5f4815baUL,
+		 0x06f653b8UL, 0x319c91b9UL, 0xb48adebcUL, 0x83e01cbdUL, 0xda5e5abfUL,
+		 0xed3498beUL},
+		{0x00000000UL, 0x6567bcb8UL, 0x8bc809aaUL, 0xeeafb512UL, 0x5797628fUL,
+		 0x32f0de37UL, 0xdc5f6b25UL, 0xb938d79dUL, 0xef28b4c5UL, 0x8a4f087dUL,
+		 0x64e0bd6fUL, 0x018701d7UL, 0xb8bfd64aUL, 0xddd86af2UL, 0x3377dfe0UL,
+		 0x56106358UL, 0x9f571950UL, 0xfa30a5e8UL, 0x149f10faUL, 0x71f8ac42UL,
+		 0xc8c07bdfUL, 0xada7c767UL, 0x43087275UL, 0x266fcecdUL, 0x707fad95UL,
+		 0x1518112dUL, 0xfbb7a43fUL, 0x9ed01887UL, 0x27e8cf1aUL, 0x428f73a2UL,
+		 0xac20c6b0UL, 0xc9477a08UL, 0x3eaf32a0UL, 0x5bc88e18UL, 0xb5673b0aUL,
+		 0xd00087b2UL, 0x6938502fUL, 0x0c5fec97UL, 0xe2f05985UL, 0x8797e53dUL,
+		 0xd1878665UL, 0xb4e03addUL, 0x5a4f8fcfUL, 0x3f283377UL, 0x8610e4eaUL,
+		 0xe3775852UL, 0x0dd8ed40UL, 0x68bf51f8UL, 0xa1f82bf0UL, 0xc49f9748UL,
+		 0x2a30225aUL, 0x4f579ee2UL, 0xf66f497fUL, 0x9308f5c7UL, 0x7da740d5UL,
+		 0x18c0fc6dUL, 0x4ed09f35UL, 0x2bb7238dUL, 0xc518969fUL, 0xa07f2a27UL,
+		 0x1947fdbaUL, 0x7c204102UL, 0x928ff410UL, 0xf7e848a8UL, 0x3d58149bUL,
+		 0x583fa823UL, 0xb6901d31UL, 0xd3f7a189UL, 0x6acf7614UL, 0x0fa8caacUL,
+		 0xe1077fbeUL, 0x8460c306UL, 0xd270a05eUL, 0xb7171ce6UL, 0x59b8a9f4UL,
+		 0x3cdf154cUL, 0x85e7c2d1UL, 0xe0807e69UL, 0x0e2fcb7bUL, 0x6b4877c3UL,
+		 0xa20f0dcbUL, 0xc768b173UL, 0x29c70461UL, 0x4ca0b8d9UL, 0xf5986f44UL,
+		 0x90ffd3fcUL, 0x7e5066eeUL, 0x1b37da56UL, 0x4d27b90eUL, 0x284005b6UL,
+		 0xc6efb0a4UL, 0xa3880c1cUL, 0x1ab0db81UL, 0x7fd76739UL, 0x9178d22bUL,
+		 0xf41f6e93UL, 0x03f7263bUL, 0x66909a83UL, 0x883f2f91UL, 0xed589329UL,
+		 0x546044b4UL, 0x3107f80cUL, 0xdfa84d1eUL, 0xbacff1a6UL, 0xecdf92feUL,
+		 0x89b82e46UL, 0x67179b54UL, 0x027027ecUL, 0xbb48f071UL, 0xde2f4cc9UL,
+		 0x3080f9dbUL, 0x55e74563UL, 0x9ca03f6bUL, 0xf9c783d3UL, 0x176836c1UL,
+		 0x720f8a79UL, 0xcb375de4UL, 0xae50e15cUL, 0x40ff544eUL, 0x2598e8f6UL,
+		 0x73888baeUL, 0x16ef3716UL, 0xf8408204UL, 0x9d273ebcUL, 0x241fe921UL,
+		 0x41785599UL, 0xafd7e08bUL, 0xcab05c33UL, 0x3bb659edUL, 0x5ed1e555UL,
+		 0xb07e5047UL, 0xd519ecffUL, 0x6c213b62UL, 0x094687daUL, 0xe7e932c8UL,
+		 0x828e8e70UL, 0xd49eed28UL, 0xb1f95190UL, 0x5f56e482UL, 0x3a31583aUL,
+		 0x83098fa7UL, 0xe66e331fUL, 0x08c1860dUL, 0x6da63ab5UL, 0xa4e140bdUL,
+		 0xc186fc05UL, 0x2f294917UL, 0x4a4ef5afUL, 0xf3762232UL, 0x96119e8aUL,
+		 0x78be2b98UL, 0x1dd99720UL, 0x4bc9f478UL, 0x2eae48c0UL, 0xc001fdd2UL,
+		 0xa566416aUL, 0x1c5e96f7UL, 0x79392a4fUL, 0x97969f5dUL, 0xf2f123e5UL,
+		 0x05196b4dUL, 0x607ed7f5UL, 0x8ed162e7UL, 0xebb6de5fUL, 0x528e09c2UL,
+		 0x37e9b57aUL, 0xd9460068UL, 0xbc21bcd0UL, 0xea31df88UL, 0x8f566330UL,
+		 0x61f9d622UL, 0x049e6a9aUL, 0xbda6bd07UL, 0xd8c101bfUL, 0x366eb4adUL,
+		 0x53090815UL, 0x9a4e721dUL, 0xff29cea5UL, 0x11867bb7UL, 0x74e1c70fUL,
+		 0xcdd91092UL, 0xa8beac2aUL, 0x46111938UL, 0x2376a580UL, 0x7566c6d8UL,
+		 0x10017a60UL, 0xfeaecf72UL, 0x9bc973caUL, 0x22f1a457UL, 0x479618efUL,
+		 0xa939adfdUL, 0xcc5e1145UL, 0x06ee4d76UL, 0x6389f1ceUL, 0x8d2644dcUL,
+		 0xe841f864UL, 0x51792ff9UL, 0x341e9341UL, 0xdab12653UL, 0xbfd69aebUL,
+		 0xe9c6f9b3UL, 0x8ca1450bUL, 0x620ef019UL, 0x07694ca1UL, 0xbe519b3cUL,
+		 0xdb362784UL, 0x35999296UL, 0x50fe2e2eUL, 0x99b95426UL, 0xfcdee89eUL,
+		 0x12715d8cUL, 0x7716e134UL, 0xce2e36a9UL, 0xab498a11UL, 0x45e63f03UL,
+		 0x208183bbUL, 0x7691e0e3UL, 0x13f65c5bUL, 0xfd59e949UL, 0x983e55f1UL,
+		 0x2106826cUL, 0x44613ed4UL, 0xaace8bc6UL, 0xcfa9377eUL, 0x38417fd6UL,
+		 0x5d26c36eUL, 0xb389767cUL, 0xd6eecac4UL, 0x6fd61d59UL, 0x0ab1a1e1UL,
+		 0xe41e14f3UL, 0x8179a84bUL, 0xd769cb13UL, 0xb20e77abUL, 0x5ca1c2b9UL,
+		 0x39c67e01UL, 0x80fea99cUL, 0xe5991524UL, 0x0b36a036UL, 0x6e511c8eUL,
+		 0xa7166686UL, 0xc271da3eUL, 0x2cde6f2cUL, 0x49b9d394UL, 0xf0810409UL,
+		 0x95e6b8b1UL, 0x7b490da3UL, 0x1e2eb11bUL, 0x483ed243UL, 0x2d596efbUL,
+		 0xc3f6dbe9UL, 0xa6916751UL, 0x1fa9b0ccUL, 0x7ace0c74UL, 0x9461b966UL,
+		 0xf10605deUL
+#endif
+		}};
diff --git a/engine/inc/bullet/ThirdPartyLibs/zlib/deflate.h b/engine/inc/bullet/ThirdPartyLibs/zlib/deflate.h
new file mode 100644
index 00000000..eb3ff791
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/zlib/deflate.h
@@ -0,0 +1,352 @@
+/* deflate.h -- internal compression state
+ * Copyright (C) 1995-2012 Jean-loup Gailly
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* @(#) $Id$ */
+
+#ifndef DEFLATE_H
+#define DEFLATE_H
+
+#include "zutil.h"
+
+/* define NO_GZIP when compiling if you want to disable gzip header and
+   trailer creation by deflate().  NO_GZIP would be used to avoid linking in
+   the crc code when it is not needed.  For shared libraries, gzip encoding
+   should be left enabled. */
+#ifndef NO_GZIP
+#define GZIP
+#endif
+
+/* ===========================================================================
+ * Internal compression state.
+ */
+
+#define LENGTH_CODES 29
+/* number of length codes, not counting the special END_BLOCK code */
+
+#define LITERALS 256
+/* number of literal bytes 0..255 */
+
+#define L_CODES (LITERALS + 1 + LENGTH_CODES)
+/* number of Literal or Length codes, including the END_BLOCK code */
+
+#define D_CODES 30
+/* number of distance codes */
+
+#define BL_CODES 19
+/* number of codes used to transfer the bit lengths */
+
+#define HEAP_SIZE (2 * L_CODES + 1)
+/* maximum heap size */
+
+#define MAX_BITS 15
+/* All codes must not exceed MAX_BITS bits */
+
+#define Buf_size 16
+/* size of bit buffer in bi_buf */
+
+#define INIT_STATE 42
+#define EXTRA_STATE 69
+#define NAME_STATE 73
+#define COMMENT_STATE 91
+#define HCRC_STATE 103
+#define BUSY_STATE 113
+#define FINISH_STATE 666
+/* Stream status */
+
+/* Data structure describing a single value and its code string. */
+typedef struct ct_data_s
+{
+	union {
+		ush freq; /* frequency count */
+		ush code; /* bit string */
+	} fc;
+	union {
+		ush dad; /* father node in Huffman tree */
+		ush len; /* length of bit string */
+	} dl;
+} FAR ct_data;
+
+#define Freq fc.freq
+#define Code fc.code
+#define Dad dl.dad
+#define Len dl.len
+
+typedef struct static_tree_desc_s static_tree_desc;
+
+typedef struct tree_desc_s
+{
+	ct_data *dyn_tree;           /* the dynamic tree */
+	int max_code;                /* largest code with non zero frequency */
+	static_tree_desc *stat_desc; /* the corresponding static tree */
+} FAR tree_desc;
+
+typedef ush Pos;
+typedef Pos FAR Posf;
+typedef unsigned IPos;
+
+/* A Pos is an index in the character window. We use short instead of int to
+ * save space in the various tables. IPos is used only for parameter passing.
+ */
+
+typedef struct internal_state
+{
+	z_streamp strm;       /* pointer back to this zlib stream */
+	int status;           /* as the name implies */
+	Bytef *pending_buf;   /* output still pending */
+	ulg pending_buf_size; /* size of pending_buf */
+	Bytef *pending_out;   /* next pending byte to output to the stream */
+	uInt pending;         /* nb of bytes in the pending buffer */
+	int wrap;             /* bit 0 true for zlib, bit 1 true for gzip */
+	gz_headerp gzhead;    /* gzip header information to write */
+	uInt gzindex;         /* where in extra, name, or comment */
+	Byte method;          /* can only be DEFLATED */
+	int last_flush;       /* value of flush param for previous deflate call */
+
+	/* used by deflate.c: */
+
+	uInt w_size; /* LZ77 window size (32K by default) */
+	uInt w_bits; /* log2(w_size)  (8..16) */
+	uInt w_mask; /* w_size - 1 */
+
+	Bytef *window;
+	/* Sliding window. Input bytes are read into the second half of the window,
+     * and move to the first half later to keep a dictionary of at least wSize
+     * bytes. With this organization, matches are limited to a distance of
+     * wSize-MAX_MATCH bytes, but this ensures that IO is always
+     * performed with a length multiple of the block size. Also, it limits
+     * the window size to 64K, which is quite useful on MSDOS.
+     * To do: use the user input buffer as sliding window.
+     */
+
+	ulg window_size;
+	/* Actual size of window: 2*wSize, except when the user input buffer
+     * is directly used as sliding window.
+     */
+
+	Posf *prev;
+	/* Link to older string with same hash index. To limit the size of this
+     * array to 64K, this link is maintained only for the last 32K strings.
+     * An index in this array is thus a window index modulo 32K.
+     */
+
+	Posf *head; /* Heads of the hash chains or NIL. */
+
+	uInt ins_h;     /* hash index of string to be inserted */
+	uInt hash_size; /* number of elements in hash table */
+	uInt hash_bits; /* log2(hash_size) */
+	uInt hash_mask; /* hash_size-1 */
+
+	uInt hash_shift;
+	/* Number of bits by which ins_h must be shifted at each input
+     * step. It must be such that after MIN_MATCH steps, the oldest
+     * byte no longer takes part in the hash key, that is:
+     *   hash_shift * MIN_MATCH >= hash_bits
+     */
+
+	long block_start;
+	/* Window position at the beginning of the current output block. Gets
+     * negative when the window is moved backwards.
+     */
+
+	uInt match_length;   /* length of best match */
+	IPos prev_match;     /* previous match */
+	int match_available; /* set if previous match exists */
+	uInt strstart;       /* start of string to insert */
+	uInt match_start;    /* start of matching string */
+	uInt lookahead;      /* number of valid bytes ahead in window */
+
+	uInt prev_length;
+	/* Length of the best match at previous step. Matches not greater than this
+     * are discarded. This is used in the lazy match evaluation.
+     */
+
+	uInt max_chain_length;
+	/* To speed up deflation, hash chains are never searched beyond this
+     * length.  A higher limit improves compression ratio but degrades the
+     * speed.
+     */
+
+	uInt max_lazy_match;
+	/* Attempt to find a better match only when the current match is strictly
+     * smaller than this value. This mechanism is used only for compression
+     * levels >= 4.
+     */
+#define max_insert_length max_lazy_match
+	/* Insert new strings in the hash table only if the match length is not
+     * greater than this length. This saves time but degrades compression.
+     * max_insert_length is used only for compression levels <= 3.
+     */
+
+	int level;    /* compression level (1..9) */
+	int strategy; /* favor or force Huffman coding*/
+
+	uInt good_match;
+	/* Use a faster search when the previous match is longer than this */
+
+	int nice_match; /* Stop searching when current match exceeds this */
+
+	/* used by trees.c: */
+	/* Didn't use ct_data typedef below to suppress compiler warning */
+	struct ct_data_s dyn_ltree[HEAP_SIZE];       /* literal and length tree */
+	struct ct_data_s dyn_dtree[2 * D_CODES + 1]; /* distance tree */
+	struct ct_data_s bl_tree[2 * BL_CODES + 1];  /* Huffman tree for bit lengths */
+
+	struct tree_desc_s l_desc;  /* desc. for literal tree */
+	struct tree_desc_s d_desc;  /* desc. for distance tree */
+	struct tree_desc_s bl_desc; /* desc. for bit length tree */
+
+	ush bl_count[MAX_BITS + 1];
+	/* number of codes at each bit length for an optimal tree */
+
+	int heap[2 * L_CODES + 1]; /* heap used to build the Huffman trees */
+	int heap_len;              /* number of elements in the heap */
+	int heap_max;              /* element of largest frequency */
+	/* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
+     * The same heap array is used to build all trees.
+     */
+
+	uch depth[2 * L_CODES + 1];
+	/* Depth of each subtree used as tie breaker for trees of equal frequency
+     */
+
+	uchf *l_buf; /* buffer for literals or lengths */
+
+	uInt lit_bufsize;
+	/* Size of match buffer for literals/lengths.  There are 4 reasons for
+     * limiting lit_bufsize to 64K:
+     *   - frequencies can be kept in 16 bit counters
+     *   - if compression is not successful for the first block, all input
+     *     data is still in the window so we can still emit a stored block even
+     *     when input comes from standard input.  (This can also be done for
+     *     all blocks if lit_bufsize is not greater than 32K.)
+     *   - if compression is not successful for a file smaller than 64K, we can
+     *     even emit a stored file instead of a stored block (saving 5 bytes).
+     *     This is applicable only for zip (not gzip or zlib).
+     *   - creating new Huffman trees less frequently may not provide fast
+     *     adaptation to changes in the input data statistics. (Take for
+     *     example a binary file with poorly compressible code followed by
+     *     a highly compressible string table.) Smaller buffer sizes give
+     *     fast adaptation but have of course the overhead of transmitting
+     *     trees more frequently.
+     *   - I can't count above 4
+     */
+
+	uInt last_lit; /* running index in l_buf */
+
+	ushf *d_buf;
+	/* Buffer for distances. To simplify the code, d_buf and l_buf have
+     * the same number of elements. To use different lengths, an extra flag
+     * array would be necessary.
+     */
+
+	ulg opt_len;    /* bit length of current block with optimal trees */
+	ulg static_len; /* bit length of current block with static trees */
+	uInt matches;   /* number of string matches in current block */
+	uInt insert;    /* bytes at end of window left to insert */
+
+#ifdef DEBUG
+	ulg compressed_len; /* total bit length of compressed file mod 2^32 */
+	ulg bits_sent;      /* bit length of compressed data sent mod 2^32 */
+#endif
+
+	ush bi_buf;
+	/* Output buffer. bits are inserted starting at the bottom (least
+     * significant bits).
+     */
+	int bi_valid;
+	/* Number of valid bits in bi_buf.  All bits above the last valid bit
+     * are always zero.
+     */
+
+	ulg high_water;
+	/* High water mark offset in window for initialized bytes -- bytes above
+     * this are set to zero in order to avoid memory check warnings when
+     * longest match routines access bytes past the input.  This is then
+     * updated to the new high water mark.
+     */
+
+} FAR deflate_state;
+
+/* Output a byte on the stream.
+ * IN assertion: there is enough room in pending_buf.
+ */
+#define put_byte(s, c)                      \
+	{                                       \
+		s->pending_buf[s->pending++] = (c); \
+	}
+
+#define MIN_LOOKAHEAD (MAX_MATCH + MIN_MATCH + 1)
+/* Minimum amount of lookahead, except at the end of the input file.
+ * See deflate.c for comments about the MIN_MATCH+1.
+ */
+
+#define MAX_DIST(s) ((s)->w_size - MIN_LOOKAHEAD)
+/* In order to simplify the code, particularly on 16 bit machines, match
+ * distances are limited to MAX_DIST instead of WSIZE.
+ */
+
+#define WIN_INIT MAX_MATCH
+/* Number of bytes after end of data in window to initialize in order to avoid
+   memory checker errors from longest match routines */
+
+/* in trees.c */
+void ZLIB_INTERNAL _tr_init OF((deflate_state * s));
+int ZLIB_INTERNAL _tr_tally OF((deflate_state * s, unsigned dist, unsigned lc));
+void ZLIB_INTERNAL _tr_flush_block OF((deflate_state * s, charf *buf,
+									   ulg stored_len, int last));
+void ZLIB_INTERNAL _tr_flush_bits OF((deflate_state * s));
+void ZLIB_INTERNAL _tr_align OF((deflate_state * s));
+void ZLIB_INTERNAL _tr_stored_block OF((deflate_state * s, charf *buf,
+										ulg stored_len, int last));
+
+#define d_code(dist) \
+	((dist) < 256 ? _dist_code[dist] : _dist_code[256 + ((dist) >> 7)])
+/* Mapping from a distance to a distance code. dist is the distance - 1 and
+ * must not have side effects. _dist_code[256] and _dist_code[257] are never
+ * used.
+ */
+
+#ifndef DEBUG
+/* Inline versions of _tr_tally for speed: */
+
+#if defined(GEN_TREES_H) || !defined(STDC)
+extern uch ZLIB_INTERNAL _length_code[];
+extern uch ZLIB_INTERNAL _dist_code[];
+#else
+extern const uch ZLIB_INTERNAL _length_code[];
+extern const uch ZLIB_INTERNAL _dist_code[];
+#endif
+
+#define _tr_tally_lit(s, c, flush)                   \
+	{                                                \
+		uch cc = (c);                                \
+		s->d_buf[s->last_lit] = 0;                   \
+		s->l_buf[s->last_lit++] = cc;                \
+		s->dyn_ltree[cc].Freq++;                     \
+		flush = (s->last_lit == s->lit_bufsize - 1); \
+	}
+#define _tr_tally_dist(s, distance, length, flush)             \
+	{                                                          \
+		uch len = (length);                                    \
+		ush dist = (distance);                                 \
+		s->d_buf[s->last_lit] = dist;                          \
+		s->l_buf[s->last_lit++] = len;                         \
+		dist--;                                                \
+		s->dyn_ltree[_length_code[len] + LITERALS + 1].Freq++; \
+		s->dyn_dtree[d_code(dist)].Freq++;                     \
+		flush = (s->last_lit == s->lit_bufsize - 1);           \
+	}
+#else
+#define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c)
+#define _tr_tally_dist(s, distance, length, flush) \
+	flush = _tr_tally(s, distance, length)
+#endif
+
+#endif /* DEFLATE_H */
diff --git a/engine/inc/bullet/ThirdPartyLibs/zlib/gzguts.h b/engine/inc/bullet/ThirdPartyLibs/zlib/gzguts.h
new file mode 100644
index 00000000..690cd105
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/zlib/gzguts.h
@@ -0,0 +1,213 @@
+/* gzguts.h -- zlib internal header definitions for gz* operations
+ * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#ifdef _LARGEFILE64_SOURCE
+#ifndef _LARGEFILE_SOURCE
+#define _LARGEFILE_SOURCE 1
+#endif
+#ifdef _FILE_OFFSET_BITS
+#undef _FILE_OFFSET_BITS
+#endif
+#endif
+
+#ifdef HAVE_HIDDEN
+#define ZLIB_INTERNAL __attribute__((visibility("hidden")))
+#else
+#define ZLIB_INTERNAL
+#endif
+
+#include <stdio.h>
+#include "zlib.h"
+#ifndef _WIN32
+#include <unistd.h>
+#endif //_WIN32
+#ifdef STDC
+#include <string.h>
+#include <stdlib.h>
+#include <limits.h>
+#endif
+#include <fcntl.h>
+
+#ifdef _WIN32
+#include <stddef.h>
+#endif
+
+#if defined(__TURBOC__) || defined(_MSC_VER) || defined(_WIN32)
+#include <io.h>
+#endif
+
+#ifdef WINAPI_FAMILY
+#define open _open
+#define read _read
+#define write _write
+#define close _close
+#endif
+
+#ifdef NO_DEFLATE /* for compatibility with old definition */
+#define NO_GZCOMPRESS
+#endif
+
+#if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550)
+#ifndef HAVE_VSNPRINTF
+#define HAVE_VSNPRINTF
+#endif
+#endif
+
+#if defined(__CYGWIN__)
+#ifndef HAVE_VSNPRINTF
+#define HAVE_VSNPRINTF
+#endif
+#endif
+
+#if defined(MSDOS) && defined(__BORLANDC__) && (BORLANDC > 0x410)
+#ifndef HAVE_VSNPRINTF
+#define HAVE_VSNPRINTF
+#endif
+#endif
+
+#ifndef HAVE_VSNPRINTF
+#ifdef MSDOS
+/* vsnprintf may exist on some MS-DOS compilers (DJGPP?),
+   but for now we just assume it doesn't. */
+#define NO_vsnprintf
+#endif
+#ifdef __TURBOC__
+#define NO_vsnprintf
+#endif
+#ifdef WIN32
+/* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */
+#if !defined(vsnprintf) && !defined(NO_vsnprintf)
+#if !defined(_MSC_VER) || (defined(_MSC_VER) && _MSC_VER < 1500)
+#define vsnprintf _vsnprintf
+#endif
+#endif
+#endif
+#ifdef __SASC
+#define NO_vsnprintf
+#endif
+#ifdef VMS
+#define NO_vsnprintf
+#endif
+#ifdef __OS400__
+#define NO_vsnprintf
+#endif
+#ifdef __MVS__
+#define NO_vsnprintf
+#endif
+#endif
+
+/* unlike snprintf (which is required in C99, yet still not supported by
+   Microsoft more than a decade later!), _snprintf does not guarantee null
+   termination of the result -- however this is only used in gzlib.c where
+   the result is assured to fit in the space provided */
+#ifdef _MSC_VER
+#define snprintf _snprintf
+#endif
+
+#ifndef local
+#define local static
+#endif
+/* compile with -Dlocal if your debugger can't find static symbols */
+
+/* gz* functions always use library allocation functions */
+#ifndef STDC
+extern voidp malloc OF((uInt size));
+extern void free OF((voidpf ptr));
+#endif
+
+/* get errno and strerror definition */
+#if defined UNDER_CE
+#include <windows.h>
+#define zstrerror() gz_strwinerror((DWORD)GetLastError())
+#else
+#ifndef NO_STRERROR
+#include <errno.h>
+#define zstrerror() strerror(errno)
+#else
+#define zstrerror() "stdio error (consult errno)"
+#endif
+#endif
+
+/* provide prototypes for these when building zlib without LFS */
+#if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE - 0 == 0
+ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
+ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int));
+ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile));
+ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile));
+#endif
+
+/* default memLevel */
+#if MAX_MEM_LEVEL >= 8
+#define DEF_MEM_LEVEL 8
+#else
+#define DEF_MEM_LEVEL MAX_MEM_LEVEL
+#endif
+
+/* default i/o buffer size -- double this for output when reading (this and
+   twice this must be able to fit in an unsigned type) */
+#define GZBUFSIZE 8192
+
+/* gzip modes, also provide a little integrity check on the passed structure */
+#define GZ_NONE 0
+#define GZ_READ 7247
+#define GZ_WRITE 31153
+#define GZ_APPEND 1 /* mode set to GZ_WRITE after the file is opened */
+
+/* values for gz_state how */
+#define LOOK 0 /* look for a gzip header */
+#define COPY 1 /* copy input directly */
+#define GZIP 2 /* decompress a gzip stream */
+
+/* internal gzip file state data structure */
+typedef struct
+{
+	/* exposed contents for gzgetc() macro */
+	struct gzFile_s x; /* "x" for exposed */
+					   /* x.have: number of bytes available at x.next */
+					   /* x.next: next output data to deliver or write */
+					   /* x.pos: current position in uncompressed data */
+	/* used for both reading and writing */
+	int mode;           /* see gzip modes above */
+	int fd;             /* file descriptor */
+	char *path;         /* path or fd for error messages */
+	unsigned size;      /* buffer size, zero if not allocated yet */
+	unsigned want;      /* requested buffer size, default is GZBUFSIZE */
+	unsigned char *in;  /* input buffer */
+	unsigned char *out; /* output buffer (double-sized when reading) */
+	int direct;         /* 0 if processing gzip, 1 if transparent */
+	/* just for reading */
+	int how;         /* 0: get header, 1: copy, 2: decompress */
+	z_off64_t start; /* where the gzip data started, for rewinding */
+	int eof;         /* true if end of input file reached */
+	int past;        /* true if read requested past end */
+	/* just for writing */
+	int level;    /* compression level */
+	int strategy; /* compression strategy */
+	/* seek request */
+	z_off64_t skip; /* amount to skip (already rewound if backwards) */
+	int seek;       /* true if seek request pending */
+	/* error information */
+	int err;   /* error code */
+	char *msg; /* error message */
+	/* zlib inflate or deflate stream */
+	z_stream strm; /* stream structure in-place (not a pointer) */
+} gz_state;
+typedef gz_state FAR *gz_statep;
+
+/* shared functions */
+void ZLIB_INTERNAL gz_error OF((gz_statep, int, const char *));
+#if defined UNDER_CE
+char ZLIB_INTERNAL *gz_strwinerror OF((DWORD error));
+#endif
+
+/* GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t
+   value -- needed when comparing unsigned to z_off64_t, which is signed
+   (possible z_off64_t types off_t, off64_t, and long are all signed) */
+#ifdef INT_MAX
+#define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > INT_MAX)
+#else
+unsigned ZLIB_INTERNAL gz_intmax OF((void));
+#define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > gz_intmax())
+#endif
diff --git a/engine/inc/bullet/ThirdPartyLibs/zlib/inffast.h b/engine/inc/bullet/ThirdPartyLibs/zlib/inffast.h
new file mode 100644
index 00000000..e5c1aa4c
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/zlib/inffast.h
@@ -0,0 +1,11 @@
+/* inffast.h -- header to use inffast.c
+ * Copyright (C) 1995-2003, 2010 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+void ZLIB_INTERNAL inflate_fast OF((z_streamp strm, unsigned start));
diff --git a/engine/inc/bullet/ThirdPartyLibs/zlib/inffixed.h b/engine/inc/bullet/ThirdPartyLibs/zlib/inffixed.h
new file mode 100644
index 00000000..1684e54e
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/zlib/inffixed.h
@@ -0,0 +1,14 @@
+/* inffixed.h -- table for decoding fixed codes
+     * Generated automatically by makefixed().
+     */
+
+/* WARNING: this file should *not* be used by applications.
+       It is part of the implementation of this library and is
+       subject to change. Applications should only use zlib.h.
+     */
+
+static const code lenfix[512] = {
+	{96, 7, 0}, {0, 8, 80}, {0, 8, 16}, {20, 8, 115}, {18, 7, 31}, {0, 8, 112}, {0, 8, 48}, {0, 9, 192}, {16, 7, 10}, {0, 8, 96}, {0, 8, 32}, {0, 9, 160}, {0, 8, 0}, {0, 8, 128}, {0, 8, 64}, {0, 9, 224}, {16, 7, 6}, {0, 8, 88}, {0, 8, 24}, {0, 9, 144}, {19, 7, 59}, {0, 8, 120}, {0, 8, 56}, {0, 9, 208}, {17, 7, 17}, {0, 8, 104}, {0, 8, 40}, {0, 9, 176}, {0, 8, 8}, {0, 8, 136}, {0, 8, 72}, {0, 9, 240}, {16, 7, 4}, {0, 8, 84}, {0, 8, 20}, {21, 8, 227}, {19, 7, 43}, {0, 8, 116}, {0, 8, 52}, {0, 9, 200}, {17, 7, 13}, {0, 8, 100}, {0, 8, 36}, {0, 9, 168}, {0, 8, 4}, {0, 8, 132}, {0, 8, 68}, {0, 9, 232}, {16, 7, 8}, {0, 8, 92}, {0, 8, 28}, {0, 9, 152}, {20, 7, 83}, {0, 8, 124}, {0, 8, 60}, {0, 9, 216}, {18, 7, 23}, {0, 8, 108}, {0, 8, 44}, {0, 9, 184}, {0, 8, 12}, {0, 8, 140}, {0, 8, 76}, {0, 9, 248}, {16, 7, 3}, {0, 8, 82}, {0, 8, 18}, {21, 8, 163}, {19, 7, 35}, {0, 8, 114}, {0, 8, 50}, {0, 9, 196}, {17, 7, 11}, {0, 8, 98}, {0, 8, 34}, {0, 9, 164}, {0, 8, 2}, {0, 8, 130}, {0, 8, 66}, {0, 9, 228}, {16, 7, 7}, {0, 8, 90}, {0, 8, 26}, {0, 9, 148}, {20, 7, 67}, {0, 8, 122}, {0, 8, 58}, {0, 9, 212}, {18, 7, 19}, {0, 8, 106}, {0, 8, 42}, {0, 9, 180}, {0, 8, 10}, {0, 8, 138}, {0, 8, 74}, {0, 9, 244}, {16, 7, 5}, {0, 8, 86}, {0, 8, 22}, {64, 8, 0}, {19, 7, 51}, {0, 8, 118}, {0, 8, 54}, {0, 9, 204}, {17, 7, 15}, {0, 8, 102}, {0, 8, 38}, {0, 9, 172}, {0, 8, 6}, {0, 8, 134}, {0, 8, 70}, {0, 9, 236}, {16, 7, 9}, {0, 8, 94}, {0, 8, 30}, {0, 9, 156}, {20, 7, 99}, {0, 8, 126}, {0, 8, 62}, {0, 9, 220}, {18, 7, 27}, {0, 8, 110}, {0, 8, 46}, {0, 9, 188}, {0, 8, 14}, {0, 8, 142}, {0, 8, 78}, {0, 9, 252}, {96, 7, 0}, {0, 8, 81}, {0, 8, 17}, {21, 8, 131}, {18, 7, 31}, {0, 8, 113}, {0, 8, 49}, {0, 9, 194}, {16, 7, 10}, {0, 8, 97}, {0, 8, 33}, {0, 9, 162}, {0, 8, 1}, {0, 8, 129}, {0, 8, 65}, {0, 9, 226}, {16, 7, 6}, {0, 8, 89}, {0, 8, 25}, {0, 9, 146}, {19, 7, 59}, {0, 8, 121}, {0, 8, 57}, {0, 9, 210}, {17, 7, 17}, {0, 8, 105}, {0, 8, 41}, {0, 9, 178}, {0, 8, 9}, {0, 8, 137}, {0, 8, 73}, {0, 9, 242}, {16, 7, 4}, {0, 8, 85}, {0, 8, 21}, {16, 8, 258}, {19, 7, 43}, {0, 8, 117}, {0, 8, 53}, {0, 9, 202}, {17, 7, 13}, {0, 8, 101}, {0, 8, 37}, {0, 9, 170}, {0, 8, 5}, {0, 8, 133}, {0, 8, 69}, {0, 9, 234}, {16, 7, 8}, {0, 8, 93}, {0, 8, 29}, {0, 9, 154}, {20, 7, 83}, {0, 8, 125}, {0, 8, 61}, {0, 9, 218}, {18, 7, 23}, {0, 8, 109}, {0, 8, 45}, {0, 9, 186}, {0, 8, 13}, {0, 8, 141}, {0, 8, 77}, {0, 9, 250}, {16, 7, 3}, {0, 8, 83}, {0, 8, 19}, {21, 8, 195}, {19, 7, 35}, {0, 8, 115}, {0, 8, 51}, {0, 9, 198}, {17, 7, 11}, {0, 8, 99}, {0, 8, 35}, {0, 9, 166}, {0, 8, 3}, {0, 8, 131}, {0, 8, 67}, {0, 9, 230}, {16, 7, 7}, {0, 8, 91}, {0, 8, 27}, {0, 9, 150}, {20, 7, 67}, {0, 8, 123}, {0, 8, 59}, {0, 9, 214}, {18, 7, 19}, {0, 8, 107}, {0, 8, 43}, {0, 9, 182}, {0, 8, 11}, {0, 8, 139}, {0, 8, 75}, {0, 9, 246}, {16, 7, 5}, {0, 8, 87}, {0, 8, 23}, {64, 8, 0}, {19, 7, 51}, {0, 8, 119}, {0, 8, 55}, {0, 9, 206}, {17, 7, 15}, {0, 8, 103}, {0, 8, 39}, {0, 9, 174}, {0, 8, 7}, {0, 8, 135}, {0, 8, 71}, {0, 9, 238}, {16, 7, 9}, {0, 8, 95}, {0, 8, 31}, {0, 9, 158}, {20, 7, 99}, {0, 8, 127}, {0, 8, 63}, {0, 9, 222}, {18, 7, 27}, {0, 8, 111}, {0, 8, 47}, {0, 9, 190}, {0, 8, 15}, {0, 8, 143}, {0, 8, 79}, {0, 9, 254}, {96, 7, 0}, {0, 8, 80}, {0, 8, 16}, {20, 8, 115}, {18, 7, 31}, {0, 8, 112}, {0, 8, 48}, {0, 9, 193}, {16, 7, 10}, {0, 8, 96}, {0, 8, 32}, {0, 9, 161}, {0, 8, 0}, {0, 8, 128}, {0, 8, 64}, {0, 9, 225}, {16, 7, 6}, {0, 8, 88}, {0, 8, 24}, {0, 9, 145}, {19, 7, 59}, {0, 8, 120}, {0, 8, 56}, {0, 9, 209}, {17, 7, 17}, {0, 8, 104}, {0, 8, 40}, {0, 9, 177}, {0, 8, 8}, {0, 8, 136}, {0, 8, 72}, {0, 9, 241}, {16, 7, 4}, {0, 8, 84}, {0, 8, 20}, {21, 8, 227}, {19, 7, 43}, {0, 8, 116}, {0, 8, 52}, {0, 9, 201}, {17, 7, 13}, {0, 8, 100}, {0, 8, 36}, {0, 9, 169}, {0, 8, 4}, {0, 8, 132}, {0, 8, 68}, {0, 9, 233}, {16, 7, 8}, {0, 8, 92}, {0, 8, 28}, {0, 9, 153}, {20, 7, 83}, {0, 8, 124}, {0, 8, 60}, {0, 9, 217}, {18, 7, 23}, {0, 8, 108}, {0, 8, 44}, {0, 9, 185}, {0, 8, 12}, {0, 8, 140}, {0, 8, 76}, {0, 9, 249}, {16, 7, 3}, {0, 8, 82}, {0, 8, 18}, {21, 8, 163}, {19, 7, 35}, {0, 8, 114}, {0, 8, 50}, {0, 9, 197}, {17, 7, 11}, {0, 8, 98}, {0, 8, 34}, {0, 9, 165}, {0, 8, 2}, {0, 8, 130}, {0, 8, 66}, {0, 9, 229}, {16, 7, 7}, {0, 8, 90}, {0, 8, 26}, {0, 9, 149}, {20, 7, 67}, {0, 8, 122}, {0, 8, 58}, {0, 9, 213}, {18, 7, 19}, {0, 8, 106}, {0, 8, 42}, {0, 9, 181}, {0, 8, 10}, {0, 8, 138}, {0, 8, 74}, {0, 9, 245}, {16, 7, 5}, {0, 8, 86}, {0, 8, 22}, {64, 8, 0}, {19, 7, 51}, {0, 8, 118}, {0, 8, 54}, {0, 9, 205}, {17, 7, 15}, {0, 8, 102}, {0, 8, 38}, {0, 9, 173}, {0, 8, 6}, {0, 8, 134}, {0, 8, 70}, {0, 9, 237}, {16, 7, 9}, {0, 8, 94}, {0, 8, 30}, {0, 9, 157}, {20, 7, 99}, {0, 8, 126}, {0, 8, 62}, {0, 9, 221}, {18, 7, 27}, {0, 8, 110}, {0, 8, 46}, {0, 9, 189}, {0, 8, 14}, {0, 8, 142}, {0, 8, 78}, {0, 9, 253}, {96, 7, 0}, {0, 8, 81}, {0, 8, 17}, {21, 8, 131}, {18, 7, 31}, {0, 8, 113}, {0, 8, 49}, {0, 9, 195}, {16, 7, 10}, {0, 8, 97}, {0, 8, 33}, {0, 9, 163}, {0, 8, 1}, {0, 8, 129}, {0, 8, 65}, {0, 9, 227}, {16, 7, 6}, {0, 8, 89}, {0, 8, 25}, {0, 9, 147}, {19, 7, 59}, {0, 8, 121}, {0, 8, 57}, {0, 9, 211}, {17, 7, 17}, {0, 8, 105}, {0, 8, 41}, {0, 9, 179}, {0, 8, 9}, {0, 8, 137}, {0, 8, 73}, {0, 9, 243}, {16, 7, 4}, {0, 8, 85}, {0, 8, 21}, {16, 8, 258}, {19, 7, 43}, {0, 8, 117}, {0, 8, 53}, {0, 9, 203}, {17, 7, 13}, {0, 8, 101}, {0, 8, 37}, {0, 9, 171}, {0, 8, 5}, {0, 8, 133}, {0, 8, 69}, {0, 9, 235}, {16, 7, 8}, {0, 8, 93}, {0, 8, 29}, {0, 9, 155}, {20, 7, 83}, {0, 8, 125}, {0, 8, 61}, {0, 9, 219}, {18, 7, 23}, {0, 8, 109}, {0, 8, 45}, {0, 9, 187}, {0, 8, 13}, {0, 8, 141}, {0, 8, 77}, {0, 9, 251}, {16, 7, 3}, {0, 8, 83}, {0, 8, 19}, {21, 8, 195}, {19, 7, 35}, {0, 8, 115}, {0, 8, 51}, {0, 9, 199}, {17, 7, 11}, {0, 8, 99}, {0, 8, 35}, {0, 9, 167}, {0, 8, 3}, {0, 8, 131}, {0, 8, 67}, {0, 9, 231}, {16, 7, 7}, {0, 8, 91}, {0, 8, 27}, {0, 9, 151}, {20, 7, 67}, {0, 8, 123}, {0, 8, 59}, {0, 9, 215}, {18, 7, 19}, {0, 8, 107}, {0, 8, 43}, {0, 9, 183}, {0, 8, 11}, {0, 8, 139}, {0, 8, 75}, {0, 9, 247}, {16, 7, 5}, {0, 8, 87}, {0, 8, 23}, {64, 8, 0}, {19, 7, 51}, {0, 8, 119}, {0, 8, 55}, {0, 9, 207}, {17, 7, 15}, {0, 8, 103}, {0, 8, 39}, {0, 9, 175}, {0, 8, 7}, {0, 8, 135}, {0, 8, 71}, {0, 9, 239}, {16, 7, 9}, {0, 8, 95}, {0, 8, 31}, {0, 9, 159}, {20, 7, 99}, {0, 8, 127}, {0, 8, 63}, {0, 9, 223}, {18, 7, 27}, {0, 8, 111}, {0, 8, 47}, {0, 9, 191}, {0, 8, 15}, {0, 8, 143}, {0, 8, 79}, {0, 9, 255}};
+
+static const code distfix[32] = {
+	{16, 5, 1}, {23, 5, 257}, {19, 5, 17}, {27, 5, 4097}, {17, 5, 5}, {25, 5, 1025}, {21, 5, 65}, {29, 5, 16385}, {16, 5, 3}, {24, 5, 513}, {20, 5, 33}, {28, 5, 8193}, {18, 5, 9}, {26, 5, 2049}, {22, 5, 129}, {64, 5, 0}, {16, 5, 2}, {23, 5, 385}, {19, 5, 25}, {27, 5, 6145}, {17, 5, 7}, {25, 5, 1537}, {21, 5, 97}, {29, 5, 24577}, {16, 5, 4}, {24, 5, 769}, {20, 5, 49}, {28, 5, 12289}, {18, 5, 13}, {26, 5, 3073}, {22, 5, 193}, {64, 5, 0}};
diff --git a/engine/inc/bullet/ThirdPartyLibs/zlib/inflate.h b/engine/inc/bullet/ThirdPartyLibs/zlib/inflate.h
new file mode 100644
index 00000000..230e0b79
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/zlib/inflate.h
@@ -0,0 +1,124 @@
+/* inflate.h -- internal inflate state definition
+ * Copyright (C) 1995-2009 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* define NO_GZIP when compiling if you want to disable gzip header and
+   trailer decoding by inflate().  NO_GZIP would be used to avoid linking in
+   the crc code when it is not needed.  For shared libraries, gzip decoding
+   should be left enabled. */
+#ifndef NO_GZIP
+#define GUNZIP
+#endif
+
+/* Possible inflate modes between inflate() calls */
+typedef enum
+{
+	HEAD,     /* i: waiting for magic header */
+	FLAGS,    /* i: waiting for method and flags (gzip) */
+	TIME,     /* i: waiting for modification time (gzip) */
+	OS,       /* i: waiting for extra flags and operating system (gzip) */
+	EXLEN,    /* i: waiting for extra length (gzip) */
+	EXTRA,    /* i: waiting for extra bytes (gzip) */
+	NAME,     /* i: waiting for end of file name (gzip) */
+	COMMENT,  /* i: waiting for end of comment (gzip) */
+	HCRC,     /* i: waiting for header crc (gzip) */
+	DICTID,   /* i: waiting for dictionary check value */
+	DICT,     /* waiting for inflateSetDictionary() call */
+	TYPE,     /* i: waiting for type bits, including last-flag bit */
+	TYPEDO,   /* i: same, but skip check to exit inflate on new block */
+	STORED,   /* i: waiting for stored size (length and complement) */
+	COPY_,    /* i/o: same as COPY below, but only first time in */
+	COPY,     /* i/o: waiting for input or output to copy stored block */
+	TABLE,    /* i: waiting for dynamic block table lengths */
+	LENLENS,  /* i: waiting for code length code lengths */
+	CODELENS, /* i: waiting for length/lit and distance code lengths */
+	LEN_,     /* i: same as LEN below, but only first time in */
+	LEN,      /* i: waiting for length/lit/eob code */
+	LENEXT,   /* i: waiting for length extra bits */
+	DIST,     /* i: waiting for distance code */
+	DISTEXT,  /* i: waiting for distance extra bits */
+	MATCH,    /* o: waiting for output space to copy string */
+	LIT,      /* o: waiting for output space to write literal */
+	CHECK,    /* i: waiting for 32-bit check value */
+	LENGTH,   /* i: waiting for 32-bit length (gzip) */
+	DONE,     /* finished check, done -- remain here until reset */
+	BAD,      /* got a data error -- remain here until reset */
+	MEM,      /* got an inflate() memory error -- remain here until reset */
+	SYNC      /* looking for synchronization bytes to restart inflate() */
+} inflate_mode;
+
+/*
+    State transitions between above modes -
+
+    (most modes can go to BAD or MEM on error -- not shown for clarity)
+
+    Process header:
+        HEAD -> (gzip) or (zlib) or (raw)
+        (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME -> COMMENT ->
+                  HCRC -> TYPE
+        (zlib) -> DICTID or TYPE
+        DICTID -> DICT -> TYPE
+        (raw) -> TYPEDO
+    Read deflate blocks:
+            TYPE -> TYPEDO -> STORED or TABLE or LEN_ or CHECK
+            STORED -> COPY_ -> COPY -> TYPE
+            TABLE -> LENLENS -> CODELENS -> LEN_
+            LEN_ -> LEN
+    Read deflate codes in fixed or dynamic block:
+                LEN -> LENEXT or LIT or TYPE
+                LENEXT -> DIST -> DISTEXT -> MATCH -> LEN
+                LIT -> LEN
+    Process trailer:
+        CHECK -> LENGTH -> DONE
+ */
+
+/* state maintained between inflate() calls.  Approximately 10K bytes. */
+struct inflate_state
+{
+	inflate_mode mode;   /* current inflate mode */
+	int last;            /* true if processing last block */
+	int wrap;            /* bit 0 true for zlib, bit 1 true for gzip */
+	int havedict;        /* true if dictionary provided */
+	int flags;           /* gzip header method and flags (0 if zlib) */
+	unsigned dmax;       /* zlib header max distance (INFLATE_STRICT) */
+	unsigned long check; /* protected copy of check value */
+	unsigned long total; /* protected copy of output count */
+	gz_headerp head;     /* where to save gzip header information */
+	/* sliding window */
+	unsigned wbits;            /* log base 2 of requested window size */
+	unsigned wsize;            /* window size or zero if not using window */
+	unsigned whave;            /* valid bytes in the window */
+	unsigned wnext;            /* window write index */
+	unsigned char FAR *window; /* allocated sliding window, if needed */
+	/* bit accumulator */
+	unsigned long hold; /* input bit accumulator */
+	unsigned bits;      /* number of bits in "in" */
+	/* for string and stored block copying */
+	unsigned length; /* literal or length of data to copy */
+	unsigned offset; /* distance back to copy string from */
+	/* for table and code decoding */
+	unsigned extra; /* extra bits needed */
+	/* fixed and dynamic code tables */
+	code const FAR *lencode;  /* starting table for length/literal codes */
+	code const FAR *distcode; /* starting table for distance codes */
+	unsigned lenbits;         /* index bits for lencode */
+	unsigned distbits;        /* index bits for distcode */
+	/* dynamic table building */
+	unsigned ncode;           /* number of code length code lengths */
+	unsigned nlen;            /* number of length code lengths */
+	unsigned ndist;           /* number of distance code lengths */
+	unsigned have;            /* number of code lengths in lens[] */
+	code FAR *next;           /* next available space in codes[] */
+	unsigned short lens[320]; /* temporary storage for code lengths */
+	unsigned short work[288]; /* work area for code table building */
+	code codes[ENOUGH];       /* space for code tables */
+	int sane;                 /* if false, allow invalid distance too far */
+	int back;                 /* bits back of last unprocessed length/lit */
+	unsigned was;             /* initial length of match */
+};
diff --git a/engine/inc/bullet/ThirdPartyLibs/zlib/inftrees.h b/engine/inc/bullet/ThirdPartyLibs/zlib/inftrees.h
new file mode 100644
index 00000000..82759603
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/zlib/inftrees.h
@@ -0,0 +1,64 @@
+/* inftrees.h -- header to use inftrees.c
+ * Copyright (C) 1995-2005, 2010 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* Structure for decoding tables.  Each entry provides either the
+   information needed to do the operation requested by the code that
+   indexed that table entry, or it provides a pointer to another
+   table that indexes more bits of the code.  op indicates whether
+   the entry is a pointer to another table, a literal, a length or
+   distance, an end-of-block, or an invalid code.  For a table
+   pointer, the low four bits of op is the number of index bits of
+   that table.  For a length or distance, the low four bits of op
+   is the number of extra bits to get after the code.  bits is
+   the number of bits in this code or part of the code to drop off
+   of the bit buffer.  val is the actual byte to output in the case
+   of a literal, the base length or distance, or the offset from
+   the current table to the next table.  Each entry is four bytes. */
+typedef struct
+{
+	unsigned char op;   /* operation, extra bits, table bits */
+	unsigned char bits; /* bits in this part of the code */
+	unsigned short val; /* offset in table or code value */
+} code;
+
+/* op values as set by inflate_table():
+    00000000 - literal
+    0000tttt - table link, tttt != 0 is the number of table index bits
+    0001eeee - length or distance, eeee is the number of extra bits
+    01100000 - end of block
+    01000000 - invalid code
+ */
+
+/* Maximum size of the dynamic table.  The maximum number of code structures is
+   1444, which is the sum of 852 for literal/length codes and 592 for distance
+   codes.  These values were found by exhaustive searches using the program
+   examples/enough.c found in the zlib distribtution.  The arguments to that
+   program are the number of symbols, the initial root table size, and the
+   maximum bit length of a code.  "enough 286 9 15" for literal/length codes
+   returns returns 852, and "enough 30 6 15" for distance codes returns 592.
+   The initial root table size (9 or 6) is found in the fifth argument of the
+   inflate_table() calls in inflate.c and infback.c.  If the root table size is
+   changed, then these maximum sizes would be need to be recalculated and
+   updated. */
+#define ENOUGH_LENS 852
+#define ENOUGH_DISTS 592
+#define ENOUGH (ENOUGH_LENS + ENOUGH_DISTS)
+
+/* Type of code to build for inflate_table() */
+typedef enum
+{
+	CODES,
+	LENS,
+	DISTS
+} codetype;
+
+int ZLIB_INTERNAL inflate_table OF((codetype type, unsigned short FAR *lens,
+									unsigned codes, code FAR *FAR *table,
+									unsigned FAR *bits, unsigned short FAR *work));
diff --git a/engine/inc/bullet/ThirdPartyLibs/zlib/trees.h b/engine/inc/bullet/ThirdPartyLibs/zlib/trees.h
new file mode 100644
index 00000000..77067ff7
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/zlib/trees.h
@@ -0,0 +1,59 @@
+/* header created automatically with -DGEN_TREES_H */
+
+local const ct_data static_ltree[L_CODES + 2] = {
+	{{12}, {8}}, {{140}, {8}}, {{76}, {8}}, {{204}, {8}}, {{44}, {8}}, {{172}, {8}}, {{108}, {8}}, {{236}, {8}}, {{28}, {8}}, {{156}, {8}}, {{92}, {8}}, {{220}, {8}}, {{60}, {8}}, {{188}, {8}}, {{124}, {8}}, {{252}, {8}}, {{2}, {8}}, {{130}, {8}}, {{66}, {8}}, {{194}, {8}}, {{34}, {8}}, {{162}, {8}}, {{98}, {8}}, {{226}, {8}}, {{18}, {8}}, {{146}, {8}}, {{82}, {8}}, {{210}, {8}}, {{50}, {8}}, {{178}, {8}}, {{114}, {8}}, {{242}, {8}}, {{10}, {8}}, {{138}, {8}}, {{74}, {8}}, {{202}, {8}}, {{42}, {8}}, {{170}, {8}}, {{106}, {8}}, {{234}, {8}}, {{26}, {8}}, {{154}, {8}}, {{90}, {8}}, {{218}, {8}}, {{58}, {8}}, {{186}, {8}}, {{122}, {8}}, {{250}, {8}}, {{6}, {8}}, {{134}, {8}}, {{70}, {8}}, {{198}, {8}}, {{38}, {8}}, {{166}, {8}}, {{102}, {8}}, {{230}, {8}}, {{22}, {8}}, {{150}, {8}}, {{86}, {8}}, {{214}, {8}}, {{54}, {8}}, {{182}, {8}}, {{118}, {8}}, {{246}, {8}}, {{14}, {8}}, {{142}, {8}}, {{78}, {8}}, {{206}, {8}}, {{46}, {8}}, {{174}, {8}}, {{110}, {8}}, {{238}, {8}}, {{30}, {8}}, {{158}, {8}}, {{94}, {8}}, {{222}, {8}}, {{62}, {8}}, {{190}, {8}}, {{126}, {8}}, {{254}, {8}}, {{1}, {8}}, {{129}, {8}}, {{65}, {8}}, {{193}, {8}}, {{33}, {8}}, {{161}, {8}}, {{97}, {8}}, {{225}, {8}}, {{17}, {8}}, {{145}, {8}}, {{81}, {8}}, {{209}, {8}}, {{49}, {8}}, {{177}, {8}}, {{113}, {8}}, {{241}, {8}}, {{9}, {8}}, {{137}, {8}}, {{73}, {8}}, {{201}, {8}}, {{41}, {8}}, {{169}, {8}}, {{105}, {8}}, {{233}, {8}}, {{25}, {8}}, {{153}, {8}}, {{89}, {8}}, {{217}, {8}}, {{57}, {8}}, {{185}, {8}}, {{121}, {8}}, {{249}, {8}}, {{5}, {8}}, {{133}, {8}}, {{69}, {8}}, {{197}, {8}}, {{37}, {8}}, {{165}, {8}}, {{101}, {8}}, {{229}, {8}}, {{21}, {8}}, {{149}, {8}}, {{85}, {8}}, {{213}, {8}}, {{53}, {8}}, {{181}, {8}}, {{117}, {8}}, {{245}, {8}}, {{13}, {8}}, {{141}, {8}}, {{77}, {8}}, {{205}, {8}}, {{45}, {8}}, {{173}, {8}}, {{109}, {8}}, {{237}, {8}}, {{29}, {8}}, {{157}, {8}}, {{93}, {8}}, {{221}, {8}}, {{61}, {8}}, {{189}, {8}}, {{125}, {8}}, {{253}, {8}}, {{19}, {9}}, {{275}, {9}}, {{147}, {9}}, {{403}, {9}}, {{83}, {9}}, {{339}, {9}}, {{211}, {9}}, {{467}, {9}}, {{51}, {9}}, {{307}, {9}}, {{179}, {9}}, {{435}, {9}}, {{115}, {9}}, {{371}, {9}}, {{243}, {9}}, {{499}, {9}}, {{11}, {9}}, {{267}, {9}}, {{139}, {9}}, {{395}, {9}}, {{75}, {9}}, {{331}, {9}}, {{203}, {9}}, {{459}, {9}}, {{43}, {9}}, {{299}, {9}}, {{171}, {9}}, {{427}, {9}}, {{107}, {9}}, {{363}, {9}}, {{235}, {9}}, {{491}, {9}}, {{27}, {9}}, {{283}, {9}}, {{155}, {9}}, {{411}, {9}}, {{91}, {9}}, {{347}, {9}}, {{219}, {9}}, {{475}, {9}}, {{59}, {9}}, {{315}, {9}}, {{187}, {9}}, {{443}, {9}}, {{123}, {9}}, {{379}, {9}}, {{251}, {9}}, {{507}, {9}}, {{7}, {9}}, {{263}, {9}}, {{135}, {9}}, {{391}, {9}}, {{71}, {9}}, {{327}, {9}}, {{199}, {9}}, {{455}, {9}}, {{39}, {9}}, {{295}, {9}}, {{167}, {9}}, {{423}, {9}}, {{103}, {9}}, {{359}, {9}}, {{231}, {9}}, {{487}, {9}}, {{23}, {9}}, {{279}, {9}}, {{151}, {9}}, {{407}, {9}}, {{87}, {9}}, {{343}, {9}}, {{215}, {9}}, {{471}, {9}}, {{55}, {9}}, {{311}, {9}}, {{183}, {9}}, {{439}, {9}}, {{119}, {9}}, {{375}, {9}}, {{247}, {9}}, {{503}, {9}}, {{15}, {9}}, {{271}, {9}}, {{143}, {9}}, {{399}, {9}}, {{79}, {9}}, {{335}, {9}}, {{207}, {9}}, {{463}, {9}}, {{47}, {9}}, {{303}, {9}}, {{175}, {9}}, {{431}, {9}}, {{111}, {9}}, {{367}, {9}}, {{239}, {9}}, {{495}, {9}}, {{31}, {9}}, {{287}, {9}}, {{159}, {9}}, {{415}, {9}}, {{95}, {9}}, {{351}, {9}}, {{223}, {9}}, {{479}, {9}}, {{63}, {9}}, {{319}, {9}}, {{191}, {9}}, {{447}, {9}}, {{127}, {9}}, {{383}, {9}}, {{255}, {9}}, {{511}, {9}}, {{0}, {7}}, {{64}, {7}}, {{32}, {7}}, {{96}, {7}}, {{16}, {7}}, {{80}, {7}}, {{48}, {7}}, {{112}, {7}}, {{8}, {7}}, {{72}, {7}}, {{40}, {7}}, {{104}, {7}}, {{24}, {7}}, {{88}, {7}}, {{56}, {7}}, {{120}, {7}}, {{4}, {7}}, {{68}, {7}}, {{36}, {7}}, {{100}, {7}}, {{20}, {7}}, {{84}, {7}}, {{52}, {7}}, {{116}, {7}}, {{3}, {8}}, {{131}, {8}}, {{67}, {8}}, {{195}, {8}}, {{35}, {8}}, {{163}, {8}}, {{99}, {8}}, {{227}, {8}}};
+
+local const ct_data static_dtree[D_CODES] = {
+	{{0}, {5}}, {{16}, {5}}, {{8}, {5}}, {{24}, {5}}, {{4}, {5}}, {{20}, {5}}, {{12}, {5}}, {{28}, {5}}, {{2}, {5}}, {{18}, {5}}, {{10}, {5}}, {{26}, {5}}, {{6}, {5}}, {{22}, {5}}, {{14}, {5}}, {{30}, {5}}, {{1}, {5}}, {{17}, {5}}, {{9}, {5}}, {{25}, {5}}, {{5}, {5}}, {{21}, {5}}, {{13}, {5}}, {{29}, {5}}, {{3}, {5}}, {{19}, {5}}, {{11}, {5}}, {{27}, {5}}, {{7}, {5}}, {{23}, {5}}};
+
+const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = {
+	0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8,
+	8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10,
+	10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+	11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+	12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 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, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+	14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+	14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+	14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15,
+	15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+	15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+	15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 16, 17,
+	18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22,
+	23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+	24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+	26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+	26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27,
+	27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+	27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+	28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+	28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+	28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+	29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+	29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+	29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29};
+
+const uch ZLIB_INTERNAL _length_code[MAX_MATCH - MIN_MATCH + 1] = {
+	0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 12,
+	13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16,
+	17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19,
+	19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+	21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22,
+	22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23,
+	23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+	24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+	25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+	25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26,
+	26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+	26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+	27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28};
+
+local const int base_length[LENGTH_CODES] = {
+	0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56,
+	64, 80, 96, 112, 128, 160, 192, 224, 0};
+
+local const int base_dist[D_CODES] = {
+	0, 1, 2, 3, 4, 6, 8, 12, 16, 24,
+	32, 48, 64, 96, 128, 192, 256, 384, 512, 768,
+	1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576};
diff --git a/engine/inc/bullet/ThirdPartyLibs/zlib/zconf.h b/engine/inc/bullet/ThirdPartyLibs/zlib/zconf.h
new file mode 100644
index 00000000..603c2412
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/zlib/zconf.h
@@ -0,0 +1,511 @@
+/* zconf.h -- configuration of the zlib compression library
+ * Copyright (C) 1995-2013 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#ifndef ZCONF_H
+#define ZCONF_H
+
+/*
+ * If you *really* need a unique prefix for all types and library functions,
+ * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
+ * Even better than compiling with -DZ_PREFIX would be to use configure to set
+ * this permanently in zconf.h using "./configure --zprefix".
+ */
+#ifdef Z_PREFIX /* may be set to #if 1 by ./configure */
+#define Z_PREFIX_SET
+
+/* all linked symbols */
+#define _dist_code z__dist_code
+#define _length_code z__length_code
+#define _tr_align z__tr_align
+#define _tr_flush_bits z__tr_flush_bits
+#define _tr_flush_block z__tr_flush_block
+#define _tr_init z__tr_init
+#define _tr_stored_block z__tr_stored_block
+#define _tr_tally z__tr_tally
+#define adler32 z_adler32
+#define adler32_combine z_adler32_combine
+#define adler32_combine64 z_adler32_combine64
+#ifndef Z_SOLO
+#define compress z_compress
+#define compress2 z_compress2
+#define compressBound z_compressBound
+#endif
+#define crc32 z_crc32
+#define crc32_combine z_crc32_combine
+#define crc32_combine64 z_crc32_combine64
+#define deflate z_deflate
+#define deflateBound z_deflateBound
+#define deflateCopy z_deflateCopy
+#define deflateEnd z_deflateEnd
+#define deflateInit2_ z_deflateInit2_
+#define deflateInit_ z_deflateInit_
+#define deflateParams z_deflateParams
+#define deflatePending z_deflatePending
+#define deflatePrime z_deflatePrime
+#define deflateReset z_deflateReset
+#define deflateResetKeep z_deflateResetKeep
+#define deflateSetDictionary z_deflateSetDictionary
+#define deflateSetHeader z_deflateSetHeader
+#define deflateTune z_deflateTune
+#define deflate_copyright z_deflate_copyright
+#define get_crc_table z_get_crc_table
+#ifndef Z_SOLO
+#define gz_error z_gz_error
+#define gz_intmax z_gz_intmax
+#define gz_strwinerror z_gz_strwinerror
+#define gzbuffer z_gzbuffer
+#define gzclearerr z_gzclearerr
+#define gzclose z_gzclose
+#define gzclose_r z_gzclose_r
+#define gzclose_w z_gzclose_w
+#define gzdirect z_gzdirect
+#define gzdopen z_gzdopen
+#define gzeof z_gzeof
+#define gzerror z_gzerror
+#define gzflush z_gzflush
+#define gzgetc z_gzgetc
+#define gzgetc_ z_gzgetc_
+#define gzgets z_gzgets
+#define gzoffset z_gzoffset
+#define gzoffset64 z_gzoffset64
+#define gzopen z_gzopen
+#define gzopen64 z_gzopen64
+#ifdef _WIN32
+#define gzopen_w z_gzopen_w
+#endif
+#define gzprintf z_gzprintf
+#define gzvprintf z_gzvprintf
+#define gzputc z_gzputc
+#define gzputs z_gzputs
+#define gzread z_gzread
+#define gzrewind z_gzrewind
+#define gzseek z_gzseek
+#define gzseek64 z_gzseek64
+#define gzsetparams z_gzsetparams
+#define gztell z_gztell
+#define gztell64 z_gztell64
+#define gzungetc z_gzungetc
+#define gzwrite z_gzwrite
+#endif
+#define inflate z_inflate
+#define inflateBack z_inflateBack
+#define inflateBackEnd z_inflateBackEnd
+#define inflateBackInit_ z_inflateBackInit_
+#define inflateCopy z_inflateCopy
+#define inflateEnd z_inflateEnd
+#define inflateGetHeader z_inflateGetHeader
+#define inflateInit2_ z_inflateInit2_
+#define inflateInit_ z_inflateInit_
+#define inflateMark z_inflateMark
+#define inflatePrime z_inflatePrime
+#define inflateReset z_inflateReset
+#define inflateReset2 z_inflateReset2
+#define inflateSetDictionary z_inflateSetDictionary
+#define inflateGetDictionary z_inflateGetDictionary
+#define inflateSync z_inflateSync
+#define inflateSyncPoint z_inflateSyncPoint
+#define inflateUndermine z_inflateUndermine
+#define inflateResetKeep z_inflateResetKeep
+#define inflate_copyright z_inflate_copyright
+#define inflate_fast z_inflate_fast
+#define inflate_table z_inflate_table
+#ifndef Z_SOLO
+#define uncompress z_uncompress
+#endif
+#define zError z_zError
+#ifndef Z_SOLO
+#define zcalloc z_zcalloc
+#define zcfree z_zcfree
+#endif
+#define zlibCompileFlags z_zlibCompileFlags
+#define zlibVersion z_zlibVersion
+
+/* all zlib typedefs in zlib.h and zconf.h */
+#define Byte z_Byte
+#define Bytef z_Bytef
+#define alloc_func z_alloc_func
+#define charf z_charf
+#define free_func z_free_func
+#ifndef Z_SOLO
+#define gzFile z_gzFile
+#endif
+#define gz_header z_gz_header
+#define gz_headerp z_gz_headerp
+#define in_func z_in_func
+#define intf z_intf
+#define out_func z_out_func
+#define uInt z_uInt
+#define uIntf z_uIntf
+#define uLong z_uLong
+#define uLongf z_uLongf
+#define voidp z_voidp
+#define voidpc z_voidpc
+#define voidpf z_voidpf
+
+/* all zlib structs in zlib.h and zconf.h */
+#define gz_header_s z_gz_header_s
+#define internal_state z_internal_state
+
+#endif
+
+#if defined(__MSDOS__) && !defined(MSDOS)
+#define MSDOS
+#endif
+#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
+#define OS2
+#endif
+#if defined(_WINDOWS) && !defined(WINDOWS)
+#define WINDOWS
+#endif
+#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
+#ifndef WIN32
+#define WIN32
+#endif
+#endif
+#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
+#if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
+#ifndef SYS16BIT
+#define SYS16BIT
+#endif
+#endif
+#endif
+
+/*
+ * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
+ * than 64k bytes at a time (needed on systems with 16-bit int).
+ */
+#ifdef SYS16BIT
+#define MAXSEG_64K
+#endif
+#ifdef MSDOS
+#define UNALIGNED_OK
+#endif
+
+#ifdef __STDC_VERSION__
+#ifndef STDC
+#define STDC
+#endif
+#if __STDC_VERSION__ >= 199901L
+#ifndef STDC99
+#define STDC99
+#endif
+#endif
+#endif
+#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
+#define STDC
+#endif
+#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
+#define STDC
+#endif
+#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
+#define STDC
+#endif
+#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
+#define STDC
+#endif
+
+#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */
+#define STDC
+#endif
+
+#ifndef STDC
+#ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
+#define const /* note: need a more gentle solution here */
+#endif
+#endif
+
+#if defined(ZLIB_CONST) && !defined(z_const)
+#define z_const const
+#else
+#define z_const
+#endif
+
+/* Some Mac compilers merge all .h files incorrectly: */
+#if defined(__MWERKS__) || defined(applec) || defined(THINK_C) || defined(__SC__)
+#define NO_DUMMY_DECL
+#endif
+
+/* Maximum value for memLevel in deflateInit2 */
+#ifndef MAX_MEM_LEVEL
+#ifdef MAXSEG_64K
+#define MAX_MEM_LEVEL 8
+#else
+#define MAX_MEM_LEVEL 9
+#endif
+#endif
+
+/* Maximum value for windowBits in deflateInit2 and inflateInit2.
+ * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
+ * created by gzip. (Files created by minigzip can still be extracted by
+ * gzip.)
+ */
+#ifndef MAX_WBITS
+#define MAX_WBITS 15 /* 32K LZ77 window */
+#endif
+
+/* The memory requirements for deflate are (in bytes):
+            (1 << (windowBits+2)) +  (1 << (memLevel+9))
+ that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
+ plus a few kilobytes for small objects. For example, if you want to reduce
+ the default memory requirements from 256K to 128K, compile with
+     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
+ Of course this will generally degrade compression (there's no free lunch).
+
+   The memory requirements for inflate are (in bytes) 1 << windowBits
+ that is, 32K for windowBits=15 (default value) plus a few kilobytes
+ for small objects.
+*/
+
+/* Type declarations */
+
+#ifndef OF /* function prototypes */
+#ifdef STDC
+#define OF(args) args
+#else
+#define OF(args) ()
+#endif
+#endif
+
+#ifndef Z_ARG /* function prototypes for stdarg */
+#if defined(STDC) || defined(Z_HAVE_STDARG_H)
+#define Z_ARG(args) args
+#else
+#define Z_ARG(args) ()
+#endif
+#endif
+
+/* The following definitions for FAR are needed only for MSDOS mixed
+ * model programming (small or medium model with some far allocations).
+ * This was tested only with MSC; for other MSDOS compilers you may have
+ * to define NO_MEMCPY in zutil.h.  If you don't need the mixed model,
+ * just define FAR to be empty.
+ */
+#ifdef SYS16BIT
+#if defined(M_I86SM) || defined(M_I86MM)
+/* MSC small or medium model */
+#define SMALL_MEDIUM
+#ifdef _MSC_VER
+#define FAR _far
+#else
+#define FAR far
+#endif
+#endif
+#if (defined(__SMALL__) || defined(__MEDIUM__))
+/* Turbo C small or medium model */
+#define SMALL_MEDIUM
+#ifdef __BORLANDC__
+#define FAR _far
+#else
+#define FAR far
+#endif
+#endif
+#endif
+
+#if defined(WINDOWS) || defined(WIN32)
+/* If building or using zlib as a DLL, define ZLIB_DLL.
+    * This is not mandatory, but it offers a little performance increase.
+    */
+#ifdef ZLIB_DLL
+#if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
+#ifdef ZLIB_INTERNAL
+#define ZEXTERN extern __declspec(dllexport)
+#else
+#define ZEXTERN extern __declspec(dllimport)
+#endif
+#endif
+#endif /* ZLIB_DLL */
+/* If building or using zlib with the WINAPI/WINAPIV calling convention,
+    * define ZLIB_WINAPI.
+    * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
+    */
+#ifdef ZLIB_WINAPI
+#ifdef FAR
+#undef FAR
+#endif
+#include <windows.h>
+/* No need for _export, use ZLIB.DEF instead. */
+/* For complete Windows compatibility, use WINAPI, not __stdcall. */
+#define ZEXPORT WINAPI
+#ifdef WIN32
+#define ZEXPORTVA WINAPIV
+#else
+#define ZEXPORTVA FAR CDECL
+#endif
+#endif
+#endif
+
+#if defined(__BEOS__)
+#ifdef ZLIB_DLL
+#ifdef ZLIB_INTERNAL
+#define ZEXPORT __declspec(dllexport)
+#define ZEXPORTVA __declspec(dllexport)
+#else
+#define ZEXPORT __declspec(dllimport)
+#define ZEXPORTVA __declspec(dllimport)
+#endif
+#endif
+#endif
+
+#ifndef ZEXTERN
+#define ZEXTERN extern
+#endif
+#ifndef ZEXPORT
+#define ZEXPORT
+#endif
+#ifndef ZEXPORTVA
+#define ZEXPORTVA
+#endif
+
+#ifndef FAR
+#define FAR
+#endif
+
+#if !defined(__MACTYPES__)
+typedef unsigned char Byte; /* 8 bits */
+#endif
+typedef unsigned int uInt;   /* 16 bits or more */
+typedef unsigned long uLong; /* 32 bits or more */
+
+#ifdef SMALL_MEDIUM
+/* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
+#define Bytef Byte FAR
+#else
+typedef Byte FAR Bytef;
+#endif
+typedef char FAR charf;
+typedef int FAR intf;
+typedef uInt FAR uIntf;
+typedef uLong FAR uLongf;
+
+#ifdef STDC
+typedef void const *voidpc;
+typedef void FAR *voidpf;
+typedef void *voidp;
+#else
+typedef Byte const *voidpc;
+typedef Byte FAR *voidpf;
+typedef Byte *voidp;
+#endif
+
+#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC)
+#include <limits.h>
+#if (UINT_MAX == 0xffffffffUL)
+#define Z_U4 unsigned
+#elif (ULONG_MAX == 0xffffffffUL)
+#define Z_U4 unsigned long
+#elif (USHRT_MAX == 0xffffffffUL)
+#define Z_U4 unsigned short
+#endif
+#endif
+
+#ifdef Z_U4
+typedef Z_U4 z_crc_t;
+#else
+typedef unsigned long z_crc_t;
+#endif
+
+#ifdef HAVE_UNISTD_H /* may be set to #if 1 by ./configure */
+#define Z_HAVE_UNISTD_H
+#endif
+
+#ifdef HAVE_STDARG_H /* may be set to #if 1 by ./configure */
+#define Z_HAVE_STDARG_H
+#endif
+
+#ifdef STDC
+#ifndef Z_SOLO
+#include <sys/types.h> /* for off_t */
+#endif
+#endif
+
+#if defined(STDC) || defined(Z_HAVE_STDARG_H)
+#ifndef Z_SOLO
+#include <stdarg.h> /* for va_list */
+#endif
+#endif
+
+#ifdef _WIN32
+#ifndef Z_SOLO
+#include <stddef.h> /* for wchar_t */
+#endif
+#endif
+
+/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and
+ * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even
+ * though the former does not conform to the LFS document), but considering
+ * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as
+ * equivalently requesting no 64-bit operations
+ */
+#if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1
+#undef _LARGEFILE64_SOURCE
+#endif
+
+#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H)
+#define Z_HAVE_UNISTD_H
+#endif
+#ifndef Z_SOLO
+#if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE)
+#include <unistd.h> /* for SEEK_*, off_t, and _LFS64_LARGEFILE */
+#ifdef VMS
+#include <unixio.h> /* for off_t */
+#endif
+#ifndef z_off_t
+#define z_off_t off_t
+#endif
+#endif
+#endif
+
+#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE - 0
+#define Z_LFS64
+#endif
+
+#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64)
+#define Z_LARGE64
+#endif
+
+#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS - 0 == 64 && defined(Z_LFS64)
+#define Z_WANT64
+#endif
+
+#if !defined(SEEK_SET) && !defined(Z_SOLO)
+#define SEEK_SET 0 /* Seek from beginning of file.  */
+#define SEEK_CUR 1 /* Seek from current position.  */
+#define SEEK_END 2 /* Set file pointer to EOF plus "offset" */
+#endif
+
+#ifndef z_off_t
+#define z_off_t long
+#endif
+
+#if !defined(_WIN32) && defined(Z_LARGE64)
+#define z_off64_t off64_t
+#else
+#if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO)
+#define z_off64_t __int64
+#else
+#define z_off64_t z_off_t
+#endif
+#endif
+
+/* MVS linker does not support external names larger than 8 bytes */
+#if defined(__MVS__)
+#pragma map(deflateInit_, "DEIN")
+#pragma map(deflateInit2_, "DEIN2")
+#pragma map(deflateEnd, "DEEND")
+#pragma map(deflateBound, "DEBND")
+#pragma map(inflateInit_, "ININ")
+#pragma map(inflateInit2_, "ININ2")
+#pragma map(inflateEnd, "INEND")
+#pragma map(inflateSync, "INSY")
+#pragma map(inflateSetDictionary, "INSEDI")
+#pragma map(compressBound, "CMBND")
+#pragma map(inflate_table, "INTABL")
+#pragma map(inflate_fast, "INFA")
+#pragma map(inflate_copyright, "INCOPY")
+#endif
+
+#endif /* ZCONF_H */
diff --git a/engine/inc/bullet/ThirdPartyLibs/zlib/zlib.h b/engine/inc/bullet/ThirdPartyLibs/zlib/zlib.h
new file mode 100644
index 00000000..097b0540
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/zlib/zlib.h
@@ -0,0 +1,1767 @@
+/* zlib.h -- interface of the 'zlib' general purpose compression library
+  version 1.2.8, April 28th, 2013
+
+  Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Jean-loup Gailly        Mark Adler
+  jloup@gzip.org          madler@alumni.caltech.edu
+
+
+  The data format used by the zlib library is described by RFCs (Request for
+  Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950
+  (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format).
+*/
+
+#ifndef ZLIB_H
+#define ZLIB_H
+
+#include "zconf.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#define ZLIB_VERSION "1.2.8"
+#define ZLIB_VERNUM 0x1280
+#define ZLIB_VER_MAJOR 1
+#define ZLIB_VER_MINOR 2
+#define ZLIB_VER_REVISION 8
+#define ZLIB_VER_SUBREVISION 0
+
+	/*
+    The 'zlib' compression library provides in-memory compression and
+  decompression functions, including integrity checks of the uncompressed data.
+  This version of the library supports only one compression method (deflation)
+  but other algorithms will be added later and will have the same stream
+  interface.
+
+    Compression can be done in a single step if the buffers are large enough,
+  or can be done by repeated calls of the compression function.  In the latter
+  case, the application must provide more input and/or consume the output
+  (providing more output space) before each call.
+
+    The compressed data format used by default by the in-memory functions is
+  the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped
+  around a deflate stream, which is itself documented in RFC 1951.
+
+    The library also supports reading and writing files in gzip (.gz) format
+  with an interface similar to that of stdio using the functions that start
+  with "gz".  The gzip format is different from the zlib format.  gzip is a
+  gzip wrapper, documented in RFC 1952, wrapped around a deflate stream.
+
+    This library can optionally read and write gzip streams in memory as well.
+
+    The zlib format was designed to be compact and fast for use in memory
+  and on communications channels.  The gzip format was designed for single-
+  file compression on file systems, has a larger header than zlib to maintain
+  directory information, and uses a different, slower check method than zlib.
+
+    The library does not install any signal handler.  The decoder checks
+  the consistency of the compressed data, so the library should never crash
+  even in case of corrupted input.
+*/
+
+	typedef voidpf(*alloc_func) OF((voidpf opaque, uInt items, uInt size));
+	typedef void(*free_func) OF((voidpf opaque, voidpf address));
+
+	struct internal_state;
+
+	typedef struct z_stream_s
+	{
+		z_const Bytef *next_in; /* next input byte */
+		uInt avail_in;          /* number of bytes available at next_in */
+		uLong total_in;         /* total number of input bytes read so far */
+
+		Bytef *next_out; /* next output byte should be put there */
+		uInt avail_out;  /* remaining free space at next_out */
+		uLong total_out; /* total number of bytes output so far */
+
+		z_const char *msg;                /* last error message, NULL if no error */
+		struct internal_state FAR *state; /* not visible by applications */
+
+		alloc_func zalloc; /* used to allocate the internal state */
+		free_func zfree;   /* used to free the internal state */
+		voidpf opaque;     /* private data object passed to zalloc and zfree */
+
+		int data_type;  /* best guess about the data type: binary or text */
+		uLong adler;    /* adler32 value of the uncompressed data */
+		uLong reserved; /* reserved for future use */
+	} z_stream;
+
+	typedef z_stream FAR *z_streamp;
+
+	/*
+     gzip header information passed to and from zlib routines.  See RFC 1952
+  for more details on the meanings of these fields.
+*/
+	typedef struct gz_header_s
+	{
+		int text;       /* true if compressed data believed to be text */
+		uLong time;     /* modification time */
+		int xflags;     /* extra flags (not used when writing a gzip file) */
+		int os;         /* operating system */
+		Bytef *extra;   /* pointer to extra field or Z_NULL if none */
+		uInt extra_len; /* extra field length (valid if extra != Z_NULL) */
+		uInt extra_max; /* space at extra (only when reading header) */
+		Bytef *name;    /* pointer to zero-terminated file name or Z_NULL */
+		uInt name_max;  /* space at name (only when reading header) */
+		Bytef *comment; /* pointer to zero-terminated comment or Z_NULL */
+		uInt comm_max;  /* space at comment (only when reading header) */
+		int hcrc;       /* true if there was or will be a header crc */
+		int done;       /* true when done reading gzip header (not used
+                           when writing a gzip file) */
+	} gz_header;
+
+	typedef gz_header FAR *gz_headerp;
+
+	/*
+     The application must update next_in and avail_in when avail_in has dropped
+   to zero.  It must update next_out and avail_out when avail_out has dropped
+   to zero.  The application must initialize zalloc, zfree and opaque before
+   calling the init function.  All other fields are set by the compression
+   library and must not be updated by the application.
+
+     The opaque value provided by the application will be passed as the first
+   parameter for calls of zalloc and zfree.  This can be useful for custom
+   memory management.  The compression library attaches no meaning to the
+   opaque value.
+
+     zalloc must return Z_NULL if there is not enough memory for the object.
+   If zlib is used in a multi-threaded application, zalloc and zfree must be
+   thread safe.
+
+     On 16-bit systems, the functions zalloc and zfree must be able to allocate
+   exactly 65536 bytes, but will not be required to allocate more than this if
+   the symbol MAXSEG_64K is defined (see zconf.h).  WARNING: On MSDOS, pointers
+   returned by zalloc for objects of exactly 65536 bytes *must* have their
+   offset normalized to zero.  The default allocation function provided by this
+   library ensures this (see zutil.c).  To reduce memory requirements and avoid
+   any allocation of 64K objects, at the expense of compression ratio, compile
+   the library with -DMAX_WBITS=14 (see zconf.h).
+
+     The fields total_in and total_out can be used for statistics or progress
+   reports.  After compression, total_in holds the total size of the
+   uncompressed data and may be saved for use in the decompressor (particularly
+   if the decompressor wants to decompress everything in a single step).
+*/
+
+	/* constants */
+
+#define Z_NO_FLUSH 0
+#define Z_PARTIAL_FLUSH 1
+#define Z_SYNC_FLUSH 2
+#define Z_FULL_FLUSH 3
+#define Z_FINISH 4
+#define Z_BLOCK 5
+#define Z_TREES 6
+	/* Allowed flush values; see deflate() and inflate() below for details */
+
+#define Z_OK 0
+#define Z_STREAM_END 1
+#define Z_NEED_DICT 2
+#define Z_ERRNO (-1)
+#define Z_STREAM_ERROR (-2)
+#define Z_DATA_ERROR (-3)
+#define Z_MEM_ERROR (-4)
+#define Z_BUF_ERROR (-5)
+#define Z_VERSION_ERROR (-6)
+	/* Return codes for the compression/decompression functions. Negative values
+ * are errors, positive values are used for special but normal events.
+ */
+
+#define Z_NO_COMPRESSION 0
+#define Z_BEST_SPEED 1
+#define Z_BEST_COMPRESSION 9
+#define Z_DEFAULT_COMPRESSION (-1)
+	/* compression levels */
+
+#define Z_FILTERED 1
+#define Z_HUFFMAN_ONLY 2
+#define Z_RLE 3
+#define Z_FIXED 4
+#define Z_DEFAULT_STRATEGY 0
+	/* compression strategy; see deflateInit2() below for details */
+
+#define Z_BINARY 0
+#define Z_TEXT 1
+#define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */
+#define Z_UNKNOWN 2
+	/* Possible values of the data_type field (though see inflate()) */
+
+#define Z_DEFLATED 8
+	/* The deflate compression method (the only one supported in this version) */
+
+#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */
+
+#define zlib_version zlibVersion()
+	/* for compatibility with versions < 1.0.2 */
+
+	/* basic functions */
+
+	ZEXTERN const char *ZEXPORT zlibVersion OF((void));
+	/* The application can compare zlibVersion and ZLIB_VERSION for consistency.
+   If the first character differs, the library code actually used is not
+   compatible with the zlib.h header file used by the application.  This check
+   is automatically made by deflateInit and inflateInit.
+ */
+
+	/*
+ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level));
+
+     Initializes the internal stream state for compression.  The fields
+   zalloc, zfree and opaque must be initialized before by the caller.  If
+   zalloc and zfree are set to Z_NULL, deflateInit updates them to use default
+   allocation functions.
+
+     The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
+   1 gives best speed, 9 gives best compression, 0 gives no compression at all
+   (the input data is simply copied a block at a time).  Z_DEFAULT_COMPRESSION
+   requests a default compromise between speed and compression (currently
+   equivalent to level 6).
+
+     deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if level is not a valid compression level, or
+   Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
+   with the version assumed by the caller (ZLIB_VERSION).  msg is set to null
+   if there is no error message.  deflateInit does not perform any compression:
+   this will be done by deflate().
+*/
+
+	ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
+	/*
+    deflate compresses as much data as possible, and stops when the input
+  buffer becomes empty or the output buffer becomes full.  It may introduce
+  some output latency (reading input without producing any output) except when
+  forced to flush.
+
+    The detailed semantics are as follows.  deflate performs one or both of the
+  following actions:
+
+  - Compress more input starting at next_in and update next_in and avail_in
+    accordingly.  If not all input can be processed (because there is not
+    enough room in the output buffer), next_in and avail_in are updated and
+    processing will resume at this point for the next call of deflate().
+
+  - Provide more output starting at next_out and update next_out and avail_out
+    accordingly.  This action is forced if the parameter flush is non zero.
+    Forcing flush frequently degrades the compression ratio, so this parameter
+    should be set only when necessary (in interactive applications).  Some
+    output may be provided even if flush is not set.
+
+    Before the call of deflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming more
+  output, and updating avail_in or avail_out accordingly; avail_out should
+  never be zero before the call.  The application can consume the compressed
+  output when it wants, for example when the output buffer is full (avail_out
+  == 0), or after each call of deflate().  If deflate returns Z_OK and with
+  zero avail_out, it must be called again after making room in the output
+  buffer because there might be more output pending.
+
+    Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to
+  decide how much data to accumulate before producing output, in order to
+  maximize compression.
+
+    If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
+  flushed to the output buffer and the output is aligned on a byte boundary, so
+  that the decompressor can get all input data available so far.  (In
+  particular avail_in is zero after the call if enough output space has been
+  provided before the call.) Flushing may degrade compression for some
+  compression algorithms and so it should be used only when necessary.  This
+  completes the current deflate block and follows it with an empty stored block
+  that is three bits plus filler bits to the next byte, followed by four bytes
+  (00 00 ff ff).
+
+    If flush is set to Z_PARTIAL_FLUSH, all pending output is flushed to the
+  output buffer, but the output is not aligned to a byte boundary.  All of the
+  input data so far will be available to the decompressor, as for Z_SYNC_FLUSH.
+  This completes the current deflate block and follows it with an empty fixed
+  codes block that is 10 bits long.  This assures that enough bytes are output
+  in order for the decompressor to finish the block before the empty fixed code
+  block.
+
+    If flush is set to Z_BLOCK, a deflate block is completed and emitted, as
+  for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to
+  seven bits of the current block are held to be written as the next byte after
+  the next deflate block is completed.  In this case, the decompressor may not
+  be provided enough bits at this point in order to complete decompression of
+  the data provided so far to the compressor.  It may need to wait for the next
+  block to be emitted.  This is for advanced applications that need to control
+  the emission of deflate blocks.
+
+    If flush is set to Z_FULL_FLUSH, all output is flushed as with
+  Z_SYNC_FLUSH, and the compression state is reset so that decompression can
+  restart from this point if previous compressed data has been damaged or if
+  random access is desired.  Using Z_FULL_FLUSH too often can seriously degrade
+  compression.
+
+    If deflate returns with avail_out == 0, this function must be called again
+  with the same value of the flush parameter and more output space (updated
+  avail_out), until the flush is complete (deflate returns with non-zero
+  avail_out).  In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that
+  avail_out is greater than six to avoid repeated flush markers due to
+  avail_out == 0 on return.
+
+    If the parameter flush is set to Z_FINISH, pending input is processed,
+  pending output is flushed and deflate returns with Z_STREAM_END if there was
+  enough output space; if deflate returns with Z_OK, this function must be
+  called again with Z_FINISH and more output space (updated avail_out) but no
+  more input data, until it returns with Z_STREAM_END or an error.  After
+  deflate has returned Z_STREAM_END, the only possible operations on the stream
+  are deflateReset or deflateEnd.
+
+    Z_FINISH can be used immediately after deflateInit if all the compression
+  is to be done in a single step.  In this case, avail_out must be at least the
+  value returned by deflateBound (see below).  Then deflate is guaranteed to
+  return Z_STREAM_END.  If not enough output space is provided, deflate will
+  not return Z_STREAM_END, and it must be called again as described above.
+
+    deflate() sets strm->adler to the adler32 checksum of all input read
+  so far (that is, total_in bytes).
+
+    deflate() may update strm->data_type if it can make a good guess about
+  the input data type (Z_BINARY or Z_TEXT).  In doubt, the data is considered
+  binary.  This field is only for information purposes and does not affect the
+  compression algorithm in any manner.
+
+    deflate() returns Z_OK if some progress has been made (more input
+  processed or more output produced), Z_STREAM_END if all input has been
+  consumed and all output has been produced (only when flush is set to
+  Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
+  if next_in or next_out was Z_NULL), Z_BUF_ERROR if no progress is possible
+  (for example avail_in or avail_out was zero).  Note that Z_BUF_ERROR is not
+  fatal, and deflate() can be called again with more input and more output
+  space to continue compressing.
+*/
+
+	ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm));
+	/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any pending
+   output.
+
+     deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
+   stream state was inconsistent, Z_DATA_ERROR if the stream was freed
+   prematurely (some input or output was discarded).  In the error case, msg
+   may be set but then points to a static string (which must not be
+   deallocated).
+*/
+
+	/*
+ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
+
+     Initializes the internal stream state for decompression.  The fields
+   next_in, avail_in, zalloc, zfree and opaque must be initialized before by
+   the caller.  If next_in is not Z_NULL and avail_in is large enough (the
+   exact value depends on the compression method), inflateInit determines the
+   compression method from the zlib header and allocates all data structures
+   accordingly; otherwise the allocation will be deferred to the first call of
+   inflate.  If zalloc and zfree are set to Z_NULL, inflateInit updates them to
+   use default allocation functions.
+
+     inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
+   version assumed by the caller, or Z_STREAM_ERROR if the parameters are
+   invalid, such as a null pointer to the structure.  msg is set to null if
+   there is no error message.  inflateInit does not perform any decompression
+   apart from possibly reading the zlib header if present: actual decompression
+   will be done by inflate().  (So next_in and avail_in may be modified, but
+   next_out and avail_out are unused and unchanged.) The current implementation
+   of inflateInit() does not process any header information -- that is deferred
+   until inflate() is called.
+*/
+
+	ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
+	/*
+    inflate decompresses as much data as possible, and stops when the input
+  buffer becomes empty or the output buffer becomes full.  It may introduce
+  some output latency (reading input without producing any output) except when
+  forced to flush.
+
+  The detailed semantics are as follows.  inflate performs one or both of the
+  following actions:
+
+  - Decompress more input starting at next_in and update next_in and avail_in
+    accordingly.  If not all input can be processed (because there is not
+    enough room in the output buffer), next_in is updated and processing will
+    resume at this point for the next call of inflate().
+
+  - Provide more output starting at next_out and update next_out and avail_out
+    accordingly.  inflate() provides as much output as possible, until there is
+    no more input data or no more space in the output buffer (see below about
+    the flush parameter).
+
+    Before the call of inflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming more
+  output, and updating the next_* and avail_* values accordingly.  The
+  application can consume the uncompressed output when it wants, for example
+  when the output buffer is full (avail_out == 0), or after each call of
+  inflate().  If inflate returns Z_OK and with zero avail_out, it must be
+  called again after making room in the output buffer because there might be
+  more output pending.
+
+    The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, Z_FINISH,
+  Z_BLOCK, or Z_TREES.  Z_SYNC_FLUSH requests that inflate() flush as much
+  output as possible to the output buffer.  Z_BLOCK requests that inflate()
+  stop if and when it gets to the next deflate block boundary.  When decoding
+  the zlib or gzip format, this will cause inflate() to return immediately
+  after the header and before the first block.  When doing a raw inflate,
+  inflate() will go ahead and process the first block, and will return when it
+  gets to the end of that block, or when it runs out of data.
+
+    The Z_BLOCK option assists in appending to or combining deflate streams.
+  Also to assist in this, on return inflate() will set strm->data_type to the
+  number of unused bits in the last byte taken from strm->next_in, plus 64 if
+  inflate() is currently decoding the last block in the deflate stream, plus
+  128 if inflate() returned immediately after decoding an end-of-block code or
+  decoding the complete header up to just before the first byte of the deflate
+  stream.  The end-of-block will not be indicated until all of the uncompressed
+  data from that block has been written to strm->next_out.  The number of
+  unused bits may in general be greater than seven, except when bit 7 of
+  data_type is set, in which case the number of unused bits will be less than
+  eight.  data_type is set as noted here every time inflate() returns for all
+  flush options, and so can be used to determine the amount of currently
+  consumed input in bits.
+
+    The Z_TREES option behaves as Z_BLOCK does, but it also returns when the
+  end of each deflate block header is reached, before any actual data in that
+  block is decoded.  This allows the caller to determine the length of the
+  deflate block header for later use in random access within a deflate block.
+  256 is added to the value of strm->data_type when inflate() returns
+  immediately after reaching the end of the deflate block header.
+
+    inflate() should normally be called until it returns Z_STREAM_END or an
+  error.  However if all decompression is to be performed in a single step (a
+  single call of inflate), the parameter flush should be set to Z_FINISH.  In
+  this case all pending input is processed and all pending output is flushed;
+  avail_out must be large enough to hold all of the uncompressed data for the
+  operation to complete.  (The size of the uncompressed data may have been
+  saved by the compressor for this purpose.) The use of Z_FINISH is not
+  required to perform an inflation in one step.  However it may be used to
+  inform inflate that a faster approach can be used for the single inflate()
+  call.  Z_FINISH also informs inflate to not maintain a sliding window if the
+  stream completes, which reduces inflate's memory footprint.  If the stream
+  does not complete, either because not all of the stream is provided or not
+  enough output space is provided, then a sliding window will be allocated and
+  inflate() can be called again to continue the operation as if Z_NO_FLUSH had
+  been used.
+
+     In this implementation, inflate() always flushes as much output as
+  possible to the output buffer, and always uses the faster approach on the
+  first call.  So the effects of the flush parameter in this implementation are
+  on the return value of inflate() as noted below, when inflate() returns early
+  when Z_BLOCK or Z_TREES is used, and when inflate() avoids the allocation of
+  memory for a sliding window when Z_FINISH is used.
+
+     If a preset dictionary is needed after this call (see inflateSetDictionary
+  below), inflate sets strm->adler to the Adler-32 checksum of the dictionary
+  chosen by the compressor and returns Z_NEED_DICT; otherwise it sets
+  strm->adler to the Adler-32 checksum of all output produced so far (that is,
+  total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described
+  below.  At the end of the stream, inflate() checks that its computed adler32
+  checksum is equal to that saved by the compressor and returns Z_STREAM_END
+  only if the checksum is correct.
+
+    inflate() can decompress and check either zlib-wrapped or gzip-wrapped
+  deflate data.  The header type is detected automatically, if requested when
+  initializing with inflateInit2().  Any information contained in the gzip
+  header is not retained, so applications that need that information should
+  instead use raw inflate, see inflateInit2() below, or inflateBack() and
+  perform their own processing of the gzip header and trailer.  When processing
+  gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output
+  producted so far.  The CRC-32 is checked against the gzip trailer.
+
+    inflate() returns Z_OK if some progress has been made (more input processed
+  or more output produced), Z_STREAM_END if the end of the compressed data has
+  been reached and all uncompressed output has been produced, Z_NEED_DICT if a
+  preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
+  corrupted (input stream not conforming to the zlib format or incorrect check
+  value), Z_STREAM_ERROR if the stream structure was inconsistent (for example
+  next_in or next_out was Z_NULL), Z_MEM_ERROR if there was not enough memory,
+  Z_BUF_ERROR if no progress is possible or if there was not enough room in the
+  output buffer when Z_FINISH is used.  Note that Z_BUF_ERROR is not fatal, and
+  inflate() can be called again with more input and more output space to
+  continue decompressing.  If Z_DATA_ERROR is returned, the application may
+  then call inflateSync() to look for a good compression block if a partial
+  recovery of the data is desired.
+*/
+
+	ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
+	/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any pending
+   output.
+
+     inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
+   was inconsistent.  In the error case, msg may be set but then points to a
+   static string (which must not be deallocated).
+*/
+
+	/* Advanced functions */
+
+	/*
+    The following functions are needed only in some special applications.
+*/
+
+	/*
+ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
+                                     int  level,
+                                     int  method,
+                                     int  windowBits,
+                                     int  memLevel,
+                                     int  strategy));
+
+     This is another version of deflateInit with more compression options.  The
+   fields next_in, zalloc, zfree and opaque must be initialized before by the
+   caller.
+
+     The method parameter is the compression method.  It must be Z_DEFLATED in
+   this version of the library.
+
+     The windowBits parameter is the base two logarithm of the window size
+   (the size of the history buffer).  It should be in the range 8..15 for this
+   version of the library.  Larger values of this parameter result in better
+   compression at the expense of memory usage.  The default value is 15 if
+   deflateInit is used instead.
+
+     windowBits can also be -8..-15 for raw deflate.  In this case, -windowBits
+   determines the window size.  deflate() will then generate raw deflate data
+   with no zlib header or trailer, and will not compute an adler32 check value.
+
+     windowBits can also be greater than 15 for optional gzip encoding.  Add
+   16 to windowBits to write a simple gzip header and trailer around the
+   compressed data instead of a zlib wrapper.  The gzip header will have no
+   file name, no extra data, no comment, no modification time (set to zero), no
+   header crc, and the operating system will be set to 255 (unknown).  If a
+   gzip stream is being written, strm->adler is a crc32 instead of an adler32.
+
+     The memLevel parameter specifies how much memory should be allocated
+   for the internal compression state.  memLevel=1 uses minimum memory but is
+   slow and reduces compression ratio; memLevel=9 uses maximum memory for
+   optimal speed.  The default value is 8.  See zconf.h for total memory usage
+   as a function of windowBits and memLevel.
+
+     The strategy parameter is used to tune the compression algorithm.  Use the
+   value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
+   filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no
+   string match), or Z_RLE to limit match distances to one (run-length
+   encoding).  Filtered data consists mostly of small values with a somewhat
+   random distribution.  In this case, the compression algorithm is tuned to
+   compress them better.  The effect of Z_FILTERED is to force more Huffman
+   coding and less string matching; it is somewhat intermediate between
+   Z_DEFAULT_STRATEGY and Z_HUFFMAN_ONLY.  Z_RLE is designed to be almost as
+   fast as Z_HUFFMAN_ONLY, but give better compression for PNG image data.  The
+   strategy parameter only affects the compression ratio but not the
+   correctness of the compressed output even if it is not set appropriately.
+   Z_FIXED prevents the use of dynamic Huffman codes, allowing for a simpler
+   decoder for special applications.
+
+     deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if any parameter is invalid (such as an invalid
+   method), or Z_VERSION_ERROR if the zlib library version (zlib_version) is
+   incompatible with the version assumed by the caller (ZLIB_VERSION).  msg is
+   set to null if there is no error message.  deflateInit2 does not perform any
+   compression: this will be done by deflate().
+*/
+
+	ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
+												 const Bytef *dictionary,
+												 uInt dictLength));
+	/*
+     Initializes the compression dictionary from the given byte sequence
+   without producing any compressed output.  When using the zlib format, this
+   function must be called immediately after deflateInit, deflateInit2 or
+   deflateReset, and before any call of deflate.  When doing raw deflate, this
+   function must be called either before any call of deflate, or immediately
+   after the completion of a deflate block, i.e. after all input has been
+   consumed and all output has been delivered when using any of the flush
+   options Z_BLOCK, Z_PARTIAL_FLUSH, Z_SYNC_FLUSH, or Z_FULL_FLUSH.  The
+   compressor and decompressor must use exactly the same dictionary (see
+   inflateSetDictionary).
+
+     The dictionary should consist of strings (byte sequences) that are likely
+   to be encountered later in the data to be compressed, with the most commonly
+   used strings preferably put towards the end of the dictionary.  Using a
+   dictionary is most useful when the data to be compressed is short and can be
+   predicted with good accuracy; the data can then be compressed better than
+   with the default empty dictionary.
+
+     Depending on the size of the compression data structures selected by
+   deflateInit or deflateInit2, a part of the dictionary may in effect be
+   discarded, for example if the dictionary is larger than the window size
+   provided in deflateInit or deflateInit2.  Thus the strings most likely to be
+   useful should be put at the end of the dictionary, not at the front.  In
+   addition, the current implementation of deflate will use at most the window
+   size minus 262 bytes of the provided dictionary.
+
+     Upon return of this function, strm->adler is set to the adler32 value
+   of the dictionary; the decompressor may later use this value to determine
+   which dictionary has been used by the compressor.  (The adler32 value
+   applies to the whole dictionary even if only a subset of the dictionary is
+   actually used by the compressor.) If a raw deflate was requested, then the
+   adler32 value is not computed and strm->adler is not set.
+
+     deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
+   parameter is invalid (e.g.  dictionary being Z_NULL) or the stream state is
+   inconsistent (for example if deflate has already been called for this stream
+   or if not at a block boundary for raw deflate).  deflateSetDictionary does
+   not perform any compression: this will be done by deflate().
+*/
+
+	ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
+										z_streamp source));
+	/*
+     Sets the destination stream as a complete copy of the source stream.
+
+     This function can be useful when several compression strategies will be
+   tried, for example when there are several ways of pre-processing the input
+   data with a filter.  The streams that will be discarded should then be freed
+   by calling deflateEnd.  Note that deflateCopy duplicates the internal
+   compression state which can be quite large, so this strategy is slow and can
+   consume lots of memory.
+
+     deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
+   (such as zalloc being Z_NULL).  msg is left unchanged in both source and
+   destination.
+*/
+
+	ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
+	/*
+     This function is equivalent to deflateEnd followed by deflateInit,
+   but does not free and reallocate all the internal compression state.  The
+   stream will keep the same compression level and any other attributes that
+   may have been set by deflateInit2.
+
+     deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being Z_NULL).
+*/
+
+	ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
+										  int level,
+										  int strategy));
+	/*
+     Dynamically update the compression level and compression strategy.  The
+   interpretation of level and strategy is as in deflateInit2.  This can be
+   used to switch between compression and straight copy of the input data, or
+   to switch to a different kind of input data requiring a different strategy.
+   If the compression level is changed, the input available so far is
+   compressed with the old level (and may be flushed); the new level will take
+   effect only at the next call of deflate().
+
+     Before the call of deflateParams, the stream state must be set as for
+   a call of deflate(), since the currently available input may have to be
+   compressed and flushed.  In particular, strm->avail_out must be non-zero.
+
+     deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
+   stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR if
+   strm->avail_out was zero.
+*/
+
+	ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm,
+										int good_length,
+										int max_lazy,
+										int nice_length,
+										int max_chain));
+	/*
+     Fine tune deflate's internal compression parameters.  This should only be
+   used by someone who understands the algorithm used by zlib's deflate for
+   searching for the best matching string, and even then only by the most
+   fanatic optimizer trying to squeeze out the last compressed bit for their
+   specific input data.  Read the deflate.c source code for the meaning of the
+   max_lazy, good_length, nice_length, and max_chain parameters.
+
+     deflateTune() can be called after deflateInit() or deflateInit2(), and
+   returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream.
+ */
+
+	ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm,
+										   uLong sourceLen));
+	/*
+     deflateBound() returns an upper bound on the compressed size after
+   deflation of sourceLen bytes.  It must be called after deflateInit() or
+   deflateInit2(), and after deflateSetHeader(), if used.  This would be used
+   to allocate an output buffer for deflation in a single pass, and so would be
+   called before deflate().  If that first deflate() call is provided the
+   sourceLen input bytes, an output buffer allocated to the size returned by
+   deflateBound(), and the flush value Z_FINISH, then deflate() is guaranteed
+   to return Z_STREAM_END.  Note that it is possible for the compressed size to
+   be larger than the value returned by deflateBound() if flush options other
+   than Z_FINISH or Z_NO_FLUSH are used.
+*/
+
+	ZEXTERN int ZEXPORT deflatePending OF((z_streamp strm,
+										   unsigned *pending,
+										   int *bits));
+	/*
+     deflatePending() returns the number of bytes and bits of output that have
+   been generated, but not yet provided in the available output.  The bytes not
+   provided would be due to the available output space having being consumed.
+   The number of bits of output not provided are between 0 and 7, where they
+   await more bits to join them in order to fill out a full byte.  If pending
+   or bits are Z_NULL, then those values are not set.
+
+     deflatePending returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+ */
+
+	ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm,
+										 int bits,
+										 int value));
+	/*
+     deflatePrime() inserts bits in the deflate output stream.  The intent
+   is that this function is used to start off the deflate output with the bits
+   leftover from a previous deflate stream when appending to it.  As such, this
+   function can only be used for raw deflate, and must be used before the first
+   deflate() call after a deflateInit2() or deflateReset().  bits must be less
+   than or equal to 16, and that many of the least significant bits of value
+   will be inserted in the output.
+
+     deflatePrime returns Z_OK if success, Z_BUF_ERROR if there was not enough
+   room in the internal buffer to insert the bits, or Z_STREAM_ERROR if the
+   source stream state was inconsistent.
+*/
+
+	ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm,
+											 gz_headerp head));
+	/*
+     deflateSetHeader() provides gzip header information for when a gzip
+   stream is requested by deflateInit2().  deflateSetHeader() may be called
+   after deflateInit2() or deflateReset() and before the first call of
+   deflate().  The text, time, os, extra field, name, and comment information
+   in the provided gz_header structure are written to the gzip header (xflag is
+   ignored -- the extra flags are set according to the compression level).  The
+   caller must assure that, if not Z_NULL, name and comment are terminated with
+   a zero byte, and that if extra is not Z_NULL, that extra_len bytes are
+   available there.  If hcrc is true, a gzip header crc is included.  Note that
+   the current versions of the command-line version of gzip (up through version
+   1.3.x) do not support header crc's, and will report that it is a "multi-part
+   gzip file" and give up.
+
+     If deflateSetHeader is not used, the default gzip header has text false,
+   the time set to zero, and os set to 255, with no extra, name, or comment
+   fields.  The gzip header is returned to the default state by deflateReset().
+
+     deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+	/*
+ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
+                                     int  windowBits));
+
+     This is another version of inflateInit with an extra parameter.  The
+   fields next_in, avail_in, zalloc, zfree and opaque must be initialized
+   before by the caller.
+
+     The windowBits parameter is the base two logarithm of the maximum window
+   size (the size of the history buffer).  It should be in the range 8..15 for
+   this version of the library.  The default value is 15 if inflateInit is used
+   instead.  windowBits must be greater than or equal to the windowBits value
+   provided to deflateInit2() while compressing, or it must be equal to 15 if
+   deflateInit2() was not used.  If a compressed stream with a larger window
+   size is given as input, inflate() will return with the error code
+   Z_DATA_ERROR instead of trying to allocate a larger window.
+
+     windowBits can also be zero to request that inflate use the window size in
+   the zlib header of the compressed stream.
+
+     windowBits can also be -8..-15 for raw inflate.  In this case, -windowBits
+   determines the window size.  inflate() will then process raw deflate data,
+   not looking for a zlib or gzip header, not generating a check value, and not
+   looking for any check values for comparison at the end of the stream.  This
+   is for use with other formats that use the deflate compressed data format
+   such as zip.  Those formats provide their own check values.  If a custom
+   format is developed using the raw deflate format for compressed data, it is
+   recommended that a check value such as an adler32 or a crc32 be applied to
+   the uncompressed data as is done in the zlib, gzip, and zip formats.  For
+   most applications, the zlib format should be used as is.  Note that comments
+   above on the use in deflateInit2() applies to the magnitude of windowBits.
+
+     windowBits can also be greater than 15 for optional gzip decoding.  Add
+   32 to windowBits to enable zlib and gzip decoding with automatic header
+   detection, or add 16 to decode only the gzip format (the zlib format will
+   return a Z_DATA_ERROR).  If a gzip stream is being decoded, strm->adler is a
+   crc32 instead of an adler32.
+
+     inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
+   version assumed by the caller, or Z_STREAM_ERROR if the parameters are
+   invalid, such as a null pointer to the structure.  msg is set to null if
+   there is no error message.  inflateInit2 does not perform any decompression
+   apart from possibly reading the zlib header if present: actual decompression
+   will be done by inflate().  (So next_in and avail_in may be modified, but
+   next_out and avail_out are unused and unchanged.) The current implementation
+   of inflateInit2() does not process any header information -- that is
+   deferred until inflate() is called.
+*/
+
+	ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
+												 const Bytef *dictionary,
+												 uInt dictLength));
+	/*
+     Initializes the decompression dictionary from the given uncompressed byte
+   sequence.  This function must be called immediately after a call of inflate,
+   if that call returned Z_NEED_DICT.  The dictionary chosen by the compressor
+   can be determined from the adler32 value returned by that call of inflate.
+   The compressor and decompressor must use exactly the same dictionary (see
+   deflateSetDictionary).  For raw inflate, this function can be called at any
+   time to set the dictionary.  If the provided dictionary is smaller than the
+   window and there is already data in the window, then the provided dictionary
+   will amend what's there.  The application must insure that the dictionary
+   that was used for compression is provided.
+
+     inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
+   parameter is invalid (e.g.  dictionary being Z_NULL) or the stream state is
+   inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
+   expected one (incorrect adler32 value).  inflateSetDictionary does not
+   perform any decompression: this will be done by subsequent calls of
+   inflate().
+*/
+
+	ZEXTERN int ZEXPORT inflateGetDictionary OF((z_streamp strm,
+												 Bytef *dictionary,
+												 uInt *dictLength));
+	/*
+     Returns the sliding dictionary being maintained by inflate.  dictLength is
+   set to the number of bytes in the dictionary, and that many bytes are copied
+   to dictionary.  dictionary must have enough space, where 32768 bytes is
+   always enough.  If inflateGetDictionary() is called with dictionary equal to
+   Z_NULL, then only the dictionary length is returned, and nothing is copied.
+   Similary, if dictLength is Z_NULL, then it is not set.
+
+     inflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the
+   stream state is inconsistent.
+*/
+
+	ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm));
+	/*
+     Skips invalid compressed data until a possible full flush point (see above
+   for the description of deflate with Z_FULL_FLUSH) can be found, or until all
+   available input is skipped.  No output is provided.
+
+     inflateSync searches for a 00 00 FF FF pattern in the compressed data.
+   All full flush points have this pattern, but not all occurrences of this
+   pattern are full flush points.
+
+     inflateSync returns Z_OK if a possible full flush point has been found,
+   Z_BUF_ERROR if no more input was provided, Z_DATA_ERROR if no flush point
+   has been found, or Z_STREAM_ERROR if the stream structure was inconsistent.
+   In the success case, the application may save the current current value of
+   total_in which indicates where valid compressed data was found.  In the
+   error case, the application may repeatedly call inflateSync, providing more
+   input each time, until success or end of the input data.
+*/
+
+	ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest,
+										z_streamp source));
+	/*
+     Sets the destination stream as a complete copy of the source stream.
+
+     This function can be useful when randomly accessing a large stream.  The
+   first pass through the stream can periodically record the inflate state,
+   allowing restarting inflate at those points when randomly accessing the
+   stream.
+
+     inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
+   (such as zalloc being Z_NULL).  msg is left unchanged in both source and
+   destination.
+*/
+
+	ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
+	/*
+     This function is equivalent to inflateEnd followed by inflateInit,
+   but does not free and reallocate all the internal decompression state.  The
+   stream will keep attributes that may have been set by inflateInit2.
+
+     inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being Z_NULL).
+*/
+
+	ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm,
+										  int windowBits));
+	/*
+     This function is the same as inflateReset, but it also permits changing
+   the wrap and window size requests.  The windowBits parameter is interpreted
+   the same as it is for inflateInit2.
+
+     inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being Z_NULL), or if
+   the windowBits parameter is invalid.
+*/
+
+	ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm,
+										 int bits,
+										 int value));
+	/*
+     This function inserts bits in the inflate input stream.  The intent is
+   that this function is used to start inflating at a bit position in the
+   middle of a byte.  The provided bits will be used before any bytes are used
+   from next_in.  This function should only be used with raw inflate, and
+   should be used before the first inflate() call after inflateInit2() or
+   inflateReset().  bits must be less than or equal to 16, and that many of the
+   least significant bits of value will be inserted in the input.
+
+     If bits is negative, then the input stream bit buffer is emptied.  Then
+   inflatePrime() can be called again to put bits in the buffer.  This is used
+   to clear out bits leftover after feeding inflate a block description prior
+   to feeding inflate codes.
+
+     inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+	ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm));
+	/*
+     This function returns two values, one in the lower 16 bits of the return
+   value, and the other in the remaining upper bits, obtained by shifting the
+   return value down 16 bits.  If the upper value is -1 and the lower value is
+   zero, then inflate() is currently decoding information outside of a block.
+   If the upper value is -1 and the lower value is non-zero, then inflate is in
+   the middle of a stored block, with the lower value equaling the number of
+   bytes from the input remaining to copy.  If the upper value is not -1, then
+   it is the number of bits back from the current bit position in the input of
+   the code (literal or length/distance pair) currently being processed.  In
+   that case the lower value is the number of bytes already emitted for that
+   code.
+
+     A code is being processed if inflate is waiting for more input to complete
+   decoding of the code, or if it has completed decoding but is waiting for
+   more output space to write the literal or match data.
+
+     inflateMark() is used to mark locations in the input data for random
+   access, which may be at bit positions, and to note those cases where the
+   output of a code may span boundaries of random access blocks.  The current
+   location in the input stream can be determined from avail_in and data_type
+   as noted in the description for the Z_BLOCK flush parameter for inflate.
+
+     inflateMark returns the value noted above or -1 << 16 if the provided
+   source stream state was inconsistent.
+*/
+
+	ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm,
+											 gz_headerp head));
+	/*
+     inflateGetHeader() requests that gzip header information be stored in the
+   provided gz_header structure.  inflateGetHeader() may be called after
+   inflateInit2() or inflateReset(), and before the first call of inflate().
+   As inflate() processes the gzip stream, head->done is zero until the header
+   is completed, at which time head->done is set to one.  If a zlib stream is
+   being decoded, then head->done is set to -1 to indicate that there will be
+   no gzip header information forthcoming.  Note that Z_BLOCK or Z_TREES can be
+   used to force inflate() to return immediately after header processing is
+   complete and before any actual data is decompressed.
+
+     The text, time, xflags, and os fields are filled in with the gzip header
+   contents.  hcrc is set to true if there is a header CRC.  (The header CRC
+   was valid if done is set to one.) If extra is not Z_NULL, then extra_max
+   contains the maximum number of bytes to write to extra.  Once done is true,
+   extra_len contains the actual extra field length, and extra contains the
+   extra field, or that field truncated if extra_max is less than extra_len.
+   If name is not Z_NULL, then up to name_max characters are written there,
+   terminated with a zero unless the length is greater than name_max.  If
+   comment is not Z_NULL, then up to comm_max characters are written there,
+   terminated with a zero unless the length is greater than comm_max.  When any
+   of extra, name, or comment are not Z_NULL and the respective field is not
+   present in the header, then that field is set to Z_NULL to signal its
+   absence.  This allows the use of deflateSetHeader() with the returned
+   structure to duplicate the header.  However if those fields are set to
+   allocated memory, then the application will need to save those pointers
+   elsewhere so that they can be eventually freed.
+
+     If inflateGetHeader is not used, then the header information is simply
+   discarded.  The header is always checked for validity, including the header
+   CRC if present.  inflateReset() will reset the process to discard the header
+   information.  The application would need to call inflateGetHeader() again to
+   retrieve the header from the next gzip stream.
+
+     inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+	/*
+ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits,
+                                        unsigned char FAR *window));
+
+     Initialize the internal stream state for decompression using inflateBack()
+   calls.  The fields zalloc, zfree and opaque in strm must be initialized
+   before the call.  If zalloc and zfree are Z_NULL, then the default library-
+   derived memory allocation routines are used.  windowBits is the base two
+   logarithm of the window size, in the range 8..15.  window is a caller
+   supplied buffer of that size.  Except for special applications where it is
+   assured that deflate was used with small window sizes, windowBits must be 15
+   and a 32K byte window must be supplied to be able to decompress general
+   deflate streams.
+
+     See inflateBack() for the usage of these routines.
+
+     inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of
+   the parameters are invalid, Z_MEM_ERROR if the internal state could not be
+   allocated, or Z_VERSION_ERROR if the version of the library does not match
+   the version of the header file.
+*/
+
+	typedef unsigned(*in_func) OF((void FAR *,
+								   z_const unsigned char FAR *FAR *));
+	typedef int(*out_func) OF((void FAR *, unsigned char FAR *, unsigned));
+
+	ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm,
+										in_func in, void FAR *in_desc,
+										out_func out, void FAR *out_desc));
+	/*
+     inflateBack() does a raw inflate with a single call using a call-back
+   interface for input and output.  This is potentially more efficient than
+   inflate() for file i/o applications, in that it avoids copying between the
+   output and the sliding window by simply making the window itself the output
+   buffer.  inflate() can be faster on modern CPUs when used with large
+   buffers.  inflateBack() trusts the application to not change the output
+   buffer passed by the output function, at least until inflateBack() returns.
+
+     inflateBackInit() must be called first to allocate the internal state
+   and to initialize the state with the user-provided window buffer.
+   inflateBack() may then be used multiple times to inflate a complete, raw
+   deflate stream with each call.  inflateBackEnd() is then called to free the
+   allocated state.
+
+     A raw deflate stream is one with no zlib or gzip header or trailer.
+   This routine would normally be used in a utility that reads zip or gzip
+   files and writes out uncompressed files.  The utility would decode the
+   header and process the trailer on its own, hence this routine expects only
+   the raw deflate stream to decompress.  This is different from the normal
+   behavior of inflate(), which expects either a zlib or gzip header and
+   trailer around the deflate stream.
+
+     inflateBack() uses two subroutines supplied by the caller that are then
+   called by inflateBack() for input and output.  inflateBack() calls those
+   routines until it reads a complete deflate stream and writes out all of the
+   uncompressed data, or until it encounters an error.  The function's
+   parameters and return types are defined above in the in_func and out_func
+   typedefs.  inflateBack() will call in(in_desc, &buf) which should return the
+   number of bytes of provided input, and a pointer to that input in buf.  If
+   there is no input available, in() must return zero--buf is ignored in that
+   case--and inflateBack() will return a buffer error.  inflateBack() will call
+   out(out_desc, buf, len) to write the uncompressed data buf[0..len-1].  out()
+   should return zero on success, or non-zero on failure.  If out() returns
+   non-zero, inflateBack() will return with an error.  Neither in() nor out()
+   are permitted to change the contents of the window provided to
+   inflateBackInit(), which is also the buffer that out() uses to write from.
+   The length written by out() will be at most the window size.  Any non-zero
+   amount of input may be provided by in().
+
+     For convenience, inflateBack() can be provided input on the first call by
+   setting strm->next_in and strm->avail_in.  If that input is exhausted, then
+   in() will be called.  Therefore strm->next_in must be initialized before
+   calling inflateBack().  If strm->next_in is Z_NULL, then in() will be called
+   immediately for input.  If strm->next_in is not Z_NULL, then strm->avail_in
+   must also be initialized, and then if strm->avail_in is not zero, input will
+   initially be taken from strm->next_in[0 ..  strm->avail_in - 1].
+
+     The in_desc and out_desc parameters of inflateBack() is passed as the
+   first parameter of in() and out() respectively when they are called.  These
+   descriptors can be optionally used to pass any information that the caller-
+   supplied in() and out() functions need to do their job.
+
+     On return, inflateBack() will set strm->next_in and strm->avail_in to
+   pass back any unused input that was provided by the last in() call.  The
+   return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR
+   if in() or out() returned an error, Z_DATA_ERROR if there was a format error
+   in the deflate stream (in which case strm->msg is set to indicate the nature
+   of the error), or Z_STREAM_ERROR if the stream was not properly initialized.
+   In the case of Z_BUF_ERROR, an input or output error can be distinguished
+   using strm->next_in which will be Z_NULL only if in() returned an error.  If
+   strm->next_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning
+   non-zero.  (in() will always be called before out(), so strm->next_in is
+   assured to be defined if out() returns non-zero.) Note that inflateBack()
+   cannot return Z_OK.
+*/
+
+	ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm));
+	/*
+     All memory allocated by inflateBackInit() is freed.
+
+     inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream
+   state was inconsistent.
+*/
+
+	ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void));
+	/* Return flags indicating compile-time options.
+
+    Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other:
+     1.0: size of uInt
+     3.2: size of uLong
+     5.4: size of voidpf (pointer)
+     7.6: size of z_off_t
+
+    Compiler, assembler, and debug options:
+     8: DEBUG
+     9: ASMV or ASMINF -- use ASM code
+     10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention
+     11: 0 (reserved)
+
+    One-time table building (smaller code, but not thread-safe if true):
+     12: BUILDFIXED -- build static block decoding tables when needed
+     13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed
+     14,15: 0 (reserved)
+
+    Library content (indicates missing functionality):
+     16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking
+                          deflate code when not needed)
+     17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect
+                    and decode gzip streams (to avoid linking crc code)
+     18-19: 0 (reserved)
+
+    Operation variations (changes in library functionality):
+     20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate
+     21: FASTEST -- deflate algorithm with only one, lowest compression level
+     22,23: 0 (reserved)
+
+    The sprintf variant used by gzprintf (zero is best):
+     24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format
+     25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure!
+     26: 0 = returns value, 1 = void -- 1 means inferred string length returned
+
+    Remainder:
+     27-31: 0 (reserved)
+ */
+
+#ifndef Z_SOLO
+
+	/* utility functions */
+
+	/*
+     The following utility functions are implemented on top of the basic
+   stream-oriented functions.  To simplify the interface, some default options
+   are assumed (compression level and memory usage, standard memory allocation
+   functions).  The source code of these utility functions can be modified if
+   you need special options.
+*/
+
+	ZEXTERN int ZEXPORT compress OF((Bytef * dest, uLongf *destLen,
+									 const Bytef *source, uLong sourceLen));
+	/*
+     Compresses the source buffer into the destination buffer.  sourceLen is
+   the byte length of the source buffer.  Upon entry, destLen is the total size
+   of the destination buffer, which must be at least the value returned by
+   compressBound(sourceLen).  Upon exit, destLen is the actual size of the
+   compressed buffer.
+
+     compress returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_BUF_ERROR if there was not enough room in the output
+   buffer.
+*/
+
+	ZEXTERN int ZEXPORT compress2 OF((Bytef * dest, uLongf *destLen,
+									  const Bytef *source, uLong sourceLen,
+									  int level));
+	/*
+     Compresses the source buffer into the destination buffer.  The level
+   parameter has the same meaning as in deflateInit.  sourceLen is the byte
+   length of the source buffer.  Upon entry, destLen is the total size of the
+   destination buffer, which must be at least the value returned by
+   compressBound(sourceLen).  Upon exit, destLen is the actual size of the
+   compressed buffer.
+
+     compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_BUF_ERROR if there was not enough room in the output buffer,
+   Z_STREAM_ERROR if the level parameter is invalid.
+*/
+
+	ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen));
+	/*
+     compressBound() returns an upper bound on the compressed size after
+   compress() or compress2() on sourceLen bytes.  It would be used before a
+   compress() or compress2() call to allocate the destination buffer.
+*/
+
+	ZEXTERN int ZEXPORT uncompress OF((Bytef * dest, uLongf *destLen,
+									   const Bytef *source, uLong sourceLen));
+	/*
+     Decompresses the source buffer into the destination buffer.  sourceLen is
+   the byte length of the source buffer.  Upon entry, destLen is the total size
+   of the destination buffer, which must be large enough to hold the entire
+   uncompressed data.  (The size of the uncompressed data must have been saved
+   previously by the compressor and transmitted to the decompressor by some
+   mechanism outside the scope of this compression library.) Upon exit, destLen
+   is the actual size of the uncompressed buffer.
+
+     uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_BUF_ERROR if there was not enough room in the output
+   buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete.  In
+   the case where there is not enough room, uncompress() will fill the output
+   buffer with the uncompressed data up to that point.
+*/
+
+	/* gzip file access functions */
+
+	/*
+     This library supports reading and writing files in gzip (.gz) format with
+   an interface similar to that of stdio, using the functions that start with
+   "gz".  The gzip format is different from the zlib format.  gzip is a gzip
+   wrapper, documented in RFC 1952, wrapped around a deflate stream.
+*/
+
+	typedef struct gzFile_s *gzFile; /* semi-opaque gzip file descriptor */
+
+	/*
+ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode));
+
+     Opens a gzip (.gz) file for reading or writing.  The mode parameter is as
+   in fopen ("rb" or "wb") but can also include a compression level ("wb9") or
+   a strategy: 'f' for filtered data as in "wb6f", 'h' for Huffman-only
+   compression as in "wb1h", 'R' for run-length encoding as in "wb1R", or 'F'
+   for fixed code compression as in "wb9F".  (See the description of
+   deflateInit2 for more information about the strategy parameter.)  'T' will
+   request transparent writing or appending with no compression and not using
+   the gzip format.
+
+     "a" can be used instead of "w" to request that the gzip stream that will
+   be written be appended to the file.  "+" will result in an error, since
+   reading and writing to the same gzip file is not supported.  The addition of
+   "x" when writing will create the file exclusively, which fails if the file
+   already exists.  On systems that support it, the addition of "e" when
+   reading or writing will set the flag to close the file on an execve() call.
+
+     These functions, as well as gzip, will read and decode a sequence of gzip
+   streams in a file.  The append function of gzopen() can be used to create
+   such a file.  (Also see gzflush() for another way to do this.)  When
+   appending, gzopen does not test whether the file begins with a gzip stream,
+   nor does it look for the end of the gzip streams to begin appending.  gzopen
+   will simply append a gzip stream to the existing file.
+
+     gzopen can be used to read a file which is not in gzip format; in this
+   case gzread will directly read from the file without decompression.  When
+   reading, this will be detected automatically by looking for the magic two-
+   byte gzip header.
+
+     gzopen returns NULL if the file could not be opened, if there was
+   insufficient memory to allocate the gzFile state, or if an invalid mode was
+   specified (an 'r', 'w', or 'a' was not provided, or '+' was provided).
+   errno can be checked to determine if the reason gzopen failed was that the
+   file could not be opened.
+*/
+
+	ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode));
+	/*
+     gzdopen associates a gzFile with the file descriptor fd.  File descriptors
+   are obtained from calls like open, dup, creat, pipe or fileno (if the file
+   has been previously opened with fopen).  The mode parameter is as in gzopen.
+
+     The next call of gzclose on the returned gzFile will also close the file
+   descriptor fd, just like fclose(fdopen(fd, mode)) closes the file descriptor
+   fd.  If you want to keep fd open, use fd = dup(fd_keep); gz = gzdopen(fd,
+   mode);.  The duplicated descriptor should be saved to avoid a leak, since
+   gzdopen does not close fd if it fails.  If you are using fileno() to get the
+   file descriptor from a FILE *, then you will have to use dup() to avoid
+   double-close()ing the file descriptor.  Both gzclose() and fclose() will
+   close the associated file descriptor, so they need to have different file
+   descriptors.
+
+     gzdopen returns NULL if there was insufficient memory to allocate the
+   gzFile state, if an invalid mode was specified (an 'r', 'w', or 'a' was not
+   provided, or '+' was provided), or if fd is -1.  The file descriptor is not
+   used until the next gz* read, write, seek, or close operation, so gzdopen
+   will not detect if fd is invalid (unless fd is -1).
+*/
+
+	ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size));
+	/*
+     Set the internal buffer size used by this library's functions.  The
+   default buffer size is 8192 bytes.  This function must be called after
+   gzopen() or gzdopen(), and before any other calls that read or write the
+   file.  The buffer memory allocation is always deferred to the first read or
+   write.  Two buffers are allocated, either both of the specified size when
+   writing, or one of the specified size and the other twice that size when
+   reading.  A larger buffer size of, for example, 64K or 128K bytes will
+   noticeably increase the speed of decompression (reading).
+
+     The new buffer size also affects the maximum length for gzprintf().
+
+     gzbuffer() returns 0 on success, or -1 on failure, such as being called
+   too late.
+*/
+
+	ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
+	/*
+     Dynamically update the compression level or strategy.  See the description
+   of deflateInit2 for the meaning of these parameters.
+
+     gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not
+   opened for writing.
+*/
+
+	ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len));
+	/*
+     Reads the given number of uncompressed bytes from the compressed file.  If
+   the input file is not in gzip format, gzread copies the given number of
+   bytes into the buffer directly from the file.
+
+     After reaching the end of a gzip stream in the input, gzread will continue
+   to read, looking for another gzip stream.  Any number of gzip streams may be
+   concatenated in the input file, and will all be decompressed by gzread().
+   If something other than a gzip stream is encountered after a gzip stream,
+   that remaining trailing garbage is ignored (and no error is returned).
+
+     gzread can be used to read a gzip file that is being concurrently written.
+   Upon reaching the end of the input, gzread will return with the available
+   data.  If the error code returned by gzerror is Z_OK or Z_BUF_ERROR, then
+   gzclearerr can be used to clear the end of file indicator in order to permit
+   gzread to be tried again.  Z_OK indicates that a gzip stream was completed
+   on the last gzread.  Z_BUF_ERROR indicates that the input file ended in the
+   middle of a gzip stream.  Note that gzread does not return -1 in the event
+   of an incomplete gzip stream.  This error is deferred until gzclose(), which
+   will return Z_BUF_ERROR if the last gzread ended in the middle of a gzip
+   stream.  Alternatively, gzerror can be used before gzclose to detect this
+   case.
+
+     gzread returns the number of uncompressed bytes actually read, less than
+   len for end of file, or -1 for error.
+*/
+
+	ZEXTERN int ZEXPORT gzwrite OF((gzFile file,
+									voidpc buf, unsigned len));
+	/*
+     Writes the given number of uncompressed bytes into the compressed file.
+   gzwrite returns the number of uncompressed bytes written or 0 in case of
+   error.
+*/
+
+	ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...));
+	/*
+     Converts, formats, and writes the arguments to the compressed file under
+   control of the format string, as in fprintf.  gzprintf returns the number of
+   uncompressed bytes actually written, or 0 in case of error.  The number of
+   uncompressed bytes written is limited to 8191, or one less than the buffer
+   size given to gzbuffer().  The caller should assure that this limit is not
+   exceeded.  If it is exceeded, then gzprintf() will return an error (0) with
+   nothing written.  In this case, there may also be a buffer overflow with
+   unpredictable consequences, which is possible only if zlib was compiled with
+   the insecure functions sprintf() or vsprintf() because the secure snprintf()
+   or vsnprintf() functions were not available.  This can be determined using
+   zlibCompileFlags().
+*/
+
+	ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
+	/*
+     Writes the given null-terminated string to the compressed file, excluding
+   the terminating null character.
+
+     gzputs returns the number of characters written, or -1 in case of error.
+*/
+
+	ZEXTERN char *ZEXPORT gzgets OF((gzFile file, char *buf, int len));
+	/*
+     Reads bytes from the compressed file until len-1 characters are read, or a
+   newline character is read and transferred to buf, or an end-of-file
+   condition is encountered.  If any characters are read or if len == 1, the
+   string is terminated with a null character.  If no characters are read due
+   to an end-of-file or len < 1, then the buffer is left untouched.
+
+     gzgets returns buf which is a null-terminated string, or it returns NULL
+   for end-of-file or in case of error.  If there was an error, the contents at
+   buf are indeterminate.
+*/
+
+	ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c));
+	/*
+     Writes c, converted to an unsigned char, into the compressed file.  gzputc
+   returns the value that was written, or -1 in case of error.
+*/
+
+	ZEXTERN int ZEXPORT gzgetc OF((gzFile file));
+	/*
+     Reads one byte from the compressed file.  gzgetc returns this byte or -1
+   in case of end of file or error.  This is implemented as a macro for speed.
+   As such, it does not do all of the checking the other functions do.  I.e.
+   it does not check to see if file is NULL, nor whether the structure file
+   points to has been clobbered or not.
+*/
+
+	ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file));
+	/*
+     Push one character back onto the stream to be read as the first character
+   on the next read.  At least one character of push-back is allowed.
+   gzungetc() returns the character pushed, or -1 on failure.  gzungetc() will
+   fail if c is -1, and may fail if a character has been pushed but not read
+   yet.  If gzungetc is used immediately after gzopen or gzdopen, at least the
+   output buffer size of pushed characters is allowed.  (See gzbuffer above.)
+   The pushed character will be discarded if the stream is repositioned with
+   gzseek() or gzrewind().
+*/
+
+	ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush));
+	/*
+     Flushes all pending output into the compressed file.  The parameter flush
+   is as in the deflate() function.  The return value is the zlib error number
+   (see function gzerror below).  gzflush is only permitted when writing.
+
+     If the flush parameter is Z_FINISH, the remaining data is written and the
+   gzip stream is completed in the output.  If gzwrite() is called again, a new
+   gzip stream will be started in the output.  gzread() is able to read such
+   concatented gzip streams.
+
+     gzflush should be called only when strictly necessary because it will
+   degrade compression if called too often.
+*/
+
+	/*
+ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file,
+                                   z_off_t offset, int whence));
+
+     Sets the starting position for the next gzread or gzwrite on the given
+   compressed file.  The offset represents a number of bytes in the
+   uncompressed data stream.  The whence parameter is defined as in lseek(2);
+   the value SEEK_END is not supported.
+
+     If the file is opened for reading, this function is emulated but can be
+   extremely slow.  If the file is opened for writing, only forward seeks are
+   supported; gzseek then compresses a sequence of zeroes up to the new
+   starting position.
+
+     gzseek returns the resulting offset location as measured in bytes from
+   the beginning of the uncompressed stream, or -1 in case of error, in
+   particular if the file is opened for writing and the new starting position
+   would be before the current position.
+*/
+
+	ZEXTERN int ZEXPORT gzrewind OF((gzFile file));
+	/*
+     Rewinds the given file. This function is supported only for reading.
+
+     gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET)
+*/
+
+	/*
+ZEXTERN z_off_t ZEXPORT    gztell OF((gzFile file));
+
+     Returns the starting position for the next gzread or gzwrite on the given
+   compressed file.  This position represents a number of bytes in the
+   uncompressed data stream, and is zero when starting, even if appending or
+   reading a gzip stream from the middle of a file using gzdopen().
+
+     gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
+*/
+
+	/*
+ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file));
+
+     Returns the current offset in the file being read or written.  This offset
+   includes the count of bytes that precede the gzip stream, for example when
+   appending or when using gzdopen() for reading.  When reading, the offset
+   does not include as yet unused buffered input.  This information can be used
+   for a progress indicator.  On error, gzoffset() returns -1.
+*/
+
+	ZEXTERN int ZEXPORT gzeof OF((gzFile file));
+	/*
+     Returns true (1) if the end-of-file indicator has been set while reading,
+   false (0) otherwise.  Note that the end-of-file indicator is set only if the
+   read tried to go past the end of the input, but came up short.  Therefore,
+   just like feof(), gzeof() may return false even if there is no more data to
+   read, in the event that the last read request was for the exact number of
+   bytes remaining in the input file.  This will happen if the input file size
+   is an exact multiple of the buffer size.
+
+     If gzeof() returns true, then the read functions will return no more data,
+   unless the end-of-file indicator is reset by gzclearerr() and the input file
+   has grown since the previous end of file was detected.
+*/
+
+	ZEXTERN int ZEXPORT gzdirect OF((gzFile file));
+	/*
+     Returns true (1) if file is being copied directly while reading, or false
+   (0) if file is a gzip stream being decompressed.
+
+     If the input file is empty, gzdirect() will return true, since the input
+   does not contain a gzip stream.
+
+     If gzdirect() is used immediately after gzopen() or gzdopen() it will
+   cause buffers to be allocated to allow reading the file to determine if it
+   is a gzip file.  Therefore if gzbuffer() is used, it should be called before
+   gzdirect().
+
+     When writing, gzdirect() returns true (1) if transparent writing was
+   requested ("wT" for the gzopen() mode), or false (0) otherwise.  (Note:
+   gzdirect() is not needed when writing.  Transparent writing must be
+   explicitly requested, so the application already knows the answer.  When
+   linking statically, using gzdirect() will include all of the zlib code for
+   gzip file reading and decompression, which may not be desired.)
+*/
+
+	ZEXTERN int ZEXPORT gzclose OF((gzFile file));
+	/*
+     Flushes all pending output if necessary, closes the compressed file and
+   deallocates the (de)compression state.  Note that once file is closed, you
+   cannot call gzerror with file, since its structures have been deallocated.
+   gzclose must not be called more than once on the same file, just as free
+   must not be called more than once on the same allocation.
+
+     gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a
+   file operation error, Z_MEM_ERROR if out of memory, Z_BUF_ERROR if the
+   last read ended in the middle of a gzip stream, or Z_OK on success.
+*/
+
+	ZEXTERN int ZEXPORT gzclose_r OF((gzFile file));
+	ZEXTERN int ZEXPORT gzclose_w OF((gzFile file));
+	/*
+     Same as gzclose(), but gzclose_r() is only for use when reading, and
+   gzclose_w() is only for use when writing or appending.  The advantage to
+   using these instead of gzclose() is that they avoid linking in zlib
+   compression or decompression code that is not used when only reading or only
+   writing respectively.  If gzclose() is used, then both compression and
+   decompression code will be included the application when linking to a static
+   zlib library.
+*/
+
+	ZEXTERN const char *ZEXPORT gzerror OF((gzFile file, int *errnum));
+	/*
+     Returns the error message for the last error which occurred on the given
+   compressed file.  errnum is set to zlib error number.  If an error occurred
+   in the file system and not in the compression library, errnum is set to
+   Z_ERRNO and the application may consult errno to get the exact error code.
+
+     The application must not modify the returned string.  Future calls to
+   this function may invalidate the previously returned string.  If file is
+   closed, then the string previously returned by gzerror will no longer be
+   available.
+
+     gzerror() should be used to distinguish errors from end-of-file for those
+   functions above that do not distinguish those cases in their return values.
+*/
+
+	ZEXTERN void ZEXPORT gzclearerr OF((gzFile file));
+	/*
+     Clears the error and end-of-file flags for file.  This is analogous to the
+   clearerr() function in stdio.  This is useful for continuing to read a gzip
+   file that is being written concurrently.
+*/
+
+#endif /* !Z_SOLO */
+
+	/* checksum functions */
+
+	/*
+     These functions are not related to compression but are exported
+   anyway because they might be useful in applications using the compression
+   library.
+*/
+
+	ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
+	/*
+     Update a running Adler-32 checksum with the bytes buf[0..len-1] and
+   return the updated checksum.  If buf is Z_NULL, this function returns the
+   required initial value for the checksum.
+
+     An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
+   much faster.
+
+   Usage example:
+
+     uLong adler = adler32(0L, Z_NULL, 0);
+
+     while (read_buffer(buffer, length) != EOF) {
+       adler = adler32(adler, buffer, length);
+     }
+     if (adler != original_adler) error();
+*/
+
+	/*
+ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2,
+                                          z_off_t len2));
+
+     Combine two Adler-32 checksums into one.  For two sequences of bytes, seq1
+   and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for
+   each, adler1 and adler2.  adler32_combine() returns the Adler-32 checksum of
+   seq1 and seq2 concatenated, requiring only adler1, adler2, and len2.  Note
+   that the z_off_t type (like off_t) is a signed integer.  If len2 is
+   negative, the result has no meaning or utility.
+*/
+
+	ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len));
+	/*
+     Update a running CRC-32 with the bytes buf[0..len-1] and return the
+   updated CRC-32.  If buf is Z_NULL, this function returns the required
+   initial value for the crc.  Pre- and post-conditioning (one's complement) is
+   performed within this function so it shouldn't be done by the application.
+
+   Usage example:
+
+     uLong crc = crc32(0L, Z_NULL, 0);
+
+     while (read_buffer(buffer, length) != EOF) {
+       crc = crc32(crc, buffer, length);
+     }
+     if (crc != original_crc) error();
+*/
+
+	/*
+ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2));
+
+     Combine two CRC-32 check values into one.  For two sequences of bytes,
+   seq1 and seq2 with lengths len1 and len2, CRC-32 check values were
+   calculated for each, crc1 and crc2.  crc32_combine() returns the CRC-32
+   check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and
+   len2.
+*/
+
+	/* various hacks, don't look :) */
+
+	/* deflateInit and inflateInit are macros to allow checking the zlib version
+ * and the compiler's view of z_stream:
+ */
+	ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
+										 const char *version, int stream_size));
+	ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm,
+										 const char *version, int stream_size));
+	ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method,
+										  int windowBits, int memLevel,
+										  int strategy, const char *version,
+										  int stream_size));
+	ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits,
+										  const char *version, int stream_size));
+	ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits,
+											 unsigned char FAR *window,
+											 const char *version,
+											 int stream_size));
+#define deflateInit(strm, level) \
+	deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
+#define inflateInit(strm) \
+	inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
+#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
+	deflateInit2_((strm), (level), (method), (windowBits), (memLevel),    \
+				  (strategy), ZLIB_VERSION, (int)sizeof(z_stream))
+#define inflateInit2(strm, windowBits)                \
+	inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
+				  (int)sizeof(z_stream))
+#define inflateBackInit(strm, windowBits, window)    \
+	inflateBackInit_((strm), (windowBits), (window), \
+					 ZLIB_VERSION, (int)sizeof(z_stream))
+
+#ifndef Z_SOLO
+
+	/* gzgetc() macro and its supporting function and exposed data structure.  Note
+ * that the real internal state is much larger than the exposed structure.
+ * This abbreviated structure exposes just enough for the gzgetc() macro.  The
+ * user should not mess with these exposed elements, since their names or
+ * behavior could change in the future, perhaps even capriciously.  They can
+ * only be used by the gzgetc() macro.  You have been warned.
+ */
+	struct gzFile_s
+	{
+		unsigned have;
+		unsigned char *next;
+		z_off64_t pos;
+	};
+	ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */
+#ifdef Z_PREFIX_SET
+#undef z_gzgetc
+#define z_gzgetc(g) \
+	((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g))
+#else
+#define gzgetc(g) \
+	((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g))
+#endif
+
+/* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or
+ * change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if
+ * both are true, the application gets the *64 functions, and the regular
+ * functions are changed to 64 bits) -- in case these are set on systems
+ * without large file support, _LFS64_LARGEFILE must also be true
+ */
+#ifdef Z_LARGE64
+	ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
+	ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int));
+	ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile));
+	ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile));
+	ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off64_t));
+	ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t));
+#endif
+
+#if !defined(ZLIB_INTERNAL) && defined(Z_WANT64)
+#ifdef Z_PREFIX_SET
+#define z_gzopen z_gzopen64
+#define z_gzseek z_gzseek64
+#define z_gztell z_gztell64
+#define z_gzoffset z_gzoffset64
+#define z_adler32_combine z_adler32_combine64
+#define z_crc32_combine z_crc32_combine64
+#else
+#define gzopen gzopen64
+#define gzseek gzseek64
+#define gztell gztell64
+#define gzoffset gzoffset64
+#define adler32_combine adler32_combine64
+#define crc32_combine crc32_combine64
+#endif
+#ifndef Z_LARGE64
+	ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
+	ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int));
+	ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile));
+	ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile));
+	ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t));
+	ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t));
+#endif
+#else
+	ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *));
+	ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int));
+	ZEXTERN z_off_t ZEXPORT gztell OF((gzFile));
+	ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile));
+	ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t));
+	ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
+#endif
+
+#else /* Z_SOLO */
+
+ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t));
+ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
+
+#endif /* !Z_SOLO */
+
+/* hack for buggy compilers */
+#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL)
+	struct internal_state
+	{
+		int dummy;
+	};
+#endif
+
+	/* undocumented functions */
+	ZEXTERN const char *ZEXPORT zError OF((int));
+	ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp));
+	ZEXTERN const z_crc_t FAR *ZEXPORT get_crc_table OF((void));
+	ZEXTERN int ZEXPORT inflateUndermine OF((z_streamp, int));
+	ZEXTERN int ZEXPORT inflateResetKeep OF((z_streamp));
+	ZEXTERN int ZEXPORT deflateResetKeep OF((z_streamp));
+#if defined(_WIN32) && !defined(Z_SOLO)
+	ZEXTERN gzFile ZEXPORT gzopen_w OF((const wchar_t *path,
+										const char *mode));
+#endif
+#if defined(STDC) || defined(Z_HAVE_STDARG_H)
+#ifndef Z_SOLO
+	ZEXTERN int ZEXPORTVA gzvprintf Z_ARG((gzFile file,
+										   const char *format,
+										   va_list va));
+#endif
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZLIB_H */
diff --git a/engine/inc/bullet/ThirdPartyLibs/zlib/zutil.h b/engine/inc/bullet/ThirdPartyLibs/zlib/zutil.h
new file mode 100644
index 00000000..fea10832
--- /dev/null
+++ b/engine/inc/bullet/ThirdPartyLibs/zlib/zutil.h
@@ -0,0 +1,274 @@
+/* zutil.h -- internal interface and configuration of the compression library
+ * Copyright (C) 1995-2013 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* @(#) $Id$ */
+
+#ifndef ZUTIL_H
+#define ZUTIL_H
+
+#ifdef HAVE_HIDDEN
+#define ZLIB_INTERNAL __attribute__((visibility("hidden")))
+#else
+#define ZLIB_INTERNAL
+#endif
+
+#include "zlib.h"
+
+#if defined(STDC) && !defined(Z_SOLO)
+#if !(defined(_WIN32_WCE) && defined(_MSC_VER))
+#include <stddef.h>
+#endif
+#include <string.h>
+#include <stdlib.h>
+#endif
+
+#ifdef Z_SOLO
+typedef long ptrdiff_t; /* guess -- will be caught if guess is wrong */
+#endif
+
+#ifndef local
+#define local static
+#endif
+/* compile with -Dlocal if your debugger can't find static symbols */
+
+typedef unsigned char uch;
+typedef uch FAR uchf;
+typedef unsigned short ush;
+typedef ush FAR ushf;
+typedef unsigned long ulg;
+
+extern z_const char *const z_errmsg[10]; /* indexed by 2-zlib_error */
+/* (size given to avoid silly warnings with Visual C++) */
+
+#define ERR_MSG(err) z_errmsg[Z_NEED_DICT - (err)]
+
+#define ERR_RETURN(strm, err) \
+	return (strm->msg = ERR_MSG(err), (err))
+/* To be used only when the state is known to be valid */
+
+/* common constants */
+
+#ifndef DEF_WBITS
+#define DEF_WBITS MAX_WBITS
+#endif
+/* default windowBits for decompression. MAX_WBITS is for compression only */
+
+#if MAX_MEM_LEVEL >= 8
+#define DEF_MEM_LEVEL 8
+#else
+#define DEF_MEM_LEVEL MAX_MEM_LEVEL
+#endif
+/* default memLevel */
+
+#define STORED_BLOCK 0
+#define STATIC_TREES 1
+#define DYN_TREES 2
+/* The three kinds of block type */
+
+#define MIN_MATCH 3
+#define MAX_MATCH 258
+/* The minimum and maximum match lengths */
+
+#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */
+
+/* target dependencies */
+
+#if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32))
+#define OS_CODE 0x00
+#ifndef Z_SOLO
+#if defined(__TURBOC__) || defined(__BORLANDC__)
+#if (__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__))
+/* Allow compilation with ANSI keywords only enabled */
+void _Cdecl farfree(void *block);
+void *_Cdecl farmalloc(unsigned long nbytes);
+#else
+#include <alloc.h>
+#endif
+#else /* MSC or DJGPP */
+#include <malloc.h>
+#endif
+#endif
+#endif
+
+#ifdef AMIGA
+#define OS_CODE 0x01
+#endif
+
+#if defined(VAXC) || defined(VMS)
+#define OS_CODE 0x02
+#define F_OPEN(name, mode) \
+	fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
+#endif
+
+#if defined(ATARI) || defined(atarist)
+#define OS_CODE 0x05
+#endif
+
+#ifdef OS2
+#define OS_CODE 0x06
+#if defined(M_I86) && !defined(Z_SOLO)
+#include <malloc.h>
+#endif
+#endif
+
+#if defined(MACOS) || defined(TARGET_OS_MAC)
+#define OS_CODE 0x07
+#ifndef Z_SOLO
+#if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
+#include <unix.h> /* for fdopen */
+#else
+#ifndef fdopen
+#define fdopen(fd, mode) NULL /* No fdopen() */
+#endif
+#endif
+#endif
+#endif
+
+#ifdef TOPS20
+#define OS_CODE 0x0a
+#endif
+
+#ifdef WIN32
+#ifndef __CYGWIN__ /* Cygwin is Unix, not Win32 */
+#define OS_CODE 0x0b
+#endif
+#endif
+
+#ifdef __50SERIES /* Prime/PRIMOS */
+#define OS_CODE 0x0f
+#endif
+
+#if defined(_BEOS_) || defined(RISCOS)
+#define fdopen(fd, mode) NULL /* No fdopen() */
+#endif
+
+#if (defined(_MSC_VER) && (_MSC_VER > 600)) && !defined __INTERIX
+#if defined(_WIN32_WCE)
+#define fdopen(fd, mode) NULL /* No fdopen() */
+#ifndef _PTRDIFF_T_DEFINED
+typedef int ptrdiff_t;
+#define _PTRDIFF_T_DEFINED
+#endif
+#else
+#define fdopen(fd, type) _fdopen(fd, type)
+#endif
+#endif
+
+#if defined(__BORLANDC__) && !defined(MSDOS)
+#pragma warn - 8004
+#pragma warn - 8008
+#pragma warn - 8066
+#endif
+
+/* provide prototypes for these when building zlib without LFS */
+#if !defined(_WIN32) && \
+	(!defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE - 0 == 0)
+ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t));
+ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t));
+#endif
+
+/* common defaults */
+
+#ifndef OS_CODE
+#define OS_CODE 0x03 /* assume Unix */
+#endif
+
+#ifndef F_OPEN
+#define F_OPEN(name, mode) fopen((name), (mode))
+#endif
+
+/* functions */
+
+#if defined(pyr) || defined(Z_SOLO)
+#define NO_MEMCPY
+#endif
+#if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__)
+/* Use our own functions for small and medium model with MSC <= 5.0.
+  * You may have to use the same strategy for Borland C (untested).
+  * The __SC__ check is for Symantec.
+  */
+#define NO_MEMCPY
+#endif
+#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY)
+#define HAVE_MEMCPY
+#endif
+#ifdef HAVE_MEMCPY
+#ifdef SMALL_MEDIUM /* MSDOS small or medium model */
+#define zmemcpy _fmemcpy
+#define zmemcmp _fmemcmp
+#define zmemzero(dest, len) _fmemset(dest, 0, len)
+#else
+#define zmemcpy memcpy
+#define zmemcmp memcmp
+#define zmemzero(dest, len) memset(dest, 0, len)
+#endif
+#else
+void ZLIB_INTERNAL zmemcpy OF((Bytef * dest, const Bytef* source, uInt len));
+int ZLIB_INTERNAL zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len));
+void ZLIB_INTERNAL zmemzero OF((Bytef * dest, uInt len));
+#endif
+
+/* Diagnostic functions */
+#ifdef DEBUG
+#include <stdio.h>
+extern int ZLIB_INTERNAL z_verbose;
+extern void ZLIB_INTERNAL z_error OF((char *m));
+#define Assert(cond, msg)          \
+	{                              \
+		if (!(cond)) z_error(msg); \
+	}
+#define Trace(x)                       \
+	{                                  \
+		if (z_verbose >= 0) fprintf x; \
+	}
+#define Tracev(x)                     \
+	{                                 \
+		if (z_verbose > 0) fprintf x; \
+	}
+#define Tracevv(x)                    \
+	{                                 \
+		if (z_verbose > 1) fprintf x; \
+	}
+#define Tracec(c, x)                         \
+	{                                        \
+		if (z_verbose > 0 && (c)) fprintf x; \
+	}
+#define Tracecv(c, x)                        \
+	{                                        \
+		if (z_verbose > 1 && (c)) fprintf x; \
+	}
+#else
+#define Assert(cond, msg)
+#define Trace(x)
+#define Tracev(x)
+#define Tracevv(x)
+#define Tracec(c, x)
+#define Tracecv(c, x)
+#endif
+
+#ifndef Z_SOLO
+voidpf ZLIB_INTERNAL zcalloc OF((voidpf opaque, unsigned items,
+								 unsigned size));
+void ZLIB_INTERNAL zcfree OF((voidpf opaque, voidpf ptr));
+#endif
+
+#define ZALLOC(strm, items, size) \
+	(*((strm)->zalloc))((strm)->opaque, (items), (size))
+#define ZFREE(strm, addr) (*((strm)->zfree))((strm)->opaque, (voidpf)(addr))
+#define TRY_FREE(s, p)      \
+	{                       \
+		if (p) ZFREE(s, p); \
+	}
+
+/* Reverse the bytes in a 32-bit value */
+#define ZSWAP32(q) ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
+					(((q)&0xff00) << 8) + (((q)&0xff) << 24))
+
+#endif /* ZUTIL_H */
diff --git a/engine/inc/bullet/TinyAudio/RtAudio.h b/engine/inc/bullet/TinyAudio/RtAudio.h
new file mode 100644
index 00000000..145cd8e7
--- /dev/null
+++ b/engine/inc/bullet/TinyAudio/RtAudio.h
@@ -0,0 +1,1171 @@
+/************************************************************************/
+/*! \class RtAudio
+    \brief Realtime audio i/o C++ classes.
+
+    RtAudio provides a common API (Application Programming Interface)
+    for realtime audio input/output across Linux (native ALSA, Jack,
+    and OSS), Macintosh OS X (CoreAudio and Jack), and Windows
+    (DirectSound, ASIO and WASAPI) operating systems.
+
+    RtAudio WWW site: http://www.music.mcgill.ca/~gary/rtaudio/
+
+    RtAudio: realtime audio i/o C++ classes
+    Copyright (c) 2001-2016 Gary P. Scavone
+
+    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.
+
+    Any person wishing to distribute modifications to the Software is
+    asked to send the modifications to the original developer so that
+    they can be incorporated into the canonical version.  This is,
+    however, not a binding provision of this license.
+
+    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.
+*/
+/************************************************************************/
+
+/*!
+  \file RtAudio.h
+ */
+
+#ifndef __RTAUDIO_H
+#define __RTAUDIO_H
+
+#define RTAUDIO_VERSION "4.1.2"
+
+#include <string>
+#include <vector>
+#include <exception>
+#include <iostream>
+
+/*! \typedef typedef unsigned long RtAudioFormat;
+    \brief RtAudio data format type.
+
+    Support for signed integers and floats.  Audio data fed to/from an
+    RtAudio stream is assumed to ALWAYS be in host byte order.  The
+    internal routines will automatically take care of any necessary
+    byte-swapping between the host format and the soundcard.  Thus,
+    endian-ness is not a concern in the following format definitions.
+
+    - \e RTAUDIO_SINT8:   8-bit signed integer.
+    - \e RTAUDIO_SINT16:  16-bit signed integer.
+    - \e RTAUDIO_SINT24:  24-bit signed integer.
+    - \e RTAUDIO_SINT32:  32-bit signed integer.
+    - \e RTAUDIO_FLOAT32: Normalized between plus/minus 1.0.
+    - \e RTAUDIO_FLOAT64: Normalized between plus/minus 1.0.
+*/
+typedef unsigned long RtAudioFormat;
+static const RtAudioFormat RTAUDIO_SINT8 = 0x1;     // 8-bit signed integer.
+static const RtAudioFormat RTAUDIO_SINT16 = 0x2;    // 16-bit signed integer.
+static const RtAudioFormat RTAUDIO_SINT24 = 0x4;    // 24-bit signed integer.
+static const RtAudioFormat RTAUDIO_SINT32 = 0x8;    // 32-bit signed integer.
+static const RtAudioFormat RTAUDIO_FLOAT32 = 0x10;  // Normalized between plus/minus 1.0.
+static const RtAudioFormat RTAUDIO_FLOAT64 = 0x20;  // Normalized between plus/minus 1.0.
+
+/*! \typedef typedef unsigned long RtAudioStreamFlags;
+    \brief RtAudio stream option flags.
+
+    The following flags can be OR'ed together to allow a client to
+    make changes to the default stream behavior:
+
+    - \e RTAUDIO_NONINTERLEAVED:   Use non-interleaved buffers (default = interleaved).
+    - \e RTAUDIO_MINIMIZE_LATENCY: Attempt to set stream parameters for lowest possible latency.
+    - \e RTAUDIO_HOG_DEVICE:       Attempt grab device for exclusive use.
+    - \e RTAUDIO_ALSA_USE_DEFAULT: Use the "default" PCM device (ALSA only).
+
+    By default, RtAudio streams pass and receive audio data from the
+    client in an interleaved format.  By passing the
+    RTAUDIO_NONINTERLEAVED flag to the openStream() function, audio
+    data will instead be presented in non-interleaved buffers.  In
+    this case, each buffer argument in the RtAudioCallback function
+    will point to a single array of data, with \c nFrames samples for
+    each channel concatenated back-to-back.  For example, the first
+    sample of data for the second channel would be located at index \c
+    nFrames (assuming the \c buffer pointer was recast to the correct
+    data type for the stream).
+
+    Certain audio APIs offer a number of parameters that influence the
+    I/O latency of a stream.  By default, RtAudio will attempt to set
+    these parameters internally for robust (glitch-free) performance
+    (though some APIs, like Windows Direct Sound, make this difficult).
+    By passing the RTAUDIO_MINIMIZE_LATENCY flag to the openStream()
+    function, internal stream settings will be influenced in an attempt
+    to minimize stream latency, though possibly at the expense of stream
+    performance.
+
+    If the RTAUDIO_HOG_DEVICE flag is set, RtAudio will attempt to
+    open the input and/or output stream device(s) for exclusive use.
+    Note that this is not possible with all supported audio APIs.
+
+    If the RTAUDIO_SCHEDULE_REALTIME flag is set, RtAudio will attempt 
+    to select realtime scheduling (round-robin) for the callback thread.
+
+    If the RTAUDIO_ALSA_USE_DEFAULT flag is set, RtAudio will attempt to
+    open the "default" PCM device when using the ALSA API. Note that this
+    will override any specified input or output device id.
+*/
+typedef unsigned int RtAudioStreamFlags;
+static const RtAudioStreamFlags RTAUDIO_NONINTERLEAVED = 0x1;     // Use non-interleaved buffers (default = interleaved).
+static const RtAudioStreamFlags RTAUDIO_MINIMIZE_LATENCY = 0x2;   // Attempt to set stream parameters for lowest possible latency.
+static const RtAudioStreamFlags RTAUDIO_HOG_DEVICE = 0x4;         // Attempt grab device and prevent use by others.
+static const RtAudioStreamFlags RTAUDIO_SCHEDULE_REALTIME = 0x8;  // Try to select realtime scheduling for callback thread.
+static const RtAudioStreamFlags RTAUDIO_ALSA_USE_DEFAULT = 0x10;  // Use the "default" PCM device (ALSA only).
+
+/*! \typedef typedef unsigned long RtAudioStreamStatus;
+    \brief RtAudio stream status (over- or underflow) flags.
+
+    Notification of a stream over- or underflow is indicated by a
+    non-zero stream \c status argument in the RtAudioCallback function.
+    The stream status can be one of the following two options,
+    depending on whether the stream is open for output and/or input:
+
+    - \e RTAUDIO_INPUT_OVERFLOW:   Input data was discarded because of an overflow condition at the driver.
+    - \e RTAUDIO_OUTPUT_UNDERFLOW: The output buffer ran low, likely producing a break in the output sound.
+*/
+typedef unsigned int RtAudioStreamStatus;
+static const RtAudioStreamStatus RTAUDIO_INPUT_OVERFLOW = 0x1;    // Input data was discarded because of an overflow condition at the driver.
+static const RtAudioStreamStatus RTAUDIO_OUTPUT_UNDERFLOW = 0x2;  // The output buffer ran low, likely causing a gap in the output sound.
+
+//! RtAudio callback function prototype.
+/*!
+   All RtAudio clients must create a function of type RtAudioCallback
+   to read and/or write data from/to the audio stream.  When the
+   underlying audio system is ready for new input or output data, this
+   function will be invoked.
+
+   \param outputBuffer For output (or duplex) streams, the client
+          should write \c nFrames of audio sample frames into this
+          buffer.  This argument should be recast to the datatype
+          specified when the stream was opened.  For input-only
+          streams, this argument will be NULL.
+
+   \param inputBuffer For input (or duplex) streams, this buffer will
+          hold \c nFrames of input audio sample frames.  This
+          argument should be recast to the datatype specified when the
+          stream was opened.  For output-only streams, this argument
+          will be NULL.
+
+   \param nFrames The number of sample frames of input or output
+          data in the buffers.  The actual buffer size in bytes is
+          dependent on the data type and number of channels in use.
+
+   \param streamTime The number of seconds that have elapsed since the
+          stream was started.
+
+   \param status If non-zero, this argument indicates a data overflow
+          or underflow condition for the stream.  The particular
+          condition can be determined by comparison with the
+          RtAudioStreamStatus flags.
+
+   \param userData A pointer to optional data provided by the client
+          when opening the stream (default = NULL).
+
+   To continue normal stream operation, the RtAudioCallback function
+   should return a value of zero.  To stop the stream and drain the
+   output buffer, the function should return a value of one.  To abort
+   the stream immediately, the client should return a value of two.
+ */
+typedef int (*RtAudioCallback)(void *outputBuffer, void *inputBuffer,
+							   unsigned int nFrames,
+							   double streamTime,
+							   RtAudioStreamStatus status,
+							   void *userData);
+
+/************************************************************************/
+/*! \class RtAudioError
+    \brief Exception handling class for RtAudio.
+
+    The RtAudioError class is quite simple but it does allow errors to be
+    "caught" by RtAudioError::Type. See the RtAudio documentation to know
+    which methods can throw an RtAudioError.
+*/
+/************************************************************************/
+
+class RtAudioError : public std::exception
+{
+public:
+	//! Defined RtAudioError types.
+	enum Type
+	{
+		WARNING,           /*!< A non-critical error. */
+		DEBUG_WARNING,     /*!< A non-critical error which might be useful for debugging. */
+		UNSPECIFIED,       /*!< The default, unspecified error type. */
+		NO_DEVICES_FOUND,  /*!< No devices found on system. */
+		INVALID_DEVICE,    /*!< An invalid device ID was specified. */
+		MEMORY_ERROR,      /*!< An error occured during memory allocation. */
+		INVALID_PARAMETER, /*!< An invalid parameter was specified to a function. */
+		INVALID_USE,       /*!< The function was called incorrectly. */
+		DRIVER_ERROR,      /*!< A system driver error occured. */
+		SYSTEM_ERROR,      /*!< A system error occured. */
+		THREAD_ERROR       /*!< A thread error occured. */
+	};
+
+	//! The constructor.
+	RtAudioError(const std::string &message, Type type = RtAudioError::UNSPECIFIED) throw() : message_(message), type_(type) {}
+
+	//! The destructor.
+	virtual ~RtAudioError(void) throw() {}
+
+	//! Prints thrown error message to stderr.
+	virtual void printMessage(void) const throw() { std::cerr << '\n'
+															  << message_ << "\n\n"; }
+
+	//! Returns the thrown error message type.
+	virtual const Type &getType(void) const throw() { return type_; }
+
+	//! Returns the thrown error message string.
+	virtual const std::string &getMessage(void) const throw() { return message_; }
+
+	//! Returns the thrown error message as a c-style string.
+	virtual const char *what(void) const throw() { return message_.c_str(); }
+
+protected:
+	std::string message_;
+	Type type_;
+};
+
+//! RtAudio error callback function prototype.
+/*!
+    \param type Type of error.
+    \param errorText Error description.
+ */
+typedef void (*RtAudioErrorCallback)(RtAudioError::Type type, const std::string &errorText);
+
+// **************************************************************** //
+//
+// RtAudio class declaration.
+//
+// RtAudio is a "controller" used to select an available audio i/o
+// interface.  It presents a common API for the user to call but all
+// functionality is implemented by the class RtApi and its
+// subclasses.  RtAudio creates an instance of an RtApi subclass
+// based on the user's API choice.  If no choice is made, RtAudio
+// attempts to make a "logical" API selection.
+//
+// **************************************************************** //
+
+class RtApi;
+
+class RtAudio
+{
+public:
+	//! Audio API specifier arguments.
+	enum Api
+	{
+		UNSPECIFIED,    /*!< Search for a working compiled API. */
+		LINUX_ALSA,     /*!< The Advanced Linux Sound Architecture API. */
+		LINUX_PULSE,    /*!< The Linux PulseAudio API. */
+		LINUX_OSS,      /*!< The Linux Open Sound System API. */
+		UNIX_JACK,      /*!< The Jack Low-Latency Audio Server API. */
+		MACOSX_CORE,    /*!< Macintosh OS-X Core Audio API. */
+		WINDOWS_WASAPI, /*!< The Microsoft WASAPI API. */
+		WINDOWS_ASIO,   /*!< The Steinberg Audio Stream I/O API. */
+		WINDOWS_DS,     /*!< The Microsoft Direct Sound API. */
+		RTAUDIO_DUMMY   /*!< A compilable but non-functional API. */
+	};
+
+	//! The public device information structure for returning queried values.
+	struct DeviceInfo
+	{
+		bool probed;                           /*!< true if the device capabilities were successfully probed. */
+		std::string name;                      /*!< Character string device identifier. */
+		unsigned int outputChannels;           /*!< Maximum output channels supported by device. */
+		unsigned int inputChannels;            /*!< Maximum input channels supported by device. */
+		unsigned int duplexChannels;           /*!< Maximum simultaneous input/output channels supported by device. */
+		bool isDefaultOutput;                  /*!< true if this is the default output device. */
+		bool isDefaultInput;                   /*!< true if this is the default input device. */
+		std::vector<unsigned int> sampleRates; /*!< Supported sample rates (queried from list of standard rates). */
+		unsigned int preferredSampleRate;      /*!< Preferred sample rate, eg. for WASAPI the system sample rate. */
+		RtAudioFormat nativeFormats;           /*!< Bit mask of supported data formats. */
+
+		// Default constructor.
+		DeviceInfo()
+			: probed(false), outputChannels(0), inputChannels(0), duplexChannels(0), isDefaultOutput(false), isDefaultInput(false), preferredSampleRate(0), nativeFormats(0) {}
+	};
+
+	//! The structure for specifying input or ouput stream parameters.
+	struct StreamParameters
+	{
+		unsigned int deviceId;     /*!< Device index (0 to getDeviceCount() - 1). */
+		unsigned int nChannels;    /*!< Number of channels. */
+		unsigned int firstChannel; /*!< First channel index on device (default = 0). */
+
+		// Default constructor.
+		StreamParameters()
+			: deviceId(0), nChannels(0), firstChannel(0) {}
+	};
+
+	//! The structure for specifying stream options.
+	/*!
+    The following flags can be OR'ed together to allow a client to
+    make changes to the default stream behavior:
+
+    - \e RTAUDIO_NONINTERLEAVED:    Use non-interleaved buffers (default = interleaved).
+    - \e RTAUDIO_MINIMIZE_LATENCY:  Attempt to set stream parameters for lowest possible latency.
+    - \e RTAUDIO_HOG_DEVICE:        Attempt grab device for exclusive use.
+    - \e RTAUDIO_SCHEDULE_REALTIME: Attempt to select realtime scheduling for callback thread.
+    - \e RTAUDIO_ALSA_USE_DEFAULT:  Use the "default" PCM device (ALSA only).
+
+    By default, RtAudio streams pass and receive audio data from the
+    client in an interleaved format.  By passing the
+    RTAUDIO_NONINTERLEAVED flag to the openStream() function, audio
+    data will instead be presented in non-interleaved buffers.  In
+    this case, each buffer argument in the RtAudioCallback function
+    will point to a single array of data, with \c nFrames samples for
+    each channel concatenated back-to-back.  For example, the first
+    sample of data for the second channel would be located at index \c
+    nFrames (assuming the \c buffer pointer was recast to the correct
+    data type for the stream).
+
+    Certain audio APIs offer a number of parameters that influence the
+    I/O latency of a stream.  By default, RtAudio will attempt to set
+    these parameters internally for robust (glitch-free) performance
+    (though some APIs, like Windows Direct Sound, make this difficult).
+    By passing the RTAUDIO_MINIMIZE_LATENCY flag to the openStream()
+    function, internal stream settings will be influenced in an attempt
+    to minimize stream latency, though possibly at the expense of stream
+    performance.
+
+    If the RTAUDIO_HOG_DEVICE flag is set, RtAudio will attempt to
+    open the input and/or output stream device(s) for exclusive use.
+    Note that this is not possible with all supported audio APIs.
+
+    If the RTAUDIO_SCHEDULE_REALTIME flag is set, RtAudio will attempt 
+    to select realtime scheduling (round-robin) for the callback thread.
+    The \c priority parameter will only be used if the RTAUDIO_SCHEDULE_REALTIME
+    flag is set. It defines the thread's realtime priority.
+
+    If the RTAUDIO_ALSA_USE_DEFAULT flag is set, RtAudio will attempt to
+    open the "default" PCM device when using the ALSA API. Note that this
+    will override any specified input or output device id.
+
+    The \c numberOfBuffers parameter can be used to control stream
+    latency in the Windows DirectSound, Linux OSS, and Linux Alsa APIs
+    only.  A value of two is usually the smallest allowed.  Larger
+    numbers can potentially result in more robust stream performance,
+    though likely at the cost of stream latency.  The value set by the
+    user is replaced during execution of the RtAudio::openStream()
+    function by the value actually used by the system.
+
+    The \c streamName parameter can be used to set the client name
+    when using the Jack API.  By default, the client name is set to
+    RtApiJack.  However, if you wish to create multiple instances of
+    RtAudio with Jack, each instance must have a unique client name.
+  */
+	struct StreamOptions
+	{
+		RtAudioStreamFlags flags;     /*!< A bit-mask of stream flags (RTAUDIO_NONINTERLEAVED, RTAUDIO_MINIMIZE_LATENCY, RTAUDIO_HOG_DEVICE, RTAUDIO_ALSA_USE_DEFAULT). */
+		unsigned int numberOfBuffers; /*!< Number of stream buffers. */
+		std::string streamName;       /*!< A stream name (currently used only in Jack). */
+		int priority;                 /*!< Scheduling priority of callback thread (only used with flag RTAUDIO_SCHEDULE_REALTIME). */
+
+		// Default constructor.
+		StreamOptions()
+			: flags(0), numberOfBuffers(0), priority(0) {}
+	};
+
+	//! A static function to determine the current RtAudio version.
+	static std::string getVersion(void) throw();
+
+	//! A static function to determine the available compiled audio APIs.
+	/*!
+    The values returned in the std::vector can be compared against
+    the enumerated list values.  Note that there can be more than one
+    API compiled for certain operating systems.
+  */
+	static void getCompiledApi(std::vector<RtAudio::Api> &apis) throw();
+
+	//! The class constructor.
+	/*!
+    The constructor performs minor initialization tasks.  An exception
+    can be thrown if no API support is compiled.
+
+    If no API argument is specified and multiple API support has been
+    compiled, the default order of use is JACK, ALSA, OSS (Linux
+    systems) and ASIO, DS (Windows systems).
+  */
+	RtAudio(RtAudio::Api api = UNSPECIFIED);
+
+	//! The destructor.
+	/*!
+    If a stream is running or open, it will be stopped and closed
+    automatically.
+  */
+	~RtAudio() throw();
+
+	//! Returns the audio API specifier for the current instance of RtAudio.
+	RtAudio::Api getCurrentApi(void) throw();
+
+	//! A public function that queries for the number of audio devices available.
+	/*!
+    This function performs a system query of available devices each time it
+    is called, thus supporting devices connected \e after instantiation. If
+    a system error occurs during processing, a warning will be issued. 
+  */
+	unsigned int getDeviceCount(void) throw();
+
+	//! Return an RtAudio::DeviceInfo structure for a specified device number.
+	/*!
+
+    Any device integer between 0 and getDeviceCount() - 1 is valid.
+    If an invalid argument is provided, an RtAudioError (type = INVALID_USE)
+    will be thrown.  If a device is busy or otherwise unavailable, the
+    structure member "probed" will have a value of "false" and all
+    other members are undefined.  If the specified device is the
+    current default input or output device, the corresponding
+    "isDefault" member will have a value of "true".
+  */
+	RtAudio::DeviceInfo getDeviceInfo(unsigned int device);
+
+	//! A function that returns the index of the default output device.
+	/*!
+    If the underlying audio API does not provide a "default
+    device", or if no devices are available, the return value will be
+    0.  Note that this is a valid device identifier and it is the
+    client's responsibility to verify that a device is available
+    before attempting to open a stream.
+  */
+	unsigned int getDefaultOutputDevice(void) throw();
+
+	//! A function that returns the index of the default input device.
+	/*!
+    If the underlying audio API does not provide a "default
+    device", or if no devices are available, the return value will be
+    0.  Note that this is a valid device identifier and it is the
+    client's responsibility to verify that a device is available
+    before attempting to open a stream.
+  */
+	unsigned int getDefaultInputDevice(void) throw();
+
+	//! A public function for opening a stream with the specified parameters.
+	/*!
+    An RtAudioError (type = SYSTEM_ERROR) is thrown if a stream cannot be
+    opened with the specified parameters or an error occurs during
+    processing.  An RtAudioError (type = INVALID_USE) is thrown if any
+    invalid device ID or channel number parameters are specified.
+
+    \param outputParameters Specifies output stream parameters to use
+           when opening a stream, including a device ID, number of channels,
+           and starting channel number.  For input-only streams, this
+           argument should be NULL.  The device ID is an index value between
+           0 and getDeviceCount() - 1.
+    \param inputParameters Specifies input stream parameters to use
+           when opening a stream, including a device ID, number of channels,
+           and starting channel number.  For output-only streams, this
+           argument should be NULL.  The device ID is an index value between
+           0 and getDeviceCount() - 1.
+    \param format An RtAudioFormat specifying the desired sample data format.
+    \param sampleRate The desired sample rate (sample frames per second).
+    \param *bufferFrames A pointer to a value indicating the desired
+           internal buffer size in sample frames.  The actual value
+           used by the device is returned via the same pointer.  A
+           value of zero can be specified, in which case the lowest
+           allowable value is determined.
+    \param callback A client-defined function that will be invoked
+           when input data is available and/or output data is needed.
+    \param userData An optional pointer to data that can be accessed
+           from within the callback function.
+    \param options An optional pointer to a structure containing various
+           global stream options, including a list of OR'ed RtAudioStreamFlags
+           and a suggested number of stream buffers that can be used to 
+           control stream latency.  More buffers typically result in more
+           robust performance, though at a cost of greater latency.  If a
+           value of zero is specified, a system-specific median value is
+           chosen.  If the RTAUDIO_MINIMIZE_LATENCY flag bit is set, the
+           lowest allowable value is used.  The actual value used is
+           returned via the structure argument.  The parameter is API dependent.
+    \param errorCallback A client-defined function that will be invoked
+           when an error has occured.
+  */
+	void openStream(RtAudio::StreamParameters *outputParameters,
+					RtAudio::StreamParameters *inputParameters,
+					RtAudioFormat format, unsigned int sampleRate,
+					unsigned int *bufferFrames, RtAudioCallback callback,
+					void *userData = NULL, RtAudio::StreamOptions *options = NULL, RtAudioErrorCallback errorCallback = NULL);
+
+	//! A function that closes a stream and frees any associated stream memory.
+	/*!
+    If a stream is not open, this function issues a warning and
+    returns (no exception is thrown).
+  */
+	void closeStream(void) throw();
+
+	//! A function that starts a stream.
+	/*!
+    An RtAudioError (type = SYSTEM_ERROR) is thrown if an error occurs
+    during processing.  An RtAudioError (type = INVALID_USE) is thrown if a
+    stream is not open.  A warning is issued if the stream is already
+    running.
+  */
+	void startStream(void);
+
+	//! Stop a stream, allowing any samples remaining in the output queue to be played.
+	/*!
+    An RtAudioError (type = SYSTEM_ERROR) is thrown if an error occurs
+    during processing.  An RtAudioError (type = INVALID_USE) is thrown if a
+    stream is not open.  A warning is issued if the stream is already
+    stopped.
+  */
+	void stopStream(void);
+
+	//! Stop a stream, discarding any samples remaining in the input/output queue.
+	/*!
+    An RtAudioError (type = SYSTEM_ERROR) is thrown if an error occurs
+    during processing.  An RtAudioError (type = INVALID_USE) is thrown if a
+    stream is not open.  A warning is issued if the stream is already
+    stopped.
+  */
+	void abortStream(void);
+
+	//! Returns true if a stream is open and false if not.
+	bool isStreamOpen(void) const throw();
+
+	//! Returns true if the stream is running and false if it is stopped or not open.
+	bool isStreamRunning(void) const throw();
+
+	//! Returns the number of elapsed seconds since the stream was started.
+	/*!
+    If a stream is not open, an RtAudioError (type = INVALID_USE) will be thrown.
+  */
+	double getStreamTime(void);
+
+	//! Set the stream time to a time in seconds greater than or equal to 0.0.
+	/*!
+    If a stream is not open, an RtAudioError (type = INVALID_USE) will be thrown.
+  */
+	void setStreamTime(double time);
+
+	//! Returns the internal stream latency in sample frames.
+	/*!
+    The stream latency refers to delay in audio input and/or output
+    caused by internal buffering by the audio system and/or hardware.
+    For duplex streams, the returned value will represent the sum of
+    the input and output latencies.  If a stream is not open, an
+    RtAudioError (type = INVALID_USE) will be thrown.  If the API does not
+    report latency, the return value will be zero.
+  */
+	long getStreamLatency(void);
+
+	//! Returns actual sample rate in use by the stream.
+	/*!
+   On some systems, the sample rate used may be slightly different
+   than that specified in the stream parameters.  If a stream is not
+   open, an RtAudioError (type = INVALID_USE) will be thrown.
+ */
+	unsigned int getStreamSampleRate(void);
+
+	//! Specify whether warning messages should be printed to stderr.
+	void showWarnings(bool value = true) throw();
+
+protected:
+	void openRtApi(RtAudio::Api api);
+	RtApi *rtapi_;
+};
+
+// Operating system dependent thread functionality.
+#if defined(__WINDOWS_DS__) || defined(__WINDOWS_ASIO__) || defined(__WINDOWS_WASAPI__)
+
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <windows.h>
+#include <process.h>
+
+typedef uintptr_t ThreadHandle;
+typedef CRITICAL_SECTION StreamMutex;
+
+#elif defined(__LINUX_ALSA__) || defined(__LINUX_PULSE__) || defined(__UNIX_JACK__) || defined(__LINUX_OSS__) || defined(__MACOSX_CORE__)
+// Using pthread library for various flavors of unix.
+#include <pthread.h>
+
+typedef pthread_t ThreadHandle;
+typedef pthread_mutex_t StreamMutex;
+
+#else  // Setup for "dummy" behavior
+
+#define __RTAUDIO_DUMMY__
+typedef int ThreadHandle;
+typedef int StreamMutex;
+
+#endif
+
+// This global structure type is used to pass callback information
+// between the private RtAudio stream structure and global callback
+// handling functions.
+struct CallbackInfo
+{
+	void *object;  // Used as a "this" pointer.
+	ThreadHandle thread;
+	void *callback;
+	void *userData;
+	void *errorCallback;
+	void *apiInfo;  // void pointer for API specific callback information
+	bool isRunning;
+	bool doRealtime;
+	int priority;
+
+	// Default constructor.
+	CallbackInfo()
+		: object(0), callback(0), userData(0), errorCallback(0), apiInfo(0), isRunning(false), doRealtime(false) {}
+};
+
+// **************************************************************** //
+//
+// RtApi class declaration.
+//
+// Subclasses of RtApi contain all API- and OS-specific code necessary
+// to fully implement the RtAudio API.
+//
+// Note that RtApi is an abstract base class and cannot be
+// explicitly instantiated.  The class RtAudio will create an
+// instance of an RtApi subclass (RtApiOss, RtApiAlsa,
+// RtApiJack, RtApiCore, RtApiDs, or RtApiAsio).
+//
+// **************************************************************** //
+
+#pragma pack(push, 1)
+class S24
+{
+protected:
+	unsigned char c3[3];
+
+public:
+	S24() {}
+
+	S24 &operator=(const int &i)
+	{
+		c3[0] = (i & 0x000000ff);
+		c3[1] = (i & 0x0000ff00) >> 8;
+		c3[2] = (i & 0x00ff0000) >> 16;
+		return *this;
+	}
+
+	S24(const S24 &v) { *this = v; }
+	S24(const double &d) { *this = (int)d; }
+	S24(const float &f) { *this = (int)f; }
+	S24(const signed short &s) { *this = (int)s; }
+	S24(const char &c) { *this = (int)c; }
+
+	int asInt()
+	{
+		int i = c3[0] | (c3[1] << 8) | (c3[2] << 16);
+		if (i & 0x800000) i |= ~0xffffff;
+		return i;
+	}
+};
+#pragma pack(pop)
+
+#if defined(HAVE_GETTIMEOFDAY)
+#include <sys/time.h>
+#endif
+
+#include <sstream>
+
+class RtApi
+{
+public:
+	RtApi();
+	virtual ~RtApi();
+	virtual RtAudio::Api getCurrentApi(void) = 0;
+	virtual unsigned int getDeviceCount(void) = 0;
+	virtual RtAudio::DeviceInfo getDeviceInfo(unsigned int device) = 0;
+	virtual unsigned int getDefaultInputDevice(void);
+	virtual unsigned int getDefaultOutputDevice(void);
+	void openStream(RtAudio::StreamParameters *outputParameters,
+					RtAudio::StreamParameters *inputParameters,
+					RtAudioFormat format, unsigned int sampleRate,
+					unsigned int *bufferFrames, RtAudioCallback callback,
+					void *userData, RtAudio::StreamOptions *options,
+					RtAudioErrorCallback errorCallback);
+	virtual void closeStream(void);
+	virtual void startStream(void) = 0;
+	virtual void stopStream(void) = 0;
+	virtual void abortStream(void) = 0;
+	long getStreamLatency(void);
+	unsigned int getStreamSampleRate(void);
+	virtual double getStreamTime(void);
+	virtual void setStreamTime(double time);
+	bool isStreamOpen(void) const { return stream_.state != STREAM_CLOSED; }
+	bool isStreamRunning(void) const { return stream_.state == STREAM_RUNNING; }
+	void showWarnings(bool value) { showWarnings_ = value; }
+
+protected:
+	static const unsigned int MAX_SAMPLE_RATES;
+	static const unsigned int SAMPLE_RATES[];
+
+	enum
+	{
+		FAILURE,
+		SUCCESS
+	};
+
+	enum StreamState
+	{
+		STREAM_STOPPED,
+		STREAM_STOPPING,
+		STREAM_RUNNING,
+		STREAM_CLOSED = -50
+	};
+
+	enum StreamMode
+	{
+		OUTPUT,
+		INPUT,
+		DUPLEX,
+		UNINITIALIZED = -75
+	};
+
+	// A protected structure used for buffer conversion.
+	struct ConvertInfo
+	{
+		int channels;
+		int inJump, outJump;
+		RtAudioFormat inFormat, outFormat;
+		std::vector<int> inOffset;
+		std::vector<int> outOffset;
+	};
+
+	// A protected structure for audio streams.
+	struct RtApiStream
+	{
+		unsigned int device[2];  // Playback and record, respectively.
+		void *apiHandle;         // void pointer for API specific stream handle information
+		StreamMode mode;         // OUTPUT, INPUT, or DUPLEX.
+		StreamState state;       // STOPPED, RUNNING, or CLOSED
+		char *userBuffer[2];     // Playback and record, respectively.
+		char *deviceBuffer;
+		bool doConvertBuffer[2];  // Playback and record, respectively.
+		bool userInterleaved;
+		bool deviceInterleaved[2];  // Playback and record, respectively.
+		bool doByteSwap[2];         // Playback and record, respectively.
+		unsigned int sampleRate;
+		unsigned int bufferSize;
+		unsigned int nBuffers;
+		unsigned int nUserChannels[2];    // Playback and record, respectively.
+		unsigned int nDeviceChannels[2];  // Playback and record channels, respectively.
+		unsigned int channelOffset[2];    // Playback and record, respectively.
+		unsigned long latency[2];         // Playback and record, respectively.
+		RtAudioFormat userFormat;
+		RtAudioFormat deviceFormat[2];  // Playback and record, respectively.
+		StreamMutex mutex;
+		CallbackInfo callbackInfo;
+		ConvertInfo convertInfo[2];
+		double streamTime;  // Number of elapsed seconds since the stream started.
+
+#if defined(HAVE_GETTIMEOFDAY)
+		struct timeval lastTickTimestamp;
+#endif
+
+		RtApiStream()
+			: apiHandle(0), deviceBuffer(0)
+		{
+			device[0] = 11111;
+			device[1] = 11111;
+		}
+	};
+
+	typedef S24 Int24;
+	typedef signed short Int16;
+	typedef signed int Int32;
+	typedef float Float32;
+	typedef double Float64;
+
+	std::ostringstream errorStream_;
+	std::string errorText_;
+	bool showWarnings_;
+	RtApiStream stream_;
+	bool firstErrorOccurred_;
+
+	/*!
+    Protected, api-specific method that attempts to open a device
+    with the given parameters.  This function MUST be implemented by
+    all subclasses.  If an error is encountered during the probe, a
+    "warning" message is reported and FAILURE is returned. A
+    successful probe is indicated by a return value of SUCCESS.
+  */
+	virtual bool probeDeviceOpen(unsigned int device, StreamMode mode, unsigned int channels,
+								 unsigned int firstChannel, unsigned int sampleRate,
+								 RtAudioFormat format, unsigned int *bufferSize,
+								 RtAudio::StreamOptions *options);
+
+	//! A protected function used to increment the stream time.
+	void tickStreamTime(void);
+
+	//! Protected common method to clear an RtApiStream structure.
+	void clearStreamInfo();
+
+	/*!
+    Protected common method that throws an RtAudioError (type =
+    INVALID_USE) if a stream is not open.
+  */
+	void verifyStream(void);
+
+	//! Protected common error method to allow global control over error handling.
+	void error(RtAudioError::Type type);
+
+	/*!
+    Protected method used to perform format, channel number, and/or interleaving
+    conversions between the user and device buffers.
+  */
+	void convertBuffer(char *outBuffer, char *inBuffer, ConvertInfo &info);
+
+	//! Protected common method used to perform byte-swapping on buffers.
+	void byteSwapBuffer(char *buffer, unsigned int samples, RtAudioFormat format);
+
+	//! Protected common method that returns the number of bytes for a given format.
+	unsigned int formatBytes(RtAudioFormat format);
+
+	//! Protected common method that sets up the parameters for buffer conversion.
+	void setConvertInfo(StreamMode mode, unsigned int firstChannel);
+};
+
+// **************************************************************** //
+//
+// Inline RtAudio definitions.
+//
+// **************************************************************** //
+
+inline RtAudio::Api RtAudio ::getCurrentApi(void) throw() { return rtapi_->getCurrentApi(); }
+inline unsigned int RtAudio ::getDeviceCount(void) throw() { return rtapi_->getDeviceCount(); }
+inline RtAudio::DeviceInfo RtAudio ::getDeviceInfo(unsigned int device) { return rtapi_->getDeviceInfo(device); }
+inline unsigned int RtAudio ::getDefaultInputDevice(void) throw() { return rtapi_->getDefaultInputDevice(); }
+inline unsigned int RtAudio ::getDefaultOutputDevice(void) throw() { return rtapi_->getDefaultOutputDevice(); }
+inline void RtAudio ::closeStream(void) throw() { return rtapi_->closeStream(); }
+inline void RtAudio ::startStream(void) { return rtapi_->startStream(); }
+inline void RtAudio ::stopStream(void) { return rtapi_->stopStream(); }
+inline void RtAudio ::abortStream(void) { return rtapi_->abortStream(); }
+inline bool RtAudio ::isStreamOpen(void) const throw() { return rtapi_->isStreamOpen(); }
+inline bool RtAudio ::isStreamRunning(void) const throw() { return rtapi_->isStreamRunning(); }
+inline long RtAudio ::getStreamLatency(void) { return rtapi_->getStreamLatency(); }
+inline unsigned int RtAudio ::getStreamSampleRate(void) { return rtapi_->getStreamSampleRate(); }
+inline double RtAudio ::getStreamTime(void) { return rtapi_->getStreamTime(); }
+inline void RtAudio ::setStreamTime(double time) { return rtapi_->setStreamTime(time); }
+inline void RtAudio ::showWarnings(bool value) throw() { rtapi_->showWarnings(value); }
+
+// RtApi Subclass prototypes.
+
+#if defined(__MACOSX_CORE__)
+
+#include <CoreAudio/AudioHardware.h>
+
+class RtApiCore : public RtApi
+{
+public:
+	RtApiCore();
+	~RtApiCore();
+	RtAudio::Api getCurrentApi(void) { return RtAudio::MACOSX_CORE; }
+	unsigned int getDeviceCount(void);
+	RtAudio::DeviceInfo getDeviceInfo(unsigned int device);
+	unsigned int getDefaultOutputDevice(void);
+	unsigned int getDefaultInputDevice(void);
+	void closeStream(void);
+	void startStream(void);
+	void stopStream(void);
+	void abortStream(void);
+	long getStreamLatency(void);
+
+	// This function is intended for internal use only.  It must be
+	// public because it is called by the internal callback handler,
+	// which is not a member of RtAudio.  External use of this function
+	// will most likely produce highly undesireable results!
+	bool callbackEvent(AudioDeviceID deviceId,
+					   const AudioBufferList *inBufferList,
+					   const AudioBufferList *outBufferList);
+
+private:
+	bool probeDeviceOpen(unsigned int device, StreamMode mode, unsigned int channels,
+						 unsigned int firstChannel, unsigned int sampleRate,
+						 RtAudioFormat format, unsigned int *bufferSize,
+						 RtAudio::StreamOptions *options);
+	static const char *getErrorCode(OSStatus code);
+};
+
+#endif
+
+#if defined(__UNIX_JACK__)
+
+class RtApiJack : public RtApi
+{
+public:
+	RtApiJack();
+	~RtApiJack();
+	RtAudio::Api getCurrentApi(void) { return RtAudio::UNIX_JACK; }
+	unsigned int getDeviceCount(void);
+	RtAudio::DeviceInfo getDeviceInfo(unsigned int device);
+	void closeStream(void);
+	void startStream(void);
+	void stopStream(void);
+	void abortStream(void);
+	long getStreamLatency(void);
+
+	// This function is intended for internal use only.  It must be
+	// public because it is called by the internal callback handler,
+	// which is not a member of RtAudio.  External use of this function
+	// will most likely produce highly undesireable results!
+	bool callbackEvent(unsigned long nframes);
+
+private:
+	bool probeDeviceOpen(unsigned int device, StreamMode mode, unsigned int channels,
+						 unsigned int firstChannel, unsigned int sampleRate,
+						 RtAudioFormat format, unsigned int *bufferSize,
+						 RtAudio::StreamOptions *options);
+};
+
+#endif
+
+#if defined(__WINDOWS_ASIO__)
+
+class RtApiAsio : public RtApi
+{
+public:
+	RtApiAsio();
+	~RtApiAsio();
+	RtAudio::Api getCurrentApi(void) { return RtAudio::WINDOWS_ASIO; }
+	unsigned int getDeviceCount(void);
+	RtAudio::DeviceInfo getDeviceInfo(unsigned int device);
+	void closeStream(void);
+	void startStream(void);
+	void stopStream(void);
+	void abortStream(void);
+	long getStreamLatency(void);
+
+	// This function is intended for internal use only.  It must be
+	// public because it is called by the internal callback handler,
+	// which is not a member of RtAudio.  External use of this function
+	// will most likely produce highly undesireable results!
+	bool callbackEvent(long bufferIndex);
+
+private:
+	std::vector<RtAudio::DeviceInfo> devices_;
+	void saveDeviceInfo(void);
+	bool coInitialized_;
+	bool probeDeviceOpen(unsigned int device, StreamMode mode, unsigned int channels,
+						 unsigned int firstChannel, unsigned int sampleRate,
+						 RtAudioFormat format, unsigned int *bufferSize,
+						 RtAudio::StreamOptions *options);
+};
+
+#endif
+
+#if defined(__WINDOWS_DS__)
+
+class RtApiDs : public RtApi
+{
+public:
+	RtApiDs();
+	~RtApiDs();
+	RtAudio::Api getCurrentApi(void) { return RtAudio::WINDOWS_DS; }
+	unsigned int getDeviceCount(void);
+	unsigned int getDefaultOutputDevice(void);
+	unsigned int getDefaultInputDevice(void);
+	RtAudio::DeviceInfo getDeviceInfo(unsigned int device);
+	void closeStream(void);
+	void startStream(void);
+	void stopStream(void);
+	void abortStream(void);
+	long getStreamLatency(void);
+
+	// This function is intended for internal use only.  It must be
+	// public because it is called by the internal callback handler,
+	// which is not a member of RtAudio.  External use of this function
+	// will most likely produce highly undesireable results!
+	void callbackEvent(void);
+
+private:
+	bool coInitialized_;
+	bool buffersRolling;
+	long duplexPrerollBytes;
+	std::vector<struct DsDevice> dsDevices;
+	bool probeDeviceOpen(unsigned int device, StreamMode mode, unsigned int channels,
+						 unsigned int firstChannel, unsigned int sampleRate,
+						 RtAudioFormat format, unsigned int *bufferSize,
+						 RtAudio::StreamOptions *options);
+};
+
+#endif
+
+#if defined(__WINDOWS_WASAPI__)
+
+struct IMMDeviceEnumerator;
+
+class RtApiWasapi : public RtApi
+{
+public:
+	RtApiWasapi();
+	~RtApiWasapi();
+
+	RtAudio::Api getCurrentApi(void) { return RtAudio::WINDOWS_WASAPI; }
+	unsigned int getDeviceCount(void);
+	RtAudio::DeviceInfo getDeviceInfo(unsigned int device);
+	unsigned int getDefaultOutputDevice(void);
+	unsigned int getDefaultInputDevice(void);
+	void closeStream(void);
+	void startStream(void);
+	void stopStream(void);
+	void abortStream(void);
+
+private:
+	bool coInitialized_;
+	IMMDeviceEnumerator *deviceEnumerator_;
+
+	bool probeDeviceOpen(unsigned int device, StreamMode mode, unsigned int channels,
+						 unsigned int firstChannel, unsigned int sampleRate,
+						 RtAudioFormat format, unsigned int *bufferSize,
+						 RtAudio::StreamOptions *options);
+
+	static DWORD WINAPI runWasapiThread(void *wasapiPtr);
+	static DWORD WINAPI stopWasapiThread(void *wasapiPtr);
+	static DWORD WINAPI abortWasapiThread(void *wasapiPtr);
+	void wasapiThread();
+};
+
+#endif
+
+#if defined(__LINUX_ALSA__)
+
+class RtApiAlsa : public RtApi
+{
+public:
+	RtApiAlsa();
+	~RtApiAlsa();
+	RtAudio::Api getCurrentApi() { return RtAudio::LINUX_ALSA; }
+	unsigned int getDeviceCount(void);
+	RtAudio::DeviceInfo getDeviceInfo(unsigned int device);
+	void closeStream(void);
+	void startStream(void);
+	void stopStream(void);
+	void abortStream(void);
+
+	// This function is intended for internal use only.  It must be
+	// public because it is called by the internal callback handler,
+	// which is not a member of RtAudio.  External use of this function
+	// will most likely produce highly undesireable results!
+	void callbackEvent(void);
+
+private:
+	std::vector<RtAudio::DeviceInfo> devices_;
+	void saveDeviceInfo(void);
+	bool probeDeviceOpen(unsigned int device, StreamMode mode, unsigned int channels,
+						 unsigned int firstChannel, unsigned int sampleRate,
+						 RtAudioFormat format, unsigned int *bufferSize,
+						 RtAudio::StreamOptions *options);
+};
+
+#endif
+
+#if defined(__LINUX_PULSE__)
+
+class RtApiPulse : public RtApi
+{
+public:
+	~RtApiPulse();
+	RtAudio::Api getCurrentApi() { return RtAudio::LINUX_PULSE; }
+	unsigned int getDeviceCount(void);
+	RtAudio::DeviceInfo getDeviceInfo(unsigned int device);
+	void closeStream(void);
+	void startStream(void);
+	void stopStream(void);
+	void abortStream(void);
+
+	// This function is intended for internal use only.  It must be
+	// public because it is called by the internal callback handler,
+	// which is not a member of RtAudio.  External use of this function
+	// will most likely produce highly undesireable results!
+	void callbackEvent(void);
+
+private:
+	std::vector<RtAudio::DeviceInfo> devices_;
+	void saveDeviceInfo(void);
+	bool probeDeviceOpen(unsigned int device, StreamMode mode, unsigned int channels,
+						 unsigned int firstChannel, unsigned int sampleRate,
+						 RtAudioFormat format, unsigned int *bufferSize,
+						 RtAudio::StreamOptions *options);
+};
+
+#endif
+
+#if defined(__LINUX_OSS__)
+
+class RtApiOss : public RtApi
+{
+public:
+	RtApiOss();
+	~RtApiOss();
+	RtAudio::Api getCurrentApi() { return RtAudio::LINUX_OSS; }
+	unsigned int getDeviceCount(void);
+	RtAudio::DeviceInfo getDeviceInfo(unsigned int device);
+	void closeStream(void);
+	void startStream(void);
+	void stopStream(void);
+	void abortStream(void);
+
+	// This function is intended for internal use only.  It must be
+	// public because it is called by the internal callback handler,
+	// which is not a member of RtAudio.  External use of this function
+	// will most likely produce highly undesireable results!
+	void callbackEvent(void);
+
+private:
+	bool probeDeviceOpen(unsigned int device, StreamMode mode, unsigned int channels,
+						 unsigned int firstChannel, unsigned int sampleRate,
+						 RtAudioFormat format, unsigned int *bufferSize,
+						 RtAudio::StreamOptions *options);
+};
+
+#endif
+
+#if defined(__RTAUDIO_DUMMY__)
+
+class RtApiDummy : public RtApi
+{
+public:
+	RtApiDummy()
+	{
+		errorText_ = "RtApiDummy: This class provides no functionality.";
+		error(RtAudioError::WARNING);
+	}
+	RtAudio::Api getCurrentApi(void) { return RtAudio::RTAUDIO_DUMMY; }
+	unsigned int getDeviceCount(void) { return 0; }
+	RtAudio::DeviceInfo getDeviceInfo(unsigned int /*device*/)
+	{
+		RtAudio::DeviceInfo info;
+		return info;
+	}
+	void closeStream(void) {}
+	void startStream(void) {}
+	void stopStream(void) {}
+	void abortStream(void) {}
+
+private:
+	bool probeDeviceOpen(unsigned int /*device*/, StreamMode /*mode*/, unsigned int /*channels*/,
+						 unsigned int /*firstChannel*/, unsigned int /*sampleRate*/,
+						 RtAudioFormat /*format*/, unsigned int * /*bufferSize*/,
+						 RtAudio::StreamOptions * /*options*/) { return false; }
+};
+
+#endif
+
+#endif
+
+// Indentation settings for Vim and Emacs
+//
+// Local Variables:
+// c-basic-offset: 2
+// indent-tabs-mode: nil
+// End:
+//
+// vim: et sts=2 sw=2
\ No newline at end of file
diff --git a/engine/inc/bullet/TinyAudio/TinyAudioExample.h b/engine/inc/bullet/TinyAudio/TinyAudioExample.h
new file mode 100644
index 00000000..14276cd3
--- /dev/null
+++ b/engine/inc/bullet/TinyAudio/TinyAudioExample.h
@@ -0,0 +1,7 @@
+
+#ifndef TINY_AUDIO_EXAMPLE_H
+#define TINY_AUDIO_EXAMPLE_H
+
+class CommonExampleInterface* TinyAudioExampleCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //TINY_AUDIO_EXAMPLE_H
\ No newline at end of file
diff --git a/engine/inc/bullet/TinyAudio/b3ADSR.h b/engine/inc/bullet/TinyAudio/b3ADSR.h
new file mode 100644
index 00000000..62d62479
--- /dev/null
+++ b/engine/inc/bullet/TinyAudio/b3ADSR.h
@@ -0,0 +1,34 @@
+#ifndef B3_ADSR_H
+#define B3_ADSR_H
+
+class b3ADSR
+{
+	int m_state;
+	double m_value;
+	double m_target;
+	double m_attackRate;
+	double m_decayRate;
+	double m_releaseRate;
+	double m_releaseTime;
+	double m_sustainLevel;
+	bool m_autoKeyOff;
+
+public:
+	b3ADSR();
+	virtual ~b3ADSR();
+
+	double tick();
+	bool isIdle() const;
+	void keyOn(bool autoKeyOff);
+	void keyOff();
+
+	void setValues(double attack, double decay, double sustain, double release)
+	{
+		m_attackRate = attack;
+		m_decayRate = decay;
+		m_sustainLevel = sustain;
+		m_releaseRate = release;
+	}
+};
+
+#endif  //B3_ADSR_H
\ No newline at end of file
diff --git a/engine/inc/bullet/TinyAudio/b3AudioListener.h b/engine/inc/bullet/TinyAudio/b3AudioListener.h
new file mode 100644
index 00000000..46b33d43
--- /dev/null
+++ b/engine/inc/bullet/TinyAudio/b3AudioListener.h
@@ -0,0 +1,27 @@
+#ifndef B3_AUDIO_LISTENER_H
+#define B3_AUDIO_LISTENER_H
+
+class b3SoundSource;
+
+class b3AudioListener
+{
+	struct b3AudioListenerInternalData* m_data;
+
+public:
+	b3AudioListener();
+	virtual ~b3AudioListener();
+
+	static int tick(void* outputBuffer, void* inputBuffer1, unsigned int nBufferFrames,
+					double streamTime, unsigned int status, void* dataPointer);
+
+	int addSoundSource(b3SoundSource* source);
+	void removeSoundSource(b3SoundSource* source);
+
+	b3AudioListenerInternalData* getTickData();
+	const b3AudioListenerInternalData* getTickData() const;
+
+	double getSampleRate() const;
+	void setSampleRate(double sampleRate);
+};
+
+#endif  //B3_AUDIO_LISTENER_H
\ No newline at end of file
diff --git a/engine/inc/bullet/TinyAudio/b3ReadWavFile.h b/engine/inc/bullet/TinyAudio/b3ReadWavFile.h
new file mode 100644
index 00000000..55c4f6a5
--- /dev/null
+++ b/engine/inc/bullet/TinyAudio/b3ReadWavFile.h
@@ -0,0 +1,53 @@
+#ifndef B3_READ_WAV_FILE_H
+#define B3_READ_WAV_FILE_H
+
+#include "Bullet3Common/b3AlignedObjectArray.h"
+#include <stdio.h>
+#include <string.h>
+
+struct b3WavTicker
+{
+	b3AlignedObjectArray<double> lastFrame_;
+	bool finished_;
+	double time_;
+	double rate_;
+};
+
+class b3ReadWavFile
+{
+	bool byteswap_;
+	bool wavFile_;
+	unsigned long m_numFrames;
+	unsigned long dataType_;
+	double fileDataRate_;
+	FILE *fd_;
+	unsigned long dataOffset_;
+	unsigned int channels_;
+	bool m_machineIsLittleEndian;
+
+public:
+	b3ReadWavFile();
+	virtual ~b3ReadWavFile();
+
+	b3AlignedObjectArray<double> m_frames;
+
+	bool getWavInfo(const char *fileName);
+
+	void normalize(double peak);
+
+	double interpolate(double frame, unsigned int channel) const;
+	double tick(unsigned int channel, b3WavTicker *ticker);
+
+	void resize();
+
+	b3WavTicker createWavTicker(double sampleRate);
+
+	bool read(unsigned long startFrame, bool doNormalize);
+
+	int getNumFrames() const
+	{
+		return m_numFrames;
+	}
+};
+
+#endif  //B3_READ_WAV_FILE_H
diff --git a/engine/inc/bullet/TinyAudio/b3SoundEngine.h b/engine/inc/bullet/TinyAudio/b3SoundEngine.h
new file mode 100644
index 00000000..db2326cf
--- /dev/null
+++ b/engine/inc/bullet/TinyAudio/b3SoundEngine.h
@@ -0,0 +1,55 @@
+#ifndef B3_SOUND_ENGINE_H
+#define B3_SOUND_ENGINE_H
+
+#include "Bullet3Common/b3Scalar.h"
+#include "b3Sound_C_Api.h"
+
+struct b3SoundMessage
+{
+	int m_type;  //B3_SOUND_SOURCE_TYPE
+	double m_amplitude;
+
+	double m_frequency;
+	int m_wavId;
+
+	double m_attackRate;
+	double m_decayRate;
+	double m_sustainLevel;
+	double m_releaseRate;
+	bool m_autoKeyOff;
+
+	b3SoundMessage()
+		: m_type(B3_SOUND_SOURCE_SINE_OSCILLATOR),
+		  m_amplitude(0.5),
+		  m_frequency(440),
+		  m_wavId(-1),
+		  m_attackRate(0.001),
+		  m_decayRate(0.00001),
+		  m_sustainLevel(0.5),
+		  m_releaseRate(0.0005),
+		  m_autoKeyOff(false)
+	{
+	}
+};
+
+class b3SoundEngine
+{
+	struct b3SoundEngineInternalData* m_data;
+
+public:
+	b3SoundEngine();
+	virtual ~b3SoundEngine();
+
+	void init(int maxNumSoundSources, bool useRealTimeDac);
+	void exit();
+
+	int getAvailableSoundSource();
+	void startSound(int soundSourceIndex, b3SoundMessage msg);
+	void releaseSound(int soundSourceIndex);
+
+	int loadWavFile(const char* fileName);
+
+	double getSampleRate() const;
+};
+
+#endif  //B3_SOUND_ENGINE_H
diff --git a/engine/inc/bullet/TinyAudio/b3SoundSource.h b/engine/inc/bullet/TinyAudio/b3SoundSource.h
new file mode 100644
index 00000000..22728126
--- /dev/null
+++ b/engine/inc/bullet/TinyAudio/b3SoundSource.h
@@ -0,0 +1,31 @@
+#ifndef B3_SOUND_SOURCE_H
+#define B3_SOUND_SOURCE_H
+
+#include "b3Sound_C_Api.h"
+
+class b3SoundSource
+{
+	struct b3SoundSourceInternalData* m_data;
+
+public:
+	b3SoundSource();
+	virtual ~b3SoundSource();
+
+	virtual bool computeSamples(double* sampleBuffer, int numSamples, double sampleRate);
+
+	int getNumOscillators() const;
+	void setOscillatorType(int oscillatorIndex, int type);
+	void setOscillatorFrequency(int oscillatorIndex, double frequency);
+	void setOscillatorAmplitude(int oscillatorIndex, double amplitude);
+	void setOscillatorPhase(int oscillatorIndex, double phase);
+	void setADSR(double attackRate, double decayRate, double sustainLevel, double releaseRate);
+
+	bool setWavFile(int oscillatorIndex, class b3ReadWavFile* wavFilePtr, int sampleRate);
+
+	void startSound(bool autoKeyOff);
+	void stopSound();
+
+	bool isAvailable() const;
+};
+
+#endif  //B3_SOUND_SOURCE_H
diff --git a/engine/inc/bullet/TinyAudio/b3Sound_C_Api.h b/engine/inc/bullet/TinyAudio/b3Sound_C_Api.h
new file mode 100644
index 00000000..95305410
--- /dev/null
+++ b/engine/inc/bullet/TinyAudio/b3Sound_C_Api.h
@@ -0,0 +1,29 @@
+#ifndef B3_SOUND_C_API_H
+#define B3_SOUND_C_API_H
+
+//todo: create a sound C-API
+
+//create sound engine
+//destroy sound engine
+//getSoundSource
+//startSound
+//releaseSound
+//etc
+
+enum B3_SOUND_SOURCE_TYPE
+{
+	B3_SOUND_SOURCE_SINE_OSCILLATOR = 1,
+	B3_SOUND_SOURCE_SAW_OSCILLATOR,
+	B3_SOUND_SOURCE_WAV_FILE,
+};
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  ///B3_SOUND_C_API_H
diff --git a/engine/inc/bullet/TinyAudio/b3SwapUtils.h b/engine/inc/bullet/TinyAudio/b3SwapUtils.h
new file mode 100644
index 00000000..8bef80b0
--- /dev/null
+++ b/engine/inc/bullet/TinyAudio/b3SwapUtils.h
@@ -0,0 +1,58 @@
+#ifndef B3_SWAP_UTILS_H
+#define B3_SWAP_UTILS_H
+
+inline void b3Swap16(unsigned char *ptr)
+{
+	unsigned char val;
+
+	// Swap 1st and 2nd bytes
+	val = *(ptr);
+	*(ptr) = *(ptr + 1);
+	*(ptr + 1) = val;
+}
+
+inline void b3Swap32(unsigned char *ptr)
+{
+	unsigned char val;
+
+	// Swap 1st and 4th bytes
+	val = *(ptr);
+	*(ptr) = *(ptr + 3);
+	*(ptr + 3) = val;
+
+	//Swap 2nd and 3rd bytes
+	ptr += 1;
+	val = *(ptr);
+	*(ptr) = *(ptr + 1);
+	*(ptr + 1) = val;
+}
+
+inline void b3Swap64(unsigned char *ptr)
+{
+	unsigned char val;
+
+	// Swap 1st and 8th bytes
+	val = *(ptr);
+	*(ptr) = *(ptr + 7);
+	*(ptr + 7) = val;
+
+	// Swap 2nd and 7th bytes
+	ptr += 1;
+	val = *(ptr);
+	*(ptr) = *(ptr + 5);
+	*(ptr + 5) = val;
+
+	// Swap 3rd and 6th bytes
+	ptr += 1;
+	val = *(ptr);
+	*(ptr) = *(ptr + 3);
+	*(ptr + 3) = val;
+
+	// Swap 4th and 5th bytes
+	ptr += 1;
+	val = *(ptr);
+	*(ptr) = *(ptr + 1);
+	*(ptr + 1) = val;
+}
+
+#endif  //B3_SWAP_UTILS_H
diff --git a/engine/inc/bullet/TinyAudio/b3WriteWavFile.h b/engine/inc/bullet/TinyAudio/b3WriteWavFile.h
new file mode 100644
index 00000000..3dc2bd95
--- /dev/null
+++ b/engine/inc/bullet/TinyAudio/b3WriteWavFile.h
@@ -0,0 +1,29 @@
+#ifndef B3_WRITE_WAV_FILE_H
+#define B3_WRITE_WAV_FILE_H
+
+// b3WriteWavFile is copied from Stk::FileWvOut/FileWrite
+// See also https://github.com/thestk/stk
+// by Perry R. Cook and Gary P. Scavone, 1995--2014.
+#include <string>
+
+class b3WriteWavFile
+{
+	void incrementFrame(void);
+	void flush();
+
+	struct b3WriteWavFileInternalData* m_data;
+
+	void flushData(int bufferSize);
+
+public:
+	b3WriteWavFile();
+	virtual ~b3WriteWavFile();
+
+	bool setWavFile(std::string fileName, int sampleRate, int numChannels, bool useDoublePrecision = true);
+
+	void closeWavFile();
+
+	void tick(double* values, int numValues);
+};
+
+#endif  //B3_WRITE_WAV_FILE_H
diff --git a/engine/inc/bullet/TinyRenderer/TinyRenderer.h b/engine/inc/bullet/TinyRenderer/TinyRenderer.h
new file mode 100644
index 00000000..75b6c08c
--- /dev/null
+++ b/engine/inc/bullet/TinyRenderer/TinyRenderer.h
@@ -0,0 +1,66 @@
+#ifndef TINY_RENDERER_H
+#define TINY_RENDERER_H
+
+#include "geometry.h"
+#include "model.h"
+#include "Bullet3Common/b3AlignedObjectArray.h"
+#include "Bullet3Common/b3Vector3.h"
+#include "LinearMath/btAlignedObjectArray.h"
+#include "LinearMath/btVector3.h"
+
+#include "tgaimage.h"
+
+struct TinyRenderObjectData
+{
+	//Camera
+	TinyRender::Matrix m_viewMatrix;
+	TinyRender::Matrix m_projectionMatrix;
+	TinyRender::Matrix m_viewportMatrix;
+	btVector3 m_localScaling;
+	btVector3 m_lightDirWorld;
+	btVector3 m_lightColor;
+	float m_lightDistance;
+	float m_lightAmbientCoeff;
+	float m_lightDiffuseCoeff;
+	float m_lightSpecularCoeff;
+
+	//Model (vertices, indices, textures, shader)
+	TinyRender::Matrix m_modelMatrix;
+	TinyRender::Model* m_model;
+	//class IShader* m_shader; todo(erwincoumans) expose the shader, for now we use a default shader
+
+	//Output
+
+	TGAImage& m_rgbColorBuffer;
+	b3AlignedObjectArray<float>& m_depthBuffer;              //required, hence a reference
+	b3AlignedObjectArray<float>* m_shadowBuffer;             //optional, hence a pointer
+	b3AlignedObjectArray<int>* m_segmentationMaskBufferPtr;  //optional, hence a pointer
+
+	TinyRenderObjectData(TGAImage& rgbColorBuffer, b3AlignedObjectArray<float>& depthBuffer);
+	TinyRenderObjectData(TGAImage& rgbColorBuffer, b3AlignedObjectArray<float>& depthBuffer, b3AlignedObjectArray<int>* segmentationMaskBuffer, int objectIndex);
+	TinyRenderObjectData(TGAImage& rgbColorBuffer, b3AlignedObjectArray<float>& depthBuffer, b3AlignedObjectArray<float>* shadowBuffer);
+	TinyRenderObjectData(TGAImage& rgbColorBuffer, b3AlignedObjectArray<float>& depthBuffer, b3AlignedObjectArray<float>* shadowBuffer, b3AlignedObjectArray<int>* segmentationMaskBuffer, int objectIndex, int linkIndex);
+	virtual ~TinyRenderObjectData();
+
+	void loadModel(const char* fileName, struct CommonFileIOInterface* fileIO);
+	void createCube(float HalfExtentsX, float HalfExtentsY, float HalfExtentsZ, struct CommonFileIOInterface* fileIO=0);
+	void registerMeshShape(const float* vertices, int numVertices, const int* indices, int numIndices, const float rgbaColor[4],
+						   unsigned char* textureImage = 0, int textureWidth = 0, int textureHeight = 0);
+
+	void registerMesh2(btAlignedObjectArray<btVector3>& vertices, btAlignedObjectArray<btVector3>& normals, btAlignedObjectArray<int>& indices, struct CommonFileIOInterface* fileIO);
+
+	void* m_userData;
+	int m_userIndex;
+	int m_objectIndex;
+	int m_linkIndex;
+	bool m_doubleSided;
+};
+
+class TinyRenderer
+{
+public:
+	static void renderObjectDepth(TinyRenderObjectData& renderData);
+	static void renderObject(TinyRenderObjectData& renderData);
+};
+
+#endif  // TINY_RENDERER_Hbla
diff --git a/engine/inc/bullet/TinyRenderer/geometry.h b/engine/inc/bullet/TinyRenderer/geometry.h
new file mode 100644
index 00000000..c17518c9
--- /dev/null
+++ b/engine/inc/bullet/TinyRenderer/geometry.h
@@ -0,0 +1,327 @@
+#ifndef __GEOMETRY_H__
+#define __GEOMETRY_H__
+#include <cmath>
+#include <cassert>
+#include <stdlib.h>
+
+namespace TinyRender
+{
+template <size_t DimCols, size_t DimRows, typename T>
+class mat;
+
+template <size_t DIM, typename T>
+struct vec
+{
+	vec()
+	{
+		for (size_t i = DIM; i--; data_[i] = T())
+			;
+	}
+	T& operator[](const size_t i)
+	{
+		assert(i < DIM);
+		return data_[i];
+	}
+	const T& operator[](const size_t i) const
+	{
+		assert(i < DIM);
+		return data_[i];
+	}
+
+private:
+	T data_[DIM];
+};
+
+/////////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+struct vec<2, T>
+{
+	vec() : x(T()), y(T()) {}
+	vec(T X, T Y) : x(X), y(Y) {}
+	template <class U>
+	vec<2, T>(const vec<2, U>& v);
+	T& operator[](const size_t i)
+	{
+		assert(i < 2);
+		return i <= 0 ? x : y;
+	}
+	const T& operator[](const size_t i) const
+	{
+		assert(i < 2);
+		return i <= 0 ? x : y;
+	}
+
+	T x, y;
+};
+
+/////////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+struct vec<3, T>
+{
+	vec() : x(T()), y(T()), z(T()) {}
+	vec(T X, T Y, T Z) : x(X), y(Y), z(Z) {}
+	template <class U>
+	vec<3, T>(const vec<3, U>& v);
+	T& operator[](const size_t i)
+	{
+		assert(i < 3);
+		return i <= 0 ? x : (1 == i ? y : z);
+	}
+	const T& operator[](const size_t i) const
+	{
+		assert(i < 3);
+		return i <= 0 ? x : (1 == i ? y : z);
+	}
+	float norm() { return std::sqrt(x * x + y * y + z * z); }
+	vec<3, T>& normalize(T l = 1)
+	{
+		*this = (*this) * (l / norm());
+		return *this;
+	}
+
+	T x, y, z;
+};
+
+/////////////////////////////////////////////////////////////////////////////////
+
+template <size_t DIM, typename T>
+T operator*(const vec<DIM, T>& lhs, const vec<DIM, T>& rhs)
+{
+	T ret = T();
+	for (size_t i = DIM; i--; ret += lhs[i] * rhs[i])
+		;
+	return ret;
+}
+
+template <size_t DIM, typename T>
+vec<DIM, T> operator+(vec<DIM, T> lhs, const vec<DIM, T>& rhs)
+{
+	for (size_t i = DIM; i--; lhs[i] += rhs[i])
+		;
+	return lhs;
+}
+
+template <size_t DIM, typename T>
+vec<DIM, T> operator-(vec<DIM, T> lhs, const vec<DIM, T>& rhs)
+{
+	for (size_t i = DIM; i--; lhs[i] -= rhs[i])
+		;
+	return lhs;
+}
+
+template <size_t DIM, typename T, typename U>
+vec<DIM, T> operator*(vec<DIM, T> lhs, const U& rhs)
+{
+	for (size_t i = DIM; i--; lhs[i] *= rhs)
+		;
+	return lhs;
+}
+
+template <size_t DIM, typename T, typename U>
+vec<DIM, T> operator/(vec<DIM, T> lhs, const U& rhs)
+{
+	for (size_t i = DIM; i--; lhs[i] /= rhs)
+		;
+	return lhs;
+}
+
+template <size_t LEN, size_t DIM, typename T>
+vec<LEN, T> embed(const vec<DIM, T>& v, T fill = 1)
+{
+	vec<LEN, T> ret;
+	for (size_t i = LEN; i--; ret[i] = (i < DIM ? v[i] : fill))
+		;
+	return ret;
+}
+
+template <size_t LEN, size_t DIM, typename T>
+vec<LEN, T> proj(const vec<DIM, T>& v)
+{
+	vec<LEN, T> ret;
+	for (size_t i = LEN; i--; ret[i] = v[i])
+		;
+	return ret;
+}
+
+template <typename T>
+vec<3, T> cross(vec<3, T> v1, vec<3, T> v2)
+{
+	return vec<3, T>(v1.y * v2.z - v1.z * v2.y, v1.z * v2.x - v1.x * v2.z, v1.x * v2.y - v1.y * v2.x);
+}
+#if 0
+template <size_t DIM, typename T> std::ostream& operator<<(std::ostream& out, vec<DIM,T>& v) {
+    for(unsigned int i=0; i<DIM; i++) {
+        out << v[i] << " " ;
+    }
+    return out ;
+}
+#endif
+/////////////////////////////////////////////////////////////////////////////////
+
+template <size_t DIM, typename T>
+struct dt
+{
+	static T det(const mat<DIM, DIM, T>& src)
+	{
+		T ret = 0;
+		for (size_t i = DIM; i--; ret += src[0][i] * src.cofactor(0, i))
+			;
+		return ret;
+	}
+};
+
+template <typename T>
+struct dt<1, T>
+{
+	static T det(const mat<1, 1, T>& src)
+	{
+		return src[0][0];
+	}
+};
+
+/////////////////////////////////////////////////////////////////////////////////
+
+template <size_t DimRows, size_t DimCols, typename T>
+class mat
+{
+	vec<DimCols, T> rows[DimRows];
+
+public:
+	mat() {}
+
+	vec<DimCols, T>& operator[](const size_t idx)
+	{
+		assert(idx < DimRows);
+		return rows[idx];
+	}
+
+	const vec<DimCols, T>& operator[](const size_t idx) const
+	{
+		assert(idx < DimRows);
+		return rows[idx];
+	}
+
+	vec<DimRows, T> col(const size_t idx) const
+	{
+		assert(idx < DimCols);
+		vec<DimRows, T> ret;
+		for (size_t i = DimRows; i--; ret[i] = rows[i][idx])
+			;
+		return ret;
+	}
+
+	void set_col(size_t idx, vec<DimRows, T> v)
+	{
+		assert(idx < DimCols);
+		for (size_t i = DimRows; i--; rows[i][idx] = v[i])
+			;
+	}
+
+	static mat<DimRows, DimCols, T> identity()
+	{
+		mat<DimRows, DimCols, T> ret;
+		for (size_t i = DimRows; i--;)
+			for (size_t j = DimCols; j--; ret[i][j] = (i == j))
+				;
+		return ret;
+	}
+
+	T det() const
+	{
+		return dt<DimCols, T>::det(*this);
+	}
+
+	mat<DimRows - 1, DimCols - 1, T> get_minor(size_t row, size_t col) const
+	{
+		mat<DimRows - 1, DimCols - 1, T> ret;
+		for (size_t i = DimRows - 1; i--;)
+			for (size_t j = DimCols - 1; j--; ret[i][j] = rows[i < row ? i : i + 1][j < col ? j : j + 1])
+				;
+		return ret;
+	}
+
+	T cofactor(size_t row, size_t col) const
+	{
+		return get_minor(row, col).det() * ((row + col) % 2 ? -1 : 1);
+	}
+
+	mat<DimRows, DimCols, T> adjugate() const
+	{
+		mat<DimRows, DimCols, T> ret;
+		for (size_t i = DimRows; i--;)
+			for (size_t j = DimCols; j--; ret[i][j] = cofactor(i, j))
+				;
+		return ret;
+	}
+
+	mat<DimRows, DimCols, T> invert_transpose()
+	{
+		mat<DimRows, DimCols, T> ret = adjugate();
+		T tmp = ret[0] * rows[0];
+		return ret / tmp;
+	}
+
+	mat<DimRows, DimCols, T> invert()
+	{
+		return invert_transpose().transpose();
+	}
+
+	mat<DimCols, DimRows, T> transpose()
+	{
+		mat<DimCols, DimRows, T> ret;
+		for (size_t i = DimCols; i--; ret[i] = this->col(i))
+			;
+		return ret;
+	}
+};
+
+/////////////////////////////////////////////////////////////////////////////////
+
+template <size_t DimRows, size_t DimCols, typename T>
+vec<DimRows, T> operator*(const mat<DimRows, DimCols, T>& lhs, const vec<DimCols, T>& rhs)
+{
+	vec<DimRows, T> ret;
+	for (size_t i = DimRows; i--; ret[i] = lhs[i] * rhs)
+		;
+	return ret;
+}
+
+template <size_t R1, size_t C1, size_t C2, typename T>
+mat<R1, C2, T> operator*(const mat<R1, C1, T>& lhs, const mat<C1, C2, T>& rhs)
+{
+	mat<R1, C2, T> result;
+	for (size_t i = R1; i--;)
+		for (size_t j = C2; j--; result[i][j] = lhs[i] * rhs.col(j))
+			;
+	return result;
+}
+
+template <size_t DimRows, size_t DimCols, typename T>
+mat<DimCols, DimRows, T> operator/(mat<DimRows, DimCols, T> lhs, const T& rhs)
+{
+	for (size_t i = DimRows; i--; lhs[i] = lhs[i] / rhs)
+		;
+	return lhs;
+}
+
+#if 0
+template <size_t DimRows,size_t DimCols,class T> std::ostream& operator<<(std::ostream& out, mat<DimRows,DimCols,T>& m) {
+    for (size_t i=0; i<DimRows; i++) out << m[i] << std::endl;
+    return out;
+}
+#endif
+/////////////////////////////////////////////////////////////////////////////////
+
+typedef vec<2, float> Vec2f;
+typedef vec<2, double> Vec2d;
+typedef vec<2, int> Vec2i;
+typedef vec<3, float> Vec3f;
+typedef vec<3, double> Vec3d;
+typedef vec<3, int> Vec3i;
+typedef vec<4, float> Vec4f;
+typedef mat<4, 4, float> Matrix;
+}
+
+#endif  //__GEOMETRY_H__
diff --git a/engine/inc/bullet/TinyRenderer/model.h b/engine/inc/bullet/TinyRenderer/model.h
new file mode 100644
index 00000000..9e01cb75
--- /dev/null
+++ b/engine/inc/bullet/TinyRenderer/model.h
@@ -0,0 +1,79 @@
+#ifndef __MODEL_H__
+#define __MODEL_H__
+#include <vector>
+#include <string>
+#include "geometry.h"
+#include "tgaimage.h"
+
+namespace TinyRender
+{
+class Model
+{
+private:
+	std::vector<Vec3f> verts_;
+	std::vector<std::vector<Vec3i> > faces_;  // attention, this Vec3i means vertex/uv/normal
+	std::vector<Vec3f> norms_;
+	std::vector<Vec2f> uv_;
+	TGAImage diffusemap_;
+	TGAImage normalmap_;
+	TGAImage specularmap_;
+	Vec4f m_colorRGBA;
+
+	void load_texture(std::string filename, const char* suffix, TGAImage& img);
+
+public:
+	Model(const char* filename);
+	Model();
+	void setColorRGBA(const float rgba[4])
+	{
+		for (int i = 0; i < 4; i++)
+			m_colorRGBA[i] = rgba[i];
+	}
+
+	const Vec4f& getColorRGBA() const
+	{
+		return m_colorRGBA;
+	}
+	void loadDiffuseTexture(const char* relativeFileName);
+	void setDiffuseTextureFromData(unsigned char* textureImage, int textureWidth, int textureHeight);
+	void reserveMemory(int numVertices, int numIndices);
+	void addVertex(float x, float y, float z, float normalX, float normalY, float normalZ, float u, float v);
+	void addTriangle(int vertexposIndex0, int normalIndex0, int uvIndex0,
+					 int vertexposIndex1, int normalIndex1, int uvIndex1,
+					 int vertexposIndex2, int normalIndex2, int uvIndex2);
+
+	~Model();
+	int nverts();
+	int nnormals()
+	{
+		return norms_.size();
+	}
+	int nfaces();
+	
+	Vec3f normal(int iface, int nthvert);
+	Vec3f normal(Vec2f uv);
+	Vec3f vert(int i);
+	Vec3f vert(int iface, int nthvert);
+	Vec3f* readWriteVertices() 
+	{
+		if (verts_.size() == 0)
+			return 0;
+		return &verts_[0];
+	}
+
+	Vec3f* readWriteNormals()
+	{
+		if (norms_.size() == 0)
+			return 0;
+		return &norms_[0];
+	}
+	
+
+	Vec2f uv(int iface, int nthvert);
+	TGAColor diffuse(Vec2f uv);
+	float specular(Vec2f uv);
+	std::vector<int> face(int idx);
+};
+}
+
+#endif  //__MODEL_H__
diff --git a/engine/inc/bullet/TinyRenderer/our_gl.h b/engine/inc/bullet/TinyRenderer/our_gl.h
new file mode 100644
index 00000000..8ee23953
--- /dev/null
+++ b/engine/inc/bullet/TinyRenderer/our_gl.h
@@ -0,0 +1,27 @@
+#ifndef __OUR_GL_H__
+#define __OUR_GL_H__
+#include "tgaimage.h"
+#include "geometry.h"
+
+namespace TinyRender
+{
+Matrix viewport(int x, int y, int w, int h);
+Matrix projection(float coeff = 0.f);  // coeff = -1/c
+Matrix lookat(Vec3f eye, Vec3f center, Vec3f up);
+
+struct IShader
+{
+	float m_nearPlane;
+	float m_farPlane;
+	virtual ~IShader();
+	virtual Vec4f vertex(int iface, int nthvert) = 0;
+	virtual bool fragment(Vec3f bar, TGAColor &color) = 0;
+};
+
+void triangle(mat<4, 3, float> &pts, IShader &shader, TGAImage &image, float *zbuffer, const Matrix &viewPortMatrix);
+void triangle(mat<4, 3, float> &pts, IShader &shader, TGAImage &image, float *zbuffer, int *segmentationMaskBuffer, const Matrix &viewPortMatrix, int objectIndex);
+void triangleClipped(mat<4, 3, float> &clippedPts, mat<4, 3, float> &pts, IShader &shader, TGAImage &image, float *zbuffer, const Matrix &viewPortMatrix);
+void triangleClipped(mat<4, 3, float> &clippedPts, mat<4, 3, float> &pts, IShader &shader, TGAImage &image, float *zbuffer, int *segmentationMaskBuffer, const Matrix &viewPortMatrix, int objectIndex);
+}
+
+#endif  //__OUR_GL_H__
diff --git a/engine/inc/bullet/TinyRenderer/tgaimage.h b/engine/inc/bullet/TinyRenderer/tgaimage.h
new file mode 100644
index 00000000..7df593a0
--- /dev/null
+++ b/engine/inc/bullet/TinyRenderer/tgaimage.h
@@ -0,0 +1,112 @@
+#ifndef __IMAGE_H__
+#define __IMAGE_H__
+
+#include <fstream>
+
+#pragma pack(push, 1)
+struct TGA_Header
+{
+	char idlength;
+	char colormaptype;
+	char datatypecode;
+	short colormaporigin;
+	short colormaplength;
+	char colormapdepth;
+	short x_origin;
+	short y_origin;
+	short width;
+	short height;
+	char bitsperpixel;
+	char imagedescriptor;
+};
+#pragma pack(pop)
+
+struct TGAColor
+{
+	unsigned char bgra[4];
+	unsigned char bytespp;
+
+	TGAColor() : bytespp(1)
+	{
+		for (int i = 0; i < 4; i++)
+			bgra[i] = 0;
+	}
+
+	TGAColor(unsigned char R, unsigned char G, unsigned char B, unsigned char A = 255) : bytespp(4)
+	{
+		bgra[0] = B;
+		bgra[1] = G;
+		bgra[2] = R;
+		bgra[3] = A;
+	}
+
+	TGAColor(unsigned char v) : bytespp(1)
+	{
+		for (int i = 0; i < 4; i++) bgra[i] = 0;
+		bgra[0] = v;
+	}
+
+	TGAColor(const unsigned char *p, unsigned char bpp) : bytespp(bpp)
+	{
+		for (int i = 0; i < (int)bpp; i++)
+		{
+			bgra[i] = p[i];
+		}
+		for (int i = bpp; i < 4; i++)
+		{
+			bgra[i] = 0;
+		}
+	}
+
+	unsigned char &operator[](const int i) { return bgra[i]; }
+
+	TGAColor operator*(float intensity) const
+	{
+		TGAColor res = *this;
+		intensity = (intensity > 1.f ? 1.f : (intensity < 0.f ? 0.f : intensity));
+		for (int i = 0; i < 4; i++) res.bgra[i] = bgra[i] * intensity;
+		return res;
+	}
+};
+
+class TGAImage
+{
+protected:
+	unsigned char *data;
+	int width;
+	int height;
+	int bytespp;
+
+	bool load_rle_data(std::ifstream &in);
+	bool unload_rle_data(std::ofstream &out) const;
+
+public:
+	enum Format
+	{
+		GRAYSCALE = 1,
+		RGB = 3,
+		RGBA = 4
+	};
+
+	TGAImage();
+	TGAImage(int w, int h, int bpp);
+	TGAImage(const TGAImage &img);
+	bool read_tga_file(const char *filename);
+	bool write_tga_file(const char *filename, bool rle = true) const;
+	bool flip_horizontally();
+	bool flip_vertically();
+	bool scale(int w, int h);
+	TGAColor get(int x, int y) const;
+
+	bool set(int x, int y, TGAColor &c);
+	bool set(int x, int y, const TGAColor &c);
+	~TGAImage();
+	TGAImage &operator=(const TGAImage &img);
+	int get_width();
+	int get_height();
+	int get_bytespp();
+	unsigned char *buffer();
+	void clear();
+};
+
+#endif  //__IMAGE_H__
diff --git a/engine/inc/bullet/Tutorial/Dof6ConstraintTutorial.h b/engine/inc/bullet/Tutorial/Dof6ConstraintTutorial.h
new file mode 100644
index 00000000..c00f2759
--- /dev/null
+++ b/engine/inc/bullet/Tutorial/Dof6ConstraintTutorial.h
@@ -0,0 +1,6 @@
+#ifndef GENERIC_6DOF_SPRING2_CONSTRAINT_TUTORIAL_H
+#define GENERIC_6DOF_SPRING2_CONSTRAINT_TUTORIAL_H
+
+class CommonExampleInterface* Dof6ConstraintTutorialCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //GENERIC_6DOF_SPRING2_CONSTRAINT_TUTORIAL_H
diff --git a/engine/inc/bullet/Tutorial/Tutorial.h b/engine/inc/bullet/Tutorial/Tutorial.h
new file mode 100644
index 00000000..33aee0a2
--- /dev/null
+++ b/engine/inc/bullet/Tutorial/Tutorial.h
@@ -0,0 +1,14 @@
+#ifndef TUTORIAL_H
+#define TUTORIAL_H
+
+enum EnumTutorialTypes
+{
+	TUT_VELOCITY = 0,
+	TUT_ACCELERATION,
+	TUT_COLLISION,
+	TUT_SOLVE_CONTACT_CONSTRAINT,
+};
+
+class CommonExampleInterface* TutorialCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //TUTORIAL_H
diff --git a/engine/inc/bullet/Utils/ChromeTraceUtil.h b/engine/inc/bullet/Utils/ChromeTraceUtil.h
new file mode 100644
index 00000000..6b5e53dc
--- /dev/null
+++ b/engine/inc/bullet/Utils/ChromeTraceUtil.h
@@ -0,0 +1,9 @@
+
+#ifndef B3_CHROME_TRACE_UTIL_H
+#define B3_CHROME_TRACE_UTIL_H
+
+void b3ChromeUtilsStartTimings();
+void b3ChromeUtilsStopTimingsAndWriteJsonFile(const char* fileNamePrefix);
+void b3ChromeUtilsEnableProfiling();
+
+#endif  //B3_CHROME_TRACE_UTIL_H
\ No newline at end of file
diff --git a/engine/inc/bullet/Utils/RobotLoggingUtil.h b/engine/inc/bullet/Utils/RobotLoggingUtil.h
new file mode 100644
index 00000000..02d3e3c6
--- /dev/null
+++ b/engine/inc/bullet/Utils/RobotLoggingUtil.h
@@ -0,0 +1,53 @@
+#ifndef ROBOT_LOGGING_UTIL_H
+#define ROBOT_LOGGING_UTIL_H
+
+#include "LinearMath/btAlignedObjectArray.h"
+#include <string>
+
+struct MinitaurLogValue
+{
+	MinitaurLogValue()
+		: m_intVal(0xcdcdcdcd)
+	{
+	}
+	MinitaurLogValue(int iv)
+		: m_intVal(iv)
+	{
+	}
+	MinitaurLogValue(float fv)
+		: m_floatVal(fv)
+	{
+	}
+	MinitaurLogValue(char fv)
+		: m_charVal(fv)
+	{
+	}
+
+	union {
+		char m_charVal;
+		int m_intVal;
+		float m_floatVal;
+	};
+};
+
+struct MinitaurLogRecord
+{
+	btAlignedObjectArray<MinitaurLogValue> m_values;
+};
+
+enum MINITAUR_LOG_ERROR
+{
+	eMinitaurFileNotFound = -1,
+	eCorruptHeader = -2,
+	eUnknownType = -3,
+	eCorruptValue = -4,
+	eInvalidAABBAlignCheck = -5,
+};
+
+int readMinitaurLogFile(const char* fileName, btAlignedObjectArray<std::string>& structNames, std::string& structTypes, btAlignedObjectArray<MinitaurLogRecord>& logRecords, bool verbose);
+
+FILE* createMinitaurLogFile(const char* fileName, btAlignedObjectArray<std::string>& structNames, std::string& structTypes);
+void appendMinitaurLogData(FILE* f, std::string& structTypes, const MinitaurLogRecord& logData);
+void closeMinitaurLogFile(FILE* f);
+
+#endif  //ROBOT_LOGGING_UTIL_H
diff --git a/engine/inc/bullet/Utils/b3BulletDefaultFileIO.h b/engine/inc/bullet/Utils/b3BulletDefaultFileIO.h
new file mode 100644
index 00000000..fa972de0
--- /dev/null
+++ b/engine/inc/bullet/Utils/b3BulletDefaultFileIO.h
@@ -0,0 +1,196 @@
+
+#ifndef B3_BULLET_DEFAULT_FILE_IO_H
+#define B3_BULLET_DEFAULT_FILE_IO_H
+
+#include "../CommonInterfaces/CommonFileIOInterface.h"
+#include "b3ResourcePath.h"
+
+#include <stdio.h>
+#define B3_FILEIO_MAX_FILES 1024
+
+struct b3BulletDefaultFileIO : public CommonFileIOInterface
+{
+	static bool FileIOPluginFindFile(void* userPtr, const char* orgFileName, char* relativeFileName, int maxRelativeFileNameMaxLen)
+	{
+		b3BulletDefaultFileIO* fileIo = (b3BulletDefaultFileIO*) userPtr;
+		return fileIo->findFile(orgFileName, relativeFileName, maxRelativeFileNameMaxLen);
+	}
+
+	char m_prefix[1024];
+	FILE* m_fileHandles[B3_FILEIO_MAX_FILES];
+	int m_numFileHandles;
+
+	b3BulletDefaultFileIO(int fileIOType=0, const char* pathPrefix=0)
+		:CommonFileIOInterface(fileIOType, m_prefix),
+		m_numFileHandles(0)
+	{
+		m_prefix[0] = 0;
+		if (pathPrefix)
+		{
+			sprintf(m_prefix,"%s", pathPrefix);
+		}
+		for (int i=0;i<B3_FILEIO_MAX_FILES;i++)
+		{
+			m_fileHandles[i]=0;
+		}
+	}
+
+	virtual ~b3BulletDefaultFileIO()
+	{
+	}
+	virtual int fileOpen(const char* fileName, const char* mode)
+	{
+		//search a free slot
+		int slot = -1;
+		for (int i=0;i<B3_FILEIO_MAX_FILES;i++)
+		{
+			if (m_fileHandles[i]==0)
+			{
+				slot=i;
+				break;
+			}
+		}
+		if (slot>=0)
+		{
+			FILE*f = ::fopen(fileName, mode);
+			if (f)
+			{
+				m_fileHandles[slot]=f;
+			} else
+			{
+				slot=-1;
+			}
+		}
+		return slot;
+	}
+	virtual int fileRead(int fileHandle, char* destBuffer, int numBytes)
+	{
+		if (fileHandle>=0 && fileHandle < B3_FILEIO_MAX_FILES)
+		{
+			FILE* f = m_fileHandles[fileHandle];
+			if (f)
+			{
+				int readBytes = ::fread(destBuffer, 1, numBytes, f);
+				return readBytes;
+			}
+		}
+		return -1;
+			
+	}
+	virtual int fileWrite(int fileHandle,const char* sourceBuffer, int numBytes)
+	{
+		if (fileHandle>=0 && fileHandle < B3_FILEIO_MAX_FILES)
+		{
+			FILE* f = m_fileHandles[fileHandle];
+			if (f)
+			{
+				return ::fwrite(sourceBuffer, 1, numBytes,m_fileHandles[fileHandle]);
+			}
+		}
+		return -1;
+	}
+	virtual void fileClose(int fileHandle)
+	{
+		if (fileHandle>=0 && fileHandle < B3_FILEIO_MAX_FILES)
+		{
+			FILE* f = m_fileHandles[fileHandle];
+			if (f)
+			{
+				::fclose(f);
+				m_fileHandles[fileHandle]=0;
+			}
+		}
+	}
+
+	virtual bool findResourcePath(const char* fileName, char* relativeFileName, int relativeFileNameSizeInBytes)
+	{
+		return b3ResourcePath::findResourcePath(fileName, relativeFileName, relativeFileNameSizeInBytes, b3BulletDefaultFileIO::FileIOPluginFindFile, this)>0;
+	}
+
+
+	virtual bool findFile(const char* orgFileName, char* relativeFileName, int maxRelativeFileNameMaxLen)
+	{
+		FILE* f = 0;
+		f = fopen(orgFileName, "rb");
+		if (f)
+		{
+			//printf("original file found: [%s]\n", orgFileName);
+			sprintf(relativeFileName, "%s", orgFileName);
+			fclose(f);
+			return true;
+		}
+
+		//printf("Trying various directories, relative to current working directory\n");
+		const char* prefix[] = {m_prefix, "./", "./data/", "../data/", "../../data/", "../../../data/", "../../../../data/"};
+		int numPrefixes = sizeof(prefix) / sizeof(const char*);
+
+		f = 0;
+		bool fileFound = false;
+
+		for (int i = 0; !f && i < numPrefixes; i++)
+		{
+#ifdef _MSC_VER
+			sprintf_s(relativeFileName, maxRelativeFileNameMaxLen, "%s%s", prefix[i], orgFileName);
+#else
+			sprintf(relativeFileName, "%s%s", prefix[i], orgFileName);
+#endif
+			f = fopen(relativeFileName, "rb");
+			if (f)
+			{
+				fileFound = true;
+				break;
+			}
+		}
+		if (f)
+		{
+			fclose(f);
+		}
+
+		return fileFound;
+	}
+	virtual char* readLine(int fileHandle, char* destBuffer, int numBytes)
+	{
+		if (fileHandle>=0 && fileHandle < B3_FILEIO_MAX_FILES)
+		{
+			FILE* f = m_fileHandles[fileHandle];
+			if (f)
+			{
+				char* txt = ::fgets(destBuffer, numBytes, m_fileHandles[fileHandle]);
+				for (int i=0;i<numBytes;i++)
+				{
+					if (destBuffer[i]=='\r'||destBuffer[i]=='\n' || destBuffer[i]==0)
+					{
+						destBuffer[i] = 0;
+						break;
+					}
+				}
+				return txt;
+			}
+		}
+		return 0;
+	}
+	virtual int getFileSize(int fileHandle)
+	{
+		int size = 0;
+		if (fileHandle>=0 && fileHandle < B3_FILEIO_MAX_FILES)
+		{
+			FILE* f = m_fileHandles[fileHandle];
+			if (f)
+			{
+				
+				if (fseek(f, 0, SEEK_END) || (size = ftell(f)) == EOF || fseek(f, 0, SEEK_SET))
+				{
+					printf("Error: Cannot access file to determine size\n");
+				}
+			}
+		}
+		return size;
+	}
+
+	virtual void enableFileCaching(bool enable)
+	{
+		(void) enable;
+	}
+};
+
+#endif //B3_BULLET_DEFAULT_FILE_IO_H
diff --git a/engine/inc/bullet/Utils/b3Clock.h b/engine/inc/bullet/Utils/b3Clock.h
new file mode 100644
index 00000000..bb3fcffc
--- /dev/null
+++ b/engine/inc/bullet/Utils/b3Clock.h
@@ -0,0 +1,38 @@
+#ifndef B3_CLOCK_H
+#define B3_CLOCK_H
+
+///The b3Clock is a portable basic clock that measures accurate time in seconds, use for profiling.
+class b3Clock
+{
+public:
+	b3Clock();
+
+	b3Clock(const b3Clock& other);
+	b3Clock& operator=(const b3Clock& other);
+
+	~b3Clock();
+
+	/// Resets the initial reference time. If zeroReference is true, will set reference to absolute 0.
+	void reset(bool zeroReference = false);
+
+	/// Returns the time in ms since the last call to reset or since
+	/// the b3Clock was created.
+	unsigned long int getTimeMilliseconds();
+
+	/// Returns the time in us since the last call to reset or since
+	/// the Clock was created.
+	unsigned long long int getTimeMicroseconds();
+
+	/// Returns the time in seconds since the last call to reset or since
+	/// the Clock was created.
+	double getTimeInSeconds();
+
+	///Sleep for 'microSeconds', to yield to other threads and not waste 100% CPU cycles.
+	///Note that some operating systems may sleep a longer time.
+	static void usleep(int microSeconds);
+
+private:
+	struct b3ClockData* m_data;
+};
+
+#endif  //B3_CLOCK_H
diff --git a/engine/inc/bullet/Utils/b3ERPCFMHelper.hpp b/engine/inc/bullet/Utils/b3ERPCFMHelper.hpp
new file mode 100644
index 00000000..89be537a
--- /dev/null
+++ b/engine/inc/bullet/Utils/b3ERPCFMHelper.hpp
@@ -0,0 +1,81 @@
+#ifndef B3_ERPCFM_HELPER
+#define B3_ERPCFM_HELPER
+
+#include <LinearMath/btScalar.h>
+
+/**
+ * @brief		ERP/CFM Utils are to provide bullet specific helper functions.
+ * @details		Details
+ * @date		2015-09-20
+ * @author		Benjamin Ellenberger
+ */
+class b3ERPCFMHelper
+{
+public:
+	/**
+	 * == How To Use ERP and CFM ==
+	 * ERP and CFM can be independently set in many joints. They can be set in contact joints, in joint limits and various other places, to control the spongyness and springyness of the joint (or joint limit).
+	 * If CFM is set to zero, the constraint will be hard. If CFM is set to a positive value, it will be possible to violate the constraint by "pushing on it" (for example, for contact constraints by forcing the two contacting objects together). In other words the constraint will be soft, and the softness will increase as CFM increases. What is actually happening here is that the constraint is allowed to be violated by an amount proportional to CFM times the restoring force that is needed to enforce the constraint. Note that setting CFM to a negative value can have undesirable bad effects, such as instability. Don't do it.
+	 * By adjusting the values of ERP and CFM, you can achieve various effects. For example you can simulate springy constraints, where the two bodies oscillate as though connected by springs. Or you can simulate more spongy constraints, without the oscillation. In fact, ERP and CFM can be selected to have the same effect as any desired spring and damper constants. If you have a spring constant k_p and damping constant k_d, then the corresponding ODE constants are:
+	 *
+	 * ERP = \frac{h k_p} {h k_p + k_d}
+	 *
+	 * CFM = \frac{1} {h k_p + k_d}
+	 *
+	 * where h is the step size. These values will give the same effect as a spring-and-damper system simulated with implicit first order integration.
+	 * Increasing CFM, especially the global CFM, can reduce the numerical errors in the simulation. If the system is near-singular, then this can markedly increase stability. In fact, if the system is misbehaving, one of the first things to try is to increase the global CFM.
+	 * @link http://ode-wiki.org/wiki/index.php?title=Manual:_All&printable=yes#How_To_Use_ERP_and_CFM
+	 * @return
+	 */
+	/**
+	 * Joint error and the Error Reduction Parameter (ERP)
+	 *
+	 * When a joint attaches two bodies, those bodies are required to have certain positions and orientations relative to each other. However, it is possible for the bodies to be in positions where the joint constraints are not met. This "joint error" can happen in two ways:
+	 *
+	 * If the user sets the position/orientation of one body without correctly setting the position/orientation of the other body.
+	 * During the simulation, errors can creep in that result in the bodies drifting away from their required positions.
+	 * Figure 3  shows an example of error in a ball and socket joint (where the ball and socket do not line up).
+	 *
+	 * There is a mechanism to reduce joint error: during each simulation step each joint applies a special force to bring its bodies back into correct alignment. This force is controlled by the error reduction parameter (ERP), which has a value between 0 and 1.
+	 *
+	 * The ERP specifies what proportion of the joint error will be fixed during the next simulation step. If ERP = 0 then no correcting force is applied and the bodies will eventually drift apart as the simulation proceeds. If ERP=1 then the simulation will attempt to fix all joint error during the next time step. However, setting ERP=1 is not recommended, as the joint error will not be completely fixed due to various internal approximations. A value of ERP=0.1 to 0.8 is recommended (0.2 is the default).
+	 *
+	 * A global ERP value can be set that affects most joints in the simulation. However some joints have local ERP values that control various aspects of the joint.
+	 * @link http://ode-wiki.org/wiki/index.php?title=Manual:_All&printable=yes#How_To_Use_ERP_and_CFM
+	 * @return
+	 */
+	static btScalar getERP(btScalar timeStep, btScalar kSpring,
+						   btScalar kDamper)
+	{
+		return timeStep * kSpring / (timeStep * kSpring + kDamper);
+	}
+
+	/**
+	 * Most constraints are by nature "hard". This means that the constraints represent conditions that are never violated. For example, the ball must always be in the socket, and the two parts of the hinge must always be lined up. In practice constraints can be violated by unintentional introduction of errors into the system, but the error reduction parameter can be set to correct these errors.
+	 * Not all constraints are hard. Some "soft" constraints are designed to be violated. For example, the contact constraint that prevents colliding objects from penetrating is hard by default, so it acts as though the colliding surfaces are made of steel. But it can be made into a soft constraint to simulate softer materials, thereby allowing some natural penetration of the two objects when they are forced together.
+	 * There are two parameters that control the distinction between hard and soft constraints. The first is the error reduction parameter (ERP) that has already been introduced. The second is the constraint force mixing (CFM) value, that is described below.
+	 *
+	 * == Constraint Force Mixing (CFM) ==
+	 * What follows is a somewhat technical description of the meaning of CFM. If you just want to know how it is used in practice then skip to the next section.
+	 * Traditionally the constraint equation for every joint has the form
+	 * \mathbf{J} v = \mathbf{c}
+	 * where v is a velocity vector for the bodies involved, \mathbf{J} is a "Jacobian" matrix with one row for every degree of freedom the joint removes from the system, and \mathbf{c} is a right hand side vector. At the next time step, a vector \lambda is calculated (of the same size as \mathbf{c}) such that the forces applied to the bodies to preserve the joint constraint are:
+	 * F_c = \mathbf{J}^T \lambda
+	 * ODE adds a new twist. ODE's constraint equation has the form
+	 *
+	 * \mathbf{J} v = \mathbf{c} + \textbf{CFM} \, \lambda
+	 * where CFM is a square diagonal matrix. CFM mixes the resulting constraint force in with the constraint that produces it. A nonzero (positive) value of CFM allows the original constraint equation to be violated by an amount proportional to CFM times the restoring force \lambda that is needed to enforce the constraint. Solving for \lambda gives
+	 *
+	 * (\mathbf{J} \mathbf{M}^{-1} \mathbf{J}^T + \frac{1}{h}  \textbf{CFM}) \lambda = \frac{1}{h} \mathbf{c}
+	 * Thus CFM simply adds to the diagonal of the original system matrix. Using a positive value of CFM has the additional benefit of taking the system away from any singularity and thus improving the factorizer accuracy.
+	 * @link http://ode-wiki.org/wiki/index.php?title=Manual:_All&printable=yes#How_To_Use_ERP_and_CFM
+	 * @return
+	 */
+	static btScalar getCFM(btScalar avoidSingularity, btScalar timeStep, btScalar kSpring,
+						   btScalar kDamper)
+	{
+		return btScalar(avoidSingularity) / (timeStep * kSpring + kDamper);
+	}
+};
+
+#endif /* B3_ERPCFM_HELPER */
diff --git a/engine/inc/bullet/Utils/b3Quickprof.h b/engine/inc/bullet/Utils/b3Quickprof.h
new file mode 100644
index 00000000..43394ad6
--- /dev/null
+++ b/engine/inc/bullet/Utils/b3Quickprof.h
@@ -0,0 +1,150 @@
+/*
+Copyright (c) 2003-2013 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+/***************************************************************************************************
+**
+** Real-Time Hierarchical Profiling for Game Programming Gems 3
+**
+** by Greg Hjelstrom & Byon Garrabrant
+**
+***************************************************************************************************/
+
+// Credits: The Clock class was inspired by the Timer classes in
+// Ogre (www.ogre3d.org).
+
+#ifndef B3_QUICK_PROF_H
+#define B3_QUICK_PROF_H
+
+//To disable built-in profiling, please comment out next line
+//#define B3_NO_PROFILE 1
+#ifndef B3_NO_PROFILE
+#include <stdio.h>  //@todo remove this, backwards compatibility
+#include "Bullet3Common/b3Scalar.h"
+#include "Bullet3Common/b3AlignedAllocator.h"
+#include <new>
+
+#include "b3Clock.h"
+
+///A node in the Profile Hierarchy Tree
+class b3ProfileNode
+{
+public:
+	b3ProfileNode(const char* name, b3ProfileNode* parent);
+	~b3ProfileNode(void);
+
+	b3ProfileNode* Get_Sub_Node(const char* name);
+
+	b3ProfileNode* Get_Parent(void) { return Parent; }
+	b3ProfileNode* Get_Sibling(void) { return Sibling; }
+	b3ProfileNode* Get_Child(void) { return Child; }
+
+	void CleanupMemory();
+	void Reset(void);
+	void Call(void);
+	bool Return(void);
+
+	const char* Get_Name(void) { return Name; }
+	int Get_Total_Calls(void) { return TotalCalls; }
+	float Get_Total_Time(void) { return TotalTime; }
+	void* GetUserPointer() const { return m_userPtr; }
+	void SetUserPointer(void* ptr) { m_userPtr = ptr; }
+
+protected:
+	const char* Name;
+	int TotalCalls;
+	float TotalTime;
+	unsigned long int StartTime;
+	int RecursionCounter;
+
+	b3ProfileNode* Parent;
+	b3ProfileNode* Child;
+	b3ProfileNode* Sibling;
+	void* m_userPtr;
+};
+
+///An iterator to navigate through the tree
+class b3ProfileIterator
+{
+public:
+	// Access all the children of the current parent
+	void First(void);
+	void Next(void);
+	bool Is_Done(void);
+	bool Is_Root(void) { return (CurrentParent->Get_Parent() == 0); }
+
+	void Enter_Child(int index);     // Make the given child the new parent
+	void Enter_Largest_Child(void);  // Make the largest child the new parent
+	void Enter_Parent(void);         // Make the current parent's parent the new parent
+
+	// Access the current child
+	const char* Get_Current_Name(void) { return CurrentChild->Get_Name(); }
+	int Get_Current_Total_Calls(void) { return CurrentChild->Get_Total_Calls(); }
+	float Get_Current_Total_Time(void) { return CurrentChild->Get_Total_Time(); }
+
+	void* Get_Current_UserPointer(void) { return CurrentChild->GetUserPointer(); }
+	void Set_Current_UserPointer(void* ptr) { CurrentChild->SetUserPointer(ptr); }
+	// Access the current parent
+	const char* Get_Current_Parent_Name(void) { return CurrentParent->Get_Name(); }
+	int Get_Current_Parent_Total_Calls(void) { return CurrentParent->Get_Total_Calls(); }
+	float Get_Current_Parent_Total_Time(void) { return CurrentParent->Get_Total_Time(); }
+
+protected:
+	b3ProfileNode* CurrentParent;
+	b3ProfileNode* CurrentChild;
+
+	b3ProfileIterator(b3ProfileNode* start);
+	friend class b3ProfileManager;
+};
+
+///The Manager for the Profile system
+class b3ProfileManager
+{
+public:
+	static void Start_Profile(const char* name);
+	static void Stop_Profile(void);
+
+	static void CleanupMemory(void)
+	{
+		Root.CleanupMemory();
+	}
+
+	static void Reset(void);
+	static void Increment_Frame_Counter(void);
+	static int Get_Frame_Count_Since_Reset(void) { return FrameCounter; }
+	static float Get_Time_Since_Reset(void);
+
+	static b3ProfileIterator* Get_Iterator(void)
+	{
+		return new b3ProfileIterator(&Root);
+	}
+	static void Release_Iterator(b3ProfileIterator* iterator) { delete (iterator); }
+
+	static void dumpRecursive(b3ProfileIterator* profileIterator, int spacing);
+	static void dumpAll();
+
+	static void dumpRecursive(FILE* f, b3ProfileIterator* profileIterator, int spacing);
+	static void dumpAll(FILE* f);
+
+private:
+	static b3ProfileNode Root;
+	static b3ProfileNode* CurrentNode;
+	static int FrameCounter;
+	static unsigned long int ResetTime;
+};
+
+#else
+
+#endif  //#ifndef B3_NO_PROFILE
+
+#endif  //B3_QUICK_PROF_H
diff --git a/engine/inc/bullet/Utils/b3ReferenceFrameHelper.hpp b/engine/inc/bullet/Utils/b3ReferenceFrameHelper.hpp
new file mode 100644
index 00000000..8616a6d4
--- /dev/null
+++ b/engine/inc/bullet/Utils/b3ReferenceFrameHelper.hpp
@@ -0,0 +1,62 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2015 Google Inc. http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef B3_REFERENCEFRAMEHELPER_H
+#define B3_REFERENCEFRAMEHELPER_H
+
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btVector3.h"
+
+class b3ReferenceFrameHelper
+{
+public:
+	static btVector3 getPointWorldToLocal(const btTransform& localObjectCenterOfMassTransform, const btVector3& point)
+	{
+		return localObjectCenterOfMassTransform.inverse() * point;  // transforms the point from the world frame into the local frame
+	}
+
+	static btVector3 getPointLocalToWorld(const btTransform& localObjectCenterOfMassTransform, const btVector3& point)
+	{
+		return localObjectCenterOfMassTransform * point;  // transforms the point from the world frame into the local frame
+	}
+
+	static btVector3 getAxisWorldToLocal(const btTransform& localObjectCenterOfMassTransform, const btVector3& axis)
+	{
+		btTransform local1 = localObjectCenterOfMassTransform.inverse();  // transforms the axis from the local frame into the world frame
+		btVector3 zero(0, 0, 0);
+		local1.setOrigin(zero);
+		return local1 * axis;
+	}
+
+	static btVector3 getAxisLocalToWorld(const btTransform& localObjectCenterOfMassTransform, const btVector3& axis)
+	{
+		btTransform local1 = localObjectCenterOfMassTransform;  // transforms the axis from the local frame into the world frame
+		btVector3 zero(0, 0, 0);
+		local1.setOrigin(zero);
+		return local1 * axis;
+	}
+
+	static btTransform getTransformWorldToLocal(const btTransform& localObjectCenterOfMassTransform, const btTransform& transform)
+	{
+		return localObjectCenterOfMassTransform.inverse() * transform;  // transforms the axis from the local frame into the world frame
+	}
+
+	static btTransform getTransformLocalToWorld(const btTransform& localObjectCenterOfMassTransform, const btTransform& transform)
+	{
+		return localObjectCenterOfMassTransform * transform;  // transforms the axis from the local frame into the world frame
+	}
+};
+
+#endif /* B3_REFERENCEFRAMEHELPER_H */
diff --git a/engine/inc/bullet/Utils/b3ResourcePath.h b/engine/inc/bullet/Utils/b3ResourcePath.h
new file mode 100644
index 00000000..49967b8c
--- /dev/null
+++ b/engine/inc/bullet/Utils/b3ResourcePath.h
@@ -0,0 +1,15 @@
+#ifndef _B3_RESOURCE_PATH_H
+#define _B3_RESOURCE_PATH_H
+
+#include <string>
+
+typedef bool (* PFN_FIND_FILE)(void* userPointer, const char* orgFileName, char* relativeFileName, int maxRelativeFileNameMaxLen);
+
+class b3ResourcePath
+{
+public:
+	static int getExePath(char* path, int maxPathLenInBytes);
+	static int findResourcePath(const char* resourceName, char* resourcePathOut, int resourcePathMaxNumBytes, PFN_FIND_FILE findFile, void* userPointer=0);
+	static void setAdditionalSearchPath(const char* path);
+};
+#endif
diff --git a/engine/inc/bullet/Vehicles/Hinge2Vehicle.h b/engine/inc/bullet/Vehicles/Hinge2Vehicle.h
new file mode 100644
index 00000000..d4ac4bc3
--- /dev/null
+++ b/engine/inc/bullet/Vehicles/Hinge2Vehicle.h
@@ -0,0 +1,21 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2015 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef HINGE2_VEHICLE_H
+#define HINGE2_VEHICLE_H
+
+class CommonExampleInterface* Hinge2VehicleCreateFunc(struct CommonExampleOptions& options);
+
+#endif  // HINGE2_VEHICLE_H
diff --git a/engine/inc/bullet/VoronoiFracture/VoronoiFractureDemo.h b/engine/inc/bullet/VoronoiFracture/VoronoiFractureDemo.h
new file mode 100644
index 00000000..49e7ace2
--- /dev/null
+++ b/engine/inc/bullet/VoronoiFracture/VoronoiFractureDemo.h
@@ -0,0 +1,20 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef VORONOI_FRACTURE_DEMO_H
+#define VORONOI_FRACTURE_DEMO_H
+
+class CommonExampleInterface* VoronoiFractureCreateFunc(struct CommonExampleOptions& options);
+
+#endif  //VORONOI_FRACTURE_DEMO_H
diff --git a/engine/inc/bullet/VoronoiFracture/btConvexConvexMprAlgorithm.h b/engine/inc/bullet/VoronoiFracture/btConvexConvexMprAlgorithm.h
new file mode 100644
index 00000000..40f27353
--- /dev/null
+++ b/engine/inc/bullet/VoronoiFracture/btConvexConvexMprAlgorithm.h
@@ -0,0 +1,79 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_CONVEX_CONVEX_MPR_ALGORITHM_H
+#define BT_CONVEX_CONVEX_MPR_ALGORITHM_H
+
+#include "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h"
+#include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h"
+#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+#include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h"
+#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
+#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h"
+#include "LinearMath/btTransformUtil.h"  //for btConvexSeparatingDistanceUtil
+
+class btConvexPenetrationDepthSolver;
+
+///Enabling USE_SEPDISTANCE_UTIL2 requires 100% reliable distance computation. However, when using large size ratios GJK can be imprecise
+///so the distance is not conservative. In that case, enabling this USE_SEPDISTANCE_UTIL2 would result in failing/missing collisions.
+///Either improve GJK for large size ratios (testing a 100 units versus a 0.1 unit object) or only enable the util
+///for certain pairs that have a small size ratio
+
+///The convexConvexAlgorithm collision algorithm implements time of impact, convex closest points and penetration depth calculations between two convex objects.
+///Multiple contact points are calculated by perturbing the orientation of the smallest object orthogonal to the separating normal.
+///This idea was described by Gino van den Bergen in this forum topic http://www.bulletphysics.com/Bullet/phpBB3/viewtopic.php?f=4&t=288&p=888#p888
+class btConvexConvexMprAlgorithm : public btActivatingCollisionAlgorithm
+{
+	bool m_ownManifold;
+	btPersistentManifold* m_manifoldPtr;
+	///cache separating vector to speedup collision detection
+
+public:
+	btConvexConvexMprAlgorithm(btPersistentManifold* mf, const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap);
+
+	virtual ~btConvexConvexMprAlgorithm();
+
+	virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	virtual btScalar calculateTimeOfImpact(btCollisionObject* body0, btCollisionObject* body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut);
+
+	virtual void getAllContactManifolds(btManifoldArray& manifoldArray)
+	{
+		///should we use m_ownManifold to avoid adding duplicates?
+		if (m_manifoldPtr && m_ownManifold)
+			manifoldArray.push_back(m_manifoldPtr);
+	}
+
+	const btPersistentManifold* getManifold()
+	{
+		return m_manifoldPtr;
+	}
+
+	struct CreateFunc : public btCollisionAlgorithmCreateFunc
+	{
+		CreateFunc();
+
+		virtual ~CreateFunc();
+
+		virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap)
+		{
+			void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btConvexConvexMprAlgorithm));
+			return new (mem) btConvexConvexMprAlgorithm(ci.m_manifold, ci, body0Wrap, body1Wrap);
+		}
+	};
+};
+
+#endif  //BT_CONVEX_CONVEX_MPR_ALGORITHM_H
diff --git a/engine/inc/bullet/btBulletCollisionCommon.h b/engine/inc/bullet/btBulletCollisionCommon.h
new file mode 100644
index 00000000..4f523756
--- /dev/null
+++ b/engine/inc/bullet/btBulletCollisionCommon.h
@@ -0,0 +1,65 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BULLET_COLLISION_COMMON_H
+#define BULLET_COLLISION_COMMON_H
+
+///Common headerfile includes for Bullet Collision Detection
+
+///Bullet's btCollisionWorld and btCollisionObject definitions
+#include "BulletCollision/CollisionDispatch/btCollisionWorld.h"
+#include "BulletCollision/CollisionDispatch/btCollisionObject.h"
+
+///Collision Shapes
+#include "BulletCollision/CollisionShapes/btBoxShape.h"
+#include "BulletCollision/CollisionShapes/btSphereShape.h"
+#include "BulletCollision/CollisionShapes/btCapsuleShape.h"
+#include "BulletCollision/CollisionShapes/btCylinderShape.h"
+#include "BulletCollision/CollisionShapes/btConeShape.h"
+#include "BulletCollision/CollisionShapes/btStaticPlaneShape.h"
+#include "BulletCollision/CollisionShapes/btConvexHullShape.h"
+#include "BulletCollision/CollisionShapes/btTriangleMesh.h"
+#include "BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h"
+#include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h"
+#include "BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h"
+#include "BulletCollision/CollisionShapes/btTriangleMeshShape.h"
+#include "BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h"
+#include "BulletCollision/CollisionShapes/btCompoundShape.h"
+#include "BulletCollision/CollisionShapes/btTetrahedronShape.h"
+#include "BulletCollision/CollisionShapes/btEmptyShape.h"
+#include "BulletCollision/CollisionShapes/btMultiSphereShape.h"
+#include "BulletCollision/CollisionShapes/btUniformScalingShape.h"
+
+///Narrowphase Collision Detector
+#include "BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h"
+
+//#include "BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h"
+#include "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h"
+
+///Dispatching and generation of collision pairs (broadphase)
+#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h"
+#include "BulletCollision/BroadphaseCollision/btSimpleBroadphase.h"
+#include "BulletCollision/BroadphaseCollision/btAxisSweep3.h"
+#include "BulletCollision/BroadphaseCollision/btDbvtBroadphase.h"
+
+///Math library & Utils
+#include "LinearMath/btQuaternion.h"
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btDefaultMotionState.h"
+#include "LinearMath/btQuickprof.h"
+#include "LinearMath/btIDebugDraw.h"
+#include "LinearMath/btSerializer.h"
+
+#endif  //BULLET_COLLISION_COMMON_H
diff --git a/engine/inc/bullet/btBulletDynamicsCommon.h b/engine/inc/bullet/btBulletDynamicsCommon.h
new file mode 100644
index 00000000..a421fa44
--- /dev/null
+++ b/engine/inc/bullet/btBulletDynamicsCommon.h
@@ -0,0 +1,43 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BULLET_DYNAMICS_COMMON_H
+#define BULLET_DYNAMICS_COMMON_H
+
+///Common headerfile includes for Bullet Dynamics, including Collision Detection
+#include "btBulletCollisionCommon.h"
+
+#include "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h"
+
+#include "BulletDynamics/Dynamics/btSimpleDynamicsWorld.h"
+#include "BulletDynamics/Dynamics/btRigidBody.h"
+
+#include "BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h"
+#include "BulletDynamics/ConstraintSolver/btHingeConstraint.h"
+#include "BulletDynamics/ConstraintSolver/btConeTwistConstraint.h"
+#include "BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h"
+#include "BulletDynamics/ConstraintSolver/btSliderConstraint.h"
+#include "BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.h"
+#include "BulletDynamics/ConstraintSolver/btUniversalConstraint.h"
+#include "BulletDynamics/ConstraintSolver/btHinge2Constraint.h"
+#include "BulletDynamics/ConstraintSolver/btGearConstraint.h"
+#include "BulletDynamics/ConstraintSolver/btFixedConstraint.h"
+
+#include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h"
+
+///Vehicle simulation, with wheel contact simulated by raycasts
+#include "BulletDynamics/Vehicle/btRaycastVehicle.h"
+
+#endif  //BULLET_DYNAMICS_COMMON_H
diff --git a/engine/inc/discord/achievement_manager.h b/engine/inc/discord/achievement_manager.h
new file mode 100644
index 00000000..1b429e25
--- /dev/null
+++ b/engine/inc/discord/achievement_manager.h
@@ -0,0 +1,34 @@
+#pragma once
+
+#include "types.h"
+
+namespace discord {
+
+class AchievementManager final {
+public:
+    ~AchievementManager() = default;
+
+    void SetUserAchievement(Snowflake achievementId,
+                            std::int64_t percentComplete,
+                            std::function<void(Result)> callback);
+    void FetchUserAchievements(std::function<void(Result)> callback);
+    void CountUserAchievements(std::int32_t* count);
+    Result GetUserAchievement(Snowflake userAchievementId, UserAchievement* userAchievement);
+    Result GetUserAchievementAt(std::int32_t index, UserAchievement* userAchievement);
+
+    Event<UserAchievement const&> OnUserAchievementUpdate;
+
+private:
+    friend class Core;
+
+    AchievementManager() = default;
+    AchievementManager(AchievementManager const& rhs) = delete;
+    AchievementManager& operator=(AchievementManager const& rhs) = delete;
+    AchievementManager(AchievementManager&& rhs) = delete;
+    AchievementManager& operator=(AchievementManager&& rhs) = delete;
+
+    IDiscordAchievementManager* internal_;
+    static IDiscordAchievementEvents events_;
+};
+
+} // namespace discord
diff --git a/engine/inc/discord/activity_manager.h b/engine/inc/discord/activity_manager.h
new file mode 100644
index 00000000..c107be27
--- /dev/null
+++ b/engine/inc/discord/activity_manager.h
@@ -0,0 +1,42 @@
+#pragma once
+
+#include "types.h"
+
+namespace discord {
+
+class ActivityManager final {
+public:
+    ~ActivityManager() = default;
+
+    Result RegisterCommand(char const* command);
+    Result RegisterSteam(std::uint32_t steamId);
+    void UpdateActivity(Activity const& activity, std::function<void(Result)> callback);
+    void ClearActivity(std::function<void(Result)> callback);
+    void SendRequestReply(UserId userId,
+                          ActivityJoinRequestReply reply,
+                          std::function<void(Result)> callback);
+    void SendInvite(UserId userId,
+                    ActivityActionType type,
+                    char const* content,
+                    std::function<void(Result)> callback);
+    void AcceptInvite(UserId userId, std::function<void(Result)> callback);
+
+    Event<char const*> OnActivityJoin;
+    Event<char const*> OnActivitySpectate;
+    Event<User const&> OnActivityJoinRequest;
+    Event<ActivityActionType, User const&, Activity const&> OnActivityInvite;
+
+private:
+    friend class Core;
+
+    ActivityManager() = default;
+    ActivityManager(ActivityManager const& rhs) = delete;
+    ActivityManager& operator=(ActivityManager const& rhs) = delete;
+    ActivityManager(ActivityManager&& rhs) = delete;
+    ActivityManager& operator=(ActivityManager&& rhs) = delete;
+
+    IDiscordActivityManager* internal_;
+    static IDiscordActivityEvents events_;
+};
+
+} // namespace discord
diff --git a/engine/inc/discord/application_manager.h b/engine/inc/discord/application_manager.h
new file mode 100644
index 00000000..ab0e8563
--- /dev/null
+++ b/engine/inc/discord/application_manager.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include "types.h"
+
+namespace discord {
+
+class ApplicationManager final {
+public:
+    ~ApplicationManager() = default;
+
+    void ValidateOrExit(std::function<void(Result)> callback);
+    void GetCurrentLocale(char locale[128]);
+    void GetCurrentBranch(char branch[4096]);
+    void GetOAuth2Token(std::function<void(Result, OAuth2Token const&)> callback);
+    void GetTicket(std::function<void(Result, char const*)> callback);
+
+private:
+    friend class Core;
+
+    ApplicationManager() = default;
+    ApplicationManager(ApplicationManager const& rhs) = delete;
+    ApplicationManager& operator=(ApplicationManager const& rhs) = delete;
+    ApplicationManager(ApplicationManager&& rhs) = delete;
+    ApplicationManager& operator=(ApplicationManager&& rhs) = delete;
+
+    IDiscordApplicationManager* internal_;
+    static IDiscordApplicationEvents events_;
+};
+
+} // namespace discord
diff --git a/engine/inc/discord/core.h b/engine/inc/discord/core.h
new file mode 100644
index 00000000..8af6fca2
--- /dev/null
+++ b/engine/inc/discord/core.h
@@ -0,0 +1,64 @@
+#pragma once
+
+#include "types.h"
+#include "application_manager.h"
+#include "user_manager.h"
+#include "image_manager.h"
+#include "activity_manager.h"
+#include "relationship_manager.h"
+#include "lobby_manager.h"
+#include "network_manager.h"
+#include "overlay_manager.h"
+#include "storage_manager.h"
+#include "store_manager.h"
+#include "voice_manager.h"
+#include "achievement_manager.h"
+
+namespace discord {
+
+class Core final {
+public:
+    static Result Create(ClientId clientId, std::uint64_t flags, Core** instance);
+
+    ~Core();
+
+    Result RunCallbacks();
+    void SetLogHook(LogLevel minLevel, std::function<void(LogLevel, char const*)> hook);
+
+    discord::ApplicationManager& ApplicationManager();
+    discord::UserManager& UserManager();
+    discord::ImageManager& ImageManager();
+    discord::ActivityManager& ActivityManager();
+    discord::RelationshipManager& RelationshipManager();
+    discord::LobbyManager& LobbyManager();
+    discord::NetworkManager& NetworkManager();
+    discord::OverlayManager& OverlayManager();
+    discord::StorageManager& StorageManager();
+    discord::StoreManager& StoreManager();
+    discord::VoiceManager& VoiceManager();
+    discord::AchievementManager& AchievementManager();
+
+private:
+    Core() = default;
+    Core(Core const& rhs) = delete;
+    Core& operator=(Core const& rhs) = delete;
+    Core(Core&& rhs) = delete;
+    Core& operator=(Core&& rhs) = delete;
+
+    IDiscordCore* internal_;
+    Event<LogLevel, char const*> setLogHook_;
+    discord::ApplicationManager applicationManager_;
+    discord::UserManager userManager_;
+    discord::ImageManager imageManager_;
+    discord::ActivityManager activityManager_;
+    discord::RelationshipManager relationshipManager_;
+    discord::LobbyManager lobbyManager_;
+    discord::NetworkManager networkManager_;
+    discord::OverlayManager overlayManager_;
+    discord::StorageManager storageManager_;
+    discord::StoreManager storeManager_;
+    discord::VoiceManager voiceManager_;
+    discord::AchievementManager achievementManager_;
+};
+
+} // namespace discord
diff --git a/engine/inc/discord/discord.h b/engine/inc/discord/discord.h
new file mode 100644
index 00000000..c9912129
--- /dev/null
+++ b/engine/inc/discord/discord.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "types.h"
+#include "core.h"
+#include "application_manager.h"
+#include "user_manager.h"
+#include "image_manager.h"
+#include "activity_manager.h"
+#include "relationship_manager.h"
+#include "lobby_manager.h"
+#include "network_manager.h"
+#include "overlay_manager.h"
+#include "storage_manager.h"
+#include "store_manager.h"
+#include "voice_manager.h"
+#include "achievement_manager.h"
diff --git a/engine/inc/discord/discord_game_sdk.h b/engine/inc/discord/discord_game_sdk.h
new file mode 100644
index 00000000..984d4746
--- /dev/null
+++ b/engine/inc/discord/discord_game_sdk.h
@@ -0,0 +1,646 @@
+#ifndef _DISCORD_GAME_SDK_H_
+#define _DISCORD_GAME_SDK_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <string.h>
+#ifndef __cplusplus
+#include <stdbool.h>
+#endif
+
+#define DISCORD_VERSION 2
+#define DISCORD_APPLICATION_MANAGER_VERSION 1
+#define DISCORD_USER_MANAGER_VERSION 1
+#define DISCORD_IMAGE_MANAGER_VERSION 1
+#define DISCORD_ACTIVITY_MANAGER_VERSION 1
+#define DISCORD_RELATIONSHIP_MANAGER_VERSION 1
+#define DISCORD_LOBBY_MANAGER_VERSION 1
+#define DISCORD_NETWORK_MANAGER_VERSION 1
+#define DISCORD_OVERLAY_MANAGER_VERSION 1
+#define DISCORD_STORAGE_MANAGER_VERSION 1
+#define DISCORD_STORE_MANAGER_VERSION 1
+#define DISCORD_VOICE_MANAGER_VERSION 1
+#define DISCORD_ACHIEVEMENT_MANAGER_VERSION 1
+
+enum EDiscordResult {
+    DiscordResult_Ok = 0,
+    DiscordResult_ServiceUnavailable = 1,
+    DiscordResult_InvalidVersion = 2,
+    DiscordResult_LockFailed = 3,
+    DiscordResult_InternalError = 4,
+    DiscordResult_InvalidPayload = 5,
+    DiscordResult_InvalidCommand = 6,
+    DiscordResult_InvalidPermissions = 7,
+    DiscordResult_NotFetched = 8,
+    DiscordResult_NotFound = 9,
+    DiscordResult_Conflict = 10,
+    DiscordResult_InvalidSecret = 11,
+    DiscordResult_InvalidJoinSecret = 12,
+    DiscordResult_NoEligibleActivity = 13,
+    DiscordResult_InvalidInvite = 14,
+    DiscordResult_NotAuthenticated = 15,
+    DiscordResult_InvalidAccessToken = 16,
+    DiscordResult_ApplicationMismatch = 17,
+    DiscordResult_InvalidDataUrl = 18,
+    DiscordResult_InvalidBase64 = 19,
+    DiscordResult_NotFiltered = 20,
+    DiscordResult_LobbyFull = 21,
+    DiscordResult_InvalidLobbySecret = 22,
+    DiscordResult_InvalidFilename = 23,
+    DiscordResult_InvalidFileSize = 24,
+    DiscordResult_InvalidEntitlement = 25,
+    DiscordResult_NotInstalled = 26,
+    DiscordResult_NotRunning = 27,
+    DiscordResult_InsufficientBuffer = 28,
+    DiscordResult_PurchaseCanceled = 29,
+    DiscordResult_InvalidGuild = 30,
+    DiscordResult_InvalidEvent = 31,
+    DiscordResult_InvalidChannel = 32,
+    DiscordResult_InvalidOrigin = 33,
+    DiscordResult_RateLimited = 34,
+    DiscordResult_OAuth2Error = 35,
+    DiscordResult_SelectChannelTimeout = 36,
+    DiscordResult_GetGuildTimeout = 37,
+    DiscordResult_SelectVoiceForceRequired = 38,
+    DiscordResult_CaptureShortcutAlreadyListening = 39,
+    DiscordResult_UnauthorizedForAchievement = 40,
+    DiscordResult_InvalidGiftCode = 41,
+    DiscordResult_PurchaseError = 42,
+    DiscordResult_TransactionAborted = 43,
+};
+
+enum EDiscordCreateFlags {
+    DiscordCreateFlags_Default = 0,
+    DiscordCreateFlags_NoRequireDiscord = 1,
+};
+
+enum EDiscordLogLevel {
+    DiscordLogLevel_Error = 1,
+    DiscordLogLevel_Warn,
+    DiscordLogLevel_Info,
+    DiscordLogLevel_Debug,
+};
+
+enum EDiscordUserFlag {
+    DiscordUserFlag_Partner = 2,
+    DiscordUserFlag_HypeSquadEvents = 4,
+    DiscordUserFlag_HypeSquadHouse1 = 64,
+    DiscordUserFlag_HypeSquadHouse2 = 128,
+    DiscordUserFlag_HypeSquadHouse3 = 256,
+};
+
+enum EDiscordPremiumType {
+    DiscordPremiumType_None = 0,
+    DiscordPremiumType_Tier1 = 1,
+    DiscordPremiumType_Tier2 = 2,
+};
+
+enum EDiscordImageType {
+    DiscordImageType_User,
+};
+
+enum EDiscordActivityType {
+    DiscordActivityType_Playing,
+    DiscordActivityType_Streaming,
+    DiscordActivityType_Listening,
+    DiscordActivityType_Watching,
+};
+
+enum EDiscordActivityActionType {
+    DiscordActivityActionType_Join = 1,
+    DiscordActivityActionType_Spectate,
+};
+
+enum EDiscordActivityJoinRequestReply {
+    DiscordActivityJoinRequestReply_No,
+    DiscordActivityJoinRequestReply_Yes,
+    DiscordActivityJoinRequestReply_Ignore,
+};
+
+enum EDiscordStatus {
+    DiscordStatus_Offline = 0,
+    DiscordStatus_Online = 1,
+    DiscordStatus_Idle = 2,
+    DiscordStatus_DoNotDisturb = 3,
+};
+
+enum EDiscordRelationshipType {
+    DiscordRelationshipType_None,
+    DiscordRelationshipType_Friend,
+    DiscordRelationshipType_Blocked,
+    DiscordRelationshipType_PendingIncoming,
+    DiscordRelationshipType_PendingOutgoing,
+    DiscordRelationshipType_Implicit,
+};
+
+enum EDiscordLobbyType {
+    DiscordLobbyType_Private = 1,
+    DiscordLobbyType_Public,
+};
+
+enum EDiscordLobbySearchComparison {
+    DiscordLobbySearchComparison_LessThanOrEqual = -2,
+    DiscordLobbySearchComparison_LessThan,
+    DiscordLobbySearchComparison_Equal,
+    DiscordLobbySearchComparison_GreaterThan,
+    DiscordLobbySearchComparison_GreaterThanOrEqual,
+    DiscordLobbySearchComparison_NotEqual,
+};
+
+enum EDiscordLobbySearchCast {
+    DiscordLobbySearchCast_String = 1,
+    DiscordLobbySearchCast_Number,
+};
+
+enum EDiscordLobbySearchDistance {
+    DiscordLobbySearchDistance_Local,
+    DiscordLobbySearchDistance_Default,
+    DiscordLobbySearchDistance_Extended,
+    DiscordLobbySearchDistance_Global,
+};
+
+enum EDiscordEntitlementType {
+    DiscordEntitlementType_Purchase = 1,
+    DiscordEntitlementType_PremiumSubscription,
+    DiscordEntitlementType_DeveloperGift,
+    DiscordEntitlementType_TestModePurchase,
+    DiscordEntitlementType_FreePurchase,
+    DiscordEntitlementType_UserGift,
+    DiscordEntitlementType_PremiumPurchase,
+};
+
+enum EDiscordSkuType {
+    DiscordSkuType_Application = 1,
+    DiscordSkuType_DLC,
+    DiscordSkuType_Consumable,
+    DiscordSkuType_Bundle,
+};
+
+enum EDiscordInputModeType {
+    DiscordInputModeType_VoiceActivity = 0,
+    DiscordInputModeType_PushToTalk,
+};
+
+typedef int64_t DiscordClientId;
+typedef int32_t DiscordVersion;
+typedef int64_t DiscordSnowflake;
+typedef int64_t DiscordTimestamp;
+typedef DiscordSnowflake DiscordUserId;
+typedef char DiscordLocale[128];
+typedef char DiscordBranch[4096];
+typedef DiscordSnowflake DiscordLobbyId;
+typedef char DiscordLobbySecret[128];
+typedef char DiscordMetadataKey[256];
+typedef char DiscordMetadataValue[4096];
+typedef uint64_t DiscordNetworkPeerId;
+typedef uint8_t DiscordNetworkChannelId;
+typedef char DiscordPath[4096];
+typedef char DiscordDateTime[64];
+
+struct DiscordUser {
+    DiscordUserId id;
+    char username[256];
+    char discriminator[8];
+    char avatar[128];
+    bool bot;
+};
+
+struct DiscordOAuth2Token {
+    char access_token[128];
+    char scopes[1024];
+    DiscordTimestamp expires;
+};
+
+struct DiscordImageHandle {
+    enum EDiscordImageType type;
+    int64_t id;
+    uint32_t size;
+};
+
+struct DiscordImageDimensions {
+    uint32_t width;
+    uint32_t height;
+};
+
+struct DiscordActivityTimestamps {
+    DiscordTimestamp start;
+    DiscordTimestamp end;
+};
+
+struct DiscordActivityAssets {
+    char large_image[128];
+    char large_text[128];
+    char small_image[128];
+    char small_text[128];
+};
+
+struct DiscordPartySize {
+    int32_t current_size;
+    int32_t max_size;
+};
+
+struct DiscordActivityParty {
+    char id[128];
+    struct DiscordPartySize size;
+};
+
+struct DiscordActivitySecrets {
+    char match[128];
+    char join[128];
+    char spectate[128];
+};
+
+struct DiscordActivity {
+    enum EDiscordActivityType type;
+    int64_t application_id;
+    char name[128];
+    char state[128];
+    char details[128];
+    struct DiscordActivityTimestamps timestamps;
+    struct DiscordActivityAssets assets;
+    struct DiscordActivityParty party;
+    struct DiscordActivitySecrets secrets;
+    bool instance;
+};
+
+struct DiscordPresence {
+    enum EDiscordStatus status;
+    struct DiscordActivity activity;
+};
+
+struct DiscordRelationship {
+    enum EDiscordRelationshipType type;
+    struct DiscordUser user;
+    struct DiscordPresence presence;
+};
+
+struct DiscordLobby {
+    DiscordLobbyId id;
+    enum EDiscordLobbyType type;
+    DiscordUserId owner_id;
+    DiscordLobbySecret secret;
+    uint32_t capacity;
+    bool locked;
+};
+
+struct DiscordFileStat {
+    char filename[260];
+    uint64_t size;
+    uint64_t last_modified;
+};
+
+struct DiscordEntitlement {
+    DiscordSnowflake id;
+    enum EDiscordEntitlementType type;
+    DiscordSnowflake sku_id;
+};
+
+struct DiscordSkuPrice {
+    uint32_t amount;
+    char currency[16];
+};
+
+struct DiscordSku {
+    DiscordSnowflake id;
+    enum EDiscordSkuType type;
+    char name[256];
+    struct DiscordSkuPrice price;
+};
+
+struct DiscordInputMode {
+    enum EDiscordInputModeType type;
+    char shortcut[256];
+};
+
+struct DiscordUserAchievement {
+    DiscordSnowflake user_id;
+    DiscordSnowflake achievement_id;
+    uint8_t percent_complete;
+    DiscordDateTime unlocked_at;
+};
+
+struct IDiscordLobbyTransaction {
+    enum EDiscordResult (*set_type)(struct IDiscordLobbyTransaction* lobby_transaction, enum EDiscordLobbyType type);
+    enum EDiscordResult (*set_owner)(struct IDiscordLobbyTransaction* lobby_transaction, DiscordUserId owner_id);
+    enum EDiscordResult (*set_capacity)(struct IDiscordLobbyTransaction* lobby_transaction, uint32_t capacity);
+    enum EDiscordResult (*set_metadata)(struct IDiscordLobbyTransaction* lobby_transaction, DiscordMetadataKey key, DiscordMetadataValue value);
+    enum EDiscordResult (*delete_metadata)(struct IDiscordLobbyTransaction* lobby_transaction, DiscordMetadataKey key);
+    enum EDiscordResult (*set_locked)(struct IDiscordLobbyTransaction* lobby_transaction, bool locked);
+};
+
+struct IDiscordLobbyMemberTransaction {
+    enum EDiscordResult (*set_metadata)(struct IDiscordLobbyMemberTransaction* lobby_member_transaction, DiscordMetadataKey key, DiscordMetadataValue value);
+    enum EDiscordResult (*delete_metadata)(struct IDiscordLobbyMemberTransaction* lobby_member_transaction, DiscordMetadataKey key);
+};
+
+struct IDiscordLobbySearchQuery {
+    enum EDiscordResult (*filter)(struct IDiscordLobbySearchQuery* lobby_search_query, DiscordMetadataKey key, enum EDiscordLobbySearchComparison comparison, enum EDiscordLobbySearchCast cast, DiscordMetadataValue value);
+    enum EDiscordResult (*sort)(struct IDiscordLobbySearchQuery* lobby_search_query, DiscordMetadataKey key, enum EDiscordLobbySearchCast cast, DiscordMetadataValue value);
+    enum EDiscordResult (*limit)(struct IDiscordLobbySearchQuery* lobby_search_query, uint32_t limit);
+    enum EDiscordResult (*distance)(struct IDiscordLobbySearchQuery* lobby_search_query, enum EDiscordLobbySearchDistance distance);
+};
+
+typedef void* IDiscordApplicationEvents;
+
+struct IDiscordApplicationManager {
+    void (*validate_or_exit)(struct IDiscordApplicationManager* manager, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*get_current_locale)(struct IDiscordApplicationManager* manager, DiscordLocale* locale);
+    void (*get_current_branch)(struct IDiscordApplicationManager* manager, DiscordBranch* branch);
+    void (*get_oauth2_token)(struct IDiscordApplicationManager* manager, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result, struct DiscordOAuth2Token* oauth2_token));
+    void (*get_ticket)(struct IDiscordApplicationManager* manager, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result, const char* data));
+};
+
+struct IDiscordUserEvents {
+    void (*on_current_user_update)(void* event_data);
+};
+
+struct IDiscordUserManager {
+    enum EDiscordResult (*get_current_user)(struct IDiscordUserManager* manager, struct DiscordUser* current_user);
+    void (*get_user)(struct IDiscordUserManager* manager, DiscordUserId user_id, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result, struct DiscordUser* user));
+    enum EDiscordResult (*get_current_user_premium_type)(struct IDiscordUserManager* manager, enum EDiscordPremiumType* premium_type);
+    enum EDiscordResult (*current_user_has_flag)(struct IDiscordUserManager* manager, enum EDiscordUserFlag flag, bool* has_flag);
+};
+
+typedef void* IDiscordImageEvents;
+
+struct IDiscordImageManager {
+    void (*fetch)(struct IDiscordImageManager* manager, struct DiscordImageHandle handle, bool refresh, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result, struct DiscordImageHandle handle_result));
+    enum EDiscordResult (*get_dimensions)(struct IDiscordImageManager* manager, struct DiscordImageHandle handle, struct DiscordImageDimensions* dimensions);
+    enum EDiscordResult (*get_data)(struct IDiscordImageManager* manager, struct DiscordImageHandle handle, uint8_t* data, uint32_t data_length);
+};
+
+struct IDiscordActivityEvents {
+    void (*on_activity_join)(void* event_data, const char* secret);
+    void (*on_activity_spectate)(void* event_data, const char* secret);
+    void (*on_activity_join_request)(void* event_data, struct DiscordUser* user);
+    void (*on_activity_invite)(void* event_data, enum EDiscordActivityActionType type, struct DiscordUser* user, struct DiscordActivity* activity);
+};
+
+struct IDiscordActivityManager {
+    enum EDiscordResult (*register_command)(struct IDiscordActivityManager* manager, const char* command);
+    enum EDiscordResult (*register_steam)(struct IDiscordActivityManager* manager, uint32_t steam_id);
+    void (*update_activity)(struct IDiscordActivityManager* manager, struct DiscordActivity* activity, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*clear_activity)(struct IDiscordActivityManager* manager, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*send_request_reply)(struct IDiscordActivityManager* manager, DiscordUserId user_id, enum EDiscordActivityJoinRequestReply reply, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*send_invite)(struct IDiscordActivityManager* manager, DiscordUserId user_id, enum EDiscordActivityActionType type, const char* content, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*accept_invite)(struct IDiscordActivityManager* manager, DiscordUserId user_id, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result));
+};
+
+struct IDiscordRelationshipEvents {
+    void (*on_refresh)(void* event_data);
+    void (*on_relationship_update)(void* event_data, struct DiscordRelationship* relationship);
+};
+
+struct IDiscordRelationshipManager {
+    void (*filter)(struct IDiscordRelationshipManager* manager, void* filter_data, bool (*filter)(void* filter_data, struct DiscordRelationship* relationship));
+    enum EDiscordResult (*count)(struct IDiscordRelationshipManager* manager, int32_t* count);
+    enum EDiscordResult (*get)(struct IDiscordRelationshipManager* manager, DiscordUserId user_id, struct DiscordRelationship* relationship);
+    enum EDiscordResult (*get_at)(struct IDiscordRelationshipManager* manager, uint32_t index, struct DiscordRelationship* relationship);
+};
+
+struct IDiscordLobbyEvents {
+    void (*on_lobby_update)(void* event_data, int64_t lobby_id);
+    void (*on_lobby_delete)(void* event_data, int64_t lobby_id, uint32_t reason);
+    void (*on_member_connect)(void* event_data, int64_t lobby_id, int64_t user_id);
+    void (*on_member_update)(void* event_data, int64_t lobby_id, int64_t user_id);
+    void (*on_member_disconnect)(void* event_data, int64_t lobby_id, int64_t user_id);
+    void (*on_lobby_message)(void* event_data, int64_t lobby_id, int64_t user_id, uint8_t* data, uint32_t data_length);
+    void (*on_speaking)(void* event_data, int64_t lobby_id, int64_t user_id, bool speaking);
+    void (*on_network_message)(void* event_data, int64_t lobby_id, int64_t user_id, uint8_t channel_id, uint8_t* data, uint32_t data_length);
+};
+
+struct IDiscordLobbyManager {
+    enum EDiscordResult (*get_lobby_create_transaction)(struct IDiscordLobbyManager* manager, struct IDiscordLobbyTransaction** transaction);
+    enum EDiscordResult (*get_lobby_update_transaction)(struct IDiscordLobbyManager* manager, DiscordLobbyId lobby_id, struct IDiscordLobbyTransaction** transaction);
+    enum EDiscordResult (*get_member_update_transaction)(struct IDiscordLobbyManager* manager, DiscordLobbyId lobby_id, DiscordUserId user_id, struct IDiscordLobbyMemberTransaction** transaction);
+    void (*create_lobby)(struct IDiscordLobbyManager* manager, struct IDiscordLobbyTransaction* transaction, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result, struct DiscordLobby* lobby));
+    void (*update_lobby)(struct IDiscordLobbyManager* manager, DiscordLobbyId lobby_id, struct IDiscordLobbyTransaction* transaction, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*delete_lobby)(struct IDiscordLobbyManager* manager, DiscordLobbyId lobby_id, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*connect_lobby)(struct IDiscordLobbyManager* manager, DiscordLobbyId lobby_id, DiscordLobbySecret secret, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result, struct DiscordLobby* lobby));
+    void (*connect_lobby_with_activity_secret)(struct IDiscordLobbyManager* manager, DiscordLobbySecret activity_secret, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result, struct DiscordLobby* lobby));
+    void (*disconnect_lobby)(struct IDiscordLobbyManager* manager, DiscordLobbyId lobby_id, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result));
+    enum EDiscordResult (*get_lobby)(struct IDiscordLobbyManager* manager, DiscordLobbyId lobby_id, struct DiscordLobby* lobby);
+    enum EDiscordResult (*get_lobby_activity_secret)(struct IDiscordLobbyManager* manager, DiscordLobbyId lobby_id, DiscordLobbySecret* secret);
+    enum EDiscordResult (*get_lobby_metadata_value)(struct IDiscordLobbyManager* manager, DiscordLobbyId lobby_id, DiscordMetadataKey key, DiscordMetadataValue* value);
+    enum EDiscordResult (*get_lobby_metadata_key)(struct IDiscordLobbyManager* manager, DiscordLobbyId lobby_id, int32_t index, DiscordMetadataKey* key);
+    enum EDiscordResult (*lobby_metadata_count)(struct IDiscordLobbyManager* manager, DiscordLobbyId lobby_id, int32_t* count);
+    enum EDiscordResult (*member_count)(struct IDiscordLobbyManager* manager, DiscordLobbyId lobby_id, int32_t* count);
+    enum EDiscordResult (*get_member_user_id)(struct IDiscordLobbyManager* manager, DiscordLobbyId lobby_id, int32_t index, DiscordUserId* user_id);
+    enum EDiscordResult (*get_member_user)(struct IDiscordLobbyManager* manager, DiscordLobbyId lobby_id, DiscordUserId user_id, struct DiscordUser* user);
+    enum EDiscordResult (*get_member_metadata_value)(struct IDiscordLobbyManager* manager, DiscordLobbyId lobby_id, DiscordUserId user_id, DiscordMetadataKey key, DiscordMetadataValue* value);
+    enum EDiscordResult (*get_member_metadata_key)(struct IDiscordLobbyManager* manager, DiscordLobbyId lobby_id, DiscordUserId user_id, int32_t index, DiscordMetadataKey* key);
+    enum EDiscordResult (*member_metadata_count)(struct IDiscordLobbyManager* manager, DiscordLobbyId lobby_id, DiscordUserId user_id, int32_t* count);
+    void (*update_member)(struct IDiscordLobbyManager* manager, DiscordLobbyId lobby_id, DiscordUserId user_id, struct IDiscordLobbyMemberTransaction* transaction, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*send_lobby_message)(struct IDiscordLobbyManager* manager, DiscordLobbyId lobby_id, uint8_t* data, uint32_t data_length, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result));
+    enum EDiscordResult (*get_search_query)(struct IDiscordLobbyManager* manager, struct IDiscordLobbySearchQuery** query);
+    void (*search)(struct IDiscordLobbyManager* manager, struct IDiscordLobbySearchQuery* query, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*lobby_count)(struct IDiscordLobbyManager* manager, int32_t* count);
+    enum EDiscordResult (*get_lobby_id)(struct IDiscordLobbyManager* manager, int32_t index, DiscordLobbyId* lobby_id);
+    void (*connect_voice)(struct IDiscordLobbyManager* manager, DiscordLobbyId lobby_id, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*disconnect_voice)(struct IDiscordLobbyManager* manager, DiscordLobbyId lobby_id, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result));
+    enum EDiscordResult (*connect_network)(struct IDiscordLobbyManager* manager, DiscordLobbyId lobby_id);
+    enum EDiscordResult (*disconnect_network)(struct IDiscordLobbyManager* manager, DiscordLobbyId lobby_id);
+    enum EDiscordResult (*flush_network)(struct IDiscordLobbyManager* manager);
+    enum EDiscordResult (*open_network_channel)(struct IDiscordLobbyManager* manager, DiscordLobbyId lobby_id, uint8_t channel_id, bool reliable);
+    enum EDiscordResult (*send_network_message)(struct IDiscordLobbyManager* manager, DiscordLobbyId lobby_id, DiscordUserId user_id, uint8_t channel_id, uint8_t* data, uint32_t data_length);
+};
+
+struct IDiscordNetworkEvents {
+    void (*on_message)(void* event_data, DiscordNetworkPeerId peer_id, DiscordNetworkChannelId channel_id, uint8_t* data, uint32_t data_length);
+    void (*on_route_update)(void* event_data, const char* route_data);
+};
+
+struct IDiscordNetworkManager {
+    /**
+     * Get the local peer ID for this process.
+     */
+    void (*get_peer_id)(struct IDiscordNetworkManager* manager, DiscordNetworkPeerId* peer_id);
+    /**
+     * Send pending network messages.
+     */
+    enum EDiscordResult (*flush)(struct IDiscordNetworkManager* manager);
+    /**
+     * Open a connection to a remote peer.
+     */
+    enum EDiscordResult (*open_peer)(struct IDiscordNetworkManager* manager, DiscordNetworkPeerId peer_id, const char* route_data);
+    /**
+     * Update the route data for a connected peer.
+     */
+    enum EDiscordResult (*update_peer)(struct IDiscordNetworkManager* manager, DiscordNetworkPeerId peer_id, const char* route_data);
+    /**
+     * Close the connection to a remote peer.
+     */
+    enum EDiscordResult (*close_peer)(struct IDiscordNetworkManager* manager, DiscordNetworkPeerId peer_id);
+    /**
+     * Open a message channel to a connected peer.
+     */
+    enum EDiscordResult (*open_channel)(struct IDiscordNetworkManager* manager, DiscordNetworkPeerId peer_id, DiscordNetworkChannelId channel_id, bool reliable);
+    /**
+     * Close a message channel to a connected peer.
+     */
+    enum EDiscordResult (*close_channel)(struct IDiscordNetworkManager* manager, DiscordNetworkPeerId peer_id, DiscordNetworkChannelId channel_id);
+    /**
+     * Send a message to a connected peer over an opened message channel.
+     */
+    enum EDiscordResult (*send_message)(struct IDiscordNetworkManager* manager, DiscordNetworkPeerId peer_id, DiscordNetworkChannelId channel_id, uint8_t* data, uint32_t data_length);
+};
+
+struct IDiscordOverlayEvents {
+    void (*on_toggle)(void* event_data, bool locked);
+};
+
+struct IDiscordOverlayManager {
+    void (*is_enabled)(struct IDiscordOverlayManager* manager, bool* enabled);
+    void (*is_locked)(struct IDiscordOverlayManager* manager, bool* locked);
+    void (*set_locked)(struct IDiscordOverlayManager* manager, bool locked, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*open_activity_invite)(struct IDiscordOverlayManager* manager, enum EDiscordActivityActionType type, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*open_guild_invite)(struct IDiscordOverlayManager* manager, const char* code, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*open_voice_settings)(struct IDiscordOverlayManager* manager, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result));
+};
+
+typedef void* IDiscordStorageEvents;
+
+struct IDiscordStorageManager {
+    enum EDiscordResult (*read)(struct IDiscordStorageManager* manager, const char* name, uint8_t* data, uint32_t data_length, uint32_t* read);
+    void (*read_async)(struct IDiscordStorageManager* manager, const char* name, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result, uint8_t* data, uint32_t data_length));
+    void (*read_async_partial)(struct IDiscordStorageManager* manager, const char* name, uint64_t offset, uint64_t length, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result, uint8_t* data, uint32_t data_length));
+    enum EDiscordResult (*write)(struct IDiscordStorageManager* manager, const char* name, uint8_t* data, uint32_t data_length);
+    void (*write_async)(struct IDiscordStorageManager* manager, const char* name, uint8_t* data, uint32_t data_length, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result));
+    enum EDiscordResult (*delete_)(struct IDiscordStorageManager* manager, const char* name);
+    enum EDiscordResult (*exists)(struct IDiscordStorageManager* manager, const char* name, bool* exists);
+    void (*count)(struct IDiscordStorageManager* manager, int32_t* count);
+    enum EDiscordResult (*stat)(struct IDiscordStorageManager* manager, const char* name, struct DiscordFileStat* stat);
+    enum EDiscordResult (*stat_at)(struct IDiscordStorageManager* manager, int32_t index, struct DiscordFileStat* stat);
+    enum EDiscordResult (*get_path)(struct IDiscordStorageManager* manager, DiscordPath* path);
+};
+
+struct IDiscordStoreEvents {
+    void (*on_entitlement_create)(void* event_data, struct DiscordEntitlement* entitlement);
+    void (*on_entitlement_delete)(void* event_data, struct DiscordEntitlement* entitlement);
+};
+
+struct IDiscordStoreManager {
+    void (*fetch_skus)(struct IDiscordStoreManager* manager, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*count_skus)(struct IDiscordStoreManager* manager, int32_t* count);
+    enum EDiscordResult (*get_sku)(struct IDiscordStoreManager* manager, DiscordSnowflake sku_id, struct DiscordSku* sku);
+    enum EDiscordResult (*get_sku_at)(struct IDiscordStoreManager* manager, int32_t index, struct DiscordSku* sku);
+    void (*fetch_entitlements)(struct IDiscordStoreManager* manager, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*count_entitlements)(struct IDiscordStoreManager* manager, int32_t* count);
+    enum EDiscordResult (*get_entitlement)(struct IDiscordStoreManager* manager, DiscordSnowflake entitlement_id, struct DiscordEntitlement* entitlement);
+    enum EDiscordResult (*get_entitlement_at)(struct IDiscordStoreManager* manager, int32_t index, struct DiscordEntitlement* entitlement);
+    enum EDiscordResult (*has_sku_entitlement)(struct IDiscordStoreManager* manager, DiscordSnowflake sku_id, bool* has_entitlement);
+    void (*start_purchase)(struct IDiscordStoreManager* manager, DiscordSnowflake sku_id, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result));
+};
+
+struct IDiscordVoiceEvents {
+    void (*on_settings_update)(void* event_data);
+};
+
+struct IDiscordVoiceManager {
+    enum EDiscordResult (*get_input_mode)(struct IDiscordVoiceManager* manager, struct DiscordInputMode* input_mode);
+    void (*set_input_mode)(struct IDiscordVoiceManager* manager, struct DiscordInputMode input_mode, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result));
+    enum EDiscordResult (*is_self_mute)(struct IDiscordVoiceManager* manager, bool* mute);
+    enum EDiscordResult (*set_self_mute)(struct IDiscordVoiceManager* manager, bool mute);
+    enum EDiscordResult (*is_self_deaf)(struct IDiscordVoiceManager* manager, bool* deaf);
+    enum EDiscordResult (*set_self_deaf)(struct IDiscordVoiceManager* manager, bool deaf);
+    enum EDiscordResult (*is_local_mute)(struct IDiscordVoiceManager* manager, DiscordSnowflake user_id, bool* mute);
+    enum EDiscordResult (*set_local_mute)(struct IDiscordVoiceManager* manager, DiscordSnowflake user_id, bool mute);
+    enum EDiscordResult (*get_local_volume)(struct IDiscordVoiceManager* manager, DiscordSnowflake user_id, uint8_t* volume);
+    enum EDiscordResult (*set_local_volume)(struct IDiscordVoiceManager* manager, DiscordSnowflake user_id, uint8_t volume);
+};
+
+struct IDiscordAchievementEvents {
+    void (*on_user_achievement_update)(void* event_data, struct DiscordUserAchievement* user_achievement);
+};
+
+struct IDiscordAchievementManager {
+    void (*set_user_achievement)(struct IDiscordAchievementManager* manager, DiscordSnowflake achievement_id, int64_t percent_complete, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*fetch_user_achievements)(struct IDiscordAchievementManager* manager, void* callback_data, void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*count_user_achievements)(struct IDiscordAchievementManager* manager, int32_t* count);
+    enum EDiscordResult (*get_user_achievement)(struct IDiscordAchievementManager* manager, DiscordSnowflake user_achievement_id, struct DiscordUserAchievement* user_achievement);
+    enum EDiscordResult (*get_user_achievement_at)(struct IDiscordAchievementManager* manager, int32_t index, struct DiscordUserAchievement* user_achievement);
+};
+
+typedef void* IDiscordCoreEvents;
+
+struct IDiscordCore {
+    void (*destroy)(struct IDiscordCore* core);
+    enum EDiscordResult (*run_callbacks)(struct IDiscordCore* core);
+    void (*set_log_hook)(struct IDiscordCore* core, enum EDiscordLogLevel min_level, void* hook_data, void (*hook)(void* hook_data, enum EDiscordLogLevel level, const char* message));
+    struct IDiscordApplicationManager* (*get_application_manager)(struct IDiscordCore* core);
+    struct IDiscordUserManager* (*get_user_manager)(struct IDiscordCore* core);
+    struct IDiscordImageManager* (*get_image_manager)(struct IDiscordCore* core);
+    struct IDiscordActivityManager* (*get_activity_manager)(struct IDiscordCore* core);
+    struct IDiscordRelationshipManager* (*get_relationship_manager)(struct IDiscordCore* core);
+    struct IDiscordLobbyManager* (*get_lobby_manager)(struct IDiscordCore* core);
+    struct IDiscordNetworkManager* (*get_network_manager)(struct IDiscordCore* core);
+    struct IDiscordOverlayManager* (*get_overlay_manager)(struct IDiscordCore* core);
+    struct IDiscordStorageManager* (*get_storage_manager)(struct IDiscordCore* core);
+    struct IDiscordStoreManager* (*get_store_manager)(struct IDiscordCore* core);
+    struct IDiscordVoiceManager* (*get_voice_manager)(struct IDiscordCore* core);
+    struct IDiscordAchievementManager* (*get_achievement_manager)(struct IDiscordCore* core);
+};
+
+struct DiscordCreateParams {
+    DiscordClientId client_id;
+    uint64_t flags;
+    IDiscordCoreEvents* events;
+    void* event_data;
+    IDiscordApplicationEvents* application_events;
+    DiscordVersion application_version;
+    struct IDiscordUserEvents* user_events;
+    DiscordVersion user_version;
+    IDiscordImageEvents* image_events;
+    DiscordVersion image_version;
+    struct IDiscordActivityEvents* activity_events;
+    DiscordVersion activity_version;
+    struct IDiscordRelationshipEvents* relationship_events;
+    DiscordVersion relationship_version;
+    struct IDiscordLobbyEvents* lobby_events;
+    DiscordVersion lobby_version;
+    struct IDiscordNetworkEvents* network_events;
+    DiscordVersion network_version;
+    struct IDiscordOverlayEvents* overlay_events;
+    DiscordVersion overlay_version;
+    IDiscordStorageEvents* storage_events;
+    DiscordVersion storage_version;
+    struct IDiscordStoreEvents* store_events;
+    DiscordVersion store_version;
+    struct IDiscordVoiceEvents* voice_events;
+    DiscordVersion voice_version;
+    struct IDiscordAchievementEvents* achievement_events;
+    DiscordVersion achievement_version;
+};
+
+#ifdef __cplusplus
+inline
+#else
+static
+#endif
+void DiscordCreateParamsSetDefault(struct DiscordCreateParams* params)
+{
+    memset(params, 0, sizeof(struct DiscordCreateParams));
+    params->application_version = DISCORD_APPLICATION_MANAGER_VERSION;
+    params->user_version = DISCORD_USER_MANAGER_VERSION;
+    params->image_version = DISCORD_IMAGE_MANAGER_VERSION;
+    params->activity_version = DISCORD_ACTIVITY_MANAGER_VERSION;
+    params->relationship_version = DISCORD_RELATIONSHIP_MANAGER_VERSION;
+    params->lobby_version = DISCORD_LOBBY_MANAGER_VERSION;
+    params->network_version = DISCORD_NETWORK_MANAGER_VERSION;
+    params->overlay_version = DISCORD_OVERLAY_MANAGER_VERSION;
+    params->storage_version = DISCORD_STORAGE_MANAGER_VERSION;
+    params->store_version = DISCORD_STORE_MANAGER_VERSION;
+    params->voice_version = DISCORD_VOICE_MANAGER_VERSION;
+    params->achievement_version = DISCORD_ACHIEVEMENT_MANAGER_VERSION;
+}
+
+enum EDiscordResult DiscordCreate(DiscordVersion version, struct DiscordCreateParams* params, struct IDiscordCore** result);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
\ No newline at end of file
diff --git a/engine/inc/discord/event.h b/engine/inc/discord/event.h
new file mode 100644
index 00000000..610887d1
--- /dev/null
+++ b/engine/inc/discord/event.h
@@ -0,0 +1,59 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+
+namespace discord {
+
+template <typename... Args>
+class Event final {
+public:
+    using Token = int;
+
+    Event() { slots_.reserve(4); }
+
+    Event(Event const&) = default;
+    Event(Event&&) = default;
+    ~Event() = default;
+
+    Event& operator=(Event const&) = default;
+    Event& operator=(Event&&) = default;
+
+    template <typename EventHandler>
+    Token Connect(EventHandler slot)
+    {
+        slots_.emplace_back(Slot{nextToken_, std::move(slot)});
+        return nextToken_++;
+    }
+
+    void Disconnect(Token token)
+    {
+        for (auto& slot : slots_) {
+            if (slot.token == token) {
+                slot = slots_.back();
+                slots_.pop_back();
+                break;
+            }
+        }
+    }
+
+    void DisconnectAll() { slots_ = {}; }
+
+    void operator()(Args... args)
+    {
+        for (auto const& slot : slots_) {
+            slot.fn(std::forward<Args>(args)...);
+        }
+    }
+
+private:
+    struct Slot {
+        Token token;
+        std::function<void(Args...)> fn;
+    };
+
+    Token nextToken_{};
+    std::vector<Slot> slots_{};
+};
+
+} // namespace discord
diff --git a/engine/inc/discord/ffi.h b/engine/inc/discord/ffi.h
new file mode 100644
index 00000000..8ce9403b
--- /dev/null
+++ b/engine/inc/discord/ffi.h
@@ -0,0 +1,942 @@
+#ifndef _DISCORD_GAME_SDK_H_
+#define _DISCORD_GAME_SDK_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <string.h>
+#ifndef __cplusplus
+#include <stdbool.h>
+#endif
+
+#define DISCORD_VERSION 2
+#define DISCORD_APPLICATION_MANAGER_VERSION 1
+#define DISCORD_USER_MANAGER_VERSION 1
+#define DISCORD_IMAGE_MANAGER_VERSION 1
+#define DISCORD_ACTIVITY_MANAGER_VERSION 1
+#define DISCORD_RELATIONSHIP_MANAGER_VERSION 1
+#define DISCORD_LOBBY_MANAGER_VERSION 1
+#define DISCORD_NETWORK_MANAGER_VERSION 1
+#define DISCORD_OVERLAY_MANAGER_VERSION 1
+#define DISCORD_STORAGE_MANAGER_VERSION 1
+#define DISCORD_STORE_MANAGER_VERSION 1
+#define DISCORD_VOICE_MANAGER_VERSION 1
+#define DISCORD_ACHIEVEMENT_MANAGER_VERSION 1
+
+enum EDiscordResult {
+    DiscordResult_Ok = 0,
+    DiscordResult_ServiceUnavailable = 1,
+    DiscordResult_InvalidVersion = 2,
+    DiscordResult_LockFailed = 3,
+    DiscordResult_InternalError = 4,
+    DiscordResult_InvalidPayload = 5,
+    DiscordResult_InvalidCommand = 6,
+    DiscordResult_InvalidPermissions = 7,
+    DiscordResult_NotFetched = 8,
+    DiscordResult_NotFound = 9,
+    DiscordResult_Conflict = 10,
+    DiscordResult_InvalidSecret = 11,
+    DiscordResult_InvalidJoinSecret = 12,
+    DiscordResult_NoEligibleActivity = 13,
+    DiscordResult_InvalidInvite = 14,
+    DiscordResult_NotAuthenticated = 15,
+    DiscordResult_InvalidAccessToken = 16,
+    DiscordResult_ApplicationMismatch = 17,
+    DiscordResult_InvalidDataUrl = 18,
+    DiscordResult_InvalidBase64 = 19,
+    DiscordResult_NotFiltered = 20,
+    DiscordResult_LobbyFull = 21,
+    DiscordResult_InvalidLobbySecret = 22,
+    DiscordResult_InvalidFilename = 23,
+    DiscordResult_InvalidFileSize = 24,
+    DiscordResult_InvalidEntitlement = 25,
+    DiscordResult_NotInstalled = 26,
+    DiscordResult_NotRunning = 27,
+    DiscordResult_InsufficientBuffer = 28,
+    DiscordResult_PurchaseCanceled = 29,
+    DiscordResult_InvalidGuild = 30,
+    DiscordResult_InvalidEvent = 31,
+    DiscordResult_InvalidChannel = 32,
+    DiscordResult_InvalidOrigin = 33,
+    DiscordResult_RateLimited = 34,
+    DiscordResult_OAuth2Error = 35,
+    DiscordResult_SelectChannelTimeout = 36,
+    DiscordResult_GetGuildTimeout = 37,
+    DiscordResult_SelectVoiceForceRequired = 38,
+    DiscordResult_CaptureShortcutAlreadyListening = 39,
+    DiscordResult_UnauthorizedForAchievement = 40,
+    DiscordResult_InvalidGiftCode = 41,
+    DiscordResult_PurchaseError = 42,
+    DiscordResult_TransactionAborted = 43,
+};
+
+enum EDiscordCreateFlags {
+    DiscordCreateFlags_Default = 0,
+    DiscordCreateFlags_NoRequireDiscord = 1,
+};
+
+enum EDiscordLogLevel {
+    DiscordLogLevel_Error = 1,
+    DiscordLogLevel_Warn,
+    DiscordLogLevel_Info,
+    DiscordLogLevel_Debug,
+};
+
+enum EDiscordUserFlag {
+    DiscordUserFlag_Partner = 2,
+    DiscordUserFlag_HypeSquadEvents = 4,
+    DiscordUserFlag_HypeSquadHouse1 = 64,
+    DiscordUserFlag_HypeSquadHouse2 = 128,
+    DiscordUserFlag_HypeSquadHouse3 = 256,
+};
+
+enum EDiscordPremiumType {
+    DiscordPremiumType_None = 0,
+    DiscordPremiumType_Tier1 = 1,
+    DiscordPremiumType_Tier2 = 2,
+};
+
+enum EDiscordImageType {
+    DiscordImageType_User,
+};
+
+enum EDiscordActivityType {
+    DiscordActivityType_Playing,
+    DiscordActivityType_Streaming,
+    DiscordActivityType_Listening,
+    DiscordActivityType_Watching,
+};
+
+enum EDiscordActivityActionType {
+    DiscordActivityActionType_Join = 1,
+    DiscordActivityActionType_Spectate,
+};
+
+enum EDiscordActivityJoinRequestReply {
+    DiscordActivityJoinRequestReply_No,
+    DiscordActivityJoinRequestReply_Yes,
+    DiscordActivityJoinRequestReply_Ignore,
+};
+
+enum EDiscordStatus {
+    DiscordStatus_Offline = 0,
+    DiscordStatus_Online = 1,
+    DiscordStatus_Idle = 2,
+    DiscordStatus_DoNotDisturb = 3,
+};
+
+enum EDiscordRelationshipType {
+    DiscordRelationshipType_None,
+    DiscordRelationshipType_Friend,
+    DiscordRelationshipType_Blocked,
+    DiscordRelationshipType_PendingIncoming,
+    DiscordRelationshipType_PendingOutgoing,
+    DiscordRelationshipType_Implicit,
+};
+
+enum EDiscordLobbyType {
+    DiscordLobbyType_Private = 1,
+    DiscordLobbyType_Public,
+};
+
+enum EDiscordLobbySearchComparison {
+    DiscordLobbySearchComparison_LessThanOrEqual = -2,
+    DiscordLobbySearchComparison_LessThan,
+    DiscordLobbySearchComparison_Equal,
+    DiscordLobbySearchComparison_GreaterThan,
+    DiscordLobbySearchComparison_GreaterThanOrEqual,
+    DiscordLobbySearchComparison_NotEqual,
+};
+
+enum EDiscordLobbySearchCast {
+    DiscordLobbySearchCast_String = 1,
+    DiscordLobbySearchCast_Number,
+};
+
+enum EDiscordLobbySearchDistance {
+    DiscordLobbySearchDistance_Local,
+    DiscordLobbySearchDistance_Default,
+    DiscordLobbySearchDistance_Extended,
+    DiscordLobbySearchDistance_Global,
+};
+
+enum EDiscordEntitlementType {
+    DiscordEntitlementType_Purchase = 1,
+    DiscordEntitlementType_PremiumSubscription,
+    DiscordEntitlementType_DeveloperGift,
+    DiscordEntitlementType_TestModePurchase,
+    DiscordEntitlementType_FreePurchase,
+    DiscordEntitlementType_UserGift,
+    DiscordEntitlementType_PremiumPurchase,
+};
+
+enum EDiscordSkuType {
+    DiscordSkuType_Application = 1,
+    DiscordSkuType_DLC,
+    DiscordSkuType_Consumable,
+    DiscordSkuType_Bundle,
+};
+
+enum EDiscordInputModeType {
+    DiscordInputModeType_VoiceActivity = 0,
+    DiscordInputModeType_PushToTalk,
+};
+
+typedef int64_t DiscordClientId;
+typedef int32_t DiscordVersion;
+typedef int64_t DiscordSnowflake;
+typedef int64_t DiscordTimestamp;
+typedef DiscordSnowflake DiscordUserId;
+typedef char DiscordLocale[128];
+typedef char DiscordBranch[4096];
+typedef DiscordSnowflake DiscordLobbyId;
+typedef char DiscordLobbySecret[128];
+typedef char DiscordMetadataKey[256];
+typedef char DiscordMetadataValue[4096];
+typedef uint64_t DiscordNetworkPeerId;
+typedef uint8_t DiscordNetworkChannelId;
+typedef char DiscordPath[4096];
+typedef char DiscordDateTime[64];
+
+struct DiscordUser {
+    DiscordUserId id;
+    char username[256];
+    char discriminator[8];
+    char avatar[128];
+    bool bot;
+};
+
+struct DiscordOAuth2Token {
+    char access_token[128];
+    char scopes[1024];
+    DiscordTimestamp expires;
+};
+
+struct DiscordImageHandle {
+    enum EDiscordImageType type;
+    int64_t id;
+    uint32_t size;
+};
+
+struct DiscordImageDimensions {
+    uint32_t width;
+    uint32_t height;
+};
+
+struct DiscordActivityTimestamps {
+    DiscordTimestamp start;
+    DiscordTimestamp end;
+};
+
+struct DiscordActivityAssets {
+    char large_image[128];
+    char large_text[128];
+    char small_image[128];
+    char small_text[128];
+};
+
+struct DiscordPartySize {
+    int32_t current_size;
+    int32_t max_size;
+};
+
+struct DiscordActivityParty {
+    char id[128];
+    struct DiscordPartySize size;
+};
+
+struct DiscordActivitySecrets {
+    char match[128];
+    char join[128];
+    char spectate[128];
+};
+
+struct DiscordActivity {
+    enum EDiscordActivityType type;
+    int64_t application_id;
+    char name[128];
+    char state[128];
+    char details[128];
+    struct DiscordActivityTimestamps timestamps;
+    struct DiscordActivityAssets assets;
+    struct DiscordActivityParty party;
+    struct DiscordActivitySecrets secrets;
+    bool instance;
+};
+
+struct DiscordPresence {
+    enum EDiscordStatus status;
+    struct DiscordActivity activity;
+};
+
+struct DiscordRelationship {
+    enum EDiscordRelationshipType type;
+    struct DiscordUser user;
+    struct DiscordPresence presence;
+};
+
+struct DiscordLobby {
+    DiscordLobbyId id;
+    enum EDiscordLobbyType type;
+    DiscordUserId owner_id;
+    DiscordLobbySecret secret;
+    uint32_t capacity;
+    bool locked;
+};
+
+struct DiscordFileStat {
+    char filename[260];
+    uint64_t size;
+    uint64_t last_modified;
+};
+
+struct DiscordEntitlement {
+    DiscordSnowflake id;
+    enum EDiscordEntitlementType type;
+    DiscordSnowflake sku_id;
+};
+
+struct DiscordSkuPrice {
+    uint32_t amount;
+    char currency[16];
+};
+
+struct DiscordSku {
+    DiscordSnowflake id;
+    enum EDiscordSkuType type;
+    char name[256];
+    struct DiscordSkuPrice price;
+};
+
+struct DiscordInputMode {
+    enum EDiscordInputModeType type;
+    char shortcut[256];
+};
+
+struct DiscordUserAchievement {
+    DiscordSnowflake user_id;
+    DiscordSnowflake achievement_id;
+    uint8_t percent_complete;
+    DiscordDateTime unlocked_at;
+};
+
+struct IDiscordLobbyTransaction {
+    enum EDiscordResult (*set_type)(struct IDiscordLobbyTransaction* lobby_transaction,
+                                    enum EDiscordLobbyType type);
+    enum EDiscordResult (*set_owner)(struct IDiscordLobbyTransaction* lobby_transaction,
+                                     DiscordUserId owner_id);
+    enum EDiscordResult (*set_capacity)(struct IDiscordLobbyTransaction* lobby_transaction,
+                                        uint32_t capacity);
+    enum EDiscordResult (*set_metadata)(struct IDiscordLobbyTransaction* lobby_transaction,
+                                        DiscordMetadataKey key,
+                                        DiscordMetadataValue value);
+    enum EDiscordResult (*delete_metadata)(struct IDiscordLobbyTransaction* lobby_transaction,
+                                           DiscordMetadataKey key);
+    enum EDiscordResult (*set_locked)(struct IDiscordLobbyTransaction* lobby_transaction,
+                                      bool locked);
+};
+
+struct IDiscordLobbyMemberTransaction {
+    enum EDiscordResult (*set_metadata)(
+      struct IDiscordLobbyMemberTransaction* lobby_member_transaction,
+      DiscordMetadataKey key,
+      DiscordMetadataValue value);
+    enum EDiscordResult (*delete_metadata)(
+      struct IDiscordLobbyMemberTransaction* lobby_member_transaction,
+      DiscordMetadataKey key);
+};
+
+struct IDiscordLobbySearchQuery {
+    enum EDiscordResult (*filter)(struct IDiscordLobbySearchQuery* lobby_search_query,
+                                  DiscordMetadataKey key,
+                                  enum EDiscordLobbySearchComparison comparison,
+                                  enum EDiscordLobbySearchCast cast,
+                                  DiscordMetadataValue value);
+    enum EDiscordResult (*sort)(struct IDiscordLobbySearchQuery* lobby_search_query,
+                                DiscordMetadataKey key,
+                                enum EDiscordLobbySearchCast cast,
+                                DiscordMetadataValue value);
+    enum EDiscordResult (*limit)(struct IDiscordLobbySearchQuery* lobby_search_query,
+                                 uint32_t limit);
+    enum EDiscordResult (*distance)(struct IDiscordLobbySearchQuery* lobby_search_query,
+                                    enum EDiscordLobbySearchDistance distance);
+};
+
+typedef void* IDiscordApplicationEvents;
+
+struct IDiscordApplicationManager {
+    void (*validate_or_exit)(struct IDiscordApplicationManager* manager,
+                             void* callback_data,
+                             void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*get_current_locale)(struct IDiscordApplicationManager* manager, DiscordLocale* locale);
+    void (*get_current_branch)(struct IDiscordApplicationManager* manager, DiscordBranch* branch);
+    void (*get_oauth2_token)(struct IDiscordApplicationManager* manager,
+                             void* callback_data,
+                             void (*callback)(void* callback_data,
+                                              enum EDiscordResult result,
+                                              struct DiscordOAuth2Token* oauth2_token));
+    void (*get_ticket)(struct IDiscordApplicationManager* manager,
+                       void* callback_data,
+                       void (*callback)(void* callback_data,
+                                        enum EDiscordResult result,
+                                        const char* data));
+};
+
+struct IDiscordUserEvents {
+    void (*on_current_user_update)(void* event_data);
+};
+
+struct IDiscordUserManager {
+    enum EDiscordResult (*get_current_user)(struct IDiscordUserManager* manager,
+                                            struct DiscordUser* current_user);
+    void (*get_user)(struct IDiscordUserManager* manager,
+                     DiscordUserId user_id,
+                     void* callback_data,
+                     void (*callback)(void* callback_data,
+                                      enum EDiscordResult result,
+                                      struct DiscordUser* user));
+    enum EDiscordResult (*get_current_user_premium_type)(struct IDiscordUserManager* manager,
+                                                         enum EDiscordPremiumType* premium_type);
+    enum EDiscordResult (*current_user_has_flag)(struct IDiscordUserManager* manager,
+                                                 enum EDiscordUserFlag flag,
+                                                 bool* has_flag);
+};
+
+typedef void* IDiscordImageEvents;
+
+struct IDiscordImageManager {
+    void (*fetch)(struct IDiscordImageManager* manager,
+                  struct DiscordImageHandle handle,
+                  bool refresh,
+                  void* callback_data,
+                  void (*callback)(void* callback_data,
+                                   enum EDiscordResult result,
+                                   struct DiscordImageHandle handle_result));
+    enum EDiscordResult (*get_dimensions)(struct IDiscordImageManager* manager,
+                                          struct DiscordImageHandle handle,
+                                          struct DiscordImageDimensions* dimensions);
+    enum EDiscordResult (*get_data)(struct IDiscordImageManager* manager,
+                                    struct DiscordImageHandle handle,
+                                    uint8_t* data,
+                                    uint32_t data_length);
+};
+
+struct IDiscordActivityEvents {
+    void (*on_activity_join)(void* event_data, const char* secret);
+    void (*on_activity_spectate)(void* event_data, const char* secret);
+    void (*on_activity_join_request)(void* event_data, struct DiscordUser* user);
+    void (*on_activity_invite)(void* event_data,
+                               enum EDiscordActivityActionType type,
+                               struct DiscordUser* user,
+                               struct DiscordActivity* activity);
+};
+
+struct IDiscordActivityManager {
+    enum EDiscordResult (*register_command)(struct IDiscordActivityManager* manager,
+                                            const char* command);
+    enum EDiscordResult (*register_steam)(struct IDiscordActivityManager* manager,
+                                          uint32_t steam_id);
+    void (*update_activity)(struct IDiscordActivityManager* manager,
+                            struct DiscordActivity* activity,
+                            void* callback_data,
+                            void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*clear_activity)(struct IDiscordActivityManager* manager,
+                           void* callback_data,
+                           void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*send_request_reply)(struct IDiscordActivityManager* manager,
+                               DiscordUserId user_id,
+                               enum EDiscordActivityJoinRequestReply reply,
+                               void* callback_data,
+                               void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*send_invite)(struct IDiscordActivityManager* manager,
+                        DiscordUserId user_id,
+                        enum EDiscordActivityActionType type,
+                        const char* content,
+                        void* callback_data,
+                        void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*accept_invite)(struct IDiscordActivityManager* manager,
+                          DiscordUserId user_id,
+                          void* callback_data,
+                          void (*callback)(void* callback_data, enum EDiscordResult result));
+};
+
+struct IDiscordRelationshipEvents {
+    void (*on_refresh)(void* event_data);
+    void (*on_relationship_update)(void* event_data, struct DiscordRelationship* relationship);
+};
+
+struct IDiscordRelationshipManager {
+    void (*filter)(struct IDiscordRelationshipManager* manager,
+                   void* filter_data,
+                   bool (*filter)(void* filter_data, struct DiscordRelationship* relationship));
+    enum EDiscordResult (*count)(struct IDiscordRelationshipManager* manager, int32_t* count);
+    enum EDiscordResult (*get)(struct IDiscordRelationshipManager* manager,
+                               DiscordUserId user_id,
+                               struct DiscordRelationship* relationship);
+    enum EDiscordResult (*get_at)(struct IDiscordRelationshipManager* manager,
+                                  uint32_t index,
+                                  struct DiscordRelationship* relationship);
+};
+
+struct IDiscordLobbyEvents {
+    void (*on_lobby_update)(void* event_data, int64_t lobby_id);
+    void (*on_lobby_delete)(void* event_data, int64_t lobby_id, uint32_t reason);
+    void (*on_member_connect)(void* event_data, int64_t lobby_id, int64_t user_id);
+    void (*on_member_update)(void* event_data, int64_t lobby_id, int64_t user_id);
+    void (*on_member_disconnect)(void* event_data, int64_t lobby_id, int64_t user_id);
+    void (*on_lobby_message)(void* event_data,
+                             int64_t lobby_id,
+                             int64_t user_id,
+                             uint8_t* data,
+                             uint32_t data_length);
+    void (*on_speaking)(void* event_data, int64_t lobby_id, int64_t user_id, bool speaking);
+    void (*on_network_message)(void* event_data,
+                               int64_t lobby_id,
+                               int64_t user_id,
+                               uint8_t channel_id,
+                               uint8_t* data,
+                               uint32_t data_length);
+};
+
+struct IDiscordLobbyManager {
+    enum EDiscordResult (*get_lobby_create_transaction)(
+      struct IDiscordLobbyManager* manager,
+      struct IDiscordLobbyTransaction** transaction);
+    enum EDiscordResult (*get_lobby_update_transaction)(
+      struct IDiscordLobbyManager* manager,
+      DiscordLobbyId lobby_id,
+      struct IDiscordLobbyTransaction** transaction);
+    enum EDiscordResult (*get_member_update_transaction)(
+      struct IDiscordLobbyManager* manager,
+      DiscordLobbyId lobby_id,
+      DiscordUserId user_id,
+      struct IDiscordLobbyMemberTransaction** transaction);
+    void (*create_lobby)(struct IDiscordLobbyManager* manager,
+                         struct IDiscordLobbyTransaction* transaction,
+                         void* callback_data,
+                         void (*callback)(void* callback_data,
+                                          enum EDiscordResult result,
+                                          struct DiscordLobby* lobby));
+    void (*update_lobby)(struct IDiscordLobbyManager* manager,
+                         DiscordLobbyId lobby_id,
+                         struct IDiscordLobbyTransaction* transaction,
+                         void* callback_data,
+                         void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*delete_lobby)(struct IDiscordLobbyManager* manager,
+                         DiscordLobbyId lobby_id,
+                         void* callback_data,
+                         void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*connect_lobby)(struct IDiscordLobbyManager* manager,
+                          DiscordLobbyId lobby_id,
+                          DiscordLobbySecret secret,
+                          void* callback_data,
+                          void (*callback)(void* callback_data,
+                                           enum EDiscordResult result,
+                                           struct DiscordLobby* lobby));
+    void (*connect_lobby_with_activity_secret)(struct IDiscordLobbyManager* manager,
+                                               DiscordLobbySecret activity_secret,
+                                               void* callback_data,
+                                               void (*callback)(void* callback_data,
+                                                                enum EDiscordResult result,
+                                                                struct DiscordLobby* lobby));
+    void (*disconnect_lobby)(struct IDiscordLobbyManager* manager,
+                             DiscordLobbyId lobby_id,
+                             void* callback_data,
+                             void (*callback)(void* callback_data, enum EDiscordResult result));
+    enum EDiscordResult (*get_lobby)(struct IDiscordLobbyManager* manager,
+                                     DiscordLobbyId lobby_id,
+                                     struct DiscordLobby* lobby);
+    enum EDiscordResult (*get_lobby_activity_secret)(struct IDiscordLobbyManager* manager,
+                                                     DiscordLobbyId lobby_id,
+                                                     DiscordLobbySecret* secret);
+    enum EDiscordResult (*get_lobby_metadata_value)(struct IDiscordLobbyManager* manager,
+                                                    DiscordLobbyId lobby_id,
+                                                    DiscordMetadataKey key,
+                                                    DiscordMetadataValue* value);
+    enum EDiscordResult (*get_lobby_metadata_key)(struct IDiscordLobbyManager* manager,
+                                                  DiscordLobbyId lobby_id,
+                                                  int32_t index,
+                                                  DiscordMetadataKey* key);
+    enum EDiscordResult (*lobby_metadata_count)(struct IDiscordLobbyManager* manager,
+                                                DiscordLobbyId lobby_id,
+                                                int32_t* count);
+    enum EDiscordResult (*member_count)(struct IDiscordLobbyManager* manager,
+                                        DiscordLobbyId lobby_id,
+                                        int32_t* count);
+    enum EDiscordResult (*get_member_user_id)(struct IDiscordLobbyManager* manager,
+                                              DiscordLobbyId lobby_id,
+                                              int32_t index,
+                                              DiscordUserId* user_id);
+    enum EDiscordResult (*get_member_user)(struct IDiscordLobbyManager* manager,
+                                           DiscordLobbyId lobby_id,
+                                           DiscordUserId user_id,
+                                           struct DiscordUser* user);
+    enum EDiscordResult (*get_member_metadata_value)(struct IDiscordLobbyManager* manager,
+                                                     DiscordLobbyId lobby_id,
+                                                     DiscordUserId user_id,
+                                                     DiscordMetadataKey key,
+                                                     DiscordMetadataValue* value);
+    enum EDiscordResult (*get_member_metadata_key)(struct IDiscordLobbyManager* manager,
+                                                   DiscordLobbyId lobby_id,
+                                                   DiscordUserId user_id,
+                                                   int32_t index,
+                                                   DiscordMetadataKey* key);
+    enum EDiscordResult (*member_metadata_count)(struct IDiscordLobbyManager* manager,
+                                                 DiscordLobbyId lobby_id,
+                                                 DiscordUserId user_id,
+                                                 int32_t* count);
+    void (*update_member)(struct IDiscordLobbyManager* manager,
+                          DiscordLobbyId lobby_id,
+                          DiscordUserId user_id,
+                          struct IDiscordLobbyMemberTransaction* transaction,
+                          void* callback_data,
+                          void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*send_lobby_message)(struct IDiscordLobbyManager* manager,
+                               DiscordLobbyId lobby_id,
+                               uint8_t* data,
+                               uint32_t data_length,
+                               void* callback_data,
+                               void (*callback)(void* callback_data, enum EDiscordResult result));
+    enum EDiscordResult (*get_search_query)(struct IDiscordLobbyManager* manager,
+                                            struct IDiscordLobbySearchQuery** query);
+    void (*search)(struct IDiscordLobbyManager* manager,
+                   struct IDiscordLobbySearchQuery* query,
+                   void* callback_data,
+                   void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*lobby_count)(struct IDiscordLobbyManager* manager, int32_t* count);
+    enum EDiscordResult (*get_lobby_id)(struct IDiscordLobbyManager* manager,
+                                        int32_t index,
+                                        DiscordLobbyId* lobby_id);
+    void (*connect_voice)(struct IDiscordLobbyManager* manager,
+                          DiscordLobbyId lobby_id,
+                          void* callback_data,
+                          void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*disconnect_voice)(struct IDiscordLobbyManager* manager,
+                             DiscordLobbyId lobby_id,
+                             void* callback_data,
+                             void (*callback)(void* callback_data, enum EDiscordResult result));
+    enum EDiscordResult (*connect_network)(struct IDiscordLobbyManager* manager,
+                                           DiscordLobbyId lobby_id);
+    enum EDiscordResult (*disconnect_network)(struct IDiscordLobbyManager* manager,
+                                              DiscordLobbyId lobby_id);
+    enum EDiscordResult (*flush_network)(struct IDiscordLobbyManager* manager);
+    enum EDiscordResult (*open_network_channel)(struct IDiscordLobbyManager* manager,
+                                                DiscordLobbyId lobby_id,
+                                                uint8_t channel_id,
+                                                bool reliable);
+    enum EDiscordResult (*send_network_message)(struct IDiscordLobbyManager* manager,
+                                                DiscordLobbyId lobby_id,
+                                                DiscordUserId user_id,
+                                                uint8_t channel_id,
+                                                uint8_t* data,
+                                                uint32_t data_length);
+};
+
+struct IDiscordNetworkEvents {
+    void (*on_message)(void* event_data,
+                       DiscordNetworkPeerId peer_id,
+                       DiscordNetworkChannelId channel_id,
+                       uint8_t* data,
+                       uint32_t data_length);
+    void (*on_route_update)(void* event_data, const char* route_data);
+};
+
+struct IDiscordNetworkManager {
+    /**
+     * Get the local peer ID for this process.
+     */
+    void (*get_peer_id)(struct IDiscordNetworkManager* manager, DiscordNetworkPeerId* peer_id);
+    /**
+     * Send pending network messages.
+     */
+    enum EDiscordResult (*flush)(struct IDiscordNetworkManager* manager);
+    /**
+     * Open a connection to a remote peer.
+     */
+    enum EDiscordResult (*open_peer)(struct IDiscordNetworkManager* manager,
+                                     DiscordNetworkPeerId peer_id,
+                                     const char* route_data);
+    /**
+     * Update the route data for a connected peer.
+     */
+    enum EDiscordResult (*update_peer)(struct IDiscordNetworkManager* manager,
+                                       DiscordNetworkPeerId peer_id,
+                                       const char* route_data);
+    /**
+     * Close the connection to a remote peer.
+     */
+    enum EDiscordResult (*close_peer)(struct IDiscordNetworkManager* manager,
+                                      DiscordNetworkPeerId peer_id);
+    /**
+     * Open a message channel to a connected peer.
+     */
+    enum EDiscordResult (*open_channel)(struct IDiscordNetworkManager* manager,
+                                        DiscordNetworkPeerId peer_id,
+                                        DiscordNetworkChannelId channel_id,
+                                        bool reliable);
+    /**
+     * Close a message channel to a connected peer.
+     */
+    enum EDiscordResult (*close_channel)(struct IDiscordNetworkManager* manager,
+                                         DiscordNetworkPeerId peer_id,
+                                         DiscordNetworkChannelId channel_id);
+    /**
+     * Send a message to a connected peer over an opened message channel.
+     */
+    enum EDiscordResult (*send_message)(struct IDiscordNetworkManager* manager,
+                                        DiscordNetworkPeerId peer_id,
+                                        DiscordNetworkChannelId channel_id,
+                                        uint8_t* data,
+                                        uint32_t data_length);
+};
+
+struct IDiscordOverlayEvents {
+    void (*on_toggle)(void* event_data, bool locked);
+};
+
+struct IDiscordOverlayManager {
+    void (*is_enabled)(struct IDiscordOverlayManager* manager, bool* enabled);
+    void (*is_locked)(struct IDiscordOverlayManager* manager, bool* locked);
+    void (*set_locked)(struct IDiscordOverlayManager* manager,
+                       bool locked,
+                       void* callback_data,
+                       void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*open_activity_invite)(struct IDiscordOverlayManager* manager,
+                                 enum EDiscordActivityActionType type,
+                                 void* callback_data,
+                                 void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*open_guild_invite)(struct IDiscordOverlayManager* manager,
+                              const char* code,
+                              void* callback_data,
+                              void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*open_voice_settings)(struct IDiscordOverlayManager* manager,
+                                void* callback_data,
+                                void (*callback)(void* callback_data, enum EDiscordResult result));
+};
+
+typedef void* IDiscordStorageEvents;
+
+struct IDiscordStorageManager {
+    enum EDiscordResult (*read)(struct IDiscordStorageManager* manager,
+                                const char* name,
+                                uint8_t* data,
+                                uint32_t data_length,
+                                uint32_t* read);
+    void (*read_async)(struct IDiscordStorageManager* manager,
+                       const char* name,
+                       void* callback_data,
+                       void (*callback)(void* callback_data,
+                                        enum EDiscordResult result,
+                                        uint8_t* data,
+                                        uint32_t data_length));
+    void (*read_async_partial)(struct IDiscordStorageManager* manager,
+                               const char* name,
+                               uint64_t offset,
+                               uint64_t length,
+                               void* callback_data,
+                               void (*callback)(void* callback_data,
+                                                enum EDiscordResult result,
+                                                uint8_t* data,
+                                                uint32_t data_length));
+    enum EDiscordResult (*write)(struct IDiscordStorageManager* manager,
+                                 const char* name,
+                                 uint8_t* data,
+                                 uint32_t data_length);
+    void (*write_async)(struct IDiscordStorageManager* manager,
+                        const char* name,
+                        uint8_t* data,
+                        uint32_t data_length,
+                        void* callback_data,
+                        void (*callback)(void* callback_data, enum EDiscordResult result));
+    enum EDiscordResult (*delete_)(struct IDiscordStorageManager* manager, const char* name);
+    enum EDiscordResult (*exists)(struct IDiscordStorageManager* manager,
+                                  const char* name,
+                                  bool* exists);
+    void (*count)(struct IDiscordStorageManager* manager, int32_t* count);
+    enum EDiscordResult (*stat)(struct IDiscordStorageManager* manager,
+                                const char* name,
+                                struct DiscordFileStat* stat);
+    enum EDiscordResult (*stat_at)(struct IDiscordStorageManager* manager,
+                                   int32_t index,
+                                   struct DiscordFileStat* stat);
+    enum EDiscordResult (*get_path)(struct IDiscordStorageManager* manager, DiscordPath* path);
+};
+
+struct IDiscordStoreEvents {
+    void (*on_entitlement_create)(void* event_data, struct DiscordEntitlement* entitlement);
+    void (*on_entitlement_delete)(void* event_data, struct DiscordEntitlement* entitlement);
+};
+
+struct IDiscordStoreManager {
+    void (*fetch_skus)(struct IDiscordStoreManager* manager,
+                       void* callback_data,
+                       void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*count_skus)(struct IDiscordStoreManager* manager, int32_t* count);
+    enum EDiscordResult (*get_sku)(struct IDiscordStoreManager* manager,
+                                   DiscordSnowflake sku_id,
+                                   struct DiscordSku* sku);
+    enum EDiscordResult (*get_sku_at)(struct IDiscordStoreManager* manager,
+                                      int32_t index,
+                                      struct DiscordSku* sku);
+    void (*fetch_entitlements)(struct IDiscordStoreManager* manager,
+                               void* callback_data,
+                               void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*count_entitlements)(struct IDiscordStoreManager* manager, int32_t* count);
+    enum EDiscordResult (*get_entitlement)(struct IDiscordStoreManager* manager,
+                                           DiscordSnowflake entitlement_id,
+                                           struct DiscordEntitlement* entitlement);
+    enum EDiscordResult (*get_entitlement_at)(struct IDiscordStoreManager* manager,
+                                              int32_t index,
+                                              struct DiscordEntitlement* entitlement);
+    enum EDiscordResult (*has_sku_entitlement)(struct IDiscordStoreManager* manager,
+                                               DiscordSnowflake sku_id,
+                                               bool* has_entitlement);
+    void (*start_purchase)(struct IDiscordStoreManager* manager,
+                           DiscordSnowflake sku_id,
+                           void* callback_data,
+                           void (*callback)(void* callback_data, enum EDiscordResult result));
+};
+
+struct IDiscordVoiceEvents {
+    void (*on_settings_update)(void* event_data);
+};
+
+struct IDiscordVoiceManager {
+    enum EDiscordResult (*get_input_mode)(struct IDiscordVoiceManager* manager,
+                                          struct DiscordInputMode* input_mode);
+    void (*set_input_mode)(struct IDiscordVoiceManager* manager,
+                           struct DiscordInputMode input_mode,
+                           void* callback_data,
+                           void (*callback)(void* callback_data, enum EDiscordResult result));
+    enum EDiscordResult (*is_self_mute)(struct IDiscordVoiceManager* manager, bool* mute);
+    enum EDiscordResult (*set_self_mute)(struct IDiscordVoiceManager* manager, bool mute);
+    enum EDiscordResult (*is_self_deaf)(struct IDiscordVoiceManager* manager, bool* deaf);
+    enum EDiscordResult (*set_self_deaf)(struct IDiscordVoiceManager* manager, bool deaf);
+    enum EDiscordResult (*is_local_mute)(struct IDiscordVoiceManager* manager,
+                                         DiscordSnowflake user_id,
+                                         bool* mute);
+    enum EDiscordResult (*set_local_mute)(struct IDiscordVoiceManager* manager,
+                                          DiscordSnowflake user_id,
+                                          bool mute);
+    enum EDiscordResult (*get_local_volume)(struct IDiscordVoiceManager* manager,
+                                            DiscordSnowflake user_id,
+                                            uint8_t* volume);
+    enum EDiscordResult (*set_local_volume)(struct IDiscordVoiceManager* manager,
+                                            DiscordSnowflake user_id,
+                                            uint8_t volume);
+};
+
+struct IDiscordAchievementEvents {
+    void (*on_user_achievement_update)(void* event_data,
+                                       struct DiscordUserAchievement* user_achievement);
+};
+
+struct IDiscordAchievementManager {
+    void (*set_user_achievement)(struct IDiscordAchievementManager* manager,
+                                 DiscordSnowflake achievement_id,
+                                 int64_t percent_complete,
+                                 void* callback_data,
+                                 void (*callback)(void* callback_data, enum EDiscordResult result));
+    void (*fetch_user_achievements)(struct IDiscordAchievementManager* manager,
+                                    void* callback_data,
+                                    void (*callback)(void* callback_data,
+                                                     enum EDiscordResult result));
+    void (*count_user_achievements)(struct IDiscordAchievementManager* manager, int32_t* count);
+    enum EDiscordResult (*get_user_achievement)(struct IDiscordAchievementManager* manager,
+                                                DiscordSnowflake user_achievement_id,
+                                                struct DiscordUserAchievement* user_achievement);
+    enum EDiscordResult (*get_user_achievement_at)(struct IDiscordAchievementManager* manager,
+                                                   int32_t index,
+                                                   struct DiscordUserAchievement* user_achievement);
+};
+
+typedef void* IDiscordCoreEvents;
+
+struct IDiscordCore {
+    void (*destroy)(struct IDiscordCore* core);
+    enum EDiscordResult (*run_callbacks)(struct IDiscordCore* core);
+    void (*set_log_hook)(struct IDiscordCore* core,
+                         enum EDiscordLogLevel min_level,
+                         void* hook_data,
+                         void (*hook)(void* hook_data,
+                                      enum EDiscordLogLevel level,
+                                      const char* message));
+    struct IDiscordApplicationManager* (*get_application_manager)(struct IDiscordCore* core);
+    struct IDiscordUserManager* (*get_user_manager)(struct IDiscordCore* core);
+    struct IDiscordImageManager* (*get_image_manager)(struct IDiscordCore* core);
+    struct IDiscordActivityManager* (*get_activity_manager)(struct IDiscordCore* core);
+    struct IDiscordRelationshipManager* (*get_relationship_manager)(struct IDiscordCore* core);
+    struct IDiscordLobbyManager* (*get_lobby_manager)(struct IDiscordCore* core);
+    struct IDiscordNetworkManager* (*get_network_manager)(struct IDiscordCore* core);
+    struct IDiscordOverlayManager* (*get_overlay_manager)(struct IDiscordCore* core);
+    struct IDiscordStorageManager* (*get_storage_manager)(struct IDiscordCore* core);
+    struct IDiscordStoreManager* (*get_store_manager)(struct IDiscordCore* core);
+    struct IDiscordVoiceManager* (*get_voice_manager)(struct IDiscordCore* core);
+    struct IDiscordAchievementManager* (*get_achievement_manager)(struct IDiscordCore* core);
+};
+
+struct DiscordCreateParams {
+    DiscordClientId client_id;
+    uint64_t flags;
+    IDiscordCoreEvents* events;
+    void* event_data;
+    IDiscordApplicationEvents* application_events;
+    DiscordVersion application_version;
+    struct IDiscordUserEvents* user_events;
+    DiscordVersion user_version;
+    IDiscordImageEvents* image_events;
+    DiscordVersion image_version;
+    struct IDiscordActivityEvents* activity_events;
+    DiscordVersion activity_version;
+    struct IDiscordRelationshipEvents* relationship_events;
+    DiscordVersion relationship_version;
+    struct IDiscordLobbyEvents* lobby_events;
+    DiscordVersion lobby_version;
+    struct IDiscordNetworkEvents* network_events;
+    DiscordVersion network_version;
+    struct IDiscordOverlayEvents* overlay_events;
+    DiscordVersion overlay_version;
+    IDiscordStorageEvents* storage_events;
+    DiscordVersion storage_version;
+    struct IDiscordStoreEvents* store_events;
+    DiscordVersion store_version;
+    struct IDiscordVoiceEvents* voice_events;
+    DiscordVersion voice_version;
+    struct IDiscordAchievementEvents* achievement_events;
+    DiscordVersion achievement_version;
+};
+
+#ifdef __cplusplus
+inline
+#else
+static
+#endif
+  void
+  DiscordCreateParamsSetDefault(struct DiscordCreateParams* params)
+{
+    memset(params, 0, sizeof(struct DiscordCreateParams));
+    params->application_version = DISCORD_APPLICATION_MANAGER_VERSION;
+    params->user_version = DISCORD_USER_MANAGER_VERSION;
+    params->image_version = DISCORD_IMAGE_MANAGER_VERSION;
+    params->activity_version = DISCORD_ACTIVITY_MANAGER_VERSION;
+    params->relationship_version = DISCORD_RELATIONSHIP_MANAGER_VERSION;
+    params->lobby_version = DISCORD_LOBBY_MANAGER_VERSION;
+    params->network_version = DISCORD_NETWORK_MANAGER_VERSION;
+    params->overlay_version = DISCORD_OVERLAY_MANAGER_VERSION;
+    params->storage_version = DISCORD_STORAGE_MANAGER_VERSION;
+    params->store_version = DISCORD_STORE_MANAGER_VERSION;
+    params->voice_version = DISCORD_VOICE_MANAGER_VERSION;
+    params->achievement_version = DISCORD_ACHIEVEMENT_MANAGER_VERSION;
+}
+
+enum EDiscordResult DiscordCreate(DiscordVersion version,
+                                  struct DiscordCreateParams* params,
+                                  struct IDiscordCore** result);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
\ No newline at end of file
diff --git a/engine/inc/discord/image_manager.h b/engine/inc/discord/image_manager.h
new file mode 100644
index 00000000..b096b171
--- /dev/null
+++ b/engine/inc/discord/image_manager.h
@@ -0,0 +1,28 @@
+#pragma once
+
+#include "types.h"
+
+namespace discord {
+
+class ImageManager final {
+public:
+    ~ImageManager() = default;
+
+    void Fetch(ImageHandle handle, bool refresh, std::function<void(Result, ImageHandle)> callback);
+    Result GetDimensions(ImageHandle handle, ImageDimensions* dimensions);
+    Result GetData(ImageHandle handle, std::uint8_t* data, std::uint32_t dataLength);
+
+private:
+    friend class Core;
+
+    ImageManager() = default;
+    ImageManager(ImageManager const& rhs) = delete;
+    ImageManager& operator=(ImageManager const& rhs) = delete;
+    ImageManager(ImageManager&& rhs) = delete;
+    ImageManager& operator=(ImageManager&& rhs) = delete;
+
+    IDiscordImageManager* internal_;
+    static IDiscordImageEvents events_;
+};
+
+} // namespace discord
diff --git a/engine/inc/discord/lobby_manager.h b/engine/inc/discord/lobby_manager.h
new file mode 100644
index 00000000..96380cbf
--- /dev/null
+++ b/engine/inc/discord/lobby_manager.h
@@ -0,0 +1,88 @@
+#pragma once
+
+#include "types.h"
+
+namespace discord {
+
+class LobbyManager final {
+public:
+    ~LobbyManager() = default;
+
+    Result GetLobbyCreateTransaction(LobbyTransaction* transaction);
+    Result GetLobbyUpdateTransaction(LobbyId lobbyId, LobbyTransaction* transaction);
+    Result GetMemberUpdateTransaction(LobbyId lobbyId,
+                                      UserId userId,
+                                      LobbyMemberTransaction* transaction);
+    void CreateLobby(LobbyTransaction const& transaction,
+                     std::function<void(Result, Lobby const&)> callback);
+    void UpdateLobby(LobbyId lobbyId,
+                     LobbyTransaction const& transaction,
+                     std::function<void(Result)> callback);
+    void DeleteLobby(LobbyId lobbyId, std::function<void(Result)> callback);
+    void ConnectLobby(LobbyId lobbyId,
+                      LobbySecret secret,
+                      std::function<void(Result, Lobby const&)> callback);
+    void ConnectLobbyWithActivitySecret(LobbySecret activitySecret,
+                                        std::function<void(Result, Lobby const&)> callback);
+    void DisconnectLobby(LobbyId lobbyId, std::function<void(Result)> callback);
+    Result GetLobby(LobbyId lobbyId, Lobby* lobby);
+    Result GetLobbyActivitySecret(LobbyId lobbyId, char secret[128]);
+    Result GetLobbyMetadataValue(LobbyId lobbyId, MetadataKey key, char value[4096]);
+    Result GetLobbyMetadataKey(LobbyId lobbyId, std::int32_t index, char key[256]);
+    Result LobbyMetadataCount(LobbyId lobbyId, std::int32_t* count);
+    Result MemberCount(LobbyId lobbyId, std::int32_t* count);
+    Result GetMemberUserId(LobbyId lobbyId, std::int32_t index, UserId* userId);
+    Result GetMemberUser(LobbyId lobbyId, UserId userId, User* user);
+    Result GetMemberMetadataValue(LobbyId lobbyId,
+                                  UserId userId,
+                                  MetadataKey key,
+                                  char value[4096]);
+    Result GetMemberMetadataKey(LobbyId lobbyId, UserId userId, std::int32_t index, char key[256]);
+    Result MemberMetadataCount(LobbyId lobbyId, UserId userId, std::int32_t* count);
+    void UpdateMember(LobbyId lobbyId,
+                      UserId userId,
+                      LobbyMemberTransaction const& transaction,
+                      std::function<void(Result)> callback);
+    void SendLobbyMessage(LobbyId lobbyId,
+                          std::uint8_t* data,
+                          std::uint32_t dataLength,
+                          std::function<void(Result)> callback);
+    Result GetSearchQuery(LobbySearchQuery* query);
+    void Search(LobbySearchQuery const& query, std::function<void(Result)> callback);
+    void LobbyCount(std::int32_t* count);
+    Result GetLobbyId(std::int32_t index, LobbyId* lobbyId);
+    void ConnectVoice(LobbyId lobbyId, std::function<void(Result)> callback);
+    void DisconnectVoice(LobbyId lobbyId, std::function<void(Result)> callback);
+    Result ConnectNetwork(LobbyId lobbyId);
+    Result DisconnectNetwork(LobbyId lobbyId);
+    Result FlushNetwork();
+    Result OpenNetworkChannel(LobbyId lobbyId, std::uint8_t channelId, bool reliable);
+    Result SendNetworkMessage(LobbyId lobbyId,
+                              UserId userId,
+                              std::uint8_t channelId,
+                              std::uint8_t* data,
+                              std::uint32_t dataLength);
+
+    Event<std::int64_t> OnLobbyUpdate;
+    Event<std::int64_t, std::uint32_t> OnLobbyDelete;
+    Event<std::int64_t, std::int64_t> OnMemberConnect;
+    Event<std::int64_t, std::int64_t> OnMemberUpdate;
+    Event<std::int64_t, std::int64_t> OnMemberDisconnect;
+    Event<std::int64_t, std::int64_t, std::uint8_t*, std::uint32_t> OnLobbyMessage;
+    Event<std::int64_t, std::int64_t, bool> OnSpeaking;
+    Event<std::int64_t, std::int64_t, std::uint8_t, std::uint8_t*, std::uint32_t> OnNetworkMessage;
+
+private:
+    friend class Core;
+
+    LobbyManager() = default;
+    LobbyManager(LobbyManager const& rhs) = delete;
+    LobbyManager& operator=(LobbyManager const& rhs) = delete;
+    LobbyManager(LobbyManager&& rhs) = delete;
+    LobbyManager& operator=(LobbyManager&& rhs) = delete;
+
+    IDiscordLobbyManager* internal_;
+    static IDiscordLobbyEvents events_;
+};
+
+} // namespace discord
diff --git a/engine/inc/discord/network_manager.h b/engine/inc/discord/network_manager.h
new file mode 100644
index 00000000..e374670a
--- /dev/null
+++ b/engine/inc/discord/network_manager.h
@@ -0,0 +1,63 @@
+#pragma once
+
+#include "types.h"
+
+namespace discord {
+
+class NetworkManager final {
+public:
+    ~NetworkManager() = default;
+
+    /**
+     * Get the local peer ID for this process.
+     */
+    void GetPeerId(NetworkPeerId* peerId);
+    /**
+     * Send pending network messages.
+     */
+    Result Flush();
+    /**
+     * Open a connection to a remote peer.
+     */
+    Result OpenPeer(NetworkPeerId peerId, char const* routeData);
+    /**
+     * Update the route data for a connected peer.
+     */
+    Result UpdatePeer(NetworkPeerId peerId, char const* routeData);
+    /**
+     * Close the connection to a remote peer.
+     */
+    Result ClosePeer(NetworkPeerId peerId);
+    /**
+     * Open a message channel to a connected peer.
+     */
+    Result OpenChannel(NetworkPeerId peerId, NetworkChannelId channelId, bool reliable);
+    /**
+     * Close a message channel to a connected peer.
+     */
+    Result CloseChannel(NetworkPeerId peerId, NetworkChannelId channelId);
+    /**
+     * Send a message to a connected peer over an opened message channel.
+     */
+    Result SendMessage(NetworkPeerId peerId,
+                       NetworkChannelId channelId,
+                       std::uint8_t* data,
+                       std::uint32_t dataLength);
+
+    Event<NetworkPeerId, NetworkChannelId, std::uint8_t*, std::uint32_t> OnMessage;
+    Event<char const*> OnRouteUpdate;
+
+private:
+    friend class Core;
+
+    NetworkManager() = default;
+    NetworkManager(NetworkManager const& rhs) = delete;
+    NetworkManager& operator=(NetworkManager const& rhs) = delete;
+    NetworkManager(NetworkManager&& rhs) = delete;
+    NetworkManager& operator=(NetworkManager&& rhs) = delete;
+
+    IDiscordNetworkManager* internal_;
+    static IDiscordNetworkEvents events_;
+};
+
+} // namespace discord
diff --git a/engine/inc/discord/overlay_manager.h b/engine/inc/discord/overlay_manager.h
new file mode 100644
index 00000000..c452aed3
--- /dev/null
+++ b/engine/inc/discord/overlay_manager.h
@@ -0,0 +1,33 @@
+#pragma once
+
+#include "types.h"
+
+namespace discord {
+
+class OverlayManager final {
+public:
+    ~OverlayManager() = default;
+
+    void IsEnabled(bool* enabled);
+    void IsLocked(bool* locked);
+    void SetLocked(bool locked, std::function<void(Result)> callback);
+    void OpenActivityInvite(ActivityActionType type, std::function<void(Result)> callback);
+    void OpenGuildInvite(char const* code, std::function<void(Result)> callback);
+    void OpenVoiceSettings(std::function<void(Result)> callback);
+
+    Event<bool> OnToggle;
+
+private:
+    friend class Core;
+
+    OverlayManager() = default;
+    OverlayManager(OverlayManager const& rhs) = delete;
+    OverlayManager& operator=(OverlayManager const& rhs) = delete;
+    OverlayManager(OverlayManager&& rhs) = delete;
+    OverlayManager& operator=(OverlayManager&& rhs) = delete;
+
+    IDiscordOverlayManager* internal_;
+    static IDiscordOverlayEvents events_;
+};
+
+} // namespace discord
diff --git a/engine/inc/discord/relationship_manager.h b/engine/inc/discord/relationship_manager.h
new file mode 100644
index 00000000..e9cd0161
--- /dev/null
+++ b/engine/inc/discord/relationship_manager.h
@@ -0,0 +1,32 @@
+#pragma once
+
+#include "types.h"
+
+namespace discord {
+
+class RelationshipManager final {
+public:
+    ~RelationshipManager() = default;
+
+    void Filter(std::function<bool(Relationship const&)> filter);
+    Result Count(std::int32_t* count);
+    Result Get(UserId userId, Relationship* relationship);
+    Result GetAt(std::uint32_t index, Relationship* relationship);
+
+    Event<> OnRefresh;
+    Event<Relationship const&> OnRelationshipUpdate;
+
+private:
+    friend class Core;
+
+    RelationshipManager() = default;
+    RelationshipManager(RelationshipManager const& rhs) = delete;
+    RelationshipManager& operator=(RelationshipManager const& rhs) = delete;
+    RelationshipManager(RelationshipManager&& rhs) = delete;
+    RelationshipManager& operator=(RelationshipManager&& rhs) = delete;
+
+    IDiscordRelationshipManager* internal_;
+    static IDiscordRelationshipEvents events_;
+};
+
+} // namespace discord
diff --git a/engine/inc/discord/storage_manager.h b/engine/inc/discord/storage_manager.h
new file mode 100644
index 00000000..5d6d17b1
--- /dev/null
+++ b/engine/inc/discord/storage_manager.h
@@ -0,0 +1,46 @@
+#pragma once
+
+#include "types.h"
+
+namespace discord {
+
+class StorageManager final {
+public:
+    ~StorageManager() = default;
+
+    Result Read(char const* name,
+                std::uint8_t* data,
+                std::uint32_t dataLength,
+                std::uint32_t* read);
+    void ReadAsync(char const* name,
+                   std::function<void(Result, std::uint8_t*, std::uint32_t)> callback);
+    void ReadAsyncPartial(char const* name,
+                          std::uint64_t offset,
+                          std::uint64_t length,
+                          std::function<void(Result, std::uint8_t*, std::uint32_t)> callback);
+    Result Write(char const* name, std::uint8_t* data, std::uint32_t dataLength);
+    void WriteAsync(char const* name,
+                    std::uint8_t* data,
+                    std::uint32_t dataLength,
+                    std::function<void(Result)> callback);
+    Result Delete(char const* name);
+    Result Exists(char const* name, bool* exists);
+    void Count(std::int32_t* count);
+    Result Stat(char const* name, FileStat* stat);
+    Result StatAt(std::int32_t index, FileStat* stat);
+    Result GetPath(char path[4096]);
+
+private:
+    friend class Core;
+
+    StorageManager() = default;
+    StorageManager(StorageManager const& rhs) = delete;
+    StorageManager& operator=(StorageManager const& rhs) = delete;
+    StorageManager(StorageManager&& rhs) = delete;
+    StorageManager& operator=(StorageManager&& rhs) = delete;
+
+    IDiscordStorageManager* internal_;
+    static IDiscordStorageEvents events_;
+};
+
+} // namespace discord
diff --git a/engine/inc/discord/store_manager.h b/engine/inc/discord/store_manager.h
new file mode 100644
index 00000000..8e0df8ac
--- /dev/null
+++ b/engine/inc/discord/store_manager.h
@@ -0,0 +1,38 @@
+#pragma once
+
+#include "types.h"
+
+namespace discord {
+
+class StoreManager final {
+public:
+    ~StoreManager() = default;
+
+    void FetchSkus(std::function<void(Result)> callback);
+    void CountSkus(std::int32_t* count);
+    Result GetSku(Snowflake skuId, Sku* sku);
+    Result GetSkuAt(std::int32_t index, Sku* sku);
+    void FetchEntitlements(std::function<void(Result)> callback);
+    void CountEntitlements(std::int32_t* count);
+    Result GetEntitlement(Snowflake entitlementId, Entitlement* entitlement);
+    Result GetEntitlementAt(std::int32_t index, Entitlement* entitlement);
+    Result HasSkuEntitlement(Snowflake skuId, bool* hasEntitlement);
+    void StartPurchase(Snowflake skuId, std::function<void(Result)> callback);
+
+    Event<Entitlement const&> OnEntitlementCreate;
+    Event<Entitlement const&> OnEntitlementDelete;
+
+private:
+    friend class Core;
+
+    StoreManager() = default;
+    StoreManager(StoreManager const& rhs) = delete;
+    StoreManager& operator=(StoreManager const& rhs) = delete;
+    StoreManager(StoreManager&& rhs) = delete;
+    StoreManager& operator=(StoreManager&& rhs) = delete;
+
+    IDiscordStoreManager* internal_;
+    static IDiscordStoreEvents events_;
+};
+
+} // namespace discord
diff --git a/engine/inc/discord/types.h b/engine/inc/discord/types.h
new file mode 100644
index 00000000..5b2655b1
--- /dev/null
+++ b/engine/inc/discord/types.h
@@ -0,0 +1,492 @@
+#pragma once
+
+#include <cstdint>
+#include "ffi.h"
+#include "event.h"
+
+namespace discord {
+
+enum class Result {
+    Ok = 0,
+    ServiceUnavailable = 1,
+    InvalidVersion = 2,
+    LockFailed = 3,
+    InternalError = 4,
+    InvalidPayload = 5,
+    InvalidCommand = 6,
+    InvalidPermissions = 7,
+    NotFetched = 8,
+    NotFound = 9,
+    Conflict = 10,
+    InvalidSecret = 11,
+    InvalidJoinSecret = 12,
+    NoEligibleActivity = 13,
+    InvalidInvite = 14,
+    NotAuthenticated = 15,
+    InvalidAccessToken = 16,
+    ApplicationMismatch = 17,
+    InvalidDataUrl = 18,
+    InvalidBase64 = 19,
+    NotFiltered = 20,
+    LobbyFull = 21,
+    InvalidLobbySecret = 22,
+    InvalidFilename = 23,
+    InvalidFileSize = 24,
+    InvalidEntitlement = 25,
+    NotInstalled = 26,
+    NotRunning = 27,
+    InsufficientBuffer = 28,
+    PurchaseCanceled = 29,
+    InvalidGuild = 30,
+    InvalidEvent = 31,
+    InvalidChannel = 32,
+    InvalidOrigin = 33,
+    RateLimited = 34,
+    OAuth2Error = 35,
+    SelectChannelTimeout = 36,
+    GetGuildTimeout = 37,
+    SelectVoiceForceRequired = 38,
+    CaptureShortcutAlreadyListening = 39,
+    UnauthorizedForAchievement = 40,
+    InvalidGiftCode = 41,
+    PurchaseError = 42,
+    TransactionAborted = 43,
+};
+
+enum class CreateFlags {
+    Default = 0,
+    NoRequireDiscord = 1,
+};
+
+enum class LogLevel {
+    Error = 1,
+    Warn,
+    Info,
+    Debug,
+};
+
+enum class UserFlag {
+    Partner = 2,
+    HypeSquadEvents = 4,
+    HypeSquadHouse1 = 64,
+    HypeSquadHouse2 = 128,
+    HypeSquadHouse3 = 256,
+};
+
+enum class PremiumType {
+    None = 0,
+    Tier1 = 1,
+    Tier2 = 2,
+};
+
+enum class ImageType {
+    User,
+};
+
+enum class ActivityType {
+    Playing,
+    Streaming,
+    Listening,
+    Watching,
+};
+
+enum class ActivityActionType {
+    Join = 1,
+    Spectate,
+};
+
+enum class ActivityJoinRequestReply {
+    No,
+    Yes,
+    Ignore,
+};
+
+enum class Status {
+    Offline = 0,
+    Online = 1,
+    Idle = 2,
+    DoNotDisturb = 3,
+};
+
+enum class RelationshipType {
+    None,
+    Friend,
+    Blocked,
+    PendingIncoming,
+    PendingOutgoing,
+    Implicit,
+};
+
+enum class LobbyType {
+    Private = 1,
+    Public,
+};
+
+enum class LobbySearchComparison {
+    LessThanOrEqual = -2,
+    LessThan,
+    Equal,
+    GreaterThan,
+    GreaterThanOrEqual,
+    NotEqual,
+};
+
+enum class LobbySearchCast {
+    String = 1,
+    Number,
+};
+
+enum class LobbySearchDistance {
+    Local,
+    Default,
+    Extended,
+    Global,
+};
+
+enum class EntitlementType {
+    Purchase = 1,
+    PremiumSubscription,
+    DeveloperGift,
+    TestModePurchase,
+    FreePurchase,
+    UserGift,
+    PremiumPurchase,
+};
+
+enum class SkuType {
+    Application = 1,
+    DLC,
+    Consumable,
+    Bundle,
+};
+
+enum class InputModeType {
+    VoiceActivity = 0,
+    PushToTalk,
+};
+
+using ClientId = std::int64_t;
+using Version = std::int32_t;
+using Snowflake = std::int64_t;
+using Timestamp = std::int64_t;
+using UserId = Snowflake;
+using Locale = char const*;
+using Branch = char const*;
+using LobbyId = Snowflake;
+using LobbySecret = char const*;
+using MetadataKey = char const*;
+using MetadataValue = char const*;
+using NetworkPeerId = std::uint64_t;
+using NetworkChannelId = std::uint8_t;
+using Path = char const*;
+using DateTime = char const*;
+
+class User final {
+public:
+    void SetId(UserId id);
+    UserId GetId() const;
+    void SetUsername(char const* username);
+    char const* GetUsername() const;
+    void SetDiscriminator(char const* discriminator);
+    char const* GetDiscriminator() const;
+    void SetAvatar(char const* avatar);
+    char const* GetAvatar() const;
+    void SetBot(bool bot);
+    bool GetBot() const;
+
+private:
+    DiscordUser internal_;
+};
+
+class OAuth2Token final {
+public:
+    void SetAccessToken(char const* accessToken);
+    char const* GetAccessToken() const;
+    void SetScopes(char const* scopes);
+    char const* GetScopes() const;
+    void SetExpires(Timestamp expires);
+    Timestamp GetExpires() const;
+
+private:
+    DiscordOAuth2Token internal_;
+};
+
+class ImageHandle final {
+public:
+    void SetType(ImageType type);
+    ImageType GetType() const;
+    void SetId(std::int64_t id);
+    std::int64_t GetId() const;
+    void SetSize(std::uint32_t size);
+    std::uint32_t GetSize() const;
+
+private:
+    DiscordImageHandle internal_;
+};
+
+class ImageDimensions final {
+public:
+    void SetWidth(std::uint32_t width);
+    std::uint32_t GetWidth() const;
+    void SetHeight(std::uint32_t height);
+    std::uint32_t GetHeight() const;
+
+private:
+    DiscordImageDimensions internal_;
+};
+
+class ActivityTimestamps final {
+public:
+    void SetStart(Timestamp start);
+    Timestamp GetStart() const;
+    void SetEnd(Timestamp end);
+    Timestamp GetEnd() const;
+
+private:
+    DiscordActivityTimestamps internal_;
+};
+
+class ActivityAssets final {
+public:
+    void SetLargeImage(char const* largeImage);
+    char const* GetLargeImage() const;
+    void SetLargeText(char const* largeText);
+    char const* GetLargeText() const;
+    void SetSmallImage(char const* smallImage);
+    char const* GetSmallImage() const;
+    void SetSmallText(char const* smallText);
+    char const* GetSmallText() const;
+
+private:
+    DiscordActivityAssets internal_;
+};
+
+class PartySize final {
+public:
+    void SetCurrentSize(std::int32_t currentSize);
+    std::int32_t GetCurrentSize() const;
+    void SetMaxSize(std::int32_t maxSize);
+    std::int32_t GetMaxSize() const;
+
+private:
+    DiscordPartySize internal_;
+};
+
+class ActivityParty final {
+public:
+    void SetId(char const* id);
+    char const* GetId() const;
+    PartySize& GetSize();
+    PartySize const& GetSize() const;
+
+private:
+    DiscordActivityParty internal_;
+};
+
+class ActivitySecrets final {
+public:
+    void SetMatch(char const* match);
+    char const* GetMatch() const;
+    void SetJoin(char const* join);
+    char const* GetJoin() const;
+    void SetSpectate(char const* spectate);
+    char const* GetSpectate() const;
+
+private:
+    DiscordActivitySecrets internal_;
+};
+
+class Activity final {
+public:
+    void SetType(ActivityType type);
+    ActivityType GetType() const;
+    void SetApplicationId(std::int64_t applicationId);
+    std::int64_t GetApplicationId() const;
+    void SetName(char const* name);
+    char const* GetName() const;
+    void SetState(char const* state);
+    char const* GetState() const;
+    void SetDetails(char const* details);
+    char const* GetDetails() const;
+    ActivityTimestamps& GetTimestamps();
+    ActivityTimestamps const& GetTimestamps() const;
+    ActivityAssets& GetAssets();
+    ActivityAssets const& GetAssets() const;
+    ActivityParty& GetParty();
+    ActivityParty const& GetParty() const;
+    ActivitySecrets& GetSecrets();
+    ActivitySecrets const& GetSecrets() const;
+    void SetInstance(bool instance);
+    bool GetInstance() const;
+
+private:
+    DiscordActivity internal_;
+};
+
+class Presence final {
+public:
+    void SetStatus(Status status);
+    Status GetStatus() const;
+    Activity& GetActivity();
+    Activity const& GetActivity() const;
+
+private:
+    DiscordPresence internal_;
+};
+
+class Relationship final {
+public:
+    void SetType(RelationshipType type);
+    RelationshipType GetType() const;
+    User& GetUser();
+    User const& GetUser() const;
+    Presence& GetPresence();
+    Presence const& GetPresence() const;
+
+private:
+    DiscordRelationship internal_;
+};
+
+class Lobby final {
+public:
+    void SetId(LobbyId id);
+    LobbyId GetId() const;
+    void SetType(LobbyType type);
+    LobbyType GetType() const;
+    void SetOwnerId(UserId ownerId);
+    UserId GetOwnerId() const;
+    void SetSecret(LobbySecret secret);
+    LobbySecret GetSecret() const;
+    void SetCapacity(std::uint32_t capacity);
+    std::uint32_t GetCapacity() const;
+    void SetLocked(bool locked);
+    bool GetLocked() const;
+
+private:
+    DiscordLobby internal_;
+};
+
+class FileStat final {
+public:
+    void SetFilename(char const* filename);
+    char const* GetFilename() const;
+    void SetSize(std::uint64_t size);
+    std::uint64_t GetSize() const;
+    void SetLastModified(std::uint64_t lastModified);
+    std::uint64_t GetLastModified() const;
+
+private:
+    DiscordFileStat internal_;
+};
+
+class Entitlement final {
+public:
+    void SetId(Snowflake id);
+    Snowflake GetId() const;
+    void SetType(EntitlementType type);
+    EntitlementType GetType() const;
+    void SetSkuId(Snowflake skuId);
+    Snowflake GetSkuId() const;
+
+private:
+    DiscordEntitlement internal_;
+};
+
+class SkuPrice final {
+public:
+    void SetAmount(std::uint32_t amount);
+    std::uint32_t GetAmount() const;
+    void SetCurrency(char const* currency);
+    char const* GetCurrency() const;
+
+private:
+    DiscordSkuPrice internal_;
+};
+
+class Sku final {
+public:
+    void SetId(Snowflake id);
+    Snowflake GetId() const;
+    void SetType(SkuType type);
+    SkuType GetType() const;
+    void SetName(char const* name);
+    char const* GetName() const;
+    SkuPrice& GetPrice();
+    SkuPrice const& GetPrice() const;
+
+private:
+    DiscordSku internal_;
+};
+
+class InputMode final {
+public:
+    void SetType(InputModeType type);
+    InputModeType GetType() const;
+    void SetShortcut(char const* shortcut);
+    char const* GetShortcut() const;
+
+private:
+    DiscordInputMode internal_;
+};
+
+class UserAchievement final {
+public:
+    void SetUserId(Snowflake userId);
+    Snowflake GetUserId() const;
+    void SetAchievementId(Snowflake achievementId);
+    Snowflake GetAchievementId() const;
+    void SetPercentComplete(std::uint8_t percentComplete);
+    std::uint8_t GetPercentComplete() const;
+    void SetUnlockedAt(DateTime unlockedAt);
+    DateTime GetUnlockedAt() const;
+
+private:
+    DiscordUserAchievement internal_;
+};
+
+class LobbyTransaction final {
+public:
+    Result SetType(LobbyType type);
+    Result SetOwner(UserId ownerId);
+    Result SetCapacity(std::uint32_t capacity);
+    Result SetMetadata(MetadataKey key, MetadataValue value);
+    Result DeleteMetadata(MetadataKey key);
+    Result SetLocked(bool locked);
+
+    IDiscordLobbyTransaction** Receive() { return &internal_; }
+    IDiscordLobbyTransaction* Internal() { return internal_; }
+
+private:
+    IDiscordLobbyTransaction* internal_;
+};
+
+class LobbyMemberTransaction final {
+public:
+    Result SetMetadata(MetadataKey key, MetadataValue value);
+    Result DeleteMetadata(MetadataKey key);
+
+    IDiscordLobbyMemberTransaction** Receive() { return &internal_; }
+    IDiscordLobbyMemberTransaction* Internal() { return internal_; }
+
+private:
+    IDiscordLobbyMemberTransaction* internal_;
+};
+
+class LobbySearchQuery final {
+public:
+    Result Filter(MetadataKey key,
+                  LobbySearchComparison comparison,
+                  LobbySearchCast cast,
+                  MetadataValue value);
+    Result Sort(MetadataKey key, LobbySearchCast cast, MetadataValue value);
+    Result Limit(std::uint32_t limit);
+    Result Distance(LobbySearchDistance distance);
+
+    IDiscordLobbySearchQuery** Receive() { return &internal_; }
+    IDiscordLobbySearchQuery* Internal() { return internal_; }
+
+private:
+    IDiscordLobbySearchQuery* internal_;
+};
+
+} // namespace discord
diff --git a/engine/inc/discord/user_manager.h b/engine/inc/discord/user_manager.h
new file mode 100644
index 00000000..d85de1b5
--- /dev/null
+++ b/engine/inc/discord/user_manager.h
@@ -0,0 +1,31 @@
+#pragma once
+
+#include "types.h"
+
+namespace discord {
+
+class UserManager final {
+public:
+    ~UserManager() = default;
+
+    Result GetCurrentUser(User* currentUser);
+    void GetUser(UserId userId, std::function<void(Result, User const&)> callback);
+    Result GetCurrentUserPremiumType(PremiumType* premiumType);
+    Result CurrentUserHasFlag(UserFlag flag, bool* hasFlag);
+
+    Event<> OnCurrentUserUpdate;
+
+private:
+    friend class Core;
+
+    UserManager() = default;
+    UserManager(UserManager const& rhs) = delete;
+    UserManager& operator=(UserManager const& rhs) = delete;
+    UserManager(UserManager&& rhs) = delete;
+    UserManager& operator=(UserManager&& rhs) = delete;
+
+    IDiscordUserManager* internal_;
+    static IDiscordUserEvents events_;
+};
+
+} // namespace discord
diff --git a/engine/inc/discord/voice_manager.h b/engine/inc/discord/voice_manager.h
new file mode 100644
index 00000000..95b20e99
--- /dev/null
+++ b/engine/inc/discord/voice_manager.h
@@ -0,0 +1,37 @@
+#pragma once
+
+#include "types.h"
+
+namespace discord {
+
+class VoiceManager final {
+public:
+    ~VoiceManager() = default;
+
+    Result GetInputMode(InputMode* inputMode);
+    void SetInputMode(InputMode inputMode, std::function<void(Result)> callback);
+    Result IsSelfMute(bool* mute);
+    Result SetSelfMute(bool mute);
+    Result IsSelfDeaf(bool* deaf);
+    Result SetSelfDeaf(bool deaf);
+    Result IsLocalMute(Snowflake userId, bool* mute);
+    Result SetLocalMute(Snowflake userId, bool mute);
+    Result GetLocalVolume(Snowflake userId, std::uint8_t* volume);
+    Result SetLocalVolume(Snowflake userId, std::uint8_t volume);
+
+    Event<> OnSettingsUpdate;
+
+private:
+    friend class Core;
+
+    VoiceManager() = default;
+    VoiceManager(VoiceManager const& rhs) = delete;
+    VoiceManager& operator=(VoiceManager const& rhs) = delete;
+    VoiceManager(VoiceManager&& rhs) = delete;
+    VoiceManager& operator=(VoiceManager&& rhs) = delete;
+
+    IDiscordVoiceManager* internal_;
+    static IDiscordVoiceEvents events_;
+};
+
+} // namespace discord
diff --git a/engine/inc/draco/animation/keyframe_animation.h b/engine/inc/draco/animation/keyframe_animation.h
new file mode 100644
index 00000000..a7afb2b8
--- /dev/null
+++ b/engine/inc/draco/animation/keyframe_animation.h
@@ -0,0 +1,107 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_ANIMATION_KEYFRAME_ANIMATION_H_
+#define DRACO_ANIMATION_KEYFRAME_ANIMATION_H_
+
+#include <vector>
+
+#include "draco/point_cloud/point_cloud.h"
+
+namespace draco {
+
+// Class for holding keyframe animation data. It will have two or more
+// attributes as a point cloud. The first attribute is always the timestamp
+// of the animation. Each KeyframeAnimation could have multiple animations with
+// the same number of frames. Each animation will be treated as a point
+// attribute.
+class KeyframeAnimation : public PointCloud {
+ public:
+  // Force time stamp to be float type.
+  using TimestampType = float;
+
+  KeyframeAnimation();
+
+  // Animation must have only one timestamp attribute.
+  // This function must be called before adding any animation data.
+  // Returns false if timestamp already exists.
+  bool SetTimestamps(const std::vector<TimestampType> &timestamp);
+
+  // Returns an id for the added animation data. This id will be used to
+  // identify this animation.
+  // Returns -1 if error, e.g. number of frames is not consistent.
+  // Type |T| should be consistent with |DataType|, e.g:
+  //    float - DT_FLOAT32,
+  //    int32_t - DT_INT32, ...
+  template <typename T>
+  int32_t AddKeyframes(DataType data_type, uint32_t num_components,
+                       const std::vector<T> &data);
+
+  const PointAttribute *timestamps() const {
+    return GetAttributeByUniqueId(kTimestampId);
+  }
+  const PointAttribute *keyframes(int32_t animation_id) const {
+    return GetAttributeByUniqueId(animation_id);
+  }
+
+  // Number of frames should be equal to number points in the point cloud.
+  void set_num_frames(int32_t num_frames) { set_num_points(num_frames); }
+  int32_t num_frames() const { return static_cast<int32_t>(num_points()); }
+
+  int32_t num_animations() const { return num_attributes() - 1; }
+
+ private:
+  // Attribute id of timestamp is fixed to 0.
+  static constexpr int32_t kTimestampId = 0;
+};
+
+template <typename T>
+int32_t KeyframeAnimation::AddKeyframes(DataType data_type,
+                                        uint32_t num_components,
+                                        const std::vector<T> &data) {
+  // TODO(draco-eng): Verify T is consistent with |data_type|.
+  if (num_components == 0) {
+    return -1;
+  }
+  // If timestamps is not added yet, then reserve attribute 0 for timestamps.
+  if (!num_attributes()) {
+    // Add a temporary attribute with 0 points to fill attribute id 0.
+    std::unique_ptr<PointAttribute> temp_att =
+        std::unique_ptr<PointAttribute>(new PointAttribute());
+    temp_att->Init(GeometryAttribute::GENERIC, num_components, data_type, false,
+                   0);
+    this->AddAttribute(std::move(temp_att));
+
+    set_num_frames(data.size() / num_components);
+  }
+
+  if (data.size() != num_components * num_frames()) {
+    return -1;
+  }
+
+  std::unique_ptr<PointAttribute> keyframe_att =
+      std::unique_ptr<PointAttribute>(new PointAttribute());
+  keyframe_att->Init(GeometryAttribute::GENERIC, num_components, data_type,
+                     false, num_frames());
+  const size_t stride = num_components;
+  for (PointIndex i(0); i < num_frames(); ++i) {
+    keyframe_att->SetAttributeValue(keyframe_att->mapped_index(i),
+                                    &data[i.value() * stride]);
+  }
+  return this->AddAttribute(std::move(keyframe_att));
+}
+
+}  // namespace draco
+
+#endif  // DRACO_ANIMATION_KEYFRAME_ANIMATION_H_
diff --git a/engine/inc/draco/animation/keyframe_animation_decoder.h b/engine/inc/draco/animation/keyframe_animation_decoder.h
new file mode 100644
index 00000000..fdf086b3
--- /dev/null
+++ b/engine/inc/draco/animation/keyframe_animation_decoder.h
@@ -0,0 +1,34 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_ANIMATION_KEYFRAME_ANIMATION_DECODER_H_
+#define DRACO_ANIMATION_KEYFRAME_ANIMATION_DECODER_H_
+
+#include "draco/animation/keyframe_animation.h"
+#include "draco/compression/point_cloud/point_cloud_sequential_decoder.h"
+
+namespace draco {
+
+// Class for decoding keyframe animation.
+class KeyframeAnimationDecoder : private PointCloudSequentialDecoder {
+ public:
+  KeyframeAnimationDecoder(){};
+
+  Status Decode(const DecoderOptions &options, DecoderBuffer *in_buffer,
+                KeyframeAnimation *animation);
+};
+
+}  // namespace draco
+
+#endif  // DRACO_ANIMATION_KEYFRAME_ANIMATION_DECODER_H_
diff --git a/engine/inc/draco/animation/keyframe_animation_encoder.h b/engine/inc/draco/animation/keyframe_animation_encoder.h
new file mode 100644
index 00000000..6096c79f
--- /dev/null
+++ b/engine/inc/draco/animation/keyframe_animation_encoder.h
@@ -0,0 +1,39 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_ANIMATION_KEYFRAME_ANIMATION_ENCODER_H_
+#define DRACO_ANIMATION_KEYFRAME_ANIMATION_ENCODER_H_
+
+#include "draco/animation/keyframe_animation.h"
+#include "draco/compression/point_cloud/point_cloud_sequential_encoder.h"
+
+namespace draco {
+
+// Class for encoding keyframe animation. It takes KeyframeAnimation as a
+// PointCloud and compress it. It's mostly a wrapper around PointCloudEncoder so
+// that the animation module could be separated from geometry compression when
+// exposed to developers.
+class KeyframeAnimationEncoder : private PointCloudSequentialEncoder {
+ public:
+  KeyframeAnimationEncoder();
+
+  // Encode an animation to a buffer.
+  Status EncodeKeyframeAnimation(const KeyframeAnimation &animation,
+                                 const EncoderOptions &options,
+                                 EncoderBuffer *out_buffer);
+};
+
+}  // namespace draco
+
+#endif  // DRACO_ANIMATION_KEYFRAME_ANIMATION_ENCODER_H_
diff --git a/engine/inc/draco/attributes/attribute_octahedron_transform.h b/engine/inc/draco/attributes/attribute_octahedron_transform.h
new file mode 100644
index 00000000..21a1725b
--- /dev/null
+++ b/engine/inc/draco/attributes/attribute_octahedron_transform.h
@@ -0,0 +1,81 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef DRACO_ATTRIBUTES_ATTRIBUTE_OCTAHEDRON_TRANSFORM_H_
+#define DRACO_ATTRIBUTES_ATTRIBUTE_OCTAHEDRON_TRANSFORM_H_
+
+#include "draco/attributes/attribute_transform.h"
+#include "draco/attributes/point_attribute.h"
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// Attribute transform for attributes transformed to octahedral coordinates.
+class AttributeOctahedronTransform : public AttributeTransform {
+ public:
+  AttributeOctahedronTransform() : quantization_bits_(-1) {}
+
+  // Return attribute transform type.
+  AttributeTransformType Type() const override {
+    return ATTRIBUTE_OCTAHEDRON_TRANSFORM;
+  }
+  // Try to init transform from attribute.
+  bool InitFromAttribute(const PointAttribute &attribute) override;
+  // Copy parameter values into the provided AttributeTransformData instance.
+  void CopyToAttributeTransformData(
+      AttributeTransformData *out_data) const override;
+
+  bool TransformAttribute(const PointAttribute &attribute,
+                          const std::vector<PointIndex> &point_ids,
+                          PointAttribute *target_attribute) override;
+
+  bool InverseTransformAttribute(const PointAttribute &attribute,
+                                 PointAttribute *target_attribute) override;
+
+  // Set number of quantization bits.
+  void SetParameters(int quantization_bits);
+
+  // Encode relevant parameters into buffer.
+  bool EncodeParameters(EncoderBuffer *encoder_buffer) const override;
+
+  bool DecodeParameters(const PointAttribute &attribute,
+                        DecoderBuffer *decoder_buffer) override;
+
+  bool is_initialized() const { return quantization_bits_ != -1; }
+  int32_t quantization_bits() const { return quantization_bits_; }
+
+ protected:
+  DataType GetTransformedDataType(
+      const PointAttribute &attribute) const override {
+    return DT_UINT32;
+  }
+  int GetTransformedNumComponents(
+      const PointAttribute &attribute) const override {
+    return 2;
+  }
+
+  // Perform the actual transformation.
+  bool GeneratePortableAttribute(const PointAttribute &attribute,
+                                 const std::vector<PointIndex> &point_ids,
+                                 int num_points,
+                                 PointAttribute *target_attribute) const;
+
+ private:
+  int32_t quantization_bits_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_ATTRIBUTES_ATTRIBUTE_OCTAHEDRON_TRANSFORM_H_
diff --git a/engine/inc/draco/attributes/attribute_quantization_transform.h b/engine/inc/draco/attributes/attribute_quantization_transform.h
new file mode 100644
index 00000000..f1122b68
--- /dev/null
+++ b/engine/inc/draco/attributes/attribute_quantization_transform.h
@@ -0,0 +1,102 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_ATTRIBUTES_ATTRIBUTE_QUANTIZATION_TRANSFORM_H_
+#define DRACO_ATTRIBUTES_ATTRIBUTE_QUANTIZATION_TRANSFORM_H_
+
+#include <vector>
+
+#include "draco/attributes/attribute_transform.h"
+#include "draco/attributes/point_attribute.h"
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// Attribute transform for quantized attributes.
+class AttributeQuantizationTransform : public AttributeTransform {
+ public:
+  AttributeQuantizationTransform() : quantization_bits_(-1), range_(0.f) {}
+  // Return attribute transform type.
+  AttributeTransformType Type() const override {
+    return ATTRIBUTE_QUANTIZATION_TRANSFORM;
+  }
+  // Try to init transform from attribute.
+  bool InitFromAttribute(const PointAttribute &attribute) override;
+  // Copy parameter values into the provided AttributeTransformData instance.
+  void CopyToAttributeTransformData(
+      AttributeTransformData *out_data) const override;
+
+  bool TransformAttribute(const PointAttribute &attribute,
+                          const std::vector<PointIndex> &point_ids,
+                          PointAttribute *target_attribute) override;
+
+  bool InverseTransformAttribute(const PointAttribute &attribute,
+                                 PointAttribute *target_attribute) override;
+
+  bool SetParameters(int quantization_bits, const float *min_values,
+                     int num_components, float range);
+
+  bool ComputeParameters(const PointAttribute &attribute,
+                         const int quantization_bits);
+
+  // Encode relevant parameters into buffer.
+  bool EncodeParameters(EncoderBuffer *encoder_buffer) const override;
+
+  bool DecodeParameters(const PointAttribute &attribute,
+                        DecoderBuffer *decoder_buffer) override;
+
+  int32_t quantization_bits() const { return quantization_bits_; }
+  float min_value(int axis) const { return min_values_[axis]; }
+  const std::vector<float> &min_values() const { return min_values_; }
+  float range() const { return range_; }
+  bool is_initialized() const { return quantization_bits_ != -1; }
+
+ protected:
+  // Create portable attribute using 1:1 mapping between points in the input and
+  // output attribute.
+  void GeneratePortableAttribute(const PointAttribute &attribute,
+                                 int num_points,
+                                 PointAttribute *target_attribute) const;
+
+  // Create portable attribute using custom mapping between input and output
+  // points.
+  void GeneratePortableAttribute(const PointAttribute &attribute,
+                                 const std::vector<PointIndex> &point_ids,
+                                 int num_points,
+                                 PointAttribute *target_attribute) const;
+
+  DataType GetTransformedDataType(
+      const PointAttribute &attribute) const override {
+    return DT_UINT32;
+  }
+  int GetTransformedNumComponents(
+      const PointAttribute &attribute) const override {
+    return attribute.num_components();
+  }
+
+  static bool IsQuantizationValid(int quantization_bits);
+
+ private:
+  int32_t quantization_bits_;
+
+  // Minimal dequantized value for each component of the attribute.
+  std::vector<float> min_values_;
+
+  // Bounds of the dequantized attribute (max delta over all components).
+  float range_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_ATTRIBUTE_DEQUANTIZATION_TRANSFORM_H_
diff --git a/engine/inc/draco/attributes/attribute_transform.h b/engine/inc/draco/attributes/attribute_transform.h
new file mode 100644
index 00000000..62aad60d
--- /dev/null
+++ b/engine/inc/draco/attributes/attribute_transform.h
@@ -0,0 +1,76 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_ATTRIBUTES_ATTRIBUTE_TRANSFORM_H_
+#define DRACO_ATTRIBUTES_ATTRIBUTE_TRANSFORM_H_
+
+#include "draco/attributes/attribute_transform_data.h"
+#include "draco/attributes/point_attribute.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// Virtual base class for various attribute transforms, enforcing common
+// interface where possible.
+class AttributeTransform {
+ public:
+  virtual ~AttributeTransform() = default;
+
+  // Return attribute transform type.
+  virtual AttributeTransformType Type() const = 0;
+  // Try to init transform from attribute.
+  virtual bool InitFromAttribute(const PointAttribute &attribute) = 0;
+  // Copy parameter values into the provided AttributeTransformData instance.
+  virtual void CopyToAttributeTransformData(
+      AttributeTransformData *out_data) const = 0;
+  bool TransferToAttribute(PointAttribute *attribute) const;
+
+  // Applies the transform to |attribute| and stores the result in
+  // |target_attribute|. |point_ids| is an optional vector that can be used to
+  // remap values during the transform.
+  virtual bool TransformAttribute(const PointAttribute &attribute,
+                                  const std::vector<PointIndex> &point_ids,
+                                  PointAttribute *target_attribute) = 0;
+
+  // Applies an inverse transform to |attribute| and stores the result in
+  // |target_attribute|. In this case, |attribute| is an attribute that was
+  // already transformed (e.g. quantized) and |target_attribute| is the
+  // attribute before the transformation.
+  virtual bool InverseTransformAttribute(const PointAttribute &attribute,
+                                         PointAttribute *target_attribute) = 0;
+
+  // Encodes all data needed by the transformation into the |encoder_buffer|.
+  virtual bool EncodeParameters(EncoderBuffer *encoder_buffer) const = 0;
+
+  // Decodes all data needed to transform |attribute| back to the original
+  // format.
+  virtual bool DecodeParameters(const PointAttribute &attribute,
+                                DecoderBuffer *decoder_buffer) = 0;
+
+  // Initializes a transformed attribute that can be used as target in the
+  // TransformAttribute() function call.
+  virtual std::unique_ptr<PointAttribute> InitTransformedAttribute(
+      const PointAttribute &src_attribute, int num_entries);
+
+ protected:
+  virtual DataType GetTransformedDataType(
+      const PointAttribute &attribute) const = 0;
+  virtual int GetTransformedNumComponents(
+      const PointAttribute &attribute) const = 0;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_ATTRIBUTES_ATTRIBUTE_OCTAHEDRON_TRANSFORM_H_
diff --git a/engine/inc/draco/attributes/attribute_transform_data.h b/engine/inc/draco/attributes/attribute_transform_data.h
new file mode 100644
index 00000000..96ed0732
--- /dev/null
+++ b/engine/inc/draco/attributes/attribute_transform_data.h
@@ -0,0 +1,71 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_ATTRIBUTES_ATTRIBUTE_TRANSFORM_DATA_H_
+#define DRACO_ATTRIBUTES_ATTRIBUTE_TRANSFORM_DATA_H_
+
+#include <memory>
+
+#include "draco/attributes/attribute_transform_type.h"
+#include "draco/core/data_buffer.h"
+
+namespace draco {
+
+// Class for holding parameter values for an attribute transform of a
+// PointAttribute. This can be for example quantization data for an attribute
+// that holds quantized values. This class provides only a basic storage for
+// attribute transform parameters and it should be accessed only through wrapper
+// classes for a specific transform (e.g. AttributeQuantizationTransform).
+class AttributeTransformData {
+ public:
+  AttributeTransformData() : transform_type_(ATTRIBUTE_INVALID_TRANSFORM) {}
+  AttributeTransformData(const AttributeTransformData &data) = default;
+
+  // Returns the type of the attribute transform that is described by the class.
+  AttributeTransformType transform_type() const { return transform_type_; }
+  void set_transform_type(AttributeTransformType type) {
+    transform_type_ = type;
+  }
+
+  // Returns a parameter value on a given |byte_offset|.
+  template <typename DataTypeT>
+  DataTypeT GetParameterValue(int byte_offset) const {
+    DataTypeT out_data;
+    buffer_.Read(byte_offset, &out_data, sizeof(DataTypeT));
+    return out_data;
+  }
+
+  // Sets a parameter value on a given |byte_offset|.
+  template <typename DataTypeT>
+  void SetParameterValue(int byte_offset, const DataTypeT &in_data) {
+    if (byte_offset + sizeof(DataTypeT) > buffer_.data_size()) {
+      buffer_.Resize(byte_offset + sizeof(DataTypeT));
+    }
+    buffer_.Write(byte_offset, &in_data, sizeof(DataTypeT));
+  }
+
+  // Sets a parameter value at the end of the |buffer_|.
+  template <typename DataTypeT>
+  void AppendParameterValue(const DataTypeT &in_data) {
+    SetParameterValue(static_cast<int>(buffer_.data_size()), in_data);
+  }
+
+ private:
+  AttributeTransformType transform_type_;
+  DataBuffer buffer_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_ATTRIBUTES_ATTRIBUTE_TRANSFORM_DATA_H_
diff --git a/engine/inc/draco/attributes/attribute_transform_type.h b/engine/inc/draco/attributes/attribute_transform_type.h
new file mode 100644
index 00000000..51ce6f33
--- /dev/null
+++ b/engine/inc/draco/attributes/attribute_transform_type.h
@@ -0,0 +1,30 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_ATTRIBUTES_ATTRIBUTE_TRANSFORM_TYPE_H_
+#define DRACO_ATTRIBUTES_ATTRIBUTE_TRANSFORM_TYPE_H_
+
+namespace draco {
+
+// List of all currently supported attribute transforms.
+enum AttributeTransformType {
+  ATTRIBUTE_INVALID_TRANSFORM = -1,
+  ATTRIBUTE_NO_TRANSFORM = 0,
+  ATTRIBUTE_QUANTIZATION_TRANSFORM = 1,
+  ATTRIBUTE_OCTAHEDRON_TRANSFORM = 2,
+};
+
+}  // namespace draco
+
+#endif  // DRACO_ATTRIBUTES_ATTRIBUTE_TRANSFORM_TYPE_H_
diff --git a/engine/inc/draco/attributes/geometry_attribute.h b/engine/inc/draco/attributes/geometry_attribute.h
new file mode 100644
index 00000000..f4d099b1
--- /dev/null
+++ b/engine/inc/draco/attributes/geometry_attribute.h
@@ -0,0 +1,350 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_ATTRIBUTES_GEOMETRY_ATTRIBUTE_H_
+#define DRACO_ATTRIBUTES_GEOMETRY_ATTRIBUTE_H_
+
+#include <array>
+#include <limits>
+
+#include "draco/attributes/geometry_indices.h"
+#include "draco/core/data_buffer.h"
+#include "draco/core/hash_utils.h"
+
+namespace draco {
+
+// The class provides access to a specific attribute which is stored in a
+// DataBuffer, such as normals or coordinates. However, the GeometryAttribute
+// class does not own the buffer and the buffer itself may store other data
+// unrelated to this attribute (such as data for other attributes in which case
+// we can have multiple GeometryAttributes accessing one buffer). Typically,
+// all attributes for a point (or corner, face) are stored in one block, which
+// is advantageous in terms of memory access. The length of the entire block is
+// given by the byte_stride, the position where the attribute starts is given by
+// the byte_offset, the actual number of bytes that the attribute occupies is
+// given by the data_type and the number of components.
+class GeometryAttribute {
+ public:
+  // Supported attribute types.
+  enum Type {
+    INVALID = -1,
+    // Named attributes start here. The difference between named and generic
+    // attributes is that for named attributes we know their purpose and we
+    // can apply some special methods when dealing with them (e.g. during
+    // encoding).
+    POSITION = 0,
+    NORMAL,
+    COLOR,
+    TEX_COORD,
+    // A special id used to mark attributes that are not assigned to any known
+    // predefined use case. Such attributes are often used for a shader specific
+    // data.
+    GENERIC,
+    // Total number of different attribute types.
+    // Always keep behind all named attributes.
+    NAMED_ATTRIBUTES_COUNT,
+  };
+
+  GeometryAttribute();
+  // Initializes and enables the attribute.
+  void Init(Type attribute_type, DataBuffer *buffer, int8_t num_components,
+            DataType data_type, bool normalized, int64_t byte_stride,
+            int64_t byte_offset);
+  bool IsValid() const { return buffer_ != nullptr; }
+
+  // Copies data from the source attribute to the this attribute.
+  // This attribute must have a valid buffer allocated otherwise the operation
+  // is going to fail and return false.
+  bool CopyFrom(const GeometryAttribute &src_att);
+
+  // Function for getting a attribute value with a specific format.
+  // Unsafe. Caller must ensure the accessed memory is valid.
+  // T is the attribute data type.
+  // att_components_t is the number of attribute components.
+  template <typename T, int att_components_t>
+  std::array<T, att_components_t> GetValue(
+      AttributeValueIndex att_index) const {
+    // Byte address of the attribute index.
+    const int64_t byte_pos = byte_offset_ + byte_stride_ * att_index.value();
+    std::array<T, att_components_t> out;
+    buffer_->Read(byte_pos, &(out[0]), sizeof(out));
+    return out;
+  }
+
+  // Function for getting a attribute value with a specific format.
+  // T is the attribute data type.
+  // att_components_t is the number of attribute components.
+  template <typename T, int att_components_t>
+  bool GetValue(AttributeValueIndex att_index,
+                std::array<T, att_components_t> *out) const {
+    // Byte address of the attribute index.
+    const int64_t byte_pos = byte_offset_ + byte_stride_ * att_index.value();
+    // Check we are not reading past end of data.
+    if (byte_pos + sizeof(*out) > buffer_->data_size()) {
+      return false;
+    }
+    buffer_->Read(byte_pos, &((*out)[0]), sizeof(*out));
+    return true;
+  }
+
+  // Returns the byte position of the attribute entry in the data buffer.
+  inline int64_t GetBytePos(AttributeValueIndex att_index) const {
+    return byte_offset_ + byte_stride_ * att_index.value();
+  }
+
+  inline const uint8_t *GetAddress(AttributeValueIndex att_index) const {
+    const int64_t byte_pos = GetBytePos(att_index);
+    return buffer_->data() + byte_pos;
+  }
+  inline uint8_t *GetAddress(AttributeValueIndex att_index) {
+    const int64_t byte_pos = GetBytePos(att_index);
+    return buffer_->data() + byte_pos;
+  }
+  inline bool IsAddressValid(const uint8_t *address) const {
+    return ((buffer_->data() + buffer_->data_size()) > address);
+  }
+
+  // Fills out_data with the raw value of the requested attribute entry.
+  // out_data must be at least byte_stride_ long.
+  void GetValue(AttributeValueIndex att_index, void *out_data) const {
+    const int64_t byte_pos = byte_offset_ + byte_stride_ * att_index.value();
+    buffer_->Read(byte_pos, out_data, byte_stride_);
+  }
+
+  // Sets a value of an attribute entry. The input value must be allocated to
+  // cover all components of a single attribute entry.
+  void SetAttributeValue(AttributeValueIndex entry_index, const void *value) {
+    const int64_t byte_pos = entry_index.value() * byte_stride();
+    buffer_->Write(byte_pos, value, byte_stride());
+  }
+
+  // DEPRECATED: Use
+  //   ConvertValue(AttributeValueIndex att_id,
+  //               int out_num_components,
+  //               OutT *out_val);
+  //
+  // Function for conversion of a attribute to a specific output format.
+  // OutT is the desired data type of the attribute.
+  // out_att_components_t is the number of components of the output format.
+  // Returns false when the conversion failed.
+  template <typename OutT, int out_att_components_t>
+  bool ConvertValue(AttributeValueIndex att_id, OutT *out_val) const {
+    return ConvertValue(att_id, out_att_components_t, out_val);
+  }
+
+  // Function for conversion of a attribute to a specific output format.
+  // |out_val| needs to be able to store |out_num_components| values.
+  // OutT is the desired data type of the attribute.
+  // Returns false when the conversion failed.
+  template <typename OutT>
+  bool ConvertValue(AttributeValueIndex att_id, int8_t out_num_components,
+                    OutT *out_val) const {
+    if (out_val == nullptr) {
+      return false;
+    }
+    switch (data_type_) {
+      case DT_INT8:
+        return ConvertTypedValue<int8_t, OutT>(att_id, out_num_components,
+                                               out_val);
+      case DT_UINT8:
+        return ConvertTypedValue<uint8_t, OutT>(att_id, out_num_components,
+                                                out_val);
+      case DT_INT16:
+        return ConvertTypedValue<int16_t, OutT>(att_id, out_num_components,
+                                                out_val);
+      case DT_UINT16:
+        return ConvertTypedValue<uint16_t, OutT>(att_id, out_num_components,
+                                                 out_val);
+      case DT_INT32:
+        return ConvertTypedValue<int32_t, OutT>(att_id, out_num_components,
+                                                out_val);
+      case DT_UINT32:
+        return ConvertTypedValue<uint32_t, OutT>(att_id, out_num_components,
+                                                 out_val);
+      case DT_INT64:
+        return ConvertTypedValue<int64_t, OutT>(att_id, out_num_components,
+                                                out_val);
+      case DT_UINT64:
+        return ConvertTypedValue<uint64_t, OutT>(att_id, out_num_components,
+                                                 out_val);
+      case DT_FLOAT32:
+        return ConvertTypedValue<float, OutT>(att_id, out_num_components,
+                                              out_val);
+      case DT_FLOAT64:
+        return ConvertTypedValue<double, OutT>(att_id, out_num_components,
+                                               out_val);
+      case DT_BOOL:
+        return ConvertTypedValue<bool, OutT>(att_id, out_num_components,
+                                             out_val);
+      default:
+        // Wrong attribute type.
+        return false;
+    }
+  }
+
+  // Function for conversion of a attribute to a specific output format.
+  // The |out_value| must be able to store all components of a single attribute
+  // entry.
+  // OutT is the desired data type of the attribute.
+  // Returns false when the conversion failed.
+  template <typename OutT>
+  bool ConvertValue(AttributeValueIndex att_index, OutT *out_value) const {
+    return ConvertValue<OutT>(att_index, num_components_, out_value);
+  }
+
+  // Utility function. Returns |attribute_type| as std::string.
+  static std::string TypeToString(Type attribute_type) {
+    switch (attribute_type) {
+      case INVALID:
+        return "INVALID";
+      case POSITION:
+        return "POSITION";
+      case NORMAL:
+        return "NORMAL";
+      case COLOR:
+        return "COLOR";
+      case TEX_COORD:
+        return "TEX_COORD";
+      case GENERIC:
+        return "GENERIC";
+      default:
+        return "UNKNOWN";
+    }
+  }
+
+  bool operator==(const GeometryAttribute &va) const;
+
+  // Returns the type of the attribute indicating the nature of the attribute.
+  Type attribute_type() const { return attribute_type_; }
+  void set_attribute_type(Type type) { attribute_type_ = type; }
+  // Returns the data type that is stored in the attribute.
+  DataType data_type() const { return data_type_; }
+  // Returns the number of components that are stored for each entry.
+  // For position attribute this is usually three (x,y,z),
+  // while texture coordinates have two components (u,v).
+  int8_t num_components() const { return num_components_; }
+  // Indicates whether the data type should be normalized before interpretation,
+  // that is, it should be divided by the max value of the data type.
+  bool normalized() const { return normalized_; }
+  // The buffer storing the entire data of the attribute.
+  const DataBuffer *buffer() const { return buffer_; }
+  // Returns the number of bytes between two attribute entries, this is, at
+  // least size of the data types times number of components.
+  int64_t byte_stride() const { return byte_stride_; }
+  // The offset where the attribute starts within the block of size byte_stride.
+  int64_t byte_offset() const { return byte_offset_; }
+  void set_byte_offset(int64_t byte_offset) { byte_offset_ = byte_offset; }
+  DataBufferDescriptor buffer_descriptor() const { return buffer_descriptor_; }
+  uint32_t unique_id() const { return unique_id_; }
+  void set_unique_id(uint32_t id) { unique_id_ = id; }
+
+ protected:
+  // Sets a new internal storage for the attribute.
+  void ResetBuffer(DataBuffer *buffer, int64_t byte_stride,
+                   int64_t byte_offset);
+
+ private:
+  // Function for conversion of an attribute to a specific output format given a
+  // format of the stored attribute.
+  // T is the stored attribute data type.
+  // OutT is the desired data type of the attribute.
+  template <typename T, typename OutT>
+  bool ConvertTypedValue(AttributeValueIndex att_id, int8_t out_num_components,
+                         OutT *out_value) const {
+    const uint8_t *src_address = GetAddress(att_id);
+
+    // Convert all components available in both the original and output formats.
+    for (int i = 0; i < std::min(num_components_, out_num_components); ++i) {
+      if (!IsAddressValid(src_address)) {
+        return false;
+      }
+      const T in_value = *reinterpret_cast<const T *>(src_address);
+
+      // Make sure the in_value fits within the range of values that OutT
+      // is able to represent. Perform the check only for integral types.
+      if (std::is_integral<T>::value && std::is_integral<OutT>::value) {
+        static constexpr OutT kOutMin =
+            std::is_signed<T>::value ? std::numeric_limits<OutT>::lowest() : 0;
+        if (in_value < kOutMin || in_value > std::numeric_limits<OutT>::max()) {
+          return false;
+        }
+      }
+
+      out_value[i] = static_cast<OutT>(in_value);
+      // When converting integer to floating point, normalize the value if
+      // necessary.
+      if (std::is_integral<T>::value && std::is_floating_point<OutT>::value &&
+          normalized_) {
+        out_value[i] /= static_cast<OutT>(std::numeric_limits<T>::max());
+      }
+      // TODO(ostava): Add handling of normalized attributes when converting
+      // between different integer representations. If the attribute is
+      // normalized, integer values should be converted as if they represent 0-1
+      // range. E.g. when we convert uint16 to uint8, the range <0, 2^16 - 1>
+      // should be converted to range <0, 2^8 - 1>.
+      src_address += sizeof(T);
+    }
+    // Fill empty data for unused output components if needed.
+    for (int i = num_components_; i < out_num_components; ++i) {
+      out_value[i] = static_cast<OutT>(0);
+    }
+    return true;
+  }
+
+  DataBuffer *buffer_;
+  // The buffer descriptor is stored at the time the buffer is attached to this
+  // attribute. The purpose is to detect if any changes happened to the buffer
+  // since the time it was attached.
+  DataBufferDescriptor buffer_descriptor_;
+  int8_t num_components_;
+  DataType data_type_;
+  bool normalized_;
+  int64_t byte_stride_;
+  int64_t byte_offset_;
+
+  Type attribute_type_;
+
+  // Unique id of this attribute. No two attributes could have the same unique
+  // id. It is used to identify each attribute, especially when there are
+  // multiple attribute of the same type in a point cloud.
+  uint32_t unique_id_;
+
+  friend struct GeometryAttributeHasher;
+};
+
+// Hashing support
+
+// Function object for using Attribute as a hash key.
+struct GeometryAttributeHasher {
+  size_t operator()(const GeometryAttribute &va) const {
+    size_t hash = HashCombine(va.buffer_descriptor_.buffer_id,
+                              va.buffer_descriptor_.buffer_update_count);
+    hash = HashCombine(va.num_components_, hash);
+    hash = HashCombine(static_cast<int8_t>(va.data_type_), hash);
+    hash = HashCombine(static_cast<int8_t>(va.attribute_type_), hash);
+    hash = HashCombine(va.byte_stride_, hash);
+    return HashCombine(va.byte_offset_, hash);
+  }
+};
+
+// Function object for using GeometryAttribute::Type as a hash key.
+struct GeometryAttributeTypeHasher {
+  size_t operator()(const GeometryAttribute::Type &at) const {
+    return static_cast<size_t>(at);
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_ATTRIBUTES_GEOMETRY_ATTRIBUTE_H_
diff --git a/engine/inc/draco/attributes/geometry_indices.h b/engine/inc/draco/attributes/geometry_indices.h
new file mode 100644
index 00000000..80e43e30
--- /dev/null
+++ b/engine/inc/draco/attributes/geometry_indices.h
@@ -0,0 +1,54 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_ATTRIBUTES_GEOMETRY_INDICES_H_
+#define DRACO_ATTRIBUTES_GEOMETRY_INDICES_H_
+
+#include <inttypes.h>
+
+#include <limits>
+
+#include "draco/core/draco_index_type.h"
+
+namespace draco {
+
+// Index of an attribute value entry stored in a GeometryAttribute.
+DEFINE_NEW_DRACO_INDEX_TYPE(uint32_t, AttributeValueIndex)
+// Index of a point in a PointCloud.
+DEFINE_NEW_DRACO_INDEX_TYPE(uint32_t, PointIndex)
+// Vertex index in a Mesh or CornerTable.
+DEFINE_NEW_DRACO_INDEX_TYPE(uint32_t, VertexIndex)
+// Corner index that identifies a corner in a Mesh or CornerTable.
+DEFINE_NEW_DRACO_INDEX_TYPE(uint32_t, CornerIndex)
+// Face index for Mesh and CornerTable.
+DEFINE_NEW_DRACO_INDEX_TYPE(uint32_t, FaceIndex)
+
+// Constants denoting invalid indices.
+static constexpr AttributeValueIndex kInvalidAttributeValueIndex(
+    std::numeric_limits<uint32_t>::max());
+static constexpr PointIndex kInvalidPointIndex(
+    std::numeric_limits<uint32_t>::max());
+static constexpr VertexIndex kInvalidVertexIndex(
+    std::numeric_limits<uint32_t>::max());
+static constexpr CornerIndex kInvalidCornerIndex(
+    std::numeric_limits<uint32_t>::max());
+static constexpr FaceIndex kInvalidFaceIndex(
+    std::numeric_limits<uint32_t>::max());
+
+// TODO(ostava): Add strongly typed indices for attribute id and unique
+// attribute id.
+
+}  // namespace draco
+
+#endif  // DRACO_ATTRIBUTES_GEOMETRY_INDICES_H_
diff --git a/engine/inc/draco/attributes/point_attribute.h b/engine/inc/draco/attributes/point_attribute.h
new file mode 100644
index 00000000..ee366203
--- /dev/null
+++ b/engine/inc/draco/attributes/point_attribute.h
@@ -0,0 +1,190 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_ATTRIBUTES_POINT_ATTRIBUTE_H_
+#define DRACO_ATTRIBUTES_POINT_ATTRIBUTE_H_
+
+#include <memory>
+
+#include "draco/attributes/attribute_transform_data.h"
+#include "draco/attributes/geometry_attribute.h"
+#include "draco/core/draco_index_type_vector.h"
+#include "draco/core/hash_utils.h"
+#include "draco/core/macros.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Class for storing point specific data about each attribute. In general,
+// multiple points stored in a point cloud can share the same attribute value
+// and this class provides the necessary mapping between point ids and attribute
+// value ids.
+class PointAttribute : public GeometryAttribute {
+ public:
+  PointAttribute();
+  explicit PointAttribute(const GeometryAttribute &att);
+
+  // Make sure the move constructor is defined (needed for better performance
+  // when new attributes are added to PointCloud).
+  PointAttribute(PointAttribute &&attribute) = default;
+  PointAttribute &operator=(PointAttribute &&attribute) = default;
+
+  // Initializes a point attribute. By default the attribute will be set to
+  // identity mapping between point indices and attribute values. To set custom
+  // mapping use SetExplicitMapping() function.
+  void Init(Type attribute_type, int8_t num_components, DataType data_type,
+            bool normalized, size_t num_attribute_values);
+
+  // Copies attribute data from the provided |src_att| attribute.
+  void CopyFrom(const PointAttribute &src_att);
+
+  // Prepares the attribute storage for the specified number of entries.
+  bool Reset(size_t num_attribute_values);
+
+  size_t size() const { return num_unique_entries_; }
+  AttributeValueIndex mapped_index(PointIndex point_index) const {
+    if (identity_mapping_) {
+      return AttributeValueIndex(point_index.value());
+    }
+    return indices_map_[point_index];
+  }
+  DataBuffer *buffer() const { return attribute_buffer_.get(); }
+  bool is_mapping_identity() const { return identity_mapping_; }
+  size_t indices_map_size() const {
+    if (is_mapping_identity()) {
+      return 0;
+    }
+    return indices_map_.size();
+  }
+
+  const uint8_t *GetAddressOfMappedIndex(PointIndex point_index) const {
+    return GetAddress(mapped_index(point_index));
+  }
+
+  // Sets the new number of unique attribute entries for the attribute. The
+  // function resizes the attribute storage to hold |num_attribute_values|
+  // entries.
+  // All previous entries with AttributeValueIndex < |num_attribute_values|
+  // are preserved. Caller needs to ensure that the PointAttribute is still
+  // valid after the resizing operation (that is, each point is mapped to a
+  // valid attribute value).
+  void Resize(size_t new_num_unique_entries);
+
+  // Functions for setting the type of mapping between point indices and
+  // attribute entry ids.
+  // This function sets the mapping to implicit, where point indices are equal
+  // to attribute entry indices.
+  void SetIdentityMapping() {
+    identity_mapping_ = true;
+    indices_map_.clear();
+  }
+  // This function sets the mapping to be explicitly using the indices_map_
+  // array that needs to be initialized by the caller.
+  void SetExplicitMapping(size_t num_points) {
+    identity_mapping_ = false;
+    indices_map_.resize(num_points, kInvalidAttributeValueIndex);
+  }
+
+  // Set an explicit map entry for a specific point index.
+  void SetPointMapEntry(PointIndex point_index,
+                        AttributeValueIndex entry_index) {
+    DRACO_DCHECK(!identity_mapping_);
+    indices_map_[point_index] = entry_index;
+  }
+
+  // Same as GeometryAttribute::GetValue(), but using point id as the input.
+  // Mapping to attribute value index is performed automatically.
+  void GetMappedValue(PointIndex point_index, void *out_data) const {
+    return GetValue(mapped_index(point_index), out_data);
+  }
+
+#ifdef DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED
+  // Deduplicate |in_att| values into |this| attribute. |in_att| can be equal
+  // to |this|.
+  // Returns -1 if the deduplication failed.
+  AttributeValueIndex::ValueType DeduplicateValues(
+      const GeometryAttribute &in_att);
+
+  // Same as above but the values read from |in_att| are sampled with the
+  // provided offset |in_att_offset|.
+  AttributeValueIndex::ValueType DeduplicateValues(
+      const GeometryAttribute &in_att, AttributeValueIndex in_att_offset);
+#endif
+
+  // Set attribute transform data for the attribute. The data is used to store
+  // the type and parameters of the transform that is applied on the attribute
+  // data (optional).
+  void SetAttributeTransformData(
+      std::unique_ptr<AttributeTransformData> transform_data) {
+    attribute_transform_data_ = std::move(transform_data);
+  }
+  const AttributeTransformData *GetAttributeTransformData() const {
+    return attribute_transform_data_.get();
+  }
+
+ private:
+#ifdef DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED
+  template <typename T>
+  AttributeValueIndex::ValueType DeduplicateTypedValues(
+      const GeometryAttribute &in_att, AttributeValueIndex in_att_offset);
+  template <typename T, int COMPONENTS_COUNT>
+  AttributeValueIndex::ValueType DeduplicateFormattedValues(
+      const GeometryAttribute &in_att, AttributeValueIndex in_att_offset);
+#endif
+
+  // Data storage for attribute values. GeometryAttribute itself doesn't own its
+  // buffer so we need to allocate it here.
+  std::unique_ptr<DataBuffer> attribute_buffer_;
+
+  // Mapping between point ids and attribute value ids.
+  IndexTypeVector<PointIndex, AttributeValueIndex> indices_map_;
+  AttributeValueIndex::ValueType num_unique_entries_;
+  // Flag when the mapping between point ids and attribute values is identity.
+  bool identity_mapping_;
+
+  // If an attribute contains transformed data (e.g. quantized), we can specify
+  // the attribute transform here and use it to transform the attribute back to
+  // its original format.
+  std::unique_ptr<AttributeTransformData> attribute_transform_data_;
+
+  friend struct PointAttributeHasher;
+};
+
+// Hash functor for the PointAttribute class.
+struct PointAttributeHasher {
+  size_t operator()(const PointAttribute &attribute) const {
+    GeometryAttributeHasher base_hasher;
+    size_t hash = base_hasher(attribute);
+    hash = HashCombine(attribute.identity_mapping_, hash);
+    hash = HashCombine(attribute.num_unique_entries_, hash);
+    hash = HashCombine(attribute.indices_map_.size(), hash);
+    if (!attribute.indices_map_.empty()) {
+      const uint64_t indices_hash = FingerprintString(
+          reinterpret_cast<const char *>(attribute.indices_map_.data()),
+          attribute.indices_map_.size());
+      hash = HashCombine(indices_hash, hash);
+    }
+    if (attribute.attribute_buffer_ != nullptr) {
+      const uint64_t buffer_hash = FingerprintString(
+          reinterpret_cast<const char *>(attribute.attribute_buffer_->data()),
+          attribute.attribute_buffer_->data_size());
+      hash = HashCombine(buffer_hash, hash);
+    }
+    return hash;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_ATTRIBUTES_POINT_ATTRIBUTE_H_
diff --git a/engine/inc/draco/compression/attributes/attributes_decoder.h b/engine/inc/draco/compression/attributes/attributes_decoder.h
new file mode 100644
index 00000000..5b2bb2cf
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/attributes_decoder.h
@@ -0,0 +1,97 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_ATTRIBUTES_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_ATTRIBUTES_DECODER_H_
+
+#include <vector>
+
+#include "draco/compression/attributes/attributes_decoder_interface.h"
+#include "draco/compression/point_cloud/point_cloud_decoder.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/draco_features.h"
+#include "draco/point_cloud/point_cloud.h"
+
+namespace draco {
+
+// Base class for decoding one or more attributes that were encoded with a
+// matching AttributesEncoder. It is a basic implementation of
+// AttributesDecoderInterface that provides functionality that is shared between
+// all AttributesDecoders.
+class AttributesDecoder : public AttributesDecoderInterface {
+ public:
+  AttributesDecoder();
+  virtual ~AttributesDecoder() = default;
+
+  // Called after all attribute decoders are created. It can be used to perform
+  // any custom initialization.
+  bool Init(PointCloudDecoder *decoder, PointCloud *pc) override;
+
+  // Decodes any attribute decoder specific data from the |in_buffer|.
+  bool DecodeAttributesDecoderData(DecoderBuffer *in_buffer) override;
+
+  int32_t GetAttributeId(int i) const override {
+    return point_attribute_ids_[i];
+  }
+  int32_t GetNumAttributes() const override {
+    return static_cast<int32_t>(point_attribute_ids_.size());
+  }
+  PointCloudDecoder *GetDecoder() const override {
+    return point_cloud_decoder_;
+  }
+
+  // Decodes attribute data from the source buffer.
+  bool DecodeAttributes(DecoderBuffer *in_buffer) override {
+    if (!DecodePortableAttributes(in_buffer)) {
+      return false;
+    }
+    if (!DecodeDataNeededByPortableTransforms(in_buffer)) {
+      return false;
+    }
+    if (!TransformAttributesToOriginalFormat()) {
+      return false;
+    }
+    return true;
+  }
+
+ protected:
+  int32_t GetLocalIdForPointAttribute(int32_t point_attribute_id) const {
+    const int id_map_size =
+        static_cast<int>(point_attribute_to_local_id_map_.size());
+    if (point_attribute_id >= id_map_size) {
+      return -1;
+    }
+    return point_attribute_to_local_id_map_[point_attribute_id];
+  }
+  virtual bool DecodePortableAttributes(DecoderBuffer *in_buffer) = 0;
+  virtual bool DecodeDataNeededByPortableTransforms(DecoderBuffer *in_buffer) {
+    return true;
+  }
+  virtual bool TransformAttributesToOriginalFormat() { return true; }
+
+ private:
+  // List of attribute ids that need to be decoded with this decoder.
+  std::vector<int32_t> point_attribute_ids_;
+
+  // Map between point attribute id and the local id (i.e., the inverse of the
+  // |point_attribute_ids_|.
+  std::vector<int32_t> point_attribute_to_local_id_map_;
+
+  PointCloudDecoder *point_cloud_decoder_;
+  PointCloud *point_cloud_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_ATTRIBUTES_DECODER_H_
diff --git a/engine/inc/draco/compression/attributes/attributes_decoder_interface.h b/engine/inc/draco/compression/attributes/attributes_decoder_interface.h
new file mode 100644
index 00000000..8e5cf52a
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/attributes_decoder_interface.h
@@ -0,0 +1,62 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_ATTRIBUTES_DECODER_INTERFACE_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_ATTRIBUTES_DECODER_INTERFACE_H_
+
+#include <vector>
+
+#include "draco/core/decoder_buffer.h"
+#include "draco/point_cloud/point_cloud.h"
+
+namespace draco {
+
+class PointCloudDecoder;
+
+// Interface class for decoding one or more attributes that were encoded with a
+// matching AttributesEncoder. It provides only the basic interface
+// that is used by the PointCloudDecoder. The actual decoding must be
+// implemented in derived classes using the DecodeAttributes() method.
+class AttributesDecoderInterface {
+ public:
+  AttributesDecoderInterface() = default;
+  virtual ~AttributesDecoderInterface() = default;
+
+  // Called after all attribute decoders are created. It can be used to perform
+  // any custom initialization.
+  virtual bool Init(PointCloudDecoder *decoder, PointCloud *pc) = 0;
+
+  // Decodes any attribute decoder specific data from the |in_buffer|.
+  virtual bool DecodeAttributesDecoderData(DecoderBuffer *in_buffer) = 0;
+
+  // Decode attribute data from the source buffer. Needs to be implemented by
+  // the derived classes.
+  virtual bool DecodeAttributes(DecoderBuffer *in_buffer) = 0;
+
+  virtual int32_t GetAttributeId(int i) const = 0;
+  virtual int32_t GetNumAttributes() const = 0;
+  virtual PointCloudDecoder *GetDecoder() const = 0;
+
+  // Returns an attribute containing data processed by the attribute transform.
+  // (see TransformToPortableFormat() method). This data is guaranteed to be
+  // same for encoder and decoder and it can be used by predictors.
+  virtual const PointAttribute *GetPortableAttribute(
+      int32_t /* point_attribute_id */) {
+    return nullptr;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_ATTRIBUTES_DECODER_INTERFACE_H_
diff --git a/engine/inc/draco/compression/attributes/attributes_encoder.h b/engine/inc/draco/compression/attributes/attributes_encoder.h
new file mode 100644
index 00000000..9de846ae
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/attributes_encoder.h
@@ -0,0 +1,154 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_ATTRIBUTES_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_ATTRIBUTES_ENCODER_H_
+
+#include "draco/attributes/point_attribute.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/point_cloud/point_cloud.h"
+
+namespace draco {
+
+class PointCloudEncoder;
+
+// Base class for encoding one or more attributes of a PointCloud (or other
+// geometry). This base class provides only the basic interface that is used
+// by the PointCloudEncoder.
+class AttributesEncoder {
+ public:
+  AttributesEncoder();
+  // Constructs an attribute encoder associated with a given point attribute.
+  explicit AttributesEncoder(int point_attrib_id);
+  virtual ~AttributesEncoder() = default;
+
+  // Called after all attribute encoders are created. It can be used to perform
+  // any custom initialization, including setting up attribute dependencies.
+  // Note: no data should be encoded in this function, because the decoder may
+  // process encoders in a different order from the decoder.
+  virtual bool Init(PointCloudEncoder *encoder, const PointCloud *pc);
+
+  // Encodes data needed by the target attribute decoder.
+  virtual bool EncodeAttributesEncoderData(EncoderBuffer *out_buffer);
+
+  // Returns a unique identifier of the given encoder type, that is used during
+  // decoding to construct the corresponding attribute decoder.
+  virtual uint8_t GetUniqueId() const = 0;
+
+  // Encode attribute data to the target buffer.
+  virtual bool EncodeAttributes(EncoderBuffer *out_buffer) {
+    if (!TransformAttributesToPortableFormat()) {
+      return false;
+    }
+    if (!EncodePortableAttributes(out_buffer)) {
+      return false;
+    }
+    // Encode data needed by portable transforms after the attribute is encoded.
+    // This corresponds to the order in which the data is going to be decoded by
+    // the decoder.
+    if (!EncodeDataNeededByPortableTransforms(out_buffer)) {
+      return false;
+    }
+    return true;
+  }
+
+  // Returns the number of attributes that need to be encoded before the
+  // specified attribute is encoded.
+  // Note that the attribute is specified by its point attribute id.
+  virtual int NumParentAttributes(int32_t /* point_attribute_id */) const {
+    return 0;
+  }
+
+  virtual int GetParentAttributeId(int32_t /* point_attribute_id */,
+                                   int32_t /* parent_i */) const {
+    return -1;
+  }
+
+  // Marks a given attribute as a parent of another attribute.
+  virtual bool MarkParentAttribute(int32_t /* point_attribute_id */) {
+    return false;
+  }
+
+  // Returns an attribute containing data processed by the attribute transform.
+  // (see TransformToPortableFormat() method). This data is guaranteed to be
+  // encoded losslessly and it can be safely used for predictors.
+  virtual const PointAttribute *GetPortableAttribute(
+      int32_t /* point_attribute_id */) {
+    return nullptr;
+  }
+
+  void AddAttributeId(int32_t id) {
+    point_attribute_ids_.push_back(id);
+    if (id >= static_cast<int32_t>(point_attribute_to_local_id_map_.size())) {
+      point_attribute_to_local_id_map_.resize(id + 1, -1);
+    }
+    point_attribute_to_local_id_map_[id] =
+        static_cast<int32_t>(point_attribute_ids_.size()) - 1;
+  }
+
+  // Sets new attribute point ids (replacing the existing ones).
+  void SetAttributeIds(const std::vector<int32_t> &point_attribute_ids) {
+    point_attribute_ids_.clear();
+    point_attribute_to_local_id_map_.clear();
+    for (int32_t att_id : point_attribute_ids) {
+      AddAttributeId(att_id);
+    }
+  }
+
+  int32_t GetAttributeId(int i) const { return point_attribute_ids_[i]; }
+  uint32_t num_attributes() const {
+    return static_cast<uint32_t>(point_attribute_ids_.size());
+  }
+  PointCloudEncoder *encoder() const { return point_cloud_encoder_; }
+
+ protected:
+  // Transforms the input attribute data into a form that should be losslessly
+  // encoded (transform itself can be lossy).
+  virtual bool TransformAttributesToPortableFormat() { return true; }
+
+  // Losslessly encodes data of all portable attributes.
+  // Precondition: All attributes must have been transformed into portable
+  // format at this point (see TransformAttributesToPortableFormat() method).
+  virtual bool EncodePortableAttributes(EncoderBuffer *out_buffer) = 0;
+
+  // Encodes any data needed to revert the transform to portable format for each
+  // attribute (e.g. data needed for dequantization of quantized values).
+  virtual bool EncodeDataNeededByPortableTransforms(EncoderBuffer *out_buffer) {
+    return true;
+  }
+
+  int32_t GetLocalIdForPointAttribute(int32_t point_attribute_id) const {
+    const int id_map_size =
+        static_cast<int>(point_attribute_to_local_id_map_.size());
+    if (point_attribute_id >= id_map_size) {
+      return -1;
+    }
+    return point_attribute_to_local_id_map_[point_attribute_id];
+  }
+
+ private:
+  // List of attribute ids that need to be encoded with this encoder.
+  std::vector<int32_t> point_attribute_ids_;
+
+  // Map between point attribute id and the local id (i.e., the inverse of the
+  // |point_attribute_ids_|.
+  std::vector<int32_t> point_attribute_to_local_id_map_;
+
+  PointCloudEncoder *point_cloud_encoder_;
+  const PointCloud *point_cloud_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_ATTRIBUTES_ENCODER_H_
diff --git a/engine/inc/draco/compression/attributes/kd_tree_attributes_decoder.h b/engine/inc/draco/compression/attributes/kd_tree_attributes_decoder.h
new file mode 100644
index 00000000..87338d6b
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/kd_tree_attributes_decoder.h
@@ -0,0 +1,46 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_KD_TREE_ATTRIBUTES_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_KD_TREE_ATTRIBUTES_DECODER_H_
+
+#include "draco/attributes/attribute_quantization_transform.h"
+#include "draco/compression/attributes/attributes_decoder.h"
+
+namespace draco {
+
+// Decodes attributes encoded with the KdTreeAttributesEncoder.
+class KdTreeAttributesDecoder : public AttributesDecoder {
+ public:
+  KdTreeAttributesDecoder();
+
+ protected:
+  bool DecodePortableAttributes(DecoderBuffer *in_buffer) override;
+  bool DecodeDataNeededByPortableTransforms(DecoderBuffer *in_buffer) override;
+  bool TransformAttributesToOriginalFormat() override;
+
+ private:
+  template <typename SignedDataTypeT>
+  bool TransformAttributeBackToSignedType(PointAttribute *att,
+                                          int num_processed_signed_components);
+
+  std::vector<AttributeQuantizationTransform>
+      attribute_quantization_transforms_;
+  std::vector<int32_t> min_signed_values_;
+  std::vector<std::unique_ptr<PointAttribute>> quantized_portable_attributes_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_KD_TREE_ATTRIBUTES_DECODER_H_
diff --git a/engine/inc/draco/compression/attributes/kd_tree_attributes_encoder.h b/engine/inc/draco/compression/attributes/kd_tree_attributes_encoder.h
new file mode 100644
index 00000000..80748e0b
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/kd_tree_attributes_encoder.h
@@ -0,0 +1,51 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_KD_TREE_ATTRIBUTES_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_KD_TREE_ATTRIBUTES_ENCODER_H_
+
+#include "draco/attributes/attribute_quantization_transform.h"
+#include "draco/compression/attributes/attributes_encoder.h"
+#include "draco/compression/config/compression_shared.h"
+
+namespace draco {
+
+// Encodes all attributes of a given PointCloud using one of the available
+// Kd-tree compression methods.
+// See compression/point_cloud/point_cloud_kd_tree_encoder.h for more details.
+class KdTreeAttributesEncoder : public AttributesEncoder {
+ public:
+  KdTreeAttributesEncoder();
+  explicit KdTreeAttributesEncoder(int att_id);
+
+  uint8_t GetUniqueId() const override { return KD_TREE_ATTRIBUTE_ENCODER; }
+
+ protected:
+  bool TransformAttributesToPortableFormat() override;
+  bool EncodePortableAttributes(EncoderBuffer *out_buffer) override;
+  bool EncodeDataNeededByPortableTransforms(EncoderBuffer *out_buffer) override;
+
+ private:
+  std::vector<AttributeQuantizationTransform>
+      attribute_quantization_transforms_;
+  // Min signed values are used to transform signed integers into unsigned ones
+  // (by subtracting the min signed value for each component).
+  std::vector<int32_t> min_signed_values_;
+  std::vector<std::unique_ptr<PointAttribute>> quantized_portable_attributes_;
+  int num_components_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_KD_TREE_ATTRIBUTES_ENCODER_H_
diff --git a/engine/inc/draco/compression/attributes/kd_tree_attributes_shared.h b/engine/inc/draco/compression/attributes/kd_tree_attributes_shared.h
new file mode 100644
index 00000000..94841a91
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/kd_tree_attributes_shared.h
@@ -0,0 +1,28 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_KD_TREE_ATTRIBUTES_SHARED_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_KD_TREE_ATTRIBUTES_SHARED_H_
+
+namespace draco {
+
+// Defines types of kD-tree compression
+enum KdTreeAttributesEncodingMethod {
+  kKdTreeQuantizationEncoding = 0,
+  kKdTreeIntegerEncoding
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_KD_TREE_ATTRIBUTES_SHARED_H_
diff --git a/engine/inc/draco/compression/attributes/linear_sequencer.h b/engine/inc/draco/compression/attributes/linear_sequencer.h
new file mode 100644
index 00000000..7d9b5264
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/linear_sequencer.h
@@ -0,0 +1,51 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_LINEAR_SEQUENCER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_LINEAR_SEQUENCER_H_
+
+#include "draco/compression/attributes/points_sequencer.h"
+
+namespace draco {
+
+// A simple sequencer that generates a linear sequence [0, num_points - 1].
+// I.e., the order of the points is preserved for the input data.
+class LinearSequencer : public PointsSequencer {
+ public:
+  explicit LinearSequencer(int32_t num_points) : num_points_(num_points) {}
+
+  bool UpdatePointToAttributeIndexMapping(PointAttribute *attribute) override {
+    attribute->SetIdentityMapping();
+    return true;
+  }
+
+ protected:
+  bool GenerateSequenceInternal() override {
+    if (num_points_ < 0) {
+      return false;
+    }
+    out_point_ids()->resize(num_points_);
+    for (int i = 0; i < num_points_; ++i) {
+      out_point_ids()->at(i) = PointIndex(i);
+    }
+    return true;
+  }
+
+ private:
+  int32_t num_points_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_LINEAR_SEQUENCER_H_
diff --git a/engine/inc/draco/compression/attributes/mesh_attribute_indices_encoding_data.h b/engine/inc/draco/compression/attributes/mesh_attribute_indices_encoding_data.h
new file mode 100644
index 00000000..9a358e44
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/mesh_attribute_indices_encoding_data.h
@@ -0,0 +1,58 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_MESH_ATTRIBUTE_INDICES_ENCODING_DATA_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_MESH_ATTRIBUTE_INDICES_ENCODING_DATA_H_
+
+#include <inttypes.h>
+
+#include <vector>
+
+#include "draco/attributes/geometry_indices.h"
+
+namespace draco {
+
+// Data used for encoding and decoding of mesh attributes.
+struct MeshAttributeIndicesEncodingData {
+  MeshAttributeIndicesEncodingData() : num_values(0) {}
+
+  void Init(int num_vertices) {
+    vertex_to_encoded_attribute_value_index_map.resize(num_vertices);
+
+    // We expect to store one value for each vertex.
+    encoded_attribute_value_index_to_corner_map.reserve(num_vertices);
+  }
+
+  // Array for storing the corner ids in the order their associated attribute
+  // entries were encoded/decoded. For every encoded attribute value entry we
+  // store exactly one corner. I.e., this is the mapping between an encoded
+  // attribute entry ids and corner ids. This map is needed for example by
+  // prediction schemes. Note that not all corners are included in this map,
+  // e.g., if multiple corners share the same attribute value, only one of these
+  // corners will be usually included.
+  std::vector<CornerIndex> encoded_attribute_value_index_to_corner_map;
+
+  // Map for storing encoding order of attribute entries for each vertex.
+  // i.e. Mapping between vertices and their corresponding attribute entry ids
+  // that are going to be used by the decoder.
+  // -1 if an attribute entry hasn't been encoded/decoded yet.
+  std::vector<int32_t> vertex_to_encoded_attribute_value_index_map;
+
+  // Total number of encoded/decoded attribute entries.
+  int num_values;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_MESH_ATTRIBUTE_INDICES_ENCODING_DATA_H_
diff --git a/engine/inc/draco/compression/attributes/normal_compression_utils.h b/engine/inc/draco/compression/attributes/normal_compression_utils.h
new file mode 100644
index 00000000..8a6f25b6
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/normal_compression_utils.h
@@ -0,0 +1,360 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Utilities for converting unit vectors to octahedral coordinates and back.
+// For more details about octahedral coordinates, see for example Cigolle
+// et al.'14 “A Survey of Efficient Representations for Independent Unit
+// Vectors�.
+//
+// In short this is motivated by an octahedron inscribed into a sphere. The
+// direction of the normal vector can be defined by a point on the octahedron.
+// On the right hemisphere (x > 0) this point is projected onto the x = 0 plane,
+// that is, the right side of the octahedron forms a diamond like shape. The
+// left side of the octahedron is also projected onto the x = 0 plane, however,
+// in this case we flap the triangles of the diamond outward. Afterwards we
+// shift the resulting square such that all values are positive.
+//
+// Important values in this file:
+// * q: number of quantization bits
+// * max_quantized_value: the max value representable with q bits (odd)
+// * max_value: max value of the diamond = max_quantized_value - 1  (even)
+// * center_value: center of the diamond after shift
+//
+// Note that the parameter space is somewhat periodic, e.g. (0, 0) ==
+// (max_value, max_value), which is also why the diamond is one smaller than the
+// maximal representable value in order to have an odd range of values.
+
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_NORMAL_COMPRESSION_UTILS_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_NORMAL_COMPRESSION_UTILS_H_
+
+#include <inttypes.h>
+
+#include <algorithm>
+#include <cmath>
+
+#include "draco/core/macros.h"
+
+namespace draco {
+
+class OctahedronToolBox {
+ public:
+  OctahedronToolBox()
+      : quantization_bits_(-1),
+        max_quantized_value_(-1),
+        max_value_(-1),
+        dequantization_scale_(1.f),
+        center_value_(-1) {}
+
+  bool SetQuantizationBits(int32_t q) {
+    if (q < 2 || q > 30) {
+      return false;
+    }
+    quantization_bits_ = q;
+    max_quantized_value_ = (1 << quantization_bits_) - 1;
+    max_value_ = max_quantized_value_ - 1;
+    dequantization_scale_ = 2.f / max_value_;
+    center_value_ = max_value_ / 2;
+    return true;
+  }
+  bool IsInitialized() const { return quantization_bits_ != -1; }
+
+  // Convert all edge points in the top left and bottom right quadrants to
+  // their corresponding position in the bottom left and top right quadrants.
+  // Convert all corner edge points to the top right corner.
+  inline void CanonicalizeOctahedralCoords(int32_t s, int32_t t, int32_t *out_s,
+                                           int32_t *out_t) const {
+    if ((s == 0 && t == 0) || (s == 0 && t == max_value_) ||
+        (s == max_value_ && t == 0)) {
+      s = max_value_;
+      t = max_value_;
+    } else if (s == 0 && t > center_value_) {
+      t = center_value_ - (t - center_value_);
+    } else if (s == max_value_ && t < center_value_) {
+      t = center_value_ + (center_value_ - t);
+    } else if (t == max_value_ && s < center_value_) {
+      s = center_value_ + (center_value_ - s);
+    } else if (t == 0 && s > center_value_) {
+      s = center_value_ - (s - center_value_);
+    }
+
+    *out_s = s;
+    *out_t = t;
+  }
+
+  // Converts an integer vector to octahedral coordinates.
+  // Precondition: |int_vec| abs sum must equal center value.
+  inline void IntegerVectorToQuantizedOctahedralCoords(const int32_t *int_vec,
+                                                       int32_t *out_s,
+                                                       int32_t *out_t) const {
+    DRACO_DCHECK_EQ(
+        std::abs(int_vec[0]) + std::abs(int_vec[1]) + std::abs(int_vec[2]),
+        center_value_);
+    int32_t s, t;
+    if (int_vec[0] >= 0) {
+      // Right hemisphere.
+      s = (int_vec[1] + center_value_);
+      t = (int_vec[2] + center_value_);
+    } else {
+      // Left hemisphere.
+      if (int_vec[1] < 0) {
+        s = std::abs(int_vec[2]);
+      } else {
+        s = (max_value_ - std::abs(int_vec[2]));
+      }
+      if (int_vec[2] < 0) {
+        t = std::abs(int_vec[1]);
+      } else {
+        t = (max_value_ - std::abs(int_vec[1]));
+      }
+    }
+    CanonicalizeOctahedralCoords(s, t, out_s, out_t);
+  }
+
+  template <class T>
+  void FloatVectorToQuantizedOctahedralCoords(const T *vector, int32_t *out_s,
+                                              int32_t *out_t) const {
+    const double abs_sum = std::abs(static_cast<double>(vector[0])) +
+                           std::abs(static_cast<double>(vector[1])) +
+                           std::abs(static_cast<double>(vector[2]));
+
+    // Adjust values such that abs sum equals 1.
+    double scaled_vector[3];
+    if (abs_sum > 1e-6) {
+      // Scale needed to project the vector to the surface of an octahedron.
+      const double scale = 1.0 / abs_sum;
+      scaled_vector[0] = vector[0] * scale;
+      scaled_vector[1] = vector[1] * scale;
+      scaled_vector[2] = vector[2] * scale;
+    } else {
+      scaled_vector[0] = 1.0;
+      scaled_vector[1] = 0;
+      scaled_vector[2] = 0;
+    }
+
+    // Scale vector such that the sum equals the center value.
+    int32_t int_vec[3];
+    int_vec[0] =
+        static_cast<int32_t>(floor(scaled_vector[0] * center_value_ + 0.5));
+    int_vec[1] =
+        static_cast<int32_t>(floor(scaled_vector[1] * center_value_ + 0.5));
+    // Make sure the sum is exactly the center value.
+    int_vec[2] = center_value_ - std::abs(int_vec[0]) - std::abs(int_vec[1]);
+    if (int_vec[2] < 0) {
+      // If the sum of first two coordinates is too large, we need to decrease
+      // the length of one of the coordinates.
+      if (int_vec[1] > 0) {
+        int_vec[1] += int_vec[2];
+      } else {
+        int_vec[1] -= int_vec[2];
+      }
+      int_vec[2] = 0;
+    }
+    // Take care of the sign.
+    if (scaled_vector[2] < 0) {
+      int_vec[2] *= -1;
+    }
+
+    IntegerVectorToQuantizedOctahedralCoords(int_vec, out_s, out_t);
+  }
+
+  // Normalize |vec| such that its abs sum is equal to the center value;
+  template <class T>
+  void CanonicalizeIntegerVector(T *vec) const {
+    static_assert(std::is_integral<T>::value, "T must be an integral type.");
+    static_assert(std::is_signed<T>::value, "T must be a signed type.");
+    const int64_t abs_sum = static_cast<int64_t>(std::abs(vec[0])) +
+                            static_cast<int64_t>(std::abs(vec[1])) +
+                            static_cast<int64_t>(std::abs(vec[2]));
+
+    if (abs_sum == 0) {
+      vec[0] = center_value_;  // vec[1] == v[2] == 0
+    } else {
+      vec[0] =
+          (static_cast<int64_t>(vec[0]) * static_cast<int64_t>(center_value_)) /
+          abs_sum;
+      vec[1] =
+          (static_cast<int64_t>(vec[1]) * static_cast<int64_t>(center_value_)) /
+          abs_sum;
+      if (vec[2] >= 0) {
+        vec[2] = center_value_ - std::abs(vec[0]) - std::abs(vec[1]);
+      } else {
+        vec[2] = -(center_value_ - std::abs(vec[0]) - std::abs(vec[1]));
+      }
+    }
+  }
+
+  inline void QuantizedOctahedralCoordsToUnitVector(int32_t in_s, int32_t in_t,
+                                                    float *out_vector) const {
+    OctahedralCoordsToUnitVector(in_s * dequantization_scale_ - 1.f,
+                                 in_t * dequantization_scale_ - 1.f,
+                                 out_vector);
+  }
+
+  // |s| and |t| are expected to be signed values.
+  inline bool IsInDiamond(const int32_t &s, const int32_t &t) const {
+    // Expect center already at origin.
+    DRACO_DCHECK_LE(s, center_value_);
+    DRACO_DCHECK_LE(t, center_value_);
+    DRACO_DCHECK_GE(s, -center_value_);
+    DRACO_DCHECK_GE(t, -center_value_);
+    return std::abs(s) + std::abs(t) <= center_value_;
+  }
+
+  void InvertDiamond(int32_t *s, int32_t *t) const {
+    // Expect center already at origin.
+    DRACO_DCHECK_LE(*s, center_value_);
+    DRACO_DCHECK_LE(*t, center_value_);
+    DRACO_DCHECK_GE(*s, -center_value_);
+    DRACO_DCHECK_GE(*t, -center_value_);
+    int32_t sign_s = 0;
+    int32_t sign_t = 0;
+    if (*s >= 0 && *t >= 0) {
+      sign_s = 1;
+      sign_t = 1;
+    } else if (*s <= 0 && *t <= 0) {
+      sign_s = -1;
+      sign_t = -1;
+    } else {
+      sign_s = (*s > 0) ? 1 : -1;
+      sign_t = (*t > 0) ? 1 : -1;
+    }
+
+    const int32_t corner_point_s = sign_s * center_value_;
+    const int32_t corner_point_t = sign_t * center_value_;
+    *s = 2 * *s - corner_point_s;
+    *t = 2 * *t - corner_point_t;
+    if (sign_s * sign_t >= 0) {
+      int32_t temp = *s;
+      *s = -*t;
+      *t = -temp;
+    } else {
+      std::swap(*s, *t);
+    }
+    *s = (*s + corner_point_s) / 2;
+    *t = (*t + corner_point_t) / 2;
+  }
+
+  void InvertDirection(int32_t *s, int32_t *t) const {
+    // Expect center already at origin.
+    DRACO_DCHECK_LE(*s, center_value_);
+    DRACO_DCHECK_LE(*t, center_value_);
+    DRACO_DCHECK_GE(*s, -center_value_);
+    DRACO_DCHECK_GE(*t, -center_value_);
+    *s *= -1;
+    *t *= -1;
+    this->InvertDiamond(s, t);
+  }
+
+  // For correction values.
+  int32_t ModMax(int32_t x) const {
+    if (x > this->center_value()) {
+      return x - this->max_quantized_value();
+    }
+    if (x < -this->center_value()) {
+      return x + this->max_quantized_value();
+    }
+    return x;
+  }
+
+  // For correction values.
+  int32_t MakePositive(int32_t x) const {
+    DRACO_DCHECK_LE(x, this->center_value() * 2);
+    if (x < 0) {
+      return x + this->max_quantized_value();
+    }
+    return x;
+  }
+
+  int32_t quantization_bits() const { return quantization_bits_; }
+  int32_t max_quantized_value() const { return max_quantized_value_; }
+  int32_t max_value() const { return max_value_; }
+  int32_t center_value() const { return center_value_; }
+
+ private:
+  inline void OctahedralCoordsToUnitVector(float in_s_scaled, float in_t_scaled,
+                                           float *out_vector) const {
+    // Background about the encoding:
+    //   A normal is encoded in a normalized space <s, t> depicted below. The
+    //   encoding correponds to an octahedron that is unwrapped to a 2D plane.
+    //   During encoding, a normal is projected to the surface of the octahedron
+    //   and the projection is then unwrapped to the 2D plane. Decoding is the
+    //   reverse of this process.
+    //   All points in the central diamond are located on triangles on the
+    //   right "hemisphere" of the octahedron while all points outside of the
+    //   diamond are on the left hemisphere (basically, they would have to be
+    //   wrapped along the diagonal edges to form the octahedron). The central
+    //   point corresponds to the right most vertex of the octahedron and all
+    //   corners of the plane correspond to the left most vertex of the
+    //   octahedron.
+    //
+    // t
+    // ^ *-----*-----*
+    // | |    /|\    |
+    //   |   / | \   |
+    //   |  /  |  \  |
+    //   | /   |   \ |
+    //   *-----*---- *
+    //   | \   |   / |
+    //   |  \  |  /  |
+    //   |   \ | /   |
+    //   |    \|/    |
+    //   *-----*-----*  --> s
+
+    // Note that the input |in_s_scaled| and |in_t_scaled| are already scaled to
+    // <-1, 1> range. This way, the central point is at coordinate (0, 0).
+    float y = in_s_scaled;
+    float z = in_t_scaled;
+
+    // Remaining coordinate can be computed by projecting the (y, z) values onto
+    // the surface of the octahedron.
+    const float x = 1.f - abs(y) - abs(z);
+
+    // |x| is essentially a signed distance from the diagonal edges of the
+    // diamond shown on the figure above. It is positive for all points in the
+    // diamond (right hemisphere) and negative for all points outside the
+    // diamond (left hemisphere). For all points on the left hemisphere we need
+    // to update their (y, z) coordinates to account for the wrapping along
+    // the edges of the diamond.
+    float x_offset = -x;
+    x_offset = x_offset < 0 ? 0 : x_offset;
+
+    // This will do nothing for the points on the right hemisphere but it will
+    // mirror the (y, z) location along the nearest diagonal edge of the
+    // diamond.
+    y += y < 0 ? x_offset : -x_offset;
+    z += z < 0 ? x_offset : -x_offset;
+
+    // Normalize the computed vector.
+    const float norm_squared = x * x + y * y + z * z;
+    if (norm_squared < 1e-6) {
+      out_vector[0] = 0;
+      out_vector[1] = 0;
+      out_vector[2] = 0;
+    } else {
+      const float d = 1.0f / std::sqrt(norm_squared);
+      out_vector[0] = x * d;
+      out_vector[1] = y * d;
+      out_vector[2] = z * d;
+    }
+  }
+
+  int32_t quantization_bits_;
+  int32_t max_quantized_value_;
+  int32_t max_value_;
+  float dequantization_scale_;
+  int32_t center_value_;
+};
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_NORMAL_COMPRESSION_UTILS_H_
diff --git a/engine/inc/draco/compression/attributes/point_d_vector.h b/engine/inc/draco/compression/attributes/point_d_vector.h
new file mode 100644
index 00000000..3b115d50
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/point_d_vector.h
@@ -0,0 +1,279 @@
+// Copyright 2018 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_POINT_D_VECTOR_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_POINT_D_VECTOR_H_
+
+#include <cstring>
+#include <memory>
+#include <vector>
+
+#include "draco/core/macros.h"
+
+namespace draco {
+
+// The main class of this file is PointDVector providing an interface similar to
+// std::vector<PointD> for arbitrary number of dimensions (without a template
+// argument). PointDVectorIterator is a random access iterator, which allows for
+// compatibility with existing algorithms. PseudoPointD provides for a view on
+// the individual items in a contiguous block of memory, which is compatible
+// with the swap function and is returned by a dereference of
+// PointDVectorIterator. Swap functions provide for compatibility/specialization
+// that allows these classes to work with currently utilized STL functions.
+
+// This class allows for swap functionality from the RandomIterator
+// It seems problematic to bring this inside PointDVector due to templating.
+template <typename internal_t>
+class PseudoPointD {
+ public:
+  PseudoPointD(internal_t *mem, internal_t dimension)
+      : mem_(mem), dimension_(dimension) {}
+
+  // Specifically copies referenced memory
+  void swap(PseudoPointD &other) noexcept {
+    for (internal_t dim = 0; dim < dimension_; dim += 1) {
+      std::swap(mem_[dim], other.mem_[dim]);
+    }
+  }
+
+  PseudoPointD(const PseudoPointD &other)
+      : mem_(other.mem_), dimension_(other.dimension_) {}
+
+  const internal_t &operator[](const size_t &n) const {
+    DRACO_DCHECK_LT(n, dimension_);
+    return mem_[n];
+  }
+  internal_t &operator[](const size_t &n) {
+    DRACO_DCHECK_LT(n, dimension_);
+    return mem_[n];
+  }
+
+  bool operator==(const PseudoPointD &other) const {
+    for (auto dim = 0; dim < dimension_; dim += 1) {
+      if (mem_[dim] != other.mem_[dim]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  bool operator!=(const PseudoPointD &other) const {
+    return !this->operator==(other);
+  }
+
+ private:
+  internal_t *const mem_;
+  const internal_t dimension_;
+};
+
+// It seems problematic to bring this inside PointDVector due to templating.
+template <typename internal_t>
+void swap(draco::PseudoPointD<internal_t> &&a,
+          draco::PseudoPointD<internal_t> &&b) noexcept {
+  a.swap(b);
+};
+template <typename internal_t>
+void swap(draco::PseudoPointD<internal_t> &a,
+          draco::PseudoPointD<internal_t> &b) noexcept {
+  a.swap(b);
+};
+
+template <typename internal_t>
+class PointDVector {
+ public:
+  PointDVector(const uint32_t n_items, const uint32_t dimensionality)
+      : n_items_(n_items),
+        dimensionality_(dimensionality),
+        item_size_bytes_(dimensionality * sizeof(internal_t)),
+        data_(n_items * dimensionality),
+        data0_(data_.data()) {}
+  // random access iterator
+  class PointDVectorIterator
+      : public std::iterator<std::random_access_iterator_tag, size_t, size_t> {
+    friend class PointDVector;
+
+   public:
+    // std::iter_swap is called inside of std::partition and needs this
+    // specialized support
+    PseudoPointD<internal_t> operator*() const {
+      return PseudoPointD<internal_t>(vec_->data0_ + item_ * dimensionality_,
+                                      dimensionality_);
+    }
+    const PointDVectorIterator &operator++() {
+      item_ += 1;
+      return *this;
+    }
+    const PointDVectorIterator &operator--() {
+      item_ -= 1;
+      return *this;
+    }
+    PointDVectorIterator operator++(int32_t) {
+      PointDVectorIterator copy(*this);
+      item_ += 1;
+      return copy;
+    }
+    PointDVectorIterator operator--(int32_t) {
+      PointDVectorIterator copy(*this);
+      item_ -= 1;
+      return copy;
+    }
+    PointDVectorIterator &operator=(const PointDVectorIterator &other) {
+      this->item_ = other.item_;
+      return *this;
+    }
+
+    bool operator==(const PointDVectorIterator &ref) const {
+      return item_ == ref.item_;
+    }
+    bool operator!=(const PointDVectorIterator &ref) const {
+      return item_ != ref.item_;
+    }
+    bool operator<(const PointDVectorIterator &ref) const {
+      return item_ < ref.item_;
+    }
+    bool operator>(const PointDVectorIterator &ref) const {
+      return item_ > ref.item_;
+    }
+    bool operator<=(const PointDVectorIterator &ref) const {
+      return item_ <= ref.item_;
+    }
+    bool operator>=(const PointDVectorIterator &ref) const {
+      return item_ >= ref.item_;
+    }
+
+    PointDVectorIterator operator+(const int32_t &add) const {
+      PointDVectorIterator copy(vec_, item_ + add);
+      return copy;
+    }
+    PointDVectorIterator &operator+=(const int32_t &add) {
+      item_ += add;
+      return *this;
+    }
+    PointDVectorIterator operator-(const int32_t &sub) const {
+      PointDVectorIterator copy(vec_, item_ - sub);
+      return copy;
+    }
+    size_t operator-(const PointDVectorIterator &sub) const {
+      return (item_ - sub.item_);
+    }
+
+    PointDVectorIterator &operator-=(const int32_t &sub) {
+      item_ -= sub;
+      return *this;
+    }
+
+    internal_t *operator[](const size_t &n) const {
+      return vec_->data0_ + (item_ + n) * dimensionality_;
+    }
+
+   protected:
+    explicit PointDVectorIterator(PointDVector *vec, size_t start_item)
+        : item_(start_item), vec_(vec), dimensionality_(vec->dimensionality_) {}
+
+   private:
+    size_t item_;  // this counts the item that should be referenced.
+    PointDVector *const vec_;        // the thing that we're iterating on
+    const uint32_t dimensionality_;  // local copy from vec_
+  };
+
+  PointDVectorIterator begin() { return PointDVectorIterator(this, 0); }
+  PointDVectorIterator end() { return PointDVectorIterator(this, n_items_); }
+
+  // operator[] allows for unprotected user-side usage of operator[] on the
+  // return value AS IF it were a natively indexable type like Point3*
+  internal_t *operator[](const uint32_t index) {
+    DRACO_DCHECK_LT(index, n_items_);
+    return data0_ + index * dimensionality_;
+  }
+  const internal_t *operator[](const uint32_t index) const {
+    DRACO_DCHECK_LT(index, n_items_);
+    return data0_ + index * dimensionality_;
+  }
+
+  uint32_t size() const { return n_items_; }
+  size_t GetBufferSize() const { return data_.size(); }
+
+  // copy a single contiguous 'item' from one PointDVector into this one.
+  void CopyItem(const PointDVector &source, const internal_t source_index,
+                const internal_t destination_index) {
+    DRACO_DCHECK(&source != this ||
+                 (&source == this && source_index != destination_index));
+    DRACO_DCHECK_LT(destination_index, n_items_);
+    DRACO_DCHECK_LT(source_index, source.n_items_);
+
+    // DRACO_DCHECK_EQ(source.n_items_, n_items_); // not technically necessary
+    DRACO_DCHECK_EQ(source.dimensionality_, dimensionality_);
+
+    const internal_t *ref = source[source_index];
+    internal_t *const dest = this->operator[](destination_index);
+    std::memcpy(dest, ref, item_size_bytes_);
+  }
+
+  // Copy data directly off of an attribute buffer interleaved into internal
+  // memory.
+  void CopyAttribute(
+      // The dimensionality of the attribute being integrated
+      const internal_t attribute_dimensionality,
+      // The offset in dimensions to insert this attribute.
+      const internal_t offset_dimensionality, const internal_t index,
+      // The direct pointer to the data
+      const void *const attribute_item_data) {
+    // chunk copy
+    const size_t copy_size = sizeof(internal_t) * attribute_dimensionality;
+
+    // a multiply and add can be optimized away with an iterator
+    std::memcpy(data0_ + index * dimensionality_ + offset_dimensionality,
+                attribute_item_data, copy_size);
+  }
+  // Copy data off of a contiguous buffer interleaved into internal memory
+  void CopyAttribute(
+      // The dimensionality of the attribute being integrated
+      const internal_t attribute_dimensionality,
+      // The offset in dimensions to insert this attribute.
+      const internal_t offset_dimensionality,
+      const internal_t *const attribute_mem) {
+    DRACO_DCHECK_LT(offset_dimensionality,
+                    dimensionality_ - attribute_dimensionality);
+    // degenerate case block copy the whole buffer.
+    if (dimensionality_ == attribute_dimensionality) {
+      DRACO_DCHECK_EQ(offset_dimensionality, 0);
+      const size_t copy_size =
+          sizeof(internal_t) * attribute_dimensionality * n_items_;
+      std::memcpy(data0_, attribute_mem, copy_size);
+    } else {  // chunk copy
+      const size_t copy_size = sizeof(internal_t) * attribute_dimensionality;
+      internal_t *internal_data;
+      const internal_t *attribute_data;
+      internal_t item;
+      for (internal_data = data0_ + offset_dimensionality,
+          attribute_data = attribute_mem, item = 0;
+           item < n_items_; internal_data += dimensionality_,
+          attribute_data += attribute_dimensionality, item += 1) {
+        std::memcpy(internal_data, attribute_data, copy_size);
+      }
+    }
+  }
+
+ private:
+  // internal parameters.
+  const uint32_t n_items_;
+  const uint32_t dimensionality_;  // The dimension of the points in the buffer
+  const uint32_t item_size_bytes_;
+  std::vector<internal_t> data_;  // contiguously stored data.  Never resized.
+  internal_t *const data0_;       // raw pointer to base data.
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_POINT_D_VECTOR_H_
diff --git a/engine/inc/draco/compression/attributes/points_sequencer.h b/engine/inc/draco/compression/attributes/points_sequencer.h
new file mode 100644
index 00000000..2f4f7e16
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/points_sequencer.h
@@ -0,0 +1,63 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_POINTS_SEQUENCER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_POINTS_SEQUENCER_H_
+
+#include <vector>
+
+#include "draco/attributes/point_attribute.h"
+
+namespace draco {
+
+// Class for generating a sequence of point ids that can be used to encode
+// or decode attribute values in a specific order.
+// See sequential_attribute_encoders/decoders_controller.h for more details.
+class PointsSequencer {
+ public:
+  PointsSequencer() : out_point_ids_(nullptr) {}
+  virtual ~PointsSequencer() = default;
+
+  // Fills the |out_point_ids| with the generated sequence of point ids.
+  bool GenerateSequence(std::vector<PointIndex> *out_point_ids) {
+    out_point_ids_ = out_point_ids;
+    return GenerateSequenceInternal();
+  }
+
+  // Appends a point to the sequence.
+  void AddPointId(PointIndex point_id) { out_point_ids_->push_back(point_id); }
+
+  // Sets the correct mapping between point ids and value ids. I.e., the inverse
+  // of the |out_point_ids|. In general, |out_point_ids_| does not contain
+  // sufficient information to compute the inverse map, because not all point
+  // ids are necessarily contained within the map.
+  // Must be implemented for sequencers that are used by attribute decoders.
+  virtual bool UpdatePointToAttributeIndexMapping(PointAttribute * /* attr */) {
+    return false;
+  }
+
+ protected:
+  // Method that needs to be implemented by the derived classes. The
+  // implementation is responsible for filling |out_point_ids_| with the valid
+  // sequence of point ids.
+  virtual bool GenerateSequenceInternal() = 0;
+  std::vector<PointIndex> *out_point_ids() const { return out_point_ids_; }
+
+ private:
+  std::vector<PointIndex> *out_point_ids_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_POINTS_SEQUENCER_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_decoder.h b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_decoder.h
new file mode 100644
index 00000000..36c124ba
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_decoder.h
@@ -0,0 +1,231 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_CONSTRAINED_MULTI_PARALLELOGRAM_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_CONSTRAINED_MULTI_PARALLELOGRAM_DECODER_H_
+
+#include <algorithm>
+#include <cmath>
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_shared.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h"
+#include "draco/compression/bit_coders/rans_bit_decoder.h"
+#include "draco/core/varint_decoding.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Decoder for predictions encoded with the constrained multi-parallelogram
+// encoder. See the corresponding encoder for more details about the prediction
+// method.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeConstrainedMultiParallelogramDecoder
+    : public MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType =
+      typename PredictionSchemeDecoder<DataTypeT, TransformT>::CorrType;
+  using CornerTable = typename MeshDataT::CornerTable;
+
+  explicit MeshPredictionSchemeConstrainedMultiParallelogramDecoder(
+      const PointAttribute *attribute)
+      : MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT>(
+            attribute),
+        selected_mode_(Mode::OPTIMAL_MULTI_PARALLELOGRAM) {}
+  MeshPredictionSchemeConstrainedMultiParallelogramDecoder(
+      const PointAttribute *attribute, const TransformT &transform,
+      const MeshDataT &mesh_data)
+      : MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data),
+        selected_mode_(Mode::OPTIMAL_MULTI_PARALLELOGRAM) {}
+
+  bool ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                             int size, int num_components,
+                             const PointIndex *entry_to_point_id_map) override;
+
+  bool DecodePredictionData(DecoderBuffer *buffer) override;
+
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM;
+  }
+
+  bool IsInitialized() const override {
+    return this->mesh_data().IsInitialized();
+  }
+
+ private:
+  typedef constrained_multi_parallelogram::Mode Mode;
+  static constexpr int kMaxNumParallelograms =
+      constrained_multi_parallelogram::kMaxNumParallelograms;
+  // Crease edges are used to store whether any given edge should be used for
+  // parallelogram prediction or not. New values are added in the order in which
+  // the edges are processed. For better compression, the flags are stored in
+  // in separate contexts based on the number of available parallelograms at a
+  // given vertex.
+  std::vector<bool> is_crease_edge_[kMaxNumParallelograms];
+  Mode selected_mode_;
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeConstrainedMultiParallelogramDecoder<
+    DataTypeT, TransformT, MeshDataT>::
+    ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                          int /* size */, int num_components,
+                          const PointIndex * /* entry_to_point_id_map */) {
+  this->transform().Init(num_components);
+
+  // Predicted values for all simple parallelograms encountered at any given
+  // vertex.
+  std::vector<DataTypeT> pred_vals[kMaxNumParallelograms];
+  for (int i = 0; i < kMaxNumParallelograms; ++i) {
+    pred_vals[i].resize(num_components, 0);
+  }
+  this->transform().ComputeOriginalValue(pred_vals[0].data(), in_corr,
+                                         out_data);
+
+  const CornerTable *const table = this->mesh_data().corner_table();
+  const std::vector<int32_t> *const vertex_to_data_map =
+      this->mesh_data().vertex_to_data_map();
+
+  // Current position in the |is_crease_edge_| array for each context.
+  std::vector<int> is_crease_edge_pos(kMaxNumParallelograms, 0);
+
+  // Used to store predicted value for multi-parallelogram prediction.
+  std::vector<DataTypeT> multi_pred_vals(num_components);
+
+  const int corner_map_size =
+      static_cast<int>(this->mesh_data().data_to_corner_map()->size());
+  for (int p = 1; p < corner_map_size; ++p) {
+    const CornerIndex start_corner_id =
+        this->mesh_data().data_to_corner_map()->at(p);
+
+    CornerIndex corner_id(start_corner_id);
+    int num_parallelograms = 0;
+    bool first_pass = true;
+    while (corner_id != kInvalidCornerIndex) {
+      if (ComputeParallelogramPrediction(
+              p, corner_id, table, *vertex_to_data_map, out_data,
+              num_components, &(pred_vals[num_parallelograms][0]))) {
+        // Parallelogram prediction applied and stored in
+        // |pred_vals[num_parallelograms]|
+        ++num_parallelograms;
+        // Stop processing when we reach the maximum number of allowed
+        // parallelograms.
+        if (num_parallelograms == kMaxNumParallelograms) {
+          break;
+        }
+      }
+
+      // Proceed to the next corner attached to the vertex. First swing left
+      // and if we reach a boundary, swing right from the start corner.
+      if (first_pass) {
+        corner_id = table->SwingLeft(corner_id);
+      } else {
+        corner_id = table->SwingRight(corner_id);
+      }
+      if (corner_id == start_corner_id) {
+        break;
+      }
+      if (corner_id == kInvalidCornerIndex && first_pass) {
+        first_pass = false;
+        corner_id = table->SwingRight(start_corner_id);
+      }
+    }
+
+    // Check which of the available parallelograms are actually used and compute
+    // the final predicted value.
+    int num_used_parallelograms = 0;
+    if (num_parallelograms > 0) {
+      for (int i = 0; i < num_components; ++i) {
+        multi_pred_vals[i] = 0;
+      }
+      // Check which parallelograms are actually used.
+      for (int i = 0; i < num_parallelograms; ++i) {
+        const int context = num_parallelograms - 1;
+        const int pos = is_crease_edge_pos[context]++;
+        if (is_crease_edge_[context].size() <= pos) {
+          return false;
+        }
+        const bool is_crease = is_crease_edge_[context][pos];
+        if (!is_crease) {
+          ++num_used_parallelograms;
+          for (int j = 0; j < num_components; ++j) {
+            multi_pred_vals[j] += pred_vals[i][j];
+          }
+        }
+      }
+    }
+    const int dst_offset = p * num_components;
+    if (num_used_parallelograms == 0) {
+      // No parallelogram was valid.
+      // We use the last decoded point as a reference.
+      const int src_offset = (p - 1) * num_components;
+      this->transform().ComputeOriginalValue(
+          out_data + src_offset, in_corr + dst_offset, out_data + dst_offset);
+    } else {
+      // Compute the correction from the predicted value.
+      for (int c = 0; c < num_components; ++c) {
+        multi_pred_vals[c] /= num_used_parallelograms;
+      }
+      this->transform().ComputeOriginalValue(
+          multi_pred_vals.data(), in_corr + dst_offset, out_data + dst_offset);
+    }
+  }
+  return true;
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeConstrainedMultiParallelogramDecoder<
+    DataTypeT, TransformT, MeshDataT>::DecodePredictionData(DecoderBuffer
+                                                                *buffer) {
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (buffer->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+    // Decode prediction mode.
+    uint8_t mode;
+    if (!buffer->Decode(&mode)) {
+      return false;
+    }
+
+    if (mode != Mode::OPTIMAL_MULTI_PARALLELOGRAM) {
+      // Unsupported mode.
+      return false;
+    }
+  }
+#endif
+
+  // Encode selected edges using separate rans bit coder for each context.
+  for (int i = 0; i < kMaxNumParallelograms; ++i) {
+    uint32_t num_flags;
+    if (!DecodeVarint<uint32_t>(&num_flags, buffer)) {
+      return false;
+    }
+    if (num_flags > 0) {
+      is_crease_edge_[i].resize(num_flags);
+      RAnsBitDecoder decoder;
+      if (!decoder.StartDecoding(buffer)) {
+        return false;
+      }
+      for (uint32_t j = 0; j < num_flags; ++j) {
+        is_crease_edge_[i][j] = decoder.DecodeNextBit();
+      }
+      decoder.EndDecoding();
+    }
+  }
+  return MeshPredictionSchemeDecoder<DataTypeT, TransformT,
+                                     MeshDataT>::DecodePredictionData(buffer);
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_CONSTRAINED_MULTI_PARALLELOGRAM_DECODER_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_encoder.h b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_encoder.h
new file mode 100644
index 00000000..77df8ee2
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_encoder.h
@@ -0,0 +1,414 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_CONSTRAINED_MULTI_PARALLELOGRAM_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_CONSTRAINED_MULTI_PARALLELOGRAM_ENCODER_H_
+
+#include <algorithm>
+#include <cmath>
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_shared.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h"
+#include "draco/compression/bit_coders/rans_bit_encoder.h"
+#include "draco/compression/entropy/shannon_entropy.h"
+#include "draco/core/varint_encoding.h"
+
+namespace draco {
+
+// Compared to standard multi-parallelogram, constrained multi-parallelogram can
+// explicitly select which of the available parallelograms are going to be used
+// for the prediction by marking crease edges between two triangles. This
+// requires storing extra data, but it allows the predictor to avoid using
+// parallelograms that would lead to poor predictions. For improved efficiency,
+// our current implementation limits the maximum number of used parallelograms
+// to four, which covers >95% of the cases (on average, there are only two
+// parallelograms available for any given vertex).
+// All bits of the explicitly chosen configuration are stored together in a
+// single context chosen by the total number of parallelograms available to
+// choose from.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeConstrainedMultiParallelogramEncoder
+    : public MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType =
+      typename PredictionSchemeEncoder<DataTypeT, TransformT>::CorrType;
+  using CornerTable = typename MeshDataT::CornerTable;
+
+  explicit MeshPredictionSchemeConstrainedMultiParallelogramEncoder(
+      const PointAttribute *attribute)
+      : MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT>(
+            attribute),
+        selected_mode_(Mode::OPTIMAL_MULTI_PARALLELOGRAM) {}
+  MeshPredictionSchemeConstrainedMultiParallelogramEncoder(
+      const PointAttribute *attribute, const TransformT &transform,
+      const MeshDataT &mesh_data)
+      : MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data),
+        selected_mode_(Mode::OPTIMAL_MULTI_PARALLELOGRAM) {}
+
+  bool ComputeCorrectionValues(
+      const DataTypeT *in_data, CorrType *out_corr, int size,
+      int num_components, const PointIndex *entry_to_point_id_map) override;
+
+  bool EncodePredictionData(EncoderBuffer *buffer) override;
+
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM;
+  }
+
+  bool IsInitialized() const override {
+    return this->mesh_data().IsInitialized();
+  }
+
+ private:
+  // Function used to compute number of bits needed to store overhead of the
+  // predictor. In this case, we consider overhead to be all bits that mark
+  // whether a parallelogram should be used for prediction or not. The input
+  // to this method is the total number of parallelograms that were evaluated so
+  // far(total_parallelogram), and the number of parallelograms we decided to
+  // use for prediction (total_used_parallelograms).
+  // Returns number of bits required to store the overhead.
+  int64_t ComputeOverheadBits(int64_t total_used_parallelograms,
+                              int64_t total_parallelogram) const {
+    // For now we assume RAns coding for the bits where the total required size
+    // is directly correlated to the binary entropy of the input stream.
+    // TODO(ostava): This should be generalized in case we use other binary
+    // coding scheme.
+    const double entropy = ComputeBinaryShannonEntropy(
+        static_cast<uint32_t>(total_parallelogram),
+        static_cast<uint32_t>(total_used_parallelograms));
+
+    // Round up to the nearest full bit.
+    return static_cast<int64_t>(
+        ceil(static_cast<double>(total_parallelogram) * entropy));
+  }
+
+  // Struct that contains data used for measuring the error of each available
+  // parallelogram configuration.
+  struct Error {
+    Error() : num_bits(0), residual_error(0) {}
+
+    // Primary metric: number of bits required to store the data as a result of
+    // the selected prediction configuration.
+    int num_bits;
+    // Secondary metric: absolute difference of residuals for the given
+    // configuration.
+    int residual_error;
+
+    bool operator<(const Error &e) const {
+      if (num_bits < e.num_bits) {
+        return true;
+      }
+      if (num_bits > e.num_bits) {
+        return false;
+      }
+      return residual_error < e.residual_error;
+    }
+  };
+
+  // Computes error for predicting |predicted_val| instead of |actual_val|.
+  // Error is computed as the number of bits needed to encode the difference
+  // between the values.
+  Error ComputeError(const DataTypeT *predicted_val,
+                     const DataTypeT *actual_val, int *out_residuals,
+                     int num_components) {
+    Error error;
+
+    for (int i = 0; i < num_components; ++i) {
+      const int dif = (predicted_val[i] - actual_val[i]);
+      error.residual_error += std::abs(dif);
+      out_residuals[i] = dif;
+      // Entropy needs unsigned symbols, so convert the signed difference to an
+      // unsigned symbol.
+      entropy_symbols_[i] = ConvertSignedIntToSymbol(dif);
+    }
+
+    // Generate entropy data for case that this configuration was used.
+    // Note that the entropy stream is NOT updated in this case.
+    const auto entropy_data =
+        entropy_tracker_.Peek(entropy_symbols_.data(), num_components);
+
+    error.num_bits = entropy_tracker_.GetNumberOfDataBits(entropy_data) +
+                     entropy_tracker_.GetNumberOfRAnsTableBits(entropy_data);
+    return error;
+  }
+
+  typedef constrained_multi_parallelogram::Mode Mode;
+  static constexpr int kMaxNumParallelograms =
+      constrained_multi_parallelogram::kMaxNumParallelograms;
+  // Crease edges are used to store whether any given edge should be used for
+  // parallelogram prediction or not. New values are added in the order in which
+  // the edges are processed. For better compression, the flags are stored in
+  // in separate contexts based on the number of available parallelograms at a
+  // given vertex.
+  // TODO(draco-eng) reconsider std::vector<bool> (performance/space).
+  std::vector<bool> is_crease_edge_[kMaxNumParallelograms];
+  Mode selected_mode_;
+
+  ShannonEntropyTracker entropy_tracker_;
+
+  // Temporary storage for symbols that are fed into the |entropy_stream|.
+  // Always contains only |num_components| entries.
+  std::vector<uint32_t> entropy_symbols_;
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeConstrainedMultiParallelogramEncoder<
+    DataTypeT, TransformT, MeshDataT>::
+    ComputeCorrectionValues(const DataTypeT *in_data, CorrType *out_corr,
+                            int size, int num_components,
+                            const PointIndex * /* entry_to_point_id_map */) {
+  this->transform().Init(in_data, size, num_components);
+  const CornerTable *const table = this->mesh_data().corner_table();
+  const std::vector<int32_t> *const vertex_to_data_map =
+      this->mesh_data().vertex_to_data_map();
+
+  // Predicted values for all simple parallelograms encountered at any given
+  // vertex.
+  std::vector<DataTypeT> pred_vals[kMaxNumParallelograms];
+  for (int i = 0; i < kMaxNumParallelograms; ++i) {
+    pred_vals[i].resize(num_components);
+  }
+  // Used to store predicted value for various multi-parallelogram predictions
+  // (combinations of simple parallelogram predictions).
+  std::vector<DataTypeT> multi_pred_vals(num_components);
+  entropy_symbols_.resize(num_components);
+
+  // Struct for holding data about prediction configuration for different sets
+  // of used parallelograms.
+  struct PredictionConfiguration {
+    PredictionConfiguration()
+        : error(), configuration(0), num_used_parallelograms(0) {}
+    Error error;
+    uint8_t configuration;  // Bitfield, 1 use parallelogram, 0 don't use it.
+    int num_used_parallelograms;
+    std::vector<DataTypeT> predicted_value;
+    std::vector<int32_t> residuals;
+  };
+
+  // Bit-field used for computing permutations of excluded edges
+  // (parallelograms).
+  bool exluded_parallelograms[kMaxNumParallelograms];
+
+  // Data about the number of used parallelogram and total number of available
+  // parallelogram for each context. Used to compute overhead needed for storing
+  // the parallelogram choices made by the encoder.
+  int64_t total_used_parallelograms[kMaxNumParallelograms] = {0};
+  int64_t total_parallelograms[kMaxNumParallelograms] = {0};
+
+  std::vector<int> current_residuals(num_components);
+
+  // We start processing the vertices from the end because this prediction uses
+  // data from previous entries that could be overwritten when an entry is
+  // processed.
+  for (int p =
+           static_cast<int>(this->mesh_data().data_to_corner_map()->size()) - 1;
+       p > 0; --p) {
+    const CornerIndex start_corner_id =
+        this->mesh_data().data_to_corner_map()->at(p);
+
+    // Go over all corners attached to the vertex and compute the predicted
+    // value from the parallelograms defined by their opposite faces.
+    CornerIndex corner_id(start_corner_id);
+    int num_parallelograms = 0;
+    bool first_pass = true;
+    while (corner_id != kInvalidCornerIndex) {
+      if (ComputeParallelogramPrediction(
+              p, corner_id, table, *vertex_to_data_map, in_data, num_components,
+              &(pred_vals[num_parallelograms][0]))) {
+        // Parallelogram prediction applied and stored in
+        // |pred_vals[num_parallelograms]|
+        ++num_parallelograms;
+        // Stop processing when we reach the maximum number of allowed
+        // parallelograms.
+        if (num_parallelograms == kMaxNumParallelograms) {
+          break;
+        }
+      }
+
+      // Proceed to the next corner attached to the vertex. First swing left
+      // and if we reach a boundary, swing right from the start corner.
+      if (first_pass) {
+        corner_id = table->SwingLeft(corner_id);
+      } else {
+        corner_id = table->SwingRight(corner_id);
+      }
+      if (corner_id == start_corner_id) {
+        break;
+      }
+      if (corner_id == kInvalidCornerIndex && first_pass) {
+        first_pass = false;
+        corner_id = table->SwingRight(start_corner_id);
+      }
+    }
+
+    // Offset to the target (destination) vertex.
+    const int dst_offset = p * num_components;
+    Error error;
+
+    // Compute all prediction errors for all possible configurations of
+    // available parallelograms.
+
+    // Variable for holding the best configuration that has been found so far.
+    PredictionConfiguration best_prediction;
+
+    // Compute delta coding error (configuration when no parallelogram is
+    // selected).
+    const int src_offset = (p - 1) * num_components;
+    error = ComputeError(in_data + src_offset, in_data + dst_offset,
+                         &current_residuals[0], num_components);
+
+    if (num_parallelograms > 0) {
+      total_parallelograms[num_parallelograms - 1] += num_parallelograms;
+      const int64_t new_overhead_bits =
+          ComputeOverheadBits(total_used_parallelograms[num_parallelograms - 1],
+                              total_parallelograms[num_parallelograms - 1]);
+      error.num_bits += new_overhead_bits;
+    }
+
+    best_prediction.error = error;
+    best_prediction.configuration = 0;
+    best_prediction.num_used_parallelograms = 0;
+    best_prediction.predicted_value.assign(
+        in_data + src_offset, in_data + src_offset + num_components);
+    best_prediction.residuals.assign(current_residuals.begin(),
+                                     current_residuals.end());
+
+    // Compute prediction error for different cases of used parallelograms.
+    for (int num_used_parallelograms = 1;
+         num_used_parallelograms <= num_parallelograms;
+         ++num_used_parallelograms) {
+      // Mark all parallelograms as excluded.
+      std::fill(exluded_parallelograms,
+                exluded_parallelograms + num_parallelograms, true);
+      // TODO(draco-eng) maybe this should be another std::fill.
+      // Mark the first |num_used_parallelograms| as not excluded.
+      for (int j = 0; j < num_used_parallelograms; ++j) {
+        exluded_parallelograms[j] = false;
+      }
+      // Permute over the excluded edges and compute error for each
+      // configuration (permutation of excluded parallelograms).
+      do {
+        // Reset the multi-parallelogram predicted values.
+        for (int j = 0; j < num_components; ++j) {
+          multi_pred_vals[j] = 0;
+        }
+        uint8_t configuration = 0;
+        for (int j = 0; j < num_parallelograms; ++j) {
+          if (exluded_parallelograms[j]) {
+            continue;
+          }
+          for (int c = 0; c < num_components; ++c) {
+            multi_pred_vals[c] += pred_vals[j][c];
+          }
+          // Set jth bit of the configuration.
+          configuration |= (1 << j);
+        }
+
+        for (int j = 0; j < num_components; ++j) {
+          multi_pred_vals[j] /= num_used_parallelograms;
+        }
+        error = ComputeError(multi_pred_vals.data(), in_data + dst_offset,
+                             &current_residuals[0], num_components);
+        if (num_parallelograms > 0) {
+          const int64_t new_overhead_bits = ComputeOverheadBits(
+              total_used_parallelograms[num_parallelograms - 1] +
+                  num_used_parallelograms,
+              total_parallelograms[num_parallelograms - 1]);
+
+          // Add overhead bits to the total error.
+          error.num_bits += new_overhead_bits;
+        }
+        if (error < best_prediction.error) {
+          best_prediction.error = error;
+          best_prediction.configuration = configuration;
+          best_prediction.num_used_parallelograms = num_used_parallelograms;
+          best_prediction.predicted_value.assign(multi_pred_vals.begin(),
+                                                 multi_pred_vals.end());
+          best_prediction.residuals.assign(current_residuals.begin(),
+                                           current_residuals.end());
+        }
+      } while (std::next_permutation(
+          exluded_parallelograms, exluded_parallelograms + num_parallelograms));
+    }
+    if (num_parallelograms > 0) {
+      total_used_parallelograms[num_parallelograms - 1] +=
+          best_prediction.num_used_parallelograms;
+    }
+
+    // Update the entropy stream by adding selected residuals as symbols to the
+    // stream.
+    for (int i = 0; i < num_components; ++i) {
+      entropy_symbols_[i] =
+          ConvertSignedIntToSymbol(best_prediction.residuals[i]);
+    }
+    entropy_tracker_.Push(entropy_symbols_.data(), num_components);
+
+    for (int i = 0; i < num_parallelograms; ++i) {
+      if ((best_prediction.configuration & (1 << i)) == 0) {
+        // Parallelogram not used, mark the edge as crease.
+        is_crease_edge_[num_parallelograms - 1].push_back(true);
+      } else {
+        // Parallelogram used. Add it to the predicted value and mark the
+        // edge as not a crease.
+        is_crease_edge_[num_parallelograms - 1].push_back(false);
+      }
+    }
+    this->transform().ComputeCorrection(in_data + dst_offset,
+                                        best_prediction.predicted_value.data(),
+                                        out_corr + dst_offset);
+  }
+  // First element is always fixed because it cannot be predicted.
+  for (int i = 0; i < num_components; ++i) {
+    pred_vals[0][i] = static_cast<DataTypeT>(0);
+  }
+  this->transform().ComputeCorrection(in_data, pred_vals[0].data(), out_corr);
+  return true;
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeConstrainedMultiParallelogramEncoder<
+    DataTypeT, TransformT, MeshDataT>::EncodePredictionData(EncoderBuffer
+                                                                *buffer) {
+  // Encode selected edges using separate rans bit coder for each context.
+  for (int i = 0; i < kMaxNumParallelograms; ++i) {
+    // |i| is the context based on the number of available parallelograms, which
+    // is always equal to |i + 1|.
+    const int num_used_parallelograms = i + 1;
+    EncodeVarint<uint32_t>(is_crease_edge_[i].size(), buffer);
+    if (is_crease_edge_[i].size()) {
+      RAnsBitEncoder encoder;
+      encoder.StartEncoding();
+      // Encode the crease edge flags in the reverse vertex order that is needed
+      // be the decoder. Note that for the currently supported mode, each vertex
+      // has exactly |num_used_parallelograms| edges that need to be encoded.
+      for (int j = static_cast<int>(is_crease_edge_[i].size()) -
+                   num_used_parallelograms;
+           j >= 0; j -= num_used_parallelograms) {
+        // Go over all edges of the current vertex.
+        for (int k = 0; k < num_used_parallelograms; ++k) {
+          encoder.EncodeBit(is_crease_edge_[i][j + k]);
+        }
+      }
+      encoder.EndEncoding(buffer);
+    }
+  }
+  return MeshPredictionSchemeEncoder<DataTypeT, TransformT,
+                                     MeshDataT>::EncodePredictionData(buffer);
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_CONSTRAINED_MULTI_PARALLELOGRAM_ENCODER_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_shared.h b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_shared.h
new file mode 100644
index 00000000..c7a4e351
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_shared.h
@@ -0,0 +1,34 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_CONSTRAINED_MULTI_PARALLELOGRAM_SHARED_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_CONSTRAINED_MULTI_PARALLELOGRAM_SHARED_H_
+
+namespace draco {
+
+// Data shared between constrained multi-parallelogram encoder and decoder.
+namespace constrained_multi_parallelogram {
+
+enum Mode {
+  // Selects the optimal multi-parallelogram from up to 4 available
+  // parallelograms.
+  OPTIMAL_MULTI_PARALLELOGRAM = 0,
+};
+
+static constexpr int kMaxNumParallelograms = 4;
+
+}  // namespace constrained_multi_parallelogram
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_CONSTRAINED_MULTI_PARALLELOGRAM_SHARED_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_data.h b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_data.h
new file mode 100644
index 00000000..2960a5e7
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_data.h
@@ -0,0 +1,72 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_DATA_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_DATA_H_
+
+#include "draco/mesh/corner_table.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Class stores data about the connectivity data of the mesh and information
+// about how the connectivity was encoded/decoded.
+template <class CornerTableT>
+class MeshPredictionSchemeData {
+ public:
+  typedef CornerTableT CornerTable;
+  MeshPredictionSchemeData()
+      : mesh_(nullptr),
+        corner_table_(nullptr),
+        vertex_to_data_map_(nullptr),
+        data_to_corner_map_(nullptr) {}
+
+  void Set(const Mesh *mesh, const CornerTable *table,
+           const std::vector<CornerIndex> *data_to_corner_map,
+           const std::vector<int32_t> *vertex_to_data_map) {
+    mesh_ = mesh;
+    corner_table_ = table;
+    data_to_corner_map_ = data_to_corner_map;
+    vertex_to_data_map_ = vertex_to_data_map;
+  }
+
+  const Mesh *mesh() const { return mesh_; }
+  const CornerTable *corner_table() const { return corner_table_; }
+  const std::vector<int32_t> *vertex_to_data_map() const {
+    return vertex_to_data_map_;
+  }
+  const std::vector<CornerIndex> *data_to_corner_map() const {
+    return data_to_corner_map_;
+  }
+  bool IsInitialized() const {
+    return mesh_ != nullptr && corner_table_ != nullptr &&
+           vertex_to_data_map_ != nullptr && data_to_corner_map_ != nullptr;
+  }
+
+ private:
+  const Mesh *mesh_;
+  const CornerTable *corner_table_;
+
+  // Mapping between vertices and their encoding order. I.e. when an attribute
+  // entry on a given vertex was encoded.
+  const std::vector<int32_t> *vertex_to_data_map_;
+
+  // Array that stores which corner was processed when a given attribute entry
+  // was encoded or decoded.
+  const std::vector<CornerIndex> *data_to_corner_map_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_DATA_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h
new file mode 100644
index 00000000..6694a981
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h
@@ -0,0 +1,46 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_DECODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_data.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_decoder.h"
+
+namespace draco {
+
+// Base class for all mesh prediction scheme decoders that use the mesh
+// connectivity data. |MeshDataT| can be any class that provides the same
+// interface as the PredictionSchemeMeshData class.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeDecoder
+    : public PredictionSchemeDecoder<DataTypeT, TransformT> {
+ public:
+  typedef MeshDataT MeshData;
+  MeshPredictionSchemeDecoder(const PointAttribute *attribute,
+                              const TransformT &transform,
+                              const MeshDataT &mesh_data)
+      : PredictionSchemeDecoder<DataTypeT, TransformT>(attribute, transform),
+        mesh_data_(mesh_data) {}
+
+ protected:
+  const MeshData &mesh_data() const { return mesh_data_; }
+
+ private:
+  MeshData mesh_data_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_DECODER_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h
new file mode 100644
index 00000000..ab3c81a3
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h
@@ -0,0 +1,46 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_ENCODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_data.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_encoder.h"
+
+namespace draco {
+
+// Base class for all mesh prediction scheme encoders that use the mesh
+// connectivity data. |MeshDataT| can be any class that provides the same
+// interface as the PredictionSchemeMeshData class.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeEncoder
+    : public PredictionSchemeEncoder<DataTypeT, TransformT> {
+ public:
+  typedef MeshDataT MeshData;
+  MeshPredictionSchemeEncoder(const PointAttribute *attribute,
+                              const TransformT &transform,
+                              const MeshDataT &mesh_data)
+      : PredictionSchemeEncoder<DataTypeT, TransformT>(attribute, transform),
+        mesh_data_(mesh_data) {}
+
+ protected:
+  const MeshData &mesh_data() const { return mesh_data_; }
+
+ private:
+  MeshData mesh_data_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_ENCODER_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_decoder.h b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_decoder.h
new file mode 100644
index 00000000..da1387a3
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_decoder.h
@@ -0,0 +1,172 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_DECODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_area.h"
+#include "draco/compression/bit_coders/rans_bit_decoder.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// See MeshPredictionSchemeGeometricNormalEncoder for documentation.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeGeometricNormalDecoder
+    : public MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType = typename MeshPredictionSchemeDecoder<DataTypeT, TransformT,
+                                                        MeshDataT>::CorrType;
+  MeshPredictionSchemeGeometricNormalDecoder(const PointAttribute *attribute,
+                                             const TransformT &transform,
+                                             const MeshDataT &mesh_data)
+      : MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data),
+        predictor_(mesh_data) {}
+
+ private:
+  MeshPredictionSchemeGeometricNormalDecoder() {}
+
+ public:
+  bool ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                             int size, int num_components,
+                             const PointIndex *entry_to_point_id_map) override;
+
+  bool DecodePredictionData(DecoderBuffer *buffer) override;
+
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_GEOMETRIC_NORMAL;
+  }
+
+  bool IsInitialized() const override {
+    if (!predictor_.IsInitialized()) {
+      return false;
+    }
+    if (!this->mesh_data().IsInitialized()) {
+      return false;
+    }
+    if (!octahedron_tool_box_.IsInitialized()) {
+      return false;
+    }
+    return true;
+  }
+
+  int GetNumParentAttributes() const override { return 1; }
+
+  GeometryAttribute::Type GetParentAttributeType(int i) const override {
+    DRACO_DCHECK_EQ(i, 0);
+    (void)i;
+    return GeometryAttribute::POSITION;
+  }
+
+  bool SetParentAttribute(const PointAttribute *att) override {
+    if (att->attribute_type() != GeometryAttribute::POSITION) {
+      return false;  // Invalid attribute type.
+    }
+    if (att->num_components() != 3) {
+      return false;  // Currently works only for 3 component positions.
+    }
+    predictor_.SetPositionAttribute(*att);
+    return true;
+  }
+  void SetQuantizationBits(int q) {
+    octahedron_tool_box_.SetQuantizationBits(q);
+  }
+
+ private:
+  MeshPredictionSchemeGeometricNormalPredictorArea<DataTypeT, TransformT,
+                                                   MeshDataT>
+      predictor_;
+  OctahedronToolBox octahedron_tool_box_;
+  RAnsBitDecoder flip_normal_bit_decoder_;
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeGeometricNormalDecoder<
+    DataTypeT, TransformT,
+    MeshDataT>::ComputeOriginalValues(const CorrType *in_corr,
+                                      DataTypeT *out_data, int /* size */,
+                                      int num_components,
+                                      const PointIndex *entry_to_point_id_map) {
+  this->SetQuantizationBits(this->transform().quantization_bits());
+  predictor_.SetEntryToPointIdMap(entry_to_point_id_map);
+  DRACO_DCHECK(this->IsInitialized());
+
+  // Expecting in_data in octahedral coordinates, i.e., portable attribute.
+  DRACO_DCHECK_EQ(num_components, 2);
+
+  const int corner_map_size =
+      static_cast<int>(this->mesh_data().data_to_corner_map()->size());
+
+  VectorD<int32_t, 3> pred_normal_3d;
+  int32_t pred_normal_oct[2];
+
+  for (int data_id = 0; data_id < corner_map_size; ++data_id) {
+    const CornerIndex corner_id =
+        this->mesh_data().data_to_corner_map()->at(data_id);
+    predictor_.ComputePredictedValue(corner_id, pred_normal_3d.data());
+
+    // Compute predicted octahedral coordinates.
+    octahedron_tool_box_.CanonicalizeIntegerVector(pred_normal_3d.data());
+    DRACO_DCHECK_EQ(pred_normal_3d.AbsSum(),
+                    octahedron_tool_box_.center_value());
+    if (flip_normal_bit_decoder_.DecodeNextBit()) {
+      pred_normal_3d = -pred_normal_3d;
+    }
+    octahedron_tool_box_.IntegerVectorToQuantizedOctahedralCoords(
+        pred_normal_3d.data(), pred_normal_oct, pred_normal_oct + 1);
+
+    const int data_offset = data_id * 2;
+    this->transform().ComputeOriginalValue(
+        pred_normal_oct, in_corr + data_offset, out_data + data_offset);
+  }
+  flip_normal_bit_decoder_.EndDecoding();
+  return true;
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeGeometricNormalDecoder<
+    DataTypeT, TransformT, MeshDataT>::DecodePredictionData(DecoderBuffer
+                                                                *buffer) {
+  // Get data needed for transform
+  if (!this->transform().DecodeTransformData(buffer)) {
+    return false;
+  }
+
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (buffer->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+    uint8_t prediction_mode;
+    if (!buffer->Decode(&prediction_mode)) {
+      return false;
+    }
+
+    if (!predictor_.SetNormalPredictionMode(
+            NormalPredictionMode(prediction_mode))) {
+      return false;
+    }
+  }
+#endif
+
+  // Init normal flips.
+  if (!flip_normal_bit_decoder_.StartDecoding(buffer)) {
+    return false;
+  }
+
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_DECODER_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_encoder.h b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_encoder.h
new file mode 100644
index 00000000..cf146f83
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_encoder.h
@@ -0,0 +1,180 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_ENCODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_area.h"
+#include "draco/compression/bit_coders/rans_bit_encoder.h"
+#include "draco/compression/config/compression_shared.h"
+
+namespace draco {
+
+// Prediction scheme for normals based on the underlying geometry.
+// At a smooth vertices normals are computed by weighting the normals of
+// adjacent faces with the area of these faces. At seams, the same approach
+// applies for seam corners.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeGeometricNormalEncoder
+    : public MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType = typename MeshPredictionSchemeEncoder<DataTypeT, TransformT,
+                                                        MeshDataT>::CorrType;
+  MeshPredictionSchemeGeometricNormalEncoder(const PointAttribute *attribute,
+                                             const TransformT &transform,
+                                             const MeshDataT &mesh_data)
+      : MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data),
+        predictor_(mesh_data) {}
+
+  bool ComputeCorrectionValues(
+      const DataTypeT *in_data, CorrType *out_corr, int size,
+      int num_components, const PointIndex *entry_to_point_id_map) override;
+
+  bool EncodePredictionData(EncoderBuffer *buffer) override;
+
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_GEOMETRIC_NORMAL;
+  }
+
+  bool IsInitialized() const override {
+    if (!predictor_.IsInitialized()) {
+      return false;
+    }
+    if (!this->mesh_data().IsInitialized()) {
+      return false;
+    }
+    return true;
+  }
+
+  int GetNumParentAttributes() const override { return 1; }
+
+  GeometryAttribute::Type GetParentAttributeType(int i) const override {
+    DRACO_DCHECK_EQ(i, 0);
+    (void)i;
+    return GeometryAttribute::POSITION;
+  }
+
+  bool SetParentAttribute(const PointAttribute *att) override {
+    if (att->attribute_type() != GeometryAttribute::POSITION) {
+      return false;  // Invalid attribute type.
+    }
+    if (att->num_components() != 3) {
+      return false;  // Currently works only for 3 component positions.
+    }
+    predictor_.SetPositionAttribute(*att);
+    return true;
+  }
+
+ private:
+  void SetQuantizationBits(int q) {
+    DRACO_DCHECK_GE(q, 2);
+    DRACO_DCHECK_LE(q, 30);
+    octahedron_tool_box_.SetQuantizationBits(q);
+  }
+  MeshPredictionSchemeGeometricNormalPredictorArea<DataTypeT, TransformT,
+                                                   MeshDataT>
+      predictor_;
+
+  OctahedronToolBox octahedron_tool_box_;
+  RAnsBitEncoder flip_normal_bit_encoder_;
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeGeometricNormalEncoder<DataTypeT, TransformT,
+                                                MeshDataT>::
+    ComputeCorrectionValues(const DataTypeT *in_data, CorrType *out_corr,
+                            int size, int num_components,
+                            const PointIndex *entry_to_point_id_map) {
+  this->SetQuantizationBits(this->transform().quantization_bits());
+  predictor_.SetEntryToPointIdMap(entry_to_point_id_map);
+  DRACO_DCHECK(this->IsInitialized());
+  // Expecting in_data in octahedral coordinates, i.e., portable attribute.
+  DRACO_DCHECK_EQ(num_components, 2);
+
+  flip_normal_bit_encoder_.StartEncoding();
+
+  const int corner_map_size =
+      static_cast<int>(this->mesh_data().data_to_corner_map()->size());
+
+  VectorD<int32_t, 3> pred_normal_3d;
+  VectorD<int32_t, 2> pos_pred_normal_oct;
+  VectorD<int32_t, 2> neg_pred_normal_oct;
+  VectorD<int32_t, 2> pos_correction;
+  VectorD<int32_t, 2> neg_correction;
+  for (int data_id = 0; data_id < corner_map_size; ++data_id) {
+    const CornerIndex corner_id =
+        this->mesh_data().data_to_corner_map()->at(data_id);
+    predictor_.ComputePredictedValue(corner_id, pred_normal_3d.data());
+
+    // Compute predicted octahedral coordinates.
+    octahedron_tool_box_.CanonicalizeIntegerVector(pred_normal_3d.data());
+    DRACO_DCHECK_EQ(pred_normal_3d.AbsSum(),
+                    octahedron_tool_box_.center_value());
+
+    // Compute octahedral coordinates for both possible directions.
+    octahedron_tool_box_.IntegerVectorToQuantizedOctahedralCoords(
+        pred_normal_3d.data(), pos_pred_normal_oct.data(),
+        pos_pred_normal_oct.data() + 1);
+    pred_normal_3d = -pred_normal_3d;
+    octahedron_tool_box_.IntegerVectorToQuantizedOctahedralCoords(
+        pred_normal_3d.data(), neg_pred_normal_oct.data(),
+        neg_pred_normal_oct.data() + 1);
+
+    // Choose the one with the best correction value.
+    const int data_offset = data_id * 2;
+    this->transform().ComputeCorrection(in_data + data_offset,
+                                        pos_pred_normal_oct.data(),
+                                        pos_correction.data());
+    this->transform().ComputeCorrection(in_data + data_offset,
+                                        neg_pred_normal_oct.data(),
+                                        neg_correction.data());
+    pos_correction[0] = octahedron_tool_box_.ModMax(pos_correction[0]);
+    pos_correction[1] = octahedron_tool_box_.ModMax(pos_correction[1]);
+    neg_correction[0] = octahedron_tool_box_.ModMax(neg_correction[0]);
+    neg_correction[1] = octahedron_tool_box_.ModMax(neg_correction[1]);
+    if (pos_correction.AbsSum() < neg_correction.AbsSum()) {
+      flip_normal_bit_encoder_.EncodeBit(false);
+      (out_corr + data_offset)[0] =
+          octahedron_tool_box_.MakePositive(pos_correction[0]);
+      (out_corr + data_offset)[1] =
+          octahedron_tool_box_.MakePositive(pos_correction[1]);
+    } else {
+      flip_normal_bit_encoder_.EncodeBit(true);
+      (out_corr + data_offset)[0] =
+          octahedron_tool_box_.MakePositive(neg_correction[0]);
+      (out_corr + data_offset)[1] =
+          octahedron_tool_box_.MakePositive(neg_correction[1]);
+    }
+  }
+  return true;
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeGeometricNormalEncoder<
+    DataTypeT, TransformT, MeshDataT>::EncodePredictionData(EncoderBuffer
+                                                                *buffer) {
+  if (!this->transform().EncodeTransformData(buffer)) {
+    return false;
+  }
+
+  // Encode normal flips.
+  flip_normal_bit_encoder_.EndEncoding(buffer);
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_ENCODER_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_area.h b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_area.h
new file mode 100644
index 00000000..775eded6
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_area.h
@@ -0,0 +1,117 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_PREDICTOR_AREA_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_PREDICTOR_AREA_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_base.h"
+
+namespace draco {
+
+// This predictor estimates the normal via the surrounding triangles of the
+// given corner. Triangles are weighted according to their area.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeGeometricNormalPredictorArea
+    : public MeshPredictionSchemeGeometricNormalPredictorBase<
+          DataTypeT, TransformT, MeshDataT> {
+  typedef MeshPredictionSchemeGeometricNormalPredictorBase<
+      DataTypeT, TransformT, MeshDataT>
+      Base;
+
+ public:
+  explicit MeshPredictionSchemeGeometricNormalPredictorArea(const MeshDataT &md)
+      : Base(md) {
+    this->SetNormalPredictionMode(TRIANGLE_AREA);
+  };
+  virtual ~MeshPredictionSchemeGeometricNormalPredictorArea() {}
+
+  // Computes predicted octahedral coordinates on a given corner.
+  void ComputePredictedValue(CornerIndex corner_id,
+                             DataTypeT *prediction) override {
+    DRACO_DCHECK(this->IsInitialized());
+    typedef typename MeshDataT::CornerTable CornerTable;
+    const CornerTable *const corner_table = this->mesh_data_.corner_table();
+    // Going to compute the predicted normal from the surrounding triangles
+    // according to the connectivity of the given corner table.
+    VertexCornersIterator<CornerTable> cit(corner_table, corner_id);
+    // Position of central vertex does not change in loop.
+    const VectorD<int64_t, 3> pos_cent = this->GetPositionForCorner(corner_id);
+    // Computing normals for triangles and adding them up.
+
+    VectorD<int64_t, 3> normal;
+    CornerIndex c_next, c_prev;
+    while (!cit.End()) {
+      // Getting corners.
+      if (this->normal_prediction_mode_ == ONE_TRIANGLE) {
+        c_next = corner_table->Next(corner_id);
+        c_prev = corner_table->Previous(corner_id);
+      } else {
+        c_next = corner_table->Next(cit.Corner());
+        c_prev = corner_table->Previous(cit.Corner());
+      }
+      const VectorD<int64_t, 3> pos_next = this->GetPositionForCorner(c_next);
+      const VectorD<int64_t, 3> pos_prev = this->GetPositionForCorner(c_prev);
+
+      // Computing delta vectors to next and prev.
+      const VectorD<int64_t, 3> delta_next = pos_next - pos_cent;
+      const VectorD<int64_t, 3> delta_prev = pos_prev - pos_cent;
+
+      // Computing cross product.
+      const VectorD<int64_t, 3> cross = CrossProduct(delta_next, delta_prev);
+
+      // Prevent signed integer overflows by doing math as unsigned.
+      auto normal_data = reinterpret_cast<uint64_t *>(normal.data());
+      auto cross_data = reinterpret_cast<const uint64_t *>(cross.data());
+      normal_data[0] = normal_data[0] + cross_data[0];
+      normal_data[1] = normal_data[1] + cross_data[1];
+      normal_data[2] = normal_data[2] + cross_data[2];
+
+      cit.Next();
+    }
+
+    // Convert to int32_t, make sure entries are not too large.
+    constexpr int64_t upper_bound = 1 << 29;
+    if (this->normal_prediction_mode_ == ONE_TRIANGLE) {
+      const int32_t abs_sum = static_cast<int32_t>(normal.AbsSum());
+      if (abs_sum > upper_bound) {
+        const int64_t quotient = abs_sum / upper_bound;
+        normal = normal / quotient;
+      }
+    } else {
+      const int64_t abs_sum = normal.AbsSum();
+      if (abs_sum > upper_bound) {
+        const int64_t quotient = abs_sum / upper_bound;
+        normal = normal / quotient;
+      }
+    }
+    DRACO_DCHECK_LE(normal.AbsSum(), upper_bound);
+    prediction[0] = static_cast<int32_t>(normal[0]);
+    prediction[1] = static_cast<int32_t>(normal[1]);
+    prediction[2] = static_cast<int32_t>(normal[2]);
+  }
+  bool SetNormalPredictionMode(NormalPredictionMode mode) override {
+    if (mode == ONE_TRIANGLE) {
+      this->normal_prediction_mode_ = mode;
+      return true;
+    } else if (mode == TRIANGLE_AREA) {
+      this->normal_prediction_mode_ = mode;
+      return true;
+    }
+    return false;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_PREDICTOR_AREA_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_base.h b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_base.h
new file mode 100644
index 00000000..a554dda9
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_base.h
@@ -0,0 +1,96 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_PREDICTOR_BASE_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_PREDICTOR_BASE_H_
+
+#include <math.h>
+
+#include "draco/attributes/point_attribute.h"
+#include "draco/compression/attributes/normal_compression_utils.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/core/math_utils.h"
+#include "draco/core/vector_d.h"
+#include "draco/mesh/corner_table.h"
+#include "draco/mesh/corner_table_iterators.h"
+
+namespace draco {
+
+// Base class for geometric normal predictors using position attribute.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeGeometricNormalPredictorBase {
+ protected:
+  explicit MeshPredictionSchemeGeometricNormalPredictorBase(const MeshDataT &md)
+      : pos_attribute_(nullptr),
+        entry_to_point_id_map_(nullptr),
+        mesh_data_(md) {}
+  virtual ~MeshPredictionSchemeGeometricNormalPredictorBase() {}
+
+ public:
+  void SetPositionAttribute(const PointAttribute &position_attribute) {
+    pos_attribute_ = &position_attribute;
+  }
+  void SetEntryToPointIdMap(const PointIndex *map) {
+    entry_to_point_id_map_ = map;
+  }
+  bool IsInitialized() const {
+    if (pos_attribute_ == nullptr) {
+      return false;
+    }
+    if (entry_to_point_id_map_ == nullptr) {
+      return false;
+    }
+    return true;
+  }
+
+  virtual bool SetNormalPredictionMode(NormalPredictionMode mode) = 0;
+  virtual NormalPredictionMode GetNormalPredictionMode() const {
+    return normal_prediction_mode_;
+  }
+
+ protected:
+  VectorD<int64_t, 3> GetPositionForDataId(int data_id) const {
+    DRACO_DCHECK(this->IsInitialized());
+    const auto point_id = entry_to_point_id_map_[data_id];
+    const auto pos_val_id = pos_attribute_->mapped_index(point_id);
+    VectorD<int64_t, 3> pos;
+    pos_attribute_->ConvertValue(pos_val_id, &pos[0]);
+    return pos;
+  }
+  VectorD<int64_t, 3> GetPositionForCorner(CornerIndex ci) const {
+    DRACO_DCHECK(this->IsInitialized());
+    const auto corner_table = mesh_data_.corner_table();
+    const auto vert_id = corner_table->Vertex(ci).value();
+    const auto data_id = mesh_data_.vertex_to_data_map()->at(vert_id);
+    return GetPositionForDataId(data_id);
+  }
+  VectorD<int32_t, 2> GetOctahedralCoordForDataId(int data_id,
+                                                  const DataTypeT *data) const {
+    DRACO_DCHECK(this->IsInitialized());
+    const int data_offset = data_id * 2;
+    return VectorD<int32_t, 2>(data[data_offset], data[data_offset + 1]);
+  }
+  // Computes predicted octahedral coordinates on a given corner.
+  virtual void ComputePredictedValue(CornerIndex corner_id,
+                                     DataTypeT *prediction) = 0;
+
+  const PointAttribute *pos_attribute_;
+  const PointIndex *entry_to_point_id_map_;
+  MeshDataT mesh_data_;
+  NormalPredictionMode normal_prediction_mode_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_PREDICTOR_BASE_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_decoder.h b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_decoder.h
new file mode 100644
index 00000000..fc82e0a8
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_decoder.h
@@ -0,0 +1,126 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_MULTI_PARALLELOGRAM_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_MULTI_PARALLELOGRAM_DECODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Decoder for predictions encoded by multi-parallelogram encoding scheme.
+// See the corresponding encoder for method description.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeMultiParallelogramDecoder
+    : public MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType =
+      typename PredictionSchemeDecoder<DataTypeT, TransformT>::CorrType;
+  using CornerTable = typename MeshDataT::CornerTable;
+
+  explicit MeshPredictionSchemeMultiParallelogramDecoder(
+      const PointAttribute *attribute)
+      : MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT>(
+            attribute) {}
+  MeshPredictionSchemeMultiParallelogramDecoder(const PointAttribute *attribute,
+                                                const TransformT &transform,
+                                                const MeshDataT &mesh_data)
+      : MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data) {}
+
+  bool ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                             int size, int num_components,
+                             const PointIndex *entry_to_point_id_map) override;
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_MULTI_PARALLELOGRAM;
+  }
+
+  bool IsInitialized() const override {
+    return this->mesh_data().IsInitialized();
+  }
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeMultiParallelogramDecoder<DataTypeT, TransformT,
+                                                   MeshDataT>::
+    ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                          int /* size */, int num_components,
+                          const PointIndex * /* entry_to_point_id_map */) {
+  this->transform().Init(num_components);
+
+  // For storage of prediction values (already initialized to zero).
+  std::unique_ptr<DataTypeT[]> pred_vals(new DataTypeT[num_components]());
+  std::unique_ptr<DataTypeT[]> parallelogram_pred_vals(
+      new DataTypeT[num_components]());
+
+  this->transform().ComputeOriginalValue(pred_vals.get(), in_corr, out_data);
+
+  const CornerTable *const table = this->mesh_data().corner_table();
+  const std::vector<int32_t> *const vertex_to_data_map =
+      this->mesh_data().vertex_to_data_map();
+
+  const int corner_map_size =
+      static_cast<int>(this->mesh_data().data_to_corner_map()->size());
+  for (int p = 1; p < corner_map_size; ++p) {
+    const CornerIndex start_corner_id =
+        this->mesh_data().data_to_corner_map()->at(p);
+
+    CornerIndex corner_id(start_corner_id);
+    int num_parallelograms = 0;
+    for (int i = 0; i < num_components; ++i) {
+      pred_vals[i] = static_cast<DataTypeT>(0);
+    }
+    while (corner_id != kInvalidCornerIndex) {
+      if (ComputeParallelogramPrediction(
+              p, corner_id, table, *vertex_to_data_map, out_data,
+              num_components, parallelogram_pred_vals.get())) {
+        for (int c = 0; c < num_components; ++c) {
+          pred_vals[c] += parallelogram_pred_vals[c];
+        }
+        ++num_parallelograms;
+      }
+
+      // Proceed to the next corner attached to the vertex.
+      corner_id = table->SwingRight(corner_id);
+      if (corner_id == start_corner_id) {
+        corner_id = kInvalidCornerIndex;
+      }
+    }
+
+    const int dst_offset = p * num_components;
+    if (num_parallelograms == 0) {
+      // No parallelogram was valid.
+      // We use the last decoded point as a reference.
+      const int src_offset = (p - 1) * num_components;
+      this->transform().ComputeOriginalValue(
+          out_data + src_offset, in_corr + dst_offset, out_data + dst_offset);
+    } else {
+      // Compute the correction from the predicted value.
+      for (int c = 0; c < num_components; ++c) {
+        pred_vals[c] /= num_parallelograms;
+      }
+      this->transform().ComputeOriginalValue(
+          pred_vals.get(), in_corr + dst_offset, out_data + dst_offset);
+    }
+  }
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_MULTI_PARALLELOGRAM_DECODER_H_
+#endif
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_encoder.h b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_encoder.h
new file mode 100644
index 00000000..301b357d
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_encoder.h
@@ -0,0 +1,133 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_MULTI_PARALLELOGRAM_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_MULTI_PARALLELOGRAM_ENCODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h"
+
+namespace draco {
+
+// Multi parallelogram prediction predicts attribute values using information
+// from all opposite faces to the predicted vertex, compared to the standard
+// prediction scheme, where only one opposite face is used (see
+// prediction_scheme_parallelogram.h). This approach is generally slower than
+// the standard parallelogram prediction, but it usually results in better
+// prediction (5 - 20% based on the quantization level. Better gains can be
+// achieved when more aggressive quantization is used).
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeMultiParallelogramEncoder
+    : public MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType =
+      typename PredictionSchemeEncoder<DataTypeT, TransformT>::CorrType;
+  using CornerTable = typename MeshDataT::CornerTable;
+
+  explicit MeshPredictionSchemeMultiParallelogramEncoder(
+      const PointAttribute *attribute)
+      : MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT>(
+            attribute) {}
+  MeshPredictionSchemeMultiParallelogramEncoder(const PointAttribute *attribute,
+                                                const TransformT &transform,
+                                                const MeshDataT &mesh_data)
+      : MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data) {}
+
+  bool ComputeCorrectionValues(
+      const DataTypeT *in_data, CorrType *out_corr, int size,
+      int num_components, const PointIndex *entry_to_point_id_map) override;
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_MULTI_PARALLELOGRAM;
+  }
+
+  bool IsInitialized() const override {
+    return this->mesh_data().IsInitialized();
+  }
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeMultiParallelogramEncoder<DataTypeT, TransformT,
+                                                   MeshDataT>::
+    ComputeCorrectionValues(const DataTypeT *in_data, CorrType *out_corr,
+                            int size, int num_components,
+                            const PointIndex * /* entry_to_point_id_map */) {
+  this->transform().Init(in_data, size, num_components);
+  const CornerTable *const table = this->mesh_data().corner_table();
+  const std::vector<int32_t> *const vertex_to_data_map =
+      this->mesh_data().vertex_to_data_map();
+
+  // For storage of prediction values (already initialized to zero).
+  std::unique_ptr<DataTypeT[]> pred_vals(new DataTypeT[num_components]());
+  std::unique_ptr<DataTypeT[]> parallelogram_pred_vals(
+      new DataTypeT[num_components]());
+
+  // We start processing from the end because this prediction uses data from
+  // previous entries that could be overwritten when an entry is processed.
+  for (int p =
+           static_cast<int>(this->mesh_data().data_to_corner_map()->size() - 1);
+       p > 0; --p) {
+    const CornerIndex start_corner_id =
+        this->mesh_data().data_to_corner_map()->at(p);
+
+    // Go over all corners attached to the vertex and compute the predicted
+    // value from the parallelograms defined by their opposite faces.
+    CornerIndex corner_id(start_corner_id);
+    int num_parallelograms = 0;
+    for (int i = 0; i < num_components; ++i) {
+      pred_vals[i] = static_cast<DataTypeT>(0);
+    }
+    while (corner_id != kInvalidCornerIndex) {
+      if (ComputeParallelogramPrediction(
+              p, corner_id, table, *vertex_to_data_map, in_data, num_components,
+              parallelogram_pred_vals.get())) {
+        for (int c = 0; c < num_components; ++c) {
+          pred_vals[c] += parallelogram_pred_vals[c];
+        }
+        ++num_parallelograms;
+      }
+
+      // Proceed to the next corner attached to the vertex.
+      corner_id = table->SwingRight(corner_id);
+      if (corner_id == start_corner_id) {
+        corner_id = kInvalidCornerIndex;
+      }
+    }
+    const int dst_offset = p * num_components;
+    if (num_parallelograms == 0) {
+      // No parallelogram was valid.
+      // We use the last encoded point as a reference.
+      const int src_offset = (p - 1) * num_components;
+      this->transform().ComputeCorrection(
+          in_data + dst_offset, in_data + src_offset, out_corr + dst_offset);
+    } else {
+      // Compute the correction from the predicted value.
+      for (int c = 0; c < num_components; ++c) {
+        pred_vals[c] /= num_parallelograms;
+      }
+      this->transform().ComputeCorrection(in_data + dst_offset, pred_vals.get(),
+                                          out_corr + dst_offset);
+    }
+  }
+  // First element is always fixed because it cannot be predicted.
+  for (int i = 0; i < num_components; ++i) {
+    pred_vals[i] = static_cast<DataTypeT>(0);
+  }
+  this->transform().ComputeCorrection(in_data, pred_vals.get(), out_corr);
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_MULTI_PARALLELOGRAM_ENCODER_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_decoder.h b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_decoder.h
new file mode 100644
index 00000000..4d47ddf3
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_decoder.h
@@ -0,0 +1,98 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_PARALLELOGRAM_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_PARALLELOGRAM_DECODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h"
+
+namespace draco {
+
+// Decoder for attribute values encoded with the standard parallelogram
+// prediction. See the description of the corresponding encoder for more
+// details.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeParallelogramDecoder
+    : public MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType =
+      typename PredictionSchemeDecoder<DataTypeT, TransformT>::CorrType;
+  using CornerTable = typename MeshDataT::CornerTable;
+  explicit MeshPredictionSchemeParallelogramDecoder(
+      const PointAttribute *attribute)
+      : MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT>(
+            attribute) {}
+  MeshPredictionSchemeParallelogramDecoder(const PointAttribute *attribute,
+                                           const TransformT &transform,
+                                           const MeshDataT &mesh_data)
+      : MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data) {}
+
+  bool ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                             int size, int num_components,
+                             const PointIndex *entry_to_point_id_map) override;
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_PARALLELOGRAM;
+  }
+
+  bool IsInitialized() const override {
+    return this->mesh_data().IsInitialized();
+  }
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeParallelogramDecoder<DataTypeT, TransformT,
+                                              MeshDataT>::
+    ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                          int /* size */, int num_components,
+                          const PointIndex * /* entry_to_point_id_map */) {
+  this->transform().Init(num_components);
+
+  const CornerTable *const table = this->mesh_data().corner_table();
+  const std::vector<int32_t> *const vertex_to_data_map =
+      this->mesh_data().vertex_to_data_map();
+
+  // For storage of prediction values (already initialized to zero).
+  std::unique_ptr<DataTypeT[]> pred_vals(new DataTypeT[num_components]());
+
+  // Restore the first value.
+  this->transform().ComputeOriginalValue(pred_vals.get(), in_corr, out_data);
+
+  const int corner_map_size =
+      static_cast<int>(this->mesh_data().data_to_corner_map()->size());
+  for (int p = 1; p < corner_map_size; ++p) {
+    const CornerIndex corner_id = this->mesh_data().data_to_corner_map()->at(p);
+    const int dst_offset = p * num_components;
+    if (!ComputeParallelogramPrediction(p, corner_id, table,
+                                        *vertex_to_data_map, out_data,
+                                        num_components, pred_vals.get())) {
+      // Parallelogram could not be computed, Possible because some of the
+      // vertices are not valid (not encoded yet).
+      // We use the last encoded point as a reference (delta coding).
+      const int src_offset = (p - 1) * num_components;
+      this->transform().ComputeOriginalValue(
+          out_data + src_offset, in_corr + dst_offset, out_data + dst_offset);
+    } else {
+      // Apply the parallelogram prediction.
+      this->transform().ComputeOriginalValue(
+          pred_vals.get(), in_corr + dst_offset, out_data + dst_offset);
+    }
+  }
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_PARALLELOGRAM_DECODER_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_encoder.h b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_encoder.h
new file mode 100644
index 00000000..f0080193
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_encoder.h
@@ -0,0 +1,111 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_PARALLELOGRAM_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_PARALLELOGRAM_ENCODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h"
+
+namespace draco {
+
+// Parallelogram prediction predicts an attribute value V from three vertices
+// on the opposite face to the predicted vertex. The values on the three
+// vertices are used to construct a parallelogram V' = O - A - B, where O is the
+// value on the opposite vertex, and A, B are values on the shared vertices:
+//     V
+//    / \
+//   /   \
+//  /     \
+// A-------B
+//  \     /
+//   \   /
+//    \ /
+//     O
+//
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeParallelogramEncoder
+    : public MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType =
+      typename PredictionSchemeEncoder<DataTypeT, TransformT>::CorrType;
+  using CornerTable = typename MeshDataT::CornerTable;
+  explicit MeshPredictionSchemeParallelogramEncoder(
+      const PointAttribute *attribute)
+      : MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT>(
+            attribute) {}
+  MeshPredictionSchemeParallelogramEncoder(const PointAttribute *attribute,
+                                           const TransformT &transform,
+                                           const MeshDataT &mesh_data)
+      : MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data) {}
+
+  bool ComputeCorrectionValues(
+      const DataTypeT *in_data, CorrType *out_corr, int size,
+      int num_components, const PointIndex *entry_to_point_id_map) override;
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_PARALLELOGRAM;
+  }
+
+  bool IsInitialized() const override {
+    return this->mesh_data().IsInitialized();
+  }
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeParallelogramEncoder<DataTypeT, TransformT,
+                                              MeshDataT>::
+    ComputeCorrectionValues(const DataTypeT *in_data, CorrType *out_corr,
+                            int size, int num_components,
+                            const PointIndex * /* entry_to_point_id_map */) {
+  this->transform().Init(in_data, size, num_components);
+  // For storage of prediction values (already initialized to zero).
+  std::unique_ptr<DataTypeT[]> pred_vals(new DataTypeT[num_components]());
+
+  // We start processing from the end because this prediction uses data from
+  // previous entries that could be overwritten when an entry is processed.
+  const CornerTable *const table = this->mesh_data().corner_table();
+  const std::vector<int32_t> *const vertex_to_data_map =
+      this->mesh_data().vertex_to_data_map();
+  for (int p =
+           static_cast<int>(this->mesh_data().data_to_corner_map()->size() - 1);
+       p > 0; --p) {
+    const CornerIndex corner_id = this->mesh_data().data_to_corner_map()->at(p);
+    const int dst_offset = p * num_components;
+    if (!ComputeParallelogramPrediction(p, corner_id, table,
+                                        *vertex_to_data_map, in_data,
+                                        num_components, pred_vals.get())) {
+      // Parallelogram could not be computed, Possible because some of the
+      // vertices are not valid (not encoded yet).
+      // We use the last encoded point as a reference (delta coding).
+      const int src_offset = (p - 1) * num_components;
+      this->transform().ComputeCorrection(
+          in_data + dst_offset, in_data + src_offset, out_corr + dst_offset);
+    } else {
+      // Apply the parallelogram prediction.
+      this->transform().ComputeCorrection(in_data + dst_offset, pred_vals.get(),
+                                          out_corr + dst_offset);
+    }
+  }
+  // First element is always fixed because it cannot be predicted.
+  for (int i = 0; i < num_components; ++i) {
+    pred_vals[i] = static_cast<DataTypeT>(0);
+  }
+  this->transform().ComputeCorrection(in_data, pred_vals.get(), out_corr);
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_PARALLELOGRAM_ENCODER_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h
new file mode 100644
index 00000000..fd10fb52
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h
@@ -0,0 +1,78 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Shared functionality for different parallelogram prediction schemes.
+
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_PARALLELOGRAM_SHARED_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_PARALLELOGRAM_SHARED_H_
+
+#include "draco/mesh/corner_table.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// TODO(draco-eng) consolidate Vertex/next/previous queries to one call
+// (performance).
+template <class CornerTableT>
+inline void GetParallelogramEntries(
+    const CornerIndex ci, const CornerTableT *table,
+    const std::vector<int32_t> &vertex_to_data_map, int *opp_entry,
+    int *next_entry, int *prev_entry) {
+  // One vertex of the input |table| correspond to exactly one attribute value
+  // entry. The |table| can be either CornerTable for per-vertex attributes,
+  // or MeshAttributeCornerTable for attributes with interior seams.
+  *opp_entry = vertex_to_data_map[table->Vertex(ci).value()];
+  *next_entry = vertex_to_data_map[table->Vertex(table->Next(ci)).value()];
+  *prev_entry = vertex_to_data_map[table->Vertex(table->Previous(ci)).value()];
+}
+
+// Computes parallelogram prediction for a given corner and data entry id.
+// The prediction is stored in |out_prediction|.
+// Function returns false when the prediction couldn't be computed, e.g. because
+// not all entry points were available.
+template <class CornerTableT, typename DataTypeT>
+inline bool ComputeParallelogramPrediction(
+    int data_entry_id, const CornerIndex ci, const CornerTableT *table,
+    const std::vector<int32_t> &vertex_to_data_map, const DataTypeT *in_data,
+    int num_components, DataTypeT *out_prediction) {
+  const CornerIndex oci = table->Opposite(ci);
+  if (oci == kInvalidCornerIndex) {
+    return false;
+  }
+  int vert_opp, vert_next, vert_prev;
+  GetParallelogramEntries<CornerTableT>(oci, table, vertex_to_data_map,
+                                        &vert_opp, &vert_next, &vert_prev);
+  if (vert_opp < data_entry_id && vert_next < data_entry_id &&
+      vert_prev < data_entry_id) {
+    // Apply the parallelogram prediction.
+    const int v_opp_off = vert_opp * num_components;
+    const int v_next_off = vert_next * num_components;
+    const int v_prev_off = vert_prev * num_components;
+    for (int c = 0; c < num_components; ++c) {
+      const int64_t in_data_next_off = in_data[v_next_off + c];
+      const int64_t in_data_prev_off = in_data[v_prev_off + c];
+      const int64_t in_data_opp_off = in_data[v_opp_off + c];
+      const int64_t result =
+          (in_data_next_off + in_data_prev_off) - in_data_opp_off;
+
+      out_prediction[c] = static_cast<DataTypeT>(result);
+    }
+    return true;
+  }
+  return false;  // Not all data is available for prediction
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_PARALLELOGRAM_SHARED_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_decoder.h b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_decoder.h
new file mode 100644
index 00000000..02cf7e60
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_decoder.h
@@ -0,0 +1,344 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_DECODER_H_
+
+#include <math.h>
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h"
+#include "draco/compression/bit_coders/rans_bit_decoder.h"
+#include "draco/core/varint_decoding.h"
+#include "draco/core/vector_d.h"
+#include "draco/draco_features.h"
+#include "draco/mesh/corner_table.h"
+
+namespace draco {
+
+// Decoder for predictions of UV coordinates encoded by our specialized texture
+// coordinate predictor. See the corresponding encoder for more details. Note
+// that this predictor is not portable and should not be used anymore. See
+// MeshPredictionSchemeTexCoordsPortableEncoder/Decoder for a portable version
+// of this prediction scheme.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeTexCoordsDecoder
+    : public MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType = typename MeshPredictionSchemeDecoder<DataTypeT, TransformT,
+                                                        MeshDataT>::CorrType;
+  MeshPredictionSchemeTexCoordsDecoder(const PointAttribute *attribute,
+                                       const TransformT &transform,
+                                       const MeshDataT &mesh_data, int version)
+      : MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data),
+        pos_attribute_(nullptr),
+        entry_to_point_id_map_(nullptr),
+        num_components_(0),
+        version_(version) {}
+
+  bool ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                             int size, int num_components,
+                             const PointIndex *entry_to_point_id_map) override;
+
+  bool DecodePredictionData(DecoderBuffer *buffer) override;
+
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_TEX_COORDS_DEPRECATED;
+  }
+
+  bool IsInitialized() const override {
+    if (pos_attribute_ == nullptr) {
+      return false;
+    }
+    if (!this->mesh_data().IsInitialized()) {
+      return false;
+    }
+    return true;
+  }
+
+  int GetNumParentAttributes() const override { return 1; }
+
+  GeometryAttribute::Type GetParentAttributeType(int i) const override {
+    DRACO_DCHECK_EQ(i, 0);
+    (void)i;
+    return GeometryAttribute::POSITION;
+  }
+
+  bool SetParentAttribute(const PointAttribute *att) override {
+    if (att == nullptr) {
+      return false;
+    }
+    if (att->attribute_type() != GeometryAttribute::POSITION) {
+      return false;  // Invalid attribute type.
+    }
+    if (att->num_components() != 3) {
+      return false;  // Currently works only for 3 component positions.
+    }
+    pos_attribute_ = att;
+    return true;
+  }
+
+ protected:
+  Vector3f GetPositionForEntryId(int entry_id) const {
+    const PointIndex point_id = entry_to_point_id_map_[entry_id];
+    Vector3f pos;
+    pos_attribute_->ConvertValue(pos_attribute_->mapped_index(point_id),
+                                 &pos[0]);
+    return pos;
+  }
+
+  Vector2f GetTexCoordForEntryId(int entry_id, const DataTypeT *data) const {
+    const int data_offset = entry_id * num_components_;
+    return Vector2f(static_cast<float>(data[data_offset]),
+                    static_cast<float>(data[data_offset + 1]));
+  }
+
+  void ComputePredictedValue(CornerIndex corner_id, const DataTypeT *data,
+                             int data_id);
+
+ private:
+  const PointAttribute *pos_attribute_;
+  const PointIndex *entry_to_point_id_map_;
+  std::unique_ptr<DataTypeT[]> predicted_value_;
+  int num_components_;
+  // Encoded / decoded array of UV flips.
+  std::vector<bool> orientations_;
+  int version_;
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeTexCoordsDecoder<DataTypeT, TransformT, MeshDataT>::
+    ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                          int /* size */, int num_components,
+                          const PointIndex *entry_to_point_id_map) {
+  num_components_ = num_components;
+  entry_to_point_id_map_ = entry_to_point_id_map;
+  predicted_value_ =
+      std::unique_ptr<DataTypeT[]>(new DataTypeT[num_components]);
+  this->transform().Init(num_components);
+
+  const int corner_map_size =
+      static_cast<int>(this->mesh_data().data_to_corner_map()->size());
+  for (int p = 0; p < corner_map_size; ++p) {
+    const CornerIndex corner_id = this->mesh_data().data_to_corner_map()->at(p);
+    ComputePredictedValue(corner_id, out_data, p);
+
+    const int dst_offset = p * num_components;
+    this->transform().ComputeOriginalValue(
+        predicted_value_.get(), in_corr + dst_offset, out_data + dst_offset);
+  }
+  return true;
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeTexCoordsDecoder<DataTypeT, TransformT, MeshDataT>::
+    DecodePredictionData(DecoderBuffer *buffer) {
+  // Decode the delta coded orientations.
+  uint32_t num_orientations = 0;
+  if (buffer->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+    if (!buffer->Decode(&num_orientations)) {
+      return false;
+    }
+  } else {
+    if (!DecodeVarint(&num_orientations, buffer)) {
+      return false;
+    }
+  }
+  if (num_orientations == 0) {
+    return false;
+  }
+  orientations_.resize(num_orientations);
+  bool last_orientation = true;
+  RAnsBitDecoder decoder;
+  if (!decoder.StartDecoding(buffer)) {
+    return false;
+  }
+  for (uint32_t i = 0; i < num_orientations; ++i) {
+    if (!decoder.DecodeNextBit()) {
+      last_orientation = !last_orientation;
+    }
+    orientations_[i] = last_orientation;
+  }
+  decoder.EndDecoding();
+  return MeshPredictionSchemeDecoder<DataTypeT, TransformT,
+                                     MeshDataT>::DecodePredictionData(buffer);
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+void MeshPredictionSchemeTexCoordsDecoder<DataTypeT, TransformT, MeshDataT>::
+    ComputePredictedValue(CornerIndex corner_id, const DataTypeT *data,
+                          int data_id) {
+  // Compute the predicted UV coordinate from the positions on all corners
+  // of the processed triangle. For the best prediction, the UV coordinates
+  // on the next/previous corners need to be already encoded/decoded.
+  const CornerIndex next_corner_id =
+      this->mesh_data().corner_table()->Next(corner_id);
+  const CornerIndex prev_corner_id =
+      this->mesh_data().corner_table()->Previous(corner_id);
+  // Get the encoded data ids from the next and previous corners.
+  // The data id is the encoding order of the UV coordinates.
+  int next_data_id, prev_data_id;
+
+  int next_vert_id, prev_vert_id;
+  next_vert_id =
+      this->mesh_data().corner_table()->Vertex(next_corner_id).value();
+  prev_vert_id =
+      this->mesh_data().corner_table()->Vertex(prev_corner_id).value();
+
+  next_data_id = this->mesh_data().vertex_to_data_map()->at(next_vert_id);
+  prev_data_id = this->mesh_data().vertex_to_data_map()->at(prev_vert_id);
+
+  if (prev_data_id < data_id && next_data_id < data_id) {
+    // Both other corners have available UV coordinates for prediction.
+    const Vector2f n_uv = GetTexCoordForEntryId(next_data_id, data);
+    const Vector2f p_uv = GetTexCoordForEntryId(prev_data_id, data);
+    if (p_uv == n_uv) {
+      // We cannot do a reliable prediction on degenerated UV triangles.
+      predicted_value_[0] = static_cast<int>(p_uv[0]);
+      predicted_value_[1] = static_cast<int>(p_uv[1]);
+      return;
+    }
+
+    // Get positions at all corners.
+    const Vector3f tip_pos = GetPositionForEntryId(data_id);
+    const Vector3f next_pos = GetPositionForEntryId(next_data_id);
+    const Vector3f prev_pos = GetPositionForEntryId(prev_data_id);
+    // Use the positions of the above triangle to predict the texture coordinate
+    // on the tip corner C.
+    // Convert the triangle into a new coordinate system defined by orthogonal
+    // bases vectors S, T, where S is vector prev_pos - next_pos and T is an
+    // perpendicular vector to S in the same plane as vector the
+    // tip_pos - next_pos.
+    // The transformed triangle in the new coordinate system is then going to
+    // be represented as:
+    //
+    //        1 ^
+    //          |
+    //          |
+    //          |   C
+    //          |  /  \
+    //          | /      \
+    //          |/          \
+    //          N--------------P
+    //          0              1
+    //
+    // Where next_pos point (N) is at position (0, 0), prev_pos point (P) is
+    // at (1, 0). Our goal is to compute the position of the tip_pos point (C)
+    // in this new coordinate space (s, t).
+    //
+    const Vector3f pn = prev_pos - next_pos;
+    const Vector3f cn = tip_pos - next_pos;
+    const float pn_norm2_squared = pn.SquaredNorm();
+    // Coordinate s of the tip corner C is simply the dot product of the
+    // normalized vectors |pn| and |cn| (normalized by the length of |pn|).
+    // Since both of these vectors are normalized, we don't need to perform the
+    // normalization explicitly and instead we can just use the squared norm
+    // of |pn| as a denominator of the resulting dot product of non normalized
+    // vectors.
+    float s, t;
+    // |pn_norm2_squared| can be exactly 0 when the next_pos and prev_pos are
+    // the same positions (e.g. because they were quantized to the same
+    // location).
+    if (version_ < DRACO_BITSTREAM_VERSION(1, 2) || pn_norm2_squared > 0) {
+      s = pn.Dot(cn) / pn_norm2_squared;
+      // To get the coordinate t, we can use formula:
+      //      t = |C-N - (P-N) * s| / |P-N|
+      // Do not use std::sqrt to avoid changes in the bitstream.
+      t = sqrt((cn - pn * s).SquaredNorm() / pn_norm2_squared);
+    } else {
+      s = 0;
+      t = 0;
+    }
+
+    // Now we need to transform the point (s, t) to the texture coordinate space
+    // UV. We know the UV coordinates on points N and P (N_UV and P_UV). Lets
+    // denote P_UV - N_UV = PN_UV. PN_UV is then 2 dimensional vector that can
+    // be used to define transformation from the normalized coordinate system
+    // to the texture coordinate system using a 3x3 affine matrix M:
+    //
+    //  M = | PN_UV[0]  -PN_UV[1]  N_UV[0] |
+    //      | PN_UV[1]   PN_UV[0]  N_UV[1] |
+    //      | 0          0         1       |
+    //
+    // The predicted point C_UV in the texture space is then equal to
+    // C_UV = M * (s, t, 1). Because the triangle in UV space may be flipped
+    // around the PN_UV axis, we also need to consider point C_UV' = M * (s, -t)
+    // as the prediction.
+    const Vector2f pn_uv = p_uv - n_uv;
+    const float pnus = pn_uv[0] * s + n_uv[0];
+    const float pnut = pn_uv[0] * t;
+    const float pnvs = pn_uv[1] * s + n_uv[1];
+    const float pnvt = pn_uv[1] * t;
+    Vector2f predicted_uv;
+
+    // When decoding the data, we already know which orientation to use.
+    const bool orientation = orientations_.back();
+    orientations_.pop_back();
+    if (orientation)
+      predicted_uv = Vector2f(pnus - pnvt, pnvs + pnut);
+    else
+      predicted_uv = Vector2f(pnus + pnvt, pnvs - pnut);
+
+    if (std::is_integral<DataTypeT>::value) {
+      // Round the predicted value for integer types.
+      if (std::isnan(predicted_uv[0])) {
+        predicted_value_[0] = INT_MIN;
+      } else {
+        predicted_value_[0] = static_cast<int>(floor(predicted_uv[0] + 0.5));
+      }
+      if (std::isnan(predicted_uv[1])) {
+        predicted_value_[1] = INT_MIN;
+      } else {
+        predicted_value_[1] = static_cast<int>(floor(predicted_uv[1] + 0.5));
+      }
+    } else {
+      predicted_value_[0] = static_cast<int>(predicted_uv[0]);
+      predicted_value_[1] = static_cast<int>(predicted_uv[1]);
+    }
+    return;
+  }
+  // Else we don't have available textures on both corners. For such case we
+  // can't use positions for predicting the uv value and we resort to delta
+  // coding.
+  int data_offset = 0;
+  if (prev_data_id < data_id) {
+    // Use the value on the previous corner as the prediction.
+    data_offset = prev_data_id * num_components_;
+  }
+  if (next_data_id < data_id) {
+    // Use the value on the next corner as the prediction.
+    data_offset = next_data_id * num_components_;
+  } else {
+    // None of the other corners have a valid value. Use the last encoded value
+    // as the prediction if possible.
+    if (data_id > 0) {
+      data_offset = (data_id - 1) * num_components_;
+    } else {
+      // We are encoding the first value. Predict 0.
+      for (int i = 0; i < num_components_; ++i) {
+        predicted_value_[i] = 0;
+      }
+      return;
+    }
+  }
+  for (int i = 0; i < num_components_; ++i) {
+    predicted_value_[i] = data[data_offset + i];
+  }
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_DECODER_H_
+#endif
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_encoder.h b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_encoder.h
new file mode 100644
index 00000000..813b72ae
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_encoder.h
@@ -0,0 +1,318 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_ENCODER_H_
+
+#include <math.h>
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h"
+#include "draco/compression/bit_coders/rans_bit_encoder.h"
+#include "draco/core/varint_encoding.h"
+#include "draco/core/vector_d.h"
+#include "draco/mesh/corner_table.h"
+
+namespace draco {
+
+// Prediction scheme designed for predicting texture coordinates from known
+// spatial position of vertices. For good parametrization, the ratios between
+// triangle edge lengths should be about the same in both the spatial and UV
+// coordinate spaces, which makes the positions a good predictor for the UV
+// coordinates.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeTexCoordsEncoder
+    : public MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType = typename MeshPredictionSchemeEncoder<DataTypeT, TransformT,
+                                                        MeshDataT>::CorrType;
+  MeshPredictionSchemeTexCoordsEncoder(const PointAttribute *attribute,
+                                       const TransformT &transform,
+                                       const MeshDataT &mesh_data)
+      : MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data),
+        pos_attribute_(nullptr),
+        entry_to_point_id_map_(nullptr),
+        num_components_(0) {}
+
+  bool ComputeCorrectionValues(
+      const DataTypeT *in_data, CorrType *out_corr, int size,
+      int num_components, const PointIndex *entry_to_point_id_map) override;
+
+  bool EncodePredictionData(EncoderBuffer *buffer) override;
+
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_TEX_COORDS_DEPRECATED;
+  }
+
+  bool IsInitialized() const override {
+    if (pos_attribute_ == nullptr) {
+      return false;
+    }
+    if (!this->mesh_data().IsInitialized()) {
+      return false;
+    }
+    return true;
+  }
+
+  int GetNumParentAttributes() const override { return 1; }
+
+  GeometryAttribute::Type GetParentAttributeType(int i) const override {
+    DRACO_DCHECK_EQ(i, 0);
+    (void)i;
+    return GeometryAttribute::POSITION;
+  }
+
+  bool SetParentAttribute(const PointAttribute *att) override {
+    if (att->attribute_type() != GeometryAttribute::POSITION) {
+      return false;  // Invalid attribute type.
+    }
+    if (att->num_components() != 3) {
+      return false;  // Currently works only for 3 component positions.
+    }
+    pos_attribute_ = att;
+    return true;
+  }
+
+ protected:
+  Vector3f GetPositionForEntryId(int entry_id) const {
+    const PointIndex point_id = entry_to_point_id_map_[entry_id];
+    Vector3f pos;
+    pos_attribute_->ConvertValue(pos_attribute_->mapped_index(point_id),
+                                 &pos[0]);
+    return pos;
+  }
+
+  Vector2f GetTexCoordForEntryId(int entry_id, const DataTypeT *data) const {
+    const int data_offset = entry_id * num_components_;
+    return Vector2f(static_cast<float>(data[data_offset]),
+                    static_cast<float>(data[data_offset + 1]));
+  }
+
+  void ComputePredictedValue(CornerIndex corner_id, const DataTypeT *data,
+                             int data_id);
+
+ private:
+  const PointAttribute *pos_attribute_;
+  const PointIndex *entry_to_point_id_map_;
+  std::unique_ptr<DataTypeT[]> predicted_value_;
+  int num_components_;
+  // Encoded / decoded array of UV flips.
+  std::vector<bool> orientations_;
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeTexCoordsEncoder<DataTypeT, TransformT, MeshDataT>::
+    ComputeCorrectionValues(const DataTypeT *in_data, CorrType *out_corr,
+                            int size, int num_components,
+                            const PointIndex *entry_to_point_id_map) {
+  num_components_ = num_components;
+  entry_to_point_id_map_ = entry_to_point_id_map;
+  predicted_value_ =
+      std::unique_ptr<DataTypeT[]>(new DataTypeT[num_components]);
+  this->transform().Init(in_data, size, num_components);
+  // We start processing from the end because this prediction uses data from
+  // previous entries that could be overwritten when an entry is processed.
+  for (int p =
+           static_cast<int>(this->mesh_data().data_to_corner_map()->size()) - 1;
+       p >= 0; --p) {
+    const CornerIndex corner_id = this->mesh_data().data_to_corner_map()->at(p);
+    ComputePredictedValue(corner_id, in_data, p);
+
+    const int dst_offset = p * num_components;
+    this->transform().ComputeCorrection(
+        in_data + dst_offset, predicted_value_.get(), out_corr + dst_offset);
+  }
+  return true;
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeTexCoordsEncoder<DataTypeT, TransformT, MeshDataT>::
+    EncodePredictionData(EncoderBuffer *buffer) {
+  // Encode the delta-coded orientations using arithmetic coding.
+  const uint32_t num_orientations = static_cast<uint32_t>(orientations_.size());
+  EncodeVarint(num_orientations, buffer);
+  bool last_orientation = true;
+  RAnsBitEncoder encoder;
+  encoder.StartEncoding();
+  for (bool orientation : orientations_) {
+    encoder.EncodeBit(orientation == last_orientation);
+    last_orientation = orientation;
+  }
+  encoder.EndEncoding(buffer);
+  return MeshPredictionSchemeEncoder<DataTypeT, TransformT,
+                                     MeshDataT>::EncodePredictionData(buffer);
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+void MeshPredictionSchemeTexCoordsEncoder<DataTypeT, TransformT, MeshDataT>::
+    ComputePredictedValue(CornerIndex corner_id, const DataTypeT *data,
+                          int data_id) {
+  // Compute the predicted UV coordinate from the positions on all corners
+  // of the processed triangle. For the best prediction, the UV coordinates
+  // on the next/previous corners need to be already encoded/decoded.
+  const CornerIndex next_corner_id =
+      this->mesh_data().corner_table()->Next(corner_id);
+  const CornerIndex prev_corner_id =
+      this->mesh_data().corner_table()->Previous(corner_id);
+  // Get the encoded data ids from the next and previous corners.
+  // The data id is the encoding order of the UV coordinates.
+  int next_data_id, prev_data_id;
+
+  int next_vert_id, prev_vert_id;
+  next_vert_id =
+      this->mesh_data().corner_table()->Vertex(next_corner_id).value();
+  prev_vert_id =
+      this->mesh_data().corner_table()->Vertex(prev_corner_id).value();
+
+  next_data_id = this->mesh_data().vertex_to_data_map()->at(next_vert_id);
+  prev_data_id = this->mesh_data().vertex_to_data_map()->at(prev_vert_id);
+
+  if (prev_data_id < data_id && next_data_id < data_id) {
+    // Both other corners have available UV coordinates for prediction.
+    const Vector2f n_uv = GetTexCoordForEntryId(next_data_id, data);
+    const Vector2f p_uv = GetTexCoordForEntryId(prev_data_id, data);
+    if (p_uv == n_uv) {
+      // We cannot do a reliable prediction on degenerated UV triangles.
+      predicted_value_[0] = static_cast<int>(p_uv[0]);
+      predicted_value_[1] = static_cast<int>(p_uv[1]);
+      return;
+    }
+
+    // Get positions at all corners.
+    const Vector3f tip_pos = GetPositionForEntryId(data_id);
+    const Vector3f next_pos = GetPositionForEntryId(next_data_id);
+    const Vector3f prev_pos = GetPositionForEntryId(prev_data_id);
+    // Use the positions of the above triangle to predict the texture coordinate
+    // on the tip corner C.
+    // Convert the triangle into a new coordinate system defined by orthogonal
+    // bases vectors S, T, where S is vector prev_pos - next_pos and T is an
+    // perpendicular vector to S in the same plane as vector the
+    // tip_pos - next_pos.
+    // The transformed triangle in the new coordinate system is then going to
+    // be represented as:
+    //
+    //        1 ^
+    //          |
+    //          |
+    //          |   C
+    //          |  /  \
+    //          | /      \
+    //          |/          \
+    //          N--------------P
+    //          0              1
+    //
+    // Where next_pos point (N) is at position (0, 0), prev_pos point (P) is
+    // at (1, 0). Our goal is to compute the position of the tip_pos point (C)
+    // in this new coordinate space (s, t).
+    //
+    const Vector3f pn = prev_pos - next_pos;
+    const Vector3f cn = tip_pos - next_pos;
+    const float pn_norm2_squared = pn.SquaredNorm();
+    // Coordinate s of the tip corner C is simply the dot product of the
+    // normalized vectors |pn| and |cn| (normalized by the length of |pn|).
+    // Since both of these vectors are normalized, we don't need to perform the
+    // normalization explicitly and instead we can just use the squared norm
+    // of |pn| as a denominator of the resulting dot product of non normalized
+    // vectors.
+    float s, t;
+    // |pn_norm2_squared| can be exactly 0 when the next_pos and prev_pos are
+    // the same positions (e.g. because they were quantized to the same
+    // location).
+    if (pn_norm2_squared > 0) {
+      s = pn.Dot(cn) / pn_norm2_squared;
+      // To get the coordinate t, we can use formula:
+      //      t = |C-N - (P-N) * s| / |P-N|
+      // Do not use std::sqrt to avoid changes in the bitstream.
+      t = sqrt((cn - pn * s).SquaredNorm() / pn_norm2_squared);
+    } else {
+      s = 0;
+      t = 0;
+    }
+
+    // Now we need to transform the point (s, t) to the texture coordinate space
+    // UV. We know the UV coordinates on points N and P (N_UV and P_UV). Lets
+    // denote P_UV - N_UV = PN_UV. PN_UV is then 2 dimensional vector that can
+    // be used to define transformation from the normalized coordinate system
+    // to the texture coordinate system using a 3x3 affine matrix M:
+    //
+    //  M = | PN_UV[0]  -PN_UV[1]  N_UV[0] |
+    //      | PN_UV[1]   PN_UV[0]  N_UV[1] |
+    //      | 0          0         1       |
+    //
+    // The predicted point C_UV in the texture space is then equal to
+    // C_UV = M * (s, t, 1). Because the triangle in UV space may be flipped
+    // around the PN_UV axis, we also need to consider point C_UV' = M * (s, -t)
+    // as the prediction.
+    const Vector2f pn_uv = p_uv - n_uv;
+    const float pnus = pn_uv[0] * s + n_uv[0];
+    const float pnut = pn_uv[0] * t;
+    const float pnvs = pn_uv[1] * s + n_uv[1];
+    const float pnvt = pn_uv[1] * t;
+    Vector2f predicted_uv;
+
+    // When encoding compute both possible vectors and determine which one
+    // results in a better prediction.
+    const Vector2f predicted_uv_0(pnus - pnvt, pnvs + pnut);
+    const Vector2f predicted_uv_1(pnus + pnvt, pnvs - pnut);
+    const Vector2f c_uv = GetTexCoordForEntryId(data_id, data);
+    if ((c_uv - predicted_uv_0).SquaredNorm() <
+        (c_uv - predicted_uv_1).SquaredNorm()) {
+      predicted_uv = predicted_uv_0;
+      orientations_.push_back(true);
+    } else {
+      predicted_uv = predicted_uv_1;
+      orientations_.push_back(false);
+    }
+    if (std::is_integral<DataTypeT>::value) {
+      // Round the predicted value for integer types.
+      predicted_value_[0] = static_cast<int>(floor(predicted_uv[0] + 0.5));
+      predicted_value_[1] = static_cast<int>(floor(predicted_uv[1] + 0.5));
+    } else {
+      predicted_value_[0] = static_cast<int>(predicted_uv[0]);
+      predicted_value_[1] = static_cast<int>(predicted_uv[1]);
+    }
+    return;
+  }
+  // Else we don't have available textures on both corners. For such case we
+  // can't use positions for predicting the uv value and we resort to delta
+  // coding.
+  int data_offset = 0;
+  if (prev_data_id < data_id) {
+    // Use the value on the previous corner as the prediction.
+    data_offset = prev_data_id * num_components_;
+  }
+  if (next_data_id < data_id) {
+    // Use the value on the next corner as the prediction.
+    data_offset = next_data_id * num_components_;
+  } else {
+    // None of the other corners have a valid value. Use the last encoded value
+    // as the prediction if possible.
+    if (data_id > 0) {
+      data_offset = (data_id - 1) * num_components_;
+    } else {
+      // We are encoding the first value. Predict 0.
+      for (int i = 0; i < num_components_; ++i) {
+        predicted_value_[i] = 0;
+      }
+      return;
+    }
+  }
+  for (int i = 0; i < num_components_; ++i) {
+    predicted_value_[i] = data[data_offset + i];
+  }
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_decoder.h b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_decoder.h
new file mode 100644
index 00000000..83d49663
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_decoder.h
@@ -0,0 +1,143 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_PORTABLE_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_PORTABLE_DECODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_predictor.h"
+#include "draco/compression/bit_coders/rans_bit_decoder.h"
+
+namespace draco {
+
+// Decoder for predictions of UV coordinates encoded by our specialized and
+// portable texture coordinate predictor. See the corresponding encoder for more
+// details.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeTexCoordsPortableDecoder
+    : public MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType = typename MeshPredictionSchemeDecoder<DataTypeT, TransformT,
+                                                        MeshDataT>::CorrType;
+  MeshPredictionSchemeTexCoordsPortableDecoder(const PointAttribute *attribute,
+                                               const TransformT &transform,
+                                               const MeshDataT &mesh_data)
+      : MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data),
+        predictor_(mesh_data) {}
+
+  bool ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                             int size, int num_components,
+                             const PointIndex *entry_to_point_id_map) override;
+
+  bool DecodePredictionData(DecoderBuffer *buffer) override;
+
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_TEX_COORDS_PORTABLE;
+  }
+
+  bool IsInitialized() const override {
+    if (!predictor_.IsInitialized()) {
+      return false;
+    }
+    if (!this->mesh_data().IsInitialized()) {
+      return false;
+    }
+    return true;
+  }
+
+  int GetNumParentAttributes() const override { return 1; }
+
+  GeometryAttribute::Type GetParentAttributeType(int i) const override {
+    DRACO_DCHECK_EQ(i, 0);
+    (void)i;
+    return GeometryAttribute::POSITION;
+  }
+
+  bool SetParentAttribute(const PointAttribute *att) override {
+    if (!att || att->attribute_type() != GeometryAttribute::POSITION) {
+      return false;  // Invalid attribute type.
+    }
+    if (att->num_components() != 3) {
+      return false;  // Currently works only for 3 component positions.
+    }
+    predictor_.SetPositionAttribute(*att);
+    return true;
+  }
+
+ private:
+  MeshPredictionSchemeTexCoordsPortablePredictor<DataTypeT, MeshDataT>
+      predictor_;
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeTexCoordsPortableDecoder<
+    DataTypeT, TransformT,
+    MeshDataT>::ComputeOriginalValues(const CorrType *in_corr,
+                                      DataTypeT *out_data, int /* size */,
+                                      int num_components,
+                                      const PointIndex *entry_to_point_id_map) {
+  if (num_components != MeshPredictionSchemeTexCoordsPortablePredictor<
+                            DataTypeT, MeshDataT>::kNumComponents) {
+    return false;
+  }
+  predictor_.SetEntryToPointIdMap(entry_to_point_id_map);
+  this->transform().Init(num_components);
+
+  const int corner_map_size =
+      static_cast<int>(this->mesh_data().data_to_corner_map()->size());
+  for (int p = 0; p < corner_map_size; ++p) {
+    const CornerIndex corner_id = this->mesh_data().data_to_corner_map()->at(p);
+    if (!predictor_.template ComputePredictedValue<false>(corner_id, out_data,
+                                                          p)) {
+      return false;
+    }
+
+    const int dst_offset = p * num_components;
+    this->transform().ComputeOriginalValue(predictor_.predicted_value(),
+                                           in_corr + dst_offset,
+                                           out_data + dst_offset);
+  }
+  return true;
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeTexCoordsPortableDecoder<
+    DataTypeT, TransformT, MeshDataT>::DecodePredictionData(DecoderBuffer
+                                                                *buffer) {
+  // Decode the delta coded orientations.
+  int32_t num_orientations = 0;
+  if (!buffer->Decode(&num_orientations) || num_orientations < 0) {
+    return false;
+  }
+  predictor_.ResizeOrientations(num_orientations);
+  bool last_orientation = true;
+  RAnsBitDecoder decoder;
+  if (!decoder.StartDecoding(buffer)) {
+    return false;
+  }
+  for (int i = 0; i < num_orientations; ++i) {
+    if (!decoder.DecodeNextBit()) {
+      last_orientation = !last_orientation;
+    }
+    predictor_.set_orientation(i, last_orientation);
+  }
+  decoder.EndDecoding();
+  return MeshPredictionSchemeDecoder<DataTypeT, TransformT,
+                                     MeshDataT>::DecodePredictionData(buffer);
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_PORTABLE_DECODER_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_encoder.h b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_encoder.h
new file mode 100644
index 00000000..741ec66d
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_encoder.h
@@ -0,0 +1,133 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_PORTABLE_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_PORTABLE_ENCODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_predictor.h"
+#include "draco/compression/bit_coders/rans_bit_encoder.h"
+
+namespace draco {
+
+// Prediction scheme designed for predicting texture coordinates from known
+// spatial position of vertices. For isometric parametrizations, the ratios
+// between triangle edge lengths should be about the same in both the spatial
+// and UV coordinate spaces, which makes the positions a good predictor for the
+// UV coordinates. Note that this may not be the optimal approach for other
+// parametrizations such as projective ones.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeTexCoordsPortableEncoder
+    : public MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType = typename MeshPredictionSchemeEncoder<DataTypeT, TransformT,
+                                                        MeshDataT>::CorrType;
+  MeshPredictionSchemeTexCoordsPortableEncoder(const PointAttribute *attribute,
+                                               const TransformT &transform,
+                                               const MeshDataT &mesh_data)
+      : MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data),
+        predictor_(mesh_data) {}
+
+  bool ComputeCorrectionValues(
+      const DataTypeT *in_data, CorrType *out_corr, int size,
+      int num_components, const PointIndex *entry_to_point_id_map) override;
+
+  bool EncodePredictionData(EncoderBuffer *buffer) override;
+
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_TEX_COORDS_PORTABLE;
+  }
+
+  bool IsInitialized() const override {
+    if (!predictor_.IsInitialized()) {
+      return false;
+    }
+    if (!this->mesh_data().IsInitialized()) {
+      return false;
+    }
+    return true;
+  }
+
+  int GetNumParentAttributes() const override { return 1; }
+
+  GeometryAttribute::Type GetParentAttributeType(int i) const override {
+    DRACO_DCHECK_EQ(i, 0);
+    (void)i;
+    return GeometryAttribute::POSITION;
+  }
+
+  bool SetParentAttribute(const PointAttribute *att) override {
+    if (att->attribute_type() != GeometryAttribute::POSITION) {
+      return false;  // Invalid attribute type.
+    }
+    if (att->num_components() != 3) {
+      return false;  // Currently works only for 3 component positions.
+    }
+    predictor_.SetPositionAttribute(*att);
+    return true;
+  }
+
+ private:
+  MeshPredictionSchemeTexCoordsPortablePredictor<DataTypeT, MeshDataT>
+      predictor_;
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeTexCoordsPortableEncoder<DataTypeT, TransformT,
+                                                  MeshDataT>::
+    ComputeCorrectionValues(const DataTypeT *in_data, CorrType *out_corr,
+                            int size, int num_components,
+                            const PointIndex *entry_to_point_id_map) {
+  predictor_.SetEntryToPointIdMap(entry_to_point_id_map);
+  this->transform().Init(in_data, size, num_components);
+  // We start processing from the end because this prediction uses data from
+  // previous entries that could be overwritten when an entry is processed.
+  for (int p =
+           static_cast<int>(this->mesh_data().data_to_corner_map()->size() - 1);
+       p >= 0; --p) {
+    const CornerIndex corner_id = this->mesh_data().data_to_corner_map()->at(p);
+    predictor_.template ComputePredictedValue<true>(corner_id, in_data, p);
+
+    const int dst_offset = p * num_components;
+    this->transform().ComputeCorrection(in_data + dst_offset,
+                                        predictor_.predicted_value(),
+                                        out_corr + dst_offset);
+  }
+  return true;
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeTexCoordsPortableEncoder<
+    DataTypeT, TransformT, MeshDataT>::EncodePredictionData(EncoderBuffer
+                                                                *buffer) {
+  // Encode the delta-coded orientations using arithmetic coding.
+  const int32_t num_orientations = predictor_.num_orientations();
+  buffer->Encode(num_orientations);
+  bool last_orientation = true;
+  RAnsBitEncoder encoder;
+  encoder.StartEncoding();
+  for (int i = 0; i < num_orientations; ++i) {
+    const bool orientation = predictor_.orientation(i);
+    encoder.EncodeBit(orientation == last_orientation);
+    last_orientation = orientation;
+  }
+  encoder.EndEncoding(buffer);
+  return MeshPredictionSchemeEncoder<DataTypeT, TransformT,
+                                     MeshDataT>::EncodePredictionData(buffer);
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_PORTABLE_ENCODER_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_predictor.h b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_predictor.h
new file mode 100644
index 00000000..f05e5ddd
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_predictor.h
@@ -0,0 +1,263 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_PORTABLE_PREDICTOR_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_PORTABLE_PREDICTOR_H_
+
+#include <math.h>
+
+#include "draco/attributes/point_attribute.h"
+#include "draco/core/math_utils.h"
+#include "draco/core/vector_d.h"
+#include "draco/mesh/corner_table.h"
+
+namespace draco {
+
+// Predictor functionality used for portable UV prediction by both encoder and
+// decoder.
+template <typename DataTypeT, class MeshDataT>
+class MeshPredictionSchemeTexCoordsPortablePredictor {
+ public:
+  static constexpr int kNumComponents = 2;
+
+  explicit MeshPredictionSchemeTexCoordsPortablePredictor(const MeshDataT &md)
+      : pos_attribute_(nullptr),
+        entry_to_point_id_map_(nullptr),
+        mesh_data_(md) {}
+  void SetPositionAttribute(const PointAttribute &position_attribute) {
+    pos_attribute_ = &position_attribute;
+  }
+  void SetEntryToPointIdMap(const PointIndex *map) {
+    entry_to_point_id_map_ = map;
+  }
+  bool IsInitialized() const { return pos_attribute_ != nullptr; }
+
+  VectorD<int64_t, 3> GetPositionForEntryId(int entry_id) const {
+    const PointIndex point_id = entry_to_point_id_map_[entry_id];
+    VectorD<int64_t, 3> pos;
+    pos_attribute_->ConvertValue(pos_attribute_->mapped_index(point_id),
+                                 &pos[0]);
+    return pos;
+  }
+
+  VectorD<int64_t, 2> GetTexCoordForEntryId(int entry_id,
+                                            const DataTypeT *data) const {
+    const int data_offset = entry_id * kNumComponents;
+    return VectorD<int64_t, 2>(data[data_offset], data[data_offset + 1]);
+  }
+
+  // Computes predicted UV coordinates on a given corner. The coordinates are
+  // stored in |predicted_value_| member.
+  template <bool is_encoder_t>
+  bool ComputePredictedValue(CornerIndex corner_id, const DataTypeT *data,
+                             int data_id);
+
+  const DataTypeT *predicted_value() const { return predicted_value_; }
+  bool orientation(int i) const { return orientations_[i]; }
+  void set_orientation(int i, bool v) { orientations_[i] = v; }
+  size_t num_orientations() const { return orientations_.size(); }
+  void ResizeOrientations(int num_orientations) {
+    orientations_.resize(num_orientations);
+  }
+
+ private:
+  const PointAttribute *pos_attribute_;
+  const PointIndex *entry_to_point_id_map_;
+  DataTypeT predicted_value_[kNumComponents];
+  // Encoded / decoded array of UV flips.
+  // TODO(ostava): We should remove this and replace this with in-place encoding
+  // and decoding to avoid unnecessary copy.
+  std::vector<bool> orientations_;
+  MeshDataT mesh_data_;
+};
+
+template <typename DataTypeT, class MeshDataT>
+template <bool is_encoder_t>
+bool MeshPredictionSchemeTexCoordsPortablePredictor<
+    DataTypeT, MeshDataT>::ComputePredictedValue(CornerIndex corner_id,
+                                                 const DataTypeT *data,
+                                                 int data_id) {
+  // Compute the predicted UV coordinate from the positions on all corners
+  // of the processed triangle. For the best prediction, the UV coordinates
+  // on the next/previous corners need to be already encoded/decoded.
+  const CornerIndex next_corner_id = mesh_data_.corner_table()->Next(corner_id);
+  const CornerIndex prev_corner_id =
+      mesh_data_.corner_table()->Previous(corner_id);
+  // Get the encoded data ids from the next and previous corners.
+  // The data id is the encoding order of the UV coordinates.
+  int next_data_id, prev_data_id;
+
+  int next_vert_id, prev_vert_id;
+  next_vert_id = mesh_data_.corner_table()->Vertex(next_corner_id).value();
+  prev_vert_id = mesh_data_.corner_table()->Vertex(prev_corner_id).value();
+
+  next_data_id = mesh_data_.vertex_to_data_map()->at(next_vert_id);
+  prev_data_id = mesh_data_.vertex_to_data_map()->at(prev_vert_id);
+
+  if (prev_data_id < data_id && next_data_id < data_id) {
+    // Both other corners have available UV coordinates for prediction.
+    const VectorD<int64_t, 2> n_uv = GetTexCoordForEntryId(next_data_id, data);
+    const VectorD<int64_t, 2> p_uv = GetTexCoordForEntryId(prev_data_id, data);
+    if (p_uv == n_uv) {
+      // We cannot do a reliable prediction on degenerated UV triangles.
+      predicted_value_[0] = p_uv[0];
+      predicted_value_[1] = p_uv[1];
+      return true;
+    }
+
+    // Get positions at all corners.
+    const VectorD<int64_t, 3> tip_pos = GetPositionForEntryId(data_id);
+    const VectorD<int64_t, 3> next_pos = GetPositionForEntryId(next_data_id);
+    const VectorD<int64_t, 3> prev_pos = GetPositionForEntryId(prev_data_id);
+    // We use the positions of the above triangle to predict the texture
+    // coordinate on the tip corner C.
+    // To convert the triangle into the UV coordinate system we first compute
+    // position X on the vector |prev_pos - next_pos| that is the projection of
+    // point C onto vector |prev_pos - next_pos|:
+    //
+    //              C
+    //             /.  \
+    //            / .     \
+    //           /  .        \
+    //          N---X----------P
+    //
+    // Where next_pos is point (N), prev_pos is point (P) and tip_pos is the
+    // position of predicted coordinate (C).
+    //
+    const VectorD<int64_t, 3> pn = prev_pos - next_pos;
+    const uint64_t pn_norm2_squared = pn.SquaredNorm();
+    if (pn_norm2_squared != 0) {
+      // Compute the projection of C onto PN by computing dot product of CN with
+      // PN and normalizing it by length of PN. This gives us a factor |s| where
+      // |s = PN.Dot(CN) / PN.SquaredNorm2()|. This factor can be used to
+      // compute X in UV space |X_UV| as |X_UV = N_UV + s * PN_UV|.
+      const VectorD<int64_t, 3> cn = tip_pos - next_pos;
+      const int64_t cn_dot_pn = pn.Dot(cn);
+
+      const VectorD<int64_t, 2> pn_uv = p_uv - n_uv;
+      // Because we perform all computations with integers, we don't explicitly
+      // compute the normalized factor |s|, but rather we perform all operations
+      // over UV vectors in a non-normalized coordinate system scaled with a
+      // scaling factor |pn_norm2_squared|:
+      //
+      //      x_uv = X_UV * PN.Norm2Squared()
+      //
+      const VectorD<int64_t, 2> x_uv =
+          n_uv * pn_norm2_squared + (cn_dot_pn * pn_uv);
+
+      const int64_t pn_absmax_element =
+          std::max(std::max(std::abs(pn[0]), std::abs(pn[1])), std::abs(pn[2]));
+      if (cn_dot_pn > std::numeric_limits<int64_t>::max() / pn_absmax_element) {
+        // return false if squared length calculation would overflow.
+        return false;
+      }
+
+      // Compute squared length of vector CX in position coordinate system:
+      const VectorD<int64_t, 3> x_pos =
+          next_pos + (cn_dot_pn * pn) / pn_norm2_squared;
+      const uint64_t cx_norm2_squared = (tip_pos - x_pos).SquaredNorm();
+
+      // Compute vector CX_UV in the uv space by rotating vector PN_UV by 90
+      // degrees and scaling it with factor CX.Norm2() / PN.Norm2():
+      //
+      //     CX_UV = (CX.Norm2() / PN.Norm2()) * Rot(PN_UV)
+      //
+      // To preserve precision, we perform all operations in scaled space as
+      // explained above, so we want the final vector to be:
+      //
+      //     cx_uv = CX_UV * PN.Norm2Squared()
+      //
+      // We can then rewrite the formula as:
+      //
+      //     cx_uv = CX.Norm2() * PN.Norm2() * Rot(PN_UV)
+      //
+      VectorD<int64_t, 2> cx_uv(pn_uv[1], -pn_uv[0]);  // Rotated PN_UV.
+      // Compute CX.Norm2() * PN.Norm2()
+      const uint64_t norm_squared =
+          IntSqrt(cx_norm2_squared * pn_norm2_squared);
+      // Final cx_uv in the scaled coordinate space.
+      cx_uv = cx_uv * norm_squared;
+
+      // Predicted uv coordinate is then computed by either adding or
+      // subtracting CX_UV to/from X_UV.
+      VectorD<int64_t, 2> predicted_uv;
+      if (is_encoder_t) {
+        // When encoding, compute both possible vectors and determine which one
+        // results in a better prediction.
+        // Both vectors need to be transformed back from the scaled space to
+        // the real UV coordinate space.
+        const VectorD<int64_t, 2> predicted_uv_0((x_uv + cx_uv) /
+                                                 pn_norm2_squared);
+        const VectorD<int64_t, 2> predicted_uv_1((x_uv - cx_uv) /
+                                                 pn_norm2_squared);
+        const VectorD<int64_t, 2> c_uv = GetTexCoordForEntryId(data_id, data);
+        if ((c_uv - predicted_uv_0).SquaredNorm() <
+            (c_uv - predicted_uv_1).SquaredNorm()) {
+          predicted_uv = predicted_uv_0;
+          orientations_.push_back(true);
+        } else {
+          predicted_uv = predicted_uv_1;
+          orientations_.push_back(false);
+        }
+      } else {
+        // When decoding the data, we already know which orientation to use.
+        if (orientations_.empty()) {
+          return false;
+        }
+        const bool orientation = orientations_.back();
+        orientations_.pop_back();
+        if (orientation) {
+          predicted_uv = (x_uv + cx_uv) / pn_norm2_squared;
+        } else {
+          predicted_uv = (x_uv - cx_uv) / pn_norm2_squared;
+        }
+      }
+      predicted_value_[0] = static_cast<int>(predicted_uv[0]);
+      predicted_value_[1] = static_cast<int>(predicted_uv[1]);
+      return true;
+    }
+  }
+  // Else we don't have available textures on both corners or the position data
+  // is invalid. For such cases we can't use positions for predicting the uv
+  // value and we resort to delta coding.
+  int data_offset = 0;
+  if (prev_data_id < data_id) {
+    // Use the value on the previous corner as the prediction.
+    data_offset = prev_data_id * kNumComponents;
+  }
+  if (next_data_id < data_id) {
+    // Use the value on the next corner as the prediction.
+    data_offset = next_data_id * kNumComponents;
+  } else {
+    // None of the other corners have a valid value. Use the last encoded value
+    // as the prediction if possible.
+    if (data_id > 0) {
+      data_offset = (data_id - 1) * kNumComponents;
+    } else {
+      // We are encoding the first value. Predict 0.
+      for (int i = 0; i < kNumComponents; ++i) {
+        predicted_value_[i] = 0;
+      }
+      return true;
+    }
+  }
+  for (int i = 0; i < kNumComponents; ++i) {
+    predicted_value_[i] = data[data_offset + i];
+  }
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_PORTABLE_PREDICTOR_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder.h b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder.h
new file mode 100644
index 00000000..064e1b44
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder.h
@@ -0,0 +1,90 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODER_H_
+
+#include <type_traits>
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_interface.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_decoding_transform.h"
+
+// Prediction schemes can be used during encoding and decoding of vertex
+// attributes to predict attribute values based on the previously
+// encoded/decoded data. The differences between the original and predicted
+// attribute values are used to compute correction values that can be usually
+// encoded with fewer bits compared to the original data.
+namespace draco {
+
+// Abstract base class for typed prediction schemes. It provides basic access
+// to the encoded attribute and to the supplied prediction transform.
+template <typename DataTypeT,
+          class TransformT =
+              PredictionSchemeDecodingTransform<DataTypeT, DataTypeT>>
+class PredictionSchemeDecoder : public PredictionSchemeTypedDecoderInterface<
+                                    DataTypeT, typename TransformT::CorrType> {
+ public:
+  typedef DataTypeT DataType;
+  typedef TransformT Transform;
+  // Correction type needs to be defined in the prediction transform class.
+  typedef typename Transform::CorrType CorrType;
+  explicit PredictionSchemeDecoder(const PointAttribute *attribute)
+      : PredictionSchemeDecoder(attribute, Transform()) {}
+  PredictionSchemeDecoder(const PointAttribute *attribute,
+                          const Transform &transform)
+      : attribute_(attribute), transform_(transform) {}
+
+  bool DecodePredictionData(DecoderBuffer *buffer) override {
+    if (!transform_.DecodeTransformData(buffer)) {
+      return false;
+    }
+    return true;
+  }
+
+  const PointAttribute *GetAttribute() const override { return attribute(); }
+
+  // Returns the number of parent attributes that are needed for the prediction.
+  int GetNumParentAttributes() const override { return 0; }
+
+  // Returns the type of each of the parent attribute.
+  GeometryAttribute::Type GetParentAttributeType(int /* i */) const override {
+    return GeometryAttribute::INVALID;
+  }
+
+  // Sets the required parent attribute.
+  bool SetParentAttribute(const PointAttribute * /* att */) override {
+    return false;
+  }
+
+  bool AreCorrectionsPositive() override {
+    return transform_.AreCorrectionsPositive();
+  }
+
+  PredictionSchemeTransformType GetTransformType() const override {
+    return transform_.GetType();
+  }
+
+ protected:
+  inline const PointAttribute *attribute() const { return attribute_; }
+  inline const Transform &transform() const { return transform_; }
+  inline Transform &transform() { return transform_; }
+
+ private:
+  const PointAttribute *attribute_;
+  Transform transform_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODER_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_factory.h b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_factory.h
new file mode 100644
index 00000000..cf2a6ba6
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_factory.h
@@ -0,0 +1,194 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Functions for creating prediction schemes for decoders using the provided
+// prediction method id.
+
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODER_FACTORY_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODER_FACTORY_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_decoder.h"
+#include "draco/draco_features.h"
+#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_decoder.h"
+#endif
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_delta_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_factory.h"
+#include "draco/compression/mesh/mesh_decoder.h"
+
+namespace draco {
+
+// Factory class for creating mesh prediction schemes. The factory implements
+// operator() that is used to create an appropriate mesh prediction scheme in
+// CreateMeshPredictionScheme() function in prediction_scheme_factory.h
+template <typename DataTypeT>
+struct MeshPredictionSchemeDecoderFactory {
+  // Operator () specialized for the wrap transform. Wrap transform can be used
+  // for all mesh prediction schemes. The specialization is done in compile time
+  // to prevent instantiations of unneeded combinations of prediction schemes +
+  // prediction transforms.
+  template <class TransformT, class MeshDataT,
+            PredictionSchemeTransformType Method>
+  struct DispatchFunctor {
+    std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>> operator()(
+        PredictionSchemeMethod method, const PointAttribute *attribute,
+        const TransformT &transform, const MeshDataT &mesh_data,
+        uint16_t bitstream_version) {
+      if (method == MESH_PREDICTION_PARALLELOGRAM) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeParallelogramDecoder<DataTypeT, TransformT,
+                                                         MeshDataT>(
+                attribute, transform, mesh_data));
+      }
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+      else if (method == MESH_PREDICTION_MULTI_PARALLELOGRAM) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeMultiParallelogramDecoder<
+                DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                  mesh_data));
+      }
+#endif
+      else if (method == MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeConstrainedMultiParallelogramDecoder<
+                DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                  mesh_data));
+      }
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+      else if (method == MESH_PREDICTION_TEX_COORDS_DEPRECATED) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeTexCoordsDecoder<DataTypeT, TransformT,
+                                                     MeshDataT>(
+                attribute, transform, mesh_data, bitstream_version));
+      }
+#endif
+      else if (method == MESH_PREDICTION_TEX_COORDS_PORTABLE) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeTexCoordsPortableDecoder<
+                DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                  mesh_data));
+      }
+#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
+      else if (method == MESH_PREDICTION_GEOMETRIC_NORMAL) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeGeometricNormalDecoder<
+                DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                  mesh_data));
+      }
+#endif
+      return nullptr;
+    }
+  };
+
+#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
+  // Operator () specialized for normal octahedron transforms. These transforms
+  // are currently used only by the geometric normal prediction scheme (the
+  // transform is also used by delta coding, but delta predictor is not
+  // constructed in this function).
+  template <class TransformT, class MeshDataT>
+  struct DispatchFunctor<TransformT, MeshDataT,
+                         PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON_CANONICALIZED> {
+    std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>> operator()(
+        PredictionSchemeMethod method, const PointAttribute *attribute,
+        const TransformT &transform, const MeshDataT &mesh_data,
+        uint16_t bitstream_version) {
+      if (method == MESH_PREDICTION_GEOMETRIC_NORMAL) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeGeometricNormalDecoder<
+                DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                  mesh_data));
+      }
+      return nullptr;
+    }
+  };
+  template <class TransformT, class MeshDataT>
+  struct DispatchFunctor<TransformT, MeshDataT,
+                         PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON> {
+    std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>> operator()(
+        PredictionSchemeMethod method, const PointAttribute *attribute,
+        const TransformT &transform, const MeshDataT &mesh_data,
+        uint16_t bitstream_version) {
+      if (method == MESH_PREDICTION_GEOMETRIC_NORMAL) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeGeometricNormalDecoder<
+                DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                  mesh_data));
+      }
+      return nullptr;
+    }
+  };
+#endif
+
+  template <class TransformT, class MeshDataT>
+  std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>> operator()(
+      PredictionSchemeMethod method, const PointAttribute *attribute,
+      const TransformT &transform, const MeshDataT &mesh_data,
+      uint16_t bitstream_version) {
+    return DispatchFunctor<TransformT, MeshDataT, TransformT::GetType()>()(
+        method, attribute, transform, mesh_data, bitstream_version);
+  }
+};
+
+// Creates a prediction scheme for a given decoder and given prediction method.
+// The prediction schemes are automatically initialized with decoder specific
+// data if needed.
+template <typename DataTypeT, class TransformT>
+std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>
+CreatePredictionSchemeForDecoder(PredictionSchemeMethod method, int att_id,
+                                 const PointCloudDecoder *decoder,
+                                 const TransformT &transform) {
+  if (method == PREDICTION_NONE) {
+    return nullptr;
+  }
+  const PointAttribute *const att = decoder->point_cloud()->attribute(att_id);
+  if (decoder->GetGeometryType() == TRIANGULAR_MESH) {
+    // Cast the decoder to mesh decoder. This is not necessarily safe if there
+    // is some other decoder decides to use TRIANGULAR_MESH as the return type,
+    // but unfortunately there is not nice work around for this without using
+    // RTTI (double dispatch and similar concepts will not work because of the
+    // template nature of the prediction schemes).
+    const MeshDecoder *const mesh_decoder =
+        static_cast<const MeshDecoder *>(decoder);
+
+    auto ret = CreateMeshPredictionScheme<
+        MeshDecoder, PredictionSchemeDecoder<DataTypeT, TransformT>,
+        MeshPredictionSchemeDecoderFactory<DataTypeT>>(
+        mesh_decoder, method, att_id, transform, decoder->bitstream_version());
+    if (ret) {
+      return ret;
+    }
+    // Otherwise try to create another prediction scheme.
+  }
+  // Create delta decoder.
+  return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+      new PredictionSchemeDeltaDecoder<DataTypeT, TransformT>(att, transform));
+}
+
+// Create a prediction scheme using a default transform constructor.
+template <typename DataTypeT, class TransformT>
+std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>
+CreatePredictionSchemeForDecoder(PredictionSchemeMethod method, int att_id,
+                                 const PointCloudDecoder *decoder) {
+  return CreatePredictionSchemeForDecoder<DataTypeT, TransformT>(
+      method, att_id, decoder, TransformT());
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODER_FACTORY_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_interface.h b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_interface.h
new file mode 100644
index 00000000..6f19f7fd
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_interface.h
@@ -0,0 +1,53 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODER_INTERFACE_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODER_INTERFACE_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_interface.h"
+#include "draco/core/decoder_buffer.h"
+
+// Prediction schemes can be used during encoding and decoding of attributes
+// to predict attribute values based on the previously encoded/decoded data.
+// See prediction_scheme.h for more details.
+namespace draco {
+
+// Abstract interface for all prediction schemes used during attribute encoding.
+class PredictionSchemeDecoderInterface : public PredictionSchemeInterface {
+ public:
+  // Method that can be used to decode any prediction scheme specific data
+  // from the input buffer.
+  virtual bool DecodePredictionData(DecoderBuffer *buffer) = 0;
+};
+
+// A specialized version of the prediction scheme interface for specific
+// input and output data types.
+// |entry_to_point_id_map| is the mapping between value entries to point ids
+// of the associated point cloud, where one entry is defined as |num_components|
+// values of the |in_data|.
+// DataTypeT is the data type of input and predicted values.
+// CorrTypeT is the data type used for storing corrected values.
+template <typename DataTypeT, typename CorrTypeT = DataTypeT>
+class PredictionSchemeTypedDecoderInterface
+    : public PredictionSchemeDecoderInterface {
+ public:
+  // Reverts changes made by the prediction scheme during encoding.
+  virtual bool ComputeOriginalValues(
+      const CorrTypeT *in_corr, DataTypeT *out_data, int size,
+      int num_components, const PointIndex *entry_to_point_id_map) = 0;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODER_INTERFACE_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_decoding_transform.h b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_decoding_transform.h
new file mode 100644
index 00000000..47c1532a
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_decoding_transform.h
@@ -0,0 +1,65 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODING_TRANSFORM_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODING_TRANSFORM_H_
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+
+// PredictionSchemeDecodingTransform is used to transform predicted values and
+// correction values into the final original attribute values.
+// DataTypeT is the data type of predicted values.
+// CorrTypeT is the data type used for storing corrected values. It allows
+// transforms to store corrections into a different type or format compared to
+// the predicted data.
+template <typename DataTypeT, typename CorrTypeT>
+class PredictionSchemeDecodingTransform {
+ public:
+  typedef CorrTypeT CorrType;
+  PredictionSchemeDecodingTransform() : num_components_(0) {}
+
+  void Init(int num_components) { num_components_ = num_components; }
+
+  // Computes the original value from the input predicted value and the decoded
+  // corrections. The default implementation is equal to std:plus.
+  inline void ComputeOriginalValue(const DataTypeT *predicted_vals,
+                                   const CorrTypeT *corr_vals,
+                                   DataTypeT *out_original_vals) const {
+    static_assert(std::is_same<DataTypeT, CorrTypeT>::value,
+                  "For the default prediction transform, correction and input "
+                  "data must be of the same type.");
+    for (int i = 0; i < num_components_; ++i) {
+      out_original_vals[i] = predicted_vals[i] + corr_vals[i];
+    }
+  }
+
+  // Decodes any transform specific data. Called before Init() method.
+  bool DecodeTransformData(DecoderBuffer * /* buffer */) { return true; }
+
+  // Should return true if all corrected values are guaranteed to be positive.
+  bool AreCorrectionsPositive() const { return false; }
+
+ protected:
+  int num_components() const { return num_components_; }
+
+ private:
+  int num_components_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODING_TRANSFORM_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_delta_decoder.h b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_delta_decoder.h
new file mode 100644
index 00000000..ae72c712
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_delta_decoder.h
@@ -0,0 +1,65 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DELTA_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DELTA_DECODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_decoder.h"
+
+namespace draco {
+
+// Decoder for values encoded with delta coding. See the corresponding encoder
+// for more details.
+template <typename DataTypeT, class TransformT>
+class PredictionSchemeDeltaDecoder
+    : public PredictionSchemeDecoder<DataTypeT, TransformT> {
+ public:
+  using CorrType =
+      typename PredictionSchemeDecoder<DataTypeT, TransformT>::CorrType;
+  // Initialized the prediction scheme.
+  explicit PredictionSchemeDeltaDecoder(const PointAttribute *attribute)
+      : PredictionSchemeDecoder<DataTypeT, TransformT>(attribute) {}
+  PredictionSchemeDeltaDecoder(const PointAttribute *attribute,
+                               const TransformT &transform)
+      : PredictionSchemeDecoder<DataTypeT, TransformT>(attribute, transform) {}
+
+  bool ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                             int size, int num_components,
+                             const PointIndex *entry_to_point_id_map) override;
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return PREDICTION_DIFFERENCE;
+  }
+  bool IsInitialized() const override { return true; }
+};
+
+template <typename DataTypeT, class TransformT>
+bool PredictionSchemeDeltaDecoder<DataTypeT, TransformT>::ComputeOriginalValues(
+    const CorrType *in_corr, DataTypeT *out_data, int size, int num_components,
+    const PointIndex *) {
+  this->transform().Init(num_components);
+  // Decode the original value for the first element.
+  std::unique_ptr<DataTypeT[]> zero_vals(new DataTypeT[num_components]());
+  this->transform().ComputeOriginalValue(zero_vals.get(), in_corr, out_data);
+
+  // Decode data from the front using D(i) = D(i) + D(i - 1).
+  for (int i = num_components; i < size; i += num_components) {
+    this->transform().ComputeOriginalValue(out_data + i - num_components,
+                                           in_corr + i, out_data + i);
+  }
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DELTA_DECODER_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_delta_encoder.h b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_delta_encoder.h
new file mode 100644
index 00000000..324afafa
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_delta_encoder.h
@@ -0,0 +1,69 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DELTA_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DELTA_ENCODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_encoder.h"
+
+namespace draco {
+
+// Basic prediction scheme based on computing backward differences between
+// stored attribute values (also known as delta-coding). Usually works better
+// than the reference point prediction scheme, because nearby values are often
+// encoded next to each other.
+template <typename DataTypeT, class TransformT>
+class PredictionSchemeDeltaEncoder
+    : public PredictionSchemeEncoder<DataTypeT, TransformT> {
+ public:
+  using CorrType =
+      typename PredictionSchemeEncoder<DataTypeT, TransformT>::CorrType;
+  // Initialized the prediction scheme.
+  explicit PredictionSchemeDeltaEncoder(const PointAttribute *attribute)
+      : PredictionSchemeEncoder<DataTypeT, TransformT>(attribute) {}
+  PredictionSchemeDeltaEncoder(const PointAttribute *attribute,
+                               const TransformT &transform)
+      : PredictionSchemeEncoder<DataTypeT, TransformT>(attribute, transform) {}
+
+  bool ComputeCorrectionValues(
+      const DataTypeT *in_data, CorrType *out_corr, int size,
+      int num_components, const PointIndex *entry_to_point_id_map) override;
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return PREDICTION_DIFFERENCE;
+  }
+  bool IsInitialized() const override { return true; }
+};
+
+template <typename DataTypeT, class TransformT>
+bool PredictionSchemeDeltaEncoder<
+    DataTypeT, TransformT>::ComputeCorrectionValues(const DataTypeT *in_data,
+                                                    CorrType *out_corr,
+                                                    int size,
+                                                    int num_components,
+                                                    const PointIndex *) {
+  this->transform().Init(in_data, size, num_components);
+  // Encode data from the back using D(i) = D(i) - D(i - 1).
+  for (int i = size - num_components; i > 0; i -= num_components) {
+    this->transform().ComputeCorrection(
+        in_data + i, in_data + i - num_components, out_corr + i);
+  }
+  // Encode correction for the first element.
+  std::unique_ptr<DataTypeT[]> zero_vals(new DataTypeT[num_components]());
+  this->transform().ComputeCorrection(in_data, zero_vals.get(), out_corr);
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DELTA_ENCODER_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder.h b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder.h
new file mode 100644
index 00000000..2a211a9f
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder.h
@@ -0,0 +1,90 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_H_
+
+#include <type_traits>
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_interface.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_encoding_transform.h"
+
+// Prediction schemes can be used during encoding and decoding of vertex
+// attributes to predict attribute values based on the previously
+// encoded/decoded data. The differences between the original and predicted
+// attribute values are used to compute correction values that can be usually
+// encoded with fewer bits compared to the original data.
+namespace draco {
+
+// Abstract base class for typed prediction schemes. It provides basic access
+// to the encoded attribute and to the supplied prediction transform.
+template <typename DataTypeT,
+          class TransformT =
+              PredictionSchemeEncodingTransform<DataTypeT, DataTypeT>>
+class PredictionSchemeEncoder : public PredictionSchemeTypedEncoderInterface<
+                                    DataTypeT, typename TransformT::CorrType> {
+ public:
+  typedef DataTypeT DataType;
+  typedef TransformT Transform;
+  // Correction type needs to be defined in the prediction transform class.
+  typedef typename Transform::CorrType CorrType;
+  explicit PredictionSchemeEncoder(const PointAttribute *attribute)
+      : PredictionSchemeEncoder(attribute, Transform()) {}
+  PredictionSchemeEncoder(const PointAttribute *attribute,
+                          const Transform &transform)
+      : attribute_(attribute), transform_(transform) {}
+
+  bool EncodePredictionData(EncoderBuffer *buffer) override {
+    if (!transform_.EncodeTransformData(buffer)) {
+      return false;
+    }
+    return true;
+  }
+
+  const PointAttribute *GetAttribute() const override { return attribute(); }
+
+  // Returns the number of parent attributes that are needed for the prediction.
+  int GetNumParentAttributes() const override { return 0; }
+
+  // Returns the type of each of the parent attribute.
+  GeometryAttribute::Type GetParentAttributeType(int /* i */) const override {
+    return GeometryAttribute::INVALID;
+  }
+
+  // Sets the required parent attribute.
+  bool SetParentAttribute(const PointAttribute * /* att */) override {
+    return false;
+  }
+
+  bool AreCorrectionsPositive() override {
+    return transform_.AreCorrectionsPositive();
+  }
+
+  PredictionSchemeTransformType GetTransformType() const override {
+    return transform_.GetType();
+  }
+
+ protected:
+  inline const PointAttribute *attribute() const { return attribute_; }
+  inline const Transform &transform() const { return transform_; }
+  inline Transform &transform() { return transform_; }
+
+ private:
+  const PointAttribute *attribute_;
+  Transform transform_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_factory.h b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_factory.h
new file mode 100644
index 00000000..40a7683a
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_factory.h
@@ -0,0 +1,129 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Functions for creating prediction schemes for encoders using the provided
+// prediction method id.
+
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_FACTORY_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_FACTORY_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_encoder.h"
+#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_encoder.h"
+#endif
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_delta_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_factory.h"
+#include "draco/compression/mesh/mesh_encoder.h"
+
+namespace draco {
+
+// Selects a prediction method based on the input geometry type and based on the
+// encoder options.
+PredictionSchemeMethod SelectPredictionMethod(int att_id,
+                                              const PointCloudEncoder *encoder);
+
+// Factory class for creating mesh prediction schemes.
+template <typename DataTypeT>
+struct MeshPredictionSchemeEncoderFactory {
+  template <class TransformT, class MeshDataT>
+  std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>> operator()(
+      PredictionSchemeMethod method, const PointAttribute *attribute,
+      const TransformT &transform, const MeshDataT &mesh_data,
+      uint16_t bitstream_version) {
+    if (method == MESH_PREDICTION_PARALLELOGRAM) {
+      return std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>>(
+          new MeshPredictionSchemeParallelogramEncoder<DataTypeT, TransformT,
+                                                       MeshDataT>(
+              attribute, transform, mesh_data));
+    } else if (method == MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM) {
+      return std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>>(
+          new MeshPredictionSchemeConstrainedMultiParallelogramEncoder<
+              DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                mesh_data));
+    } else if (method == MESH_PREDICTION_TEX_COORDS_PORTABLE) {
+      return std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>>(
+          new MeshPredictionSchemeTexCoordsPortableEncoder<
+              DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                mesh_data));
+    }
+#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
+    else if (method == MESH_PREDICTION_GEOMETRIC_NORMAL) {
+      return std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>>(
+          new MeshPredictionSchemeGeometricNormalEncoder<DataTypeT, TransformT,
+                                                         MeshDataT>(
+              attribute, transform, mesh_data));
+    }
+#endif
+    return nullptr;
+  }
+};
+
+// Creates a prediction scheme for a given encoder and given prediction method.
+// The prediction schemes are automatically initialized with encoder specific
+// data if needed.
+template <typename DataTypeT, class TransformT>
+std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>>
+CreatePredictionSchemeForEncoder(PredictionSchemeMethod method, int att_id,
+                                 const PointCloudEncoder *encoder,
+                                 const TransformT &transform) {
+  const PointAttribute *const att = encoder->point_cloud()->attribute(att_id);
+  if (method == PREDICTION_UNDEFINED) {
+    method = SelectPredictionMethod(att_id, encoder);
+  }
+  if (method == PREDICTION_NONE) {
+    return nullptr;  // No prediction is used.
+  }
+  if (encoder->GetGeometryType() == TRIANGULAR_MESH) {
+    // Cast the encoder to mesh encoder. This is not necessarily safe if there
+    // is some other encoder decides to use TRIANGULAR_MESH as the return type,
+    // but unfortunately there is not nice work around for this without using
+    // RTTI (double dispatch and similar concepts will not work because of the
+    // template nature of the prediction schemes).
+    const MeshEncoder *const mesh_encoder =
+        static_cast<const MeshEncoder *>(encoder);
+    auto ret = CreateMeshPredictionScheme<
+        MeshEncoder, PredictionSchemeEncoder<DataTypeT, TransformT>,
+        MeshPredictionSchemeEncoderFactory<DataTypeT>>(
+        mesh_encoder, method, att_id, transform, kDracoMeshBitstreamVersion);
+    if (ret) {
+      return ret;
+    }
+    // Otherwise try to create another prediction scheme.
+  }
+  // Create delta encoder.
+  return std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>>(
+      new PredictionSchemeDeltaEncoder<DataTypeT, TransformT>(att, transform));
+}
+
+// Create a prediction scheme using a default transform constructor.
+template <typename DataTypeT, class TransformT>
+std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>>
+CreatePredictionSchemeForEncoder(PredictionSchemeMethod method, int att_id,
+                                 const PointCloudEncoder *encoder) {
+  return CreatePredictionSchemeForEncoder<DataTypeT, TransformT>(
+      method, att_id, encoder, TransformT());
+}
+
+// Returns the preferred prediction scheme based on the encoder options.
+PredictionSchemeMethod GetPredictionMethodFromOptions(
+    int att_id, const EncoderOptions &options);
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_FACTORY_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_interface.h b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_interface.h
new file mode 100644
index 00000000..37aa9f76
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_interface.h
@@ -0,0 +1,55 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_INTERFACE_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_INTERFACE_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_interface.h"
+#include "draco/core/encoder_buffer.h"
+
+// Prediction schemes can be used during encoding and decoding of attributes
+// to predict attribute values based on the previously encoded/decoded data.
+// See prediction_scheme.h for more details.
+namespace draco {
+
+// Abstract interface for all prediction schemes used during attribute encoding.
+class PredictionSchemeEncoderInterface : public PredictionSchemeInterface {
+ public:
+  // Method that can be used to encode any prediction scheme specific data
+  // into the output buffer.
+  virtual bool EncodePredictionData(EncoderBuffer *buffer) = 0;
+};
+
+// A specialized version of the prediction scheme interface for specific
+// input and output data types.
+// |entry_to_point_id_map| is the mapping between value entries to point ids
+// of the associated point cloud, where one entry is defined as |num_components|
+// values of the |in_data|.
+// DataTypeT is the data type of input and predicted values.
+// CorrTypeT is the data type used for storing corrected values.
+template <typename DataTypeT, typename CorrTypeT = DataTypeT>
+class PredictionSchemeTypedEncoderInterface
+    : public PredictionSchemeEncoderInterface {
+ public:
+  // Applies the prediction scheme when encoding the attribute.
+  // |in_data| contains value entries to be encoded.
+  // |out_corr| is an output array containing the to be encoded corrections.
+  virtual bool ComputeCorrectionValues(
+      const DataTypeT *in_data, CorrTypeT *out_corr, int size,
+      int num_components, const PointIndex *entry_to_point_id_map) = 0;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_INTERFACE_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_encoding_transform.h b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_encoding_transform.h
new file mode 100644
index 00000000..0929492a
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_encoding_transform.h
@@ -0,0 +1,77 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODING_TRANSFORM_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODING_TRANSFORM_H_
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// PredictionSchemeEncodingTransform is used to transform predicted values into
+// correction values.
+// CorrTypeT is the data type used for storing corrected values. It allows
+// transforms to store corrections into a different type or format compared to
+// the predicted data.
+template <typename DataTypeT, typename CorrTypeT>
+class PredictionSchemeEncodingTransform {
+ public:
+  typedef CorrTypeT CorrType;
+  PredictionSchemeEncodingTransform() : num_components_(0) {}
+
+  PredictionSchemeTransformType GetType() const {
+    return PREDICTION_TRANSFORM_DELTA;
+  }
+
+  // Performs any custom initialization of the transform for the encoder.
+  // |size| = total number of values in |orig_data| (i.e., number of entries *
+  // number of components).
+  void Init(const DataTypeT * /* orig_data */, int /* size */,
+            int num_components) {
+    num_components_ = num_components;
+  }
+
+  // Computes the corrections based on the input original values and the
+  // predicted values. The correction is always computed for all components
+  // of the input element. |val_id| is the id of the input value
+  // (i.e., element_id * num_components). The default implementation is equal to
+  // std::minus.
+  inline void ComputeCorrection(const DataTypeT *original_vals,
+                                const DataTypeT *predicted_vals,
+                                CorrTypeT *out_corr_vals) {
+    static_assert(std::is_same<DataTypeT, CorrTypeT>::value,
+                  "For the default prediction transform, correction and input "
+                  "data must be of the same type.");
+    for (int i = 0; i < num_components_; ++i) {
+      out_corr_vals[i] = original_vals[i] - predicted_vals[i];
+    }
+  }
+
+  // Encode any transform specific data.
+  bool EncodeTransformData(EncoderBuffer * /* buffer */) { return true; }
+
+  // Should return true if all corrected values are guaranteed to be positive.
+  bool AreCorrectionsPositive() const { return false; }
+
+ protected:
+  int num_components() const { return num_components_; }
+
+ private:
+  int num_components_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODING_TRANSFORM_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_factory.h b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_factory.h
new file mode 100644
index 00000000..b36c4c8a
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_factory.h
@@ -0,0 +1,85 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Functions for creating prediction schemes from a provided prediction method
+// name. The functions in this file can create only basic prediction schemes
+// that don't require any encoder or decoder specific data. To create more
+// sophisticated prediction schemes, use functions from either
+// prediction_scheme_encoder_factory.h  or,
+// prediction_scheme_decoder_factory.h.
+
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_FACTORY_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_FACTORY_H_
+
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_data.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/mesh/mesh_attribute_corner_table.h"
+
+namespace draco {
+
+template <class EncodingDataSourceT, class PredictionSchemeT,
+          class MeshPredictionSchemeFactoryT>
+std::unique_ptr<PredictionSchemeT> CreateMeshPredictionScheme(
+    const EncodingDataSourceT *source, PredictionSchemeMethod method,
+    int att_id, const typename PredictionSchemeT::Transform &transform,
+    uint16_t bitstream_version) {
+  const PointAttribute *const att = source->point_cloud()->attribute(att_id);
+  if (source->GetGeometryType() == TRIANGULAR_MESH &&
+      (method == MESH_PREDICTION_PARALLELOGRAM ||
+       method == MESH_PREDICTION_MULTI_PARALLELOGRAM ||
+       method == MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM ||
+       method == MESH_PREDICTION_TEX_COORDS_PORTABLE ||
+       method == MESH_PREDICTION_GEOMETRIC_NORMAL ||
+       method == MESH_PREDICTION_TEX_COORDS_DEPRECATED)) {
+    const CornerTable *const ct = source->GetCornerTable();
+    const MeshAttributeIndicesEncodingData *const encoding_data =
+        source->GetAttributeEncodingData(att_id);
+    if (ct == nullptr || encoding_data == nullptr) {
+      // No connectivity data found.
+      return nullptr;
+    }
+    // Connectivity data exists.
+    const MeshAttributeCornerTable *const att_ct =
+        source->GetAttributeCornerTable(att_id);
+    if (att_ct != nullptr) {
+      typedef MeshPredictionSchemeData<MeshAttributeCornerTable> MeshData;
+      MeshData md;
+      md.Set(source->mesh(), att_ct,
+             &encoding_data->encoded_attribute_value_index_to_corner_map,
+             &encoding_data->vertex_to_encoded_attribute_value_index_map);
+      MeshPredictionSchemeFactoryT factory;
+      auto ret = factory(method, att, transform, md, bitstream_version);
+      if (ret) {
+        return ret;
+      }
+    } else {
+      typedef MeshPredictionSchemeData<CornerTable> MeshData;
+      MeshData md;
+      md.Set(source->mesh(), ct,
+             &encoding_data->encoded_attribute_value_index_to_corner_map,
+             &encoding_data->vertex_to_encoded_attribute_value_index_map);
+      MeshPredictionSchemeFactoryT factory;
+      auto ret = factory(method, att, transform, md, bitstream_version);
+      if (ret) {
+        return ret;
+      }
+    }
+  }
+  return nullptr;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_FACTORY_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_interface.h b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_interface.h
new file mode 100644
index 00000000..c9b37069
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_interface.h
@@ -0,0 +1,60 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_INTERFACE_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_INTERFACE_H_
+
+#include "draco/attributes/point_attribute.h"
+#include "draco/compression/config/compression_shared.h"
+
+// Prediction schemes can be used during encoding and decoding of attributes
+// to predict attribute values based on the previously encoded/decoded data.
+// See prediction_scheme.h for more details.
+namespace draco {
+
+// Abstract interface for all prediction schemes used during attribute encoding.
+class PredictionSchemeInterface {
+ public:
+  virtual ~PredictionSchemeInterface() = default;
+  virtual PredictionSchemeMethod GetPredictionMethod() const = 0;
+
+  // Returns the encoded attribute.
+  virtual const PointAttribute *GetAttribute() const = 0;
+
+  // Returns true when the prediction scheme is initialized with all data it
+  // needs.
+  virtual bool IsInitialized() const = 0;
+
+  // Returns the number of parent attributes that are needed for the prediction.
+  virtual int GetNumParentAttributes() const = 0;
+
+  // Returns the type of each of the parent attribute.
+  virtual GeometryAttribute::Type GetParentAttributeType(int i) const = 0;
+
+  // Sets the required parent attribute.
+  // Returns false if the attribute doesn't meet the requirements of the
+  // prediction scheme.
+  virtual bool SetParentAttribute(const PointAttribute *att) = 0;
+
+  // Method should return true if the prediction scheme guarantees that all
+  // correction values are always positive (or at least non-negative).
+  virtual bool AreCorrectionsPositive() = 0;
+
+  // Returns the transform type used by the prediction scheme.
+  virtual PredictionSchemeTransformType GetTransformType() const = 0;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_INTERFACE_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_decoding_transform.h b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_decoding_transform.h
new file mode 100644
index 00000000..5a6c7c2d
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_decoding_transform.h
@@ -0,0 +1,118 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_DECODING_TRANSFORM_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_DECODING_TRANSFORM_H_
+
+#include <cmath>
+
+#include "draco/compression/attributes/normal_compression_utils.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_base.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/macros.h"
+#include "draco/core/vector_d.h"
+
+namespace draco {
+
+// Class for converting correction values transformed by the canonicalized
+// normal octahedron transform back to the original values. See the
+// corresponding encoder for more details.
+template <typename DataTypeT>
+class PredictionSchemeNormalOctahedronCanonicalizedDecodingTransform
+    : public PredictionSchemeNormalOctahedronCanonicalizedTransformBase<
+          DataTypeT> {
+ public:
+  typedef VectorD<DataTypeT, 2> Point2;
+  typedef DataTypeT CorrType;
+  typedef DataTypeT DataType;
+
+  PredictionSchemeNormalOctahedronCanonicalizedDecodingTransform() {}
+
+  // Dummy to fulfill concept.
+  void Init(int num_components) {}
+
+  bool DecodeTransformData(DecoderBuffer *buffer) {
+    DataTypeT max_quantized_value, center_value;
+    if (!buffer->Decode(&max_quantized_value)) {
+      return false;
+    }
+    if (!buffer->Decode(&center_value)) {
+      return false;
+    }
+    (void)center_value;
+    if (!this->set_max_quantized_value(max_quantized_value)) {
+      return false;
+    }
+    // Account for reading wrong values, e.g., due to fuzzing.
+    if (this->quantization_bits() < 2) {
+      return false;
+    }
+    if (this->quantization_bits() > 30) {
+      return false;
+    }
+    return true;
+  }
+
+  inline void ComputeOriginalValue(const DataType *pred_vals,
+                                   const CorrType *corr_vals,
+                                   DataType *out_orig_vals) const {
+    DRACO_DCHECK_LE(pred_vals[0], 2 * this->center_value());
+    DRACO_DCHECK_LE(pred_vals[1], 2 * this->center_value());
+    DRACO_DCHECK_LE(corr_vals[0], 2 * this->center_value());
+    DRACO_DCHECK_LE(corr_vals[1], 2 * this->center_value());
+
+    DRACO_DCHECK_LE(0, pred_vals[0]);
+    DRACO_DCHECK_LE(0, pred_vals[1]);
+    DRACO_DCHECK_LE(0, corr_vals[0]);
+    DRACO_DCHECK_LE(0, corr_vals[1]);
+
+    const Point2 pred = Point2(pred_vals[0], pred_vals[1]);
+    const Point2 corr = Point2(corr_vals[0], corr_vals[1]);
+    const Point2 orig = ComputeOriginalValue(pred, corr);
+
+    out_orig_vals[0] = orig[0];
+    out_orig_vals[1] = orig[1];
+  }
+
+ private:
+  Point2 ComputeOriginalValue(Point2 pred, Point2 corr) const {
+    const Point2 t(this->center_value(), this->center_value());
+    pred = pred - t;
+    const bool pred_is_in_diamond = this->IsInDiamond(pred[0], pred[1]);
+    if (!pred_is_in_diamond) {
+      this->InvertDiamond(&pred[0], &pred[1]);
+    }
+    const bool pred_is_in_bottom_left = this->IsInBottomLeft(pred);
+    const int32_t rotation_count = this->GetRotationCount(pred);
+    if (!pred_is_in_bottom_left) {
+      pred = this->RotatePoint(pred, rotation_count);
+    }
+    Point2 orig = pred + corr;
+    orig[0] = this->ModMax(orig[0]);
+    orig[1] = this->ModMax(orig[1]);
+    if (!pred_is_in_bottom_left) {
+      const int32_t reverse_rotation_count = (4 - rotation_count) % 4;
+      orig = this->RotatePoint(orig, reverse_rotation_count);
+    }
+    if (!pred_is_in_diamond) {
+      this->InvertDiamond(&orig[0], &orig[1]);
+    }
+    orig = orig + t;
+    return orig;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_DECODING_TRANSFORM_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_encoding_transform.h b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_encoding_transform.h
new file mode 100644
index 00000000..0dc96967
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_encoding_transform.h
@@ -0,0 +1,116 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_ENCODING_TRANSFORM_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_ENCODING_TRANSFORM_H_
+
+#include <cmath>
+
+#include "draco/compression/attributes/normal_compression_utils.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_base.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/core/macros.h"
+#include "draco/core/vector_d.h"
+
+namespace draco {
+
+// The transform works on octahedral coordinates for normals. The square is
+// subdivided into four inner triangles (diamond) and four outer triangles. The
+// inner triangles are associated with the upper part of the octahedron and the
+// outer triangles are associated with the lower part.
+// Given a prediction value P and the actual value Q that should be encoded,
+// this transform first checks if P is outside the diamond. If so, the outer
+// triangles are flipped towards the inside and vice versa. Then it checks if p
+// is in the bottom left quadrant. If it is not, it rotates p and q accordingly.
+// The actual correction value is then based on the mapped and rotated P and Q
+// values. The inversion tends to result in shorter correction vectors and the
+// rotation makes it so that all long correction values are positive, reducing
+// the possible value range of the correction values and increasing the
+// occurrences of positive large correction values, which helps the entropy
+// encoder. This is possible since P is also known by the decoder, see also
+// ComputeCorrection and ComputeOriginalValue functions.
+// Note that the tile is not periodic, which implies that the outer edges can
+// not be identified, which requires us to use an odd number of values on each
+// axis.
+// DataTypeT is expected to be some integral type.
+//
+template <typename DataTypeT>
+class PredictionSchemeNormalOctahedronCanonicalizedEncodingTransform
+    : public PredictionSchemeNormalOctahedronCanonicalizedTransformBase<
+          DataTypeT> {
+ public:
+  typedef PredictionSchemeNormalOctahedronCanonicalizedTransformBase<DataTypeT>
+      Base;
+  typedef VectorD<DataTypeT, 2> Point2;
+  typedef DataTypeT CorrType;
+  typedef DataTypeT DataType;
+
+  // We expect the mod value to be of the form 2^b-1.
+  explicit PredictionSchemeNormalOctahedronCanonicalizedEncodingTransform(
+      DataType max_quantized_value)
+      : Base(max_quantized_value) {}
+
+  // Dummy function to fulfill concept.
+  void Init(const DataTypeT *orig_data, int size, int num_components) {}
+
+  bool EncodeTransformData(EncoderBuffer *buffer) {
+    buffer->Encode(this->max_quantized_value());
+    buffer->Encode(this->center_value());
+    return true;
+  }
+
+  inline void ComputeCorrection(const DataType *orig_vals,
+                                const DataType *pred_vals,
+                                CorrType *out_corr_vals) const {
+    DRACO_DCHECK_LE(pred_vals[0], this->center_value() * 2);
+    DRACO_DCHECK_LE(pred_vals[1], this->center_value() * 2);
+    DRACO_DCHECK_LE(orig_vals[0], this->center_value() * 2);
+    DRACO_DCHECK_LE(orig_vals[1], this->center_value() * 2);
+    DRACO_DCHECK_LE(0, pred_vals[0]);
+    DRACO_DCHECK_LE(0, pred_vals[1]);
+    DRACO_DCHECK_LE(0, orig_vals[0]);
+    DRACO_DCHECK_LE(0, orig_vals[1]);
+
+    const Point2 orig = Point2(orig_vals[0], orig_vals[1]);
+    const Point2 pred = Point2(pred_vals[0], pred_vals[1]);
+    const Point2 corr = ComputeCorrection(orig, pred);
+
+    out_corr_vals[0] = corr[0];
+    out_corr_vals[1] = corr[1];
+  }
+
+ private:
+  Point2 ComputeCorrection(Point2 orig, Point2 pred) const {
+    const Point2 t(this->center_value(), this->center_value());
+    orig = orig - t;
+    pred = pred - t;
+    if (!this->IsInDiamond(pred[0], pred[1])) {
+      this->InvertDiamond(&orig[0], &orig[1]);
+      this->InvertDiamond(&pred[0], &pred[1]);
+    }
+    if (!this->IsInBottomLeft(pred)) {
+      const int32_t rotation_count = this->GetRotationCount(pred);
+      orig = this->RotatePoint(orig, rotation_count);
+      pred = this->RotatePoint(pred, rotation_count);
+    }
+    Point2 corr = orig - pred;
+    corr[0] = this->MakePositive(corr[0]);
+    corr[1] = this->MakePositive(corr[1]);
+    return corr;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_ENCODING_TRANSFORM_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_base.h b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_base.h
new file mode 100644
index 00000000..4a1e3a67
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_base.h
@@ -0,0 +1,102 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_TRANSFORM_BASE_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_TRANSFORM_BASE_H_
+
+#include <cmath>
+
+#include "draco/compression/attributes/normal_compression_utils.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_base.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/core/bit_utils.h"
+#include "draco/core/macros.h"
+#include "draco/core/vector_d.h"
+
+namespace draco {
+
+// Base class containing shared functionality used by both encoding and decoding
+// canonicalized normal octahedron prediction scheme transforms. See the
+// encoding transform for more details about the method.
+template <typename DataTypeT>
+class PredictionSchemeNormalOctahedronCanonicalizedTransformBase
+    : public PredictionSchemeNormalOctahedronTransformBase<DataTypeT> {
+ public:
+  typedef PredictionSchemeNormalOctahedronTransformBase<DataTypeT> Base;
+  typedef VectorD<DataTypeT, 2> Point2;
+  typedef DataTypeT DataType;
+
+  PredictionSchemeNormalOctahedronCanonicalizedTransformBase() : Base() {}
+  // We expect the mod value to be of the form 2^b-1.
+  explicit PredictionSchemeNormalOctahedronCanonicalizedTransformBase(
+      DataType mod_value)
+      : Base(mod_value) {}
+
+  static constexpr PredictionSchemeTransformType GetType() {
+    return PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON_CANONICALIZED;
+  }
+
+  int32_t GetRotationCount(Point2 pred) const {
+    const DataType sign_x = pred[0];
+    const DataType sign_y = pred[1];
+
+    int32_t rotation_count = 0;
+    if (sign_x == 0) {
+      if (sign_y == 0) {
+        rotation_count = 0;
+      } else if (sign_y > 0) {
+        rotation_count = 3;
+      } else {
+        rotation_count = 1;
+      }
+    } else if (sign_x > 0) {
+      if (sign_y >= 0) {
+        rotation_count = 2;
+      } else {
+        rotation_count = 1;
+      }
+    } else {
+      if (sign_y <= 0) {
+        rotation_count = 0;
+      } else {
+        rotation_count = 3;
+      }
+    }
+    return rotation_count;
+  }
+
+  Point2 RotatePoint(Point2 p, int32_t rotation_count) const {
+    switch (rotation_count) {
+      case 1:
+        return Point2(p[1], -p[0]);
+      case 2:
+        return Point2(-p[0], -p[1]);
+      case 3:
+        return Point2(-p[1], p[0]);
+      default:
+        return p;
+    }
+  }
+
+  bool IsInBottomLeft(const Point2 &p) const {
+    if (p[0] == 0 && p[1] == 0) {
+      return true;
+    }
+    return (p[0] < 0 && p[1] <= 0);
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_TRANSFORM_BASE_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_decoding_transform.h b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_decoding_transform.h
new file mode 100644
index 00000000..a1bc4a32
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_decoding_transform.h
@@ -0,0 +1,103 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_DECODING_TRANSFORM_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_DECODING_TRANSFORM_H_
+
+#include <cmath>
+
+#include "draco/compression/attributes/normal_compression_utils.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_base.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/macros.h"
+#include "draco/core/vector_d.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Class for converting correction values transformed by the octahedral normal
+// transform back to the original values. See the corresponding encoder for more
+// details.
+template <typename DataTypeT>
+class PredictionSchemeNormalOctahedronDecodingTransform
+    : public PredictionSchemeNormalOctahedronTransformBase<DataTypeT> {
+ public:
+  typedef VectorD<DataTypeT, 2> Point2;
+  typedef DataTypeT CorrType;
+  typedef DataTypeT DataType;
+
+  PredictionSchemeNormalOctahedronDecodingTransform() {}
+
+  // Dummy function to fulfill concept.
+  void Init(int num_components) {}
+  bool DecodeTransformData(DecoderBuffer *buffer) {
+    DataTypeT max_quantized_value, center_value;
+    if (!buffer->Decode(&max_quantized_value)) {
+      return false;
+    }
+    if (buffer->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+      if (!buffer->Decode(&center_value)) {
+        return false;
+      }
+    }
+    (void)center_value;
+    return this->set_max_quantized_value(max_quantized_value);
+  }
+
+  inline void ComputeOriginalValue(const DataType *pred_vals,
+                                   const CorrType *corr_vals,
+                                   DataType *out_orig_vals) const {
+    DRACO_DCHECK_LE(pred_vals[0], 2 * this->center_value());
+    DRACO_DCHECK_LE(pred_vals[1], 2 * this->center_value());
+    DRACO_DCHECK_LE(corr_vals[0], 2 * this->center_value());
+    DRACO_DCHECK_LE(corr_vals[1], 2 * this->center_value());
+
+    DRACO_DCHECK_LE(0, pred_vals[0]);
+    DRACO_DCHECK_LE(0, pred_vals[1]);
+    DRACO_DCHECK_LE(0, corr_vals[0]);
+    DRACO_DCHECK_LE(0, corr_vals[1]);
+
+    const Point2 pred = Point2(pred_vals[0], pred_vals[1]);
+    const Point2 corr = Point2(corr_vals[0], corr_vals[1]);
+    const Point2 orig = ComputeOriginalValue(pred, corr);
+
+    out_orig_vals[0] = orig[0];
+    out_orig_vals[1] = orig[1];
+  }
+
+ private:
+  Point2 ComputeOriginalValue(Point2 pred, const Point2 &corr) const {
+    const Point2 t(this->center_value(), this->center_value());
+    pred = pred - t;
+
+    const bool pred_is_in_diamond = this->IsInDiamond(pred[0], pred[1]);
+    if (!pred_is_in_diamond) {
+      this->InvertDiamond(&pred[0], &pred[1]);
+    }
+    Point2 orig = pred + corr;
+    orig[0] = this->ModMax(orig[0]);
+    orig[1] = this->ModMax(orig[1]);
+    if (!pred_is_in_diamond) {
+      this->InvertDiamond(&orig[0], &orig[1]);
+    }
+    orig = orig + t;
+    return orig;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_DECODING_TRANSFORM_H_
+#endif
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_encoding_transform.h b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_encoding_transform.h
new file mode 100644
index 00000000..4abfef66
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_encoding_transform.h
@@ -0,0 +1,105 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_ENCODING_TRANSFORM_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_ENCODING_TRANSFORM_H_
+
+#include <cmath>
+
+#include "draco/compression/attributes/normal_compression_utils.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_base.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/core/macros.h"
+#include "draco/core/vector_d.h"
+
+namespace draco {
+
+// The transform works on octahedral coordinates for normals. The square is
+// subdivided into four inner triangles (diamond) and four outer triangles. The
+// inner triangles are associated with the upper part of the octahedron and the
+// outer triangles are associated with the lower part.
+// Given a prediction value P and the actual value Q that should be encoded,
+// this transform first checks if P is outside the diamond. If so, the outer
+// triangles are flipped towards the inside and vice versa. The actual
+// correction value is then based on the mapped P and Q values. This tends to
+// result in shorter correction vectors.
+// This is possible since the P value is also known by the decoder, see also
+// ComputeCorrection and ComputeOriginalValue functions.
+// Note that the tile is not periodic, which implies that the outer edges can
+// not be identified, which requires us to use an odd number of values on each
+// axis.
+// DataTypeT is expected to be some integral type.
+//
+template <typename DataTypeT>
+class PredictionSchemeNormalOctahedronEncodingTransform
+    : public PredictionSchemeNormalOctahedronTransformBase<DataTypeT> {
+ public:
+  typedef PredictionSchemeNormalOctahedronTransformBase<DataTypeT> Base;
+  typedef VectorD<DataTypeT, 2> Point2;
+  typedef DataTypeT CorrType;
+  typedef DataTypeT DataType;
+
+  // We expect the mod value to be of the form 2^b-1.
+  explicit PredictionSchemeNormalOctahedronEncodingTransform(
+      DataType max_quantized_value)
+      : Base(max_quantized_value) {}
+
+  void Init(const DataTypeT *orig_data, int size, int num_components) {}
+
+  bool EncodeTransformData(EncoderBuffer *buffer) {
+    buffer->Encode(this->max_quantized_value());
+    return true;
+  }
+
+  inline void ComputeCorrection(const DataType *orig_vals,
+                                const DataType *pred_vals,
+                                CorrType *out_corr_vals) const {
+    DRACO_DCHECK_LE(pred_vals[0], this->center_value() * 2);
+    DRACO_DCHECK_LE(pred_vals[1], this->center_value() * 2);
+    DRACO_DCHECK_LE(orig_vals[0], this->center_value() * 2);
+    DRACO_DCHECK_LE(orig_vals[1], this->center_value() * 2);
+    DRACO_DCHECK_LE(0, pred_vals[0]);
+    DRACO_DCHECK_LE(0, pred_vals[1]);
+    DRACO_DCHECK_LE(0, orig_vals[0]);
+    DRACO_DCHECK_LE(0, orig_vals[1]);
+
+    const Point2 orig = Point2(orig_vals[0], orig_vals[1]);
+    const Point2 pred = Point2(pred_vals[0], pred_vals[1]);
+    const Point2 corr = ComputeCorrection(orig, pred);
+
+    out_corr_vals[0] = corr[0];
+    out_corr_vals[1] = corr[1];
+  }
+
+ private:
+  Point2 ComputeCorrection(Point2 orig, Point2 pred) const {
+    const Point2 t(this->center_value(), this->center_value());
+    orig = orig - t;
+    pred = pred - t;
+
+    if (!this->IsInDiamond(pred[0], pred[1])) {
+      this->InvertDiamond(&orig[0], &orig[1]);
+      this->InvertDiamond(&pred[0], &pred[1]);
+    }
+
+    Point2 corr = orig - pred;
+    corr[0] = this->MakePositive(corr[0]);
+    corr[1] = this->MakePositive(corr[1]);
+    return corr;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_ENCODING_TRANSFORM_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_base.h b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_base.h
new file mode 100644
index 00000000..c9dd7d67
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_base.h
@@ -0,0 +1,90 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_TRANSFORM_BASE_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_TRANSFORM_BASE_H_
+
+#include <cmath>
+
+#include "draco/compression/attributes/normal_compression_utils.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/core/bit_utils.h"
+#include "draco/core/macros.h"
+#include "draco/core/vector_d.h"
+
+namespace draco {
+
+// Base class containing shared functionality used by both encoding and decoding
+// octahedral normal prediction scheme transforms. See the encoding transform
+// for more details about the method.
+template <typename DataTypeT>
+class PredictionSchemeNormalOctahedronTransformBase {
+ public:
+  typedef VectorD<DataTypeT, 2> Point2;
+  typedef DataTypeT DataType;
+
+  PredictionSchemeNormalOctahedronTransformBase() {}
+  // We expect the mod value to be of the form 2^b-1.
+  explicit PredictionSchemeNormalOctahedronTransformBase(
+      DataType max_quantized_value) {
+    this->set_max_quantized_value(max_quantized_value);
+  }
+
+  static constexpr PredictionSchemeTransformType GetType() {
+    return PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON;
+  }
+
+  // We can return true as we keep correction values positive.
+  bool AreCorrectionsPositive() const { return true; }
+
+  inline DataTypeT max_quantized_value() const {
+    return octahedron_tool_box_.max_quantized_value();
+  }
+  inline DataTypeT center_value() const {
+    return octahedron_tool_box_.center_value();
+  }
+  inline int32_t quantization_bits() const {
+    return octahedron_tool_box_.quantization_bits();
+  }
+
+ protected:
+  inline bool set_max_quantized_value(DataTypeT max_quantized_value) {
+    if (max_quantized_value % 2 == 0) {
+      return false;
+    }
+    int q = MostSignificantBit(max_quantized_value) + 1;
+    return octahedron_tool_box_.SetQuantizationBits(q);
+  }
+
+  bool IsInDiamond(DataTypeT s, DataTypeT t) const {
+    return octahedron_tool_box_.IsInDiamond(s, t);
+  }
+  void InvertDiamond(DataTypeT *s, DataTypeT *t) const {
+    return octahedron_tool_box_.InvertDiamond(s, t);
+  }
+
+  int32_t ModMax(int32_t x) const { return octahedron_tool_box_.ModMax(x); }
+
+  // For correction values.
+  int32_t MakePositive(int32_t x) const {
+    return octahedron_tool_box_.MakePositive(x);
+  }
+
+ private:
+  OctahedronToolBox octahedron_tool_box_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_TRANSFORM_BASE_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_decoding_transform.h b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_decoding_transform.h
new file mode 100644
index 00000000..e100c738
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_decoding_transform.h
@@ -0,0 +1,88 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_WRAP_DECODING_TRANSFORM_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_WRAP_DECODING_TRANSFORM_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_transform_base.h"
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+
+// PredictionSchemeWrapDecodingTransform unwraps values encoded with the
+// PredictionSchemeWrapEncodingTransform.
+// See prediction_scheme_wrap_transform_base.h for more details about the
+// method.
+template <typename DataTypeT, typename CorrTypeT = DataTypeT>
+class PredictionSchemeWrapDecodingTransform
+    : public PredictionSchemeWrapTransformBase<DataTypeT> {
+ public:
+  typedef CorrTypeT CorrType;
+  PredictionSchemeWrapDecodingTransform() {}
+
+  // Computes the original value from the input predicted value and the decoded
+  // corrections. Values out of the bounds of the input values are unwrapped.
+  inline void ComputeOriginalValue(const DataTypeT *predicted_vals,
+                                   const CorrTypeT *corr_vals,
+                                   DataTypeT *out_original_vals) const {
+    // For now we assume both |DataTypeT| and |CorrTypeT| are equal.
+    static_assert(std::is_same<DataTypeT, CorrTypeT>::value,
+                  "Predictions and corrections must have the same type.");
+
+    // The only valid implementation right now is for int32_t.
+    static_assert(std::is_same<DataTypeT, int32_t>::value,
+                  "Only int32_t is supported for predicted values.");
+
+    predicted_vals = this->ClampPredictedValue(predicted_vals);
+
+    // Perform the wrapping using unsigned coordinates to avoid potential signed
+    // integer overflows caused by malformed input.
+    const uint32_t *const uint_predicted_vals =
+        reinterpret_cast<const uint32_t *>(predicted_vals);
+    const uint32_t *const uint_corr_vals =
+        reinterpret_cast<const uint32_t *>(corr_vals);
+    for (int i = 0; i < this->num_components(); ++i) {
+      out_original_vals[i] =
+          static_cast<DataTypeT>(uint_predicted_vals[i] + uint_corr_vals[i]);
+      if (out_original_vals[i] > this->max_value()) {
+        out_original_vals[i] -= this->max_dif();
+      } else if (out_original_vals[i] < this->min_value()) {
+        out_original_vals[i] += this->max_dif();
+      }
+    }
+  }
+
+  bool DecodeTransformData(DecoderBuffer *buffer) {
+    DataTypeT min_value, max_value;
+    if (!buffer->Decode(&min_value)) {
+      return false;
+    }
+    if (!buffer->Decode(&max_value)) {
+      return false;
+    }
+    if (min_value > max_value) {
+      return false;
+    }
+    this->set_min_value(min_value);
+    this->set_max_value(max_value);
+    if (!this->InitCorrectionBounds()) {
+      return false;
+    }
+    return true;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_WRAP_DECODING_TRANSFORM_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_encoding_transform.h b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_encoding_transform.h
new file mode 100644
index 00000000..1f5e8b13
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_encoding_transform.h
@@ -0,0 +1,81 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_WRAP_ENCODING_TRANSFORM_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_WRAP_ENCODING_TRANSFORM_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_transform_base.h"
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// PredictionSchemeWrapEncodingTransform wraps input values using the wrapping
+// scheme described in: prediction_scheme_wrap_transform_base.h .
+template <typename DataTypeT, typename CorrTypeT = DataTypeT>
+class PredictionSchemeWrapEncodingTransform
+    : public PredictionSchemeWrapTransformBase<DataTypeT> {
+ public:
+  typedef CorrTypeT CorrType;
+  PredictionSchemeWrapEncodingTransform() {}
+
+  void Init(const DataTypeT *orig_data, int size, int num_components) {
+    PredictionSchemeWrapTransformBase<DataTypeT>::Init(num_components);
+    // Go over the original values and compute the bounds.
+    if (size == 0) {
+      return;
+    }
+    DataTypeT min_value = orig_data[0];
+    DataTypeT max_value = min_value;
+    for (int i = 1; i < size; ++i) {
+      if (orig_data[i] < min_value) {
+        min_value = orig_data[i];
+      } else if (orig_data[i] > max_value) {
+        max_value = orig_data[i];
+      }
+    }
+    this->set_min_value(min_value);
+    this->set_max_value(max_value);
+    this->InitCorrectionBounds();
+  }
+
+  // Computes the corrections based on the input original value and the
+  // predicted value. Out of bound correction values are wrapped around the max
+  // range of input values.
+  inline void ComputeCorrection(const DataTypeT *original_vals,
+                                const DataTypeT *predicted_vals,
+                                CorrTypeT *out_corr_vals) const {
+    for (int i = 0; i < this->num_components(); ++i) {
+      predicted_vals = this->ClampPredictedValue(predicted_vals);
+      out_corr_vals[i] = original_vals[i] - predicted_vals[i];
+      // Wrap around if needed.
+      DataTypeT &corr_val = out_corr_vals[i];
+      if (corr_val < this->min_correction()) {
+        corr_val += this->max_dif();
+      } else if (corr_val > this->max_correction()) {
+        corr_val -= this->max_dif();
+      }
+    }
+  }
+
+  bool EncodeTransformData(EncoderBuffer *buffer) {
+    // Store the input value range as it is needed by the decoder.
+    buffer->Encode(this->min_value());
+    buffer->Encode(this->max_value());
+    return true;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_WRAP_ENCODING_TRANSFORM_H_
diff --git a/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_transform_base.h b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_transform_base.h
new file mode 100644
index 00000000..26f61fba
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_transform_base.h
@@ -0,0 +1,120 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_WRAP_TRANSFORM_BASE_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_WRAP_TRANSFORM_BASE_H_
+
+#include <limits>
+#include <vector>
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/core/macros.h"
+
+namespace draco {
+
+// PredictionSchemeWrapTransform uses the min and max bounds of the original
+// data to wrap stored correction values around these bounds centered at 0,
+// i.e., when the range of the original values O is between <MIN, MAX> and
+// N = MAX-MIN, we can then store any correction X = O - P, as:
+//        X + N,   if X < -N / 2
+//        X - N,   if X > N / 2
+//        X        otherwise
+// To unwrap this value, the decoder then simply checks whether the final
+// corrected value F = P + X is out of the bounds of the input values.
+// All out of bounds values are unwrapped using
+//        F + N,   if F < MIN
+//        F - N,   if F > MAX
+// This wrapping can reduce the number of unique values, which translates to a
+// better entropy of the stored values and better compression rates.
+template <typename DataTypeT>
+class PredictionSchemeWrapTransformBase {
+ public:
+  PredictionSchemeWrapTransformBase()
+      : num_components_(0),
+        min_value_(0),
+        max_value_(0),
+        max_dif_(0),
+        max_correction_(0),
+        min_correction_(0) {}
+
+  static constexpr PredictionSchemeTransformType GetType() {
+    return PREDICTION_TRANSFORM_WRAP;
+  }
+
+  void Init(int num_components) {
+    num_components_ = num_components;
+    clamped_value_.resize(num_components);
+  }
+
+  bool AreCorrectionsPositive() const { return false; }
+
+  inline const DataTypeT *ClampPredictedValue(
+      const DataTypeT *predicted_val) const {
+    for (int i = 0; i < this->num_components(); ++i) {
+      if (predicted_val[i] > max_value_) {
+        clamped_value_[i] = max_value_;
+      } else if (predicted_val[i] < min_value_) {
+        clamped_value_[i] = min_value_;
+      } else {
+        clamped_value_[i] = predicted_val[i];
+      }
+    }
+    return &clamped_value_[0];
+  }
+
+  // TODO(hemmer): Consider refactoring to avoid this dummy.
+  int quantization_bits() const {
+    DRACO_DCHECK(false);
+    return -1;
+  }
+
+ protected:
+  bool InitCorrectionBounds() {
+    const int64_t dif =
+        static_cast<int64_t>(max_value_) - static_cast<int64_t>(min_value_);
+    if (dif < 0 || dif >= std::numeric_limits<DataTypeT>::max()) {
+      return false;
+    }
+    max_dif_ = 1 + static_cast<DataTypeT>(dif);
+    max_correction_ = max_dif_ / 2;
+    min_correction_ = -max_correction_;
+    if ((max_dif_ & 1) == 0) {
+      max_correction_ -= 1;
+    }
+    return true;
+  }
+
+  inline int num_components() const { return num_components_; }
+  inline DataTypeT min_value() const { return min_value_; }
+  inline void set_min_value(const DataTypeT &v) { min_value_ = v; }
+  inline DataTypeT max_value() const { return max_value_; }
+  inline void set_max_value(const DataTypeT &v) { max_value_ = v; }
+  inline DataTypeT max_dif() const { return max_dif_; }
+  inline DataTypeT min_correction() const { return min_correction_; }
+  inline DataTypeT max_correction() const { return max_correction_; }
+
+ private:
+  int num_components_;
+  DataTypeT min_value_;
+  DataTypeT max_value_;
+  DataTypeT max_dif_;
+  DataTypeT max_correction_;
+  DataTypeT min_correction_;
+  // This is in fact just a tmp variable to avoid reallocation.
+  mutable std::vector<DataTypeT> clamped_value_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_WRAP_TRANSFORM_BASE_H_
diff --git a/engine/inc/draco/compression/attributes/sequential_attribute_decoder.h b/engine/inc/draco/compression/attributes/sequential_attribute_decoder.h
new file mode 100644
index 00000000..d4811946
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/sequential_attribute_decoder.h
@@ -0,0 +1,86 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_DECODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_interface.h"
+#include "draco/compression/point_cloud/point_cloud_decoder.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// A base class for decoding attribute values encoded by the
+// SequentialAttributeEncoder.
+class SequentialAttributeDecoder {
+ public:
+  SequentialAttributeDecoder();
+  virtual ~SequentialAttributeDecoder() = default;
+
+  virtual bool Init(PointCloudDecoder *decoder, int attribute_id);
+
+  // Initialization for a specific attribute. This can be used mostly for
+  // standalone decoding of an attribute without an PointCloudDecoder.
+  virtual bool InitializeStandalone(PointAttribute *attribute);
+
+  // Performs lossless decoding of the portable attribute data.
+  virtual bool DecodePortableAttribute(const std::vector<PointIndex> &point_ids,
+                                       DecoderBuffer *in_buffer);
+
+  // Decodes any data needed to revert portable transform of the decoded
+  // attribute.
+  virtual bool DecodeDataNeededByPortableTransform(
+      const std::vector<PointIndex> &point_ids, DecoderBuffer *in_buffer);
+
+  // Reverts transformation performed by encoder in
+  // SequentialAttributeEncoder::TransformAttributeToPortableFormat() method.
+  virtual bool TransformAttributeToOriginalFormat(
+      const std::vector<PointIndex> &point_ids);
+
+  const PointAttribute *GetPortableAttribute();
+
+  const PointAttribute *attribute() const { return attribute_; }
+  PointAttribute *attribute() { return attribute_; }
+  int attribute_id() const { return attribute_id_; }
+  PointCloudDecoder *decoder() const { return decoder_; }
+
+ protected:
+  // Should be used to initialize newly created prediction scheme.
+  // Returns false when the initialization failed (in which case the scheme
+  // cannot be used).
+  virtual bool InitPredictionScheme(PredictionSchemeInterface *ps);
+
+  // The actual implementation of the attribute decoding. Should be overridden
+  // for specialized decoders.
+  virtual bool DecodeValues(const std::vector<PointIndex> &point_ids,
+                            DecoderBuffer *in_buffer);
+
+  void SetPortableAttribute(std::unique_ptr<PointAttribute> att) {
+    portable_attribute_ = std::move(att);
+  }
+
+  PointAttribute *portable_attribute() { return portable_attribute_.get(); }
+
+ private:
+  PointCloudDecoder *decoder_;
+  PointAttribute *attribute_;
+  int attribute_id_;
+
+  // Storage for decoded portable attribute (after lossless decoding).
+  std::unique_ptr<PointAttribute> portable_attribute_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_DECODER_H_
diff --git a/engine/inc/draco/compression/attributes/sequential_attribute_decoders_controller.h b/engine/inc/draco/compression/attributes/sequential_attribute_decoders_controller.h
new file mode 100644
index 00000000..abc1f368
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/sequential_attribute_decoders_controller.h
@@ -0,0 +1,61 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_DECODERS_CONTROLLER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_DECODERS_CONTROLLER_H_
+
+#include "draco/compression/attributes/attributes_decoder.h"
+#include "draco/compression/attributes/points_sequencer.h"
+#include "draco/compression/attributes/sequential_attribute_decoder.h"
+
+namespace draco {
+
+// A basic implementation of an attribute decoder that decodes data encoded by
+// the SequentialAttributeEncodersController class. The
+// SequentialAttributeDecodersController creates a single
+// AttributeIndexedValuesDecoder for each of the decoded attribute, where the
+// type of the values decoder is determined by the unique identifier that was
+// encoded by the encoder.
+class SequentialAttributeDecodersController : public AttributesDecoder {
+ public:
+  explicit SequentialAttributeDecodersController(
+      std::unique_ptr<PointsSequencer> sequencer);
+
+  bool DecodeAttributesDecoderData(DecoderBuffer *buffer) override;
+  bool DecodeAttributes(DecoderBuffer *buffer) override;
+  const PointAttribute *GetPortableAttribute(
+      int32_t point_attribute_id) override {
+    const int32_t loc_id = GetLocalIdForPointAttribute(point_attribute_id);
+    if (loc_id < 0) {
+      return nullptr;
+    }
+    return sequential_decoders_[loc_id]->GetPortableAttribute();
+  }
+
+ protected:
+  bool DecodePortableAttributes(DecoderBuffer *in_buffer) override;
+  bool DecodeDataNeededByPortableTransforms(DecoderBuffer *in_buffer) override;
+  bool TransformAttributesToOriginalFormat() override;
+  virtual std::unique_ptr<SequentialAttributeDecoder> CreateSequentialDecoder(
+      uint8_t decoder_type);
+
+ private:
+  std::vector<std::unique_ptr<SequentialAttributeDecoder>> sequential_decoders_;
+  std::vector<PointIndex> point_ids_;
+  std::unique_ptr<PointsSequencer> sequencer_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_DECODERS_CONTROLLER_H_
diff --git a/engine/inc/draco/compression/attributes/sequential_attribute_encoder.h b/engine/inc/draco/compression/attributes/sequential_attribute_encoder.h
new file mode 100644
index 00000000..00f62db8
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/sequential_attribute_encoder.h
@@ -0,0 +1,134 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_ENCODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_interface.h"
+#include "draco/compression/point_cloud/point_cloud_encoder.h"
+
+namespace draco {
+
+// A base class for encoding attribute values of a single attribute using a
+// given sequence of point ids. The default implementation encodes all attribute
+// values directly to the buffer but derived classes can perform any custom
+// encoding (such as quantization) by overriding the EncodeValues() method.
+class SequentialAttributeEncoder {
+ public:
+  SequentialAttributeEncoder();
+  virtual ~SequentialAttributeEncoder() = default;
+
+  // Method that can be used for custom initialization of an attribute encoder,
+  // such as creation of prediction schemes and initialization of attribute
+  // encoder dependencies.
+  // |encoder| is the parent PointCloudEncoder,
+  // |attribute_id| is the id of the attribute that is being encoded by this
+  // encoder.
+  // This method is automatically called by the PointCloudEncoder after all
+  // attribute encoders are created and it should not be called explicitly from
+  // other places.
+  virtual bool Init(PointCloudEncoder *encoder, int attribute_id);
+
+  // Initialization for a specific attribute. This can be used mostly for
+  // standalone encoding of an attribute without an PointCloudEncoder.
+  virtual bool InitializeStandalone(PointAttribute *attribute);
+
+  // Transforms attribute data into format that is going to be encoded
+  // losslessly. The transform itself can be lossy.
+  virtual bool TransformAttributeToPortableFormat(
+      const std::vector<PointIndex> &point_ids);
+
+  // Performs lossless encoding of the transformed attribute data.
+  virtual bool EncodePortableAttribute(const std::vector<PointIndex> &point_ids,
+                                       EncoderBuffer *out_buffer);
+
+  // Encodes any data related to the portable attribute transform.
+  virtual bool EncodeDataNeededByPortableTransform(EncoderBuffer *out_buffer);
+
+  virtual bool IsLossyEncoder() const { return false; }
+
+  int NumParentAttributes() const {
+    return static_cast<int>(parent_attributes_.size());
+  }
+  int GetParentAttributeId(int i) const { return parent_attributes_[i]; }
+
+  const PointAttribute *GetPortableAttribute() const {
+    if (portable_attribute_ != nullptr) {
+      return portable_attribute_.get();
+    }
+    return attribute();
+  }
+
+  // Called when this attribute encoder becomes a parent encoder of another
+  // encoder.
+  void MarkParentAttribute();
+
+  virtual uint8_t GetUniqueId() const {
+    return SEQUENTIAL_ATTRIBUTE_ENCODER_GENERIC;
+  }
+
+  const PointAttribute *attribute() const { return attribute_; }
+  int attribute_id() const { return attribute_id_; }
+  PointCloudEncoder *encoder() const { return encoder_; }
+
+ protected:
+  // Should be used to initialize newly created prediction scheme.
+  // Returns false when the initialization failed (in which case the scheme
+  // cannot be used).
+  virtual bool InitPredictionScheme(PredictionSchemeInterface *ps);
+
+  // Sets parent attributes for a given prediction scheme. Must be called
+  // after all prediction schemes are initialized, but before the prediction
+  // scheme is used.
+  virtual bool SetPredictionSchemeParentAttributes(
+      PredictionSchemeInterface *ps);
+
+  // Encodes all attribute values in the specified order. Should be overridden
+  // for specialized  encoders.
+  virtual bool EncodeValues(const std::vector<PointIndex> &point_ids,
+                            EncoderBuffer *out_buffer);
+
+  bool is_parent_encoder() const { return is_parent_encoder_; }
+
+  void SetPortableAttribute(std::unique_ptr<PointAttribute> att) {
+    portable_attribute_ = std::move(att);
+  }
+
+  // Returns a mutable attribute that should be filled by derived encoders with
+  // the transformed version of the attribute data. To get a public const
+  // version, use the GetPortableAttribute() method.
+  PointAttribute *portable_attribute() { return portable_attribute_.get(); }
+
+ private:
+  PointCloudEncoder *encoder_;
+  const PointAttribute *attribute_;
+  int attribute_id_;
+
+  // List of attribute encoders that need to be encoded before this attribute.
+  // E.g. The parent attributes may be used to predict values used by this
+  // attribute encoder.
+  std::vector<int32_t> parent_attributes_;
+
+  bool is_parent_encoder_;
+
+  // Attribute that stores transformed data from the source attribute after it
+  // is processed through the ApplyTransform() method. Attribute data stored
+  // within this attribute is guaranteed to be encoded losslessly and it can be
+  // safely used for prediction of other attributes.
+  std::unique_ptr<PointAttribute> portable_attribute_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_ENCODER_H_
diff --git a/engine/inc/draco/compression/attributes/sequential_attribute_encoders_controller.h b/engine/inc/draco/compression/attributes/sequential_attribute_encoders_controller.h
new file mode 100644
index 00000000..13c2704e
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/sequential_attribute_encoders_controller.h
@@ -0,0 +1,115 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_ENCODERS_CONTROLLER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_ENCODERS_CONTROLLER_H_
+
+#include "draco/compression/attributes/attributes_encoder.h"
+#include "draco/compression/attributes/points_sequencer.h"
+#include "draco/compression/attributes/sequential_attribute_encoder.h"
+
+namespace draco {
+
+// A basic implementation of an attribute encoder that can be used to encode
+// an arbitrary set of attributes. The encoder creates a sequential attribute
+// encoder for each encoded attribute (see sequential_attribute_encoder.h) and
+// then it encodes all attribute values in an order defined by a point sequence
+// generated in the GeneratePointSequence() method. The default implementation
+// generates a linear sequence of all points, but derived classes can generate
+// any custom sequence.
+class SequentialAttributeEncodersController : public AttributesEncoder {
+ public:
+  explicit SequentialAttributeEncodersController(
+      std::unique_ptr<PointsSequencer> sequencer);
+  SequentialAttributeEncodersController(
+      std::unique_ptr<PointsSequencer> sequencer, int point_attrib_id);
+
+  bool Init(PointCloudEncoder *encoder, const PointCloud *pc) override;
+  bool EncodeAttributesEncoderData(EncoderBuffer *out_buffer) override;
+  bool EncodeAttributes(EncoderBuffer *buffer) override;
+  uint8_t GetUniqueId() const override { return BASIC_ATTRIBUTE_ENCODER; }
+
+  int NumParentAttributes(int32_t point_attribute_id) const override {
+    const int32_t loc_id = GetLocalIdForPointAttribute(point_attribute_id);
+    if (loc_id < 0) {
+      return 0;
+    }
+    return sequential_encoders_[loc_id]->NumParentAttributes();
+  }
+
+  int GetParentAttributeId(int32_t point_attribute_id,
+                           int32_t parent_i) const override {
+    const int32_t loc_id = GetLocalIdForPointAttribute(point_attribute_id);
+    if (loc_id < 0) {
+      return -1;
+    }
+    return sequential_encoders_[loc_id]->GetParentAttributeId(parent_i);
+  }
+
+  bool MarkParentAttribute(int32_t point_attribute_id) override {
+    const int32_t loc_id = GetLocalIdForPointAttribute(point_attribute_id);
+    if (loc_id < 0) {
+      return false;
+    }
+    // Mark the attribute encoder as parent (even when if it is not created
+    // yet).
+    if (sequential_encoder_marked_as_parent_.size() <= loc_id) {
+      sequential_encoder_marked_as_parent_.resize(loc_id + 1, false);
+    }
+    sequential_encoder_marked_as_parent_[loc_id] = true;
+
+    if (sequential_encoders_.size() <= loc_id) {
+      return true;  // Sequential encoders not generated yet.
+    }
+    sequential_encoders_[loc_id]->MarkParentAttribute();
+    return true;
+  }
+
+  const PointAttribute *GetPortableAttribute(
+      int32_t point_attribute_id) override {
+    const int32_t loc_id = GetLocalIdForPointAttribute(point_attribute_id);
+    if (loc_id < 0) {
+      return nullptr;
+    }
+    return sequential_encoders_[loc_id]->GetPortableAttribute();
+  }
+
+ protected:
+  bool TransformAttributesToPortableFormat() override;
+  bool EncodePortableAttributes(EncoderBuffer *out_buffer) override;
+  bool EncodeDataNeededByPortableTransforms(EncoderBuffer *out_buffer) override;
+
+  // Creates all sequential encoders (one for each attribute associated with the
+  // encoder).
+  virtual bool CreateSequentialEncoders();
+
+  // Create a sequential encoder for a given attribute based on the attribute
+  // type
+  // and the provided encoder options.
+  virtual std::unique_ptr<SequentialAttributeEncoder> CreateSequentialEncoder(
+      int i);
+
+ private:
+  std::vector<std::unique_ptr<SequentialAttributeEncoder>> sequential_encoders_;
+
+  // Flag for each sequential attribute encoder indicating whether it was marked
+  // as parent attribute or not.
+  std::vector<bool> sequential_encoder_marked_as_parent_;
+  std::vector<PointIndex> point_ids_;
+  std::unique_ptr<PointsSequencer> sequencer_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_ENCODERS_CONTROLLER_H_
diff --git a/engine/inc/draco/compression/attributes/sequential_integer_attribute_decoder.h b/engine/inc/draco/compression/attributes/sequential_integer_attribute_decoder.h
new file mode 100644
index 00000000..ef48ed81
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/sequential_integer_attribute_decoder.h
@@ -0,0 +1,76 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_INTEGER_ATTRIBUTE_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_INTEGER_ATTRIBUTE_DECODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_decoder.h"
+#include "draco/compression/attributes/sequential_attribute_decoder.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Decoder for attributes encoded with the SequentialIntegerAttributeEncoder.
+class SequentialIntegerAttributeDecoder : public SequentialAttributeDecoder {
+ public:
+  SequentialIntegerAttributeDecoder();
+  bool Init(PointCloudDecoder *decoder, int attribute_id) override;
+
+  bool TransformAttributeToOriginalFormat(
+      const std::vector<PointIndex> &point_ids) override;
+
+ protected:
+  bool DecodeValues(const std::vector<PointIndex> &point_ids,
+                    DecoderBuffer *in_buffer) override;
+  virtual bool DecodeIntegerValues(const std::vector<PointIndex> &point_ids,
+                                   DecoderBuffer *in_buffer);
+
+  // Returns a prediction scheme that should be used for decoding of the
+  // integer values.
+  virtual std::unique_ptr<PredictionSchemeTypedDecoderInterface<int32_t>>
+  CreateIntPredictionScheme(PredictionSchemeMethod method,
+                            PredictionSchemeTransformType transform_type);
+
+  // Returns the number of integer attribute components. In general, this
+  // can be different from the number of components of the input attribute.
+  virtual int32_t GetNumValueComponents() const {
+    return attribute()->num_components();
+  }
+
+  // Called after all integer values are decoded. The implementation should
+  // use this method to store the values into the attribute.
+  virtual bool StoreValues(uint32_t num_values);
+
+  void PreparePortableAttribute(int num_entries, int num_components);
+
+  int32_t *GetPortableAttributeData() {
+    if (portable_attribute()->size() == 0) {
+      return nullptr;
+    }
+    return reinterpret_cast<int32_t *>(
+        portable_attribute()->GetAddress(AttributeValueIndex(0)));
+  }
+
+ private:
+  // Stores decoded values into the attribute with a data type AttributeTypeT.
+  template <typename AttributeTypeT>
+  void StoreTypedValues(uint32_t num_values);
+
+  std::unique_ptr<PredictionSchemeTypedDecoderInterface<int32_t>>
+      prediction_scheme_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_INTEGER_ATTRIBUTE_DECODER_H_
diff --git a/engine/inc/draco/compression/attributes/sequential_integer_attribute_encoder.h b/engine/inc/draco/compression/attributes/sequential_integer_attribute_encoder.h
new file mode 100644
index 00000000..c1d6222e
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/sequential_integer_attribute_encoder.h
@@ -0,0 +1,67 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_INTEGER_ATTRIBUTE_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_INTEGER_ATTRIBUTE_ENCODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_encoder.h"
+#include "draco/compression/attributes/sequential_attribute_encoder.h"
+
+namespace draco {
+
+// Attribute encoder designed for lossless encoding of integer attributes. The
+// attribute values can be pre-processed by a prediction scheme and compressed
+// with a built-in entropy coder.
+class SequentialIntegerAttributeEncoder : public SequentialAttributeEncoder {
+ public:
+  SequentialIntegerAttributeEncoder();
+  uint8_t GetUniqueId() const override {
+    return SEQUENTIAL_ATTRIBUTE_ENCODER_INTEGER;
+  }
+
+  bool Init(PointCloudEncoder *encoder, int attribute_id) override;
+  bool TransformAttributeToPortableFormat(
+      const std::vector<PointIndex> &point_ids) override;
+
+ protected:
+  bool EncodeValues(const std::vector<PointIndex> &point_ids,
+                    EncoderBuffer *out_buffer) override;
+
+  // Returns a prediction scheme that should be used for encoding of the
+  // integer values.
+  virtual std::unique_ptr<PredictionSchemeTypedEncoderInterface<int32_t>>
+  CreateIntPredictionScheme(PredictionSchemeMethod method);
+
+  // Prepares the integer values that are going to be encoded.
+  virtual bool PrepareValues(const std::vector<PointIndex> &point_ids,
+                             int num_points);
+
+  void PreparePortableAttribute(int num_entries, int num_components,
+                                int num_points);
+
+  int32_t *GetPortableAttributeData() {
+    return reinterpret_cast<int32_t *>(
+        portable_attribute()->GetAddress(AttributeValueIndex(0)));
+  }
+
+ private:
+  // Optional prediction scheme can be used to modify the integer values in
+  // order to make them easier to compress.
+  std::unique_ptr<PredictionSchemeTypedEncoderInterface<int32_t>>
+      prediction_scheme_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_INTEGER_ATTRIBUTE_ENCODER_H_
diff --git a/engine/inc/draco/compression/attributes/sequential_normal_attribute_decoder.h b/engine/inc/draco/compression/attributes/sequential_normal_attribute_decoder.h
new file mode 100644
index 00000000..8c2d801b
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/sequential_normal_attribute_decoder.h
@@ -0,0 +1,83 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_NORMAL_ATTRIBUTE_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_NORMAL_ATTRIBUTE_DECODER_H_
+
+#include "draco/attributes/attribute_octahedron_transform.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_factory.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_decoding_transform.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_decoding_transform.h"
+#include "draco/compression/attributes/sequential_integer_attribute_decoder.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Decoder for attributes encoded with SequentialNormalAttributeEncoder.
+class SequentialNormalAttributeDecoder
+    : public SequentialIntegerAttributeDecoder {
+ public:
+  SequentialNormalAttributeDecoder();
+  bool Init(PointCloudDecoder *decoder, int attribute_id) override;
+
+ protected:
+  int32_t GetNumValueComponents() const override {
+    return 2;  // We quantize everything into two components.
+  }
+  bool DecodeIntegerValues(const std::vector<PointIndex> &point_ids,
+                           DecoderBuffer *in_buffer) override;
+  bool DecodeDataNeededByPortableTransform(
+      const std::vector<PointIndex> &point_ids,
+      DecoderBuffer *in_buffer) override;
+  bool StoreValues(uint32_t num_points) override;
+
+ private:
+  AttributeOctahedronTransform octahedral_transform_;
+
+  std::unique_ptr<PredictionSchemeTypedDecoderInterface<int32_t>>
+  CreateIntPredictionScheme(
+      PredictionSchemeMethod method,
+      PredictionSchemeTransformType transform_type) override {
+    switch (transform_type) {
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+      case PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON: {
+        typedef PredictionSchemeNormalOctahedronDecodingTransform<int32_t>
+            Transform;
+        // At this point the decoder has not read the quantization bits,
+        // which is why we must construct the transform by default.
+        // See Transform.DecodeTransformData for more details.
+        return CreatePredictionSchemeForDecoder<int32_t, Transform>(
+            method, attribute_id(), decoder());
+      }
+#endif
+      case PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON_CANONICALIZED: {
+        typedef PredictionSchemeNormalOctahedronCanonicalizedDecodingTransform<
+            int32_t>
+            Transform;
+        // At this point the decoder has not read the quantization bits,
+        // which is why we must construct the transform by default.
+        // See Transform.DecodeTransformData for more details.
+        return CreatePredictionSchemeForDecoder<int32_t, Transform>(
+            method, attribute_id(), decoder());
+      }
+      default:
+        return nullptr;  // Currently, we support only octahedron transform and
+                         // octahedron transform canonicalized.
+    }
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_NORMAL_ATTRIBUTE_DECODER_H_
diff --git a/engine/inc/draco/compression/attributes/sequential_normal_attribute_encoder.h b/engine/inc/draco/compression/attributes/sequential_normal_attribute_encoder.h
new file mode 100644
index 00000000..53705c59
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/sequential_normal_attribute_encoder.h
@@ -0,0 +1,82 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_NORMAL_ATTRIBUTE_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_NORMAL_ATTRIBUTE_ENCODER_H_
+
+#include "draco/attributes/attribute_octahedron_transform.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_factory.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_encoding_transform.h"
+#include "draco/compression/attributes/sequential_integer_attribute_encoder.h"
+#include "draco/compression/config/compression_shared.h"
+
+namespace draco {
+
+// Class for encoding normal vectors using an octahedral encoding, see Cigolle
+// et al.'14 “A Survey of Efficient Representations for Independent Unit
+// Vectors�. Compared to the basic quantization encoder, this encoder results
+// in a better compression rate under the same accuracy settings. Note that this
+// encoder doesn't preserve the lengths of input vectors, therefore it will not
+// work correctly when the input values are not normalized.
+class SequentialNormalAttributeEncoder
+    : public SequentialIntegerAttributeEncoder {
+ public:
+  uint8_t GetUniqueId() const override {
+    return SEQUENTIAL_ATTRIBUTE_ENCODER_NORMALS;
+  }
+  bool IsLossyEncoder() const override { return true; }
+
+  bool EncodeDataNeededByPortableTransform(EncoderBuffer *out_buffer) override;
+
+ protected:
+  bool Init(PointCloudEncoder *encoder, int attribute_id) override;
+
+  // Put quantized values in portable attribute for sequential encoding.
+  bool PrepareValues(const std::vector<PointIndex> &point_ids,
+                     int num_points) override;
+
+  std::unique_ptr<PredictionSchemeTypedEncoderInterface<int32_t>>
+  CreateIntPredictionScheme(PredictionSchemeMethod /* method */) override {
+    typedef PredictionSchemeNormalOctahedronCanonicalizedEncodingTransform<
+        int32_t>
+        Transform;
+    const int32_t quantization_bits = encoder()->options()->GetAttributeInt(
+        attribute_id(), "quantization_bits", -1);
+    const int32_t max_value = (1 << quantization_bits) - 1;
+    const Transform transform(max_value);
+    const PredictionSchemeMethod default_prediction_method =
+        SelectPredictionMethod(attribute_id(), encoder());
+    const int32_t prediction_method = encoder()->options()->GetAttributeInt(
+        attribute_id(), "prediction_scheme", default_prediction_method);
+
+    if (prediction_method == MESH_PREDICTION_GEOMETRIC_NORMAL) {
+      return CreatePredictionSchemeForEncoder<int32_t, Transform>(
+          MESH_PREDICTION_GEOMETRIC_NORMAL, attribute_id(), encoder(),
+          transform);
+    }
+    if (prediction_method == PREDICTION_DIFFERENCE) {
+      return CreatePredictionSchemeForEncoder<int32_t, Transform>(
+          PREDICTION_DIFFERENCE, attribute_id(), encoder(), transform);
+    }
+    DRACO_DCHECK(false);  // Should never be reached.
+    return nullptr;
+  }
+
+  // Used for the conversion to quantized normals in octahedral format.
+  AttributeOctahedronTransform attribute_octahedron_transform_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_NORMAL_ATTRIBUTE_ENCODER_H_
diff --git a/engine/inc/draco/compression/attributes/sequential_quantization_attribute_decoder.h b/engine/inc/draco/compression/attributes/sequential_quantization_attribute_decoder.h
new file mode 100644
index 00000000..ad372dcd
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/sequential_quantization_attribute_decoder.h
@@ -0,0 +1,52 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_QUANTIZATION_ATTRIBUTE_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_QUANTIZATION_ATTRIBUTE_DECODER_H_
+
+#include "draco/attributes/attribute_quantization_transform.h"
+#include "draco/compression/attributes/sequential_integer_attribute_decoder.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Decoder for attribute values encoded with the
+// SequentialQuantizationAttributeEncoder.
+class SequentialQuantizationAttributeDecoder
+    : public SequentialIntegerAttributeDecoder {
+ public:
+  SequentialQuantizationAttributeDecoder();
+  bool Init(PointCloudDecoder *decoder, int attribute_id) override;
+
+ protected:
+  bool DecodeIntegerValues(const std::vector<PointIndex> &point_ids,
+                           DecoderBuffer *in_buffer) override;
+  bool DecodeDataNeededByPortableTransform(
+      const std::vector<PointIndex> &point_ids,
+      DecoderBuffer *in_buffer) override;
+  bool StoreValues(uint32_t num_points) override;
+
+  // Decodes data necessary for dequantizing the encoded values.
+  virtual bool DecodeQuantizedDataInfo();
+
+  // Dequantizes all values and stores them into the output attribute.
+  virtual bool DequantizeValues(uint32_t num_values);
+
+ private:
+  AttributeQuantizationTransform quantization_transform_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_QUANTIZATION_ATTRIBUTE_DECODER_H_
diff --git a/engine/inc/draco/compression/attributes/sequential_quantization_attribute_encoder.h b/engine/inc/draco/compression/attributes/sequential_quantization_attribute_encoder.h
new file mode 100644
index 00000000..e9762bdd
--- /dev/null
+++ b/engine/inc/draco/compression/attributes/sequential_quantization_attribute_encoder.h
@@ -0,0 +1,52 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_QUANTIZATION_ATTRIBUTE_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_QUANTIZATION_ATTRIBUTE_ENCODER_H_
+
+#include "draco/attributes/attribute_quantization_transform.h"
+#include "draco/compression/attributes/sequential_integer_attribute_encoder.h"
+
+namespace draco {
+
+class MeshEncoder;
+
+// Attribute encoder that quantizes floating point attribute values. The
+// quantized values can be optionally compressed using an entropy coding.
+class SequentialQuantizationAttributeEncoder
+    : public SequentialIntegerAttributeEncoder {
+ public:
+  SequentialQuantizationAttributeEncoder();
+  uint8_t GetUniqueId() const override {
+    return SEQUENTIAL_ATTRIBUTE_ENCODER_QUANTIZATION;
+  }
+  bool Init(PointCloudEncoder *encoder, int attribute_id) override;
+
+  bool IsLossyEncoder() const override { return true; }
+
+  bool EncodeDataNeededByPortableTransform(EncoderBuffer *out_buffer) override;
+
+ protected:
+  // Put quantized values in portable attribute for sequential encoding.
+  bool PrepareValues(const std::vector<PointIndex> &point_ids,
+                     int num_points) override;
+
+ private:
+  // Used for the quantization.
+  AttributeQuantizationTransform attribute_quantization_transform_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_QUANTIZATION_ATTRIBUTE_ENCODER_H_
diff --git a/engine/inc/draco/compression/bit_coders/adaptive_rans_bit_coding_shared.h b/engine/inc/draco/compression/bit_coders/adaptive_rans_bit_coding_shared.h
new file mode 100644
index 00000000..faacbd5b
--- /dev/null
+++ b/engine/inc/draco/compression/bit_coders/adaptive_rans_bit_coding_shared.h
@@ -0,0 +1,43 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File provides shared functions for adaptive rANS bit coding.
+#ifndef DRACO_COMPRESSION_BIT_CODERS_ADAPTIVE_RANS_BIT_CODING_SHARED_H_
+#define DRACO_COMPRESSION_BIT_CODERS_ADAPTIVE_RANS_BIT_CODING_SHARED_H_
+
+#include "draco/core/macros.h"
+
+namespace draco {
+
+// Clamp the probability p to a uint8_t in the range [1,255].
+inline uint8_t clamp_probability(double p) {
+  DRACO_DCHECK_LE(p, 1.0);
+  DRACO_DCHECK_LE(0.0, p);
+  uint32_t p_int = static_cast<uint32_t>((p * 256) + 0.5);
+  p_int -= (p_int == 256);
+  p_int += (p_int == 0);
+  return static_cast<uint8_t>(p_int);
+}
+
+// Update the probability according to new incoming bit.
+inline double update_probability(double old_p, bool bit) {
+  static constexpr double w = 128.0;
+  static constexpr double w0 = (w - 1.0) / w;
+  static constexpr double w1 = 1.0 / w;
+  return old_p * w0 + (!bit) * w1;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_ADAPTIVE_RANS_BIT_CODING_SHARED_H_
diff --git a/engine/inc/draco/compression/bit_coders/adaptive_rans_bit_decoder.h b/engine/inc/draco/compression/bit_coders/adaptive_rans_bit_decoder.h
new file mode 100644
index 00000000..a1ea011d
--- /dev/null
+++ b/engine/inc/draco/compression/bit_coders/adaptive_rans_bit_decoder.h
@@ -0,0 +1,54 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File provides basic classes and functions for rANS bit decoding.
+#ifndef DRACO_COMPRESSION_BIT_CODERS_ADAPTIVE_RANS_BIT_DECODER_H_
+#define DRACO_COMPRESSION_BIT_CODERS_ADAPTIVE_RANS_BIT_DECODER_H_
+
+#include <vector>
+
+#include "draco/compression/entropy/ans.h"
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+
+// Class for decoding a sequence of bits that were encoded with
+// AdaptiveRAnsBitEncoder.
+class AdaptiveRAnsBitDecoder {
+ public:
+  AdaptiveRAnsBitDecoder();
+  ~AdaptiveRAnsBitDecoder();
+
+  // Sets |source_buffer| as the buffer to decode bits from.
+  bool StartDecoding(DecoderBuffer *source_buffer);
+
+  // Decode one bit. Returns true if the bit is a 1, otherwise false.
+  bool DecodeNextBit();
+
+  // Decode the next |nbits| and return the sequence in |value|. |nbits| must be
+  // > 0 and <= 32.
+  void DecodeLeastSignificantBits32(int nbits, uint32_t *value);
+
+  void EndDecoding() {}
+
+ private:
+  void Clear();
+
+  AnsDecoder ans_decoder_;
+  double p0_f_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_ADAPTIVE_RANS_BIT_DECODER_H_
diff --git a/engine/inc/draco/compression/bit_coders/adaptive_rans_bit_encoder.h b/engine/inc/draco/compression/bit_coders/adaptive_rans_bit_encoder.h
new file mode 100644
index 00000000..9b183284
--- /dev/null
+++ b/engine/inc/draco/compression/bit_coders/adaptive_rans_bit_encoder.h
@@ -0,0 +1,61 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File provides basic classes and functions for rANS bit encoding.
+#ifndef DRACO_COMPRESSION_BIT_CODERS_ADAPTIVE_RANS_BIT_ENCODER_H_
+#define DRACO_COMPRESSION_BIT_CODERS_ADAPTIVE_RANS_BIT_ENCODER_H_
+
+#include <vector>
+
+#include "draco/compression/entropy/ans.h"
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// Class for adaptive encoding a sequence of bits using rANS.
+class AdaptiveRAnsBitEncoder {
+ public:
+  AdaptiveRAnsBitEncoder();
+  ~AdaptiveRAnsBitEncoder();
+
+  // Must be called before any Encode* function is called.
+  void StartEncoding();
+
+  // Encode one bit. If |bit| is true encode a 1, otherwise encode a 0.
+  void EncodeBit(bool bit) { bits_.push_back(bit); }
+
+  // Encode |nbits| of |value|, starting from the least significant bit.
+  // |nbits| must be > 0 and <= 32.
+  void EncodeLeastSignificantBits32(int nbits, uint32_t value) {
+    DRACO_DCHECK_EQ(true, nbits <= 32);
+    DRACO_DCHECK_EQ(true, nbits > 0);
+    uint32_t selector = (1 << (nbits - 1));
+    while (selector) {
+      EncodeBit(value & selector);
+      selector = selector >> 1;
+    }
+  }
+
+  // Ends the bit encoding and stores the result into the target_buffer.
+  void EndEncoding(EncoderBuffer *target_buffer);
+
+ private:
+  void Clear();
+
+  std::vector<bool> bits_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_ADAPTIVE_RANS_BIT_ENCODER_H_
diff --git a/engine/inc/draco/compression/bit_coders/direct_bit_decoder.h b/engine/inc/draco/compression/bit_coders/direct_bit_decoder.h
new file mode 100644
index 00000000..b9fbc2d6
--- /dev/null
+++ b/engine/inc/draco/compression/bit_coders/direct_bit_decoder.h
@@ -0,0 +1,90 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File provides direct encoding of bits with arithmetic encoder interface.
+#ifndef DRACO_COMPRESSION_BIT_CODERS_DIRECT_BIT_DECODER_H_
+#define DRACO_COMPRESSION_BIT_CODERS_DIRECT_BIT_DECODER_H_
+
+#include <vector>
+
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+
+class DirectBitDecoder {
+ public:
+  DirectBitDecoder();
+  ~DirectBitDecoder();
+
+  // Sets |source_buffer| as the buffer to decode bits from.
+  bool StartDecoding(DecoderBuffer *source_buffer);
+
+  // Decode one bit. Returns true if the bit is a 1, otherwise false.
+  bool DecodeNextBit() {
+    const uint32_t selector = 1 << (31 - num_used_bits_);
+    if (pos_ == bits_.end()) {
+      return false;
+    }
+    const bool bit = *pos_ & selector;
+    ++num_used_bits_;
+    if (num_used_bits_ == 32) {
+      ++pos_;
+      num_used_bits_ = 0;
+    }
+    return bit;
+  }
+
+  // Decode the next |nbits| and return the sequence in |value|. |nbits| must be
+  // > 0 and <= 32.
+  void DecodeLeastSignificantBits32(int nbits, uint32_t *value) {
+    DRACO_DCHECK_EQ(true, nbits <= 32);
+    DRACO_DCHECK_EQ(true, nbits > 0);
+    const int remaining = 32 - num_used_bits_;
+    if (nbits <= remaining) {
+      if (pos_ == bits_.end()) {
+        *value = 0;
+        return;
+      }
+      *value = (*pos_ << num_used_bits_) >> (32 - nbits);
+      num_used_bits_ += nbits;
+      if (num_used_bits_ == 32) {
+        ++pos_;
+        num_used_bits_ = 0;
+      }
+    } else {
+      if (pos_ + 1 == bits_.end()) {
+        *value = 0;
+        return;
+      }
+      const uint32_t value_l = ((*pos_) << num_used_bits_);
+      num_used_bits_ = nbits - remaining;
+      ++pos_;
+      const uint32_t value_r = (*pos_) >> (32 - num_used_bits_);
+      *value = (value_l >> (32 - num_used_bits_ - remaining)) | value_r;
+    }
+  }
+
+  void EndDecoding() {}
+
+ private:
+  void Clear();
+
+  std::vector<uint32_t> bits_;
+  std::vector<uint32_t>::const_iterator pos_;
+  uint32_t num_used_bits_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_DIRECT_BIT_DECODER_H_
diff --git a/engine/inc/draco/compression/bit_coders/direct_bit_encoder.h b/engine/inc/draco/compression/bit_coders/direct_bit_encoder.h
new file mode 100644
index 00000000..705b2ca9
--- /dev/null
+++ b/engine/inc/draco/compression/bit_coders/direct_bit_encoder.h
@@ -0,0 +1,89 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File provides direct encoding of bits with arithmetic encoder interface.
+#ifndef DRACO_COMPRESSION_BIT_CODERS_DIRECT_BIT_ENCODER_H_
+#define DRACO_COMPRESSION_BIT_CODERS_DIRECT_BIT_ENCODER_H_
+
+#include <vector>
+
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+class DirectBitEncoder {
+ public:
+  DirectBitEncoder();
+  ~DirectBitEncoder();
+
+  // Must be called before any Encode* function is called.
+  void StartEncoding();
+
+  // Encode one bit. If |bit| is true encode a 1, otherwise encode a 0.
+  void EncodeBit(bool bit) {
+    if (bit) {
+      local_bits_ |= 1 << (31 - num_local_bits_);
+    }
+    num_local_bits_++;
+    if (num_local_bits_ == 32) {
+      bits_.push_back(local_bits_);
+      num_local_bits_ = 0;
+      local_bits_ = 0;
+    }
+  }
+
+  // Encode |nbits| of |value|, starting from the least significant bit.
+  // |nbits| must be > 0 and <= 32.
+  void EncodeLeastSignificantBits32(int nbits, uint32_t value) {
+    DRACO_DCHECK_EQ(true, nbits <= 32);
+    DRACO_DCHECK_EQ(true, nbits > 0);
+
+    const int remaining = 32 - num_local_bits_;
+
+    // Make sure there are no leading bits that should not be encoded and
+    // start from here.
+    value = value << (32 - nbits);
+    if (nbits <= remaining) {
+      value = value >> num_local_bits_;
+      local_bits_ = local_bits_ | value;
+      num_local_bits_ += nbits;
+      if (num_local_bits_ == 32) {
+        bits_.push_back(local_bits_);
+        local_bits_ = 0;
+        num_local_bits_ = 0;
+      }
+    } else {
+      value = value >> (32 - nbits);
+      num_local_bits_ = nbits - remaining;
+      const uint32_t value_l = value >> num_local_bits_;
+      local_bits_ = local_bits_ | value_l;
+      bits_.push_back(local_bits_);
+      local_bits_ = value << (32 - num_local_bits_);
+    }
+  }
+
+  // Ends the bit encoding and stores the result into the target_buffer.
+  void EndEncoding(EncoderBuffer *target_buffer);
+
+ private:
+  void Clear();
+
+  std::vector<uint32_t> bits_;
+  uint32_t local_bits_;
+  uint32_t num_local_bits_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_DIRECT_BIT_ENCODER_H_
diff --git a/engine/inc/draco/compression/bit_coders/folded_integer_bit_decoder.h b/engine/inc/draco/compression/bit_coders/folded_integer_bit_decoder.h
new file mode 100644
index 00000000..c14058b6
--- /dev/null
+++ b/engine/inc/draco/compression/bit_coders/folded_integer_bit_decoder.h
@@ -0,0 +1,77 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File provides direct encoding of bits with arithmetic encoder interface.
+#ifndef DRACO_COMPRESSION_BIT_CODERS_FOLDED_INTEGER_BIT_DECODER_H_
+#define DRACO_COMPRESSION_BIT_CODERS_FOLDED_INTEGER_BIT_DECODER_H_
+
+#include <vector>
+
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+
+// See FoldedBit32Encoder for more details.
+template <class BitDecoderT>
+class FoldedBit32Decoder {
+ public:
+  FoldedBit32Decoder() {}
+  ~FoldedBit32Decoder() {}
+
+  // Sets |source_buffer| as the buffer to decode bits from.
+  bool StartDecoding(DecoderBuffer *source_buffer) {
+    for (int i = 0; i < 32; i++) {
+      if (!folded_number_decoders_[i].StartDecoding(source_buffer)) {
+        return false;
+      }
+    }
+    return bit_decoder_.StartDecoding(source_buffer);
+  }
+
+  // Decode one bit. Returns true if the bit is a 1, otherwise false.
+  bool DecodeNextBit() { return bit_decoder_.DecodeNextBit(); }
+
+  // Decode the next |nbits| and return the sequence in |value|. |nbits| must be
+  // > 0 and <= 32.
+  void DecodeLeastSignificantBits32(int nbits, uint32_t *value) {
+    uint32_t result = 0;
+    for (int i = 0; i < nbits; ++i) {
+      const bool bit = folded_number_decoders_[i].DecodeNextBit();
+      result = (result << 1) + bit;
+    }
+    *value = result;
+  }
+
+  void EndDecoding() {
+    for (int i = 0; i < 32; i++) {
+      folded_number_decoders_[i].EndDecoding();
+    }
+    bit_decoder_.EndDecoding();
+  }
+
+ private:
+  void Clear() {
+    for (int i = 0; i < 32; i++) {
+      folded_number_decoders_[i].Clear();
+    }
+    bit_decoder_.Clear();
+  }
+
+  std::array<BitDecoderT, 32> folded_number_decoders_;
+  BitDecoderT bit_decoder_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_FOLDED_INTEGER_BIT_DECODER_H_
diff --git a/engine/inc/draco/compression/bit_coders/folded_integer_bit_encoder.h b/engine/inc/draco/compression/bit_coders/folded_integer_bit_encoder.h
new file mode 100644
index 00000000..375b38a6
--- /dev/null
+++ b/engine/inc/draco/compression/bit_coders/folded_integer_bit_encoder.h
@@ -0,0 +1,82 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File provides direct encoding of bits with arithmetic encoder interface.
+#ifndef DRACO_COMPRESSION_BIT_CODERS_FOLDED_INTEGER_BIT_ENCODER_H_
+#define DRACO_COMPRESSION_BIT_CODERS_FOLDED_INTEGER_BIT_ENCODER_H_
+
+#include <vector>
+
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// This coding scheme considers every bit of an (up to) 32bit integer as a
+// separate context. This can be a significant advantage when encoding numbers
+// where it is more likely that the front bits are zero.
+// The behavior is essentially the same as other arithmetic encoding schemes,
+// the only difference is that encoding and decoding of bits must be absolutely
+// symmetric, bits handed in by EncodeBit32 must be also decoded in this way.
+// This is the FoldedBit32Encoder, see also FoldedBit32Decoder.
+template <class BitEncoderT>
+class FoldedBit32Encoder {
+ public:
+  FoldedBit32Encoder() {}
+  ~FoldedBit32Encoder() {}
+
+  // Must be called before any Encode* function is called.
+  void StartEncoding() {
+    for (int i = 0; i < 32; i++) {
+      folded_number_encoders_[i].StartEncoding();
+    }
+    bit_encoder_.StartEncoding();
+  }
+
+  // Encode one bit. If |bit| is true encode a 1, otherwise encode a 0.
+  void EncodeBit(bool bit) { bit_encoder_.EncodeBit(bit); }
+
+  // Encode |nbits| of |value|, starting from the least significant bit.
+  // |nbits| must be > 0 and <= 32.
+  void EncodeLeastSignificantBits32(int nbits, uint32_t value) {
+    uint32_t selector = 1 << (nbits - 1);
+    for (int i = 0; i < nbits; i++) {
+      const bool bit = (value & selector);
+      folded_number_encoders_[i].EncodeBit(bit);
+      selector = selector >> 1;
+    }
+  }
+
+  // Ends the bit encoding and stores the result into the target_buffer.
+  void EndEncoding(EncoderBuffer *target_buffer) {
+    for (int i = 0; i < 32; i++) {
+      folded_number_encoders_[i].EndEncoding(target_buffer);
+    }
+    bit_encoder_.EndEncoding(target_buffer);
+  }
+
+ private:
+  void Clear() {
+    for (int i = 0; i < 32; i++) {
+      folded_number_encoders_[i].Clear();
+    }
+    bit_encoder_.Clear();
+  }
+
+  std::array<BitEncoderT, 32> folded_number_encoders_;
+  BitEncoderT bit_encoder_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_FOLDED_INTEGER_BIT_ENCODER_H_
diff --git a/engine/inc/draco/compression/bit_coders/rans_bit_decoder.h b/engine/inc/draco/compression/bit_coders/rans_bit_decoder.h
new file mode 100644
index 00000000..25d243ea
--- /dev/null
+++ b/engine/inc/draco/compression/bit_coders/rans_bit_decoder.h
@@ -0,0 +1,55 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File provides basic classes and functions for rANS coding.
+#ifndef DRACO_COMPRESSION_BIT_CODERS_RANS_BIT_DECODER_H_
+#define DRACO_COMPRESSION_BIT_CODERS_RANS_BIT_DECODER_H_
+
+#include <vector>
+
+#include "draco/compression/entropy/ans.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Class for decoding a sequence of bits that were encoded with RAnsBitEncoder.
+class RAnsBitDecoder {
+ public:
+  RAnsBitDecoder();
+  ~RAnsBitDecoder();
+
+  // Sets |source_buffer| as the buffer to decode bits from.
+  // Returns false when the data is invalid.
+  bool StartDecoding(DecoderBuffer *source_buffer);
+
+  // Decode one bit. Returns true if the bit is a 1, otherwise false.
+  bool DecodeNextBit();
+
+  // Decode the next |nbits| and return the sequence in |value|. |nbits| must be
+  // > 0 and <= 32.
+  void DecodeLeastSignificantBits32(int nbits, uint32_t *value);
+
+  void EndDecoding() {}
+
+ private:
+  void Clear();
+
+  AnsDecoder ans_decoder_;
+  uint8_t prob_zero_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_RANS_BIT_DECODER_H_
diff --git a/engine/inc/draco/compression/bit_coders/rans_bit_encoder.h b/engine/inc/draco/compression/bit_coders/rans_bit_encoder.h
new file mode 100644
index 00000000..1993dd3d
--- /dev/null
+++ b/engine/inc/draco/compression/bit_coders/rans_bit_encoder.h
@@ -0,0 +1,57 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File provides basic classes and functions for rANS coding.
+#ifndef DRACO_COMPRESSION_BIT_CODERS_RANS_BIT_ENCODER_H_
+#define DRACO_COMPRESSION_BIT_CODERS_RANS_BIT_ENCODER_H_
+
+#include <vector>
+
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// Class for encoding a sequence of bits using rANS. The probability table used
+// to encode the bits is based off the total counts of bits.
+// TODO(fgalligan): Investigate using an adaptive table for more compression.
+class RAnsBitEncoder {
+ public:
+  RAnsBitEncoder();
+  ~RAnsBitEncoder();
+
+  // Must be called before any Encode* function is called.
+  void StartEncoding();
+
+  // Encode one bit. If |bit| is true encode a 1, otherwise encode a 0.
+  void EncodeBit(bool bit);
+
+  // Encode |nbits| of |value|, starting from the least significant bit.
+  // |nbits| must be > 0 and <= 32.
+  void EncodeLeastSignificantBits32(int nbits, uint32_t value);
+
+  // Ends the bit encoding and stores the result into the target_buffer.
+  void EndEncoding(EncoderBuffer *target_buffer);
+
+ private:
+  void Clear();
+
+  std::vector<uint64_t> bit_counts_;
+  std::vector<uint32_t> bits_;
+  uint32_t local_bits_;
+  uint32_t num_local_bits_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_RANS_BIT_ENCODER_H_
diff --git a/engine/inc/draco/compression/bit_coders/symbol_bit_decoder.h b/engine/inc/draco/compression/bit_coders/symbol_bit_decoder.h
new file mode 100644
index 00000000..909d7174
--- /dev/null
+++ b/engine/inc/draco/compression/bit_coders/symbol_bit_decoder.h
@@ -0,0 +1,36 @@
+#ifndef DRACO_COMPRESSION_BIT_CODERS_SYMBOL_BIT_DECODER_H_
+#define DRACO_COMPRESSION_BIT_CODERS_SYMBOL_BIT_DECODER_H_
+
+#include <algorithm>
+#include <vector>
+
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+
+// Class for decoding bits using the symbol entropy encoding. Wraps
+// |DecodeSymbols|. Note that this uses a symbol-based encoding scheme for
+// encoding bits.
+class SymbolBitDecoder {
+ public:
+  // Sets |source_buffer| as the buffer to decode bits from.
+  bool StartDecoding(DecoderBuffer *source_buffer);
+
+  // Decode one bit. Returns true if the bit is a 1, otherwise false.
+  bool DecodeNextBit();
+
+  // Decode the next |nbits| and return the sequence in |value|. |nbits| must be
+  // > 0 and <= 32.
+  void DecodeLeastSignificantBits32(int nbits, uint32_t *value);
+
+  void EndDecoding() { Clear(); }
+
+ private:
+  void Clear();
+
+  std::vector<uint32_t> symbols_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_SYMBOL_BIT_DECODER_H_
diff --git a/engine/inc/draco/compression/bit_coders/symbol_bit_encoder.h b/engine/inc/draco/compression/bit_coders/symbol_bit_encoder.h
new file mode 100644
index 00000000..7f1570c1
--- /dev/null
+++ b/engine/inc/draco/compression/bit_coders/symbol_bit_encoder.h
@@ -0,0 +1,36 @@
+#ifndef DRACO_COMPRESSION_BIT_CODERS_SYMBOL_BIT_ENCODER_H_
+#define DRACO_COMPRESSION_BIT_CODERS_SYMBOL_BIT_ENCODER_H_
+
+#include <algorithm>
+#include <vector>
+
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// Class for encoding bits using the symbol entropy encoding. Wraps
+// |EncodeSymbols|. Note that this uses a symbol-based encoding scheme for
+// encoding bits.
+class SymbolBitEncoder {
+ public:
+  // Must be called before any Encode* function is called.
+  void StartEncoding() { Clear(); }
+
+  // Encode one bit. If |bit| is true encode a 1, otherwise encode a 0.
+  void EncodeBit(bool bit) { EncodeLeastSignificantBits32(1, bit ? 1 : 0); }
+
+  // Encode |nbits| LSBs of |value| as a symbol. |nbits| must be > 0 and <= 32.
+  void EncodeLeastSignificantBits32(int nbits, uint32_t value);
+
+  // Ends the bit encoding and stores the result into the target_buffer.
+  void EndEncoding(EncoderBuffer *target_buffer);
+
+ private:
+  void Clear();
+
+  std::vector<uint32_t> symbols_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_SYMBOL_BIT_ENCODER_H_
diff --git a/engine/inc/draco/compression/config/compression_shared.h b/engine/inc/draco/compression/config/compression_shared.h
new file mode 100644
index 00000000..c43f303b
--- /dev/null
+++ b/engine/inc/draco/compression/config/compression_shared.h
@@ -0,0 +1,155 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_CONFIG_COMPRESSION_SHARED_H_
+#define DRACO_COMPRESSION_CONFIG_COMPRESSION_SHARED_H_
+
+#include <stdint.h>
+
+#include "draco/core/macros.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Latest Draco bit-stream version.
+static constexpr uint8_t kDracoPointCloudBitstreamVersionMajor = 2;
+static constexpr uint8_t kDracoPointCloudBitstreamVersionMinor = 3;
+static constexpr uint8_t kDracoMeshBitstreamVersionMajor = 2;
+static constexpr uint8_t kDracoMeshBitstreamVersionMinor = 2;
+
+// Concatenated latest bit-stream version.
+static constexpr uint16_t kDracoPointCloudBitstreamVersion =
+    DRACO_BITSTREAM_VERSION(kDracoPointCloudBitstreamVersionMajor,
+                            kDracoPointCloudBitstreamVersionMinor);
+
+static constexpr uint16_t kDracoMeshBitstreamVersion = DRACO_BITSTREAM_VERSION(
+    kDracoMeshBitstreamVersionMajor, kDracoMeshBitstreamVersionMinor);
+
+// Currently, we support point cloud and triangular mesh encoding.
+// TODO(draco-eng) Convert enum to enum class (safety, not performance).
+enum EncodedGeometryType {
+  INVALID_GEOMETRY_TYPE = -1,
+  POINT_CLOUD = 0,
+  TRIANGULAR_MESH,
+  NUM_ENCODED_GEOMETRY_TYPES
+};
+
+// List of encoding methods for point clouds.
+enum PointCloudEncodingMethod {
+  POINT_CLOUD_SEQUENTIAL_ENCODING = 0,
+  POINT_CLOUD_KD_TREE_ENCODING
+};
+
+// List of encoding methods for meshes.
+enum MeshEncoderMethod {
+  MESH_SEQUENTIAL_ENCODING = 0,
+  MESH_EDGEBREAKER_ENCODING,
+};
+
+// List of various attribute encoders supported by our framework. The entries
+// are used as unique identifiers of the encoders and their values should not
+// be changed!
+enum AttributeEncoderType {
+  BASIC_ATTRIBUTE_ENCODER = 0,
+  MESH_TRAVERSAL_ATTRIBUTE_ENCODER,
+  KD_TREE_ATTRIBUTE_ENCODER,
+};
+
+// List of various sequential attribute encoder/decoders that can be used in our
+// pipeline. The values represent unique identifiers used by the decoder and
+// they should not be changed.
+enum SequentialAttributeEncoderType {
+  SEQUENTIAL_ATTRIBUTE_ENCODER_GENERIC = 0,
+  SEQUENTIAL_ATTRIBUTE_ENCODER_INTEGER,
+  SEQUENTIAL_ATTRIBUTE_ENCODER_QUANTIZATION,
+  SEQUENTIAL_ATTRIBUTE_ENCODER_NORMALS,
+};
+
+// List of all prediction methods currently supported by our framework.
+enum PredictionSchemeMethod {
+  // Special value indicating that no prediction scheme was used.
+  PREDICTION_NONE = -2,
+  // Used when no specific prediction scheme is required.
+  PREDICTION_UNDEFINED = -1,
+  PREDICTION_DIFFERENCE = 0,
+  MESH_PREDICTION_PARALLELOGRAM = 1,
+  MESH_PREDICTION_MULTI_PARALLELOGRAM = 2,
+  MESH_PREDICTION_TEX_COORDS_DEPRECATED = 3,
+  MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM = 4,
+  MESH_PREDICTION_TEX_COORDS_PORTABLE = 5,
+  MESH_PREDICTION_GEOMETRIC_NORMAL = 6,
+  NUM_PREDICTION_SCHEMES
+};
+
+// List of all prediction scheme transforms used by our framework.
+enum PredictionSchemeTransformType {
+  PREDICTION_TRANSFORM_NONE = -1,
+  // Basic delta transform where the prediction is computed as difference the
+  // predicted and original value.
+  PREDICTION_TRANSFORM_DELTA = 0,
+  // An improved delta transform where all computed delta values are wrapped
+  // around a fixed interval which lowers the entropy.
+  PREDICTION_TRANSFORM_WRAP = 1,
+  // Specialized transform for normal coordinates using inverted tiles.
+  PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON = 2,
+  // Specialized transform for normal coordinates using canonicalized inverted
+  // tiles.
+  PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON_CANONICALIZED = 3,
+  // The number of valid (non-negative) prediction scheme transform types.
+  NUM_PREDICTION_SCHEME_TRANSFORM_TYPES
+};
+
+// List of all mesh traversal methods supported by Draco framework.
+enum MeshTraversalMethod {
+  MESH_TRAVERSAL_DEPTH_FIRST = 0,
+  MESH_TRAVERSAL_PREDICTION_DEGREE = 1,
+  NUM_TRAVERSAL_METHODS
+};
+
+// List of all variant of the edgebreaker method that is used for compression
+// of mesh connectivity.
+enum MeshEdgebreakerConnectivityEncodingMethod {
+  MESH_EDGEBREAKER_STANDARD_ENCODING = 0,
+  MESH_EDGEBREAKER_PREDICTIVE_ENCODING = 1,  // Deprecated.
+  MESH_EDGEBREAKER_VALENCE_ENCODING = 2,
+};
+
+// Draco header V1
+struct DracoHeader {
+  int8_t draco_string[5];
+  uint8_t version_major;
+  uint8_t version_minor;
+  uint8_t encoder_type;
+  uint8_t encoder_method;
+  uint16_t flags;
+};
+
+enum NormalPredictionMode {
+  ONE_TRIANGLE = 0,  // To be deprecated.
+  TRIANGLE_AREA = 1,
+};
+
+// Different methods used for symbol entropy encoding.
+enum SymbolCodingMethod {
+  SYMBOL_CODING_TAGGED = 0,
+  SYMBOL_CODING_RAW = 1,
+  NUM_SYMBOL_CODING_METHODS,
+};
+
+// Mask for setting and getting the bit for metadata in |flags| of header.
+#define METADATA_FLAG_MASK 0x8000
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_CONFIG_COMPRESSION_SHARED_H_
diff --git a/engine/inc/draco/compression/config/decoder_options.h b/engine/inc/draco/compression/config/decoder_options.h
new file mode 100644
index 00000000..3b388999
--- /dev/null
+++ b/engine/inc/draco/compression/config/decoder_options.h
@@ -0,0 +1,34 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_CONFIG_DECODER_OPTIONS_H_
+#define DRACO_COMPRESSION_CONFIG_DECODER_OPTIONS_H_
+
+#include <map>
+#include <memory>
+
+#include "draco/attributes/geometry_attribute.h"
+#include "draco/compression/config/draco_options.h"
+
+namespace draco {
+
+// Class containing options that can be passed to PointCloudDecoder to control
+// decoding of the input geometry. The options can be specified either for the
+// whole geometry or for a specific attribute type. Each option is identified
+// by a unique name stored as an std::string.
+typedef DracoOptions<GeometryAttribute::Type> DecoderOptions;
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_CONFIG_DECODER_OPTIONS_H_
diff --git a/engine/inc/draco/compression/config/draco_options.h b/engine/inc/draco/compression/config/draco_options.h
new file mode 100644
index 00000000..2bd4a3b6
--- /dev/null
+++ b/engine/inc/draco/compression/config/draco_options.h
@@ -0,0 +1,249 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_CONFIG_DRACO_OPTIONS_H_
+#define DRACO_COMPRESSION_CONFIG_DRACO_OPTIONS_H_
+
+#include <map>
+#include <memory>
+
+#include "draco/core/options.h"
+
+namespace draco {
+
+// Base option class used to control encoding and decoding. The geometry coding
+// can be controlled through the following options:
+//   1. Global options - Options specific to overall geometry or options common
+//                       for all attributes
+//   2. Per attribute options - Options specific to a given attribute.
+//                              Each attribute is identified by the template
+//                              argument AttributeKeyT that can be for example
+//                              the attribute type or the attribute id.
+//
+// Example:
+//
+//   DracoOptions<AttributeKey> options;
+//
+//   // Set an option common for all attributes.
+//   options.SetGlobalInt("some_option_name", 2);
+//
+//   // Geometry with two attributes.
+//   AttributeKey att_key0 = in_key0;
+//   AttributeKey att_key1 = in_key1;
+//
+//   options.SetAttributeInt(att_key0, "some_option_name", 3);
+//
+//   options.GetAttributeInt(att_key0, "some_option_name");  // Returns 3
+//   options.GetAttributeInt(att_key1, "some_option_name");  // Returns 2
+//   options.GetGlobalInt("some_option_name");               // Returns 2
+//
+template <typename AttributeKeyT>
+class DracoOptions {
+ public:
+  typedef AttributeKeyT AttributeKey;
+
+  // Get an option for a specific attribute key. If the option is not found in
+  // an attribute specific storage, the implementation will return a global
+  // option of the given name (if available). If the option is not found, the
+  // provided default value |default_val| is returned instead.
+  int GetAttributeInt(const AttributeKey &att_key, const std::string &name,
+                      int default_val) const;
+
+  // Sets an option for a specific attribute key.
+  void SetAttributeInt(const AttributeKey &att_key, const std::string &name,
+                       int val);
+
+  float GetAttributeFloat(const AttributeKey &att_key, const std::string &name,
+                          float default_val) const;
+  void SetAttributeFloat(const AttributeKey &att_key, const std::string &name,
+                         float val);
+  bool GetAttributeBool(const AttributeKey &att_key, const std::string &name,
+                        bool default_val) const;
+  void SetAttributeBool(const AttributeKey &att_key, const std::string &name,
+                        bool val);
+  template <typename DataTypeT>
+  bool GetAttributeVector(const AttributeKey &att_key, const std::string &name,
+                          int num_dims, DataTypeT *val) const;
+  template <typename DataTypeT>
+  void SetAttributeVector(const AttributeKey &att_key, const std::string &name,
+                          int num_dims, const DataTypeT *val);
+
+  bool IsAttributeOptionSet(const AttributeKey &att_key,
+                            const std::string &name) const;
+
+  // Gets/sets a global option that is not specific to any attribute.
+  int GetGlobalInt(const std::string &name, int default_val) const {
+    return global_options_.GetInt(name, default_val);
+  }
+  void SetGlobalInt(const std::string &name, int val) {
+    global_options_.SetInt(name, val);
+  }
+  float GetGlobalFloat(const std::string &name, float default_val) const {
+    return global_options_.GetFloat(name, default_val);
+  }
+  void SetGlobalFloat(const std::string &name, float val) {
+    global_options_.SetFloat(name, val);
+  }
+  bool GetGlobalBool(const std::string &name, bool default_val) const {
+    return global_options_.GetBool(name, default_val);
+  }
+  void SetGlobalBool(const std::string &name, bool val) {
+    global_options_.SetBool(name, val);
+  }
+  template <typename DataTypeT>
+  bool GetGlobalVector(const std::string &name, int num_dims,
+                       DataTypeT *val) const {
+    return global_options_.GetVector(name, num_dims, val);
+  }
+  template <typename DataTypeT>
+  void SetGlobalVector(const std::string &name, int num_dims,
+                       const DataTypeT *val) {
+    global_options_.SetVector(name, val, num_dims);
+  }
+  bool IsGlobalOptionSet(const std::string &name) const {
+    return global_options_.IsOptionSet(name);
+  }
+
+  // Sets or replaces attribute options with the provided |options|.
+  void SetAttributeOptions(const AttributeKey &att_key, const Options &options);
+  void SetGlobalOptions(const Options &options) { global_options_ = options; }
+
+  // Returns |Options| instance for the specified options class if it exists.
+  const Options *FindAttributeOptions(const AttributeKeyT &att_key) const;
+  const Options &GetGlobalOptions() const { return global_options_; }
+
+ private:
+  Options *GetAttributeOptions(const AttributeKeyT &att_key);
+
+  Options global_options_;
+
+  // Storage for options related to geometry attributes.
+  std::map<AttributeKey, Options> attribute_options_;
+};
+
+template <typename AttributeKeyT>
+const Options *DracoOptions<AttributeKeyT>::FindAttributeOptions(
+    const AttributeKeyT &att_key) const {
+  auto it = attribute_options_.find(att_key);
+  if (it == attribute_options_.end()) {
+    return nullptr;
+  }
+  return &it->second;
+}
+
+template <typename AttributeKeyT>
+Options *DracoOptions<AttributeKeyT>::GetAttributeOptions(
+    const AttributeKeyT &att_key) {
+  auto it = attribute_options_.find(att_key);
+  if (it != attribute_options_.end()) {
+    return &it->second;
+  }
+  Options new_options;
+  it = attribute_options_.insert(std::make_pair(att_key, new_options)).first;
+  return &it->second;
+}
+
+template <typename AttributeKeyT>
+int DracoOptions<AttributeKeyT>::GetAttributeInt(const AttributeKeyT &att_key,
+                                                 const std::string &name,
+                                                 int default_val) const {
+  const Options *const att_options = FindAttributeOptions(att_key);
+  if (att_options && att_options->IsOptionSet(name)) {
+    return att_options->GetInt(name, default_val);
+  }
+  return global_options_.GetInt(name, default_val);
+}
+
+template <typename AttributeKeyT>
+void DracoOptions<AttributeKeyT>::SetAttributeInt(const AttributeKeyT &att_key,
+                                                  const std::string &name,
+                                                  int val) {
+  GetAttributeOptions(att_key)->SetInt(name, val);
+}
+
+template <typename AttributeKeyT>
+float DracoOptions<AttributeKeyT>::GetAttributeFloat(
+    const AttributeKeyT &att_key, const std::string &name,
+    float default_val) const {
+  const Options *const att_options = FindAttributeOptions(att_key);
+  if (att_options && att_options->IsOptionSet(name)) {
+    return att_options->GetFloat(name, default_val);
+  }
+  return global_options_.GetFloat(name, default_val);
+}
+
+template <typename AttributeKeyT>
+void DracoOptions<AttributeKeyT>::SetAttributeFloat(
+    const AttributeKeyT &att_key, const std::string &name, float val) {
+  GetAttributeOptions(att_key)->SetFloat(name, val);
+}
+
+template <typename AttributeKeyT>
+bool DracoOptions<AttributeKeyT>::GetAttributeBool(const AttributeKeyT &att_key,
+                                                   const std::string &name,
+                                                   bool default_val) const {
+  const Options *const att_options = FindAttributeOptions(att_key);
+  if (att_options && att_options->IsOptionSet(name)) {
+    return att_options->GetBool(name, default_val);
+  }
+  return global_options_.GetBool(name, default_val);
+}
+
+template <typename AttributeKeyT>
+void DracoOptions<AttributeKeyT>::SetAttributeBool(const AttributeKeyT &att_key,
+                                                   const std::string &name,
+                                                   bool val) {
+  GetAttributeOptions(att_key)->SetBool(name, val);
+}
+
+template <typename AttributeKeyT>
+template <typename DataTypeT>
+bool DracoOptions<AttributeKeyT>::GetAttributeVector(
+    const AttributeKey &att_key, const std::string &name, int num_dims,
+    DataTypeT *val) const {
+  const Options *const att_options = FindAttributeOptions(att_key);
+  if (att_options && att_options->IsOptionSet(name)) {
+    return att_options->GetVector(name, num_dims, val);
+  }
+  return global_options_.GetVector(name, num_dims, val);
+}
+
+template <typename AttributeKeyT>
+template <typename DataTypeT>
+void DracoOptions<AttributeKeyT>::SetAttributeVector(
+    const AttributeKey &att_key, const std::string &name, int num_dims,
+    const DataTypeT *val) {
+  GetAttributeOptions(att_key)->SetVector(name, val, num_dims);
+}
+
+template <typename AttributeKeyT>
+bool DracoOptions<AttributeKeyT>::IsAttributeOptionSet(
+    const AttributeKey &att_key, const std::string &name) const {
+  const Options *const att_options = FindAttributeOptions(att_key);
+  if (att_options) {
+    return att_options->IsOptionSet(name);
+  }
+  return global_options_.IsOptionSet(name);
+}
+
+template <typename AttributeKeyT>
+void DracoOptions<AttributeKeyT>::SetAttributeOptions(
+    const AttributeKey &att_key, const Options &options) {
+  Options *att_options = GetAttributeOptions(att_key);
+  *att_options = options;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_CONFIG_DRACO_OPTIONS_H_
diff --git a/engine/inc/draco/compression/config/encoder_options.h b/engine/inc/draco/compression/config/encoder_options.h
new file mode 100644
index 00000000..ed1b0206
--- /dev/null
+++ b/engine/inc/draco/compression/config/encoder_options.h
@@ -0,0 +1,97 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_CONFIG_ENCODER_OPTIONS_H_
+#define DRACO_COMPRESSION_CONFIG_ENCODER_OPTIONS_H_
+
+#include "draco/attributes/geometry_attribute.h"
+#include "draco/compression/config/draco_options.h"
+#include "draco/compression/config/encoding_features.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// EncoderOptions allow users to specify so called feature options that are used
+// to inform the encoder which encoding features can be used (i.e. which
+// features are going to be available to the decoder).
+template <typename AttributeKeyT>
+class EncoderOptionsBase : public DracoOptions<AttributeKeyT> {
+ public:
+  static EncoderOptionsBase CreateDefaultOptions() {
+    EncoderOptionsBase options;
+#ifdef DRACO_STANDARD_EDGEBREAKER_SUPPORTED
+    options.SetSupportedFeature(features::kEdgebreaker, true);
+#endif
+#ifdef DRACO_PREDICTIVE_EDGEBREAKER_SUPPORTED
+    options.SetSupportedFeature(features::kPredictiveEdgebreaker, true);
+#endif
+    return options;
+  }
+  static EncoderOptionsBase CreateEmptyOptions() {
+    return EncoderOptionsBase();
+  }
+
+  // Returns speed options with default value of 5.
+  int GetEncodingSpeed() const {
+    return this->GetGlobalInt("encoding_speed", 5);
+  }
+  int GetDecodingSpeed() const {
+    return this->GetGlobalInt("decoding_speed", 5);
+  }
+
+  // Returns the maximum speed for both encoding/decoding.
+  int GetSpeed() const {
+    const int encoding_speed = this->GetGlobalInt("encoding_speed", -1);
+    const int decoding_speed = this->GetGlobalInt("decoding_speed", -1);
+    const int max_speed = std::max(encoding_speed, decoding_speed);
+    if (max_speed == -1) {
+      return 5;  // Default value.
+    }
+    return max_speed;
+  }
+
+  void SetSpeed(int encoding_speed, int decoding_speed) {
+    this->SetGlobalInt("encoding_speed", encoding_speed);
+    this->SetGlobalInt("decoding_speed", decoding_speed);
+  }
+
+  // Sets a given feature as supported or unsupported by the target decoder.
+  // Encoder will always use only supported features when encoding the input
+  // geometry.
+  void SetSupportedFeature(const std::string &name, bool supported) {
+    feature_options_.SetBool(name, supported);
+  }
+  bool IsFeatureSupported(const std::string &name) const {
+    return feature_options_.GetBool(name);
+  }
+
+  void SetFeatureOptions(const Options &options) { feature_options_ = options; }
+  const Options &GetFeaturelOptions() const { return feature_options_; }
+
+ private:
+  // Use helper methods to construct the encoder options.
+  // See CreateDefaultOptions();
+  EncoderOptionsBase() {}
+
+  // List of supported/unsupported features that can be used by the encoder.
+  Options feature_options_;
+};
+
+// Encoder options where attributes are identified by their attribute id.
+// Used to set options that are specific to a given geometry.
+typedef EncoderOptionsBase<int32_t> EncoderOptions;
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_CONFIG_ENCODER_OPTIONS_H_
diff --git a/engine/inc/draco/compression/config/encoding_features.h b/engine/inc/draco/compression/config/encoding_features.h
new file mode 100644
index 00000000..d6a8b712
--- /dev/null
+++ b/engine/inc/draco/compression/config/encoding_features.h
@@ -0,0 +1,39 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File provides helpful macros that define features available for encoding
+// the input of the input geometry. These macros can be used as an input in
+// the EncoderOptions::SetSupportedFeature() method instead of the text.
+// The most recent set of features supported
+// by the default implementation is:
+//
+// kEdgebreaker
+//     - edgebreaker method for encoding meshes.
+// kPredictiveEdgebreaker
+//     - advanced version of the edgebreaker method (slower but better
+//       compression).
+//
+#ifndef DRACO_COMPRESSION_CONFIG_ENCODING_FEATURES_H_
+#define DRACO_COMPRESSION_CONFIG_ENCODING_FEATURES_H_
+
+namespace draco {
+namespace features {
+
+constexpr const char *kEdgebreaker = "standard_edgebreaker";
+constexpr const char *kPredictiveEdgebreaker = "predictive_edgebreaker";
+
+}  // namespace features
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_CONFIG_ENCODING_FEATURES_H_
diff --git a/engine/inc/draco/compression/decode.h b/engine/inc/draco/compression/decode.h
new file mode 100644
index 00000000..5f3fad26
--- /dev/null
+++ b/engine/inc/draco/compression/decode.h
@@ -0,0 +1,80 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_DECODE_H_
+#define DRACO_COMPRESSION_DECODE_H_
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/config/decoder_options.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/status_or.h"
+#include "draco/draco_features.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Class responsible for decoding of meshes and point clouds that were
+// compressed by a Draco encoder.
+class Decoder {
+ public:
+  // Returns the geometry type encoded in the input |in_buffer|.
+  // The return value is one of POINT_CLOUD, MESH or INVALID_GEOMETRY in case
+  // the input data is invalid.
+  // The decoded geometry type can be used to choose an appropriate decoding
+  // function for a given geometry type (see below).
+  static StatusOr<EncodedGeometryType> GetEncodedGeometryType(
+      DecoderBuffer *in_buffer);
+
+  // Decodes point cloud from the provided buffer. The buffer must be filled
+  // with data that was encoded with either the EncodePointCloudToBuffer or
+  // EncodeMeshToBuffer methods in encode.h. In case the input buffer contains
+  // mesh, the returned instance can be down-casted to Mesh.
+  StatusOr<std::unique_ptr<PointCloud>> DecodePointCloudFromBuffer(
+      DecoderBuffer *in_buffer);
+
+  // Decodes a triangular mesh from the provided buffer. The mesh must be filled
+  // with data that was encoded using the EncodeMeshToBuffer method in encode.h.
+  // The function will return nullptr in case the input is invalid or if it was
+  // encoded with the EncodePointCloudToBuffer method.
+  StatusOr<std::unique_ptr<Mesh>> DecodeMeshFromBuffer(
+      DecoderBuffer *in_buffer);
+
+  // Decodes the buffer into a provided geometry. If the geometry is
+  // incompatible with the encoded data. For example, when |out_geometry| is
+  // draco::Mesh while the data contains a point cloud, the function will return
+  // an error status.
+  Status DecodeBufferToGeometry(DecoderBuffer *in_buffer,
+                                PointCloud *out_geometry);
+  Status DecodeBufferToGeometry(DecoderBuffer *in_buffer, Mesh *out_geometry);
+
+  // When set, the decoder is going to skip attribute transform for a given
+  // attribute type. For example for quantized attributes, the decoder would
+  // skip the dequantization step and the returned geometry would contain an
+  // attribute with quantized values. The attribute would also contain an
+  // instance of AttributeTransform class that is used to describe the skipped
+  // transform, including all parameters that are needed to perform the
+  // transform manually.
+  void SetSkipAttributeTransform(GeometryAttribute::Type att_type);
+
+  // Returns the options instance used by the decoder that can be used by users
+  // to control the decoding process.
+  DecoderOptions *options() { return &options_; }
+
+ private:
+  DecoderOptions options_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_DECODE_H_
diff --git a/engine/inc/draco/compression/encode.h b/engine/inc/draco/compression/encode.h
new file mode 100644
index 00000000..bce8b34c
--- /dev/null
+++ b/engine/inc/draco/compression/encode.h
@@ -0,0 +1,140 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ENCODE_H_
+#define DRACO_COMPRESSION_ENCODE_H_
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/config/encoder_options.h"
+#include "draco/compression/encode_base.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/core/status.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Basic helper class for encoding geometry using the Draco compression library.
+// The class provides various methods that can be used to control several common
+// options used during the encoding, such as the number of quantization bits for
+// a given attribute. All these options are defined per attribute type, i.e.,
+// if there are more attributes of the same type (such as multiple texture
+// coordinate attributes), the same options are going to be used for all of the
+// attributes of this type. If different attributes of the same type need to
+// use different options, use ExpertEncoder in expert_encode.h.
+class Encoder
+    : public EncoderBase<EncoderOptionsBase<GeometryAttribute::Type>> {
+ public:
+  typedef EncoderBase<EncoderOptionsBase<GeometryAttribute::Type>> Base;
+
+  Encoder();
+  virtual ~Encoder() {}
+
+  // Encodes a point cloud to the provided buffer.
+  virtual Status EncodePointCloudToBuffer(const PointCloud &pc,
+                                          EncoderBuffer *out_buffer);
+
+  // Encodes a mesh to the provided buffer.
+  virtual Status EncodeMeshToBuffer(const Mesh &m, EncoderBuffer *out_buffer);
+
+  // Set encoder options used during the geometry encoding. Note that this call
+  // overwrites any modifications to the options done with the functions below,
+  // i.e., it resets the encoder.
+  void Reset(const EncoderOptionsBase<GeometryAttribute::Type> &options);
+  void Reset();
+
+  // Sets the desired encoding and decoding speed for the given options.
+  //
+  //  0 = slowest speed, but the best compression.
+  // 10 = fastest, but the worst compression.
+  // -1 = undefined.
+  //
+  // Note that both speed options affect the encoder choice of used methods and
+  // algorithms. For example, a requirement for fast decoding may prevent the
+  // encoder from using the best compression methods even if the encoding speed
+  // is set to 0. In general, the faster of the two options limits the choice of
+  // features that can be used by the encoder. Additionally, setting
+  // |decoding_speed| to be faster than the |encoding_speed| may allow the
+  // encoder to choose the optimal method out of the available features for the
+  // given |decoding_speed|.
+  void SetSpeedOptions(int encoding_speed, int decoding_speed);
+
+  // Sets the quantization compression options for a named attribute. The
+  // attribute values will be quantized in a box defined by the maximum extent
+  // of the attribute values. I.e., the actual precision of this option depends
+  // on the scale of the attribute values.
+  void SetAttributeQuantization(GeometryAttribute::Type type,
+                                int quantization_bits);
+
+  // Sets the explicit quantization compression for a named attribute. The
+  // attribute values will be quantized in a coordinate system defined by the
+  // provided origin and range (the input values should be within interval:
+  // <origin, origin + range>).
+  void SetAttributeExplicitQuantization(GeometryAttribute::Type type,
+                                        int quantization_bits, int num_dims,
+                                        const float *origin, float range);
+
+  // Sets the desired prediction method for a given attribute. By default,
+  // prediction scheme is selected automatically by the encoder using other
+  // provided options (such as speed) and input geometry type (mesh, point
+  // cloud). This function should be called only when a specific prediction is
+  // preferred (e.g., when it is known that the encoder would select a less
+  // optimal prediction for the given input data).
+  //
+  // |prediction_scheme_method| should be one of the entries defined in
+  // compression/config/compression_shared.h :
+  //
+  //   PREDICTION_NONE - use no prediction.
+  //   PREDICTION_DIFFERENCE - delta coding
+  //   MESH_PREDICTION_PARALLELOGRAM - parallelogram prediction for meshes.
+  //   MESH_PREDICTION_CONSTRAINED_PARALLELOGRAM
+  //      - better and more costly version of the parallelogram prediction.
+  //   MESH_PREDICTION_TEX_COORDS_PORTABLE
+  //      - specialized predictor for tex coordinates.
+  //   MESH_PREDICTION_GEOMETRIC_NORMAL
+  //      - specialized predictor for normal coordinates.
+  //
+  // Note that in case the desired prediction cannot be used, the default
+  // prediction will be automatically used instead.
+  Status SetAttributePredictionScheme(GeometryAttribute::Type type,
+                                      int prediction_scheme_method);
+
+  // Sets the desired encoding method for a given geometry. By default, encoding
+  // method is selected based on the properties of the input geometry and based
+  // on the other options selected in the used EncoderOptions (such as desired
+  // encoding and decoding speed). This function should be called only when a
+  // specific method is required.
+  //
+  // |encoding_method| can be one of the values defined in
+  // compression/config/compression_shared.h based on the type of the input
+  // geometry that is going to be encoded. For point clouds, allowed entries are
+  //   POINT_CLOUD_SEQUENTIAL_ENCODING
+  //   POINT_CLOUD_KD_TREE_ENCODING
+  //
+  // For meshes the input can be
+  //   MESH_SEQUENTIAL_ENCODING
+  //   MESH_EDGEBREAKER_ENCODING
+  //
+  // If the selected method cannot be used for the given input, the subsequent
+  // call of EncodePointCloudToBuffer or EncodeMeshToBuffer is going to fail.
+  void SetEncodingMethod(int encoding_method);
+
+ protected:
+  // Creates encoder options for the expert encoder used during the actual
+  // encoding.
+  EncoderOptions CreateExpertEncoderOptions(const PointCloud &pc) const;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ENCODE_H_
diff --git a/engine/inc/draco/compression/encode_base.h b/engine/inc/draco/compression/encode_base.h
new file mode 100644
index 00000000..c501bc4f
--- /dev/null
+++ b/engine/inc/draco/compression/encode_base.h
@@ -0,0 +1,131 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ENCODE_BASE_H_
+#define DRACO_COMPRESSION_ENCODE_BASE_H_
+
+#include "draco/attributes/geometry_attribute.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/core/status.h"
+
+namespace draco {
+
+// Base class for our geometry encoder classes. |EncoderOptionsT| specifies
+// options class used by the encoder. Please, see encode.h and expert_encode.h
+// for more details and method descriptions.
+template <class EncoderOptionsT>
+class EncoderBase {
+ public:
+  typedef EncoderOptionsT OptionsType;
+
+  EncoderBase()
+      : options_(EncoderOptionsT::CreateDefaultOptions()),
+        num_encoded_points_(0),
+        num_encoded_faces_(0) {}
+  virtual ~EncoderBase() {}
+
+  const EncoderOptionsT &options() const { return options_; }
+  EncoderOptionsT &options() { return options_; }
+
+  // If enabled, it tells the encoder to keep track of the number of encoded
+  // points and faces (default = false).
+  // Note that this can slow down encoding for certain encoders.
+  void SetTrackEncodedProperties(bool flag);
+
+  // Returns the number of encoded points and faces during the last encoding
+  // operation. Returns 0 if SetTrackEncodedProperties() was not set.
+  size_t num_encoded_points() const { return num_encoded_points_; }
+  size_t num_encoded_faces() const { return num_encoded_faces_; }
+
+ protected:
+  void Reset(const EncoderOptionsT &options) { options_ = options; }
+
+  void Reset() { options_ = EncoderOptionsT::CreateDefaultOptions(); }
+
+  void SetSpeedOptions(int encoding_speed, int decoding_speed) {
+    options_.SetSpeed(encoding_speed, decoding_speed);
+  }
+
+  void SetEncodingMethod(int encoding_method) {
+    options_.SetGlobalInt("encoding_method", encoding_method);
+  }
+
+  void SetEncodingSubmethod(int encoding_submethod) {
+    options_.SetGlobalInt("encoding_submethod", encoding_submethod);
+  }
+
+  Status CheckPredictionScheme(GeometryAttribute::Type att_type,
+                               int prediction_scheme) const {
+    // Out of bound checks:
+    if (prediction_scheme < PREDICTION_NONE) {
+      return Status(Status::DRACO_ERROR,
+                    "Invalid prediction scheme requested.");
+    }
+    if (prediction_scheme >= NUM_PREDICTION_SCHEMES) {
+      return Status(Status::DRACO_ERROR,
+                    "Invalid prediction scheme requested.");
+    }
+    // Deprecated prediction schemes:
+    if (prediction_scheme == MESH_PREDICTION_TEX_COORDS_DEPRECATED) {
+      return Status(Status::DRACO_ERROR,
+                    "MESH_PREDICTION_TEX_COORDS_DEPRECATED is deprecated.");
+    }
+    if (prediction_scheme == MESH_PREDICTION_MULTI_PARALLELOGRAM) {
+      return Status(Status::DRACO_ERROR,
+                    "MESH_PREDICTION_MULTI_PARALLELOGRAM is deprecated.");
+    }
+    // Attribute specific checks:
+    if (prediction_scheme == MESH_PREDICTION_TEX_COORDS_PORTABLE) {
+      if (att_type != GeometryAttribute::TEX_COORD) {
+        return Status(Status::DRACO_ERROR,
+                      "Invalid prediction scheme for attribute type.");
+      }
+    }
+    if (prediction_scheme == MESH_PREDICTION_GEOMETRIC_NORMAL) {
+      if (att_type != GeometryAttribute::NORMAL) {
+        return Status(Status::DRACO_ERROR,
+                      "Invalid prediction scheme for attribute type.");
+      }
+    }
+    // TODO(hemmer): Try to enable more prediction schemes for normals.
+    if (att_type == GeometryAttribute::NORMAL) {
+      if (!(prediction_scheme == PREDICTION_DIFFERENCE ||
+            prediction_scheme == MESH_PREDICTION_GEOMETRIC_NORMAL)) {
+        return Status(Status::DRACO_ERROR,
+                      "Invalid prediction scheme for attribute type.");
+      }
+    }
+    return OkStatus();
+  }
+
+ protected:
+  void set_num_encoded_points(size_t num) { num_encoded_points_ = num; }
+  void set_num_encoded_faces(size_t num) { num_encoded_faces_ = num; }
+
+ private:
+  EncoderOptionsT options_;
+
+  size_t num_encoded_points_;
+  size_t num_encoded_faces_;
+};
+
+template <class EncoderOptionsT>
+void EncoderBase<EncoderOptionsT>::SetTrackEncodedProperties(bool flag) {
+  options_.SetGlobalBool("store_number_of_encoded_points", flag);
+  options_.SetGlobalBool("store_number_of_encoded_faces", flag);
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ENCODE_BASE_H_
diff --git a/engine/inc/draco/compression/entropy/ans.h b/engine/inc/draco/compression/entropy/ans.h
new file mode 100644
index 00000000..c71d5897
--- /dev/null
+++ b/engine/inc/draco/compression/entropy/ans.h
@@ -0,0 +1,527 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ENTROPY_ANS_H_
+#define DRACO_COMPRESSION_ENTROPY_ANS_H_
+// An implementation of Asymmetric Numeral Systems (rANS).
+// See http://arxiv.org/abs/1311.2540v2 for more information on rANS.
+// This file is based off libvpx's ans.h.
+
+#include <vector>
+
+#define DRACO_ANS_DIVIDE_BY_MULTIPLY 1
+#if DRACO_ANS_DIVIDE_BY_MULTIPLY
+#include "draco/core/divide.h"
+#endif
+#include "draco/core/macros.h"
+
+namespace draco {
+
+#if DRACO_ANS_DIVIDE_BY_MULTIPLY
+
+#define DRACO_ANS_DIVREM(quotient, remainder, dividend, divisor) \
+  do {                                                           \
+    quotient = fastdiv(dividend, divisor);                       \
+    remainder = dividend - quotient * divisor;                   \
+  } while (0)
+#define DRACO_ANS_DIV(dividend, divisor) fastdiv(dividend, divisor)
+#else
+#define DRACO_ANS_DIVREM(quotient, remainder, dividend, divisor) \
+  do {                                                           \
+    quotient = dividend / divisor;                               \
+    remainder = dividend % divisor;                              \
+  } while (0)
+#define DRACO_ANS_DIV(dividend, divisor) ((dividend) / (divisor))
+#endif
+
+struct AnsCoder {
+  AnsCoder() : buf(nullptr), buf_offset(0), state(0) {}
+  uint8_t *buf;
+  int buf_offset;
+  uint32_t state;
+};
+
+struct AnsDecoder {
+  AnsDecoder() : buf(nullptr), buf_offset(0), state(0) {}
+  const uint8_t *buf;
+  int buf_offset;
+  uint32_t state;
+};
+
+typedef uint8_t AnsP8;
+#define DRACO_ANS_P8_PRECISION 256u
+#define DRACO_ANS_L_BASE (4096u)
+#define DRACO_ANS_IO_BASE 256
+
+static uint32_t mem_get_le16(const void *vmem) {
+  uint32_t val;
+  const uint8_t *mem = (const uint8_t *)vmem;
+
+  val = mem[1] << 8;
+  val |= mem[0];
+  return val;
+}
+
+static uint32_t mem_get_le24(const void *vmem) {
+  uint32_t val;
+  const uint8_t *mem = (const uint8_t *)vmem;
+
+  val = mem[2] << 16;
+  val |= mem[1] << 8;
+  val |= mem[0];
+  return val;
+}
+
+static inline uint32_t mem_get_le32(const void *vmem) {
+  uint32_t val;
+  const uint8_t *mem = (const uint8_t *)vmem;
+
+  val = mem[3] << 24;
+  val |= mem[2] << 16;
+  val |= mem[1] << 8;
+  val |= mem[0];
+  return val;
+}
+
+static inline void mem_put_le16(void *vmem, uint32_t val) {
+  uint8_t *mem = reinterpret_cast<uint8_t *>(vmem);
+
+  mem[0] = (val >> 0) & 0xff;
+  mem[1] = (val >> 8) & 0xff;
+}
+
+static inline void mem_put_le24(void *vmem, uint32_t val) {
+  uint8_t *mem = reinterpret_cast<uint8_t *>(vmem);
+
+  mem[0] = (val >> 0) & 0xff;
+  mem[1] = (val >> 8) & 0xff;
+  mem[2] = (val >> 16) & 0xff;
+}
+
+static inline void mem_put_le32(void *vmem, uint32_t val) {
+  uint8_t *mem = reinterpret_cast<uint8_t *>(vmem);
+
+  mem[0] = (val >> 0) & 0xff;
+  mem[1] = (val >> 8) & 0xff;
+  mem[2] = (val >> 16) & 0xff;
+  mem[3] = (val >> 24) & 0xff;
+}
+
+static inline void ans_write_init(struct AnsCoder *const ans,
+                                  uint8_t *const buf) {
+  ans->buf = buf;
+  ans->buf_offset = 0;
+  ans->state = DRACO_ANS_L_BASE;
+}
+
+static inline int ans_write_end(struct AnsCoder *const ans) {
+  uint32_t state;
+  DRACO_DCHECK_GE(ans->state, DRACO_ANS_L_BASE);
+  DRACO_DCHECK_LT(ans->state, DRACO_ANS_L_BASE * DRACO_ANS_IO_BASE);
+  state = ans->state - DRACO_ANS_L_BASE;
+  if (state < (1 << 6)) {
+    ans->buf[ans->buf_offset] = (0x00 << 6) + state;
+    return ans->buf_offset + 1;
+  } else if (state < (1 << 14)) {
+    mem_put_le16(ans->buf + ans->buf_offset, (0x01 << 14) + state);
+    return ans->buf_offset + 2;
+  } else if (state < (1 << 22)) {
+    mem_put_le24(ans->buf + ans->buf_offset, (0x02 << 22) + state);
+    return ans->buf_offset + 3;
+  } else {
+    DRACO_DCHECK(0 && "State is too large to be serialized");
+    return ans->buf_offset;
+  }
+}
+
+// rABS with descending spread.
+// p or p0 takes the place of l_s from the paper.
+// DRACO_ANS_P8_PRECISION is m.
+static inline void rabs_desc_write(struct AnsCoder *ans, int val, AnsP8 p0) {
+  const AnsP8 p = DRACO_ANS_P8_PRECISION - p0;
+  const unsigned l_s = val ? p : p0;
+  unsigned quot, rem;
+  if (ans->state >=
+      DRACO_ANS_L_BASE / DRACO_ANS_P8_PRECISION * DRACO_ANS_IO_BASE * l_s) {
+    ans->buf[ans->buf_offset++] = ans->state % DRACO_ANS_IO_BASE;
+    ans->state /= DRACO_ANS_IO_BASE;
+  }
+  DRACO_ANS_DIVREM(quot, rem, ans->state, l_s);
+  ans->state = quot * DRACO_ANS_P8_PRECISION + rem + (val ? 0 : p);
+}
+
+#define DRACO_ANS_IMPL1 0
+#define UNPREDICTABLE(x) x
+static inline int rabs_desc_read(struct AnsDecoder *ans, AnsP8 p0) {
+  int val;
+#if DRACO_ANS_IMPL1
+  unsigned l_s;
+#else
+  unsigned quot, rem, x, xn;
+#endif
+  const AnsP8 p = DRACO_ANS_P8_PRECISION - p0;
+  if (ans->state < DRACO_ANS_L_BASE && ans->buf_offset > 0) {
+    ans->state = ans->state * DRACO_ANS_IO_BASE + ans->buf[--ans->buf_offset];
+  }
+#if DRACO_ANS_IMPL1
+  val = ans->state % DRACO_ANS_P8_PRECISION < p;
+  l_s = val ? p : p0;
+  ans->state = (ans->state / DRACO_ANS_P8_PRECISION) * l_s +
+               ans->state % DRACO_ANS_P8_PRECISION - (!val * p);
+#else
+  x = ans->state;
+  quot = x / DRACO_ANS_P8_PRECISION;
+  rem = x % DRACO_ANS_P8_PRECISION;
+  xn = quot * p;
+  val = rem < p;
+  if (UNPREDICTABLE(val)) {
+    ans->state = xn + rem;
+  } else {
+    // ans->state = quot * p0 + rem - p;
+    ans->state = x - xn - p;
+  }
+#endif
+  return val;
+}
+
+// rABS with ascending spread.
+// p or p0 takes the place of l_s from the paper.
+// DRACO_ANS_P8_PRECISION is m.
+static inline void rabs_asc_write(struct AnsCoder *ans, int val, AnsP8 p0) {
+  const AnsP8 p = DRACO_ANS_P8_PRECISION - p0;
+  const unsigned l_s = val ? p : p0;
+  unsigned quot, rem;
+  if (ans->state >=
+      DRACO_ANS_L_BASE / DRACO_ANS_P8_PRECISION * DRACO_ANS_IO_BASE * l_s) {
+    ans->buf[ans->buf_offset++] = ans->state % DRACO_ANS_IO_BASE;
+    ans->state /= DRACO_ANS_IO_BASE;
+  }
+  DRACO_ANS_DIVREM(quot, rem, ans->state, l_s);
+  ans->state = quot * DRACO_ANS_P8_PRECISION + rem + (val ? p0 : 0);
+}
+
+static inline int rabs_asc_read(struct AnsDecoder *ans, AnsP8 p0) {
+  int val;
+#if DRACO_ANS_IMPL1
+  unsigned l_s;
+#else
+  unsigned quot, rem, x, xn;
+#endif
+  const AnsP8 p = DRACO_ANS_P8_PRECISION - p0;
+  if (ans->state < DRACO_ANS_L_BASE) {
+    ans->state = ans->state * DRACO_ANS_IO_BASE + ans->buf[--ans->buf_offset];
+  }
+#if DRACO_ANS_IMPL1
+  val = ans->state % DRACO_ANS_P8_PRECISION < p;
+  l_s = val ? p : p0;
+  ans->state = (ans->state / DRACO_ANS_P8_PRECISION) * l_s +
+               ans->state % DRACO_ANS_P8_PRECISION - (!val * p);
+#else
+  x = ans->state;
+  quot = x / DRACO_ANS_P8_PRECISION;
+  rem = x % DRACO_ANS_P8_PRECISION;
+  xn = quot * p;
+  val = rem >= p0;
+  if (UNPREDICTABLE(val)) {
+    ans->state = xn + rem - p0;
+  } else {
+    // ans->state = quot * p0 + rem - p0;
+    ans->state = x - xn;
+  }
+#endif
+  return val;
+}
+
+#define rabs_read rabs_desc_read
+#define rabs_write rabs_desc_write
+
+// uABS with normalization.
+static inline void uabs_write(struct AnsCoder *ans, int val, AnsP8 p0) {
+  AnsP8 p = DRACO_ANS_P8_PRECISION - p0;
+  const unsigned l_s = val ? p : p0;
+  while (ans->state >=
+         DRACO_ANS_L_BASE / DRACO_ANS_P8_PRECISION * DRACO_ANS_IO_BASE * l_s) {
+    ans->buf[ans->buf_offset++] = ans->state % DRACO_ANS_IO_BASE;
+    ans->state /= DRACO_ANS_IO_BASE;
+  }
+  if (!val) {
+    ans->state = DRACO_ANS_DIV(ans->state * DRACO_ANS_P8_PRECISION, p0);
+  } else {
+    ans->state =
+        DRACO_ANS_DIV((ans->state + 1) * DRACO_ANS_P8_PRECISION + p - 1, p) - 1;
+  }
+}
+
+static inline int uabs_read(struct AnsDecoder *ans, AnsP8 p0) {
+  AnsP8 p = DRACO_ANS_P8_PRECISION - p0;
+  int s;
+  // unsigned int xp1;
+  unsigned xp, sp;
+  unsigned state = ans->state;
+  while (state < DRACO_ANS_L_BASE && ans->buf_offset > 0) {
+    state = state * DRACO_ANS_IO_BASE + ans->buf[--ans->buf_offset];
+  }
+  sp = state * p;
+  // xp1 = (sp + p) / DRACO_ANS_P8_PRECISION;
+  xp = sp / DRACO_ANS_P8_PRECISION;
+  // s = xp1 - xp;
+  s = (sp & 0xFF) >= p0;
+  if (UNPREDICTABLE(s)) {
+    ans->state = xp;
+  } else {
+    ans->state = state - xp;
+  }
+  return s;
+}
+
+static inline int uabs_read_bit(struct AnsDecoder *ans) {
+  int s;
+  unsigned state = ans->state;
+  while (state < DRACO_ANS_L_BASE && ans->buf_offset > 0) {
+    state = state * DRACO_ANS_IO_BASE + ans->buf[--ans->buf_offset];
+  }
+  s = static_cast<int>(state & 1);
+  ans->state = state >> 1;
+  return s;
+}
+
+static inline int ans_read_init(struct AnsDecoder *const ans,
+                                const uint8_t *const buf, int offset) {
+  unsigned x;
+  if (offset < 1) {
+    return 1;
+  }
+  ans->buf = buf;
+  x = buf[offset - 1] >> 6;
+  if (x == 0) {
+    ans->buf_offset = offset - 1;
+    ans->state = buf[offset - 1] & 0x3F;
+  } else if (x == 1) {
+    if (offset < 2) {
+      return 1;
+    }
+    ans->buf_offset = offset - 2;
+    ans->state = mem_get_le16(buf + offset - 2) & 0x3FFF;
+  } else if (x == 2) {
+    if (offset < 3) {
+      return 1;
+    }
+    ans->buf_offset = offset - 3;
+    ans->state = mem_get_le24(buf + offset - 3) & 0x3FFFFF;
+  } else {
+    return 1;
+  }
+  ans->state += DRACO_ANS_L_BASE;
+  if (ans->state >= DRACO_ANS_L_BASE * DRACO_ANS_IO_BASE) {
+    return 1;
+  }
+  return 0;
+}
+
+static inline int ans_read_end(struct AnsDecoder *const ans) {
+  return ans->state == DRACO_ANS_L_BASE;
+}
+
+static inline int ans_reader_has_error(const struct AnsDecoder *const ans) {
+  return ans->state < DRACO_ANS_L_BASE && ans->buf_offset == 0;
+}
+
+struct rans_sym {
+  uint32_t prob;
+  uint32_t cum_prob;  // not-inclusive.
+};
+
+// Class for performing rANS encoding using a desired number of precision bits.
+// The max number of precision bits is currently 19. The actual number of
+// symbols in the input alphabet should be (much) smaller than that, otherwise
+// the compression rate may suffer.
+template <int rans_precision_bits_t>
+class RAnsEncoder {
+ public:
+  RAnsEncoder() {}
+
+  // Provides the input buffer where the data is going to be stored.
+  inline void write_init(uint8_t *const buf) {
+    ans_.buf = buf;
+    ans_.buf_offset = 0;
+    ans_.state = l_rans_base;
+  }
+
+  // Needs to be called after all symbols are encoded.
+  inline int write_end() {
+    uint32_t state;
+    DRACO_DCHECK_GE(ans_.state, l_rans_base);
+    DRACO_DCHECK_LT(ans_.state, l_rans_base * DRACO_ANS_IO_BASE);
+    state = ans_.state - l_rans_base;
+    if (state < (1 << 6)) {
+      ans_.buf[ans_.buf_offset] = (0x00 << 6) + state;
+      return ans_.buf_offset + 1;
+    } else if (state < (1 << 14)) {
+      mem_put_le16(ans_.buf + ans_.buf_offset, (0x01 << 14) + state);
+      return ans_.buf_offset + 2;
+    } else if (state < (1 << 22)) {
+      mem_put_le24(ans_.buf + ans_.buf_offset, (0x02 << 22) + state);
+      return ans_.buf_offset + 3;
+    } else if (state < (1 << 30)) {
+      mem_put_le32(ans_.buf + ans_.buf_offset, (0x03u << 30u) + state);
+      return ans_.buf_offset + 4;
+    } else {
+      DRACO_DCHECK(0 && "State is too large to be serialized");
+      return ans_.buf_offset;
+    }
+  }
+
+  // rANS with normalization.
+  // sym->prob takes the place of l_s from the paper.
+  // rans_precision is m.
+  inline void rans_write(const struct rans_sym *const sym) {
+    const uint32_t p = sym->prob;
+    while (ans_.state >= l_rans_base / rans_precision * DRACO_ANS_IO_BASE * p) {
+      ans_.buf[ans_.buf_offset++] = ans_.state % DRACO_ANS_IO_BASE;
+      ans_.state /= DRACO_ANS_IO_BASE;
+    }
+    // TODO(ostava): The division and multiplication should be optimized.
+    ans_.state =
+        (ans_.state / p) * rans_precision + ans_.state % p + sym->cum_prob;
+  }
+
+ private:
+  static constexpr int rans_precision = 1 << rans_precision_bits_t;
+  static constexpr int l_rans_base = rans_precision * 4;
+  AnsCoder ans_;
+};
+
+struct rans_dec_sym {
+  uint32_t val;
+  uint32_t prob;
+  uint32_t cum_prob;  // not-inclusive.
+};
+
+// Class for performing rANS decoding using a desired number of precision bits.
+// The number of precision bits needs to be the same as with the RAnsEncoder
+// that was used to encode the input data.
+template <int rans_precision_bits_t>
+class RAnsDecoder {
+ public:
+  RAnsDecoder() {}
+
+  // Initializes the decoder from the input buffer. The |offset| specifies the
+  // number of bytes encoded by the encoder. A non zero return value is an
+  // error.
+  inline int read_init(const uint8_t *const buf, int offset) {
+    unsigned x;
+    if (offset < 1) {
+      return 1;
+    }
+    ans_.buf = buf;
+    x = buf[offset - 1] >> 6;
+    if (x == 0) {
+      ans_.buf_offset = offset - 1;
+      ans_.state = buf[offset - 1] & 0x3F;
+    } else if (x == 1) {
+      if (offset < 2) {
+        return 1;
+      }
+      ans_.buf_offset = offset - 2;
+      ans_.state = mem_get_le16(buf + offset - 2) & 0x3FFF;
+    } else if (x == 2) {
+      if (offset < 3) {
+        return 1;
+      }
+      ans_.buf_offset = offset - 3;
+      ans_.state = mem_get_le24(buf + offset - 3) & 0x3FFFFF;
+    } else if (x == 3) {
+      ans_.buf_offset = offset - 4;
+      ans_.state = mem_get_le32(buf + offset - 4) & 0x3FFFFFFF;
+    } else {
+      return 1;
+    }
+    ans_.state += l_rans_base;
+    if (ans_.state >= l_rans_base * DRACO_ANS_IO_BASE) {
+      return 1;
+    }
+    return 0;
+  }
+
+  inline int read_end() { return ans_.state == l_rans_base; }
+
+  inline int reader_has_error() {
+    return ans_.state < l_rans_base && ans_.buf_offset == 0;
+  }
+
+  inline int rans_read() {
+    unsigned rem;
+    unsigned quo;
+    struct rans_dec_sym sym;
+    while (ans_.state < l_rans_base && ans_.buf_offset > 0) {
+      ans_.state = ans_.state * DRACO_ANS_IO_BASE + ans_.buf[--ans_.buf_offset];
+    }
+    // |rans_precision| is a power of two compile time constant, and the below
+    // division and modulo are going to be optimized by the compiler.
+    quo = ans_.state / rans_precision;
+    rem = ans_.state % rans_precision;
+    fetch_sym(&sym, rem);
+    ans_.state = quo * sym.prob + rem - sym.cum_prob;
+    return sym.val;
+  }
+
+  // Construct a lookup table with |rans_precision| number of entries.
+  // Returns false if the table couldn't be built (because of wrong input data).
+  inline bool rans_build_look_up_table(const uint32_t token_probs[],
+                                       uint32_t num_symbols) {
+    lut_table_.resize(rans_precision);
+    probability_table_.resize(num_symbols);
+    uint32_t cum_prob = 0;
+    uint32_t act_prob = 0;
+    for (uint32_t i = 0; i < num_symbols; ++i) {
+      probability_table_[i].prob = token_probs[i];
+      probability_table_[i].cum_prob = cum_prob;
+      cum_prob += token_probs[i];
+      if (cum_prob > rans_precision) {
+        return false;
+      }
+      for (uint32_t j = act_prob; j < cum_prob; ++j) {
+        lut_table_[j] = i;
+      }
+      act_prob = cum_prob;
+    }
+    if (cum_prob != rans_precision) {
+      return false;
+    }
+    return true;
+  }
+
+ private:
+  inline void fetch_sym(struct rans_dec_sym *out, uint32_t rem) {
+    uint32_t symbol = lut_table_[rem];
+    out->val = symbol;
+    out->prob = probability_table_[symbol].prob;
+    out->cum_prob = probability_table_[symbol].cum_prob;
+  }
+
+  static constexpr int rans_precision = 1 << rans_precision_bits_t;
+  static constexpr int l_rans_base = rans_precision * 4;
+  std::vector<uint32_t> lut_table_;
+  std::vector<rans_sym> probability_table_;
+  AnsDecoder ans_;
+};
+
+#undef DRACO_ANS_DIVREM
+#undef DRACO_ANS_P8_PRECISION
+#undef DRACO_ANS_L_BASE
+#undef DRACO_ANS_IO_BASE
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ENTROPY_ANS_H_
diff --git a/engine/inc/draco/compression/entropy/rans_symbol_coding.h b/engine/inc/draco/compression/entropy/rans_symbol_coding.h
new file mode 100644
index 00000000..cd427119
--- /dev/null
+++ b/engine/inc/draco/compression/entropy/rans_symbol_coding.h
@@ -0,0 +1,53 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File providing shared functionality for RAnsSymbolEncoder and
+// RAnsSymbolDecoder (see rans_symbol_encoder.h / rans_symbol_decoder.h).
+#ifndef DRACO_COMPRESSION_ENTROPY_RANS_SYMBOL_CODING_H_
+#define DRACO_COMPRESSION_ENTROPY_RANS_SYMBOL_CODING_H_
+
+#include "draco/compression/entropy/ans.h"
+
+namespace draco {
+
+// Computes the desired precision of the rANS method for the specified number of
+// unique symbols the input data (defined by their bit_length).
+constexpr int ComputeRAnsUnclampedPrecision(int symbols_bit_length) {
+  return (3 * symbols_bit_length) / 2;
+}
+
+// Computes the desired precision clamped to guarantee a valid functionality of
+// our rANS library (which is between 12 to 20 bits).
+constexpr int ComputeRAnsPrecisionFromUniqueSymbolsBitLength(
+    int symbols_bit_length) {
+  return ComputeRAnsUnclampedPrecision(symbols_bit_length) < 12 ? 12
+         : ComputeRAnsUnclampedPrecision(symbols_bit_length) > 20
+             ? 20
+             : ComputeRAnsUnclampedPrecision(symbols_bit_length);
+}
+
+// Compute approximate frequency table size needed for storing the provided
+// symbols.
+static inline int64_t ApproximateRAnsFrequencyTableBits(
+    int32_t max_value, int num_unique_symbols) {
+  // Approximate number of bits for storing zero frequency entries using the
+  // run length encoding (with max length of 64).
+  const int64_t table_zero_frequency_bits =
+      8 * (num_unique_symbols + (max_value - num_unique_symbols) / 64);
+  return 8 * num_unique_symbols + table_zero_frequency_bits;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ENTROPY_RANS_SYMBOL_CODING_H_
diff --git a/engine/inc/draco/compression/entropy/rans_symbol_decoder.h b/engine/inc/draco/compression/entropy/rans_symbol_decoder.h
new file mode 100644
index 00000000..10cdc678
--- /dev/null
+++ b/engine/inc/draco/compression/entropy/rans_symbol_decoder.h
@@ -0,0 +1,164 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ENTROPY_RANS_SYMBOL_DECODER_H_
+#define DRACO_COMPRESSION_ENTROPY_RANS_SYMBOL_DECODER_H_
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/entropy/rans_symbol_coding.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/varint_decoding.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// A helper class for decoding symbols using the rANS algorithm (see ans.h).
+// The class can be used to decode the probability table and the data encoded
+// by the RAnsSymbolEncoder. |unique_symbols_bit_length_t| must be the same as
+// the one used for the corresponding RAnsSymbolEncoder.
+template <int unique_symbols_bit_length_t>
+class RAnsSymbolDecoder {
+ public:
+  RAnsSymbolDecoder() : num_symbols_(0) {}
+
+  // Initialize the decoder and decode the probability table.
+  bool Create(DecoderBuffer *buffer);
+
+  uint32_t num_symbols() const { return num_symbols_; }
+
+  // Starts decoding from the buffer. The buffer will be advanced past the
+  // encoded data after this call.
+  bool StartDecoding(DecoderBuffer *buffer);
+  uint32_t DecodeSymbol() { return ans_.rans_read(); }
+  void EndDecoding();
+
+ private:
+  static constexpr int rans_precision_bits_ =
+      ComputeRAnsPrecisionFromUniqueSymbolsBitLength(
+          unique_symbols_bit_length_t);
+  static constexpr int rans_precision_ = 1 << rans_precision_bits_;
+
+  std::vector<uint32_t> probability_table_;
+  uint32_t num_symbols_;
+  RAnsDecoder<rans_precision_bits_> ans_;
+};
+
+template <int unique_symbols_bit_length_t>
+bool RAnsSymbolDecoder<unique_symbols_bit_length_t>::Create(
+    DecoderBuffer *buffer) {
+  // Check that the DecoderBuffer version is set.
+  if (buffer->bitstream_version() == 0) {
+    return false;
+  }
+  // Decode the number of alphabet symbols.
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (buffer->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0)) {
+    if (!buffer->Decode(&num_symbols_)) {
+      return false;
+    }
+
+  } else
+#endif
+  {
+    if (!DecodeVarint(&num_symbols_, buffer)) {
+      return false;
+    }
+  }
+  probability_table_.resize(num_symbols_);
+  if (num_symbols_ == 0) {
+    return true;
+  }
+  // Decode the table.
+  for (uint32_t i = 0; i < num_symbols_; ++i) {
+    uint8_t prob_data = 0;
+    // Decode the first byte and extract the number of extra bytes we need to
+    // get, or the offset to the next symbol with non-zero probability.
+    if (!buffer->Decode(&prob_data)) {
+      return false;
+    }
+    // Token is stored in the first two bits of the first byte. Values 0-2 are
+    // used to indicate the number of extra bytes, and value 3 is a special
+    // symbol used to denote run-length coding of zero probability entries.
+    // See rans_symbol_encoder.h for more details.
+    const int token = prob_data & 3;
+    if (token == 3) {
+      const uint32_t offset = prob_data >> 2;
+      if (i + offset >= num_symbols_) {
+        return false;
+      }
+      // Set zero probability for all symbols in the specified range.
+      for (uint32_t j = 0; j < offset + 1; ++j) {
+        probability_table_[i + j] = 0;
+      }
+      i += offset;
+    } else {
+      const int extra_bytes = token;
+      uint32_t prob = prob_data >> 2;
+      for (int b = 0; b < extra_bytes; ++b) {
+        uint8_t eb;
+        if (!buffer->Decode(&eb)) {
+          return false;
+        }
+        // Shift 8 bits for each extra byte and subtract 2 for the two first
+        // bits.
+        prob |= static_cast<uint32_t>(eb) << (8 * (b + 1) - 2);
+      }
+      probability_table_[i] = prob;
+    }
+  }
+  if (!ans_.rans_build_look_up_table(&probability_table_[0], num_symbols_)) {
+    return false;
+  }
+  return true;
+}
+
+template <int unique_symbols_bit_length_t>
+bool RAnsSymbolDecoder<unique_symbols_bit_length_t>::StartDecoding(
+    DecoderBuffer *buffer) {
+  uint64_t bytes_encoded;
+  // Decode the number of bytes encoded by the encoder.
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (buffer->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0)) {
+    if (!buffer->Decode(&bytes_encoded)) {
+      return false;
+    }
+
+  } else
+#endif
+  {
+    if (!DecodeVarint<uint64_t>(&bytes_encoded, buffer)) {
+      return false;
+    }
+  }
+  if (bytes_encoded > static_cast<uint64_t>(buffer->remaining_size())) {
+    return false;
+  }
+  const uint8_t *const data_head =
+      reinterpret_cast<const uint8_t *>(buffer->data_head());
+  // Advance the buffer past the rANS data.
+  buffer->Advance(bytes_encoded);
+  if (ans_.read_init(data_head, static_cast<int>(bytes_encoded)) != 0) {
+    return false;
+  }
+  return true;
+}
+
+template <int unique_symbols_bit_length_t>
+void RAnsSymbolDecoder<unique_symbols_bit_length_t>::EndDecoding() {
+  ans_.read_end();
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ENTROPY_RANS_SYMBOL_DECODER_H_
diff --git a/engine/inc/draco/compression/entropy/rans_symbol_encoder.h b/engine/inc/draco/compression/entropy/rans_symbol_encoder.h
new file mode 100644
index 00000000..4e07ec87
--- /dev/null
+++ b/engine/inc/draco/compression/entropy/rans_symbol_encoder.h
@@ -0,0 +1,290 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ENTROPY_RANS_SYMBOL_ENCODER_H_
+#define DRACO_COMPRESSION_ENTROPY_RANS_SYMBOL_ENCODER_H_
+
+#include <algorithm>
+#include <cmath>
+#include <cstring>
+
+#include "draco/compression/entropy/ans.h"
+#include "draco/compression/entropy/rans_symbol_coding.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/core/varint_encoding.h"
+
+namespace draco {
+
+// A helper class for encoding symbols using the rANS algorithm (see ans.h).
+// The class can be used to initialize and encode probability table needed by
+// rANS, and to perform encoding of symbols into the provided EncoderBuffer.
+template <int unique_symbols_bit_length_t>
+class RAnsSymbolEncoder {
+ public:
+  RAnsSymbolEncoder()
+      : num_symbols_(0), num_expected_bits_(0), buffer_offset_(0) {}
+
+  // Creates a probability table needed by the rANS library and encode it into
+  // the provided buffer.
+  bool Create(const uint64_t *frequencies, int num_symbols,
+              EncoderBuffer *buffer);
+
+  void StartEncoding(EncoderBuffer *buffer);
+  void EncodeSymbol(uint32_t symbol) {
+    ans_.rans_write(&probability_table_[symbol]);
+  }
+  void EndEncoding(EncoderBuffer *buffer);
+
+  // rANS requires to encode the input symbols in the reverse order.
+  static constexpr bool needs_reverse_encoding() { return true; }
+
+ private:
+  // Functor used for sorting symbol ids according to their probabilities.
+  // The functor sorts symbol indices that index an underlying map between
+  // symbol ids and their probabilities. We don't sort the probability table
+  // directly, because that would require an additional indirection during the
+  // EncodeSymbol() function.
+  struct ProbabilityLess {
+    explicit ProbabilityLess(const std::vector<rans_sym> *probs)
+        : probabilities(probs) {}
+    bool operator()(int i, int j) const {
+      return probabilities->at(i).prob < probabilities->at(j).prob;
+    }
+    const std::vector<rans_sym> *probabilities;
+  };
+
+  // Encodes the probability table into the output buffer.
+  bool EncodeTable(EncoderBuffer *buffer);
+
+  static constexpr int rans_precision_bits_ =
+      ComputeRAnsPrecisionFromUniqueSymbolsBitLength(
+          unique_symbols_bit_length_t);
+  static constexpr int rans_precision_ = 1 << rans_precision_bits_;
+
+  std::vector<rans_sym> probability_table_;
+  // The number of symbols in the input alphabet.
+  uint32_t num_symbols_;
+  // Expected number of bits that is needed to encode the input.
+  uint64_t num_expected_bits_;
+
+  RAnsEncoder<rans_precision_bits_> ans_;
+  // Initial offset of the encoder buffer before any ans data was encoded.
+  uint64_t buffer_offset_;
+};
+
+template <int unique_symbols_bit_length_t>
+bool RAnsSymbolEncoder<unique_symbols_bit_length_t>::Create(
+    const uint64_t *frequencies, int num_symbols, EncoderBuffer *buffer) {
+  // Compute the total of the input frequencies.
+  uint64_t total_freq = 0;
+  int max_valid_symbol = 0;
+  for (int i = 0; i < num_symbols; ++i) {
+    total_freq += frequencies[i];
+    if (frequencies[i] > 0) {
+      max_valid_symbol = i;
+    }
+  }
+  num_symbols = max_valid_symbol + 1;
+  num_symbols_ = num_symbols;
+  probability_table_.resize(num_symbols);
+  const double total_freq_d = static_cast<double>(total_freq);
+  const double rans_precision_d = static_cast<double>(rans_precision_);
+  // Compute probabilities by rescaling the normalized frequencies into interval
+  // [1, rans_precision - 1]. The total probability needs to be equal to
+  // rans_precision.
+  int total_rans_prob = 0;
+  for (int i = 0; i < num_symbols; ++i) {
+    const uint64_t freq = frequencies[i];
+
+    // Normalized probability.
+    const double prob = static_cast<double>(freq) / total_freq_d;
+
+    // RAns probability in range of [1, rans_precision - 1].
+    uint32_t rans_prob = static_cast<uint32_t>(prob * rans_precision_d + 0.5f);
+    if (rans_prob == 0 && freq > 0) {
+      rans_prob = 1;
+    }
+    probability_table_[i].prob = rans_prob;
+    total_rans_prob += rans_prob;
+  }
+  // Because of rounding errors, the total precision may not be exactly accurate
+  // and we may need to adjust the entries a little bit.
+  if (total_rans_prob != rans_precision_) {
+    std::vector<int> sorted_probabilities(num_symbols);
+    for (int i = 0; i < num_symbols; ++i) {
+      sorted_probabilities[i] = i;
+    }
+    std::sort(sorted_probabilities.begin(), sorted_probabilities.end(),
+              ProbabilityLess(&probability_table_));
+    if (total_rans_prob < rans_precision_) {
+      // This happens rather infrequently, just add the extra needed precision
+      // to the most frequent symbol.
+      probability_table_[sorted_probabilities.back()].prob +=
+          rans_precision_ - total_rans_prob;
+    } else {
+      // We have over-allocated the precision, which is quite common.
+      // Rescale the probabilities of all symbols.
+      int32_t error = total_rans_prob - rans_precision_;
+      while (error > 0) {
+        const double act_total_prob_d = static_cast<double>(total_rans_prob);
+        const double act_rel_error_d = rans_precision_d / act_total_prob_d;
+        for (int j = num_symbols - 1; j > 0; --j) {
+          int symbol_id = sorted_probabilities[j];
+          if (probability_table_[symbol_id].prob <= 1) {
+            if (j == num_symbols - 1) {
+              return false;  // Most frequent symbol would be empty.
+            }
+            break;
+          }
+          const int32_t new_prob = static_cast<int32_t>(
+              floor(act_rel_error_d *
+                    static_cast<double>(probability_table_[symbol_id].prob)));
+          int32_t fix = probability_table_[symbol_id].prob - new_prob;
+          if (fix == 0u) {
+            fix = 1;
+          }
+          if (fix >= static_cast<int32_t>(probability_table_[symbol_id].prob)) {
+            fix = probability_table_[symbol_id].prob - 1;
+          }
+          if (fix > error) {
+            fix = error;
+          }
+          probability_table_[symbol_id].prob -= fix;
+          total_rans_prob -= fix;
+          error -= fix;
+          if (total_rans_prob == rans_precision_) {
+            break;
+          }
+        }
+      }
+    }
+  }
+
+  // Compute the cumulative probability (cdf).
+  uint32_t total_prob = 0;
+  for (int i = 0; i < num_symbols; ++i) {
+    probability_table_[i].cum_prob = total_prob;
+    total_prob += probability_table_[i].prob;
+  }
+  if (total_prob != rans_precision_) {
+    return false;
+  }
+
+  // Estimate the number of bits needed to encode the input.
+  // From Shannon entropy the total number of bits N is:
+  //   N = -sum{i : all_symbols}(F(i) * log2(P(i)))
+  // where P(i) is the normalized probability of symbol i and F(i) is the
+  // symbol's frequency in the input data.
+  double num_bits = 0;
+  for (int i = 0; i < num_symbols; ++i) {
+    if (probability_table_[i].prob == 0) {
+      continue;
+    }
+    const double norm_prob =
+        static_cast<double>(probability_table_[i].prob) / rans_precision_d;
+    num_bits += static_cast<double>(frequencies[i]) * log2(norm_prob);
+  }
+  num_expected_bits_ = static_cast<uint64_t>(ceil(-num_bits));
+  if (!EncodeTable(buffer)) {
+    return false;
+  }
+  return true;
+}
+
+template <int unique_symbols_bit_length_t>
+bool RAnsSymbolEncoder<unique_symbols_bit_length_t>::EncodeTable(
+    EncoderBuffer *buffer) {
+  EncodeVarint(num_symbols_, buffer);
+  // Use varint encoding for the probabilities (first two bits represent the
+  // number of bytes used - 1).
+  for (uint32_t i = 0; i < num_symbols_; ++i) {
+    const uint32_t prob = probability_table_[i].prob;
+    int num_extra_bytes = 0;
+    if (prob >= (1 << 6)) {
+      num_extra_bytes++;
+      if (prob >= (1 << 14)) {
+        num_extra_bytes++;
+        if (prob >= (1 << 22)) {
+          // The maximum number of precision bits is 20 so we should not really
+          // get to this point.
+          return false;
+        }
+      }
+    }
+    if (prob == 0) {
+      // When the probability of the symbol is 0, set the first two bits to 1
+      // (unique identifier) and use the remaining 6 bits to store the offset
+      // to the next symbol with non-zero probability.
+      uint32_t offset = 0;
+      for (; offset < (1 << 6) - 1; ++offset) {
+        // Note: we don't have to check whether the next symbol id is larger
+        // than num_symbols_ because we know that the last symbol always has
+        // non-zero probability.
+        const uint32_t next_prob = probability_table_[i + offset + 1].prob;
+        if (next_prob > 0) {
+          break;
+        }
+      }
+      buffer->Encode(static_cast<uint8_t>((offset << 2) | 3));
+      i += offset;
+    } else {
+      // Encode the first byte (including the number of extra bytes).
+      buffer->Encode(static_cast<uint8_t>((prob << 2) | (num_extra_bytes & 3)));
+      // Encode the extra bytes.
+      for (int b = 0; b < num_extra_bytes; ++b) {
+        buffer->Encode(static_cast<uint8_t>(prob >> (8 * (b + 1) - 2)));
+      }
+    }
+  }
+  return true;
+}
+
+template <int unique_symbols_bit_length_t>
+void RAnsSymbolEncoder<unique_symbols_bit_length_t>::StartEncoding(
+    EncoderBuffer *buffer) {
+  // Allocate extra storage just in case.
+  const uint64_t required_bits = 2 * num_expected_bits_ + 32;
+
+  buffer_offset_ = buffer->size();
+  const int64_t required_bytes = (required_bits + 7) / 8;
+  buffer->Resize(buffer_offset_ + required_bytes + sizeof(buffer_offset_));
+  uint8_t *const data =
+      reinterpret_cast<uint8_t *>(const_cast<char *>(buffer->data()));
+  ans_.write_init(data + buffer_offset_);
+}
+
+template <int unique_symbols_bit_length_t>
+void RAnsSymbolEncoder<unique_symbols_bit_length_t>::EndEncoding(
+    EncoderBuffer *buffer) {
+  char *const src = const_cast<char *>(buffer->data()) + buffer_offset_;
+
+  // TODO(fgalligan): Look into changing this to uint32_t as write_end()
+  // returns an int.
+  const uint64_t bytes_written = static_cast<uint64_t>(ans_.write_end());
+  EncoderBuffer var_size_buffer;
+  EncodeVarint(bytes_written, &var_size_buffer);
+  const uint32_t size_len = static_cast<uint32_t>(var_size_buffer.size());
+  char *const dst = src + size_len;
+  memmove(dst, src, bytes_written);
+
+  // Store the size of the encoded data.
+  memcpy(src, var_size_buffer.data(), size_len);
+
+  // Resize the buffer to match the number of encoded bytes.
+  buffer->Resize(buffer_offset_ + bytes_written + size_len);
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ENTROPY_RANS_SYMBOL_ENCODER_H_
diff --git a/engine/inc/draco/compression/entropy/shannon_entropy.h b/engine/inc/draco/compression/entropy/shannon_entropy.h
new file mode 100644
index 00000000..85165f4c
--- /dev/null
+++ b/engine/inc/draco/compression/entropy/shannon_entropy.h
@@ -0,0 +1,110 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ENTROPY_SHANNON_ENTROPY_H_
+#define DRACO_COMPRESSION_ENTROPY_SHANNON_ENTROPY_H_
+
+#include <stdint.h>
+
+#include <vector>
+
+namespace draco {
+
+// Computes an approximate Shannon entropy of symbols stored in the provided
+// input array |symbols|. The entropy corresponds to the number of bits that is
+// required to represent/store all the symbols using an optimal entropy coding
+// algorithm. See for example "A mathematical theory of communication" by
+// Shannon'48 (http://ieeexplore.ieee.org/document/6773024/).
+//
+// |max_value| is a required input that define the maximum value in the input
+// |symbols| array.
+//
+// |out_num_unique_symbols| is an optional output argument that stores the
+// number of unique symbols contained within the |symbols| array.
+// TODO(ostava): This should be renamed or the return value should be changed to
+// return the actual entropy and not the number of bits needed to represent the
+// input symbols.
+int64_t ComputeShannonEntropy(const uint32_t *symbols, int num_symbols,
+                              int max_value, int *out_num_unique_symbols);
+
+// Computes the Shannon entropy of |num_values| Boolean entries, where
+// |num_true_values| are set to true.
+// Returns entropy between 0-1.
+double ComputeBinaryShannonEntropy(uint32_t num_values,
+                                   uint32_t num_true_values);
+
+// Class that can be used to keep track of the Shannon entropy on streamed data.
+// As new symbols are pushed to the tracker, the entropy is automatically
+// recomputed. The class also support recomputing the entropy without actually
+// pushing the symbols to the tracker through the Peek() method.
+class ShannonEntropyTracker {
+ public:
+  ShannonEntropyTracker();
+
+  // Struct for holding entropy data about the symbols added to the tracker.
+  // It can be used to compute the number of bits needed to store the data using
+  // the method:
+  //   ShannonEntropyTracker::GetNumberOfDataBits(entropy_data);
+  // or to compute the approximate size of the frequency table needed by the
+  // rans coding using method:
+  //   ShannonEntropyTracker::GetNumberOfRAnsTableBits(entropy_data);
+  struct EntropyData {
+    double entropy_norm;
+    int num_values;
+    int max_symbol;
+    int num_unique_symbols;
+    EntropyData()
+        : entropy_norm(0.0),
+          num_values(0),
+          max_symbol(0),
+          num_unique_symbols(0) {}
+  };
+
+  // Adds new symbols to the tracker and recomputes the entropy accordingly.
+  EntropyData Push(const uint32_t *symbols, int num_symbols);
+
+  // Returns new entropy data for the tracker as if |symbols| were added to the
+  // tracker without actually changing the status of the tracker.
+  EntropyData Peek(const uint32_t *symbols, int num_symbols);
+
+  // Gets the number of bits needed for encoding symbols added to the tracker.
+  int64_t GetNumberOfDataBits() const {
+    return GetNumberOfDataBits(entropy_data_);
+  }
+
+  // Gets the number of bits needed for encoding frequency table using the rans
+  // encoder.
+  int64_t GetNumberOfRAnsTableBits() const {
+    return GetNumberOfRAnsTableBits(entropy_data_);
+  }
+
+  // Gets the number of bits needed for encoding given |entropy_data|.
+  static int64_t GetNumberOfDataBits(const EntropyData &entropy_data);
+
+  // Gets the number of bits needed for encoding frequency table using the rans
+  // encoder for the given |entropy_data|.
+  static int64_t GetNumberOfRAnsTableBits(const EntropyData &entropy_data);
+
+ private:
+  EntropyData UpdateSymbols(const uint32_t *symbols, int num_symbols,
+                            bool push_changes);
+
+  std::vector<int32_t> frequencies_;
+
+  EntropyData entropy_data_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ENTROPY_SHANNON_ENTROPY_H_
diff --git a/engine/inc/draco/compression/entropy/symbol_decoding.h b/engine/inc/draco/compression/entropy/symbol_decoding.h
new file mode 100644
index 00000000..ea11165c
--- /dev/null
+++ b/engine/inc/draco/compression/entropy/symbol_decoding.h
@@ -0,0 +1,29 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ENTROPY_SYMBOL_DECODING_H_
+#define DRACO_COMPRESSION_ENTROPY_SYMBOL_DECODING_H_
+
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+
+// Decodes an array of symbols that was previously encoded with an entropy code.
+// Returns false on error.
+bool DecodeSymbols(uint32_t num_values, int num_components,
+                   DecoderBuffer *src_buffer, uint32_t *out_values);
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ENTROPY_SYMBOL_DECODING_H_
diff --git a/engine/inc/draco/compression/entropy/symbol_encoding.h b/engine/inc/draco/compression/entropy/symbol_encoding.h
new file mode 100644
index 00000000..839b28b1
--- /dev/null
+++ b/engine/inc/draco/compression/entropy/symbol_encoding.h
@@ -0,0 +1,47 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ENTROPY_SYMBOL_ENCODING_H_
+#define DRACO_COMPRESSION_ENTROPY_SYMBOL_ENCODING_H_
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/core/options.h"
+
+namespace draco {
+
+// Encodes an array of symbols using an entropy coding. This function
+// automatically decides whether to encode the symbol values using bit
+// length tags (see EncodeTaggedSymbols), or whether to encode them directly
+// (see EncodeRawSymbols). The symbols can be grouped into separate components
+// that can be used for better compression. |options| is an optional parameter
+// that allows more direct control over various stages of the symbol encoding
+// (see below for functions that are used to set valid options).
+// Returns false on error.
+bool EncodeSymbols(const uint32_t *symbols, int num_values, int num_components,
+                   const Options *options, EncoderBuffer *target_buffer);
+
+// Sets an option that forces symbol encoder to use the specified encoding
+// method.
+void SetSymbolEncodingMethod(Options *options, SymbolCodingMethod method);
+
+// Sets the desired compression level for symbol encoding in range <0, 10> where
+// 0 is the worst but fastest compression and 10 is the best but slowest
+// compression. If the option is not set, default value of 7 is used.
+// Returns false if an invalid level has been set.
+bool SetSymbolEncodingCompressionLevel(Options *options, int compression_level);
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ENTROPY_SYMBOL_ENCODING_H_
diff --git a/engine/inc/draco/compression/expert_encode.h b/engine/inc/draco/compression/expert_encode.h
new file mode 100644
index 00000000..ea59393d
--- /dev/null
+++ b/engine/inc/draco/compression/expert_encode.h
@@ -0,0 +1,147 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_EXPERT_ENCODE_H_
+#define DRACO_COMPRESSION_EXPERT_ENCODE_H_
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/config/encoder_options.h"
+#include "draco/compression/encode_base.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/core/status.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Advanced helper class for encoding geometry using the Draco compression
+// library. Unlike the basic Encoder (encode.h), this class allows users to
+// specify options for each attribute individually using provided attribute ids.
+// The drawback of this encoder is that it can be used to encode only one model
+// at a time, and for each new model the options need to be set again,
+class ExpertEncoder : public EncoderBase<EncoderOptions> {
+ public:
+  typedef EncoderBase<EncoderOptions> Base;
+  typedef EncoderOptions OptionsType;
+
+  explicit ExpertEncoder(const PointCloud &point_cloud);
+  explicit ExpertEncoder(const Mesh &mesh);
+
+  // Encodes the geometry provided in the constructor to the target buffer.
+  Status EncodeToBuffer(EncoderBuffer *out_buffer);
+
+  // Set encoder options used during the geometry encoding. Note that this call
+  // overwrites any modifications to the options done with the functions below.
+  void Reset(const EncoderOptions &options);
+  void Reset();
+
+  // Sets the desired encoding and decoding speed for the given options.
+  //
+  //  0 = slowest speed, but the best compression.
+  // 10 = fastest, but the worst compression.
+  // -1 = undefined.
+  //
+  // Note that both speed options affect the encoder choice of used methods and
+  // algorithms. For example, a requirement for fast decoding may prevent the
+  // encoder from using the best compression methods even if the encoding speed
+  // is set to 0. In general, the faster of the two options limits the choice of
+  // features that can be used by the encoder. Additionally, setting
+  // |decoding_speed| to be faster than the |encoding_speed| may allow the
+  // encoder to choose the optimal method out of the available features for the
+  // given |decoding_speed|.
+  void SetSpeedOptions(int encoding_speed, int decoding_speed);
+
+  // Sets the quantization compression options for a specific attribute. The
+  // attribute values will be quantized in a box defined by the maximum extent
+  // of the attribute values. I.e., the actual precision of this option depends
+  // on the scale of the attribute values.
+  void SetAttributeQuantization(int32_t attribute_id, int quantization_bits);
+
+  // Sets the explicit quantization compression for a named attribute. The
+  // attribute values will be quantized in a coordinate system defined by the
+  // provided origin and range (the input values should be within interval:
+  // <origin, origin + range>).
+  void SetAttributeExplicitQuantization(int32_t attribute_id,
+                                        int quantization_bits, int num_dims,
+                                        const float *origin, float range);
+
+  // Enables/disables built in entropy coding of attribute values. Disabling
+  // this option may be useful to improve the performance when third party
+  // compression is used on top of the Draco compression. Default: [true].
+  void SetUseBuiltInAttributeCompression(bool enabled);
+
+  // Sets the desired encoding method for a given geometry. By default, encoding
+  // method is selected based on the properties of the input geometry and based
+  // on the other options selected in the used EncoderOptions (such as desired
+  // encoding and decoding speed). This function should be called only when a
+  // specific method is required.
+  //
+  // |encoding_method| can be one of the values defined in
+  // compression/config/compression_shared.h based on the type of the input
+  // geometry that is going to be encoded. For point clouds, allowed entries are
+  //   POINT_CLOUD_SEQUENTIAL_ENCODING
+  //   POINT_CLOUD_KD_TREE_ENCODING
+  //
+  // For meshes the input can be
+  //   MESH_SEQUENTIAL_ENCODING
+  //   MESH_EDGEBREAKER_ENCODING
+  //
+  // If the selected method cannot be used for the given input, the subsequent
+  // call of EncodePointCloudToBuffer or EncodeMeshToBuffer is going to fail.
+  void SetEncodingMethod(int encoding_method);
+
+  // Sets the desired encoding submethod, only for MESH_EDGEBREAKER_ENCODING.
+  // Valid values for |encoding_submethod| are:
+  //   MESH_EDGEBREAKER_STANDARD_ENCODING
+  //   MESH_EDGEBREAKER_VALENCE_ENCODING
+  // see also compression/config/compression_shared.h.
+  void SetEncodingSubmethod(int encoding_submethod);
+
+  // Sets the desired prediction method for a given attribute. By default,
+  // prediction scheme is selected automatically by the encoder using other
+  // provided options (such as speed) and input geometry type (mesh, point
+  // cloud). This function should be called only when a specific prediction is
+  // preferred (e.g., when it is known that the encoder would select a less
+  // optimal prediction for the given input data).
+  //
+  // |prediction_scheme_method| should be one of the entries defined in
+  // compression/config/compression_shared.h :
+  //
+  //   PREDICTION_NONE - use no prediction.
+  //   PREDICTION_DIFFERENCE - delta coding
+  //   MESH_PREDICTION_PARALLELOGRAM - parallelogram prediction for meshes.
+  //   MESH_PREDICTION_CONSTRAINED_PARALLELOGRAM
+  //      - better and more costly version of the parallelogram prediction.
+  //   MESH_PREDICTION_TEX_COORDS_PORTABLE
+  //      - specialized predictor for tex coordinates.
+  //   MESH_PREDICTION_GEOMETRIC_NORMAL
+  //      - specialized predictor for normal coordinates.
+  //
+  // Note that in case the desired prediction cannot be used, the default
+  // prediction will be automatically used instead.
+  Status SetAttributePredictionScheme(int32_t attribute_id,
+                                      int prediction_scheme_method);
+
+ private:
+  Status EncodePointCloudToBuffer(const PointCloud &pc,
+                                  EncoderBuffer *out_buffer);
+
+  Status EncodeMeshToBuffer(const Mesh &m, EncoderBuffer *out_buffer);
+
+  const PointCloud *point_cloud_;
+  const Mesh *mesh_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_EXPERT_ENCODE_H_
diff --git a/engine/inc/draco/compression/mesh/mesh_decoder.h b/engine/inc/draco/compression/mesh/mesh_decoder.h
new file mode 100644
index 00000000..397a679d
--- /dev/null
+++ b/engine/inc/draco/compression/mesh/mesh_decoder.h
@@ -0,0 +1,68 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_DECODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_DECODER_H_
+
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/compression/point_cloud/point_cloud_decoder.h"
+#include "draco/mesh/mesh.h"
+#include "draco/mesh/mesh_attribute_corner_table.h"
+
+namespace draco {
+
+// Class that reconstructs a 3D mesh from input data that was encoded by
+// MeshEncoder.
+class MeshDecoder : public PointCloudDecoder {
+ public:
+  MeshDecoder();
+
+  EncodedGeometryType GetGeometryType() const override {
+    return TRIANGULAR_MESH;
+  }
+
+  // The main entry point for mesh decoding.
+  Status Decode(const DecoderOptions &options, DecoderBuffer *in_buffer,
+                Mesh *out_mesh);
+
+  // Returns the base connectivity of the decoded mesh (or nullptr if it is not
+  // initialized).
+  virtual const CornerTable *GetCornerTable() const { return nullptr; }
+
+  // Returns the attribute connectivity data or nullptr if it does not exist.
+  virtual const MeshAttributeCornerTable *GetAttributeCornerTable(
+      int /* att_id */) const {
+    return nullptr;
+  }
+
+  // Returns the decoding data for a given attribute or nullptr when the data
+  // does not exist.
+  virtual const MeshAttributeIndicesEncodingData *GetAttributeEncodingData(
+      int /* att_id */) const {
+    return nullptr;
+  }
+
+  Mesh *mesh() const { return mesh_; }
+
+ protected:
+  bool DecodeGeometryData() override;
+  virtual bool DecodeConnectivity() = 0;
+
+ private:
+  Mesh *mesh_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_DECODER_H_
diff --git a/engine/inc/draco/compression/mesh/mesh_edgebreaker_decoder.h b/engine/inc/draco/compression/mesh/mesh_edgebreaker_decoder.h
new file mode 100644
index 00000000..5c161794
--- /dev/null
+++ b/engine/inc/draco/compression/mesh/mesh_edgebreaker_decoder.h
@@ -0,0 +1,54 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_H_
+
+#include "draco/compression/mesh/mesh_decoder.h"
+#include "draco/compression/mesh/mesh_edgebreaker_decoder_impl_interface.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Class for decoding data encoded by MeshEdgebreakerEncoder.
+class MeshEdgebreakerDecoder : public MeshDecoder {
+ public:
+  MeshEdgebreakerDecoder();
+
+  const CornerTable *GetCornerTable() const override {
+    return impl_->GetCornerTable();
+  }
+
+  const MeshAttributeCornerTable *GetAttributeCornerTable(
+      int att_id) const override {
+    return impl_->GetAttributeCornerTable(att_id);
+  }
+
+  const MeshAttributeIndicesEncodingData *GetAttributeEncodingData(
+      int att_id) const override {
+    return impl_->GetAttributeEncodingData(att_id);
+  }
+
+ protected:
+  bool InitializeDecoder() override;
+  bool CreateAttributesDecoder(int32_t att_decoder_id) override;
+  bool DecodeConnectivity() override;
+  bool OnAttributesDecoded() override;
+
+  std::unique_ptr<MeshEdgebreakerDecoderImplInterface> impl_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_H_
diff --git a/engine/inc/draco/compression/mesh/mesh_edgebreaker_decoder_impl.h b/engine/inc/draco/compression/mesh/mesh_edgebreaker_decoder_impl.h
new file mode 100644
index 00000000..78053f91
--- /dev/null
+++ b/engine/inc/draco/compression/mesh/mesh_edgebreaker_decoder_impl.h
@@ -0,0 +1,228 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_IMPL_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_IMPL_H_
+
+#include <unordered_map>
+#include <unordered_set>
+
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/compression/mesh/mesh_edgebreaker_decoder_impl_interface.h"
+#include "draco/compression/mesh/mesh_edgebreaker_shared.h"
+#include "draco/compression/mesh/traverser/mesh_traversal_sequencer.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/draco_features.h"
+#include "draco/mesh/corner_table.h"
+#include "draco/mesh/mesh_attribute_corner_table.h"
+
+namespace draco {
+
+// Implementation of the edgebreaker decoder that decodes data encoded with the
+// MeshEdgebreakerEncoderImpl class. The implementation of the decoder is based
+// on the algorithm presented in Isenburg et al'02 "Spirale Reversi: Reverse
+// decoding of the Edgebreaker encoding". Note that the encoding is still based
+// on the standard edgebreaker method as presented in "3D Compression
+// Made Simple: Edgebreaker on a Corner-Table" by Rossignac at al.'01.
+// http://www.cc.gatech.edu/~jarek/papers/CornerTableSMI.pdf. One difference is
+// caused by the properties of the spirale reversi algorithm that decodes the
+// symbols from the last one to the first one. To make the decoding more
+// efficient, we encode all symbols in the reverse order, therefore the decoder
+// can process them one by one.
+// The main advantage of the spirale reversi method is that the partially
+// decoded mesh has valid connectivity data at any time during the decoding
+// process (valid with respect to the decoded portion of the mesh). The standard
+// Edgebreaker decoder used two passes (forward decoding + zipping) which not
+// only prevented us from having a valid connectivity but it was also slower.
+// The main benefit of having the valid connectivity is that we can use the
+// known connectivity to predict encoded symbols that can improve the
+// compression rate.
+template <class TraversalDecoderT>
+class MeshEdgebreakerDecoderImpl : public MeshEdgebreakerDecoderImplInterface {
+ public:
+  MeshEdgebreakerDecoderImpl();
+  bool Init(MeshEdgebreakerDecoder *decoder) override;
+
+  const MeshAttributeCornerTable *GetAttributeCornerTable(
+      int att_id) const override;
+  const MeshAttributeIndicesEncodingData *GetAttributeEncodingData(
+      int att_id) const override;
+
+  bool CreateAttributesDecoder(int32_t att_decoder_id) override;
+  bool DecodeConnectivity() override;
+  bool OnAttributesDecoded() override;
+  MeshEdgebreakerDecoder *GetDecoder() const override { return decoder_; }
+  const CornerTable *GetCornerTable() const override {
+    return corner_table_.get();
+  }
+
+ private:
+  // Creates a vertex traversal sequencer for the specified |TraverserT| type.
+  template <class TraverserT>
+  std::unique_ptr<PointsSequencer> CreateVertexTraversalSequencer(
+      MeshAttributeIndicesEncodingData *encoding_data);
+
+  // Decodes connectivity between vertices (vertex indices).
+  // Returns the number of vertices created by the decoder or -1 on error.
+  int DecodeConnectivity(int num_symbols);
+
+  // Returns true if the current symbol was part of a topology split event. This
+  // means that the current face was connected to the left edge of a face
+  // encoded with the TOPOLOGY_S symbol. |out_symbol_edge| can be used to
+  // identify which edge of the source symbol was connected to the TOPOLOGY_S
+  // symbol.
+  bool IsTopologySplit(int encoder_symbol_id, EdgeFaceName *out_face_edge,
+                       int *out_encoder_split_symbol_id) {
+    if (topology_split_data_.size() == 0) {
+      return false;
+    }
+    if (topology_split_data_.back().source_symbol_id >
+        static_cast<uint32_t>(encoder_symbol_id)) {
+      // Something is wrong; if the desired source symbol is greater than the
+      // current encoder_symbol_id, we missed it, or the input was tampered
+      // (|encoder_symbol_id| keeps decreasing).
+      // Return invalid symbol id to notify the decoder that there was an
+      // error.
+      *out_encoder_split_symbol_id = -1;
+      return true;
+    }
+    if (topology_split_data_.back().source_symbol_id != encoder_symbol_id) {
+      return false;
+    }
+    *out_face_edge =
+        static_cast<EdgeFaceName>(topology_split_data_.back().source_edge);
+    *out_encoder_split_symbol_id = topology_split_data_.back().split_symbol_id;
+    // Remove the latest split event.
+    topology_split_data_.pop_back();
+    return true;
+  }
+
+  // Decodes event data for hole and topology split events and stores them for
+  // future use.
+  // Returns the number of parsed bytes, or -1 on error.
+  int32_t DecodeHoleAndTopologySplitEvents(DecoderBuffer *decoder_buffer);
+
+  // Decodes all non-position attribute connectivity on the currently
+  // processed face.
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  bool DecodeAttributeConnectivitiesOnFaceLegacy(CornerIndex corner);
+#endif
+  bool DecodeAttributeConnectivitiesOnFace(CornerIndex corner);
+
+  // Initializes mapping between corners and point ids.
+  bool AssignPointsToCorners(int num_connectivity_verts);
+
+  bool IsFaceVisited(CornerIndex corner_id) const {
+    if (corner_id < 0) {
+      return true;  // Invalid corner signalizes that the face does not exist.
+    }
+    return visited_faces_[corner_table_->Face(corner_id).value()];
+  }
+
+  void SetOppositeCorners(CornerIndex corner_0, CornerIndex corner_1) {
+    corner_table_->SetOppositeCorner(corner_0, corner_1);
+    corner_table_->SetOppositeCorner(corner_1, corner_0);
+  }
+
+  MeshEdgebreakerDecoder *decoder_;
+
+  std::unique_ptr<CornerTable> corner_table_;
+
+  // Stack used for storing corners that need to be traversed when decoding
+  // mesh vertices. New corner is added for each initial face and a split
+  // symbol, and one corner is removed when the end symbol is reached.
+  // Stored as member variable to prevent frequent memory reallocations when
+  // handling meshes with lots of disjoint components.  Originally, we used
+  // recursive functions to handle this behavior, but that can cause stack
+  // memory overflow when compressing huge meshes.
+  std::vector<CornerIndex> corner_traversal_stack_;
+
+  // Array stores the number of visited visited for each mesh traversal.
+  std::vector<int> vertex_traversal_length_;
+
+  // List of decoded topology split events.
+  std::vector<TopologySplitEventData> topology_split_data_;
+
+  // List of decoded hole events.
+  std::vector<HoleEventData> hole_event_data_;
+
+  // Configuration of the initial face for each mesh component.
+  std::vector<bool> init_face_configurations_;
+
+  // Initial corner for each traversal.
+  std::vector<CornerIndex> init_corners_;
+
+  // Id of the last processed input symbol.
+  int last_symbol_id_;
+
+  // Id of the last decoded vertex.
+  int last_vert_id_;
+
+  // Id of the last decoded face.
+  int last_face_id_;
+
+  // Array for marking visited faces.
+  std::vector<bool> visited_faces_;
+  // Array for marking visited vertices.
+  std::vector<bool> visited_verts_;
+  // Array for marking vertices on open boundaries.
+  std::vector<bool> is_vert_hole_;
+
+  // The number of new vertices added by the encoder (because of non-manifold
+  // vertices on the input mesh).
+  // If there are no non-manifold edges/vertices on the input mesh, this should
+  // be 0.
+  int num_new_vertices_;
+  // For every newly added vertex, this array stores it's mapping to the
+  // parent vertex id of the encoded mesh.
+  std::unordered_map<int, int> new_to_parent_vertex_map_;
+  // The number of vertices that were encoded (can be different from the number
+  // of vertices of the input mesh).
+  int num_encoded_vertices_;
+
+  // Array for storing the encoded corner ids in the order their associated
+  // vertices were decoded.
+  std::vector<int32_t> processed_corner_ids_;
+
+  // Array storing corners in the order they were visited during the
+  // connectivity decoding (always storing the tip corner of each newly visited
+  // face).
+  std::vector<int> processed_connectivity_corners_;
+
+  MeshAttributeIndicesEncodingData pos_encoding_data_;
+
+  // Id of an attributes decoder that uses |pos_encoding_data_|.
+  int pos_data_decoder_id_;
+
+  // Data for non-position attributes used by the decoder.
+  struct AttributeData {
+    AttributeData() : decoder_id(-1), is_connectivity_used(true) {}
+    // Id of the attribute decoder that was used to decode this attribute data.
+    int decoder_id;
+    MeshAttributeCornerTable connectivity_data;
+    // Flag that can mark the connectivity_data invalid. In such case the base
+    // corner table of the mesh should be used instead.
+    bool is_connectivity_used;
+    MeshAttributeIndicesEncodingData encoding_data;
+    // Opposite corners to attribute seam edges.
+    std::vector<int32_t> attribute_seam_corners;
+  };
+  std::vector<AttributeData> attribute_data_;
+
+  TraversalDecoderT traversal_decoder_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_IMPL_H_
diff --git a/engine/inc/draco/compression/mesh/mesh_edgebreaker_decoder_impl_interface.h b/engine/inc/draco/compression/mesh/mesh_edgebreaker_decoder_impl_interface.h
new file mode 100644
index 00000000..31fabf25
--- /dev/null
+++ b/engine/inc/draco/compression/mesh/mesh_edgebreaker_decoder_impl_interface.h
@@ -0,0 +1,47 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_IMPL_INTERFACE_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_IMPL_INTERFACE_H_
+
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/mesh/mesh_attribute_corner_table.h"
+
+namespace draco {
+
+// Forward declaration is necessary here to avoid circular dependencies.
+class MeshEdgebreakerDecoder;
+
+// Abstract interface used by MeshEdgebreakerDecoder to interact with the actual
+// implementation of the edgebreaker decoding method.
+class MeshEdgebreakerDecoderImplInterface {
+ public:
+  virtual ~MeshEdgebreakerDecoderImplInterface() = default;
+  virtual bool Init(MeshEdgebreakerDecoder *decoder) = 0;
+
+  virtual const MeshAttributeCornerTable *GetAttributeCornerTable(
+      int att_id) const = 0;
+  virtual const MeshAttributeIndicesEncodingData *GetAttributeEncodingData(
+      int att_id) const = 0;
+  virtual bool CreateAttributesDecoder(int32_t att_decoder_id) = 0;
+  virtual bool DecodeConnectivity() = 0;
+  virtual bool OnAttributesDecoded() = 0;
+
+  virtual MeshEdgebreakerDecoder *GetDecoder() const = 0;
+  virtual const CornerTable *GetCornerTable() const = 0;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_IMPL_INTERFACE_H_
diff --git a/engine/inc/draco/compression/mesh/mesh_edgebreaker_encoder.h b/engine/inc/draco/compression/mesh/mesh_edgebreaker_encoder.h
new file mode 100644
index 00000000..70d4d506
--- /dev/null
+++ b/engine/inc/draco/compression/mesh/mesh_edgebreaker_encoder.h
@@ -0,0 +1,73 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_ENCODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_ENCODER_H_
+
+#include <unordered_map>
+
+#include "draco/compression/mesh/mesh_edgebreaker_encoder_impl_interface.h"
+#include "draco/compression/mesh/mesh_edgebreaker_shared.h"
+#include "draco/compression/mesh/mesh_encoder.h"
+#include "draco/mesh/corner_table.h"
+
+namespace draco {
+
+// Class implements the edge breaker geometry compression method as described
+// in "3D Compression Made Simple: Edgebreaker on a Corner-Table" by Rossignac
+// at al.'01. http://www.cc.gatech.edu/~jarek/papers/CornerTableSMI.pdf
+class MeshEdgebreakerEncoder : public MeshEncoder {
+ public:
+  MeshEdgebreakerEncoder();
+
+  const CornerTable *GetCornerTable() const override {
+    return impl_->GetCornerTable();
+  }
+
+  const MeshAttributeCornerTable *GetAttributeCornerTable(
+      int att_id) const override {
+    return impl_->GetAttributeCornerTable(att_id);
+  }
+
+  const MeshAttributeIndicesEncodingData *GetAttributeEncodingData(
+      int att_id) const override {
+    return impl_->GetAttributeEncodingData(att_id);
+  }
+
+  uint8_t GetEncodingMethod() const override {
+    return MESH_EDGEBREAKER_ENCODING;
+  }
+
+ protected:
+  bool InitializeEncoder() override;
+  Status EncodeConnectivity() override;
+  bool GenerateAttributesEncoder(int32_t att_id) override;
+  bool EncodeAttributesEncoderIdentifier(int32_t att_encoder_id) override;
+  void ComputeNumberOfEncodedPoints() override;
+  void ComputeNumberOfEncodedFaces() override;
+
+ private:
+  // The actual implementation of the edge breaker method. The implementations
+  // are in general specializations of a template class
+  // MeshEdgebreakerEncoderImpl where the template arguments control encoding
+  // of the connectivity data. The actual implementation is selected in this
+  // class based on the provided encoding options. Because this choice is done
+  // in run-time, the actual implementation has to be hidden behind the
+  // abstract interface MeshEdgebreakerEncoderImplInterface.
+  std::unique_ptr<MeshEdgebreakerEncoderImplInterface> impl_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_ENCODER_H_
diff --git a/engine/inc/draco/compression/mesh/mesh_edgebreaker_encoder_impl.h b/engine/inc/draco/compression/mesh/mesh_edgebreaker_encoder_impl.h
new file mode 100644
index 00000000..fb337716
--- /dev/null
+++ b/engine/inc/draco/compression/mesh/mesh_edgebreaker_encoder_impl.h
@@ -0,0 +1,210 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_ENCODER_IMPL_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_ENCODER_IMPL_H_
+
+#include <unordered_map>
+
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/mesh/mesh_edgebreaker_encoder_impl_interface.h"
+#include "draco/compression/mesh/mesh_edgebreaker_shared.h"
+#include "draco/compression/mesh/traverser/mesh_traversal_sequencer.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/mesh/mesh_attribute_corner_table.h"
+
+namespace draco {
+
+// Class implementing the edgebreaker encoding as described in "3D Compression
+// Made Simple: Edgebreaker on a Corner-Table" by Rossignac at al.'01.
+// http://www.cc.gatech.edu/~jarek/papers/CornerTableSMI.pdf
+template <class TraversalEncoderT>
+class MeshEdgebreakerEncoderImpl : public MeshEdgebreakerEncoderImplInterface {
+ public:
+  MeshEdgebreakerEncoderImpl();
+  explicit MeshEdgebreakerEncoderImpl(
+      const TraversalEncoderT &traversal_encoder);
+  bool Init(MeshEdgebreakerEncoder *encoder) override;
+
+  const MeshAttributeCornerTable *GetAttributeCornerTable(
+      int att_id) const override;
+  const MeshAttributeIndicesEncodingData *GetAttributeEncodingData(
+      int att_id) const override;
+
+  bool GenerateAttributesEncoder(int32_t att_id) override;
+  bool EncodeAttributesEncoderIdentifier(int32_t att_encoder_id) override;
+  Status EncodeConnectivity() override;
+
+  const CornerTable *GetCornerTable() const override {
+    return corner_table_.get();
+  }
+  bool IsFaceEncoded(FaceIndex fi) const override {
+    return visited_faces_[fi.value()];
+  }
+  MeshEdgebreakerEncoder *GetEncoder() const override { return encoder_; }
+
+ private:
+  // Initializes data needed for encoding non-position attributes.
+  // Returns false on error.
+  bool InitAttributeData();
+
+  // Creates a vertex traversal sequencer for the specified |TraverserT| type.
+  template <class TraverserT>
+  std::unique_ptr<PointsSequencer> CreateVertexTraversalSequencer(
+      MeshAttributeIndicesEncodingData *encoding_data);
+
+  // Finds the configuration of the initial face that starts the traversal.
+  // Configurations are determined by location of holes around the init face
+  // and they are described in mesh_edgebreaker_shared.h.
+  // Returns true if the face configuration is interior and false if it is
+  // exterior.
+  bool FindInitFaceConfiguration(FaceIndex face_id,
+                                 CornerIndex *out_corner_id) const;
+
+  // Encodes the connectivity between vertices.
+  bool EncodeConnectivityFromCorner(CornerIndex corner_id);
+
+  // Encodes all vertices of a hole starting at start_corner_id.
+  // The vertex associated with the first corner is encoded only if
+  // |encode_first_vertex| is true.
+  // Returns the number of encoded hole vertices.
+  int EncodeHole(CornerIndex start_corner_id, bool encode_first_vertex);
+
+  // Encodes topology split data.
+  // Returns nullptr on error.
+  bool EncodeSplitData();
+
+  CornerIndex GetRightCorner(CornerIndex corner_id) const;
+  CornerIndex GetLeftCorner(CornerIndex corner_id) const;
+
+  bool IsRightFaceVisited(CornerIndex corner_id) const;
+  bool IsLeftFaceVisited(CornerIndex corner_id) const;
+  bool IsVertexVisited(VertexIndex vert_id) const {
+    return visited_vertex_ids_[vert_id.value()];
+  }
+
+  // Finds and stores data about all holes in the input mesh.
+  bool FindHoles();
+
+  // For faces encoded with symbol TOPOLOGY_S (split), this method returns
+  // the encoded symbol id or -1 if the face wasn't encoded by a split symbol.
+  int GetSplitSymbolIdOnFace(int face_id) const;
+
+  // Checks whether there is a topology split event on a neighboring face and
+  // stores the event data if necessary. For more info about topology split
+  // events, see description of TopologySplitEventData in
+  // mesh_edgebreaker_shared.h.
+  void CheckAndStoreTopologySplitEvent(int src_symbol_id, int src_face_id,
+                                       EdgeFaceName src_edge,
+                                       int neighbor_face_id);
+
+  // Encodes connectivity of all attributes on a newly traversed face.
+  bool EncodeAttributeConnectivitiesOnFace(CornerIndex corner);
+
+  // This function is used to to assign correct encoding order of attributes
+  // to unprocessed corners. The encoding order is equal to the order in which
+  // the attributes are going to be processed by the decoder and it is necessary
+  // for proper prediction of attribute values.
+  bool AssignPositionEncodingOrderToAllCorners();
+
+  // This function is used to generate encoding order for all non-position
+  // attributes.
+  // Returns false when one or more attributes failed to be processed.
+  bool GenerateEncodingOrderForAttributes();
+
+  // The main encoder that owns this class.
+  MeshEdgebreakerEncoder *encoder_;
+  // Mesh that's being encoded.
+  const Mesh *mesh_;
+  // Corner table stores the mesh face connectivity data.
+  std::unique_ptr<CornerTable> corner_table_;
+  // Stack used for storing corners that need to be traversed when encoding
+  // the connectivity. New corner is added for each initial face and a split
+  // symbol, and one corner is removed when the end symbol is reached.
+  // Stored as member variable to prevent frequent memory reallocations when
+  // handling meshes with lots of disjoint components. Originally, we used
+  // recursive functions to handle this behavior, but that can cause stack
+  // memory overflow when compressing huge meshes.
+  std::vector<CornerIndex> corner_traversal_stack_;
+  // Array for marking visited faces.
+  std::vector<bool> visited_faces_;
+
+  // Attribute data for position encoding.
+  MeshAttributeIndicesEncodingData pos_encoding_data_;
+
+  // Traversal method used for the position attribute.
+  MeshTraversalMethod pos_traversal_method_;
+
+  // Array storing corners in the order they were visited during the
+  // connectivity encoding (always storing the tip corner of each newly visited
+  // face).
+  std::vector<CornerIndex> processed_connectivity_corners_;
+
+  // Array for storing visited vertex ids of all input vertices.
+  std::vector<bool> visited_vertex_ids_;
+
+  // For each traversal, this array stores the number of visited vertices.
+  std::vector<int> vertex_traversal_length_;
+  // Array for storing all topology split events encountered during the mesh
+  // traversal.
+  std::vector<TopologySplitEventData> topology_split_event_data_;
+  // Map between face_id and symbol_id. Contains entries only for faces that
+  // were encoded with TOPOLOGY_S symbol.
+  std::unordered_map<int, int> face_to_split_symbol_map_;
+
+  // Array for marking holes that has been reached during the traversal.
+  std::vector<bool> visited_holes_;
+  // Array for mapping vertices to hole ids. If a vertex is not on a hole, the
+  // stored value is -1.
+  std::vector<int> vertex_hole_id_;
+
+  // Id of the last encoded symbol.
+  int last_encoded_symbol_id_;
+
+  // The number of encoded split symbols.
+  uint32_t num_split_symbols_;
+
+  // Struct holding data used for encoding each non-position attribute.
+  // TODO(ostava): This should be probably renamed to something better.
+  struct AttributeData {
+    AttributeData() : attribute_index(-1), is_connectivity_used(true) {}
+    int attribute_index;
+    MeshAttributeCornerTable connectivity_data;
+    // Flag that can mark the connectivity_data invalid. In such case the base
+    // corner table of the mesh should be used instead.
+    bool is_connectivity_used;
+    // Data about attribute encoding order.
+    MeshAttributeIndicesEncodingData encoding_data;
+    // Traversal method used to generate the encoding data for this attribute.
+    MeshTraversalMethod traversal_method;
+  };
+  std::vector<AttributeData> attribute_data_;
+
+  // Array storing mapping between attribute encoder id and attribute data id.
+  std::vector<int32_t> attribute_encoder_to_data_id_map_;
+
+  TraversalEncoderT traversal_encoder_;
+
+  // If set, the encoder is going to use the same connectivity for all
+  // attributes. This effectively breaks the mesh along all attribute seams.
+  // In general, this approach should be much faster compared to encoding each
+  // connectivity separately, but the decoded model may contain higher number of
+  // duplicate attribute values which may decrease the compression ratio.
+  bool use_single_connectivity_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_ENCODER_IMPL_H_
diff --git a/engine/inc/draco/compression/mesh/mesh_edgebreaker_encoder_impl_interface.h b/engine/inc/draco/compression/mesh/mesh_edgebreaker_encoder_impl_interface.h
new file mode 100644
index 00000000..627d5126
--- /dev/null
+++ b/engine/inc/draco/compression/mesh/mesh_edgebreaker_encoder_impl_interface.h
@@ -0,0 +1,57 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_ENCODER_IMPL_INTERFACE_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_ENCODER_IMPL_INTERFACE_H_
+
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/mesh/corner_table.h"
+#include "draco/mesh/mesh_attribute_corner_table.h"
+
+namespace draco {
+
+// Forward declaration is necessary here to avoid circular dependencies.
+class MeshEdgebreakerEncoder;
+
+// Abstract interface used by MeshEdgebreakerEncoder to interact with the actual
+// implementation of the edgebreaker method. The implementations are in general
+// specializations of a template class MeshEdgebreakerEncoderImpl where the
+// template arguments control encoding of the connectivity data. Because the
+// choice of the implementation is done in run-time, we need to hide it behind
+// the abstract interface MeshEdgebreakerEncoderImplInterface.
+class MeshEdgebreakerEncoderImplInterface {
+ public:
+  virtual ~MeshEdgebreakerEncoderImplInterface() = default;
+  virtual bool Init(MeshEdgebreakerEncoder *encoder) = 0;
+
+  virtual const MeshAttributeCornerTable *GetAttributeCornerTable(
+      int att_id) const = 0;
+  virtual const MeshAttributeIndicesEncodingData *GetAttributeEncodingData(
+      int att_id) const = 0;
+  virtual bool GenerateAttributesEncoder(int32_t att_id) = 0;
+  virtual bool EncodeAttributesEncoderIdentifier(int32_t att_encoder_id) = 0;
+  virtual Status EncodeConnectivity() = 0;
+
+  // Returns corner table of the encoded mesh.
+  virtual const CornerTable *GetCornerTable() const = 0;
+
+  // Returns true if a given face has been already encoded.
+  virtual bool IsFaceEncoded(FaceIndex fi) const = 0;
+
+  virtual MeshEdgebreakerEncoder *GetEncoder() const = 0;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_ENCODER_IMPL_INTERFACE_H_
diff --git a/engine/inc/draco/compression/mesh/mesh_edgebreaker_shared.h b/engine/inc/draco/compression/mesh/mesh_edgebreaker_shared.h
new file mode 100644
index 00000000..cb3c29dd
--- /dev/null
+++ b/engine/inc/draco/compression/mesh/mesh_edgebreaker_shared.h
@@ -0,0 +1,131 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_SHARED_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_SHARED_H_
+
+#include <stdint.h>
+
+namespace draco {
+
+// Shared declarations used by both edgebreaker encoder and decoder.
+
+// A variable length encoding for storing all possible topology configurations
+// during traversal of mesh's surface. The configurations are based on visited
+// state of neighboring triangles around a currently processed face corner.
+// Note that about half of the encountered configurations is expected to be of
+// type TOPOLOGY_C. It's guaranteed that the encoding will use at most 2 bits
+// per triangle for meshes with no holes and up to 6 bits per triangle for
+// general meshes. In addition, the encoding will take up to 4 bits per triangle
+// for each non-position attribute attached to the mesh.
+//
+//     *-------*          *-------*          *-------*
+//    / \     / \        / \     / \        / \     / \
+//   /   \   /   \      /   \   /   \      /   \   /   \
+//  /     \ /     \    /     \ /     \    /     \ /     \
+// *-------v-------*  *-------v-------*  *-------v-------*
+//  \     /x\     /          /x\     /    \     /x\
+//   \   /   \   /          /   \   /      \   /   \
+//    \ /  C  \ /          /  L  \ /        \ /  R  \
+//     *-------*          *-------*          *-------*
+//
+//     *       *
+//    / \     / \
+//   /   \   /   \
+//  /     \ /     \
+// *-------v-------*          v
+//  \     /x\     /          /x\
+//   \   /   \   /          /   \
+//    \ /  S  \ /          /  E  \
+//     *-------*          *-------*
+//
+// TODO(ostava): Get rid of the topology bit pattern. It's important only for
+// encoding but the algorithms should use EdgebreakerSymbol instead.
+enum EdgebreakerTopologyBitPattern {
+  TOPOLOGY_C = 0x0,  // 0
+  TOPOLOGY_S = 0x1,  // 1 0 0
+  TOPOLOGY_L = 0x3,  // 1 1 0
+  TOPOLOGY_R = 0x5,  // 1 0 1
+  TOPOLOGY_E = 0x7,  // 1 1 1
+  // A special symbol that's not actually encoded, but it can be used to mark
+  // the initial face that triggers the mesh encoding of a single connected
+  // component.
+  TOPOLOGY_INIT_FACE,
+  // A special value used to indicate an invalid symbol.
+  TOPOLOGY_INVALID
+};
+
+enum EdgebreakerSymbol {
+  EDGEBREAKER_SYMBOL_C = 0,
+  EDGEBREAKER_SYMBOL_S,
+  EDGEBREAKER_SYMBOL_L,
+  EDGEBREAKER_SYMBOL_R,
+  EDGEBREAKER_SYMBOL_E,
+  EDGEBREAKER_SYMBOL_INVALID
+};
+
+// Bit-length of symbols in the EdgebreakerTopologyBitPattern stored as a
+// lookup table for faster indexing.
+constexpr int32_t edge_breaker_topology_bit_pattern_length[] = {1, 3, 0, 3,
+                                                                0, 3, 0, 3};
+
+// Zero-indexed symbol id for each of topology pattern.
+constexpr EdgebreakerSymbol edge_breaker_topology_to_symbol_id[] = {
+    EDGEBREAKER_SYMBOL_C,       EDGEBREAKER_SYMBOL_S,
+    EDGEBREAKER_SYMBOL_INVALID, EDGEBREAKER_SYMBOL_L,
+    EDGEBREAKER_SYMBOL_INVALID, EDGEBREAKER_SYMBOL_R,
+    EDGEBREAKER_SYMBOL_INVALID, EDGEBREAKER_SYMBOL_E};
+
+// Reverse mapping between symbol id and topology pattern symbol.
+constexpr EdgebreakerTopologyBitPattern edge_breaker_symbol_to_topology_id[] = {
+    TOPOLOGY_C, TOPOLOGY_S, TOPOLOGY_L, TOPOLOGY_R, TOPOLOGY_E};
+
+// Types of edges used during mesh traversal relative to the tip vertex of a
+// visited triangle.
+enum EdgeFaceName : uint8_t { LEFT_FACE_EDGE = 0, RIGHT_FACE_EDGE = 1 };
+
+// Struct used for storing data about a source face that connects to an
+// already traversed face that was either the initial face or a face encoded
+// with either topology S (split) symbol. Such connection can be only caused by
+// topology changes on the traversed surface (if its genus != 0, i.e. when the
+// surface has topological handles or holes).
+// For each occurrence of such event we always encode the split symbol id,
+// source symbol id and source edge id (left, or right). There will be always
+// exactly two occurrences of this event for every topological handle on the
+// traversed mesh and one occurrence for a hole.
+struct TopologySplitEventData {
+  uint32_t split_symbol_id;
+  uint32_t source_symbol_id;
+  // We need to use uint32_t instead of EdgeFaceName because the most recent
+  // version of gcc does not allow that when optimizations are turned on.
+  uint32_t source_edge : 1;
+};
+
+// Hole event is used to store info about the first symbol that reached a
+// vertex of so far unvisited hole. This can happen only on either the initial
+// face or during a regular traversal when TOPOLOGY_S is encountered.
+struct HoleEventData {
+  int32_t symbol_id;
+  HoleEventData() : symbol_id(0) {}
+  explicit HoleEventData(int32_t sym_id) : symbol_id(sym_id) {}
+};
+
+// List of supported modes for valence based edgebreaker coding.
+enum EdgebreakerValenceCodingMode {
+  EDGEBREAKER_VALENCE_MODE_2_7 = 0,  // Use contexts for valences in range 2-7.
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_SHARED_H_
diff --git a/engine/inc/draco/compression/mesh/mesh_edgebreaker_traversal_decoder.h b/engine/inc/draco/compression/mesh/mesh_edgebreaker_traversal_decoder.h
new file mode 100644
index 00000000..ce91adc8
--- /dev/null
+++ b/engine/inc/draco/compression/mesh/mesh_edgebreaker_traversal_decoder.h
@@ -0,0 +1,201 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_DECODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_DECODER_H_
+
+#include "draco/compression/bit_coders/rans_bit_decoder.h"
+#include "draco/compression/mesh/mesh_edgebreaker_decoder.h"
+#include "draco/compression/mesh/mesh_edgebreaker_decoder_impl_interface.h"
+#include "draco/compression/mesh/mesh_edgebreaker_shared.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+typedef RAnsBitDecoder BinaryDecoder;
+
+// Default implementation of the edgebreaker traversal decoder that reads the
+// traversal data directly from a buffer.
+class MeshEdgebreakerTraversalDecoder {
+ public:
+  MeshEdgebreakerTraversalDecoder()
+      : attribute_connectivity_decoders_(nullptr),
+        num_attribute_data_(0),
+        decoder_impl_(nullptr) {}
+  void Init(MeshEdgebreakerDecoderImplInterface *decoder) {
+    decoder_impl_ = decoder;
+    buffer_.Init(decoder->GetDecoder()->buffer()->data_head(),
+                 decoder->GetDecoder()->buffer()->remaining_size(),
+                 decoder->GetDecoder()->buffer()->bitstream_version());
+  }
+
+  // Returns the Draco bitstream version.
+  uint16_t BitstreamVersion() const {
+    return decoder_impl_->GetDecoder()->bitstream_version();
+  }
+
+  // Used to tell the decoder what is the number of expected decoded vertices.
+  // Ignored by default.
+  void SetNumEncodedVertices(int /* num_vertices */) {}
+
+  // Set the number of non-position attribute data for which we need to decode
+  // the connectivity.
+  void SetNumAttributeData(int num_data) { num_attribute_data_ = num_data; }
+
+  // Called before the traversal decoding is started.
+  // Returns a buffer decoder that points to data that was encoded after the
+  // traversal.
+  bool Start(DecoderBuffer *out_buffer) {
+    // Decode symbols from the main buffer decoder and face configurations from
+    // the start_face_buffer decoder.
+    if (!DecodeTraversalSymbols()) {
+      return false;
+    }
+
+    if (!DecodeStartFaces()) {
+      return false;
+    }
+
+    if (!DecodeAttributeSeams()) {
+      return false;
+    }
+    *out_buffer = buffer_;
+    return true;
+  }
+
+  // Returns the configuration of a new initial face.
+  inline bool DecodeStartFaceConfiguration() {
+    uint32_t face_configuration;
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+    if (buffer_.bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+      start_face_buffer_.DecodeLeastSignificantBits32(1, &face_configuration);
+
+    } else
+#endif
+    {
+      face_configuration = start_face_decoder_.DecodeNextBit();
+    }
+    return face_configuration;
+  }
+
+  // Returns the next edgebreaker symbol that was reached during the traversal.
+  inline uint32_t DecodeSymbol() {
+    uint32_t symbol;
+    symbol_buffer_.DecodeLeastSignificantBits32(1, &symbol);
+    if (symbol == TOPOLOGY_C) {
+      return symbol;
+    }
+    // Else decode two additional bits.
+    uint32_t symbol_suffix;
+    symbol_buffer_.DecodeLeastSignificantBits32(2, &symbol_suffix);
+    symbol |= (symbol_suffix << 1);
+    return symbol;
+  }
+
+  // Called whenever a new active corner is set in the decoder.
+  inline void NewActiveCornerReached(CornerIndex /* corner */) {}
+
+  // Called whenever |source| vertex is about to be merged into the |dest|
+  // vertex.
+  inline void MergeVertices(VertexIndex /* dest */, VertexIndex /* source */) {}
+
+  // Returns true if there is an attribute seam for the next processed pair
+  // of visited faces.
+  // |attribute| is used to mark the id of the non-position attribute (in range
+  // of <0, num_attributes - 1>).
+  inline bool DecodeAttributeSeam(int attribute) {
+    return attribute_connectivity_decoders_[attribute].DecodeNextBit();
+  }
+
+  // Called when the traversal is finished.
+  void Done() {
+    if (symbol_buffer_.bit_decoder_active()) {
+      symbol_buffer_.EndBitDecoding();
+    }
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+    if (buffer_.bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+      start_face_buffer_.EndBitDecoding();
+
+    } else
+#endif
+    {
+      start_face_decoder_.EndDecoding();
+    }
+  }
+
+ protected:
+  DecoderBuffer *buffer() { return &buffer_; }
+
+  bool DecodeTraversalSymbols() {
+    uint64_t traversal_size;
+    symbol_buffer_ = buffer_;
+    if (!symbol_buffer_.StartBitDecoding(true, &traversal_size)) {
+      return false;
+    }
+    buffer_ = symbol_buffer_;
+    if (traversal_size > static_cast<uint64_t>(buffer_.remaining_size())) {
+      return false;
+    }
+    buffer_.Advance(traversal_size);
+    return true;
+  }
+
+  bool DecodeStartFaces() {
+    // Create a decoder that is set to the end of the encoded traversal data.
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+    if (buffer_.bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+      start_face_buffer_ = buffer_;
+      uint64_t traversal_size;
+      if (!start_face_buffer_.StartBitDecoding(true, &traversal_size)) {
+        return false;
+      }
+      buffer_ = start_face_buffer_;
+      if (traversal_size > static_cast<uint64_t>(buffer_.remaining_size())) {
+        return false;
+      }
+      buffer_.Advance(traversal_size);
+      return true;
+    }
+#endif
+    return start_face_decoder_.StartDecoding(&buffer_);
+  }
+
+  bool DecodeAttributeSeams() {
+    // Prepare attribute decoding.
+    if (num_attribute_data_ > 0) {
+      attribute_connectivity_decoders_ = std::unique_ptr<BinaryDecoder[]>(
+          new BinaryDecoder[num_attribute_data_]);
+      for (int i = 0; i < num_attribute_data_; ++i) {
+        if (!attribute_connectivity_decoders_[i].StartDecoding(&buffer_)) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+ private:
+  // Buffer that contains the encoded data.
+  DecoderBuffer buffer_;
+  DecoderBuffer symbol_buffer_;
+  BinaryDecoder start_face_decoder_;
+  DecoderBuffer start_face_buffer_;
+  std::unique_ptr<BinaryDecoder[]> attribute_connectivity_decoders_;
+  int num_attribute_data_;
+  const MeshEdgebreakerDecoderImplInterface *decoder_impl_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_DECODER_H_
diff --git a/engine/inc/draco/compression/mesh/mesh_edgebreaker_traversal_encoder.h b/engine/inc/draco/compression/mesh/mesh_edgebreaker_traversal_encoder.h
new file mode 100644
index 00000000..08cb66e4
--- /dev/null
+++ b/engine/inc/draco/compression/mesh/mesh_edgebreaker_traversal_encoder.h
@@ -0,0 +1,139 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_ENCODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_ENCODER_H_
+
+#include "draco/compression/bit_coders/rans_bit_encoder.h"
+#include "draco/compression/mesh/mesh_edgebreaker_encoder.h"
+#include "draco/compression/mesh/mesh_edgebreaker_encoder_impl_interface.h"
+#include "draco/core/macros.h"
+
+namespace draco {
+
+typedef RAnsBitEncoder BinaryEncoder;
+
+// Default implementation of the edgebreaker traversal encoder. Face
+// configurations are stored directly into the output buffer and the symbols
+// are first collected and then encoded in the reverse order to make the
+// decoding faster.
+class MeshEdgebreakerTraversalEncoder {
+ public:
+  MeshEdgebreakerTraversalEncoder()
+      : encoder_impl_(nullptr),
+        attribute_connectivity_encoders_(nullptr),
+        num_attribute_data_(0) {}
+  bool Init(MeshEdgebreakerEncoderImplInterface *encoder) {
+    encoder_impl_ = encoder;
+    return true;
+  }
+
+  // Set the number of non-position attribute data for which we need to encode
+  // the connectivity.
+  void SetNumAttributeData(int num_data) { num_attribute_data_ = num_data; }
+
+  // Called before the traversal encoding is started.
+  void Start() {
+    start_face_encoder_.StartEncoding();
+    if (num_attribute_data_ > 0) {
+      // Init and start arithmetic encoders for storing configuration types
+      // of non-position attributes.
+      attribute_connectivity_encoders_ = std::unique_ptr<BinaryEncoder[]>(
+          new BinaryEncoder[num_attribute_data_]);
+      for (int i = 0; i < num_attribute_data_; ++i) {
+        attribute_connectivity_encoders_[i].StartEncoding();
+      }
+    }
+  }
+
+  // Called when a traversal starts from a new initial face.
+  inline void EncodeStartFaceConfiguration(bool interior) {
+    start_face_encoder_.EncodeBit(interior);
+  }
+
+  // Called when a new corner is reached during the traversal. No-op for the
+  // default encoder.
+  inline void NewCornerReached(CornerIndex /* corner */) {}
+
+  // Called whenever a new symbol is reached during the edgebreaker traversal.
+  inline void EncodeSymbol(EdgebreakerTopologyBitPattern symbol) {
+    // Store the symbol. It will be encoded after all symbols are processed.
+    symbols_.push_back(symbol);
+  }
+
+  // Called for every pair of connected and visited faces. |is_seam| specifies
+  // whether there is an attribute seam between the two faces.
+
+  inline void EncodeAttributeSeam(int attribute, bool is_seam) {
+    attribute_connectivity_encoders_[attribute].EncodeBit(is_seam ? 1 : 0);
+  }
+
+  // Called when the traversal is finished.
+  void Done() {
+    EncodeTraversalSymbols();
+    EncodeStartFaces();
+    EncodeAttributeSeams();
+  }
+
+  // Returns the number of encoded symbols.
+  int NumEncodedSymbols() const { return static_cast<int>(symbols_.size()); }
+
+  const EncoderBuffer &buffer() const { return traversal_buffer_; }
+
+ protected:
+  void EncodeTraversalSymbols() {
+    // Bit encode the collected symbols.
+    // Allocate enough storage for the bit encoder.
+    // It's guaranteed that each face will need only up to 3 bits.
+    traversal_buffer_.StartBitEncoding(
+        encoder_impl_->GetEncoder()->mesh()->num_faces() * 3, true);
+    for (int i = static_cast<int>(symbols_.size() - 1); i >= 0; --i) {
+      traversal_buffer_.EncodeLeastSignificantBits32(
+          edge_breaker_topology_bit_pattern_length[symbols_[i]], symbols_[i]);
+    }
+    traversal_buffer_.EndBitEncoding();
+  }
+
+  void EncodeStartFaces() {
+    start_face_encoder_.EndEncoding(&traversal_buffer_);
+  }
+
+  void EncodeAttributeSeams() {
+    if (attribute_connectivity_encoders_ != nullptr) {
+      for (int i = 0; i < num_attribute_data_; ++i) {
+        attribute_connectivity_encoders_[i].EndEncoding(&traversal_buffer_);
+      }
+    }
+  }
+
+  EncoderBuffer *GetOutputBuffer() { return &traversal_buffer_; }
+  const MeshEdgebreakerEncoderImplInterface *encoder_impl() const {
+    return encoder_impl_;
+  }
+
+ private:
+  BinaryEncoder start_face_encoder_;
+  EncoderBuffer traversal_buffer_;
+  const MeshEdgebreakerEncoderImplInterface *encoder_impl_;
+  // Symbols collected during the traversal.
+  std::vector<EdgebreakerTopologyBitPattern> symbols_;
+  // Arithmetic encoder for encoding attribute seams.
+  // One context for each non-position attribute.
+  std::unique_ptr<BinaryEncoder[]> attribute_connectivity_encoders_;
+  int num_attribute_data_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_ENCODER_H_
diff --git a/engine/inc/draco/compression/mesh/mesh_edgebreaker_traversal_predictive_decoder.h b/engine/inc/draco/compression/mesh/mesh_edgebreaker_traversal_predictive_decoder.h
new file mode 100644
index 00000000..3f900458
--- /dev/null
+++ b/engine/inc/draco/compression/mesh/mesh_edgebreaker_traversal_predictive_decoder.h
@@ -0,0 +1,134 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_PREDICTIVE_DECODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_PREDICTIVE_DECODER_H_
+
+#include "draco/compression/mesh/mesh_edgebreaker_traversal_decoder.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Decoder for traversal encoded with the
+// MeshEdgebreakerTraversalPredictiveEncoder. The decoder maintains valences
+// of the decoded portion of the traversed mesh and it uses them to predict
+// symbols that are about to be decoded.
+class MeshEdgebreakerTraversalPredictiveDecoder
+    : public MeshEdgebreakerTraversalDecoder {
+ public:
+  MeshEdgebreakerTraversalPredictiveDecoder()
+      : corner_table_(nullptr),
+        num_vertices_(0),
+        last_symbol_(-1),
+        predicted_symbol_(-1) {}
+  void Init(MeshEdgebreakerDecoderImplInterface *decoder) {
+    MeshEdgebreakerTraversalDecoder::Init(decoder);
+    corner_table_ = decoder->GetCornerTable();
+  }
+  void SetNumEncodedVertices(int num_vertices) { num_vertices_ = num_vertices; }
+
+  bool Start(DecoderBuffer *out_buffer) {
+    if (!MeshEdgebreakerTraversalDecoder::Start(out_buffer)) {
+      return false;
+    }
+    int32_t num_split_symbols;
+    if (!out_buffer->Decode(&num_split_symbols) || num_split_symbols < 0)
+      return false;
+    if (num_split_symbols >= num_vertices_) {
+      return false;
+    }
+    // Set the valences of all initial vertices to 0.
+    vertex_valences_.resize(num_vertices_, 0);
+    if (!prediction_decoder_.StartDecoding(out_buffer)) {
+      return false;
+    }
+    return true;
+  }
+
+  inline uint32_t DecodeSymbol() {
+    // First check if we have a predicted symbol.
+    if (predicted_symbol_ != -1) {
+      // Double check that the predicted symbol was predicted correctly.
+      if (prediction_decoder_.DecodeNextBit()) {
+        last_symbol_ = predicted_symbol_;
+        return predicted_symbol_;
+      }
+    }
+    // We don't have a predicted symbol or the symbol was mis-predicted.
+    // Decode it directly.
+    last_symbol_ = MeshEdgebreakerTraversalDecoder::DecodeSymbol();
+    return last_symbol_;
+  }
+
+  inline void NewActiveCornerReached(CornerIndex corner) {
+    const CornerIndex next = corner_table_->Next(corner);
+    const CornerIndex prev = corner_table_->Previous(corner);
+    // Update valences.
+    switch (last_symbol_) {
+      case TOPOLOGY_C:
+      case TOPOLOGY_S:
+        vertex_valences_[corner_table_->Vertex(next).value()] += 1;
+        vertex_valences_[corner_table_->Vertex(prev).value()] += 1;
+        break;
+      case TOPOLOGY_R:
+        vertex_valences_[corner_table_->Vertex(corner).value()] += 1;
+        vertex_valences_[corner_table_->Vertex(next).value()] += 1;
+        vertex_valences_[corner_table_->Vertex(prev).value()] += 2;
+        break;
+      case TOPOLOGY_L:
+        vertex_valences_[corner_table_->Vertex(corner).value()] += 1;
+        vertex_valences_[corner_table_->Vertex(next).value()] += 2;
+        vertex_valences_[corner_table_->Vertex(prev).value()] += 1;
+        break;
+      case TOPOLOGY_E:
+        vertex_valences_[corner_table_->Vertex(corner).value()] += 2;
+        vertex_valences_[corner_table_->Vertex(next).value()] += 2;
+        vertex_valences_[corner_table_->Vertex(prev).value()] += 2;
+        break;
+      default:
+        break;
+    }
+    // Compute the new predicted symbol.
+    if (last_symbol_ == TOPOLOGY_C || last_symbol_ == TOPOLOGY_R) {
+      const VertexIndex pivot =
+          corner_table_->Vertex(corner_table_->Next(corner));
+      if (vertex_valences_[pivot.value()] < 6) {
+        predicted_symbol_ = TOPOLOGY_R;
+      } else {
+        predicted_symbol_ = TOPOLOGY_C;
+      }
+    } else {
+      predicted_symbol_ = -1;
+    }
+  }
+
+  inline void MergeVertices(VertexIndex dest, VertexIndex source) {
+    // Update valences on the merged vertices.
+    vertex_valences_[dest.value()] += vertex_valences_[source.value()];
+  }
+
+ private:
+  const CornerTable *corner_table_;
+  int num_vertices_;
+  std::vector<int> vertex_valences_;
+  BinaryDecoder prediction_decoder_;
+  int last_symbol_;
+  int predicted_symbol_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_PREDICTIVE_DECODER_H_
+#endif
diff --git a/engine/inc/draco/compression/mesh/mesh_edgebreaker_traversal_predictive_encoder.h b/engine/inc/draco/compression/mesh/mesh_edgebreaker_traversal_predictive_encoder.h
new file mode 100644
index 00000000..eb937fe8
--- /dev/null
+++ b/engine/inc/draco/compression/mesh/mesh_edgebreaker_traversal_predictive_encoder.h
@@ -0,0 +1,172 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_PREDICTIVE_ENCODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_PREDICTIVE_ENCODER_H_
+
+#include "draco/compression/mesh/mesh_edgebreaker_traversal_encoder.h"
+
+namespace draco {
+
+// Encoder that tries to predict the edgebreaker traversal symbols based on the
+// vertex valences of the unencoded portion of the mesh. The current prediction
+// scheme assumes that each vertex has valence 6 which can be used to predict
+// the symbol preceding the one that is currently encoded. Predictions are
+// encoded using an arithmetic coding which can lead to less than 1 bit per
+// triangle encoding for highly regular meshes.
+class MeshEdgebreakerTraversalPredictiveEncoder
+    : public MeshEdgebreakerTraversalEncoder {
+ public:
+  MeshEdgebreakerTraversalPredictiveEncoder()
+      : corner_table_(nullptr),
+        prev_symbol_(-1),
+        num_split_symbols_(0),
+        last_corner_(kInvalidCornerIndex),
+        num_symbols_(0) {}
+
+  bool Init(MeshEdgebreakerEncoderImplInterface *encoder) {
+    if (!MeshEdgebreakerTraversalEncoder::Init(encoder)) {
+      return false;
+    }
+    corner_table_ = encoder->GetCornerTable();
+    // Initialize valences of all vertices.
+    vertex_valences_.resize(corner_table_->num_vertices());
+    for (uint32_t i = 0; i < vertex_valences_.size(); ++i) {
+      vertex_valences_[i] = corner_table_->Valence(VertexIndex(i));
+    }
+    return true;
+  }
+
+  inline void NewCornerReached(CornerIndex corner) { last_corner_ = corner; }
+
+  inline int32_t ComputePredictedSymbol(VertexIndex pivot) {
+    const int valence = vertex_valences_[pivot.value()];
+    if (valence < 0) {
+      // This situation can happen only for split vertices. Returning
+      // TOPOLOGY_INVALID always cases misprediction.
+      return TOPOLOGY_INVALID;
+    }
+    if (valence < 6) {
+      return TOPOLOGY_R;
+    }
+    return TOPOLOGY_C;
+  }
+
+  inline void EncodeSymbol(EdgebreakerTopologyBitPattern symbol) {
+    ++num_symbols_;
+    // Update valences on the mesh. And compute the predicted preceding symbol.
+    // Note that the valences are computed for the so far unencoded part of the
+    // mesh. Adding a new symbol either reduces valences on the vertices or
+    // leaves the valence unchanged.
+    int32_t predicted_symbol = -1;
+    const CornerIndex next = corner_table_->Next(last_corner_);
+    const CornerIndex prev = corner_table_->Previous(last_corner_);
+    switch (symbol) {
+      case TOPOLOGY_C:
+        // Compute prediction.
+        predicted_symbol = ComputePredictedSymbol(corner_table_->Vertex(next));
+        FALLTHROUGH_INTENDED;
+      case TOPOLOGY_S:
+        // Update valences.
+        vertex_valences_[corner_table_->Vertex(next).value()] -= 1;
+        vertex_valences_[corner_table_->Vertex(prev).value()] -= 1;
+        if (symbol == TOPOLOGY_S) {
+          // Whenever we reach a split symbol, mark its tip vertex as invalid by
+          // setting the valence to a negative value. Any prediction that will
+          // use this vertex will then cause a misprediction. This is currently
+          // necessary because the decoding works in the reverse direction and
+          // the decoder doesn't know about these vertices until the split
+          // symbol is decoded at which point two vertices are merged into one.
+          // This can be most likely solved on the encoder side by splitting the
+          // tip vertex into two, but since split symbols are relatively rare,
+          // it's probably not worth doing it.
+          vertex_valences_[corner_table_->Vertex(last_corner_).value()] = -1;
+          ++num_split_symbols_;
+        }
+        break;
+      case TOPOLOGY_R:
+        // Compute prediction.
+        predicted_symbol = ComputePredictedSymbol(corner_table_->Vertex(next));
+        // Update valences.
+        vertex_valences_[corner_table_->Vertex(last_corner_).value()] -= 1;
+        vertex_valences_[corner_table_->Vertex(next).value()] -= 1;
+        vertex_valences_[corner_table_->Vertex(prev).value()] -= 2;
+        break;
+      case TOPOLOGY_L:
+        vertex_valences_[corner_table_->Vertex(last_corner_).value()] -= 1;
+        vertex_valences_[corner_table_->Vertex(next).value()] -= 2;
+        vertex_valences_[corner_table_->Vertex(prev).value()] -= 1;
+        break;
+      case TOPOLOGY_E:
+        vertex_valences_[corner_table_->Vertex(last_corner_).value()] -= 2;
+        vertex_valences_[corner_table_->Vertex(next).value()] -= 2;
+        vertex_valences_[corner_table_->Vertex(prev).value()] -= 2;
+        break;
+      default:
+        break;
+    }
+    // Flag used when it's necessary to explicitly store the previous symbol.
+    bool store_prev_symbol = true;
+    if (predicted_symbol != -1) {
+      if (predicted_symbol == prev_symbol_) {
+        predictions_.push_back(true);
+        store_prev_symbol = false;
+      } else if (prev_symbol_ != -1) {
+        predictions_.push_back(false);
+      }
+    }
+    if (store_prev_symbol && prev_symbol_ != -1) {
+      MeshEdgebreakerTraversalEncoder::EncodeSymbol(
+          static_cast<EdgebreakerTopologyBitPattern>(prev_symbol_));
+    }
+    prev_symbol_ = symbol;
+  }
+
+  void Done() {
+    // We still need to store the last encoded symbol.
+    if (prev_symbol_ != -1) {
+      MeshEdgebreakerTraversalEncoder::EncodeSymbol(
+          static_cast<EdgebreakerTopologyBitPattern>(prev_symbol_));
+    }
+    // Store the init face configurations and the explicitly encoded symbols.
+    MeshEdgebreakerTraversalEncoder::Done();
+    // Encode the number of split symbols.
+    GetOutputBuffer()->Encode(num_split_symbols_);
+    // Store the predictions.
+    BinaryEncoder prediction_encoder;
+    prediction_encoder.StartEncoding();
+    for (int i = static_cast<int>(predictions_.size()) - 1; i >= 0; --i) {
+      prediction_encoder.EncodeBit(predictions_[i]);
+    }
+    prediction_encoder.EndEncoding(GetOutputBuffer());
+  }
+
+  int NumEncodedSymbols() const { return num_symbols_; }
+
+ private:
+  const CornerTable *corner_table_;
+  std::vector<int> vertex_valences_;
+  std::vector<bool> predictions_;
+  // Previously encoded symbol.
+  int32_t prev_symbol_;
+  // The total number of encoded split symbols.
+  int32_t num_split_symbols_;
+  CornerIndex last_corner_;
+  // Explicitly count the number of encoded symbols.
+  int num_symbols_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_PREDICTIVE_ENCODER_H_
diff --git a/engine/inc/draco/compression/mesh/mesh_edgebreaker_traversal_valence_decoder.h b/engine/inc/draco/compression/mesh/mesh_edgebreaker_traversal_valence_decoder.h
new file mode 100644
index 00000000..c0037372
--- /dev/null
+++ b/engine/inc/draco/compression/mesh/mesh_edgebreaker_traversal_valence_decoder.h
@@ -0,0 +1,215 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_VALENCE_DECODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_VALENCE_DECODER_H_
+
+#include "draco/compression/entropy/symbol_decoding.h"
+#include "draco/compression/mesh/mesh_edgebreaker_traversal_decoder.h"
+#include "draco/core/varint_decoding.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Decoder for traversal encoded with MeshEdgebreakerTraversalValenceEncoder.
+// The decoder maintains valences of the decoded portion of the traversed mesh
+// and it uses them to select entropy context used for decoding of the actual
+// symbols.
+class MeshEdgebreakerTraversalValenceDecoder
+    : public MeshEdgebreakerTraversalDecoder {
+ public:
+  MeshEdgebreakerTraversalValenceDecoder()
+      : corner_table_(nullptr),
+        num_vertices_(0),
+        last_symbol_(-1),
+        active_context_(-1),
+        min_valence_(2),
+        max_valence_(7) {}
+  void Init(MeshEdgebreakerDecoderImplInterface *decoder) {
+    MeshEdgebreakerTraversalDecoder::Init(decoder);
+    corner_table_ = decoder->GetCornerTable();
+  }
+  void SetNumEncodedVertices(int num_vertices) { num_vertices_ = num_vertices; }
+
+  bool Start(DecoderBuffer *out_buffer) {
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+    if (BitstreamVersion() < DRACO_BITSTREAM_VERSION(2, 2)) {
+      if (!MeshEdgebreakerTraversalDecoder::DecodeTraversalSymbols()) {
+        return false;
+      }
+    }
+#endif
+    if (!MeshEdgebreakerTraversalDecoder::DecodeStartFaces()) {
+      return false;
+    }
+    if (!MeshEdgebreakerTraversalDecoder::DecodeAttributeSeams()) {
+      return false;
+    }
+    *out_buffer = *buffer();
+
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+    if (BitstreamVersion() < DRACO_BITSTREAM_VERSION(2, 2)) {
+      uint32_t num_split_symbols;
+      if (BitstreamVersion() < DRACO_BITSTREAM_VERSION(2, 0)) {
+        if (!out_buffer->Decode(&num_split_symbols)) {
+          return false;
+        }
+      } else {
+        if (!DecodeVarint(&num_split_symbols, out_buffer)) {
+          return false;
+        }
+      }
+      if (num_split_symbols >= static_cast<uint32_t>(num_vertices_)) {
+        return false;
+      }
+
+      int8_t mode;
+      if (!out_buffer->Decode(&mode)) {
+        return false;
+      }
+      if (mode == EDGEBREAKER_VALENCE_MODE_2_7) {
+        min_valence_ = 2;
+        max_valence_ = 7;
+      } else {
+        // Unsupported mode.
+        return false;
+      }
+
+    } else
+#endif
+    {
+      min_valence_ = 2;
+      max_valence_ = 7;
+    }
+
+    if (num_vertices_ < 0) {
+      return false;
+    }
+    // Set the valences of all initial vertices to 0.
+    vertex_valences_.resize(num_vertices_, 0);
+
+    const int num_unique_valences = max_valence_ - min_valence_ + 1;
+
+    // Decode all symbols for all contexts.
+    context_symbols_.resize(num_unique_valences);
+    context_counters_.resize(context_symbols_.size());
+    for (int i = 0; i < context_symbols_.size(); ++i) {
+      uint32_t num_symbols;
+      if (!DecodeVarint<uint32_t>(&num_symbols, out_buffer)) {
+        return false;
+      }
+      if (num_symbols > static_cast<uint32_t>(corner_table_->num_faces())) {
+        return false;
+      }
+      if (num_symbols > 0) {
+        context_symbols_[i].resize(num_symbols);
+        DecodeSymbols(num_symbols, 1, out_buffer, context_symbols_[i].data());
+        // All symbols are going to be processed from the back.
+        context_counters_[i] = num_symbols;
+      }
+    }
+    return true;
+  }
+
+  inline uint32_t DecodeSymbol() {
+    // First check if we have a valid context.
+    if (active_context_ != -1) {
+      const int context_counter = --context_counters_[active_context_];
+      if (context_counter < 0) {
+        return TOPOLOGY_INVALID;
+      }
+      const int symbol_id = context_symbols_[active_context_][context_counter];
+      last_symbol_ = edge_breaker_symbol_to_topology_id[symbol_id];
+    } else {
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+      if (BitstreamVersion() < DRACO_BITSTREAM_VERSION(2, 2)) {
+        // We don't have a predicted symbol or the symbol was mis-predicted.
+        // Decode it directly.
+        last_symbol_ = MeshEdgebreakerTraversalDecoder::DecodeSymbol();
+
+      } else
+#endif
+      {
+        // The first symbol must be E.
+        last_symbol_ = TOPOLOGY_E;
+      }
+    }
+    return last_symbol_;
+  }
+
+  inline void NewActiveCornerReached(CornerIndex corner) {
+    const CornerIndex next = corner_table_->Next(corner);
+    const CornerIndex prev = corner_table_->Previous(corner);
+    // Update valences.
+    switch (last_symbol_) {
+      case TOPOLOGY_C:
+      case TOPOLOGY_S:
+        vertex_valences_[corner_table_->Vertex(next)] += 1;
+        vertex_valences_[corner_table_->Vertex(prev)] += 1;
+        break;
+      case TOPOLOGY_R:
+        vertex_valences_[corner_table_->Vertex(corner)] += 1;
+        vertex_valences_[corner_table_->Vertex(next)] += 1;
+        vertex_valences_[corner_table_->Vertex(prev)] += 2;
+        break;
+      case TOPOLOGY_L:
+        vertex_valences_[corner_table_->Vertex(corner)] += 1;
+        vertex_valences_[corner_table_->Vertex(next)] += 2;
+        vertex_valences_[corner_table_->Vertex(prev)] += 1;
+        break;
+      case TOPOLOGY_E:
+        vertex_valences_[corner_table_->Vertex(corner)] += 2;
+        vertex_valences_[corner_table_->Vertex(next)] += 2;
+        vertex_valences_[corner_table_->Vertex(prev)] += 2;
+        break;
+      default:
+        break;
+    }
+    // Compute the new context that is going to be used to decode the next
+    // symbol.
+    const int active_valence = vertex_valences_[corner_table_->Vertex(next)];
+    int clamped_valence;
+    if (active_valence < min_valence_) {
+      clamped_valence = min_valence_;
+    } else if (active_valence > max_valence_) {
+      clamped_valence = max_valence_;
+    } else {
+      clamped_valence = active_valence;
+    }
+
+    active_context_ = (clamped_valence - min_valence_);
+  }
+
+  inline void MergeVertices(VertexIndex dest, VertexIndex source) {
+    // Update valences on the merged vertices.
+    vertex_valences_[dest] += vertex_valences_[source];
+  }
+
+ private:
+  const CornerTable *corner_table_;
+  int num_vertices_;
+  IndexTypeVector<VertexIndex, int> vertex_valences_;
+  int last_symbol_;
+  int active_context_;
+
+  int min_valence_;
+  int max_valence_;
+  std::vector<std::vector<uint32_t>> context_symbols_;
+  // Points to the active symbol in each context.
+  std::vector<int> context_counters_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_VALENCE_DECODER_H_
diff --git a/engine/inc/draco/compression/mesh/mesh_edgebreaker_traversal_valence_encoder.h b/engine/inc/draco/compression/mesh/mesh_edgebreaker_traversal_valence_encoder.h
new file mode 100644
index 00000000..c492c84b
--- /dev/null
+++ b/engine/inc/draco/compression/mesh/mesh_edgebreaker_traversal_valence_encoder.h
@@ -0,0 +1,226 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_VALENCE_ENCODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_VALENCE_ENCODER_H_
+
+#include "draco/compression/entropy/symbol_encoding.h"
+#include "draco/compression/mesh/mesh_edgebreaker_traversal_encoder.h"
+#include "draco/core/varint_encoding.h"
+
+namespace draco {
+
+// Predictive encoder for the Edgebreaker symbols based on valences of the
+// previously encoded vertices, following the method described in: Szymczak'02,
+// "Optimized Edgebreaker Encoding for Large and Regular Triangle Meshes". Each
+// valence is used to specify a different entropy context for encoding of the
+// symbols.
+// Encoder can operate in various predefined modes that can be used to select
+// the way in which the entropy contexts are computed (e.g. using different
+// clamping for valences, or even using different inputs to compute the
+// contexts), see EdgebreakerValenceCodingMode in mesh_edgebreaker_shared.h for
+// a list of supported modes.
+class MeshEdgebreakerTraversalValenceEncoder
+    : public MeshEdgebreakerTraversalEncoder {
+ public:
+  MeshEdgebreakerTraversalValenceEncoder()
+      : corner_table_(nullptr),
+        prev_symbol_(-1),
+        last_corner_(kInvalidCornerIndex),
+        num_symbols_(0),
+        min_valence_(2),
+        max_valence_(7) {}
+
+  bool Init(MeshEdgebreakerEncoderImplInterface *encoder) {
+    if (!MeshEdgebreakerTraversalEncoder::Init(encoder)) {
+      return false;
+    }
+    min_valence_ = 2;
+    max_valence_ = 7;
+    corner_table_ = encoder->GetCornerTable();
+
+    // Initialize valences of all vertices.
+    vertex_valences_.resize(corner_table_->num_vertices());
+    for (VertexIndex i(0); i < static_cast<uint32_t>(vertex_valences_.size());
+         ++i) {
+      vertex_valences_[i] = corner_table_->Valence(VertexIndex(i));
+    }
+
+    // Replicate the corner to vertex map from the corner table. We need to do
+    // this because the map may get updated during encoding because we add new
+    // vertices when we encounter split symbols.
+    corner_to_vertex_map_.resize(corner_table_->num_corners());
+    for (CornerIndex i(0); i < corner_table_->num_corners(); ++i) {
+      corner_to_vertex_map_[i] = corner_table_->Vertex(i);
+    }
+    const int32_t num_unique_valences = max_valence_ - min_valence_ + 1;
+
+    context_symbols_.resize(num_unique_valences);
+    return true;
+  }
+
+  inline void NewCornerReached(CornerIndex corner) { last_corner_ = corner; }
+
+  inline void EncodeSymbol(EdgebreakerTopologyBitPattern symbol) {
+    ++num_symbols_;
+    // Update valences on the mesh and compute the context that is going to be
+    // used to encode the processed symbol.
+    // Note that the valences are computed for the so far unencoded part of the
+    // mesh (i.e. the decoding is reverse). Adding a new symbol either reduces
+    // valences on the vertices or leaves the valence unchanged.
+
+    const CornerIndex next = corner_table_->Next(last_corner_);
+    const CornerIndex prev = corner_table_->Previous(last_corner_);
+
+    // Get valence on the tip corner of the active edge (outgoing edge that is
+    // going to be used in reverse decoding of the connectivity to predict the
+    // next symbol).
+    const int active_valence = vertex_valences_[corner_to_vertex_map_[next]];
+    switch (symbol) {
+      case TOPOLOGY_C:
+        // Compute prediction.
+        FALLTHROUGH_INTENDED;
+      case TOPOLOGY_S:
+        // Update valences.
+        vertex_valences_[corner_to_vertex_map_[next]] -= 1;
+        vertex_valences_[corner_to_vertex_map_[prev]] -= 1;
+        if (symbol == TOPOLOGY_S) {
+          // Whenever we reach a split symbol, we need to split the vertex into
+          // two and attach all corners on the left and right sides of the split
+          // vertex to the respective vertices (see image below). This is
+          // necessary since the decoder works in the reverse order and it
+          // merges the two vertices only after the split symbol is processed.
+          //
+          //     * -----
+          //    / \--------
+          //   /   \--------
+          //  /     \-------
+          // *-------v-------*
+          //  \     /c\     /
+          //   \   /   \   /
+          //    \ /n S p\ /
+          //     *.......*
+          //
+
+          // Count the number of faces on the left side of the split vertex and
+          // update the valence on the "left vertex".
+          int num_left_faces = 0;
+          CornerIndex act_c = corner_table_->Opposite(prev);
+          while (act_c != kInvalidCornerIndex) {
+            if (encoder_impl()->IsFaceEncoded(corner_table_->Face(act_c))) {
+              break;  // Stop when we reach the first visited face.
+            }
+            ++num_left_faces;
+            act_c = corner_table_->Opposite(corner_table_->Next(act_c));
+          }
+          vertex_valences_[corner_to_vertex_map_[last_corner_]] =
+              num_left_faces + 1;
+
+          // Create a new vertex for the right side and count the number of
+          // faces that should be attached to this vertex.
+          const int new_vert_id = static_cast<int>(vertex_valences_.size());
+          int num_right_faces = 0;
+
+          act_c = corner_table_->Opposite(next);
+          while (act_c != kInvalidCornerIndex) {
+            if (encoder_impl()->IsFaceEncoded(corner_table_->Face(act_c))) {
+              break;  // Stop when we reach the first visited face.
+            }
+            ++num_right_faces;
+            // Map corners on the right side to the newly created vertex.
+            corner_to_vertex_map_[corner_table_->Next(act_c)] = new_vert_id;
+            act_c = corner_table_->Opposite(corner_table_->Previous(act_c));
+          }
+          vertex_valences_.push_back(num_right_faces + 1);
+        }
+        break;
+      case TOPOLOGY_R:
+        // Update valences.
+        vertex_valences_[corner_to_vertex_map_[last_corner_]] -= 1;
+        vertex_valences_[corner_to_vertex_map_[next]] -= 1;
+        vertex_valences_[corner_to_vertex_map_[prev]] -= 2;
+        break;
+      case TOPOLOGY_L:
+
+        vertex_valences_[corner_to_vertex_map_[last_corner_]] -= 1;
+        vertex_valences_[corner_to_vertex_map_[next]] -= 2;
+        vertex_valences_[corner_to_vertex_map_[prev]] -= 1;
+        break;
+      case TOPOLOGY_E:
+        vertex_valences_[corner_to_vertex_map_[last_corner_]] -= 2;
+        vertex_valences_[corner_to_vertex_map_[next]] -= 2;
+        vertex_valences_[corner_to_vertex_map_[prev]] -= 2;
+        break;
+      default:
+        break;
+    }
+
+    if (prev_symbol_ != -1) {
+      int clamped_valence;
+      if (active_valence < min_valence_) {
+        clamped_valence = min_valence_;
+      } else if (active_valence > max_valence_) {
+        clamped_valence = max_valence_;
+      } else {
+        clamped_valence = active_valence;
+      }
+
+      const int context = clamped_valence - min_valence_;
+      context_symbols_[context].push_back(
+          edge_breaker_topology_to_symbol_id[prev_symbol_]);
+    }
+
+    prev_symbol_ = symbol;
+  }
+
+  void Done() {
+    // Store the init face configurations and attribute seam data
+    MeshEdgebreakerTraversalEncoder::EncodeStartFaces();
+    MeshEdgebreakerTraversalEncoder::EncodeAttributeSeams();
+
+    // Store the contexts.
+    for (int i = 0; i < context_symbols_.size(); ++i) {
+      EncodeVarint<uint32_t>(static_cast<uint32_t>(context_symbols_[i].size()),
+                             GetOutputBuffer());
+      if (context_symbols_[i].size() > 0) {
+        EncodeSymbols(context_symbols_[i].data(),
+                      static_cast<int>(context_symbols_[i].size()), 1, nullptr,
+                      GetOutputBuffer());
+      }
+    }
+  }
+
+  int NumEncodedSymbols() const { return num_symbols_; }
+
+ private:
+  const CornerTable *corner_table_;
+  // Explicit map between corners and vertices. We cannot use the one stored
+  // in the |corner_table_| because we may need to add additional vertices to
+  // handle split symbols.
+  IndexTypeVector<CornerIndex, VertexIndex> corner_to_vertex_map_;
+  IndexTypeVector<VertexIndex, int> vertex_valences_;
+  // Previously encoded symbol.
+  int32_t prev_symbol_;
+  CornerIndex last_corner_;
+  // Explicitly count the number of encoded symbols.
+  int num_symbols_;
+
+  int min_valence_;
+  int max_valence_;
+  std::vector<std::vector<uint32_t>> context_symbols_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_VALENCE_ENCODER_H_
diff --git a/engine/inc/draco/compression/mesh/mesh_encoder.h b/engine/inc/draco/compression/mesh/mesh_encoder.h
new file mode 100644
index 00000000..30ec4fa3
--- /dev/null
+++ b/engine/inc/draco/compression/mesh/mesh_encoder.h
@@ -0,0 +1,84 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_ENCODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_ENCODER_H_
+
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/compression/point_cloud/point_cloud_encoder.h"
+#include "draco/mesh/mesh.h"
+#include "draco/mesh/mesh_attribute_corner_table.h"
+
+namespace draco {
+
+// Abstract base class for all mesh encoders. It provides some basic
+// functionality that's shared between different encoders.
+class MeshEncoder : public PointCloudEncoder {
+ public:
+  MeshEncoder();
+
+  // Sets the mesh that is going be encoded. Must be called before the Encode()
+  // method.
+  void SetMesh(const Mesh &m);
+
+  EncodedGeometryType GetGeometryType() const override {
+    return TRIANGULAR_MESH;
+  }
+
+  // Returns the number of faces that were encoded during the last Encode().
+  // function call. Valid only if "store_number_of_encoded_faces" flag was set
+  // in the provided EncoderOptions.
+  size_t num_encoded_faces() const { return num_encoded_faces_; }
+
+  // Returns the base connectivity of the encoded mesh (or nullptr if it is not
+  // initialized).
+  virtual const CornerTable *GetCornerTable() const { return nullptr; }
+
+  // Returns the attribute connectivity data or nullptr if it does not exist.
+  virtual const MeshAttributeCornerTable *GetAttributeCornerTable(
+      int /* att_id */) const {
+    return nullptr;
+  }
+
+  // Returns the encoding data for a given attribute or nullptr when the data
+  // does not exist.
+  virtual const MeshAttributeIndicesEncodingData *GetAttributeEncodingData(
+      int /* att_id */) const {
+    return nullptr;
+  }
+
+  const Mesh *mesh() const { return mesh_; }
+
+ protected:
+  Status EncodeGeometryData() override;
+
+  // Needs to be implemented by the derived classes.
+  virtual Status EncodeConnectivity() = 0;
+
+  // Computes and sets the num_encoded_faces_ for the encoder.
+  virtual void ComputeNumberOfEncodedFaces() = 0;
+
+  void set_mesh(const Mesh *mesh) { mesh_ = mesh; }
+  void set_num_encoded_faces(size_t num_faces) {
+    num_encoded_faces_ = num_faces;
+  }
+
+ private:
+  const Mesh *mesh_;
+  size_t num_encoded_faces_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_ENCODER_H_
diff --git a/engine/inc/draco/compression/mesh/mesh_sequential_decoder.h b/engine/inc/draco/compression/mesh/mesh_sequential_decoder.h
new file mode 100644
index 00000000..3a86c75d
--- /dev/null
+++ b/engine/inc/draco/compression/mesh/mesh_sequential_decoder.h
@@ -0,0 +1,39 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_SEQUENTIAL_DECODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_SEQUENTIAL_DECODER_H_
+
+#include "draco/compression/mesh/mesh_decoder.h"
+
+namespace draco {
+
+// Class for decoding data encoded by MeshSequentialEncoder.
+class MeshSequentialDecoder : public MeshDecoder {
+ public:
+  MeshSequentialDecoder();
+
+ protected:
+  bool DecodeConnectivity() override;
+  bool CreateAttributesDecoder(int32_t att_decoder_id) override;
+
+ private:
+  // Decodes face indices that were compressed with an entropy code.
+  // Returns false on error.
+  bool DecodeAndDecompressIndices(uint32_t num_faces);
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_SEQUENTIAL_DECODER_H_
diff --git a/engine/inc/draco/compression/mesh/mesh_sequential_encoder.h b/engine/inc/draco/compression/mesh/mesh_sequential_encoder.h
new file mode 100644
index 00000000..67260964
--- /dev/null
+++ b/engine/inc/draco/compression/mesh/mesh_sequential_encoder.h
@@ -0,0 +1,57 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// The encoder compresses all attribute values using an order preserving
+// attribute encoder (that can still support quantization, prediction schemes,
+// and other features).
+// The mesh connectivity data can be encoded using two modes that are controlled
+// using a global encoder options flag called "compress_connectivity"
+// 1. When "compress_connectivity" == true:
+//      All point ids are first delta coded and then compressed using an entropy
+//      coding.
+// 2. When "compress_connectivity" == false:
+//      All point ids are encoded directly using either 8, 16, or 32 bits per
+//      value based on the maximum point id value.
+
+#ifndef DRACO_COMPRESSION_MESH_MESH_SEQUENTIAL_ENCODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_SEQUENTIAL_ENCODER_H_
+
+#include "draco/compression/mesh/mesh_encoder.h"
+
+namespace draco {
+
+// Class that encodes mesh data using a simple binary representation of mesh's
+// connectivity and geometry.
+// TODO(ostava): Use a better name.
+class MeshSequentialEncoder : public MeshEncoder {
+ public:
+  MeshSequentialEncoder();
+  uint8_t GetEncodingMethod() const override {
+    return MESH_SEQUENTIAL_ENCODING;
+  }
+
+ protected:
+  Status EncodeConnectivity() override;
+  bool GenerateAttributesEncoder(int32_t att_id) override;
+  void ComputeNumberOfEncodedPoints() override;
+  void ComputeNumberOfEncodedFaces() override;
+
+ private:
+  // Returns false on error.
+  bool CompressAndEncodeIndices();
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_SEQUENTIAL_ENCODER_H_
diff --git a/engine/inc/draco/compression/mesh/traverser/depth_first_traverser.h b/engine/inc/draco/compression/mesh/traverser/depth_first_traverser.h
new file mode 100644
index 00000000..0b387ec3
--- /dev/null
+++ b/engine/inc/draco/compression/mesh/traverser/depth_first_traverser.h
@@ -0,0 +1,172 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_TRAVERSER_DEPTH_FIRST_TRAVERSER_H_
+#define DRACO_COMPRESSION_MESH_TRAVERSER_DEPTH_FIRST_TRAVERSER_H_
+
+#include <vector>
+
+#include "draco/compression/mesh/traverser/traverser_base.h"
+#include "draco/mesh/corner_table.h"
+
+namespace draco {
+
+// Basic traverser that traverses a mesh in a DFS like fashion using the
+// CornerTable data structure. The necessary bookkeeping is available via the
+// TraverserBase. Callbacks are handled through template argument
+// TraversalObserverT.
+//
+// TraversalObserverT can perform an action on a traversal event such as newly
+// visited face, or corner, but it does not affect the traversal itself.
+//
+// Concept TraversalObserverT requires:
+//
+// public:
+// void OnNewFaceVisited(FaceIndex face);
+//    - Called whenever a previously unvisited face is reached.
+//
+// void OnNewVertexVisited(VertexIndex vert, CornerIndex corner)
+//    - Called when a new vertex is visited. |corner| is used to indicate the
+//      which of the vertex's corners has been reached.
+
+template <class CornerTableT, class TraversalObserverT>
+class DepthFirstTraverser
+    : public TraverserBase<CornerTableT, TraversalObserverT> {
+ public:
+  typedef CornerTableT CornerTable;
+  typedef TraversalObserverT TraversalObserver;
+  typedef TraverserBase<CornerTable, TraversalObserver> Base;
+
+  DepthFirstTraverser() {}
+
+  // Called before any traversing starts.
+  void OnTraversalStart() {}
+
+  // Called when all the traversing is done.
+  void OnTraversalEnd() {}
+
+  bool TraverseFromCorner(CornerIndex corner_id) {
+    if (this->IsFaceVisited(corner_id)) {
+      return true;  // Already traversed.
+    }
+
+    corner_traversal_stack_.clear();
+    corner_traversal_stack_.push_back(corner_id);
+    // For the first face, check the remaining corners as they may not be
+    // processed yet.
+    const VertexIndex next_vert =
+        this->corner_table()->Vertex(this->corner_table()->Next(corner_id));
+    const VertexIndex prev_vert =
+        this->corner_table()->Vertex(this->corner_table()->Previous(corner_id));
+    if (next_vert == kInvalidVertexIndex || prev_vert == kInvalidVertexIndex) {
+      return false;
+    }
+    if (!this->IsVertexVisited(next_vert)) {
+      this->MarkVertexVisited(next_vert);
+      this->traversal_observer().OnNewVertexVisited(
+          next_vert, this->corner_table()->Next(corner_id));
+    }
+    if (!this->IsVertexVisited(prev_vert)) {
+      this->MarkVertexVisited(prev_vert);
+      this->traversal_observer().OnNewVertexVisited(
+          prev_vert, this->corner_table()->Previous(corner_id));
+    }
+
+    // Start the actual traversal.
+    while (!corner_traversal_stack_.empty()) {
+      // Currently processed corner.
+      corner_id = corner_traversal_stack_.back();
+      FaceIndex face_id(corner_id.value() / 3);
+      // Make sure the face hasn't been visited yet.
+      if (corner_id == kInvalidCornerIndex || this->IsFaceVisited(face_id)) {
+        // This face has been already traversed.
+        corner_traversal_stack_.pop_back();
+        continue;
+      }
+      while (true) {
+        this->MarkFaceVisited(face_id);
+        this->traversal_observer().OnNewFaceVisited(face_id);
+        const VertexIndex vert_id = this->corner_table()->Vertex(corner_id);
+        if (vert_id == kInvalidVertexIndex) {
+          return false;
+        }
+        if (!this->IsVertexVisited(vert_id)) {
+          const bool on_boundary = this->corner_table()->IsOnBoundary(vert_id);
+          this->MarkVertexVisited(vert_id);
+          this->traversal_observer().OnNewVertexVisited(vert_id, corner_id);
+          if (!on_boundary) {
+            corner_id = this->corner_table()->GetRightCorner(corner_id);
+            face_id = FaceIndex(corner_id.value() / 3);
+            continue;
+          }
+        }
+        // The current vertex has been already visited or it was on a boundary.
+        // We need to determine whether we can visit any of it's neighboring
+        // faces.
+        const CornerIndex right_corner_id =
+            this->corner_table()->GetRightCorner(corner_id);
+        const CornerIndex left_corner_id =
+            this->corner_table()->GetLeftCorner(corner_id);
+        const FaceIndex right_face_id(
+            (right_corner_id == kInvalidCornerIndex
+                 ? kInvalidFaceIndex
+                 : FaceIndex(right_corner_id.value() / 3)));
+        const FaceIndex left_face_id(
+            (left_corner_id == kInvalidCornerIndex
+                 ? kInvalidFaceIndex
+                 : FaceIndex(left_corner_id.value() / 3)));
+        if (this->IsFaceVisited(right_face_id)) {
+          // Right face has been already visited.
+          if (this->IsFaceVisited(left_face_id)) {
+            // Both neighboring faces are visited. End reached.
+            corner_traversal_stack_.pop_back();
+            break;  // Break from the while (true) loop.
+          } else {
+            // Go to the left face.
+            corner_id = left_corner_id;
+            face_id = left_face_id;
+          }
+        } else {
+          // Right face was not visited.
+          if (this->IsFaceVisited(left_face_id)) {
+            // Left face visited, go to the right one.
+            corner_id = right_corner_id;
+            face_id = right_face_id;
+          } else {
+            // Both neighboring faces are unvisited, we need to visit both of
+            // them.
+
+            // Split the traversal.
+            // First make the top of the current corner stack point to the left
+            // face (this one will be processed second).
+            corner_traversal_stack_.back() = left_corner_id;
+            // Add a new corner to the top of the stack (right face needs to
+            // be traversed first).
+            corner_traversal_stack_.push_back(right_corner_id);
+            // Break from the while (true) loop.
+            break;
+          }
+        }
+      }
+    }
+    return true;
+  }
+
+ private:
+  std::vector<CornerIndex> corner_traversal_stack_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_TRAVERSER_DEPTH_FIRST_TRAVERSER_H_
diff --git a/engine/inc/draco/compression/mesh/traverser/max_prediction_degree_traverser.h b/engine/inc/draco/compression/mesh/traverser/max_prediction_degree_traverser.h
new file mode 100644
index 00000000..514193ea
--- /dev/null
+++ b/engine/inc/draco/compression/mesh/traverser/max_prediction_degree_traverser.h
@@ -0,0 +1,226 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_TRAVERSER_MAX_PREDICTION_DEGREE_TRAVERSER_H_
+#define DRACO_COMPRESSION_MESH_TRAVERSER_MAX_PREDICTION_DEGREE_TRAVERSER_H_
+
+#include <vector>
+
+#include "draco/compression/mesh/traverser/traverser_base.h"
+#include "draco/mesh/corner_table.h"
+
+namespace draco {
+
+// PredictionDegreeTraverser provides framework for traversal over a corner
+// table data structure following paper "Multi-way Geometry Encoding" by
+// Cohen-or at al.'02. The traversal is implicitly guided by prediction degree
+// of the destination vertices. A prediction degree is computed as the number of
+// possible faces that can be used as source points for traversal to the given
+// destination vertex (see image below, where faces F1 and F2 are already
+// traversed and face F0 is not traversed yet. The prediction degree of vertex
+// V is then equal to two).
+//
+//            X-----V-----o
+//           / \   / \   / \
+//          / F0\ /   \ / F2\
+//         X-----o-----o-----B
+//                \ F1/
+//                 \ /
+//                  A
+//
+// The class implements the same interface as the DepthFirstTraverser
+// (depth_first_traverser.h) and it can be controlled via the same template
+// trait classes |CornerTableT| and |TraversalObserverT|, that are used
+// for controlling and monitoring of the traversal respectively. For details,
+// please see depth_first_traverser.h.
+template <class CornerTableT, class TraversalObserverT>
+class MaxPredictionDegreeTraverser
+    : public TraverserBase<CornerTable, TraversalObserverT> {
+ public:
+  typedef CornerTableT CornerTable;
+  typedef TraversalObserverT TraversalObserver;
+  typedef TraverserBase<CornerTable, TraversalObserver> Base;
+
+  MaxPredictionDegreeTraverser() {}
+
+  // Called before any traversing starts.
+  void OnTraversalStart() {
+    prediction_degree_.resize(this->corner_table()->num_vertices(), 0);
+  }
+
+  // Called when all the traversing is done.
+  void OnTraversalEnd() {}
+
+  bool TraverseFromCorner(CornerIndex corner_id) {
+    if (prediction_degree_.size() == 0) {
+      return true;
+    }
+
+    // Traversal starts from the |corner_id|. It's going to follow either the
+    // right or the left neighboring faces to |corner_id| based on their
+    // prediction degree.
+    traversal_stacks_[0].push_back(corner_id);
+    best_priority_ = 0;
+    // For the first face, check the remaining corners as they may not be
+    // processed yet.
+    const VertexIndex next_vert =
+        this->corner_table()->Vertex(this->corner_table()->Next(corner_id));
+    const VertexIndex prev_vert =
+        this->corner_table()->Vertex(this->corner_table()->Previous(corner_id));
+    if (!this->IsVertexVisited(next_vert)) {
+      this->MarkVertexVisited(next_vert);
+      this->traversal_observer().OnNewVertexVisited(
+          next_vert, this->corner_table()->Next(corner_id));
+    }
+    if (!this->IsVertexVisited(prev_vert)) {
+      this->MarkVertexVisited(prev_vert);
+      this->traversal_observer().OnNewVertexVisited(
+          prev_vert, this->corner_table()->Previous(corner_id));
+    }
+    const VertexIndex tip_vertex = this->corner_table()->Vertex(corner_id);
+    if (!this->IsVertexVisited(tip_vertex)) {
+      this->MarkVertexVisited(tip_vertex);
+      this->traversal_observer().OnNewVertexVisited(tip_vertex, corner_id);
+    }
+    // Start the actual traversal.
+    while ((corner_id = PopNextCornerToTraverse()) != kInvalidCornerIndex) {
+      FaceIndex face_id(corner_id.value() / 3);
+      // Make sure the face hasn't been visited yet.
+      if (this->IsFaceVisited(face_id)) {
+        // This face has been already traversed.
+        continue;
+      }
+
+      while (true) {
+        face_id = FaceIndex(corner_id.value() / 3);
+        this->MarkFaceVisited(face_id);
+        this->traversal_observer().OnNewFaceVisited(face_id);
+
+        // If the newly reached vertex hasn't been visited, mark it and notify
+        // the observer.
+        const VertexIndex vert_id = this->corner_table()->Vertex(corner_id);
+        if (!this->IsVertexVisited(vert_id)) {
+          this->MarkVertexVisited(vert_id);
+          this->traversal_observer().OnNewVertexVisited(vert_id, corner_id);
+        }
+
+        // Check whether we can traverse to the right and left neighboring
+        // faces.
+        const CornerIndex right_corner_id =
+            this->corner_table()->GetRightCorner(corner_id);
+        const CornerIndex left_corner_id =
+            this->corner_table()->GetLeftCorner(corner_id);
+        const FaceIndex right_face_id(
+            (right_corner_id == kInvalidCornerIndex
+                 ? kInvalidFaceIndex
+                 : FaceIndex(right_corner_id.value() / 3)));
+        const FaceIndex left_face_id(
+            (left_corner_id == kInvalidCornerIndex
+                 ? kInvalidFaceIndex
+                 : FaceIndex(left_corner_id.value() / 3)));
+        const bool is_right_face_visited = this->IsFaceVisited(right_face_id);
+        const bool is_left_face_visited = this->IsFaceVisited(left_face_id);
+
+        if (!is_left_face_visited) {
+          // We can go to the left face.
+          const int priority = ComputePriority(left_corner_id);
+          if (is_right_face_visited && priority <= best_priority_) {
+            // Right face has been already visited and the priority is equal or
+            // better than the best priority. We are sure that the left face
+            // would be traversed next so there is no need to put it onto the
+            // stack.
+            corner_id = left_corner_id;
+            continue;
+          } else {
+            AddCornerToTraversalStack(left_corner_id, priority);
+          }
+        }
+        if (!is_right_face_visited) {
+          // Go to the right face.
+          const int priority = ComputePriority(right_corner_id);
+          if (priority <= best_priority_) {
+            // We are sure that the right face would be traversed next so there
+            // is no need to put it onto the stack.
+            corner_id = right_corner_id;
+            continue;
+          } else {
+            AddCornerToTraversalStack(right_corner_id, priority);
+          }
+        }
+
+        // Couldn't proceed directly to the next corner
+        break;
+      }
+    }
+    return true;
+  }
+
+ private:
+  // Retrieves the next available corner (edge) to traverse. Edges are processed
+  // based on their priorities.
+  // Returns kInvalidCornerIndex when there is no edge available.
+  CornerIndex PopNextCornerToTraverse() {
+    for (int i = best_priority_; i < kMaxPriority; ++i) {
+      if (!traversal_stacks_[i].empty()) {
+        const CornerIndex ret = traversal_stacks_[i].back();
+        traversal_stacks_[i].pop_back();
+        best_priority_ = i;
+        return ret;
+      }
+    }
+    return kInvalidCornerIndex;
+  }
+
+  inline void AddCornerToTraversalStack(CornerIndex ci, int priority) {
+    traversal_stacks_[priority].push_back(ci);
+    // Make sure that the best available priority is up to date.
+    if (priority < best_priority_) {
+      best_priority_ = priority;
+    }
+  }
+
+  // Returns the priority of traversing edge leading to |corner_id|.
+  inline int ComputePriority(CornerIndex corner_id) {
+    const VertexIndex v_tip = this->corner_table()->Vertex(corner_id);
+    // Priority 0 when traversing to already visited vertices.
+    int priority = 0;
+    if (!this->IsVertexVisited(v_tip)) {
+      const int degree = ++prediction_degree_[v_tip];
+      // Priority 1 when prediction degree > 1, otherwise 2.
+      priority = (degree > 1 ? 1 : 2);
+    }
+    // Clamp the priority to the maximum number of buckets.
+    if (priority >= kMaxPriority) {
+      priority = kMaxPriority - 1;
+    }
+    return priority;
+  }
+
+  // For efficiency reasons, the priority traversal is implemented using buckets
+  // where each buckets represent a stack of available corners for a given
+  // priority. Corners with the highest priority are always processed first.
+  static constexpr int kMaxPriority = 3;
+  std::vector<CornerIndex> traversal_stacks_[kMaxPriority];
+
+  // Keep the track of the best available priority to improve the performance
+  // of PopNextCornerToTraverse() method.
+  int best_priority_;
+
+  // Prediction degree available for each vertex.
+  IndexTypeVector<VertexIndex, int> prediction_degree_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_TRAVERSER_MAX_PREDICTION_DEGREE_TRAVERSER_H_
diff --git a/engine/inc/draco/compression/mesh/traverser/mesh_attribute_indices_encoding_observer.h b/engine/inc/draco/compression/mesh/traverser/mesh_attribute_indices_encoding_observer.h
new file mode 100644
index 00000000..e66dd14b
--- /dev/null
+++ b/engine/inc/draco/compression/mesh/traverser/mesh_attribute_indices_encoding_observer.h
@@ -0,0 +1,76 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_TRAVERSER_MESH_ATTRIBUTE_INDICES_ENCODING_OBSERVER_H_
+#define DRACO_COMPRESSION_MESH_TRAVERSER_MESH_ATTRIBUTE_INDICES_ENCODING_OBSERVER_H_
+
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/compression/attributes/points_sequencer.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Class that can be used to generate encoding (and decoding) order of attribute
+// values based on the traversal of the encoded mesh. The class should be used
+// as the TraversalObserverT member of a Traverser class such as the
+// DepthFirstTraverser (depth_first_traverser.h).
+// TODO(hemmer): rename to AttributeIndicesCodingTraverserObserver
+template <class CornerTableT>
+class MeshAttributeIndicesEncodingObserver {
+ public:
+  MeshAttributeIndicesEncodingObserver()
+      : att_connectivity_(nullptr),
+        encoding_data_(nullptr),
+        mesh_(nullptr),
+        sequencer_(nullptr) {}
+  MeshAttributeIndicesEncodingObserver(
+      const CornerTableT *connectivity, const Mesh *mesh,
+      PointsSequencer *sequencer,
+      MeshAttributeIndicesEncodingData *encoding_data)
+      : att_connectivity_(connectivity),
+        encoding_data_(encoding_data),
+        mesh_(mesh),
+        sequencer_(sequencer) {}
+
+  // Interface for TraversalObserverT
+
+  void OnNewFaceVisited(FaceIndex /* face */) {}
+
+  inline void OnNewVertexVisited(VertexIndex vertex, CornerIndex corner) {
+    const PointIndex point_id =
+        mesh_->face(FaceIndex(corner.value() / 3))[corner.value() % 3];
+    // Append the visited attribute to the encoding order.
+    sequencer_->AddPointId(point_id);
+
+    // Keep track of visited corners.
+    encoding_data_->encoded_attribute_value_index_to_corner_map.push_back(
+        corner);
+
+    encoding_data_
+        ->vertex_to_encoded_attribute_value_index_map[vertex.value()] =
+        encoding_data_->num_values;
+
+    encoding_data_->num_values++;
+  }
+
+ private:
+  const CornerTableT *att_connectivity_;
+  MeshAttributeIndicesEncodingData *encoding_data_;
+  const Mesh *mesh_;
+  PointsSequencer *sequencer_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_TRAVERSER_MESH_ATTRIBUTE_INDICES_ENCODING_OBSERVER_H_
diff --git a/engine/inc/draco/compression/mesh/traverser/mesh_traversal_sequencer.h b/engine/inc/draco/compression/mesh/traverser/mesh_traversal_sequencer.h
new file mode 100644
index 00000000..ebe1d5f7
--- /dev/null
+++ b/engine/inc/draco/compression/mesh/traverser/mesh_traversal_sequencer.h
@@ -0,0 +1,113 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_TRAVERSER_MESH_TRAVERSAL_SEQUENCER_H_
+#define DRACO_COMPRESSION_MESH_TRAVERSER_MESH_TRAVERSAL_SEQUENCER_H_
+
+#include "draco/attributes/geometry_indices.h"
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/compression/attributes/points_sequencer.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Sequencer that generates point sequence in an order given by a deterministic
+// traversal on the mesh surface. Note that all attributes encoded with this
+// sequence must share the same connectivity.
+// TODO(hemmer): Consider refactoring such that this is an observer.
+template <class TraverserT>
+class MeshTraversalSequencer : public PointsSequencer {
+ public:
+  MeshTraversalSequencer(const Mesh *mesh,
+                         const MeshAttributeIndicesEncodingData *encoding_data)
+      : mesh_(mesh), encoding_data_(encoding_data), corner_order_(nullptr) {}
+  void SetTraverser(const TraverserT &t) { traverser_ = t; }
+
+  // Function that can be used to set an order in which the mesh corners should
+  // be processed. This is an optional flag used usually only by the encoder
+  // to match the same corner order that is going to be used by the decoder.
+  // Note that |corner_order| should contain only one corner per face (it can
+  // have all corners but only the first encountered corner for each face is
+  // going to be used to start a traversal). If the corner order is not set, the
+  // corners are processed sequentially based on their ids.
+  void SetCornerOrder(const std::vector<CornerIndex> &corner_order) {
+    corner_order_ = &corner_order;
+  }
+
+  bool UpdatePointToAttributeIndexMapping(PointAttribute *attribute) override {
+    const auto *corner_table = traverser_.corner_table();
+    attribute->SetExplicitMapping(mesh_->num_points());
+    const size_t num_faces = mesh_->num_faces();
+    const size_t num_points = mesh_->num_points();
+    for (FaceIndex f(0); f < static_cast<uint32_t>(num_faces); ++f) {
+      const auto &face = mesh_->face(f);
+      for (int p = 0; p < 3; ++p) {
+        const PointIndex point_id = face[p];
+        const VertexIndex vert_id =
+            corner_table->Vertex(CornerIndex(3 * f.value() + p));
+        if (vert_id == kInvalidVertexIndex) {
+          return false;
+        }
+        const AttributeValueIndex att_entry_id(
+            encoding_data_
+                ->vertex_to_encoded_attribute_value_index_map[vert_id.value()]);
+        if (point_id >= num_points || att_entry_id.value() >= num_points) {
+          // There cannot be more attribute values than the number of points.
+          return false;
+        }
+        attribute->SetPointMapEntry(point_id, att_entry_id);
+      }
+    }
+    return true;
+  }
+
+ protected:
+  bool GenerateSequenceInternal() override {
+    // Preallocate memory for storing point indices. We expect the number of
+    // points to be the same as the number of corner table vertices.
+    out_point_ids()->reserve(traverser_.corner_table()->num_vertices());
+
+    traverser_.OnTraversalStart();
+    if (corner_order_) {
+      for (uint32_t i = 0; i < corner_order_->size(); ++i) {
+        if (!ProcessCorner(corner_order_->at(i))) {
+          return false;
+        }
+      }
+    } else {
+      const int32_t num_faces = traverser_.corner_table()->num_faces();
+      for (int i = 0; i < num_faces; ++i) {
+        if (!ProcessCorner(CornerIndex(3 * i))) {
+          return false;
+        }
+      }
+    }
+    traverser_.OnTraversalEnd();
+    return true;
+  }
+
+ private:
+  bool ProcessCorner(CornerIndex corner_id) {
+    return traverser_.TraverseFromCorner(corner_id);
+  }
+
+  TraverserT traverser_;
+  const Mesh *mesh_;
+  const MeshAttributeIndicesEncodingData *encoding_data_;
+  const std::vector<CornerIndex> *corner_order_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_TRAVERSER_MESH_TRAVERSAL_SEQUENCER_H_
diff --git a/engine/inc/draco/compression/mesh/traverser/traverser_base.h b/engine/inc/draco/compression/mesh/traverser/traverser_base.h
new file mode 100644
index 00000000..f2f8da79
--- /dev/null
+++ b/engine/inc/draco/compression/mesh/traverser/traverser_base.h
@@ -0,0 +1,87 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_TRAVERSER_TRAVERSER_BASE_H_
+#define DRACO_COMPRESSION_MESH_TRAVERSER_TRAVERSER_BASE_H_
+
+#include "draco/mesh/corner_table.h"
+
+namespace draco {
+
+// Class providing the basic traversal functionality needed by traversers (such
+// as the DepthFirstTraverser, see depth_first_traverser.h). It keeps a pointer
+// to the corner table that is used for the traversal, plus it provides a basic
+// bookkeeping of visited faces and vertices during the traversal.
+template <class CornerTableT, class TraversalObserverT>
+class TraverserBase {
+ public:
+  typedef CornerTableT CornerTable;
+  typedef TraversalObserverT TraversalObserver;
+
+  TraverserBase() : corner_table_(nullptr) {}
+  virtual ~TraverserBase() = default;
+
+  virtual void Init(const CornerTable *corner_table,
+                    TraversalObserver traversal_observer) {
+    corner_table_ = corner_table;
+    is_face_visited_.assign(corner_table->num_faces(), false);
+    is_vertex_visited_.assign(corner_table_->num_vertices(), false);
+    traversal_observer_ = traversal_observer;
+  }
+
+  const CornerTable &GetCornerTable() const { return *corner_table_; }
+
+  inline bool IsFaceVisited(FaceIndex face_id) const {
+    if (face_id == kInvalidFaceIndex) {
+      return true;  // Invalid faces are always considered as visited.
+    }
+    return is_face_visited_[face_id.value()];
+  }
+
+  // Returns true if the face containing the given corner was visited.
+  inline bool IsFaceVisited(CornerIndex corner_id) const {
+    if (corner_id == kInvalidCornerIndex) {
+      return true;  // Invalid faces are always considered as visited.
+    }
+    return is_face_visited_[corner_id.value() / 3];
+  }
+
+  inline void MarkFaceVisited(FaceIndex face_id) {
+    is_face_visited_[face_id.value()] = true;
+  }
+  inline bool IsVertexVisited(VertexIndex vert_id) const {
+    return is_vertex_visited_[vert_id.value()];
+  }
+  inline void MarkVertexVisited(VertexIndex vert_id) {
+    is_vertex_visited_[vert_id.value()] = true;
+  }
+
+  inline const CornerTable *corner_table() const { return corner_table_; }
+  inline const TraversalObserverT &traversal_observer() const {
+    return traversal_observer_;
+  }
+  inline TraversalObserverT &traversal_observer() {
+    return traversal_observer_;
+  }
+
+ private:
+  const CornerTable *corner_table_;
+  TraversalObserverT traversal_observer_;
+  std::vector<bool> is_face_visited_;
+  std::vector<bool> is_vertex_visited_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_TRAVERSER_TRAVERSER_BASE_H_
diff --git a/engine/inc/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_decoder.h b/engine/inc/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_decoder.h
new file mode 100644
index 00000000..87bc2b7e
--- /dev/null
+++ b/engine/inc/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_decoder.h
@@ -0,0 +1,330 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// See dynamic_integer_points_kd_tree_encoder.h for documentation.
+
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_DYNAMIC_INTEGER_POINTS_KD_TREE_DECODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_DYNAMIC_INTEGER_POINTS_KD_TREE_DECODER_H_
+
+#include <array>
+#include <memory>
+#include <stack>
+
+#include "draco/compression/bit_coders/adaptive_rans_bit_decoder.h"
+#include "draco/compression/bit_coders/direct_bit_decoder.h"
+#include "draco/compression/bit_coders/folded_integer_bit_decoder.h"
+#include "draco/compression/bit_coders/rans_bit_decoder.h"
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+#include "draco/core/bit_utils.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/math_utils.h"
+
+namespace draco {
+
+template <int compression_level_t>
+struct DynamicIntegerPointsKdTreeDecoderCompressionPolicy
+    : public DynamicIntegerPointsKdTreeDecoderCompressionPolicy<
+          compression_level_t - 1> {};
+
+template <>
+struct DynamicIntegerPointsKdTreeDecoderCompressionPolicy<0> {
+  typedef DirectBitDecoder NumbersDecoder;
+  typedef DirectBitDecoder AxisDecoder;
+  typedef DirectBitDecoder HalfDecoder;
+  typedef DirectBitDecoder RemainingBitsDecoder;
+  static constexpr bool select_axis = false;
+};
+
+template <>
+struct DynamicIntegerPointsKdTreeDecoderCompressionPolicy<2>
+    : public DynamicIntegerPointsKdTreeDecoderCompressionPolicy<1> {
+  typedef RAnsBitDecoder NumbersDecoder;
+};
+
+template <>
+struct DynamicIntegerPointsKdTreeDecoderCompressionPolicy<4>
+    : public DynamicIntegerPointsKdTreeDecoderCompressionPolicy<3> {
+  typedef FoldedBit32Decoder<RAnsBitDecoder> NumbersDecoder;
+};
+
+template <>
+struct DynamicIntegerPointsKdTreeDecoderCompressionPolicy<6>
+    : public DynamicIntegerPointsKdTreeDecoderCompressionPolicy<5> {
+  static constexpr bool select_axis = true;
+};
+
+// Decodes a point cloud encoded by DynamicIntegerPointsKdTreeEncoder.
+template <int compression_level_t>
+class DynamicIntegerPointsKdTreeDecoder {
+  static_assert(compression_level_t >= 0, "Compression level must in [0..6].");
+  static_assert(compression_level_t <= 6, "Compression level must in [0..6].");
+  typedef DynamicIntegerPointsKdTreeDecoderCompressionPolicy<
+      compression_level_t>
+      Policy;
+
+  typedef typename Policy::NumbersDecoder NumbersDecoder;
+  typedef typename Policy::AxisDecoder AxisDecoder;
+  typedef typename Policy::HalfDecoder HalfDecoder;
+  typedef typename Policy::RemainingBitsDecoder RemainingBitsDecoder;
+  typedef std::vector<uint32_t> VectorUint32;
+
+ public:
+  explicit DynamicIntegerPointsKdTreeDecoder(uint32_t dimension)
+      : bit_length_(0),
+        num_points_(0),
+        num_decoded_points_(0),
+        dimension_(dimension),
+        p_(dimension, 0),
+        axes_(dimension, 0),
+        // Init the stack with the maximum depth of the tree.
+        // +1 for a second leaf.
+        base_stack_(32 * dimension + 1, VectorUint32(dimension, 0)),
+        levels_stack_(32 * dimension + 1, VectorUint32(dimension, 0)) {}
+
+  // Decodes a integer point cloud from |buffer|.
+  template <class OutputIteratorT>
+  bool DecodePoints(DecoderBuffer *buffer, OutputIteratorT &oit);
+
+#ifndef DRACO_OLD_GCC
+  template <class OutputIteratorT>
+  bool DecodePoints(DecoderBuffer *buffer, OutputIteratorT &&oit);
+#endif  // DRACO_OLD_GCC
+
+  const uint32_t dimension() const { return dimension_; }
+
+ private:
+  uint32_t GetAxis(uint32_t num_remaining_points, const VectorUint32 &levels,
+                   uint32_t last_axis);
+
+  template <class OutputIteratorT>
+  bool DecodeInternal(uint32_t num_points, OutputIteratorT &oit);
+
+  void DecodeNumber(int nbits, uint32_t *value) {
+    numbers_decoder_.DecodeLeastSignificantBits32(nbits, value);
+  }
+
+  struct DecodingStatus {
+    DecodingStatus(uint32_t num_remaining_points_, uint32_t last_axis_,
+                   uint32_t stack_pos_)
+        : num_remaining_points(num_remaining_points_),
+          last_axis(last_axis_),
+          stack_pos(stack_pos_) {}
+
+    uint32_t num_remaining_points;
+    uint32_t last_axis;
+    uint32_t stack_pos;  // used to get base and levels
+  };
+
+  uint32_t bit_length_;
+  uint32_t num_points_;
+  uint32_t num_decoded_points_;
+  uint32_t dimension_;
+  NumbersDecoder numbers_decoder_;
+  RemainingBitsDecoder remaining_bits_decoder_;
+  AxisDecoder axis_decoder_;
+  HalfDecoder half_decoder_;
+  VectorUint32 p_;
+  VectorUint32 axes_;
+  std::vector<VectorUint32> base_stack_;
+  std::vector<VectorUint32> levels_stack_;
+};
+
+// Decodes a point cloud from |buffer|.
+#ifndef DRACO_OLD_GCC
+template <int compression_level_t>
+template <class OutputIteratorT>
+bool DynamicIntegerPointsKdTreeDecoder<compression_level_t>::DecodePoints(
+    DecoderBuffer *buffer, OutputIteratorT &&oit) {
+  OutputIteratorT local = std::forward<OutputIteratorT>(oit);
+  return DecodePoints(buffer, local);
+}
+#endif  // DRACO_OLD_GCC
+
+template <int compression_level_t>
+template <class OutputIteratorT>
+bool DynamicIntegerPointsKdTreeDecoder<compression_level_t>::DecodePoints(
+    DecoderBuffer *buffer, OutputIteratorT &oit) {
+  if (!buffer->Decode(&bit_length_)) {
+    return false;
+  }
+  if (bit_length_ > 32) {
+    return false;
+  }
+  if (!buffer->Decode(&num_points_)) {
+    return false;
+  }
+  if (num_points_ == 0) {
+    return true;
+  }
+  num_decoded_points_ = 0;
+
+  if (!numbers_decoder_.StartDecoding(buffer)) {
+    return false;
+  }
+  if (!remaining_bits_decoder_.StartDecoding(buffer)) {
+    return false;
+  }
+  if (!axis_decoder_.StartDecoding(buffer)) {
+    return false;
+  }
+  if (!half_decoder_.StartDecoding(buffer)) {
+    return false;
+  }
+
+  if (!DecodeInternal(num_points_, oit)) {
+    return false;
+  }
+
+  numbers_decoder_.EndDecoding();
+  remaining_bits_decoder_.EndDecoding();
+  axis_decoder_.EndDecoding();
+  half_decoder_.EndDecoding();
+
+  return true;
+}
+
+template <int compression_level_t>
+uint32_t DynamicIntegerPointsKdTreeDecoder<compression_level_t>::GetAxis(
+    uint32_t num_remaining_points, const VectorUint32 &levels,
+    uint32_t last_axis) {
+  if (!Policy::select_axis) {
+    return DRACO_INCREMENT_MOD(last_axis, dimension_);
+  }
+
+  uint32_t best_axis = 0;
+  if (num_remaining_points < 64) {
+    for (uint32_t axis = 1; axis < dimension_; ++axis) {
+      if (levels[best_axis] > levels[axis]) {
+        best_axis = axis;
+      }
+    }
+  } else {
+    axis_decoder_.DecodeLeastSignificantBits32(4, &best_axis);
+  }
+
+  return best_axis;
+}
+
+template <int compression_level_t>
+template <class OutputIteratorT>
+bool DynamicIntegerPointsKdTreeDecoder<compression_level_t>::DecodeInternal(
+    uint32_t num_points, OutputIteratorT &oit) {
+  typedef DecodingStatus Status;
+  base_stack_[0] = VectorUint32(dimension_, 0);
+  levels_stack_[0] = VectorUint32(dimension_, 0);
+  DecodingStatus init_status(num_points, 0, 0);
+  std::stack<Status> status_stack;
+  status_stack.push(init_status);
+
+  // TODO(hemmer): use preallocated vector instead of stack.
+  while (!status_stack.empty()) {
+    const DecodingStatus status = status_stack.top();
+    status_stack.pop();
+
+    const uint32_t num_remaining_points = status.num_remaining_points;
+    const uint32_t last_axis = status.last_axis;
+    const uint32_t stack_pos = status.stack_pos;
+    const VectorUint32 &old_base = base_stack_[stack_pos];
+    const VectorUint32 &levels = levels_stack_[stack_pos];
+
+    if (num_remaining_points > num_points) {
+      return false;
+    }
+
+    const uint32_t axis = GetAxis(num_remaining_points, levels, last_axis);
+    if (axis >= dimension_) {
+      return false;
+    }
+
+    const uint32_t level = levels[axis];
+
+    // All axes have been fully subdivided, just output points.
+    if ((bit_length_ - level) == 0) {
+      for (uint32_t i = 0; i < num_remaining_points; i++) {
+        *oit = old_base;
+        ++oit;
+        ++num_decoded_points_;
+      }
+      continue;
+    }
+
+    DRACO_DCHECK_EQ(true, num_remaining_points != 0);
+
+    // Fast decoding of remaining bits if number of points is 1 or 2.
+    if (num_remaining_points <= 2) {
+      // TODO(hemmer): axes_ not necessary, remove would change bitstream!
+      axes_[0] = axis;
+      for (uint32_t i = 1; i < dimension_; i++) {
+        axes_[i] = DRACO_INCREMENT_MOD(axes_[i - 1], dimension_);
+      }
+      for (uint32_t i = 0; i < num_remaining_points; ++i) {
+        for (uint32_t j = 0; j < dimension_; j++) {
+          p_[axes_[j]] = 0;
+          const uint32_t num_remaining_bits = bit_length_ - levels[axes_[j]];
+          if (num_remaining_bits) {
+            remaining_bits_decoder_.DecodeLeastSignificantBits32(
+                num_remaining_bits, &p_[axes_[j]]);
+          }
+          p_[axes_[j]] = old_base[axes_[j]] | p_[axes_[j]];
+        }
+        *oit = p_;
+        ++oit;
+        ++num_decoded_points_;
+      }
+      continue;
+    }
+
+    if (num_decoded_points_ > num_points_) {
+      return false;
+    }
+
+    const int num_remaining_bits = bit_length_ - level;
+    const uint32_t modifier = 1 << (num_remaining_bits - 1);
+    base_stack_[stack_pos + 1] = old_base;         // copy
+    base_stack_[stack_pos + 1][axis] += modifier;  // new base
+
+    const int incoming_bits = MostSignificantBit(num_remaining_points);
+
+    uint32_t number = 0;
+    DecodeNumber(incoming_bits, &number);
+
+    uint32_t first_half = num_remaining_points / 2 - number;
+    uint32_t second_half = num_remaining_points - first_half;
+
+    if (first_half != second_half) {
+      if (!half_decoder_.DecodeNextBit()) {
+        std::swap(first_half, second_half);
+      }
+    }
+
+    levels_stack_[stack_pos][axis] += 1;
+    levels_stack_[stack_pos + 1] = levels_stack_[stack_pos];  // copy
+    if (first_half) {
+      status_stack.push(DecodingStatus(first_half, axis, stack_pos));
+    }
+    if (second_half) {
+      status_stack.push(DecodingStatus(second_half, axis, stack_pos + 1));
+    }
+  }
+  return true;
+}
+
+extern template class DynamicIntegerPointsKdTreeDecoder<0>;
+extern template class DynamicIntegerPointsKdTreeDecoder<2>;
+extern template class DynamicIntegerPointsKdTreeDecoder<4>;
+extern template class DynamicIntegerPointsKdTreeDecoder<6>;
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_DYNAMIC_INTEGER_POINTS_KD_TREE_DECODER_H_
diff --git a/engine/inc/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_encoder.h b/engine/inc/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_encoder.h
new file mode 100644
index 00000000..14fa32d7
--- /dev/null
+++ b/engine/inc/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_encoder.h
@@ -0,0 +1,371 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_DYNAMIC_INTEGER_POINTS_KD_TREE_ENCODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_DYNAMIC_INTEGER_POINTS_KD_TREE_ENCODER_H_
+
+#include <algorithm>
+#include <array>
+#include <memory>
+#include <stack>
+#include <vector>
+
+#include "draco/compression/bit_coders/adaptive_rans_bit_encoder.h"
+#include "draco/compression/bit_coders/direct_bit_encoder.h"
+#include "draco/compression/bit_coders/folded_integer_bit_encoder.h"
+#include "draco/compression/bit_coders/rans_bit_encoder.h"
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+#include "draco/core/bit_utils.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/core/math_utils.h"
+
+namespace draco {
+
+// This policy class provides several configurations for the encoder that allow
+// to trade speed vs compression rate. Level 0 is fastest while 6 is the best
+// compression rate. The decoder must select the same level.
+template <int compression_level_t>
+struct DynamicIntegerPointsKdTreeEncoderCompressionPolicy
+    : public DynamicIntegerPointsKdTreeEncoderCompressionPolicy<
+          compression_level_t - 1> {};
+
+template <>
+struct DynamicIntegerPointsKdTreeEncoderCompressionPolicy<0> {
+  typedef DirectBitEncoder NumbersEncoder;
+  typedef DirectBitEncoder AxisEncoder;
+  typedef DirectBitEncoder HalfEncoder;
+  typedef DirectBitEncoder RemainingBitsEncoder;
+  static constexpr bool select_axis = false;
+};
+
+template <>
+struct DynamicIntegerPointsKdTreeEncoderCompressionPolicy<2>
+    : public DynamicIntegerPointsKdTreeEncoderCompressionPolicy<1> {
+  typedef RAnsBitEncoder NumbersEncoder;
+};
+
+template <>
+struct DynamicIntegerPointsKdTreeEncoderCompressionPolicy<4>
+    : public DynamicIntegerPointsKdTreeEncoderCompressionPolicy<3> {
+  typedef FoldedBit32Encoder<RAnsBitEncoder> NumbersEncoder;
+};
+
+template <>
+struct DynamicIntegerPointsKdTreeEncoderCompressionPolicy<6>
+    : public DynamicIntegerPointsKdTreeEncoderCompressionPolicy<5> {
+  static constexpr bool select_axis = true;
+};
+
+// This class encodes a given integer point cloud based on the point cloud
+// compression algorithm in:
+// Olivier Devillers and Pierre-Marie Gandoin
+// "Geometric compression for interactive transmission"
+//
+// In principle the algorithm keeps on splitting the point cloud in the middle
+// while alternating the axes. In 3D this results in an Octree like structure.
+// In each step we encode the number of points in the first half.
+// The algorithm does not preserve the order of points.
+//
+// However, the algorithm here differs from the original as follows:
+// The algorithm keeps on splitting the point cloud in the middle of the axis
+// that keeps the point cloud as clustered as possible, which gives a better
+// compression rate.
+// The number of points is encode by the deviation from the half of the points
+// in the smaller half of the two. This results in a better compression rate as
+// there are more leading zeros, which is then compressed better by the
+// arithmetic encoding.
+template <int compression_level_t>
+class DynamicIntegerPointsKdTreeEncoder {
+  static_assert(compression_level_t >= 0, "Compression level must in [0..6].");
+  static_assert(compression_level_t <= 6, "Compression level must in [0..6].");
+  typedef DynamicIntegerPointsKdTreeEncoderCompressionPolicy<
+      compression_level_t>
+      Policy;
+  typedef typename Policy::NumbersEncoder NumbersEncoder;
+  typedef typename Policy::AxisEncoder AxisEncoder;
+  typedef typename Policy::HalfEncoder HalfEncoder;
+  typedef typename Policy::RemainingBitsEncoder RemainingBitsEncoder;
+  typedef std::vector<uint32_t> VectorUint32;
+
+ public:
+  explicit DynamicIntegerPointsKdTreeEncoder(uint32_t dimension)
+      : bit_length_(0),
+        dimension_(dimension),
+        deviations_(dimension, 0),
+        num_remaining_bits_(dimension, 0),
+        axes_(dimension, 0),
+        base_stack_(32 * dimension + 1, VectorUint32(dimension, 0)),
+        levels_stack_(32 * dimension + 1, VectorUint32(dimension, 0)) {}
+
+  // Encodes an integer point cloud given by [begin,end) into buffer.
+  // |bit_length| gives the highest bit used for all coordinates.
+  template <class RandomAccessIteratorT>
+  bool EncodePoints(RandomAccessIteratorT begin, RandomAccessIteratorT end,
+                    const uint32_t &bit_length, EncoderBuffer *buffer);
+
+  // Encodes an integer point cloud given by [begin,end) into buffer.
+  template <class RandomAccessIteratorT>
+  bool EncodePoints(RandomAccessIteratorT begin, RandomAccessIteratorT end,
+                    EncoderBuffer *buffer) {
+    return EncodePoints(begin, end, 32, buffer);
+  }
+
+  const uint32_t dimension() const { return dimension_; }
+
+ private:
+  template <class RandomAccessIteratorT>
+  uint32_t GetAndEncodeAxis(RandomAccessIteratorT begin,
+                            RandomAccessIteratorT end,
+                            const VectorUint32 &old_base,
+                            const VectorUint32 &levels, uint32_t last_axis);
+  template <class RandomAccessIteratorT>
+  void EncodeInternal(RandomAccessIteratorT begin, RandomAccessIteratorT end);
+
+  class Splitter {
+   public:
+    Splitter(uint32_t axis, uint32_t value) : axis_(axis), value_(value) {}
+    template <class PointT>
+    bool operator()(const PointT &a) const {
+      return a[axis_] < value_;
+    }
+
+   private:
+    const uint32_t axis_;
+    const uint32_t value_;
+  };
+
+  void EncodeNumber(int nbits, uint32_t value) {
+    numbers_encoder_.EncodeLeastSignificantBits32(nbits, value);
+  }
+
+  template <class RandomAccessIteratorT>
+  struct EncodingStatus {
+    EncodingStatus(RandomAccessIteratorT begin_, RandomAccessIteratorT end_,
+                   uint32_t last_axis_, uint32_t stack_pos_)
+        : begin(begin_),
+          end(end_),
+          last_axis(last_axis_),
+          stack_pos(stack_pos_) {
+      num_remaining_points = static_cast<uint32_t>(end - begin);
+    }
+
+    RandomAccessIteratorT begin;
+    RandomAccessIteratorT end;
+    uint32_t last_axis;
+    uint32_t num_remaining_points;
+    uint32_t stack_pos;  // used to get base and levels
+  };
+
+  uint32_t bit_length_;
+  uint32_t num_points_;
+  uint32_t dimension_;
+  NumbersEncoder numbers_encoder_;
+  RemainingBitsEncoder remaining_bits_encoder_;
+  AxisEncoder axis_encoder_;
+  HalfEncoder half_encoder_;
+  VectorUint32 deviations_;
+  VectorUint32 num_remaining_bits_;
+  VectorUint32 axes_;
+  std::vector<VectorUint32> base_stack_;
+  std::vector<VectorUint32> levels_stack_;
+};
+
+template <int compression_level_t>
+template <class RandomAccessIteratorT>
+bool DynamicIntegerPointsKdTreeEncoder<compression_level_t>::EncodePoints(
+    RandomAccessIteratorT begin, RandomAccessIteratorT end,
+    const uint32_t &bit_length, EncoderBuffer *buffer) {
+  bit_length_ = bit_length;
+  num_points_ = static_cast<uint32_t>(end - begin);
+
+  buffer->Encode(bit_length_);
+  buffer->Encode(num_points_);
+  if (num_points_ == 0) {
+    return true;
+  }
+
+  numbers_encoder_.StartEncoding();
+  remaining_bits_encoder_.StartEncoding();
+  axis_encoder_.StartEncoding();
+  half_encoder_.StartEncoding();
+
+  EncodeInternal(begin, end);
+
+  numbers_encoder_.EndEncoding(buffer);
+  remaining_bits_encoder_.EndEncoding(buffer);
+  axis_encoder_.EndEncoding(buffer);
+  half_encoder_.EndEncoding(buffer);
+
+  return true;
+}
+template <int compression_level_t>
+template <class RandomAccessIteratorT>
+uint32_t
+DynamicIntegerPointsKdTreeEncoder<compression_level_t>::GetAndEncodeAxis(
+    RandomAccessIteratorT begin, RandomAccessIteratorT end,
+    const VectorUint32 &old_base, const VectorUint32 &levels,
+    uint32_t last_axis) {
+  if (!Policy::select_axis) {
+    return DRACO_INCREMENT_MOD(last_axis, dimension_);
+  }
+
+  // For many points this function selects the axis that should be used
+  // for the split by keeping as many points as possible bundled.
+  // In the best case we do not split the point cloud at all.
+  // For lower number of points, we simply choose the axis that is refined the
+  // least so far.
+
+  DRACO_DCHECK_EQ(true, end - begin != 0);
+
+  uint32_t best_axis = 0;
+  if (end - begin < 64) {
+    for (uint32_t axis = 1; axis < dimension_; ++axis) {
+      if (levels[best_axis] > levels[axis]) {
+        best_axis = axis;
+      }
+    }
+  } else {
+    const uint32_t size = static_cast<uint32_t>(end - begin);
+    for (uint32_t i = 0; i < dimension_; i++) {
+      deviations_[i] = 0;
+      num_remaining_bits_[i] = bit_length_ - levels[i];
+      if (num_remaining_bits_[i] > 0) {
+        const uint32_t split =
+            old_base[i] + (1 << (num_remaining_bits_[i] - 1));
+        for (auto it = begin; it != end; ++it) {
+          deviations_[i] += ((*it)[i] < split);
+        }
+        deviations_[i] = std::max(size - deviations_[i], deviations_[i]);
+      }
+    }
+
+    uint32_t max_value = 0;
+    best_axis = 0;
+    for (uint32_t i = 0; i < dimension_; i++) {
+      // If axis can be subdivided.
+      if (num_remaining_bits_[i]) {
+        // Check if this is the better axis.
+        if (max_value < deviations_[i]) {
+          max_value = deviations_[i];
+          best_axis = i;
+        }
+      }
+    }
+    axis_encoder_.EncodeLeastSignificantBits32(4, best_axis);
+  }
+
+  return best_axis;
+}
+
+template <int compression_level_t>
+template <class RandomAccessIteratorT>
+void DynamicIntegerPointsKdTreeEncoder<compression_level_t>::EncodeInternal(
+    RandomAccessIteratorT begin, RandomAccessIteratorT end) {
+  typedef EncodingStatus<RandomAccessIteratorT> Status;
+
+  base_stack_[0] = VectorUint32(dimension_, 0);
+  levels_stack_[0] = VectorUint32(dimension_, 0);
+  Status init_status(begin, end, 0, 0);
+  std::stack<Status> status_stack;
+  status_stack.push(init_status);
+
+  // TODO(hemmer): use preallocated vector instead of stack.
+  while (!status_stack.empty()) {
+    Status status = status_stack.top();
+    status_stack.pop();
+
+    begin = status.begin;
+    end = status.end;
+    const uint32_t last_axis = status.last_axis;
+    const uint32_t stack_pos = status.stack_pos;
+    const VectorUint32 &old_base = base_stack_[stack_pos];
+    const VectorUint32 &levels = levels_stack_[stack_pos];
+
+    const uint32_t axis =
+        GetAndEncodeAxis(begin, end, old_base, levels, last_axis);
+    const uint32_t level = levels[axis];
+    const uint32_t num_remaining_points = static_cast<uint32_t>(end - begin);
+
+    // If this happens all axis are subdivided to the end.
+    if ((bit_length_ - level) == 0) {
+      continue;
+    }
+
+    // Fast encoding of remaining bits if number of points is 1 or 2.
+    // Doing this also for 2 gives a slight additional speed up.
+    if (num_remaining_points <= 2) {
+      // TODO(hemmer): axes_ not necessary, remove would change bitstream!
+      axes_[0] = axis;
+      for (uint32_t i = 1; i < dimension_; i++) {
+        axes_[i] = DRACO_INCREMENT_MOD(axes_[i - 1], dimension_);
+      }
+      for (uint32_t i = 0; i < num_remaining_points; ++i) {
+        const auto &p = *(begin + i);
+        for (uint32_t j = 0; j < dimension_; j++) {
+          const uint32_t num_remaining_bits = bit_length_ - levels[axes_[j]];
+          if (num_remaining_bits) {
+            remaining_bits_encoder_.EncodeLeastSignificantBits32(
+                num_remaining_bits, p[axes_[j]]);
+          }
+        }
+      }
+      continue;
+    }
+
+    const uint32_t num_remaining_bits = bit_length_ - level;
+    const uint32_t modifier = 1 << (num_remaining_bits - 1);
+    base_stack_[stack_pos + 1] = old_base;  // copy
+    base_stack_[stack_pos + 1][axis] += modifier;
+    const VectorUint32 &new_base = base_stack_[stack_pos + 1];
+
+    const RandomAccessIteratorT split =
+        std::partition(begin, end, Splitter(axis, new_base[axis]));
+
+    DRACO_DCHECK_EQ(true, (end - begin) > 0);
+
+    // Encode number of points in first and second half.
+    const int required_bits = MostSignificantBit(num_remaining_points);
+
+    const uint32_t first_half = static_cast<uint32_t>(split - begin);
+    const uint32_t second_half = static_cast<uint32_t>(end - split);
+    const bool left = first_half < second_half;
+
+    if (first_half != second_half) {
+      half_encoder_.EncodeBit(left);
+    }
+
+    if (left) {
+      EncodeNumber(required_bits, num_remaining_points / 2 - first_half);
+    } else {
+      EncodeNumber(required_bits, num_remaining_points / 2 - second_half);
+    }
+
+    levels_stack_[stack_pos][axis] += 1;
+    levels_stack_[stack_pos + 1] = levels_stack_[stack_pos];  // copy
+    if (split != begin) {
+      status_stack.push(Status(begin, split, axis, stack_pos));
+    }
+    if (split != end) {
+      status_stack.push(Status(split, end, axis, stack_pos + 1));
+    }
+  }
+}
+extern template class DynamicIntegerPointsKdTreeEncoder<0>;
+extern template class DynamicIntegerPointsKdTreeEncoder<2>;
+extern template class DynamicIntegerPointsKdTreeEncoder<4>;
+extern template class DynamicIntegerPointsKdTreeEncoder<6>;
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_DYNAMIC_INTEGER_POINTS_KD_TREE_ENCODER_H_
diff --git a/engine/inc/draco/compression/point_cloud/algorithms/float_points_tree_decoder.h b/engine/inc/draco/compression/point_cloud/algorithms/float_points_tree_decoder.h
new file mode 100644
index 00000000..4f09ed2c
--- /dev/null
+++ b/engine/inc/draco/compression/point_cloud/algorithms/float_points_tree_decoder.h
@@ -0,0 +1,141 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_FLOAT_POINTS_TREE_DECODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_FLOAT_POINTS_TREE_DECODER_H_
+
+#include <memory>
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/point_cloud/algorithms/point_cloud_compression_method.h"
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+#include "draco/compression/point_cloud/algorithms/quantize_points_3.h"
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+
+// Decodes a point cloud encoded by PointCloudTreeEncoder.
+class FloatPointsTreeDecoder {
+ public:
+  FloatPointsTreeDecoder();
+
+  // Decodes a point cloud from |buffer|.
+  template <class OutputIteratorT>
+  bool DecodePointCloud(DecoderBuffer *buffer, OutputIteratorT &out);
+
+#ifndef DRACO_OLD_GCC
+  template <class OutputIteratorT>
+  bool DecodePointCloud(DecoderBuffer *buffer, OutputIteratorT &&out);
+#endif  // DRACO_OLD_GCC
+
+  // Initializes a DecoderBuffer from |data|, and calls function above.
+  template <class OutputIteratorT>
+  bool DecodePointCloud(const char *data, size_t data_size,
+                        OutputIteratorT out) {
+    if (data == 0 || data_size <= 0) {
+      return false;
+    }
+
+    DecoderBuffer buffer;
+    buffer.Init(data, data_size);
+    buffer.set_bitstream_version(kDracoPointCloudBitstreamVersion);
+    return DecodePointCloud(&buffer, out);
+  }
+
+  uint32_t quantization_bits() const { return qinfo_.quantization_bits; }
+  uint32_t compression_level() const { return compression_level_; }
+  float range() const { return qinfo_.range; }
+  uint32_t num_points() const { return num_points_; }
+  uint32_t version() const { return version_; }
+  std::string identification_string() const {
+    if (method_ == KDTREE) {
+      return "FloatPointsTreeDecoder: IntegerPointsKDTreeDecoder";
+    } else {
+      return "FloatPointsTreeDecoder: Unsupported Method";
+    }
+  }
+
+  void set_num_points_from_header(uint32_t num_points) {
+    num_points_from_header_ = num_points;
+  }
+
+ private:
+  bool DecodePointCloudKdTreeInternal(DecoderBuffer *buffer,
+                                      std::vector<Point3ui> *qpoints);
+
+  static const uint32_t version_ = 3;
+  QuantizationInfo qinfo_;
+  PointCloudCompressionMethod method_;
+  uint32_t num_points_;
+  uint32_t compression_level_;
+
+  // Member variable to check if the number of points from the file header
+  // matches the number of points in the compression header. If
+  // |num_points_from_header_| is 0, do not perform the check. Defaults to 0.
+  uint32_t num_points_from_header_;
+};
+
+#ifndef DRACO_OLD_GCC
+// TODO(vytyaz): Reenable once USD migrates from GCC 4.8 to a higher version
+// that can disambiguate calls to overloaded methods taking rvalue reference.
+template <class OutputIteratorT>
+bool FloatPointsTreeDecoder::DecodePointCloud(DecoderBuffer *buffer,
+                                              OutputIteratorT &&out) {
+  OutputIteratorT local = std::forward<OutputIteratorT>(out);
+  return DecodePointCloud(buffer, local);
+}
+#endif  // DRACO_OLD_GCC
+
+template <class OutputIteratorT>
+bool FloatPointsTreeDecoder::DecodePointCloud(DecoderBuffer *buffer,
+                                              OutputIteratorT &out) {
+  std::vector<Point3ui> qpoints;
+
+  uint32_t decoded_version;
+  if (!buffer->Decode(&decoded_version)) {
+    return false;
+  }
+
+  if (decoded_version == 3) {
+    int8_t method_number;
+    if (!buffer->Decode(&method_number)) {
+      return false;
+    }
+
+    method_ = static_cast<PointCloudCompressionMethod>(method_number);
+
+    if (method_ == KDTREE) {
+      if (!DecodePointCloudKdTreeInternal(buffer, &qpoints)) {
+        return false;
+      }
+    } else {  // Unsupported method.
+      fprintf(stderr, "Method not supported. \n");
+      return false;
+    }
+  } else if (decoded_version == 2) {  // Version 2 only uses KDTREE method.
+    if (!DecodePointCloudKdTreeInternal(buffer, &qpoints)) {
+      return false;
+    }
+  } else {  // Unsupported version.
+    fprintf(stderr, "Version not supported. \n");
+    return false;
+  }
+
+  DequantizePoints3(qpoints.begin(), qpoints.end(), qinfo_, out);
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_FLOAT_POINTS_TREE_DECODER_H_
diff --git a/engine/inc/draco/compression/point_cloud/algorithms/float_points_tree_encoder.h b/engine/inc/draco/compression/point_cloud/algorithms/float_points_tree_encoder.h
new file mode 100644
index 00000000..26ba94f1
--- /dev/null
+++ b/engine/inc/draco/compression/point_cloud/algorithms/float_points_tree_encoder.h
@@ -0,0 +1,126 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_FLOAT_POINTS_TREE_ENCODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_FLOAT_POINTS_TREE_ENCODER_H_
+
+#include <memory>
+#include <vector>
+
+#include "draco/compression/point_cloud/algorithms/point_cloud_compression_method.h"
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+#include "draco/compression/point_cloud/algorithms/quantize_points_3.h"
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// This class encodes a given point cloud based on the point cloud compression
+// algorithm in:
+// Olivier Devillers and Pierre-Marie Gandoin
+// "Geometric compression for interactive transmission"
+//
+// In principle the algorithm keeps on splitting the point cloud in the middle
+// while alternating the axes. For 3D this results in an Octree like structure.
+// In each step we encode the number of points in the first half.
+// The algorithm uses quantization and does not preserve the order of points.
+//
+// However, the algorithm here differs from the original as follows:
+// The algorithm keeps on splitting the point cloud in the middle of the axis
+// that keeps the point cloud as clustered as possible, which gives a better
+// compression rate.
+// The number of points is encode by the deviation from the half of the points
+// in the smaller half of the two. This results in a better compression rate as
+// there are more leading zeros, which is then compressed better by the
+// arithmetic encoding.
+
+// TODO(hemmer): Remove class because it duplicates quantization code.
+class FloatPointsTreeEncoder {
+ public:
+  explicit FloatPointsTreeEncoder(PointCloudCompressionMethod method);
+  explicit FloatPointsTreeEncoder(PointCloudCompressionMethod method,
+                                  uint32_t quantization_bits,
+                                  uint32_t compression_level);
+
+  template <class InputIteratorT>
+  bool EncodePointCloud(InputIteratorT points_begin, InputIteratorT points_end);
+  EncoderBuffer *buffer() { return &buffer_; }
+
+  uint32_t version() const { return version_; }
+  uint32_t quantization_bits() const { return qinfo_.quantization_bits; }
+  uint32_t &quantization_bits() { return qinfo_.quantization_bits; }
+  uint32_t compression_level() const { return compression_level_; }
+  uint32_t &compression_level() { return compression_level_; }
+  float range() const { return qinfo_.range; }
+  uint32_t num_points() const { return num_points_; }
+  std::string identification_string() const {
+    if (method_ == KDTREE) {
+      return "FloatPointsTreeEncoder: IntegerPointsKDTreeEncoder";
+    } else {
+      return "FloatPointsTreeEncoder: Unsupported Method";
+    }
+  }
+
+ private:
+  void Clear() { buffer_.Clear(); }
+  bool EncodePointCloudKdTreeInternal(std::vector<Point3ui> *qpoints);
+
+  static const uint32_t version_;
+  QuantizationInfo qinfo_;
+  PointCloudCompressionMethod method_;
+  uint32_t num_points_;
+  EncoderBuffer buffer_;
+  uint32_t compression_level_;
+};
+
+template <class InputIteratorT>
+bool FloatPointsTreeEncoder::EncodePointCloud(InputIteratorT points_begin,
+                                              InputIteratorT points_end) {
+  Clear();
+
+  // Collect necessary data for encoding.
+  num_points_ = std::distance(points_begin, points_end);
+
+  // TODO(hemmer): Extend quantization tools to make this more automatic.
+  // Compute range of points for quantization
+  std::vector<Point3ui> qpoints;
+  qpoints.reserve(num_points_);
+  QuantizePoints3(points_begin, points_end, &qinfo_,
+                  std::back_inserter(qpoints));
+
+  // Encode header.
+  buffer()->Encode(version_);
+  buffer()->Encode(static_cast<int8_t>(method_));
+  buffer()->Encode(qinfo_.quantization_bits);
+  buffer()->Encode(qinfo_.range);
+  buffer()->Encode(num_points_);
+
+  if (method_ == KDTREE) {
+    buffer()->Encode(compression_level_);
+  }
+
+  if (num_points_ == 0) {
+    return true;
+  }
+
+  if (method_ == KDTREE) {
+    return EncodePointCloudKdTreeInternal(&qpoints);
+  } else {  // Unsupported method.
+    fprintf(stderr, "Method not supported. \n");
+    return false;
+  }
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_FLOAT_POINTS_TREE_ENCODER_H_
diff --git a/engine/inc/draco/compression/point_cloud/algorithms/integer_points_kd_tree_decoder.h b/engine/inc/draco/compression/point_cloud/algorithms/integer_points_kd_tree_decoder.h
new file mode 100644
index 00000000..94e523ca
--- /dev/null
+++ b/engine/inc/draco/compression/point_cloud/algorithms/integer_points_kd_tree_decoder.h
@@ -0,0 +1,314 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// TODO(hemmer): Make this a wrapper using DynamicIntegerPointsKdTreeDecoder.
+//
+// See integer_points_kd_tree_encoder.h for documentation.
+
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_INTEGER_POINTS_KD_TREE_DECODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_INTEGER_POINTS_KD_TREE_DECODER_H_
+
+#include <array>
+#include <memory>
+
+#include "draco/compression/bit_coders/adaptive_rans_bit_decoder.h"
+#include "draco/compression/bit_coders/direct_bit_decoder.h"
+#include "draco/compression/bit_coders/folded_integer_bit_decoder.h"
+#include "draco/compression/bit_coders/rans_bit_decoder.h"
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+#include "draco/compression/point_cloud/algorithms/queuing_policy.h"
+#include "draco/core/bit_utils.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/math_utils.h"
+
+namespace draco {
+
+template <int compression_level_t>
+struct IntegerPointsKdTreeDecoderCompressionPolicy
+    : public IntegerPointsKdTreeDecoderCompressionPolicy<compression_level_t -
+                                                         1> {};
+
+template <>
+struct IntegerPointsKdTreeDecoderCompressionPolicy<0> {
+  typedef DirectBitDecoder NumbersDecoder;
+  typedef DirectBitDecoder AxisDecoder;
+  typedef DirectBitDecoder HalfDecoder;
+  typedef DirectBitDecoder RemainingBitsDecoder;
+  static constexpr bool select_axis = false;
+
+  template <class T>
+  using QueuingStrategy = Stack<T>;
+};
+
+template <>
+struct IntegerPointsKdTreeDecoderCompressionPolicy<2>
+    : public IntegerPointsKdTreeDecoderCompressionPolicy<1> {
+  typedef RAnsBitDecoder NumbersDecoder;
+};
+
+template <>
+struct IntegerPointsKdTreeDecoderCompressionPolicy<4>
+    : public IntegerPointsKdTreeDecoderCompressionPolicy<3> {
+  typedef FoldedBit32Decoder<RAnsBitDecoder> NumbersDecoder;
+};
+
+template <>
+struct IntegerPointsKdTreeDecoderCompressionPolicy<6>
+    : public IntegerPointsKdTreeDecoderCompressionPolicy<5> {
+  static constexpr bool select_axis = true;
+};
+
+template <>
+struct IntegerPointsKdTreeDecoderCompressionPolicy<8>
+    : public IntegerPointsKdTreeDecoderCompressionPolicy<7> {
+  typedef FoldedBit32Decoder<AdaptiveRAnsBitDecoder> NumbersDecoder;
+  template <class T>
+  using QueuingStrategy = Queue<T>;
+};
+
+template <>
+struct IntegerPointsKdTreeDecoderCompressionPolicy<10>
+    : public IntegerPointsKdTreeDecoderCompressionPolicy<9> {
+  template <class T>
+  using QueuingStrategy = PriorityQueue<T>;
+};
+
+// Decodes a point cloud encoded by IntegerPointsKdTreeEncoder.
+// |PointDiT| is a type representing a point with uint32_t coordinates.
+// must provide construction from three uint32_t and operator[].
+template <class PointDiT, int compression_level_t>
+class IntegerPointsKdTreeDecoder {
+  typedef IntegerPointsKdTreeDecoderCompressionPolicy<compression_level_t>
+      Policy;
+
+  typedef typename Policy::NumbersDecoder NumbersDecoder;
+  typedef typename Policy::AxisDecoder AxisDecoder;
+  typedef typename Policy::HalfDecoder HalfDecoder;
+  typedef typename Policy::RemainingBitsDecoder RemainingBitsDecoder;
+
+ public:
+  IntegerPointsKdTreeDecoder() : bit_length_(0) {}
+
+  // Decodes a integer point cloud from |buffer|.
+  template <class OutputIteratorT>
+  bool DecodePoints(DecoderBuffer *buffer, OutputIteratorT oit);
+
+ private:
+  // For the sake of readability of code, we decided to make this exception
+  // from the naming scheme.
+  static constexpr int D = PointTraits<PointDiT>::Dimension();
+
+  uint32_t GetAxis(uint32_t num_remaining_points, const PointDiT &base,
+                   std::array<uint32_t, D> levels, uint32_t last_axis);
+
+  template <class OutputIteratorT>
+  void DecodeInternal(uint32_t num_remaining_points, PointDiT base,
+                      std::array<uint32_t, D> levels, uint32_t last_axis,
+                      OutputIteratorT oit);
+
+  void DecodeNumber(int nbits, uint32_t *value) {
+    numbers_decoder_.DecodeLeastSignificantBits32(nbits, value);
+  }
+
+  struct DecodingStatus {
+    DecodingStatus(
+        uint32_t num_remaining_points_, const PointDiT &old_base_,
+        std::array<uint32_t, PointTraits<PointDiT>::Dimension()> levels_,
+        uint32_t last_axis_)
+        : num_remaining_points(num_remaining_points_),
+          old_base(old_base_),
+          levels(levels_),
+          last_axis(last_axis_) {}
+
+    uint32_t num_remaining_points;
+    PointDiT old_base;
+    std::array<uint32_t, D> levels;
+    uint32_t last_axis;
+    friend bool operator<(const DecodingStatus &l, const DecodingStatus &r) {
+      return l.num_remaining_points < r.num_remaining_points;
+    }
+  };
+
+  uint32_t bit_length_;
+  uint32_t num_points_;
+  NumbersDecoder numbers_decoder_;
+  RemainingBitsDecoder remaining_bits_decoder_;
+  AxisDecoder axis_decoder_;
+  HalfDecoder half_decoder_;
+};
+
+// Decodes a point cloud from |buffer|.
+template <class PointDiT, int compression_level_t>
+template <class OutputIteratorT>
+bool IntegerPointsKdTreeDecoder<PointDiT, compression_level_t>::DecodePoints(
+    DecoderBuffer *buffer, OutputIteratorT oit) {
+  if (!buffer->Decode(&bit_length_)) {
+    return false;
+  }
+  if (!buffer->Decode(&num_points_)) {
+    return false;
+  }
+  if (num_points_ == 0) {
+    return true;
+  }
+
+  if (!numbers_decoder_.StartDecoding(buffer)) {
+    return false;
+  }
+  if (!remaining_bits_decoder_.StartDecoding(buffer)) {
+    return false;
+  }
+  if (!axis_decoder_.StartDecoding(buffer)) {
+    return false;
+  }
+  if (!half_decoder_.StartDecoding(buffer)) {
+    return false;
+  }
+
+  DecodeInternal(num_points_, PointTraits<PointDiT>::Origin(),
+                 PointTraits<PointDiT>::ZeroArray(), 0, oit);
+
+  numbers_decoder_.EndDecoding();
+  remaining_bits_decoder_.EndDecoding();
+  axis_decoder_.EndDecoding();
+  half_decoder_.EndDecoding();
+
+  return true;
+}
+
+template <class PointDiT, int compression_level_t>
+uint32_t IntegerPointsKdTreeDecoder<PointDiT, compression_level_t>::GetAxis(
+    uint32_t num_remaining_points, const PointDiT & /* base */,
+    std::array<uint32_t, D> levels, uint32_t last_axis) {
+  if (!Policy::select_axis) {
+    return DRACO_INCREMENT_MOD(last_axis, D);
+  }
+
+  uint32_t best_axis = 0;
+  if (num_remaining_points < 64) {
+    for (uint32_t axis = 1; axis < D; ++axis) {
+      if (levels[best_axis] > levels[axis]) {
+        best_axis = axis;
+      }
+    }
+  } else {
+    axis_decoder_.DecodeLeastSignificantBits32(4, &best_axis);
+  }
+
+  return best_axis;
+}
+
+template <class PointDiT, int compression_level_t>
+template <class OutputIteratorT>
+void IntegerPointsKdTreeDecoder<PointDiT, compression_level_t>::DecodeInternal(
+    uint32_t num_remaining_points, PointDiT old_base,
+    std::array<uint32_t, D> levels, uint32_t last_axis, OutputIteratorT oit) {
+  DecodingStatus init_status(num_remaining_points, old_base, levels, last_axis);
+  typename Policy::template QueuingStrategy<DecodingStatus> status_q;
+  status_q.push(init_status);
+
+  while (!status_q.empty()) {
+    const DecodingStatus status = status_q.front();
+    status_q.pop();
+
+    num_remaining_points = status.num_remaining_points;
+    old_base = status.old_base;
+    levels = status.levels;
+    last_axis = status.last_axis;
+
+    const uint32_t axis =
+        GetAxis(num_remaining_points, old_base, levels, last_axis);
+
+    const uint32_t level = levels[axis];
+
+    // All axes have been fully subdivided, just output points.
+    if ((bit_length_ - level) == 0) {
+      for (int i = 0; i < static_cast<int>(num_remaining_points); i++) {
+        *oit++ = old_base;
+      }
+      continue;
+    }
+
+    DRACO_DCHECK_EQ(true, num_remaining_points != 0);
+    if (num_remaining_points <= 2) {
+      std::array<uint32_t, D> axes;
+      axes[0] = axis;
+      for (int i = 1; i < D; i++) {
+        axes[i] = DRACO_INCREMENT_MOD(axes[i - 1], D);
+      }
+
+      std::array<uint32_t, D> num_remaining_bits;
+      for (int i = 0; i < D; i++) {
+        num_remaining_bits[i] = bit_length_ - levels[axes[i]];
+      }
+
+      for (uint32_t i = 0; i < num_remaining_points; ++i) {
+        // Get remaining bits, mind the carry if not starting at x.
+        PointDiT p = PointTraits<PointDiT>::Origin();
+        for (int j = 0; j < static_cast<int>(D); j++) {
+          if (num_remaining_bits[j]) {
+            remaining_bits_decoder_.DecodeLeastSignificantBits32(
+                num_remaining_bits[j], &p[axes[j]]);
+          }
+          p[axes[j]] = old_base[axes[j]] | p[axes[j]];
+        }
+        *oit++ = p;
+      }
+      continue;
+    }
+
+    const int num_remaining_bits = bit_length_ - level;
+    const uint32_t modifier = 1 << (num_remaining_bits - 1);
+    PointDiT new_base(old_base);
+    new_base[axis] += modifier;
+
+    const int incoming_bits = MostSignificantBit(num_remaining_points);
+
+    uint32_t number = 0;
+    DecodeNumber(incoming_bits, &number);
+
+    uint32_t first_half = num_remaining_points / 2 - number;
+    uint32_t second_half = num_remaining_points - first_half;
+
+    if (first_half != second_half) {
+      if (!half_decoder_.DecodeNextBit()) {
+        std::swap(first_half, second_half);
+      }
+    }
+
+    levels[axis] += 1;
+    if (first_half) {
+      status_q.push(DecodingStatus(first_half, old_base, levels, axis));
+    }
+    if (second_half) {
+      status_q.push(DecodingStatus(second_half, new_base, levels, axis));
+    }
+  }
+}
+
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 0>;
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 1>;
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 2>;
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 3>;
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 4>;
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 5>;
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 6>;
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 7>;
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 8>;
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 9>;
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 10>;
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_INTEGER_POINTS_KD_TREE_DECODER_H_
diff --git a/engine/inc/draco/compression/point_cloud/algorithms/integer_points_kd_tree_encoder.h b/engine/inc/draco/compression/point_cloud/algorithms/integer_points_kd_tree_encoder.h
new file mode 100644
index 00000000..b8811092
--- /dev/null
+++ b/engine/inc/draco/compression/point_cloud/algorithms/integer_points_kd_tree_encoder.h
@@ -0,0 +1,404 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// TODO(hemmer): Make this a wrapper using DynamicIntegerPointsKdTreeEncoder.
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_INTEGER_POINTS_KD_TREE_ENCODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_INTEGER_POINTS_KD_TREE_ENCODER_H_
+
+#include <algorithm>
+#include <array>
+#include <memory>
+#include <vector>
+
+#include "draco/compression/bit_coders/adaptive_rans_bit_encoder.h"
+#include "draco/compression/bit_coders/direct_bit_encoder.h"
+#include "draco/compression/bit_coders/folded_integer_bit_encoder.h"
+#include "draco/compression/bit_coders/rans_bit_encoder.h"
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+#include "draco/compression/point_cloud/algorithms/queuing_policy.h"
+#include "draco/core/bit_utils.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/core/math_utils.h"
+
+namespace draco {
+
+// This policy class provides several configurations for the encoder that allow
+// to trade speed vs compression rate. Level 0 is fastest while 10 is the best
+// compression rate. The decoder must select the same level.
+template <int compression_level_t>
+struct IntegerPointsKdTreeEncoderCompressionPolicy
+    : public IntegerPointsKdTreeEncoderCompressionPolicy<compression_level_t -
+                                                         1> {};
+
+template <>
+struct IntegerPointsKdTreeEncoderCompressionPolicy<0> {
+  typedef DirectBitEncoder NumbersEncoder;
+  typedef DirectBitEncoder AxisEncoder;
+  typedef DirectBitEncoder HalfEncoder;
+  typedef DirectBitEncoder RemainingBitsEncoder;
+  static constexpr bool select_axis = false;
+
+  template <class T>
+  using QueuingStrategy = Stack<T>;
+};
+
+template <>
+struct IntegerPointsKdTreeEncoderCompressionPolicy<2>
+    : public IntegerPointsKdTreeEncoderCompressionPolicy<1> {
+  typedef RAnsBitEncoder NumbersEncoder;
+};
+
+template <>
+struct IntegerPointsKdTreeEncoderCompressionPolicy<4>
+    : public IntegerPointsKdTreeEncoderCompressionPolicy<3> {
+  typedef FoldedBit32Encoder<RAnsBitEncoder> NumbersEncoder;
+};
+
+template <>
+struct IntegerPointsKdTreeEncoderCompressionPolicy<6>
+    : public IntegerPointsKdTreeEncoderCompressionPolicy<5> {
+  static constexpr bool select_axis = true;
+};
+
+template <>
+struct IntegerPointsKdTreeEncoderCompressionPolicy<8>
+    : public IntegerPointsKdTreeEncoderCompressionPolicy<7> {
+  typedef FoldedBit32Encoder<AdaptiveRAnsBitEncoder> NumbersEncoder;
+  template <class T>
+  using QueuingStrategy = Queue<T>;
+};
+
+template <>
+struct IntegerPointsKdTreeEncoderCompressionPolicy<10>
+    : public IntegerPointsKdTreeEncoderCompressionPolicy<9> {
+  template <class T>
+  using QueuingStrategy = PriorityQueue<T>;
+};
+
+// This class encodes a given integer point cloud based on the point cloud
+// compression algorithm in:
+// Olivier Devillers and Pierre-Marie Gandoin
+// "Geometric compression for interactive transmission"
+//
+// In principle the algorithm keeps on splitting the point cloud in the middle
+// while alternating the axes. In 3D this results in an Octree like structure.
+// In each step we encode the number of points in the first half.
+// The algorithm does not preserve the order of points.
+//
+// However, the algorithm here differs from the original as follows:
+// The algorithm keeps on splitting the point cloud in the middle of the axis
+// that keeps the point cloud as clustered as possible, which gives a better
+// compression rate.
+// The number of points is encode by the deviation from the half of the points
+// in the smaller half of the two. This results in a better compression rate as
+// there are more leading zeros, which is then compressed better by the
+// arithmetic encoding.
+//
+// |PointDiT| is a type representing a point with uint32_t coordinates.
+// must provide construction from three uint32_t and operator[].
+template <class PointDiT, int compression_level_t>
+class IntegerPointsKdTreeEncoder {
+  typedef IntegerPointsKdTreeEncoderCompressionPolicy<compression_level_t>
+      Policy;
+  typedef typename Policy::NumbersEncoder NumbersEncoder;
+  typedef typename Policy::AxisEncoder AxisEncoder;
+  typedef typename Policy::HalfEncoder HalfEncoder;
+  typedef typename Policy::RemainingBitsEncoder RemainingBitsEncoder;
+
+ public:
+  IntegerPointsKdTreeEncoder() : bit_length_(0) {}
+
+  // Encodes an integer point cloud given by [begin,end) into buffer.
+  // |bit_length| gives the highest bit used for all coordinates.
+  template <class RandomAccessIteratorT>
+  bool EncodePoints(RandomAccessIteratorT begin, RandomAccessIteratorT end,
+                    const uint32_t &bit_length, EncoderBuffer *buffer);
+
+  // Encodes an integer point cloud given by [begin,end) into buffer.
+  template <class RandomAccessIteratorT>
+  bool EncodePoints(RandomAccessIteratorT begin, RandomAccessIteratorT end,
+                    EncoderBuffer *buffer) {
+    return EncodePoints(begin, end, 32, buffer);
+  }
+
+ private:
+  // For the sack of readability of code, we decided to make this exception
+  // from the naming scheme.
+  static constexpr int D = PointTraits<PointDiT>::Dimension();
+  template <class RandomAccessIteratorT>
+  uint32_t GetAxis(RandomAccessIteratorT begin, RandomAccessIteratorT end,
+                   const PointDiT &old_base, std::array<uint32_t, D> levels,
+                   uint32_t last_axis);
+
+  template <class RandomAccessIteratorT>
+  void EncodeInternal(RandomAccessIteratorT begin, RandomAccessIteratorT end,
+                      PointDiT old_base, std::array<uint32_t, D> levels,
+                      uint32_t last_axis);
+
+  class Splitter {
+   public:
+    Splitter(int axis, uint32_t value) : axis_(axis), value_(value) {}
+    bool operator()(const PointDiT &a) { return a[axis_] < value_; }
+
+   private:
+    int axis_;
+    uint32_t value_;
+  };
+
+  void EncodeNumber(int nbits, uint32_t value) {
+    numbers_encoder_.EncodeLeastSignificantBits32(nbits, value);
+  }
+
+  template <class RandomAccessIteratorT>
+  struct EncodingStatus {
+    EncodingStatus(
+        RandomAccessIteratorT begin_, RandomAccessIteratorT end_,
+        const PointDiT &old_base_,
+        std::array<uint32_t, PointTraits<PointDiT>::Dimension()> levels_,
+        uint32_t last_axis_)
+        : begin(begin_),
+          end(end_),
+          old_base(old_base_),
+          levels(levels_),
+          last_axis(last_axis_) {
+      num_remaining_points = end - begin;
+    }
+
+    RandomAccessIteratorT begin;
+    RandomAccessIteratorT end;
+    PointDiT old_base;
+    std::array<uint32_t, D> levels;
+    uint32_t last_axis;
+    uint32_t num_remaining_points;
+    friend bool operator<(const EncodingStatus &l, const EncodingStatus &r) {
+      return l.num_remaining_points < r.num_remaining_points;
+    }
+  };
+
+  uint32_t bit_length_;
+  uint32_t num_points_;
+  NumbersEncoder numbers_encoder_;
+  RemainingBitsEncoder remaining_bits_encoder_;
+  AxisEncoder axis_encoder_;
+  HalfEncoder half_encoder_;
+};
+
+template <class PointDiT, int compression_level_t>
+template <class RandomAccessIteratorT>
+bool IntegerPointsKdTreeEncoder<PointDiT, compression_level_t>::EncodePoints(
+    RandomAccessIteratorT begin, RandomAccessIteratorT end,
+    const uint32_t &bit_length, EncoderBuffer *buffer) {
+  bit_length_ = bit_length;
+  num_points_ = end - begin;
+
+  buffer->Encode(bit_length_);
+  buffer->Encode(num_points_);
+  if (num_points_ == 0) {
+    return true;
+  }
+
+  numbers_encoder_.StartEncoding();
+  remaining_bits_encoder_.StartEncoding();
+  axis_encoder_.StartEncoding();
+  half_encoder_.StartEncoding();
+
+  EncodeInternal(begin, end, PointTraits<PointDiT>::Origin(),
+                 PointTraits<PointDiT>::ZeroArray(), 0);
+
+  numbers_encoder_.EndEncoding(buffer);
+  remaining_bits_encoder_.EndEncoding(buffer);
+  axis_encoder_.EndEncoding(buffer);
+  half_encoder_.EndEncoding(buffer);
+
+  return true;
+}
+template <class PointDiT, int compression_level_t>
+template <class RandomAccessIteratorT>
+uint32_t IntegerPointsKdTreeEncoder<PointDiT, compression_level_t>::GetAxis(
+    RandomAccessIteratorT begin, RandomAccessIteratorT end,
+    const PointDiT &old_base, std::array<uint32_t, D> levels,
+    uint32_t last_axis) {
+  if (!Policy::select_axis) {
+    return DRACO_INCREMENT_MOD(last_axis, D);
+  }
+
+  // For many points this function selects the axis that should be used
+  // for the split by keeping as many points as possible bundled.
+  // In the best case we do not split the point cloud at all.
+  // For lower number of points, we simply choose the axis that is refined the
+  // least so far.
+
+  DRACO_DCHECK_EQ(true, end - begin != 0);
+
+  uint32_t best_axis = 0;
+  if (end - begin < 64) {
+    for (uint32_t axis = 1; axis < D; ++axis) {
+      if (levels[best_axis] > levels[axis]) {
+        best_axis = axis;
+      }
+    }
+  } else {
+    const uint32_t size = (end - begin);
+    std::array<uint32_t, D> num_remaining_bits =
+        PointTraits<PointDiT>::ZeroArray();
+    for (int i = 0; i < D; i++) {
+      num_remaining_bits[i] = bit_length_ - levels[i];
+    }
+    PointDiT split(old_base);
+
+    for (int i = 0; i < D; i++) {
+      if (num_remaining_bits[i]) {
+        split[i] += 1 << (num_remaining_bits[i] - 1);
+      }
+    }
+
+    std::array<uint32_t, D> deviations = PointTraits<PointDiT>::ZeroArray();
+    for (auto it = begin; it != end; ++it) {
+      for (int i = 0; i < D; i++) {
+        deviations[i] += ((*it)[i] < split[i]);
+      }
+    }
+    for (int i = 0; i < D; i++) {
+      deviations[i] = std::max(size - deviations[i], deviations[i]);
+    }
+
+    uint32_t max_value = 0;
+    best_axis = 0;
+    for (int i = 0; i < D; i++) {
+      // If axis can be subdivided.
+      if (num_remaining_bits[i]) {
+        // Check if this is the better axis.
+        if (max_value < deviations[i]) {
+          max_value = deviations[i];
+          best_axis = i;
+        }
+      }
+    }
+    axis_encoder_.EncodeLeastSignificantBits32(4, best_axis);
+  }
+
+  return best_axis;
+}
+
+template <class PointDiT, int compression_level_t>
+template <class RandomAccessIteratorT>
+void IntegerPointsKdTreeEncoder<PointDiT, compression_level_t>::EncodeInternal(
+    RandomAccessIteratorT begin, RandomAccessIteratorT end, PointDiT old_base,
+    std::array<uint32_t, D> levels, uint32_t last_axis) {
+  EncodingStatus<RandomAccessIteratorT> init_status(begin, end, old_base,
+                                                    levels, last_axis);
+  typename Policy::template QueuingStrategy<
+      EncodingStatus<RandomAccessIteratorT>>
+      status_q;
+
+  status_q.push(init_status);
+
+  while (!status_q.empty()) {
+    EncodingStatus<RandomAccessIteratorT> status = status_q.front();
+    status_q.pop();
+
+    begin = status.begin;
+    end = status.end;
+    old_base = status.old_base;
+    levels = status.levels;
+    last_axis = status.last_axis;
+
+    const uint32_t axis = GetAxis(begin, end, old_base, levels, last_axis);
+    const uint32_t level = levels[axis];
+    const uint32_t num_remaining_points = end - begin;
+
+    // If this happens all axis are subdivided to the end.
+    if ((bit_length_ - level) == 0) {
+      continue;
+    }
+
+    // Fast encoding of remaining bits if number of points is 1.
+    // Doing this also for 2 gives a slight additional speed up.
+    if (num_remaining_points <= 2) {
+      std::array<uint32_t, D> axes;
+      axes[0] = axis;
+      for (int i = 1; i < D; i++) {
+        axes[i] = DRACO_INCREMENT_MOD(axes[i - 1], D);
+      }
+
+      std::array<uint32_t, D> num_remaining_bits;
+      for (int i = 0; i < D; i++) {
+        num_remaining_bits[i] = bit_length_ - levels[axes[i]];
+      }
+
+      for (uint32_t i = 0; i < num_remaining_points; ++i) {
+        const PointDiT &p = *(begin + i);
+        for (int j = 0; j < D; j++) {
+          if (num_remaining_bits[j]) {
+            remaining_bits_encoder_.EncodeLeastSignificantBits32(
+                num_remaining_bits[j], p[axes[j]]);
+          }
+        }
+      }
+      continue;
+    }
+
+    const uint32_t num_remaining_bits = bit_length_ - level;
+    const uint32_t modifier = 1 << (num_remaining_bits - 1);
+    PointDiT new_base(old_base);
+    new_base[axis] += modifier;
+    const RandomAccessIteratorT split =
+        std::partition(begin, end, Splitter(axis, new_base[axis]));
+
+    DRACO_DCHECK_EQ(true, (end - begin) > 0);
+
+    // Encode number of points in first and second half.
+    const int required_bits = MostSignificantBit(num_remaining_points);
+
+    const uint32_t first_half = split - begin;
+    const uint32_t second_half = end - split;
+    const bool left = first_half < second_half;
+
+    if (first_half != second_half) {
+      half_encoder_.EncodeBit(left);
+    }
+
+    if (left) {
+      EncodeNumber(required_bits, num_remaining_points / 2 - first_half);
+    } else {
+      EncodeNumber(required_bits, num_remaining_points / 2 - second_half);
+    }
+
+    levels[axis] += 1;
+    if (split != begin) {
+      status_q.push(EncodingStatus<RandomAccessIteratorT>(
+          begin, split, old_base, levels, axis));
+    }
+    if (split != end) {
+      status_q.push(EncodingStatus<RandomAccessIteratorT>(split, end, new_base,
+                                                          levels, axis));
+    }
+  }
+}
+
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 0>;
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 1>;
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 2>;
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 3>;
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 4>;
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 5>;
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 6>;
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 7>;
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 8>;
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 9>;
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 10>;
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_INTEGER_POINTS_KD_TREE_ENCODER_H_
diff --git a/engine/inc/draco/compression/point_cloud/algorithms/point_cloud_compression_method.h b/engine/inc/draco/compression/point_cloud/algorithms/point_cloud_compression_method.h
new file mode 100644
index 00000000..9541c966
--- /dev/null
+++ b/engine/inc/draco/compression/point_cloud/algorithms/point_cloud_compression_method.h
@@ -0,0 +1,34 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_POINT_CLOUD_COMPRESSION_METHOD_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_POINT_CLOUD_COMPRESSION_METHOD_H_
+
+namespace draco {
+
+// Enum indicating the used compression method, used by Encoder and Decoder.
+enum PointCloudCompressionMethod {
+  RESERVED_POINT_CLOUD_METHOD_0 = 0,  // Reserved for internal use.
+  // Generalized version of Encoding using the Octree method by Olivier
+  // Devillers to d dimensions.
+  // "Progressive lossless compression of arbitrary simplicial complexes"
+  // https://doi.org/10.1145/566570.566591
+  KDTREE = 1,
+  RESERVED_POINT_CLOUD_METHOD_2 = 2,  // Reserved for internal use.
+  RESERVED_POINT_CLOUD_METHOD_3 = 0,  // Reserved for internal use.
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_POINT_CLOUD_COMPRESSION_METHOD_H_
diff --git a/engine/inc/draco/compression/point_cloud/algorithms/point_cloud_types.h b/engine/inc/draco/compression/point_cloud/algorithms/point_cloud_types.h
new file mode 100644
index 00000000..893efbef
--- /dev/null
+++ b/engine/inc/draco/compression/point_cloud/algorithms/point_cloud_types.h
@@ -0,0 +1,76 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_POINT_CLOUD_TYPES_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_POINT_CLOUD_TYPES_H_
+
+#include <inttypes.h>
+
+#include <vector>
+
+#include "draco/core/vector_d.h"
+
+namespace draco {
+
+// Using Eigen as this is favored by project Cartographer.
+typedef Vector3f Point3f;
+typedef Vector4f Point4f;
+typedef Vector3ui Point3ui;
+typedef Vector4ui Point4ui;
+typedef Vector5ui Point5ui;
+typedef Vector6ui Point6ui;
+typedef Vector7ui Point7ui;
+
+typedef std::vector<Point3f> PointCloud3f;
+
+template <class PointDT>
+struct PointDLess;
+
+template <class CoeffT, int dimension_t>
+struct PointDLess<VectorD<CoeffT, dimension_t>> {
+  bool operator()(const VectorD<CoeffT, dimension_t> &a,
+                  const VectorD<CoeffT, dimension_t> &b) const {
+    return a < b;
+  }
+};
+
+template <class PointDT>
+class PointTraits {};
+
+template <class CoordinateTypeT, int dimension_t>
+class PointTraits<VectorD<CoordinateTypeT, dimension_t>> {
+ public:
+  typedef VectorD<CoordinateTypeT, dimension_t> PointD;
+  typedef CoordinateTypeT CoordinateType;
+
+  static constexpr uint32_t Dimension() { return dimension_t; }
+  static PointD Origin() {
+    PointD origin;
+    for (uint32_t i = 0; i < dimension_t; i++) {
+      origin(i) = 0;
+    }
+    return origin;
+  }
+  static std::array<uint32_t, dimension_t> ZeroArray() {
+    std::array<uint32_t, dimension_t> zero;
+    for (uint32_t i = 0; i < dimension_t; i++) {
+      zero[i] = 0;
+    }
+    return zero;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_POINT_CLOUD_TYPES_H_
diff --git a/engine/inc/draco/compression/point_cloud/algorithms/quantize_points_3.h b/engine/inc/draco/compression/point_cloud/algorithms/quantize_points_3.h
new file mode 100644
index 00000000..01943ad9
--- /dev/null
+++ b/engine/inc/draco/compression/point_cloud/algorithms/quantize_points_3.h
@@ -0,0 +1,84 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_QUANTIZE_POINTS_3_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_QUANTIZE_POINTS_3_H_
+
+#include <inttypes.h>
+
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+#include "draco/core/quantization_utils.h"
+
+namespace draco {
+
+// TODO(hemmer): Make this a stable bounding box.
+struct QuantizationInfo {
+  uint32_t quantization_bits;
+  float range;
+};
+
+template <class PointIterator, class OutputIterator>
+OutputIterator QuantizePoints3(const PointIterator &begin,
+                               const PointIterator &end, QuantizationInfo *info,
+                               OutputIterator oit) {
+  DRACO_DCHECK_GE(info->quantization_bits, 0);
+
+  float max_range = 0;
+  for (auto it = begin; it != end; ++it) {
+    max_range = std::max(std::fabs((*it)[0]), max_range);
+    max_range = std::max(std::fabs((*it)[1]), max_range);
+    max_range = std::max(std::fabs((*it)[2]), max_range);
+  }
+
+  const uint32_t max_quantized_value((1 << info->quantization_bits) - 1);
+  Quantizer quantize;
+  quantize.Init(max_range, max_quantized_value);
+  info->range = max_range;
+
+  Point3ui qpoint;
+  for (auto it = begin; it != end; ++it) {
+    // Quantize and all positive.
+    qpoint[0] = quantize((*it)[0]) + max_quantized_value;
+    qpoint[1] = quantize((*it)[1]) + max_quantized_value;
+    qpoint[2] = quantize((*it)[2]) + max_quantized_value;
+    *oit++ = (qpoint);
+  }
+
+  return oit;
+}
+
+template <class QPointIterator, class OutputIterator>
+void DequantizePoints3(const QPointIterator &begin, const QPointIterator &end,
+                       const QuantizationInfo &info, OutputIterator &oit) {
+  DRACO_DCHECK_GE(info.quantization_bits, 0);
+  DRACO_DCHECK_GE(info.range, 0);
+
+  const uint32_t quantization_bits = info.quantization_bits;
+  const float range = info.range;
+  const uint32_t max_quantized_value((1 << quantization_bits) - 1);
+  Dequantizer dequantize;
+  dequantize.Init(range, max_quantized_value);
+
+  for (auto it = begin; it != end; ++it) {
+    const float x = dequantize((*it)[0] - max_quantized_value);
+    const float y = dequantize((*it)[1] - max_quantized_value);
+    const float z = dequantize((*it)[2] - max_quantized_value);
+    *oit = Point3f(x, y, z);
+    ++oit;
+  }
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_QUANTIZE_POINTS_3_H_
diff --git a/engine/inc/draco/compression/point_cloud/algorithms/queuing_policy.h b/engine/inc/draco/compression/point_cloud/algorithms/queuing_policy.h
new file mode 100644
index 00000000..2db0ea21
--- /dev/null
+++ b/engine/inc/draco/compression/point_cloud/algorithms/queuing_policy.h
@@ -0,0 +1,75 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File defining a coherent interface for different queuing strategies.
+
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_QUEUING_POLICY_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_QUEUING_POLICY_H_
+
+#include <queue>
+#include <stack>
+#include <utility>
+
+namespace draco {
+
+template <class T>
+class Queue {
+ public:
+  bool empty() const { return q_.empty(); }
+  typename std::queue<T>::size_type size() const { return q_.size(); }
+  void clear() { return q_.clear(); }
+  void push(const T &value) { q_.push(value); }
+  void push(T &&value) { q_.push(std::move(value)); }
+  void pop() { q_.pop(); }
+  typename std::queue<T>::const_reference front() const { return q_.front(); }
+
+ private:
+  std::queue<T> q_;
+};
+
+template <class T>
+class Stack {
+ public:
+  bool empty() const { return s_.empty(); }
+  typename std::stack<T>::size_type size() const { return s_.size(); }
+  void clear() { return s_.clear(); }
+  void push(const T &value) { s_.push(value); }
+  void push(T &&value) { s_.push(std::move(value)); }
+  void pop() { s_.pop(); }
+  typename std::stack<T>::const_reference front() const { return s_.top(); }
+
+ private:
+  std::stack<T> s_;
+};
+
+template <class T, class Compare = std::less<T> >
+class PriorityQueue {
+  typedef std::priority_queue<T, std::vector<T>, Compare> QType;
+
+ public:
+  bool empty() const { return s_.empty(); }
+  typename QType::size_type size() const { return s_.size(); }
+  void clear() { return s_.clear(); }
+  void push(const T &value) { s_.push(value); }
+  void push(T &&value) { s_.push(std::move(value)); }
+  void pop() { s_.pop(); }
+  typename QType::const_reference front() const { return s_.top(); }
+
+ private:
+  QType s_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_QUEUING_POLICY_H_
diff --git a/engine/inc/draco/compression/point_cloud/point_cloud_decoder.h b/engine/inc/draco/compression/point_cloud/point_cloud_decoder.h
new file mode 100644
index 00000000..4af7f5cd
--- /dev/null
+++ b/engine/inc/draco/compression/point_cloud/point_cloud_decoder.h
@@ -0,0 +1,118 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_DECODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_DECODER_H_
+
+#include "draco/compression/attributes/attributes_decoder_interface.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/config/decoder_options.h"
+#include "draco/core/status.h"
+#include "draco/point_cloud/point_cloud.h"
+
+namespace draco {
+
+// Abstract base class for all point cloud and mesh decoders. It provides a
+// basic functionality that is shared between different decoders.
+class PointCloudDecoder {
+ public:
+  PointCloudDecoder();
+  virtual ~PointCloudDecoder() = default;
+
+  virtual EncodedGeometryType GetGeometryType() const { return POINT_CLOUD; }
+
+  // Decodes a Draco header int other provided |out_header|.
+  // Returns false on error.
+  static Status DecodeHeader(DecoderBuffer *buffer, DracoHeader *out_header);
+
+  // The main entry point for point cloud decoding.
+  Status Decode(const DecoderOptions &options, DecoderBuffer *in_buffer,
+                PointCloud *out_point_cloud);
+
+  bool SetAttributesDecoder(
+      int att_decoder_id, std::unique_ptr<AttributesDecoderInterface> decoder) {
+    if (att_decoder_id < 0) {
+      return false;
+    }
+    if (att_decoder_id >= static_cast<int>(attributes_decoders_.size())) {
+      attributes_decoders_.resize(att_decoder_id + 1);
+    }
+    attributes_decoders_[att_decoder_id] = std::move(decoder);
+    return true;
+  }
+
+  // Returns an attribute containing decoded data in their portable form that
+  // is guaranteed to be the same for both encoder and decoder. I.e., it returns
+  // an attribute before it was transformed back into its final form which may
+  // be slightly different (non-portable) across platforms. For example, for
+  // attributes encoded with quantization, this method returns an attribute
+  // that contains the quantized values (before the dequantization step).
+  const PointAttribute *GetPortableAttribute(int32_t point_attribute_id);
+
+  uint16_t bitstream_version() const {
+    return DRACO_BITSTREAM_VERSION(version_major_, version_minor_);
+  }
+
+  const AttributesDecoderInterface *attributes_decoder(int dec_id) {
+    return attributes_decoders_[dec_id].get();
+  }
+  int32_t num_attributes_decoders() const {
+    return static_cast<int32_t>(attributes_decoders_.size());
+  }
+
+  // Get a mutable pointer to the decoded point cloud. This is intended to be
+  // used mostly by other decoder subsystems.
+  PointCloud *point_cloud() { return point_cloud_; }
+  const PointCloud *point_cloud() const { return point_cloud_; }
+
+  DecoderBuffer *buffer() { return buffer_; }
+  const DecoderOptions *options() const { return options_; }
+
+ protected:
+  // Can be implemented by derived classes to perform any custom initialization
+  // of the decoder. Called in the Decode() method.
+  virtual bool InitializeDecoder() { return true; }
+
+  // Creates an attribute decoder.
+  virtual bool CreateAttributesDecoder(int32_t att_decoder_id) = 0;
+  virtual bool DecodeGeometryData() { return true; }
+  virtual bool DecodePointAttributes();
+
+  virtual bool DecodeAllAttributes();
+  virtual bool OnAttributesDecoded() { return true; }
+
+  Status DecodeMetadata();
+
+ private:
+  // Point cloud that is being filled in by the decoder.
+  PointCloud *point_cloud_;
+
+  std::vector<std::unique_ptr<AttributesDecoderInterface>> attributes_decoders_;
+
+  // Map between attribute id and decoder id.
+  std::vector<int32_t> attribute_to_decoder_map_;
+
+  // Input buffer holding the encoded data.
+  DecoderBuffer *buffer_;
+
+  // Bit-stream version of the encoder that encoded the input data.
+  uint8_t version_major_;
+  uint8_t version_minor_;
+
+  const DecoderOptions *options_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_DECODER_H_
diff --git a/engine/inc/draco/compression/point_cloud/point_cloud_encoder.h b/engine/inc/draco/compression/point_cloud/point_cloud_encoder.h
new file mode 100644
index 00000000..8883f17a
--- /dev/null
+++ b/engine/inc/draco/compression/point_cloud/point_cloud_encoder.h
@@ -0,0 +1,158 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_ENCODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_ENCODER_H_
+
+#include "draco/compression/attributes/attributes_encoder.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/config/encoder_options.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/core/status.h"
+#include "draco/point_cloud/point_cloud.h"
+
+namespace draco {
+
+// Abstract base class for all point cloud and mesh encoders. It provides a
+// basic functionality that's shared between different encoders.
+class PointCloudEncoder {
+ public:
+  PointCloudEncoder();
+  virtual ~PointCloudEncoder() = default;
+
+  // Sets the point cloud that is going be encoded. Must be called before the
+  // Encode() method.
+  void SetPointCloud(const PointCloud &pc);
+
+  // The main entry point that encodes provided point cloud.
+  Status Encode(const EncoderOptions &options, EncoderBuffer *out_buffer);
+
+  virtual EncodedGeometryType GetGeometryType() const { return POINT_CLOUD; }
+
+  // Returns the unique identifier of the encoding method (such as Edgebreaker
+  // for mesh compression).
+  virtual uint8_t GetEncodingMethod() const = 0;
+
+  // Returns the number of points that were encoded during the last Encode()
+  // function call. Valid only if "store_number_of_encoded_points" flag was set
+  // in the provided EncoderOptions.
+  size_t num_encoded_points() const { return num_encoded_points_; }
+
+  int num_attributes_encoders() const {
+    return static_cast<int>(attributes_encoders_.size());
+  }
+  AttributesEncoder *attributes_encoder(int i) {
+    return attributes_encoders_[i].get();
+  }
+
+  // Adds a new attribute encoder, returning its id.
+  int AddAttributesEncoder(std::unique_ptr<AttributesEncoder> att_enc) {
+    attributes_encoders_.push_back(std::move(att_enc));
+    return static_cast<int>(attributes_encoders_.size() - 1);
+  }
+
+  // Marks one attribute as a parent of another attribute. Must be called after
+  // all attribute encoders are created (usually in the
+  // AttributeEncoder::Init() method).
+  bool MarkParentAttribute(int32_t parent_att_id);
+
+  // Returns an attribute containing portable version of the attribute data that
+  // is guaranteed to be encoded losslessly. This attribute can be used safely
+  // as predictor for other attributes.
+  const PointAttribute *GetPortableAttribute(int32_t point_attribute_id);
+
+  EncoderBuffer *buffer() { return buffer_; }
+  const EncoderOptions *options() const { return options_; }
+  const PointCloud *point_cloud() const { return point_cloud_; }
+
+ protected:
+  // Can be implemented by derived classes to perform any custom initialization
+  // of the encoder. Called in the Encode() method.
+  virtual bool InitializeEncoder() { return true; }
+
+  // Should be used to encode any encoder-specific data.
+  virtual bool EncodeEncoderData() { return true; }
+
+  // Encodes any global geometry data (such as the number of points).
+  virtual Status EncodeGeometryData() { return OkStatus(); }
+
+  // encode all attribute values. The attribute encoders are sorted to resolve
+  // any attribute dependencies and all the encoded data is stored into the
+  // |buffer_|.
+  // Returns false if the encoding failed.
+  virtual bool EncodePointAttributes();
+
+  // Generate attribute encoders that are going to be used for encoding
+  // point attribute data. Calls GenerateAttributesEncoder() for every attribute
+  // of the encoded PointCloud.
+  virtual bool GenerateAttributesEncoders();
+
+  // Creates attribute encoder for a specific point attribute. This function
+  // needs to be implemented by the derived classes. The derived classes need
+  // to either 1. Create a new attribute encoder and add it using the
+  // AddAttributeEncoder method, or 2. add the attribute to an existing
+  // attribute encoder (using AttributesEncoder::AddAttributeId() method).
+  virtual bool GenerateAttributesEncoder(int32_t att_id) = 0;
+
+  // Encodes any data that is necessary to recreate a given attribute encoder.
+  // Note: this is called in order in which the attribute encoders are going to
+  // be encoded.
+  virtual bool EncodeAttributesEncoderIdentifier(int32_t /* att_encoder_id */) {
+    return true;
+  }
+
+  // Encodes all the attribute data using the created attribute encoders.
+  virtual bool EncodeAllAttributes();
+
+  // Computes and sets the num_encoded_points_ for the encoder.
+  virtual void ComputeNumberOfEncodedPoints() = 0;
+
+  void set_num_encoded_points(size_t num_points) {
+    num_encoded_points_ = num_points;
+  }
+
+ private:
+  // Encodes Draco header that is the same for all encoders.
+  Status EncodeHeader();
+
+  // Encode metadata.
+  Status EncodeMetadata();
+
+  // Rearranges attribute encoders and their attributes to reflect the
+  // underlying attribute dependencies. This ensures that the attributes are
+  // encoded in the correct order (parent attributes before their children).
+  bool RearrangeAttributesEncoders();
+
+  const PointCloud *point_cloud_;
+  std::vector<std::unique_ptr<AttributesEncoder>> attributes_encoders_;
+
+  // Map between attribute id and encoder id.
+  std::vector<int32_t> attribute_to_encoder_map_;
+
+  // Encoding order of individual attribute encoders (i.e., the order in which
+  // they are processed during encoding that may be different from the order
+  // in which they were created because of attribute dependencies.
+  std::vector<int32_t> attributes_encoder_ids_order_;
+
+  // This buffer holds the final encoded data.
+  EncoderBuffer *buffer_;
+
+  const EncoderOptions *options_;
+
+  size_t num_encoded_points_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_ENCODER_H_
diff --git a/engine/inc/draco/compression/point_cloud/point_cloud_kd_tree_decoder.h b/engine/inc/draco/compression/point_cloud/point_cloud_kd_tree_decoder.h
new file mode 100644
index 00000000..6e192f2a
--- /dev/null
+++ b/engine/inc/draco/compression/point_cloud/point_cloud_kd_tree_decoder.h
@@ -0,0 +1,31 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_KD_TREE_DECODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_KD_TREE_DECODER_H_
+
+#include "draco/compression/point_cloud/point_cloud_decoder.h"
+
+namespace draco {
+
+// Decodes PointCloud encoded with the PointCloudKdTreeEncoder.
+class PointCloudKdTreeDecoder : public PointCloudDecoder {
+ protected:
+  bool DecodeGeometryData() override;
+  bool CreateAttributesDecoder(int32_t att_decoder_id) override;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_KD_TREE_DECODER_H_
diff --git a/engine/inc/draco/compression/point_cloud/point_cloud_kd_tree_encoder.h b/engine/inc/draco/compression/point_cloud/point_cloud_kd_tree_encoder.h
new file mode 100644
index 00000000..6acbb949
--- /dev/null
+++ b/engine/inc/draco/compression/point_cloud/point_cloud_kd_tree_encoder.h
@@ -0,0 +1,45 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_KD_TREE_ENCODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_KD_TREE_ENCODER_H_
+
+#include "draco/compression/point_cloud/point_cloud_encoder.h"
+
+namespace draco {
+
+// Encodes a PointCloud using one of the available Kd-tree compression methods.
+// See FloatPointsKdTreeEncoder and DynamicIntegerPointsKdTreeEncoder for more
+// details. Currently, the input PointCloud must satisfy the following
+// requirements to use this encoder:
+//  1. PointCloud has only one attribute of type GeometryAttribute::POSITION.
+//  2. The position attribute has three components (x,y,z).
+//  3. The position values are stored as either DT_FLOAT32 or DT_UINT32.
+//  4. If the position values are stored as DT_FLOAT32, quantization needs to
+//     be enabled for the position attribute.
+class PointCloudKdTreeEncoder : public PointCloudEncoder {
+ public:
+  uint8_t GetEncodingMethod() const override {
+    return POINT_CLOUD_KD_TREE_ENCODING;
+  }
+
+ protected:
+  Status EncodeGeometryData() override;
+  bool GenerateAttributesEncoder(int32_t att_id) override;
+  void ComputeNumberOfEncodedPoints() override;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_KD_TREE_ENCODER_H_
diff --git a/engine/inc/draco/compression/point_cloud/point_cloud_sequential_decoder.h b/engine/inc/draco/compression/point_cloud/point_cloud_sequential_decoder.h
new file mode 100644
index 00000000..9968dc27
--- /dev/null
+++ b/engine/inc/draco/compression/point_cloud/point_cloud_sequential_decoder.h
@@ -0,0 +1,33 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_SEQUENTIAL_DECODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_SEQUENTIAL_DECODER_H_
+
+#include "draco/compression/point_cloud/point_cloud_decoder.h"
+
+namespace draco {
+
+// Point cloud decoder for data encoded by the PointCloudSequentialEncoder.
+// All attribute values are decoded using an identity mapping between point ids
+// and attribute value ids.
+class PointCloudSequentialDecoder : public PointCloudDecoder {
+ protected:
+  bool DecodeGeometryData() override;
+  bool CreateAttributesDecoder(int32_t att_decoder_id) override;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_SEQUENTIAL_DECODER_H_
diff --git a/engine/inc/draco/compression/point_cloud/point_cloud_sequential_encoder.h b/engine/inc/draco/compression/point_cloud/point_cloud_sequential_encoder.h
new file mode 100644
index 00000000..40d8edcd
--- /dev/null
+++ b/engine/inc/draco/compression/point_cloud/point_cloud_sequential_encoder.h
@@ -0,0 +1,43 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_SEQUENTIAL_ENCODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_SEQUENTIAL_ENCODER_H_
+
+#include "draco/compression/point_cloud/point_cloud_encoder.h"
+
+namespace draco {
+
+// A basic point cloud encoder that iterates over all points and encodes all
+// attribute values for every visited point. The attribute values encoding
+// can be controlled using provided encoding option to enable features such
+// as quantization or prediction schemes.
+// This encoder preserves the order and the number of input points, but the
+// mapping between point ids and attribute values may be different for the
+// decoded point cloud.
+class PointCloudSequentialEncoder : public PointCloudEncoder {
+ public:
+  uint8_t GetEncodingMethod() const override {
+    return POINT_CLOUD_SEQUENTIAL_ENCODING;
+  }
+
+ protected:
+  Status EncodeGeometryData() override;
+  bool GenerateAttributesEncoder(int32_t att_id) override;
+  void ComputeNumberOfEncodedPoints() override;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_SEQUENTIAL_ENCODER_H_
diff --git a/engine/inc/draco/core/bit_utils.h b/engine/inc/draco/core/bit_utils.h
new file mode 100644
index 00000000..a102095c
--- /dev/null
+++ b/engine/inc/draco/core/bit_utils.h
@@ -0,0 +1,124 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File containing a basic set of bit manipulation utilities used within the
+// Draco library.
+
+#ifndef DRACO_CORE_BIT_UTILS_H_
+#define DRACO_CORE_BIT_UTILS_H_
+
+#include <inttypes.h>
+#include <stdint.h>
+
+#include <type_traits>
+
+#if defined(_MSC_VER)
+#include <intrin.h>
+#endif  // defined(_MSC_VER)
+
+namespace draco {
+
+// Returns the number of '1' bits within the input 32 bit integer.
+inline int CountOneBits32(uint32_t n) {
+  n -= ((n >> 1) & 0x55555555);
+  n = ((n >> 2) & 0x33333333) + (n & 0x33333333);
+  return (((n + (n >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24;
+}
+
+inline uint32_t ReverseBits32(uint32_t n) {
+  n = ((n >> 1) & 0x55555555) | ((n & 0x55555555) << 1);
+  n = ((n >> 2) & 0x33333333) | ((n & 0x33333333) << 2);
+  n = ((n >> 4) & 0x0F0F0F0F) | ((n & 0x0F0F0F0F) << 4);
+  n = ((n >> 8) & 0x00FF00FF) | ((n & 0x00FF00FF) << 8);
+  return (n >> 16) | (n << 16);
+}
+
+// Copies the |nbits| from the src integer into the |dst| integer using the
+// provided bit offsets |dst_offset| and |src_offset|.
+inline void CopyBits32(uint32_t *dst, int dst_offset, uint32_t src,
+                       int src_offset, int nbits) {
+  const uint32_t mask = (~static_cast<uint32_t>(0)) >> (32 - nbits)
+                                                           << dst_offset;
+  *dst = (*dst & (~mask)) | (((src >> src_offset) << dst_offset) & mask);
+}
+
+// Returns the location of the most significant bit in the input integer |n|.
+// The functionality is not defined for |n == 0|.
+inline int MostSignificantBit(uint32_t n) {
+#if defined(__GNUC__)
+  return 31 ^ __builtin_clz(n);
+#elif defined(_MSC_VER)
+
+  unsigned long where;
+  _BitScanReverse(&where, n);
+  return (int)where;
+#else
+  // TODO(fgalligan): Optimize this code.
+  int msb = -1;
+  while (n != 0) {
+    msb++;
+    n >>= 1;
+  }
+  return msb;
+#endif
+}
+
+// Helper function that converts signed integer values into unsigned integer
+// symbols that can be encoded using an entropy encoder.
+void ConvertSignedIntsToSymbols(const int32_t *in, int in_values,
+                                uint32_t *out);
+
+// Converts unsigned integer symbols encoded with an entropy encoder back to
+// signed values.
+void ConvertSymbolsToSignedInts(const uint32_t *in, int in_values,
+                                int32_t *out);
+
+// Helper function that converts a single signed integer value into an unsigned
+// integer symbol that can be encoded using an entropy encoder.
+template <class IntTypeT>
+typename std::make_unsigned<IntTypeT>::type ConvertSignedIntToSymbol(
+    IntTypeT val) {
+  typedef typename std::make_unsigned<IntTypeT>::type UnsignedType;
+  static_assert(std::is_integral<IntTypeT>::value, "IntTypeT is not integral.");
+  // Early exit if val is positive.
+  if (val >= 0) {
+    return static_cast<UnsignedType>(val) << 1;
+  }
+  val = -(val + 1);  // Map -1 to 0, -2 to -1, etc..
+  UnsignedType ret = static_cast<UnsignedType>(val);
+  ret <<= 1;
+  ret |= 1;
+  return ret;
+}
+
+// Converts a single unsigned integer symbol encoded with an entropy encoder
+// back to a signed value.
+template <class IntTypeT>
+typename std::make_signed<IntTypeT>::type ConvertSymbolToSignedInt(
+    IntTypeT val) {
+  static_assert(std::is_integral<IntTypeT>::value, "IntTypeT is not integral.");
+  typedef typename std::make_signed<IntTypeT>::type SignedType;
+  const bool is_positive = !static_cast<bool>(val & 1);
+  val >>= 1;
+  if (is_positive) {
+    return static_cast<SignedType>(val);
+  }
+  SignedType ret = static_cast<SignedType>(val);
+  ret = -ret - 1;
+  return ret;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_BIT_UTILS_H_
diff --git a/engine/inc/draco/core/bounding_box.h b/engine/inc/draco/core/bounding_box.h
new file mode 100644
index 00000000..31ba2d68
--- /dev/null
+++ b/engine/inc/draco/core/bounding_box.h
@@ -0,0 +1,72 @@
+// Copyright 2018 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_BOUNDING_BOX_H_
+#define DRACO_CORE_BOUNDING_BOX_H_
+
+#include "draco/core/vector_d.h"
+
+namespace draco {
+
+// Class for computing the bounding box of points in 3D space.
+class BoundingBox {
+ public:
+  // Creates bounding box object with minimum and maximum points initialized to
+  // the largest positive and the smallest negative values, respectively. The
+  // resulting abstract bounding box effectively has no points and can be
+  // updated by providing any point to Update() method.
+  BoundingBox();
+
+  // Creates bounding box object with minimum and maximum points initialized to
+  // |min_point| and |max_point|, respectively.
+  BoundingBox(const Vector3f &min_point, const Vector3f &max_point);
+
+  // Returns the minimum point of the bounding box.
+  inline const Vector3f &GetMinPoint() const { return min_point_; }
+
+  // Returns the maximum point of the bounding box.
+  inline const Vector3f &GetMaxPoint() const { return max_point_; }
+
+  // Conditionally updates the bounding box with a given |new_point|.
+  void Update(const Vector3f &new_point) {
+    for (int i = 0; i < 3; i++) {
+      if (new_point[i] < min_point_[i]) {
+        min_point_[i] = new_point[i];
+      }
+      if (new_point[i] > max_point_[i]) {
+        max_point_[i] = new_point[i];
+      }
+    }
+  }
+
+  // Updates bounding box with minimum and maximum points of the |other|
+  // bounding box.
+  void Update(const BoundingBox &other) {
+    Update(other.GetMinPoint());
+    Update(other.GetMaxPoint());
+  }
+
+  // Returns the size of the bounding box along each axis.
+  Vector3f Size() const { return max_point_ - min_point_; }
+
+  // Returns the center of the bounding box.
+  Vector3f Center() const { return (min_point_ + max_point_) / 2; }
+
+ private:
+  Vector3f min_point_;
+  Vector3f max_point_;
+};
+}  // namespace draco
+
+#endif  //  DRACO_CORE_BOUNDING_BOX_H_
diff --git a/engine/inc/draco/core/cycle_timer.h b/engine/inc/draco/core/cycle_timer.h
new file mode 100644
index 00000000..172f1c2e
--- /dev/null
+++ b/engine/inc/draco/core/cycle_timer.h
@@ -0,0 +1,50 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_CYCLE_TIMER_H_
+#define DRACO_CORE_CYCLE_TIMER_H_
+
+#ifdef _WIN32
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+typedef LARGE_INTEGER timeval;
+#else
+#include <sys/time.h>
+#endif
+
+#include <cinttypes>
+#include <cstddef>
+
+namespace draco {
+
+class DracoTimer {
+ public:
+  DracoTimer() {}
+  ~DracoTimer() {}
+  void Start();
+  void Stop();
+  int64_t GetInMs();
+
+ private:
+  timeval tv_start;
+  timeval tv_end;
+};
+
+typedef DracoTimer CycleTimer;
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_CYCLE_TIMER_H_
diff --git a/engine/inc/draco/core/data_buffer.h b/engine/inc/draco/core/data_buffer.h
new file mode 100644
index 00000000..8ee69054
--- /dev/null
+++ b/engine/inc/draco/core/data_buffer.h
@@ -0,0 +1,82 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_DATA_BUFFER_H_
+#define DRACO_CORE_DATA_BUFFER_H_
+
+#include <cstring>
+#include <ostream>
+#include <vector>
+
+#include "draco/core/draco_types.h"
+
+namespace draco {
+
+// Buffer descriptor servers as a unique identifier of a buffer.
+struct DataBufferDescriptor {
+  DataBufferDescriptor() : buffer_id(0), buffer_update_count(0) {}
+  // Id of the data buffer.
+  int64_t buffer_id;
+  // The number of times the buffer content was updated.
+  int64_t buffer_update_count;
+};
+
+// Class used for storing raw buffer data.
+class DataBuffer {
+ public:
+  DataBuffer();
+  bool Update(const void *data, int64_t size);
+  bool Update(const void *data, int64_t size, int64_t offset);
+
+  // Reallocate the buffer storage to a new size keeping the data unchanged.
+  void Resize(int64_t new_size);
+  void WriteDataToStream(std::ostream &stream);
+  // Reads data from the buffer. Potentially unsafe, called needs to ensure
+  // the accessed memory is valid.
+  void Read(int64_t byte_pos, void *out_data, size_t data_size) const {
+    memcpy(out_data, data() + byte_pos, data_size);
+  }
+
+  // Writes data to the buffer. Unsafe, caller must ensure the accessed memory
+  // is valid.
+  void Write(int64_t byte_pos, const void *in_data, size_t data_size) {
+    memcpy(const_cast<uint8_t *>(data()) + byte_pos, in_data, data_size);
+  }
+
+  // Copies data from another buffer to this buffer.
+  void Copy(int64_t dst_offset, const DataBuffer *src_buf, int64_t src_offset,
+            int64_t size) {
+    memcpy(const_cast<uint8_t *>(data()) + dst_offset,
+           src_buf->data() + src_offset, size);
+  }
+
+  void set_update_count(int64_t buffer_update_count) {
+    descriptor_.buffer_update_count = buffer_update_count;
+  }
+  int64_t update_count() const { return descriptor_.buffer_update_count; }
+  size_t data_size() const { return data_.size(); }
+  const uint8_t *data() const { return data_.data(); }
+  uint8_t *data() { return &data_[0]; }
+  int64_t buffer_id() const { return descriptor_.buffer_id; }
+  void set_buffer_id(int64_t buffer_id) { descriptor_.buffer_id = buffer_id; }
+
+ private:
+  std::vector<uint8_t> data_;
+  // Counter incremented by Update() calls.
+  DataBufferDescriptor descriptor_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_DATA_BUFFER_H_
diff --git a/engine/inc/draco/core/decoder_buffer.h b/engine/inc/draco/core/decoder_buffer.h
new file mode 100644
index 00000000..0559abbe
--- /dev/null
+++ b/engine/inc/draco/core/decoder_buffer.h
@@ -0,0 +1,216 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_DECODER_BUFFER_H_
+#define DRACO_CORE_DECODER_BUFFER_H_
+
+#include <stdint.h>
+
+#include <cstring>
+#include <memory>
+
+#include "draco/core/macros.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Class is a wrapper around input data used by MeshDecoder. It provides a
+// basic interface for decoding either typed or variable-bit sized data.
+class DecoderBuffer {
+ public:
+  DecoderBuffer();
+  DecoderBuffer(const DecoderBuffer &buf) = default;
+
+  DecoderBuffer &operator=(const DecoderBuffer &buf) = default;
+
+  // Sets the buffer's internal data. Note that no copy of the input data is
+  // made so the data owner needs to keep the data valid and unchanged for
+  // runtime of the decoder.
+  void Init(const char *data, size_t data_size);
+
+  // Sets the buffer's internal data. |version| is the Draco bitstream version.
+  void Init(const char *data, size_t data_size, uint16_t version);
+
+  // Starts decoding a bit sequence.
+  // decode_size must be true if the size of the encoded bit data was included,
+  // during encoding. The size is then returned to out_size.
+  // Returns false on error.
+  bool StartBitDecoding(bool decode_size, uint64_t *out_size);
+
+  // Ends the decoding of the bit sequence and return to the default
+  // byte-aligned decoding.
+  void EndBitDecoding();
+
+  // Decodes up to 32 bits into out_val. Can be called only in between
+  // StartBitDecoding and EndBitDecoding. Otherwise returns false.
+  bool DecodeLeastSignificantBits32(int nbits, uint32_t *out_value) {
+    if (!bit_decoder_active()) {
+      return false;
+    }
+    bit_decoder_.GetBits(nbits, out_value);
+    return true;
+  }
+
+  // Decodes an arbitrary data type.
+  // Can be used only when we are not decoding a bit-sequence.
+  // Returns false on error.
+  template <typename T>
+  bool Decode(T *out_val) {
+    if (!Peek(out_val)) {
+      return false;
+    }
+    pos_ += sizeof(T);
+    return true;
+  }
+
+  bool Decode(void *out_data, size_t size_to_decode) {
+    if (data_size_ < static_cast<int64_t>(pos_ + size_to_decode)) {
+      return false;  // Buffer overflow.
+    }
+    memcpy(out_data, (data_ + pos_), size_to_decode);
+    pos_ += size_to_decode;
+    return true;
+  }
+
+  // Decodes an arbitrary data, but does not advance the reading position.
+  template <typename T>
+  bool Peek(T *out_val) {
+    const size_t size_to_decode = sizeof(T);
+    if (data_size_ < static_cast<int64_t>(pos_ + size_to_decode)) {
+      return false;  // Buffer overflow.
+    }
+    memcpy(out_val, (data_ + pos_), size_to_decode);
+    return true;
+  }
+
+  bool Peek(void *out_data, size_t size_to_peek) {
+    if (data_size_ < static_cast<int64_t>(pos_ + size_to_peek)) {
+      return false;  // Buffer overflow.
+    }
+    memcpy(out_data, (data_ + pos_), size_to_peek);
+    return true;
+  }
+
+  // Discards #bytes from the input buffer.
+  void Advance(int64_t bytes) { pos_ += bytes; }
+
+  // Moves the parsing position to a specific offset from the beginning of the
+  // input data.
+  void StartDecodingFrom(int64_t offset) { pos_ = offset; }
+
+  void set_bitstream_version(uint16_t version) { bitstream_version_ = version; }
+
+  // Returns the data array at the current decoder position.
+  const char *data_head() const { return data_ + pos_; }
+  int64_t remaining_size() const { return data_size_ - pos_; }
+  int64_t decoded_size() const { return pos_; }
+  bool bit_decoder_active() const { return bit_mode_; }
+
+  // Returns the bitstream associated with the data. Returns 0 if unknown.
+  uint16_t bitstream_version() const { return bitstream_version_; }
+
+ private:
+  // Internal helper class to decode bits from a bit buffer.
+  class BitDecoder {
+   public:
+    BitDecoder();
+    ~BitDecoder();
+
+    // Sets the bit buffer to |b|. |s| is the size of |b| in bytes.
+    inline void reset(const void *b, size_t s) {
+      bit_offset_ = 0;
+      bit_buffer_ = static_cast<const uint8_t *>(b);
+      bit_buffer_end_ = bit_buffer_ + s;
+    }
+
+    // Returns number of bits decoded so far.
+    inline uint64_t BitsDecoded() const {
+      return static_cast<uint64_t>(bit_offset_);
+    }
+
+    // Return number of bits available for decoding
+    inline uint64_t AvailBits() const {
+      return ((bit_buffer_end_ - bit_buffer_) * 8) - bit_offset_;
+    }
+
+    inline uint32_t EnsureBits(int k) {
+      DRACO_DCHECK_LE(k, 24);
+      DRACO_DCHECK_LE(static_cast<uint64_t>(k), AvailBits());
+
+      uint32_t buf = 0;
+      for (int i = 0; i < k; ++i) {
+        buf |= PeekBit(i) << i;
+      }
+      return buf;  // Okay to return extra bits
+    }
+
+    inline void ConsumeBits(int k) { bit_offset_ += k; }
+
+    // Returns |nbits| bits in |x|.
+    inline bool GetBits(int32_t nbits, uint32_t *x) {
+      DRACO_DCHECK_GE(nbits, 0);
+      DRACO_DCHECK_LE(nbits, 32);
+      uint32_t value = 0;
+      for (int32_t bit = 0; bit < nbits; ++bit) {
+        value |= GetBit() << bit;
+      }
+      *x = value;
+      return true;
+    }
+
+   private:
+    // TODO(fgalligan): Add support for error reporting on range check.
+    // Returns one bit from the bit buffer.
+    inline int GetBit() {
+      const size_t off = bit_offset_;
+      const size_t byte_offset = off >> 3;
+      const int bit_shift = static_cast<int>(off & 0x7);
+      if (bit_buffer_ + byte_offset < bit_buffer_end_) {
+        const int bit = (bit_buffer_[byte_offset] >> bit_shift) & 1;
+        bit_offset_ = off + 1;
+        return bit;
+      }
+      return 0;
+    }
+
+    inline int PeekBit(int offset) {
+      const size_t off = bit_offset_ + offset;
+      const size_t byte_offset = off >> 3;
+      const int bit_shift = static_cast<int>(off & 0x7);
+      if (bit_buffer_ + byte_offset < bit_buffer_end_) {
+        const int bit = (bit_buffer_[byte_offset] >> bit_shift) & 1;
+        return bit;
+      }
+      return 0;
+    }
+
+    const uint8_t *bit_buffer_;
+    const uint8_t *bit_buffer_end_;
+    size_t bit_offset_;
+  };
+  friend class BufferBitCodingTest;
+
+  const char *data_;
+  int64_t data_size_;
+
+  // Current parsing position of the decoder.
+  int64_t pos_;
+  BitDecoder bit_decoder_;
+  bool bit_mode_;
+  uint16_t bitstream_version_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_DECODER_BUFFER_H_
diff --git a/engine/inc/draco/core/divide.h b/engine/inc/draco/core/divide.h
new file mode 100644
index 00000000..7e3838a0
--- /dev/null
+++ b/engine/inc/draco/core/divide.h
@@ -0,0 +1,42 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_DIVIDE_H_
+#define DRACO_CORE_DIVIDE_H_
+// An implementation of the divide by multiply algorithm
+// https://gmplib.org/~tege/divcnst-pldi94.pdf
+// This file is based off libvpx's divide.h.
+
+#include <stdint.h>
+
+#include <climits>
+
+namespace draco {
+
+struct fastdiv_elem {
+  unsigned mult;
+  unsigned shift;
+};
+
+extern const struct fastdiv_elem vp10_fastdiv_tab[256];
+
+static inline unsigned fastdiv(unsigned x, int y) {
+  unsigned t =
+      ((uint64_t)x * vp10_fastdiv_tab[y].mult) >> (sizeof(x) * CHAR_BIT);
+  return (t + x) >> vp10_fastdiv_tab[y].shift;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_DIVIDE_H_
diff --git a/engine/inc/draco/core/draco_index_type.h b/engine/inc/draco/core/draco_index_type.h
new file mode 100644
index 00000000..d9dd3f64
--- /dev/null
+++ b/engine/inc/draco/core/draco_index_type.h
@@ -0,0 +1,183 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// This files provides a basic framework for strongly typed indices that are
+// used within the Draco library. The motivation of using strongly typed indices
+// is to prevent bugs caused by mixing up incompatible indices, such as indexing
+// mesh faces with point indices and vice versa.
+//
+// Usage:
+//      Define strongly typed index using macro:
+//
+//        DEFINE_NEW_DRACO_INDEX_TYPE(value_type, name)
+//
+//      where |value_type| is the data type of the index value (such as int32_t)
+//      and |name| is a unique typename of the new index.
+//
+//      E.g., we can define new index types as:
+//
+//        DEFINE_NEW_DRACO_INDEX_TYPE(int, PointIndex)
+//        DEFINE_NEW_DRACO_INDEX_TYPE(int, FaceIndex)
+//
+//      The new types can then be used in the similar way as the regular weakly
+//      typed indices (such as int32, int64, ...), but they cannot be
+//      accidentally misassigned. E.g.:
+//
+//        PointIndex point_index(10);
+//        FaceIndex face_index;
+//        face_index = point_index;  // Compile error!
+//
+//      One can still cast one type to another explicitly by accessing the index
+//      value directly using the .value() method:
+//
+//        face_index = FaceIndex(point_index.value());  // Compiles OK.
+//
+//      Strongly typed indices support most of the common binary and unary
+//      operators and support for additional operators can be added if
+//      necessary.
+
+#ifndef DRACO_CORE_DRACO_INDEX_TYPE_H_
+#define DRACO_CORE_DRACO_INDEX_TYPE_H_
+
+#include <ostream>
+
+#include "draco/draco_features.h"
+
+namespace draco {
+
+#define DEFINE_NEW_DRACO_INDEX_TYPE(value_type, name) \
+  struct name##_tag_type_ {};                         \
+  typedef IndexType<value_type, name##_tag_type_> name;
+
+template <class ValueTypeT, class TagT>
+class IndexType {
+ public:
+  typedef IndexType<ValueTypeT, TagT> ThisIndexType;
+  typedef ValueTypeT ValueType;
+
+  constexpr IndexType() : value_(ValueTypeT()) {}
+  constexpr explicit IndexType(ValueTypeT value) : value_(value) {}
+
+  constexpr ValueTypeT value() const { return value_; }
+
+  constexpr bool operator==(const IndexType &i) const {
+    return value_ == i.value_;
+  }
+  constexpr bool operator==(const ValueTypeT &val) const {
+    return value_ == val;
+  }
+  constexpr bool operator!=(const IndexType &i) const {
+    return value_ != i.value_;
+  }
+  constexpr bool operator!=(const ValueTypeT &val) const {
+    return value_ != val;
+  }
+  constexpr bool operator<(const IndexType &i) const {
+    return value_ < i.value_;
+  }
+  constexpr bool operator<(const ValueTypeT &val) const { return value_ < val; }
+  constexpr bool operator>(const IndexType &i) const {
+    return value_ > i.value_;
+  }
+  constexpr bool operator>(const ValueTypeT &val) const { return value_ > val; }
+  constexpr bool operator>=(const IndexType &i) const {
+    return value_ >= i.value_;
+  }
+  constexpr bool operator>=(const ValueTypeT &val) const {
+    return value_ >= val;
+  }
+
+  inline ThisIndexType &operator++() {
+    ++value_;
+    return *this;
+  }
+  inline ThisIndexType operator++(int) {
+    const ThisIndexType ret(value_);
+    ++value_;
+    return ret;
+  }
+
+  inline ThisIndexType &operator--() {
+    --value_;
+    return *this;
+  }
+  inline ThisIndexType operator--(int) {
+    const ThisIndexType ret(value_);
+    --value_;
+    return ret;
+  }
+
+  constexpr ThisIndexType operator+(const IndexType &i) const {
+    return ThisIndexType(value_ + i.value_);
+  }
+  constexpr ThisIndexType operator+(const ValueTypeT &val) const {
+    return ThisIndexType(value_ + val);
+  }
+  constexpr ThisIndexType operator-(const IndexType &i) const {
+    return ThisIndexType(value_ - i.value_);
+  }
+  constexpr ThisIndexType operator-(const ValueTypeT &val) const {
+    return ThisIndexType(value_ - val);
+  }
+
+  inline ThisIndexType &operator+=(const IndexType &i) {
+    value_ += i.value_;
+    return *this;
+  }
+  inline ThisIndexType operator+=(const ValueTypeT &val) {
+    value_ += val;
+    return *this;
+  }
+  inline ThisIndexType &operator-=(const IndexType &i) {
+    value_ -= i.value_;
+    return *this;
+  }
+  inline ThisIndexType operator-=(const ValueTypeT &val) {
+    value_ -= val;
+    return *this;
+  }
+  inline ThisIndexType &operator=(const ThisIndexType &i) {
+    value_ = i.value_;
+    return *this;
+  }
+  inline ThisIndexType &operator=(const ValueTypeT &val) {
+    value_ = val;
+    return *this;
+  }
+
+ private:
+  ValueTypeT value_;
+};
+
+// Stream operator << provided for logging purposes.
+template <class ValueTypeT, class TagT>
+std::ostream &operator<<(std::ostream &os, IndexType<ValueTypeT, TagT> index) {
+  return os << index.value();
+}
+
+}  // namespace draco
+
+// Specialize std::hash for the strongly indexed types.
+namespace std {
+
+template <class ValueTypeT, class TagT>
+struct hash<draco::IndexType<ValueTypeT, TagT>> {
+  size_t operator()(const draco::IndexType<ValueTypeT, TagT> &i) const {
+    return static_cast<size_t>(i.value());
+  }
+};
+
+}  // namespace std
+
+#endif  // DRACO_CORE_DRACO_INDEX_TYPE_H_
diff --git a/engine/inc/draco/core/draco_index_type_vector.h b/engine/inc/draco/core/draco_index_type_vector.h
new file mode 100644
index 00000000..aae1e7aa
--- /dev/null
+++ b/engine/inc/draco/core/draco_index_type_vector.h
@@ -0,0 +1,83 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_DRACO_INDEX_TYPE_VECTOR_H_
+#define DRACO_CORE_DRACO_INDEX_TYPE_VECTOR_H_
+
+#include <cstddef>
+#include <utility>
+#include <vector>
+
+#include "draco/core/draco_index_type.h"
+
+namespace draco {
+
+// A wrapper around the standard std::vector that supports indexing of the
+// vector entries using the strongly typed indices as defined in
+// draco_index_type.h .
+// TODO(ostava): Make the interface more complete. It's currently missing
+// features such as iterators.
+// TODO(vytyaz): Add more unit tests for this class.
+template <class IndexTypeT, class ValueTypeT>
+class IndexTypeVector {
+ public:
+  typedef typename std::vector<ValueTypeT>::const_reference const_reference;
+  typedef typename std::vector<ValueTypeT>::reference reference;
+
+  IndexTypeVector() {}
+  explicit IndexTypeVector(size_t size) : vector_(size) {}
+  IndexTypeVector(size_t size, const ValueTypeT &val) : vector_(size, val) {}
+
+  void clear() { vector_.clear(); }
+  void reserve(size_t size) { vector_.reserve(size); }
+  void resize(size_t size) { vector_.resize(size); }
+  void resize(size_t size, const ValueTypeT &val) { vector_.resize(size, val); }
+  void assign(size_t size, const ValueTypeT &val) { vector_.assign(size, val); }
+
+  void swap(IndexTypeVector<IndexTypeT, ValueTypeT> &arg) {
+    vector_.swap(arg.vector_);
+  }
+
+  size_t size() const { return vector_.size(); }
+  bool empty() const { return vector_.empty(); }
+
+  void push_back(const ValueTypeT &val) { vector_.push_back(val); }
+  void push_back(ValueTypeT &&val) { vector_.push_back(std::move(val)); }
+
+  template <typename... Args>
+  void emplace_back(Args &&...args) {
+    vector_.emplace_back(std::forward<Args>(args)...);
+  }
+
+  inline reference operator[](const IndexTypeT &index) {
+    return vector_[index.value()];
+  }
+  inline const_reference operator[](const IndexTypeT &index) const {
+    return vector_[index.value()];
+  }
+  inline reference at(const IndexTypeT &index) {
+    return vector_[index.value()];
+  }
+  inline const_reference at(const IndexTypeT &index) const {
+    return vector_[index.value()];
+  }
+  const ValueTypeT *data() const { return vector_.data(); }
+
+ private:
+  std::vector<ValueTypeT> vector_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_DRACO_INDEX_TYPE_VECTOR_H_
diff --git a/engine/inc/draco/core/draco_test_base.h b/engine/inc/draco/core/draco_test_base.h
new file mode 100644
index 00000000..f5c9d751
--- /dev/null
+++ b/engine/inc/draco/core/draco_test_base.h
@@ -0,0 +1,11 @@
+// Wrapper for including googletest indirectly. Useful when the location of the
+// googletest sources must change depending on build environment and repository
+// source location.
+#ifndef DRACO_CORE_DRACO_TEST_BASE_H_
+#define DRACO_CORE_DRACO_TEST_BASE_H_
+
+static bool FLAGS_update_golden_files;
+#include "gtest/gtest.h"
+#include "testing/draco_test_config.h"
+
+#endif  // DRACO_CORE_DRACO_TEST_BASE_H_
diff --git a/engine/inc/draco/core/draco_test_utils.h b/engine/inc/draco/core/draco_test_utils.h
new file mode 100644
index 00000000..fa548f52
--- /dev/null
+++ b/engine/inc/draco/core/draco_test_utils.h
@@ -0,0 +1,93 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_DRACO_TEST_UTILS_H_
+#define DRACO_CORE_DRACO_TEST_UTILS_H_
+
+#include "draco/core/draco_test_base.h"
+#include "draco/io/mesh_io.h"
+#include "draco/io/point_cloud_io.h"
+
+namespace draco {
+
+// Returns the full path to a given file system entry, such as test file or test
+// directory.
+std::string GetTestFileFullPath(const std::string &entry_name);
+
+// Returns the full path to a given temporary file (a location where tests store
+// generated files).
+std::string GetTestTempFileFullPath(const std::string &file_name);
+
+// Generates a new golden file and saves it into the correct folder.
+// Returns false if the file couldn't be created.
+bool GenerateGoldenFile(const std::string &golden_file_name, const void *data,
+                        int data_size);
+
+// Compare a golden file content with the input data.
+// Function will log the first byte position where the data differ.
+// Returns false if there are any differences.
+bool CompareGoldenFile(const std::string &golden_file_name, const void *data,
+                       int data_size);
+
+// Loads a mesh / point cloud specified by a |file_name| that is going to be
+// automatically converted to the correct path available to the testing
+// instance.
+inline std::unique_ptr<Mesh> ReadMeshFromTestFile(
+    const std::string &file_name) {
+  const std::string path = GetTestFileFullPath(file_name);
+  return ReadMeshFromFile(path).value();
+}
+inline std::unique_ptr<Mesh> ReadMeshFromTestFile(const std::string &file_name,
+                                                  bool use_metadata) {
+  const std::string path = GetTestFileFullPath(file_name);
+  return ReadMeshFromFile(path, use_metadata).value();
+}
+inline std::unique_ptr<Mesh> ReadMeshFromTestFile(const std::string &file_name,
+                                                  const Options &options) {
+  const std::string path = GetTestFileFullPath(file_name);
+  return ReadMeshFromFile(path, options).value();
+}
+
+inline std::unique_ptr<PointCloud> ReadPointCloudFromTestFile(
+    const std::string &file_name) {
+  const std::string path = GetTestFileFullPath(file_name);
+  return ReadPointCloudFromFile(path).value();
+}
+
+// Evaluates an expression that returns draco::Status. If the status is not OK,
+// the macro asserts and logs the error message.
+#define DRACO_ASSERT_OK(expression)                                      \
+  {                                                                      \
+    const draco::Status _local_status = (expression);                    \
+    ASSERT_TRUE(_local_status.ok()) << _local_status.error_msg_string(); \
+  }
+
+// In case StatusOr<T> is ok(), this macro assigns value stored in StatusOr<T>
+// to |lhs|, otherwise it asserts and logs the error message.
+//
+//   DRACO_ASSIGN_OR_ASSERT(lhs, expression)
+//
+#define DRACO_ASSIGN_OR_ASSERT(lhs, expression)                                \
+  DRACO_ASSIGN_OR_ASSERT_IMPL_(DRACO_MACROS_IMPL_CONCAT_(_statusor, __LINE__), \
+                               lhs, expression, _status)
+
+// The actual implementation of the above macro.
+#define DRACO_ASSIGN_OR_ASSERT_IMPL_(statusor, lhs, expression, error_expr) \
+  auto statusor = (expression);                                             \
+  ASSERT_TRUE(statusor.ok()) << statusor.status().error_msg_string();       \
+  lhs = std::move(statusor).value();
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_DRACO_TEST_UTILS_H_
diff --git a/engine/inc/draco/core/draco_types.h b/engine/inc/draco/core/draco_types.h
new file mode 100644
index 00000000..d14437a0
--- /dev/null
+++ b/engine/inc/draco/core/draco_types.h
@@ -0,0 +1,52 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_DRACO_TYPES_H_
+#define DRACO_CORE_DRACO_TYPES_H_
+
+#include <stdint.h>
+
+#include <string>
+
+#include "draco/draco_features.h"
+
+namespace draco {
+
+enum DataType {
+  // Not a legal value for DataType. Used to indicate a field has not been set.
+  DT_INVALID = 0,
+  DT_INT8,
+  DT_UINT8,
+  DT_INT16,
+  DT_UINT16,
+  DT_INT32,
+  DT_UINT32,
+  DT_INT64,
+  DT_UINT64,
+  DT_FLOAT32,
+  DT_FLOAT64,
+  DT_BOOL,
+  DT_TYPES_COUNT
+};
+
+int32_t DataTypeLength(DataType dt);
+
+// Equivalent to std::is_integral for draco::DataType. Returns true for all
+// signed and unsigned integer types (including DT_BOOL). Returns false
+// otherwise.
+bool IsDataTypeIntegral(DataType dt);
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_DRACO_TYPES_H_
diff --git a/engine/inc/draco/core/draco_version.h b/engine/inc/draco/core/draco_version.h
new file mode 100644
index 00000000..14a504a5
--- /dev/null
+++ b/engine/inc/draco/core/draco_version.h
@@ -0,0 +1,27 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_DRACO_VERSION_H_
+#define DRACO_CORE_DRACO_VERSION_H_
+
+namespace draco {
+
+// Draco version is comprised of <major>.<minor>.<revision>.
+static const char kDracoVersion[] = "1.4.1";
+
+const char *Version() { return kDracoVersion; }
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_DRACO_VERSION_H_
diff --git a/engine/inc/draco/core/encoder_buffer.h b/engine/inc/draco/core/encoder_buffer.h
new file mode 100644
index 00000000..b153a629
--- /dev/null
+++ b/engine/inc/draco/core/encoder_buffer.h
@@ -0,0 +1,152 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_ENCODER_BUFFER_H_
+#define DRACO_CORE_ENCODER_BUFFER_H_
+
+#include <memory>
+#include <vector>
+
+#include "draco/core/bit_utils.h"
+#include "draco/core/macros.h"
+
+namespace draco {
+
+// Class representing a buffer that can be used for either for byte-aligned
+// encoding of arbitrary data structures or for encoding of variable-length
+// bit data.
+class EncoderBuffer {
+ public:
+  EncoderBuffer();
+  void Clear();
+  void Resize(int64_t nbytes);
+
+  // Start encoding a bit sequence. A maximum size of the sequence needs to
+  // be known upfront.
+  // If encode_size is true, the size of encoded bit sequence is stored before
+  // the sequence. Decoder can then use this size to skip over the bit sequence
+  // if needed.
+  // Returns false on error.
+  bool StartBitEncoding(int64_t required_bits, bool encode_size);
+
+  // End the encoding of the bit sequence and return to the default byte-aligned
+  // encoding.
+  void EndBitEncoding();
+
+  // Encode up to 32 bits into the buffer. Can be called only in between
+  // StartBitEncoding and EndBitEncoding. Otherwise returns false.
+  bool EncodeLeastSignificantBits32(int nbits, uint32_t value) {
+    if (!bit_encoder_active()) {
+      return false;
+    }
+    bit_encoder_->PutBits(value, nbits);
+    return true;
+  }
+  // Encode an arbitrary data type.
+  // Can be used only when we are not encoding a bit-sequence.
+  // Returns false when the value couldn't be encoded.
+  template <typename T>
+  bool Encode(const T &data) {
+    if (bit_encoder_active()) {
+      return false;
+    }
+    const uint8_t *src_data = reinterpret_cast<const uint8_t *>(&data);
+    buffer_.insert(buffer_.end(), src_data, src_data + sizeof(T));
+    return true;
+  }
+  bool Encode(const void *data, size_t data_size) {
+    if (bit_encoder_active()) {
+      return false;
+    }
+    const uint8_t *src_data = reinterpret_cast<const uint8_t *>(data);
+    buffer_.insert(buffer_.end(), src_data, src_data + data_size);
+    return true;
+  }
+
+  bool bit_encoder_active() const { return bit_encoder_reserved_bytes_ > 0; }
+  const char *data() const { return buffer_.data(); }
+  size_t size() const { return buffer_.size(); }
+  std::vector<char> *buffer() { return &buffer_; }
+
+ private:
+  // Internal helper class to encode bits to a bit buffer.
+  class BitEncoder {
+   public:
+    // |data| is the buffer to write the bits into.
+    explicit BitEncoder(char *data) : bit_buffer_(data), bit_offset_(0) {}
+
+    // Write |nbits| of |data| into the bit buffer.
+    void PutBits(uint32_t data, int32_t nbits) {
+      DRACO_DCHECK_GE(nbits, 0);
+      DRACO_DCHECK_LE(nbits, 32);
+      for (int32_t bit = 0; bit < nbits; ++bit) {
+        PutBit((data >> bit) & 1);
+      }
+    }
+
+    // Return number of bits encoded so far.
+    uint64_t Bits() const { return static_cast<uint64_t>(bit_offset_); }
+
+    // TODO(fgalligan): Remove this function once we know we do not need the
+    // old API anymore.
+    // This is a function of an old API, that currently does nothing.
+    void Flush(int /* left_over_bit_value */) {}
+
+    // Return the number of bits required to store the given number
+    static uint32_t BitsRequired(uint32_t x) {
+      return static_cast<uint32_t>(MostSignificantBit(x));
+    }
+
+   private:
+    void PutBit(uint8_t value) {
+      const int byte_size = 8;
+      const uint64_t off = static_cast<uint64_t>(bit_offset_);
+      const uint64_t byte_offset = off / byte_size;
+      const int bit_shift = off % byte_size;
+
+      // TODO(fgalligan): Check performance if we add a branch and only do one
+      // memory write if bit_shift is 7. Also try using a temporary variable to
+      // hold the bits before writing to the buffer.
+
+      bit_buffer_[byte_offset] &= ~(1 << bit_shift);
+      bit_buffer_[byte_offset] |= value << bit_shift;
+      bit_offset_++;
+    }
+
+    char *bit_buffer_;
+    size_t bit_offset_;
+  };
+  friend class BufferBitCodingTest;
+  // All data is stored in this vector.
+  std::vector<char> buffer_;
+
+  // Bit encoder is used when encoding variable-length bit data.
+  // TODO(ostava): Currently encoder needs to be recreated each time
+  // StartBitEncoding method is called. This is not necessary if BitEncoder
+  // supported reset function which can easily added but let's leave that for
+  // later.
+  std::unique_ptr<BitEncoder> bit_encoder_;
+
+  // The number of bytes reserved for bit encoder.
+  // Values > 0 indicate we are in the bit encoding mode.
+  int64_t bit_encoder_reserved_bytes_;
+
+  // Flag used indicating that we need to store the length of the currently
+  // processed bit sequence.
+  bool encode_bit_sequence_size_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_ENCODER_BUFFER_H_
diff --git a/engine/inc/draco/core/hash_utils.h b/engine/inc/draco/core/hash_utils.h
new file mode 100644
index 00000000..aa61523e
--- /dev/null
+++ b/engine/inc/draco/core/hash_utils.h
@@ -0,0 +1,64 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_HASH_UTILS_H_
+#define DRACO_CORE_HASH_UTILS_H_
+
+#include <stdint.h>
+
+#include <cstddef>
+#include <functional>
+
+namespace draco {
+
+template <typename T1, typename T2>
+size_t HashCombine(T1 a, T2 b) {
+  const size_t hash1 = std::hash<T1>()(a);
+  const size_t hash2 = std::hash<T2>()(b);
+  return (hash1 << 2) ^ (hash2 << 1);
+}
+
+template <typename T>
+size_t HashCombine(T a, size_t hash) {
+  const size_t hasha = std::hash<T>()(a);
+  return (hash) ^ (hasha + 239);
+}
+
+inline uint64_t HashCombine(uint64_t a, uint64_t b) {
+  return (a + 1013) ^ (b + 107) << 1;
+}
+
+// Will never return 1 or 0.
+uint64_t FingerprintString(const char *s, size_t len);
+
+// Hash for std::array.
+template <typename T>
+struct HashArray {
+  size_t operator()(const T &a) const {
+    size_t hash = 79;  // Magic number.
+    for (unsigned int i = 0; i < std::tuple_size<T>::value; ++i) {
+      hash = HashCombine(hash, ValueHash(a[i]));
+    }
+    return hash;
+  }
+
+  template <typename V>
+  size_t ValueHash(const V &val) const {
+    return std::hash<V>()(val);
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_HASH_UTILS_H_
diff --git a/engine/inc/draco/core/macros.h b/engine/inc/draco/core/macros.h
new file mode 100644
index 00000000..147bbaaf
--- /dev/null
+++ b/engine/inc/draco/core/macros.h
@@ -0,0 +1,119 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_MACROS_H_
+#define DRACO_CORE_MACROS_H_
+
+#include "assert.h"
+#include "draco/draco_features.h"
+
+#ifdef ANDROID_LOGGING
+#include <android/log.h>
+#define LOG_TAG "draco"
+#define DRACO_LOGI(...) \
+  __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
+#define DRACO_LOGE(...) \
+  __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+#else
+#define DRACO_LOGI printf
+#define DRACO_LOGE printf
+#endif
+
+#include <iostream>
+namespace draco {
+
+#ifndef DISALLOW_COPY_AND_ASSIGN
+#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
+  TypeName(const TypeName &) = delete;     \
+  void operator=(const TypeName &) = delete;
+#endif
+
+#ifndef FALLTHROUGH_INTENDED
+#if defined(__clang__) && defined(__has_warning)
+#if __has_feature(cxx_attributes) && __has_warning("-Wimplicit-fallthrough")
+#define FALLTHROUGH_INTENDED [[clang::fallthrough]]
+#endif
+#elif defined(__GNUC__) && __GNUC__ >= 7
+#define FALLTHROUGH_INTENDED [[gnu::fallthrough]]
+#endif
+
+// If FALLTHROUGH_INTENDED is still not defined, define it.
+#ifndef FALLTHROUGH_INTENDED
+#define FALLTHROUGH_INTENDED \
+  do {                       \
+  } while (0)
+#endif
+#endif
+
+#ifndef LOG
+#define LOG(...) std::cout
+#endif
+
+#ifndef VLOG
+#define VLOG(...) std::cout
+#endif
+
+}  // namespace draco
+
+#ifdef DRACO_DEBUG
+#define DRACO_DCHECK(x) (assert(x));
+#define DRACO_DCHECK_EQ(a, b) assert((a) == (b));
+#define DRACO_DCHECK_NE(a, b) assert((a) != (b));
+#define DRACO_DCHECK_GE(a, b) assert((a) >= (b));
+#define DRACO_DCHECK_GT(a, b) assert((a) > (b));
+#define DRACO_DCHECK_LE(a, b) assert((a) <= (b));
+#define DRACO_DCHECK_LT(a, b) assert((a) < (b));
+#define DRACO_DCHECK_NOTNULL(x) assert((x) != NULL);
+#else
+#define DRACO_DCHECK(x)
+#define DRACO_DCHECK_EQ(a, b)
+#define DRACO_DCHECK_NE(a, b)
+#define DRACO_DCHECK_GE(a, b)
+#define DRACO_DCHECK_GT(a, b)
+#define DRACO_DCHECK_LE(a, b)
+#define DRACO_DCHECK_LT(a, b)
+#define DRACO_DCHECK_NOTNULL(x)
+#endif
+
+// Helper macros for concatenating macro values.
+#define DRACO_MACROS_IMPL_CONCAT_INNER_(x, y) x##y
+#define DRACO_MACROS_IMPL_CONCAT_(x, y) DRACO_MACROS_IMPL_CONCAT_INNER_(x, y)
+
+// Expand the n-th argument of the macro. Used to select an argument based on
+// the number of entries in a variadic macro argument. Example usage:
+//
+// #define FUNC_1(x) x
+// #define FUNC_2(x, y) x + y
+// #define FUNC_3(x, y, z) x + y + z
+//
+// #define VARIADIC_MACRO(...)
+//   DRACO_SELECT_NTH_FROM_3(__VA_ARGS__, FUNC_3, FUNC_2, FUNC_1) __VA_ARGS__
+//
+#define DRACO_SELECT_NTH_FROM_2(_1, _2, NAME) NAME
+#define DRACO_SELECT_NTH_FROM_3(_1, _2, _3, NAME) NAME
+#define DRACO_SELECT_NTH_FROM_4(_1, _2, _3, _4, NAME) NAME
+
+// Macro that converts the Draco bit-stream into one uint16_t number.
+// Useful mostly when checking version numbers.
+#define DRACO_BITSTREAM_VERSION(MAJOR, MINOR) \
+  ((static_cast<uint16_t>(MAJOR) << 8) | MINOR)
+
+// Macro that converts the uint16_t Draco bit-stream number into the major
+// and minor components respectively.
+#define DRACO_BISTREAM_VERSION_MAJOR(VERSION) \
+  (static_cast<uint8_t>(VERSION >> 8))
+#define DRACO_BISTREAM_VERSION_MINOR(VERSION) \
+  (static_cast<uint8_t>(VERSION & 0xFF))
+
+#endif  // DRACO_CORE_MACROS_H_
diff --git a/engine/inc/draco/core/math_utils.h b/engine/inc/draco/core/math_utils.h
new file mode 100644
index 00000000..7f382fa3
--- /dev/null
+++ b/engine/inc/draco/core/math_utils.h
@@ -0,0 +1,55 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_MATH_UTILS_H_
+#define DRACO_CORE_MATH_UTILS_H_
+
+#include <inttypes.h>
+
+#include "draco/core/vector_d.h"
+
+#define DRACO_INCREMENT_MOD(I, M) (((I) == ((M)-1)) ? 0 : ((I) + 1))
+
+// Returns floor(sqrt(x)) where x is an integer number. The main intend of this
+// function is to provide a cross platform and deterministic implementation of
+// square root for integer numbers. This function is not intended to be a
+// replacement for std::sqrt() for general cases. IntSqrt is in fact about 3X
+// slower compared to most implementation of std::sqrt().
+inline uint64_t IntSqrt(uint64_t number) {
+  if (number == 0) {
+    return 0;
+  }
+  // First estimate good initial value of the square root as log2(number).
+  uint64_t act_number = number;
+  uint64_t square_root = 1;
+  while (act_number >= 2) {
+    // Double the square root until |square_root * square_root > number|.
+    square_root *= 2;
+    act_number /= 4;
+  }
+  // Perform Newton's (or Babylonian) method to find the true floor(sqrt()).
+  do {
+    // New |square_root| estimate is computed as the average between
+    // |square_root| and |number / square_root|.
+    square_root = (square_root + number / square_root) / 2;
+
+    // Note that after the first iteration, the estimate is always going to be
+    // larger or equal to the true square root value. Therefore to check
+    // convergence, we can simply detect condition when the square of the
+    // estimated square root is larger than the input.
+  } while (square_root * square_root > number);
+  return square_root;
+}
+
+#endif  // DRACO_CORE_MATH_UTILS_H_
diff --git a/engine/inc/draco/core/options.h b/engine/inc/draco/core/options.h
new file mode 100644
index 00000000..1bc4dc0f
--- /dev/null
+++ b/engine/inc/draco/core/options.h
@@ -0,0 +1,150 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_OPTIONS_H_
+#define DRACO_CORE_OPTIONS_H_
+
+#include <cstdlib>
+#include <map>
+#include <string>
+
+namespace draco {
+
+// Class for storing generic options as a <name, value> pair in a string map.
+// The API provides helper methods for directly storing values of various types
+// such as ints and bools. One named option should be set with only a single
+// data type.
+class Options {
+ public:
+  Options();
+
+  // Merges |other_options| on top of the existing options of this instance
+  // replacing all entries that are present in both options instances.
+  void MergeAndReplace(const Options &other_options);
+
+  void SetInt(const std::string &name, int val);
+  void SetFloat(const std::string &name, float val);
+  void SetBool(const std::string &name, bool val);
+  void SetString(const std::string &name, const std::string &val);
+  template <class VectorT>
+  void SetVector(const std::string &name, const VectorT &vec) {
+    SetVector(name, &vec[0], VectorT::dimension);
+  }
+  template <typename DataTypeT>
+  void SetVector(const std::string &name, const DataTypeT *vec, int num_dims);
+
+  // Getters will return a default value if the entry is not found. The default
+  // value can be specified in the overloaded version of each function.
+  int GetInt(const std::string &name) const;
+  int GetInt(const std::string &name, int default_val) const;
+  float GetFloat(const std::string &name) const;
+  float GetFloat(const std::string &name, float default_val) const;
+  bool GetBool(const std::string &name) const;
+  bool GetBool(const std::string &name, bool default_val) const;
+  std::string GetString(const std::string &name) const;
+  std::string GetString(const std::string &name,
+                        const std::string &default_val) const;
+  template <class VectorT>
+  VectorT GetVector(const std::string &name, const VectorT &default_val) const;
+  // Unlike other Get functions, this function returns false if the option does
+  // not exist, otherwise it fills |out_val| with the vector values. If a
+  // default value is needed, it can be set in |out_val|.
+  template <typename DataTypeT>
+  bool GetVector(const std::string &name, int num_dims,
+                 DataTypeT *out_val) const;
+
+  bool IsOptionSet(const std::string &name) const {
+    return options_.count(name) > 0;
+  }
+
+ private:
+  // All entries are internally stored as strings and converted to the desired
+  // return type based on the used Get* method.
+  // TODO(ostava): Consider adding type safety mechanism that would prevent
+  // unsafe operations such as a conversion from vector to int.
+  std::map<std::string, std::string> options_;
+};
+
+template <typename DataTypeT>
+void Options::SetVector(const std::string &name, const DataTypeT *vec,
+                        int num_dims) {
+  std::string out;
+  for (int i = 0; i < num_dims; ++i) {
+    if (i > 0) {
+      out += " ";
+    }
+
+// GNU STL on android doesn't include a proper std::to_string, but the libc++
+// version does
+#if defined(ANDROID) && !defined(_LIBCPP_VERSION)
+    out += to_string(vec[i]);
+#else
+    out += std::to_string(vec[i]);
+#endif
+  }
+  options_[name] = out;
+}
+
+template <class VectorT>
+VectorT Options::GetVector(const std::string &name,
+                           const VectorT &default_val) const {
+  VectorT ret = default_val;
+  GetVector(name, VectorT::dimension, &ret[0]);
+  return ret;
+}
+
+template <typename DataTypeT>
+bool Options::GetVector(const std::string &name, int num_dims,
+                        DataTypeT *out_val) const {
+  const auto it = options_.find(name);
+  if (it == options_.end()) {
+    return false;
+  }
+  const std::string value = it->second;
+  if (value.length() == 0) {
+    return true;  // Option set but no data is present
+  }
+  const char *act_str = value.c_str();
+  char *next_str;
+  for (int i = 0; i < num_dims; ++i) {
+    if (std::is_integral<DataTypeT>::value) {
+#ifdef ANDROID
+      const int val = strtol(act_str, &next_str, 10);
+#else
+      const int val = static_cast<int>(std::strtol(act_str, &next_str, 10));
+#endif
+      if (act_str == next_str) {
+        return true;  // End reached.
+      }
+      act_str = next_str;
+      out_val[i] = static_cast<DataTypeT>(val);
+    } else {
+#ifdef ANDROID
+      const float val = strtof(act_str, &next_str);
+#else
+      const float val = std::strtof(act_str, &next_str);
+#endif
+      if (act_str == next_str) {
+        return true;  // End reached.
+      }
+      act_str = next_str;
+      out_val[i] = static_cast<DataTypeT>(val);
+    }
+  }
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_OPTIONS_H_
diff --git a/engine/inc/draco/core/quantization_utils.h b/engine/inc/draco/core/quantization_utils.h
new file mode 100644
index 00000000..0f60f1e1
--- /dev/null
+++ b/engine/inc/draco/core/quantization_utils.h
@@ -0,0 +1,82 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// A set of classes for quantizing and dequantizing of floating point values
+// into integers.
+// The quantization works on all floating point numbers within (-range, +range)
+// interval producing integers in range
+// (-max_quantized_value, +max_quantized_value).
+
+#ifndef DRACO_CORE_QUANTIZATION_UTILS_H_
+#define DRACO_CORE_QUANTIZATION_UTILS_H_
+
+#include <stdint.h>
+
+#include <cmath>
+
+#include "draco/core/macros.h"
+
+namespace draco {
+
+// Class for quantizing single precision floating point values. The values
+// should be centered around zero and be within interval (-range, +range), where
+// the range is specified in the Init() method. Alternatively, the quantization
+// can be defined by |delta| that specifies the distance between two quantized
+// values. Note that the quantizer always snaps the values to the nearest
+// integer value. E.g. for |delta| == 1.f, values -0.4f and 0.4f would be
+// both quantized to 0 while value 0.6f would be quantized to 1. If a value
+// lies exactly between two quantized states, it is always rounded up. E.g.,
+// for |delta| == 1.f, value -0.5f would be quantized to 0 while 0.5f would be
+// quantized to 1.
+class Quantizer {
+ public:
+  Quantizer();
+  void Init(float range, int32_t max_quantized_value);
+  void Init(float delta);
+  inline int32_t QuantizeFloat(float val) const {
+    val *= inverse_delta_;
+    return static_cast<int32_t>(floor(val + 0.5f));
+  }
+  inline int32_t operator()(float val) const { return QuantizeFloat(val); }
+
+ private:
+  float inverse_delta_;
+};
+
+// Class for dequantizing values that were previously quantized using the
+// Quantizer class.
+class Dequantizer {
+ public:
+  Dequantizer();
+
+  // Initializes the dequantizer. Both parameters must correspond to the values
+  // provided to the initializer of the Quantizer class.
+  // Returns false when the initialization fails.
+  bool Init(float range, int32_t max_quantized_value);
+
+  // Initializes the dequantizer using the |delta| between two quantized values.
+  bool Init(float delta);
+
+  inline float DequantizeFloat(int32_t val) const {
+    return static_cast<float>(val) * delta_;
+  }
+  inline float operator()(int32_t val) const { return DequantizeFloat(val); }
+
+ private:
+  float delta_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_QUANTIZATION_UTILS_H_
diff --git a/engine/inc/draco/core/status.h b/engine/inc/draco/core/status.h
new file mode 100644
index 00000000..449ad856
--- /dev/null
+++ b/engine/inc/draco/core/status.h
@@ -0,0 +1,77 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_STATUS_H_
+#define DRACO_CORE_STATUS_H_
+
+#include <string>
+
+namespace draco {
+
+// Class encapsulating a return status of an operation with an optional error
+// message. Intended to be used as a return type for functions instead of bool.
+class Status {
+ public:
+  enum Code {
+    OK = 0,
+    DRACO_ERROR = -1,          // Used for general errors.
+    IO_ERROR = -2,             // Error when handling input or output stream.
+    INVALID_PARAMETER = -3,    // Invalid parameter passed to a function.
+    UNSUPPORTED_VERSION = -4,  // Input not compatible with the current version.
+    UNKNOWN_VERSION = -5,      // Input was created with an unknown version of
+                               // the library.
+    UNSUPPORTED_FEATURE = -6,  // Input contains feature that is not supported.
+  };
+
+  Status() : code_(OK) {}
+  Status(const Status &status) = default;
+  Status(Status &&status) = default;
+  explicit Status(Code code) : code_(code) {}
+  Status(Code code, const std::string &error_msg)
+      : code_(code), error_msg_(error_msg) {}
+
+  Code code() const { return code_; }
+  const std::string &error_msg_string() const { return error_msg_; }
+  const char *error_msg() const { return error_msg_.c_str(); }
+
+  bool operator==(Code code) const { return code == code_; }
+  bool ok() const { return code_ == OK; }
+
+  Status &operator=(const Status &) = default;
+
+ private:
+  Code code_;
+  std::string error_msg_;
+};
+
+inline std::ostream &operator<<(std::ostream &os, const Status &status) {
+  os << status.error_msg_string();
+  return os;
+}
+
+inline Status OkStatus() { return Status(Status::OK); }
+
+// Evaluates an expression that returns draco::Status. If the status is not OK,
+// the macro returns the status object.
+#define DRACO_RETURN_IF_ERROR(expression)             \
+  {                                                   \
+    const draco::Status _local_status = (expression); \
+    if (!_local_status.ok()) {                        \
+      return _local_status;                           \
+    }                                                 \
+  }
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_STATUS_H_
diff --git a/engine/inc/draco/core/status_or.h b/engine/inc/draco/core/status_or.h
new file mode 100644
index 00000000..156b9bc0
--- /dev/null
+++ b/engine/inc/draco/core/status_or.h
@@ -0,0 +1,81 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_STATUS_OR_H_
+#define DRACO_CORE_STATUS_OR_H_
+
+#include "draco/core/macros.h"
+#include "draco/core/status.h"
+
+namespace draco {
+
+// Class StatusOr is used to wrap a Status along with a value of a specified
+// type |T|. StatusOr is intended to be returned from functions in situations
+// where it is desirable to carry over more information about the potential
+// errors encountered during the function execution. If there are not errors,
+// the caller can simply use the return value, otherwise the Status object
+// provides more info about the encountered problem.
+template <class T>
+class StatusOr {
+ public:
+  StatusOr() {}
+  // Note: Constructors are intentionally not explicit to allow returning
+  // Status or the return value directly from functions.
+  StatusOr(const StatusOr &) = default;
+  StatusOr(StatusOr &&) = default;
+  StatusOr(const Status &status) : status_(status) {}
+  StatusOr(const T &value) : status_(OkStatus()), value_(value) {}
+  StatusOr(T &&value) : status_(OkStatus()), value_(std::move(value)) {}
+  StatusOr(const Status &status, const T &value)
+      : status_(status), value_(value) {}
+
+  const Status &status() const { return status_; }
+  const T &value() const & { return value_; }
+  const T &&value() const && { return std::move(value_); }
+  T &&value() && { return std::move(value_); }
+
+  // For consistency with existing Google StatusOr API we also include
+  // ValueOrDie() that currently returns the value().
+  const T &ValueOrDie() const & { return value(); }
+  T &&ValueOrDie() && { return std::move(value()); }
+
+  bool ok() const { return status_.ok(); }
+
+ private:
+  Status status_;
+  T value_;
+};
+
+// In case StatusOr<T> is ok(), this macro assigns value stored in StatusOr<T>
+// to |lhs|, otherwise it returns the error Status.
+//
+//   DRACO_ASSIGN_OR_RETURN(lhs, expression)
+//
+#define DRACO_ASSIGN_OR_RETURN(lhs, expression)                                \
+  DRACO_ASSIGN_OR_RETURN_IMPL_(DRACO_MACROS_IMPL_CONCAT_(_statusor, __LINE__), \
+                               lhs, expression, _status)
+
+// The actual implementation of the above macro.
+#define DRACO_ASSIGN_OR_RETURN_IMPL_(statusor, lhs, expression, error_expr) \
+  auto statusor = (expression);                                             \
+  if (!statusor.ok()) {                                                     \
+    auto _status = std::move(statusor.status());                            \
+    (void)_status; /* error_expression may not use it */                    \
+    return error_expr;                                                      \
+  }                                                                         \
+  lhs = std::move(statusor).value();
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_STATUS_OR_H_
diff --git a/engine/inc/draco/core/varint_decoding.h b/engine/inc/draco/core/varint_decoding.h
new file mode 100644
index 00000000..cff47e93
--- /dev/null
+++ b/engine/inc/draco/core/varint_decoding.h
@@ -0,0 +1,81 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_VARINT_DECODING_H_
+#define DRACO_CORE_VARINT_DECODING_H_
+
+#include <type_traits>
+
+#include "draco/core/bit_utils.h"
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+
+namespace {
+
+// Decodes a specified unsigned integer as varint. |depth| is the current
+// recursion call depth. The first call to the function must be 1.
+template <typename IntTypeT>
+bool DecodeVarintUnsigned(int depth, IntTypeT *out_val, DecoderBuffer *buffer) {
+  constexpr IntTypeT max_depth = sizeof(IntTypeT) + 1 + (sizeof(IntTypeT) >> 3);
+  if (depth > max_depth) {
+    return false;
+  }
+  // Coding of unsigned values.
+  // 0-6 bit - data
+  // 7 bit - next byte?
+  uint8_t in;
+  if (!buffer->Decode(&in)) {
+    return false;
+  }
+  if (in & (1 << 7)) {
+    // Next byte is available, decode it first.
+    if (!DecodeVarintUnsigned<IntTypeT>(depth + 1, out_val, buffer)) {
+      return false;
+    }
+    // Append decoded info from this byte.
+    *out_val <<= 7;
+    *out_val |= in & ((1 << 7) - 1);
+  } else {
+    // Last byte reached
+    *out_val = in;
+  }
+  return true;
+}
+
+}  // namespace
+
+// Decodes a specified integer as varint. Note that the IntTypeT must be the
+// same as the one used in the corresponding EncodeVarint() call.
+// out_val is undefined if this returns false.
+template <typename IntTypeT>
+bool DecodeVarint(IntTypeT *out_val, DecoderBuffer *buffer) {
+  if (std::is_unsigned<IntTypeT>::value) {
+    if (!DecodeVarintUnsigned<IntTypeT>(1, out_val, buffer)) {
+      return false;
+    }
+  } else {
+    // IntTypeT is a signed value. Decode the symbol and convert to signed.
+    typename std::make_unsigned<IntTypeT>::type symbol;
+    if (!DecodeVarintUnsigned(1, &symbol, buffer)) {
+      return false;
+    }
+    *out_val = ConvertSymbolToSignedInt(symbol);
+  }
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_VARINT_DECODING_H_
diff --git a/engine/inc/draco/core/varint_encoding.h b/engine/inc/draco/core/varint_encoding.h
new file mode 100644
index 00000000..9a8a5393
--- /dev/null
+++ b/engine/inc/draco/core/varint_encoding.h
@@ -0,0 +1,61 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_VARINT_ENCODING_H_
+#define DRACO_CORE_VARINT_ENCODING_H_
+
+#include <type_traits>
+
+#include "draco/core/bit_utils.h"
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// Encodes a specified integer as varint. Note that different coding is used
+// when IntTypeT is an unsigned data type.
+template <typename IntTypeT>
+bool EncodeVarint(IntTypeT val, EncoderBuffer *out_buffer) {
+  if (std::is_unsigned<IntTypeT>::value) {
+    // Coding of unsigned values.
+    // 0-6 bit - data
+    // 7 bit - next byte?
+    uint8_t out = 0;
+    out |= val & ((1 << 7) - 1);
+    if (val >= (1 << 7)) {
+      out |= (1 << 7);
+      if (!out_buffer->Encode(out)) {
+        return false;
+      }
+      if (!EncodeVarint<IntTypeT>(val >> 7, out_buffer)) {
+        return false;
+      }
+      return true;
+    }
+    if (!out_buffer->Encode(out)) {
+      return false;
+    }
+  } else {
+    // IntTypeT is a signed value. Convert to unsigned symbol and encode.
+    const typename std::make_unsigned<IntTypeT>::type symbol =
+        ConvertSignedIntToSymbol(val);
+    if (!EncodeVarint(symbol, out_buffer)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_VARINT_ENCODING_H_
diff --git a/engine/inc/draco/core/vector_d.h b/engine/inc/draco/core/vector_d.h
new file mode 100644
index 00000000..a3c46a46
--- /dev/null
+++ b/engine/inc/draco/core/vector_d.h
@@ -0,0 +1,355 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_VECTOR_D_H_
+#define DRACO_CORE_VECTOR_D_H_
+
+#include <inttypes.h>
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <limits>
+
+#include "draco/core/macros.h"
+
+namespace draco {
+// D-dimensional vector class with basic operations.
+template <class ScalarT, int dimension_t>
+class VectorD {
+ public:
+  static constexpr int dimension = dimension_t;
+
+  typedef ScalarT Scalar;
+  typedef VectorD<Scalar, dimension_t> Self;
+
+  // TODO(hemmer): Deprecate.
+  typedef ScalarT CoefficientType;
+
+  VectorD() {
+    for (int i = 0; i < dimension; ++i) {
+      (*this)[i] = Scalar(0);
+    }
+  }
+
+  // The following constructor does not compile in opt mode, which for now led
+  // to the constructors further down, which is not ideal.
+  // TODO(hemmer): fix constructor below and remove others.
+  // template <typename... Args>
+  // explicit VectorD(Args... args) : v_({args...}) {}
+
+  VectorD(const Scalar &c0, const Scalar &c1) : v_({{c0, c1}}) {
+    DRACO_DCHECK_EQ(dimension, 2);
+    v_[0] = c0;
+    v_[1] = c1;
+  }
+
+  VectorD(const Scalar &c0, const Scalar &c1, const Scalar &c2)
+      : v_({{c0, c1, c2}}) {
+    DRACO_DCHECK_EQ(dimension, 3);
+  }
+
+  VectorD(const Scalar &c0, const Scalar &c1, const Scalar &c2,
+          const Scalar &c3)
+      : v_({{c0, c1, c2, c3}}) {
+    DRACO_DCHECK_EQ(dimension, 4);
+  }
+
+  VectorD(const Scalar &c0, const Scalar &c1, const Scalar &c2,
+          const Scalar &c3, const Scalar &c4)
+      : v_({{c0, c1, c2, c3, c4}}) {
+    DRACO_DCHECK_EQ(dimension, 5);
+  }
+
+  VectorD(const Scalar &c0, const Scalar &c1, const Scalar &c2,
+          const Scalar &c3, const Scalar &c4, const Scalar &c5)
+      : v_({{c0, c1, c2, c3, c4, c5}}) {
+    DRACO_DCHECK_EQ(dimension, 6);
+  }
+
+  VectorD(const Scalar &c0, const Scalar &c1, const Scalar &c2,
+          const Scalar &c3, const Scalar &c4, const Scalar &c5,
+          const Scalar &c6)
+      : v_({{c0, c1, c2, c3, c4, c5, c6}}) {
+    DRACO_DCHECK_EQ(dimension, 7);
+  }
+
+  VectorD(const Self &o) {
+    for (int i = 0; i < dimension; ++i) {
+      (*this)[i] = o[i];
+    }
+  }
+
+  // Constructs the vector from another vector with a different data type or a
+  // different number of components. If the |src_vector| has more components
+  // than |this| vector, the excess components are truncated. If the
+  // |src_vector| has fewer components than |this| vector, the remaining
+  // components are padded with 0.
+  // Note that the constructor is intentionally explicit to avoid accidental
+  // conversions between different vector types.
+  template <class OtherScalarT, int other_dimension_t>
+  explicit VectorD(const VectorD<OtherScalarT, other_dimension_t> &src_vector) {
+    for (int i = 0; i < dimension; ++i) {
+      if (i < other_dimension_t) {
+        v_[i] = Scalar(src_vector[i]);
+      } else {
+        v_[i] = Scalar(0);
+      }
+    }
+  }
+
+  Scalar &operator[](int i) { return v_[i]; }
+  const Scalar &operator[](int i) const { return v_[i]; }
+  // TODO(hemmer): remove.
+  // Similar to interface of Eigen library.
+  Scalar &operator()(int i) { return v_[i]; }
+  const Scalar &operator()(int i) const { return v_[i]; }
+
+  // Unary operators.
+  Self operator-() const {
+    Self ret;
+    for (int i = 0; i < dimension; ++i) {
+      ret[i] = -(*this)[i];
+    }
+    return ret;
+  }
+
+  // Binary operators.
+  Self operator+(const Self &o) const {
+    Self ret;
+    for (int i = 0; i < dimension; ++i) {
+      ret[i] = (*this)[i] + o[i];
+    }
+    return ret;
+  }
+
+  Self operator-(const Self &o) const {
+    Self ret;
+    for (int i = 0; i < dimension; ++i) {
+      ret[i] = (*this)[i] - o[i];
+    }
+    return ret;
+  }
+
+  Self operator*(const Self &o) const {
+    Self ret;
+    for (int i = 0; i < dimension; ++i) {
+      ret[i] = (*this)[i] * o[i];
+    }
+    return ret;
+  }
+
+  Self &operator+=(const Self &o) {
+    for (int i = 0; i < dimension; ++i) {
+      (*this)[i] += o[i];
+    }
+    return *this;
+  }
+
+  Self &operator-=(const Self &o) {
+    for (int i = 0; i < dimension; ++i) {
+      (*this)[i] -= o[i];
+    }
+    return *this;
+  }
+
+  Self &operator*=(const Self &o) {
+    for (int i = 0; i < dimension; ++i) {
+      (*this)[i] *= o[i];
+    }
+    return *this;
+  }
+
+  Self operator*(const Scalar &o) const {
+    Self ret;
+    for (int i = 0; i < dimension; ++i) {
+      ret[i] = (*this)[i] * o;
+    }
+    return ret;
+  }
+
+  Self operator/(const Scalar &o) const {
+    Self ret;
+    for (int i = 0; i < dimension; ++i) {
+      ret[i] = (*this)[i] / o;
+    }
+    return ret;
+  }
+
+  Self operator+(const Scalar &o) const {
+    Self ret;
+    for (int i = 0; i < dimension; ++i) {
+      ret[i] = (*this)[i] + o;
+    }
+    return ret;
+  }
+
+  Self operator-(const Scalar &o) const {
+    Self ret;
+    for (int i = 0; i < dimension; ++i) {
+      ret[i] = (*this)[i] - o;
+    }
+    return ret;
+  }
+
+  bool operator==(const Self &o) const {
+    for (int i = 0; i < dimension; ++i) {
+      if ((*this)[i] != o[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  bool operator!=(const Self &x) const { return !((*this) == x); }
+
+  bool operator<(const Self &x) const {
+    for (int i = 0; i < dimension - 1; ++i) {
+      if (v_[i] < x.v_[i]) {
+        return true;
+      }
+      if (v_[i] > x.v_[i]) {
+        return false;
+      }
+    }
+    // Only one check needed for the last dimension.
+    if (v_[dimension - 1] < x.v_[dimension - 1]) {
+      return true;
+    }
+    return false;
+  }
+
+  // Functions.
+  Scalar SquaredNorm() const { return this->Dot(*this); }
+
+  // Computes L1, the sum of absolute values of all entries.
+  Scalar AbsSum() const {
+    Scalar result(0);
+    for (int i = 0; i < dimension; ++i) {
+      Scalar next_value = std::abs(v_[i]);
+      if (result > std::numeric_limits<Scalar>::max() - next_value) {
+        // Return the max if adding would have caused an overflow.
+        return std::numeric_limits<Scalar>::max();
+      }
+      result += next_value;
+    }
+    return result;
+  }
+
+  Scalar Dot(const Self &o) const {
+    Scalar ret(0);
+    for (int i = 0; i < dimension; ++i) {
+      ret += (*this)[i] * o[i];
+    }
+    return ret;
+  }
+
+  void Normalize() {
+    const Scalar magnitude = std::sqrt(this->SquaredNorm());
+    if (magnitude == 0) {
+      return;
+    }
+    for (int i = 0; i < dimension; ++i) {
+      (*this)[i] /= magnitude;
+    }
+  }
+
+  Self GetNormalized() const {
+    Self ret(*this);
+    ret.Normalize();
+    return ret;
+  }
+
+  const Scalar &MaxCoeff() const {
+    return *std::max_element(v_.begin(), v_.end());
+  }
+
+  const Scalar &MinCoeff() const {
+    return *std::min_element(v_.begin(), v_.end());
+  }
+
+  Scalar *data() { return &(v_[0]); }
+  const Scalar *data() const { return &(v_[0]); }
+
+ private:
+  std::array<Scalar, dimension> v_;
+};
+
+// Scalar multiplication from the other side too.
+template <class ScalarT, int dimension_t>
+VectorD<ScalarT, dimension_t> operator*(
+    const ScalarT &o, const VectorD<ScalarT, dimension_t> &v) {
+  return v * o;
+}
+
+// Calculates the squared distance between two points.
+template <class ScalarT, int dimension_t>
+ScalarT SquaredDistance(const VectorD<ScalarT, dimension_t> &v1,
+                        const VectorD<ScalarT, dimension_t> &v2) {
+  ScalarT difference;
+  ScalarT squared_distance = 0;
+  // Check each index separately so difference is never negative and underflow
+  // is avoided for unsigned types.
+  for (int i = 0; i < dimension_t; ++i) {
+    if (v1[i] >= v2[i]) {
+      difference = v1[i] - v2[i];
+    } else {
+      difference = v2[i] - v1[i];
+    }
+    squared_distance += (difference * difference);
+  }
+  return squared_distance;
+}
+
+// Global function computing the cross product of two 3D vectors.
+template <class ScalarT>
+VectorD<ScalarT, 3> CrossProduct(const VectorD<ScalarT, 3> &u,
+                                 const VectorD<ScalarT, 3> &v) {
+  // Preventing accidental use with uint32_t and the like.
+  static_assert(std::is_signed<ScalarT>::value,
+                "ScalarT must be a signed type. ");
+  VectorD<ScalarT, 3> r;
+  r[0] = (u[1] * v[2]) - (u[2] * v[1]);
+  r[1] = (u[2] * v[0]) - (u[0] * v[2]);
+  r[2] = (u[0] * v[1]) - (u[1] * v[0]);
+  return r;
+}
+
+template <class ScalarT, int dimension_t>
+inline std::ostream &operator<<(
+    std::ostream &out, const draco::VectorD<ScalarT, dimension_t> &vec) {
+  for (int i = 0; i < dimension_t - 1; ++i) {
+    out << vec[i] << " ";
+  }
+  out << vec[dimension_t - 1];
+  return out;
+}
+
+typedef VectorD<float, 2> Vector2f;
+typedef VectorD<float, 3> Vector3f;
+typedef VectorD<float, 4> Vector4f;
+typedef VectorD<float, 5> Vector5f;
+typedef VectorD<float, 6> Vector6f;
+typedef VectorD<float, 7> Vector7f;
+
+typedef VectorD<uint32_t, 2> Vector2ui;
+typedef VectorD<uint32_t, 3> Vector3ui;
+typedef VectorD<uint32_t, 4> Vector4ui;
+typedef VectorD<uint32_t, 5> Vector5ui;
+typedef VectorD<uint32_t, 6> Vector6ui;
+typedef VectorD<uint32_t, 7> Vector7ui;
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_VECTOR_D_H_
diff --git a/engine/inc/draco/draco_features.h b/engine/inc/draco/draco_features.h
new file mode 100644
index 00000000..90251e12
--- /dev/null
+++ b/engine/inc/draco/draco_features.h
@@ -0,0 +1,15 @@
+// GENERATED FILE -- DO NOT EDIT
+
+#ifndef DRACO_FEATURES_H_
+#define DRACO_FEATURES_H_
+
+#define DRACO_POINT_CLOUD_COMPRESSION_SUPPORTED
+#define DRACO_MESH_COMPRESSION_SUPPORTED
+#define DRACO_NORMAL_ENCODING_SUPPORTED
+#define DRACO_STANDARD_EDGEBREAKER_SUPPORTED
+#define DRACO_PREDICTIVE_EDGEBREAKER_SUPPORTED
+#define DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+#define DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED
+#define DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED
+
+#endif  // DRACO_FEATURES_H_
diff --git a/engine/inc/draco/io/file_reader_factory.h b/engine/inc/draco/io/file_reader_factory.h
new file mode 100644
index 00000000..12bd7a5a
--- /dev/null
+++ b/engine/inc/draco/io/file_reader_factory.h
@@ -0,0 +1,34 @@
+#ifndef DRACO_IO_FILE_READER_FACTORY_H_
+#define DRACO_IO_FILE_READER_FACTORY_H_
+
+#include <memory>
+#include <string>
+
+#include "draco/io/file_reader_interface.h"
+
+namespace draco {
+
+class FileReaderFactory {
+ public:
+  using OpenFunction =
+      std::unique_ptr<FileReaderInterface> (*)(const std::string &file_name);
+
+  FileReaderFactory() = delete;
+  FileReaderFactory(const FileReaderFactory &) = delete;
+  FileReaderFactory &operator=(const FileReaderFactory &) = delete;
+  ~FileReaderFactory() = default;
+
+  // Registers the OpenFunction for a FileReaderInterface and returns true when
+  // registration succeeds.
+  static bool RegisterReader(OpenFunction open_function);
+
+  // Passes |file_name| to each OpenFunction until one succeeds. Returns nullptr
+  // when no reader is found for |file_name|. Otherwise a FileReaderInterface is
+  // returned.
+  static std::unique_ptr<FileReaderInterface> OpenReader(
+      const std::string &file_name);
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_FILE_READER_FACTORY_H_
diff --git a/engine/inc/draco/io/file_reader_interface.h b/engine/inc/draco/io/file_reader_interface.h
new file mode 100644
index 00000000..a6e6a0da
--- /dev/null
+++ b/engine/inc/draco/io/file_reader_interface.h
@@ -0,0 +1,32 @@
+#ifndef DRACO_IO_FILE_READER_INTERFACE_H_
+#define DRACO_IO_FILE_READER_INTERFACE_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+namespace draco {
+
+class FileReaderInterface {
+ public:
+  FileReaderInterface() = default;
+  FileReaderInterface(const FileReaderInterface &) = delete;
+  FileReaderInterface &operator=(const FileReaderInterface &) = delete;
+
+  FileReaderInterface(FileReaderInterface &&) = default;
+  FileReaderInterface &operator=(FileReaderInterface &&) = default;
+
+  // Closes the file.
+  virtual ~FileReaderInterface() = default;
+
+  // Reads the entire contents of the input file into |buffer| and returns true.
+  virtual bool ReadFileToBuffer(std::vector<char> *buffer) = 0;
+  virtual bool ReadFileToBuffer(std::vector<uint8_t> *buffer) = 0;
+
+  // Returns the size of the file.
+  virtual size_t GetFileSize() = 0;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_FILE_READER_INTERFACE_H_
diff --git a/engine/inc/draco/io/file_reader_test_common.h b/engine/inc/draco/io/file_reader_test_common.h
new file mode 100644
index 00000000..0d07d4a5
--- /dev/null
+++ b/engine/inc/draco/io/file_reader_test_common.h
@@ -0,0 +1,13 @@
+#ifndef DRACO_IO_FILE_READER_TEST_COMMON_H_
+#define DRACO_IO_FILE_READER_TEST_COMMON_H_
+
+#include <cstddef>
+
+namespace draco {
+
+const size_t kFileSizeCarDrc = 69892;
+const size_t kFileSizeCubePcDrc = 224;
+
+}  // namespace draco
+
+#endif  // DRACO_IO_FILE_READER_TEST_COMMON_H_
diff --git a/engine/inc/draco/io/file_utils.h b/engine/inc/draco/io/file_utils.h
new file mode 100644
index 00000000..4b734e04
--- /dev/null
+++ b/engine/inc/draco/io/file_utils.h
@@ -0,0 +1,73 @@
+// Copyright 2018 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_FILE_UTILS_H_
+#define DRACO_IO_FILE_UTILS_H_
+
+#include <string>
+#include <vector>
+
+namespace draco {
+
+// Splits full path to a file into a folder path + file name.
+// |out_folder_path| will contain the path to the folder containing the file
+// excluding the final slash. If no folder is specified in the |full_path|, then
+// |out_folder_path| is set to "."
+void SplitPath(const std::string &full_path, std::string *out_folder_path,
+               std::string *out_file_name);
+
+// Replaces file extension in |in_file_name| with |new_extension|.
+// If |in_file_name| does not have any extension, the extension is appended.
+std::string ReplaceFileExtension(const std::string &in_file_name,
+                                 const std::string &new_extension);
+
+// Returns the file extension in lowercase if present, else "". Extension is
+// defined as the string after the last '.' character. If the file starts with
+// '.' (e.g. Linux hidden files), the first delimiter is ignored.
+std::string LowercaseFileExtension(const std::string &filename);
+
+// Given a path of the input file |input_file_relative_path| relative to the
+// parent directory of |sibling_file_full_path|, this function returns full path
+// to the input file. If |sibling_file_full_path| has no directory, the relative
+// path itself |input_file_relative_path| is returned. A common use case is for
+// the |input_file_relative_path| to be just a file name. See usage examples in
+// the unit test.
+std::string GetFullPath(const std::string &input_file_relative_path,
+                        const std::string &sibling_file_full_path);
+
+// Convenience method. Uses draco::FileReaderFactory internally. Reads contents
+// of file referenced by |file_name| into |buffer| and returns true upon
+// success.
+bool ReadFileToBuffer(const std::string &file_name, std::vector<char> *buffer);
+bool ReadFileToBuffer(const std::string &file_name,
+                      std::vector<uint8_t> *buffer);
+
+// Convenience method. Uses draco::FileWriterFactory internally. Writes contents
+// of |buffer| to file referred to by |file_name|. File is overwritten if it
+// exists. Returns true after successful write.
+bool WriteBufferToFile(const char *buffer, size_t buffer_size,
+                       const std::string &file_name);
+bool WriteBufferToFile(const unsigned char *buffer, size_t buffer_size,
+                       const std::string &file_name);
+bool WriteBufferToFile(const void *buffer, size_t buffer_size,
+                       const std::string &file_name);
+
+// Convenience method. Uses draco::FileReaderFactory internally. Returns size of
+// file referenced by |file_name|. Returns 0 when referenced file is empty or
+// does not exist.
+size_t GetFileSize(const std::string &file_name);
+
+}  // namespace draco
+
+#endif  // DRACO_IO_FILE_UTILS_H_
diff --git a/engine/inc/draco/io/file_writer_factory.h b/engine/inc/draco/io/file_writer_factory.h
new file mode 100644
index 00000000..ecf735d8
--- /dev/null
+++ b/engine/inc/draco/io/file_writer_factory.h
@@ -0,0 +1,34 @@
+#ifndef DRACO_IO_FILE_WRITER_FACTORY_H_
+#define DRACO_IO_FILE_WRITER_FACTORY_H_
+
+#include <memory>
+#include <string>
+
+#include "draco/io/file_writer_interface.h"
+
+namespace draco {
+
+class FileWriterFactory {
+ public:
+  using OpenFunction =
+      std::unique_ptr<FileWriterInterface> (*)(const std::string &file_name);
+
+  FileWriterFactory() = delete;
+  FileWriterFactory(const FileWriterFactory &) = delete;
+  FileWriterFactory &operator=(const FileWriterFactory &) = delete;
+  ~FileWriterFactory() = default;
+
+  // Registers the OpenFunction for a FileWriterInterface and returns true when
+  // registration succeeds.
+  static bool RegisterWriter(OpenFunction open_function);
+
+  // Passes |file_name| to each OpenFunction until one succeeds. Returns nullptr
+  // when no writer is found for |file_name|. Otherwise a FileWriterInterface is
+  // returned.
+  static std::unique_ptr<FileWriterInterface> OpenWriter(
+      const std::string &file_name);
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_FILE_WRITER_FACTORY_H_
diff --git a/engine/inc/draco/io/file_writer_interface.h b/engine/inc/draco/io/file_writer_interface.h
new file mode 100644
index 00000000..719f7cc8
--- /dev/null
+++ b/engine/inc/draco/io/file_writer_interface.h
@@ -0,0 +1,26 @@
+#ifndef DRACO_IO_FILE_WRITER_INTERFACE_H_
+#define DRACO_IO_FILE_WRITER_INTERFACE_H_
+
+#include <cstddef>
+
+namespace draco {
+
+class FileWriterInterface {
+ public:
+  FileWriterInterface() = default;
+  FileWriterInterface(const FileWriterInterface &) = delete;
+  FileWriterInterface &operator=(const FileWriterInterface &) = delete;
+
+  FileWriterInterface(FileWriterInterface &&) = default;
+  FileWriterInterface &operator=(FileWriterInterface &&) = default;
+
+  // Closes the file.
+  virtual ~FileWriterInterface() = default;
+
+  // Writes |size| bytes from |buffer| to file.
+  virtual bool Write(const char *buffer, size_t size) = 0;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_FILE_WRITER_INTERFACE_H_
diff --git a/engine/inc/draco/io/file_writer_utils.h b/engine/inc/draco/io/file_writer_utils.h
new file mode 100644
index 00000000..e5ba2836
--- /dev/null
+++ b/engine/inc/draco/io/file_writer_utils.h
@@ -0,0 +1,38 @@
+// Copyright 2020 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_FILE_WRITER_UTILS_H_
+#define DRACO_IO_FILE_WRITER_UTILS_H_
+
+#include <string>
+
+namespace draco {
+
+// Splits full path to a file into a folder path + file name.
+// |out_folder_path| will contain the path to the folder containing the file
+// excluding the final slash. If no folder is specified in the |full_path|, then
+// |out_folder_path| is set to "."
+void SplitPathPrivate(const std::string &full_path,
+                      std::string *out_folder_path, std::string *out_file_name);
+
+// Checks is |path| exists and if it is a directory.
+bool DirectoryExists(const std::string &path);
+
+// Checks if the path for file is valid. If not this function will try and
+// create the path. Returns false on error.
+bool CheckAndCreatePathForFile(const std::string &filename);
+
+}  // namespace draco
+
+#endif  // DRACO_IO_FILE_WRITER_UTILS_H_
diff --git a/engine/inc/draco/io/mesh_io.h b/engine/inc/draco/io/mesh_io.h
new file mode 100644
index 00000000..9af178c7
--- /dev/null
+++ b/engine/inc/draco/io/mesh_io.h
@@ -0,0 +1,107 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_MESH_IO_H_
+#define DRACO_IO_MESH_IO_H_
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/decode.h"
+#include "draco/compression/expert_encode.h"
+#include "draco/core/options.h"
+
+namespace draco {
+
+template <typename OutStreamT>
+OutStreamT WriteMeshIntoStream(const Mesh *mesh, OutStreamT &&os,
+                               MeshEncoderMethod method,
+                               const EncoderOptions &options) {
+  EncoderBuffer buffer;
+  EncoderOptions local_options = options;
+  ExpertEncoder encoder(*mesh);
+  encoder.Reset(local_options);
+  encoder.SetEncodingMethod(method);
+  if (!encoder.EncodeToBuffer(&buffer).ok()) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+
+  os.write(static_cast<const char *>(buffer.data()), buffer.size());
+
+  return os;
+}
+
+template <typename OutStreamT>
+OutStreamT WriteMeshIntoStream(const Mesh *mesh, OutStreamT &&os,
+                               MeshEncoderMethod method) {
+  const EncoderOptions options = EncoderOptions::CreateDefaultOptions();
+  return WriteMeshIntoStream(mesh, os, method, options);
+}
+
+template <typename OutStreamT>
+OutStreamT &WriteMeshIntoStream(const Mesh *mesh, OutStreamT &&os) {
+  return WriteMeshIntoStream(mesh, os, MESH_EDGEBREAKER_ENCODING);
+}
+
+template <typename InStreamT>
+InStreamT &ReadMeshFromStream(std::unique_ptr<Mesh> *mesh, InStreamT &&is) {
+  // Determine size of stream and write into a vector
+  const auto start_pos = is.tellg();
+  is.seekg(0, std::ios::end);
+  const std::streampos is_size = is.tellg() - start_pos;
+  is.seekg(start_pos);
+  std::vector<char> data(is_size);
+  is.read(&data[0], is_size);
+
+  // Create a mesh from that data.
+  DecoderBuffer buffer;
+  buffer.Init(&data[0], data.size());
+  Decoder decoder;
+  auto statusor = decoder.DecodeMeshFromBuffer(&buffer);
+  *mesh = std::move(statusor).value();
+  if (!statusor.ok() || *mesh == nullptr) {
+    is.setstate(std::ios_base::badbit);
+  }
+
+  return is;
+}
+
+// Reads a mesh from a file. The function automatically chooses the correct
+// decoder based on the extension of the files. Currently, .obj and .ply files
+// are supported. Other file extensions are processed by the default
+// draco::MeshDecoder.
+// Returns nullptr with an error status if the decoding failed.
+StatusOr<std::unique_ptr<Mesh>> ReadMeshFromFile(const std::string &file_name);
+
+// Reads a mesh from a file. The function does the same thing as the previous
+// one except using metadata to encode additional information when
+// |use_metadata| is set to true.
+// Returns nullptr with an error status if the decoding failed.
+StatusOr<std::unique_ptr<Mesh>> ReadMeshFromFile(const std::string &file_name,
+                                                 bool use_metadata);
+
+// Reads a mesh from a file. Reading is configured with |options|:
+// use_metadata  : Read obj file info like material names and object names into
+// metadata. Default is false.
+// The second form returns the files associated with the mesh via the
+// |mesh_files| argument.
+// Returns nullptr with an error status if the decoding failed.
+StatusOr<std::unique_ptr<Mesh>> ReadMeshFromFile(const std::string &file_name,
+                                                 const Options &options);
+StatusOr<std::unique_ptr<Mesh>> ReadMeshFromFile(
+    const std::string &file_name, const Options &options,
+    std::vector<std::string> *mesh_files);
+
+}  // namespace draco
+
+#endif  // DRACO_IO_MESH_IO_H_
diff --git a/engine/inc/draco/io/obj_decoder.h b/engine/inc/draco/io/obj_decoder.h
new file mode 100644
index 00000000..baeab5b0
--- /dev/null
+++ b/engine/inc/draco/io/obj_decoder.h
@@ -0,0 +1,129 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_OBJ_DECODER_H_
+#define DRACO_IO_OBJ_DECODER_H_
+
+#include <string>
+#include <unordered_map>
+
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/status.h"
+#include "draco/draco_features.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Decodes a Wavefront OBJ file into draco::Mesh (or draco::PointCloud if the
+// connectivity data is not needed).. This decoder can handle decoding of
+// positions, texture coordinates, normals and triangular faces.
+// All other geometry properties are ignored.
+class ObjDecoder {
+ public:
+  ObjDecoder();
+
+  // Decodes an obj file stored in the input file.
+  // Returns nullptr if the decoding failed.
+  Status DecodeFromFile(const std::string &file_name, Mesh *out_mesh);
+  Status DecodeFromFile(const std::string &file_name,
+                        PointCloud *out_point_cloud);
+
+  Status DecodeFromBuffer(DecoderBuffer *buffer, Mesh *out_mesh);
+  Status DecodeFromBuffer(DecoderBuffer *buffer, PointCloud *out_point_cloud);
+
+  // Flag that can be used to turn on/off deduplication of input values.
+  // This should be disabled only when we are sure that the input data does not
+  // contain any duplicate entries.
+  // Default: true
+  void set_deduplicate_input_values(bool v) { deduplicate_input_values_ = v; }
+  // Flag for whether using metadata to record other information in the obj
+  // file, e.g. material names, object names.
+  void set_use_metadata(bool flag) { use_metadata_ = flag; }
+
+ protected:
+  Status DecodeInternal();
+  DecoderBuffer *buffer() { return &buffer_; }
+
+ private:
+  // Resets internal counters for attributes and faces.
+  void ResetCounters();
+
+  // Parses the next mesh property definition (position, tex coord, normal, or
+  // face). If the parsed data is unrecognized, it will be skipped.
+  // Returns false when the end of file was reached.
+  bool ParseDefinition(Status *status);
+
+  // Attempts to parse definition of position, normal, tex coord, or face
+  // respectively.
+  // Returns false when the parsed data didn't contain the given definition.
+  bool ParseVertexPosition(Status *status);
+  bool ParseNormal(Status *status);
+  bool ParseTexCoord(Status *status);
+  bool ParseFace(Status *status);
+  bool ParseMaterialLib(Status *status);
+  bool ParseMaterial(Status *status);
+  bool ParseObject(Status *status);
+
+  // Parses triplet of position, tex coords and normal indices.
+  // Returns false on error.
+  bool ParseVertexIndices(std::array<int32_t, 3> *out_indices);
+
+  // Maps specified point index to the parsed vertex indices (triplet of
+  // position, texture coordinate, and normal indices) .
+  void MapPointToVertexIndices(PointIndex vert_id,
+                               const std::array<int32_t, 3> &indices);
+
+  // Parses material file definitions from a separate file.
+  bool ParseMaterialFile(const std::string &file_name, Status *status);
+  bool ParseMaterialFileDefinition(Status *status);
+
+  // If set to true, the parser will count the number of various definitions
+  // but it will not parse the actual data or add any new entries to the mesh.
+  bool counting_mode_;
+  int num_obj_faces_;
+  int num_positions_;
+  int num_tex_coords_;
+  int num_normals_;
+  int num_materials_;
+  int last_sub_obj_id_;
+
+  int pos_att_id_;
+  int tex_att_id_;
+  int norm_att_id_;
+  int material_att_id_;
+  int sub_obj_att_id_;  // Attribute id for storing sub-objects.
+
+  bool deduplicate_input_values_;
+
+  int last_material_id_;
+  std::string material_file_name_;
+
+  std::string input_file_name_;
+
+  std::unordered_map<std::string, int> material_name_to_id_;
+  std::unordered_map<std::string, int> obj_name_to_id_;
+
+  bool use_metadata_;
+
+  DecoderBuffer buffer_;
+
+  // Data structure that stores the decoded data. |out_point_cloud_| must be
+  // always set but |out_mesh_| is optional.
+  Mesh *out_mesh_;
+  PointCloud *out_point_cloud_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_OBJ_DECODER_H_
diff --git a/engine/inc/draco/io/obj_encoder.h b/engine/inc/draco/io/obj_encoder.h
new file mode 100644
index 00000000..509d39ba
--- /dev/null
+++ b/engine/inc/draco/io/obj_encoder.h
@@ -0,0 +1,92 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_OBJ_ENCODER_H_
+#define DRACO_IO_OBJ_ENCODER_H_
+
+#include <unordered_map>
+
+#include "draco/core/encoder_buffer.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Class for encoding input draco::Mesh or draco::PointCloud into the Wavefront
+// OBJ format.
+class ObjEncoder {
+ public:
+  ObjEncoder();
+
+  // Encodes the mesh or a point cloud  and saves it into a file.
+  // Returns false when either the encoding failed or when the file couldn't be
+  // opened.
+  bool EncodeToFile(const PointCloud &pc, const std::string &file_name);
+  bool EncodeToFile(const Mesh &mesh, const std::string &file_name);
+
+  // Encodes the mesh or the point cloud into a buffer.
+  bool EncodeToBuffer(const PointCloud &pc, EncoderBuffer *out_buffer);
+  bool EncodeToBuffer(const Mesh &mesh, EncoderBuffer *out_buffer);
+
+ protected:
+  bool EncodeInternal();
+  EncoderBuffer *buffer() const { return out_buffer_; }
+  bool ExitAndCleanup(bool return_value);
+
+ private:
+  bool GetSubObjects();
+  bool EncodeMaterialFileName();
+  bool EncodePositions();
+  bool EncodeTextureCoordinates();
+  bool EncodeNormals();
+  bool EncodeFaces();
+  bool EncodeSubObject(FaceIndex face_id);
+  bool EncodeMaterial(FaceIndex face_id);
+  bool EncodeFaceCorner(FaceIndex face_id, int local_corner_id);
+
+  void EncodeFloat(float val);
+  void EncodeFloatList(float *vals, int num_vals);
+  void EncodeInt(int32_t val);
+
+  // Various attributes used by the encoder. If an attribute is not used, it is
+  // set to nullptr.
+  const PointAttribute *pos_att_;
+  const PointAttribute *tex_coord_att_;
+  const PointAttribute *normal_att_;
+  const PointAttribute *material_att_;
+  const PointAttribute *sub_obj_att_;
+
+  // Buffer used for encoding float/int numbers.
+  char num_buffer_[20];
+
+  EncoderBuffer *out_buffer_;
+
+  const PointCloud *in_point_cloud_;
+  const Mesh *in_mesh_;
+
+  // Store sub object name for each value.
+  std::unordered_map<int, std::string> sub_obj_id_to_name_;
+  // Current sub object id of faces.
+  int current_sub_obj_id_;
+
+  // Store material name for each value in material attribute.
+  std::unordered_map<int, std::string> material_id_to_name_;
+  // Current material id of faces.
+  int current_material_id_;
+
+  std::string file_name_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_OBJ_ENCODER_H_
diff --git a/engine/inc/draco/io/parser_utils.h b/engine/inc/draco/io/parser_utils.h
new file mode 100644
index 00000000..b83cd936
--- /dev/null
+++ b/engine/inc/draco/io/parser_utils.h
@@ -0,0 +1,66 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_PARSER_UTILS_H_
+#define DRACO_IO_PARSER_UTILS_H_
+
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+namespace parser {
+
+// Skips to first character not included in |skip_chars|.
+void SkipCharacters(DecoderBuffer *buffer, const char *skip_chars);
+
+// Skips any whitespace until a regular character is reached.
+void SkipWhitespace(DecoderBuffer *buffer);
+
+// Returns true if the next character is a whitespace.
+// |end_reached| is set to true when the end of the stream is reached.
+bool PeekWhitespace(DecoderBuffer *buffer, bool *end_reached);
+
+// Skips all characters until the end of the line.
+void SkipLine(DecoderBuffer *buffer);
+
+// Parses signed floating point number or returns false on error.
+bool ParseFloat(DecoderBuffer *buffer, float *value);
+
+// Parses a signed integer (can be preceded by '-' or '+' characters.
+bool ParseSignedInt(DecoderBuffer *buffer, int32_t *value);
+
+// Parses an unsigned integer. It cannot be preceded by '-' or '+'
+// characters.
+bool ParseUnsignedInt(DecoderBuffer *buffer, uint32_t *value);
+
+// Returns -1 if c == '-'.
+// Returns +1 if c == '+'.
+// Returns 0 otherwise.
+int GetSignValue(char c);
+
+// Parses a string until a whitespace or end of file is reached.
+bool ParseString(DecoderBuffer *buffer, std::string *out_string);
+
+// Parses the entire line into the buffer (excluding the new line characters).
+void ParseLine(DecoderBuffer *buffer, std::string *out_string);
+
+// Parses line and stores into a new decoder buffer.
+DecoderBuffer ParseLineIntoDecoderBuffer(DecoderBuffer *buffer);
+
+// Returns a string with all characters converted to lower case.
+std::string ToLower(const std::string &str);
+
+}  // namespace parser
+}  // namespace draco
+
+#endif  // DRACO_IO_PARSER_UTILS_H_
diff --git a/engine/inc/draco/io/ply_decoder.h b/engine/inc/draco/io/ply_decoder.h
new file mode 100644
index 00000000..db1e480c
--- /dev/null
+++ b/engine/inc/draco/io/ply_decoder.h
@@ -0,0 +1,69 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_PLY_DECODER_H_
+#define DRACO_IO_PLY_DECODER_H_
+
+#include <string>
+
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/status.h"
+#include "draco/draco_features.h"
+#include "draco/io/ply_reader.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Decodes a PLY file into draco::Mesh (or draco::PointCloud if the
+// connectivity data is not needed).
+// TODO(b/34330853): The current implementation assumes that the input vertices
+// are defined with x, y, z properties. The decoder also reads uint8 red, green,
+// blue, alpha color information, float32 defined as nx, ny, nz properties, but
+// all other attributes are ignored for now.
+class PlyDecoder {
+ public:
+  PlyDecoder();
+
+  // Decodes an obj file stored in the input file.
+  Status DecodeFromFile(const std::string &file_name, Mesh *out_mesh);
+  Status DecodeFromFile(const std::string &file_name,
+                        PointCloud *out_point_cloud);
+
+  Status DecodeFromBuffer(DecoderBuffer *buffer, Mesh *out_mesh);
+  Status DecodeFromBuffer(DecoderBuffer *buffer, PointCloud *out_point_cloud);
+
+ protected:
+  Status DecodeInternal();
+  DecoderBuffer *buffer() { return &buffer_; }
+
+ private:
+  Status DecodeFaceData(const PlyElement *face_element);
+  Status DecodeVertexData(const PlyElement *vertex_element);
+
+  template <typename DataTypeT>
+  bool ReadPropertiesToAttribute(
+      const std::vector<const PlyProperty *> &properties,
+      PointAttribute *attribute, int num_vertices);
+
+  DecoderBuffer buffer_;
+
+  // Data structure that stores the decoded data. |out_point_cloud_| must be
+  // always set but |out_mesh_| is optional.
+  Mesh *out_mesh_;
+  PointCloud *out_point_cloud_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_PLY_DECODER_H_
diff --git a/engine/inc/draco/io/ply_encoder.h b/engine/inc/draco/io/ply_encoder.h
new file mode 100644
index 00000000..242bbd6d
--- /dev/null
+++ b/engine/inc/draco/io/ply_encoder.h
@@ -0,0 +1,54 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_PLY_ENCODER_H_
+#define DRACO_IO_PLY_ENCODER_H_
+
+#include "draco/core/encoder_buffer.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Class for encoding draco::Mesh or draco::PointCloud into the PLY file format.
+class PlyEncoder {
+ public:
+  PlyEncoder();
+
+  // Encodes the mesh or a point cloud  and saves it into a file.
+  // Returns false when either the encoding failed or when the file couldn't be
+  // opened.
+  bool EncodeToFile(const PointCloud &pc, const std::string &file_name);
+  bool EncodeToFile(const Mesh &mesh, const std::string &file_name);
+
+  // Encodes the mesh or the point cloud into a buffer.
+  bool EncodeToBuffer(const PointCloud &pc, EncoderBuffer *out_buffer);
+  bool EncodeToBuffer(const Mesh &mesh, EncoderBuffer *out_buffer);
+
+ protected:
+  bool EncodeInternal();
+  EncoderBuffer *buffer() const { return out_buffer_; }
+  bool ExitAndCleanup(bool return_value);
+
+ private:
+  const char *GetAttributeDataType(int attribute);
+
+  EncoderBuffer *out_buffer_;
+
+  const PointCloud *in_point_cloud_;
+  const Mesh *in_mesh_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_PLY_ENCODER_H_
diff --git a/engine/inc/draco/io/ply_property_reader.h b/engine/inc/draco/io/ply_property_reader.h
new file mode 100644
index 00000000..efb8a3a1
--- /dev/null
+++ b/engine/inc/draco/io/ply_property_reader.h
@@ -0,0 +1,96 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_PLY_PROPERTY_READER_H_
+#define DRACO_IO_PLY_PROPERTY_READER_H_
+
+#include <functional>
+
+#include "draco/io/ply_reader.h"
+
+namespace draco {
+
+// Class for reading PlyProperty with a given type, performing data conversion
+// if necessary.
+template <typename ReadTypeT>
+class PlyPropertyReader {
+ public:
+  explicit PlyPropertyReader(const PlyProperty *property)
+      : property_(property) {
+    // Find the suitable function for converting values.
+    switch (property->data_type()) {
+      case DT_UINT8:
+        convert_value_func_ = [=](int val_id) {
+          return this->ConvertValue<uint8_t>(val_id);
+        };
+        break;
+      case DT_INT8:
+        convert_value_func_ = [=](int val_id) {
+          return this->ConvertValue<int8_t>(val_id);
+        };
+        break;
+      case DT_UINT16:
+        convert_value_func_ = [=](int val_id) {
+          return this->ConvertValue<uint16_t>(val_id);
+        };
+        break;
+      case DT_INT16:
+        convert_value_func_ = [=](int val_id) {
+          return this->ConvertValue<int16_t>(val_id);
+        };
+        break;
+      case DT_UINT32:
+        convert_value_func_ = [=](int val_id) {
+          return this->ConvertValue<uint32_t>(val_id);
+        };
+        break;
+      case DT_INT32:
+        convert_value_func_ = [=](int val_id) {
+          return this->ConvertValue<int32_t>(val_id);
+        };
+        break;
+      case DT_FLOAT32:
+        convert_value_func_ = [=](int val_id) {
+          return this->ConvertValue<float>(val_id);
+        };
+        break;
+      case DT_FLOAT64:
+        convert_value_func_ = [=](int val_id) {
+          return this->ConvertValue<double>(val_id);
+        };
+        break;
+      default:
+        break;
+    }
+  }
+
+  ReadTypeT ReadValue(int value_id) const {
+    return convert_value_func_(value_id);
+  }
+
+ private:
+  template <typename SourceTypeT>
+  ReadTypeT ConvertValue(int value_id) const {
+    const void *const address = property_->GetDataEntryAddress(value_id);
+    const SourceTypeT src_val = *reinterpret_cast<const SourceTypeT *>(address);
+    return static_cast<ReadTypeT>(src_val);
+  }
+
+  const PlyProperty *property_;
+  std::function<ReadTypeT(int)> convert_value_func_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_PLY_PROPERTY_READER_H_
diff --git a/engine/inc/draco/io/ply_property_writer.h b/engine/inc/draco/io/ply_property_writer.h
new file mode 100644
index 00000000..4f243b28
--- /dev/null
+++ b/engine/inc/draco/io/ply_property_writer.h
@@ -0,0 +1,94 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_PLY_PROPERTY_WRITER_H_
+#define DRACO_IO_PLY_PROPERTY_WRITER_H_
+
+#include <functional>
+
+#include "draco/io/ply_reader.h"
+
+namespace draco {
+
+// Class for writing PlyProperty with a given type, performing data conversion
+// if necessary.
+template <typename WriteTypeT>
+class PlyPropertyWriter {
+ public:
+  explicit PlyPropertyWriter(PlyProperty *property) : property_(property) {
+    // Find the suitable function for converting values.
+    switch (property->data_type()) {
+      case DT_UINT8:
+        convert_value_func_ = [=](WriteTypeT val) {
+          return this->ConvertValue<uint8_t>(val);
+        };
+        break;
+      case DT_INT8:
+        convert_value_func_ = [=](WriteTypeT val) {
+          return this->ConvertValue<int8_t>(val);
+        };
+        break;
+      case DT_UINT16:
+        convert_value_func_ = [=](WriteTypeT val) {
+          return this->ConvertValue<uint16_t>(val);
+        };
+        break;
+      case DT_INT16:
+        convert_value_func_ = [=](WriteTypeT val) {
+          return this->ConvertValue<int16_t>(val);
+        };
+        break;
+      case DT_UINT32:
+        convert_value_func_ = [=](WriteTypeT val) {
+          return this->ConvertValue<uint32_t>(val);
+        };
+        break;
+      case DT_INT32:
+        convert_value_func_ = [=](WriteTypeT val) {
+          return this->ConvertValue<int32_t>(val);
+        };
+        break;
+      case DT_FLOAT32:
+        convert_value_func_ = [=](WriteTypeT val) {
+          return this->ConvertValue<float>(val);
+        };
+        break;
+      case DT_FLOAT64:
+        convert_value_func_ = [=](WriteTypeT val) {
+          return this->ConvertValue<double>(val);
+        };
+        break;
+      default:
+        break;
+    }
+  }
+
+  void PushBackValue(WriteTypeT value) const {
+    return convert_value_func_(value);
+  }
+
+ private:
+  template <typename SourceTypeT>
+  void ConvertValue(WriteTypeT value) const {
+    const SourceTypeT src_val = static_cast<SourceTypeT>(value);
+    property_->push_back_value(&src_val);
+  }
+
+  PlyProperty *property_;
+  std::function<void(WriteTypeT)> convert_value_func_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_PLY_PROPERTY_WRITER_H_
diff --git a/engine/inc/draco/io/ply_reader.h b/engine/inc/draco/io/ply_reader.h
new file mode 100644
index 00000000..e0f15a31
--- /dev/null
+++ b/engine/inc/draco/io/ply_reader.h
@@ -0,0 +1,155 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File contains helper classes used for parsing of PLY files. The classes are
+// used by the PlyDecoder (ply_decoder.h) to read a point cloud or mesh from a
+// source PLY file.
+// TODO(ostava): Currently, we support only binary PLYs encoded in the little
+// endian format ("format binary_little_endian 1.0").
+
+#ifndef DRACO_IO_PLY_READER_H_
+#define DRACO_IO_PLY_READER_H_
+
+#include <map>
+#include <vector>
+
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/draco_types.h"
+#include "draco/core/status.h"
+#include "draco/core/status_or.h"
+
+namespace draco {
+
+// A single PLY property of a given PLY element. For "vertex" element this can
+// contain data such as "x", "y", or "z" coordinate of the vertex, while for
+// "face" element this usually contains corner indices.
+class PlyProperty {
+ public:
+  friend class PlyReader;
+
+  PlyProperty(const std::string &name, DataType data_type, DataType list_type);
+  void ReserveData(int num_entries) {
+    data_.reserve(DataTypeLength(data_type_) * num_entries);
+  }
+
+  int64_t GetListEntryOffset(int entry_id) const {
+    return list_data_[entry_id * 2];
+  }
+  int64_t GetListEntryNumValues(int entry_id) const {
+    return list_data_[entry_id * 2 + 1];
+  }
+  const void *GetDataEntryAddress(int entry_id) const {
+    return data_.data() + entry_id * data_type_num_bytes_;
+  }
+  void push_back_value(const void *data) {
+    data_.insert(data_.end(), static_cast<const uint8_t *>(data),
+                 static_cast<const uint8_t *>(data) + data_type_num_bytes_);
+  }
+
+  const std::string &name() const { return name_; }
+  bool is_list() const { return list_data_type_ != DT_INVALID; }
+  DataType data_type() const { return data_type_; }
+  int data_type_num_bytes() const { return data_type_num_bytes_; }
+  DataType list_data_type() const { return list_data_type_; }
+  int list_data_type_num_bytes() const { return list_data_type_num_bytes_; }
+
+ private:
+  std::string name_;
+  std::vector<uint8_t> data_;
+  // List data contain pairs of <offset, number_of_values>
+  std::vector<int64_t> list_data_;
+  DataType data_type_;
+  int data_type_num_bytes_;
+  DataType list_data_type_;
+  int list_data_type_num_bytes_;
+};
+
+// A single PLY element such as "vertex" or "face". Each element can store
+// arbitrary properties such as vertex coordinates or face indices.
+class PlyElement {
+ public:
+  PlyElement(const std::string &name, int64_t num_entries);
+  void AddProperty(const PlyProperty &prop) {
+    property_index_[prop.name()] = static_cast<int>(properties_.size());
+    properties_.emplace_back(prop);
+    if (!properties_.back().is_list()) {
+      properties_.back().ReserveData(static_cast<int>(num_entries_));
+    }
+  }
+
+  const PlyProperty *GetPropertyByName(const std::string &name) const {
+    const auto it = property_index_.find(name);
+    if (it != property_index_.end()) {
+      return &properties_[it->second];
+    }
+    return nullptr;
+  }
+
+  int num_properties() const { return static_cast<int>(properties_.size()); }
+  int num_entries() const { return static_cast<int>(num_entries_); }
+  const PlyProperty &property(int prop_index) const {
+    return properties_[prop_index];
+  }
+  PlyProperty &property(int prop_index) { return properties_[prop_index]; }
+
+ private:
+  std::string name_;
+  int64_t num_entries_;
+  std::vector<PlyProperty> properties_;
+  std::map<std::string, int> property_index_;
+};
+
+// Class responsible for parsing PLY data. It produces a list of PLY elements
+// and their properties that can be used to construct a mesh or a point cloud.
+class PlyReader {
+ public:
+  PlyReader();
+  Status Read(DecoderBuffer *buffer);
+
+  const PlyElement *GetElementByName(const std::string &name) const {
+    const auto it = element_index_.find(name);
+    if (it != element_index_.end()) {
+      return &elements_[it->second];
+    }
+    return nullptr;
+  }
+
+  int num_elements() const { return static_cast<int>(elements_.size()); }
+  const PlyElement &element(int element_index) const {
+    return elements_[element_index];
+  }
+
+ private:
+  enum Format { kLittleEndian = 0, kAscii };
+
+  Status ParseHeader(DecoderBuffer *buffer);
+  StatusOr<bool> ParseEndHeader(DecoderBuffer *buffer);
+  bool ParseElement(DecoderBuffer *buffer);
+  StatusOr<bool> ParseProperty(DecoderBuffer *buffer);
+  bool ParsePropertiesData(DecoderBuffer *buffer);
+  bool ParseElementData(DecoderBuffer *buffer, int element_index);
+  bool ParseElementDataAscii(DecoderBuffer *buffer, int element_index);
+
+  // Splits |line| by whitespace characters.
+  std::vector<std::string> SplitWords(const std::string &line);
+  DataType GetDataTypeFromString(const std::string &name) const;
+
+  std::vector<PlyElement> elements_;
+  std::map<std::string, int> element_index_;
+  Format format_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_PLY_READER_H_
diff --git a/engine/inc/draco/io/point_cloud_io.h b/engine/inc/draco/io/point_cloud_io.h
new file mode 100644
index 00000000..4e1eb359
--- /dev/null
+++ b/engine/inc/draco/io/point_cloud_io.h
@@ -0,0 +1,89 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_POINT_CLOUD_IO_H_
+#define DRACO_IO_POINT_CLOUD_IO_H_
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/decode.h"
+#include "draco/compression/expert_encode.h"
+
+namespace draco {
+
+template <typename OutStreamT>
+OutStreamT WritePointCloudIntoStream(const PointCloud *pc, OutStreamT &&os,
+                                     PointCloudEncodingMethod method,
+                                     const EncoderOptions &options) {
+  EncoderBuffer buffer;
+  EncoderOptions local_options = options;
+  ExpertEncoder encoder(*pc);
+  encoder.Reset(local_options);
+  encoder.SetEncodingMethod(method);
+  if (!encoder.EncodeToBuffer(&buffer).ok()) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+
+  os.write(static_cast<const char *>(buffer.data()), buffer.size());
+
+  return os;
+}
+
+template <typename OutStreamT>
+OutStreamT WritePointCloudIntoStream(const PointCloud *pc, OutStreamT &&os,
+                                     PointCloudEncodingMethod method) {
+  const EncoderOptions options = EncoderOptions::CreateDefaultOptions();
+  return WritePointCloudIntoStream(pc, os, method, options);
+}
+
+template <typename OutStreamT>
+OutStreamT &WritePointCloudIntoStream(const PointCloud *pc, OutStreamT &&os) {
+  return WritePointCloudIntoStream(pc, os, POINT_CLOUD_SEQUENTIAL_ENCODING);
+}
+
+template <typename InStreamT>
+InStreamT &ReadPointCloudFromStream(std::unique_ptr<PointCloud> *point_cloud,
+                                    InStreamT &&is) {
+  // Determine size of stream and write into a vector
+  const auto start_pos = is.tellg();
+  is.seekg(0, std::ios::end);
+  const std::streampos is_size = is.tellg() - start_pos;
+  is.seekg(start_pos);
+  std::vector<char> data(is_size);
+  is.read(&data[0], is_size);
+
+  // Create a point cloud from that data.
+  DecoderBuffer buffer;
+  buffer.Init(&data[0], data.size());
+  Decoder decoder;
+  auto statusor = decoder.DecodePointCloudFromBuffer(&buffer);
+  *point_cloud = std::move(statusor).value();
+  if (!statusor.ok() || *point_cloud == nullptr) {
+    is.setstate(std::ios_base::badbit);
+  }
+
+  return is;
+}
+
+// Reads a point cloud from a file. The function automatically chooses the
+// correct decoder based on the extension of the files. Currently, .obj and .ply
+// files are supported. Other file extensions are processed by the default
+// draco::PointCloudDecoder.
+// Returns nullptr with an error status if the decoding failed.
+StatusOr<std::unique_ptr<PointCloud>> ReadPointCloudFromFile(
+    const std::string &file_name);
+
+}  // namespace draco
+
+#endif  // DRACO_IO_POINT_CLOUD_IO_H_
diff --git a/engine/inc/draco/io/stdio_file_reader.h b/engine/inc/draco/io/stdio_file_reader.h
new file mode 100644
index 00000000..f822c891
--- /dev/null
+++ b/engine/inc/draco/io/stdio_file_reader.h
@@ -0,0 +1,48 @@
+#ifndef DRACO_IO_STDIO_FILE_READER_H_
+#define DRACO_IO_STDIO_FILE_READER_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "draco/io/file_reader_interface.h"
+
+namespace draco {
+
+class StdioFileReader : public FileReaderInterface {
+ public:
+  // Creates and returns a StdioFileReader that reads from |file_name|.
+  // Returns nullptr when the file does not exist or cannot be read.
+  static std::unique_ptr<FileReaderInterface> Open(
+      const std::string &file_name);
+
+  StdioFileReader() = delete;
+  StdioFileReader(const StdioFileReader &) = delete;
+  StdioFileReader &operator=(const StdioFileReader &) = delete;
+
+  StdioFileReader(StdioFileReader &&) = default;
+  StdioFileReader &operator=(StdioFileReader &&) = default;
+
+  // Closes |file_|.
+  ~StdioFileReader() override;
+
+  // Reads the entire contents of the input file into |buffer| and returns true.
+  bool ReadFileToBuffer(std::vector<char> *buffer) override;
+  bool ReadFileToBuffer(std::vector<uint8_t> *buffer) override;
+
+  // Returns the size of the file.
+  size_t GetFileSize() override;
+
+ private:
+  StdioFileReader(FILE *file) : file_(file) {}
+
+  FILE *file_ = nullptr;
+  static bool registered_in_factory_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_STDIO_FILE_READER_H_
diff --git a/engine/inc/draco/io/stdio_file_writer.h b/engine/inc/draco/io/stdio_file_writer.h
new file mode 100644
index 00000000..4e392556
--- /dev/null
+++ b/engine/inc/draco/io/stdio_file_writer.h
@@ -0,0 +1,42 @@
+#ifndef DRACO_IO_STDIO_FILE_WRITER_H_
+#define DRACO_IO_STDIO_FILE_WRITER_H_
+
+#include <cstddef>
+#include <cstdio>
+#include <memory>
+#include <string>
+
+#include "draco/io/file_writer_interface.h"
+
+namespace draco {
+
+class StdioFileWriter : public FileWriterInterface {
+ public:
+  // Creates and returns a StdioFileWriter that writes to |file_name|.
+  // Returns nullptr when |file_name| cannot be opened for writing.
+  static std::unique_ptr<FileWriterInterface> Open(
+      const std::string &file_name);
+
+  StdioFileWriter() = delete;
+  StdioFileWriter(const StdioFileWriter &) = delete;
+  StdioFileWriter &operator=(const StdioFileWriter &) = delete;
+
+  StdioFileWriter(StdioFileWriter &&) = default;
+  StdioFileWriter &operator=(StdioFileWriter &&) = default;
+
+  // Closes |file_|.
+  ~StdioFileWriter() override;
+
+  // Writes |size| bytes to |file_| from |buffer|. Returns true for success.
+  bool Write(const char *buffer, size_t size) override;
+
+ private:
+  StdioFileWriter(FILE *file) : file_(file) {}
+
+  FILE *file_ = nullptr;
+  static bool registered_in_factory_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_STDIO_FILE_WRITER_H_
diff --git a/engine/inc/draco/maya/draco_maya_plugin.h b/engine/inc/draco/maya/draco_maya_plugin.h
new file mode 100644
index 00000000..372e25fb
--- /dev/null
+++ b/engine/inc/draco/maya/draco_maya_plugin.h
@@ -0,0 +1,81 @@
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_MAYA_DRACO_MAYA_PLUGIN_H_
+#define DRACO_MAYA_DRACO_MAYA_PLUGIN_H_
+
+#include <fstream>
+
+#include "draco/compression/decode.h"
+#include "draco/compression/encode.h"
+
+#ifdef DRACO_MAYA_PLUGIN
+
+// If compiling with Visual Studio.
+#if defined(_MSC_VER)
+#define EXPORT_API __declspec(dllexport)
+#else
+// Other platforms don't need this.
+#define EXPORT_API
+#endif  // defined(_MSC_VER)
+
+namespace draco {
+namespace maya {
+
+enum class EncodeResult {
+  OK = 0,
+  KO_WRONG_INPUT = -1,
+  KO_MESH_ENCODING = -2,
+  KO_FILE_CREATION = -3
+};
+enum class DecodeResult {
+  OK = 0,
+  KO_GEOMETRY_TYPE_INVALID = -1,
+  KO_TRIANGULAR_MESH_NOT_FOUND = -2,
+  KO_MESH_DECODING = -3
+};
+
+extern "C" {
+struct EXPORT_API Drc2PyMesh {
+  Drc2PyMesh()
+      : faces_num(0),
+        faces(nullptr),
+        vertices_num(0),
+        vertices(nullptr),
+        normals_num(0),
+        normals(nullptr),
+        uvs_num(0),
+        uvs_real_num(0),
+        uvs(nullptr) {}
+  int faces_num;
+  int *faces;
+  int vertices_num;
+  float *vertices;
+  int normals_num;
+  float *normals;
+  int uvs_num;
+  int uvs_real_num;
+  float *uvs;
+};
+
+EXPORT_API DecodeResult drc2py_decode(char *data, unsigned int length,
+                                      Drc2PyMesh **res_mesh);
+EXPORT_API void drc2py_free(Drc2PyMesh **res_mesh);
+EXPORT_API EncodeResult drc2py_encode(Drc2PyMesh *in_mesh, char *file_path);
+}  // extern "C"
+
+}  // namespace maya
+}  // namespace draco
+
+#endif  // DRACO_MAYA_PLUGIN
+
+#endif  // DRACO_MAYA_DRACO_MAYA_PLUGIN_H_
diff --git a/engine/inc/draco/mesh/corner_table.h b/engine/inc/draco/mesh/corner_table.h
new file mode 100644
index 00000000..3aa720fd
--- /dev/null
+++ b/engine/inc/draco/mesh/corner_table.h
@@ -0,0 +1,396 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_MESH_CORNER_TABLE_H_
+#define DRACO_MESH_CORNER_TABLE_H_
+
+#include <array>
+#include <memory>
+
+#include "draco/attributes/geometry_indices.h"
+#include "draco/core/draco_index_type_vector.h"
+#include "draco/core/macros.h"
+#include "draco/mesh/valence_cache.h"
+
+namespace draco {
+
+// CornerTable is used to represent connectivity of triangular meshes.
+// For every corner of all faces, the corner table stores the index of the
+// opposite corner in the neighboring face (if it exists) as illustrated in the
+// figure below (see corner |c| and it's opposite corner |o|).
+//
+//     *
+//    /c\
+//   /   \
+//  /n   p\
+// *-------*
+//  \     /
+//   \   /
+//    \o/
+//     *
+//
+// All corners are defined by unique CornerIndex and each triplet of corners
+// that define a single face id always ordered consecutively as:
+//     { 3 * FaceIndex, 3 * FaceIndex + 1, 3 * FaceIndex +2 }.
+// This representation of corners allows CornerTable to easily retrieve Next and
+// Previous corners on any face (see corners |n| and |p| in the figure above).
+// Using the Next, Previous, and Opposite corners then enables traversal of any
+// 2-manifold surface.
+// If the CornerTable is constructed from a non-manifold surface, the input
+// non-manifold edges and vertices are automatically split.
+class CornerTable {
+ public:
+  // Corner table face type.
+  typedef std::array<VertexIndex, 3> FaceType;
+
+  CornerTable();
+  static std::unique_ptr<CornerTable> Create(
+      const IndexTypeVector<FaceIndex, FaceType> &faces);
+
+  // Initializes the CornerTable from provides set of indexed faces.
+  // The input faces can represent a non-manifold topology, in which case the
+  // non-manifold edges and vertices are going to be split.
+  bool Init(const IndexTypeVector<FaceIndex, FaceType> &faces);
+
+  // Resets the corner table to the given number of invalid faces.
+  bool Reset(int num_faces);
+
+  // Resets the corner table to the given number of invalid faces and vertices.
+  bool Reset(int num_faces, int num_vertices);
+
+  inline int num_vertices() const {
+    return static_cast<int>(vertex_corners_.size());
+  }
+  inline int num_corners() const {
+    return static_cast<int>(corner_to_vertex_map_.size());
+  }
+  inline int num_faces() const {
+    return static_cast<int>(corner_to_vertex_map_.size() / 3);
+  }
+
+  inline CornerIndex Opposite(CornerIndex corner) const {
+    if (corner == kInvalidCornerIndex) {
+      return corner;
+    }
+    return opposite_corners_[corner];
+  }
+  inline CornerIndex Next(CornerIndex corner) const {
+    if (corner == kInvalidCornerIndex) {
+      return corner;
+    }
+    return LocalIndex(++corner) ? corner : corner - 3;
+  }
+  inline CornerIndex Previous(CornerIndex corner) const {
+    if (corner == kInvalidCornerIndex) {
+      return corner;
+    }
+    return LocalIndex(corner) ? corner - 1 : corner + 2;
+  }
+  inline VertexIndex Vertex(CornerIndex corner) const {
+    if (corner == kInvalidCornerIndex) {
+      return kInvalidVertexIndex;
+    }
+    return ConfidentVertex(corner);
+  }
+  inline VertexIndex ConfidentVertex(CornerIndex corner) const {
+    DRACO_DCHECK_GE(corner.value(), 0);
+    DRACO_DCHECK_LT(corner.value(), num_corners());
+    return corner_to_vertex_map_[corner];
+  }
+  inline FaceIndex Face(CornerIndex corner) const {
+    if (corner == kInvalidCornerIndex) {
+      return kInvalidFaceIndex;
+    }
+    return FaceIndex(corner.value() / 3);
+  }
+  inline CornerIndex FirstCorner(FaceIndex face) const {
+    if (face == kInvalidFaceIndex) {
+      return kInvalidCornerIndex;
+    }
+    return CornerIndex(face.value() * 3);
+  }
+  inline std::array<CornerIndex, 3> AllCorners(FaceIndex face) const {
+    const CornerIndex ci = CornerIndex(face.value() * 3);
+    return {{ci, ci + 1, ci + 2}};
+  }
+  inline int LocalIndex(CornerIndex corner) const { return corner.value() % 3; }
+
+  inline FaceType FaceData(FaceIndex face) const {
+    const CornerIndex first_corner = FirstCorner(face);
+    FaceType face_data;
+    for (int i = 0; i < 3; ++i) {
+      face_data[i] = corner_to_vertex_map_[first_corner + i];
+    }
+    return face_data;
+  }
+
+  void SetFaceData(FaceIndex face, FaceType data) {
+    DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+    const CornerIndex first_corner = FirstCorner(face);
+    for (int i = 0; i < 3; ++i) {
+      corner_to_vertex_map_[first_corner + i] = data[i];
+    }
+  }
+
+  // Returns the left-most corner of a single vertex 1-ring. If a vertex is not
+  // on a boundary (in which case it has a full 1-ring), this function returns
+  // any of the corners mapped to the given vertex.
+  inline CornerIndex LeftMostCorner(VertexIndex v) const {
+    return vertex_corners_[v];
+  }
+
+  // Returns the parent vertex index of a given corner table vertex.
+  VertexIndex VertexParent(VertexIndex vertex) const {
+    if (vertex.value() < static_cast<uint32_t>(num_original_vertices_)) {
+      return vertex;
+    }
+    return non_manifold_vertex_parents_[vertex - num_original_vertices_];
+  }
+
+  // Returns true if the corner is valid.
+  inline bool IsValid(CornerIndex c) const {
+    return Vertex(c) != kInvalidVertexIndex;
+  }
+
+  // Returns the valence (or degree) of a vertex.
+  // Returns -1 if the given vertex index is not valid.
+  int Valence(VertexIndex v) const;
+  // Same as above but does not check for validity and does not return -1
+  int ConfidentValence(VertexIndex v) const;
+  // Returns the valence of the vertex at the given corner.
+  inline int Valence(CornerIndex c) const {
+    if (c == kInvalidCornerIndex) {
+      return -1;
+    }
+    return ConfidentValence(c);
+  }
+  inline int ConfidentValence(CornerIndex c) const {
+    DRACO_DCHECK_LT(c.value(), num_corners());
+    return ConfidentValence(ConfidentVertex(c));
+  }
+
+  // Returns true if the specified vertex is on a boundary.
+  inline bool IsOnBoundary(VertexIndex vert) const {
+    const CornerIndex corner = LeftMostCorner(vert);
+    if (SwingLeft(corner) == kInvalidCornerIndex) {
+      return true;
+    }
+    return false;
+  }
+
+  //     *-------*
+  //    / \     / \
+  //   /   \   /   \
+  //  /   sl\c/sr   \
+  // *-------v-------*
+  // Returns the corner on the adjacent face on the right that maps to
+  // the same vertex as the given corner (sr in the above diagram).
+  inline CornerIndex SwingRight(CornerIndex corner) const {
+    return Previous(Opposite(Previous(corner)));
+  }
+  // Returns the corner on the left face that maps to the same vertex as the
+  // given corner (sl in the above diagram).
+  inline CornerIndex SwingLeft(CornerIndex corner) const {
+    return Next(Opposite(Next(corner)));
+  }
+
+  // Get opposite corners on the left and right faces respectively (see image
+  // below, where L and R are the left and right corners of a corner X.
+  //
+  // *-------*-------*
+  //  \L    /X\    R/
+  //   \   /   \   /
+  //    \ /     \ /
+  //     *-------*
+  inline CornerIndex GetLeftCorner(CornerIndex corner_id) const {
+    if (corner_id == kInvalidCornerIndex) {
+      return kInvalidCornerIndex;
+    }
+    return Opposite(Previous(corner_id));
+  }
+  inline CornerIndex GetRightCorner(CornerIndex corner_id) const {
+    if (corner_id == kInvalidCornerIndex) {
+      return kInvalidCornerIndex;
+    }
+    return Opposite(Next(corner_id));
+  }
+
+  // Returns the number of new vertices that were created as a result of
+  // splitting of non-manifold vertices of the input geometry.
+  int NumNewVertices() const { return num_vertices() - num_original_vertices_; }
+  int NumOriginalVertices() const { return num_original_vertices_; }
+
+  // Returns the number of faces with duplicated vertex indices.
+  int NumDegeneratedFaces() const { return num_degenerated_faces_; }
+
+  // Returns the number of isolated vertices (vertices that have
+  // vertex_corners_ mapping set to kInvalidCornerIndex.
+  int NumIsolatedVertices() const { return num_isolated_vertices_; }
+
+  bool IsDegenerated(FaceIndex face) const;
+
+  // Methods that modify an existing corner table.
+  // Sets the opposite corner mapping between two corners. Caller must ensure
+  // that the indices are valid.
+  inline void SetOppositeCorner(CornerIndex corner_id,
+                                CornerIndex opp_corner_id) {
+    DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+    opposite_corners_[corner_id] = opp_corner_id;
+  }
+
+  // Sets opposite corners for both input corners.
+  inline void SetOppositeCorners(CornerIndex corner_0, CornerIndex corner_1) {
+    DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+    if (corner_0 != kInvalidCornerIndex) {
+      SetOppositeCorner(corner_0, corner_1);
+    }
+    if (corner_1 != kInvalidCornerIndex) {
+      SetOppositeCorner(corner_1, corner_0);
+    }
+  }
+
+  // Updates mapping between a corner and a vertex.
+  inline void MapCornerToVertex(CornerIndex corner_id, VertexIndex vert_id) {
+    DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+    corner_to_vertex_map_[corner_id] = vert_id;
+  }
+
+  VertexIndex AddNewVertex() {
+    DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+    // Add a new invalid vertex.
+    vertex_corners_.push_back(kInvalidCornerIndex);
+    return VertexIndex(static_cast<uint32_t>(vertex_corners_.size() - 1));
+  }
+
+  // Adds a new face connected to three vertices. Note that connectivity is not
+  // automatically updated and all opposite corners need to be set explicitly.
+  FaceIndex AddNewFace(const std::array<VertexIndex, 3> &vertices) {
+    // Add a new invalid face.
+    const FaceIndex new_face_index(num_faces());
+    for (int i = 0; i < 3; ++i) {
+      corner_to_vertex_map_.push_back(vertices[i]);
+      SetLeftMostCorner(vertices[i],
+                        CornerIndex(corner_to_vertex_map_.size() - 1));
+    }
+    opposite_corners_.resize(corner_to_vertex_map_.size(), kInvalidCornerIndex);
+    return new_face_index;
+  }
+
+  // Sets a new left most corner for a given vertex.
+  void SetLeftMostCorner(VertexIndex vert, CornerIndex corner) {
+    DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+    if (vert != kInvalidVertexIndex) {
+      vertex_corners_[vert] = corner;
+    }
+  }
+
+  // Updates the vertex to corner map on a specified vertex. This should be
+  // called in cases where the mapping may be invalid (e.g. when the corner
+  // table was constructed manually).
+  void UpdateVertexToCornerMap(VertexIndex vert) {
+    DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+    const CornerIndex first_c = vertex_corners_[vert];
+    if (first_c == kInvalidCornerIndex) {
+      return;  // Isolated vertex.
+    }
+    CornerIndex act_c = SwingLeft(first_c);
+    CornerIndex c = first_c;
+    while (act_c != kInvalidCornerIndex && act_c != first_c) {
+      c = act_c;
+      act_c = SwingLeft(act_c);
+    }
+    if (act_c != first_c) {
+      vertex_corners_[vert] = c;
+    }
+  }
+
+  // Sets the new number of vertices. It's a responsibility of the caller to
+  // ensure that no corner is mapped beyond the range of the new number of
+  // vertices.
+  inline void SetNumVertices(int num_vertices) {
+    DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+    vertex_corners_.resize(num_vertices, kInvalidCornerIndex);
+  }
+
+  // Makes a vertex isolated (not attached to any corner).
+  void MakeVertexIsolated(VertexIndex vert) {
+    DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+    vertex_corners_[vert] = kInvalidCornerIndex;
+  }
+
+  // Returns true if a vertex is not attached to any face.
+  inline bool IsVertexIsolated(VertexIndex v) const {
+    return LeftMostCorner(v) == kInvalidCornerIndex;
+  }
+
+  // Makes a given face invalid (all corners are marked as invalid).
+  void MakeFaceInvalid(FaceIndex face) {
+    DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+    if (face != kInvalidFaceIndex) {
+      const CornerIndex first_corner = FirstCorner(face);
+      for (int i = 0; i < 3; ++i) {
+        corner_to_vertex_map_[first_corner + i] = kInvalidVertexIndex;
+      }
+    }
+  }
+
+  // Updates mapping between faces and a vertex using the corners mapped to
+  // the provided vertex.
+  void UpdateFaceToVertexMap(const VertexIndex vertex);
+
+  // Allows access to an internal object for caching valences.  The object can
+  // be instructed to cache or uncache all valences and then its interfaces
+  // queried directly for valences with differing performance/confidence
+  // qualities.  If the mesh or table is modified the cache should be discarded
+  // and not relied on as it does not automatically update or invalidate for
+  // performance reasons.
+  const draco::ValenceCache<CornerTable> &GetValenceCache() const {
+    return valence_cache_;
+  }
+
+ private:
+  // Computes opposite corners mapping from the data stored in
+  // |corner_to_vertex_map_|.
+  bool ComputeOppositeCorners(int *num_vertices);
+
+  // Finds and breaks non-manifold edges in the 1-ring neighborhood around
+  // vertices (vertices themselves will be split in the ComputeVertexCorners()
+  // function if necessary).
+  bool BreakNonManifoldEdges();
+
+  // Computes the lookup map for going from a vertex to a corner. This method
+  // can handle non-manifold vertices by splitting them into multiple manifold
+  // vertices.
+  bool ComputeVertexCorners(int num_vertices);
+
+  // Each three consecutive corners represent one face.
+  IndexTypeVector<CornerIndex, VertexIndex> corner_to_vertex_map_;
+  IndexTypeVector<CornerIndex, CornerIndex> opposite_corners_;
+  IndexTypeVector<VertexIndex, CornerIndex> vertex_corners_;
+
+  int num_original_vertices_;
+  int num_degenerated_faces_;
+  int num_isolated_vertices_;
+  IndexTypeVector<VertexIndex, VertexIndex> non_manifold_vertex_parents_;
+
+  draco::ValenceCache<CornerTable> valence_cache_;
+};
+
+// A special case to denote an invalid corner table triangle.
+static constexpr CornerTable::FaceType kInvalidFace(
+    {{kInvalidVertexIndex, kInvalidVertexIndex, kInvalidVertexIndex}});
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_CORNER_TABLE_H_
diff --git a/engine/inc/draco/mesh/corner_table_iterators.h b/engine/inc/draco/mesh/corner_table_iterators.h
new file mode 100644
index 00000000..7122aa1b
--- /dev/null
+++ b/engine/inc/draco/mesh/corner_table_iterators.h
@@ -0,0 +1,289 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_MESH_CORNER_TABLE_ITERATORS_H_
+#define DRACO_MESH_CORNER_TABLE_ITERATORS_H_
+
+#include "draco/mesh/corner_table.h"
+
+namespace draco {
+
+// Class for iterating over vertices in a 1-ring around the specified vertex.
+template <class CornerTableT>
+class VertexRingIterator
+    : public std::iterator<std::forward_iterator_tag, VertexIndex> {
+ public:
+  // std::iterator interface requires a default constructor.
+  VertexRingIterator()
+      : corner_table_(nullptr),
+        start_corner_(kInvalidCornerIndex),
+        corner_(start_corner_),
+        left_traversal_(true) {}
+
+  // Create the iterator from the provided corner table and the central vertex.
+  VertexRingIterator(const CornerTableT *table, VertexIndex vert_id)
+      : corner_table_(table),
+        start_corner_(table->LeftMostCorner(vert_id)),
+        corner_(start_corner_),
+        left_traversal_(true) {}
+
+  // Gets the last visited ring vertex.
+  VertexIndex Vertex() const {
+    CornerIndex ring_corner = left_traversal_ ? corner_table_->Previous(corner_)
+                                              : corner_table_->Next(corner_);
+    return corner_table_->Vertex(ring_corner);
+  }
+
+  // Returns one of the corners opposite to the edge connecting the currently
+  // iterated ring vertex with the central vertex.
+  CornerIndex EdgeCorner() const {
+    return left_traversal_ ? corner_table_->Next(corner_)
+                           : corner_table_->Previous(corner_);
+  }
+
+  // Returns true when all ring vertices have been visited.
+  bool End() const { return corner_ == kInvalidCornerIndex; }
+
+  // Proceeds to the next ring vertex if possible.
+  void Next() {
+    if (left_traversal_) {
+      corner_ = corner_table_->SwingLeft(corner_);
+      if (corner_ == kInvalidCornerIndex) {
+        // Open boundary reached.
+        corner_ = start_corner_;
+        left_traversal_ = false;
+      } else if (corner_ == start_corner_) {
+        // End reached.
+        corner_ = kInvalidCornerIndex;
+      }
+    } else {
+      // Go to the right until we reach a boundary there (no explicit check
+      // is needed in this case).
+      corner_ = corner_table_->SwingRight(corner_);
+    }
+  }
+
+  // std::iterator interface.
+  value_type operator*() const { return Vertex(); }
+  VertexRingIterator &operator++() {
+    Next();
+    return *this;
+  }
+  VertexRingIterator operator++(int) {
+    const VertexRingIterator result = *this;
+    ++(*this);
+    return result;
+  }
+  bool operator!=(const VertexRingIterator &other) const {
+    return corner_ != other.corner_ || start_corner_ != other.start_corner_;
+  }
+  bool operator==(const VertexRingIterator &other) const {
+    return !this->operator!=(other);
+  }
+
+  // Helper function for getting a valid end iterator.
+  static VertexRingIterator EndIterator(VertexRingIterator other) {
+    VertexRingIterator ret = other;
+    ret.corner_ = kInvalidCornerIndex;
+    return ret;
+  }
+
+ private:
+  const CornerTableT *corner_table_;
+  // The first processed corner.
+  CornerIndex start_corner_;
+  // The last processed corner.
+  CornerIndex corner_;
+  // Traversal direction.
+  bool left_traversal_;
+};
+
+// Class for iterating over faces adjacent to the specified input face.
+template <class CornerTableT>
+class FaceAdjacencyIterator
+    : public std::iterator<std::forward_iterator_tag, FaceIndex> {
+ public:
+  // std::iterator interface requires a default constructor.
+  FaceAdjacencyIterator()
+      : corner_table_(nullptr),
+        start_corner_(kInvalidCornerIndex),
+        corner_(start_corner_) {}
+
+  // Create the iterator from the provided corner table and the central vertex.
+  FaceAdjacencyIterator(const CornerTableT *table, FaceIndex face_id)
+      : corner_table_(table),
+        start_corner_(table->FirstCorner(face_id)),
+        corner_(start_corner_) {
+    // We need to start with a corner that has a valid opposite face (if
+    // there is any such corner).
+    if (corner_table_->Opposite(corner_) == kInvalidCornerIndex) {
+      FindNextFaceNeighbor();
+    }
+  }
+
+  // Gets the last visited adjacent face.
+  FaceIndex Face() const {
+    return corner_table_->Face(corner_table_->Opposite(corner_));
+  }
+
+  // Returns true when all adjacent faces have been visited.
+  bool End() const { return corner_ == kInvalidCornerIndex; }
+
+  // Proceeds to the next adjacent face if possible.
+  void Next() { FindNextFaceNeighbor(); }
+
+  // std::iterator interface.
+  value_type operator*() const { return Face(); }
+  FaceAdjacencyIterator &operator++() {
+    Next();
+    return *this;
+  }
+  FaceAdjacencyIterator operator++(int) {
+    const FaceAdjacencyIterator result = *this;
+    ++(*this);
+    return result;
+  }
+  bool operator!=(const FaceAdjacencyIterator &other) const {
+    return corner_ != other.corner_ || start_corner_ != other.start_corner_;
+  }
+  bool operator==(const FaceAdjacencyIterator &other) const {
+    return !this->operator!=(other);
+  }
+
+  // Helper function for getting a valid end iterator.
+  static FaceAdjacencyIterator EndIterator(FaceAdjacencyIterator other) {
+    FaceAdjacencyIterator ret = other;
+    ret.corner_ = kInvalidCornerIndex;
+    return ret;
+  }
+
+ private:
+  // Finds the next corner with a valid opposite face.
+  void FindNextFaceNeighbor() {
+    while (corner_ != kInvalidCornerIndex) {
+      corner_ = corner_table_->Next(corner_);
+      if (corner_ == start_corner_) {
+        corner_ = kInvalidCornerIndex;
+        return;
+      }
+      if (corner_table_->Opposite(corner_) != kInvalidCornerIndex) {
+        // Valid opposite face.
+        return;
+      }
+    }
+  }
+
+  const CornerTableT *corner_table_;
+  // The first processed corner.
+  CornerIndex start_corner_;
+  // The last processed corner.
+  CornerIndex corner_;
+};
+
+// Class for iterating over corners attached to a specified vertex.
+template <class CornerTableT = CornerTable>
+class VertexCornersIterator
+    : public std::iterator<std::forward_iterator_tag, CornerIndex> {
+ public:
+  // std::iterator interface requires a default constructor.
+  VertexCornersIterator()
+      : corner_table_(nullptr),
+        start_corner_(-1),
+        corner_(start_corner_),
+        left_traversal_(true) {}
+
+  // Create the iterator from the provided corner table and the central vertex.
+  VertexCornersIterator(const CornerTableT *table, VertexIndex vert_id)
+      : corner_table_(table),
+        start_corner_(table->LeftMostCorner(vert_id)),
+        corner_(start_corner_),
+        left_traversal_(true) {}
+
+  // Create the iterator from the provided corner table and the first corner.
+  VertexCornersIterator(const CornerTableT *table, CornerIndex corner_id)
+      : corner_table_(table),
+        start_corner_(corner_id),
+        corner_(start_corner_),
+        left_traversal_(true) {}
+
+  // Gets the last visited corner.
+  CornerIndex Corner() const { return corner_; }
+
+  // Returns true when all ring vertices have been visited.
+  bool End() const { return corner_ == kInvalidCornerIndex; }
+
+  // Proceeds to the next corner if possible.
+  void Next() {
+    if (left_traversal_) {
+      corner_ = corner_table_->SwingLeft(corner_);
+      if (corner_ == kInvalidCornerIndex) {
+        // Open boundary reached.
+        corner_ = corner_table_->SwingRight(start_corner_);
+        left_traversal_ = false;
+      } else if (corner_ == start_corner_) {
+        // End reached.
+        corner_ = kInvalidCornerIndex;
+      }
+    } else {
+      // Go to the right until we reach a boundary there (no explicit check
+      // is needed in this case).
+      corner_ = corner_table_->SwingRight(corner_);
+    }
+  }
+
+  // std::iterator interface.
+  CornerIndex operator*() const { return Corner(); }
+  VertexCornersIterator &operator++() {
+    Next();
+    return *this;
+  }
+  VertexCornersIterator operator++(int) {
+    const VertexCornersIterator result = *this;
+    ++(*this);
+    return result;
+  }
+  bool operator!=(const VertexCornersIterator &other) const {
+    return corner_ != other.corner_ || start_corner_ != other.start_corner_;
+  }
+  bool operator==(const VertexCornersIterator &other) const {
+    return !this->operator!=(other);
+  }
+
+  // Helper function for getting a valid end iterator.
+  static VertexCornersIterator EndIterator(VertexCornersIterator other) {
+    VertexCornersIterator ret = other;
+    ret.corner_ = kInvalidCornerIndex;
+    return ret;
+  }
+
+ protected:
+  const CornerTableT *corner_table() const { return corner_table_; }
+  CornerIndex start_corner() const { return start_corner_; }
+  CornerIndex &corner() { return corner_; }
+  bool is_left_traversal() const { return left_traversal_; }
+  void swap_traversal() { left_traversal_ = !left_traversal_; }
+
+ private:
+  const CornerTableT *corner_table_;
+  // The first processed corner.
+  CornerIndex start_corner_;
+  // The last processed corner.
+  CornerIndex corner_;
+  // Traversal direction.
+  bool left_traversal_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_CORNER_TABLE_ITERATORS_H_
diff --git a/engine/inc/draco/mesh/mesh.h b/engine/inc/draco/mesh/mesh.h
new file mode 100644
index 00000000..f4506da8
--- /dev/null
+++ b/engine/inc/draco/mesh/mesh.h
@@ -0,0 +1,152 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_MESH_MESH_H_
+#define DRACO_MESH_MESH_H_
+
+#include <memory>
+
+#include "draco/attributes/geometry_indices.h"
+#include "draco/core/hash_utils.h"
+#include "draco/core/macros.h"
+#include "draco/core/status.h"
+#include "draco/draco_features.h"
+#include "draco/point_cloud/point_cloud.h"
+
+namespace draco {
+
+// List of different variants of mesh attributes.
+enum MeshAttributeElementType {
+  // All corners attached to a vertex share the same attribute value. A typical
+  // example are the vertex positions and often vertex colors.
+  MESH_VERTEX_ATTRIBUTE = 0,
+  // The most general attribute where every corner of the mesh can have a
+  // different attribute value. Often used for texture coordinates or normals.
+  MESH_CORNER_ATTRIBUTE,
+  // All corners of a single face share the same value.
+  MESH_FACE_ATTRIBUTE
+};
+
+// Mesh class can be used to represent general triangular meshes. Internally,
+// Mesh is just an extended PointCloud with extra connectivity data that defines
+// what points are connected together in triangles.
+class Mesh : public PointCloud {
+ public:
+  typedef std::array<PointIndex, 3> Face;
+
+  Mesh();
+
+  void AddFace(const Face &face) { faces_.push_back(face); }
+
+  void SetFace(FaceIndex face_id, const Face &face) {
+    if (face_id >= static_cast<uint32_t>(faces_.size())) {
+      faces_.resize(face_id.value() + 1, Face());
+    }
+    faces_[face_id] = face;
+  }
+
+  // Sets the total number of faces. Creates new empty faces or deletes
+  // existing ones if necessary.
+  void SetNumFaces(size_t num_faces) { faces_.resize(num_faces, Face()); }
+
+  FaceIndex::ValueType num_faces() const {
+    return static_cast<uint32_t>(faces_.size());
+  }
+  const Face &face(FaceIndex face_id) const {
+    DRACO_DCHECK_LE(0, face_id.value());
+    DRACO_DCHECK_LT(face_id.value(), static_cast<int>(faces_.size()));
+    return faces_[face_id];
+  }
+
+  void SetAttribute(int att_id, std::unique_ptr<PointAttribute> pa) override {
+    PointCloud::SetAttribute(att_id, std::move(pa));
+    if (static_cast<int>(attribute_data_.size()) <= att_id) {
+      attribute_data_.resize(att_id + 1);
+    }
+  }
+
+  void DeleteAttribute(int att_id) override {
+    PointCloud::DeleteAttribute(att_id);
+    if (att_id >= 0 && att_id < static_cast<int>(attribute_data_.size())) {
+      attribute_data_.erase(attribute_data_.begin() + att_id);
+    }
+  }
+
+  MeshAttributeElementType GetAttributeElementType(int att_id) const {
+    return attribute_data_[att_id].element_type;
+  }
+
+  void SetAttributeElementType(int att_id, MeshAttributeElementType et) {
+    attribute_data_[att_id].element_type = et;
+  }
+
+  // Returns the point id of for a corner |ci|.
+  inline PointIndex CornerToPointId(int ci) const {
+    if (ci < 0 || static_cast<uint32_t>(ci) == kInvalidCornerIndex.value()) {
+      return kInvalidPointIndex;
+    }
+    return this->face(FaceIndex(ci / 3))[ci % 3];
+  }
+
+  // Returns the point id of a corner |ci|.
+  inline PointIndex CornerToPointId(CornerIndex ci) const {
+    return this->CornerToPointId(ci.value());
+  }
+
+  struct AttributeData {
+    AttributeData() : element_type(MESH_CORNER_ATTRIBUTE) {}
+    MeshAttributeElementType element_type;
+  };
+
+ protected:
+#ifdef DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED
+  // Extends the point deduplication to face corners. This method is called from
+  // the PointCloud::DeduplicatePointIds() and it remaps all point ids stored in
+  // |faces_| to the new deduplicated point ids using the map |id_map|.
+  void ApplyPointIdDeduplication(
+      const IndexTypeVector<PointIndex, PointIndex> &id_map,
+      const std::vector<PointIndex> &unique_point_ids) override;
+#endif
+
+ private:
+  // Mesh specific per-attribute data.
+  std::vector<AttributeData> attribute_data_;
+
+  // Vertex indices valid for all attributes. Each attribute has its own map
+  // that converts vertex indices into attribute indices.
+  IndexTypeVector<FaceIndex, Face> faces_;
+
+  friend struct MeshHasher;
+};
+
+// Functor for computing a hash from data stored within a mesh.
+// Note that this can be quite slow. Two meshes will have the same hash only
+// when they have exactly the same connectivity and attribute values.
+struct MeshHasher {
+  size_t operator()(const Mesh &mesh) const {
+    PointCloudHasher pc_hasher;
+    size_t hash = pc_hasher(mesh);
+    // Hash faces.
+    for (FaceIndex i(0); i < static_cast<uint32_t>(mesh.faces_.size()); ++i) {
+      for (int j = 0; j < 3; ++j) {
+        hash = HashCombine(mesh.faces_[i][j].value(), hash);
+      }
+    }
+    return hash;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_MESH_H_
diff --git a/engine/inc/draco/mesh/mesh_are_equivalent.h b/engine/inc/draco/mesh/mesh_are_equivalent.h
new file mode 100644
index 00000000..71ef4a93
--- /dev/null
+++ b/engine/inc/draco/mesh/mesh_are_equivalent.h
@@ -0,0 +1,71 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_MESH_MESH_ARE_EQUIVALENT_H_
+#define DRACO_MESH_MESH_ARE_EQUIVALENT_H_
+
+#include "draco/core/vector_d.h"
+#include "draco/mesh/mesh.h"
+
+// This file defines a functor to compare two meshes for equivalency up
+// to permutation of the vertices.
+namespace draco {
+
+// A functor to compare two meshes for equivalency up to permutation of the
+// vertices.
+class MeshAreEquivalent {
+ public:
+  // Returns true if both meshes are equivalent up to permutation of
+  // the internal order of vertices. This includes all attributes.
+  bool operator()(const Mesh &mesh0, const Mesh &mesh1);
+
+ private:
+  // Internal type to keep overview.
+  struct MeshInfo {
+    explicit MeshInfo(const Mesh &in_mesh) : mesh(in_mesh) {}
+    const Mesh &mesh;
+    std::vector<FaceIndex> ordered_index_of_face;
+    IndexTypeVector<FaceIndex, int> corner_index_of_smallest_vertex;
+  };
+
+  // Prepare functor for actual comparison.
+  void Init(const Mesh &mesh0, const Mesh &mesh1);
+
+  // Get position as Vector3f of corner c of face f.
+  static Vector3f GetPosition(const Mesh &mesh, FaceIndex f, int32_t c);
+  // Internal helper function mostly for debugging.
+  void PrintPosition(const Mesh &mesh, FaceIndex f, int32_t c);
+  // Get the corner index of the lex smallest vertex of face f.
+  static int32_t ComputeCornerIndexOfSmallestPointXYZ(const Mesh &mesh,
+                                                      FaceIndex f);
+
+  // Less compare functor for two faces (represented by their indices)
+  // with respect to their lex order.
+  struct FaceIndexLess {
+    explicit FaceIndexLess(const MeshInfo &in_mesh_info)
+        : mesh_info(in_mesh_info) {}
+    bool operator()(FaceIndex f0, FaceIndex f1) const;
+    const MeshInfo &mesh_info;
+  };
+
+  void InitCornerIndexOfSmallestPointXYZ();
+  void InitOrderedFaceIndex();
+
+  std::vector<MeshInfo> mesh_infos_;
+  int32_t num_faces_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_MESH_ARE_EQUIVALENT_H_
diff --git a/engine/inc/draco/mesh/mesh_attribute_corner_table.h b/engine/inc/draco/mesh/mesh_attribute_corner_table.h
new file mode 100644
index 00000000..7dad25cf
--- /dev/null
+++ b/engine/inc/draco/mesh/mesh_attribute_corner_table.h
@@ -0,0 +1,196 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_MESH_MESH_ATTRIBUTE_CORNER_TABLE_H_
+#define DRACO_MESH_MESH_ATTRIBUTE_CORNER_TABLE_H_
+
+#include "draco/core/macros.h"
+#include "draco/mesh/corner_table.h"
+#include "draco/mesh/mesh.h"
+#include "draco/mesh/valence_cache.h"
+
+namespace draco {
+
+// Class for storing connectivity of mesh attributes. The connectivity is stored
+// as a difference from the base mesh's corner table, where the differences are
+// represented by attribute seam edges. This class provides a basic
+// functionality for detecting the seam edges for a given attribute and for
+// traversing the constrained corner table with the seam edges.
+class MeshAttributeCornerTable {
+ public:
+  MeshAttributeCornerTable();
+  bool InitEmpty(const CornerTable *table);
+  bool InitFromAttribute(const Mesh *mesh, const CornerTable *table,
+                         const PointAttribute *att);
+
+  void AddSeamEdge(CornerIndex opp_corner);
+
+  // Recomputes vertices using the newly added seam edges (needs to be called
+  // whenever the seam edges are updated).
+  // |mesh| and |att| can be null, in which case mapping between vertices and
+  // attribute value ids is set to identity.
+  void RecomputeVertices(const Mesh *mesh, const PointAttribute *att);
+
+  inline bool IsCornerOppositeToSeamEdge(CornerIndex corner) const {
+    return is_edge_on_seam_[corner.value()];
+  }
+
+  inline CornerIndex Opposite(CornerIndex corner) const {
+    if (corner == kInvalidCornerIndex || IsCornerOppositeToSeamEdge(corner)) {
+      return kInvalidCornerIndex;
+    }
+    return corner_table_->Opposite(corner);
+  }
+
+  inline CornerIndex Next(CornerIndex corner) const {
+    return corner_table_->Next(corner);
+  }
+
+  inline CornerIndex Previous(CornerIndex corner) const {
+    return corner_table_->Previous(corner);
+  }
+
+  // Returns true when a corner is attached to any attribute seam.
+  inline bool IsCornerOnSeam(CornerIndex corner) const {
+    return is_vertex_on_seam_[corner_table_->Vertex(corner).value()];
+  }
+
+  // Similar to CornerTable::GetLeftCorner and CornerTable::GetRightCorner, but
+  // does not go over seam edges.
+  inline CornerIndex GetLeftCorner(CornerIndex corner) const {
+    return Opposite(Previous(corner));
+  }
+  inline CornerIndex GetRightCorner(CornerIndex corner) const {
+    return Opposite(Next(corner));
+  }
+
+  // Similar to CornerTable::SwingRight, but it does not go over seam edges.
+  inline CornerIndex SwingRight(CornerIndex corner) const {
+    return Previous(Opposite(Previous(corner)));
+  }
+
+  // Similar to CornerTable::SwingLeft, but it does not go over seam edges.
+  inline CornerIndex SwingLeft(CornerIndex corner) const {
+    return Next(Opposite(Next(corner)));
+  }
+
+  int num_vertices() const {
+    return static_cast<int>(vertex_to_attribute_entry_id_map_.size());
+  }
+  int num_faces() const { return static_cast<int>(corner_table_->num_faces()); }
+  int num_corners() const { return corner_table_->num_corners(); }
+
+  VertexIndex Vertex(CornerIndex corner) const {
+    DRACO_DCHECK_LT(corner.value(), corner_to_vertex_map_.size());
+    return ConfidentVertex(corner);
+  }
+  VertexIndex ConfidentVertex(CornerIndex corner) const {
+    return corner_to_vertex_map_[corner.value()];
+  }
+  // Returns the attribute entry id associated to the given vertex.
+  VertexIndex VertexParent(VertexIndex vert) const {
+    return VertexIndex(vertex_to_attribute_entry_id_map_[vert.value()].value());
+  }
+
+  inline CornerIndex LeftMostCorner(VertexIndex v) const {
+    return vertex_to_left_most_corner_map_[v.value()];
+  }
+
+  inline FaceIndex Face(CornerIndex corner) const {
+    return corner_table_->Face(corner);
+  }
+
+  inline CornerIndex FirstCorner(FaceIndex face) const {
+    return corner_table_->FirstCorner(face);
+  }
+
+  inline std::array<CornerIndex, 3> AllCorners(FaceIndex face) const {
+    return corner_table_->AllCorners(face);
+  }
+
+  inline bool IsOnBoundary(VertexIndex vert) const {
+    const CornerIndex corner = LeftMostCorner(vert);
+    if (corner == kInvalidCornerIndex) {
+      return true;
+    }
+    if (SwingLeft(corner) == kInvalidCornerIndex) {
+      return true;
+    }
+    return false;
+  }
+
+  bool no_interior_seams() const { return no_interior_seams_; }
+  const CornerTable *corner_table() const { return corner_table_; }
+
+  // TODO(draco-eng): extract valence functions into a reusable class/object
+  // also from 'corner_table.*'
+
+  // Returns the valence (or degree) of a vertex.
+  // Returns -1 if the given vertex index is not valid.
+  int Valence(VertexIndex v) const;
+  // Same as above but does not check for validity and does not return -1
+  int ConfidentValence(VertexIndex v) const;
+  // Returns the valence of the vertex at the given corner.
+  inline int Valence(CornerIndex c) const {
+    DRACO_DCHECK_LT(c.value(), corner_table_->num_corners());
+    if (c == kInvalidCornerIndex) {
+      return -1;
+    }
+    return ConfidentValence(c);
+  }
+  inline int ConfidentValence(CornerIndex c) const {
+    DRACO_DCHECK_LT(c.value(), corner_table_->num_corners());
+    return ConfidentValence(Vertex(c));
+  }
+
+  // Allows access to an internal object for caching valences.  The object can
+  // be instructed to cache or uncache all valences and then its interfaces
+  // queried directly for valences with differing performance/confidence
+  // qualities.  If the mesh or table is modified the cache should be discarded
+  // and not relied on as it does not automatically update or invalidate for
+  // performance reasons.
+  const ValenceCache<MeshAttributeCornerTable> &GetValenceCache() const {
+    return valence_cache_;
+  }
+
+ private:
+  template <bool init_vertex_to_attribute_entry_map>
+  void RecomputeVerticesInternal(const Mesh *mesh, const PointAttribute *att);
+
+  std::vector<bool> is_edge_on_seam_;
+  std::vector<bool> is_vertex_on_seam_;
+
+  // If this is set to true, it means that there are no attribute seams between
+  // two faces. This can be used to speed up some algorithms.
+  bool no_interior_seams_;
+
+  std::vector<VertexIndex> corner_to_vertex_map_;
+
+  // Map between vertices and their associated left most corners. A left most
+  // corner is a corner that is adjacent to a boundary or an attribute seam from
+  // right (i.e., SwingLeft from that corner will return an invalid corner). If
+  // no such corner exists for a given vertex, then any corner attached to the
+  // vertex can be used.
+  std::vector<CornerIndex> vertex_to_left_most_corner_map_;
+
+  // Map between vertex ids and attribute entry ids (i.e. the values stored in
+  // the attribute buffer). The attribute entry id can be retrieved using the
+  // VertexParent() method.
+  std::vector<AttributeValueIndex> vertex_to_attribute_entry_id_map_;
+  const CornerTable *corner_table_;
+  ValenceCache<MeshAttributeCornerTable> valence_cache_;
+};
+
+}  // namespace draco
+#endif  // DRACO_MESH_MESH_ATTRIBUTE_CORNER_TABLE_H_
diff --git a/engine/inc/draco/mesh/mesh_cleanup.h b/engine/inc/draco/mesh/mesh_cleanup.h
new file mode 100644
index 00000000..09aae2e1
--- /dev/null
+++ b/engine/inc/draco/mesh/mesh_cleanup.h
@@ -0,0 +1,65 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_MESH_MESH_CLEANUP_H_
+#define DRACO_MESH_MESH_CLEANUP_H_
+
+#include "draco/core/status.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Options used by the MeshCleanup class.
+struct MeshCleanupOptions {
+  MeshCleanupOptions()
+      : remove_degenerated_faces(true),
+        remove_duplicate_faces(true),
+        remove_unused_attributes(true),
+        make_geometry_manifold(false) {}
+  // If true, the cleanup tool removes any face where two or more vertices
+  // share the same position index.
+  bool remove_degenerated_faces;
+
+  // If true, the cleanup tool removes all duplicate faces. A pair of faces is
+  // duplicate if both faces share the same position indices on all vertices
+  // (that is, position values have to be duduplicated). Note that all
+  // non-position properties are currently ignored.
+  bool remove_duplicate_faces;
+
+  // If true, the cleanup tool removes any unused attribute value or unused
+  // point id. For example, it can be used to remove isolated vertices.
+  bool remove_unused_attributes;
+
+  // If true, the cleanup tool splits vertices along non-manifold edges and
+  // vertices. This ensures that the connectivity defined by position indices
+  // is manifold.
+  bool make_geometry_manifold;
+};
+
+// Tool that can be used for removing bad or unused data from draco::Meshes.
+class MeshCleanup {
+ public:
+  // Performs in-place cleanup of the input mesh according to the input options.
+  bool operator()(Mesh *mesh, const MeshCleanupOptions &options);
+
+ private:
+  static void RemoveDegeneratedFaces(Mesh *mesh);
+  static void RemoveDuplicateFaces(Mesh *mesh);
+  static void RemoveUnusedAttributes(Mesh *mesh);
+  static Status MakeGeometryManifold(Mesh *mesh);
+};
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_MESH_CLEANUP_H_
diff --git a/engine/inc/draco/mesh/mesh_misc_functions.h b/engine/inc/draco/mesh/mesh_misc_functions.h
new file mode 100644
index 00000000..b450bc80
--- /dev/null
+++ b/engine/inc/draco/mesh/mesh_misc_functions.h
@@ -0,0 +1,98 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// This file contains misc functions that are needed by several mesh related
+// algorithms.
+
+#ifndef DRACO_MESH_MESH_MISC_FUNCTIONS_H_
+#define DRACO_MESH_MESH_MISC_FUNCTIONS_H_
+
+#include "draco/mesh/corner_table.h"
+#include "draco/mesh/mesh.h"
+
+// The file contains functions that use both Mesh and CornerTable as inputs.
+namespace draco {
+
+// Creates a CornerTable from the position attribute of |mesh|. Returns nullptr
+// on error.
+std::unique_ptr<CornerTable> CreateCornerTableFromPositionAttribute(
+    const Mesh *mesh);
+
+// Creates a CornerTable from the first named attribute of |mesh| with a given
+// type. Returns nullptr on error.
+std::unique_ptr<CornerTable> CreateCornerTableFromAttribute(
+    const Mesh *mesh, GeometryAttribute::Type type);
+
+// Creates a CornerTable from all attributes of |mesh|. Boundaries are
+// automatically introduced on all attribute seams. Returns nullptr on error.
+std::unique_ptr<CornerTable> CreateCornerTableFromAllAttributes(
+    const Mesh *mesh);
+
+// Returns true when the given corner lies opposite to an attribute seam.
+inline bool IsCornerOppositeToAttributeSeam(CornerIndex ci,
+                                            const PointAttribute &att,
+                                            const Mesh &mesh,
+                                            const CornerTable &ct) {
+  const CornerIndex opp_ci = ct.Opposite(ci);
+  if (opp_ci == kInvalidCornerIndex) {
+    return false;  // No opposite corner == no attribute seam.
+  }
+  // Compare attribute value indices on both ends of the opposite edge.
+  CornerIndex c0 = ct.Next(ci);
+  CornerIndex c1 = ct.Previous(opp_ci);
+  if (att.mapped_index(mesh.CornerToPointId(c0)) !=
+      att.mapped_index(mesh.CornerToPointId(c1))) {
+    return true;
+  }
+  c0 = ct.Previous(ci);
+  c1 = ct.Next(opp_ci);
+  if (att.mapped_index(mesh.CornerToPointId(c0)) !=
+      att.mapped_index(mesh.CornerToPointId(c1))) {
+    return true;
+  }
+  return false;
+}
+
+// Interpolates an attribute value on a face using given barycentric
+// coordinates. InterpolatedVectorT should be a VectorD that corresponds to the
+// values stored in the attribute.
+// TODO(ostava): Find a better place for this.
+template <typename InterpolatedVectorT>
+InterpolatedVectorT ComputeInterpolatedAttributeValueOnMeshFace(
+    const Mesh &mesh, const PointAttribute &attribute, FaceIndex fi,
+    const std::array<float, 3> &barycentric_coord) {
+  const Mesh::Face &face = mesh.face(fi);
+  // Get values for all three corners of the face.
+  InterpolatedVectorT val[3];
+  for (int c = 0; c < 3; ++c) {
+    attribute.GetMappedValue(face[c], &(val[c][0]));
+  }
+  // Return an interpolated value.
+  InterpolatedVectorT res;
+  for (int d = 0; d < InterpolatedVectorT::dimension; ++d) {
+    const float interpolated_component = barycentric_coord[0] * val[0][d] +
+                                         barycentric_coord[1] * val[1][d] +
+                                         barycentric_coord[2] * val[2][d];
+    if (std::is_integral<typename InterpolatedVectorT::Scalar>::value) {
+      res[d] = std::floor(interpolated_component + 0.5f);
+    } else {
+      res[d] = interpolated_component;
+    }
+  }
+  return res;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_MESH_MISC_FUNCTIONS_H_
diff --git a/engine/inc/draco/mesh/mesh_stripifier.h b/engine/inc/draco/mesh/mesh_stripifier.h
new file mode 100644
index 00000000..262e3c79
--- /dev/null
+++ b/engine/inc/draco/mesh/mesh_stripifier.h
@@ -0,0 +1,260 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_MESH_MESH_STRIPIFIER_H_
+#define DRACO_MESH_MESH_STRIPIFIER_H_
+
+#include "draco/mesh/mesh_misc_functions.h"
+
+namespace draco {
+
+// Class that generates triangle strips from a provided draco::Mesh data
+// structure. The strips represent a more memory efficient storage of triangle
+// connectivity that can be used directly on the GPU (see
+// https://en.wikipedia.org/wiki/Triangle_strip ). In general, a mesh needs to
+// be represented by several triangle strips and it has been proven that finding
+// the optimal set of triangle strips is an NP-complete problem. The algorithm
+// implemented by this class finds this set of triangle strips based on a greedy
+// heuristic that always selects the longest available strip that covers the
+// next unprocessed face. The longest strip is found by analyzing all strips
+// that can cover the given face (three strips corresponding to three
+// directions).
+class MeshStripifier {
+ public:
+  MeshStripifier()
+      : mesh_(nullptr),
+        num_strips_(0),
+        num_encoded_faces_(0),
+        last_encoded_point_(kInvalidPointIndex) {}
+
+  // Generate triangle strips for a given mesh and output them to the output
+  // iterator |out_it|. In most cases |out_it| stores the values in a buffer
+  // that can be used directly on the GPU. Note that the algorithm can generate
+  // multiple strips to represent the whole mesh. In such cases multiple strips
+  // are separated using a so called primitive restart index that is specified
+  // by the |primitive_restart_index| (usually defined as the maximum allowed
+  // value for the given type).
+  // https://www.khronos.org/opengl/wiki/Vertex_Rendering#Primitive_Restart
+  template <typename OutputIteratorT, typename IndexTypeT>
+  bool GenerateTriangleStripsWithPrimitiveRestart(
+      const Mesh &mesh, IndexTypeT primitive_restart_index,
+      OutputIteratorT out_it);
+
+  // The same as above but disjoint triangle strips are separated by degenerate
+  // triangles instead of the primitive restart index. Degenerate triangles are
+  // zero area triangles that are automatically discarded by the GPU. Using
+  // degenerate triangles usually results in a slightly longer output indices
+  // array compared to the similar triangle strips that use primitive restart
+  // index. The advantage of this method is that it is supported by all hardware
+  // and all relevant APIs (including WebGL 1.0).
+  template <typename OutputIteratorT>
+  bool GenerateTriangleStripsWithDegenerateTriangles(const Mesh &mesh,
+                                                     OutputIteratorT out_it);
+
+  // Returns the number of strips generated by the last call of the
+  // GenerateTriangleStrips() method.
+  int num_strips() const { return num_strips_; }
+
+ private:
+  bool Prepare(const Mesh &mesh) {
+    mesh_ = &mesh;
+    num_strips_ = 0;
+    num_encoded_faces_ = 0;
+    // TODO(ostava): We may be able to avoid computing the corner table if we
+    // already have it stored somewhere.
+    corner_table_ = CreateCornerTableFromPositionAttribute(mesh_);
+    if (corner_table_ == nullptr) {
+      return false;
+    }
+
+    // Mark all faces as unvisited.
+    is_face_visited_.assign(mesh.num_faces(), false);
+    return true;
+  }
+
+  // Returns local id of the longest strip that can be created from the given
+  // face |fi|.
+  int FindLongestStripFromFace(FaceIndex fi) {
+    // There are three possible strip directions that can contain the provided
+    // input face. We try all of them and select the direction that result in
+    // the longest strip.
+    const CornerIndex first_ci = corner_table_->FirstCorner(fi);
+    int longest_strip_id = -1;
+    int longest_strip_length = 0;
+    for (int i = 0; i < 3; ++i) {
+      GenerateStripsFromCorner(i, first_ci + i);
+      if (strip_faces_[i].size() > longest_strip_length) {
+        longest_strip_length = static_cast<int>(strip_faces_[i].size());
+        longest_strip_id = i;
+      }
+    }
+    return longest_strip_id;
+  }
+
+  // Generates strip from the data stored in |strip_faces_| and
+  // |strip_start_start_corners_| and stores it to |out_it|.
+  template <typename OutputIteratorT>
+  void StoreStrip(int local_strip_id, OutputIteratorT out_it) {
+    ++num_strips_;
+
+    const int num_strip_faces = strip_faces_[local_strip_id].size();
+    CornerIndex ci = strip_start_corners_[local_strip_id];
+    for (int i = 0; i < num_strip_faces; ++i) {
+      const FaceIndex fi = corner_table_->Face(ci);
+      is_face_visited_[fi] = true;
+      ++num_encoded_faces_;
+
+      if (i == 0) {
+        // Add the start face (three indices).
+        *out_it++ = CornerToPointIndex(ci).value();
+        *out_it++ = CornerToPointIndex(corner_table_->Next(ci)).value();
+        last_encoded_point_ = CornerToPointIndex(corner_table_->Previous(ci));
+        *out_it++ = last_encoded_point_.value();
+      } else {
+        // Store the point on the newly reached corner.
+        last_encoded_point_ = CornerToPointIndex(ci);
+        *out_it++ = last_encoded_point_.value();
+
+        // Go to the correct source corner to proceed to the next face.
+        if (i & 1) {
+          ci = corner_table_->Previous(ci);
+        } else {
+          ci = corner_table_->Next(ci);
+        }
+      }
+      ci = corner_table_->Opposite(ci);
+    }
+  }
+
+  PointIndex CornerToPointIndex(CornerIndex ci) const {
+    return mesh_->CornerToPointId(ci);
+  }
+
+  // Returns the opposite corner in case the opposite triangle does not lie
+  // across an attribute seam. Otherwise return kInvalidCornerIndex.
+  CornerIndex GetOppositeCorner(CornerIndex ci) const {
+    const CornerIndex oci = corner_table_->Opposite(ci);
+    if (oci < 0) {
+      return kInvalidCornerIndex;
+    }
+    // Ensure the point ids are same on both sides of the shared edge between
+    // the triangles.
+    if (CornerToPointIndex(corner_table_->Next(ci)) !=
+        CornerToPointIndex(corner_table_->Previous(oci))) {
+      return kInvalidCornerIndex;
+    }
+    if (CornerToPointIndex(corner_table_->Previous(ci)) !=
+        CornerToPointIndex(corner_table_->Next(oci))) {
+      return kInvalidCornerIndex;
+    }
+    return oci;
+  }
+
+  void GenerateStripsFromCorner(int local_strip_id, CornerIndex ci);
+
+  const Mesh *mesh_;
+  std::unique_ptr<CornerTable> corner_table_;
+
+  // Store strip faces for each of three possible directions from a given face.
+  std::vector<FaceIndex> strip_faces_[3];
+  // Start corner for each direction of the strip containing the processed face.
+  CornerIndex strip_start_corners_[3];
+  IndexTypeVector<FaceIndex, bool> is_face_visited_;
+  // The number of strips generated by this method.
+  int num_strips_;
+  // The number of encoded triangles.
+  int num_encoded_faces_;
+  // Last encoded point.
+  PointIndex last_encoded_point_;
+};
+
+template <typename OutputIteratorT, typename IndexTypeT>
+bool MeshStripifier::GenerateTriangleStripsWithPrimitiveRestart(
+    const Mesh &mesh, IndexTypeT primitive_restart_index,
+    OutputIteratorT out_it) {
+  if (!Prepare(mesh)) {
+    return false;
+  }
+
+  // Go over all faces and generate strips from the first unvisited one.
+  for (FaceIndex fi(0); fi < mesh.num_faces(); ++fi) {
+    if (is_face_visited_[fi]) {
+      continue;
+    }
+
+    const int longest_strip_id = FindLongestStripFromFace(fi);
+
+    // Separate triangle strips with the primitive restart index.
+    if (num_strips_ > 0) {
+      *out_it++ = primitive_restart_index;
+    }
+
+    StoreStrip(longest_strip_id, out_it);
+  }
+
+  return true;
+}
+
+template <typename OutputIteratorT>
+bool MeshStripifier::GenerateTriangleStripsWithDegenerateTriangles(
+    const Mesh &mesh, OutputIteratorT out_it) {
+  if (!Prepare(mesh)) {
+    return false;
+  }
+
+  // Go over all faces and generate strips from the first unvisited one.
+  for (FaceIndex fi(0); fi < mesh.num_faces(); ++fi) {
+    if (is_face_visited_[fi]) {
+      continue;
+    }
+
+    const int longest_strip_id = FindLongestStripFromFace(fi);
+
+    // Separate triangle strips by degenerate triangles. There will be either
+    // three or four degenerate triangles inserted based on the number of
+    // triangles that are already encoded in the output strip (three degenerate
+    // triangles for even number of existing triangles, four degenerate
+    // triangles for odd number of triangles).
+    if (num_strips_ > 0) {
+      // Duplicate last encoded index (first degenerate face).
+      *out_it++ = last_encoded_point_.value();
+
+      // Connect it to the start point of the new triangle strip (second
+      // degenerate face).
+      const CornerIndex new_start_corner =
+          strip_start_corners_[longest_strip_id];
+      const PointIndex new_start_point = CornerToPointIndex(new_start_corner);
+      *out_it++ = new_start_point.value();
+      num_encoded_faces_ += 2;
+      // If we have previously encoded number of faces we need to duplicate the
+      // point one more time to preserve the correct orientation of the next
+      // strip.
+      if (num_encoded_faces_ & 1) {
+        *out_it++ = new_start_point.value();
+        num_encoded_faces_ += 1;
+      }
+      // The last degenerate face will be added implicitly in the StoreStrip()
+      // function below as the first point index is going to be encoded there
+      // again.
+    }
+
+    StoreStrip(longest_strip_id, out_it);
+  }
+
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_MESH_STRIPIFIER_H_
diff --git a/engine/inc/draco/mesh/triangle_soup_mesh_builder.h b/engine/inc/draco/mesh/triangle_soup_mesh_builder.h
new file mode 100644
index 00000000..89466e1d
--- /dev/null
+++ b/engine/inc/draco/mesh/triangle_soup_mesh_builder.h
@@ -0,0 +1,63 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_MESH_TRIANGLE_SOUP_MESH_BUILDER_H_
+#define DRACO_MESH_TRIANGLE_SOUP_MESH_BUILDER_H_
+
+#include "draco/draco_features.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Class for building meshes directly from attribute values that can be
+// specified for each face corner. All attributes are automatically
+// deduplicated.
+class TriangleSoupMeshBuilder {
+ public:
+  // Starts mesh building for a given number of faces.
+  // TODO(ostava): Currently it's necessary to select the correct number of
+  // faces upfront. This should be generalized, but it will require us to
+  // rewrite our attribute resizing functions.
+  void Start(int num_faces);
+
+  // Adds an empty attribute to the mesh. Returns the new attribute's id.
+  int AddAttribute(GeometryAttribute::Type attribute_type,
+                   int8_t num_components, DataType data_type);
+
+  // Sets values for a given attribute on all corners of a given face.
+  void SetAttributeValuesForFace(int att_id, FaceIndex face_id,
+                                 const void *corner_value_0,
+                                 const void *corner_value_1,
+                                 const void *corner_value_2);
+
+  // Sets value for a per-face attribute. If all faces of a given attribute are
+  // set with this method, the attribute will be marked as per-face, otherwise
+  // it will be marked as per-corner attribute.
+  void SetPerFaceAttributeValueForFace(int att_id, FaceIndex face_id,
+                                       const void *value);
+
+  // Finalizes the mesh or returns nullptr on error.
+  // Once this function is called, the builder becomes invalid and cannot be
+  // used until the method Start() is called again.
+  std::unique_ptr<Mesh> Finalize();
+
+ private:
+  std::vector<int8_t> attribute_element_types_;
+
+  std::unique_ptr<Mesh> mesh_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_TRIANGLE_SOUP_MESH_BUILDER_H_
diff --git a/engine/inc/draco/mesh/valence_cache.h b/engine/inc/draco/mesh/valence_cache.h
new file mode 100644
index 00000000..3540377d
--- /dev/null
+++ b/engine/inc/draco/mesh/valence_cache.h
@@ -0,0 +1,142 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_MESH_VALENCE_CACHE_H_
+#define DRACO_MESH_VALENCE_CACHE_H_
+
+#include "draco/attributes/geometry_indices.h"
+#include "draco/core/draco_index_type_vector.h"
+#include "draco/core/macros.h"
+
+namespace draco {
+
+// ValenceCache provides support for the caching of valences off of some kind of
+// CornerTable 'type' of class.
+// No valences should be queried before Caching is
+// performed and values should be removed/recached when changes to the
+// underlying mesh are taking place.
+
+template <class CornerTableT>
+class ValenceCache {
+  const CornerTableT &table_;
+
+ public:
+  explicit ValenceCache(const CornerTableT &table) : table_(table) {}
+
+  // Do not call before CacheValences() / CacheValencesInaccurate().
+  inline int8_t ValenceFromCacheInaccurate(CornerIndex c) const {
+    if (c == kInvalidCornerIndex) {
+      return -1;
+    }
+    return ValenceFromCacheInaccurate(table_.Vertex(c));
+  }
+  inline int32_t ValenceFromCache(CornerIndex c) const {
+    if (c == kInvalidCornerIndex) {
+      return -1;
+    }
+    return ValenceFromCache(table_.Vertex(c));
+  }
+
+  inline int32_t ConfidentValenceFromCache(VertexIndex v) const {
+    DRACO_DCHECK_LT(v.value(), table_.num_vertices());
+    DRACO_DCHECK_EQ(vertex_valence_cache_32_bit_.size(), table_.num_vertices());
+    return vertex_valence_cache_32_bit_[v];
+  }
+
+  // Collect the valence for all vertices so they can be reused later.  The
+  // 'inaccurate' versions of this family of functions clips the true valence
+  // of the vertices to 8 signed bits as a space optimization.  This clipping
+  // will lead to occasionally wrong results.  If accurate results are required
+  // under all circumstances, do not use the 'inaccurate' version or else
+  // use it and fetch the correct result in the event the value appears clipped.
+  // The topology of the mesh should be a constant when Valence Cache functions
+  // are being used.  Modification of the mesh while cache(s) are filled will
+  // not guarantee proper results on subsequent calls unless they are rebuilt.
+  void CacheValencesInaccurate() const {
+    if (vertex_valence_cache_8_bit_.size() == 0) {
+      const VertexIndex vertex_count = VertexIndex(table_.num_vertices());
+      vertex_valence_cache_8_bit_.resize(vertex_count.value());
+      for (VertexIndex v = VertexIndex(0); v < vertex_count; v += 1) {
+        vertex_valence_cache_8_bit_[v] = static_cast<int8_t>(
+            (std::min)(static_cast<int32_t>(std::numeric_limits<int8_t>::max()),
+                       table_.Valence(v)));
+      }
+    }
+  }
+  void CacheValences() const {
+    if (vertex_valence_cache_32_bit_.size() == 0) {
+      const VertexIndex vertex_count = VertexIndex(table_.num_vertices());
+      vertex_valence_cache_32_bit_.resize(vertex_count.value());
+      for (VertexIndex v = VertexIndex(0); v < vertex_count; v += 1) {
+        vertex_valence_cache_32_bit_[v] = table_.Valence(v);
+      }
+    }
+  }
+
+  inline int8_t ConfidentValenceFromCacheInaccurate(CornerIndex c) const {
+    DRACO_DCHECK_GE(c.value(), 0);
+    return ConfidentValenceFromCacheInaccurate(table_.ConfidentVertex(c));
+  }
+  inline int32_t ConfidentValenceFromCache(CornerIndex c) const {
+    DRACO_DCHECK_GE(c.value(), 0);
+    return ConfidentValenceFromCache(table_.ConfidentVertex(c));
+  }
+  inline int8_t ValenceFromCacheInaccurate(VertexIndex v) const {
+    DRACO_DCHECK_EQ(vertex_valence_cache_8_bit_.size(), table_.num_vertices());
+    if (v == kInvalidVertexIndex || v.value() >= table_.num_vertices()) {
+      return -1;
+    }
+    return ConfidentValenceFromCacheInaccurate(v);
+  }
+  inline int8_t ConfidentValenceFromCacheInaccurate(VertexIndex v) const {
+    DRACO_DCHECK_LT(v.value(), table_.num_vertices());
+    DRACO_DCHECK_EQ(vertex_valence_cache_8_bit_.size(), table_.num_vertices());
+    return vertex_valence_cache_8_bit_[v];
+  }
+
+  // TODO(draco-eng) Add unit tests for ValenceCache functions.
+  inline int32_t ValenceFromCache(VertexIndex v) const {
+    DRACO_DCHECK_EQ(vertex_valence_cache_32_bit_.size(), table_.num_vertices());
+    if (v == kInvalidVertexIndex || v.value() >= table_.num_vertices()) {
+      return -1;
+    }
+    return ConfidentValenceFromCache(v);
+  }
+
+  // Clear the cache of valences and deallocate the memory.
+  void ClearValenceCacheInaccurate() const {
+    vertex_valence_cache_8_bit_.clear();
+    // Force erasure.
+    IndexTypeVector<VertexIndex, int8_t>().swap(vertex_valence_cache_8_bit_);
+  }
+  void ClearValenceCache() const {
+    vertex_valence_cache_32_bit_.clear();
+    // Force erasure.
+    IndexTypeVector<VertexIndex, int32_t>().swap(vertex_valence_cache_32_bit_);
+  }
+
+  bool IsCacheEmpty() const {
+    return vertex_valence_cache_8_bit_.size() == 0 &&
+           vertex_valence_cache_32_bit_.size() == 0;
+  }
+
+ private:
+  // Retain valences and clip them to char size.
+  mutable IndexTypeVector<VertexIndex, int8_t> vertex_valence_cache_8_bit_;
+  mutable IndexTypeVector<VertexIndex, int32_t> vertex_valence_cache_32_bit_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_VALENCE_CACHE_H_
diff --git a/engine/inc/draco/metadata/geometry_metadata.h b/engine/inc/draco/metadata/geometry_metadata.h
new file mode 100644
index 00000000..ec7ecb9e
--- /dev/null
+++ b/engine/inc/draco/metadata/geometry_metadata.h
@@ -0,0 +1,140 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_METADATA_GEOMETRY_METADATA_H_
+#define DRACO_METADATA_GEOMETRY_METADATA_H_
+
+#include "draco/metadata/metadata.h"
+
+namespace draco {
+
+// Class for representing specifically metadata of attributes. It must have an
+// attribute id which should be identical to it's counterpart attribute in
+// the point cloud it belongs to.
+class AttributeMetadata : public Metadata {
+ public:
+  AttributeMetadata() : att_unique_id_(0) {}
+  explicit AttributeMetadata(const Metadata &metadata)
+      : Metadata(metadata), att_unique_id_(0) {}
+
+  void set_att_unique_id(uint32_t att_unique_id) {
+    att_unique_id_ = att_unique_id;
+  }
+  // The unique id of the attribute that this metadata belongs to.
+  uint32_t att_unique_id() const { return att_unique_id_; }
+
+ private:
+  uint32_t att_unique_id_;
+
+  friend struct AttributeMetadataHasher;
+  friend class PointCloud;
+};
+
+// Functor for computing a hash from data stored in a AttributeMetadata class.
+struct AttributeMetadataHasher {
+  size_t operator()(const AttributeMetadata &metadata) const {
+    size_t hash = metadata.att_unique_id_;
+    MetadataHasher metadata_hasher;
+    hash = HashCombine(metadata_hasher(static_cast<const Metadata &>(metadata)),
+                       hash);
+    return hash;
+  }
+};
+
+// Class for representing the metadata for a point cloud. It could have a list
+// of attribute metadata.
+class GeometryMetadata : public Metadata {
+ public:
+  GeometryMetadata() {}
+  explicit GeometryMetadata(const Metadata &metadata) : Metadata(metadata) {}
+
+  const AttributeMetadata *GetAttributeMetadataByStringEntry(
+      const std::string &entry_name, const std::string &entry_value) const;
+  bool AddAttributeMetadata(std::unique_ptr<AttributeMetadata> att_metadata);
+
+  void DeleteAttributeMetadataByUniqueId(int32_t att_unique_id) {
+    if (att_unique_id < 0) {
+      return;
+    }
+    for (auto itr = att_metadatas_.begin(); itr != att_metadatas_.end();
+         ++itr) {
+      if (itr->get()->att_unique_id() == static_cast<uint32_t>(att_unique_id)) {
+        att_metadatas_.erase(itr);
+        return;
+      }
+    }
+  }
+
+  const AttributeMetadata *GetAttributeMetadataByUniqueId(
+      int32_t att_unique_id) const {
+    if (att_unique_id < 0) {
+      return nullptr;
+    }
+
+    // TODO(draco-eng): Consider using unordered_map instead of vector to store
+    // attribute metadata.
+    for (auto &&att_metadata : att_metadatas_) {
+      if (att_metadata->att_unique_id() ==
+          static_cast<uint32_t>(att_unique_id)) {
+        return att_metadata.get();
+      }
+    }
+    return nullptr;
+  }
+
+  AttributeMetadata *attribute_metadata(int32_t att_unique_id) {
+    if (att_unique_id < 0) {
+      return nullptr;
+    }
+
+    // TODO(draco-eng): Consider use unordered_map instead of vector to store
+    // attribute metadata.
+    for (auto &&att_metadata : att_metadatas_) {
+      if (att_metadata->att_unique_id() ==
+          static_cast<uint32_t>(att_unique_id)) {
+        return att_metadata.get();
+      }
+    }
+    return nullptr;
+  }
+
+  const std::vector<std::unique_ptr<AttributeMetadata>> &attribute_metadatas()
+      const {
+    return att_metadatas_;
+  }
+
+ private:
+  std::vector<std::unique_ptr<AttributeMetadata>> att_metadatas_;
+
+  friend struct GeometryMetadataHasher;
+};
+
+// Functor for computing a hash from data stored in a GeometryMetadata class.
+struct GeometryMetadataHasher {
+  size_t operator()(const GeometryMetadata &metadata) const {
+    size_t hash = metadata.att_metadatas_.size();
+    AttributeMetadataHasher att_metadata_hasher;
+    for (auto &&att_metadata : metadata.att_metadatas_) {
+      hash = HashCombine(att_metadata_hasher(*att_metadata), hash);
+    }
+    MetadataHasher metadata_hasher;
+    hash = HashCombine(metadata_hasher(static_cast<const Metadata &>(metadata)),
+                       hash);
+    return hash;
+  }
+};
+
+}  // namespace draco
+
+#endif  // THIRD_PARTY_DRACO_METADATA_GEOMETRY_METADATA_H_
diff --git a/engine/inc/draco/metadata/metadata.h b/engine/inc/draco/metadata/metadata.h
new file mode 100644
index 00000000..56d05e46
--- /dev/null
+++ b/engine/inc/draco/metadata/metadata.h
@@ -0,0 +1,208 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_METADATA_METADATA_H_
+#define DRACO_METADATA_METADATA_H_
+
+#include <cstring>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "draco/core/hash_utils.h"
+
+namespace draco {
+
+// Class for storing a value of an entry in Metadata. Internally it is
+// represented by a buffer of data. It can be accessed by various data types,
+// e.g. int, float, binary data or string.
+class EntryValue {
+ public:
+  template <typename DataTypeT>
+  explicit EntryValue(const DataTypeT &data) {
+    const size_t data_type_size = sizeof(DataTypeT);
+    data_.resize(data_type_size);
+    memcpy(&data_[0], &data, data_type_size);
+  }
+
+  template <typename DataTypeT>
+  explicit EntryValue(const std::vector<DataTypeT> &data) {
+    const size_t total_size = sizeof(DataTypeT) * data.size();
+    data_.resize(total_size);
+    memcpy(&data_[0], &data[0], total_size);
+  }
+
+  EntryValue(const EntryValue &value);
+  explicit EntryValue(const std::string &value);
+
+  template <typename DataTypeT>
+  bool GetValue(DataTypeT *value) const {
+    const size_t data_type_size = sizeof(DataTypeT);
+    if (data_type_size != data_.size()) {
+      return false;
+    }
+    memcpy(value, &data_[0], data_type_size);
+    return true;
+  }
+
+  template <typename DataTypeT>
+  bool GetValue(std::vector<DataTypeT> *value) const {
+    if (data_.empty()) {
+      return false;
+    }
+    const size_t data_type_size = sizeof(DataTypeT);
+    if (data_.size() % data_type_size != 0) {
+      return false;
+    }
+    value->resize(data_.size() / data_type_size);
+    memcpy(&value->at(0), &data_[0], data_.size());
+    return true;
+  }
+
+  const std::vector<uint8_t> &data() const { return data_; }
+
+ private:
+  std::vector<uint8_t> data_;
+
+  friend struct EntryValueHasher;
+};
+
+// Functor for computing a hash from data stored within an EntryValue.
+struct EntryValueHasher {
+  size_t operator()(const EntryValue &ev) const {
+    size_t hash = ev.data_.size();
+    for (size_t i = 0; i < ev.data_.size(); ++i) {
+      hash = HashCombine(ev.data_[i], hash);
+    }
+    return hash;
+  }
+};
+
+// Class for holding generic metadata. It has a list of entries which consist of
+// an entry name and an entry value. Each Metadata could also have nested
+// metadata.
+class Metadata {
+ public:
+  Metadata() {}
+  Metadata(const Metadata &metadata);
+  // In theory, we support all types of data as long as it could be serialized
+  // to binary data. We provide the following functions for inserting and
+  // accessing entries of common data types. For now, developers need to know
+  // the type of entries they are requesting.
+  void AddEntryInt(const std::string &name, int32_t value);
+
+  // Returns false if Metadata does not contain an entry with a key of |name|.
+  // This function does not guarantee that entry's type is int32_t.
+  bool GetEntryInt(const std::string &name, int32_t *value) const;
+
+  void AddEntryIntArray(const std::string &name,
+                        const std::vector<int32_t> &value);
+
+  // Returns false if Metadata does not contain an entry with a key of |name|.
+  // This function does not guarantee that entry's type is a vector of int32_t.
+  bool GetEntryIntArray(const std::string &name,
+                        std::vector<int32_t> *value) const;
+
+  void AddEntryDouble(const std::string &name, double value);
+
+  // Returns false if Metadata does not contain an entry with a key of |name|.
+  // This function does not guarantee that entry's type is double.
+  bool GetEntryDouble(const std::string &name, double *value) const;
+
+  void AddEntryDoubleArray(const std::string &name,
+                           const std::vector<double> &value);
+
+  // Returns false if Metadata does not contain an entry with a key of |name|.
+  // This function does not guarantee that entry's type is a vector of double.
+  bool GetEntryDoubleArray(const std::string &name,
+                           std::vector<double> *value) const;
+
+  void AddEntryString(const std::string &name, const std::string &value);
+
+  // Returns false if Metadata does not contain an entry with a key of |name|.
+  // This function does not guarantee that entry's type is std::string.
+  bool GetEntryString(const std::string &name, std::string *value) const;
+
+  // Add a blob of data as an entry.
+  void AddEntryBinary(const std::string &name,
+                      const std::vector<uint8_t> &value);
+
+  // Returns false if Metadata does not contain an entry with a key of |name|.
+  // This function does not guarantee that entry's type is a vector of uint8_t.
+  bool GetEntryBinary(const std::string &name,
+                      std::vector<uint8_t> *value) const;
+
+  bool AddSubMetadata(const std::string &name,
+                      std::unique_ptr<Metadata> sub_metadata);
+  const Metadata *GetSubMetadata(const std::string &name) const;
+
+  void RemoveEntry(const std::string &name);
+
+  int num_entries() const { return static_cast<int>(entries_.size()); }
+  const std::map<std::string, EntryValue> &entries() const { return entries_; }
+  const std::map<std::string, std::unique_ptr<Metadata>> &sub_metadatas()
+      const {
+    return sub_metadatas_;
+  }
+
+ private:
+  // Make this function private to avoid adding undefined data types.
+  template <typename DataTypeT>
+  void AddEntry(const std::string &entry_name, const DataTypeT &entry_value) {
+    const auto itr = entries_.find(entry_name);
+    if (itr != entries_.end()) {
+      entries_.erase(itr);
+    }
+    entries_.insert(std::make_pair(entry_name, EntryValue(entry_value)));
+  }
+
+  // Make this function private to avoid adding undefined data types.
+  template <typename DataTypeT>
+  bool GetEntry(const std::string &entry_name, DataTypeT *entry_value) const {
+    const auto itr = entries_.find(entry_name);
+    if (itr == entries_.end()) {
+      return false;
+    }
+    return itr->second.GetValue(entry_value);
+  }
+
+  std::map<std::string, EntryValue> entries_;
+  std::map<std::string, std::unique_ptr<Metadata>> sub_metadatas_;
+
+  friend struct MetadataHasher;
+};
+
+// Functor for computing a hash from data stored within a metadata class.
+struct MetadataHasher {
+  size_t operator()(const Metadata &metadata) const {
+    size_t hash =
+        HashCombine(metadata.entries_.size(), metadata.sub_metadatas_.size());
+    EntryValueHasher entry_value_hasher;
+    for (const auto &entry : metadata.entries_) {
+      hash = HashCombine(entry.first, hash);
+      hash = HashCombine(entry_value_hasher(entry.second), hash);
+    }
+    MetadataHasher metadata_hasher;
+    for (auto &&sub_metadata : metadata.sub_metadatas_) {
+      hash = HashCombine(sub_metadata.first, hash);
+      hash = HashCombine(metadata_hasher(*sub_metadata.second), hash);
+    }
+    return hash;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_METADATA_METADATA_H_
diff --git a/engine/inc/draco/metadata/metadata_decoder.h b/engine/inc/draco/metadata/metadata_decoder.h
new file mode 100644
index 00000000..b4c4943f
--- /dev/null
+++ b/engine/inc/draco/metadata/metadata_decoder.h
@@ -0,0 +1,42 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_METADATA_METADATA_DECODER_H_
+#define DRACO_METADATA_METADATA_DECODER_H_
+
+#include "draco/core/decoder_buffer.h"
+#include "draco/metadata/geometry_metadata.h"
+#include "draco/metadata/metadata.h"
+
+namespace draco {
+
+// Class for decoding the metadata.
+class MetadataDecoder {
+ public:
+  MetadataDecoder();
+  bool DecodeMetadata(DecoderBuffer *in_buffer, Metadata *metadata);
+  bool DecodeGeometryMetadata(DecoderBuffer *in_buffer,
+                              GeometryMetadata *metadata);
+
+ private:
+  bool DecodeMetadata(Metadata *metadata);
+  bool DecodeEntries(Metadata *metadata);
+  bool DecodeEntry(Metadata *metadata);
+  bool DecodeName(std::string *name);
+
+  DecoderBuffer *buffer_;
+};
+}  // namespace draco
+
+#endif  // DRACO_METADATA_METADATA_DECODER_H_
diff --git a/engine/inc/draco/metadata/metadata_encoder.h b/engine/inc/draco/metadata/metadata_encoder.h
new file mode 100644
index 00000000..5bce5d5b
--- /dev/null
+++ b/engine/inc/draco/metadata/metadata_encoder.h
@@ -0,0 +1,41 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_METADATA_METADATA_ENCODER_H_
+#define DRACO_METADATA_METADATA_ENCODER_H_
+
+#include "draco/core/encoder_buffer.h"
+#include "draco/metadata/geometry_metadata.h"
+#include "draco/metadata/metadata.h"
+
+namespace draco {
+
+// Class for encoding metadata. It could encode either base Metadata class or
+// a metadata of a geometry, e.g. a point cloud.
+class MetadataEncoder {
+ public:
+  MetadataEncoder() {}
+
+  bool EncodeGeometryMetadata(EncoderBuffer *out_buffer,
+                              const GeometryMetadata *metadata);
+  bool EncodeMetadata(EncoderBuffer *out_buffer, const Metadata *metadata);
+
+ private:
+  bool EncodeAttributeMetadata(EncoderBuffer *out_buffer,
+                               const AttributeMetadata *metadata);
+  bool EncodeString(EncoderBuffer *out_buffer, const std::string &str);
+};
+}  // namespace draco
+
+#endif  // DRACO_METADATA_METADATA_ENCODER_H_
diff --git a/engine/inc/draco/point_cloud/point_cloud.h b/engine/inc/draco/point_cloud/point_cloud.h
new file mode 100644
index 00000000..d11bd47a
--- /dev/null
+++ b/engine/inc/draco/point_cloud/point_cloud.h
@@ -0,0 +1,244 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_POINT_CLOUD_POINT_CLOUD_H_
+#define DRACO_POINT_CLOUD_POINT_CLOUD_H_
+
+#include "draco/attributes/point_attribute.h"
+#include "draco/core/bounding_box.h"
+#include "draco/core/vector_d.h"
+#include "draco/draco_features.h"
+#include "draco/metadata/geometry_metadata.h"
+
+namespace draco {
+
+// PointCloud is a collection of n-dimensional points that are described by a
+// set of PointAttributes that can represent data such as positions or colors
+// of individual points (see point_attribute.h).
+class PointCloud {
+ public:
+  PointCloud();
+  virtual ~PointCloud() = default;
+
+  // Returns the number of named attributes of a given type.
+  int32_t NumNamedAttributes(GeometryAttribute::Type type) const;
+
+  // Returns attribute id of the first named attribute with a given type or -1
+  // when the attribute is not used by the point cloud.
+  int32_t GetNamedAttributeId(GeometryAttribute::Type type) const;
+
+  // Returns the id of the i-th named attribute of a given type.
+  int32_t GetNamedAttributeId(GeometryAttribute::Type type, int i) const;
+
+  // Returns the first named attribute of a given type or nullptr if the
+  // attribute is not used by the point cloud.
+  const PointAttribute *GetNamedAttribute(GeometryAttribute::Type type) const;
+
+  // Returns the i-th named attribute of a given type.
+  const PointAttribute *GetNamedAttribute(GeometryAttribute::Type type,
+                                          int i) const;
+
+  // Returns the named attribute of a given unique id.
+  const PointAttribute *GetNamedAttributeByUniqueId(
+      GeometryAttribute::Type type, uint32_t id) const;
+
+  // Returns the attribute of a given unique id.
+  const PointAttribute *GetAttributeByUniqueId(uint32_t id) const;
+  int32_t GetAttributeIdByUniqueId(uint32_t unique_id) const;
+
+  int32_t num_attributes() const {
+    return static_cast<int32_t>(attributes_.size());
+  }
+  const PointAttribute *attribute(int32_t att_id) const {
+    DRACO_DCHECK_LE(0, att_id);
+    DRACO_DCHECK_LT(att_id, static_cast<int32_t>(attributes_.size()));
+    return attributes_[att_id].get();
+  }
+
+  // Returned attribute can be modified, but it's caller's responsibility to
+  // maintain the attribute's consistency with draco::PointCloud.
+  PointAttribute *attribute(int32_t att_id) {
+    DRACO_DCHECK_LE(0, att_id);
+    DRACO_DCHECK_LT(att_id, static_cast<int32_t>(attributes_.size()));
+    return attributes_[att_id].get();
+  }
+
+  // Adds a new attribute to the point cloud.
+  // Returns the attribute id.
+  int AddAttribute(std::unique_ptr<PointAttribute> pa);
+
+  // Creates and adds a new attribute to the point cloud. The attribute has
+  // properties derived from the provided GeometryAttribute |att|.
+  // If |identity_mapping| is set to true, the attribute will use identity
+  // mapping between point indices and attribute value indices (i.e., each
+  // point has a unique attribute value). If |identity_mapping| is false, the
+  // mapping between point indices and attribute value indices is set to
+  // explicit, and it needs to be initialized manually using the
+  // PointAttribute::SetPointMapEntry() method. |num_attribute_values| can be
+  // used to specify the number of attribute values that are going to be
+  // stored in the newly created attribute. Returns attribute id of the newly
+  // created attribute or -1 in case of failure.
+  int AddAttribute(const GeometryAttribute &att, bool identity_mapping,
+                   AttributeValueIndex::ValueType num_attribute_values);
+
+  // Creates and returns a new attribute or nullptr in case of failure. This
+  // method is similar to AddAttribute(), except that it returns the new
+  // attribute instead of adding it to the point cloud.
+  std::unique_ptr<PointAttribute> CreateAttribute(
+      const GeometryAttribute &att, bool identity_mapping,
+      AttributeValueIndex::ValueType num_attribute_values) const;
+
+  // Assigns an attribute id to a given PointAttribute. If an attribute with
+  // the same attribute id already exists, it is deleted.
+  virtual void SetAttribute(int att_id, std::unique_ptr<PointAttribute> pa);
+
+  // Deletes an attribute with specified attribute id. Note that this changes
+  // attribute ids of all subsequent attributes.
+  virtual void DeleteAttribute(int att_id);
+
+#ifdef DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED
+  // Deduplicates all attribute values (all attribute entries with the same
+  // value are merged into a single entry).
+  virtual bool DeduplicateAttributeValues();
+#endif
+
+#ifdef DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED
+  // Removes duplicate point ids (two point ids are duplicate when all of their
+  // attributes are mapped to the same entry ids).
+  virtual void DeduplicatePointIds();
+#endif
+
+  // Get bounding box.
+  BoundingBox ComputeBoundingBox() const;
+
+  // Add metadata.
+  void AddMetadata(std::unique_ptr<GeometryMetadata> metadata) {
+    metadata_ = std::move(metadata);
+  }
+
+  // Add metadata for an attribute.
+  void AddAttributeMetadata(int32_t att_id,
+                            std::unique_ptr<AttributeMetadata> metadata) {
+    if (!metadata_) {
+      metadata_ = std::unique_ptr<GeometryMetadata>(new GeometryMetadata());
+    }
+    const int32_t att_unique_id = attribute(att_id)->unique_id();
+    metadata->set_att_unique_id(att_unique_id);
+    metadata_->AddAttributeMetadata(std::move(metadata));
+  }
+
+  const AttributeMetadata *GetAttributeMetadataByAttributeId(
+      int32_t att_id) const {
+    if (metadata_ == nullptr) {
+      return nullptr;
+    }
+    const uint32_t unique_id = attribute(att_id)->unique_id();
+    return metadata_->GetAttributeMetadataByUniqueId(unique_id);
+  }
+
+  // Returns the attribute metadata that has the requested metadata entry.
+  const AttributeMetadata *GetAttributeMetadataByStringEntry(
+      const std::string &name, const std::string &value) const {
+    if (metadata_ == nullptr) {
+      return nullptr;
+    }
+    return metadata_->GetAttributeMetadataByStringEntry(name, value);
+  }
+
+  // Returns the first attribute that has the requested metadata entry.
+  int GetAttributeIdByMetadataEntry(const std::string &name,
+                                    const std::string &value) const {
+    if (metadata_ == nullptr) {
+      return -1;
+    }
+    const AttributeMetadata *att_metadata =
+        metadata_->GetAttributeMetadataByStringEntry(name, value);
+    if (!att_metadata) {
+      return -1;
+    }
+    return GetAttributeIdByUniqueId(att_metadata->att_unique_id());
+  }
+
+  // Get a const pointer of the metadata of the point cloud.
+  const GeometryMetadata *GetMetadata() const { return metadata_.get(); }
+
+  // Get a pointer to the metadata of the point cloud.
+  GeometryMetadata *metadata() { return metadata_.get(); }
+
+  // Returns the number of n-dimensional points stored within the point cloud.
+  PointIndex::ValueType num_points() const { return num_points_; }
+
+  // Sets the number of points. It's the caller's responsibility to ensure the
+  // new number is valid with respect to the PointAttributes stored in the point
+  // cloud.
+  void set_num_points(PointIndex::ValueType num) { num_points_ = num; }
+
+ protected:
+#ifdef DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED
+  // Applies id mapping of deduplicated points (called by DeduplicatePointIds).
+  virtual void ApplyPointIdDeduplication(
+      const IndexTypeVector<PointIndex, PointIndex> &id_map,
+      const std::vector<PointIndex> &unique_point_ids);
+#endif
+
+ private:
+  // Metadata for the point cloud.
+  std::unique_ptr<GeometryMetadata> metadata_;
+
+  // Attributes describing the point cloud.
+  std::vector<std::unique_ptr<PointAttribute>> attributes_;
+
+  // Ids of named attributes of the given type.
+  std::vector<int32_t>
+      named_attribute_index_[GeometryAttribute::NAMED_ATTRIBUTES_COUNT];
+
+  // The number of n-dimensional points. All point attribute values are stored
+  // in corresponding PointAttribute instances in the |attributes_| array.
+  PointIndex::ValueType num_points_;
+
+  friend struct PointCloudHasher;
+};
+
+// Functor for computing a hash from data stored within a point cloud.
+// Note that this can be quite slow. Two point clouds will have the same hash
+// only when all points have the same order and when all attribute values are
+// exactly the same.
+struct PointCloudHasher {
+  size_t operator()(const PointCloud &pc) const {
+    size_t hash = pc.num_points_;
+    hash = HashCombine(pc.attributes_.size(), hash);
+    for (int i = 0; i < GeometryAttribute::NAMED_ATTRIBUTES_COUNT; ++i) {
+      hash = HashCombine(pc.named_attribute_index_[i].size(), hash);
+      for (int j = 0; j < static_cast<int>(pc.named_attribute_index_[i].size());
+           ++j) {
+        hash = HashCombine(pc.named_attribute_index_[i][j], hash);
+      }
+    }
+    // Hash attributes.
+    for (int i = 0; i < static_cast<int>(pc.attributes_.size()); ++i) {
+      PointAttributeHasher att_hasher;
+      hash = HashCombine(att_hasher(*pc.attributes_[i]), hash);
+    }
+    // Hash metadata.
+    GeometryMetadataHasher metadata_hasher;
+    if (pc.metadata_) {
+      hash = HashCombine(metadata_hasher(*pc.metadata_), hash);
+    }
+    return hash;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_POINT_CLOUD_POINT_CLOUD_H_
diff --git a/engine/inc/draco/point_cloud/point_cloud_builder.h b/engine/inc/draco/point_cloud/point_cloud_builder.h
new file mode 100644
index 00000000..cf55a728
--- /dev/null
+++ b/engine/inc/draco/point_cloud/point_cloud_builder.h
@@ -0,0 +1,80 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_POINT_CLOUD_POINT_CLOUD_BUILDER_H_
+#define DRACO_POINT_CLOUD_POINT_CLOUD_BUILDER_H_
+
+#include "draco/point_cloud/point_cloud.h"
+
+namespace draco {
+
+// A helper class for constructing PointCloud instances from other data sources.
+// Usage:
+//   PointCloudBuilder builder;
+//   // Initialize the builder for a given number of points (required).
+//   builder.Start(num_points);
+//   // Specify desired attributes.
+//   int pos_att_id =
+//       builder.AddAttribute(GeometryAttribute::POSITION, 3, DT_FLOAT32);
+//   // Add attribute values.
+//   for (PointIndex i(0); i < num_points; ++i) {
+//     builder.SetAttributeValueForPoint(pos_att_id, i, input_pos[i.value()]);
+//   }
+//   // Get the final PointCloud.
+//   constexpr bool deduplicate_points = false;
+//   std::unique_ptr<PointCloud> pc = builder.Finalize(deduplicate_points);
+
+class PointCloudBuilder {
+ public:
+  PointCloudBuilder();
+
+  // Starts collecting point cloud data.
+  // The behavior of other functions is undefined before this method is called.
+  void Start(PointIndex::ValueType num_points);
+
+  int AddAttribute(GeometryAttribute::Type attribute_type,
+                   int8_t num_components, DataType data_type);
+
+  // Sets attribute value for a specific point.
+  // |attribute_value| must contain data in the format specified by the
+  // AddAttribute method.
+  void SetAttributeValueForPoint(int att_id, PointIndex point_index,
+                                 const void *attribute_value);
+
+  // Sets attribute values for all points. All the values must be stored in the
+  // input |attribute_values| buffer. |stride| can be used to define the byte
+  // offset between two consecutive attribute values. If |stride| is set to 0,
+  // the stride is automatically computed based on the format of the given
+  // attribute.
+  void SetAttributeValuesForAllPoints(int att_id, const void *attribute_values,
+                                      int stride);
+
+  // Finalizes the PointCloud or returns nullptr on error.
+  // If |deduplicate_points| is set to true, the following happens:
+  //   1. Attribute values with duplicate entries are deduplicated.
+  //   2. Point ids that are mapped to the same attribute values are
+  //      deduplicated.
+  // Therefore, if |deduplicate_points| is true the final PointCloud can have
+  // a different number of point from the value specified in the Start method.
+  // Once this function is called, the builder becomes invalid and cannot be
+  // used until the method Start() is called again.
+  std::unique_ptr<PointCloud> Finalize(bool deduplicate_points);
+
+ private:
+  std::unique_ptr<PointCloud> point_cloud_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_POINT_CLOUD_POINT_CLOUD_BUILDER_H_
diff --git a/engine/inc/draco/unity/draco_unity_plugin.h b/engine/inc/draco/unity/draco_unity_plugin.h
new file mode 100644
index 00000000..2f878889
--- /dev/null
+++ b/engine/inc/draco/unity/draco_unity_plugin.h
@@ -0,0 +1,154 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_UNITY_DRACO_UNITY_PLUGIN_H_
+#define DRACO_UNITY_DRACO_UNITY_PLUGIN_H_
+
+#include "draco/attributes/geometry_attribute.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/decode.h"
+#include "draco/core/draco_types.h"
+
+#ifdef DRACO_UNITY_PLUGIN
+
+// If compiling with Visual Studio.
+#if defined(_MSC_VER)
+#define EXPORT_API __declspec(dllexport)
+#else
+// Other platforms don't need this.
+#define EXPORT_API
+#endif  // defined(_MSC_VER)
+
+namespace draco {
+
+extern "C" {
+
+// Struct representing Draco attribute data within Unity.
+struct EXPORT_API DracoData {
+  DracoData() : data_type(DT_INVALID), data(nullptr) {}
+
+  DataType data_type;
+  void *data;
+};
+
+// Struct representing a Draco attribute within Unity.
+struct EXPORT_API DracoAttribute {
+  DracoAttribute()
+      : attribute_type(GeometryAttribute::INVALID),
+        data_type(DT_INVALID),
+        num_components(0),
+        unique_id(0),
+        private_attribute(nullptr) {}
+
+  GeometryAttribute::Type attribute_type;
+  DataType data_type;
+  int num_components;
+  int unique_id;
+  const void *private_attribute;
+};
+
+// Struct representing a Draco mesh within Unity.
+struct EXPORT_API DracoMesh {
+  DracoMesh()
+      : num_faces(0),
+        num_vertices(0),
+        num_attributes(0),
+        private_mesh(nullptr) {}
+
+  int num_faces;
+  int num_vertices;
+  int num_attributes;
+  void *private_mesh;
+};
+
+// Release data associated with DracoMesh.
+void EXPORT_API ReleaseDracoMesh(DracoMesh **mesh_ptr);
+// Release data associated with DracoAttribute.
+void EXPORT_API ReleaseDracoAttribute(DracoAttribute **attr_ptr);
+// Release attribute data.
+void EXPORT_API ReleaseDracoData(DracoData **data_ptr);
+
+// Decodes compressed Draco mesh in |data| and returns |mesh|. On input, |mesh|
+// must be null. The returned |mesh| must be released with ReleaseDracoMesh.
+int EXPORT_API DecodeDracoMesh(char *data, unsigned int length,
+                               DracoMesh **mesh);
+
+// Returns |attribute| at |index| in |mesh|.  On input, |attribute| must be
+// null. The returned |attribute| must be released with ReleaseDracoAttribute.
+bool EXPORT_API GetAttribute(const DracoMesh *mesh, int index,
+                             DracoAttribute **attribute);
+// Returns |attribute| of |type| at |index| in |mesh|. E.g. If the mesh has
+// two texture coordinates then GetAttributeByType(mesh,
+// AttributeType.TEX_COORD, 1, &attr); will return the second TEX_COORD
+// attribute. On input, |attribute| must be null. The returned |attribute| must
+// be released with ReleaseDracoAttribute.
+bool EXPORT_API GetAttributeByType(const DracoMesh *mesh,
+                                   GeometryAttribute::Type type, int index,
+                                   DracoAttribute **attribute);
+// Returns |attribute| with |unique_id| in |mesh|. On input, |attribute| must be
+// null. The returned |attribute| must be released with ReleaseDracoAttribute.
+bool EXPORT_API GetAttributeByUniqueId(const DracoMesh *mesh, int unique_id,
+                                       DracoAttribute **attribute);
+// Returns the indices as well as the type of data in |indices|. On input,
+// |indices| must be null. The returned |indices| must be released with
+// ReleaseDracoData.
+bool EXPORT_API GetMeshIndices(const DracoMesh *mesh, DracoData **indices);
+// Returns the attribute data from attribute as well as the type of data in
+// |data|. On input, |data| must be null. The returned |data| must be released
+// with ReleaseDracoData.
+bool EXPORT_API GetAttributeData(const DracoMesh *mesh,
+                                 const DracoAttribute *attribute,
+                                 DracoData **data);
+
+// DracoToUnityMesh is deprecated.
+struct EXPORT_API DracoToUnityMesh {
+  DracoToUnityMesh()
+      : num_faces(0),
+        indices(nullptr),
+        num_vertices(0),
+        position(nullptr),
+        has_normal(false),
+        normal(nullptr),
+        has_texcoord(false),
+        texcoord(nullptr),
+        has_color(false),
+        color(nullptr) {}
+
+  int num_faces;
+  int *indices;
+  int num_vertices;
+  float *position;
+  bool has_normal;
+  float *normal;
+  bool has_texcoord;
+  float *texcoord;
+  bool has_color;
+  float *color;
+};
+
+// ReleaseUnityMesh is deprecated.
+void EXPORT_API ReleaseUnityMesh(DracoToUnityMesh **mesh_ptr);
+
+// To use this function, you do not allocate memory for |tmp_mesh|, just
+// define and pass a null pointer. Otherwise there will be memory leak.
+// DecodeMeshForUnity is deprecated.
+int EXPORT_API DecodeMeshForUnity(char *data, unsigned int length,
+                                  DracoToUnityMesh **tmp_mesh);
+}  // extern "C"
+
+}  // namespace draco
+
+#endif  // DRACO_UNITY_PLUGIN
+
+#endif  // DRACO_UNITY_DRACO_UNITY_PLUGIN_H_
diff --git a/engine/inc/dreamcast.h b/engine/inc/dreamcast.h
new file mode 100644
index 00000000..2624fb76
--- /dev/null
+++ b/engine/inc/dreamcast.h
@@ -0,0 +1,39 @@
+#pragma once
+
+#include <string>
+#include <sstream>
+#include <cstdlib>
+#include <math.h>
+
+namespace std {
+	template<typename T>
+	std::string to_string( const T& val ) {
+		std::stringstream ss;
+		ss << val;
+		return ss.str();
+	}
+
+	inline float strtof(const char* str, char** endptr) { return ::strtof(str, endptr); }
+	inline double strtold(const char* str, char** endptr) { return ::strtold(str, endptr); }
+	inline long long int strtoll(const char* str, char** endptr, int base) { return ::strtoll(str, endptr, base); } 
+	inline unsigned long long int strtoull(const char* str, char** endptr, int base) { return ::strtoull(str, endptr, base); }
+
+	inline double log2( double n ) { return log(n) / log(2); }
+
+	template<typename... Args>
+	inline int snprintf( char* s, size_t n, const char* format, Args... args ) {
+		return ::snprintf(s, n, format, args...);
+	}
+
+	inline unsigned long long stoull( const std::string& s, std::size_t* pos = 0, int base = 10 ) {
+		std::wstring ws(s.begin(), s.end());
+		return std::__cxx11::stoull( ws, pos, base );
+	}
+	inline int stoi( const std::string& s, std::size_t* pos = 0, int base = 10 ) {
+		std::wstring ws(s.begin(), s.end());
+		return std::__cxx11::stoi( ws, pos, base );
+	}
+	inline double cbrt( double x ) {
+		return ::cbrt( x );
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/freetype/config/ftconfig.h b/engine/inc/freetype/config/ftconfig.h
new file mode 100644
index 00000000..3fddb716
--- /dev/null
+++ b/engine/inc/freetype/config/ftconfig.h
@@ -0,0 +1,524 @@
+/* ftconfig.h.  Generated from ftconfig.in by configure.  */
+/***************************************************************************/
+/*                                                                         */
+/*  ftconfig.in                                                            */
+/*                                                                         */
+/*    UNIX-specific configuration file (specification only).               */
+/*                                                                         */
+/*  Copyright 1996-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This header file contains a number of macro definitions that are used */
+  /* by the rest of the engine.  Most of the macros here are automatically */
+  /* determined at compile time, and you should not need to change it to   */
+  /* port FreeType, except to compile the library with a non-ANSI          */
+  /* compiler.                                                             */
+  /*                                                                       */
+  /* Note however that if some specific modifications are needed, we       */
+  /* advise you to place a modified copy in your build directory.          */
+  /*                                                                       */
+  /* The build directory is usually `builds/<system>', and contains        */
+  /* system-specific files that are always included first when building    */
+  /* the library.                                                          */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#ifndef FTCONFIG_H_
+#define FTCONFIG_H_
+
+#include <ft2build.h>
+#include FT_CONFIG_OPTIONS_H
+#include FT_CONFIG_STANDARD_LIBRARY_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*               PLATFORM-SPECIFIC CONFIGURATION MACROS                  */
+  /*                                                                       */
+  /* These macros can be toggled to suit a specific system.  The current   */
+  /* ones are defaults used to compile FreeType in an ANSI C environment   */
+  /* (16bit compilers are also supported).  Copy this file to your own     */
+  /* `builds/<system>' directory, and edit it to port the engine.          */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#define HAVE_UNISTD_H 1
+#define HAVE_FCNTL_H 1
+#define HAVE_STDINT_H 1
+
+
+  /* There are systems (like the Texas Instruments 'C54x) where a `char' */
+  /* has 16 bits.  ANSI C says that sizeof(char) is always 1.  Since an  */
+  /* `int' has 16 bits also for this system, sizeof(int) gives 1 which   */
+  /* is probably unexpected.                                             */
+  /*                                                                     */
+  /* `CHAR_BIT' (defined in limits.h) gives the number of bits in a      */
+  /* `char' type.                                                        */
+
+#ifndef FT_CHAR_BIT
+#define FT_CHAR_BIT  CHAR_BIT
+#endif
+
+
+/* #undef FT_USE_AUTOCONF_SIZEOF_TYPES */
+#ifdef FT_USE_AUTOCONF_SIZEOF_TYPES
+
+#define SIZEOF_INT 4
+#define SIZEOF_LONG 4
+#define FT_SIZEOF_INT  SIZEOF_INT
+#define FT_SIZEOF_LONG SIZEOF_LONG
+
+#else /* !FT_USE_AUTOCONF_SIZEOF_TYPES */
+
+  /* Following cpp computation of the bit length of int and long */
+  /* is copied from default include/freetype/config/ftconfig.h.  */
+  /* If any improvement is required for this file, it should be  */
+  /* applied to the original header file for the builders that   */
+  /* do not use configure script.                                */
+
+  /* The size of an `int' type.  */
+#if                                 FT_UINT_MAX == 0xFFFFUL
+#define FT_SIZEOF_INT  (16 / FT_CHAR_BIT)
+#elif                               FT_UINT_MAX == 0xFFFFFFFFUL
+#define FT_SIZEOF_INT  (32 / FT_CHAR_BIT)
+#elif FT_UINT_MAX > 0xFFFFFFFFUL && FT_UINT_MAX == 0xFFFFFFFFFFFFFFFFUL
+#define FT_SIZEOF_INT  (64 / FT_CHAR_BIT)
+#else
+#error "Unsupported size of `int' type!"
+#endif
+
+  /* The size of a `long' type.  A five-byte `long' (as used e.g. on the */
+  /* DM642) is recognized but avoided.                                   */
+#if                                  FT_ULONG_MAX == 0xFFFFFFFFUL
+#define FT_SIZEOF_LONG  (32 / FT_CHAR_BIT)
+#elif FT_ULONG_MAX > 0xFFFFFFFFUL && FT_ULONG_MAX == 0xFFFFFFFFFFUL
+#define FT_SIZEOF_LONG  (32 / FT_CHAR_BIT)
+#elif FT_ULONG_MAX > 0xFFFFFFFFUL && FT_ULONG_MAX == 0xFFFFFFFFFFFFFFFFUL
+#define FT_SIZEOF_LONG  (64 / FT_CHAR_BIT)
+#else
+#error "Unsupported size of `long' type!"
+#endif
+
+#endif /* !FT_USE_AUTOCONF_SIZEOF_TYPES */
+
+
+  /* FT_UNUSED is a macro used to indicate that a given parameter is not  */
+  /* used -- this is only used to get rid of unpleasant compiler warnings */
+#ifndef FT_UNUSED
+#define FT_UNUSED( arg )  ( (arg) = (arg) )
+#endif
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*                     AUTOMATIC CONFIGURATION MACROS                    */
+  /*                                                                       */
+  /* These macros are computed from the ones defined above.  Don't touch   */
+  /* their definition, unless you know precisely what you are doing.  No   */
+  /* porter should need to mess with them.                                 */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Mac support                                                           */
+  /*                                                                       */
+  /*   This is the only necessary change, so it is defined here instead    */
+  /*   providing a new configuration file.                                 */
+  /*                                                                       */
+#if defined( __APPLE__ ) || ( defined( __MWERKS__ ) && defined( macintosh ) )
+  /* no Carbon frameworks for 64bit 10.4.x */
+  /* AvailabilityMacros.h is available since Mac OS X 10.2,        */
+  /* so guess the system version by maximum errno before inclusion */
+#include <errno.h>
+#ifdef ECANCELED /* defined since 10.2 */
+#include "AvailabilityMacros.h"
+#endif
+#if defined( __LP64__ ) && \
+    ( MAC_OS_X_VERSION_MIN_REQUIRED <= MAC_OS_X_VERSION_10_4 )
+#undef FT_MACINTOSH
+#endif
+
+#elif defined( __SC__ ) || defined( __MRC__ )
+  /* Classic MacOS compilers */
+#include "ConditionalMacros.h"
+#if TARGET_OS_MAC
+#define FT_MACINTOSH 1
+#endif
+
+#endif
+
+
+  /* Fix compiler warning with sgi compiler */
+#if defined( __sgi ) && !defined( __GNUC__ )
+#if defined( _COMPILER_VERSION ) && ( _COMPILER_VERSION >= 730 )
+#pragma set woff 3505
+#endif
+#endif
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    basic_types                                                        */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Int16                                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A typedef for a 16bit signed integer type.                         */
+  /*                                                                       */
+  typedef signed short  FT_Int16;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_UInt16                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A typedef for a 16bit unsigned integer type.                       */
+  /*                                                                       */
+  typedef unsigned short  FT_UInt16;
+
+  /* */
+
+
+  /* this #if 0 ... #endif clause is for documentation purposes */
+#if 0
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Int32                                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A typedef for a 32bit signed integer type.  The size depends on    */
+  /*    the configuration.                                                 */
+  /*                                                                       */
+  typedef signed XXX  FT_Int32;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_UInt32                                                          */
+  /*                                                                       */
+  /*    A typedef for a 32bit unsigned integer type.  The size depends on  */
+  /*    the configuration.                                                 */
+  /*                                                                       */
+  typedef unsigned XXX  FT_UInt32;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Int64                                                           */
+  /*                                                                       */
+  /*    A typedef for a 64bit signed integer type.  The size depends on    */
+  /*    the configuration.  Only defined if there is real 64bit support;   */
+  /*    otherwise, it gets emulated with a structure (if necessary).       */
+  /*                                                                       */
+  typedef signed XXX  FT_Int64;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_UInt64                                                          */
+  /*                                                                       */
+  /*    A typedef for a 64bit unsigned integer type.  The size depends on  */
+  /*    the configuration.  Only defined if there is real 64bit support;   */
+  /*    otherwise, it gets emulated with a structure (if necessary).       */
+  /*                                                                       */
+  typedef unsigned XXX  FT_UInt64;
+
+  /* */
+
+#endif
+
+#if FT_SIZEOF_INT == 4
+
+  typedef signed int      FT_Int32;
+  typedef unsigned int    FT_UInt32;
+
+#elif FT_SIZEOF_LONG == 4
+
+  typedef signed long     FT_Int32;
+  typedef unsigned long   FT_UInt32;
+
+#else
+#error "no 32bit type found -- please check your configuration files"
+#endif
+
+
+  /* look up an integer type that is at least 32 bits */
+#if FT_SIZEOF_INT >= 4
+
+  typedef int            FT_Fast;
+  typedef unsigned int   FT_UFast;
+
+#elif FT_SIZEOF_LONG >= 4
+
+  typedef long           FT_Fast;
+  typedef unsigned long  FT_UFast;
+
+#endif
+
+
+  /* determine whether we have a 64-bit int type  */
+  /* (mostly for environments without `autoconf') */
+#if FT_SIZEOF_LONG == 8
+
+  /* FT_LONG64 must be defined if a 64-bit type is available */
+#define FT_LONG64
+#define FT_INT64   long
+#define FT_UINT64  unsigned long
+
+  /* we handle the LLP64 scheme separately for GCC and clang, */
+  /* suppressing the `long long' warning                      */
+#elif ( FT_SIZEOF_LONG == 4 )       && \
+      defined( HAVE_LONG_LONG_INT ) && \
+      defined( __GNUC__ )
+#pragma GCC diagnostic ignored "-Wlong-long"
+#define FT_LONG64
+#define FT_INT64   long long int
+#define FT_UINT64  unsigned long long int
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* A 64-bit data type may create compilation problems if you compile     */
+  /* in strict ANSI mode.  To avoid them, we disable other 64-bit data     */
+  /* types if __STDC__ is defined.  You can however ignore this rule       */
+  /* by defining the FT_CONFIG_OPTION_FORCE_INT64 configuration macro.     */
+  /*                                                                       */
+#elif !defined( __STDC__ ) || defined( FT_CONFIG_OPTION_FORCE_INT64 )
+
+#if defined( __STDC_VERSION__ ) && __STDC_VERSION__ >= 199901L
+
+#define FT_LONG64
+#define FT_INT64   long long int
+#define FT_UINT64  unsigned long long int
+
+#elif defined( _MSC_VER ) && _MSC_VER >= 900  /* Visual C++ (and Intel C++) */
+
+  /* this compiler provides the __int64 type */
+#define FT_LONG64
+#define FT_INT64   __int64
+#define FT_UINT64  unsigned __int64
+
+#elif defined( __BORLANDC__ )  /* Borland C++ */
+
+  /* XXXX: We should probably check the value of __BORLANDC__ in order */
+  /*       to test the compiler version.                               */
+
+  /* this compiler provides the __int64 type */
+#define FT_LONG64
+#define FT_INT64   __int64
+#define FT_UINT64  unsigned __int64
+
+#elif defined( __WATCOMC__ )   /* Watcom C++ */
+
+  /* Watcom doesn't provide 64-bit data types */
+
+#elif defined( __MWERKS__ )    /* Metrowerks CodeWarrior */
+
+#define FT_LONG64
+#define FT_INT64   long long int
+#define FT_UINT64  unsigned long long int
+
+#elif defined( __GNUC__ )
+
+  /* GCC provides the `long long' type */
+#define FT_LONG64
+#define FT_INT64   long long int
+#define FT_UINT64  unsigned long long int
+
+#endif /* __STDC_VERSION__ >= 199901L */
+
+#endif /* FT_SIZEOF_LONG == 8 */
+
+#ifdef FT_LONG64
+  typedef FT_INT64   FT_Int64;
+  typedef FT_UINT64  FT_UInt64;
+#endif
+
+
+#ifdef _WIN64
+  /* only 64bit Windows uses the LLP64 data model, i.e., */
+  /* 32bit integers, 64bit pointers                      */
+#define FT_UINT_TO_POINTER( x ) (void*)(unsigned __int64)(x)
+#else
+#define FT_UINT_TO_POINTER( x ) (void*)(unsigned long)(x)
+#endif
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* miscellaneous                                                         */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#define FT_BEGIN_STMNT  do {
+#define FT_END_STMNT    } while ( 0 )
+#define FT_DUMMY_STMNT  FT_BEGIN_STMNT FT_END_STMNT
+
+
+  /* typeof condition taken from gnulib's `intprops.h' header file */
+#if ( ( defined( __GNUC__ ) && __GNUC__ >= 2 )                       || \
+      ( defined( __IBMC__ ) && __IBMC__ >= 1210 &&                      \
+        defined( __IBM__TYPEOF__ ) )                                 || \
+      ( defined( __SUNPRO_C ) && __SUNPRO_C >= 0x5110 && !__STDC__ ) )
+#define FT_TYPEOF( type )  ( __typeof__ ( type ) )
+#else
+#define FT_TYPEOF( type )  /* empty */
+#endif
+
+
+#ifdef FT_MAKE_OPTION_SINGLE_OBJECT
+
+#define FT_LOCAL( x )      static  x
+#define FT_LOCAL_DEF( x )  static  x
+
+#else
+
+#ifdef __cplusplus
+#define FT_LOCAL( x )      extern "C"  x
+#define FT_LOCAL_DEF( x )  extern "C"  x
+#else
+#define FT_LOCAL( x )      extern  x
+#define FT_LOCAL_DEF( x )  x
+#endif
+
+#endif /* FT_MAKE_OPTION_SINGLE_OBJECT */
+
+#define FT_LOCAL_ARRAY( x )      extern const  x
+#define FT_LOCAL_ARRAY_DEF( x )  const  x
+
+
+#ifndef FT_BASE
+
+#ifdef __cplusplus
+#define FT_BASE( x )  extern "C"  x
+#else
+#define FT_BASE( x )  extern  x
+#endif
+
+#endif /* !FT_BASE */
+
+
+#ifndef FT_BASE_DEF
+
+#ifdef __cplusplus
+#define FT_BASE_DEF( x )  x
+#else
+#define FT_BASE_DEF( x )  x
+#endif
+
+#endif /* !FT_BASE_DEF */
+
+
+#ifndef FT_EXPORT
+
+#ifdef __cplusplus
+#define FT_EXPORT( x )  extern "C"  x
+#else
+#define FT_EXPORT( x )  extern  x
+#endif
+
+#endif /* !FT_EXPORT */
+
+
+#ifndef FT_EXPORT_DEF
+
+#ifdef __cplusplus
+#define FT_EXPORT_DEF( x )  extern "C"  x
+#else
+#define FT_EXPORT_DEF( x )  extern  x
+#endif
+
+#endif /* !FT_EXPORT_DEF */
+
+
+#ifndef FT_EXPORT_VAR
+
+#ifdef __cplusplus
+#define FT_EXPORT_VAR( x )  extern "C"  x
+#else
+#define FT_EXPORT_VAR( x )  extern  x
+#endif
+
+#endif /* !FT_EXPORT_VAR */
+
+  /* The following macros are needed to compile the library with a   */
+  /* C++ compiler and with 16bit compilers.                          */
+  /*                                                                 */
+
+  /* This is special.  Within C++, you must specify `extern "C"' for */
+  /* functions which are used via function pointers, and you also    */
+  /* must do that for structures which contain function pointers to  */
+  /* assure C linkage -- it's not possible to have (local) anonymous */
+  /* functions which are accessed by (global) function pointers.     */
+  /*                                                                 */
+  /*                                                                 */
+  /* FT_CALLBACK_DEF is used to _define_ a callback function.        */
+  /*                                                                 */
+  /* FT_CALLBACK_TABLE is used to _declare_ a constant variable that */
+  /* contains pointers to callback functions.                        */
+  /*                                                                 */
+  /* FT_CALLBACK_TABLE_DEF is used to _define_ a constant variable   */
+  /* that contains pointers to callback functions.                   */
+  /*                                                                 */
+  /*                                                                 */
+  /* Some 16bit compilers have to redefine these macros to insert    */
+  /* the infamous `_cdecl' or `__fastcall' declarations.             */
+  /*                                                                 */
+#ifndef FT_CALLBACK_DEF
+#ifdef __cplusplus
+#define FT_CALLBACK_DEF( x )  extern "C"  x
+#else
+#define FT_CALLBACK_DEF( x )  static  x
+#endif
+#endif /* FT_CALLBACK_DEF */
+
+#ifndef FT_CALLBACK_TABLE
+#ifdef __cplusplus
+#define FT_CALLBACK_TABLE      extern "C"
+#define FT_CALLBACK_TABLE_DEF  extern "C"
+#else
+#define FT_CALLBACK_TABLE      extern
+#define FT_CALLBACK_TABLE_DEF  /* nothing */
+#endif
+#endif /* FT_CALLBACK_TABLE */
+
+
+FT_END_HEADER
+
+
+#endif /* FTCONFIG_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/config/ftheader.h b/engine/inc/freetype/config/ftheader.h
new file mode 100644
index 00000000..d491af57
--- /dev/null
+++ b/engine/inc/freetype/config/ftheader.h
@@ -0,0 +1,846 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftheader.h                                                             */
+/*                                                                         */
+/*    Build macros of the FreeType 2 library.                              */
+/*                                                                         */
+/*  Copyright 1996-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+#ifndef FTHEADER_H_
+#define FTHEADER_H_
+
+
+  /*@***********************************************************************/
+  /*                                                                       */
+  /* <Macro>                                                               */
+  /*    FT_BEGIN_HEADER                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This macro is used in association with @FT_END_HEADER in header    */
+  /*    files to ensure that the declarations within are properly          */
+  /*    encapsulated in an `extern "C" { .. }' block when included from a  */
+  /*    C++ compiler.                                                      */
+  /*                                                                       */
+#ifdef __cplusplus
+#define FT_BEGIN_HEADER  extern "C" {
+#else
+#define FT_BEGIN_HEADER  /* nothing */
+#endif
+
+
+  /*@***********************************************************************/
+  /*                                                                       */
+  /* <Macro>                                                               */
+  /*    FT_END_HEADER                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This macro is used in association with @FT_BEGIN_HEADER in header  */
+  /*    files to ensure that the declarations within are properly          */
+  /*    encapsulated in an `extern "C" { .. }' block when included from a  */
+  /*    C++ compiler.                                                      */
+  /*                                                                       */
+#ifdef __cplusplus
+#define FT_END_HEADER  }
+#else
+#define FT_END_HEADER  /* nothing */
+#endif
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Aliases for the FreeType 2 public and configuration files.            */
+  /*                                                                       */
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    header_file_macros                                                 */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    Header File Macros                                                 */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    Macro definitions used to #include specific header files.          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The following macros are defined to the name of specific           */
+  /*    FreeType~2 header files.  They can be used directly in #include    */
+  /*    statements as in:                                                  */
+  /*                                                                       */
+  /*    {                                                                  */
+  /*      #include FT_FREETYPE_H                                           */
+  /*      #include FT_MULTIPLE_MASTERS_H                                   */
+  /*      #include FT_GLYPH_H                                              */
+  /*    }                                                                  */
+  /*                                                                       */
+  /*    There are several reasons why we are now using macros to name      */
+  /*    public header files.  The first one is that such macros are not    */
+  /*    limited to the infamous 8.3~naming rule required by DOS (and       */
+  /*    `FT_MULTIPLE_MASTERS_H' is a lot more meaningful than `ftmm.h').   */
+  /*                                                                       */
+  /*    The second reason is that it allows for more flexibility in the    */
+  /*    way FreeType~2 is installed on a given system.                     */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /* configuration files */
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_CONFIG_CONFIG_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing
+   *   FreeType~2 configuration data.
+   *
+   */
+#ifndef FT_CONFIG_CONFIG_H
+#define FT_CONFIG_CONFIG_H  <freetype/config/ftconfig.h>
+#endif
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_CONFIG_STANDARD_LIBRARY_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing
+   *   FreeType~2 interface to the standard C library functions.
+   *
+   */
+#ifndef FT_CONFIG_STANDARD_LIBRARY_H
+#define FT_CONFIG_STANDARD_LIBRARY_H  <freetype/config/ftstdlib.h>
+#endif
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_CONFIG_OPTIONS_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing
+   *   FreeType~2 project-specific configuration options.
+   *
+   */
+#ifndef FT_CONFIG_OPTIONS_H
+#define FT_CONFIG_OPTIONS_H  <freetype/config/ftoption.h>
+#endif
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_CONFIG_MODULES_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   list of FreeType~2 modules that are statically linked to new library
+   *   instances in @FT_Init_FreeType.
+   *
+   */
+#ifndef FT_CONFIG_MODULES_H
+#define FT_CONFIG_MODULES_H  <freetype/config/ftmodule.h>
+#endif
+
+  /* */
+
+  /* public headers */
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_FREETYPE_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   base FreeType~2 API.
+   *
+   */
+#define FT_FREETYPE_H  <freetype/freetype.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_ERRORS_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   list of FreeType~2 error codes (and messages).
+   *
+   *   It is included by @FT_FREETYPE_H.
+   *
+   */
+#define FT_ERRORS_H  <freetype/fterrors.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_MODULE_ERRORS_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   list of FreeType~2 module error offsets (and messages).
+   *
+   */
+#define FT_MODULE_ERRORS_H  <freetype/ftmoderr.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_SYSTEM_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   FreeType~2 interface to low-level operations (i.e., memory management
+   *   and stream i/o).
+   *
+   *   It is included by @FT_FREETYPE_H.
+   *
+   */
+#define FT_SYSTEM_H  <freetype/ftsystem.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_IMAGE_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing type
+   *   definitions related to glyph images (i.e., bitmaps, outlines,
+   *   scan-converter parameters).
+   *
+   *   It is included by @FT_FREETYPE_H.
+   *
+   */
+#define FT_IMAGE_H  <freetype/ftimage.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_TYPES_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   basic data types defined by FreeType~2.
+   *
+   *   It is included by @FT_FREETYPE_H.
+   *
+   */
+#define FT_TYPES_H  <freetype/fttypes.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_LIST_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   list management API of FreeType~2.
+   *
+   *   (Most applications will never need to include this file.)
+   *
+   */
+#define FT_LIST_H  <freetype/ftlist.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_OUTLINE_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   scalable outline management API of FreeType~2.
+   *
+   */
+#define FT_OUTLINE_H  <freetype/ftoutln.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_SIZES_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   API which manages multiple @FT_Size objects per face.
+   *
+   */
+#define FT_SIZES_H  <freetype/ftsizes.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_MODULE_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   module management API of FreeType~2.
+   *
+   */
+#define FT_MODULE_H  <freetype/ftmodapi.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_RENDER_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   renderer module management API of FreeType~2.
+   *
+   */
+#define FT_RENDER_H  <freetype/ftrender.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_AUTOHINTER_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing
+   *   structures and macros related to the auto-hinting module.
+   *
+   */
+#define FT_AUTOHINTER_H  <freetype/ftautoh.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_CFF_DRIVER_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing
+   *   structures and macros related to the CFF driver module.
+   *
+   */
+#define FT_CFF_DRIVER_H  <freetype/ftcffdrv.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_TRUETYPE_DRIVER_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing
+   *   structures and macros related to the TrueType driver module.
+   *
+   */
+#define FT_TRUETYPE_DRIVER_H  <freetype/ftttdrv.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_PCF_DRIVER_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing
+   *   structures and macros related to the PCF driver module.
+   *
+   */
+#define FT_PCF_DRIVER_H  <freetype/ftpcfdrv.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_TYPE1_TABLES_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   types and API specific to the Type~1 format.
+   *
+   */
+#define FT_TYPE1_TABLES_H  <freetype/t1tables.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_TRUETYPE_IDS_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   enumeration values which identify name strings, languages, encodings,
+   *   etc.  This file really contains a _large_ set of constant macro
+   *   definitions, taken from the TrueType and OpenType specifications.
+   *
+   */
+#define FT_TRUETYPE_IDS_H  <freetype/ttnameid.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_TRUETYPE_TABLES_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   types and API specific to the TrueType (as well as OpenType) format.
+   *
+   */
+#define FT_TRUETYPE_TABLES_H  <freetype/tttables.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_TRUETYPE_TAGS_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   definitions of TrueType four-byte `tags' which identify blocks in
+   *   SFNT-based font formats (i.e., TrueType and OpenType).
+   *
+   */
+#define FT_TRUETYPE_TAGS_H  <freetype/tttags.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_BDF_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   definitions of an API which accesses BDF-specific strings from a
+   *   face.
+   *
+   */
+#define FT_BDF_H  <freetype/ftbdf.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_CID_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   definitions of an API which access CID font information from a
+   *   face.
+   *
+   */
+#define FT_CID_H  <freetype/ftcid.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_GZIP_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   definitions of an API which supports gzip-compressed files.
+   *
+   */
+#define FT_GZIP_H  <freetype/ftgzip.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_LZW_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   definitions of an API which supports LZW-compressed files.
+   *
+   */
+#define FT_LZW_H  <freetype/ftlzw.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_BZIP2_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   definitions of an API which supports bzip2-compressed files.
+   *
+   */
+#define FT_BZIP2_H  <freetype/ftbzip2.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_WINFONTS_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   definitions of an API which supports Windows FNT files.
+   *
+   */
+#define FT_WINFONTS_H   <freetype/ftwinfnt.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_GLYPH_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   API of the optional glyph management component.
+   *
+   */
+#define FT_GLYPH_H  <freetype/ftglyph.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_BITMAP_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   API of the optional bitmap conversion component.
+   *
+   */
+#define FT_BITMAP_H  <freetype/ftbitmap.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_BBOX_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   API of the optional exact bounding box computation routines.
+   *
+   */
+#define FT_BBOX_H  <freetype/ftbbox.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_CACHE_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   API of the optional FreeType~2 cache sub-system.
+   *
+   */
+#define FT_CACHE_H  <freetype/ftcache.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_CACHE_IMAGE_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   `glyph image' API of the FreeType~2 cache sub-system.
+   *
+   *   It is used to define a cache for @FT_Glyph elements.  You can also
+   *   use the API defined in @FT_CACHE_SMALL_BITMAPS_H if you only need to
+   *   store small glyph bitmaps, as it will use less memory.
+   *
+   *   This macro is deprecated.  Simply include @FT_CACHE_H to have all
+   *   glyph image-related cache declarations.
+   *
+   */
+#define FT_CACHE_IMAGE_H  FT_CACHE_H
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_CACHE_SMALL_BITMAPS_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   `small bitmaps' API of the FreeType~2 cache sub-system.
+   *
+   *   It is used to define a cache for small glyph bitmaps in a relatively
+   *   memory-efficient way.  You can also use the API defined in
+   *   @FT_CACHE_IMAGE_H if you want to cache arbitrary glyph images,
+   *   including scalable outlines.
+   *
+   *   This macro is deprecated.  Simply include @FT_CACHE_H to have all
+   *   small bitmaps-related cache declarations.
+   *
+   */
+#define FT_CACHE_SMALL_BITMAPS_H  FT_CACHE_H
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_CACHE_CHARMAP_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   `charmap' API of the FreeType~2 cache sub-system.
+   *
+   *   This macro is deprecated.  Simply include @FT_CACHE_H to have all
+   *   charmap-based cache declarations.
+   *
+   */
+#define FT_CACHE_CHARMAP_H  FT_CACHE_H
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_MAC_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   Macintosh-specific FreeType~2 API.  The latter is used to access
+   *   fonts embedded in resource forks.
+   *
+   *   This header file must be explicitly included by client applications
+   *   compiled on the Mac (note that the base API still works though).
+   *
+   */
+#define FT_MAC_H  <freetype/ftmac.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_MULTIPLE_MASTERS_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   optional multiple-masters management API of FreeType~2.
+   *
+   */
+#define FT_MULTIPLE_MASTERS_H  <freetype/ftmm.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_SFNT_NAMES_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   optional FreeType~2 API which accesses embedded `name' strings in
+   *   SFNT-based font formats (i.e., TrueType and OpenType).
+   *
+   */
+#define FT_SFNT_NAMES_H  <freetype/ftsnames.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_OPENTYPE_VALIDATE_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   optional FreeType~2 API which validates OpenType tables (BASE, GDEF,
+   *   GPOS, GSUB, JSTF).
+   *
+   */
+#define FT_OPENTYPE_VALIDATE_H  <freetype/ftotval.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_GX_VALIDATE_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   optional FreeType~2 API which validates TrueTypeGX/AAT tables (feat,
+   *   mort, morx, bsln, just, kern, opbd, trak, prop).
+   *
+   */
+#define FT_GX_VALIDATE_H  <freetype/ftgxval.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_PFR_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   FreeType~2 API which accesses PFR-specific data.
+   *
+   */
+#define FT_PFR_H  <freetype/ftpfr.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_STROKER_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   FreeType~2 API which provides functions to stroke outline paths.
+   */
+#define FT_STROKER_H  <freetype/ftstroke.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_SYNTHESIS_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   FreeType~2 API which performs artificial obliquing and emboldening.
+   */
+#define FT_SYNTHESIS_H  <freetype/ftsynth.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_FONT_FORMATS_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   FreeType~2 API which provides functions specific to font formats.
+   */
+#define FT_FONT_FORMATS_H  <freetype/ftfntfmt.h>
+
+  /* deprecated */
+#define FT_XFREE86_H  FT_FONT_FORMATS_H
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_TRIGONOMETRY_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   FreeType~2 API which performs trigonometric computations (e.g.,
+   *   cosines and arc tangents).
+   */
+#define FT_TRIGONOMETRY_H  <freetype/fttrigon.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_LCD_FILTER_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   FreeType~2 API which performs color filtering for subpixel rendering.
+   */
+#define FT_LCD_FILTER_H  <freetype/ftlcdfil.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_UNPATENTED_HINTING_H
+   *
+   * @description:
+   *   Deprecated.
+   */
+#define FT_UNPATENTED_HINTING_H  <freetype/ttunpat.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_INCREMENTAL_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   FreeType~2 API which performs incremental glyph loading.
+   */
+#define FT_INCREMENTAL_H  <freetype/ftincrem.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_GASP_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   FreeType~2 API which returns entries from the TrueType GASP table.
+   */
+#define FT_GASP_H  <freetype/ftgasp.h>
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_ADVANCES_H
+   *
+   * @description:
+   *   A macro used in #include statements to name the file containing the
+   *   FreeType~2 API which returns individual and ranged glyph advances.
+   */
+#define FT_ADVANCES_H  <freetype/ftadvanc.h>
+
+
+  /* */
+
+#define FT_ERROR_DEFINITIONS_H  <freetype/fterrdef.h>
+
+
+  /* The internals of the cache sub-system are no longer exposed.  We */
+  /* default to FT_CACHE_H at the moment just in case, but we know of */
+  /* no rogue client that uses them.                                  */
+  /*                                                                  */
+#define FT_CACHE_MANAGER_H           <freetype/ftcache.h>
+#define FT_CACHE_INTERNAL_MRU_H      <freetype/ftcache.h>
+#define FT_CACHE_INTERNAL_MANAGER_H  <freetype/ftcache.h>
+#define FT_CACHE_INTERNAL_CACHE_H    <freetype/ftcache.h>
+#define FT_CACHE_INTERNAL_GLYPH_H    <freetype/ftcache.h>
+#define FT_CACHE_INTERNAL_IMAGE_H    <freetype/ftcache.h>
+#define FT_CACHE_INTERNAL_SBITS_H    <freetype/ftcache.h>
+
+
+#define FT_INCREMENTAL_H          <freetype/ftincrem.h>
+
+#define FT_TRUETYPE_UNPATENTED_H  <freetype/ttunpat.h>
+
+
+  /*
+   * Include internal headers definitions from <internal/...>
+   * only when building the library.
+   */
+#ifdef FT2_BUILD_LIBRARY
+#define  FT_INTERNAL_INTERNAL_H  <freetype/internal/internal.h>
+#include FT_INTERNAL_INTERNAL_H
+#endif /* FT2_BUILD_LIBRARY */
+
+
+#endif /* FTHEADER_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/config/ftmodule.h b/engine/inc/freetype/config/ftmodule.h
new file mode 100644
index 00000000..d1b938ba
--- /dev/null
+++ b/engine/inc/freetype/config/ftmodule.h
@@ -0,0 +1,22 @@
+/* This is a generated file. */
+FT_USE_MODULE( FT_Driver_ClassRec, tt_driver_class )
+FT_USE_MODULE( FT_Driver_ClassRec, t1_driver_class )
+FT_USE_MODULE( FT_Driver_ClassRec, cff_driver_class )
+FT_USE_MODULE( FT_Driver_ClassRec, t1cid_driver_class )
+FT_USE_MODULE( FT_Driver_ClassRec, pfr_driver_class )
+FT_USE_MODULE( FT_Driver_ClassRec, t42_driver_class )
+FT_USE_MODULE( FT_Driver_ClassRec, winfnt_driver_class )
+FT_USE_MODULE( FT_Driver_ClassRec, pcf_driver_class )
+FT_USE_MODULE( FT_Driver_ClassRec, bdf_driver_class )
+FT_USE_MODULE( FT_Module_Class, sfnt_module_class )
+FT_USE_MODULE( FT_Module_Class, autofit_module_class )
+FT_USE_MODULE( FT_Module_Class, pshinter_module_class )
+FT_USE_MODULE( FT_Renderer_Class, ft_raster1_renderer_class )
+FT_USE_MODULE( FT_Renderer_Class, ft_smooth_renderer_class )
+FT_USE_MODULE( FT_Renderer_Class, ft_smooth_lcd_renderer_class )
+FT_USE_MODULE( FT_Renderer_Class, ft_smooth_lcdv_renderer_class )
+FT_USE_MODULE( FT_Module_Class, gxv_module_class )
+FT_USE_MODULE( FT_Module_Class, otv_module_class )
+FT_USE_MODULE( FT_Module_Class, psaux_module_class )
+FT_USE_MODULE( FT_Module_Class, psnames_module_class )
+/* EOF */
diff --git a/engine/inc/freetype/config/ftoption.h b/engine/inc/freetype/config/ftoption.h
new file mode 100644
index 00000000..2fbe80b9
--- /dev/null
+++ b/engine/inc/freetype/config/ftoption.h
@@ -0,0 +1,990 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftoption.h                                                             */
+/*                                                                         */
+/*    User-selectable configuration macros (specification only).           */
+/*                                                                         */
+/*  Copyright 1996-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTOPTION_H_
+#define FTOPTION_H_
+
+
+#include <ft2build.h>
+
+
+FT_BEGIN_HEADER
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*                 USER-SELECTABLE CONFIGURATION MACROS                  */
+  /*                                                                       */
+  /* This file contains the default configuration macro definitions for    */
+  /* a standard build of the FreeType library.  There are three ways to    */
+  /* use this file to build project-specific versions of the library:      */
+  /*                                                                       */
+  /*  - You can modify this file by hand, but this is not recommended in   */
+  /*    cases where you would like to build several versions of the        */
+  /*    library from a single source directory.                            */
+  /*                                                                       */
+  /*  - You can put a copy of this file in your build directory, more      */
+  /*    precisely in `$BUILD/freetype/config/ftoption.h', where `$BUILD'   */
+  /*    is the name of a directory that is included _before_ the FreeType  */
+  /*    include path during compilation.                                   */
+  /*                                                                       */
+  /*    The default FreeType Makefiles and Jamfiles use the build          */
+  /*    directory `builds/<system>' by default, but you can easily change  */
+  /*    that for your own projects.                                        */
+  /*                                                                       */
+  /*  - Copy the file <ft2build.h> to `$BUILD/ft2build.h' and modify it    */
+  /*    slightly to pre-define the macro FT_CONFIG_OPTIONS_H used to       */
+  /*    locate this file during the build.  For example,                   */
+  /*                                                                       */
+  /*      #define FT_CONFIG_OPTIONS_H  <myftoptions.h>                     */
+  /*      #include <freetype/config/ftheader.h>                            */
+  /*                                                                       */
+  /*    will use `$BUILD/myftoptions.h' instead of this file for macro     */
+  /*    definitions.                                                       */
+  /*                                                                       */
+  /*    Note also that you can similarly pre-define the macro              */
+  /*    FT_CONFIG_MODULES_H used to locate the file listing of the modules */
+  /*    that are statically linked to the library at compile time.  By     */
+  /*    default, this file is <freetype/config/ftmodule.h>.                */
+  /*                                                                       */
+  /* We highly recommend using the third method whenever possible.         */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /**** G E N E R A L   F R E E T Y P E   2   C O N F I G U R A T I O N ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* If you enable this configuration option, FreeType recognizes an       */
+  /* environment variable called `FREETYPE_PROPERTIES', which can be used  */
+  /* to control the various font drivers and modules.  The controllable    */
+  /* properties are listed in the section `Controlling FreeType Modules'   */
+  /* in the reference's table of contents; currently there are properties  */
+  /* for the auto-hinter (file `ftautoh.h'), CFF (file `ftcffdrv.h'),      */
+  /* TrueType (file `ftttdrv.h'), and PCF (file `ftpcfdrv.h').             */
+  /*                                                                       */
+  /* `FREETYPE_PROPERTIES' has the following syntax form (broken here into */
+  /* multiple lines for better readability).                               */
+  /*                                                                       */
+  /*   <optional whitespace>                                               */
+  /*   <module-name1> ':'                                                  */
+  /*   <property-name1> '=' <property-value1>                              */
+  /*   <whitespace>                                                        */
+  /*   <module-name2> ':'                                                  */
+  /*   <property-name2> '=' <property-value2>                              */
+  /*   ...                                                                 */
+  /*                                                                       */
+  /* Example:                                                              */
+  /*                                                                       */
+  /*   FREETYPE_PROPERTIES=truetype:interpreter-version=35 \               */
+  /*                       cff:no-stem-darkening=1 \                       */
+  /*                       autofitter:warping=1                            */
+  /*                                                                       */
+#define FT_CONFIG_OPTION_ENVIRONMENT_PROPERTIES
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Uncomment the line below if you want to activate LCD rendering        */
+  /* technology similar to ClearType in this build of the library.  This   */
+  /* technology triples the resolution in the direction color subpixels.   */
+  /* To mitigate color fringes inherent to this technology, you also need  */
+  /* to explicitly set up LCD filtering.                                   */
+  /*                                                                       */
+  /* Note that this feature is covered by several Microsoft patents        */
+  /* and should not be activated in any default build of the library.      */
+  /* When this macro is not defined, FreeType offers alternative LCD       */
+  /* rendering technology that produces excellent output without LCD       */
+  /* filtering.                                                            */
+  /*                                                                       */
+/* #define FT_CONFIG_OPTION_SUBPIXEL_RENDERING */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Many compilers provide a non-ANSI 64-bit data type that can be used   */
+  /* by FreeType to speed up some computations.  However, this will create */
+  /* some problems when compiling the library in strict ANSI mode.         */
+  /*                                                                       */
+  /* For this reason, the use of 64-bit integers is normally disabled when */
+  /* the __STDC__ macro is defined.  You can however disable this by       */
+  /* defining the macro FT_CONFIG_OPTION_FORCE_INT64 here.                 */
+  /*                                                                       */
+  /* For most compilers, this will only create compilation warnings when   */
+  /* building the library.                                                 */
+  /*                                                                       */
+  /* ObNote: The compiler-specific 64-bit integers are detected in the     */
+  /*         file `ftconfig.h' either statically or through the            */
+  /*         `configure' script on supported platforms.                    */
+  /*                                                                       */
+#undef FT_CONFIG_OPTION_FORCE_INT64
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* If this macro is defined, do not try to use an assembler version of   */
+  /* performance-critical functions (e.g. FT_MulFix).  You should only do  */
+  /* that to verify that the assembler function works properly, or to      */
+  /* execute benchmark tests of the various implementations.               */
+/* #define FT_CONFIG_OPTION_NO_ASSEMBLER */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* If this macro is defined, try to use an inlined assembler version of  */
+  /* the `FT_MulFix' function, which is a `hotspot' when loading and       */
+  /* hinting glyphs, and which should be executed as fast as possible.     */
+  /*                                                                       */
+  /* Note that if your compiler or CPU is not supported, this will default */
+  /* to the standard and portable implementation found in `ftcalc.c'.      */
+  /*                                                                       */
+#define FT_CONFIG_OPTION_INLINE_MULFIX
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* LZW-compressed file support.                                          */
+  /*                                                                       */
+  /*   FreeType now handles font files that have been compressed with the  */
+  /*   `compress' program.  This is mostly used to parse many of the PCF   */
+  /*   files that come with various X11 distributions.  The implementation */
+  /*   uses NetBSD's `zopen' to partially uncompress the file on the fly   */
+  /*   (see src/lzw/ftgzip.c).                                             */
+  /*                                                                       */
+  /*   Define this macro if you want to enable this `feature'.             */
+  /*                                                                       */
+#define FT_CONFIG_OPTION_USE_LZW
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Gzip-compressed file support.                                         */
+  /*                                                                       */
+  /*   FreeType now handles font files that have been compressed with the  */
+  /*   `gzip' program.  This is mostly used to parse many of the PCF files */
+  /*   that come with XFree86.  The implementation uses `zlib' to          */
+  /*   partially uncompress the file on the fly (see src/gzip/ftgzip.c).   */
+  /*                                                                       */
+  /*   Define this macro if you want to enable this `feature'.  See also   */
+  /*   the macro FT_CONFIG_OPTION_SYSTEM_ZLIB below.                       */
+  /*                                                                       */
+#define FT_CONFIG_OPTION_USE_ZLIB
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* ZLib library selection                                                */
+  /*                                                                       */
+  /*   This macro is only used when FT_CONFIG_OPTION_USE_ZLIB is defined.  */
+  /*   It allows FreeType's `ftgzip' component to link to the system's     */
+  /*   installation of the ZLib library.  This is useful on systems like   */
+  /*   Unix or VMS where it generally is already available.                */
+  /*                                                                       */
+  /*   If you let it undefined, the component will use its own copy        */
+  /*   of the zlib sources instead.  These have been modified to be        */
+  /*   included directly within the component and *not* export external    */
+  /*   function names.  This allows you to link any program with FreeType  */
+  /*   _and_ ZLib without linking conflicts.                               */
+  /*                                                                       */
+  /*   Do not #undef this macro here since the build system might define   */
+  /*   it for certain configurations only.                                 */
+  /*                                                                       */
+/* #define FT_CONFIG_OPTION_SYSTEM_ZLIB */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Bzip2-compressed file support.                                        */
+  /*                                                                       */
+  /*   FreeType now handles font files that have been compressed with the  */
+  /*   `bzip2' program.  This is mostly used to parse many of the PCF      */
+  /*   files that come with XFree86.  The implementation uses `libbz2' to  */
+  /*   partially uncompress the file on the fly (see src/bzip2/ftbzip2.c). */
+  /*   Contrary to gzip, bzip2 currently is not included and need to use   */
+  /*   the system available bzip2 implementation.                          */
+  /*                                                                       */
+  /*   Define this macro if you want to enable this `feature'.             */
+  /*                                                                       */
+/* #define FT_CONFIG_OPTION_USE_BZIP2 */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Define to disable the use of file stream functions and types, FILE,   */
+  /* fopen() etc.  Enables the use of smaller system libraries on embedded */
+  /* systems that have multiple system libraries, some with or without     */
+  /* file stream support, in the cases where file stream support is not    */
+  /* necessary such as memory loading of font files.                       */
+  /*                                                                       */
+/* #define FT_CONFIG_OPTION_DISABLE_STREAM_SUPPORT */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* PNG bitmap support.                                                   */
+  /*                                                                       */
+  /*   FreeType now handles loading color bitmap glyphs in the PNG format. */
+  /*   This requires help from the external libpng library.  Uncompressed  */
+  /*   color bitmaps do not need any external libraries and will be        */
+  /*   supported regardless of this configuration.                         */
+  /*                                                                       */
+  /*   Define this macro if you want to enable this `feature'.             */
+  /*                                                                       */
+/* #define FT_CONFIG_OPTION_USE_PNG */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* HarfBuzz support.                                                     */
+  /*                                                                       */
+  /*   FreeType uses the HarfBuzz library to improve auto-hinting of       */
+  /*   OpenType fonts.  If available, many glyphs not directly addressable */
+  /*   by a font's character map will be hinted also.                      */
+  /*                                                                       */
+  /*   Define this macro if you want to enable this `feature'.             */
+  /*                                                                       */
+/* #define FT_CONFIG_OPTION_USE_HARFBUZZ */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* DLL export compilation                                                */
+  /*                                                                       */
+  /*   When compiling FreeType as a DLL, some systems/compilers need a     */
+  /*   special keyword in front OR after the return type of function       */
+  /*   declarations.                                                       */
+  /*                                                                       */
+  /*   Two macros are used within the FreeType source code to define       */
+  /*   exported library functions: FT_EXPORT and FT_EXPORT_DEF.            */
+  /*                                                                       */
+  /*     FT_EXPORT( return_type )                                          */
+  /*                                                                       */
+  /*       is used in a function declaration, as in                        */
+  /*                                                                       */
+  /*         FT_EXPORT( FT_Error )                                         */
+  /*         FT_Init_FreeType( FT_Library*  alibrary );                    */
+  /*                                                                       */
+  /*                                                                       */
+  /*     FT_EXPORT_DEF( return_type )                                      */
+  /*                                                                       */
+  /*       is used in a function definition, as in                         */
+  /*                                                                       */
+  /*         FT_EXPORT_DEF( FT_Error )                                     */
+  /*         FT_Init_FreeType( FT_Library*  alibrary )                     */
+  /*         {                                                             */
+  /*           ... some code ...                                           */
+  /*           return FT_Err_Ok;                                           */
+  /*         }                                                             */
+  /*                                                                       */
+  /*   You can provide your own implementation of FT_EXPORT and            */
+  /*   FT_EXPORT_DEF here if you want.  If you leave them undefined, they  */
+  /*   will be later automatically defined as `extern return_type' to      */
+  /*   allow normal compilation.                                           */
+  /*                                                                       */
+  /*   Do not #undef these macros here since the build system might define */
+  /*   them for certain configurations only.                               */
+  /*                                                                       */
+/* #define FT_EXPORT(x)      extern x */
+/* #define FT_EXPORT_DEF(x)  x */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Glyph Postscript Names handling                                       */
+  /*                                                                       */
+  /*   By default, FreeType 2 is compiled with the `psnames' module.  This */
+  /*   module is in charge of converting a glyph name string into a        */
+  /*   Unicode value, or return a Macintosh standard glyph name for the    */
+  /*   use with the TrueType `post' table.                                 */
+  /*                                                                       */
+  /*   Undefine this macro if you do not want `psnames' compiled in your   */
+  /*   build of FreeType.  This has the following effects:                 */
+  /*                                                                       */
+  /*   - The TrueType driver will provide its own set of glyph names,      */
+  /*     if you build it to support postscript names in the TrueType       */
+  /*     `post' table, but will not synthesize a missing Unicode charmap.  */
+  /*                                                                       */
+  /*   - The Type 1 driver will not be able to synthesize a Unicode        */
+  /*     charmap out of the glyphs found in the fonts.                     */
+  /*                                                                       */
+  /*   You would normally undefine this configuration macro when building  */
+  /*   a version of FreeType that doesn't contain a Type 1 or CFF driver.  */
+  /*                                                                       */
+#define FT_CONFIG_OPTION_POSTSCRIPT_NAMES
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Postscript Names to Unicode Values support                            */
+  /*                                                                       */
+  /*   By default, FreeType 2 is built with the `PSNames' module compiled  */
+  /*   in.  Among other things, the module is used to convert a glyph name */
+  /*   into a Unicode value.  This is especially useful in order to        */
+  /*   synthesize on the fly a Unicode charmap from the CFF/Type 1 driver  */
+  /*   through a big table named the `Adobe Glyph List' (AGL).             */
+  /*                                                                       */
+  /*   Undefine this macro if you do not want the Adobe Glyph List         */
+  /*   compiled in your `PSNames' module.  The Type 1 driver will not be   */
+  /*   able to synthesize a Unicode charmap out of the glyphs found in the */
+  /*   fonts.                                                              */
+  /*                                                                       */
+#define FT_CONFIG_OPTION_ADOBE_GLYPH_LIST
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Support for Mac fonts                                                 */
+  /*                                                                       */
+  /*   Define this macro if you want support for outline fonts in Mac      */
+  /*   format (mac dfont, mac resource, macbinary containing a mac         */
+  /*   resource) on non-Mac platforms.                                     */
+  /*                                                                       */
+  /*   Note that the `FOND' resource isn't checked.                        */
+  /*                                                                       */
+#define FT_CONFIG_OPTION_MAC_FONTS
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Guessing methods to access embedded resource forks                    */
+  /*                                                                       */
+  /*   Enable extra Mac fonts support on non-Mac platforms (e.g.           */
+  /*   GNU/Linux).                                                         */
+  /*                                                                       */
+  /*   Resource forks which include fonts data are stored sometimes in     */
+  /*   locations which users or developers don't expected.  In some cases, */
+  /*   resource forks start with some offset from the head of a file.  In  */
+  /*   other cases, the actual resource fork is stored in file different   */
+  /*   from what the user specifies.  If this option is activated,         */
+  /*   FreeType tries to guess whether such offsets or different file      */
+  /*   names must be used.                                                 */
+  /*                                                                       */
+  /*   Note that normal, direct access of resource forks is controlled via */
+  /*   the FT_CONFIG_OPTION_MAC_FONTS option.                              */
+  /*                                                                       */
+#ifdef FT_CONFIG_OPTION_MAC_FONTS
+#define FT_CONFIG_OPTION_GUESSING_EMBEDDED_RFORK
+#endif
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Allow the use of FT_Incremental_Interface to load typefaces that      */
+  /* contain no glyph data, but supply it via a callback function.         */
+  /* This is required by clients supporting document formats which         */
+  /* supply font data incrementally as the document is parsed, such        */
+  /* as the Ghostscript interpreter for the PostScript language.           */
+  /*                                                                       */
+#define FT_CONFIG_OPTION_INCREMENTAL
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The size in bytes of the render pool used by the scan-line converter  */
+  /* to do all of its work.                                                */
+  /*                                                                       */
+#define FT_RENDER_POOL_SIZE  16384L
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* FT_MAX_MODULES                                                        */
+  /*                                                                       */
+  /*   The maximum number of modules that can be registered in a single    */
+  /*   FreeType library object.  32 is the default.                        */
+  /*                                                                       */
+#define FT_MAX_MODULES  32
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Debug level                                                           */
+  /*                                                                       */
+  /*   FreeType can be compiled in debug or trace mode.  In debug mode,    */
+  /*   errors are reported through the `ftdebug' component.  In trace      */
+  /*   mode, additional messages are sent to the standard output during    */
+  /*   execution.                                                          */
+  /*                                                                       */
+  /*   Define FT_DEBUG_LEVEL_ERROR to build the library in debug mode.     */
+  /*   Define FT_DEBUG_LEVEL_TRACE to build it in trace mode.              */
+  /*                                                                       */
+  /*   Don't define any of these macros to compile in `release' mode!      */
+  /*                                                                       */
+  /*   Do not #undef these macros here since the build system might define */
+  /*   them for certain configurations only.                               */
+  /*                                                                       */
+/* #define FT_DEBUG_LEVEL_ERROR */
+/* #define FT_DEBUG_LEVEL_TRACE */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Autofitter debugging                                                  */
+  /*                                                                       */
+  /*   If FT_DEBUG_AUTOFIT is defined, FreeType provides some means to     */
+  /*   control the autofitter behaviour for debugging purposes with global */
+  /*   boolean variables (consequently, you should *never* enable this     */
+  /*   while compiling in `release' mode):                                 */
+  /*                                                                       */
+  /*     _af_debug_disable_horz_hints                                      */
+  /*     _af_debug_disable_vert_hints                                      */
+  /*     _af_debug_disable_blue_hints                                      */
+  /*                                                                       */
+  /*   Additionally, the following functions provide dumps of various      */
+  /*   internal autofit structures to stdout (using `printf'):             */
+  /*                                                                       */
+  /*     af_glyph_hints_dump_points                                        */
+  /*     af_glyph_hints_dump_segments                                      */
+  /*     af_glyph_hints_dump_edges                                         */
+  /*     af_glyph_hints_get_num_segments                                   */
+  /*     af_glyph_hints_get_segment_offset                                 */
+  /*                                                                       */
+  /*   As an argument, they use another global variable:                   */
+  /*                                                                       */
+  /*     _af_debug_hints                                                   */
+  /*                                                                       */
+  /*   Please have a look at the `ftgrid' demo program to see how those    */
+  /*   variables and macros should be used.                                */
+  /*                                                                       */
+  /*   Do not #undef these macros here since the build system might define */
+  /*   them for certain configurations only.                               */
+  /*                                                                       */
+/* #define FT_DEBUG_AUTOFIT */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Memory Debugging                                                      */
+  /*                                                                       */
+  /*   FreeType now comes with an integrated memory debugger that is       */
+  /*   capable of detecting simple errors like memory leaks or double      */
+  /*   deletes.  To compile it within your build of the library, you       */
+  /*   should define FT_DEBUG_MEMORY here.                                 */
+  /*                                                                       */
+  /*   Note that the memory debugger is only activated at runtime when     */
+  /*   when the _environment_ variable `FT2_DEBUG_MEMORY' is defined also! */
+  /*                                                                       */
+  /*   Do not #undef this macro here since the build system might define   */
+  /*   it for certain configurations only.                                 */
+  /*                                                                       */
+/* #define FT_DEBUG_MEMORY */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Module errors                                                         */
+  /*                                                                       */
+  /*   If this macro is set (which is _not_ the default), the higher byte  */
+  /*   of an error code gives the module in which the error has occurred,  */
+  /*   while the lower byte is the real error code.                        */
+  /*                                                                       */
+  /*   Setting this macro makes sense for debugging purposes only, since   */
+  /*   it would break source compatibility of certain programs that use    */
+  /*   FreeType 2.                                                         */
+  /*                                                                       */
+  /*   More details can be found in the files ftmoderr.h and fterrors.h.   */
+  /*                                                                       */
+#undef FT_CONFIG_OPTION_USE_MODULE_ERRORS
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Position Independent Code                                             */
+  /*                                                                       */
+  /*   If this macro is set (which is _not_ the default), FreeType2 will   */
+  /*   avoid creating constants that require address fixups.  Instead the  */
+  /*   constants will be moved into a struct and additional intialization  */
+  /*   code will be used.                                                  */
+  /*                                                                       */
+  /*   Setting this macro is needed for systems that prohibit address      */
+  /*   fixups, such as BREW.  [Note that standard compilers like gcc or    */
+  /*   clang handle PIC generation automatically; you don't have to set    */
+  /*   FT_CONFIG_OPTION_PIC, which is only necessary for very special      */
+  /*   compilers.]                                                         */
+  /*                                                                       */
+  /*   Note that FT_CONFIG_OPTION_PIC support is not available for all     */
+  /*   modules (see `modules.cfg' for a complete list).  For building with */
+  /*   FT_CONFIG_OPTION_PIC support, do the following.                     */
+  /*                                                                       */
+  /*     0. Clone the repository.                                          */
+  /*     1. Define FT_CONFIG_OPTION_PIC.                                   */
+  /*     2. Remove all subdirectories in `src' that don't have             */
+  /*        FT_CONFIG_OPTION_PIC support.                                  */
+  /*     3. Comment out the corresponding modules in `modules.cfg'.        */
+  /*     4. Compile.                                                       */
+  /*                                                                       */
+/* #define FT_CONFIG_OPTION_PIC */
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****        S F N T   D R I V E R    C O N F I G U R A T I O N       ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Define TT_CONFIG_OPTION_EMBEDDED_BITMAPS if you want to support       */
+  /* embedded bitmaps in all formats using the SFNT module (namely         */
+  /* TrueType & OpenType).                                                 */
+  /*                                                                       */
+#define TT_CONFIG_OPTION_EMBEDDED_BITMAPS
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Define TT_CONFIG_OPTION_POSTSCRIPT_NAMES if you want to be able to    */
+  /* load and enumerate the glyph Postscript names in a TrueType or        */
+  /* OpenType file.                                                        */
+  /*                                                                       */
+  /* Note that when you do not compile the `PSNames' module by undefining  */
+  /* the above FT_CONFIG_OPTION_POSTSCRIPT_NAMES, the `sfnt' module will   */
+  /* contain additional code used to read the PS Names table from a font.  */
+  /*                                                                       */
+  /* (By default, the module uses `PSNames' to extract glyph names.)       */
+  /*                                                                       */
+#define TT_CONFIG_OPTION_POSTSCRIPT_NAMES
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Define TT_CONFIG_OPTION_SFNT_NAMES if your applications need to       */
+  /* access the internal name table in a SFNT-based format like TrueType   */
+  /* or OpenType.  The name table contains various strings used to         */
+  /* describe the font, like family name, copyright, version, etc.  It     */
+  /* does not contain any glyph name though.                               */
+  /*                                                                       */
+  /* Accessing SFNT names is done through the functions declared in        */
+  /* `ftsnames.h'.                                                         */
+  /*                                                                       */
+#define TT_CONFIG_OPTION_SFNT_NAMES
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* TrueType CMap support                                                 */
+  /*                                                                       */
+  /*   Here you can fine-tune which TrueType CMap table format shall be    */
+  /*   supported.                                                          */
+#define TT_CONFIG_CMAP_FORMAT_0
+#define TT_CONFIG_CMAP_FORMAT_2
+#define TT_CONFIG_CMAP_FORMAT_4
+#define TT_CONFIG_CMAP_FORMAT_6
+#define TT_CONFIG_CMAP_FORMAT_8
+#define TT_CONFIG_CMAP_FORMAT_10
+#define TT_CONFIG_CMAP_FORMAT_12
+#define TT_CONFIG_CMAP_FORMAT_13
+#define TT_CONFIG_CMAP_FORMAT_14
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****    T R U E T Y P E   D R I V E R    C O N F I G U R A T I O N   ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Define TT_CONFIG_OPTION_BYTECODE_INTERPRETER if you want to compile   */
+  /* a bytecode interpreter in the TrueType driver.                        */
+  /*                                                                       */
+  /* By undefining this, you will only compile the code necessary to load  */
+  /* TrueType glyphs without hinting.                                      */
+  /*                                                                       */
+  /*   Do not #undef this macro here, since the build system might         */
+  /*   define it for certain configurations only.                          */
+  /*                                                                       */
+#define TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Define TT_CONFIG_OPTION_SUBPIXEL_HINTING if you want to compile       */
+  /* subpixel hinting support into the TrueType driver.  This modifies the */
+  /* TrueType hinting mechanism when anything but FT_RENDER_MODE_MONO is   */
+  /* requested.                                                            */
+  /*                                                                       */
+  /* In particular, it modifies the bytecode interpreter to interpret (or  */
+  /* not) instructions in a certain way so that all TrueType fonts look    */
+  /* like they do in a Windows ClearType (DirectWrite) environment.  See   */
+  /* [1] for a technical overview on what this means.  See `ttinterp.h'    */
+  /* for more details on the LEAN option.                                  */
+  /*                                                                       */
+  /* There are three possible values.                                      */
+  /*                                                                       */
+  /* Value 1:                                                              */
+  /*    This value is associated with the `Infinality' moniker,            */
+  /*    contributed by an individual nicknamed Infinality with the goal of */
+  /*    making TrueType fonts render better than on Windows.  A high       */
+  /*    amount of configurability and flexibility, down to rules for       */
+  /*    single glyphs in fonts, but also very slow.  Its experimental and  */
+  /*    slow nature and the original developer losing interest meant that  */
+  /*    this option was never enabled in default builds.                   */
+  /*                                                                       */
+  /*    The corresponding interpreter version is v38.                      */
+  /*                                                                       */
+  /* Value 2:                                                              */
+  /*    The new default mode for the TrueType driver.  The Infinality code */
+  /*    base was stripped to the bare minimum and all configurability      */
+  /*    removed in the name of speed and simplicity.  The configurability  */
+  /*    was mainly aimed at legacy fonts like Arial, Times New Roman, or   */
+  /*    Courier.  Legacy fonts are fonts that modify vertical stems to     */
+  /*    achieve clean black-and-white bitmaps.  The new mode focuses on    */
+  /*    applying a minimal set of rules to all fonts indiscriminately so   */
+  /*    that modern and web fonts render well while legacy fonts render    */
+  /*    okay.                                                              */
+  /*                                                                       */
+  /*    The corresponding interpreter version is v40.                      */
+  /*                                                                       */
+  /* Value 3:                                                              */
+  /*    Compile both, making both v38 and v40 available (the latter is the */
+  /*    default).                                                          */
+  /*                                                                       */
+  /* By undefining these, you get rendering behavior like on Windows       */
+  /* without ClearType, i.e., Windows XP without ClearType enabled and     */
+  /* Win9x (interpreter version v35).  Or not, depending on how much       */
+  /* hinting blood and testing tears the font designer put into a given    */
+  /* font.  If you define one or both subpixel hinting options, you can    */
+  /* switch between between v35 and the ones you define (using             */
+  /* `FT_Property_Set').                                                   */
+  /*                                                                       */
+  /* This option requires TT_CONFIG_OPTION_BYTECODE_INTERPRETER to be      */
+  /* defined.                                                              */
+  /*                                                                       */
+  /* [1] http://www.microsoft.com/typography/cleartype/truetypecleartype.aspx */
+  /*                                                                       */
+/* #define TT_CONFIG_OPTION_SUBPIXEL_HINTING  1         */
+#define TT_CONFIG_OPTION_SUBPIXEL_HINTING  2
+/* #define TT_CONFIG_OPTION_SUBPIXEL_HINTING  ( 1 | 2 ) */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Define TT_CONFIG_OPTION_COMPONENT_OFFSET_SCALED to compile the        */
+  /* TrueType glyph loader to use Apple's definition of how to handle      */
+  /* component offsets in composite glyphs.                                */
+  /*                                                                       */
+  /* Apple and MS disagree on the default behavior of component offsets    */
+  /* in composites.  Apple says that they should be scaled by the scaling  */
+  /* factors in the transformation matrix (roughly, it's more complex)     */
+  /* while MS says they should not.  OpenType defines two bits in the      */
+  /* composite flags array which can be used to disambiguate, but old      */
+  /* fonts will not have them.                                             */
+  /*                                                                       */
+  /*   http://www.microsoft.com/typography/otspec/glyf.htm                 */
+  /*   https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6glyf.html */
+  /*                                                                       */
+#undef TT_CONFIG_OPTION_COMPONENT_OFFSET_SCALED
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Define TT_CONFIG_OPTION_GX_VAR_SUPPORT if you want to include         */
+  /* support for Apple's distortable font technology (fvar, gvar, cvar,    */
+  /* and avar tables).  This has many similarities to Type 1 Multiple      */
+  /* Masters support.                                                      */
+  /*                                                                       */
+#define TT_CONFIG_OPTION_GX_VAR_SUPPORT
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Define TT_CONFIG_OPTION_BDF if you want to include support for        */
+  /* an embedded `BDF ' table within SFNT-based bitmap formats.            */
+  /*                                                                       */
+#define TT_CONFIG_OPTION_BDF
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Option TT_CONFIG_OPTION_MAX_RUNNABLE_OPCODES controls the maximum     */
+  /* number of bytecode instructions executed for a single run of the      */
+  /* bytecode interpreter, needed to prevent infinite loops.  You don't    */
+  /* want to change this except for very special situations (e.g., making  */
+  /* a library fuzzer spend less time to handle broken fonts).             */
+  /*                                                                       */
+  /* It is not expected that this value is ever modified by a configuring  */
+  /* script; instead, it gets surrounded with #ifndef ... #endif so that   */
+  /* the value can be set as a preprocessor option on the compiler's       */
+  /* command line.                                                         */
+  /*                                                                       */
+#ifndef TT_CONFIG_OPTION_MAX_RUNNABLE_OPCODES
+#define TT_CONFIG_OPTION_MAX_RUNNABLE_OPCODES  1000000L
+#endif
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****      T Y P E 1   D R I V E R    C O N F I G U R A T I O N       ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* T1_MAX_DICT_DEPTH is the maximum depth of nest dictionaries and       */
+  /* arrays in the Type 1 stream (see t1load.c).  A minimum of 4 is        */
+  /* required.                                                             */
+  /*                                                                       */
+#define T1_MAX_DICT_DEPTH  5
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* T1_MAX_SUBRS_CALLS details the maximum number of nested sub-routine   */
+  /* calls during glyph loading.                                           */
+  /*                                                                       */
+#define T1_MAX_SUBRS_CALLS  16
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* T1_MAX_CHARSTRING_OPERANDS is the charstring stack's capacity.  A     */
+  /* minimum of 16 is required.                                            */
+  /*                                                                       */
+  /* The Chinese font MingTiEG-Medium (CNS 11643 character set) needs 256. */
+  /*                                                                       */
+#define T1_MAX_CHARSTRINGS_OPERANDS  256
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Define this configuration macro if you want to prevent the            */
+  /* compilation of `t1afm', which is in charge of reading Type 1 AFM      */
+  /* files into an existing face.  Note that if set, the T1 driver will be */
+  /* unable to produce kerning distances.                                  */
+  /*                                                                       */
+#undef T1_CONFIG_OPTION_NO_AFM
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Define this configuration macro if you want to prevent the            */
+  /* compilation of the Multiple Masters font support in the Type 1        */
+  /* driver.                                                               */
+  /*                                                                       */
+#undef T1_CONFIG_OPTION_NO_MM_SUPPORT
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****         C F F   D R I V E R    C O N F I G U R A T I O N        ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Using CFF_CONFIG_OPTION_DARKENING_PARAMETER_{X,Y}{1,2,3,4} it is      */
+  /* possible to set up the default values of the four control points that */
+  /* define the stem darkening behaviour of the (new) CFF engine.  For     */
+  /* more details please read the documentation of the                     */
+  /* `darkening-parameters' property of the cff driver module (file        */
+  /* `ftcffdrv.h'), which allows the control at run-time.                  */
+  /*                                                                       */
+  /* Do *not* undefine these macros!                                       */
+  /*                                                                       */
+#define CFF_CONFIG_OPTION_DARKENING_PARAMETER_X1   500
+#define CFF_CONFIG_OPTION_DARKENING_PARAMETER_Y1   400
+
+#define CFF_CONFIG_OPTION_DARKENING_PARAMETER_X2  1000
+#define CFF_CONFIG_OPTION_DARKENING_PARAMETER_Y2   275
+
+#define CFF_CONFIG_OPTION_DARKENING_PARAMETER_X3  1667
+#define CFF_CONFIG_OPTION_DARKENING_PARAMETER_Y3   275
+
+#define CFF_CONFIG_OPTION_DARKENING_PARAMETER_X4  2333
+#define CFF_CONFIG_OPTION_DARKENING_PARAMETER_Y4     0
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* CFF_CONFIG_OPTION_OLD_ENGINE controls whether the pre-Adobe CFF       */
+  /* engine gets compiled into FreeType.  If defined, it is possible to    */
+  /* switch between the two engines using the `hinting-engine' property of */
+  /* the cff driver module.                                                */
+  /*                                                                       */
+/* #define CFF_CONFIG_OPTION_OLD_ENGINE */
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****         P C F   D R I V E R    C O N F I G U R A T I O N        ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* There are many PCF fonts just called `Fixed' which look completely    */
+  /* different, and which have nothing to do with each other.  When        */
+  /* selecting `Fixed' in KDE or Gnome one gets results that appear rather */
+  /* random, the style changes often if one changes the size and one       */
+  /* cannot select some fonts at all.  This option makes the PCF module    */
+  /* prepend the foundry name (plus a space) to the family name.           */
+  /*                                                                       */
+  /* We also check whether we have `wide' characters; all put together, we */
+  /* get family names like `Sony Fixed' or `Misc Fixed Wide'.              */
+  /*                                                                       */
+  /* If this option is activated, it can be controlled with the            */
+  /* `no-long-family-names' property of the pcf driver module.             */
+  /*                                                                       */
+/* #define PCF_CONFIG_OPTION_LONG_FAMILY_NAMES */
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****    A U T O F I T   M O D U L E    C O N F I G U R A T I O N     ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Compile autofit module with CJK (Chinese, Japanese, Korean) script    */
+  /* support.                                                              */
+  /*                                                                       */
+#define AF_CONFIG_OPTION_CJK
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Compile autofit module with fallback Indic script support, covering   */
+  /* some scripts that the `latin' submodule of the autofit module doesn't */
+  /* (yet) handle.                                                         */
+  /*                                                                       */
+#define AF_CONFIG_OPTION_INDIC
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Compile autofit module with warp hinting.  The idea of the warping    */
+  /* code is to slightly scale and shift a glyph within a single dimension */
+  /* so that as much of its segments are aligned (more or less) on the     */
+  /* grid.  To find out the optimal scaling and shifting value, various    */
+  /* parameter combinations are tried and scored.                          */
+  /*                                                                       */
+  /* This experimental option is active only if the rendering mode is      */
+  /* FT_RENDER_MODE_LIGHT; you can switch warping on and off with the      */
+  /* `warping' property of the auto-hinter (see file `ftautoh.h' for more  */
+  /* information; by default it is switched off).                          */
+  /*                                                                       */
+#define AF_CONFIG_OPTION_USE_WARPER
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Use TrueType-like size metrics for `light' auto-hinting.              */
+  /*                                                                       */
+  /* It is strongly recommended to avoid this option, which exists only to */
+  /* help some legacy applications retain its appearance and behaviour     */
+  /* with respect to auto-hinted TrueType fonts.                           */
+  /*                                                                       */
+  /* The very reason this option exists at all are GNU/Linux distributions */
+  /* like Fedora that did not un-patch the following change (which was     */
+  /* present in FreeType between versions 2.4.6 and 2.7.1, inclusive).     */
+  /*                                                                       */
+  /*   2011-07-16  Steven Chu  <steven.f.chu@gmail.com>                    */
+  /*                                                                       */
+  /*     [truetype] Fix metrics on size request for scalable fonts.        */
+  /*                                                                       */
+  /* This problematic commit is now reverted (more or less).               */
+  /*                                                                       */
+/* #define AF_CONFIG_OPTION_TT_SIZE_METRICS */
+
+  /* */
+
+
+  /*
+   * This macro is obsolete.  Support has been removed in FreeType
+   * version 2.5.
+   */
+/* #define FT_CONFIG_OPTION_OLD_INTERNALS */
+
+
+  /*
+   * This macro is defined if native TrueType hinting is requested by the
+   * definitions above.
+   */
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+#define  TT_USE_BYTECODE_INTERPRETER
+
+#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
+#if TT_CONFIG_OPTION_SUBPIXEL_HINTING & 1
+#define  TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY
+#endif
+
+#if TT_CONFIG_OPTION_SUBPIXEL_HINTING & 2
+#define  TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL
+#endif
+#endif
+#endif
+
+
+  /*
+   * Check CFF darkening parameters.  The checks are the same as in function
+   * `cff_property_set' in file `cffdrivr.c'.
+   */
+#if CFF_CONFIG_OPTION_DARKENING_PARAMETER_X1 < 0   || \
+    CFF_CONFIG_OPTION_DARKENING_PARAMETER_X2 < 0   || \
+    CFF_CONFIG_OPTION_DARKENING_PARAMETER_X3 < 0   || \
+    CFF_CONFIG_OPTION_DARKENING_PARAMETER_X4 < 0   || \
+                                                      \
+    CFF_CONFIG_OPTION_DARKENING_PARAMETER_Y1 < 0   || \
+    CFF_CONFIG_OPTION_DARKENING_PARAMETER_Y2 < 0   || \
+    CFF_CONFIG_OPTION_DARKENING_PARAMETER_Y3 < 0   || \
+    CFF_CONFIG_OPTION_DARKENING_PARAMETER_Y4 < 0   || \
+                                                      \
+    CFF_CONFIG_OPTION_DARKENING_PARAMETER_X1 >        \
+      CFF_CONFIG_OPTION_DARKENING_PARAMETER_X2     || \
+    CFF_CONFIG_OPTION_DARKENING_PARAMETER_X2 >        \
+      CFF_CONFIG_OPTION_DARKENING_PARAMETER_X3     || \
+    CFF_CONFIG_OPTION_DARKENING_PARAMETER_X3 >        \
+      CFF_CONFIG_OPTION_DARKENING_PARAMETER_X4     || \
+                                                      \
+    CFF_CONFIG_OPTION_DARKENING_PARAMETER_Y1 > 500 || \
+    CFF_CONFIG_OPTION_DARKENING_PARAMETER_Y2 > 500 || \
+    CFF_CONFIG_OPTION_DARKENING_PARAMETER_Y3 > 500 || \
+    CFF_CONFIG_OPTION_DARKENING_PARAMETER_Y4 > 500
+#error "Invalid CFF darkening parameters!"
+#endif
+
+FT_END_HEADER
+
+
+#endif /* FTOPTION_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/config/ftstdlib.h b/engine/inc/freetype/config/ftstdlib.h
new file mode 100644
index 00000000..05a4845f
--- /dev/null
+++ b/engine/inc/freetype/config/ftstdlib.h
@@ -0,0 +1,175 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftstdlib.h                                                             */
+/*                                                                         */
+/*    ANSI-specific library and header configuration file (specification   */
+/*    only).                                                               */
+/*                                                                         */
+/*  Copyright 2002-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This file is used to group all #includes to the ANSI C library that   */
+  /* FreeType normally requires.  It also defines macros to rename the     */
+  /* standard functions within the FreeType source code.                   */
+  /*                                                                       */
+  /* Load a file which defines FTSTDLIB_H_ before this one to override it. */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#ifndef FTSTDLIB_H_
+#define FTSTDLIB_H_
+
+
+#include <stddef.h>
+
+#define ft_ptrdiff_t  ptrdiff_t
+
+
+  /**********************************************************************/
+  /*                                                                    */
+  /*                           integer limits                           */
+  /*                                                                    */
+  /* UINT_MAX and ULONG_MAX are used to automatically compute the size  */
+  /* of `int' and `long' in bytes at compile-time.  So far, this works  */
+  /* for all platforms the library has been tested on.                  */
+  /*                                                                    */
+  /* Note that on the extremely rare platforms that do not provide      */
+  /* integer types that are _exactly_ 16 and 32 bits wide (e.g. some    */
+  /* old Crays where `int' is 36 bits), we do not make any guarantee    */
+  /* about the correct behaviour of FT2 with all fonts.                 */
+  /*                                                                    */
+  /* In these case, `ftconfig.h' will refuse to compile anyway with a   */
+  /* message like `couldn't find 32-bit type' or something similar.     */
+  /*                                                                    */
+  /**********************************************************************/
+
+
+#include <limits.h>
+
+#define FT_CHAR_BIT    CHAR_BIT
+#define FT_USHORT_MAX  USHRT_MAX
+#define FT_INT_MAX     INT_MAX
+#define FT_INT_MIN     INT_MIN
+#define FT_UINT_MAX    UINT_MAX
+#define FT_LONG_MIN    LONG_MIN
+#define FT_LONG_MAX    LONG_MAX
+#define FT_ULONG_MAX   ULONG_MAX
+
+
+  /**********************************************************************/
+  /*                                                                    */
+  /*                 character and string processing                    */
+  /*                                                                    */
+  /**********************************************************************/
+
+
+#include <string.h>
+
+#define ft_memchr   memchr
+#define ft_memcmp   memcmp
+#define ft_memcpy   memcpy
+#define ft_memmove  memmove
+#define ft_memset   memset
+#define ft_strcat   strcat
+#define ft_strcmp   strcmp
+#define ft_strcpy   strcpy
+#define ft_strlen   strlen
+#define ft_strncmp  strncmp
+#define ft_strncpy  strncpy
+#define ft_strrchr  strrchr
+#define ft_strstr   strstr
+
+
+  /**********************************************************************/
+  /*                                                                    */
+  /*                           file handling                            */
+  /*                                                                    */
+  /**********************************************************************/
+
+
+#include <stdio.h>
+
+#define FT_FILE     FILE
+#define ft_fclose   fclose
+#define ft_fopen    fopen
+#define ft_fread    fread
+#define ft_fseek    fseek
+#define ft_ftell    ftell
+#define ft_sprintf  sprintf
+
+
+  /**********************************************************************/
+  /*                                                                    */
+  /*                             sorting                                */
+  /*                                                                    */
+  /**********************************************************************/
+
+
+#include <stdlib.h>
+
+#define ft_qsort  qsort
+
+
+  /**********************************************************************/
+  /*                                                                    */
+  /*                        memory allocation                           */
+  /*                                                                    */
+  /**********************************************************************/
+
+
+#define ft_scalloc   calloc
+#define ft_sfree     free
+#define ft_smalloc   malloc
+#define ft_srealloc  realloc
+
+
+  /**********************************************************************/
+  /*                                                                    */
+  /*                          miscellaneous                             */
+  /*                                                                    */
+  /**********************************************************************/
+
+
+#define ft_strtol  strtol
+#define ft_getenv  getenv
+
+
+  /**********************************************************************/
+  /*                                                                    */
+  /*                         execution control                          */
+  /*                                                                    */
+  /**********************************************************************/
+
+
+#include <setjmp.h>
+
+#define ft_jmp_buf     jmp_buf  /* note: this cannot be a typedef since */
+                                /*       jmp_buf is defined as a macro  */
+                                /*       on certain platforms           */
+
+#define ft_longjmp     longjmp
+#define ft_setjmp( b ) setjmp( *(ft_jmp_buf*) &(b) ) /* same thing here */
+
+
+  /* the following is only used for debugging purposes, i.e., if */
+  /* FT_DEBUG_LEVEL_ERROR or FT_DEBUG_LEVEL_TRACE are defined    */
+
+#include <stdarg.h>
+
+
+#endif /* FTSTDLIB_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/freetype.h b/engine/inc/freetype/freetype.h
new file mode 100644
index 00000000..b0c26179
--- /dev/null
+++ b/engine/inc/freetype/freetype.h
@@ -0,0 +1,4557 @@
+/***************************************************************************/
+/*                                                                         */
+/*  freetype.h                                                             */
+/*                                                                         */
+/*    FreeType high-level API and common types (specification only).       */
+/*                                                                         */
+/*  Copyright 1996-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FREETYPE_H_
+#define FREETYPE_H_
+
+
+#ifndef FT_FREETYPE_H
+#error "`ft2build.h' hasn't been included yet!"
+#error "Please always use macros to include FreeType header files."
+#error "Example:"
+#error "  #include <ft2build.h>"
+#error "  #include FT_FREETYPE_H"
+#endif
+
+
+#include <ft2build.h>
+#include FT_CONFIG_CONFIG_H
+#include FT_TYPES_H
+#include FT_ERRORS_H
+
+
+FT_BEGIN_HEADER
+
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    header_inclusion                                                   */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    FreeType's header inclusion scheme                                 */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    How client applications should include FreeType header files.      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    To be as flexible as possible (and for historical reasons),        */
+  /*    FreeType uses a very special inclusion scheme to load header       */
+  /*    files, for example                                                 */
+  /*                                                                       */
+  /*    {                                                                  */
+  /*      #include <ft2build.h>                                            */
+  /*                                                                       */
+  /*      #include FT_FREETYPE_H                                           */
+  /*      #include FT_OUTLINE_H                                            */
+  /*    }                                                                  */
+  /*                                                                       */
+  /*    A compiler and its preprocessor only needs an include path to find */
+  /*    the file `ft2build.h'; the exact locations and names of the other  */
+  /*    FreeType header files are hidden by preprocessor macro names,      */
+  /*    loaded by `ft2build.h'.  The API documentation always gives the    */
+  /*    header macro name needed for a particular function.                */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    user_allocation                                                    */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    User allocation                                                    */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    How client applications should allocate FreeType data structures.  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    FreeType assumes that structures allocated by the user and passed  */
+  /*    as arguments are zeroed out except for the actual data.  In other  */
+  /*    words, it is recommended to use `calloc' (or variants of it)       */
+  /*    instead of `malloc' for allocation.                                */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*                                                                       */
+  /*                        B A S I C   T Y P E S                          */
+  /*                                                                       */
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    base_interface                                                     */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    Base Interface                                                     */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    The FreeType~2 base font interface.                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section describes the most important public high-level API    */
+  /*    functions of FreeType~2.                                           */
+  /*                                                                       */
+  /* <Order>                                                               */
+  /*    FT_Library                                                         */
+  /*    FT_Face                                                            */
+  /*    FT_Size                                                            */
+  /*    FT_GlyphSlot                                                       */
+  /*    FT_CharMap                                                         */
+  /*    FT_Encoding                                                        */
+  /*    FT_ENC_TAG                                                         */
+  /*                                                                       */
+  /*    FT_FaceRec                                                         */
+  /*                                                                       */
+  /*    FT_FACE_FLAG_SCALABLE                                              */
+  /*    FT_FACE_FLAG_FIXED_SIZES                                           */
+  /*    FT_FACE_FLAG_FIXED_WIDTH                                           */
+  /*    FT_FACE_FLAG_HORIZONTAL                                            */
+  /*    FT_FACE_FLAG_VERTICAL                                              */
+  /*    FT_FACE_FLAG_COLOR                                                 */
+  /*    FT_FACE_FLAG_SFNT                                                  */
+  /*    FT_FACE_FLAG_CID_KEYED                                             */
+  /*    FT_FACE_FLAG_TRICKY                                                */
+  /*    FT_FACE_FLAG_KERNING                                               */
+  /*    FT_FACE_FLAG_MULTIPLE_MASTERS                                      */
+  /*    FT_FACE_FLAG_GLYPH_NAMES                                           */
+  /*    FT_FACE_FLAG_EXTERNAL_STREAM                                       */
+  /*    FT_FACE_FLAG_HINTER                                                */
+  /*                                                                       */
+  /*    FT_HAS_HORIZONTAL                                                  */
+  /*    FT_HAS_VERTICAL                                                    */
+  /*    FT_HAS_KERNING                                                     */
+  /*    FT_HAS_FIXED_SIZES                                                 */
+  /*    FT_HAS_GLYPH_NAMES                                                 */
+  /*    FT_HAS_MULTIPLE_MASTERS                                            */
+  /*    FT_HAS_COLOR                                                       */
+  /*                                                                       */
+  /*    FT_IS_SFNT                                                         */
+  /*    FT_IS_SCALABLE                                                     */
+  /*    FT_IS_FIXED_WIDTH                                                  */
+  /*    FT_IS_CID_KEYED                                                    */
+  /*    FT_IS_TRICKY                                                       */
+  /*                                                                       */
+  /*    FT_STYLE_FLAG_BOLD                                                 */
+  /*    FT_STYLE_FLAG_ITALIC                                               */
+  /*                                                                       */
+  /*    FT_SizeRec                                                         */
+  /*    FT_Size_Metrics                                                    */
+  /*                                                                       */
+  /*    FT_GlyphSlotRec                                                    */
+  /*    FT_Glyph_Metrics                                                   */
+  /*    FT_SubGlyph                                                        */
+  /*                                                                       */
+  /*    FT_Bitmap_Size                                                     */
+  /*                                                                       */
+  /*    FT_Init_FreeType                                                   */
+  /*    FT_Done_FreeType                                                   */
+  /*                                                                       */
+  /*    FT_New_Face                                                        */
+  /*    FT_Done_Face                                                       */
+  /*    FT_Reference_Face                                                  */
+  /*    FT_New_Memory_Face                                                 */
+  /*    FT_Face_Properties                                                 */
+  /*    FT_Open_Face                                                       */
+  /*    FT_Open_Args                                                       */
+  /*    FT_Parameter                                                       */
+  /*    FT_Attach_File                                                     */
+  /*    FT_Attach_Stream                                                   */
+  /*                                                                       */
+  /*    FT_Set_Char_Size                                                   */
+  /*    FT_Set_Pixel_Sizes                                                 */
+  /*    FT_Request_Size                                                    */
+  /*    FT_Select_Size                                                     */
+  /*    FT_Size_Request_Type                                               */
+  /*    FT_Size_RequestRec                                                 */
+  /*    FT_Size_Request                                                    */
+  /*    FT_Set_Transform                                                   */
+  /*    FT_Load_Glyph                                                      */
+  /*    FT_Get_Char_Index                                                  */
+  /*    FT_Get_First_Char                                                  */
+  /*    FT_Get_Next_Char                                                   */
+  /*    FT_Get_Name_Index                                                  */
+  /*    FT_Load_Char                                                       */
+  /*                                                                       */
+  /*    FT_OPEN_MEMORY                                                     */
+  /*    FT_OPEN_STREAM                                                     */
+  /*    FT_OPEN_PATHNAME                                                   */
+  /*    FT_OPEN_DRIVER                                                     */
+  /*    FT_OPEN_PARAMS                                                     */
+  /*                                                                       */
+  /*    FT_LOAD_DEFAULT                                                    */
+  /*    FT_LOAD_RENDER                                                     */
+  /*    FT_LOAD_MONOCHROME                                                 */
+  /*    FT_LOAD_LINEAR_DESIGN                                              */
+  /*    FT_LOAD_NO_SCALE                                                   */
+  /*    FT_LOAD_NO_HINTING                                                 */
+  /*    FT_LOAD_NO_BITMAP                                                  */
+  /*    FT_LOAD_NO_AUTOHINT                                                */
+  /*    FT_LOAD_COLOR                                                      */
+  /*                                                                       */
+  /*    FT_LOAD_VERTICAL_LAYOUT                                            */
+  /*    FT_LOAD_IGNORE_TRANSFORM                                           */
+  /*    FT_LOAD_FORCE_AUTOHINT                                             */
+  /*    FT_LOAD_NO_RECURSE                                                 */
+  /*    FT_LOAD_PEDANTIC                                                   */
+  /*                                                                       */
+  /*    FT_LOAD_TARGET_NORMAL                                              */
+  /*    FT_LOAD_TARGET_LIGHT                                               */
+  /*    FT_LOAD_TARGET_MONO                                                */
+  /*    FT_LOAD_TARGET_LCD                                                 */
+  /*    FT_LOAD_TARGET_LCD_V                                               */
+  /*                                                                       */
+  /*    FT_LOAD_TARGET_MODE                                                */
+  /*                                                                       */
+  /*    FT_Render_Glyph                                                    */
+  /*    FT_Render_Mode                                                     */
+  /*    FT_Get_Kerning                                                     */
+  /*    FT_Kerning_Mode                                                    */
+  /*    FT_Get_Track_Kerning                                               */
+  /*    FT_Get_Glyph_Name                                                  */
+  /*    FT_Get_Postscript_Name                                             */
+  /*                                                                       */
+  /*    FT_CharMapRec                                                      */
+  /*    FT_Select_Charmap                                                  */
+  /*    FT_Set_Charmap                                                     */
+  /*    FT_Get_Charmap_Index                                               */
+  /*                                                                       */
+  /*    FT_Get_FSType_Flags                                                */
+  /*    FT_Get_SubGlyph_Info                                               */
+  /*                                                                       */
+  /*    FT_Face_Internal                                                   */
+  /*    FT_Size_Internal                                                   */
+  /*    FT_Slot_Internal                                                   */
+  /*                                                                       */
+  /*    FT_FACE_FLAG_XXX                                                   */
+  /*    FT_STYLE_FLAG_XXX                                                  */
+  /*    FT_OPEN_XXX                                                        */
+  /*    FT_LOAD_XXX                                                        */
+  /*    FT_LOAD_TARGET_XXX                                                 */
+  /*    FT_SUBGLYPH_FLAG_XXX                                               */
+  /*    FT_FSTYPE_XXX                                                      */
+  /*                                                                       */
+  /*    FT_HAS_FAST_GLYPHS                                                 */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Glyph_Metrics                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure to model the metrics of a single glyph.  The values    */
+  /*    are expressed in 26.6 fractional pixel format; if the flag         */
+  /*    @FT_LOAD_NO_SCALE has been used while loading the glyph, values    */
+  /*    are expressed in font units instead.                               */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    width ::                                                           */
+  /*      The glyph's width.                                               */
+  /*                                                                       */
+  /*    height ::                                                          */
+  /*      The glyph's height.                                              */
+  /*                                                                       */
+  /*    horiBearingX ::                                                    */
+  /*      Left side bearing for horizontal layout.                         */
+  /*                                                                       */
+  /*    horiBearingY ::                                                    */
+  /*      Top side bearing for horizontal layout.                          */
+  /*                                                                       */
+  /*    horiAdvance ::                                                     */
+  /*      Advance width for horizontal layout.                             */
+  /*                                                                       */
+  /*    vertBearingX ::                                                    */
+  /*      Left side bearing for vertical layout.                           */
+  /*                                                                       */
+  /*    vertBearingY ::                                                    */
+  /*      Top side bearing for vertical layout.  Larger positive values    */
+  /*      mean further below the vertical glyph origin.                    */
+  /*                                                                       */
+  /*    vertAdvance ::                                                     */
+  /*      Advance height for vertical layout.  Positive values mean the    */
+  /*      glyph has a positive advance downward.                           */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    If not disabled with @FT_LOAD_NO_HINTING, the values represent     */
+  /*    dimensions of the hinted glyph (in case hinting is applicable).    */
+  /*                                                                       */
+  /*    Stroking a glyph with an outside border does not increase          */
+  /*    `horiAdvance' or `vertAdvance'; you have to manually adjust these  */
+  /*    values to account for the added width and height.                  */
+  /*                                                                       */
+  /*    FreeType doesn't use the `VORG' table data for CFF fonts because   */
+  /*    it doesn't have an interface to quickly retrieve the glyph height. */
+  /*    The y~coordinate of the vertical origin can be simply computed as  */
+  /*    `vertBearingY + height' after loading a glyph.                     */
+  /*                                                                       */
+  typedef struct  FT_Glyph_Metrics_
+  {
+    FT_Pos  width;
+    FT_Pos  height;
+
+    FT_Pos  horiBearingX;
+    FT_Pos  horiBearingY;
+    FT_Pos  horiAdvance;
+
+    FT_Pos  vertBearingX;
+    FT_Pos  vertBearingY;
+    FT_Pos  vertAdvance;
+
+  } FT_Glyph_Metrics;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Bitmap_Size                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This structure models the metrics of a bitmap strike (i.e., a set  */
+  /*    of glyphs for a given point size and resolution) in a bitmap font. */
+  /*    It is used for the `available_sizes' field of @FT_Face.            */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    height :: The vertical distance, in pixels, between two            */
+  /*              consecutive baselines.  It is always positive.           */
+  /*                                                                       */
+  /*    width  :: The average width, in pixels, of all glyphs in the       */
+  /*              strike.                                                  */
+  /*                                                                       */
+  /*    size   :: The nominal size of the strike in 26.6 fractional        */
+  /*              points.  This field is not very useful.                  */
+  /*                                                                       */
+  /*    x_ppem :: The horizontal ppem (nominal width) in 26.6 fractional   */
+  /*              pixels.                                                  */
+  /*                                                                       */
+  /*    y_ppem :: The vertical ppem (nominal height) in 26.6 fractional    */
+  /*              pixels.                                                  */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Windows FNT:                                                       */
+  /*      The nominal size given in a FNT font is not reliable.  If the    */
+  /*      driver finds it incorrect, it sets `size' to some calculated     */
+  /*      values, and `x_ppem' and `y_ppem' to the pixel width and height  */
+  /*      given in the font, respectively.                                 */
+  /*                                                                       */
+  /*    TrueType embedded bitmaps:                                         */
+  /*      `size', `width', and `height' values are not contained in the    */
+  /*      bitmap strike itself.  They are computed from the global font    */
+  /*      parameters.                                                      */
+  /*                                                                       */
+  typedef struct  FT_Bitmap_Size_
+  {
+    FT_Short  height;
+    FT_Short  width;
+
+    FT_Pos    size;
+
+    FT_Pos    x_ppem;
+    FT_Pos    y_ppem;
+
+  } FT_Bitmap_Size;
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*                                                                       */
+  /*                     O B J E C T   C L A S S E S                       */
+  /*                                                                       */
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Library                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a FreeType library instance.  Each `library' is        */
+  /*    completely independent from the others; it is the `root' of a set  */
+  /*    of objects like fonts, faces, sizes, etc.                          */
+  /*                                                                       */
+  /*    It also embeds a memory manager (see @FT_Memory), as well as a     */
+  /*    scan-line converter object (see @FT_Raster).                       */
+  /*                                                                       */
+  /*    In multi-threaded applications it is easiest to use one            */
+  /*    `FT_Library' object per thread.  In case this is too cumbersome,   */
+  /*    a single `FT_Library' object across threads is possible also       */
+  /*    (since FreeType version 2.5.6), as long as a mutex lock is used    */
+  /*    around @FT_New_Face and @FT_Done_Face.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Library objects are normally created by @FT_Init_FreeType, and     */
+  /*    destroyed with @FT_Done_FreeType.  If you need reference-counting  */
+  /*    (cf. @FT_Reference_Library), use @FT_New_Library and               */
+  /*    @FT_Done_Library.                                                  */
+  /*                                                                       */
+  typedef struct FT_LibraryRec_  *FT_Library;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    module_management                                                  */
+  /*                                                                       */
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Module                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a given FreeType module object.  A module can be a     */
+  /*    font driver, a renderer, or anything else that provides services   */
+  /*    to the former.                                                     */
+  /*                                                                       */
+  typedef struct FT_ModuleRec_*  FT_Module;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Driver                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a given FreeType font driver object.  A font driver    */
+  /*    is a module capable of creating faces from font files.             */
+  /*                                                                       */
+  typedef struct FT_DriverRec_*  FT_Driver;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Renderer                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a given FreeType renderer.  A renderer is a module in  */
+  /*    charge of converting a glyph's outline image to a bitmap.  It      */
+  /*    supports a single glyph image format, and one or more target       */
+  /*    surface depths.                                                    */
+  /*                                                                       */
+  typedef struct FT_RendererRec_*  FT_Renderer;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    base_interface                                                     */
+  /*                                                                       */
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Face                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a typographic face object.  A face object models a     */
+  /*    given typeface, in a given style.                                  */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    A face object also owns a single @FT_GlyphSlot object, as well     */
+  /*    as one or more @FT_Size objects.                                   */
+  /*                                                                       */
+  /*    Use @FT_New_Face or @FT_Open_Face to create a new face object from */
+  /*    a given filepath or a custom input stream.                         */
+  /*                                                                       */
+  /*    Use @FT_Done_Face to destroy it (along with its slot and sizes).   */
+  /*                                                                       */
+  /*    An `FT_Face' object can only be safely used from one thread at a   */
+  /*    time.  Similarly, creation and destruction of `FT_Face' with the   */
+  /*    same @FT_Library object can only be done from one thread at a      */
+  /*    time.  On the other hand, functions like @FT_Load_Glyph and its    */
+  /*    siblings are thread-safe and do not need the lock to be held as    */
+  /*    long as the same `FT_Face' object is not used from multiple        */
+  /*    threads at the same time.                                          */
+  /*                                                                       */
+  /* <Also>                                                                */
+  /*    See @FT_FaceRec for the publicly accessible fields of a given face */
+  /*    object.                                                            */
+  /*                                                                       */
+  typedef struct FT_FaceRec_*  FT_Face;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Size                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to an object that models a face scaled to a given         */
+  /*    character size.                                                    */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    An @FT_Face has one _active_ @FT_Size object that is used by       */
+  /*    functions like @FT_Load_Glyph to determine the scaling             */
+  /*    transformation that in turn is used to load and hint glyphs and    */
+  /*    metrics.                                                           */
+  /*                                                                       */
+  /*    You can use @FT_Set_Char_Size, @FT_Set_Pixel_Sizes,                */
+  /*    @FT_Request_Size or even @FT_Select_Size to change the content     */
+  /*    (i.e., the scaling values) of the active @FT_Size.                 */
+  /*                                                                       */
+  /*    You can use @FT_New_Size to create additional size objects for a   */
+  /*    given @FT_Face, but they won't be used by other functions until    */
+  /*    you activate it through @FT_Activate_Size.  Only one size can be   */
+  /*    activated at any given time per face.                              */
+  /*                                                                       */
+  /* <Also>                                                                */
+  /*    See @FT_SizeRec for the publicly accessible fields of a given size */
+  /*    object.                                                            */
+  /*                                                                       */
+  typedef struct FT_SizeRec_*  FT_Size;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_GlyphSlot                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a given `glyph slot'.  A slot is a container that can  */
+  /*    hold any of the glyphs contained in its parent face.               */
+  /*                                                                       */
+  /*    In other words, each time you call @FT_Load_Glyph or               */
+  /*    @FT_Load_Char, the slot's content is erased by the new glyph data, */
+  /*    i.e., the glyph's metrics, its image (bitmap or outline), and      */
+  /*    other control information.                                         */
+  /*                                                                       */
+  /* <Also>                                                                */
+  /*    See @FT_GlyphSlotRec for the publicly accessible glyph fields.     */
+  /*                                                                       */
+  typedef struct FT_GlyphSlotRec_*  FT_GlyphSlot;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_CharMap                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a character map (usually abbreviated to `charmap').  A */
+  /*    charmap is used to translate character codes in a given encoding   */
+  /*    into glyph indexes for its parent's face.  Some font formats may   */
+  /*    provide several charmaps per font.                                 */
+  /*                                                                       */
+  /*    Each face object owns zero or more charmaps, but only one of them  */
+  /*    can be `active', providing the data used by @FT_Get_Char_Index or  */
+  /*    @FT_Load_Char.                                                     */
+  /*                                                                       */
+  /*    The list of available charmaps in a face is available through the  */
+  /*    `face->num_charmaps' and `face->charmaps' fields of @FT_FaceRec.   */
+  /*                                                                       */
+  /*    The currently active charmap is available as `face->charmap'.      */
+  /*    You should call @FT_Set_Charmap to change it.                      */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    When a new face is created (either through @FT_New_Face or         */
+  /*    @FT_Open_Face), the library looks for a Unicode charmap within     */
+  /*    the list and automatically activates it.  If there is no Unicode   */
+  /*    charmap, FreeType doesn't set an `active' charmap.                 */
+  /*                                                                       */
+  /* <Also>                                                                */
+  /*    See @FT_CharMapRec for the publicly accessible fields of a given   */
+  /*    character map.                                                     */
+  /*                                                                       */
+  typedef struct FT_CharMapRec_*  FT_CharMap;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Macro>                                                               */
+  /*    FT_ENC_TAG                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This macro converts four-letter tags into an unsigned long.  It is */
+  /*    used to define `encoding' identifiers (see @FT_Encoding).          */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Since many 16-bit compilers don't like 32-bit enumerations, you    */
+  /*    should redefine this macro in case of problems to something like   */
+  /*    this:                                                              */
+  /*                                                                       */
+  /*    {                                                                  */
+  /*      #define FT_ENC_TAG( value, a, b, c, d )  value                   */
+  /*    }                                                                  */
+  /*                                                                       */
+  /*    to get a simple enumeration without assigning special numbers.     */
+  /*                                                                       */
+
+#ifndef FT_ENC_TAG
+#define FT_ENC_TAG( value, a, b, c, d )         \
+          value = ( ( (FT_UInt32)(a) << 24 ) |  \
+                    ( (FT_UInt32)(b) << 16 ) |  \
+                    ( (FT_UInt32)(c) <<  8 ) |  \
+                      (FT_UInt32)(d)         )
+
+#endif /* FT_ENC_TAG */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    FT_Encoding                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An enumeration to specify character sets supported by charmaps.    */
+  /*    Used in the @FT_Select_Charmap API function.                       */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Despite the name, this enumeration lists specific character        */
+  /*    repertories (i.e., charsets), and not text encoding methods (e.g., */
+  /*    UTF-8, UTF-16, etc.).                                              */
+  /*                                                                       */
+  /*    Other encodings might be defined in the future.                    */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    FT_ENCODING_NONE ::                                                */
+  /*      The encoding value~0 is reserved.                                */
+  /*                                                                       */
+  /*    FT_ENCODING_UNICODE ::                                             */
+  /*      The Unicode character set.  This value covers all versions of    */
+  /*      the Unicode repertoire, including ASCII and Latin-1.  Most fonts */
+  /*      include a Unicode charmap, but not all of them.                  */
+  /*                                                                       */
+  /*      For example, if you want to access Unicode value U+1F028 (and    */
+  /*      the font contains it), use value 0x1F028 as the input value for  */
+  /*      @FT_Get_Char_Index.                                              */
+  /*                                                                       */
+  /*    FT_ENCODING_MS_SYMBOL ::                                           */
+  /*      Microsoft Symbol encoding, used to encode mathematical symbols   */
+  /*      and wingdings.  For more information, see                        */
+  /*      `http://www.microsoft.com/typography/otspec/recom.htm',          */
+  /*      `http://www.kostis.net/charsets/symbol.htm', and                 */
+  /*      `http://www.kostis.net/charsets/wingding.htm'.                   */
+  /*                                                                       */
+  /*      This encoding uses character codes from the PUA (Private Unicode */
+  /*      Area) in the range U+F020-U+F0FF.                                */
+  /*                                                                       */
+  /*    FT_ENCODING_SJIS ::                                                */
+  /*      Shift JIS encoding for Japanese.  More info at                   */
+  /*      `http://en.wikipedia.org/wiki/Shift_JIS'.  See note on           */
+  /*      multi-byte encodings below.                                      */
+  /*                                                                       */
+  /*    FT_ENCODING_PRC ::                                                 */
+  /*      Corresponds to encoding systems mainly for Simplified Chinese as */
+  /*      used in People's Republic of China (PRC).  The encoding layout   */
+  /*      is based on GB~2312 and its supersets GBK and GB~18030.          */
+  /*                                                                       */
+  /*    FT_ENCODING_BIG5 ::                                                */
+  /*      Corresponds to an encoding system for Traditional Chinese as     */
+  /*      used in Taiwan and Hong Kong.                                    */
+  /*                                                                       */
+  /*    FT_ENCODING_WANSUNG ::                                             */
+  /*      Corresponds to the Korean encoding system known as Extended      */
+  /*      Wansung (MS Windows code page 949).                              */
+  /*      For more information see                                         */
+  /*      `http://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WindowsBestFit/bestfit949.txt'. */
+  /*                                                                       */
+  /*    FT_ENCODING_JOHAB ::                                               */
+  /*      The Korean standard character set (KS~C 5601-1992), which        */
+  /*      corresponds to MS Windows code page 1361.  This character set    */
+  /*      includes all possible Hangul character combinations.             */
+  /*                                                                       */
+  /*    FT_ENCODING_ADOBE_LATIN_1 ::                                       */
+  /*      Corresponds to a Latin-1 encoding as defined in a Type~1         */
+  /*      PostScript font.  It is limited to 256 character codes.          */
+  /*                                                                       */
+  /*    FT_ENCODING_ADOBE_STANDARD ::                                      */
+  /*      Adobe Standard encoding, as found in Type~1, CFF, and            */
+  /*      OpenType/CFF fonts.  It is limited to 256 character codes.       */
+  /*                                                                       */
+  /*    FT_ENCODING_ADOBE_EXPERT ::                                        */
+  /*      Adobe Expert encoding, as found in Type~1, CFF, and OpenType/CFF */
+  /*      fonts.  It is limited to 256 character codes.                    */
+  /*                                                                       */
+  /*    FT_ENCODING_ADOBE_CUSTOM ::                                        */
+  /*      Corresponds to a custom encoding, as found in Type~1, CFF, and   */
+  /*      OpenType/CFF fonts.  It is limited to 256 character codes.       */
+  /*                                                                       */
+  /*    FT_ENCODING_APPLE_ROMAN ::                                         */
+  /*      Apple roman encoding.  Many TrueType and OpenType fonts contain  */
+  /*      a charmap for this 8-bit encoding, since older versions of Mac   */
+  /*      OS are able to use it.                                           */
+  /*                                                                       */
+  /*    FT_ENCODING_OLD_LATIN_2 ::                                         */
+  /*      This value is deprecated and was neither used nor reported by    */
+  /*      FreeType.  Don't use or test for it.                             */
+  /*                                                                       */
+  /*    FT_ENCODING_MS_SJIS ::                                             */
+  /*      Same as FT_ENCODING_SJIS.  Deprecated.                           */
+  /*                                                                       */
+  /*    FT_ENCODING_MS_GB2312 ::                                           */
+  /*      Same as FT_ENCODING_PRC.  Deprecated.                            */
+  /*                                                                       */
+  /*    FT_ENCODING_MS_BIG5 ::                                             */
+  /*      Same as FT_ENCODING_BIG5.  Deprecated.                           */
+  /*                                                                       */
+  /*    FT_ENCODING_MS_WANSUNG ::                                          */
+  /*      Same as FT_ENCODING_WANSUNG.  Deprecated.                        */
+  /*                                                                       */
+  /*    FT_ENCODING_MS_JOHAB ::                                            */
+  /*      Same as FT_ENCODING_JOHAB.  Deprecated.                          */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    By default, FreeType automatically synthesizes a Unicode charmap   */
+  /*    for PostScript fonts, using their glyph name dictionaries.         */
+  /*    However, it also reports the encodings defined explicitly in the   */
+  /*    font file, for the cases when they are needed, with the Adobe      */
+  /*    values as well.                                                    */
+  /*                                                                       */
+  /*    FT_ENCODING_NONE is set by the BDF and PCF drivers if the charmap  */
+  /*    is neither Unicode nor ISO-8859-1 (otherwise it is set to          */
+  /*    FT_ENCODING_UNICODE).  Use @FT_Get_BDF_Charset_ID to find out      */
+  /*    which encoding is really present.  If, for example, the            */
+  /*    `cs_registry' field is `KOI8' and the `cs_encoding' field is `R',  */
+  /*    the font is encoded in KOI8-R.                                     */
+  /*                                                                       */
+  /*    FT_ENCODING_NONE is always set (with a single exception) by the    */
+  /*    winfonts driver.  Use @FT_Get_WinFNT_Header and examine the        */
+  /*    `charset' field of the @FT_WinFNT_HeaderRec structure to find out  */
+  /*    which encoding is really present.  For example,                    */
+  /*    @FT_WinFNT_ID_CP1251 (204) means Windows code page 1251 (for       */
+  /*    Russian).                                                          */
+  /*                                                                       */
+  /*    FT_ENCODING_NONE is set if `platform_id' is @TT_PLATFORM_MACINTOSH */
+  /*    and `encoding_id' is not `TT_MAC_ID_ROMAN' (otherwise it is set to */
+  /*    FT_ENCODING_APPLE_ROMAN).                                          */
+  /*                                                                       */
+  /*    If `platform_id' is @TT_PLATFORM_MACINTOSH, use the function       */
+  /*    @FT_Get_CMap_Language_ID to query the Mac language ID that may     */
+  /*    be needed to be able to distinguish Apple encoding variants.  See  */
+  /*                                                                       */
+  /*      http://www.unicode.org/Public/MAPPINGS/VENDORS/APPLE/Readme.txt  */
+  /*                                                                       */
+  /*    to get an idea how to do that.  Basically, if the language ID      */
+  /*    is~0, don't use it, otherwise subtract 1 from the language ID.     */
+  /*    Then examine `encoding_id'.  If, for example, `encoding_id' is     */
+  /*    `TT_MAC_ID_ROMAN' and the language ID (minus~1) is                 */
+  /*    `TT_MAC_LANGID_GREEK', it is the Greek encoding, not Roman.        */
+  /*    `TT_MAC_ID_ARABIC' with `TT_MAC_LANGID_FARSI' means the Farsi      */
+  /*    variant the Arabic encoding.                                       */
+  /*                                                                       */
+  typedef enum  FT_Encoding_
+  {
+    FT_ENC_TAG( FT_ENCODING_NONE, 0, 0, 0, 0 ),
+
+    FT_ENC_TAG( FT_ENCODING_MS_SYMBOL, 's', 'y', 'm', 'b' ),
+    FT_ENC_TAG( FT_ENCODING_UNICODE,   'u', 'n', 'i', 'c' ),
+
+    FT_ENC_TAG( FT_ENCODING_SJIS,    's', 'j', 'i', 's' ),
+    FT_ENC_TAG( FT_ENCODING_PRC,     'g', 'b', ' ', ' ' ),
+    FT_ENC_TAG( FT_ENCODING_BIG5,    'b', 'i', 'g', '5' ),
+    FT_ENC_TAG( FT_ENCODING_WANSUNG, 'w', 'a', 'n', 's' ),
+    FT_ENC_TAG( FT_ENCODING_JOHAB,   'j', 'o', 'h', 'a' ),
+
+    /* for backward compatibility */
+    FT_ENCODING_GB2312     = FT_ENCODING_PRC,
+    FT_ENCODING_MS_SJIS    = FT_ENCODING_SJIS,
+    FT_ENCODING_MS_GB2312  = FT_ENCODING_PRC,
+    FT_ENCODING_MS_BIG5    = FT_ENCODING_BIG5,
+    FT_ENCODING_MS_WANSUNG = FT_ENCODING_WANSUNG,
+    FT_ENCODING_MS_JOHAB   = FT_ENCODING_JOHAB,
+
+    FT_ENC_TAG( FT_ENCODING_ADOBE_STANDARD, 'A', 'D', 'O', 'B' ),
+    FT_ENC_TAG( FT_ENCODING_ADOBE_EXPERT,   'A', 'D', 'B', 'E' ),
+    FT_ENC_TAG( FT_ENCODING_ADOBE_CUSTOM,   'A', 'D', 'B', 'C' ),
+    FT_ENC_TAG( FT_ENCODING_ADOBE_LATIN_1,  'l', 'a', 't', '1' ),
+
+    FT_ENC_TAG( FT_ENCODING_OLD_LATIN_2, 'l', 'a', 't', '2' ),
+
+    FT_ENC_TAG( FT_ENCODING_APPLE_ROMAN, 'a', 'r', 'm', 'n' )
+
+  } FT_Encoding;
+
+
+  /* these constants are deprecated; use the corresponding `FT_Encoding' */
+  /* values instead                                                      */
+#define ft_encoding_none            FT_ENCODING_NONE
+#define ft_encoding_unicode         FT_ENCODING_UNICODE
+#define ft_encoding_symbol          FT_ENCODING_MS_SYMBOL
+#define ft_encoding_latin_1         FT_ENCODING_ADOBE_LATIN_1
+#define ft_encoding_latin_2         FT_ENCODING_OLD_LATIN_2
+#define ft_encoding_sjis            FT_ENCODING_SJIS
+#define ft_encoding_gb2312          FT_ENCODING_PRC
+#define ft_encoding_big5            FT_ENCODING_BIG5
+#define ft_encoding_wansung         FT_ENCODING_WANSUNG
+#define ft_encoding_johab           FT_ENCODING_JOHAB
+
+#define ft_encoding_adobe_standard  FT_ENCODING_ADOBE_STANDARD
+#define ft_encoding_adobe_expert    FT_ENCODING_ADOBE_EXPERT
+#define ft_encoding_adobe_custom    FT_ENCODING_ADOBE_CUSTOM
+#define ft_encoding_apple_roman     FT_ENCODING_APPLE_ROMAN
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_CharMapRec                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The base charmap structure.                                        */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    face        :: A handle to the parent face object.                 */
+  /*                                                                       */
+  /*    encoding    :: An @FT_Encoding tag identifying the charmap.  Use   */
+  /*                   this with @FT_Select_Charmap.                       */
+  /*                                                                       */
+  /*    platform_id :: An ID number describing the platform for the        */
+  /*                   following encoding ID.  This comes directly from    */
+  /*                   the TrueType specification and gets emulated for    */
+  /*                   other formats.                                      */
+  /*                                                                       */
+  /*    encoding_id :: A platform specific encoding number.  This also     */
+  /*                   comes from the TrueType specification and gets      */
+  /*                   emulated similarly.                                 */
+  /*                                                                       */
+  typedef struct  FT_CharMapRec_
+  {
+    FT_Face      face;
+    FT_Encoding  encoding;
+    FT_UShort    platform_id;
+    FT_UShort    encoding_id;
+
+  } FT_CharMapRec;
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*                                                                       */
+  /*                 B A S E   O B J E C T   C L A S S E S                 */
+  /*                                                                       */
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Face_Internal                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An opaque handle to an `FT_Face_InternalRec' structure that models */
+  /*    the private data of a given @FT_Face object.                       */
+  /*                                                                       */
+  /*    This structure might change between releases of FreeType~2 and is  */
+  /*    not generally available to client applications.                    */
+  /*                                                                       */
+  typedef struct FT_Face_InternalRec_*  FT_Face_Internal;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_FaceRec                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    FreeType root face class structure.  A face object models a        */
+  /*    typeface in a font file.                                           */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    num_faces           :: The number of faces in the font file.  Some */
+  /*                           font formats can have multiple faces in     */
+  /*                           a single font file.                         */
+  /*                                                                       */
+  /*    face_index          :: This field holds two different values.      */
+  /*                           Bits 0-15 are the index of the face in the  */
+  /*                           font file (starting with value~0).  They    */
+  /*                           are set to~0 if there is only one face in   */
+  /*                           the font file.                              */
+  /*                                                                       */
+  /*                           Bits 16-30 are relevant to GX and OpenType  */
+  /*                           variation fonts only, holding the named     */
+  /*                           instance index for the current face index   */
+  /*                           (starting with value~1; value~0 indicates   */
+  /*                           font access without a named instance).  For */
+  /*                           non-variation fonts, bits 16-30 are         */
+  /*                           ignored.  If we have the third named        */
+  /*                           instance of face~4, say, `face_index' is    */
+  /*                           set to 0x00030004.                          */
+  /*                                                                       */
+  /*                           Bit 31 is always zero (this is,             */
+  /*                           `face_index' is always a positive value).   */
+  /*                                                                       */
+  /*    face_flags          :: A set of bit flags that give important      */
+  /*                           information about the face; see             */
+  /*                           @FT_FACE_FLAG_XXX for the details.          */
+  /*                                                                       */
+  /*    style_flags         :: The lower 16~bits contain a set of bit      */
+  /*                           flags indicating the style of the face; see */
+  /*                           @FT_STYLE_FLAG_XXX for the details.  Bits   */
+  /*                           16-30 hold the number of named instances    */
+  /*                           available for the current face if we have a */
+  /*                           GX or OpenType variation (sub)font.  Bit 31 */
+  /*                           is always zero (this is, `style_flags' is   */
+  /*                           always a positive value).  Note that a      */
+  /*                           variation font has always at least one      */
+  /*                           named instance, namely the default          */
+  /*                           instance.                                   */
+  /*                                                                       */
+  /*    num_glyphs          :: The number of glyphs in the face.  If the   */
+  /*                           face is scalable and has sbits (see         */
+  /*                           `num_fixed_sizes'), it is set to the number */
+  /*                           of outline glyphs.                          */
+  /*                                                                       */
+  /*                           For CID-keyed fonts (not in an SFNT         */
+  /*                           wrapper) this value gives the highest CID   */
+  /*                           used in the font.                           */
+  /*                                                                       */
+  /*    family_name         :: The face's family name.  This is an ASCII   */
+  /*                           string, usually in English, that describes  */
+  /*                           the typeface's family (like `Times New      */
+  /*                           Roman', `Bodoni', `Garamond', etc).  This   */
+  /*                           is a least common denominator used to list  */
+  /*                           fonts.  Some formats (TrueType & OpenType)  */
+  /*                           provide localized and Unicode versions of   */
+  /*                           this string.  Applications should use the   */
+  /*                           format specific interface to access them.   */
+  /*                           Can be NULL (e.g., in fonts embedded in a   */
+  /*                           PDF file).                                  */
+  /*                                                                       */
+  /*                           In case the font doesn't provide a specific */
+  /*                           family name entry, FreeType tries to        */
+  /*                           synthesize one, deriving it from other name */
+  /*                           entries.                                    */
+  /*                                                                       */
+  /*    style_name          :: The face's style name.  This is an ASCII    */
+  /*                           string, usually in English, that describes  */
+  /*                           the typeface's style (like `Italic',        */
+  /*                           `Bold', `Condensed', etc).  Not all font    */
+  /*                           formats provide a style name, so this field */
+  /*                           is optional, and can be set to NULL.  As    */
+  /*                           for `family_name', some formats provide     */
+  /*                           localized and Unicode versions of this      */
+  /*                           string.  Applications should use the format */
+  /*                           specific interface to access them.          */
+  /*                                                                       */
+  /*    num_fixed_sizes     :: The number of bitmap strikes in the face.   */
+  /*                           Even if the face is scalable, there might   */
+  /*                           still be bitmap strikes, which are called   */
+  /*                           `sbits' in that case.                       */
+  /*                                                                       */
+  /*    available_sizes     :: An array of @FT_Bitmap_Size for all bitmap  */
+  /*                           strikes in the face.  It is set to NULL if  */
+  /*                           there is no bitmap strike.                  */
+  /*                                                                       */
+  /*                           Note that FreeType tries to sanitize the    */
+  /*                           strike data since they are sometimes sloppy */
+  /*                           or incorrect, but this can easily fail.     */
+  /*                                                                       */
+  /*    num_charmaps        :: The number of charmaps in the face.         */
+  /*                                                                       */
+  /*    charmaps            :: An array of the charmaps of the face.       */
+  /*                                                                       */
+  /*    generic             :: A field reserved for client uses.  See the  */
+  /*                           @FT_Generic type description.               */
+  /*                                                                       */
+  /*    bbox                :: The font bounding box.  Coordinates are     */
+  /*                           expressed in font units (see                */
+  /*                           `units_per_EM').  The box is large enough   */
+  /*                           to contain any glyph from the font.  Thus,  */
+  /*                           `bbox.yMax' can be seen as the `maximum     */
+  /*                           ascender', and `bbox.yMin' as the `minimum  */
+  /*                           descender'.  Only relevant for scalable     */
+  /*                           formats.                                    */
+  /*                                                                       */
+  /*                           Note that the bounding box might be off by  */
+  /*                           (at least) one pixel for hinted fonts.  See */
+  /*                           @FT_Size_Metrics for further discussion.    */
+  /*                                                                       */
+  /*    units_per_EM        :: The number of font units per EM square for  */
+  /*                           this face.  This is typically 2048 for      */
+  /*                           TrueType fonts, and 1000 for Type~1 fonts.  */
+  /*                           Only relevant for scalable formats.         */
+  /*                                                                       */
+  /*    ascender            :: The typographic ascender of the face,       */
+  /*                           expressed in font units.  For font formats  */
+  /*                           not having this information, it is set to   */
+  /*                           `bbox.yMax'.  Only relevant for scalable    */
+  /*                           formats.                                    */
+  /*                                                                       */
+  /*    descender           :: The typographic descender of the face,      */
+  /*                           expressed in font units.  For font formats  */
+  /*                           not having this information, it is set to   */
+  /*                           `bbox.yMin'.  Note that this field is       */
+  /*                           negative for values below the baseline.     */
+  /*                           Only relevant for scalable formats.         */
+  /*                                                                       */
+  /*    height              :: This value is the vertical distance         */
+  /*                           between two consecutive baselines,          */
+  /*                           expressed in font units.  It is always      */
+  /*                           positive.  Only relevant for scalable       */
+  /*                           formats.                                    */
+  /*                                                                       */
+  /*                           If you want the global glyph height, use    */
+  /*                           `ascender - descender'.                     */
+  /*                                                                       */
+  /*    max_advance_width   :: The maximum advance width, in font units,   */
+  /*                           for all glyphs in this face.  This can be   */
+  /*                           used to make word wrapping computations     */
+  /*                           faster.  Only relevant for scalable         */
+  /*                           formats.                                    */
+  /*                                                                       */
+  /*    max_advance_height  :: The maximum advance height, in font units,  */
+  /*                           for all glyphs in this face.  This is only  */
+  /*                           relevant for vertical layouts, and is set   */
+  /*                           to `height' for fonts that do not provide   */
+  /*                           vertical metrics.  Only relevant for        */
+  /*                           scalable formats.                           */
+  /*                                                                       */
+  /*    underline_position  :: The position, in font units, of the         */
+  /*                           underline line for this face.  It is the    */
+  /*                           center of the underlining stem.  Only       */
+  /*                           relevant for scalable formats.              */
+  /*                                                                       */
+  /*    underline_thickness :: The thickness, in font units, of the        */
+  /*                           underline for this face.  Only relevant for */
+  /*                           scalable formats.                           */
+  /*                                                                       */
+  /*    glyph               :: The face's associated glyph slot(s).        */
+  /*                                                                       */
+  /*    size                :: The current active size for this face.      */
+  /*                                                                       */
+  /*    charmap             :: The current active charmap for this face.   */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Fields may be changed after a call to @FT_Attach_File or           */
+  /*    @FT_Attach_Stream.                                                 */
+  /*                                                                       */
+  /*    For an OpenType variation font, the values of the following fields */
+  /*    can change after a call to @FT_Set_Var_Design_Coordinates (and     */
+  /*    friends) if the font contains an `MVAR' table: `ascender',         */
+  /*    `descender', `height', `underline_position', and                   */
+  /*    `underline_thickness'.                                             */
+  /*                                                                       */
+  typedef struct  FT_FaceRec_
+  {
+    FT_Long           num_faces;
+    FT_Long           face_index;
+
+    FT_Long           face_flags;
+    FT_Long           style_flags;
+
+    FT_Long           num_glyphs;
+
+    FT_String*        family_name;
+    FT_String*        style_name;
+
+    FT_Int            num_fixed_sizes;
+    FT_Bitmap_Size*   available_sizes;
+
+    FT_Int            num_charmaps;
+    FT_CharMap*       charmaps;
+
+    FT_Generic        generic;
+
+    /*# The following member variables (down to `underline_thickness') */
+    /*# are only relevant to scalable outlines; cf. @FT_Bitmap_Size    */
+    /*# for bitmap fonts.                                              */
+    FT_BBox           bbox;
+
+    FT_UShort         units_per_EM;
+    FT_Short          ascender;
+    FT_Short          descender;
+    FT_Short          height;
+
+    FT_Short          max_advance_width;
+    FT_Short          max_advance_height;
+
+    FT_Short          underline_position;
+    FT_Short          underline_thickness;
+
+    FT_GlyphSlot      glyph;
+    FT_Size           size;
+    FT_CharMap        charmap;
+
+    /*@private begin */
+
+    FT_Driver         driver;
+    FT_Memory         memory;
+    FT_Stream         stream;
+
+    FT_ListRec        sizes_list;
+
+    FT_Generic        autohint;   /* face-specific auto-hinter data */
+    void*             extensions; /* unused                         */
+
+    FT_Face_Internal  internal;
+
+    /*@private end */
+
+  } FT_FaceRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    FT_FACE_FLAG_XXX                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A list of bit flags used in the `face_flags' field of the          */
+  /*    @FT_FaceRec structure.  They inform client applications of         */
+  /*    properties of the corresponding face.                              */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    FT_FACE_FLAG_SCALABLE ::                                           */
+  /*      The face contains outline glyphs.  Note that a face can contain  */
+  /*      bitmap strikes also, i.e., a face can have both this flag and    */
+  /*      @FT_FACE_FLAG_FIXED_SIZES set.                                   */
+  /*                                                                       */
+  /*    FT_FACE_FLAG_FIXED_SIZES ::                                        */
+  /*      The face contains bitmap strikes.  See also the                  */
+  /*      `num_fixed_sizes' and `available_sizes' fields of @FT_FaceRec.   */
+  /*                                                                       */
+  /*    FT_FACE_FLAG_FIXED_WIDTH ::                                        */
+  /*      The face contains fixed-width characters (like Courier, Lucida,  */
+  /*      MonoType, etc.).                                                 */
+  /*                                                                       */
+  /*    FT_FACE_FLAG_SFNT ::                                               */
+  /*      The face uses the SFNT storage scheme.  For now, this means      */
+  /*      TrueType and OpenType.                                           */
+  /*                                                                       */
+  /*    FT_FACE_FLAG_HORIZONTAL ::                                         */
+  /*      The face contains horizontal glyph metrics.  This should be set  */
+  /*      for all common formats.                                          */
+  /*                                                                       */
+  /*    FT_FACE_FLAG_VERTICAL ::                                           */
+  /*      The face contains vertical glyph metrics.  This is only          */
+  /*      available in some formats, not all of them.                      */
+  /*                                                                       */
+  /*    FT_FACE_FLAG_KERNING ::                                            */
+  /*      The face contains kerning information.  If set, the kerning      */
+  /*      distance can be retrieved using the function @FT_Get_Kerning.    */
+  /*      Otherwise the function always return the vector (0,0).  Note     */
+  /*      that FreeType doesn't handle kerning data from the SFNT `GPOS'   */
+  /*      table (as present in many OpenType fonts).                       */
+  /*                                                                       */
+  /*    FT_FACE_FLAG_FAST_GLYPHS ::                                        */
+  /*      THIS FLAG IS DEPRECATED.  DO NOT USE OR TEST IT.                 */
+  /*                                                                       */
+  /*    FT_FACE_FLAG_MULTIPLE_MASTERS ::                                   */
+  /*      The face contains multiple masters and is capable of             */
+  /*      interpolating between them.  Supported formats are Adobe MM,     */
+  /*      TrueType GX, and OpenType variation fonts.                       */
+  /*                                                                       */
+  /*      See the multiple-masters specific API for details.               */
+  /*                                                                       */
+  /*    FT_FACE_FLAG_GLYPH_NAMES ::                                        */
+  /*      The face contains glyph names, which can be retrieved using      */
+  /*      @FT_Get_Glyph_Name.  Note that some TrueType fonts contain       */
+  /*      broken glyph name tables.  Use the function                      */
+  /*      @FT_Has_PS_Glyph_Names when needed.                              */
+  /*                                                                       */
+  /*    FT_FACE_FLAG_EXTERNAL_STREAM ::                                    */
+  /*      Used internally by FreeType to indicate that a face's stream was */
+  /*      provided by the client application and should not be destroyed   */
+  /*      when @FT_Done_Face is called.  Don't read or test this flag.     */
+  /*                                                                       */
+  /*    FT_FACE_FLAG_HINTER ::                                             */
+  /*      The font driver has a hinting machine of its own.  For example,  */
+  /*      with TrueType fonts, it makes sense to use data from the SFNT    */
+  /*      `gasp' table only if the native TrueType hinting engine (with    */
+  /*      the bytecode interpreter) is available and active.               */
+  /*                                                                       */
+  /*    FT_FACE_FLAG_CID_KEYED ::                                          */
+  /*      The face is CID-keyed.  In that case, the face is not accessed   */
+  /*      by glyph indices but by CID values.  For subsetted CID-keyed     */
+  /*      fonts this has the consequence that not all index values are a   */
+  /*      valid argument to @FT_Load_Glyph.  Only the CID values for which */
+  /*      corresponding glyphs in the subsetted font exist make            */
+  /*      `FT_Load_Glyph' return successfully; in all other cases you get  */
+  /*      an `FT_Err_Invalid_Argument' error.                              */
+  /*                                                                       */
+  /*      Note that CID-keyed fonts that are in an SFNT wrapper (this is,  */
+  /*      all OpenType/CFF fonts) don't have this flag set since the       */
+  /*      glyphs are accessed in the normal way (using contiguous          */
+  /*      indices); the `CID-ness' isn't visible to the application.       */
+  /*                                                                       */
+  /*    FT_FACE_FLAG_TRICKY ::                                             */
+  /*      The face is `tricky', this is, it always needs the font format's */
+  /*      native hinting engine to get a reasonable result.  A typical     */
+  /*      example is the old Chinese font `mingli.ttf' (but not            */
+  /*      `mingliu.ttc') that uses TrueType bytecode instructions to move  */
+  /*      and scale all of its subglyphs.                                  */
+  /*                                                                       */
+  /*      It is not possible to auto-hint such fonts using                 */
+  /*      @FT_LOAD_FORCE_AUTOHINT; it will also ignore                     */
+  /*      @FT_LOAD_NO_HINTING.  You have to set both @FT_LOAD_NO_HINTING   */
+  /*      and @FT_LOAD_NO_AUTOHINT to really disable hinting; however, you */
+  /*      probably never want this except for demonstration purposes.      */
+  /*                                                                       */
+  /*      Currently, there are about a dozen TrueType fonts in the list of */
+  /*      tricky fonts; they are hard-coded in file `ttobjs.c'.            */
+  /*                                                                       */
+  /*    FT_FACE_FLAG_COLOR ::                                              */
+  /*      The face has color glyph tables.  To access color glyphs use     */
+  /*      @FT_LOAD_COLOR.                                                  */
+  /*                                                                       */
+#define FT_FACE_FLAG_SCALABLE          ( 1L <<  0 )
+#define FT_FACE_FLAG_FIXED_SIZES       ( 1L <<  1 )
+#define FT_FACE_FLAG_FIXED_WIDTH       ( 1L <<  2 )
+#define FT_FACE_FLAG_SFNT              ( 1L <<  3 )
+#define FT_FACE_FLAG_HORIZONTAL        ( 1L <<  4 )
+#define FT_FACE_FLAG_VERTICAL          ( 1L <<  5 )
+#define FT_FACE_FLAG_KERNING           ( 1L <<  6 )
+#define FT_FACE_FLAG_FAST_GLYPHS       ( 1L <<  7 )
+#define FT_FACE_FLAG_MULTIPLE_MASTERS  ( 1L <<  8 )
+#define FT_FACE_FLAG_GLYPH_NAMES       ( 1L <<  9 )
+#define FT_FACE_FLAG_EXTERNAL_STREAM   ( 1L << 10 )
+#define FT_FACE_FLAG_HINTER            ( 1L << 11 )
+#define FT_FACE_FLAG_CID_KEYED         ( 1L << 12 )
+#define FT_FACE_FLAG_TRICKY            ( 1L << 13 )
+#define FT_FACE_FLAG_COLOR             ( 1L << 14 )
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_HAS_HORIZONTAL( face )
+   *
+   * @description:
+   *   A macro that returns true whenever a face object contains
+   *   horizontal metrics (this is true for all font formats though).
+   *
+   * @also:
+   *   @FT_HAS_VERTICAL can be used to check for vertical metrics.
+   *
+   */
+#define FT_HAS_HORIZONTAL( face ) \
+          ( (face)->face_flags & FT_FACE_FLAG_HORIZONTAL )
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_HAS_VERTICAL( face )
+   *
+   * @description:
+   *   A macro that returns true whenever a face object contains real
+   *   vertical metrics (and not only synthesized ones).
+   *
+   */
+#define FT_HAS_VERTICAL( face ) \
+          ( (face)->face_flags & FT_FACE_FLAG_VERTICAL )
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_HAS_KERNING( face )
+   *
+   * @description:
+   *   A macro that returns true whenever a face object contains kerning
+   *   data that can be accessed with @FT_Get_Kerning.
+   *
+   */
+#define FT_HAS_KERNING( face ) \
+          ( (face)->face_flags & FT_FACE_FLAG_KERNING )
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_IS_SCALABLE( face )
+   *
+   * @description:
+   *   A macro that returns true whenever a face object contains a scalable
+   *   font face (true for TrueType, Type~1, Type~42, CID, OpenType/CFF,
+   *   and PFR font formats).
+   *
+   */
+#define FT_IS_SCALABLE( face ) \
+          ( (face)->face_flags & FT_FACE_FLAG_SCALABLE )
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_IS_SFNT( face )
+   *
+   * @description:
+   *   A macro that returns true whenever a face object contains a font
+   *   whose format is based on the SFNT storage scheme.  This usually
+   *   means: TrueType fonts, OpenType fonts, as well as SFNT-based embedded
+   *   bitmap fonts.
+   *
+   *   If this macro is true, all functions defined in @FT_SFNT_NAMES_H and
+   *   @FT_TRUETYPE_TABLES_H are available.
+   *
+   */
+#define FT_IS_SFNT( face ) \
+          ( (face)->face_flags & FT_FACE_FLAG_SFNT )
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_IS_FIXED_WIDTH( face )
+   *
+   * @description:
+   *   A macro that returns true whenever a face object contains a font face
+   *   that contains fixed-width (or `monospace', `fixed-pitch', etc.)
+   *   glyphs.
+   *
+   */
+#define FT_IS_FIXED_WIDTH( face ) \
+          ( (face)->face_flags & FT_FACE_FLAG_FIXED_WIDTH )
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_HAS_FIXED_SIZES( face )
+   *
+   * @description:
+   *   A macro that returns true whenever a face object contains some
+   *   embedded bitmaps.  See the `available_sizes' field of the
+   *   @FT_FaceRec structure.
+   *
+   */
+#define FT_HAS_FIXED_SIZES( face ) \
+          ( (face)->face_flags & FT_FACE_FLAG_FIXED_SIZES )
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_HAS_FAST_GLYPHS( face )
+   *
+   * @description:
+   *   Deprecated.
+   *
+   */
+#define FT_HAS_FAST_GLYPHS( face )  0
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_HAS_GLYPH_NAMES( face )
+   *
+   * @description:
+   *   A macro that returns true whenever a face object contains some glyph
+   *   names that can be accessed through @FT_Get_Glyph_Name.
+   *
+   */
+#define FT_HAS_GLYPH_NAMES( face ) \
+          ( (face)->face_flags & FT_FACE_FLAG_GLYPH_NAMES )
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_HAS_MULTIPLE_MASTERS( face )
+   *
+   * @description:
+   *   A macro that returns true whenever a face object contains some
+   *   multiple masters.  The functions provided by @FT_MULTIPLE_MASTERS_H
+   *   are then available to choose the exact design you want.
+   *
+   */
+#define FT_HAS_MULTIPLE_MASTERS( face ) \
+          ( (face)->face_flags & FT_FACE_FLAG_MULTIPLE_MASTERS )
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_IS_NAMED_INSTANCE( face )
+   *
+   * @description:
+   *   A macro that returns true whenever a face object is a named instance
+   *   of a GX or OpenType variation font.
+   *
+   */
+#define FT_IS_NAMED_INSTANCE( face ) \
+          ( (face)->face_index & 0x7FFF0000L )
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_IS_CID_KEYED( face )
+   *
+   * @description:
+   *   A macro that returns true whenever a face object contains a CID-keyed
+   *   font.  See the discussion of @FT_FACE_FLAG_CID_KEYED for more
+   *   details.
+   *
+   *   If this macro is true, all functions defined in @FT_CID_H are
+   *   available.
+   *
+   */
+#define FT_IS_CID_KEYED( face ) \
+          ( (face)->face_flags & FT_FACE_FLAG_CID_KEYED )
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_IS_TRICKY( face )
+   *
+   * @description:
+   *   A macro that returns true whenever a face represents a `tricky' font.
+   *   See the discussion of @FT_FACE_FLAG_TRICKY for more details.
+   *
+   */
+#define FT_IS_TRICKY( face ) \
+          ( (face)->face_flags & FT_FACE_FLAG_TRICKY )
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_HAS_COLOR( face )
+   *
+   * @description:
+   *   A macro that returns true whenever a face object contains
+   *   tables for color glyphs.
+   *
+   */
+#define FT_HAS_COLOR( face ) \
+          ( (face)->face_flags & FT_FACE_FLAG_COLOR )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Const>                                                               */
+  /*    FT_STYLE_FLAG_XXX                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A list of bit flags to indicate the style of a given face.  These  */
+  /*    are used in the `style_flags' field of @FT_FaceRec.                */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    FT_STYLE_FLAG_ITALIC ::                                            */
+  /*      The face style is italic or oblique.                             */
+  /*                                                                       */
+  /*    FT_STYLE_FLAG_BOLD ::                                              */
+  /*      The face is bold.                                                */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The style information as provided by FreeType is very basic.  More */
+  /*    details are beyond the scope and should be done on a higher level  */
+  /*    (for example, by analyzing various fields of the `OS/2' table in   */
+  /*    SFNT based fonts).                                                 */
+  /*                                                                       */
+#define FT_STYLE_FLAG_ITALIC  ( 1 << 0 )
+#define FT_STYLE_FLAG_BOLD    ( 1 << 1 )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Size_Internal                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An opaque handle to an `FT_Size_InternalRec' structure, used to    */
+  /*    model private data of a given @FT_Size object.                     */
+  /*                                                                       */
+  typedef struct FT_Size_InternalRec_*  FT_Size_Internal;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Size_Metrics                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The size metrics structure gives the metrics of a size object.     */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    x_ppem       :: The width of the scaled EM square in pixels, hence */
+  /*                    the term `ppem' (pixels per EM).  It is also       */
+  /*                    referred to as `nominal width'.                    */
+  /*                                                                       */
+  /*    y_ppem       :: The height of the scaled EM square in pixels,      */
+  /*                    hence the term `ppem' (pixels per EM).  It is also */
+  /*                    referred to as `nominal height'.                   */
+  /*                                                                       */
+  /*    x_scale      :: A 16.16 fractional scaling value to convert        */
+  /*                    horizontal metrics from font units to 26.6         */
+  /*                    fractional pixels.  Only relevant for scalable     */
+  /*                    font formats.                                      */
+  /*                                                                       */
+  /*    y_scale      :: A 16.16 fractional scaling value to convert        */
+  /*                    vertical metrics from font units to 26.6           */
+  /*                    fractional pixels.  Only relevant for scalable     */
+  /*                    font formats.                                      */
+  /*                                                                       */
+  /*    ascender     :: The ascender in 26.6 fractional pixels, rounded up */
+  /*                    to an integer value.  See @FT_FaceRec for the      */
+  /*                    details.                                           */
+  /*                                                                       */
+  /*    descender    :: The descender in 26.6 fractional pixels, rounded   */
+  /*                    down to an integer value.  See @FT_FaceRec for the */
+  /*                    details.                                           */
+  /*                                                                       */
+  /*    height       :: The height in 26.6 fractional pixels, rounded to   */
+  /*                    an integer value.  See @FT_FaceRec for the         */
+  /*                    details.                                           */
+  /*                                                                       */
+  /*    max_advance  :: The maximum advance width in 26.6 fractional       */
+  /*                    pixels, rounded to an integer value.  See          */
+  /*                    @FT_FaceRec for the details.                       */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The scaling values, if relevant, are determined first during a     */
+  /*    size changing operation.  The remaining fields are then set by the */
+  /*    driver.  For scalable formats, they are usually set to scaled      */
+  /*    values of the corresponding fields in @FT_FaceRec.  Some values    */
+  /*    like ascender or descender are rounded for historical reasons;     */
+  /*    more precise values (for outline fonts) can be derived by scaling  */
+  /*    the corresponding @FT_FaceRec values manually, with code similar   */
+  /*    to the following.                                                  */
+  /*                                                                       */
+  /*    {                                                                  */
+  /*      scaled_ascender = FT_MulFix( face->root.ascender,                */
+  /*                                   size_metrics->y_scale );            */
+  /*    }                                                                  */
+  /*                                                                       */
+  /*    Note that due to glyph hinting and the selected rendering mode     */
+  /*    these values are usually not exact; consequently, they must be     */
+  /*    treated as unreliable with an error margin of at least one pixel!  */
+  /*                                                                       */
+  /*    Indeed, the only way to get the exact metrics is to render _all_   */
+  /*    glyphs.  As this would be a definite performance hit, it is up to  */
+  /*    client applications to perform such computations.                  */
+  /*                                                                       */
+  /*    The `FT_Size_Metrics' structure is valid for bitmap fonts also.    */
+  /*                                                                       */
+  typedef struct  FT_Size_Metrics_
+  {
+    FT_UShort  x_ppem;      /* horizontal pixels per EM               */
+    FT_UShort  y_ppem;      /* vertical pixels per EM                 */
+
+    FT_Fixed   x_scale;     /* scaling values used to convert font    */
+    FT_Fixed   y_scale;     /* units to 26.6 fractional pixels        */
+
+    FT_Pos     ascender;    /* ascender in 26.6 frac. pixels          */
+    FT_Pos     descender;   /* descender in 26.6 frac. pixels         */
+    FT_Pos     height;      /* text height in 26.6 frac. pixels       */
+    FT_Pos     max_advance; /* max horizontal advance, in 26.6 pixels */
+
+  } FT_Size_Metrics;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_SizeRec                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    FreeType root size class structure.  A size object models a face   */
+  /*    object at a given size.                                            */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    face    :: Handle to the parent face object.                       */
+  /*                                                                       */
+  /*    generic :: A typeless pointer, unused by the FreeType library or   */
+  /*               any of its drivers.  It can be used by client           */
+  /*               applications to link their own data to each size        */
+  /*               object.                                                 */
+  /*                                                                       */
+  /*    metrics :: Metrics for this size object.  This field is read-only. */
+  /*                                                                       */
+  typedef struct  FT_SizeRec_
+  {
+    FT_Face           face;      /* parent face object              */
+    FT_Generic        generic;   /* generic pointer for client uses */
+    FT_Size_Metrics   metrics;   /* size metrics                    */
+    FT_Size_Internal  internal;
+
+  } FT_SizeRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_SubGlyph                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The subglyph structure is an internal object used to describe      */
+  /*    subglyphs (for example, in the case of composites).                */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The subglyph implementation is not part of the high-level API,     */
+  /*    hence the forward structure declaration.                           */
+  /*                                                                       */
+  /*    You can however retrieve subglyph information with                 */
+  /*    @FT_Get_SubGlyph_Info.                                             */
+  /*                                                                       */
+  typedef struct FT_SubGlyphRec_*  FT_SubGlyph;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Slot_Internal                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An opaque handle to an `FT_Slot_InternalRec' structure, used to    */
+  /*    model private data of a given @FT_GlyphSlot object.                */
+  /*                                                                       */
+  typedef struct FT_Slot_InternalRec_*  FT_Slot_Internal;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_GlyphSlotRec                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    FreeType root glyph slot class structure.  A glyph slot is a       */
+  /*    container where individual glyphs can be loaded, be they in        */
+  /*    outline or bitmap format.                                          */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    library           :: A handle to the FreeType library instance     */
+  /*                         this slot belongs to.                         */
+  /*                                                                       */
+  /*    face              :: A handle to the parent face object.           */
+  /*                                                                       */
+  /*    next              :: In some cases (like some font tools), several */
+  /*                         glyph slots per face object can be a good     */
+  /*                         thing.  As this is rare, the glyph slots are  */
+  /*                         listed through a direct, single-linked list   */
+  /*                         using its `next' field.                       */
+  /*                                                                       */
+  /*    generic           :: A typeless pointer unused by the FreeType     */
+  /*                         library or any of its drivers.  It can be     */
+  /*                         used by client applications to link their own */
+  /*                         data to each glyph slot object.               */
+  /*                                                                       */
+  /*    metrics           :: The metrics of the last loaded glyph in the   */
+  /*                         slot.  The returned values depend on the last */
+  /*                         load flags (see the @FT_Load_Glyph API        */
+  /*                         function) and can be expressed either in 26.6 */
+  /*                         fractional pixels or font units.              */
+  /*                                                                       */
+  /*                         Note that even when the glyph image is        */
+  /*                         transformed, the metrics are not.             */
+  /*                                                                       */
+  /*    linearHoriAdvance :: The advance width of the unhinted glyph.      */
+  /*                         Its value is expressed in 16.16 fractional    */
+  /*                         pixels, unless @FT_LOAD_LINEAR_DESIGN is set  */
+  /*                         when loading the glyph.  This field can be    */
+  /*                         important to perform correct WYSIWYG layout.  */
+  /*                         Only relevant for outline glyphs.             */
+  /*                                                                       */
+  /*    linearVertAdvance :: The advance height of the unhinted glyph.     */
+  /*                         Its value is expressed in 16.16 fractional    */
+  /*                         pixels, unless @FT_LOAD_LINEAR_DESIGN is set  */
+  /*                         when loading the glyph.  This field can be    */
+  /*                         important to perform correct WYSIWYG layout.  */
+  /*                         Only relevant for outline glyphs.             */
+  /*                                                                       */
+  /*    advance           :: This shorthand is, depending on               */
+  /*                         @FT_LOAD_IGNORE_TRANSFORM, the transformed    */
+  /*                         (hinted) advance width for the glyph, in 26.6 */
+  /*                         fractional pixel format.  As specified with   */
+  /*                         @FT_LOAD_VERTICAL_LAYOUT, it uses either the  */
+  /*                         `horiAdvance' or the `vertAdvance' value of   */
+  /*                         `metrics' field.                              */
+  /*                                                                       */
+  /*    format            :: This field indicates the format of the image  */
+  /*                         contained in the glyph slot.  Typically       */
+  /*                         @FT_GLYPH_FORMAT_BITMAP,                      */
+  /*                         @FT_GLYPH_FORMAT_OUTLINE, or                  */
+  /*                         @FT_GLYPH_FORMAT_COMPOSITE, but other values  */
+  /*                         are possible.                                 */
+  /*                                                                       */
+  /*    bitmap            :: This field is used as a bitmap descriptor     */
+  /*                         when the slot format is                       */
+  /*                         @FT_GLYPH_FORMAT_BITMAP.  Note that the       */
+  /*                         address and content of the bitmap buffer can  */
+  /*                         change between calls of @FT_Load_Glyph and a  */
+  /*                         few other functions.                          */
+  /*                                                                       */
+  /*    bitmap_left       :: The bitmap's left bearing expressed in        */
+  /*                         integer pixels.  Only valid if the format is  */
+  /*                         @FT_GLYPH_FORMAT_BITMAP, this is, if the      */
+  /*                         glyph slot contains a bitmap.                 */
+  /*                                                                       */
+  /*    bitmap_top        :: The bitmap's top bearing expressed in integer */
+  /*                         pixels.  This is the distance from the        */
+  /*                         baseline to the top-most glyph scanline,      */
+  /*                         upwards y~coordinates being *positive*.       */
+  /*                                                                       */
+  /*    outline           :: The outline descriptor for the current glyph  */
+  /*                         image if its format is                        */
+  /*                         @FT_GLYPH_FORMAT_OUTLINE.  Once a glyph is    */
+  /*                         loaded, `outline' can be transformed,         */
+  /*                         distorted, emboldened, etc.  However, it must */
+  /*                         not be freed.                                 */
+  /*                                                                       */
+  /*    num_subglyphs     :: The number of subglyphs in a composite glyph. */
+  /*                         This field is only valid for the composite    */
+  /*                         glyph format that should normally only be     */
+  /*                         loaded with the @FT_LOAD_NO_RECURSE flag.     */
+  /*                                                                       */
+  /*    subglyphs         :: An array of subglyph descriptors for          */
+  /*                         composite glyphs.  There are `num_subglyphs'  */
+  /*                         elements in there.  Currently internal to     */
+  /*                         FreeType.                                     */
+  /*                                                                       */
+  /*    control_data      :: Certain font drivers can also return the      */
+  /*                         control data for a given glyph image (e.g.    */
+  /*                         TrueType bytecode, Type~1 charstrings, etc.). */
+  /*                         This field is a pointer to such data; it is   */
+  /*                         currently internal to FreeType.               */
+  /*                                                                       */
+  /*    control_len       :: This is the length in bytes of the control    */
+  /*                         data.  Currently internal to FreeType.        */
+  /*                                                                       */
+  /*    other             :: Reserved.                                     */
+  /*                                                                       */
+  /*    lsb_delta         :: The difference between hinted and unhinted    */
+  /*                         left side bearing while auto-hinting is       */
+  /*                         active.  Zero otherwise.                      */
+  /*                                                                       */
+  /*    rsb_delta         :: The difference between hinted and unhinted    */
+  /*                         right side bearing while auto-hinting is      */
+  /*                         active.  Zero otherwise.                      */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    If @FT_Load_Glyph is called with default flags (see                */
+  /*    @FT_LOAD_DEFAULT) the glyph image is loaded in the glyph slot in   */
+  /*    its native format (e.g., an outline glyph for TrueType and Type~1  */
+  /*    formats).                                                          */
+  /*                                                                       */
+  /*    This image can later be converted into a bitmap by calling         */
+  /*    @FT_Render_Glyph.  This function searches the current renderer for */
+  /*    the native image's format, then invokes it.                        */
+  /*                                                                       */
+  /*    The renderer is in charge of transforming the native image through */
+  /*    the slot's face transformation fields, then converting it into a   */
+  /*    bitmap that is returned in `slot->bitmap'.                         */
+  /*                                                                       */
+  /*    Note that `slot->bitmap_left' and `slot->bitmap_top' are also used */
+  /*    to specify the position of the bitmap relative to the current pen  */
+  /*    position (e.g., coordinates (0,0) on the baseline).  Of course,    */
+  /*    `slot->format' is also changed to @FT_GLYPH_FORMAT_BITMAP.         */
+  /*                                                                       */
+  /*    Here is a small pseudo code fragment that shows how to use         */
+  /*    `lsb_delta' and `rsb_delta' to do fractional positioning of        */
+  /*    glyphs:                                                            */
+  /*                                                                       */
+  /*    {                                                                  */
+  /*      FT_GlyphSlot  slot     = face->glyph;                            */
+  /*      FT_Pos        origin_x = 0;                                      */
+  /*                                                                       */
+  /*                                                                       */
+  /*      for all glyphs do                                                */
+  /*        <load glyph with `FT_Load_Glyph'>                              */
+  /*                                                                       */
+  /*        FT_Outline_Translate( slot->outline, origin_x & 63, 0 );       */
+  /*                                                                       */
+  /*        <save glyph image, or render glyph, or ...>                    */
+  /*                                                                       */
+  /*        <compute kern between current and next glyph                   */
+  /*         and add it to `origin_x'>                                     */
+  /*                                                                       */
+  /*        origin_x += slot->advance.x;                                   */
+  /*        origin_x += slot->rsb_delta - slot->lsb_delta;                 */
+  /*      endfor                                                           */
+  /*    }                                                                  */
+  /*                                                                       */
+  /*    Here is another small pseudo code fragment that shows how to use   */
+  /*    `lsb_delta' and `rsb_delta' to improve integer positioning of      */
+  /*    glyphs:                                                            */
+  /*                                                                       */
+  /*    {                                                                  */
+  /*      FT_GlyphSlot  slot           = face->glyph;                      */
+  /*      FT_Pos        origin_x       = 0;                                */
+  /*      FT_Pos        prev_rsb_delta = 0;                                */
+  /*                                                                       */
+  /*                                                                       */
+  /*      for all glyphs do                                                */
+  /*        <compute kern between current and previous glyph               */
+  /*         and add it to `origin_x'>                                     */
+  /*                                                                       */
+  /*        <load glyph with `FT_Load_Glyph'>                              */
+  /*                                                                       */
+  /*        if ( prev_rsb_delta - slot->lsb_delta >  32 )                  */
+  /*          origin_x -= 64;                                              */
+  /*        else if ( prev_rsb_delta - slot->lsb_delta < -31 )             */
+  /*          origin_x += 64;                                              */
+  /*                                                                       */
+  /*        prev_rsb_delta = slot->rsb_delta;                              */
+  /*                                                                       */
+  /*        <save glyph image, or render glyph, or ...>                    */
+  /*                                                                       */
+  /*        origin_x += slot->advance.x;                                   */
+  /*      endfor                                                           */
+  /*    }                                                                  */
+  /*                                                                       */
+  /*    If you use strong auto-hinting, you *must* apply these delta       */
+  /*    values!  Otherwise you will experience far too large inter-glyph   */
+  /*    spacing at small rendering sizes in most cases.  Note that it      */
+  /*    doesn't harm to use the above code for other hinting modes also,   */
+  /*    since the delta values are zero then.                              */
+  /*                                                                       */
+  typedef struct  FT_GlyphSlotRec_
+  {
+    FT_Library        library;
+    FT_Face           face;
+    FT_GlyphSlot      next;
+    FT_UInt           reserved;       /* retained for binary compatibility */
+    FT_Generic        generic;
+
+    FT_Glyph_Metrics  metrics;
+    FT_Fixed          linearHoriAdvance;
+    FT_Fixed          linearVertAdvance;
+    FT_Vector         advance;
+
+    FT_Glyph_Format   format;
+
+    FT_Bitmap         bitmap;
+    FT_Int            bitmap_left;
+    FT_Int            bitmap_top;
+
+    FT_Outline        outline;
+
+    FT_UInt           num_subglyphs;
+    FT_SubGlyph       subglyphs;
+
+    void*             control_data;
+    long              control_len;
+
+    FT_Pos            lsb_delta;
+    FT_Pos            rsb_delta;
+
+    void*             other;
+
+    FT_Slot_Internal  internal;
+
+  } FT_GlyphSlotRec;
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*                                                                       */
+  /*                         F U N C T I O N S                             */
+  /*                                                                       */
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Init_FreeType                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Initialize a new FreeType library object.  The set of modules      */
+  /*    that are registered by this function is determined at build time.  */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    alibrary :: A handle to a new library object.                      */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    In case you want to provide your own memory allocating routines,   */
+  /*    use @FT_New_Library instead, followed by a call to                 */
+  /*    @FT_Add_Default_Modules (or a series of calls to @FT_Add_Module)   */
+  /*    and @FT_Set_Default_Properties.                                    */
+  /*                                                                       */
+  /*    See the documentation of @FT_Library and @FT_Face for              */
+  /*    multi-threading issues.                                            */
+  /*                                                                       */
+  /*    If you need reference-counting (cf. @FT_Reference_Library), use    */
+  /*    @FT_New_Library and @FT_Done_Library.                              */
+  /*                                                                       */
+  /*    If compilation option FT_CONFIG_OPTION_ENVIRONMENT_PROPERTIES is   */
+  /*    set, this function reads the `FREETYPE_PROPERTIES' environment     */
+  /*    variable to control driver properties.  See sections @auto_hinter, */
+  /*    @cff_driver, @pcf_driver, and @tt_driver for more.                 */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Init_FreeType( FT_Library  *alibrary );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Done_FreeType                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Destroy a given FreeType library object and all of its children,   */
+  /*    including resources, drivers, faces, sizes, etc.                   */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    library :: A handle to the target library object.                  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Done_FreeType( FT_Library  library );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    FT_OPEN_XXX                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A list of bit field constants used within the `flags' field of the */
+  /*    @FT_Open_Args structure.                                           */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    FT_OPEN_MEMORY   :: This is a memory-based stream.                 */
+  /*                                                                       */
+  /*    FT_OPEN_STREAM   :: Copy the stream from the `stream' field.       */
+  /*                                                                       */
+  /*    FT_OPEN_PATHNAME :: Create a new input stream from a C~path        */
+  /*                        name.                                          */
+  /*                                                                       */
+  /*    FT_OPEN_DRIVER   :: Use the `driver' field.                        */
+  /*                                                                       */
+  /*    FT_OPEN_PARAMS   :: Use the `num_params' and `params' fields.      */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The `FT_OPEN_MEMORY', `FT_OPEN_STREAM', and `FT_OPEN_PATHNAME'     */
+  /*    flags are mutually exclusive.                                      */
+  /*                                                                       */
+#define FT_OPEN_MEMORY    0x1
+#define FT_OPEN_STREAM    0x2
+#define FT_OPEN_PATHNAME  0x4
+#define FT_OPEN_DRIVER    0x8
+#define FT_OPEN_PARAMS    0x10
+
+
+  /* these constants are deprecated; use the corresponding `FT_OPEN_XXX' */
+  /* values instead                                                      */
+#define ft_open_memory    FT_OPEN_MEMORY
+#define ft_open_stream    FT_OPEN_STREAM
+#define ft_open_pathname  FT_OPEN_PATHNAME
+#define ft_open_driver    FT_OPEN_DRIVER
+#define ft_open_params    FT_OPEN_PARAMS
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Parameter                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A simple structure to pass more or less generic parameters to      */
+  /*    @FT_Open_Face and @FT_Face_Properties.                             */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    tag  :: A four-byte identification tag.                            */
+  /*                                                                       */
+  /*    data :: A pointer to the parameter data.                           */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The ID and function of parameters are driver-specific.  See the    */
+  /*    various FT_PARAM_TAG_XXX flags for more information.               */
+  /*                                                                       */
+  typedef struct  FT_Parameter_
+  {
+    FT_ULong    tag;
+    FT_Pointer  data;
+
+  } FT_Parameter;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Open_Args                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure to indicate how to open a new font file or stream.  A  */
+  /*    pointer to such a structure can be used as a parameter for the     */
+  /*    functions @FT_Open_Face and @FT_Attach_Stream.                     */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    flags       :: A set of bit flags indicating how to use the        */
+  /*                   structure.                                          */
+  /*                                                                       */
+  /*    memory_base :: The first byte of the file in memory.               */
+  /*                                                                       */
+  /*    memory_size :: The size in bytes of the file in memory.            */
+  /*                                                                       */
+  /*    pathname    :: A pointer to an 8-bit file pathname.                */
+  /*                                                                       */
+  /*    stream      :: A handle to a source stream object.                 */
+  /*                                                                       */
+  /*    driver      :: This field is exclusively used by @FT_Open_Face;    */
+  /*                   it simply specifies the font driver to use for      */
+  /*                   opening the face.  If set to NULL, FreeType tries   */
+  /*                   to load the face with each one of the drivers in    */
+  /*                   its list.                                           */
+  /*                                                                       */
+  /*    num_params  :: The number of extra parameters.                     */
+  /*                                                                       */
+  /*    params      :: Extra parameters passed to the font driver when     */
+  /*                   opening a new face.                                 */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The stream type is determined by the contents of `flags' that      */
+  /*    are tested in the following order by @FT_Open_Face:                */
+  /*                                                                       */
+  /*    If the @FT_OPEN_MEMORY bit is set, assume that this is a           */
+  /*    memory file of `memory_size' bytes, located at `memory_address'.   */
+  /*    The data are not copied, and the client is responsible for         */
+  /*    releasing and destroying them _after_ the corresponding call to    */
+  /*    @FT_Done_Face.                                                     */
+  /*                                                                       */
+  /*    Otherwise, if the @FT_OPEN_STREAM bit is set, assume that a        */
+  /*    custom input stream `stream' is used.                              */
+  /*                                                                       */
+  /*    Otherwise, if the @FT_OPEN_PATHNAME bit is set, assume that this   */
+  /*    is a normal file and use `pathname' to open it.                    */
+  /*                                                                       */
+  /*    If the @FT_OPEN_DRIVER bit is set, @FT_Open_Face only tries to     */
+  /*    open the file with the driver whose handler is in `driver'.        */
+  /*                                                                       */
+  /*    If the @FT_OPEN_PARAMS bit is set, the parameters given by         */
+  /*    `num_params' and `params' is used.  They are ignored otherwise.    */
+  /*                                                                       */
+  /*    Ideally, both the `pathname' and `params' fields should be tagged  */
+  /*    as `const'; this is missing for API backward compatibility.  In    */
+  /*    other words, applications should treat them as read-only.          */
+  /*                                                                       */
+  typedef struct  FT_Open_Args_
+  {
+    FT_UInt         flags;
+    const FT_Byte*  memory_base;
+    FT_Long         memory_size;
+    FT_String*      pathname;
+    FT_Stream       stream;
+    FT_Module       driver;
+    FT_Int          num_params;
+    FT_Parameter*   params;
+
+  } FT_Open_Args;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_New_Face                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Call @FT_Open_Face to open a font by its pathname.                 */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    library    :: A handle to the library resource.                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    pathname   :: A path to the font file.                             */
+  /*                                                                       */
+  /*    face_index :: See @FT_Open_Face for a detailed description of this */
+  /*                  parameter.                                           */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    aface      :: A handle to a new face object.  If `face_index' is   */
+  /*                  greater than or equal to zero, it must be non-NULL.  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Use @FT_Done_Face to destroy the created @FT_Face object (along    */
+  /*    with its slot and sizes).                                          */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_New_Face( FT_Library   library,
+               const char*  filepathname,
+               FT_Long      face_index,
+               FT_Face     *aface );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_New_Memory_Face                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Call @FT_Open_Face to open a font that has been loaded into        */
+  /*    memory.                                                            */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    library    :: A handle to the library resource.                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    file_base  :: A pointer to the beginning of the font data.         */
+  /*                                                                       */
+  /*    file_size  :: The size of the memory chunk used by the font data.  */
+  /*                                                                       */
+  /*    face_index :: See @FT_Open_Face for a detailed description of this */
+  /*                  parameter.                                           */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    aface      :: A handle to a new face object.  If `face_index' is   */
+  /*                  greater than or equal to zero, it must be non-NULL.  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    You must not deallocate the memory before calling @FT_Done_Face.   */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_New_Memory_Face( FT_Library      library,
+                      const FT_Byte*  file_base,
+                      FT_Long         file_size,
+                      FT_Long         face_index,
+                      FT_Face        *aface );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Open_Face                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Create a face object from a given resource described by            */
+  /*    @FT_Open_Args.                                                     */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    library    :: A handle to the library resource.                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    args       :: A pointer to an `FT_Open_Args' structure that must   */
+  /*                  be filled by the caller.                             */
+  /*                                                                       */
+  /*    face_index :: This field holds two different values.  Bits 0-15    */
+  /*                  are the index of the face in the font file (starting */
+  /*                  with value~0).  Set it to~0 if there is only one     */
+  /*                  face in the font file.                               */
+  /*                                                                       */
+  /*                  Bits 16-30 are relevant to GX and OpenType variation */
+  /*                  fonts only, specifying the named instance index for  */
+  /*                  the current face index (starting with value~1;       */
+  /*                  value~0 makes FreeType ignore named instances).  For */
+  /*                  non-variation fonts, bits 16-30 are ignored.         */
+  /*                  Assuming that you want to access the third named     */
+  /*                  instance in face~4, `face_index' should be set to    */
+  /*                  0x00030004.  If you want to access face~4 without    */
+  /*                  variation handling, simply set `face_index' to       */
+  /*                  value~4.                                             */
+  /*                                                                       */
+  /*                  `FT_Open_Face' and its siblings can be used to       */
+  /*                  quickly check whether the font format of a given     */
+  /*                  font resource is supported by FreeType.  In general, */
+  /*                  if the `face_index' argument is negative, the        */
+  /*                  function's return value is~0 if the font format is   */
+  /*                  recognized, or non-zero otherwise.  The function     */
+  /*                  allocates a more or less empty face handle in        */
+  /*                  `*aface' (if `aface' isn't NULL); the only two       */
+  /*                  useful fields in this special case are               */
+  /*                  `face->num_faces' and `face->style_flags'.  For any  */
+  /*                  negative value of `face_index', `face->num_faces'    */
+  /*                  gives the number of faces within the font file.  For */
+  /*                  the negative value `-(N+1)' (with `N' a non-negative */
+  /*                  16-bit value), bits 16-30 in `face->style_flags'     */
+  /*                  give the number of named instances in face `N' if we */
+  /*                  have a variation font (or zero otherwise).  After    */
+  /*                  examination, the returned @FT_Face structure should  */
+  /*                  be deallocated with a call to @FT_Done_Face.         */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    aface      :: A handle to a new face object.  If `face_index' is   */
+  /*                  greater than or equal to zero, it must be non-NULL.  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Unlike FreeType 1.x, this function automatically creates a glyph   */
+  /*    slot for the face object that can be accessed directly through     */
+  /*    `face->glyph'.                                                     */
+  /*                                                                       */
+  /*    Each new face object created with this function also owns a        */
+  /*    default @FT_Size object, accessible as `face->size'.               */
+  /*                                                                       */
+  /*    One @FT_Library instance can have multiple face objects, this is,  */
+  /*    @FT_Open_Face and its siblings can be called multiple times using  */
+  /*    the same `library' argument.                                       */
+  /*                                                                       */
+  /*    See the discussion of reference counters in the description of     */
+  /*    @FT_Reference_Face.                                                */
+  /*                                                                       */
+  /*    To loop over all faces, use code similar to the following snippet  */
+  /*    (omitting the error handling).                                     */
+  /*                                                                       */
+  /*    {                                                                  */
+  /*      ...                                                              */
+  /*      FT_Face  face;                                                   */
+  /*      FT_Long  i, num_faces;                                           */
+  /*                                                                       */
+  /*                                                                       */
+  /*      error = FT_Open_Face( library, args, -1, &face );                */
+  /*      if ( error ) { ... }                                             */
+  /*                                                                       */
+  /*      num_faces = face->num_faces;                                     */
+  /*      FT_Done_Face( face );                                            */
+  /*                                                                       */
+  /*      for ( i = 0; i < num_faces; i++ )                                */
+  /*      {                                                                */
+  /*        ...                                                            */
+  /*        error = FT_Open_Face( library, args, i, &face );               */
+  /*        ...                                                            */
+  /*        FT_Done_Face( face );                                          */
+  /*        ...                                                            */
+  /*      }                                                                */
+  /*    }                                                                  */
+  /*                                                                       */
+  /*    To loop over all valid values for `face_index', use something      */
+  /*    similar to the following snippet, again without error handling.    */
+  /*    The code accesses all faces immediately (thus only a single call   */
+  /*    of `FT_Open_Face' within the do-loop), with and without named      */
+  /*    instances.                                                         */
+  /*                                                                       */
+  /*    {                                                                  */
+  /*      ...                                                              */
+  /*      FT_Face  face;                                                   */
+  /*                                                                       */
+  /*      FT_Long  num_faces     = 0;                                      */
+  /*      FT_Long  num_instances = 0;                                      */
+  /*                                                                       */
+  /*      FT_Long  face_idx     = 0;                                       */
+  /*      FT_Long  instance_idx = 0;                                       */
+  /*                                                                       */
+  /*                                                                       */
+  /*      do                                                               */
+  /*      {                                                                */
+  /*        FT_Long  id = ( instance_idx << 16 ) + face_idx;               */
+  /*                                                                       */
+  /*                                                                       */
+  /*        error = FT_Open_Face( library, args, id, &face );              */
+  /*        if ( error ) { ... }                                           */
+  /*                                                                       */
+  /*        num_faces     = face->num_faces;                               */
+  /*        num_instances = face->style_flags >> 16;                       */
+  /*                                                                       */
+  /*        ...                                                            */
+  /*                                                                       */
+  /*        FT_Done_Face( face );                                          */
+  /*                                                                       */
+  /*        if ( instance_idx < num_instances )                            */
+  /*          instance_idx++;                                              */
+  /*        else                                                           */
+  /*        {                                                              */
+  /*          face_idx++;                                                  */
+  /*          instance_idx = 0;                                            */
+  /*        }                                                              */
+  /*                                                                       */
+  /*      } while ( face_idx < num_faces )                                 */
+  /*    }                                                                  */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Open_Face( FT_Library           library,
+                const FT_Open_Args*  args,
+                FT_Long              face_index,
+                FT_Face             *aface );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Attach_File                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Call @FT_Attach_Stream to attach a file.                           */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face         :: The target face object.                            */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    filepathname :: The pathname.                                      */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Attach_File( FT_Face      face,
+                  const char*  filepathname );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Attach_Stream                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    `Attach' data to a face object.  Normally, this is used to read    */
+  /*    additional information for the face object.  For example, you can  */
+  /*    attach an AFM file that comes with a Type~1 font to get the        */
+  /*    kerning values and other metrics.                                  */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face       :: The target face object.                              */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    parameters :: A pointer to @FT_Open_Args that must be filled by    */
+  /*                  the caller.                                          */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The meaning of the `attach' (i.e., what really happens when the    */
+  /*    new file is read) is not fixed by FreeType itself.  It really      */
+  /*    depends on the font format (and thus the font driver).             */
+  /*                                                                       */
+  /*    Client applications are expected to know what they are doing       */
+  /*    when invoking this function.  Most drivers simply do not implement */
+  /*    file or stream attachments.                                        */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Attach_Stream( FT_Face        face,
+                    FT_Open_Args*  parameters );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Reference_Face                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A counter gets initialized to~1 at the time an @FT_Face structure  */
+  /*    is created.  This function increments the counter.  @FT_Done_Face  */
+  /*    then only destroys a face if the counter is~1, otherwise it simply */
+  /*    decrements the counter.                                            */
+  /*                                                                       */
+  /*    This function helps in managing life-cycles of structures that     */
+  /*    reference @FT_Face objects.                                        */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face :: A handle to a target face object.                          */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Since>                                                               */
+  /*    2.4.2                                                              */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Reference_Face( FT_Face  face );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Done_Face                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Discard a given face object, as well as all of its child slots and */
+  /*    sizes.                                                             */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face :: A handle to a target face object.                          */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    See the discussion of reference counters in the description of     */
+  /*    @FT_Reference_Face.                                                */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Done_Face( FT_Face  face );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Select_Size                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Select a bitmap strike.  To be more precise, this function sets    */
+  /*    the scaling factors of the active @FT_Size object in a face so     */
+  /*    that bitmaps from this particular strike are taken by              */
+  /*    @FT_Load_Glyph and friends.                                        */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face         :: A handle to a target face object.                  */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    strike_index :: The index of the bitmap strike in the              */
+  /*                    `available_sizes' field of @FT_FaceRec structure.  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    For bitmaps embedded in outline fonts it is common that only a     */
+  /*    subset of the available glyphs at a given ppem value is available. */
+  /*    FreeType silently uses outlines if there is no bitmap for a given  */
+  /*    glyph index.                                                       */
+  /*                                                                       */
+  /*    For GX and OpenType variation fonts, a bitmap strike makes sense   */
+  /*    only if the default instance is active (this is, no glyph          */
+  /*    variation takes place); otherwise, FreeType simply ignores bitmap  */
+  /*    strikes.  The same is true for all named instances that are        */
+  /*    different from the default instance.                               */
+  /*                                                                       */
+  /*    Don't use this function if you are using the FreeType cache API.   */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Select_Size( FT_Face  face,
+                  FT_Int   strike_index );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    FT_Size_Request_Type                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An enumeration type that lists the supported size request types,   */
+  /*    i.e., what input size (in font units) maps to the requested output */
+  /*    size (in pixels, as computed from the arguments of                 */
+  /*    @FT_Size_Request).                                                 */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    FT_SIZE_REQUEST_TYPE_NOMINAL ::                                    */
+  /*      The nominal size.  The `units_per_EM' field of @FT_FaceRec is    */
+  /*      used to determine both scaling values.                           */
+  /*                                                                       */
+  /*      This is the standard scaling found in most applications.  In     */
+  /*      particular, use this size request type for TrueType fonts if     */
+  /*      they provide optical scaling or something similar.  Note,        */
+  /*      however, that `units_per_EM' is a rather abstract value which    */
+  /*      bears no relation to the actual size of the glyphs in a font.    */
+  /*                                                                       */
+  /*    FT_SIZE_REQUEST_TYPE_REAL_DIM ::                                   */
+  /*      The real dimension.  The sum of the `ascender' and (minus of)    */
+  /*      the `descender' fields of @FT_FaceRec is used to determine both  */
+  /*      scaling values.                                                  */
+  /*                                                                       */
+  /*    FT_SIZE_REQUEST_TYPE_BBOX ::                                       */
+  /*      The font bounding box.  The width and height of the `bbox' field */
+  /*      of @FT_FaceRec are used to determine the horizontal and vertical */
+  /*      scaling value, respectively.                                     */
+  /*                                                                       */
+  /*    FT_SIZE_REQUEST_TYPE_CELL ::                                       */
+  /*      The `max_advance_width' field of @FT_FaceRec is used to          */
+  /*      determine the horizontal scaling value; the vertical scaling     */
+  /*      value is determined the same way as                              */
+  /*      @FT_SIZE_REQUEST_TYPE_REAL_DIM does.  Finally, both scaling      */
+  /*      values are set to the smaller one.  This type is useful if you   */
+  /*      want to specify the font size for, say, a window of a given      */
+  /*      dimension and 80x24 cells.                                       */
+  /*                                                                       */
+  /*    FT_SIZE_REQUEST_TYPE_SCALES ::                                     */
+  /*      Specify the scaling values directly.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The above descriptions only apply to scalable formats.  For bitmap */
+  /*    formats, the behaviour is up to the driver.                        */
+  /*                                                                       */
+  /*    See the note section of @FT_Size_Metrics if you wonder how size    */
+  /*    requesting relates to scaling values.                              */
+  /*                                                                       */
+  typedef enum  FT_Size_Request_Type_
+  {
+    FT_SIZE_REQUEST_TYPE_NOMINAL,
+    FT_SIZE_REQUEST_TYPE_REAL_DIM,
+    FT_SIZE_REQUEST_TYPE_BBOX,
+    FT_SIZE_REQUEST_TYPE_CELL,
+    FT_SIZE_REQUEST_TYPE_SCALES,
+
+    FT_SIZE_REQUEST_TYPE_MAX
+
+  } FT_Size_Request_Type;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Size_RequestRec                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure to model a size request.                               */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    type           :: See @FT_Size_Request_Type.                       */
+  /*                                                                       */
+  /*    width          :: The desired width, given as a 26.6 fractional    */
+  /*                      point value (with 72pt = 1in).                   */
+  /*                                                                       */
+  /*    height         :: The desired height, given as a 26.6 fractional   */
+  /*                      point value (with 72pt = 1in).                   */
+  /*                                                                       */
+  /*    horiResolution :: The horizontal resolution (dpi, i.e., pixels per */
+  /*                      inch).  If set to zero, `width' is treated as a  */
+  /*                      26.6 fractional *pixel* value, which gets        */
+  /*                      internally rounded to an integer.                */
+  /*                                                                       */
+  /*    vertResolution :: The vertical resolution (dpi, i.e., pixels per   */
+  /*                      inch).  If set to zero, `height' is treated as a */
+  /*                      26.6 fractional *pixel* value, which gets        */
+  /*                      internally rounded to an integer.                */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    If `width' is zero, the horizontal scaling value is set equal      */
+  /*    to the vertical scaling value, and vice versa.                     */
+  /*                                                                       */
+  /*    If `type' is FT_SIZE_REQUEST_TYPE_SCALES, `width' and `height' are */
+  /*    interpreted directly as 16.16 fractional scaling values, without   */
+  /*    any further modification, and both `horiResolution' and            */
+  /*    `vertResolution' are ignored.                                      */
+  /*                                                                       */
+  typedef struct  FT_Size_RequestRec_
+  {
+    FT_Size_Request_Type  type;
+    FT_Long               width;
+    FT_Long               height;
+    FT_UInt               horiResolution;
+    FT_UInt               vertResolution;
+
+  } FT_Size_RequestRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Size_Request                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a size request structure.                              */
+  /*                                                                       */
+  typedef struct FT_Size_RequestRec_  *FT_Size_Request;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Request_Size                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Resize the scale of the active @FT_Size object in a face.          */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face :: A handle to a target face object.                          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    req  :: A pointer to a @FT_Size_RequestRec.                        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Although drivers may select the bitmap strike matching the         */
+  /*    request, you should not rely on this if you intend to select a     */
+  /*    particular bitmap strike.  Use @FT_Select_Size instead in that     */
+  /*    case.                                                              */
+  /*                                                                       */
+  /*    The relation between the requested size and the resulting glyph    */
+  /*    size is dependent entirely on how the size is defined in the       */
+  /*    source face.  The font designer chooses the final size of each     */
+  /*    glyph relative to this size.  For more information refer to        */
+  /*    `https://www.freetype.org/freetype2/docs/glyphs/glyphs-2.html'.    */
+  /*                                                                       */
+  /*    Contrary to @FT_Set_Char_Size, this function doesn't have special  */
+  /*    code to normalize zero-valued widths, heights, or resolutions      */
+  /*    (which lead to errors in most cases).                              */
+  /*                                                                       */
+  /*    Don't use this function if you are using the FreeType cache API.   */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Request_Size( FT_Face          face,
+                   FT_Size_Request  req );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Set_Char_Size                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Call @FT_Request_Size to request the nominal size (in points).     */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face            :: A handle to a target face object.               */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    char_width      :: The nominal width, in 26.6 fractional points.   */
+  /*                                                                       */
+  /*    char_height     :: The nominal height, in 26.6 fractional points.  */
+  /*                                                                       */
+  /*    horz_resolution :: The horizontal resolution in dpi.               */
+  /*                                                                       */
+  /*    vert_resolution :: The vertical resolution in dpi.                 */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    While this function allows fractional points as input values, the  */
+  /*    resulting ppem value for the given resolution is always rounded to */
+  /*    the nearest integer.                                               */
+  /*                                                                       */
+  /*    If either the character width or height is zero, it is set equal   */
+  /*    to the other value.                                                */
+  /*                                                                       */
+  /*    If either the horizontal or vertical resolution is zero, it is set */
+  /*    equal to the other value.                                          */
+  /*                                                                       */
+  /*    A character width or height smaller than 1pt is set to 1pt; if     */
+  /*    both resolution values are zero, they are set to 72dpi.            */
+  /*                                                                       */
+  /*    Don't use this function if you are using the FreeType cache API.   */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Set_Char_Size( FT_Face     face,
+                    FT_F26Dot6  char_width,
+                    FT_F26Dot6  char_height,
+                    FT_UInt     horz_resolution,
+                    FT_UInt     vert_resolution );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Set_Pixel_Sizes                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Call @FT_Request_Size to request the nominal size (in pixels).     */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face         :: A handle to the target face object.                */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    pixel_width  :: The nominal width, in pixels.                      */
+  /*                                                                       */
+  /*    pixel_height :: The nominal height, in pixels.                     */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    You should not rely on the resulting glyphs matching or being      */
+  /*    constrained to this pixel size.  Refer to @FT_Request_Size to      */
+  /*    understand how requested sizes relate to actual sizes.             */
+  /*                                                                       */
+  /*    Don't use this function if you are using the FreeType cache API.   */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Set_Pixel_Sizes( FT_Face  face,
+                      FT_UInt  pixel_width,
+                      FT_UInt  pixel_height );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Load_Glyph                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Load a glyph into the glyph slot of a face object.                 */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face        :: A handle to the target face object where the glyph  */
+  /*                   is loaded.                                          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    glyph_index :: The index of the glyph in the font file.  For       */
+  /*                   CID-keyed fonts (either in PS or in CFF format)     */
+  /*                   this argument specifies the CID value.              */
+  /*                                                                       */
+  /*    load_flags  :: A flag indicating what to load for this glyph.  The */
+  /*                   @FT_LOAD_XXX constants can be used to control the   */
+  /*                   glyph loading process (e.g., whether the outline    */
+  /*                   should be scaled, whether to load bitmaps or not,   */
+  /*                   whether to hint the outline, etc).                  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The loaded glyph may be transformed.  See @FT_Set_Transform for    */
+  /*    the details.                                                       */
+  /*                                                                       */
+  /*    For subsetted CID-keyed fonts, `FT_Err_Invalid_Argument' is        */
+  /*    returned for invalid CID values (this is, for CID values that      */
+  /*    don't have a corresponding glyph in the font).  See the discussion */
+  /*    of the @FT_FACE_FLAG_CID_KEYED flag for more details.              */
+  /*                                                                       */
+  /*    If you receive `FT_Err_Glyph_Too_Big', try getting the glyph       */
+  /*    outline at EM size, then scale it manually and fill it as a        */
+  /*    graphics operation.                                                */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Load_Glyph( FT_Face   face,
+                 FT_UInt   glyph_index,
+                 FT_Int32  load_flags );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Load_Char                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Load a glyph into the glyph slot of a face object, accessed by its */
+  /*    character code.                                                    */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face        :: A handle to a target face object where the glyph    */
+  /*                   is loaded.                                          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    char_code   :: The glyph's character code, according to the        */
+  /*                   current charmap used in the face.                   */
+  /*                                                                       */
+  /*    load_flags  :: A flag indicating what to load for this glyph.  The */
+  /*                   @FT_LOAD_XXX constants can be used to control the   */
+  /*                   glyph loading process (e.g., whether the outline    */
+  /*                   should be scaled, whether to load bitmaps or not,   */
+  /*                   whether to hint the outline, etc).                  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This function simply calls @FT_Get_Char_Index and @FT_Load_Glyph.  */
+  /*                                                                       */
+  /*    Many fonts contain glyphs that can't be loaded by this function    */
+  /*    since its glyph indices are not listed in any of the font's        */
+  /*    charmaps.                                                          */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Load_Char( FT_Face   face,
+                FT_ULong  char_code,
+                FT_Int32  load_flags );
+
+
+  /*************************************************************************
+   *
+   * @enum:
+   *   FT_LOAD_XXX
+   *
+   * @description:
+   *   A list of bit field constants for @FT_Load_Glyph to indicate what
+   *   kind of operations to perform during glyph loading.
+   *
+   * @values:
+   *   FT_LOAD_DEFAULT ::
+   *     Corresponding to~0, this value is used as the default glyph load
+   *     operation.  In this case, the following happens:
+   *
+   *     1. FreeType looks for a bitmap for the glyph corresponding to the
+   *        face's current size.  If one is found, the function returns.
+   *        The bitmap data can be accessed from the glyph slot (see note
+   *        below).
+   *
+   *     2. If no embedded bitmap is searched for or found, FreeType looks
+   *        for a scalable outline.  If one is found, it is loaded from
+   *        the font file, scaled to device pixels, then `hinted' to the
+   *        pixel grid in order to optimize it.  The outline data can be
+   *        accessed from the glyph slot (see note below).
+   *
+   *     Note that by default the glyph loader doesn't render outlines into
+   *     bitmaps.  The following flags are used to modify this default
+   *     behaviour to more specific and useful cases.
+   *
+   *   FT_LOAD_NO_SCALE ::
+   *     Don't scale the loaded outline glyph but keep it in font units.
+   *
+   *     This flag implies @FT_LOAD_NO_HINTING and @FT_LOAD_NO_BITMAP, and
+   *     unsets @FT_LOAD_RENDER.
+   *
+   *     If the font is `tricky' (see @FT_FACE_FLAG_TRICKY for more), using
+   *     FT_LOAD_NO_SCALE usually yields meaningless outlines because the
+   *     subglyphs must be scaled and positioned with hinting instructions.
+   *     This can be solved by loading the font without FT_LOAD_NO_SCALE and
+   *     setting the character size to `font->units_per_EM'.
+   *
+   *   FT_LOAD_NO_HINTING ::
+   *     Disable hinting.  This generally generates `blurrier' bitmap glyphs
+   *     when the glyph are rendered in any of the anti-aliased modes.  See
+   *     also the note below.
+   *
+   *     This flag is implied by @FT_LOAD_NO_SCALE.
+   *
+   *   FT_LOAD_RENDER ::
+   *     Call @FT_Render_Glyph after the glyph is loaded.  By default, the
+   *     glyph is rendered in @FT_RENDER_MODE_NORMAL mode.  This can be
+   *     overridden by @FT_LOAD_TARGET_XXX or @FT_LOAD_MONOCHROME.
+   *
+   *     This flag is unset by @FT_LOAD_NO_SCALE.
+   *
+   *   FT_LOAD_NO_BITMAP ::
+   *     Ignore bitmap strikes when loading.  Bitmap-only fonts ignore this
+   *     flag.
+   *
+   *     @FT_LOAD_NO_SCALE always sets this flag.
+   *
+   *   FT_LOAD_VERTICAL_LAYOUT ::
+   *     Load the glyph for vertical text layout.  In particular, the
+   *     `advance' value in the @FT_GlyphSlotRec structure is set to the
+   *     `vertAdvance' value of the `metrics' field.
+   *
+   *     In case @FT_HAS_VERTICAL doesn't return true, you shouldn't use
+   *     this flag currently.  Reason is that in this case vertical metrics
+   *     get synthesized, and those values are not always consistent across
+   *     various font formats.
+   *
+   *   FT_LOAD_FORCE_AUTOHINT ::
+   *     Prefer the auto-hinter over the font's native hinter.  See also
+   *     the note below.
+   *
+   *   FT_LOAD_PEDANTIC ::
+   *     Make the font driver perform pedantic verifications during glyph
+   *     loading.  This is mostly used to detect broken glyphs in fonts.
+   *     By default, FreeType tries to handle broken fonts also.
+   *
+   *     In particular, errors from the TrueType bytecode engine are not
+   *     passed to the application if this flag is not set; this might
+   *     result in partially hinted or distorted glyphs in case a glyph's
+   *     bytecode is buggy.
+   *
+   *   FT_LOAD_NO_RECURSE ::
+   *     Don't load composite glyphs recursively.  Instead, the font
+   *     driver should set the `num_subglyph' and `subglyphs' values of
+   *     the glyph slot accordingly, and set `glyph->format' to
+   *     @FT_GLYPH_FORMAT_COMPOSITE.  The description of subglyphs can
+   *     then be accessed with @FT_Get_SubGlyph_Info.
+   *
+   *     This flag implies @FT_LOAD_NO_SCALE and @FT_LOAD_IGNORE_TRANSFORM.
+   *
+   *   FT_LOAD_IGNORE_TRANSFORM ::
+   *     Ignore the transform matrix set by @FT_Set_Transform.
+   *
+   *   FT_LOAD_MONOCHROME ::
+   *     This flag is used with @FT_LOAD_RENDER to indicate that you want to
+   *     render an outline glyph to a 1-bit monochrome bitmap glyph, with
+   *     8~pixels packed into each byte of the bitmap data.
+   *
+   *     Note that this has no effect on the hinting algorithm used.  You
+   *     should rather use @FT_LOAD_TARGET_MONO so that the
+   *     monochrome-optimized hinting algorithm is used.
+   *
+   *   FT_LOAD_LINEAR_DESIGN ::
+   *     Keep  `linearHoriAdvance' and `linearVertAdvance' fields of
+   *     @FT_GlyphSlotRec in font units.  See @FT_GlyphSlotRec for
+   *     details.
+   *
+   *   FT_LOAD_NO_AUTOHINT ::
+   *     Disable the auto-hinter.  See also the note below.
+   *
+   *   FT_LOAD_COLOR ::
+   *     Load embedded color bitmap images.  The resulting color bitmaps,
+   *     if available, will have the @FT_PIXEL_MODE_BGRA format.  If the
+   *     flag is not set and color bitmaps are found, they are converted
+   *     to 256-level gray bitmaps transparently, using the
+   *     @FT_PIXEL_MODE_GRAY format.
+   *
+   *   FT_LOAD_COMPUTE_METRICS ::
+   *     Compute glyph metrics from the glyph data, without the use of
+   *     bundled metrics tables (for example, the `hdmx' table in TrueType
+   *     fonts).  This flag is mainly used by font validating or font
+   *     editing applications, which need to ignore, verify, or edit those
+   *     tables.
+   *
+   *     Currently, this flag is only implemented for TrueType fonts.
+   *
+   *   FT_LOAD_BITMAP_METRICS_ONLY ::
+   *     Request loading of the metrics and bitmap image information of a
+   *     (possibly embedded) bitmap glyph without allocating or copying
+   *     the bitmap image data itself.  No effect if the target glyph is
+   *     not a bitmap image.
+   *
+   *     This flag unsets @FT_LOAD_RENDER.
+   *
+   *   FT_LOAD_CROP_BITMAP ::
+   *     Ignored.  Deprecated.
+   *
+   *   FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH ::
+   *     Ignored.  Deprecated.
+   *
+   * @note:
+   *   By default, hinting is enabled and the font's native hinter (see
+   *   @FT_FACE_FLAG_HINTER) is preferred over the auto-hinter.  You can
+   *   disable hinting by setting @FT_LOAD_NO_HINTING or change the
+   *   precedence by setting @FT_LOAD_FORCE_AUTOHINT.  You can also set
+   *   @FT_LOAD_NO_AUTOHINT in case you don't want the auto-hinter to be
+   *   used at all.
+   *
+   *   See the description of @FT_FACE_FLAG_TRICKY for a special exception
+   *   (affecting only a handful of Asian fonts).
+   *
+   *   Besides deciding which hinter to use, you can also decide which
+   *   hinting algorithm to use.  See @FT_LOAD_TARGET_XXX for details.
+   *
+   *   Note that the auto-hinter needs a valid Unicode cmap (either a native
+   *   one or synthesized by FreeType) for producing correct results.  If a
+   *   font provides an incorrect mapping (for example, assigning the
+   *   character code U+005A, LATIN CAPITAL LETTER Z, to a glyph depicting a
+   *   mathematical integral sign), the auto-hinter might produce useless
+   *   results.
+   *
+   */
+#define FT_LOAD_DEFAULT                      0x0
+#define FT_LOAD_NO_SCALE                     ( 1L << 0 )
+#define FT_LOAD_NO_HINTING                   ( 1L << 1 )
+#define FT_LOAD_RENDER                       ( 1L << 2 )
+#define FT_LOAD_NO_BITMAP                    ( 1L << 3 )
+#define FT_LOAD_VERTICAL_LAYOUT              ( 1L << 4 )
+#define FT_LOAD_FORCE_AUTOHINT               ( 1L << 5 )
+#define FT_LOAD_CROP_BITMAP                  ( 1L << 6 )
+#define FT_LOAD_PEDANTIC                     ( 1L << 7 )
+#define FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH  ( 1L << 9 )
+#define FT_LOAD_NO_RECURSE                   ( 1L << 10 )
+#define FT_LOAD_IGNORE_TRANSFORM             ( 1L << 11 )
+#define FT_LOAD_MONOCHROME                   ( 1L << 12 )
+#define FT_LOAD_LINEAR_DESIGN                ( 1L << 13 )
+#define FT_LOAD_NO_AUTOHINT                  ( 1L << 15 )
+  /* Bits 16-19 are used by `FT_LOAD_TARGET_' */
+#define FT_LOAD_COLOR                        ( 1L << 20 )
+#define FT_LOAD_COMPUTE_METRICS              ( 1L << 21 )
+#define FT_LOAD_BITMAP_METRICS_ONLY          ( 1L << 22 )
+
+  /* */
+
+  /* used internally only by certain font drivers */
+#define FT_LOAD_ADVANCE_ONLY                 ( 1L << 8 )
+#define FT_LOAD_SBITS_ONLY                   ( 1L << 14 )
+
+
+  /**************************************************************************
+   *
+   * @enum:
+   *   FT_LOAD_TARGET_XXX
+   *
+   * @description:
+   *   A list of values to select a specific hinting algorithm for the
+   *   hinter.  You should OR one of these values to your `load_flags'
+   *   when calling @FT_Load_Glyph.
+   *
+   *   Note that a font's native hinters may ignore the hinting algorithm
+   *   you have specified (e.g., the TrueType bytecode interpreter).  You
+   *   can set @FT_LOAD_FORCE_AUTOHINT to ensure that the auto-hinter is
+   *   used.
+   *
+   * @values:
+   *   FT_LOAD_TARGET_NORMAL ::
+   *     The default hinting algorithm, optimized for standard gray-level
+   *     rendering.  For monochrome output, use @FT_LOAD_TARGET_MONO
+   *     instead.
+   *
+   *   FT_LOAD_TARGET_LIGHT ::
+   *     A lighter hinting algorithm for gray-level modes.  Many generated
+   *     glyphs are fuzzier but better resemble their original shape.  This
+   *     is achieved by snapping glyphs to the pixel grid only vertically
+   *     (Y-axis), as is done by FreeType's new CFF engine or Microsoft's
+   *     ClearType font renderer.  This preserves inter-glyph spacing in
+   *     horizontal text.  The snapping is done either by the native font
+   *     driver, if the driver itself and the font support it, or by the
+   *     auto-hinter.
+   *
+   *     Advance widths are rounded to integer values; however, using the
+   *     `lsb_delta' and `rsb_delta' fields of @FT_GlyphSlotRec, it is
+   *     possible to get fractional advance widths for sub-pixel positioning
+   *     (which is recommended to use).
+   *
+   *     If configuration option AF_CONFIG_OPTION_TT_SIZE_METRICS is active,
+   *     TrueType-like metrics are used to make this mode behave similarly
+   *     as in unpatched FreeType versions between 2.4.6 and 2.7.1
+   *     (inclusive).
+   *
+   *   FT_LOAD_TARGET_MONO ::
+   *     Strong hinting algorithm that should only be used for monochrome
+   *     output.  The result is probably unpleasant if the glyph is rendered
+   *     in non-monochrome modes.
+   *
+   *   FT_LOAD_TARGET_LCD ::
+   *     A variant of @FT_LOAD_TARGET_LIGHT optimized for horizontally
+   *     decimated LCD displays.
+   *
+   *   FT_LOAD_TARGET_LCD_V ::
+   *     A variant of @FT_LOAD_TARGET_NORMAL optimized for vertically
+   *     decimated LCD displays.
+   *
+   * @note:
+   *   You should use only _one_ of the FT_LOAD_TARGET_XXX values in your
+   *   `load_flags'.  They can't be ORed.
+   *
+   *   If @FT_LOAD_RENDER is also set, the glyph is rendered in the
+   *   corresponding mode (i.e., the mode that matches the used algorithm
+   *   best).  An exception is FT_LOAD_TARGET_MONO since it implies
+   *   @FT_LOAD_MONOCHROME.
+   *
+   *   You can use a hinting algorithm that doesn't correspond to the same
+   *   rendering mode.  As an example, it is possible to use the `light'
+   *   hinting algorithm and have the results rendered in horizontal LCD
+   *   pixel mode, with code like
+   *
+   *     {
+   *       FT_Load_Glyph( face, glyph_index,
+   *                      load_flags | FT_LOAD_TARGET_LIGHT );
+   *
+   *       FT_Render_Glyph( face->glyph, FT_RENDER_MODE_LCD );
+   *     }
+   *
+   *   In general, you should stick with one rendering mode.  For example,
+   *   switching between @FT_LOAD_TARGET_NORMAL and @FT_LOAD_TARGET_MONO
+   *   enforces a lot of recomputation for TrueType fonts, which is slow.
+   *   Another reason is caching: Selecting a different mode usually causes
+   *   changes in both the outlines and the rasterized bitmaps; it is thus
+   *   necessary to empty the cache after a mode switch to avoid false hits.
+   *
+   */
+#define FT_LOAD_TARGET_( x )   ( (FT_Int32)( (x) & 15 ) << 16 )
+
+#define FT_LOAD_TARGET_NORMAL  FT_LOAD_TARGET_( FT_RENDER_MODE_NORMAL )
+#define FT_LOAD_TARGET_LIGHT   FT_LOAD_TARGET_( FT_RENDER_MODE_LIGHT  )
+#define FT_LOAD_TARGET_MONO    FT_LOAD_TARGET_( FT_RENDER_MODE_MONO   )
+#define FT_LOAD_TARGET_LCD     FT_LOAD_TARGET_( FT_RENDER_MODE_LCD    )
+#define FT_LOAD_TARGET_LCD_V   FT_LOAD_TARGET_( FT_RENDER_MODE_LCD_V  )
+
+
+  /**************************************************************************
+   *
+   * @macro:
+   *   FT_LOAD_TARGET_MODE
+   *
+   * @description:
+   *   Return the @FT_Render_Mode corresponding to a given
+   *   @FT_LOAD_TARGET_XXX value.
+   *
+   */
+#define FT_LOAD_TARGET_MODE( x )  ( (FT_Render_Mode)( ( (x) >> 16 ) & 15 ) )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Set_Transform                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Set the transformation that is applied to glyph images when they   */
+  /*    are loaded into a glyph slot through @FT_Load_Glyph.               */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face   :: A handle to the source face object.                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    matrix :: A pointer to the transformation's 2x2 matrix.  Use NULL  */
+  /*              for the identity matrix.                                 */
+  /*    delta  :: A pointer to the translation vector.  Use NULL for the   */
+  /*              null vector.                                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The transformation is only applied to scalable image formats after */
+  /*    the glyph has been loaded.  It means that hinting is unaltered by  */
+  /*    the transformation and is performed on the character size given in */
+  /*    the last call to @FT_Set_Char_Size or @FT_Set_Pixel_Sizes.         */
+  /*                                                                       */
+  /*    Note that this also transforms the `face.glyph.advance' field, but */
+  /*    *not* the values in `face.glyph.metrics'.                          */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Set_Transform( FT_Face     face,
+                    FT_Matrix*  matrix,
+                    FT_Vector*  delta );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    FT_Render_Mode                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Render modes supported by FreeType~2.  Each mode corresponds to a  */
+  /*    specific type of scanline conversion performed on the outline.     */
+  /*                                                                       */
+  /*    For bitmap fonts and embedded bitmaps the `bitmap->pixel_mode'     */
+  /*    field in the @FT_GlyphSlotRec structure gives the format of the    */
+  /*    returned bitmap.                                                   */
+  /*                                                                       */
+  /*    All modes except @FT_RENDER_MODE_MONO use 256 levels of opacity,   */
+  /*    indicating pixel coverage.  Use linear alpha blending and gamma    */
+  /*    correction to correctly render non-monochrome glyph bitmaps onto a */
+  /*    surface; see @FT_Render_Glyph.                                     */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    FT_RENDER_MODE_NORMAL ::                                           */
+  /*      Default render mode; it corresponds to 8-bit anti-aliased        */
+  /*      bitmaps.                                                         */
+  /*                                                                       */
+  /*    FT_RENDER_MODE_LIGHT ::                                            */
+  /*      This is equivalent to @FT_RENDER_MODE_NORMAL.  It is only        */
+  /*      defined as a separate value because render modes are also used   */
+  /*      indirectly to define hinting algorithm selectors.  See           */
+  /*      @FT_LOAD_TARGET_XXX for details.                                 */
+  /*                                                                       */
+  /*    FT_RENDER_MODE_MONO ::                                             */
+  /*      This mode corresponds to 1-bit bitmaps (with 2~levels of         */
+  /*      opacity).                                                        */
+  /*                                                                       */
+  /*    FT_RENDER_MODE_LCD ::                                              */
+  /*      This mode corresponds to horizontal RGB and BGR sub-pixel        */
+  /*      displays like LCD screens.  It produces 8-bit bitmaps that are   */
+  /*      3~times the width of the original glyph outline in pixels, and   */
+  /*      which use the @FT_PIXEL_MODE_LCD mode.                           */
+  /*                                                                       */
+  /*    FT_RENDER_MODE_LCD_V ::                                            */
+  /*      This mode corresponds to vertical RGB and BGR sub-pixel displays */
+  /*      (like PDA screens, rotated LCD displays, etc.).  It produces     */
+  /*      8-bit bitmaps that are 3~times the height of the original        */
+  /*      glyph outline in pixels and use the @FT_PIXEL_MODE_LCD_V mode.   */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Should you define FT_CONFIG_OPTION_SUBPIXEL_RENDERING in your      */
+  /*    `ftoption.h', which enables patented ClearType-style rendering,    */
+  /*    the LCD-optimized glyph bitmaps should be filtered to reduce color */
+  /*    fringes inherent to this technology.  You can either set up LCD    */
+  /*    filtering with @FT_Library_SetLcdFilter or @FT_Face_Properties,    */
+  /*    or do the filtering yourself.  The default FreeType LCD rendering  */
+  /*    technology does not require filtering.                             */
+  /*                                                                       */
+  /*    The selected render mode only affects vector glyphs of a font.     */
+  /*    Embedded bitmaps often have a different pixel mode like            */
+  /*    @FT_PIXEL_MODE_MONO.  You can use @FT_Bitmap_Convert to transform  */
+  /*    them into 8-bit pixmaps.                                           */
+  /*                                                                       */
+  typedef enum  FT_Render_Mode_
+  {
+    FT_RENDER_MODE_NORMAL = 0,
+    FT_RENDER_MODE_LIGHT,
+    FT_RENDER_MODE_MONO,
+    FT_RENDER_MODE_LCD,
+    FT_RENDER_MODE_LCD_V,
+
+    FT_RENDER_MODE_MAX
+
+  } FT_Render_Mode;
+
+
+  /* these constants are deprecated; use the corresponding */
+  /* `FT_Render_Mode' values instead                       */
+#define ft_render_mode_normal  FT_RENDER_MODE_NORMAL
+#define ft_render_mode_mono    FT_RENDER_MODE_MONO
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Render_Glyph                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Convert a given glyph image to a bitmap.  It does so by inspecting */
+  /*    the glyph image format, finding the relevant renderer, and         */
+  /*    invoking it.                                                       */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    slot        :: A handle to the glyph slot containing the image to  */
+  /*                   convert.                                            */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    render_mode :: The render mode used to render the glyph image into */
+  /*                   a bitmap.  See @FT_Render_Mode for a list of        */
+  /*                   possible values.                                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    To get meaningful results, font scaling values must be set with    */
+  /*    functions like @FT_Set_Char_Size before calling `FT_Render_Glyph'. */
+  /*                                                                       */
+  /*    When FreeType outputs a bitmap of a glyph, it really outputs an    */
+  /*    alpha coverage map.  If a pixel is completely covered by a         */
+  /*    filled-in outline, the bitmap contains 0xFF at that pixel, meaning */
+  /*    that 0xFF/0xFF fraction of that pixel is covered, meaning the      */
+  /*    pixel is 100% black (or 0% bright).  If a pixel is only 50%        */
+  /*    covered (value 0x80), the pixel is made 50% black (50% bright or a */
+  /*    middle shade of grey).  0% covered means 0% black (100% bright or  */
+  /*    white).                                                            */
+  /*                                                                       */
+  /*    On high-DPI screens like on smartphones and tablets, the pixels    */
+  /*    are so small that their chance of being completely covered and     */
+  /*    therefore completely black are fairly good.  On the low-DPI        */
+  /*    screens, however, the situation is different.  The pixels are too  */
+  /*    large for most of the details of a glyph and shades of gray are    */
+  /*    the norm rather than the exception.                                */
+  /*                                                                       */
+  /*    This is relevant because all our screens have a second problem:    */
+  /*    they are not linear.  1~+~1 is not~2.  Twice the value does not    */
+  /*    result in twice the brightness.  When a pixel is only 50% covered, */
+  /*    the coverage map says 50% black, and this translates to a pixel    */
+  /*    value of 128 when you use 8~bits per channel (0-255).  However,    */
+  /*    this does not translate to 50% brightness for that pixel on our    */
+  /*    sRGB and gamma~2.2 screens.  Due to their non-linearity, they      */
+  /*    dwell longer in the darks and only a pixel value of about 186      */
+  /*    results in 50% brightness -- 128 ends up too dark on both bright   */
+  /*    and dark backgrounds.  The net result is that dark text looks      */
+  /*    burnt-out, pixely and blotchy on bright background, bright text    */
+  /*    too frail on dark backgrounds, and colored text on colored         */
+  /*    background (for example, red on green) seems to have dark halos or */
+  /*    `dirt' around it.  The situation is especially ugly for diagonal   */
+  /*    stems like in `w' glyph shapes where the quality of FreeType's     */
+  /*    anti-aliasing depends on the correct display of grays.  On         */
+  /*    high-DPI screens where smaller, fully black pixels reign supreme,  */
+  /*    this doesn't matter, but on our low-DPI screens with all the gray  */
+  /*    shades, it does.  0% and 100% brightness are the same things in    */
+  /*    linear and non-linear space, just all the shades in-between        */
+  /*    aren't.                                                            */
+  /*                                                                       */
+  /*    The blending function for placing text over a background is        */
+  /*                                                                       */
+  /*    {                                                                  */
+  /*      dst = alpha * src + (1 - alpha) * dst    ,                       */
+  /*    }                                                                  */
+  /*                                                                       */
+  /*    which is known as the OVER operator.                               */
+  /*                                                                       */
+  /*    To correctly composite an antialiased pixel of a glyph onto a      */
+  /*    surface,                                                           */
+  /*                                                                       */
+  /*    1. take the foreground and background colors (e.g., in sRGB space) */
+  /*       and apply gamma to get them in a linear space,                  */
+  /*                                                                       */
+  /*    2. use OVER to blend the two linear colors using the glyph pixel   */
+  /*       as the alpha value (remember, the glyph bitmap is an alpha      */
+  /*       coverage bitmap), and                                           */
+  /*                                                                       */
+  /*    3. apply inverse gamma to the blended pixel and write it back to   */
+  /*       the image.                                                      */
+  /*                                                                       */
+  /*    Internal testing at Adobe found that a target inverse gamma of~1.8 */
+  /*    for step~3 gives good results across a wide range of displays with */
+  /*    an sRGB gamma curve or a similar one.                              */
+  /*                                                                       */
+  /*    This process can cost performance.  There is an approximation that */
+  /*    does not need to know about the background color; see              */
+  /*    https://bel.fi/alankila/lcd/ and                                   */
+  /*    https://bel.fi/alankila/lcd/alpcor.html for details.               */
+  /*                                                                       */
+  /*    *ATTENTION*: Linear blending is even more important when dealing   */
+  /*    with subpixel-rendered glyphs to prevent color-fringing!  A        */
+  /*    subpixel-rendered glyph must first be filtered with a filter that  */
+  /*    gives equal weight to the three color primaries and does not       */
+  /*    exceed a sum of 0x100, see section @lcd_filtering.  Then the       */
+  /*    only difference to gray linear blending is that subpixel-rendered  */
+  /*    linear blending is done 3~times per pixel: red foreground subpixel */
+  /*    to red background subpixel and so on for green and blue.           */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Render_Glyph( FT_GlyphSlot    slot,
+                   FT_Render_Mode  render_mode );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    FT_Kerning_Mode                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An enumeration to specify the format of kerning values returned by */
+  /*    @FT_Get_Kerning.                                                   */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    FT_KERNING_DEFAULT  :: Return grid-fitted kerning distances in     */
+  /*                           26.6 fractional pixels.                     */
+  /*                                                                       */
+  /*    FT_KERNING_UNFITTED :: Return un-grid-fitted kerning distances in  */
+  /*                           26.6 fractional pixels.                     */
+  /*                                                                       */
+  /*    FT_KERNING_UNSCALED :: Return the kerning vector in original font  */
+  /*                           units.                                      */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    FT_KERNING_DEFAULT returns full pixel values; it also makes        */
+  /*    FreeType heuristically scale down kerning distances at small ppem  */
+  /*    values so that they don't become too big.                          */
+  /*                                                                       */
+  /*    Both FT_KERNING_DEFAULT and FT_KERNING_UNFITTED use the current    */
+  /*    horizontal scaling factor (as set e.g. with @FT_Set_Char_Size) to  */
+  /*    convert font units to pixels.                                      */
+  /*                                                                       */
+  typedef enum  FT_Kerning_Mode_
+  {
+    FT_KERNING_DEFAULT = 0,
+    FT_KERNING_UNFITTED,
+    FT_KERNING_UNSCALED
+
+  } FT_Kerning_Mode;
+
+
+  /* these constants are deprecated; use the corresponding */
+  /* `FT_Kerning_Mode' values instead                      */
+#define ft_kerning_default   FT_KERNING_DEFAULT
+#define ft_kerning_unfitted  FT_KERNING_UNFITTED
+#define ft_kerning_unscaled  FT_KERNING_UNSCALED
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Kerning                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Return the kerning vector between two glyphs of the same face.     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face        :: A handle to a source face object.                   */
+  /*                                                                       */
+  /*    left_glyph  :: The index of the left glyph in the kern pair.       */
+  /*                                                                       */
+  /*    right_glyph :: The index of the right glyph in the kern pair.      */
+  /*                                                                       */
+  /*    kern_mode   :: See @FT_Kerning_Mode for more information.          */
+  /*                   Determines the scale and dimension of the returned  */
+  /*                   kerning vector.                                     */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    akerning    :: The kerning vector.  This is either in font units,  */
+  /*                   fractional pixels (26.6 format), or pixels for      */
+  /*                   scalable formats, and in pixels for fixed-sizes     */
+  /*                   formats.                                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Only horizontal layouts (left-to-right & right-to-left) are        */
+  /*    supported by this method.  Other layouts, or more sophisticated    */
+  /*    kernings, are out of the scope of this API function -- they can be */
+  /*    implemented through format-specific interfaces.                    */
+  /*                                                                       */
+  /*    Kerning for OpenType fonts implemented in a `GPOS' table is not    */
+  /*    supported; use @FT_HAS_KERNING to find out whether a font has data */
+  /*    that can be extracted with `FT_Get_Kerning'.                       */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Get_Kerning( FT_Face     face,
+                  FT_UInt     left_glyph,
+                  FT_UInt     right_glyph,
+                  FT_UInt     kern_mode,
+                  FT_Vector  *akerning );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Track_Kerning                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Return the track kerning for a given face object at a given size.  */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face       :: A handle to a source face object.                    */
+  /*                                                                       */
+  /*    point_size :: The point size in 16.16 fractional points.           */
+  /*                                                                       */
+  /*    degree     :: The degree of tightness.  Increasingly negative      */
+  /*                  values represent tighter track kerning, while        */
+  /*                  increasingly positive values represent looser track  */
+  /*                  kerning.  Value zero means no track kerning.         */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    akerning   :: The kerning in 16.16 fractional points, to be        */
+  /*                  uniformly applied between all glyphs.                */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Currently, only the Type~1 font driver supports track kerning,     */
+  /*    using data from AFM files (if attached with @FT_Attach_File or     */
+  /*    @FT_Attach_Stream).                                                */
+  /*                                                                       */
+  /*    Only very few AFM files come with track kerning data; please refer */
+  /*    to Adobe's AFM specification for more details.                     */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Get_Track_Kerning( FT_Face    face,
+                        FT_Fixed   point_size,
+                        FT_Int     degree,
+                        FT_Fixed*  akerning );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Glyph_Name                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Retrieve the ASCII name of a given glyph in a face.  This only     */
+  /*    works for those faces where @FT_HAS_GLYPH_NAMES(face) returns~1.   */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face        :: A handle to a source face object.                   */
+  /*                                                                       */
+  /*    glyph_index :: The glyph index.                                    */
+  /*                                                                       */
+  /*    buffer_max  :: The maximum number of bytes available in the        */
+  /*                   buffer.                                             */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    buffer      :: A pointer to a target buffer where the name is      */
+  /*                   copied to.                                          */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    An error is returned if the face doesn't provide glyph names or if */
+  /*    the glyph index is invalid.  In all cases of failure, the first    */
+  /*    byte of `buffer' is set to~0 to indicate an empty name.            */
+  /*                                                                       */
+  /*    The glyph name is truncated to fit within the buffer if it is too  */
+  /*    long.  The returned string is always zero-terminated.              */
+  /*                                                                       */
+  /*    Be aware that FreeType reorders glyph indices internally so that   */
+  /*    glyph index~0 always corresponds to the `missing glyph' (called    */
+  /*    `.notdef').                                                        */
+  /*                                                                       */
+  /*    This function always returns an error if the config macro          */
+  /*    `FT_CONFIG_OPTION_NO_GLYPH_NAMES' is not defined in `ftoption.h'.  */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Get_Glyph_Name( FT_Face     face,
+                     FT_UInt     glyph_index,
+                     FT_Pointer  buffer,
+                     FT_UInt     buffer_max );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Postscript_Name                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Retrieve the ASCII PostScript name of a given face, if available.  */
+  /*    This only works with PostScript, TrueType, and OpenType fonts.     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face :: A handle to the source face object.                        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    A pointer to the face's PostScript name.  NULL if unavailable.     */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The returned pointer is owned by the face and is destroyed with    */
+  /*    it.                                                                */
+  /*                                                                       */
+  /*    For variation fonts, this string changes if you select a different */
+  /*    instance, and you have to call `FT_Get_PostScript_Name' again to   */
+  /*    retrieve it.  FreeType follows Adobe TechNote #5902, `Generating   */
+  /*    PostScript Names for Fonts Using OpenType Font Variations'.        */
+  /*                                                                       */
+  /*      http://wwwimages.adobe.com/content/dam/Adobe/en/devnet/font/pdfs/5902.AdobePSNameGeneration.html */
+  /*                                                                       */
+  FT_EXPORT( const char* )
+  FT_Get_Postscript_Name( FT_Face  face );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Select_Charmap                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Select a given charmap by its encoding tag (as listed in           */
+  /*    `freetype.h').                                                     */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face     :: A handle to the source face object.                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    encoding :: A handle to the selected encoding.                     */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This function returns an error if no charmap in the face           */
+  /*    corresponds to the encoding queried here.                          */
+  /*                                                                       */
+  /*    Because many fonts contain more than a single cmap for Unicode     */
+  /*    encoding, this function has some special code to select the one    */
+  /*    that covers Unicode best (`best' in the sense that a UCS-4 cmap is */
+  /*    preferred to a UCS-2 cmap).  It is thus preferable to              */
+  /*    @FT_Set_Charmap in this case.                                      */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Select_Charmap( FT_Face      face,
+                     FT_Encoding  encoding );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Set_Charmap                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Select a given charmap for character code to glyph index mapping.  */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face    :: A handle to the source face object.                     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charmap :: A handle to the selected charmap.                       */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This function returns an error if the charmap is not part of       */
+  /*    the face (i.e., if it is not listed in the `face->charmaps'        */
+  /*    table).                                                            */
+  /*                                                                       */
+  /*    It also fails if an OpenType type~14 charmap is selected (which    */
+  /*    doesn't map character codes to glyph indices at all).              */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Set_Charmap( FT_Face     face,
+                  FT_CharMap  charmap );
+
+
+  /*************************************************************************
+   *
+   * @function:
+   *   FT_Get_Charmap_Index
+   *
+   * @description:
+   *   Retrieve index of a given charmap.
+   *
+   * @input:
+   *   charmap ::
+   *     A handle to a charmap.
+   *
+   * @return:
+   *   The index into the array of character maps within the face to which
+   *   `charmap' belongs.  If an error occurs, -1 is returned.
+   *
+   */
+  FT_EXPORT( FT_Int )
+  FT_Get_Charmap_Index( FT_CharMap  charmap );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Char_Index                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Return the glyph index of a given character code.  This function   */
+  /*    uses the currently selected charmap to do the mapping.             */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face     :: A handle to the source face object.                    */
+  /*                                                                       */
+  /*    charcode :: The character code.                                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The glyph index.  0~means `undefined character code'.              */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    If you use FreeType to manipulate the contents of font files       */
+  /*    directly, be aware that the glyph index returned by this function  */
+  /*    doesn't always correspond to the internal indices used within the  */
+  /*    file.  This is done to ensure that value~0 always corresponds to   */
+  /*    the `missing glyph'.  If the first glyph is not named `.notdef',   */
+  /*    then for Type~1 and Type~42 fonts, `.notdef' will be moved into    */
+  /*    the glyph ID~0 position, and whatever was there will be moved to   */
+  /*    the position `.notdef' had.  For Type~1 fonts, if there is no      */
+  /*    `.notdef' glyph at all, then one will be created at index~0 and    */
+  /*    whatever was there will be moved to the last index -- Type~42      */
+  /*    fonts are considered invalid under this condition.                 */
+  /*                                                                       */
+  FT_EXPORT( FT_UInt )
+  FT_Get_Char_Index( FT_Face   face,
+                     FT_ULong  charcode );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_First_Char                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Return the first character code in the current charmap of a given  */
+  /*    face, together with its corresponding glyph index.                 */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face    :: A handle to the source face object.                     */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    agindex :: Glyph index of first character code.  0~if charmap is   */
+  /*               empty.                                                  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The charmap's first character code.                                */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    You should use this function together with @FT_Get_Next_Char to    */
+  /*    parse all character codes available in a given charmap.  The code  */
+  /*    should look like this:                                             */
+  /*                                                                       */
+  /*    {                                                                  */
+  /*      FT_ULong  charcode;                                              */
+  /*      FT_UInt   gindex;                                                */
+  /*                                                                       */
+  /*                                                                       */
+  /*      charcode = FT_Get_First_Char( face, &gindex );                   */
+  /*      while ( gindex != 0 )                                            */
+  /*      {                                                                */
+  /*        ... do something with (charcode,gindex) pair ...               */
+  /*                                                                       */
+  /*        charcode = FT_Get_Next_Char( face, charcode, &gindex );        */
+  /*      }                                                                */
+  /*    }                                                                  */
+  /*                                                                       */
+  /*    Be aware that character codes can have values up to 0xFFFFFFFF;    */
+  /*    this might happen for non-Unicode or malformed cmaps.  However,    */
+  /*    even with regular Unicode encoding, so-called `last resort fonts'  */
+  /*    (using SFNT cmap format 13, see function @FT_Get_CMap_Format)      */
+  /*    normally have entries for all Unicode characters up to 0x1FFFFF,   */
+  /*    which can cause *a lot* of iterations.                             */
+  /*                                                                       */
+  /*    Note that `*agindex' is set to~0 if the charmap is empty.  The     */
+  /*    result itself can be~0 in two cases: if the charmap is empty or    */
+  /*    if the value~0 is the first valid character code.                  */
+  /*                                                                       */
+  FT_EXPORT( FT_ULong )
+  FT_Get_First_Char( FT_Face   face,
+                     FT_UInt  *agindex );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Next_Char                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Return the next character code in the current charmap of a given   */
+  /*    face following the value `char_code', as well as the corresponding */
+  /*    glyph index.                                                       */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face      :: A handle to the source face object.                   */
+  /*                                                                       */
+  /*    char_code :: The starting character code.                          */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    agindex   :: Glyph index of next character code.  0~if charmap     */
+  /*                 is empty.                                             */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The charmap's next character code.                                 */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    You should use this function with @FT_Get_First_Char to walk       */
+  /*    over all character codes available in a given charmap.  See the    */
+  /*    note for that function for a simple code example.                  */
+  /*                                                                       */
+  /*    Note that `*agindex' is set to~0 when there are no more codes in   */
+  /*    the charmap.                                                       */
+  /*                                                                       */
+  FT_EXPORT( FT_ULong )
+  FT_Get_Next_Char( FT_Face    face,
+                    FT_ULong   char_code,
+                    FT_UInt   *agindex );
+
+
+  /*************************************************************************
+   *
+   * @function:
+   *   FT_Face_Properties
+   *
+   * @description:
+   *   Set or override certain (library or module-wide) properties on a
+   *   face-by-face basis.  Useful for finer-grained control and avoiding
+   *   locks on shared structures (threads can modify their own faces as
+   *   they see fit).
+   *
+   *   Contrary to @FT_Property_Set, this function uses @FT_Parameter so
+   *   that you can pass multiple properties to the target face in one call.
+   *   Note that only a subset of the available properties can be
+   *   controlled.
+   *
+   *   * Stem darkening (@FT_PARAM_TAG_STEM_DARKENING, corresponding to the
+   *     property `no-stem-darkening' provided by the `autofit' and `cff'
+   *     modules; see @no-stem-darkening[autofit] and
+   *     @no-stem-darkening[cff]).
+   *
+   *   * LCD filter weights (@FT_PARAM_TAG_LCD_FILTER_WEIGHTS, corresponding
+   *     to function @FT_Library_SetLcdFilterWeights).
+   *
+   *   * Seed value for the CFF `random' operator
+   *     (@FT_PARAM_TAG_RANDOM_SEED, corresponding to the `random-seed'
+   *     property provided by the `cff' module; see @random-seed).
+   *
+   *   Pass NULL as `data' in @FT_Parameter for a given tag to reset the
+   *   option and use the library or module default again.
+   *
+   * @input:
+   *   face ::
+   *     A handle to the source face object.
+   *
+   *   num_properties ::
+   *     The number of properties that follow.
+   *
+   *   properties ::
+   *     A handle to an @FT_Parameter array with `num_properties' elements.
+   *
+   * @return:
+   *   FreeType error code.  0~means success.
+   *
+   * @note:
+   *   Here an example that sets three properties.  You must define
+   *   FT_CONFIG_OPTION_SUBPIXEL_RENDERING to make the LCD filter examples
+   *   work.
+   *
+   *   {
+   *     FT_Parameter         property1;
+   *     FT_Bool              darken_stems = 1;
+   *
+   *     FT_Parameter         property2;
+   *     FT_LcdFiveTapFilter  custom_weight =
+   *                            { 0x11, 0x44, 0x56, 0x44, 0x11 };
+   *
+   *     FT_Parameter         property3;
+   *     FT_Int32             random_seed = 314159265;
+   *
+   *     FT_Parameter         properties[3] = { property1,
+   *                                            property2,
+   *                                            property3 };
+   *
+   *
+   *     property1.tag  = FT_PARAM_TAG_STEM_DARKENING;
+   *     property1.data = &darken_stems;
+   *
+   *     property2.tag  = FT_PARAM_TAG_LCD_FILTER_WEIGHTS;
+   *     property2.data = custom_weight;
+   *
+   *     property3.tag  = FT_PARAM_TAG_RANDOM_SEED;
+   *     property3.data = &random_seed;
+   *
+   *     FT_Face_Properties( face, 3, properties );
+   *   }
+   *
+   *   The next example resets a single property to its default value.
+   *
+   *   {
+   *     FT_Parameter  property;
+   *
+   *
+   *     property.tag  = FT_PARAM_TAG_LCD_FILTER_WEIGHTS;
+   *     property.data = NULL;
+   *
+   *     FT_Face_Properties( face, 1, &property );
+   *   }
+   *
+   */
+  FT_EXPORT( FT_Error )
+  FT_Face_Properties( FT_Face        face,
+                      FT_UInt        num_properties,
+                      FT_Parameter*  properties );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Name_Index                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Return the glyph index of a given glyph name.                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face       :: A handle to the source face object.                  */
+  /*                                                                       */
+  /*    glyph_name :: The glyph name.                                      */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The glyph index.  0~means `undefined character code'.              */
+  /*                                                                       */
+  FT_EXPORT( FT_UInt )
+  FT_Get_Name_Index( FT_Face     face,
+                     FT_String*  glyph_name );
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_SUBGLYPH_FLAG_XXX
+   *
+   * @description:
+   *   A list of constants describing subglyphs.  Please refer to the
+   *   `glyf' table description in the OpenType specification for the
+   *   meaning of the various flags (which get synthesized for
+   *   non-OpenType subglyphs).
+   *
+   * @values:
+   *   FT_SUBGLYPH_FLAG_ARGS_ARE_WORDS ::
+   *   FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES ::
+   *   FT_SUBGLYPH_FLAG_ROUND_XY_TO_GRID ::
+   *   FT_SUBGLYPH_FLAG_SCALE ::
+   *   FT_SUBGLYPH_FLAG_XY_SCALE ::
+   *   FT_SUBGLYPH_FLAG_2X2 ::
+   *   FT_SUBGLYPH_FLAG_USE_MY_METRICS ::
+   *
+   */
+#define FT_SUBGLYPH_FLAG_ARGS_ARE_WORDS          1
+#define FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES      2
+#define FT_SUBGLYPH_FLAG_ROUND_XY_TO_GRID        4
+#define FT_SUBGLYPH_FLAG_SCALE                   8
+#define FT_SUBGLYPH_FLAG_XY_SCALE             0x40
+#define FT_SUBGLYPH_FLAG_2X2                  0x80
+#define FT_SUBGLYPH_FLAG_USE_MY_METRICS      0x200
+
+
+  /*************************************************************************
+   *
+   * @func:
+   *   FT_Get_SubGlyph_Info
+   *
+   * @description:
+   *   Retrieve a description of a given subglyph.  Only use it if
+   *   `glyph->format' is @FT_GLYPH_FORMAT_COMPOSITE; an error is
+   *   returned otherwise.
+   *
+   * @input:
+   *   glyph ::
+   *     The source glyph slot.
+   *
+   *   sub_index ::
+   *     The index of the subglyph.  Must be less than
+   *     `glyph->num_subglyphs'.
+   *
+   * @output:
+   *   p_index ::
+   *     The glyph index of the subglyph.
+   *
+   *   p_flags ::
+   *     The subglyph flags, see @FT_SUBGLYPH_FLAG_XXX.
+   *
+   *   p_arg1 ::
+   *     The subglyph's first argument (if any).
+   *
+   *   p_arg2 ::
+   *     The subglyph's second argument (if any).
+   *
+   *   p_transform ::
+   *     The subglyph transformation (if any).
+   *
+   * @return:
+   *   FreeType error code.  0~means success.
+   *
+   * @note:
+   *   The values of `*p_arg1', `*p_arg2', and `*p_transform' must be
+   *   interpreted depending on the flags returned in `*p_flags'.  See the
+   *   OpenType specification for details.
+   *
+   */
+  FT_EXPORT( FT_Error )
+  FT_Get_SubGlyph_Info( FT_GlyphSlot  glyph,
+                        FT_UInt       sub_index,
+                        FT_Int       *p_index,
+                        FT_UInt      *p_flags,
+                        FT_Int       *p_arg1,
+                        FT_Int       *p_arg2,
+                        FT_Matrix    *p_transform );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    FT_FSTYPE_XXX                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A list of bit flags used in the `fsType' field of the OS/2 table   */
+  /*    in a TrueType or OpenType font and the `FSType' entry in a         */
+  /*    PostScript font.  These bit flags are returned by                  */
+  /*    @FT_Get_FSType_Flags; they inform client applications of embedding */
+  /*    and subsetting restrictions associated with a font.                */
+  /*                                                                       */
+  /*    See                                                                */
+  /*    http://www.adobe.com/content/dam/Adobe/en/devnet/acrobat/pdfs/FontPolicies.pdf */
+  /*    for more details.                                                  */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    FT_FSTYPE_INSTALLABLE_EMBEDDING ::                                 */
+  /*      Fonts with no fsType bit set may be embedded and permanently     */
+  /*      installed on the remote system by an application.                */
+  /*                                                                       */
+  /*    FT_FSTYPE_RESTRICTED_LICENSE_EMBEDDING ::                          */
+  /*      Fonts that have only this bit set must not be modified, embedded */
+  /*      or exchanged in any manner without first obtaining permission of */
+  /*      the font software copyright owner.                               */
+  /*                                                                       */
+  /*    FT_FSTYPE_PREVIEW_AND_PRINT_EMBEDDING ::                           */
+  /*      The font may be embedded and temporarily loaded on the remote    */
+  /*      system.  Documents containing Preview & Print fonts must be      */
+  /*      opened `read-only'; no edits can be applied to the document.     */
+  /*                                                                       */
+  /*    FT_FSTYPE_EDITABLE_EMBEDDING ::                                    */
+  /*      The font may be embedded but must only be installed temporarily  */
+  /*      on other systems.  In contrast to Preview & Print fonts,         */
+  /*      documents containing editable fonts may be opened for reading,   */
+  /*      editing is permitted, and changes may be saved.                  */
+  /*                                                                       */
+  /*    FT_FSTYPE_NO_SUBSETTING ::                                         */
+  /*      The font may not be subsetted prior to embedding.                */
+  /*                                                                       */
+  /*    FT_FSTYPE_BITMAP_EMBEDDING_ONLY ::                                 */
+  /*      Only bitmaps contained in the font may be embedded; no outline   */
+  /*      data may be embedded.  If there are no bitmaps available in the  */
+  /*      font, then the font is unembeddable.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The flags are ORed together, thus more than a single value can be  */
+  /*    returned.                                                          */
+  /*                                                                       */
+  /*    While the `fsType' flags can indicate that a font may be embedded, */
+  /*    a license with the font vendor may be separately required to use   */
+  /*    the font in this way.                                              */
+  /*                                                                       */
+#define FT_FSTYPE_INSTALLABLE_EMBEDDING         0x0000
+#define FT_FSTYPE_RESTRICTED_LICENSE_EMBEDDING  0x0002
+#define FT_FSTYPE_PREVIEW_AND_PRINT_EMBEDDING   0x0004
+#define FT_FSTYPE_EDITABLE_EMBEDDING            0x0008
+#define FT_FSTYPE_NO_SUBSETTING                 0x0100
+#define FT_FSTYPE_BITMAP_EMBEDDING_ONLY         0x0200
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_FSType_Flags                                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Return the `fsType' flags for a font.                              */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face :: A handle to the source face object.                        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The `fsType' flags, see @FT_FSTYPE_XXX.                            */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Use this function rather than directly reading the `fs_type' field */
+  /*    in the @PS_FontInfoRec structure, which is only guaranteed to      */
+  /*    return the correct results for Type~1 fonts.                       */
+  /*                                                                       */
+  /* <Since>                                                               */
+  /*    2.3.8                                                              */
+  /*                                                                       */
+  FT_EXPORT( FT_UShort )
+  FT_Get_FSType_Flags( FT_Face  face );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    glyph_variants                                                     */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    Unicode Variation Sequences                                        */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    The FreeType~2 interface to Unicode Variation Sequences (UVS),     */
+  /*    using the SFNT cmap format~14.                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Many characters, especially for CJK scripts, have variant forms.   */
+  /*    They are a sort of grey area somewhere between being totally       */
+  /*    irrelevant and semantically distinct; for this reason, the Unicode */
+  /*    consortium decided to introduce Variation Sequences (VS),          */
+  /*    consisting of a Unicode base character and a variation selector    */
+  /*    instead of further extending the already huge number of            */
+  /*    characters.                                                        */
+  /*                                                                       */
+  /*    Unicode maintains two different sets, namely `Standardized         */
+  /*    Variation Sequences' and registered `Ideographic Variation         */
+  /*    Sequences' (IVS), collected in the `Ideographic Variation          */
+  /*    Database' (IVD).                                                   */
+  /*                                                                       */
+  /*      http://unicode.org/Public/UCD/latest/ucd/StandardizedVariants.txt */
+  /*      http://unicode.org/reports/tr37/                                 */
+  /*      http://unicode.org/ivd/                                          */
+  /*                                                                       */
+  /*    To date (January 2017), the character with the most ideographic    */
+  /*    variations is U+9089, having 32 such IVS.                          */
+  /*                                                                       */
+  /*    Three Mongolian Variation Selectors have the values U+180B-U+180D; */
+  /*    256 generic Variation Selectors are encoded in the ranges          */
+  /*    U+FE00-U+FE0F and U+E0100-U+E01EF.  IVS currently use Variation    */
+  /*    Selectors from the range U+E0100-U+E01EF only.                     */
+  /*                                                                       */
+  /*    A VS consists of the base character value followed by a single     */
+  /*    Variation Selector.  For example, to get the first variation of    */
+  /*    U+9089, you have to write the character sequence `U+9089 U+E0100'. */
+  /*                                                                       */
+  /*    Adobe and MS decided to support both standardized and ideographic  */
+  /*    VS with a new cmap subtable (format~14).  It is an odd subtable    */
+  /*    because it is not a mapping of input code points to glyphs, but    */
+  /*    contains lists of all variations supported by the font.            */
+  /*                                                                       */
+  /*    A variation may be either `default' or `non-default' for a given   */
+  /*    font.  A default variation is the one you will get for that code   */
+  /*    point if you look it up in the standard Unicode cmap.  A           */
+  /*    non-default variation is a different glyph.                        */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Face_GetCharVariantIndex                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Return the glyph index of a given character code as modified by    */
+  /*    the variation selector.                                            */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face ::                                                            */
+  /*      A handle to the source face object.                              */
+  /*                                                                       */
+  /*    charcode ::                                                        */
+  /*      The character code point in Unicode.                             */
+  /*                                                                       */
+  /*    variantSelector ::                                                 */
+  /*      The Unicode code point of the variation selector.                */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The glyph index.  0~means either `undefined character code', or    */
+  /*    `undefined selector code', or `no variation selector cmap          */
+  /*    subtable', or `current CharMap is not Unicode'.                    */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    If you use FreeType to manipulate the contents of font files       */
+  /*    directly, be aware that the glyph index returned by this function  */
+  /*    doesn't always correspond to the internal indices used within      */
+  /*    the file.  This is done to ensure that value~0 always corresponds  */
+  /*    to the `missing glyph'.                                            */
+  /*                                                                       */
+  /*    This function is only meaningful if                                */
+  /*      a) the font has a variation selector cmap sub table,             */
+  /*    and                                                                */
+  /*      b) the current charmap has a Unicode encoding.                   */
+  /*                                                                       */
+  /* <Since>                                                               */
+  /*    2.3.6                                                              */
+  /*                                                                       */
+  FT_EXPORT( FT_UInt )
+  FT_Face_GetCharVariantIndex( FT_Face   face,
+                               FT_ULong  charcode,
+                               FT_ULong  variantSelector );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Face_GetCharVariantIsDefault                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Check whether this variation of this Unicode character is the one  */
+  /*    to be found in the `cmap'.                                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face ::                                                            */
+  /*      A handle to the source face object.                              */
+  /*                                                                       */
+  /*    charcode ::                                                        */
+  /*      The character codepoint in Unicode.                              */
+  /*                                                                       */
+  /*    variantSelector ::                                                 */
+  /*      The Unicode codepoint of the variation selector.                 */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    1~if found in the standard (Unicode) cmap, 0~if found in the       */
+  /*    variation selector cmap, or -1 if it is not a variation.           */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This function is only meaningful if the font has a variation       */
+  /*    selector cmap subtable.                                            */
+  /*                                                                       */
+  /* <Since>                                                               */
+  /*    2.3.6                                                              */
+  /*                                                                       */
+  FT_EXPORT( FT_Int )
+  FT_Face_GetCharVariantIsDefault( FT_Face   face,
+                                   FT_ULong  charcode,
+                                   FT_ULong  variantSelector );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Face_GetVariantSelectors                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Return a zero-terminated list of Unicode variation selectors found */
+  /*    in the font.                                                       */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face ::                                                            */
+  /*      A handle to the source face object.                              */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    A pointer to an array of selector code points, or NULL if there is */
+  /*    no valid variation selector cmap subtable.                         */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The last item in the array is~0; the array is owned by the         */
+  /*    @FT_Face object but can be overwritten or released on the next     */
+  /*    call to a FreeType function.                                       */
+  /*                                                                       */
+  /* <Since>                                                               */
+  /*    2.3.6                                                              */
+  /*                                                                       */
+  FT_EXPORT( FT_UInt32* )
+  FT_Face_GetVariantSelectors( FT_Face  face );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Face_GetVariantsOfChar                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Return a zero-terminated list of Unicode variation selectors found */
+  /*    for the specified character code.                                  */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face ::                                                            */
+  /*      A handle to the source face object.                              */
+  /*                                                                       */
+  /*    charcode ::                                                        */
+  /*      The character codepoint in Unicode.                              */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    A pointer to an array of variation selector code points that are   */
+  /*    active for the given character, or NULL if the corresponding list  */
+  /*    is empty.                                                          */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The last item in the array is~0; the array is owned by the         */
+  /*    @FT_Face object but can be overwritten or released on the next     */
+  /*    call to a FreeType function.                                       */
+  /*                                                                       */
+  /* <Since>                                                               */
+  /*    2.3.6                                                              */
+  /*                                                                       */
+  FT_EXPORT( FT_UInt32* )
+  FT_Face_GetVariantsOfChar( FT_Face   face,
+                             FT_ULong  charcode );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Face_GetCharsOfVariant                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Return a zero-terminated list of Unicode character codes found for */
+  /*    the specified variation selector.                                  */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face ::                                                            */
+  /*      A handle to the source face object.                              */
+  /*                                                                       */
+  /*    variantSelector ::                                                 */
+  /*      The variation selector code point in Unicode.                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    A list of all the code points that are specified by this selector  */
+  /*    (both default and non-default codes are returned) or NULL if there */
+  /*    is no valid cmap or the variation selector is invalid.             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The last item in the array is~0; the array is owned by the         */
+  /*    @FT_Face object but can be overwritten or released on the next     */
+  /*    call to a FreeType function.                                       */
+  /*                                                                       */
+  /* <Since>                                                               */
+  /*    2.3.6                                                              */
+  /*                                                                       */
+  FT_EXPORT( FT_UInt32* )
+  FT_Face_GetCharsOfVariant( FT_Face   face,
+                             FT_ULong  variantSelector );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    computations                                                       */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    Computations                                                       */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    Crunching fixed numbers and vectors.                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains various functions used to perform            */
+  /*    computations on 16.16 fixed-float numbers or 2d vectors.           */
+  /*                                                                       */
+  /* <Order>                                                               */
+  /*    FT_MulDiv                                                          */
+  /*    FT_MulFix                                                          */
+  /*    FT_DivFix                                                          */
+  /*    FT_RoundFix                                                        */
+  /*    FT_CeilFix                                                         */
+  /*    FT_FloorFix                                                        */
+  /*    FT_Vector_Transform                                                */
+  /*    FT_Matrix_Multiply                                                 */
+  /*    FT_Matrix_Invert                                                   */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_MulDiv                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Compute `(a*b)/c' with maximum accuracy, using a 64-bit            */
+  /*    intermediate integer whenever necessary.                           */
+  /*                                                                       */
+  /*    This function isn't necessarily as fast as some processor specific */
+  /*    operations, but is at least completely portable.                   */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    a :: The first multiplier.                                         */
+  /*                                                                       */
+  /*    b :: The second multiplier.                                        */
+  /*                                                                       */
+  /*    c :: The divisor.                                                  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The result of `(a*b)/c'.  This function never traps when trying to */
+  /*    divide by zero; it simply returns `MaxInt' or `MinInt' depending   */
+  /*    on the signs of `a' and `b'.                                       */
+  /*                                                                       */
+  FT_EXPORT( FT_Long )
+  FT_MulDiv( FT_Long  a,
+             FT_Long  b,
+             FT_Long  c );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_MulFix                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Compute `(a*b)/0x10000' with maximum accuracy.  Its main use is to */
+  /*    multiply a given value by a 16.16 fixed-point factor.              */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    a :: The first multiplier.                                         */
+  /*                                                                       */
+  /*    b :: The second multiplier.  Use a 16.16 factor here whenever      */
+  /*         possible (see note below).                                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The result of `(a*b)/0x10000'.                                     */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This function has been optimized for the case where the absolute   */
+  /*    value of `a' is less than 2048, and `b' is a 16.16 scaling factor. */
+  /*    As this happens mainly when scaling from notional units to         */
+  /*    fractional pixels in FreeType, it resulted in noticeable speed     */
+  /*    improvements between versions 2.x and 1.x.                         */
+  /*                                                                       */
+  /*    As a conclusion, always try to place a 16.16 factor as the         */
+  /*    _second_ argument of this function; this can make a great          */
+  /*    difference.                                                        */
+  /*                                                                       */
+  FT_EXPORT( FT_Long )
+  FT_MulFix( FT_Long  a,
+             FT_Long  b );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_DivFix                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Compute `(a*0x10000)/b' with maximum accuracy.  Its main use is to */
+  /*    divide a given value by a 16.16 fixed-point factor.                */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    a :: The numerator.                                                */
+  /*                                                                       */
+  /*    b :: The denominator.  Use a 16.16 factor here.                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The result of `(a*0x10000)/b'.                                     */
+  /*                                                                       */
+  FT_EXPORT( FT_Long )
+  FT_DivFix( FT_Long  a,
+             FT_Long  b );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_RoundFix                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Round a 16.16 fixed number.                                        */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    a :: The number to be rounded.                                     */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    `a' rounded to the nearest 16.16 fixed integer, halfway cases away */
+  /*    from zero.                                                         */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The function uses wrap-around arithmetic.                          */
+  /*                                                                       */
+  FT_EXPORT( FT_Fixed )
+  FT_RoundFix( FT_Fixed  a );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_CeilFix                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Compute the smallest following integer of a 16.16 fixed number.    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    a :: The number for which the ceiling function is to be computed.  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    `a' rounded towards plus infinity.                                 */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The function uses wrap-around arithmetic.                          */
+  /*                                                                       */
+  FT_EXPORT( FT_Fixed )
+  FT_CeilFix( FT_Fixed  a );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_FloorFix                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Compute the largest previous integer of a 16.16 fixed number.      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    a :: The number for which the floor function is to be computed.    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    `a' rounded towards minus infinity.                                */
+  /*                                                                       */
+  FT_EXPORT( FT_Fixed )
+  FT_FloorFix( FT_Fixed  a );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Vector_Transform                                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Transform a single vector through a 2x2 matrix.                    */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    vector :: The target vector to transform.                          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    matrix :: A pointer to the source 2x2 matrix.                      */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The result is undefined if either `vector' or `matrix' is invalid. */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Vector_Transform( FT_Vector*        vec,
+                       const FT_Matrix*  matrix );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    version                                                            */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    FreeType Version                                                   */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    Functions and macros related to FreeType versions.                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Note that those functions and macros are of limited use because    */
+  /*    even a new release of FreeType with only documentation changes     */
+  /*    increases the version number.                                      */
+  /*                                                                       */
+  /* <Order>                                                               */
+  /*    FT_Library_Version                                                 */
+  /*                                                                       */
+  /*    FREETYPE_MAJOR                                                     */
+  /*    FREETYPE_MINOR                                                     */
+  /*    FREETYPE_PATCH                                                     */
+  /*                                                                       */
+  /*    FT_Face_CheckTrueTypePatents                                       */
+  /*    FT_Face_SetUnpatentedHinting                                       */
+  /*                                                                       */
+  /*    FREETYPE_XXX                                                       */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************
+   *
+   * @enum:
+   *   FREETYPE_XXX
+   *
+   * @description:
+   *   These three macros identify the FreeType source code version.
+   *   Use @FT_Library_Version to access them at runtime.
+   *
+   * @values:
+   *   FREETYPE_MAJOR :: The major version number.
+   *   FREETYPE_MINOR :: The minor version number.
+   *   FREETYPE_PATCH :: The patch level.
+   *
+   * @note:
+   *   The version number of FreeType if built as a dynamic link library
+   *   with the `libtool' package is _not_ controlled by these three
+   *   macros.
+   *
+   */
+#define FREETYPE_MAJOR  2
+#define FREETYPE_MINOR  8
+#define FREETYPE_PATCH  1
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Library_Version                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Return the version of the FreeType library being used.  This is    */
+  /*    useful when dynamically linking to the library, since one cannot   */
+  /*    use the macros @FREETYPE_MAJOR, @FREETYPE_MINOR, and               */
+  /*    @FREETYPE_PATCH.                                                   */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    library :: A source library handle.                                */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    amajor  :: The major version number.                               */
+  /*                                                                       */
+  /*    aminor  :: The minor version number.                               */
+  /*                                                                       */
+  /*    apatch  :: The patch version number.                               */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The reason why this function takes a `library' argument is because */
+  /*    certain programs implement library initialization in a custom way  */
+  /*    that doesn't use @FT_Init_FreeType.                                */
+  /*                                                                       */
+  /*    In such cases, the library version might not be available before   */
+  /*    the library object has been created.                               */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Library_Version( FT_Library   library,
+                      FT_Int      *amajor,
+                      FT_Int      *aminor,
+                      FT_Int      *apatch );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Face_CheckTrueTypePatents                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Deprecated, does nothing.                                          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face :: A face handle.                                             */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Always returns false.                                              */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Since May 2010, TrueType hinting is no longer patented.            */
+  /*                                                                       */
+  /* <Since>                                                               */
+  /*    2.3.5                                                              */
+  /*                                                                       */
+  FT_EXPORT( FT_Bool )
+  FT_Face_CheckTrueTypePatents( FT_Face  face );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Face_SetUnpatentedHinting                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Deprecated, does nothing.                                          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face  :: A face handle.                                            */
+  /*                                                                       */
+  /*    value :: New boolean setting.                                      */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Always returns false.                                              */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Since May 2010, TrueType hinting is no longer patented.            */
+  /*                                                                       */
+  /* <Since>                                                               */
+  /*    2.3.5                                                              */
+  /*                                                                       */
+  FT_EXPORT( FT_Bool )
+  FT_Face_SetUnpatentedHinting( FT_Face  face,
+                                FT_Bool  value );
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* FREETYPE_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ftadvanc.h b/engine/inc/freetype/ftadvanc.h
new file mode 100644
index 00000000..dea96e0d
--- /dev/null
+++ b/engine/inc/freetype/ftadvanc.h
@@ -0,0 +1,187 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftadvanc.h                                                             */
+/*                                                                         */
+/*    Quick computation of advance widths (specification only).            */
+/*                                                                         */
+/*  Copyright 2008-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTADVANC_H_
+#define FTADVANC_H_
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+
+  /**************************************************************************
+   *
+   * @section:
+   *   quick_advance
+   *
+   * @title:
+   *   Quick retrieval of advance values
+   *
+   * @abstract:
+   *   Retrieve horizontal and vertical advance values without processing
+   *   glyph outlines, if possible.
+   *
+   * @description:
+   *   This section contains functions to quickly extract advance values
+   *   without handling glyph outlines, if possible.
+   *
+   * @order:
+   *   FT_Get_Advance
+   *   FT_Get_Advances
+   *
+   */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Const>                                                               */
+  /*    FT_ADVANCE_FLAG_FAST_ONLY                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A bit-flag to be OR-ed with the `flags' parameter of the           */
+  /*    @FT_Get_Advance and @FT_Get_Advances functions.                    */
+  /*                                                                       */
+  /*    If set, it indicates that you want these functions to fail if the  */
+  /*    corresponding hinting mode or font driver doesn't allow for very   */
+  /*    quick advance computation.                                         */
+  /*                                                                       */
+  /*    Typically, glyphs that are either unscaled, unhinted, bitmapped,   */
+  /*    or light-hinted can have their advance width computed very         */
+  /*    quickly.                                                           */
+  /*                                                                       */
+  /*    Normal and bytecode hinted modes that require loading, scaling,    */
+  /*    and hinting of the glyph outline, are extremely slow by            */
+  /*    comparison.                                                        */
+  /*                                                                       */
+#define FT_ADVANCE_FLAG_FAST_ONLY  0x20000000L
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Advance                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Retrieve the advance value of a given glyph outline in an          */
+  /*    @FT_Face.                                                          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face       :: The source @FT_Face handle.                          */
+  /*                                                                       */
+  /*    gindex     :: The glyph index.                                     */
+  /*                                                                       */
+  /*    load_flags :: A set of bit flags similar to those used when        */
+  /*                  calling @FT_Load_Glyph, used to determine what kind  */
+  /*                  of advances you need.                                */
+  /* <Output>                                                              */
+  /*    padvance :: The advance value.  If scaling is performed (based on  */
+  /*                the value of `load_flags'), the advance value is in    */
+  /*                16.16 format.  Otherwise, it is in font units.         */
+  /*                                                                       */
+  /*                If @FT_LOAD_VERTICAL_LAYOUT is set, this is the        */
+  /*                vertical advance corresponding to a vertical layout.   */
+  /*                Otherwise, it is the horizontal advance in a           */
+  /*                horizontal layout.                                     */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This function may fail if you use @FT_ADVANCE_FLAG_FAST_ONLY and   */
+  /*    if the corresponding font backend doesn't have a quick way to      */
+  /*    retrieve the advances.                                             */
+  /*                                                                       */
+  /*    A scaled advance is returned in 16.16 format but isn't transformed */
+  /*    by the affine transformation specified by @FT_Set_Transform.       */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Get_Advance( FT_Face    face,
+                  FT_UInt    gindex,
+                  FT_Int32   load_flags,
+                  FT_Fixed  *padvance );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Advances                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Retrieve the advance values of several glyph outlines in an        */
+  /*    @FT_Face.                                                          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face        :: The source @FT_Face handle.                         */
+  /*                                                                       */
+  /*    start       :: The first glyph index.                              */
+  /*                                                                       */
+  /*    count       :: The number of advance values you want to retrieve.  */
+  /*                                                                       */
+  /*    load_flags  :: A set of bit flags similar to those used when       */
+  /*                   calling @FT_Load_Glyph.                             */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    padvance :: The advance values.  This array, to be provided by the */
+  /*                caller, must contain at least `count' elements.        */
+  /*                                                                       */
+  /*                If scaling is performed (based on the value of         */
+  /*                `load_flags'), the advance values are in 16.16 format. */
+  /*                Otherwise, they are in font units.                     */
+  /*                                                                       */
+  /*                If @FT_LOAD_VERTICAL_LAYOUT is set, these are the      */
+  /*                vertical advances corresponding to a vertical layout.  */
+  /*                Otherwise, they are the horizontal advances in a       */
+  /*                horizontal layout.                                     */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This function may fail if you use @FT_ADVANCE_FLAG_FAST_ONLY and   */
+  /*    if the corresponding font backend doesn't have a quick way to      */
+  /*    retrieve the advances.                                             */
+  /*                                                                       */
+  /*    Scaled advances are returned in 16.16 format but aren't            */
+  /*    transformed by the affine transformation specified by              */
+  /*    @FT_Set_Transform.                                                 */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Get_Advances( FT_Face    face,
+                   FT_UInt    start,
+                   FT_UInt    count,
+                   FT_Int32   load_flags,
+                   FT_Fixed  *padvances );
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* FTADVANC_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ftautoh.h b/engine/inc/freetype/ftautoh.h
new file mode 100644
index 00000000..2bb675ae
--- /dev/null
+++ b/engine/inc/freetype/ftautoh.h
@@ -0,0 +1,533 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftautoh.h                                                              */
+/*                                                                         */
+/*    FreeType API for controlling the auto-hinter (specification only).   */
+/*                                                                         */
+/*  Copyright 2012-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTAUTOH_H_
+#define FTAUTOH_H_
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+
+  /**************************************************************************
+   *
+   * @section:
+   *   auto_hinter
+   *
+   * @title:
+   *   The auto-hinter
+   *
+   * @abstract:
+   *   Controlling the auto-hinting module.
+   *
+   * @description:
+   *   While FreeType's auto-hinter doesn't expose API functions by itself,
+   *   it is possible to control its behaviour with @FT_Property_Set and
+   *   @FT_Property_Get.  The following lists the available properties
+   *   together with the necessary macros and structures.
+   *
+   *   Note that the auto-hinter's module name is `autofitter' for
+   *   historical reasons.
+   *
+   */
+
+
+  /**************************************************************************
+   *
+   * @property:
+   *   glyph-to-script-map
+   *
+   * @description:
+   *   *Experimental* *only*
+   *
+   *   The auto-hinter provides various script modules to hint glyphs.
+   *   Examples of supported scripts are Latin or CJK.  Before a glyph is
+   *   auto-hinted, the Unicode character map of the font gets examined, and
+   *   the script is then determined based on Unicode character ranges, see
+   *   below.
+   *
+   *   OpenType fonts, however, often provide much more glyphs than
+   *   character codes (small caps, superscripts, ligatures, swashes, etc.),
+   *   to be controlled by so-called `features'.  Handling OpenType features
+   *   can be quite complicated and thus needs a separate library on top of
+   *   FreeType.
+   *
+   *   The mapping between glyph indices and scripts (in the auto-hinter
+   *   sense, see the @FT_AUTOHINTER_SCRIPT_XXX values) is stored as an
+   *   array with `num_glyphs' elements, as found in the font's @FT_Face
+   *   structure.  The `glyph-to-script-map' property returns a pointer to
+   *   this array, which can be modified as needed.  Note that the
+   *   modification should happen before the first glyph gets processed by
+   *   the auto-hinter so that the global analysis of the font shapes
+   *   actually uses the modified mapping.
+   *
+   *   The following example code demonstrates how to access it (omitting
+   *   the error handling).
+   *
+   *   {
+   *     FT_Library                library;
+   *     FT_Face                   face;
+   *     FT_Prop_GlyphToScriptMap  prop;
+   *
+   *
+   *     FT_Init_FreeType( &library );
+   *     FT_New_Face( library, "foo.ttf", 0, &face );
+   *
+   *     prop.face = face;
+   *
+   *     FT_Property_Get( library, "autofitter",
+   *                               "glyph-to-script-map", &prop );
+   *
+   *     // adjust `prop.map' as needed right here
+   *
+   *     FT_Load_Glyph( face, ..., FT_LOAD_FORCE_AUTOHINT );
+   *   }
+   *
+   */
+
+
+  /**************************************************************************
+   *
+   * @enum:
+   *   FT_AUTOHINTER_SCRIPT_XXX
+   *
+   * @description:
+   *   *Experimental* *only*
+   *
+   *   A list of constants used for the @glyph-to-script-map property to
+   *   specify the script submodule the auto-hinter should use for hinting a
+   *   particular glyph.
+   *
+   * @values:
+   *   FT_AUTOHINTER_SCRIPT_NONE ::
+   *     Don't auto-hint this glyph.
+   *
+   *   FT_AUTOHINTER_SCRIPT_LATIN ::
+   *     Apply the latin auto-hinter.  For the auto-hinter, `latin' is a
+   *     very broad term, including Cyrillic and Greek also since characters
+   *     from those scripts share the same design constraints.
+   *
+   *     By default, characters from the following Unicode ranges are
+   *     assigned to this submodule.
+   *
+   *     {
+   *       U+0020 - U+007F  // Basic Latin (no control characters)
+   *       U+00A0 - U+00FF  // Latin-1 Supplement (no control characters)
+   *       U+0100 - U+017F  // Latin Extended-A
+   *       U+0180 - U+024F  // Latin Extended-B
+   *       U+0250 - U+02AF  // IPA Extensions
+   *       U+02B0 - U+02FF  // Spacing Modifier Letters
+   *       U+0300 - U+036F  // Combining Diacritical Marks
+   *       U+0370 - U+03FF  // Greek and Coptic
+   *       U+0400 - U+04FF  // Cyrillic
+   *       U+0500 - U+052F  // Cyrillic Supplement
+   *       U+1D00 - U+1D7F  // Phonetic Extensions
+   *       U+1D80 - U+1DBF  // Phonetic Extensions Supplement
+   *       U+1DC0 - U+1DFF  // Combining Diacritical Marks Supplement
+   *       U+1E00 - U+1EFF  // Latin Extended Additional
+   *       U+1F00 - U+1FFF  // Greek Extended
+   *       U+2000 - U+206F  // General Punctuation
+   *       U+2070 - U+209F  // Superscripts and Subscripts
+   *       U+20A0 - U+20CF  // Currency Symbols
+   *       U+2150 - U+218F  // Number Forms
+   *       U+2460 - U+24FF  // Enclosed Alphanumerics
+   *       U+2C60 - U+2C7F  // Latin Extended-C
+   *       U+2DE0 - U+2DFF  // Cyrillic Extended-A
+   *       U+2E00 - U+2E7F  // Supplemental Punctuation
+   *       U+A640 - U+A69F  // Cyrillic Extended-B
+   *       U+A720 - U+A7FF  // Latin Extended-D
+   *       U+FB00 - U+FB06  // Alphab. Present. Forms (Latin Ligatures)
+   *      U+1D400 - U+1D7FF // Mathematical Alphanumeric Symbols
+   *      U+1F100 - U+1F1FF // Enclosed Alphanumeric Supplement
+   *     }
+   *
+   *   FT_AUTOHINTER_SCRIPT_CJK ::
+   *     Apply the CJK auto-hinter, covering Chinese, Japanese, Korean, old
+   *     Vietnamese, and some other scripts.
+   *
+   *     By default, characters from the following Unicode ranges are
+   *     assigned to this submodule.
+   *
+   *     {
+   *       U+1100 - U+11FF  // Hangul Jamo
+   *       U+2E80 - U+2EFF  // CJK Radicals Supplement
+   *       U+2F00 - U+2FDF  // Kangxi Radicals
+   *       U+2FF0 - U+2FFF  // Ideographic Description Characters
+   *       U+3000 - U+303F  // CJK Symbols and Punctuation
+   *       U+3040 - U+309F  // Hiragana
+   *       U+30A0 - U+30FF  // Katakana
+   *       U+3100 - U+312F  // Bopomofo
+   *       U+3130 - U+318F  // Hangul Compatibility Jamo
+   *       U+3190 - U+319F  // Kanbun
+   *       U+31A0 - U+31BF  // Bopomofo Extended
+   *       U+31C0 - U+31EF  // CJK Strokes
+   *       U+31F0 - U+31FF  // Katakana Phonetic Extensions
+   *       U+3200 - U+32FF  // Enclosed CJK Letters and Months
+   *       U+3300 - U+33FF  // CJK Compatibility
+   *       U+3400 - U+4DBF  // CJK Unified Ideographs Extension A
+   *       U+4DC0 - U+4DFF  // Yijing Hexagram Symbols
+   *       U+4E00 - U+9FFF  // CJK Unified Ideographs
+   *       U+A960 - U+A97F  // Hangul Jamo Extended-A
+   *       U+AC00 - U+D7AF  // Hangul Syllables
+   *       U+D7B0 - U+D7FF  // Hangul Jamo Extended-B
+   *       U+F900 - U+FAFF  // CJK Compatibility Ideographs
+   *       U+FE10 - U+FE1F  // Vertical forms
+   *       U+FE30 - U+FE4F  // CJK Compatibility Forms
+   *       U+FF00 - U+FFEF  // Halfwidth and Fullwidth Forms
+   *      U+1B000 - U+1B0FF // Kana Supplement
+   *      U+1D300 - U+1D35F // Tai Xuan Hing Symbols
+   *      U+1F200 - U+1F2FF // Enclosed Ideographic Supplement
+   *      U+20000 - U+2A6DF // CJK Unified Ideographs Extension B
+   *      U+2A700 - U+2B73F // CJK Unified Ideographs Extension C
+   *      U+2B740 - U+2B81F // CJK Unified Ideographs Extension D
+   *      U+2F800 - U+2FA1F // CJK Compatibility Ideographs Supplement
+   *     }
+   *
+   *   FT_AUTOHINTER_SCRIPT_INDIC ::
+   *     Apply the indic auto-hinter, covering all major scripts from the
+   *     Indian sub-continent and some other related scripts like Thai, Lao,
+   *     or Tibetan.
+   *
+   *     By default, characters from the following Unicode ranges are
+   *     assigned to this submodule.
+   *
+   *     {
+   *       U+0900 - U+0DFF  // Indic Range
+   *       U+0F00 - U+0FFF  // Tibetan
+   *       U+1900 - U+194F  // Limbu
+   *       U+1B80 - U+1BBF  // Sundanese
+   *       U+A800 - U+A82F  // Syloti Nagri
+   *       U+ABC0 - U+ABFF  // Meetei Mayek
+   *      U+11800 - U+118DF // Sharada
+   *     }
+   *
+   *     Note that currently Indic support is rudimentary only, missing blue
+   *     zone support.
+   *
+   */
+#define FT_AUTOHINTER_SCRIPT_NONE   0
+#define FT_AUTOHINTER_SCRIPT_LATIN  1
+#define FT_AUTOHINTER_SCRIPT_CJK    2
+#define FT_AUTOHINTER_SCRIPT_INDIC  3
+
+
+  /**************************************************************************
+   *
+   * @struct:
+   *   FT_Prop_GlyphToScriptMap
+   *
+   * @description:
+   *   *Experimental* *only*
+   *
+   *   The data exchange structure for the @glyph-to-script-map property.
+   *
+   */
+  typedef struct  FT_Prop_GlyphToScriptMap_
+  {
+    FT_Face     face;
+    FT_UShort*  map;
+
+  } FT_Prop_GlyphToScriptMap;
+
+
+  /**************************************************************************
+   *
+   * @property:
+   *   fallback-script
+   *
+   * @description:
+   *   *Experimental* *only*
+   *
+   *   If no auto-hinter script module can be assigned to a glyph, a
+   *   fallback script gets assigned to it (see also the
+   *   @glyph-to-script-map property).  By default, this is
+   *   @FT_AUTOHINTER_SCRIPT_CJK.  Using the `fallback-script' property,
+   *   this fallback value can be changed.
+   *
+   *   {
+   *     FT_Library  library;
+   *     FT_UInt     fallback_script = FT_AUTOHINTER_SCRIPT_NONE;
+   *
+   *
+   *     FT_Init_FreeType( &library );
+   *
+   *     FT_Property_Set( library, "autofitter",
+   *                               "fallback-script", &fallback_script );
+   *   }
+   *
+   * @note:
+   *   This property can be used with @FT_Property_Get also.
+   *
+   *   It's important to use the right timing for changing this value: The
+   *   creation of the glyph-to-script map that eventually uses the
+   *   fallback script value gets triggered either by setting or reading a
+   *   face-specific property like @glyph-to-script-map, or by auto-hinting
+   *   any glyph from that face.  In particular, if you have already created
+   *   an @FT_Face structure but not loaded any glyph (using the
+   *   auto-hinter), a change of the fallback script will affect this face.
+   *
+   */
+
+
+  /**************************************************************************
+   *
+   * @property:
+   *   default-script
+   *
+   * @description:
+   *   *Experimental* *only*
+   *
+   *   If FreeType gets compiled with FT_CONFIG_OPTION_USE_HARFBUZZ to make
+   *   the HarfBuzz library access OpenType features for getting better
+   *   glyph coverages, this property sets the (auto-fitter) script to be
+   *   used for the default (OpenType) script data of a font's GSUB table.
+   *   Features for the default script are intended for all scripts not
+   *   explicitly handled in GSUB; an example is a `dlig' feature,
+   *   containing the combination of the characters `T', `E', and `L' to
+   *   form a `TEL' ligature.
+   *
+   *   By default, this is @FT_AUTOHINTER_SCRIPT_LATIN.  Using the
+   *   `default-script' property, this default value can be changed.
+   *
+   *   {
+   *     FT_Library  library;
+   *     FT_UInt     default_script = FT_AUTOHINTER_SCRIPT_NONE;
+   *
+   *
+   *     FT_Init_FreeType( &library );
+   *
+   *     FT_Property_Set( library, "autofitter",
+   *                               "default-script", &default_script );
+   *   }
+   *
+   * @note:
+   *   This property can be used with @FT_Property_Get also.
+   *
+   *   It's important to use the right timing for changing this value: The
+   *   creation of the glyph-to-script map that eventually uses the
+   *   default script value gets triggered either by setting or reading a
+   *   face-specific property like @glyph-to-script-map, or by auto-hinting
+   *   any glyph from that face.  In particular, if you have already created
+   *   an @FT_Face structure but not loaded any glyph (using the
+   *   auto-hinter), a change of the default script will affect this face.
+   *
+   */
+
+
+  /**************************************************************************
+   *
+   * @property:
+   *   increase-x-height
+   *
+   * @description:
+   *   For ppem values in the range 6~<= ppem <= `increase-x-height', round
+   *   up the font's x~height much more often than normally.  If the value
+   *   is set to~0, which is the default, this feature is switched off.  Use
+   *   this property to improve the legibility of small font sizes if
+   *   necessary.
+   *
+   *   {
+   *     FT_Library               library;
+   *     FT_Face                  face;
+   *     FT_Prop_IncreaseXHeight  prop;
+   *
+   *
+   *     FT_Init_FreeType( &library );
+   *     FT_New_Face( library, "foo.ttf", 0, &face );
+   *     FT_Set_Char_Size( face, 10 * 64, 0, 72, 0 );
+   *
+   *     prop.face  = face;
+   *     prop.limit = 14;
+   *
+   *     FT_Property_Set( library, "autofitter",
+   *                               "increase-x-height", &prop );
+   *   }
+   *
+   * @note:
+   *   This property can be used with @FT_Property_Get also.
+   *
+   *   Set this value right after calling @FT_Set_Char_Size, but before
+   *   loading any glyph (using the auto-hinter).
+   *
+   */
+
+
+  /**************************************************************************
+   *
+   * @struct:
+   *   FT_Prop_IncreaseXHeight
+   *
+   * @description:
+   *   The data exchange structure for the @increase-x-height property.
+   *
+   */
+  typedef struct  FT_Prop_IncreaseXHeight_
+  {
+    FT_Face  face;
+    FT_UInt  limit;
+
+  } FT_Prop_IncreaseXHeight;
+
+
+  /**************************************************************************
+   *
+   * @property:
+   *   warping
+   *
+   * @description:
+   *   *Experimental* *only*
+   *
+   *   If FreeType gets compiled with option AF_CONFIG_OPTION_USE_WARPER to
+   *   activate the warp hinting code in the auto-hinter, this property
+   *   switches warping on and off.
+   *
+   *   Warping only works in `normal' auto-hinting mode replacing it.
+   *   The idea of the code is to slightly scale and shift a glyph along
+   *   the non-hinted dimension (which is usually the horizontal axis) so
+   *   that as much of its segments are aligned (more or less) to the grid.
+   *   To find out a glyph's optimal scaling and shifting value, various
+   *   parameter combinations are tried and scored.
+   *
+   *   By default, warping is off.  The example below shows how to switch on
+   *   warping (omitting the error handling).
+   *
+   *   {
+   *     FT_Library  library;
+   *     FT_Bool     warping = 1;
+   *
+   *
+   *     FT_Init_FreeType( &library );
+   *
+   *     FT_Property_Set( library, "autofitter",
+   *                               "warping", &warping );
+   *   }
+   *
+   * @note:
+   *   This property can be used with @FT_Property_Get also.
+   *
+   *   This property can be set via the `FREETYPE_PROPERTIES' environment
+   *   variable (using values 1 and 0 for `on' and `off', respectively).
+   *
+   *   The warping code can also change advance widths.  Have a look at the
+   *   `lsb_delta' and `rsb_delta' fields in the @FT_GlyphSlotRec structure
+   *   for details on improving inter-glyph distances while rendering.
+   *
+   *   Since warping is a global property of the auto-hinter it is best to
+   *   change its value before rendering any face.  Otherwise, you should
+   *   reload all faces that get auto-hinted in `normal' hinting mode.
+   *
+   */
+
+
+  /**************************************************************************
+   *
+   * @property:
+   *   no-stem-darkening[autofit]
+   *
+   * @description:
+   *   *Experimental* *only*, *requires* *linear* *alpha* *blending* *and*
+   *   *gamma* *correction*
+   *
+   *   Stem darkening emboldens glyphs at smaller sizes to make them more
+   *   readable on common low-DPI screens when using linear alpha blending
+   *   and gamma correction, see @FT_Render_Glyph.  When not using linear
+   *   alpha blending and gamma correction, glyphs will appear heavy and
+   *   fuzzy!
+   *
+   *   Gamma correction essentially lightens fonts since shades of grey are
+   *   shifted to higher pixel values (=~higher brightness) to match the
+   *   original intention to the reality of our screens.  The side-effect is
+   *   that glyphs `thin out'.  Mac OS~X and Adobe's proprietary font
+   *   rendering library implement a counter-measure: stem darkening at
+   *   smaller sizes where shades of gray dominate.  By emboldening a glyph
+   *   slightly in relation to its pixel size, individual pixels get higher
+   *   coverage of filled-in outlines and are therefore `blacker'.  This
+   *   counteracts the `thinning out' of glyphs, making text remain readable
+   *   at smaller sizes.  All glyphs that pass through the auto-hinter will
+   *   be emboldened unless this property is set to TRUE.
+   *
+   *   See the description of the CFF driver for algorithmic details.  Total
+   *   consistency with the CFF driver is currently not achieved because the
+   *   emboldening method differs and glyphs must be scaled down on the
+   *   Y-axis to keep outline points inside their precomputed blue zones.
+   *   The smaller the size (especially 9ppem and down), the higher the loss
+   *   of emboldening versus the CFF driver.
+   *
+   *   This property can be set via the `FREETYPE_PROPERTIES' environment
+   *   variable similar to the CFF driver.  It can also be set per face
+   *   using @FT_Face_Properties with @FT_PARAM_TAG_STEM_DARKENING.
+   *
+   */
+
+
+  /**************************************************************************
+   *
+   * @constant:
+   *   FT_PARAM_TAG_STEM_DARKENING
+   *
+   * @description:
+   *   An @FT_Parameter tag to be used with @FT_Face_Properties.  The
+   *   corresponding Boolean argument specifies whether to apply stem
+   *   darkening, overriding the global default values or the values set up
+   *   with @FT_Property_Set (see @no-stem-darkening[autofit] and
+   *   @no-stem-darkening[cff]).
+   *
+   *   This is a passive setting that only takes effect if the font driver
+   *   or autohinter honors it, which the CFF driver always does, but the
+   *   autohinter only in `light' hinting mode (as of version 2.7.0).
+   *
+   */
+#define FT_PARAM_TAG_STEM_DARKENING \
+          FT_MAKE_TAG( 'd', 'a', 'r', 'k' )
+
+
+  /**************************************************************************
+   *
+   * @property:
+   *   darkening-parameters[autofit]
+   *
+   * @description:
+   *   *Experimental* *only*
+   *
+   *   See the description of the CFF driver for details.  This
+   *   implementation appropriates the
+   *   CFF_CONFIG_OPTION_DARKENING_PARAMETER_* #defines for consistency.
+   *   Note the differences described in @no-stem-darkening[autofit].
+   *
+   *   This property can be set via the `FREETYPE_PROPERTIES' environment
+   *   variable similar to the CFF driver.
+   */
+
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* FTAUTOH_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ftbbox.h b/engine/inc/freetype/ftbbox.h
new file mode 100644
index 00000000..f03bdc1e
--- /dev/null
+++ b/engine/inc/freetype/ftbbox.h
@@ -0,0 +1,101 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftbbox.h                                                               */
+/*                                                                         */
+/*    FreeType exact bbox computation (specification).                     */
+/*                                                                         */
+/*  Copyright 1996-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This component has a _single_ role: to compute exact outline bounding */
+  /* boxes.                                                                */
+  /*                                                                       */
+  /* It is separated from the rest of the engine for various technical     */
+  /* reasons.  It may well be integrated in `ftoutln' later.               */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#ifndef FTBBOX_H_
+#define FTBBOX_H_
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    outline_processing                                                 */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Outline_Get_BBox                                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Compute the exact bounding box of an outline.  This is slower      */
+  /*    than computing the control box.  However, it uses an advanced      */
+  /*    algorithm that returns _very_ quickly when the two boxes           */
+  /*    coincide.  Otherwise, the outline Bézier arcs are traversed to     */
+  /*    extract their extrema.                                             */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    outline :: A pointer to the source outline.                        */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    abbox   :: The outline's exact bounding box.                       */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    If the font is tricky and the glyph has been loaded with           */
+  /*    @FT_LOAD_NO_SCALE, the resulting BBox is meaningless.  To get      */
+  /*    reasonable values for the BBox it is necessary to load the glyph   */
+  /*    at a large ppem value (so that the hinting instructions can        */
+  /*    properly shift and scale the subglyphs), then extracting the BBox, */
+  /*    which can be eventually converted back to font units.              */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Outline_Get_BBox( FT_Outline*  outline,
+                       FT_BBox     *abbox );
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* FTBBOX_H_ */
+
+
+/* END */
+
+
+/* Local Variables: */
+/* coding: utf-8    */
+/* End:             */
diff --git a/engine/inc/freetype/ftbdf.h b/engine/inc/freetype/ftbdf.h
new file mode 100644
index 00000000..3d3106ba
--- /dev/null
+++ b/engine/inc/freetype/ftbdf.h
@@ -0,0 +1,210 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftbdf.h                                                                */
+/*                                                                         */
+/*    FreeType API for accessing BDF-specific strings (specification).     */
+/*                                                                         */
+/*  Copyright 2002-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTBDF_H_
+#define FTBDF_H_
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    bdf_fonts                                                          */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    BDF and PCF Files                                                  */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    BDF and PCF specific API.                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains the declaration of functions specific to BDF */
+  /*    and PCF fonts.                                                     */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /**********************************************************************
+   *
+   * @enum:
+   *    BDF_PropertyType
+   *
+   * @description:
+   *    A list of BDF property types.
+   *
+   * @values:
+   *    BDF_PROPERTY_TYPE_NONE ::
+   *      Value~0 is used to indicate a missing property.
+   *
+   *    BDF_PROPERTY_TYPE_ATOM ::
+   *      Property is a string atom.
+   *
+   *    BDF_PROPERTY_TYPE_INTEGER ::
+   *      Property is a 32-bit signed integer.
+   *
+   *    BDF_PROPERTY_TYPE_CARDINAL ::
+   *      Property is a 32-bit unsigned integer.
+   */
+  typedef enum  BDF_PropertyType_
+  {
+    BDF_PROPERTY_TYPE_NONE     = 0,
+    BDF_PROPERTY_TYPE_ATOM     = 1,
+    BDF_PROPERTY_TYPE_INTEGER  = 2,
+    BDF_PROPERTY_TYPE_CARDINAL = 3
+
+  } BDF_PropertyType;
+
+
+  /**********************************************************************
+   *
+   * @type:
+   *    BDF_Property
+   *
+   * @description:
+   *    A handle to a @BDF_PropertyRec structure to model a given
+   *    BDF/PCF property.
+   */
+  typedef struct BDF_PropertyRec_*  BDF_Property;
+
+
+ /**********************************************************************
+  *
+  * @struct:
+  *    BDF_PropertyRec
+  *
+  * @description:
+  *    This structure models a given BDF/PCF property.
+  *
+  * @fields:
+  *    type ::
+  *      The property type.
+  *
+  *    u.atom ::
+  *      The atom string, if type is @BDF_PROPERTY_TYPE_ATOM.  May be
+  *      NULL, indicating an empty string.
+  *
+  *    u.integer ::
+  *      A signed integer, if type is @BDF_PROPERTY_TYPE_INTEGER.
+  *
+  *    u.cardinal ::
+  *      An unsigned integer, if type is @BDF_PROPERTY_TYPE_CARDINAL.
+  */
+  typedef struct  BDF_PropertyRec_
+  {
+    BDF_PropertyType  type;
+    union {
+      const char*     atom;
+      FT_Int32        integer;
+      FT_UInt32       cardinal;
+
+    } u;
+
+  } BDF_PropertyRec;
+
+
+ /**********************************************************************
+  *
+  * @function:
+  *    FT_Get_BDF_Charset_ID
+  *
+  * @description:
+  *    Retrieve a BDF font character set identity, according to
+  *    the BDF specification.
+  *
+  * @input:
+  *    face ::
+  *       A handle to the input face.
+  *
+  * @output:
+  *    acharset_encoding ::
+  *       Charset encoding, as a C~string, owned by the face.
+  *
+  *    acharset_registry ::
+  *       Charset registry, as a C~string, owned by the face.
+  *
+  * @return:
+  *   FreeType error code.  0~means success.
+  *
+  * @note:
+  *   This function only works with BDF faces, returning an error otherwise.
+  */
+  FT_EXPORT( FT_Error )
+  FT_Get_BDF_Charset_ID( FT_Face       face,
+                         const char*  *acharset_encoding,
+                         const char*  *acharset_registry );
+
+
+ /**********************************************************************
+  *
+  * @function:
+  *    FT_Get_BDF_Property
+  *
+  * @description:
+  *    Retrieve a BDF property from a BDF or PCF font file.
+  *
+  * @input:
+  *    face :: A handle to the input face.
+  *
+  *    name :: The property name.
+  *
+  * @output:
+  *    aproperty :: The property.
+  *
+  * @return:
+  *   FreeType error code.  0~means success.
+  *
+  * @note:
+  *   This function works with BDF _and_ PCF fonts.  It returns an error
+  *   otherwise.  It also returns an error if the property is not in the
+  *   font.
+  *
+  *   A `property' is a either key-value pair within the STARTPROPERTIES
+  *   ... ENDPROPERTIES block of a BDF font or a key-value pair from the
+  *   `info->props' array within a `FontRec' structure of a PCF font.
+  *
+  *   Integer properties are always stored as `signed' within PCF fonts;
+  *   consequently, @BDF_PROPERTY_TYPE_CARDINAL is a possible return value
+  *   for BDF fonts only.
+  *
+  *   In case of error, `aproperty->type' is always set to
+  *   @BDF_PROPERTY_TYPE_NONE.
+  */
+  FT_EXPORT( FT_Error )
+  FT_Get_BDF_Property( FT_Face           face,
+                       const char*       prop_name,
+                       BDF_PropertyRec  *aproperty );
+
+  /* */
+
+FT_END_HEADER
+
+#endif /* FTBDF_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ftbitmap.h b/engine/inc/freetype/ftbitmap.h
new file mode 100644
index 00000000..04b2402a
--- /dev/null
+++ b/engine/inc/freetype/ftbitmap.h
@@ -0,0 +1,240 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftbitmap.h                                                             */
+/*                                                                         */
+/*    FreeType utility functions for bitmaps (specification).              */
+/*                                                                         */
+/*  Copyright 2004-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTBITMAP_H_
+#define FTBITMAP_H_
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    bitmap_handling                                                    */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    Bitmap Handling                                                    */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    Handling FT_Bitmap objects.                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains functions for handling @FT_Bitmap objects.   */
+  /*    Note that none of the functions changes the bitmap's `flow' (as    */
+  /*    indicated by the sign of the `pitch' field in `FT_Bitmap').        */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Bitmap_Init                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Initialize a pointer to an @FT_Bitmap structure.                   */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    abitmap :: A pointer to the bitmap structure.                      */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    A deprecated name for the same function is `FT_Bitmap_New'.        */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Bitmap_Init( FT_Bitmap  *abitmap );
+
+
+  /* deprecated */
+  FT_EXPORT( void )
+  FT_Bitmap_New( FT_Bitmap  *abitmap );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Bitmap_Copy                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Copy a bitmap into another one.                                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    library :: A handle to a library object.                           */
+  /*                                                                       */
+  /*    source  :: A handle to the source bitmap.                          */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    target  :: A handle to the target bitmap.                          */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Bitmap_Copy( FT_Library        library,
+                  const FT_Bitmap  *source,
+                  FT_Bitmap        *target);
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Bitmap_Embolden                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Embolden a bitmap.  The new bitmap will be about `xStrength'       */
+  /*    pixels wider and `yStrength' pixels higher.  The left and bottom   */
+  /*    borders are kept unchanged.                                        */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    library   :: A handle to a library object.                         */
+  /*                                                                       */
+  /*    xStrength :: How strong the glyph is emboldened horizontally.      */
+  /*                 Expressed in 26.6 pixel format.                       */
+  /*                                                                       */
+  /*    yStrength :: How strong the glyph is emboldened vertically.        */
+  /*                 Expressed in 26.6 pixel format.                       */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    bitmap    :: A handle to the target bitmap.                        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The current implementation restricts `xStrength' to be less than   */
+  /*    or equal to~8 if bitmap is of pixel_mode @FT_PIXEL_MODE_MONO.      */
+  /*                                                                       */
+  /*    If you want to embolden the bitmap owned by a @FT_GlyphSlotRec,    */
+  /*    you should call @FT_GlyphSlot_Own_Bitmap on the slot first.        */
+  /*                                                                       */
+  /*    Bitmaps in @FT_PIXEL_MODE_GRAY2 and @FT_PIXEL_MODE_GRAY@ format    */
+  /*    are converted to @FT_PIXEL_MODE_GRAY format (i.e., 8bpp).          */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Bitmap_Embolden( FT_Library  library,
+                      FT_Bitmap*  bitmap,
+                      FT_Pos      xStrength,
+                      FT_Pos      yStrength );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Bitmap_Convert                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Convert a bitmap object with depth 1bpp, 2bpp, 4bpp, 8bpp or 32bpp */
+  /*    to a bitmap object with depth 8bpp, making the number of used      */
+  /*    bytes line (a.k.a. the `pitch') a multiple of `alignment'.         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    library   :: A handle to a library object.                         */
+  /*                                                                       */
+  /*    source    :: The source bitmap.                                    */
+  /*                                                                       */
+  /*    alignment :: The pitch of the bitmap is a multiple of this         */
+  /*                 parameter.  Common values are 1, 2, or 4.             */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    target    :: The target bitmap.                                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    It is possible to call @FT_Bitmap_Convert multiple times without   */
+  /*    calling @FT_Bitmap_Done (the memory is simply reallocated).        */
+  /*                                                                       */
+  /*    Use @FT_Bitmap_Done to finally remove the bitmap object.           */
+  /*                                                                       */
+  /*    The `library' argument is taken to have access to FreeType's       */
+  /*    memory handling functions.                                         */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Bitmap_Convert( FT_Library        library,
+                     const FT_Bitmap  *source,
+                     FT_Bitmap        *target,
+                     FT_Int            alignment );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_GlyphSlot_Own_Bitmap                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Make sure that a glyph slot owns `slot->bitmap'.                   */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    slot :: The glyph slot.                                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This function is to be used in combination with                    */
+  /*    @FT_Bitmap_Embolden.                                               */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_GlyphSlot_Own_Bitmap( FT_GlyphSlot  slot );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Bitmap_Done                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Destroy a bitmap object initialized with @FT_Bitmap_Init.          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    library :: A handle to a library object.                           */
+  /*                                                                       */
+  /*    bitmap  :: The bitmap object to be freed.                          */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The `library' argument is taken to have access to FreeType's       */
+  /*    memory handling functions.                                         */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Bitmap_Done( FT_Library  library,
+                  FT_Bitmap  *bitmap );
+
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* FTBITMAP_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ftbzip2.h b/engine/inc/freetype/ftbzip2.h
new file mode 100644
index 00000000..9147a790
--- /dev/null
+++ b/engine/inc/freetype/ftbzip2.h
@@ -0,0 +1,102 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftbzip2.h                                                              */
+/*                                                                         */
+/*    Bzip2-compressed stream support.                                     */
+/*                                                                         */
+/*  Copyright 2010-2017 by                                                 */
+/*  Joel Klinghed.                                                         */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTBZIP2_H_
+#define FTBZIP2_H_
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    bzip2                                                              */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    BZIP2 Streams                                                      */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    Using bzip2-compressed font files.                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains the declaration of Bzip2-specific functions. */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+ /************************************************************************
+  *
+  * @function:
+  *   FT_Stream_OpenBzip2
+  *
+  * @description:
+  *   Open a new stream to parse bzip2-compressed font files.  This is
+  *   mainly used to support the compressed `*.pcf.bz2' fonts that come
+  *   with XFree86.
+  *
+  * @input:
+  *   stream ::
+  *     The target embedding stream.
+  *
+  *   source ::
+  *     The source stream.
+  *
+  * @return:
+  *   FreeType error code.  0~means success.
+  *
+  * @note:
+  *   The source stream must be opened _before_ calling this function.
+  *
+  *   Calling the internal function `FT_Stream_Close' on the new stream will
+  *   *not* call `FT_Stream_Close' on the source stream.  None of the stream
+  *   objects will be released to the heap.
+  *
+  *   The stream implementation is very basic and resets the decompression
+  *   process each time seeking backwards is needed within the stream.
+  *
+  *   In certain builds of the library, bzip2 compression recognition is
+  *   automatically handled when calling @FT_New_Face or @FT_Open_Face.
+  *   This means that if no font driver is capable of handling the raw
+  *   compressed file, the library will try to open a bzip2 compressed stream
+  *   from it and re-open the face with it.
+  *
+  *   This function may return `FT_Err_Unimplemented_Feature' if your build
+  *   of FreeType was not compiled with bzip2 support.
+  */
+  FT_EXPORT( FT_Error )
+  FT_Stream_OpenBzip2( FT_Stream  stream,
+                       FT_Stream  source );
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* FTBZIP2_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ftcache.h b/engine/inc/freetype/ftcache.h
new file mode 100644
index 00000000..5ff3ccf4
--- /dev/null
+++ b/engine/inc/freetype/ftcache.h
@@ -0,0 +1,1057 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftcache.h                                                              */
+/*                                                                         */
+/*    FreeType Cache subsystem (specification).                            */
+/*                                                                         */
+/*  Copyright 1996-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTCACHE_H_
+#define FTCACHE_H_
+
+
+#include <ft2build.h>
+#include FT_GLYPH_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************
+   *
+   * <Section>
+   *    cache_subsystem
+   *
+   * <Title>
+   *    Cache Sub-System
+   *
+   * <Abstract>
+   *    How to cache face, size, and glyph data with FreeType~2.
+   *
+   * <Description>
+   *   This section describes the FreeType~2 cache sub-system, which is used
+   *   to limit the number of concurrently opened @FT_Face and @FT_Size
+   *   objects, as well as caching information like character maps and glyph
+   *   images while limiting their maximum memory usage.
+   *
+   *   Note that all types and functions begin with the `FTC_' prefix.
+   *
+   *   The cache is highly portable and thus doesn't know anything about the
+   *   fonts installed on your system, or how to access them.  This implies
+   *   the following scheme:
+   *
+   *   First, available or installed font faces are uniquely identified by
+   *   @FTC_FaceID values, provided to the cache by the client.  Note that
+   *   the cache only stores and compares these values, and doesn't try to
+   *   interpret them in any way.
+   *
+   *   Second, the cache calls, only when needed, a client-provided function
+   *   to convert an @FTC_FaceID into a new @FT_Face object.  The latter is
+   *   then completely managed by the cache, including its termination
+   *   through @FT_Done_Face.  To monitor termination of face objects, the
+   *   finalizer callback in the `generic' field of the @FT_Face object can
+   *   be used, which might also be used to store the @FTC_FaceID of the
+   *   face.
+   *
+   *   Clients are free to map face IDs to anything else.  The most simple
+   *   usage is to associate them to a (pathname,face_index) pair that is
+   *   used to call @FT_New_Face.  However, more complex schemes are also
+   *   possible.
+   *
+   *   Note that for the cache to work correctly, the face ID values must be
+   *   *persistent*, which means that the contents they point to should not
+   *   change at runtime, or that their value should not become invalid.
+   *
+   *   If this is unavoidable (e.g., when a font is uninstalled at runtime),
+   *   you should call @FTC_Manager_RemoveFaceID as soon as possible, to let
+   *   the cache get rid of any references to the old @FTC_FaceID it may
+   *   keep internally.  Failure to do so will lead to incorrect behaviour
+   *   or even crashes.
+   *
+   *   To use the cache, start with calling @FTC_Manager_New to create a new
+   *   @FTC_Manager object, which models a single cache instance.  You can
+   *   then look up @FT_Face and @FT_Size objects with
+   *   @FTC_Manager_LookupFace and @FTC_Manager_LookupSize, respectively.
+   *
+   *   If you want to use the charmap caching, call @FTC_CMapCache_New, then
+   *   later use @FTC_CMapCache_Lookup to perform the equivalent of
+   *   @FT_Get_Char_Index, only much faster.
+   *
+   *   If you want to use the @FT_Glyph caching, call @FTC_ImageCache, then
+   *   later use @FTC_ImageCache_Lookup to retrieve the corresponding
+   *   @FT_Glyph objects from the cache.
+   *
+   *   If you need lots of small bitmaps, it is much more memory efficient
+   *   to call @FTC_SBitCache_New followed by @FTC_SBitCache_Lookup.  This
+   *   returns @FTC_SBitRec structures, which are used to store small
+   *   bitmaps directly.  (A small bitmap is one whose metrics and
+   *   dimensions all fit into 8-bit integers).
+   *
+   *   We hope to also provide a kerning cache in the near future.
+   *
+   *
+   * <Order>
+   *   FTC_Manager
+   *   FTC_FaceID
+   *   FTC_Face_Requester
+   *
+   *   FTC_Manager_New
+   *   FTC_Manager_Reset
+   *   FTC_Manager_Done
+   *   FTC_Manager_LookupFace
+   *   FTC_Manager_LookupSize
+   *   FTC_Manager_RemoveFaceID
+   *
+   *   FTC_Node
+   *   FTC_Node_Unref
+   *
+   *   FTC_ImageCache
+   *   FTC_ImageCache_New
+   *   FTC_ImageCache_Lookup
+   *
+   *   FTC_SBit
+   *   FTC_SBitCache
+   *   FTC_SBitCache_New
+   *   FTC_SBitCache_Lookup
+   *
+   *   FTC_CMapCache
+   *   FTC_CMapCache_New
+   *   FTC_CMapCache_Lookup
+   *
+   *************************************************************************/
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                    BASIC TYPE DEFINITIONS                     *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************
+   *
+   * @type: FTC_FaceID
+   *
+   * @description:
+   *   An opaque pointer type that is used to identity face objects.  The
+   *   contents of such objects is application-dependent.
+   *
+   *   These pointers are typically used to point to a user-defined
+   *   structure containing a font file path, and face index.
+   *
+   * @note:
+   *   Never use NULL as a valid @FTC_FaceID.
+   *
+   *   Face IDs are passed by the client to the cache manager that calls,
+   *   when needed, the @FTC_Face_Requester to translate them into new
+   *   @FT_Face objects.
+   *
+   *   If the content of a given face ID changes at runtime, or if the value
+   *   becomes invalid (e.g., when uninstalling a font), you should
+   *   immediately call @FTC_Manager_RemoveFaceID before any other cache
+   *   function.
+   *
+   *   Failure to do so will result in incorrect behaviour or even
+   *   memory leaks and crashes.
+   */
+  typedef FT_Pointer  FTC_FaceID;
+
+
+  /************************************************************************
+   *
+   * @functype:
+   *   FTC_Face_Requester
+   *
+   * @description:
+   *   A callback function provided by client applications.  It is used by
+   *   the cache manager to translate a given @FTC_FaceID into a new valid
+   *   @FT_Face object, on demand.
+   *
+   * <Input>
+   *   face_id ::
+   *     The face ID to resolve.
+   *
+   *   library ::
+   *     A handle to a FreeType library object.
+   *
+   *   req_data ::
+   *     Application-provided request data (see note below).
+   *
+   * <Output>
+   *   aface ::
+   *     A new @FT_Face handle.
+   *
+   * <Return>
+   *   FreeType error code.  0~means success.
+   *
+   * <Note>
+   *   The third parameter `req_data' is the same as the one passed by the
+   *   client when @FTC_Manager_New is called.
+   *
+   *   The face requester should not perform funny things on the returned
+   *   face object, like creating a new @FT_Size for it, or setting a
+   *   transformation through @FT_Set_Transform!
+   */
+  typedef FT_Error
+  (*FTC_Face_Requester)( FTC_FaceID  face_id,
+                         FT_Library  library,
+                         FT_Pointer  req_data,
+                         FT_Face*    aface );
+
+  /* */
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                      CACHE MANAGER OBJECT                     *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FTC_Manager                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This object corresponds to one instance of the cache-subsystem.    */
+  /*    It is used to cache one or more @FT_Face objects, along with       */
+  /*    corresponding @FT_Size objects.                                    */
+  /*                                                                       */
+  /*    The manager intentionally limits the total number of opened        */
+  /*    @FT_Face and @FT_Size objects to control memory usage.  See the    */
+  /*    `max_faces' and `max_sizes' parameters of @FTC_Manager_New.        */
+  /*                                                                       */
+  /*    The manager is also used to cache `nodes' of various types while   */
+  /*    limiting their total memory usage.                                 */
+  /*                                                                       */
+  /*    All limitations are enforced by keeping lists of managed objects   */
+  /*    in most-recently-used order, and flushing old nodes to make room   */
+  /*    for new ones.                                                      */
+  /*                                                                       */
+  typedef struct FTC_ManagerRec_*  FTC_Manager;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FTC_Node                                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An opaque handle to a cache node object.  Each cache node is       */
+  /*    reference-counted.  A node with a count of~0 might be flushed      */
+  /*    out of a full cache whenever a lookup request is performed.        */
+  /*                                                                       */
+  /*    If you look up nodes, you have the ability to `acquire' them,      */
+  /*    i.e., to increment their reference count.  This will prevent the   */
+  /*    node from being flushed out of the cache until you explicitly      */
+  /*    `release' it (see @FTC_Node_Unref).                                */
+  /*                                                                       */
+  /*    See also @FTC_SBitCache_Lookup and @FTC_ImageCache_Lookup.         */
+  /*                                                                       */
+  typedef struct FTC_NodeRec_*  FTC_Node;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FTC_Manager_New                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Create a new cache manager.                                        */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    library   :: The parent FreeType library handle to use.            */
+  /*                                                                       */
+  /*    max_faces :: Maximum number of opened @FT_Face objects managed by  */
+  /*                 this cache instance.  Use~0 for defaults.             */
+  /*                                                                       */
+  /*    max_sizes :: Maximum number of opened @FT_Size objects managed by  */
+  /*                 this cache instance.  Use~0 for defaults.             */
+  /*                                                                       */
+  /*    max_bytes :: Maximum number of bytes to use for cached data nodes. */
+  /*                 Use~0 for defaults.  Note that this value does not    */
+  /*                 account for managed @FT_Face and @FT_Size objects.    */
+  /*                                                                       */
+  /*    requester :: An application-provided callback used to translate    */
+  /*                 face IDs into real @FT_Face objects.                  */
+  /*                                                                       */
+  /*    req_data  :: A generic pointer that is passed to the requester     */
+  /*                 each time it is called (see @FTC_Face_Requester).     */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    amanager  :: A handle to a new manager object.  0~in case of       */
+  /*                 failure.                                              */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FTC_Manager_New( FT_Library          library,
+                   FT_UInt             max_faces,
+                   FT_UInt             max_sizes,
+                   FT_ULong            max_bytes,
+                   FTC_Face_Requester  requester,
+                   FT_Pointer          req_data,
+                   FTC_Manager        *amanager );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FTC_Manager_Reset                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Empty a given cache manager.  This simply gets rid of all the      */
+  /*    currently cached @FT_Face and @FT_Size objects within the manager. */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    manager :: A handle to the manager.                                */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FTC_Manager_Reset( FTC_Manager  manager );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FTC_Manager_Done                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Destroy a given manager after emptying it.                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    manager :: A handle to the target cache manager object.            */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FTC_Manager_Done( FTC_Manager  manager );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FTC_Manager_LookupFace                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Retrieve the @FT_Face object that corresponds to a given face ID   */
+  /*    through a cache manager.                                           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    manager :: A handle to the cache manager.                          */
+  /*                                                                       */
+  /*    face_id :: The ID of the face object.                              */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    aface   :: A handle to the face object.                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The returned @FT_Face object is always owned by the manager.  You  */
+  /*    should never try to discard it yourself.                           */
+  /*                                                                       */
+  /*    The @FT_Face object doesn't necessarily have a current size object */
+  /*    (i.e., face->size can be~0).  If you need a specific `font size',  */
+  /*    use @FTC_Manager_LookupSize instead.                               */
+  /*                                                                       */
+  /*    Never change the face's transformation matrix (i.e., never call    */
+  /*    the @FT_Set_Transform function) on a returned face!  If you need   */
+  /*    to transform glyphs, do it yourself after glyph loading.           */
+  /*                                                                       */
+  /*    When you perform a lookup, out-of-memory errors are detected       */
+  /*    _within_ the lookup and force incremental flushes of the cache     */
+  /*    until enough memory is released for the lookup to succeed.         */
+  /*                                                                       */
+  /*    If a lookup fails with `FT_Err_Out_Of_Memory' the cache has        */
+  /*    already been completely flushed, and still no memory was available */
+  /*    for the operation.                                                 */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FTC_Manager_LookupFace( FTC_Manager  manager,
+                          FTC_FaceID   face_id,
+                          FT_Face     *aface );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FTC_ScalerRec                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to describe a given character size in either      */
+  /*    pixels or points to the cache manager.  See                        */
+  /*    @FTC_Manager_LookupSize.                                           */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    face_id :: The source face ID.                                     */
+  /*                                                                       */
+  /*    width   :: The character width.                                    */
+  /*                                                                       */
+  /*    height  :: The character height.                                   */
+  /*                                                                       */
+  /*    pixel   :: A Boolean.  If 1, the `width' and `height' fields are   */
+  /*               interpreted as integer pixel character sizes.           */
+  /*               Otherwise, they are expressed as 1/64th of points.      */
+  /*                                                                       */
+  /*    x_res   :: Only used when `pixel' is value~0 to indicate the       */
+  /*               horizontal resolution in dpi.                           */
+  /*                                                                       */
+  /*    y_res   :: Only used when `pixel' is value~0 to indicate the       */
+  /*               vertical resolution in dpi.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This type is mainly used to retrieve @FT_Size objects through the  */
+  /*    cache manager.                                                     */
+  /*                                                                       */
+  typedef struct  FTC_ScalerRec_
+  {
+    FTC_FaceID  face_id;
+    FT_UInt     width;
+    FT_UInt     height;
+    FT_Int      pixel;
+    FT_UInt     x_res;
+    FT_UInt     y_res;
+
+  } FTC_ScalerRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FTC_Scaler                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to an @FTC_ScalerRec structure.                           */
+  /*                                                                       */
+  typedef struct FTC_ScalerRec_*  FTC_Scaler;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FTC_Manager_LookupSize                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Retrieve the @FT_Size object that corresponds to a given           */
+  /*    @FTC_ScalerRec pointer through a cache manager.                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    manager :: A handle to the cache manager.                          */
+  /*                                                                       */
+  /*    scaler  :: A scaler handle.                                        */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    asize   :: A handle to the size object.                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The returned @FT_Size object is always owned by the manager.  You  */
+  /*    should never try to discard it by yourself.                        */
+  /*                                                                       */
+  /*    You can access the parent @FT_Face object simply as `size->face'   */
+  /*    if you need it.  Note that this object is also owned by the        */
+  /*    manager.                                                           */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    When you perform a lookup, out-of-memory errors are detected       */
+  /*    _within_ the lookup and force incremental flushes of the cache     */
+  /*    until enough memory is released for the lookup to succeed.         */
+  /*                                                                       */
+  /*    If a lookup fails with `FT_Err_Out_Of_Memory' the cache has        */
+  /*    already been completely flushed, and still no memory is available  */
+  /*    for the operation.                                                 */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FTC_Manager_LookupSize( FTC_Manager  manager,
+                          FTC_Scaler   scaler,
+                          FT_Size     *asize );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FTC_Node_Unref                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Decrement a cache node's internal reference count.  When the count */
+  /*    reaches 0, it is not destroyed but becomes eligible for subsequent */
+  /*    cache flushes.                                                     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    node    :: The cache node handle.                                  */
+  /*                                                                       */
+  /*    manager :: The cache manager handle.                               */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FTC_Node_Unref( FTC_Node     node,
+                  FTC_Manager  manager );
+
+
+  /*************************************************************************
+   *
+   * @function:
+   *   FTC_Manager_RemoveFaceID
+   *
+   * @description:
+   *   A special function used to indicate to the cache manager that
+   *   a given @FTC_FaceID is no longer valid, either because its
+   *   content changed, or because it was deallocated or uninstalled.
+   *
+   * @input:
+   *   manager ::
+   *     The cache manager handle.
+   *
+   *   face_id ::
+   *     The @FTC_FaceID to be removed.
+   *
+   * @note:
+   *   This function flushes all nodes from the cache corresponding to this
+   *   `face_id', with the exception of nodes with a non-null reference
+   *   count.
+   *
+   *   Such nodes are however modified internally so as to never appear
+   *   in later lookups with the same `face_id' value, and to be immediately
+   *   destroyed when released by all their users.
+   *
+   */
+  FT_EXPORT( void )
+  FTC_Manager_RemoveFaceID( FTC_Manager  manager,
+                            FTC_FaceID   face_id );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    cache_subsystem                                                    */
+  /*                                                                       */
+  /*************************************************************************/
+
+  /*************************************************************************
+   *
+   * @type:
+   *   FTC_CMapCache
+   *
+   * @description:
+   *   An opaque handle used to model a charmap cache.  This cache is to
+   *   hold character codes -> glyph indices mappings.
+   *
+   */
+  typedef struct FTC_CMapCacheRec_*  FTC_CMapCache;
+
+
+  /*************************************************************************
+   *
+   * @function:
+   *   FTC_CMapCache_New
+   *
+   * @description:
+   *   Create a new charmap cache.
+   *
+   * @input:
+   *   manager ::
+   *     A handle to the cache manager.
+   *
+   * @output:
+   *   acache ::
+   *     A new cache handle.  NULL in case of error.
+   *
+   * @return:
+   *   FreeType error code.  0~means success.
+   *
+   * @note:
+   *   Like all other caches, this one will be destroyed with the cache
+   *   manager.
+   *
+   */
+  FT_EXPORT( FT_Error )
+  FTC_CMapCache_New( FTC_Manager     manager,
+                     FTC_CMapCache  *acache );
+
+
+  /************************************************************************
+   *
+   * @function:
+   *   FTC_CMapCache_Lookup
+   *
+   * @description:
+   *   Translate a character code into a glyph index, using the charmap
+   *   cache.
+   *
+   * @input:
+   *   cache ::
+   *     A charmap cache handle.
+   *
+   *   face_id ::
+   *     The source face ID.
+   *
+   *   cmap_index ::
+   *     The index of the charmap in the source face.  Any negative value
+   *     means to use the cache @FT_Face's default charmap.
+   *
+   *   char_code ::
+   *     The character code (in the corresponding charmap).
+   *
+   * @return:
+   *    Glyph index.  0~means `no glyph'.
+   *
+   */
+  FT_EXPORT( FT_UInt )
+  FTC_CMapCache_Lookup( FTC_CMapCache  cache,
+                        FTC_FaceID     face_id,
+                        FT_Int         cmap_index,
+                        FT_UInt32      char_code );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    cache_subsystem                                                    */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                       IMAGE CACHE OBJECT                      *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************
+   *
+   * @struct:
+   *   FTC_ImageTypeRec
+   *
+   * @description:
+   *   A structure used to model the type of images in a glyph cache.
+   *
+   * @fields:
+   *   face_id ::
+   *     The face ID.
+   *
+   *   width ::
+   *     The width in pixels.
+   *
+   *   height ::
+   *     The height in pixels.
+   *
+   *   flags ::
+   *     The load flags, as in @FT_Load_Glyph.
+   *
+   */
+  typedef struct  FTC_ImageTypeRec_
+  {
+    FTC_FaceID  face_id;
+    FT_UInt     width;
+    FT_UInt     height;
+    FT_Int32    flags;
+
+  } FTC_ImageTypeRec;
+
+
+  /*************************************************************************
+   *
+   * @type:
+   *   FTC_ImageType
+   *
+   * @description:
+   *   A handle to an @FTC_ImageTypeRec structure.
+   *
+   */
+  typedef struct FTC_ImageTypeRec_*  FTC_ImageType;
+
+
+  /* */
+
+
+#define FTC_IMAGE_TYPE_COMPARE( d1, d2 )      \
+          ( (d1)->face_id == (d2)->face_id && \
+            (d1)->width   == (d2)->width   && \
+            (d1)->flags   == (d2)->flags   )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FTC_ImageCache                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a glyph image cache object.  They are designed to      */
+  /*    hold many distinct glyph images while not exceeding a certain      */
+  /*    memory threshold.                                                  */
+  /*                                                                       */
+  typedef struct FTC_ImageCacheRec_*  FTC_ImageCache;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FTC_ImageCache_New                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Create a new glyph image cache.                                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    manager :: The parent manager for the image cache.                 */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    acache  :: A handle to the new glyph image cache object.           */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FTC_ImageCache_New( FTC_Manager      manager,
+                      FTC_ImageCache  *acache );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FTC_ImageCache_Lookup                                              */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Retrieve a given glyph image from a glyph image cache.             */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    cache  :: A handle to the source glyph image cache.                */
+  /*                                                                       */
+  /*    type   :: A pointer to a glyph image type descriptor.              */
+  /*                                                                       */
+  /*    gindex :: The glyph index to retrieve.                             */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    aglyph :: The corresponding @FT_Glyph object.  0~in case of        */
+  /*              failure.                                                 */
+  /*                                                                       */
+  /*    anode  :: Used to return the address of the corresponding cache    */
+  /*              node after incrementing its reference count (see note    */
+  /*              below).                                                  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The returned glyph is owned and managed by the glyph image cache.  */
+  /*    Never try to transform or discard it manually!  You can however    */
+  /*    create a copy with @FT_Glyph_Copy and modify the new one.          */
+  /*                                                                       */
+  /*    If `anode' is _not_ NULL, it receives the address of the cache     */
+  /*    node containing the glyph image, after increasing its reference    */
+  /*    count.  This ensures that the node (as well as the @FT_Glyph) will */
+  /*    always be kept in the cache until you call @FTC_Node_Unref to      */
+  /*    `release' it.                                                      */
+  /*                                                                       */
+  /*    If `anode' is NULL, the cache node is left unchanged, which means  */
+  /*    that the @FT_Glyph could be flushed out of the cache on the next   */
+  /*    call to one of the caching sub-system APIs.  Don't assume that it  */
+  /*    is persistent!                                                     */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FTC_ImageCache_Lookup( FTC_ImageCache  cache,
+                         FTC_ImageType   type,
+                         FT_UInt         gindex,
+                         FT_Glyph       *aglyph,
+                         FTC_Node       *anode );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FTC_ImageCache_LookupScaler                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A variant of @FTC_ImageCache_Lookup that uses an @FTC_ScalerRec    */
+  /*    to specify the face ID and its size.                               */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    cache      :: A handle to the source glyph image cache.            */
+  /*                                                                       */
+  /*    scaler     :: A pointer to a scaler descriptor.                    */
+  /*                                                                       */
+  /*    load_flags :: The corresponding load flags.                        */
+  /*                                                                       */
+  /*    gindex     :: The glyph index to retrieve.                         */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    aglyph     :: The corresponding @FT_Glyph object.  0~in case of    */
+  /*                  failure.                                             */
+  /*                                                                       */
+  /*    anode      :: Used to return the address of the corresponding      */
+  /*                  cache node after incrementing its reference count    */
+  /*                  (see note below).                                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The returned glyph is owned and managed by the glyph image cache.  */
+  /*    Never try to transform or discard it manually!  You can however    */
+  /*    create a copy with @FT_Glyph_Copy and modify the new one.          */
+  /*                                                                       */
+  /*    If `anode' is _not_ NULL, it receives the address of the cache     */
+  /*    node containing the glyph image, after increasing its reference    */
+  /*    count.  This ensures that the node (as well as the @FT_Glyph) will */
+  /*    always be kept in the cache until you call @FTC_Node_Unref to      */
+  /*    `release' it.                                                      */
+  /*                                                                       */
+  /*    If `anode' is NULL, the cache node is left unchanged, which means  */
+  /*    that the @FT_Glyph could be flushed out of the cache on the next   */
+  /*    call to one of the caching sub-system APIs.  Don't assume that it  */
+  /*    is persistent!                                                     */
+  /*                                                                       */
+  /*    Calls to @FT_Set_Char_Size and friends have no effect on cached    */
+  /*    glyphs; you should always use the FreeType cache API instead.      */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FTC_ImageCache_LookupScaler( FTC_ImageCache  cache,
+                               FTC_Scaler      scaler,
+                               FT_ULong        load_flags,
+                               FT_UInt         gindex,
+                               FT_Glyph       *aglyph,
+                               FTC_Node       *anode );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FTC_SBit                                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a small bitmap descriptor.  See the @FTC_SBitRec       */
+  /*    structure for details.                                             */
+  /*                                                                       */
+  typedef struct FTC_SBitRec_*  FTC_SBit;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FTC_SBitRec                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A very compact structure used to describe a small glyph bitmap.    */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    width     :: The bitmap width in pixels.                           */
+  /*                                                                       */
+  /*    height    :: The bitmap height in pixels.                          */
+  /*                                                                       */
+  /*    left      :: The horizontal distance from the pen position to the  */
+  /*                 left bitmap border (a.k.a. `left side bearing', or    */
+  /*                 `lsb').                                               */
+  /*                                                                       */
+  /*    top       :: The vertical distance from the pen position (on the   */
+  /*                 baseline) to the upper bitmap border (a.k.a. `top     */
+  /*                 side bearing').  The distance is positive for upwards */
+  /*                 y~coordinates.                                        */
+  /*                                                                       */
+  /*    format    :: The format of the glyph bitmap (monochrome or gray).  */
+  /*                                                                       */
+  /*    max_grays :: Maximum gray level value (in the range 1 to~255).     */
+  /*                                                                       */
+  /*    pitch     :: The number of bytes per bitmap line.  May be positive */
+  /*                 or negative.                                          */
+  /*                                                                       */
+  /*    xadvance  :: The horizontal advance width in pixels.               */
+  /*                                                                       */
+  /*    yadvance  :: The vertical advance height in pixels.                */
+  /*                                                                       */
+  /*    buffer    :: A pointer to the bitmap pixels.                       */
+  /*                                                                       */
+  typedef struct  FTC_SBitRec_
+  {
+    FT_Byte   width;
+    FT_Byte   height;
+    FT_Char   left;
+    FT_Char   top;
+
+    FT_Byte   format;
+    FT_Byte   max_grays;
+    FT_Short  pitch;
+    FT_Char   xadvance;
+    FT_Char   yadvance;
+
+    FT_Byte*  buffer;
+
+  } FTC_SBitRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FTC_SBitCache                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a small bitmap cache.  These are special cache objects */
+  /*    used to store small glyph bitmaps (and anti-aliased pixmaps) in a  */
+  /*    much more efficient way than the traditional glyph image cache     */
+  /*    implemented by @FTC_ImageCache.                                    */
+  /*                                                                       */
+  typedef struct FTC_SBitCacheRec_*  FTC_SBitCache;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FTC_SBitCache_New                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Create a new cache to store small glyph bitmaps.                   */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    manager :: A handle to the source cache manager.                   */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    acache  :: A handle to the new sbit cache.  NULL in case of error. */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FTC_SBitCache_New( FTC_Manager     manager,
+                     FTC_SBitCache  *acache );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FTC_SBitCache_Lookup                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Look up a given small glyph bitmap in a given sbit cache and       */
+  /*    `lock' it to prevent its flushing from the cache until needed.     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    cache  :: A handle to the source sbit cache.                       */
+  /*                                                                       */
+  /*    type   :: A pointer to the glyph image type descriptor.            */
+  /*                                                                       */
+  /*    gindex :: The glyph index.                                         */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    sbit   :: A handle to a small bitmap descriptor.                   */
+  /*                                                                       */
+  /*    anode  :: Used to return the address of the corresponding cache    */
+  /*              node after incrementing its reference count (see note    */
+  /*              below).                                                  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The small bitmap descriptor and its bit buffer are owned by the    */
+  /*    cache and should never be freed by the application.  They might    */
+  /*    as well disappear from memory on the next cache lookup, so don't   */
+  /*    treat them as persistent data.                                     */
+  /*                                                                       */
+  /*    The descriptor's `buffer' field is set to~0 to indicate a missing  */
+  /*    glyph bitmap.                                                      */
+  /*                                                                       */
+  /*    If `anode' is _not_ NULL, it receives the address of the cache     */
+  /*    node containing the bitmap, after increasing its reference count.  */
+  /*    This ensures that the node (as well as the image) will always be   */
+  /*    kept in the cache until you call @FTC_Node_Unref to `release' it.  */
+  /*                                                                       */
+  /*    If `anode' is NULL, the cache node is left unchanged, which means  */
+  /*    that the bitmap could be flushed out of the cache on the next      */
+  /*    call to one of the caching sub-system APIs.  Don't assume that it  */
+  /*    is persistent!                                                     */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FTC_SBitCache_Lookup( FTC_SBitCache    cache,
+                        FTC_ImageType    type,
+                        FT_UInt          gindex,
+                        FTC_SBit        *sbit,
+                        FTC_Node        *anode );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FTC_SBitCache_LookupScaler                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A variant of @FTC_SBitCache_Lookup that uses an @FTC_ScalerRec     */
+  /*    to specify the face ID and its size.                               */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    cache      :: A handle to the source sbit cache.                   */
+  /*                                                                       */
+  /*    scaler     :: A pointer to the scaler descriptor.                  */
+  /*                                                                       */
+  /*    load_flags :: The corresponding load flags.                        */
+  /*                                                                       */
+  /*    gindex     :: The glyph index.                                     */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    sbit       :: A handle to a small bitmap descriptor.               */
+  /*                                                                       */
+  /*    anode      :: Used to return the address of the corresponding      */
+  /*                  cache node after incrementing its reference count    */
+  /*                  (see note below).                                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The small bitmap descriptor and its bit buffer are owned by the    */
+  /*    cache and should never be freed by the application.  They might    */
+  /*    as well disappear from memory on the next cache lookup, so don't   */
+  /*    treat them as persistent data.                                     */
+  /*                                                                       */
+  /*    The descriptor's `buffer' field is set to~0 to indicate a missing  */
+  /*    glyph bitmap.                                                      */
+  /*                                                                       */
+  /*    If `anode' is _not_ NULL, it receives the address of the cache     */
+  /*    node containing the bitmap, after increasing its reference count.  */
+  /*    This ensures that the node (as well as the image) will always be   */
+  /*    kept in the cache until you call @FTC_Node_Unref to `release' it.  */
+  /*                                                                       */
+  /*    If `anode' is NULL, the cache node is left unchanged, which means  */
+  /*    that the bitmap could be flushed out of the cache on the next      */
+  /*    call to one of the caching sub-system APIs.  Don't assume that it  */
+  /*    is persistent!                                                     */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FTC_SBitCache_LookupScaler( FTC_SBitCache  cache,
+                              FTC_Scaler     scaler,
+                              FT_ULong       load_flags,
+                              FT_UInt        gindex,
+                              FTC_SBit      *sbit,
+                              FTC_Node      *anode );
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* FTCACHE_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ftcffdrv.h b/engine/inc/freetype/ftcffdrv.h
new file mode 100644
index 00000000..477b6ddb
--- /dev/null
+++ b/engine/inc/freetype/ftcffdrv.h
@@ -0,0 +1,321 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftcffdrv.h                                                             */
+/*                                                                         */
+/*    FreeType API for controlling the CFF driver (specification only).    */
+/*                                                                         */
+/*  Copyright 2013-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTCFFDRV_H_
+#define FTCFFDRV_H_
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+
+  /**************************************************************************
+   *
+   * @section:
+   *   cff_driver
+   *
+   * @title:
+   *   The CFF driver
+   *
+   * @abstract:
+   *   Controlling the CFF driver module.
+   *
+   * @description:
+   *   While FreeType's CFF driver doesn't expose API functions by itself,
+   *   it is possible to control its behaviour with @FT_Property_Set and
+   *   @FT_Property_Get.  The list below gives the available properties
+   *   together with the necessary macros and structures.
+   *
+   *   The CFF driver's module name is `cff'.
+   *
+   *   *Hinting* *and* *antialiasing* *principles* *of* *the* *new* *engine*
+   *
+   *   The rasterizer is positioning horizontal features (e.g., ascender
+   *   height & x-height, or crossbars) on the pixel grid and minimizing the
+   *   amount of antialiasing applied to them, while placing vertical
+   *   features (vertical stems) on the pixel grid without hinting, thus
+   *   representing the stem position and weight accurately.  Sometimes the
+   *   vertical stems may be only partially black.  In this context,
+   *   `antialiasing' means that stems are not positioned exactly on pixel
+   *   borders, causing a fuzzy appearance.
+   *
+   *   There are two principles behind this approach.
+   *
+   *   1) No hinting in the horizontal direction: Unlike `superhinted'
+   *   TrueType, which changes glyph widths to accommodate regular
+   *   inter-glyph spacing, Adobe's approach is `faithful to the design' in
+   *   representing both the glyph width and the inter-glyph spacing
+   *   designed for the font.  This makes the screen display as close as it
+   *   can be to the result one would get with infinite resolution, while
+   *   preserving what is considered the key characteristics of each glyph.
+   *   Note that the distances between unhinted and grid-fitted positions at
+   *   small sizes are comparable to kerning values and thus would be
+   *   noticeable (and distracting) while reading if hinting were applied.
+   *
+   *   One of the reasons to not hint horizontally is antialiasing for LCD
+   *   screens: The pixel geometry of modern displays supplies three
+   *   vertical sub-pixels as the eye moves horizontally across each visible
+   *   pixel.  On devices where we can be certain this characteristic is
+   *   present a rasterizer can take advantage of the sub-pixels to add
+   *   increments of weight.  In Western writing systems this turns out to
+   *   be the more critical direction anyway; the weights and spacing of
+   *   vertical stems (see above) are central to Armenian, Cyrillic, Greek,
+   *   and Latin type designs.  Even when the rasterizer uses greyscale
+   *   antialiasing instead of color (a necessary compromise when one
+   *   doesn't know the screen characteristics), the unhinted vertical
+   *   features preserve the design's weight and spacing much better than
+   *   aliased type would.
+   *
+   *   2) Alignment in the vertical direction: Weights and spacing along the
+   *   y~axis are less critical; what is much more important is the visual
+   *   alignment of related features (like cap-height and x-height).  The
+   *   sense of alignment for these is enhanced by the sharpness of grid-fit
+   *   edges, while the cruder vertical resolution (full pixels instead of
+   *   1/3 pixels) is less of a problem.
+   *
+   *   On the technical side, horizontal alignment zones for ascender,
+   *   x-height, and other important height values (traditionally called
+   *   `blue zones') as defined in the font are positioned independently,
+   *   each being rounded to the nearest pixel edge, taking care of
+   *   overshoot suppression at small sizes, stem darkening, and scaling.
+   *
+   *   Hstems (this is, hint values defined in the font to help align
+   *   horizontal features) that fall within a blue zone are said to be
+   *   `captured' and are aligned to that zone.  Uncaptured stems are moved
+   *   in one of four ways, top edge up or down, bottom edge up or down.
+   *   Unless there are conflicting hstems, the smallest movement is taken
+   *   to minimize distortion.
+   *
+   * @order:
+   *   hinting-engine[cff]
+   *   no-stem-darkening[cff]
+   *   darkening-parameters[cff]
+   *   random-seed
+   *
+   */
+
+
+  /**************************************************************************
+   *
+   * @property:
+   *   hinting-engine[cff]
+   *
+   * @description:
+   *   Thanks to Adobe, which contributed a new hinting (and parsing)
+   *   engine, an application can select between `freetype' and `adobe' if
+   *   compiled with CFF_CONFIG_OPTION_OLD_ENGINE.  If this configuration
+   *   macro isn't defined, `hinting-engine' does nothing.
+   *
+   *   The default engine is `freetype' if CFF_CONFIG_OPTION_OLD_ENGINE is
+   *   defined, and `adobe' otherwise.
+   *
+   *   The following example code demonstrates how to select Adobe's hinting
+   *   engine (omitting the error handling).
+   *
+   *   {
+   *     FT_Library  library;
+   *     FT_UInt     hinting_engine = FT_CFF_HINTING_ADOBE;
+   *
+   *
+   *     FT_Init_FreeType( &library );
+   *
+   *     FT_Property_Set( library, "cff",
+   *                               "hinting-engine", &hinting_engine );
+   *   }
+   *
+   * @note:
+   *   This property can be used with @FT_Property_Get also.
+   *
+   *   This property can be set via the `FREETYPE_PROPERTIES' environment
+   *   variable (using values `adobe' or `freetype').
+   */
+
+
+  /**************************************************************************
+   *
+   * @enum:
+   *   FT_CFF_HINTING_XXX
+   *
+   * @description:
+   *   A list of constants used for the @hinting-engine[cff] property to
+   *   select the hinting engine for CFF fonts.
+   *
+   * @values:
+   *   FT_CFF_HINTING_FREETYPE ::
+   *     Use the old FreeType hinting engine.
+   *
+   *   FT_CFF_HINTING_ADOBE ::
+   *     Use the hinting engine contributed by Adobe.
+   *
+   */
+#define FT_CFF_HINTING_FREETYPE  0
+#define FT_CFF_HINTING_ADOBE     1
+
+
+  /**************************************************************************
+   *
+   * @property:
+   *   no-stem-darkening[cff]
+   *
+   * @description:
+   *   By default, the Adobe CFF engine darkens stems at smaller sizes,
+   *   regardless of hinting, to enhance contrast.  This feature requires
+   *   a rendering system with proper gamma correction.  Setting this
+   *   property, stem darkening gets switched off.
+   *
+   *   Note that stem darkening is never applied if @FT_LOAD_NO_SCALE is set.
+   *
+   *   {
+   *     FT_Library  library;
+   *     FT_Bool     no_stem_darkening = TRUE;
+   *
+   *
+   *     FT_Init_FreeType( &library );
+   *
+   *     FT_Property_Set( library, "cff",
+   *                               "no-stem-darkening", &no_stem_darkening );
+   *   }
+   *
+   * @note:
+   *   This property can be used with @FT_Property_Get also.
+   *
+   *   This property can be set via the `FREETYPE_PROPERTIES' environment
+   *   variable (using values 1 and 0 for `on' and `off', respectively).
+   *   It can also be set per face using @FT_Face_Properties with
+   *   @FT_PARAM_TAG_STEM_DARKENING.
+   *
+   */
+
+
+  /**************************************************************************
+   *
+   * @property:
+   *   darkening-parameters[cff]
+   *
+   * @description:
+   *   By default, the Adobe CFF engine darkens stems as follows (if the
+   *   `no-stem-darkening' property isn't set):
+   *
+   *   {
+   *     stem width <= 0.5px:   darkening amount = 0.4px
+   *     stem width  = 1px:     darkening amount = 0.275px
+   *     stem width  = 1.667px: darkening amount = 0.275px
+   *     stem width >= 2.333px: darkening amount = 0px
+   *   }
+   *
+   *   and piecewise linear in-between.  At configuration time, these four
+   *   control points can be set with the macro
+   *   `CFF_CONFIG_OPTION_DARKENING_PARAMETERS'.  At runtime, the control
+   *   points can be changed using the `darkening-parameters' property, as
+   *   the following example demonstrates.
+   *
+   *   {
+   *     FT_Library  library;
+   *     FT_Int      darken_params[8] = {  500, 300,   // x1, y1
+   *                                      1000, 200,   // x2, y2
+   *                                      1500, 100,   // x3, y3
+   *                                      2000,   0 }; // x4, y4
+   *
+   *
+   *     FT_Init_FreeType( &library );
+   *
+   *     FT_Property_Set( library, "cff",
+   *                               "darkening-parameters", darken_params );
+   *   }
+   *
+   *   The x~values give the stem width, and the y~values the darkening
+   *   amount.  The unit is 1000th of pixels.  All coordinate values must be
+   *   positive; the x~values must be monotonically increasing; the
+   *   y~values must be monotonically decreasing and smaller than or
+   *   equal to 500 (corresponding to half a pixel); the slope of each
+   *   linear piece must be shallower than -1 (e.g., -.4).
+   *
+   * @note:
+   *   This property can be used with @FT_Property_Get also.
+   *
+   *   This property can be set via the `FREETYPE_PROPERTIES' environment
+   *   variable, using eight comma-separated integers without spaces.  Here
+   *   the above example, using `\' to break the line for readability.
+   *
+   *   {
+   *     FREETYPE_PROPERTIES=\
+   *     cff:darkening-parameters=500,300,1000,200,1500,100,2000,0
+   *   }
+   */
+
+
+  /**************************************************************************
+   *
+   * @property:
+   *   random-seed
+   *
+   * @description:
+   *   By default, the seed value for the CFF `random' operator is set to a
+   *   random value.  However, mainly for debugging purposes, it is often
+   *   necessary to use a known value as a seed so that the pseudo-random
+   *   number sequences generated by `random' are repeatable.
+   *
+   *   The `random-seed' property does that.  Its argument is a signed 32bit
+   *   integer; if the value is zero or negative, the seed given by the
+   *   `intitialRandomSeed' private DICT operator in a CFF file gets used
+   *   (or a default value if there is no such operator).  If the value is
+   *   positive, use it instead of `initialRandomSeed', which is
+   *   consequently ignored.
+   *
+   * @note:
+   *   This property can be set via the `FREETYPE_PROPERTIES' environment
+   *   variable.  It can also be set per face using @FT_Face_Properties with
+   *   @FT_PARAM_TAG_RANDOM_SEED.
+   *
+   */
+
+
+  /**************************************************************************
+   *
+   * @constant:
+   *   FT_PARAM_TAG_RANDOM_SEED
+   *
+   * @description:
+   *   An @FT_Parameter tag to be used with @FT_Face_Properties.  The
+   *   corresponding 32bit signed integer argument overrides the CFF
+   *   module's random seed value with a face-specific one; see
+   *   @random-seed.
+   *
+   */
+#define FT_PARAM_TAG_RANDOM_SEED \
+          FT_MAKE_TAG( 's', 'e', 'e', 'd' )
+
+
+  /* */
+
+
+FT_END_HEADER
+
+
+#endif /* FTCFFDRV_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ftchapters.h b/engine/inc/freetype/ftchapters.h
new file mode 100644
index 00000000..a0a121b0
--- /dev/null
+++ b/engine/inc/freetype/ftchapters.h
@@ -0,0 +1,136 @@
+/***************************************************************************/
+/*                                                                         */
+/* This file defines the structure of the FreeType reference.              */
+/* It is used by the python script that generates the HTML files.          */
+/*                                                                         */
+/***************************************************************************/
+
+
+/***************************************************************************/
+/*                                                                         */
+/* <Chapter>                                                               */
+/*    general_remarks                                                      */
+/*                                                                         */
+/* <Title>                                                                 */
+/*    General Remarks                                                      */
+/*                                                                         */
+/* <Sections>                                                              */
+/*    header_inclusion                                                     */
+/*    user_allocation                                                      */
+/*                                                                         */
+/***************************************************************************/
+
+
+/***************************************************************************/
+/*                                                                         */
+/* <Chapter>                                                               */
+/*    core_api                                                             */
+/*                                                                         */
+/* <Title>                                                                 */
+/*    Core API                                                             */
+/*                                                                         */
+/* <Sections>                                                              */
+/*    version                                                              */
+/*    basic_types                                                          */
+/*    base_interface                                                       */
+/*    glyph_variants                                                       */
+/*    glyph_management                                                     */
+/*    mac_specific                                                         */
+/*    sizes_management                                                     */
+/*    header_file_macros                                                   */
+/*                                                                         */
+/***************************************************************************/
+
+
+/***************************************************************************/
+/*                                                                         */
+/* <Chapter>                                                               */
+/*    format_specific                                                      */
+/*                                                                         */
+/* <Title>                                                                 */
+/*    Format-Specific API                                                  */
+/*                                                                         */
+/* <Sections>                                                              */
+/*    multiple_masters                                                     */
+/*    truetype_tables                                                      */
+/*    type1_tables                                                         */
+/*    sfnt_names                                                           */
+/*    bdf_fonts                                                            */
+/*    cid_fonts                                                            */
+/*    pfr_fonts                                                            */
+/*    winfnt_fonts                                                         */
+/*    font_formats                                                         */
+/*    gasp_table                                                           */
+/*                                                                         */
+/***************************************************************************/
+
+
+/***************************************************************************/
+/*                                                                         */
+/* <Chapter>                                                               */
+/*    module_specific                                                      */
+/*                                                                         */
+/* <Title>                                                                 */
+/*    Controlling FreeType Modules                                         */
+/*                                                                         */
+/* <Sections>                                                              */
+/*    auto_hinter                                                          */
+/*    cff_driver                                                           */
+/*    tt_driver                                                            */
+/*    pcf_driver                                                           */
+/*                                                                         */
+/***************************************************************************/
+
+
+/***************************************************************************/
+/*                                                                         */
+/* <Chapter>                                                               */
+/*    cache_subsystem                                                      */
+/*                                                                         */
+/* <Title>                                                                 */
+/*    Cache Sub-System                                                     */
+/*                                                                         */
+/* <Sections>                                                              */
+/*    cache_subsystem                                                      */
+/*                                                                         */
+/***************************************************************************/
+
+
+/***************************************************************************/
+/*                                                                         */
+/* <Chapter>                                                               */
+/*    support_api                                                          */
+/*                                                                         */
+/* <Title>                                                                 */
+/*    Support API                                                          */
+/*                                                                         */
+/* <Sections>                                                              */
+/*    computations                                                         */
+/*    list_processing                                                      */
+/*    outline_processing                                                   */
+/*    quick_advance                                                        */
+/*    bitmap_handling                                                      */
+/*    raster                                                               */
+/*    glyph_stroker                                                        */
+/*    system_interface                                                     */
+/*    module_management                                                    */
+/*    gzip                                                                 */
+/*    lzw                                                                  */
+/*    bzip2                                                                */
+/*    lcd_filtering                                                        */
+/*                                                                         */
+/***************************************************************************/
+
+/***************************************************************************/
+/*                                                                         */
+/* <Chapter>                                                               */
+/*    error_codes                                                          */
+/*                                                                         */
+/* <Title>                                                                 */
+/*    Error Codes                                                          */
+/*                                                                         */
+/* <Sections>                                                              */
+/*    error_enumerations                                                   */
+/*    error_code_values                                                    */
+/*                                                                         */
+/***************************************************************************/
diff --git a/engine/inc/freetype/ftcid.h b/engine/inc/freetype/ftcid.h
new file mode 100644
index 00000000..4adcbeed
--- /dev/null
+++ b/engine/inc/freetype/ftcid.h
@@ -0,0 +1,168 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftcid.h                                                                */
+/*                                                                         */
+/*    FreeType API for accessing CID font information (specification).     */
+/*                                                                         */
+/*  Copyright 2007-2017 by                                                 */
+/*  Dereg Clegg and Michael Toftdal.                                       */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTCID_H_
+#define FTCID_H_
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    cid_fonts                                                          */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    CID Fonts                                                          */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    CID-keyed font specific API.                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains the declaration of CID-keyed font specific   */
+  /*    functions.                                                         */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /**********************************************************************
+   *
+   * @function:
+   *    FT_Get_CID_Registry_Ordering_Supplement
+   *
+   * @description:
+   *    Retrieve the Registry/Ordering/Supplement triple (also known as the
+   *    "R/O/S") from a CID-keyed font.
+   *
+   * @input:
+   *    face ::
+   *       A handle to the input face.
+   *
+   * @output:
+   *    registry ::
+   *       The registry, as a C~string, owned by the face.
+   *
+   *    ordering ::
+   *       The ordering, as a C~string, owned by the face.
+   *
+   *    supplement ::
+   *       The supplement.
+   *
+   * @return:
+   *    FreeType error code.  0~means success.
+   *
+   * @note:
+   *    This function only works with CID faces, returning an error
+   *    otherwise.
+   *
+   * @since:
+   *    2.3.6
+   */
+  FT_EXPORT( FT_Error )
+  FT_Get_CID_Registry_Ordering_Supplement( FT_Face       face,
+                                           const char*  *registry,
+                                           const char*  *ordering,
+                                           FT_Int       *supplement);
+
+
+  /**********************************************************************
+   *
+   * @function:
+   *    FT_Get_CID_Is_Internally_CID_Keyed
+   *
+   * @description:
+   *    Retrieve the type of the input face, CID keyed or not.  In
+   *    contrast to the @FT_IS_CID_KEYED macro this function returns
+   *    successfully also for CID-keyed fonts in an SFNT wrapper.
+   *
+   * @input:
+   *    face ::
+   *       A handle to the input face.
+   *
+   * @output:
+   *    is_cid ::
+   *       The type of the face as an @FT_Bool.
+   *
+   * @return:
+   *    FreeType error code.  0~means success.
+   *
+   * @note:
+   *    This function only works with CID faces and OpenType fonts,
+   *    returning an error otherwise.
+   *
+   * @since:
+   *    2.3.9
+   */
+  FT_EXPORT( FT_Error )
+  FT_Get_CID_Is_Internally_CID_Keyed( FT_Face   face,
+                                      FT_Bool  *is_cid );
+
+
+  /**********************************************************************
+   *
+   * @function:
+   *    FT_Get_CID_From_Glyph_Index
+   *
+   * @description:
+   *    Retrieve the CID of the input glyph index.
+   *
+   * @input:
+   *    face ::
+   *       A handle to the input face.
+   *
+   *    glyph_index ::
+   *       The input glyph index.
+   *
+   * @output:
+   *    cid ::
+   *       The CID as an @FT_UInt.
+   *
+   * @return:
+   *    FreeType error code.  0~means success.
+   *
+   * @note:
+   *    This function only works with CID faces and OpenType fonts,
+   *    returning an error otherwise.
+   *
+   * @since:
+   *    2.3.9
+   */
+  FT_EXPORT( FT_Error )
+  FT_Get_CID_From_Glyph_Index( FT_Face   face,
+                               FT_UInt   glyph_index,
+                               FT_UInt  *cid );
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* FTCID_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/fterrdef.h b/engine/inc/freetype/fterrdef.h
new file mode 100644
index 00000000..6a6dc85b
--- /dev/null
+++ b/engine/inc/freetype/fterrdef.h
@@ -0,0 +1,280 @@
+/***************************************************************************/
+/*                                                                         */
+/*  fterrdef.h                                                             */
+/*                                                                         */
+/*    FreeType error codes (specification).                                */
+/*                                                                         */
+/*  Copyright 2002-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*   error_code_values                                                   */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*   Error Code Values                                                   */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*   All possible error codes returned by FreeType functions.            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*   The list below is taken verbatim from the file `fterrdef.h'         */
+  /*   (loaded automatically by including `FT_FREETYPE_H').  The first     */
+  /*   argument of the `FT_ERROR_DEF_' macro is the error label; by        */
+  /*   default, the prefix `FT_Err_' gets added so that you get error      */
+  /*   names like `FT_Err_Cannot_Open_Resource'.  The second argument is   */
+  /*   the error code, and the last argument an error string, which is not */
+  /*   used by FreeType.                                                   */
+  /*                                                                       */
+  /*   Within your application you should *only* use error names and       */
+  /*   *never* its numeric values!  The latter might (and actually do)     */
+  /*   change in forthcoming FreeType versions.                            */
+  /*                                                                       */
+  /*   Macro `FT_NOERRORDEF_' defines `FT_Err_Ok', which is always zero.   */
+  /*   See the `Error Enumerations' subsection how to automatically        */
+  /*   generate a list of error strings.                                   */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    FT_Err_XXX                                                         */
+  /*                                                                       */
+  /*************************************************************************/
+
+  /* generic errors */
+
+  FT_NOERRORDEF_( Ok,                                        0x00,
+                  "no error" )
+
+  FT_ERRORDEF_( Cannot_Open_Resource,                        0x01,
+                "cannot open resource" )
+  FT_ERRORDEF_( Unknown_File_Format,                         0x02,
+                "unknown file format" )
+  FT_ERRORDEF_( Invalid_File_Format,                         0x03,
+                "broken file" )
+  FT_ERRORDEF_( Invalid_Version,                             0x04,
+                "invalid FreeType version" )
+  FT_ERRORDEF_( Lower_Module_Version,                        0x05,
+                "module version is too low" )
+  FT_ERRORDEF_( Invalid_Argument,                            0x06,
+                "invalid argument" )
+  FT_ERRORDEF_( Unimplemented_Feature,                       0x07,
+                "unimplemented feature" )
+  FT_ERRORDEF_( Invalid_Table,                               0x08,
+                "broken table" )
+  FT_ERRORDEF_( Invalid_Offset,                              0x09,
+                "broken offset within table" )
+  FT_ERRORDEF_( Array_Too_Large,                             0x0A,
+                "array allocation size too large" )
+  FT_ERRORDEF_( Missing_Module,                              0x0B,
+                "missing module" )
+  FT_ERRORDEF_( Missing_Property,                            0x0C,
+                "missing property" )
+
+  /* glyph/character errors */
+
+  FT_ERRORDEF_( Invalid_Glyph_Index,                         0x10,
+                "invalid glyph index" )
+  FT_ERRORDEF_( Invalid_Character_Code,                      0x11,
+                "invalid character code" )
+  FT_ERRORDEF_( Invalid_Glyph_Format,                        0x12,
+                "unsupported glyph image format" )
+  FT_ERRORDEF_( Cannot_Render_Glyph,                         0x13,
+                "cannot render this glyph format" )
+  FT_ERRORDEF_( Invalid_Outline,                             0x14,
+                "invalid outline" )
+  FT_ERRORDEF_( Invalid_Composite,                           0x15,
+                "invalid composite glyph" )
+  FT_ERRORDEF_( Too_Many_Hints,                              0x16,
+                "too many hints" )
+  FT_ERRORDEF_( Invalid_Pixel_Size,                          0x17,
+                "invalid pixel size" )
+
+  /* handle errors */
+
+  FT_ERRORDEF_( Invalid_Handle,                              0x20,
+                "invalid object handle" )
+  FT_ERRORDEF_( Invalid_Library_Handle,                      0x21,
+                "invalid library handle" )
+  FT_ERRORDEF_( Invalid_Driver_Handle,                       0x22,
+                "invalid module handle" )
+  FT_ERRORDEF_( Invalid_Face_Handle,                         0x23,
+                "invalid face handle" )
+  FT_ERRORDEF_( Invalid_Size_Handle,                         0x24,
+                "invalid size handle" )
+  FT_ERRORDEF_( Invalid_Slot_Handle,                         0x25,
+                "invalid glyph slot handle" )
+  FT_ERRORDEF_( Invalid_CharMap_Handle,                      0x26,
+                "invalid charmap handle" )
+  FT_ERRORDEF_( Invalid_Cache_Handle,                        0x27,
+                "invalid cache manager handle" )
+  FT_ERRORDEF_( Invalid_Stream_Handle,                       0x28,
+                "invalid stream handle" )
+
+  /* driver errors */
+
+  FT_ERRORDEF_( Too_Many_Drivers,                            0x30,
+                "too many modules" )
+  FT_ERRORDEF_( Too_Many_Extensions,                         0x31,
+                "too many extensions" )
+
+  /* memory errors */
+
+  FT_ERRORDEF_( Out_Of_Memory,                               0x40,
+                "out of memory" )
+  FT_ERRORDEF_( Unlisted_Object,                             0x41,
+                "unlisted object" )
+
+  /* stream errors */
+
+  FT_ERRORDEF_( Cannot_Open_Stream,                          0x51,
+                "cannot open stream" )
+  FT_ERRORDEF_( Invalid_Stream_Seek,                         0x52,
+                "invalid stream seek" )
+  FT_ERRORDEF_( Invalid_Stream_Skip,                         0x53,
+                "invalid stream skip" )
+  FT_ERRORDEF_( Invalid_Stream_Read,                         0x54,
+                "invalid stream read" )
+  FT_ERRORDEF_( Invalid_Stream_Operation,                    0x55,
+                "invalid stream operation" )
+  FT_ERRORDEF_( Invalid_Frame_Operation,                     0x56,
+                "invalid frame operation" )
+  FT_ERRORDEF_( Nested_Frame_Access,                         0x57,
+                "nested frame access" )
+  FT_ERRORDEF_( Invalid_Frame_Read,                          0x58,
+                "invalid frame read" )
+
+  /* raster errors */
+
+  FT_ERRORDEF_( Raster_Uninitialized,                        0x60,
+                "raster uninitialized" )
+  FT_ERRORDEF_( Raster_Corrupted,                            0x61,
+                "raster corrupted" )
+  FT_ERRORDEF_( Raster_Overflow,                             0x62,
+                "raster overflow" )
+  FT_ERRORDEF_( Raster_Negative_Height,                      0x63,
+                "negative height while rastering" )
+
+  /* cache errors */
+
+  FT_ERRORDEF_( Too_Many_Caches,                             0x70,
+                "too many registered caches" )
+
+  /* TrueType and SFNT errors */
+
+  FT_ERRORDEF_( Invalid_Opcode,                              0x80,
+                "invalid opcode" )
+  FT_ERRORDEF_( Too_Few_Arguments,                           0x81,
+                "too few arguments" )
+  FT_ERRORDEF_( Stack_Overflow,                              0x82,
+                "stack overflow" )
+  FT_ERRORDEF_( Code_Overflow,                               0x83,
+                "code overflow" )
+  FT_ERRORDEF_( Bad_Argument,                                0x84,
+                "bad argument" )
+  FT_ERRORDEF_( Divide_By_Zero,                              0x85,
+                "division by zero" )
+  FT_ERRORDEF_( Invalid_Reference,                           0x86,
+                "invalid reference" )
+  FT_ERRORDEF_( Debug_OpCode,                                0x87,
+                "found debug opcode" )
+  FT_ERRORDEF_( ENDF_In_Exec_Stream,                         0x88,
+                "found ENDF opcode in execution stream" )
+  FT_ERRORDEF_( Nested_DEFS,                                 0x89,
+                "nested DEFS" )
+  FT_ERRORDEF_( Invalid_CodeRange,                           0x8A,
+                "invalid code range" )
+  FT_ERRORDEF_( Execution_Too_Long,                          0x8B,
+                "execution context too long" )
+  FT_ERRORDEF_( Too_Many_Function_Defs,                      0x8C,
+                "too many function definitions" )
+  FT_ERRORDEF_( Too_Many_Instruction_Defs,                   0x8D,
+                "too many instruction definitions" )
+  FT_ERRORDEF_( Table_Missing,                               0x8E,
+                "SFNT font table missing" )
+  FT_ERRORDEF_( Horiz_Header_Missing,                        0x8F,
+                "horizontal header (hhea) table missing" )
+  FT_ERRORDEF_( Locations_Missing,                           0x90,
+                "locations (loca) table missing" )
+  FT_ERRORDEF_( Name_Table_Missing,                          0x91,
+                "name table missing" )
+  FT_ERRORDEF_( CMap_Table_Missing,                          0x92,
+                "character map (cmap) table missing" )
+  FT_ERRORDEF_( Hmtx_Table_Missing,                          0x93,
+                "horizontal metrics (hmtx) table missing" )
+  FT_ERRORDEF_( Post_Table_Missing,                          0x94,
+                "PostScript (post) table missing" )
+  FT_ERRORDEF_( Invalid_Horiz_Metrics,                       0x95,
+                "invalid horizontal metrics" )
+  FT_ERRORDEF_( Invalid_CharMap_Format,                      0x96,
+                "invalid character map (cmap) format" )
+  FT_ERRORDEF_( Invalid_PPem,                                0x97,
+                "invalid ppem value" )
+  FT_ERRORDEF_( Invalid_Vert_Metrics,                        0x98,
+                "invalid vertical metrics" )
+  FT_ERRORDEF_( Could_Not_Find_Context,                      0x99,
+                "could not find context" )
+  FT_ERRORDEF_( Invalid_Post_Table_Format,                   0x9A,
+                "invalid PostScript (post) table format" )
+  FT_ERRORDEF_( Invalid_Post_Table,                          0x9B,
+                "invalid PostScript (post) table" )
+  FT_ERRORDEF_( DEF_In_Glyf_Bytecode,                        0x9C,
+                "found FDEF or IDEF opcode in glyf bytecode" )
+  FT_ERRORDEF_( Missing_Bitmap,                              0x9D,
+                "missing bitmap in strike" )
+
+  /* CFF, CID, and Type 1 errors */
+
+  FT_ERRORDEF_( Syntax_Error,                                0xA0,
+                "opcode syntax error" )
+  FT_ERRORDEF_( Stack_Underflow,                             0xA1,
+                "argument stack underflow" )
+  FT_ERRORDEF_( Ignore,                                      0xA2,
+                "ignore" )
+  FT_ERRORDEF_( No_Unicode_Glyph_Name,                       0xA3,
+                "no Unicode glyph name found" )
+  FT_ERRORDEF_( Glyph_Too_Big,                               0xA4,
+                "glyph too big for hinting" )
+
+  /* BDF errors */
+
+  FT_ERRORDEF_( Missing_Startfont_Field,                     0xB0,
+                "`STARTFONT' field missing" )
+  FT_ERRORDEF_( Missing_Font_Field,                          0xB1,
+                "`FONT' field missing" )
+  FT_ERRORDEF_( Missing_Size_Field,                          0xB2,
+                "`SIZE' field missing" )
+  FT_ERRORDEF_( Missing_Fontboundingbox_Field,               0xB3,
+                "`FONTBOUNDINGBOX' field missing" )
+  FT_ERRORDEF_( Missing_Chars_Field,                         0xB4,
+                "`CHARS' field missing" )
+  FT_ERRORDEF_( Missing_Startchar_Field,                     0xB5,
+                "`STARTCHAR' field missing" )
+  FT_ERRORDEF_( Missing_Encoding_Field,                      0xB6,
+                "`ENCODING' field missing" )
+  FT_ERRORDEF_( Missing_Bbx_Field,                           0xB7,
+                "`BBX' field missing" )
+  FT_ERRORDEF_( Bbx_Too_Big,                                 0xB8,
+                "`BBX' too big" )
+  FT_ERRORDEF_( Corrupted_Font_Header,                       0xB9,
+                "Font header corrupted or missing fields" )
+  FT_ERRORDEF_( Corrupted_Font_Glyphs,                       0xBA,
+                "Font glyphs corrupted or missing fields" )
+
+  /* */
+
+
+/* END */
diff --git a/engine/inc/freetype/fterrors.h b/engine/inc/freetype/fterrors.h
new file mode 100644
index 00000000..ae382c41
--- /dev/null
+++ b/engine/inc/freetype/fterrors.h
@@ -0,0 +1,226 @@
+/***************************************************************************/
+/*                                                                         */
+/*  fterrors.h                                                             */
+/*                                                                         */
+/*    FreeType error code handling (specification).                        */
+/*                                                                         */
+/*  Copyright 1996-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*   error_enumerations                                                  */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*   Error Enumerations                                                  */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*   How to handle errors and error strings.                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*   The header file `fterrors.h' (which is automatically included by    */
+  /*   `freetype.h' defines the handling of FreeType's enumeration         */
+  /*   constants.  It can also be used to generate error message strings   */
+  /*   with a small macro trick explained below.                           */
+  /*                                                                       */
+  /*   *Error* *Formats*                                                   */
+  /*                                                                       */
+  /*   The configuration macro FT_CONFIG_OPTION_USE_MODULE_ERRORS can be   */
+  /*   defined in `ftoption.h' in order to make the higher byte indicate   */
+  /*   the module where the error has happened (this is not compatible     */
+  /*   with standard builds of FreeType~2, however).  See the file         */
+  /*   `ftmoderr.h' for more details.                                      */
+  /*                                                                       */
+  /*   *Error* *Message* *Strings*                                         */
+  /*                                                                       */
+  /*   Error definitions are set up with special macros that allow client  */
+  /*   applications to build a table of error message strings.  The        */
+  /*   strings are not included in a normal build of FreeType~2 to save    */
+  /*   space (most client applications do not use them).                   */
+  /*                                                                       */
+  /*   To do so, you have to define the following macros before including  */
+  /*   this file.                                                          */
+  /*                                                                       */
+  /*   {                                                                   */
+  /*     FT_ERROR_START_LIST                                               */
+  /*   }                                                                   */
+  /*                                                                       */
+  /*   This macro is called before anything else to define the start of    */
+  /*   the error list.  It is followed by several FT_ERROR_DEF calls.      */
+  /*                                                                       */
+  /*   {                                                                   */
+  /*     FT_ERROR_DEF( e, v, s )                                           */
+  /*   }                                                                   */
+  /*                                                                       */
+  /*   This macro is called to define one single error.  `e' is the error  */
+  /*   code identifier (e.g., `Invalid_Argument'), `v' is the error's      */
+  /*   numerical value, and `s' is the corresponding error string.         */
+  /*                                                                       */
+  /*   {                                                                   */
+  /*     FT_ERROR_END_LIST                                                 */
+  /*   }                                                                   */
+  /*                                                                       */
+  /*   This macro ends the list.                                           */
+  /*                                                                       */
+  /*   Additionally, you have to undefine `FTERRORS_H_' before #including  */
+  /*   this file.                                                          */
+  /*                                                                       */
+  /*   Here is a simple example.                                           */
+  /*                                                                       */
+  /*   {                                                                   */
+  /*     #undef FTERRORS_H_                                                */
+  /*     #define FT_ERRORDEF( e, v, s )  { e, s },                         */
+  /*     #define FT_ERROR_START_LIST     {                                 */
+  /*     #define FT_ERROR_END_LIST       { 0, NULL } };                    */
+  /*                                                                       */
+  /*     const struct                                                      */
+  /*     {                                                                 */
+  /*       int          err_code;                                          */
+  /*       const char*  err_msg;                                           */
+  /*     } ft_errors[] =                                                   */
+  /*                                                                       */
+  /*     #include FT_ERRORS_H                                              */
+  /*   }                                                                   */
+  /*                                                                       */
+  /*   Note that `FT_Err_Ok' is _not_ defined with `FT_ERRORDEF' but with  */
+  /*   `FT_NOERRORDEF'; it is always zero.                                 */
+  /*                                                                       */
+  /*************************************************************************/
+
+  /* */
+
+  /* In previous FreeType versions we used `__FTERRORS_H__'.  However, */
+  /* using two successive underscores in a non-system symbol name      */
+  /* violates the C (and C++) standard, so it was changed to the       */
+  /* current form.  In spite of this, we have to make                  */
+  /*                                                                   */
+  /*   #undefine __FTERRORS_H__                                        */
+  /*                                                                   */
+  /* work for backward compatibility.                                  */
+  /*                                                                   */
+#if !( defined( FTERRORS_H_ ) && defined ( __FTERRORS_H__ ) )
+#define FTERRORS_H_
+#define __FTERRORS_H__
+
+
+  /* include module base error codes */
+#include FT_MODULE_ERRORS_H
+
+
+  /*******************************************************************/
+  /*******************************************************************/
+  /*****                                                         *****/
+  /*****                       SETUP MACROS                      *****/
+  /*****                                                         *****/
+  /*******************************************************************/
+  /*******************************************************************/
+
+
+#undef  FT_NEED_EXTERN_C
+
+
+  /* FT_ERR_PREFIX is used as a prefix for error identifiers. */
+  /* By default, we use `FT_Err_'.                            */
+  /*                                                          */
+#ifndef FT_ERR_PREFIX
+#define FT_ERR_PREFIX  FT_Err_
+#endif
+
+
+  /* FT_ERR_BASE is used as the base for module-specific errors. */
+  /*                                                             */
+#ifdef FT_CONFIG_OPTION_USE_MODULE_ERRORS
+
+#ifndef FT_ERR_BASE
+#define FT_ERR_BASE  FT_Mod_Err_Base
+#endif
+
+#else
+
+#undef FT_ERR_BASE
+#define FT_ERR_BASE  0
+
+#endif /* FT_CONFIG_OPTION_USE_MODULE_ERRORS */
+
+
+  /* If FT_ERRORDEF is not defined, we need to define a simple */
+  /* enumeration type.                                         */
+  /*                                                           */
+#ifndef FT_ERRORDEF
+
+#define FT_ERRORDEF( e, v, s )  e = v,
+#define FT_ERROR_START_LIST     enum {
+#define FT_ERROR_END_LIST       FT_ERR_CAT( FT_ERR_PREFIX, Max ) };
+
+#ifdef __cplusplus
+#define FT_NEED_EXTERN_C
+  extern "C" {
+#endif
+
+#endif /* !FT_ERRORDEF */
+
+
+  /* this macro is used to define an error */
+#define FT_ERRORDEF_( e, v, s )                                             \
+          FT_ERRORDEF( FT_ERR_CAT( FT_ERR_PREFIX, e ), v + FT_ERR_BASE, s )
+
+  /* this is only used for <module>_Err_Ok, which must be 0! */
+#define FT_NOERRORDEF_( e, v, s )                             \
+          FT_ERRORDEF( FT_ERR_CAT( FT_ERR_PREFIX, e ), v, s )
+
+
+#ifdef FT_ERROR_START_LIST
+  FT_ERROR_START_LIST
+#endif
+
+
+  /* now include the error codes */
+#include FT_ERROR_DEFINITIONS_H
+
+
+#ifdef FT_ERROR_END_LIST
+  FT_ERROR_END_LIST
+#endif
+
+
+  /*******************************************************************/
+  /*******************************************************************/
+  /*****                                                         *****/
+  /*****                      SIMPLE CLEANUP                     *****/
+  /*****                                                         *****/
+  /*******************************************************************/
+  /*******************************************************************/
+
+#ifdef FT_NEED_EXTERN_C
+  }
+#endif
+
+#undef FT_ERROR_START_LIST
+#undef FT_ERROR_END_LIST
+
+#undef FT_ERRORDEF
+#undef FT_ERRORDEF_
+#undef FT_NOERRORDEF_
+
+#undef FT_NEED_EXTERN_C
+#undef FT_ERR_BASE
+
+  /* FT_ERR_PREFIX is needed internally */
+#ifndef FT2_BUILD_LIBRARY
+#undef FT_ERR_PREFIX
+#endif
+
+#endif /* !(FTERRORS_H_ && __FTERRORS_H__) */
+
+
+/* END */
diff --git a/engine/inc/freetype/ftfntfmt.h b/engine/inc/freetype/ftfntfmt.h
new file mode 100644
index 00000000..33775832
--- /dev/null
+++ b/engine/inc/freetype/ftfntfmt.h
@@ -0,0 +1,95 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftfntfmt.h                                                             */
+/*                                                                         */
+/*    Support functions for font formats.                                  */
+/*                                                                         */
+/*  Copyright 2002-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTFNTFMT_H_
+#define FTFNTFMT_H_
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*   font_formats                                                        */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*   Font Formats                                                        */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*   Getting the font format.                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*   The single function in this section can be used to get the font     */
+  /*   format.  Note that this information is not needed normally;         */
+  /*   however, there are special cases (like in PDF devices) where it is  */
+  /*   important to differentiate, in spite of FreeType's uniform API.     */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*   FT_Get_Font_Format                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*   Return a string describing the format of a given face.  Possible    */
+  /*   values are `TrueType', `Type~1', `BDF', `PCF', `Type~42',           */
+  /*   `CID~Type~1', `CFF', `PFR', and `Windows~FNT'.                      */
+  /*                                                                       */
+  /*   The return value is suitable to be used as an X11 FONT_PROPERTY.    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*   face ::                                                             */
+  /*     Input face handle.                                                */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*   Font format string.  NULL in case of error.                         */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*   A deprecated name for the same function is                          */
+  /*   `FT_Get_X11_Font_Format'.                                           */
+  /*                                                                       */
+  FT_EXPORT( const char* )
+  FT_Get_Font_Format( FT_Face  face );
+
+
+  /* deprecated */
+  FT_EXPORT( const char* )
+  FT_Get_X11_Font_Format( FT_Face  face );
+
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* FTFNTFMT_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ftgasp.h b/engine/inc/freetype/ftgasp.h
new file mode 100644
index 00000000..ce18d647
--- /dev/null
+++ b/engine/inc/freetype/ftgasp.h
@@ -0,0 +1,137 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftgasp.h                                                               */
+/*                                                                         */
+/*    Access of TrueType's `gasp' table (specification).                   */
+/*                                                                         */
+/*  Copyright 2007-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTGASP_H_
+#define FTGASP_H_
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+  /***************************************************************************
+   *
+   * @section:
+   *   gasp_table
+   *
+   * @title:
+   *   Gasp Table
+   *
+   * @abstract:
+   *   Retrieving TrueType `gasp' table entries.
+   *
+   * @description:
+   *   The function @FT_Get_Gasp can be used to query a TrueType or OpenType
+   *   font for specific entries in its `gasp' table, if any.  This is
+   *   mainly useful when implementing native TrueType hinting with the
+   *   bytecode interpreter to duplicate the Windows text rendering results.
+   */
+
+  /*************************************************************************
+   *
+   * @enum:
+   *   FT_GASP_XXX
+   *
+   * @description:
+   *   A list of values and/or bit-flags returned by the @FT_Get_Gasp
+   *   function.
+   *
+   * @values:
+   *   FT_GASP_NO_TABLE ::
+   *     This special value means that there is no GASP table in this face.
+   *     It is up to the client to decide what to do.
+   *
+   *   FT_GASP_DO_GRIDFIT ::
+   *     Grid-fitting and hinting should be performed at the specified ppem.
+   *     This *really* means TrueType bytecode interpretation.  If this bit
+   *     is not set, no hinting gets applied.
+   *
+   *   FT_GASP_DO_GRAY ::
+   *     Anti-aliased rendering should be performed at the specified ppem.
+   *     If not set, do monochrome rendering.
+   *
+   *   FT_GASP_SYMMETRIC_SMOOTHING ::
+   *     If set, smoothing along multiple axes must be used with ClearType.
+   *
+   *   FT_GASP_SYMMETRIC_GRIDFIT ::
+   *     Grid-fitting must be used with ClearType's symmetric smoothing.
+   *
+   * @note:
+   *   The bit-flags `FT_GASP_DO_GRIDFIT' and `FT_GASP_DO_GRAY' are to be
+   *   used for standard font rasterization only.  Independently of that,
+   *   `FT_GASP_SYMMETRIC_SMOOTHING' and `FT_GASP_SYMMETRIC_GRIDFIT' are to
+   *   be used if ClearType is enabled (and `FT_GASP_DO_GRIDFIT' and
+   *   `FT_GASP_DO_GRAY' are consequently ignored).
+   *
+   *   `ClearType' is Microsoft's implementation of LCD rendering, partly
+   *   protected by patents.
+   *
+   * @since:
+   *   2.3.0
+   */
+#define FT_GASP_NO_TABLE               -1
+#define FT_GASP_DO_GRIDFIT           0x01
+#define FT_GASP_DO_GRAY              0x02
+#define FT_GASP_SYMMETRIC_GRIDFIT    0x04
+#define FT_GASP_SYMMETRIC_SMOOTHING  0x08
+
+
+  /*************************************************************************
+   *
+   * @func:
+   *   FT_Get_Gasp
+   *
+   * @description:
+   *   For a TrueType or OpenType font file, return the rasterizer behaviour
+   *   flags from the font's `gasp' table corresponding to a given
+   *   character pixel size.
+   *
+   * @input:
+   *   face :: The source face handle.
+   *
+   *   ppem :: The vertical character pixel size.
+   *
+   * @return:
+   *   Bit flags (see @FT_GASP_XXX), or @FT_GASP_NO_TABLE if there is no
+   *   `gasp' table in the face.
+   *
+   * @note:
+   *   If you want to use the MM functionality of OpenType variation fonts
+   *   (i.e., using @FT_Set_Var_Design_Coordinates and friends), call this
+   *   function *after* setting an instance since the return values can
+   *   change.
+   *
+   * @since:
+   *   2.3.0
+   */
+  FT_EXPORT( FT_Int )
+  FT_Get_Gasp( FT_Face  face,
+               FT_UInt  ppem );
+
+  /* */
+
+
+#endif /* FTGASP_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ftglyph.h b/engine/inc/freetype/ftglyph.h
new file mode 100644
index 00000000..db1a2c8b
--- /dev/null
+++ b/engine/inc/freetype/ftglyph.h
@@ -0,0 +1,614 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftglyph.h                                                              */
+/*                                                                         */
+/*    FreeType convenience functions to handle glyphs (specification).     */
+/*                                                                         */
+/*  Copyright 1996-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This file contains the definition of several convenience functions    */
+  /* that can be used by client applications to easily retrieve glyph      */
+  /* bitmaps and outlines from a given face.                               */
+  /*                                                                       */
+  /* These functions should be optional if you are writing a font server   */
+  /* or text layout engine on top of FreeType.  However, they are pretty   */
+  /* handy for many other simple uses of the library.                      */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#ifndef FTGLYPH_H_
+#define FTGLYPH_H_
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    glyph_management                                                   */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    Glyph Management                                                   */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    Generic interface to manage individual glyph data.                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains definitions used to manage glyph data        */
+  /*    through generic FT_Glyph objects.  Each of them can contain a      */
+  /*    bitmap, a vector outline, or even images in other formats.         */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /* forward declaration to a private type */
+  typedef struct FT_Glyph_Class_  FT_Glyph_Class;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Glyph                                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Handle to an object used to model generic glyph images.  It is a   */
+  /*    pointer to the @FT_GlyphRec structure and can contain a glyph      */
+  /*    bitmap or pointer.                                                 */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Glyph objects are not owned by the library.  You must thus release */
+  /*    them manually (through @FT_Done_Glyph) _before_ calling            */
+  /*    @FT_Done_FreeType.                                                 */
+  /*                                                                       */
+  typedef struct FT_GlyphRec_*  FT_Glyph;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_GlyphRec                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The root glyph structure contains a given glyph image plus its     */
+  /*    advance width in 16.16 fixed-point format.                         */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    library :: A handle to the FreeType library object.                */
+  /*                                                                       */
+  /*    clazz   :: A pointer to the glyph's class.  Private.               */
+  /*                                                                       */
+  /*    format  :: The format of the glyph's image.                        */
+  /*                                                                       */
+  /*    advance :: A 16.16 vector that gives the glyph's advance width.    */
+  /*                                                                       */
+  typedef struct  FT_GlyphRec_
+  {
+    FT_Library             library;
+    const FT_Glyph_Class*  clazz;
+    FT_Glyph_Format        format;
+    FT_Vector              advance;
+
+  } FT_GlyphRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_BitmapGlyph                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to an object used to model a bitmap glyph image.  This is */
+  /*    a sub-class of @FT_Glyph, and a pointer to @FT_BitmapGlyphRec.     */
+  /*                                                                       */
+  typedef struct FT_BitmapGlyphRec_*  FT_BitmapGlyph;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_BitmapGlyphRec                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used for bitmap glyph images.  This really is a        */
+  /*    `sub-class' of @FT_GlyphRec.                                       */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    root   :: The root @FT_Glyph fields.                               */
+  /*                                                                       */
+  /*    left   :: The left-side bearing, i.e., the horizontal distance     */
+  /*              from the current pen position to the left border of the  */
+  /*              glyph bitmap.                                            */
+  /*                                                                       */
+  /*    top    :: The top-side bearing, i.e., the vertical distance from   */
+  /*              the current pen position to the top border of the glyph  */
+  /*              bitmap.  This distance is positive for upwards~y!        */
+  /*                                                                       */
+  /*    bitmap :: A descriptor for the bitmap.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    You can typecast an @FT_Glyph to @FT_BitmapGlyph if you have       */
+  /*    `glyph->format == FT_GLYPH_FORMAT_BITMAP'.  This lets you access   */
+  /*    the bitmap's contents easily.                                      */
+  /*                                                                       */
+  /*    The corresponding pixel buffer is always owned by @FT_BitmapGlyph  */
+  /*    and is thus created and destroyed with it.                         */
+  /*                                                                       */
+  typedef struct  FT_BitmapGlyphRec_
+  {
+    FT_GlyphRec  root;
+    FT_Int       left;
+    FT_Int       top;
+    FT_Bitmap    bitmap;
+
+  } FT_BitmapGlyphRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_OutlineGlyph                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to an object used to model an outline glyph image.  This  */
+  /*    is a sub-class of @FT_Glyph, and a pointer to @FT_OutlineGlyphRec. */
+  /*                                                                       */
+  typedef struct FT_OutlineGlyphRec_*  FT_OutlineGlyph;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_OutlineGlyphRec                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used for outline (vectorial) glyph images.  This       */
+  /*    really is a `sub-class' of @FT_GlyphRec.                           */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    root    :: The root @FT_Glyph fields.                              */
+  /*                                                                       */
+  /*    outline :: A descriptor for the outline.                           */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    You can typecast an @FT_Glyph to @FT_OutlineGlyph if you have      */
+  /*    `glyph->format == FT_GLYPH_FORMAT_OUTLINE'.  This lets you access  */
+  /*    the outline's content easily.                                      */
+  /*                                                                       */
+  /*    As the outline is extracted from a glyph slot, its coordinates are */
+  /*    expressed normally in 26.6 pixels, unless the flag                 */
+  /*    @FT_LOAD_NO_SCALE was used in @FT_Load_Glyph() or @FT_Load_Char(). */
+  /*                                                                       */
+  /*    The outline's tables are always owned by the object and are        */
+  /*    destroyed with it.                                                 */
+  /*                                                                       */
+  typedef struct  FT_OutlineGlyphRec_
+  {
+    FT_GlyphRec  root;
+    FT_Outline   outline;
+
+  } FT_OutlineGlyphRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Glyph                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function used to extract a glyph image from a slot.  Note that   */
+  /*    the created @FT_Glyph object must be released with @FT_Done_Glyph. */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    slot   :: A handle to the source glyph slot.                       */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    aglyph :: A handle to the glyph object.                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Because `*aglyph->advance.x' and '*aglyph->advance.y' are 16.16    */
+  /*    fixed-point numbers, `slot->advance.x' and `slot->advance.y'       */
+  /*    (which are in 26.6 fixed-point format) must be in the range        */
+  /*    ]-32768;32768[.                                                    */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Get_Glyph( FT_GlyphSlot  slot,
+                FT_Glyph     *aglyph );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Glyph_Copy                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function used to copy a glyph image.  Note that the created      */
+  /*    @FT_Glyph object must be released with @FT_Done_Glyph.             */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    source :: A handle to the source glyph object.                     */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    target :: A handle to the target glyph object.  0~in case of       */
+  /*              error.                                                   */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Glyph_Copy( FT_Glyph   source,
+                 FT_Glyph  *target );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Glyph_Transform                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Transform a glyph image if its format is scalable.                 */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    glyph  :: A handle to the target glyph object.                     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    matrix :: A pointer to a 2x2 matrix to apply.                      */
+  /*                                                                       */
+  /*    delta  :: A pointer to a 2d vector to apply.  Coordinates are      */
+  /*              expressed in 1/64th of a pixel.                          */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code (if not 0, the glyph format is not scalable).  */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The 2x2 transformation matrix is also applied to the glyph's       */
+  /*    advance vector.                                                    */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Glyph_Transform( FT_Glyph    glyph,
+                      FT_Matrix*  matrix,
+                      FT_Vector*  delta );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    FT_Glyph_BBox_Mode                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The mode how the values of @FT_Glyph_Get_CBox are returned.        */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    FT_GLYPH_BBOX_UNSCALED ::                                          */
+  /*      Return unscaled font units.                                      */
+  /*                                                                       */
+  /*    FT_GLYPH_BBOX_SUBPIXELS ::                                         */
+  /*      Return unfitted 26.6 coordinates.                                */
+  /*                                                                       */
+  /*    FT_GLYPH_BBOX_GRIDFIT ::                                           */
+  /*      Return grid-fitted 26.6 coordinates.                             */
+  /*                                                                       */
+  /*    FT_GLYPH_BBOX_TRUNCATE ::                                          */
+  /*      Return coordinates in integer pixels.                            */
+  /*                                                                       */
+  /*    FT_GLYPH_BBOX_PIXELS ::                                            */
+  /*      Return grid-fitted pixel coordinates.                            */
+  /*                                                                       */
+  typedef enum  FT_Glyph_BBox_Mode_
+  {
+    FT_GLYPH_BBOX_UNSCALED  = 0,
+    FT_GLYPH_BBOX_SUBPIXELS = 0,
+    FT_GLYPH_BBOX_GRIDFIT   = 1,
+    FT_GLYPH_BBOX_TRUNCATE  = 2,
+    FT_GLYPH_BBOX_PIXELS    = 3
+
+  } FT_Glyph_BBox_Mode;
+
+
+  /* these constants are deprecated; use the corresponding */
+  /* `FT_Glyph_BBox_Mode' values instead                   */
+#define ft_glyph_bbox_unscaled   FT_GLYPH_BBOX_UNSCALED
+#define ft_glyph_bbox_subpixels  FT_GLYPH_BBOX_SUBPIXELS
+#define ft_glyph_bbox_gridfit    FT_GLYPH_BBOX_GRIDFIT
+#define ft_glyph_bbox_truncate   FT_GLYPH_BBOX_TRUNCATE
+#define ft_glyph_bbox_pixels     FT_GLYPH_BBOX_PIXELS
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Glyph_Get_CBox                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Return a glyph's `control box'.  The control box encloses all the  */
+  /*    outline's points, including Bézier control points.  Though it      */
+  /*    coincides with the exact bounding box for most glyphs, it can be   */
+  /*    slightly larger in some situations (like when rotating an outline  */
+  /*    that contains Bézier outside arcs).                                */
+  /*                                                                       */
+  /*    Computing the control box is very fast, while getting the bounding */
+  /*    box can take much more time as it needs to walk over all segments  */
+  /*    and arcs in the outline.  To get the latter, you can use the       */
+  /*    `ftbbox' component, which is dedicated to this single task.        */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    glyph :: A handle to the source glyph object.                      */
+  /*                                                                       */
+  /*    mode  :: The mode that indicates how to interpret the returned     */
+  /*             bounding box values.                                      */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    acbox :: The glyph coordinate bounding box.  Coordinates are       */
+  /*             expressed in 1/64th of pixels if it is grid-fitted.       */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Coordinates are relative to the glyph origin, using the y~upwards  */
+  /*    convention.                                                        */
+  /*                                                                       */
+  /*    If the glyph has been loaded with @FT_LOAD_NO_SCALE, `bbox_mode'   */
+  /*    must be set to @FT_GLYPH_BBOX_UNSCALED to get unscaled font        */
+  /*    units in 26.6 pixel format.  The value @FT_GLYPH_BBOX_SUBPIXELS    */
+  /*    is another name for this constant.                                 */
+  /*                                                                       */
+  /*    If the font is tricky and the glyph has been loaded with           */
+  /*    @FT_LOAD_NO_SCALE, the resulting CBox is meaningless.  To get      */
+  /*    reasonable values for the CBox it is necessary to load the glyph   */
+  /*    at a large ppem value (so that the hinting instructions can        */
+  /*    properly shift and scale the subglyphs), then extracting the CBox, */
+  /*    which can be eventually converted back to font units.              */
+  /*                                                                       */
+  /*    Note that the maximum coordinates are exclusive, which means that  */
+  /*    one can compute the width and height of the glyph image (be it in  */
+  /*    integer or 26.6 pixels) as:                                        */
+  /*                                                                       */
+  /*    {                                                                  */
+  /*      width  = bbox.xMax - bbox.xMin;                                  */
+  /*      height = bbox.yMax - bbox.yMin;                                  */
+  /*    }                                                                  */
+  /*                                                                       */
+  /*    Note also that for 26.6 coordinates, if `bbox_mode' is set to      */
+  /*    @FT_GLYPH_BBOX_GRIDFIT, the coordinates will also be grid-fitted,  */
+  /*    which corresponds to:                                              */
+  /*                                                                       */
+  /*    {                                                                  */
+  /*      bbox.xMin = FLOOR(bbox.xMin);                                    */
+  /*      bbox.yMin = FLOOR(bbox.yMin);                                    */
+  /*      bbox.xMax = CEILING(bbox.xMax);                                  */
+  /*      bbox.yMax = CEILING(bbox.yMax);                                  */
+  /*    }                                                                  */
+  /*                                                                       */
+  /*    To get the bbox in pixel coordinates, set `bbox_mode' to           */
+  /*    @FT_GLYPH_BBOX_TRUNCATE.                                           */
+  /*                                                                       */
+  /*    To get the bbox in grid-fitted pixel coordinates, set `bbox_mode'  */
+  /*    to @FT_GLYPH_BBOX_PIXELS.                                          */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Glyph_Get_CBox( FT_Glyph  glyph,
+                     FT_UInt   bbox_mode,
+                     FT_BBox  *acbox );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Glyph_To_Bitmap                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Convert a given glyph object to a bitmap glyph object.             */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    the_glyph   :: A pointer to a handle to the target glyph.          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    render_mode :: An enumeration that describes how the data is       */
+  /*                   rendered.                                           */
+  /*                                                                       */
+  /*    origin      :: A pointer to a vector used to translate the glyph   */
+  /*                   image before rendering.  Can be~0 (if no            */
+  /*                   translation).  The origin is expressed in           */
+  /*                   26.6 pixels.                                        */
+  /*                                                                       */
+  /*    destroy     :: A boolean that indicates that the original glyph    */
+  /*                   image should be destroyed by this function.  It is  */
+  /*                   never destroyed in case of error.                   */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This function does nothing if the glyph format isn't scalable.     */
+  /*                                                                       */
+  /*    The glyph image is translated with the `origin' vector before      */
+  /*    rendering.                                                         */
+  /*                                                                       */
+  /*    The first parameter is a pointer to an @FT_Glyph handle, that will */
+  /*    be _replaced_ by this function (with newly allocated data).        */
+  /*    Typically, you would use (omitting error handling):                */
+  /*                                                                       */
+  /*                                                                       */
+  /*      {                                                                */
+  /*        FT_Glyph        glyph;                                         */
+  /*        FT_BitmapGlyph  glyph_bitmap;                                  */
+  /*                                                                       */
+  /*                                                                       */
+  /*        // load glyph                                                  */
+  /*        error = FT_Load_Char( face, glyph_index, FT_LOAD_DEFAULT );    */
+  /*                                                                       */
+  /*        // extract glyph image                                         */
+  /*        error = FT_Get_Glyph( face->glyph, &glyph );                   */
+  /*                                                                       */
+  /*        // convert to a bitmap (default render mode + destroying old)  */
+  /*        if ( glyph->format != FT_GLYPH_FORMAT_BITMAP )                 */
+  /*        {                                                              */
+  /*          error = FT_Glyph_To_Bitmap( &glyph, FT_RENDER_MODE_NORMAL,   */
+  /*                                      0, 1 );                          */
+  /*          if ( error ) // `glyph' unchanged                            */
+  /*            ...                                                        */
+  /*        }                                                              */
+  /*                                                                       */
+  /*        // access bitmap content by typecasting                        */
+  /*        glyph_bitmap = (FT_BitmapGlyph)glyph;                          */
+  /*                                                                       */
+  /*        // do funny stuff with it, like blitting/drawing               */
+  /*        ...                                                            */
+  /*                                                                       */
+  /*        // discard glyph image (bitmap or not)                         */
+  /*        FT_Done_Glyph( glyph );                                        */
+  /*      }                                                                */
+  /*                                                                       */
+  /*                                                                       */
+  /*    Here another example, again without error handling:                */
+  /*                                                                       */
+  /*                                                                       */
+  /*      {                                                                */
+  /*        FT_Glyph  glyphs[MAX_GLYPHS]                                   */
+  /*                                                                       */
+  /*                                                                       */
+  /*        ...                                                            */
+  /*                                                                       */
+  /*        for ( idx = 0; i < MAX_GLYPHS; i++ )                           */
+  /*          error = FT_Load_Glyph( face, idx, FT_LOAD_DEFAULT ) ||       */
+  /*                  FT_Get_Glyph ( face->glyph, &glyph[idx] );           */
+  /*                                                                       */
+  /*        ...                                                            */
+  /*                                                                       */
+  /*        for ( idx = 0; i < MAX_GLYPHS; i++ )                           */
+  /*        {                                                              */
+  /*          FT_Glyph  bitmap = glyphs[idx];                              */
+  /*                                                                       */
+  /*                                                                       */
+  /*          ...                                                          */
+  /*                                                                       */
+  /*          // after this call, `bitmap' no longer points into           */
+  /*          // the `glyphs' array (and the old value isn't destroyed)    */
+  /*          FT_Glyph_To_Bitmap( &bitmap, FT_RENDER_MODE_MONO, 0, 0 );    */
+  /*                                                                       */
+  /*          ...                                                          */
+  /*                                                                       */
+  /*          FT_Done_Glyph( bitmap );                                     */
+  /*        }                                                              */
+  /*                                                                       */
+  /*        ...                                                            */
+  /*                                                                       */
+  /*        for ( idx = 0; i < MAX_GLYPHS; i++ )                           */
+  /*          FT_Done_Glyph( glyphs[idx] );                                */
+  /*      }                                                                */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Glyph_To_Bitmap( FT_Glyph*       the_glyph,
+                      FT_Render_Mode  render_mode,
+                      FT_Vector*      origin,
+                      FT_Bool         destroy );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Done_Glyph                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Destroy a given glyph.                                             */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    glyph :: A handle to the target glyph object.                      */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Done_Glyph( FT_Glyph  glyph );
+
+  /* */
+
+
+  /* other helpful functions */
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    computations                                                       */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Matrix_Multiply                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Perform the matrix operation `b = a*b'.                            */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    a :: A pointer to matrix `a'.                                      */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    b :: A pointer to matrix `b'.                                      */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The result is undefined if either `a' or `b' is zero.              */
+  /*                                                                       */
+  /*    Since the function uses wrap-around arithmetic, results become     */
+  /*    meaningless if the arguments are very large.                       */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Matrix_Multiply( const FT_Matrix*  a,
+                      FT_Matrix*        b );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Matrix_Invert                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Invert a 2x2 matrix.  Return an error if it can't be inverted.     */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    matrix :: A pointer to the target matrix.  Remains untouched in    */
+  /*              case of error.                                           */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Matrix_Invert( FT_Matrix*  matrix );
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* FTGLYPH_H_ */
+
+
+/* END */
+
+
+/* Local Variables: */
+/* coding: utf-8    */
+/* End:             */
diff --git a/engine/inc/freetype/ftgxval.h b/engine/inc/freetype/ftgxval.h
new file mode 100644
index 00000000..f239c71e
--- /dev/null
+++ b/engine/inc/freetype/ftgxval.h
@@ -0,0 +1,357 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftgxval.h                                                              */
+/*                                                                         */
+/*    FreeType API for validating TrueTypeGX/AAT tables (specification).   */
+/*                                                                         */
+/*  Copyright 2004-2017 by                                                 */
+/*  Masatake YAMATO, Redhat K.K,                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+/***************************************************************************/
+/*                                                                         */
+/* gxvalid is derived from both gxlayout module and otvalid module.        */
+/* Development of gxlayout is supported by the Information-technology      */
+/* Promotion Agency(IPA), Japan.                                           */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTGXVAL_H_
+#define FTGXVAL_H_
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    gx_validation                                                      */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    TrueTypeGX/AAT Validation                                          */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    An API to validate TrueTypeGX/AAT tables.                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains the declaration of functions to validate     */
+  /*    some TrueTypeGX tables (feat, mort, morx, bsln, just, kern, opbd,  */
+  /*    trak, prop, lcar).                                                 */
+  /*                                                                       */
+  /* <Order>                                                               */
+  /*    FT_TrueTypeGX_Validate                                             */
+  /*    FT_TrueTypeGX_Free                                                 */
+  /*                                                                       */
+  /*    FT_ClassicKern_Validate                                            */
+  /*    FT_ClassicKern_Free                                                */
+  /*                                                                       */
+  /*    FT_VALIDATE_GX_LENGTH                                              */
+  /*    FT_VALIDATE_GXXXX                                                  */
+  /*    FT_VALIDATE_CKERNXXX                                               */
+  /*                                                                       */
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*                                                                       */
+  /* Warning: Use FT_VALIDATE_XXX to validate a table.                     */
+  /*          Following definitions are for gxvalid developers.            */
+  /*                                                                       */
+  /*                                                                       */
+  /*************************************************************************/
+
+#define FT_VALIDATE_feat_INDEX     0
+#define FT_VALIDATE_mort_INDEX     1
+#define FT_VALIDATE_morx_INDEX     2
+#define FT_VALIDATE_bsln_INDEX     3
+#define FT_VALIDATE_just_INDEX     4
+#define FT_VALIDATE_kern_INDEX     5
+#define FT_VALIDATE_opbd_INDEX     6
+#define FT_VALIDATE_trak_INDEX     7
+#define FT_VALIDATE_prop_INDEX     8
+#define FT_VALIDATE_lcar_INDEX     9
+#define FT_VALIDATE_GX_LAST_INDEX  FT_VALIDATE_lcar_INDEX
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_VALIDATE_GX_LENGTH
+   *
+   * @description:
+   *   The number of tables checked in this module.  Use it as a parameter
+   *   for the `table-length' argument of function @FT_TrueTypeGX_Validate.
+   */
+#define FT_VALIDATE_GX_LENGTH     (FT_VALIDATE_GX_LAST_INDEX + 1)
+
+  /* */
+
+  /* Up to 0x1000 is used by otvalid.
+     Ox2xxx is reserved for feature OT extension. */
+#define FT_VALIDATE_GX_START 0x4000
+#define FT_VALIDATE_GX_BITFIELD( tag )                  \
+  ( FT_VALIDATE_GX_START << FT_VALIDATE_##tag##_INDEX )
+
+
+ /**********************************************************************
+  *
+  * @enum:
+  *    FT_VALIDATE_GXXXX
+  *
+  * @description:
+  *    A list of bit-field constants used with @FT_TrueTypeGX_Validate to
+  *    indicate which TrueTypeGX/AAT Type tables should be validated.
+  *
+  * @values:
+  *    FT_VALIDATE_feat ::
+  *      Validate `feat' table.
+  *
+  *    FT_VALIDATE_mort ::
+  *      Validate `mort' table.
+  *
+  *    FT_VALIDATE_morx ::
+  *      Validate `morx' table.
+  *
+  *    FT_VALIDATE_bsln ::
+  *      Validate `bsln' table.
+  *
+  *    FT_VALIDATE_just ::
+  *      Validate `just' table.
+  *
+  *    FT_VALIDATE_kern ::
+  *      Validate `kern' table.
+  *
+  *    FT_VALIDATE_opbd ::
+  *      Validate `opbd' table.
+  *
+  *    FT_VALIDATE_trak ::
+  *      Validate `trak' table.
+  *
+  *    FT_VALIDATE_prop ::
+  *      Validate `prop' table.
+  *
+  *    FT_VALIDATE_lcar ::
+  *      Validate `lcar' table.
+  *
+  *    FT_VALIDATE_GX ::
+  *      Validate all TrueTypeGX tables (feat, mort, morx, bsln, just, kern,
+  *      opbd, trak, prop and lcar).
+  *
+  */
+
+#define FT_VALIDATE_feat  FT_VALIDATE_GX_BITFIELD( feat )
+#define FT_VALIDATE_mort  FT_VALIDATE_GX_BITFIELD( mort )
+#define FT_VALIDATE_morx  FT_VALIDATE_GX_BITFIELD( morx )
+#define FT_VALIDATE_bsln  FT_VALIDATE_GX_BITFIELD( bsln )
+#define FT_VALIDATE_just  FT_VALIDATE_GX_BITFIELD( just )
+#define FT_VALIDATE_kern  FT_VALIDATE_GX_BITFIELD( kern )
+#define FT_VALIDATE_opbd  FT_VALIDATE_GX_BITFIELD( opbd )
+#define FT_VALIDATE_trak  FT_VALIDATE_GX_BITFIELD( trak )
+#define FT_VALIDATE_prop  FT_VALIDATE_GX_BITFIELD( prop )
+#define FT_VALIDATE_lcar  FT_VALIDATE_GX_BITFIELD( lcar )
+
+#define FT_VALIDATE_GX  ( FT_VALIDATE_feat | \
+                          FT_VALIDATE_mort | \
+                          FT_VALIDATE_morx | \
+                          FT_VALIDATE_bsln | \
+                          FT_VALIDATE_just | \
+                          FT_VALIDATE_kern | \
+                          FT_VALIDATE_opbd | \
+                          FT_VALIDATE_trak | \
+                          FT_VALIDATE_prop | \
+                          FT_VALIDATE_lcar )
+
+
+ /**********************************************************************
+  *
+  * @function:
+  *    FT_TrueTypeGX_Validate
+  *
+  * @description:
+  *    Validate various TrueTypeGX tables to assure that all offsets and
+  *    indices are valid.  The idea is that a higher-level library that
+  *    actually does the text layout can access those tables without
+  *    error checking (which can be quite time consuming).
+  *
+  * @input:
+  *    face ::
+  *       A handle to the input face.
+  *
+  *    validation_flags ::
+  *       A bit field that specifies the tables to be validated.  See
+  *       @FT_VALIDATE_GXXXX for possible values.
+  *
+  *    table_length ::
+  *       The size of the `tables' array.  Normally, @FT_VALIDATE_GX_LENGTH
+  *       should be passed.
+  *
+  * @output:
+  *    tables ::
+  *       The array where all validated sfnt tables are stored.
+  *       The array itself must be allocated by a client.
+  *
+  * @return:
+  *   FreeType error code.  0~means success.
+  *
+  * @note:
+  *   This function only works with TrueTypeGX fonts, returning an error
+  *   otherwise.
+  *
+  *   After use, the application should deallocate the buffers pointed to by
+  *   each `tables' element, by calling @FT_TrueTypeGX_Free.  A NULL value
+  *   indicates that the table either doesn't exist in the font, the
+  *   application hasn't asked for validation, or the validator doesn't have
+  *   the ability to validate the sfnt table.
+  */
+  FT_EXPORT( FT_Error )
+  FT_TrueTypeGX_Validate( FT_Face   face,
+                          FT_UInt   validation_flags,
+                          FT_Bytes  tables[FT_VALIDATE_GX_LENGTH],
+                          FT_UInt   table_length );
+
+
+ /**********************************************************************
+  *
+  * @function:
+  *    FT_TrueTypeGX_Free
+  *
+  * @description:
+  *    Free the buffer allocated by TrueTypeGX validator.
+  *
+  * @input:
+  *    face ::
+  *       A handle to the input face.
+  *
+  *    table ::
+  *       The pointer to the buffer allocated by
+  *       @FT_TrueTypeGX_Validate.
+  *
+  * @note:
+  *   This function must be used to free the buffer allocated by
+  *   @FT_TrueTypeGX_Validate only.
+  */
+  FT_EXPORT( void )
+  FT_TrueTypeGX_Free( FT_Face   face,
+                      FT_Bytes  table );
+
+
+ /**********************************************************************
+  *
+  * @enum:
+  *    FT_VALIDATE_CKERNXXX
+  *
+  * @description:
+  *    A list of bit-field constants used with @FT_ClassicKern_Validate
+  *    to indicate the classic kern dialect or dialects.  If the selected
+  *    type doesn't fit, @FT_ClassicKern_Validate regards the table as
+  *    invalid.
+  *
+  * @values:
+  *    FT_VALIDATE_MS ::
+  *      Handle the `kern' table as a classic Microsoft kern table.
+  *
+  *    FT_VALIDATE_APPLE ::
+  *      Handle the `kern' table as a classic Apple kern table.
+  *
+  *    FT_VALIDATE_CKERN ::
+  *      Handle the `kern' as either classic Apple or Microsoft kern table.
+  */
+#define FT_VALIDATE_MS     ( FT_VALIDATE_GX_START << 0 )
+#define FT_VALIDATE_APPLE  ( FT_VALIDATE_GX_START << 1 )
+
+#define FT_VALIDATE_CKERN  ( FT_VALIDATE_MS | FT_VALIDATE_APPLE )
+
+
+ /**********************************************************************
+  *
+  * @function:
+  *    FT_ClassicKern_Validate
+  *
+  * @description:
+  *    Validate classic (16-bit format) kern table to assure that the offsets
+  *    and indices are valid.  The idea is that a higher-level library that
+  *    actually does the text layout can access those tables without error
+  *    checking (which can be quite time consuming).
+  *
+  *    The `kern' table validator in @FT_TrueTypeGX_Validate deals with both
+  *    the new 32-bit format and the classic 16-bit format, while
+  *    FT_ClassicKern_Validate only supports the classic 16-bit format.
+  *
+  * @input:
+  *    face ::
+  *       A handle to the input face.
+  *
+  *    validation_flags ::
+  *       A bit field that specifies the dialect to be validated.  See
+  *       @FT_VALIDATE_CKERNXXX for possible values.
+  *
+  * @output:
+  *    ckern_table ::
+  *       A pointer to the kern table.
+  *
+  * @return:
+  *   FreeType error code.  0~means success.
+  *
+  * @note:
+  *   After use, the application should deallocate the buffers pointed to by
+  *   `ckern_table', by calling @FT_ClassicKern_Free.  A NULL value
+  *   indicates that the table doesn't exist in the font.
+  */
+  FT_EXPORT( FT_Error )
+  FT_ClassicKern_Validate( FT_Face    face,
+                           FT_UInt    validation_flags,
+                           FT_Bytes  *ckern_table );
+
+
+ /**********************************************************************
+  *
+  * @function:
+  *    FT_ClassicKern_Free
+  *
+  * @description:
+  *    Free the buffer allocated by classic Kern validator.
+  *
+  * @input:
+  *    face ::
+  *       A handle to the input face.
+  *
+  *    table ::
+  *       The pointer to the buffer that is allocated by
+  *       @FT_ClassicKern_Validate.
+  *
+  * @note:
+  *   This function must be used to free the buffer allocated by
+  *   @FT_ClassicKern_Validate only.
+  */
+  FT_EXPORT( void )
+  FT_ClassicKern_Free( FT_Face   face,
+                       FT_Bytes  table );
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* FTGXVAL_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ftgzip.h b/engine/inc/freetype/ftgzip.h
new file mode 100644
index 00000000..bd5ceaab
--- /dev/null
+++ b/engine/inc/freetype/ftgzip.h
@@ -0,0 +1,148 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftgzip.h                                                               */
+/*                                                                         */
+/*    Gzip-compressed stream support.                                      */
+/*                                                                         */
+/*  Copyright 2002-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTGZIP_H_
+#define FTGZIP_H_
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    gzip                                                               */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    GZIP Streams                                                       */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    Using gzip-compressed font files.                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains the declaration of Gzip-specific functions.  */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+ /************************************************************************
+  *
+  * @function:
+  *   FT_Stream_OpenGzip
+  *
+  * @description:
+  *   Open a new stream to parse gzip-compressed font files.  This is
+  *   mainly used to support the compressed `*.pcf.gz' fonts that come
+  *   with XFree86.
+  *
+  * @input:
+  *   stream ::
+  *     The target embedding stream.
+  *
+  *   source ::
+  *     The source stream.
+  *
+  * @return:
+  *   FreeType error code.  0~means success.
+  *
+  * @note:
+  *   The source stream must be opened _before_ calling this function.
+  *
+  *   Calling the internal function `FT_Stream_Close' on the new stream will
+  *   *not* call `FT_Stream_Close' on the source stream.  None of the stream
+  *   objects will be released to the heap.
+  *
+  *   The stream implementation is very basic and resets the decompression
+  *   process each time seeking backwards is needed within the stream.
+  *
+  *   In certain builds of the library, gzip compression recognition is
+  *   automatically handled when calling @FT_New_Face or @FT_Open_Face.
+  *   This means that if no font driver is capable of handling the raw
+  *   compressed file, the library will try to open a gzipped stream from
+  *   it and re-open the face with it.
+  *
+  *   This function may return `FT_Err_Unimplemented_Feature' if your build
+  *   of FreeType was not compiled with zlib support.
+  */
+  FT_EXPORT( FT_Error )
+  FT_Stream_OpenGzip( FT_Stream  stream,
+                      FT_Stream  source );
+
+
+ /************************************************************************
+  *
+  * @function:
+  *   FT_Gzip_Uncompress
+  *
+  * @description:
+  *   Decompress a zipped input buffer into an output buffer.  This function
+  *   is modeled after zlib's `uncompress' function.
+  *
+  * @input:
+  *   memory ::
+  *     A FreeType memory handle.
+  *
+  *   input ::
+  *     The input buffer.
+  *
+  *   input_len ::
+  *     The length of the input buffer.
+  *
+  * @output:
+  *   output::
+  *     The output buffer.
+  *
+  * @inout:
+  *   output_len ::
+  *     Before calling the function, this is the total size of the output
+  *     buffer, which must be large enough to hold the entire uncompressed
+  *     data (so the size of the uncompressed data must be known in
+  *     advance).  After calling the function, `output_len' is the size of
+  *     the used data in `output'.
+  *
+  * @return:
+  *   FreeType error code.  0~means success.
+  *
+  * @note:
+  *   This function may return `FT_Err_Unimplemented_Feature' if your build
+  *   of FreeType was not compiled with zlib support.
+  */
+  FT_EXPORT( FT_Error )
+  FT_Gzip_Uncompress( FT_Memory       memory,
+                      FT_Byte*        output,
+                      FT_ULong*       output_len,
+                      const FT_Byte*  input,
+                      FT_ULong        input_len );
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* FTGZIP_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ftimage.h b/engine/inc/freetype/ftimage.h
new file mode 100644
index 00000000..1c789e5a
--- /dev/null
+++ b/engine/inc/freetype/ftimage.h
@@ -0,0 +1,1205 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftimage.h                                                              */
+/*                                                                         */
+/*    FreeType glyph image formats and default raster interface            */
+/*    (specification).                                                     */
+/*                                                                         */
+/*  Copyright 1996-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Note: A `raster' is simply a scan-line converter, used to render      */
+  /*       FT_Outlines into FT_Bitmaps.                                    */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#ifndef FTIMAGE_H_
+#define FTIMAGE_H_
+
+
+  /* STANDALONE_ is from ftgrays.c */
+#ifndef STANDALONE_
+#include <ft2build.h>
+#endif
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    basic_types                                                        */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Pos                                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The type FT_Pos is used to store vectorial coordinates.  Depending */
+  /*    on the context, these can represent distances in integer font      */
+  /*    units, or 16.16, or 26.6 fixed-point pixel coordinates.            */
+  /*                                                                       */
+  typedef signed long  FT_Pos;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Vector                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A simple structure used to store a 2D vector; coordinates are of   */
+  /*    the FT_Pos type.                                                   */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    x :: The horizontal coordinate.                                    */
+  /*    y :: The vertical coordinate.                                      */
+  /*                                                                       */
+  typedef struct  FT_Vector_
+  {
+    FT_Pos  x;
+    FT_Pos  y;
+
+  } FT_Vector;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_BBox                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to hold an outline's bounding box, i.e., the      */
+  /*    coordinates of its extrema in the horizontal and vertical          */
+  /*    directions.                                                        */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    xMin :: The horizontal minimum (left-most).                        */
+  /*                                                                       */
+  /*    yMin :: The vertical minimum (bottom-most).                        */
+  /*                                                                       */
+  /*    xMax :: The horizontal maximum (right-most).                       */
+  /*                                                                       */
+  /*    yMax :: The vertical maximum (top-most).                           */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The bounding box is specified with the coordinates of the lower    */
+  /*    left and the upper right corner.  In PostScript, those values are  */
+  /*    often called (llx,lly) and (urx,ury), respectively.                */
+  /*                                                                       */
+  /*    If `yMin' is negative, this value gives the glyph's descender.     */
+  /*    Otherwise, the glyph doesn't descend below the baseline.           */
+  /*    Similarly, if `ymax' is positive, this value gives the glyph's     */
+  /*    ascender.                                                          */
+  /*                                                                       */
+  /*    `xMin' gives the horizontal distance from the glyph's origin to    */
+  /*    the left edge of the glyph's bounding box.  If `xMin' is negative, */
+  /*    the glyph extends to the left of the origin.                       */
+  /*                                                                       */
+  typedef struct  FT_BBox_
+  {
+    FT_Pos  xMin, yMin;
+    FT_Pos  xMax, yMax;
+
+  } FT_BBox;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    FT_Pixel_Mode                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An enumeration type used to describe the format of pixels in a     */
+  /*    given bitmap.  Note that additional formats may be added in the    */
+  /*    future.                                                            */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    FT_PIXEL_MODE_NONE ::                                              */
+  /*      Value~0 is reserved.                                             */
+  /*                                                                       */
+  /*    FT_PIXEL_MODE_MONO ::                                              */
+  /*      A monochrome bitmap, using 1~bit per pixel.  Note that pixels    */
+  /*      are stored in most-significant order (MSB), which means that     */
+  /*      the left-most pixel in a byte has value 128.                     */
+  /*                                                                       */
+  /*    FT_PIXEL_MODE_GRAY ::                                              */
+  /*      An 8-bit bitmap, generally used to represent anti-aliased glyph  */
+  /*      images.  Each pixel is stored in one byte.  Note that the number */
+  /*      of `gray' levels is stored in the `num_grays' field of the       */
+  /*      @FT_Bitmap structure (it generally is 256).                      */
+  /*                                                                       */
+  /*    FT_PIXEL_MODE_GRAY2 ::                                             */
+  /*      A 2-bit per pixel bitmap, used to represent embedded             */
+  /*      anti-aliased bitmaps in font files according to the OpenType     */
+  /*      specification.  We haven't found a single font using this        */
+  /*      format, however.                                                 */
+  /*                                                                       */
+  /*    FT_PIXEL_MODE_GRAY4 ::                                             */
+  /*      A 4-bit per pixel bitmap, representing embedded anti-aliased     */
+  /*      bitmaps in font files according to the OpenType specification.   */
+  /*      We haven't found a single font using this format, however.       */
+  /*                                                                       */
+  /*    FT_PIXEL_MODE_LCD ::                                               */
+  /*      An 8-bit bitmap, representing RGB or BGR decimated glyph images  */
+  /*      used for display on LCD displays; the bitmap is three times      */
+  /*      wider than the original glyph image.  See also                   */
+  /*      @FT_RENDER_MODE_LCD.                                             */
+  /*                                                                       */
+  /*    FT_PIXEL_MODE_LCD_V ::                                             */
+  /*      An 8-bit bitmap, representing RGB or BGR decimated glyph images  */
+  /*      used for display on rotated LCD displays; the bitmap is three    */
+  /*      times taller than the original glyph image.  See also            */
+  /*      @FT_RENDER_MODE_LCD_V.                                           */
+  /*                                                                       */
+  /*    FT_PIXEL_MODE_BGRA ::                                              */
+  /*      An image with four 8-bit channels per pixel, representing a      */
+  /*      color image (such as emoticons) with alpha channel.  For each    */
+  /*      pixel, the format is BGRA, which means, the blue channel comes   */
+  /*      first in memory.  The color channels are pre-multiplied and in   */
+  /*      the sRGB colorspace.  For example, full red at half-translucent  */
+  /*      opacity will be represented as `00,00,80,80', not `00,00,FF,80'. */
+  /*      See also @FT_LOAD_COLOR.                                         */
+  /*                                                                       */
+  typedef enum  FT_Pixel_Mode_
+  {
+    FT_PIXEL_MODE_NONE = 0,
+    FT_PIXEL_MODE_MONO,
+    FT_PIXEL_MODE_GRAY,
+    FT_PIXEL_MODE_GRAY2,
+    FT_PIXEL_MODE_GRAY4,
+    FT_PIXEL_MODE_LCD,
+    FT_PIXEL_MODE_LCD_V,
+    FT_PIXEL_MODE_BGRA,
+
+    FT_PIXEL_MODE_MAX      /* do not remove */
+
+  } FT_Pixel_Mode;
+
+
+  /* these constants are deprecated; use the corresponding `FT_Pixel_Mode' */
+  /* values instead.                                                       */
+#define ft_pixel_mode_none   FT_PIXEL_MODE_NONE
+#define ft_pixel_mode_mono   FT_PIXEL_MODE_MONO
+#define ft_pixel_mode_grays  FT_PIXEL_MODE_GRAY
+#define ft_pixel_mode_pal2   FT_PIXEL_MODE_GRAY2
+#define ft_pixel_mode_pal4   FT_PIXEL_MODE_GRAY4
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Bitmap                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to describe a bitmap or pixmap to the raster.     */
+  /*    Note that we now manage pixmaps of various depths through the      */
+  /*    `pixel_mode' field.                                                */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    rows         :: The number of bitmap rows.                         */
+  /*                                                                       */
+  /*    width        :: The number of pixels in bitmap row.                */
+  /*                                                                       */
+  /*    pitch        :: The pitch's absolute value is the number of bytes  */
+  /*                    taken by one bitmap row, including padding.        */
+  /*                    However, the pitch is positive when the bitmap has */
+  /*                    a `down' flow, and negative when it has an `up'    */
+  /*                    flow.  In all cases, the pitch is an offset to add */
+  /*                    to a bitmap pointer in order to go down one row.   */
+  /*                                                                       */
+  /*                    Note that `padding' means the alignment of a       */
+  /*                    bitmap to a byte border, and FreeType functions    */
+  /*                    normally align to the smallest possible integer    */
+  /*                    value.                                             */
+  /*                                                                       */
+  /*                    For the B/W rasterizer, `pitch' is always an even  */
+  /*                    number.                                            */
+  /*                                                                       */
+  /*                    To change the pitch of a bitmap (say, to make it a */
+  /*                    multiple of 4), use @FT_Bitmap_Convert.            */
+  /*                    Alternatively, you might use callback functions to */
+  /*                    directly render to the application's surface; see  */
+  /*                    the file `example2.cpp' in the tutorial for a      */
+  /*                    demonstration.                                     */
+  /*                                                                       */
+  /*    buffer       :: A typeless pointer to the bitmap buffer.  This     */
+  /*                    value should be aligned on 32-bit boundaries in    */
+  /*                    most cases.                                        */
+  /*                                                                       */
+  /*    num_grays    :: This field is only used with                       */
+  /*                    @FT_PIXEL_MODE_GRAY; it gives the number of gray   */
+  /*                    levels used in the bitmap.                         */
+  /*                                                                       */
+  /*    pixel_mode   :: The pixel mode, i.e., how pixel bits are stored.   */
+  /*                    See @FT_Pixel_Mode for possible values.            */
+  /*                                                                       */
+  /*    palette_mode :: This field is intended for paletted pixel modes;   */
+  /*                    it indicates how the palette is stored.  Not       */
+  /*                    used currently.                                    */
+  /*                                                                       */
+  /*    palette      :: A typeless pointer to the bitmap palette; this     */
+  /*                    field is intended for paletted pixel modes.  Not   */
+  /*                    used currently.                                    */
+  /*                                                                       */
+  typedef struct  FT_Bitmap_
+  {
+    unsigned int    rows;
+    unsigned int    width;
+    int             pitch;
+    unsigned char*  buffer;
+    unsigned short  num_grays;
+    unsigned char   pixel_mode;
+    unsigned char   palette_mode;
+    void*           palette;
+
+  } FT_Bitmap;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    outline_processing                                                 */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Outline                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This structure is used to describe an outline to the scan-line     */
+  /*    converter.                                                         */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    n_contours :: The number of contours in the outline.               */
+  /*                                                                       */
+  /*    n_points   :: The number of points in the outline.                 */
+  /*                                                                       */
+  /*    points     :: A pointer to an array of `n_points' @FT_Vector       */
+  /*                  elements, giving the outline's point coordinates.    */
+  /*                                                                       */
+  /*    tags       :: A pointer to an array of `n_points' chars, giving    */
+  /*                  each outline point's type.                           */
+  /*                                                                       */
+  /*                  If bit~0 is unset, the point is `off' the curve,     */
+  /*                  i.e., a Bézier control point, while it is `on' if    */
+  /*                  set.                                                 */
+  /*                                                                       */
+  /*                  Bit~1 is meaningful for `off' points only.  If set,  */
+  /*                  it indicates a third-order Bézier arc control point; */
+  /*                  and a second-order control point if unset.           */
+  /*                                                                       */
+  /*                  If bit~2 is set, bits 5-7 contain the drop-out mode  */
+  /*                  (as defined in the OpenType specification; the value */
+  /*                  is the same as the argument to the SCANMODE          */
+  /*                  instruction).                                        */
+  /*                                                                       */
+  /*                  Bits 3 and~4 are reserved for internal purposes.     */
+  /*                                                                       */
+  /*    contours   :: An array of `n_contours' shorts, giving the end      */
+  /*                  point of each contour within the outline.  For       */
+  /*                  example, the first contour is defined by the points  */
+  /*                  `0' to `contours[0]', the second one is defined by   */
+  /*                  the points `contours[0]+1' to `contours[1]', etc.    */
+  /*                                                                       */
+  /*    flags      :: A set of bit flags used to characterize the outline  */
+  /*                  and give hints to the scan-converter and hinter on   */
+  /*                  how to convert/grid-fit it.  See @FT_OUTLINE_XXX.    */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The B/W rasterizer only checks bit~2 in the `tags' array for the   */
+  /*    first point of each contour.  The drop-out mode as given with      */
+  /*    @FT_OUTLINE_IGNORE_DROPOUTS, @FT_OUTLINE_SMART_DROPOUTS, and       */
+  /*    @FT_OUTLINE_INCLUDE_STUBS in `flags' is then overridden.           */
+  /*                                                                       */
+  typedef struct  FT_Outline_
+  {
+    short       n_contours;      /* number of contours in glyph        */
+    short       n_points;        /* number of points in the glyph      */
+
+    FT_Vector*  points;          /* the outline's points               */
+    char*       tags;            /* the points flags                   */
+    short*      contours;        /* the contour end points             */
+
+    int         flags;           /* outline masks                      */
+
+  } FT_Outline;
+
+  /* */
+
+  /* Following limits must be consistent with */
+  /* FT_Outline.{n_contours,n_points}         */
+#define FT_OUTLINE_CONTOURS_MAX  SHRT_MAX
+#define FT_OUTLINE_POINTS_MAX    SHRT_MAX
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    FT_OUTLINE_XXX                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A list of bit-field constants use for the flags in an outline's    */
+  /*    `flags' field.                                                     */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    FT_OUTLINE_NONE ::                                                 */
+  /*      Value~0 is reserved.                                             */
+  /*                                                                       */
+  /*    FT_OUTLINE_OWNER ::                                                */
+  /*      If set, this flag indicates that the outline's field arrays      */
+  /*      (i.e., `points', `flags', and `contours') are `owned' by the     */
+  /*      outline object, and should thus be freed when it is destroyed.   */
+  /*                                                                       */
+  /*    FT_OUTLINE_EVEN_ODD_FILL ::                                        */
+  /*      By default, outlines are filled using the non-zero winding rule. */
+  /*      If set to 1, the outline will be filled using the even-odd fill  */
+  /*      rule (only works with the smooth rasterizer).                    */
+  /*                                                                       */
+  /*    FT_OUTLINE_REVERSE_FILL ::                                         */
+  /*      By default, outside contours of an outline are oriented in       */
+  /*      clock-wise direction, as defined in the TrueType specification.  */
+  /*      This flag is set if the outline uses the opposite direction      */
+  /*      (typically for Type~1 fonts).  This flag is ignored by the scan  */
+  /*      converter.                                                       */
+  /*                                                                       */
+  /*    FT_OUTLINE_IGNORE_DROPOUTS ::                                      */
+  /*      By default, the scan converter will try to detect drop-outs in   */
+  /*      an outline and correct the glyph bitmap to ensure consistent     */
+  /*      shape continuity.  If set, this flag hints the scan-line         */
+  /*      converter to ignore such cases.  See below for more information. */
+  /*                                                                       */
+  /*    FT_OUTLINE_SMART_DROPOUTS ::                                       */
+  /*      Select smart dropout control.  If unset, use simple dropout      */
+  /*      control.  Ignored if @FT_OUTLINE_IGNORE_DROPOUTS is set.  See    */
+  /*      below for more information.                                      */
+  /*                                                                       */
+  /*    FT_OUTLINE_INCLUDE_STUBS ::                                        */
+  /*      If set, turn pixels on for `stubs', otherwise exclude them.      */
+  /*      Ignored if @FT_OUTLINE_IGNORE_DROPOUTS is set.  See below for    */
+  /*      more information.                                                */
+  /*                                                                       */
+  /*    FT_OUTLINE_HIGH_PRECISION ::                                       */
+  /*      This flag indicates that the scan-line converter should try to   */
+  /*      convert this outline to bitmaps with the highest possible        */
+  /*      quality.  It is typically set for small character sizes.  Note   */
+  /*      that this is only a hint that might be completely ignored by a   */
+  /*      given scan-converter.                                            */
+  /*                                                                       */
+  /*    FT_OUTLINE_SINGLE_PASS ::                                          */
+  /*      This flag is set to force a given scan-converter to only use a   */
+  /*      single pass over the outline to render a bitmap glyph image.     */
+  /*      Normally, it is set for very large character sizes.  It is only  */
+  /*      a hint that might be completely ignored by a given               */
+  /*      scan-converter.                                                  */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The flags @FT_OUTLINE_IGNORE_DROPOUTS, @FT_OUTLINE_SMART_DROPOUTS, */
+  /*    and @FT_OUTLINE_INCLUDE_STUBS are ignored by the smooth            */
+  /*    rasterizer.                                                        */
+  /*                                                                       */
+  /*    There exists a second mechanism to pass the drop-out mode to the   */
+  /*    B/W rasterizer; see the `tags' field in @FT_Outline.               */
+  /*                                                                       */
+  /*    Please refer to the description of the `SCANTYPE' instruction in   */
+  /*    the OpenType specification (in file `ttinst1.doc') how simple      */
+  /*    drop-outs, smart drop-outs, and stubs are defined.                 */
+  /*                                                                       */
+#define FT_OUTLINE_NONE             0x0
+#define FT_OUTLINE_OWNER            0x1
+#define FT_OUTLINE_EVEN_ODD_FILL    0x2
+#define FT_OUTLINE_REVERSE_FILL     0x4
+#define FT_OUTLINE_IGNORE_DROPOUTS  0x8
+#define FT_OUTLINE_SMART_DROPOUTS   0x10
+#define FT_OUTLINE_INCLUDE_STUBS    0x20
+
+#define FT_OUTLINE_HIGH_PRECISION   0x100
+#define FT_OUTLINE_SINGLE_PASS      0x200
+
+
+  /* these constants are deprecated; use the corresponding */
+  /* `FT_OUTLINE_XXX' values instead                       */
+#define ft_outline_none             FT_OUTLINE_NONE
+#define ft_outline_owner            FT_OUTLINE_OWNER
+#define ft_outline_even_odd_fill    FT_OUTLINE_EVEN_ODD_FILL
+#define ft_outline_reverse_fill     FT_OUTLINE_REVERSE_FILL
+#define ft_outline_ignore_dropouts  FT_OUTLINE_IGNORE_DROPOUTS
+#define ft_outline_high_precision   FT_OUTLINE_HIGH_PRECISION
+#define ft_outline_single_pass      FT_OUTLINE_SINGLE_PASS
+
+  /* */
+
+#define FT_CURVE_TAG( flag )  ( flag & 3 )
+
+#define FT_CURVE_TAG_ON            1
+#define FT_CURVE_TAG_CONIC         0
+#define FT_CURVE_TAG_CUBIC         2
+
+#define FT_CURVE_TAG_HAS_SCANMODE  4
+
+#define FT_CURVE_TAG_TOUCH_X       8  /* reserved for the TrueType hinter */
+#define FT_CURVE_TAG_TOUCH_Y      16  /* reserved for the TrueType hinter */
+
+#define FT_CURVE_TAG_TOUCH_BOTH    ( FT_CURVE_TAG_TOUCH_X | \
+                                     FT_CURVE_TAG_TOUCH_Y )
+
+#define FT_Curve_Tag_On       FT_CURVE_TAG_ON
+#define FT_Curve_Tag_Conic    FT_CURVE_TAG_CONIC
+#define FT_Curve_Tag_Cubic    FT_CURVE_TAG_CUBIC
+#define FT_Curve_Tag_Touch_X  FT_CURVE_TAG_TOUCH_X
+#define FT_Curve_Tag_Touch_Y  FT_CURVE_TAG_TOUCH_Y
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_Outline_MoveToFunc                                              */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function pointer type used to describe the signature of a `move  */
+  /*    to' function during outline walking/decomposition.                 */
+  /*                                                                       */
+  /*    A `move to' is emitted to start a new contour in an outline.       */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    to   :: A pointer to the target point of the `move to'.            */
+  /*                                                                       */
+  /*    user :: A typeless pointer, which is passed from the caller of the */
+  /*            decomposition function.                                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Error code.  0~means success.                                      */
+  /*                                                                       */
+  typedef int
+  (*FT_Outline_MoveToFunc)( const FT_Vector*  to,
+                            void*             user );
+
+#define FT_Outline_MoveTo_Func  FT_Outline_MoveToFunc
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_Outline_LineToFunc                                              */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function pointer type used to describe the signature of a `line  */
+  /*    to' function during outline walking/decomposition.                 */
+  /*                                                                       */
+  /*    A `line to' is emitted to indicate a segment in the outline.       */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    to   :: A pointer to the target point of the `line to'.            */
+  /*                                                                       */
+  /*    user :: A typeless pointer, which is passed from the caller of the */
+  /*            decomposition function.                                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Error code.  0~means success.                                      */
+  /*                                                                       */
+  typedef int
+  (*FT_Outline_LineToFunc)( const FT_Vector*  to,
+                            void*             user );
+
+#define FT_Outline_LineTo_Func  FT_Outline_LineToFunc
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_Outline_ConicToFunc                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function pointer type used to describe the signature of a `conic */
+  /*    to' function during outline walking or decomposition.              */
+  /*                                                                       */
+  /*    A `conic to' is emitted to indicate a second-order Bézier arc in   */
+  /*    the outline.                                                       */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    control :: An intermediate control point between the last position */
+  /*               and the new target in `to'.                             */
+  /*                                                                       */
+  /*    to      :: A pointer to the target end point of the conic arc.     */
+  /*                                                                       */
+  /*    user    :: A typeless pointer, which is passed from the caller of  */
+  /*               the decomposition function.                             */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Error code.  0~means success.                                      */
+  /*                                                                       */
+  typedef int
+  (*FT_Outline_ConicToFunc)( const FT_Vector*  control,
+                             const FT_Vector*  to,
+                             void*             user );
+
+#define FT_Outline_ConicTo_Func  FT_Outline_ConicToFunc
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_Outline_CubicToFunc                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function pointer type used to describe the signature of a `cubic */
+  /*    to' function during outline walking or decomposition.              */
+  /*                                                                       */
+  /*    A `cubic to' is emitted to indicate a third-order Bézier arc.      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    control1 :: A pointer to the first Bézier control point.           */
+  /*                                                                       */
+  /*    control2 :: A pointer to the second Bézier control point.          */
+  /*                                                                       */
+  /*    to       :: A pointer to the target end point.                     */
+  /*                                                                       */
+  /*    user     :: A typeless pointer, which is passed from the caller of */
+  /*                the decomposition function.                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Error code.  0~means success.                                      */
+  /*                                                                       */
+  typedef int
+  (*FT_Outline_CubicToFunc)( const FT_Vector*  control1,
+                             const FT_Vector*  control2,
+                             const FT_Vector*  to,
+                             void*             user );
+
+#define FT_Outline_CubicTo_Func  FT_Outline_CubicToFunc
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Outline_Funcs                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure to hold various function pointers used during outline  */
+  /*    decomposition in order to emit segments, conic, and cubic Béziers. */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    move_to  :: The `move to' emitter.                                 */
+  /*                                                                       */
+  /*    line_to  :: The segment emitter.                                   */
+  /*                                                                       */
+  /*    conic_to :: The second-order Bézier arc emitter.                   */
+  /*                                                                       */
+  /*    cubic_to :: The third-order Bézier arc emitter.                    */
+  /*                                                                       */
+  /*    shift    :: The shift that is applied to coordinates before they   */
+  /*                are sent to the emitter.                               */
+  /*                                                                       */
+  /*    delta    :: The delta that is applied to coordinates before they   */
+  /*                are sent to the emitter, but after the shift.          */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The point coordinates sent to the emitters are the transformed     */
+  /*    version of the original coordinates (this is important for high    */
+  /*    accuracy during scan-conversion).  The transformation is simple:   */
+  /*                                                                       */
+  /*    {                                                                  */
+  /*      x' = (x << shift) - delta                                        */
+  /*      y' = (y << shift) - delta                                        */
+  /*    }                                                                  */
+  /*                                                                       */
+  /*    Set the values of `shift' and `delta' to~0 to get the original     */
+  /*    point coordinates.                                                 */
+  /*                                                                       */
+  typedef struct  FT_Outline_Funcs_
+  {
+    FT_Outline_MoveToFunc   move_to;
+    FT_Outline_LineToFunc   line_to;
+    FT_Outline_ConicToFunc  conic_to;
+    FT_Outline_CubicToFunc  cubic_to;
+
+    int                     shift;
+    FT_Pos                  delta;
+
+  } FT_Outline_Funcs;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    basic_types                                                        */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Macro>                                                               */
+  /*    FT_IMAGE_TAG                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This macro converts four-letter tags to an unsigned long type.     */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Since many 16-bit compilers don't like 32-bit enumerations, you    */
+  /*    should redefine this macro in case of problems to something like   */
+  /*    this:                                                              */
+  /*                                                                       */
+  /*    {                                                                  */
+  /*      #define FT_IMAGE_TAG( value, _x1, _x2, _x3, _x4 )  value         */
+  /*    }                                                                  */
+  /*                                                                       */
+  /*    to get a simple enumeration without assigning special numbers.     */
+  /*                                                                       */
+#ifndef FT_IMAGE_TAG
+#define FT_IMAGE_TAG( value, _x1, _x2, _x3, _x4 )  \
+          value = ( ( (unsigned long)_x1 << 24 ) | \
+                    ( (unsigned long)_x2 << 16 ) | \
+                    ( (unsigned long)_x3 << 8  ) | \
+                      (unsigned long)_x4         )
+#endif /* FT_IMAGE_TAG */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    FT_Glyph_Format                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An enumeration type used to describe the format of a given glyph   */
+  /*    image.  Note that this version of FreeType only supports two image */
+  /*    formats, even though future font drivers will be able to register  */
+  /*    their own format.                                                  */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    FT_GLYPH_FORMAT_NONE ::                                            */
+  /*      The value~0 is reserved.                                         */
+  /*                                                                       */
+  /*    FT_GLYPH_FORMAT_COMPOSITE ::                                       */
+  /*      The glyph image is a composite of several other images.  This    */
+  /*      format is _only_ used with @FT_LOAD_NO_RECURSE, and is used to   */
+  /*      report compound glyphs (like accented characters).               */
+  /*                                                                       */
+  /*    FT_GLYPH_FORMAT_BITMAP ::                                          */
+  /*      The glyph image is a bitmap, and can be described as an          */
+  /*      @FT_Bitmap.  You generally need to access the `bitmap' field of  */
+  /*      the @FT_GlyphSlotRec structure to read it.                       */
+  /*                                                                       */
+  /*    FT_GLYPH_FORMAT_OUTLINE ::                                         */
+  /*      The glyph image is a vectorial outline made of line segments     */
+  /*      and Bézier arcs; it can be described as an @FT_Outline; you      */
+  /*      generally want to access the `outline' field of the              */
+  /*      @FT_GlyphSlotRec structure to read it.                           */
+  /*                                                                       */
+  /*    FT_GLYPH_FORMAT_PLOTTER ::                                         */
+  /*      The glyph image is a vectorial path with no inside and outside   */
+  /*      contours.  Some Type~1 fonts, like those in the Hershey family,  */
+  /*      contain glyphs in this format.  These are described as           */
+  /*      @FT_Outline, but FreeType isn't currently capable of rendering   */
+  /*      them correctly.                                                  */
+  /*                                                                       */
+  typedef enum  FT_Glyph_Format_
+  {
+    FT_IMAGE_TAG( FT_GLYPH_FORMAT_NONE, 0, 0, 0, 0 ),
+
+    FT_IMAGE_TAG( FT_GLYPH_FORMAT_COMPOSITE, 'c', 'o', 'm', 'p' ),
+    FT_IMAGE_TAG( FT_GLYPH_FORMAT_BITMAP,    'b', 'i', 't', 's' ),
+    FT_IMAGE_TAG( FT_GLYPH_FORMAT_OUTLINE,   'o', 'u', 't', 'l' ),
+    FT_IMAGE_TAG( FT_GLYPH_FORMAT_PLOTTER,   'p', 'l', 'o', 't' )
+
+  } FT_Glyph_Format;
+
+
+  /* these constants are deprecated; use the corresponding */
+  /* `FT_Glyph_Format' values instead.                     */
+#define ft_glyph_format_none       FT_GLYPH_FORMAT_NONE
+#define ft_glyph_format_composite  FT_GLYPH_FORMAT_COMPOSITE
+#define ft_glyph_format_bitmap     FT_GLYPH_FORMAT_BITMAP
+#define ft_glyph_format_outline    FT_GLYPH_FORMAT_OUTLINE
+#define ft_glyph_format_plotter    FT_GLYPH_FORMAT_PLOTTER
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****            R A S T E R   D E F I N I T I O N S                *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* A raster is a scan converter, in charge of rendering an outline into  */
+  /* a bitmap.  This section contains the public API for rasters.          */
+  /*                                                                       */
+  /* Note that in FreeType 2, all rasters are now encapsulated within      */
+  /* specific modules called `renderers'.  See `ftrender.h' for more       */
+  /* details on renderers.                                                 */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    raster                                                             */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    Scanline Converter                                                 */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    How vectorial outlines are converted into bitmaps and pixmaps.     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains technical definitions.                       */
+  /*                                                                       */
+  /* <Order>                                                               */
+  /*    FT_Raster                                                          */
+  /*    FT_Span                                                            */
+  /*    FT_SpanFunc                                                        */
+  /*                                                                       */
+  /*    FT_Raster_Params                                                   */
+  /*    FT_RASTER_FLAG_XXX                                                 */
+  /*                                                                       */
+  /*    FT_Raster_NewFunc                                                  */
+  /*    FT_Raster_DoneFunc                                                 */
+  /*    FT_Raster_ResetFunc                                                */
+  /*    FT_Raster_SetModeFunc                                              */
+  /*    FT_Raster_RenderFunc                                               */
+  /*    FT_Raster_Funcs                                                    */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Raster                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An opaque handle (pointer) to a raster object.  Each object can be */
+  /*    used independently to convert an outline into a bitmap or pixmap.  */
+  /*                                                                       */
+  typedef struct FT_RasterRec_*  FT_Raster;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Span                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to model a single span of gray pixels when        */
+  /*    rendering an anti-aliased bitmap.                                  */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    x        :: The span's horizontal start position.                  */
+  /*                                                                       */
+  /*    len      :: The span's length in pixels.                           */
+  /*                                                                       */
+  /*    coverage :: The span color/coverage, ranging from 0 (background)   */
+  /*                to 255 (foreground).                                   */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This structure is used by the span drawing callback type named     */
+  /*    @FT_SpanFunc that takes the y~coordinate of the span as a          */
+  /*    parameter.                                                         */
+  /*                                                                       */
+  /*    The coverage value is always between 0 and 255.  If you want less  */
+  /*    gray values, the callback function has to reduce them.             */
+  /*                                                                       */
+  typedef struct  FT_Span_
+  {
+    short           x;
+    unsigned short  len;
+    unsigned char   coverage;
+
+  } FT_Span;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_SpanFunc                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function used as a call-back by the anti-aliased renderer in     */
+  /*    order to let client applications draw themselves the gray pixel    */
+  /*    spans on each scan line.                                           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    y     :: The scanline's y~coordinate.                              */
+  /*                                                                       */
+  /*    count :: The number of spans to draw on this scanline.             */
+  /*                                                                       */
+  /*    spans :: A table of `count' spans to draw on the scanline.         */
+  /*                                                                       */
+  /*    user  :: User-supplied data that is passed to the callback.        */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This callback allows client applications to directly render the    */
+  /*    gray spans of the anti-aliased bitmap to any kind of surfaces.     */
+  /*                                                                       */
+  /*    This can be used to write anti-aliased outlines directly to a      */
+  /*    given background bitmap, and even perform translucency.            */
+  /*                                                                       */
+  typedef void
+  (*FT_SpanFunc)( int             y,
+                  int             count,
+                  const FT_Span*  spans,
+                  void*           user );
+
+#define FT_Raster_Span_Func  FT_SpanFunc
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_Raster_BitTest_Func                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Deprecated, unimplemented.                                         */
+  /*                                                                       */
+  typedef int
+  (*FT_Raster_BitTest_Func)( int    y,
+                             int    x,
+                             void*  user );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_Raster_BitSet_Func                                              */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Deprecated, unimplemented.                                         */
+  /*                                                                       */
+  typedef void
+  (*FT_Raster_BitSet_Func)( int    y,
+                            int    x,
+                            void*  user );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    FT_RASTER_FLAG_XXX                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A list of bit flag constants as used in the `flags' field of a     */
+  /*    @FT_Raster_Params structure.                                       */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    FT_RASTER_FLAG_DEFAULT :: This value is 0.                         */
+  /*                                                                       */
+  /*    FT_RASTER_FLAG_AA      :: This flag is set to indicate that an     */
+  /*                              anti-aliased glyph image should be       */
+  /*                              generated.  Otherwise, it will be        */
+  /*                              monochrome (1-bit).                      */
+  /*                                                                       */
+  /*    FT_RASTER_FLAG_DIRECT  :: This flag is set to indicate direct      */
+  /*                              rendering.  In this mode, client         */
+  /*                              applications must provide their own span */
+  /*                              callback.  This lets them directly       */
+  /*                              draw or compose over an existing bitmap. */
+  /*                              If this bit is not set, the target       */
+  /*                              pixmap's buffer _must_ be zeroed before  */
+  /*                              rendering.                               */
+  /*                                                                       */
+  /*                              Direct rendering is only possible with   */
+  /*                              anti-aliased glyphs.                     */
+  /*                                                                       */
+  /*    FT_RASTER_FLAG_CLIP    :: This flag is only used in direct         */
+  /*                              rendering mode.  If set, the output will */
+  /*                              be clipped to a box specified in the     */
+  /*                              `clip_box' field of the                  */
+  /*                              @FT_Raster_Params structure.             */
+  /*                                                                       */
+  /*                              Note that by default, the glyph bitmap   */
+  /*                              is clipped to the target pixmap, except  */
+  /*                              in direct rendering mode where all spans */
+  /*                              are generated if no clipping box is set. */
+  /*                                                                       */
+#define FT_RASTER_FLAG_DEFAULT  0x0
+#define FT_RASTER_FLAG_AA       0x1
+#define FT_RASTER_FLAG_DIRECT   0x2
+#define FT_RASTER_FLAG_CLIP     0x4
+
+  /* these constants are deprecated; use the corresponding */
+  /* `FT_RASTER_FLAG_XXX' values instead                   */
+#define ft_raster_flag_default  FT_RASTER_FLAG_DEFAULT
+#define ft_raster_flag_aa       FT_RASTER_FLAG_AA
+#define ft_raster_flag_direct   FT_RASTER_FLAG_DIRECT
+#define ft_raster_flag_clip     FT_RASTER_FLAG_CLIP
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Raster_Params                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure to hold the arguments used by a raster's render        */
+  /*    function.                                                          */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    target      :: The target bitmap.                                  */
+  /*                                                                       */
+  /*    source      :: A pointer to the source glyph image (e.g., an       */
+  /*                   @FT_Outline).                                       */
+  /*                                                                       */
+  /*    flags       :: The rendering flags.                                */
+  /*                                                                       */
+  /*    gray_spans  :: The gray span drawing callback.                     */
+  /*                                                                       */
+  /*    black_spans :: Unused.                                             */
+  /*                                                                       */
+  /*    bit_test    :: Unused.                                             */
+  /*                                                                       */
+  /*    bit_set     :: Unused.                                             */
+  /*                                                                       */
+  /*    user        :: User-supplied data that is passed to each drawing   */
+  /*                   callback.                                           */
+  /*                                                                       */
+  /*    clip_box    :: An optional clipping box.  It is only used in       */
+  /*                   direct rendering mode.  Note that coordinates here  */
+  /*                   should be expressed in _integer_ pixels (and not in */
+  /*                   26.6 fixed-point units).                            */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    An anti-aliased glyph bitmap is drawn if the @FT_RASTER_FLAG_AA    */
+  /*    bit flag is set in the `flags' field, otherwise a monochrome       */
+  /*    bitmap is generated.                                               */
+  /*                                                                       */
+  /*    If the @FT_RASTER_FLAG_DIRECT bit flag is set in `flags', the      */
+  /*    raster will call the `gray_spans' callback to draw gray pixel      */
+  /*    spans.  This allows direct composition over a pre-existing bitmap  */
+  /*    through user-provided callbacks to perform the span drawing and    */
+  /*    composition.    Not supported by the monochrome rasterizer.        */
+  /*                                                                       */
+  typedef struct  FT_Raster_Params_
+  {
+    const FT_Bitmap*        target;
+    const void*             source;
+    int                     flags;
+    FT_SpanFunc             gray_spans;
+    FT_SpanFunc             black_spans;  /* unused */
+    FT_Raster_BitTest_Func  bit_test;     /* unused */
+    FT_Raster_BitSet_Func   bit_set;      /* unused */
+    void*                   user;
+    FT_BBox                 clip_box;
+
+  } FT_Raster_Params;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_Raster_NewFunc                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function used to create a new raster object.                     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    memory :: A handle to the memory allocator.                        */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    raster :: A handle to the new raster object.                       */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Error code.  0~means success.                                      */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The `memory' parameter is a typeless pointer in order to avoid     */
+  /*    un-wanted dependencies on the rest of the FreeType code.  In       */
+  /*    practice, it is an @FT_Memory object, i.e., a handle to the        */
+  /*    standard FreeType memory allocator.  However, this field can be    */
+  /*    completely ignored by a given raster implementation.               */
+  /*                                                                       */
+  typedef int
+  (*FT_Raster_NewFunc)( void*       memory,
+                        FT_Raster*  raster );
+
+#define FT_Raster_New_Func  FT_Raster_NewFunc
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_Raster_DoneFunc                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function used to destroy a given raster object.                  */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    raster :: A handle to the raster object.                           */
+  /*                                                                       */
+  typedef void
+  (*FT_Raster_DoneFunc)( FT_Raster  raster );
+
+#define FT_Raster_Done_Func  FT_Raster_DoneFunc
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_Raster_ResetFunc                                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    FreeType used to provide an area of memory called the `render      */
+  /*    pool' available to all registered rasterizers.  This was not       */
+  /*    thread safe, however, and now FreeType never allocates this pool.  */
+  /*                                                                       */
+  /*    This function is called after a new raster object is created.      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    raster    :: A handle to the new raster object.                    */
+  /*                                                                       */
+  /*    pool_base :: Previously, the address in memory of the render pool. */
+  /*                 Set this to NULL.                                     */
+  /*                                                                       */
+  /*    pool_size :: Previously, the size in bytes of the render pool.     */
+  /*                 Set this to 0.                                        */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Rasterizers should rely on dynamic or stack allocation if they     */
+  /*    want to (a handle to the memory allocator is passed to the         */
+  /*    rasterizer constructor).                                           */
+  /*                                                                       */
+  typedef void
+  (*FT_Raster_ResetFunc)( FT_Raster       raster,
+                          unsigned char*  pool_base,
+                          unsigned long   pool_size );
+
+#define FT_Raster_Reset_Func  FT_Raster_ResetFunc
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_Raster_SetModeFunc                                              */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This function is a generic facility to change modes or attributes  */
+  /*    in a given raster.  This can be used for debugging purposes, or    */
+  /*    simply to allow implementation-specific `features' in a given      */
+  /*    raster module.                                                     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    raster :: A handle to the new raster object.                       */
+  /*                                                                       */
+  /*    mode   :: A 4-byte tag used to name the mode or property.          */
+  /*                                                                       */
+  /*    args   :: A pointer to the new mode/property to use.               */
+  /*                                                                       */
+  typedef int
+  (*FT_Raster_SetModeFunc)( FT_Raster      raster,
+                            unsigned long  mode,
+                            void*          args );
+
+#define FT_Raster_Set_Mode_Func  FT_Raster_SetModeFunc
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_Raster_RenderFunc                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Invoke a given raster to scan-convert a given glyph image into a   */
+  /*    target bitmap.                                                     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    raster :: A handle to the raster object.                           */
+  /*                                                                       */
+  /*    params :: A pointer to an @FT_Raster_Params structure used to      */
+  /*              store the rendering parameters.                          */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Error code.  0~means success.                                      */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The exact format of the source image depends on the raster's glyph */
+  /*    format defined in its @FT_Raster_Funcs structure.  It can be an    */
+  /*    @FT_Outline or anything else in order to support a large array of  */
+  /*    glyph formats.                                                     */
+  /*                                                                       */
+  /*    Note also that the render function can fail and return a           */
+  /*    `FT_Err_Unimplemented_Feature' error code if the raster used does  */
+  /*    not support direct composition.                                    */
+  /*                                                                       */
+  /*    XXX: For now, the standard raster doesn't support direct           */
+  /*         composition but this should change for the final release (see */
+  /*         the files `demos/src/ftgrays.c' and `demos/src/ftgrays2.c'    */
+  /*         for examples of distinct implementations that support direct  */
+  /*         composition).                                                 */
+  /*                                                                       */
+  typedef int
+  (*FT_Raster_RenderFunc)( FT_Raster                raster,
+                           const FT_Raster_Params*  params );
+
+#define FT_Raster_Render_Func  FT_Raster_RenderFunc
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Raster_Funcs                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*   A structure used to describe a given raster class to the library.   */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    glyph_format  :: The supported glyph format for this raster.       */
+  /*                                                                       */
+  /*    raster_new    :: The raster constructor.                           */
+  /*                                                                       */
+  /*    raster_reset  :: Used to reset the render pool within the raster.  */
+  /*                                                                       */
+  /*    raster_render :: A function to render a glyph into a given bitmap. */
+  /*                                                                       */
+  /*    raster_done   :: The raster destructor.                            */
+  /*                                                                       */
+  typedef struct  FT_Raster_Funcs_
+  {
+    FT_Glyph_Format        glyph_format;
+
+    FT_Raster_NewFunc      raster_new;
+    FT_Raster_ResetFunc    raster_reset;
+    FT_Raster_SetModeFunc  raster_set_mode;
+    FT_Raster_RenderFunc   raster_render;
+    FT_Raster_DoneFunc     raster_done;
+
+  } FT_Raster_Funcs;
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* FTIMAGE_H_ */
+
+
+/* END */
+
+
+/* Local Variables: */
+/* coding: utf-8    */
+/* End:             */
diff --git a/engine/inc/freetype/ftincrem.h b/engine/inc/freetype/ftincrem.h
new file mode 100644
index 00000000..f6ae2bae
--- /dev/null
+++ b/engine/inc/freetype/ftincrem.h
@@ -0,0 +1,354 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftincrem.h                                                             */
+/*                                                                         */
+/*    FreeType incremental loading (specification).                        */
+/*                                                                         */
+/*  Copyright 2002-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTINCREM_H_
+#define FTINCREM_H_
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+  /***************************************************************************
+   *
+   * @section:
+   *    incremental
+   *
+   * @title:
+   *    Incremental Loading
+   *
+   * @abstract:
+   *    Custom Glyph Loading.
+   *
+   * @description:
+   *   This section contains various functions used to perform so-called
+   *   `incremental' glyph loading.  This is a mode where all glyphs loaded
+   *   from a given @FT_Face are provided by the client application.
+   *
+   *   Apart from that, all other tables are loaded normally from the font
+   *   file.  This mode is useful when FreeType is used within another
+   *   engine, e.g., a PostScript Imaging Processor.
+   *
+   *   To enable this mode, you must use @FT_Open_Face, passing an
+   *   @FT_Parameter with the @FT_PARAM_TAG_INCREMENTAL tag and an
+   *   @FT_Incremental_Interface value.  See the comments for
+   *   @FT_Incremental_InterfaceRec for an example.
+   *
+   */
+
+
+  /***************************************************************************
+   *
+   * @type:
+   *   FT_Incremental
+   *
+   * @description:
+   *   An opaque type describing a user-provided object used to implement
+   *   `incremental' glyph loading within FreeType.  This is used to support
+   *   embedded fonts in certain environments (e.g., PostScript interpreters),
+   *   where the glyph data isn't in the font file, or must be overridden by
+   *   different values.
+   *
+   * @note:
+   *   It is up to client applications to create and implement @FT_Incremental
+   *   objects, as long as they provide implementations for the methods
+   *   @FT_Incremental_GetGlyphDataFunc, @FT_Incremental_FreeGlyphDataFunc
+   *   and @FT_Incremental_GetGlyphMetricsFunc.
+   *
+   *   See the description of @FT_Incremental_InterfaceRec to understand how
+   *   to use incremental objects with FreeType.
+   *
+   */
+  typedef struct FT_IncrementalRec_*  FT_Incremental;
+
+
+  /***************************************************************************
+   *
+   * @struct:
+   *   FT_Incremental_MetricsRec
+   *
+   * @description:
+   *   A small structure used to contain the basic glyph metrics returned
+   *   by the @FT_Incremental_GetGlyphMetricsFunc method.
+   *
+   * @fields:
+   *   bearing_x ::
+   *     Left bearing, in font units.
+   *
+   *   bearing_y ::
+   *     Top bearing, in font units.
+   *
+   *   advance ::
+   *     Horizontal component of glyph advance, in font units.
+   *
+   *   advance_v ::
+   *     Vertical component of glyph advance, in font units.
+   *
+   * @note:
+   *   These correspond to horizontal or vertical metrics depending on the
+   *   value of the `vertical' argument to the function
+   *   @FT_Incremental_GetGlyphMetricsFunc.
+   *
+   */
+  typedef struct  FT_Incremental_MetricsRec_
+  {
+    FT_Long  bearing_x;
+    FT_Long  bearing_y;
+    FT_Long  advance;
+    FT_Long  advance_v;     /* since 2.3.12 */
+
+  } FT_Incremental_MetricsRec;
+
+
+  /***************************************************************************
+   *
+   * @struct:
+   *   FT_Incremental_Metrics
+   *
+   * @description:
+   *   A handle to an @FT_Incremental_MetricsRec structure.
+   *
+   */
+   typedef struct FT_Incremental_MetricsRec_*  FT_Incremental_Metrics;
+
+
+  /***************************************************************************
+   *
+   * @type:
+   *   FT_Incremental_GetGlyphDataFunc
+   *
+   * @description:
+   *   A function called by FreeType to access a given glyph's data bytes
+   *   during @FT_Load_Glyph or @FT_Load_Char if incremental loading is
+   *   enabled.
+   *
+   *   Note that the format of the glyph's data bytes depends on the font
+   *   file format.  For TrueType, it must correspond to the raw bytes within
+   *   the `glyf' table.  For PostScript formats, it must correspond to the
+   *   *unencrypted* charstring bytes, without any `lenIV' header.  It is
+   *   undefined for any other format.
+   *
+   * @input:
+   *   incremental ::
+   *     Handle to an opaque @FT_Incremental handle provided by the client
+   *     application.
+   *
+   *   glyph_index ::
+   *     Index of relevant glyph.
+   *
+   * @output:
+   *   adata ::
+   *     A structure describing the returned glyph data bytes (which will be
+   *     accessed as a read-only byte block).
+   *
+   * @return:
+   *   FreeType error code.  0~means success.
+   *
+   * @note:
+   *   If this function returns successfully the method
+   *   @FT_Incremental_FreeGlyphDataFunc will be called later to release
+   *   the data bytes.
+   *
+   *   Nested calls to @FT_Incremental_GetGlyphDataFunc can happen for
+   *   compound glyphs.
+   *
+   */
+  typedef FT_Error
+  (*FT_Incremental_GetGlyphDataFunc)( FT_Incremental  incremental,
+                                      FT_UInt         glyph_index,
+                                      FT_Data*        adata );
+
+
+  /***************************************************************************
+   *
+   * @type:
+   *   FT_Incremental_FreeGlyphDataFunc
+   *
+   * @description:
+   *   A function used to release the glyph data bytes returned by a
+   *   successful call to @FT_Incremental_GetGlyphDataFunc.
+   *
+   * @input:
+   *   incremental ::
+   *     A handle to an opaque @FT_Incremental handle provided by the client
+   *     application.
+   *
+   *   data ::
+   *     A structure describing the glyph data bytes (which will be accessed
+   *     as a read-only byte block).
+   *
+   */
+  typedef void
+  (*FT_Incremental_FreeGlyphDataFunc)( FT_Incremental  incremental,
+                                       FT_Data*        data );
+
+
+  /***************************************************************************
+   *
+   * @type:
+   *   FT_Incremental_GetGlyphMetricsFunc
+   *
+   * @description:
+   *   A function used to retrieve the basic metrics of a given glyph index
+   *   before accessing its data.  This is necessary because, in certain
+   *   formats like TrueType, the metrics are stored in a different place from
+   *   the glyph images proper.
+   *
+   * @input:
+   *   incremental ::
+   *     A handle to an opaque @FT_Incremental handle provided by the client
+   *     application.
+   *
+   *   glyph_index ::
+   *     Index of relevant glyph.
+   *
+   *   vertical ::
+   *     If true, return vertical metrics.
+   *
+   *   ametrics ::
+   *     This parameter is used for both input and output.
+   *     The original glyph metrics, if any, in font units.  If metrics are
+   *     not available all the values must be set to zero.
+   *
+   * @output:
+   *   ametrics ::
+   *     The replacement glyph metrics in font units.
+   *
+   */
+  typedef FT_Error
+  (*FT_Incremental_GetGlyphMetricsFunc)
+                      ( FT_Incremental              incremental,
+                        FT_UInt                     glyph_index,
+                        FT_Bool                     vertical,
+                        FT_Incremental_MetricsRec  *ametrics );
+
+
+  /**************************************************************************
+   *
+   * @struct:
+   *   FT_Incremental_FuncsRec
+   *
+   * @description:
+   *   A table of functions for accessing fonts that load data
+   *   incrementally.  Used in @FT_Incremental_InterfaceRec.
+   *
+   * @fields:
+   *   get_glyph_data ::
+   *     The function to get glyph data.  Must not be null.
+   *
+   *   free_glyph_data ::
+   *     The function to release glyph data.  Must not be null.
+   *
+   *   get_glyph_metrics ::
+   *     The function to get glyph metrics.  May be null if the font does
+   *     not provide overriding glyph metrics.
+   *
+   */
+  typedef struct  FT_Incremental_FuncsRec_
+  {
+    FT_Incremental_GetGlyphDataFunc     get_glyph_data;
+    FT_Incremental_FreeGlyphDataFunc    free_glyph_data;
+    FT_Incremental_GetGlyphMetricsFunc  get_glyph_metrics;
+
+  } FT_Incremental_FuncsRec;
+
+
+  /***************************************************************************
+   *
+   * @struct:
+   *   FT_Incremental_InterfaceRec
+   *
+   * @description:
+   *   A structure to be used with @FT_Open_Face to indicate that the user
+   *   wants to support incremental glyph loading.  You should use it with
+   *   @FT_PARAM_TAG_INCREMENTAL as in the following example:
+   *
+   *     {
+   *       FT_Incremental_InterfaceRec  inc_int;
+   *       FT_Parameter                 parameter;
+   *       FT_Open_Args                 open_args;
+   *
+   *
+   *       // set up incremental descriptor
+   *       inc_int.funcs  = my_funcs;
+   *       inc_int.object = my_object;
+   *
+   *       // set up optional parameter
+   *       parameter.tag  = FT_PARAM_TAG_INCREMENTAL;
+   *       parameter.data = &inc_int;
+   *
+   *       // set up FT_Open_Args structure
+   *       open_args.flags      = FT_OPEN_PATHNAME | FT_OPEN_PARAMS;
+   *       open_args.pathname   = my_font_pathname;
+   *       open_args.num_params = 1;
+   *       open_args.params     = &parameter; // we use one optional argument
+   *
+   *       // open the font
+   *       error = FT_Open_Face( library, &open_args, index, &face );
+   *       ...
+   *     }
+   *
+   */
+  typedef struct  FT_Incremental_InterfaceRec_
+  {
+    const FT_Incremental_FuncsRec*  funcs;
+    FT_Incremental                  object;
+
+  } FT_Incremental_InterfaceRec;
+
+
+  /***************************************************************************
+   *
+   * @type:
+   *   FT_Incremental_Interface
+   *
+   * @description:
+   *   A pointer to an @FT_Incremental_InterfaceRec structure.
+   *
+   */
+  typedef FT_Incremental_InterfaceRec*   FT_Incremental_Interface;
+
+
+  /***************************************************************************
+   *
+   * @constant:
+   *   FT_PARAM_TAG_INCREMENTAL
+   *
+   * @description:
+   *   A constant used as the tag of @FT_Parameter structures to indicate
+   *   an incremental loading object to be used by FreeType.
+   *
+   */
+#define FT_PARAM_TAG_INCREMENTAL  FT_MAKE_TAG( 'i', 'n', 'c', 'r' )
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* FTINCREM_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ftlcdfil.h b/engine/inc/freetype/ftlcdfil.h
new file mode 100644
index 00000000..bdaf9af9
--- /dev/null
+++ b/engine/inc/freetype/ftlcdfil.h
@@ -0,0 +1,322 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftlcdfil.h                                                             */
+/*                                                                         */
+/*    FreeType API for color filtering of subpixel bitmap glyphs           */
+/*    (specification).                                                     */
+/*                                                                         */
+/*  Copyright 2006-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTLCDFIL_H_
+#define FTLCDFIL_H_
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+  /***************************************************************************
+   *
+   * @section:
+   *   lcd_filtering
+   *
+   * @title:
+   *   LCD Filtering
+   *
+   * @abstract:
+   *   Reduce color fringes of subpixel-rendered bitmaps.
+   *
+   * @description:
+   *   Should you #define FT_CONFIG_OPTION_SUBPIXEL_RENDERING in your
+   *   `ftoption.h', which enables patented ClearType-style rendering,
+   *   the LCD-optimized glyph bitmaps should be filtered to reduce color
+   *   fringes inherent to this technology.  The default FreeType LCD
+   *   rendering uses different technology, and API described below,
+   *   although available, does nothing.
+   *
+   *   ClearType-style LCD rendering exploits the color-striped structure of
+   *   LCD pixels, increasing the available resolution in the direction of
+   *   the stripe (usually horizontal RGB) by a factor of~3.  Since these
+   *   subpixels are color pixels, using them unfiltered creates severe
+   *   color fringes.  Use the @FT_Library_SetLcdFilter API to specify a
+   *   low-pass filter, which is then applied to subpixel-rendered bitmaps
+   *   generated through @FT_Render_Glyph.  The filter sacrifices some of
+   *   the higher resolution to reduce color fringes, making the glyph image
+   *   slightly blurrier.  Positional improvements will remain.
+   *
+   *   A filter should have two properties:
+   *
+   *   1) It should be normalized, meaning the sum of the 5~components
+   *      should be 256 (0x100).  It is possible to go above or under this
+   *      target sum, however: going under means tossing out contrast, going
+   *      over means invoking clamping and thereby non-linearities that
+   *      increase contrast somewhat at the expense of greater distortion
+   *      and color-fringing.  Contrast is better enhanced through stem
+   *      darkening.
+   *
+   *   2) It should be color-balanced, meaning a filter `{~a, b, c, b, a~}'
+   *      where a~+ b~=~c.  It distributes the computed coverage for one
+   *      subpixel to all subpixels equally, sacrificing some won resolution
+   *      but drastically reducing color-fringing.  Positioning improvements
+   *      remain!  Note that color-fringing can only really be minimized
+   *      when using a color-balanced filter and alpha-blending the glyph
+   *      onto a surface in linear space; see @FT_Render_Glyph.
+   *
+   *   Regarding the form, a filter can be a `boxy' filter or a `beveled'
+   *   filter.  Boxy filters are sharper but are less forgiving of non-ideal
+   *   gamma curves of a screen (viewing angles!), beveled filters are
+   *   fuzzier but more tolerant.
+   *
+   *   Examples:
+   *
+   *   - [0x10 0x40 0x70 0x40 0x10] is beveled and neither balanced nor
+   *     normalized.
+   *
+   *   - [0x1A 0x33 0x4D 0x33 0x1A] is beveled and balanced but not
+   *     normalized.
+   *
+   *   - [0x19 0x33 0x66 0x4c 0x19] is beveled and normalized but not
+   *     balanced.
+   *
+   *   - [0x00 0x4c 0x66 0x4c 0x00] is boxily beveled and normalized but not
+   *     balanced.
+   *
+   *   - [0x00 0x55 0x56 0x55 0x00] is boxy, normalized, and almost
+   *     balanced.
+   *
+   *   - [0x08 0x4D 0x56 0x4D 0x08] is beveled, normalized and, almost
+   *     balanced.
+   *
+   *   The filter affects glyph bitmaps rendered through @FT_Render_Glyph,
+   *   @FT_Load_Glyph, and @FT_Load_Char.  It does _not_ affect the output
+   *   of @FT_Outline_Render and @FT_Outline_Get_Bitmap.
+   *
+   *   If this feature is activated, the dimensions of LCD glyph bitmaps are
+   *   either wider or taller than the dimensions of the corresponding
+   *   outline with regard to the pixel grid.  For example, for
+   *   @FT_RENDER_MODE_LCD, the filter adds 3~subpixels to the left, and
+   *   3~subpixels to the right.  The bitmap offset values are adjusted
+   *   accordingly, so clients shouldn't need to modify their layout and
+   *   glyph positioning code when enabling the filter.
+   *
+   *   It is important to understand that linear alpha blending and gamma
+   *   correction is critical for correctly rendering glyphs onto surfaces
+   *   without artifacts and even more critical when subpixel rendering is
+   *   involved.
+   *
+   *   Each of the 3~alpha values (subpixels) is independently used to blend
+   *   one color channel.  That is, red alpha blends the red channel of the
+   *   text color with the red channel of the background pixel.  The
+   *   distribution of density values by the color-balanced filter assumes
+   *   alpha blending is done in linear space; only then color artifacts
+   *   cancel out.
+   */
+
+
+  /****************************************************************************
+   *
+   * @enum:
+   *   FT_LcdFilter
+   *
+   * @description:
+   *   A list of values to identify various types of LCD filters.
+   *
+   * @values:
+   *   FT_LCD_FILTER_NONE ::
+   *     Do not perform filtering.  When used with subpixel rendering, this
+   *     results in sometimes severe color fringes.
+   *
+   *   FT_LCD_FILTER_DEFAULT ::
+   *     The default filter reduces color fringes considerably, at the cost
+   *     of a slight blurriness in the output.
+   *
+   *     It is a beveled, normalized, and color-balanced five-tap filter
+   *     that is more forgiving to screens with non-ideal gamma curves and
+   *     viewing angles.  Note that while color-fringing is reduced, it can
+   *     only be minimized by using linear alpha blending and gamma
+   *     correction to render glyphs onto surfaces.  The default filter
+   *     weights are [0x08 0x4D 0x56 0x4D 0x08].
+   *
+   *   FT_LCD_FILTER_LIGHT ::
+   *     The light filter is a variant that is sharper at the cost of
+   *     slightly more color fringes than the default one.
+   *
+   *     It is a boxy, normalized, and color-balanced three-tap filter that
+   *     is less forgiving to screens with non-ideal gamma curves and
+   *     viewing angles.  This filter works best when the rendering system
+   *     uses linear alpha blending and gamma correction to render glyphs
+   *     onto surfaces.  The light filter weights are
+   *     [0x00 0x55 0x56 0x55 0x00].
+   *
+   *   FT_LCD_FILTER_LEGACY ::
+   *     This filter corresponds to the original libXft color filter.  It
+   *     provides high contrast output but can exhibit really bad color
+   *     fringes if glyphs are not extremely well hinted to the pixel grid.
+   *     In other words, it only works well if the TrueType bytecode
+   *     interpreter is enabled *and* high-quality hinted fonts are used.
+   *
+   *     This filter is only provided for comparison purposes, and might be
+   *     disabled or stay unsupported in the future.
+   *
+   *   FT_LCD_FILTER_LEGACY1 ::
+   *     For historical reasons, the FontConfig library returns a different
+   *     enumeration value for legacy LCD filtering.  To make code work that
+   *     (incorrectly) forwards FontConfig's enumeration value to
+   *     @FT_Library_SetLcdFilter without proper mapping, it is thus easiest
+   *     to have another enumeration value, which is completely equal to
+   *     `FT_LCD_FILTER_LEGACY'.
+   *
+   * @since:
+   *   2.3.0 (`FT_LCD_FILTER_LEGACY1' since 2.6.2)
+   */
+  typedef enum  FT_LcdFilter_
+  {
+    FT_LCD_FILTER_NONE    = 0,
+    FT_LCD_FILTER_DEFAULT = 1,
+    FT_LCD_FILTER_LIGHT   = 2,
+    FT_LCD_FILTER_LEGACY1 = 3,
+    FT_LCD_FILTER_LEGACY  = 16,
+
+    FT_LCD_FILTER_MAX   /* do not remove */
+
+  } FT_LcdFilter;
+
+
+  /**************************************************************************
+   *
+   * @func:
+   *   FT_Library_SetLcdFilter
+   *
+   * @description:
+   *   This function is used to apply color filtering to LCD decimated
+   *   bitmaps, like the ones used when calling @FT_Render_Glyph with
+   *   @FT_RENDER_MODE_LCD or @FT_RENDER_MODE_LCD_V.
+   *
+   * @input:
+   *   library ::
+   *     A handle to the target library instance.
+   *
+   *   filter ::
+   *     The filter type.
+   *
+   *     You can use @FT_LCD_FILTER_NONE here to disable this feature, or
+   *     @FT_LCD_FILTER_DEFAULT to use a default filter that should work
+   *     well on most LCD screens.
+   *
+   * @return:
+   *   FreeType error code.  0~means success.
+   *
+   * @note:
+   *   This feature is always disabled by default.  Clients must make an
+   *   explicit call to this function with a `filter' value other than
+   *   @FT_LCD_FILTER_NONE in order to enable it.
+   *
+   *   Due to *PATENTS* covering subpixel rendering, this function doesn't
+   *   do anything except returning `FT_Err_Unimplemented_Feature' if the
+   *   configuration macro FT_CONFIG_OPTION_SUBPIXEL_RENDERING is not
+   *   defined in your build of the library, which should correspond to all
+   *   default builds of FreeType.
+   *
+   * @since:
+   *   2.3.0
+   */
+  FT_EXPORT( FT_Error )
+  FT_Library_SetLcdFilter( FT_Library    library,
+                           FT_LcdFilter  filter );
+
+
+  /**************************************************************************
+   *
+   * @func:
+   *   FT_Library_SetLcdFilterWeights
+   *
+   * @description:
+   *   This function can be used to enable LCD filter with custom weights,
+   *   instead of using presets in @FT_Library_SetLcdFilter.
+   *
+   * @input:
+   *   library ::
+   *     A handle to the target library instance.
+   *
+   *   weights ::
+   *     A pointer to an array; the function copies the first five bytes and
+   *     uses them to specify the filter weights.
+   *
+   * @return:
+   *   FreeType error code.  0~means success.
+   *
+   * @note:
+   *   Due to *PATENTS* covering subpixel rendering, this function doesn't
+   *   do anything except returning `FT_Err_Unimplemented_Feature' if the
+   *   configuration macro FT_CONFIG_OPTION_SUBPIXEL_RENDERING is not
+   *   defined in your build of the library, which should correspond to all
+   *   default builds of FreeType.
+   *
+   *   LCD filter weights can also be set per face using @FT_Face_Properties
+   *   with @FT_PARAM_TAG_LCD_FILTER_WEIGHTS.
+   *
+   * @since:
+   *   2.4.0
+   */
+  FT_EXPORT( FT_Error )
+  FT_Library_SetLcdFilterWeights( FT_Library      library,
+                                  unsigned char  *weights );
+
+
+  /**************************************************************************
+   *
+   * @constant:
+   *   FT_PARAM_TAG_LCD_FILTER_WEIGHTS
+   *
+   * @description:
+   *   An @FT_Parameter tag to be used with @FT_Face_Properties.  The
+   *   corresponding argument specifies the five LCD filter weights for a
+   *   given face (if using @FT_LOAD_TARGET_LCD, for example), overriding
+   *   the global default values or the values set up with
+   *   @FT_Library_SetLcdFilterWeights.
+   *
+   */
+#define FT_PARAM_TAG_LCD_FILTER_WEIGHTS \
+          FT_MAKE_TAG( 'l', 'c', 'd', 'f' )
+
+
+  /*
+   * @type:
+   *   FT_LcdFiveTapFilter
+   *
+   * @description:
+   *   A typedef for passing the five LCD filter weights to
+   *   @FT_Face_Properties within an @FT_Parameter structure.
+   *
+   */
+#define FT_LCD_FILTER_FIVE_TAPS  5
+
+  typedef FT_Byte  FT_LcdFiveTapFilter[FT_LCD_FILTER_FIVE_TAPS];
+
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* FTLCDFIL_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ftlist.h b/engine/inc/freetype/ftlist.h
new file mode 100644
index 00000000..5309cb18
--- /dev/null
+++ b/engine/inc/freetype/ftlist.h
@@ -0,0 +1,276 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftlist.h                                                               */
+/*                                                                         */
+/*    Generic list support for FreeType (specification).                   */
+/*                                                                         */
+/*  Copyright 1996-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*  This file implements functions relative to list processing.  Its     */
+  /*  data structures are defined in `freetype.h'.                         */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#ifndef FTLIST_H_
+#define FTLIST_H_
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    list_processing                                                    */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    List Processing                                                    */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    Simple management of lists.                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains various definitions related to list          */
+  /*    processing using doubly-linked nodes.                              */
+  /*                                                                       */
+  /* <Order>                                                               */
+  /*    FT_List                                                            */
+  /*    FT_ListNode                                                        */
+  /*    FT_ListRec                                                         */
+  /*    FT_ListNodeRec                                                     */
+  /*                                                                       */
+  /*    FT_List_Add                                                        */
+  /*    FT_List_Insert                                                     */
+  /*    FT_List_Find                                                       */
+  /*    FT_List_Remove                                                     */
+  /*    FT_List_Up                                                         */
+  /*    FT_List_Iterate                                                    */
+  /*    FT_List_Iterator                                                   */
+  /*    FT_List_Finalize                                                   */
+  /*    FT_List_Destructor                                                 */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_List_Find                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Find the list node for a given listed object.                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    list :: A pointer to the parent list.                              */
+  /*    data :: The address of the listed object.                          */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    List node.  NULL if it wasn't found.                               */
+  /*                                                                       */
+  FT_EXPORT( FT_ListNode )
+  FT_List_Find( FT_List  list,
+                void*    data );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_List_Add                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Append an element to the end of a list.                            */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    list :: A pointer to the parent list.                              */
+  /*    node :: The node to append.                                        */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_List_Add( FT_List      list,
+               FT_ListNode  node );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_List_Insert                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Insert an element at the head of a list.                           */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    list :: A pointer to parent list.                                  */
+  /*    node :: The node to insert.                                        */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_List_Insert( FT_List      list,
+                  FT_ListNode  node );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_List_Remove                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Remove a node from a list.  This function doesn't check whether    */
+  /*    the node is in the list!                                           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    node :: The node to remove.                                        */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    list :: A pointer to the parent list.                              */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_List_Remove( FT_List      list,
+                  FT_ListNode  node );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_List_Up                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Move a node to the head/top of a list.  Used to maintain LRU       */
+  /*    lists.                                                             */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    list :: A pointer to the parent list.                              */
+  /*    node :: The node to move.                                          */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_List_Up( FT_List      list,
+              FT_ListNode  node );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_List_Iterator                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An FT_List iterator function that is called during a list parse    */
+  /*    by @FT_List_Iterate.                                               */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    node :: The current iteration list node.                           */
+  /*                                                                       */
+  /*    user :: A typeless pointer passed to @FT_List_Iterate.             */
+  /*            Can be used to point to the iteration's state.             */
+  /*                                                                       */
+  typedef FT_Error
+  (*FT_List_Iterator)( FT_ListNode  node,
+                       void*        user );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_List_Iterate                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Parse a list and calls a given iterator function on each element.  */
+  /*    Note that parsing is stopped as soon as one of the iterator calls  */
+  /*    returns a non-zero value.                                          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    list     :: A handle to the list.                                  */
+  /*    iterator :: An iterator function, called on each node of the list. */
+  /*    user     :: A user-supplied field that is passed as the second     */
+  /*                argument to the iterator.                              */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The result (a FreeType error code) of the last iterator call.      */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_List_Iterate( FT_List           list,
+                   FT_List_Iterator  iterator,
+                   void*             user );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_List_Destructor                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An @FT_List iterator function that is called during a list         */
+  /*    finalization by @FT_List_Finalize to destroy all elements in a     */
+  /*    given list.                                                        */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    system :: The current system object.                               */
+  /*                                                                       */
+  /*    data   :: The current object to destroy.                           */
+  /*                                                                       */
+  /*    user   :: A typeless pointer passed to @FT_List_Iterate.  It can   */
+  /*              be used to point to the iteration's state.               */
+  /*                                                                       */
+  typedef void
+  (*FT_List_Destructor)( FT_Memory  memory,
+                         void*      data,
+                         void*      user );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_List_Finalize                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Destroy all elements in the list as well as the list itself.       */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    list    :: A handle to the list.                                   */
+  /*                                                                       */
+  /*    destroy :: A list destructor that will be applied to each element  */
+  /*               of the list.  Set this to NULL if not needed.           */
+  /*                                                                       */
+  /*    memory  :: The current memory object that handles deallocation.    */
+  /*                                                                       */
+  /*    user    :: A user-supplied field that is passed as the last        */
+  /*               argument to the destructor.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This function expects that all nodes added by @FT_List_Add or      */
+  /*    @FT_List_Insert have been dynamically allocated.                   */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_List_Finalize( FT_List             list,
+                    FT_List_Destructor  destroy,
+                    FT_Memory           memory,
+                    void*               user );
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* FTLIST_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ftlzw.h b/engine/inc/freetype/ftlzw.h
new file mode 100644
index 00000000..a82c95e7
--- /dev/null
+++ b/engine/inc/freetype/ftlzw.h
@@ -0,0 +1,99 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftlzw.h                                                                */
+/*                                                                         */
+/*    LZW-compressed stream support.                                       */
+/*                                                                         */
+/*  Copyright 2004-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTLZW_H_
+#define FTLZW_H_
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    lzw                                                                */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    LZW Streams                                                        */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    Using LZW-compressed font files.                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains the declaration of LZW-specific functions.   */
+  /*                                                                       */
+  /*************************************************************************/
+
+ /************************************************************************
+  *
+  * @function:
+  *   FT_Stream_OpenLZW
+  *
+  * @description:
+  *   Open a new stream to parse LZW-compressed font files.  This is
+  *   mainly used to support the compressed `*.pcf.Z' fonts that come
+  *   with XFree86.
+  *
+  * @input:
+  *   stream :: The target embedding stream.
+  *
+  *   source :: The source stream.
+  *
+  * @return:
+  *   FreeType error code.  0~means success.
+  *
+  * @note:
+  *   The source stream must be opened _before_ calling this function.
+  *
+  *   Calling the internal function `FT_Stream_Close' on the new stream will
+  *   *not* call `FT_Stream_Close' on the source stream.  None of the stream
+  *   objects will be released to the heap.
+  *
+  *   The stream implementation is very basic and resets the decompression
+  *   process each time seeking backwards is needed within the stream
+  *
+  *   In certain builds of the library, LZW compression recognition is
+  *   automatically handled when calling @FT_New_Face or @FT_Open_Face.
+  *   This means that if no font driver is capable of handling the raw
+  *   compressed file, the library will try to open a LZW stream from it
+  *   and re-open the face with it.
+  *
+  *   This function may return `FT_Err_Unimplemented_Feature' if your build
+  *   of FreeType was not compiled with LZW support.
+  */
+  FT_EXPORT( FT_Error )
+  FT_Stream_OpenLZW( FT_Stream  stream,
+                     FT_Stream  source );
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* FTLZW_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ftmac.h b/engine/inc/freetype/ftmac.h
new file mode 100644
index 00000000..a1656eec
--- /dev/null
+++ b/engine/inc/freetype/ftmac.h
@@ -0,0 +1,275 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftmac.h                                                                */
+/*                                                                         */
+/*    Additional Mac-specific API.                                         */
+/*                                                                         */
+/*  Copyright 1996-2017 by                                                 */
+/*  Just van Rossum, David Turner, Robert Wilhelm, and Werner Lemberg.     */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+/***************************************************************************/
+/*                                                                         */
+/* NOTE: Include this file after FT_FREETYPE_H and after any               */
+/*       Mac-specific headers (because this header uses Mac types such as  */
+/*       Handle, FSSpec, FSRef, etc.)                                      */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTMAC_H_
+#define FTMAC_H_
+
+
+#include <ft2build.h>
+
+
+FT_BEGIN_HEADER
+
+
+  /* gcc-3.1 and later can warn about functions tagged as deprecated */
+#ifndef FT_DEPRECATED_ATTRIBUTE
+#if defined( __GNUC__ )                                     && \
+    ( ( __GNUC__ >= 4 )                                  ||    \
+      ( ( __GNUC__ == 3 ) && ( __GNUC_MINOR__ >= 1 ) ) )
+#define FT_DEPRECATED_ATTRIBUTE  __attribute__(( deprecated ))
+#else
+#define FT_DEPRECATED_ATTRIBUTE
+#endif
+#endif
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    mac_specific                                                       */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    Mac Specific Interface                                             */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    Only available on the Macintosh.                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The following definitions are only available if FreeType is        */
+  /*    compiled on a Macintosh.                                           */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_New_Face_From_FOND                                              */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Create a new face object from a FOND resource.                     */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    library    :: A handle to the library resource.                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    fond       :: A FOND resource.                                     */
+  /*                                                                       */
+  /*    face_index :: Only supported for the -1 `sanity check' special     */
+  /*                  case.                                                */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    aface      :: A handle to a new face object.                       */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Notes>                                                               */
+  /*    This function can be used to create @FT_Face objects from fonts    */
+  /*    that are installed in the system as follows.                       */
+  /*                                                                       */
+  /*    {                                                                  */
+  /*      fond = GetResource( 'FOND', fontName );                          */
+  /*      error = FT_New_Face_From_FOND( library, fond, 0, &face );        */
+  /*    }                                                                  */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_New_Face_From_FOND( FT_Library  library,
+                         Handle      fond,
+                         FT_Long     face_index,
+                         FT_Face    *aface )
+                       FT_DEPRECATED_ATTRIBUTE;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_GetFile_From_Mac_Name                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Return an FSSpec for the disk file containing the named font.      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    fontName   :: Mac OS name of the font (e.g., Times New Roman       */
+  /*                  Bold).                                               */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    pathSpec   :: FSSpec to the file.  For passing to                  */
+  /*                  @FT_New_Face_From_FSSpec.                            */
+  /*                                                                       */
+  /*    face_index :: Index of the face.  For passing to                   */
+  /*                  @FT_New_Face_From_FSSpec.                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_GetFile_From_Mac_Name( const char*  fontName,
+                            FSSpec*      pathSpec,
+                            FT_Long*     face_index )
+                          FT_DEPRECATED_ATTRIBUTE;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_GetFile_From_Mac_ATS_Name                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Return an FSSpec for the disk file containing the named font.      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    fontName   :: Mac OS name of the font in ATS framework.            */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    pathSpec   :: FSSpec to the file. For passing to                   */
+  /*                  @FT_New_Face_From_FSSpec.                            */
+  /*                                                                       */
+  /*    face_index :: Index of the face. For passing to                    */
+  /*                  @FT_New_Face_From_FSSpec.                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_GetFile_From_Mac_ATS_Name( const char*  fontName,
+                                FSSpec*      pathSpec,
+                                FT_Long*     face_index )
+                              FT_DEPRECATED_ATTRIBUTE;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_GetFilePath_From_Mac_ATS_Name                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Return a pathname of the disk file and face index for given font   */
+  /*    name that is handled by ATS framework.                             */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    fontName    :: Mac OS name of the font in ATS framework.           */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    path        :: Buffer to store pathname of the file.  For passing  */
+  /*                   to @FT_New_Face.  The client must allocate this     */
+  /*                   buffer before calling this function.                */
+  /*                                                                       */
+  /*    maxPathSize :: Lengths of the buffer `path' that client allocated. */
+  /*                                                                       */
+  /*    face_index  :: Index of the face.  For passing to @FT_New_Face.    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_GetFilePath_From_Mac_ATS_Name( const char*  fontName,
+                                    UInt8*       path,
+                                    UInt32       maxPathSize,
+                                    FT_Long*     face_index )
+                                  FT_DEPRECATED_ATTRIBUTE;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_New_Face_From_FSSpec                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Create a new face object from a given resource and typeface index  */
+  /*    using an FSSpec to the font file.                                  */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    library    :: A handle to the library resource.                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    spec       :: FSSpec to the font file.                             */
+  /*                                                                       */
+  /*    face_index :: The index of the face within the resource.  The      */
+  /*                  first face has index~0.                              */
+  /* <Output>                                                              */
+  /*    aface      :: A handle to a new face object.                       */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    @FT_New_Face_From_FSSpec is identical to @FT_New_Face except       */
+  /*    it accepts an FSSpec instead of a path.                            */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_New_Face_From_FSSpec( FT_Library     library,
+                           const FSSpec  *spec,
+                           FT_Long        face_index,
+                           FT_Face       *aface )
+                         FT_DEPRECATED_ATTRIBUTE;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_New_Face_From_FSRef                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Create a new face object from a given resource and typeface index  */
+  /*    using an FSRef to the font file.                                   */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    library    :: A handle to the library resource.                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    spec       :: FSRef to the font file.                              */
+  /*                                                                       */
+  /*    face_index :: The index of the face within the resource.  The      */
+  /*                  first face has index~0.                              */
+  /* <Output>                                                              */
+  /*    aface      :: A handle to a new face object.                       */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    @FT_New_Face_From_FSRef is identical to @FT_New_Face except        */
+  /*    it accepts an FSRef instead of a path.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_New_Face_From_FSRef( FT_Library    library,
+                          const FSRef  *ref,
+                          FT_Long       face_index,
+                          FT_Face      *aface )
+                        FT_DEPRECATED_ATTRIBUTE;
+
+  /* */
+
+
+FT_END_HEADER
+
+
+#endif /* FTMAC_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ftmm.h b/engine/inc/freetype/ftmm.h
new file mode 100644
index 00000000..80ac98d6
--- /dev/null
+++ b/engine/inc/freetype/ftmm.h
@@ -0,0 +1,550 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftmm.h                                                                 */
+/*                                                                         */
+/*    FreeType Multiple Master font interface (specification).             */
+/*                                                                         */
+/*  Copyright 1996-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTMM_H_
+#define FTMM_H_
+
+
+#include <ft2build.h>
+#include FT_TYPE1_TABLES_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    multiple_masters                                                   */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    Multiple Masters                                                   */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    How to manage Multiple Masters fonts.                              */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The following types and functions are used to manage Multiple      */
+  /*    Master fonts, i.e., the selection of specific design instances by  */
+  /*    setting design axis coordinates.                                   */
+  /*                                                                       */
+  /*    Besides Adobe MM fonts, the interface supports Apple's TrueType GX */
+  /*    and OpenType variation fonts.  Some of the routines only work with */
+  /*    Adobe MM fonts, others will work with all three types.  They are   */
+  /*    similar enough that a consistent interface makes sense.            */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_MM_Axis                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure to model a given axis in design space for Multiple     */
+  /*    Masters fonts.                                                     */
+  /*                                                                       */
+  /*    This structure can't be used for TrueType GX or OpenType variation */
+  /*    fonts.                                                             */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    name    :: The axis's name.                                        */
+  /*                                                                       */
+  /*    minimum :: The axis's minimum design coordinate.                   */
+  /*                                                                       */
+  /*    maximum :: The axis's maximum design coordinate.                   */
+  /*                                                                       */
+  typedef struct  FT_MM_Axis_
+  {
+    FT_String*  name;
+    FT_Long     minimum;
+    FT_Long     maximum;
+
+  } FT_MM_Axis;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Multi_Master                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure to model the axes and space of a Multiple Masters      */
+  /*    font.                                                              */
+  /*                                                                       */
+  /*    This structure can't be used for TrueType GX or OpenType variation */
+  /*    fonts.                                                             */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    num_axis    :: Number of axes.  Cannot exceed~4.                   */
+  /*                                                                       */
+  /*    num_designs :: Number of designs; should be normally 2^num_axis    */
+  /*                   even though the Type~1 specification strangely      */
+  /*                   allows for intermediate designs to be present.      */
+  /*                   This number cannot exceed~16.                       */
+  /*                                                                       */
+  /*    axis        :: A table of axis descriptors.                        */
+  /*                                                                       */
+  typedef struct  FT_Multi_Master_
+  {
+    FT_UInt     num_axis;
+    FT_UInt     num_designs;
+    FT_MM_Axis  axis[T1_MAX_MM_AXIS];
+
+  } FT_Multi_Master;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Var_Axis                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure to model a given axis in design space for Multiple     */
+  /*    Masters, TrueType GX, and OpenType variation fonts.                */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    name    :: The axis's name.                                        */
+  /*               Not always meaningful for TrueType GX or OpenType       */
+  /*               variation fonts.                                        */
+  /*                                                                       */
+  /*    minimum :: The axis's minimum design coordinate.                   */
+  /*                                                                       */
+  /*    def     :: The axis's default design coordinate.                   */
+  /*               FreeType computes meaningful default values for Adobe   */
+  /*               MM fonts.                                               */
+  /*                                                                       */
+  /*    maximum :: The axis's maximum design coordinate.                   */
+  /*                                                                       */
+  /*    tag     :: The axis's tag (the equivalent to `name' for TrueType   */
+  /*               GX and OpenType variation fonts).  FreeType provides    */
+  /*               default values for Adobe MM fonts if possible.          */
+  /*                                                                       */
+  /*    strid   :: The axis name entry in the font's `name' table.  This   */
+  /*               is another (and often better) version of the `name'     */
+  /*               field for TrueType GX or OpenType variation fonts.  Not */
+  /*               meaningful for Adobe MM fonts.                          */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The fields `minimum', `def', and `maximum' are 16.16 fractional    */
+  /*    values for TrueType GX and OpenType variation fonts.  For Adobe MM */
+  /*    fonts, the values are integers.                                    */
+  /*                                                                       */
+  typedef struct  FT_Var_Axis_
+  {
+    FT_String*  name;
+
+    FT_Fixed    minimum;
+    FT_Fixed    def;
+    FT_Fixed    maximum;
+
+    FT_ULong    tag;
+    FT_UInt     strid;
+
+  } FT_Var_Axis;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Var_Named_Style                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure to model a named instance in a TrueType GX or OpenType */
+  /*    variation font.                                                    */
+  /*                                                                       */
+  /*    This structure can't be used for Adobe MM fonts.                   */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    coords :: The design coordinates for this instance.                */
+  /*              This is an array with one entry for each axis.           */
+  /*                                                                       */
+  /*    strid  :: The entry in `name' table identifying this instance.     */
+  /*                                                                       */
+  /*    psid   :: The entry in `name' table identifying a PostScript name  */
+  /*              for this instance.  Value 0xFFFF indicates a missing     */
+  /*              entry.                                                   */
+  /*                                                                       */
+  typedef struct  FT_Var_Named_Style_
+  {
+    FT_Fixed*  coords;
+    FT_UInt    strid;
+    FT_UInt    psid;   /* since 2.7.1 */
+
+  } FT_Var_Named_Style;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_MM_Var                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure to model the axes and space of an Adobe MM, TrueType   */
+  /*    GX, or OpenType variation font.                                    */
+  /*                                                                       */
+  /*    Some fields are specific to one format and not to the others.      */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    num_axis        :: The number of axes.  The maximum value is~4 for */
+  /*                       Adobe MM fonts; no limit in TrueType GX or      */
+  /*                       OpenType variation fonts.                       */
+  /*                                                                       */
+  /*    num_designs     :: The number of designs; should be normally       */
+  /*                       2^num_axis for Adobe MM fonts.  Not meaningful  */
+  /*                       for TrueType GX or OpenType variation fonts     */
+  /*                       (where every glyph could have a different       */
+  /*                       number of designs).                             */
+  /*                                                                       */
+  /*    num_namedstyles :: The number of named styles; a `named style' is  */
+  /*                       a tuple of design coordinates that has a string */
+  /*                       ID (in the `name' table) associated with it.    */
+  /*                       The font can tell the user that, for example,   */
+  /*                       [Weight=1.5,Width=1.1] is `Bold'.  Another name */
+  /*                       for `named style' is `named instance'.          */
+  /*                                                                       */
+  /*                       For Adobe Multiple Masters fonts, this value is */
+  /*                       always zero because the format does not support */
+  /*                       named styles.                                   */
+  /*                                                                       */
+  /*    axis            :: An axis descriptor table.                       */
+  /*                       TrueType GX and OpenType variation fonts        */
+  /*                       contain slightly more data than Adobe MM fonts. */
+  /*                       Memory management of this pointer is done       */
+  /*                       internally by FreeType.                         */
+  /*                                                                       */
+  /*    namedstyle      :: A named style (instance) table.                 */
+  /*                       Only meaningful for TrueType GX and OpenType    */
+  /*                       variation fonts.  Memory management of this     */
+  /*                       pointer is done internally by FreeType.         */
+  /*                                                                       */
+  typedef struct  FT_MM_Var_
+  {
+    FT_UInt              num_axis;
+    FT_UInt              num_designs;
+    FT_UInt              num_namedstyles;
+    FT_Var_Axis*         axis;
+    FT_Var_Named_Style*  namedstyle;
+
+  } FT_MM_Var;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Multi_Master                                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Retrieve a variation descriptor of a given Adobe MM font.          */
+  /*                                                                       */
+  /*    This function can't be used with TrueType GX or OpenType variation */
+  /*    fonts.                                                             */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face    :: A handle to the source face.                            */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    amaster :: The Multiple Masters descriptor.                        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Get_Multi_Master( FT_Face           face,
+                       FT_Multi_Master  *amaster );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_MM_Var                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Retrieve a variation descriptor for a given font.                  */
+  /*                                                                       */
+  /*    This function works with all supported variation formats.          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face    :: A handle to the source face.                            */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    amaster :: The variation descriptor.                               */
+  /*               Allocates a data structure, which the user must         */
+  /*               deallocate with `free' after use.                       */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Get_MM_Var( FT_Face      face,
+                 FT_MM_Var*  *amaster );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Set_MM_Design_Coordinates                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    For Adobe MM fonts, choose an interpolated font design through     */
+  /*    design coordinates.                                                */
+  /*                                                                       */
+  /*    This function can't be used with TrueType GX or OpenType variation */
+  /*    fonts.                                                             */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face       :: A handle to the source face.                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    num_coords :: The number of available design coordinates.  If it   */
+  /*                  is larger than the number of axes, ignore the excess */
+  /*                  values.  If it is smaller than the number of axes,   */
+  /*                  use default values for the remaining axes.           */
+  /*                                                                       */
+  /*    coords     :: An array of design coordinates.                      */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    To reset all axes to the default values, call the function with    */
+  /*    `num_coords' set to zero and `coords' set to NULL (new feature in  */
+  /*    FreeType version 2.8.1).                                           */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Set_MM_Design_Coordinates( FT_Face   face,
+                                FT_UInt   num_coords,
+                                FT_Long*  coords );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Set_Var_Design_Coordinates                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Choose an interpolated font design through design coordinates.     */
+  /*                                                                       */
+  /*    This function works with all supported variation formats.          */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face       :: A handle to the source face.                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    num_coords :: The number of available design coordinates.  If it   */
+  /*                  is larger than the number of axes, ignore the excess */
+  /*                  values.  If it is smaller than the number of axes,   */
+  /*                  use default values for the remaining axes.           */
+  /*                                                                       */
+  /*    coords     :: An array of design coordinates.                      */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    To reset all axes to the default values, call the function with    */
+  /*    `num_coords' set to zero and `coords' set to NULL (new feature in  */
+  /*    FreeType version 2.8.1).                                           */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Set_Var_Design_Coordinates( FT_Face    face,
+                                 FT_UInt    num_coords,
+                                 FT_Fixed*  coords );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Var_Design_Coordinates                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Get the design coordinates of the currently selected interpolated  */
+  /*    font.                                                              */
+  /*                                                                       */
+  /*    This function works with all supported variation formats.          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face       :: A handle to the source face.                         */
+  /*                                                                       */
+  /*    num_coords :: The number of design coordinates to retrieve.  If it */
+  /*                  is larger than the number of axes, set the excess    */
+  /*                  values to~0.                                         */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    coords     :: The design coordinates array.                        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Get_Var_Design_Coordinates( FT_Face    face,
+                                 FT_UInt    num_coords,
+                                 FT_Fixed*  coords );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Set_MM_Blend_Coordinates                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Choose an interpolated font design through normalized blend        */
+  /*    coordinates.                                                       */
+  /*                                                                       */
+  /*    This function works with all supported variation formats.          */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face       :: A handle to the source face.                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    num_coords :: The number of available design coordinates.  If it   */
+  /*                  is larger than the number of axes, ignore the excess */
+  /*                  values.  If it is smaller than the number of axes,   */
+  /*                  use default values for the remaining axes.           */
+  /*                                                                       */
+  /*    coords     :: The design coordinates array (each element must be   */
+  /*                  between 0 and 1.0 for Adobe MM fonts, and between    */
+  /*                  -1.0 and 1.0 for TrueType GX and OpenType variation  */
+  /*                  fonts).                                              */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    To reset all axes to the default values, call the function with    */
+  /*    `num_coords' set to zero and `coords' set to NULL (new feature in  */
+  /*    FreeType version 2.8.1).                                           */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Set_MM_Blend_Coordinates( FT_Face    face,
+                               FT_UInt    num_coords,
+                               FT_Fixed*  coords );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_MM_Blend_Coordinates                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Get the normalized blend coordinates of the currently selected     */
+  /*    interpolated font.                                                 */
+  /*                                                                       */
+  /*    This function works with all supported variation formats.          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face       :: A handle to the source face.                         */
+  /*                                                                       */
+  /*    num_coords :: The number of normalized blend coordinates to        */
+  /*                  retrieve.  If it is larger than the number of axes,  */
+  /*                  set the excess values to~0.5 for Adobe MM fonts, and */
+  /*                  to~0 for TrueType GX and OpenType variation fonts.   */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    coords     :: The normalized blend coordinates array.              */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Get_MM_Blend_Coordinates( FT_Face    face,
+                               FT_UInt    num_coords,
+                               FT_Fixed*  coords );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Set_Var_Blend_Coordinates                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This is another name of @FT_Set_MM_Blend_Coordinates.              */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Set_Var_Blend_Coordinates( FT_Face    face,
+                                FT_UInt    num_coords,
+                                FT_Fixed*  coords );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Var_Blend_Coordinates                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This is another name of @FT_Get_MM_Blend_Coordinates.              */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Get_Var_Blend_Coordinates( FT_Face    face,
+                                FT_UInt    num_coords,
+                                FT_Fixed*  coords );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    FT_VAR_AXIS_FLAG_XXX                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A list of bit flags used in the return value of                    */
+  /*    @FT_Get_Var_Axis_Flags.                                            */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    FT_VAR_AXIS_FLAG_HIDDEN ::                                         */
+  /*      The variation axis should not be exposed to user interfaces.     */
+  /*                                                                       */
+#define FT_VAR_AXIS_FLAG_HIDDEN  1
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Var_Axis_Flags                                              */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Get the `flags' field of an OpenType Variation Axis Record.        */
+  /*                                                                       */
+  /*    Not meaningful for Adobe MM fonts (`*flags' is always zero).       */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    master     :: The variation descriptor.                            */
+  /*                                                                       */
+  /*    axis_index :: The index of the requested variation axis.           */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    flags      :: The `flags' field.  See @FT_VAR_AXIS_FLAG_XXX for    */
+  /*                  possible values.                                     */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Get_Var_Axis_Flags( FT_MM_Var*  master,
+                         FT_UInt     axis_index,
+                         FT_UInt*    flags );
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* FTMM_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ftmodapi.h b/engine/inc/freetype/ftmodapi.h
new file mode 100644
index 00000000..4147aadf
--- /dev/null
+++ b/engine/inc/freetype/ftmodapi.h
@@ -0,0 +1,710 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftmodapi.h                                                             */
+/*                                                                         */
+/*    FreeType modules public interface (specification).                   */
+/*                                                                         */
+/*  Copyright 1996-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTMODAPI_H_
+#define FTMODAPI_H_
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    module_management                                                  */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    Module Management                                                  */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    How to add, upgrade, remove, and control modules from FreeType.    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The definitions below are used to manage modules within FreeType.  */
+  /*    Modules can be added, upgraded, and removed at runtime.            */
+  /*    Additionally, some module properties can be controlled also.       */
+  /*                                                                       */
+  /*    Here is a list of possible values of the `module_name' field in    */
+  /*    the @FT_Module_Class structure.                                    */
+  /*                                                                       */
+  /*    {                                                                  */
+  /*      autofitter                                                       */
+  /*      bdf                                                              */
+  /*      cff                                                              */
+  /*      gxvalid                                                          */
+  /*      otvalid                                                          */
+  /*      pcf                                                              */
+  /*      pfr                                                              */
+  /*      psaux                                                            */
+  /*      pshinter                                                         */
+  /*      psnames                                                          */
+  /*      raster1                                                          */
+  /*      sfnt                                                             */
+  /*      smooth, smooth-lcd, smooth-lcdv                                  */
+  /*      truetype                                                         */
+  /*      type1                                                            */
+  /*      type42                                                           */
+  /*      t1cid                                                            */
+  /*      winfonts                                                         */
+  /*    }                                                                  */
+  /*                                                                       */
+  /*    Note that the FreeType Cache sub-system is not a FreeType module.  */
+  /*                                                                       */
+  /* <Order>                                                               */
+  /*    FT_Module                                                          */
+  /*    FT_Module_Constructor                                              */
+  /*    FT_Module_Destructor                                               */
+  /*    FT_Module_Requester                                                */
+  /*    FT_Module_Class                                                    */
+  /*                                                                       */
+  /*    FT_Add_Module                                                      */
+  /*    FT_Get_Module                                                      */
+  /*    FT_Remove_Module                                                   */
+  /*    FT_Add_Default_Modules                                             */
+  /*                                                                       */
+  /*    FT_Property_Set                                                    */
+  /*    FT_Property_Get                                                    */
+  /*    FT_Set_Default_Properties                                          */
+  /*                                                                       */
+  /*    FT_New_Library                                                     */
+  /*    FT_Done_Library                                                    */
+  /*    FT_Reference_Library                                               */
+  /*                                                                       */
+  /*    FT_Renderer                                                        */
+  /*    FT_Renderer_Class                                                  */
+  /*                                                                       */
+  /*    FT_Get_Renderer                                                    */
+  /*    FT_Set_Renderer                                                    */
+  /*                                                                       */
+  /*    FT_Set_Debug_Hook                                                  */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /* module bit flags */
+#define FT_MODULE_FONT_DRIVER         1  /* this module is a font driver  */
+#define FT_MODULE_RENDERER            2  /* this module is a renderer     */
+#define FT_MODULE_HINTER              4  /* this module is a glyph hinter */
+#define FT_MODULE_STYLER              8  /* this module is a styler       */
+
+#define FT_MODULE_DRIVER_SCALABLE      0x100  /* the driver supports      */
+                                              /* scalable fonts           */
+#define FT_MODULE_DRIVER_NO_OUTLINES   0x200  /* the driver does not      */
+                                              /* support vector outlines  */
+#define FT_MODULE_DRIVER_HAS_HINTER    0x400  /* the driver provides its  */
+                                              /* own hinter               */
+#define FT_MODULE_DRIVER_HINTS_LIGHTLY 0x800  /* the driver's hinter      */
+                                              /* produces LIGHT hints     */
+
+
+  /* deprecated values */
+#define ft_module_font_driver         FT_MODULE_FONT_DRIVER
+#define ft_module_renderer            FT_MODULE_RENDERER
+#define ft_module_hinter              FT_MODULE_HINTER
+#define ft_module_styler              FT_MODULE_STYLER
+
+#define ft_module_driver_scalable       FT_MODULE_DRIVER_SCALABLE
+#define ft_module_driver_no_outlines    FT_MODULE_DRIVER_NO_OUTLINES
+#define ft_module_driver_has_hinter     FT_MODULE_DRIVER_HAS_HINTER
+#define ft_module_driver_hints_lightly  FT_MODULE_DRIVER_HINTS_LIGHTLY
+
+
+  typedef FT_Pointer  FT_Module_Interface;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_Module_Constructor                                              */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function used to initialize (not create) a new module object.    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    module :: The module to initialize.                                */
+  /*                                                                       */
+  typedef FT_Error
+  (*FT_Module_Constructor)( FT_Module  module );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_Module_Destructor                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function used to finalize (not destroy) a given module object.   */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    module :: The module to finalize.                                  */
+  /*                                                                       */
+  typedef void
+  (*FT_Module_Destructor)( FT_Module  module );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_Module_Requester                                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function used to query a given module for a specific interface.  */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    module :: The module to be searched.                               */
+  /*                                                                       */
+  /*    name ::   The name of the interface in the module.                 */
+  /*                                                                       */
+  typedef FT_Module_Interface
+  (*FT_Module_Requester)( FT_Module    module,
+                          const char*  name );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Module_Class                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The module class descriptor.                                       */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    module_flags    :: Bit flags describing the module.                */
+  /*                                                                       */
+  /*    module_size     :: The size of one module object/instance in       */
+  /*                       bytes.                                          */
+  /*                                                                       */
+  /*    module_name     :: The name of the module.                         */
+  /*                                                                       */
+  /*    module_version  :: The version, as a 16.16 fixed number            */
+  /*                       (major.minor).                                  */
+  /*                                                                       */
+  /*    module_requires :: The version of FreeType this module requires,   */
+  /*                       as a 16.16 fixed number (major.minor).  Starts  */
+  /*                       at version 2.0, i.e., 0x20000.                  */
+  /*                                                                       */
+  /*    module_init     :: The initializing function.                      */
+  /*                                                                       */
+  /*    module_done     :: The finalizing function.                        */
+  /*                                                                       */
+  /*    get_interface   :: The interface requesting function.              */
+  /*                                                                       */
+  typedef struct  FT_Module_Class_
+  {
+    FT_ULong               module_flags;
+    FT_Long                module_size;
+    const FT_String*       module_name;
+    FT_Fixed               module_version;
+    FT_Fixed               module_requires;
+
+    const void*            module_interface;
+
+    FT_Module_Constructor  module_init;
+    FT_Module_Destructor   module_done;
+    FT_Module_Requester    get_interface;
+
+  } FT_Module_Class;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Add_Module                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Add a new module to a given library instance.                      */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    library :: A handle to the library object.                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    clazz   :: A pointer to class descriptor for the module.           */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    An error will be returned if a module already exists by that name, */
+  /*    or if the module requires a version of FreeType that is too great. */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Add_Module( FT_Library              library,
+                 const FT_Module_Class*  clazz );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Module                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Find a module by its name.                                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    library     :: A handle to the library object.                     */
+  /*                                                                       */
+  /*    module_name :: The module's name (as an ASCII string).             */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    A module handle.  0~if none was found.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    FreeType's internal modules aren't documented very well, and you   */
+  /*    should look up the source code for details.                        */
+  /*                                                                       */
+  FT_EXPORT( FT_Module )
+  FT_Get_Module( FT_Library   library,
+                 const char*  module_name );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Remove_Module                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Remove a given module from a library instance.                     */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    library :: A handle to a library object.                           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    module  :: A handle to a module object.                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The module object is destroyed by the function in case of success. */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Remove_Module( FT_Library  library,
+                    FT_Module   module );
+
+
+  /**********************************************************************
+   *
+   * @function:
+   *    FT_Property_Set
+   *
+   * @description:
+   *    Set a property for a given module.
+   *
+   * @input:
+   *    library ::
+   *       A handle to the library the module is part of.
+   *
+   *    module_name ::
+   *       The module name.
+   *
+   *    property_name ::
+   *       The property name.  Properties are described in the `Synopsis'
+   *       subsection of the module's documentation.
+   *
+   *       Note that only a few modules have properties.
+   *
+   *    value ::
+   *       A generic pointer to a variable or structure that gives the new
+   *       value of the property.  The exact definition of `value' is
+   *       dependent on the property; see the `Synopsis' subsection of the
+   *       module's documentation.
+   *
+   * @return:
+   *   FreeType error code.  0~means success.
+   *
+   * @note:
+   *    If `module_name' isn't a valid module name, or `property_name'
+   *    doesn't specify a valid property, or if `value' doesn't represent a
+   *    valid value for the given property, an error is returned.
+   *
+   *    The following example sets property `bar' (a simple integer) in
+   *    module `foo' to value~1.
+   *
+   *    {
+   *      FT_UInt  bar;
+   *
+   *
+   *      bar = 1;
+   *      FT_Property_Set( library, "foo", "bar", &bar );
+   *    }
+   *
+   *    Note that the FreeType Cache sub-system doesn't recognize module
+   *    property changes.  To avoid glyph lookup confusion within the cache
+   *    you should call @FTC_Manager_Reset to completely flush the cache if
+   *    a module property gets changed after @FTC_Manager_New has been
+   *    called.
+   *
+   *    It is not possible to set properties of the FreeType Cache
+   *    sub-system itself with FT_Property_Set; use @FTC_Property_Set
+   *    instead.
+   *
+   *  @since:
+   *    2.4.11
+   *
+   */
+  FT_EXPORT( FT_Error )
+  FT_Property_Set( FT_Library        library,
+                   const FT_String*  module_name,
+                   const FT_String*  property_name,
+                   const void*       value );
+
+
+  /**********************************************************************
+   *
+   * @function:
+   *    FT_Property_Get
+   *
+   * @description:
+   *    Get a module's property value.
+   *
+   * @input:
+   *    library ::
+   *       A handle to the library the module is part of.
+   *
+   *    module_name ::
+   *       The module name.
+   *
+   *    property_name ::
+   *       The property name.  Properties are described in the `Synopsis'
+   *       subsection of the module's documentation.
+   *
+   * @inout:
+   *    value ::
+   *       A generic pointer to a variable or structure that gives the
+   *       value of the property.  The exact definition of `value' is
+   *       dependent on the property; see the `Synopsis' subsection of the
+   *       module's documentation.
+   *
+   * @return:
+   *   FreeType error code.  0~means success.
+   *
+   * @note:
+   *    If `module_name' isn't a valid module name, or `property_name'
+   *    doesn't specify a valid property, or if `value' doesn't represent a
+   *    valid value for the given property, an error is returned.
+   *
+   *    The following example gets property `baz' (a range) in module `foo'.
+   *
+   *    {
+   *      typedef  range_
+   *      {
+   *        FT_Int32  min;
+   *        FT_Int32  max;
+   *
+   *      } range;
+   *
+   *      range  baz;
+   *
+   *
+   *      FT_Property_Get( library, "foo", "baz", &baz );
+   *    }
+   *
+   *    It is not possible to retrieve properties of the FreeType Cache
+   *    sub-system with FT_Property_Get; use @FTC_Property_Get instead.
+   *
+   *  @since:
+   *    2.4.11
+   *
+   */
+  FT_EXPORT( FT_Error )
+  FT_Property_Get( FT_Library        library,
+                   const FT_String*  module_name,
+                   const FT_String*  property_name,
+                   void*             value );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Set_Default_Properties                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    If compilation option FT_CONFIG_OPTION_ENVIRONMENT_PROPERTIES is   */
+  /*    set, this function reads the `FREETYPE_PROPERTIES' environment     */
+  /*    variable to control driver properties.  See sections @auto_hinter, */
+  /*    @cff_driver, @pcf_driver, and @tt_driver for more.                 */
+  /*                                                                       */
+  /*    If the compilation option is not set, this function does nothing.  */
+  /*                                                                       */
+  /*    `FREETYPE_PROPERTIES' has the following syntax form (broken here   */
+  /*    into multiple lines for better readability).                       */
+  /*                                                                       */
+  /*    {                                                                  */
+  /*      <optional whitespace>                                            */
+  /*      <module-name1> ':'                                               */
+  /*      <property-name1> '=' <property-value1>                           */
+  /*      <whitespace>                                                     */
+  /*      <module-name2> ':'                                               */
+  /*      <property-name2> '=' <property-value2>                           */
+  /*      ...                                                              */
+  /*    }                                                                  */
+  /*                                                                       */
+  /*    Example:                                                           */
+  /*                                                                       */
+  /*    {                                                                  */
+  /*      FREETYPE_PROPERTIES=truetype:interpreter-version=35 \            */
+  /*                          cff:no-stem-darkening=1 \                    */
+  /*                          autofitter:warping=1                         */
+  /*    }                                                                  */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    library :: A handle to a new library object.                       */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Set_Default_Properties( FT_Library  library );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Reference_Library                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A counter gets initialized to~1 at the time an @FT_Library         */
+  /*    structure is created.  This function increments the counter.       */
+  /*    @FT_Done_Library then only destroys a library if the counter is~1, */
+  /*    otherwise it simply decrements the counter.                        */
+  /*                                                                       */
+  /*    This function helps in managing life-cycles of structures that     */
+  /*    reference @FT_Library objects.                                     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    library :: A handle to a target library object.                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Since>                                                               */
+  /*    2.4.2                                                              */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Reference_Library( FT_Library  library );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_New_Library                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This function is used to create a new FreeType library instance    */
+  /*    from a given memory object.  It is thus possible to use libraries  */
+  /*    with distinct memory allocators within the same program.  Note,    */
+  /*    however, that the used @FT_Memory structure is expected to remain  */
+  /*    valid for the life of the @FT_Library object.                      */
+  /*                                                                       */
+  /*    Normally, you would call this function (followed by a call to      */
+  /*    @FT_Add_Default_Modules or a series of calls to @FT_Add_Module,    */
+  /*    and a call to @FT_Set_Default_Properties) instead of               */
+  /*    @FT_Init_FreeType to initialize the FreeType library.              */
+  /*                                                                       */
+  /*    Don't use @FT_Done_FreeType but @FT_Done_Library to destroy a      */
+  /*    library instance.                                                  */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    memory   :: A handle to the original memory object.                */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    alibrary :: A pointer to handle of a new library object.           */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    See the discussion of reference counters in the description of     */
+  /*    @FT_Reference_Library.                                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_New_Library( FT_Memory    memory,
+                  FT_Library  *alibrary );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Done_Library                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Discard a given library object.  This closes all drivers and       */
+  /*    discards all resource objects.                                     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    library :: A handle to the target library.                         */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    See the discussion of reference counters in the description of     */
+  /*    @FT_Reference_Library.                                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Done_Library( FT_Library  library );
+
+  /* */
+
+  typedef void
+  (*FT_DebugHook_Func)( void*  arg );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Set_Debug_Hook                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Set a debug hook function for debugging the interpreter of a font  */
+  /*    format.                                                            */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    library    :: A handle to the library object.                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    hook_index :: The index of the debug hook.  You should use the     */
+  /*                  values defined in `ftobjs.h', e.g.,                  */
+  /*                  `FT_DEBUG_HOOK_TRUETYPE'.                            */
+  /*                                                                       */
+  /*    debug_hook :: The function used to debug the interpreter.          */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Currently, four debug hook slots are available, but only two (for  */
+  /*    the TrueType and the Type~1 interpreter) are defined.              */
+  /*                                                                       */
+  /*    Since the internal headers of FreeType are no longer installed,    */
+  /*    the symbol `FT_DEBUG_HOOK_TRUETYPE' isn't available publicly.      */
+  /*    This is a bug and will be fixed in a forthcoming release.          */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Set_Debug_Hook( FT_Library         library,
+                     FT_UInt            hook_index,
+                     FT_DebugHook_Func  debug_hook );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Add_Default_Modules                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Add the set of default drivers to a given library object.          */
+  /*    This is only useful when you create a library object with          */
+  /*    @FT_New_Library (usually to plug a custom memory manager).         */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    library :: A handle to a new library object.                       */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Add_Default_Modules( FT_Library  library );
+
+
+
+  /**************************************************************************
+   *
+   * @section:
+   *   truetype_engine
+   *
+   * @title:
+   *   The TrueType Engine
+   *
+   * @abstract:
+   *   TrueType bytecode support.
+   *
+   * @description:
+   *   This section contains a function used to query the level of TrueType
+   *   bytecode support compiled in this version of the library.
+   *
+   */
+
+
+  /**************************************************************************
+   *
+   *  @enum:
+   *     FT_TrueTypeEngineType
+   *
+   *  @description:
+   *     A list of values describing which kind of TrueType bytecode
+   *     engine is implemented in a given FT_Library instance.  It is used
+   *     by the @FT_Get_TrueType_Engine_Type function.
+   *
+   *  @values:
+   *     FT_TRUETYPE_ENGINE_TYPE_NONE ::
+   *       The library doesn't implement any kind of bytecode interpreter.
+   *
+   *     FT_TRUETYPE_ENGINE_TYPE_UNPATENTED ::
+   *       Deprecated and removed.
+   *
+   *     FT_TRUETYPE_ENGINE_TYPE_PATENTED ::
+   *       The library implements a bytecode interpreter that covers
+   *       the full instruction set of the TrueType virtual machine (this
+   *       was governed by patents until May 2010, hence the name).
+   *
+   *  @since:
+   *     2.2
+   *
+   */
+  typedef enum  FT_TrueTypeEngineType_
+  {
+    FT_TRUETYPE_ENGINE_TYPE_NONE = 0,
+    FT_TRUETYPE_ENGINE_TYPE_UNPATENTED,
+    FT_TRUETYPE_ENGINE_TYPE_PATENTED
+
+  } FT_TrueTypeEngineType;
+
+
+  /**************************************************************************
+   *
+   *  @func:
+   *     FT_Get_TrueType_Engine_Type
+   *
+   *  @description:
+   *     Return an @FT_TrueTypeEngineType value to indicate which level of
+   *     the TrueType virtual machine a given library instance supports.
+   *
+   *  @input:
+   *     library ::
+   *       A library instance.
+   *
+   *  @return:
+   *     A value indicating which level is supported.
+   *
+   *  @since:
+   *     2.2
+   *
+   */
+  FT_EXPORT( FT_TrueTypeEngineType )
+  FT_Get_TrueType_Engine_Type( FT_Library  library );
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* FTMODAPI_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ftmoderr.h b/engine/inc/freetype/ftmoderr.h
new file mode 100644
index 00000000..7f608375
--- /dev/null
+++ b/engine/inc/freetype/ftmoderr.h
@@ -0,0 +1,194 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftmoderr.h                                                             */
+/*                                                                         */
+/*    FreeType module error offsets (specification).                       */
+/*                                                                         */
+/*  Copyright 2001-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This file is used to define the FreeType module error codes.          */
+  /*                                                                       */
+  /* If the macro FT_CONFIG_OPTION_USE_MODULE_ERRORS in `ftoption.h' is    */
+  /* set, the lower byte of an error value identifies the error code as    */
+  /* usual.  In addition, the higher byte identifies the module.  For      */
+  /* example, the error `FT_Err_Invalid_File_Format' has value 0x0003, the */
+  /* error `TT_Err_Invalid_File_Format' has value 0x1303, the error        */
+  /* `T1_Err_Invalid_File_Format' has value 0x1403, etc.                   */
+  /*                                                                       */
+  /* Note that `FT_Err_Ok', `TT_Err_Ok', etc. are always equal to zero,    */
+  /* including the high byte.                                              */
+  /*                                                                       */
+  /* If FT_CONFIG_OPTION_USE_MODULE_ERRORS isn't set, the higher byte of   */
+  /* an error value is set to zero.                                        */
+  /*                                                                       */
+  /* To hide the various `XXX_Err_' prefixes in the source code, FreeType  */
+  /* provides some macros in `fttypes.h'.                                  */
+  /*                                                                       */
+  /*   FT_ERR( err )                                                       */
+  /*     Add current error module prefix (as defined with the              */
+  /*     `FT_ERR_PREFIX' macro) to `err'.  For example, in the BDF module  */
+  /*     the line                                                          */
+  /*                                                                       */
+  /*       error = FT_ERR( Invalid_Outline );                              */
+  /*                                                                       */
+  /*     expands to                                                        */
+  /*                                                                       */
+  /*       error = BDF_Err_Invalid_Outline;                                */
+  /*                                                                       */
+  /*     For simplicity, you can always use `FT_Err_Ok' directly instead   */
+  /*     of `FT_ERR( Ok )'.                                                */
+  /*                                                                       */
+  /*   FT_ERR_EQ( errcode, err )                                           */
+  /*   FT_ERR_NEQ( errcode, err )                                          */
+  /*     Compare error code `errcode' with the error `err' for equality    */
+  /*     and inequality, respectively.  Example:                           */
+  /*                                                                       */
+  /*       if ( FT_ERR_EQ( error, Invalid_Outline ) )                      */
+  /*         ...                                                           */
+  /*                                                                       */
+  /*     Using this macro you don't have to think about error prefixes.    */
+  /*     Of course, if module errors are not active, the above example is  */
+  /*     the same as                                                       */
+  /*                                                                       */
+  /*       if ( error == FT_Err_Invalid_Outline )                          */
+  /*         ...                                                           */
+  /*                                                                       */
+  /*   FT_ERROR_BASE( errcode )                                            */
+  /*   FT_ERROR_MODULE( errcode )                                          */
+  /*     Get base error and module error code, respectively.               */
+  /*                                                                       */
+  /*                                                                       */
+  /* It can also be used to create a module error message table easily     */
+  /* with something like                                                   */
+  /*                                                                       */
+  /*   {                                                                   */
+  /*     #undef FTMODERR_H_                                                */
+  /*     #define FT_MODERRDEF( e, v, s )  { FT_Mod_Err_ ## e, s },         */
+  /*     #define FT_MODERR_START_LIST     {                                */
+  /*     #define FT_MODERR_END_LIST       { 0, 0 } };                      */
+  /*                                                                       */
+  /*     const struct                                                      */
+  /*     {                                                                 */
+  /*       int          mod_err_offset;                                    */
+  /*       const char*  mod_err_msg                                        */
+  /*     } ft_mod_errors[] =                                               */
+  /*                                                                       */
+  /*     #include FT_MODULE_ERRORS_H                                       */
+  /*   }                                                                   */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#ifndef FTMODERR_H_
+#define FTMODERR_H_
+
+
+  /*******************************************************************/
+  /*******************************************************************/
+  /*****                                                         *****/
+  /*****                       SETUP MACROS                      *****/
+  /*****                                                         *****/
+  /*******************************************************************/
+  /*******************************************************************/
+
+
+#undef  FT_NEED_EXTERN_C
+
+#ifndef FT_MODERRDEF
+
+#ifdef FT_CONFIG_OPTION_USE_MODULE_ERRORS
+#define FT_MODERRDEF( e, v, s )  FT_Mod_Err_ ## e = v,
+#else
+#define FT_MODERRDEF( e, v, s )  FT_Mod_Err_ ## e = 0,
+#endif
+
+#define FT_MODERR_START_LIST  enum {
+#define FT_MODERR_END_LIST    FT_Mod_Err_Max };
+
+#ifdef __cplusplus
+#define FT_NEED_EXTERN_C
+  extern "C" {
+#endif
+
+#endif /* !FT_MODERRDEF */
+
+
+  /*******************************************************************/
+  /*******************************************************************/
+  /*****                                                         *****/
+  /*****               LIST MODULE ERROR BASES                   *****/
+  /*****                                                         *****/
+  /*******************************************************************/
+  /*******************************************************************/
+
+
+#ifdef FT_MODERR_START_LIST
+  FT_MODERR_START_LIST
+#endif
+
+
+  FT_MODERRDEF( Base,      0x000, "base module" )
+  FT_MODERRDEF( Autofit,   0x100, "autofitter module" )
+  FT_MODERRDEF( BDF,       0x200, "BDF module" )
+  FT_MODERRDEF( Bzip2,     0x300, "Bzip2 module" )
+  FT_MODERRDEF( Cache,     0x400, "cache module" )
+  FT_MODERRDEF( CFF,       0x500, "CFF module" )
+  FT_MODERRDEF( CID,       0x600, "CID module" )
+  FT_MODERRDEF( Gzip,      0x700, "Gzip module" )
+  FT_MODERRDEF( LZW,       0x800, "LZW module" )
+  FT_MODERRDEF( OTvalid,   0x900, "OpenType validation module" )
+  FT_MODERRDEF( PCF,       0xA00, "PCF module" )
+  FT_MODERRDEF( PFR,       0xB00, "PFR module" )
+  FT_MODERRDEF( PSaux,     0xC00, "PS auxiliary module" )
+  FT_MODERRDEF( PShinter,  0xD00, "PS hinter module" )
+  FT_MODERRDEF( PSnames,   0xE00, "PS names module" )
+  FT_MODERRDEF( Raster,    0xF00, "raster module" )
+  FT_MODERRDEF( SFNT,     0x1000, "SFNT module" )
+  FT_MODERRDEF( Smooth,   0x1100, "smooth raster module" )
+  FT_MODERRDEF( TrueType, 0x1200, "TrueType module" )
+  FT_MODERRDEF( Type1,    0x1300, "Type 1 module" )
+  FT_MODERRDEF( Type42,   0x1400, "Type 42 module" )
+  FT_MODERRDEF( Winfonts, 0x1500, "Windows FON/FNT module" )
+  FT_MODERRDEF( GXvalid,  0x1600, "GX validation module" )
+
+
+#ifdef FT_MODERR_END_LIST
+  FT_MODERR_END_LIST
+#endif
+
+
+  /*******************************************************************/
+  /*******************************************************************/
+  /*****                                                         *****/
+  /*****                      CLEANUP                            *****/
+  /*****                                                         *****/
+  /*******************************************************************/
+  /*******************************************************************/
+
+
+#ifdef FT_NEED_EXTERN_C
+  }
+#endif
+
+#undef FT_MODERR_START_LIST
+#undef FT_MODERR_END_LIST
+#undef FT_MODERRDEF
+#undef FT_NEED_EXTERN_C
+
+
+#endif /* FTMODERR_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ftotval.h b/engine/inc/freetype/ftotval.h
new file mode 100644
index 00000000..b5d27cfe
--- /dev/null
+++ b/engine/inc/freetype/ftotval.h
@@ -0,0 +1,204 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftotval.h                                                              */
+/*                                                                         */
+/*    FreeType API for validating OpenType tables (specification).         */
+/*                                                                         */
+/*  Copyright 2004-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+/***************************************************************************/
+/*                                                                         */
+/*                                                                         */
+/* Warning: This module might be moved to a different library in the       */
+/*          future to avoid a tight dependency between FreeType and the    */
+/*          OpenType specification.                                        */
+/*                                                                         */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTOTVAL_H_
+#define FTOTVAL_H_
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    ot_validation                                                      */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    OpenType Validation                                                */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    An API to validate OpenType tables.                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains the declaration of functions to validate     */
+  /*    some OpenType tables (BASE, GDEF, GPOS, GSUB, JSTF, MATH).         */
+  /*                                                                       */
+  /* <Order>                                                               */
+  /*    FT_OpenType_Validate                                               */
+  /*    FT_OpenType_Free                                                   */
+  /*                                                                       */
+  /*    FT_VALIDATE_OTXXX                                                  */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+ /**********************************************************************
+  *
+  * @enum:
+  *    FT_VALIDATE_OTXXX
+  *
+  * @description:
+  *    A list of bit-field constants used with @FT_OpenType_Validate to
+  *    indicate which OpenType tables should be validated.
+  *
+  * @values:
+  *    FT_VALIDATE_BASE ::
+  *      Validate BASE table.
+  *
+  *    FT_VALIDATE_GDEF ::
+  *      Validate GDEF table.
+  *
+  *    FT_VALIDATE_GPOS ::
+  *      Validate GPOS table.
+  *
+  *    FT_VALIDATE_GSUB ::
+  *      Validate GSUB table.
+  *
+  *    FT_VALIDATE_JSTF ::
+  *      Validate JSTF table.
+  *
+  *    FT_VALIDATE_MATH ::
+  *      Validate MATH table.
+  *
+  *    FT_VALIDATE_OT ::
+  *      Validate all OpenType tables (BASE, GDEF, GPOS, GSUB, JSTF, MATH).
+  *
+  */
+#define FT_VALIDATE_BASE  0x0100
+#define FT_VALIDATE_GDEF  0x0200
+#define FT_VALIDATE_GPOS  0x0400
+#define FT_VALIDATE_GSUB  0x0800
+#define FT_VALIDATE_JSTF  0x1000
+#define FT_VALIDATE_MATH  0x2000
+
+#define FT_VALIDATE_OT  ( FT_VALIDATE_BASE | \
+                          FT_VALIDATE_GDEF | \
+                          FT_VALIDATE_GPOS | \
+                          FT_VALIDATE_GSUB | \
+                          FT_VALIDATE_JSTF | \
+                          FT_VALIDATE_MATH )
+
+ /**********************************************************************
+  *
+  * @function:
+  *    FT_OpenType_Validate
+  *
+  * @description:
+  *    Validate various OpenType tables to assure that all offsets and
+  *    indices are valid.  The idea is that a higher-level library that
+  *    actually does the text layout can access those tables without
+  *    error checking (which can be quite time consuming).
+  *
+  * @input:
+  *    face ::
+  *       A handle to the input face.
+  *
+  *    validation_flags ::
+  *       A bit field that specifies the tables to be validated.  See
+  *       @FT_VALIDATE_OTXXX for possible values.
+  *
+  * @output:
+  *    BASE_table ::
+  *       A pointer to the BASE table.
+  *
+  *    GDEF_table ::
+  *       A pointer to the GDEF table.
+  *
+  *    GPOS_table ::
+  *       A pointer to the GPOS table.
+  *
+  *    GSUB_table ::
+  *       A pointer to the GSUB table.
+  *
+  *    JSTF_table ::
+  *       A pointer to the JSTF table.
+  *
+  * @return:
+  *   FreeType error code.  0~means success.
+  *
+  * @note:
+  *   This function only works with OpenType fonts, returning an error
+  *   otherwise.
+  *
+  *   After use, the application should deallocate the five tables with
+  *   @FT_OpenType_Free.  A NULL value indicates that the table either
+  *   doesn't exist in the font, or the application hasn't asked for
+  *   validation.
+  */
+  FT_EXPORT( FT_Error )
+  FT_OpenType_Validate( FT_Face    face,
+                        FT_UInt    validation_flags,
+                        FT_Bytes  *BASE_table,
+                        FT_Bytes  *GDEF_table,
+                        FT_Bytes  *GPOS_table,
+                        FT_Bytes  *GSUB_table,
+                        FT_Bytes  *JSTF_table );
+
+ /**********************************************************************
+  *
+  * @function:
+  *    FT_OpenType_Free
+  *
+  * @description:
+  *    Free the buffer allocated by OpenType validator.
+  *
+  * @input:
+  *    face ::
+  *       A handle to the input face.
+  *
+  *    table ::
+  *       The pointer to the buffer that is allocated by
+  *       @FT_OpenType_Validate.
+  *
+  * @note:
+  *   This function must be used to free the buffer allocated by
+  *   @FT_OpenType_Validate only.
+  */
+  FT_EXPORT( void )
+  FT_OpenType_Free( FT_Face   face,
+                    FT_Bytes  table );
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* FTOTVAL_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ftoutln.h b/engine/inc/freetype/ftoutln.h
new file mode 100644
index 00000000..56f56a96
--- /dev/null
+++ b/engine/inc/freetype/ftoutln.h
@@ -0,0 +1,585 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftoutln.h                                                              */
+/*                                                                         */
+/*    Support for the FT_Outline type used to store glyph shapes of        */
+/*    most scalable font formats (specification).                          */
+/*                                                                         */
+/*  Copyright 1996-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTOUTLN_H_
+#define FTOUTLN_H_
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    outline_processing                                                 */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    Outline Processing                                                 */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    Functions to create, transform, and render vectorial glyph images. */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains routines used to create and destroy scalable */
+  /*    glyph images known as `outlines'.  These can also be measured,     */
+  /*    transformed, and converted into bitmaps and pixmaps.               */
+  /*                                                                       */
+  /* <Order>                                                               */
+  /*    FT_Outline                                                         */
+  /*    FT_Outline_New                                                     */
+  /*    FT_Outline_Done                                                    */
+  /*    FT_Outline_Copy                                                    */
+  /*    FT_Outline_Translate                                               */
+  /*    FT_Outline_Transform                                               */
+  /*    FT_Outline_Embolden                                                */
+  /*    FT_Outline_EmboldenXY                                              */
+  /*    FT_Outline_Reverse                                                 */
+  /*    FT_Outline_Check                                                   */
+  /*                                                                       */
+  /*    FT_Outline_Get_CBox                                                */
+  /*    FT_Outline_Get_BBox                                                */
+  /*                                                                       */
+  /*    FT_Outline_Get_Bitmap                                              */
+  /*    FT_Outline_Render                                                  */
+  /*    FT_Outline_Decompose                                               */
+  /*    FT_Outline_Funcs                                                   */
+  /*    FT_Outline_MoveToFunc                                              */
+  /*    FT_Outline_LineToFunc                                              */
+  /*    FT_Outline_ConicToFunc                                             */
+  /*    FT_Outline_CubicToFunc                                             */
+  /*                                                                       */
+  /*    FT_Orientation                                                     */
+  /*    FT_Outline_Get_Orientation                                         */
+  /*                                                                       */
+  /*    FT_OUTLINE_XXX                                                     */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Outline_Decompose                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Walk over an outline's structure to decompose it into individual   */
+  /*    segments and Bézier arcs.  This function also emits `move to'      */
+  /*    operations to indicate the start of new contours in the outline.   */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    outline        :: A pointer to the source target.                  */
+  /*                                                                       */
+  /*    func_interface :: A table of `emitters', i.e., function pointers   */
+  /*                      called during decomposition to indicate path     */
+  /*                      operations.                                      */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    user           :: A typeless pointer that is passed to each        */
+  /*                      emitter during the decomposition.  It can be     */
+  /*                      used to store the state during the               */
+  /*                      decomposition.                                   */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    A contour that contains a single point only is represented by a    */
+  /*    `move to' operation followed by `line to' to the same point.  In   */
+  /*    most cases, it is best to filter this out before using the         */
+  /*    outline for stroking purposes (otherwise it would result in a      */
+  /*    visible dot when round caps are used).                             */
+  /*                                                                       */
+  /*    Similarly, the function returns success for an empty outline also  */
+  /*    (doing nothing, this is, not calling any emitter); if necessary,   */
+  /*    you should filter this out, too.                                   */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Outline_Decompose( FT_Outline*              outline,
+                        const FT_Outline_Funcs*  func_interface,
+                        void*                    user );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Outline_New                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Create a new outline of a given size.                              */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    library     :: A handle to the library object from where the       */
+  /*                   outline is allocated.  Note however that the new    */
+  /*                   outline will *not* necessarily be *freed*, when     */
+  /*                   destroying the library, by @FT_Done_FreeType.       */
+  /*                                                                       */
+  /*    numPoints   :: The maximum number of points within the outline.    */
+  /*                   Must be smaller than or equal to 0xFFFF (65535).    */
+  /*                                                                       */
+  /*    numContours :: The maximum number of contours within the outline.  */
+  /*                   This value must be in the range 0 to `numPoints'.   */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    anoutline   :: A handle to the new outline.                        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The reason why this function takes a `library' parameter is simply */
+  /*    to use the library's memory allocator.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Outline_New( FT_Library   library,
+                  FT_UInt      numPoints,
+                  FT_Int       numContours,
+                  FT_Outline  *anoutline );
+
+
+  FT_EXPORT( FT_Error )
+  FT_Outline_New_Internal( FT_Memory    memory,
+                           FT_UInt      numPoints,
+                           FT_Int       numContours,
+                           FT_Outline  *anoutline );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Outline_Done                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Destroy an outline created with @FT_Outline_New.                   */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    library :: A handle of the library object used to allocate the     */
+  /*               outline.                                                */
+  /*                                                                       */
+  /*    outline :: A pointer to the outline object to be discarded.        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    If the outline's `owner' field is not set, only the outline        */
+  /*    descriptor will be released.                                       */
+  /*                                                                       */
+  /*    The reason why this function takes an `library' parameter is       */
+  /*    simply to use ft_mem_free().                                       */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Outline_Done( FT_Library   library,
+                   FT_Outline*  outline );
+
+
+  FT_EXPORT( FT_Error )
+  FT_Outline_Done_Internal( FT_Memory    memory,
+                            FT_Outline*  outline );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Outline_Check                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Check the contents of an outline descriptor.                       */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    outline :: A handle to a source outline.                           */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    An empty outline, or an outline with a single point only is also   */
+  /*    valid.                                                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Outline_Check( FT_Outline*  outline );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Outline_Get_CBox                                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Return an outline's `control box'.  The control box encloses all   */
+  /*    the outline's points, including Bézier control points.  Though it  */
+  /*    coincides with the exact bounding box for most glyphs, it can be   */
+  /*    slightly larger in some situations (like when rotating an outline  */
+  /*    that contains Bézier outside arcs).                                */
+  /*                                                                       */
+  /*    Computing the control box is very fast, while getting the bounding */
+  /*    box can take much more time as it needs to walk over all segments  */
+  /*    and arcs in the outline.  To get the latter, you can use the       */
+  /*    `ftbbox' component, which is dedicated to this single task.        */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    outline :: A pointer to the source outline descriptor.             */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    acbox   :: The outline's control box.                              */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    See @FT_Glyph_Get_CBox for a discussion of tricky fonts.           */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Outline_Get_CBox( const FT_Outline*  outline,
+                       FT_BBox           *acbox );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Outline_Translate                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Apply a simple translation to the points of an outline.            */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    outline :: A pointer to the target outline descriptor.             */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    xOffset :: The horizontal offset.                                  */
+  /*                                                                       */
+  /*    yOffset :: The vertical offset.                                    */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Outline_Translate( const FT_Outline*  outline,
+                        FT_Pos             xOffset,
+                        FT_Pos             yOffset );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Outline_Copy                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Copy an outline into another one.  Both objects must have the      */
+  /*    same sizes (number of points & number of contours) when this       */
+  /*    function is called.                                                */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    source :: A handle to the source outline.                          */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    target :: A handle to the target outline.                          */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Outline_Copy( const FT_Outline*  source,
+                   FT_Outline        *target );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Outline_Transform                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Apply a simple 2x2 matrix to all of an outline's points.  Useful   */
+  /*    for applying rotations, slanting, flipping, etc.                   */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    outline :: A pointer to the target outline descriptor.             */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    matrix  :: A pointer to the transformation matrix.                 */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    You can use @FT_Outline_Translate if you need to translate the     */
+  /*    outline's points.                                                  */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Outline_Transform( const FT_Outline*  outline,
+                        const FT_Matrix*   matrix );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Outline_Embolden                                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Embolden an outline.  The new outline will be at most 4~times      */
+  /*    `strength' pixels wider and higher.  You may think of the left and */
+  /*    bottom borders as unchanged.                                       */
+  /*                                                                       */
+  /*    Negative `strength' values to reduce the outline thickness are     */
+  /*    possible also.                                                     */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    outline  :: A handle to the target outline.                        */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    strength :: How strong the glyph is emboldened.  Expressed in      */
+  /*                26.6 pixel format.                                     */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The used algorithm to increase or decrease the thickness of the    */
+  /*    glyph doesn't change the number of points; this means that certain */
+  /*    situations like acute angles or intersections are sometimes        */
+  /*    handled incorrectly.                                               */
+  /*                                                                       */
+  /*    If you need `better' metrics values you should call                */
+  /*    @FT_Outline_Get_CBox or @FT_Outline_Get_BBox.                      */
+  /*                                                                       */
+  /*    Example call:                                                      */
+  /*                                                                       */
+  /*    {                                                                  */
+  /*      FT_Load_Glyph( face, index, FT_LOAD_DEFAULT );                   */
+  /*      if ( face->glyph->format == FT_GLYPH_FORMAT_OUTLINE )            */
+  /*        FT_Outline_Embolden( &face->glyph->outline, strength );        */
+  /*    }                                                                  */
+  /*                                                                       */
+  /*    To get meaningful results, font scaling values must be set with    */
+  /*    functions like @FT_Set_Char_Size before calling FT_Render_Glyph.   */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Outline_Embolden( FT_Outline*  outline,
+                       FT_Pos       strength );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Outline_EmboldenXY                                              */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Embolden an outline.  The new outline will be `xstrength' pixels   */
+  /*    wider and `ystrength' pixels higher.  Otherwise, it is similar to  */
+  /*    @FT_Outline_Embolden, which uses the same strength in both         */
+  /*    directions.                                                        */
+  /*                                                                       */
+  /* <Since>                                                               */
+  /*    2.4.10                                                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Outline_EmboldenXY( FT_Outline*  outline,
+                         FT_Pos       xstrength,
+                         FT_Pos       ystrength );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Outline_Reverse                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Reverse the drawing direction of an outline.  This is used to      */
+  /*    ensure consistent fill conventions for mirrored glyphs.            */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    outline :: A pointer to the target outline descriptor.             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This function toggles the bit flag @FT_OUTLINE_REVERSE_FILL in     */
+  /*    the outline's `flags' field.                                       */
+  /*                                                                       */
+  /*    It shouldn't be used by a normal client application, unless it     */
+  /*    knows what it is doing.                                            */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Outline_Reverse( FT_Outline*  outline );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Outline_Get_Bitmap                                              */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Render an outline within a bitmap.  The outline's image is simply  */
+  /*    OR-ed to the target bitmap.                                        */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    library :: A handle to a FreeType library object.                  */
+  /*                                                                       */
+  /*    outline :: A pointer to the source outline descriptor.             */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    abitmap :: A pointer to the target bitmap descriptor.              */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This function does NOT CREATE the bitmap, it only renders an       */
+  /*    outline image within the one you pass to it!  Consequently, the    */
+  /*    various fields in `abitmap' should be set accordingly.             */
+  /*                                                                       */
+  /*    It will use the raster corresponding to the default glyph format.  */
+  /*                                                                       */
+  /*    The value of the `num_grays' field in `abitmap' is ignored.  If    */
+  /*    you select the gray-level rasterizer, and you want less than 256   */
+  /*    gray levels, you have to use @FT_Outline_Render directly.          */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Outline_Get_Bitmap( FT_Library        library,
+                         FT_Outline*       outline,
+                         const FT_Bitmap  *abitmap );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Outline_Render                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Render an outline within a bitmap using the current scan-convert.  */
+  /*    This function uses an @FT_Raster_Params structure as an argument,  */
+  /*    allowing advanced features like direct composition, translucency,  */
+  /*    etc.                                                               */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    library :: A handle to a FreeType library object.                  */
+  /*                                                                       */
+  /*    outline :: A pointer to the source outline descriptor.             */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    params  :: A pointer to an @FT_Raster_Params structure used to     */
+  /*               describe the rendering operation.                       */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    You should know what you are doing and how @FT_Raster_Params works */
+  /*    to use this function.                                              */
+  /*                                                                       */
+  /*    The field `params.source' will be set to `outline' before the scan */
+  /*    converter is called, which means that the value you give to it is  */
+  /*    actually ignored.                                                  */
+  /*                                                                       */
+  /*    The gray-level rasterizer always uses 256 gray levels.  If you     */
+  /*    want less gray levels, you have to provide your own span callback. */
+  /*    See the @FT_RASTER_FLAG_DIRECT value of the `flags' field in the   */
+  /*    @FT_Raster_Params structure for more details.                      */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Outline_Render( FT_Library         library,
+                     FT_Outline*        outline,
+                     FT_Raster_Params*  params );
+
+
+ /**************************************************************************
+  *
+  * @enum:
+  *   FT_Orientation
+  *
+  * @description:
+  *   A list of values used to describe an outline's contour orientation.
+  *
+  *   The TrueType and PostScript specifications use different conventions
+  *   to determine whether outline contours should be filled or unfilled.
+  *
+  * @values:
+  *   FT_ORIENTATION_TRUETYPE ::
+  *     According to the TrueType specification, clockwise contours must
+  *     be filled, and counter-clockwise ones must be unfilled.
+  *
+  *   FT_ORIENTATION_POSTSCRIPT ::
+  *     According to the PostScript specification, counter-clockwise contours
+  *     must be filled, and clockwise ones must be unfilled.
+  *
+  *   FT_ORIENTATION_FILL_RIGHT ::
+  *     This is identical to @FT_ORIENTATION_TRUETYPE, but is used to
+  *     remember that in TrueType, everything that is to the right of
+  *     the drawing direction of a contour must be filled.
+  *
+  *   FT_ORIENTATION_FILL_LEFT ::
+  *     This is identical to @FT_ORIENTATION_POSTSCRIPT, but is used to
+  *     remember that in PostScript, everything that is to the left of
+  *     the drawing direction of a contour must be filled.
+  *
+  *   FT_ORIENTATION_NONE ::
+  *     The orientation cannot be determined.  That is, different parts of
+  *     the glyph have different orientation.
+  *
+  */
+  typedef enum  FT_Orientation_
+  {
+    FT_ORIENTATION_TRUETYPE   = 0,
+    FT_ORIENTATION_POSTSCRIPT = 1,
+    FT_ORIENTATION_FILL_RIGHT = FT_ORIENTATION_TRUETYPE,
+    FT_ORIENTATION_FILL_LEFT  = FT_ORIENTATION_POSTSCRIPT,
+    FT_ORIENTATION_NONE
+
+  } FT_Orientation;
+
+
+ /**************************************************************************
+  *
+  * @function:
+  *   FT_Outline_Get_Orientation
+  *
+  * @description:
+  *   This function analyzes a glyph outline and tries to compute its
+  *   fill orientation (see @FT_Orientation).  This is done by integrating
+  *   the total area covered by the outline. The positive integral
+  *   corresponds to the clockwise orientation and @FT_ORIENTATION_POSTSCRIPT
+  *   is returned. The negative integral corresponds to the counter-clockwise
+  *   orientation and @FT_ORIENTATION_TRUETYPE is returned.
+  *
+  *   Note that this will return @FT_ORIENTATION_TRUETYPE for empty
+  *   outlines.
+  *
+  * @input:
+  *   outline ::
+  *     A handle to the source outline.
+  *
+  * @return:
+  *   The orientation.
+  *
+  */
+  FT_EXPORT( FT_Orientation )
+  FT_Outline_Get_Orientation( FT_Outline*  outline );
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* FTOUTLN_H_ */
+
+
+/* END */
+
+
+/* Local Variables: */
+/* coding: utf-8    */
+/* End:             */
diff --git a/engine/inc/freetype/ftpcfdrv.h b/engine/inc/freetype/ftpcfdrv.h
new file mode 100644
index 00000000..6622c936
--- /dev/null
+++ b/engine/inc/freetype/ftpcfdrv.h
@@ -0,0 +1,105 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftpcfdrv.h                                                             */
+/*                                                                         */
+/*    FreeType API for controlling the PCF driver (specification only).    */
+/*                                                                         */
+/*  Copyright 2017 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTPCFDRV_H_
+#define FTPCFDRV_H_
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+
+  /**************************************************************************
+   *
+   * @section:
+   *   pcf_driver
+   *
+   * @title:
+   *   The PCF driver
+   *
+   * @abstract:
+   *   Controlling the PCF driver module.
+   *
+   * @description:
+   *   While FreeType's PCF driver doesn't expose API functions by itself,
+   *   it is possible to control its behaviour with @FT_Property_Set and
+   *   @FT_Property_Get.  Right now, there is a single property
+   *   `no-long-family-names' available if FreeType is compiled with
+   *   PCF_CONFIG_OPTION_LONG_FAMILY_NAMES.
+   *
+   *   The PCF driver's module name is `pcf'.
+   *
+   */
+
+
+  /**************************************************************************
+   *
+   * @property:
+   *   no-long-family-names
+   *
+   * @description:
+   *   If PCF_CONFIG_OPTION_LONG_FAMILY_NAMES is active while compiling
+   *   FreeType, the PCF driver constructs long family names.
+   *
+   *   There are many PCF fonts just called `Fixed' which look completely
+   *   different, and which have nothing to do with each other.  When
+   *   selecting `Fixed' in KDE or Gnome one gets results that appear rather
+   *   random, the style changes often if one changes the size and one
+   *   cannot select some fonts at all.  The improve this situation, the PCF
+   *   module prepends the foundry name (plus a space) to the family name. 
+   *   It also checks whether there are `wide' characters; all put together,
+   *   family names like `Sony Fixed' or `Misc Fixed Wide' are constructed.
+   *
+   *   If `no-long-family-names' is set, this feature gets switched off.
+   *
+   *   {
+   *     FT_Library  library;
+   *     FT_Bool     no_long_family_names = TRUE;
+   *
+   *
+   *     FT_Init_FreeType( &library );
+   *
+   *     FT_Property_Set( library, "pcf",
+   *                               "no-long-family-names",
+   *                               &no_long_family_names );
+   *   }
+   *
+   * @note:
+   *   This property can be used with @FT_Property_Get also.
+   *
+   *   This property can be set via the `FREETYPE_PROPERTIES' environment
+   *   variable (using values 1 and 0 for `on' and `off', respectively).
+   *
+   */
+
+
+FT_END_HEADER
+
+
+#endif /* FTPCFDRV_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ftpfr.h b/engine/inc/freetype/ftpfr.h
new file mode 100644
index 00000000..f2a6ae93
--- /dev/null
+++ b/engine/inc/freetype/ftpfr.h
@@ -0,0 +1,172 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftpfr.h                                                                */
+/*                                                                         */
+/*    FreeType API for accessing PFR-specific data (specification only).   */
+/*                                                                         */
+/*  Copyright 2002-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTPFR_H_
+#define FTPFR_H_
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    pfr_fonts                                                          */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    PFR Fonts                                                          */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    PFR/TrueDoc specific API.                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains the declaration of PFR-specific functions.   */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+ /**********************************************************************
+  *
+  * @function:
+  *    FT_Get_PFR_Metrics
+  *
+  * @description:
+  *    Return the outline and metrics resolutions of a given PFR face.
+  *
+  * @input:
+  *    face :: Handle to the input face.  It can be a non-PFR face.
+  *
+  * @output:
+  *    aoutline_resolution ::
+  *      Outline resolution.  This is equivalent to `face->units_per_EM'
+  *      for non-PFR fonts.  Optional (parameter can be NULL).
+  *
+  *    ametrics_resolution ::
+  *      Metrics resolution.  This is equivalent to `outline_resolution'
+  *      for non-PFR fonts.  Optional (parameter can be NULL).
+  *
+  *    ametrics_x_scale ::
+  *      A 16.16 fixed-point number used to scale distance expressed
+  *      in metrics units to device sub-pixels.  This is equivalent to
+  *      `face->size->x_scale', but for metrics only.  Optional (parameter
+  *      can be NULL).
+  *
+  *    ametrics_y_scale ::
+  *      Same as `ametrics_x_scale' but for the vertical direction.
+  *      optional (parameter can be NULL).
+  *
+  * @return:
+  *    FreeType error code.  0~means success.
+  *
+  * @note:
+  *   If the input face is not a PFR, this function will return an error.
+  *   However, in all cases, it will return valid values.
+  */
+  FT_EXPORT( FT_Error )
+  FT_Get_PFR_Metrics( FT_Face    face,
+                      FT_UInt   *aoutline_resolution,
+                      FT_UInt   *ametrics_resolution,
+                      FT_Fixed  *ametrics_x_scale,
+                      FT_Fixed  *ametrics_y_scale );
+
+
+ /**********************************************************************
+  *
+  * @function:
+  *    FT_Get_PFR_Kerning
+  *
+  * @description:
+  *    Return the kerning pair corresponding to two glyphs in a PFR face.
+  *    The distance is expressed in metrics units, unlike the result of
+  *    @FT_Get_Kerning.
+  *
+  * @input:
+  *    face  :: A handle to the input face.
+  *
+  *    left  :: Index of the left glyph.
+  *
+  *    right :: Index of the right glyph.
+  *
+  * @output:
+  *    avector :: A kerning vector.
+  *
+  * @return:
+  *    FreeType error code.  0~means success.
+  *
+  * @note:
+  *    This function always return distances in original PFR metrics
+  *    units.  This is unlike @FT_Get_Kerning with the @FT_KERNING_UNSCALED
+  *    mode, which always returns distances converted to outline units.
+  *
+  *    You can use the value of the `x_scale' and `y_scale' parameters
+  *    returned by @FT_Get_PFR_Metrics to scale these to device sub-pixels.
+  */
+  FT_EXPORT( FT_Error )
+  FT_Get_PFR_Kerning( FT_Face     face,
+                      FT_UInt     left,
+                      FT_UInt     right,
+                      FT_Vector  *avector );
+
+
+ /**********************************************************************
+  *
+  * @function:
+  *    FT_Get_PFR_Advance
+  *
+  * @description:
+  *    Return a given glyph advance, expressed in original metrics units,
+  *    from a PFR font.
+  *
+  * @input:
+  *    face   :: A handle to the input face.
+  *
+  *    gindex :: The glyph index.
+  *
+  * @output:
+  *    aadvance :: The glyph advance in metrics units.
+  *
+  * @return:
+  *    FreeType error code.  0~means success.
+  *
+  * @note:
+  *    You can use the `x_scale' or `y_scale' results of @FT_Get_PFR_Metrics
+  *    to convert the advance to device sub-pixels (i.e., 1/64th of pixels).
+  */
+  FT_EXPORT( FT_Error )
+  FT_Get_PFR_Advance( FT_Face   face,
+                      FT_UInt   gindex,
+                      FT_Pos   *aadvance );
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* FTPFR_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ftrender.h b/engine/inc/freetype/ftrender.h
new file mode 100644
index 00000000..96083758
--- /dev/null
+++ b/engine/inc/freetype/ftrender.h
@@ -0,0 +1,233 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftrender.h                                                             */
+/*                                                                         */
+/*    FreeType renderer modules public interface (specification).          */
+/*                                                                         */
+/*  Copyright 1996-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTRENDER_H_
+#define FTRENDER_H_
+
+
+#include <ft2build.h>
+#include FT_MODULE_H
+#include FT_GLYPH_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    module_management                                                  */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /* create a new glyph object */
+  typedef FT_Error
+  (*FT_Glyph_InitFunc)( FT_Glyph      glyph,
+                        FT_GlyphSlot  slot );
+
+  /* destroys a given glyph object */
+  typedef void
+  (*FT_Glyph_DoneFunc)( FT_Glyph  glyph );
+
+  typedef void
+  (*FT_Glyph_TransformFunc)( FT_Glyph          glyph,
+                             const FT_Matrix*  matrix,
+                             const FT_Vector*  delta );
+
+  typedef void
+  (*FT_Glyph_GetBBoxFunc)( FT_Glyph  glyph,
+                           FT_BBox*  abbox );
+
+  typedef FT_Error
+  (*FT_Glyph_CopyFunc)( FT_Glyph   source,
+                        FT_Glyph   target );
+
+  typedef FT_Error
+  (*FT_Glyph_PrepareFunc)( FT_Glyph      glyph,
+                           FT_GlyphSlot  slot );
+
+/* deprecated */
+#define FT_Glyph_Init_Func       FT_Glyph_InitFunc
+#define FT_Glyph_Done_Func       FT_Glyph_DoneFunc
+#define FT_Glyph_Transform_Func  FT_Glyph_TransformFunc
+#define FT_Glyph_BBox_Func       FT_Glyph_GetBBoxFunc
+#define FT_Glyph_Copy_Func       FT_Glyph_CopyFunc
+#define FT_Glyph_Prepare_Func    FT_Glyph_PrepareFunc
+
+
+  struct  FT_Glyph_Class_
+  {
+    FT_Long                 glyph_size;
+    FT_Glyph_Format         glyph_format;
+
+    FT_Glyph_InitFunc       glyph_init;
+    FT_Glyph_DoneFunc       glyph_done;
+    FT_Glyph_CopyFunc       glyph_copy;
+    FT_Glyph_TransformFunc  glyph_transform;
+    FT_Glyph_GetBBoxFunc    glyph_bbox;
+    FT_Glyph_PrepareFunc    glyph_prepare;
+  };
+
+
+  typedef FT_Error
+  (*FT_Renderer_RenderFunc)( FT_Renderer       renderer,
+                             FT_GlyphSlot      slot,
+                             FT_UInt           mode,
+                             const FT_Vector*  origin );
+
+  typedef FT_Error
+  (*FT_Renderer_TransformFunc)( FT_Renderer       renderer,
+                                FT_GlyphSlot      slot,
+                                const FT_Matrix*  matrix,
+                                const FT_Vector*  delta );
+
+
+  typedef void
+  (*FT_Renderer_GetCBoxFunc)( FT_Renderer   renderer,
+                              FT_GlyphSlot  slot,
+                              FT_BBox*      cbox );
+
+
+  typedef FT_Error
+  (*FT_Renderer_SetModeFunc)( FT_Renderer  renderer,
+                              FT_ULong     mode_tag,
+                              FT_Pointer   mode_ptr );
+
+/* deprecated identifiers */
+#define FTRenderer_render  FT_Renderer_RenderFunc
+#define FTRenderer_transform  FT_Renderer_TransformFunc
+#define FTRenderer_getCBox  FT_Renderer_GetCBoxFunc
+#define FTRenderer_setMode  FT_Renderer_SetModeFunc
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Renderer_Class                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The renderer module class descriptor.                              */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    root            :: The root @FT_Module_Class fields.               */
+  /*                                                                       */
+  /*    glyph_format    :: The glyph image format this renderer handles.   */
+  /*                                                                       */
+  /*    render_glyph    :: A method used to render the image that is in a  */
+  /*                       given glyph slot into a bitmap.                 */
+  /*                                                                       */
+  /*    transform_glyph :: A method used to transform the image that is in */
+  /*                       a given glyph slot.                             */
+  /*                                                                       */
+  /*    get_glyph_cbox  :: A method used to access the glyph's cbox.       */
+  /*                                                                       */
+  /*    set_mode        :: A method used to pass additional parameters.    */
+  /*                                                                       */
+  /*    raster_class    :: For @FT_GLYPH_FORMAT_OUTLINE renderers only.    */
+  /*                       This is a pointer to its raster's class.        */
+  /*                                                                       */
+  typedef struct  FT_Renderer_Class_
+  {
+    FT_Module_Class            root;
+
+    FT_Glyph_Format            glyph_format;
+
+    FT_Renderer_RenderFunc     render_glyph;
+    FT_Renderer_TransformFunc  transform_glyph;
+    FT_Renderer_GetCBoxFunc    get_glyph_cbox;
+    FT_Renderer_SetModeFunc    set_mode;
+
+    FT_Raster_Funcs*           raster_class;
+
+  } FT_Renderer_Class;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Renderer                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Retrieve the current renderer for a given glyph format.            */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    library :: A handle to the library object.                         */
+  /*                                                                       */
+  /*    format  :: The glyph format.                                       */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    A renderer handle.  0~if none found.                               */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    An error will be returned if a module already exists by that name, */
+  /*    or if the module requires a version of FreeType that is too great. */
+  /*                                                                       */
+  /*    To add a new renderer, simply use @FT_Add_Module.  To retrieve a   */
+  /*    renderer by its name, use @FT_Get_Module.                          */
+  /*                                                                       */
+  FT_EXPORT( FT_Renderer )
+  FT_Get_Renderer( FT_Library       library,
+                   FT_Glyph_Format  format );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Set_Renderer                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Set the current renderer to use, and set additional mode.          */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    library    :: A handle to the library object.                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    renderer   :: A handle to the renderer object.                     */
+  /*                                                                       */
+  /*    num_params :: The number of additional parameters.                 */
+  /*                                                                       */
+  /*    parameters :: Additional parameters.                               */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    In case of success, the renderer will be used to convert glyph     */
+  /*    images in the renderer's known format into bitmaps.                */
+  /*                                                                       */
+  /*    This doesn't change the current renderer for other formats.        */
+  /*                                                                       */
+  /*    Currently, no FreeType renderer module uses `parameters'; you      */
+  /*    should thus always pass NULL as the value.                         */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Set_Renderer( FT_Library     library,
+                   FT_Renderer    renderer,
+                   FT_UInt        num_params,
+                   FT_Parameter*  parameters );
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* FTRENDER_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ftsizes.h b/engine/inc/freetype/ftsizes.h
new file mode 100644
index 00000000..2f3958a8
--- /dev/null
+++ b/engine/inc/freetype/ftsizes.h
@@ -0,0 +1,159 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftsizes.h                                                              */
+/*                                                                         */
+/*    FreeType size objects management (specification).                    */
+/*                                                                         */
+/*  Copyright 1996-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Typical application would normally not need to use these functions.   */
+  /* However, they have been placed in a public API for the rare cases     */
+  /* where they are needed.                                                */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#ifndef FTSIZES_H_
+#define FTSIZES_H_
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    sizes_management                                                   */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    Size Management                                                    */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    Managing multiple sizes per face.                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    When creating a new face object (e.g., with @FT_New_Face), an      */
+  /*    @FT_Size object is automatically created and used to store all     */
+  /*    pixel-size dependent information, available in the `face->size'    */
+  /*    field.                                                             */
+  /*                                                                       */
+  /*    It is however possible to create more sizes for a given face,      */
+  /*    mostly in order to manage several character pixel sizes of the     */
+  /*    same font family and style.  See @FT_New_Size and @FT_Done_Size.   */
+  /*                                                                       */
+  /*    Note that @FT_Set_Pixel_Sizes and @FT_Set_Char_Size only           */
+  /*    modify the contents of the current `active' size; you thus need    */
+  /*    to use @FT_Activate_Size to change it.                             */
+  /*                                                                       */
+  /*    99% of applications won't need the functions provided here,        */
+  /*    especially if they use the caching sub-system, so be cautious      */
+  /*    when using these.                                                  */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_New_Size                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Create a new size object from a given face object.                 */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face :: A handle to a parent face object.                          */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    asize :: A handle to a new size object.                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    You need to call @FT_Activate_Size in order to select the new size */
+  /*    for upcoming calls to @FT_Set_Pixel_Sizes, @FT_Set_Char_Size,      */
+  /*    @FT_Load_Glyph, @FT_Load_Char, etc.                                */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_New_Size( FT_Face   face,
+               FT_Size*  size );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Done_Size                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Discard a given size object.  Note that @FT_Done_Face              */
+  /*    automatically discards all size objects allocated with             */
+  /*    @FT_New_Size.                                                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    size :: A handle to a target size object.                          */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Done_Size( FT_Size  size );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Activate_Size                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Even though it is possible to create several size objects for a    */
+  /*    given face (see @FT_New_Size for details), functions like          */
+  /*    @FT_Load_Glyph or @FT_Load_Char only use the one that has been     */
+  /*    activated last to determine the `current character pixel size'.    */
+  /*                                                                       */
+  /*    This function can be used to `activate' a previously created size  */
+  /*    object.                                                            */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    size :: A handle to a target size object.                          */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    If `face' is the size's parent face object, this function changes  */
+  /*    the value of `face->size' to the input size handle.                */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Activate_Size( FT_Size  size );
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* FTSIZES_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ftsnames.h b/engine/inc/freetype/ftsnames.h
new file mode 100644
index 00000000..a3165405
--- /dev/null
+++ b/engine/inc/freetype/ftsnames.h
@@ -0,0 +1,287 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftsnames.h                                                             */
+/*                                                                         */
+/*    Simple interface to access SFNT `name' tables (which are used        */
+/*    to hold font names, copyright info, notices, etc.) (specification).  */
+/*                                                                         */
+/*    This is _not_ used to retrieve glyph names!                          */
+/*                                                                         */
+/*  Copyright 1996-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTSNAMES_H_
+#define FTSNAMES_H_
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    sfnt_names                                                         */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    SFNT Names                                                         */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    Access the names embedded in TrueType and OpenType files.          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The TrueType and OpenType specifications allow the inclusion of    */
+  /*    a special names table (`name') in font files.  This table contains */
+  /*    textual (and internationalized) information regarding the font,    */
+  /*    like family name, copyright, version, etc.                         */
+  /*                                                                       */
+  /*    The definitions below are used to access them if available.        */
+  /*                                                                       */
+  /*    Note that this has nothing to do with glyph names!                 */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_SfntName                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to model an SFNT `name' table entry.              */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    platform_id :: The platform ID for `string'.                       */
+  /*                   See @TT_PLATFORM_XXX for possible values.           */
+  /*                                                                       */
+  /*    encoding_id :: The encoding ID for `string'.                       */
+  /*                   See @TT_APPLE_ID_XXX, @TT_MAC_ID_XXX,               */
+  /*                   @TT_ISO_ID_XXX, @TT_MS_ID_XXX, and @TT_ADOBE_ID_XXX */
+  /*                   for possible values.                                */
+  /*                                                                       */
+  /*    language_id :: The language ID for `string'.                       */
+  /*                   See @TT_MAC_LANGID_XXX and @TT_MS_LANGID_XXX for    */
+  /*                   possible values.                                    */
+  /*                                                                       */
+  /*                   Registered OpenType values for `language_id' are    */
+  /*                   always smaller than 0x8000; values equal or larger  */
+  /*                   than 0x8000 usually indicate a language tag string  */
+  /*                   (introduced in OpenType version 1.6).  Use function */
+  /*                   @FT_Get_Sfnt_LangTag with `language_id' as its      */
+  /*                   argument to retrieve the associated language tag.   */
+  /*                                                                       */
+  /*    name_id     :: An identifier for `string'.                         */
+  /*                   See @TT_NAME_ID_XXX for possible values.            */
+  /*                                                                       */
+  /*    string      :: The `name' string.  Note that its format differs    */
+  /*                   depending on the (platform,encoding) pair, being    */
+  /*                   either a string of bytes (without a terminating     */
+  /*                   NULL byte) or containing UTF-16BE entities.         */
+  /*                                                                       */
+  /*    string_len  :: The length of `string' in bytes.                    */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Please refer to the TrueType or OpenType specification for more    */
+  /*    details.                                                           */
+  /*                                                                       */
+  typedef struct  FT_SfntName_
+  {
+    FT_UShort  platform_id;
+    FT_UShort  encoding_id;
+    FT_UShort  language_id;
+    FT_UShort  name_id;
+
+    FT_Byte*   string;      /* this string is *not* null-terminated! */
+    FT_UInt    string_len;  /* in bytes                              */
+
+  } FT_SfntName;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Sfnt_Name_Count                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Retrieve the number of name strings in the SFNT `name' table.      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face :: A handle to the source face.                               */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The number of strings in the `name' table.                         */
+  /*                                                                       */
+  FT_EXPORT( FT_UInt )
+  FT_Get_Sfnt_Name_Count( FT_Face  face );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Sfnt_Name                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Retrieve a string of the SFNT `name' table for a given index.      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face  :: A handle to the source face.                              */
+  /*                                                                       */
+  /*    idx   :: The index of the `name' string.                           */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    aname :: The indexed @FT_SfntName structure.                       */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The `string' array returned in the `aname' structure is not        */
+  /*    null-terminated.  Note that you don't have to deallocate `string'  */
+  /*    by yourself; FreeType takes care of it if you call @FT_Done_Face.  */
+  /*                                                                       */
+  /*    Use @FT_Get_Sfnt_Name_Count to get the total number of available   */
+  /*    `name' table entries, then do a loop until you get the right       */
+  /*    platform, encoding, and name ID.                                   */
+  /*                                                                       */
+  /*    `name' table format~1 entries can use language tags also, see      */
+  /*    @FT_Get_Sfnt_LangTag.                                              */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Get_Sfnt_Name( FT_Face       face,
+                    FT_UInt       idx,
+                    FT_SfntName  *aname );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_SfntLangTag                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure to model a language tag entry from an SFNT `name'      */
+  /*    table.                                                             */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    string      :: The language tag string, encoded in UTF-16BE        */
+  /*                   (without trailing NULL bytes).                      */
+  /*                                                                       */
+  /*    string_len  :: The length of `string' in *bytes*.                  */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Please refer to the TrueType or OpenType specification for more    */
+  /*    details.                                                           */
+  /*                                                                       */
+  typedef struct  FT_SfntLangTag_
+  {
+    FT_Byte*  string;      /* this string is *not* null-terminated! */
+    FT_UInt   string_len;  /* in bytes                              */
+
+  } FT_SfntLangTag;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Sfnt_LangTag                                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Retrieve the language tag associated with a language ID of an SFNT */
+  /*    `name' table entry.                                                */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face     :: A handle to the source face.                           */
+  /*                                                                       */
+  /*    langID   :: The language ID, as returned by @FT_Get_Sfnt_Name.     */
+  /*                This is always a value larger than 0x8000.             */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    alangTag :: The language tag associated with the `name' table      */
+  /*                entry's language ID.                                   */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0~means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The `string' array returned in the `alangTag' structure is not     */
+  /*    null-terminated.  Note that you don't have to deallocate `string'  */
+  /*    by yourself; FreeType takes care of it if you call @FT_Done_Face.  */
+  /*                                                                       */
+  /*    Only `name' table format~1 supports language tags.  For format~0   */
+  /*    tables, this function always returns FT_Err_Invalid_Table.  For    */
+  /*    invalid format~1 language ID values, FT_Err_Invalid_Argument is    */
+  /*    returned.                                                          */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Get_Sfnt_LangTag( FT_Face          face,
+                       FT_UInt          langID,
+                       FT_SfntLangTag  *alangTag );
+
+
+  /***************************************************************************
+   *
+   * @constant:
+   *   FT_PARAM_TAG_IGNORE_TYPOGRAPHIC_FAMILY
+   *
+   * @description:
+   *   A tag for @FT_Parameter to make @FT_Open_Face ignore typographic
+   *   family names in the `name' table (introduced in OpenType version
+   *   1.4).  Use this for backward compatibility with legacy systems that
+   *   have a four-faces-per-family restriction.
+   *
+   */
+#define FT_PARAM_TAG_IGNORE_TYPOGRAPHIC_FAMILY \
+          FT_MAKE_TAG( 'i', 'g', 'p', 'f' )
+
+
+  /* this constant is deprecated */
+#define FT_PARAM_TAG_IGNORE_PREFERRED_FAMILY \
+          FT_PARAM_TAG_IGNORE_TYPOGRAPHIC_FAMILY
+
+
+  /***************************************************************************
+   *
+   * @constant:
+   *   FT_PARAM_TAG_IGNORE_TYPOGRAPHIC_SUBFAMILY
+   *
+   * @description:
+   *   A tag for @FT_Parameter to make @FT_Open_Face ignore typographic
+   *   subfamily names in the `name' table (introduced in OpenType version
+   *   1.4).  Use this for backward compatibility with legacy systems that
+   *   have a four-faces-per-family restriction.
+   *
+   */
+#define FT_PARAM_TAG_IGNORE_TYPOGRAPHIC_SUBFAMILY \
+          FT_MAKE_TAG( 'i', 'g', 'p', 's' )
+
+
+  /* this constant is deprecated */
+#define FT_PARAM_TAG_IGNORE_PREFERRED_SUBFAMILY \
+          FT_PARAM_TAG_IGNORE_TYPOGRAPHIC_SUBFAMILY
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* FTSNAMES_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ftstroke.h b/engine/inc/freetype/ftstroke.h
new file mode 100644
index 00000000..4a20667c
--- /dev/null
+++ b/engine/inc/freetype/ftstroke.h
@@ -0,0 +1,785 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftstroke.h                                                             */
+/*                                                                         */
+/*    FreeType path stroker (specification).                               */
+/*                                                                         */
+/*  Copyright 2002-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTSTROKE_H_
+#define FTSTROKE_H_
+
+#include <ft2build.h>
+#include FT_OUTLINE_H
+#include FT_GLYPH_H
+
+
+FT_BEGIN_HEADER
+
+
+ /************************************************************************
+  *
+  * @section:
+  *    glyph_stroker
+  *
+  * @title:
+  *    Glyph Stroker
+  *
+  * @abstract:
+  *    Generating bordered and stroked glyphs.
+  *
+  * @description:
+  *    This component generates stroked outlines of a given vectorial
+  *    glyph.  It also allows you to retrieve the `outside' and/or the
+  *    `inside' borders of the stroke.
+  *
+  *    This can be useful to generate `bordered' glyph, i.e., glyphs
+  *    displayed with a coloured (and anti-aliased) border around their
+  *    shape.
+  *
+  * @order:
+  *    FT_Stroker
+  *
+  *    FT_Stroker_LineJoin
+  *    FT_Stroker_LineCap
+  *    FT_StrokerBorder
+  *
+  *    FT_Outline_GetInsideBorder
+  *    FT_Outline_GetOutsideBorder
+  *
+  *    FT_Glyph_Stroke
+  *    FT_Glyph_StrokeBorder
+  *
+  *    FT_Stroker_New
+  *    FT_Stroker_Set
+  *    FT_Stroker_Rewind
+  *    FT_Stroker_ParseOutline
+  *    FT_Stroker_Done
+  *
+  *    FT_Stroker_BeginSubPath
+  *    FT_Stroker_EndSubPath
+  *
+  *    FT_Stroker_LineTo
+  *    FT_Stroker_ConicTo
+  *    FT_Stroker_CubicTo
+  *
+  *    FT_Stroker_GetBorderCounts
+  *    FT_Stroker_ExportBorder
+  *    FT_Stroker_GetCounts
+  *    FT_Stroker_Export
+  *
+  */
+
+
+ /**************************************************************
+  *
+  * @type:
+  *   FT_Stroker
+  *
+  * @description:
+  *   Opaque handle to a path stroker object.
+  */
+  typedef struct FT_StrokerRec_*  FT_Stroker;
+
+
+  /**************************************************************
+   *
+   * @enum:
+   *   FT_Stroker_LineJoin
+   *
+   * @description:
+   *   These values determine how two joining lines are rendered
+   *   in a stroker.
+   *
+   * @values:
+   *   FT_STROKER_LINEJOIN_ROUND ::
+   *     Used to render rounded line joins.  Circular arcs are used
+   *     to join two lines smoothly.
+   *
+   *   FT_STROKER_LINEJOIN_BEVEL ::
+   *     Used to render beveled line joins.  The outer corner of
+   *     the joined lines is filled by enclosing the triangular
+   *     region of the corner with a straight line between the
+   *     outer corners of each stroke.
+   *
+   *   FT_STROKER_LINEJOIN_MITER_FIXED ::
+   *     Used to render mitered line joins, with fixed bevels if the
+   *     miter limit is exceeded.  The outer edges of the strokes
+   *     for the two segments are extended until they meet at an
+   *     angle.  If the segments meet at too sharp an angle (such
+   *     that the miter would extend from the intersection of the
+   *     segments a distance greater than the product of the miter
+   *     limit value and the border radius), then a bevel join (see
+   *     above) is used instead.  This prevents long spikes being
+   *     created.  FT_STROKER_LINEJOIN_MITER_FIXED generates a miter
+   *     line join as used in PostScript and PDF.
+   *
+   *   FT_STROKER_LINEJOIN_MITER_VARIABLE ::
+   *   FT_STROKER_LINEJOIN_MITER ::
+   *     Used to render mitered line joins, with variable bevels if
+   *     the miter limit is exceeded.  The intersection of the
+   *     strokes is clipped at a line perpendicular to the bisector
+   *     of the angle between the strokes, at the distance from the
+   *     intersection of the segments equal to the product of the
+   *     miter limit value and the border radius.  This prevents
+   *     long spikes being created.
+   *     FT_STROKER_LINEJOIN_MITER_VARIABLE generates a mitered line
+   *     join as used in XPS.  FT_STROKER_LINEJOIN_MITER is an alias
+   *     for FT_STROKER_LINEJOIN_MITER_VARIABLE, retained for
+   *     backward compatibility.
+   */
+  typedef enum  FT_Stroker_LineJoin_
+  {
+    FT_STROKER_LINEJOIN_ROUND          = 0,
+    FT_STROKER_LINEJOIN_BEVEL          = 1,
+    FT_STROKER_LINEJOIN_MITER_VARIABLE = 2,
+    FT_STROKER_LINEJOIN_MITER          = FT_STROKER_LINEJOIN_MITER_VARIABLE,
+    FT_STROKER_LINEJOIN_MITER_FIXED    = 3
+
+  } FT_Stroker_LineJoin;
+
+
+  /**************************************************************
+   *
+   * @enum:
+   *   FT_Stroker_LineCap
+   *
+   * @description:
+   *   These values determine how the end of opened sub-paths are
+   *   rendered in a stroke.
+   *
+   * @values:
+   *   FT_STROKER_LINECAP_BUTT ::
+   *     The end of lines is rendered as a full stop on the last
+   *     point itself.
+   *
+   *   FT_STROKER_LINECAP_ROUND ::
+   *     The end of lines is rendered as a half-circle around the
+   *     last point.
+   *
+   *   FT_STROKER_LINECAP_SQUARE ::
+   *     The end of lines is rendered as a square around the
+   *     last point.
+   */
+  typedef enum  FT_Stroker_LineCap_
+  {
+    FT_STROKER_LINECAP_BUTT = 0,
+    FT_STROKER_LINECAP_ROUND,
+    FT_STROKER_LINECAP_SQUARE
+
+  } FT_Stroker_LineCap;
+
+
+  /**************************************************************
+   *
+   * @enum:
+   *   FT_StrokerBorder
+   *
+   * @description:
+   *   These values are used to select a given stroke border
+   *   in @FT_Stroker_GetBorderCounts and @FT_Stroker_ExportBorder.
+   *
+   * @values:
+   *   FT_STROKER_BORDER_LEFT ::
+   *     Select the left border, relative to the drawing direction.
+   *
+   *   FT_STROKER_BORDER_RIGHT ::
+   *     Select the right border, relative to the drawing direction.
+   *
+   * @note:
+   *   Applications are generally interested in the `inside' and `outside'
+   *   borders.  However, there is no direct mapping between these and the
+   *   `left' and `right' ones, since this really depends on the glyph's
+   *   drawing orientation, which varies between font formats.
+   *
+   *   You can however use @FT_Outline_GetInsideBorder and
+   *   @FT_Outline_GetOutsideBorder to get these.
+   */
+  typedef enum  FT_StrokerBorder_
+  {
+    FT_STROKER_BORDER_LEFT = 0,
+    FT_STROKER_BORDER_RIGHT
+
+  } FT_StrokerBorder;
+
+
+  /**************************************************************
+   *
+   * @function:
+   *   FT_Outline_GetInsideBorder
+   *
+   * @description:
+   *   Retrieve the @FT_StrokerBorder value corresponding to the
+   *   `inside' borders of a given outline.
+   *
+   * @input:
+   *   outline ::
+   *     The source outline handle.
+   *
+   * @return:
+   *   The border index.  @FT_STROKER_BORDER_RIGHT for empty or invalid
+   *   outlines.
+   */
+  FT_EXPORT( FT_StrokerBorder )
+  FT_Outline_GetInsideBorder( FT_Outline*  outline );
+
+
+  /**************************************************************
+   *
+   * @function:
+   *   FT_Outline_GetOutsideBorder
+   *
+   * @description:
+   *   Retrieve the @FT_StrokerBorder value corresponding to the
+   *   `outside' borders of a given outline.
+   *
+   * @input:
+   *   outline ::
+   *     The source outline handle.
+   *
+   * @return:
+   *   The border index.  @FT_STROKER_BORDER_LEFT for empty or invalid
+   *   outlines.
+   */
+  FT_EXPORT( FT_StrokerBorder )
+  FT_Outline_GetOutsideBorder( FT_Outline*  outline );
+
+
+  /**************************************************************
+   *
+   * @function:
+   *   FT_Stroker_New
+   *
+   * @description:
+   *   Create a new stroker object.
+   *
+   * @input:
+   *   library ::
+   *     FreeType library handle.
+   *
+   * @output:
+   *   astroker ::
+   *     A new stroker object handle.  NULL in case of error.
+   *
+   * @return:
+   *    FreeType error code.  0~means success.
+   */
+  FT_EXPORT( FT_Error )
+  FT_Stroker_New( FT_Library   library,
+                  FT_Stroker  *astroker );
+
+
+  /**************************************************************
+   *
+   * @function:
+   *   FT_Stroker_Set
+   *
+   * @description:
+   *   Reset a stroker object's attributes.
+   *
+   * @input:
+   *   stroker ::
+   *     The target stroker handle.
+   *
+   *   radius ::
+   *     The border radius.
+   *
+   *   line_cap ::
+   *     The line cap style.
+   *
+   *   line_join ::
+   *     The line join style.
+   *
+   *   miter_limit ::
+   *     The miter limit for the FT_STROKER_LINEJOIN_MITER_FIXED and
+   *     FT_STROKER_LINEJOIN_MITER_VARIABLE line join styles,
+   *     expressed as 16.16 fixed-point value.
+   *
+   * @note:
+   *   The radius is expressed in the same units as the outline
+   *   coordinates.
+   *
+   *   This function calls @FT_Stroker_Rewind automatically.
+   */
+  FT_EXPORT( void )
+  FT_Stroker_Set( FT_Stroker           stroker,
+                  FT_Fixed             radius,
+                  FT_Stroker_LineCap   line_cap,
+                  FT_Stroker_LineJoin  line_join,
+                  FT_Fixed             miter_limit );
+
+
+  /**************************************************************
+   *
+   * @function:
+   *   FT_Stroker_Rewind
+   *
+   * @description:
+   *   Reset a stroker object without changing its attributes.
+   *   You should call this function before beginning a new
+   *   series of calls to @FT_Stroker_BeginSubPath or
+   *   @FT_Stroker_EndSubPath.
+   *
+   * @input:
+   *   stroker ::
+   *     The target stroker handle.
+   */
+  FT_EXPORT( void )
+  FT_Stroker_Rewind( FT_Stroker  stroker );
+
+
+  /**************************************************************
+   *
+   * @function:
+   *   FT_Stroker_ParseOutline
+   *
+   * @description:
+   *   A convenience function used to parse a whole outline with
+   *   the stroker.  The resulting outline(s) can be retrieved
+   *   later by functions like @FT_Stroker_GetCounts and @FT_Stroker_Export.
+   *
+   * @input:
+   *   stroker ::
+   *     The target stroker handle.
+   *
+   *   outline ::
+   *     The source outline.
+   *
+   *   opened ::
+   *     A boolean.  If~1, the outline is treated as an open path instead
+   *     of a closed one.
+   *
+   * @return:
+   *   FreeType error code.  0~means success.
+   *
+   * @note:
+   *   If `opened' is~0 (the default), the outline is treated as a closed
+   *   path, and the stroker generates two distinct `border' outlines.
+   *
+   *   If `opened' is~1, the outline is processed as an open path, and the
+   *   stroker generates a single `stroke' outline.
+   *
+   *   This function calls @FT_Stroker_Rewind automatically.
+   */
+  FT_EXPORT( FT_Error )
+  FT_Stroker_ParseOutline( FT_Stroker   stroker,
+                           FT_Outline*  outline,
+                           FT_Bool      opened );
+
+
+  /**************************************************************
+   *
+   * @function:
+   *   FT_Stroker_BeginSubPath
+   *
+   * @description:
+   *   Start a new sub-path in the stroker.
+   *
+   * @input:
+   *   stroker ::
+   *     The target stroker handle.
+   *
+   *   to ::
+   *     A pointer to the start vector.
+   *
+   *   open ::
+   *     A boolean.  If~1, the sub-path is treated as an open one.
+   *
+   * @return:
+   *   FreeType error code.  0~means success.
+   *
+   * @note:
+   *   This function is useful when you need to stroke a path that is
+   *   not stored as an @FT_Outline object.
+   */
+  FT_EXPORT( FT_Error )
+  FT_Stroker_BeginSubPath( FT_Stroker  stroker,
+                           FT_Vector*  to,
+                           FT_Bool     open );
+
+
+  /**************************************************************
+   *
+   * @function:
+   *   FT_Stroker_EndSubPath
+   *
+   * @description:
+   *   Close the current sub-path in the stroker.
+   *
+   * @input:
+   *   stroker ::
+   *     The target stroker handle.
+   *
+   * @return:
+   *   FreeType error code.  0~means success.
+   *
+   * @note:
+   *   You should call this function after @FT_Stroker_BeginSubPath.
+   *   If the subpath was not `opened', this function `draws' a
+   *   single line segment to the start position when needed.
+   */
+  FT_EXPORT( FT_Error )
+  FT_Stroker_EndSubPath( FT_Stroker  stroker );
+
+
+  /**************************************************************
+   *
+   * @function:
+   *   FT_Stroker_LineTo
+   *
+   * @description:
+   *   `Draw' a single line segment in the stroker's current sub-path,
+   *   from the last position.
+   *
+   * @input:
+   *   stroker ::
+   *     The target stroker handle.
+   *
+   *   to ::
+   *     A pointer to the destination point.
+   *
+   * @return:
+   *   FreeType error code.  0~means success.
+   *
+   * @note:
+   *   You should call this function between @FT_Stroker_BeginSubPath and
+   *   @FT_Stroker_EndSubPath.
+   */
+  FT_EXPORT( FT_Error )
+  FT_Stroker_LineTo( FT_Stroker  stroker,
+                     FT_Vector*  to );
+
+
+  /**************************************************************
+   *
+   * @function:
+   *   FT_Stroker_ConicTo
+   *
+   * @description:
+   *   `Draw' a single quadratic Bézier in the stroker's current sub-path,
+   *   from the last position.
+   *
+   * @input:
+   *   stroker ::
+   *     The target stroker handle.
+   *
+   *   control ::
+   *     A pointer to a Bézier control point.
+   *
+   *   to ::
+   *     A pointer to the destination point.
+   *
+   * @return:
+   *   FreeType error code.  0~means success.
+   *
+   * @note:
+   *   You should call this function between @FT_Stroker_BeginSubPath and
+   *   @FT_Stroker_EndSubPath.
+   */
+  FT_EXPORT( FT_Error )
+  FT_Stroker_ConicTo( FT_Stroker  stroker,
+                      FT_Vector*  control,
+                      FT_Vector*  to );
+
+
+  /**************************************************************
+   *
+   * @function:
+   *   FT_Stroker_CubicTo
+   *
+   * @description:
+   *   `Draw' a single cubic Bézier in the stroker's current sub-path,
+   *   from the last position.
+   *
+   * @input:
+   *   stroker ::
+   *     The target stroker handle.
+   *
+   *   control1 ::
+   *     A pointer to the first Bézier control point.
+   *
+   *   control2 ::
+   *     A pointer to second Bézier control point.
+   *
+   *   to ::
+   *     A pointer to the destination point.
+   *
+   * @return:
+   *   FreeType error code.  0~means success.
+   *
+   * @note:
+   *   You should call this function between @FT_Stroker_BeginSubPath and
+   *   @FT_Stroker_EndSubPath.
+   */
+  FT_EXPORT( FT_Error )
+  FT_Stroker_CubicTo( FT_Stroker  stroker,
+                      FT_Vector*  control1,
+                      FT_Vector*  control2,
+                      FT_Vector*  to );
+
+
+  /**************************************************************
+   *
+   * @function:
+   *   FT_Stroker_GetBorderCounts
+   *
+   * @description:
+   *   Call this function once you have finished parsing your paths
+   *   with the stroker.  It returns the number of points and
+   *   contours necessary to export one of the `border' or `stroke'
+   *   outlines generated by the stroker.
+   *
+   * @input:
+   *   stroker ::
+   *     The target stroker handle.
+   *
+   *   border ::
+   *     The border index.
+   *
+   * @output:
+   *   anum_points ::
+   *     The number of points.
+   *
+   *   anum_contours ::
+   *     The number of contours.
+   *
+   * @return:
+   *   FreeType error code.  0~means success.
+   *
+   * @note:
+   *   When an outline, or a sub-path, is `closed', the stroker generates
+   *   two independent `border' outlines, named `left' and `right'.
+   *
+   *   When the outline, or a sub-path, is `opened', the stroker merges
+   *   the `border' outlines with caps.  The `left' border receives all
+   *   points, while the `right' border becomes empty.
+   *
+   *   Use the function @FT_Stroker_GetCounts instead if you want to
+   *   retrieve the counts associated to both borders.
+   */
+  FT_EXPORT( FT_Error )
+  FT_Stroker_GetBorderCounts( FT_Stroker        stroker,
+                              FT_StrokerBorder  border,
+                              FT_UInt          *anum_points,
+                              FT_UInt          *anum_contours );
+
+
+  /**************************************************************
+   *
+   * @function:
+   *   FT_Stroker_ExportBorder
+   *
+   * @description:
+   *   Call this function after @FT_Stroker_GetBorderCounts to
+   *   export the corresponding border to your own @FT_Outline
+   *   structure.
+   *
+   *   Note that this function appends the border points and
+   *   contours to your outline, but does not try to resize its
+   *   arrays.
+   *
+   * @input:
+   *   stroker ::
+   *     The target stroker handle.
+   *
+   *   border ::
+   *     The border index.
+   *
+   *   outline ::
+   *     The target outline handle.
+   *
+   * @note:
+   *   Always call this function after @FT_Stroker_GetBorderCounts to
+   *   get sure that there is enough room in your @FT_Outline object to
+   *   receive all new data.
+   *
+   *   When an outline, or a sub-path, is `closed', the stroker generates
+   *   two independent `border' outlines, named `left' and `right'.
+   *
+   *   When the outline, or a sub-path, is `opened', the stroker merges
+   *   the `border' outlines with caps.  The `left' border receives all
+   *   points, while the `right' border becomes empty.
+   *
+   *   Use the function @FT_Stroker_Export instead if you want to
+   *   retrieve all borders at once.
+   */
+  FT_EXPORT( void )
+  FT_Stroker_ExportBorder( FT_Stroker        stroker,
+                           FT_StrokerBorder  border,
+                           FT_Outline*       outline );
+
+
+  /**************************************************************
+   *
+   * @function:
+   *   FT_Stroker_GetCounts
+   *
+   * @description:
+   *   Call this function once you have finished parsing your paths
+   *   with the stroker.  It returns the number of points and
+   *   contours necessary to export all points/borders from the stroked
+   *   outline/path.
+   *
+   * @input:
+   *   stroker ::
+   *     The target stroker handle.
+   *
+   * @output:
+   *   anum_points ::
+   *     The number of points.
+   *
+   *   anum_contours ::
+   *     The number of contours.
+   *
+   * @return:
+   *   FreeType error code.  0~means success.
+   */
+  FT_EXPORT( FT_Error )
+  FT_Stroker_GetCounts( FT_Stroker  stroker,
+                        FT_UInt    *anum_points,
+                        FT_UInt    *anum_contours );
+
+
+  /**************************************************************
+   *
+   * @function:
+   *   FT_Stroker_Export
+   *
+   * @description:
+   *   Call this function after @FT_Stroker_GetBorderCounts to
+   *   export all borders to your own @FT_Outline structure.
+   *
+   *   Note that this function appends the border points and
+   *   contours to your outline, but does not try to resize its
+   *   arrays.
+   *
+   * @input:
+   *   stroker ::
+   *     The target stroker handle.
+   *
+   *   outline ::
+   *     The target outline handle.
+   */
+  FT_EXPORT( void )
+  FT_Stroker_Export( FT_Stroker   stroker,
+                     FT_Outline*  outline );
+
+
+  /**************************************************************
+   *
+   * @function:
+   *   FT_Stroker_Done
+   *
+   * @description:
+   *   Destroy a stroker object.
+   *
+   * @input:
+   *   stroker ::
+   *     A stroker handle.  Can be NULL.
+   */
+  FT_EXPORT( void )
+  FT_Stroker_Done( FT_Stroker  stroker );
+
+
+  /**************************************************************
+   *
+   * @function:
+   *   FT_Glyph_Stroke
+   *
+   * @description:
+   *   Stroke a given outline glyph object with a given stroker.
+   *
+   * @inout:
+   *   pglyph ::
+   *     Source glyph handle on input, new glyph handle on output.
+   *
+   * @input:
+   *   stroker ::
+   *     A stroker handle.
+   *
+   *   destroy ::
+   *     A Boolean.  If~1, the source glyph object is destroyed
+   *     on success.
+   *
+   * @return:
+   *    FreeType error code.  0~means success.
+   *
+   * @note:
+   *   The source glyph is untouched in case of error.
+   *
+   *   Adding stroke may yield a significantly wider and taller glyph
+   *   depending on how large of a radius was used to stroke the glyph.  You
+   *   may need to manually adjust horizontal and vertical advance amounts
+   *   to account for this added size.
+   */
+  FT_EXPORT( FT_Error )
+  FT_Glyph_Stroke( FT_Glyph    *pglyph,
+                   FT_Stroker   stroker,
+                   FT_Bool      destroy );
+
+
+  /**************************************************************
+   *
+   * @function:
+   *   FT_Glyph_StrokeBorder
+   *
+   * @description:
+   *   Stroke a given outline glyph object with a given stroker, but
+   *   only return either its inside or outside border.
+   *
+   * @inout:
+   *   pglyph ::
+   *     Source glyph handle on input, new glyph handle on output.
+   *
+   * @input:
+   *   stroker ::
+   *     A stroker handle.
+   *
+   *   inside ::
+   *     A Boolean.  If~1, return the inside border, otherwise
+   *     the outside border.
+   *
+   *   destroy ::
+   *     A Boolean.  If~1, the source glyph object is destroyed
+   *     on success.
+   *
+   * @return:
+   *    FreeType error code.  0~means success.
+   *
+   * @note:
+   *   The source glyph is untouched in case of error.
+   *
+   *   Adding stroke may yield a significantly wider and taller glyph
+   *   depending on how large of a radius was used to stroke the glyph.  You
+   *   may need to manually adjust horizontal and vertical advance amounts
+   *   to account for this added size.
+   */
+  FT_EXPORT( FT_Error )
+  FT_Glyph_StrokeBorder( FT_Glyph    *pglyph,
+                         FT_Stroker   stroker,
+                         FT_Bool      inside,
+                         FT_Bool      destroy );
+
+  /* */
+
+FT_END_HEADER
+
+#endif /* FTSTROKE_H_ */
+
+
+/* END */
+
+
+/* Local Variables: */
+/* coding: utf-8    */
+/* End:             */
diff --git a/engine/inc/freetype/ftsynth.h b/engine/inc/freetype/ftsynth.h
new file mode 100644
index 00000000..1863fa23
--- /dev/null
+++ b/engine/inc/freetype/ftsynth.h
@@ -0,0 +1,84 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftsynth.h                                                              */
+/*                                                                         */
+/*    FreeType synthesizing code for emboldening and slanting              */
+/*    (specification).                                                     */
+/*                                                                         */
+/*  Copyright 2000-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*********                                                       *********/
+  /*********        WARNING, THIS IS ALPHA CODE!  THIS API         *********/
+  /*********    IS DUE TO CHANGE UNTIL STRICTLY NOTIFIED BY THE    *********/
+  /*********            FREETYPE DEVELOPMENT TEAM                  *********/
+  /*********                                                       *********/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /* Main reason for not lifting the functions in this module to a  */
+  /* `standard' API is that the used parameters for emboldening and */
+  /* slanting are not configurable.  Consider the functions as a    */
+  /* code resource that should be copied into the application and   */
+  /* adapted to the particular needs.                               */
+
+
+#ifndef FTSYNTH_H_
+#define FTSYNTH_H_
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+  /* Embolden a glyph by a `reasonable' value (which is highly a matter of */
+  /* taste).  This function is actually a convenience function, providing  */
+  /* a wrapper for @FT_Outline_Embolden and @FT_Bitmap_Embolden.           */
+  /*                                                                       */
+  /* For emboldened outlines the height, width, and advance metrics are    */
+  /* increased by the strength of the emboldening -- this even affects     */
+  /* mono-width fonts!                                                     */
+  /*                                                                       */
+  /* You can also call @FT_Outline_Get_CBox to get precise values.         */
+  FT_EXPORT( void )
+  FT_GlyphSlot_Embolden( FT_GlyphSlot  slot );
+
+  /* Slant an outline glyph to the right by about 12 degrees. */
+  FT_EXPORT( void )
+  FT_GlyphSlot_Oblique( FT_GlyphSlot  slot );
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* FTSYNTH_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ftsystem.h b/engine/inc/freetype/ftsystem.h
new file mode 100644
index 00000000..1aa4762a
--- /dev/null
+++ b/engine/inc/freetype/ftsystem.h
@@ -0,0 +1,355 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftsystem.h                                                             */
+/*                                                                         */
+/*    FreeType low-level system interface definition (specification).      */
+/*                                                                         */
+/*  Copyright 1996-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTSYSTEM_H_
+#define FTSYSTEM_H_
+
+
+#include <ft2build.h>
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*   system_interface                                                    */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*   System Interface                                                    */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*   How FreeType manages memory and i/o.                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*   This section contains various definitions related to memory         */
+  /*   management and i/o access.  You need to understand this             */
+  /*   information if you want to use a custom memory manager or you own   */
+  /*   i/o streams.                                                        */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*                  M E M O R Y   M A N A G E M E N T                    */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************
+   *
+   * @type:
+   *   FT_Memory
+   *
+   * @description:
+   *   A handle to a given memory manager object, defined with an
+   *   @FT_MemoryRec structure.
+   *
+   */
+  typedef struct FT_MemoryRec_*  FT_Memory;
+
+
+  /*************************************************************************
+   *
+   * @functype:
+   *   FT_Alloc_Func
+   *
+   * @description:
+   *   A function used to allocate `size' bytes from `memory'.
+   *
+   * @input:
+   *   memory ::
+   *     A handle to the source memory manager.
+   *
+   *   size ::
+   *     The size in bytes to allocate.
+   *
+   * @return:
+   *   Address of new memory block.  0~in case of failure.
+   *
+   */
+  typedef void*
+  (*FT_Alloc_Func)( FT_Memory  memory,
+                    long       size );
+
+
+  /*************************************************************************
+   *
+   * @functype:
+   *   FT_Free_Func
+   *
+   * @description:
+   *   A function used to release a given block of memory.
+   *
+   * @input:
+   *   memory ::
+   *     A handle to the source memory manager.
+   *
+   *   block ::
+   *     The address of the target memory block.
+   *
+   */
+  typedef void
+  (*FT_Free_Func)( FT_Memory  memory,
+                   void*      block );
+
+
+  /*************************************************************************
+   *
+   * @functype:
+   *   FT_Realloc_Func
+   *
+   * @description:
+   *   A function used to re-allocate a given block of memory.
+   *
+   * @input:
+   *   memory ::
+   *     A handle to the source memory manager.
+   *
+   *   cur_size ::
+   *     The block's current size in bytes.
+   *
+   *   new_size ::
+   *     The block's requested new size.
+   *
+   *   block ::
+   *     The block's current address.
+   *
+   * @return:
+   *   New block address.  0~in case of memory shortage.
+   *
+   * @note:
+   *   In case of error, the old block must still be available.
+   *
+   */
+  typedef void*
+  (*FT_Realloc_Func)( FT_Memory  memory,
+                      long       cur_size,
+                      long       new_size,
+                      void*      block );
+
+
+  /*************************************************************************
+   *
+   * @struct:
+   *   FT_MemoryRec
+   *
+   * @description:
+   *   A structure used to describe a given memory manager to FreeType~2.
+   *
+   * @fields:
+   *   user ::
+   *     A generic typeless pointer for user data.
+   *
+   *   alloc ::
+   *     A pointer type to an allocation function.
+   *
+   *   free ::
+   *     A pointer type to an memory freeing function.
+   *
+   *   realloc ::
+   *     A pointer type to a reallocation function.
+   *
+   */
+  struct  FT_MemoryRec_
+  {
+    void*            user;
+    FT_Alloc_Func    alloc;
+    FT_Free_Func     free;
+    FT_Realloc_Func  realloc;
+  };
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*                       I / O   M A N A G E M E N T                     */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************
+   *
+   * @type:
+   *   FT_Stream
+   *
+   * @description:
+   *   A handle to an input stream.
+   *
+   * @also:
+   *   See @FT_StreamRec for the publicly accessible fields of a given
+   *   stream object.
+   *
+   */
+  typedef struct FT_StreamRec_*  FT_Stream;
+
+
+  /*************************************************************************
+   *
+   * @struct:
+   *   FT_StreamDesc
+   *
+   * @description:
+   *   A union type used to store either a long or a pointer.  This is used
+   *   to store a file descriptor or a `FILE*' in an input stream.
+   *
+   */
+  typedef union  FT_StreamDesc_
+  {
+    long   value;
+    void*  pointer;
+
+  } FT_StreamDesc;
+
+
+  /*************************************************************************
+   *
+   * @functype:
+   *   FT_Stream_IoFunc
+   *
+   * @description:
+   *   A function used to seek and read data from a given input stream.
+   *
+   * @input:
+   *   stream ::
+   *     A handle to the source stream.
+   *
+   *   offset ::
+   *     The offset of read in stream (always from start).
+   *
+   *   buffer ::
+   *     The address of the read buffer.
+   *
+   *   count ::
+   *     The number of bytes to read from the stream.
+   *
+   * @return:
+   *   The number of bytes effectively read by the stream.
+   *
+   * @note:
+   *   This function might be called to perform a seek or skip operation
+   *   with a `count' of~0.  A non-zero return value then indicates an
+   *   error.
+   *
+   */
+  typedef unsigned long
+  (*FT_Stream_IoFunc)( FT_Stream       stream,
+                       unsigned long   offset,
+                       unsigned char*  buffer,
+                       unsigned long   count );
+
+
+  /*************************************************************************
+   *
+   * @functype:
+   *   FT_Stream_CloseFunc
+   *
+   * @description:
+   *   A function used to close a given input stream.
+   *
+   * @input:
+   *  stream ::
+   *     A handle to the target stream.
+   *
+   */
+  typedef void
+  (*FT_Stream_CloseFunc)( FT_Stream  stream );
+
+
+  /*************************************************************************
+   *
+   * @struct:
+   *   FT_StreamRec
+   *
+   * @description:
+   *   A structure used to describe an input stream.
+   *
+   * @input:
+   *   base ::
+   *     For memory-based streams, this is the address of the first stream
+   *     byte in memory.  This field should always be set to NULL for
+   *     disk-based streams.
+   *
+   *   size ::
+   *     The stream size in bytes.
+   *
+   *     In case of compressed streams where the size is unknown before
+   *     actually doing the decompression, the value is set to 0x7FFFFFFF.
+   *     (Note that this size value can occur for normal streams also; it is
+   *     thus just a hint.)
+   *
+   *   pos ::
+   *     The current position within the stream.
+   *
+   *   descriptor ::
+   *     This field is a union that can hold an integer or a pointer.  It is
+   *     used by stream implementations to store file descriptors or `FILE*'
+   *     pointers.
+   *
+   *   pathname ::
+   *     This field is completely ignored by FreeType.  However, it is often
+   *     useful during debugging to use it to store the stream's filename
+   *     (where available).
+   *
+   *   read ::
+   *     The stream's input function.
+   *
+   *   close ::
+   *     The stream's close function.
+   *
+   *   memory ::
+   *     The memory manager to use to preload frames.  This is set
+   *     internally by FreeType and shouldn't be touched by stream
+   *     implementations.
+   *
+   *   cursor ::
+   *     This field is set and used internally by FreeType when parsing
+   *     frames.
+   *
+   *   limit ::
+   *     This field is set and used internally by FreeType when parsing
+   *     frames.
+   *
+   */
+  typedef struct  FT_StreamRec_
+  {
+    unsigned char*       base;
+    unsigned long        size;
+    unsigned long        pos;
+
+    FT_StreamDesc        descriptor;
+    FT_StreamDesc        pathname;
+    FT_Stream_IoFunc     read;
+    FT_Stream_CloseFunc  close;
+
+    FT_Memory            memory;
+    unsigned char*       cursor;
+    unsigned char*       limit;
+
+  } FT_StreamRec;
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* FTSYSTEM_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/fttrigon.h b/engine/inc/freetype/fttrigon.h
new file mode 100644
index 00000000..89f03506
--- /dev/null
+++ b/engine/inc/freetype/fttrigon.h
@@ -0,0 +1,350 @@
+/***************************************************************************/
+/*                                                                         */
+/*  fttrigon.h                                                             */
+/*                                                                         */
+/*    FreeType trigonometric functions (specification).                    */
+/*                                                                         */
+/*  Copyright 2001-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTTRIGON_H_
+#define FTTRIGON_H_
+
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*   computations                                                        */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************
+   *
+   * @type:
+   *   FT_Angle
+   *
+   * @description:
+   *   This type is used to model angle values in FreeType.  Note that the
+   *   angle is a 16.16 fixed-point value expressed in degrees.
+   *
+   */
+  typedef FT_Fixed  FT_Angle;
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_ANGLE_PI
+   *
+   * @description:
+   *   The angle pi expressed in @FT_Angle units.
+   *
+   */
+#define FT_ANGLE_PI  ( 180L << 16 )
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_ANGLE_2PI
+   *
+   * @description:
+   *   The angle 2*pi expressed in @FT_Angle units.
+   *
+   */
+#define FT_ANGLE_2PI  ( FT_ANGLE_PI * 2 )
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_ANGLE_PI2
+   *
+   * @description:
+   *   The angle pi/2 expressed in @FT_Angle units.
+   *
+   */
+#define FT_ANGLE_PI2  ( FT_ANGLE_PI / 2 )
+
+
+  /*************************************************************************
+   *
+   * @macro:
+   *   FT_ANGLE_PI4
+   *
+   * @description:
+   *   The angle pi/4 expressed in @FT_Angle units.
+   *
+   */
+#define FT_ANGLE_PI4  ( FT_ANGLE_PI / 4 )
+
+
+  /*************************************************************************
+   *
+   * @function:
+   *   FT_Sin
+   *
+   * @description:
+   *   Return the sinus of a given angle in fixed-point format.
+   *
+   * @input:
+   *   angle ::
+   *     The input angle.
+   *
+   * @return:
+   *   The sinus value.
+   *
+   * @note:
+   *   If you need both the sinus and cosinus for a given angle, use the
+   *   function @FT_Vector_Unit.
+   *
+   */
+  FT_EXPORT( FT_Fixed )
+  FT_Sin( FT_Angle  angle );
+
+
+  /*************************************************************************
+   *
+   * @function:
+   *   FT_Cos
+   *
+   * @description:
+   *   Return the cosinus of a given angle in fixed-point format.
+   *
+   * @input:
+   *   angle ::
+   *     The input angle.
+   *
+   * @return:
+   *   The cosinus value.
+   *
+   * @note:
+   *   If you need both the sinus and cosinus for a given angle, use the
+   *   function @FT_Vector_Unit.
+   *
+   */
+  FT_EXPORT( FT_Fixed )
+  FT_Cos( FT_Angle  angle );
+
+
+  /*************************************************************************
+   *
+   * @function:
+   *   FT_Tan
+   *
+   * @description:
+   *   Return the tangent of a given angle in fixed-point format.
+   *
+   * @input:
+   *   angle ::
+   *     The input angle.
+   *
+   * @return:
+   *   The tangent value.
+   *
+   */
+  FT_EXPORT( FT_Fixed )
+  FT_Tan( FT_Angle  angle );
+
+
+  /*************************************************************************
+   *
+   * @function:
+   *   FT_Atan2
+   *
+   * @description:
+   *   Return the arc-tangent corresponding to a given vector (x,y) in
+   *   the 2d plane.
+   *
+   * @input:
+   *   x ::
+   *     The horizontal vector coordinate.
+   *
+   *   y ::
+   *     The vertical vector coordinate.
+   *
+   * @return:
+   *   The arc-tangent value (i.e. angle).
+   *
+   */
+  FT_EXPORT( FT_Angle )
+  FT_Atan2( FT_Fixed  x,
+            FT_Fixed  y );
+
+
+  /*************************************************************************
+   *
+   * @function:
+   *   FT_Angle_Diff
+   *
+   * @description:
+   *   Return the difference between two angles.  The result is always
+   *   constrained to the ]-PI..PI] interval.
+   *
+   * @input:
+   *   angle1 ::
+   *     First angle.
+   *
+   *   angle2 ::
+   *     Second angle.
+   *
+   * @return:
+   *   Constrained value of `value2-value1'.
+   *
+   */
+  FT_EXPORT( FT_Angle )
+  FT_Angle_Diff( FT_Angle  angle1,
+                 FT_Angle  angle2 );
+
+
+  /*************************************************************************
+   *
+   * @function:
+   *   FT_Vector_Unit
+   *
+   * @description:
+   *   Return the unit vector corresponding to a given angle.  After the
+   *   call, the value of `vec.x' will be `cos(angle)', and the value of
+   *   `vec.y' will be `sin(angle)'.
+   *
+   *   This function is useful to retrieve both the sinus and cosinus of a
+   *   given angle quickly.
+   *
+   * @output:
+   *   vec ::
+   *     The address of target vector.
+   *
+   * @input:
+   *   angle ::
+   *     The input angle.
+   *
+   */
+  FT_EXPORT( void )
+  FT_Vector_Unit( FT_Vector*  vec,
+                  FT_Angle    angle );
+
+
+  /*************************************************************************
+   *
+   * @function:
+   *   FT_Vector_Rotate
+   *
+   * @description:
+   *   Rotate a vector by a given angle.
+   *
+   * @inout:
+   *   vec ::
+   *     The address of target vector.
+   *
+   * @input:
+   *   angle ::
+   *     The input angle.
+   *
+   */
+  FT_EXPORT( void )
+  FT_Vector_Rotate( FT_Vector*  vec,
+                    FT_Angle    angle );
+
+
+  /*************************************************************************
+   *
+   * @function:
+   *   FT_Vector_Length
+   *
+   * @description:
+   *   Return the length of a given vector.
+   *
+   * @input:
+   *   vec ::
+   *     The address of target vector.
+   *
+   * @return:
+   *   The vector length, expressed in the same units that the original
+   *   vector coordinates.
+   *
+   */
+  FT_EXPORT( FT_Fixed )
+  FT_Vector_Length( FT_Vector*  vec );
+
+
+  /*************************************************************************
+   *
+   * @function:
+   *   FT_Vector_Polarize
+   *
+   * @description:
+   *   Compute both the length and angle of a given vector.
+   *
+   * @input:
+   *   vec ::
+   *     The address of source vector.
+   *
+   * @output:
+   *   length ::
+   *     The vector length.
+   *
+   *   angle ::
+   *     The vector angle.
+   *
+   */
+  FT_EXPORT( void )
+  FT_Vector_Polarize( FT_Vector*  vec,
+                      FT_Fixed   *length,
+                      FT_Angle   *angle );
+
+
+  /*************************************************************************
+   *
+   * @function:
+   *   FT_Vector_From_Polar
+   *
+   * @description:
+   *   Compute vector coordinates from a length and angle.
+   *
+   * @output:
+   *   vec ::
+   *     The address of source vector.
+   *
+   * @input:
+   *   length ::
+   *     The vector length.
+   *
+   *   angle ::
+   *     The vector angle.
+   *
+   */
+  FT_EXPORT( void )
+  FT_Vector_From_Polar( FT_Vector*  vec,
+                        FT_Fixed    length,
+                        FT_Angle    angle );
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* FTTRIGON_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ftttdrv.h b/engine/inc/freetype/ftttdrv.h
new file mode 100644
index 00000000..26bc5e96
--- /dev/null
+++ b/engine/inc/freetype/ftttdrv.h
@@ -0,0 +1,328 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftttdrv.h                                                              */
+/*                                                                         */
+/*    FreeType API for controlling the TrueType driver                     */
+/*    (specification only).                                                */
+/*                                                                         */
+/*  Copyright 2013-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTTTDRV_H_
+#define FTTTDRV_H_
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+
+  /**************************************************************************
+   *
+   * @section:
+   *   tt_driver
+   *
+   * @title:
+   *   The TrueType driver
+   *
+   * @abstract:
+   *   Controlling the TrueType driver module.
+   *
+   * @description:
+   *   While FreeType's TrueType driver doesn't expose API functions by
+   *   itself, it is possible to control its behaviour with @FT_Property_Set
+   *   and @FT_Property_Get.  The following lists the available properties
+   *   together with the necessary macros and structures.
+   *
+   *   The TrueType driver's module name is `truetype'.
+   *
+   *   We start with a list of definitions, kindly provided by Greg
+   *   Hitchcock.
+   *
+   *   _Bi-Level_ _Rendering_
+   *
+   *   Monochromatic rendering, exclusively used in the early days of
+   *   TrueType by both Apple and Microsoft.  Microsoft's GDI interface
+   *   supported hinting of the right-side bearing point, such that the
+   *   advance width could be non-linear.  Most often this was done to
+   *   achieve some level of glyph symmetry.  To enable reasonable
+   *   performance (e.g., not having to run hinting on all glyphs just to
+   *   get the widths) there was a bit in the head table indicating if the
+   *   side bearing was hinted, and additional tables, `hdmx' and `LTSH', to
+   *   cache hinting widths across multiple sizes and device aspect ratios.
+   *
+   *   _Font_ _Smoothing_
+   *
+   *   Microsoft's GDI implementation of anti-aliasing.  Not traditional
+   *   anti-aliasing as the outlines were hinted before the sampling.  The
+   *   widths matched the bi-level rendering.
+   *
+   *   _ClearType_ _Rendering_
+   *
+   *   Technique that uses physical subpixels to improve rendering on LCD
+   *   (and other) displays.  Because of the higher resolution, many methods
+   *   of improving symmetry in glyphs through hinting the right-side
+   *   bearing were no longer necessary.  This lead to what GDI calls
+   *   `natural widths' ClearType, see
+   *   http://www.beatstamm.com/typography/RTRCh4.htm#Sec21.  Since hinting
+   *   has extra resolution, most non-linearity went away, but it is still
+   *   possible for hints to change the advance widths in this mode.
+   *
+   *   _ClearType_ _Compatible_ _Widths_
+   *
+   *   One of the earliest challenges with ClearType was allowing the
+   *   implementation in GDI to be selected without requiring all UI and
+   *   documents to reflow.  To address this, a compatible method of
+   *   rendering ClearType was added where the font hints are executed once
+   *   to determine the width in bi-level rendering, and then re-run in
+   *   ClearType, with the difference in widths being absorbed in the font
+   *   hints for ClearType (mostly in the white space of hints); see
+   *   http://www.beatstamm.com/typography/RTRCh4.htm#Sec20.  Somewhat by
+   *   definition, compatible width ClearType allows for non-linear widths,
+   *   but only when the bi-level version has non-linear widths.
+   *
+   *   _ClearType_ _Subpixel_ _Positioning_
+   *
+   *   One of the nice benefits of ClearType is the ability to more crisply
+   *   display fractional widths; unfortunately, the GDI model of integer
+   *   bitmaps did not support this.  However, the WPF and Direct Write
+   *   frameworks do support fractional widths.  DWrite calls this `natural
+   *   mode', not to be confused with GDI's `natural widths'.  Subpixel
+   *   positioning, in the current implementation of Direct Write,
+   *   unfortunately does not support hinted advance widths, see
+   *   http://www.beatstamm.com/typography/RTRCh4.htm#Sec22.  Note that the
+   *   TrueType interpreter fully allows the advance width to be adjusted in
+   *   this mode, just the DWrite client will ignore those changes.
+   *
+   *   _ClearType_ _Backward_ _Compatibility_
+   *
+   *   This is a set of exceptions made in the TrueType interpreter to
+   *   minimize hinting techniques that were problematic with the extra
+   *   resolution of ClearType; see
+   *   http://www.beatstamm.com/typography/RTRCh4.htm#Sec1 and
+   *   http://www.microsoft.com/typography/cleartype/truetypecleartype.aspx.
+   *   This technique is not to be confused with ClearType compatible
+   *   widths.  ClearType backward compatibility has no direct impact on
+   *   changing advance widths, but there might be an indirect impact on
+   *   disabling some deltas.  This could be worked around in backward
+   *   compatibility mode.
+   *
+   *   _Native_ _ClearType_ _Mode_
+   *
+   *   (Not to be confused with `natural widths'.)  This mode removes all
+   *   the exceptions in the TrueType interpreter when running with
+   *   ClearType.  Any issues on widths would still apply, though.
+   *
+   */
+
+
+  /**************************************************************************
+   *
+   * @property:
+   *   interpreter-version
+   *
+   * @description:
+   *   Currently, three versions are available, two representing the
+   *   bytecode interpreter with subpixel hinting support (old `Infinality'
+   *   code and new stripped-down and higher performance `minimal' code) and
+   *   one without, respectively.  The default is subpixel support if
+   *   TT_CONFIG_OPTION_SUBPIXEL_HINTING is defined, and no subpixel support
+   *   otherwise (since it isn't available then).
+   *
+   *   If subpixel hinting is on, many TrueType bytecode instructions behave
+   *   differently compared to B/W or grayscale rendering (except if `native
+   *   ClearType' is selected by the font).  Microsoft's main idea is to
+   *   render at a much increased horizontal resolution, then sampling down
+   *   the created output to subpixel precision.  However, many older fonts
+   *   are not suited to this and must be specially taken care of by
+   *   applying (hardcoded) tweaks in Microsoft's interpreter.
+   *
+   *   Details on subpixel hinting and some of the necessary tweaks can be
+   *   found in Greg Hitchcock's whitepaper at
+   *   `http://www.microsoft.com/typography/cleartype/truetypecleartype.aspx'. 
+   *   Note that FreeType currently doesn't really `subpixel hint' (6x1, 6x2,
+   *   or 6x5 supersampling) like discussed in the paper.  Depending on the
+   *   chosen interpreter, it simply ignores instructions on vertical stems
+   *   to arrive at very similar results.
+   *
+   *   The following example code demonstrates how to deactivate subpixel
+   *   hinting (omitting the error handling).
+   *
+   *   {
+   *     FT_Library  library;
+   *     FT_Face     face;
+   *     FT_UInt     interpreter_version = TT_INTERPRETER_VERSION_35;
+   *
+   *
+   *     FT_Init_FreeType( &library );
+   *
+   *     FT_Property_Set( library, "truetype",
+   *                               "interpreter-version",
+   *                               &interpreter_version );
+   *   }
+   *
+   * @note:
+   *   This property can be used with @FT_Property_Get also.
+   *
+   *   This property can be set via the `FREETYPE_PROPERTIES' environment
+   *   variable (using values `35', `38', or `40').
+   */
+
+
+  /**************************************************************************
+   *
+   * @enum:
+   *   TT_INTERPRETER_VERSION_XXX
+   *
+   * @description:
+   *   A list of constants used for the @interpreter-version property to
+   *   select the hinting engine for Truetype fonts.
+   *
+   *   The numeric value in the constant names represents the version
+   *   number as returned by the `GETINFO' bytecode instruction.
+   *
+   * @values:
+   *   TT_INTERPRETER_VERSION_35 ::
+   *     Version~35 corresponds to MS rasterizer v.1.7 as used e.g. in
+   *     Windows~98; only grayscale and B/W rasterizing is supported.
+   *
+   *   TT_INTERPRETER_VERSION_38 ::
+   *     Version~38 corresponds to MS rasterizer v.1.9; it is roughly
+   *     equivalent to the hinting provided by DirectWrite ClearType (as can
+   *     be found, for example, in the Internet Explorer~9 running on
+   *     Windows~7).  It is used in FreeType to select the `Infinality'
+   *     subpixel hinting code.  The code may be removed in a future
+   *     version.
+   *
+   *   TT_INTERPRETER_VERSION_40 ::
+   *     Version~40 corresponds to MS rasterizer v.2.1; it is roughly
+   *     equivalent to the hinting provided by DirectWrite ClearType (as can
+   *     be found, for example, in Microsoft's Edge Browser on Windows~10). 
+   *     It is used in FreeType to select the `minimal' subpixel hinting
+   *     code, a stripped-down and higher performance version of the
+   *     `Infinality' code.
+   *
+   * @note:
+   *   This property controls the behaviour of the bytecode interpreter
+   *   and thus how outlines get hinted.  It does *not* control how glyph
+   *   get rasterized!  In particular, it does not control subpixel color
+   *   filtering.
+   *
+   *   If FreeType has not been compiled with the configuration option
+   *   TT_CONFIG_OPTION_SUBPIXEL_HINTING, selecting version~38 or~40 causes
+   *   an `FT_Err_Unimplemented_Feature' error.
+   *
+   *   Depending on the graphics framework, Microsoft uses different
+   *   bytecode and rendering engines.  As a consequence, the version
+   *   numbers returned by a call to the `GETINFO' bytecode instruction are
+   *   more convoluted than desired.
+   *
+   *   Here are two tables that try to shed some light on the possible
+   *   values for the MS rasterizer engine, together with the additional
+   *   features introduced by it.
+   *
+   *   {
+   *     GETINFO framework               version feature
+   *     -------------------------------------------------------------------
+   *         3   GDI (Win 3.1),            v1.0  16-bit, first version
+   *             TrueImage
+   *        33   GDI (Win NT 3.1),         v1.5  32-bit
+   *             HP Laserjet
+   *        34   GDI (Win 95)              v1.6  font smoothing,
+   *                                             new SCANTYPE opcode
+   *        35   GDI (Win 98/2000)         v1.7  (UN)SCALED_COMPONENT_OFFSET
+   *                                               bits in composite glyphs
+   *        36   MGDI (Win CE 2)           v1.6+ classic ClearType
+   *        37   GDI (XP and later),       v1.8  ClearType
+   *             GDI+ old (before Vista)
+   *        38   GDI+ old (Vista, Win 7),  v1.9  subpixel ClearType,
+   *             WPF                             Y-direction ClearType,
+   *                                             additional error checking
+   *        39   DWrite (before Win 8)     v2.0  subpixel ClearType flags
+   *                                               in GETINFO opcode,
+   *                                             bug fixes
+   *        40   GDI+ (after Win 7),       v2.1  Y-direction ClearType flag
+   *             DWrite (Win 8)                    in GETINFO opcode,
+   *                                             Gray ClearType
+   *   }
+   *
+   *   The `version' field gives a rough orientation only, since some
+   *   applications provided certain features much earlier (as an example,
+   *   Microsoft Reader used subpixel and Y-direction ClearType already in
+   *   Windows 2000).  Similarly, updates to a given framework might include
+   *   improved hinting support.
+   *
+   *   {
+   *      version   sampling          rendering        comment
+   *               x        y       x           y
+   *     --------------------------------------------------------------
+   *       v1.0   normal  normal  B/W           B/W    bi-level
+   *       v1.6   high    high    gray          gray   grayscale
+   *       v1.8   high    normal  color-filter  B/W    (GDI) ClearType
+   *       v1.9   high    high    color-filter  gray   Color ClearType
+   *       v2.1   high    normal  gray          B/W    Gray ClearType
+   *       v2.1   high    high    gray          gray   Gray ClearType
+   *   }
+   *
+   *   Color and Gray ClearType are the two available variants of
+   *   `Y-direction ClearType', meaning grayscale rasterization along the
+   *   Y-direction; the name used in the TrueType specification for this
+   *   feature is `symmetric smoothing'.  `Classic ClearType' is the
+   *   original algorithm used before introducing a modified version in
+   *   Win~XP.  Another name for v1.6's grayscale rendering is `font
+   *   smoothing', and `Color ClearType' is sometimes also called `DWrite
+   *   ClearType'.  To differentiate between today's Color ClearType and the
+   *   earlier ClearType variant with B/W rendering along the vertical axis,
+   *   the latter is sometimes called `GDI ClearType'.
+   *
+   *   `Normal' and `high' sampling describe the (virtual) resolution to
+   *   access the rasterized outline after the hinting process.  `Normal'
+   *   means 1 sample per grid line (i.e., B/W).  In the current Microsoft
+   *   implementation, `high' means an extra virtual resolution of 16x16 (or
+   *   16x1) grid lines per pixel for bytecode instructions like `MIRP'.
+   *   After hinting, these 16 grid lines are mapped to 6x5 (or 6x1) grid
+   *   lines for color filtering if Color ClearType is activated.
+   *
+   *   Note that `Gray ClearType' is essentially the same as v1.6's
+   *   grayscale rendering.  However, the GETINFO instruction handles it
+   *   differently: v1.6 returns bit~12 (hinting for grayscale), while v2.1
+   *   returns bits~13 (hinting for ClearType), 18 (symmetrical smoothing),
+   *   and~19 (Gray ClearType).  Also, this mode respects bits 2 and~3 for
+   *   the version~1 gasp table exclusively (like Color ClearType), while
+   *   v1.6 only respects the values of version~0 (bits 0 and~1).
+   *
+   *   Keep in mind that the features of the above interpreter versions
+   *   might not map exactly to FreeType features or behavior because it is
+   *   a fundamentally different library with different internals.
+   *
+   */
+#define TT_INTERPRETER_VERSION_35  35
+#define TT_INTERPRETER_VERSION_38  38
+#define TT_INTERPRETER_VERSION_40  40
+
+ /* */
+
+
+FT_END_HEADER
+
+
+#endif /* FTTTDRV_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/fttypes.h b/engine/inc/freetype/fttypes.h
new file mode 100644
index 00000000..eab8adaa
--- /dev/null
+++ b/engine/inc/freetype/fttypes.h
@@ -0,0 +1,602 @@
+/***************************************************************************/
+/*                                                                         */
+/*  fttypes.h                                                              */
+/*                                                                         */
+/*    FreeType simple types definitions (specification only).              */
+/*                                                                         */
+/*  Copyright 1996-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTTYPES_H_
+#define FTTYPES_H_
+
+
+#include <ft2build.h>
+#include FT_CONFIG_CONFIG_H
+#include FT_SYSTEM_H
+#include FT_IMAGE_H
+
+#include <stddef.h>
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    basic_types                                                        */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    Basic Data Types                                                   */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    The basic data types defined by the library.                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains the basic data types defined by FreeType~2,  */
+  /*    ranging from simple scalar types to bitmap descriptors.  More      */
+  /*    font-specific structures are defined in a different section.       */
+  /*                                                                       */
+  /* <Order>                                                               */
+  /*    FT_Byte                                                            */
+  /*    FT_Bytes                                                           */
+  /*    FT_Char                                                            */
+  /*    FT_Int                                                             */
+  /*    FT_UInt                                                            */
+  /*    FT_Int16                                                           */
+  /*    FT_UInt16                                                          */
+  /*    FT_Int32                                                           */
+  /*    FT_UInt32                                                          */
+  /*    FT_Int64                                                           */
+  /*    FT_UInt64                                                          */
+  /*    FT_Short                                                           */
+  /*    FT_UShort                                                          */
+  /*    FT_Long                                                            */
+  /*    FT_ULong                                                           */
+  /*    FT_Bool                                                            */
+  /*    FT_Offset                                                          */
+  /*    FT_PtrDist                                                         */
+  /*    FT_String                                                          */
+  /*    FT_Tag                                                             */
+  /*    FT_Error                                                           */
+  /*    FT_Fixed                                                           */
+  /*    FT_Pointer                                                         */
+  /*    FT_Pos                                                             */
+  /*    FT_Vector                                                          */
+  /*    FT_BBox                                                            */
+  /*    FT_Matrix                                                          */
+  /*    FT_FWord                                                           */
+  /*    FT_UFWord                                                          */
+  /*    FT_F2Dot14                                                         */
+  /*    FT_UnitVector                                                      */
+  /*    FT_F26Dot6                                                         */
+  /*    FT_Data                                                            */
+  /*                                                                       */
+  /*    FT_MAKE_TAG                                                        */
+  /*                                                                       */
+  /*    FT_Generic                                                         */
+  /*    FT_Generic_Finalizer                                               */
+  /*                                                                       */
+  /*    FT_Bitmap                                                          */
+  /*    FT_Pixel_Mode                                                      */
+  /*    FT_Palette_Mode                                                    */
+  /*    FT_Glyph_Format                                                    */
+  /*    FT_IMAGE_TAG                                                       */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Bool                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A typedef of unsigned char, used for simple booleans.  As usual,   */
+  /*    values 1 and~0 represent true and false, respectively.             */
+  /*                                                                       */
+  typedef unsigned char  FT_Bool;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_FWord                                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A signed 16-bit integer used to store a distance in original font  */
+  /*    units.                                                             */
+  /*                                                                       */
+  typedef signed short  FT_FWord;   /* distance in FUnits */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_UFWord                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An unsigned 16-bit integer used to store a distance in original    */
+  /*    font units.                                                        */
+  /*                                                                       */
+  typedef unsigned short  FT_UFWord;  /* unsigned distance */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Char                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A simple typedef for the _signed_ char type.                       */
+  /*                                                                       */
+  typedef signed char  FT_Char;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Byte                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A simple typedef for the _unsigned_ char type.                     */
+  /*                                                                       */
+  typedef unsigned char  FT_Byte;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Bytes                                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A typedef for constant memory areas.                               */
+  /*                                                                       */
+  typedef const FT_Byte*  FT_Bytes;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Tag                                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A typedef for 32-bit tags (as used in the SFNT format).            */
+  /*                                                                       */
+  typedef FT_UInt32  FT_Tag;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_String                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A simple typedef for the char type, usually used for strings.      */
+  /*                                                                       */
+  typedef char  FT_String;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Short                                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A typedef for signed short.                                        */
+  /*                                                                       */
+  typedef signed short  FT_Short;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_UShort                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A typedef for unsigned short.                                      */
+  /*                                                                       */
+  typedef unsigned short  FT_UShort;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Int                                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A typedef for the int type.                                        */
+  /*                                                                       */
+  typedef signed int  FT_Int;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_UInt                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A typedef for the unsigned int type.                               */
+  /*                                                                       */
+  typedef unsigned int  FT_UInt;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Long                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A typedef for signed long.                                         */
+  /*                                                                       */
+  typedef signed long  FT_Long;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_ULong                                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A typedef for unsigned long.                                       */
+  /*                                                                       */
+  typedef unsigned long  FT_ULong;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_F2Dot14                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A signed 2.14 fixed-point type used for unit vectors.              */
+  /*                                                                       */
+  typedef signed short  FT_F2Dot14;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_F26Dot6                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A signed 26.6 fixed-point type used for vectorial pixel            */
+  /*    coordinates.                                                       */
+  /*                                                                       */
+  typedef signed long  FT_F26Dot6;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Fixed                                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This type is used to store 16.16 fixed-point values, like scaling  */
+  /*    values or matrix coefficients.                                     */
+  /*                                                                       */
+  typedef signed long  FT_Fixed;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Error                                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The FreeType error code type.  A value of~0 is always interpreted  */
+  /*    as a successful operation.                                         */
+  /*                                                                       */
+  typedef int  FT_Error;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Pointer                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A simple typedef for a typeless pointer.                           */
+  /*                                                                       */
+  typedef void*  FT_Pointer;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Offset                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This is equivalent to the ANSI~C `size_t' type, i.e., the largest  */
+  /*    _unsigned_ integer type used to express a file size or position,   */
+  /*    or a memory block size.                                            */
+  /*                                                                       */
+  typedef size_t  FT_Offset;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_PtrDist                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This is equivalent to the ANSI~C `ptrdiff_t' type, i.e., the       */
+  /*    largest _signed_ integer type used to express the distance         */
+  /*    between two pointers.                                              */
+  /*                                                                       */
+  typedef ft_ptrdiff_t  FT_PtrDist;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_UnitVector                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A simple structure used to store a 2D vector unit vector.  Uses    */
+  /*    FT_F2Dot14 types.                                                  */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    x :: Horizontal coordinate.                                        */
+  /*                                                                       */
+  /*    y :: Vertical coordinate.                                          */
+  /*                                                                       */
+  typedef struct  FT_UnitVector_
+  {
+    FT_F2Dot14  x;
+    FT_F2Dot14  y;
+
+  } FT_UnitVector;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Matrix                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A simple structure used to store a 2x2 matrix.  Coefficients are   */
+  /*    in 16.16 fixed-point format.  The computation performed is:        */
+  /*                                                                       */
+  /*       {                                                               */
+  /*          x' = x*xx + y*xy                                             */
+  /*          y' = x*yx + y*yy                                             */
+  /*       }                                                               */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    xx :: Matrix coefficient.                                          */
+  /*                                                                       */
+  /*    xy :: Matrix coefficient.                                          */
+  /*                                                                       */
+  /*    yx :: Matrix coefficient.                                          */
+  /*                                                                       */
+  /*    yy :: Matrix coefficient.                                          */
+  /*                                                                       */
+  typedef struct  FT_Matrix_
+  {
+    FT_Fixed  xx, xy;
+    FT_Fixed  yx, yy;
+
+  } FT_Matrix;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Data                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Read-only binary data represented as a pointer and a length.       */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    pointer :: The data.                                               */
+  /*                                                                       */
+  /*    length  :: The length of the data in bytes.                        */
+  /*                                                                       */
+  typedef struct  FT_Data_
+  {
+    const FT_Byte*  pointer;
+    FT_Int          length;
+
+  } FT_Data;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_Generic_Finalizer                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Describe a function used to destroy the `client' data of any       */
+  /*    FreeType object.  See the description of the @FT_Generic type for  */
+  /*    details of usage.                                                  */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    The address of the FreeType object that is under finalization.     */
+  /*    Its client data is accessed through its `generic' field.           */
+  /*                                                                       */
+  typedef void  (*FT_Generic_Finalizer)(void*  object);
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Generic                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Client applications often need to associate their own data to a    */
+  /*    variety of FreeType core objects.  For example, a text layout API  */
+  /*    might want to associate a glyph cache to a given size object.      */
+  /*                                                                       */
+  /*    Some FreeType object contains a `generic' field, of type           */
+  /*    FT_Generic, which usage is left to client applications and font    */
+  /*    servers.                                                           */
+  /*                                                                       */
+  /*    It can be used to store a pointer to client-specific data, as well */
+  /*    as the address of a `finalizer' function, which will be called by  */
+  /*    FreeType when the object is destroyed (for example, the previous   */
+  /*    client example would put the address of the glyph cache destructor */
+  /*    in the `finalizer' field).                                         */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    data      :: A typeless pointer to any client-specified data. This */
+  /*                 field is completely ignored by the FreeType library.  */
+  /*                                                                       */
+  /*    finalizer :: A pointer to a `generic finalizer' function, which    */
+  /*                 will be called when the object is destroyed.  If this */
+  /*                 field is set to NULL, no code will be called.         */
+  /*                                                                       */
+  typedef struct  FT_Generic_
+  {
+    void*                 data;
+    FT_Generic_Finalizer  finalizer;
+
+  } FT_Generic;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Macro>                                                               */
+  /*    FT_MAKE_TAG                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This macro converts four-letter tags that are used to label        */
+  /*    TrueType tables into an unsigned long, to be used within FreeType. */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The produced values *must* be 32-bit integers.  Don't redefine     */
+  /*    this macro.                                                        */
+  /*                                                                       */
+#define FT_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
+          (FT_Tag)                        \
+          ( ( (FT_ULong)_x1 << 24 ) |     \
+            ( (FT_ULong)_x2 << 16 ) |     \
+            ( (FT_ULong)_x3 <<  8 ) |     \
+              (FT_ULong)_x4         )
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*                                                                       */
+  /*                    L I S T   M A N A G E M E N T                      */
+  /*                                                                       */
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    list_processing                                                    */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_ListNode                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*     Many elements and objects in FreeType are listed through an       */
+  /*     @FT_List record (see @FT_ListRec).  As its name suggests, an      */
+  /*     FT_ListNode is a handle to a single list element.                 */
+  /*                                                                       */
+  typedef struct FT_ListNodeRec_*  FT_ListNode;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_List                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a list record (see @FT_ListRec).                       */
+  /*                                                                       */
+  typedef struct FT_ListRec_*  FT_List;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_ListNodeRec                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to hold a single list element.                    */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    prev :: The previous element in the list.  NULL if first.          */
+  /*                                                                       */
+  /*    next :: The next element in the list.  NULL if last.               */
+  /*                                                                       */
+  /*    data :: A typeless pointer to the listed object.                   */
+  /*                                                                       */
+  typedef struct  FT_ListNodeRec_
+  {
+    FT_ListNode  prev;
+    FT_ListNode  next;
+    void*        data;
+
+  } FT_ListNodeRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_ListRec                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to hold a simple doubly-linked list.  These are   */
+  /*    used in many parts of FreeType.                                    */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    head :: The head (first element) of doubly-linked list.            */
+  /*                                                                       */
+  /*    tail :: The tail (last element) of doubly-linked list.             */
+  /*                                                                       */
+  typedef struct  FT_ListRec_
+  {
+    FT_ListNode  head;
+    FT_ListNode  tail;
+
+  } FT_ListRec;
+
+  /* */
+
+
+#define FT_IS_EMPTY( list )  ( (list).head == 0 )
+#define FT_BOOL( x )  ( (FT_Bool)( x ) )
+
+  /* concatenate C tokens */
+#define FT_ERR_XCAT( x, y )  x ## y
+#define FT_ERR_CAT( x, y )   FT_ERR_XCAT( x, y )
+
+  /* see `ftmoderr.h' for descriptions of the following macros */
+
+#define FT_ERR( e )  FT_ERR_CAT( FT_ERR_PREFIX, e )
+
+#define FT_ERROR_BASE( x )    ( (x) & 0xFF )
+#define FT_ERROR_MODULE( x )  ( (x) & 0xFF00U )
+
+#define FT_ERR_EQ( x, e )                                        \
+          ( FT_ERROR_BASE( x ) == FT_ERROR_BASE( FT_ERR( e ) ) )
+#define FT_ERR_NEQ( x, e )                                       \
+          ( FT_ERROR_BASE( x ) != FT_ERROR_BASE( FT_ERR( e ) ) )
+
+
+FT_END_HEADER
+
+#endif /* FTTYPES_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ftwinfnt.h b/engine/inc/freetype/ftwinfnt.h
new file mode 100644
index 00000000..1eeef6c8
--- /dev/null
+++ b/engine/inc/freetype/ftwinfnt.h
@@ -0,0 +1,275 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftwinfnt.h                                                             */
+/*                                                                         */
+/*    FreeType API for accessing Windows fnt-specific data.                */
+/*                                                                         */
+/*  Copyright 2003-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef FTWINFNT_H_
+#define FTWINFNT_H_
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    winfnt_fonts                                                       */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    Window FNT Files                                                   */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    Windows FNT specific API.                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains the declaration of Windows FNT specific      */
+  /*    functions.                                                         */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************
+   *
+   * @enum:
+   *   FT_WinFNT_ID_XXX
+   *
+   * @description:
+   *   A list of valid values for the `charset' byte in
+   *   @FT_WinFNT_HeaderRec.  Exact mapping tables for the various cpXXXX
+   *   encodings (except for cp1361) can be found at
+   *   ftp://ftp.unicode.org/Public in the MAPPINGS/VENDORS/MICSFT/WINDOWS
+   *   subdirectory.  cp1361 is roughly a superset of
+   *   MAPPINGS/OBSOLETE/EASTASIA/KSC/JOHAB.TXT.
+   *
+   * @values:
+   *   FT_WinFNT_ID_DEFAULT ::
+   *     This is used for font enumeration and font creation as a
+   *     `don't care' value.  Valid font files don't contain this value.
+   *     When querying for information about the character set of the font
+   *     that is currently selected into a specified device context, this
+   *     return value (of the related Windows API) simply denotes failure.
+   *
+   *   FT_WinFNT_ID_SYMBOL ::
+   *     There is no known mapping table available.
+   *
+   *   FT_WinFNT_ID_MAC ::
+   *     Mac Roman encoding.
+   *
+   *   FT_WinFNT_ID_OEM ::
+   *     From Michael Pöttgen <michael@poettgen.de>:
+   *
+   *       The `Windows Font Mapping' article says that FT_WinFNT_ID_OEM
+   *       is used for the charset of vector fonts, like `modern.fon',
+   *       `roman.fon', and `script.fon' on Windows.
+   *
+   *       The `CreateFont' documentation says: The FT_WinFNT_ID_OEM value
+   *       specifies a character set that is operating-system dependent.
+   *
+   *       The `IFIMETRICS' documentation from the `Windows Driver
+   *       Development Kit' says: This font supports an OEM-specific
+   *       character set.  The OEM character set is system dependent.
+   *
+   *       In general OEM, as opposed to ANSI (i.e., cp1252), denotes the
+   *       second default codepage that most international versions of
+   *       Windows have.  It is one of the OEM codepages from
+   *
+   *         https://msdn.microsoft.com/en-us/goglobal/bb964655,
+   *
+   *       and is used for the `DOS boxes', to support legacy applications.
+   *       A German Windows version for example usually uses ANSI codepage
+   *       1252 and OEM codepage 850.
+   *
+   *   FT_WinFNT_ID_CP874 ::
+   *     A superset of Thai TIS 620 and ISO 8859-11.
+   *
+   *   FT_WinFNT_ID_CP932 ::
+   *     A superset of Japanese Shift-JIS (with minor deviations).
+   *
+   *   FT_WinFNT_ID_CP936 ::
+   *     A superset of simplified Chinese GB 2312-1980 (with different
+   *     ordering and minor deviations).
+   *
+   *   FT_WinFNT_ID_CP949 ::
+   *     A superset of Korean Hangul KS~C 5601-1987 (with different
+   *     ordering and minor deviations).
+   *
+   *   FT_WinFNT_ID_CP950 ::
+   *     A superset of traditional Chinese Big~5 ETen (with different
+   *     ordering and minor deviations).
+   *
+   *   FT_WinFNT_ID_CP1250 ::
+   *     A superset of East European ISO 8859-2 (with slightly different
+   *     ordering).
+   *
+   *   FT_WinFNT_ID_CP1251 ::
+   *     A superset of Russian ISO 8859-5 (with different ordering).
+   *
+   *   FT_WinFNT_ID_CP1252 ::
+   *     ANSI encoding.  A superset of ISO 8859-1.
+   *
+   *   FT_WinFNT_ID_CP1253 ::
+   *     A superset of Greek ISO 8859-7 (with minor modifications).
+   *
+   *   FT_WinFNT_ID_CP1254 ::
+   *     A superset of Turkish ISO 8859-9.
+   *
+   *   FT_WinFNT_ID_CP1255 ::
+   *     A superset of Hebrew ISO 8859-8 (with some modifications).
+   *
+   *   FT_WinFNT_ID_CP1256 ::
+   *     A superset of Arabic ISO 8859-6 (with different ordering).
+   *
+   *   FT_WinFNT_ID_CP1257 ::
+   *     A superset of Baltic ISO 8859-13 (with some deviations).
+   *
+   *   FT_WinFNT_ID_CP1258 ::
+   *     For Vietnamese.  This encoding doesn't cover all necessary
+   *     characters.
+   *
+   *   FT_WinFNT_ID_CP1361 ::
+   *     Korean (Johab).
+   */
+
+#define FT_WinFNT_ID_CP1252    0
+#define FT_WinFNT_ID_DEFAULT   1
+#define FT_WinFNT_ID_SYMBOL    2
+#define FT_WinFNT_ID_MAC      77
+#define FT_WinFNT_ID_CP932   128
+#define FT_WinFNT_ID_CP949   129
+#define FT_WinFNT_ID_CP1361  130
+#define FT_WinFNT_ID_CP936   134
+#define FT_WinFNT_ID_CP950   136
+#define FT_WinFNT_ID_CP1253  161
+#define FT_WinFNT_ID_CP1254  162
+#define FT_WinFNT_ID_CP1258  163
+#define FT_WinFNT_ID_CP1255  177
+#define FT_WinFNT_ID_CP1256  178
+#define FT_WinFNT_ID_CP1257  186
+#define FT_WinFNT_ID_CP1251  204
+#define FT_WinFNT_ID_CP874   222
+#define FT_WinFNT_ID_CP1250  238
+#define FT_WinFNT_ID_OEM     255
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_WinFNT_HeaderRec                                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Windows FNT Header info.                                           */
+  /*                                                                       */
+  typedef struct  FT_WinFNT_HeaderRec_
+  {
+    FT_UShort  version;
+    FT_ULong   file_size;
+    FT_Byte    copyright[60];
+    FT_UShort  file_type;
+    FT_UShort  nominal_point_size;
+    FT_UShort  vertical_resolution;
+    FT_UShort  horizontal_resolution;
+    FT_UShort  ascent;
+    FT_UShort  internal_leading;
+    FT_UShort  external_leading;
+    FT_Byte    italic;
+    FT_Byte    underline;
+    FT_Byte    strike_out;
+    FT_UShort  weight;
+    FT_Byte    charset;
+    FT_UShort  pixel_width;
+    FT_UShort  pixel_height;
+    FT_Byte    pitch_and_family;
+    FT_UShort  avg_width;
+    FT_UShort  max_width;
+    FT_Byte    first_char;
+    FT_Byte    last_char;
+    FT_Byte    default_char;
+    FT_Byte    break_char;
+    FT_UShort  bytes_per_row;
+    FT_ULong   device_offset;
+    FT_ULong   face_name_offset;
+    FT_ULong   bits_pointer;
+    FT_ULong   bits_offset;
+    FT_Byte    reserved;
+    FT_ULong   flags;
+    FT_UShort  A_space;
+    FT_UShort  B_space;
+    FT_UShort  C_space;
+    FT_UShort  color_table_offset;
+    FT_ULong   reserved1[4];
+
+  } FT_WinFNT_HeaderRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_WinFNT_Header                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to an @FT_WinFNT_HeaderRec structure.                     */
+  /*                                                                       */
+  typedef struct FT_WinFNT_HeaderRec_*  FT_WinFNT_Header;
+
+
+  /**********************************************************************
+   *
+   * @function:
+   *    FT_Get_WinFNT_Header
+   *
+   * @description:
+   *    Retrieve a Windows FNT font info header.
+   *
+   * @input:
+   *    face    :: A handle to the input face.
+   *
+   * @output:
+   *    aheader :: The WinFNT header.
+   *
+   * @return:
+   *   FreeType error code.  0~means success.
+   *
+   * @note:
+   *   This function only works with Windows FNT faces, returning an error
+   *   otherwise.
+   */
+  FT_EXPORT( FT_Error )
+  FT_Get_WinFNT_Header( FT_Face               face,
+                        FT_WinFNT_HeaderRec  *aheader );
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* FTWINFNT_H_ */
+
+
+/* END */
+
+
+/* Local Variables: */
+/* coding: utf-8    */
+/* End:             */
diff --git a/engine/inc/freetype/t1tables.h b/engine/inc/freetype/t1tables.h
new file mode 100644
index 00000000..3f6b36e1
--- /dev/null
+++ b/engine/inc/freetype/t1tables.h
@@ -0,0 +1,761 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t1tables.h                                                             */
+/*                                                                         */
+/*    Basic Type 1/Type 2 tables definitions and interface (specification  */
+/*    only).                                                               */
+/*                                                                         */
+/*  Copyright 1996-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef T1TABLES_H_
+#define T1TABLES_H_
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    type1_tables                                                       */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    Type 1 Tables                                                      */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    Type~1 (PostScript) specific font tables.                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains the definition of Type 1-specific tables,    */
+  /*    including structures related to other PostScript font formats.     */
+  /*                                                                       */
+  /* <Order>                                                               */
+  /*    PS_FontInfoRec                                                     */
+  /*    PS_FontInfo                                                        */
+  /*    PS_PrivateRec                                                      */
+  /*    PS_Private                                                         */
+  /*                                                                       */
+  /*    CID_FaceDictRec                                                    */
+  /*    CID_FaceDict                                                       */
+  /*    CID_FaceInfoRec                                                    */
+  /*    CID_FaceInfo                                                       */
+  /*                                                                       */
+  /*    FT_Has_PS_Glyph_Names                                              */
+  /*    FT_Get_PS_Font_Info                                                */
+  /*    FT_Get_PS_Font_Private                                             */
+  /*    FT_Get_PS_Font_Value                                               */
+  /*                                                                       */
+  /*    T1_Blend_Flags                                                     */
+  /*    T1_EncodingType                                                    */
+  /*    PS_Dict_Keys                                                       */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /* Note that we separate font data in PS_FontInfoRec and PS_PrivateRec */
+  /* structures in order to support Multiple Master fonts.               */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    PS_FontInfoRec                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to model a Type~1 or Type~2 FontInfo dictionary.  */
+  /*    Note that for Multiple Master fonts, each instance has its own     */
+  /*    FontInfo dictionary.                                               */
+  /*                                                                       */
+  typedef struct  PS_FontInfoRec_
+  {
+    FT_String*  version;
+    FT_String*  notice;
+    FT_String*  full_name;
+    FT_String*  family_name;
+    FT_String*  weight;
+    FT_Long     italic_angle;
+    FT_Bool     is_fixed_pitch;
+    FT_Short    underline_position;
+    FT_UShort   underline_thickness;
+
+  } PS_FontInfoRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    PS_FontInfo                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a @PS_FontInfoRec structure.                           */
+  /*                                                                       */
+  typedef struct PS_FontInfoRec_*  PS_FontInfo;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    T1_FontInfo                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This type is equivalent to @PS_FontInfoRec.  It is deprecated but  */
+  /*    kept to maintain source compatibility between various versions of  */
+  /*    FreeType.                                                          */
+  /*                                                                       */
+  typedef PS_FontInfoRec  T1_FontInfo;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    PS_PrivateRec                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to model a Type~1 or Type~2 private dictionary.   */
+  /*    Note that for Multiple Master fonts, each instance has its own     */
+  /*    Private dictionary.                                                */
+  /*                                                                       */
+  typedef struct  PS_PrivateRec_
+  {
+    FT_Int     unique_id;
+    FT_Int     lenIV;
+
+    FT_Byte    num_blue_values;
+    FT_Byte    num_other_blues;
+    FT_Byte    num_family_blues;
+    FT_Byte    num_family_other_blues;
+
+    FT_Short   blue_values[14];
+    FT_Short   other_blues[10];
+
+    FT_Short   family_blues      [14];
+    FT_Short   family_other_blues[10];
+
+    FT_Fixed   blue_scale;
+    FT_Int     blue_shift;
+    FT_Int     blue_fuzz;
+
+    FT_UShort  standard_width[1];
+    FT_UShort  standard_height[1];
+
+    FT_Byte    num_snap_widths;
+    FT_Byte    num_snap_heights;
+    FT_Bool    force_bold;
+    FT_Bool    round_stem_up;
+
+    FT_Short   snap_widths [13];  /* including std width  */
+    FT_Short   snap_heights[13];  /* including std height */
+
+    FT_Fixed   expansion_factor;
+
+    FT_Long    language_group;
+    FT_Long    password;
+
+    FT_Short   min_feature[2];
+
+  } PS_PrivateRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    PS_Private                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a @PS_PrivateRec structure.                            */
+  /*                                                                       */
+  typedef struct PS_PrivateRec_*  PS_Private;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    T1_Private                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*   This type is equivalent to @PS_PrivateRec.  It is deprecated but    */
+  /*   kept to maintain source compatibility between various versions of   */
+  /*   FreeType.                                                           */
+  /*                                                                       */
+  typedef PS_PrivateRec  T1_Private;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    T1_Blend_Flags                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A set of flags used to indicate which fields are present in a      */
+  /*    given blend dictionary (font info or private).  Used to support    */
+  /*    Multiple Masters fonts.                                            */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    T1_BLEND_UNDERLINE_POSITION ::                                     */
+  /*    T1_BLEND_UNDERLINE_THICKNESS ::                                    */
+  /*    T1_BLEND_ITALIC_ANGLE ::                                           */
+  /*    T1_BLEND_BLUE_VALUES ::                                            */
+  /*    T1_BLEND_OTHER_BLUES ::                                            */
+  /*    T1_BLEND_STANDARD_WIDTH ::                                         */
+  /*    T1_BLEND_STANDARD_HEIGHT ::                                        */
+  /*    T1_BLEND_STEM_SNAP_WIDTHS ::                                       */
+  /*    T1_BLEND_STEM_SNAP_HEIGHTS ::                                      */
+  /*    T1_BLEND_BLUE_SCALE ::                                             */
+  /*    T1_BLEND_BLUE_SHIFT ::                                             */
+  /*    T1_BLEND_FAMILY_BLUES ::                                           */
+  /*    T1_BLEND_FAMILY_OTHER_BLUES ::                                     */
+  /*    T1_BLEND_FORCE_BOLD ::                                             */
+  /*                                                                       */
+  typedef enum  T1_Blend_Flags_
+  {
+    /* required fields in a FontInfo blend dictionary */
+    T1_BLEND_UNDERLINE_POSITION = 0,
+    T1_BLEND_UNDERLINE_THICKNESS,
+    T1_BLEND_ITALIC_ANGLE,
+
+    /* required fields in a Private blend dictionary */
+    T1_BLEND_BLUE_VALUES,
+    T1_BLEND_OTHER_BLUES,
+    T1_BLEND_STANDARD_WIDTH,
+    T1_BLEND_STANDARD_HEIGHT,
+    T1_BLEND_STEM_SNAP_WIDTHS,
+    T1_BLEND_STEM_SNAP_HEIGHTS,
+    T1_BLEND_BLUE_SCALE,
+    T1_BLEND_BLUE_SHIFT,
+    T1_BLEND_FAMILY_BLUES,
+    T1_BLEND_FAMILY_OTHER_BLUES,
+    T1_BLEND_FORCE_BOLD,
+
+    T1_BLEND_MAX    /* do not remove */
+
+  } T1_Blend_Flags;
+
+
+  /* these constants are deprecated; use the corresponding */
+  /* `T1_Blend_Flags' values instead                       */
+#define t1_blend_underline_position   T1_BLEND_UNDERLINE_POSITION
+#define t1_blend_underline_thickness  T1_BLEND_UNDERLINE_THICKNESS
+#define t1_blend_italic_angle         T1_BLEND_ITALIC_ANGLE
+#define t1_blend_blue_values          T1_BLEND_BLUE_VALUES
+#define t1_blend_other_blues          T1_BLEND_OTHER_BLUES
+#define t1_blend_standard_widths      T1_BLEND_STANDARD_WIDTH
+#define t1_blend_standard_height      T1_BLEND_STANDARD_HEIGHT
+#define t1_blend_stem_snap_widths     T1_BLEND_STEM_SNAP_WIDTHS
+#define t1_blend_stem_snap_heights    T1_BLEND_STEM_SNAP_HEIGHTS
+#define t1_blend_blue_scale           T1_BLEND_BLUE_SCALE
+#define t1_blend_blue_shift           T1_BLEND_BLUE_SHIFT
+#define t1_blend_family_blues         T1_BLEND_FAMILY_BLUES
+#define t1_blend_family_other_blues   T1_BLEND_FAMILY_OTHER_BLUES
+#define t1_blend_force_bold           T1_BLEND_FORCE_BOLD
+#define t1_blend_max                  T1_BLEND_MAX
+
+  /* */
+
+
+  /* maximum number of Multiple Masters designs, as defined in the spec */
+#define T1_MAX_MM_DESIGNS     16
+
+  /* maximum number of Multiple Masters axes, as defined in the spec */
+#define T1_MAX_MM_AXIS        4
+
+  /* maximum number of elements in a design map */
+#define T1_MAX_MM_MAP_POINTS  20
+
+
+  /* this structure is used to store the BlendDesignMap entry for an axis */
+  typedef struct  PS_DesignMap_
+  {
+    FT_Byte    num_points;
+    FT_Long*   design_points;
+    FT_Fixed*  blend_points;
+
+  } PS_DesignMapRec, *PS_DesignMap;
+
+  /* backward compatible definition */
+  typedef PS_DesignMapRec  T1_DesignMap;
+
+
+  typedef struct  PS_BlendRec_
+  {
+    FT_UInt          num_designs;
+    FT_UInt          num_axis;
+
+    FT_String*       axis_names[T1_MAX_MM_AXIS];
+    FT_Fixed*        design_pos[T1_MAX_MM_DESIGNS];
+    PS_DesignMapRec  design_map[T1_MAX_MM_AXIS];
+
+    FT_Fixed*        weight_vector;
+    FT_Fixed*        default_weight_vector;
+
+    PS_FontInfo      font_infos[T1_MAX_MM_DESIGNS + 1];
+    PS_Private       privates  [T1_MAX_MM_DESIGNS + 1];
+
+    FT_ULong         blend_bitflags;
+
+    FT_BBox*         bboxes    [T1_MAX_MM_DESIGNS + 1];
+
+    /* since 2.3.0 */
+
+    /* undocumented, optional: the default design instance;   */
+    /* corresponds to default_weight_vector --                */
+    /* num_default_design_vector == 0 means it is not present */
+    /* in the font and associated metrics files               */
+    FT_UInt          default_design_vector[T1_MAX_MM_DESIGNS];
+    FT_UInt          num_default_design_vector;
+
+  } PS_BlendRec, *PS_Blend;
+
+
+  /* backward compatible definition */
+  typedef PS_BlendRec  T1_Blend;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    CID_FaceDictRec                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to represent data in a CID top-level dictionary.  */
+  /*                                                                       */
+  typedef struct  CID_FaceDictRec_
+  {
+    PS_PrivateRec  private_dict;
+
+    FT_UInt        len_buildchar;
+    FT_Fixed       forcebold_threshold;
+    FT_Pos         stroke_width;
+    FT_Fixed       expansion_factor;
+
+    FT_Byte        paint_type;
+    FT_Byte        font_type;
+    FT_Matrix      font_matrix;
+    FT_Vector      font_offset;
+
+    FT_UInt        num_subrs;
+    FT_ULong       subrmap_offset;
+    FT_Int         sd_bytes;
+
+  } CID_FaceDictRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    CID_FaceDict                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a @CID_FaceDictRec structure.                          */
+  /*                                                                       */
+  typedef struct CID_FaceDictRec_*  CID_FaceDict;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    CID_FontDict                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This type is equivalent to @CID_FaceDictRec.  It is deprecated but */
+  /*    kept to maintain source compatibility between various versions of  */
+  /*    FreeType.                                                          */
+  /*                                                                       */
+  typedef CID_FaceDictRec  CID_FontDict;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    CID_FaceInfoRec                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to represent CID Face information.                */
+  /*                                                                       */
+  typedef struct  CID_FaceInfoRec_
+  {
+    FT_String*      cid_font_name;
+    FT_Fixed        cid_version;
+    FT_Int          cid_font_type;
+
+    FT_String*      registry;
+    FT_String*      ordering;
+    FT_Int          supplement;
+
+    PS_FontInfoRec  font_info;
+    FT_BBox         font_bbox;
+    FT_ULong        uid_base;
+
+    FT_Int          num_xuid;
+    FT_ULong        xuid[16];
+
+    FT_ULong        cidmap_offset;
+    FT_Int          fd_bytes;
+    FT_Int          gd_bytes;
+    FT_ULong        cid_count;
+
+    FT_Int          num_dicts;
+    CID_FaceDict    font_dicts;
+
+    FT_ULong        data_offset;
+
+  } CID_FaceInfoRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    CID_FaceInfo                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a @CID_FaceInfoRec structure.                          */
+  /*                                                                       */
+  typedef struct CID_FaceInfoRec_*  CID_FaceInfo;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    CID_Info                                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*   This type is equivalent to @CID_FaceInfoRec.  It is deprecated but  */
+  /*   kept to maintain source compatibility between various versions of   */
+  /*   FreeType.                                                           */
+  /*                                                                       */
+  typedef CID_FaceInfoRec  CID_Info;
+
+
+  /************************************************************************
+   *
+   * @function:
+   *    FT_Has_PS_Glyph_Names
+   *
+   * @description:
+   *    Return true if a given face provides reliable PostScript glyph
+   *    names.  This is similar to using the @FT_HAS_GLYPH_NAMES macro,
+   *    except that certain fonts (mostly TrueType) contain incorrect
+   *    glyph name tables.
+   *
+   *    When this function returns true, the caller is sure that the glyph
+   *    names returned by @FT_Get_Glyph_Name are reliable.
+   *
+   * @input:
+   *    face ::
+   *       face handle
+   *
+   * @return:
+   *    Boolean.  True if glyph names are reliable.
+   *
+   */
+  FT_EXPORT( FT_Int )
+  FT_Has_PS_Glyph_Names( FT_Face  face );
+
+
+  /************************************************************************
+   *
+   * @function:
+   *    FT_Get_PS_Font_Info
+   *
+   * @description:
+   *    Retrieve the @PS_FontInfoRec structure corresponding to a given
+   *    PostScript font.
+   *
+   * @input:
+   *    face ::
+   *       PostScript face handle.
+   *
+   * @output:
+   *    afont_info ::
+   *       Output font info structure pointer.
+   *
+   * @return:
+   *    FreeType error code.  0~means success.
+   *
+   * @note:
+   *    String pointers within the @PS_FontInfoRec structure are owned by
+   *    the face and don't need to be freed by the caller.  Missing entries
+   *    in the font's FontInfo dictionary are represented by NULL pointers.
+   *
+   *    If the font's format is not PostScript-based, this function will
+   *    return the `FT_Err_Invalid_Argument' error code.
+   *
+   */
+  FT_EXPORT( FT_Error )
+  FT_Get_PS_Font_Info( FT_Face      face,
+                       PS_FontInfo  afont_info );
+
+
+  /************************************************************************
+   *
+   * @function:
+   *    FT_Get_PS_Font_Private
+   *
+   * @description:
+   *    Retrieve the @PS_PrivateRec structure corresponding to a given
+   *    PostScript font.
+   *
+   * @input:
+   *    face ::
+   *       PostScript face handle.
+   *
+   * @output:
+   *    afont_private ::
+   *       Output private dictionary structure pointer.
+   *
+   * @return:
+   *    FreeType error code.  0~means success.
+   *
+   * @note:
+   *    The string pointers within the @PS_PrivateRec structure are owned by
+   *    the face and don't need to be freed by the caller.
+   *
+   *    If the font's format is not PostScript-based, this function returns
+   *    the `FT_Err_Invalid_Argument' error code.
+   *
+   */
+  FT_EXPORT( FT_Error )
+  FT_Get_PS_Font_Private( FT_Face     face,
+                          PS_Private  afont_private );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    T1_EncodingType                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An enumeration describing the `Encoding' entry in a Type 1         */
+  /*    dictionary.                                                        */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    T1_ENCODING_TYPE_NONE ::                                           */
+  /*    T1_ENCODING_TYPE_ARRAY ::                                          */
+  /*    T1_ENCODING_TYPE_STANDARD ::                                       */
+  /*    T1_ENCODING_TYPE_ISOLATIN1 ::                                      */
+  /*    T1_ENCODING_TYPE_EXPERT ::                                         */
+  /*                                                                       */
+  typedef enum  T1_EncodingType_
+  {
+    T1_ENCODING_TYPE_NONE = 0,
+    T1_ENCODING_TYPE_ARRAY,
+    T1_ENCODING_TYPE_STANDARD,
+    T1_ENCODING_TYPE_ISOLATIN1,
+    T1_ENCODING_TYPE_EXPERT
+
+  } T1_EncodingType;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    PS_Dict_Keys                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An enumeration used in calls to @FT_Get_PS_Font_Value to identify  */
+  /*    the Type~1 dictionary entry to retrieve.                           */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    PS_DICT_FONT_TYPE ::                                               */
+  /*    PS_DICT_FONT_MATRIX ::                                             */
+  /*    PS_DICT_FONT_BBOX ::                                               */
+  /*    PS_DICT_PAINT_TYPE ::                                              */
+  /*    PS_DICT_FONT_NAME ::                                               */
+  /*    PS_DICT_UNIQUE_ID ::                                               */
+  /*    PS_DICT_NUM_CHAR_STRINGS ::                                        */
+  /*    PS_DICT_CHAR_STRING_KEY ::                                         */
+  /*    PS_DICT_CHAR_STRING ::                                             */
+  /*    PS_DICT_ENCODING_TYPE ::                                           */
+  /*    PS_DICT_ENCODING_ENTRY ::                                          */
+  /*    PS_DICT_NUM_SUBRS ::                                               */
+  /*    PS_DICT_SUBR ::                                                    */
+  /*    PS_DICT_STD_HW ::                                                  */
+  /*    PS_DICT_STD_VW ::                                                  */
+  /*    PS_DICT_NUM_BLUE_VALUES ::                                         */
+  /*    PS_DICT_BLUE_VALUE ::                                              */
+  /*    PS_DICT_BLUE_FUZZ ::                                               */
+  /*    PS_DICT_NUM_OTHER_BLUES ::                                         */
+  /*    PS_DICT_OTHER_BLUE ::                                              */
+  /*    PS_DICT_NUM_FAMILY_BLUES ::                                        */
+  /*    PS_DICT_FAMILY_BLUE ::                                             */
+  /*    PS_DICT_NUM_FAMILY_OTHER_BLUES ::                                  */
+  /*    PS_DICT_FAMILY_OTHER_BLUE ::                                       */
+  /*    PS_DICT_BLUE_SCALE ::                                              */
+  /*    PS_DICT_BLUE_SHIFT ::                                              */
+  /*    PS_DICT_NUM_STEM_SNAP_H ::                                         */
+  /*    PS_DICT_STEM_SNAP_H ::                                             */
+  /*    PS_DICT_NUM_STEM_SNAP_V ::                                         */
+  /*    PS_DICT_STEM_SNAP_V ::                                             */
+  /*    PS_DICT_FORCE_BOLD ::                                              */
+  /*    PS_DICT_RND_STEM_UP ::                                             */
+  /*    PS_DICT_MIN_FEATURE ::                                             */
+  /*    PS_DICT_LEN_IV ::                                                  */
+  /*    PS_DICT_PASSWORD ::                                                */
+  /*    PS_DICT_LANGUAGE_GROUP ::                                          */
+  /*    PS_DICT_VERSION ::                                                 */
+  /*    PS_DICT_NOTICE ::                                                  */
+  /*    PS_DICT_FULL_NAME ::                                               */
+  /*    PS_DICT_FAMILY_NAME ::                                             */
+  /*    PS_DICT_WEIGHT ::                                                  */
+  /*    PS_DICT_IS_FIXED_PITCH ::                                          */
+  /*    PS_DICT_UNDERLINE_POSITION ::                                      */
+  /*    PS_DICT_UNDERLINE_THICKNESS ::                                     */
+  /*    PS_DICT_FS_TYPE ::                                                 */
+  /*    PS_DICT_ITALIC_ANGLE ::                                            */
+  /*                                                                       */
+  typedef enum  PS_Dict_Keys_
+  {
+    /* conventionally in the font dictionary */
+    PS_DICT_FONT_TYPE,              /* FT_Byte         */
+    PS_DICT_FONT_MATRIX,            /* FT_Fixed        */
+    PS_DICT_FONT_BBOX,              /* FT_Fixed        */
+    PS_DICT_PAINT_TYPE,             /* FT_Byte         */
+    PS_DICT_FONT_NAME,              /* FT_String*      */
+    PS_DICT_UNIQUE_ID,              /* FT_Int          */
+    PS_DICT_NUM_CHAR_STRINGS,       /* FT_Int          */
+    PS_DICT_CHAR_STRING_KEY,        /* FT_String*      */
+    PS_DICT_CHAR_STRING,            /* FT_String*      */
+    PS_DICT_ENCODING_TYPE,          /* T1_EncodingType */
+    PS_DICT_ENCODING_ENTRY,         /* FT_String*      */
+
+    /* conventionally in the font Private dictionary */
+    PS_DICT_NUM_SUBRS,              /* FT_Int     */
+    PS_DICT_SUBR,                   /* FT_String* */
+    PS_DICT_STD_HW,                 /* FT_UShort  */
+    PS_DICT_STD_VW,                 /* FT_UShort  */
+    PS_DICT_NUM_BLUE_VALUES,        /* FT_Byte    */
+    PS_DICT_BLUE_VALUE,             /* FT_Short   */
+    PS_DICT_BLUE_FUZZ,              /* FT_Int     */
+    PS_DICT_NUM_OTHER_BLUES,        /* FT_Byte    */
+    PS_DICT_OTHER_BLUE,             /* FT_Short   */
+    PS_DICT_NUM_FAMILY_BLUES,       /* FT_Byte    */
+    PS_DICT_FAMILY_BLUE,            /* FT_Short   */
+    PS_DICT_NUM_FAMILY_OTHER_BLUES, /* FT_Byte    */
+    PS_DICT_FAMILY_OTHER_BLUE,      /* FT_Short   */
+    PS_DICT_BLUE_SCALE,             /* FT_Fixed   */
+    PS_DICT_BLUE_SHIFT,             /* FT_Int     */
+    PS_DICT_NUM_STEM_SNAP_H,        /* FT_Byte    */
+    PS_DICT_STEM_SNAP_H,            /* FT_Short   */
+    PS_DICT_NUM_STEM_SNAP_V,        /* FT_Byte    */
+    PS_DICT_STEM_SNAP_V,            /* FT_Short   */
+    PS_DICT_FORCE_BOLD,             /* FT_Bool    */
+    PS_DICT_RND_STEM_UP,            /* FT_Bool    */
+    PS_DICT_MIN_FEATURE,            /* FT_Short   */
+    PS_DICT_LEN_IV,                 /* FT_Int     */
+    PS_DICT_PASSWORD,               /* FT_Long    */
+    PS_DICT_LANGUAGE_GROUP,         /* FT_Long    */
+
+    /* conventionally in the font FontInfo dictionary */
+    PS_DICT_VERSION,                /* FT_String* */
+    PS_DICT_NOTICE,                 /* FT_String* */
+    PS_DICT_FULL_NAME,              /* FT_String* */
+    PS_DICT_FAMILY_NAME,            /* FT_String* */
+    PS_DICT_WEIGHT,                 /* FT_String* */
+    PS_DICT_IS_FIXED_PITCH,         /* FT_Bool    */
+    PS_DICT_UNDERLINE_POSITION,     /* FT_Short   */
+    PS_DICT_UNDERLINE_THICKNESS,    /* FT_UShort  */
+    PS_DICT_FS_TYPE,                /* FT_UShort  */
+    PS_DICT_ITALIC_ANGLE,           /* FT_Long    */
+
+    PS_DICT_MAX = PS_DICT_ITALIC_ANGLE
+
+  } PS_Dict_Keys;
+
+
+  /************************************************************************
+   *
+   * @function:
+   *    FT_Get_PS_Font_Value
+   *
+   * @description:
+   *    Retrieve the value for the supplied key from a PostScript font.
+   *
+   * @input:
+   *    face ::
+   *       PostScript face handle.
+   *
+   *    key ::
+   *       An enumeration value representing the dictionary key to retrieve.
+   *
+   *    idx ::
+   *       For array values, this specifies the index to be returned.
+   *
+   *    value ::
+   *       A pointer to memory into which to write the value.
+   *
+   *    valen_len ::
+   *       The size, in bytes, of the memory supplied for the value.
+   *
+   * @output:
+   *    value ::
+   *       The value matching the above key, if it exists.
+   *
+   * @return:
+   *    The amount of memory (in bytes) required to hold the requested
+   *    value (if it exists, -1 otherwise).
+   *
+   * @note:
+   *    The values returned are not pointers into the internal structures of
+   *    the face, but are `fresh' copies, so that the memory containing them
+   *    belongs to the calling application.  This also enforces the
+   *    `read-only' nature of these values, i.e., this function cannot be
+   *    used to manipulate the face.
+   *
+   *    `value' is a void pointer because the values returned can be of
+   *    various types.
+   *
+   *    If either `value' is NULL or `value_len' is too small, just the
+   *    required memory size for the requested entry is returned.
+   *
+   *    The `idx' parameter is used, not only to retrieve elements of, for
+   *    example, the FontMatrix or FontBBox, but also to retrieve name keys
+   *    from the CharStrings dictionary, and the charstrings themselves.  It
+   *    is ignored for atomic values.
+   *
+   *    PS_DICT_BLUE_SCALE returns a value that is scaled up by 1000.  To
+   *    get the value as in the font stream, you need to divide by
+   *    65536000.0 (to remove the FT_Fixed scale, and the x1000 scale).
+   *
+   *    IMPORTANT: Only key/value pairs read by the FreeType interpreter can
+   *    be retrieved.  So, for example, PostScript procedures such as NP,
+   *    ND, and RD are not available.  Arbitrary keys are, obviously, not be
+   *    available either.
+   *
+   *    If the font's format is not PostScript-based, this function returns
+   *    the `FT_Err_Invalid_Argument' error code.
+   *
+   */
+  FT_EXPORT( FT_Long )
+  FT_Get_PS_Font_Value( FT_Face       face,
+                        PS_Dict_Keys  key,
+                        FT_UInt       idx,
+                        void         *value,
+                        FT_Long       value_len );
+
+  /* */
+
+FT_END_HEADER
+
+#endif /* T1TABLES_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ttnameid.h b/engine/inc/freetype/ttnameid.h
new file mode 100644
index 00000000..494d6771
--- /dev/null
+++ b/engine/inc/freetype/ttnameid.h
@@ -0,0 +1,1236 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ttnameid.h                                                             */
+/*                                                                         */
+/*    TrueType name ID definitions (specification only).                   */
+/*                                                                         */
+/*  Copyright 1996-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef TTNAMEID_H_
+#define TTNAMEID_H_
+
+
+#include <ft2build.h>
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    truetype_tables                                                    */
+  /*                                                                       */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Possible values for the `platform' identifier code in the name        */
+  /* records of an SFNT `name' table.                                      */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /***********************************************************************
+   *
+   * @enum:
+   *   TT_PLATFORM_XXX
+   *
+   * @description:
+   *   A list of valid values for the `platform_id' identifier code in
+   *   @FT_CharMapRec and @FT_SfntName structures.
+   *
+   * @values:
+   *   TT_PLATFORM_APPLE_UNICODE ::
+   *     Used by Apple to indicate a Unicode character map and/or name entry.
+   *     See @TT_APPLE_ID_XXX for corresponding `encoding_id' values.  Note
+   *     that name entries in this format are coded as big-endian UCS-2
+   *     character codes _only_.
+   *
+   *   TT_PLATFORM_MACINTOSH ::
+   *     Used by Apple to indicate a MacOS-specific charmap and/or name entry.
+   *     See @TT_MAC_ID_XXX for corresponding `encoding_id' values.  Note that
+   *     most TrueType fonts contain an Apple roman charmap to be usable on
+   *     MacOS systems (even if they contain a Microsoft charmap as well).
+   *
+   *   TT_PLATFORM_ISO ::
+   *     This value was used to specify ISO/IEC 10646 charmaps.  It is however
+   *     now deprecated.  See @TT_ISO_ID_XXX for a list of corresponding
+   *     `encoding_id' values.
+   *
+   *   TT_PLATFORM_MICROSOFT ::
+   *     Used by Microsoft to indicate Windows-specific charmaps.  See
+   *     @TT_MS_ID_XXX for a list of corresponding `encoding_id' values.
+   *     Note that most fonts contain a Unicode charmap using
+   *     (TT_PLATFORM_MICROSOFT, @TT_MS_ID_UNICODE_CS).
+   *
+   *   TT_PLATFORM_CUSTOM ::
+   *     Used to indicate application-specific charmaps.
+   *
+   *   TT_PLATFORM_ADOBE ::
+   *     This value isn't part of any font format specification, but is used
+   *     by FreeType to report Adobe-specific charmaps in an @FT_CharMapRec
+   *     structure.  See @TT_ADOBE_ID_XXX.
+   */
+
+#define TT_PLATFORM_APPLE_UNICODE  0
+#define TT_PLATFORM_MACINTOSH      1
+#define TT_PLATFORM_ISO            2 /* deprecated */
+#define TT_PLATFORM_MICROSOFT      3
+#define TT_PLATFORM_CUSTOM         4
+#define TT_PLATFORM_ADOBE          7 /* artificial */
+
+
+  /***********************************************************************
+   *
+   * @enum:
+   *   TT_APPLE_ID_XXX
+   *
+   * @description:
+   *   A list of valid values for the `encoding_id' for
+   *   @TT_PLATFORM_APPLE_UNICODE charmaps and name entries.
+   *
+   * @values:
+   *   TT_APPLE_ID_DEFAULT ::
+   *     Unicode version 1.0.
+   *
+   *   TT_APPLE_ID_UNICODE_1_1 ::
+   *     Unicode 1.1; specifies Hangul characters starting at U+34xx.
+   *
+   *   TT_APPLE_ID_ISO_10646 ::
+   *     Deprecated (identical to preceding).
+   *
+   *   TT_APPLE_ID_UNICODE_2_0 ::
+   *     Unicode 2.0 and beyond (UTF-16 BMP only).
+   *
+   *   TT_APPLE_ID_UNICODE_32 ::
+   *     Unicode 3.1 and beyond, using UTF-32.
+   *
+   *   TT_APPLE_ID_VARIANT_SELECTOR ::
+   *     From Adobe, not Apple.  Not a normal cmap.  Specifies variations
+   *     on a real cmap.
+   *
+   *   TT_APPLE_ID_FULL_UNICODE ::
+   *     Used for fallback fonts that provide complete Unicode coverage with
+   *     a type~13 cmap.
+   */
+
+#define TT_APPLE_ID_DEFAULT           0 /* Unicode 1.0                   */
+#define TT_APPLE_ID_UNICODE_1_1       1 /* specify Hangul at U+34xx      */
+#define TT_APPLE_ID_ISO_10646         2 /* deprecated                    */
+#define TT_APPLE_ID_UNICODE_2_0       3 /* or later                      */
+#define TT_APPLE_ID_UNICODE_32        4 /* 2.0 or later, full repertoire */
+#define TT_APPLE_ID_VARIANT_SELECTOR  5 /* variation selector data       */
+#define TT_APPLE_ID_FULL_UNICODE      6 /* used with type 13 cmaps       */
+
+
+  /***********************************************************************
+   *
+   * @enum:
+   *   TT_MAC_ID_XXX
+   *
+   * @description:
+   *   A list of valid values for the `encoding_id' for
+   *   @TT_PLATFORM_MACINTOSH charmaps and name entries.
+   */
+
+#define TT_MAC_ID_ROMAN                 0
+#define TT_MAC_ID_JAPANESE              1
+#define TT_MAC_ID_TRADITIONAL_CHINESE   2
+#define TT_MAC_ID_KOREAN                3
+#define TT_MAC_ID_ARABIC                4
+#define TT_MAC_ID_HEBREW                5
+#define TT_MAC_ID_GREEK                 6
+#define TT_MAC_ID_RUSSIAN               7
+#define TT_MAC_ID_RSYMBOL               8
+#define TT_MAC_ID_DEVANAGARI            9
+#define TT_MAC_ID_GURMUKHI             10
+#define TT_MAC_ID_GUJARATI             11
+#define TT_MAC_ID_ORIYA                12
+#define TT_MAC_ID_BENGALI              13
+#define TT_MAC_ID_TAMIL                14
+#define TT_MAC_ID_TELUGU               15
+#define TT_MAC_ID_KANNADA              16
+#define TT_MAC_ID_MALAYALAM            17
+#define TT_MAC_ID_SINHALESE            18
+#define TT_MAC_ID_BURMESE              19
+#define TT_MAC_ID_KHMER                20
+#define TT_MAC_ID_THAI                 21
+#define TT_MAC_ID_LAOTIAN              22
+#define TT_MAC_ID_GEORGIAN             23
+#define TT_MAC_ID_ARMENIAN             24
+#define TT_MAC_ID_MALDIVIAN            25
+#define TT_MAC_ID_SIMPLIFIED_CHINESE   25
+#define TT_MAC_ID_TIBETAN              26
+#define TT_MAC_ID_MONGOLIAN            27
+#define TT_MAC_ID_GEEZ                 28
+#define TT_MAC_ID_SLAVIC               29
+#define TT_MAC_ID_VIETNAMESE           30
+#define TT_MAC_ID_SINDHI               31
+#define TT_MAC_ID_UNINTERP             32
+
+
+  /***********************************************************************
+   *
+   * @enum:
+   *   TT_ISO_ID_XXX
+   *
+   * @description:
+   *   A list of valid values for the `encoding_id' for
+   *   @TT_PLATFORM_ISO charmaps and name entries.
+   *
+   *   Their use is now deprecated.
+   *
+   * @values:
+   *   TT_ISO_ID_7BIT_ASCII ::
+   *     ASCII.
+   *   TT_ISO_ID_10646 ::
+   *     ISO/10646.
+   *   TT_ISO_ID_8859_1 ::
+   *     Also known as Latin-1.
+   */
+
+#define TT_ISO_ID_7BIT_ASCII  0
+#define TT_ISO_ID_10646       1
+#define TT_ISO_ID_8859_1      2
+
+
+  /***********************************************************************
+   *
+   * @enum:
+   *   TT_MS_ID_XXX
+   *
+   * @description:
+   *   A list of valid values for the `encoding_id' for
+   *   @TT_PLATFORM_MICROSOFT charmaps and name entries.
+   *
+   * @values:
+   *   TT_MS_ID_SYMBOL_CS ::
+   *     Microsoft symbol encoding.  See @FT_ENCODING_MS_SYMBOL.
+   *
+   *   TT_MS_ID_UNICODE_CS ::
+   *     Microsoft WGL4 charmap, matching Unicode.  See
+   *     @FT_ENCODING_UNICODE.
+   *
+   *   TT_MS_ID_SJIS ::
+   *     Shift JIS Japanese encoding.  See @FT_ENCODING_SJIS.
+   *
+   *   TT_MS_ID_PRC ::
+   *     Chinese encodings as used in the People's Republic of China (PRC).
+   *     This means the encodings GB~2312 and its supersets GBK and
+   *     GB~18030.  See @FT_ENCODING_PRC.
+   *
+   *   TT_MS_ID_BIG_5 ::
+   *     Traditional Chinese as used in Taiwan and Hong Kong.  See
+   *     @FT_ENCODING_BIG5.
+   *
+   *   TT_MS_ID_WANSUNG ::
+   *     Korean Extended Wansung encoding.  See @FT_ENCODING_WANSUNG.
+   *
+   *   TT_MS_ID_JOHAB ::
+   *     Korean Johab encoding.  See @FT_ENCODING_JOHAB.
+   *
+   *   TT_MS_ID_UCS_4 ::
+   *     UCS-4 or UTF-32 charmaps.  This has been added to the OpenType
+   *     specification version 1.4 (mid-2001).
+   */
+
+#define TT_MS_ID_SYMBOL_CS    0
+#define TT_MS_ID_UNICODE_CS   1
+#define TT_MS_ID_SJIS         2
+#define TT_MS_ID_PRC          3
+#define TT_MS_ID_BIG_5        4
+#define TT_MS_ID_WANSUNG      5
+#define TT_MS_ID_JOHAB        6
+#define TT_MS_ID_UCS_4       10
+
+  /* this value is deprecated */
+#define TT_MS_ID_GB2312  TT_MS_ID_PRC
+
+
+  /***********************************************************************
+   *
+   * @enum:
+   *   TT_ADOBE_ID_XXX
+   *
+   * @description:
+   *   A list of valid values for the `encoding_id' for
+   *   @TT_PLATFORM_ADOBE charmaps.  This is a FreeType-specific extension!
+   *
+   * @values:
+   *   TT_ADOBE_ID_STANDARD ::
+   *     Adobe standard encoding.
+   *   TT_ADOBE_ID_EXPERT ::
+   *     Adobe expert encoding.
+   *   TT_ADOBE_ID_CUSTOM ::
+   *     Adobe custom encoding.
+   *   TT_ADOBE_ID_LATIN_1 ::
+   *     Adobe Latin~1 encoding.
+   */
+
+#define TT_ADOBE_ID_STANDARD  0
+#define TT_ADOBE_ID_EXPERT    1
+#define TT_ADOBE_ID_CUSTOM    2
+#define TT_ADOBE_ID_LATIN_1   3
+
+
+  /***********************************************************************
+   *
+   * @enum:
+   *   TT_MAC_LANGID_XXX
+   *
+   * @description:
+   *   Possible values of the language identifier field in the name records
+   *   of the SFNT `name' table if the `platform' identifier code is
+   *   @TT_PLATFORM_MACINTOSH.  These values are also used as return values
+   *   for function @FT_Get_CMap_Language_ID.
+   *
+   *   The canonical source for Apple's IDs is
+   *
+   *     https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6name.html
+   */
+
+#define TT_MAC_LANGID_ENGLISH                       0
+#define TT_MAC_LANGID_FRENCH                        1
+#define TT_MAC_LANGID_GERMAN                        2
+#define TT_MAC_LANGID_ITALIAN                       3
+#define TT_MAC_LANGID_DUTCH                         4
+#define TT_MAC_LANGID_SWEDISH                       5
+#define TT_MAC_LANGID_SPANISH                       6
+#define TT_MAC_LANGID_DANISH                        7
+#define TT_MAC_LANGID_PORTUGUESE                    8
+#define TT_MAC_LANGID_NORWEGIAN                     9
+#define TT_MAC_LANGID_HEBREW                       10
+#define TT_MAC_LANGID_JAPANESE                     11
+#define TT_MAC_LANGID_ARABIC                       12
+#define TT_MAC_LANGID_FINNISH                      13
+#define TT_MAC_LANGID_GREEK                        14
+#define TT_MAC_LANGID_ICELANDIC                    15
+#define TT_MAC_LANGID_MALTESE                      16
+#define TT_MAC_LANGID_TURKISH                      17
+#define TT_MAC_LANGID_CROATIAN                     18
+#define TT_MAC_LANGID_CHINESE_TRADITIONAL          19
+#define TT_MAC_LANGID_URDU                         20
+#define TT_MAC_LANGID_HINDI                        21
+#define TT_MAC_LANGID_THAI                         22
+#define TT_MAC_LANGID_KOREAN                       23
+#define TT_MAC_LANGID_LITHUANIAN                   24
+#define TT_MAC_LANGID_POLISH                       25
+#define TT_MAC_LANGID_HUNGARIAN                    26
+#define TT_MAC_LANGID_ESTONIAN                     27
+#define TT_MAC_LANGID_LETTISH                      28
+#define TT_MAC_LANGID_SAAMISK                      29
+#define TT_MAC_LANGID_FAEROESE                     30
+#define TT_MAC_LANGID_FARSI                        31
+#define TT_MAC_LANGID_RUSSIAN                      32
+#define TT_MAC_LANGID_CHINESE_SIMPLIFIED           33
+#define TT_MAC_LANGID_FLEMISH                      34
+#define TT_MAC_LANGID_IRISH                        35
+#define TT_MAC_LANGID_ALBANIAN                     36
+#define TT_MAC_LANGID_ROMANIAN                     37
+#define TT_MAC_LANGID_CZECH                        38
+#define TT_MAC_LANGID_SLOVAK                       39
+#define TT_MAC_LANGID_SLOVENIAN                    40
+#define TT_MAC_LANGID_YIDDISH                      41
+#define TT_MAC_LANGID_SERBIAN                      42
+#define TT_MAC_LANGID_MACEDONIAN                   43
+#define TT_MAC_LANGID_BULGARIAN                    44
+#define TT_MAC_LANGID_UKRAINIAN                    45
+#define TT_MAC_LANGID_BYELORUSSIAN                 46
+#define TT_MAC_LANGID_UZBEK                        47
+#define TT_MAC_LANGID_KAZAKH                       48
+#define TT_MAC_LANGID_AZERBAIJANI                  49
+#define TT_MAC_LANGID_AZERBAIJANI_CYRILLIC_SCRIPT  49
+#define TT_MAC_LANGID_AZERBAIJANI_ARABIC_SCRIPT    50
+#define TT_MAC_LANGID_ARMENIAN                     51
+#define TT_MAC_LANGID_GEORGIAN                     52
+#define TT_MAC_LANGID_MOLDAVIAN                    53
+#define TT_MAC_LANGID_KIRGHIZ                      54
+#define TT_MAC_LANGID_TAJIKI                       55
+#define TT_MAC_LANGID_TURKMEN                      56
+#define TT_MAC_LANGID_MONGOLIAN                    57
+#define TT_MAC_LANGID_MONGOLIAN_MONGOLIAN_SCRIPT   57
+#define TT_MAC_LANGID_MONGOLIAN_CYRILLIC_SCRIPT    58
+#define TT_MAC_LANGID_PASHTO                       59
+#define TT_MAC_LANGID_KURDISH                      60
+#define TT_MAC_LANGID_KASHMIRI                     61
+#define TT_MAC_LANGID_SINDHI                       62
+#define TT_MAC_LANGID_TIBETAN                      63
+#define TT_MAC_LANGID_NEPALI                       64
+#define TT_MAC_LANGID_SANSKRIT                     65
+#define TT_MAC_LANGID_MARATHI                      66
+#define TT_MAC_LANGID_BENGALI                      67
+#define TT_MAC_LANGID_ASSAMESE                     68
+#define TT_MAC_LANGID_GUJARATI                     69
+#define TT_MAC_LANGID_PUNJABI                      70
+#define TT_MAC_LANGID_ORIYA                        71
+#define TT_MAC_LANGID_MALAYALAM                    72
+#define TT_MAC_LANGID_KANNADA                      73
+#define TT_MAC_LANGID_TAMIL                        74
+#define TT_MAC_LANGID_TELUGU                       75
+#define TT_MAC_LANGID_SINHALESE                    76
+#define TT_MAC_LANGID_BURMESE                      77
+#define TT_MAC_LANGID_KHMER                        78
+#define TT_MAC_LANGID_LAO                          79
+#define TT_MAC_LANGID_VIETNAMESE                   80
+#define TT_MAC_LANGID_INDONESIAN                   81
+#define TT_MAC_LANGID_TAGALOG                      82
+#define TT_MAC_LANGID_MALAY_ROMAN_SCRIPT           83
+#define TT_MAC_LANGID_MALAY_ARABIC_SCRIPT          84
+#define TT_MAC_LANGID_AMHARIC                      85
+#define TT_MAC_LANGID_TIGRINYA                     86
+#define TT_MAC_LANGID_GALLA                        87
+#define TT_MAC_LANGID_SOMALI                       88
+#define TT_MAC_LANGID_SWAHILI                      89
+#define TT_MAC_LANGID_RUANDA                       90
+#define TT_MAC_LANGID_RUNDI                        91
+#define TT_MAC_LANGID_CHEWA                        92
+#define TT_MAC_LANGID_MALAGASY                     93
+#define TT_MAC_LANGID_ESPERANTO                    94
+#define TT_MAC_LANGID_WELSH                       128
+#define TT_MAC_LANGID_BASQUE                      129
+#define TT_MAC_LANGID_CATALAN                     130
+#define TT_MAC_LANGID_LATIN                       131
+#define TT_MAC_LANGID_QUECHUA                     132
+#define TT_MAC_LANGID_GUARANI                     133
+#define TT_MAC_LANGID_AYMARA                      134
+#define TT_MAC_LANGID_TATAR                       135
+#define TT_MAC_LANGID_UIGHUR                      136
+#define TT_MAC_LANGID_DZONGKHA                    137
+#define TT_MAC_LANGID_JAVANESE                    138
+#define TT_MAC_LANGID_SUNDANESE                   139
+
+  /* The following codes are new as of 2000-03-10 */
+#define TT_MAC_LANGID_GALICIAN                    140
+#define TT_MAC_LANGID_AFRIKAANS                   141
+#define TT_MAC_LANGID_BRETON                      142
+#define TT_MAC_LANGID_INUKTITUT                   143
+#define TT_MAC_LANGID_SCOTTISH_GAELIC             144
+#define TT_MAC_LANGID_MANX_GAELIC                 145
+#define TT_MAC_LANGID_IRISH_GAELIC                146
+#define TT_MAC_LANGID_TONGAN                      147
+#define TT_MAC_LANGID_GREEK_POLYTONIC             148
+#define TT_MAC_LANGID_GREELANDIC                  149
+#define TT_MAC_LANGID_AZERBAIJANI_ROMAN_SCRIPT    150
+
+
+  /***********************************************************************
+   *
+   * @enum:
+   *   TT_MS_LANGID_XXX
+   *
+   * @description:
+   *   Possible values of the language identifier field in the name records
+   *   of the SFNT `name' table if the `platform' identifier code is
+   *   @TT_PLATFORM_MICROSOFT.  These values are also used as return values
+   *   for function @FT_Get_CMap_Language_ID.
+   *
+   *   The canonical source for Microsoft's IDs is
+   *
+   *     http://www.microsoft.com/globaldev/reference/lcid-all.mspx ,
+   *
+   *   however, we only provide macros for language identifiers present in
+   *   the OpenType specification: Microsoft has abandoned the concept of
+   *   LCIDs (language code identifiers), and format~1 of the `name' table
+   *   provides a better mechanism for languages not covered here.
+   *
+   *   More legacy values not listed in the reference can be found in the
+   *   @FT_TRUETYPE_IDS_H header file.
+   */
+
+#define TT_MS_LANGID_ARABIC_SAUDI_ARABIA               0x0401
+#define TT_MS_LANGID_ARABIC_IRAQ                       0x0801
+#define TT_MS_LANGID_ARABIC_EGYPT                      0x0C01
+#define TT_MS_LANGID_ARABIC_LIBYA                      0x1001
+#define TT_MS_LANGID_ARABIC_ALGERIA                    0x1401
+#define TT_MS_LANGID_ARABIC_MOROCCO                    0x1801
+#define TT_MS_LANGID_ARABIC_TUNISIA                    0x1C01
+#define TT_MS_LANGID_ARABIC_OMAN                       0x2001
+#define TT_MS_LANGID_ARABIC_YEMEN                      0x2401
+#define TT_MS_LANGID_ARABIC_SYRIA                      0x2801
+#define TT_MS_LANGID_ARABIC_JORDAN                     0x2C01
+#define TT_MS_LANGID_ARABIC_LEBANON                    0x3001
+#define TT_MS_LANGID_ARABIC_KUWAIT                     0x3401
+#define TT_MS_LANGID_ARABIC_UAE                        0x3801
+#define TT_MS_LANGID_ARABIC_BAHRAIN                    0x3C01
+#define TT_MS_LANGID_ARABIC_QATAR                      0x4001
+#define TT_MS_LANGID_BULGARIAN_BULGARIA                0x0402
+#define TT_MS_LANGID_CATALAN_CATALAN                   0x0403
+#define TT_MS_LANGID_CHINESE_TAIWAN                    0x0404
+#define TT_MS_LANGID_CHINESE_PRC                       0x0804
+#define TT_MS_LANGID_CHINESE_HONG_KONG                 0x0C04
+#define TT_MS_LANGID_CHINESE_SINGAPORE                 0x1004
+#define TT_MS_LANGID_CHINESE_MACAO                     0x1404
+#define TT_MS_LANGID_CZECH_CZECH_REPUBLIC              0x0405
+#define TT_MS_LANGID_DANISH_DENMARK                    0x0406
+#define TT_MS_LANGID_GERMAN_GERMANY                    0x0407
+#define TT_MS_LANGID_GERMAN_SWITZERLAND                0x0807
+#define TT_MS_LANGID_GERMAN_AUSTRIA                    0x0C07
+#define TT_MS_LANGID_GERMAN_LUXEMBOURG                 0x1007
+#define TT_MS_LANGID_GERMAN_LIECHTENSTEIN              0x1407
+#define TT_MS_LANGID_GREEK_GREECE                      0x0408
+#define TT_MS_LANGID_ENGLISH_UNITED_STATES             0x0409
+#define TT_MS_LANGID_ENGLISH_UNITED_KINGDOM            0x0809
+#define TT_MS_LANGID_ENGLISH_AUSTRALIA                 0x0C09
+#define TT_MS_LANGID_ENGLISH_CANADA                    0x1009
+#define TT_MS_LANGID_ENGLISH_NEW_ZEALAND               0x1409
+#define TT_MS_LANGID_ENGLISH_IRELAND                   0x1809
+#define TT_MS_LANGID_ENGLISH_SOUTH_AFRICA              0x1C09
+#define TT_MS_LANGID_ENGLISH_JAMAICA                   0x2009
+#define TT_MS_LANGID_ENGLISH_CARIBBEAN                 0x2409
+#define TT_MS_LANGID_ENGLISH_BELIZE                    0x2809
+#define TT_MS_LANGID_ENGLISH_TRINIDAD                  0x2C09
+#define TT_MS_LANGID_ENGLISH_ZIMBABWE                  0x3009
+#define TT_MS_LANGID_ENGLISH_PHILIPPINES               0x3409
+#define TT_MS_LANGID_ENGLISH_INDIA                     0x4009
+#define TT_MS_LANGID_ENGLISH_MALAYSIA                  0x4409
+#define TT_MS_LANGID_ENGLISH_SINGAPORE                 0x4809
+#define TT_MS_LANGID_SPANISH_SPAIN_TRADITIONAL_SORT    0x040A
+#define TT_MS_LANGID_SPANISH_MEXICO                    0x080A
+#define TT_MS_LANGID_SPANISH_SPAIN_MODERN_SORT         0x0C0A
+#define TT_MS_LANGID_SPANISH_GUATEMALA                 0x100A
+#define TT_MS_LANGID_SPANISH_COSTA_RICA                0x140A
+#define TT_MS_LANGID_SPANISH_PANAMA                    0x180A
+#define TT_MS_LANGID_SPANISH_DOMINICAN_REPUBLIC        0x1C0A
+#define TT_MS_LANGID_SPANISH_VENEZUELA                 0x200A
+#define TT_MS_LANGID_SPANISH_COLOMBIA                  0x240A
+#define TT_MS_LANGID_SPANISH_PERU                      0x280A
+#define TT_MS_LANGID_SPANISH_ARGENTINA                 0x2C0A
+#define TT_MS_LANGID_SPANISH_ECUADOR                   0x300A
+#define TT_MS_LANGID_SPANISH_CHILE                     0x340A
+#define TT_MS_LANGID_SPANISH_URUGUAY                   0x380A
+#define TT_MS_LANGID_SPANISH_PARAGUAY                  0x3C0A
+#define TT_MS_LANGID_SPANISH_BOLIVIA                   0x400A
+#define TT_MS_LANGID_SPANISH_EL_SALVADOR               0x440A
+#define TT_MS_LANGID_SPANISH_HONDURAS                  0x480A
+#define TT_MS_LANGID_SPANISH_NICARAGUA                 0x4C0A
+#define TT_MS_LANGID_SPANISH_PUERTO_RICO               0x500A
+#define TT_MS_LANGID_SPANISH_UNITED_STATES             0x540A
+#define TT_MS_LANGID_FINNISH_FINLAND                   0x040B
+#define TT_MS_LANGID_FRENCH_FRANCE                     0x040C
+#define TT_MS_LANGID_FRENCH_BELGIUM                    0x080C
+#define TT_MS_LANGID_FRENCH_CANADA                     0x0C0C
+#define TT_MS_LANGID_FRENCH_SWITZERLAND                0x100C
+#define TT_MS_LANGID_FRENCH_LUXEMBOURG                 0x140C
+#define TT_MS_LANGID_FRENCH_MONACO                     0x180C
+#define TT_MS_LANGID_HEBREW_ISRAEL                     0x040D
+#define TT_MS_LANGID_HUNGARIAN_HUNGARY                 0x040E
+#define TT_MS_LANGID_ICELANDIC_ICELAND                 0x040F
+#define TT_MS_LANGID_ITALIAN_ITALY                     0x0410
+#define TT_MS_LANGID_ITALIAN_SWITZERLAND               0x0810
+#define TT_MS_LANGID_JAPANESE_JAPAN                    0x0411
+#define TT_MS_LANGID_KOREAN_KOREA                      0x0412
+#define TT_MS_LANGID_DUTCH_NETHERLANDS                 0x0413
+#define TT_MS_LANGID_DUTCH_BELGIUM                     0x0813
+#define TT_MS_LANGID_NORWEGIAN_NORWAY_BOKMAL           0x0414
+#define TT_MS_LANGID_NORWEGIAN_NORWAY_NYNORSK          0x0814
+#define TT_MS_LANGID_POLISH_POLAND                     0x0415
+#define TT_MS_LANGID_PORTUGUESE_BRAZIL                 0x0416
+#define TT_MS_LANGID_PORTUGUESE_PORTUGAL               0x0816
+#define TT_MS_LANGID_ROMANSH_SWITZERLAND               0x0417
+#define TT_MS_LANGID_ROMANIAN_ROMANIA                  0x0418
+#define TT_MS_LANGID_RUSSIAN_RUSSIA                    0x0419
+#define TT_MS_LANGID_CROATIAN_CROATIA                  0x041A
+#define TT_MS_LANGID_SERBIAN_SERBIA_LATIN              0x081A
+#define TT_MS_LANGID_SERBIAN_SERBIA_CYRILLIC           0x0C1A
+#define TT_MS_LANGID_CROATIAN_BOSNIA_HERZEGOVINA       0x101A
+#define TT_MS_LANGID_BOSNIAN_BOSNIA_HERZEGOVINA        0x141A
+#define TT_MS_LANGID_SERBIAN_BOSNIA_HERZ_LATIN         0x181A
+#define TT_MS_LANGID_SERBIAN_BOSNIA_HERZ_CYRILLIC      0x1C1A
+#define TT_MS_LANGID_BOSNIAN_BOSNIA_HERZ_CYRILLIC      0x201A
+#define TT_MS_LANGID_SLOVAK_SLOVAKIA                   0x041B
+#define TT_MS_LANGID_ALBANIAN_ALBANIA                  0x041C
+#define TT_MS_LANGID_SWEDISH_SWEDEN                    0x041D
+#define TT_MS_LANGID_SWEDISH_FINLAND                   0x081D
+#define TT_MS_LANGID_THAI_THAILAND                     0x041E
+#define TT_MS_LANGID_TURKISH_TURKEY                    0x041F
+#define TT_MS_LANGID_URDU_PAKISTAN                     0x0420
+#define TT_MS_LANGID_INDONESIAN_INDONESIA              0x0421
+#define TT_MS_LANGID_UKRAINIAN_UKRAINE                 0x0422
+#define TT_MS_LANGID_BELARUSIAN_BELARUS                0x0423
+#define TT_MS_LANGID_SLOVENIAN_SLOVENIA                0x0424
+#define TT_MS_LANGID_ESTONIAN_ESTONIA                  0x0425
+#define TT_MS_LANGID_LATVIAN_LATVIA                    0x0426
+#define TT_MS_LANGID_LITHUANIAN_LITHUANIA              0x0427
+#define TT_MS_LANGID_TAJIK_TAJIKISTAN                  0x0428
+#define TT_MS_LANGID_VIETNAMESE_VIET_NAM               0x042A
+#define TT_MS_LANGID_ARMENIAN_ARMENIA                  0x042B
+#define TT_MS_LANGID_AZERI_AZERBAIJAN_LATIN            0x042C
+#define TT_MS_LANGID_AZERI_AZERBAIJAN_CYRILLIC         0x082C
+#define TT_MS_LANGID_BASQUE_BASQUE                     0x042D
+#define TT_MS_LANGID_UPPER_SORBIAN_GERMANY             0x042E
+#define TT_MS_LANGID_LOWER_SORBIAN_GERMANY             0x082E
+#define TT_MS_LANGID_MACEDONIAN_MACEDONIA              0x042F
+#define TT_MS_LANGID_SETSWANA_SOUTH_AFRICA             0x0432
+#define TT_MS_LANGID_ISIXHOSA_SOUTH_AFRICA             0x0434
+#define TT_MS_LANGID_ISIZULU_SOUTH_AFRICA              0x0435
+#define TT_MS_LANGID_AFRIKAANS_SOUTH_AFRICA            0x0436
+#define TT_MS_LANGID_GEORGIAN_GEORGIA                  0x0437
+#define TT_MS_LANGID_FAEROESE_FAEROE_ISLANDS           0x0438
+#define TT_MS_LANGID_HINDI_INDIA                       0x0439
+#define TT_MS_LANGID_MALTESE_MALTA                     0x043A
+#define TT_MS_LANGID_SAMI_NORTHERN_NORWAY              0x043B
+#define TT_MS_LANGID_SAMI_NORTHERN_SWEDEN              0x083B
+#define TT_MS_LANGID_SAMI_NORTHERN_FINLAND             0x0C3B
+#define TT_MS_LANGID_SAMI_LULE_NORWAY                  0x103B
+#define TT_MS_LANGID_SAMI_LULE_SWEDEN                  0x143B
+#define TT_MS_LANGID_SAMI_SOUTHERN_NORWAY              0x183B
+#define TT_MS_LANGID_SAMI_SOUTHERN_SWEDEN              0x1C3B
+#define TT_MS_LANGID_SAMI_SKOLT_FINLAND                0x203B
+#define TT_MS_LANGID_SAMI_INARI_FINLAND                0x243B
+#define TT_MS_LANGID_IRISH_IRELAND                     0x083C
+#define TT_MS_LANGID_MALAY_MALAYSIA                    0x043E
+#define TT_MS_LANGID_MALAY_BRUNEI_DARUSSALAM           0x083E
+#define TT_MS_LANGID_KAZAKH_KAZAKHSTAN                 0x043F
+#define TT_MS_LANGID_KYRGYZ_KYRGYZSTAN /* Cyrillic*/   0x0440
+#define TT_MS_LANGID_KISWAHILI_KENYA                   0x0441
+#define TT_MS_LANGID_TURKMEN_TURKMENISTAN              0x0442
+#define TT_MS_LANGID_UZBEK_UZBEKISTAN_LATIN            0x0443
+#define TT_MS_LANGID_UZBEK_UZBEKISTAN_CYRILLIC         0x0843
+#define TT_MS_LANGID_TATAR_RUSSIA                      0x0444
+#define TT_MS_LANGID_BENGALI_INDIA                     0x0445
+#define TT_MS_LANGID_BENGALI_BANGLADESH                0x0845
+#define TT_MS_LANGID_PUNJABI_INDIA                     0x0446
+#define TT_MS_LANGID_GUJARATI_INDIA                    0x0447
+#define TT_MS_LANGID_ODIA_INDIA                        0x0448
+#define TT_MS_LANGID_TAMIL_INDIA                       0x0449
+#define TT_MS_LANGID_TELUGU_INDIA                      0x044A
+#define TT_MS_LANGID_KANNADA_INDIA                     0x044B
+#define TT_MS_LANGID_MALAYALAM_INDIA                   0x044C
+#define TT_MS_LANGID_ASSAMESE_INDIA                    0x044D
+#define TT_MS_LANGID_MARATHI_INDIA                     0x044E
+#define TT_MS_LANGID_SANSKRIT_INDIA                    0x044F
+#define TT_MS_LANGID_MONGOLIAN_MONGOLIA /* Cyrillic */ 0x0450
+#define TT_MS_LANGID_MONGOLIAN_PRC                     0x0850
+#define TT_MS_LANGID_TIBETAN_PRC                       0x0451
+#define TT_MS_LANGID_WELSH_UNITED_KINGDOM              0x0452
+#define TT_MS_LANGID_KHMER_CAMBODIA                    0x0453
+#define TT_MS_LANGID_LAO_LAOS                          0x0454
+#define TT_MS_LANGID_GALICIAN_GALICIAN                 0x0456
+#define TT_MS_LANGID_KONKANI_INDIA                     0x0457
+#define TT_MS_LANGID_SYRIAC_SYRIA                      0x045A
+#define TT_MS_LANGID_SINHALA_SRI_LANKA                 0x045B
+#define TT_MS_LANGID_INUKTITUT_CANADA                  0x045D
+#define TT_MS_LANGID_INUKTITUT_CANADA_LATIN            0x085D
+#define TT_MS_LANGID_AMHARIC_ETHIOPIA                  0x045E
+#define TT_MS_LANGID_TAMAZIGHT_ALGERIA                 0x085F
+#define TT_MS_LANGID_NEPALI_NEPAL                      0x0461
+#define TT_MS_LANGID_FRISIAN_NETHERLANDS               0x0462
+#define TT_MS_LANGID_PASHTO_AFGHANISTAN                0x0463
+#define TT_MS_LANGID_FILIPINO_PHILIPPINES              0x0464
+#define TT_MS_LANGID_DHIVEHI_MALDIVES                  0x0465
+#define TT_MS_LANGID_HAUSA_NIGERIA                     0x0468
+#define TT_MS_LANGID_YORUBA_NIGERIA                    0x046A
+#define TT_MS_LANGID_QUECHUA_BOLIVIA                   0x046B
+#define TT_MS_LANGID_QUECHUA_ECUADOR                   0x086B
+#define TT_MS_LANGID_QUECHUA_PERU                      0x0C6B
+#define TT_MS_LANGID_SESOTHO_SA_LEBOA_SOUTH_AFRICA     0x046C
+#define TT_MS_LANGID_BASHKIR_RUSSIA                    0x046D
+#define TT_MS_LANGID_LUXEMBOURGISH_LUXEMBOURG          0x046E
+#define TT_MS_LANGID_GREENLANDIC_GREENLAND             0x046F
+#define TT_MS_LANGID_IGBO_NIGERIA                      0x0470
+#define TT_MS_LANGID_YI_PRC                            0x0478
+#define TT_MS_LANGID_MAPUDUNGUN_CHILE                  0x047A
+#define TT_MS_LANGID_MOHAWK_MOHAWK                     0x047C
+#define TT_MS_LANGID_BRETON_FRANCE                     0x047E
+#define TT_MS_LANGID_UIGHUR_PRC                        0x0480
+#define TT_MS_LANGID_MAORI_NEW_ZEALAND                 0x0481
+#define TT_MS_LANGID_OCCITAN_FRANCE                    0x0482
+#define TT_MS_LANGID_CORSICAN_FRANCE                   0x0483
+#define TT_MS_LANGID_ALSATIAN_FRANCE                   0x0484
+#define TT_MS_LANGID_YAKUT_RUSSIA                      0x0485
+#define TT_MS_LANGID_KICHE_GUATEMALA                   0x0486
+#define TT_MS_LANGID_KINYARWANDA_RWANDA                0x0487
+#define TT_MS_LANGID_WOLOF_SENEGAL                     0x0488
+#define TT_MS_LANGID_DARI_AFGHANISTAN                  0x048C
+
+  /* */
+
+
+  /* legacy macro definitions not present in OpenType 1.8.1 */
+#define TT_MS_LANGID_ARABIC_GENERAL                    0x0001
+#define TT_MS_LANGID_CATALAN_SPAIN \
+          TT_MS_LANGID_CATALAN_CATALAN
+#define TT_MS_LANGID_CHINESE_GENERAL                   0x0004
+#define TT_MS_LANGID_CHINESE_MACAU \
+          TT_MS_LANGID_CHINESE_MACAO
+#define TT_MS_LANGID_GERMAN_LIECHTENSTEI \
+          TT_MS_LANGID_GERMAN_LIECHTENSTEIN
+#define TT_MS_LANGID_ENGLISH_GENERAL                   0x0009
+#define TT_MS_LANGID_ENGLISH_INDONESIA                 0x3809
+#define TT_MS_LANGID_ENGLISH_HONG_KONG                 0x3C09
+#define TT_MS_LANGID_SPANISH_SPAIN_INTERNATIONAL_SORT \
+          TT_MS_LANGID_SPANISH_SPAIN_MODERN_SORT
+#define TT_MS_LANGID_SPANISH_LATIN_AMERICA             0xE40AU
+#define TT_MS_LANGID_FRENCH_WEST_INDIES                0x1C0C
+#define TT_MS_LANGID_FRENCH_REUNION                    0x200C
+#define TT_MS_LANGID_FRENCH_CONGO                      0x240C
+  /* which was formerly: */
+#define TT_MS_LANGID_FRENCH_ZAIRE \
+          TT_MS_LANGID_FRENCH_CONGO
+#define TT_MS_LANGID_FRENCH_SENEGAL                    0x280C
+#define TT_MS_LANGID_FRENCH_CAMEROON                   0x2C0C
+#define TT_MS_LANGID_FRENCH_COTE_D_IVOIRE              0x300C
+#define TT_MS_LANGID_FRENCH_MALI                       0x340C
+#define TT_MS_LANGID_FRENCH_MOROCCO                    0x380C
+#define TT_MS_LANGID_FRENCH_HAITI                      0x3C0C
+#define TT_MS_LANGID_FRENCH_NORTH_AFRICA               0xE40CU
+#define TT_MS_LANGID_KOREAN_EXTENDED_WANSUNG_KOREA \
+          TT_MS_LANGID_KOREAN_KOREA
+#define TT_MS_LANGID_KOREAN_JOHAB_KOREA                0x0812
+#define TT_MS_LANGID_RHAETO_ROMANIC_SWITZERLAND \
+          TT_MS_LANGID_ROMANSH_SWITZERLAND
+#define TT_MS_LANGID_MOLDAVIAN_MOLDAVIA                0x0818
+#define TT_MS_LANGID_RUSSIAN_MOLDAVIA                  0x0819
+#define TT_MS_LANGID_URDU_INDIA                        0x0820
+#define TT_MS_LANGID_CLASSIC_LITHUANIAN_LITHUANIA      0x0827
+#define TT_MS_LANGID_SLOVENE_SLOVENIA \
+          TT_MS_LANGID_SLOVENIAN_SLOVENIA
+#define TT_MS_LANGID_FARSI_IRAN                        0x0429
+#define TT_MS_LANGID_BASQUE_SPAIN \
+          TT_MS_LANGID_BASQUE_BASQUE
+#define TT_MS_LANGID_SORBIAN_GERMANY \
+          TT_MS_LANGID_UPPER_SORBIAN_GERMANY
+#define TT_MS_LANGID_SUTU_SOUTH_AFRICA                 0x0430
+#define TT_MS_LANGID_TSONGA_SOUTH_AFRICA               0x0431
+#define TT_MS_LANGID_TSWANA_SOUTH_AFRICA \
+          TT_MS_LANGID_SETSWANA_SOUTH_AFRICA
+#define TT_MS_LANGID_VENDA_SOUTH_AFRICA                0x0433
+#define TT_MS_LANGID_XHOSA_SOUTH_AFRICA \
+          TT_MS_LANGID_ISIXHOSA_SOUTH_AFRICA
+#define TT_MS_LANGID_ZULU_SOUTH_AFRICA \
+          TT_MS_LANGID_ISIZULU_SOUTH_AFRICA
+#define TT_MS_LANGID_SAAMI_LAPONIA                     0x043B
+  /* the next two values are incorrectly inverted */
+#define TT_MS_LANGID_IRISH_GAELIC_IRELAND              0x043C
+#define TT_MS_LANGID_SCOTTISH_GAELIC_UNITED_KINGDOM    0x083C
+#define TT_MS_LANGID_YIDDISH_GERMANY                   0x043D
+#define TT_MS_LANGID_KAZAK_KAZAKSTAN \
+          TT_MS_LANGID_KAZAKH_KAZAKHSTAN
+#define TT_MS_LANGID_KIRGHIZ_KIRGHIZ_REPUBLIC \
+          TT_MS_LANGID_KYRGYZ_KYRGYZSTAN
+#define TT_MS_LANGID_KIRGHIZ_KIRGHIZSTAN \
+          TT_MS_LANGID_KYRGYZ_KYRGYZSTAN
+#define TT_MS_LANGID_SWAHILI_KENYA \
+          TT_MS_LANGID_KISWAHILI_KENYA
+#define TT_MS_LANGID_TATAR_TATARSTAN \
+          TT_MS_LANGID_TATAR_RUSSIA
+#define TT_MS_LANGID_PUNJABI_ARABIC_PAKISTAN           0x0846
+#define TT_MS_LANGID_ORIYA_INDIA \
+          TT_MS_LANGID_ODIA_INDIA
+#define TT_MS_LANGID_MONGOLIAN_MONGOLIA_MONGOLIAN \
+          TT_MS_LANGID_MONGOLIAN_PRC
+#define TT_MS_LANGID_TIBETAN_CHINA \
+          TT_MS_LANGID_TIBETAN_PRC
+#define TT_MS_LANGID_DZONGHKA_BHUTAN                   0x0851
+#define TT_MS_LANGID_TIBETAN_BHUTAN \
+          TT_MS_LANGID_DZONGHKA_BHUTAN
+#define TT_MS_LANGID_WELSH_WALES \
+          TT_MS_LANGID_WELSH_UNITED_KINGDOM
+#define TT_MS_LANGID_BURMESE_MYANMAR                   0x0455
+#define TT_MS_LANGID_GALICIAN_SPAIN \
+          TT_MS_LANGID_GALICIAN_GALICIAN
+#define TT_MS_LANGID_MANIPURI_INDIA  /* Bengali */     0x0458
+#define TT_MS_LANGID_SINDHI_INDIA /* Arabic */         0x0459
+#define TT_MS_LANGID_SINDHI_PAKISTAN                   0x0859
+#define TT_MS_LANGID_SINHALESE_SRI_LANKA \
+          TT_MS_LANGID_SINHALA_SRI_LANKA
+#define TT_MS_LANGID_CHEROKEE_UNITED_STATES            0x045C
+#define TT_MS_LANGID_TAMAZIGHT_MOROCCO /* Arabic */    0x045F
+#define TT_MS_LANGID_TAMAZIGHT_MOROCCO_LATIN \
+          TT_MS_LANGID_TAMAZIGHT_ALGERIA
+#define TT_MS_LANGID_KASHMIRI_PAKISTAN /* Arabic */    0x0460
+#define TT_MS_LANGID_KASHMIRI_SASIA                    0x0860
+#define TT_MS_LANGID_KASHMIRI_INDIA \
+          TT_MS_LANGID_KASHMIRI_SASIA
+#define TT_MS_LANGID_NEPALI_INDIA                      0x0861
+#define TT_MS_LANGID_DIVEHI_MALDIVES \
+          TT_MS_LANGID_DHIVEHI_MALDIVES
+#define TT_MS_LANGID_EDO_NIGERIA                       0x0466
+#define TT_MS_LANGID_FULFULDE_NIGERIA                  0x0467
+#define TT_MS_LANGID_IBIBIO_NIGERIA                    0x0469
+#define TT_MS_LANGID_SEPEDI_SOUTH_AFRICA \
+          TT_MS_LANGID_SESOTHO_SA_LEBOA_SOUTH_AFRICA
+#define TT_MS_LANGID_SOTHO_SOUTHERN_SOUTH_AFRICA \
+          TT_MS_LANGID_SESOTHO_SA_LEBOA_SOUTH_AFRICA
+#define TT_MS_LANGID_KANURI_NIGERIA                    0x0471
+#define TT_MS_LANGID_OROMO_ETHIOPIA                    0x0472
+#define TT_MS_LANGID_TIGRIGNA_ETHIOPIA                 0x0473
+#define TT_MS_LANGID_TIGRIGNA_ERYTHREA                 0x0873
+#define TT_MS_LANGID_TIGRIGNA_ERYTREA \
+          TT_MS_LANGID_TIGRIGNA_ERYTHREA
+#define TT_MS_LANGID_GUARANI_PARAGUAY                  0x0474
+#define TT_MS_LANGID_HAWAIIAN_UNITED_STATES            0x0475
+#define TT_MS_LANGID_LATIN                             0x0476
+#define TT_MS_LANGID_SOMALI_SOMALIA                    0x0477
+#define TT_MS_LANGID_YI_CHINA \
+          TT_MS_LANGID_YI_PRC
+#define TT_MS_LANGID_PAPIAMENTU_NETHERLANDS_ANTILLES   0x0479
+#define TT_MS_LANGID_UIGHUR_CHINA \
+          TT_MS_LANGID_UIGHUR_PRC
+
+
+  /***********************************************************************
+   *
+   * @enum:
+   *   TT_NAME_ID_XXX
+   *
+   * @description:
+   *   Possible values of the `name' identifier field in the name records of
+   *   an SFNT `name' table.  These values are platform independent.
+   */
+
+#define TT_NAME_ID_COPYRIGHT              0
+#define TT_NAME_ID_FONT_FAMILY            1
+#define TT_NAME_ID_FONT_SUBFAMILY         2
+#define TT_NAME_ID_UNIQUE_ID              3
+#define TT_NAME_ID_FULL_NAME              4
+#define TT_NAME_ID_VERSION_STRING         5
+#define TT_NAME_ID_PS_NAME                6
+#define TT_NAME_ID_TRADEMARK              7
+
+  /* the following values are from the OpenType spec */
+#define TT_NAME_ID_MANUFACTURER           8
+#define TT_NAME_ID_DESIGNER               9
+#define TT_NAME_ID_DESCRIPTION            10
+#define TT_NAME_ID_VENDOR_URL             11
+#define TT_NAME_ID_DESIGNER_URL           12
+#define TT_NAME_ID_LICENSE                13
+#define TT_NAME_ID_LICENSE_URL            14
+  /* number 15 is reserved */
+#define TT_NAME_ID_TYPOGRAPHIC_FAMILY     16
+#define TT_NAME_ID_TYPOGRAPHIC_SUBFAMILY  17
+#define TT_NAME_ID_MAC_FULL_NAME          18
+
+  /* The following code is new as of 2000-01-21 */
+#define TT_NAME_ID_SAMPLE_TEXT            19
+
+  /* This is new in OpenType 1.3 */
+#define TT_NAME_ID_CID_FINDFONT_NAME      20
+
+  /* This is new in OpenType 1.5 */
+#define TT_NAME_ID_WWS_FAMILY             21
+#define TT_NAME_ID_WWS_SUBFAMILY          22
+
+  /* This is new in OpenType 1.7 */
+#define TT_NAME_ID_LIGHT_BACKGROUND       23
+#define TT_NAME_ID_DARK_BACKGROUND        24
+
+  /* This is new in OpenType 1.8 */
+#define TT_NAME_ID_VARIATIONS_PREFIX      25
+
+  /* these two values are deprecated */
+#define TT_NAME_ID_PREFERRED_FAMILY     TT_NAME_ID_TYPOGRAPHIC_FAMILY
+#define TT_NAME_ID_PREFERRED_SUBFAMILY  TT_NAME_ID_TYPOGRAPHIC_SUBFAMILY
+
+
+  /***********************************************************************
+   *
+   * @enum:
+   *   TT_UCR_XXX
+   *
+   * @description:
+   *   Possible bit mask values for the `ulUnicodeRangeX' fields in an SFNT
+   *   `OS/2' table.
+   */
+
+  /* ulUnicodeRange1 */
+  /* --------------- */
+
+  /* Bit  0   Basic Latin */
+#define TT_UCR_BASIC_LATIN                     (1L <<  0) /* U+0020-U+007E */
+  /* Bit  1   C1 Controls and Latin-1 Supplement */
+#define TT_UCR_LATIN1_SUPPLEMENT               (1L <<  1) /* U+0080-U+00FF */
+  /* Bit  2   Latin Extended-A */
+#define TT_UCR_LATIN_EXTENDED_A                (1L <<  2) /* U+0100-U+017F */
+  /* Bit  3   Latin Extended-B */
+#define TT_UCR_LATIN_EXTENDED_B                (1L <<  3) /* U+0180-U+024F */
+  /* Bit  4   IPA Extensions                 */
+  /*          Phonetic Extensions            */
+  /*          Phonetic Extensions Supplement */
+#define TT_UCR_IPA_EXTENSIONS                  (1L <<  4) /* U+0250-U+02AF */
+                                                          /* U+1D00-U+1D7F */
+                                                          /* U+1D80-U+1DBF */
+  /* Bit  5   Spacing Modifier Letters */
+  /*          Modifier Tone Letters    */
+#define TT_UCR_SPACING_MODIFIER                (1L <<  5) /* U+02B0-U+02FF */
+                                                          /* U+A700-U+A71F */
+  /* Bit  6   Combining Diacritical Marks            */
+  /*          Combining Diacritical Marks Supplement */
+#define TT_UCR_COMBINING_DIACRITICAL_MARKS     (1L <<  6) /* U+0300-U+036F */
+                                                          /* U+1DC0-U+1DFF */
+  /* Bit  7   Greek and Coptic */
+#define TT_UCR_GREEK                           (1L <<  7) /* U+0370-U+03FF */
+  /* Bit  8   Coptic */
+#define TT_UCR_COPTIC                          (1L <<  8) /* U+2C80-U+2CFF */
+  /* Bit  9   Cyrillic            */
+  /*          Cyrillic Supplement */
+  /*          Cyrillic Extended-A */
+  /*          Cyrillic Extended-B */
+#define TT_UCR_CYRILLIC                        (1L <<  9) /* U+0400-U+04FF */
+                                                          /* U+0500-U+052F */
+                                                          /* U+2DE0-U+2DFF */
+                                                          /* U+A640-U+A69F */
+  /* Bit 10   Armenian */
+#define TT_UCR_ARMENIAN                        (1L << 10) /* U+0530-U+058F */
+  /* Bit 11   Hebrew */
+#define TT_UCR_HEBREW                          (1L << 11) /* U+0590-U+05FF */
+  /* Bit 12   Vai */
+#define TT_UCR_VAI                             (1L << 12) /* U+A500-U+A63F */
+  /* Bit 13   Arabic            */
+  /*          Arabic Supplement */
+#define TT_UCR_ARABIC                          (1L << 13) /* U+0600-U+06FF */
+                                                          /* U+0750-U+077F */
+  /* Bit 14   NKo */
+#define TT_UCR_NKO                             (1L << 14) /* U+07C0-U+07FF */
+  /* Bit 15   Devanagari */
+#define TT_UCR_DEVANAGARI                      (1L << 15) /* U+0900-U+097F */
+  /* Bit 16   Bengali */
+#define TT_UCR_BENGALI                         (1L << 16) /* U+0980-U+09FF */
+  /* Bit 17   Gurmukhi */
+#define TT_UCR_GURMUKHI                        (1L << 17) /* U+0A00-U+0A7F */
+  /* Bit 18   Gujarati */
+#define TT_UCR_GUJARATI                        (1L << 18) /* U+0A80-U+0AFF */
+  /* Bit 19   Oriya */
+#define TT_UCR_ORIYA                           (1L << 19) /* U+0B00-U+0B7F */
+  /* Bit 20   Tamil */
+#define TT_UCR_TAMIL                           (1L << 20) /* U+0B80-U+0BFF */
+  /* Bit 21   Telugu */
+#define TT_UCR_TELUGU                          (1L << 21) /* U+0C00-U+0C7F */
+  /* Bit 22   Kannada */
+#define TT_UCR_KANNADA                         (1L << 22) /* U+0C80-U+0CFF */
+  /* Bit 23   Malayalam */
+#define TT_UCR_MALAYALAM                       (1L << 23) /* U+0D00-U+0D7F */
+  /* Bit 24   Thai */
+#define TT_UCR_THAI                            (1L << 24) /* U+0E00-U+0E7F */
+  /* Bit 25   Lao */
+#define TT_UCR_LAO                             (1L << 25) /* U+0E80-U+0EFF */
+  /* Bit 26   Georgian            */
+  /*          Georgian Supplement */
+#define TT_UCR_GEORGIAN                        (1L << 26) /* U+10A0-U+10FF */
+                                                          /* U+2D00-U+2D2F */
+  /* Bit 27   Balinese */
+#define TT_UCR_BALINESE                        (1L << 27) /* U+1B00-U+1B7F */
+  /* Bit 28   Hangul Jamo */
+#define TT_UCR_HANGUL_JAMO                     (1L << 28) /* U+1100-U+11FF */
+  /* Bit 29   Latin Extended Additional */
+  /*          Latin Extended-C          */
+  /*          Latin Extended-D          */
+#define TT_UCR_LATIN_EXTENDED_ADDITIONAL       (1L << 29) /* U+1E00-U+1EFF */
+                                                          /* U+2C60-U+2C7F */
+                                                          /* U+A720-U+A7FF */
+  /* Bit 30   Greek Extended */
+#define TT_UCR_GREEK_EXTENDED                  (1L << 30) /* U+1F00-U+1FFF */
+  /* Bit 31   General Punctuation      */
+  /*          Supplemental Punctuation */
+#define TT_UCR_GENERAL_PUNCTUATION             (1L << 31) /* U+2000-U+206F */
+                                                          /* U+2E00-U+2E7F */
+
+  /* ulUnicodeRange2 */
+  /* --------------- */
+
+  /* Bit 32   Superscripts And Subscripts */
+#define TT_UCR_SUPERSCRIPTS_SUBSCRIPTS         (1L <<  0) /* U+2070-U+209F */
+  /* Bit 33   Currency Symbols */
+#define TT_UCR_CURRENCY_SYMBOLS                (1L <<  1) /* U+20A0-U+20CF */
+  /* Bit 34   Combining Diacritical Marks For Symbols */
+#define TT_UCR_COMBINING_DIACRITICAL_MARKS_SYMB \
+                                               (1L <<  2) /* U+20D0-U+20FF */
+  /* Bit 35   Letterlike Symbols */
+#define TT_UCR_LETTERLIKE_SYMBOLS              (1L <<  3) /* U+2100-U+214F */
+  /* Bit 36   Number Forms */
+#define TT_UCR_NUMBER_FORMS                    (1L <<  4) /* U+2150-U+218F */
+  /* Bit 37   Arrows                           */
+  /*          Supplemental Arrows-A            */
+  /*          Supplemental Arrows-B            */
+  /*          Miscellaneous Symbols and Arrows */
+#define TT_UCR_ARROWS                          (1L <<  5) /* U+2190-U+21FF */
+                                                          /* U+27F0-U+27FF */
+                                                          /* U+2900-U+297F */
+                                                          /* U+2B00-U+2BFF */
+  /* Bit 38   Mathematical Operators               */
+  /*          Supplemental Mathematical Operators  */
+  /*          Miscellaneous Mathematical Symbols-A */
+  /*          Miscellaneous Mathematical Symbols-B */
+#define TT_UCR_MATHEMATICAL_OPERATORS          (1L <<  6) /* U+2200-U+22FF */
+                                                          /* U+2A00-U+2AFF */
+                                                          /* U+27C0-U+27EF */
+                                                          /* U+2980-U+29FF */
+  /* Bit 39 Miscellaneous Technical */
+#define TT_UCR_MISCELLANEOUS_TECHNICAL         (1L <<  7) /* U+2300-U+23FF */
+  /* Bit 40   Control Pictures */
+#define TT_UCR_CONTROL_PICTURES                (1L <<  8) /* U+2400-U+243F */
+  /* Bit 41   Optical Character Recognition */
+#define TT_UCR_OCR                             (1L <<  9) /* U+2440-U+245F */
+  /* Bit 42   Enclosed Alphanumerics */
+#define TT_UCR_ENCLOSED_ALPHANUMERICS          (1L << 10) /* U+2460-U+24FF */
+  /* Bit 43   Box Drawing */
+#define TT_UCR_BOX_DRAWING                     (1L << 11) /* U+2500-U+257F */
+  /* Bit 44   Block Elements */
+#define TT_UCR_BLOCK_ELEMENTS                  (1L << 12) /* U+2580-U+259F */
+  /* Bit 45   Geometric Shapes */
+#define TT_UCR_GEOMETRIC_SHAPES                (1L << 13) /* U+25A0-U+25FF */
+  /* Bit 46   Miscellaneous Symbols */
+#define TT_UCR_MISCELLANEOUS_SYMBOLS           (1L << 14) /* U+2600-U+26FF */
+  /* Bit 47   Dingbats */
+#define TT_UCR_DINGBATS                        (1L << 15) /* U+2700-U+27BF */
+  /* Bit 48   CJK Symbols and Punctuation */
+#define TT_UCR_CJK_SYMBOLS                     (1L << 16) /* U+3000-U+303F */
+  /* Bit 49   Hiragana */
+#define TT_UCR_HIRAGANA                        (1L << 17) /* U+3040-U+309F */
+  /* Bit 50   Katakana                     */
+  /*          Katakana Phonetic Extensions */
+#define TT_UCR_KATAKANA                        (1L << 18) /* U+30A0-U+30FF */
+                                                          /* U+31F0-U+31FF */
+  /* Bit 51   Bopomofo          */
+  /*          Bopomofo Extended */
+#define TT_UCR_BOPOMOFO                        (1L << 19) /* U+3100-U+312F */
+                                                          /* U+31A0-U+31BF */
+  /* Bit 52   Hangul Compatibility Jamo */
+#define TT_UCR_HANGUL_COMPATIBILITY_JAMO       (1L << 20) /* U+3130-U+318F */
+  /* Bit 53   Phags-Pa */
+#define TT_UCR_CJK_MISC                        (1L << 21) /* U+A840-U+A87F */
+#define TT_UCR_KANBUN  TT_UCR_CJK_MISC /* deprecated */
+#define TT_UCR_PHAGSPA
+  /* Bit 54   Enclosed CJK Letters and Months */
+#define TT_UCR_ENCLOSED_CJK_LETTERS_MONTHS     (1L << 22) /* U+3200-U+32FF */
+  /* Bit 55   CJK Compatibility */
+#define TT_UCR_CJK_COMPATIBILITY               (1L << 23) /* U+3300-U+33FF */
+  /* Bit 56   Hangul Syllables */
+#define TT_UCR_HANGUL                          (1L << 24) /* U+AC00-U+D7A3 */
+  /* Bit 57   High Surrogates              */
+  /*          High Private Use Surrogates  */
+  /*          Low Surrogates               */
+
+  /* According to OpenType specs v.1.3+,   */
+  /* setting bit 57 implies that there is  */
+  /* at least one codepoint beyond the     */
+  /* Basic Multilingual Plane that is      */
+  /* supported by this font.  So it really */
+  /* means >= U+10000.                     */
+#define TT_UCR_SURROGATES                      (1L << 25) /* U+D800-U+DB7F */
+                                                          /* U+DB80-U+DBFF */
+                                                          /* U+DC00-U+DFFF */
+#define TT_UCR_NON_PLANE_0  TT_UCR_SURROGATES
+  /* Bit 58  Phoenician */
+#define TT_UCR_PHOENICIAN                      (1L << 26) /*U+10900-U+1091F*/
+  /* Bit 59   CJK Unified Ideographs             */
+  /*          CJK Radicals Supplement            */
+  /*          Kangxi Radicals                    */
+  /*          Ideographic Description Characters */
+  /*          CJK Unified Ideographs Extension A */
+  /*          CJK Unified Ideographs Extension B */
+  /*          Kanbun                             */
+#define TT_UCR_CJK_UNIFIED_IDEOGRAPHS          (1L << 27) /* U+4E00-U+9FFF */
+                                                          /* U+2E80-U+2EFF */
+                                                          /* U+2F00-U+2FDF */
+                                                          /* U+2FF0-U+2FFF */
+                                                          /* U+3400-U+4DB5 */
+                                                          /*U+20000-U+2A6DF*/
+                                                          /* U+3190-U+319F */
+  /* Bit 60   Private Use */
+#define TT_UCR_PRIVATE_USE                     (1L << 28) /* U+E000-U+F8FF */
+  /* Bit 61   CJK Strokes                             */
+  /*          CJK Compatibility Ideographs            */
+  /*          CJK Compatibility Ideographs Supplement */
+#define TT_UCR_CJK_COMPATIBILITY_IDEOGRAPHS    (1L << 29) /* U+31C0-U+31EF */
+                                                          /* U+F900-U+FAFF */
+                                                          /*U+2F800-U+2FA1F*/
+  /* Bit 62   Alphabetic Presentation Forms */
+#define TT_UCR_ALPHABETIC_PRESENTATION_FORMS   (1L << 30) /* U+FB00-U+FB4F */
+  /* Bit 63   Arabic Presentation Forms-A */
+#define TT_UCR_ARABIC_PRESENTATION_FORMS_A     (1L << 31) /* U+FB50-U+FDFF */
+
+  /* ulUnicodeRange3 */
+  /* --------------- */
+
+  /* Bit 64   Combining Half Marks */
+#define TT_UCR_COMBINING_HALF_MARKS            (1L <<  0) /* U+FE20-U+FE2F */
+  /* Bit 65   Vertical forms          */
+  /*          CJK Compatibility Forms */
+#define TT_UCR_CJK_COMPATIBILITY_FORMS         (1L <<  1) /* U+FE10-U+FE1F */
+                                                          /* U+FE30-U+FE4F */
+  /* Bit 66   Small Form Variants */
+#define TT_UCR_SMALL_FORM_VARIANTS             (1L <<  2) /* U+FE50-U+FE6F */
+  /* Bit 67   Arabic Presentation Forms-B */
+#define TT_UCR_ARABIC_PRESENTATION_FORMS_B     (1L <<  3) /* U+FE70-U+FEFE */
+  /* Bit 68   Halfwidth and Fullwidth Forms */
+#define TT_UCR_HALFWIDTH_FULLWIDTH_FORMS       (1L <<  4) /* U+FF00-U+FFEF */
+  /* Bit 69   Specials */
+#define TT_UCR_SPECIALS                        (1L <<  5) /* U+FFF0-U+FFFD */
+  /* Bit 70   Tibetan */
+#define TT_UCR_TIBETAN                         (1L <<  6) /* U+0F00-U+0FFF */
+  /* Bit 71   Syriac */
+#define TT_UCR_SYRIAC                          (1L <<  7) /* U+0700-U+074F */
+  /* Bit 72   Thaana */
+#define TT_UCR_THAANA                          (1L <<  8) /* U+0780-U+07BF */
+  /* Bit 73   Sinhala */
+#define TT_UCR_SINHALA                         (1L <<  9) /* U+0D80-U+0DFF */
+  /* Bit 74   Myanmar */
+#define TT_UCR_MYANMAR                         (1L << 10) /* U+1000-U+109F */
+  /* Bit 75   Ethiopic            */
+  /*          Ethiopic Supplement */
+  /*          Ethiopic Extended   */
+#define TT_UCR_ETHIOPIC                        (1L << 11) /* U+1200-U+137F */
+                                                          /* U+1380-U+139F */
+                                                          /* U+2D80-U+2DDF */
+  /* Bit 76   Cherokee */
+#define TT_UCR_CHEROKEE                        (1L << 12) /* U+13A0-U+13FF */
+  /* Bit 77   Unified Canadian Aboriginal Syllabics */
+#define TT_UCR_CANADIAN_ABORIGINAL_SYLLABICS   (1L << 13) /* U+1400-U+167F */
+  /* Bit 78   Ogham */
+#define TT_UCR_OGHAM                           (1L << 14) /* U+1680-U+169F */
+  /* Bit 79   Runic */
+#define TT_UCR_RUNIC                           (1L << 15) /* U+16A0-U+16FF */
+  /* Bit 80   Khmer         */
+  /*          Khmer Symbols */
+#define TT_UCR_KHMER                           (1L << 16) /* U+1780-U+17FF */
+                                                          /* U+19E0-U+19FF */
+  /* Bit 81   Mongolian */
+#define TT_UCR_MONGOLIAN                       (1L << 17) /* U+1800-U+18AF */
+  /* Bit 82   Braille Patterns */
+#define TT_UCR_BRAILLE                         (1L << 18) /* U+2800-U+28FF */
+  /* Bit 83   Yi Syllables */
+  /*          Yi Radicals  */
+#define TT_UCR_YI                              (1L << 19) /* U+A000-U+A48F */
+                                                          /* U+A490-U+A4CF */
+  /* Bit 84   Tagalog  */
+  /*          Hanunoo  */
+  /*          Buhid    */
+  /*          Tagbanwa */
+#define TT_UCR_PHILIPPINE                      (1L << 20) /* U+1700-U+171F */
+                                                          /* U+1720-U+173F */
+                                                          /* U+1740-U+175F */
+                                                          /* U+1760-U+177F */
+  /* Bit 85   Old Italic */
+#define TT_UCR_OLD_ITALIC                      (1L << 21) /*U+10300-U+1032F*/
+  /* Bit 86   Gothic */
+#define TT_UCR_GOTHIC                          (1L << 22) /*U+10330-U+1034F*/
+  /* Bit 87   Deseret */
+#define TT_UCR_DESERET                         (1L << 23) /*U+10400-U+1044F*/
+  /* Bit 88   Byzantine Musical Symbols      */
+  /*          Musical Symbols                */
+  /*          Ancient Greek Musical Notation */
+#define TT_UCR_MUSICAL_SYMBOLS                 (1L << 24) /*U+1D000-U+1D0FF*/
+                                                          /*U+1D100-U+1D1FF*/
+                                                          /*U+1D200-U+1D24F*/
+  /* Bit 89   Mathematical Alphanumeric Symbols */
+#define TT_UCR_MATH_ALPHANUMERIC_SYMBOLS       (1L << 25) /*U+1D400-U+1D7FF*/
+  /* Bit 90   Private Use (plane 15) */
+  /*          Private Use (plane 16) */
+#define TT_UCR_PRIVATE_USE_SUPPLEMENTARY       (1L << 26) /*U+F0000-U+FFFFD*/
+                                                        /*U+100000-U+10FFFD*/
+  /* Bit 91   Variation Selectors            */
+  /*          Variation Selectors Supplement */
+#define TT_UCR_VARIATION_SELECTORS             (1L << 27) /* U+FE00-U+FE0F */
+                                                          /*U+E0100-U+E01EF*/
+  /* Bit 92   Tags */
+#define TT_UCR_TAGS                            (1L << 28) /*U+E0000-U+E007F*/
+  /* Bit 93   Limbu */
+#define TT_UCR_LIMBU                           (1L << 29) /* U+1900-U+194F */
+  /* Bit 94   Tai Le */
+#define TT_UCR_TAI_LE                          (1L << 30) /* U+1950-U+197F */
+  /* Bit 95   New Tai Lue */
+#define TT_UCR_NEW_TAI_LUE                     (1L << 31) /* U+1980-U+19DF */
+
+  /* ulUnicodeRange4 */
+  /* --------------- */
+
+  /* Bit 96   Buginese */
+#define TT_UCR_BUGINESE                        (1L <<  0) /* U+1A00-U+1A1F */
+  /* Bit 97   Glagolitic */
+#define TT_UCR_GLAGOLITIC                      (1L <<  1) /* U+2C00-U+2C5F */
+  /* Bit 98   Tifinagh */
+#define TT_UCR_TIFINAGH                        (1L <<  2) /* U+2D30-U+2D7F */
+  /* Bit 99   Yijing Hexagram Symbols */
+#define TT_UCR_YIJING                          (1L <<  3) /* U+4DC0-U+4DFF */
+  /* Bit 100  Syloti Nagri */
+#define TT_UCR_SYLOTI_NAGRI                    (1L <<  4) /* U+A800-U+A82F */
+  /* Bit 101  Linear B Syllabary */
+  /*          Linear B Ideograms */
+  /*          Aegean Numbers     */
+#define TT_UCR_LINEAR_B                        (1L <<  5) /*U+10000-U+1007F*/
+                                                          /*U+10080-U+100FF*/
+                                                          /*U+10100-U+1013F*/
+  /* Bit 102  Ancient Greek Numbers */
+#define TT_UCR_ANCIENT_GREEK_NUMBERS           (1L <<  6) /*U+10140-U+1018F*/
+  /* Bit 103  Ugaritic */
+#define TT_UCR_UGARITIC                        (1L <<  7) /*U+10380-U+1039F*/
+  /* Bit 104  Old Persian */
+#define TT_UCR_OLD_PERSIAN                     (1L <<  8) /*U+103A0-U+103DF*/
+  /* Bit 105  Shavian */
+#define TT_UCR_SHAVIAN                         (1L <<  9) /*U+10450-U+1047F*/
+  /* Bit 106  Osmanya */
+#define TT_UCR_OSMANYA                         (1L << 10) /*U+10480-U+104AF*/
+  /* Bit 107  Cypriot Syllabary */
+#define TT_UCR_CYPRIOT_SYLLABARY               (1L << 11) /*U+10800-U+1083F*/
+  /* Bit 108  Kharoshthi */
+#define TT_UCR_KHAROSHTHI                      (1L << 12) /*U+10A00-U+10A5F*/
+  /* Bit 109  Tai Xuan Jing Symbols */
+#define TT_UCR_TAI_XUAN_JING                   (1L << 13) /*U+1D300-U+1D35F*/
+  /* Bit 110  Cuneiform                         */
+  /*          Cuneiform Numbers and Punctuation */
+#define TT_UCR_CUNEIFORM                       (1L << 14) /*U+12000-U+123FF*/
+                                                          /*U+12400-U+1247F*/
+  /* Bit 111  Counting Rod Numerals */
+#define TT_UCR_COUNTING_ROD_NUMERALS           (1L << 15) /*U+1D360-U+1D37F*/
+  /* Bit 112  Sundanese */
+#define TT_UCR_SUNDANESE                       (1L << 16) /* U+1B80-U+1BBF */
+  /* Bit 113  Lepcha */
+#define TT_UCR_LEPCHA                          (1L << 17) /* U+1C00-U+1C4F */
+  /* Bit 114  Ol Chiki */
+#define TT_UCR_OL_CHIKI                        (1L << 18) /* U+1C50-U+1C7F */
+  /* Bit 115  Saurashtra */
+#define TT_UCR_SAURASHTRA                      (1L << 19) /* U+A880-U+A8DF */
+  /* Bit 116  Kayah Li */
+#define TT_UCR_KAYAH_LI                        (1L << 20) /* U+A900-U+A92F */
+  /* Bit 117  Rejang */
+#define TT_UCR_REJANG                          (1L << 21) /* U+A930-U+A95F */
+  /* Bit 118  Cham */
+#define TT_UCR_CHAM                            (1L << 22) /* U+AA00-U+AA5F */
+  /* Bit 119  Ancient Symbols */
+#define TT_UCR_ANCIENT_SYMBOLS                 (1L << 23) /*U+10190-U+101CF*/
+  /* Bit 120  Phaistos Disc */
+#define TT_UCR_PHAISTOS_DISC                   (1L << 24) /*U+101D0-U+101FF*/
+  /* Bit 121  Carian */
+  /*          Lycian */
+  /*          Lydian */
+#define TT_UCR_OLD_ANATOLIAN                   (1L << 25) /*U+102A0-U+102DF*/
+                                                          /*U+10280-U+1029F*/
+                                                          /*U+10920-U+1093F*/
+  /* Bit 122  Domino Tiles  */
+  /*          Mahjong Tiles */
+#define TT_UCR_GAME_TILES                      (1L << 26) /*U+1F030-U+1F09F*/
+                                                          /*U+1F000-U+1F02F*/
+  /* Bit 123-127 Reserved for process-internal usage */
+
+  /* */
+
+  /* for backward compatibility with older FreeType versions */
+#define TT_UCR_ARABIC_PRESENTATION_A         \
+          TT_UCR_ARABIC_PRESENTATION_FORMS_A
+#define TT_UCR_ARABIC_PRESENTATION_B         \
+          TT_UCR_ARABIC_PRESENTATION_FORMS_B
+
+#define TT_UCR_COMBINING_DIACRITICS          \
+          TT_UCR_COMBINING_DIACRITICAL_MARKS
+#define TT_UCR_COMBINING_DIACRITICS_SYMB          \
+          TT_UCR_COMBINING_DIACRITICAL_MARKS_SYMB
+
+
+FT_END_HEADER
+
+#endif /* TTNAMEID_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/tttables.h b/engine/inc/freetype/tttables.h
new file mode 100644
index 00000000..58312044
--- /dev/null
+++ b/engine/inc/freetype/tttables.h
@@ -0,0 +1,846 @@
+/***************************************************************************/
+/*                                                                         */
+/*  tttables.h                                                             */
+/*                                                                         */
+/*    Basic SFNT/TrueType tables definitions and interface                 */
+/*    (specification only).                                                */
+/*                                                                         */
+/*  Copyright 1996-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef TTTABLES_H_
+#define TTTABLES_H_
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    truetype_tables                                                    */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    TrueType Tables                                                    */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    TrueType specific table types and functions.                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains definitions of some basic tables specific to */
+  /*    TrueType and OpenType as well as some routines used to access and  */
+  /*    process them.                                                      */
+  /*                                                                       */
+  /* <Order>                                                               */
+  /*    TT_Header                                                          */
+  /*    TT_HoriHeader                                                      */
+  /*    TT_VertHeader                                                      */
+  /*    TT_OS2                                                             */
+  /*    TT_Postscript                                                      */
+  /*    TT_PCLT                                                            */
+  /*    TT_MaxProfile                                                      */
+  /*                                                                       */
+  /*    FT_Sfnt_Tag                                                        */
+  /*    FT_Get_Sfnt_Table                                                  */
+  /*    FT_Load_Sfnt_Table                                                 */
+  /*    FT_Sfnt_Table_Info                                                 */
+  /*                                                                       */
+  /*    FT_Get_CMap_Language_ID                                            */
+  /*    FT_Get_CMap_Format                                                 */
+  /*                                                                       */
+  /*    FT_PARAM_TAG_UNPATENTED_HINTING                                    */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_Header                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure to model a TrueType font header table.  All fields     */
+  /*    follow the OpenType specification.                                 */
+  /*                                                                       */
+  typedef struct  TT_Header_
+  {
+    FT_Fixed   Table_Version;
+    FT_Fixed   Font_Revision;
+
+    FT_Long    CheckSum_Adjust;
+    FT_Long    Magic_Number;
+
+    FT_UShort  Flags;
+    FT_UShort  Units_Per_EM;
+
+    FT_Long    Created [2];
+    FT_Long    Modified[2];
+
+    FT_Short   xMin;
+    FT_Short   yMin;
+    FT_Short   xMax;
+    FT_Short   yMax;
+
+    FT_UShort  Mac_Style;
+    FT_UShort  Lowest_Rec_PPEM;
+
+    FT_Short   Font_Direction;
+    FT_Short   Index_To_Loc_Format;
+    FT_Short   Glyph_Data_Format;
+
+  } TT_Header;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_HoriHeader                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure to model a TrueType horizontal header, the `hhea'      */
+  /*    table, as well as the corresponding horizontal metrics table,      */
+  /*    `hmtx'.                                                            */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    Version                :: The table version.                       */
+  /*                                                                       */
+  /*    Ascender               :: The font's ascender, i.e., the distance  */
+  /*                              from the baseline to the top-most of all */
+  /*                              glyph points found in the font.          */
+  /*                                                                       */
+  /*                              This value is invalid in many fonts, as  */
+  /*                              it is usually set by the font designer,  */
+  /*                              and often reflects only a portion of the */
+  /*                              glyphs found in the font (maybe ASCII).  */
+  /*                                                                       */
+  /*                              You should use the `sTypoAscender' field */
+  /*                              of the `OS/2' table instead if you want  */
+  /*                              the correct one.                         */
+  /*                                                                       */
+  /*    Descender              :: The font's descender, i.e., the distance */
+  /*                              from the baseline to the bottom-most of  */
+  /*                              all glyph points found in the font.  It  */
+  /*                              is negative.                             */
+  /*                                                                       */
+  /*                              This value is invalid in many fonts, as  */
+  /*                              it is usually set by the font designer,  */
+  /*                              and often reflects only a portion of the */
+  /*                              glyphs found in the font (maybe ASCII).  */
+  /*                                                                       */
+  /*                              You should use the `sTypoDescender'      */
+  /*                              field of the `OS/2' table instead if you */
+  /*                              want the correct one.                    */
+  /*                                                                       */
+  /*    Line_Gap               :: The font's line gap, i.e., the distance  */
+  /*                              to add to the ascender and descender to  */
+  /*                              get the BTB, i.e., the                   */
+  /*                              baseline-to-baseline distance for the    */
+  /*                              font.                                    */
+  /*                                                                       */
+  /*    advance_Width_Max      :: This field is the maximum of all advance */
+  /*                              widths found in the font.  It can be     */
+  /*                              used to compute the maximum width of an  */
+  /*                              arbitrary string of text.                */
+  /*                                                                       */
+  /*    min_Left_Side_Bearing  :: The minimum left side bearing of all     */
+  /*                              glyphs within the font.                  */
+  /*                                                                       */
+  /*    min_Right_Side_Bearing :: The minimum right side bearing of all    */
+  /*                              glyphs within the font.                  */
+  /*                                                                       */
+  /*    xMax_Extent            :: The maximum horizontal extent (i.e., the */
+  /*                              `width' of a glyph's bounding box) for   */
+  /*                              all glyphs in the font.                  */
+  /*                                                                       */
+  /*    caret_Slope_Rise       :: The rise coefficient of the cursor's     */
+  /*                              slope of the cursor (slope=rise/run).    */
+  /*                                                                       */
+  /*    caret_Slope_Run        :: The run coefficient of the cursor's      */
+  /*                              slope.                                   */
+  /*                                                                       */
+  /*    caret_Offset           :: The cursor's offset for slanted fonts.   */
+  /*                                                                       */
+  /*    Reserved               :: 8~reserved bytes.                        */
+  /*                                                                       */
+  /*    metric_Data_Format     :: Always~0.                                */
+  /*                                                                       */
+  /*    number_Of_HMetrics     :: Number of HMetrics entries in the `hmtx' */
+  /*                              table -- this value can be smaller than  */
+  /*                              the total number of glyphs in the font.  */
+  /*                                                                       */
+  /*    long_metrics           :: A pointer into the `hmtx' table.         */
+  /*                                                                       */
+  /*    short_metrics          :: A pointer into the `hmtx' table.         */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    For an OpenType variation font, the values of the following fields */
+  /*    can change after a call to @FT_Set_Var_Design_Coordinates (and     */
+  /*    friends) if the font contains an `MVAR' table: `caret_Slope_Rise', */
+  /*    `caret_Slope_Run', and `caret_Offset'.                             */
+  /*                                                                       */
+  typedef struct  TT_HoriHeader_
+  {
+    FT_Fixed   Version;
+    FT_Short   Ascender;
+    FT_Short   Descender;
+    FT_Short   Line_Gap;
+
+    FT_UShort  advance_Width_Max;      /* advance width maximum */
+
+    FT_Short   min_Left_Side_Bearing;  /* minimum left-sb       */
+    FT_Short   min_Right_Side_Bearing; /* minimum right-sb      */
+    FT_Short   xMax_Extent;            /* xmax extents          */
+    FT_Short   caret_Slope_Rise;
+    FT_Short   caret_Slope_Run;
+    FT_Short   caret_Offset;
+
+    FT_Short   Reserved[4];
+
+    FT_Short   metric_Data_Format;
+    FT_UShort  number_Of_HMetrics;
+
+    /* The following fields are not defined by the OpenType specification */
+    /* but they are used to connect the metrics header to the relevant    */
+    /* `hmtx' table.                                                      */
+
+    void*      long_metrics;
+    void*      short_metrics;
+
+  } TT_HoriHeader;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_VertHeader                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to model a TrueType vertical header, the `vhea'   */
+  /*    table, as well as the corresponding vertical metrics table,        */
+  /*    `vmtx'.                                                            */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    Version                 :: The table version.                      */
+  /*                                                                       */
+  /*    Ascender                :: The font's ascender, i.e., the distance */
+  /*                               from the baseline to the top-most of    */
+  /*                               all glyph points found in the font.     */
+  /*                                                                       */
+  /*                               This value is invalid in many fonts, as */
+  /*                               it is usually set by the font designer, */
+  /*                               and often reflects only a portion of    */
+  /*                               the glyphs found in the font (maybe     */
+  /*                               ASCII).                                 */
+  /*                                                                       */
+  /*                               You should use the `sTypoAscender'      */
+  /*                               field of the `OS/2' table instead if    */
+  /*                               you want the correct one.               */
+  /*                                                                       */
+  /*    Descender               :: The font's descender, i.e., the         */
+  /*                               distance from the baseline to the       */
+  /*                               bottom-most of all glyph points found   */
+  /*                               in the font.  It is negative.           */
+  /*                                                                       */
+  /*                               This value is invalid in many fonts, as */
+  /*                               it is usually set by the font designer, */
+  /*                               and often reflects only a portion of    */
+  /*                               the glyphs found in the font (maybe     */
+  /*                               ASCII).                                 */
+  /*                                                                       */
+  /*                               You should use the `sTypoDescender'     */
+  /*                               field of the `OS/2' table instead if    */
+  /*                               you want the correct one.               */
+  /*                                                                       */
+  /*    Line_Gap                :: The font's line gap, i.e., the distance */
+  /*                               to add to the ascender and descender to */
+  /*                               get the BTB, i.e., the                  */
+  /*                               baseline-to-baseline distance for the   */
+  /*                               font.                                   */
+  /*                                                                       */
+  /*    advance_Height_Max      :: This field is the maximum of all        */
+  /*                               advance heights found in the font.  It  */
+  /*                               can be used to compute the maximum      */
+  /*                               height of an arbitrary string of text.  */
+  /*                                                                       */
+  /*    min_Top_Side_Bearing    :: The minimum top side bearing of all     */
+  /*                               glyphs within the font.                 */
+  /*                                                                       */
+  /*    min_Bottom_Side_Bearing :: The minimum bottom side bearing of all  */
+  /*                               glyphs within the font.                 */
+  /*                                                                       */
+  /*    yMax_Extent             :: The maximum vertical extent (i.e., the  */
+  /*                               `height' of a glyph's bounding box) for */
+  /*                               all glyphs in the font.                 */
+  /*                                                                       */
+  /*    caret_Slope_Rise        :: The rise coefficient of the cursor's    */
+  /*                               slope of the cursor (slope=rise/run).   */
+  /*                                                                       */
+  /*    caret_Slope_Run         :: The run coefficient of the cursor's     */
+  /*                               slope.                                  */
+  /*                                                                       */
+  /*    caret_Offset            :: The cursor's offset for slanted fonts.  */
+  /*                                                                       */
+  /*    Reserved                :: 8~reserved bytes.                       */
+  /*                                                                       */
+  /*    metric_Data_Format      :: Always~0.                               */
+  /*                                                                       */
+  /*    number_Of_VMetrics      :: Number of VMetrics entries in the       */
+  /*                               `vmtx' table -- this value can be       */
+  /*                               smaller than the total number of glyphs */
+  /*                               in the font.                            */
+  /*                                                                       */
+  /*    long_metrics            :: A pointer into the `vmtx' table.        */
+  /*                                                                       */
+  /*    short_metrics           :: A pointer into the `vmtx' table.        */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    For an OpenType variation font, the values of the following fields */
+  /*    can change after a call to @FT_Set_Var_Design_Coordinates (and     */
+  /*    friends) if the font contains an `MVAR' table: `Ascender',         */
+  /*    `Descender', `Line_Gap', `caret_Slope_Rise', `caret_Slope_Run',    */
+  /*    and `caret_Offset'.                                                */
+  /*                                                                       */
+  typedef struct  TT_VertHeader_
+  {
+    FT_Fixed   Version;
+    FT_Short   Ascender;
+    FT_Short   Descender;
+    FT_Short   Line_Gap;
+
+    FT_UShort  advance_Height_Max;      /* advance height maximum */
+
+    FT_Short   min_Top_Side_Bearing;    /* minimum top-sb          */
+    FT_Short   min_Bottom_Side_Bearing; /* minimum bottom-sb       */
+    FT_Short   yMax_Extent;             /* ymax extents            */
+    FT_Short   caret_Slope_Rise;
+    FT_Short   caret_Slope_Run;
+    FT_Short   caret_Offset;
+
+    FT_Short   Reserved[4];
+
+    FT_Short   metric_Data_Format;
+    FT_UShort  number_Of_VMetrics;
+
+    /* The following fields are not defined by the OpenType specification */
+    /* but they are used to connect the metrics header to the relevant    */
+    /* `vmtx' table.                                                      */
+
+    void*      long_metrics;
+    void*      short_metrics;
+
+  } TT_VertHeader;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_OS2                                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure to model a TrueType `OS/2' table.  All fields comply   */
+  /*    to the OpenType specification.                                     */
+  /*                                                                       */
+  /*    Note that we now support old Mac fonts that do not include an      */
+  /*    `OS/2' table.  In this case, the `version' field is always set to  */
+  /*    0xFFFF.                                                            */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    For an OpenType variation font, the values of the following fields */
+  /*    can change after a call to @FT_Set_Var_Design_Coordinates (and     */
+  /*    friends) if the font contains an `MVAR' table: `sCapHeight',       */
+  /*    `sTypoAscender', `sTypoDescender', `sTypoLineGap', `sxHeight',     */
+  /*    `usWinAscent', `usWinDescent', `yStrikeoutPosition',               */
+  /*    `yStrikeoutSize', `ySubscriptXOffset', `ySubScriptXSize',          */
+  /*    `ySubscriptYOffset', `ySubscriptYSize', `ySuperscriptXOffset',     */
+  /*    `ySuperscriptXSize', `ySuperscriptYOffset', and                    */
+  /*    `ySuperscriptYSize'.                                               */
+  /*                                                                       */
+  /*    Possible values for bits in the `ulUnicodeRangeX' fields are given */
+  /*    by the @TT_UCR_XXX macros.                                         */
+  /*                                                                       */
+
+  typedef struct  TT_OS2_
+  {
+    FT_UShort  version;                /* 0x0001 - more or 0xFFFF */
+    FT_Short   xAvgCharWidth;
+    FT_UShort  usWeightClass;
+    FT_UShort  usWidthClass;
+    FT_UShort  fsType;
+    FT_Short   ySubscriptXSize;
+    FT_Short   ySubscriptYSize;
+    FT_Short   ySubscriptXOffset;
+    FT_Short   ySubscriptYOffset;
+    FT_Short   ySuperscriptXSize;
+    FT_Short   ySuperscriptYSize;
+    FT_Short   ySuperscriptXOffset;
+    FT_Short   ySuperscriptYOffset;
+    FT_Short   yStrikeoutSize;
+    FT_Short   yStrikeoutPosition;
+    FT_Short   sFamilyClass;
+
+    FT_Byte    panose[10];
+
+    FT_ULong   ulUnicodeRange1;        /* Bits 0-31   */
+    FT_ULong   ulUnicodeRange2;        /* Bits 32-63  */
+    FT_ULong   ulUnicodeRange3;        /* Bits 64-95  */
+    FT_ULong   ulUnicodeRange4;        /* Bits 96-127 */
+
+    FT_Char    achVendID[4];
+
+    FT_UShort  fsSelection;
+    FT_UShort  usFirstCharIndex;
+    FT_UShort  usLastCharIndex;
+    FT_Short   sTypoAscender;
+    FT_Short   sTypoDescender;
+    FT_Short   sTypoLineGap;
+    FT_UShort  usWinAscent;
+    FT_UShort  usWinDescent;
+
+    /* only version 1 and higher: */
+
+    FT_ULong   ulCodePageRange1;       /* Bits 0-31   */
+    FT_ULong   ulCodePageRange2;       /* Bits 32-63  */
+
+    /* only version 2 and higher: */
+
+    FT_Short   sxHeight;
+    FT_Short   sCapHeight;
+    FT_UShort  usDefaultChar;
+    FT_UShort  usBreakChar;
+    FT_UShort  usMaxContext;
+
+    /* only version 5 and higher: */
+
+    FT_UShort  usLowerOpticalPointSize;       /* in twips (1/20th points) */
+    FT_UShort  usUpperOpticalPointSize;       /* in twips (1/20th points) */
+
+  } TT_OS2;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_Postscript                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure to model a TrueType `post' table.  All fields comply   */
+  /*    to the OpenType specification.  This structure does not reference  */
+  /*    a font's PostScript glyph names; use @FT_Get_Glyph_Name to         */
+  /*    retrieve them.                                                     */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    For an OpenType variation font, the values of the following fields */
+  /*    can change after a call to @FT_Set_Var_Design_Coordinates (and     */
+  /*    friends) if the font contains an `MVAR' table: `underlinePosition' */
+  /*    and `underlineThickness'.                                          */
+  /*                                                                       */
+  typedef struct  TT_Postscript_
+  {
+    FT_Fixed  FormatType;
+    FT_Fixed  italicAngle;
+    FT_Short  underlinePosition;
+    FT_Short  underlineThickness;
+    FT_ULong  isFixedPitch;
+    FT_ULong  minMemType42;
+    FT_ULong  maxMemType42;
+    FT_ULong  minMemType1;
+    FT_ULong  maxMemType1;
+
+    /* Glyph names follow in the `post' table, but we don't */
+    /* load them by default.                                */
+
+  } TT_Postscript;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_PCLT                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure to model a TrueType `PCLT' table.  All fields comply   */
+  /*    to the OpenType specification.                                     */
+  /*                                                                       */
+  typedef struct  TT_PCLT_
+  {
+    FT_Fixed   Version;
+    FT_ULong   FontNumber;
+    FT_UShort  Pitch;
+    FT_UShort  xHeight;
+    FT_UShort  Style;
+    FT_UShort  TypeFamily;
+    FT_UShort  CapHeight;
+    FT_UShort  SymbolSet;
+    FT_Char    TypeFace[16];
+    FT_Char    CharacterComplement[8];
+    FT_Char    FileName[6];
+    FT_Char    StrokeWeight;
+    FT_Char    WidthType;
+    FT_Byte    SerifStyle;
+    FT_Byte    Reserved;
+
+  } TT_PCLT;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_MaxProfile                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The maximum profile (`maxp') table contains many max values, which */
+  /*    can be used to pre-allocate arrays for speeding up glyph loading   */
+  /*    and hinting.                                                       */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    version               :: The version number.                       */
+  /*                                                                       */
+  /*    numGlyphs             :: The number of glyphs in this TrueType     */
+  /*                             font.                                     */
+  /*                                                                       */
+  /*    maxPoints             :: The maximum number of points in a         */
+  /*                             non-composite TrueType glyph.  See also   */
+  /*                             `maxCompositePoints'.                     */
+  /*                                                                       */
+  /*    maxContours           :: The maximum number of contours in a       */
+  /*                             non-composite TrueType glyph.  See also   */
+  /*                             `maxCompositeContours'.                   */
+  /*                                                                       */
+  /*    maxCompositePoints    :: The maximum number of points in a         */
+  /*                             composite TrueType glyph.  See also       */
+  /*                             `maxPoints'.                              */
+  /*                                                                       */
+  /*    maxCompositeContours  :: The maximum number of contours in a       */
+  /*                             composite TrueType glyph.  See also       */
+  /*                             `maxContours'.                            */
+  /*                                                                       */
+  /*    maxZones              :: The maximum number of zones used for      */
+  /*                             glyph hinting.                            */
+  /*                                                                       */
+  /*    maxTwilightPoints     :: The maximum number of points in the       */
+  /*                             twilight zone used for glyph hinting.     */
+  /*                                                                       */
+  /*    maxStorage            :: The maximum number of elements in the     */
+  /*                             storage area used for glyph hinting.      */
+  /*                                                                       */
+  /*    maxFunctionDefs       :: The maximum number of function            */
+  /*                             definitions in the TrueType bytecode for  */
+  /*                             this font.                                */
+  /*                                                                       */
+  /*    maxInstructionDefs    :: The maximum number of instruction         */
+  /*                             definitions in the TrueType bytecode for  */
+  /*                             this font.                                */
+  /*                                                                       */
+  /*    maxStackElements      :: The maximum number of stack elements used */
+  /*                             during bytecode interpretation.           */
+  /*                                                                       */
+  /*    maxSizeOfInstructions :: The maximum number of TrueType opcodes    */
+  /*                             used for glyph hinting.                   */
+  /*                                                                       */
+  /*    maxComponentElements  :: The maximum number of simple (i.e., non-  */
+  /*                             composite) glyphs in a composite glyph.   */
+  /*                                                                       */
+  /*    maxComponentDepth     :: The maximum nesting depth of composite    */
+  /*                             glyphs.                                   */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This structure is only used during font loading.                   */
+  /*                                                                       */
+  typedef struct  TT_MaxProfile_
+  {
+    FT_Fixed   version;
+    FT_UShort  numGlyphs;
+    FT_UShort  maxPoints;
+    FT_UShort  maxContours;
+    FT_UShort  maxCompositePoints;
+    FT_UShort  maxCompositeContours;
+    FT_UShort  maxZones;
+    FT_UShort  maxTwilightPoints;
+    FT_UShort  maxStorage;
+    FT_UShort  maxFunctionDefs;
+    FT_UShort  maxInstructionDefs;
+    FT_UShort  maxStackElements;
+    FT_UShort  maxSizeOfInstructions;
+    FT_UShort  maxComponentElements;
+    FT_UShort  maxComponentDepth;
+
+  } TT_MaxProfile;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    FT_Sfnt_Tag                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An enumeration to specify indices of SFNT tables loaded and parsed */
+  /*    by FreeType during initialization of an SFNT font.  Used in the    */
+  /*    @FT_Get_Sfnt_Table API function.                                   */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    FT_SFNT_HEAD :: To access the font's @TT_Header structure.         */
+  /*                                                                       */
+  /*    FT_SFNT_MAXP :: To access the font's @TT_MaxProfile structure.     */
+  /*                                                                       */
+  /*    FT_SFNT_OS2  :: To access the font's @TT_OS2 structure.            */
+  /*                                                                       */
+  /*    FT_SFNT_HHEA :: To access the font's @TT_HoriHeader structure.     */
+  /*                                                                       */
+  /*    FT_SFNT_VHEA :: To access the font's @TT_VertHeader structure.     */
+  /*                                                                       */
+  /*    FT_SFNT_POST :: To access the font's @TT_Postscript structure.     */
+  /*                                                                       */
+  /*    FT_SFNT_PCLT :: To access the font's @TT_PCLT structure.           */
+  /*                                                                       */
+  typedef enum  FT_Sfnt_Tag_
+  {
+    FT_SFNT_HEAD,
+    FT_SFNT_MAXP,
+    FT_SFNT_OS2,
+    FT_SFNT_HHEA,
+    FT_SFNT_VHEA,
+    FT_SFNT_POST,
+    FT_SFNT_PCLT,
+
+    FT_SFNT_MAX
+
+  } FT_Sfnt_Tag;
+
+  /* these constants are deprecated; use the corresponding `FT_Sfnt_Tag' */
+  /* values instead                                                      */
+#define ft_sfnt_head  FT_SFNT_HEAD
+#define ft_sfnt_maxp  FT_SFNT_MAXP
+#define ft_sfnt_os2   FT_SFNT_OS2
+#define ft_sfnt_hhea  FT_SFNT_HHEA
+#define ft_sfnt_vhea  FT_SFNT_VHEA
+#define ft_sfnt_post  FT_SFNT_POST
+#define ft_sfnt_pclt  FT_SFNT_PCLT
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Sfnt_Table                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Return a pointer to a given SFNT table stored within a face.       */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face :: A handle to the source.                                    */
+  /*                                                                       */
+  /*    tag  :: The index of the SFNT table.                               */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    A type-less pointer to the table.  This will be NULL in case of    */
+  /*    error, or if the corresponding table was not found *OR* loaded     */
+  /*    from the file.                                                     */
+  /*                                                                       */
+  /*    Use a typecast according to `tag' to access the structure          */
+  /*    elements.                                                          */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The table is owned by the face object and disappears with it.      */
+  /*                                                                       */
+  /*    This function is only useful to access SFNT tables that are loaded */
+  /*    by the sfnt, truetype, and opentype drivers.  See @FT_Sfnt_Tag for */
+  /*    a list.                                                            */
+  /*                                                                       */
+  /*    Here an example how to access the `vhea' table:                    */
+  /*                                                                       */
+  /*    {                                                                  */
+  /*      TT_VertHeader*  vert_header;                                     */
+  /*                                                                       */
+  /*                                                                       */
+  /*      vert_header =                                                    */
+  /*        (TT_VertHeader*)FT_Get_Sfnt_Table( face, FT_SFNT_VHEA );       */
+  /*    }                                                                  */
+  /*                                                                       */
+  FT_EXPORT( void* )
+  FT_Get_Sfnt_Table( FT_Face      face,
+                     FT_Sfnt_Tag  tag );
+
+
+  /**************************************************************************
+   *
+   * @function:
+   *   FT_Load_Sfnt_Table
+   *
+   * @description:
+   *   Load any SFNT font table into client memory.
+   *
+   * @input:
+   *   face ::
+   *     A handle to the source face.
+   *
+   *   tag ::
+   *     The four-byte tag of the table to load.  Use value~0 if you want
+   *     to access the whole font file.  Otherwise, you can use one of the
+   *     definitions found in the @FT_TRUETYPE_TAGS_H file, or forge a new
+   *     one with @FT_MAKE_TAG.
+   *
+   *   offset ::
+   *     The starting offset in the table (or file if tag~==~0).
+   *
+   * @output:
+   *   buffer ::
+   *     The target buffer address.  The client must ensure that the memory
+   *     array is big enough to hold the data.
+   *
+   * @inout:
+   *   length ::
+   *     If the `length' parameter is NULL, try to load the whole table.
+   *     Return an error code if it fails.
+   *
+   *     Else, if `*length' is~0, exit immediately while returning the
+   *     table's (or file) full size in it.
+   *
+   *     Else the number of bytes to read from the table or file, from the
+   *     starting offset.
+   *
+   * @return:
+   *   FreeType error code.  0~means success.
+   *
+   * @note:
+   *   If you need to determine the table's length you should first call this
+   *   function with `*length' set to~0, as in the following example:
+   *
+   *     {
+   *       FT_ULong  length = 0;
+   *
+   *
+   *       error = FT_Load_Sfnt_Table( face, tag, 0, NULL, &length );
+   *       if ( error ) { ... table does not exist ... }
+   *
+   *       buffer = malloc( length );
+   *       if ( buffer == NULL ) { ... not enough memory ... }
+   *
+   *       error = FT_Load_Sfnt_Table( face, tag, 0, buffer, &length );
+   *       if ( error ) { ... could not load table ... }
+   *     }
+   *
+   *   Note that structures like @TT_Header or @TT_OS2 can't be used with
+   *   this function; they are limited to @FT_Get_Sfnt_Table.  Reason is that
+   *   those structures depend on the processor architecture, with varying
+   *   size (e.g. 32bit vs. 64bit) or order (big endian vs. little endian).
+   *
+   */
+  FT_EXPORT( FT_Error )
+  FT_Load_Sfnt_Table( FT_Face    face,
+                      FT_ULong   tag,
+                      FT_Long    offset,
+                      FT_Byte*   buffer,
+                      FT_ULong*  length );
+
+
+  /**************************************************************************
+   *
+   * @function:
+   *   FT_Sfnt_Table_Info
+   *
+   * @description:
+   *   Return information on an SFNT table.
+   *
+   * @input:
+   *   face ::
+   *     A handle to the source face.
+   *
+   *   table_index ::
+   *     The index of an SFNT table.  The function returns
+   *     FT_Err_Table_Missing for an invalid value.
+   *
+   * @inout:
+   *   tag ::
+   *     The name tag of the SFNT table.  If the value is NULL, `table_index'
+   *     is ignored, and `length' returns the number of SFNT tables in the
+   *     font.
+   *
+   * @output:
+   *   length ::
+   *     The length of the SFNT table (or the number of SFNT tables, depending
+   *     on `tag').
+   *
+   * @return:
+   *   FreeType error code.  0~means success.
+   *
+   * @note:
+   *   While parsing fonts, FreeType handles SFNT tables with length zero as
+   *   missing.
+   *
+   */
+  FT_EXPORT( FT_Error )
+  FT_Sfnt_Table_Info( FT_Face    face,
+                      FT_UInt    table_index,
+                      FT_ULong  *tag,
+                      FT_ULong  *length );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_CMap_Language_ID                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Return cmap language ID as specified in the OpenType standard.     */
+  /*    Definitions of language ID values are in file @FT_TRUETYPE_IDS_H.  */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charmap ::                                                         */
+  /*      The target charmap.                                              */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The language ID of `charmap'.  If `charmap' doesn't belong to an   */
+  /*    SFNT face, just return~0 as the default value.                     */
+  /*                                                                       */
+  /*    For a format~14 cmap (to access Unicode IVS), the return value is  */
+  /*    0xFFFFFFFF.                                                        */
+  /*                                                                       */
+  FT_EXPORT( FT_ULong )
+  FT_Get_CMap_Language_ID( FT_CharMap  charmap );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_CMap_Format                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Return the format of an SFNT `cmap' table.                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charmap ::                                                         */
+  /*      The target charmap.                                              */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The format of `charmap'.  If `charmap' doesn't belong to an SFNT   */
+  /*    face, return -1.                                                   */
+  /*                                                                       */
+  FT_EXPORT( FT_Long )
+  FT_Get_CMap_Format( FT_CharMap  charmap );
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* TTTABLES_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/tttags.h b/engine/inc/freetype/tttags.h
new file mode 100644
index 00000000..b7d3bac0
--- /dev/null
+++ b/engine/inc/freetype/tttags.h
@@ -0,0 +1,121 @@
+/***************************************************************************/
+/*                                                                         */
+/*  tttags.h                                                               */
+/*                                                                         */
+/*    Tags for TrueType and OpenType tables (specification only).          */
+/*                                                                         */
+/*  Copyright 1996-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef TTAGS_H_
+#define TTAGS_H_
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+
+#define TTAG_avar  FT_MAKE_TAG( 'a', 'v', 'a', 'r' )
+#define TTAG_BASE  FT_MAKE_TAG( 'B', 'A', 'S', 'E' )
+#define TTAG_bdat  FT_MAKE_TAG( 'b', 'd', 'a', 't' )
+#define TTAG_BDF   FT_MAKE_TAG( 'B', 'D', 'F', ' ' )
+#define TTAG_bhed  FT_MAKE_TAG( 'b', 'h', 'e', 'd' )
+#define TTAG_bloc  FT_MAKE_TAG( 'b', 'l', 'o', 'c' )
+#define TTAG_bsln  FT_MAKE_TAG( 'b', 's', 'l', 'n' )
+#define TTAG_CBDT  FT_MAKE_TAG( 'C', 'B', 'D', 'T' )
+#define TTAG_CBLC  FT_MAKE_TAG( 'C', 'B', 'L', 'C' )
+#define TTAG_CFF   FT_MAKE_TAG( 'C', 'F', 'F', ' ' )
+#define TTAG_CFF2  FT_MAKE_TAG( 'C', 'F', 'F', '2' )
+#define TTAG_CID   FT_MAKE_TAG( 'C', 'I', 'D', ' ' )
+#define TTAG_cmap  FT_MAKE_TAG( 'c', 'm', 'a', 'p' )
+#define TTAG_cvar  FT_MAKE_TAG( 'c', 'v', 'a', 'r' )
+#define TTAG_cvt   FT_MAKE_TAG( 'c', 'v', 't', ' ' )
+#define TTAG_DSIG  FT_MAKE_TAG( 'D', 'S', 'I', 'G' )
+#define TTAG_EBDT  FT_MAKE_TAG( 'E', 'B', 'D', 'T' )
+#define TTAG_EBLC  FT_MAKE_TAG( 'E', 'B', 'L', 'C' )
+#define TTAG_EBSC  FT_MAKE_TAG( 'E', 'B', 'S', 'C' )
+#define TTAG_feat  FT_MAKE_TAG( 'f', 'e', 'a', 't' )
+#define TTAG_FOND  FT_MAKE_TAG( 'F', 'O', 'N', 'D' )
+#define TTAG_fpgm  FT_MAKE_TAG( 'f', 'p', 'g', 'm' )
+#define TTAG_fvar  FT_MAKE_TAG( 'f', 'v', 'a', 'r' )
+#define TTAG_gasp  FT_MAKE_TAG( 'g', 'a', 's', 'p' )
+#define TTAG_GDEF  FT_MAKE_TAG( 'G', 'D', 'E', 'F' )
+#define TTAG_glyf  FT_MAKE_TAG( 'g', 'l', 'y', 'f' )
+#define TTAG_GPOS  FT_MAKE_TAG( 'G', 'P', 'O', 'S' )
+#define TTAG_GSUB  FT_MAKE_TAG( 'G', 'S', 'U', 'B' )
+#define TTAG_gvar  FT_MAKE_TAG( 'g', 'v', 'a', 'r' )
+#define TTAG_HVAR  FT_MAKE_TAG( 'H', 'V', 'A', 'R' )
+#define TTAG_hdmx  FT_MAKE_TAG( 'h', 'd', 'm', 'x' )
+#define TTAG_head  FT_MAKE_TAG( 'h', 'e', 'a', 'd' )
+#define TTAG_hhea  FT_MAKE_TAG( 'h', 'h', 'e', 'a' )
+#define TTAG_hmtx  FT_MAKE_TAG( 'h', 'm', 't', 'x' )
+#define TTAG_JSTF  FT_MAKE_TAG( 'J', 'S', 'T', 'F' )
+#define TTAG_just  FT_MAKE_TAG( 'j', 'u', 's', 't' )
+#define TTAG_kern  FT_MAKE_TAG( 'k', 'e', 'r', 'n' )
+#define TTAG_lcar  FT_MAKE_TAG( 'l', 'c', 'a', 'r' )
+#define TTAG_loca  FT_MAKE_TAG( 'l', 'o', 'c', 'a' )
+#define TTAG_LTSH  FT_MAKE_TAG( 'L', 'T', 'S', 'H' )
+#define TTAG_LWFN  FT_MAKE_TAG( 'L', 'W', 'F', 'N' )
+#define TTAG_MATH  FT_MAKE_TAG( 'M', 'A', 'T', 'H' )
+#define TTAG_maxp  FT_MAKE_TAG( 'm', 'a', 'x', 'p' )
+#define TTAG_META  FT_MAKE_TAG( 'M', 'E', 'T', 'A' )
+#define TTAG_MMFX  FT_MAKE_TAG( 'M', 'M', 'F', 'X' )
+#define TTAG_MMSD  FT_MAKE_TAG( 'M', 'M', 'S', 'D' )
+#define TTAG_mort  FT_MAKE_TAG( 'm', 'o', 'r', 't' )
+#define TTAG_morx  FT_MAKE_TAG( 'm', 'o', 'r', 'x' )
+#define TTAG_MVAR  FT_MAKE_TAG( 'M', 'V', 'A', 'R' )
+#define TTAG_name  FT_MAKE_TAG( 'n', 'a', 'm', 'e' )
+#define TTAG_opbd  FT_MAKE_TAG( 'o', 'p', 'b', 'd' )
+#define TTAG_OS2   FT_MAKE_TAG( 'O', 'S', '/', '2' )
+#define TTAG_OTTO  FT_MAKE_TAG( 'O', 'T', 'T', 'O' )
+#define TTAG_PCLT  FT_MAKE_TAG( 'P', 'C', 'L', 'T' )
+#define TTAG_POST  FT_MAKE_TAG( 'P', 'O', 'S', 'T' )
+#define TTAG_post  FT_MAKE_TAG( 'p', 'o', 's', 't' )
+#define TTAG_prep  FT_MAKE_TAG( 'p', 'r', 'e', 'p' )
+#define TTAG_prop  FT_MAKE_TAG( 'p', 'r', 'o', 'p' )
+#define TTAG_sbix  FT_MAKE_TAG( 's', 'b', 'i', 'x' )
+#define TTAG_sfnt  FT_MAKE_TAG( 's', 'f', 'n', 't' )
+#define TTAG_SING  FT_MAKE_TAG( 'S', 'I', 'N', 'G' )
+#define TTAG_trak  FT_MAKE_TAG( 't', 'r', 'a', 'k' )
+#define TTAG_true  FT_MAKE_TAG( 't', 'r', 'u', 'e' )
+#define TTAG_ttc   FT_MAKE_TAG( 't', 't', 'c', ' ' )
+#define TTAG_ttcf  FT_MAKE_TAG( 't', 't', 'c', 'f' )
+#define TTAG_TYP1  FT_MAKE_TAG( 'T', 'Y', 'P', '1' )
+#define TTAG_typ1  FT_MAKE_TAG( 't', 'y', 'p', '1' )
+#define TTAG_VDMX  FT_MAKE_TAG( 'V', 'D', 'M', 'X' )
+#define TTAG_vhea  FT_MAKE_TAG( 'v', 'h', 'e', 'a' )
+#define TTAG_vmtx  FT_MAKE_TAG( 'v', 'm', 't', 'x' )
+#define TTAG_VVAR  FT_MAKE_TAG( 'V', 'V', 'A', 'R' )
+#define TTAG_wOFF  FT_MAKE_TAG( 'w', 'O', 'F', 'F' )
+
+/* used by "Keyboard.dfont" on legacy Mac OS X */
+#define TTAG_0xA5kbd  FT_MAKE_TAG( 0xA5, 'k', 'b', 'd' )
+
+/* used by "LastResort.dfont" on legacy Mac OS X */
+#define TTAG_0xA5lst  FT_MAKE_TAG( 0xA5, 'l', 's', 't' )
+
+
+FT_END_HEADER
+
+#endif /* TTAGS_H_ */
+
+
+/* END */
diff --git a/engine/inc/freetype/ttunpat.h b/engine/inc/freetype/ttunpat.h
new file mode 100644
index 00000000..f5e41708
--- /dev/null
+++ b/engine/inc/freetype/ttunpat.h
@@ -0,0 +1,63 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ttunpat.h                                                              */
+/*                                                                         */
+/*    Definitions for the unpatented TrueType hinting system.              */
+/*    Obsolete, retained for backward compatibility.                       */
+/*                                                                         */
+/*  Copyright 2003-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  Written by Graham Asher <graham.asher@btinternet.com>                  */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef TTUNPAT_H_
+#define TTUNPAT_H_
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef FREETYPE_H
+#error "freetype.h of FreeType 1 has been loaded!"
+#error "Please fix the directory search order for header files"
+#error "so that freetype.h of FreeType 2 is found first."
+#endif
+
+
+FT_BEGIN_HEADER
+
+
+ /***************************************************************************
+  *
+  * @constant:
+  *   FT_PARAM_TAG_UNPATENTED_HINTING
+  *
+  * @description:
+  *   Deprecated.
+  *
+  *   Previously: A constant used as the tag of an @FT_Parameter structure to
+  *   indicate that unpatented methods only should be used by the TrueType
+  *   bytecode interpreter for a typeface opened by @FT_Open_Face.
+  *
+  */
+#define FT_PARAM_TAG_UNPATENTED_HINTING  FT_MAKE_TAG( 'u', 'n', 'p', 'a' )
+
+  /* */
+
+
+FT_END_HEADER
+
+
+#endif /* TTUNPAT_H_ */
+
+
+/* END */
diff --git a/engine/inc/ft2build.h b/engine/inc/ft2build.h
new file mode 100644
index 00000000..e7d808f3
--- /dev/null
+++ b/engine/inc/ft2build.h
@@ -0,0 +1,42 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ft2build.h                                                             */
+/*                                                                         */
+/*    FreeType 2 build and setup macros.                                   */
+/*                                                                         */
+/*  Copyright 1996-2017 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This is the `entry point' for FreeType header file inclusions.  It is */
+  /* the only header file which should be included directly; all other     */
+  /* FreeType header files should be accessed with macro names (after      */
+  /* including `ft2build.h').                                              */
+  /*                                                                       */
+  /* A typical example is                                                  */
+  /*                                                                       */
+  /*   #include <ft2build.h>                                               */
+  /*   #include FT_FREETYPE_H                                              */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#ifndef FT2BUILD_H_
+#define FT2BUILD_H_
+
+#include <freetype/config/ftheader.h>
+
+#endif /* FT2BUILD_H_ */
+
+
+/* END */
diff --git a/engine/inc/glm/common.hpp b/engine/inc/glm/common.hpp
new file mode 100644
index 00000000..25e7a376
--- /dev/null
+++ b/engine/inc/glm/common.hpp
@@ -0,0 +1,533 @@
+/// @ref core
+/// @file glm/common.hpp
+///
+/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+///
+/// @defgroup core_func_common Common functions
+/// @ingroup core
+///
+/// Provides GLSL common functions
+///
+/// These all operate component-wise. The description is per component.
+///
+/// Include <glm/common.hpp> to use these core features.
+
+#pragma once
+
+#include "detail/qualifier.hpp"
+#include "detail/_fixes.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_func_common
+	/// @{
+
+	/// Returns x if x >= 0; otherwise, it returns -x.
+	///
+	/// @tparam genType floating-point or signed integer; scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/abs.xml">GLSL abs man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType abs(genType x);
+
+	/// Returns x if x >= 0; otherwise, it returns -x.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or signed integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/abs.xml">GLSL abs man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> abs(vec<L, T, Q> const& x);
+
+	/// Returns 1.0 if x > 0, 0.0 if x == 0, or -1.0 if x < 0.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sign.xml">GLSL sign man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> sign(vec<L, T, Q> const& x);
+
+	/// Returns a value equal to the nearest integer that is less then or equal to x.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floor.xml">GLSL floor man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> floor(vec<L, T, Q> const& x);
+
+	/// Returns a value equal to the nearest integer to x
+	/// whose absolute value is not larger than the absolute value of x.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/trunc.xml">GLSL trunc man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> trunc(vec<L, T, Q> const& x);
+
+	/// Returns a value equal to the nearest integer to x.
+	/// The fraction 0.5 will round in a direction chosen by the
+	/// implementation, presumably the direction that is fastest.
+	/// This includes the possibility that round(x) returns the
+	/// same value as roundEven(x) for all values of x.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/round.xml">GLSL round man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> round(vec<L, T, Q> const& x);
+
+	/// Returns a value equal to the nearest integer to x.
+	/// A fractional part of 0.5 will round toward the nearest even
+	/// integer. (Both 3.5 and 4.5 for x will return 4.0.)
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/roundEven.xml">GLSL roundEven man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	/// @see <a href="http://developer.amd.com/documentation/articles/pages/New-Round-to-Even-Technique.aspx">New round to even technique</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> roundEven(vec<L, T, Q> const& x);
+
+	/// Returns a value equal to the nearest integer
+	/// that is greater than or equal to x.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/ceil.xml">GLSL ceil man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> ceil(vec<L, T, Q> const& x);
+
+	/// Return x - floor(x).
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/fract.xml">GLSL fract man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<typename genType>
+	GLM_FUNC_DECL genType fract(genType x);
+
+	/// Return x - floor(x).
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/fract.xml">GLSL fract man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> fract(vec<L, T, Q> const& x);
+
+	template<typename genType>
+	GLM_FUNC_DECL genType mod(genType x, genType y);
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> mod(vec<L, T, Q> const& x, T y);
+
+	/// Modulus. Returns x - y * floor(x / y)
+	/// for each component in x using the floating point value y.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types, include glm/gtc/integer for integer scalar types support
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> mod(vec<L, T, Q> const& x, vec<L, T, Q> const& y);
+
+	/// Returns the fractional part of x and sets i to the integer
+	/// part (as a whole number floating point value). Both the
+	/// return value and the output parameter will have the same
+	/// sign as x.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/modf.xml">GLSL modf man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<typename genType>
+	GLM_FUNC_DECL genType modf(genType x, genType& i);
+
+	/// Returns y if y < x; otherwise, it returns x.
+	///
+	/// @tparam genType Floating-point or integer; scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/min.xml">GLSL min man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType min(genType x, genType y);
+
+	/// Returns y if y < x; otherwise, it returns x.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/min.xml">GLSL min man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> min(vec<L, T, Q> const& x, T y);
+
+	/// Returns y if y < x; otherwise, it returns x.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/min.xml">GLSL min man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> min(vec<L, T, Q> const& x, vec<L, T, Q> const& y);
+
+	/// Returns y if x < y; otherwise, it returns x.
+	///
+	/// @tparam genType Floating-point or integer; scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/max.xml">GLSL max man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType max(genType x, genType y);
+
+	/// Returns y if x < y; otherwise, it returns x.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/max.xml">GLSL max man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> max(vec<L, T, Q> const& x, T y);
+
+	/// Returns y if x < y; otherwise, it returns x.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/max.xml">GLSL max man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> max(vec<L, T, Q> const& x, vec<L, T, Q> const& y);
+
+	/// Returns min(max(x, minVal), maxVal) for each component in x
+	/// using the floating-point values minVal and maxVal.
+	///
+	/// @tparam genType Floating-point or integer; scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/clamp.xml">GLSL clamp man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType clamp(genType x, genType minVal, genType maxVal);
+
+	/// Returns min(max(x, minVal), maxVal) for each component in x
+	/// using the floating-point values minVal and maxVal.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/clamp.xml">GLSL clamp man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> clamp(vec<L, T, Q> const& x, T minVal, T maxVal);
+
+	/// Returns min(max(x, minVal), maxVal) for each component in x
+	/// using the floating-point values minVal and maxVal.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/clamp.xml">GLSL clamp man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> clamp(vec<L, T, Q> const& x, vec<L, T, Q> const& minVal, vec<L, T, Q> const& maxVal);
+
+	/// If genTypeU is a floating scalar or vector:
+	/// Returns x * (1.0 - a) + y * a, i.e., the linear blend of
+	/// x and y using the floating-point value a.
+	/// The value for a is not restricted to the range [0, 1].
+	///
+	/// If genTypeU is a boolean scalar or vector:
+	/// Selects which vector each returned component comes
+	/// from. For a component of 'a' that is false, the
+	/// corresponding component of 'x' is returned. For a
+	/// component of 'a' that is true, the corresponding
+	/// component of 'y' is returned. Components of 'x' and 'y' that
+	/// are not selected are allowed to be invalid floating point
+	/// values and will have no effect on the results. Thus, this
+	/// provides different functionality than
+	/// genType mix(genType x, genType y, genType(a))
+	/// where a is a Boolean vector.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mix.xml">GLSL mix man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	///
+	/// @param[in]  x Value to interpolate.
+	/// @param[in]  y Value to interpolate.
+	/// @param[in]  a Interpolant.
+	///
+	/// @tparam	genTypeT Floating point scalar or vector.
+	/// @tparam genTypeU Floating point or boolean scalar or vector. It can't be a vector if it is the length of genTypeT.
+	///
+	/// @code
+	/// #include <glm/glm.hpp>
+	/// ...
+	/// float a;
+	/// bool b;
+	/// glm::dvec3 e;
+	/// glm::dvec3 f;
+	/// glm::vec4 g;
+	/// glm::vec4 h;
+	/// ...
+	/// glm::vec4 r = glm::mix(g, h, a); // Interpolate with a floating-point scalar two vectors.
+	/// glm::vec4 s = glm::mix(g, h, b); // Returns g or h;
+	/// glm::dvec3 t = glm::mix(e, f, a); // Types of the third parameter is not required to match with the first and the second.
+	/// glm::vec4 u = glm::mix(g, h, r); // Interpolations can be perform per component with a vector for the last parameter.
+	/// @endcode
+	template<typename genTypeT, typename genTypeU>
+	GLM_FUNC_DECL genTypeT mix(genTypeT x, genTypeT y, genTypeU a);
+
+	template<length_t L, typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> mix(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, U, Q> const& a);
+
+	template<length_t L, typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> mix(vec<L, T, Q> const& x, vec<L, T, Q> const& y, U a);
+
+	/// Returns 0.0 if x < edge, otherwise it returns 1.0 for each component of a genType.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<typename genType>
+	GLM_FUNC_DECL genType step(genType edge, genType x);
+
+	/// Returns 0.0 if x < edge, otherwise it returns 1.0.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> step(T edge, vec<L, T, Q> const& x);
+
+	/// Returns 0.0 if x < edge, otherwise it returns 1.0.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> step(vec<L, T, Q> const& edge, vec<L, T, Q> const& x);
+
+	/// Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and
+	/// performs smooth Hermite interpolation between 0 and 1
+	/// when edge0 < x < edge1. This is useful in cases where
+	/// you would want a threshold function with a smooth
+	/// transition. This is equivalent to:
+	/// genType t;
+	/// t = clamp ((x - edge0) / (edge1 - edge0), 0, 1);
+	/// return t * t * (3 - 2 * t);
+	/// Results are undefined if edge0 >= edge1.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/smoothstep.xml">GLSL smoothstep man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<typename genType>
+	GLM_FUNC_DECL genType smoothstep(genType edge0, genType edge1, genType x);
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> smoothstep(T edge0, T edge1, vec<L, T, Q> const& x);
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> smoothstep(vec<L, T, Q> const& edge0, vec<L, T, Q> const& edge1, vec<L, T, Q> const& x);
+
+	/// Returns true if x holds a NaN (not a number)
+	/// representation in the underlying implementation's set of
+	/// floating point representations. Returns false otherwise,
+	/// including for implementations with no NaN
+	/// representations.
+	///
+	/// /!\ When using compiler fast math, this function may fail.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isnan.xml">GLSL isnan man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, bool, Q> isnan(vec<L, T, Q> const& x);
+
+	/// Returns true if x holds a positive infinity or negative
+	/// infinity representation in the underlying implementation's
+	/// set of floating point representations. Returns false
+	/// otherwise, including for implementations with no infinity
+	/// representations.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isinf.xml">GLSL isinf man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, bool, Q> isinf(vec<L, T, Q> const& x);
+
+	/// Returns a signed integer value representing
+	/// the encoding of a floating-point value. The floating-point
+	/// value's bit-level representation is preserved.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToInt.xml">GLSL floatBitsToInt man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	GLM_FUNC_DECL int floatBitsToInt(float const& v);
+
+	/// Returns a signed integer value representing
+	/// the encoding of a floating-point value. The floatingpoint
+	/// value's bit-level representation is preserved.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToInt.xml">GLSL floatBitsToInt man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, qualifier Q>
+	GLM_FUNC_DECL vec<L, int, Q> floatBitsToInt(vec<L, float, Q> const& v);
+
+	/// Returns a unsigned integer value representing
+	/// the encoding of a floating-point value. The floatingpoint
+	/// value's bit-level representation is preserved.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToUint.xml">GLSL floatBitsToUint man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	GLM_FUNC_DECL uint floatBitsToUint(float const& v);
+
+	/// Returns a unsigned integer value representing
+	/// the encoding of a floating-point value. The floatingpoint
+	/// value's bit-level representation is preserved.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToUint.xml">GLSL floatBitsToUint man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, qualifier Q>
+	GLM_FUNC_DECL vec<L, uint, Q> floatBitsToUint(vec<L, float, Q> const& v);
+
+	/// Returns a floating-point value corresponding to a signed
+	/// integer encoding of a floating-point value.
+	/// If an inf or NaN is passed in, it will not signal, and the
+	/// resulting floating point value is unspecified. Otherwise,
+	/// the bit-level representation is preserved.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/intBitsToFloat.xml">GLSL intBitsToFloat man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	GLM_FUNC_DECL float intBitsToFloat(int const& v);
+
+	/// Returns a floating-point value corresponding to a signed
+	/// integer encoding of a floating-point value.
+	/// If an inf or NaN is passed in, it will not signal, and the
+	/// resulting floating point value is unspecified. Otherwise,
+	/// the bit-level representation is preserved.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/intBitsToFloat.xml">GLSL intBitsToFloat man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, qualifier Q>
+	GLM_FUNC_DECL vec<L, float, Q> intBitsToFloat(vec<L, int, Q> const& v);
+
+	/// Returns a floating-point value corresponding to a
+	/// unsigned integer encoding of a floating-point value.
+	/// If an inf or NaN is passed in, it will not signal, and the
+	/// resulting floating point value is unspecified. Otherwise,
+	/// the bit-level representation is preserved.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uintBitsToFloat.xml">GLSL uintBitsToFloat man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	GLM_FUNC_DECL float uintBitsToFloat(uint const& v);
+
+	/// Returns a floating-point value corresponding to a
+	/// unsigned integer encoding of a floating-point value.
+	/// If an inf or NaN is passed in, it will not signal, and the
+	/// resulting floating point value is unspecified. Otherwise,
+	/// the bit-level representation is preserved.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uintBitsToFloat.xml">GLSL uintBitsToFloat man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<length_t L, qualifier Q>
+	GLM_FUNC_DECL vec<L, float, Q> uintBitsToFloat(vec<L, uint, Q> const& v);
+
+	/// Computes and returns a * b + c.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/fma.xml">GLSL fma man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<typename genType>
+	GLM_FUNC_DECL genType fma(genType const& a, genType const& b, genType const& c);
+
+	/// Splits x into a floating-point significand in the range
+	/// [0.5, 1.0) and an integral exponent of two, such that:
+	/// x = significand * exp(2, exponent)
+	///
+	/// The significand is returned by the function and the
+	/// exponent is returned in the parameter exp. For a
+	/// floating-point value of zero, the significant and exponent
+	/// are both zero. For a floating-point value that is an
+	/// infinity or is not a number, the results are undefined.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/frexp.xml">GLSL frexp man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<typename genType, typename genIType>
+	GLM_FUNC_DECL genType frexp(genType const& x, genIType& exp);
+
+	/// Builds a floating-point number from x and the
+	/// corresponding integral exponent of two in exp, returning:
+	/// significand * exp(2, exponent)
+	///
+	/// If this product is too large to be represented in the
+	/// floating-point type, the result is undefined.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/ldexp.xml">GLSL ldexp man page</a>;
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<typename genType, typename genIType>
+	GLM_FUNC_DECL genType ldexp(genType const& x, genIType const& exp);
+
+	/// @}
+}//namespace glm
+
+#include "detail/func_common.inl"
+
diff --git a/engine/inc/glm/detail/_features.hpp b/engine/inc/glm/detail/_features.hpp
new file mode 100644
index 00000000..b0cbe9ff
--- /dev/null
+++ b/engine/inc/glm/detail/_features.hpp
@@ -0,0 +1,394 @@
+#pragma once
+
+// #define GLM_CXX98_EXCEPTIONS
+// #define GLM_CXX98_RTTI
+
+// #define GLM_CXX11_RVALUE_REFERENCES
+// Rvalue references - GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2118.html
+
+// GLM_CXX11_TRAILING_RETURN
+// Rvalue references for *this - GCC not supported
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2439.htm
+
+// GLM_CXX11_NONSTATIC_MEMBER_INIT
+// Initialization of class objects by rvalues - GCC any
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1610.html
+
+// GLM_CXX11_NONSTATIC_MEMBER_INIT
+// Non-static data member initializers - GCC 4.7
+// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2008/n2756.htm
+
+// #define GLM_CXX11_VARIADIC_TEMPLATE
+// Variadic templates - GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2242.pdf
+
+//
+// Extending variadic template template parameters - GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2555.pdf
+
+// #define GLM_CXX11_GENERALIZED_INITIALIZERS
+// Initializer lists - GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2672.htm
+
+// #define GLM_CXX11_STATIC_ASSERT
+// Static assertions - GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1720.html
+
+// #define GLM_CXX11_AUTO_TYPE
+// auto-typed variables - GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1984.pdf
+
+// #define GLM_CXX11_AUTO_TYPE
+// Multi-declarator auto - GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1737.pdf
+
+// #define GLM_CXX11_AUTO_TYPE
+// Removal of auto as a storage-class specifier - GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2546.htm
+
+// #define GLM_CXX11_AUTO_TYPE
+// New function declarator syntax - GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2541.htm
+
+// #define GLM_CXX11_LAMBDAS
+// New wording for C++0x lambdas - GCC 4.5
+// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2927.pdf
+
+// #define GLM_CXX11_DECLTYPE
+// Declared type of an expression - GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2343.pdf
+
+//
+// Right angle brackets - GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1757.html
+
+//
+// Default template arguments for function templates	DR226	GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#226
+
+//
+// Solving the SFINAE problem for expressions	DR339	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2634.html
+
+// #define GLM_CXX11_ALIAS_TEMPLATE
+// Template aliases	N2258	GCC 4.7
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2258.pdf
+
+//
+// Extern templates	N1987	Yes
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1987.htm
+
+// #define GLM_CXX11_NULLPTR
+// Null pointer constant	N2431	GCC 4.6
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2431.pdf
+
+// #define GLM_CXX11_STRONG_ENUMS
+// Strongly-typed enums	N2347	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2347.pdf
+
+//
+// Forward declarations for enums	N2764	GCC 4.6
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2764.pdf
+
+//
+// Generalized attributes	N2761	GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2761.pdf
+
+//
+// Generalized constant expressions	N2235	GCC 4.6
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2235.pdf
+
+//
+// Alignment support	N2341	GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2341.pdf
+
+// #define GLM_CXX11_DELEGATING_CONSTRUCTORS
+// Delegating constructors	N1986	GCC 4.7
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1986.pdf
+
+//
+// Inheriting constructors	N2540	GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2540.htm
+
+// #define GLM_CXX11_EXPLICIT_CONVERSIONS
+// Explicit conversion operators	N2437	GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2437.pdf
+
+//
+// New character types	N2249	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2249.html
+
+//
+// Unicode string literals	N2442	GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2442.htm
+
+//
+// Raw string literals	N2442	GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2442.htm
+
+//
+// Universal character name literals	N2170	GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2170.html
+
+// #define GLM_CXX11_USER_LITERALS
+// User-defined literals		N2765	GCC 4.7
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2765.pdf
+
+//
+// Standard Layout Types	N2342	GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2342.htm
+
+// #define GLM_CXX11_DEFAULTED_FUNCTIONS
+// #define GLM_CXX11_DELETED_FUNCTIONS
+// Defaulted and deleted functions	N2346	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2346.htm
+
+//
+// Extended friend declarations	N1791	GCC 4.7
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1791.pdf
+
+//
+// Extending sizeof	N2253	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2253.html
+
+// #define GLM_CXX11_INLINE_NAMESPACES
+// Inline namespaces	N2535	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2535.htm
+
+// #define GLM_CXX11_UNRESTRICTED_UNIONS
+// Unrestricted unions	N2544	GCC 4.6
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2544.pdf
+
+// #define GLM_CXX11_LOCAL_TYPE_TEMPLATE_ARGS
+// Local and unnamed types as template arguments	N2657	GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm
+
+// #define GLM_CXX11_RANGE_FOR
+// Range-based for	N2930	GCC 4.6
+// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2930.html
+
+// #define GLM_CXX11_OVERRIDE_CONTROL
+// Explicit virtual overrides	N2928 N3206 N3272	GCC 4.7
+// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2928.htm
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3206.htm
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3272.htm
+
+//
+// Minimal support for garbage collection and reachability-based leak detection	N2670	No
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2670.htm
+
+// #define GLM_CXX11_NOEXCEPT
+// Allowing move constructors to throw [noexcept]	N3050	GCC 4.6 (core language only)
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3050.html
+
+//
+// Defining move special member functions	N3053	GCC 4.6
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3053.html
+
+//
+// Sequence points	N2239	Yes
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2239.html
+
+//
+// Atomic operations	N2427	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2239.html
+
+//
+// Strong Compare and Exchange	N2748	GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html
+
+//
+// Bidirectional Fences	N2752	GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2752.htm
+
+//
+// Memory model	N2429	GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2429.htm
+
+//
+// Data-dependency ordering: atomics and memory model	N2664	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2664.htm
+
+//
+// Propagating exceptions	N2179	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2179.html
+
+//
+// Abandoning a process and at_quick_exit	N2440	GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2440.htm
+
+//
+// Allow atomics use in signal handlers	N2547	Yes
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2547.htm
+
+//
+// Thread-local storage	N2659	GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2659.htm
+
+//
+// Dynamic initialization and destruction with concurrency	N2660	GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2660.htm
+
+//
+// __func__ predefined identifier	N2340	GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2340.htm
+
+//
+// C99 preprocessor	N1653	GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1653.htm
+
+//
+// long long	N1811	GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1811.pdf
+
+//
+// Extended integral types	N1988	Yes
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1988.pdf
+
+#if(GLM_COMPILER & GLM_COMPILER_GCC)
+
+#	define GLM_CXX11_STATIC_ASSERT
+
+#elif(GLM_COMPILER & GLM_COMPILER_CLANG)
+#	if(__has_feature(cxx_exceptions))
+#		define GLM_CXX98_EXCEPTIONS
+#	endif
+
+#	if(__has_feature(cxx_rtti))
+#		define GLM_CXX98_RTTI
+#	endif
+
+#	if(__has_feature(cxx_access_control_sfinae))
+#		define GLM_CXX11_ACCESS_CONTROL_SFINAE
+#	endif
+
+#	if(__has_feature(cxx_alias_templates))
+#		define GLM_CXX11_ALIAS_TEMPLATE
+#	endif
+
+#	if(__has_feature(cxx_alignas))
+#		define GLM_CXX11_ALIGNAS
+#	endif
+
+#	if(__has_feature(cxx_attributes))
+#		define GLM_CXX11_ATTRIBUTES
+#	endif
+
+#	if(__has_feature(cxx_constexpr))
+#		define GLM_CXX11_CONSTEXPR
+#	endif
+
+#	if(__has_feature(cxx_decltype))
+#		define GLM_CXX11_DECLTYPE
+#	endif
+
+#	if(__has_feature(cxx_default_function_template_args))
+#		define GLM_CXX11_DEFAULT_FUNCTION_TEMPLATE_ARGS
+#	endif
+
+#	if(__has_feature(cxx_defaulted_functions))
+#		define GLM_CXX11_DEFAULTED_FUNCTIONS
+#	endif
+
+#	if(__has_feature(cxx_delegating_constructors))
+#		define GLM_CXX11_DELEGATING_CONSTRUCTORS
+#	endif
+
+#	if(__has_feature(cxx_deleted_functions))
+#		define GLM_CXX11_DELETED_FUNCTIONS
+#	endif
+
+#	if(__has_feature(cxx_explicit_conversions))
+#		define GLM_CXX11_EXPLICIT_CONVERSIONS
+#	endif
+
+#	if(__has_feature(cxx_generalized_initializers))
+#		define GLM_CXX11_GENERALIZED_INITIALIZERS
+#	endif
+
+#	if(__has_feature(cxx_implicit_moves))
+#		define GLM_CXX11_IMPLICIT_MOVES
+#	endif
+
+#	if(__has_feature(cxx_inheriting_constructors))
+#		define GLM_CXX11_INHERITING_CONSTRUCTORS
+#	endif
+
+#	if(__has_feature(cxx_inline_namespaces))
+#		define GLM_CXX11_INLINE_NAMESPACES
+#	endif
+
+#	if(__has_feature(cxx_lambdas))
+#		define GLM_CXX11_LAMBDAS
+#	endif
+
+#	if(__has_feature(cxx_local_type_template_args))
+#		define GLM_CXX11_LOCAL_TYPE_TEMPLATE_ARGS
+#	endif
+
+#	if(__has_feature(cxx_noexcept))
+#		define GLM_CXX11_NOEXCEPT
+#	endif
+
+#	if(__has_feature(cxx_nonstatic_member_init))
+#		define GLM_CXX11_NONSTATIC_MEMBER_INIT
+#	endif
+
+#	if(__has_feature(cxx_nullptr))
+#		define GLM_CXX11_NULLPTR
+#	endif
+
+#	if(__has_feature(cxx_override_control))
+#		define GLM_CXX11_OVERRIDE_CONTROL
+#	endif
+
+#	if(__has_feature(cxx_reference_qualified_functions))
+#		define GLM_CXX11_REFERENCE_QUALIFIED_FUNCTIONS
+#	endif
+
+#	if(__has_feature(cxx_range_for))
+#		define GLM_CXX11_RANGE_FOR
+#	endif
+
+#	if(__has_feature(cxx_raw_string_literals))
+#		define GLM_CXX11_RAW_STRING_LITERALS
+#	endif
+
+#	if(__has_feature(cxx_rvalue_references))
+#		define GLM_CXX11_RVALUE_REFERENCES
+#	endif
+
+#	if(__has_feature(cxx_static_assert))
+#		define GLM_CXX11_STATIC_ASSERT
+#	endif
+
+#	if(__has_feature(cxx_auto_type))
+#		define GLM_CXX11_AUTO_TYPE
+#	endif
+
+#	if(__has_feature(cxx_strong_enums))
+#		define GLM_CXX11_STRONG_ENUMS
+#	endif
+
+#	if(__has_feature(cxx_trailing_return))
+#		define GLM_CXX11_TRAILING_RETURN
+#	endif
+
+#	if(__has_feature(cxx_unicode_literals))
+#		define GLM_CXX11_UNICODE_LITERALS
+#	endif
+
+#	if(__has_feature(cxx_unrestricted_unions))
+#		define GLM_CXX11_UNRESTRICTED_UNIONS
+#	endif
+
+#	if(__has_feature(cxx_user_literals))
+#		define GLM_CXX11_USER_LITERALS
+#	endif
+
+#	if(__has_feature(cxx_variadic_templates))
+#		define GLM_CXX11_VARIADIC_TEMPLATES
+#	endif
+
+#endif//(GLM_COMPILER & GLM_COMPILER_CLANG)
diff --git a/engine/inc/glm/detail/_fixes.hpp b/engine/inc/glm/detail/_fixes.hpp
new file mode 100644
index 00000000..a503c7c0
--- /dev/null
+++ b/engine/inc/glm/detail/_fixes.hpp
@@ -0,0 +1,27 @@
+#include <cmath>
+
+//! Workaround for compatibility with other libraries
+#ifdef max
+#undef max
+#endif
+
+//! Workaround for compatibility with other libraries
+#ifdef min
+#undef min
+#endif
+
+//! Workaround for Android
+#ifdef isnan
+#undef isnan
+#endif
+
+//! Workaround for Android
+#ifdef isinf
+#undef isinf
+#endif
+
+//! Workaround for Chrone Native Client
+#ifdef log2
+#undef log2
+#endif
+
diff --git a/engine/inc/glm/detail/_noise.hpp b/engine/inc/glm/detail/_noise.hpp
new file mode 100644
index 00000000..5a874a02
--- /dev/null
+++ b/engine/inc/glm/detail/_noise.hpp
@@ -0,0 +1,81 @@
+#pragma once
+
+#include "../common.hpp"
+
+namespace glm{
+namespace detail
+{
+	template<typename T>
+	GLM_FUNC_QUALIFIER T mod289(T const& x)
+	{
+		return x - floor(x * (static_cast<T>(1.0) / static_cast<T>(289.0))) * static_cast<T>(289.0);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER T permute(T const& x)
+	{
+		return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<2, T, Q> permute(vec<2, T, Q> const& x)
+	{
+		return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> permute(vec<3, T, Q> const& x)
+	{
+		return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, T, Q> permute(vec<4, T, Q> const& x)
+	{
+		return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER T taylorInvSqrt(T const& r)
+	{
+		return static_cast<T>(1.79284291400159) - static_cast<T>(0.85373472095314) * r;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<2, T, Q> taylorInvSqrt(vec<2, T, Q> const& r)
+	{
+		return static_cast<T>(1.79284291400159) - static_cast<T>(0.85373472095314) * r;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> taylorInvSqrt(vec<3, T, Q> const& r)
+	{
+		return static_cast<T>(1.79284291400159) - static_cast<T>(0.85373472095314) * r;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, T, Q> taylorInvSqrt(vec<4, T, Q> const& r)
+	{
+		return static_cast<T>(1.79284291400159) - static_cast<T>(0.85373472095314) * r;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<2, T, Q> fade(vec<2, T, Q> const& t)
+	{
+		return (t * t * t) * (t * (t * static_cast<T>(6) - static_cast<T>(15)) + static_cast<T>(10));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> fade(vec<3, T, Q> const& t)
+	{
+		return (t * t * t) * (t * (t * static_cast<T>(6) - static_cast<T>(15)) + static_cast<T>(10));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, T, Q> fade(vec<4, T, Q> const& t)
+	{
+		return (t * t * t) * (t * (t * static_cast<T>(6) - static_cast<T>(15)) + static_cast<T>(10));
+	}
+}//namespace detail
+}//namespace glm
+
diff --git a/engine/inc/glm/detail/_swizzle.hpp b/engine/inc/glm/detail/_swizzle.hpp
new file mode 100644
index 00000000..87896ef4
--- /dev/null
+++ b/engine/inc/glm/detail/_swizzle.hpp
@@ -0,0 +1,804 @@
+#pragma once
+
+namespace glm{
+namespace detail
+{
+	// Internal class for implementing swizzle operators
+	template<typename T, int N>
+	struct _swizzle_base0
+	{
+	protected:
+		GLM_FUNC_QUALIFIER T& elem(size_t i){ return (reinterpret_cast<T*>(_buffer))[i]; }
+		GLM_FUNC_QUALIFIER T const& elem(size_t i) const{ return (reinterpret_cast<const T*>(_buffer))[i]; }
+
+		// Use an opaque buffer to *ensure* the compiler doesn't call a constructor.
+		// The size 1 buffer is assumed to aligned to the actual members so that the
+		// elem()
+		char    _buffer[1];
+	};
+
+	template<int N, typename T, qualifier Q, int E0, int E1, int E2, int E3, bool Aligned>
+	struct _swizzle_base1 : public _swizzle_base0<T, N>
+	{
+	};
+
+	template<typename T, qualifier Q, int E0, int E1, bool Aligned>
+	struct _swizzle_base1<2, T, Q, E0,E1,-1,-2, Aligned> : public _swizzle_base0<T, 2>
+	{
+		GLM_FUNC_QUALIFIER vec<2, T, Q> operator ()()  const { return vec<2, T, Q>(this->elem(E0), this->elem(E1)); }
+	};
+
+	template<typename T, qualifier Q, int E0, int E1, int E2, bool Aligned>
+	struct _swizzle_base1<3, T, Q, E0,E1,E2,-1, Aligned> : public _swizzle_base0<T, 3>
+	{
+		GLM_FUNC_QUALIFIER vec<3, T, Q> operator ()()  const { return vec<3, T, Q>(this->elem(E0), this->elem(E1), this->elem(E2)); }
+	};
+
+	template<typename T, qualifier Q, int E0, int E1, int E2, int E3, bool Aligned>
+	struct _swizzle_base1<4, T, Q, E0,E1,E2,E3, Aligned> : public _swizzle_base0<T, 4>
+	{
+		GLM_FUNC_QUALIFIER vec<4, T, Q> operator ()()  const { return vec<4, T, Q>(this->elem(E0), this->elem(E1), this->elem(E2), this->elem(E3)); }
+	};
+
+	// Internal class for implementing swizzle operators
+	/*
+		Template parameters:
+
+		T			= type of scalar values (e.g. float, double)
+		N			= number of components in the vector (e.g. 3)
+		E0...3		= what index the n-th element of this swizzle refers to in the unswizzled vec
+
+		DUPLICATE_ELEMENTS = 1 if there is a repeated element, 0 otherwise (used to specialize swizzles
+			containing duplicate elements so that they cannot be used as r-values).
+	*/
+	template<int N, typename T, qualifier Q, int E0, int E1, int E2, int E3, int DUPLICATE_ELEMENTS>
+	struct _swizzle_base2 : public _swizzle_base1<N, T, Q, E0,E1,E2,E3, detail::is_aligned<Q>::value>
+	{
+		struct op_equal
+		{
+			GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e = t; }
+		};
+
+		struct op_minus
+		{
+			GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e -= t; }
+		};
+
+		struct op_plus
+		{
+			GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e += t; }
+		};
+
+		struct op_mul
+		{
+			GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e *= t; }
+		};
+
+		struct op_div
+		{
+			GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e /= t; }
+		};
+
+	public:
+		GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const T& t)
+		{
+			for (int i = 0; i < N; ++i)
+				(*this)[i] = t;
+			return *this;
+		}
+
+		GLM_FUNC_QUALIFIER _swizzle_base2& operator= (vec<N, T, Q> const& that)
+		{
+			_apply_op(that, op_equal());
+			return *this;
+		}
+
+		GLM_FUNC_QUALIFIER void operator -= (vec<N, T, Q> const& that)
+		{
+			_apply_op(that, op_minus());
+		}
+
+		GLM_FUNC_QUALIFIER void operator += (vec<N, T, Q> const& that)
+		{
+			_apply_op(that, op_plus());
+		}
+
+		GLM_FUNC_QUALIFIER void operator *= (vec<N, T, Q> const& that)
+		{
+			_apply_op(that, op_mul());
+		}
+
+		GLM_FUNC_QUALIFIER void operator /= (vec<N, T, Q> const& that)
+		{
+			_apply_op(that, op_div());
+		}
+
+		GLM_FUNC_QUALIFIER T& operator[](size_t i)
+		{
+			const int offset_dst[4] = { E0, E1, E2, E3 };
+			return this->elem(offset_dst[i]);
+		}
+		GLM_FUNC_QUALIFIER T operator[](size_t i) const
+		{
+			const int offset_dst[4] = { E0, E1, E2, E3 };
+			return this->elem(offset_dst[i]);
+		}
+
+	protected:
+		template<typename U>
+		GLM_FUNC_QUALIFIER void _apply_op(vec<N, T, Q> const& that, const U& op)
+		{
+			// Make a copy of the data in this == &that.
+			// The copier should optimize out the copy in cases where the function is
+			// properly inlined and the copy is not necessary.
+			T t[N];
+			for (int i = 0; i < N; ++i)
+				t[i] = that[i];
+			for (int i = 0; i < N; ++i)
+				op( (*this)[i], t[i] );
+		}
+	};
+
+	// Specialization for swizzles containing duplicate elements.  These cannot be modified.
+	template<int N, typename T, qualifier Q, int E0, int E1, int E2, int E3>
+	struct _swizzle_base2<N, T, Q, E0,E1,E2,E3, 1> : public _swizzle_base1<N, T, Q, E0,E1,E2,E3, detail::is_aligned<Q>::value>
+	{
+		struct Stub {};
+
+		GLM_FUNC_QUALIFIER _swizzle_base2& operator= (Stub const&) { return *this; }
+
+		GLM_FUNC_QUALIFIER T operator[]  (size_t i) const
+		{
+			const int offset_dst[4] = { E0, E1, E2, E3 };
+			return this->elem(offset_dst[i]);
+		}
+	};
+
+	template<int N, typename T, qualifier Q, int E0, int E1, int E2, int E3>
+	struct _swizzle : public _swizzle_base2<N, T, Q, E0, E1, E2, E3, (E0 == E1 || E0 == E2 || E0 == E3 || E1 == E2 || E1 == E3 || E2 == E3)>
+	{
+		typedef _swizzle_base2<N, T, Q, E0, E1, E2, E3, (E0 == E1 || E0 == E2 || E0 == E3 || E1 == E2 || E1 == E3 || E2 == E3)> base_type;
+
+		using base_type::operator=;
+
+		GLM_FUNC_QUALIFIER operator vec<N, T, Q> () const { return (*this)(); }
+	};
+
+//
+// To prevent the C++ syntax from getting entirely overwhelming, define some alias macros
+//
+#define GLM_SWIZZLE_TEMPLATE1   template<int N, typename T, qualifier Q, int E0, int E1, int E2, int E3>
+#define GLM_SWIZZLE_TEMPLATE2   template<int N, typename T, qualifier Q, int E0, int E1, int E2, int E3, int F0, int F1, int F2, int F3>
+#define GLM_SWIZZLE_TYPE1       _swizzle<N, T, Q, E0, E1, E2, E3>
+#define GLM_SWIZZLE_TYPE2       _swizzle<N, T, Q, F0, F1, F2, F3>
+
+//
+// Wrapper for a binary operator (e.g. u.yy + v.zy)
+//
+#define GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND)                 \
+	GLM_SWIZZLE_TEMPLATE2                                                          \
+	GLM_FUNC_QUALIFIER vec<N, T, Q> operator OPERAND ( const GLM_SWIZZLE_TYPE1& a, const GLM_SWIZZLE_TYPE2& b)  \
+	{                                                                               \
+		return a() OPERAND b();                                                     \
+	}                                                                               \
+	GLM_SWIZZLE_TEMPLATE1                                                          \
+	GLM_FUNC_QUALIFIER vec<N, T, Q> operator OPERAND ( const GLM_SWIZZLE_TYPE1& a, const vec<N, T, Q>& b)                   \
+	{                                                                               \
+		return a() OPERAND b;                                                       \
+	}                                                                               \
+	GLM_SWIZZLE_TEMPLATE1                                                          \
+	GLM_FUNC_QUALIFIER vec<N, T, Q> operator OPERAND ( const vec<N, T, Q>& a, const GLM_SWIZZLE_TYPE1& b)                   \
+	{                                                                               \
+		return a OPERAND b();                                                       \
+	}
+
+//
+// Wrapper for a operand between a swizzle and a binary (e.g. 1.0f - u.xyz)
+//
+#define GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND)								\
+	GLM_SWIZZLE_TEMPLATE1																		\
+	GLM_FUNC_QUALIFIER vec<N, T, Q> operator OPERAND ( const GLM_SWIZZLE_TYPE1& a, const T& b)	\
+	{																							\
+		return a() OPERAND b;																	\
+	}																							\
+	GLM_SWIZZLE_TEMPLATE1																		\
+	GLM_FUNC_QUALIFIER vec<N, T, Q> operator OPERAND ( const T& a, const GLM_SWIZZLE_TYPE1& b)	\
+	{																							\
+		return a OPERAND b();																	\
+	}
+
+//
+// Macro for wrapping a function taking one argument (e.g. abs())
+//
+#define GLM_SWIZZLE_FUNCTION_1_ARGS(RETURN_TYPE,FUNCTION)												\
+	GLM_SWIZZLE_TEMPLATE1																				\
+	GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a)		\
+	{																									\
+		return FUNCTION(a());																			\
+	}
+
+//
+// Macro for wrapping a function taking two vector arguments (e.g. dot()).
+//
+#define GLM_SWIZZLE_FUNCTION_2_ARGS(RETURN_TYPE,FUNCTION)                                                       \
+	GLM_SWIZZLE_TEMPLATE2                                                                                       \
+	GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const GLM_SWIZZLE_TYPE2& b) \
+	{                                                                                                           \
+		return FUNCTION(a(), b());                                                                              \
+	}                                                                                                           \
+	GLM_SWIZZLE_TEMPLATE1                                                                                       \
+	GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const GLM_SWIZZLE_TYPE1& b) \
+	{                                                                                                           \
+		return FUNCTION(a(), b());                                                                              \
+	}                                                                                                           \
+	GLM_SWIZZLE_TEMPLATE1                                                                                       \
+	GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const typename V& b)         \
+	{                                                                                                           \
+		return FUNCTION(a(), b);                                                                                \
+	}                                                                                                           \
+	GLM_SWIZZLE_TEMPLATE1                                                                                       \
+	GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const V& a, const GLM_SWIZZLE_TYPE1& b)                  \
+	{                                                                                                           \
+		return FUNCTION(a, b());                                                                                \
+	}
+
+//
+// Macro for wrapping a function take 2 vec arguments followed by a scalar (e.g. mix()).
+//
+#define GLM_SWIZZLE_FUNCTION_2_ARGS_SCALAR(RETURN_TYPE,FUNCTION)                                                             \
+	GLM_SWIZZLE_TEMPLATE2                                                                                                    \
+	GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const GLM_SWIZZLE_TYPE2& b, const T& c)   \
+	{                                                                                                                         \
+		return FUNCTION(a(), b(), c);                                                                                         \
+	}                                                                                                                         \
+	GLM_SWIZZLE_TEMPLATE1                                                                                                    \
+	GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const GLM_SWIZZLE_TYPE1& b, const T& c)   \
+	{                                                                                                                         \
+		return FUNCTION(a(), b(), c);                                                                                         \
+	}                                                                                                                         \
+	GLM_SWIZZLE_TEMPLATE1                                                                                                    \
+	GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const typename S0::vec_type& b, const T& c)\
+	{                                                                                                                         \
+		return FUNCTION(a(), b, c);                                                                                           \
+	}                                                                                                                         \
+	GLM_SWIZZLE_TEMPLATE1                                                                                                    \
+	GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const typename V& a, const GLM_SWIZZLE_TYPE1& b, const T& c)           \
+	{                                                                                                                         \
+		return FUNCTION(a, b(), c);                                                                                           \
+	}
+
+}//namespace detail
+}//namespace glm
+
+namespace glm
+{
+	namespace detail
+	{
+		GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(-)
+		GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(*)
+		GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(+)
+		GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(-)
+		GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(*)
+		GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(/)
+	}
+
+	//
+	// Swizzles are distinct types from the unswizzled type.  The below macros will
+	// provide template specializations for the swizzle types for the given functions
+	// so that the compiler does not have any ambiguity to choosing how to handle
+	// the function.
+	//
+	// The alternative is to use the operator()() when calling the function in order
+	// to explicitly convert the swizzled type to the unswizzled type.
+	//
+
+	//GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type,    abs);
+	//GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type,    acos);
+	//GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type,    acosh);
+	//GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type,    all);
+	//GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type,    any);
+
+	//GLM_SWIZZLE_FUNCTION_2_ARGS(value_type,  dot);
+	//GLM_SWIZZLE_FUNCTION_2_ARGS(vec_type,    cross);
+	//GLM_SWIZZLE_FUNCTION_2_ARGS(vec_type,    step);
+	//GLM_SWIZZLE_FUNCTION_2_ARGS_SCALAR(vec_type, mix);
+}
+
+#define GLM_SWIZZLE2_2_MEMBERS(T, Q, E0,E1) \
+	struct { detail::_swizzle<2, T, Q, 0,0,-1,-2> E0 ## E0; }; \
+	struct { detail::_swizzle<2, T, Q, 0,1,-1,-2> E0 ## E1; }; \
+	struct { detail::_swizzle<2, T, Q, 1,0,-1,-2> E1 ## E0; }; \
+	struct { detail::_swizzle<2, T, Q, 1,1,-1,-2> E1 ## E1; };
+
+#define GLM_SWIZZLE2_3_MEMBERS(T, Q, E0,E1) \
+	struct { detail::_swizzle<3,T, Q, 0,0,0,-1> E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3,T, Q, 0,0,1,-1> E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3,T, Q, 0,1,0,-1> E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3,T, Q, 0,1,1,-1> E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3,T, Q, 1,0,0,-1> E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3,T, Q, 1,0,1,-1> E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3,T, Q, 1,1,0,-1> E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3,T, Q, 1,1,1,-1> E1 ## E1 ## E1; };
+
+#define GLM_SWIZZLE2_4_MEMBERS(T, Q, E0,E1) \
+	struct { detail::_swizzle<4,T, Q, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 1,1,1,1> E1 ## E1 ## E1 ## E1; };
+
+#define GLM_SWIZZLE3_2_MEMBERS(T, Q, E0,E1,E2) \
+	struct { detail::_swizzle<2,T, Q, 0,0,-1,-2> E0 ## E0; }; \
+	struct { detail::_swizzle<2,T, Q, 0,1,-1,-2> E0 ## E1; }; \
+	struct { detail::_swizzle<2,T, Q, 0,2,-1,-2> E0 ## E2; }; \
+	struct { detail::_swizzle<2,T, Q, 1,0,-1,-2> E1 ## E0; }; \
+	struct { detail::_swizzle<2,T, Q, 1,1,-1,-2> E1 ## E1; }; \
+	struct { detail::_swizzle<2,T, Q, 1,2,-1,-2> E1 ## E2; }; \
+	struct { detail::_swizzle<2,T, Q, 2,0,-1,-2> E2 ## E0; }; \
+	struct { detail::_swizzle<2,T, Q, 2,1,-1,-2> E2 ## E1; }; \
+	struct { detail::_swizzle<2,T, Q, 2,2,-1,-2> E2 ## E2; };
+
+#define GLM_SWIZZLE3_3_MEMBERS(T, Q ,E0,E1,E2) \
+	struct { detail::_swizzle<3, T, Q, 0,0,0,-1> E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 0,0,1,-1> E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 0,0,2,-1> E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 0,1,0,-1> E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 0,1,1,-1> E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 0,1,2,-1> E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 0,2,0,-1> E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 0,2,1,-1> E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 0,2,2,-1> E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 1,0,0,-1> E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 1,0,1,-1> E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 1,0,2,-1> E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 1,1,0,-1> E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 1,1,1,-1> E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 1,1,2,-1> E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 1,2,0,-1> E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 1,2,1,-1> E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 1,2,2,-1> E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 2,0,0,-1> E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 2,0,1,-1> E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 2,0,2,-1> E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 2,1,0,-1> E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 2,1,1,-1> E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 2,1,2,-1> E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 2,2,0,-1> E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 2,2,1,-1> E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 2,2,2,-1> E2 ## E2 ## E2; };
+
+#define GLM_SWIZZLE3_4_MEMBERS(T, Q, E0,E1,E2) \
+	struct { detail::_swizzle<4,T, Q, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 0,0,0,2> E0 ## E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 0,0,1,2> E0 ## E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 0,0,2,0> E0 ## E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 0,0,2,1> E0 ## E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 0,0,2,2> E0 ## E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 0,1,0,2> E0 ## E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 0,1,1,2> E0 ## E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 0,1,2,0> E0 ## E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 0,1,2,1> E0 ## E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 0,1,2,2> E0 ## E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 0,2,0,0> E0 ## E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 0,2,0,1> E0 ## E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 0,2,0,2> E0 ## E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 0,2,1,0> E0 ## E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 0,2,1,1> E0 ## E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 0,2,1,2> E0 ## E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 0,2,2,0> E0 ## E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 0,2,2,1> E0 ## E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 0,2,2,2> E0 ## E2 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 1,0,1,2> E1 ## E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 1,0,2,0> E1 ## E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 1,0,2,1> E1 ## E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 1,0,2,2> E1 ## E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 1,1,0,2> E1 ## E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 1,1,1,2> E1 ## E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 1,1,2,0> E1 ## E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 1,1,2,1> E1 ## E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 1,1,2,2> E1 ## E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 1,2,0,0> E1 ## E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 1,2,0,1> E1 ## E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 1,2,0,2> E1 ## E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 1,2,1,0> E1 ## E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 1,2,1,1> E1 ## E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 1,2,1,2> E1 ## E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 1,2,2,0> E1 ## E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 1,2,2,1> E1 ## E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 1,2,2,2> E1 ## E2 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 2,0,0,0> E2 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 2,0,0,1> E2 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 2,0,0,2> E2 ## E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 2,0,1,0> E2 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 2,0,1,1> E2 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 2,0,1,2> E2 ## E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 2,0,2,0> E2 ## E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 2,0,2,1> E2 ## E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 2,0,2,2> E2 ## E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 2,1,0,0> E2 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 2,1,0,1> E2 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 2,1,0,2> E2 ## E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 2,1,1,0> E2 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 2,1,1,1> E2 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 2,1,1,2> E2 ## E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 2,1,2,0> E2 ## E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 2,1,2,1> E2 ## E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 2,1,2,2> E2 ## E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 2,2,0,0> E2 ## E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 2,2,0,1> E2 ## E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 2,2,0,2> E2 ## E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 2,2,1,0> E2 ## E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 2,2,1,1> E2 ## E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 2,2,1,2> E2 ## E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, Q, 2,2,2,0> E2 ## E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, Q, 2,2,2,1> E2 ## E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, Q, 2,2,2,2> E2 ## E2 ## E2 ## E2; };
+
+#define GLM_SWIZZLE4_2_MEMBERS(T, Q, E0,E1,E2,E3) \
+	struct { detail::_swizzle<2,T, Q, 0,0,-1,-2> E0 ## E0; }; \
+	struct { detail::_swizzle<2,T, Q, 0,1,-1,-2> E0 ## E1; }; \
+	struct { detail::_swizzle<2,T, Q, 0,2,-1,-2> E0 ## E2; }; \
+	struct { detail::_swizzle<2,T, Q, 0,3,-1,-2> E0 ## E3; }; \
+	struct { detail::_swizzle<2,T, Q, 1,0,-1,-2> E1 ## E0; }; \
+	struct { detail::_swizzle<2,T, Q, 1,1,-1,-2> E1 ## E1; }; \
+	struct { detail::_swizzle<2,T, Q, 1,2,-1,-2> E1 ## E2; }; \
+	struct { detail::_swizzle<2,T, Q, 1,3,-1,-2> E1 ## E3; }; \
+	struct { detail::_swizzle<2,T, Q, 2,0,-1,-2> E2 ## E0; }; \
+	struct { detail::_swizzle<2,T, Q, 2,1,-1,-2> E2 ## E1; }; \
+	struct { detail::_swizzle<2,T, Q, 2,2,-1,-2> E2 ## E2; }; \
+	struct { detail::_swizzle<2,T, Q, 2,3,-1,-2> E2 ## E3; }; \
+	struct { detail::_swizzle<2,T, Q, 3,0,-1,-2> E3 ## E0; }; \
+	struct { detail::_swizzle<2,T, Q, 3,1,-1,-2> E3 ## E1; }; \
+	struct { detail::_swizzle<2,T, Q, 3,2,-1,-2> E3 ## E2; }; \
+	struct { detail::_swizzle<2,T, Q, 3,3,-1,-2> E3 ## E3; };
+
+#define GLM_SWIZZLE4_3_MEMBERS(T, Q, E0,E1,E2,E3) \
+	struct { detail::_swizzle<3, T, Q, 0,0,0,-1> E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 0,0,1,-1> E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 0,0,2,-1> E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 0,0,3,-1> E0 ## E0 ## E3; }; \
+	struct { detail::_swizzle<3, T, Q, 0,1,0,-1> E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 0,1,1,-1> E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 0,1,2,-1> E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 0,1,3,-1> E0 ## E1 ## E3; }; \
+	struct { detail::_swizzle<3, T, Q, 0,2,0,-1> E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 0,2,1,-1> E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 0,2,2,-1> E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 0,2,3,-1> E0 ## E2 ## E3; }; \
+	struct { detail::_swizzle<3, T, Q, 0,3,0,-1> E0 ## E3 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 0,3,1,-1> E0 ## E3 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 0,3,2,-1> E0 ## E3 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 0,3,3,-1> E0 ## E3 ## E3; }; \
+	struct { detail::_swizzle<3, T, Q, 1,0,0,-1> E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 1,0,1,-1> E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 1,0,2,-1> E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 1,0,3,-1> E1 ## E0 ## E3; }; \
+	struct { detail::_swizzle<3, T, Q, 1,1,0,-1> E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 1,1,1,-1> E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 1,1,2,-1> E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 1,1,3,-1> E1 ## E1 ## E3; }; \
+	struct { detail::_swizzle<3, T, Q, 1,2,0,-1> E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 1,2,1,-1> E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 1,2,2,-1> E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 1,2,3,-1> E1 ## E2 ## E3; }; \
+	struct { detail::_swizzle<3, T, Q, 1,3,0,-1> E1 ## E3 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 1,3,1,-1> E1 ## E3 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 1,3,2,-1> E1 ## E3 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 1,3,3,-1> E1 ## E3 ## E3; }; \
+	struct { detail::_swizzle<3, T, Q, 2,0,0,-1> E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 2,0,1,-1> E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 2,0,2,-1> E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 2,0,3,-1> E2 ## E0 ## E3; }; \
+	struct { detail::_swizzle<3, T, Q, 2,1,0,-1> E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 2,1,1,-1> E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 2,1,2,-1> E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 2,1,3,-1> E2 ## E1 ## E3; }; \
+	struct { detail::_swizzle<3, T, Q, 2,2,0,-1> E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 2,2,1,-1> E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 2,2,2,-1> E2 ## E2 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 2,2,3,-1> E2 ## E2 ## E3; }; \
+	struct { detail::_swizzle<3, T, Q, 2,3,0,-1> E2 ## E3 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 2,3,1,-1> E2 ## E3 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 2,3,2,-1> E2 ## E3 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 2,3,3,-1> E2 ## E3 ## E3; }; \
+	struct { detail::_swizzle<3, T, Q, 3,0,0,-1> E3 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 3,0,1,-1> E3 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 3,0,2,-1> E3 ## E0 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 3,0,3,-1> E3 ## E0 ## E3; }; \
+	struct { detail::_swizzle<3, T, Q, 3,1,0,-1> E3 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 3,1,1,-1> E3 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 3,1,2,-1> E3 ## E1 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 3,1,3,-1> E3 ## E1 ## E3; }; \
+	struct { detail::_swizzle<3, T, Q, 3,2,0,-1> E3 ## E2 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 3,2,1,-1> E3 ## E2 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 3,2,2,-1> E3 ## E2 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 3,2,3,-1> E3 ## E2 ## E3; }; \
+	struct { detail::_swizzle<3, T, Q, 3,3,0,-1> E3 ## E3 ## E0; }; \
+	struct { detail::_swizzle<3, T, Q, 3,3,1,-1> E3 ## E3 ## E1; }; \
+	struct { detail::_swizzle<3, T, Q, 3,3,2,-1> E3 ## E3 ## E2; }; \
+	struct { detail::_swizzle<3, T, Q, 3,3,3,-1> E3 ## E3 ## E3; };
+
+#define GLM_SWIZZLE4_4_MEMBERS(T, Q, E0,E1,E2,E3) \
+	struct { detail::_swizzle<4, T, Q, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,0,0,2> E0 ## E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,0,0,3> E0 ## E0 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,0,1,2> E0 ## E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,0,1,3> E0 ## E0 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 0,0,2,0> E0 ## E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,0,2,1> E0 ## E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,0,2,2> E0 ## E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,0,2,3> E0 ## E0 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 0,0,3,0> E0 ## E0 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,0,3,1> E0 ## E0 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,0,3,2> E0 ## E0 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,0,3,3> E0 ## E0 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,0,2> E0 ## E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,0,3> E0 ## E1 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,1,2> E0 ## E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,1,3> E0 ## E1 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,2,0> E0 ## E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,2,1> E0 ## E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,2,2> E0 ## E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,2,3> E0 ## E1 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,3,0> E0 ## E1 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,3,1> E0 ## E1 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,3,2> E0 ## E1 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,1,3,3> E0 ## E1 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,0,0> E0 ## E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,0,1> E0 ## E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,0,2> E0 ## E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,0,3> E0 ## E2 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,1,0> E0 ## E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,1,1> E0 ## E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,1,2> E0 ## E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,1,3> E0 ## E2 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,2,0> E0 ## E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,2,1> E0 ## E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,2,2> E0 ## E2 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,2,3> E0 ## E2 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,3,0> E0 ## E2 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,3,1> E0 ## E2 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,3,2> E0 ## E2 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,2,3,3> E0 ## E2 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,0,0> E0 ## E3 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,0,1> E0 ## E3 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,0,2> E0 ## E3 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,0,3> E0 ## E3 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,1,0> E0 ## E3 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,1,1> E0 ## E3 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,1,2> E0 ## E3 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,1,3> E0 ## E3 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,2,0> E0 ## E3 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,2,1> E0 ## E3 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,2,2> E0 ## E3 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,2,3> E0 ## E3 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,3,0> E0 ## E3 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,3,1> E0 ## E3 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,3,2> E0 ## E3 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 0,3,3,3> E0 ## E3 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,0,3> E1 ## E0 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,1,2> E1 ## E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,1,3> E1 ## E0 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,2,0> E1 ## E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,2,1> E1 ## E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,2,2> E1 ## E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,2,3> E1 ## E0 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,3,0> E1 ## E0 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,3,1> E1 ## E0 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,3,2> E1 ## E0 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,0,3,3> E1 ## E0 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,0,2> E1 ## E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,0,3> E1 ## E1 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,1,2> E1 ## E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,1,3> E1 ## E1 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,2,0> E1 ## E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,2,1> E1 ## E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,2,2> E1 ## E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,2,3> E1 ## E1 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,3,0> E1 ## E1 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,3,1> E1 ## E1 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,3,2> E1 ## E1 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,1,3,3> E1 ## E1 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,0,0> E1 ## E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,0,1> E1 ## E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,0,2> E1 ## E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,0,3> E1 ## E2 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,1,0> E1 ## E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,1,1> E1 ## E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,1,2> E1 ## E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,1,3> E1 ## E2 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,2,0> E1 ## E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,2,1> E1 ## E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,2,2> E1 ## E2 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,2,3> E1 ## E2 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,3,0> E1 ## E2 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,3,1> E1 ## E2 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,3,2> E1 ## E2 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,2,3,3> E1 ## E2 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,0,0> E1 ## E3 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,0,1> E1 ## E3 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,0,2> E1 ## E3 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,0,3> E1 ## E3 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,1,0> E1 ## E3 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,1,1> E1 ## E3 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,1,2> E1 ## E3 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,1,3> E1 ## E3 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,2,0> E1 ## E3 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,2,1> E1 ## E3 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,2,2> E1 ## E3 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,2,3> E1 ## E3 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,3,0> E1 ## E3 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,3,1> E1 ## E3 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,3,2> E1 ## E3 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 1,3,3,3> E1 ## E3 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,0,0> E2 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,0,1> E2 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,0,2> E2 ## E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,0,3> E2 ## E0 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,1,0> E2 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,1,1> E2 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,1,2> E2 ## E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,1,3> E2 ## E0 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,2,0> E2 ## E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,2,1> E2 ## E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,2,2> E2 ## E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,2,3> E2 ## E0 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,3,0> E2 ## E0 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,3,1> E2 ## E0 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,3,2> E2 ## E0 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,0,3,3> E2 ## E0 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,0,0> E2 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,0,1> E2 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,0,2> E2 ## E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,0,3> E2 ## E1 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,1,0> E2 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,1,1> E2 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,1,2> E2 ## E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,1,3> E2 ## E1 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,2,0> E2 ## E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,2,1> E2 ## E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,2,2> E2 ## E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,2,3> E2 ## E1 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,3,0> E2 ## E1 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,3,1> E2 ## E1 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,3,2> E2 ## E1 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,1,3,3> E2 ## E1 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,0,0> E2 ## E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,0,1> E2 ## E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,0,2> E2 ## E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,0,3> E2 ## E2 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,1,0> E2 ## E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,1,1> E2 ## E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,1,2> E2 ## E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,1,3> E2 ## E2 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,2,0> E2 ## E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,2,1> E2 ## E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,2,2> E2 ## E2 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,2,3> E2 ## E2 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,3,0> E2 ## E2 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,3,1> E2 ## E2 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,3,2> E2 ## E2 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,2,3,3> E2 ## E2 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,0,0> E2 ## E3 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,0,1> E2 ## E3 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,0,2> E2 ## E3 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,0,3> E2 ## E3 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,1,0> E2 ## E3 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,1,1> E2 ## E3 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,1,2> E2 ## E3 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,1,3> E2 ## E3 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,2,0> E2 ## E3 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,2,1> E2 ## E3 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,2,2> E2 ## E3 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,2,3> E2 ## E3 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,3,0> E2 ## E3 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,3,1> E2 ## E3 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,3,2> E2 ## E3 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 2,3,3,3> E2 ## E3 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,0,0> E3 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,0,1> E3 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,0,2> E3 ## E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,0,3> E3 ## E0 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,1,0> E3 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,1,1> E3 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,1,2> E3 ## E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,1,3> E3 ## E0 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,2,0> E3 ## E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,2,1> E3 ## E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,2,2> E3 ## E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,2,3> E3 ## E0 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,3,0> E3 ## E0 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,3,1> E3 ## E0 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,3,2> E3 ## E0 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,0,3,3> E3 ## E0 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,0,0> E3 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,0,1> E3 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,0,2> E3 ## E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,0,3> E3 ## E1 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,1,0> E3 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,1,1> E3 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,1,2> E3 ## E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,1,3> E3 ## E1 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,2,0> E3 ## E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,2,1> E3 ## E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,2,2> E3 ## E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,2,3> E3 ## E1 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,3,0> E3 ## E1 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,3,1> E3 ## E1 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,3,2> E3 ## E1 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,1,3,3> E3 ## E1 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,0,0> E3 ## E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,0,1> E3 ## E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,0,2> E3 ## E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,0,3> E3 ## E2 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,1,0> E3 ## E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,1,1> E3 ## E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,1,2> E3 ## E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,1,3> E3 ## E2 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,2,0> E3 ## E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,2,1> E3 ## E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,2,2> E3 ## E2 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,2,3> E3 ## E2 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,3,0> E3 ## E2 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,3,1> E3 ## E2 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,3,2> E3 ## E2 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,2,3,3> E3 ## E2 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,0,0> E3 ## E3 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,0,1> E3 ## E3 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,0,2> E3 ## E3 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,0,3> E3 ## E3 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,1,0> E3 ## E3 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,1,1> E3 ## E3 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,1,2> E3 ## E3 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,1,3> E3 ## E3 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,2,0> E3 ## E3 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,2,1> E3 ## E3 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,2,2> E3 ## E3 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,2,3> E3 ## E3 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,3,0> E3 ## E3 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,3,1> E3 ## E3 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,3,2> E3 ## E3 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, Q, 3,3,3,3> E3 ## E3 ## E3 ## E3; };
diff --git a/engine/inc/glm/detail/_swizzle_func.hpp b/engine/inc/glm/detail/_swizzle_func.hpp
new file mode 100644
index 00000000..d93c6afd
--- /dev/null
+++ b/engine/inc/glm/detail/_swizzle_func.hpp
@@ -0,0 +1,682 @@
+#pragma once
+
+#define GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, CONST, A, B)	\
+	vec<2, T, Q> A ## B() CONST							\
+	{													\
+		return vec<2, T, Q>(this->A, this->B);			\
+	}
+
+#define GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, CONST, A, B, C)		\
+	vec<3, T, Q> A ## B ## C() CONST							\
+	{															\
+		return vec<3, T, Q>(this->A, this->B, this->C);			\
+	}
+
+#define GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, CONST, A, B, C, D)					\
+	vec<4, T, Q> A ## B ## C ## D() CONST									\
+	{																		\
+		return vec<4, T, Q>(this->A, this->B, this->C, this->D);			\
+	}
+
+#define GLM_SWIZZLE_GEN_VEC2_ENTRY_DEF(T, P, L, CONST, A, B)	\
+	template<typename T>										\
+	vec<L, T, Q> vec<L, T, Q>::A ## B() CONST					\
+	{															\
+		return vec<2, T, Q>(this->A, this->B);					\
+	}
+
+#define GLM_SWIZZLE_GEN_VEC3_ENTRY_DEF(T, P, L, CONST, A, B, C)		\
+	template<typename T>											\
+	vec<3, T, Q> vec<L, T, Q>::A ## B ## C() CONST					\
+	{																\
+		return vec<3, T, Q>(this->A, this->B, this->C);				\
+	}
+
+#define GLM_SWIZZLE_GEN_VEC4_ENTRY_DEF(T, P, L, CONST, A, B, C, D)		\
+	template<typename T>												\
+	vec<4, T, Q> vec<L, T, Q>::A ## B ## C ## D() CONST					\
+	{																	\
+		return vec<4, T, Q>(this->A, this->B, this->C, this->D);		\
+	}
+
+#define GLM_MUTABLE
+
+#define GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(T, P, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, 2, GLM_MUTABLE, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, 2, GLM_MUTABLE, B, A)
+
+#define GLM_SWIZZLE_GEN_REF_FROM_VEC2(T, P) \
+	GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(T, P, x, y) \
+	GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(T, P, r, g) \
+	GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(T, P, s, t)
+
+#define GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, B)
+
+#define GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, C, B, A)
+
+#define GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, P, A, B, C) \
+	GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+	GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(T, P, A, B, C)
+
+#define GLM_SWIZZLE_GEN_REF_FROM_VEC3(T, P) \
+	GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, P, x, y, z) \
+	GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, P, r, g, b) \
+	GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, P, s, t, p)
+
+#define GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, D, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, D, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, D, C)
+
+#define GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, B, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, D, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, D, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, A, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, D, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, D, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, A, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, B, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, D, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, D, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, C, B)
+
+#define GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, C, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, C, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, D, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, D, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, B, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, C, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, C, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, D, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, D, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, A, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, A, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, B, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, B, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, D, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, D, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, A, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, A, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, B, C, A)
+
+#define GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(T, P, A, B, C, D)
+
+#define GLM_SWIZZLE_GEN_REF_FROM_VEC4(T, P) \
+	GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, P, x, y, z, w) \
+	GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, P, r, g, b, a) \
+	GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, P, s, t, p, q)
+
+#define GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(T, P, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, B)
+
+#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(T, P, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, B)
+
+#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(T, P, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, B)
+
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(T, P, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(T, P, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(T, P, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(T, P, A, B)
+
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC2(T, P)			\
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(T, P, x, y)	\
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(T, P, r, g)	\
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(T, P, s, t)
+
+#define GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, C)
+
+#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, C)
+
+#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, C)
+
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, P, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(T, P, A, B, C)
+
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, P) \
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, P, x, y, z) \
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, P, r, g, b) \
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, P, s, t, p)
+
+#define GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, D, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, D, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, D, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, D, D)
+
+#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, D, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, D, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, D, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, D, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, D, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, D, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, D, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, D, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, D, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, D, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, D, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, D, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, A, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, B, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, C, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, D, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, D, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, D, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, D, D)
+
+#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, D, D)
+
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(T, P, A, B, C, D)
+
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, P) \
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, P, x, y, z, w) \
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, P, r, g, b, a) \
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, P, s, t, p, q)
+
diff --git a/engine/inc/glm/detail/_vectorize.hpp b/engine/inc/glm/detail/_vectorize.hpp
new file mode 100644
index 00000000..ba7fd85c
--- /dev/null
+++ b/engine/inc/glm/detail/_vectorize.hpp
@@ -0,0 +1,123 @@
+#pragma once
+
+namespace glm{
+namespace detail
+{
+	template<template<length_t L, typename T, qualifier Q> class vec, length_t L, typename R, typename T, qualifier Q>
+	struct functor1{};
+
+	template<template<length_t L, typename T, qualifier Q> class vec, typename R, typename T, qualifier Q>
+	struct functor1<vec, 1, R, T, Q>
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<1, R, Q> call(R (*Func) (T x), vec<1, T, Q> const& v)
+		{
+			return vec<1, R, Q>(Func(v.x));
+		}
+	};
+
+	template<template<length_t L, typename T, qualifier Q> class vec, typename R, typename T, qualifier Q>
+	struct functor1<vec, 2, R, T, Q>
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<2, R, Q> call(R (*Func) (T x), vec<2, T, Q> const& v)
+		{
+			return vec<2, R, Q>(Func(v.x), Func(v.y));
+		}
+	};
+
+	template<template<length_t L, typename T, qualifier Q> class vec, typename R, typename T, qualifier Q>
+	struct functor1<vec, 3, R, T, Q>
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<3, R, Q> call(R (*Func) (T x), vec<3, T, Q> const& v)
+		{
+			return vec<3, R, Q>(Func(v.x), Func(v.y), Func(v.z));
+		}
+	};
+
+	template<template<length_t L, typename T, qualifier Q> class vec, typename R, typename T, qualifier Q>
+	struct functor1<vec, 4, R, T, Q>
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, R, Q> call(R (*Func) (T x), vec<4, T, Q> const& v)
+		{
+			return vec<4, R, Q>(Func(v.x), Func(v.y), Func(v.z), Func(v.w));
+		}
+	};
+
+	template<template<length_t L, typename T, qualifier Q> class vec, length_t L, typename T, qualifier Q>
+	struct functor2{};
+
+	template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+	struct functor2<vec, 1, T, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<1, T, Q> call(T (*Func) (T x, T y), vec<1, T, Q> const& a, vec<1, T, Q> const& b)
+		{
+			return vec<1, T, Q>(Func(a.x, b.x));
+		}
+	};
+
+	template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+	struct functor2<vec, 2, T, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<2, T, Q> call(T (*Func) (T x, T y), vec<2, T, Q> const& a, vec<2, T, Q> const& b)
+		{
+			return vec<2, T, Q>(Func(a.x, b.x), Func(a.y, b.y));
+		}
+	};
+
+	template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+	struct functor2<vec, 3, T, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<3, T, Q> call(T (*Func) (T x, T y), vec<3, T, Q> const& a, vec<3, T, Q> const& b)
+		{
+			return vec<3, T, Q>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z));
+		}
+	};
+
+	template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+	struct functor2<vec, 4, T, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, T, Q> call(T (*Func) (T x, T y), vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			return vec<4, T, Q>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z), Func(a.w, b.w));
+		}
+	};
+
+	template<template<length_t L, typename T, qualifier Q> class vec, length_t L, typename T, qualifier Q>
+	struct functor2_vec_sca{};
+
+	template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+	struct functor2_vec_sca<vec, 1, T, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<1, T, Q> call(T (*Func) (T x, T y), vec<1, T, Q> const& a, T b)
+		{
+			return vec<1, T, Q>(Func(a.x, b));
+		}
+	};
+
+	template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+	struct functor2_vec_sca<vec, 2, T, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<2, T, Q> call(T (*Func) (T x, T y), vec<2, T, Q> const& a, T b)
+		{
+			return vec<2, T, Q>(Func(a.x, b), Func(a.y, b));
+		}
+	};
+
+	template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+	struct functor2_vec_sca<vec, 3, T, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<3, T, Q> call(T (*Func) (T x, T y), vec<3, T, Q> const& a, T b)
+		{
+			return vec<3, T, Q>(Func(a.x, b), Func(a.y, b), Func(a.z, b));
+		}
+	};
+
+	template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+	struct functor2_vec_sca<vec, 4, T, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, T, Q> call(T (*Func) (T x, T y), vec<4, T, Q> const& a, T b)
+		{
+			return vec<4, T, Q>(Func(a.x, b), Func(a.y, b), Func(a.z, b), Func(a.w, b));
+		}
+	};
+}//namespace detail
+}//namespace glm
diff --git a/engine/inc/glm/detail/compute_common.hpp b/engine/inc/glm/detail/compute_common.hpp
new file mode 100644
index 00000000..cc24b9e6
--- /dev/null
+++ b/engine/inc/glm/detail/compute_common.hpp
@@ -0,0 +1,50 @@
+#pragma once
+
+#include "setup.hpp"
+#include <limits>
+
+namespace glm{
+namespace detail
+{
+	template<typename genFIType, bool /*signed*/>
+	struct compute_abs
+	{};
+
+	template<typename genFIType>
+	struct compute_abs<genFIType, true>
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genFIType call(genFIType x)
+		{
+			GLM_STATIC_ASSERT(
+				std::numeric_limits<genFIType>::is_iec559 || std::numeric_limits<genFIType>::is_signed,
+				"'abs' only accept floating-point and integer scalar or vector inputs");
+
+			return x >= genFIType(0) ? x : -x;
+			// TODO, perf comp with: *(((int *) &x) + 1) &= 0x7fffffff;
+		}
+	};
+
+#if GLM_COMPILER & GLM_COMPILER_CUDA
+	template<>
+	struct compute_abs<float, true>
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static float call(float x)
+		{
+			return fabsf(x);
+		}
+	};
+#endif
+
+	template<typename genFIType>
+	struct compute_abs<genFIType, false>
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genFIType call(genFIType x)
+		{
+			GLM_STATIC_ASSERT(
+				(!std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer),
+				"'abs' only accept floating-point and integer scalar or vector inputs");
+			return x;
+		}
+	};
+}//namespace detail
+}//namespace glm
diff --git a/engine/inc/glm/detail/compute_vector_relational.hpp b/engine/inc/glm/detail/compute_vector_relational.hpp
new file mode 100644
index 00000000..167b6345
--- /dev/null
+++ b/engine/inc/glm/detail/compute_vector_relational.hpp
@@ -0,0 +1,30 @@
+#pragma once
+
+//#include "compute_common.hpp"
+#include "setup.hpp"
+#include <limits>
+
+namespace glm{
+namespace detail
+{
+	template <typename T, bool isFloat>
+	struct compute_equal
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static bool call(T a, T b)
+		{
+			return a == b;
+		}
+	};
+/*
+	template <typename T>
+	struct compute_equal<T, true>
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static bool call(T a, T b)
+		{
+			return detail::compute_abs<T, std::numeric_limits<T>::is_signed>::call(b - a) <= static_cast<T>(0);
+			//return std::memcmp(&a, &b, sizeof(T)) == 0;
+		}
+	};
+*/
+}//namespace detail
+}//namespace glm
diff --git a/engine/inc/glm/detail/func_common.inl b/engine/inc/glm/detail/func_common.inl
new file mode 100644
index 00000000..c15ca56d
--- /dev/null
+++ b/engine/inc/glm/detail/func_common.inl
@@ -0,0 +1,786 @@
+/// @ref core
+/// @file glm/detail/func_common.inl
+
+#include "../vector_relational.hpp"
+#include "compute_common.hpp"
+#include "type_vec2.hpp"
+#include "type_vec3.hpp"
+#include "type_vec4.hpp"
+#include "_vectorize.hpp"
+#include <limits>
+
+namespace glm
+{
+	// min
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType min(genType x, genType y)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer, "'min' only accept floating-point or integer inputs");
+		return (y < x) ? y : x;
+	}
+
+	// max
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType max(genType x, genType y)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer, "'max' only accept floating-point or integer inputs");
+
+		return (x < y) ? y : x;
+	}
+
+	// abs
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR int abs(int x)
+	{
+		int const y = x >> (sizeof(int) * 8 - 1);
+		return (x ^ y) - y;
+	}
+
+	// round
+#	if GLM_HAS_CXX11_STL
+		using ::std::round;
+#	else
+		template<typename genType>
+		GLM_FUNC_QUALIFIER genType round(genType x)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'round' only accept floating-point inputs");
+
+			return x < static_cast<genType>(0) ? static_cast<genType>(int(x - static_cast<genType>(0.5))) : static_cast<genType>(int(x + static_cast<genType>(0.5)));
+		}
+#	endif
+
+	// trunc
+#	if GLM_HAS_CXX11_STL
+		using ::std::trunc;
+#	else
+		template<typename genType>
+		GLM_FUNC_QUALIFIER genType trunc(genType x)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'trunc' only accept floating-point inputs");
+
+			return x < static_cast<genType>(0) ? -std::floor(-x) : std::floor(x);
+		}
+#	endif
+
+}//namespace glm
+
+namespace glm{
+namespace detail
+{
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_abs_vector
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<L, T, Q> call(vec<L, T, Q> const& x)
+		{
+			return detail::functor1<vec, L, T, T, Q>::call(abs, x);
+		}
+	};
+
+	template<length_t L, typename T, typename U, qualifier Q, bool Aligned>
+	struct compute_mix_vector
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, U, Q> const& a)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a");
+
+			return vec<L, T, Q>(vec<L, U, Q>(x) + a * vec<L, U, Q>(y - x));
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_mix_vector<L, T, bool, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, bool, Q> const& a)
+		{
+			vec<L, T, Q> Result;
+			for(length_t i = 0; i < x.length(); ++i)
+				Result[i] = a[i] ? y[i] : x[i];
+			return Result;
+		}
+	};
+
+	template<length_t L, typename T, typename U, qualifier Q, bool Aligned>
+	struct compute_mix_scalar
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& y, U const& a)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a");
+
+			return vec<L, T, Q>(vec<L, U, Q>(x) + a * vec<L, U, Q>(y - x));
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_mix_scalar<L, T, bool, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& y, bool const& a)
+		{
+			return a ? y : x;
+		}
+	};
+
+	template<typename T, typename U>
+	struct compute_mix
+	{
+		GLM_FUNC_QUALIFIER static T call(T const& x, T const& y, U const& a)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a");
+
+			return static_cast<T>(static_cast<U>(x) + a * static_cast<U>(y - x));
+		}
+	};
+
+	template<typename T>
+	struct compute_mix<T, bool>
+	{
+		GLM_FUNC_QUALIFIER static T call(T const& x, T const& y, bool const& a)
+		{
+			return a ? y : x;
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool isFloat, bool Aligned>
+	struct compute_sign
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
+		{
+			return vec<L, T, Q>(glm::lessThan(vec<L, T, Q>(0), x)) - vec<L, T, Q>(glm::lessThan(x, vec<L, T, Q>(0)));
+		}
+	};
+
+#	if GLM_ARCH == GLM_ARCH_X86
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_sign<L, T, Q, false, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
+		{
+			T const Shift(static_cast<T>(sizeof(T) * 8 - 1));
+			vec<L, T, Q> const y(vec<L, typename detail::make_unsigned<T>::type, Q>(-x) >> typename detail::make_unsigned<T>::type(Shift));
+
+			return (x >> Shift) | y;
+		}
+	};
+#	endif
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_floor
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
+		{
+			return detail::functor1<vec, L, T, T, Q>::call(std::floor, x);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_ceil
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
+		{
+			return detail::functor1<vec, L, T, T, Q>::call(std::ceil, x);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_fract
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
+		{
+			return x - floor(x);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_trunc
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
+		{
+			return detail::functor1<vec, L, T, T, Q>::call(trunc, x);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_round
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
+		{
+			return detail::functor1<vec, L, T, T, Q>::call(round, x);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_mod
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& a, vec<L, T, Q> const& b)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'mod' only accept floating-point inputs. Include <glm/gtc/integer.hpp> for integer inputs.");
+			return a - b * floor(a / b);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_min_vector
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+		{
+			return detail::functor2<vec, L, T, Q>::call(min, x, y);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_max_vector
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+		{
+			return detail::functor2<vec, L, T, Q>::call(max, x, y);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_clamp_vector
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& minVal, vec<L, T, Q> const& maxVal)
+		{
+			return min(max(x, minVal), maxVal);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_step_vector
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& edge, vec<L, T, Q> const& x)
+		{
+			return mix(vec<L, T, Q>(1), vec<L, T, Q>(0), glm::lessThan(x, edge));
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_smoothstep_vector
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& edge0, vec<L, T, Q> const& edge1, vec<L, T, Q> const& x)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'step' only accept floating-point inputs");
+			vec<L, T, Q> const tmp(clamp((x - edge0) / (edge1 - edge0), static_cast<T>(0), static_cast<T>(1)));
+			return tmp * tmp * (static_cast<T>(3) - static_cast<T>(2) * tmp);
+		}
+	};
+}//namespace detail
+
+	template<typename genFIType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genFIType abs(genFIType x)
+	{
+		return detail::compute_abs<genFIType, std::numeric_limits<genFIType>::is_signed>::call(x);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> abs(vec<L, T, Q> const& x)
+	{
+		return detail::compute_abs_vector<L, T, Q, detail::is_aligned<Q>::value>::call(x);
+	}
+
+	// sign
+	// fast and works for any type
+	template<typename genFIType>
+	GLM_FUNC_QUALIFIER genFIType sign(genFIType x)
+	{
+		GLM_STATIC_ASSERT(
+			std::numeric_limits<genFIType>::is_iec559 || (std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer),
+			"'sign' only accept signed inputs");
+
+		return detail::compute_sign<1, genFIType, defaultp, std::numeric_limits<genFIType>::is_iec559, highp>::call(vec<1, genFIType>(x)).x;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> sign(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(
+			std::numeric_limits<T>::is_iec559 || (std::numeric_limits<T>::is_signed && std::numeric_limits<T>::is_integer),
+			"'sign' only accept signed inputs");
+
+		return detail::compute_sign<L, T, Q, std::numeric_limits<T>::is_iec559, detail::is_aligned<Q>::value>::call(x);
+	}
+
+	// floor
+	using ::std::floor;
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> floor(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'floor' only accept floating-point inputs.");
+		return detail::compute_floor<L, T, Q, detail::is_aligned<Q>::value>::call(x);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> trunc(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'trunc' only accept floating-point inputs");
+		return detail::compute_trunc<L, T, Q, detail::is_aligned<Q>::value>::call(x);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> round(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'round' only accept floating-point inputs");
+		return detail::compute_round<L, T, Q, detail::is_aligned<Q>::value>::call(x);
+	}
+
+/*
+	// roundEven
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType roundEven(genType const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'roundEven' only accept floating-point inputs");
+
+		return genType(int(x + genType(int(x) % 2)));
+	}
+*/
+
+	// roundEven
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType roundEven(genType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'roundEven' only accept floating-point inputs");
+
+		int Integer = static_cast<int>(x);
+		genType IntegerPart = static_cast<genType>(Integer);
+		genType FractionalPart = fract(x);
+
+		if(FractionalPart > static_cast<genType>(0.5) || FractionalPart < static_cast<genType>(0.5))
+		{
+			return round(x);
+		}
+		else if((Integer % 2) == 0)
+		{
+			return IntegerPart;
+		}
+		else if(x <= static_cast<genType>(0)) // Work around...
+		{
+			return IntegerPart - static_cast<genType>(1);
+		}
+		else
+		{
+			return IntegerPart + static_cast<genType>(1);
+		}
+		//else // Bug on MinGW 4.5.2
+		//{
+		//	return mix(IntegerPart + genType(-1), IntegerPart + genType(1), x <= genType(0));
+		//}
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> roundEven(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'roundEven' only accept floating-point inputs");
+		return detail::functor1<vec, L, T, T, Q>::call(roundEven, x);
+	}
+
+	// ceil
+	using ::std::ceil;
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> ceil(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ceil' only accept floating-point inputs");
+		return detail::compute_ceil<L, T, Q, detail::is_aligned<Q>::value>::call(x);
+	}
+
+	// fract
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType fract(genType x)
+	{
+		return fract(vec<1, genType>(x)).x;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fract(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'fract' only accept floating-point inputs");
+		return detail::compute_fract<L, T, Q, detail::is_aligned<Q>::value>::call(x);
+	}
+
+	// mod
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType mod(genType x, genType y)
+	{
+#		if GLM_COMPILER & GLM_COMPILER_CUDA
+			// Another Cuda compiler bug https://github.com/g-truc/glm/issues/530
+			vec<1, genType, defaultp> Result(mod(vec<1, genType, defaultp>(x), y));
+			return Result.x;
+#		else
+			return mod(vec<1, genType, defaultp>(x), y).x;
+#		endif
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> mod(vec<L, T, Q> const& x, T y)
+	{
+		return detail::compute_mod<L, T, Q, detail::is_aligned<Q>::value>::call(x, vec<L, T, Q>(y));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> mod(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+	{
+		return detail::compute_mod<L, T, Q, detail::is_aligned<Q>::value>::call(x, y);
+	}
+
+	// modf
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType modf(genType x, genType & i)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'modf' only accept floating-point inputs");
+		return std::modf(x, &i);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<1, T, Q> modf(vec<1, T, Q> const& x, vec<1, T, Q> & i)
+	{
+		return vec<1, T, Q>(
+			modf(x.x, i.x));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<2, T, Q> modf(vec<2, T, Q> const& x, vec<2, T, Q> & i)
+	{
+		return vec<2, T, Q>(
+			modf(x.x, i.x),
+			modf(x.y, i.y));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> modf(vec<3, T, Q> const& x, vec<3, T, Q> & i)
+	{
+		return vec<3, T, Q>(
+			modf(x.x, i.x),
+			modf(x.y, i.y),
+			modf(x.z, i.z));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, T, Q> modf(vec<4, T, Q> const& x, vec<4, T, Q> & i)
+	{
+		return vec<4, T, Q>(
+			modf(x.x, i.x),
+			modf(x.y, i.y),
+			modf(x.z, i.z),
+			modf(x.w, i.w));
+	}
+
+	//// Only valid if (INT_MIN <= x-y <= INT_MAX)
+	//// min(x,y)
+	//r = y + ((x - y) & ((x - y) >> (sizeof(int) *
+	//CHAR_BIT - 1)));
+	//// max(x,y)
+	//r = x - ((x - y) & ((x - y) >> (sizeof(int) *
+	//CHAR_BIT - 1)));
+
+	// min
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> min(vec<L, T, Q> const& a, T b)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer, "'min' only accept floating-point or integer inputs");
+		return detail::compute_min_vector<L, T, Q, detail::is_aligned<Q>::value>::call(a, vec<L, T, Q>(b));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> min(vec<L, T, Q> const& a, vec<L, T, Q> const& b)
+	{
+		return detail::compute_min_vector<L, T, Q, detail::is_aligned<Q>::value>::call(a, b);
+	}
+
+	// max
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> max(vec<L, T, Q> const& a, T b)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer, "'max' only accept floating-point or integer inputs");
+		return detail::compute_max_vector<L, T, Q, detail::is_aligned<Q>::value>::call(a, vec<L, T, Q>(b));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> max(vec<L, T, Q> const& a, vec<L, T, Q> const& b)
+	{
+		return detail::compute_max_vector<L, T, Q, detail::is_aligned<Q>::value>::call(a, b);
+	}
+
+	// clamp
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType clamp(genType x, genType minVal, genType maxVal)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer, "'clamp' only accept floating-point or integer inputs");
+		return min(max(x, minVal), maxVal);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> clamp(vec<L, T, Q> const& x, T minVal, T maxVal)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer, "'clamp' only accept floating-point or integer inputs");
+		return detail::compute_clamp_vector<L, T, Q, detail::is_aligned<Q>::value>::call(x, vec<L, T, Q>(minVal), vec<L, T, Q>(maxVal));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> clamp(vec<L, T, Q> const& x, vec<L, T, Q> const& minVal, vec<L, T, Q> const& maxVal)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer, "'clamp' only accept floating-point or integer inputs");
+		return detail::compute_clamp_vector<L, T, Q, detail::is_aligned<Q>::value>::call(x, minVal, maxVal);
+	}
+
+	template<typename genTypeT, typename genTypeU>
+	GLM_FUNC_QUALIFIER genTypeT mix(genTypeT x, genTypeT y, genTypeU a)
+	{
+		return detail::compute_mix<genTypeT, genTypeU>::call(x, y, a);
+	}
+
+	template<length_t L, typename T, typename U, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> mix(vec<L, T, Q> const& x, vec<L, T, Q> const& y, U a)
+	{
+		return detail::compute_mix_scalar<L, T, U, Q, detail::is_aligned<Q>::value>::call(x, y, a);
+	}
+
+	template<length_t L, typename T, typename U, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> mix(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, U, Q> const& a)
+	{
+		return detail::compute_mix_vector<L, T, U, Q, detail::is_aligned<Q>::value>::call(x, y, a);
+	}
+
+	// step
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType step(genType edge, genType x)
+	{
+		return mix(static_cast<genType>(1), static_cast<genType>(0), x < edge);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> step(T edge, vec<L, T, Q> const& x)
+	{
+		return detail::compute_step_vector<L, T, Q, detail::is_aligned<Q>::value>::call(vec<L, T, Q>(edge), x);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> step(vec<L, T, Q> const& edge, vec<L, T, Q> const& x)
+	{
+		return detail::compute_step_vector<L, T, Q, detail::is_aligned<Q>::value>::call(edge, x);
+	}
+
+	// smoothstep
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType smoothstep(genType edge0, genType edge1, genType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'smoothstep' only accept floating-point inputs");
+
+		genType const tmp(clamp((x - edge0) / (edge1 - edge0), genType(0), genType(1)));
+		return tmp * tmp * (genType(3) - genType(2) * tmp);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> smoothstep(T edge0, T edge1, vec<L, T, Q> const& x)
+	{
+		return detail::compute_smoothstep_vector<L, T, Q, detail::is_aligned<Q>::value>::call(vec<L, T, Q>(edge0), vec<L, T, Q>(edge1), x);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> smoothstep(vec<L, T, Q> const& edge0, vec<L, T, Q> const& edge1, vec<L, T, Q> const& x)
+	{
+		return detail::compute_smoothstep_vector<L, T, Q, detail::is_aligned<Q>::value>::call(edge0, edge1, x);
+	}
+
+#	if GLM_HAS_CXX11_STL
+		using std::isnan;
+#	else
+		template<typename genType>
+		GLM_FUNC_QUALIFIER bool isnan(genType x)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'isnan' only accept floating-point inputs");
+
+#			if GLM_HAS_CXX11_STL
+				return std::isnan(x);
+#			elif GLM_COMPILER & GLM_COMPILER_VC
+				return _isnan(x) != 0;
+#			elif GLM_COMPILER & GLM_COMPILER_INTEL
+#				if GLM_PLATFORM & GLM_PLATFORM_WINDOWS
+					return _isnan(x) != 0;
+#				else
+					return ::isnan(x) != 0;
+#				endif
+#			elif (GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG)) && (GLM_PLATFORM & GLM_PLATFORM_ANDROID) && __cplusplus < 201103L
+				return _isnan(x) != 0;
+#			elif GLM_COMPILER & GLM_COMPILER_CUDA
+				return ::isnan(x) != 0;
+#			else
+				return std::isnan(x);
+#			endif
+		}
+#	endif
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, bool, Q> isnan(vec<L, T, Q> const& v)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isnan' only accept floating-point inputs");
+
+		vec<L, bool, Q> Result;
+		for (length_t l = 0; l < v.length(); ++l)
+			Result[l] = glm::isnan(v[l]);
+		return Result;
+	}
+
+#	if GLM_HAS_CXX11_STL
+		using std::isinf;
+#	else
+		template<typename genType>
+		GLM_FUNC_QUALIFIER bool isinf(genType x)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'isinf' only accept floating-point inputs");
+
+#			if GLM_HAS_CXX11_STL
+				return std::isinf(x);
+#			elif GLM_COMPILER & (GLM_COMPILER_INTEL | GLM_COMPILER_VC)
+#				if(GLM_PLATFORM & GLM_PLATFORM_WINDOWS)
+					return _fpclass(x) == _FPCLASS_NINF || _fpclass(x) == _FPCLASS_PINF;
+#				else
+					return ::isinf(x);
+#				endif
+#			elif GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG)
+#				if(GLM_PLATFORM & GLM_PLATFORM_ANDROID && __cplusplus < 201103L)
+					return _isinf(x) != 0;
+#				else
+					return std::isinf(x);
+#				endif
+#			elif GLM_COMPILER & GLM_COMPILER_CUDA
+				// http://developer.download.nvidia.com/compute/cuda/4_2/rel/toolkit/docs/online/group__CUDA__MATH__DOUBLE_g13431dd2b40b51f9139cbb7f50c18fab.html#g13431dd2b40b51f9139cbb7f50c18fab
+				return ::isinf(double(x)) != 0;
+#			else
+				return std::isinf(x);
+#			endif
+	}
+#	endif
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, bool, Q> isinf(vec<L, T, Q> const& v)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isinf' only accept floating-point inputs");
+
+		vec<L, bool, Q> Result;
+		for (length_t l = 0; l < v.length(); ++l)
+			Result[l] = glm::isinf(v[l]);
+		return Result;
+	}
+
+	GLM_FUNC_QUALIFIER int floatBitsToInt(float const& v)
+	{
+		union
+		{
+			float in;
+			int out;
+		} u;
+
+		u.in = v;
+
+		return u.out;
+	}
+
+	template<length_t L, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, int, Q> floatBitsToInt(vec<L, float, Q> const& v)
+	{
+		return reinterpret_cast<vec<L, int, Q>&>(const_cast<vec<L, float, Q>&>(v));
+	}
+
+	GLM_FUNC_QUALIFIER uint floatBitsToUint(float const& v)
+	{
+		union
+		{
+			float in;
+			uint out;
+		} u;
+
+		u.in = v;
+
+		return u.out;
+	}
+
+	template<length_t L, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, uint, Q> floatBitsToUint(vec<L, float, Q> const& v)
+	{
+		return reinterpret_cast<vec<L, uint, Q>&>(const_cast<vec<L, float, Q>&>(v));
+	}
+
+	GLM_FUNC_QUALIFIER float intBitsToFloat(int const& v)
+	{
+		union
+		{
+			int in;
+			float out;
+		} u;
+
+		u.in = v;
+
+		return u.out;
+	}
+
+	template<length_t L, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, float, Q> intBitsToFloat(vec<L, int, Q> const& v)
+	{
+		return reinterpret_cast<vec<L, float, Q>&>(const_cast<vec<L, int, Q>&>(v));
+	}
+
+	GLM_FUNC_QUALIFIER float uintBitsToFloat(uint const& v)
+	{
+		union
+		{
+			uint in;
+			float out;
+		} u;
+
+		u.in = v;
+
+		return u.out;
+	}
+
+	template<length_t L, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, float, Q> uintBitsToFloat(vec<L, uint, Q> const& v)
+	{
+		return reinterpret_cast<vec<L, float, Q>&>(const_cast<vec<L, uint, Q>&>(v));
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType fma(genType const& a, genType const& b, genType const& c)
+	{
+		return a * b + c;
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType frexp(genType x, int& exp)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'frexp' only accept floating-point inputs");
+
+		return std::frexp(x, &exp);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> frexp(vec<L, T, Q> const& v, vec<L, int, Q>& exp)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'frexp' only accept floating-point inputs");
+
+		vec<L, T, Q> Result;
+		for (length_t l = 0; l < v.length(); ++l)
+			Result[l] = std::frexp(v[l], &exp[l]);
+		return Result;
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType ldexp(genType const& x, int const& exp)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'ldexp' only accept floating-point inputs");
+
+		return std::ldexp(x, exp);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> ldexp(vec<L, T, Q> const& v, vec<L, int, Q> const& exp)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ldexp' only accept floating-point inputs");
+
+		vec<L, T, Q> Result;
+		for (length_t l = 0; l < v.length(); ++l)
+			Result[l] = std::ldexp(v[l], exp[l]);
+		return Result;
+	}
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+#	include "func_common_simd.inl"
+#endif
diff --git a/engine/inc/glm/detail/func_common_simd.inl b/engine/inc/glm/detail/func_common_simd.inl
new file mode 100644
index 00000000..ce0032d3
--- /dev/null
+++ b/engine/inc/glm/detail/func_common_simd.inl
@@ -0,0 +1,231 @@
+/// @ref core
+/// @file glm/detail/func_common_simd.inl
+
+#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+#include "../simd/common.h"
+
+#include <immintrin.h>
+
+namespace glm{
+namespace detail
+{
+	template<qualifier Q>
+	struct compute_abs_vector<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
+		{
+			vec<4, float, Q> result;
+			result.data = glm_vec4_abs(v.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_abs_vector<4, int, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& v)
+		{
+			vec<4, int, Q> result;
+			result.data = glm_ivec4_abs(v.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_floor<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
+		{
+			vec<4, float, Q> result;
+			result.data = glm_vec4_floor(v.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_ceil<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
+		{
+			vec<4, float, Q> result;
+			result.data = glm_vec4_ceil(v.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_fract<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
+		{
+			vec<4, float, Q> result;
+			result.data = glm_vec4_fract(v.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_round<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
+		{
+			vec<4, float, Q> result;
+			result.data = glm_vec4_round(v.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_mod<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& x, vec<4, float, Q> const& y)
+		{
+			vec<4, float, Q> result;
+			result.data = glm_vec4_mod(x.data, y.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_min_vector<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2)
+		{
+			vec<4, float, Q> result;
+			result.data = _mm_min_ps(v1.data, v2.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_min_vector<4, int, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& v1, vec<4, int, Q> const& v2)
+		{
+			vec<4, int, Q> result;
+			result.data = _mm_min_epi32(v1.data, v2.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_min_vector<4, uint, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, uint, Q> call(vec<4, uint, Q> const& v1, vec<4, uint, Q> const& v2)
+		{
+			vec<4, uint, Q> result;
+			result.data = _mm_min_epu32(v1.data, v2.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_max_vector<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2)
+		{
+			vec<4, float, Q> result;
+			result.data = _mm_max_ps(v1.data, v2.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_max_vector<4, int, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& v1, vec<4, int, Q> const& v2)
+		{
+			vec<4, int, Q> result;
+			result.data = _mm_max_epi32(v1.data, v2.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_max_vector<4, uint, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, uint, Q> call(vec<4, uint, Q> const& v1, vec<4, uint, Q> const& v2)
+		{
+			vec<4, uint, Q> result;
+			result.data = _mm_max_epu32(v1.data, v2.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_clamp_vector<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& x, vec<4, float, Q> const& minVal, vec<4, float, Q> const& maxVal)
+		{
+			vec<4, float, Q> result;
+			result.data = _mm_min_ps(_mm_max_ps(x.data, minVal.data), maxVal.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_clamp_vector<4, int, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& x, vec<4, int, Q> const& minVal, vec<4, int, Q> const& maxVal)
+		{
+			vec<4, int, Q> result;
+			result.data = _mm_min_epi32(_mm_max_epi32(x.data, minVal.data), maxVal.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_clamp_vector<4, uint, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, uint, Q> call(vec<4, uint, Q> const& x, vec<4, uint, Q> const& minVal, vec<4, uint, Q> const& maxVal)
+		{
+			vec<4, uint, Q> result;
+			result.data = _mm_min_epu32(_mm_max_epu32(x.data, minVal.data), maxVal.data);
+			return result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_mix_vector<4, float, bool, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& x, vec<4, float, Q> const& y, vec<4, bool, Q> const& a)
+		{
+			__m128i const Load = _mm_set_epi32(-static_cast<int>(a.w), -static_cast<int>(a.z), -static_cast<int>(a.y), -static_cast<int>(a.x));
+			__m128 const Mask = _mm_castsi128_ps(Load);
+
+			vec<4, float, Q> Result;
+#			if 0 && GLM_ARCH & GLM_ARCH_AVX
+				Result.data = _mm_blendv_ps(x.data, y.data, Mask);
+#			else
+				Result.data = _mm_or_ps(_mm_and_ps(Mask, y.data), _mm_andnot_ps(Mask, x.data));
+#			endif
+			return Result;
+		}
+	};
+/* FIXME
+	template<qualifier Q>
+	struct compute_step_vector<float, Q, tvec4>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& edge, vec<4, float, Q> const& x)
+		{
+			vec<4, float, Q> Result;
+			result.data = glm_vec4_step(edge.data, x.data);
+			return result;
+		}
+	};
+*/
+	template<qualifier Q>
+	struct compute_smoothstep_vector<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& edge0, vec<4, float, Q> const& edge1, vec<4, float, Q> const& x)
+		{
+			vec<4, float, Q> Result;
+			Result.data = glm_vec4_smoothstep(edge0.data, edge1.data, x.data);
+			return Result;
+		}
+	};
+}//namespace detail
+}//namespace glm
+
+#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
diff --git a/engine/inc/glm/detail/func_exponential.inl b/engine/inc/glm/detail/func_exponential.inl
new file mode 100644
index 00000000..2040d41f
--- /dev/null
+++ b/engine/inc/glm/detail/func_exponential.inl
@@ -0,0 +1,152 @@
+/// @ref core
+/// @file glm/detail/func_exponential.inl
+
+#include "../vector_relational.hpp"
+#include "_vectorize.hpp"
+#include <limits>
+#include <cmath>
+#include <cassert>
+
+namespace glm{
+namespace detail
+{
+#	if GLM_HAS_CXX11_STL
+		using std::log2;
+#	else
+		template<typename genType>
+		genType log2(genType Value)
+		{
+			return std::log(Value) * static_cast<genType>(1.4426950408889634073599246810019);
+		}
+#	endif
+
+	template<length_t L, typename T, qualifier Q, bool isFloat, bool Aligned>
+	struct compute_log2
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& v)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'log2' only accept floating-point inputs. Include <glm/gtc/integer.hpp> for integer inputs.");
+
+			return detail::functor1<vec, L, T, T, Q>::call(log2, v);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_sqrt
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
+		{
+			return detail::functor1<vec, L, T, T, Q>::call(std::sqrt, x);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_inversesqrt
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
+		{
+			return static_cast<T>(1) / sqrt(x);
+		}
+	};
+
+	template<length_t L, bool Aligned>
+	struct compute_inversesqrt<L, float, lowp, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, float, lowp> call(vec<L, float, lowp> const& x)
+		{
+			vec<L, float, lowp> tmp(x);
+			vec<L, float, lowp> xhalf(tmp * 0.5f);
+			vec<L, uint, lowp>* p = reinterpret_cast<vec<L, uint, lowp>*>(const_cast<vec<L, float, lowp>*>(&x));
+			vec<L, uint, lowp> i = vec<L, uint, lowp>(0x5f375a86) - (*p >> vec<L, uint, lowp>(1));
+			vec<L, float, lowp>* ptmp = reinterpret_cast<vec<L, float, lowp>*>(&i);
+			tmp = *ptmp;
+			tmp = tmp * (1.5f - xhalf * tmp * tmp);
+			return tmp;
+		}
+	};
+}//namespace detail
+
+	// pow
+	using std::pow;
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> pow(vec<L, T, Q> const& base, vec<L, T, Q> const& exponent)
+	{
+		return detail::functor2<vec, L, T, Q>::call(pow, base, exponent);
+	}
+
+	// exp
+	using std::exp;
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> exp(vec<L, T, Q> const& x)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(exp, x);
+	}
+
+	// log
+	using std::log;
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> log(vec<L, T, Q> const& x)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(log, x);
+	}
+
+#   if GLM_HAS_CXX11_STL
+    using std::exp2;
+#   else
+	//exp2, ln2 = 0.69314718055994530941723212145818f
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType exp2(genType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'exp2' only accept floating-point inputs");
+
+		return std::exp(static_cast<genType>(0.69314718055994530941723212145818) * x);
+	}
+#   endif
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> exp2(vec<L, T, Q> const& x)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(exp2, x);
+	}
+
+	// log2, ln2 = 0.69314718055994530941723212145818f
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType log2(genType x)
+	{
+		return log2(vec<1, genType>(x)).x;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> log2(vec<L, T, Q> const& x)
+	{
+		return detail::compute_log2<L, T, Q, std::numeric_limits<T>::is_iec559, detail::is_aligned<Q>::value>::call(x);
+	}
+
+	// sqrt
+	using std::sqrt;
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> sqrt(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'sqrt' only accept floating-point inputs");
+		return detail::compute_sqrt<L, T, Q, detail::is_aligned<Q>::value>::call(x);
+	}
+
+	// inversesqrt
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType inversesqrt(genType x)
+	{
+		return static_cast<genType>(1) / sqrt(x);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> inversesqrt(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'inversesqrt' only accept floating-point inputs");
+		return detail::compute_inversesqrt<L, T, Q, detail::is_aligned<Q>::value>::call(x);
+	}
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+#	include "func_exponential_simd.inl"
+#endif
+
diff --git a/engine/inc/glm/detail/func_exponential_simd.inl b/engine/inc/glm/detail/func_exponential_simd.inl
new file mode 100644
index 00000000..fb789517
--- /dev/null
+++ b/engine/inc/glm/detail/func_exponential_simd.inl
@@ -0,0 +1,37 @@
+/// @ref core
+/// @file glm/detail/func_exponential_simd.inl
+
+#include "../simd/exponential.h"
+
+#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+namespace glm{
+namespace detail
+{
+	template<qualifier Q>
+	struct compute_sqrt<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
+		{
+			vec<4, float, Q> Result;
+			Result.data = _mm_sqrt_ps(v.data);
+			return Result;
+		}
+	};
+
+#	if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE
+	template<>
+	struct compute_sqrt<4, float, aligned_lowp, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, aligned_lowp> call(vec<4, float, aligned_lowp> const& v)
+		{
+			vec<4, float, aligned_lowp> Result;
+			Result.data = glm_vec4_sqrt_lowp(v.data);
+			return Result;
+		}
+	};
+#	endif
+}//namespace detail
+}//namespace glm
+
+#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
diff --git a/engine/inc/glm/detail/func_geometric.inl b/engine/inc/glm/detail/func_geometric.inl
new file mode 100644
index 00000000..9cde28fe
--- /dev/null
+++ b/engine/inc/glm/detail/func_geometric.inl
@@ -0,0 +1,243 @@
+#include "../exponential.hpp"
+#include "../common.hpp"
+
+namespace glm{
+namespace detail
+{
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_length
+	{
+		GLM_FUNC_QUALIFIER static T call(vec<L, T, Q> const& v)
+		{
+			return sqrt(dot(v, v));
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_distance
+	{
+		GLM_FUNC_QUALIFIER static T call(vec<L, T, Q> const& p0, vec<L, T, Q> const& p1)
+		{
+			return length(p1 - p0);
+		}
+	};
+
+	template<typename V, typename T, bool Aligned>
+	struct compute_dot{};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_dot<vec<1, T, Q>, T, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static T call(vec<1, T, Q> const& a, vec<1, T, Q> const& b)
+		{
+			return a.x * b.x;
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_dot<vec<2, T, Q>, T, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static T call(vec<2, T, Q> const& a, vec<2, T, Q> const& b)
+		{
+			vec<2, T, Q> tmp(a * b);
+			return tmp.x + tmp.y;
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_dot<vec<3, T, Q>, T, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static T call(vec<3, T, Q> const& a, vec<3, T, Q> const& b)
+		{
+			vec<3, T, Q> tmp(a * b);
+			return tmp.x + tmp.y + tmp.z;
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_dot<vec<4, T, Q>, T, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static T call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			vec<4, T, Q> tmp(a * b);
+			return (tmp.x + tmp.y) + (tmp.z + tmp.w);
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_cross
+	{
+		GLM_FUNC_QUALIFIER static vec<3, T, Q> call(vec<3, T, Q> const& x, vec<3, T, Q> const& y)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'cross' accepts only floating-point inputs");
+
+			return vec<3, T, Q>(
+				x.y * y.z - y.y * x.z,
+				x.z * y.x - y.z * x.x,
+				x.x * y.y - y.x * x.y);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_normalize
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& v)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' accepts only floating-point inputs");
+
+			return v * inversesqrt(dot(v, v));
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_faceforward
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& N, vec<L, T, Q> const& I, vec<L, T, Q> const& Nref)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' accepts only floating-point inputs");
+
+			return dot(Nref, I) < static_cast<T>(0) ? N : -N;
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_reflect
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& I, vec<L, T, Q> const& N)
+		{
+			return I - N * dot(N, I) * static_cast<T>(2);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_refract
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& I, vec<L, T, Q> const& N, T eta)
+		{
+			T const dotValue(dot(N, I));
+			T const k(static_cast<T>(1) - eta * eta * (static_cast<T>(1) - dotValue * dotValue));
+			vec<L, T, Q> const Result =
+                (k >= static_cast<T>(0)) ? (eta * I - (eta * dotValue + std::sqrt(k)) * N) : vec<L, T, Q>(0);
+			return Result;
+		}
+	};
+}//namespace detail
+
+	// length
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType length(genType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'length' accepts only floating-point inputs");
+
+		return abs(x);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T length(vec<L, T, Q> const& v)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'length' accepts only floating-point inputs");
+
+		return detail::compute_length<L, T, Q, detail::is_aligned<Q>::value>::call(v);
+	}
+
+	// distance
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType distance(genType const& p0, genType const& p1)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'distance' accepts only floating-point inputs");
+
+		return length(p1 - p0);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T distance(vec<L, T, Q> const& p0, vec<L, T, Q> const& p1)
+	{
+		return detail::compute_distance<L, T, Q, detail::is_aligned<Q>::value>::call(p0, p1);
+	}
+
+	// dot
+	template<typename T>
+	GLM_FUNC_QUALIFIER T dot(T x, T y)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' accepts only floating-point inputs");
+		return x * y;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T dot(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' accepts only floating-point inputs");
+		return detail::compute_dot<vec<L, T, Q>, T, detail::is_aligned<Q>::value>::call(x, y);
+	}
+
+	// cross
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> cross(vec<3, T, Q> const& x, vec<3, T, Q> const& y)
+	{
+		return detail::compute_cross<T, Q, detail::is_aligned<Q>::value>::call(x, y);
+	}
+/*
+	// normalize
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType normalize(genType const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'normalize' accepts only floating-point inputs");
+
+		return x < genType(0) ? genType(-1) : genType(1);
+	}
+*/
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> normalize(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' accepts only floating-point inputs");
+
+		return detail::compute_normalize<L, T, Q, detail::is_aligned<Q>::value>::call(x);
+	}
+
+	// faceforward
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType faceforward(genType const& N, genType const& I, genType const& Nref)
+	{
+		return dot(Nref, I) < static_cast<genType>(0) ? N : -N;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> faceforward(vec<L, T, Q> const& N, vec<L, T, Q> const& I, vec<L, T, Q> const& Nref)
+	{
+		return detail::compute_faceforward<L, T, Q, detail::is_aligned<Q>::value>::call(N, I, Nref);
+	}
+
+	// reflect
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType reflect(genType const& I, genType const& N)
+	{
+		return I - N * dot(N, I) * genType(2);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> reflect(vec<L, T, Q> const& I, vec<L, T, Q> const& N)
+	{
+		return detail::compute_reflect<L, T, Q, detail::is_aligned<Q>::value>::call(I, N);
+	}
+
+	// refract
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType refract(genType const& I, genType const& N, genType eta)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'refract' accepts only floating-point inputs");
+		genType const dotValue(dot(N, I));
+		genType const k(static_cast<genType>(1) - eta * eta * (static_cast<genType>(1) - dotValue * dotValue));
+		return (eta * I - (eta * dotValue + sqrt(k)) * N) * static_cast<genType>(k >= static_cast<genType>(0));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> refract(vec<L, T, Q> const& I, vec<L, T, Q> const& N, T eta)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'refract' accepts only floating-point inputs");
+		return detail::compute_refract<L, T, Q, detail::is_aligned<Q>::value>::call(I, N, eta);
+	}
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+#	include "func_geometric_simd.inl"
+#endif
diff --git a/engine/inc/glm/detail/func_geometric_simd.inl b/engine/inc/glm/detail/func_geometric_simd.inl
new file mode 100644
index 00000000..e6c8d85f
--- /dev/null
+++ b/engine/inc/glm/detail/func_geometric_simd.inl
@@ -0,0 +1,99 @@
+/// @ref core
+/// @file glm/detail/func_geometric_simd.inl
+
+#include "../simd/geometric.h"
+
+#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+namespace glm{
+namespace detail
+{
+	template<qualifier Q>
+	struct compute_length<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static float call(vec<4, float, Q> const& v)
+		{
+			return _mm_cvtss_f32(glm_vec4_length(v.data));
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_distance<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static float call(vec<4, float, Q> const& p0, vec<4, float, Q> const& p1)
+		{
+			return _mm_cvtss_f32(glm_vec4_distance(p0.data, p1.data));
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_dot<vec<4, float, Q>, float, true>
+	{
+		GLM_FUNC_QUALIFIER static float call(vec<4, float, Q> const& x, vec<4, float, Q> const& y)
+		{
+			return _mm_cvtss_f32(glm_vec1_dot(x.data, y.data));
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_cross<float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<3, float, Q> call(vec<3, float, Q> const& a, vec<3, float, Q> const& b)
+		{
+			__m128 const set0 = _mm_set_ps(0.0f, a.z, a.y, a.x);
+			__m128 const set1 = _mm_set_ps(0.0f, b.z, b.y, b.x);
+			__m128 const xpd0 = glm_vec4_cross(set0, set1);
+
+			vec<4, float, Q> Result;
+			Result.data = xpd0;
+			return vec<3, float, Q>(Result);
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_normalize<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
+		{
+			vec<4, float, Q> Result;
+			Result.data = glm_vec4_normalize(v.data);
+			return Result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_faceforward<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& N, vec<4, float, Q> const& I, vec<4, float, Q> const& Nref)
+		{
+			vec<4, float, Q> Result;
+			Result.data = glm_vec4_faceforward(N.data, I.data, Nref.data);
+			return Result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_reflect<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& I, vec<4, float, Q> const& N)
+		{
+			vec<4, float, Q> Result;
+			Result.data = glm_vec4_reflect(I.data, N.data);
+			return Result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_refract<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& I, vec<4, float, Q> const& N, float eta)
+		{
+			vec<4, float, Q> Result;
+			Result.data = glm_vec4_refract(I.data, N.data, _mm_set1_ps(eta));
+			return Result;
+		}
+	};
+}//namespace detail
+}//namespace glm
+
+#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
diff --git a/engine/inc/glm/detail/func_integer.inl b/engine/inc/glm/detail/func_integer.inl
new file mode 100644
index 00000000..f4067ffc
--- /dev/null
+++ b/engine/inc/glm/detail/func_integer.inl
@@ -0,0 +1,362 @@
+/// @ref core
+
+#include "_vectorize.hpp"
+#if(GLM_ARCH & GLM_ARCH_X86 && GLM_COMPILER & GLM_COMPILER_VC)
+#	include <intrin.h>
+#	pragma intrinsic(_BitScanReverse)
+#endif//(GLM_ARCH & GLM_ARCH_X86 && GLM_COMPILER & GLM_COMPILER_VC)
+#include <limits>
+
+#if !GLM_HAS_EXTENDED_INTEGER_TYPE
+#	if GLM_COMPILER & GLM_COMPILER_GCC
+#		pragma GCC diagnostic ignored "-Wlong-long"
+#	endif
+#	if (GLM_COMPILER & GLM_COMPILER_CLANG)
+#		pragma clang diagnostic ignored "-Wc++11-long-long"
+#	endif
+#endif
+
+namespace glm{
+namespace detail
+{
+	template<typename T>
+	GLM_FUNC_QUALIFIER T mask(T Bits)
+	{
+		return Bits >= static_cast<T>(sizeof(T) * 8) ? ~static_cast<T>(0) : (static_cast<T>(1) << Bits) - static_cast<T>(1);
+	}
+
+	template<length_t L, typename T, qualifier Q, bool Aligned, bool EXEC>
+	struct compute_bitfieldReverseStep
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& v, T, T)
+		{
+			return v;
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_bitfieldReverseStep<L, T, Q, Aligned, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& v, T Mask, T Shift)
+		{
+			return (v & Mask) << Shift | (v & (~Mask)) >> Shift;
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned, bool EXEC>
+	struct compute_bitfieldBitCountStep
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& v, T, T)
+		{
+			return v;
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_bitfieldBitCountStep<L, T, Q, Aligned, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& v, T Mask, T Shift)
+		{
+			return (v & Mask) + ((v >> Shift) & Mask);
+		}
+	};
+
+	template<typename genIUType, size_t Bits>
+	struct compute_findLSB
+	{
+		GLM_FUNC_QUALIFIER static int call(genIUType Value)
+		{
+			if(Value == 0)
+				return -1;
+
+			return glm::bitCount(~Value & (Value - static_cast<genIUType>(1)));
+		}
+	};
+
+#	if GLM_HAS_BITSCAN_WINDOWS
+		template<typename genIUType>
+		struct compute_findLSB<genIUType, 32>
+		{
+			GLM_FUNC_QUALIFIER static int call(genIUType Value)
+			{
+				unsigned long Result(0);
+				unsigned char IsNotNull = _BitScanForward(&Result, *reinterpret_cast<unsigned long*>(&Value));
+				return IsNotNull ? int(Result) : -1;
+			}
+		};
+
+#		if !((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_MODEL == GLM_MODEL_32))
+		template<typename genIUType>
+		struct compute_findLSB<genIUType, 64>
+		{
+			GLM_FUNC_QUALIFIER static int call(genIUType Value)
+			{
+				unsigned long Result(0);
+				unsigned char IsNotNull = _BitScanForward64(&Result, *reinterpret_cast<unsigned __int64*>(&Value));
+				return IsNotNull ? int(Result) : -1;
+			}
+		};
+#		endif
+#	endif//GLM_HAS_BITSCAN_WINDOWS
+
+	template<length_t L, typename T, qualifier Q, bool EXEC = true>
+	struct compute_findMSB_step_vec
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, T Shift)
+		{
+			return x | (x >> Shift);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q>
+	struct compute_findMSB_step_vec<L, T, Q, false>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, T)
+		{
+			return x;
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, int>
+	struct compute_findMSB_vec
+	{
+		GLM_FUNC_QUALIFIER static vec<L, int, Q> call(vec<L, T, Q> const& v)
+		{
+			vec<L, T, Q> x(v);
+			x = compute_findMSB_step_vec<L, T, Q, sizeof(T) * 8 >=  8>::call(x, static_cast<T>( 1));
+			x = compute_findMSB_step_vec<L, T, Q, sizeof(T) * 8 >=  8>::call(x, static_cast<T>( 2));
+			x = compute_findMSB_step_vec<L, T, Q, sizeof(T) * 8 >=  8>::call(x, static_cast<T>( 4));
+			x = compute_findMSB_step_vec<L, T, Q, sizeof(T) * 8 >= 16>::call(x, static_cast<T>( 8));
+			x = compute_findMSB_step_vec<L, T, Q, sizeof(T) * 8 >= 32>::call(x, static_cast<T>(16));
+			x = compute_findMSB_step_vec<L, T, Q, sizeof(T) * 8 >= 64>::call(x, static_cast<T>(32));
+			return vec<L, int, Q>(sizeof(T) * 8 - 1) - glm::bitCount(~x);
+		}
+	};
+
+#	if GLM_HAS_BITSCAN_WINDOWS
+		template<typename genIUType>
+		GLM_FUNC_QUALIFIER int compute_findMSB_32(genIUType Value)
+		{
+			unsigned long Result(0);
+			unsigned char IsNotNull = _BitScanReverse(&Result, *reinterpret_cast<unsigned long*>(&Value));
+			return IsNotNull ? int(Result) : -1;
+		}
+
+		template<length_t L, typename T, qualifier Q>
+		struct compute_findMSB_vec<L, T, Q, 32>
+		{
+			GLM_FUNC_QUALIFIER static vec<L, int, Q> call(vec<L, T, Q> const& x)
+			{
+				return detail::functor1<vec, L, int, T, Q>::call(compute_findMSB_32, x);
+			}
+		};
+
+#		if !((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_MODEL == GLM_MODEL_32))
+		template<typename genIUType>
+		GLM_FUNC_QUALIFIER int compute_findMSB_64(genIUType Value)
+		{
+			unsigned long Result(0);
+			unsigned char IsNotNull = _BitScanReverse64(&Result, *reinterpret_cast<unsigned __int64*>(&Value));
+			return IsNotNull ? int(Result) : -1;
+		}
+
+		template<length_t L, typename T, qualifier Q>
+		struct compute_findMSB_vec<L, T, Q, 64>
+		{
+			GLM_FUNC_QUALIFIER static vec<L, int, Q> call(vec<L, T, Q> const& x)
+			{
+				return detail::functor1<vec, L, int, T, Q>::call(compute_findMSB_64, x);
+			}
+		};
+#		endif
+#	endif//GLM_HAS_BITSCAN_WINDOWS
+}//namespace detail
+
+	// uaddCarry
+	GLM_FUNC_QUALIFIER uint uaddCarry(uint const& x, uint const& y, uint & Carry)
+	{
+		detail::uint64 const Value64(static_cast<detail::uint64>(x) + static_cast<detail::uint64>(y));
+		detail::uint64 const Max32((static_cast<detail::uint64>(1) << static_cast<detail::uint64>(32)) - static_cast<detail::uint64>(1));
+		Carry = Value64 > Max32 ? 1u : 0u;
+		return static_cast<uint>(Value64 % (Max32 + static_cast<detail::uint64>(1)));
+	}
+
+	template<length_t L, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, uint, Q> uaddCarry(vec<L, uint, Q> const& x, vec<L, uint, Q> const& y, vec<L, uint, Q>& Carry)
+	{
+		vec<L, detail::uint64, Q> Value64(vec<L, detail::uint64, Q>(x) + vec<L, detail::uint64, Q>(y));
+		vec<L, detail::uint64, Q> Max32((static_cast<detail::uint64>(1) << static_cast<detail::uint64>(32)) - static_cast<detail::uint64>(1));
+		Carry = mix(vec<L, uint, Q>(0), vec<L, uint, Q>(1), greaterThan(Value64, Max32));
+		return vec<L, uint, Q>(Value64 % (Max32 + static_cast<detail::uint64>(1)));
+	}
+
+	// usubBorrow
+	GLM_FUNC_QUALIFIER uint usubBorrow(uint const& x, uint const& y, uint & Borrow)
+	{
+		Borrow = x >= y ? static_cast<uint>(0) : static_cast<uint>(1);
+		if(y >= x)
+			return y - x;
+		else
+			return static_cast<uint>((static_cast<detail::int64>(1) << static_cast<detail::int64>(32)) + (static_cast<detail::int64>(y) - static_cast<detail::int64>(x)));
+	}
+
+	template<length_t L, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, uint, Q> usubBorrow(vec<L, uint, Q> const& x, vec<L, uint, Q> const& y, vec<L, uint, Q>& Borrow)
+	{
+		Borrow = mix(vec<L, uint, Q>(1), vec<L, uint, Q>(0), greaterThanEqual(x, y));
+		vec<L, uint, Q> const YgeX(y - x);
+		vec<L, uint, Q> const XgeY(vec<L, uint, Q>((static_cast<detail::int64>(1) << static_cast<detail::int64>(32)) + (vec<L, detail::int64, Q>(y) - vec<L, detail::int64, Q>(x))));
+		return mix(XgeY, YgeX, greaterThanEqual(y, x));
+	}
+
+	// umulExtended
+	GLM_FUNC_QUALIFIER void umulExtended(uint const& x, uint const& y, uint & msb, uint & lsb)
+	{
+		detail::uint64 Value64 = static_cast<detail::uint64>(x) * static_cast<detail::uint64>(y);
+		msb = static_cast<uint>(Value64 >> static_cast<detail::uint64>(32));
+		lsb = static_cast<uint>(Value64);
+	}
+
+	template<length_t L, qualifier Q>
+	GLM_FUNC_QUALIFIER void umulExtended(vec<L, uint, Q> const& x, vec<L, uint, Q> const& y, vec<L, uint, Q>& msb, vec<L, uint, Q>& lsb)
+	{
+		vec<L, detail::uint64, Q> Value64(vec<L, detail::uint64, Q>(x) * vec<L, detail::uint64, Q>(y));
+		msb = vec<L, uint, Q>(Value64 >> static_cast<detail::uint64>(32));
+		lsb = vec<L, uint, Q>(Value64);
+	}
+
+	// imulExtended
+	GLM_FUNC_QUALIFIER void imulExtended(int x, int y, int& msb, int& lsb)
+	{
+		detail::int64 Value64 = static_cast<detail::int64>(x) * static_cast<detail::int64>(y);
+		msb = static_cast<int>(Value64 >> static_cast<detail::int64>(32));
+		lsb = static_cast<int>(Value64);
+	}
+
+	template<length_t L, qualifier Q>
+	GLM_FUNC_QUALIFIER void imulExtended(vec<L, int, Q> const& x, vec<L, int, Q> const& y, vec<L, int, Q>& msb, vec<L, int, Q>& lsb)
+	{
+		vec<L, detail::int64, Q> Value64(vec<L, detail::int64, Q>(x) * vec<L, detail::int64, Q>(y));
+		lsb = vec<L, int, Q>(Value64 & static_cast<detail::int64>(0xFFFFFFFF));
+		msb = vec<L, int, Q>((Value64 >> static_cast<detail::int64>(32)) & static_cast<detail::int64>(0xFFFFFFFF));
+	}
+
+	// bitfieldExtract
+	template<typename genIUType>
+	GLM_FUNC_QUALIFIER genIUType bitfieldExtract(genIUType Value, int Offset, int Bits)
+	{
+		return bitfieldExtract(vec<1, genIUType>(Value), Offset, Bits).x;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> bitfieldExtract(vec<L, T, Q> const& Value, int Offset, int Bits)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldExtract' only accept integer inputs");
+
+		return (Value >> static_cast<T>(Offset)) & static_cast<T>(detail::mask(Bits));
+	}
+
+	// bitfieldInsert
+	template<typename genIUType>
+	GLM_FUNC_QUALIFIER genIUType bitfieldInsert(genIUType const& Base, genIUType const& Insert, int Offset, int Bits)
+	{
+		return bitfieldInsert(vec<1, genIUType>(Base), vec<1, genIUType>(Insert), Offset, Bits).x;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> bitfieldInsert(vec<L, T, Q> const& Base, vec<L, T, Q> const& Insert, int Offset, int Bits)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldInsert' only accept integer values");
+
+		T const Mask = static_cast<T>(detail::mask(Bits) << Offset);
+		return (Base & ~Mask) | ((Insert << static_cast<T>(Offset)) & Mask);
+	}
+
+	// bitfieldReverse
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType bitfieldReverse(genType x)
+	{
+		return bitfieldReverse(glm::vec<1, genType, glm::defaultp>(x)).x;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> bitfieldReverse(vec<L, T, Q> const& v)
+	{
+		vec<L, T, Q> x(v);
+		x = detail::compute_bitfieldReverseStep<L, T, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>=  2>::call(x, static_cast<T>(0x5555555555555555ull), static_cast<T>( 1));
+		x = detail::compute_bitfieldReverseStep<L, T, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>=  4>::call(x, static_cast<T>(0x3333333333333333ull), static_cast<T>( 2));
+		x = detail::compute_bitfieldReverseStep<L, T, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>=  8>::call(x, static_cast<T>(0x0F0F0F0F0F0F0F0Full), static_cast<T>( 4));
+		x = detail::compute_bitfieldReverseStep<L, T, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>= 16>::call(x, static_cast<T>(0x00FF00FF00FF00FFull), static_cast<T>( 8));
+		x = detail::compute_bitfieldReverseStep<L, T, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>= 32>::call(x, static_cast<T>(0x0000FFFF0000FFFFull), static_cast<T>(16));
+		x = detail::compute_bitfieldReverseStep<L, T, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>= 64>::call(x, static_cast<T>(0x00000000FFFFFFFFull), static_cast<T>(32));
+		return x;
+	}
+
+	// bitCount
+	template<typename genType>
+	GLM_FUNC_QUALIFIER int bitCount(genType x)
+	{
+		return bitCount(glm::vec<1, genType, glm::defaultp>(x)).x;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, int, Q> bitCount(vec<L, T, Q> const& v)
+	{
+#		if GLM_COMPILER & GLM_COMPILER_VC
+#			pragma warning(push)
+#			pragma warning(disable : 4310) //cast truncates constant value
+#		endif
+
+		vec<L, typename detail::make_unsigned<T>::type, Q> x(*reinterpret_cast<vec<L, typename detail::make_unsigned<T>::type, Q> const *>(&v));
+		x = detail::compute_bitfieldBitCountStep<L, typename detail::make_unsigned<T>::type, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>=  2>::call(x, typename detail::make_unsigned<T>::type(0x5555555555555555ull), typename detail::make_unsigned<T>::type( 1));
+		x = detail::compute_bitfieldBitCountStep<L, typename detail::make_unsigned<T>::type, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>=  4>::call(x, typename detail::make_unsigned<T>::type(0x3333333333333333ull), typename detail::make_unsigned<T>::type( 2));
+		x = detail::compute_bitfieldBitCountStep<L, typename detail::make_unsigned<T>::type, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>=  8>::call(x, typename detail::make_unsigned<T>::type(0x0F0F0F0F0F0F0F0Full), typename detail::make_unsigned<T>::type( 4));
+		x = detail::compute_bitfieldBitCountStep<L, typename detail::make_unsigned<T>::type, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>= 16>::call(x, typename detail::make_unsigned<T>::type(0x00FF00FF00FF00FFull), typename detail::make_unsigned<T>::type( 8));
+		x = detail::compute_bitfieldBitCountStep<L, typename detail::make_unsigned<T>::type, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>= 32>::call(x, typename detail::make_unsigned<T>::type(0x0000FFFF0000FFFFull), typename detail::make_unsigned<T>::type(16));
+		x = detail::compute_bitfieldBitCountStep<L, typename detail::make_unsigned<T>::type, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>= 64>::call(x, typename detail::make_unsigned<T>::type(0x00000000FFFFFFFFull), typename detail::make_unsigned<T>::type(32));
+		return vec<L, int, Q>(x);
+
+#		if GLM_COMPILER & GLM_COMPILER_VC
+#			pragma warning(pop)
+#		endif
+	}
+
+	// findLSB
+	template<typename genIUType>
+	GLM_FUNC_QUALIFIER int findLSB(genIUType Value)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findLSB' only accept integer values");
+
+		return detail::compute_findLSB<genIUType, sizeof(genIUType) * 8>::call(Value);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, int, Q> findLSB(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'findLSB' only accept integer values");
+
+		return detail::functor1<vec, L, int, T, Q>::call(findLSB, x);
+	}
+
+	// findMSB
+	template<typename genIUType>
+	GLM_FUNC_QUALIFIER int findMSB(genIUType v)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
+
+		return findMSB(vec<1, genIUType>(v)).x;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, int, Q> findMSB(vec<L, T, Q> const& v)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'findMSB' only accept integer values");
+
+		return detail::compute_findMSB_vec<L, T, Q, sizeof(T) * 8>::call(v);
+	}
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+#	include "func_integer_simd.inl"
+#endif
+
diff --git a/engine/inc/glm/detail/func_integer_simd.inl b/engine/inc/glm/detail/func_integer_simd.inl
new file mode 100644
index 00000000..8be6c9ce
--- /dev/null
+++ b/engine/inc/glm/detail/func_integer_simd.inl
@@ -0,0 +1,65 @@
+#include "../simd/integer.h"
+
+#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+namespace glm{
+namespace detail
+{
+	template<qualifier Q>
+	struct compute_bitfieldReverseStep<4, uint, Q, true, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, uint, Q> call(vec<4, uint, Q> const& v, uint Mask, uint Shift)
+		{
+			__m128i const set0 = v.data;
+
+			__m128i const set1 = _mm_set1_epi32(static_cast<int>(Mask));
+			__m128i const and1 = _mm_and_si128(set0, set1);
+			__m128i const sft1 = _mm_slli_epi32(and1, Shift);
+
+			__m128i const set2 = _mm_andnot_si128(set0, _mm_set1_epi32(-1));
+			__m128i const and2 = _mm_and_si128(set0, set2);
+			__m128i const sft2 = _mm_srai_epi32(and2, Shift);
+
+			__m128i const or0 = _mm_or_si128(sft1, sft2);
+
+			return or0;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_bitfieldBitCountStep<4, uint, Q, true, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, uint, Q> call(vec<4, uint, Q> const& v, uint Mask, uint Shift)
+		{
+			__m128i const set0 = v.data;
+
+			__m128i const set1 = _mm_set1_epi32(static_cast<int>(Mask));
+			__m128i const and0 = _mm_and_si128(set0, set1);
+			__m128i const sft0 = _mm_slli_epi32(set0, Shift);
+			__m128i const and1 = _mm_and_si128(sft0, set1);
+			__m128i const add0 = _mm_add_epi32(and0, and1);
+
+			return add0;
+		}
+	};
+}//namespace detail
+
+#	if GLM_ARCH & GLM_ARCH_AVX_BIT
+	template<>
+	GLM_FUNC_QUALIFIER int bitCount(uint x)
+	{
+		return _mm_popcnt_u32(x);
+	}
+
+#	if(GLM_MODEL == GLM_MODEL_64)
+	template<>
+	GLM_FUNC_QUALIFIER int bitCount(detail::uint64 x)
+	{
+		return static_cast<int>(_mm_popcnt_u64(x));
+	}
+#	endif//GLM_MODEL
+#	endif//GLM_ARCH
+
+}//namespace glm
+
+#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
diff --git a/engine/inc/glm/detail/func_matrix.inl b/engine/inc/glm/detail/func_matrix.inl
new file mode 100644
index 00000000..d980c6d3
--- /dev/null
+++ b/engine/inc/glm/detail/func_matrix.inl
@@ -0,0 +1,398 @@
+#include "../geometric.hpp"
+#include <limits>
+
+namespace glm{
+namespace detail
+{
+	template<length_t C, length_t R, typename T, qualifier Q, bool Aligned>
+	struct compute_matrixCompMult
+	{
+		GLM_FUNC_QUALIFIER static mat<C, R, T, Q> call(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y)
+		{
+			mat<C, R, T, Q> Result;
+			for(length_t i = 0; i < Result.length(); ++i)
+				Result[i] = x[i] * y[i];
+			return Result;
+		}
+	};
+
+	template<length_t C, length_t R, typename T, qualifier Q, bool Aligned>
+	struct compute_transpose{};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_transpose<2, 2, T, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static mat<2, 2, T, Q> call(mat<2, 2, T, Q> const& m)
+		{
+			mat<2, 2, T, Q> Result;
+			Result[0][0] = m[0][0];
+			Result[0][1] = m[1][0];
+			Result[1][0] = m[0][1];
+			Result[1][1] = m[1][1];
+			return Result;
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_transpose<2, 3, T, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static mat<3, 2, T, Q> call(mat<2, 3, T, Q> const& m)
+		{
+			mat<3,2, T, Q> Result;
+			Result[0][0] = m[0][0];
+			Result[0][1] = m[1][0];
+			Result[1][0] = m[0][1];
+			Result[1][1] = m[1][1];
+			Result[2][0] = m[0][2];
+			Result[2][1] = m[1][2];
+			return Result;
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_transpose<2, 4, T, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static mat<4, 2, T, Q> call(mat<2, 4, T, Q> const& m)
+		{
+			mat<4, 2, T, Q> Result;
+			Result[0][0] = m[0][0];
+			Result[0][1] = m[1][0];
+			Result[1][0] = m[0][1];
+			Result[1][1] = m[1][1];
+			Result[2][0] = m[0][2];
+			Result[2][1] = m[1][2];
+			Result[3][0] = m[0][3];
+			Result[3][1] = m[1][3];
+			return Result;
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_transpose<3, 2, T, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static mat<2, 3, T, Q> call(mat<3, 2, T, Q> const& m)
+		{
+			mat<2, 3, T, Q> Result;
+			Result[0][0] = m[0][0];
+			Result[0][1] = m[1][0];
+			Result[0][2] = m[2][0];
+			Result[1][0] = m[0][1];
+			Result[1][1] = m[1][1];
+			Result[1][2] = m[2][1];
+			return Result;
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_transpose<3, 3, T, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static mat<3, 3, T, Q> call(mat<3, 3, T, Q> const& m)
+		{
+			mat<3, 3, T, Q> Result;
+			Result[0][0] = m[0][0];
+			Result[0][1] = m[1][0];
+			Result[0][2] = m[2][0];
+
+			Result[1][0] = m[0][1];
+			Result[1][1] = m[1][1];
+			Result[1][2] = m[2][1];
+
+			Result[2][0] = m[0][2];
+			Result[2][1] = m[1][2];
+			Result[2][2] = m[2][2];
+			return Result;
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_transpose<3, 4, T, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static mat<4, 3, T, Q> call(mat<3, 4, T, Q> const& m)
+		{
+			mat<4, 3, T, Q> Result;
+			Result[0][0] = m[0][0];
+			Result[0][1] = m[1][0];
+			Result[0][2] = m[2][0];
+			Result[1][0] = m[0][1];
+			Result[1][1] = m[1][1];
+			Result[1][2] = m[2][1];
+			Result[2][0] = m[0][2];
+			Result[2][1] = m[1][2];
+			Result[2][2] = m[2][2];
+			Result[3][0] = m[0][3];
+			Result[3][1] = m[1][3];
+			Result[3][2] = m[2][3];
+			return Result;
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_transpose<4, 2, T, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static mat<2, 4, T, Q> call(mat<4, 2, T, Q> const& m)
+		{
+			mat<2, 4, T, Q> Result;
+			Result[0][0] = m[0][0];
+			Result[0][1] = m[1][0];
+			Result[0][2] = m[2][0];
+			Result[0][3] = m[3][0];
+			Result[1][0] = m[0][1];
+			Result[1][1] = m[1][1];
+			Result[1][2] = m[2][1];
+			Result[1][3] = m[3][1];
+			return Result;
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_transpose<4, 3, T, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static mat<3, 4, T, Q> call(mat<4, 3, T, Q> const& m)
+		{
+			mat<3, 4, T, Q> Result;
+			Result[0][0] = m[0][0];
+			Result[0][1] = m[1][0];
+			Result[0][2] = m[2][0];
+			Result[0][3] = m[3][0];
+			Result[1][0] = m[0][1];
+			Result[1][1] = m[1][1];
+			Result[1][2] = m[2][1];
+			Result[1][3] = m[3][1];
+			Result[2][0] = m[0][2];
+			Result[2][1] = m[1][2];
+			Result[2][2] = m[2][2];
+			Result[2][3] = m[3][2];
+			return Result;
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_transpose<4, 4, T, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static mat<4, 4, T, Q> call(mat<4, 4, T, Q> const& m)
+		{
+			mat<4, 4, T, Q> Result;
+			Result[0][0] = m[0][0];
+			Result[0][1] = m[1][0];
+			Result[0][2] = m[2][0];
+			Result[0][3] = m[3][0];
+
+			Result[1][0] = m[0][1];
+			Result[1][1] = m[1][1];
+			Result[1][2] = m[2][1];
+			Result[1][3] = m[3][1];
+
+			Result[2][0] = m[0][2];
+			Result[2][1] = m[1][2];
+			Result[2][2] = m[2][2];
+			Result[2][3] = m[3][2];
+
+			Result[3][0] = m[0][3];
+			Result[3][1] = m[1][3];
+			Result[3][2] = m[2][3];
+			Result[3][3] = m[3][3];
+			return Result;
+		}
+	};
+
+	template<length_t C, length_t R, typename T, qualifier Q, bool Aligned>
+	struct compute_determinant{};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_determinant<2, 2, T, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static T call(mat<2, 2, T, Q> const& m)
+		{
+			return m[0][0] * m[1][1] - m[1][0] * m[0][1];
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_determinant<3, 3, T, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static T call(mat<3, 3, T, Q> const& m)
+		{
+			return
+				+ m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2])
+				- m[1][0] * (m[0][1] * m[2][2] - m[2][1] * m[0][2])
+				+ m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_determinant<4, 4, T, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static T call(mat<4, 4, T, Q> const& m)
+		{
+			T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+			T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+			T SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+			T SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+			T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+			T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+
+			vec<4, T, Q> DetCof(
+				+ (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02),
+				- (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04),
+				+ (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05),
+				- (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05));
+
+			return
+				m[0][0] * DetCof[0] + m[0][1] * DetCof[1] +
+				m[0][2] * DetCof[2] + m[0][3] * DetCof[3];
+		}
+	};
+
+	template<length_t C, length_t R, typename T, qualifier Q, bool Aligned>
+	struct compute_inverse{};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_inverse<2, 2, T, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static mat<2, 2, T, Q> call(mat<2, 2, T, Q> const& m)
+		{
+			T OneOverDeterminant = static_cast<T>(1) / (
+				+ m[0][0] * m[1][1]
+				- m[1][0] * m[0][1]);
+
+			mat<2, 2, T, Q> Inverse(
+				+ m[1][1] * OneOverDeterminant,
+				- m[0][1] * OneOverDeterminant,
+				- m[1][0] * OneOverDeterminant,
+				+ m[0][0] * OneOverDeterminant);
+
+			return Inverse;
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_inverse<3, 3, T, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static mat<3, 3, T, Q> call(mat<3, 3, T, Q> const& m)
+		{
+			T OneOverDeterminant = static_cast<T>(1) / (
+				+ m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2])
+				- m[1][0] * (m[0][1] * m[2][2] - m[2][1] * m[0][2])
+				+ m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2]));
+
+			mat<3, 3, T, Q> Inverse;
+			Inverse[0][0] = + (m[1][1] * m[2][2] - m[2][1] * m[1][2]) * OneOverDeterminant;
+			Inverse[1][0] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]) * OneOverDeterminant;
+			Inverse[2][0] = + (m[1][0] * m[2][1] - m[2][0] * m[1][1]) * OneOverDeterminant;
+			Inverse[0][1] = - (m[0][1] * m[2][2] - m[2][1] * m[0][2]) * OneOverDeterminant;
+			Inverse[1][1] = + (m[0][0] * m[2][2] - m[2][0] * m[0][2]) * OneOverDeterminant;
+			Inverse[2][1] = - (m[0][0] * m[2][1] - m[2][0] * m[0][1]) * OneOverDeterminant;
+			Inverse[0][2] = + (m[0][1] * m[1][2] - m[1][1] * m[0][2]) * OneOverDeterminant;
+			Inverse[1][2] = - (m[0][0] * m[1][2] - m[1][0] * m[0][2]) * OneOverDeterminant;
+			Inverse[2][2] = + (m[0][0] * m[1][1] - m[1][0] * m[0][1]) * OneOverDeterminant;
+
+			return Inverse;
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_inverse<4, 4, T, Q, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static mat<4, 4, T, Q> call(mat<4, 4, T, Q> const& m)
+		{
+			T Coef00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+			T Coef02 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
+			T Coef03 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
+
+			T Coef04 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+			T Coef06 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
+			T Coef07 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
+
+			T Coef08 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+			T Coef10 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
+			T Coef11 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
+
+			T Coef12 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+			T Coef14 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
+			T Coef15 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
+
+			T Coef16 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+			T Coef18 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
+			T Coef19 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
+
+			T Coef20 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+			T Coef22 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
+			T Coef23 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
+
+			vec<4, T, Q> Fac0(Coef00, Coef00, Coef02, Coef03);
+			vec<4, T, Q> Fac1(Coef04, Coef04, Coef06, Coef07);
+			vec<4, T, Q> Fac2(Coef08, Coef08, Coef10, Coef11);
+			vec<4, T, Q> Fac3(Coef12, Coef12, Coef14, Coef15);
+			vec<4, T, Q> Fac4(Coef16, Coef16, Coef18, Coef19);
+			vec<4, T, Q> Fac5(Coef20, Coef20, Coef22, Coef23);
+
+			vec<4, T, Q> Vec0(m[1][0], m[0][0], m[0][0], m[0][0]);
+			vec<4, T, Q> Vec1(m[1][1], m[0][1], m[0][1], m[0][1]);
+			vec<4, T, Q> Vec2(m[1][2], m[0][2], m[0][2], m[0][2]);
+			vec<4, T, Q> Vec3(m[1][3], m[0][3], m[0][3], m[0][3]);
+
+			vec<4, T, Q> Inv0(Vec1 * Fac0 - Vec2 * Fac1 + Vec3 * Fac2);
+			vec<4, T, Q> Inv1(Vec0 * Fac0 - Vec2 * Fac3 + Vec3 * Fac4);
+			vec<4, T, Q> Inv2(Vec0 * Fac1 - Vec1 * Fac3 + Vec3 * Fac5);
+			vec<4, T, Q> Inv3(Vec0 * Fac2 - Vec1 * Fac4 + Vec2 * Fac5);
+
+			vec<4, T, Q> SignA(+1, -1, +1, -1);
+			vec<4, T, Q> SignB(-1, +1, -1, +1);
+			mat<4, 4, T, Q> Inverse(Inv0 * SignA, Inv1 * SignB, Inv2 * SignA, Inv3 * SignB);
+
+			vec<4, T, Q> Row0(Inverse[0][0], Inverse[1][0], Inverse[2][0], Inverse[3][0]);
+
+			vec<4, T, Q> Dot0(m[0] * Row0);
+			T Dot1 = (Dot0.x + Dot0.y) + (Dot0.z + Dot0.w);
+
+			T OneOverDeterminant = static_cast<T>(1) / Dot1;
+
+			return Inverse * OneOverDeterminant;
+		}
+	};
+}//namespace detail
+
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<C, R, T, Q> matrixCompMult(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'matrixCompMult' only accept floating-point inputs");
+		return detail::compute_matrixCompMult<C, R, T, Q, detail::is_aligned<Q>::value>::call(x, y);
+	}
+
+	template<length_t DA, length_t DB, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename detail::outerProduct_trait<DA, DB, T, Q>::type outerProduct(vec<DA, T, Q> const& c, vec<DB, T, Q> const& r)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'outerProduct' only accept floating-point inputs");
+
+		typename detail::outerProduct_trait<DA, DB, T, Q>::type m;
+		for(length_t i = 0; i < m.length(); ++i)
+			m[i] = c * r[i];
+		return m;
+	}
+
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<C, R, T, Q>::transpose_type transpose(mat<C, R, T, Q> const& m)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'transpose' only accept floating-point inputs");
+		return detail::compute_transpose<C, R, T, Q, detail::is_aligned<Q>::value>::call(m);
+	}
+
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T determinant(mat<C, R, T, Q> const& m)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'determinant' only accept floating-point inputs");
+		return detail::compute_determinant<C, R, T, Q, detail::is_aligned<Q>::value>::call(m);
+	}
+
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<C, R, T, Q> inverse(mat<C, R, T, Q> const& m)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'inverse' only accept floating-point inputs");
+		return detail::compute_inverse<C, R, T, Q, detail::is_aligned<Q>::value>::call(m);
+	}
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+#	include "func_matrix_simd.inl"
+#endif
+
diff --git a/engine/inc/glm/detail/func_matrix_simd.inl b/engine/inc/glm/detail/func_matrix_simd.inl
new file mode 100644
index 00000000..f7337fe7
--- /dev/null
+++ b/engine/inc/glm/detail/func_matrix_simd.inl
@@ -0,0 +1,94 @@
+#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+#include "type_mat4x4.hpp"
+#include "../geometric.hpp"
+#include "../simd/matrix.h"
+#include <cstring>
+
+namespace glm{
+namespace detail
+{
+#	if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE
+	template<qualifier Q>
+	struct compute_matrixCompMult<4, 4, float, Q, true>
+	{
+		GLM_STATIC_ASSERT(detail::is_aligned<Q>::value, "Specialization requires aligned");
+
+		GLM_FUNC_QUALIFIER static mat<4, 4, float, Q> call(mat<4, 4, float, Q> const& x, mat<4, 4, float, Q> const& y)
+		{
+			mat<4, 4, float, Q> Result;
+			glm_mat4_matrixCompMult(
+				*static_cast<glm_vec4 const (*)[4]>(&x[0].data),
+				*static_cast<glm_vec4 const (*)[4]>(&y[0].data),
+				*static_cast<glm_vec4(*)[4]>(&Result[0].data));
+			return Result;
+		}
+	};
+#	endif
+
+	template<qualifier Q>
+	struct compute_transpose<4, 4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static mat<4, 4, float, Q> call(mat<4, 4, float, Q> const& m)
+		{
+			mat<4, 4, float, Q> Result;
+			glm_mat4_transpose(&m[0].data, &Result[0].data);
+			return Result;
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_determinant<4, 4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static float call(mat<4, 4, float, Q> const& m)
+		{
+			return _mm_cvtss_f32(glm_mat4_determinant(&m[0].data));
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_inverse<4, 4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static mat<4, 4, float, Q> call(mat<4, 4, float, Q> const& m)
+		{
+			mat<4, 4, float, Q> Result;
+			glm_mat4_inverse(&m[0].data, &Result[0].data);
+			return Result;
+		}
+	};
+}//namespace detail
+
+#	if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE
+	template<>
+	GLM_FUNC_QUALIFIER mat<4, 4, float, aligned_lowp> outerProduct<4, 4, float, aligned_lowp>(vec<4, float, aligned_lowp> const& c, vec<4, float, aligned_lowp> const& r)
+	{
+		__m128 NativeResult[4];
+		glm_mat4_outerProduct(c.data, r.data, NativeResult);
+		mat<4, 4, float, aligned_lowp> Result;
+		std::memcpy(&Result[0], &NativeResult[0], sizeof(Result));
+		return Result;
+	}
+
+	template<>
+	GLM_FUNC_QUALIFIER mat<4, 4, float, aligned_mediump> outerProduct<4, 4, float, aligned_mediump>(vec<4, float, aligned_mediump> const& c, vec<4, float, aligned_mediump> const& r)
+	{
+		__m128 NativeResult[4];
+		glm_mat4_outerProduct(c.data, r.data, NativeResult);
+		mat<4, 4, float, aligned_mediump> Result;
+		std::memcpy(&Result[0], &NativeResult[0], sizeof(Result));
+		return Result;
+	}
+
+	template<>
+	GLM_FUNC_QUALIFIER mat<4, 4, float, aligned_highp> outerProduct<4, 4, float, aligned_highp>(vec<4, float, aligned_highp> const& c, vec<4, float, aligned_highp> const& r)
+	{
+		__m128 NativeResult[4];
+		glm_mat4_outerProduct(c.data, r.data, NativeResult);
+		mat<4, 4, float, aligned_highp> Result;
+		std::memcpy(&Result[0], &NativeResult[0], sizeof(Result));
+		return Result;
+	}
+#	endif
+}//namespace glm
+
+#endif
diff --git a/engine/inc/glm/detail/func_packing.inl b/engine/inc/glm/detail/func_packing.inl
new file mode 100644
index 00000000..234b093c
--- /dev/null
+++ b/engine/inc/glm/detail/func_packing.inl
@@ -0,0 +1,189 @@
+/// @ref core
+/// @file glm/detail/func_packing.inl
+
+#include "../common.hpp"
+#include "type_half.hpp"
+
+namespace glm
+{
+	GLM_FUNC_QUALIFIER uint packUnorm2x16(vec2 const& v)
+	{
+		union
+		{
+			unsigned short in[2];
+			uint out;
+		} u;
+
+		vec<2, unsigned short, defaultp> result(round(clamp(v, 0.0f, 1.0f) * 65535.0f));
+
+		u.in[0] = result[0];
+		u.in[1] = result[1];
+
+		return u.out;
+	}
+
+	GLM_FUNC_QUALIFIER vec2 unpackUnorm2x16(uint p)
+	{
+		union
+		{
+			uint in;
+			unsigned short out[2];
+		} u;
+
+		u.in = p;
+
+		return vec2(u.out[0], u.out[1]) * 1.5259021896696421759365224689097e-5f;
+	}
+
+	GLM_FUNC_QUALIFIER uint packSnorm2x16(vec2 const& v)
+	{
+		union
+		{
+			signed short in[2];
+			uint out;
+		} u;
+ 
+		vec<2, short, defaultp> result(round(clamp(v, -1.0f, 1.0f) * 32767.0f));
+
+		u.in[0] = result[0];
+		u.in[1] = result[1];
+
+		return u.out;
+	}
+
+	GLM_FUNC_QUALIFIER vec2 unpackSnorm2x16(uint p)
+	{
+		union
+		{
+			uint in;
+			signed short out[2];
+		} u;
+
+		u.in = p;
+
+		return clamp(vec2(u.out[0], u.out[1]) * 3.0518509475997192297128208258309e-5f, -1.0f, 1.0f);
+	}
+
+	GLM_FUNC_QUALIFIER uint packUnorm4x8(vec4 const& v)
+	{
+		union
+		{
+			unsigned char in[4];
+			uint out;
+		} u;
+
+		vec<4, unsigned char, defaultp> result(round(clamp(v, 0.0f, 1.0f) * 255.0f));
+
+		u.in[0] = result[0];
+		u.in[1] = result[1];
+		u.in[2] = result[2];
+		u.in[3] = result[3];
+
+		return u.out;
+	}
+
+	GLM_FUNC_QUALIFIER vec4 unpackUnorm4x8(uint p)
+	{
+		union
+		{
+			uint in;
+			unsigned char out[4];
+		} u;
+
+		u.in = p;
+
+		return vec4(u.out[0], u.out[1], u.out[2], u.out[3]) * 0.0039215686274509803921568627451f;
+	}
+
+	GLM_FUNC_QUALIFIER uint packSnorm4x8(vec4 const& v)
+	{
+		union
+		{
+			signed char in[4];
+			uint out;
+		} u;
+
+		vec<4, signed char, defaultp> result(round(clamp(v, -1.0f, 1.0f) * 127.0f));
+
+		u.in[0] = result[0];
+		u.in[1] = result[1];
+		u.in[2] = result[2];
+		u.in[3] = result[3];
+
+		return u.out;
+	}
+
+	GLM_FUNC_QUALIFIER glm::vec4 unpackSnorm4x8(uint p)
+	{
+		union
+		{
+			uint in;
+			signed char out[4];
+		} u;
+
+		u.in = p;
+
+		return clamp(vec4(u.out[0], u.out[1], u.out[2], u.out[3]) * 0.0078740157480315f, -1.0f, 1.0f);
+	}
+
+	GLM_FUNC_QUALIFIER double packDouble2x32(uvec2 const& v)
+	{
+		union
+		{
+			uint   in[2];
+			double out;
+		} u;
+
+		u.in[0] = v[0];
+		u.in[1] = v[1];
+
+		return u.out;
+	}
+
+	GLM_FUNC_QUALIFIER uvec2 unpackDouble2x32(double v)
+	{
+		union
+		{
+			double in;
+			uint   out[2];
+		} u;
+
+		u.in = v;
+
+		return uvec2(u.out[0], u.out[1]);
+	}
+
+	GLM_FUNC_QUALIFIER uint packHalf2x16(vec2 const& v)
+	{
+		union
+		{
+			signed short in[2];
+			uint out;
+		} u;
+
+		u.in[0] = detail::toFloat16(v.x);
+		u.in[1] = detail::toFloat16(v.y);
+
+		return u.out;
+	}
+
+	GLM_FUNC_QUALIFIER vec2 unpackHalf2x16(uint v)
+	{
+		union
+		{
+			uint in;
+			signed short out[2];
+		} u;
+
+		u.in = v;
+
+		return vec2(
+			detail::toFloat32(u.out[0]),
+			detail::toFloat32(u.out[1]));
+	}
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+#	include "func_packing_simd.inl"
+#endif
+
diff --git a/engine/inc/glm/detail/func_packing_simd.inl b/engine/inc/glm/detail/func_packing_simd.inl
new file mode 100644
index 00000000..fd0fe8b7
--- /dev/null
+++ b/engine/inc/glm/detail/func_packing_simd.inl
@@ -0,0 +1,6 @@
+namespace glm{
+namespace detail
+{
+
+}//namespace detail
+}//namespace glm
diff --git a/engine/inc/glm/detail/func_trigonometric.inl b/engine/inc/glm/detail/func_trigonometric.inl
new file mode 100644
index 00000000..e129dcea
--- /dev/null
+++ b/engine/inc/glm/detail/func_trigonometric.inl
@@ -0,0 +1,197 @@
+#include "_vectorize.hpp"
+#include <cmath>
+#include <limits>
+
+namespace glm
+{
+	// radians
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType radians(genType degrees)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'radians' only accept floating-point input");
+
+		return degrees * static_cast<genType>(0.01745329251994329576923690768489);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> radians(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(radians, v);
+	}
+
+	// degrees
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType degrees(genType radians)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'degrees' only accept floating-point input");
+
+		return radians * static_cast<genType>(57.295779513082320876798154814105);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> degrees(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(degrees, v);
+	}
+
+	// sin
+	using ::std::sin;
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> sin(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(sin, v);
+	}
+
+	// cos
+	using std::cos;
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> cos(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(cos, v);
+	}
+
+	// tan
+	using std::tan;
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> tan(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(tan, v);
+	}
+
+	// asin
+	using std::asin;
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> asin(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(asin, v);
+	}
+
+	// acos
+	using std::acos;
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> acos(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(acos, v);
+	}
+
+	// atan
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType atan(genType y, genType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'atan' only accept floating-point input");
+
+		return ::std::atan2(y, x);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> atan(vec<L, T, Q> const& a, vec<L, T, Q> const& b)
+	{
+		return detail::functor2<vec, L, T, Q>::call(::std::atan2, a, b);
+	}
+
+	using std::atan;
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> atan(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(atan, v);
+	}
+
+	// sinh
+	using std::sinh;
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> sinh(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(sinh, v);
+	}
+
+	// cosh
+	using std::cosh;
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> cosh(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(cosh, v);
+	}
+
+	// tanh
+	using std::tanh;
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> tanh(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(tanh, v);
+	}
+
+	// asinh
+#	if GLM_HAS_CXX11_STL
+		using std::asinh;
+#	else
+		template<typename genType>
+		GLM_FUNC_QUALIFIER genType asinh(genType x)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'asinh' only accept floating-point input");
+
+			return (x < static_cast<genType>(0) ? static_cast<genType>(-1) : (x > static_cast<genType>(0) ? static_cast<genType>(1) : static_cast<genType>(0))) * log(std::abs(x) + sqrt(static_cast<genType>(1) + x * x));
+		}
+#	endif
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> asinh(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(asinh, v);
+	}
+
+	// acosh
+#	if GLM_HAS_CXX11_STL
+		using std::acosh;
+#	else
+		template<typename genType>
+		GLM_FUNC_QUALIFIER genType acosh(genType x)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'acosh' only accept floating-point input");
+
+			if(x < static_cast<genType>(1))
+				return static_cast<genType>(0);
+			return log(x + sqrt(x * x - static_cast<genType>(1)));
+		}
+#	endif
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> acosh(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(acosh, v);
+	}
+
+	// atanh
+#	if GLM_HAS_CXX11_STL
+		using std::atanh;
+#	else
+		template<typename genType>
+		GLM_FUNC_QUALIFIER genType atanh(genType x)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'atanh' only accept floating-point input");
+
+			if(std::abs(x) >= static_cast<genType>(1))
+				return 0;
+			return static_cast<genType>(0.5) * log((static_cast<genType>(1) + x) / (static_cast<genType>(1) - x));
+		}
+#	endif
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> atanh(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(atanh, v);
+	}
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+#	include "func_trigonometric_simd.inl"
+#endif
+
diff --git a/data/scripts/main.lua b/engine/inc/glm/detail/func_trigonometric_simd.inl
similarity index 100%
rename from data/scripts/main.lua
rename to engine/inc/glm/detail/func_trigonometric_simd.inl
diff --git a/engine/inc/glm/detail/func_vector_relational.inl b/engine/inc/glm/detail/func_vector_relational.inl
new file mode 100644
index 00000000..80c9e87f
--- /dev/null
+++ b/engine/inc/glm/detail/func_vector_relational.inl
@@ -0,0 +1,87 @@
+namespace glm
+{
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, bool, Q> lessThan(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+	{
+		vec<L, bool, Q> Result(true);
+		for(length_t i = 0; i < L; ++i)
+			Result[i] = x[i] < y[i];
+		return Result;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, bool, Q> lessThanEqual(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+	{
+		vec<L, bool, Q> Result(true);
+		for(length_t i = 0; i < L; ++i)
+			Result[i] = x[i] <= y[i];
+		return Result;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, bool, Q> greaterThan(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+	{
+		vec<L, bool, Q> Result(true);
+		for(length_t i = 0; i < L; ++i)
+			Result[i] = x[i] > y[i];
+		return Result;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, bool, Q> greaterThanEqual(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+	{
+		vec<L, bool, Q> Result(true);
+		for(length_t i = 0; i < L; ++i)
+			Result[i] = x[i] >= y[i];
+		return Result;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, bool, Q> equal(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+	{
+		vec<L, bool, Q> Result(true);
+		for(length_t i = 0; i < L; ++i)
+			Result[i] = x[i] == y[i];
+		return Result;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, bool, Q> notEqual(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+	{
+		vec<L, bool, Q> Result(true);
+		for(length_t i = 0; i < L; ++i)
+			Result[i] = x[i] != y[i];
+		return Result;
+	}
+
+	template<length_t L, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool any(vec<L, bool, Q> const& v)
+	{
+		bool Result = false;
+		for(length_t i = 0; i < L; ++i)
+			Result = Result || v[i];
+		return Result;
+	}
+
+	template<length_t L, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool all(vec<L, bool, Q> const& v)
+	{
+		bool Result = true;
+		for(length_t i = 0; i < L; ++i)
+			Result = Result && v[i];
+		return Result;
+	}
+
+	template<length_t L, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, bool, Q> not_(vec<L, bool, Q> const& v)
+	{
+		vec<L, bool, Q> Result(true);
+		for(length_t i = 0; i < L; ++i)
+			Result[i] = !v[i];
+		return Result;
+	}
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+#	include "func_vector_relational_simd.inl"
+#endif
diff --git a/engine/inc/glm/detail/func_vector_relational_simd.inl b/engine/inc/glm/detail/func_vector_relational_simd.inl
new file mode 100644
index 00000000..fd0fe8b7
--- /dev/null
+++ b/engine/inc/glm/detail/func_vector_relational_simd.inl
@@ -0,0 +1,6 @@
+namespace glm{
+namespace detail
+{
+
+}//namespace detail
+}//namespace glm
diff --git a/engine/inc/glm/detail/glm.cpp b/engine/inc/glm/detail/glm.cpp
new file mode 100644
index 00000000..b76ce478
--- /dev/null
+++ b/engine/inc/glm/detail/glm.cpp
@@ -0,0 +1,261 @@
+/// @ref core
+/// @file glm/glm.cpp
+
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/dual_quaternion.hpp>
+#include <glm/gtc/vec1.hpp>
+#include <glm/gtc/quaternion.hpp>
+#include <glm/ext/scalar_int_sized.hpp>
+#include <glm/ext/scalar_uint_sized.hpp>
+#include <glm/glm.hpp>
+
+namespace glm
+{
+// tvec1 type explicit instantiation
+template struct vec<1, uint8, lowp>;
+template struct vec<1, uint16, lowp>;
+template struct vec<1, uint32, lowp>;
+template struct vec<1, uint64, lowp>;
+template struct vec<1, int8, lowp>;
+template struct vec<1, int16, lowp>;
+template struct vec<1, int32, lowp>;
+template struct vec<1, int64, lowp>;
+template struct vec<1, float32, lowp>;
+template struct vec<1, float64, lowp>;
+
+template struct vec<1, uint8, mediump>;
+template struct vec<1, uint16, mediump>;
+template struct vec<1, uint32, mediump>;
+template struct vec<1, uint64, mediump>;
+template struct vec<1, int8, mediump>;
+template struct vec<1, int16, mediump>;
+template struct vec<1, int32, mediump>;
+template struct vec<1, int64, mediump>;
+template struct vec<1, float32, mediump>;
+template struct vec<1, float64, mediump>;
+
+template struct vec<1, uint8, highp>;
+template struct vec<1, uint16, highp>;
+template struct vec<1, uint32, highp>;
+template struct vec<1, uint64, highp>;
+template struct vec<1, int8, highp>;
+template struct vec<1, int16, highp>;
+template struct vec<1, int32, highp>;
+template struct vec<1, int64, highp>;
+template struct vec<1, float32, highp>;
+template struct vec<1, float64, highp>;
+
+// tvec2 type explicit instantiation
+template struct vec<2, uint8, lowp>;
+template struct vec<2, uint16, lowp>;
+template struct vec<2, uint32, lowp>;
+template struct vec<2, uint64, lowp>;
+template struct vec<2, int8, lowp>;
+template struct vec<2, int16, lowp>;
+template struct vec<2, int32, lowp>;
+template struct vec<2, int64, lowp>;
+template struct vec<2, float32, lowp>;
+template struct vec<2, float64, lowp>;
+
+template struct vec<2, uint8, mediump>;
+template struct vec<2, uint16, mediump>;
+template struct vec<2, uint32, mediump>;
+template struct vec<2, uint64, mediump>;
+template struct vec<2, int8, mediump>;
+template struct vec<2, int16, mediump>;
+template struct vec<2, int32, mediump>;
+template struct vec<2, int64, mediump>;
+template struct vec<2, float32, mediump>;
+template struct vec<2, float64, mediump>;
+
+template struct vec<2, uint8, highp>;
+template struct vec<2, uint16, highp>;
+template struct vec<2, uint32, highp>;
+template struct vec<2, uint64, highp>;
+template struct vec<2, int8, highp>;
+template struct vec<2, int16, highp>;
+template struct vec<2, int32, highp>;
+template struct vec<2, int64, highp>;
+template struct vec<2, float32, highp>;
+template struct vec<2, float64, highp>;
+
+// tvec3 type explicit instantiation
+template struct vec<3, uint8, lowp>;
+template struct vec<3, uint16, lowp>;
+template struct vec<3, uint32, lowp>;
+template struct vec<3, uint64, lowp>;
+template struct vec<3, int8, lowp>;
+template struct vec<3, int16, lowp>;
+template struct vec<3, int32, lowp>;
+template struct vec<3, int64, lowp>;
+template struct vec<3, float32, lowp>;
+template struct vec<3, float64, lowp>;
+
+template struct vec<3, uint8, mediump>;
+template struct vec<3, uint16, mediump>;
+template struct vec<3, uint32, mediump>;
+template struct vec<3, uint64, mediump>;
+template struct vec<3, int8, mediump>;
+template struct vec<3, int16, mediump>;
+template struct vec<3, int32, mediump>;
+template struct vec<3, int64, mediump>;
+template struct vec<3, float32, mediump>;
+template struct vec<3, float64, mediump>;
+
+template struct vec<3, uint8, highp>;
+template struct vec<3, uint16, highp>;
+template struct vec<3, uint32, highp>;
+template struct vec<3, uint64, highp>;
+template struct vec<3, int8, highp>;
+template struct vec<3, int16, highp>;
+template struct vec<3, int32, highp>;
+template struct vec<3, int64, highp>;
+template struct vec<3, float32, highp>;
+template struct vec<3, float64, highp>;
+
+// tvec4 type explicit instantiation
+template struct vec<4, uint8, lowp>;
+template struct vec<4, uint16, lowp>;
+template struct vec<4, uint32, lowp>;
+template struct vec<4, uint64, lowp>;
+template struct vec<4, int8, lowp>;
+template struct vec<4, int16, lowp>;
+template struct vec<4, int32, lowp>;
+template struct vec<4, int64, lowp>;
+template struct vec<4, float32, lowp>;
+template struct vec<4, float64, lowp>;
+
+template struct vec<4, uint8, mediump>;
+template struct vec<4, uint16, mediump>;
+template struct vec<4, uint32, mediump>;
+template struct vec<4, uint64, mediump>;
+template struct vec<4, int8, mediump>;
+template struct vec<4, int16, mediump>;
+template struct vec<4, int32, mediump>;
+template struct vec<4, int64, mediump>;
+template struct vec<4, float32, mediump>;
+template struct vec<4, float64, mediump>;
+
+template struct vec<4, uint8, highp>;
+template struct vec<4, uint16, highp>;
+template struct vec<4, uint32, highp>;
+template struct vec<4, uint64, highp>;
+template struct vec<4, int8, highp>;
+template struct vec<4, int16, highp>;
+template struct vec<4, int32, highp>;
+template struct vec<4, int64, highp>;
+template struct vec<4, float32, highp>;
+template struct vec<4, float64, highp>;
+
+// tmat2x2 type explicit instantiation
+template struct mat<2, 2, float32, lowp>;
+template struct mat<2, 2, float64, lowp>;
+
+template struct mat<2, 2, float32, mediump>;
+template struct mat<2, 2, float64, mediump>;
+
+template struct mat<2, 2, float32, highp>;
+template struct mat<2, 2, float64, highp>;
+
+// tmat2x3 type explicit instantiation
+template struct mat<2, 3, float32, lowp>;
+template struct mat<2, 3, float64, lowp>;
+
+template struct mat<2, 3, float32, mediump>;
+template struct mat<2, 3, float64, mediump>;
+
+template struct mat<2, 3, float32, highp>;
+template struct mat<2, 3, float64, highp>;
+
+// tmat2x4 type explicit instantiation
+template struct mat<2, 4, float32, lowp>;
+template struct mat<2, 4, float64, lowp>;
+
+template struct mat<2, 4, float32, mediump>;
+template struct mat<2, 4, float64, mediump>;
+
+template struct mat<2, 4, float32, highp>;
+template struct mat<2, 4, float64, highp>;
+
+// tmat3x2 type explicit instantiation
+template struct mat<3, 2, float32, lowp>;
+template struct mat<3, 2, float64, lowp>;
+
+template struct mat<3, 2, float32, mediump>;
+template struct mat<3, 2, float64, mediump>;
+
+template struct mat<3, 2, float32, highp>;
+template struct mat<3, 2, float64, highp>;
+
+// tmat3x3 type explicit instantiation
+template struct mat<3, 3, float32, lowp>;
+template struct mat<3, 3, float64, lowp>;
+
+template struct mat<3, 3, float32, mediump>;
+template struct mat<3, 3, float64, mediump>;
+
+template struct mat<3, 3, float32, highp>;
+template struct mat<3, 3, float64, highp>;
+
+// tmat3x4 type explicit instantiation
+template struct mat<3, 4, float32, lowp>;
+template struct mat<3, 4, float64, lowp>;
+
+template struct mat<3, 4, float32, mediump>;
+template struct mat<3, 4, float64, mediump>;
+
+template struct mat<3, 4, float32, highp>;
+template struct mat<3, 4, float64, highp>;
+
+// tmat4x2 type explicit instantiation
+template struct mat<4, 2, float32, lowp>;
+template struct mat<4, 2, float64, lowp>;
+
+template struct mat<4, 2, float32, mediump>;
+template struct mat<4, 2, float64, mediump>;
+
+template struct mat<4, 2, float32, highp>;
+template struct mat<4, 2, float64, highp>;
+
+// tmat4x3 type explicit instantiation
+template struct mat<4, 3, float32, lowp>;
+template struct mat<4, 3, float64, lowp>;
+
+template struct mat<4, 3, float32, mediump>;
+template struct mat<4, 3, float64, mediump>;
+
+template struct mat<4, 3, float32, highp>;
+template struct mat<4, 3, float64, highp>;
+
+// tmat4x4 type explicit instantiation
+template struct mat<4, 4, float32, lowp>;
+template struct mat<4, 4, float64, lowp>;
+
+template struct mat<4, 4, float32, mediump>;
+template struct mat<4, 4, float64, mediump>;
+
+template struct mat<4, 4, float32, highp>;
+template struct mat<4, 4, float64, highp>;
+
+// tquat type explicit instantiation
+template struct qua<float32, lowp>;
+template struct qua<float64, lowp>;
+
+template struct qua<float32, mediump>;
+template struct qua<float64, mediump>;
+
+template struct qua<float32, highp>;
+template struct qua<float64, highp>;
+
+//tdualquat type explicit instantiation
+template struct tdualquat<float32, lowp>;
+template struct tdualquat<float64, lowp>;
+
+template struct tdualquat<float32, mediump>;
+template struct tdualquat<float64, mediump>;
+
+template struct tdualquat<float32, highp>;
+template struct tdualquat<float64, highp>;
+
+}//namespace glm
+
diff --git a/engine/inc/glm/detail/qualifier.hpp b/engine/inc/glm/detail/qualifier.hpp
new file mode 100644
index 00000000..115817f1
--- /dev/null
+++ b/engine/inc/glm/detail/qualifier.hpp
@@ -0,0 +1,210 @@
+#pragma once
+
+#include "setup.hpp"
+
+namespace glm
+{
+	/// Qualify GLM types in term of alignment (packed, aligned) and precision in term of ULPs (lowp, mediump, highp)
+	enum qualifier
+	{
+		packed_highp, ///< Typed data is tightly packed in memory and operations are executed with high precision in term of ULPs
+		packed_mediump, ///< Typed data is tightly packed in memory  and operations are executed with medium precision in term of ULPs for higher performance
+		packed_lowp, ///< Typed data is tightly packed in memory  and operations are executed with low precision in term of ULPs to maximize performance
+
+#		if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE
+			aligned_highp, ///< Typed data is aligned in memory allowing SIMD optimizations and operations are executed with high precision in term of ULPs
+			aligned_mediump, ///< Typed data is aligned in memory allowing SIMD optimizations and operations are executed with high precision in term of ULPs for higher performance
+			aligned_lowp, // ///< Typed data is aligned in memory allowing SIMD optimizations and operations are executed with high precision in term of ULPs to maximize performance
+			aligned = aligned_highp, ///< By default aligned qualifier is also high precision
+#		endif
+
+		highp = packed_highp, ///< By default highp qualifier is also packed
+		mediump = packed_mediump, ///< By default mediump qualifier is also packed
+		lowp = packed_lowp, ///< By default lowp qualifier is also packed
+		packed = packed_highp, ///< By default packed qualifier is also high precision
+
+#		if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE && defined(GLM_FORCE_DEFAULT_ALIGNED_GENTYPES)
+			defaultp = aligned_highp
+#		else
+			defaultp = highp
+#		endif
+	};
+
+	typedef qualifier precision;
+
+	template<length_t L, typename T, qualifier Q = defaultp> struct vec;
+	template<length_t C, length_t R, typename T, qualifier Q = defaultp> struct mat;
+	template<typename T, qualifier Q = defaultp> struct qua;
+
+#	if GLM_HAS_TEMPLATE_ALIASES
+		template <typename T, qualifier Q = defaultp> using tvec1 = vec<1, T, Q>;
+		template <typename T, qualifier Q = defaultp> using tvec2 = vec<2, T, Q>;
+		template <typename T, qualifier Q = defaultp> using tvec3 = vec<3, T, Q>;
+		template <typename T, qualifier Q = defaultp> using tvec4 = vec<4, T, Q>;
+		template <typename T, qualifier Q = defaultp> using tmat2x2 = mat<2, 2, T, Q>;
+		template <typename T, qualifier Q = defaultp> using tmat2x3 = mat<2, 3, T, Q>;
+		template <typename T, qualifier Q = defaultp> using tmat2x4 = mat<2, 4, T, Q>;
+		template <typename T, qualifier Q = defaultp> using tmat3x2 = mat<3, 2, T, Q>;
+		template <typename T, qualifier Q = defaultp> using tmat3x3 = mat<3, 3, T, Q>;
+		template <typename T, qualifier Q = defaultp> using tmat3x4 = mat<3, 4, T, Q>;
+		template <typename T, qualifier Q = defaultp> using tmat4x2 = mat<4, 2, T, Q>;
+		template <typename T, qualifier Q = defaultp> using tmat4x3 = mat<4, 3, T, Q>;
+		template <typename T, qualifier Q = defaultp> using tmat4x4 = mat<4, 4, T, Q>;
+		template <typename T, qualifier Q = defaultp> using tquat = qua<T, Q>;
+#	endif
+
+namespace detail
+{
+	template<glm::qualifier P>
+	struct is_aligned
+	{
+		static const bool value = false;
+	};
+
+#	if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE
+		template<>
+		struct is_aligned<glm::aligned_lowp>
+		{
+			static const bool value = true;
+		};
+
+		template<>
+		struct is_aligned<glm::aligned_mediump>
+		{
+			static const bool value = true;
+		};
+
+		template<>
+		struct is_aligned<glm::aligned_highp>
+		{
+			static const bool value = true;
+		};
+#	endif
+
+	template<length_t L, typename T, bool is_aligned>
+	struct storage
+	{
+		typedef struct type {
+			T data[L];
+		} type;
+	};
+
+#	if GLM_HAS_ALIGNOF
+		template<length_t L, typename T>
+		struct storage<L, T, true>
+		{
+			typedef struct alignas(L * sizeof(T)) type {
+				T data[L];
+			} type;
+		};
+
+		template<typename T>
+		struct storage<3, T, true>
+		{
+			typedef struct alignas(4 * sizeof(T)) type {
+				T data[4];
+			} type;
+		};
+#	endif
+
+#	if GLM_ARCH & GLM_ARCH_SSE2_BIT
+	template<>
+	struct storage<4, float, true>
+	{
+		typedef glm_f32vec4 type;
+	};
+
+	template<>
+	struct storage<4, int, true>
+	{
+		typedef glm_i32vec4 type;
+	};
+
+	template<>
+	struct storage<4, unsigned int, true>
+	{
+		typedef glm_u32vec4 type;
+	};
+
+	template<>
+	struct storage<2, double, true>
+	{
+		typedef glm_f64vec2 type;
+	};
+
+	template<>
+	struct storage<2, detail::int64, true>
+	{
+		typedef glm_i64vec2 type;
+	};
+
+	template<>
+	struct storage<2, detail::uint64, true>
+	{
+		typedef glm_u64vec2 type;
+	};
+#	endif
+
+#	if (GLM_ARCH & GLM_ARCH_AVX_BIT)
+	template<>
+	struct storage<4, double, true>
+	{
+		typedef glm_f64vec4 type;
+	};
+#	endif
+
+#	if (GLM_ARCH & GLM_ARCH_AVX2_BIT)
+	template<>
+	struct storage<4, detail::int64, true>
+	{
+		typedef glm_i64vec4 type;
+	};
+
+	template<>
+	struct storage<4, detail::uint64, true>
+	{
+		typedef glm_u64vec4 type;
+	};
+#	endif
+
+	enum genTypeEnum
+	{
+		GENTYPE_VEC,
+		GENTYPE_MAT,
+		GENTYPE_QUAT
+	};
+
+	template <typename genType>
+	struct genTypeTrait
+	{};
+
+	template <length_t C, length_t R, typename T>
+	struct genTypeTrait<mat<C, R, T> >
+	{
+		static const genTypeEnum GENTYPE = GENTYPE_MAT;
+	};
+
+	template<typename genType, genTypeEnum type>
+	struct init_gentype
+	{
+	};
+
+	template<typename genType>
+	struct init_gentype<genType, GENTYPE_QUAT>
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genType identity()
+		{
+			return genType(1, 0, 0, 0);
+		}
+	};
+
+	template<typename genType>
+	struct init_gentype<genType, GENTYPE_MAT>
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genType identity()
+		{
+			return genType(1);
+		}
+	};
+}//namespace detail
+}//namespace glm
diff --git a/engine/inc/glm/detail/setup.hpp b/engine/inc/glm/detail/setup.hpp
new file mode 100644
index 00000000..04430ea6
--- /dev/null
+++ b/engine/inc/glm/detail/setup.hpp
@@ -0,0 +1,1065 @@
+#ifndef GLM_SETUP_INCLUDED
+
+#include <cassert>
+#include <cstddef>
+
+#define GLM_VERSION_MAJOR			0
+#define GLM_VERSION_MINOR			9
+#define GLM_VERSION_PATCH			9
+#define GLM_VERSION_REVISION		3
+#define GLM_VERSION					993
+#define GLM_VERSION_MESSAGE			"GLM: version 0.9.9.3"
+
+#define GLM_SETUP_INCLUDED			GLM_VERSION
+
+///////////////////////////////////////////////////////////////////////////////////
+// Active states
+
+#define GLM_DISABLE		0
+#define GLM_ENABLE		1
+
+///////////////////////////////////////////////////////////////////////////////////
+// Messages
+
+#if defined(GLM_FORCE_MESSAGES)
+#	define GLM_MESSAGES GLM_ENABLE
+#else
+#	define GLM_MESSAGES GLM_DISABLE
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Detect the platform
+
+#include "../simd/platform.h"
+
+///////////////////////////////////////////////////////////////////////////////////
+// Build model
+
+#if defined(__arch64__) || defined(__LP64__) || defined(_M_X64) || defined(__ppc64__) || defined(__x86_64__)
+#	define GLM_MODEL	GLM_MODEL_64
+#elif defined(__i386__) || defined(__ppc__)
+#	define GLM_MODEL	GLM_MODEL_32
+#else
+#	define GLM_MODEL	GLM_MODEL_32
+#endif//
+
+#if !defined(GLM_MODEL) && GLM_COMPILER != 0
+#	error "GLM_MODEL undefined, your compiler may not be supported by GLM. Add #define GLM_MODEL 0 to ignore this message."
+#endif//GLM_MODEL
+
+///////////////////////////////////////////////////////////////////////////////////
+// C++ Version
+
+// User defines: GLM_FORCE_CXX98, GLM_FORCE_CXX03, GLM_FORCE_CXX11, GLM_FORCE_CXX14, GLM_FORCE_CXX17, GLM_FORCE_CXX2A
+
+#define GLM_LANG_CXX98_FLAG			(1 << 1)
+#define GLM_LANG_CXX03_FLAG			(1 << 2)
+#define GLM_LANG_CXX0X_FLAG			(1 << 3)
+#define GLM_LANG_CXX11_FLAG			(1 << 4)
+#define GLM_LANG_CXX14_FLAG			(1 << 5)
+#define GLM_LANG_CXX17_FLAG			(1 << 6)
+#define GLM_LANG_CXX2A_FLAG			(1 << 7)
+#define GLM_LANG_CXXMS_FLAG			(1 << 8)
+#define GLM_LANG_CXXGNU_FLAG		(1 << 9)
+
+#define GLM_LANG_CXX98			GLM_LANG_CXX98_FLAG
+#define GLM_LANG_CXX03			(GLM_LANG_CXX98 | GLM_LANG_CXX03_FLAG)
+#define GLM_LANG_CXX0X			(GLM_LANG_CXX03 | GLM_LANG_CXX0X_FLAG)
+#define GLM_LANG_CXX11			(GLM_LANG_CXX0X | GLM_LANG_CXX11_FLAG)
+#define GLM_LANG_CXX14			(GLM_LANG_CXX11 | GLM_LANG_CXX14_FLAG)
+#define GLM_LANG_CXX17			(GLM_LANG_CXX14 | GLM_LANG_CXX17_FLAG)
+#define GLM_LANG_CXX2A			(GLM_LANG_CXX17 | GLM_LANG_CXX2A_FLAG)
+#define GLM_LANG_CXXMS			GLM_LANG_CXXMS_FLAG
+#define GLM_LANG_CXXGNU			GLM_LANG_CXXGNU_FLAG
+
+#if (defined(_MSC_EXTENSIONS))
+#	define GLM_LANG_EXT GLM_LANG_CXXMS_FLAG
+#elif ((GLM_COMPILER & (GLM_COMPILER_CLANG | GLM_COMPILER_GCC)) && (GLM_ARCH & GLM_ARCH_SIMD_BIT))
+#	define GLM_LANG_EXT GLM_LANG_CXXMS_FLAG
+#else
+#	define GLM_LANG_EXT 0
+#endif
+
+#if (defined(GLM_FORCE_CXX_UNKNOWN))
+#	define GLM_LANG 0
+#elif defined(GLM_FORCE_CXX2A)
+#	define GLM_LANG (GLM_LANG_CXX2A | GLM_LANG_EXT)
+#	define GLM_LANG_STL11_FORCED
+#elif defined(GLM_FORCE_CXX17)
+#	define GLM_LANG (GLM_LANG_CXX17 | GLM_LANG_EXT)
+#	define GLM_LANG_STL11_FORCED
+#elif defined(GLM_FORCE_CXX14)
+#	define GLM_LANG (GLM_LANG_CXX14 | GLM_LANG_EXT)
+#	define GLM_LANG_STL11_FORCED
+#elif defined(GLM_FORCE_CXX11)
+#	define GLM_LANG (GLM_LANG_CXX11 | GLM_LANG_EXT)
+#	define GLM_LANG_STL11_FORCED
+#elif defined(GLM_FORCE_CXX03)
+#	define GLM_LANG (GLM_LANG_CXX03 | GLM_LANG_EXT)
+#elif defined(GLM_FORCE_CXX98)
+#	define GLM_LANG (GLM_LANG_CXX98 | GLM_LANG_EXT)
+#else
+#	if GLM_COMPILER & GLM_COMPILER_VC && defined(_MSVC_LANG)
+#		if GLM_COMPILER >= GLM_COMPILER_VC15_7
+#			define GLM_LANG_PLATFORM _MSVC_LANG
+#		elif GLM_COMPILER >= GLM_COMPILER_VC15
+#			if _MSVC_LANG > 201402L
+#				define GLM_LANG_PLATFORM 201402L
+#			else
+#				define GLM_LANG_PLATFORM _MSVC_LANG
+#			endif
+#		else
+#			define GLM_LANG_PLATFORM 0
+#		endif
+#	else
+#		define GLM_LANG_PLATFORM 0
+#	endif
+
+#	if __cplusplus > 201703L || GLM_LANG_PLATFORM > 201703L
+#		define GLM_LANG (GLM_LANG_CXX2A | GLM_LANG_EXT)
+#	elif __cplusplus == 201703L || GLM_LANG_PLATFORM == 201703L
+#		define GLM_LANG (GLM_LANG_CXX17 | GLM_LANG_EXT)
+#	elif __cplusplus == 201402L || GLM_LANG_PLATFORM == 201402L
+#		define GLM_LANG (GLM_LANG_CXX14 | GLM_LANG_EXT)
+#	elif __cplusplus == 201103L || GLM_LANG_PLATFORM == 201103L
+#		define GLM_LANG (GLM_LANG_CXX11 | GLM_LANG_EXT)
+#	elif defined(__INTEL_CXX11_MODE__) || defined(_MSC_VER) || defined(__GXX_EXPERIMENTAL_CXX0X__)
+#		define GLM_LANG (GLM_LANG_CXX0X | GLM_LANG_EXT)
+#	elif __cplusplus == 199711L
+#		define GLM_LANG (GLM_LANG_CXX98 | GLM_LANG_EXT)
+#	else
+#		define GLM_LANG (0 | GLM_LANG_EXT)
+#	endif
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Has of C++ features
+
+// http://clang.llvm.org/cxx_status.html
+// http://gcc.gnu.org/projects/cxx0x.html
+// http://msdn.microsoft.com/en-us/library/vstudio/hh567368(v=vs.120).aspx
+
+// Android has multiple STLs but C++11 STL detection doesn't always work #284 #564
+#if GLM_PLATFORM == GLM_PLATFORM_ANDROID && !defined(GLM_LANG_STL11_FORCED)
+#	define GLM_HAS_CXX11_STL 0
+#elif GLM_COMPILER & GLM_COMPILER_CLANG
+#	if (defined(_LIBCPP_VERSION) && GLM_LANG & GLM_LANG_CXX11_FLAG) || defined(GLM_LANG_STL11_FORCED)
+#		define GLM_HAS_CXX11_STL 1
+#	else
+#		define GLM_HAS_CXX11_STL 0
+#	endif
+#elif GLM_LANG & GLM_LANG_CXX11_FLAG
+#	define GLM_HAS_CXX11_STL 1
+#else
+#	define GLM_HAS_CXX11_STL ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+		((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC48)) || \
+		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \
+		((GLM_PLATFORM != GLM_PLATFORM_WINDOWS) && (GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL15))))
+#endif
+
+// N1720
+#if GLM_COMPILER & GLM_COMPILER_CLANG
+#	define GLM_HAS_STATIC_ASSERT __has_feature(cxx_static_assert)
+#elif GLM_LANG & GLM_LANG_CXX11_FLAG
+#	define GLM_HAS_STATIC_ASSERT 1
+#else
+#	define GLM_HAS_STATIC_ASSERT ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+		((GLM_COMPILER & GLM_COMPILER_CUDA)) || \
+		((GLM_COMPILER & GLM_COMPILER_VC))))
+#endif
+
+// N1988
+#if GLM_LANG & GLM_LANG_CXX11_FLAG
+#	define GLM_HAS_EXTENDED_INTEGER_TYPE 1
+#else
+#	define GLM_HAS_EXTENDED_INTEGER_TYPE (\
+		((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_VC)) || \
+		((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_CUDA)) || \
+		((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_CLANG)))
+#endif
+
+// N2672 Initializer lists http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2672.htm
+#if GLM_COMPILER & GLM_COMPILER_CLANG
+#	define GLM_HAS_INITIALIZER_LISTS __has_feature(cxx_generalized_initializers)
+#elif GLM_LANG & GLM_LANG_CXX11_FLAG
+#	define GLM_HAS_INITIALIZER_LISTS 1
+#else
+#	define GLM_HAS_INITIALIZER_LISTS ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC15)) || \
+		((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL14)) || \
+		((GLM_COMPILER & GLM_COMPILER_CUDA) && (GLM_COMPILER >= GLM_COMPILER_CUDA75))))
+#endif
+
+// N2544 Unrestricted unions http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2544.pdf
+#if GLM_COMPILER & GLM_COMPILER_CLANG
+#	define GLM_HAS_UNRESTRICTED_UNIONS __has_feature(cxx_unrestricted_unions)
+#elif GLM_LANG & GLM_LANG_CXX11_FLAG
+#	define GLM_HAS_UNRESTRICTED_UNIONS 1
+#else
+#	define GLM_HAS_UNRESTRICTED_UNIONS (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+		(GLM_COMPILER & GLM_COMPILER_VC) || \
+		((GLM_COMPILER & GLM_COMPILER_CUDA) && (GLM_COMPILER >= GLM_COMPILER_CUDA75)))
+#endif
+
+// N2346
+#if GLM_COMPILER & GLM_COMPILER_CLANG
+#	define GLM_HAS_DEFAULTED_FUNCTIONS __has_feature(cxx_defaulted_functions)
+#elif GLM_LANG & GLM_LANG_CXX11_FLAG
+#	define GLM_HAS_DEFAULTED_FUNCTIONS 1
+#else
+#	define GLM_HAS_DEFAULTED_FUNCTIONS ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \
+		((GLM_COMPILER & GLM_COMPILER_INTEL)) || \
+		(GLM_COMPILER & GLM_COMPILER_CUDA)))
+#endif
+
+// N2118
+#if GLM_COMPILER & GLM_COMPILER_CLANG
+#	define GLM_HAS_RVALUE_REFERENCES __has_feature(cxx_rvalue_references)
+#elif GLM_LANG & GLM_LANG_CXX11_FLAG
+#	define GLM_HAS_RVALUE_REFERENCES 1
+#else
+#	define GLM_HAS_RVALUE_REFERENCES ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+		((GLM_COMPILER & GLM_COMPILER_VC)) || \
+		((GLM_COMPILER & GLM_COMPILER_CUDA))))
+#endif
+
+// N2437 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2437.pdf
+#if GLM_COMPILER & GLM_COMPILER_CLANG
+#	define GLM_HAS_EXPLICIT_CONVERSION_OPERATORS __has_feature(cxx_explicit_conversions)
+#elif GLM_LANG & GLM_LANG_CXX11_FLAG
+#	define GLM_HAS_EXPLICIT_CONVERSION_OPERATORS 1
+#else
+#	define GLM_HAS_EXPLICIT_CONVERSION_OPERATORS ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+		((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL14)) || \
+		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \
+		((GLM_COMPILER & GLM_COMPILER_CUDA))))
+#endif
+
+// N2258 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2258.pdf
+#if GLM_COMPILER & GLM_COMPILER_CLANG
+#	define GLM_HAS_TEMPLATE_ALIASES __has_feature(cxx_alias_templates)
+#elif GLM_LANG & GLM_LANG_CXX11_FLAG
+#	define GLM_HAS_TEMPLATE_ALIASES 1
+#else
+#	define GLM_HAS_TEMPLATE_ALIASES ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+		((GLM_COMPILER & GLM_COMPILER_INTEL)) || \
+		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \
+		((GLM_COMPILER & GLM_COMPILER_CUDA))))
+#endif
+
+// N2930 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2930.html
+#if GLM_COMPILER & GLM_COMPILER_CLANG
+#	define GLM_HAS_RANGE_FOR __has_feature(cxx_range_for)
+#elif GLM_LANG & GLM_LANG_CXX11_FLAG
+#	define GLM_HAS_RANGE_FOR 1
+#else
+#	define GLM_HAS_RANGE_FOR ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+		((GLM_COMPILER & GLM_COMPILER_INTEL)) || \
+		((GLM_COMPILER & GLM_COMPILER_VC)) || \
+		((GLM_COMPILER & GLM_COMPILER_CUDA))))
+#endif
+
+// N2341 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2341.pdf
+#if GLM_COMPILER & GLM_COMPILER_CLANG
+#	define GLM_HAS_ALIGNOF __has_feature(cxx_alignas)
+#elif GLM_LANG & GLM_LANG_CXX11_FLAG
+#	define GLM_HAS_ALIGNOF 1
+#else
+#	define GLM_HAS_ALIGNOF ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+		((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL15)) || \
+		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC14)) || \
+		((GLM_COMPILER & GLM_COMPILER_CUDA) && (GLM_COMPILER >= GLM_COMPILER_CUDA70))))
+#endif
+
+// N2235 Generalized Constant Expressions http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2235.pdf
+// N3652 Extended Constant Expressions http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3652.html
+#if (GLM_ARCH & GLM_ARCH_SIMD_BIT) // Compiler SIMD intrinsics don't support constexpr...
+#	define GLM_HAS_CONSTEXPR 0
+#elif (GLM_COMPILER & GLM_COMPILER_CLANG)
+#	define GLM_HAS_CONSTEXPR __has_feature(cxx_relaxed_constexpr)
+#elif (GLM_LANG & GLM_LANG_CXX14_FLAG)
+#	define GLM_HAS_CONSTEXPR 1
+#else
+#	define GLM_HAS_CONSTEXPR ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && GLM_HAS_INITIALIZER_LISTS && (\
+		((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL17)) || \
+		((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC6)) || \
+		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC15))))
+#endif
+
+#if GLM_HAS_CONSTEXPR
+#	define GLM_CONSTEXPR constexpr
+#else
+#	define GLM_CONSTEXPR
+#endif
+
+//
+#if GLM_LANG & GLM_LANG_CXX11_FLAG
+#	define GLM_HAS_ASSIGNABLE 1
+#else
+#	define GLM_HAS_ASSIGNABLE ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC15)) || \
+		((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC49))))
+#endif
+
+//
+#define GLM_HAS_TRIVIAL_QUERIES 0
+
+//
+#if GLM_LANG & GLM_LANG_CXX11_FLAG
+#	define GLM_HAS_MAKE_SIGNED 1
+#else
+#	define GLM_HAS_MAKE_SIGNED ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \
+		((GLM_COMPILER & GLM_COMPILER_CUDA))))
+#endif
+
+//
+#if defined(GLM_FORCE_PURE)
+#	define GLM_HAS_BITSCAN_WINDOWS 0
+#else
+#	define GLM_HAS_BITSCAN_WINDOWS ((GLM_PLATFORM & GLM_PLATFORM_WINDOWS) && (\
+		((GLM_COMPILER & GLM_COMPILER_INTEL)) || \
+		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC14) && (GLM_ARCH & GLM_ARCH_X86_BIT))))
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// OpenMP
+#ifdef _OPENMP
+#	if GLM_COMPILER & GLM_COMPILER_GCC
+#		if GLM_COMPILER >= GLM_COMPILER_GCC61
+#			define GLM_HAS_OPENMP 45
+#		elif GLM_COMPILER >= GLM_COMPILER_GCC49
+#			define GLM_HAS_OPENMP 40
+#		elif GLM_COMPILER >= GLM_COMPILER_GCC47
+#			define GLM_HAS_OPENMP 31
+#		else
+#			define GLM_HAS_OPENMP 0
+#		endif
+#	elif GLM_COMPILER & GLM_COMPILER_CLANG
+#		if GLM_COMPILER >= GLM_COMPILER_CLANG38
+#			define GLM_HAS_OPENMP 31
+#		else
+#			define GLM_HAS_OPENMP 0
+#		endif
+#	elif GLM_COMPILER & GLM_COMPILER_VC
+#		define GLM_HAS_OPENMP 20
+#	elif GLM_COMPILER & GLM_COMPILER_INTEL
+#		if GLM_COMPILER >= GLM_COMPILER_INTEL16
+#			define GLM_HAS_OPENMP 40
+#		else
+#			define GLM_HAS_OPENMP 0
+#		endif
+#	else
+#		define GLM_HAS_OPENMP 0
+#	endif
+#else
+#	define GLM_HAS_OPENMP 0
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// nullptr
+
+#if GLM_LANG & GLM_LANG_CXX0X_FLAG
+#	define GLM_CONFIG_NULLPTR GLM_ENABLE
+#else
+#	define GLM_CONFIG_NULLPTR GLM_DISABLE
+#endif
+
+#if GLM_CONFIG_NULLPTR == GLM_ENABLE
+#	define GLM_NULLPTR nullptr
+#else
+#	define GLM_NULLPTR 0
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Static assert
+
+#if GLM_HAS_STATIC_ASSERT
+#	define GLM_STATIC_ASSERT(x, message) static_assert(x, message)
+#elif GLM_COMPILER & GLM_COMPILER_VC
+#	define GLM_STATIC_ASSERT(x, message) typedef char __CASSERT__##__LINE__[(x) ? 1 : -1]
+#else
+#	define GLM_STATIC_ASSERT(x, message) assert(x)
+#endif//GLM_LANG
+
+///////////////////////////////////////////////////////////////////////////////////
+// Qualifiers
+
+#if GLM_COMPILER & GLM_COMPILER_CUDA
+#	define GLM_CUDA_FUNC_DEF __device__ __host__
+#	define GLM_CUDA_FUNC_DECL __device__ __host__
+#else
+#	define GLM_CUDA_FUNC_DEF
+#	define GLM_CUDA_FUNC_DECL
+#endif
+
+#if defined(GLM_FORCE_INLINE)
+#	if GLM_COMPILER & GLM_COMPILER_VC
+#		define GLM_INLINE __forceinline
+#		define GLM_NEVER_INLINE __declspec((noinline))
+#	elif GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG)
+#		define GLM_INLINE inline __attribute__((__always_inline__))
+#		define GLM_NEVER_INLINE __attribute__((__noinline__))
+#	elif GLM_COMPILER & GLM_COMPILER_CUDA
+#		define GLM_INLINE __forceinline__
+#		define GLM_NEVER_INLINE __noinline__
+#	else
+#		define GLM_INLINE inline
+#		define GLM_NEVER_INLINE
+#	endif//GLM_COMPILER
+#else
+#	define GLM_INLINE inline
+#	define GLM_NEVER_INLINE
+#endif//defined(GLM_FORCE_INLINE)
+
+#define GLM_FUNC_DECL GLM_CUDA_FUNC_DECL
+#define GLM_FUNC_QUALIFIER GLM_CUDA_FUNC_DEF GLM_INLINE
+
+///////////////////////////////////////////////////////////////////////////////////
+// Swizzle operators
+
+// User defines: GLM_FORCE_SWIZZLE
+
+#define GLM_SWIZZLE_DISABLED		0
+#define GLM_SWIZZLE_OPERATOR		1
+#define GLM_SWIZZLE_FUNCTION		2
+
+#if defined(GLM_FORCE_XYZW_ONLY)
+#	undef GLM_FORCE_SWIZZLE
+#endif
+
+#if defined(GLM_SWIZZLE)
+#	pragma message("GLM: GLM_SWIZZLE is deprecated, use GLM_FORCE_SWIZZLE instead.")
+#	define GLM_FORCE_SWIZZLE
+#endif
+
+#if defined(GLM_FORCE_SWIZZLE) && (GLM_LANG & GLM_LANG_CXXMS_FLAG)
+#	define GLM_CONFIG_SWIZZLE GLM_SWIZZLE_OPERATOR
+#elif defined(GLM_FORCE_SWIZZLE)
+#	define GLM_CONFIG_SWIZZLE GLM_SWIZZLE_FUNCTION
+#else
+#	define GLM_CONFIG_SWIZZLE GLM_SWIZZLE_DISABLED
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Allows using not basic types as genType
+
+// #define GLM_FORCE_UNRESTRICTED_GENTYPE
+
+#ifdef GLM_FORCE_UNRESTRICTED_GENTYPE
+#	define GLM_CONFIG_UNRESTRICTED_GENTYPE GLM_ENABLE
+#else
+#	define GLM_CONFIG_UNRESTRICTED_GENTYPE GLM_DISABLE
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Clip control, define GLM_FORCE_DEPTH_ZERO_TO_ONE before including GLM
+// to use a clip space between 0 to 1.
+// Coordinate system, define GLM_FORCE_LEFT_HANDED before including GLM
+// to use left handed coordinate system by default.
+
+#define GLM_CLIP_CONTROL_ZO_BIT		(1 << 0) // ZERO_TO_ONE
+#define GLM_CLIP_CONTROL_NO_BIT		(1 << 1) // NEGATIVE_ONE_TO_ONE
+#define GLM_CLIP_CONTROL_LH_BIT		(1 << 2) // LEFT_HANDED, For DirectX, Metal, Vulkan
+#define GLM_CLIP_CONTROL_RH_BIT		(1 << 3) // RIGHT_HANDED, For OpenGL, default in GLM
+
+#define GLM_CLIP_CONTROL_LH_ZO (GLM_CLIP_CONTROL_LH_BIT | GLM_CLIP_CONTROL_ZO_BIT)
+#define GLM_CLIP_CONTROL_LH_NO (GLM_CLIP_CONTROL_LH_BIT | GLM_CLIP_CONTROL_NO_BIT)
+#define GLM_CLIP_CONTROL_RH_ZO (GLM_CLIP_CONTROL_RH_BIT | GLM_CLIP_CONTROL_ZO_BIT)
+#define GLM_CLIP_CONTROL_RH_NO (GLM_CLIP_CONTROL_RH_BIT | GLM_CLIP_CONTROL_NO_BIT)
+
+#ifdef GLM_FORCE_DEPTH_ZERO_TO_ONE
+#	ifdef GLM_FORCE_LEFT_HANDED
+#		define GLM_CONFIG_CLIP_CONTROL GLM_CLIP_CONTROL_LH_ZO
+#	else
+#		define GLM_CONFIG_CLIP_CONTROL GLM_CLIP_CONTROL_RH_ZO
+#	endif
+#else
+#	ifdef GLM_FORCE_LEFT_HANDED
+#		define GLM_CONFIG_CLIP_CONTROL GLM_CLIP_CONTROL_LH_NO
+#	else
+#		define GLM_CONFIG_CLIP_CONTROL GLM_CLIP_CONTROL_RH_NO
+#	endif
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Qualifiers
+
+#if (GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS))
+#	define GLM_DEPRECATED __declspec(deprecated)
+#	define GLM_ALIGNED_TYPEDEF(type, name, alignment) typedef __declspec(align(alignment)) type name
+#elif GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG | GLM_COMPILER_INTEL)
+#	define GLM_DEPRECATED __attribute__((__deprecated__))
+#	define GLM_ALIGNED_TYPEDEF(type, name, alignment) typedef type name __attribute__((aligned(alignment)))
+#elif GLM_COMPILER & GLM_COMPILER_CUDA
+#	define GLM_DEPRECATED
+#	define GLM_ALIGNED_TYPEDEF(type, name, alignment) typedef type name __align__(x)
+#else
+#	define GLM_DEPRECATED
+#	define GLM_ALIGNED_TYPEDEF(type, name, alignment) typedef type name
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+
+#ifdef GLM_FORCE_EXPLICIT_CTOR
+#	define GLM_EXPLICIT explicit
+#else
+#	define GLM_EXPLICIT
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Length type: all length functions returns a length_t type.
+// When GLM_FORCE_SIZE_T_LENGTH is defined, length_t is a typedef of size_t otherwise
+// length_t is a typedef of int like GLSL defines it.
+
+#define GLM_LENGTH_INT		1
+#define GLM_LENGTH_SIZE_T	2
+
+#ifdef GLM_FORCE_SIZE_T_LENGTH
+#	define GLM_CONFIG_LENGTH_TYPE		GLM_LENGTH_SIZE_T
+#else
+#	define GLM_CONFIG_LENGTH_TYPE		GLM_LENGTH_INT
+#endif
+
+namespace glm
+{
+	using std::size_t;
+#	if GLM_CONFIG_LENGTH_TYPE == GLM_LENGTH_SIZE_T
+		typedef size_t length_t;
+#	else
+		typedef int length_t;
+#	endif
+}//namespace glm
+
+///////////////////////////////////////////////////////////////////////////////////
+// constexpr
+
+#if GLM_HAS_CONSTEXPR
+#	define GLM_CONFIG_CONSTEXP GLM_ENABLE
+
+	namespace glm
+	{
+		template<typename T, std::size_t N>
+		constexpr std::size_t countof(T const (&)[N])
+		{
+			return N;
+		}
+	}//namespace glm
+#	define GLM_COUNTOF(arr) glm::countof(arr)
+#elif defined(_MSC_VER)
+#	define GLM_CONFIG_CONSTEXP GLM_DISABLE
+
+#	define GLM_COUNTOF(arr) _countof(arr)
+#else
+#	define GLM_CONFIG_CONSTEXP GLM_DISABLE
+
+#	define GLM_COUNTOF(arr) sizeof(arr) / sizeof(arr[0])
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// uint
+
+namespace glm{
+namespace detail
+{
+	template<typename T>
+	struct is_int
+	{
+		enum test {value = 0};
+	};
+
+	template<>
+	struct is_int<unsigned int>
+	{
+		enum test {value = ~0};
+	};
+
+	template<>
+	struct is_int<signed int>
+	{
+		enum test {value = ~0};
+	};
+}//namespace detail
+
+	typedef unsigned int	uint;
+}//namespace glm
+
+///////////////////////////////////////////////////////////////////////////////////
+// 64-bit int
+
+#if GLM_HAS_EXTENDED_INTEGER_TYPE
+#	include <cstdint>
+#endif
+
+namespace glm{
+namespace detail
+{
+#	if GLM_HAS_EXTENDED_INTEGER_TYPE
+		typedef std::uint64_t						uint64;
+		typedef std::int64_t						int64;
+#	elif (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) // C99 detected, 64 bit types available
+		typedef uint64_t							uint64;
+		typedef int64_t								int64;
+#	elif GLM_COMPILER & GLM_COMPILER_VC
+		typedef unsigned __int64					uint64;
+		typedef signed __int64						int64;
+#	elif GLM_COMPILER & GLM_COMPILER_GCC
+#		pragma GCC diagnostic ignored "-Wlong-long"
+		__extension__ typedef unsigned long long	uint64;
+		__extension__ typedef signed long long		int64;
+#	elif (GLM_COMPILER & GLM_COMPILER_CLANG)
+#		pragma clang diagnostic ignored "-Wc++11-long-long"
+		typedef unsigned long long					uint64;
+		typedef signed long long					int64;
+#	else//unknown compiler
+		typedef unsigned long long					uint64;
+		typedef signed long long					int64;
+#	endif
+}//namespace detail
+}//namespace glm
+
+///////////////////////////////////////////////////////////////////////////////////
+// make_unsigned
+
+#if GLM_HAS_MAKE_SIGNED
+#	include <type_traits>
+
+namespace glm{
+namespace detail
+{
+	using std::make_unsigned;
+}//namespace detail
+}//namespace glm
+
+#else
+
+namespace glm{
+namespace detail
+{
+	template<typename genType>
+	struct make_unsigned
+	{};
+
+	template<>
+	struct make_unsigned<char>
+	{
+		typedef unsigned char type;
+	};
+
+	template<>
+	struct make_unsigned<short>
+	{
+		typedef unsigned short type;
+	};
+
+	template<>
+	struct make_unsigned<int>
+	{
+		typedef unsigned int type;
+	};
+
+	template<>
+	struct make_unsigned<long>
+	{
+		typedef unsigned long type;
+	};
+
+	template<>
+	struct make_unsigned<int64>
+	{
+		typedef uint64 type;
+	};
+
+	template<>
+	struct make_unsigned<unsigned char>
+	{
+		typedef unsigned char type;
+	};
+
+	template<>
+	struct make_unsigned<unsigned short>
+	{
+		typedef unsigned short type;
+	};
+
+	template<>
+	struct make_unsigned<unsigned int>
+	{
+		typedef unsigned int type;
+	};
+
+	template<>
+	struct make_unsigned<unsigned long>
+	{
+		typedef unsigned long type;
+	};
+
+	template<>
+	struct make_unsigned<uint64>
+	{
+		typedef uint64 type;
+	};
+}//namespace detail
+}//namespace glm
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Only use x, y, z, w as vector type components
+
+#ifdef GLM_FORCE_XYZW_ONLY
+#	define GLM_CONFIG_XYZW_ONLY GLM_ENABLE
+#else
+#	define GLM_CONFIG_XYZW_ONLY GLM_DISABLE
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Configure the use of defaulted initialized types
+
+#define GLM_CTOR_INIT_DISABLE		0
+#define GLM_CTOR_INITIALIZER_LIST	1
+#define GLM_CTOR_INITIALISATION		2
+
+#if defined(GLM_FORCE_CTOR_INIT) && GLM_HAS_INITIALIZER_LISTS
+#	define GLM_CONFIG_CTOR_INIT GLM_CTOR_INITIALIZER_LIST
+#elif defined(GLM_FORCE_CTOR_INIT) && !GLM_HAS_INITIALIZER_LISTS
+#	define GLM_CONFIG_CTOR_INIT GLM_CTOR_INITIALISATION
+#else
+#	define GLM_CONFIG_CTOR_INIT GLM_CTOR_INIT_DISABLE
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Use SIMD instruction sets
+
+#if GLM_HAS_ALIGNOF && (GLM_LANG & GLM_LANG_CXXMS_FLAG) && (GLM_ARCH & GLM_ARCH_SIMD_BIT)
+#	define GLM_CONFIG_SIMD GLM_ENABLE
+#else
+#	define GLM_CONFIG_SIMD GLM_DISABLE
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Configure the use of defaulted function
+
+#if GLM_HAS_DEFAULTED_FUNCTIONS && GLM_CONFIG_CTOR_INIT == GLM_CTOR_INIT_DISABLE
+#	define GLM_CONFIG_DEFAULTED_FUNCTIONS GLM_ENABLE
+#	define GLM_DEFAULT = default
+#else
+#	define GLM_CONFIG_DEFAULTED_FUNCTIONS GLM_DISABLE
+#	define GLM_DEFAULT
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Configure the use of aligned gentypes
+
+#ifdef GLM_FORCE_ALIGNED // Legacy define
+#	define GLM_FORCE_DEFAULT_ALIGNED_GENTYPES
+#endif
+
+#ifdef GLM_FORCE_DEFAULT_ALIGNED_GENTYPES
+#	define GLM_FORCE_ALIGNED_GENTYPES
+#endif
+
+#if GLM_HAS_ALIGNOF && (GLM_LANG & GLM_LANG_CXXMS_FLAG) && (defined(GLM_FORCE_ALIGNED_GENTYPES) || (GLM_CONFIG_SIMD == GLM_ENABLE))
+#	define GLM_CONFIG_ALIGNED_GENTYPES GLM_ENABLE
+#else
+#	define GLM_CONFIG_ALIGNED_GENTYPES GLM_DISABLE
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Configure the use of anonymous structure as implementation detail
+
+#if ((GLM_CONFIG_SIMD == GLM_ENABLE) || (GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR) || (GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE))
+#	define GLM_CONFIG_ANONYMOUS_STRUCT GLM_ENABLE
+#else
+#	define GLM_CONFIG_ANONYMOUS_STRUCT GLM_DISABLE
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Silent warnings
+
+#ifdef GLM_FORCE_SILENT_WARNINGS
+#	define GLM_SILENT_WARNINGS GLM_ENABLE
+#else
+#	define GLM_SILENT_WARNINGS GLM_DISABLE
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Precision
+
+#define GLM_HIGHP		1
+#define GLM_MEDIUMP		2
+#define GLM_LOWP		3
+
+#if defined(GLM_FORCE_PRECISION_HIGHP_BOOL) || defined(GLM_PRECISION_HIGHP_BOOL)
+#	define GLM_CONFIG_PRECISION_BOOL		GLM_HIGHP
+#elif defined(GLM_FORCE_PRECISION_MEDIUMP_BOOL) || defined(GLM_PRECISION_MEDIUMP_BOOL)
+#	define GLM_CONFIG_PRECISION_BOOL		GLM_MEDIUMP
+#elif defined(GLM_FORCE_PRECISION_LOWP_BOOL) || defined(GLM_PRECISION_LOWP_BOOL)
+#	define GLM_CONFIG_PRECISION_BOOL		GLM_LOWP
+#else
+#	define GLM_CONFIG_PRECISION_BOOL		GLM_HIGHP
+#endif
+
+#if defined(GLM_FORCE_PRECISION_HIGHP_INT) || defined(GLM_PRECISION_HIGHP_INT)
+#	define GLM_CONFIG_PRECISION_INT			GLM_HIGHP
+#elif defined(GLM_FORCE_PRECISION_MEDIUMP_INT) || defined(GLM_PRECISION_MEDIUMP_INT)
+#	define GLM_CONFIG_PRECISION_INT			GLM_MEDIUMP
+#elif defined(GLM_FORCE_PRECISION_LOWP_INT) || defined(GLM_PRECISION_LOWP_INT)
+#	define GLM_CONFIG_PRECISION_INT			GLM_LOWP
+#else
+#	define GLM_CONFIG_PRECISION_INT			GLM_HIGHP
+#endif
+
+#if defined(GLM_FORCE_PRECISION_HIGHP_UINT) || defined(GLM_PRECISION_HIGHP_UINT)
+#	define GLM_CONFIG_PRECISION_UINT		GLM_HIGHP
+#elif defined(GLM_FORCE_PRECISION_MEDIUMP_UINT) || defined(GLM_PRECISION_MEDIUMP_UINT)
+#	define GLM_CONFIG_PRECISION_UINT		GLM_MEDIUMP
+#elif defined(GLM_FORCE_PRECISION_LOWP_UINT) || defined(GLM_PRECISION_LOWP_UINT)
+#	define GLM_CONFIG_PRECISION_UINT		GLM_LOWP
+#else
+#	define GLM_CONFIG_PRECISION_UINT		GLM_HIGHP
+#endif
+
+#if defined(GLM_FORCE_PRECISION_HIGHP_FLOAT) || defined(GLM_PRECISION_HIGHP_FLOAT)
+#	define GLM_CONFIG_PRECISION_FLOAT		GLM_HIGHP
+#elif defined(GLM_FORCE_PRECISION_MEDIUMP_FLOAT) || defined(GLM_PRECISION_MEDIUMP_FLOAT)
+#	define GLM_CONFIG_PRECISION_FLOAT		GLM_MEDIUMP
+#elif defined(GLM_FORCE_PRECISION_LOWP_FLOAT) || defined(GLM_PRECISION_LOWP_FLOAT)
+#	define GLM_CONFIG_PRECISION_FLOAT		GLM_LOWP
+#else
+#	define GLM_CONFIG_PRECISION_FLOAT		GLM_HIGHP
+#endif
+
+#if defined(GLM_FORCE_PRECISION_HIGHP_DOUBLE) || defined(GLM_PRECISION_HIGHP_DOUBLE)
+#	define GLM_CONFIG_PRECISION_DOUBLE		GLM_HIGHP
+#elif defined(GLM_FORCE_PRECISION_MEDIUMP_DOUBLE) || defined(GLM_PRECISION_MEDIUMP_DOUBLE)
+#	define GLM_CONFIG_PRECISION_DOUBLE		GLM_MEDIUMP
+#elif defined(GLM_FORCE_PRECISION_LOWP_DOUBLE) || defined(GLM_PRECISION_LOWP_DOUBLE)
+#	define GLM_CONFIG_PRECISION_DOUBLE		GLM_LOWP
+#else
+#	define GLM_CONFIG_PRECISION_DOUBLE		GLM_HIGHP
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Check inclusions of different versions of GLM
+
+#elif ((GLM_SETUP_INCLUDED != GLM_VERSION) && !defined(GLM_FORCE_IGNORE_VERSION))
+#	error "GLM error: A different version of GLM is already included. Define GLM_FORCE_IGNORE_VERSION before including GLM headers to ignore this error."
+#elif GLM_SETUP_INCLUDED == GLM_VERSION
+
+///////////////////////////////////////////////////////////////////////////////////
+// Messages
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_MESSAGE_DISPLAYED)
+#	define GLM_MESSAGE_DISPLAYED
+#		define GLM_STR_HELPER(x) #x
+#		define GLM_STR(x) GLM_STR_HELPER(x)
+
+	// Report GLM version
+#		pragma message (GLM_STR(GLM_VERSION_MESSAGE))
+
+	// Report C++ language
+#	if (GLM_LANG & GLM_LANG_CXX2A_FLAG) && (GLM_LANG & GLM_LANG_EXT)
+#		pragma message("GLM: C++ 2A with extensions")
+#	elif (GLM_LANG & GLM_LANG_CXX2A_FLAG)
+#		pragma message("GLM: C++ 2A")
+#	elif (GLM_LANG & GLM_LANG_CXX17_FLAG) && (GLM_LANG & GLM_LANG_EXT)
+#		pragma message("GLM: C++ 17 with extensions")
+#	elif (GLM_LANG & GLM_LANG_CXX17_FLAG)
+#		pragma message("GLM: C++ 17")
+#	elif (GLM_LANG & GLM_LANG_CXX14_FLAG) && (GLM_LANG & GLM_LANG_EXT)
+#		pragma message("GLM: C++ 14 with extensions")
+#	elif (GLM_LANG & GLM_LANG_CXX14_FLAG)
+#		pragma message("GLM: C++ 14")
+#	elif (GLM_LANG & GLM_LANG_CXX11_FLAG) && (GLM_LANG & GLM_LANG_EXT)
+#		pragma message("GLM: C++ 11 with extensions")
+#	elif (GLM_LANG & GLM_LANG_CXX11_FLAG)
+#		pragma message("GLM: C++ 11")
+#	elif (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_LANG & GLM_LANG_EXT)
+#		pragma message("GLM: C++ 0x with extensions")
+#	elif (GLM_LANG & GLM_LANG_CXX0X_FLAG)
+#		pragma message("GLM: C++ 0x")
+#	elif (GLM_LANG & GLM_LANG_CXX03_FLAG) && (GLM_LANG & GLM_LANG_EXT)
+#		pragma message("GLM: C++ 03 with extensions")
+#	elif (GLM_LANG & GLM_LANG_CXX03_FLAG)
+#		pragma message("GLM: C++ 03")
+#	elif (GLM_LANG & GLM_LANG_CXX98_FLAG) && (GLM_LANG & GLM_LANG_EXT)
+#		pragma message("GLM: C++ 98 with extensions")
+#	elif (GLM_LANG & GLM_LANG_CXX98_FLAG)
+#		pragma message("GLM: C++ 98")
+#	else
+#		pragma message("GLM: C++ language undetected")
+#	endif//GLM_LANG
+
+	// Report compiler detection
+#	if GLM_COMPILER & GLM_COMPILER_CUDA
+#		pragma message("GLM: CUDA compiler detected")
+#	elif GLM_COMPILER & GLM_COMPILER_VC
+#		pragma message("GLM: Visual C++ compiler detected")
+#	elif GLM_COMPILER & GLM_COMPILER_CLANG
+#		pragma message("GLM: Clang compiler detected")
+#	elif GLM_COMPILER & GLM_COMPILER_INTEL
+#		pragma message("GLM: Intel Compiler detected")
+#	elif GLM_COMPILER & GLM_COMPILER_GCC
+#		pragma message("GLM: GCC compiler detected")
+#	else
+#		pragma message("GLM: Compiler not detected")
+#	endif
+
+	// Report build target
+#	if (GLM_ARCH & GLM_ARCH_AVX2_BIT) && (GLM_MODEL == GLM_MODEL_64)
+#		pragma message("GLM: x86 64 bits with AVX2 instruction set build target")
+#	elif (GLM_ARCH & GLM_ARCH_AVX2_BIT) && (GLM_MODEL == GLM_MODEL_32)
+#		pragma message("GLM: x86 32 bits with AVX2 instruction set build target")
+
+#	elif (GLM_ARCH & GLM_ARCH_AVX_BIT) && (GLM_MODEL == GLM_MODEL_64)
+#		pragma message("GLM: x86 64 bits with AVX instruction set build target")
+#	elif (GLM_ARCH & GLM_ARCH_AVX_BIT) && (GLM_MODEL == GLM_MODEL_32)
+#		pragma message("GLM: x86 32 bits with AVX instruction set build target")
+
+#	elif (GLM_ARCH & GLM_ARCH_SSE42_BIT) && (GLM_MODEL == GLM_MODEL_64)
+#		pragma message("GLM: x86 64 bits with SSE4.2 instruction set build target")
+#	elif (GLM_ARCH & GLM_ARCH_SSE42_BIT) && (GLM_MODEL == GLM_MODEL_32)
+#		pragma message("GLM: x86 32 bits with SSE4.2 instruction set build target")
+
+#	elif (GLM_ARCH & GLM_ARCH_SSE41_BIT) && (GLM_MODEL == GLM_MODEL_64)
+#		pragma message("GLM: x86 64 bits with SSE4.1 instruction set build target")
+#	elif (GLM_ARCH & GLM_ARCH_SSE41_BIT) && (GLM_MODEL == GLM_MODEL_32)
+#		pragma message("GLM: x86 32 bits with SSE4.1 instruction set build target")
+
+#	elif (GLM_ARCH & GLM_ARCH_SSSE3_BIT) && (GLM_MODEL == GLM_MODEL_64)
+#		pragma message("GLM: x86 64 bits with SSSE3 instruction set build target")
+#	elif (GLM_ARCH & GLM_ARCH_SSSE3_BIT) && (GLM_MODEL == GLM_MODEL_32)
+#		pragma message("GLM: x86 32 bits with SSSE3 instruction set build target")
+
+#	elif (GLM_ARCH & GLM_ARCH_SSE3_BIT) && (GLM_MODEL == GLM_MODEL_64)
+#		pragma message("GLM: x86 64 bits with SSE3 instruction set build target")
+#	elif (GLM_ARCH & GLM_ARCH_SSE3_BIT) && (GLM_MODEL == GLM_MODEL_32)
+#		pragma message("GLM: x86 32 bits with SSE3 instruction set build target")
+
+#	elif (GLM_ARCH & GLM_ARCH_SSE2_BIT) && (GLM_MODEL == GLM_MODEL_64)
+#		pragma message("GLM: x86 64 bits with SSE2 instruction set build target")
+#	elif (GLM_ARCH & GLM_ARCH_SSE2_BIT) && (GLM_MODEL == GLM_MODEL_32)
+#		pragma message("GLM: x86 32 bits with SSE2 instruction set build target")
+
+#	elif (GLM_ARCH & GLM_ARCH_X86_BIT) && (GLM_MODEL == GLM_MODEL_64)
+#		pragma message("GLM: x86 64 bits build target")
+#	elif (GLM_ARCH & GLM_ARCH_X86_BIT) && (GLM_MODEL == GLM_MODEL_32)
+#		pragma message("GLM: x86 32 bits build target")
+
+#	elif (GLM_ARCH & GLM_ARCH_NEON_BIT) && (GLM_MODEL == GLM_MODEL_64)
+#		pragma message("GLM: ARM 64 bits with Neon instruction set build target")
+#	elif (GLM_ARCH & GLM_ARCH_NEON_BIT) && (GLM_MODEL == GLM_MODEL_32)
+#		pragma message("GLM: ARM 32 bits with Neon instruction set build target")
+
+#	elif (GLM_ARCH & GLM_ARCH_ARM_BIT) && (GLM_MODEL == GLM_MODEL_64)
+#		pragma message("GLM: ARM 64 bits build target")
+#	elif (GLM_ARCH & GLM_ARCH_ARM_BIT) && (GLM_MODEL == GLM_MODEL_32)
+#		pragma message("GLM: ARM 32 bits build target")
+
+#	elif (GLM_ARCH & GLM_ARCH_MIPS_BIT) && (GLM_MODEL == GLM_MODEL_64)
+#		pragma message("GLM: MIPS 64 bits build target")
+#	elif (GLM_ARCH & GLM_ARCH_MIPS_BIT) && (GLM_MODEL == GLM_MODEL_32)
+#		pragma message("GLM: MIPS 32 bits build target")
+
+#	elif (GLM_ARCH & GLM_ARCH_PPC_BIT) && (GLM_MODEL == GLM_MODEL_64)
+#		pragma message("GLM: PowerPC 64 bits build target")
+#	elif (GLM_ARCH & GLM_ARCH_PPC_BIT) && (GLM_MODEL == GLM_MODEL_32)
+#		pragma message("GLM: PowerPC 32 bits build target")
+#	else
+#		pragma message("GLM: Unknown build target")
+#	endif//GLM_ARCH
+
+	// Report platform name
+#	if(GLM_PLATFORM & GLM_PLATFORM_QNXNTO)
+#		pragma message("GLM: QNX platform detected")
+//#	elif(GLM_PLATFORM & GLM_PLATFORM_IOS)
+//#		pragma message("GLM: iOS platform detected")
+#	elif(GLM_PLATFORM & GLM_PLATFORM_APPLE)
+#		pragma message("GLM: Apple platform detected")
+#	elif(GLM_PLATFORM & GLM_PLATFORM_WINCE)
+#		pragma message("GLM: WinCE platform detected")
+#	elif(GLM_PLATFORM & GLM_PLATFORM_WINDOWS)
+#		pragma message("GLM: Windows platform detected")
+#	elif(GLM_PLATFORM & GLM_PLATFORM_CHROME_NACL)
+#		pragma message("GLM: Native Client detected")
+#	elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
+#		pragma message("GLM: Android platform detected")
+#	elif(GLM_PLATFORM & GLM_PLATFORM_LINUX)
+#		pragma message("GLM: Linux platform detected")
+#	elif(GLM_PLATFORM & GLM_PLATFORM_UNIX)
+#		pragma message("GLM: UNIX platform detected")
+#	elif(GLM_PLATFORM & GLM_PLATFORM_UNKNOWN)
+#		pragma message("GLM: platform unknown")
+#	else
+#		pragma message("GLM: platform not detected")
+#	endif
+
+	// Report whether only xyzw component are used
+#	if defined GLM_FORCE_XYZW_ONLY
+#		pragma message("GLM: GLM_FORCE_XYZW_ONLY is defined. Only x, y, z and w component are available in vector type. This define disables swizzle operators and SIMD instruction sets.")
+#	endif
+
+	// Report swizzle operator support
+#	if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+#		pragma message("GLM: GLM_FORCE_SWIZZLE is defined, swizzling operators enabled.")
+#	elif GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+#		pragma message("GLM: GLM_FORCE_SWIZZLE is defined, swizzling functions enabled. Enable compiler C++ language extensions to enable swizzle operators.")
+#	else
+#		pragma message("GLM: GLM_FORCE_SWIZZLE is undefined. swizzling functions or operators are disabled.")
+#	endif
+
+	// Report .length() type
+#	if GLM_CONFIG_LENGTH_TYPE == GLM_LENGTH_SIZE_T
+#		pragma message("GLM: GLM_FORCE_SIZE_T_LENGTH is defined. .length() returns a glm::length_t, a typedef of std::size_t.")
+#	else
+#		pragma message("GLM: GLM_FORCE_SIZE_T_LENGTH is undefined. .length() returns a glm::length_t, a typedef of int following GLSL.")
+#	endif
+
+#	if GLM_CONFIG_UNRESTRICTED_GENTYPE == GLM_ENABLE
+#		pragma message("GLM: GLM_FORCE_UNRESTRICTED_GENTYPE is defined. Removes GLSL restrictions on valid function genTypes.")
+#	else
+#		pragma message("GLM: GLM_FORCE_UNRESTRICTED_GENTYPE is undefined. Follows strictly GLSL on valid function genTypes.")
+#	endif
+
+#	if GLM_SILENT_WARNINGS == GLM_ENABLE
+#		pragma message("GLM: GLM_FORCE_SILENT_WARNINGS is defined. Ignores C++ warnings from using C++ language extensions.")
+#	else
+#		pragma message("GLM: GLM_FORCE_SILENT_WARNINGS is undefined. Shows C++ warnings from using C++ language extensions.")
+#	endif
+
+#	ifdef GLM_FORCE_SINGLE_ONLY
+#		pragma message("GLM: GLM_FORCE_SINGLE_ONLY is defined. Using only single precision floating-point types.")
+#	endif
+
+#	if defined(GLM_FORCE_ALIGNED_GENTYPES) && (GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE)
+#		undef GLM_FORCE_ALIGNED_GENTYPES
+#		pragma message("GLM: GLM_FORCE_ALIGNED_GENTYPES is defined, allowing aligned types. This prevents the use of C++ constexpr.")
+#	elif defined(GLM_FORCE_ALIGNED_GENTYPES) && (GLM_CONFIG_ALIGNED_GENTYPES == GLM_DISABLE)
+#		undef GLM_FORCE_ALIGNED_GENTYPES
+#		pragma message("GLM: GLM_FORCE_ALIGNED_GENTYPES is defined but is disabled. It requires C++11 and language extensions.")
+#	endif
+
+#	if defined(GLM_FORCE_DEFAULT_ALIGNED_GENTYPES)
+#		if GLM_CONFIG_ALIGNED_GENTYPES == GLM_DISABLE
+#			undef GLM_FORCE_DEFAULT_ALIGNED_GENTYPES
+#			pragma message("GLM: GLM_FORCE_DEFAULT_ALIGNED_GENTYPES is defined but is disabled. It requires C++11 and language extensions.")
+#		elif GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE
+#			pragma message("GLM: GLM_FORCE_DEFAULT_ALIGNED_GENTYPES is defined. All gentypes (e.g. vec3) will be aligned and padded by default.")
+#		endif
+#	endif
+
+#	if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT
+#		pragma message("GLM: GLM_FORCE_DEPTH_ZERO_TO_ONE is defined. Using zero to one depth clip space.")
+#	else
+#		pragma message("GLM: GLM_FORCE_DEPTH_ZERO_TO_ONE is undefined. Using negative one to one depth clip space.")
+#	endif
+
+#	if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT
+#		pragma message("GLM: GLM_FORCE_LEFT_HANDED is defined. Using left handed coordinate system.")
+#	else
+#		pragma message("GLM: GLM_FORCE_LEFT_HANDED is undefined. Using right handed coordinate system.")
+#	endif
+#endif//GLM_MESSAGES
+
+#endif//GLM_SETUP_INCLUDED
diff --git a/engine/inc/glm/detail/type_float.hpp b/engine/inc/glm/detail/type_float.hpp
new file mode 100644
index 00000000..c8037ebd
--- /dev/null
+++ b/engine/inc/glm/detail/type_float.hpp
@@ -0,0 +1,68 @@
+#pragma once
+
+#include "setup.hpp"
+
+#if GLM_COMPILER == GLM_COMPILER_VC12
+#	pragma warning(push)
+#	pragma warning(disable: 4512) // assignment operator could not be generated
+#endif
+
+namespace glm{
+namespace detail
+{
+	template <typename T>
+	union float_t
+	{};
+
+	// https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
+	template <>
+	union float_t<float>
+	{
+		typedef int int_type;
+		typedef float float_type;
+
+		GLM_CONSTEXPR float_t(float_type Num = 0.0f) : f(Num) {}
+
+		GLM_CONSTEXPR float_t& operator=(float_t const& x)
+		{
+			f = x.f;
+			return *this;
+		}
+
+		// Portable extraction of components.
+		GLM_CONSTEXPR bool negative() const { return i < 0; }
+		GLM_CONSTEXPR int_type mantissa() const { return i & ((1 << 23) - 1); }
+		GLM_CONSTEXPR int_type exponent() const { return (i >> 23) & ((1 << 8) - 1); }
+
+		int_type i;
+		float_type f;
+	};
+
+	template <>
+	union float_t<double>
+	{
+		typedef detail::int64 int_type;
+		typedef double float_type;
+
+		GLM_CONSTEXPR float_t(float_type Num = static_cast<float_type>(0)) : f(Num) {}
+
+		GLM_CONSTEXPR float_t& operator=(float_t const& x)
+		{
+			f = x.f;
+			return *this;
+		}
+
+		// Portable extraction of components.
+		GLM_CONSTEXPR bool negative() const { return i < 0; }
+		GLM_CONSTEXPR int_type mantissa() const { return i & ((int_type(1) << 52) - 1); }
+		GLM_CONSTEXPR int_type exponent() const { return (i >> 52) & ((int_type(1) << 11) - 1); }
+
+		int_type i;
+		float_type f;
+	};
+}//namespace detail
+}//namespace glm
+
+#if GLM_COMPILER == GLM_COMPILER_VC12
+#	pragma warning(pop)
+#endif
diff --git a/engine/inc/glm/detail/type_half.hpp b/engine/inc/glm/detail/type_half.hpp
new file mode 100644
index 00000000..40b8bec0
--- /dev/null
+++ b/engine/inc/glm/detail/type_half.hpp
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "setup.hpp"
+
+namespace glm{
+namespace detail
+{
+	typedef short hdata;
+
+	GLM_FUNC_DECL float toFloat32(hdata value);
+	GLM_FUNC_DECL hdata toFloat16(float const& value);
+
+}//namespace detail
+}//namespace glm
+
+#include "type_half.inl"
diff --git a/engine/inc/glm/detail/type_half.inl b/engine/inc/glm/detail/type_half.inl
new file mode 100644
index 00000000..6a052f26
--- /dev/null
+++ b/engine/inc/glm/detail/type_half.inl
@@ -0,0 +1,241 @@
+namespace glm{
+namespace detail
+{
+	GLM_FUNC_QUALIFIER float overflow()
+	{
+		volatile float f = 1e10;
+
+		for(int i = 0; i < 10; ++i)
+			f *= f; // this will overflow before the for loop terminates
+		return f;
+	}
+
+	union uif32
+	{
+		GLM_FUNC_QUALIFIER uif32() :
+			i(0)
+		{}
+
+		GLM_FUNC_QUALIFIER uif32(float f_) :
+			f(f_)
+		{}
+
+		GLM_FUNC_QUALIFIER uif32(unsigned int i_) :
+			i(i_)
+		{}
+
+		float f;
+		unsigned int i;
+	};
+
+	GLM_FUNC_QUALIFIER float toFloat32(hdata value)
+	{
+		int s = (value >> 15) & 0x00000001;
+		int e = (value >> 10) & 0x0000001f;
+		int m =  value        & 0x000003ff;
+
+		if(e == 0)
+		{
+			if(m == 0)
+			{
+				//
+				// Plus or minus zero
+				//
+
+				detail::uif32 result;
+				result.i = static_cast<unsigned int>(s << 31);
+				return result.f;
+			}
+			else
+			{
+				//
+				// Denormalized number -- renormalize it
+				//
+
+				while(!(m & 0x00000400))
+				{
+					m <<= 1;
+					e -=  1;
+				}
+
+				e += 1;
+				m &= ~0x00000400;
+			}
+		}
+		else if(e == 31)
+		{
+			if(m == 0)
+			{
+				//
+				// Positive or negative infinity
+				//
+
+				uif32 result;
+				result.i = static_cast<unsigned int>((s << 31) | 0x7f800000);
+				return result.f;
+			}
+			else
+			{
+				//
+				// Nan -- preserve sign and significand bits
+				//
+
+				uif32 result;
+				result.i = static_cast<unsigned int>((s << 31) | 0x7f800000 | (m << 13));
+				return result.f;
+			}
+		}
+
+		//
+		// Normalized number
+		//
+
+		e = e + (127 - 15);
+		m = m << 13;
+
+		//
+		// Assemble s, e and m.
+		//
+
+		uif32 Result;
+		Result.i = static_cast<unsigned int>((s << 31) | (e << 23) | m);
+		return Result.f;
+	}
+
+	GLM_FUNC_QUALIFIER hdata toFloat16(float const& f)
+	{
+		uif32 Entry;
+		Entry.f = f;
+		int i = static_cast<int>(Entry.i);
+
+		//
+		// Our floating point number, f, is represented by the bit
+		// pattern in integer i.  Disassemble that bit pattern into
+		// the sign, s, the exponent, e, and the significand, m.
+		// Shift s into the position where it will go in in the
+		// resulting half number.
+		// Adjust e, accounting for the different exponent bias
+		// of float and half (127 versus 15).
+		//
+
+		int s =  (i >> 16) & 0x00008000;
+		int e = ((i >> 23) & 0x000000ff) - (127 - 15);
+		int m =   i        & 0x007fffff;
+
+		//
+		// Now reassemble s, e and m into a half:
+		//
+
+		if(e <= 0)
+		{
+			if(e < -10)
+			{
+				//
+				// E is less than -10.  The absolute value of f is
+				// less than half_MIN (f may be a small normalized
+				// float, a denormalized float or a zero).
+				//
+				// We convert f to a half zero.
+				//
+
+				return hdata(s);
+			}
+
+			//
+			// E is between -10 and 0.  F is a normalized float,
+			// whose magnitude is less than __half_NRM_MIN.
+			//
+			// We convert f to a denormalized half.
+			//
+
+			m = (m | 0x00800000) >> (1 - e);
+
+			//
+			// Round to nearest, round "0.5" up.
+			//
+			// Rounding may cause the significand to overflow and make
+			// our number normalized.  Because of the way a half's bits
+			// are laid out, we don't have to treat this case separately;
+			// the code below will handle it correctly.
+			//
+
+			if(m & 0x00001000)
+				m += 0x00002000;
+
+			//
+			// Assemble the half from s, e (zero) and m.
+			//
+
+			return hdata(s | (m >> 13));
+		}
+		else if(e == 0xff - (127 - 15))
+		{
+			if(m == 0)
+			{
+				//
+				// F is an infinity; convert f to a half
+				// infinity with the same sign as f.
+				//
+
+				return hdata(s | 0x7c00);
+			}
+			else
+			{
+				//
+				// F is a NAN; we produce a half NAN that preserves
+				// the sign bit and the 10 leftmost bits of the
+				// significand of f, with one exception: If the 10
+				// leftmost bits are all zero, the NAN would turn
+				// into an infinity, so we have to set at least one
+				// bit in the significand.
+				//
+
+				m >>= 13;
+
+				return hdata(s | 0x7c00 | m | (m == 0));
+			}
+		}
+		else
+		{
+			//
+			// E is greater than zero.  F is a normalized float.
+			// We try to convert f to a normalized half.
+			//
+
+			//
+			// Round to nearest, round "0.5" up
+			//
+
+			if(m &  0x00001000)
+			{
+				m += 0x00002000;
+
+				if(m & 0x00800000)
+				{
+					m =  0;     // overflow in significand,
+					e += 1;     // adjust exponent
+				}
+			}
+
+			//
+			// Handle exponent overflow
+			//
+
+			if (e > 30)
+			{
+				overflow();        // Cause a hardware floating point overflow;
+
+				return hdata(s | 0x7c00);
+				// if this returns, the half becomes an
+			}   // infinity with the same sign as f.
+
+			//
+			// Assemble the half from s, e and m.
+			//
+
+			return hdata(s | (e << 10) | (m >> 13));
+		}
+	}
+
+}//namespace detail
+}//namespace glm
diff --git a/engine/inc/glm/detail/type_mat2x2.hpp b/engine/inc/glm/detail/type_mat2x2.hpp
new file mode 100644
index 00000000..033908f4
--- /dev/null
+++ b/engine/inc/glm/detail/type_mat2x2.hpp
@@ -0,0 +1,177 @@
+/// @ref core
+/// @file glm/detail/type_mat2x2.hpp
+
+#pragma once
+
+#include "type_vec2.hpp"
+#include <limits>
+#include <cstddef>
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	struct mat<2, 2, T, Q>
+	{
+		typedef vec<2, T, Q> col_type;
+		typedef vec<2, T, Q> row_type;
+		typedef mat<2, 2, T, Q> type;
+		typedef mat<2, 2, T, Q> transpose_type;
+		typedef T value_type;
+
+	private:
+		col_type value[2];
+
+	public:
+		// -- Accesses --
+
+		typedef length_t length_type;
+		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 2; }
+
+		GLM_FUNC_DECL col_type & operator[](length_type i);
+		GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const;
+
+		// -- Constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT;
+		template<qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<2, 2, T, P> const& m);
+
+		GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			T const& x1, T const& y1,
+			T const& x2, T const& y2);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			col_type const& v1,
+			col_type const& v2);
+
+		// -- Conversions --
+
+		template<typename U, typename V, typename M, typename N>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			U const& x1, V const& y1,
+			M const& x2, N const& y2);
+
+		template<typename U, typename V>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			vec<2, U, Q> const& v1,
+			vec<2, V, Q> const& v2);
+
+		// -- Matrix conversions --
+
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, U, P> const& m);
+
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x);
+
+		// -- Unary arithmetic operators --
+
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 2, T, Q> & operator=(mat<2, 2, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 2, T, Q> & operator+=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 2, T, Q> & operator+=(mat<2, 2, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 2, T, Q> & operator-=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 2, T, Q> & operator-=(mat<2, 2, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 2, T, Q> & operator*=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 2, T, Q> & operator*=(mat<2, 2, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 2, T, Q> & operator/=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 2, T, Q> & operator/=(mat<2, 2, U, Q> const& m);
+
+		// -- Increment and decrement operators --
+
+		GLM_FUNC_DECL mat<2, 2, T, Q> & operator++ ();
+		GLM_FUNC_DECL mat<2, 2, T, Q> & operator-- ();
+		GLM_FUNC_DECL mat<2, 2, T, Q> operator++(int);
+		GLM_FUNC_DECL mat<2, 2, T, Q> operator--(int);
+	};
+
+	// -- Unary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator+(mat<2, 2, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator-(mat<2, 2, T, Q> const& m);
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator+(mat<2, 2, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator+(T scalar, mat<2, 2, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator+(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator-(mat<2, 2, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator-(T scalar, mat<2, 2, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator-(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator*(mat<2, 2, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator*(T scalar, mat<2, 2, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<2, 2, T, Q>::col_type operator*(mat<2, 2, T, Q> const& m, typename mat<2, 2, T, Q>::row_type const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<2, 2, T, Q>::row_type operator*(typename mat<2, 2, T, Q>::col_type const& v, mat<2, 2, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator*(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 2, T, Q> operator*(mat<2, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 2, T, Q> operator*(mat<2, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator/(mat<2, 2, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator/(T scalar, mat<2, 2, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<2, 2, T, Q>::col_type operator/(mat<2, 2, T, Q> const& m, typename mat<2, 2, T, Q>::row_type const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<2, 2, T, Q>::row_type operator/(typename mat<2, 2, T, Q>::col_type const& v, mat<2, 2, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator/(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2);
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator==(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator!=(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2);
+} //namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat2x2.inl"
+#endif
diff --git a/engine/inc/glm/detail/type_mat2x2.inl b/engine/inc/glm/detail/type_mat2x2.inl
new file mode 100644
index 00000000..fe5d1aa3
--- /dev/null
+++ b/engine/inc/glm/detail/type_mat2x2.inl
@@ -0,0 +1,536 @@
+#include "../matrix.hpp"
+
+namespace glm
+{
+	// -- Constructors --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat()
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
+				: value{col_type(1, 0), col_type(0, 1)}
+#			endif
+		{
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
+				this->value[0] = col_type(1, 0);
+				this->value[1] = col_type(0, 1);
+#			endif
+		}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<2, 2, T, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{m[0], m[1]}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = m[0];
+			this->value[1] = m[1];
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(T scalar)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(scalar, 0), col_type(0, scalar)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(scalar, 0);
+			this->value[1] = col_type(0, scalar);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat
+	(
+		T const& x0, T const& y0,
+		T const& x1, T const& y1
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(x0, y0), col_type(x1, y1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x0, y0);
+			this->value[1] = col_type(x1, y1);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(col_type const& v0, col_type const& v1)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{v0, v1}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = v0;
+			this->value[1] = v1;
+#		endif
+	}
+
+	// -- Conversion constructors --
+
+	template<typename T, qualifier Q>
+	template<typename X1, typename Y1, typename X2, typename Y2>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat
+	(
+		X1 const& x1, Y1 const& y1,
+		X2 const& x2, Y2 const& y2
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(static_cast<T>(x1), value_type(y1)), col_type(static_cast<T>(x2), value_type(y2)) }
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(static_cast<T>(x1), value_type(y1));
+			this->value[1] = col_type(static_cast<T>(x2), value_type(y2));
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	template<typename V1, typename V2>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(vec<2, V1, Q> const& v1, vec<2, V2, Q> const& v2)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v1), col_type(v2)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(v1);
+			this->value[1] = col_type(v2);
+#		endif
+	}
+
+	// -- mat2x2 matrix conversions --
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<2, 2, U, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<3, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<4, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<2, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<3, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<2, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<4, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<3, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<4, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	// -- Accesses --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<2, 2, T, Q>::col_type& mat<2, 2, T, Q>::operator[](typename mat<2, 2, T, Q>::length_type i)
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<2, 2, T, Q>::col_type const& mat<2, 2, T, Q>::operator[](typename mat<2, 2, T, Q>::length_type i) const
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	// -- Unary updatable operators --
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator=(mat<2, 2, U, Q> const& m)
+	{
+		this->value[0] = m[0];
+		this->value[1] = m[1];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator+=(U scalar)
+	{
+		this->value[0] += scalar;
+		this->value[1] += scalar;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator+=(mat<2, 2, U, Q> const& m)
+	{
+		this->value[0] += m[0];
+		this->value[1] += m[1];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator-=(U scalar)
+	{
+		this->value[0] -= scalar;
+		this->value[1] -= scalar;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator-=(mat<2, 2, U, Q> const& m)
+	{
+		this->value[0] -= m[0];
+		this->value[1] -= m[1];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator*=(U scalar)
+	{
+		this->value[0] *= scalar;
+		this->value[1] *= scalar;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator*=(mat<2, 2, U, Q> const& m)
+	{
+		return (*this = *this * m);
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator/=(U scalar)
+	{
+		this->value[0] /= scalar;
+		this->value[1] /= scalar;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator/=(mat<2, 2, U, Q> const& m)
+	{
+		return *this *= inverse(m);
+	}
+
+	// -- Increment and decrement operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator++()
+	{
+		++this->value[0];
+		++this->value[1];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator--()
+	{
+		--this->value[0];
+		--this->value[1];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> mat<2, 2, T, Q>::operator++(int)
+	{
+		mat<2, 2, T, Q> Result(*this);
+		++*this;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> mat<2, 2, T, Q>::operator--(int)
+	{
+		mat<2, 2, T, Q> Result(*this);
+		--*this;
+		return Result;
+	}
+
+	// -- Unary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator+(mat<2, 2, T, Q> const& m)
+	{
+		return m;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator-(mat<2, 2, T, Q> const& m)
+	{
+		return mat<2, 2, T, Q>(
+			-m[0],
+			-m[1]);
+	}
+
+	// -- Binary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator+(mat<2, 2, T, Q> const& m, T scalar)
+	{
+		return mat<2, 2, T, Q>(
+			m[0] + scalar,
+			m[1] + scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator+(T scalar, mat<2, 2, T, Q> const& m)
+	{
+		return mat<2, 2, T, Q>(
+			m[0] + scalar,
+			m[1] + scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator+(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2)
+	{
+		return mat<2, 2, T, Q>(
+			m1[0] + m2[0],
+			m1[1] + m2[1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator-(mat<2, 2, T, Q> const& m, T scalar)
+	{
+		return mat<2, 2, T, Q>(
+			m[0] - scalar,
+			m[1] - scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator-(T scalar, mat<2, 2, T, Q> const& m)
+	{
+		return mat<2, 2, T, Q>(
+			scalar - m[0],
+			scalar - m[1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator-(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2)
+	{
+		return mat<2, 2, T, Q>(
+			m1[0] - m2[0],
+			m1[1] - m2[1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator*(mat<2, 2, T, Q> const& m, T scalar)
+	{
+		return mat<2, 2, T, Q>(
+			m[0] * scalar,
+			m[1] * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator*(T scalar, mat<2, 2, T, Q> const& m)
+	{
+		return mat<2, 2, T, Q>(
+			m[0] * scalar,
+			m[1] * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<2, 2, T, Q>::col_type operator*
+	(
+		mat<2, 2, T, Q> const& m,
+		typename mat<2, 2, T, Q>::row_type const& v
+	)
+	{
+		return vec<2, T, Q>(
+			m[0][0] * v.x + m[1][0] * v.y,
+			m[0][1] * v.x + m[1][1] * v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<2, 2, T, Q>::row_type operator*
+	(
+		typename mat<2, 2, T, Q>::col_type const& v,
+		mat<2, 2, T, Q> const& m
+	)
+	{
+		return vec<2, T, Q>(
+			v.x * m[0][0] + v.y * m[0][1],
+			v.x * m[1][0] + v.y * m[1][1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator*(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2)
+	{
+		return mat<2, 2, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator*(mat<2, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2)
+	{
+		return mat<3, 2, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
+			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1],
+			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator*(mat<2, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2)
+	{
+		return mat<4, 2, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
+			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1],
+			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1],
+			m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1],
+			m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator/(mat<2, 2, T, Q> const& m, T scalar)
+	{
+		return mat<2, 2, T, Q>(
+			m[0] / scalar,
+			m[1] / scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator/(T scalar, mat<2, 2, T, Q> const& m)
+	{
+		return mat<2, 2, T, Q>(
+			scalar / m[0],
+			scalar / m[1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<2, 2, T, Q>::col_type operator/(mat<2, 2, T, Q> const& m, typename mat<2, 2, T, Q>::row_type const& v)
+	{
+		return inverse(m) * v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<2, 2, T, Q>::row_type operator/(typename mat<2, 2, T, Q>::col_type const& v, mat<2, 2, T, Q> const& m)
+	{
+		return v *  inverse(m);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator/(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2)
+	{
+		mat<2, 2, T, Q> m1_copy(m1);
+		return m1_copy /= m2;
+	}
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator==(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator!=(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]);
+	}
+} //namespace glm
diff --git a/engine/inc/glm/detail/type_mat2x3.hpp b/engine/inc/glm/detail/type_mat2x3.hpp
new file mode 100644
index 00000000..d6596e46
--- /dev/null
+++ b/engine/inc/glm/detail/type_mat2x3.hpp
@@ -0,0 +1,159 @@
+/// @ref core
+/// @file glm/detail/type_mat2x3.hpp
+
+#pragma once
+
+#include "type_vec2.hpp"
+#include "type_vec3.hpp"
+#include <limits>
+#include <cstddef>
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	struct mat<2, 3, T, Q>
+	{
+		typedef vec<3, T, Q> col_type;
+		typedef vec<2, T, Q> row_type;
+		typedef mat<2, 3, T, Q> type;
+		typedef mat<3, 2, T, Q> transpose_type;
+		typedef T value_type;
+
+	private:
+		col_type value[2];
+
+	public:
+		// -- Accesses --
+
+		typedef length_t length_type;
+		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 2; }
+
+		GLM_FUNC_DECL col_type & operator[](length_type i);
+		GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const;
+
+		// -- Constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT;
+		template<qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<2, 3, T, P> const& m);
+
+		GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			T x0, T y0, T z0,
+			T x1, T y1, T z1);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			col_type const& v0,
+			col_type const& v1);
+
+		// -- Conversions --
+
+		template<typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			X1 x1, Y1 y1, Z1 z1,
+			X2 x2, Y2 y2, Z2 z2);
+
+		template<typename U, typename V>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			vec<3, U, Q> const& v1,
+			vec<3, V, Q> const& v2);
+
+		// -- Matrix conversions --
+
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, U, P> const& m);
+
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x);
+
+		// -- Unary arithmetic operators --
+
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 3, T, Q> & operator=(mat<2, 3, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 3, T, Q> & operator+=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 3, T, Q> & operator+=(mat<2, 3, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 3, T, Q> & operator-=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 3, T, Q> & operator-=(mat<2, 3, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 3, T, Q> & operator*=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 3, T, Q> & operator/=(U s);
+
+		// -- Increment and decrement operators --
+
+		GLM_FUNC_DECL mat<2, 3, T, Q> & operator++ ();
+		GLM_FUNC_DECL mat<2, 3, T, Q> & operator-- ();
+		GLM_FUNC_DECL mat<2, 3, T, Q> operator++(int);
+		GLM_FUNC_DECL mat<2, 3, T, Q> operator--(int);
+	};
+
+	// -- Unary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 3, T, Q> operator+(mat<2, 3, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 3, T, Q> operator-(mat<2, 3, T, Q> const& m);
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 3, T, Q> operator+(mat<2, 3, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 3, T, Q> operator+(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 3, T, Q> operator-(mat<2, 3, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 3, T, Q> operator-(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 3, T, Q> operator*(mat<2, 3, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 3, T, Q> operator*(T scalar, mat<2, 3, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<2, 3, T, Q>::col_type operator*(mat<2, 3, T, Q> const& m, typename mat<2, 3, T, Q>::row_type const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<2, 3, T, Q>::row_type operator*(typename mat<2, 3, T, Q>::col_type const& v, mat<2, 3, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 3, T, Q> operator*(mat<2, 3, T, Q> const& m1, mat<2, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator*(mat<2, 3, T, Q> const& m1, mat<3, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 3, T, Q> operator*(mat<2, 3, T, Q> const& m1, mat<4, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 3, T, Q> operator/(mat<2, 3, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 3, T, Q> operator/(T scalar, mat<2, 3, T, Q> const& m);
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator==(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator!=(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat2x3.inl"
+#endif
diff --git a/engine/inc/glm/detail/type_mat2x3.inl b/engine/inc/glm/detail/type_mat2x3.inl
new file mode 100644
index 00000000..5fec17e5
--- /dev/null
+++ b/engine/inc/glm/detail/type_mat2x3.inl
@@ -0,0 +1,510 @@
+namespace glm
+{
+	// -- Constructors --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat()
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
+				: value{col_type(1, 0, 0), col_type(0, 1, 0)}
+#			endif
+		{
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
+				this->value[0] = col_type(1, 0, 0);
+				this->value[1] = col_type(0, 1, 0);
+#			endif
+		}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<2, 3, T, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{m.value[0], m.value[1]}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = m.value[0];
+			this->value[1] = m.value[1];
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(T scalar)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(scalar, 0, 0), col_type(0, scalar, 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(scalar, 0, 0);
+			this->value[1] = col_type(0, scalar, 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat
+	(
+		T x0, T y0, T z0,
+		T x1, T y1, T z1
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(x0, y0, z0), col_type(x1, y1, z1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x0, y0, z0);
+			this->value[1] = col_type(x1, y1, z1);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(col_type const& v0, col_type const& v1)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v0), col_type(v1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(v0);
+			this->value[1] = col_type(v1);
+#		endif
+	}
+
+	// -- Conversion constructors --
+
+	template<typename T, qualifier Q>
+	template<
+		typename X1, typename Y1, typename Z1,
+		typename X2, typename Y2, typename Z2>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat
+	(
+		X1 x1, Y1 y1, Z1 z1,
+		X2 x2, Y2 y2, Z2 z2
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(x1, y1, z1), col_type(x2, y2, z2)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x1, y1, z1);
+			this->value[1] = col_type(x2, y2, z2);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	template<typename V1, typename V2>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(vec<3, V1, Q> const& v1, vec<3, V2, Q> const& v2)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v1), col_type(v2)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(v1);
+			this->value[1] = col_type(v2);
+#		endif
+	}
+
+	// -- Matrix conversions --
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<2, 3, U, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<2, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR  mat<2, 3, T, Q>::mat(mat<3, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<4, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+		: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<2, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<3, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<3, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<4, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<4, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	// -- Accesses --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<2, 3, T, Q>::col_type & mat<2, 3, T, Q>::operator[](typename mat<2, 3, T, Q>::length_type i)
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<2, 3, T, Q>::col_type const& mat<2, 3, T, Q>::operator[](typename mat<2, 3, T, Q>::length_type i) const
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	// -- Unary updatable operators --
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q>& mat<2, 3, T, Q>::operator=(mat<2, 3, U, Q> const& m)
+	{
+		this->value[0] = m[0];
+		this->value[1] = m[1];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> & mat<2, 3, T, Q>::operator+=(U s)
+	{
+		this->value[0] += s;
+		this->value[1] += s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q>& mat<2, 3, T, Q>::operator+=(mat<2, 3, U, Q> const& m)
+	{
+		this->value[0] += m[0];
+		this->value[1] += m[1];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q>& mat<2, 3, T, Q>::operator-=(U s)
+	{
+		this->value[0] -= s;
+		this->value[1] -= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q>& mat<2, 3, T, Q>::operator-=(mat<2, 3, U, Q> const& m)
+	{
+		this->value[0] -= m[0];
+		this->value[1] -= m[1];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q>& mat<2, 3, T, Q>::operator*=(U s)
+	{
+		this->value[0] *= s;
+		this->value[1] *= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> & mat<2, 3, T, Q>::operator/=(U s)
+	{
+		this->value[0] /= s;
+		this->value[1] /= s;
+		return *this;
+	}
+
+	// -- Increment and decrement operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> & mat<2, 3, T, Q>::operator++()
+	{
+		++this->value[0];
+		++this->value[1];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> & mat<2, 3, T, Q>::operator--()
+	{
+		--this->value[0];
+		--this->value[1];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> mat<2, 3, T, Q>::operator++(int)
+	{
+		mat<2, 3, T, Q> Result(*this);
+		++*this;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> mat<2, 3, T, Q>::operator--(int)
+	{
+		mat<2, 3, T, Q> Result(*this);
+		--*this;
+		return Result;
+	}
+
+	// -- Unary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator+(mat<2, 3, T, Q> const& m)
+	{
+		return m;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator-(mat<2, 3, T, Q> const& m)
+	{
+		return mat<2, 3, T, Q>(
+			-m[0],
+			-m[1]);
+	}
+
+	// -- Binary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator+(mat<2, 3, T, Q> const& m, T scalar)
+	{
+		return mat<2, 3, T, Q>(
+			m[0] + scalar,
+			m[1] + scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator+(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2)
+	{
+		return mat<2, 3, T, Q>(
+			m1[0] + m2[0],
+			m1[1] + m2[1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator-(mat<2, 3, T, Q> const& m, T scalar)
+	{
+		return mat<2, 3, T, Q>(
+			m[0] - scalar,
+			m[1] - scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator-(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2)
+	{
+		return mat<2, 3, T, Q>(
+			m1[0] - m2[0],
+			m1[1] - m2[1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator*(mat<2, 3, T, Q> const& m, T scalar)
+	{
+		return mat<2, 3, T, Q>(
+			m[0] * scalar,
+			m[1] * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator*(T scalar, mat<2, 3, T, Q> const& m)
+	{
+		return mat<2, 3, T, Q>(
+			m[0] * scalar,
+			m[1] * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<2, 3, T, Q>::col_type operator*
+	(
+		mat<2, 3, T, Q> const& m,
+		typename mat<2, 3, T, Q>::row_type const& v)
+	{
+		return typename mat<2, 3, T, Q>::col_type(
+			m[0][0] * v.x + m[1][0] * v.y,
+			m[0][1] * v.x + m[1][1] * v.y,
+			m[0][2] * v.x + m[1][2] * v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<2, 3, T, Q>::row_type operator*
+	(
+		typename mat<2, 3, T, Q>::col_type const& v,
+		mat<2, 3, T, Q> const& m)
+	{
+		return typename mat<2, 3, T, Q>::row_type(
+			v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2],
+			v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator*(mat<2, 3, T, Q> const& m1, mat<2, 2, T, Q> const& m2)
+	{
+		return mat<2, 3, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
+			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
+			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator*(mat<2, 3, T, Q> const& m1, mat<3, 2, T, Q> const& m2)
+	{
+		T SrcA00 = m1[0][0];
+		T SrcA01 = m1[0][1];
+		T SrcA02 = m1[0][2];
+		T SrcA10 = m1[1][0];
+		T SrcA11 = m1[1][1];
+		T SrcA12 = m1[1][2];
+
+		T SrcB00 = m2[0][0];
+		T SrcB01 = m2[0][1];
+		T SrcB10 = m2[1][0];
+		T SrcB11 = m2[1][1];
+		T SrcB20 = m2[2][0];
+		T SrcB21 = m2[2][1];
+
+		mat<3, 3, T, Q> Result;
+		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01;
+		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01;
+		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01;
+		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11;
+		Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11;
+		Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11;
+		Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21;
+		Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21;
+		Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator*(mat<2, 3, T, Q> const& m1, mat<4, 2, T, Q> const& m2)
+	{
+		return mat<4, 3, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
+			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
+			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1],
+			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1],
+			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1],
+			m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1],
+			m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1],
+			m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1],
+			m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator/(mat<2, 3, T, Q> const& m, T scalar)
+	{
+		return mat<2, 3, T, Q>(
+			m[0] / scalar,
+			m[1] / scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator/(T scalar, mat<2, 3, T, Q> const& m)
+	{
+		return mat<2, 3, T, Q>(
+			scalar / m[0],
+			scalar / m[1]);
+	}
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator==(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator!=(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]);
+	}
+} //namespace glm
diff --git a/engine/inc/glm/detail/type_mat2x4.hpp b/engine/inc/glm/detail/type_mat2x4.hpp
new file mode 100644
index 00000000..ff03e215
--- /dev/null
+++ b/engine/inc/glm/detail/type_mat2x4.hpp
@@ -0,0 +1,161 @@
+/// @ref core
+/// @file glm/detail/type_mat2x4.hpp
+
+#pragma once
+
+#include "type_vec2.hpp"
+#include "type_vec4.hpp"
+#include <limits>
+#include <cstddef>
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	struct mat<2, 4, T, Q>
+	{
+		typedef vec<4, T, Q> col_type;
+		typedef vec<2, T, Q> row_type;
+		typedef mat<2, 4, T, Q> type;
+		typedef mat<4, 2, T, Q> transpose_type;
+		typedef T value_type;
+
+	private:
+		col_type value[2];
+
+	public:
+		// -- Accesses --
+
+		typedef length_t length_type;
+		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 2; }
+
+		GLM_FUNC_DECL col_type & operator[](length_type i);
+		GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const;
+
+		// -- Constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT;
+		template<qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<2, 4, T, P> const& m);
+
+		GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			T x0, T y0, T z0, T w0,
+			T x1, T y1, T z1, T w1);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			col_type const& v0,
+			col_type const& v1);
+
+		// -- Conversions --
+
+		template<
+			typename X1, typename Y1, typename Z1, typename W1,
+			typename X2, typename Y2, typename Z2, typename W2>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			X1 x1, Y1 y1, Z1 z1, W1 w1,
+			X2 x2, Y2 y2, Z2 z2, W2 w2);
+
+		template<typename U, typename V>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			vec<4, U, Q> const& v1,
+			vec<4, V, Q> const& v2);
+
+		// -- Matrix conversions --
+
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, U, P> const& m);
+
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x);
+
+		// -- Unary arithmetic operators --
+
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 4, T, Q> & operator=(mat<2, 4, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 4, T, Q> & operator+=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 4, T, Q> & operator+=(mat<2, 4, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 4, T, Q> & operator-=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 4, T, Q> & operator-=(mat<2, 4, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 4, T, Q> & operator*=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 4, T, Q> & operator/=(U s);
+
+		// -- Increment and decrement operators --
+
+		GLM_FUNC_DECL mat<2, 4, T, Q> & operator++ ();
+		GLM_FUNC_DECL mat<2, 4, T, Q> & operator-- ();
+		GLM_FUNC_DECL mat<2, 4, T, Q> operator++(int);
+		GLM_FUNC_DECL mat<2, 4, T, Q> operator--(int);
+	};
+
+	// -- Unary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 4, T, Q> operator+(mat<2, 4, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 4, T, Q> operator-(mat<2, 4, T, Q> const& m);
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 4, T, Q> operator+(mat<2, 4, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 4, T, Q> operator+(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 4, T, Q> operator-(mat<2, 4, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 4, T, Q> operator-(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 4, T, Q> operator*(mat<2, 4, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 4, T, Q> operator*(T scalar, mat<2, 4, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<2, 4, T, Q>::col_type operator*(mat<2, 4, T, Q> const& m, typename mat<2, 4, T, Q>::row_type const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<2, 4, T, Q>::row_type operator*(typename mat<2, 4, T, Q>::col_type const& v, mat<2, 4, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator*(mat<2, 4, T, Q> const& m1, mat<4, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 4, T, Q> operator*(mat<2, 4, T, Q> const& m1, mat<2, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 4, T, Q> operator*(mat<2, 4, T, Q> const& m1, mat<3, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 4, T, Q> operator/(mat<2, 4, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 4, T, Q> operator/(T scalar, mat<2, 4, T, Q> const& m);
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator==(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator!=(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat2x4.inl"
+#endif
diff --git a/engine/inc/glm/detail/type_mat2x4.inl b/engine/inc/glm/detail/type_mat2x4.inl
new file mode 100644
index 00000000..b6d2b9dd
--- /dev/null
+++ b/engine/inc/glm/detail/type_mat2x4.inl
@@ -0,0 +1,520 @@
+namespace glm
+{
+	// -- Constructors --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat()
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
+				: value{col_type(1, 0, 0, 0), col_type(0, 1, 0, 0)}
+#			endif
+		{
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
+				this->value[0] = col_type(1, 0, 0, 0);
+				this->value[1] = col_type(0, 1, 0, 0);
+#			endif
+		}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<2, 4, T, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{m[0], m[1]}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = m[0];
+			this->value[1] = m[1];
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(T s)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(s, 0, 0, 0), col_type(0, s, 0, 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(s, 0, 0, 0);
+			this->value[1] = col_type(0, s, 0, 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat
+	(
+		T x0, T y0, T z0, T w0,
+		T x1, T y1, T z1, T w1
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(x0, y0, z0, w0), col_type(x1, y1, z1, w1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x0, y0, z0, w0);
+			this->value[1] = col_type(x1, y1, z1, w1);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(col_type const& v0, col_type const& v1)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v0), col_type(v1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = v0;
+			this->value[1] = v1;
+#		endif
+	}
+
+	// -- Conversion constructors --
+
+	template<typename T, qualifier Q>
+	template<
+		typename X1, typename Y1, typename Z1, typename W1,
+		typename X2, typename Y2, typename Z2, typename W2>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat
+	(
+		X1 x1, Y1 y1, Z1 z1, W1 w1,
+		X2 x2, Y2 y2, Z2 z2, W2 w2
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{
+				col_type(x1, y1, z1, w1),
+				col_type(x2, y2, z2, w2)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x1, y1, z1, w1);
+			this->value[1] = col_type(x2, y2, z2, w2);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	template<typename V1, typename V2>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(vec<4, V1, Q> const& v1, vec<4, V2, Q> const& v2)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v1), col_type(v2)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(v1);
+			this->value[1] = col_type(v2);
+#		endif
+	}
+
+	// -- Matrix conversions --
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<2, 4, U, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<2, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0, 0);
+			this->value[1] = col_type(m[1], 0, 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<3, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<4, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<2, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<3, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0, 0);
+			this->value[1] = col_type(m[1], 0, 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<3, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<4, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0, 0);
+			this->value[1] = col_type(m[1], 0, 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<4, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+#		endif
+	}
+
+	// -- Accesses --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<2, 4, T, Q>::col_type & mat<2, 4, T, Q>::operator[](typename mat<2, 4, T, Q>::length_type i)
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<2, 4, T, Q>::col_type const& mat<2, 4, T, Q>::operator[](typename mat<2, 4, T, Q>::length_type i) const
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	// -- Unary updatable operators --
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator=(mat<2, 4, U, Q> const& m)
+	{
+		this->value[0] = m[0];
+		this->value[1] = m[1];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator+=(U s)
+	{
+		this->value[0] += s;
+		this->value[1] += s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator+=(mat<2, 4, U, Q> const& m)
+	{
+		this->value[0] += m[0];
+		this->value[1] += m[1];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator-=(U s)
+	{
+		this->value[0] -= s;
+		this->value[1] -= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator-=(mat<2, 4, U, Q> const& m)
+	{
+		this->value[0] -= m[0];
+		this->value[1] -= m[1];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator*=(U s)
+	{
+		this->value[0] *= s;
+		this->value[1] *= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> & mat<2, 4, T, Q>::operator/=(U s)
+	{
+		this->value[0] /= s;
+		this->value[1] /= s;
+		return *this;
+	}
+
+	// -- Increment and decrement operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator++()
+	{
+		++this->value[0];
+		++this->value[1];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator--()
+	{
+		--this->value[0];
+		--this->value[1];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> mat<2, 4, T, Q>::operator++(int)
+	{
+		mat<2, 4, T, Q> Result(*this);
+		++*this;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> mat<2, 4, T, Q>::operator--(int)
+	{
+		mat<2, 4, T, Q> Result(*this);
+		--*this;
+		return Result;
+	}
+
+	// -- Unary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator+(mat<2, 4, T, Q> const& m)
+	{
+		return m;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator-(mat<2, 4, T, Q> const& m)
+	{
+		return mat<2, 4, T, Q>(
+			-m[0],
+			-m[1]);
+	}
+
+	// -- Binary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator+(mat<2, 4, T, Q> const& m, T scalar)
+	{
+		return mat<2, 4, T, Q>(
+			m[0] + scalar,
+			m[1] + scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator+(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2)
+	{
+		return mat<2, 4, T, Q>(
+			m1[0] + m2[0],
+			m1[1] + m2[1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator-(mat<2, 4, T, Q> const& m, T scalar)
+	{
+		return mat<2, 4, T, Q>(
+			m[0] - scalar,
+			m[1] - scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator-(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2)
+	{
+		return mat<2, 4, T, Q>(
+			m1[0] - m2[0],
+			m1[1] - m2[1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator*(mat<2, 4, T, Q> const& m, T scalar)
+	{
+		return mat<2, 4, T, Q>(
+			m[0] * scalar,
+			m[1] * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator*(T scalar, mat<2, 4, T, Q> const& m)
+	{
+		return mat<2, 4, T, Q>(
+			m[0] * scalar,
+			m[1] * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<2, 4, T, Q>::col_type operator*(mat<2, 4, T, Q> const& m, typename mat<2, 4, T, Q>::row_type const& v)
+	{
+		return typename mat<2, 4, T, Q>::col_type(
+			m[0][0] * v.x + m[1][0] * v.y,
+			m[0][1] * v.x + m[1][1] * v.y,
+			m[0][2] * v.x + m[1][2] * v.y,
+			m[0][3] * v.x + m[1][3] * v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<2, 4, T, Q>::row_type operator*(typename mat<2, 4, T, Q>::col_type const& v, mat<2, 4, T, Q> const& m)
+	{
+		return typename mat<2, 4, T, Q>::row_type(
+			v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2] + v.w * m[0][3],
+			v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2] + v.w * m[1][3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator*(mat<2, 4, T, Q> const& m1, mat<4, 2, T, Q> const& m2)
+	{
+		T SrcA00 = m1[0][0];
+		T SrcA01 = m1[0][1];
+		T SrcA02 = m1[0][2];
+		T SrcA03 = m1[0][3];
+		T SrcA10 = m1[1][0];
+		T SrcA11 = m1[1][1];
+		T SrcA12 = m1[1][2];
+		T SrcA13 = m1[1][3];
+
+		T SrcB00 = m2[0][0];
+		T SrcB01 = m2[0][1];
+		T SrcB10 = m2[1][0];
+		T SrcB11 = m2[1][1];
+		T SrcB20 = m2[2][0];
+		T SrcB21 = m2[2][1];
+		T SrcB30 = m2[3][0];
+		T SrcB31 = m2[3][1];
+
+		mat<4, 4, T, Q> Result;
+		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01;
+		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01;
+		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01;
+		Result[0][3] = SrcA03 * SrcB00 + SrcA13 * SrcB01;
+		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11;
+		Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11;
+		Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11;
+		Result[1][3] = SrcA03 * SrcB10 + SrcA13 * SrcB11;
+		Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21;
+		Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21;
+		Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21;
+		Result[2][3] = SrcA03 * SrcB20 + SrcA13 * SrcB21;
+		Result[3][0] = SrcA00 * SrcB30 + SrcA10 * SrcB31;
+		Result[3][1] = SrcA01 * SrcB30 + SrcA11 * SrcB31;
+		Result[3][2] = SrcA02 * SrcB30 + SrcA12 * SrcB31;
+		Result[3][3] = SrcA03 * SrcB30 + SrcA13 * SrcB31;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator*(mat<2, 4, T, Q> const& m1, mat<2, 2, T, Q> const& m2)
+	{
+		return mat<2, 4, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
+			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1],
+			m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
+			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1],
+			m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator*(mat<2, 4, T, Q> const& m1, mat<3, 2, T, Q> const& m2)
+	{
+		return mat<3, 4, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
+			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1],
+			m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
+			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1],
+			m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1],
+			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1],
+			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1],
+			m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1],
+			m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator/(mat<2, 4, T, Q> const& m, T scalar)
+	{
+		return mat<2, 4, T, Q>(
+			m[0] / scalar,
+			m[1] / scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator/(T scalar, mat<2, 4, T, Q> const& m)
+	{
+		return mat<2, 4, T, Q>(
+			scalar / m[0],
+			scalar / m[1]);
+	}
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator==(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator!=(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]);
+	}
+} //namespace glm
diff --git a/engine/inc/glm/detail/type_mat3x2.hpp b/engine/inc/glm/detail/type_mat3x2.hpp
new file mode 100644
index 00000000..e1665813
--- /dev/null
+++ b/engine/inc/glm/detail/type_mat3x2.hpp
@@ -0,0 +1,167 @@
+/// @ref core
+/// @file glm/detail/type_mat3x2.hpp
+
+#pragma once
+
+#include "type_vec2.hpp"
+#include "type_vec3.hpp"
+#include <limits>
+#include <cstddef>
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	struct mat<3, 2, T, Q>
+	{
+		typedef vec<2, T, Q> col_type;
+		typedef vec<3, T, Q> row_type;
+		typedef mat<3, 2, T, Q> type;
+		typedef mat<2, 3, T, Q> transpose_type;
+		typedef T value_type;
+
+	private:
+		col_type value[3];
+
+	public:
+		// -- Accesses --
+
+		typedef length_t length_type;
+		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 3; }
+
+		GLM_FUNC_DECL col_type & operator[](length_type i);
+		GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const;
+
+		// -- Constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT;
+		template<qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<3, 2, T, P> const& m);
+
+		GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			T x0, T y0,
+			T x1, T y1,
+			T x2, T y2);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			col_type const& v0,
+			col_type const& v1,
+			col_type const& v2);
+
+		// -- Conversions --
+
+		template<
+			typename X1, typename Y1,
+			typename X2, typename Y2,
+			typename X3, typename Y3>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			X1 x1, Y1 y1,
+			X2 x2, Y2 y2,
+			X3 x3, Y3 y3);
+
+		template<typename V1, typename V2, typename V3>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			vec<2, V1, Q> const& v1,
+			vec<2, V2, Q> const& v2,
+			vec<2, V3, Q> const& v3);
+
+		// -- Matrix conversions --
+
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, U, P> const& m);
+
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x);
+
+		// -- Unary arithmetic operators --
+
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 2, T, Q> & operator=(mat<3, 2, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 2, T, Q> & operator+=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 2, T, Q> & operator+=(mat<3, 2, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 2, T, Q> & operator-=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 2, T, Q> & operator-=(mat<3, 2, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 2, T, Q> & operator*=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 2, T, Q> & operator/=(U s);
+
+		// -- Increment and decrement operators --
+
+		GLM_FUNC_DECL mat<3, 2, T, Q> & operator++ ();
+		GLM_FUNC_DECL mat<3, 2, T, Q> & operator-- ();
+		GLM_FUNC_DECL mat<3, 2, T, Q> operator++(int);
+		GLM_FUNC_DECL mat<3, 2, T, Q> operator--(int);
+	};
+
+	// -- Unary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 2, T, Q> operator+(mat<3, 2, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 2, T, Q> operator-(mat<3, 2, T, Q> const& m);
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 2, T, Q> operator+(mat<3, 2, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 2, T, Q> operator+(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 2, T, Q> operator-(mat<3, 2, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 2, T, Q> operator-(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 2, T, Q> operator*(mat<3, 2, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 2, T, Q> operator*(T scalar, mat<3, 2, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<3, 2, T, Q>::col_type operator*(mat<3, 2, T, Q> const& m, typename mat<3, 2, T, Q>::row_type const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<3, 2, T, Q>::row_type operator*(typename mat<3, 2, T, Q>::col_type const& v, mat<3, 2, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator*(mat<3, 2, T, Q> const& m1, mat<2, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 2, T, Q> operator*(mat<3, 2, T, Q> const& m1, mat<3, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 2, T, Q> operator*(mat<3, 2, T, Q> const& m1, mat<4, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 2, T, Q> operator/(mat<3, 2, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 2, T, Q> operator/(T scalar, mat<3, 2, T, Q> const& m);
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator==(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator!=(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2);
+
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat3x2.inl"
+#endif
diff --git a/engine/inc/glm/detail/type_mat3x2.inl b/engine/inc/glm/detail/type_mat3x2.inl
new file mode 100644
index 00000000..b4b948b7
--- /dev/null
+++ b/engine/inc/glm/detail/type_mat3x2.inl
@@ -0,0 +1,532 @@
+namespace glm
+{
+	// -- Constructors --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat()
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
+				: value{col_type(1, 0), col_type(0, 1), col_type(0, 0)}
+#			endif
+		{
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
+				this->value[0] = col_type(1, 0);
+				this->value[1] = col_type(0, 1);
+				this->value[2] = col_type(0, 0);
+#			endif
+		}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<3, 2, T, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = m[0];
+			this->value[1] = m[1];
+			this->value[2] = m[2];
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(T s)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(s, 0), col_type(0, s), col_type(0, 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(s, 0);
+			this->value[1] = col_type(0, s);
+			this->value[2] = col_type(0, 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat
+	(
+		T x0, T y0,
+		T x1, T y1,
+		T x2, T y2
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(x0, y0), col_type(x1, y1), col_type(x2, y2)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x0, y0);
+			this->value[1] = col_type(x1, y1);
+			this->value[2] = col_type(x2, y2);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v0), col_type(v1), col_type(v2)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = v0;
+			this->value[1] = v1;
+			this->value[2] = v2;
+#		endif
+	}
+
+	// -- Conversion constructors --
+
+	template<typename T, qualifier Q>
+	template<
+		typename X0, typename Y0,
+		typename X1, typename Y1,
+		typename X2, typename Y2>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat
+	(
+		X0 x0, Y0 y0,
+		X1 x1, Y1 y1,
+		X2 x2, Y2 y2
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(x0, y0), col_type(x1, y1), col_type(x2, y2)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x0, y0);
+			this->value[1] = col_type(x1, y1);
+			this->value[2] = col_type(x2, y2);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	template<typename V0, typename V1, typename V2>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(vec<2, V0, Q> const& v0, vec<2, V1, Q> const& v1, vec<2, V2, Q> const& v2)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v0), col_type(v1), col_type(v2)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(v0);
+			this->value[1] = col_type(v1);
+			this->value[2] = col_type(v2);
+#		endif
+	}
+
+	// -- Matrix conversions --
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<3, 2, U, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<2, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = m[0];
+			this->value[1] = m[1];
+			this->value[2] = col_type(0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<3, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<4, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<2, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<2, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<3, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<4, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = m[0];
+			this->value[1] = m[1];
+			this->value[2] = m[2];
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<4, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+#		endif
+	}
+
+	// -- Accesses --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<3, 2, T, Q>::col_type & mat<3, 2, T, Q>::operator[](typename mat<3, 2, T, Q>::length_type i)
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<3, 2, T, Q>::col_type const& mat<3, 2, T, Q>::operator[](typename mat<3, 2, T, Q>::length_type i) const
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	// -- Unary updatable operators --
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator=(mat<3, 2, U, Q> const& m)
+	{
+		this->value[0] = m[0];
+		this->value[1] = m[1];
+		this->value[2] = m[2];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator+=(U s)
+	{
+		this->value[0] += s;
+		this->value[1] += s;
+		this->value[2] += s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator+=(mat<3, 2, U, Q> const& m)
+	{
+		this->value[0] += m[0];
+		this->value[1] += m[1];
+		this->value[2] += m[2];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator-=(U s)
+	{
+		this->value[0] -= s;
+		this->value[1] -= s;
+		this->value[2] -= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator-=(mat<3, 2, U, Q> const& m)
+	{
+		this->value[0] -= m[0];
+		this->value[1] -= m[1];
+		this->value[2] -= m[2];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator*=(U s)
+	{
+		this->value[0] *= s;
+		this->value[1] *= s;
+		this->value[2] *= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> & mat<3, 2, T, Q>::operator/=(U s)
+	{
+		this->value[0] /= s;
+		this->value[1] /= s;
+		this->value[2] /= s;
+		return *this;
+	}
+
+	// -- Increment and decrement operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator++()
+	{
+		++this->value[0];
+		++this->value[1];
+		++this->value[2];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator--()
+	{
+		--this->value[0];
+		--this->value[1];
+		--this->value[2];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> mat<3, 2, T, Q>::operator++(int)
+	{
+		mat<3, 2, T, Q> Result(*this);
+		++*this;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> mat<3, 2, T, Q>::operator--(int)
+	{
+		mat<3, 2, T, Q> Result(*this);
+		--*this;
+		return Result;
+	}
+
+	// -- Unary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator+(mat<3, 2, T, Q> const& m)
+	{
+		return m;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator-(mat<3, 2, T, Q> const& m)
+	{
+		return mat<3, 2, T, Q>(
+			-m[0],
+			-m[1],
+			-m[2]);
+	}
+
+	// -- Binary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator+(mat<3, 2, T, Q> const& m, T scalar)
+	{
+		return mat<3, 2, T, Q>(
+			m[0] + scalar,
+			m[1] + scalar,
+			m[2] + scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator+(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2)
+	{
+		return mat<3, 2, T, Q>(
+			m1[0] + m2[0],
+			m1[1] + m2[1],
+			m1[2] + m2[2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator-(mat<3, 2, T, Q> const& m, T scalar)
+	{
+		return mat<3, 2, T, Q>(
+			m[0] - scalar,
+			m[1] - scalar,
+			m[2] - scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator-(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2)
+	{
+		return mat<3, 2, T, Q>(
+			m1[0] - m2[0],
+			m1[1] - m2[1],
+			m1[2] - m2[2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator*(mat<3, 2, T, Q> const& m, T scalar)
+	{
+		return mat<3, 2, T, Q>(
+			m[0] * scalar,
+			m[1] * scalar,
+			m[2] * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator*(T scalar, mat<3, 2, T, Q> const& m)
+	{
+		return mat<3, 2, T, Q>(
+			m[0] * scalar,
+			m[1] * scalar,
+			m[2] * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<3, 2, T, Q>::col_type operator*(mat<3, 2, T, Q> const& m, typename mat<3, 2, T, Q>::row_type const& v)
+	{
+		return typename mat<3, 2, T, Q>::col_type(
+			m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z,
+			m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<3, 2, T, Q>::row_type operator*(typename mat<3, 2, T, Q>::col_type const& v, mat<3, 2, T, Q> const& m)
+	{
+		return typename mat<3, 2, T, Q>::row_type(
+			v.x * m[0][0] + v.y * m[0][1],
+			v.x * m[1][0] + v.y * m[1][1],
+			v.x * m[2][0] + v.y * m[2][1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator*(mat<3, 2, T, Q> const& m1, mat<2, 3, T, Q> const& m2)
+	{
+		const T SrcA00 = m1[0][0];
+		const T SrcA01 = m1[0][1];
+		const T SrcA10 = m1[1][0];
+		const T SrcA11 = m1[1][1];
+		const T SrcA20 = m1[2][0];
+		const T SrcA21 = m1[2][1];
+
+		const T SrcB00 = m2[0][0];
+		const T SrcB01 = m2[0][1];
+		const T SrcB02 = m2[0][2];
+		const T SrcB10 = m2[1][0];
+		const T SrcB11 = m2[1][1];
+		const T SrcB12 = m2[1][2];
+
+		mat<2, 2, T, Q> Result;
+		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02;
+		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02;
+		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12;
+		Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator*(mat<3, 2, T, Q> const& m1, mat<3, 3, T, Q> const& m2)
+	{
+		return mat<3, 2, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
+			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2],
+			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator*(mat<3, 2, T, Q> const& m1, mat<4, 3, T, Q> const& m2)
+	{
+		return mat<4, 2, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
+			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2],
+			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2],
+			m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2],
+			m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator/(mat<3, 2, T, Q> const& m, T scalar)
+	{
+		return mat<3, 2, T, Q>(
+			m[0] / scalar,
+			m[1] / scalar,
+			m[2] / scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator/(T scalar, mat<3, 2, T, Q> const& m)
+	{
+		return mat<3, 2, T, Q>(
+			scalar / m[0],
+			scalar / m[1],
+			scalar / m[2]);
+	}
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator==(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator!=(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
+	}
+} //namespace glm
diff --git a/engine/inc/glm/detail/type_mat3x3.hpp b/engine/inc/glm/detail/type_mat3x3.hpp
new file mode 100644
index 00000000..3174872e
--- /dev/null
+++ b/engine/inc/glm/detail/type_mat3x3.hpp
@@ -0,0 +1,184 @@
+/// @ref core
+/// @file glm/detail/type_mat3x3.hpp
+
+#pragma once
+
+#include "type_vec3.hpp"
+#include <limits>
+#include <cstddef>
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	struct mat<3, 3, T, Q>
+	{
+		typedef vec<3, T, Q> col_type;
+		typedef vec<3, T, Q> row_type;
+		typedef mat<3, 3, T, Q> type;
+		typedef mat<3, 3, T, Q> transpose_type;
+		typedef T value_type;
+
+	private:
+		col_type value[3];
+
+	public:
+		// -- Accesses --
+
+		typedef length_t length_type;
+		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 3; }
+
+		GLM_FUNC_DECL col_type & operator[](length_type i);
+		GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const;
+
+		// -- Constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT;
+		template<qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<3, 3, T, P> const& m);
+
+		GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			T x0, T y0, T z0,
+			T x1, T y1, T z1,
+			T x2, T y2, T z2);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			col_type const& v0,
+			col_type const& v1,
+			col_type const& v2);
+
+		// -- Conversions --
+
+		template<
+			typename X1, typename Y1, typename Z1,
+			typename X2, typename Y2, typename Z2,
+			typename X3, typename Y3, typename Z3>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			X1 x1, Y1 y1, Z1 z1,
+			X2 x2, Y2 y2, Z2 z2,
+			X3 x3, Y3 y3, Z3 z3);
+
+		template<typename V1, typename V2, typename V3>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			vec<3, V1, Q> const& v1,
+			vec<3, V2, Q> const& v2,
+			vec<3, V3, Q> const& v3);
+
+		// -- Matrix conversions --
+
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, U, P> const& m);
+
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x);
+
+		// -- Unary arithmetic operators --
+
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 3, T, Q> & operator=(mat<3, 3, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 3, T, Q> & operator+=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 3, T, Q> & operator+=(mat<3, 3, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 3, T, Q> & operator-=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 3, T, Q> & operator-=(mat<3, 3, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 3, T, Q> & operator*=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 3, T, Q> & operator*=(mat<3, 3, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 3, T, Q> & operator/=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 3, T, Q> & operator/=(mat<3, 3, U, Q> const& m);
+
+		// -- Increment and decrement operators --
+
+		GLM_FUNC_DECL mat<3, 3, T, Q> & operator++();
+		GLM_FUNC_DECL mat<3, 3, T, Q> & operator--();
+		GLM_FUNC_DECL mat<3, 3, T, Q> operator++(int);
+		GLM_FUNC_DECL mat<3, 3, T, Q> operator--(int);
+	};
+
+	// -- Unary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator+(mat<3, 3, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator-(mat<3, 3, T, Q> const& m);
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator+(mat<3, 3, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator+(T scalar, mat<3, 3, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator+(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator-(mat<3, 3, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator-(T scalar, mat<3, 3, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator-(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator*(mat<3, 3, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator*(T scalar, mat<3, 3, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<3, 3, T, Q>::col_type operator*(mat<3, 3, T, Q> const& m, typename mat<3, 3, T, Q>::row_type const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<3, 3, T, Q>::row_type operator*(typename mat<3, 3, T, Q>::col_type const& v, mat<3, 3, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator*(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 3, T, Q> operator*(mat<3, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 3, T, Q> operator*(mat<3, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator/(mat<3, 3, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator/(T scalar, mat<3, 3, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<3, 3, T, Q>::col_type operator/(mat<3, 3, T, Q> const& m, typename mat<3, 3, T, Q>::row_type const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<3, 3, T, Q>::row_type operator/(typename mat<3, 3, T, Q>::col_type const& v, mat<3, 3, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator/(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2);
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR bool operator==(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator!=(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat3x3.inl"
+#endif
diff --git a/engine/inc/glm/detail/type_mat3x3.inl b/engine/inc/glm/detail/type_mat3x3.inl
new file mode 100644
index 00000000..1ddaf99d
--- /dev/null
+++ b/engine/inc/glm/detail/type_mat3x3.inl
@@ -0,0 +1,601 @@
+#include "../matrix.hpp"
+
+namespace glm
+{
+	// -- Constructors --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat()
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
+				: value{col_type(1, 0, 0), col_type(0, 1, 0), col_type(0, 0, 1)}
+#			endif
+		{
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
+			this->value[0] = col_type(1, 0, 0);
+				this->value[1] = col_type(0, 1, 0);
+				this->value[2] = col_type(0, 0, 1);
+#			endif
+		}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<3, 3, T, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(T s)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(s, 0, 0), col_type(0, s, 0), col_type(0, 0, s)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(s, 0, 0);
+			this->value[1] = col_type(0, s, 0);
+			this->value[2] = col_type(0, 0, s);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat
+	(
+		T x0, T y0, T z0,
+		T x1, T y1, T z1,
+		T x2, T y2, T z2
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(x0, y0, z0), col_type(x1, y1, z1), col_type(x2, y2, z2)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x0, y0, z0);
+			this->value[1] = col_type(x1, y1, z1);
+			this->value[2] = col_type(x2, y2, z2);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v0), col_type(v1), col_type(v2)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(v0);
+			this->value[1] = col_type(v1);
+			this->value[2] = col_type(v2);
+#		endif
+	}
+
+	// -- Conversion constructors --
+
+	template<typename T, qualifier Q>
+	template<
+		typename X1, typename Y1, typename Z1,
+		typename X2, typename Y2, typename Z2,
+		typename X3, typename Y3, typename Z3>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat
+	(
+		X1 x1, Y1 y1, Z1 z1,
+		X2 x2, Y2 y2, Z2 z2,
+		X3 x3, Y3 y3, Z3 z3
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(x1, y1, z1), col_type(x2, y2, z2), col_type(x3, y3, z3)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x1, y1, z1);
+			this->value[1] = col_type(x2, y2, z2);
+			this->value[2] = col_type(x3, y3, z3);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	template<typename V1, typename V2, typename V3>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(vec<3, V1, Q> const& v1, vec<3, V2, Q> const& v2, vec<3, V3, Q> const& v3)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v1), col_type(v2), col_type(v3)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(v1);
+			this->value[1] = col_type(v2);
+			this->value[2] = col_type(v3);
+#		endif
+	}
+
+	// -- Matrix conversions --
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<3, 3, U, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<2, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(0, 0, 1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+			this->value[2] = col_type(0, 0, 1);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<4, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<2, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(0, 0, 1);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<3, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+			this->value[2] = col_type(m[2], 1);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<2, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(0, 0, 1);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<4, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+			this->value[2] = col_type(m[2], 1);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<3, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<4, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+#		endif
+	}
+
+	// -- Accesses --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<3, 3, T, Q>::col_type & mat<3, 3, T, Q>::operator[](typename mat<3, 3, T, Q>::length_type i)
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<3, 3, T, Q>::col_type const& mat<3, 3, T, Q>::operator[](typename mat<3, 3, T, Q>::length_type i) const
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	// -- Unary updatable operators --
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator=(mat<3, 3, U, Q> const& m)
+	{
+		this->value[0] = m[0];
+		this->value[1] = m[1];
+		this->value[2] = m[2];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator+=(U s)
+	{
+		this->value[0] += s;
+		this->value[1] += s;
+		this->value[2] += s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator+=(mat<3, 3, U, Q> const& m)
+	{
+		this->value[0] += m[0];
+		this->value[1] += m[1];
+		this->value[2] += m[2];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator-=(U s)
+	{
+		this->value[0] -= s;
+		this->value[1] -= s;
+		this->value[2] -= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator-=(mat<3, 3, U, Q> const& m)
+	{
+		this->value[0] -= m[0];
+		this->value[1] -= m[1];
+		this->value[2] -= m[2];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator*=(U s)
+	{
+		this->value[0] *= s;
+		this->value[1] *= s;
+		this->value[2] *= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator*=(mat<3, 3, U, Q> const& m)
+	{
+		return (*this = *this * m);
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator/=(U s)
+	{
+		this->value[0] /= s;
+		this->value[1] /= s;
+		this->value[2] /= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator/=(mat<3, 3, U, Q> const& m)
+	{
+		return *this *= inverse(m);
+	}
+
+	// -- Increment and decrement operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator++()
+	{
+		++this->value[0];
+		++this->value[1];
+		++this->value[2];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator--()
+	{
+		--this->value[0];
+		--this->value[1];
+		--this->value[2];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> mat<3, 3, T, Q>::operator++(int)
+	{
+		mat<3, 3, T, Q> Result(*this);
+		++*this;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> mat<3, 3, T, Q>::operator--(int)
+	{
+		mat<3, 3, T, Q> Result(*this);
+		--*this;
+		return Result;
+	}
+
+	// -- Unary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator+(mat<3, 3, T, Q> const& m)
+	{
+		return m;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator-(mat<3, 3, T, Q> const& m)
+	{
+		return mat<3, 3, T, Q>(
+			-m[0],
+			-m[1],
+			-m[2]);
+	}
+
+	// -- Binary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator+(mat<3, 3, T, Q> const& m, T scalar)
+	{
+		return mat<3, 3, T, Q>(
+			m[0] + scalar,
+			m[1] + scalar,
+			m[2] + scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator+(T scalar, mat<3, 3, T, Q> const& m)
+	{
+		return mat<3, 3, T, Q>(
+			m[0] + scalar,
+			m[1] + scalar,
+			m[2] + scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator+(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2)
+	{
+		return mat<3, 3, T, Q>(
+			m1[0] + m2[0],
+			m1[1] + m2[1],
+			m1[2] + m2[2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator-(mat<3, 3, T, Q> const& m, T scalar)
+	{
+		return mat<3, 3, T, Q>(
+			m[0] - scalar,
+			m[1] - scalar,
+			m[2] - scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator-(T scalar, mat<3, 3, T, Q> const& m)
+	{
+		return mat<3, 3, T, Q>(
+			scalar - m[0],
+			scalar - m[1],
+			scalar - m[2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator-(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2)
+	{
+		return mat<3, 3, T, Q>(
+			m1[0] - m2[0],
+			m1[1] - m2[1],
+			m1[2] - m2[2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator*(mat<3, 3, T, Q> const& m, T scalar)
+	{
+		return mat<3, 3, T, Q>(
+			m[0] * scalar,
+			m[1] * scalar,
+			m[2] * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator*(T scalar, mat<3, 3, T, Q> const& m)
+	{
+		return mat<3, 3, T, Q>(
+			m[0] * scalar,
+			m[1] * scalar,
+			m[2] * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<3, 3, T, Q>::col_type operator*(mat<3, 3, T, Q> const& m, typename mat<3, 3, T, Q>::row_type const& v)
+	{
+		return typename mat<3, 3, T, Q>::col_type(
+			m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z,
+			m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z,
+			m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<3, 3, T, Q>::row_type operator*(typename mat<3, 3, T, Q>::col_type const& v, mat<3, 3, T, Q> const& m)
+	{
+		return typename mat<3, 3, T, Q>::row_type(
+			m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z,
+			m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z,
+			m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator*(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2)
+	{
+		T const SrcA00 = m1[0][0];
+		T const SrcA01 = m1[0][1];
+		T const SrcA02 = m1[0][2];
+		T const SrcA10 = m1[1][0];
+		T const SrcA11 = m1[1][1];
+		T const SrcA12 = m1[1][2];
+		T const SrcA20 = m1[2][0];
+		T const SrcA21 = m1[2][1];
+		T const SrcA22 = m1[2][2];
+
+		T const SrcB00 = m2[0][0];
+		T const SrcB01 = m2[0][1];
+		T const SrcB02 = m2[0][2];
+		T const SrcB10 = m2[1][0];
+		T const SrcB11 = m2[1][1];
+		T const SrcB12 = m2[1][2];
+		T const SrcB20 = m2[2][0];
+		T const SrcB21 = m2[2][1];
+		T const SrcB22 = m2[2][2];
+
+		mat<3, 3, T, Q> Result;
+		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02;
+		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02;
+		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02;
+		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12;
+		Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12;
+		Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12;
+		Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22;
+		Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22;
+		Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator*(mat<3, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2)
+	{
+		return mat<2, 3, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
+			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
+			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator*(mat<3, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2)
+	{
+		return mat<4, 3, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
+			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
+			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2],
+			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2],
+			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2],
+			m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2],
+			m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2],
+			m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2],
+			m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1] + m1[2][2] * m2[3][2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator/(mat<3, 3, T, Q> const& m,	T scalar)
+	{
+		return mat<3, 3, T, Q>(
+			m[0] / scalar,
+			m[1] / scalar,
+			m[2] / scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator/(T scalar, mat<3, 3, T, Q> const& m)
+	{
+		return mat<3, 3, T, Q>(
+			scalar / m[0],
+			scalar / m[1],
+			scalar / m[2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<3, 3, T, Q>::col_type operator/(mat<3, 3, T, Q> const& m, typename mat<3, 3, T, Q>::row_type const& v)
+	{
+		return  inverse(m) * v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<3, 3, T, Q>::row_type operator/(typename mat<3, 3, T, Q>::col_type const& v, mat<3, 3, T, Q> const& m)
+	{
+		return v * inverse(m);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator/(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2)
+	{
+		mat<3, 3, T, Q> m1_copy(m1);
+		return m1_copy /= m2;
+	}
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator==(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator!=(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
+	}
+} //namespace glm
diff --git a/engine/inc/glm/detail/type_mat3x4.hpp b/engine/inc/glm/detail/type_mat3x4.hpp
new file mode 100644
index 00000000..6e40b903
--- /dev/null
+++ b/engine/inc/glm/detail/type_mat3x4.hpp
@@ -0,0 +1,166 @@
+/// @ref core
+/// @file glm/detail/type_mat3x4.hpp
+
+#pragma once
+
+#include "type_vec3.hpp"
+#include "type_vec4.hpp"
+#include <limits>
+#include <cstddef>
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	struct mat<3, 4, T, Q>
+	{
+		typedef vec<4, T, Q> col_type;
+		typedef vec<3, T, Q> row_type;
+		typedef mat<3, 4, T, Q> type;
+		typedef mat<4, 3, T, Q> transpose_type;
+		typedef T value_type;
+
+	private:
+		col_type value[3];
+
+	public:
+		// -- Accesses --
+
+		typedef length_t length_type;
+		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 3; }
+
+		GLM_FUNC_DECL col_type & operator[](length_type i);
+		GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const;
+
+		// -- Constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT;
+		template<qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<3, 4, T, P> const& m);
+
+		GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			T x0, T y0, T z0, T w0,
+			T x1, T y1, T z1, T w1,
+			T x2, T y2, T z2, T w2);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			col_type const& v0,
+			col_type const& v1,
+			col_type const& v2);
+
+		// -- Conversions --
+
+		template<
+			typename X1, typename Y1, typename Z1, typename W1,
+			typename X2, typename Y2, typename Z2, typename W2,
+			typename X3, typename Y3, typename Z3, typename W3>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			X1 x1, Y1 y1, Z1 z1, W1 w1,
+			X2 x2, Y2 y2, Z2 z2, W2 w2,
+			X3 x3, Y3 y3, Z3 z3, W3 w3);
+
+		template<typename V1, typename V2, typename V3>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			vec<4, V1, Q> const& v1,
+			vec<4, V2, Q> const& v2,
+			vec<4, V3, Q> const& v3);
+
+		// -- Matrix conversions --
+
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, U, P> const& m);
+
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x);
+
+		// -- Unary arithmetic operators --
+
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 4, T, Q> & operator=(mat<3, 4, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 4, T, Q> & operator+=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 4, T, Q> & operator+=(mat<3, 4, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 4, T, Q> & operator-=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 4, T, Q> & operator-=(mat<3, 4, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 4, T, Q> & operator*=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 4, T, Q> & operator/=(U s);
+
+		// -- Increment and decrement operators --
+
+		GLM_FUNC_DECL mat<3, 4, T, Q> & operator++();
+		GLM_FUNC_DECL mat<3, 4, T, Q> & operator--();
+		GLM_FUNC_DECL mat<3, 4, T, Q> operator++(int);
+		GLM_FUNC_DECL mat<3, 4, T, Q> operator--(int);
+	};
+
+	// -- Unary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m);
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 4, T, Q> operator*(mat<3, 4, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 4, T, Q> operator*(T scalar, mat<3, 4, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<3, 4, T, Q>::col_type operator*(mat<3, 4, T, Q> const& m, typename mat<3, 4, T, Q>::row_type const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<3, 4, T, Q>::row_type operator*(typename mat<3, 4, T, Q>::col_type const& v, mat<3, 4, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1,	mat<4, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1, mat<2, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1,	mat<3, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 4, T, Q> operator/(mat<3, 4, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 4, T, Q> operator/(T scalar, mat<3, 4, T, Q> const& m);
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator==(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator!=(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat3x4.inl"
+#endif
diff --git a/engine/inc/glm/detail/type_mat3x4.inl b/engine/inc/glm/detail/type_mat3x4.inl
new file mode 100644
index 00000000..6ee416cf
--- /dev/null
+++ b/engine/inc/glm/detail/type_mat3x4.inl
@@ -0,0 +1,578 @@
+namespace glm
+{
+	// -- Constructors --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat()
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
+				: value{col_type(1, 0, 0, 0), col_type(0, 1, 0, 0), col_type(0, 0, 1, 0)}
+#			endif
+		{
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
+				this->value[0] = col_type(1, 0, 0, 0);
+				this->value[1] = col_type(0, 1, 0, 0);
+				this->value[2] = col_type(0, 0, 1, 0);
+#			endif
+		}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<3, 4, T, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = m[0];
+			this->value[1] = m[1];
+			this->value[2] = m[2];
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(T s)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(s, 0, 0, 0), col_type(0, s, 0, 0), col_type(0, 0, s, 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(s, 0, 0, 0);
+			this->value[1] = col_type(0, s, 0, 0);
+			this->value[2] = col_type(0, 0, s, 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat
+	(
+		T x0, T y0, T z0, T w0,
+		T x1, T y1, T z1, T w1,
+		T x2, T y2, T z2, T w2
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{
+				col_type(x0, y0, z0, w0),
+				col_type(x1, y1, z1, w1),
+				col_type(x2, y2, z2, w2)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x0, y0, z0, w0);
+			this->value[1] = col_type(x1, y1, z1, w1);
+			this->value[2] = col_type(x2, y2, z2, w2);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v0), col_type(v1), col_type(v2)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = v0;
+			this->value[1] = v1;
+			this->value[2] = v2;
+#		endif
+	}
+
+	// -- Conversion constructors --
+
+	template<typename T, qualifier Q>
+	template<
+		typename X0, typename Y0, typename Z0, typename W0,
+		typename X1, typename Y1, typename Z1, typename W1,
+		typename X2, typename Y2, typename Z2, typename W2>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat
+	(
+		X0 x0, Y0 y0, Z0 z0, W0 w0,
+		X1 x1, Y1 y1, Z1 z1, W1 w1,
+		X2 x2, Y2 y2, Z2 z2, W2 w2
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{
+				col_type(x0, y0, z0, w0),
+				col_type(x1, y1, z1, w1),
+				col_type(x2, y2, z2, w2)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x0, y0, z0, w0);
+			this->value[1] = col_type(x1, y1, z1, w1);
+			this->value[2] = col_type(x2, y2, z2, w2);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	template<typename V1, typename V2, typename V3>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(vec<4, V1, Q> const& v0, vec<4, V2, Q> const& v1, vec<4, V3, Q> const& v2)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v0), col_type(v1), col_type(v2)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(v0);
+			this->value[1] = col_type(v1);
+			this->value[2] = col_type(v2);
+#		endif
+	}
+
+	// -- Matrix conversions --
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<3, 4, U, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<2, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(0, 0, 1, 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0, 0);
+			this->value[1] = col_type(m[1], 0, 0);
+			this->value[2] = col_type(0, 0, 1, 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<3, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+			this->value[2] = col_type(m[2], 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<4, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<2, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(0, 0, 1, 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+			this->value[2] = col_type(0, 0, 1, 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<3, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(m[2], 1, 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0, 0);
+			this->value[1] = col_type(m[1], 0, 0);
+			this->value[2] = col_type(m[2], 1, 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<2, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1, 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(0, 0, 1, 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<4, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(m[2], 1, 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0, 0);
+			this->value[1] = col_type(m[1], 0, 0);
+			this->value[2] = col_type(m[2], 1, 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<4, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+			this->value[2] = col_type(m[2], 0);
+#		endif
+	}
+
+	// -- Accesses --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<3, 4, T, Q>::col_type & mat<3, 4, T, Q>::operator[](typename mat<3, 4, T, Q>::length_type i)
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<3, 4, T, Q>::col_type const& mat<3, 4, T, Q>::operator[](typename mat<3, 4, T, Q>::length_type i) const
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	// -- Unary updatable operators --
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator=(mat<3, 4, U, Q> const& m)
+	{
+		this->value[0] = m[0];
+		this->value[1] = m[1];
+		this->value[2] = m[2];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator+=(U s)
+	{
+		this->value[0] += s;
+		this->value[1] += s;
+		this->value[2] += s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator+=(mat<3, 4, U, Q> const& m)
+	{
+		this->value[0] += m[0];
+		this->value[1] += m[1];
+		this->value[2] += m[2];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator-=(U s)
+	{
+		this->value[0] -= s;
+		this->value[1] -= s;
+		this->value[2] -= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator-=(mat<3, 4, U, Q> const& m)
+	{
+		this->value[0] -= m[0];
+		this->value[1] -= m[1];
+		this->value[2] -= m[2];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator*=(U s)
+	{
+		this->value[0] *= s;
+		this->value[1] *= s;
+		this->value[2] *= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> & mat<3, 4, T, Q>::operator/=(U s)
+	{
+		this->value[0] /= s;
+		this->value[1] /= s;
+		this->value[2] /= s;
+		return *this;
+	}
+
+	// -- Increment and decrement operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator++()
+	{
+		++this->value[0];
+		++this->value[1];
+		++this->value[2];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator--()
+	{
+		--this->value[0];
+		--this->value[1];
+		--this->value[2];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> mat<3, 4, T, Q>::operator++(int)
+	{
+		mat<3, 4, T, Q> Result(*this);
+		++*this;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> mat<3, 4, T, Q>::operator--(int)
+	{
+		mat<3, 4, T, Q> Result(*this);
+		--*this;
+		return Result;
+	}
+
+	// -- Unary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m)
+	{
+		return m;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m)
+	{
+		return mat<3, 4, T, Q>(
+			-m[0],
+			-m[1],
+			-m[2]);
+	}
+
+	// -- Binary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m, T scalar)
+	{
+		return mat<3, 4, T, Q>(
+			m[0] + scalar,
+			m[1] + scalar,
+			m[2] + scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2)
+	{
+		return mat<3, 4, T, Q>(
+			m1[0] + m2[0],
+			m1[1] + m2[1],
+			m1[2] + m2[2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m,	T scalar)
+	{
+		return mat<3, 4, T, Q>(
+			m[0] - scalar,
+			m[1] - scalar,
+			m[2] - scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2)
+	{
+		return mat<3, 4, T, Q>(
+			m1[0] - m2[0],
+			m1[1] - m2[1],
+			m1[2] - m2[2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator*(mat<3, 4, T, Q> const& m, T scalar)
+	{
+		return mat<3, 4, T, Q>(
+			m[0] * scalar,
+			m[1] * scalar,
+			m[2] * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator*(T scalar, mat<3, 4, T, Q> const& m)
+	{
+		return mat<3, 4, T, Q>(
+			m[0] * scalar,
+			m[1] * scalar,
+			m[2] * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<3, 4, T, Q>::col_type operator*
+	(
+		mat<3, 4, T, Q> const& m,
+		typename mat<3, 4, T, Q>::row_type const& v
+	)
+	{
+		return typename mat<3, 4, T, Q>::col_type(
+			m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z,
+			m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z,
+			m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z,
+			m[0][3] * v.x + m[1][3] * v.y + m[2][3] * v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<3, 4, T, Q>::row_type operator*
+	(
+		typename mat<3, 4, T, Q>::col_type const& v,
+		mat<3, 4, T, Q> const& m
+	)
+	{
+		return typename mat<3, 4, T, Q>::row_type(
+			v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2] + v.w * m[0][3],
+			v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2] + v.w * m[1][3],
+			v.x * m[2][0] + v.y * m[2][1] + v.z * m[2][2] + v.w * m[2][3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1, mat<4, 3, T, Q> const& m2)
+	{
+		const T SrcA00 = m1[0][0];
+		const T SrcA01 = m1[0][1];
+		const T SrcA02 = m1[0][2];
+		const T SrcA03 = m1[0][3];
+		const T SrcA10 = m1[1][0];
+		const T SrcA11 = m1[1][1];
+		const T SrcA12 = m1[1][2];
+		const T SrcA13 = m1[1][3];
+		const T SrcA20 = m1[2][0];
+		const T SrcA21 = m1[2][1];
+		const T SrcA22 = m1[2][2];
+		const T SrcA23 = m1[2][3];
+
+		const T SrcB00 = m2[0][0];
+		const T SrcB01 = m2[0][1];
+		const T SrcB02 = m2[0][2];
+		const T SrcB10 = m2[1][0];
+		const T SrcB11 = m2[1][1];
+		const T SrcB12 = m2[1][2];
+		const T SrcB20 = m2[2][0];
+		const T SrcB21 = m2[2][1];
+		const T SrcB22 = m2[2][2];
+		const T SrcB30 = m2[3][0];
+		const T SrcB31 = m2[3][1];
+		const T SrcB32 = m2[3][2];
+
+		mat<4, 4, T, Q> Result;
+		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02;
+		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02;
+		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02;
+		Result[0][3] = SrcA03 * SrcB00 + SrcA13 * SrcB01 + SrcA23 * SrcB02;
+		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12;
+		Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12;
+		Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12;
+		Result[1][3] = SrcA03 * SrcB10 + SrcA13 * SrcB11 + SrcA23 * SrcB12;
+		Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22;
+		Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22;
+		Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22;
+		Result[2][3] = SrcA03 * SrcB20 + SrcA13 * SrcB21 + SrcA23 * SrcB22;
+		Result[3][0] = SrcA00 * SrcB30 + SrcA10 * SrcB31 + SrcA20 * SrcB32;
+		Result[3][1] = SrcA01 * SrcB30 + SrcA11 * SrcB31 + SrcA21 * SrcB32;
+		Result[3][2] = SrcA02 * SrcB30 + SrcA12 * SrcB31 + SrcA22 * SrcB32;
+		Result[3][3] = SrcA03 * SrcB30 + SrcA13 * SrcB31 + SrcA23 * SrcB32;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1, mat<2, 3, T, Q> const& m2)
+	{
+		return mat<2, 4, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
+			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2],
+			m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
+			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2],
+			m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1, mat<3, 3, T, Q> const& m2)
+	{
+		return mat<3, 4, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
+			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2],
+			m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
+			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2],
+			m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2],
+			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2],
+			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2],
+			m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2],
+			m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1] + m1[2][3] * m2[2][2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator/(mat<3, 4, T, Q> const& m,	T scalar)
+	{
+		return mat<3, 4, T, Q>(
+			m[0] / scalar,
+			m[1] / scalar,
+			m[2] / scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator/(T scalar, mat<3, 4, T, Q> const& m)
+	{
+		return mat<3, 4, T, Q>(
+			scalar / m[0],
+			scalar / m[1],
+			scalar / m[2]);
+	}
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator==(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator!=(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
+	}
+} //namespace glm
diff --git a/engine/inc/glm/detail/type_mat4x2.hpp b/engine/inc/glm/detail/type_mat4x2.hpp
new file mode 100644
index 00000000..8d343527
--- /dev/null
+++ b/engine/inc/glm/detail/type_mat4x2.hpp
@@ -0,0 +1,171 @@
+/// @ref core
+/// @file glm/detail/type_mat4x2.hpp
+
+#pragma once
+
+#include "type_vec2.hpp"
+#include "type_vec4.hpp"
+#include <limits>
+#include <cstddef>
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	struct mat<4, 2, T, Q>
+	{
+		typedef vec<2, T, Q> col_type;
+		typedef vec<4, T, Q> row_type;
+		typedef mat<4, 2, T, Q> type;
+		typedef mat<2, 4, T, Q> transpose_type;
+		typedef T value_type;
+
+	private:
+		col_type value[4];
+
+	public:
+		// -- Accesses --
+
+		typedef length_t length_type;
+		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 4; }
+
+		GLM_FUNC_DECL col_type & operator[](length_type i);
+		GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const;
+
+		// -- Constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT;
+		template<qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<4, 2, T, P> const& m);
+
+		GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			T x0, T y0,
+			T x1, T y1,
+			T x2, T y2,
+			T x3, T y3);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			col_type const& v0,
+			col_type const& v1,
+			col_type const& v2,
+			col_type const& v3);
+
+		// -- Conversions --
+
+		template<
+			typename X0, typename Y0,
+			typename X1, typename Y1,
+			typename X2, typename Y2,
+			typename X3, typename Y3>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			X0 x0, Y0 y0,
+			X1 x1, Y1 y1,
+			X2 x2, Y2 y2,
+			X3 x3, Y3 y3);
+
+		template<typename V1, typename V2, typename V3, typename V4>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			vec<2, V1, Q> const& v1,
+			vec<2, V2, Q> const& v2,
+			vec<2, V3, Q> const& v3,
+			vec<2, V4, Q> const& v4);
+
+		// -- Matrix conversions --
+
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, U, P> const& m);
+
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x);
+
+		// -- Unary arithmetic operators --
+
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 2, T, Q> & operator=(mat<4, 2, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 2, T, Q> & operator+=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 2, T, Q> & operator+=(mat<4, 2, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 2, T, Q> & operator-=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 2, T, Q> & operator-=(mat<4, 2, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 2, T, Q> & operator*=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 2, T, Q> & operator/=(U s);
+
+		// -- Increment and decrement operators --
+
+		GLM_FUNC_DECL mat<4, 2, T, Q> & operator++ ();
+		GLM_FUNC_DECL mat<4, 2, T, Q> & operator-- ();
+		GLM_FUNC_DECL mat<4, 2, T, Q> operator++(int);
+		GLM_FUNC_DECL mat<4, 2, T, Q> operator--(int);
+	};
+
+	// -- Unary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 2, T, Q> operator+(mat<4, 2, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 2, T, Q> operator-(mat<4, 2, T, Q> const& m);
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 2, T, Q> operator+(mat<4, 2, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 2, T, Q> operator+(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 2, T, Q> operator-(mat<4, 2, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 2, T, Q> operator-(mat<4, 2, T, Q> const& m1,	mat<4, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 2, T, Q> operator*(mat<4, 2, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 2, T, Q> operator*(T scalar, mat<4, 2, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<4, 2, T, Q>::col_type operator*(mat<4, 2, T, Q> const& m, typename mat<4, 2, T, Q>::row_type const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<4, 2, T, Q>::row_type operator*(typename mat<4, 2, T, Q>::col_type const& v, mat<4, 2, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> operator*(mat<4, 2, T, Q> const& m1, mat<2, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 2, T, Q> operator*(mat<4, 2, T, Q> const& m1, mat<3, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 2, T, Q> operator*(mat<4, 2, T, Q> const& m1, mat<4, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 2, T, Q> operator/(mat<4, 2, T, Q> const& m, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 2, T, Q> operator/(T scalar, mat<4, 2, T, Q> const& m);
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator==(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator!=(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat4x2.inl"
+#endif
diff --git a/engine/inc/glm/detail/type_mat4x2.inl b/engine/inc/glm/detail/type_mat4x2.inl
new file mode 100644
index 00000000..419c80c4
--- /dev/null
+++ b/engine/inc/glm/detail/type_mat4x2.inl
@@ -0,0 +1,574 @@
+namespace glm
+{
+	// -- Constructors --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat()
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
+				: value{col_type(1, 0), col_type(0, 1), col_type(0, 0), col_type(0, 0)}
+#			endif
+		{
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
+				this->value[0] = col_type(1, 0);
+				this->value[1] = col_type(0, 1);
+				this->value[2] = col_type(0, 0);
+				this->value[3] = col_type(0, 0);
+#			endif
+		}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<4, 2, T, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = m[0];
+			this->value[1] = m[1];
+			this->value[2] = m[2];
+			this->value[3] = m[3];
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(T s)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(s, 0), col_type(0, s), col_type(0, 0), col_type(0, 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(s, 0);
+			this->value[1] = col_type(0, s);
+			this->value[2] = col_type(0, 0);
+			this->value[3] = col_type(0, 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat
+	(
+		T x0, T y0,
+		T x1, T y1,
+		T x2, T y2,
+		T x3, T y3
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(x0, y0), col_type(x1, y1), col_type(x2, y2), col_type(x3, y3)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x0, y0);
+			this->value[1] = col_type(x1, y1);
+			this->value[2] = col_type(x2, y2);
+			this->value[3] = col_type(x3, y3);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2, col_type const& v3)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v0), col_type(v1), col_type(v2), col_type(v3)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = v0;
+			this->value[1] = v1;
+			this->value[2] = v2;
+			this->value[3] = v3;
+#		endif
+	}
+
+	// -- Conversion constructors --
+
+	template<typename T, qualifier Q>
+	template<
+		typename X0, typename Y0,
+		typename X1, typename Y1,
+		typename X2, typename Y2,
+		typename X3, typename Y3>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat
+	(
+		X0 x0, Y0 y0,
+		X1 x1, Y1 y1,
+		X2 x2, Y2 y2,
+		X3 x3, Y3 y3
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(x0, y0), col_type(x1, y1), col_type(x2, y2), col_type(x3, y3)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x0, y0);
+			this->value[1] = col_type(x1, y1);
+			this->value[2] = col_type(x2, y2);
+			this->value[3] = col_type(x3, y3);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	template<typename V0, typename V1, typename V2, typename V3>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(vec<2, V0, Q> const& v0, vec<2, V1, Q> const& v1, vec<2, V2, Q> const& v2, vec<2, V3, Q> const& v3)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v0), col_type(v1), col_type(v2), col_type(v3)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(v0);
+			this->value[1] = col_type(v1);
+			this->value[2] = col_type(v2);
+			this->value[3] = col_type(v3);
+#		endif
+	}
+
+	// -- Conversion --
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<4, 2, U, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+			this->value[3] = col_type(m[3]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<2, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(0), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(0);
+			this->value[3] = col_type(0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<3, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+			this->value[3] = col_type(0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<4, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+			this->value[3] = col_type(m[3]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<2, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(0), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(0);
+			this->value[3] = col_type(0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<3, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+			this->value[3] = col_type(0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<2, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(0), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(0);
+			this->value[3] = col_type(0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<4, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+				this->value[0] = col_type(m[0]);
+				this->value[1] = col_type(m[1]);
+				this->value[2] = col_type(m[2]);
+				this->value[3] = col_type(m[3]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<3, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+			this->value[3] = col_type(0);
+#		endif
+	}
+
+	// -- Accesses --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<4, 2, T, Q>::col_type & mat<4, 2, T, Q>::operator[](typename mat<4, 2, T, Q>::length_type i)
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<4, 2, T, Q>::col_type const& mat<4, 2, T, Q>::operator[](typename mat<4, 2, T, Q>::length_type i) const
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	// -- Unary updatable operators --
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q>& mat<4, 2, T, Q>::operator=(mat<4, 2, U, Q> const& m)
+	{
+		this->value[0] = m[0];
+		this->value[1] = m[1];
+		this->value[2] = m[2];
+		this->value[3] = m[3];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator+=(U s)
+	{
+		this->value[0] += s;
+		this->value[1] += s;
+		this->value[2] += s;
+		this->value[3] += s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator+=(mat<4, 2, U, Q> const& m)
+	{
+		this->value[0] += m[0];
+		this->value[1] += m[1];
+		this->value[2] += m[2];
+		this->value[3] += m[3];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator-=(U s)
+	{
+		this->value[0] -= s;
+		this->value[1] -= s;
+		this->value[2] -= s;
+		this->value[3] -= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator-=(mat<4, 2, U, Q> const& m)
+	{
+		this->value[0] -= m[0];
+		this->value[1] -= m[1];
+		this->value[2] -= m[2];
+		this->value[3] -= m[3];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator*=(U s)
+	{
+		this->value[0] *= s;
+		this->value[1] *= s;
+		this->value[2] *= s;
+		this->value[3] *= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator/=(U s)
+	{
+		this->value[0] /= s;
+		this->value[1] /= s;
+		this->value[2] /= s;
+		this->value[3] /= s;
+		return *this;
+	}
+
+	// -- Increment and decrement operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator++()
+	{
+		++this->value[0];
+		++this->value[1];
+		++this->value[2];
+		++this->value[3];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator--()
+	{
+		--this->value[0];
+		--this->value[1];
+		--this->value[2];
+		--this->value[3];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> mat<4, 2, T, Q>::operator++(int)
+	{
+		mat<4, 2, T, Q> Result(*this);
+		++*this;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> mat<4, 2, T, Q>::operator--(int)
+	{
+		mat<4, 2, T, Q> Result(*this);
+		--*this;
+		return Result;
+	}
+
+	// -- Unary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator+(mat<4, 2, T, Q> const& m)
+	{
+		return m;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator-(mat<4, 2, T, Q> const& m)
+	{
+		return mat<4, 2, T, Q>(
+			-m[0],
+			-m[1],
+			-m[2],
+			-m[3]);
+	}
+
+	// -- Binary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator+(mat<4, 2, T, Q> const& m, T scalar)
+	{
+		return mat<4, 2, T, Q>(
+			m[0] + scalar,
+			m[1] + scalar,
+			m[2] + scalar,
+			m[3] + scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator+(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2)
+	{
+		return mat<4, 2, T, Q>(
+			m1[0] + m2[0],
+			m1[1] + m2[1],
+			m1[2] + m2[2],
+			m1[3] + m2[3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator-(mat<4, 2, T, Q> const& m, T scalar)
+	{
+		return mat<4, 2, T, Q>(
+			m[0] - scalar,
+			m[1] - scalar,
+			m[2] - scalar,
+			m[3] - scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator-(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2)
+	{
+		return mat<4, 2, T, Q>(
+			m1[0] - m2[0],
+			m1[1] - m2[1],
+			m1[2] - m2[2],
+			m1[3] - m2[3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator*(mat<4, 2, T, Q> const& m, T scalar)
+	{
+		return mat<4, 2, T, Q>(
+			m[0] * scalar,
+			m[1] * scalar,
+			m[2] * scalar,
+			m[3] * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator*(T scalar, mat<4, 2, T, Q> const& m)
+	{
+		return mat<4, 2, T, Q>(
+			m[0] * scalar,
+			m[1] * scalar,
+			m[2] * scalar,
+			m[3] * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<4, 2, T, Q>::col_type operator*(mat<4, 2, T, Q> const& m, typename mat<4, 2, T, Q>::row_type const& v)
+	{
+		return typename mat<4, 2, T, Q>::col_type(
+			m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * v.w,
+			m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * v.w);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<4, 2, T, Q>::row_type operator*(typename mat<4, 2, T, Q>::col_type const& v, mat<4, 2, T, Q> const& m)
+	{
+		return typename mat<4, 2, T, Q>::row_type(
+			v.x * m[0][0] + v.y * m[0][1],
+			v.x * m[1][0] + v.y * m[1][1],
+			v.x * m[2][0] + v.y * m[2][1],
+			v.x * m[3][0] + v.y * m[3][1]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator*(mat<4, 2, T, Q> const& m1, mat<2, 4, T, Q> const& m2)
+	{
+		T const SrcA00 = m1[0][0];
+		T const SrcA01 = m1[0][1];
+		T const SrcA10 = m1[1][0];
+		T const SrcA11 = m1[1][1];
+		T const SrcA20 = m1[2][0];
+		T const SrcA21 = m1[2][1];
+		T const SrcA30 = m1[3][0];
+		T const SrcA31 = m1[3][1];
+
+		T const SrcB00 = m2[0][0];
+		T const SrcB01 = m2[0][1];
+		T const SrcB02 = m2[0][2];
+		T const SrcB03 = m2[0][3];
+		T const SrcB10 = m2[1][0];
+		T const SrcB11 = m2[1][1];
+		T const SrcB12 = m2[1][2];
+		T const SrcB13 = m2[1][3];
+
+		mat<2, 2, T, Q> Result;
+		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02 + SrcA30 * SrcB03;
+		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02 + SrcA31 * SrcB03;
+		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12 + SrcA30 * SrcB13;
+		Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12 + SrcA31 * SrcB13;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator*(mat<4, 2, T, Q> const& m1, mat<3, 4, T, Q> const& m2)
+	{
+		return mat<3, 2, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
+			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3],
+			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator*(mat<4, 2, T, Q> const& m1, mat<4, 4, T, Q> const& m2)
+	{
+		return mat<4, 2, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
+			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3],
+			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3],
+			m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2] + m1[3][0] * m2[3][3],
+			m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2] + m1[3][1] * m2[3][3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator/(mat<4, 2, T, Q> const& m, T scalar)
+	{
+		return mat<4, 2, T, Q>(
+			m[0] / scalar,
+			m[1] / scalar,
+			m[2] / scalar,
+			m[3] / scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator/(T scalar, mat<4, 2, T, Q> const& m)
+	{
+		return mat<4, 2, T, Q>(
+			scalar / m[0],
+			scalar / m[1],
+			scalar / m[2],
+			scalar / m[3]);
+	}
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator==(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator!=(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
+	}
+} //namespace glm
diff --git a/engine/inc/glm/detail/type_mat4x3.hpp b/engine/inc/glm/detail/type_mat4x3.hpp
new file mode 100644
index 00000000..16e42705
--- /dev/null
+++ b/engine/inc/glm/detail/type_mat4x3.hpp
@@ -0,0 +1,171 @@
+/// @ref core
+/// @file glm/detail/type_mat4x3.hpp
+
+#pragma once
+
+#include "type_vec3.hpp"
+#include "type_vec4.hpp"
+#include <limits>
+#include <cstddef>
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	struct mat<4, 3, T, Q>
+	{
+		typedef vec<3, T, Q> col_type;
+		typedef vec<4, T, Q> row_type;
+		typedef mat<4, 3, T, Q> type;
+		typedef mat<3, 4, T, Q> transpose_type;
+		typedef T value_type;
+
+	private:
+		col_type value[4];
+
+	public:
+		// -- Accesses --
+
+		typedef length_t length_type;
+		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 4; }
+
+		GLM_FUNC_DECL col_type & operator[](length_type i);
+		GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const;
+
+		// -- Constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT;
+		template<qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<4, 3, T, P> const& m);
+
+		GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T const& x);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			T const& x0, T const& y0, T const& z0,
+			T const& x1, T const& y1, T const& z1,
+			T const& x2, T const& y2, T const& z2,
+			T const& x3, T const& y3, T const& z3);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			col_type const& v0,
+			col_type const& v1,
+			col_type const& v2,
+			col_type const& v3);
+
+		// -- Conversions --
+
+		template<
+			typename X1, typename Y1, typename Z1,
+			typename X2, typename Y2, typename Z2,
+			typename X3, typename Y3, typename Z3,
+			typename X4, typename Y4, typename Z4>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			X1 const& x1, Y1 const& y1, Z1 const& z1,
+			X2 const& x2, Y2 const& y2, Z2 const& z2,
+			X3 const& x3, Y3 const& y3, Z3 const& z3,
+			X4 const& x4, Y4 const& y4, Z4 const& z4);
+
+		template<typename V1, typename V2, typename V3, typename V4>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			vec<3, V1, Q> const& v1,
+			vec<3, V2, Q> const& v2,
+			vec<3, V3, Q> const& v3,
+			vec<3, V4, Q> const& v4);
+
+		// -- Matrix conversions --
+
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, U, P> const& m);
+
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x);
+
+		// -- Unary arithmetic operators --
+
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 3, T, Q> & operator=(mat<4, 3, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 3, T, Q> & operator+=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 3, T, Q> & operator+=(mat<4, 3, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 3, T, Q> & operator-=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 3, T, Q> & operator-=(mat<4, 3, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 3, T, Q> & operator*=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 3, T, Q> & operator/=(U s);
+
+		// -- Increment and decrement operators --
+
+		GLM_FUNC_DECL mat<4, 3, T, Q>& operator++();
+		GLM_FUNC_DECL mat<4, 3, T, Q>& operator--();
+		GLM_FUNC_DECL mat<4, 3, T, Q> operator++(int);
+		GLM_FUNC_DECL mat<4, 3, T, Q> operator--(int);
+	};
+
+	// -- Unary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 3, T, Q> operator+(mat<4, 3, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 3, T, Q> operator-(mat<4, 3, T, Q> const& m);
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 3, T, Q> operator+(mat<4, 3, T, Q> const& m, T const& s);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 3, T, Q> operator+(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 3, T, Q> operator-(mat<4, 3, T, Q> const& m, T const& s);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 3, T, Q> operator-(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 3, T, Q> operator*(mat<4, 3, T, Q> const& m, T const& s);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 3, T, Q> operator*(T const& s, mat<4, 3, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<4, 3, T, Q>::col_type operator*(mat<4, 3, T, Q> const& m, typename mat<4, 3, T, Q>::row_type const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<4, 3, T, Q>::row_type operator*(typename mat<4, 3, T, Q>::col_type const& v, mat<4, 3, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 3, T, Q> operator*(mat<4, 3, T, Q> const& m1, mat<2, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> operator*(mat<4, 3, T, Q> const& m1,	mat<3, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 3, T, Q> operator*(mat<4, 3, T, Q> const& m1, mat<4, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 3, T, Q> operator/(mat<4, 3, T, Q> const& m, T const& s);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 3, T, Q> operator/(T const& s, mat<4, 3, T, Q> const& m);
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator==(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator!=(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat4x3.inl"
+#endif //GLM_EXTERNAL_TEMPLATE
diff --git a/engine/inc/glm/detail/type_mat4x3.inl b/engine/inc/glm/detail/type_mat4x3.inl
new file mode 100644
index 00000000..702025dd
--- /dev/null
+++ b/engine/inc/glm/detail/type_mat4x3.inl
@@ -0,0 +1,598 @@
+namespace glm
+{
+	// -- Constructors --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat()
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
+				: value{col_type(1, 0, 0), col_type(0, 1, 0), col_type(0, 0, 1), col_type(0, 0, 0)}
+#			endif
+		{
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
+				this->value[0] = col_type(1, 0, 0);
+				this->value[1] = col_type(0, 1, 0);
+				this->value[2] = col_type(0, 0, 1);
+				this->value[3] = col_type(0, 0, 0);
+#			endif
+		}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<4, 3, T, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = m[0];
+			this->value[1] = m[1];
+			this->value[2] = m[2];
+			this->value[3] = m[3];
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(T const& s)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(s, 0, 0), col_type(0, s, 0), col_type(0, 0, s), col_type(0, 0, 0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(s, 0, 0);
+			this->value[1] = col_type(0, s, 0);
+			this->value[2] = col_type(0, 0, s);
+			this->value[3] = col_type(0, 0, 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat
+	(
+		T const& x0, T const& y0, T const& z0,
+		T const& x1, T const& y1, T const& z1,
+		T const& x2, T const& y2, T const& z2,
+		T const& x3, T const& y3, T const& z3
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(x0, y0, z0), col_type(x1, y1, z1), col_type(x2, y2, z2), col_type(x3, y3, z3)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x0, y0, z0);
+			this->value[1] = col_type(x1, y1, z1);
+			this->value[2] = col_type(x2, y2, z2);
+			this->value[3] = col_type(x3, y3, z3);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2, col_type const& v3)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v0), col_type(v1), col_type(v2), col_type(v3)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = v0;
+			this->value[1] = v1;
+			this->value[2] = v2;
+			this->value[3] = v3;
+#		endif
+	}
+
+	// -- Conversion constructors --
+
+	template<typename T, qualifier Q>
+	template<
+		typename X0, typename Y0, typename Z0,
+		typename X1, typename Y1, typename Z1,
+		typename X2, typename Y2, typename Z2,
+		typename X3, typename Y3, typename Z3>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat
+	(
+		X0 const& x0, Y0 const& y0, Z0 const& z0,
+		X1 const& x1, Y1 const& y1, Z1 const& z1,
+		X2 const& x2, Y2 const& y2, Z2 const& z2,
+		X3 const& x3, Y3 const& y3, Z3 const& z3
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(x0, y0, z0), col_type(x1, y1, z1), col_type(x2, y2, z2), col_type(x3, y3, z3)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x0, y0, z0);
+			this->value[1] = col_type(x1, y1, z1);
+			this->value[2] = col_type(x2, y2, z2);
+			this->value[3] = col_type(x3, y3, z3);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	template<typename V1, typename V2, typename V3, typename V4>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(vec<3, V1, Q> const& v1, vec<3, V2, Q> const& v2, vec<3, V3, Q> const& v3, vec<3, V4, Q> const& v4)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v1), col_type(v2), col_type(v3), col_type(v4)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(v1);
+			this->value[1] = col_type(v2);
+			this->value[2] = col_type(v3);
+			this->value[3] = col_type(v4);
+#		endif
+	}
+
+	// -- Matrix conversions --
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<4, 3, U, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+			this->value[3] = col_type(m[3]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<2, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(0, 0, 1), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+			this->value[2] = col_type(0, 0, 1);
+			this->value[3] = col_type(0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<3, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+			this->value[3] = col_type(0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<4, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+			this->value[3] = col_type(m[3]);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<2, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(0, 0, 1);
+			this->value[3] = col_type(0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<3, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 1), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+			this->value[2] = col_type(m[2], 1);
+			this->value[3] = col_type(0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<2, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(0, 0, 1);
+			this->value[3] = col_type(0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<4, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 1), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+			this->value[2] = col_type(m[2], 1);
+			this->value[3] = col_type(m[3], 0);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<3, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+			this->value[3] = col_type(0);
+#		endif
+	}
+
+	// -- Accesses --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<4, 3, T, Q>::col_type & mat<4, 3, T, Q>::operator[](typename mat<4, 3, T, Q>::length_type i)
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<4, 3, T, Q>::col_type const& mat<4, 3, T, Q>::operator[](typename mat<4, 3, T, Q>::length_type i) const
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	// -- Unary updatable operators --
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q>& mat<4, 3, T, Q>::operator=(mat<4, 3, U, Q> const& m)
+	{
+		this->value[0] = m[0];
+		this->value[1] = m[1];
+		this->value[2] = m[2];
+		this->value[3] = m[3];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator+=(U s)
+	{
+		this->value[0] += s;
+		this->value[1] += s;
+		this->value[2] += s;
+		this->value[3] += s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator+=(mat<4, 3, U, Q> const& m)
+	{
+		this->value[0] += m[0];
+		this->value[1] += m[1];
+		this->value[2] += m[2];
+		this->value[3] += m[3];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator-=(U s)
+	{
+		this->value[0] -= s;
+		this->value[1] -= s;
+		this->value[2] -= s;
+		this->value[3] -= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator-=(mat<4, 3, U, Q> const& m)
+	{
+		this->value[0] -= m[0];
+		this->value[1] -= m[1];
+		this->value[2] -= m[2];
+		this->value[3] -= m[3];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator*=(U s)
+	{
+		this->value[0] *= s;
+		this->value[1] *= s;
+		this->value[2] *= s;
+		this->value[3] *= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator/=(U s)
+	{
+		this->value[0] /= s;
+		this->value[1] /= s;
+		this->value[2] /= s;
+		this->value[3] /= s;
+		return *this;
+	}
+
+	// -- Increment and decrement operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator++()
+	{
+		++this->value[0];
+		++this->value[1];
+		++this->value[2];
+		++this->value[3];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator--()
+	{
+		--this->value[0];
+		--this->value[1];
+		--this->value[2];
+		--this->value[3];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> mat<4, 3, T, Q>::operator++(int)
+	{
+		mat<4, 3, T, Q> Result(*this);
+		++*this;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> mat<4, 3, T, Q>::operator--(int)
+	{
+		mat<4, 3, T, Q> Result(*this);
+		--*this;
+		return Result;
+	}
+
+	// -- Unary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator+(mat<4, 3, T, Q> const& m)
+	{
+		return m;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator-(mat<4, 3, T, Q> const& m)
+	{
+		return mat<4, 3, T, Q>(
+			-m[0],
+			-m[1],
+			-m[2],
+			-m[3]);
+	}
+
+	// -- Binary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator+(mat<4, 3, T, Q> const& m, T const& s)
+	{
+		return mat<4, 3, T, Q>(
+			m[0] + s,
+			m[1] + s,
+			m[2] + s,
+			m[3] + s);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator+(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2)
+	{
+		return mat<4, 3, T, Q>(
+			m1[0] + m2[0],
+			m1[1] + m2[1],
+			m1[2] + m2[2],
+			m1[3] + m2[3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator-(mat<4, 3, T, Q> const& m, T const& s)
+	{
+		return mat<4, 3, T, Q>(
+			m[0] - s,
+			m[1] - s,
+			m[2] - s,
+			m[3] - s);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator-(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2)
+	{
+		return mat<4, 3, T, Q>(
+			m1[0] - m2[0],
+			m1[1] - m2[1],
+			m1[2] - m2[2],
+			m1[3] - m2[3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator*(mat<4, 3, T, Q> const& m, T const& s)
+	{
+		return mat<4, 3, T, Q>(
+			m[0] * s,
+			m[1] * s,
+			m[2] * s,
+			m[3] * s);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator*(T const& s, mat<4, 3, T, Q> const& m)
+	{
+		return mat<4, 3, T, Q>(
+			m[0] * s,
+			m[1] * s,
+			m[2] * s,
+			m[3] * s);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<4, 3, T, Q>::col_type operator*
+	(
+		mat<4, 3, T, Q> const& m,
+		typename mat<4, 3, T, Q>::row_type const& v)
+	{
+		return typename mat<4, 3, T, Q>::col_type(
+			m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * v.w,
+			m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * v.w,
+			m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z + m[3][2] * v.w);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<4, 3, T, Q>::row_type operator*
+	(
+		typename mat<4, 3, T, Q>::col_type const& v,
+		mat<4, 3, T, Q> const& m)
+	{
+		return typename mat<4, 3, T, Q>::row_type(
+			v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2],
+			v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2],
+			v.x * m[2][0] + v.y * m[2][1] + v.z * m[2][2],
+			v.x * m[3][0] + v.y * m[3][1] + v.z * m[3][2]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator*(mat<4, 3, T, Q> const& m1, mat<2, 4, T, Q> const& m2)
+	{
+		return mat<2, 3, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
+			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
+			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator*(mat<4, 3, T, Q> const& m1, mat<3, 4, T, Q> const& m2)
+	{
+		T const SrcA00 = m1[0][0];
+		T const SrcA01 = m1[0][1];
+		T const SrcA02 = m1[0][2];
+		T const SrcA10 = m1[1][0];
+		T const SrcA11 = m1[1][1];
+		T const SrcA12 = m1[1][2];
+		T const SrcA20 = m1[2][0];
+		T const SrcA21 = m1[2][1];
+		T const SrcA22 = m1[2][2];
+		T const SrcA30 = m1[3][0];
+		T const SrcA31 = m1[3][1];
+		T const SrcA32 = m1[3][2];
+
+		T const SrcB00 = m2[0][0];
+		T const SrcB01 = m2[0][1];
+		T const SrcB02 = m2[0][2];
+		T const SrcB03 = m2[0][3];
+		T const SrcB10 = m2[1][0];
+		T const SrcB11 = m2[1][1];
+		T const SrcB12 = m2[1][2];
+		T const SrcB13 = m2[1][3];
+		T const SrcB20 = m2[2][0];
+		T const SrcB21 = m2[2][1];
+		T const SrcB22 = m2[2][2];
+		T const SrcB23 = m2[2][3];
+
+		mat<3, 3, T, Q> Result;
+		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02 + SrcA30 * SrcB03;
+		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02 + SrcA31 * SrcB03;
+		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02 + SrcA32 * SrcB03;
+		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12 + SrcA30 * SrcB13;
+		Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12 + SrcA31 * SrcB13;
+		Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12 + SrcA32 * SrcB13;
+		Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22 + SrcA30 * SrcB23;
+		Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22 + SrcA31 * SrcB23;
+		Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22 + SrcA32 * SrcB23;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator*(mat<4, 3, T, Q> const& m1, mat<4, 4, T, Q> const& m2)
+	{
+		return mat<4, 3, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
+			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
+			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3],
+			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3],
+			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3],
+			m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2] + m1[3][2] * m2[2][3],
+			m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2] + m1[3][0] * m2[3][3],
+			m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2] + m1[3][1] * m2[3][3],
+			m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1] + m1[2][2] * m2[3][2] + m1[3][2] * m2[3][3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator/(mat<4, 3, T, Q> const& m, T const& s)
+	{
+		return mat<4, 3, T, Q>(
+			m[0] / s,
+			m[1] / s,
+			m[2] / s,
+			m[3] / s);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator/(T const& s, mat<4, 3, T, Q> const& m)
+	{
+		return mat<4, 3, T, Q>(
+			s / m[0],
+			s / m[1],
+			s / m[2],
+			s / m[3]);
+	}
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator==(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator!=(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
+	}
+} //namespace glm
diff --git a/engine/inc/glm/detail/type_mat4x4.hpp b/engine/inc/glm/detail/type_mat4x4.hpp
new file mode 100644
index 00000000..3517f9f5
--- /dev/null
+++ b/engine/inc/glm/detail/type_mat4x4.hpp
@@ -0,0 +1,189 @@
+/// @ref core
+/// @file glm/detail/type_mat4x4.hpp
+
+#pragma once
+
+#include "type_vec4.hpp"
+#include <limits>
+#include <cstddef>
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	struct mat<4, 4, T, Q>
+	{
+		typedef vec<4, T, Q> col_type;
+		typedef vec<4, T, Q> row_type;
+		typedef mat<4, 4, T, Q> type;
+		typedef mat<4, 4, T, Q> transpose_type;
+		typedef T value_type;
+
+	private:
+		col_type value[4];
+
+	public:
+		// -- Accesses --
+
+		typedef length_t length_type;
+		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 4;}
+
+		GLM_FUNC_DECL col_type & operator[](length_type i);
+		GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const;
+
+		// -- Constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT;
+		template<qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<4, 4, T, P> const& m);
+
+		GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T const& x);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			T const& x0, T const& y0, T const& z0, T const& w0,
+			T const& x1, T const& y1, T const& z1, T const& w1,
+			T const& x2, T const& y2, T const& z2, T const& w2,
+			T const& x3, T const& y3, T const& z3, T const& w3);
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			col_type const& v0,
+			col_type const& v1,
+			col_type const& v2,
+			col_type const& v3);
+
+		// -- Conversions --
+
+		template<
+			typename X1, typename Y1, typename Z1, typename W1,
+			typename X2, typename Y2, typename Z2, typename W2,
+			typename X3, typename Y3, typename Z3, typename W3,
+			typename X4, typename Y4, typename Z4, typename W4>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			X1 const& x1, Y1 const& y1, Z1 const& z1, W1 const& w1,
+			X2 const& x2, Y2 const& y2, Z2 const& z2, W2 const& w2,
+			X3 const& x3, Y3 const& y3, Z3 const& z3, W3 const& w3,
+			X4 const& x4, Y4 const& y4, Z4 const& z4, W4 const& w4);
+
+		template<typename V1, typename V2, typename V3, typename V4>
+		GLM_FUNC_DECL GLM_CONSTEXPR mat(
+			vec<4, V1, Q> const& v1,
+			vec<4, V2, Q> const& v2,
+			vec<4, V3, Q> const& v3,
+			vec<4, V4, Q> const& v4);
+
+		// -- Matrix conversions --
+
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, U, P> const& m);
+
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x);
+
+		// -- Unary arithmetic operators --
+
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 4, T, Q> & operator=(mat<4, 4, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 4, T, Q> & operator+=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 4, T, Q> & operator+=(mat<4, 4, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 4, T, Q> & operator-=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 4, T, Q> & operator-=(mat<4, 4, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 4, T, Q> & operator*=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 4, T, Q> & operator*=(mat<4, 4, U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 4, T, Q> & operator/=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 4, T, Q> & operator/=(mat<4, 4, U, Q> const& m);
+
+		// -- Increment and decrement operators --
+
+		GLM_FUNC_DECL mat<4, 4, T, Q> & operator++();
+		GLM_FUNC_DECL mat<4, 4, T, Q> & operator--();
+		GLM_FUNC_DECL mat<4, 4, T, Q> operator++(int);
+		GLM_FUNC_DECL mat<4, 4, T, Q> operator--(int);
+	};
+
+	// -- Unary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator+(mat<4, 4, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator-(mat<4, 4, T, Q> const& m);
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator+(mat<4, 4, T, Q> const& m, T const& s);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator+(T const& s, mat<4, 4, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator+(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator-(mat<4, 4, T, Q> const& m, T const& s);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator-(T const& s, mat<4, 4, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator-(mat<4, 4, T, Q> const& m1,	mat<4, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator*(mat<4, 4, T, Q> const& m, T const& s);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator*(T const& s, mat<4, 4, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<4, 4, T, Q>::col_type operator*(mat<4, 4, T, Q> const& m, typename mat<4, 4, T, Q>::row_type const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<4, 4, T, Q>::row_type operator*(typename mat<4, 4, T, Q>::col_type const& v, mat<4, 4, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator/(mat<4, 4, T, Q> const& m, T const& s);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator/(T const& s, mat<4, 4, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<4, 4, T, Q>::col_type operator/(mat<4, 4, T, Q> const& m, typename mat<4, 4, T, Q>::row_type const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<4, 4, T, Q>::row_type operator/(typename mat<4, 4, T, Q>::col_type const& v, mat<4, 4, T, Q> const& m);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> operator/(mat<4, 4, T, Q> const& m1,	mat<4, 4, T, Q> const& m2);
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator==(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator!=(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat4x4.inl"
+#endif//GLM_EXTERNAL_TEMPLATE
diff --git a/engine/inc/glm/detail/type_mat4x4.inl b/engine/inc/glm/detail/type_mat4x4.inl
new file mode 100644
index 00000000..e38b87f7
--- /dev/null
+++ b/engine/inc/glm/detail/type_mat4x4.inl
@@ -0,0 +1,706 @@
+#include "../matrix.hpp"
+
+namespace glm
+{
+	// -- Constructors --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat()
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
+				: value{col_type(1, 0, 0, 0), col_type(0, 1, 0, 0), col_type(0, 0, 1, 0), col_type(0, 0, 0, 1)}
+#			endif
+		{
+#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
+				this->value[0] = col_type(1, 0, 0, 0);
+				this->value[1] = col_type(0, 1, 0, 0);
+				this->value[2] = col_type(0, 0, 1, 0);
+				this->value[3] = col_type(0, 0, 0, 1);
+#			endif
+		}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<4, 4, T, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = m[0];
+			this->value[1] = m[1];
+			this->value[2] = m[2];
+			this->value[3] = m[3];
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(T const& s)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(s, 0, 0, 0), col_type(0, s, 0, 0), col_type(0, 0, s, 0), col_type(0, 0, 0, s)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(s, 0, 0, 0);
+			this->value[1] = col_type(0, s, 0, 0);
+			this->value[2] = col_type(0, 0, s, 0);
+			this->value[3] = col_type(0, 0, 0, s);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat
+	(
+		T const& x0, T const& y0, T const& z0, T const& w0,
+		T const& x1, T const& y1, T const& z1, T const& w1,
+		T const& x2, T const& y2, T const& z2, T const& w2,
+		T const& x3, T const& y3, T const& z3, T const& w3
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{
+				col_type(x0, y0, z0, w0),
+				col_type(x1, y1, z1, w1),
+				col_type(x2, y2, z2, w2),
+				col_type(x3, y3, z3, w3)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x0, y0, z0, w0);
+			this->value[1] = col_type(x1, y1, z1, w1);
+			this->value[2] = col_type(x2, y2, z2, w2);
+			this->value[3] = col_type(x3, y3, z3, w3);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2, col_type const& v3)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v0), col_type(v1), col_type(v2), col_type(v3)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = v0;
+			this->value[1] = v1;
+			this->value[2] = v2;
+			this->value[3] = v3;
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<4, 4, U, P> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0]);
+			this->value[1] = col_type(m[1]);
+			this->value[2] = col_type(m[2]);
+			this->value[3] = col_type(m[3]);
+#		endif
+	}
+
+	// -- Conversions --
+
+	template<typename T, qualifier Q>
+	template<
+		typename X1, typename Y1, typename Z1, typename W1,
+		typename X2, typename Y2, typename Z2, typename W2,
+		typename X3, typename Y3, typename Z3, typename W3,
+		typename X4, typename Y4, typename Z4, typename W4>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat
+	(
+		X1 const& x1, Y1 const& y1, Z1 const& z1, W1 const& w1,
+		X2 const& x2, Y2 const& y2, Z2 const& z2, W2 const& w2,
+		X3 const& x3, Y3 const& y3, Z3 const& z3, W3 const& w3,
+		X4 const& x4, Y4 const& y4, Z4 const& z4, W4 const& w4
+	)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(x1, y1, z1, w1), col_type(x2, y2, z2, w2), col_type(x3, y3, z3, w3), col_type(x4, y4, z4, w4)}
+#		endif
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<X1>::is_iec559 || std::numeric_limits<X1>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 1st parameter type invalid.");
+		GLM_STATIC_ASSERT(std::numeric_limits<Y1>::is_iec559 || std::numeric_limits<Y1>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 2nd parameter type invalid.");
+		GLM_STATIC_ASSERT(std::numeric_limits<Z1>::is_iec559 || std::numeric_limits<Z1>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 3rd parameter type invalid.");
+		GLM_STATIC_ASSERT(std::numeric_limits<W1>::is_iec559 || std::numeric_limits<W1>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 4th parameter type invalid.");
+
+		GLM_STATIC_ASSERT(std::numeric_limits<X2>::is_iec559 || std::numeric_limits<X2>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 5th parameter type invalid.");
+		GLM_STATIC_ASSERT(std::numeric_limits<Y2>::is_iec559 || std::numeric_limits<Y2>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 6th parameter type invalid.");
+		GLM_STATIC_ASSERT(std::numeric_limits<Z2>::is_iec559 || std::numeric_limits<Z2>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 7th parameter type invalid.");
+		GLM_STATIC_ASSERT(std::numeric_limits<W2>::is_iec559 || std::numeric_limits<W2>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 8th parameter type invalid.");
+
+		GLM_STATIC_ASSERT(std::numeric_limits<X3>::is_iec559 || std::numeric_limits<X3>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 9th parameter type invalid.");
+		GLM_STATIC_ASSERT(std::numeric_limits<Y3>::is_iec559 || std::numeric_limits<Y3>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 10th parameter type invalid.");
+		GLM_STATIC_ASSERT(std::numeric_limits<Z3>::is_iec559 || std::numeric_limits<Z3>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 11th parameter type invalid.");
+		GLM_STATIC_ASSERT(std::numeric_limits<W3>::is_iec559 || std::numeric_limits<W3>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 12th parameter type invalid.");
+
+		GLM_STATIC_ASSERT(std::numeric_limits<X4>::is_iec559 || std::numeric_limits<X4>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 13th parameter type invalid.");
+		GLM_STATIC_ASSERT(std::numeric_limits<Y4>::is_iec559 || std::numeric_limits<Y4>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 14th parameter type invalid.");
+		GLM_STATIC_ASSERT(std::numeric_limits<Z4>::is_iec559 || std::numeric_limits<Z4>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 15th parameter type invalid.");
+		GLM_STATIC_ASSERT(std::numeric_limits<W4>::is_iec559 || std::numeric_limits<W4>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 16th parameter type invalid.");
+
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(x1, y1, z1, w1);
+			this->value[1] = col_type(x2, y2, z2, w2);
+			this->value[2] = col_type(x3, y3, z3, w3);
+			this->value[3] = col_type(x4, y4, z4, w4);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	template<typename V1, typename V2, typename V3, typename V4>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(vec<4, V1, Q> const& v1, vec<4, V2, Q> const& v2, vec<4, V3, Q> const& v3, vec<4, V4, Q> const& v4)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(v1), col_type(v2), col_type(v3), col_type(v4)}
+#		endif
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<V1>::is_iec559 || std::numeric_limits<V1>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 1st parameter type invalid.");
+		GLM_STATIC_ASSERT(std::numeric_limits<V2>::is_iec559 || std::numeric_limits<V2>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 2nd parameter type invalid.");
+		GLM_STATIC_ASSERT(std::numeric_limits<V3>::is_iec559 || std::numeric_limits<V3>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 3rd parameter type invalid.");
+		GLM_STATIC_ASSERT(std::numeric_limits<V4>::is_iec559 || std::numeric_limits<V4>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 4th parameter type invalid.");
+
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(v1);
+			this->value[1] = col_type(v2);
+			this->value[2] = col_type(v3);
+			this->value[3] = col_type(v4);
+#		endif
+	}
+
+	// -- Matrix conversions --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<2, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(0, 0, 1, 0), col_type(0, 0, 0, 1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0, 0);
+			this->value[1] = col_type(m[1], 0, 0);
+			this->value[2] = col_type(0, 0, 1, 0);
+			this->value[3] = col_type(0, 0, 0, 1);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<3, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 0), col_type(0, 0, 0, 1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+			this->value[2] = col_type(m[2], 0);
+			this->value[3] = col_type(0, 0, 0, 1);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<2, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(0, 0, 1, 0), col_type(0, 0, 0, 1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+			this->value[2] = col_type(0, 0, 1, 0);
+			this->value[3] = col_type(0, 0, 0, 1);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<3, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(m[2], 1, 0), col_type(0, 0, 0, 1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0, 0);
+			this->value[1] = col_type(m[1], 0, 0);
+			this->value[2] = col_type(m[2], 1, 0);
+			this->value[3] = col_type(0, 0, 0, 1);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<2, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1, 0), col_type(0, 0, 0, 1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = m[0];
+			this->value[1] = m[1];
+			this->value[2] = col_type(0, 0, 1, 0);
+			this->value[3] = col_type(0, 0, 0, 1);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<4, 2, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(0, 0, 1, 0), col_type(0, 0, 0, 1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0, 0);
+			this->value[1] = col_type(m[1], 0, 0);
+			this->value[2] = col_type(0, 0, 1, 0);
+			this->value[3] = col_type(0, 0, 0, 1);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<3, 4, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0, 0, 0, 1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = m[0];
+			this->value[1] = m[1];
+			this->value[2] = m[2];
+			this->value[3] = col_type(0, 0, 0, 1);
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<4, 3, T, Q> const& m)
+#		if GLM_HAS_INITIALIZER_LISTS
+			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 0), col_type(m[3], 1)}
+#		endif
+	{
+#		if !GLM_HAS_INITIALIZER_LISTS
+			this->value[0] = col_type(m[0], 0);
+			this->value[1] = col_type(m[1], 0);
+			this->value[2] = col_type(m[2], 0);
+			this->value[3] = col_type(m[3], 1);
+#		endif
+	}
+
+	// -- Accesses --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<4, 4, T, Q>::col_type & mat<4, 4, T, Q>::operator[](typename mat<4, 4, T, Q>::length_type i)
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<4, 4, T, Q>::col_type const& mat<4, 4, T, Q>::operator[](typename mat<4, 4, T, Q>::length_type i) const
+	{
+		assert(i < this->length());
+		return this->value[i];
+	}
+
+	// -- Unary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q>& mat<4, 4, T, Q>::operator=(mat<4, 4, U, Q> const& m)
+	{
+		//memcpy could be faster
+		//memcpy(&this->value, &m.value, 16 * sizeof(valType));
+		this->value[0] = m[0];
+		this->value[1] = m[1];
+		this->value[2] = m[2];
+		this->value[3] = m[3];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q>& mat<4, 4, T, Q>::operator+=(U s)
+	{
+		this->value[0] += s;
+		this->value[1] += s;
+		this->value[2] += s;
+		this->value[3] += s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q>& mat<4, 4, T, Q>::operator+=(mat<4, 4, U, Q> const& m)
+	{
+		this->value[0] += m[0];
+		this->value[1] += m[1];
+		this->value[2] += m[2];
+		this->value[3] += m[3];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator-=(U s)
+	{
+		this->value[0] -= s;
+		this->value[1] -= s;
+		this->value[2] -= s;
+		this->value[3] -= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator-=(mat<4, 4, U, Q> const& m)
+	{
+		this->value[0] -= m[0];
+		this->value[1] -= m[1];
+		this->value[2] -= m[2];
+		this->value[3] -= m[3];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator*=(U s)
+	{
+		this->value[0] *= s;
+		this->value[1] *= s;
+		this->value[2] *= s;
+		this->value[3] *= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator*=(mat<4, 4, U, Q> const& m)
+	{
+		return (*this = *this * m);
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator/=(U s)
+	{
+		this->value[0] /= s;
+		this->value[1] /= s;
+		this->value[2] /= s;
+		this->value[3] /= s;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator/=(mat<4, 4, U, Q> const& m)
+	{
+		return *this *= inverse(m);
+	}
+
+	// -- Increment and decrement operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator++()
+	{
+		++this->value[0];
+		++this->value[1];
+		++this->value[2];
+		++this->value[3];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator--()
+	{
+		--this->value[0];
+		--this->value[1];
+		--this->value[2];
+		--this->value[3];
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> mat<4, 4, T, Q>::operator++(int)
+	{
+		mat<4, 4, T, Q> Result(*this);
+		++*this;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> mat<4, 4, T, Q>::operator--(int)
+	{
+		mat<4, 4, T, Q> Result(*this);
+		--*this;
+		return Result;
+	}
+
+	// -- Unary constant operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator+(mat<4, 4, T, Q> const& m)
+	{
+		return m;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator-(mat<4, 4, T, Q> const& m)
+	{
+		return mat<4, 4, T, Q>(
+			-m[0],
+			-m[1],
+			-m[2],
+			-m[3]);
+	}
+
+	// -- Binary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator+(mat<4, 4, T, Q> const& m, T const& s)
+	{
+		return mat<4, 4, T, Q>(
+			m[0] + s,
+			m[1] + s,
+			m[2] + s,
+			m[3] + s);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator+(T const& s, mat<4, 4, T, Q> const& m)
+	{
+		return mat<4, 4, T, Q>(
+			m[0] + s,
+			m[1] + s,
+			m[2] + s,
+			m[3] + s);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator+(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2)
+	{
+		return mat<4, 4, T, Q>(
+			m1[0] + m2[0],
+			m1[1] + m2[1],
+			m1[2] + m2[2],
+			m1[3] + m2[3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator-(mat<4, 4, T, Q> const& m, T const& s)
+	{
+		return mat<4, 4, T, Q>(
+			m[0] - s,
+			m[1] - s,
+			m[2] - s,
+			m[3] - s);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator-(T const& s, mat<4, 4, T, Q> const& m)
+	{
+		return mat<4, 4, T, Q>(
+			s - m[0],
+			s - m[1],
+			s - m[2],
+			s - m[3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator-(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2)
+	{
+		return mat<4, 4, T, Q>(
+			m1[0] - m2[0],
+			m1[1] - m2[1],
+			m1[2] - m2[2],
+			m1[3] - m2[3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator*(mat<4, 4, T, Q> const& m, T const  & s)
+	{
+		return mat<4, 4, T, Q>(
+			m[0] * s,
+			m[1] * s,
+			m[2] * s,
+			m[3] * s);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator*(T const& s, mat<4, 4, T, Q> const& m)
+	{
+		return mat<4, 4, T, Q>(
+			m[0] * s,
+			m[1] * s,
+			m[2] * s,
+			m[3] * s);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<4, 4, T, Q>::col_type operator*
+	(
+		mat<4, 4, T, Q> const& m,
+		typename mat<4, 4, T, Q>::row_type const& v
+	)
+	{
+/*
+		__m128 v0 = _mm_shuffle_ps(v.data, v.data, _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 v1 = _mm_shuffle_ps(v.data, v.data, _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 v2 = _mm_shuffle_ps(v.data, v.data, _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 v3 = _mm_shuffle_ps(v.data, v.data, _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 m0 = _mm_mul_ps(m[0].data, v0);
+		__m128 m1 = _mm_mul_ps(m[1].data, v1);
+		__m128 a0 = _mm_add_ps(m0, m1);
+
+		__m128 m2 = _mm_mul_ps(m[2].data, v2);
+		__m128 m3 = _mm_mul_ps(m[3].data, v3);
+		__m128 a1 = _mm_add_ps(m2, m3);
+
+		__m128 a2 = _mm_add_ps(a0, a1);
+
+		return typename mat<4, 4, T, Q>::col_type(a2);
+*/
+
+		typename mat<4, 4, T, Q>::col_type const Mov0(v[0]);
+		typename mat<4, 4, T, Q>::col_type const Mov1(v[1]);
+		typename mat<4, 4, T, Q>::col_type const Mul0 = m[0] * Mov0;
+		typename mat<4, 4, T, Q>::col_type const Mul1 = m[1] * Mov1;
+		typename mat<4, 4, T, Q>::col_type const Add0 = Mul0 + Mul1;
+		typename mat<4, 4, T, Q>::col_type const Mov2(v[2]);
+		typename mat<4, 4, T, Q>::col_type const Mov3(v[3]);
+		typename mat<4, 4, T, Q>::col_type const Mul2 = m[2] * Mov2;
+		typename mat<4, 4, T, Q>::col_type const Mul3 = m[3] * Mov3;
+		typename mat<4, 4, T, Q>::col_type const Add1 = Mul2 + Mul3;
+		typename mat<4, 4, T, Q>::col_type const Add2 = Add0 + Add1;
+		return Add2;
+
+/*
+		return typename mat<4, 4, T, Q>::col_type(
+			m[0][0] * v[0] + m[1][0] * v[1] + m[2][0] * v[2] + m[3][0] * v[3],
+			m[0][1] * v[0] + m[1][1] * v[1] + m[2][1] * v[2] + m[3][1] * v[3],
+			m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2] + m[3][2] * v[3],
+			m[0][3] * v[0] + m[1][3] * v[1] + m[2][3] * v[2] + m[3][3] * v[3]);
+*/
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<4, 4, T, Q>::row_type operator*
+	(
+		typename mat<4, 4, T, Q>::col_type const& v,
+		mat<4, 4, T, Q> const& m
+	)
+	{
+		return typename mat<4, 4, T, Q>::row_type(
+			m[0][0] * v[0] + m[0][1] * v[1] + m[0][2] * v[2] + m[0][3] * v[3],
+			m[1][0] * v[0] + m[1][1] * v[1] + m[1][2] * v[2] + m[1][3] * v[3],
+			m[2][0] * v[0] + m[2][1] * v[1] + m[2][2] * v[2] + m[2][3] * v[3],
+			m[3][0] * v[0] + m[3][1] * v[1] + m[3][2] * v[2] + m[3][3] * v[3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2)
+	{
+		return mat<2, 4, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
+			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3],
+			m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2] + m1[3][3] * m2[0][3],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
+			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3],
+			m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2] + m1[3][3] * m2[1][3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2)
+	{
+		return mat<3, 4, T, Q>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
+			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3],
+			m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2] + m1[3][3] * m2[0][3],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
+			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3],
+			m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2] + m1[3][3] * m2[1][3],
+			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3],
+			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3],
+			m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2] + m1[3][2] * m2[2][3],
+			m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1] + m1[2][3] * m2[2][2] + m1[3][3] * m2[2][3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2)
+	{
+		typename mat<4, 4, T, Q>::col_type const SrcA0 = m1[0];
+		typename mat<4, 4, T, Q>::col_type const SrcA1 = m1[1];
+		typename mat<4, 4, T, Q>::col_type const SrcA2 = m1[2];
+		typename mat<4, 4, T, Q>::col_type const SrcA3 = m1[3];
+
+		typename mat<4, 4, T, Q>::col_type const SrcB0 = m2[0];
+		typename mat<4, 4, T, Q>::col_type const SrcB1 = m2[1];
+		typename mat<4, 4, T, Q>::col_type const SrcB2 = m2[2];
+		typename mat<4, 4, T, Q>::col_type const SrcB3 = m2[3];
+
+		mat<4, 4, T, Q> Result;
+		Result[0] = SrcA0 * SrcB0[0] + SrcA1 * SrcB0[1] + SrcA2 * SrcB0[2] + SrcA3 * SrcB0[3];
+		Result[1] = SrcA0 * SrcB1[0] + SrcA1 * SrcB1[1] + SrcA2 * SrcB1[2] + SrcA3 * SrcB1[3];
+		Result[2] = SrcA0 * SrcB2[0] + SrcA1 * SrcB2[1] + SrcA2 * SrcB2[2] + SrcA3 * SrcB2[3];
+		Result[3] = SrcA0 * SrcB3[0] + SrcA1 * SrcB3[1] + SrcA2 * SrcB3[2] + SrcA3 * SrcB3[3];
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator/(mat<4, 4, T, Q> const& m, T const& s)
+	{
+		return mat<4, 4, T, Q>(
+			m[0] / s,
+			m[1] / s,
+			m[2] / s,
+			m[3] / s);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator/(T const& s,	mat<4, 4, T, Q> const& m)
+	{
+		return mat<4, 4, T, Q>(
+			s / m[0],
+			s / m[1],
+			s / m[2],
+			s / m[3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<4, 4, T, Q>::col_type operator/(mat<4, 4, T, Q> const& m, typename mat<4, 4, T, Q>::row_type const& v)
+	{
+		return inverse(m) * v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename mat<4, 4, T, Q>::row_type operator/(typename mat<4, 4, T, Q>::col_type const& v, mat<4, 4, T, Q> const& m)
+	{
+		return v * inverse(m);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator/(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2)
+	{
+		mat<4, 4, T, Q> m1_copy(m1);
+		return m1_copy /= m2;
+	}
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator==(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator!=(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
+	}
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+#	include "type_mat4x4_simd.inl"
+#endif
diff --git a/engine/inc/glm/detail/type_mat4x4_simd.inl b/engine/inc/glm/detail/type_mat4x4_simd.inl
new file mode 100644
index 00000000..fb3a16f0
--- /dev/null
+++ b/engine/inc/glm/detail/type_mat4x4_simd.inl
@@ -0,0 +1,6 @@
+/// @ref core
+
+namespace glm
+{
+
+}//namespace glm
diff --git a/engine/inc/glm/detail/type_quat.hpp b/engine/inc/glm/detail/type_quat.hpp
new file mode 100644
index 00000000..b49c2534
--- /dev/null
+++ b/engine/inc/glm/detail/type_quat.hpp
@@ -0,0 +1,190 @@
+/// @ref gtc_quaternion
+/// @file glm/gtc/quaternion.hpp
+///
+/// @see core (dependence)
+/// @see gtc_constants (dependence)
+///
+/// @defgroup gtc_quaternion GLM_GTC_quaternion
+/// @ingroup gtc
+///
+/// Include <glm/gtc/quaternion.hpp> to use the features of this extension.
+///
+/// Defines a templated quaternion type and several quaternion operations.
+
+#pragma once
+
+// Dependency:
+#include "../detail/type_mat3x3.hpp"
+#include "../detail/type_mat4x4.hpp"
+#include "../detail/type_vec3.hpp"
+#include "../detail/type_vec4.hpp"
+#include "../ext/vector_relational.hpp"
+#include "../ext/quaternion_relational.hpp"
+#include "../gtc/constants.hpp"
+#include "../gtc/matrix_transform.hpp"
+
+namespace glm
+{
+	/// @addtogroup gtc_quaternion
+	/// @{
+
+	template<typename T, qualifier Q>
+	struct qua
+	{
+		// -- Implementation detail --
+
+		typedef qua<T, Q> type;
+		typedef T value_type;
+
+		// -- Data --
+
+#		if GLM_SILENT_WARNINGS == GLM_ENABLE
+#			if GLM_COMPILER & GLM_COMPILER_GCC
+#				pragma GCC diagnostic push
+#				pragma GCC diagnostic ignored "-Wpedantic"
+#			elif GLM_COMPILER & GLM_COMPILER_CLANG
+#				pragma clang diagnostic push
+#				pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
+#				pragma clang diagnostic ignored "-Wnested-anon-types"
+#			elif GLM_COMPILER & GLM_COMPILER_VC
+#				pragma warning(push)
+#				pragma warning(disable: 4201)  // nonstandard extension used : nameless struct/union
+#			endif
+#		endif
+
+#		if GLM_LANG & GLM_LANG_CXXMS_FLAG
+			union
+			{
+				struct { T x, y, z, w;};
+
+				typename detail::storage<4, T, detail::is_aligned<Q>::value>::type data;
+			};
+#		else
+			T x, y, z, w;
+#		endif
+
+#		if GLM_SILENT_WARNINGS == GLM_ENABLE
+#			if GLM_COMPILER & GLM_COMPILER_CLANG
+#				pragma clang diagnostic pop
+#			elif GLM_COMPILER & GLM_COMPILER_GCC
+#				pragma GCC diagnostic pop
+#			elif GLM_COMPILER & GLM_COMPILER_VC
+#				pragma warning(pop)
+#			endif
+#		endif
+
+		// -- Component accesses --
+
+		typedef length_t length_type;
+		/// Return the count of components of a quaternion
+		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 4;}
+
+		GLM_FUNC_DECL GLM_CONSTEXPR T & operator[](length_type i);
+		GLM_FUNC_DECL GLM_CONSTEXPR T const& operator[](length_type i) const;
+
+		// -- Implicit basic constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR qua() GLM_DEFAULT;
+		GLM_FUNC_DECL GLM_CONSTEXPR qua(qua<T, Q> const& q) GLM_DEFAULT;
+		template<qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR qua(qua<T, P> const& q);
+
+		// -- Explicit basic constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR qua(T s, vec<3, T, Q> const& v);
+		GLM_FUNC_DECL GLM_CONSTEXPR qua(T w, T x, T y, T z);
+
+		// -- Conversion constructors --
+
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT qua(qua<U, P> const& q);
+
+		/// Explicit conversion operators
+#		if GLM_HAS_EXPLICIT_CONVERSION_OPERATORS
+			GLM_FUNC_DECL explicit operator mat<3, 3, T, Q>();
+			GLM_FUNC_DECL explicit operator mat<4, 4, T, Q>();
+#		endif
+
+		/// Create a quaternion from two normalized axis
+		///
+		/// @param u A first normalized axis
+		/// @param v A second normalized axis
+		/// @see gtc_quaternion
+		/// @see http://lolengine.net/blog/2013/09/18/beautiful-maths-quaternion-from-vectors
+		GLM_FUNC_DECL qua(vec<3, T, Q> const& u, vec<3, T, Q> const& v);
+
+		/// Build a quaternion from euler angles (pitch, yaw, roll), in radians.
+		GLM_FUNC_DECL GLM_EXPLICIT qua(vec<3, T, Q> const& eulerAngles);
+		GLM_FUNC_DECL GLM_EXPLICIT qua(mat<3, 3, T, Q> const& q);
+		GLM_FUNC_DECL GLM_EXPLICIT qua(mat<4, 4, T, Q> const& q);
+
+		// -- Unary arithmetic operators --
+
+		GLM_FUNC_DECL qua<T, Q>& operator=(qua<T, Q> const& q) GLM_DEFAULT;
+
+		template<typename U>
+		GLM_FUNC_DECL qua<T, Q>& operator=(qua<U, Q> const& q);
+		template<typename U>
+		GLM_FUNC_DECL qua<T, Q>& operator+=(qua<U, Q> const& q);
+		template<typename U>
+		GLM_FUNC_DECL qua<T, Q>& operator-=(qua<U, Q> const& q);
+		template<typename U>
+		GLM_FUNC_DECL qua<T, Q>& operator*=(qua<U, Q> const& q);
+		template<typename U>
+		GLM_FUNC_DECL qua<T, Q>& operator*=(U s);
+		template<typename U>
+		GLM_FUNC_DECL qua<T, Q>& operator/=(U s);
+	};
+
+	// -- Unary bit operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> operator+(qua<T, Q> const& q);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> operator-(qua<T, Q> const& q);
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> operator+(qua<T, Q> const& q, qua<T, Q> const& p);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> operator-(qua<T, Q> const& q, qua<T, Q> const& p);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> operator*(qua<T, Q> const& q, qua<T, Q> const& p);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> operator*(qua<T, Q> const& q, vec<3, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> operator*(vec<3, T, Q> const& v, qua<T, Q> const& q);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<4, T, Q> operator*(qua<T, Q> const& q, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<4, T, Q> operator*(vec<4, T, Q> const& v, qua<T, Q> const& q);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> operator*(qua<T, Q> const& q, T const& s);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> operator*(T const& s, qua<T, Q> const& q);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> operator/(qua<T, Q> const& q, T const& s);
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR bool operator==(qua<T, Q> const& q1, qua<T, Q> const& q2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR bool operator!=(qua<T, Q> const& q1, qua<T, Q> const& q2);
+
+	/// @}
+} //namespace glm
+
+#include "type_quat.inl"
diff --git a/engine/inc/glm/detail/type_quat.inl b/engine/inc/glm/detail/type_quat.inl
new file mode 100644
index 00000000..d9f63c67
--- /dev/null
+++ b/engine/inc/glm/detail/type_quat.inl
@@ -0,0 +1,379 @@
+#include "../trigonometric.hpp"
+#include "../exponential.hpp"
+#include "../ext/quaternion_geometric.hpp"
+#include <limits>
+
+namespace glm{
+namespace detail
+{
+	template <typename T>
+	struct genTypeTrait<qua<T> >
+	{
+		static const genTypeEnum GENTYPE = GENTYPE_QUAT;
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_dot<qua<T, Q>, T, Aligned>
+	{
+		static GLM_FUNC_QUALIFIER T call(qua<T, Q> const& a, qua<T, Q> const& b)
+		{
+			vec<4, T, Q> tmp(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w);
+			return (tmp.x + tmp.y) + (tmp.z + tmp.w);
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_quat_add
+	{
+		static qua<T, Q> call(qua<T, Q> const& q, qua<T, Q> const& p)
+		{
+			return qua<T, Q>(q.w + p.w, q.x + p.x, q.y + p.y, q.z + p.z);
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_quat_sub
+	{
+		static qua<T, Q> call(qua<T, Q> const& q, qua<T, Q> const& p)
+		{
+			return qua<T, Q>(q.w - p.w, q.x - p.x, q.y - p.y, q.z - p.z);
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_quat_mul_scalar
+	{
+		static qua<T, Q> call(qua<T, Q> const& q, T s)
+		{
+			return qua<T, Q>(q.w * s, q.x * s, q.y * s, q.z * s);
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_quat_div_scalar
+	{
+		static qua<T, Q> call(qua<T, Q> const& q, T s)
+		{
+			return qua<T, Q>(q.w / s, q.x / s, q.y / s, q.z / s);
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_quat_mul_vec4
+	{
+		static vec<4, T, Q> call(qua<T, Q> const& q, vec<4, T, Q> const& v)
+		{
+			return vec<4, T, Q>(q * vec<3, T, Q>(v), v.w);
+		}
+	};
+}//namespace detail
+
+	// -- Component accesses --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR T & qua<T, Q>::operator[](typename qua<T, Q>::length_type i)
+	{
+		assert(i >= 0 && i < this->length());
+		return (&x)[i];
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR T const& qua<T, Q>::operator[](typename qua<T, Q>::length_type i) const
+	{
+		assert(i >= 0 && i < this->length());
+		return (&x)[i];
+	}
+
+	// -- Implicit basic constructors --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q>::qua()
+#			if GLM_CONFIG_CTOR_INIT != GLM_CTOR_INIT_DISABLE
+			: x(0), y(0), z(0), w(1)
+#			endif
+		{}
+
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q>::qua(qua<T, Q> const& q)
+			: x(q.x), y(q.y), z(q.z), w(q.w)
+		{}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q>::qua(qua<T, P> const& q)
+		: x(q.x), y(q.y), z(q.z), w(q.w)
+	{}
+
+	// -- Explicit basic constructors --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q>::qua(T s, vec<3, T, Q> const& v)
+		: x(v.x), y(v.y), z(v.z), w(s)
+	{}
+
+	template <typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q>::qua(T _w, T _x, T _y, T _z)
+		: x(_x), y(_y), z(_z), w(_w)
+	{}
+
+	// -- Conversion constructors --
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q>::qua(qua<U, P> const& q)
+		: x(static_cast<T>(q.x))
+		, y(static_cast<T>(q.y))
+		, z(static_cast<T>(q.z))
+		, w(static_cast<T>(q.w))
+	{}
+
+	//template<typename valType>
+	//GLM_FUNC_QUALIFIER qua<valType>::qua
+	//(
+	//	valType const& pitch,
+	//	valType const& yaw,
+	//	valType const& roll
+	//)
+	//{
+	//	vec<3, valType> eulerAngle(pitch * valType(0.5), yaw * valType(0.5), roll * valType(0.5));
+	//	vec<3, valType> c = glm::cos(eulerAngle * valType(0.5));
+	//	vec<3, valType> s = glm::sin(eulerAngle * valType(0.5));
+	//
+	//	this->w = c.x * c.y * c.z + s.x * s.y * s.z;
+	//	this->x = s.x * c.y * c.z - c.x * s.y * s.z;
+	//	this->y = c.x * s.y * c.z + s.x * c.y * s.z;
+	//	this->z = c.x * c.y * s.z - s.x * s.y * c.z;
+	//}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q>::qua(vec<3, T, Q> const& u, vec<3, T, Q> const& v)
+	{
+		T norm_u_norm_v = sqrt(dot(u, u) * dot(v, v));
+		T real_part = norm_u_norm_v + dot(u, v);
+		vec<3, T, Q> t;
+
+		if(real_part < static_cast<T>(1.e-6f) * norm_u_norm_v)
+		{
+			// If u and v are exactly opposite, rotate 180 degrees
+			// around an arbitrary orthogonal axis. Axis normalisation
+			// can happen later, when we normalise the quaternion.
+			real_part = static_cast<T>(0);
+			t = abs(u.x) > abs(u.z) ? vec<3, T, Q>(-u.y, u.x, static_cast<T>(0)) : vec<3, T, Q>(static_cast<T>(0), -u.z, u.y);
+		}
+		else
+		{
+			// Otherwise, build quaternion the standard way.
+			t = cross(u, v);
+		}
+
+		*this = normalize(qua<T, Q>(real_part, t.x, t.y, t.z));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q>::qua(vec<3, T, Q> const& eulerAngle)
+	{
+		vec<3, T, Q> c = glm::cos(eulerAngle * T(0.5));
+		vec<3, T, Q> s = glm::sin(eulerAngle * T(0.5));
+
+		this->w = c.x * c.y * c.z + s.x * s.y * s.z;
+		this->x = s.x * c.y * c.z - c.x * s.y * s.z;
+		this->y = c.x * s.y * c.z + s.x * c.y * s.z;
+		this->z = c.x * c.y * s.z - s.x * s.y * c.z;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q>::qua(mat<3, 3, T, Q> const& m)
+	{
+		*this = quat_cast(m);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q>::qua(mat<4, 4, T, Q> const& m)
+	{
+		*this = quat_cast(m);
+	}
+
+#	if GLM_HAS_EXPLICIT_CONVERSION_OPERATORS
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q>::operator mat<3, 3, T, Q>()
+	{
+		return mat3_cast(*this);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q>::operator mat<4, 4, T, Q>()
+	{
+		return mat4_cast(*this);
+	}
+#	endif//GLM_HAS_EXPLICIT_CONVERSION_OPERATORS
+
+	// -- Unary arithmetic operators --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER qua<T, Q> & qua<T, Q>::operator=(qua<T, Q> const& q)
+		{
+			this->w = q.w;
+			this->x = q.x;
+			this->y = q.y;
+			this->z = q.z;
+			return *this;
+		}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER qua<T, Q> & qua<T, Q>::operator=(qua<U, Q> const& q)
+	{
+		this->w = static_cast<T>(q.w);
+		this->x = static_cast<T>(q.x);
+		this->y = static_cast<T>(q.y);
+		this->z = static_cast<T>(q.z);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER qua<T, Q> & qua<T, Q>::operator+=(qua<U, Q> const& q)
+	{
+		return (*this = detail::compute_quat_add<T, Q, detail::is_aligned<Q>::value>::call(*this, qua<T, Q>(q)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER qua<T, Q> & qua<T, Q>::operator-=(qua<U, Q> const& q)
+	{
+		return (*this = detail::compute_quat_sub<T, Q, detail::is_aligned<Q>::value>::call(*this, qua<T, Q>(q)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER qua<T, Q> & qua<T, Q>::operator*=(qua<U, Q> const& r)
+	{
+		qua<T, Q> const p(*this);
+		qua<T, Q> const q(r);
+
+		this->w = p.w * q.w - p.x * q.x - p.y * q.y - p.z * q.z;
+		this->x = p.w * q.x + p.x * q.w + p.y * q.z - p.z * q.y;
+		this->y = p.w * q.y + p.y * q.w + p.z * q.x - p.x * q.z;
+		this->z = p.w * q.z + p.z * q.w + p.x * q.y - p.y * q.x;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER qua<T, Q> & qua<T, Q>::operator*=(U s)
+	{
+		return (*this = detail::compute_quat_mul_scalar<T, Q, detail::is_aligned<Q>::value>::call(*this, static_cast<U>(s)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER qua<T, Q> & qua<T, Q>::operator/=(U s)
+	{
+		return (*this = detail::compute_quat_div_scalar<T, Q, detail::is_aligned<Q>::value>::call(*this, static_cast<U>(s)));
+	}
+
+	// -- Unary bit operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> operator+(qua<T, Q> const& q)
+	{
+		return q;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> operator-(qua<T, Q> const& q)
+	{
+		return qua<T, Q>(-q.w, -q.x, -q.y, -q.z);
+	}
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> operator+(qua<T, Q> const& q, qua<T, Q> const& p)
+	{
+		return qua<T, Q>(q) += p;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> operator-(qua<T, Q> const& q, qua<T, Q> const& p)
+	{
+		return qua<T, Q>(q) -= p;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> operator*(qua<T, Q> const& q, qua<T, Q> const& p)
+	{
+		return qua<T, Q>(q) *= p;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> operator*(qua<T, Q> const& q, vec<3, T, Q> const& v)
+	{
+		vec<3, T, Q> const QuatVector(q.x, q.y, q.z);
+		vec<3, T, Q> const uv(glm::cross(QuatVector, v));
+		vec<3, T, Q> const uuv(glm::cross(QuatVector, uv));
+
+		return v + ((uv * q.w) + uuv) * static_cast<T>(2);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> operator*(vec<3, T, Q> const& v, qua<T, Q> const& q)
+	{
+		return glm::inverse(q) * v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, T, Q> operator*(qua<T, Q> const& q, vec<4, T, Q> const& v)
+	{
+		return detail::compute_quat_mul_vec4<T, Q, detail::is_aligned<Q>::value>::call(q, v);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, T, Q> operator*(vec<4, T, Q> const& v, qua<T, Q> const& q)
+	{
+		return glm::inverse(q) * v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> operator*(qua<T, Q> const& q, T const& s)
+	{
+		return qua<T, Q>(
+			q.w * s, q.x * s, q.y * s, q.z * s);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> operator*(T const& s, qua<T, Q> const& q)
+	{
+		return q * s;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> operator/(qua<T, Q> const& q, T const& s)
+	{
+		return qua<T, Q>(
+			q.w / s, q.x / s, q.y / s, q.z / s);
+	}
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator==(qua<T, Q> const& q1, qua<T, Q> const& q2)
+	{
+		return q1.x == q2.x && q1.y == q2.y && q1.z == q2.z && q1.w == q2.w;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator!=(qua<T, Q> const& q1, qua<T, Q> const& q2)
+	{
+		return q1.x != q2.x || q1.y != q2.y || q1.z != q2.z || q1.w != q2.w;
+	}
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+#	include "type_quat_simd.inl"
+#endif
+
diff --git a/engine/inc/glm/detail/type_quat_simd.inl b/engine/inc/glm/detail/type_quat_simd.inl
new file mode 100644
index 00000000..3333e59f
--- /dev/null
+++ b/engine/inc/glm/detail/type_quat_simd.inl
@@ -0,0 +1,188 @@
+/// @ref core
+
+#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+namespace glm{
+namespace detail
+{
+/*
+	template<qualifier Q>
+	struct compute_quat_mul<float, Q, true>
+	{
+		static qua<float, Q> call(qua<float, Q> const& q1, qua<float, Q> const& q2)
+		{
+			// SSE2 STATS: 11 shuffle, 8 mul, 8 add
+			// SSE4 STATS: 3 shuffle, 4 mul, 4 dpps
+
+			__m128 const mul0 = _mm_mul_ps(q1.Data, _mm_shuffle_ps(q2.Data, q2.Data, _MM_SHUFFLE(0, 1, 2, 3)));
+			__m128 const mul1 = _mm_mul_ps(q1.Data, _mm_shuffle_ps(q2.Data, q2.Data, _MM_SHUFFLE(1, 0, 3, 2)));
+			__m128 const mul2 = _mm_mul_ps(q1.Data, _mm_shuffle_ps(q2.Data, q2.Data, _MM_SHUFFLE(2, 3, 0, 1)));
+			__m128 const mul3 = _mm_mul_ps(q1.Data, q2.Data);
+
+#			if GLM_ARCH & GLM_ARCH_SSE41_BIT
+				__m128 const add0 = _mm_dp_ps(mul0, _mm_set_ps(1.0f, -1.0f,  1.0f,  1.0f), 0xff);
+				__m128 const add1 = _mm_dp_ps(mul1, _mm_set_ps(1.0f,  1.0f,  1.0f, -1.0f), 0xff);
+				__m128 const add2 = _mm_dp_ps(mul2, _mm_set_ps(1.0f,  1.0f, -1.0f,  1.0f), 0xff);
+				__m128 const add3 = _mm_dp_ps(mul3, _mm_set_ps(1.0f, -1.0f, -1.0f, -1.0f), 0xff);
+#			else
+				__m128 const mul4 = _mm_mul_ps(mul0, _mm_set_ps(1.0f, -1.0f,  1.0f,  1.0f));
+				__m128 const add0 = _mm_add_ps(mul0, _mm_movehl_ps(mul4, mul4));
+				__m128 const add4 = _mm_add_ss(add0, _mm_shuffle_ps(add0, add0, 1));
+
+				__m128 const mul5 = _mm_mul_ps(mul1, _mm_set_ps(1.0f,  1.0f,  1.0f, -1.0f));
+				__m128 const add1 = _mm_add_ps(mul1, _mm_movehl_ps(mul5, mul5));
+				__m128 const add5 = _mm_add_ss(add1, _mm_shuffle_ps(add1, add1, 1));
+
+				__m128 const mul6 = _mm_mul_ps(mul2, _mm_set_ps(1.0f,  1.0f, -1.0f,  1.0f));
+				__m128 const add2 = _mm_add_ps(mul6, _mm_movehl_ps(mul6, mul6));
+				__m128 const add6 = _mm_add_ss(add2, _mm_shuffle_ps(add2, add2, 1));
+
+				__m128 const mul7 = _mm_mul_ps(mul3, _mm_set_ps(1.0f, -1.0f, -1.0f, -1.0f));
+				__m128 const add3 = _mm_add_ps(mul3, _mm_movehl_ps(mul7, mul7));
+				__m128 const add7 = _mm_add_ss(add3, _mm_shuffle_ps(add3, add3, 1));
+		#endif
+
+			// This SIMD code is a politically correct way of doing this, but in every test I've tried it has been slower than
+			// the final code below. I'll keep this here for reference - maybe somebody else can do something better...
+			//
+			//__m128 xxyy = _mm_shuffle_ps(add4, add5, _MM_SHUFFLE(0, 0, 0, 0));
+			//__m128 zzww = _mm_shuffle_ps(add6, add7, _MM_SHUFFLE(0, 0, 0, 0));
+			//
+			//return _mm_shuffle_ps(xxyy, zzww, _MM_SHUFFLE(2, 0, 2, 0));
+
+			qua<float, Q> Result;
+			_mm_store_ss(&Result.x, add4);
+			_mm_store_ss(&Result.y, add5);
+			_mm_store_ss(&Result.z, add6);
+			_mm_store_ss(&Result.w, add7);
+			return Result;
+		}
+	};
+*/
+
+	template<qualifier Q>
+	struct compute_quat_add<float, Q, true>
+	{
+		static qua<float, Q> call(qua<float, Q> const& q, qua<float, Q> const& p)
+		{
+			qua<float, Q> Result;
+			Result.data = _mm_add_ps(q.data, p.data);
+			return Result;
+		}
+	};
+
+#	if GLM_ARCH & GLM_ARCH_AVX_BIT
+	template<qualifier Q>
+	struct compute_quat_add<double, Q, true>
+	{
+		static qua<double, Q> call(qua<double, Q> const& a, qua<double, Q> const& b)
+		{
+			qua<double, Q> Result;
+			Result.data = _mm256_add_pd(a.data, b.data);
+			return Result;
+		}
+	};
+#	endif
+
+	template<qualifier Q>
+	struct compute_quat_sub<float, Q, true>
+	{
+		static qua<float, Q> call(qua<float, Q> const& q, qua<float, Q> const& p)
+		{
+			vec<4, float, Q> Result;
+			Result.data = _mm_sub_ps(q.data, p.data);
+			return Result;
+		}
+	};
+
+#	if GLM_ARCH & GLM_ARCH_AVX_BIT
+	template<qualifier Q>
+	struct compute_quat_sub<double, Q, true>
+	{
+		static qua<double, Q> call(qua<double, Q> const& a, qua<double, Q> const& b)
+		{
+			qua<double, Q> Result;
+			Result.data = _mm256_sub_pd(a.data, b.data);
+			return Result;
+		}
+	};
+#	endif
+
+	template<qualifier Q>
+	struct compute_quat_mul_scalar<float, Q, true>
+	{
+		static qua<float, Q> call(qua<float, Q> const& q, float s)
+		{
+			vec<4, float, Q> Result;
+			Result.data = _mm_mul_ps(q.data, _mm_set_ps1(s));
+			return Result;
+		}
+	};
+
+#	if GLM_ARCH & GLM_ARCH_AVX_BIT
+	template<qualifier Q>
+	struct compute_quat_mul_scalar<double, Q, true>
+	{
+		static qua<double, Q> call(qua<double, Q> const& q, double s)
+		{
+			qua<double, Q> Result;
+			Result.data = _mm256_mul_pd(q.data, _mm_set_ps1(s));
+			return Result;
+		}
+	};
+#	endif
+
+	template<qualifier Q>
+	struct compute_quat_div_scalar<float, Q, true>
+	{
+		static qua<float, Q> call(qua<float, Q> const& q, float s)
+		{
+			vec<4, float, Q> Result;
+			Result.data = _mm_div_ps(q.data, _mm_set_ps1(s));
+			return Result;
+		}
+	};
+
+#	if GLM_ARCH & GLM_ARCH_AVX_BIT
+	template<qualifier Q>
+	struct compute_quat_div_scalar<double, Q, true>
+	{
+		static qua<double, Q> call(qua<double, Q> const& q, double s)
+		{
+			qua<double, Q> Result;
+			Result.data = _mm256_div_pd(q.data, _mm_set_ps1(s));
+			return Result;
+		}
+	};
+#	endif
+
+	template<qualifier Q>
+	struct compute_quat_mul_vec4<float, Q, true>
+	{
+		static vec<4, float, Q> call(qua<float, Q> const& q, vec<4, float, Q> const& v)
+		{
+			__m128 const q_wwww = _mm_shuffle_ps(q.data, q.data, _MM_SHUFFLE(3, 3, 3, 3));
+			__m128 const q_swp0 = _mm_shuffle_ps(q.data, q.data, _MM_SHUFFLE(3, 0, 2, 1));
+			__m128 const q_swp1 = _mm_shuffle_ps(q.data, q.data, _MM_SHUFFLE(3, 1, 0, 2));
+			__m128 const v_swp0 = _mm_shuffle_ps(v.data, v.data, _MM_SHUFFLE(3, 0, 2, 1));
+			__m128 const v_swp1 = _mm_shuffle_ps(v.data, v.data, _MM_SHUFFLE(3, 1, 0, 2));
+
+			__m128 uv      = _mm_sub_ps(_mm_mul_ps(q_swp0, v_swp1), _mm_mul_ps(q_swp1, v_swp0));
+			__m128 uv_swp0 = _mm_shuffle_ps(uv, uv, _MM_SHUFFLE(3, 0, 2, 1));
+			__m128 uv_swp1 = _mm_shuffle_ps(uv, uv, _MM_SHUFFLE(3, 1, 0, 2));
+			__m128 uuv     = _mm_sub_ps(_mm_mul_ps(q_swp0, uv_swp1), _mm_mul_ps(q_swp1, uv_swp0));
+
+			__m128 const two = _mm_set1_ps(2.0f);
+			uv  = _mm_mul_ps(uv, _mm_mul_ps(q_wwww, two));
+			uuv = _mm_mul_ps(uuv, two);
+
+			vec<4, float, Q> Result;
+			Result.data = _mm_add_ps(v.Data, _mm_add_ps(uv, uuv));
+			return Result;
+		}
+	};
+}//namespace detail
+}//namespace glm
+
+#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
+
diff --git a/engine/inc/glm/detail/type_vec1.hpp b/engine/inc/glm/detail/type_vec1.hpp
new file mode 100644
index 00000000..51163f14
--- /dev/null
+++ b/engine/inc/glm/detail/type_vec1.hpp
@@ -0,0 +1,308 @@
+/// @ref core
+/// @file glm/detail/type_vec1.hpp
+
+#pragma once
+
+#include "qualifier.hpp"
+#if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+#	include "_swizzle.hpp"
+#elif GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+#	include "_swizzle_func.hpp"
+#endif
+#include <cstddef>
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	struct vec<1, T, Q>
+	{
+		// -- Implementation detail --
+
+		typedef T value_type;
+		typedef vec<1, T, Q> type;
+		typedef vec<1, bool, Q> bool_type;
+
+		// -- Data --
+
+#		if GLM_SILENT_WARNINGS == GLM_ENABLE
+#			if GLM_COMPILER & GLM_COMPILER_GCC
+#				pragma GCC diagnostic push
+#				pragma GCC diagnostic ignored "-Wpedantic"
+#			elif GLM_COMPILER & GLM_COMPILER_CLANG
+#				pragma clang diagnostic push
+#				pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
+#				pragma clang diagnostic ignored "-Wnested-anon-types"
+#			elif GLM_COMPILER & GLM_COMPILER_VC
+#				pragma warning(push)
+#				pragma warning(disable: 4201)  // nonstandard extension used : nameless struct/union
+#			endif
+#		endif
+
+#		if GLM_CONFIG_XYZW_ONLY
+			T x;
+#		elif GLM_CONFIG_ANONYMOUS_STRUCT == GLM_ENABLE
+			union
+			{
+				T x;
+				T r;
+				T s;
+
+				typename detail::storage<1, T, detail::is_aligned<Q>::value>::type data;
+/*
+#				if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+					_GLM_SWIZZLE1_2_MEMBERS(T, Q, x)
+					_GLM_SWIZZLE1_2_MEMBERS(T, Q, r)
+					_GLM_SWIZZLE1_2_MEMBERS(T, Q, s)
+					_GLM_SWIZZLE1_3_MEMBERS(T, Q, x)
+					_GLM_SWIZZLE1_3_MEMBERS(T, Q, r)
+					_GLM_SWIZZLE1_3_MEMBERS(T, Q, s)
+					_GLM_SWIZZLE1_4_MEMBERS(T, Q, x)
+					_GLM_SWIZZLE1_4_MEMBERS(T, Q, r)
+					_GLM_SWIZZLE1_4_MEMBERS(T, Q, s)
+#				endif
+*/
+			};
+#		else
+			union {T x, r, s;};
+/*
+#			if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+				GLM_SWIZZLE_GEN_VEC_FROM_VEC1(T, Q)
+#			endif
+*/
+#		endif
+
+#		if GLM_SILENT_WARNINGS == GLM_ENABLE
+#			if GLM_COMPILER & GLM_COMPILER_CLANG
+#				pragma clang diagnostic pop
+#			elif GLM_COMPILER & GLM_COMPILER_GCC
+#				pragma GCC diagnostic pop
+#			elif GLM_COMPILER & GLM_COMPILER_VC
+#				pragma warning(pop)
+#			endif
+#		endif
+
+		// -- Component accesses --
+
+		/// Return the count of components of the vector
+		typedef length_t length_type;
+		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 1;}
+
+		GLM_FUNC_DECL GLM_CONSTEXPR T & operator[](length_type i);
+		GLM_FUNC_DECL GLM_CONSTEXPR T const& operator[](length_type i) const;
+
+		// -- Implicit basic constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR vec() GLM_DEFAULT;
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec const& v) GLM_DEFAULT;
+		template<qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, T, P> const& v);
+
+		// -- Explicit basic constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(T scalar);
+
+		// -- Conversion vector constructors --
+
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<2, U, P> const& v);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<3, U, P> const& v);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<4, U, P> const& v);
+
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<1, U, P> const& v);
+
+		// -- Swizzle constructors --
+/*
+#		if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+			template<int E0>
+			GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<1, T, Q, E0, -1,-2,-3> const& that)
+			{
+				*this = that();
+			}
+#		endif//GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+*/
+		// -- Unary arithmetic operators --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator=(vec const& v) GLM_DEFAULT;
+
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator+=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator+=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator-=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator-=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator*=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator*=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator/=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator/=(vec<1, U, Q> const& v);
+
+		// -- Increment and decrement operators --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator++();
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator--();
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator++(int);
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator--(int);
+
+		// -- Unary bit operators --
+
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator%=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator%=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator&=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator&=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator|=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator|=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator^=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator^=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator<<=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator<<=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator>>=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator>>=(vec<1, U, Q> const& v);
+	};
+
+	// -- Unary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator+(vec<1, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator-(vec<1, T, Q> const& v);
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator+(vec<1, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator+(T scalar, vec<1, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator+(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator-(vec<1, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator-(T scalar, vec<1, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator-(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator*(vec<1, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator*(T scalar, vec<1, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator*(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator/(vec<1, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator/(T scalar, vec<1, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator/(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator%(vec<1, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator%(T scalar, vec<1, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator%(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator&(vec<1, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator&(T scalar, vec<1, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator&(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator|(vec<1, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator|(T scalar, vec<1, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator|(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator^(vec<1, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator^(T scalar, vec<1, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator^(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator<<(vec<1, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator<<(T scalar, vec<1, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator<<(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator>>(vec<1, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator>>(T scalar, vec<1, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator>>(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator~(vec<1, T, Q> const& v);
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR bool operator==(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR bool operator!=(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, bool, Q> operator&&(vec<1, bool, Q> const& v1, vec<1, bool, Q> const& v2);
+
+	template<qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<1, bool, Q> operator||(vec<1, bool, Q> const& v1, vec<1, bool, Q> const& v2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_vec1.inl"
+#endif//GLM_EXTERNAL_TEMPLATE
diff --git a/engine/inc/glm/detail/type_vec1.inl b/engine/inc/glm/detail/type_vec1.inl
new file mode 100644
index 00000000..d0f49fd3
--- /dev/null
+++ b/engine/inc/glm/detail/type_vec1.inl
@@ -0,0 +1,551 @@
+/// @ref core
+
+#include "./compute_vector_relational.hpp"
+
+namespace glm
+{
+	// -- Implicit basic constructors --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec()
+#			if GLM_CONFIG_CTOR_INIT != GLM_CTOR_INIT_DISABLE
+				: x(0)
+#			endif
+		{}
+
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(vec<1, T, Q> const& v)
+			: x(v.x)
+		{}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(vec<1, T, P> const& v)
+		: x(v.x)
+	{}
+
+	// -- Explicit basic constructors --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(T scalar)
+		: x(scalar)
+	{}
+
+	// -- Conversion vector constructors --
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(vec<1, U, P> const& v)
+		: x(static_cast<T>(v.x))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(vec<2, U, P> const& v)
+		: x(static_cast<T>(v.x))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(vec<3, U, P> const& v)
+		: x(static_cast<T>(v.x))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(vec<4, U, P> const& v)
+		: x(static_cast<T>(v.x))
+	{}
+
+	// -- Component accesses --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR T & vec<1, T, Q>::operator[](typename vec<1, T, Q>::length_type)
+	{
+		return x;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR T const& vec<1, T, Q>::operator[](typename vec<1, T, Q>::length_type) const
+	{
+		return x;
+	}
+
+	// -- Unary arithmetic operators --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator=(vec<1, T, Q> const& v)
+		{
+			this->x = v.x;
+			return *this;
+		}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator=(vec<1, U, Q> const& v)
+	{
+		this->x = static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator+=(U scalar)
+	{
+		this->x += static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator+=(vec<1, U, Q> const& v)
+	{
+		this->x += static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator-=(U scalar)
+	{
+		this->x -= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator-=(vec<1, U, Q> const& v)
+	{
+		this->x -= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator*=(U scalar)
+	{
+		this->x *= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator*=(vec<1, U, Q> const& v)
+	{
+		this->x *= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator/=(U scalar)
+	{
+		this->x /= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator/=(vec<1, U, Q> const& v)
+	{
+		this->x /= static_cast<T>(v.x);
+		return *this;
+	}
+
+	// -- Increment and decrement operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator++()
+	{
+		++this->x;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator--()
+	{
+		--this->x;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> vec<1, T, Q>::operator++(int)
+	{
+		vec<1, T, Q> Result(*this);
+		++*this;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> vec<1, T, Q>::operator--(int)
+	{
+		vec<1, T, Q> Result(*this);
+		--*this;
+		return Result;
+	}
+
+	// -- Unary bit operators --
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator%=(U scalar)
+	{
+		this->x %= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator%=(vec<1, U, Q> const& v)
+	{
+		this->x %= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator&=(U scalar)
+	{
+		this->x &= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator&=(vec<1, U, Q> const& v)
+	{
+		this->x &= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator|=(U scalar)
+	{
+		this->x |= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator|=(vec<1, U, Q> const& v)
+	{
+		this->x |= U(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator^=(U scalar)
+	{
+		this->x ^= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator^=(vec<1, U, Q> const& v)
+	{
+		this->x ^= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator<<=(U scalar)
+	{
+		this->x <<= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator<<=(vec<1, U, Q> const& v)
+	{
+		this->x <<= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator>>=(U scalar)
+	{
+		this->x >>= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator>>=(vec<1, U, Q> const& v)
+	{
+		this->x >>= static_cast<T>(v.x);
+		return *this;
+	}
+
+	// -- Unary constant operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator+(vec<1, T, Q> const& v)
+	{
+		return v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator-(vec<1, T, Q> const& v)
+	{
+		return vec<1, T, Q>(
+			-v.x);
+	}
+
+	// -- Binary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator+(vec<1, T, Q> const& v, T scalar)
+	{
+		return vec<1, T, Q>(
+			v.x + scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator+(T scalar, vec<1, T, Q> const& v)
+	{
+		return vec<1, T, Q>(
+			scalar + v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator+(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<1, T, Q>(
+			v1.x + v2.x);
+	}
+
+	//operator-
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator-(vec<1, T, Q> const& v, T scalar)
+	{
+		return vec<1, T, Q>(
+			v.x - scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator-(T scalar, vec<1, T, Q> const& v)
+	{
+		return vec<1, T, Q>(
+			scalar - v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator-(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<1, T, Q>(
+			v1.x - v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator*(vec<1, T, Q> const& v, T scalar)
+	{
+		return vec<1, T, Q>(
+			v.x * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator*(T scalar, vec<1, T, Q> const& v)
+	{
+		return vec<1, T, Q>(
+			scalar * v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator*(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<1, T, Q>(
+			v1.x * v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator/(vec<1, T, Q> const& v, T scalar)
+	{
+		return vec<1, T, Q>(
+			v.x / scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator/(T scalar, vec<1, T, Q> const& v)
+	{
+		return vec<1, T, Q>(
+			scalar / v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator/(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<1, T, Q>(
+			v1.x / v2.x);
+	}
+
+	// -- Binary bit operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator%(vec<1, T, Q> const& v, T scalar)
+	{
+		return vec<1, T, Q>(
+			v.x % scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator%(T scalar, vec<1, T, Q> const& v)
+	{
+		return vec<1, T, Q>(
+			scalar % v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator%(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<1, T, Q>(
+			v1.x % v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator&(vec<1, T, Q> const& v, T scalar)
+	{
+		return vec<1, T, Q>(
+			v.x & scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator&(T scalar, vec<1, T, Q> const& v)
+	{
+		return vec<1, T, Q>(
+			scalar & v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator&(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<1, T, Q>(
+			v1.x & v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator|(vec<1, T, Q> const& v, T scalar)
+	{
+		return vec<1, T, Q>(
+			v.x | scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator|(T scalar, vec<1, T, Q> const& v)
+	{
+		return vec<1, T, Q>(
+			scalar | v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator|(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<1, T, Q>(
+			v1.x | v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator^(vec<1, T, Q> const& v, T scalar)
+	{
+		return vec<1, T, Q>(
+			v.x ^ scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator^(T scalar, vec<1, T, Q> const& v)
+	{
+		return vec<1, T, Q>(
+			scalar ^ v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator^(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<1, T, Q>(
+			v1.x ^ v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator<<(vec<1, T, Q> const& v, T scalar)
+	{
+		return vec<1, T, Q>(
+			static_cast<T>(v.x << scalar));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator<<(T scalar, vec<1, T, Q> const& v)
+	{
+		return vec<1, T, Q>(
+			scalar << v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator<<(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<1, T, Q>(
+			v1.x << v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator>>(vec<1, T, Q> const& v, T scalar)
+	{
+		return vec<1, T, Q>(
+			v.x >> scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator>>(T scalar, vec<1, T, Q> const& v)
+	{
+		return vec<1, T, Q>(
+			scalar >> v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator>>(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<1, T, Q>(
+			v1.x >> v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator~(vec<1, T, Q> const& v)
+	{
+		return vec<1, T, Q>(
+			~v.x);
+	}
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator==(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return detail::compute_equal<T, std::numeric_limits<T>::is_iec559>::call(v1.x, v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator!=(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return !(v1 == v2);
+	}
+
+	template<qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, bool, Q> operator&&(vec<1, bool, Q> const& v1, vec<1, bool, Q> const& v2)
+	{
+		return vec<1, bool, Q>(v1.x && v2.x);
+	}
+
+	template<qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, bool, Q> operator||(vec<1, bool, Q> const& v1, vec<1, bool, Q> const& v2)
+	{
+		return vec<1, bool, Q>(v1.x || v2.x);
+	}
+}//namespace glm
diff --git a/engine/inc/glm/detail/type_vec2.hpp b/engine/inc/glm/detail/type_vec2.hpp
new file mode 100644
index 00000000..52ef408e
--- /dev/null
+++ b/engine/inc/glm/detail/type_vec2.hpp
@@ -0,0 +1,399 @@
+/// @ref core
+/// @file glm/detail/type_vec2.hpp
+
+#pragma once
+
+#include "qualifier.hpp"
+#if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+#	include "_swizzle.hpp"
+#elif GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+#	include "_swizzle_func.hpp"
+#endif
+#include <cstddef>
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	struct vec<2, T, Q>
+	{
+		// -- Implementation detail --
+
+		typedef T value_type;
+		typedef vec<2, T, Q> type;
+		typedef vec<2, bool, Q> bool_type;
+
+		// -- Data --
+
+#		if GLM_SILENT_WARNINGS == GLM_ENABLE
+#			if GLM_COMPILER & GLM_COMPILER_GCC
+#				pragma GCC diagnostic push
+#				pragma GCC diagnostic ignored "-Wpedantic"
+#			elif GLM_COMPILER & GLM_COMPILER_CLANG
+#				pragma clang diagnostic push
+#				pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
+#				pragma clang diagnostic ignored "-Wnested-anon-types"
+#			elif GLM_COMPILER & GLM_COMPILER_VC
+#				pragma warning(push)
+#				pragma warning(disable: 4201)  // nonstandard extension used : nameless struct/union
+#			endif
+#		endif
+
+#		if GLM_CONFIG_XYZW_ONLY
+			T x, y;
+#		elif GLM_CONFIG_ANONYMOUS_STRUCT == GLM_ENABLE
+			union
+			{
+				struct{ T x, y; };
+				struct{ T r, g; };
+				struct{ T s, t; };
+
+				typename detail::storage<2, T, detail::is_aligned<Q>::value>::type data;
+
+#				if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+					GLM_SWIZZLE2_2_MEMBERS(T, Q, x, y)
+					GLM_SWIZZLE2_2_MEMBERS(T, Q, r, g)
+					GLM_SWIZZLE2_2_MEMBERS(T, Q, s, t)
+					GLM_SWIZZLE2_3_MEMBERS(T, Q, x, y)
+					GLM_SWIZZLE2_3_MEMBERS(T, Q, r, g)
+					GLM_SWIZZLE2_3_MEMBERS(T, Q, s, t)
+					GLM_SWIZZLE2_4_MEMBERS(T, Q, x, y)
+					GLM_SWIZZLE2_4_MEMBERS(T, Q, r, g)
+					GLM_SWIZZLE2_4_MEMBERS(T, Q, s, t)
+#				endif
+			};
+#		else
+			union {T x, r, s;};
+			union {T y, g, t;};
+
+#			if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+				GLM_SWIZZLE_GEN_VEC_FROM_VEC2(T, Q)
+#			endif//GLM_CONFIG_SWIZZLE
+#		endif
+
+#		if GLM_SILENT_WARNINGS == GLM_ENABLE
+#			if GLM_COMPILER & GLM_COMPILER_CLANG
+#				pragma clang diagnostic pop
+#			elif GLM_COMPILER & GLM_COMPILER_GCC
+#				pragma GCC diagnostic pop
+#			elif GLM_COMPILER & GLM_COMPILER_VC
+#				pragma warning(pop)
+#			endif
+#		endif
+
+		// -- Component accesses --
+
+		/// Return the count of components of the vector
+		typedef length_t length_type;
+		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 2;}
+
+		GLM_FUNC_DECL GLM_CONSTEXPR T& operator[](length_type i);
+		GLM_FUNC_DECL GLM_CONSTEXPR T const& operator[](length_type i) const;
+
+		// -- Implicit basic constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR vec() GLM_DEFAULT;
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec const& v) GLM_DEFAULT;
+		template<qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, T, P> const& v);
+
+		// -- Explicit basic constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(T x, T y);
+
+		// -- Conversion constructors --
+
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(vec<1, U, P> const& v);
+
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(A x, B y);
+		template<typename A, typename B>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, Q> const& x, B y);
+		template<typename A, typename B>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(A x, vec<1, B, Q> const& y);
+		template<typename A, typename B>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, Q> const& x, vec<1, B, Q> const& y);
+
+		// -- Conversion vector constructors --
+
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<3, U, P> const& v);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<4, U, P> const& v);
+
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<2, U, P> const& v);
+
+		// -- Swizzle constructors --
+#		if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+			template<int E0, int E1>
+			GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<2, T, Q, E0, E1,-1,-2> const& that)
+			{
+				*this = that();
+			}
+#		endif//GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+
+		// -- Unary arithmetic operators --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator=(vec const& v) GLM_DEFAULT;
+
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator=(vec<2, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator+=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator+=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator+=(vec<2, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator-=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator-=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator-=(vec<2, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator*=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator*=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator*=(vec<2, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator/=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator/=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator/=(vec<2, U, Q> const& v);
+
+		// -- Increment and decrement operators --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator++();
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator--();
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator++(int);
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator--(int);
+
+		// -- Unary bit operators --
+
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator%=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator%=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator%=(vec<2, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator&=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator&=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator&=(vec<2, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator|=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator|=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator|=(vec<2, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator^=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator^=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator^=(vec<2, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator<<=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator<<=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator<<=(vec<2, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator>>=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator>>=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator>>=(vec<2, U, Q> const& v);
+	};
+
+	// -- Unary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v);
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator+(T scalar, vec<2, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator+(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator-(T scalar, vec<2, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator-(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator*(vec<2, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator*(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator*(T scalar, vec<2, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator*(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator*(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator/(vec<2, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator/(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator/(T scalar, vec<2, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator/(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator/(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator%(vec<2, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator%(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator%(T scalar, vec<2, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator%(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator%(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator&(vec<2, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator&(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator&(T scalar, vec<2, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator&(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator&(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator|(vec<2, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator|(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator|(T scalar, vec<2, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator|(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator|(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator^(vec<2, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator^(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator^(T scalar, vec<2, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator^(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator^(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<2, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator<<(T scalar, vec<2, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<2, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator>>(T scalar, vec<2, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator~(vec<2, T, Q> const& v);
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR bool operator==(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR bool operator!=(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+	template<qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, bool, Q> operator&&(vec<2, bool, Q> const& v1, vec<2, bool, Q> const& v2);
+
+	template<qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<2, bool, Q> operator||(vec<2, bool, Q> const& v1, vec<2, bool, Q> const& v2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_vec2.inl"
+#endif//GLM_EXTERNAL_TEMPLATE
diff --git a/engine/inc/glm/detail/type_vec2.inl b/engine/inc/glm/detail/type_vec2.inl
new file mode 100644
index 00000000..8e65d6bb
--- /dev/null
+++ b/engine/inc/glm/detail/type_vec2.inl
@@ -0,0 +1,913 @@
+/// @ref core
+
+#include "./compute_vector_relational.hpp"
+
+namespace glm
+{
+	// -- Implicit basic constructors --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec()
+#			if GLM_CONFIG_CTOR_INIT != GLM_CTOR_INIT_DISABLE
+				: x(0), y(0)
+#			endif
+		{}
+
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<2, T, Q> const& v)
+			: x(v.x), y(v.y)
+		{}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<2, T, P> const& v)
+		: x(v.x), y(v.y)
+	{}
+
+	// -- Explicit basic constructors --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(T scalar)
+		: x(scalar), y(scalar)
+	{}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(T _x, T _y)
+		: x(_x), y(_y)
+	{}
+
+	// -- Conversion scalar constructors --
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<1, U, P> const& v)
+		: x(static_cast<T>(v.x))
+		, y(static_cast<T>(v.x))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename A, typename B>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(A _x, B _y)
+		: x(static_cast<T>(_x))
+		, y(static_cast<T>(_y))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename A, typename B>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<1, A, Q> const& _x, B _y)
+		: x(static_cast<T>(_x.x))
+		, y(static_cast<T>(_y))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename A, typename B>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(A _x, vec<1, B, Q> const& _y)
+		: x(static_cast<T>(_x))
+		, y(static_cast<T>(_y.x))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename A, typename B>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<1, A, Q> const& _x, vec<1, B, Q> const& _y)
+		: x(static_cast<T>(_x.x))
+		, y(static_cast<T>(_y.x))
+	{}
+
+	// -- Conversion vector constructors --
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<2, U, P> const& v)
+		: x(static_cast<T>(v.x))
+		, y(static_cast<T>(v.y))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<3, U, P> const& v)
+		: x(static_cast<T>(v.x))
+		, y(static_cast<T>(v.y))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<4, U, P> const& v)
+		: x(static_cast<T>(v.x))
+		, y(static_cast<T>(v.y))
+	{}
+
+	// -- Component accesses --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR T & vec<2, T, Q>::operator[](typename vec<2, T, Q>::length_type i)
+	{
+		assert(i >= 0 && i < this->length());
+		switch(i)
+		{
+		default:
+		case 0:
+			return x;
+		case 1:
+			return y;
+		}
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR T const& vec<2, T, Q>::operator[](typename vec<2, T, Q>::length_type i) const
+	{
+		assert(i >= 0 && i < this->length());
+		switch(i)
+		{
+		default:
+		case 0:
+			return x;
+		case 1:
+			return y;
+		}
+	}
+
+	// -- Unary arithmetic operators --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator=(vec<2, T, Q> const& v)
+		{
+			this->x = v.x;
+			this->y = v.y;
+			return *this;
+		}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator=(vec<2, U, Q> const& v)
+	{
+		this->x = static_cast<T>(v.x);
+		this->y = static_cast<T>(v.y);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator+=(U scalar)
+	{
+		this->x += static_cast<T>(scalar);
+		this->y += static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator+=(vec<1, U, Q> const& v)
+	{
+		this->x += static_cast<T>(v.x);
+		this->y += static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator+=(vec<2, U, Q> const& v)
+	{
+		this->x += static_cast<T>(v.x);
+		this->y += static_cast<T>(v.y);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator-=(U scalar)
+	{
+		this->x -= static_cast<T>(scalar);
+		this->y -= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator-=(vec<1, U, Q> const& v)
+	{
+		this->x -= static_cast<T>(v.x);
+		this->y -= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator-=(vec<2, U, Q> const& v)
+	{
+		this->x -= static_cast<T>(v.x);
+		this->y -= static_cast<T>(v.y);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator*=(U scalar)
+	{
+		this->x *= static_cast<T>(scalar);
+		this->y *= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator*=(vec<1, U, Q> const& v)
+	{
+		this->x *= static_cast<T>(v.x);
+		this->y *= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator*=(vec<2, U, Q> const& v)
+	{
+		this->x *= static_cast<T>(v.x);
+		this->y *= static_cast<T>(v.y);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator/=(U scalar)
+	{
+		this->x /= static_cast<T>(scalar);
+		this->y /= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator/=(vec<1, U, Q> const& v)
+	{
+		this->x /= static_cast<T>(v.x);
+		this->y /= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator/=(vec<2, U, Q> const& v)
+	{
+		this->x /= static_cast<T>(v.x);
+		this->y /= static_cast<T>(v.y);
+		return *this;
+	}
+
+	// -- Increment and decrement operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator++()
+	{
+		++this->x;
+		++this->y;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator--()
+	{
+		--this->x;
+		--this->y;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> vec<2, T, Q>::operator++(int)
+	{
+		vec<2, T, Q> Result(*this);
+		++*this;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> vec<2, T, Q>::operator--(int)
+	{
+		vec<2, T, Q> Result(*this);
+		--*this;
+		return Result;
+	}
+
+	// -- Unary bit operators --
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator%=(U scalar)
+	{
+		this->x %= static_cast<T>(scalar);
+		this->y %= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator%=(vec<1, U, Q> const& v)
+	{
+		this->x %= static_cast<T>(v.x);
+		this->y %= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator%=(vec<2, U, Q> const& v)
+	{
+		this->x %= static_cast<T>(v.x);
+		this->y %= static_cast<T>(v.y);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator&=(U scalar)
+	{
+		this->x &= static_cast<T>(scalar);
+		this->y &= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator&=(vec<1, U, Q> const& v)
+	{
+		this->x &= static_cast<T>(v.x);
+		this->y &= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator&=(vec<2, U, Q> const& v)
+	{
+		this->x &= static_cast<T>(v.x);
+		this->y &= static_cast<T>(v.y);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator|=(U scalar)
+	{
+		this->x |= static_cast<T>(scalar);
+		this->y |= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator|=(vec<1, U, Q> const& v)
+	{
+		this->x |= static_cast<T>(v.x);
+		this->y |= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator|=(vec<2, U, Q> const& v)
+	{
+		this->x |= static_cast<T>(v.x);
+		this->y |= static_cast<T>(v.y);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator^=(U scalar)
+	{
+		this->x ^= static_cast<T>(scalar);
+		this->y ^= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator^=(vec<1, U, Q> const& v)
+	{
+		this->x ^= static_cast<T>(v.x);
+		this->y ^= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator^=(vec<2, U, Q> const& v)
+	{
+		this->x ^= static_cast<T>(v.x);
+		this->y ^= static_cast<T>(v.y);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator<<=(U scalar)
+	{
+		this->x <<= static_cast<T>(scalar);
+		this->y <<= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator<<=(vec<1, U, Q> const& v)
+	{
+		this->x <<= static_cast<T>(v.x);
+		this->y <<= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator<<=(vec<2, U, Q> const& v)
+	{
+		this->x <<= static_cast<T>(v.x);
+		this->y <<= static_cast<T>(v.y);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator>>=(U scalar)
+	{
+		this->x >>= static_cast<T>(scalar);
+		this->y >>= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator>>=(vec<1, U, Q> const& v)
+	{
+		this->x >>= static_cast<T>(v.x);
+		this->y >>= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator>>=(vec<2, U, Q> const& v)
+	{
+		this->x >>= static_cast<T>(v.x);
+		this->y >>= static_cast<T>(v.y);
+		return *this;
+	}
+
+	// -- Unary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v)
+	{
+		return v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v)
+	{
+		return vec<2, T, Q>(
+			-v.x,
+			-v.y);
+	}
+
+	// -- Binary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v, T scalar)
+	{
+		return vec<2, T, Q>(
+			v.x + scalar,
+			v.y + scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x + v2.x,
+			v1.y + v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator+(T scalar, vec<2, T, Q> const& v)
+	{
+		return vec<2, T, Q>(
+			scalar + v.x,
+			scalar + v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator+(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x + v2.x,
+			v1.x + v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x + v2.x,
+			v1.y + v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v, T scalar)
+	{
+		return vec<2, T, Q>(
+			v.x - scalar,
+			v.y - scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x - v2.x,
+			v1.y - v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator-(T scalar, vec<2, T, Q> const& v)
+	{
+		return vec<2, T, Q>(
+			scalar - v.x,
+			scalar - v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator-(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x - v2.x,
+			v1.x - v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x - v2.x,
+			v1.y - v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator*(vec<2, T, Q> const& v, T scalar)
+	{
+		return vec<2, T, Q>(
+			v.x * scalar,
+			v.y * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator*(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x * v2.x,
+			v1.y * v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator*(T scalar, vec<2, T, Q> const& v)
+	{
+		return vec<2, T, Q>(
+			scalar * v.x,
+			scalar * v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator*(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x * v2.x,
+			v1.x * v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator*(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x * v2.x,
+			v1.y * v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator/(vec<2, T, Q> const& v, T scalar)
+	{
+		return vec<2, T, Q>(
+			v.x / scalar,
+			v.y / scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator/(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x / v2.x,
+			v1.y / v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator/(T scalar, vec<2, T, Q> const& v)
+	{
+		return vec<2, T, Q>(
+			scalar / v.x,
+			scalar / v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator/(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x / v2.x,
+			v1.x / v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator/(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x / v2.x,
+			v1.y / v2.y);
+	}
+
+	// -- Binary bit operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator%(vec<2, T, Q> const& v, T scalar)
+	{
+		return vec<2, T, Q>(
+			v.x % scalar,
+			v.y % scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator%(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x % v2.x,
+			v1.y % v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator%(T scalar, vec<2, T, Q> const& v)
+	{
+		return vec<2, T, Q>(
+			scalar % v.x,
+			scalar % v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator%(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x % v2.x,
+			v1.x % v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator%(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x % v2.x,
+			v1.y % v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator&(vec<2, T, Q> const& v, T scalar)
+	{
+		return vec<2, T, Q>(
+			v.x & scalar,
+			v.y & scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator&(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x & v2.x,
+			v1.y & v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator&(T scalar, vec<2, T, Q> const& v)
+	{
+		return vec<2, T, Q>(
+			scalar & v.x,
+			scalar & v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator&(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x & v2.x,
+			v1.x & v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator&(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x & v2.x,
+			v1.y & v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator|(vec<2, T, Q> const& v, T scalar)
+	{
+		return vec<2, T, Q>(
+			v.x | scalar,
+			v.y | scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator|(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x | v2.x,
+			v1.y | v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator|(T scalar, vec<2, T, Q> const& v)
+	{
+		return vec<2, T, Q>(
+			scalar | v.x,
+			scalar | v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator|(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x | v2.x,
+			v1.x | v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator|(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x | v2.x,
+			v1.y | v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator^(vec<2, T, Q> const& v, T scalar)
+	{
+		return vec<2, T, Q>(
+			v.x ^ scalar,
+			v.y ^ scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator^(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x ^ v2.x,
+			v1.y ^ v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator^(T scalar, vec<2, T, Q> const& v)
+	{
+		return vec<2, T, Q>(
+			scalar ^ v.x,
+			scalar ^ v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator^(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x ^ v2.x,
+			v1.x ^ v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator^(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x ^ v2.x,
+			v1.y ^ v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<2, T, Q> const& v, T scalar)
+	{
+		return vec<2, T, Q>(
+			v.x << scalar,
+			v.y << scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x << v2.x,
+			v1.y << v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator<<(T scalar, vec<2, T, Q> const& v)
+	{
+		return vec<2, T, Q>(
+			scalar << v.x,
+			scalar << v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x << v2.x,
+			v1.x << v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x << v2.x,
+			v1.y << v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<2, T, Q> const& v, T scalar)
+	{
+		return vec<2, T, Q>(
+			v.x >> scalar,
+			v.y >> scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x >> v2.x,
+			v1.y >> v2.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator>>(T scalar, vec<2, T, Q> const& v)
+	{
+		return vec<2, T, Q>(
+			scalar >> v.x,
+			scalar >> v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x >> v2.x,
+			v1.x >> v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return vec<2, T, Q>(
+			v1.x >> v2.x,
+			v1.y >> v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator~(vec<2, T, Q> const& v)
+	{
+		return vec<2, T, Q>(
+			~v.x,
+			~v.y);
+	}
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator==(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return
+			detail::compute_equal<T, std::numeric_limits<T>::is_iec559>::call(v1.x, v2.x) &&
+			detail::compute_equal<T, std::numeric_limits<T>::is_iec559>::call(v1.y, v2.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator!=(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+	{
+		return !(v1 == v2);
+	}
+
+	template<qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, bool, Q> operator&&(vec<2, bool, Q> const& v1, vec<2, bool, Q> const& v2)
+	{
+		return vec<2, bool, Q>(v1.x && v2.x, v1.y && v2.y);
+	}
+
+	template<qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, bool, Q> operator||(vec<2, bool, Q> const& v1, vec<2, bool, Q> const& v2)
+	{
+		return vec<2, bool, Q>(v1.x || v2.x, v1.y || v2.y);
+	}
+}//namespace glm
diff --git a/engine/inc/glm/detail/type_vec3.hpp b/engine/inc/glm/detail/type_vec3.hpp
new file mode 100644
index 00000000..d83cde67
--- /dev/null
+++ b/engine/inc/glm/detail/type_vec3.hpp
@@ -0,0 +1,432 @@
+/// @ref core
+/// @file glm/detail/type_vec3.hpp
+
+#pragma once
+
+#include "qualifier.hpp"
+#if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+#	include "_swizzle.hpp"
+#elif GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+#	include "_swizzle_func.hpp"
+#endif
+#include <cstddef>
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	struct vec<3, T, Q>
+	{
+		// -- Implementation detail --
+
+		typedef T value_type;
+		typedef vec<3, T, Q> type;
+		typedef vec<3, bool, Q> bool_type;
+
+		// -- Data --
+
+#		if GLM_SILENT_WARNINGS == GLM_ENABLE
+#			if GLM_COMPILER & GLM_COMPILER_GCC
+#				pragma GCC diagnostic push
+#				pragma GCC diagnostic ignored "-Wpedantic"
+#			elif GLM_COMPILER & GLM_COMPILER_CLANG
+#				pragma clang diagnostic push
+#				pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
+#				pragma clang diagnostic ignored "-Wnested-anon-types"
+#			elif GLM_COMPILER & GLM_COMPILER_VC
+#				pragma warning(push)
+#				pragma warning(disable: 4201)  // nonstandard extension used : nameless struct/union
+#				if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE
+#					pragma warning(disable: 4324)  // structure was padded due to alignment specifier
+#				endif
+#			endif
+#		endif
+
+#		if GLM_CONFIG_XYZW_ONLY
+			T x, y, z;
+#		elif GLM_CONFIG_ANONYMOUS_STRUCT == GLM_ENABLE
+			union
+			{
+				struct{ T x, y, z; };
+				struct{ T r, g, b; };
+				struct{ T s, t, p; };
+
+				typename detail::storage<3, T, detail::is_aligned<Q>::value>::type data;
+
+#				if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+					GLM_SWIZZLE3_2_MEMBERS(T, Q, x, y, z)
+					GLM_SWIZZLE3_2_MEMBERS(T, Q, r, g, b)
+					GLM_SWIZZLE3_2_MEMBERS(T, Q, s, t, p)
+					GLM_SWIZZLE3_3_MEMBERS(T, Q, x, y, z)
+					GLM_SWIZZLE3_3_MEMBERS(T, Q, r, g, b)
+					GLM_SWIZZLE3_3_MEMBERS(T, Q, s, t, p)
+					GLM_SWIZZLE3_4_MEMBERS(T, Q, x, y, z)
+					GLM_SWIZZLE3_4_MEMBERS(T, Q, r, g, b)
+					GLM_SWIZZLE3_4_MEMBERS(T, Q, s, t, p)
+#				endif
+			};
+#		else
+			union { T x, r, s; };
+			union { T y, g, t; };
+			union { T z, b, p; };
+
+#			if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+				GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, Q)
+#			endif//GLM_CONFIG_SWIZZLE
+#		endif//GLM_LANG
+
+#		if GLM_SILENT_WARNINGS == GLM_ENABLE
+#			if GLM_COMPILER & GLM_COMPILER_CLANG
+#				pragma clang diagnostic pop
+#			elif GLM_COMPILER & GLM_COMPILER_GCC
+#				pragma GCC diagnostic pop
+#			elif GLM_COMPILER & GLM_COMPILER_VC
+#				pragma warning(pop)
+#			endif
+#		endif
+
+		// -- Component accesses --
+
+		/// Return the count of components of the vector
+		typedef length_t length_type;
+		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 3;}
+
+		GLM_FUNC_DECL GLM_CONSTEXPR T & operator[](length_type i);
+		GLM_FUNC_DECL GLM_CONSTEXPR T const& operator[](length_type i) const;
+
+		// -- Implicit basic constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR vec() GLM_DEFAULT;
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec const& v) GLM_DEFAULT;
+		template<qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<3, T, P> const& v);
+
+		// -- Explicit basic constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(T a, T b, T c);
+
+		// -- Conversion scalar constructors --
+
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(vec<1, U, P> const& v);
+
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename X, typename Y, typename Z>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(X x, Y y, Z z);
+		template<typename X, typename Y, typename Z>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, Y _y, Z _z);
+		template<typename X, typename Y, typename Z>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, vec<1, Y, Q> const& _y, Z _z);
+		template<typename X, typename Y, typename Z>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, Z _z);
+		template<typename X, typename Y, typename Z>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, Y _y, vec<1, Z, Q> const& _z);
+		template<typename X, typename Y, typename Z>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, Y _y, vec<1, Z, Q> const& _z);
+		template<typename X, typename Y, typename Z>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z);
+		template<typename X, typename Y, typename Z>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z);
+
+		// -- Conversion vector constructors --
+
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, P> const& _xy, B _z);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, P> const& _xy, vec<1, B, P> const& _z);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(A _x, vec<2, B, P> const& _yz);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, P> const& _x, vec<2, B, P> const& _yz);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<4, U, P> const& v);
+
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<3, U, P> const& v);
+
+		// -- Swizzle constructors --
+#		if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+			template<int E0, int E1, int E2>
+			GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<3, T, Q, E0, E1, E2, -1> const& that)
+			{
+				*this = that();
+			}
+
+			template<int E0, int E1>
+			GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<2, T, Q, E0, E1, -1, -2> const& v, T const& scalar)
+			{
+				*this = vec(v(), scalar);
+			}
+
+			template<int E0, int E1>
+			GLM_FUNC_DECL GLM_CONSTEXPR vec(T const& scalar, detail::_swizzle<2, T, Q, E0, E1, -1, -2> const& v)
+			{
+				*this = vec(scalar, v());
+			}
+#		endif//GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+
+		// -- Unary arithmetic operators --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q>& operator=(vec<3, T, Q> const& v) GLM_DEFAULT;
+
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator=(vec<3, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator+=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator+=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator+=(vec<3, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator-=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator-=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator-=(vec<3, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator*=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator*=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator*=(vec<3, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator/=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator/=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator/=(vec<3, U, Q> const& v);
+
+		// -- Increment and decrement operators --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator++();
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator--();
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator++(int);
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator--(int);
+
+		// -- Unary bit operators --
+
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator%=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator%=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator%=(vec<3, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator&=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator&=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator&=(vec<3, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator|=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator|=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator|=(vec<3, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator^=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator^=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator^=(vec<3, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator<<=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator<<=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator<<=(vec<3, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator>>=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator>>=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator>>=(vec<3, U, Q> const& v);
+	};
+
+	// -- Unary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v);
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator+(T scalar, vec<3, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator+(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator-(T scalar, vec<3, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator-(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator*(T scalar, vec<3, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator*(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator/(vec<3, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator/(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator/(T scalar, vec<3, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator/(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator/(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator%(vec<3, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator%(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator%(T scalar, vec<3, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator%(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator%(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator&(vec<3, T, Q> const& v1, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator&(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator&(T scalar, vec<3, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator&(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator&(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator|(vec<3, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator|(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator|(T scalar, vec<3, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator|(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator|(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator^(vec<3, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator^(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator^(T scalar, vec<3, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator^(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator^(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<3, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator<<(T scalar, vec<3, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<3, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator>>(T scalar, vec<3, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator~(vec<3, T, Q> const& v);
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR bool operator==(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR bool operator!=(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+	template<qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, bool, Q> operator&&(vec<3, bool, Q> const& v1, vec<3, bool, Q> const& v2);
+
+	template<qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<3, bool, Q> operator||(vec<3, bool, Q> const& v1, vec<3, bool, Q> const& v2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_vec3.inl"
+#endif//GLM_EXTERNAL_TEMPLATE
diff --git a/engine/inc/glm/detail/type_vec3.inl b/engine/inc/glm/detail/type_vec3.inl
new file mode 100644
index 00000000..6532c9e6
--- /dev/null
+++ b/engine/inc/glm/detail/type_vec3.inl
@@ -0,0 +1,1068 @@
+/// @ref core
+
+#include "compute_vector_relational.hpp"
+
+namespace glm
+{
+	// -- Implicit basic constructors --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec()
+#			if GLM_CONFIG_CTOR_INIT != GLM_CTOR_INIT_DISABLE
+				: x(0), y(0), z(0)
+#			endif
+		{}
+
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<3, T, Q> const& v)
+			: x(v.x), y(v.y), z(v.z)
+		{}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<3, T, P> const& v)
+		: x(v.x), y(v.y), z(v.z)
+	{}
+
+	// -- Explicit basic constructors --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(T scalar)
+		: x(scalar), y(scalar), z(scalar)
+	{}
+
+	template <typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(T _x, T _y, T _z)
+		: x(_x), y(_y), z(_z)
+	{}
+
+	// -- Conversion scalar constructors --
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<1, U, P> const& v)
+		: x(static_cast<T>(v.x))
+		, y(static_cast<T>(v.x))
+		, z(static_cast<T>(v.x))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename X, typename Y, typename Z>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(X _x, Y _y, Z _z)
+		: x(static_cast<T>(_x))
+		, y(static_cast<T>(_y))
+		, z(static_cast<T>(_z))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename X, typename Y, typename Z>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<1, X, Q> const& _x, Y _y, Z _z)
+		: x(static_cast<T>(_x.x))
+		, y(static_cast<T>(_y))
+		, z(static_cast<T>(_z))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename X, typename Y, typename Z>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(X _x, vec<1, Y, Q> const& _y, Z _z)
+		: x(static_cast<T>(_x))
+		, y(static_cast<T>(_y.x))
+		, z(static_cast<T>(_z))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename X, typename Y, typename Z>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, Z _z)
+		: x(static_cast<T>(_x.x))
+		, y(static_cast<T>(_y.x))
+		, z(static_cast<T>(_z))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename X, typename Y, typename Z>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(X _x, Y _y, vec<1, Z, Q> const& _z)
+		: x(static_cast<T>(_x))
+		, y(static_cast<T>(_y))
+		, z(static_cast<T>(_z.x))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename X, typename Y, typename Z>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<1, X, Q> const& _x, Y _y, vec<1, Z, Q> const& _z)
+		: x(static_cast<T>(_x.x))
+		, y(static_cast<T>(_y))
+		, z(static_cast<T>(_z.x))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename X, typename Y, typename Z>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(X _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z)
+		: x(static_cast<T>(_x))
+		, y(static_cast<T>(_y.x))
+		, z(static_cast<T>(_z.x))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename X, typename Y, typename Z>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z)
+		: x(static_cast<T>(_x.x))
+		, y(static_cast<T>(_y.x))
+		, z(static_cast<T>(_z.x))
+	{}
+
+	// -- Conversion vector constructors --
+
+	template<typename T, qualifier Q>
+	template<typename A, typename B, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<2, A, P> const& _xy, B _z)
+		: x(static_cast<T>(_xy.x))
+		, y(static_cast<T>(_xy.y))
+		, z(static_cast<T>(_z))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename A, typename B, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<2, A, P> const& _xy, vec<1, B, P> const& _z)
+		: x(static_cast<T>(_xy.x))
+		, y(static_cast<T>(_xy.y))
+		, z(static_cast<T>(_z.x))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename A, typename B, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(A _x, vec<2, B, P> const& _yz)
+		: x(static_cast<T>(_x))
+		, y(static_cast<T>(_yz.x))
+		, z(static_cast<T>(_yz.y))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename A, typename B, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<1, A, P> const& _x, vec<2, B, P> const& _yz)
+		: x(static_cast<T>(_x.x))
+		, y(static_cast<T>(_yz.x))
+		, z(static_cast<T>(_yz.y))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<3, U, P> const& v)
+		: x(static_cast<T>(v.x))
+		, y(static_cast<T>(v.y))
+		, z(static_cast<T>(v.z))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<4, U, P> const& v)
+		: x(static_cast<T>(v.x))
+		, y(static_cast<T>(v.y))
+		, z(static_cast<T>(v.z))
+	{}
+
+	// -- Component accesses --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR T & vec<3, T, Q>::operator[](typename vec<3, T, Q>::length_type i)
+	{
+		assert(i >= 0 && i < this->length());
+		switch(i)
+		{
+		default:
+			case 0:
+		return x;
+			case 1:
+		return y;
+			case 2:
+		return z;
+		}
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR T const& vec<3, T, Q>::operator[](typename vec<3, T, Q>::length_type i) const
+	{
+		assert(i >= 0 && i < this->length());
+		switch(i)
+		{
+		default:
+		case 0:
+			return x;
+		case 1:
+			return y;
+		case 2:
+			return z;
+		}
+	}
+
+	// -- Unary arithmetic operators --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>& vec<3, T, Q>::operator=(vec<3, T, Q> const& v)
+		{
+			this->x = v.x;
+			this->y = v.y;
+			this->z = v.z;
+			return *this;
+		}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>& vec<3, T, Q>::operator=(vec<3, U, Q> const& v)
+	{
+		this->x = static_cast<T>(v.x);
+		this->y = static_cast<T>(v.y);
+		this->z = static_cast<T>(v.z);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator+=(U scalar)
+	{
+		this->x += static_cast<T>(scalar);
+		this->y += static_cast<T>(scalar);
+		this->z += static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator+=(vec<1, U, Q> const& v)
+	{
+		this->x += static_cast<T>(v.x);
+		this->y += static_cast<T>(v.x);
+		this->z += static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator+=(vec<3, U, Q> const& v)
+	{
+		this->x += static_cast<T>(v.x);
+		this->y += static_cast<T>(v.y);
+		this->z += static_cast<T>(v.z);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator-=(U scalar)
+	{
+		this->x -= static_cast<T>(scalar);
+		this->y -= static_cast<T>(scalar);
+		this->z -= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator-=(vec<1, U, Q> const& v)
+	{
+		this->x -= static_cast<T>(v.x);
+		this->y -= static_cast<T>(v.x);
+		this->z -= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator-=(vec<3, U, Q> const& v)
+	{
+		this->x -= static_cast<T>(v.x);
+		this->y -= static_cast<T>(v.y);
+		this->z -= static_cast<T>(v.z);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator*=(U scalar)
+	{
+		this->x *= static_cast<T>(scalar);
+		this->y *= static_cast<T>(scalar);
+		this->z *= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator*=(vec<1, U, Q> const& v)
+	{
+		this->x *= static_cast<T>(v.x);
+		this->y *= static_cast<T>(v.x);
+		this->z *= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator*=(vec<3, U, Q> const& v)
+	{
+		this->x *= static_cast<T>(v.x);
+		this->y *= static_cast<T>(v.y);
+		this->z *= static_cast<T>(v.z);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator/=(U v)
+	{
+		this->x /= static_cast<T>(v);
+		this->y /= static_cast<T>(v);
+		this->z /= static_cast<T>(v);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator/=(vec<1, U, Q> const& v)
+	{
+		this->x /= static_cast<T>(v.x);
+		this->y /= static_cast<T>(v.x);
+		this->z /= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator/=(vec<3, U, Q> const& v)
+	{
+		this->x /= static_cast<T>(v.x);
+		this->y /= static_cast<T>(v.y);
+		this->z /= static_cast<T>(v.z);
+		return *this;
+	}
+
+	// -- Increment and decrement operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator++()
+	{
+		++this->x;
+		++this->y;
+		++this->z;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator--()
+	{
+		--this->x;
+		--this->y;
+		--this->z;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> vec<3, T, Q>::operator++(int)
+	{
+		vec<3, T, Q> Result(*this);
+		++*this;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> vec<3, T, Q>::operator--(int)
+	{
+		vec<3, T, Q> Result(*this);
+		--*this;
+		return Result;
+	}
+
+	// -- Unary bit operators --
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator%=(U scalar)
+	{
+		this->x %= scalar;
+		this->y %= scalar;
+		this->z %= scalar;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator%=(vec<1, U, Q> const& v)
+	{
+		this->x %= v.x;
+		this->y %= v.x;
+		this->z %= v.x;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator%=(vec<3, U, Q> const& v)
+	{
+		this->x %= v.x;
+		this->y %= v.y;
+		this->z %= v.z;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator&=(U scalar)
+	{
+		this->x &= scalar;
+		this->y &= scalar;
+		this->z &= scalar;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator&=(vec<1, U, Q> const& v)
+	{
+		this->x &= v.x;
+		this->y &= v.x;
+		this->z &= v.x;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator&=(vec<3, U, Q> const& v)
+	{
+		this->x &= v.x;
+		this->y &= v.y;
+		this->z &= v.z;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator|=(U scalar)
+	{
+		this->x |= scalar;
+		this->y |= scalar;
+		this->z |= scalar;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator|=(vec<1, U, Q> const& v)
+	{
+		this->x |= v.x;
+		this->y |= v.x;
+		this->z |= v.x;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator|=(vec<3, U, Q> const& v)
+	{
+		this->x |= v.x;
+		this->y |= v.y;
+		this->z |= v.z;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator^=(U scalar)
+	{
+		this->x ^= scalar;
+		this->y ^= scalar;
+		this->z ^= scalar;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator^=(vec<1, U, Q> const& v)
+	{
+		this->x ^= v.x;
+		this->y ^= v.x;
+		this->z ^= v.x;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator^=(vec<3, U, Q> const& v)
+	{
+		this->x ^= v.x;
+		this->y ^= v.y;
+		this->z ^= v.z;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator<<=(U scalar)
+	{
+		this->x <<= scalar;
+		this->y <<= scalar;
+		this->z <<= scalar;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator<<=(vec<1, U, Q> const& v)
+	{
+		this->x <<= static_cast<T>(v.x);
+		this->y <<= static_cast<T>(v.x);
+		this->z <<= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator<<=(vec<3, U, Q> const& v)
+	{
+		this->x <<= static_cast<T>(v.x);
+		this->y <<= static_cast<T>(v.y);
+		this->z <<= static_cast<T>(v.z);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator>>=(U scalar)
+	{
+		this->x >>= static_cast<T>(scalar);
+		this->y >>= static_cast<T>(scalar);
+		this->z >>= static_cast<T>(scalar);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator>>=(vec<1, U, Q> const& v)
+	{
+		this->x >>= static_cast<T>(v.x);
+		this->y >>= static_cast<T>(v.x);
+		this->z >>= static_cast<T>(v.x);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator>>=(vec<3, U, Q> const& v)
+	{
+		this->x >>= static_cast<T>(v.x);
+		this->y >>= static_cast<T>(v.y);
+		this->z >>= static_cast<T>(v.z);
+		return *this;
+	}
+
+	// -- Unary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v)
+	{
+		return v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v)
+	{
+		return vec<3, T, Q>(
+			-v.x,
+			-v.y,
+			-v.z);
+	}
+
+	// -- Binary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v, T scalar)
+	{
+		return vec<3, T, Q>(
+			v.x + scalar,
+			v.y + scalar,
+			v.z + scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
+	{
+		return vec<3, T, Q>(
+			v.x + scalar.x,
+			v.y + scalar.x,
+			v.z + scalar.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator+(T scalar, vec<3, T, Q> const& v)
+	{
+		return vec<3, T, Q>(
+			scalar + v.x,
+			scalar + v.y,
+			scalar + v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator+(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
+	{
+		return vec<3, T, Q>(
+			scalar.x + v.x,
+			scalar.x + v.y,
+			scalar.x + v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
+	{
+		return vec<3, T, Q>(
+			v1.x + v2.x,
+			v1.y + v2.y,
+			v1.z + v2.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v, T scalar)
+	{
+		return vec<3, T, Q>(
+			v.x - scalar,
+			v.y - scalar,
+			v.z - scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
+	{
+		return vec<3, T, Q>(
+			v.x - scalar.x,
+			v.y - scalar.x,
+			v.z - scalar.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator-(T scalar, vec<3, T, Q> const& v)
+	{
+		return vec<3, T, Q>(
+			scalar - v.x,
+			scalar - v.y,
+			scalar - v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator-(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
+	{
+		return vec<3, T, Q>(
+			scalar.x - v.x,
+			scalar.x - v.y,
+			scalar.x - v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
+	{
+		return vec<3, T, Q>(
+			v1.x - v2.x,
+			v1.y - v2.y,
+			v1.z - v2.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v, T scalar)
+	{
+		return vec<3, T, Q>(
+			v.x * scalar,
+			v.y * scalar,
+			v.z * scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
+	{
+		return vec<3, T, Q>(
+			v.x * scalar.x,
+			v.y * scalar.x,
+			v.z * scalar.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(T scalar, vec<3, T, Q> const& v)
+	{
+		return vec<3, T, Q>(
+			scalar * v.x,
+			scalar * v.y,
+			scalar * v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
+	{
+		return vec<3, T, Q>(
+			scalar.x * v.x,
+			scalar.x * v.y,
+			scalar.x * v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
+	{
+		return vec<3, T, Q>(
+			v1.x * v2.x,
+			v1.y * v2.y,
+			v1.z * v2.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator/(vec<3, T, Q> const& v, T scalar)
+	{
+		return vec<3, T, Q>(
+			v.x / scalar,
+			v.y / scalar,
+			v.z / scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator/(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
+	{
+		return vec<3, T, Q>(
+			v.x / scalar.x,
+			v.y / scalar.x,
+			v.z / scalar.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator/(T scalar, vec<3, T, Q> const& v)
+	{
+		return vec<3, T, Q>(
+			scalar / v.x,
+			scalar / v.y,
+			scalar / v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator/(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
+	{
+		return vec<3, T, Q>(
+			scalar.x / v.x,
+			scalar.x / v.y,
+			scalar.x / v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator/(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
+	{
+		return vec<3, T, Q>(
+			v1.x / v2.x,
+			v1.y / v2.y,
+			v1.z / v2.z);
+	}
+
+	// -- Binary bit operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator%(vec<3, T, Q> const& v, T scalar)
+	{
+		return vec<3, T, Q>(
+			v.x % scalar,
+			v.y % scalar,
+			v.z % scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator%(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
+	{
+		return vec<3, T, Q>(
+			v.x % scalar.x,
+			v.y % scalar.x,
+			v.z % scalar.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator%(T scalar, vec<3, T, Q> const& v)
+	{
+		return vec<3, T, Q>(
+			scalar % v.x,
+			scalar % v.y,
+			scalar % v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator%(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
+	{
+		return vec<3, T, Q>(
+			scalar.x % v.x,
+			scalar.x % v.y,
+			scalar.x % v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator%(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
+	{
+		return vec<3, T, Q>(
+			v1.x % v2.x,
+			v1.y % v2.y,
+			v1.z % v2.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator&(vec<3, T, Q> const& v, T scalar)
+	{
+		return vec<3, T, Q>(
+			v.x & scalar,
+			v.y & scalar,
+			v.z & scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator&(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
+	{
+		return vec<3, T, Q>(
+			v.x & scalar.x,
+			v.y & scalar.x,
+			v.z & scalar.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator&(T scalar, vec<3, T, Q> const& v)
+	{
+		return vec<3, T, Q>(
+			scalar & v.x,
+			scalar & v.y,
+			scalar & v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator&(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
+	{
+		return vec<3, T, Q>(
+			scalar.x & v.x,
+			scalar.x & v.y,
+			scalar.x & v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator&(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
+	{
+		return vec<3, T, Q>(
+			v1.x & v2.x,
+			v1.y & v2.y,
+			v1.z & v2.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator|(vec<3, T, Q> const& v, T scalar)
+	{
+		return vec<3, T, Q>(
+			v.x | scalar,
+			v.y | scalar,
+			v.z | scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator|(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
+	{
+		return vec<3, T, Q>(
+			v.x | scalar.x,
+			v.y | scalar.x,
+			v.z | scalar.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator|(T scalar, vec<3, T, Q> const& v)
+	{
+		return vec<3, T, Q>(
+			scalar | v.x,
+			scalar | v.y,
+			scalar | v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator|(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
+	{
+		return vec<3, T, Q>(
+			scalar.x | v.x,
+			scalar.x | v.y,
+			scalar.x | v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator|(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
+	{
+		return vec<3, T, Q>(
+			v1.x | v2.x,
+			v1.y | v2.y,
+			v1.z | v2.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator^(vec<3, T, Q> const& v, T scalar)
+	{
+		return vec<3, T, Q>(
+			v.x ^ scalar,
+			v.y ^ scalar,
+			v.z ^ scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator^(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
+	{
+		return vec<3, T, Q>(
+			v.x ^ scalar.x,
+			v.y ^ scalar.x,
+			v.z ^ scalar.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator^(T scalar, vec<3, T, Q> const& v)
+	{
+		return vec<3, T, Q>(
+			scalar ^ v.x,
+			scalar ^ v.y,
+			scalar ^ v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator^(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
+	{
+		return vec<3, T, Q>(
+			scalar.x ^ v.x,
+			scalar.x ^ v.y,
+			scalar.x ^ v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator^(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
+	{
+		return vec<3, T, Q>(
+			v1.x ^ v2.x,
+			v1.y ^ v2.y,
+			v1.z ^ v2.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<3, T, Q> const& v, T scalar)
+	{
+		return vec<3, T, Q>(
+			v.x << scalar,
+			v.y << scalar,
+			v.z << scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
+	{
+		return vec<3, T, Q>(
+			v.x << scalar.x,
+			v.y << scalar.x,
+			v.z << scalar.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator<<(T scalar, vec<3, T, Q> const& v)
+	{
+		return vec<3, T, Q>(
+			scalar << v.x,
+			scalar << v.y,
+			scalar << v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
+	{
+		return vec<3, T, Q>(
+			scalar.x << v.x,
+			scalar.x << v.y,
+			scalar.x << v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
+	{
+		return vec<3, T, Q>(
+			v1.x << v2.x,
+			v1.y << v2.y,
+			v1.z << v2.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<3, T, Q> const& v, T scalar)
+	{
+		return vec<3, T, Q>(
+			v.x >> scalar,
+			v.y >> scalar,
+			v.z >> scalar);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
+	{
+		return vec<3, T, Q>(
+			v.x >> scalar.x,
+			v.y >> scalar.x,
+			v.z >> scalar.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator>>(T scalar, vec<3, T, Q> const& v)
+	{
+		return vec<3, T, Q>(
+			scalar >> v.x,
+			scalar >> v.y,
+			scalar >> v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
+	{
+		return vec<3, T, Q>(
+			scalar.x >> v.x,
+			scalar.x >> v.y,
+			scalar.x >> v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
+	{
+		return vec<3, T, Q>(
+			v1.x >> v2.x,
+			v1.y >> v2.y,
+			v1.z >> v2.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator~(vec<3, T, Q> const& v)
+	{
+		return vec<3, T, Q>(
+			~v.x,
+			~v.y,
+			~v.z);
+	}
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator==(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
+	{
+		return
+			detail::compute_equal<T, std::numeric_limits<T>::is_iec559>::call(v1.x, v2.x) &&
+			detail::compute_equal<T, std::numeric_limits<T>::is_iec559>::call(v1.y, v2.y) &&
+			detail::compute_equal<T, std::numeric_limits<T>::is_iec559>::call(v1.z, v2.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator!=(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
+	{
+		return !(v1 == v2);
+	}
+
+	template<qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, bool, Q> operator&&(vec<3, bool, Q> const& v1, vec<3, bool, Q> const& v2)
+	{
+		return vec<3, bool, Q>(v1.x && v2.x, v1.y && v2.y, v1.z && v2.z);
+	}
+
+	template<qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, bool, Q> operator||(vec<3, bool, Q> const& v1, vec<3, bool, Q> const& v2)
+	{
+		return vec<3, bool, Q>(v1.x || v2.x, v1.y || v2.y, v1.z || v2.z);
+	}
+}//namespace glm
diff --git a/engine/inc/glm/detail/type_vec4.hpp b/engine/inc/glm/detail/type_vec4.hpp
new file mode 100644
index 00000000..15fabe12
--- /dev/null
+++ b/engine/inc/glm/detail/type_vec4.hpp
@@ -0,0 +1,504 @@
+/// @ref core
+/// @file glm/detail/type_vec4.hpp
+
+#pragma once
+
+#include "qualifier.hpp"
+#if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+#	include "_swizzle.hpp"
+#elif GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+#	include "_swizzle_func.hpp"
+#endif
+#include <cstddef>
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	struct vec<4, T, Q>
+	{
+		// -- Implementation detail --
+
+		typedef T value_type;
+		typedef vec<4, T, Q> type;
+		typedef vec<4, bool, Q> bool_type;
+
+		// -- Data --
+
+#		if GLM_SILENT_WARNINGS == GLM_ENABLE
+#			if GLM_COMPILER & GLM_COMPILER_GCC
+#				pragma GCC diagnostic push
+#				pragma GCC diagnostic ignored "-Wpedantic"
+#			elif GLM_COMPILER & GLM_COMPILER_CLANG
+#				pragma clang diagnostic push
+#				pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
+#				pragma clang diagnostic ignored "-Wnested-anon-types"
+#			elif GLM_COMPILER & GLM_COMPILER_VC
+#				pragma warning(push)
+#				pragma warning(disable: 4201)  // nonstandard extension used : nameless struct/union
+#			endif
+#		endif
+
+#		if GLM_CONFIG_XYZW_ONLY
+			T x, y, z, w;
+#		elif GLM_CONFIG_ANONYMOUS_STRUCT == GLM_ENABLE
+			union
+			{
+				struct { T x, y, z, w; };
+				struct { T r, g, b, a; };
+				struct { T s, t, p, q; };
+
+				typename detail::storage<4, T, detail::is_aligned<Q>::value>::type data;
+
+#				if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+					GLM_SWIZZLE4_2_MEMBERS(T, Q, x, y, z, w)
+					GLM_SWIZZLE4_2_MEMBERS(T, Q, r, g, b, a)
+					GLM_SWIZZLE4_2_MEMBERS(T, Q, s, t, p, q)
+					GLM_SWIZZLE4_3_MEMBERS(T, Q, x, y, z, w)
+					GLM_SWIZZLE4_3_MEMBERS(T, Q, r, g, b, a)
+					GLM_SWIZZLE4_3_MEMBERS(T, Q, s, t, p, q)
+					GLM_SWIZZLE4_4_MEMBERS(T, Q, x, y, z, w)
+					GLM_SWIZZLE4_4_MEMBERS(T, Q, r, g, b, a)
+					GLM_SWIZZLE4_4_MEMBERS(T, Q, s, t, p, q)
+#				endif
+			};
+#		else
+			union { T x, r, s; };
+			union { T y, g, t; };
+			union { T z, b, p; };
+			union { T w, a, q; };
+
+#			if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+				GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, Q)
+#			endif
+#		endif
+
+#		if GLM_SILENT_WARNINGS == GLM_ENABLE
+#			if GLM_COMPILER & GLM_COMPILER_CLANG
+#				pragma clang diagnostic pop
+#			elif GLM_COMPILER & GLM_COMPILER_GCC
+#				pragma GCC diagnostic pop
+#			elif GLM_COMPILER & GLM_COMPILER_VC
+#				pragma warning(pop)
+#			endif
+#		endif
+
+		// -- Component accesses --
+
+		/// Return the count of components of the vector
+		typedef length_t length_type;
+		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 4;}
+
+		GLM_FUNC_DECL GLM_CONSTEXPR T & operator[](length_type i);
+		GLM_FUNC_DECL GLM_CONSTEXPR T const& operator[](length_type i) const;
+
+		// -- Implicit basic constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR vec() GLM_DEFAULT;
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<4, T, Q> const& v) GLM_DEFAULT;
+		template<qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<4, T, P> const& v);
+
+		// -- Explicit basic constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(T x, T y, T z, T w);
+
+		// -- Conversion scalar constructors --
+
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(vec<1, U, P> const& v);
+
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename X, typename Y, typename Z, typename W>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, Y _y, Z _z, W _w);
+		template<typename X, typename Y, typename Z, typename W>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, Y _y, Z _z, W _w);
+		template<typename X, typename Y, typename Z, typename W>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, vec<1, Y, Q> const& _y, Z _z, W _w);
+		template<typename X, typename Y, typename Z, typename W>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, Z _z, W _w);
+		template<typename X, typename Y, typename Z, typename W>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, Y _y, vec<1, Z, Q> const& _z, W _w);
+		template<typename X, typename Y, typename Z, typename W>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, Y _y, vec<1, Z, Q> const& _z, W _w);
+		template<typename X, typename Y, typename Z, typename W>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z, W _w);
+		template<typename X, typename Y, typename Z, typename W>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z, W _w);
+		template<typename X, typename Y, typename Z, typename W>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, Y _y, Z _z, vec<1, W, Q> const& _w);
+		template<typename X, typename Y, typename Z, typename W>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, vec<1, Y, Q> const& _y, Z _z, vec<1, W, Q> const& _w);
+		template<typename X, typename Y, typename Z, typename W>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, Z _z, vec<1, W, Q> const& _w);
+		template<typename X, typename Y, typename Z, typename W>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, Y _y, vec<1, Z, Q> const& _z, vec<1, W, Q> const& _w);
+		template<typename X, typename Y, typename Z, typename W>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, Y _y, vec<1, Z, Q> const& _z, vec<1, W, Q> const& _w);
+		template<typename X, typename Y, typename Z, typename W>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z, vec<1, W, Q> const& _w);
+		template<typename X, typename Y, typename Z, typename W>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _Y, vec<1, Z, Q> const& _z, vec<1, W, Q> const& _w);
+
+		// -- Conversion vector constructors --
+
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, typename C, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, P> const& _xy, B _z, C _w);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, typename C, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, P> const& _xy, vec<1, B, P> const& _z, C _w);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, typename C, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, P> const& _xy, B _z, vec<1, C, P> const& _w);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, typename C, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, P> const& _xy, vec<1, B, P> const& _z, vec<1, C, P> const& _w);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, typename C, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(A _x, vec<2, B, P> const& _yz, C _w);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, typename C, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, P> const& _x, vec<2, B, P> const& _yz, C _w);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, typename C, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(A _x, vec<2, B, P> const& _yz, vec<1, C, P> const& _w);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, typename C, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, P> const& _x, vec<2, B, P> const& _yz, vec<1, C, P> const& _w);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, typename C, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(A _x, B _y, vec<2, C, P> const& _zw);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, typename C, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, P> const& _x, B _y, vec<2, C, P> const& _zw);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, typename C, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(A _x, vec<1, B, P> const& _y, vec<2, C, P> const& _zw);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, typename C, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, P> const& _x, vec<1, B, P> const& _y, vec<2, C, P> const& _zw);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<3, A, P> const& _xyz, B _w);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<3, A, P> const& _xyz, vec<1, B, P> const& _w);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(A _x, vec<3, B, P> const& _yzw);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, P> const& _x, vec<3, B, P> const& _yzw);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, P> const& _xy, vec<2, B, P> const& _zw);
+
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<4, U, P> const& v);
+
+		// -- Swizzle constructors --
+#		if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+			template<int E0, int E1, int E2, int E3>
+			GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<4, T, Q, E0, E1, E2, E3> const& that)
+			{
+				*this = that();
+			}
+
+			template<int E0, int E1, int F0, int F1>
+			GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<2, T, Q, E0, E1, -1, -2> const& v, detail::_swizzle<2, T, Q, F0, F1, -1, -2> const& u)
+			{
+				*this = vec<4, T, Q>(v(), u());
+			}
+
+			template<int E0, int E1>
+			GLM_FUNC_DECL GLM_CONSTEXPR vec(T const& x, T const& y, detail::_swizzle<2, T, Q, E0, E1, -1, -2> const& v)
+			{
+				*this = vec<4, T, Q>(x, y, v());
+			}
+
+			template<int E0, int E1>
+			GLM_FUNC_DECL GLM_CONSTEXPR vec(T const& x, detail::_swizzle<2, T, Q, E0, E1, -1, -2> const& v, T const& w)
+			{
+				*this = vec<4, T, Q>(x, v(), w);
+			}
+
+			template<int E0, int E1>
+			GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<2, T, Q, E0, E1, -1, -2> const& v, T const& z, T const& w)
+			{
+				*this = vec<4, T, Q>(v(), z, w);
+			}
+
+			template<int E0, int E1, int E2>
+			GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<3, T, Q, E0, E1, E2, -1> const& v, T const& w)
+			{
+				*this = vec<4, T, Q>(v(), w);
+			}
+
+			template<int E0, int E1, int E2>
+			GLM_FUNC_DECL GLM_CONSTEXPR vec(T const& x, detail::_swizzle<3, T, Q, E0, E1, E2, -1> const& v)
+			{
+				*this = vec<4, T, Q>(x, v());
+			}
+#		endif//GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+
+		// -- Unary arithmetic operators --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator=(vec<4, T, Q> const& v) GLM_DEFAULT;
+
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator=(vec<4, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator+=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator+=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator+=(vec<4, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator-=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator-=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator-=(vec<4, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator*=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator*=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator*=(vec<4, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator/=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator/=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator/=(vec<4, U, Q> const& v);
+
+		// -- Increment and decrement operators --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator++();
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator--();
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator++(int);
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator--(int);
+
+		// -- Unary bit operators --
+
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator%=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator%=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator%=(vec<4, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator&=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator&=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator&=(vec<4, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator|=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator|=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator|=(vec<4, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator^=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator^=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator^=(vec<4, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator<<=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator<<=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator<<=(vec<4, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator>>=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator>>=(vec<1, U, Q> const& v);
+		template<typename U>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator>>=(vec<4, U, Q> const& v);
+	};
+
+	// -- Unary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator+(vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator-(vec<4, T, Q> const& v);
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator+(vec<4, T, Q> const& v, T const & scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator+(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator+(T scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator+(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator+(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator-(vec<4, T, Q> const& v, T const & scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator-(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator-(T scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator-(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator-(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator*(vec<4, T, Q> const& v, T const & scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator*(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator*(T scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator*(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator*(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator/(vec<4, T, Q> const& v, T const & scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator/(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator/(T scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator/(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator/(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator%(vec<4, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator%(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator%(T scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator%(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator%(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator&(vec<4, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator&(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator&(T scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator&(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator&(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator|(vec<4, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator|(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator|(T scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator|(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator|(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator^(vec<4, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator^(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator^(T scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator^(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator^(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator<<(vec<4, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator<<(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator<<(T scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator<<(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator<<(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator>>(vec<4, T, Q> const& v, T scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator>>(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator>>(T scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator>>(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator>>(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator~(vec<4, T, Q> const& v);
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR bool operator==(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR bool operator!=(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+	template<qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, bool, Q> operator&&(vec<4, bool, Q> const& v1, vec<4, bool, Q> const& v2);
+
+	template<qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<4, bool, Q> operator||(vec<4, bool, Q> const& v1, vec<4, bool, Q> const& v2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_vec4.inl"
+#endif//GLM_EXTERNAL_TEMPLATE
diff --git a/engine/inc/glm/detail/type_vec4.inl b/engine/inc/glm/detail/type_vec4.inl
new file mode 100644
index 00000000..3c212d98
--- /dev/null
+++ b/engine/inc/glm/detail/type_vec4.inl
@@ -0,0 +1,1140 @@
+/// @ref core
+
+#include "compute_vector_relational.hpp"
+
+namespace glm{
+namespace detail
+{
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_vec4_add
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			return vec<4, T, Q>(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w);
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_vec4_sub
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			return vec<4, T, Q>(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w);
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_vec4_mul
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			return vec<4, T, Q>(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w);
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_vec4_div
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			return vec<4, T, Q>(a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w);
+		}
+	};
+
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_vec4_mod
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			return vec<4, T, Q>(a.x % b.x, a.y % b.y, a.z % b.z, a.w % b.w);
+		}
+	};
+
+	template<typename T, qualifier Q, int IsInt, std::size_t Size, bool Aligned>
+	struct compute_vec4_and
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			return vec<4, T, Q>(a.x & b.x, a.y & b.y, a.z & b.z, a.w & b.w);
+		}
+	};
+
+	template<typename T, qualifier Q, int IsInt, std::size_t Size, bool Aligned>
+	struct compute_vec4_or
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			return vec<4, T, Q>(a.x | b.x, a.y | b.y, a.z | b.z, a.w | b.w);
+		}
+	};
+
+	template<typename T, qualifier Q, int IsInt, std::size_t Size, bool Aligned>
+	struct compute_vec4_xor
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			return vec<4, T, Q>(a.x ^ b.x, a.y ^ b.y, a.z ^ b.z, a.w ^ b.w);
+		}
+	};
+
+	template<typename T, qualifier Q, int IsInt, std::size_t Size, bool Aligned>
+	struct compute_vec4_shift_left
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			return vec<4, T, Q>(a.x << b.x, a.y << b.y, a.z << b.z, a.w << b.w);
+		}
+	};
+
+	template<typename T, qualifier Q, int IsInt, std::size_t Size, bool Aligned>
+	struct compute_vec4_shift_right
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			return vec<4, T, Q>(a.x >> b.x, a.y >> b.y, a.z >> b.z, a.w >> b.w);
+		}
+	};
+
+	template<typename T, qualifier Q, int IsInt, std::size_t Size, bool Aligned>
+	struct compute_vec4_equal
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static bool call(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2)
+		{
+			return
+				detail::compute_equal<T, std::numeric_limits<T>::is_iec559>::call(v1.x, v2.x) &&
+				detail::compute_equal<T, std::numeric_limits<T>::is_iec559>::call(v1.y, v2.y) &&
+				detail::compute_equal<T, std::numeric_limits<T>::is_iec559>::call(v1.z, v2.z) &&
+				detail::compute_equal<T, std::numeric_limits<T>::is_iec559>::call(v1.w, v2.w);
+		}
+	};
+
+	template<typename T, qualifier Q, int IsInt, std::size_t Size, bool Aligned>
+	struct compute_vec4_nequal
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static bool call(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2)
+		{
+			return !compute_vec4_equal<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(v1, v2);
+		}
+	};
+
+	template<typename T, qualifier Q, int IsInt, std::size_t Size, bool Aligned>
+	struct compute_vec4_bitwise_not
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& v)
+		{
+			return vec<4, T, Q>(~v.x, ~v.y, ~v.z, ~v.w);
+		}
+	};
+}//namespace detail
+
+	// -- Implicit basic constructors --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec()
+#			if GLM_CONFIG_CTOR_INIT != GLM_CTOR_INIT_DISABLE
+				: x(0), y(0), z(0), w(0)
+#			endif
+		{}
+
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<4, T, Q> const& v)
+			: x(v.x), y(v.y), z(v.z), w(v.w)
+		{}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<4, T, P> const& v)
+		: x(v.x), y(v.y), z(v.z), w(v.w)
+	{}
+
+	// -- Explicit basic constructors --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(T scalar)
+		: x(scalar), y(scalar), z(scalar), w(scalar)
+	{}
+
+	template <typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(T _x, T _y, T _z, T _w)
+		: x(_x), y(_y), z(_z), w(_w)
+	{}
+
+	// -- Conversion scalar constructors --
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, U, P> const& v)
+		: x(static_cast<T>(v.x))
+		, y(static_cast<T>(v.x))
+		, z(static_cast<T>(v.x))
+		, w(static_cast<T>(v.x))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename X, typename Y, typename Z, typename W>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(X _x, Y _y, Z _z, W _w)
+		: x(static_cast<T>(_x))
+		, y(static_cast<T>(_y))
+		, z(static_cast<T>(_z))
+		, w(static_cast<T>(_w))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename X, typename Y, typename Z, typename W>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, X, Q> const& _x, Y _y, Z _z, W _w)
+		: x(static_cast<T>(_x.x))
+		, y(static_cast<T>(_y))
+		, z(static_cast<T>(_z))
+		, w(static_cast<T>(_w))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename X, typename Y, typename Z, typename W>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(X _x, vec<1, Y, Q> const& _y, Z _z, W _w)
+		: x(static_cast<T>(_x))
+		, y(static_cast<T>(_y.x))
+		, z(static_cast<T>(_z))
+		, w(static_cast<T>(_w))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename X, typename Y, typename Z, typename W>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, Z _z, W _w)
+		: x(static_cast<T>(_x.x))
+		, y(static_cast<T>(_y.x))
+		, z(static_cast<T>(_z))
+		, w(static_cast<T>(_w))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename X, typename Y, typename Z, typename W>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(X _x, Y _y, vec<1, Z, Q> const& _z, W _w)
+		: x(static_cast<T>(_x))
+		, y(static_cast<T>(_y))
+		, z(static_cast<T>(_z.x))
+		, w(static_cast<T>(_w))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename X, typename Y, typename Z, typename W>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, X, Q> const& _x, Y _y, vec<1, Z, Q> const& _z, W _w)
+		: x(static_cast<T>(_x.x))
+		, y(static_cast<T>(_y))
+		, z(static_cast<T>(_z.x))
+		, w(static_cast<T>(_w))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename X, typename Y, typename Z, typename W>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(X _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z, W _w)
+		: x(static_cast<T>(_x))
+		, y(static_cast<T>(_y.x))
+		, z(static_cast<T>(_z.x))
+		, w(static_cast<T>(_w))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename X, typename Y, typename Z, typename W>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z, W _w)
+		: x(static_cast<T>(_x.x))
+		, y(static_cast<T>(_y.x))
+		, z(static_cast<T>(_z.x))
+		, w(static_cast<T>(_w))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename X, typename Y, typename Z, typename W>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, X, Q> const& _x, Y _y, Z _z, vec<1, W, Q> const& _w)
+		: x(static_cast<T>(_x.x))
+		, y(static_cast<T>(_y))
+		, z(static_cast<T>(_z))
+		, w(static_cast<T>(_w.x))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename X, typename Y, typename Z, typename W>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(X _x, vec<1, Y, Q> const& _y, Z _z, vec<1, W, Q> const& _w)
+		: x(static_cast<T>(_x))
+		, y(static_cast<T>(_y.x))
+		, z(static_cast<T>(_z))
+		, w(static_cast<T>(_w.x))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename X, typename Y, typename Z, typename W>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, Z _z, vec<1, W, Q> const& _w)
+		: x(static_cast<T>(_x.x))
+		, y(static_cast<T>(_y.x))
+		, z(static_cast<T>(_z))
+		, w(static_cast<T>(_w.x))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename X, typename Y, typename Z, typename W>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(X _x, Y _y, vec<1, Z, Q> const& _z, vec<1, W, Q> const& _w)
+		: x(static_cast<T>(_x))
+		, y(static_cast<T>(_y))
+		, z(static_cast<T>(_z.x))
+		, w(static_cast<T>(_w.x))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename X, typename Y, typename Z, typename W>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, X, Q> const& _x, Y _y, vec<1, Z, Q> const& _z, vec<1, W, Q> const& _w)
+		: x(static_cast<T>(_x.x))
+		, y(static_cast<T>(_y))
+		, z(static_cast<T>(_z.x))
+		, w(static_cast<T>(_w.x))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename X, typename Y, typename Z, typename W>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(X _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z, vec<1, W, Q> const& _w)
+		: x(static_cast<T>(_x))
+		, y(static_cast<T>(_y.x))
+		, z(static_cast<T>(_z.x))
+		, w(static_cast<T>(_w.x))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename X, typename Y, typename Z, typename W>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z, vec<1, W, Q> const& _w)
+		: x(static_cast<T>(_x.x))
+		, y(static_cast<T>(_y.x))
+		, z(static_cast<T>(_z.x))
+		, w(static_cast<T>(_w.x))
+	{}
+
+	// -- Conversion vector constructors --
+
+	template<typename T, qualifier Q>
+	template<typename A, typename B, typename C, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<2, A, P> const& _xy, B _z, C _w)
+		: x(static_cast<T>(_xy.x))
+		, y(static_cast<T>(_xy.y))
+		, z(static_cast<T>(_z))
+		, w(static_cast<T>(_w))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename A, typename B, typename C, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<2, A, P> const& _xy, vec<1, B, P> const& _z, C _w)
+		: x(static_cast<T>(_xy.x))
+		, y(static_cast<T>(_xy.y))
+		, z(static_cast<T>(_z.x))
+		, w(static_cast<T>(_w))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename A, typename B, typename C, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<2, A, P> const& _xy, B _z, vec<1, C, P> const& _w)
+		: x(static_cast<T>(_xy.x))
+		, y(static_cast<T>(_xy.y))
+		, z(static_cast<T>(_z))
+		, w(static_cast<T>(_w.x))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename A, typename B, typename C, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<2, A, P> const& _xy, vec<1, B, P> const& _z, vec<1, C, P> const& _w)
+		: x(static_cast<T>(_xy.x))
+		, y(static_cast<T>(_xy.y))
+		, z(static_cast<T>(_z.x))
+		, w(static_cast<T>(_w.x))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename A, typename B, typename C, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(A _x, vec<2, B, P> const& _yz, C _w)
+		: x(static_cast<T>(_x))
+		, y(static_cast<T>(_yz.x))
+		, z(static_cast<T>(_yz.y))
+		, w(static_cast<T>(_w))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename A, typename B, typename C, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, A, P> const& _x, vec<2, B, P> const& _yz, C _w)
+		: x(static_cast<T>(_x.x))
+		, y(static_cast<T>(_yz.x))
+		, z(static_cast<T>(_yz.y))
+		, w(static_cast<T>(_w))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename A, typename B, typename C, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(A _x, vec<2, B, P> const& _yz, vec<1, C, P> const& _w)
+		: x(static_cast<T>(_x))
+		, y(static_cast<T>(_yz.x))
+		, z(static_cast<T>(_yz.y))
+		, w(static_cast<T>(_w.x))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename A, typename B, typename C, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, A, P> const& _x, vec<2, B, P> const& _yz, vec<1, C, P> const& _w)
+		: x(static_cast<T>(_x.x))
+		, y(static_cast<T>(_yz.x))
+		, z(static_cast<T>(_yz.y))
+		, w(static_cast<T>(_w.x))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename A, typename B, typename C, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(A _x, B _y, vec<2, C, P> const& _zw)
+		: x(static_cast<T>(_x))
+		, y(static_cast<T>(_y))
+		, z(static_cast<T>(_zw.x))
+		, w(static_cast<T>(_zw.y))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename A, typename B, typename C, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, A, P> const& _x, B _y, vec<2, C, P> const& _zw)
+		: x(static_cast<T>(_x.x))
+		, y(static_cast<T>(_y))
+		, z(static_cast<T>(_zw.x))
+		, w(static_cast<T>(_zw.y))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename A, typename B, typename C, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(A _x, vec<1, B, P> const& _y, vec<2, C, P> const& _zw)
+		: x(static_cast<T>(_x))
+		, y(static_cast<T>(_y.x))
+		, z(static_cast<T>(_zw.x))
+		, w(static_cast<T>(_zw.y))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename A, typename B, typename C, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, A, P> const& _x, vec<1, B, P> const& _y, vec<2, C, P> const& _zw)
+		: x(static_cast<T>(_x.x))
+		, y(static_cast<T>(_y.x))
+		, z(static_cast<T>(_zw.x))
+		, w(static_cast<T>(_zw.y))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename A, typename B, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<3, A, P> const& _xyz, B _w)
+		: x(static_cast<T>(_xyz.x))
+		, y(static_cast<T>(_xyz.y))
+		, z(static_cast<T>(_xyz.z))
+		, w(static_cast<T>(_w))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename A, typename B, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<3, A, P> const& _xyz, vec<1, B, P> const& _w)
+		: x(static_cast<T>(_xyz.x))
+		, y(static_cast<T>(_xyz.y))
+		, z(static_cast<T>(_xyz.z))
+		, w(static_cast<T>(_w.x))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename A, typename B, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(A _x, vec<3, B, P> const& _yzw)
+		: x(static_cast<T>(_x))
+		, y(static_cast<T>(_yzw.x))
+		, z(static_cast<T>(_yzw.y))
+		, w(static_cast<T>(_yzw.z))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename A, typename B, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, A, P> const& _x, vec<3, B, P> const& _yzw)
+		: x(static_cast<T>(_x.x))
+		, y(static_cast<T>(_yzw.x))
+		, z(static_cast<T>(_yzw.y))
+		, w(static_cast<T>(_yzw.z))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename A, typename B, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<2, A, P> const& _xy, vec<2, B, P> const& _zw)
+		: x(static_cast<T>(_xy.x))
+		, y(static_cast<T>(_xy.y))
+		, z(static_cast<T>(_zw.x))
+		, w(static_cast<T>(_zw.y))
+	{}
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<4, U, P> const& v)
+		: x(static_cast<T>(v.x))
+		, y(static_cast<T>(v.y))
+		, z(static_cast<T>(v.z))
+		, w(static_cast<T>(v.w))
+	{}
+
+	// -- Component accesses --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR T& vec<4, T, Q>::operator[](typename vec<4, T, Q>::length_type i)
+	{
+		assert(i >= 0 && i < this->length());
+		switch(i)
+		{
+		default:
+		case 0:
+			return x;
+		case 1:
+			return y;
+		case 2:
+			return z;
+		case 3:
+			return w;
+		}
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR T const& vec<4, T, Q>::operator[](typename vec<4, T, Q>::length_type i) const
+	{
+		assert(i >= 0 && i < this->length());
+		switch(i)
+		{
+		default:
+		case 0:
+			return x;
+		case 1:
+			return y;
+		case 2:
+			return z;
+		case 3:
+			return w;
+		}
+	}
+
+	// -- Unary arithmetic operators --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>& vec<4, T, Q>::operator=(vec<4, T, Q> const& v)
+		{
+			this->x = v.x;
+			this->y = v.y;
+			this->z = v.z;
+			this->w = v.w;
+			return *this;
+		}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>& vec<4, T, Q>::operator=(vec<4, U, Q> const& v)
+	{
+		this->x = static_cast<T>(v.x);
+		this->y = static_cast<T>(v.y);
+		this->z = static_cast<T>(v.z);
+		this->w = static_cast<T>(v.w);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator+=(U scalar)
+	{
+		return (*this = detail::compute_vec4_add<T, Q, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(scalar)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator+=(vec<1, U, Q> const& v)
+	{
+		return (*this = detail::compute_vec4_add<T, Q, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v.x)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator+=(vec<4, U, Q> const& v)
+	{
+		return (*this = detail::compute_vec4_add<T, Q, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator-=(U scalar)
+	{
+		return (*this = detail::compute_vec4_sub<T, Q, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(scalar)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator-=(vec<1, U, Q> const& v)
+	{
+		return (*this = detail::compute_vec4_sub<T, Q, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v.x)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator-=(vec<4, U, Q> const& v)
+	{
+		return (*this = detail::compute_vec4_sub<T, Q, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator*=(U scalar)
+	{
+		return (*this = detail::compute_vec4_mul<T, Q, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(scalar)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator*=(vec<1, U, Q> const& v)
+	{
+		return (*this = detail::compute_vec4_mul<T, Q, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v.x)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator*=(vec<4, U, Q> const& v)
+	{
+		return (*this = detail::compute_vec4_mul<T, Q, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator/=(U scalar)
+	{
+		return (*this = detail::compute_vec4_div<T, Q, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(scalar)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator/=(vec<1, U, Q> const& v)
+	{
+		return (*this = detail::compute_vec4_div<T, Q, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v.x)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator/=(vec<4, U, Q> const& v)
+	{
+		return (*this = detail::compute_vec4_div<T, Q, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+	}
+
+	// -- Increment and decrement operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator++()
+	{
+		++this->x;
+		++this->y;
+		++this->z;
+		++this->w;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator--()
+	{
+		--this->x;
+		--this->y;
+		--this->z;
+		--this->w;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> vec<4, T, Q>::operator++(int)
+	{
+		vec<4, T, Q> Result(*this);
+		++*this;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> vec<4, T, Q>::operator--(int)
+	{
+		vec<4, T, Q> Result(*this);
+		--*this;
+		return Result;
+	}
+
+	// -- Unary bit operators --
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator%=(U scalar)
+	{
+		return (*this = detail::compute_vec4_mod<T, Q, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(scalar)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator%=(vec<1, U, Q> const& v)
+	{
+		return (*this = detail::compute_vec4_mod<T, Q, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator%=(vec<4, U, Q> const& v)
+	{
+		return (*this = detail::compute_vec4_mod<T, Q, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator&=(U scalar)
+	{
+		return (*this = detail::compute_vec4_and<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(scalar)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator&=(vec<1, U, Q> const& v)
+	{
+		return (*this = detail::compute_vec4_and<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator&=(vec<4, U, Q> const& v)
+	{
+		return (*this = detail::compute_vec4_and<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator|=(U scalar)
+	{
+		return (*this = detail::compute_vec4_or<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(scalar)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator|=(vec<1, U, Q> const& v)
+	{
+		return (*this = detail::compute_vec4_or<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator|=(vec<4, U, Q> const& v)
+	{
+		return (*this = detail::compute_vec4_or<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator^=(U scalar)
+	{
+		return (*this = detail::compute_vec4_xor<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(scalar)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator^=(vec<1, U, Q> const& v)
+	{
+		return (*this = detail::compute_vec4_xor<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator^=(vec<4, U, Q> const& v)
+	{
+		return (*this = detail::compute_vec4_xor<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator<<=(U scalar)
+	{
+		return (*this = detail::compute_vec4_shift_left<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(scalar)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator<<=(vec<1, U, Q> const& v)
+	{
+		return (*this = detail::compute_vec4_shift_left<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator<<=(vec<4, U, Q> const& v)
+	{
+		return (*this = detail::compute_vec4_shift_left<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator>>=(U scalar)
+	{
+		return (*this = detail::compute_vec4_shift_right<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(scalar)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator>>=(vec<1, U, Q> const& v)
+	{
+		return (*this = detail::compute_vec4_shift_right<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator>>=(vec<4, U, Q> const& v)
+	{
+		return (*this = detail::compute_vec4_shift_right<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+	}
+
+	// -- Unary constant operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator+(vec<4, T, Q> const& v)
+	{
+		return v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator-(vec<4, T, Q> const& v)
+	{
+		return vec<4, T, Q>(0) -= v;
+	}
+
+	// -- Binary arithmetic operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator+(vec<4, T, Q> const& v, T const & scalar)
+	{
+		return vec<4, T, Q>(v) += scalar;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator+(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<4, T, Q>(v1) += v2;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator+(T scalar, vec<4, T, Q> const& v)
+	{
+		return vec<4, T, Q>(v) += scalar;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator+(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2)
+	{
+		return vec<4, T, Q>(v2) += v1;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator+(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2)
+	{
+		return vec<4, T, Q>(v1) += v2;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator-(vec<4, T, Q> const& v, T const & scalar)
+	{
+		return vec<4, T, Q>(v) -= scalar;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator-(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<4, T, Q>(v1) -= v2;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator-(T scalar, vec<4, T, Q> const& v)
+	{
+		return vec<4, T, Q>(scalar) -= v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator-(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2)
+	{
+		return vec<4, T, Q>(v1.x) -= v2;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator-(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2)
+	{
+		return vec<4, T, Q>(v1) -= v2;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator*(vec<4, T, Q> const& v, T const & scalar)
+	{
+		return vec<4, T, Q>(v) *= scalar;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator*(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<4, T, Q>(v1) *= v2;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator*(T scalar, vec<4, T, Q> const& v)
+	{
+		return vec<4, T, Q>(v) *= scalar;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator*(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2)
+	{
+		return vec<4, T, Q>(v2) *= v1;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator*(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2)
+	{
+		return vec<4, T, Q>(v1) *= v2;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator/(vec<4, T, Q> const& v, T const & scalar)
+	{
+		return vec<4, T, Q>(v) /= scalar;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator/(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<4, T, Q>(v1) /= v2;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator/(T scalar, vec<4, T, Q> const& v)
+	{
+		return vec<4, T, Q>(scalar) /= v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator/(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2)
+	{
+		return vec<4, T, Q>(v1.x) /= v2;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator/(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2)
+	{
+		return vec<4, T, Q>(v1) /= v2;
+	}
+
+	// -- Binary bit operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator%(vec<4, T, Q> const& v, T scalar)
+	{
+		return vec<4, T, Q>(v) %= scalar;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator%(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<4, T, Q>(v1) %= v2.x;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator%(T scalar, vec<4, T, Q> const& v)
+	{
+		return vec<4, T, Q>(scalar) %= v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator%(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v)
+	{
+		return vec<4, T, Q>(scalar.x) %= v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator%(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2)
+	{
+		return vec<4, T, Q>(v1) %= v2;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator&(vec<4, T, Q> const& v, T scalar)
+	{
+		return vec<4, T, Q>(v) &= scalar;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator&(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar)
+	{
+		return vec<4, T, Q>(v) &= scalar;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator&(T scalar, vec<4, T, Q> const& v)
+	{
+		return vec<4, T, Q>(scalar) &= v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator&(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2)
+	{
+		return vec<4, T, Q>(v1.x) &= v2;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator&(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2)
+	{
+		return vec<4, T, Q>(v1) &= v2;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator|(vec<4, T, Q> const& v, T scalar)
+	{
+		return vec<4, T, Q>(v) |= scalar;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator|(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<4, T, Q>(v1) |= v2.x;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator|(T scalar, vec<4, T, Q> const& v)
+	{
+		return vec<4, T, Q>(scalar) |= v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator|(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2)
+	{
+		return vec<4, T, Q>(v1.x) |= v2;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator|(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2)
+	{
+		return vec<4, T, Q>(v1) |= v2;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator^(vec<4, T, Q> const& v, T scalar)
+	{
+		return vec<4, T, Q>(v) ^= scalar;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator^(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<4, T, Q>(v1) ^= v2.x;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator^(T scalar, vec<4, T, Q> const& v)
+	{
+		return vec<4, T, Q>(scalar) ^= v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator^(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2)
+	{
+		return vec<4, T, Q>(v1.x) ^= v2;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator^(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2)
+	{
+		return vec<4, T, Q>(v1) ^= v2;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator<<(vec<4, T, Q> const& v, T scalar)
+	{
+		return vec<4, T, Q>(v) <<= scalar;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator<<(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<4, T, Q>(v1) <<= v2.x;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator<<(T scalar, vec<4, T, Q> const& v)
+	{
+		return vec<4, T, Q>(scalar) <<= v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator<<(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2)
+	{
+		return vec<4, T, Q>(v1.x) <<= v2;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator<<(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2)
+	{
+		return vec<4, T, Q>(v1) <<= v2;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator>>(vec<4, T, Q> const& v, T scalar)
+	{
+		return vec<4, T, Q>(v) >>= scalar;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator>>(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2)
+	{
+		return vec<4, T, Q>(v1) >>= v2.x;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator>>(T scalar, vec<4, T, Q> const& v)
+	{
+		return vec<4, T, Q>(scalar) >>= v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator>>(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2)
+	{
+		return vec<4, T, Q>(v1.x) >>= v2;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator>>(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2)
+	{
+		return vec<4, T, Q>(v1) >>= v2;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator~(vec<4, T, Q> const& v)
+	{
+		return detail::compute_vec4_bitwise_not<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(v);
+	}
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator==(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2)
+	{
+		return detail::compute_vec4_equal<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(v1, v2);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator!=(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2)
+	{
+		return detail::compute_vec4_nequal<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(v1, v2);
+	}
+
+	template<qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, bool, Q> operator&&(vec<4, bool, Q> const& v1, vec<4, bool, Q> const& v2)
+	{
+		return vec<4, bool, Q>(v1.x && v2.x, v1.y && v2.y, v1.z && v2.z, v1.w && v2.w);
+	}
+
+	template<qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, bool, Q> operator||(vec<4, bool, Q> const& v1, vec<4, bool, Q> const& v2)
+	{
+		return vec<4, bool, Q>(v1.x || v2.x, v1.y || v2.y, v1.z || v2.z, v1.w || v2.w);
+	}
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+#	include "type_vec4_simd.inl"
+#endif
diff --git a/engine/inc/glm/detail/type_vec4_simd.inl b/engine/inc/glm/detail/type_vec4_simd.inl
new file mode 100644
index 00000000..415b73cb
--- /dev/null
+++ b/engine/inc/glm/detail/type_vec4_simd.inl
@@ -0,0 +1,463 @@
+#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+namespace glm{
+namespace detail
+{
+#	if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+	template<qualifier Q, int E0, int E1, int E2, int E3>
+	struct _swizzle_base1<4, float, Q, E0,E1,E2,E3, true> : public _swizzle_base0<float, 4>
+	{
+		GLM_FUNC_QUALIFIER vec<4, float, Q> operator ()()  const
+		{
+			__m128 data = *reinterpret_cast<__m128 const*>(&this->_buffer);
+
+			vec<4, float, Q> Result;
+#			if GLM_ARCH & GLM_ARCH_AVX_BIT
+				Result.data = _mm_permute_ps(data, _MM_SHUFFLE(E3, E2, E1, E0));
+#			else
+				Result.data = _mm_shuffle_ps(data, data, _MM_SHUFFLE(E3, E2, E1, E0));
+#			endif
+			return Result;
+		}
+	};
+
+	template<qualifier Q, int E0, int E1, int E2, int E3>
+	struct _swizzle_base1<4, int, Q, E0,E1,E2,E3, true> : public _swizzle_base0<int, 4>
+	{
+		GLM_FUNC_QUALIFIER vec<4, int, Q> operator ()()  const
+		{
+			__m128i data = *reinterpret_cast<__m128i const*>(&this->_buffer);
+
+			vec<4, int, Q> Result;
+			Result.data = _mm_shuffle_epi32(data, _MM_SHUFFLE(E3, E2, E1, E0));
+			return Result;
+		}
+	};
+
+	template<qualifier Q, int E0, int E1, int E2, int E3>
+	struct _swizzle_base1<4, uint, Q, E0,E1,E2,E3, true> : public _swizzle_base0<uint, 4>
+	{
+		GLM_FUNC_QUALIFIER vec<4, uint, Q> operator ()()  const
+		{
+			__m128i data = *reinterpret_cast<__m128i const*>(&this->_buffer);
+
+			vec<4, uint, Q> Result;
+			Result.data = _mm_shuffle_epi32(data, _MM_SHUFFLE(E3, E2, E1, E0));
+			return Result;
+		}
+	};
+#	endif// GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+
+	template<qualifier Q>
+	struct compute_vec4_add<float, Q, true>
+	{
+		static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b)
+		{
+			vec<4, float, Q> Result;
+			Result.data = _mm_add_ps(a.data, b.data);
+			return Result;
+		}
+	};
+
+#	if GLM_ARCH & GLM_ARCH_AVX_BIT
+	template<qualifier Q>
+	struct compute_vec4_add<double, Q, true>
+	{
+		static vec<4, double, Q> call(vec<4, double, Q> const& a, vec<4, double, Q> const& b)
+		{
+			vec<4, double, Q> Result;
+			Result.data = _mm256_add_pd(a.data, b.data);
+			return Result;
+		}
+	};
+#	endif
+
+	template<qualifier Q>
+	struct compute_vec4_sub<float, Q, true>
+	{
+		static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b)
+		{
+			vec<4, float, Q> Result;
+			Result.data = _mm_sub_ps(a.data, b.data);
+			return Result;
+		}
+	};
+
+#	if GLM_ARCH & GLM_ARCH_AVX_BIT
+	template<qualifier Q>
+	struct compute_vec4_sub<double, Q, true>
+	{
+		static vec<4, double, Q> call(vec<4, double, Q> const& a, vec<4, double, Q> const& b)
+		{
+			vec<4, double, Q> Result;
+			Result.data = _mm256_sub_pd(a.data, b.data);
+			return Result;
+		}
+	};
+#	endif
+
+	template<qualifier Q>
+	struct compute_vec4_mul<float, Q, true>
+	{
+		static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b)
+		{
+			vec<4, float, Q> Result;
+			Result.data = _mm_mul_ps(a.data, b.data);
+			return Result;
+		}
+	};
+
+#	if GLM_ARCH & GLM_ARCH_AVX_BIT
+	template<qualifier Q>
+	struct compute_vec4_mul<double, Q, true>
+	{
+		static vec<4, double, Q> call(vec<4, double, Q> const& a, vec<4, double, Q> const& b)
+		{
+			vec<4, double, Q> Result;
+			Result.data = _mm256_mul_pd(a.data, b.data);
+			return Result;
+		}
+	};
+#	endif
+
+	template<qualifier Q>
+	struct compute_vec4_div<float, Q, true>
+	{
+		static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b)
+		{
+			vec<4, float, Q> Result;
+			Result.data = _mm_div_ps(a.data, b.data);
+			return Result;
+		}
+	};
+
+	#	if GLM_ARCH & GLM_ARCH_AVX_BIT
+	template<qualifier Q>
+	struct compute_vec4_div<double, Q, true>
+	{
+		static vec<4, double, Q> call(vec<4, double, Q> const& a, vec<4, double, Q> const& b)
+		{
+			vec<4, double, Q> Result;
+			Result.data = _mm256_div_pd(a.data, b.data);
+			return Result;
+		}
+	};
+#	endif
+
+	template<>
+	struct compute_vec4_div<float, aligned_lowp, true>
+	{
+		static vec<4, float, aligned_lowp> call(vec<4, float, aligned_lowp> const& a, vec<4, float, aligned_lowp> const& b)
+		{
+			vec<4, float, aligned_lowp> Result;
+			Result.data = _mm_mul_ps(a.data, _mm_rcp_ps(b.data));
+			return Result;
+		}
+	};
+
+	template<typename T, qualifier Q>
+	struct compute_vec4_and<T, Q, true, 32, true>
+	{
+		static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			vec<4, T, Q> Result;
+			Result.data = _mm_and_si128(a.data, b.data);
+			return Result;
+		}
+	};
+
+#	if GLM_ARCH & GLM_ARCH_AVX2_BIT
+	template<typename T, qualifier Q>
+	struct compute_vec4_and<T, Q, true, 64, true>
+	{
+		static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			vec<4, T, Q> Result;
+			Result.data = _mm256_and_si256(a.data, b.data);
+			return Result;
+		}
+	};
+#	endif
+
+	template<typename T, qualifier Q>
+	struct compute_vec4_or<T, Q, true, 32, true>
+	{
+		static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			vec<4, T, Q> Result;
+			Result.data = _mm_or_si128(a.data, b.data);
+			return Result;
+		}
+	};
+
+#	if GLM_ARCH & GLM_ARCH_AVX2_BIT
+	template<typename T, qualifier Q>
+	struct compute_vec4_or<T, Q, true, 64, true>
+	{
+		static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			vec<4, T, Q> Result;
+			Result.data = _mm256_or_si256(a.data, b.data);
+			return Result;
+		}
+	};
+#	endif
+
+	template<typename T, qualifier Q>
+	struct compute_vec4_xor<T, Q, true, 32, true>
+	{
+		static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			vec<4, T, Q> Result;
+			Result.data = _mm_xor_si128(a.data, b.data);
+			return Result;
+		}
+	};
+
+#	if GLM_ARCH & GLM_ARCH_AVX2_BIT
+	template<typename T, qualifier Q>
+	struct compute_vec4_xor<T, Q, true, 64, true>
+	{
+		static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			vec<4, T, Q> Result;
+			Result.data = _mm256_xor_si256(a.data, b.data);
+			return Result;
+		}
+	};
+#	endif
+
+	template<typename T, qualifier Q>
+	struct compute_vec4_shift_left<T, Q, true, 32, true>
+	{
+		static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			vec<4, T, Q> Result;
+			Result.data = _mm_sll_epi32(a.data, b.data);
+			return Result;
+		}
+	};
+
+#	if GLM_ARCH & GLM_ARCH_AVX2_BIT
+	template<typename T, qualifier Q>
+	struct compute_vec4_shift_left<T, Q, true, 64, true>
+	{
+		static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			vec<4, T, Q> Result;
+			Result.data = _mm256_sll_epi64(a.data, b.data);
+			return Result;
+		}
+	};
+#	endif
+
+	template<typename T, qualifier Q>
+	struct compute_vec4_shift_right<T, Q, true, 32, true>
+	{
+		static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			vec<4, T, Q> Result;
+			Result.data = _mm_srl_epi32(a.data, b.data);
+			return Result;
+		}
+	};
+
+#	if GLM_ARCH & GLM_ARCH_AVX2_BIT
+	template<typename T, qualifier Q>
+	struct compute_vec4_shift_right<T, Q, true, 64, true>
+	{
+		static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+		{
+			vec<4, T, Q> Result;
+			Result.data = _mm256_srl_epi64(a.data, b.data);
+			return Result;
+		}
+	};
+#	endif
+
+	template<typename T, qualifier Q>
+	struct compute_vec4_bitwise_not<T, Q, true, 32, true>
+	{
+		static vec<4, T, Q> call(vec<4, T, Q> const& v)
+		{
+			vec<4, T, Q> Result;
+			Result.data = _mm_xor_si128(v.data, _mm_set1_epi32(-1));
+			return Result;
+		}
+	};
+
+#	if GLM_ARCH & GLM_ARCH_AVX2_BIT
+	template<typename T, qualifier Q>
+	struct compute_vec4_bitwise_not<T, Q, true, 64, true>
+	{
+		static vec<4, T, Q> call(vec<4, T, Q> const& v)
+		{
+			vec<4, T, Q> Result;
+			Result.data = _mm256_xor_si256(v.data, _mm_set1_epi32(-1));
+			return Result;
+		}
+	};
+#	endif
+
+	template<qualifier Q>
+	struct compute_vec4_equal<float, Q, false, 32, true>
+	{
+		static bool call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2)
+		{
+			return _mm_movemask_ps(_mm_cmpeq_ps(v1.data, v2.data)) != 0;
+		}
+	};
+
+#	if GLM_ARCH & GLM_ARCH_SSE41_BIT
+	template<qualifier Q>
+	struct compute_vec4_equal<int, Q, true, 32, true>
+	{
+		static bool call(vec<4, int, Q> const& v1, vec<4, int, Q> const& v2)
+		{
+			//return _mm_movemask_epi8(_mm_cmpeq_epi32(v1.data, v2.data)) != 0;
+			__m128i neq = _mm_xor_si128(v1.data, v2.data);
+			return _mm_test_all_zeros(neq, neq) == 0;
+		}
+	};
+#	endif
+
+	template<qualifier Q>
+	struct compute_vec4_nequal<float, Q, false, 32, true>
+	{
+		static bool call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2)
+		{
+			return _mm_movemask_ps(_mm_cmpneq_ps(v1.data, v2.data)) != 0;
+		}
+	};
+
+#	if GLM_ARCH & GLM_ARCH_SSE41_BIT
+	template<qualifier Q>
+	struct compute_vec4_nequal<int, Q, true, 32, true>
+	{
+		static bool call(vec<4, int, Q> const& v1, vec<4, int, Q> const& v2)
+		{
+			//return _mm_movemask_epi8(_mm_cmpneq_epi32(v1.data, v2.data)) != 0;
+			__m128i neq = _mm_xor_si128(v1.data, v2.data);
+			return _mm_test_all_zeros(neq, neq) != 0;
+		}
+	};
+#	endif
+}//namespace detail
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_lowp>::vec(float _s) :
+		data(_mm_set1_ps(_s))
+	{}
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_mediump>::vec(float _s) :
+		data(_mm_set1_ps(_s))
+	{}
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_highp>::vec(float _s) :
+		data(_mm_set1_ps(_s))
+	{}
+
+#	if GLM_ARCH & GLM_ARCH_AVX_BIT
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, double, aligned_lowp>::vec(double _s) :
+		data(_mm256_set1_pd(_s))
+	{}
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, double, aligned_mediump>::vec(double _s) :
+		data(_mm256_set1_pd(_s))
+	{}
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, double, aligned_highp>::vec(double _s) :
+		data(_mm256_set1_pd(_s))
+	{}
+#	endif
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_lowp>::vec(int _s) :
+		data(_mm_set1_epi32(_s))
+	{}
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_mediump>::vec(int _s) :
+		data(_mm_set1_epi32(_s))
+	{}
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_highp>::vec(int _s) :
+		data(_mm_set1_epi32(_s))
+	{}
+
+#	if GLM_ARCH & GLM_ARCH_AVX2_BIT
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, detail::int64, aligned_lowp>::vec(detail::int64 _s) :
+		data(_mm256_set1_epi64x(_s))
+	{}
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, detail::int64, aligned_mediump>::vec(detail::int64 _s) :
+		data(_mm256_set1_epi64x(_s))
+	{}
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, detail::int64, aligned_highp>::vec(detail::int64 _s) :
+		data(_mm256_set1_epi64x(_s))
+	{}
+#	endif
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_lowp>::vec(float _x, float _y, float _z, float _w) :
+		data(_mm_set_ps(_w, _z, _y, _x))
+	{}
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_mediump>::vec(float _x, float _y, float _z, float _w) :
+		data(_mm_set_ps(_w, _z, _y, _x))
+	{}
+
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_highp>::vec(float _x, float _y, float _z, float _w) :
+		data(_mm_set_ps(_w, _z, _y, _x))
+	{}
+
+	template<>
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_lowp>::vec(int _x, int _y, int _z, int _w) :
+		data(_mm_set_epi32(_w, _z, _y, _x))
+	{}
+
+	template<>
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_mediump>::vec(int _x, int _y, int _z, int _w) :
+		data(_mm_set_epi32(_w, _z, _y, _x))
+	{}
+
+	template<>
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_highp>::vec(int _x, int _y, int _z, int _w) :
+		data(_mm_set_epi32(_w, _z, _y, _x))
+	{}
+
+	template<>
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_lowp>::vec(int _x, int _y, int _z, int _w) :
+		data(_mm_cvtepi32_ps(_mm_set_epi32(_w, _z, _y, _x)))
+	{}
+
+	template<>
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_mediump>::vec(int _x, int _y, int _z, int _w) :
+		data(_mm_cvtepi32_ps(_mm_set_epi32(_w, _z, _y, _x)))
+	{}
+
+	template<>
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_highp>::vec(int _x, int _y, int _z, int _w) :
+		data(_mm_cvtepi32_ps(_mm_set_epi32(_w, _z, _y, _x)))
+	{}
+}//namespace glm
+
+#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
diff --git a/engine/inc/glm/exponential.hpp b/engine/inc/glm/exponential.hpp
new file mode 100644
index 00000000..f8fb886f
--- /dev/null
+++ b/engine/inc/glm/exponential.hpp
@@ -0,0 +1,110 @@
+/// @ref core
+/// @file glm/exponential.hpp
+///
+/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+///
+/// @defgroup core_func_exponential Exponential functions
+/// @ingroup core
+///
+/// Provides GLSL exponential functions
+///
+/// These all operate component-wise. The description is per component.
+///
+/// Include <glm/exponential.hpp> to use these core features.
+
+#pragma once
+
+#include "detail/type_vec1.hpp"
+#include "detail/type_vec2.hpp"
+#include "detail/type_vec3.hpp"
+#include "detail/type_vec4.hpp"
+#include <cmath>
+
+namespace glm
+{
+	/// @addtogroup core_func_exponential
+	/// @{
+
+	/// Returns 'base' raised to the power 'exponent'.
+	///
+	/// @param base Floating point value. pow function is defined for input values of 'base' defined in the range (inf-, inf+) in the limit of the type qualifier.
+	/// @param exponent Floating point value representing the 'exponent'.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/pow.xml">GLSL pow man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> pow(vec<L, T, Q> const& base, vec<L, T, Q> const& exponent);
+
+	/// Returns the natural exponentiation of x, i.e., e^x.
+	///
+	/// @param v exp function is defined for input values of v defined in the range (inf-, inf+) in the limit of the type qualifier.
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	/// @tparam T Floating-point scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/exp.xml">GLSL exp man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> exp(vec<L, T, Q> const& v);
+
+	/// Returns the natural logarithm of v, i.e.,
+	/// returns the value y which satisfies the equation x = e^y.
+	/// Results are undefined if v <= 0.
+	///
+	/// @param v log function is defined for input values of v defined in the range (0, inf+) in the limit of the type qualifier.
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	/// @tparam T Floating-point scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/log.xml">GLSL log man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> log(vec<L, T, Q> const& v);
+
+	/// Returns 2 raised to the v power.
+	///
+	/// @param v exp2 function is defined for input values of v defined in the range (inf-, inf+) in the limit of the type qualifier.
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	/// @tparam T Floating-point scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/exp2.xml">GLSL exp2 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> exp2(vec<L, T, Q> const& v);
+
+	/// Returns the base 2 log of x, i.e., returns the value y,
+	/// which satisfies the equation x = 2 ^ y.
+	///
+	/// @param v log2 function is defined for input values of v defined in the range (0, inf+) in the limit of the type qualifier.
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	/// @tparam T Floating-point scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/log2.xml">GLSL log2 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> log2(vec<L, T, Q> const& v);
+
+	/// Returns the positive square root of v.
+	///
+	/// @param v sqrt function is defined for input values of v defined in the range [0, inf+) in the limit of the type qualifier.
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	/// @tparam T Floating-point scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sqrt.xml">GLSL sqrt man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> sqrt(vec<L, T, Q> const& v);
+
+	/// Returns the reciprocal of the positive square root of v.
+	///
+	/// @param v inversesqrt function is defined for input values of v defined in the range [0, inf+) in the limit of the type qualifier.
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	/// @tparam T Floating-point scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inversesqrt.xml">GLSL inversesqrt man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> inversesqrt(vec<L, T, Q> const& v);
+
+	/// @}
+}//namespace glm
+
+#include "detail/func_exponential.inl"
diff --git a/engine/inc/glm/ext.hpp b/engine/inc/glm/ext.hpp
new file mode 100644
index 00000000..3bc8db27
--- /dev/null
+++ b/engine/inc/glm/ext.hpp
@@ -0,0 +1,196 @@
+/// @file glm/ext.hpp
+///
+/// @ref core (Dependence)
+
+#include "detail/setup.hpp"
+
+#pragma once
+
+#include "glm.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_MESSAGE_EXT_INCLUDED_DISPLAYED)
+#	define GLM_MESSAGE_EXT_INCLUDED_DISPLAYED
+#	pragma message("GLM: All extensions included (not recommended)")
+#endif//GLM_MESSAGES
+
+#include "./ext/matrix_double2x2.hpp"
+#include "./ext/matrix_double2x2_precision.hpp"
+#include "./ext/matrix_double2x3.hpp"
+#include "./ext/matrix_double2x3_precision.hpp"
+#include "./ext/matrix_double2x4.hpp"
+#include "./ext/matrix_double2x4_precision.hpp"
+#include "./ext/matrix_double3x2.hpp"
+#include "./ext/matrix_double3x2_precision.hpp"
+#include "./ext/matrix_double3x3.hpp"
+#include "./ext/matrix_double3x3_precision.hpp"
+#include "./ext/matrix_double3x4.hpp"
+#include "./ext/matrix_double3x4_precision.hpp"
+#include "./ext/matrix_double4x2.hpp"
+#include "./ext/matrix_double4x2_precision.hpp"
+#include "./ext/matrix_double4x3.hpp"
+#include "./ext/matrix_double4x3_precision.hpp"
+#include "./ext/matrix_double4x4.hpp"
+#include "./ext/matrix_double4x4_precision.hpp"
+
+#include "./ext/matrix_float2x2.hpp"
+#include "./ext/matrix_float2x2_precision.hpp"
+#include "./ext/matrix_float2x3.hpp"
+#include "./ext/matrix_float2x3_precision.hpp"
+#include "./ext/matrix_float2x4.hpp"
+#include "./ext/matrix_float2x4_precision.hpp"
+#include "./ext/matrix_float3x2.hpp"
+#include "./ext/matrix_float3x2_precision.hpp"
+#include "./ext/matrix_float3x3.hpp"
+#include "./ext/matrix_float3x3_precision.hpp"
+#include "./ext/matrix_float3x4.hpp"
+#include "./ext/matrix_float3x4_precision.hpp"
+#include "./ext/matrix_float4x2.hpp"
+#include "./ext/matrix_float4x2_precision.hpp"
+#include "./ext/matrix_float4x3.hpp"
+#include "./ext/matrix_float4x3_precision.hpp"
+#include "./ext/matrix_float4x4.hpp"
+#include "./ext/matrix_float4x4_precision.hpp"
+
+#include "./ext/matrix_relational.hpp"
+
+#include "./ext/quaternion_double.hpp"
+#include "./ext/quaternion_double_precision.hpp"
+#include "./ext/quaternion_float.hpp"
+#include "./ext/quaternion_float_precision.hpp"
+#include "./ext/quaternion_geometric.hpp"
+#include "./ext/quaternion_relational.hpp"
+
+#include "./ext/scalar_constants.hpp"
+#include "./ext/scalar_int_sized.hpp"
+#include "./ext/scalar_relational.hpp"
+
+#include "./ext/vector_bool1.hpp"
+#include "./ext/vector_bool1_precision.hpp"
+#include "./ext/vector_bool2.hpp"
+#include "./ext/vector_bool2_precision.hpp"
+#include "./ext/vector_bool3.hpp"
+#include "./ext/vector_bool3_precision.hpp"
+#include "./ext/vector_bool4.hpp"
+#include "./ext/vector_bool4_precision.hpp"
+
+#include "./ext/vector_double1.hpp"
+#include "./ext/vector_double1_precision.hpp"
+#include "./ext/vector_double2.hpp"
+#include "./ext/vector_double2_precision.hpp"
+#include "./ext/vector_double3.hpp"
+#include "./ext/vector_double3_precision.hpp"
+#include "./ext/vector_double4.hpp"
+#include "./ext/vector_double4_precision.hpp"
+
+#include "./ext/vector_float1.hpp"
+#include "./ext/vector_float1_precision.hpp"
+#include "./ext/vector_float2.hpp"
+#include "./ext/vector_float2_precision.hpp"
+#include "./ext/vector_float3.hpp"
+#include "./ext/vector_float3_precision.hpp"
+#include "./ext/vector_float4.hpp"
+#include "./ext/vector_float4_precision.hpp"
+
+#include "./ext/vector_int1.hpp"
+#include "./ext/vector_int1_precision.hpp"
+#include "./ext/vector_int2.hpp"
+#include "./ext/vector_int2_precision.hpp"
+#include "./ext/vector_int3.hpp"
+#include "./ext/vector_int3_precision.hpp"
+#include "./ext/vector_int4.hpp"
+#include "./ext/vector_int4_precision.hpp"
+
+#include "./ext/vector_relational.hpp"
+
+#include "./ext/vector_uint1.hpp"
+#include "./ext/vector_uint1_precision.hpp"
+#include "./ext/vector_uint2.hpp"
+#include "./ext/vector_uint2_precision.hpp"
+#include "./ext/vector_uint3.hpp"
+#include "./ext/vector_uint3_precision.hpp"
+#include "./ext/vector_uint4.hpp"
+#include "./ext/vector_uint4_precision.hpp"
+
+#include "./gtc/bitfield.hpp"
+#include "./gtc/color_space.hpp"
+#include "./gtc/constants.hpp"
+#include "./gtc/epsilon.hpp"
+#include "./gtc/integer.hpp"
+#include "./gtc/matrix_access.hpp"
+#include "./gtc/matrix_integer.hpp"
+#include "./gtc/matrix_inverse.hpp"
+#include "./gtc/matrix_transform.hpp"
+#include "./gtc/noise.hpp"
+#include "./gtc/packing.hpp"
+#include "./gtc/quaternion.hpp"
+#include "./gtc/random.hpp"
+#include "./gtc/reciprocal.hpp"
+#include "./gtc/round.hpp"
+#include "./gtc/type_precision.hpp"
+#include "./gtc/type_ptr.hpp"
+#include "./gtc/ulp.hpp"
+#include "./gtc/vec1.hpp"
+#if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE
+#	include "./gtc/type_aligned.hpp"
+#endif
+
+#ifdef GLM_ENABLE_EXPERIMENTAL
+#include "./gtx/associated_min_max.hpp"
+#include "./gtx/bit.hpp"
+#include "./gtx/closest_point.hpp"
+#include "./gtx/color_encoding.hpp"
+#include "./gtx/color_space.hpp"
+#include "./gtx/color_space_YCoCg.hpp"
+#include "./gtx/compatibility.hpp"
+#include "./gtx/component_wise.hpp"
+#include "./gtx/dual_quaternion.hpp"
+#include "./gtx/euler_angles.hpp"
+#include "./gtx/extend.hpp"
+#include "./gtx/extended_min_max.hpp"
+#include "./gtx/fast_exponential.hpp"
+#include "./gtx/fast_square_root.hpp"
+#include "./gtx/fast_trigonometry.hpp"
+#include "./gtx/functions.hpp"
+#include "./gtx/gradient_paint.hpp"
+#include "./gtx/handed_coordinate_space.hpp"
+#include "./gtx/integer.hpp"
+#include "./gtx/intersect.hpp"
+#include "./gtx/log_base.hpp"
+#include "./gtx/matrix_cross_product.hpp"
+#include "./gtx/matrix_interpolation.hpp"
+#include "./gtx/matrix_major_storage.hpp"
+#include "./gtx/matrix_operation.hpp"
+#include "./gtx/matrix_query.hpp"
+#include "./gtx/mixed_product.hpp"
+#include "./gtx/norm.hpp"
+#include "./gtx/normal.hpp"
+#include "./gtx/normalize_dot.hpp"
+#include "./gtx/number_precision.hpp"
+#include "./gtx/optimum_pow.hpp"
+#include "./gtx/orthonormalize.hpp"
+#include "./gtx/perpendicular.hpp"
+#include "./gtx/polar_coordinates.hpp"
+#include "./gtx/projection.hpp"
+#include "./gtx/quaternion.hpp"
+#include "./gtx/raw_data.hpp"
+#include "./gtx/rotate_vector.hpp"
+#include "./gtx/spline.hpp"
+#include "./gtx/std_based_type.hpp"
+#if !(GLM_COMPILER & GLM_COMPILER_CUDA)
+#	include "./gtx/string_cast.hpp"
+#endif
+#include "./gtx/transform.hpp"
+#include "./gtx/transform2.hpp"
+#include "./gtx/vec_swizzle.hpp"
+#include "./gtx/vector_angle.hpp"
+#include "./gtx/vector_query.hpp"
+#include "./gtx/wrap.hpp"
+
+#if GLM_HAS_TEMPLATE_ALIASES
+#	include "./gtx/scalar_multiplication.hpp"
+#endif
+
+#if GLM_HAS_RANGE_FOR
+#	include "./gtx/range.hpp"
+#endif
+#endif//GLM_ENABLE_EXPERIMENTAL
diff --git a/engine/inc/glm/ext/matrix_clip_space.hpp b/engine/inc/glm/ext/matrix_clip_space.hpp
new file mode 100644
index 00000000..c3874f2f
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_clip_space.hpp
@@ -0,0 +1,522 @@
+/// @ref ext_matrix_clip_space
+/// @file glm/ext/matrix_clip_space.hpp
+///
+/// @defgroup ext_matrix_clip_space GLM_EXT_matrix_clip_space
+/// @ingroup ext
+///
+/// Defines functions that generate clip space transformation matrices.
+///
+/// The matrices generated by this extension use standard OpenGL fixed-function
+/// conventions. For example, the lookAt function generates a transform from world
+/// space into the specific eye space that the projective matrix functions
+/// (perspective, ortho, etc) are designed to expect. The OpenGL compatibility
+/// specifications defines the particular layout of this eye space.
+///
+/// Include <glm/ext/matrix_clip_space.hpp> to use the features of this extension.
+///
+/// @see ext_matrix_transform
+/// @see ext_matrix_projection
+
+#pragma once
+
+// Dependencies
+#include "../ext/scalar_constants.hpp"
+#include "../geometric.hpp"
+#include "../trigonometric.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_matrix_clip_space extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup ext_matrix_clip_space
+	/// @{
+
+	/// Creates a matrix for projecting two-dimensional coordinates onto the screen.
+	///
+	/// @tparam T A floating-point scalar type
+	///
+	/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top, T const& zNear, T const& zFar)
+	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluOrtho2D.xml">gluOrtho2D man page</a>
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> ortho(
+		T left, T right, T bottom, T top);
+
+	/// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates.
+	/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
+	///
+	/// @tparam T A floating-point scalar type
+	///
+	/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoLH_ZO(
+		T left, T right, T bottom, T top, T zNear, T zFar);
+
+	/// Creates a matrix for an orthographic parallel viewing volume using right-handed coordinates.
+	/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
+	///
+	/// @tparam T A floating-point scalar type
+	///
+	/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoLH_NO(
+		T left, T right, T bottom, T top, T zNear, T zFar);
+
+	/// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates.
+	/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
+	///
+	/// @tparam T A floating-point scalar type
+	///
+	/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoRH_ZO(
+		T left, T right, T bottom, T top, T zNear, T zFar);
+
+	/// Creates a matrix for an orthographic parallel viewing volume, using right-handed coordinates.
+	/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
+	///
+	/// @tparam T A floating-point scalar type
+	///
+	/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoRH_NO(
+		T left, T right, T bottom, T top, T zNear, T zFar);
+
+	/// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates.
+	/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
+	///
+	/// @tparam T A floating-point scalar type
+	///
+	/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoZO(
+		T left, T right, T bottom, T top, T zNear, T zFar);
+
+	/// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
+	/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
+	///
+	/// @tparam T A floating-point scalar type
+	///
+	/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoNO(
+		T left, T right, T bottom, T top, T zNear, T zFar);
+
+	/// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates.
+	/// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
+	/// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
+	///
+	/// @tparam T A floating-point scalar type
+	///
+	/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoLH(
+		T left, T right, T bottom, T top, T zNear, T zFar);
+
+	/// Creates a matrix for an orthographic parallel viewing volume, using right-handed coordinates.
+	/// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
+	/// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
+	///
+	/// @tparam T A floating-point scalar type
+	///
+	/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoRH(
+		T left, T right, T bottom, T top, T zNear, T zFar);
+
+	/// Creates a matrix for an orthographic parallel viewing volume, using the default handedness and default near and far clip planes definition.
+	/// To change default handedness use GLM_FORCE_LEFT_HANDED. To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE.
+	///
+	/// @tparam T A floating-point scalar type
+	///
+	/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
+	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glOrtho.xml">glOrtho man page</a>
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> ortho(
+		T left, T right, T bottom, T top, T zNear, T zFar);
+
+	/// Creates a left handed frustum matrix.
+	/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
+	///
+	/// @tparam T A floating-point scalar type
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumLH_ZO(
+		T left, T right, T bottom, T top, T near, T far);
+
+	/// Creates a left handed frustum matrix.
+	/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
+	///
+	/// @tparam T A floating-point scalar type
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumLH_NO(
+		T left, T right, T bottom, T top, T near, T far);
+
+	/// Creates a right handed frustum matrix.
+	/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
+	///
+	/// @tparam T A floating-point scalar type
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumRH_ZO(
+		T left, T right, T bottom, T top, T near, T far);
+
+	/// Creates a right handed frustum matrix.
+	/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
+	///
+	/// @tparam T A floating-point scalar type
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumRH_NO(
+		T left, T right, T bottom, T top, T near, T far);
+
+	/// Creates a frustum matrix using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
+	/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
+	///
+	/// @tparam T A floating-point scalar type
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumZO(
+		T left, T right, T bottom, T top, T near, T far);
+
+	/// Creates a frustum matrix using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
+	/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
+	///
+	/// @tparam T A floating-point scalar type
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumNO(
+		T left, T right, T bottom, T top, T near, T far);
+
+	/// Creates a left handed frustum matrix.
+	/// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
+	/// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
+	///
+	/// @tparam T A floating-point scalar type
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumLH(
+		T left, T right, T bottom, T top, T near, T far);
+
+	/// Creates a right handed frustum matrix.
+	/// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
+	/// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
+	///
+	/// @tparam T A floating-point scalar type
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumRH(
+		T left, T right, T bottom, T top, T near, T far);
+
+	/// Creates a frustum matrix with default handedness, using the default handedness and default near and far clip planes definition.
+	/// To change default handedness use GLM_FORCE_LEFT_HANDED. To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE.
+	///
+	/// @tparam T A floating-point scalar type
+	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glFrustum.xml">glFrustum man page</a>
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> frustum(
+		T left, T right, T bottom, T top, T near, T far);
+
+
+	/// Creates a matrix for a right handed, symetric perspective-view frustum.
+	/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
+	///
+	/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
+	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
+	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
+	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
+	///
+	/// @tparam T A floating-point scalar type
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveRH_ZO(
+		T fovy, T aspect, T near, T far);
+
+	/// Creates a matrix for a right handed, symetric perspective-view frustum.
+	/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
+	///
+	/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
+	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
+	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
+	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
+	///
+	/// @tparam T A floating-point scalar type
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveRH_NO(
+		T fovy, T aspect, T near, T far);
+
+	/// Creates a matrix for a left handed, symetric perspective-view frustum.
+	/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
+	///
+	/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
+	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
+	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
+	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
+	///
+	/// @tparam T A floating-point scalar type
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveLH_ZO(
+		T fovy, T aspect, T near, T far);
+
+	/// Creates a matrix for a left handed, symetric perspective-view frustum.
+	/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
+	///
+	/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
+	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
+	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
+	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
+	///
+	/// @tparam T A floating-point scalar type
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveLH_NO(
+		T fovy, T aspect, T near, T far);
+
+	/// Creates a matrix for a symetric perspective-view frustum using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
+	/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
+	///
+	/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
+	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
+	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
+	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
+	///
+	/// @tparam T A floating-point scalar type
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveZO(
+		T fovy, T aspect, T near, T far);
+
+	/// Creates a matrix for a symetric perspective-view frustum using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
+	/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
+	///
+	/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
+	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
+	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
+	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
+	///
+	/// @tparam T A floating-point scalar type
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveNO(
+		T fovy, T aspect, T near, T far);
+
+	/// Creates a matrix for a right handed, symetric perspective-view frustum.
+	/// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
+	/// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
+	///
+	/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
+	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
+	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
+	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
+	///
+	/// @tparam T A floating-point scalar type
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveRH(
+		T fovy, T aspect, T near, T far);
+
+	/// Creates a matrix for a left handed, symetric perspective-view frustum.
+	/// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
+	/// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
+	///
+	/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
+	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
+	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
+	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
+	///
+	/// @tparam T A floating-point scalar type
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveLH(
+		T fovy, T aspect, T near, T far);
+
+	/// Creates a matrix for a symetric perspective-view frustum based on the default handedness and default near and far clip planes definition.
+	/// To change default handedness use GLM_FORCE_LEFT_HANDED. To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE.
+	///
+	/// @param fovy Specifies the field of view angle in the y direction. Expressed in radians.
+	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
+	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
+	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
+	///
+	/// @tparam T A floating-point scalar type
+	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluPerspective.xml">gluPerspective man page</a>
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspective(
+		T fovy, T aspect, T near, T far);
+
+	/// Builds a perspective projection matrix based on a field of view using right-handed coordinates.
+	/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
+	///
+	/// @param fov Expressed in radians.
+	/// @param width Width of the viewport
+	/// @param height Height of the viewport
+	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
+	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
+	///
+	/// @tparam T A floating-point scalar type
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovRH_ZO(
+		T fov, T width, T height, T near, T far);
+
+	/// Builds a perspective projection matrix based on a field of view using right-handed coordinates.
+	/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
+	///
+	/// @param fov Expressed in radians.
+	/// @param width Width of the viewport
+	/// @param height Height of the viewport
+	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
+	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
+	///
+	/// @tparam T A floating-point scalar type
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovRH_NO(
+		T fov, T width, T height, T near, T far);
+
+	/// Builds a perspective projection matrix based on a field of view using left-handed coordinates.
+	/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
+	///
+	/// @param fov Expressed in radians.
+	/// @param width Width of the viewport
+	/// @param height Height of the viewport
+	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
+	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
+	///
+	/// @tparam T A floating-point scalar type
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovLH_ZO(
+		T fov, T width, T height, T near, T far);
+
+	/// Builds a perspective projection matrix based on a field of view using left-handed coordinates.
+	/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
+	///
+	/// @param fov Expressed in radians.
+	/// @param width Width of the viewport
+	/// @param height Height of the viewport
+	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
+	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
+	///
+	/// @tparam T A floating-point scalar type
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovLH_NO(
+		T fov, T width, T height, T near, T far);
+
+	/// Builds a perspective projection matrix based on a field of view using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
+	/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
+	///
+	/// @param fov Expressed in radians.
+	/// @param width Width of the viewport
+	/// @param height Height of the viewport
+	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
+	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
+	///
+	/// @tparam T A floating-point scalar type
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovZO(
+		T fov, T width, T height, T near, T far);
+
+	/// Builds a perspective projection matrix based on a field of view using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
+	/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
+	///
+	/// @param fov Expressed in radians.
+	/// @param width Width of the viewport
+	/// @param height Height of the viewport
+	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
+	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
+	///
+	/// @tparam T A floating-point scalar type
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovNO(
+		T fov, T width, T height, T near, T far);
+
+	/// Builds a right handed perspective projection matrix based on a field of view.
+	/// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
+	/// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
+	///
+	/// @param fov Expressed in radians.
+	/// @param width Width of the viewport
+	/// @param height Height of the viewport
+	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
+	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
+	///
+	/// @tparam T A floating-point scalar type
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovRH(
+		T fov, T width, T height, T near, T far);
+
+	/// Builds a left handed perspective projection matrix based on a field of view.
+	/// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
+	/// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
+	///
+	/// @param fov Expressed in radians.
+	/// @param width Width of the viewport
+	/// @param height Height of the viewport
+	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
+	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
+	///
+	/// @tparam T A floating-point scalar type
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovLH(
+		T fov, T width, T height, T near, T far);
+
+	/// Builds a perspective projection matrix based on a field of view and the default handedness and default near and far clip planes definition.
+	/// To change default handedness use GLM_FORCE_LEFT_HANDED. To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE.
+	///
+	/// @param fov Expressed in radians.
+	/// @param width Width of the viewport
+	/// @param height Height of the viewport
+	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
+	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
+	///
+	/// @tparam T A floating-point scalar type
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFov(
+		T fov, T width, T height, T near, T far);
+
+	/// Creates a matrix for a left handed, symmetric perspective-view frustum with far plane at infinite.
+	///
+	/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
+	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
+	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
+	///
+	/// @tparam T A floating-point scalar type
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> infinitePerspectiveLH(
+		T fovy, T aspect, T near);
+
+	/// Creates a matrix for a right handed, symmetric perspective-view frustum with far plane at infinite.
+	///
+	/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
+	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
+	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
+	///
+	/// @tparam T A floating-point scalar type
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> infinitePerspectiveRH(
+		T fovy, T aspect, T near);
+
+	/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite with default handedness.
+	///
+	/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
+	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
+	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
+	///
+	/// @tparam T A floating-point scalar type
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> infinitePerspective(
+		T fovy, T aspect, T near);
+
+	/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping.
+	///
+	/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
+	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
+	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
+	///
+	/// @tparam T A floating-point scalar type
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> tweakedInfinitePerspective(
+		T fovy, T aspect, T near);
+
+	/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping.
+	///
+	/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
+	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
+	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
+	/// @param ep Epsilon
+	///
+	/// @tparam T A floating-point scalar type
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> tweakedInfinitePerspective(
+		T fovy, T aspect, T near, T ep);
+
+	/// @}
+}//namespace glm
+
+#include "matrix_clip_space.inl"
diff --git a/engine/inc/glm/ext/matrix_clip_space.inl b/engine/inc/glm/ext/matrix_clip_space.inl
new file mode 100644
index 00000000..9b870dc7
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_clip_space.inl
@@ -0,0 +1,534 @@
+namespace glm
+{
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> ortho(T left, T right, T bottom, T top)
+	{
+		mat<4, 4, T, defaultp> Result(static_cast<T>(1));
+		Result[0][0] = static_cast<T>(2) / (right - left);
+		Result[1][1] = static_cast<T>(2) / (top - bottom);
+		Result[2][2] = - static_cast<T>(1);
+		Result[3][0] = - (right + left) / (right - left);
+		Result[3][1] = - (top + bottom) / (top - bottom);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoLH_ZO(T left, T right, T bottom, T top, T zNear, T zFar)
+	{
+		mat<4, 4, T, defaultp> Result(1);
+		Result[0][0] = static_cast<T>(2) / (right - left);
+		Result[1][1] = static_cast<T>(2) / (top - bottom);
+		Result[2][2] = static_cast<T>(1) / (zFar - zNear);
+		Result[3][0] = - (right + left) / (right - left);
+		Result[3][1] = - (top + bottom) / (top - bottom);
+		Result[3][2] = - zNear / (zFar - zNear);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoLH_NO(T left, T right, T bottom, T top, T zNear, T zFar)
+	{
+		mat<4, 4, T, defaultp> Result(1);
+		Result[0][0] = static_cast<T>(2) / (right - left);
+		Result[1][1] = static_cast<T>(2) / (top - bottom);
+		Result[2][2] = static_cast<T>(2) / (zFar - zNear);
+		Result[3][0] = - (right + left) / (right - left);
+		Result[3][1] = - (top + bottom) / (top - bottom);
+		Result[3][2] = - (zFar + zNear) / (zFar - zNear);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoRH_ZO(T left, T right, T bottom, T top, T zNear, T zFar)
+	{
+		mat<4, 4, T, defaultp> Result(1);
+		Result[0][0] = static_cast<T>(2) / (right - left);
+		Result[1][1] = static_cast<T>(2) / (top - bottom);
+		Result[2][2] = - static_cast<T>(1) / (zFar - zNear);
+		Result[3][0] = - (right + left) / (right - left);
+		Result[3][1] = - (top + bottom) / (top - bottom);
+		Result[3][2] = - zNear / (zFar - zNear);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoRH_NO(T left, T right, T bottom, T top, T zNear, T zFar)
+	{
+		mat<4, 4, T, defaultp> Result(1);
+		Result[0][0] = static_cast<T>(2) / (right - left);
+		Result[1][1] = static_cast<T>(2) / (top - bottom);
+		Result[2][2] = - static_cast<T>(2) / (zFar - zNear);
+		Result[3][0] = - (right + left) / (right - left);
+		Result[3][1] = - (top + bottom) / (top - bottom);
+		Result[3][2] = - (zFar + zNear) / (zFar - zNear);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoZO(T left, T right, T bottom, T top, T zNear, T zFar)
+	{
+		if(GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT)
+			return orthoLH_ZO(left, right, bottom, top, zNear, zFar);
+		else
+			return orthoRH_ZO(left, right, bottom, top, zNear, zFar);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoNO(T left, T right, T bottom, T top, T zNear, T zFar)
+	{
+		if(GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT)
+			return orthoLH_NO(left, right, bottom, top, zNear, zFar);
+		else
+			return orthoRH_NO(left, right, bottom, top, zNear, zFar);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoLH(T left, T right, T bottom, T top, T zNear, T zFar)
+	{
+		if(GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT)
+			return orthoLH_ZO(left, right, bottom, top, zNear, zFar);
+		else
+			return orthoLH_NO(left, right, bottom, top, zNear, zFar);
+
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoRH(T left, T right, T bottom, T top, T zNear, T zFar)
+	{
+		if(GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT)
+			return orthoRH_ZO(left, right, bottom, top, zNear, zFar);
+		else
+			return orthoRH_NO(left, right, bottom, top, zNear, zFar);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> ortho(T left, T right, T bottom, T top, T zNear, T zFar)
+	{
+		if(GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_LH_ZO)
+			return orthoLH_ZO(left, right, bottom, top, zNear, zFar);
+		else if(GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_LH_NO)
+			return orthoLH_NO(left, right, bottom, top, zNear, zFar);
+		else if(GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_RH_ZO)
+			return orthoRH_ZO(left, right, bottom, top, zNear, zFar);
+		else if(GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_RH_NO)
+			return orthoRH_NO(left, right, bottom, top, zNear, zFar);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumLH_ZO(T left, T right, T bottom, T top, T nearVal, T farVal)
+	{
+		mat<4, 4, T, defaultp> Result(0);
+		Result[0][0] = (static_cast<T>(2) * nearVal) / (right - left);
+		Result[1][1] = (static_cast<T>(2) * nearVal) / (top - bottom);
+		Result[2][0] = (right + left) / (right - left);
+		Result[2][1] = (top + bottom) / (top - bottom);
+		Result[2][2] = farVal / (farVal - nearVal);
+		Result[2][3] = static_cast<T>(1);
+		Result[3][2] = -(farVal * nearVal) / (farVal - nearVal);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumLH_NO(T left, T right, T bottom, T top, T nearVal, T farVal)
+	{
+		mat<4, 4, T, defaultp> Result(0);
+		Result[0][0] = (static_cast<T>(2) * nearVal) / (right - left);
+		Result[1][1] = (static_cast<T>(2) * nearVal) / (top - bottom);
+		Result[2][0] = (right + left) / (right - left);
+		Result[2][1] = (top + bottom) / (top - bottom);
+		Result[2][2] = (farVal + nearVal) / (farVal - nearVal);
+		Result[2][3] = static_cast<T>(1);
+		Result[3][2] = - (static_cast<T>(2) * farVal * nearVal) / (farVal - nearVal);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumRH_ZO(T left, T right, T bottom, T top, T nearVal, T farVal)
+	{
+		mat<4, 4, T, defaultp> Result(0);
+		Result[0][0] = (static_cast<T>(2) * nearVal) / (right - left);
+		Result[1][1] = (static_cast<T>(2) * nearVal) / (top - bottom);
+		Result[2][0] = (right + left) / (right - left);
+		Result[2][1] = (top + bottom) / (top - bottom);
+		Result[2][2] = farVal / (nearVal - farVal);
+		Result[2][3] = static_cast<T>(-1);
+		Result[3][2] = -(farVal * nearVal) / (farVal - nearVal);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumRH_NO(T left, T right, T bottom, T top, T nearVal, T farVal)
+	{
+		mat<4, 4, T, defaultp> Result(0);
+		Result[0][0] = (static_cast<T>(2) * nearVal) / (right - left);
+		Result[1][1] = (static_cast<T>(2) * nearVal) / (top - bottom);
+		Result[2][0] = (right + left) / (right - left);
+		Result[2][1] = (top + bottom) / (top - bottom);
+		Result[2][2] = - (farVal + nearVal) / (farVal - nearVal);
+		Result[2][3] = static_cast<T>(-1);
+		Result[3][2] = - (static_cast<T>(2) * farVal * nearVal) / (farVal - nearVal);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumZO(T left, T right, T bottom, T top, T nearVal, T farVal)
+	{
+		if(GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT)
+			return frustumLH_ZO(left, right, bottom, top, nearVal, farVal);
+		else
+			return frustumRH_ZO(left, right, bottom, top, nearVal, farVal);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumNO(T left, T right, T bottom, T top, T nearVal, T farVal)
+	{
+		if(GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT)
+			return frustumLH_NO(left, right, bottom, top, nearVal, farVal);
+		else
+			return frustumRH_NO(left, right, bottom, top, nearVal, farVal);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumLH(T left, T right, T bottom, T top, T nearVal, T farVal)
+	{
+		if(GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT)
+			return frustumLH_ZO(left, right, bottom, top, nearVal, farVal);
+		else
+			return frustumLH_NO(left, right, bottom, top, nearVal, farVal);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumRH(T left, T right, T bottom, T top, T nearVal, T farVal)
+	{
+		if(GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT)
+			return frustumRH_ZO(left, right, bottom, top, nearVal, farVal);
+		else
+			return frustumRH_NO(left, right, bottom, top, nearVal, farVal);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustum(T left, T right, T bottom, T top, T nearVal, T farVal)
+	{
+		if(GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_LH_ZO)
+			return frustumLH_ZO(left, right, bottom, top, nearVal, farVal);
+		else if(GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_LH_NO)
+			return frustumLH_NO(left, right, bottom, top, nearVal, farVal);
+		else if(GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_RH_ZO)
+			return frustumRH_ZO(left, right, bottom, top, nearVal, farVal);
+		else if(GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_RH_NO)
+			return frustumRH_NO(left, right, bottom, top, nearVal, farVal);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveRH_ZO(T fovy, T aspect, T zNear, T zFar)
+	{
+		assert(abs(aspect - std::numeric_limits<T>::epsilon()) > static_cast<T>(0));
+
+		T const tanHalfFovy = tan(fovy / static_cast<T>(2));
+
+		mat<4, 4, T, defaultp> Result(static_cast<T>(0));
+		Result[0][0] = static_cast<T>(1) / (aspect * tanHalfFovy);
+		Result[1][1] = static_cast<T>(1) / (tanHalfFovy);
+		Result[2][2] = zFar / (zNear - zFar);
+		Result[2][3] = - static_cast<T>(1);
+		Result[3][2] = -(zFar * zNear) / (zFar - zNear);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveRH_NO(T fovy, T aspect, T zNear, T zFar)
+	{
+		assert(abs(aspect - std::numeric_limits<T>::epsilon()) > static_cast<T>(0));
+
+		T const tanHalfFovy = tan(fovy / static_cast<T>(2));
+
+		mat<4, 4, T, defaultp> Result(static_cast<T>(0));
+		Result[0][0] = static_cast<T>(1) / (aspect * tanHalfFovy);
+		Result[1][1] = static_cast<T>(1) / (tanHalfFovy);
+		Result[2][2] = - (zFar + zNear) / (zFar - zNear);
+		Result[2][3] = - static_cast<T>(1);
+		Result[3][2] = - (static_cast<T>(2) * zFar * zNear) / (zFar - zNear);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveLH_ZO(T fovy, T aspect, T zNear, T zFar)
+	{
+		assert(abs(aspect - std::numeric_limits<T>::epsilon()) > static_cast<T>(0));
+
+		T const tanHalfFovy = tan(fovy / static_cast<T>(2));
+
+		mat<4, 4, T, defaultp> Result(static_cast<T>(0));
+		Result[0][0] = static_cast<T>(1) / (aspect * tanHalfFovy);
+		Result[1][1] = static_cast<T>(1) / (tanHalfFovy);
+		Result[2][2] = zFar / (zFar - zNear);
+		Result[2][3] = static_cast<T>(1);
+		Result[3][2] = -(zFar * zNear) / (zFar - zNear);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveLH_NO(T fovy, T aspect, T zNear, T zFar)
+	{
+		assert(abs(aspect - std::numeric_limits<T>::epsilon()) > static_cast<T>(0));
+
+		T const tanHalfFovy = tan(fovy / static_cast<T>(2));
+
+		mat<4, 4, T, defaultp> Result(static_cast<T>(0));
+		Result[0][0] = static_cast<T>(1) / (aspect * tanHalfFovy);
+		Result[1][1] = static_cast<T>(1) / (tanHalfFovy);
+		Result[2][2] = (zFar + zNear) / (zFar - zNear);
+		Result[2][3] = static_cast<T>(1);
+		Result[3][2] = - (static_cast<T>(2) * zFar * zNear) / (zFar - zNear);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveZO(T fovy, T aspect, T zNear, T zFar)
+	{
+		if(GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT)
+			return perspectiveLH_ZO(fovy, aspect, zNear, zFar);
+		else
+			return perspectiveRH_ZO(fovy, aspect, zNear, zFar);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveNO(T fovy, T aspect, T zNear, T zFar)
+	{
+		if(GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT)
+			return perspectiveLH_NO(fovy, aspect, zNear, zFar);
+		else
+			return perspectiveRH_NO(fovy, aspect, zNear, zFar);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveLH(T fovy, T aspect, T zNear, T zFar)
+	{
+		if(GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT)
+			return perspectiveLH_ZO(fovy, aspect, zNear, zFar);
+		else
+			return perspectiveLH_NO(fovy, aspect, zNear, zFar);
+
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveRH(T fovy, T aspect, T zNear, T zFar)
+	{
+		if(GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT)
+			return perspectiveRH_ZO(fovy, aspect, zNear, zFar);
+		else
+			return perspectiveRH_NO(fovy, aspect, zNear, zFar);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspective(T fovy, T aspect, T zNear, T zFar)
+	{
+		if(GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_LH_ZO)
+			return perspectiveLH_ZO(fovy, aspect, zNear, zFar);
+		else if(GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_LH_NO)
+			return perspectiveLH_NO(fovy, aspect, zNear, zFar);
+		else if(GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_RH_ZO)
+			return perspectiveRH_ZO(fovy, aspect, zNear, zFar);
+		else if(GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_RH_NO)
+			return perspectiveRH_NO(fovy, aspect, zNear, zFar);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovRH_ZO(T fov, T width, T height, T zNear, T zFar)
+	{
+		assert(width > static_cast<T>(0));
+		assert(height > static_cast<T>(0));
+		assert(fov > static_cast<T>(0));
+
+		T const rad = fov;
+		T const h = glm::cos(static_cast<T>(0.5) * rad) / glm::sin(static_cast<T>(0.5) * rad);
+		T const w = h * height / width; ///todo max(width , Height) / min(width , Height)?
+
+		mat<4, 4, T, defaultp> Result(static_cast<T>(0));
+		Result[0][0] = w;
+		Result[1][1] = h;
+		Result[2][2] = zFar / (zNear - zFar);
+		Result[2][3] = - static_cast<T>(1);
+		Result[3][2] = -(zFar * zNear) / (zFar - zNear);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovRH_NO(T fov, T width, T height, T zNear, T zFar)
+	{
+		assert(width > static_cast<T>(0));
+		assert(height > static_cast<T>(0));
+		assert(fov > static_cast<T>(0));
+
+		T const rad = fov;
+		T const h = glm::cos(static_cast<T>(0.5) * rad) / glm::sin(static_cast<T>(0.5) * rad);
+		T const w = h * height / width; ///todo max(width , Height) / min(width , Height)?
+
+		mat<4, 4, T, defaultp> Result(static_cast<T>(0));
+		Result[0][0] = w;
+		Result[1][1] = h;
+		Result[2][2] = - (zFar + zNear) / (zFar - zNear);
+		Result[2][3] = - static_cast<T>(1);
+		Result[3][2] = - (static_cast<T>(2) * zFar * zNear) / (zFar - zNear);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovLH_ZO(T fov, T width, T height, T zNear, T zFar)
+	{
+		assert(width > static_cast<T>(0));
+		assert(height > static_cast<T>(0));
+		assert(fov > static_cast<T>(0));
+
+		T const rad = fov;
+		T const h = glm::cos(static_cast<T>(0.5) * rad) / glm::sin(static_cast<T>(0.5) * rad);
+		T const w = h * height / width; ///todo max(width , Height) / min(width , Height)?
+
+		mat<4, 4, T, defaultp> Result(static_cast<T>(0));
+		Result[0][0] = w;
+		Result[1][1] = h;
+		Result[2][2] = zFar / (zFar - zNear);
+		Result[2][3] = static_cast<T>(1);
+		Result[3][2] = -(zFar * zNear) / (zFar - zNear);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovLH_NO(T fov, T width, T height, T zNear, T zFar)
+	{
+		assert(width > static_cast<T>(0));
+		assert(height > static_cast<T>(0));
+		assert(fov > static_cast<T>(0));
+
+		T const rad = fov;
+		T const h = glm::cos(static_cast<T>(0.5) * rad) / glm::sin(static_cast<T>(0.5) * rad);
+		T const w = h * height / width; ///todo max(width , Height) / min(width , Height)?
+
+		mat<4, 4, T, defaultp> Result(static_cast<T>(0));
+		Result[0][0] = w;
+		Result[1][1] = h;
+		Result[2][2] = (zFar + zNear) / (zFar - zNear);
+		Result[2][3] = static_cast<T>(1);
+		Result[3][2] = - (static_cast<T>(2) * zFar * zNear) / (zFar - zNear);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovZO(T fov, T width, T height, T zNear, T zFar)
+	{
+		if(GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT)
+			return perspectiveFovLH_ZO(fov, width, height, zNear, zFar);
+		else
+			return perspectiveFovRH_ZO(fov, width, height, zNear, zFar);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovNO(T fov, T width, T height, T zNear, T zFar)
+	{
+		if(GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT)
+			return perspectiveFovLH_NO(fov, width, height, zNear, zFar);
+		else
+			return perspectiveFovRH_NO(fov, width, height, zNear, zFar);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovLH(T fov, T width, T height, T zNear, T zFar)
+	{
+		if(GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT)
+			return perspectiveFovLH_ZO(fov, width, height, zNear, zFar);
+		else
+			return perspectiveFovLH_NO(fov, width, height, zNear, zFar);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovRH(T fov, T width, T height, T zNear, T zFar)
+	{
+		if(GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT)
+			return perspectiveFovRH_ZO(fov, width, height, zNear, zFar);
+		else
+			return perspectiveFovRH_NO(fov, width, height, zNear, zFar);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFov(T fov, T width, T height, T zNear, T zFar)
+	{
+		if(GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_LH_ZO)
+			return perspectiveFovLH_ZO(fov, width, height, zNear, zFar);
+		else if(GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_LH_NO)
+			return perspectiveFovLH_NO(fov, width, height, zNear, zFar);
+		else if(GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_RH_ZO)
+			return perspectiveFovRH_ZO(fov, width, height, zNear, zFar);
+		else if(GLM_CONFIG_CLIP_CONTROL == GLM_CLIP_CONTROL_RH_NO)
+			return perspectiveFovRH_NO(fov, width, height, zNear, zFar);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> infinitePerspectiveRH(T fovy, T aspect, T zNear)
+	{
+		T const range = tan(fovy / static_cast<T>(2)) * zNear;
+		T const left = -range * aspect;
+		T const right = range * aspect;
+		T const bottom = -range;
+		T const top = range;
+
+		mat<4, 4, T, defaultp> Result(static_cast<T>(0));
+		Result[0][0] = (static_cast<T>(2) * zNear) / (right - left);
+		Result[1][1] = (static_cast<T>(2) * zNear) / (top - bottom);
+		Result[2][2] = - static_cast<T>(1);
+		Result[2][3] = - static_cast<T>(1);
+		Result[3][2] = - static_cast<T>(2) * zNear;
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> infinitePerspectiveLH(T fovy, T aspect, T zNear)
+	{
+		T const range = tan(fovy / static_cast<T>(2)) * zNear;
+		T const left = -range * aspect;
+		T const right = range * aspect;
+		T const bottom = -range;
+		T const top = range;
+
+		mat<4, 4, T, defaultp> Result(T(0));
+		Result[0][0] = (static_cast<T>(2) * zNear) / (right - left);
+		Result[1][1] = (static_cast<T>(2) * zNear) / (top - bottom);
+		Result[2][2] = static_cast<T>(1);
+		Result[2][3] = static_cast<T>(1);
+		Result[3][2] = - static_cast<T>(2) * zNear;
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> infinitePerspective(T fovy, T aspect, T zNear)
+	{
+		if(GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT)
+			return infinitePerspectiveLH(fovy, aspect, zNear);
+		else
+			return infinitePerspectiveRH(fovy, aspect, zNear);
+	}
+
+	// Infinite projection matrix: http://www.terathon.com/gdc07_lengyel.pdf
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> tweakedInfinitePerspective(T fovy, T aspect, T zNear, T ep)
+	{
+		T const range = tan(fovy / static_cast<T>(2)) * zNear;
+		T const left = -range * aspect;
+		T const right = range * aspect;
+		T const bottom = -range;
+		T const top = range;
+
+		mat<4, 4, T, defaultp> Result(static_cast<T>(0));
+		Result[0][0] = (static_cast<T>(2) * zNear) / (right - left);
+		Result[1][1] = (static_cast<T>(2) * zNear) / (top - bottom);
+		Result[2][2] = ep - static_cast<T>(1);
+		Result[2][3] = static_cast<T>(-1);
+		Result[3][2] = (ep - static_cast<T>(2)) * zNear;
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> tweakedInfinitePerspective(T fovy, T aspect, T zNear)
+	{
+		return tweakedInfinitePerspective(fovy, aspect, zNear, epsilon<T>());
+	}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_double2x2.hpp b/engine/inc/glm/ext/matrix_double2x2.hpp
new file mode 100644
index 00000000..94dca54b
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_double2x2.hpp
@@ -0,0 +1,23 @@
+/// @ref core
+/// @file glm/ext/matrix_double2x2.hpp
+
+#pragma once
+#include "../detail/type_mat2x2.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix
+	/// @{
+
+	/// 2 columns of 2 components matrix of double-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef mat<2, 2, double, defaultp>		dmat2x2;
+
+	/// 2 columns of 2 components matrix of double-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef mat<2, 2, double, defaultp>		dmat2;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_double2x2_precision.hpp b/engine/inc/glm/ext/matrix_double2x2_precision.hpp
new file mode 100644
index 00000000..9e2c174e
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_double2x2_precision.hpp
@@ -0,0 +1,49 @@
+/// @ref core
+/// @file glm/ext/matrix_double2x2_precision.hpp
+
+#pragma once
+#include "../detail/type_mat2x2.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix_precision
+	/// @{
+
+	/// 2 columns of 2 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<2, 2, double, lowp>		lowp_dmat2;
+
+	/// 2 columns of 2 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<2, 2, double, mediump>	mediump_dmat2;
+
+	/// 2 columns of 2 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<2, 2, double, highp>	highp_dmat2;
+
+	/// 2 columns of 2 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<2, 2, double, lowp>		lowp_dmat2x2;
+
+	/// 2 columns of 2 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<2, 2, double, mediump>	mediump_dmat2x2;
+
+	/// 2 columns of 2 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<2, 2, double, highp>	highp_dmat2x2;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_double2x3.hpp b/engine/inc/glm/ext/matrix_double2x3.hpp
new file mode 100644
index 00000000..bfef87a6
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_double2x3.hpp
@@ -0,0 +1,18 @@
+/// @ref core
+/// @file glm/ext/matrix_double2x3.hpp
+
+#pragma once
+#include "../detail/type_mat2x3.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix
+	/// @{
+
+	/// 2 columns of 3 components matrix of double-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef mat<2, 3, double, defaultp>		dmat2x3;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_double2x3_precision.hpp b/engine/inc/glm/ext/matrix_double2x3_precision.hpp
new file mode 100644
index 00000000..098fb604
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_double2x3_precision.hpp
@@ -0,0 +1,31 @@
+/// @ref core
+/// @file glm/ext/matrix_double2x3_precision.hpp
+
+#pragma once
+#include "../detail/type_mat2x3.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix_precision
+	/// @{
+
+	/// 2 columns of 3 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<2, 3, double, lowp>		lowp_dmat2x3;
+
+	/// 2 columns of 3 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<2, 3, double, mediump>	mediump_dmat2x3;
+
+	/// 2 columns of 3 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<2, 3, double, highp>	highp_dmat2x3;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_double2x4.hpp b/engine/inc/glm/ext/matrix_double2x4.hpp
new file mode 100644
index 00000000..499284bc
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_double2x4.hpp
@@ -0,0 +1,18 @@
+/// @ref core
+/// @file glm/ext/matrix_double2x4.hpp
+
+#pragma once
+#include "../detail/type_mat2x4.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix
+	/// @{
+
+	/// 2 columns of 4 components matrix of double-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef mat<2, 4, double, defaultp>		dmat2x4;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_double2x4_precision.hpp b/engine/inc/glm/ext/matrix_double2x4_precision.hpp
new file mode 100644
index 00000000..9b61ebce
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_double2x4_precision.hpp
@@ -0,0 +1,31 @@
+/// @ref core
+/// @file glm/ext/matrix_double2x4_precision.hpp
+
+#pragma once
+#include "../detail/type_mat2x4.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix_precision
+	/// @{
+
+	/// 2 columns of 4 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<2, 4, double, lowp>		lowp_dmat2x4;
+
+	/// 2 columns of 4 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<2, 4, double, mediump>	mediump_dmat2x4;
+
+	/// 2 columns of 4 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<2, 4, double, highp>	highp_dmat2x4;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_double3x2.hpp b/engine/inc/glm/ext/matrix_double3x2.hpp
new file mode 100644
index 00000000..dd23f36c
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_double3x2.hpp
@@ -0,0 +1,18 @@
+/// @ref core
+/// @file glm/ext/matrix_double3x2.hpp
+
+#pragma once
+#include "../detail/type_mat3x2.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix
+	/// @{
+
+	/// 3 columns of 2 components matrix of double-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef mat<3, 2, double, defaultp>		dmat3x2;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_double3x2_precision.hpp b/engine/inc/glm/ext/matrix_double3x2_precision.hpp
new file mode 100644
index 00000000..068d9e91
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_double3x2_precision.hpp
@@ -0,0 +1,31 @@
+/// @ref core
+/// @file glm/ext/matrix_double3x2_precision.hpp
+
+#pragma once
+#include "../detail/type_mat3x2.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix_precision
+	/// @{
+
+	/// 3 columns of 2 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<3, 2, double, lowp>		lowp_dmat3x2;
+
+	/// 3 columns of 2 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<3, 2, double, mediump>	mediump_dmat3x2;
+
+	/// 3 columns of 2 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<3, 2, double, highp>	highp_dmat3x2;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_double3x3.hpp b/engine/inc/glm/ext/matrix_double3x3.hpp
new file mode 100644
index 00000000..53572b73
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_double3x3.hpp
@@ -0,0 +1,23 @@
+/// @ref core
+/// @file glm/ext/matrix_double3x3.hpp
+
+#pragma once
+#include "../detail/type_mat3x3.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix
+	/// @{
+
+	/// 3 columns of 3 components matrix of double-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef mat<3, 3, double, defaultp>		dmat3x3;
+
+	/// 3 columns of 3 components matrix of double-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef mat<3, 3, double, defaultp>		dmat3;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_double3x3_precision.hpp b/engine/inc/glm/ext/matrix_double3x3_precision.hpp
new file mode 100644
index 00000000..8691e780
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_double3x3_precision.hpp
@@ -0,0 +1,49 @@
+/// @ref core
+/// @file glm/ext/matrix_double3x3_precision.hpp
+
+#pragma once
+#include "../detail/type_mat3x3.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix_precision
+	/// @{
+
+	/// 3 columns of 3 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<3, 3, double, lowp>		lowp_dmat3;
+
+	/// 3 columns of 3 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<3, 3, double, mediump>	mediump_dmat3;
+
+	/// 3 columns of 3 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<3, 3, double, highp>	highp_dmat3;
+
+	/// 3 columns of 3 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<3, 3, double, lowp>		lowp_dmat3x3;
+
+	/// 3 columns of 3 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<3, 3, double, mediump>	mediump_dmat3x3;
+
+	/// 3 columns of 3 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<3, 3, double, highp>	highp_dmat3x3;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_double3x4.hpp b/engine/inc/glm/ext/matrix_double3x4.hpp
new file mode 100644
index 00000000..c572d637
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_double3x4.hpp
@@ -0,0 +1,18 @@
+/// @ref core
+/// @file glm/ext/matrix_double3x4.hpp
+
+#pragma once
+#include "../detail/type_mat3x4.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix
+	/// @{
+
+	/// 3 columns of 4 components matrix of double-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef mat<3, 4, double, defaultp>		dmat3x4;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_double3x4_precision.hpp b/engine/inc/glm/ext/matrix_double3x4_precision.hpp
new file mode 100644
index 00000000..f040217e
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_double3x4_precision.hpp
@@ -0,0 +1,31 @@
+/// @ref core
+/// @file glm/ext/matrix_double3x4_precision.hpp
+
+#pragma once
+#include "../detail/type_mat3x4.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix_precision
+	/// @{
+
+	/// 3 columns of 4 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<3, 4, double, lowp>		lowp_dmat3x4;
+
+	/// 3 columns of 4 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<3, 4, double, mediump>	mediump_dmat3x4;
+
+	/// 3 columns of 4 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<3, 4, double, highp>	highp_dmat3x4;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_double4x2.hpp b/engine/inc/glm/ext/matrix_double4x2.hpp
new file mode 100644
index 00000000..9b229f47
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_double4x2.hpp
@@ -0,0 +1,18 @@
+/// @ref core
+/// @file glm/ext/matrix_double4x2.hpp
+
+#pragma once
+#include "../detail/type_mat4x2.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix
+	/// @{
+
+	/// 4 columns of 2 components matrix of double-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef mat<4, 2, double, defaultp>		dmat4x2;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_double4x2_precision.hpp b/engine/inc/glm/ext/matrix_double4x2_precision.hpp
new file mode 100644
index 00000000..6ad18ba9
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_double4x2_precision.hpp
@@ -0,0 +1,31 @@
+/// @ref core
+/// @file glm/ext/matrix_double4x2_precision.hpp
+
+#pragma once
+#include "../detail/type_mat4x2.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix_precision
+	/// @{
+
+	/// 4 columns of 2 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<4, 2, double, lowp>		lowp_dmat4x2;
+
+	/// 4 columns of 2 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<4, 2, double, mediump>	mediump_dmat4x2;
+
+	/// 4 columns of 2 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<4, 2, double, highp>	highp_dmat4x2;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_double4x3.hpp b/engine/inc/glm/ext/matrix_double4x3.hpp
new file mode 100644
index 00000000..dca4cf95
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_double4x3.hpp
@@ -0,0 +1,18 @@
+/// @ref core
+/// @file glm/ext/matrix_double4x3.hpp
+
+#pragma once
+#include "../detail/type_mat4x3.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix
+	/// @{
+
+	/// 4 columns of 3 components matrix of double-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef mat<4, 3, double, defaultp>		dmat4x3;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_double4x3_precision.hpp b/engine/inc/glm/ext/matrix_double4x3_precision.hpp
new file mode 100644
index 00000000..f7371de8
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_double4x3_precision.hpp
@@ -0,0 +1,31 @@
+/// @ref core
+/// @file glm/ext/matrix_double4x3_precision.hpp
+
+#pragma once
+#include "../detail/type_mat4x3.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix_precision
+	/// @{
+
+	/// 4 columns of 3 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<4, 3, double, lowp>		lowp_dmat4x3;
+
+	/// 4 columns of 3 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<4, 3, double, mediump>	mediump_dmat4x3;
+
+	/// 4 columns of 3 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<4, 3, double, highp>	highp_dmat4x3;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_double4x4.hpp b/engine/inc/glm/ext/matrix_double4x4.hpp
new file mode 100644
index 00000000..81e1bf65
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_double4x4.hpp
@@ -0,0 +1,23 @@
+/// @ref core
+/// @file glm/ext/matrix_double4x4.hpp
+
+#pragma once
+#include "../detail/type_mat4x4.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix
+	/// @{
+
+	/// 4 columns of 4 components matrix of double-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef mat<4, 4, double, defaultp>		dmat4x4;
+
+	/// 4 columns of 4 components matrix of double-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef mat<4, 4, double, defaultp>		dmat4;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_double4x4_precision.hpp b/engine/inc/glm/ext/matrix_double4x4_precision.hpp
new file mode 100644
index 00000000..4c36a848
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_double4x4_precision.hpp
@@ -0,0 +1,49 @@
+/// @ref core
+/// @file glm/ext/matrix_double4x4_precision.hpp
+
+#pragma once
+#include "../detail/type_mat4x4.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix_precision
+	/// @{
+
+	/// 4 columns of 4 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<4, 4, double, lowp>		lowp_dmat4;
+
+	/// 4 columns of 4 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<4, 4, double, mediump>	mediump_dmat4;
+
+	/// 4 columns of 4 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<4, 4, double, highp>	highp_dmat4;
+
+	/// 4 columns of 4 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<4, 4, double, lowp>		lowp_dmat4x4;
+
+	/// 4 columns of 4 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<4, 4, double, mediump>	mediump_dmat4x4;
+
+	/// 4 columns of 4 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<4, 4, double, highp>	highp_dmat4x4;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_float2x2.hpp b/engine/inc/glm/ext/matrix_float2x2.hpp
new file mode 100644
index 00000000..53df921f
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_float2x2.hpp
@@ -0,0 +1,23 @@
+/// @ref core
+/// @file glm/ext/matrix_float2x2.hpp
+
+#pragma once
+#include "../detail/type_mat2x2.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix
+	/// @{
+
+	/// 2 columns of 2 components matrix of single-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef mat<2, 2, float, defaultp>		mat2x2;
+
+	/// 2 columns of 2 components matrix of single-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef mat<2, 2, float, defaultp>		mat2;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_float2x2_precision.hpp b/engine/inc/glm/ext/matrix_float2x2_precision.hpp
new file mode 100644
index 00000000..898b6db7
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_float2x2_precision.hpp
@@ -0,0 +1,49 @@
+/// @ref core
+/// @file glm/ext/matrix_float2x2_precision.hpp
+
+#pragma once
+#include "../detail/type_mat2x2.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix_precision
+	/// @{
+
+	/// 2 columns of 2 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<2, 2, float, lowp>		lowp_mat2;
+
+	/// 2 columns of 2 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<2, 2, float, mediump>	mediump_mat2;
+
+	/// 2 columns of 2 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<2, 2, float, highp>		highp_mat2;
+
+	/// 2 columns of 2 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<2, 2, float, lowp>		lowp_mat2x2;
+
+	/// 2 columns of 2 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<2, 2, float, mediump>	mediump_mat2x2;
+
+	/// 2 columns of 2 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<2, 2, float, highp>		highp_mat2x2;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_float2x3.hpp b/engine/inc/glm/ext/matrix_float2x3.hpp
new file mode 100644
index 00000000..6f68822d
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_float2x3.hpp
@@ -0,0 +1,18 @@
+/// @ref core
+/// @file glm/ext/matrix_float2x3.hpp
+
+#pragma once
+#include "../detail/type_mat2x3.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix
+	/// @{
+
+	/// 2 columns of 3 components matrix of single-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef mat<2, 3, float, defaultp>		mat2x3;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_float2x3_precision.hpp b/engine/inc/glm/ext/matrix_float2x3_precision.hpp
new file mode 100644
index 00000000..50c10324
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_float2x3_precision.hpp
@@ -0,0 +1,31 @@
+/// @ref core
+/// @file glm/ext/matrix_float2x3_precision.hpp
+
+#pragma once
+#include "../detail/type_mat2x3.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix_precision
+	/// @{
+
+	/// 2 columns of 3 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<2, 3, float, lowp>		lowp_mat2x3;
+
+	/// 2 columns of 3 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<2, 3, float, mediump>	mediump_mat2x3;
+
+	/// 2 columns of 3 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<2, 3, float, highp>		highp_mat2x3;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_float2x4.hpp b/engine/inc/glm/ext/matrix_float2x4.hpp
new file mode 100644
index 00000000..30f30de3
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_float2x4.hpp
@@ -0,0 +1,18 @@
+/// @ref core
+/// @file glm/ext/matrix_float2x4.hpp
+
+#pragma once
+#include "../detail/type_mat2x4.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix
+	/// @{
+
+	/// 2 columns of 4 components matrix of single-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef mat<2, 4, float, defaultp>		mat2x4;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_float2x4_precision.hpp b/engine/inc/glm/ext/matrix_float2x4_precision.hpp
new file mode 100644
index 00000000..079d6382
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_float2x4_precision.hpp
@@ -0,0 +1,31 @@
+/// @ref core
+/// @file glm/ext/matrix_float2x4_precision.hpp
+
+#pragma once
+#include "../detail/type_mat2x4.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix_precision
+	/// @{
+
+	/// 2 columns of 4 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<2, 4, float, lowp>		lowp_mat2x4;
+
+	/// 2 columns of 4 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<2, 4, float, mediump>	mediump_mat2x4;
+
+	/// 2 columns of 4 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<2, 4, float, highp>		highp_mat2x4;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_float3x2.hpp b/engine/inc/glm/ext/matrix_float3x2.hpp
new file mode 100644
index 00000000..d39dd2fe
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_float3x2.hpp
@@ -0,0 +1,18 @@
+/// @ref core
+/// @file glm/ext/matrix_float3x2.hpp
+
+#pragma once
+#include "../detail/type_mat3x2.hpp"
+
+namespace glm
+{
+	/// @addtogroup core
+	/// @{
+
+	/// 3 columns of 2 components matrix of single-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef mat<3, 2, float, defaultp>			mat3x2;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_float3x2_precision.hpp b/engine/inc/glm/ext/matrix_float3x2_precision.hpp
new file mode 100644
index 00000000..8572c2a1
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_float3x2_precision.hpp
@@ -0,0 +1,31 @@
+/// @ref core
+/// @file glm/ext/matrix_float3x2_precision.hpp
+
+#pragma once
+#include "../detail/type_mat3x2.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix_precision
+	/// @{
+
+	/// 3 columns of 2 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<3, 2, float, lowp>		lowp_mat3x2;
+
+	/// 3 columns of 2 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<3, 2, float, mediump>	mediump_mat3x2;
+
+	/// 3 columns of 2 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<3, 2, float, highp>		highp_mat3x2;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_float3x3.hpp b/engine/inc/glm/ext/matrix_float3x3.hpp
new file mode 100644
index 00000000..177d809f
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_float3x3.hpp
@@ -0,0 +1,23 @@
+/// @ref core
+/// @file glm/ext/matrix_float3x3.hpp
+
+#pragma once
+#include "../detail/type_mat3x3.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix
+	/// @{
+
+	/// 3 columns of 3 components matrix of single-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef mat<3, 3, float, defaultp>			mat3x3;
+
+	/// 3 columns of 3 components matrix of single-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef mat<3, 3, float, defaultp>			mat3;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_float3x3_precision.hpp b/engine/inc/glm/ext/matrix_float3x3_precision.hpp
new file mode 100644
index 00000000..8a900c16
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_float3x3_precision.hpp
@@ -0,0 +1,49 @@
+/// @ref core
+/// @file glm/ext/matrix_float3x3_precision.hpp
+
+#pragma once
+#include "../detail/type_mat3x3.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix_precision
+	/// @{
+
+	/// 3 columns of 3 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<3, 3, float, lowp>		lowp_mat3;
+
+	/// 3 columns of 3 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<3, 3, float, mediump>	mediump_mat3;
+
+	/// 3 columns of 3 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<3, 3, float, highp>		highp_mat3;
+
+	/// 3 columns of 3 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<3, 3, float, lowp>		lowp_mat3x3;
+
+	/// 3 columns of 3 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<3, 3, float, mediump>	mediump_mat3x3;
+
+	/// 3 columns of 3 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<3, 3, float, highp>		highp_mat3x3;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_float3x4.hpp b/engine/inc/glm/ext/matrix_float3x4.hpp
new file mode 100644
index 00000000..64b8459d
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_float3x4.hpp
@@ -0,0 +1,18 @@
+/// @ref core
+/// @file glm/ext/matrix_float3x4.hpp
+
+#pragma once
+#include "../detail/type_mat3x4.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix
+	/// @{
+
+	/// 3 columns of 4 components matrix of single-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef mat<3, 4, float, defaultp>			mat3x4;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_float3x4_precision.hpp b/engine/inc/glm/ext/matrix_float3x4_precision.hpp
new file mode 100644
index 00000000..bc36bf13
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_float3x4_precision.hpp
@@ -0,0 +1,31 @@
+/// @ref core
+/// @file glm/ext/matrix_float3x4_precision.hpp
+
+#pragma once
+#include "../detail/type_mat3x4.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix_precision
+	/// @{
+
+	/// 3 columns of 4 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<3, 4, float, lowp>		lowp_mat3x4;
+
+	/// 3 columns of 4 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<3, 4, float, mediump>	mediump_mat3x4;
+
+	/// 3 columns of 4 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<3, 4, float, highp>		highp_mat3x4;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_float4x2.hpp b/engine/inc/glm/ext/matrix_float4x2.hpp
new file mode 100644
index 00000000..1ed5227b
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_float4x2.hpp
@@ -0,0 +1,18 @@
+/// @ref core
+/// @file glm/ext/matrix_float4x2.hpp
+
+#pragma once
+#include "../detail/type_mat4x2.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix
+	/// @{
+
+	/// 4 columns of 2 components matrix of single-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef mat<4, 2, float, defaultp>			mat4x2;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_float4x2_precision.hpp b/engine/inc/glm/ext/matrix_float4x2_precision.hpp
new file mode 100644
index 00000000..88fd0696
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_float4x2_precision.hpp
@@ -0,0 +1,31 @@
+/// @ref core
+/// @file glm/ext/matrix_float2x2_precision.hpp
+
+#pragma once
+#include "../detail/type_mat2x2.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix_precision
+	/// @{
+
+	/// 4 columns of 2 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<4, 2, float, lowp>		lowp_mat4x2;
+
+	/// 4 columns of 2 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<4, 2, float, mediump>	mediump_mat4x2;
+
+	/// 4 columns of 2 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<4, 2, float, highp>		highp_mat4x2;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_float4x3.hpp b/engine/inc/glm/ext/matrix_float4x3.hpp
new file mode 100644
index 00000000..5dbe7657
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_float4x3.hpp
@@ -0,0 +1,18 @@
+/// @ref core
+/// @file glm/ext/matrix_float4x3.hpp
+
+#pragma once
+#include "../detail/type_mat4x3.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix
+	/// @{
+
+	/// 4 columns of 3 components matrix of single-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef mat<4, 3, float, defaultp>			mat4x3;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_float4x3_precision.hpp b/engine/inc/glm/ext/matrix_float4x3_precision.hpp
new file mode 100644
index 00000000..846ed4fc
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_float4x3_precision.hpp
@@ -0,0 +1,31 @@
+/// @ref core
+/// @file glm/ext/matrix_float4x3_precision.hpp
+
+#pragma once
+#include "../detail/type_mat4x3.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix_precision
+	/// @{
+
+	/// 4 columns of 3 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<4, 3, float, lowp>		lowp_mat4x3;
+
+	/// 4 columns of 3 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<4, 3, float, mediump>	mediump_mat4x3;
+
+	/// 4 columns of 3 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<4, 3, float, highp>		highp_mat4x3;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_float4x4.hpp b/engine/inc/glm/ext/matrix_float4x4.hpp
new file mode 100644
index 00000000..5ba111de
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_float4x4.hpp
@@ -0,0 +1,23 @@
+/// @ref core
+/// @file glm/ext/matrix_float4x4.hpp
+
+#pragma once
+#include "../detail/type_mat4x4.hpp"
+
+namespace glm
+{
+	/// @ingroup core_matrix
+	/// @{
+
+	/// 4 columns of 4 components matrix of single-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef mat<4, 4, float, defaultp>			mat4x4;
+
+	/// 4 columns of 4 components matrix of single-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef mat<4, 4, float, defaultp>			mat4;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_float4x4_precision.hpp b/engine/inc/glm/ext/matrix_float4x4_precision.hpp
new file mode 100644
index 00000000..597149bc
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_float4x4_precision.hpp
@@ -0,0 +1,49 @@
+/// @ref core
+/// @file glm/ext/matrix_float4x4_precision.hpp
+
+#pragma once
+#include "../detail/type_mat4x4.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_matrix_precision
+	/// @{
+
+	/// 4 columns of 4 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<4, 4, float, lowp>		lowp_mat4;
+
+	/// 4 columns of 4 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<4, 4, float, mediump>	mediump_mat4;
+
+	/// 4 columns of 4 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<4, 4, float, highp>		highp_mat4;
+
+	/// 4 columns of 4 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<4, 4, float, lowp>		lowp_mat4x4;
+
+	/// 4 columns of 4 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<4, 4, float, mediump>	mediump_mat4x4;
+
+	/// 4 columns of 4 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mat<4, 4, float, highp>		highp_mat4x4;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_projection.hpp b/engine/inc/glm/ext/matrix_projection.hpp
new file mode 100644
index 00000000..51fd01bd
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_projection.hpp
@@ -0,0 +1,149 @@
+/// @ref ext_matrix_projection
+/// @file glm/ext/matrix_projection.hpp
+///
+/// @defgroup ext_matrix_projection GLM_EXT_matrix_projection
+/// @ingroup ext
+///
+/// Functions that generate common projection transformation matrices.
+///
+/// The matrices generated by this extension use standard OpenGL fixed-function
+/// conventions. For example, the lookAt function generates a transform from world
+/// space into the specific eye space that the projective matrix functions
+/// (perspective, ortho, etc) are designed to expect. The OpenGL compatibility
+/// specifications defines the particular layout of this eye space.
+///
+/// Include <glm/ext/matrix_projection.hpp> to use the features of this extension.
+///
+/// @see ext_matrix_transform
+/// @see ext_matrix_clip_space
+
+#pragma once
+
+// Dependencies
+#include "../gtc/constants.hpp"
+#include "../geometric.hpp"
+#include "../trigonometric.hpp"
+#include "../matrix.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_matrix_projection extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup ext_matrix_projection
+	/// @{
+
+	/// Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates.
+	/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
+	///
+	/// @param obj Specify the object coordinates.
+	/// @param model Specifies the current modelview matrix
+	/// @param proj Specifies the current projection matrix
+	/// @param viewport Specifies the current viewport
+	/// @return Return the computed window coordinates.
+	/// @tparam T Native type used for the computation. Currently supported: half (not recommended), float or double.
+	/// @tparam U Currently supported: Floating-point types and integer types.
+	///
+	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluProject.xml">gluProject man page</a>
+	template<typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> projectZO(
+		vec<3, T, Q> const& obj, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport);
+
+	/// Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates.
+	/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
+	///
+	/// @param obj Specify the object coordinates.
+	/// @param model Specifies the current modelview matrix
+	/// @param proj Specifies the current projection matrix
+	/// @param viewport Specifies the current viewport
+	/// @return Return the computed window coordinates.
+	/// @tparam T Native type used for the computation. Currently supported: half (not recommended), float or double.
+	/// @tparam U Currently supported: Floating-point types and integer types.
+	///
+	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluProject.xml">gluProject man page</a>
+	template<typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> projectNO(
+		vec<3, T, Q> const& obj, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport);
+
+	/// Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates using default near and far clip planes definition.
+	/// To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE.
+	///
+	/// @param obj Specify the object coordinates.
+	/// @param model Specifies the current modelview matrix
+	/// @param proj Specifies the current projection matrix
+	/// @param viewport Specifies the current viewport
+	/// @return Return the computed window coordinates.
+	/// @tparam T Native type used for the computation. Currently supported: half (not recommended), float or double.
+	/// @tparam U Currently supported: Floating-point types and integer types.
+	///
+	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluProject.xml">gluProject man page</a>
+	template<typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> project(
+		vec<3, T, Q> const& obj, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport);
+
+	/// Map the specified window coordinates (win.x, win.y, win.z) into object coordinates.
+	/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
+	///
+	/// @param win Specify the window coordinates to be mapped.
+	/// @param model Specifies the modelview matrix
+	/// @param proj Specifies the projection matrix
+	/// @param viewport Specifies the viewport
+	/// @return Returns the computed object coordinates.
+	/// @tparam T Native type used for the computation. Currently supported: half (not recommended), float or double.
+	/// @tparam U Currently supported: Floating-point types and integer types.
+	///
+	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluUnProject.xml">gluUnProject man page</a>
+	template<typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> unProjectZO(
+		vec<3, T, Q> const& win, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport);
+
+	/// Map the specified window coordinates (win.x, win.y, win.z) into object coordinates.
+	/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
+	///
+	/// @param win Specify the window coordinates to be mapped.
+	/// @param model Specifies the modelview matrix
+	/// @param proj Specifies the projection matrix
+	/// @param viewport Specifies the viewport
+	/// @return Returns the computed object coordinates.
+	/// @tparam T Native type used for the computation. Currently supported: half (not recommended), float or double.
+	/// @tparam U Currently supported: Floating-point types and integer types.
+	///
+	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluUnProject.xml">gluUnProject man page</a>
+	template<typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> unProjectNO(
+		vec<3, T, Q> const& win, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport);
+
+	/// Map the specified window coordinates (win.x, win.y, win.z) into object coordinates using default near and far clip planes definition.
+	/// To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE.
+	///
+	/// @param win Specify the window coordinates to be mapped.
+	/// @param model Specifies the modelview matrix
+	/// @param proj Specifies the projection matrix
+	/// @param viewport Specifies the viewport
+	/// @return Returns the computed object coordinates.
+	/// @tparam T Native type used for the computation. Currently supported: half (not recommended), float or double.
+	/// @tparam U Currently supported: Floating-point types and integer types.
+	///
+	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluUnProject.xml">gluUnProject man page</a>
+	template<typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> unProject(
+		vec<3, T, Q> const& win, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport);
+
+	/// Define a picking region
+	///
+	/// @param center Specify the center of a picking region in window coordinates.
+	/// @param delta Specify the width and height, respectively, of the picking region in window coordinates.
+	/// @param viewport Rendering viewport
+	/// @tparam T Native type used for the computation. Currently supported: half (not recommended), float or double.
+	/// @tparam U Currently supported: Floating-point types and integer types.
+	///
+	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluPickMatrix.xml">gluPickMatrix man page</a>
+	template<typename T, qualifier Q, typename U>
+	GLM_FUNC_DECL mat<4, 4, T, Q> pickMatrix(
+		vec<2, T, Q> const& center, vec<2, T, Q> const& delta, vec<4, U, Q> const& viewport);
+
+	/// @}
+}//namespace glm
+
+#include "matrix_projection.inl"
diff --git a/engine/inc/glm/ext/matrix_projection.inl b/engine/inc/glm/ext/matrix_projection.inl
new file mode 100644
index 00000000..8b4eea98
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_projection.inl
@@ -0,0 +1,104 @@
+namespace glm
+{
+	template<typename T, typename U, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> projectZO(vec<3, T, Q> const& obj, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport)
+	{
+		vec<4, T, Q> tmp = vec<4, T, Q>(obj, static_cast<T>(1));
+		tmp = model * tmp;
+		tmp = proj * tmp;
+
+		tmp /= tmp.w;
+		tmp.x = tmp.x * static_cast<T>(0.5) + static_cast<T>(0.5);
+		tmp.y = tmp.y * static_cast<T>(0.5) + static_cast<T>(0.5);
+
+		tmp[0] = tmp[0] * T(viewport[2]) + T(viewport[0]);
+		tmp[1] = tmp[1] * T(viewport[3]) + T(viewport[1]);
+
+		return vec<3, T, Q>(tmp);
+	}
+
+	template<typename T, typename U, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> projectNO(vec<3, T, Q> const& obj, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport)
+	{
+		vec<4, T, Q> tmp = vec<4, T, Q>(obj, static_cast<T>(1));
+		tmp = model * tmp;
+		tmp = proj * tmp;
+
+		tmp /= tmp.w;
+		tmp = tmp * static_cast<T>(0.5) + static_cast<T>(0.5);
+		tmp[0] = tmp[0] * T(viewport[2]) + T(viewport[0]);
+		tmp[1] = tmp[1] * T(viewport[3]) + T(viewport[1]);
+
+		return vec<3, T, Q>(tmp);
+	}
+
+	template<typename T, typename U, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> project(vec<3, T, Q> const& obj, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport)
+	{
+		if(GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT)
+			return projectZO(obj, model, proj, viewport);
+		else
+			return projectNO(obj, model, proj, viewport);
+	}
+
+	template<typename T, typename U, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> unProjectZO(vec<3, T, Q> const& win, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport)
+	{
+		mat<4, 4, T, Q> Inverse = inverse(proj * model);
+
+		vec<4, T, Q> tmp = vec<4, T, Q>(win, T(1));
+		tmp.x = (tmp.x - T(viewport[0])) / T(viewport[2]);
+		tmp.y = (tmp.y - T(viewport[1])) / T(viewport[3]);
+		tmp.x = tmp.x * static_cast<T>(2) - static_cast<T>(1);
+		tmp.y = tmp.y * static_cast<T>(2) - static_cast<T>(1);
+
+		vec<4, T, Q> obj = Inverse * tmp;
+		obj /= obj.w;
+
+		return vec<3, T, Q>(obj);
+	}
+
+	template<typename T, typename U, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> unProjectNO(vec<3, T, Q> const& win, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport)
+	{
+		mat<4, 4, T, Q> Inverse = inverse(proj * model);
+
+		vec<4, T, Q> tmp = vec<4, T, Q>(win, T(1));
+		tmp.x = (tmp.x - T(viewport[0])) / T(viewport[2]);
+		tmp.y = (tmp.y - T(viewport[1])) / T(viewport[3]);
+		tmp = tmp * static_cast<T>(2) - static_cast<T>(1);
+
+		vec<4, T, Q> obj = Inverse * tmp;
+		obj /= obj.w;
+
+		return vec<3, T, Q>(obj);
+	}
+
+	template<typename T, typename U, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> unProject(vec<3, T, Q> const& win, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport)
+	{
+		if(GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT)
+			return unProjectZO(win, model, proj, viewport);
+		else
+			return unProjectNO(win, model, proj, viewport);
+	}
+
+	template<typename T, qualifier Q, typename U>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> pickMatrix(vec<2, T, Q> const& center, vec<2, T, Q> const& delta, vec<4, U, Q> const& viewport)
+	{
+		assert(delta.x > static_cast<T>(0) && delta.y > static_cast<T>(0));
+		mat<4, 4, T, Q> Result(static_cast<T>(1));
+
+		if(!(delta.x > static_cast<T>(0) && delta.y > static_cast<T>(0)))
+			return Result; // Error
+
+		vec<3, T, Q> Temp(
+			(static_cast<T>(viewport[2]) - static_cast<T>(2) * (center.x - static_cast<T>(viewport[0]))) / delta.x,
+			(static_cast<T>(viewport[3]) - static_cast<T>(2) * (center.y - static_cast<T>(viewport[1]))) / delta.y,
+			static_cast<T>(0));
+
+		// Translate and scale the picked region to the entire window
+		Result = translate(Result, Temp);
+		return scale(Result, vec<3, T, Q>(static_cast<T>(viewport[2]) / delta.x, static_cast<T>(viewport[3]) / delta.y, static_cast<T>(1)));
+	}
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_relational.hpp b/engine/inc/glm/ext/matrix_relational.hpp
new file mode 100644
index 00000000..20023ad8
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_relational.hpp
@@ -0,0 +1,132 @@
+/// @ref ext_matrix_relational
+/// @file glm/ext/matrix_relational.hpp
+///
+/// @defgroup ext_matrix_relational GLM_EXT_matrix_relational
+/// @ingroup ext
+///
+/// Exposes comparison functions for matrix types that take a user defined epsilon values.
+///
+/// Include <glm/ext/matrix_relational.hpp> to use the features of this extension.
+///
+/// @see ext_vector_relational
+/// @see ext_scalar_relational
+/// @see ext_quaternion_relational
+
+#pragma once
+
+// Dependencies
+#include "../detail/qualifier.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_matrix_relational extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup ext_matrix_relational
+	/// @{
+
+	/// Perform a component-wise equal-to comparison of two matrices.
+	/// Return a boolean vector which components value is True if this expression is satisfied per column of the matrices.
+	///
+	/// @tparam C Integer between 1 and 4 included that qualify the number of columns of the matrix
+	/// @tparam R Integer between 1 and 4 included that qualify the number of rows of the matrix
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<C, bool, Q> equal(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y);
+
+	/// Perform a component-wise not-equal-to comparison of two matrices.
+	/// Return a boolean vector which components value is True if this expression is satisfied per column of the matrices.
+	///
+	/// @tparam C Integer between 1 and 4 included that qualify the number of columns of the matrix
+	/// @tparam R Integer between 1 and 4 included that qualify the number of rows of the matrix
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<C, bool, Q> notEqual(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y);
+
+	/// Returns the component-wise comparison of |x - y| < epsilon.
+	/// True if this expression is satisfied.
+	///
+	/// @tparam C Integer between 1 and 4 included that qualify the number of columns of the matrix
+	/// @tparam R Integer between 1 and 4 included that qualify the number of rows of the matrix
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<C, bool, Q> equal(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y, T epsilon);
+
+	/// Returns the component-wise comparison of |x - y| < epsilon.
+	/// True if this expression is satisfied.
+	///
+	/// @tparam C Integer between 1 and 4 included that qualify the number of columns of the matrix
+	/// @tparam R Integer between 1 and 4 included that qualify the number of rows of the matrix
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<C, bool, Q> equal(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y, vec<C, T, Q> const& epsilon);
+
+	/// Returns the component-wise comparison of |x - y| < epsilon.
+	/// True if this expression is not satisfied.
+	///
+	/// @tparam C Integer between 1 and 4 included that qualify the number of columns of the matrix
+	/// @tparam R Integer between 1 and 4 included that qualify the number of rows of the matrix
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<C, bool, Q> notEqual(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y, T epsilon);
+
+	/// Returns the component-wise comparison of |x - y| >= epsilon.
+	/// True if this expression is not satisfied.
+	///
+	/// @tparam C Integer between 1 and 4 included that qualify the number of columns of the matrix
+	/// @tparam R Integer between 1 and 4 included that qualify the number of rows of the matrix
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<C, bool, Q> notEqual(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y, vec<C, T, Q> const& epsilon);
+
+	/// Returns the component-wise comparison between two vectors in term of ULPs.
+	/// True if this expression is satisfied.
+	///
+	/// @tparam C Integer between 1 and 4 included that qualify the number of columns of the matrix
+	/// @tparam R Integer between 1 and 4 included that qualify the number of rows of the matrix
+	/// @tparam T Floating-point
+	/// @tparam Q Value from qualifier enum
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<C, bool, Q> equal(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y, int ULPs);
+
+	/// Returns the component-wise comparison between two vectors in term of ULPs.
+	/// True if this expression is satisfied.
+	///
+	/// @tparam C Integer between 1 and 4 included that qualify the number of columns of the matrix
+	/// @tparam R Integer between 1 and 4 included that qualify the number of rows of the matrix
+	/// @tparam T Floating-point
+	/// @tparam Q Value from qualifier enum
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<C, bool, Q> equal(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y, vec<C, int, Q> const& ULPs);
+
+	/// Returns the component-wise comparison between two vectors in term of ULPs.
+	/// True if this expression is not satisfied.
+	///
+	/// @tparam C Integer between 1 and 4 included that qualify the number of columns of the matrix
+	/// @tparam R Integer between 1 and 4 included that qualify the number of rows of the matrix
+	/// @tparam T Floating-point
+	/// @tparam Q Value from qualifier enum
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<C, bool, Q> notEqual(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y, int ULPs);
+
+	/// Returns the component-wise comparison between two vectors in term of ULPs.
+	/// True if this expression is not satisfied.
+	///
+	/// @tparam C Integer between 1 and 4 included that qualify the number of columns of the matrix
+	/// @tparam R Integer between 1 and 4 included that qualify the number of rows of the matrix
+	/// @tparam T Floating-point
+	/// @tparam Q Value from qualifier enum
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<C, bool, Q> notEqual(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y, vec<C, int, Q> const& ULPs);
+
+	/// @}
+}//namespace glm
+
+#include "matrix_relational.inl"
diff --git a/engine/inc/glm/ext/matrix_relational.inl b/engine/inc/glm/ext/matrix_relational.inl
new file mode 100644
index 00000000..b2b87530
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_relational.inl
@@ -0,0 +1,82 @@
+/// @ref ext_vector_relational
+/// @file glm/ext/vector_relational.inl
+
+// Dependency:
+#include "../ext/vector_relational.hpp"
+#include "../common.hpp"
+
+namespace glm
+{
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<C, bool, Q> equal(mat<C, R, T, Q> const& a, mat<C, R, T, Q> const& b)
+	{
+		return equal(a, b, static_cast<T>(0));
+	}
+
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<C, bool, Q> equal(mat<C, R, T, Q> const& a, mat<C, R, T, Q> const& b, T Epsilon)
+	{
+		return equal(a, b, vec<C, T, Q>(Epsilon));
+	}
+
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<C, bool, Q> equal(mat<C, R, T, Q> const& a, mat<C, R, T, Q> const& b, vec<C, T, Q> const& Epsilon)
+	{
+		vec<C, bool, Q> Result(true);
+		for(length_t i = 0; i < C; ++i)
+			Result[i] = all(equal(a[i], b[i], Epsilon[i]));
+		return Result;
+	}
+
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<C, bool, Q> notEqual(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y)
+	{
+		return notEqual(x, y, static_cast<T>(0));
+	}
+
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<C, bool, Q> notEqual(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y, T Epsilon)
+	{
+		return notEqual(x, y, vec<C, T, Q>(Epsilon));
+	}
+
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<C, bool, Q> notEqual(mat<C, R, T, Q> const& a, mat<C, R, T, Q> const& b, vec<C, T, Q> const& Epsilon)
+	{
+		vec<C, bool, Q> Result(true);
+		for(length_t i = 0; i < C; ++i)
+			Result[i] = any(notEqual(a[i], b[i], Epsilon[i]));
+		return Result;
+	}
+
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<C, bool, Q> equal(mat<C, R, T, Q> const& a, mat<C, R, T, Q> const& b, int MaxULPs)
+	{
+		return equal(a, b, vec<C, int, Q>(MaxULPs));
+	}
+
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<C, bool, Q> equal(mat<C, R, T, Q> const& a, mat<C, R, T, Q> const& b, vec<C, int, Q> const& MaxULPs)
+	{
+		vec<C, bool, Q> Result(true);
+		for(length_t i = 0; i < C; ++i)
+			Result[i] = all(equal(a[i], b[i], MaxULPs[i]));
+		return Result;
+	}
+
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<C, bool, Q> notEqual(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y, int MaxULPs)
+	{
+		return notEqual(x, y, vec<C, int, Q>(MaxULPs));
+	}
+
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<C, bool, Q> notEqual(mat<C, R, T, Q> const& a, mat<C, R, T, Q> const& b, vec<C, int, Q> const& MaxULPs)
+	{
+		vec<C, bool, Q> Result(true);
+		for(length_t i = 0; i < C; ++i)
+			Result[i] = any(notEqual(a[i], b[i], MaxULPs[i]));
+		return Result;
+	}
+
+}//namespace glm
diff --git a/engine/inc/glm/ext/matrix_transform.hpp b/engine/inc/glm/ext/matrix_transform.hpp
new file mode 100644
index 00000000..cbd187ef
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_transform.hpp
@@ -0,0 +1,144 @@
+/// @ref ext_matrix_transform
+/// @file glm/ext/matrix_transform.hpp
+///
+/// @defgroup ext_matrix_transform GLM_EXT_matrix_transform
+/// @ingroup ext
+///
+/// Defines functions that generate common transformation matrices.
+///
+/// The matrices generated by this extension use standard OpenGL fixed-function
+/// conventions. For example, the lookAt function generates a transform from world
+/// space into the specific eye space that the projective matrix functions
+/// (perspective, ortho, etc) are designed to expect. The OpenGL compatibility
+/// specifications defines the particular layout of this eye space.
+///
+/// Include <glm/ext/matrix_transform.hpp> to use the features of this extension.
+///
+/// @see ext_matrix_projection
+/// @see ext_matrix_clip_space
+
+#pragma once
+
+// Dependencies
+#include "../gtc/constants.hpp"
+#include "../geometric.hpp"
+#include "../trigonometric.hpp"
+#include "../matrix.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_matrix_transform extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup ext_matrix_transform
+	/// @{
+
+	/// Builds an identity matrix.
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType identity();
+
+	/// Builds a translation 4 * 4 matrix created from a vector of 3 components.
+	///
+	/// @param m Input matrix multiplied by this translation matrix.
+	/// @param v Coordinates of a translation vector.
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	///
+	/// @code
+	/// #include <glm/glm.hpp>
+	/// #include <glm/gtc/matrix_transform.hpp>
+	/// ...
+	/// glm::mat4 m = glm::translate(glm::mat4(1.0f), glm::vec3(1.0f));
+	/// // m[0][0] == 1.0f, m[0][1] == 0.0f, m[0][2] == 0.0f, m[0][3] == 0.0f
+	/// // m[1][0] == 0.0f, m[1][1] == 1.0f, m[1][2] == 0.0f, m[1][3] == 0.0f
+	/// // m[2][0] == 0.0f, m[2][1] == 0.0f, m[2][2] == 1.0f, m[2][3] == 0.0f
+	/// // m[3][0] == 1.0f, m[3][1] == 1.0f, m[3][2] == 1.0f, m[3][3] == 1.0f
+	/// @endcode
+	///
+	/// @see - translate(mat<4, 4, T, Q> const& m, T x, T y, T z)
+	/// @see - translate(vec<3, T, Q> const& v)
+	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glTranslate.xml">glTranslate man page</a>
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> translate(
+		mat<4, 4, T, Q> const& m, vec<3, T, Q> const& v);
+
+	/// Builds a rotation 4 * 4 matrix created from an axis vector and an angle.
+	///
+	/// @param m Input matrix multiplied by this rotation matrix.
+	/// @param angle Rotation angle expressed in radians.
+	/// @param axis Rotation axis, recommended to be normalized.
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	///
+	/// @see - rotate(mat<4, 4, T, Q> const& m, T angle, T x, T y, T z)
+	/// @see - rotate(T angle, vec<3, T, Q> const& v)
+	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glRotate.xml">glRotate man page</a>
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> rotate(
+		mat<4, 4, T, Q> const& m, T angle, vec<3, T, Q> const& axis);
+
+	/// Builds a scale 4 * 4 matrix created from 3 scalars.
+	///
+	/// @param m Input matrix multiplied by this scale matrix.
+	/// @param v Ratio of scaling for each axis.
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	///
+	/// @see - scale(mat<4, 4, T, Q> const& m, T x, T y, T z)
+	/// @see - scale(vec<3, T, Q> const& v)
+	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glScale.xml">glScale man page</a>
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> scale(
+		mat<4, 4, T, Q> const& m, vec<3, T, Q> const& v);
+
+	/// Build a right handed look at view matrix.
+	///
+	/// @param eye Position of the camera
+	/// @param center Position where the camera is looking at
+	/// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1)
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	///
+	/// @see - frustum(T const& left, T const& right, T const& bottom, T const& top, T const& nearVal, T const& farVal) frustum(T const& left, T const& right, T const& bottom, T const& top, T const& nearVal, T const& farVal)
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> lookAtRH(
+		vec<3, T, Q> const& eye, vec<3, T, Q> const& center, vec<3, T, Q> const& up);
+
+	/// Build a left handed look at view matrix.
+	///
+	/// @param eye Position of the camera
+	/// @param center Position where the camera is looking at
+	/// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1)
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	///
+	/// @see - frustum(T const& left, T const& right, T const& bottom, T const& top, T const& nearVal, T const& farVal) frustum(T const& left, T const& right, T const& bottom, T const& top, T const& nearVal, T const& farVal)
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> lookAtLH(
+		vec<3, T, Q> const& eye, vec<3, T, Q> const& center, vec<3, T, Q> const& up);
+
+	/// Build a look at view matrix based on the default handedness.
+	///
+	/// @param eye Position of the camera
+	/// @param center Position where the camera is looking at
+	/// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1)
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	///
+	/// @see - frustum(T const& left, T const& right, T const& bottom, T const& top, T const& nearVal, T const& farVal) frustum(T const& left, T const& right, T const& bottom, T const& top, T const& nearVal, T const& farVal)
+	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluLookAt.xml">gluLookAt man page</a>
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> lookAt(
+		vec<3, T, Q> const& eye, vec<3, T, Q> const& center, vec<3, T, Q> const& up);
+
+	/// @}
+}//namespace glm
+
+#include "matrix_transform.inl"
diff --git a/engine/inc/glm/ext/matrix_transform.inl b/engine/inc/glm/ext/matrix_transform.inl
new file mode 100644
index 00000000..5037ec1b
--- /dev/null
+++ b/engine/inc/glm/ext/matrix_transform.inl
@@ -0,0 +1,152 @@
+namespace glm
+{
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType identity()
+	{
+		return detail::init_gentype<genType, detail::genTypeTrait<genType>::GENTYPE>::identity();
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> translate(mat<4, 4, T, Q> const& m, vec<3, T, Q> const& v)
+	{
+		mat<4, 4, T, Q> Result(m);
+		Result[3] = m[0] * v[0] + m[1] * v[1] + m[2] * v[2] + m[3];
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> rotate(mat<4, 4, T, Q> const& m, T angle, vec<3, T, Q> const& v)
+	{
+		T const a = angle;
+		T const c = cos(a);
+		T const s = sin(a);
+
+		vec<3, T, Q> axis(normalize(v));
+		vec<3, T, Q> temp((T(1) - c) * axis);
+
+		mat<4, 4, T, Q> Rotate;
+		Rotate[0][0] = c + temp[0] * axis[0];
+		Rotate[0][1] = temp[0] * axis[1] + s * axis[2];
+		Rotate[0][2] = temp[0] * axis[2] - s * axis[1];
+
+		Rotate[1][0] = temp[1] * axis[0] - s * axis[2];
+		Rotate[1][1] = c + temp[1] * axis[1];
+		Rotate[1][2] = temp[1] * axis[2] + s * axis[0];
+
+		Rotate[2][0] = temp[2] * axis[0] + s * axis[1];
+		Rotate[2][1] = temp[2] * axis[1] - s * axis[0];
+		Rotate[2][2] = c + temp[2] * axis[2];
+
+		mat<4, 4, T, Q> Result;
+		Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2];
+		Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2];
+		Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2];
+		Result[3] = m[3];
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> rotate_slow(mat<4, 4, T, Q> const& m, T angle, vec<3, T, Q> const& v)
+	{
+		T const a = angle;
+		T const c = cos(a);
+		T const s = sin(a);
+		mat<4, 4, T, Q> Result;
+
+		vec<3, T, Q> axis = normalize(v);
+
+		Result[0][0] = c + (static_cast<T>(1) - c)      * axis.x     * axis.x;
+		Result[0][1] = (static_cast<T>(1) - c) * axis.x * axis.y + s * axis.z;
+		Result[0][2] = (static_cast<T>(1) - c) * axis.x * axis.z - s * axis.y;
+		Result[0][3] = static_cast<T>(0);
+
+		Result[1][0] = (static_cast<T>(1) - c) * axis.y * axis.x - s * axis.z;
+		Result[1][1] = c + (static_cast<T>(1) - c) * axis.y * axis.y;
+		Result[1][2] = (static_cast<T>(1) - c) * axis.y * axis.z + s * axis.x;
+		Result[1][3] = static_cast<T>(0);
+
+		Result[2][0] = (static_cast<T>(1) - c) * axis.z * axis.x + s * axis.y;
+		Result[2][1] = (static_cast<T>(1) - c) * axis.z * axis.y - s * axis.x;
+		Result[2][2] = c + (static_cast<T>(1) - c) * axis.z * axis.z;
+		Result[2][3] = static_cast<T>(0);
+
+		Result[3] = vec<4, T, Q>(0, 0, 0, 1);
+		return m * Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> scale(mat<4, 4, T, Q> const& m, vec<3, T, Q> const& v)
+	{
+		mat<4, 4, T, Q> Result;
+		Result[0] = m[0] * v[0];
+		Result[1] = m[1] * v[1];
+		Result[2] = m[2] * v[2];
+		Result[3] = m[3];
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> scale_slow(mat<4, 4, T, Q> const& m, vec<3, T, Q> const& v)
+	{
+		mat<4, 4, T, Q> Result(T(1));
+		Result[0][0] = v.x;
+		Result[1][1] = v.y;
+		Result[2][2] = v.z;
+		return m * Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> lookAtRH(vec<3, T, Q> const& eye, vec<3, T, Q> const& center, vec<3, T, Q> const& up)
+	{
+		vec<3, T, Q> const f(normalize(center - eye));
+		vec<3, T, Q> const s(normalize(cross(f, up)));
+		vec<3, T, Q> const u(cross(s, f));
+
+		mat<4, 4, T, Q> Result(1);
+		Result[0][0] = s.x;
+		Result[1][0] = s.y;
+		Result[2][0] = s.z;
+		Result[0][1] = u.x;
+		Result[1][1] = u.y;
+		Result[2][1] = u.z;
+		Result[0][2] =-f.x;
+		Result[1][2] =-f.y;
+		Result[2][2] =-f.z;
+		Result[3][0] =-dot(s, eye);
+		Result[3][1] =-dot(u, eye);
+		Result[3][2] = dot(f, eye);
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> lookAtLH(vec<3, T, Q> const& eye, vec<3, T, Q> const& center, vec<3, T, Q> const& up)
+	{
+		vec<3, T, Q> const f(normalize(center - eye));
+		vec<3, T, Q> const s(normalize(cross(up, f)));
+		vec<3, T, Q> const u(cross(f, s));
+
+		mat<4, 4, T, Q> Result(1);
+		Result[0][0] = s.x;
+		Result[1][0] = s.y;
+		Result[2][0] = s.z;
+		Result[0][1] = u.x;
+		Result[1][1] = u.y;
+		Result[2][1] = u.z;
+		Result[0][2] = f.x;
+		Result[1][2] = f.y;
+		Result[2][2] = f.z;
+		Result[3][0] = -dot(s, eye);
+		Result[3][1] = -dot(u, eye);
+		Result[3][2] = -dot(f, eye);
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> lookAt(vec<3, T, Q> const& eye, vec<3, T, Q> const& center, vec<3, T, Q> const& up)
+	{
+		if(GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT)
+			return lookAtLH(eye, center, up);
+		else
+			return lookAtRH(eye, center, up);
+	}
+}//namespace glm
diff --git a/engine/inc/glm/ext/quaternion_common.hpp b/engine/inc/glm/ext/quaternion_common.hpp
new file mode 100644
index 00000000..2980ed4d
--- /dev/null
+++ b/engine/inc/glm/ext/quaternion_common.hpp
@@ -0,0 +1,120 @@
+/// @ref ext_quaternion_common
+/// @file glm/ext/quaternion_common.hpp
+///
+/// @defgroup ext_quaternion_common GLM_EXT_quaternion_common
+/// @ingroup ext
+///
+/// Provides common functions for quaternion types
+///
+/// Include <glm/ext/quaternion_common.hpp> to use the features of this extension.
+///
+/// @see ext_scalar_common
+/// @see ext_vector_common
+/// @see ext_quaternion_float
+/// @see ext_quaternion_double
+/// @see ext_quaternion_exponential
+/// @see ext_quaternion_geometric
+/// @see ext_quaternion_relational
+/// @see ext_quaternion_trigonometric
+/// @see ext_quaternion_transform
+
+#pragma once
+
+// Dependency:
+#include "../ext/scalar_constants.hpp"
+#include "../ext/quaternion_geometric.hpp"
+#include "../common.hpp"
+#include "../trigonometric.hpp"
+#include "../exponential.hpp"
+#include <limits>
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_quaternion_common extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup ext_quaternion_common
+	/// @{
+
+	/// Spherical linear interpolation of two quaternions.
+	/// The interpolation is oriented and the rotation is performed at constant speed.
+	/// For short path spherical linear interpolation, use the slerp function.
+	///
+	/// @param x A quaternion
+	/// @param y A quaternion
+	/// @param a Interpolation factor. The interpolation is defined beyond the range [0, 1].
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	///
+	/// @see - slerp(qua<T, Q> const& x, qua<T, Q> const& y, T const& a)
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> mix(qua<T, Q> const& x, qua<T, Q> const& y, T a);
+
+	/// Linear interpolation of two quaternions.
+	/// The interpolation is oriented.
+	///
+	/// @param x A quaternion
+	/// @param y A quaternion
+	/// @param a Interpolation factor. The interpolation is defined in the range [0, 1].
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> lerp(qua<T, Q> const& x, qua<T, Q> const& y, T a);
+
+	/// Spherical linear interpolation of two quaternions.
+	/// The interpolation always take the short path and the rotation is performed at constant speed.
+	///
+	/// @param x A quaternion
+	/// @param y A quaternion
+	/// @param a Interpolation factor. The interpolation is defined beyond the range [0, 1].
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> slerp(qua<T, Q> const& x, qua<T, Q> const& y, T a);
+
+	/// Returns the q conjugate.
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> conjugate(qua<T, Q> const& q);
+
+	/// Returns the q inverse.
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> inverse(qua<T, Q> const& q);
+
+	/// Returns true if x holds a NaN (not a number)
+	/// representation in the underlying implementation's set of
+	/// floating point representations. Returns false otherwise,
+	/// including for implementations with no NaN
+	/// representations.
+	///
+	/// /!\ When using compiler fast math, this function may fail.
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<4, bool, Q> isnan(qua<T, Q> const& x);
+
+	/// Returns true if x holds a positive infinity or negative
+	/// infinity representation in the underlying implementation's
+	/// set of floating point representations. Returns false
+	/// otherwise, including for implementations with no infinity
+	/// representations.
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<4, bool, Q> isinf(qua<T, Q> const& x);
+
+	/// @}
+} //namespace glm
+
+#include "quaternion_common.inl"
diff --git a/engine/inc/glm/ext/quaternion_common.inl b/engine/inc/glm/ext/quaternion_common.inl
new file mode 100644
index 00000000..3b2846f3
--- /dev/null
+++ b/engine/inc/glm/ext/quaternion_common.inl
@@ -0,0 +1,107 @@
+namespace glm
+{
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> mix(qua<T, Q> const& x, qua<T, Q> const& y, T a)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'mix' only accept floating-point inputs");
+
+		T const cosTheta = dot(x, y);
+
+		// Perform a linear interpolation when cosTheta is close to 1 to avoid side effect of sin(angle) becoming a zero denominator
+		if(cosTheta > static_cast<T>(1) - epsilon<T>())
+		{
+			// Linear interpolation
+			return qua<T, Q>(
+				mix(x.w, y.w, a),
+				mix(x.x, y.x, a),
+				mix(x.y, y.y, a),
+				mix(x.z, y.z, a));
+		}
+		else
+		{
+			// Essential Mathematics, page 467
+			T angle = acos(cosTheta);
+			return (sin((static_cast<T>(1) - a) * angle) * x + sin(a * angle) * y) / sin(angle);
+		}
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> lerp(qua<T, Q> const& x, qua<T, Q> const& y, T a)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'lerp' only accept floating-point inputs");
+
+		// Lerp is only defined in [0, 1]
+		assert(a >= static_cast<T>(0));
+		assert(a <= static_cast<T>(1));
+
+		return x * (static_cast<T>(1) - a) + (y * a);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> slerp(qua<T, Q> const& x, qua<T, Q> const& y, T a)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'slerp' only accept floating-point inputs");
+
+		qua<T, Q> z = y;
+
+		T cosTheta = dot(x, y);
+
+		// If cosTheta < 0, the interpolation will take the long way around the sphere.
+		// To fix this, one quat must be negated.
+		if(cosTheta < static_cast<T>(0))
+		{
+			z = -y;
+			cosTheta = -cosTheta;
+		}
+
+		// Perform a linear interpolation when cosTheta is close to 1 to avoid side effect of sin(angle) becoming a zero denominator
+		if(cosTheta > static_cast<T>(1) - epsilon<T>())
+		{
+			// Linear interpolation
+			return qua<T, Q>(
+				mix(x.w, z.w, a),
+				mix(x.x, z.x, a),
+				mix(x.y, z.y, a),
+				mix(x.z, z.z, a));
+		}
+		else
+		{
+			// Essential Mathematics, page 467
+			T angle = acos(cosTheta);
+			return (sin((static_cast<T>(1) - a) * angle) * x + sin(a * angle) * z) / sin(angle);
+		}
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> conjugate(qua<T, Q> const& q)
+	{
+		return qua<T, Q>(q.w, -q.x, -q.y, -q.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> inverse(qua<T, Q> const& q)
+	{
+		return conjugate(q) / dot(q, q);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, bool, Q> isnan(qua<T, Q> const& q)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isnan' only accept floating-point inputs");
+
+		return vec<4, bool, Q>(isnan(q.x), isnan(q.y), isnan(q.z), isnan(q.w));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, bool, Q> isinf(qua<T, Q> const& q)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isinf' only accept floating-point inputs");
+
+		return vec<4, bool, Q>(isinf(q.x), isinf(q.y), isinf(q.z), isinf(q.w));
+	}
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+#	include "quaternion_common_simd.inl"
+#endif
+
diff --git a/engine/inc/glm/ext/quaternion_common_simd.inl b/engine/inc/glm/ext/quaternion_common_simd.inl
new file mode 100644
index 00000000..ddfc8a44
--- /dev/null
+++ b/engine/inc/glm/ext/quaternion_common_simd.inl
@@ -0,0 +1,18 @@
+#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+namespace glm{
+namespace detail
+{
+	template<qualifier Q>
+	struct compute_dot<qua<float, Q>, float, true>
+	{
+		static GLM_FUNC_QUALIFIER float call(qua<float, Q> const& x, qua<float, Q> const& y)
+		{
+			return _mm_cvtss_f32(glm_vec1_dot(x.data, y.data));
+		}
+	};
+}//namespace detail
+}//namespace glm
+
+#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
+
diff --git a/engine/inc/glm/ext/quaternion_double.hpp b/engine/inc/glm/ext/quaternion_double.hpp
new file mode 100644
index 00000000..63b24de4
--- /dev/null
+++ b/engine/inc/glm/ext/quaternion_double.hpp
@@ -0,0 +1,39 @@
+/// @ref ext_quaternion_double
+/// @file glm/ext/quaternion_double.hpp
+///
+/// @defgroup ext_quaternion_double GLM_EXT_quaternion_double
+/// @ingroup ext
+///
+/// Exposes double-precision floating point quaternion type.
+///
+/// Include <glm/ext/quaternion_double.hpp> to use the features of this extension.
+///
+/// @see ext_quaternion_float
+/// @see ext_quaternion_double_precision
+/// @see ext_quaternion_common
+/// @see ext_quaternion_exponential
+/// @see ext_quaternion_geometric
+/// @see ext_quaternion_relational
+/// @see ext_quaternion_transform
+/// @see ext_quaternion_trigonometric
+
+#pragma once
+
+// Dependency:
+#include "../detail/type_quat.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_quaternion_double extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup ext_quaternion_double
+	/// @{
+
+	/// Quaternion of double-precision floating-point numbers.
+	typedef qua<double, defaultp>		dquat;
+
+	/// @}
+} //namespace glm
+
diff --git a/engine/inc/glm/ext/quaternion_double_precision.hpp b/engine/inc/glm/ext/quaternion_double_precision.hpp
new file mode 100644
index 00000000..8aa24a17
--- /dev/null
+++ b/engine/inc/glm/ext/quaternion_double_precision.hpp
@@ -0,0 +1,42 @@
+/// @ref ext_quaternion_double_precision
+/// @file glm/ext/quaternion_double_precision.hpp
+///
+/// @defgroup ext_quaternion_double_precision GLM_EXT_quaternion_double_precision
+/// @ingroup ext
+///
+/// Exposes double-precision floating point quaternion type with various precision in term of ULPs.
+///
+/// Include <glm/ext/quaternion_double_precision.hpp> to use the features of this extension.
+
+#pragma once
+
+// Dependency:
+#include "../detail/type_quat.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_quaternion_double_precision extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup ext_quaternion_double_precision
+	/// @{
+
+	/// Quaternion of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	///
+	/// @see ext_quaternion_double_precision
+	typedef qua<double, lowp>		lowp_dquat;
+
+	/// Quaternion of medium double-qualifier floating-point numbers using high precision arithmetic in term of ULPs.
+	///
+	/// @see ext_quaternion_double_precision
+	typedef qua<double, mediump>	mediump_dquat;
+
+	/// Quaternion of high double-qualifier floating-point numbers using high precision arithmetic in term of ULPs.
+	///
+	/// @see ext_quaternion_double_precision
+	typedef qua<double, highp>		highp_dquat;
+
+	/// @}
+} //namespace glm
+
diff --git a/engine/inc/glm/ext/quaternion_exponential.hpp b/engine/inc/glm/ext/quaternion_exponential.hpp
new file mode 100644
index 00000000..affe2979
--- /dev/null
+++ b/engine/inc/glm/ext/quaternion_exponential.hpp
@@ -0,0 +1,63 @@
+/// @ref ext_quaternion_exponential
+/// @file glm/ext/quaternion_exponential.hpp
+///
+/// @defgroup ext_quaternion_exponential GLM_EXT_quaternion_exponential
+/// @ingroup ext
+///
+/// Provides exponential functions for quaternion types
+///
+/// Include <glm/ext/quaternion_exponential.hpp> to use the features of this extension.
+///
+/// @see core_exponential
+/// @see ext_quaternion_float
+/// @see ext_quaternion_double
+
+#pragma once
+
+// Dependency:
+#include "../common.hpp"
+#include "../trigonometric.hpp"
+#include "../geometric.hpp"
+#include "../ext/scalar_constants.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_quaternion_exponential extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup ext_quaternion_transform
+	/// @{
+
+	/// Returns a exponential of a quaternion.
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> exp(qua<T, Q> const& q);
+
+	/// Returns a logarithm of a quaternion
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> log(qua<T, Q> const& q);
+
+	/// Returns a quaternion raised to a power.
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> pow(qua<T, Q> const& q, T y);
+
+	/// Returns the square root of a quaternion
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> sqrt(qua<T, Q> const& q);
+
+	/// @}
+} //namespace glm
+
+#include "quaternion_exponential.inl"
diff --git a/engine/inc/glm/ext/quaternion_exponential.inl b/engine/inc/glm/ext/quaternion_exponential.inl
new file mode 100644
index 00000000..1365d0a9
--- /dev/null
+++ b/engine/inc/glm/ext/quaternion_exponential.inl
@@ -0,0 +1,69 @@
+namespace glm
+{
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> exp(qua<T, Q> const& q)
+	{
+		vec<3, T, Q> u(q.x, q.y, q.z);
+		T const Angle = glm::length(u);
+		if (Angle < epsilon<T>())
+			return qua<T, Q>();
+
+		vec<3, T, Q> const v(u / Angle);
+		return qua<T, Q>(cos(Angle), sin(Angle) * v);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> log(qua<T, Q> const& q)
+	{
+		vec<3, T, Q> u(q.x, q.y, q.z);
+		T Vec3Len = length(u);
+
+		if (Vec3Len < epsilon<T>())
+		{
+			if(q.w > static_cast<T>(0))
+				return qua<T, Q>(log(q.w), static_cast<T>(0), static_cast<T>(0), static_cast<T>(0));
+			else if(q.w < static_cast<T>(0))
+				return qua<T, Q>(log(-q.w), pi<T>(), static_cast<T>(0), static_cast<T>(0));
+			else
+				return qua<T, Q>(std::numeric_limits<T>::infinity(), std::numeric_limits<T>::infinity(), std::numeric_limits<T>::infinity(), std::numeric_limits<T>::infinity());
+		}
+		else
+		{
+			T t = atan(Vec3Len, T(q.w)) / Vec3Len;
+			T QuatLen2 = Vec3Len * Vec3Len + q.w * q.w;
+			return qua<T, Q>(static_cast<T>(0.5) * log(QuatLen2), t * q.x, t * q.y, t * q.z);
+		}
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> pow(qua<T, Q> const& x, T y)
+	{
+		//Raising to the power of 0 should yield 1
+		//Needed to prevent a division by 0 error later on
+		if(y > -epsilon<T>() && y < epsilon<T>())
+			return qua<T, Q>(1,0,0,0);
+
+		//To deal with non-unit quaternions
+		T magnitude = sqrt(x.x * x.x + x.y * x.y + x.z * x.z + x.w *x.w);
+
+		//Equivalent to raising a real number to a power
+		//Needed to prevent a division by 0 error later on
+		if(abs(x.w / magnitude) > static_cast<T>(1) - epsilon<T>() && abs(x.w / magnitude) < static_cast<T>(1) + epsilon<T>())
+			return qua<T, Q>(pow(x.w, y), 0, 0, 0);
+
+		T Angle = acos(x.w / magnitude);
+		T NewAngle = Angle * y;
+		T Div = sin(NewAngle) / sin(Angle);
+		T Mag = pow(magnitude, y - static_cast<T>(1));
+
+		return qua<T, Q>(cos(NewAngle) * magnitude * Mag, x.x * Div * Mag, x.y * Div * Mag, x.z * Div * Mag);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> sqrt(qua<T, Q> const& x)
+	{
+		return pow(x, static_cast<T>(0.5));
+	}
+}//namespace glm
+
+
diff --git a/engine/inc/glm/ext/quaternion_float.hpp b/engine/inc/glm/ext/quaternion_float.hpp
new file mode 100644
index 00000000..ca42a605
--- /dev/null
+++ b/engine/inc/glm/ext/quaternion_float.hpp
@@ -0,0 +1,39 @@
+/// @ref ext_quaternion_float
+/// @file glm/ext/quaternion_float.hpp
+///
+/// @defgroup ext_quaternion_float GLM_EXT_quaternion_float
+/// @ingroup ext
+///
+/// Exposes single-precision floating point quaternion type.
+///
+/// Include <glm/ext/quaternion_float.hpp> to use the features of this extension.
+///
+/// @see ext_quaternion_double
+/// @see ext_quaternion_float_precision
+/// @see ext_quaternion_common
+/// @see ext_quaternion_exponential
+/// @see ext_quaternion_geometric
+/// @see ext_quaternion_relational
+/// @see ext_quaternion_transform
+/// @see ext_quaternion_trigonometric
+
+#pragma once
+
+// Dependency:
+#include "../detail/type_quat.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_quaternion_float extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup ext_quaternion_float
+	/// @{
+
+	/// Quaternion of single-precision floating-point numbers.
+	typedef qua<float, defaultp>		quat;
+
+	/// @}
+} //namespace glm
+
diff --git a/engine/inc/glm/ext/quaternion_float_precision.hpp b/engine/inc/glm/ext/quaternion_float_precision.hpp
new file mode 100644
index 00000000..f9e4f5c2
--- /dev/null
+++ b/engine/inc/glm/ext/quaternion_float_precision.hpp
@@ -0,0 +1,36 @@
+/// @ref ext_quaternion_float_precision
+/// @file glm/ext/quaternion_float_precision.hpp
+///
+/// @defgroup ext_quaternion_float_precision GLM_EXT_quaternion_float_precision
+/// @ingroup ext
+///
+/// Exposes single-precision floating point quaternion type with various precision in term of ULPs.
+///
+/// Include <glm/ext/quaternion_float_precision.hpp> to use the features of this extension.
+
+#pragma once
+
+// Dependency:
+#include "../detail/type_quat.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_quaternion_float_precision extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup ext_quaternion_float_precision
+	/// @{
+
+	/// Quaternion of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef qua<float, lowp>		lowp_quat;
+
+	/// Quaternion of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef qua<float, mediump>		mediump_quat;
+
+	/// Quaternion of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef qua<float, highp>		highp_quat;
+
+	/// @}
+} //namespace glm
+
diff --git a/engine/inc/glm/ext/quaternion_geometric.hpp b/engine/inc/glm/ext/quaternion_geometric.hpp
new file mode 100644
index 00000000..6d98bbe9
--- /dev/null
+++ b/engine/inc/glm/ext/quaternion_geometric.hpp
@@ -0,0 +1,70 @@
+/// @ref ext_quaternion_geometric
+/// @file glm/ext/quaternion_geometric.hpp
+///
+/// @defgroup ext_quaternion_geometric GLM_EXT_quaternion_geometric
+/// @ingroup ext
+///
+/// Provides geometric functions for quaternion types
+///
+/// Include <glm/ext/quaternion_geometric.hpp> to use the features of this extension.
+///
+/// @see core_geometric
+/// @see ext_quaternion_float
+/// @see ext_quaternion_double
+
+#pragma once
+
+// Dependency:
+#include "../geometric.hpp"
+#include "../exponential.hpp"
+#include "../ext/vector_relational.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_quaternion_geometric extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup ext_quaternion_geometric
+	/// @{
+
+	/// Returns the norm of a quaternions
+	///
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see ext_quaternion_geometric
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL T length(qua<T, Q> const& q);
+
+	/// Returns the normalized quaternion.
+	///
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see ext_quaternion_geometric
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> normalize(qua<T, Q> const& q);
+
+	/// Returns dot product of q1 and q2, i.e., q1[0] * q2[0] + q1[1] * q2[1] + ...
+	///
+	/// @tparam T Floating-point scalar types.
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see ext_quaternion_geometric
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL T dot(qua<T, Q> const& x, qua<T, Q> const& y);
+
+	/// Compute a cross product.
+	///
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see ext_quaternion_geometric
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> cross(qua<T, Q> const& q1, qua<T, Q> const& q2);
+
+	/// @}
+} //namespace glm
+
+#include "quaternion_geometric.inl"
diff --git a/engine/inc/glm/ext/quaternion_geometric.inl b/engine/inc/glm/ext/quaternion_geometric.inl
new file mode 100644
index 00000000..e155ac52
--- /dev/null
+++ b/engine/inc/glm/ext/quaternion_geometric.inl
@@ -0,0 +1,36 @@
+namespace glm
+{
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T dot(qua<T, Q> const& x, qua<T, Q> const& y)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' accepts only floating-point inputs");
+		return detail::compute_dot<qua<T, Q>, T, detail::is_aligned<Q>::value>::call(x, y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T length(qua<T, Q> const& q)
+	{
+		return glm::sqrt(dot(q, q));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> normalize(qua<T, Q> const& q)
+	{
+		T len = length(q);
+		if(len <= static_cast<T>(0)) // Problem
+			return qua<T, Q>(static_cast<T>(1), static_cast<T>(0), static_cast<T>(0), static_cast<T>(0));
+		T oneOverLen = static_cast<T>(1) / len;
+		return qua<T, Q>(q.w * oneOverLen, q.x * oneOverLen, q.y * oneOverLen, q.z * oneOverLen);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> cross(qua<T, Q> const& q1, qua<T, Q> const& q2)
+	{
+		return qua<T, Q>(
+			q1.w * q2.w - q1.x * q2.x - q1.y * q2.y - q1.z * q2.z,
+			q1.w * q2.x + q1.x * q2.w + q1.y * q2.z - q1.z * q2.y,
+			q1.w * q2.y + q1.y * q2.w + q1.z * q2.x - q1.x * q2.z,
+			q1.w * q2.z + q1.z * q2.w + q1.x * q2.y - q1.y * q2.x);
+	}
+}//namespace glm
+
diff --git a/engine/inc/glm/ext/quaternion_relational.hpp b/engine/inc/glm/ext/quaternion_relational.hpp
new file mode 100644
index 00000000..7aa121da
--- /dev/null
+++ b/engine/inc/glm/ext/quaternion_relational.hpp
@@ -0,0 +1,62 @@
+/// @ref ext_quaternion_relational
+/// @file glm/ext/quaternion_relational.hpp
+///
+/// @defgroup ext_quaternion_relational GLM_EXT_quaternion_relational
+/// @ingroup ext
+///
+/// Exposes comparison functions for quaternion types that take a user defined epsilon values.
+///
+/// Include <glm/ext/quaternion_relational.hpp> to use the features of this extension.
+///
+/// @see core_vector_relational
+/// @see ext_vector_relational
+/// @see ext_matrix_relational
+/// @see ext_quaternion_float
+/// @see ext_quaternion_double
+
+#pragma once
+
+// Dependency:
+#include "../vector_relational.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_quaternion_relational extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup ext_quaternion_relational
+	/// @{
+
+	/// Returns the component-wise comparison of result x == y.
+	///
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<4, bool, Q> equal(qua<T, Q> const& x, qua<T, Q> const& y);
+
+	/// Returns the component-wise comparison of |x - y| < epsilon.
+	///
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<4, bool, Q> equal(qua<T, Q> const& x, qua<T, Q> const& y, T epsilon);
+
+	/// Returns the component-wise comparison of result x != y.
+	///
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<4, bool, Q> notEqual(qua<T, Q> const& x, qua<T, Q> const& y);
+
+	/// Returns the component-wise comparison of |x - y| >= epsilon.
+	///
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<4, bool, Q> notEqual(qua<T, Q> const& x, qua<T, Q> const& y, T epsilon);
+
+	/// @}
+} //namespace glm
+
+#include "quaternion_relational.inl"
diff --git a/engine/inc/glm/ext/quaternion_relational.inl b/engine/inc/glm/ext/quaternion_relational.inl
new file mode 100644
index 00000000..b1713e95
--- /dev/null
+++ b/engine/inc/glm/ext/quaternion_relational.inl
@@ -0,0 +1,35 @@
+namespace glm
+{
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, bool, Q> equal(qua<T, Q> const& x, qua<T, Q> const& y)
+	{
+		vec<4, bool, Q> Result;
+		for(length_t i = 0; i < x.length(); ++i)
+			Result[i] = x[i] == y[i];
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, bool, Q> equal(qua<T, Q> const& x, qua<T, Q> const& y, T epsilon)
+	{
+		vec<4, T, Q> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w);
+		return lessThan(abs(v), vec<4, T, Q>(epsilon));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, bool, Q> notEqual(qua<T, Q> const& x, qua<T, Q> const& y)
+	{
+		vec<4, bool, Q> Result;
+		for(length_t i = 0; i < x.length(); ++i)
+			Result[i] = x[i] != y[i];
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, bool, Q> notEqual(qua<T, Q> const& x, qua<T, Q> const& y, T epsilon)
+	{
+		vec<4, T, Q> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w);
+		return greaterThanEqual(abs(v), vec<4, T, Q>(epsilon));
+	}
+}//namespace glm
+
diff --git a/engine/inc/glm/ext/quaternion_transform.hpp b/engine/inc/glm/ext/quaternion_transform.hpp
new file mode 100644
index 00000000..a9cc5c2b
--- /dev/null
+++ b/engine/inc/glm/ext/quaternion_transform.hpp
@@ -0,0 +1,47 @@
+/// @ref ext_quaternion_transform
+/// @file glm/ext/quaternion_transform.hpp
+///
+/// @defgroup ext_quaternion_transform GLM_EXT_quaternion_transform
+/// @ingroup ext
+///
+/// Provides transformation functions for quaternion types
+///
+/// Include <glm/ext/quaternion_transform.hpp> to use the features of this extension.
+///
+/// @see ext_quaternion_float
+/// @see ext_quaternion_double
+/// @see ext_quaternion_exponential
+/// @see ext_quaternion_geometric
+/// @see ext_quaternion_relational
+/// @see ext_quaternion_trigonometric
+
+#pragma once
+
+// Dependency:
+#include "../common.hpp"
+#include "../trigonometric.hpp"
+#include "../geometric.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_quaternion_transform extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup ext_quaternion_transform
+	/// @{
+
+	/// Rotates a quaternion from a vector of 3 components axis and an angle.
+	///
+	/// @param q Source orientation
+	/// @param angle Angle expressed in radians.
+	/// @param axis Axis of the rotation
+	///
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> rotate(qua<T, Q> const& q, T const& angle, vec<3, T, Q> const& axis);
+	/// @}
+} //namespace glm
+
+#include "quaternion_transform.inl"
diff --git a/engine/inc/glm/ext/quaternion_transform.inl b/engine/inc/glm/ext/quaternion_transform.inl
new file mode 100644
index 00000000..b87ecb65
--- /dev/null
+++ b/engine/inc/glm/ext/quaternion_transform.inl
@@ -0,0 +1,24 @@
+namespace glm
+{
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> rotate(qua<T, Q> const& q, T const& angle, vec<3, T, Q> const& v)
+	{
+		vec<3, T, Q> Tmp = v;
+
+		// Axis of rotation must be normalised
+		T len = glm::length(Tmp);
+		if(abs(len - static_cast<T>(1)) > static_cast<T>(0.001))
+		{
+			T oneOverLen = static_cast<T>(1) / len;
+			Tmp.x *= oneOverLen;
+			Tmp.y *= oneOverLen;
+			Tmp.z *= oneOverLen;
+		}
+
+		T const AngleRad(angle);
+		T const Sin = sin(AngleRad * static_cast<T>(0.5));
+
+		return q * qua<T, Q>(cos(AngleRad * static_cast<T>(0.5)), Tmp.x * Sin, Tmp.y * Sin, Tmp.z * Sin);
+	}
+}//namespace glm
+
diff --git a/engine/inc/glm/ext/quaternion_trigonometric.hpp b/engine/inc/glm/ext/quaternion_trigonometric.hpp
new file mode 100644
index 00000000..76cea27a
--- /dev/null
+++ b/engine/inc/glm/ext/quaternion_trigonometric.hpp
@@ -0,0 +1,63 @@
+/// @ref ext_quaternion_trigonometric
+/// @file glm/ext/quaternion_trigonometric.hpp
+///
+/// @defgroup ext_quaternion_trigonometric GLM_EXT_quaternion_trigonometric
+/// @ingroup ext
+///
+/// Provides trigonometric functions for quaternion types
+///
+/// Include <glm/ext/quaternion_trigonometric.hpp> to use the features of this extension.
+///
+/// @see ext_quaternion_float
+/// @see ext_quaternion_double
+/// @see ext_quaternion_exponential
+/// @see ext_quaternion_geometric
+/// @see ext_quaternion_relational
+/// @see ext_quaternion_transform
+
+#pragma once
+
+// Dependency:
+#include "../trigonometric.hpp"
+#include "../exponential.hpp"
+#include "scalar_constants.hpp"
+#include "vector_relational.hpp"
+#include <limits>
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_quaternion_trigonometric extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup ext_quaternion_trigonometric
+	/// @{
+
+	/// Returns the quaternion rotation angle.
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL T angle(qua<T, Q> const& x);
+
+	/// Returns the q rotation axis.
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> axis(qua<T, Q> const& x);
+
+	/// Build a quaternion from an angle and a normalized axis.
+	///
+	/// @param angle Angle expressed in radians.
+	/// @param axis Axis of the quaternion, must be normalized.
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> angleAxis(T const& angle, vec<3, T, Q> const& axis);
+
+	/// @}
+} //namespace glm
+
+#include "quaternion_trigonometric.inl"
diff --git a/engine/inc/glm/ext/quaternion_trigonometric.inl b/engine/inc/glm/ext/quaternion_trigonometric.inl
new file mode 100644
index 00000000..0c0bf63f
--- /dev/null
+++ b/engine/inc/glm/ext/quaternion_trigonometric.inl
@@ -0,0 +1,27 @@
+namespace glm
+{
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T angle(qua<T, Q> const& x)
+	{
+		return acos(x.w) * static_cast<T>(2);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> axis(qua<T, Q> const& x)
+	{
+		T const tmp1 = static_cast<T>(1) - x.w * x.w;
+		if(tmp1 <= static_cast<T>(0))
+			return vec<3, T, Q>(0, 0, 1);
+		T const tmp2 = static_cast<T>(1) / sqrt(tmp1);
+		return vec<3, T, Q>(x.x * tmp2, x.y * tmp2, x.z * tmp2);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> angleAxis(T const& angle, vec<3, T, Q> const& v)
+	{
+		T const a(angle);
+		T const s = glm::sin(a * static_cast<T>(0.5));
+
+		return qua<T, Q>(glm::cos(a * static_cast<T>(0.5)), v * s);
+	}
+}//namespace glm
diff --git a/engine/inc/glm/ext/scalar_common.hpp b/engine/inc/glm/ext/scalar_common.hpp
new file mode 100644
index 00000000..4ab0f88b
--- /dev/null
+++ b/engine/inc/glm/ext/scalar_common.hpp
@@ -0,0 +1,103 @@
+/// @ref ext_scalar_common
+/// @file glm/ext/scalar_common.hpp
+///
+/// @defgroup ext_scalar_common GLM_EXT_scalar_common
+/// @ingroup ext
+///
+/// Exposes min and max functions for 3 to 4 scalar parameters.
+///
+/// Include <glm/ext/scalar_common.hpp> to use the features of this extension.
+///
+/// @see core_func_common
+/// @see ext_vector_common
+
+#pragma once
+
+// Dependency:
+#include "../common.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_scalar_common extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup ext_scalar_common
+	/// @{
+
+	/// Returns the minimum component-wise values of 3 inputs
+	///
+	/// @tparam T A floating-point scalar type.
+	template<typename T>
+	GLM_FUNC_DECL T min(T a, T b, T c);
+
+	/// Returns the minimum component-wise values of 4 inputs
+	///
+	/// @tparam T A floating-point scalar type.
+	template<typename T>
+	GLM_FUNC_DECL T min(T a, T b, T c, T d);
+
+	/// Returns the maximum component-wise values of 3 inputs
+	///
+	/// @tparam T A floating-point scalar type.
+	template<typename T>
+	GLM_FUNC_DECL T max(T a, T b, T c);
+
+	/// Returns the maximum component-wise values of 4 inputs
+	///
+	/// @tparam T A floating-point scalar type.
+	template<typename T>
+	GLM_FUNC_DECL T max(T a, T b, T c, T d);
+
+	/// Returns the minimum component-wise values of 2 inputs. If one of the two arguments is NaN, the value of the other argument is returned.
+	///
+	/// @tparam T A floating-point scalar type.
+	///
+	/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmin">std::fmin documentation</a>
+	template<typename T>
+	GLM_FUNC_DECL T fmin(T a, T b);
+
+	/// Returns the minimum component-wise values of 3 inputs. If one of the two arguments is NaN, the value of the other argument is returned.
+	///
+	/// @tparam T A floating-point scalar type.
+	///
+	/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmin">std::fmin documentation</a>
+	template<typename T>
+	GLM_FUNC_DECL T fmin(T a, T b, T c);
+
+	/// Returns the minimum component-wise values of 4 inputs. If one of the two arguments is NaN, the value of the other argument is returned.
+	///
+	/// @tparam T A floating-point scalar type.
+	///
+	/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmin">std::fmin documentation</a>
+	template<typename T>
+	GLM_FUNC_DECL T fmin(T a, T b, T c, T d);
+
+	/// Returns the maximum component-wise values of 2 inputs. If one of the two arguments is NaN, the value of the other argument is returned.
+	///
+	/// @tparam T A floating-point scalar type.
+	///
+	/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmax">std::fmax documentation</a>
+	template<typename T>
+	GLM_FUNC_DECL T fmax(T a, T b);
+
+	/// Returns the maximum component-wise values of 3 inputs. If one of the two arguments is NaN, the value of the other argument is returned.
+	///
+	/// @tparam T A floating-point scalar type.
+	///
+	/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmax">std::fmax documentation</a>
+	template<typename T>
+	GLM_FUNC_DECL T fmax(T a, T b, T C);
+
+	/// Returns the maximum component-wise values of 4 inputs. If one of the two arguments is NaN, the value of the other argument is returned.
+	///
+	/// @tparam T A floating-point scalar type.
+	///
+	/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmax">std::fmax documentation</a>
+	template<typename T>
+	GLM_FUNC_DECL T fmax(T a, T b, T C, T D);
+
+	/// @}
+}//namespace glm
+
+#include "scalar_common.inl"
diff --git a/engine/inc/glm/ext/scalar_common.inl b/engine/inc/glm/ext/scalar_common.inl
new file mode 100644
index 00000000..118a670e
--- /dev/null
+++ b/engine/inc/glm/ext/scalar_common.inl
@@ -0,0 +1,115 @@
+namespace glm
+{
+	template<typename T>
+	GLM_FUNC_QUALIFIER T min(T a, T b, T c)
+	{
+		return glm::min(glm::min(a, b), c);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER T min(T a, T b, T c, T d)
+	{
+		return glm::min(glm::min(a, b), glm::min(c, d));
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER T max(T a, T b, T c)
+	{
+		return glm::max(glm::max(a, b), c);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER T max(T a, T b, T c, T d)
+	{
+		return glm::max(glm::max(a, b), glm::max(c, d));
+	}
+
+#	if GLM_HAS_CXX11_STL
+		using std::fmin;
+#	else
+		template<typename T>
+		GLM_FUNC_QUALIFIER T fmin(T a, T b)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'fmin' only accept floating-point input");
+
+			if (isnan(a))
+				return b;
+			return min(a, b);
+		}
+#	endif
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER T fmin(T a, T b, T c)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'fmin' only accept floating-point input");
+
+		if (isnan(a))
+			return fmin(b, c);
+		if (isnan(b))
+			return fmin(a, c);
+		if (isnan(c))
+			return min(a, b);
+		return min(a, b, c);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER T fmin(T a, T b, T c, T d)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'fmin' only accept floating-point input");
+
+		if (isnan(a))
+			return fmin(b, c, d);
+		if (isnan(b))
+			return min(a, fmin(c, d));
+		if (isnan(c))
+			return fmin(min(a, b), d);
+		if (isnan(d))
+			return min(a, b, c);
+		return min(a, b, c, d);
+	}
+
+
+#	if GLM_HAS_CXX11_STL
+		using std::fmax;
+#	else
+		template<typename T>
+		GLM_FUNC_QUALIFIER T fmax(T a, T b)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'fmax' only accept floating-point input");
+
+			if (isnan(a))
+				return b;
+			return max(a, b);
+		}
+#	endif
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER T fmax(T a, T b, T c)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'fmax' only accept floating-point input");
+
+		if (isnan(a))
+			return fmax(b, c);
+		if (isnan(b))
+			return fmax(a, c);
+		if (isnan(c))
+			return max(a, b);
+		return max(a, b, c);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER T fmax(T a, T b, T c, T d)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'fmax' only accept floating-point input");
+
+		if (isnan(a))
+			return fmax(b, c, d);
+		if (isnan(b))
+			return max(a, fmax(c, d));
+		if (isnan(c))
+			return fmax(max(a, b), d);
+		if (isnan(d))
+			return max(a, b, c);
+		return max(a, b, c, d);
+	}
+}//namespace glm
diff --git a/engine/inc/glm/ext/scalar_constants.hpp b/engine/inc/glm/ext/scalar_constants.hpp
new file mode 100644
index 00000000..4a61faa5
--- /dev/null
+++ b/engine/inc/glm/ext/scalar_constants.hpp
@@ -0,0 +1,36 @@
+/// @ref ext_scalar_constants
+/// @file glm/ext/scalar_constants.hpp
+///
+/// @defgroup ext_scalar_constants GLM_EXT_scalar_constants
+/// @ingroup ext
+///
+/// Provides a list of constants and precomputed useful values.
+///
+/// Include <glm/ext/scalar_constants.hpp> to use the features of this extension.
+
+#pragma once
+
+// Dependencies
+#include "../detail/setup.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_scalar_constants extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup ext_scalar_constants
+	/// @{
+
+	/// Return the epsilon constant for floating point types.
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType epsilon();
+
+	/// Return the pi constant for floating point types.
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType pi();
+
+	/// @}
+} //namespace glm
+
+#include "scalar_constants.inl"
diff --git a/engine/inc/glm/ext/scalar_constants.inl b/engine/inc/glm/ext/scalar_constants.inl
new file mode 100644
index 00000000..c075fbc7
--- /dev/null
+++ b/engine/inc/glm/ext/scalar_constants.inl
@@ -0,0 +1,18 @@
+#include <limits>
+
+namespace glm
+{
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType epsilon()
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'epsilon' only accepts floating-point inputs");
+		return std::numeric_limits<genType>::epsilon();
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType pi()
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'epsilon' only accepts floating-point inputs");
+		return static_cast<genType>(3.14159265358979323846264338327950288);
+	}
+} //namespace glm
diff --git a/engine/inc/glm/ext/scalar_int_sized.hpp b/engine/inc/glm/ext/scalar_int_sized.hpp
new file mode 100644
index 00000000..5dbd7845
--- /dev/null
+++ b/engine/inc/glm/ext/scalar_int_sized.hpp
@@ -0,0 +1,70 @@
+/// @ref ext_scalar_int_sized
+/// @file glm/ext/scalar_int_sized.hpp
+///
+/// @defgroup ext_scalar_int_sized GLM_EXT_scalar_int_sized
+/// @ingroup ext
+///
+/// Exposes sized signed integer scalar types.
+///
+/// Include <glm/ext/scalar_int_sized.hpp> to use the features of this extension.
+///
+/// @see ext_scalar_uint_sized
+
+#pragma once
+
+#include "../detail/setup.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_scalar_int_sized extension included")
+#endif
+
+namespace glm{
+namespace detail
+{
+#	if GLM_HAS_EXTENDED_INTEGER_TYPE
+		typedef std::int8_t			int8;
+		typedef std::int16_t		int16;
+		typedef std::int32_t		int32;
+#	else
+		typedef char				int8;
+		typedef short				int16;
+		typedef int					int32;
+#endif//
+
+	template<>
+	struct is_int<int8>
+	{
+		enum test {value = ~0};
+	};
+
+	template<>
+	struct is_int<int16>
+	{
+		enum test {value = ~0};
+	};
+
+	template<>
+	struct is_int<int64>
+	{
+		enum test {value = ~0};
+	};
+}//namespace detail
+
+
+	/// @addtogroup ext_scalar_int_sized
+	/// @{
+
+	/// 8 bit signed integer type.
+	typedef detail::int8		int8;
+
+	/// 16 bit signed integer type.
+	typedef detail::int16		int16;
+
+	/// 32 bit signed integer type.
+	typedef detail::int32		int32;
+
+	/// 64 bit signed integer type.
+	typedef detail::int64		int64;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/scalar_relational.hpp b/engine/inc/glm/ext/scalar_relational.hpp
new file mode 100644
index 00000000..3076a5e6
--- /dev/null
+++ b/engine/inc/glm/ext/scalar_relational.hpp
@@ -0,0 +1,65 @@
+/// @ref ext_scalar_relational
+/// @file glm/ext/scalar_relational.hpp
+///
+/// @defgroup ext_scalar_relational GLM_EXT_scalar_relational
+/// @ingroup ext
+///
+/// Exposes comparison functions for scalar types that take a user defined epsilon values.
+///
+/// Include <glm/ext/scalar_relational.hpp> to use the features of this extension.
+///
+/// @see core_vector_relational
+/// @see ext_vector_relational
+/// @see ext_matrix_relational
+
+#pragma once
+
+// Dependencies
+#include "../detail/qualifier.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_scalar_relational extension included")
+#endif
+
+namespace glm
+{
+	/// Returns the component-wise comparison of |x - y| < epsilon.
+	/// True if this expression is satisfied.
+	///
+	/// @tparam genType Floating-point or integer scalar types
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR bool equal(genType const& x, genType const& y, genType const& epsilon);
+
+	/// Returns the component-wise comparison of |x - y| >= epsilon.
+	/// True if this expression is not satisfied.
+	///
+	/// @tparam genType Floating-point or integer scalar types
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR bool notEqual(genType const& x, genType const& y, genType const& epsilon);
+
+	/// Returns the component-wise comparison between two scalars in term of ULPs.
+	/// True if this expression is satisfied.
+	///
+	/// @param x First operand.
+	/// @param y Second operand.
+	/// @param ULPs Maximum difference in ULPs between the two operators to consider them equal.
+	///
+	/// @tparam genType Floating-point or integer scalar types
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR bool equal(genType const& x, genType const& y, int ULPs);
+
+	/// Returns the component-wise comparison between two scalars in term of ULPs.
+	/// True if this expression is not satisfied.
+	///
+	/// @param x First operand.
+	/// @param y Second operand.
+	/// @param ULPs Maximum difference in ULPs between the two operators to consider them not equal.
+	///
+	/// @tparam genType Floating-point or integer scalar types
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR bool notEqual(genType const& x, genType const& y, int ULPs);
+
+	/// @}
+}//namespace glm
+
+#include "scalar_relational.inl"
diff --git a/engine/inc/glm/ext/scalar_relational.inl b/engine/inc/glm/ext/scalar_relational.inl
new file mode 100644
index 00000000..27370e14
--- /dev/null
+++ b/engine/inc/glm/ext/scalar_relational.inl
@@ -0,0 +1,43 @@
+#include "../common.hpp"
+#include "../ext/scalar_int_sized.hpp"
+#include "../ext/scalar_uint_sized.hpp"
+#include "../detail/type_float.hpp"
+
+namespace glm
+{
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool equal(genType const& x, genType const& y, genType const& epsilon)
+	{
+		return abs(x - y) <= epsilon;
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool notEqual(genType const& x, genType const& y, genType const& epsilon)
+	{
+		return abs(x - y) > epsilon;
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool equal(genType const& x, genType const& y, int MaxULPs)
+	{
+		detail::float_t<genType> const a(x);
+		detail::float_t<genType> const b(y);
+
+		// Different signs means they do not match.
+		if(a.negative() != b.negative())
+		{
+			// Check for equality to make sure +0==-0
+			return a.mantissa() == b.mantissa() && a.exponent() == b.exponent();
+		}
+
+		// Find the difference in ULPs.
+		typename detail::float_t<genType>::int_type const DiffULPs = abs(a.i - b.i);
+		return DiffULPs <= MaxULPs;
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool notEqual(genType const& x, genType const& y, int ULPs)
+	{
+		return !equal(x, y, ULPs);
+	}
+}//namespace glm
diff --git a/engine/inc/glm/ext/scalar_uint_sized.hpp b/engine/inc/glm/ext/scalar_uint_sized.hpp
new file mode 100644
index 00000000..fd5267fa
--- /dev/null
+++ b/engine/inc/glm/ext/scalar_uint_sized.hpp
@@ -0,0 +1,70 @@
+/// @ref ext_scalar_uint_sized
+/// @file glm/ext/scalar_uint_sized.hpp
+///
+/// @defgroup ext_scalar_uint_sized GLM_EXT_scalar_uint_sized
+/// @ingroup ext
+///
+/// Exposes sized unsigned integer scalar types.
+///
+/// Include <glm/ext/scalar_uint_sized.hpp> to use the features of this extension.
+///
+/// @see ext_scalar_int_sized
+
+#pragma once
+
+#include "../detail/setup.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_scalar_uint_sized extension included")
+#endif
+
+namespace glm{
+namespace detail
+{
+#	if GLM_HAS_EXTENDED_INTEGER_TYPE
+		typedef std::uint8_t		uint8;
+		typedef std::uint16_t		uint16;
+		typedef std::uint32_t		uint32;
+#	else
+		typedef unsigned char		uint8;
+		typedef unsigned short		uint16;
+		typedef unsigned int		uint32;
+#endif
+
+	template<>
+	struct is_int<uint8>
+	{
+		enum test {value = ~0};
+	};
+
+	template<>
+	struct is_int<uint16>
+	{
+		enum test {value = ~0};
+	};
+
+	template<>
+	struct is_int<uint64>
+	{
+		enum test {value = ~0};
+	};
+}//namespace detail
+
+
+	/// @addtogroup ext_scalar_uint_sized
+	/// @{
+
+	/// 8 bit unsigned integer type.
+	typedef detail::uint8		uint8;
+
+	/// 16 bit unsigned integer type.
+	typedef detail::uint16		uint16;
+
+	/// 32 bit unsigned integer type.
+	typedef detail::uint32		uint32;
+
+	/// 64 bit unsigned integer type.
+	typedef detail::uint64		uint64;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/scalar_ulp.hpp b/engine/inc/glm/ext/scalar_ulp.hpp
new file mode 100644
index 00000000..90e177da
--- /dev/null
+++ b/engine/inc/glm/ext/scalar_ulp.hpp
@@ -0,0 +1,74 @@
+/// @ref ext_scalar_ulp
+/// @file glm/ext/scalar_ulp.hpp
+///
+/// @defgroup ext_scalar_ulp GLM_EXT_scalar_ulp
+/// @ingroup ext
+///
+/// Allow the measurement of the accuracy of a function against a reference
+/// implementation. This extension works on floating-point data and provide results
+/// in ULP.
+///
+/// Include <glm/ext/scalar_ulp.hpp> to use the features of this extension.
+///
+/// @see ext_vector_ulp
+/// @see ext_scalar_relational
+
+#pragma once
+
+// Dependencies
+#include "../ext/scalar_int_sized.hpp"
+#include "../common.hpp"
+#include "../detail/qualifier.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_scalar_ulp extension included")
+#endif
+
+namespace glm
+{
+	/// Return the next ULP value(s) after the input value(s).
+	///
+	/// @tparam genType A floating-point scalar type.
+	///
+	/// @see ext_scalar_ulp
+	template<typename genType>
+	GLM_FUNC_DECL genType next_float(genType x);
+
+	/// Return the previous ULP value(s) before the input value(s).
+	///
+	/// @tparam genType A floating-point scalar type.
+	///
+	/// @see ext_scalar_ulp
+	template<typename genType>
+	GLM_FUNC_DECL genType prev_float(genType x);
+
+	/// Return the value(s) ULP distance after the input value(s).
+	///
+	/// @tparam genType A floating-point scalar type.
+	///
+	/// @see ext_scalar_ulp
+	template<typename genType>
+	GLM_FUNC_DECL genType next_float(genType x, int ULPs);
+
+	/// Return the value(s) ULP distance before the input value(s).
+	///
+	/// @tparam genType A floating-point scalar type.
+	///
+	/// @see ext_scalar_ulp
+	template<typename genType>
+	GLM_FUNC_DECL genType prev_float(genType x, int ULPs);
+
+	/// Return the distance in the number of ULP between 2 single-precision floating-point scalars.
+	///
+	/// @see ext_scalar_ulp
+	GLM_FUNC_DECL int float_distance(float x, float y);
+
+	/// Return the distance in the number of ULP between 2 double-precision floating-point scalars.
+	///
+	/// @see ext_scalar_ulp
+	GLM_FUNC_DECL int64 float_distance(double x, double y);
+
+	/// @}
+}//namespace glm
+
+#include "scalar_ulp.inl"
diff --git a/engine/inc/glm/ext/scalar_ulp.inl b/engine/inc/glm/ext/scalar_ulp.inl
new file mode 100644
index 00000000..8fc3759b
--- /dev/null
+++ b/engine/inc/glm/ext/scalar_ulp.inl
@@ -0,0 +1,284 @@
+/// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+///
+/// Developed at SunPro, a Sun Microsystems, Inc. business.
+/// Permission to use, copy, modify, and distribute this
+/// software is freely granted, provided that this notice
+/// is preserved.
+
+#include "../detail/type_float.hpp"
+#include "../ext/scalar_constants.hpp"
+#include <cmath>
+#include <cfloat>
+
+#if(GLM_COMPILER & GLM_COMPILER_VC)
+#	pragma warning(push)
+#	pragma warning(disable : 4127)
+#endif
+
+typedef union
+{
+	float value;
+	/* FIXME: Assumes 32 bit int.  */
+	unsigned int word;
+} ieee_float_shape_type;
+
+typedef union
+{
+	double value;
+	struct
+	{
+		int lsw;
+		int msw;
+	} parts;
+} ieee_double_shape_type;
+
+#define GLM_EXTRACT_WORDS(ix0,ix1,d)		\
+	do {									\
+		ieee_double_shape_type ew_u;		\
+		ew_u.value = (d);					\
+		(ix0) = ew_u.parts.msw;				\
+		(ix1) = ew_u.parts.lsw;				\
+	} while (0)
+
+#define GLM_GET_FLOAT_WORD(i,d)				\
+	do {									\
+		ieee_float_shape_type gf_u;			\
+		gf_u.value = (d);					\
+		(i) = gf_u.word;					\
+	} while (0)
+
+#define GLM_SET_FLOAT_WORD(d,i)				\
+	do {									\
+		ieee_float_shape_type sf_u;			\
+		sf_u.word = (i);					\
+		(d) = sf_u.value;					\
+	} while (0)
+
+#define GLM_INSERT_WORDS(d,ix0,ix1)			\
+	do {									\
+		ieee_double_shape_type iw_u;		\
+		iw_u.parts.msw = (ix0);				\
+		iw_u.parts.lsw = (ix1);				\
+		(d) = iw_u.value;					\
+	} while (0)
+
+namespace glm{
+namespace detail
+{
+	GLM_FUNC_QUALIFIER float nextafterf(float x, float y)
+	{
+		volatile float t;
+		int hx, hy, ix, iy;
+
+		GLM_GET_FLOAT_WORD(hx, x);
+		GLM_GET_FLOAT_WORD(hy, y);
+		ix = hx & 0x7fffffff;		// |x|
+		iy = hy & 0x7fffffff;		// |y|
+
+		if((ix > 0x7f800000) ||	// x is nan
+			(iy > 0x7f800000))	// y is nan
+			return x + y;
+		if(abs(y - x) <= epsilon<float>())
+			return y;		// x=y, return y
+		if(ix == 0)
+		{				// x == 0
+			GLM_SET_FLOAT_WORD(x, (hy & 0x80000000) | 1);// return +-minsubnormal
+			t = x * x;
+			if(abs(t - x) <= epsilon<float>())
+				return t;
+			else
+				return x;	// raise underflow flag
+		}
+		if(hx >= 0)
+		{						// x > 0
+			if(hx > hy)			// x > y, x -= ulp
+				hx -= 1;
+			else				// x < y, x += ulp
+				hx += 1;
+		}
+		else
+		{						// x < 0
+			if(hy >= 0 || hx > hy)	// x < y, x -= ulp
+				hx -= 1;
+			else				// x > y, x += ulp
+				hx += 1;
+		}
+		hy = hx & 0x7f800000;
+		if(hy >= 0x7f800000)
+			return x + x;  		// overflow
+		if(hy < 0x00800000)		// underflow
+		{
+			t = x * x;
+			if(abs(t - x) > epsilon<float>())
+			{					// raise underflow flag
+				GLM_SET_FLOAT_WORD(y, hx);
+				return y;
+			}
+		}
+		GLM_SET_FLOAT_WORD(x, hx);
+		return x;
+	}
+
+	GLM_FUNC_QUALIFIER double nextafter(double x, double y)
+	{
+		volatile double t;
+		int hx, hy, ix, iy;
+		unsigned int lx, ly;
+
+		GLM_EXTRACT_WORDS(hx, lx, x);
+		GLM_EXTRACT_WORDS(hy, ly, y);
+		ix = hx & 0x7fffffff;								// |x|
+		iy = hy & 0x7fffffff;								// |y|
+
+		if(((ix >= 0x7ff00000) && ((ix - 0x7ff00000) | lx) != 0) ||	// x is nan
+			((iy >= 0x7ff00000) && ((iy - 0x7ff00000) | ly) != 0))	// y is nan
+			return x + y;
+		if(abs(y - x) <= epsilon<double>())
+			return y;									// x=y, return y
+		if((ix | lx) == 0)
+		{													// x == 0
+			GLM_INSERT_WORDS(x, hy & 0x80000000, 1);		// return +-minsubnormal
+			t = x * x;
+			if(abs(t - x) <= epsilon<double>())
+				return t;
+			else
+				return x;   // raise underflow flag
+		}
+		if(hx >= 0) {                             // x > 0
+			if(hx > hy || ((hx == hy) && (lx > ly))) {    // x > y, x -= ulp
+				if(lx == 0) hx -= 1;
+				lx -= 1;
+			}
+			else {                            // x < y, x += ulp
+				lx += 1;
+				if(lx == 0) hx += 1;
+			}
+		}
+		else {                                // x < 0
+			if(hy >= 0 || hx > hy || ((hx == hy) && (lx > ly))){// x < y, x -= ulp
+				if(lx == 0) hx -= 1;
+				lx -= 1;
+			}
+			else {                            // x > y, x += ulp
+				lx += 1;
+				if(lx == 0) hx += 1;
+			}
+		}
+		hy = hx & 0x7ff00000;
+		if(hy >= 0x7ff00000)
+			return x + x;			// overflow
+		if(hy < 0x00100000)
+		{						// underflow
+			t = x * x;
+			if(abs(t - x) > epsilon<double>())
+			{					// raise underflow flag
+				GLM_INSERT_WORDS(y, hx, lx);
+				return y;
+			}
+		}
+		GLM_INSERT_WORDS(x, hx, lx);
+		return x;
+	}
+}//namespace detail
+}//namespace glm
+
+#if(GLM_COMPILER & GLM_COMPILER_VC)
+#	pragma warning(pop)
+#endif
+
+namespace glm
+{
+	template<>
+	GLM_FUNC_QUALIFIER float next_float(float x)
+	{
+#		if GLM_HAS_CXX11_STL
+			return std::nextafter(x, std::numeric_limits<float>::max());
+#		elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
+			return detail::nextafterf(x, FLT_MAX);
+#		elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
+			return __builtin_nextafterf(x, FLT_MAX);
+#		else
+			return nextafterf(x, FLT_MAX);
+#		endif
+	}
+
+	template<>
+	GLM_FUNC_QUALIFIER double next_float(double x)
+	{
+#		if GLM_HAS_CXX11_STL
+			return std::nextafter(x, std::numeric_limits<double>::max());
+#		elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
+			return detail::nextafter(x, std::numeric_limits<double>::max());
+#		elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
+			return __builtin_nextafter(x, DBL_MAX);
+#		else
+			return nextafter(x, DBL_MAX);
+#		endif
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER T next_float(T x, int ULPs)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'next_float' only accept floating-point input");
+		assert(ULPs >= 0);
+
+		T temp = x;
+		for(int i = 0; i < ULPs; ++i)
+			temp = next_float(temp);
+		return temp;
+	}
+
+	GLM_FUNC_QUALIFIER float prev_float(float x)
+	{
+#		if GLM_HAS_CXX11_STL
+			return std::nextafter(x, std::numeric_limits<float>::min());
+#		elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
+			return detail::nextafterf(x, FLT_MIN);
+#		elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
+			return __builtin_nextafterf(x, FLT_MIN);
+#		else
+			return nextafterf(x, FLT_MIN);
+#		endif
+	}
+
+	GLM_FUNC_QUALIFIER double prev_float(double x)
+	{
+#		if GLM_HAS_CXX11_STL
+			return std::nextafter(x, std::numeric_limits<double>::min());
+#		elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
+			return _nextafter(x, DBL_MIN);
+#		elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
+			return __builtin_nextafter(x, DBL_MIN);
+#		else
+			return nextafter(x, DBL_MIN);
+#		endif
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER T prev_float(T x, int ULPs)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'prev_float' only accept floating-point input");
+		assert(ULPs >= 0);
+
+		T temp = x;
+		for(int i = 0; i < ULPs; ++i)
+			temp = prev_float(temp);
+		return temp;
+	}
+
+	GLM_FUNC_QUALIFIER int float_distance(float x, float y)
+	{
+		detail::float_t<float> const a(x);
+		detail::float_t<float> const b(y);
+
+		return abs(a.i - b.i);
+	}
+
+	GLM_FUNC_QUALIFIER int64 float_distance(double x, double y)
+	{
+		detail::float_t<double> const a(x);
+		detail::float_t<double> const b(y);
+
+		return abs(a.i - b.i);
+	}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_bool1.hpp b/engine/inc/glm/ext/vector_bool1.hpp
new file mode 100644
index 00000000..002c3202
--- /dev/null
+++ b/engine/inc/glm/ext/vector_bool1.hpp
@@ -0,0 +1,30 @@
+/// @ref ext_vector_bool1
+/// @file glm/ext/vector_bool1.hpp
+///
+/// @defgroup ext_vector_bool1 GLM_EXT_vector_bool1
+/// @ingroup ext
+///
+/// Exposes bvec1 vector type.
+///
+/// Include <glm/ext/vector_bool1.hpp> to use the features of this extension.
+///
+/// @see ext_vector_bool1_precision extension.
+
+#pragma once
+
+#include "../detail/type_vec1.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_vector_bool1 extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup ext_vector_bool1
+	/// @{
+
+	/// 1 components vector of boolean.
+	typedef vec<1, bool, defaultp>		bvec1;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_bool1_precision.hpp b/engine/inc/glm/ext/vector_bool1_precision.hpp
new file mode 100644
index 00000000..e62d3cfb
--- /dev/null
+++ b/engine/inc/glm/ext/vector_bool1_precision.hpp
@@ -0,0 +1,34 @@
+/// @ref ext_vector_bool1_precision
+/// @file glm/ext/vector_bool1_precision.hpp
+///
+/// @defgroup ext_vector_bool1_precision GLM_EXT_vector_bool1_precision
+/// @ingroup ext
+///
+/// Exposes highp_bvec1, mediump_bvec1 and lowp_bvec1 types.
+///
+/// Include <glm/ext/vector_bool1_precision.hpp> to use the features of this extension.
+
+#pragma once
+
+#include "../detail/type_vec1.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_vector_bool1_precision extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup ext_vector_bool1_precision
+	/// @{
+
+	/// 1 component vector of bool values.
+	typedef vec<1, bool, highp>			highp_bvec1;
+
+	/// 1 component vector of bool values.
+	typedef vec<1, bool, mediump>		mediump_bvec1;
+
+	/// 1 component vector of bool values.
+	typedef vec<1, bool, lowp>			lowp_bvec1;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_bool2.hpp b/engine/inc/glm/ext/vector_bool2.hpp
new file mode 100644
index 00000000..52288b75
--- /dev/null
+++ b/engine/inc/glm/ext/vector_bool2.hpp
@@ -0,0 +1,18 @@
+/// @ref core
+/// @file glm/ext/vector_bool2.hpp
+
+#pragma once
+#include "../detail/type_vec2.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_vector
+	/// @{
+
+	/// 2 components vector of boolean.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	typedef vec<2, bool, defaultp>		bvec2;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_bool2_precision.hpp b/engine/inc/glm/ext/vector_bool2_precision.hpp
new file mode 100644
index 00000000..43709332
--- /dev/null
+++ b/engine/inc/glm/ext/vector_bool2_precision.hpp
@@ -0,0 +1,31 @@
+/// @ref core
+/// @file glm/ext/vector_bool2_precision.hpp
+
+#pragma once
+#include "../detail/type_vec2.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_vector_precision
+	/// @{
+
+	/// 2 components vector of high qualifier bool numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<2, bool, highp>		highp_bvec2;
+
+	/// 2 components vector of medium qualifier bool numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<2, bool, mediump>	mediump_bvec2;
+
+	/// 2 components vector of low qualifier bool numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<2, bool, lowp>		lowp_bvec2;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_bool3.hpp b/engine/inc/glm/ext/vector_bool3.hpp
new file mode 100644
index 00000000..90a0b7ea
--- /dev/null
+++ b/engine/inc/glm/ext/vector_bool3.hpp
@@ -0,0 +1,18 @@
+/// @ref core
+/// @file glm/ext/vector_bool3.hpp
+
+#pragma once
+#include "../detail/type_vec3.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_vector
+	/// @{
+
+	/// 3 components vector of boolean.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	typedef vec<3, bool, defaultp>		bvec3;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_bool3_precision.hpp b/engine/inc/glm/ext/vector_bool3_precision.hpp
new file mode 100644
index 00000000..89cd2d32
--- /dev/null
+++ b/engine/inc/glm/ext/vector_bool3_precision.hpp
@@ -0,0 +1,31 @@
+/// @ref core
+/// @file glm/ext/vector_bool3_precision.hpp
+
+#pragma once
+#include "../detail/type_vec3.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_vector_precision
+	/// @{
+
+	/// 3 components vector of high qualifier bool numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<3, bool, highp>		highp_bvec3;
+
+	/// 3 components vector of medium qualifier bool numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<3, bool, mediump>	mediump_bvec3;
+
+	/// 3 components vector of low qualifier bool numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<3, bool, lowp>		lowp_bvec3;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_bool4.hpp b/engine/inc/glm/ext/vector_bool4.hpp
new file mode 100644
index 00000000..18aa71bd
--- /dev/null
+++ b/engine/inc/glm/ext/vector_bool4.hpp
@@ -0,0 +1,18 @@
+/// @ref core
+/// @file glm/ext/vector_bool4.hpp
+
+#pragma once
+#include "../detail/type_vec4.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_vector
+	/// @{
+
+	/// 4 components vector of boolean.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	typedef vec<4, bool, defaultp>		bvec4;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_bool4_precision.hpp b/engine/inc/glm/ext/vector_bool4_precision.hpp
new file mode 100644
index 00000000..79786e54
--- /dev/null
+++ b/engine/inc/glm/ext/vector_bool4_precision.hpp
@@ -0,0 +1,31 @@
+/// @ref core
+/// @file glm/ext/vector_bool4_precision.hpp
+
+#pragma once
+#include "../detail/type_vec4.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_vector_precision
+	/// @{
+
+	/// 4 components vector of high qualifier bool numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<4, bool, highp>		highp_bvec4;
+
+	/// 4 components vector of medium qualifier bool numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<4, bool, mediump>	mediump_bvec4;
+
+	/// 4 components vector of low qualifier bool numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<4, bool, lowp>		lowp_bvec4;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_common.hpp b/engine/inc/glm/ext/vector_common.hpp
new file mode 100644
index 00000000..324fe1c7
--- /dev/null
+++ b/engine/inc/glm/ext/vector_common.hpp
@@ -0,0 +1,144 @@
+/// @ref ext_vector_common
+/// @file glm/ext/vector_common.hpp
+///
+/// @defgroup ext_vector_common GLM_EXT_vector_common
+/// @ingroup ext
+///
+/// Exposes min and max functions for 3 to 4 vector parameters.
+///
+/// Include <glm/ext/vector_common.hpp> to use the features of this extension.
+///
+/// @see core_common
+/// @see ext_scalar_common
+
+#pragma once
+
+// Dependency:
+#include "../ext/scalar_common.hpp"
+#include "../common.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_vector_common extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup ext_vector_common
+	/// @{
+
+	/// Return the minimum component-wise values of 3 inputs
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> min(vec<L, T, Q> const& a, vec<L, T, Q> const& b, vec<L, T, Q> const& c);
+
+	/// Return the minimum component-wise values of 4 inputs
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> min(vec<L, T, Q> const& a, vec<L, T, Q> const& b, vec<L, T, Q> const& c, vec<L, T, Q> const& d);
+
+	/// Return the maximum component-wise values of 3 inputs
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> max(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, T, Q> const& z);
+
+	/// Return the maximum component-wise values of 4 inputs
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> max( vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, T, Q> const& z, vec<L, T, Q> const& w);
+
+	/// Returns y if y < x; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmin">std::fmin documentation</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> fmin(vec<L, T, Q> const& x, T y);
+
+	/// Returns y if y < x; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmin">std::fmin documentation</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> fmin(vec<L, T, Q> const& x, vec<L, T, Q> const& y);
+
+	/// Returns y if y < x; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmin">std::fmin documentation</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> fmin(vec<L, T, Q> const& a, vec<L, T, Q> const& b, vec<L, T, Q> const& c);
+
+	/// Returns y if y < x; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmin">std::fmin documentation</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> fmin(vec<L, T, Q> const& a, vec<L, T, Q> const& b, vec<L, T, Q> const& c, vec<L, T, Q> const& d);
+
+	/// Returns y if x < y; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmax">std::fmax documentation</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> fmax(vec<L, T, Q> const& a, T b);
+
+	/// Returns y if x < y; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmax">std::fmax documentation</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> fmax(vec<L, T, Q> const& a, vec<L, T, Q> const& b);
+
+	/// Returns y if x < y; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmax">std::fmax documentation</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> fmax(vec<L, T, Q> const& a, vec<L, T, Q> const& b, vec<L, T, Q> const& c);
+
+	/// Returns y if x < y; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmax">std::fmax documentation</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> fmax(vec<L, T, Q> const& a, vec<L, T, Q> const& b, vec<L, T, Q> const& c, vec<L, T, Q> const& d);
+
+	/// @}
+}//namespace glm
+
+#include "vector_common.inl"
diff --git a/engine/inc/glm/ext/vector_common.inl b/engine/inc/glm/ext/vector_common.inl
new file mode 100644
index 00000000..71f38093
--- /dev/null
+++ b/engine/inc/glm/ext/vector_common.inl
@@ -0,0 +1,88 @@
+#include "../detail/_vectorize.hpp"
+
+namespace glm
+{
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> min(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, T, Q> const& z)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'min' only accept floating-point or integer inputs");
+		return glm::min(glm::min(x, y), z);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> min(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, T, Q> const& z, vec<L, T, Q> const& w)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'min' only accept floating-point or integer inputs");
+		return glm::min(glm::min(x, y), glm::min(z, w));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> max(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, T, Q> const& z)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'max' only accept floating-point or integer inputs");
+		return glm::max(glm::max(x, y), z);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> max(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, T, Q> const& z, vec<L, T, Q> const& w)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'max' only accept floating-point or integer inputs");
+		return glm::max(glm::max(x, y), glm::max(z, w));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fmin(vec<L, T, Q> const& a, T b)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'fmin' only accept floating-point inputs");
+		return detail::functor2<vec, L, T, Q>::call(fmin, a, vec<L, T, Q>(b));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fmin(vec<L, T, Q> const& a, vec<L, T, Q> const& b)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'fmin' only accept floating-point inputs");
+		return detail::functor2<vec, L, T, Q>::call(fmin, a, b);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fmin(vec<L, T, Q> const& a, vec<L, T, Q> const& b, vec<L, T, Q> const& c)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'fmin' only accept floating-point inputs");
+		return fmin(fmin(a, b), c);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fmin(vec<L, T, Q> const& a, vec<L, T, Q> const& b, vec<L, T, Q> const& c, vec<L, T, Q> const& d)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'fmin' only accept floating-point inputs");
+		return fmin(fmin(a, b), fmin(c, d));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fmax(vec<L, T, Q> const& a, T b)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'fmax' only accept floating-point inputs");
+		return detail::functor2<vec, L, T, Q>::call(fmax, a, vec<L, T, Q>(b));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fmax(vec<L, T, Q> const& a, vec<L, T, Q> const& b)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'fmax' only accept floating-point inputs");
+		return detail::functor2<vec, L, T, Q>::call(fmax, a, b);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fmax(vec<L, T, Q> const& a, vec<L, T, Q> const& b, vec<L, T, Q> const& c)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'fmax' only accept floating-point inputs");
+		return fmax(fmax(a, b), c);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fmax(vec<L, T, Q> const& a, vec<L, T, Q> const& b, vec<L, T, Q> const& c, vec<L, T, Q> const& d)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'fmax' only accept floating-point inputs");
+		return fmax(fmax(a, b), fmax(c, d));
+	}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_double1.hpp b/engine/inc/glm/ext/vector_double1.hpp
new file mode 100644
index 00000000..ef12def4
--- /dev/null
+++ b/engine/inc/glm/ext/vector_double1.hpp
@@ -0,0 +1,31 @@
+/// @ref ext_vector_double1
+/// @file glm/ext/vector_double1.hpp
+///
+/// @defgroup ext_vector_double1 GLM_EXT_vector_double1
+/// @ingroup ext
+///
+/// Exposes double-precision floating point vector type with one component.
+///
+/// Include <glm/ext/vector_double1.hpp> to use the features of this extension.
+///
+/// @see ext_vector_double1_precision extension.
+/// @see ext_vector_float1 extension.
+
+#pragma once
+
+#include "../detail/type_vec1.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_vector_dvec1 extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup ext_vector_double1
+	/// @{
+
+	/// 1 components vector of double-precision floating-point numbers.
+	typedef vec<1, double, defaultp>		dvec1;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_double1_precision.hpp b/engine/inc/glm/ext/vector_double1_precision.hpp
new file mode 100644
index 00000000..1d471959
--- /dev/null
+++ b/engine/inc/glm/ext/vector_double1_precision.hpp
@@ -0,0 +1,36 @@
+/// @ref ext_vector_double1_precision
+/// @file glm/ext/vector_double1_precision.hpp
+///
+/// @defgroup ext_vector_double1_precision GLM_EXT_vector_double1_precision
+/// @ingroup ext
+///
+/// Exposes highp_dvec1, mediump_dvec1 and lowp_dvec1 types.
+///
+/// Include <glm/ext/vector_double1_precision.hpp> to use the features of this extension.
+///
+/// @see ext_vector_double1
+
+#pragma once
+
+#include "../detail/type_vec1.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_vector_double1_precision extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup ext_vector_double1_precision
+	/// @{
+
+	/// 1 component vector of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef vec<1, double, highp>		highp_dvec1;
+
+	/// 1 component vector of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef vec<1, double, mediump>		mediump_dvec1;
+
+	/// 1 component vector of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef vec<1, double, lowp>		lowp_dvec1;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_double2.hpp b/engine/inc/glm/ext/vector_double2.hpp
new file mode 100644
index 00000000..60e35775
--- /dev/null
+++ b/engine/inc/glm/ext/vector_double2.hpp
@@ -0,0 +1,18 @@
+/// @ref core
+/// @file glm/ext/vector_double2.hpp
+
+#pragma once
+#include "../detail/type_vec2.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_vector
+	/// @{
+
+	/// 2 components vector of double-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	typedef vec<2, double, defaultp>		dvec2;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_double2_precision.hpp b/engine/inc/glm/ext/vector_double2_precision.hpp
new file mode 100644
index 00000000..fa53940f
--- /dev/null
+++ b/engine/inc/glm/ext/vector_double2_precision.hpp
@@ -0,0 +1,31 @@
+/// @ref core
+/// @file glm/ext/vector_double2_precision.hpp
+
+#pragma once
+#include "../detail/type_vec2.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_vector_precision
+	/// @{
+
+	/// 2 components vector of high double-qualifier floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<2, double, highp>		highp_dvec2;
+
+	/// 2 components vector of medium double-qualifier floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<2, double, mediump>		mediump_dvec2;
+
+	/// 2 components vector of low double-qualifier floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<2, double, lowp>		lowp_dvec2;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_double3.hpp b/engine/inc/glm/ext/vector_double3.hpp
new file mode 100644
index 00000000..6dfe4c67
--- /dev/null
+++ b/engine/inc/glm/ext/vector_double3.hpp
@@ -0,0 +1,18 @@
+/// @ref core
+/// @file glm/ext/vector_double3.hpp
+
+#pragma once
+#include "../detail/type_vec3.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_vector
+	/// @{
+
+	/// 3 components vector of double-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	typedef vec<3, double, defaultp>		dvec3;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_double3_precision.hpp b/engine/inc/glm/ext/vector_double3_precision.hpp
new file mode 100644
index 00000000..a8cfa37a
--- /dev/null
+++ b/engine/inc/glm/ext/vector_double3_precision.hpp
@@ -0,0 +1,34 @@
+/// @ref core
+/// @file glm/ext/vector_double3_precision.hpp
+
+#pragma once
+#include "../detail/type_vec3.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_vector_precision
+	/// @{
+
+	/// 3 components vector of high double-qualifier floating-point numbers.
+	/// There is no guarantee on the actual qualifier.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<3, double, highp>		highp_dvec3;
+
+	/// 3 components vector of medium double-qualifier floating-point numbers.
+	/// There is no guarantee on the actual qualifier.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<3, double, mediump>		mediump_dvec3;
+
+	/// 3 components vector of low double-qualifier floating-point numbers.
+	/// There is no guarantee on the actual qualifier.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<3, double, lowp>		lowp_dvec3;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_double4.hpp b/engine/inc/glm/ext/vector_double4.hpp
new file mode 100644
index 00000000..87f225f6
--- /dev/null
+++ b/engine/inc/glm/ext/vector_double4.hpp
@@ -0,0 +1,18 @@
+/// @ref core
+/// @file glm/ext/vector_double4.hpp
+
+#pragma once
+#include "../detail/type_vec4.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_vector
+	/// @{
+
+	/// 4 components vector of double-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	typedef vec<4, double, defaultp>		dvec4;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_double4_precision.hpp b/engine/inc/glm/ext/vector_double4_precision.hpp
new file mode 100644
index 00000000..09cafa1e
--- /dev/null
+++ b/engine/inc/glm/ext/vector_double4_precision.hpp
@@ -0,0 +1,35 @@
+/// @ref core
+/// @file glm/ext/vector_double4_precision.hpp
+
+#pragma once
+#include "../detail/setup.hpp"
+#include "../detail/type_vec4.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_vector_precision
+	/// @{
+
+	/// 4 components vector of high double-qualifier floating-point numbers.
+	/// There is no guarantee on the actual qualifier.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<4, double, highp>		highp_dvec4;
+
+	/// 4 components vector of medium double-qualifier floating-point numbers.
+	/// There is no guarantee on the actual qualifier.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<4, double, mediump>		mediump_dvec4;
+
+	/// 4 components vector of low double-qualifier floating-point numbers.
+	/// There is no guarantee on the actual qualifier.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<4, double, lowp>		lowp_dvec4;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_float1.hpp b/engine/inc/glm/ext/vector_float1.hpp
new file mode 100644
index 00000000..28acc2c9
--- /dev/null
+++ b/engine/inc/glm/ext/vector_float1.hpp
@@ -0,0 +1,31 @@
+/// @ref ext_vector_float1
+/// @file glm/ext/vector_float1.hpp
+///
+/// @defgroup ext_vector_float1 GLM_EXT_vector_float1
+/// @ingroup ext
+///
+/// Exposes single-precision floating point vector type with one component.
+///
+/// Include <glm/ext/vector_float1.hpp> to use the features of this extension.
+///
+/// @see ext_vector_float1_precision extension.
+/// @see ext_vector_double1 extension.
+
+#pragma once
+
+#include "../detail/type_vec1.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_vector_float1 extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup ext_vector_float1
+	/// @{
+
+	/// 1 components vector of single-precision floating-point numbers.
+	typedef vec<1, float, defaultp>		vec1;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_float1_precision.hpp b/engine/inc/glm/ext/vector_float1_precision.hpp
new file mode 100644
index 00000000..6e8dad8d
--- /dev/null
+++ b/engine/inc/glm/ext/vector_float1_precision.hpp
@@ -0,0 +1,36 @@
+/// @ref ext_vector_float1_precision
+/// @file glm/ext/vector_float1_precision.hpp
+///
+/// @defgroup ext_vector_float1_precision GLM_EXT_vector_float1_precision
+/// @ingroup ext
+///
+/// Exposes highp_vec1, mediump_vec1 and lowp_vec1 types.
+///
+/// Include <glm/ext/vector_float1_precision.hpp> to use the features of this extension.
+///
+/// @see ext_vector_float1 extension.
+
+#pragma once
+
+#include "../detail/type_vec1.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_vector_float1_precision extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup ext_vector_float1_precision
+	/// @{
+
+	/// 1 component vector of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef vec<1, float, highp>		highp_vec1;
+
+	/// 1 component vector of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef vec<1, float, mediump>		mediump_vec1;
+
+	/// 1 component vector of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef vec<1, float, lowp>			lowp_vec1;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_float2.hpp b/engine/inc/glm/ext/vector_float2.hpp
new file mode 100644
index 00000000..d31545dc
--- /dev/null
+++ b/engine/inc/glm/ext/vector_float2.hpp
@@ -0,0 +1,18 @@
+/// @ref core
+/// @file glm/ext/vector_float2.hpp
+
+#pragma once
+#include "../detail/type_vec2.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_vector
+	/// @{
+
+	/// 2 components vector of single-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	typedef vec<2, float, defaultp>	vec2;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_float2_precision.hpp b/engine/inc/glm/ext/vector_float2_precision.hpp
new file mode 100644
index 00000000..23c0820d
--- /dev/null
+++ b/engine/inc/glm/ext/vector_float2_precision.hpp
@@ -0,0 +1,31 @@
+/// @ref core
+/// @file glm/ext/vector_float2_precision.hpp
+
+#pragma once
+#include "../detail/type_vec2.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_vector_precision
+	/// @{
+
+	/// 2 components vector of high single-qualifier floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<2, float, highp>		highp_vec2;
+
+	/// 2 components vector of medium single-qualifier floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<2, float, mediump>		mediump_vec2;
+
+	/// 2 components vector of low single-qualifier floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<2, float, lowp>			lowp_vec2;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_float3.hpp b/engine/inc/glm/ext/vector_float3.hpp
new file mode 100644
index 00000000..cd79a620
--- /dev/null
+++ b/engine/inc/glm/ext/vector_float3.hpp
@@ -0,0 +1,18 @@
+/// @ref core
+/// @file glm/ext/vector_float3.hpp
+
+#pragma once
+#include "../detail/type_vec3.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_vector
+	/// @{
+
+	/// 3 components vector of single-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	typedef vec<3, float, defaultp>		vec3;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_float3_precision.hpp b/engine/inc/glm/ext/vector_float3_precision.hpp
new file mode 100644
index 00000000..be640b53
--- /dev/null
+++ b/engine/inc/glm/ext/vector_float3_precision.hpp
@@ -0,0 +1,31 @@
+/// @ref core
+/// @file glm/ext/vector_float3_precision.hpp
+
+#pragma once
+#include "../detail/type_vec3.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_vector_precision
+	/// @{
+
+	/// 3 components vector of high single-qualifier floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<3, float, highp>		highp_vec3;
+
+	/// 3 components vector of medium single-qualifier floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<3, float, mediump>		mediump_vec3;
+
+	/// 3 components vector of low single-qualifier floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<3, float, lowp>			lowp_vec3;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_float4.hpp b/engine/inc/glm/ext/vector_float4.hpp
new file mode 100644
index 00000000..d84adcc2
--- /dev/null
+++ b/engine/inc/glm/ext/vector_float4.hpp
@@ -0,0 +1,18 @@
+/// @ref core
+/// @file glm/ext/vector_float4.hpp
+
+#pragma once
+#include "../detail/type_vec4.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_vector
+	/// @{
+
+	/// 4 components vector of single-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	typedef vec<4, float, defaultp>		vec4;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_float4_precision.hpp b/engine/inc/glm/ext/vector_float4_precision.hpp
new file mode 100644
index 00000000..aede8388
--- /dev/null
+++ b/engine/inc/glm/ext/vector_float4_precision.hpp
@@ -0,0 +1,31 @@
+/// @ref core
+/// @file glm/ext/vector_float4_precision.hpp
+
+#pragma once
+#include "../detail/type_vec4.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_vector_precision
+	/// @{
+
+	/// 4 components vector of high single-qualifier floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<4, float, highp>		highp_vec4;
+
+	/// 4 components vector of medium single-qualifier floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<4, float, mediump>		mediump_vec4;
+
+	/// 4 components vector of low single-qualifier floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<4, float, lowp>			lowp_vec4;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_int1.hpp b/engine/inc/glm/ext/vector_int1.hpp
new file mode 100644
index 00000000..dc860389
--- /dev/null
+++ b/engine/inc/glm/ext/vector_int1.hpp
@@ -0,0 +1,32 @@
+/// @ref ext_vector_int1
+/// @file glm/ext/vector_int1.hpp
+///
+/// @defgroup ext_vector_int1 GLM_EXT_vector_int1
+/// @ingroup ext
+///
+/// Exposes ivec1 vector type.
+///
+/// Include <glm/ext/vector_int1.hpp> to use the features of this extension.
+///
+/// @see ext_vector_uint1 extension.
+/// @see ext_vector_int1_precision extension.
+
+#pragma once
+
+#include "../detail/type_vec1.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_vector_int1 extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup ext_vector_int1
+	/// @{
+
+	/// 1 component vector of signed integer numbers.
+	typedef vec<1, int, defaultp>			ivec1;
+
+	/// @}
+}//namespace glm
+
diff --git a/engine/inc/glm/ext/vector_int1_precision.hpp b/engine/inc/glm/ext/vector_int1_precision.hpp
new file mode 100644
index 00000000..3323954b
--- /dev/null
+++ b/engine/inc/glm/ext/vector_int1_precision.hpp
@@ -0,0 +1,34 @@
+/// @ref ext_vector_int1_precision
+/// @file glm/ext/vector_int1_precision.hpp
+///
+/// @defgroup ext_vector_int1_precision GLM_EXT_vector_int1_precision
+/// @ingroup ext
+///
+/// Exposes highp_ivec1, mediump_ivec1 and lowp_ivec1 types.
+///
+/// Include <glm/ext/vector_int1_precision.hpp> to use the features of this extension.
+
+#pragma once
+
+#include "../detail/type_vec1.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_vector_int1_precision extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup ext_vector_int1_precision
+	/// @{
+
+	/// 1 component vector of signed integer values.
+	typedef vec<1, int, highp>			highp_ivec1;
+
+	/// 1 component vector of signed integer values.
+	typedef vec<1, int, mediump>		mediump_ivec1;
+
+	/// 1 component vector of signed integer values.
+	typedef vec<1, int, lowp>			lowp_ivec1;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_int2.hpp b/engine/inc/glm/ext/vector_int2.hpp
new file mode 100644
index 00000000..aef803e9
--- /dev/null
+++ b/engine/inc/glm/ext/vector_int2.hpp
@@ -0,0 +1,18 @@
+/// @ref core
+/// @file glm/ext/vector_int2.hpp
+
+#pragma once
+#include "../detail/type_vec2.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_vector
+	/// @{
+
+	/// 2 components vector of signed integer numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	typedef vec<2, int, defaultp>		ivec2;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_int2_precision.hpp b/engine/inc/glm/ext/vector_int2_precision.hpp
new file mode 100644
index 00000000..97315fc3
--- /dev/null
+++ b/engine/inc/glm/ext/vector_int2_precision.hpp
@@ -0,0 +1,31 @@
+/// @ref core
+/// @file glm/ext/vector_int2_precision.hpp
+
+#pragma once
+#include "../detail/type_vec2.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_vector_precision
+	/// @{
+
+	/// 2 components vector of high qualifier signed integer numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<2, int, highp>		highp_ivec2;
+
+	/// 2 components vector of medium qualifier signed integer numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<2, int, mediump>	mediump_ivec2;
+
+	/// 2 components vector of low qualifier signed integer numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<2, int, lowp>		lowp_ivec2;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_int3.hpp b/engine/inc/glm/ext/vector_int3.hpp
new file mode 100644
index 00000000..4767e61e
--- /dev/null
+++ b/engine/inc/glm/ext/vector_int3.hpp
@@ -0,0 +1,18 @@
+/// @ref core
+/// @file glm/ext/vector_int3.hpp
+
+#pragma once
+#include "../detail/type_vec3.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_vector
+	/// @{
+
+	/// 3 components vector of signed integer numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	typedef vec<3, int, defaultp>		ivec3;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_int3_precision.hpp b/engine/inc/glm/ext/vector_int3_precision.hpp
new file mode 100644
index 00000000..2cd3f5ff
--- /dev/null
+++ b/engine/inc/glm/ext/vector_int3_precision.hpp
@@ -0,0 +1,31 @@
+/// @ref core
+/// @file glm/ext/vector_int3_precision.hpp
+
+#pragma once
+#include "../detail/type_vec3.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_vector_precision
+	/// @{
+
+	/// 3 components vector of high qualifier signed integer numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<3, int, highp>		highp_ivec3;
+
+	/// 3 components vector of medium qualifier signed integer numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<3, int, mediump>	mediump_ivec3;
+
+	/// 3 components vector of low qualifier signed integer numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<3, int, lowp>		lowp_ivec3;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_int4.hpp b/engine/inc/glm/ext/vector_int4.hpp
new file mode 100644
index 00000000..bb23adf7
--- /dev/null
+++ b/engine/inc/glm/ext/vector_int4.hpp
@@ -0,0 +1,18 @@
+/// @ref core
+/// @file glm/ext/vector_int4.hpp
+
+#pragma once
+#include "../detail/type_vec4.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_vector
+	/// @{
+
+	/// 4 components vector of signed integer numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	typedef vec<4, int, defaultp>		ivec4;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_int4_precision.hpp b/engine/inc/glm/ext/vector_int4_precision.hpp
new file mode 100644
index 00000000..4fcd7916
--- /dev/null
+++ b/engine/inc/glm/ext/vector_int4_precision.hpp
@@ -0,0 +1,31 @@
+/// @ref core
+/// @file glm/ext/vector_int4_precision.hpp
+
+#pragma once
+#include "../detail/type_vec4.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_vector_precision
+	/// @{
+
+	/// 4 components vector of high qualifier signed integer numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<4, int, highp>		highp_ivec4;
+
+	/// 4 components vector of medium qualifier signed integer numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<4, int, mediump>	mediump_ivec4;
+
+	/// 4 components vector of low qualifier signed integer numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<4, int, lowp>		lowp_ivec4;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_relational.hpp b/engine/inc/glm/ext/vector_relational.hpp
new file mode 100644
index 00000000..a556bdfa
--- /dev/null
+++ b/engine/inc/glm/ext/vector_relational.hpp
@@ -0,0 +1,104 @@
+/// @ref ext_vector_relational
+/// @file glm/ext/vector_relational.hpp
+///
+/// @defgroup ext_vector_relational GLM_EXT_vector_relational
+/// @ingroup ext
+///
+/// Exposes comparison functions for vector types that take a user defined epsilon values.
+///
+/// Include <glm/ext/vector_relational.hpp> to use the features of this extension.
+///
+/// @see core_vector_relational
+/// @see ext_scalar_relational
+/// @see ext_matrix_relational
+
+#pragma once
+
+// Dependencies
+#include "../detail/qualifier.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_vector_relational extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup ext_vector_relational
+	/// @{
+
+	/// Returns the component-wise comparison of |x - y| < epsilon.
+	/// True if this expression is satisfied.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, bool, Q> equal(vec<L, T, Q> const& x, vec<L, T, Q> const& y, T epsilon);
+
+	/// Returns the component-wise comparison of |x - y| < epsilon.
+	/// True if this expression is satisfied.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, bool, Q> equal(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, T, Q> const& epsilon);
+
+	/// Returns the component-wise comparison of |x - y| >= epsilon.
+	/// True if this expression is not satisfied.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, bool, Q> notEqual(vec<L, T, Q> const& x, vec<L, T, Q> const& y, T epsilon);
+
+	/// Returns the component-wise comparison of |x - y| >= epsilon.
+	/// True if this expression is not satisfied.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, bool, Q> notEqual(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, T, Q> const& epsilon);
+
+	/// Returns the component-wise comparison between two vectors in term of ULPs.
+	/// True if this expression is satisfied.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point
+	/// @tparam Q Value from qualifier enum
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, bool, Q> equal(vec<L, T, Q> const& x, vec<L, T, Q> const& y, int ULPs);
+
+	/// Returns the component-wise comparison between two vectors in term of ULPs.
+	/// True if this expression is satisfied.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point
+	/// @tparam Q Value from qualifier enum
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, bool, Q> equal(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, int, Q> const& ULPs);
+
+	/// Returns the component-wise comparison between two vectors in term of ULPs.
+	/// True if this expression is not satisfied.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point
+	/// @tparam Q Value from qualifier enum
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, bool, Q> notEqual(vec<L, T, Q> const& x, vec<L, T, Q> const& y, int ULPs);
+
+	/// Returns the component-wise comparison between two vectors in term of ULPs.
+	/// True if this expression is not satisfied.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point
+	/// @tparam Q Value from qualifier enum
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, bool, Q> notEqual(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, int, Q> const& ULPs);
+
+	/// @}
+}//namespace glm
+
+#include "vector_relational.inl"
diff --git a/engine/inc/glm/ext/vector_relational.inl b/engine/inc/glm/ext/vector_relational.inl
new file mode 100644
index 00000000..7a39ab50
--- /dev/null
+++ b/engine/inc/glm/ext/vector_relational.inl
@@ -0,0 +1,75 @@
+#include "../vector_relational.hpp"
+#include "../common.hpp"
+#include "../detail/qualifier.hpp"
+#include "../detail/type_float.hpp"
+
+namespace glm
+{
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, bool, Q> equal(vec<L, T, Q> const& x, vec<L, T, Q> const& y, T Epsilon)
+	{
+		return equal(x, y, vec<L, T, Q>(Epsilon));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, bool, Q> equal(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, T, Q> const& Epsilon)
+	{
+		return lessThanEqual(abs(x - y), Epsilon);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, bool, Q> notEqual(vec<L, T, Q> const& x, vec<L, T, Q> const& y, T Epsilon)
+	{
+		return notEqual(x, y, vec<L, T, Q>(Epsilon));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, bool, Q> notEqual(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, T, Q> const& Epsilon)
+	{
+		return greaterThan(abs(x - y), Epsilon);
+	}
+
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, bool, Q> equal(vec<L, T, Q> const& x, vec<L, T, Q> const& y, int MaxULPs)
+	{
+		return equal(x, y, vec<L, int, Q>(MaxULPs));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, bool, Q> equal(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, int, Q> const& MaxULPs)
+	{
+		vec<L, bool, Q> Result(false);
+		for(length_t i = 0; i < L; ++i)
+		{
+			detail::float_t<T> const a(x[i]);
+			detail::float_t<T> const b(y[i]);
+
+			// Different signs means they do not match.
+			if(a.negative() != b.negative())
+			{
+				// Check for equality to make sure +0==-0
+				Result[i] = a.mantissa() == b.mantissa() && a.exponent() == b.exponent();
+			}
+			else
+			{
+				// Find the difference in ULPs.
+				typename detail::float_t<T>::int_type const DiffULPs = abs(a.i - b.i);
+				Result[i] = DiffULPs <= MaxULPs[i];
+			}
+		}
+		return Result;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, bool, Q> notEqual(vec<L, T, Q> const& x, vec<L, T, Q> const& y, int MaxULPs)
+	{
+		return notEqual(x, y, vec<L, int, Q>(MaxULPs));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, bool, Q> notEqual(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, int, Q> const& MaxULPs)
+	{
+		return not_(equal(x, y, MaxULPs));
+	}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_uint1.hpp b/engine/inc/glm/ext/vector_uint1.hpp
new file mode 100644
index 00000000..eb8a7049
--- /dev/null
+++ b/engine/inc/glm/ext/vector_uint1.hpp
@@ -0,0 +1,32 @@
+/// @ref ext_vector_uint1
+/// @file glm/ext/vector_uint1.hpp
+///
+/// @defgroup ext_vector_uint1 GLM_EXT_vector_uint1
+/// @ingroup ext
+///
+/// Exposes uvec1 vector type.
+///
+/// Include <glm/ext/vector_uvec1.hpp> to use the features of this extension.
+///
+/// @see ext_vector_int1 extension.
+/// @see ext_vector_uint1_precision extension.
+
+#pragma once
+
+#include "../detail/type_vec1.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_vector_uint1 extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup ext_vector_uint1
+	/// @{
+
+	/// 1 component vector of unsigned integer numbers.
+	typedef vec<1, unsigned int, defaultp>			uvec1;
+
+	/// @}
+}//namespace glm
+
diff --git a/engine/inc/glm/ext/vector_uint1_precision.hpp b/engine/inc/glm/ext/vector_uint1_precision.hpp
new file mode 100644
index 00000000..30daa5b6
--- /dev/null
+++ b/engine/inc/glm/ext/vector_uint1_precision.hpp
@@ -0,0 +1,40 @@
+/// @ref ext_vector_uint1_precision
+/// @file glm/ext/vector_uint1_precision.hpp
+///
+/// @defgroup ext_vector_uint1_precision GLM_EXT_vector_uint1_precision
+/// @ingroup ext
+///
+/// Exposes highp_uvec1, mediump_uvec1 and lowp_uvec1 types.
+///
+/// Include <glm/ext/vector_uint1_precision.hpp> to use the features of this extension.
+
+#pragma once
+
+#include "../detail/type_vec1.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_vector_uint1_precision extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup ext_vector_uint1_precision
+	/// @{
+
+	/// 1 component vector of unsigned integer values.
+	///
+	/// @see ext_vector_uint1_precision
+	typedef vec<1, unsigned int, highp>			highp_uvec1;
+
+	/// 1 component vector of unsigned integer values.
+	///
+	/// @see ext_vector_uint1_precision
+	typedef vec<1, unsigned int, mediump>		mediump_uvec1;
+
+	/// 1 component vector of unsigned integer values.
+	///
+	/// @see ext_vector_uint1_precision
+	typedef vec<1, unsigned int, lowp>			lowp_uvec1;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_uint2.hpp b/engine/inc/glm/ext/vector_uint2.hpp
new file mode 100644
index 00000000..03c00f5f
--- /dev/null
+++ b/engine/inc/glm/ext/vector_uint2.hpp
@@ -0,0 +1,18 @@
+/// @ref core
+/// @file glm/ext/vector_uint2.hpp
+
+#pragma once
+#include "../detail/type_vec2.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_vector
+	/// @{
+
+	/// 2 components vector of unsigned integer numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	typedef vec<2, unsigned int, defaultp>		uvec2;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_uint2_precision.hpp b/engine/inc/glm/ext/vector_uint2_precision.hpp
new file mode 100644
index 00000000..2ba7b0d4
--- /dev/null
+++ b/engine/inc/glm/ext/vector_uint2_precision.hpp
@@ -0,0 +1,31 @@
+/// @ref core
+/// @file glm/ext/vector_uint2_precision.hpp
+
+#pragma once
+#include "../detail/type_vec2.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_vector_precision
+	/// @{
+
+	/// 2 components vector of high qualifier unsigned integer numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<2, unsigned int, highp>		highp_uvec2;
+
+	/// 2 components vector of medium qualifier unsigned integer numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<2, unsigned int, mediump>	mediump_uvec2;
+
+	/// 2 components vector of low qualifier unsigned integer numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<2, unsigned int, lowp>		lowp_uvec2;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_uint3.hpp b/engine/inc/glm/ext/vector_uint3.hpp
new file mode 100644
index 00000000..f5b41c40
--- /dev/null
+++ b/engine/inc/glm/ext/vector_uint3.hpp
@@ -0,0 +1,18 @@
+/// @ref core
+/// @file glm/ext/vector_uint3.hpp
+
+#pragma once
+#include "../detail/type_vec3.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_vector
+	/// @{
+
+	/// 3 components vector of unsigned integer numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	typedef vec<3, unsigned int, defaultp>		uvec3;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_uint3_precision.hpp b/engine/inc/glm/ext/vector_uint3_precision.hpp
new file mode 100644
index 00000000..125191c7
--- /dev/null
+++ b/engine/inc/glm/ext/vector_uint3_precision.hpp
@@ -0,0 +1,31 @@
+/// @ref core
+/// @file glm/ext/vector_uint3_precision.hpp
+
+#pragma once
+#include "../detail/type_vec3.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_vector_precision
+	/// @{
+
+	/// 3 components vector of high qualifier unsigned integer numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<3, unsigned int, highp>		highp_uvec3;
+
+	/// 3 components vector of medium qualifier unsigned integer numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<3, unsigned int, mediump>	mediump_uvec3;
+
+	/// 3 components vector of low qualifier unsigned integer numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<3, unsigned int, lowp>		lowp_uvec3;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_uint4.hpp b/engine/inc/glm/ext/vector_uint4.hpp
new file mode 100644
index 00000000..32ced58a
--- /dev/null
+++ b/engine/inc/glm/ext/vector_uint4.hpp
@@ -0,0 +1,18 @@
+/// @ref core
+/// @file glm/ext/vector_uint4.hpp
+
+#pragma once
+#include "../detail/type_vec4.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_vector
+	/// @{
+
+	/// 4 components vector of unsigned integer numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	typedef vec<4, unsigned int, defaultp>		uvec4;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_uint4_precision.hpp b/engine/inc/glm/ext/vector_uint4_precision.hpp
new file mode 100644
index 00000000..cf4097ce
--- /dev/null
+++ b/engine/inc/glm/ext/vector_uint4_precision.hpp
@@ -0,0 +1,31 @@
+/// @ref core
+/// @file glm/ext/vector_uint4_precision.hpp
+
+#pragma once
+#include "../detail/type_vec4.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_vector_precision
+	/// @{
+
+	/// 4 components vector of high qualifier unsigned integer numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<4, unsigned int, highp>		highp_uvec4;
+
+	/// 4 components vector of medium qualifier unsigned integer numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<4, unsigned int, mediump>	mediump_uvec4;
+
+	/// 4 components vector of low qualifier unsigned integer numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef vec<4, unsigned int, lowp>		lowp_uvec4;
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/ext/vector_ulp.hpp b/engine/inc/glm/ext/vector_ulp.hpp
new file mode 100644
index 00000000..3883758f
--- /dev/null
+++ b/engine/inc/glm/ext/vector_ulp.hpp
@@ -0,0 +1,109 @@
+/// @ref ext_vector_ulp
+/// @file glm/ext/vector_ulp.hpp
+///
+/// @defgroup ext_vector_ulp GLM_EXT_vector_ulp
+/// @ingroup ext
+///
+/// Allow the measurement of the accuracy of a function against a reference
+/// implementation. This extension works on floating-point data and provide results
+/// in ULP.
+///
+/// Include <glm/ext/vector_ulp.hpp> to use the features of this extension.
+///
+/// @see ext_scalar_ulp
+/// @see ext_scalar_relational
+/// @see ext_vector_relational
+
+#pragma once
+
+// Dependencies
+#include "../ext/scalar_ulp.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_EXT_vector_ulp extension included")
+#endif
+
+namespace glm
+{
+	/// Return the next ULP value(s) after the input value(s).
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see ext_scalar_ulp
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> next_float(vec<L, T, Q> const& x);
+
+	/// Return the value(s) ULP distance after the input value(s).
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see ext_scalar_ulp
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> next_float(vec<L, T, Q> const& x, int ULPs);
+
+	/// Return the value(s) ULP distance after the input value(s).
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see ext_scalar_ulp
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> next_float(vec<L, T, Q> const& x, vec<L, int, Q> const& ULPs);
+
+	/// Return the previous ULP value(s) before the input value(s).
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see ext_scalar_ulp
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> prev_float(vec<L, T, Q> const& x);
+
+	/// Return the value(s) ULP distance before the input value(s).
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see ext_scalar_ulp
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> prev_float(vec<L, T, Q> const& x, int ULPs);
+
+	/// Return the value(s) ULP distance before the input value(s).
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see ext_scalar_ulp
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> prev_float(vec<L, T, Q> const& x, vec<L, int, Q> const& ULPs);
+
+	/// Return the distance in the number of ULP between 2 single-precision floating-point scalars.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see ext_scalar_ulp
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, int, Q> float_distance(vec<L, float, Q> const& x, vec<L, float, Q> const& y);
+
+	/// Return the distance in the number of ULP between 2 double-precision floating-point scalars.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see ext_scalar_ulp
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, int64, Q> float_distance(vec<L, double, Q> const& x, vec<L, double, Q> const& y);
+
+	/// @}
+}//namespace glm
+
+#include "vector_ulp.inl"
diff --git a/engine/inc/glm/ext/vector_ulp.inl b/engine/inc/glm/ext/vector_ulp.inl
new file mode 100644
index 00000000..86465343
--- /dev/null
+++ b/engine/inc/glm/ext/vector_ulp.inl
@@ -0,0 +1,74 @@
+namespace glm
+{
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> next_float(vec<L, T, Q> const& x)
+	{
+		vec<L, T, Q> Result;
+		for(length_t i = 0, n = Result.length(); i < n; ++i)
+			Result[i] = next_float(x[i]);
+		return Result;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> next_float(vec<L, T, Q> const& x, int ULPs)
+	{
+		vec<L, T, Q> Result;
+		for(length_t i = 0, n = Result.length(); i < n; ++i)
+			Result[i] = next_float(x[i], ULPs);
+		return Result;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> next_float(vec<L, T, Q> const& x, vec<L, int, Q> const& ULPs)
+	{
+		vec<L, T, Q> Result;
+		for(length_t i = 0, n = Result.length(); i < n; ++i)
+			Result[i] = next_float(x[i], ULPs[i]);
+		return Result;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> prev_float(vec<L, T, Q> const& x)
+	{
+		vec<L, T, Q> Result;
+		for(length_t i = 0, n = Result.length(); i < n; ++i)
+			Result[i] = prev_float(x[i]);
+		return Result;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> prev_float(vec<L, T, Q> const& x, int ULPs)
+	{
+		vec<L, T, Q> Result;
+		for(length_t i = 0, n = Result.length(); i < n; ++i)
+			Result[i] = prev_float(x[i], ULPs);
+		return Result;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> prev_float(vec<L, T, Q> const& x, vec<L, int, Q> const& ULPs)
+	{
+		vec<L, T, Q> Result;
+		for(length_t i = 0, n = Result.length(); i < n; ++i)
+			Result[i] = prev_float(x[i], ULPs[i]);
+		return Result;
+	}
+
+	template<length_t L, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, int, Q> float_distance(vec<L, float, Q> const& x, vec<L, float, Q> const& y)
+	{
+		vec<L, int, Q> Result;
+		for(length_t i = 0, n = Result.length(); i < n; ++i)
+			Result[i] = float_distance(x[i], y[i]);
+		return Result;
+	}
+
+	template<length_t L, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, int64, Q> float_distance(vec<L, double, Q> const& x, vec<L, double, Q> const& y)
+	{
+		vec<L, int64, Q> Result;
+		for(length_t i = 0, n = Result.length(); i < n; ++i)
+			Result[i] = float_distance(x[i], y[i]);
+		return Result;
+	}
+}//namespace glm
diff --git a/engine/inc/glm/fwd.hpp b/engine/inc/glm/fwd.hpp
new file mode 100644
index 00000000..41a3bee5
--- /dev/null
+++ b/engine/inc/glm/fwd.hpp
@@ -0,0 +1,818 @@
+#pragma once
+
+#include "detail/qualifier.hpp"
+
+namespace glm
+{
+#if GLM_HAS_EXTENDED_INTEGER_TYPE
+	typedef std::int8_t				int8;
+	typedef std::int16_t			int16;
+	typedef std::int32_t			int32;
+	typedef std::int64_t			int64;
+
+	typedef std::uint8_t			uint8;
+	typedef std::uint16_t			uint16;
+	typedef std::uint32_t			uint32;
+	typedef std::uint64_t			uint64;
+#else
+	typedef char					int8;
+	typedef short					int16;
+	typedef int						int32;
+	typedef detail::int64			int64;
+
+	typedef unsigned char			uint8;
+	typedef unsigned short			uint16;
+	typedef unsigned int			uint32;
+	typedef detail::uint64			uint64;
+#endif
+
+	// Scalar int
+
+	typedef int8					lowp_i8;
+	typedef int8					mediump_i8;
+	typedef int8					highp_i8;
+	typedef int8					i8;
+
+	typedef int8					lowp_int8;
+	typedef int8					mediump_int8;
+	typedef int8					highp_int8;
+
+	typedef int8					lowp_int8_t;
+	typedef int8					mediump_int8_t;
+	typedef int8					highp_int8_t;
+	typedef int8					int8_t;
+
+	typedef int16					lowp_i16;
+	typedef int16					mediump_i16;
+	typedef int16					highp_i16;
+	typedef int16					i16;
+
+	typedef int16					lowp_int16;
+	typedef int16					mediump_int16;
+	typedef int16					highp_int16;
+
+	typedef int16					lowp_int16_t;
+	typedef int16					mediump_int16_t;
+	typedef int16					highp_int16_t;
+	typedef int16					int16_t;
+
+	typedef int32					lowp_i32;
+	typedef int32					mediump_i32;
+	typedef int32					highp_i32;
+	typedef int32					i32;
+
+	typedef int32					lowp_int32;
+	typedef int32					mediump_int32;
+	typedef int32					highp_int32;
+
+	typedef int32					lowp_int32_t;
+	typedef int32					mediump_int32_t;
+	typedef int32					highp_int32_t;
+	typedef int32					int32_t;
+
+	typedef int64					lowp_i64;
+	typedef int64					mediump_i64;
+	typedef int64					highp_i64;
+	typedef int64					i64;
+
+	typedef int64					lowp_int64;
+	typedef int64					mediump_int64;
+	typedef int64					highp_int64;
+
+	typedef int64					lowp_int64_t;
+	typedef int64					mediump_int64_t;
+	typedef int64					highp_int64_t;
+	typedef int64					int64_t;
+
+	// Scalar uint
+
+	typedef uint8					lowp_u8;
+	typedef uint8					mediump_u8;
+	typedef uint8					highp_u8;
+	typedef uint8					u8;
+
+	typedef uint8					lowp_uint8;
+	typedef uint8					mediump_uint8;
+	typedef uint8					highp_uint8;
+
+	typedef uint8					lowp_uint8_t;
+	typedef uint8					mediump_uint8_t;
+	typedef uint8					highp_uint8_t;
+	typedef uint8					uint8_t;
+
+	typedef uint16					lowp_u16;
+	typedef uint16					mediump_u16;
+	typedef uint16					highp_u16;
+	typedef uint16					u16;
+
+	typedef uint16					lowp_uint16;
+	typedef uint16					mediump_uint16;
+	typedef uint16					highp_uint16;
+
+	typedef uint16					lowp_uint16_t;
+	typedef uint16					mediump_uint16_t;
+	typedef uint16					highp_uint16_t;
+	typedef uint16					uint16_t;
+
+	typedef uint32					lowp_u32;
+	typedef uint32					mediump_u32;
+	typedef uint32					highp_u32;
+	typedef uint32					u32;
+
+	typedef uint32					lowp_uint32;
+	typedef uint32					mediump_uint32;
+	typedef uint32					highp_uint32;
+
+	typedef uint32					lowp_uint32_t;
+	typedef uint32					mediump_uint32_t;
+	typedef uint32					highp_uint32_t;
+	typedef uint32					uint32_t;
+
+	typedef uint64					lowp_u64;
+	typedef uint64					mediump_u64;
+	typedef uint64					highp_u64;
+	typedef uint64					u64;
+
+	typedef uint64					lowp_uint64;
+	typedef uint64					mediump_uint64;
+	typedef uint64					highp_uint64;
+
+	typedef uint64					lowp_uint64_t;
+	typedef uint64					mediump_uint64_t;
+	typedef uint64					highp_uint64_t;
+	typedef uint64					uint64_t;
+
+	// Scalar float
+
+	typedef float					lowp_f32;
+	typedef float					mediump_f32;
+	typedef float					highp_f32;
+	typedef float					f32;
+
+	typedef float					lowp_float32;
+	typedef float					mediump_float32;
+	typedef float					highp_float32;
+	typedef float					float32;
+
+	typedef float					lowp_float32_t;
+	typedef float					mediump_float32_t;
+	typedef float					highp_float32_t;
+	typedef float					float32_t;
+
+
+	typedef double					lowp_f64;
+	typedef double					mediump_f64;
+	typedef double					highp_f64;
+	typedef double					f64;
+
+	typedef double					lowp_float64;
+	typedef double					mediump_float64;
+	typedef double					highp_float64;
+	typedef double					float64;
+
+	typedef double					lowp_float64_t;
+	typedef double					mediump_float64_t;
+	typedef double					highp_float64_t;
+	typedef double					float64_t;
+
+	// Vector bool
+
+	typedef vec<1, bool, lowp>		lowp_bvec1;
+	typedef vec<2, bool, lowp>		lowp_bvec2;
+	typedef vec<3, bool, lowp>		lowp_bvec3;
+	typedef vec<4, bool, lowp>		lowp_bvec4;
+
+	typedef vec<1, bool, mediump>	mediump_bvec1;
+	typedef vec<2, bool, mediump>	mediump_bvec2;
+	typedef vec<3, bool, mediump>	mediump_bvec3;
+	typedef vec<4, bool, mediump>	mediump_bvec4;
+
+	typedef vec<1, bool, highp>		highp_bvec1;
+	typedef vec<2, bool, highp>		highp_bvec2;
+	typedef vec<3, bool, highp>		highp_bvec3;
+	typedef vec<4, bool, highp>		highp_bvec4;
+
+	typedef vec<1, bool, defaultp>	bvec1;
+	typedef vec<2, bool, defaultp>	bvec2;
+	typedef vec<3, bool, defaultp>	bvec3;
+	typedef vec<4, bool, defaultp>	bvec4;
+
+	// Vector int
+
+	typedef vec<1, i32, lowp>		lowp_ivec1;
+	typedef vec<2, i32, lowp>		lowp_ivec2;
+	typedef vec<3, i32, lowp>		lowp_ivec3;
+	typedef vec<4, i32, lowp>		lowp_ivec4;
+
+	typedef vec<1, i32, mediump>	mediump_ivec1;
+	typedef vec<2, i32, mediump>	mediump_ivec2;
+	typedef vec<3, i32, mediump>	mediump_ivec3;
+	typedef vec<4, i32, mediump>	mediump_ivec4;
+
+	typedef vec<1, i32, highp>		highp_ivec1;
+	typedef vec<2, i32, highp>		highp_ivec2;
+	typedef vec<3, i32, highp>		highp_ivec3;
+	typedef vec<4, i32, highp>		highp_ivec4;
+
+	typedef vec<1, i32, defaultp>	ivec1;
+	typedef vec<2, i32, defaultp>	ivec2;
+	typedef vec<3, i32, defaultp>	ivec3;
+	typedef vec<4, i32, defaultp>	ivec4;
+
+	typedef vec<1, i8, lowp>		lowp_i8vec1;
+	typedef vec<2, i8, lowp>		lowp_i8vec2;
+	typedef vec<3, i8, lowp>		lowp_i8vec3;
+	typedef vec<4, i8, lowp>		lowp_i8vec4;
+
+	typedef vec<1, i8, mediump>		mediump_i8vec1;
+	typedef vec<2, i8, mediump>		mediump_i8vec2;
+	typedef vec<3, i8, mediump>		mediump_i8vec3;
+	typedef vec<4, i8, mediump>		mediump_i8vec4;
+
+	typedef vec<1, i8, highp>		highp_i8vec1;
+	typedef vec<2, i8, highp>		highp_i8vec2;
+	typedef vec<3, i8, highp>		highp_i8vec3;
+	typedef vec<4, i8, highp>		highp_i8vec4;
+
+	typedef vec<1, i8, defaultp>	i8vec1;
+	typedef vec<2, i8, defaultp>	i8vec2;
+	typedef vec<3, i8, defaultp>	i8vec3;
+	typedef vec<4, i8, defaultp>	i8vec4;
+
+	typedef vec<1, i16, lowp>		lowp_i16vec1;
+	typedef vec<2, i16, lowp>		lowp_i16vec2;
+	typedef vec<3, i16, lowp>		lowp_i16vec3;
+	typedef vec<4, i16, lowp>		lowp_i16vec4;
+
+	typedef vec<1, i16, mediump>	mediump_i16vec1;
+	typedef vec<2, i16, mediump>	mediump_i16vec2;
+	typedef vec<3, i16, mediump>	mediump_i16vec3;
+	typedef vec<4, i16, mediump>	mediump_i16vec4;
+
+	typedef vec<1, i16, highp>		highp_i16vec1;
+	typedef vec<2, i16, highp>		highp_i16vec2;
+	typedef vec<3, i16, highp>		highp_i16vec3;
+	typedef vec<4, i16, highp>		highp_i16vec4;
+
+	typedef vec<1, i16, defaultp>	i16vec1;
+	typedef vec<2, i16, defaultp>	i16vec2;
+	typedef vec<3, i16, defaultp>	i16vec3;
+	typedef vec<4, i16, defaultp>	i16vec4;
+
+	typedef vec<1, i32, lowp>		lowp_i32vec1;
+	typedef vec<2, i32, lowp>		lowp_i32vec2;
+	typedef vec<3, i32, lowp>		lowp_i32vec3;
+	typedef vec<4, i32, lowp>		lowp_i32vec4;
+
+	typedef vec<1, i32, mediump>	mediump_i32vec1;
+	typedef vec<2, i32, mediump>	mediump_i32vec2;
+	typedef vec<3, i32, mediump>	mediump_i32vec3;
+	typedef vec<4, i32, mediump>	mediump_i32vec4;
+
+	typedef vec<1, i32, highp>		highp_i32vec1;
+	typedef vec<2, i32, highp>		highp_i32vec2;
+	typedef vec<3, i32, highp>		highp_i32vec3;
+	typedef vec<4, i32, highp>		highp_i32vec4;
+
+	typedef vec<1, i32, defaultp>	i32vec1;
+	typedef vec<2, i32, defaultp>	i32vec2;
+	typedef vec<3, i32, defaultp>	i32vec3;
+	typedef vec<4, i32, defaultp>	i32vec4;
+
+	typedef vec<1, i64, lowp>		lowp_i64vec1;
+	typedef vec<2, i64, lowp>		lowp_i64vec2;
+	typedef vec<3, i64, lowp>		lowp_i64vec3;
+	typedef vec<4, i64, lowp>		lowp_i64vec4;
+
+	typedef vec<1, i64, mediump>	mediump_i64vec1;
+	typedef vec<2, i64, mediump>	mediump_i64vec2;
+	typedef vec<3, i64, mediump>	mediump_i64vec3;
+	typedef vec<4, i64, mediump>	mediump_i64vec4;
+
+	typedef vec<1, i64, highp>		highp_i64vec1;
+	typedef vec<2, i64, highp>		highp_i64vec2;
+	typedef vec<3, i64, highp>		highp_i64vec3;
+	typedef vec<4, i64, highp>		highp_i64vec4;
+
+	typedef vec<1, i64, defaultp>	i64vec1;
+	typedef vec<2, i64, defaultp>	i64vec2;
+	typedef vec<3, i64, defaultp>	i64vec3;
+	typedef vec<4, i64, defaultp>	i64vec4;
+
+	// Vector uint
+
+	typedef vec<1, u32, lowp>		lowp_uvec1;
+	typedef vec<2, u32, lowp>		lowp_uvec2;
+	typedef vec<3, u32, lowp>		lowp_uvec3;
+	typedef vec<4, u32, lowp>		lowp_uvec4;
+
+	typedef vec<1, u32, mediump>	mediump_uvec1;
+	typedef vec<2, u32, mediump>	mediump_uvec2;
+	typedef vec<3, u32, mediump>	mediump_uvec3;
+	typedef vec<4, u32, mediump>	mediump_uvec4;
+
+	typedef vec<1, u32, highp>		highp_uvec1;
+	typedef vec<2, u32, highp>		highp_uvec2;
+	typedef vec<3, u32, highp>		highp_uvec3;
+	typedef vec<4, u32, highp>		highp_uvec4;
+
+	typedef vec<1, u32, defaultp>	uvec1;
+	typedef vec<2, u32, defaultp>	uvec2;
+	typedef vec<3, u32, defaultp>	uvec3;
+	typedef vec<4, u32, defaultp>	uvec4;
+
+	typedef vec<1, u8, lowp>		lowp_u8vec1;
+	typedef vec<2, u8, lowp>		lowp_u8vec2;
+	typedef vec<3, u8, lowp>		lowp_u8vec3;
+	typedef vec<4, u8, lowp>		lowp_u8vec4;
+
+	typedef vec<1, u8, mediump>		mediump_u8vec1;
+	typedef vec<2, u8, mediump>		mediump_u8vec2;
+	typedef vec<3, u8, mediump>		mediump_u8vec3;
+	typedef vec<4, u8, mediump>		mediump_u8vec4;
+
+	typedef vec<1, u8, highp>		highp_u8vec1;
+	typedef vec<2, u8, highp>		highp_u8vec2;
+	typedef vec<3, u8, highp>		highp_u8vec3;
+	typedef vec<4, u8, highp>		highp_u8vec4;
+
+	typedef vec<1, u8, defaultp>	u8vec1;
+	typedef vec<2, u8, defaultp>	u8vec2;
+	typedef vec<3, u8, defaultp>	u8vec3;
+	typedef vec<4, u8, defaultp>	u8vec4;
+
+	typedef vec<1, u16, lowp>		lowp_u16vec1;
+	typedef vec<2, u16, lowp>		lowp_u16vec2;
+	typedef vec<3, u16, lowp>		lowp_u16vec3;
+	typedef vec<4, u16, lowp>		lowp_u16vec4;
+
+	typedef vec<1, u16, mediump>	mediump_u16vec1;
+	typedef vec<2, u16, mediump>	mediump_u16vec2;
+	typedef vec<3, u16, mediump>	mediump_u16vec3;
+	typedef vec<4, u16, mediump>	mediump_u16vec4;
+
+	typedef vec<1, u16, highp>		highp_u16vec1;
+	typedef vec<2, u16, highp>		highp_u16vec2;
+	typedef vec<3, u16, highp>		highp_u16vec3;
+	typedef vec<4, u16, highp>		highp_u16vec4;
+
+	typedef vec<1, u16, defaultp>	u16vec1;
+	typedef vec<2, u16, defaultp>	u16vec2;
+	typedef vec<3, u16, defaultp>	u16vec3;
+	typedef vec<4, u16, defaultp>	u16vec4;
+
+	typedef vec<1, u32, lowp>		lowp_u32vec1;
+	typedef vec<2, u32, lowp>		lowp_u32vec2;
+	typedef vec<3, u32, lowp>		lowp_u32vec3;
+	typedef vec<4, u32, lowp>		lowp_u32vec4;
+
+	typedef vec<1, u32, mediump>	mediump_u32vec1;
+	typedef vec<2, u32, mediump>	mediump_u32vec2;
+	typedef vec<3, u32, mediump>	mediump_u32vec3;
+	typedef vec<4, u32, mediump>	mediump_u32vec4;
+
+	typedef vec<1, u32, highp>		highp_u32vec1;
+	typedef vec<2, u32, highp>		highp_u32vec2;
+	typedef vec<3, u32, highp>		highp_u32vec3;
+	typedef vec<4, u32, highp>		highp_u32vec4;
+
+	typedef vec<1, u32, defaultp>	u32vec1;
+	typedef vec<2, u32, defaultp>	u32vec2;
+	typedef vec<3, u32, defaultp>	u32vec3;
+	typedef vec<4, u32, defaultp>	u32vec4;
+
+	typedef vec<1, u64, lowp>		lowp_u64vec1;
+	typedef vec<2, u64, lowp>		lowp_u64vec2;
+	typedef vec<3, u64, lowp>		lowp_u64vec3;
+	typedef vec<4, u64, lowp>		lowp_u64vec4;
+
+	typedef vec<1, u64, mediump>	mediump_u64vec1;
+	typedef vec<2, u64, mediump>	mediump_u64vec2;
+	typedef vec<3, u64, mediump>	mediump_u64vec3;
+	typedef vec<4, u64, mediump>	mediump_u64vec4;
+
+	typedef vec<1, u64, highp>		highp_u64vec1;
+	typedef vec<2, u64, highp>		highp_u64vec2;
+	typedef vec<3, u64, highp>		highp_u64vec3;
+	typedef vec<4, u64, highp>		highp_u64vec4;
+
+	typedef vec<1, u64, defaultp>	u64vec1;
+	typedef vec<2, u64, defaultp>	u64vec2;
+	typedef vec<3, u64, defaultp>	u64vec3;
+	typedef vec<4, u64, defaultp>	u64vec4;
+
+	// Vector float
+
+	typedef vec<1, float, lowp>			lowp_vec1;
+	typedef vec<2, float, lowp>			lowp_vec2;
+	typedef vec<3, float, lowp>			lowp_vec3;
+	typedef vec<4, float, lowp>			lowp_vec4;
+
+	typedef vec<1, float, mediump>		mediump_vec1;
+	typedef vec<2, float, mediump>		mediump_vec2;
+	typedef vec<3, float, mediump>		mediump_vec3;
+	typedef vec<4, float, mediump>		mediump_vec4;
+
+	typedef vec<1, float, highp>		highp_vec1;
+	typedef vec<2, float, highp>		highp_vec2;
+	typedef vec<3, float, highp>		highp_vec3;
+	typedef vec<4, float, highp>		highp_vec4;
+
+	typedef vec<1, float, defaultp>		vec1;
+	typedef vec<2, float, defaultp>		vec2;
+	typedef vec<3, float, defaultp>		vec3;
+	typedef vec<4, float, defaultp>		vec4;
+
+	typedef vec<1, float, lowp>			lowp_fvec1;
+	typedef vec<2, float, lowp>			lowp_fvec2;
+	typedef vec<3, float, lowp>			lowp_fvec3;
+	typedef vec<4, float, lowp>			lowp_fvec4;
+
+	typedef vec<1, float, mediump>		mediump_fvec1;
+	typedef vec<2, float, mediump>		mediump_fvec2;
+	typedef vec<3, float, mediump>		mediump_fvec3;
+	typedef vec<4, float, mediump>		mediump_fvec4;
+
+	typedef vec<1, float, highp>		highp_fvec1;
+	typedef vec<2, float, highp>		highp_fvec2;
+	typedef vec<3, float, highp>		highp_fvec3;
+	typedef vec<4, float, highp>		highp_fvec4;
+
+	typedef vec<1, f32, defaultp>		fvec1;
+	typedef vec<2, f32, defaultp>		fvec2;
+	typedef vec<3, f32, defaultp>		fvec3;
+	typedef vec<4, f32, defaultp>		fvec4;
+
+	typedef vec<1, f32, lowp>			lowp_f32vec1;
+	typedef vec<2, f32, lowp>			lowp_f32vec2;
+	typedef vec<3, f32, lowp>			lowp_f32vec3;
+	typedef vec<4, f32, lowp>			lowp_f32vec4;
+
+	typedef vec<1, f32, mediump>		mediump_f32vec1;
+	typedef vec<2, f32, mediump>		mediump_f32vec2;
+	typedef vec<3, f32, mediump>		mediump_f32vec3;
+	typedef vec<4, f32, mediump>		mediump_f32vec4;
+
+	typedef vec<1, f32, highp>			highp_f32vec1;
+	typedef vec<2, f32, highp>			highp_f32vec2;
+	typedef vec<3, f32, highp>			highp_f32vec3;
+	typedef vec<4, f32, highp>			highp_f32vec4;
+
+	typedef vec<1, f32, defaultp>		f32vec1;
+	typedef vec<2, f32, defaultp>		f32vec2;
+	typedef vec<3, f32, defaultp>		f32vec3;
+	typedef vec<4, f32, defaultp>		f32vec4;
+
+	typedef vec<1, f64, lowp>			lowp_dvec1;
+	typedef vec<2, f64, lowp>			lowp_dvec2;
+	typedef vec<3, f64, lowp>			lowp_dvec3;
+	typedef vec<4, f64, lowp>			lowp_dvec4;
+
+	typedef vec<1, f64, mediump>		mediump_dvec1;
+	typedef vec<2, f64, mediump>		mediump_dvec2;
+	typedef vec<3, f64, mediump>		mediump_dvec3;
+	typedef vec<4, f64, mediump>		mediump_dvec4;
+
+	typedef vec<1, f64, highp>			highp_dvec1;
+	typedef vec<2, f64, highp>			highp_dvec2;
+	typedef vec<3, f64, highp>			highp_dvec3;
+	typedef vec<4, f64, highp>			highp_dvec4;
+
+	typedef vec<1, f64, defaultp>		dvec1;
+	typedef vec<2, f64, defaultp>		dvec2;
+	typedef vec<3, f64, defaultp>		dvec3;
+	typedef vec<4, f64, defaultp>		dvec4;
+
+	typedef vec<1, f64, lowp>			lowp_f64vec1;
+	typedef vec<2, f64, lowp>			lowp_f64vec2;
+	typedef vec<3, f64, lowp>			lowp_f64vec3;
+	typedef vec<4, f64, lowp>			lowp_f64vec4;
+
+	typedef vec<1, f64, mediump>		mediump_f64vec1;
+	typedef vec<2, f64, mediump>		mediump_f64vec2;
+	typedef vec<3, f64, mediump>		mediump_f64vec3;
+	typedef vec<4, f64, mediump>		mediump_f64vec4;
+
+	typedef vec<1, f64, highp>			highp_f64vec1;
+	typedef vec<2, f64, highp>			highp_f64vec2;
+	typedef vec<3, f64, highp>			highp_f64vec3;
+	typedef vec<4, f64, highp>			highp_f64vec4;
+
+	typedef vec<1, f64, defaultp>		f64vec1;
+	typedef vec<2, f64, defaultp>		f64vec2;
+	typedef vec<3, f64, defaultp>		f64vec3;
+	typedef vec<4, f64, defaultp>		f64vec4;
+
+	// Matrix NxN
+
+	typedef mat<2, 2, f32, lowp>		lowp_mat2;
+	typedef mat<3, 3, f32, lowp>		lowp_mat3;
+	typedef mat<4, 4, f32, lowp>		lowp_mat4;
+
+	typedef mat<2, 2, f32, mediump>		mediump_mat2;
+	typedef mat<3, 3, f32, mediump>		mediump_mat3;
+	typedef mat<4, 4, f32, mediump>		mediump_mat4;
+
+	typedef mat<2, 2, f32, highp>		highp_mat2;
+	typedef mat<3, 3, f32, highp>		highp_mat3;
+	typedef mat<4, 4, f32, highp>		highp_mat4;
+
+	typedef mat<2, 2, f32, defaultp>	mat2;
+	typedef mat<3, 3, f32, defaultp>	mat3;
+	typedef mat<4, 4, f32, defaultp>	mat4;
+
+	typedef mat<2, 2, f32, lowp>		lowp_fmat2;
+	typedef mat<3, 3, f32, lowp>		lowp_fmat3;
+	typedef mat<4, 4, f32, lowp>		lowp_fmat4;
+
+	typedef mat<2, 2, f32, mediump>		mediump_fmat2;
+	typedef mat<3, 3, f32, mediump>		mediump_fmat3;
+	typedef mat<4, 4, f32, mediump>		mediump_fmat4;
+
+	typedef mat<2, 2, f32, highp>		highp_fmat2;
+	typedef mat<3, 3, f32, highp>		highp_fmat3;
+	typedef mat<4, 4, f32, highp>		highp_fmat4;
+
+	typedef mat<2, 2, f32, defaultp>	fmat2;
+	typedef mat<3, 3, f32, defaultp>	fmat3;
+	typedef mat<4, 4, f32, defaultp>	fmat4;
+
+	typedef mat<2, 2, f32, lowp>		lowp_f32mat2;
+	typedef mat<3, 3, f32, lowp>		lowp_f32mat3;
+	typedef mat<4, 4, f32, lowp>		lowp_f32mat4;
+
+	typedef mat<2, 2, f32, mediump>		mediump_f32mat2;
+	typedef mat<3, 3, f32, mediump>		mediump_f32mat3;
+	typedef mat<4, 4, f32, mediump>		mediump_f32mat4;
+
+	typedef mat<2, 2, f32, highp>		highp_f32mat2;
+	typedef mat<3, 3, f32, highp>		highp_f32mat3;
+	typedef mat<4, 4, f32, highp>		highp_f32mat4;
+
+	typedef mat<2, 2, f32, defaultp>	f32mat2;
+	typedef mat<3, 3, f32, defaultp>	f32mat3;
+	typedef mat<4, 4, f32, defaultp>	f32mat4;
+
+	typedef mat<2, 2, f64, lowp>		lowp_dmat2;
+	typedef mat<3, 3, f64, lowp>		lowp_dmat3;
+	typedef mat<4, 4, f64, lowp>		lowp_dmat4;
+
+	typedef mat<2, 2, f64, mediump>		mediump_dmat2;
+	typedef mat<3, 3, f64, mediump>		mediump_dmat3;
+	typedef mat<4, 4, f64, mediump>		mediump_dmat4;
+
+	typedef mat<2, 2, f64, highp>		highp_dmat2;
+	typedef mat<3, 3, f64, highp>		highp_dmat3;
+	typedef mat<4, 4, f64, highp>		highp_dmat4;
+
+	typedef mat<2, 2, f64, defaultp>	dmat2;
+	typedef mat<3, 3, f64, defaultp>	dmat3;
+	typedef mat<4, 4, f64, defaultp>	dmat4;
+
+	typedef mat<2, 2, f64, lowp>		lowp_f64mat2;
+	typedef mat<3, 3, f64, lowp>		lowp_f64mat3;
+	typedef mat<4, 4, f64, lowp>		lowp_f64mat4;
+
+	typedef mat<2, 2, f64, mediump>		mediump_f64mat2;
+	typedef mat<3, 3, f64, mediump>		mediump_f64mat3;
+	typedef mat<4, 4, f64, mediump>		mediump_f64mat4;
+
+	typedef mat<2, 2, f64, highp>		highp_f64mat2;
+	typedef mat<3, 3, f64, highp>		highp_f64mat3;
+	typedef mat<4, 4, f64, highp>		highp_f64mat4;
+
+	typedef mat<2, 2, f64, defaultp>	f64mat2;
+	typedef mat<3, 3, f64, defaultp>	f64mat3;
+	typedef mat<4, 4, f64, defaultp>	f64mat4;
+
+	// Matrix MxN
+
+	typedef mat<2, 2, f32, lowp>		lowp_mat2x2;
+	typedef mat<2, 3, f32, lowp>		lowp_mat2x3;
+	typedef mat<2, 4, f32, lowp>		lowp_mat2x4;
+	typedef mat<3, 2, f32, lowp>		lowp_mat3x2;
+	typedef mat<3, 3, f32, lowp>		lowp_mat3x3;
+	typedef mat<3, 4, f32, lowp>		lowp_mat3x4;
+	typedef mat<4, 2, f32, lowp>		lowp_mat4x2;
+	typedef mat<4, 3, f32, lowp>		lowp_mat4x3;
+	typedef mat<4, 4, f32, lowp>		lowp_mat4x4;
+
+	typedef mat<2, 2, f32, mediump>		mediump_mat2x2;
+	typedef mat<2, 3, f32, mediump>		mediump_mat2x3;
+	typedef mat<2, 4, f32, mediump>		mediump_mat2x4;
+	typedef mat<3, 2, f32, mediump>		mediump_mat3x2;
+	typedef mat<3, 3, f32, mediump>		mediump_mat3x3;
+	typedef mat<3, 4, f32, mediump>		mediump_mat3x4;
+	typedef mat<4, 2, f32, mediump>		mediump_mat4x2;
+	typedef mat<4, 3, f32, mediump>		mediump_mat4x3;
+	typedef mat<4, 4, f32, mediump>		mediump_mat4x4;
+
+	typedef mat<2, 2, f32, highp>		highp_mat2x2;
+	typedef mat<2, 3, f32, highp>		highp_mat2x3;
+	typedef mat<2, 4, f32, highp>		highp_mat2x4;
+	typedef mat<3, 2, f32, highp>		highp_mat3x2;
+	typedef mat<3, 3, f32, highp>		highp_mat3x3;
+	typedef mat<3, 4, f32, highp>		highp_mat3x4;
+	typedef mat<4, 2, f32, highp>		highp_mat4x2;
+	typedef mat<4, 3, f32, highp>		highp_mat4x3;
+	typedef mat<4, 4, f32, highp>		highp_mat4x4;
+
+	typedef mat<2, 2, f32, defaultp>	mat2x2;
+	typedef mat<3, 2, f32, defaultp>	mat3x2;
+	typedef mat<4, 2, f32, defaultp>	mat4x2;
+	typedef mat<2, 3, f32, defaultp>	mat2x3;
+	typedef mat<3, 3, f32, defaultp>	mat3x3;
+	typedef mat<4, 3, f32, defaultp>	mat4x3;
+	typedef mat<2, 4, f32, defaultp>	mat2x4;
+	typedef mat<3, 4, f32, defaultp>	mat3x4;
+	typedef mat<4, 4, f32, defaultp>	mat4x4;
+
+	typedef mat<2, 2, f32, lowp>		lowp_fmat2x2;
+	typedef mat<2, 3, f32, lowp>		lowp_fmat2x3;
+	typedef mat<2, 4, f32, lowp>		lowp_fmat2x4;
+	typedef mat<3, 2, f32, lowp>		lowp_fmat3x2;
+	typedef mat<3, 3, f32, lowp>		lowp_fmat3x3;
+	typedef mat<3, 4, f32, lowp>		lowp_fmat3x4;
+	typedef mat<4, 2, f32, lowp>		lowp_fmat4x2;
+	typedef mat<4, 3, f32, lowp>		lowp_fmat4x3;
+	typedef mat<4, 4, f32, lowp>		lowp_fmat4x4;
+
+	typedef mat<2, 2, f32, mediump>		mediump_fmat2x2;
+	typedef mat<2, 3, f32, mediump>		mediump_fmat2x3;
+	typedef mat<2, 4, f32, mediump>		mediump_fmat2x4;
+	typedef mat<3, 2, f32, mediump>		mediump_fmat3x2;
+	typedef mat<3, 3, f32, mediump>		mediump_fmat3x3;
+	typedef mat<3, 4, f32, mediump>		mediump_fmat3x4;
+	typedef mat<4, 2, f32, mediump>		mediump_fmat4x2;
+	typedef mat<4, 3, f32, mediump>		mediump_fmat4x3;
+	typedef mat<4, 4, f32, mediump>		mediump_fmat4x4;
+
+	typedef mat<2, 2, f32, highp>		highp_fmat2x2;
+	typedef mat<2, 3, f32, highp>		highp_fmat2x3;
+	typedef mat<2, 4, f32, highp>		highp_fmat2x4;
+	typedef mat<3, 2, f32, highp>		highp_fmat3x2;
+	typedef mat<3, 3, f32, highp>		highp_fmat3x3;
+	typedef mat<3, 4, f32, highp>		highp_fmat3x4;
+	typedef mat<4, 2, f32, highp>		highp_fmat4x2;
+	typedef mat<4, 3, f32, highp>		highp_fmat4x3;
+	typedef mat<4, 4, f32, highp>		highp_fmat4x4;
+
+	typedef mat<2, 2, f32, defaultp>	fmat2x2;
+	typedef mat<3, 2, f32, defaultp>	fmat3x2;
+	typedef mat<4, 2, f32, defaultp>	fmat4x2;
+	typedef mat<2, 3, f32, defaultp>	fmat2x3;
+	typedef mat<3, 3, f32, defaultp>	fmat3x3;
+	typedef mat<4, 3, f32, defaultp>	fmat4x3;
+	typedef mat<2, 4, f32, defaultp>	fmat2x4;
+	typedef mat<3, 4, f32, defaultp>	fmat3x4;
+	typedef mat<4, 4, f32, defaultp>	fmat4x4;
+
+	typedef mat<2, 2, f32, lowp>		lowp_f32mat2x2;
+	typedef mat<2, 3, f32, lowp>		lowp_f32mat2x3;
+	typedef mat<2, 4, f32, lowp>		lowp_f32mat2x4;
+	typedef mat<3, 2, f32, lowp>		lowp_f32mat3x2;
+	typedef mat<3, 3, f32, lowp>		lowp_f32mat3x3;
+	typedef mat<3, 4, f32, lowp>		lowp_f32mat3x4;
+	typedef mat<4, 2, f32, lowp>		lowp_f32mat4x2;
+	typedef mat<4, 3, f32, lowp>		lowp_f32mat4x3;
+	typedef mat<4, 4, f32, lowp>		lowp_f32mat4x4;
+	
+	typedef mat<2, 2, f32, mediump>		mediump_f32mat2x2;
+	typedef mat<2, 3, f32, mediump>		mediump_f32mat2x3;
+	typedef mat<2, 4, f32, mediump>		mediump_f32mat2x4;
+	typedef mat<3, 2, f32, mediump>		mediump_f32mat3x2;
+	typedef mat<3, 3, f32, mediump>		mediump_f32mat3x3;
+	typedef mat<3, 4, f32, mediump>		mediump_f32mat3x4;
+	typedef mat<4, 2, f32, mediump>		mediump_f32mat4x2;
+	typedef mat<4, 3, f32, mediump>		mediump_f32mat4x3;
+	typedef mat<4, 4, f32, mediump>		mediump_f32mat4x4;
+
+	typedef mat<2, 2, f32, highp>		highp_f32mat2x2;
+	typedef mat<2, 3, f32, highp>		highp_f32mat2x3;
+	typedef mat<2, 4, f32, highp>		highp_f32mat2x4;
+	typedef mat<3, 2, f32, highp>		highp_f32mat3x2;
+	typedef mat<3, 3, f32, highp>		highp_f32mat3x3;
+	typedef mat<3, 4, f32, highp>		highp_f32mat3x4;
+	typedef mat<4, 2, f32, highp>		highp_f32mat4x2;
+	typedef mat<4, 3, f32, highp>		highp_f32mat4x3;
+	typedef mat<4, 4, f32, highp>		highp_f32mat4x4;
+
+	typedef mat<2, 2, f32, defaultp>	f32mat2x2;
+	typedef mat<3, 2, f32, defaultp>	f32mat3x2;
+	typedef mat<4, 2, f32, defaultp>	f32mat4x2;
+	typedef mat<2, 3, f32, defaultp>	f32mat2x3;
+	typedef mat<3, 3, f32, defaultp>	f32mat3x3;
+	typedef mat<4, 3, f32, defaultp>	f32mat4x3;
+	typedef mat<2, 4, f32, defaultp>	f32mat2x4;
+	typedef mat<3, 4, f32, defaultp>	f32mat3x4;
+	typedef mat<4, 4, f32, defaultp>	f32mat4x4;
+
+	typedef mat<2, 2, double, lowp>		lowp_dmat2x2;
+	typedef mat<2, 3, double, lowp>		lowp_dmat2x3;
+	typedef mat<2, 4, double, lowp>		lowp_dmat2x4;
+	typedef mat<3, 2, double, lowp>		lowp_dmat3x2;
+	typedef mat<3, 3, double, lowp>		lowp_dmat3x3;
+	typedef mat<3, 4, double, lowp>		lowp_dmat3x4;
+	typedef mat<4, 2, double, lowp>		lowp_dmat4x2;
+	typedef mat<4, 3, double, lowp>		lowp_dmat4x3;
+	typedef mat<4, 4, double, lowp>		lowp_dmat4x4;
+
+	typedef mat<2, 2, double, mediump>	mediump_dmat2x2;
+	typedef mat<2, 3, double, mediump>	mediump_dmat2x3;
+	typedef mat<2, 4, double, mediump>	mediump_dmat2x4;
+	typedef mat<3, 2, double, mediump>	mediump_dmat3x2;
+	typedef mat<3, 3, double, mediump>	mediump_dmat3x3;
+	typedef mat<3, 4, double, mediump>	mediump_dmat3x4;
+	typedef mat<4, 2, double, mediump>	mediump_dmat4x2;
+	typedef mat<4, 3, double, mediump>	mediump_dmat4x3;
+	typedef mat<4, 4, double, mediump>	mediump_dmat4x4;
+
+	typedef mat<2, 2, double, highp>	highp_dmat2x2;
+	typedef mat<2, 3, double, highp>	highp_dmat2x3;
+	typedef mat<2, 4, double, highp>	highp_dmat2x4;
+	typedef mat<3, 2, double, highp>	highp_dmat3x2;
+	typedef mat<3, 3, double, highp>	highp_dmat3x3;
+	typedef mat<3, 4, double, highp>	highp_dmat3x4;
+	typedef mat<4, 2, double, highp>	highp_dmat4x2;
+	typedef mat<4, 3, double, highp>	highp_dmat4x3;
+	typedef mat<4, 4, double, highp>	highp_dmat4x4;
+
+	typedef mat<2, 2, double, defaultp>	dmat2x2;
+	typedef mat<3, 2, double, defaultp>	dmat3x2;
+	typedef mat<4, 2, double, defaultp>	dmat4x2;
+	typedef mat<2, 3, double, defaultp>	dmat2x3;
+	typedef mat<3, 3, double, defaultp>	dmat3x3;
+	typedef mat<4, 3, double, defaultp>	dmat4x3;
+	typedef mat<2, 4, double, defaultp>	dmat2x4;
+	typedef mat<3, 4, double, defaultp>	dmat3x4;
+	typedef mat<4, 4, double, defaultp>	dmat4x4;
+
+	typedef mat<2, 2, f64, lowp>		lowp_f64mat2x2;
+	typedef mat<2, 3, f64, lowp>		lowp_f64mat2x3;
+	typedef mat<2, 4, f64, lowp>		lowp_f64mat2x4;
+	typedef mat<3, 2, f64, lowp>		lowp_f64mat3x2;
+	typedef mat<3, 3, f64, lowp>		lowp_f64mat3x3;
+	typedef mat<3, 4, f64, lowp>		lowp_f64mat3x4;
+	typedef mat<4, 2, f64, lowp>		lowp_f64mat4x2;
+	typedef mat<4, 3, f64, lowp>		lowp_f64mat4x3;
+	typedef mat<4, 4, f64, lowp>		lowp_f64mat4x4;
+
+	typedef mat<2, 2, f64, mediump>		mediump_f64mat2x2;
+	typedef mat<2, 3, f64, mediump>		mediump_f64mat2x3;
+	typedef mat<2, 4, f64, mediump>		mediump_f64mat2x4;
+	typedef mat<3, 2, f64, mediump>		mediump_f64mat3x2;
+	typedef mat<3, 3, f64, mediump>		mediump_f64mat3x3;
+	typedef mat<3, 4, f64, mediump>		mediump_f64mat3x4;
+	typedef mat<4, 2, f64, mediump>		mediump_f64mat4x2;
+	typedef mat<4, 3, f64, mediump>		mediump_f64mat4x3;
+	typedef mat<4, 4, f64, mediump>		mediump_f64mat4x4;
+
+	typedef mat<2, 2, f64, highp>		highp_f64mat2x2;
+	typedef mat<2, 3, f64, highp>		highp_f64mat2x3;
+	typedef mat<2, 4, f64, highp>		highp_f64mat2x4;
+	typedef mat<3, 2, f64, highp>		highp_f64mat3x2;
+	typedef mat<3, 3, f64, highp>		highp_f64mat3x3;
+	typedef mat<3, 4, f64, highp>		highp_f64mat3x4;
+	typedef mat<4, 2, f64, highp>		highp_f64mat4x2;
+	typedef mat<4, 3, f64, highp>		highp_f64mat4x3;
+	typedef mat<4, 4, f64, highp>		highp_f64mat4x4;
+
+	typedef mat<2, 2, f64, defaultp>	f64mat2x2;
+	typedef mat<3, 2, f64, defaultp>	f64mat3x2;
+	typedef mat<4, 2, f64, defaultp>	f64mat4x2;
+	typedef mat<2, 3, f64, defaultp>	f64mat2x3;
+	typedef mat<3, 3, f64, defaultp>	f64mat3x3;
+	typedef mat<4, 3, f64, defaultp>	f64mat4x3;
+	typedef mat<2, 4, f64, defaultp>	f64mat2x4;
+	typedef mat<3, 4, f64, defaultp>	f64mat3x4;
+	typedef mat<4, 4, f64, defaultp>	f64mat4x4;
+
+	// Quaternion
+
+	typedef qua<float, lowp>			lowp_quat;
+	typedef qua<float, mediump>			mediump_quat;
+	typedef qua<float, highp>			highp_quat;
+	typedef qua<float, defaultp>		quat;
+
+	typedef qua<float, lowp>			lowp_fquat;
+	typedef qua<float, mediump>			mediump_fquat;
+	typedef qua<float, highp>			highp_fquat;
+	typedef qua<float, defaultp>		fquat;
+
+	typedef qua<f32, lowp>				lowp_f32quat;
+	typedef qua<f32, mediump>			mediump_f32quat;
+	typedef qua<f32, highp>				highp_f32quat;
+	typedef qua<f32, defaultp>			f32quat;
+
+	typedef qua<double, lowp>			lowp_dquat;
+	typedef qua<double, mediump>		mediump_dquat;
+	typedef qua<double, highp>			highp_dquat;
+	typedef qua<double, defaultp>		dquat;
+
+	typedef qua<f64, lowp>				lowp_f64quat;
+	typedef qua<f64, mediump>			mediump_f64quat;
+	typedef qua<f64, highp>				highp_f64quat;
+	typedef qua<f64, defaultp>			f64quat;
+}//namespace glm
+
+
diff --git a/engine/inc/glm/geometric.hpp b/engine/inc/glm/geometric.hpp
new file mode 100644
index 00000000..c068a3cb
--- /dev/null
+++ b/engine/inc/glm/geometric.hpp
@@ -0,0 +1,116 @@
+/// @ref core
+/// @file glm/geometric.hpp
+///
+/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+///
+/// @defgroup core_func_geometric Geometric functions
+/// @ingroup core
+///
+/// These operate on vectors as vectors, not component-wise.
+///
+/// Include <glm/geometric.hpp> to use these core features.
+
+#pragma once
+
+#include "detail/type_vec3.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_func_geometric
+	/// @{
+
+	/// Returns the length of x, i.e., sqrt(x * x).
+	///
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	/// @tparam T Floating-point scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/length.xml">GLSL length man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL T length(vec<L, T, Q> const& x);
+
+	/// Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
+	///
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	/// @tparam T Floating-point scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/distance.xml">GLSL distance man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL T distance(vec<L, T, Q> const& p0, vec<L, T, Q> const& p1);
+
+	/// Returns the dot product of x and y, i.e., result = x * y.
+	///
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	/// @tparam T Floating-point scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/dot.xml">GLSL dot man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL T dot(vec<L, T, Q> const& x, vec<L, T, Q> const& y);
+
+	/// Returns the cross product of x and y.
+	///
+	/// @tparam T Floating-point scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cross.xml">GLSL cross man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> cross(vec<3, T, Q> const& x, vec<3, T, Q> const& y);
+
+	/// Returns a vector in the same direction as x but with length of 1.
+	/// According to issue 10 GLSL 1.10 specification, if length(x) == 0 then result is undefined and generate an error.
+	///
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	/// @tparam T Floating-point scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/normalize.xml">GLSL normalize man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> normalize(vec<L, T, Q> const& x);
+
+	/// If dot(Nref, I) < 0.0, return N, otherwise, return -N.
+	///
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	/// @tparam T Floating-point scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/faceforward.xml">GLSL faceforward man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> faceforward(
+		vec<L, T, Q> const& N,
+		vec<L, T, Q> const& I,
+		vec<L, T, Q> const& Nref);
+
+	/// For the incident vector I and surface orientation N,
+	/// returns the reflection direction : result = I - 2.0 * dot(N, I) * N.
+	///
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	/// @tparam T Floating-point scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/reflect.xml">GLSL reflect man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> reflect(
+		vec<L, T, Q> const& I,
+		vec<L, T, Q> const& N);
+
+	/// For the incident vector I and surface normal N,
+	/// and the ratio of indices of refraction eta,
+	/// return the refraction vector.
+	///
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	/// @tparam T Floating-point scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/refract.xml">GLSL refract man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> refract(
+		vec<L, T, Q> const& I,
+		vec<L, T, Q> const& N,
+		T eta);
+
+	/// @}
+}//namespace glm
+
+#include "detail/func_geometric.inl"
diff --git a/engine/inc/glm/glm.hpp b/engine/inc/glm/glm.hpp
new file mode 100644
index 00000000..8b610649
--- /dev/null
+++ b/engine/inc/glm/glm.hpp
@@ -0,0 +1,136 @@
+/// @ref core
+/// @file glm/glm.hpp
+///
+/// @defgroup core Core features
+///
+/// @brief Features that implement in C++ the GLSL specification as closely as possible.
+///
+/// The GLM core consists of C++ types that mirror GLSL types and
+/// C++ functions that mirror the GLSL functions.
+///
+/// The best documentation for GLM Core is the current GLSL specification,
+/// <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.clean.pdf">version 4.2
+/// (pdf file)</a>.
+///
+/// GLM core functionalities require <glm/glm.hpp> to be included to be used.
+///
+///
+/// @defgroup core_vector Vector types
+///
+/// Vector types of two to four components with an exhaustive set of operators.
+///
+/// @ingroup core
+///
+///
+/// @defgroup core_vector_precision Vector types with precision qualifiers
+///
+/// @brief Vector types with precision qualifiers which may result in various precision in term of ULPs
+///
+/// GLSL allows defining qualifiers for particular variables.
+/// With OpenGL's GLSL, these qualifiers have no effect; they are there for compatibility,
+/// with OpenGL ES's GLSL, these qualifiers do have an effect.
+///
+/// C++ has no language equivalent to qualifier qualifiers. So GLM provides the next-best thing:
+/// a number of typedefs that use a particular qualifier.
+///
+/// None of these types make any guarantees about the actual qualifier used.
+///
+/// @ingroup core
+///
+///
+/// @defgroup core_matrix Matrix types
+///
+/// Matrix types of with C columns and R rows where C and R are values between 2 to 4 included.
+/// These types have exhaustive sets of operators.
+///
+/// @ingroup core
+///
+///
+/// @defgroup core_matrix_precision Matrix types with precision qualifiers
+///
+/// @brief Matrix types with precision qualifiers which may result in various precision in term of ULPs
+///
+/// GLSL allows defining qualifiers for particular variables.
+/// With OpenGL's GLSL, these qualifiers have no effect; they are there for compatibility,
+/// with OpenGL ES's GLSL, these qualifiers do have an effect.
+///
+/// C++ has no language equivalent to qualifier qualifiers. So GLM provides the next-best thing:
+/// a number of typedefs that use a particular qualifier.
+///
+/// None of these types make any guarantees about the actual qualifier used.
+///
+/// @ingroup core
+///
+///
+/// @defgroup ext Stable extensions
+///
+/// @brief Additional features not specified by GLSL specification.
+///
+/// EXT extensions are fully tested and documented.
+///
+/// Even if it's highly unrecommended, it's possible to include all the extensions at once by
+/// including <glm/ext.hpp>. Otherwise, each extension needs to be included  a specific file.
+///
+///
+/// @defgroup gtc Recommended extensions
+///
+/// @brief Additional features not specified by GLSL specification.
+///
+/// GTC extensions aim to be stable with tests and documentation.
+///
+/// Even if it's highly unrecommended, it's possible to include all the extensions at once by
+/// including <glm/ext.hpp>. Otherwise, each extension needs to be included  a specific file.
+///
+///
+/// @defgroup gtx Experimental extensions
+///
+/// @brief Experimental features not specified by GLSL specification.
+///
+/// Experimental extensions are useful functions and types, but the development of
+/// their API and functionality is not necessarily stable. They can change
+/// substantially between versions. Backwards compatibility is not much of an issue
+/// for them.
+///
+/// Even if it's highly unrecommended, it's possible to include all the extensions
+/// at once by including <glm/ext.hpp>. Otherwise, each extension needs to be
+/// included  a specific file.
+///
+/// @mainpage OpenGL Mathematics (GLM)
+/// - Website: <a href="https://glm.g-truc.net">glm.g-truc.net</a>
+/// - <a href="modules.html">GLM API documentation</a>
+/// - <a href="https://github.com/g-truc/glm/blob/master/manual.md">GLM Manual</a>
+
+#include "detail/_fixes.hpp"
+
+#include "detail/setup.hpp"
+
+#pragma once
+
+#include <cmath>
+#include <climits>
+#include <cfloat>
+#include <limits>
+#include <cassert>
+#include "fwd.hpp"
+
+#include "vec2.hpp"
+#include "vec3.hpp"
+#include "vec4.hpp"
+#include "mat2x2.hpp"
+#include "mat2x3.hpp"
+#include "mat2x4.hpp"
+#include "mat3x2.hpp"
+#include "mat3x3.hpp"
+#include "mat3x4.hpp"
+#include "mat4x2.hpp"
+#include "mat4x3.hpp"
+#include "mat4x4.hpp"
+
+#include "trigonometric.hpp"
+#include "exponential.hpp"
+#include "common.hpp"
+#include "packing.hpp"
+#include "geometric.hpp"
+#include "matrix.hpp"
+#include "vector_relational.hpp"
+#include "integer.hpp"
diff --git a/engine/inc/glm/gtc/bitfield.hpp b/engine/inc/glm/gtc/bitfield.hpp
new file mode 100644
index 00000000..084fbe75
--- /dev/null
+++ b/engine/inc/glm/gtc/bitfield.hpp
@@ -0,0 +1,266 @@
+/// @ref gtc_bitfield
+/// @file glm/gtc/bitfield.hpp
+///
+/// @see core (dependence)
+/// @see gtc_bitfield (dependence)
+///
+/// @defgroup gtc_bitfield GLM_GTC_bitfield
+/// @ingroup gtc
+///
+/// Include <glm/gtc/bitfield.hpp> to use the features of this extension.
+///
+/// Allow to perform bit operations on integer values
+
+#include "../detail/setup.hpp"
+
+#pragma once
+
+// Dependencies
+#include "../ext/scalar_int_sized.hpp"
+#include "../ext/scalar_uint_sized.hpp"
+#include "../detail/qualifier.hpp"
+#include "../detail/_vectorize.hpp"
+#include "type_precision.hpp"
+#include <limits>
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTC_bitfield extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtc_bitfield
+	/// @{
+
+	/// Build a mask of 'count' bits
+	///
+	/// @see gtc_bitfield
+	template<typename genIUType>
+	GLM_FUNC_DECL genIUType mask(genIUType Bits);
+
+	/// Build a mask of 'count' bits
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Signed and unsigned integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see gtc_bitfield
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> mask(vec<L, T, Q> const& v);
+
+	/// Rotate all bits to the right. All the bits dropped in the right side are inserted back on the left side.
+	///
+	/// @see gtc_bitfield
+	template<typename genIUType>
+	GLM_FUNC_DECL genIUType bitfieldRotateRight(genIUType In, int Shift);
+
+	/// Rotate all bits to the right. All the bits dropped in the right side are inserted back on the left side.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Signed and unsigned integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see gtc_bitfield
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> bitfieldRotateRight(vec<L, T, Q> const& In, int Shift);
+
+	/// Rotate all bits to the left. All the bits dropped in the left side are inserted back on the right side.
+	///
+	/// @see gtc_bitfield
+	template<typename genIUType>
+	GLM_FUNC_DECL genIUType bitfieldRotateLeft(genIUType In, int Shift);
+
+	/// Rotate all bits to the left. All the bits dropped in the left side are inserted back on the right side.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Signed and unsigned integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see gtc_bitfield
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> bitfieldRotateLeft(vec<L, T, Q> const& In, int Shift);
+
+	/// Set to 1 a range of bits.
+	///
+	/// @see gtc_bitfield
+	template<typename genIUType>
+	GLM_FUNC_DECL genIUType bitfieldFillOne(genIUType Value, int FirstBit, int BitCount);
+
+	/// Set to 1 a range of bits.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Signed and unsigned integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see gtc_bitfield
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> bitfieldFillOne(vec<L, T, Q> const& Value, int FirstBit, int BitCount);
+
+	/// Set to 0 a range of bits.
+	///
+	/// @see gtc_bitfield
+	template<typename genIUType>
+	GLM_FUNC_DECL genIUType bitfieldFillZero(genIUType Value, int FirstBit, int BitCount);
+
+	/// Set to 0 a range of bits.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Signed and unsigned integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see gtc_bitfield
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> bitfieldFillZero(vec<L, T, Q> const& Value, int FirstBit, int BitCount);
+
+	/// Interleaves the bits of x and y.
+	/// The first bit is the first bit of x followed by the first bit of y.
+	/// The other bits are interleaved following the previous sequence.
+	///
+	/// @see gtc_bitfield
+	GLM_FUNC_DECL int16 bitfieldInterleave(int8 x, int8 y);
+
+	/// Interleaves the bits of x and y.
+	/// The first bit is the first bit of x followed by the first bit of y.
+	/// The other bits are interleaved following the previous sequence.
+	///
+	/// @see gtc_bitfield
+	GLM_FUNC_DECL uint16 bitfieldInterleave(uint8 x, uint8 y);
+
+	/// Interleaves the bits of x and y.
+	/// The first bit is the first bit of v.x followed by the first bit of v.y.
+	/// The other bits are interleaved following the previous sequence.
+	///
+	/// @see gtc_bitfield
+	GLM_FUNC_DECL uint16 bitfieldInterleave(u8vec2 const& v);
+
+	/// Deinterleaves the bits of x.
+	///
+	/// @see gtc_bitfield
+	GLM_FUNC_DECL glm::u8vec2 bitfieldDeinterleave(glm::uint16 x);
+
+	/// Interleaves the bits of x and y.
+	/// The first bit is the first bit of x followed by the first bit of y.
+	/// The other bits are interleaved following the previous sequence.
+	///
+	/// @see gtc_bitfield
+	GLM_FUNC_DECL int32 bitfieldInterleave(int16 x, int16 y);
+
+	/// Interleaves the bits of x and y.
+	/// The first bit is the first bit of x followed by the first bit of y.
+	/// The other bits are interleaved following the previous sequence.
+	///
+	/// @see gtc_bitfield
+	GLM_FUNC_DECL uint32 bitfieldInterleave(uint16 x, uint16 y);
+
+	/// Interleaves the bits of x and y.
+	/// The first bit is the first bit of v.x followed by the first bit of v.y.
+	/// The other bits are interleaved following the previous sequence.
+	///
+	/// @see gtc_bitfield
+	GLM_FUNC_DECL uint32 bitfieldInterleave(u16vec2 const& v);
+
+	/// Deinterleaves the bits of x.
+	///
+	/// @see gtc_bitfield
+	GLM_FUNC_DECL glm::u16vec2 bitfieldDeinterleave(glm::uint32 x);
+
+	/// Interleaves the bits of x and y.
+	/// The first bit is the first bit of x followed by the first bit of y.
+	/// The other bits are interleaved following the previous sequence.
+	///
+	/// @see gtc_bitfield
+	GLM_FUNC_DECL int64 bitfieldInterleave(int32 x, int32 y);
+
+	/// Interleaves the bits of x and y.
+	/// The first bit is the first bit of x followed by the first bit of y.
+	/// The other bits are interleaved following the previous sequence.
+	///
+	/// @see gtc_bitfield
+	GLM_FUNC_DECL uint64 bitfieldInterleave(uint32 x, uint32 y);
+
+	/// Interleaves the bits of x and y.
+	/// The first bit is the first bit of v.x followed by the first bit of v.y.
+	/// The other bits are interleaved following the previous sequence.
+	///
+	/// @see gtc_bitfield
+	GLM_FUNC_DECL uint64 bitfieldInterleave(u32vec2 const& v);
+
+	/// Deinterleaves the bits of x.
+	///
+	/// @see gtc_bitfield
+	GLM_FUNC_DECL glm::u32vec2 bitfieldDeinterleave(glm::uint64 x);
+
+	/// Interleaves the bits of x, y and z.
+	/// The first bit is the first bit of x followed by the first bit of y and the first bit of z.
+	/// The other bits are interleaved following the previous sequence.
+	///
+	/// @see gtc_bitfield
+	GLM_FUNC_DECL int32 bitfieldInterleave(int8 x, int8 y, int8 z);
+
+	/// Interleaves the bits of x, y and z.
+	/// The first bit is the first bit of x followed by the first bit of y and the first bit of z.
+	/// The other bits are interleaved following the previous sequence.
+	///
+	/// @see gtc_bitfield
+	GLM_FUNC_DECL uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z);
+
+	/// Interleaves the bits of x, y and z.
+	/// The first bit is the first bit of x followed by the first bit of y and the first bit of z.
+	/// The other bits are interleaved following the previous sequence.
+	///
+	/// @see gtc_bitfield
+	GLM_FUNC_DECL int64 bitfieldInterleave(int16 x, int16 y, int16 z);
+
+	/// Interleaves the bits of x, y and z.
+	/// The first bit is the first bit of x followed by the first bit of y and the first bit of z.
+	/// The other bits are interleaved following the previous sequence.
+	///
+	/// @see gtc_bitfield
+	GLM_FUNC_DECL uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z);
+
+	/// Interleaves the bits of x, y and z.
+	/// The first bit is the first bit of x followed by the first bit of y and the first bit of z.
+	/// The other bits are interleaved following the previous sequence.
+	///
+	/// @see gtc_bitfield
+	GLM_FUNC_DECL int64 bitfieldInterleave(int32 x, int32 y, int32 z);
+
+	/// Interleaves the bits of x, y and z.
+	/// The first bit is the first bit of x followed by the first bit of y and the first bit of z.
+	/// The other bits are interleaved following the previous sequence.
+	///
+	/// @see gtc_bitfield
+	GLM_FUNC_DECL uint64 bitfieldInterleave(uint32 x, uint32 y, uint32 z);
+
+	/// Interleaves the bits of x, y, z and w.
+	/// The first bit is the first bit of x followed by the first bit of y, the first bit of z and finally the first bit of w.
+	/// The other bits are interleaved following the previous sequence.
+	///
+	/// @see gtc_bitfield
+	GLM_FUNC_DECL int32 bitfieldInterleave(int8 x, int8 y, int8 z, int8 w);
+
+	/// Interleaves the bits of x, y, z and w.
+	/// The first bit is the first bit of x followed by the first bit of y, the first bit of z and finally the first bit of w.
+	/// The other bits are interleaved following the previous sequence.
+	///
+	/// @see gtc_bitfield
+	GLM_FUNC_DECL uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z, uint8 w);
+
+	/// Interleaves the bits of x, y, z and w.
+	/// The first bit is the first bit of x followed by the first bit of y, the first bit of z and finally the first bit of w.
+	/// The other bits are interleaved following the previous sequence.
+	///
+	/// @see gtc_bitfield
+	GLM_FUNC_DECL int64 bitfieldInterleave(int16 x, int16 y, int16 z, int16 w);
+
+	/// Interleaves the bits of x, y, z and w.
+	/// The first bit is the first bit of x followed by the first bit of y, the first bit of z and finally the first bit of w.
+	/// The other bits are interleaved following the previous sequence.
+	///
+	/// @see gtc_bitfield
+	GLM_FUNC_DECL uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z, uint16 w);
+
+	/// @}
+} //namespace glm
+
+#include "bitfield.inl"
diff --git a/engine/inc/glm/gtc/bitfield.inl b/engine/inc/glm/gtc/bitfield.inl
new file mode 100644
index 00000000..06cf1889
--- /dev/null
+++ b/engine/inc/glm/gtc/bitfield.inl
@@ -0,0 +1,626 @@
+/// @ref gtc_bitfield
+
+#include "../simd/integer.h"
+
+namespace glm{
+namespace detail
+{
+	template<typename PARAM, typename RET>
+	GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y);
+
+	template<typename PARAM, typename RET>
+	GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y, PARAM z);
+
+	template<typename PARAM, typename RET>
+	GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y, PARAM z, PARAM w);
+
+	template<>
+	GLM_FUNC_QUALIFIER glm::uint16 bitfieldInterleave(glm::uint8 x, glm::uint8 y)
+	{
+		glm::uint16 REG1(x);
+		glm::uint16 REG2(y);
+
+		REG1 = ((REG1 <<  4) | REG1) & static_cast<glm::uint16>(0x0F0F);
+		REG2 = ((REG2 <<  4) | REG2) & static_cast<glm::uint16>(0x0F0F);
+
+		REG1 = ((REG1 <<  2) | REG1) & static_cast<glm::uint16>(0x3333);
+		REG2 = ((REG2 <<  2) | REG2) & static_cast<glm::uint16>(0x3333);
+
+		REG1 = ((REG1 <<  1) | REG1) & static_cast<glm::uint16>(0x5555);
+		REG2 = ((REG2 <<  1) | REG2) & static_cast<glm::uint16>(0x5555);
+
+		return REG1 | static_cast<glm::uint16>(REG2 << 1);
+	}
+
+	template<>
+	GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(glm::uint16 x, glm::uint16 y)
+	{
+		glm::uint32 REG1(x);
+		glm::uint32 REG2(y);
+
+		REG1 = ((REG1 <<  8) | REG1) & static_cast<glm::uint32>(0x00FF00FF);
+		REG2 = ((REG2 <<  8) | REG2) & static_cast<glm::uint32>(0x00FF00FF);
+
+		REG1 = ((REG1 <<  4) | REG1) & static_cast<glm::uint32>(0x0F0F0F0F);
+		REG2 = ((REG2 <<  4) | REG2) & static_cast<glm::uint32>(0x0F0F0F0F);
+
+		REG1 = ((REG1 <<  2) | REG1) & static_cast<glm::uint32>(0x33333333);
+		REG2 = ((REG2 <<  2) | REG2) & static_cast<glm::uint32>(0x33333333);
+
+		REG1 = ((REG1 <<  1) | REG1) & static_cast<glm::uint32>(0x55555555);
+		REG2 = ((REG2 <<  1) | REG2) & static_cast<glm::uint32>(0x55555555);
+
+		return REG1 | (REG2 << 1);
+	}
+
+	template<>
+	GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint32 x, glm::uint32 y)
+	{
+		glm::uint64 REG1(x);
+		glm::uint64 REG2(y);
+
+		REG1 = ((REG1 << 16) | REG1) & static_cast<glm::uint64>(0x0000FFFF0000FFFFull);
+		REG2 = ((REG2 << 16) | REG2) & static_cast<glm::uint64>(0x0000FFFF0000FFFFull);
+
+		REG1 = ((REG1 <<  8) | REG1) & static_cast<glm::uint64>(0x00FF00FF00FF00FFull);
+		REG2 = ((REG2 <<  8) | REG2) & static_cast<glm::uint64>(0x00FF00FF00FF00FFull);
+
+		REG1 = ((REG1 <<  4) | REG1) & static_cast<glm::uint64>(0x0F0F0F0F0F0F0F0Full);
+		REG2 = ((REG2 <<  4) | REG2) & static_cast<glm::uint64>(0x0F0F0F0F0F0F0F0Full);
+
+		REG1 = ((REG1 <<  2) | REG1) & static_cast<glm::uint64>(0x3333333333333333ull);
+		REG2 = ((REG2 <<  2) | REG2) & static_cast<glm::uint64>(0x3333333333333333ull);
+
+		REG1 = ((REG1 <<  1) | REG1) & static_cast<glm::uint64>(0x5555555555555555ull);
+		REG2 = ((REG2 <<  1) | REG2) & static_cast<glm::uint64>(0x5555555555555555ull);
+
+		return REG1 | (REG2 << 1);
+	}
+
+	template<>
+	GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(glm::uint8 x, glm::uint8 y, glm::uint8 z)
+	{
+		glm::uint32 REG1(x);
+		glm::uint32 REG2(y);
+		glm::uint32 REG3(z);
+
+		REG1 = ((REG1 << 16) | REG1) & static_cast<glm::uint32>(0xFF0000FFu);
+		REG2 = ((REG2 << 16) | REG2) & static_cast<glm::uint32>(0xFF0000FFu);
+		REG3 = ((REG3 << 16) | REG3) & static_cast<glm::uint32>(0xFF0000FFu);
+
+		REG1 = ((REG1 <<  8) | REG1) & static_cast<glm::uint32>(0x0F00F00Fu);
+		REG2 = ((REG2 <<  8) | REG2) & static_cast<glm::uint32>(0x0F00F00Fu);
+		REG3 = ((REG3 <<  8) | REG3) & static_cast<glm::uint32>(0x0F00F00Fu);
+
+		REG1 = ((REG1 <<  4) | REG1) & static_cast<glm::uint32>(0xC30C30C3u);
+		REG2 = ((REG2 <<  4) | REG2) & static_cast<glm::uint32>(0xC30C30C3u);
+		REG3 = ((REG3 <<  4) | REG3) & static_cast<glm::uint32>(0xC30C30C3u);
+
+		REG1 = ((REG1 <<  2) | REG1) & static_cast<glm::uint32>(0x49249249u);
+		REG2 = ((REG2 <<  2) | REG2) & static_cast<glm::uint32>(0x49249249u);
+		REG3 = ((REG3 <<  2) | REG3) & static_cast<glm::uint32>(0x49249249u);
+
+		return REG1 | (REG2 << 1) | (REG3 << 2);
+	}
+
+	template<>
+	GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint16 x, glm::uint16 y, glm::uint16 z)
+	{
+		glm::uint64 REG1(x);
+		glm::uint64 REG2(y);
+		glm::uint64 REG3(z);
+
+		REG1 = ((REG1 << 32) | REG1) & static_cast<glm::uint64>(0xFFFF00000000FFFFull);
+		REG2 = ((REG2 << 32) | REG2) & static_cast<glm::uint64>(0xFFFF00000000FFFFull);
+		REG3 = ((REG3 << 32) | REG3) & static_cast<glm::uint64>(0xFFFF00000000FFFFull);
+
+		REG1 = ((REG1 << 16) | REG1) & static_cast<glm::uint64>(0x00FF0000FF0000FFull);
+		REG2 = ((REG2 << 16) | REG2) & static_cast<glm::uint64>(0x00FF0000FF0000FFull);
+		REG3 = ((REG3 << 16) | REG3) & static_cast<glm::uint64>(0x00FF0000FF0000FFull);
+
+		REG1 = ((REG1 <<  8) | REG1) & static_cast<glm::uint64>(0xF00F00F00F00F00Full);
+		REG2 = ((REG2 <<  8) | REG2) & static_cast<glm::uint64>(0xF00F00F00F00F00Full);
+		REG3 = ((REG3 <<  8) | REG3) & static_cast<glm::uint64>(0xF00F00F00F00F00Full);
+
+		REG1 = ((REG1 <<  4) | REG1) & static_cast<glm::uint64>(0x30C30C30C30C30C3ull);
+		REG2 = ((REG2 <<  4) | REG2) & static_cast<glm::uint64>(0x30C30C30C30C30C3ull);
+		REG3 = ((REG3 <<  4) | REG3) & static_cast<glm::uint64>(0x30C30C30C30C30C3ull);
+
+		REG1 = ((REG1 <<  2) | REG1) & static_cast<glm::uint64>(0x9249249249249249ull);
+		REG2 = ((REG2 <<  2) | REG2) & static_cast<glm::uint64>(0x9249249249249249ull);
+		REG3 = ((REG3 <<  2) | REG3) & static_cast<glm::uint64>(0x9249249249249249ull);
+
+		return REG1 | (REG2 << 1) | (REG3 << 2);
+	}
+
+	template<>
+	GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint32 x, glm::uint32 y, glm::uint32 z)
+	{
+		glm::uint64 REG1(x);
+		glm::uint64 REG2(y);
+		glm::uint64 REG3(z);
+
+		REG1 = ((REG1 << 32) | REG1) & static_cast<glm::uint64>(0xFFFF00000000FFFFull);
+		REG2 = ((REG2 << 32) | REG2) & static_cast<glm::uint64>(0xFFFF00000000FFFFull);
+		REG3 = ((REG3 << 32) | REG3) & static_cast<glm::uint64>(0xFFFF00000000FFFFull);
+
+		REG1 = ((REG1 << 16) | REG1) & static_cast<glm::uint64>(0x00FF0000FF0000FFull);
+		REG2 = ((REG2 << 16) | REG2) & static_cast<glm::uint64>(0x00FF0000FF0000FFull);
+		REG3 = ((REG3 << 16) | REG3) & static_cast<glm::uint64>(0x00FF0000FF0000FFull);
+
+		REG1 = ((REG1 <<  8) | REG1) & static_cast<glm::uint64>(0xF00F00F00F00F00Full);
+		REG2 = ((REG2 <<  8) | REG2) & static_cast<glm::uint64>(0xF00F00F00F00F00Full);
+		REG3 = ((REG3 <<  8) | REG3) & static_cast<glm::uint64>(0xF00F00F00F00F00Full);
+
+		REG1 = ((REG1 <<  4) | REG1) & static_cast<glm::uint64>(0x30C30C30C30C30C3ull);
+		REG2 = ((REG2 <<  4) | REG2) & static_cast<glm::uint64>(0x30C30C30C30C30C3ull);
+		REG3 = ((REG3 <<  4) | REG3) & static_cast<glm::uint64>(0x30C30C30C30C30C3ull);
+
+		REG1 = ((REG1 <<  2) | REG1) & static_cast<glm::uint64>(0x9249249249249249ull);
+		REG2 = ((REG2 <<  2) | REG2) & static_cast<glm::uint64>(0x9249249249249249ull);
+		REG3 = ((REG3 <<  2) | REG3) & static_cast<glm::uint64>(0x9249249249249249ull);
+
+		return REG1 | (REG2 << 1) | (REG3 << 2);
+	}
+
+	template<>
+	GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(glm::uint8 x, glm::uint8 y, glm::uint8 z, glm::uint8 w)
+	{
+		glm::uint32 REG1(x);
+		glm::uint32 REG2(y);
+		glm::uint32 REG3(z);
+		glm::uint32 REG4(w);
+
+		REG1 = ((REG1 << 12) | REG1) & static_cast<glm::uint32>(0x000F000Fu);
+		REG2 = ((REG2 << 12) | REG2) & static_cast<glm::uint32>(0x000F000Fu);
+		REG3 = ((REG3 << 12) | REG3) & static_cast<glm::uint32>(0x000F000Fu);
+		REG4 = ((REG4 << 12) | REG4) & static_cast<glm::uint32>(0x000F000Fu);
+
+		REG1 = ((REG1 <<  6) | REG1) & static_cast<glm::uint32>(0x03030303u);
+		REG2 = ((REG2 <<  6) | REG2) & static_cast<glm::uint32>(0x03030303u);
+		REG3 = ((REG3 <<  6) | REG3) & static_cast<glm::uint32>(0x03030303u);
+		REG4 = ((REG4 <<  6) | REG4) & static_cast<glm::uint32>(0x03030303u);
+
+		REG1 = ((REG1 <<  3) | REG1) & static_cast<glm::uint32>(0x11111111u);
+		REG2 = ((REG2 <<  3) | REG2) & static_cast<glm::uint32>(0x11111111u);
+		REG3 = ((REG3 <<  3) | REG3) & static_cast<glm::uint32>(0x11111111u);
+		REG4 = ((REG4 <<  3) | REG4) & static_cast<glm::uint32>(0x11111111u);
+
+		return REG1 | (REG2 << 1) | (REG3 << 2) | (REG4 << 3);
+	}
+
+	template<>
+	GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint16 x, glm::uint16 y, glm::uint16 z, glm::uint16 w)
+	{
+		glm::uint64 REG1(x);
+		glm::uint64 REG2(y);
+		glm::uint64 REG3(z);
+		glm::uint64 REG4(w);
+
+		REG1 = ((REG1 << 24) | REG1) & static_cast<glm::uint64>(0x000000FF000000FFull);
+		REG2 = ((REG2 << 24) | REG2) & static_cast<glm::uint64>(0x000000FF000000FFull);
+		REG3 = ((REG3 << 24) | REG3) & static_cast<glm::uint64>(0x000000FF000000FFull);
+		REG4 = ((REG4 << 24) | REG4) & static_cast<glm::uint64>(0x000000FF000000FFull);
+
+		REG1 = ((REG1 << 12) | REG1) & static_cast<glm::uint64>(0x000F000F000F000Full);
+		REG2 = ((REG2 << 12) | REG2) & static_cast<glm::uint64>(0x000F000F000F000Full);
+		REG3 = ((REG3 << 12) | REG3) & static_cast<glm::uint64>(0x000F000F000F000Full);
+		REG4 = ((REG4 << 12) | REG4) & static_cast<glm::uint64>(0x000F000F000F000Full);
+
+		REG1 = ((REG1 <<  6) | REG1) & static_cast<glm::uint64>(0x0303030303030303ull);
+		REG2 = ((REG2 <<  6) | REG2) & static_cast<glm::uint64>(0x0303030303030303ull);
+		REG3 = ((REG3 <<  6) | REG3) & static_cast<glm::uint64>(0x0303030303030303ull);
+		REG4 = ((REG4 <<  6) | REG4) & static_cast<glm::uint64>(0x0303030303030303ull);
+
+		REG1 = ((REG1 <<  3) | REG1) & static_cast<glm::uint64>(0x1111111111111111ull);
+		REG2 = ((REG2 <<  3) | REG2) & static_cast<glm::uint64>(0x1111111111111111ull);
+		REG3 = ((REG3 <<  3) | REG3) & static_cast<glm::uint64>(0x1111111111111111ull);
+		REG4 = ((REG4 <<  3) | REG4) & static_cast<glm::uint64>(0x1111111111111111ull);
+
+		return REG1 | (REG2 << 1) | (REG3 << 2) | (REG4 << 3);
+	}
+}//namespace detail
+
+	template<typename genIUType>
+	GLM_FUNC_QUALIFIER genIUType mask(genIUType Bits)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'mask' accepts only integer values");
+
+		return Bits >= sizeof(genIUType) * 8 ? ~static_cast<genIUType>(0) : (static_cast<genIUType>(1) << Bits) - static_cast<genIUType>(1);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> mask(vec<L, T, Q> const& v)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'mask' accepts only integer values");
+
+		return detail::functor1<vec, L, T, T, Q>::call(mask, v);
+	}
+
+	template<typename genIType>
+	GLM_FUNC_QUALIFIER genIType bitfieldRotateRight(genIType In, int Shift)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genIType>::is_integer, "'bitfieldRotateRight' accepts only integer values");
+
+		int const BitSize = static_cast<genIType>(sizeof(genIType) * 8);
+		return (In << static_cast<genIType>(Shift)) | (In >> static_cast<genIType>(BitSize - Shift));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> bitfieldRotateRight(vec<L, T, Q> const& In, int Shift)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldRotateRight' accepts only integer values");
+
+		int const BitSize = static_cast<int>(sizeof(T) * 8);
+		return (In << static_cast<T>(Shift)) | (In >> static_cast<T>(BitSize - Shift));
+	}
+
+	template<typename genIType>
+	GLM_FUNC_QUALIFIER genIType bitfieldRotateLeft(genIType In, int Shift)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genIType>::is_integer, "'bitfieldRotateLeft' accepts only integer values");
+
+		int const BitSize = static_cast<genIType>(sizeof(genIType) * 8);
+		return (In >> static_cast<genIType>(Shift)) | (In << static_cast<genIType>(BitSize - Shift));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> bitfieldRotateLeft(vec<L, T, Q> const& In, int Shift)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldRotateLeft' accepts only integer values");
+
+		int const BitSize = static_cast<int>(sizeof(T) * 8);
+		return (In >> static_cast<T>(Shift)) | (In << static_cast<T>(BitSize - Shift));
+	}
+
+	template<typename genIUType>
+	GLM_FUNC_QUALIFIER genIUType bitfieldFillOne(genIUType Value, int FirstBit, int BitCount)
+	{
+		return Value | static_cast<genIUType>(mask(BitCount) << FirstBit);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> bitfieldFillOne(vec<L, T, Q> const& Value, int FirstBit, int BitCount)
+	{
+		return Value | static_cast<T>(mask(BitCount) << FirstBit);
+	}
+
+	template<typename genIUType>
+	GLM_FUNC_QUALIFIER genIUType bitfieldFillZero(genIUType Value, int FirstBit, int BitCount)
+	{
+		return Value & static_cast<genIUType>(~(mask(BitCount) << FirstBit));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> bitfieldFillZero(vec<L, T, Q> const& Value, int FirstBit, int BitCount)
+	{
+		return Value & static_cast<T>(~(mask(BitCount) << FirstBit));
+	}
+
+	GLM_FUNC_QUALIFIER int16 bitfieldInterleave(int8 x, int8 y)
+	{
+		union sign8
+		{
+			int8 i;
+			uint8 u;
+		} sign_x, sign_y;
+
+		union sign16
+		{
+			int16 i;
+			uint16 u;
+		} result;
+
+		sign_x.i = x;
+		sign_y.i = y;
+		result.u = bitfieldInterleave(sign_x.u, sign_y.u);
+
+		return result.i;
+	}
+
+	GLM_FUNC_QUALIFIER uint16 bitfieldInterleave(uint8 x, uint8 y)
+	{
+		return detail::bitfieldInterleave<uint8, uint16>(x, y);
+	}
+
+	GLM_FUNC_QUALIFIER uint16 bitfieldInterleave(u8vec2 const& v)
+	{
+		return detail::bitfieldInterleave<uint8, uint16>(v.x, v.y);
+	}
+
+	GLM_FUNC_QUALIFIER u8vec2 bitfieldDeinterleave(glm::uint16 x)
+	{
+		uint16 REG1(x);
+		uint16 REG2(x >>= 1);
+
+		REG1 = REG1 & static_cast<uint16>(0x5555);
+		REG2 = REG2 & static_cast<uint16>(0x5555);
+
+		REG1 = ((REG1 >> 1) | REG1) & static_cast<uint16>(0x3333);
+		REG2 = ((REG2 >> 1) | REG2) & static_cast<uint16>(0x3333);
+
+		REG1 = ((REG1 >> 2) | REG1) & static_cast<uint16>(0x0F0F);
+		REG2 = ((REG2 >> 2) | REG2) & static_cast<uint16>(0x0F0F);
+
+		REG1 = ((REG1 >> 4) | REG1) & static_cast<uint16>(0x00FF);
+		REG2 = ((REG2 >> 4) | REG2) & static_cast<uint16>(0x00FF);
+
+		REG1 = ((REG1 >> 8) | REG1) & static_cast<uint16>(0xFFFF);
+		REG2 = ((REG2 >> 8) | REG2) & static_cast<uint16>(0xFFFF);
+
+		return glm::u8vec2(REG1, REG2);
+	}
+
+	GLM_FUNC_QUALIFIER int32 bitfieldInterleave(int16 x, int16 y)
+	{
+		union sign16
+		{
+			int16 i;
+			uint16 u;
+		} sign_x, sign_y;
+
+		union sign32
+		{
+			int32 i;
+			uint32 u;
+		} result;
+
+		sign_x.i = x;
+		sign_y.i = y;
+		result.u = bitfieldInterleave(sign_x.u, sign_y.u);
+
+		return result.i;
+	}
+
+	GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(uint16 x, uint16 y)
+	{
+		return detail::bitfieldInterleave<uint16, uint32>(x, y);
+	}
+
+	GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(u16vec2 const& v)
+	{
+		return detail::bitfieldInterleave<uint16, uint32>(v.x, v.y);
+	}
+
+	GLM_FUNC_QUALIFIER glm::u16vec2 bitfieldDeinterleave(glm::uint32 x)
+	{
+		glm::uint32 REG1(x);
+		glm::uint32 REG2(x >>= 1);
+
+		REG1 = REG1 & static_cast<glm::uint32>(0x55555555);
+		REG2 = REG2 & static_cast<glm::uint32>(0x55555555);
+
+		REG1 = ((REG1 >> 1) | REG1) & static_cast<glm::uint32>(0x33333333);
+		REG2 = ((REG2 >> 1) | REG2) & static_cast<glm::uint32>(0x33333333);
+
+		REG1 = ((REG1 >> 2) | REG1) & static_cast<glm::uint32>(0x0F0F0F0F);
+		REG2 = ((REG2 >> 2) | REG2) & static_cast<glm::uint32>(0x0F0F0F0F);
+
+		REG1 = ((REG1 >> 4) | REG1) & static_cast<glm::uint32>(0x00FF00FF);
+		REG2 = ((REG2 >> 4) | REG2) & static_cast<glm::uint32>(0x00FF00FF);
+
+		REG1 = ((REG1 >> 8) | REG1) & static_cast<glm::uint32>(0x0000FFFF);
+		REG2 = ((REG2 >> 8) | REG2) & static_cast<glm::uint32>(0x0000FFFF);
+
+		return glm::u16vec2(REG1, REG2);
+	}
+
+	GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int32 x, int32 y)
+	{
+		union sign32
+		{
+			int32 i;
+			uint32 u;
+		} sign_x, sign_y;
+
+		union sign64
+		{
+			int64 i;
+			uint64 u;
+		} result;
+
+		sign_x.i = x;
+		sign_y.i = y;
+		result.u = bitfieldInterleave(sign_x.u, sign_y.u);
+
+		return result.i;
+	}
+
+	GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint32 x, uint32 y)
+	{
+		return detail::bitfieldInterleave<uint32, uint64>(x, y);
+	}
+
+	GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(u32vec2 const& v)
+	{
+		return detail::bitfieldInterleave<uint32, uint64>(v.x, v.y);
+	}
+
+	GLM_FUNC_QUALIFIER glm::u32vec2 bitfieldDeinterleave(glm::uint64 x)
+	{
+		glm::uint64 REG1(x);
+		glm::uint64 REG2(x >>= 1);
+
+		REG1 = REG1 & static_cast<glm::uint64>(0x5555555555555555ull);
+		REG2 = REG2 & static_cast<glm::uint64>(0x5555555555555555ull);
+
+		REG1 = ((REG1 >> 1) | REG1) & static_cast<glm::uint64>(0x3333333333333333ull);
+		REG2 = ((REG2 >> 1) | REG2) & static_cast<glm::uint64>(0x3333333333333333ull);
+
+		REG1 = ((REG1 >> 2) | REG1) & static_cast<glm::uint64>(0x0F0F0F0F0F0F0F0Full);
+		REG2 = ((REG2 >> 2) | REG2) & static_cast<glm::uint64>(0x0F0F0F0F0F0F0F0Full);
+
+		REG1 = ((REG1 >> 4) | REG1) & static_cast<glm::uint64>(0x00FF00FF00FF00FFull);
+		REG2 = ((REG2 >> 4) | REG2) & static_cast<glm::uint64>(0x00FF00FF00FF00FFull);
+
+		REG1 = ((REG1 >> 8) | REG1) & static_cast<glm::uint64>(0x0000FFFF0000FFFFull);
+		REG2 = ((REG2 >> 8) | REG2) & static_cast<glm::uint64>(0x0000FFFF0000FFFFull);
+
+		REG1 = ((REG1 >> 16) | REG1) & static_cast<glm::uint64>(0x00000000FFFFFFFFull);
+		REG2 = ((REG2 >> 16) | REG2) & static_cast<glm::uint64>(0x00000000FFFFFFFFull);
+
+		return glm::u32vec2(REG1, REG2);
+	}
+
+	GLM_FUNC_QUALIFIER int32 bitfieldInterleave(int8 x, int8 y, int8 z)
+	{
+		union sign8
+		{
+			int8 i;
+			uint8 u;
+		} sign_x, sign_y, sign_z;
+
+		union sign32
+		{
+			int32 i;
+			uint32 u;
+		} result;
+
+		sign_x.i = x;
+		sign_y.i = y;
+		sign_z.i = z;
+		result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u);
+
+		return result.i;
+	}
+
+	GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z)
+	{
+		return detail::bitfieldInterleave<uint8, uint32>(x, y, z);
+	}
+
+	GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(u8vec3 const& v)
+	{
+		return detail::bitfieldInterleave<uint8, uint32>(v.x, v.y, v.z);
+	}
+
+	GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int16 x, int16 y, int16 z)
+	{
+		union sign16
+		{
+			int16 i;
+			uint16 u;
+		} sign_x, sign_y, sign_z;
+
+		union sign64
+		{
+			int64 i;
+			uint64 u;
+		} result;
+
+		sign_x.i = x;
+		sign_y.i = y;
+		sign_z.i = z;
+		result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u);
+
+		return result.i;
+	}
+
+	GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z)
+	{
+		return detail::bitfieldInterleave<uint32, uint64>(x, y, z);
+	}
+
+	GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(u16vec3 const& v)
+	{
+		return detail::bitfieldInterleave<uint32, uint64>(v.x, v.y, v.z);
+	}
+
+	GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int32 x, int32 y, int32 z)
+	{
+		union sign16
+		{
+			int32 i;
+			uint32 u;
+		} sign_x, sign_y, sign_z;
+
+		union sign64
+		{
+			int64 i;
+			uint64 u;
+		} result;
+
+		sign_x.i = x;
+		sign_y.i = y;
+		sign_z.i = z;
+		result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u);
+
+		return result.i;
+	}
+
+	GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint32 x, uint32 y, uint32 z)
+	{
+		return detail::bitfieldInterleave<uint32, uint64>(x, y, z);
+	}
+
+	GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(u32vec3 const& v)
+	{
+		return detail::bitfieldInterleave<uint32, uint64>(v.x, v.y, v.z);
+	}
+
+	GLM_FUNC_QUALIFIER int32 bitfieldInterleave(int8 x, int8 y, int8 z, int8 w)
+	{
+		union sign8
+		{
+			int8 i;
+			uint8 u;
+		} sign_x, sign_y, sign_z, sign_w;
+
+		union sign32
+		{
+			int32 i;
+			uint32 u;
+		} result;
+
+		sign_x.i = x;
+		sign_y.i = y;
+		sign_z.i = z;
+		sign_w.i = w;
+		result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u, sign_w.u);
+
+		return result.i;
+	}
+
+	GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z, uint8 w)
+	{
+		return detail::bitfieldInterleave<uint8, uint32>(x, y, z, w);
+	}
+
+	GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(u8vec4 const& v)
+	{
+		return detail::bitfieldInterleave<uint8, uint32>(v.x, v.y, v.z, v.w);
+	}
+
+	GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int16 x, int16 y, int16 z, int16 w)
+	{
+		union sign16
+		{
+			int16 i;
+			uint16 u;
+		} sign_x, sign_y, sign_z, sign_w;
+
+		union sign64
+		{
+			int64 i;
+			uint64 u;
+		} result;
+
+		sign_x.i = x;
+		sign_y.i = y;
+		sign_z.i = z;
+		sign_w.i = w;
+		result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u, sign_w.u);
+
+		return result.i;
+	}
+
+	GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z, uint16 w)
+	{
+		return detail::bitfieldInterleave<uint16, uint64>(x, y, z, w);
+	}
+
+	GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(u16vec4 const& v)
+	{
+		return detail::bitfieldInterleave<uint16, uint64>(v.x, v.y, v.z, v.w);
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtc/color_space.hpp b/engine/inc/glm/gtc/color_space.hpp
new file mode 100644
index 00000000..cffd9f09
--- /dev/null
+++ b/engine/inc/glm/gtc/color_space.hpp
@@ -0,0 +1,56 @@
+/// @ref gtc_color_space
+/// @file glm/gtc/color_space.hpp
+///
+/// @see core (dependence)
+/// @see gtc_color_space (dependence)
+///
+/// @defgroup gtc_color_space GLM_GTC_color_space
+/// @ingroup gtc
+///
+/// Include <glm/gtc/color_space.hpp> to use the features of this extension.
+///
+/// Allow to perform bit operations on integer values
+
+#pragma once
+
+// Dependencies
+#include "../detail/setup.hpp"
+#include "../detail/qualifier.hpp"
+#include "../exponential.hpp"
+#include "../vec3.hpp"
+#include "../vec4.hpp"
+#include <limits>
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTC_color_space extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtc_color_space
+	/// @{
+
+	/// Convert a linear color to sRGB color using a standard gamma correction.
+	/// IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> convertLinearToSRGB(vec<L, T, Q> const& ColorLinear);
+
+	/// Convert a linear color to sRGB color using a custom gamma correction.
+	/// IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> convertLinearToSRGB(vec<L, T, Q> const& ColorLinear, T Gamma);
+
+	/// Convert a sRGB color to linear color using a standard gamma correction.
+	/// IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> convertSRGBToLinear(vec<L, T, Q> const& ColorSRGB);
+
+	/// Convert a sRGB color to linear color using a custom gamma correction.
+	// IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> convertSRGBToLinear(vec<L, T, Q> const& ColorSRGB, T Gamma);
+
+	/// @}
+} //namespace glm
+
+#include "color_space.inl"
diff --git a/engine/inc/glm/gtc/color_space.inl b/engine/inc/glm/gtc/color_space.inl
new file mode 100644
index 00000000..2a900044
--- /dev/null
+++ b/engine/inc/glm/gtc/color_space.inl
@@ -0,0 +1,84 @@
+/// @ref gtc_color_space
+
+namespace glm{
+namespace detail
+{
+	template<length_t L, typename T, qualifier Q>
+	struct compute_rgbToSrgb
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& ColorRGB, T GammaCorrection)
+		{
+			vec<L, T, Q> const ClampedColor(clamp(ColorRGB, static_cast<T>(0), static_cast<T>(1)));
+
+			return mix(
+				pow(ClampedColor, vec<L, T, Q>(GammaCorrection)) * static_cast<T>(1.055) - static_cast<T>(0.055),
+				ClampedColor * static_cast<T>(12.92),
+				lessThan(ClampedColor, vec<L, T, Q>(static_cast<T>(0.0031308))));
+		}
+	};
+
+	template<typename T, qualifier Q>
+	struct compute_rgbToSrgb<4, T, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, T, Q> call(vec<4, T, Q> const& ColorRGB, T GammaCorrection)
+		{
+			return vec<4, T, Q>(compute_rgbToSrgb<3, T, Q>::call(vec<3, T, Q>(ColorRGB), GammaCorrection), ColorRGB.w);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q>
+	struct compute_srgbToRgb
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& ColorSRGB, T Gamma)
+		{
+			return mix(
+				pow((ColorSRGB + static_cast<T>(0.055)) * static_cast<T>(0.94786729857819905213270142180095), vec<L, T, Q>(Gamma)),
+				ColorSRGB * static_cast<T>(0.07739938080495356037151702786378),
+				lessThanEqual(ColorSRGB, vec<L, T, Q>(static_cast<T>(0.04045))));
+		}
+	};
+
+	template<typename T, qualifier Q>
+	struct compute_srgbToRgb<4, T, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, T, Q> call(vec<4, T, Q> const& ColorSRGB, T Gamma)
+		{
+			return vec<4, T, Q>(compute_srgbToRgb<3, T, Q>::call(vec<3, T, Q>(ColorSRGB), Gamma), ColorSRGB.w);
+		}
+	};
+}//namespace detail
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> convertLinearToSRGB(vec<L, T, Q> const& ColorLinear)
+	{
+		return detail::compute_rgbToSrgb<L, T, Q>::call(ColorLinear, static_cast<T>(0.41666));
+	}
+
+	// Based on Ian Taylor http://chilliant.blogspot.fr/2012/08/srgb-approximations-for-hlsl.html
+	template<>
+	GLM_FUNC_QUALIFIER vec<3, float, lowp> convertLinearToSRGB(vec<3, float, lowp> const& ColorLinear)
+	{
+		vec<3, float, lowp> S1 = sqrt(ColorLinear);
+		vec<3, float, lowp> S2 = sqrt(S1);
+		vec<3, float, lowp> S3 = sqrt(S2);
+		return 0.662002687f * S1 + 0.684122060f * S2 - 0.323583601f * S3 - 0.0225411470f * ColorLinear;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> convertLinearToSRGB(vec<L, T, Q> const& ColorLinear, T Gamma)
+	{
+		return detail::compute_rgbToSrgb<L, T, Q>::call(ColorLinear, static_cast<T>(1) / Gamma);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> convertSRGBToLinear(vec<L, T, Q> const& ColorSRGB)
+	{
+		return detail::compute_srgbToRgb<L, T, Q>::call(ColorSRGB, static_cast<T>(2.4));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> convertSRGBToLinear(vec<L, T, Q> const& ColorSRGB, T Gamma)
+	{
+		return detail::compute_srgbToRgb<L, T, Q>::call(ColorSRGB, Gamma);
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtc/constants.hpp b/engine/inc/glm/gtc/constants.hpp
new file mode 100644
index 00000000..99f21286
--- /dev/null
+++ b/engine/inc/glm/gtc/constants.hpp
@@ -0,0 +1,165 @@
+/// @ref gtc_constants
+/// @file glm/gtc/constants.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtc_constants GLM_GTC_constants
+/// @ingroup gtc
+///
+/// Include <glm/gtc/constants.hpp> to use the features of this extension.
+///
+/// Provide a list of constants and precomputed useful values.
+
+#pragma once
+
+// Dependencies
+#include "../ext/scalar_constants.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTC_constants extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtc_constants
+	/// @{
+
+	/// Return 0.
+	/// @see gtc_constants
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType zero();
+
+	/// Return 1.
+	/// @see gtc_constants
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType one();
+
+	/// Return pi * 2.
+	/// @see gtc_constants
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType two_pi();
+
+	/// Return square root of pi.
+	/// @see gtc_constants
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType root_pi();
+
+	/// Return pi / 2.
+	/// @see gtc_constants
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType half_pi();
+
+	/// Return pi / 2 * 3.
+	/// @see gtc_constants
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType three_over_two_pi();
+
+	/// Return pi / 4.
+	/// @see gtc_constants
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType quarter_pi();
+
+	/// Return 1 / pi.
+	/// @see gtc_constants
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType one_over_pi();
+
+	/// Return 1 / (pi * 2).
+	/// @see gtc_constants
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType one_over_two_pi();
+
+	/// Return 2 / pi.
+	/// @see gtc_constants
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType two_over_pi();
+
+	/// Return 4 / pi.
+	/// @see gtc_constants
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType four_over_pi();
+
+	/// Return 2 / sqrt(pi).
+	/// @see gtc_constants
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType two_over_root_pi();
+
+	/// Return 1 / sqrt(2).
+	/// @see gtc_constants
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType one_over_root_two();
+
+	/// Return sqrt(pi / 2).
+	/// @see gtc_constants
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType root_half_pi();
+
+	/// Return sqrt(2 * pi).
+	/// @see gtc_constants
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType root_two_pi();
+
+	/// Return sqrt(ln(4)).
+	/// @see gtc_constants
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType root_ln_four();
+
+	/// Return e constant.
+	/// @see gtc_constants
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType e();
+
+	/// Return Euler's constant.
+	/// @see gtc_constants
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType euler();
+
+	/// Return sqrt(2).
+	/// @see gtc_constants
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType root_two();
+
+	/// Return sqrt(3).
+	/// @see gtc_constants
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType root_three();
+
+	/// Return sqrt(5).
+	/// @see gtc_constants
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType root_five();
+
+	/// Return ln(2).
+	/// @see gtc_constants
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType ln_two();
+
+	/// Return ln(10).
+	/// @see gtc_constants
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType ln_ten();
+
+	/// Return ln(ln(2)).
+	/// @see gtc_constants
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType ln_ln_two();
+
+	/// Return 1 / 3.
+	/// @see gtc_constants
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType third();
+
+	/// Return 2 / 3.
+	/// @see gtc_constants
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType two_thirds();
+
+	/// Return the golden ratio constant.
+	/// @see gtc_constants
+	template<typename genType>
+	GLM_FUNC_DECL GLM_CONSTEXPR genType golden_ratio();
+
+	/// @}
+} //namespace glm
+
+#include "constants.inl"
diff --git a/engine/inc/glm/gtc/constants.inl b/engine/inc/glm/gtc/constants.inl
new file mode 100644
index 00000000..87f5c860
--- /dev/null
+++ b/engine/inc/glm/gtc/constants.inl
@@ -0,0 +1,166 @@
+/// @ref gtc_constants
+
+namespace glm
+{
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType zero()
+	{
+		return genType(0);
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType one()
+	{
+		return genType(1);
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType two_pi()
+	{
+		return genType(6.28318530717958647692528676655900576);
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_pi()
+	{
+		return genType(1.772453850905516027);
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType half_pi()
+	{
+		return genType(1.57079632679489661923132169163975144);
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType three_over_two_pi()
+	{
+		return genType(4.71238898038468985769396507491925432);
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType quarter_pi()
+	{
+		return genType(0.785398163397448309615660845819875721);
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType one_over_pi()
+	{
+		return genType(0.318309886183790671537767526745028724);
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType one_over_two_pi()
+	{
+		return genType(0.159154943091895335768883763372514362);
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType two_over_pi()
+	{
+		return genType(0.636619772367581343075535053490057448);
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType four_over_pi()
+	{
+		return genType(1.273239544735162686151070106980114898);
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType two_over_root_pi()
+	{
+		return genType(1.12837916709551257389615890312154517);
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType one_over_root_two()
+	{
+		return genType(0.707106781186547524400844362104849039);
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_half_pi()
+	{
+		return genType(1.253314137315500251);
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_two_pi()
+	{
+		return genType(2.506628274631000502);
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_ln_four()
+	{
+		return genType(1.17741002251547469);
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType e()
+	{
+		return genType(2.71828182845904523536);
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType euler()
+	{
+		return genType(0.577215664901532860606);
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_two()
+	{
+		return genType(1.41421356237309504880168872420969808);
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_three()
+	{
+		return genType(1.73205080756887729352744634150587236);
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_five()
+	{
+		return genType(2.23606797749978969640917366873127623);
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType ln_two()
+	{
+		return genType(0.693147180559945309417232121458176568);
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType ln_ten()
+	{
+		return genType(2.30258509299404568401799145468436421);
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType ln_ln_two()
+	{
+		return genType(-0.3665129205816643);
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType third()
+	{
+		return genType(0.3333333333333333333333333333333333333333);
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType two_thirds()
+	{
+		return genType(0.666666666666666666666666666666666666667);
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType golden_ratio()
+	{
+		return genType(1.61803398874989484820458683436563811);
+	}
+} //namespace glm
diff --git a/engine/inc/glm/gtc/epsilon.hpp b/engine/inc/glm/gtc/epsilon.hpp
new file mode 100644
index 00000000..640439b1
--- /dev/null
+++ b/engine/inc/glm/gtc/epsilon.hpp
@@ -0,0 +1,60 @@
+/// @ref gtc_epsilon
+/// @file glm/gtc/epsilon.hpp
+///
+/// @see core (dependence)
+/// @see gtc_quaternion (dependence)
+///
+/// @defgroup gtc_epsilon GLM_GTC_epsilon
+/// @ingroup gtc
+///
+/// Include <glm/gtc/epsilon.hpp> to use the features of this extension.
+///
+/// Comparison functions for a user defined epsilon values.
+
+#pragma once
+
+// Dependencies
+#include "../detail/setup.hpp"
+#include "../detail/qualifier.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTC_epsilon extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtc_epsilon
+	/// @{
+
+	/// Returns the component-wise comparison of |x - y| < epsilon.
+	/// True if this expression is satisfied.
+	///
+	/// @see gtc_epsilon
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, bool, Q> epsilonEqual(vec<L, T, Q> const& x, vec<L, T, Q> const& y, T const& epsilon);
+
+	/// Returns the component-wise comparison of |x - y| < epsilon.
+	/// True if this expression is satisfied.
+	///
+	/// @see gtc_epsilon
+	template<typename genType>
+	GLM_FUNC_DECL bool epsilonEqual(genType const& x, genType const& y, genType const& epsilon);
+
+	/// Returns the component-wise comparison of |x - y| < epsilon.
+	/// True if this expression is not satisfied.
+	///
+	/// @see gtc_epsilon
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, bool, Q> epsilonNotEqual(vec<L, T, Q> const& x, vec<L, T, Q> const& y, T const& epsilon);
+
+	/// Returns the component-wise comparison of |x - y| >= epsilon.
+	/// True if this expression is not satisfied.
+	///
+	/// @see gtc_epsilon
+	template<typename genType>
+	GLM_FUNC_DECL bool epsilonNotEqual(genType const& x, genType const& y, genType const& epsilon);
+
+	/// @}
+}//namespace glm
+
+#include "epsilon.inl"
diff --git a/engine/inc/glm/gtc/epsilon.inl b/engine/inc/glm/gtc/epsilon.inl
new file mode 100644
index 00000000..508b9f89
--- /dev/null
+++ b/engine/inc/glm/gtc/epsilon.inl
@@ -0,0 +1,80 @@
+/// @ref gtc_epsilon
+
+// Dependency:
+#include "../vector_relational.hpp"
+#include "../common.hpp"
+
+namespace glm
+{
+	template<>
+	GLM_FUNC_QUALIFIER bool epsilonEqual
+	(
+		float const& x,
+		float const& y,
+		float const& epsilon
+	)
+	{
+		return abs(x - y) < epsilon;
+	}
+
+	template<>
+	GLM_FUNC_QUALIFIER bool epsilonEqual
+	(
+		double const& x,
+		double const& y,
+		double const& epsilon
+	)
+	{
+		return abs(x - y) < epsilon;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, bool, Q> epsilonEqual(vec<L, T, Q> const& x, vec<L, T, Q> const& y, T const& epsilon)
+	{
+		return lessThan(abs(x - y), vec<L, T, Q>(epsilon));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, bool, Q> epsilonEqual(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, T, Q> const& epsilon)
+	{
+		return lessThan(abs(x - y), vec<L, T, Q>(epsilon));
+	}
+
+	template<>
+	GLM_FUNC_QUALIFIER bool epsilonNotEqual(float const& x, float const& y, float const& epsilon)
+	{
+		return abs(x - y) >= epsilon;
+	}
+
+	template<>
+	GLM_FUNC_QUALIFIER bool epsilonNotEqual(double const& x, double const& y, double const& epsilon)
+	{
+		return abs(x - y) >= epsilon;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, bool, Q> epsilonNotEqual(vec<L, T, Q> const& x, vec<L, T, Q> const& y, T const& epsilon)
+	{
+		return greaterThanEqual(abs(x - y), vec<L, T, Q>(epsilon));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, bool, Q> epsilonNotEqual(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, T, Q> const& epsilon)
+	{
+		return greaterThanEqual(abs(x - y), vec<L, T, Q>(epsilon));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, bool, Q> epsilonEqual(qua<T, Q> const& x, qua<T, Q> const& y, T const& epsilon)
+	{
+		vec<4, T, Q> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w);
+		return lessThan(abs(v), vec<4, T, Q>(epsilon));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, bool, Q> epsilonNotEqual(qua<T, Q> const& x, qua<T, Q> const& y, T const& epsilon)
+	{
+		vec<4, T, Q> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w);
+		return greaterThanEqual(abs(v), vec<4, T, Q>(epsilon));
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtc/integer.hpp b/engine/inc/glm/gtc/integer.hpp
new file mode 100644
index 00000000..4c3f28f6
--- /dev/null
+++ b/engine/inc/glm/gtc/integer.hpp
@@ -0,0 +1,65 @@
+/// @ref gtc_integer
+/// @file glm/gtc/integer.hpp
+///
+/// @see core (dependence)
+/// @see gtc_integer (dependence)
+///
+/// @defgroup gtc_integer GLM_GTC_integer
+/// @ingroup gtc
+///
+/// Include <glm/gtc/integer.hpp> to use the features of this extension.
+///
+/// @brief Allow to perform bit operations on integer values
+
+#pragma once
+
+// Dependencies
+#include "../detail/setup.hpp"
+#include "../detail/qualifier.hpp"
+#include "../common.hpp"
+#include "../integer.hpp"
+#include "../exponential.hpp"
+#include <limits>
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTC_integer extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtc_integer
+	/// @{
+
+	/// Returns the log2 of x for integer values. Can be reliably using to compute mipmap count from the texture size.
+	/// @see gtc_integer
+	template<typename genIUType>
+	GLM_FUNC_DECL genIUType log2(genIUType x);
+
+	/// Returns a value equal to the nearest integer to x.
+	/// The fraction 0.5 will round in a direction chosen by the
+	/// implementation, presumably the direction that is fastest.
+	///
+	/// @param x The values of the argument must be greater or equal to zero.
+	/// @tparam T floating point scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/round.xml">GLSL round man page</a>
+	/// @see gtc_integer
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, int, Q> iround(vec<L, T, Q> const& x);
+
+	/// Returns a value equal to the nearest integer to x.
+	/// The fraction 0.5 will round in a direction chosen by the
+	/// implementation, presumably the direction that is fastest.
+	///
+	/// @param x The values of the argument must be greater or equal to zero.
+	/// @tparam T floating point scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/round.xml">GLSL round man page</a>
+	/// @see gtc_integer
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, uint, Q> uround(vec<L, T, Q> const& x);
+
+	/// @}
+} //namespace glm
+
+#include "integer.inl"
diff --git a/engine/inc/glm/gtc/integer.inl b/engine/inc/glm/gtc/integer.inl
new file mode 100644
index 00000000..f0a8b4f2
--- /dev/null
+++ b/engine/inc/glm/gtc/integer.inl
@@ -0,0 +1,68 @@
+/// @ref gtc_integer
+
+namespace glm{
+namespace detail
+{
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_log2<L, T, Q, false, Aligned>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& v)
+		{
+			//Equivalent to return findMSB(vec); but save one function call in ASM with VC
+			//return findMSB(vec);
+			return vec<L, T, Q>(detail::compute_findMSB_vec<L, T, Q, sizeof(T) * 8>::call(v));
+		}
+	};
+
+#	if GLM_HAS_BITSCAN_WINDOWS
+		template<qualifier Q, bool Aligned>
+		struct compute_log2<4, int, Q, false, Aligned>
+		{
+			GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& v)
+			{
+				vec<4, int, Q> Result;
+				_BitScanReverse(reinterpret_cast<unsigned long*>(&Result.x), v.x);
+				_BitScanReverse(reinterpret_cast<unsigned long*>(&Result.y), v.y);
+				_BitScanReverse(reinterpret_cast<unsigned long*>(&Result.z), v.z);
+				_BitScanReverse(reinterpret_cast<unsigned long*>(&Result.w), v.w);
+				return Result;
+			}
+		};
+#	endif//GLM_HAS_BITSCAN_WINDOWS
+}//namespace detail
+	template<typename genType>
+	GLM_FUNC_QUALIFIER int iround(genType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'iround' only accept floating-point inputs");
+		assert(static_cast<genType>(0.0) <= x);
+
+		return static_cast<int>(x + static_cast<genType>(0.5));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, int, Q> iround(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'iround' only accept floating-point inputs");
+		assert(all(lessThanEqual(vec<L, T, Q>(0), x)));
+
+		return vec<L, int, Q>(x + static_cast<T>(0.5));
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER uint uround(genType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'uround' only accept floating-point inputs");
+		assert(static_cast<genType>(0.0) <= x);
+
+		return static_cast<uint>(x + static_cast<genType>(0.5));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, uint, Q> uround(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'uround' only accept floating-point inputs");
+		assert(all(lessThanEqual(vec<L, T, Q>(0), x)));
+
+		return vec<L, uint, Q>(x + static_cast<T>(0.5));
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtc/matrix_access.hpp b/engine/inc/glm/gtc/matrix_access.hpp
new file mode 100644
index 00000000..4935ba75
--- /dev/null
+++ b/engine/inc/glm/gtc/matrix_access.hpp
@@ -0,0 +1,60 @@
+/// @ref gtc_matrix_access
+/// @file glm/gtc/matrix_access.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtc_matrix_access GLM_GTC_matrix_access
+/// @ingroup gtc
+///
+/// Include <glm/gtc/matrix_access.hpp> to use the features of this extension.
+///
+/// Defines functions to access rows or columns of a matrix easily.
+
+#pragma once
+
+// Dependency:
+#include "../detail/setup.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTC_matrix_access extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtc_matrix_access
+	/// @{
+
+	/// Get a specific row of a matrix.
+	/// @see gtc_matrix_access
+	template<typename genType>
+	GLM_FUNC_DECL typename genType::row_type row(
+		genType const& m,
+		length_t index);
+
+	/// Set a specific row to a matrix.
+	/// @see gtc_matrix_access
+	template<typename genType>
+	GLM_FUNC_DECL genType row(
+		genType const& m,
+		length_t index,
+		typename genType::row_type const& x);
+
+	/// Get a specific column of a matrix.
+	/// @see gtc_matrix_access
+	template<typename genType>
+	GLM_FUNC_DECL typename genType::col_type column(
+		genType const& m,
+		length_t index);
+
+	/// Set a specific column to a matrix.
+	/// @see gtc_matrix_access
+	template<typename genType>
+	GLM_FUNC_DECL genType column(
+		genType const& m,
+		length_t index,
+		typename genType::col_type const& x);
+
+	/// @}
+}//namespace glm
+
+#include "matrix_access.inl"
diff --git a/engine/inc/glm/gtc/matrix_access.inl b/engine/inc/glm/gtc/matrix_access.inl
new file mode 100644
index 00000000..09fcc10d
--- /dev/null
+++ b/engine/inc/glm/gtc/matrix_access.inl
@@ -0,0 +1,62 @@
+/// @ref gtc_matrix_access
+
+namespace glm
+{
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType row
+	(
+		genType const& m,
+		length_t index,
+		typename genType::row_type const& x
+	)
+	{
+		assert(index >= 0 && index < m[0].length());
+
+		genType Result = m;
+		for(length_t i = 0; i < m.length(); ++i)
+			Result[i][index] = x[i];
+		return Result;
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER typename genType::row_type row
+	(
+		genType const& m,
+		length_t index
+	)
+	{
+		assert(index >= 0 && index < m[0].length());
+
+		typename genType::row_type Result(0);
+		for(length_t i = 0; i < m.length(); ++i)
+			Result[i] = m[i][index];
+		return Result;
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType column
+	(
+		genType const& m,
+		length_t index,
+		typename genType::col_type const& x
+	)
+	{
+		assert(index >= 0 && index < m.length());
+
+		genType Result = m;
+		Result[index] = x;
+		return Result;
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER typename genType::col_type column
+	(
+		genType const& m,
+		length_t index
+	)
+	{
+		assert(index >= 0 && index < m.length());
+
+		return m[index];
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtc/matrix_integer.hpp b/engine/inc/glm/gtc/matrix_integer.hpp
new file mode 100644
index 00000000..557a9775
--- /dev/null
+++ b/engine/inc/glm/gtc/matrix_integer.hpp
@@ -0,0 +1,487 @@
+/// @ref gtc_matrix_integer
+/// @file glm/gtc/matrix_integer.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtc_matrix_integer GLM_GTC_matrix_integer
+/// @ingroup gtc
+///
+/// Include <glm/gtc/matrix_integer.hpp> to use the features of this extension.
+///
+/// Defines a number of matrices with integer types.
+
+#pragma once
+
+// Dependency:
+#include "../mat2x2.hpp"
+#include "../mat2x3.hpp"
+#include "../mat2x4.hpp"
+#include "../mat3x2.hpp"
+#include "../mat3x3.hpp"
+#include "../mat3x4.hpp"
+#include "../mat4x2.hpp"
+#include "../mat4x3.hpp"
+#include "../mat4x4.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTC_matrix_integer extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtc_matrix_integer
+	/// @{
+
+	/// High-qualifier signed integer 2x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<2, 2, int, highp>				highp_imat2;
+
+	/// High-qualifier signed integer 3x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<3, 3, int, highp>				highp_imat3;
+
+	/// High-qualifier signed integer 4x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<4, 4, int, highp>				highp_imat4;
+
+	/// High-qualifier signed integer 2x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<2, 2, int, highp>				highp_imat2x2;
+
+	/// High-qualifier signed integer 2x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<2, 3, int, highp>				highp_imat2x3;
+
+	/// High-qualifier signed integer 2x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<2, 4, int, highp>				highp_imat2x4;
+
+	/// High-qualifier signed integer 3x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<3, 2, int, highp>				highp_imat3x2;
+
+	/// High-qualifier signed integer 3x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<3, 3, int, highp>				highp_imat3x3;
+
+	/// High-qualifier signed integer 3x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<3, 4, int, highp>				highp_imat3x4;
+
+	/// High-qualifier signed integer 4x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<4, 2, int, highp>				highp_imat4x2;
+
+	/// High-qualifier signed integer 4x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<4, 3, int, highp>				highp_imat4x3;
+
+	/// High-qualifier signed integer 4x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<4, 4, int, highp>				highp_imat4x4;
+
+
+	/// Medium-qualifier signed integer 2x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<2, 2, int, mediump>			mediump_imat2;
+
+	/// Medium-qualifier signed integer 3x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<3, 3, int, mediump>			mediump_imat3;
+
+	/// Medium-qualifier signed integer 4x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<4, 4, int, mediump>			mediump_imat4;
+
+
+	/// Medium-qualifier signed integer 2x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<2, 2, int, mediump>			mediump_imat2x2;
+
+	/// Medium-qualifier signed integer 2x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<2, 3, int, mediump>			mediump_imat2x3;
+
+	/// Medium-qualifier signed integer 2x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<2, 4, int, mediump>			mediump_imat2x4;
+
+	/// Medium-qualifier signed integer 3x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<3, 2, int, mediump>			mediump_imat3x2;
+
+	/// Medium-qualifier signed integer 3x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<3, 3, int, mediump>			mediump_imat3x3;
+
+	/// Medium-qualifier signed integer 3x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<3, 4, int, mediump>			mediump_imat3x4;
+
+	/// Medium-qualifier signed integer 4x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<4, 2, int, mediump>			mediump_imat4x2;
+
+	/// Medium-qualifier signed integer 4x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<4, 3, int, mediump>			mediump_imat4x3;
+
+	/// Medium-qualifier signed integer 4x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<4, 4, int, mediump>			mediump_imat4x4;
+
+
+	/// Low-qualifier signed integer 2x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<2, 2, int, lowp>				lowp_imat2;
+
+	/// Low-qualifier signed integer 3x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<3, 3, int, lowp>				lowp_imat3;
+
+	/// Low-qualifier signed integer 4x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<4, 4, int, lowp>				lowp_imat4;
+
+
+	/// Low-qualifier signed integer 2x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<2, 2, int, lowp>				lowp_imat2x2;
+
+	/// Low-qualifier signed integer 2x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<2, 3, int, lowp>				lowp_imat2x3;
+
+	/// Low-qualifier signed integer 2x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<2, 4, int, lowp>				lowp_imat2x4;
+
+	/// Low-qualifier signed integer 3x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<3, 2, int, lowp>				lowp_imat3x2;
+
+	/// Low-qualifier signed integer 3x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<3, 3, int, lowp>				lowp_imat3x3;
+
+	/// Low-qualifier signed integer 3x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<3, 4, int, lowp>				lowp_imat3x4;
+
+	/// Low-qualifier signed integer 4x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<4, 2, int, lowp>				lowp_imat4x2;
+
+	/// Low-qualifier signed integer 4x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<4, 3, int, lowp>				lowp_imat4x3;
+
+	/// Low-qualifier signed integer 4x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<4, 4, int, lowp>				lowp_imat4x4;
+
+
+	/// High-qualifier unsigned integer 2x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<2, 2, uint, highp>				highp_umat2;
+
+	/// High-qualifier unsigned integer 3x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<3, 3, uint, highp>				highp_umat3;
+
+	/// High-qualifier unsigned integer 4x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<4, 4, uint, highp>				highp_umat4;
+
+	/// High-qualifier unsigned integer 2x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<2, 2, uint, highp>				highp_umat2x2;
+
+	/// High-qualifier unsigned integer 2x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<2, 3, uint, highp>				highp_umat2x3;
+
+	/// High-qualifier unsigned integer 2x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<2, 4, uint, highp>				highp_umat2x4;
+
+	/// High-qualifier unsigned integer 3x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<3, 2, uint, highp>				highp_umat3x2;
+
+	/// High-qualifier unsigned integer 3x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<3, 3, uint, highp>				highp_umat3x3;
+
+	/// High-qualifier unsigned integer 3x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<3, 4, uint, highp>				highp_umat3x4;
+
+	/// High-qualifier unsigned integer 4x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<4, 2, uint, highp>				highp_umat4x2;
+
+	/// High-qualifier unsigned integer 4x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<4, 3, uint, highp>				highp_umat4x3;
+
+	/// High-qualifier unsigned integer 4x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<4, 4, uint, highp>				highp_umat4x4;
+
+
+	/// Medium-qualifier unsigned integer 2x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<2, 2, uint, mediump>			mediump_umat2;
+
+	/// Medium-qualifier unsigned integer 3x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<3, 3, uint, mediump>			mediump_umat3;
+
+	/// Medium-qualifier unsigned integer 4x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<4, 4, uint, mediump>			mediump_umat4;
+
+
+	/// Medium-qualifier unsigned integer 2x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<2, 2, uint, mediump>			mediump_umat2x2;
+
+	/// Medium-qualifier unsigned integer 2x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<2, 3, uint, mediump>			mediump_umat2x3;
+
+	/// Medium-qualifier unsigned integer 2x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<2, 4, uint, mediump>			mediump_umat2x4;
+
+	/// Medium-qualifier unsigned integer 3x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<3, 2, uint, mediump>			mediump_umat3x2;
+
+	/// Medium-qualifier unsigned integer 3x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<3, 3, uint, mediump>			mediump_umat3x3;
+
+	/// Medium-qualifier unsigned integer 3x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<3, 4, uint, mediump>			mediump_umat3x4;
+
+	/// Medium-qualifier unsigned integer 4x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<4, 2, uint, mediump>			mediump_umat4x2;
+
+	/// Medium-qualifier unsigned integer 4x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<4, 3, uint, mediump>			mediump_umat4x3;
+
+	/// Medium-qualifier unsigned integer 4x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<4, 4, uint, mediump>			mediump_umat4x4;
+
+
+	/// Low-qualifier unsigned integer 2x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<2, 2, uint, lowp>				lowp_umat2;
+
+	/// Low-qualifier unsigned integer 3x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<3, 3, uint, lowp>				lowp_umat3;
+
+	/// Low-qualifier unsigned integer 4x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<4, 4, uint, lowp>				lowp_umat4;
+
+
+	/// Low-qualifier unsigned integer 2x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<2, 2, uint, lowp>				lowp_umat2x2;
+
+	/// Low-qualifier unsigned integer 2x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<2, 3, uint, lowp>				lowp_umat2x3;
+
+	/// Low-qualifier unsigned integer 2x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<2, 4, uint, lowp>				lowp_umat2x4;
+
+	/// Low-qualifier unsigned integer 3x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<3, 2, uint, lowp>				lowp_umat3x2;
+
+	/// Low-qualifier unsigned integer 3x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<3, 3, uint, lowp>				lowp_umat3x3;
+
+	/// Low-qualifier unsigned integer 3x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<3, 4, uint, lowp>				lowp_umat3x4;
+
+	/// Low-qualifier unsigned integer 4x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<4, 2, uint, lowp>				lowp_umat4x2;
+
+	/// Low-qualifier unsigned integer 4x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<4, 3, uint, lowp>				lowp_umat4x3;
+
+	/// Low-qualifier unsigned integer 4x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mat<4, 4, uint, lowp>				lowp_umat4x4;
+
+#if(defined(GLM_PRECISION_HIGHP_INT))
+	typedef highp_imat2								imat2;
+	typedef highp_imat3								imat3;
+	typedef highp_imat4								imat4;
+	typedef highp_imat2x2							imat2x2;
+	typedef highp_imat2x3							imat2x3;
+	typedef highp_imat2x4							imat2x4;
+	typedef highp_imat3x2							imat3x2;
+	typedef highp_imat3x3							imat3x3;
+	typedef highp_imat3x4							imat3x4;
+	typedef highp_imat4x2							imat4x2;
+	typedef highp_imat4x3							imat4x3;
+	typedef highp_imat4x4							imat4x4;
+#elif(defined(GLM_PRECISION_LOWP_INT))
+	typedef lowp_imat2								imat2;
+	typedef lowp_imat3								imat3;
+	typedef lowp_imat4								imat4;
+	typedef lowp_imat2x2							imat2x2;
+	typedef lowp_imat2x3							imat2x3;
+	typedef lowp_imat2x4							imat2x4;
+	typedef lowp_imat3x2							imat3x2;
+	typedef lowp_imat3x3							imat3x3;
+	typedef lowp_imat3x4							imat3x4;
+	typedef lowp_imat4x2							imat4x2;
+	typedef lowp_imat4x3							imat4x3;
+	typedef lowp_imat4x4							imat4x4;
+#else //if(defined(GLM_PRECISION_MEDIUMP_INT))
+
+	/// Signed integer 2x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mediump_imat2							imat2;
+
+	/// Signed integer 3x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mediump_imat3							imat3;
+
+	/// Signed integer 4x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mediump_imat4							imat4;
+
+	/// Signed integer 2x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mediump_imat2x2							imat2x2;
+
+	/// Signed integer 2x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mediump_imat2x3							imat2x3;
+
+	/// Signed integer 2x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mediump_imat2x4							imat2x4;
+
+	/// Signed integer 3x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mediump_imat3x2							imat3x2;
+
+	/// Signed integer 3x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mediump_imat3x3							imat3x3;
+
+	/// Signed integer 3x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mediump_imat3x4							imat3x4;
+
+	/// Signed integer 4x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mediump_imat4x2							imat4x2;
+
+	/// Signed integer 4x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mediump_imat4x3							imat4x3;
+
+	/// Signed integer 4x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mediump_imat4x4							imat4x4;
+#endif//GLM_PRECISION
+
+#if(defined(GLM_PRECISION_HIGHP_UINT))
+	typedef highp_umat2								umat2;
+	typedef highp_umat3								umat3;
+	typedef highp_umat4								umat4;
+	typedef highp_umat2x2							umat2x2;
+	typedef highp_umat2x3							umat2x3;
+	typedef highp_umat2x4							umat2x4;
+	typedef highp_umat3x2							umat3x2;
+	typedef highp_umat3x3							umat3x3;
+	typedef highp_umat3x4							umat3x4;
+	typedef highp_umat4x2							umat4x2;
+	typedef highp_umat4x3							umat4x3;
+	typedef highp_umat4x4							umat4x4;
+#elif(defined(GLM_PRECISION_LOWP_UINT))
+	typedef lowp_umat2								umat2;
+	typedef lowp_umat3								umat3;
+	typedef lowp_umat4								umat4;
+	typedef lowp_umat2x2							umat2x2;
+	typedef lowp_umat2x3							umat2x3;
+	typedef lowp_umat2x4							umat2x4;
+	typedef lowp_umat3x2							umat3x2;
+	typedef lowp_umat3x3							umat3x3;
+	typedef lowp_umat3x4							umat3x4;
+	typedef lowp_umat4x2							umat4x2;
+	typedef lowp_umat4x3							umat4x3;
+	typedef lowp_umat4x4							umat4x4;
+#else //if(defined(GLM_PRECISION_MEDIUMP_UINT))
+
+	/// Unsigned integer 2x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mediump_umat2							umat2;
+
+	/// Unsigned integer 3x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mediump_umat3							umat3;
+
+	/// Unsigned integer 4x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mediump_umat4							umat4;
+
+	/// Unsigned integer 2x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mediump_umat2x2							umat2x2;
+
+	/// Unsigned integer 2x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mediump_umat2x3							umat2x3;
+
+	/// Unsigned integer 2x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mediump_umat2x4							umat2x4;
+
+	/// Unsigned integer 3x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mediump_umat3x2							umat3x2;
+
+	/// Unsigned integer 3x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mediump_umat3x3							umat3x3;
+
+	/// Unsigned integer 3x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mediump_umat3x4							umat3x4;
+
+	/// Unsigned integer 4x2 matrix.
+	/// @see gtc_matrix_integer
+	typedef mediump_umat4x2							umat4x2;
+
+	/// Unsigned integer 4x3 matrix.
+	/// @see gtc_matrix_integer
+	typedef mediump_umat4x3							umat4x3;
+
+	/// Unsigned integer 4x4 matrix.
+	/// @see gtc_matrix_integer
+	typedef mediump_umat4x4							umat4x4;
+#endif//GLM_PRECISION
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/gtc/matrix_inverse.hpp b/engine/inc/glm/gtc/matrix_inverse.hpp
new file mode 100644
index 00000000..a1900adc
--- /dev/null
+++ b/engine/inc/glm/gtc/matrix_inverse.hpp
@@ -0,0 +1,50 @@
+/// @ref gtc_matrix_inverse
+/// @file glm/gtc/matrix_inverse.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtc_matrix_inverse GLM_GTC_matrix_inverse
+/// @ingroup gtc
+///
+/// Include <glm/gtc/matrix_integer.hpp> to use the features of this extension.
+///
+/// Defines additional matrix inverting functions.
+
+#pragma once
+
+// Dependencies
+#include "../detail/setup.hpp"
+#include "../matrix.hpp"
+#include "../mat2x2.hpp"
+#include "../mat3x3.hpp"
+#include "../mat4x4.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTC_matrix_inverse extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtc_matrix_inverse
+	/// @{
+
+	/// Fast matrix inverse for affine matrix.
+	///
+	/// @param m Input matrix to invert.
+	/// @tparam genType Squared floating-point matrix: half, float or double. Inverse of matrix based of half-qualifier floating point value is highly innacurate.
+	/// @see gtc_matrix_inverse
+	template<typename genType>
+	GLM_FUNC_DECL genType affineInverse(genType const& m);
+
+	/// Compute the inverse transpose of a matrix.
+	///
+	/// @param m Input matrix to invert transpose.
+	/// @tparam genType Squared floating-point matrix: half, float or double. Inverse of matrix based of half-qualifier floating point value is highly innacurate.
+	/// @see gtc_matrix_inverse
+	template<typename genType>
+	GLM_FUNC_DECL genType inverseTranspose(genType const& m);
+
+	/// @}
+}//namespace glm
+
+#include "matrix_inverse.inl"
diff --git a/engine/inc/glm/gtc/matrix_inverse.inl b/engine/inc/glm/gtc/matrix_inverse.inl
new file mode 100644
index 00000000..938a9408
--- /dev/null
+++ b/engine/inc/glm/gtc/matrix_inverse.inl
@@ -0,0 +1,119 @@
+/// @ref gtc_matrix_inverse
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> affineInverse(mat<3, 3, T, Q> const& m)
+	{
+		mat<2, 2, T, Q> const Inv(inverse(mat<2, 2, T, Q>(m)));
+
+		return mat<3, 3, T, Q>(
+			vec<3, T, Q>(Inv[0], static_cast<T>(0)),
+			vec<3, T, Q>(Inv[1], static_cast<T>(0)),
+			vec<3, T, Q>(-Inv * vec<2, T, Q>(m[2]), static_cast<T>(1)));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> affineInverse(mat<4, 4, T, Q> const& m)
+	{
+		mat<3, 3, T, Q> const Inv(inverse(mat<3, 3, T, Q>(m)));
+
+		return mat<4, 4, T, Q>(
+			vec<4, T, Q>(Inv[0], static_cast<T>(0)),
+			vec<4, T, Q>(Inv[1], static_cast<T>(0)),
+			vec<4, T, Q>(Inv[2], static_cast<T>(0)),
+			vec<4, T, Q>(-Inv * vec<3, T, Q>(m[3]), static_cast<T>(1)));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> inverseTranspose(mat<2, 2, T, Q> const& m)
+	{
+		T Determinant = m[0][0] * m[1][1] - m[1][0] * m[0][1];
+
+		mat<2, 2, T, Q> Inverse(
+			+ m[1][1] / Determinant,
+			- m[0][1] / Determinant,
+			- m[1][0] / Determinant,
+			+ m[0][0] / Determinant);
+
+		return Inverse;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> inverseTranspose(mat<3, 3, T, Q> const& m)
+	{
+		T Determinant =
+			+ m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1])
+			- m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0])
+			+ m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0]);
+
+		mat<3, 3, T, Q> Inverse;
+		Inverse[0][0] = + (m[1][1] * m[2][2] - m[2][1] * m[1][2]);
+		Inverse[0][1] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]);
+		Inverse[0][2] = + (m[1][0] * m[2][1] - m[2][0] * m[1][1]);
+		Inverse[1][0] = - (m[0][1] * m[2][2] - m[2][1] * m[0][2]);
+		Inverse[1][1] = + (m[0][0] * m[2][2] - m[2][0] * m[0][2]);
+		Inverse[1][2] = - (m[0][0] * m[2][1] - m[2][0] * m[0][1]);
+		Inverse[2][0] = + (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
+		Inverse[2][1] = - (m[0][0] * m[1][2] - m[1][0] * m[0][2]);
+		Inverse[2][2] = + (m[0][0] * m[1][1] - m[1][0] * m[0][1]);
+		Inverse /= Determinant;
+
+		return Inverse;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> inverseTranspose(mat<4, 4, T, Q> const& m)
+	{
+		T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+		T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+		T SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+		T SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+		T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+		T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+		T SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
+		T SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
+		T SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
+		T SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
+		T SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
+		T SubFactor11 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
+		T SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
+		T SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
+		T SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
+		T SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
+		T SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
+		T SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
+		T SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
+
+		mat<4, 4, T, Q> Inverse;
+		Inverse[0][0] = + (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02);
+		Inverse[0][1] = - (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04);
+		Inverse[0][2] = + (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05);
+		Inverse[0][3] = - (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05);
+
+		Inverse[1][0] = - (m[0][1] * SubFactor00 - m[0][2] * SubFactor01 + m[0][3] * SubFactor02);
+		Inverse[1][1] = + (m[0][0] * SubFactor00 - m[0][2] * SubFactor03 + m[0][3] * SubFactor04);
+		Inverse[1][2] = - (m[0][0] * SubFactor01 - m[0][1] * SubFactor03 + m[0][3] * SubFactor05);
+		Inverse[1][3] = + (m[0][0] * SubFactor02 - m[0][1] * SubFactor04 + m[0][2] * SubFactor05);
+
+		Inverse[2][0] = + (m[0][1] * SubFactor06 - m[0][2] * SubFactor07 + m[0][3] * SubFactor08);
+		Inverse[2][1] = - (m[0][0] * SubFactor06 - m[0][2] * SubFactor09 + m[0][3] * SubFactor10);
+		Inverse[2][2] = + (m[0][0] * SubFactor11 - m[0][1] * SubFactor09 + m[0][3] * SubFactor12);
+		Inverse[2][3] = - (m[0][0] * SubFactor08 - m[0][1] * SubFactor10 + m[0][2] * SubFactor12);
+
+		Inverse[3][0] = - (m[0][1] * SubFactor13 - m[0][2] * SubFactor14 + m[0][3] * SubFactor15);
+		Inverse[3][1] = + (m[0][0] * SubFactor13 - m[0][2] * SubFactor16 + m[0][3] * SubFactor17);
+		Inverse[3][2] = - (m[0][0] * SubFactor14 - m[0][1] * SubFactor16 + m[0][3] * SubFactor18);
+		Inverse[3][3] = + (m[0][0] * SubFactor15 - m[0][1] * SubFactor17 + m[0][2] * SubFactor18);
+
+		T Determinant =
+			+ m[0][0] * Inverse[0][0]
+			+ m[0][1] * Inverse[0][1]
+			+ m[0][2] * Inverse[0][2]
+			+ m[0][3] * Inverse[0][3];
+
+		Inverse /= Determinant;
+
+		return Inverse;
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtc/matrix_transform.hpp b/engine/inc/glm/gtc/matrix_transform.hpp
new file mode 100644
index 00000000..612418fa
--- /dev/null
+++ b/engine/inc/glm/gtc/matrix_transform.hpp
@@ -0,0 +1,36 @@
+/// @ref gtc_matrix_transform
+/// @file glm/gtc/matrix_transform.hpp
+///
+/// @see core (dependence)
+/// @see gtx_transform
+/// @see gtx_transform2
+///
+/// @defgroup gtc_matrix_transform GLM_GTC_matrix_transform
+/// @ingroup gtc
+///
+/// Include <glm/gtc/matrix_transform.hpp> to use the features of this extension.
+///
+/// Defines functions that generate common transformation matrices.
+///
+/// The matrices generated by this extension use standard OpenGL fixed-function
+/// conventions. For example, the lookAt function generates a transform from world
+/// space into the specific eye space that the projective matrix functions
+/// (perspective, ortho, etc) are designed to expect. The OpenGL compatibility
+/// specifications defines the particular layout of this eye space.
+
+#pragma once
+
+// Dependencies
+#include "../mat4x4.hpp"
+#include "../vec2.hpp"
+#include "../vec3.hpp"
+#include "../vec4.hpp"
+#include "../ext/matrix_projection.hpp"
+#include "../ext/matrix_clip_space.hpp"
+#include "../ext/matrix_transform.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTC_matrix_transform extension included")
+#endif
+
+#include "matrix_transform.inl"
diff --git a/engine/inc/glm/gtc/matrix_transform.inl b/engine/inc/glm/gtc/matrix_transform.inl
new file mode 100644
index 00000000..15b46bc9
--- /dev/null
+++ b/engine/inc/glm/gtc/matrix_transform.inl
@@ -0,0 +1,3 @@
+#include "../geometric.hpp"
+#include "../trigonometric.hpp"
+#include "../matrix.hpp"
diff --git a/engine/inc/glm/gtc/noise.hpp b/engine/inc/glm/gtc/noise.hpp
new file mode 100644
index 00000000..ab1772e7
--- /dev/null
+++ b/engine/inc/glm/gtc/noise.hpp
@@ -0,0 +1,61 @@
+/// @ref gtc_noise
+/// @file glm/gtc/noise.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtc_noise GLM_GTC_noise
+/// @ingroup gtc
+///
+/// Include <glm/gtc/noise.hpp> to use the features of this extension.
+///
+/// Defines 2D, 3D and 4D procedural noise functions
+/// Based on the work of Stefan Gustavson and Ashima Arts on "webgl-noise":
+/// https://github.com/ashima/webgl-noise
+/// Following Stefan Gustavson's paper "Simplex noise demystified":
+/// http://www.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf
+
+#pragma once
+
+// Dependencies
+#include "../detail/setup.hpp"
+#include "../detail/qualifier.hpp"
+#include "../detail/_noise.hpp"
+#include "../geometric.hpp"
+#include "../common.hpp"
+#include "../vector_relational.hpp"
+#include "../vec2.hpp"
+#include "../vec3.hpp"
+#include "../vec4.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTC_noise extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtc_noise
+	/// @{
+
+	/// Classic perlin noise.
+	/// @see gtc_noise
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL T perlin(
+		vec<L, T, Q> const& p);
+
+	/// Periodic perlin noise.
+	/// @see gtc_noise
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL T perlin(
+		vec<L, T, Q> const& p,
+		vec<L, T, Q> const& rep);
+
+	/// Simplex noise.
+	/// @see gtc_noise
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL T simplex(
+		vec<L, T, Q> const& p);
+
+	/// @}
+}//namespace glm
+
+#include "noise.inl"
diff --git a/engine/inc/glm/gtc/noise.inl b/engine/inc/glm/gtc/noise.inl
new file mode 100644
index 00000000..30d0b274
--- /dev/null
+++ b/engine/inc/glm/gtc/noise.inl
@@ -0,0 +1,807 @@
+/// @ref gtc_noise
+///
+// Based on the work of Stefan Gustavson and Ashima Arts on "webgl-noise":
+// https://github.com/ashima/webgl-noise
+// Following Stefan Gustavson's paper "Simplex noise demystified":
+// http://www.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf
+
+namespace glm{
+namespace gtc
+{
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, T, Q> grad4(T const& j, vec<4, T, Q> const& ip)
+	{
+		vec<3, T, Q> pXYZ = floor(fract(vec<3, T, Q>(j) * vec<3, T, Q>(ip)) * T(7)) * ip[2] - T(1);
+		T pW = static_cast<T>(1.5) - dot(abs(pXYZ), vec<3, T, Q>(1));
+		vec<4, T, Q> s = vec<4, T, Q>(lessThan(vec<4, T, Q>(pXYZ, pW), vec<4, T, Q>(0.0)));
+		pXYZ = pXYZ + (vec<3, T, Q>(s) * T(2) - T(1)) * s.w;
+		return vec<4, T, Q>(pXYZ, pW);
+	}
+}//namespace gtc
+
+	// Classic Perlin noise
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T perlin(vec<2, T, Q> const& Position)
+	{
+		vec<4, T, Q> Pi = glm::floor(vec<4, T, Q>(Position.x, Position.y, Position.x, Position.y)) + vec<4, T, Q>(0.0, 0.0, 1.0, 1.0);
+		vec<4, T, Q> Pf = glm::fract(vec<4, T, Q>(Position.x, Position.y, Position.x, Position.y)) - vec<4, T, Q>(0.0, 0.0, 1.0, 1.0);
+		Pi = mod(Pi, vec<4, T, Q>(289)); // To avoid truncation effects in permutation
+		vec<4, T, Q> ix(Pi.x, Pi.z, Pi.x, Pi.z);
+		vec<4, T, Q> iy(Pi.y, Pi.y, Pi.w, Pi.w);
+		vec<4, T, Q> fx(Pf.x, Pf.z, Pf.x, Pf.z);
+		vec<4, T, Q> fy(Pf.y, Pf.y, Pf.w, Pf.w);
+
+		vec<4, T, Q> i = detail::permute(detail::permute(ix) + iy);
+
+		vec<4, T, Q> gx = static_cast<T>(2) * glm::fract(i / T(41)) - T(1);
+		vec<4, T, Q> gy = glm::abs(gx) - T(0.5);
+		vec<4, T, Q> tx = glm::floor(gx + T(0.5));
+		gx = gx - tx;
+
+		vec<2, T, Q> g00(gx.x, gy.x);
+		vec<2, T, Q> g10(gx.y, gy.y);
+		vec<2, T, Q> g01(gx.z, gy.z);
+		vec<2, T, Q> g11(gx.w, gy.w);
+
+		vec<4, T, Q> norm = detail::taylorInvSqrt(vec<4, T, Q>(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
+		g00 *= norm.x;
+		g01 *= norm.y;
+		g10 *= norm.z;
+		g11 *= norm.w;
+
+		T n00 = dot(g00, vec<2, T, Q>(fx.x, fy.x));
+		T n10 = dot(g10, vec<2, T, Q>(fx.y, fy.y));
+		T n01 = dot(g01, vec<2, T, Q>(fx.z, fy.z));
+		T n11 = dot(g11, vec<2, T, Q>(fx.w, fy.w));
+
+		vec<2, T, Q> fade_xy = detail::fade(vec<2, T, Q>(Pf.x, Pf.y));
+		vec<2, T, Q> n_x = mix(vec<2, T, Q>(n00, n01), vec<2, T, Q>(n10, n11), fade_xy.x);
+		T n_xy = mix(n_x.x, n_x.y, fade_xy.y);
+		return T(2.3) * n_xy;
+	}
+
+	// Classic Perlin noise
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T perlin(vec<3, T, Q> const& Position)
+	{
+		vec<3, T, Q> Pi0 = floor(Position); // Integer part for indexing
+		vec<3, T, Q> Pi1 = Pi0 + T(1); // Integer part + 1
+		Pi0 = detail::mod289(Pi0);
+		Pi1 = detail::mod289(Pi1);
+		vec<3, T, Q> Pf0 = fract(Position); // Fractional part for interpolation
+		vec<3, T, Q> Pf1 = Pf0 - T(1); // Fractional part - 1.0
+		vec<4, T, Q> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
+		vec<4, T, Q> iy = vec<4, T, Q>(vec<2, T, Q>(Pi0.y), vec<2, T, Q>(Pi1.y));
+		vec<4, T, Q> iz0(Pi0.z);
+		vec<4, T, Q> iz1(Pi1.z);
+
+		vec<4, T, Q> ixy = detail::permute(detail::permute(ix) + iy);
+		vec<4, T, Q> ixy0 = detail::permute(ixy + iz0);
+		vec<4, T, Q> ixy1 = detail::permute(ixy + iz1);
+
+		vec<4, T, Q> gx0 = ixy0 * T(1.0 / 7.0);
+		vec<4, T, Q> gy0 = fract(floor(gx0) * T(1.0 / 7.0)) - T(0.5);
+		gx0 = fract(gx0);
+		vec<4, T, Q> gz0 = vec<4, T, Q>(0.5) - abs(gx0) - abs(gy0);
+		vec<4, T, Q> sz0 = step(gz0, vec<4, T, Q>(0.0));
+		gx0 -= sz0 * (step(T(0), gx0) - T(0.5));
+		gy0 -= sz0 * (step(T(0), gy0) - T(0.5));
+
+		vec<4, T, Q> gx1 = ixy1 * T(1.0 / 7.0);
+		vec<4, T, Q> gy1 = fract(floor(gx1) * T(1.0 / 7.0)) - T(0.5);
+		gx1 = fract(gx1);
+		vec<4, T, Q> gz1 = vec<4, T, Q>(0.5) - abs(gx1) - abs(gy1);
+		vec<4, T, Q> sz1 = step(gz1, vec<4, T, Q>(0.0));
+		gx1 -= sz1 * (step(T(0), gx1) - T(0.5));
+		gy1 -= sz1 * (step(T(0), gy1) - T(0.5));
+
+		vec<3, T, Q> g000(gx0.x, gy0.x, gz0.x);
+		vec<3, T, Q> g100(gx0.y, gy0.y, gz0.y);
+		vec<3, T, Q> g010(gx0.z, gy0.z, gz0.z);
+		vec<3, T, Q> g110(gx0.w, gy0.w, gz0.w);
+		vec<3, T, Q> g001(gx1.x, gy1.x, gz1.x);
+		vec<3, T, Q> g101(gx1.y, gy1.y, gz1.y);
+		vec<3, T, Q> g011(gx1.z, gy1.z, gz1.z);
+		vec<3, T, Q> g111(gx1.w, gy1.w, gz1.w);
+
+		vec<4, T, Q> norm0 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
+		g000 *= norm0.x;
+		g010 *= norm0.y;
+		g100 *= norm0.z;
+		g110 *= norm0.w;
+		vec<4, T, Q> norm1 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
+		g001 *= norm1.x;
+		g011 *= norm1.y;
+		g101 *= norm1.z;
+		g111 *= norm1.w;
+
+		T n000 = dot(g000, Pf0);
+		T n100 = dot(g100, vec<3, T, Q>(Pf1.x, Pf0.y, Pf0.z));
+		T n010 = dot(g010, vec<3, T, Q>(Pf0.x, Pf1.y, Pf0.z));
+		T n110 = dot(g110, vec<3, T, Q>(Pf1.x, Pf1.y, Pf0.z));
+		T n001 = dot(g001, vec<3, T, Q>(Pf0.x, Pf0.y, Pf1.z));
+		T n101 = dot(g101, vec<3, T, Q>(Pf1.x, Pf0.y, Pf1.z));
+		T n011 = dot(g011, vec<3, T, Q>(Pf0.x, Pf1.y, Pf1.z));
+		T n111 = dot(g111, Pf1);
+
+		vec<3, T, Q> fade_xyz = detail::fade(Pf0);
+		vec<4, T, Q> n_z = mix(vec<4, T, Q>(n000, n100, n010, n110), vec<4, T, Q>(n001, n101, n011, n111), fade_xyz.z);
+		vec<2, T, Q> n_yz = mix(vec<2, T, Q>(n_z.x, n_z.y), vec<2, T, Q>(n_z.z, n_z.w), fade_xyz.y);
+		T n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x);
+		return T(2.2) * n_xyz;
+	}
+	/*
+	// Classic Perlin noise
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T perlin(vec<3, T, Q> const& P)
+	{
+		vec<3, T, Q> Pi0 = floor(P); // Integer part for indexing
+		vec<3, T, Q> Pi1 = Pi0 + T(1); // Integer part + 1
+		Pi0 = mod(Pi0, T(289));
+		Pi1 = mod(Pi1, T(289));
+		vec<3, T, Q> Pf0 = fract(P); // Fractional part for interpolation
+		vec<3, T, Q> Pf1 = Pf0 - T(1); // Fractional part - 1.0
+		vec<4, T, Q> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
+		vec<4, T, Q> iy(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
+		vec<4, T, Q> iz0(Pi0.z);
+		vec<4, T, Q> iz1(Pi1.z);
+
+		vec<4, T, Q> ixy = permute(permute(ix) + iy);
+		vec<4, T, Q> ixy0 = permute(ixy + iz0);
+		vec<4, T, Q> ixy1 = permute(ixy + iz1);
+
+		vec<4, T, Q> gx0 = ixy0 / T(7);
+		vec<4, T, Q> gy0 = fract(floor(gx0) / T(7)) - T(0.5);
+		gx0 = fract(gx0);
+		vec<4, T, Q> gz0 = vec<4, T, Q>(0.5) - abs(gx0) - abs(gy0);
+		vec<4, T, Q> sz0 = step(gz0, vec<4, T, Q>(0.0));
+		gx0 -= sz0 * (step(0.0, gx0) - T(0.5));
+		gy0 -= sz0 * (step(0.0, gy0) - T(0.5));
+
+		vec<4, T, Q> gx1 = ixy1 / T(7);
+		vec<4, T, Q> gy1 = fract(floor(gx1) / T(7)) - T(0.5);
+		gx1 = fract(gx1);
+		vec<4, T, Q> gz1 = vec<4, T, Q>(0.5) - abs(gx1) - abs(gy1);
+		vec<4, T, Q> sz1 = step(gz1, vec<4, T, Q>(0.0));
+		gx1 -= sz1 * (step(T(0), gx1) - T(0.5));
+		gy1 -= sz1 * (step(T(0), gy1) - T(0.5));
+
+		vec<3, T, Q> g000(gx0.x, gy0.x, gz0.x);
+		vec<3, T, Q> g100(gx0.y, gy0.y, gz0.y);
+		vec<3, T, Q> g010(gx0.z, gy0.z, gz0.z);
+		vec<3, T, Q> g110(gx0.w, gy0.w, gz0.w);
+		vec<3, T, Q> g001(gx1.x, gy1.x, gz1.x);
+		vec<3, T, Q> g101(gx1.y, gy1.y, gz1.y);
+		vec<3, T, Q> g011(gx1.z, gy1.z, gz1.z);
+		vec<3, T, Q> g111(gx1.w, gy1.w, gz1.w);
+
+		vec<4, T, Q> norm0 = taylorInvSqrt(vec<4, T, Q>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
+		g000 *= norm0.x;
+		g010 *= norm0.y;
+		g100 *= norm0.z;
+		g110 *= norm0.w;
+		vec<4, T, Q> norm1 = taylorInvSqrt(vec<4, T, Q>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
+		g001 *= norm1.x;
+		g011 *= norm1.y;
+		g101 *= norm1.z;
+		g111 *= norm1.w;
+
+		T n000 = dot(g000, Pf0);
+		T n100 = dot(g100, vec<3, T, Q>(Pf1.x, Pf0.y, Pf0.z));
+		T n010 = dot(g010, vec<3, T, Q>(Pf0.x, Pf1.y, Pf0.z));
+		T n110 = dot(g110, vec<3, T, Q>(Pf1.x, Pf1.y, Pf0.z));
+		T n001 = dot(g001, vec<3, T, Q>(Pf0.x, Pf0.y, Pf1.z));
+		T n101 = dot(g101, vec<3, T, Q>(Pf1.x, Pf0.y, Pf1.z));
+		T n011 = dot(g011, vec<3, T, Q>(Pf0.x, Pf1.y, Pf1.z));
+		T n111 = dot(g111, Pf1);
+
+		vec<3, T, Q> fade_xyz = fade(Pf0);
+		vec<4, T, Q> n_z = mix(vec<4, T, Q>(n000, n100, n010, n110), vec<4, T, Q>(n001, n101, n011, n111), fade_xyz.z);
+		vec<2, T, Q> n_yz = mix(
+			vec<2, T, Q>(n_z.x, n_z.y),
+			vec<2, T, Q>(n_z.z, n_z.w), fade_xyz.y);
+		T n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x);
+		return T(2.2) * n_xyz;
+	}
+	*/
+	// Classic Perlin noise
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T perlin(vec<4, T, Q> const& Position)
+	{
+		vec<4, T, Q> Pi0 = floor(Position);	// Integer part for indexing
+		vec<4, T, Q> Pi1 = Pi0 + T(1);		// Integer part + 1
+		Pi0 = mod(Pi0, vec<4, T, Q>(289));
+		Pi1 = mod(Pi1, vec<4, T, Q>(289));
+		vec<4, T, Q> Pf0 = fract(Position);	// Fractional part for interpolation
+		vec<4, T, Q> Pf1 = Pf0 - T(1);		// Fractional part - 1.0
+		vec<4, T, Q> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
+		vec<4, T, Q> iy(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
+		vec<4, T, Q> iz0(Pi0.z);
+		vec<4, T, Q> iz1(Pi1.z);
+		vec<4, T, Q> iw0(Pi0.w);
+		vec<4, T, Q> iw1(Pi1.w);
+
+		vec<4, T, Q> ixy = detail::permute(detail::permute(ix) + iy);
+		vec<4, T, Q> ixy0 = detail::permute(ixy + iz0);
+		vec<4, T, Q> ixy1 = detail::permute(ixy + iz1);
+		vec<4, T, Q> ixy00 = detail::permute(ixy0 + iw0);
+		vec<4, T, Q> ixy01 = detail::permute(ixy0 + iw1);
+		vec<4, T, Q> ixy10 = detail::permute(ixy1 + iw0);
+		vec<4, T, Q> ixy11 = detail::permute(ixy1 + iw1);
+
+		vec<4, T, Q> gx00 = ixy00 / T(7);
+		vec<4, T, Q> gy00 = floor(gx00) / T(7);
+		vec<4, T, Q> gz00 = floor(gy00) / T(6);
+		gx00 = fract(gx00) - T(0.5);
+		gy00 = fract(gy00) - T(0.5);
+		gz00 = fract(gz00) - T(0.5);
+		vec<4, T, Q> gw00 = vec<4, T, Q>(0.75) - abs(gx00) - abs(gy00) - abs(gz00);
+		vec<4, T, Q> sw00 = step(gw00, vec<4, T, Q>(0.0));
+		gx00 -= sw00 * (step(T(0), gx00) - T(0.5));
+		gy00 -= sw00 * (step(T(0), gy00) - T(0.5));
+
+		vec<4, T, Q> gx01 = ixy01 / T(7);
+		vec<4, T, Q> gy01 = floor(gx01) / T(7);
+		vec<4, T, Q> gz01 = floor(gy01) / T(6);
+		gx01 = fract(gx01) - T(0.5);
+		gy01 = fract(gy01) - T(0.5);
+		gz01 = fract(gz01) - T(0.5);
+		vec<4, T, Q> gw01 = vec<4, T, Q>(0.75) - abs(gx01) - abs(gy01) - abs(gz01);
+		vec<4, T, Q> sw01 = step(gw01, vec<4, T, Q>(0.0));
+		gx01 -= sw01 * (step(T(0), gx01) - T(0.5));
+		gy01 -= sw01 * (step(T(0), gy01) - T(0.5));
+
+		vec<4, T, Q> gx10 = ixy10 / T(7);
+		vec<4, T, Q> gy10 = floor(gx10) / T(7);
+		vec<4, T, Q> gz10 = floor(gy10) / T(6);
+		gx10 = fract(gx10) - T(0.5);
+		gy10 = fract(gy10) - T(0.5);
+		gz10 = fract(gz10) - T(0.5);
+		vec<4, T, Q> gw10 = vec<4, T, Q>(0.75) - abs(gx10) - abs(gy10) - abs(gz10);
+		vec<4, T, Q> sw10 = step(gw10, vec<4, T, Q>(0));
+		gx10 -= sw10 * (step(T(0), gx10) - T(0.5));
+		gy10 -= sw10 * (step(T(0), gy10) - T(0.5));
+
+		vec<4, T, Q> gx11 = ixy11 / T(7);
+		vec<4, T, Q> gy11 = floor(gx11) / T(7);
+		vec<4, T, Q> gz11 = floor(gy11) / T(6);
+		gx11 = fract(gx11) - T(0.5);
+		gy11 = fract(gy11) - T(0.5);
+		gz11 = fract(gz11) - T(0.5);
+		vec<4, T, Q> gw11 = vec<4, T, Q>(0.75) - abs(gx11) - abs(gy11) - abs(gz11);
+		vec<4, T, Q> sw11 = step(gw11, vec<4, T, Q>(0.0));
+		gx11 -= sw11 * (step(T(0), gx11) - T(0.5));
+		gy11 -= sw11 * (step(T(0), gy11) - T(0.5));
+
+		vec<4, T, Q> g0000(gx00.x, gy00.x, gz00.x, gw00.x);
+		vec<4, T, Q> g1000(gx00.y, gy00.y, gz00.y, gw00.y);
+		vec<4, T, Q> g0100(gx00.z, gy00.z, gz00.z, gw00.z);
+		vec<4, T, Q> g1100(gx00.w, gy00.w, gz00.w, gw00.w);
+		vec<4, T, Q> g0010(gx10.x, gy10.x, gz10.x, gw10.x);
+		vec<4, T, Q> g1010(gx10.y, gy10.y, gz10.y, gw10.y);
+		vec<4, T, Q> g0110(gx10.z, gy10.z, gz10.z, gw10.z);
+		vec<4, T, Q> g1110(gx10.w, gy10.w, gz10.w, gw10.w);
+		vec<4, T, Q> g0001(gx01.x, gy01.x, gz01.x, gw01.x);
+		vec<4, T, Q> g1001(gx01.y, gy01.y, gz01.y, gw01.y);
+		vec<4, T, Q> g0101(gx01.z, gy01.z, gz01.z, gw01.z);
+		vec<4, T, Q> g1101(gx01.w, gy01.w, gz01.w, gw01.w);
+		vec<4, T, Q> g0011(gx11.x, gy11.x, gz11.x, gw11.x);
+		vec<4, T, Q> g1011(gx11.y, gy11.y, gz11.y, gw11.y);
+		vec<4, T, Q> g0111(gx11.z, gy11.z, gz11.z, gw11.z);
+		vec<4, T, Q> g1111(gx11.w, gy11.w, gz11.w, gw11.w);
+
+		vec<4, T, Q> norm00 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100)));
+		g0000 *= norm00.x;
+		g0100 *= norm00.y;
+		g1000 *= norm00.z;
+		g1100 *= norm00.w;
+
+		vec<4, T, Q> norm01 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101)));
+		g0001 *= norm01.x;
+		g0101 *= norm01.y;
+		g1001 *= norm01.z;
+		g1101 *= norm01.w;
+
+		vec<4, T, Q> norm10 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110)));
+		g0010 *= norm10.x;
+		g0110 *= norm10.y;
+		g1010 *= norm10.z;
+		g1110 *= norm10.w;
+
+		vec<4, T, Q> norm11 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111)));
+		g0011 *= norm11.x;
+		g0111 *= norm11.y;
+		g1011 *= norm11.z;
+		g1111 *= norm11.w;
+
+		T n0000 = dot(g0000, Pf0);
+		T n1000 = dot(g1000, vec<4, T, Q>(Pf1.x, Pf0.y, Pf0.z, Pf0.w));
+		T n0100 = dot(g0100, vec<4, T, Q>(Pf0.x, Pf1.y, Pf0.z, Pf0.w));
+		T n1100 = dot(g1100, vec<4, T, Q>(Pf1.x, Pf1.y, Pf0.z, Pf0.w));
+		T n0010 = dot(g0010, vec<4, T, Q>(Pf0.x, Pf0.y, Pf1.z, Pf0.w));
+		T n1010 = dot(g1010, vec<4, T, Q>(Pf1.x, Pf0.y, Pf1.z, Pf0.w));
+		T n0110 = dot(g0110, vec<4, T, Q>(Pf0.x, Pf1.y, Pf1.z, Pf0.w));
+		T n1110 = dot(g1110, vec<4, T, Q>(Pf1.x, Pf1.y, Pf1.z, Pf0.w));
+		T n0001 = dot(g0001, vec<4, T, Q>(Pf0.x, Pf0.y, Pf0.z, Pf1.w));
+		T n1001 = dot(g1001, vec<4, T, Q>(Pf1.x, Pf0.y, Pf0.z, Pf1.w));
+		T n0101 = dot(g0101, vec<4, T, Q>(Pf0.x, Pf1.y, Pf0.z, Pf1.w));
+		T n1101 = dot(g1101, vec<4, T, Q>(Pf1.x, Pf1.y, Pf0.z, Pf1.w));
+		T n0011 = dot(g0011, vec<4, T, Q>(Pf0.x, Pf0.y, Pf1.z, Pf1.w));
+		T n1011 = dot(g1011, vec<4, T, Q>(Pf1.x, Pf0.y, Pf1.z, Pf1.w));
+		T n0111 = dot(g0111, vec<4, T, Q>(Pf0.x, Pf1.y, Pf1.z, Pf1.w));
+		T n1111 = dot(g1111, Pf1);
+
+		vec<4, T, Q> fade_xyzw = detail::fade(Pf0);
+		vec<4, T, Q> n_0w = mix(vec<4, T, Q>(n0000, n1000, n0100, n1100), vec<4, T, Q>(n0001, n1001, n0101, n1101), fade_xyzw.w);
+		vec<4, T, Q> n_1w = mix(vec<4, T, Q>(n0010, n1010, n0110, n1110), vec<4, T, Q>(n0011, n1011, n0111, n1111), fade_xyzw.w);
+		vec<4, T, Q> n_zw = mix(n_0w, n_1w, fade_xyzw.z);
+		vec<2, T, Q> n_yzw = mix(vec<2, T, Q>(n_zw.x, n_zw.y), vec<2, T, Q>(n_zw.z, n_zw.w), fade_xyzw.y);
+		T n_xyzw = mix(n_yzw.x, n_yzw.y, fade_xyzw.x);
+		return T(2.2) * n_xyzw;
+	}
+
+	// Classic Perlin noise, periodic variant
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T perlin(vec<2, T, Q> const& Position, vec<2, T, Q> const& rep)
+	{
+		vec<4, T, Q> Pi = floor(vec<4, T, Q>(Position.x, Position.y, Position.x, Position.y)) + vec<4, T, Q>(0.0, 0.0, 1.0, 1.0);
+		vec<4, T, Q> Pf = fract(vec<4, T, Q>(Position.x, Position.y, Position.x, Position.y)) - vec<4, T, Q>(0.0, 0.0, 1.0, 1.0);
+		Pi = mod(Pi, vec<4, T, Q>(rep.x, rep.y, rep.x, rep.y)); // To create noise with explicit period
+		Pi = mod(Pi, vec<4, T, Q>(289)); // To avoid truncation effects in permutation
+		vec<4, T, Q> ix(Pi.x, Pi.z, Pi.x, Pi.z);
+		vec<4, T, Q> iy(Pi.y, Pi.y, Pi.w, Pi.w);
+		vec<4, T, Q> fx(Pf.x, Pf.z, Pf.x, Pf.z);
+		vec<4, T, Q> fy(Pf.y, Pf.y, Pf.w, Pf.w);
+
+		vec<4, T, Q> i = detail::permute(detail::permute(ix) + iy);
+
+		vec<4, T, Q> gx = static_cast<T>(2) * fract(i / T(41)) - T(1);
+		vec<4, T, Q> gy = abs(gx) - T(0.5);
+		vec<4, T, Q> tx = floor(gx + T(0.5));
+		gx = gx - tx;
+
+		vec<2, T, Q> g00(gx.x, gy.x);
+		vec<2, T, Q> g10(gx.y, gy.y);
+		vec<2, T, Q> g01(gx.z, gy.z);
+		vec<2, T, Q> g11(gx.w, gy.w);
+
+		vec<4, T, Q> norm = detail::taylorInvSqrt(vec<4, T, Q>(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
+		g00 *= norm.x;
+		g01 *= norm.y;
+		g10 *= norm.z;
+		g11 *= norm.w;
+
+		T n00 = dot(g00, vec<2, T, Q>(fx.x, fy.x));
+		T n10 = dot(g10, vec<2, T, Q>(fx.y, fy.y));
+		T n01 = dot(g01, vec<2, T, Q>(fx.z, fy.z));
+		T n11 = dot(g11, vec<2, T, Q>(fx.w, fy.w));
+
+		vec<2, T, Q> fade_xy = detail::fade(vec<2, T, Q>(Pf.x, Pf.y));
+		vec<2, T, Q> n_x = mix(vec<2, T, Q>(n00, n01), vec<2, T, Q>(n10, n11), fade_xy.x);
+		T n_xy = mix(n_x.x, n_x.y, fade_xy.y);
+		return T(2.3) * n_xy;
+	}
+
+	// Classic Perlin noise, periodic variant
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T perlin(vec<3, T, Q> const& Position, vec<3, T, Q> const& rep)
+	{
+		vec<3, T, Q> Pi0 = mod(floor(Position), rep); // Integer part, modulo period
+		vec<3, T, Q> Pi1 = mod(Pi0 + vec<3, T, Q>(T(1)), rep); // Integer part + 1, mod period
+		Pi0 = mod(Pi0, vec<3, T, Q>(289));
+		Pi1 = mod(Pi1, vec<3, T, Q>(289));
+		vec<3, T, Q> Pf0 = fract(Position); // Fractional part for interpolation
+		vec<3, T, Q> Pf1 = Pf0 - vec<3, T, Q>(T(1)); // Fractional part - 1.0
+		vec<4, T, Q> ix = vec<4, T, Q>(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
+		vec<4, T, Q> iy = vec<4, T, Q>(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
+		vec<4, T, Q> iz0(Pi0.z);
+		vec<4, T, Q> iz1(Pi1.z);
+
+		vec<4, T, Q> ixy = detail::permute(detail::permute(ix) + iy);
+		vec<4, T, Q> ixy0 = detail::permute(ixy + iz0);
+		vec<4, T, Q> ixy1 = detail::permute(ixy + iz1);
+
+		vec<4, T, Q> gx0 = ixy0 / T(7);
+		vec<4, T, Q> gy0 = fract(floor(gx0) / T(7)) - T(0.5);
+		gx0 = fract(gx0);
+		vec<4, T, Q> gz0 = vec<4, T, Q>(0.5) - abs(gx0) - abs(gy0);
+		vec<4, T, Q> sz0 = step(gz0, vec<4, T, Q>(0));
+		gx0 -= sz0 * (step(T(0), gx0) - T(0.5));
+		gy0 -= sz0 * (step(T(0), gy0) - T(0.5));
+
+		vec<4, T, Q> gx1 = ixy1 / T(7);
+		vec<4, T, Q> gy1 = fract(floor(gx1) / T(7)) - T(0.5);
+		gx1 = fract(gx1);
+		vec<4, T, Q> gz1 = vec<4, T, Q>(0.5) - abs(gx1) - abs(gy1);
+		vec<4, T, Q> sz1 = step(gz1, vec<4, T, Q>(T(0)));
+		gx1 -= sz1 * (step(T(0), gx1) - T(0.5));
+		gy1 -= sz1 * (step(T(0), gy1) - T(0.5));
+
+		vec<3, T, Q> g000 = vec<3, T, Q>(gx0.x, gy0.x, gz0.x);
+		vec<3, T, Q> g100 = vec<3, T, Q>(gx0.y, gy0.y, gz0.y);
+		vec<3, T, Q> g010 = vec<3, T, Q>(gx0.z, gy0.z, gz0.z);
+		vec<3, T, Q> g110 = vec<3, T, Q>(gx0.w, gy0.w, gz0.w);
+		vec<3, T, Q> g001 = vec<3, T, Q>(gx1.x, gy1.x, gz1.x);
+		vec<3, T, Q> g101 = vec<3, T, Q>(gx1.y, gy1.y, gz1.y);
+		vec<3, T, Q> g011 = vec<3, T, Q>(gx1.z, gy1.z, gz1.z);
+		vec<3, T, Q> g111 = vec<3, T, Q>(gx1.w, gy1.w, gz1.w);
+
+		vec<4, T, Q> norm0 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
+		g000 *= norm0.x;
+		g010 *= norm0.y;
+		g100 *= norm0.z;
+		g110 *= norm0.w;
+		vec<4, T, Q> norm1 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
+		g001 *= norm1.x;
+		g011 *= norm1.y;
+		g101 *= norm1.z;
+		g111 *= norm1.w;
+
+		T n000 = dot(g000, Pf0);
+		T n100 = dot(g100, vec<3, T, Q>(Pf1.x, Pf0.y, Pf0.z));
+		T n010 = dot(g010, vec<3, T, Q>(Pf0.x, Pf1.y, Pf0.z));
+		T n110 = dot(g110, vec<3, T, Q>(Pf1.x, Pf1.y, Pf0.z));
+		T n001 = dot(g001, vec<3, T, Q>(Pf0.x, Pf0.y, Pf1.z));
+		T n101 = dot(g101, vec<3, T, Q>(Pf1.x, Pf0.y, Pf1.z));
+		T n011 = dot(g011, vec<3, T, Q>(Pf0.x, Pf1.y, Pf1.z));
+		T n111 = dot(g111, Pf1);
+
+		vec<3, T, Q> fade_xyz = detail::fade(Pf0);
+		vec<4, T, Q> n_z = mix(vec<4, T, Q>(n000, n100, n010, n110), vec<4, T, Q>(n001, n101, n011, n111), fade_xyz.z);
+		vec<2, T, Q> n_yz = mix(vec<2, T, Q>(n_z.x, n_z.y), vec<2, T, Q>(n_z.z, n_z.w), fade_xyz.y);
+		T n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x);
+		return T(2.2) * n_xyz;
+	}
+
+	// Classic Perlin noise, periodic version
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T perlin(vec<4, T, Q> const& Position, vec<4, T, Q> const& rep)
+	{
+		vec<4, T, Q> Pi0 = mod(floor(Position), rep); // Integer part modulo rep
+		vec<4, T, Q> Pi1 = mod(Pi0 + T(1), rep); // Integer part + 1 mod rep
+		vec<4, T, Q> Pf0 = fract(Position); // Fractional part for interpolation
+		vec<4, T, Q> Pf1 = Pf0 - T(1); // Fractional part - 1.0
+		vec<4, T, Q> ix = vec<4, T, Q>(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
+		vec<4, T, Q> iy = vec<4, T, Q>(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
+		vec<4, T, Q> iz0(Pi0.z);
+		vec<4, T, Q> iz1(Pi1.z);
+		vec<4, T, Q> iw0(Pi0.w);
+		vec<4, T, Q> iw1(Pi1.w);
+
+		vec<4, T, Q> ixy = detail::permute(detail::permute(ix) + iy);
+		vec<4, T, Q> ixy0 = detail::permute(ixy + iz0);
+		vec<4, T, Q> ixy1 = detail::permute(ixy + iz1);
+		vec<4, T, Q> ixy00 = detail::permute(ixy0 + iw0);
+		vec<4, T, Q> ixy01 = detail::permute(ixy0 + iw1);
+		vec<4, T, Q> ixy10 = detail::permute(ixy1 + iw0);
+		vec<4, T, Q> ixy11 = detail::permute(ixy1 + iw1);
+
+		vec<4, T, Q> gx00 = ixy00 / T(7);
+		vec<4, T, Q> gy00 = floor(gx00) / T(7);
+		vec<4, T, Q> gz00 = floor(gy00) / T(6);
+		gx00 = fract(gx00) - T(0.5);
+		gy00 = fract(gy00) - T(0.5);
+		gz00 = fract(gz00) - T(0.5);
+		vec<4, T, Q> gw00 = vec<4, T, Q>(0.75) - abs(gx00) - abs(gy00) - abs(gz00);
+		vec<4, T, Q> sw00 = step(gw00, vec<4, T, Q>(0));
+		gx00 -= sw00 * (step(T(0), gx00) - T(0.5));
+		gy00 -= sw00 * (step(T(0), gy00) - T(0.5));
+
+		vec<4, T, Q> gx01 = ixy01 / T(7);
+		vec<4, T, Q> gy01 = floor(gx01) / T(7);
+		vec<4, T, Q> gz01 = floor(gy01) / T(6);
+		gx01 = fract(gx01) - T(0.5);
+		gy01 = fract(gy01) - T(0.5);
+		gz01 = fract(gz01) - T(0.5);
+		vec<4, T, Q> gw01 = vec<4, T, Q>(0.75) - abs(gx01) - abs(gy01) - abs(gz01);
+		vec<4, T, Q> sw01 = step(gw01, vec<4, T, Q>(0.0));
+		gx01 -= sw01 * (step(T(0), gx01) - T(0.5));
+		gy01 -= sw01 * (step(T(0), gy01) - T(0.5));
+
+		vec<4, T, Q> gx10 = ixy10 / T(7);
+		vec<4, T, Q> gy10 = floor(gx10) / T(7);
+		vec<4, T, Q> gz10 = floor(gy10) / T(6);
+		gx10 = fract(gx10) - T(0.5);
+		gy10 = fract(gy10) - T(0.5);
+		gz10 = fract(gz10) - T(0.5);
+		vec<4, T, Q> gw10 = vec<4, T, Q>(0.75) - abs(gx10) - abs(gy10) - abs(gz10);
+		vec<4, T, Q> sw10 = step(gw10, vec<4, T, Q>(0.0));
+		gx10 -= sw10 * (step(T(0), gx10) - T(0.5));
+		gy10 -= sw10 * (step(T(0), gy10) - T(0.5));
+
+		vec<4, T, Q> gx11 = ixy11 / T(7);
+		vec<4, T, Q> gy11 = floor(gx11) / T(7);
+		vec<4, T, Q> gz11 = floor(gy11) / T(6);
+		gx11 = fract(gx11) - T(0.5);
+		gy11 = fract(gy11) - T(0.5);
+		gz11 = fract(gz11) - T(0.5);
+		vec<4, T, Q> gw11 = vec<4, T, Q>(0.75) - abs(gx11) - abs(gy11) - abs(gz11);
+		vec<4, T, Q> sw11 = step(gw11, vec<4, T, Q>(T(0)));
+		gx11 -= sw11 * (step(T(0), gx11) - T(0.5));
+		gy11 -= sw11 * (step(T(0), gy11) - T(0.5));
+
+		vec<4, T, Q> g0000(gx00.x, gy00.x, gz00.x, gw00.x);
+		vec<4, T, Q> g1000(gx00.y, gy00.y, gz00.y, gw00.y);
+		vec<4, T, Q> g0100(gx00.z, gy00.z, gz00.z, gw00.z);
+		vec<4, T, Q> g1100(gx00.w, gy00.w, gz00.w, gw00.w);
+		vec<4, T, Q> g0010(gx10.x, gy10.x, gz10.x, gw10.x);
+		vec<4, T, Q> g1010(gx10.y, gy10.y, gz10.y, gw10.y);
+		vec<4, T, Q> g0110(gx10.z, gy10.z, gz10.z, gw10.z);
+		vec<4, T, Q> g1110(gx10.w, gy10.w, gz10.w, gw10.w);
+		vec<4, T, Q> g0001(gx01.x, gy01.x, gz01.x, gw01.x);
+		vec<4, T, Q> g1001(gx01.y, gy01.y, gz01.y, gw01.y);
+		vec<4, T, Q> g0101(gx01.z, gy01.z, gz01.z, gw01.z);
+		vec<4, T, Q> g1101(gx01.w, gy01.w, gz01.w, gw01.w);
+		vec<4, T, Q> g0011(gx11.x, gy11.x, gz11.x, gw11.x);
+		vec<4, T, Q> g1011(gx11.y, gy11.y, gz11.y, gw11.y);
+		vec<4, T, Q> g0111(gx11.z, gy11.z, gz11.z, gw11.z);
+		vec<4, T, Q> g1111(gx11.w, gy11.w, gz11.w, gw11.w);
+
+		vec<4, T, Q> norm00 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100)));
+		g0000 *= norm00.x;
+		g0100 *= norm00.y;
+		g1000 *= norm00.z;
+		g1100 *= norm00.w;
+
+		vec<4, T, Q> norm01 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101)));
+		g0001 *= norm01.x;
+		g0101 *= norm01.y;
+		g1001 *= norm01.z;
+		g1101 *= norm01.w;
+
+		vec<4, T, Q> norm10 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110)));
+		g0010 *= norm10.x;
+		g0110 *= norm10.y;
+		g1010 *= norm10.z;
+		g1110 *= norm10.w;
+
+		vec<4, T, Q> norm11 = detail::taylorInvSqrt(vec<4, T, Q>(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111)));
+		g0011 *= norm11.x;
+		g0111 *= norm11.y;
+		g1011 *= norm11.z;
+		g1111 *= norm11.w;
+
+		T n0000 = dot(g0000, Pf0);
+		T n1000 = dot(g1000, vec<4, T, Q>(Pf1.x, Pf0.y, Pf0.z, Pf0.w));
+		T n0100 = dot(g0100, vec<4, T, Q>(Pf0.x, Pf1.y, Pf0.z, Pf0.w));
+		T n1100 = dot(g1100, vec<4, T, Q>(Pf1.x, Pf1.y, Pf0.z, Pf0.w));
+		T n0010 = dot(g0010, vec<4, T, Q>(Pf0.x, Pf0.y, Pf1.z, Pf0.w));
+		T n1010 = dot(g1010, vec<4, T, Q>(Pf1.x, Pf0.y, Pf1.z, Pf0.w));
+		T n0110 = dot(g0110, vec<4, T, Q>(Pf0.x, Pf1.y, Pf1.z, Pf0.w));
+		T n1110 = dot(g1110, vec<4, T, Q>(Pf1.x, Pf1.y, Pf1.z, Pf0.w));
+		T n0001 = dot(g0001, vec<4, T, Q>(Pf0.x, Pf0.y, Pf0.z, Pf1.w));
+		T n1001 = dot(g1001, vec<4, T, Q>(Pf1.x, Pf0.y, Pf0.z, Pf1.w));
+		T n0101 = dot(g0101, vec<4, T, Q>(Pf0.x, Pf1.y, Pf0.z, Pf1.w));
+		T n1101 = dot(g1101, vec<4, T, Q>(Pf1.x, Pf1.y, Pf0.z, Pf1.w));
+		T n0011 = dot(g0011, vec<4, T, Q>(Pf0.x, Pf0.y, Pf1.z, Pf1.w));
+		T n1011 = dot(g1011, vec<4, T, Q>(Pf1.x, Pf0.y, Pf1.z, Pf1.w));
+		T n0111 = dot(g0111, vec<4, T, Q>(Pf0.x, Pf1.y, Pf1.z, Pf1.w));
+		T n1111 = dot(g1111, Pf1);
+
+		vec<4, T, Q> fade_xyzw = detail::fade(Pf0);
+		vec<4, T, Q> n_0w = mix(vec<4, T, Q>(n0000, n1000, n0100, n1100), vec<4, T, Q>(n0001, n1001, n0101, n1101), fade_xyzw.w);
+		vec<4, T, Q> n_1w = mix(vec<4, T, Q>(n0010, n1010, n0110, n1110), vec<4, T, Q>(n0011, n1011, n0111, n1111), fade_xyzw.w);
+		vec<4, T, Q> n_zw = mix(n_0w, n_1w, fade_xyzw.z);
+		vec<2, T, Q> n_yzw = mix(vec<2, T, Q>(n_zw.x, n_zw.y), vec<2, T, Q>(n_zw.z, n_zw.w), fade_xyzw.y);
+		T n_xyzw = mix(n_yzw.x, n_yzw.y, fade_xyzw.x);
+		return T(2.2) * n_xyzw;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T simplex(glm::vec<2, T, Q> const& v)
+	{
+		vec<4, T, Q> const C = vec<4, T, Q>(
+			T( 0.211324865405187),  // (3.0 -  sqrt(3.0)) / 6.0
+			T( 0.366025403784439),  //  0.5 * (sqrt(3.0)  - 1.0)
+			T(-0.577350269189626),	// -1.0 + 2.0 * C.x
+			T( 0.024390243902439)); //  1.0 / 41.0
+
+		// First corner
+		vec<2, T, Q> i  = floor(v + dot(v, vec<2, T, Q>(C[1])));
+		vec<2, T, Q> x0 = v -   i + dot(i, vec<2, T, Q>(C[0]));
+
+		// Other corners
+		//i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
+		//i1.y = 1.0 - i1.x;
+		vec<2, T, Q> i1 = (x0.x > x0.y) ? vec<2, T, Q>(1, 0) : vec<2, T, Q>(0, 1);
+		// x0 = x0 - 0.0 + 0.0 * C.xx ;
+		// x1 = x0 - i1 + 1.0 * C.xx ;
+		// x2 = x0 - 1.0 + 2.0 * C.xx ;
+		vec<4, T, Q> x12 = vec<4, T, Q>(x0.x, x0.y, x0.x, x0.y) + vec<4, T, Q>(C.x, C.x, C.z, C.z);
+		x12 = vec<4, T, Q>(vec<2, T, Q>(x12) - i1, x12.z, x12.w);
+
+		// Permutations
+		i = mod(i, vec<2, T, Q>(289)); // Avoid truncation effects in permutation
+		vec<3, T, Q> p = detail::permute(
+			detail::permute(i.y + vec<3, T, Q>(T(0), i1.y, T(1)))
+			+ i.x + vec<3, T, Q>(T(0), i1.x, T(1)));
+
+		vec<3, T, Q> m = max(vec<3, T, Q>(0.5) - vec<3, T, Q>(
+			dot(x0, x0),
+			dot(vec<2, T, Q>(x12.x, x12.y), vec<2, T, Q>(x12.x, x12.y)),
+			dot(vec<2, T, Q>(x12.z, x12.w), vec<2, T, Q>(x12.z, x12.w))), vec<3, T, Q>(0));
+		m = m * m ;
+		m = m * m ;
+
+		// Gradients: 41 points uniformly over a line, mapped onto a diamond.
+		// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
+
+		vec<3, T, Q> x = static_cast<T>(2) * fract(p * C.w) - T(1);
+		vec<3, T, Q> h = abs(x) - T(0.5);
+		vec<3, T, Q> ox = floor(x + T(0.5));
+		vec<3, T, Q> a0 = x - ox;
+
+		// Normalise gradients implicitly by scaling m
+		// Inlined for speed: m *= taylorInvSqrt( a0*a0 + h*h );
+		m *= static_cast<T>(1.79284291400159) - T(0.85373472095314) * (a0 * a0 + h * h);
+
+		// Compute final noise value at P
+		vec<3, T, Q> g;
+		g.x  = a0.x  * x0.x  + h.x  * x0.y;
+		//g.yz = a0.yz * x12.xz + h.yz * x12.yw;
+		g.y = a0.y * x12.x + h.y * x12.y;
+		g.z = a0.z * x12.z + h.z * x12.w;
+		return T(130) * dot(m, g);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T simplex(vec<3, T, Q> const& v)
+	{
+		vec<2, T, Q> const C(1.0 / 6.0, 1.0 / 3.0);
+		vec<4, T, Q> const D(0.0, 0.5, 1.0, 2.0);
+
+		// First corner
+		vec<3, T, Q> i(floor(v + dot(v, vec<3, T, Q>(C.y))));
+		vec<3, T, Q> x0(v - i + dot(i, vec<3, T, Q>(C.x)));
+
+		// Other corners
+		vec<3, T, Q> g(step(vec<3, T, Q>(x0.y, x0.z, x0.x), x0));
+		vec<3, T, Q> l(T(1) - g);
+		vec<3, T, Q> i1(min(g, vec<3, T, Q>(l.z, l.x, l.y)));
+		vec<3, T, Q> i2(max(g, vec<3, T, Q>(l.z, l.x, l.y)));
+
+		//   x0 = x0 - 0.0 + 0.0 * C.xxx;
+		//   x1 = x0 - i1  + 1.0 * C.xxx;
+		//   x2 = x0 - i2  + 2.0 * C.xxx;
+		//   x3 = x0 - 1.0 + 3.0 * C.xxx;
+		vec<3, T, Q> x1(x0 - i1 + C.x);
+		vec<3, T, Q> x2(x0 - i2 + C.y); // 2.0*C.x = 1/3 = C.y
+		vec<3, T, Q> x3(x0 - D.y);      // -1.0+3.0*C.x = -0.5 = -D.y
+
+		// Permutations
+		i = detail::mod289(i);
+		vec<4, T, Q> p(detail::permute(detail::permute(detail::permute(
+			i.z + vec<4, T, Q>(T(0), i1.z, i2.z, T(1))) +
+			i.y + vec<4, T, Q>(T(0), i1.y, i2.y, T(1))) +
+			i.x + vec<4, T, Q>(T(0), i1.x, i2.x, T(1))));
+
+		// Gradients: 7x7 points over a square, mapped onto an octahedron.
+		// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
+		T n_ = static_cast<T>(0.142857142857); // 1.0/7.0
+		vec<3, T, Q> ns(n_ * vec<3, T, Q>(D.w, D.y, D.z) - vec<3, T, Q>(D.x, D.z, D.x));
+
+		vec<4, T, Q> j(p - T(49) * floor(p * ns.z * ns.z));  //  mod(p,7*7)
+
+		vec<4, T, Q> x_(floor(j * ns.z));
+		vec<4, T, Q> y_(floor(j - T(7) * x_));    // mod(j,N)
+
+		vec<4, T, Q> x(x_ * ns.x + ns.y);
+		vec<4, T, Q> y(y_ * ns.x + ns.y);
+		vec<4, T, Q> h(T(1) - abs(x) - abs(y));
+
+		vec<4, T, Q> b0(x.x, x.y, y.x, y.y);
+		vec<4, T, Q> b1(x.z, x.w, y.z, y.w);
+
+		// vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
+		// vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
+		vec<4, T, Q> s0(floor(b0) * T(2) + T(1));
+		vec<4, T, Q> s1(floor(b1) * T(2) + T(1));
+		vec<4, T, Q> sh(-step(h, vec<4, T, Q>(0.0)));
+
+		vec<4, T, Q> a0 = vec<4, T, Q>(b0.x, b0.z, b0.y, b0.w) + vec<4, T, Q>(s0.x, s0.z, s0.y, s0.w) * vec<4, T, Q>(sh.x, sh.x, sh.y, sh.y);
+		vec<4, T, Q> a1 = vec<4, T, Q>(b1.x, b1.z, b1.y, b1.w) + vec<4, T, Q>(s1.x, s1.z, s1.y, s1.w) * vec<4, T, Q>(sh.z, sh.z, sh.w, sh.w);
+
+		vec<3, T, Q> p0(a0.x, a0.y, h.x);
+		vec<3, T, Q> p1(a0.z, a0.w, h.y);
+		vec<3, T, Q> p2(a1.x, a1.y, h.z);
+		vec<3, T, Q> p3(a1.z, a1.w, h.w);
+
+		// Normalise gradients
+		vec<4, T, Q> norm = detail::taylorInvSqrt(vec<4, T, Q>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
+		p0 *= norm.x;
+		p1 *= norm.y;
+		p2 *= norm.z;
+		p3 *= norm.w;
+
+		// Mix final noise value
+		vec<4, T, Q> m = max(T(0.6) - vec<4, T, Q>(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), vec<4, T, Q>(0));
+		m = m * m;
+		return T(42) * dot(m * m, vec<4, T, Q>(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3)));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T simplex(vec<4, T, Q> const& v)
+	{
+		vec<4, T, Q> const C(
+			0.138196601125011,  // (5 - sqrt(5))/20  G4
+			0.276393202250021,  // 2 * G4
+			0.414589803375032,  // 3 * G4
+			-0.447213595499958); // -1 + 4 * G4
+
+		// (sqrt(5) - 1)/4 = F4, used once below
+		T const F4 = static_cast<T>(0.309016994374947451);
+
+		// First corner
+		vec<4, T, Q> i  = floor(v + dot(v, vec<4, T, Q>(F4)));
+		vec<4, T, Q> x0 = v -   i + dot(i, vec<4, T, Q>(C.x));
+
+		// Other corners
+
+		// Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI)
+		vec<4, T, Q> i0;
+		vec<3, T, Q> isX = step(vec<3, T, Q>(x0.y, x0.z, x0.w), vec<3, T, Q>(x0.x));
+		vec<3, T, Q> isYZ = step(vec<3, T, Q>(x0.z, x0.w, x0.w), vec<3, T, Q>(x0.y, x0.y, x0.z));
+		//  i0.x = dot(isX, vec3(1.0));
+		//i0.x = isX.x + isX.y + isX.z;
+		//i0.yzw = static_cast<T>(1) - isX;
+		i0 = vec<4, T, Q>(isX.x + isX.y + isX.z, T(1) - isX);
+		//  i0.y += dot(isYZ.xy, vec2(1.0));
+		i0.y += isYZ.x + isYZ.y;
+		//i0.zw += 1.0 - vec<2, T, Q>(isYZ.x, isYZ.y);
+		i0.z += static_cast<T>(1) - isYZ.x;
+		i0.w += static_cast<T>(1) - isYZ.y;
+		i0.z += isYZ.z;
+		i0.w += static_cast<T>(1) - isYZ.z;
+
+		// i0 now contains the unique values 0,1,2,3 in each channel
+		vec<4, T, Q> i3 = clamp(i0, T(0), T(1));
+		vec<4, T, Q> i2 = clamp(i0 - T(1), T(0), T(1));
+		vec<4, T, Q> i1 = clamp(i0 - T(2), T(0), T(1));
+
+		//  x0 = x0 - 0.0 + 0.0 * C.xxxx
+		//  x1 = x0 - i1  + 0.0 * C.xxxx
+		//  x2 = x0 - i2  + 0.0 * C.xxxx
+		//  x3 = x0 - i3  + 0.0 * C.xxxx
+		//  x4 = x0 - 1.0 + 4.0 * C.xxxx
+		vec<4, T, Q> x1 = x0 - i1 + C.x;
+		vec<4, T, Q> x2 = x0 - i2 + C.y;
+		vec<4, T, Q> x3 = x0 - i3 + C.z;
+		vec<4, T, Q> x4 = x0 + C.w;
+
+		// Permutations
+		i = mod(i, vec<4, T, Q>(289));
+		T j0 = detail::permute(detail::permute(detail::permute(detail::permute(i.w) + i.z) + i.y) + i.x);
+		vec<4, T, Q> j1 = detail::permute(detail::permute(detail::permute(detail::permute(
+			i.w + vec<4, T, Q>(i1.w, i2.w, i3.w, T(1))) +
+			i.z + vec<4, T, Q>(i1.z, i2.z, i3.z, T(1))) +
+			i.y + vec<4, T, Q>(i1.y, i2.y, i3.y, T(1))) +
+			i.x + vec<4, T, Q>(i1.x, i2.x, i3.x, T(1)));
+
+		// Gradients: 7x7x6 points over a cube, mapped onto a 4-cross polytope
+		// 7*7*6 = 294, which is close to the ring size 17*17 = 289.
+		vec<4, T, Q> ip = vec<4, T, Q>(T(1) / T(294), T(1) / T(49), T(1) / T(7), T(0));
+
+		vec<4, T, Q> p0 = gtc::grad4(j0,   ip);
+		vec<4, T, Q> p1 = gtc::grad4(j1.x, ip);
+		vec<4, T, Q> p2 = gtc::grad4(j1.y, ip);
+		vec<4, T, Q> p3 = gtc::grad4(j1.z, ip);
+		vec<4, T, Q> p4 = gtc::grad4(j1.w, ip);
+
+		// Normalise gradients
+		vec<4, T, Q> norm = detail::taylorInvSqrt(vec<4, T, Q>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
+		p0 *= norm.x;
+		p1 *= norm.y;
+		p2 *= norm.z;
+		p3 *= norm.w;
+		p4 *= detail::taylorInvSqrt(dot(p4, p4));
+
+		// Mix contributions from the five corners
+		vec<3, T, Q> m0 = max(T(0.6) - vec<3, T, Q>(dot(x0, x0), dot(x1, x1), dot(x2, x2)), vec<3, T, Q>(0));
+		vec<2, T, Q> m1 = max(T(0.6) - vec<2, T, Q>(dot(x3, x3), dot(x4, x4)             ), vec<2, T, Q>(0));
+		m0 = m0 * m0;
+		m1 = m1 * m1;
+		return T(49) *
+			(dot(m0 * m0, vec<3, T, Q>(dot(p0, x0), dot(p1, x1), dot(p2, x2))) +
+			dot(m1 * m1, vec<2, T, Q>(dot(p3, x3), dot(p4, x4))));
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtc/packing.hpp b/engine/inc/glm/gtc/packing.hpp
new file mode 100644
index 00000000..28523952
--- /dev/null
+++ b/engine/inc/glm/gtc/packing.hpp
@@ -0,0 +1,728 @@
+/// @ref gtc_packing
+/// @file glm/gtc/packing.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtc_packing GLM_GTC_packing
+/// @ingroup gtc
+///
+/// Include <glm/gtc/packing.hpp> to use the features of this extension.
+///
+/// This extension provides a set of function to convert vertors to packed
+/// formats.
+
+#pragma once
+
+// Dependency:
+#include "type_precision.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTC_packing extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtc_packing
+	/// @{
+
+	/// First, converts the normalized floating-point value v into a 8-bit integer value.
+	/// Then, the results are packed into the returned 8-bit unsigned integer.
+	///
+	/// The conversion for component c of v to fixed point is done as follows:
+	/// packUnorm1x8:	round(clamp(c, 0, +1) * 255.0)
+	///
+	/// @see gtc_packing
+	/// @see uint16 packUnorm2x8(vec2 const& v)
+	/// @see uint32 packUnorm4x8(vec4 const& v)
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm4x8.xml">GLSL packUnorm4x8 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL uint8 packUnorm1x8(float v);
+
+	/// Convert a single 8-bit integer to a normalized floating-point value.
+	///
+	/// The conversion for unpacked fixed-point value f to floating point is done as follows:
+	/// unpackUnorm4x8: f / 255.0
+	///
+	/// @see gtc_packing
+	/// @see vec2 unpackUnorm2x8(uint16 p)
+	/// @see vec4 unpackUnorm4x8(uint32 p)
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm4x8.xml">GLSL unpackUnorm4x8 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL float unpackUnorm1x8(uint8 p);
+
+	/// First, converts each component of the normalized floating-point value v into 8-bit integer values.
+	/// Then, the results are packed into the returned 16-bit unsigned integer.
+	///
+	/// The conversion for component c of v to fixed point is done as follows:
+	/// packUnorm2x8:	round(clamp(c, 0, +1) * 255.0)
+	///
+	/// The first component of the vector will be written to the least significant bits of the output;
+	/// the last component will be written to the most significant bits.
+	///
+	/// @see gtc_packing
+	/// @see uint8 packUnorm1x8(float const& v)
+	/// @see uint32 packUnorm4x8(vec4 const& v)
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm4x8.xml">GLSL packUnorm4x8 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL uint16 packUnorm2x8(vec2 const& v);
+
+	/// First, unpacks a single 16-bit unsigned integer p into a pair of 8-bit unsigned integers.
+	/// Then, each component is converted to a normalized floating-point value to generate the returned two-component vector.
+	///
+	/// The conversion for unpacked fixed-point value f to floating point is done as follows:
+	/// unpackUnorm4x8: f / 255.0
+	///
+	/// The first component of the returned vector will be extracted from the least significant bits of the input;
+	/// the last component will be extracted from the most significant bits.
+	///
+	/// @see gtc_packing
+	/// @see float unpackUnorm1x8(uint8 v)
+	/// @see vec4 unpackUnorm4x8(uint32 p)
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm4x8.xml">GLSL unpackUnorm4x8 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL vec2 unpackUnorm2x8(uint16 p);
+
+	/// First, converts the normalized floating-point value v into 8-bit integer value.
+	/// Then, the results are packed into the returned 8-bit unsigned integer.
+	///
+	/// The conversion to fixed point is done as follows:
+	/// packSnorm1x8:	round(clamp(s, -1, +1) * 127.0)
+	///
+	/// @see gtc_packing
+	/// @see uint16 packSnorm2x8(vec2 const& v)
+	/// @see uint32 packSnorm4x8(vec4 const& v)
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm4x8.xml">GLSL packSnorm4x8 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL uint8 packSnorm1x8(float s);
+
+	/// First, unpacks a single 8-bit unsigned integer p into a single 8-bit signed integers.
+	/// Then, the value is converted to a normalized floating-point value to generate the returned scalar.
+	///
+	/// The conversion for unpacked fixed-point value f to floating point is done as follows:
+	/// unpackSnorm1x8: clamp(f / 127.0, -1, +1)
+	///
+	/// @see gtc_packing
+	/// @see vec2 unpackSnorm2x8(uint16 p)
+	/// @see vec4 unpackSnorm4x8(uint32 p)
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm4x8.xml">GLSL unpackSnorm4x8 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL float unpackSnorm1x8(uint8 p);
+
+	/// First, converts each component of the normalized floating-point value v into 8-bit integer values.
+	/// Then, the results are packed into the returned 16-bit unsigned integer.
+	///
+	/// The conversion for component c of v to fixed point is done as follows:
+	/// packSnorm2x8:	round(clamp(c, -1, +1) * 127.0)
+	///
+	/// The first component of the vector will be written to the least significant bits of the output;
+	/// the last component will be written to the most significant bits.
+	///
+	/// @see gtc_packing
+	/// @see uint8 packSnorm1x8(float const& v)
+	/// @see uint32 packSnorm4x8(vec4 const& v)
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm4x8.xml">GLSL packSnorm4x8 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL uint16 packSnorm2x8(vec2 const& v);
+
+	/// First, unpacks a single 16-bit unsigned integer p into a pair of 8-bit signed integers.
+	/// Then, each component is converted to a normalized floating-point value to generate the returned two-component vector.
+	///
+	/// The conversion for unpacked fixed-point value f to floating point is done as follows:
+	/// unpackSnorm2x8: clamp(f / 127.0, -1, +1)
+	///
+	/// The first component of the returned vector will be extracted from the least significant bits of the input;
+	/// the last component will be extracted from the most significant bits.
+	///
+	/// @see gtc_packing
+	/// @see float unpackSnorm1x8(uint8 p)
+	/// @see vec4 unpackSnorm4x8(uint32 p)
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm4x8.xml">GLSL unpackSnorm4x8 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL vec2 unpackSnorm2x8(uint16 p);
+
+	/// First, converts the normalized floating-point value v into a 16-bit integer value.
+	/// Then, the results are packed into the returned 16-bit unsigned integer.
+	///
+	/// The conversion for component c of v to fixed point is done as follows:
+	/// packUnorm1x16:	round(clamp(c, 0, +1) * 65535.0)
+	///
+	/// @see gtc_packing
+	/// @see uint16 packSnorm1x16(float const& v)
+	/// @see uint64 packSnorm4x16(vec4 const& v)
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm4x8.xml">GLSL packUnorm4x8 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL uint16 packUnorm1x16(float v);
+
+	/// First, unpacks a single 16-bit unsigned integer p into a of 16-bit unsigned integers.
+	/// Then, the value is converted to a normalized floating-point value to generate the returned scalar.
+	///
+	/// The conversion for unpacked fixed-point value f to floating point is done as follows:
+	/// unpackUnorm1x16: f / 65535.0
+	///
+	/// @see gtc_packing
+	/// @see vec2 unpackUnorm2x16(uint32 p)
+	/// @see vec4 unpackUnorm4x16(uint64 p)
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm2x16.xml">GLSL unpackUnorm2x16 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL float unpackUnorm1x16(uint16 p);
+
+	/// First, converts each component of the normalized floating-point value v into 16-bit integer values.
+	/// Then, the results are packed into the returned 64-bit unsigned integer.
+	///
+	/// The conversion for component c of v to fixed point is done as follows:
+	/// packUnorm4x16:	round(clamp(c, 0, +1) * 65535.0)
+	///
+	/// The first component of the vector will be written to the least significant bits of the output;
+	/// the last component will be written to the most significant bits.
+	///
+	/// @see gtc_packing
+	/// @see uint16 packUnorm1x16(float const& v)
+	/// @see uint32 packUnorm2x16(vec2 const& v)
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm4x8.xml">GLSL packUnorm4x8 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL uint64 packUnorm4x16(vec4 const& v);
+
+	/// First, unpacks a single 64-bit unsigned integer p into four 16-bit unsigned integers.
+	/// Then, each component is converted to a normalized floating-point value to generate the returned four-component vector.
+	///
+	/// The conversion for unpacked fixed-point value f to floating point is done as follows:
+	/// unpackUnormx4x16: f / 65535.0
+	///
+	/// The first component of the returned vector will be extracted from the least significant bits of the input;
+	/// the last component will be extracted from the most significant bits.
+	///
+	/// @see gtc_packing
+	/// @see float unpackUnorm1x16(uint16 p)
+	/// @see vec2 unpackUnorm2x16(uint32 p)
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm2x16.xml">GLSL unpackUnorm2x16 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL vec4 unpackUnorm4x16(uint64 p);
+
+	/// First, converts the normalized floating-point value v into 16-bit integer value.
+	/// Then, the results are packed into the returned 16-bit unsigned integer.
+	///
+	/// The conversion to fixed point is done as follows:
+	/// packSnorm1x8:	round(clamp(s, -1, +1) * 32767.0)
+	///
+	/// @see gtc_packing
+	/// @see uint32 packSnorm2x16(vec2 const& v)
+	/// @see uint64 packSnorm4x16(vec4 const& v)
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm4x8.xml">GLSL packSnorm4x8 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL uint16 packSnorm1x16(float v);
+
+	/// First, unpacks a single 16-bit unsigned integer p into a single 16-bit signed integers.
+	/// Then, each component is converted to a normalized floating-point value to generate the returned scalar.
+	///
+	/// The conversion for unpacked fixed-point value f to floating point is done as follows:
+	/// unpackSnorm1x16: clamp(f / 32767.0, -1, +1)
+	///
+	/// @see gtc_packing
+	/// @see vec2 unpackSnorm2x16(uint32 p)
+	/// @see vec4 unpackSnorm4x16(uint64 p)
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm1x16.xml">GLSL unpackSnorm4x8 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL float unpackSnorm1x16(uint16 p);
+
+	/// First, converts each component of the normalized floating-point value v into 16-bit integer values.
+	/// Then, the results are packed into the returned 64-bit unsigned integer.
+	///
+	/// The conversion for component c of v to fixed point is done as follows:
+	/// packSnorm2x8:	round(clamp(c, -1, +1) * 32767.0)
+	///
+	/// The first component of the vector will be written to the least significant bits of the output;
+	/// the last component will be written to the most significant bits.
+	///
+	/// @see gtc_packing
+	/// @see uint16 packSnorm1x16(float const& v)
+	/// @see uint32 packSnorm2x16(vec2 const& v)
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm4x8.xml">GLSL packSnorm4x8 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL uint64 packSnorm4x16(vec4 const& v);
+
+	/// First, unpacks a single 64-bit unsigned integer p into four 16-bit signed integers.
+	/// Then, each component is converted to a normalized floating-point value to generate the returned four-component vector.
+	///
+	/// The conversion for unpacked fixed-point value f to floating point is done as follows:
+	/// unpackSnorm4x16: clamp(f / 32767.0, -1, +1)
+	///
+	/// The first component of the returned vector will be extracted from the least significant bits of the input;
+	/// the last component will be extracted from the most significant bits.
+	///
+	/// @see gtc_packing
+	/// @see float unpackSnorm1x16(uint16 p)
+	/// @see vec2 unpackSnorm2x16(uint32 p)
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm2x16.xml">GLSL unpackSnorm4x8 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL vec4 unpackSnorm4x16(uint64 p);
+
+	/// Returns an unsigned integer obtained by converting the components of a floating-point scalar
+	/// to the 16-bit floating-point representation found in the OpenGL Specification,
+	/// and then packing this 16-bit value into a 16-bit unsigned integer.
+	///
+	/// @see gtc_packing
+	/// @see uint32 packHalf2x16(vec2 const& v)
+	/// @see uint64 packHalf4x16(vec4 const& v)
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packHalf2x16.xml">GLSL packHalf2x16 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL uint16 packHalf1x16(float v);
+
+	/// Returns a floating-point scalar with components obtained by unpacking a 16-bit unsigned integer into a 16-bit value,
+	/// interpreted as a 16-bit floating-point number according to the OpenGL Specification,
+	/// and converting it to 32-bit floating-point values.
+	///
+	/// @see gtc_packing
+	/// @see vec2 unpackHalf2x16(uint32 const& v)
+	/// @see vec4 unpackHalf4x16(uint64 const& v)
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackHalf2x16.xml">GLSL unpackHalf2x16 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL float unpackHalf1x16(uint16 v);
+
+	/// Returns an unsigned integer obtained by converting the components of a four-component floating-point vector
+	/// to the 16-bit floating-point representation found in the OpenGL Specification,
+	/// and then packing these four 16-bit values into a 64-bit unsigned integer.
+	/// The first vector component specifies the 16 least-significant bits of the result;
+	/// the forth component specifies the 16 most-significant bits.
+	///
+	/// @see gtc_packing
+	/// @see uint16 packHalf1x16(float const& v)
+	/// @see uint32 packHalf2x16(vec2 const& v)
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packHalf2x16.xml">GLSL packHalf2x16 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL uint64 packHalf4x16(vec4 const& v);
+
+	/// Returns a four-component floating-point vector with components obtained by unpacking a 64-bit unsigned integer into four 16-bit values,
+	/// interpreting those values as 16-bit floating-point numbers according to the OpenGL Specification,
+	/// and converting them to 32-bit floating-point values.
+	/// The first component of the vector is obtained from the 16 least-significant bits of v;
+	/// the forth component is obtained from the 16 most-significant bits of v.
+	///
+	/// @see gtc_packing
+	/// @see float unpackHalf1x16(uint16 const& v)
+	/// @see vec2 unpackHalf2x16(uint32 const& v)
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackHalf2x16.xml">GLSL unpackHalf2x16 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL vec4 unpackHalf4x16(uint64 p);
+
+	/// Returns an unsigned integer obtained by converting the components of a four-component signed integer vector
+	/// to the 10-10-10-2-bit signed integer representation found in the OpenGL Specification,
+	/// and then packing these four values into a 32-bit unsigned integer.
+	/// The first vector component specifies the 10 least-significant bits of the result;
+	/// the forth component specifies the 2 most-significant bits.
+	///
+	/// @see gtc_packing
+	/// @see uint32 packI3x10_1x2(uvec4 const& v)
+	/// @see uint32 packSnorm3x10_1x2(vec4 const& v)
+	/// @see uint32 packUnorm3x10_1x2(vec4 const& v)
+	/// @see ivec4 unpackI3x10_1x2(uint32 const& p)
+	GLM_FUNC_DECL uint32 packI3x10_1x2(ivec4 const& v);
+
+	/// Unpacks a single 32-bit unsigned integer p into three 10-bit and one 2-bit signed integers.
+	///
+	/// The first component of the returned vector will be extracted from the least significant bits of the input;
+	/// the last component will be extracted from the most significant bits.
+	///
+	/// @see gtc_packing
+	/// @see uint32 packU3x10_1x2(uvec4 const& v)
+	/// @see vec4 unpackSnorm3x10_1x2(uint32 const& p);
+	/// @see uvec4 unpackI3x10_1x2(uint32 const& p);
+	GLM_FUNC_DECL ivec4 unpackI3x10_1x2(uint32 p);
+
+	/// Returns an unsigned integer obtained by converting the components of a four-component unsigned integer vector
+	/// to the 10-10-10-2-bit unsigned integer representation found in the OpenGL Specification,
+	/// and then packing these four values into a 32-bit unsigned integer.
+	/// The first vector component specifies the 10 least-significant bits of the result;
+	/// the forth component specifies the 2 most-significant bits.
+	///
+	/// @see gtc_packing
+	/// @see uint32 packI3x10_1x2(ivec4 const& v)
+	/// @see uint32 packSnorm3x10_1x2(vec4 const& v)
+	/// @see uint32 packUnorm3x10_1x2(vec4 const& v)
+	/// @see ivec4 unpackU3x10_1x2(uint32 const& p)
+	GLM_FUNC_DECL uint32 packU3x10_1x2(uvec4 const& v);
+
+	/// Unpacks a single 32-bit unsigned integer p into three 10-bit and one 2-bit unsigned integers.
+	///
+	/// The first component of the returned vector will be extracted from the least significant bits of the input;
+	/// the last component will be extracted from the most significant bits.
+	///
+	/// @see gtc_packing
+	/// @see uint32 packU3x10_1x2(uvec4 const& v)
+	/// @see vec4 unpackSnorm3x10_1x2(uint32 const& p);
+	/// @see uvec4 unpackI3x10_1x2(uint32 const& p);
+	GLM_FUNC_DECL uvec4 unpackU3x10_1x2(uint32 p);
+
+	/// First, converts the first three components of the normalized floating-point value v into 10-bit signed integer values.
+	/// Then, converts the forth component of the normalized floating-point value v into 2-bit signed integer values.
+	/// Then, the results are packed into the returned 32-bit unsigned integer.
+	///
+	/// The conversion for component c of v to fixed point is done as follows:
+	/// packSnorm3x10_1x2(xyz):	round(clamp(c, -1, +1) * 511.0)
+	/// packSnorm3x10_1x2(w):	round(clamp(c, -1, +1) * 1.0)
+	///
+	/// The first vector component specifies the 10 least-significant bits of the result;
+	/// the forth component specifies the 2 most-significant bits.
+	///
+	/// @see gtc_packing
+	/// @see vec4 unpackSnorm3x10_1x2(uint32 const& p)
+	/// @see uint32 packUnorm3x10_1x2(vec4 const& v)
+	/// @see uint32 packU3x10_1x2(uvec4 const& v)
+	/// @see uint32 packI3x10_1x2(ivec4 const& v)
+	GLM_FUNC_DECL uint32 packSnorm3x10_1x2(vec4 const& v);
+
+	/// First, unpacks a single 32-bit unsigned integer p into four 16-bit signed integers.
+	/// Then, each component is converted to a normalized floating-point value to generate the returned four-component vector.
+	///
+	/// The conversion for unpacked fixed-point value f to floating point is done as follows:
+	/// unpackSnorm3x10_1x2(xyz): clamp(f / 511.0, -1, +1)
+	/// unpackSnorm3x10_1x2(w): clamp(f / 511.0, -1, +1)
+	///
+	/// The first component of the returned vector will be extracted from the least significant bits of the input;
+	/// the last component will be extracted from the most significant bits.
+	///
+	/// @see gtc_packing
+	/// @see uint32 packSnorm3x10_1x2(vec4 const& v)
+	/// @see vec4 unpackUnorm3x10_1x2(uint32 const& p))
+	/// @see uvec4 unpackI3x10_1x2(uint32 const& p)
+	/// @see uvec4 unpackU3x10_1x2(uint32 const& p)
+	GLM_FUNC_DECL vec4 unpackSnorm3x10_1x2(uint32 p);
+
+	/// First, converts the first three components of the normalized floating-point value v into 10-bit unsigned integer values.
+	/// Then, converts the forth component of the normalized floating-point value v into 2-bit signed uninteger values.
+	/// Then, the results are packed into the returned 32-bit unsigned integer.
+	///
+	/// The conversion for component c of v to fixed point is done as follows:
+	/// packUnorm3x10_1x2(xyz):	round(clamp(c, 0, +1) * 1023.0)
+	/// packUnorm3x10_1x2(w):	round(clamp(c, 0, +1) * 3.0)
+	///
+	/// The first vector component specifies the 10 least-significant bits of the result;
+	/// the forth component specifies the 2 most-significant bits.
+	///
+	/// @see gtc_packing
+	/// @see vec4 unpackUnorm3x10_1x2(uint32 const& p)
+	/// @see uint32 packUnorm3x10_1x2(vec4 const& v)
+	/// @see uint32 packU3x10_1x2(uvec4 const& v)
+	/// @see uint32 packI3x10_1x2(ivec4 const& v)
+	GLM_FUNC_DECL uint32 packUnorm3x10_1x2(vec4 const& v);
+
+	/// First, unpacks a single 32-bit unsigned integer p into four 16-bit signed integers.
+	/// Then, each component is converted to a normalized floating-point value to generate the returned four-component vector.
+	///
+	/// The conversion for unpacked fixed-point value f to floating point is done as follows:
+	/// unpackSnorm3x10_1x2(xyz): clamp(f / 1023.0, 0, +1)
+	/// unpackSnorm3x10_1x2(w): clamp(f / 3.0, 0, +1)
+	///
+	/// The first component of the returned vector will be extracted from the least significant bits of the input;
+	/// the last component will be extracted from the most significant bits.
+	///
+	/// @see gtc_packing
+	/// @see uint32 packSnorm3x10_1x2(vec4 const& v)
+	/// @see vec4 unpackInorm3x10_1x2(uint32 const& p))
+	/// @see uvec4 unpackI3x10_1x2(uint32 const& p)
+	/// @see uvec4 unpackU3x10_1x2(uint32 const& p)
+	GLM_FUNC_DECL vec4 unpackUnorm3x10_1x2(uint32 p);
+
+	/// First, converts the first two components of the normalized floating-point value v into 11-bit signless floating-point values.
+	/// Then, converts the third component of the normalized floating-point value v into a 10-bit signless floating-point value.
+	/// Then, the results are packed into the returned 32-bit unsigned integer.
+	///
+	/// The first vector component specifies the 11 least-significant bits of the result;
+	/// the last component specifies the 10 most-significant bits.
+	///
+	/// @see gtc_packing
+	/// @see vec3 unpackF2x11_1x10(uint32 const& p)
+	GLM_FUNC_DECL uint32 packF2x11_1x10(vec3 const& v);
+
+	/// First, unpacks a single 32-bit unsigned integer p into two 11-bit signless floating-point values and one 10-bit signless floating-point value .
+	/// Then, each component is converted to a normalized floating-point value to generate the returned three-component vector.
+	///
+	/// The first component of the returned vector will be extracted from the least significant bits of the input;
+	/// the last component will be extracted from the most significant bits.
+	///
+	/// @see gtc_packing
+	/// @see uint32 packF2x11_1x10(vec3 const& v)
+	GLM_FUNC_DECL vec3 unpackF2x11_1x10(uint32 p);
+
+
+	/// First, converts the first two components of the normalized floating-point value v into 11-bit signless floating-point values.
+	/// Then, converts the third component of the normalized floating-point value v into a 10-bit signless floating-point value.
+	/// Then, the results are packed into the returned 32-bit unsigned integer.
+	///
+	/// The first vector component specifies the 11 least-significant bits of the result;
+	/// the last component specifies the 10 most-significant bits.
+	///
+	/// packF3x9_E1x5 allows encoding into RGBE / RGB9E5 format
+	///
+	/// @see gtc_packing
+	/// @see vec3 unpackF3x9_E1x5(uint32 const& p)
+	GLM_FUNC_DECL uint32 packF3x9_E1x5(vec3 const& v);
+
+	/// First, unpacks a single 32-bit unsigned integer p into two 11-bit signless floating-point values and one 10-bit signless floating-point value .
+	/// Then, each component is converted to a normalized floating-point value to generate the returned three-component vector.
+	///
+	/// The first component of the returned vector will be extracted from the least significant bits of the input;
+	/// the last component will be extracted from the most significant bits.
+	///
+	/// unpackF3x9_E1x5 allows decoding RGBE / RGB9E5 data
+	///
+	/// @see gtc_packing
+	/// @see uint32 packF3x9_E1x5(vec3 const& v)
+	GLM_FUNC_DECL vec3 unpackF3x9_E1x5(uint32 p);
+
+	/// Returns an unsigned integer vector obtained by converting the components of a floating-point vector
+	/// to the 16-bit floating-point representation found in the OpenGL Specification.
+	/// The first vector component specifies the 16 least-significant bits of the result;
+	/// the forth component specifies the 16 most-significant bits.
+	///
+	/// @see gtc_packing
+	/// @see vec<3, T, Q> unpackRGBM(vec<4, T, Q> const& p)
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<4, T, Q> packRGBM(vec<3, T, Q> const& rgb);
+
+	/// Returns a floating-point vector with components obtained by reinterpreting an integer vector as 16-bit floating-point numbers and converting them to 32-bit floating-point values.
+	/// The first component of the vector is obtained from the 16 least-significant bits of v;
+	/// the forth component is obtained from the 16 most-significant bits of v.
+	///
+	/// @see gtc_packing
+	/// @see vec<4, T, Q> packRGBM(vec<3, float, Q> const& v)
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> unpackRGBM(vec<4, T, Q> const& rgbm);
+
+	/// Returns an unsigned integer vector obtained by converting the components of a floating-point vector
+	/// to the 16-bit floating-point representation found in the OpenGL Specification.
+	/// The first vector component specifies the 16 least-significant bits of the result;
+	/// the forth component specifies the 16 most-significant bits.
+	///
+	/// @see gtc_packing
+	/// @see vec<L, float, Q> unpackHalf(vec<L, uint16, Q> const& p)
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	template<length_t L, qualifier Q>
+	GLM_FUNC_DECL vec<L, uint16, Q> packHalf(vec<L, float, Q> const& v);
+
+	/// Returns a floating-point vector with components obtained by reinterpreting an integer vector as 16-bit floating-point numbers and converting them to 32-bit floating-point values.
+	/// The first component of the vector is obtained from the 16 least-significant bits of v;
+	/// the forth component is obtained from the 16 most-significant bits of v.
+	///
+	/// @see gtc_packing
+	/// @see vec<L, uint16, Q> packHalf(vec<L, float, Q> const& v)
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	template<length_t L, qualifier Q>
+	GLM_FUNC_DECL vec<L, float, Q> unpackHalf(vec<L, uint16, Q> const& p);
+
+	/// Convert each component of the normalized floating-point vector into unsigned integer values.
+	///
+	/// @see gtc_packing
+	/// @see vec<L, floatType, Q> unpackUnorm(vec<L, intType, Q> const& p);
+	template<typename uintType, length_t L, typename floatType, qualifier Q>
+	GLM_FUNC_DECL vec<L, uintType, Q> packUnorm(vec<L, floatType, Q> const& v);
+
+	/// Convert a packed integer to a normalized floating-point vector.
+	///
+	/// @see gtc_packing
+	/// @see vec<L, intType, Q> packUnorm(vec<L, floatType, Q> const& v)
+	template<typename floatType, length_t L, typename uintType, qualifier Q>
+	GLM_FUNC_DECL vec<L, floatType, Q> unpackUnorm(vec<L, uintType, Q> const& v);
+
+	/// Convert each component of the normalized floating-point vector into signed integer values.
+	///
+	/// @see gtc_packing
+	/// @see vec<L, floatType, Q> unpackSnorm(vec<L, intType, Q> const& p);
+	template<typename intType, length_t L, typename floatType, qualifier Q>
+	GLM_FUNC_DECL vec<L, intType, Q> packSnorm(vec<L, floatType, Q> const& v);
+
+	/// Convert a packed integer to a normalized floating-point vector.
+	///
+	/// @see gtc_packing
+	/// @see vec<L, intType, Q> packSnorm(vec<L, floatType, Q> const& v)
+	template<typename floatType, length_t L, typename intType, qualifier Q>
+	GLM_FUNC_DECL vec<L, floatType, Q> unpackSnorm(vec<L, intType, Q> const& v);
+
+	/// Convert each component of the normalized floating-point vector into unsigned integer values.
+	///
+	/// @see gtc_packing
+	/// @see vec2 unpackUnorm2x4(uint8 p)
+	GLM_FUNC_DECL uint8 packUnorm2x4(vec2 const& v);
+
+	/// Convert a packed integer to a normalized floating-point vector.
+	///
+	/// @see gtc_packing
+	/// @see uint8 packUnorm2x4(vec2 const& v)
+	GLM_FUNC_DECL vec2 unpackUnorm2x4(uint8 p);
+
+	/// Convert each component of the normalized floating-point vector into unsigned integer values.
+	///
+	/// @see gtc_packing
+	/// @see vec4 unpackUnorm4x4(uint16 p)
+	GLM_FUNC_DECL uint16 packUnorm4x4(vec4 const& v);
+
+	/// Convert a packed integer to a normalized floating-point vector.
+	///
+	/// @see gtc_packing
+	/// @see uint16 packUnorm4x4(vec4 const& v)
+	GLM_FUNC_DECL vec4 unpackUnorm4x4(uint16 p);
+
+	/// Convert each component of the normalized floating-point vector into unsigned integer values.
+	///
+	/// @see gtc_packing
+	/// @see vec3 unpackUnorm1x5_1x6_1x5(uint16 p)
+	GLM_FUNC_DECL uint16 packUnorm1x5_1x6_1x5(vec3 const& v);
+
+	/// Convert a packed integer to a normalized floating-point vector.
+	///
+	/// @see gtc_packing
+	/// @see uint16 packUnorm1x5_1x6_1x5(vec3 const& v)
+	GLM_FUNC_DECL vec3 unpackUnorm1x5_1x6_1x5(uint16 p);
+
+	/// Convert each component of the normalized floating-point vector into unsigned integer values.
+	///
+	/// @see gtc_packing
+	/// @see vec4 unpackUnorm3x5_1x1(uint16 p)
+	GLM_FUNC_DECL uint16 packUnorm3x5_1x1(vec4 const& v);
+
+	/// Convert a packed integer to a normalized floating-point vector.
+	///
+	/// @see gtc_packing
+	/// @see uint16 packUnorm3x5_1x1(vec4 const& v)
+	GLM_FUNC_DECL vec4 unpackUnorm3x5_1x1(uint16 p);
+
+	/// Convert each component of the normalized floating-point vector into unsigned integer values.
+	///
+	/// @see gtc_packing
+	/// @see vec3 unpackUnorm2x3_1x2(uint8 p)
+	GLM_FUNC_DECL uint8 packUnorm2x3_1x2(vec3 const& v);
+
+	/// Convert a packed integer to a normalized floating-point vector.
+	///
+	/// @see gtc_packing
+	/// @see uint8 packUnorm2x3_1x2(vec3 const& v)
+	GLM_FUNC_DECL vec3 unpackUnorm2x3_1x2(uint8 p);
+
+
+
+	/// Convert each component from an integer vector into a packed unsigned integer.
+	///
+	/// @see gtc_packing
+	/// @see i8vec2 unpackInt2x8(int16 p)
+	GLM_FUNC_DECL int16 packInt2x8(i8vec2 const& v);
+
+	/// Convert a packed integer into an integer vector.
+	///
+	/// @see gtc_packing
+	/// @see int16 packInt2x8(i8vec2 const& v)
+	GLM_FUNC_DECL i8vec2 unpackInt2x8(int16 p);
+
+	/// Convert each component from an integer vector into a packed unsigned integer.
+	///
+	/// @see gtc_packing
+	/// @see u8vec2 unpackInt2x8(uint16 p)
+	GLM_FUNC_DECL uint16 packUint2x8(u8vec2 const& v);
+
+	/// Convert a packed integer into an integer vector.
+	///
+	/// @see gtc_packing
+	/// @see uint16 packInt2x8(u8vec2 const& v)
+	GLM_FUNC_DECL u8vec2 unpackUint2x8(uint16 p);
+
+	/// Convert each component from an integer vector into a packed unsigned integer.
+	///
+	/// @see gtc_packing
+	/// @see i8vec4 unpackInt4x8(int32 p)
+	GLM_FUNC_DECL int32 packInt4x8(i8vec4 const& v);
+
+	/// Convert a packed integer into an integer vector.
+	///
+	/// @see gtc_packing
+	/// @see int32 packInt2x8(i8vec4 const& v)
+	GLM_FUNC_DECL i8vec4 unpackInt4x8(int32 p);
+
+	/// Convert each component from an integer vector into a packed unsigned integer.
+	///
+	/// @see gtc_packing
+	/// @see u8vec4 unpackUint4x8(uint32 p)
+	GLM_FUNC_DECL uint32 packUint4x8(u8vec4 const& v);
+
+	/// Convert a packed integer into an integer vector.
+	///
+	/// @see gtc_packing
+	/// @see uint32 packUint4x8(u8vec2 const& v)
+	GLM_FUNC_DECL u8vec4 unpackUint4x8(uint32 p);
+
+	/// Convert each component from an integer vector into a packed unsigned integer.
+	///
+	/// @see gtc_packing
+	/// @see i16vec2 unpackInt2x16(int p)
+	GLM_FUNC_DECL int packInt2x16(i16vec2 const& v);
+
+	/// Convert a packed integer into an integer vector.
+	///
+	/// @see gtc_packing
+	/// @see int packInt2x16(i16vec2 const& v)
+	GLM_FUNC_DECL i16vec2 unpackInt2x16(int p);
+
+	/// Convert each component from an integer vector into a packed unsigned integer.
+	///
+	/// @see gtc_packing
+	/// @see i16vec4 unpackInt4x16(int64 p)
+	GLM_FUNC_DECL int64 packInt4x16(i16vec4 const& v);
+
+	/// Convert a packed integer into an integer vector.
+	///
+	/// @see gtc_packing
+	/// @see int64 packInt4x16(i16vec4 const& v)
+	GLM_FUNC_DECL i16vec4 unpackInt4x16(int64 p);
+
+	/// Convert each component from an integer vector into a packed unsigned integer.
+	///
+	/// @see gtc_packing
+	/// @see u16vec2 unpackUint2x16(uint p)
+	GLM_FUNC_DECL uint packUint2x16(u16vec2 const& v);
+
+	/// Convert a packed integer into an integer vector.
+	///
+	/// @see gtc_packing
+	/// @see uint packUint2x16(u16vec2 const& v)
+	GLM_FUNC_DECL u16vec2 unpackUint2x16(uint p);
+
+	/// Convert each component from an integer vector into a packed unsigned integer.
+	///
+	/// @see gtc_packing
+	/// @see u16vec4 unpackUint4x16(uint64 p)
+	GLM_FUNC_DECL uint64 packUint4x16(u16vec4 const& v);
+
+	/// Convert a packed integer into an integer vector.
+	///
+	/// @see gtc_packing
+	/// @see uint64 packUint4x16(u16vec4 const& v)
+	GLM_FUNC_DECL u16vec4 unpackUint4x16(uint64 p);
+
+	/// Convert each component from an integer vector into a packed unsigned integer.
+	///
+	/// @see gtc_packing
+	/// @see i32vec2 unpackInt2x32(int p)
+	GLM_FUNC_DECL int64 packInt2x32(i32vec2 const& v);
+
+	/// Convert a packed integer into an integer vector.
+	///
+	/// @see gtc_packing
+	/// @see int packInt2x16(i32vec2 const& v)
+	GLM_FUNC_DECL i32vec2 unpackInt2x32(int64 p);
+
+	/// Convert each component from an integer vector into a packed unsigned integer.
+	///
+	/// @see gtc_packing
+	/// @see u32vec2 unpackUint2x32(int p)
+	GLM_FUNC_DECL uint64 packUint2x32(u32vec2 const& v);
+
+	/// Convert a packed integer into an integer vector.
+	///
+	/// @see gtc_packing
+	/// @see int packUint2x16(u32vec2 const& v)
+	GLM_FUNC_DECL u32vec2 unpackUint2x32(uint64 p);
+
+
+	/// @}
+}// namespace glm
+
+#include "packing.inl"
diff --git a/engine/inc/glm/gtc/packing.inl b/engine/inc/glm/gtc/packing.inl
new file mode 100644
index 00000000..8c906e16
--- /dev/null
+++ b/engine/inc/glm/gtc/packing.inl
@@ -0,0 +1,938 @@
+/// @ref gtc_packing
+
+#include "../ext/scalar_relational.hpp"
+#include "../ext/vector_relational.hpp"
+#include "../common.hpp"
+#include "../vec2.hpp"
+#include "../vec3.hpp"
+#include "../vec4.hpp"
+#include "../detail/type_half.hpp"
+#include <cstring>
+#include <limits>
+
+namespace glm{
+namespace detail
+{
+	GLM_FUNC_QUALIFIER glm::uint16 float2half(glm::uint32 f)
+	{
+		// 10 bits    =>                         EE EEEFFFFF
+		// 11 bits    =>                        EEE EEFFFFFF
+		// Half bits  =>                   SEEEEEFF FFFFFFFF
+		// Float bits => SEEEEEEE EFFFFFFF FFFFFFFF FFFFFFFF
+
+		// 0x00007c00 => 00000000 00000000 01111100 00000000
+		// 0x000003ff => 00000000 00000000 00000011 11111111
+		// 0x38000000 => 00111000 00000000 00000000 00000000
+		// 0x7f800000 => 01111111 10000000 00000000 00000000
+		// 0x00008000 => 00000000 00000000 10000000 00000000
+		return
+			((f >> 16) & 0x8000) | // sign
+			((((f & 0x7f800000) - 0x38000000) >> 13) & 0x7c00) | // exponential
+			((f >> 13) & 0x03ff); // Mantissa
+	}
+
+	GLM_FUNC_QUALIFIER glm::uint32 float2packed11(glm::uint32 f)
+	{
+		// 10 bits    =>                         EE EEEFFFFF
+		// 11 bits    =>                        EEE EEFFFFFF
+		// Half bits  =>                   SEEEEEFF FFFFFFFF
+		// Float bits => SEEEEEEE EFFFFFFF FFFFFFFF FFFFFFFF
+
+		// 0x000007c0 => 00000000 00000000 00000111 11000000
+		// 0x00007c00 => 00000000 00000000 01111100 00000000
+		// 0x000003ff => 00000000 00000000 00000011 11111111
+		// 0x38000000 => 00111000 00000000 00000000 00000000
+		// 0x7f800000 => 01111111 10000000 00000000 00000000
+		// 0x00008000 => 00000000 00000000 10000000 00000000
+		return
+			((((f & 0x7f800000) - 0x38000000) >> 17) & 0x07c0) | // exponential
+			((f >> 17) & 0x003f); // Mantissa
+	}
+
+	GLM_FUNC_QUALIFIER glm::uint32 packed11ToFloat(glm::uint32 p)
+	{
+		// 10 bits    =>                         EE EEEFFFFF
+		// 11 bits    =>                        EEE EEFFFFFF
+		// Half bits  =>                   SEEEEEFF FFFFFFFF
+		// Float bits => SEEEEEEE EFFFFFFF FFFFFFFF FFFFFFFF
+
+		// 0x000007c0 => 00000000 00000000 00000111 11000000
+		// 0x00007c00 => 00000000 00000000 01111100 00000000
+		// 0x000003ff => 00000000 00000000 00000011 11111111
+		// 0x38000000 => 00111000 00000000 00000000 00000000
+		// 0x7f800000 => 01111111 10000000 00000000 00000000
+		// 0x00008000 => 00000000 00000000 10000000 00000000
+		return
+			((((p & 0x07c0) << 17) + 0x38000000) & 0x7f800000) | // exponential
+			((p & 0x003f) << 17); // Mantissa
+	}
+
+	GLM_FUNC_QUALIFIER glm::uint32 float2packed10(glm::uint32 f)
+	{
+		// 10 bits    =>                         EE EEEFFFFF
+		// 11 bits    =>                        EEE EEFFFFFF
+		// Half bits  =>                   SEEEEEFF FFFFFFFF
+		// Float bits => SEEEEEEE EFFFFFFF FFFFFFFF FFFFFFFF
+
+		// 0x0000001F => 00000000 00000000 00000000 00011111
+		// 0x0000003F => 00000000 00000000 00000000 00111111
+		// 0x000003E0 => 00000000 00000000 00000011 11100000
+		// 0x000007C0 => 00000000 00000000 00000111 11000000
+		// 0x00007C00 => 00000000 00000000 01111100 00000000
+		// 0x000003FF => 00000000 00000000 00000011 11111111
+		// 0x38000000 => 00111000 00000000 00000000 00000000
+		// 0x7f800000 => 01111111 10000000 00000000 00000000
+		// 0x00008000 => 00000000 00000000 10000000 00000000
+		return
+			((((f & 0x7f800000) - 0x38000000) >> 18) & 0x03E0) | // exponential
+			((f >> 18) & 0x001f); // Mantissa
+	}
+
+	GLM_FUNC_QUALIFIER glm::uint32 packed10ToFloat(glm::uint32 p)
+	{
+		// 10 bits    =>                         EE EEEFFFFF
+		// 11 bits    =>                        EEE EEFFFFFF
+		// Half bits  =>                   SEEEEEFF FFFFFFFF
+		// Float bits => SEEEEEEE EFFFFFFF FFFFFFFF FFFFFFFF
+
+		// 0x0000001F => 00000000 00000000 00000000 00011111
+		// 0x0000003F => 00000000 00000000 00000000 00111111
+		// 0x000003E0 => 00000000 00000000 00000011 11100000
+		// 0x000007C0 => 00000000 00000000 00000111 11000000
+		// 0x00007C00 => 00000000 00000000 01111100 00000000
+		// 0x000003FF => 00000000 00000000 00000011 11111111
+		// 0x38000000 => 00111000 00000000 00000000 00000000
+		// 0x7f800000 => 01111111 10000000 00000000 00000000
+		// 0x00008000 => 00000000 00000000 10000000 00000000
+		return
+			((((p & 0x03E0) << 18) + 0x38000000) & 0x7f800000) | // exponential
+			((p & 0x001f) << 18); // Mantissa
+	}
+
+	GLM_FUNC_QUALIFIER glm::uint half2float(glm::uint h)
+	{
+		return ((h & 0x8000) << 16) | ((( h & 0x7c00) + 0x1C000) << 13) | ((h & 0x03FF) << 13);
+	}
+
+	GLM_FUNC_QUALIFIER glm::uint floatTo11bit(float x)
+	{
+		if(x == 0.0f)
+			return 0u;
+		else if(glm::isnan(x))
+			return ~0u;
+		else if(glm::isinf(x))
+			return 0x1Fu << 6u;
+
+		uint Pack = 0u;
+		memcpy(&Pack, &x, sizeof(Pack));
+		return float2packed11(Pack);
+	}
+
+	GLM_FUNC_QUALIFIER float packed11bitToFloat(glm::uint x)
+	{
+		if(x == 0)
+			return 0.0f;
+		else if(x == ((1 << 11) - 1))
+			return ~0;//NaN
+		else if(x == (0x1f << 6))
+			return ~0;//Inf
+
+		uint Result = packed11ToFloat(x);
+
+		float Temp = 0;
+		memcpy(&Temp, &Result, sizeof(Temp));
+		return Temp;
+	}
+
+	GLM_FUNC_QUALIFIER glm::uint floatTo10bit(float x)
+	{
+		if(x == 0.0f)
+			return 0u;
+		else if(glm::isnan(x))
+			return ~0u;
+		else if(glm::isinf(x))
+			return 0x1Fu << 5u;
+
+		uint Pack = 0;
+		memcpy(&Pack, &x, sizeof(Pack));
+		return float2packed10(Pack);
+	}
+
+	GLM_FUNC_QUALIFIER float packed10bitToFloat(glm::uint x)
+	{
+		if(x == 0)
+			return 0.0f;
+		else if(x == ((1 << 10) - 1))
+			return ~0;//NaN
+		else if(x == (0x1f << 5))
+			return ~0;//Inf
+
+		uint Result = packed10ToFloat(x);
+
+		float Temp = 0;
+		memcpy(&Temp, &Result, sizeof(Temp));
+		return Temp;
+	}
+
+//	GLM_FUNC_QUALIFIER glm::uint f11_f11_f10(float x, float y, float z)
+//	{
+//		return ((floatTo11bit(x) & ((1 << 11) - 1)) << 0) |  ((floatTo11bit(y) & ((1 << 11) - 1)) << 11) | ((floatTo10bit(z) & ((1 << 10) - 1)) << 22);
+//	}
+
+	union u3u3u2
+	{
+		struct
+		{
+			uint x : 3;
+			uint y : 3;
+			uint z : 2;
+		} data;
+		uint8 pack;
+	};
+
+	union u4u4
+	{
+		struct
+		{
+			uint x : 4;
+			uint y : 4;
+		} data;
+		uint8 pack;
+	};
+
+	union u4u4u4u4
+	{
+		struct
+		{
+			uint x : 4;
+			uint y : 4;
+			uint z : 4;
+			uint w : 4;
+		} data;
+		uint16 pack;
+	};
+
+	union u5u6u5
+	{
+		struct
+		{
+			uint x : 5;
+			uint y : 6;
+			uint z : 5;
+		} data;
+		uint16 pack;
+	};
+
+	union u5u5u5u1
+	{
+		struct
+		{
+			uint x : 5;
+			uint y : 5;
+			uint z : 5;
+			uint w : 1;
+		} data;
+		uint16 pack;
+	};
+
+	union u10u10u10u2
+	{
+		struct
+		{
+			uint x : 10;
+			uint y : 10;
+			uint z : 10;
+			uint w : 2;
+		} data;
+		uint32 pack;
+	};
+
+	union i10i10i10i2
+	{
+		struct
+		{
+			int x : 10;
+			int y : 10;
+			int z : 10;
+			int w : 2;
+		} data;
+		uint32 pack;
+	};
+
+	union u9u9u9e5
+	{
+		struct
+		{
+			uint x : 9;
+			uint y : 9;
+			uint z : 9;
+			uint w : 5;
+		} data;
+		uint32 pack;
+	};
+
+	template<length_t L, qualifier Q>
+	struct compute_half
+	{};
+
+	template<qualifier Q>
+	struct compute_half<1, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<1, uint16, Q> pack(vec<1, float, Q> const& v)
+		{
+			int16 const Unpack(detail::toFloat16(v.x));
+			u16vec1 Packed;
+			memcpy(&Packed, &Unpack, sizeof(Packed));
+			return Packed;
+		}
+
+		GLM_FUNC_QUALIFIER static vec<1, float, Q> unpack(vec<1, uint16, Q> const& v)
+		{
+			i16vec1 Unpack;
+			memcpy(&Unpack, &v, sizeof(Unpack));
+			return vec<1, float, Q>(detail::toFloat32(v.x));
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_half<2, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<2, uint16, Q> pack(vec<2, float, Q> const& v)
+		{
+			vec<2, int16, Q> const Unpack(detail::toFloat16(v.x), detail::toFloat16(v.y));
+			u16vec2 Packed;
+			memcpy(&Packed, &Unpack, sizeof(Packed));
+			return Packed;
+		}
+
+		GLM_FUNC_QUALIFIER static vec<2, float, Q> unpack(vec<2, uint16, Q> const& v)
+		{
+			i16vec2 Unpack;
+			memcpy(&Unpack, &v, sizeof(Unpack));
+			return vec<2, float, Q>(detail::toFloat32(v.x), detail::toFloat32(v.y));
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_half<3, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<3, uint16, Q> pack(vec<3, float, Q> const& v)
+		{
+			vec<3, int16, Q> const Unpack(detail::toFloat16(v.x), detail::toFloat16(v.y), detail::toFloat16(v.z));
+			u16vec3 Packed;
+			memcpy(&Packed, &Unpack, sizeof(Packed));
+			return Packed;
+		}
+
+		GLM_FUNC_QUALIFIER static vec<3, float, Q> unpack(vec<3, uint16, Q> const& v)
+		{
+			i16vec3 Unpack;
+			memcpy(&Unpack, &v, sizeof(Unpack));
+			return vec<3, float, Q>(detail::toFloat32(v.x), detail::toFloat32(v.y), detail::toFloat32(v.z));
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_half<4, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, uint16, Q> pack(vec<4, float, Q> const& v)
+		{
+			vec<4, int16, Q> const Unpack(detail::toFloat16(v.x), detail::toFloat16(v.y), detail::toFloat16(v.z), detail::toFloat16(v.w));
+			u16vec4 Packed;
+			memcpy(&Packed, &Unpack, sizeof(Packed));
+			return Packed;
+		}
+
+		GLM_FUNC_QUALIFIER static vec<4, float, Q> unpack(vec<4, uint16, Q> const& v)
+		{
+			i16vec4 Unpack;
+			memcpy(&Unpack, &v, sizeof(Unpack));
+			return vec<4, float, Q>(detail::toFloat32(v.x), detail::toFloat32(v.y), detail::toFloat32(v.z), detail::toFloat32(v.w));
+		}
+	};
+}//namespace detail
+
+	GLM_FUNC_QUALIFIER uint8 packUnorm1x8(float v)
+	{
+		return static_cast<uint8>(round(clamp(v, 0.0f, 1.0f) * 255.0f));
+	}
+
+	GLM_FUNC_QUALIFIER float unpackUnorm1x8(uint8 p)
+	{
+		float const Unpack(p);
+		return Unpack * static_cast<float>(0.0039215686274509803921568627451); // 1 / 255
+	}
+
+	GLM_FUNC_QUALIFIER uint16 packUnorm2x8(vec2 const& v)
+	{
+		u8vec2 const Topack(round(clamp(v, 0.0f, 1.0f) * 255.0f));
+
+		uint16 Unpack = 0;
+		memcpy(&Unpack, &Topack, sizeof(Unpack));
+		return Unpack;
+	}
+
+	GLM_FUNC_QUALIFIER vec2 unpackUnorm2x8(uint16 p)
+	{
+		u8vec2 Unpack;
+		memcpy(&Unpack, &p, sizeof(Unpack));
+		return vec2(Unpack) * float(0.0039215686274509803921568627451); // 1 / 255
+	}
+
+	GLM_FUNC_QUALIFIER uint8 packSnorm1x8(float v)
+	{
+		int8 const Topack(static_cast<int8>(round(clamp(v ,-1.0f, 1.0f) * 127.0f)));
+		uint8 Packed = 0;
+		memcpy(&Packed, &Topack, sizeof(Packed));
+		return Packed;
+	}
+
+	GLM_FUNC_QUALIFIER float unpackSnorm1x8(uint8 p)
+	{
+		int8 Unpack = 0;
+		memcpy(&Unpack, &p, sizeof(Unpack));
+		return clamp(
+			static_cast<float>(Unpack) * 0.00787401574803149606299212598425f, // 1.0f / 127.0f
+			-1.0f, 1.0f);
+	}
+
+	GLM_FUNC_QUALIFIER uint16 packSnorm2x8(vec2 const& v)
+	{
+		i8vec2 const Topack(round(clamp(v, -1.0f, 1.0f) * 127.0f));
+		uint16 Packed = 0;
+		memcpy(&Packed, &Topack, sizeof(Packed));
+		return Packed;
+	}
+
+	GLM_FUNC_QUALIFIER vec2 unpackSnorm2x8(uint16 p)
+	{
+		i8vec2 Unpack;
+		memcpy(&Unpack, &p, sizeof(Unpack));
+		return clamp(
+			vec2(Unpack) * 0.00787401574803149606299212598425f, // 1.0f / 127.0f
+			-1.0f, 1.0f);
+	}
+
+	GLM_FUNC_QUALIFIER uint16 packUnorm1x16(float s)
+	{
+		return static_cast<uint16>(round(clamp(s, 0.0f, 1.0f) * 65535.0f));
+	}
+
+	GLM_FUNC_QUALIFIER float unpackUnorm1x16(uint16 p)
+	{
+		float const Unpack(p);
+		return Unpack * 1.5259021896696421759365224689097e-5f; // 1.0 / 65535.0
+	}
+
+	GLM_FUNC_QUALIFIER uint64 packUnorm4x16(vec4 const& v)
+	{
+		u16vec4 const Topack(round(clamp(v , 0.0f, 1.0f) * 65535.0f));
+		uint64 Packed = 0;
+		memcpy(&Packed, &Topack, sizeof(Packed));
+		return Packed;
+	}
+
+	GLM_FUNC_QUALIFIER vec4 unpackUnorm4x16(uint64 p)
+	{
+		u16vec4 Unpack;
+		memcpy(&Unpack, &p, sizeof(Unpack));
+		return vec4(Unpack) * 1.5259021896696421759365224689097e-5f; // 1.0 / 65535.0
+	}
+
+	GLM_FUNC_QUALIFIER uint16 packSnorm1x16(float v)
+	{
+		int16 const Topack = static_cast<int16>(round(clamp(v ,-1.0f, 1.0f) * 32767.0f));
+		uint16 Packed = 0;
+		memcpy(&Packed, &Topack, sizeof(Packed));
+		return Packed;
+	}
+
+	GLM_FUNC_QUALIFIER float unpackSnorm1x16(uint16 p)
+	{
+		int16 Unpack = 0;
+		memcpy(&Unpack, &p, sizeof(Unpack));
+		return clamp(
+			static_cast<float>(Unpack) * 3.0518509475997192297128208258309e-5f, //1.0f / 32767.0f,
+			-1.0f, 1.0f);
+	}
+
+	GLM_FUNC_QUALIFIER uint64 packSnorm4x16(vec4 const& v)
+	{
+		i16vec4 const Topack(round(clamp(v ,-1.0f, 1.0f) * 32767.0f));
+		uint64 Packed = 0;
+		memcpy(&Packed, &Topack, sizeof(Packed));
+		return Packed;
+	}
+
+	GLM_FUNC_QUALIFIER vec4 unpackSnorm4x16(uint64 p)
+	{
+		i16vec4 Unpack;
+		memcpy(&Unpack, &p, sizeof(Unpack));
+		return clamp(
+			vec4(Unpack) * 3.0518509475997192297128208258309e-5f, //1.0f / 32767.0f,
+			-1.0f, 1.0f);
+	}
+
+	GLM_FUNC_QUALIFIER uint16 packHalf1x16(float v)
+	{
+		int16 const Topack(detail::toFloat16(v));
+		uint16 Packed = 0;
+		memcpy(&Packed, &Topack, sizeof(Packed));
+		return Packed;
+	}
+
+	GLM_FUNC_QUALIFIER float unpackHalf1x16(uint16 v)
+	{
+		int16 Unpack = 0;
+		memcpy(&Unpack, &v, sizeof(Unpack));
+		return detail::toFloat32(Unpack);
+	}
+
+	GLM_FUNC_QUALIFIER uint64 packHalf4x16(glm::vec4 const& v)
+	{
+		i16vec4 const Unpack(
+			detail::toFloat16(v.x),
+			detail::toFloat16(v.y),
+			detail::toFloat16(v.z),
+			detail::toFloat16(v.w));
+		uint64 Packed = 0;
+		memcpy(&Packed, &Unpack, sizeof(Packed));
+		return Packed;
+	}
+
+	GLM_FUNC_QUALIFIER glm::vec4 unpackHalf4x16(uint64 v)
+	{
+		i16vec4 Unpack;
+		memcpy(&Unpack, &v, sizeof(Unpack));
+		return vec4(
+			detail::toFloat32(Unpack.x),
+			detail::toFloat32(Unpack.y),
+			detail::toFloat32(Unpack.z),
+			detail::toFloat32(Unpack.w));
+	}
+
+	GLM_FUNC_QUALIFIER uint32 packI3x10_1x2(ivec4 const& v)
+	{
+		detail::i10i10i10i2 Result;
+		Result.data.x = v.x;
+		Result.data.y = v.y;
+		Result.data.z = v.z;
+		Result.data.w = v.w;
+		return Result.pack;
+	}
+
+	GLM_FUNC_QUALIFIER ivec4 unpackI3x10_1x2(uint32 v)
+	{
+		detail::i10i10i10i2 Unpack;
+		Unpack.pack = v;
+		return ivec4(
+			Unpack.data.x,
+			Unpack.data.y,
+			Unpack.data.z,
+			Unpack.data.w);
+	}
+
+	GLM_FUNC_QUALIFIER uint32 packU3x10_1x2(uvec4 const& v)
+	{
+		detail::u10u10u10u2 Result;
+		Result.data.x = v.x;
+		Result.data.y = v.y;
+		Result.data.z = v.z;
+		Result.data.w = v.w;
+		return Result.pack;
+	}
+
+	GLM_FUNC_QUALIFIER uvec4 unpackU3x10_1x2(uint32 v)
+	{
+		detail::u10u10u10u2 Unpack;
+		Unpack.pack = v;
+		return uvec4(
+			Unpack.data.x,
+			Unpack.data.y,
+			Unpack.data.z,
+			Unpack.data.w);
+	}
+
+	GLM_FUNC_QUALIFIER uint32 packSnorm3x10_1x2(vec4 const& v)
+	{
+		ivec4 const Pack(round(clamp(v,-1.0f, 1.0f) * vec4(511.f, 511.f, 511.f, 1.f)));
+
+		detail::i10i10i10i2 Result;
+		Result.data.x = Pack.x;
+		Result.data.y = Pack.y;
+		Result.data.z = Pack.z;
+		Result.data.w = Pack.w;
+		return Result.pack;
+	}
+
+	GLM_FUNC_QUALIFIER vec4 unpackSnorm3x10_1x2(uint32 v)
+	{
+		detail::i10i10i10i2 Unpack;
+		Unpack.pack = v;
+
+		vec4 const Result(Unpack.data.x, Unpack.data.y, Unpack.data.z, Unpack.data.w);
+
+		return clamp(Result * vec4(1.f / 511.f, 1.f / 511.f, 1.f / 511.f, 1.f), -1.0f, 1.0f);
+	}
+
+	GLM_FUNC_QUALIFIER uint32 packUnorm3x10_1x2(vec4 const& v)
+	{
+		uvec4 const Unpack(round(clamp(v, 0.0f, 1.0f) * vec4(1023.f, 1023.f, 1023.f, 3.f)));
+
+		detail::u10u10u10u2 Result;
+		Result.data.x = Unpack.x;
+		Result.data.y = Unpack.y;
+		Result.data.z = Unpack.z;
+		Result.data.w = Unpack.w;
+		return Result.pack;
+	}
+
+	GLM_FUNC_QUALIFIER vec4 unpackUnorm3x10_1x2(uint32 v)
+	{
+		vec4 const ScaleFactors(1.0f / 1023.f, 1.0f / 1023.f, 1.0f / 1023.f, 1.0f / 3.f);
+
+		detail::u10u10u10u2 Unpack;
+		Unpack.pack = v;
+		return vec4(Unpack.data.x, Unpack.data.y, Unpack.data.z, Unpack.data.w) * ScaleFactors;
+	}
+
+	GLM_FUNC_QUALIFIER uint32 packF2x11_1x10(vec3 const& v)
+	{
+		return
+			((detail::floatTo11bit(v.x) & ((1 << 11) - 1)) <<  0) |
+			((detail::floatTo11bit(v.y) & ((1 << 11) - 1)) << 11) |
+			((detail::floatTo10bit(v.z) & ((1 << 10) - 1)) << 22);
+	}
+
+	GLM_FUNC_QUALIFIER vec3 unpackF2x11_1x10(uint32 v)
+	{
+		return vec3(
+			detail::packed11bitToFloat(v >> 0),
+			detail::packed11bitToFloat(v >> 11),
+			detail::packed10bitToFloat(v >> 22));
+	}
+
+	GLM_FUNC_QUALIFIER uint32 packF3x9_E1x5(vec3 const& v)
+	{
+		float const SharedExpMax = (pow(2.0f, 9.0f - 1.0f) / pow(2.0f, 9.0f)) * pow(2.0f, 31.f - 15.f);
+		vec3 const Color = clamp(v, 0.0f, SharedExpMax);
+		float const MaxColor = max(Color.x, max(Color.y, Color.z));
+
+		float const ExpSharedP = max(-15.f - 1.f, floor(log2(MaxColor))) + 1.0f + 15.f;
+		float const MaxShared = floor(MaxColor / pow(2.0f, (ExpSharedP - 15.f - 9.f)) + 0.5f);
+		float const ExpShared = equal(MaxShared, pow(2.0f, 9.0f), epsilon<float>()) ? ExpSharedP + 1.0f : ExpSharedP;
+
+		uvec3 const ColorComp(floor(Color / pow(2.f, (ExpShared - 15.f - 9.f)) + 0.5f));
+
+		detail::u9u9u9e5 Unpack;
+		Unpack.data.x = ColorComp.x;
+		Unpack.data.y = ColorComp.y;
+		Unpack.data.z = ColorComp.z;
+		Unpack.data.w = uint(ExpShared);
+		return Unpack.pack;
+	}
+
+	GLM_FUNC_QUALIFIER vec3 unpackF3x9_E1x5(uint32 v)
+	{
+		detail::u9u9u9e5 Unpack;
+		Unpack.pack = v;
+
+		return vec3(Unpack.data.x, Unpack.data.y, Unpack.data.z) * pow(2.0f, Unpack.data.w - 15.f - 9.f);
+	}
+
+	// Based on Brian Karis http://graphicrants.blogspot.fr/2009/04/rgbm-color-encoding.html
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, T, Q> packRGBM(vec<3, T, Q> const& rgb)
+	{
+		vec<3, T, Q> const Color(rgb * static_cast<T>(1.0 / 6.0));
+		T Alpha = clamp(max(max(Color.x, Color.y), max(Color.z, static_cast<T>(1e-6))), static_cast<T>(0), static_cast<T>(1));
+		Alpha = ceil(Alpha * static_cast<T>(255.0)) / static_cast<T>(255.0);
+		return vec<4, T, Q>(Color / Alpha, Alpha);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> unpackRGBM(vec<4, T, Q> const& rgbm)
+	{
+		return vec<3, T, Q>(rgbm.x, rgbm.y, rgbm.z) * rgbm.w * static_cast<T>(6);
+	}
+
+	template<length_t L, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, uint16, Q> packHalf(vec<L, float, Q> const& v)
+	{
+		return detail::compute_half<L, Q>::pack(v);
+	}
+
+	template<length_t L, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, float, Q> unpackHalf(vec<L, uint16, Q> const& v)
+	{
+		return detail::compute_half<L, Q>::unpack(v);
+	}
+
+	template<typename uintType, length_t L, typename floatType, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, uintType, Q> packUnorm(vec<L, floatType, Q> const& v)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<uintType>::is_integer, "uintType must be an integer type");
+		GLM_STATIC_ASSERT(std::numeric_limits<floatType>::is_iec559, "floatType must be a floating point type");
+
+		return vec<L, uintType, Q>(round(clamp(v, static_cast<floatType>(0), static_cast<floatType>(1)) * static_cast<floatType>(std::numeric_limits<uintType>::max())));
+	}
+
+	template<typename floatType, length_t L, typename uintType, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, floatType, Q> unpackUnorm(vec<L, uintType, Q> const& v)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<uintType>::is_integer, "uintType must be an integer type");
+		GLM_STATIC_ASSERT(std::numeric_limits<floatType>::is_iec559, "floatType must be a floating point type");
+
+		return vec<L, float, Q>(v) * (static_cast<floatType>(1) / static_cast<floatType>(std::numeric_limits<uintType>::max()));
+	}
+
+	template<typename intType, length_t L, typename floatType, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, intType, Q> packSnorm(vec<L, floatType, Q> const& v)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<intType>::is_integer, "uintType must be an integer type");
+		GLM_STATIC_ASSERT(std::numeric_limits<floatType>::is_iec559, "floatType must be a floating point type");
+
+		return vec<L, intType, Q>(round(clamp(v , static_cast<floatType>(-1), static_cast<floatType>(1)) * static_cast<floatType>(std::numeric_limits<intType>::max())));
+	}
+
+	template<typename floatType, length_t L, typename intType, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, floatType, Q> unpackSnorm(vec<L, intType, Q> const& v)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<intType>::is_integer, "uintType must be an integer type");
+		GLM_STATIC_ASSERT(std::numeric_limits<floatType>::is_iec559, "floatType must be a floating point type");
+
+		return clamp(vec<L, floatType, Q>(v) * (static_cast<floatType>(1) / static_cast<floatType>(std::numeric_limits<intType>::max())), static_cast<floatType>(-1), static_cast<floatType>(1));
+	}
+
+	GLM_FUNC_QUALIFIER uint8 packUnorm2x4(vec2 const& v)
+	{
+		u32vec2 const Unpack(round(clamp(v, 0.0f, 1.0f) * 15.0f));
+		detail::u4u4 Result;
+		Result.data.x = Unpack.x;
+		Result.data.y = Unpack.y;
+		return Result.pack;
+	}
+
+	GLM_FUNC_QUALIFIER vec2 unpackUnorm2x4(uint8 v)
+	{
+		float const ScaleFactor(1.f / 15.f);
+		detail::u4u4 Unpack;
+		Unpack.pack = v;
+		return vec2(Unpack.data.x, Unpack.data.y) * ScaleFactor;
+	}
+
+	GLM_FUNC_QUALIFIER uint16 packUnorm4x4(vec4 const& v)
+	{
+		u32vec4 const Unpack(round(clamp(v, 0.0f, 1.0f) * 15.0f));
+		detail::u4u4u4u4 Result;
+		Result.data.x = Unpack.x;
+		Result.data.y = Unpack.y;
+		Result.data.z = Unpack.z;
+		Result.data.w = Unpack.w;
+		return Result.pack;
+	}
+
+	GLM_FUNC_QUALIFIER vec4 unpackUnorm4x4(uint16 v)
+	{
+		float const ScaleFactor(1.f / 15.f);
+		detail::u4u4u4u4 Unpack;
+		Unpack.pack = v;
+		return vec4(Unpack.data.x, Unpack.data.y, Unpack.data.z, Unpack.data.w) * ScaleFactor;
+	}
+
+	GLM_FUNC_QUALIFIER uint16 packUnorm1x5_1x6_1x5(vec3 const& v)
+	{
+		u32vec3 const Unpack(round(clamp(v, 0.0f, 1.0f) * vec3(31.f, 63.f, 31.f)));
+		detail::u5u6u5 Result;
+		Result.data.x = Unpack.x;
+		Result.data.y = Unpack.y;
+		Result.data.z = Unpack.z;
+		return Result.pack;
+	}
+
+	GLM_FUNC_QUALIFIER vec3 unpackUnorm1x5_1x6_1x5(uint16 v)
+	{
+		vec3 const ScaleFactor(1.f / 31.f, 1.f / 63.f, 1.f / 31.f);
+		detail::u5u6u5 Unpack;
+		Unpack.pack = v;
+		return vec3(Unpack.data.x, Unpack.data.y, Unpack.data.z) * ScaleFactor;
+	}
+
+	GLM_FUNC_QUALIFIER uint16 packUnorm3x5_1x1(vec4 const& v)
+	{
+		u32vec4 const Unpack(round(clamp(v, 0.0f, 1.0f) * vec4(31.f, 31.f, 31.f, 1.f)));
+		detail::u5u5u5u1 Result;
+		Result.data.x = Unpack.x;
+		Result.data.y = Unpack.y;
+		Result.data.z = Unpack.z;
+		Result.data.w = Unpack.w;
+		return Result.pack;
+	}
+
+	GLM_FUNC_QUALIFIER vec4 unpackUnorm3x5_1x1(uint16 v)
+	{
+		vec4 const ScaleFactor(1.f / 31.f, 1.f / 31.f, 1.f / 31.f, 1.f);
+		detail::u5u5u5u1 Unpack;
+		Unpack.pack = v;
+		return vec4(Unpack.data.x, Unpack.data.y, Unpack.data.z, Unpack.data.w) * ScaleFactor;
+	}
+
+	GLM_FUNC_QUALIFIER uint8 packUnorm2x3_1x2(vec3 const& v)
+	{
+		u32vec3 const Unpack(round(clamp(v, 0.0f, 1.0f) * vec3(7.f, 7.f, 3.f)));
+		detail::u3u3u2 Result;
+		Result.data.x = Unpack.x;
+		Result.data.y = Unpack.y;
+		Result.data.z = Unpack.z;
+		return Result.pack;
+	}
+
+	GLM_FUNC_QUALIFIER vec3 unpackUnorm2x3_1x2(uint8 v)
+	{
+		vec3 const ScaleFactor(1.f / 7.f, 1.f / 7.f, 1.f / 3.f);
+		detail::u3u3u2 Unpack;
+		Unpack.pack = v;
+		return vec3(Unpack.data.x, Unpack.data.y, Unpack.data.z) * ScaleFactor;
+	}
+
+	GLM_FUNC_QUALIFIER int16 packInt2x8(i8vec2 const& v)
+	{
+		int16 Pack = 0;
+		memcpy(&Pack, &v, sizeof(Pack));
+		return Pack;
+	}
+
+	GLM_FUNC_QUALIFIER i8vec2 unpackInt2x8(int16 p)
+	{
+		i8vec2 Unpack;
+		memcpy(&Unpack, &p, sizeof(Unpack));
+		return Unpack;
+	}
+
+	GLM_FUNC_QUALIFIER uint16 packUint2x8(u8vec2 const& v)
+	{
+		uint16 Pack = 0;
+		memcpy(&Pack, &v, sizeof(Pack));
+		return Pack;
+	}
+
+	GLM_FUNC_QUALIFIER u8vec2 unpackUint2x8(uint16 p)
+	{
+		u8vec2 Unpack;
+		memcpy(&Unpack, &p, sizeof(Unpack));
+		return Unpack;
+	}
+
+	GLM_FUNC_QUALIFIER int32 packInt4x8(i8vec4 const& v)
+	{
+		int32 Pack = 0;
+		memcpy(&Pack, &v, sizeof(Pack));
+		return Pack;
+	}
+
+	GLM_FUNC_QUALIFIER i8vec4 unpackInt4x8(int32 p)
+	{
+		i8vec4 Unpack;
+		memcpy(&Unpack, &p, sizeof(Unpack));
+		return Unpack;
+	}
+
+	GLM_FUNC_QUALIFIER uint32 packUint4x8(u8vec4 const& v)
+	{
+		uint32 Pack = 0;
+		memcpy(&Pack, &v, sizeof(Pack));
+		return Pack;
+	}
+
+	GLM_FUNC_QUALIFIER u8vec4 unpackUint4x8(uint32 p)
+	{
+		u8vec4 Unpack;
+		memcpy(&Unpack, &p, sizeof(Unpack));
+		return Unpack;
+	}
+
+	GLM_FUNC_QUALIFIER int packInt2x16(i16vec2 const& v)
+	{
+		int Pack = 0;
+		memcpy(&Pack, &v, sizeof(Pack));
+		return Pack;
+	}
+
+	GLM_FUNC_QUALIFIER i16vec2 unpackInt2x16(int p)
+	{
+		i16vec2 Unpack;
+		memcpy(&Unpack, &p, sizeof(Unpack));
+		return Unpack;
+	}
+
+	GLM_FUNC_QUALIFIER int64 packInt4x16(i16vec4 const& v)
+	{
+		int64 Pack = 0;
+		memcpy(&Pack, &v, sizeof(Pack));
+		return Pack;
+	}
+
+	GLM_FUNC_QUALIFIER i16vec4 unpackInt4x16(int64 p)
+	{
+		i16vec4 Unpack;
+		memcpy(&Unpack, &p, sizeof(Unpack));
+		return Unpack;
+	}
+
+	GLM_FUNC_QUALIFIER uint packUint2x16(u16vec2 const& v)
+	{
+		uint Pack = 0;
+		memcpy(&Pack, &v, sizeof(Pack));
+		return Pack;
+	}
+
+	GLM_FUNC_QUALIFIER u16vec2 unpackUint2x16(uint p)
+	{
+		u16vec2 Unpack;
+		memcpy(&Unpack, &p, sizeof(Unpack));
+		return Unpack;
+	}
+
+	GLM_FUNC_QUALIFIER uint64 packUint4x16(u16vec4 const& v)
+	{
+		uint64 Pack = 0;
+		memcpy(&Pack, &v, sizeof(Pack));
+		return Pack;
+	}
+
+	GLM_FUNC_QUALIFIER u16vec4 unpackUint4x16(uint64 p)
+	{
+		u16vec4 Unpack;
+		memcpy(&Unpack, &p, sizeof(Unpack));
+		return Unpack;
+	}
+
+	GLM_FUNC_QUALIFIER int64 packInt2x32(i32vec2 const& v)
+	{
+		int64 Pack = 0;
+		memcpy(&Pack, &v, sizeof(Pack));
+		return Pack;
+	}
+
+	GLM_FUNC_QUALIFIER i32vec2 unpackInt2x32(int64 p)
+	{
+		i32vec2 Unpack;
+		memcpy(&Unpack, &p, sizeof(Unpack));
+		return Unpack;
+	}
+
+	GLM_FUNC_QUALIFIER uint64 packUint2x32(u32vec2 const& v)
+	{
+		uint64 Pack = 0;
+		memcpy(&Pack, &v, sizeof(Pack));
+		return Pack;
+	}
+
+	GLM_FUNC_QUALIFIER u32vec2 unpackUint2x32(uint64 p)
+	{
+		u32vec2 Unpack;
+		memcpy(&Unpack, &p, sizeof(Unpack));
+		return Unpack;
+	}
+}//namespace glm
+
diff --git a/engine/inc/glm/gtc/quaternion.hpp b/engine/inc/glm/gtc/quaternion.hpp
new file mode 100644
index 00000000..359e072b
--- /dev/null
+++ b/engine/inc/glm/gtc/quaternion.hpp
@@ -0,0 +1,173 @@
+/// @ref gtc_quaternion
+/// @file glm/gtc/quaternion.hpp
+///
+/// @see core (dependence)
+/// @see gtc_constants (dependence)
+///
+/// @defgroup gtc_quaternion GLM_GTC_quaternion
+/// @ingroup gtc
+///
+/// Include <glm/gtc/quaternion.hpp> to use the features of this extension.
+///
+/// Defines a templated quaternion type and several quaternion operations.
+
+#pragma once
+
+// Dependency:
+#include "../gtc/constants.hpp"
+#include "../gtc/matrix_transform.hpp"
+#include "../ext/vector_relational.hpp"
+#include "../ext/quaternion_common.hpp"
+#include "../ext/quaternion_float.hpp"
+#include "../ext/quaternion_float_precision.hpp"
+#include "../ext/quaternion_double.hpp"
+#include "../ext/quaternion_double_precision.hpp"
+#include "../ext/quaternion_relational.hpp"
+#include "../ext/quaternion_geometric.hpp"
+#include "../ext/quaternion_trigonometric.hpp"
+#include "../ext/quaternion_transform.hpp"
+#include "../detail/type_mat3x3.hpp"
+#include "../detail/type_mat4x4.hpp"
+#include "../detail/type_vec3.hpp"
+#include "../detail/type_vec4.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTC_quaternion extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtc_quaternion
+	/// @{
+
+	/// Returns euler angles, pitch as x, yaw as y, roll as z.
+	/// The result is expressed in radians.
+	///
+	/// @tparam T Floating-point scalar types.
+	///
+	/// @see gtc_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> eulerAngles(qua<T, Q> const& x);
+
+	/// Returns roll value of euler angles expressed in radians.
+	///
+	/// @tparam T Floating-point scalar types.
+	///
+	/// @see gtc_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL T roll(qua<T, Q> const& x);
+
+	/// Returns pitch value of euler angles expressed in radians.
+	///
+	/// @tparam T Floating-point scalar types.
+	///
+	/// @see gtc_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL T pitch(qua<T, Q> const& x);
+
+	/// Returns yaw value of euler angles expressed in radians.
+	///
+	/// @tparam T Floating-point scalar types.
+	///
+	/// @see gtc_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL T yaw(qua<T, Q> const& x);
+
+	/// Converts a quaternion to a 3 * 3 matrix.
+	///
+	/// @tparam T Floating-point scalar types.
+	///
+	/// @see gtc_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> mat3_cast(qua<T, Q> const& x);
+
+	/// Converts a quaternion to a 4 * 4 matrix.
+	///
+	/// @tparam T Floating-point scalar types.
+	///
+	/// @see gtc_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> mat4_cast(qua<T, Q> const& x);
+
+	/// Converts a pure rotation 3 * 3 matrix to a quaternion.
+	///
+	/// @tparam T Floating-point scalar types.
+	///
+	/// @see gtc_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> quat_cast(mat<3, 3, T, Q> const& x);
+
+	/// Converts a pure rotation 4 * 4 matrix to a quaternion.
+	///
+	/// @tparam T Floating-point scalar types.
+	///
+	/// @see gtc_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> quat_cast(mat<4, 4, T, Q> const& x);
+
+	/// Returns the component-wise comparison result of x < y.
+	///
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see ext_quaternion_relational
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<4, bool, Q> lessThan(qua<T, Q> const& x, qua<T, Q> const& y);
+
+	/// Returns the component-wise comparison of result x <= y.
+	///
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see ext_quaternion_relational
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<4, bool, Q> lessThanEqual(qua<T, Q> const& x, qua<T, Q> const& y);
+
+	/// Returns the component-wise comparison of result x > y.
+	///
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see ext_quaternion_relational
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<4, bool, Q> greaterThan(qua<T, Q> const& x, qua<T, Q> const& y);
+
+	/// Returns the component-wise comparison of result x >= y.
+	///
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see ext_quaternion_relational
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<4, bool, Q> greaterThanEqual(qua<T, Q> const& x, qua<T, Q> const& y);
+
+	/// Build a look at quaternion based on the default handedness.
+	///
+	/// @param direction Desired forward direction. Needs to be normalized.
+	/// @param up Up vector, how the camera is oriented. Typically (0, 1, 0).
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> quatLookAt(
+		vec<3, T, Q> const& direction,
+		vec<3, T, Q> const& up);
+
+	/// Build a right-handed look at quaternion.
+	///
+	/// @param direction Desired forward direction onto which the -z-axis gets mapped. Needs to be normalized.
+	/// @param up Up vector, how the camera is oriented. Typically (0, 1, 0).
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> quatLookAtRH(
+		vec<3, T, Q> const& direction,
+		vec<3, T, Q> const& up);
+
+	/// Build a left-handed look at quaternion.
+	///
+	/// @param direction Desired forward direction onto which the +z-axis gets mapped. Needs to be normalized.
+	/// @param up Up vector, how the camera is oriented. Typically (0, 1, 0).
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> quatLookAtLH(
+		vec<3, T, Q> const& direction,
+		vec<3, T, Q> const& up);
+	/// @}
+} //namespace glm
+
+#include "quaternion.inl"
diff --git a/engine/inc/glm/gtc/quaternion.inl b/engine/inc/glm/gtc/quaternion.inl
new file mode 100644
index 00000000..9dd037ee
--- /dev/null
+++ b/engine/inc/glm/gtc/quaternion.inl
@@ -0,0 +1,200 @@
+#include "../trigonometric.hpp"
+#include "../geometric.hpp"
+#include "../exponential.hpp"
+#include "epsilon.hpp"
+#include <limits>
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> eulerAngles(qua<T, Q> const& x)
+	{
+		return vec<3, T, Q>(pitch(x), yaw(x), roll(x));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T roll(qua<T, Q> const& q)
+	{
+		return static_cast<T>(atan(static_cast<T>(2) * (q.x * q.y + q.w * q.z), q.w * q.w + q.x * q.x - q.y * q.y - q.z * q.z));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T pitch(qua<T, Q> const& q)
+	{
+		//return T(atan(T(2) * (q.y * q.z + q.w * q.x), q.w * q.w - q.x * q.x - q.y * q.y + q.z * q.z));
+		T const y = static_cast<T>(2) * (q.y * q.z + q.w * q.x);
+		T const x = q.w * q.w - q.x * q.x - q.y * q.y + q.z * q.z;
+
+		if(all(equal(vec<2, T, Q>(x, y), vec<2, T, Q>(0), epsilon<T>()))) //avoid atan2(0,0) - handle singularity - Matiis
+			return static_cast<T>(static_cast<T>(2) * atan(q.x, q.w));
+
+		return static_cast<T>(atan(y, x));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T yaw(qua<T, Q> const& q)
+	{
+		return asin(clamp(static_cast<T>(-2) * (q.x * q.z - q.w * q.y), static_cast<T>(-1), static_cast<T>(1)));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> mat3_cast(qua<T, Q> const& q)
+	{
+		mat<3, 3, T, Q> Result(T(1));
+		T qxx(q.x * q.x);
+		T qyy(q.y * q.y);
+		T qzz(q.z * q.z);
+		T qxz(q.x * q.z);
+		T qxy(q.x * q.y);
+		T qyz(q.y * q.z);
+		T qwx(q.w * q.x);
+		T qwy(q.w * q.y);
+		T qwz(q.w * q.z);
+
+		Result[0][0] = T(1) - T(2) * (qyy +  qzz);
+		Result[0][1] = T(2) * (qxy + qwz);
+		Result[0][2] = T(2) * (qxz - qwy);
+
+		Result[1][0] = T(2) * (qxy - qwz);
+		Result[1][1] = T(1) - T(2) * (qxx +  qzz);
+		Result[1][2] = T(2) * (qyz + qwx);
+
+		Result[2][0] = T(2) * (qxz + qwy);
+		Result[2][1] = T(2) * (qyz - qwx);
+		Result[2][2] = T(1) - T(2) * (qxx +  qyy);
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> mat4_cast(qua<T, Q> const& q)
+	{
+		return mat<4, 4, T, Q>(mat3_cast(q));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> quat_cast(mat<3, 3, T, Q> const& m)
+	{
+		T fourXSquaredMinus1 = m[0][0] - m[1][1] - m[2][2];
+		T fourYSquaredMinus1 = m[1][1] - m[0][0] - m[2][2];
+		T fourZSquaredMinus1 = m[2][2] - m[0][0] - m[1][1];
+		T fourWSquaredMinus1 = m[0][0] + m[1][1] + m[2][2];
+
+		int biggestIndex = 0;
+		T fourBiggestSquaredMinus1 = fourWSquaredMinus1;
+		if(fourXSquaredMinus1 > fourBiggestSquaredMinus1)
+		{
+			fourBiggestSquaredMinus1 = fourXSquaredMinus1;
+			biggestIndex = 1;
+		}
+		if(fourYSquaredMinus1 > fourBiggestSquaredMinus1)
+		{
+			fourBiggestSquaredMinus1 = fourYSquaredMinus1;
+			biggestIndex = 2;
+		}
+		if(fourZSquaredMinus1 > fourBiggestSquaredMinus1)
+		{
+			fourBiggestSquaredMinus1 = fourZSquaredMinus1;
+			biggestIndex = 3;
+		}
+
+		T biggestVal = sqrt(fourBiggestSquaredMinus1 + static_cast<T>(1)) * static_cast<T>(0.5);
+		T mult = static_cast<T>(0.25) / biggestVal;
+
+		switch(biggestIndex)
+		{
+		case 0:
+			return qua<T, Q>(biggestVal, (m[1][2] - m[2][1]) * mult, (m[2][0] - m[0][2]) * mult, (m[0][1] - m[1][0]) * mult);
+		case 1:
+			return qua<T, Q>((m[1][2] - m[2][1]) * mult, biggestVal, (m[0][1] + m[1][0]) * mult, (m[2][0] + m[0][2]) * mult);
+		case 2:
+			return qua<T, Q>((m[2][0] - m[0][2]) * mult, (m[0][1] + m[1][0]) * mult, biggestVal, (m[1][2] + m[2][1]) * mult);
+		case 3:
+			return qua<T, Q>((m[0][1] - m[1][0]) * mult, (m[2][0] + m[0][2]) * mult, (m[1][2] + m[2][1]) * mult, biggestVal);
+		default: // Silence a -Wswitch-default warning in GCC. Should never actually get here. Assert is just for sanity.
+			assert(false);
+			return qua<T, Q>(1, 0, 0, 0);
+		}
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> quat_cast(mat<4, 4, T, Q> const& m4)
+	{
+		return quat_cast(mat<3, 3, T, Q>(m4));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, bool, Q> lessThan(qua<T, Q> const& x, qua<T, Q> const& y)
+	{
+		vec<4, bool, Q> Result;
+		for(length_t i = 0; i < x.length(); ++i)
+			Result[i] = x[i] < y[i];
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, bool, Q> lessThanEqual(qua<T, Q> const& x, qua<T, Q> const& y)
+	{
+		vec<4, bool, Q> Result;
+		for(length_t i = 0; i < x.length(); ++i)
+			Result[i] = x[i] <= y[i];
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, bool, Q> greaterThan(qua<T, Q> const& x, qua<T, Q> const& y)
+	{
+		vec<4, bool, Q> Result;
+		for(length_t i = 0; i < x.length(); ++i)
+			Result[i] = x[i] > y[i];
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, bool, Q> greaterThanEqual(qua<T, Q> const& x, qua<T, Q> const& y)
+	{
+		vec<4, bool, Q> Result;
+		for(length_t i = 0; i < x.length(); ++i)
+			Result[i] = x[i] >= y[i];
+		return Result;
+	}
+
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> quatLookAt(vec<3, T, Q> const& direction, vec<3, T, Q> const& up)
+	{
+#		if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT
+			return quatLookAtLH(direction, up);
+#		else
+			return quatLookAtRH(direction, up);
+# 		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> quatLookAtRH(vec<3, T, Q> const& direction, vec<3, T, Q> const& up)
+	{
+		mat<3, 3, T, Q> Result;
+
+		Result[2] = -direction;
+		Result[0] = normalize(cross(up, Result[2]));
+		Result[1] = cross(Result[2], Result[0]);
+
+		return quat_cast(Result);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> quatLookAtLH(vec<3, T, Q> const& direction, vec<3, T, Q> const& up)
+	{
+		mat<3, 3, T, Q> Result;
+
+		Result[2] = direction;
+		Result[0] = normalize(cross(up, Result[2]));
+		Result[1] = cross(Result[2], Result[0]);
+
+		return quat_cast(Result);
+	}
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+#	include "quaternion_simd.inl"
+#endif
+
diff --git a/engine/inc/glm/gtc/quaternion_simd.inl b/engine/inc/glm/gtc/quaternion_simd.inl
new file mode 100644
index 00000000..e69de29b
diff --git a/engine/inc/glm/gtc/random.hpp b/engine/inc/glm/gtc/random.hpp
new file mode 100644
index 00000000..9a859580
--- /dev/null
+++ b/engine/inc/glm/gtc/random.hpp
@@ -0,0 +1,82 @@
+/// @ref gtc_random
+/// @file glm/gtc/random.hpp
+///
+/// @see core (dependence)
+/// @see gtx_random (extended)
+///
+/// @defgroup gtc_random GLM_GTC_random
+/// @ingroup gtc
+///
+/// Include <glm/gtc/random.hpp> to use the features of this extension.
+///
+/// Generate random number from various distribution methods.
+
+#pragma once
+
+// Dependency:
+#include "../ext/scalar_int_sized.hpp"
+#include "../ext/scalar_uint_sized.hpp"
+#include "../detail/qualifier.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTC_random extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtc_random
+	/// @{
+
+	/// Generate random numbers in the interval [Min, Max], according a linear distribution
+	///
+	/// @param Min Minimum value included in the sampling
+	/// @param Max Maximum value included in the sampling
+	/// @tparam genType Value type. Currently supported: float or double scalars.
+	/// @see gtc_random
+	template<typename genType>
+	GLM_FUNC_DECL genType linearRand(genType Min, genType Max);
+
+	/// Generate random numbers in the interval [Min, Max], according a linear distribution
+	///
+	/// @param Min Minimum value included in the sampling
+	/// @param Max Maximum value included in the sampling
+	/// @tparam T Value type. Currently supported: float or double.
+	///
+	/// @see gtc_random
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> linearRand(vec<L, T, Q> const& Min, vec<L, T, Q> const& Max);
+
+	/// Generate random numbers in the interval [Min, Max], according a gaussian distribution
+	///
+	/// @see gtc_random
+	template<typename genType>
+	GLM_FUNC_DECL genType gaussRand(genType Mean, genType Deviation);
+
+	/// Generate a random 2D vector which coordinates are regulary distributed on a circle of a given radius
+	///
+	/// @see gtc_random
+	template<typename T>
+	GLM_FUNC_DECL vec<2, T, defaultp> circularRand(T Radius);
+
+	/// Generate a random 3D vector which coordinates are regulary distributed on a sphere of a given radius
+	///
+	/// @see gtc_random
+	template<typename T>
+	GLM_FUNC_DECL vec<3, T, defaultp> sphericalRand(T Radius);
+
+	/// Generate a random 2D vector which coordinates are regulary distributed within the area of a disk of a given radius
+	///
+	/// @see gtc_random
+	template<typename T>
+	GLM_FUNC_DECL vec<2, T, defaultp> diskRand(T Radius);
+
+	/// Generate a random 3D vector which coordinates are regulary distributed within the volume of a ball of a given radius
+	///
+	/// @see gtc_random
+	template<typename T>
+	GLM_FUNC_DECL vec<3, T, defaultp> ballRand(T Radius);
+
+	/// @}
+}//namespace glm
+
+#include "random.inl"
diff --git a/engine/inc/glm/gtc/random.inl b/engine/inc/glm/gtc/random.inl
new file mode 100644
index 00000000..de10a409
--- /dev/null
+++ b/engine/inc/glm/gtc/random.inl
@@ -0,0 +1,303 @@
+#include "../geometric.hpp"
+#include "../exponential.hpp"
+#include "../trigonometric.hpp"
+#include "../detail/type_vec1.hpp"
+#include <cstdlib>
+#include <ctime>
+#include <cassert>
+#include <cmath>
+
+namespace glm{
+namespace detail
+{
+	template <length_t L, typename T, qualifier Q>
+	struct compute_rand
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call();
+	};
+
+	template <qualifier P>
+	struct compute_rand<1, uint8, P>
+	{
+		GLM_FUNC_QUALIFIER static vec<1, uint8, P> call()
+		{
+			return vec<1, uint8, P>(
+				std::rand() % std::numeric_limits<uint8>::max());
+		}
+	};
+
+	template <qualifier P>
+	struct compute_rand<2, uint8, P>
+	{
+		GLM_FUNC_QUALIFIER static vec<2, uint8, P> call()
+		{
+			return vec<2, uint8, P>(
+				std::rand() % std::numeric_limits<uint8>::max(),
+				std::rand() % std::numeric_limits<uint8>::max());
+		}
+	};
+
+	template <qualifier P>
+	struct compute_rand<3, uint8, P>
+	{
+		GLM_FUNC_QUALIFIER static vec<3, uint8, P> call()
+		{
+			return vec<3, uint8, P>(
+				std::rand() % std::numeric_limits<uint8>::max(),
+				std::rand() % std::numeric_limits<uint8>::max(),
+				std::rand() % std::numeric_limits<uint8>::max());
+		}
+	};
+
+	template <qualifier P>
+	struct compute_rand<4, uint8, P>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, uint8, P> call()
+		{
+			return vec<4, uint8, P>(
+				std::rand() % std::numeric_limits<uint8>::max(),
+				std::rand() % std::numeric_limits<uint8>::max(),
+				std::rand() % std::numeric_limits<uint8>::max(),
+				std::rand() % std::numeric_limits<uint8>::max());
+		}
+	};
+
+	template <length_t L, qualifier Q>
+	struct compute_rand<L, uint16, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, uint16, Q> call()
+		{
+			return
+				(vec<L, uint16, Q>(compute_rand<L, uint8, Q>::call()) << static_cast<uint16>(8)) |
+				(vec<L, uint16, Q>(compute_rand<L, uint8, Q>::call()) << static_cast<uint16>(0));
+		}
+	};
+
+	template <length_t L, qualifier Q>
+	struct compute_rand<L, uint32, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, uint32, Q> call()
+		{
+			return
+				(vec<L, uint32, Q>(compute_rand<L, uint16, Q>::call()) << static_cast<uint32>(16)) |
+				(vec<L, uint32, Q>(compute_rand<L, uint16, Q>::call()) << static_cast<uint32>(0));
+		}
+	};
+
+	template <length_t L, qualifier Q>
+	struct compute_rand<L, uint64, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, uint64, Q> call()
+		{
+			return
+				(vec<L, uint64, Q>(compute_rand<L, uint32, Q>::call()) << static_cast<uint64>(32)) |
+				(vec<L, uint64, Q>(compute_rand<L, uint32, Q>::call()) << static_cast<uint64>(0));
+		}
+	};
+
+	template <length_t L, typename T, qualifier Q>
+	struct compute_linearRand
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& Min, vec<L, T, Q> const& Max);
+	};
+
+	template<length_t L, qualifier Q>
+	struct compute_linearRand<L, int8, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, int8, Q> call(vec<L, int8, Q> const& Min, vec<L, int8, Q> const& Max)
+		{
+			return (vec<L, int8, Q>(compute_rand<L, uint8, Q>::call() % vec<L, uint8, Q>(Max + static_cast<int8>(1) - Min))) + Min;
+		}
+	};
+
+	template<length_t L, qualifier Q>
+	struct compute_linearRand<L, uint8, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, uint8, Q> call(vec<L, uint8, Q> const& Min, vec<L, uint8, Q> const& Max)
+		{
+			return (compute_rand<L, uint8, Q>::call() % (Max + static_cast<uint8>(1) - Min)) + Min;
+		}
+	};
+
+	template<length_t L, qualifier Q>
+	struct compute_linearRand<L, int16, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, int16, Q> call(vec<L, int16, Q> const& Min, vec<L, int16, Q> const& Max)
+		{
+			return (vec<L, int16, Q>(compute_rand<L, uint16, Q>::call() % vec<L, uint16, Q>(Max + static_cast<int16>(1) - Min))) + Min;
+		}
+	};
+
+	template<length_t L, qualifier Q>
+	struct compute_linearRand<L, uint16, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, uint16, Q> call(vec<L, uint16, Q> const& Min, vec<L, uint16, Q> const& Max)
+		{
+			return (compute_rand<L, uint16, Q>::call() % (Max + static_cast<uint16>(1) - Min)) + Min;
+		}
+	};
+
+	template<length_t L, qualifier Q>
+	struct compute_linearRand<L, int32, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, int32, Q> call(vec<L, int32, Q> const& Min, vec<L, int32, Q> const& Max)
+		{
+			return (vec<L, int32, Q>(compute_rand<L, uint32, Q>::call() % vec<L, uint32, Q>(Max + static_cast<int32>(1) - Min))) + Min;
+		}
+	};
+
+	template<length_t L, qualifier Q>
+	struct compute_linearRand<L, uint32, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, uint32, Q> call(vec<L, uint32, Q> const& Min, vec<L, uint32, Q> const& Max)
+		{
+			return (compute_rand<L, uint32, Q>::call() % (Max + static_cast<uint32>(1) - Min)) + Min;
+		}
+	};
+
+	template<length_t L, qualifier Q>
+	struct compute_linearRand<L, int64, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, int64, Q> call(vec<L, int64, Q> const& Min, vec<L, int64, Q> const& Max)
+		{
+			return (vec<L, int64, Q>(compute_rand<L, uint64, Q>::call() % vec<L, uint64, Q>(Max + static_cast<int64>(1) - Min))) + Min;
+		}
+	};
+
+	template<length_t L, qualifier Q>
+	struct compute_linearRand<L, uint64, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, uint64, Q> call(vec<L, uint64, Q> const& Min, vec<L, uint64, Q> const& Max)
+		{
+			return (compute_rand<L, uint64, Q>::call() % (Max + static_cast<uint64>(1) - Min)) + Min;
+		}
+	};
+
+	template<length_t L, qualifier Q>
+	struct compute_linearRand<L, float, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, float, Q> call(vec<L, float, Q> const& Min, vec<L, float, Q> const& Max)
+		{
+			return vec<L, float, Q>(compute_rand<L, uint32, Q>::call()) / static_cast<float>(std::numeric_limits<uint32>::max()) * (Max - Min) + Min;
+		}
+	};
+
+	template<length_t L, qualifier Q>
+	struct compute_linearRand<L, double, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, double, Q> call(vec<L, double, Q> const& Min, vec<L, double, Q> const& Max)
+		{
+			return vec<L, double, Q>(compute_rand<L, uint64, Q>::call()) / static_cast<double>(std::numeric_limits<uint64>::max()) * (Max - Min) + Min;
+		}
+	};
+
+	template<length_t L, qualifier Q>
+	struct compute_linearRand<L, long double, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, long double, Q> call(vec<L, long double, Q> const& Min, vec<L, long double, Q> const& Max)
+		{
+			return vec<L, long double, Q>(compute_rand<L, uint64, Q>::call()) / static_cast<long double>(std::numeric_limits<uint64>::max()) * (Max - Min) + Min;
+		}
+	};
+}//namespace detail
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType linearRand(genType Min, genType Max)
+	{
+		return detail::compute_linearRand<1, genType, highp>::call(
+			vec<1, genType, highp>(Min),
+			vec<1, genType, highp>(Max)).x;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> linearRand(vec<L, T, Q> const& Min, vec<L, T, Q> const& Max)
+	{
+		return detail::compute_linearRand<L, T, Q>::call(Min, Max);
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType gaussRand(genType Mean, genType Deviation)
+	{
+		genType w, x1, x2;
+
+		do
+		{
+			x1 = linearRand(genType(-1), genType(1));
+			x2 = linearRand(genType(-1), genType(1));
+
+			w = x1 * x1 + x2 * x2;
+		} while(w > genType(1));
+
+		return x2 * Deviation * Deviation * sqrt((genType(-2) * log(w)) / w) + Mean;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> gaussRand(vec<L, T, Q> const& Mean, vec<L, T, Q> const& Deviation)
+	{
+		return detail::functor2<vec, L, T, Q>::call(gaussRand, Mean, Deviation);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER vec<2, T, defaultp> diskRand(T Radius)
+	{
+		assert(Radius > static_cast<T>(0));
+
+		vec<2, T, defaultp> Result(T(0));
+		T LenRadius(T(0));
+
+		do
+		{
+			Result = linearRand(
+				vec<2, T, defaultp>(-Radius),
+				vec<2, T, defaultp>(Radius));
+			LenRadius = length(Result);
+		}
+		while(LenRadius > Radius);
+
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER vec<3, T, defaultp> ballRand(T Radius)
+	{
+		assert(Radius > static_cast<T>(0));
+
+		vec<3, T, defaultp> Result(T(0));
+		T LenRadius(T(0));
+
+		do
+		{
+			Result = linearRand(
+				vec<3, T, defaultp>(-Radius),
+				vec<3, T, defaultp>(Radius));
+			LenRadius = length(Result);
+		}
+		while(LenRadius > Radius);
+
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER vec<2, T, defaultp> circularRand(T Radius)
+	{
+		assert(Radius > static_cast<T>(0));
+
+		T a = linearRand(T(0), static_cast<T>(6.283185307179586476925286766559));
+		return vec<2, T, defaultp>(glm::cos(a), glm::sin(a)) * Radius;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER vec<3, T, defaultp> sphericalRand(T Radius)
+	{
+		assert(Radius > static_cast<T>(0));
+
+		T theta = linearRand(T(0), T(6.283185307179586476925286766559f));
+		T phi = std::acos(linearRand(T(-1.0f), T(1.0f)));
+
+		T x = std::sin(phi) * std::cos(theta);
+		T y = std::sin(phi) * std::sin(theta);
+		T z = std::cos(phi);
+
+		return vec<3, T, defaultp>(x, y, z) * Radius;
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtc/reciprocal.hpp b/engine/inc/glm/gtc/reciprocal.hpp
new file mode 100644
index 00000000..c7d13303
--- /dev/null
+++ b/engine/inc/glm/gtc/reciprocal.hpp
@@ -0,0 +1,135 @@
+/// @ref gtc_reciprocal
+/// @file glm/gtc/reciprocal.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtc_reciprocal GLM_GTC_reciprocal
+/// @ingroup gtc
+///
+/// Include <glm/gtc/reciprocal.hpp> to use the features of this extension.
+///
+/// Define secant, cosecant and cotangent functions.
+
+#pragma once
+
+// Dependencies
+#include "../detail/setup.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTC_reciprocal extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtc_reciprocal
+	/// @{
+
+	/// Secant function.
+	/// hypotenuse / adjacent or 1 / cos(x)
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see gtc_reciprocal
+	template<typename genType>
+	GLM_FUNC_DECL genType sec(genType angle);
+
+	/// Cosecant function.
+	/// hypotenuse / opposite or 1 / sin(x)
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see gtc_reciprocal
+	template<typename genType>
+	GLM_FUNC_DECL genType csc(genType angle);
+
+	/// Cotangent function.
+	/// adjacent / opposite or 1 / tan(x)
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see gtc_reciprocal
+	template<typename genType>
+	GLM_FUNC_DECL genType cot(genType angle);
+
+	/// Inverse secant function.
+	///
+	/// @return Return an angle expressed in radians.
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see gtc_reciprocal
+	template<typename genType>
+	GLM_FUNC_DECL genType asec(genType x);
+
+	/// Inverse cosecant function.
+	///
+	/// @return Return an angle expressed in radians.
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see gtc_reciprocal
+	template<typename genType>
+	GLM_FUNC_DECL genType acsc(genType x);
+
+	/// Inverse cotangent function.
+	///
+	/// @return Return an angle expressed in radians.
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see gtc_reciprocal
+	template<typename genType>
+	GLM_FUNC_DECL genType acot(genType x);
+
+	/// Secant hyperbolic function.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see gtc_reciprocal
+	template<typename genType>
+	GLM_FUNC_DECL genType sech(genType angle);
+
+	/// Cosecant hyperbolic function.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see gtc_reciprocal
+	template<typename genType>
+	GLM_FUNC_DECL genType csch(genType angle);
+
+	/// Cotangent hyperbolic function.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see gtc_reciprocal
+	template<typename genType>
+	GLM_FUNC_DECL genType coth(genType angle);
+
+	/// Inverse secant hyperbolic function.
+	///
+	/// @return Return an angle expressed in radians.
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see gtc_reciprocal
+	template<typename genType>
+	GLM_FUNC_DECL genType asech(genType x);
+
+	/// Inverse cosecant hyperbolic function.
+	///
+	/// @return Return an angle expressed in radians.
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see gtc_reciprocal
+	template<typename genType>
+	GLM_FUNC_DECL genType acsch(genType x);
+
+	/// Inverse cotangent hyperbolic function.
+	///
+	/// @return Return an angle expressed in radians.
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see gtc_reciprocal
+	template<typename genType>
+	GLM_FUNC_DECL genType acoth(genType x);
+
+	/// @}
+}//namespace glm
+
+#include "reciprocal.inl"
diff --git a/engine/inc/glm/gtc/reciprocal.inl b/engine/inc/glm/gtc/reciprocal.inl
new file mode 100644
index 00000000..d88729e8
--- /dev/null
+++ b/engine/inc/glm/gtc/reciprocal.inl
@@ -0,0 +1,191 @@
+/// @ref gtc_reciprocal
+
+#include "../trigonometric.hpp"
+#include <limits>
+
+namespace glm
+{
+	// sec
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType sec(genType angle)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'sec' only accept floating-point values");
+		return genType(1) / glm::cos(angle);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> sec(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'sec' only accept floating-point inputs");
+		return detail::functor1<vec, L, T, T, Q>::call(sec, x);
+	}
+
+	// csc
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType csc(genType angle)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'csc' only accept floating-point values");
+		return genType(1) / glm::sin(angle);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> csc(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'csc' only accept floating-point inputs");
+		return detail::functor1<vec, L, T, T, Q>::call(csc, x);
+	}
+
+	// cot
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType cot(genType angle)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'cot' only accept floating-point values");
+
+		genType const pi_over_2 = genType(3.1415926535897932384626433832795 / 2.0);
+		return glm::tan(pi_over_2 - angle);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> cot(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'cot' only accept floating-point inputs");
+		return detail::functor1<vec, L, T, T, Q>::call(cot, x);
+	}
+
+	// asec
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType asec(genType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'asec' only accept floating-point values");
+		return acos(genType(1) / x);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> asec(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'asec' only accept floating-point inputs");
+		return detail::functor1<vec, L, T, T, Q>::call(asec, x);
+	}
+
+	// acsc
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType acsc(genType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'acsc' only accept floating-point values");
+		return asin(genType(1) / x);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> acsc(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'acsc' only accept floating-point inputs");
+		return detail::functor1<vec, L, T, T, Q>::call(acsc, x);
+	}
+
+	// acot
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType acot(genType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'acot' only accept floating-point values");
+
+		genType const pi_over_2 = genType(3.1415926535897932384626433832795 / 2.0);
+		return pi_over_2 - atan(x);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> acot(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'acot' only accept floating-point inputs");
+		return detail::functor1<vec, L, T, T, Q>::call(acot, x);
+	}
+
+	// sech
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType sech(genType angle)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'sech' only accept floating-point values");
+		return genType(1) / glm::cosh(angle);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> sech(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'sech' only accept floating-point inputs");
+		return detail::functor1<vec, L, T, T, Q>::call(sech, x);
+	}
+
+	// csch
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType csch(genType angle)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'csch' only accept floating-point values");
+		return genType(1) / glm::sinh(angle);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> csch(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'csch' only accept floating-point inputs");
+		return detail::functor1<vec, L, T, T, Q>::call(csch, x);
+	}
+
+	// coth
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType coth(genType angle)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'coth' only accept floating-point values");
+		return glm::cosh(angle) / glm::sinh(angle);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> coth(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'coth' only accept floating-point inputs");
+		return detail::functor1<vec, L, T, T, Q>::call(coth, x);
+	}
+
+	// asech
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType asech(genType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'asech' only accept floating-point values");
+		return acosh(genType(1) / x);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> asech(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'asech' only accept floating-point inputs");
+		return detail::functor1<vec, L, T, T, Q>::call(asech, x);
+	}
+
+	// acsch
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType acsch(genType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'acsch' only accept floating-point values");
+		return asinh(genType(1) / x);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> acsch(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'acsch' only accept floating-point inputs");
+		return detail::functor1<vec, L, T, T, Q>::call(acsch, x);
+	}
+
+	// acoth
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType acoth(genType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'acoth' only accept floating-point values");
+		return atanh(genType(1) / x);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> acoth(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'acoth' only accept floating-point inputs");
+		return detail::functor1<vec, L, T, T, Q>::call(acoth, x);
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtc/round.hpp b/engine/inc/glm/gtc/round.hpp
new file mode 100644
index 00000000..fbbcdeb5
--- /dev/null
+++ b/engine/inc/glm/gtc/round.hpp
@@ -0,0 +1,202 @@
+/// @ref gtc_round
+/// @file glm/gtc/round.hpp
+///
+/// @see core (dependence)
+/// @see gtc_round (dependence)
+///
+/// @defgroup gtc_round GLM_GTC_round
+/// @ingroup gtc
+///
+/// Include <glm/gtc/round.hpp> to use the features of this extension.
+///
+/// Rounding value to specific boundings
+
+#pragma once
+
+// Dependencies
+#include "../detail/setup.hpp"
+#include "../detail/qualifier.hpp"
+#include "../detail/_vectorize.hpp"
+#include "../vector_relational.hpp"
+#include "../common.hpp"
+#include <limits>
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTC_integer extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtc_round
+	/// @{
+
+	/// Return true if the value is a power of two number.
+	///
+	/// @see gtc_round
+	template<typename genIUType>
+	GLM_FUNC_DECL bool isPowerOfTwo(genIUType v);
+
+	/// Return true if the value is a power of two number.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see gtc_round
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, bool, Q> isPowerOfTwo(vec<L, T, Q> const& v);
+
+	/// Return the power of two number which value is just higher the input value,
+	/// round up to a power of two.
+	///
+	/// @see gtc_round
+	template<typename genIUType>
+	GLM_FUNC_DECL genIUType ceilPowerOfTwo(genIUType v);
+
+	/// Return the power of two number which value is just higher the input value,
+	/// round up to a power of two.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see gtc_round
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> ceilPowerOfTwo(vec<L, T, Q> const& v);
+
+	/// Return the power of two number which value is just lower the input value,
+	/// round down to a power of two.
+	///
+	/// @see gtc_round
+	template<typename genIUType>
+	GLM_FUNC_DECL genIUType floorPowerOfTwo(genIUType v);
+
+	/// Return the power of two number which value is just lower the input value,
+	/// round down to a power of two.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see gtc_round
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> floorPowerOfTwo(vec<L, T, Q> const& v);
+
+	/// Return the power of two number which value is the closet to the input value.
+	///
+	/// @see gtc_round
+	template<typename genIUType>
+	GLM_FUNC_DECL genIUType roundPowerOfTwo(genIUType v);
+
+	/// Return the power of two number which value is the closet to the input value.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see gtc_round
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> roundPowerOfTwo(vec<L, T, Q> const& v);
+
+	/// Return true if the 'Value' is a multiple of 'Multiple'.
+	///
+	/// @see gtc_round
+	template<typename genIUType>
+	GLM_FUNC_DECL bool isMultiple(genIUType v, genIUType Multiple);
+
+	/// Return true if the 'Value' is a multiple of 'Multiple'.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see gtc_round
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, bool, Q> isMultiple(vec<L, T, Q> const& v, T Multiple);
+
+	/// Return true if the 'Value' is a multiple of 'Multiple'.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see gtc_round
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, bool, Q> isMultiple(vec<L, T, Q> const& v, vec<L, T, Q> const& Multiple);
+
+	/// Higher multiple number of Source.
+	///
+	/// @tparam genType Floating-point or integer scalar or vector types.
+	///
+	/// @param v Source value to which is applied the function
+	/// @param Multiple Must be a null or positive value
+	///
+	/// @see gtc_round
+	template<typename genType>
+	GLM_FUNC_DECL genType ceilMultiple(genType v, genType Multiple);
+
+	/// Higher multiple number of Source.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @param v Source values to which is applied the function
+	/// @param Multiple Must be a null or positive value
+	///
+	/// @see gtc_round
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> ceilMultiple(vec<L, T, Q> const& v, vec<L, T, Q> const& Multiple);
+
+	/// Lower multiple number of Source.
+	///
+	/// @tparam genType Floating-point or integer scalar or vector types.
+	///
+	/// @param v Source value to which is applied the function
+	/// @param Multiple Must be a null or positive value
+	///
+	/// @see gtc_round
+	template<typename genType>
+	GLM_FUNC_DECL genType floorMultiple(genType v, genType Multiple);
+
+	/// Lower multiple number of Source.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @param v Source values to which is applied the function
+	/// @param Multiple Must be a null or positive value
+	///
+	/// @see gtc_round
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> floorMultiple(vec<L, T, Q> const& v, vec<L, T, Q> const& Multiple);
+
+	/// Lower multiple number of Source.
+	///
+	/// @tparam genType Floating-point or integer scalar or vector types.
+	///
+	/// @param v Source value to which is applied the function
+	/// @param Multiple Must be a null or positive value
+	///
+	/// @see gtc_round
+	template<typename genType>
+	GLM_FUNC_DECL genType roundMultiple(genType v, genType Multiple);
+
+	/// Lower multiple number of Source.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @param v Source values to which is applied the function
+	/// @param Multiple Must be a null or positive value
+	///
+	/// @see gtc_round
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> roundMultiple(vec<L, T, Q> const& v, vec<L, T, Q> const& Multiple);
+
+	/// @}
+} //namespace glm
+
+#include "round.inl"
diff --git a/engine/inc/glm/gtc/round.inl b/engine/inc/glm/gtc/round.inl
new file mode 100644
index 00000000..0d4d7d67
--- /dev/null
+++ b/engine/inc/glm/gtc/round.inl
@@ -0,0 +1,343 @@
+/// @ref gtc_round
+
+#include "../integer.hpp"
+
+namespace glm{
+namespace detail
+{
+	template<length_t L, typename T, qualifier Q, bool compute = false>
+	struct compute_ceilShift
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& v, T)
+		{
+			return v;
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q>
+	struct compute_ceilShift<L, T, Q, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& v, T Shift)
+		{
+			return v | (v >> Shift);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q, bool isSigned = true>
+	struct compute_ceilPowerOfTwo
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
+		{
+			GLM_STATIC_ASSERT(!std::numeric_limits<T>::is_iec559, "'ceilPowerOfTwo' only accept integer scalar or vector inputs");
+
+			vec<L, T, Q> const Sign(sign(x));
+
+			vec<L, T, Q> v(abs(x));
+
+			v = v - static_cast<T>(1);
+			v = v | (v >> static_cast<T>(1));
+			v = v | (v >> static_cast<T>(2));
+			v = v | (v >> static_cast<T>(4));
+			v = compute_ceilShift<L, T, Q, sizeof(T) >= 2>::call(v, 8);
+			v = compute_ceilShift<L, T, Q, sizeof(T) >= 4>::call(v, 16);
+			v = compute_ceilShift<L, T, Q, sizeof(T) >= 8>::call(v, 32);
+			return (v + static_cast<T>(1)) * Sign;
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q>
+	struct compute_ceilPowerOfTwo<L, T, Q, false>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
+		{
+			GLM_STATIC_ASSERT(!std::numeric_limits<T>::is_iec559, "'ceilPowerOfTwo' only accept integer scalar or vector inputs");
+
+			vec<L, T, Q> v(x);
+
+			v = v - static_cast<T>(1);
+			v = v | (v >> static_cast<T>(1));
+			v = v | (v >> static_cast<T>(2));
+			v = v | (v >> static_cast<T>(4));
+			v = compute_ceilShift<L, T, Q, sizeof(T) >= 2>::call(v, 8);
+			v = compute_ceilShift<L, T, Q, sizeof(T) >= 4>::call(v, 16);
+			v = compute_ceilShift<L, T, Q, sizeof(T) >= 8>::call(v, 32);
+			return v + static_cast<T>(1);
+		}
+	};
+
+	template<bool is_float, bool is_signed>
+	struct compute_ceilMultiple{};
+
+	template<>
+	struct compute_ceilMultiple<true, true>
+	{
+		template<typename genType>
+		GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
+		{
+			if(Source > genType(0))
+				return Source + (Multiple - std::fmod(Source, Multiple));
+			else
+				return Source + std::fmod(-Source, Multiple);
+		}
+	};
+
+	template<>
+	struct compute_ceilMultiple<false, false>
+	{
+		template<typename genType>
+		GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
+		{
+			genType Tmp = Source - genType(1);
+			return Tmp + (Multiple - (Tmp % Multiple));
+		}
+	};
+
+	template<>
+	struct compute_ceilMultiple<false, true>
+	{
+		template<typename genType>
+		GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
+		{
+			if(Source > genType(0))
+			{
+				genType Tmp = Source - genType(1);
+				return Tmp + (Multiple - (Tmp % Multiple));
+			}
+			else
+				return Source + (-Source % Multiple);
+		}
+	};
+
+	template<bool is_float, bool is_signed>
+	struct compute_floorMultiple{};
+
+	template<>
+	struct compute_floorMultiple<true, true>
+	{
+		template<typename genType>
+		GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
+		{
+			if(Source >= genType(0))
+				return Source - std::fmod(Source, Multiple);
+			else
+				return Source - std::fmod(Source, Multiple) - Multiple;
+		}
+	};
+
+	template<>
+	struct compute_floorMultiple<false, false>
+	{
+		template<typename genType>
+		GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
+		{
+			if(Source >= genType(0))
+				return Source - Source % Multiple;
+			else
+			{
+				genType Tmp = Source + genType(1);
+				return Tmp - Tmp % Multiple - Multiple;
+			}
+		}
+	};
+
+	template<>
+	struct compute_floorMultiple<false, true>
+	{
+		template<typename genType>
+		GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
+		{
+			if(Source >= genType(0))
+				return Source - Source % Multiple;
+			else
+			{
+				genType Tmp = Source + genType(1);
+				return Tmp - Tmp % Multiple - Multiple;
+			}
+		}
+	};
+
+	template<bool is_float, bool is_signed>
+	struct compute_roundMultiple{};
+
+	template<>
+	struct compute_roundMultiple<true, true>
+	{
+		template<typename genType>
+		GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
+		{
+			if(Source >= genType(0))
+				return Source - std::fmod(Source, Multiple);
+			else
+			{
+				genType Tmp = Source + genType(1);
+				return Tmp - std::fmod(Tmp, Multiple) - Multiple;
+			}
+		}
+	};
+
+	template<>
+	struct compute_roundMultiple<false, false>
+	{
+		template<typename genType>
+		GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
+		{
+			if(Source >= genType(0))
+				return Source - Source % Multiple;
+			else
+			{
+				genType Tmp = Source + genType(1);
+				return Tmp - Tmp % Multiple - Multiple;
+			}
+		}
+	};
+
+	template<>
+	struct compute_roundMultiple<false, true>
+	{
+		template<typename genType>
+		GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
+		{
+			if(Source >= genType(0))
+				return Source - Source % Multiple;
+			else
+			{
+				genType Tmp = Source + genType(1);
+				return Tmp - Tmp % Multiple - Multiple;
+			}
+		}
+	};
+}//namespace detail
+
+	////////////////
+	// isPowerOfTwo
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER bool isPowerOfTwo(genType Value)
+	{
+		genType const Result = glm::abs(Value);
+		return !(Result & (Result - 1));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, bool, Q> isPowerOfTwo(vec<L, T, Q> const& Value)
+	{
+		vec<L, T, Q> const Result(abs(Value));
+		return equal(Result & (Result - 1), vec<L, T, Q>(0));
+	}
+
+	//////////////////
+	// ceilPowerOfTwo
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType ceilPowerOfTwo(genType value)
+	{
+		return detail::compute_ceilPowerOfTwo<1, genType, defaultp, std::numeric_limits<genType>::is_signed>::call(vec<1, genType, defaultp>(value)).x;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> ceilPowerOfTwo(vec<L, T, Q> const& v)
+	{
+		return detail::compute_ceilPowerOfTwo<L, T, Q, std::numeric_limits<T>::is_signed>::call(v);
+	}
+
+	///////////////////
+	// floorPowerOfTwo
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType floorPowerOfTwo(genType value)
+	{
+		return isPowerOfTwo(value) ? value : static_cast<genType>(1) << findMSB(value);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> floorPowerOfTwo(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(floorPowerOfTwo, v);
+	}
+
+	///////////////////
+	// roundPowerOfTwo
+
+	template<typename genIUType>
+	GLM_FUNC_QUALIFIER genIUType roundPowerOfTwo(genIUType value)
+	{
+		if(isPowerOfTwo(value))
+			return value;
+
+		genIUType const prev = static_cast<genIUType>(1) << findMSB(value);
+		genIUType const next = prev << static_cast<genIUType>(1);
+		return (next - value) < (value - prev) ? next : prev;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> roundPowerOfTwo(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(roundPowerOfTwo, v);
+	}
+
+	////////////////
+	// isMultiple
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER bool isMultiple(genType Value, genType Multiple)
+	{
+		return isMultiple(vec<1, genType>(Value), vec<1, genType>(Multiple)).x;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, bool, Q> isMultiple(vec<L, T, Q> const& Value, T Multiple)
+	{
+		return (Value % Multiple) == vec<L, T, Q>(0);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, bool, Q> isMultiple(vec<L, T, Q> const& Value, vec<L, T, Q> const& Multiple)
+	{
+		return (Value % Multiple) == vec<L, T, Q>(0);
+	}
+
+	//////////////////////
+	// ceilMultiple
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType ceilMultiple(genType Source, genType Multiple)
+	{
+		return detail::compute_ceilMultiple<std::numeric_limits<genType>::is_iec559, std::numeric_limits<genType>::is_signed>::call(Source, Multiple);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> ceilMultiple(vec<L, T, Q> const& Source, vec<L, T, Q> const& Multiple)
+	{
+		return detail::functor2<vec, L, T, Q>::call(ceilMultiple, Source, Multiple);
+	}
+
+	//////////////////////
+	// floorMultiple
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType floorMultiple(genType Source, genType Multiple)
+	{
+		return detail::compute_floorMultiple<std::numeric_limits<genType>::is_iec559, std::numeric_limits<genType>::is_signed>::call(Source, Multiple);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> floorMultiple(vec<L, T, Q> const& Source, vec<L, T, Q> const& Multiple)
+	{
+		return detail::functor2<vec, L, T, Q>::call(floorMultiple, Source, Multiple);
+	}
+
+	//////////////////////
+	// roundMultiple
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType roundMultiple(genType Source, genType Multiple)
+	{
+		return detail::compute_roundMultiple<std::numeric_limits<genType>::is_iec559, std::numeric_limits<genType>::is_signed>::call(Source, Multiple);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> roundMultiple(vec<L, T, Q> const& Source, vec<L, T, Q> const& Multiple)
+	{
+		return detail::functor2<vec, L, T, Q>::call(roundMultiple, Source, Multiple);
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtc/type_aligned.hpp b/engine/inc/glm/gtc/type_aligned.hpp
new file mode 100644
index 00000000..5403abf6
--- /dev/null
+++ b/engine/inc/glm/gtc/type_aligned.hpp
@@ -0,0 +1,1315 @@
+/// @ref gtc_type_aligned
+/// @file glm/gtc/type_aligned.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtc_type_aligned GLM_GTC_type_aligned
+/// @ingroup gtc
+///
+/// Include <glm/gtc/type_aligned.hpp> to use the features of this extension.
+///
+/// Aligned types allowing SIMD optimizations of vectors and matrices types
+
+#pragma once
+
+#if (GLM_CONFIG_ALIGNED_GENTYPES == GLM_DISABLE)
+#	error "GLM: Aligned gentypes require to enable C++ language extensions. Define GLM_FORCE_ALIGNED_GENTYPES before including GLM headers to use aligned types."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+# pragma message("GLM: GLM_GTC_type_aligned extension included")
+#endif
+
+#include "../mat4x4.hpp"
+#include "../mat4x3.hpp"
+#include "../mat4x2.hpp"
+#include "../mat3x4.hpp"
+#include "../mat3x3.hpp"
+#include "../mat3x2.hpp"
+#include "../mat2x4.hpp"
+#include "../mat2x3.hpp"
+#include "../mat2x2.hpp"
+#include "../gtc/vec1.hpp"
+#include "../vec2.hpp"
+#include "../vec3.hpp"
+#include "../vec4.hpp"
+
+namespace glm
+{
+	/// @addtogroup gtc_type_aligned
+	/// @{
+
+	// -- *vec1 --
+
+	/// 1 component vector aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef vec<1, float, aligned_highp>	aligned_highp_vec1;
+
+	/// 1 component vector aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef vec<1, float, aligned_mediump>	aligned_mediump_vec1;
+
+	/// 1 component vector aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef vec<1, float, aligned_lowp>		aligned_lowp_vec1;
+
+	/// 1 component vector aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef vec<1, double, aligned_highp>	aligned_highp_dvec1;
+
+	/// 1 component vector aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef vec<1, double, aligned_mediump>	aligned_mediump_dvec1;
+
+	/// 1 component vector aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef vec<1, double, aligned_lowp>	aligned_lowp_dvec1;
+
+	/// 1 component vector aligned in memory of signed integer numbers.
+	typedef vec<1, int, aligned_highp>		aligned_highp_ivec1;
+
+	/// 1 component vector aligned in memory of signed integer numbers.
+	typedef vec<1, int, aligned_mediump>	aligned_mediump_ivec1;
+
+	/// 1 component vector aligned in memory of signed integer numbers.
+	typedef vec<1, int, aligned_lowp>		aligned_lowp_ivec1;
+
+	/// 1 component vector aligned in memory of unsigned integer numbers.
+	typedef vec<1, uint, aligned_highp>		aligned_highp_uvec1;
+
+	/// 1 component vector aligned in memory of unsigned integer numbers.
+	typedef vec<1, uint, aligned_mediump>	aligned_mediump_uvec1;
+
+	/// 1 component vector aligned in memory of unsigned integer numbers.
+	typedef vec<1, uint, aligned_lowp>		aligned_lowp_uvec1;
+
+	/// 1 component vector aligned in memory of bool values.
+	typedef vec<1, bool, aligned_highp>		aligned_highp_bvec1;
+
+	/// 1 component vector aligned in memory of bool values.
+	typedef vec<1, bool, aligned_mediump>	aligned_mediump_bvec1;
+
+	/// 1 component vector aligned in memory of bool values.
+	typedef vec<1, bool, aligned_lowp>		aligned_lowp_bvec1;
+
+	/// 1 component vector tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef vec<1, float, packed_highp>		packed_highp_vec1;
+
+	/// 1 component vector tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef vec<1, float, packed_mediump>	packed_mediump_vec1;
+
+	/// 1 component vector tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef vec<1, float, packed_lowp>		packed_lowp_vec1;
+
+	/// 1 component vector tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef vec<1, double, packed_highp>	packed_highp_dvec1;
+
+	/// 1 component vector tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef vec<1, double, packed_mediump>	packed_mediump_dvec1;
+
+	/// 1 component vector tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef vec<1, double, packed_lowp>		packed_lowp_dvec1;
+
+	/// 1 component vector tightly packed in memory of signed integer numbers.
+	typedef vec<1, int, packed_highp>		packed_highp_ivec1;
+
+	/// 1 component vector tightly packed in memory of signed integer numbers.
+	typedef vec<1, int, packed_mediump>		packed_mediump_ivec1;
+
+	/// 1 component vector tightly packed in memory of signed integer numbers.
+	typedef vec<1, int, packed_lowp>		packed_lowp_ivec1;
+
+	/// 1 component vector tightly packed in memory of unsigned integer numbers.
+	typedef vec<1, uint, packed_highp>		packed_highp_uvec1;
+
+	/// 1 component vector tightly packed in memory of unsigned integer numbers.
+	typedef vec<1, uint, packed_mediump>	packed_mediump_uvec1;
+
+	/// 1 component vector tightly packed in memory of unsigned integer numbers.
+	typedef vec<1, uint, packed_lowp>		packed_lowp_uvec1;
+
+	/// 1 component vector tightly packed in memory of bool values.
+	typedef vec<1, bool, packed_highp>		packed_highp_bvec1;
+
+	/// 1 component vector tightly packed in memory of bool values.
+	typedef vec<1, bool, packed_mediump>	packed_mediump_bvec1;
+
+	/// 1 component vector tightly packed in memory of bool values.
+	typedef vec<1, bool, packed_lowp>		packed_lowp_bvec1;
+
+	// -- *vec2 --
+
+	/// 2 components vector aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef vec<2, float, aligned_highp>	aligned_highp_vec2;
+
+	/// 2 components vector aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef vec<2, float, aligned_mediump>	aligned_mediump_vec2;
+
+	/// 2 components vector aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef vec<2, float, aligned_lowp>		aligned_lowp_vec2;
+
+	/// 2 components vector aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef vec<2, double, aligned_highp>	aligned_highp_dvec2;
+
+	/// 2 components vector aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef vec<2, double, aligned_mediump>	aligned_mediump_dvec2;
+
+	/// 2 components vector aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef vec<2, double, aligned_lowp>	aligned_lowp_dvec2;
+
+	/// 2 components vector aligned in memory of signed integer numbers.
+	typedef vec<2, int, aligned_highp>		aligned_highp_ivec2;
+
+	/// 2 components vector aligned in memory of signed integer numbers.
+	typedef vec<2, int, aligned_mediump>	aligned_mediump_ivec2;
+
+	/// 2 components vector aligned in memory of signed integer numbers.
+	typedef vec<2, int, aligned_lowp>		aligned_lowp_ivec2;
+
+	/// 2 components vector aligned in memory of unsigned integer numbers.
+	typedef vec<2, uint, aligned_highp>		aligned_highp_uvec2;
+
+	/// 2 components vector aligned in memory of unsigned integer numbers.
+	typedef vec<2, uint, aligned_mediump>	aligned_mediump_uvec2;
+
+	/// 2 components vector aligned in memory of unsigned integer numbers.
+	typedef vec<2, uint, aligned_lowp>		aligned_lowp_uvec2;
+
+	/// 2 components vector aligned in memory of bool values.
+	typedef vec<2, bool, aligned_highp>		aligned_highp_bvec2;
+
+	/// 2 components vector aligned in memory of bool values.
+	typedef vec<2, bool, aligned_mediump>	aligned_mediump_bvec2;
+
+	/// 2 components vector aligned in memory of bool values.
+	typedef vec<2, bool, aligned_lowp>		aligned_lowp_bvec2;
+
+	/// 2 components vector tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef vec<2, float, packed_highp>		packed_highp_vec2;
+
+	/// 2 components vector tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef vec<2, float, packed_mediump>	packed_mediump_vec2;
+
+	/// 2 components vector tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef vec<2, float, packed_lowp>		packed_lowp_vec2;
+
+	/// 2 components vector tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef vec<2, double, packed_highp>	packed_highp_dvec2;
+
+	/// 2 components vector tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef vec<2, double, packed_mediump>	packed_mediump_dvec2;
+
+	/// 2 components vector tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef vec<2, double, packed_lowp>		packed_lowp_dvec2;
+
+	/// 2 components vector tightly packed in memory of signed integer numbers.
+	typedef vec<2, int, packed_highp>		packed_highp_ivec2;
+
+	/// 2 components vector tightly packed in memory of signed integer numbers.
+	typedef vec<2, int, packed_mediump>		packed_mediump_ivec2;
+
+	/// 2 components vector tightly packed in memory of signed integer numbers.
+	typedef vec<2, int, packed_lowp>		packed_lowp_ivec2;
+
+	/// 2 components vector tightly packed in memory of unsigned integer numbers.
+	typedef vec<2, uint, packed_highp>		packed_highp_uvec2;
+
+	/// 2 components vector tightly packed in memory of unsigned integer numbers.
+	typedef vec<2, uint, packed_mediump>	packed_mediump_uvec2;
+
+	/// 2 components vector tightly packed in memory of unsigned integer numbers.
+	typedef vec<2, uint, packed_lowp>		packed_lowp_uvec2;
+
+	/// 2 components vector tightly packed in memory of bool values.
+	typedef vec<2, bool, packed_highp>		packed_highp_bvec2;
+
+	/// 2 components vector tightly packed in memory of bool values.
+	typedef vec<2, bool, packed_mediump>	packed_mediump_bvec2;
+
+	/// 2 components vector tightly packed in memory of bool values.
+	typedef vec<2, bool, packed_lowp>		packed_lowp_bvec2;
+
+	// -- *vec3 --
+
+	/// 3 components vector aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef vec<3, float, aligned_highp>	aligned_highp_vec3;
+
+	/// 3 components vector aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef vec<3, float, aligned_mediump>	aligned_mediump_vec3;
+
+	/// 3 components vector aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef vec<3, float, aligned_lowp>		aligned_lowp_vec3;
+
+	/// 3 components vector aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef vec<3, double, aligned_highp>	aligned_highp_dvec3;
+
+	/// 3 components vector aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef vec<3, double, aligned_mediump>	aligned_mediump_dvec3;
+
+	/// 3 components vector aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef vec<3, double, aligned_lowp>	aligned_lowp_dvec3;
+
+	/// 3 components vector aligned in memory of signed integer numbers.
+	typedef vec<3, int, aligned_highp>		aligned_highp_ivec3;
+
+	/// 3 components vector aligned in memory of signed integer numbers.
+	typedef vec<3, int, aligned_mediump>	aligned_mediump_ivec3;
+
+	/// 3 components vector aligned in memory of signed integer numbers.
+	typedef vec<3, int, aligned_lowp>		aligned_lowp_ivec3;
+
+	/// 3 components vector aligned in memory of unsigned integer numbers.
+	typedef vec<3, uint, aligned_highp>		aligned_highp_uvec3;
+
+	/// 3 components vector aligned in memory of unsigned integer numbers.
+	typedef vec<3, uint, aligned_mediump>	aligned_mediump_uvec3;
+
+	/// 3 components vector aligned in memory of unsigned integer numbers.
+	typedef vec<3, uint, aligned_lowp>		aligned_lowp_uvec3;
+
+	/// 3 components vector aligned in memory of bool values.
+	typedef vec<3, bool, aligned_highp>		aligned_highp_bvec3;
+
+	/// 3 components vector aligned in memory of bool values.
+	typedef vec<3, bool, aligned_mediump>	aligned_mediump_bvec3;
+
+	/// 3 components vector aligned in memory of bool values.
+	typedef vec<3, bool, aligned_lowp>		aligned_lowp_bvec3;
+
+	/// 3 components vector tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef vec<3, float, packed_highp>		packed_highp_vec3;
+
+	/// 3 components vector tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef vec<3, float, packed_mediump>	packed_mediump_vec3;
+
+	/// 3 components vector tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef vec<3, float, packed_lowp>		packed_lowp_vec3;
+
+	/// 3 components vector tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef vec<3, double, packed_highp>	packed_highp_dvec3;
+
+	/// 3 components vector tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef vec<3, double, packed_mediump>	packed_mediump_dvec3;
+
+	/// 3 components vector tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef vec<3, double, packed_lowp>		packed_lowp_dvec3;
+
+	/// 3 components vector tightly packed in memory of signed integer numbers.
+	typedef vec<3, int, packed_highp>		packed_highp_ivec3;
+
+	/// 3 components vector tightly packed in memory of signed integer numbers.
+	typedef vec<3, int, packed_mediump>		packed_mediump_ivec3;
+
+	/// 3 components vector tightly packed in memory of signed integer numbers.
+	typedef vec<3, int, packed_lowp>		packed_lowp_ivec3;
+
+	/// 3 components vector tightly packed in memory of unsigned integer numbers.
+	typedef vec<3, uint, packed_highp>		packed_highp_uvec3;
+
+	/// 3 components vector tightly packed in memory of unsigned integer numbers.
+	typedef vec<3, uint, packed_mediump>	packed_mediump_uvec3;
+
+	/// 3 components vector tightly packed in memory of unsigned integer numbers.
+	typedef vec<3, uint, packed_lowp>		packed_lowp_uvec3;
+
+	/// 3 components vector tightly packed in memory of bool values.
+	typedef vec<3, bool, packed_highp>		packed_highp_bvec3;
+
+	/// 3 components vector tightly packed in memory of bool values.
+	typedef vec<3, bool, packed_mediump>	packed_mediump_bvec3;
+
+	/// 3 components vector tightly packed in memory of bool values.
+	typedef vec<3, bool, packed_lowp>		packed_lowp_bvec3;
+
+	// -- *vec4 --
+
+	/// 4 components vector aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef vec<4, float, aligned_highp>	aligned_highp_vec4;
+
+	/// 4 components vector aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef vec<4, float, aligned_mediump>	aligned_mediump_vec4;
+
+	/// 4 components vector aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef vec<4, float, aligned_lowp>		aligned_lowp_vec4;
+
+	/// 4 components vector aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef vec<4, double, aligned_highp>	aligned_highp_dvec4;
+
+	/// 4 components vector aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef vec<4, double, aligned_mediump>	aligned_mediump_dvec4;
+
+	/// 4 components vector aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef vec<4, double, aligned_lowp>	aligned_lowp_dvec4;
+
+	/// 4 components vector aligned in memory of signed integer numbers.
+	typedef vec<4, int, aligned_highp>		aligned_highp_ivec4;
+
+	/// 4 components vector aligned in memory of signed integer numbers.
+	typedef vec<4, int, aligned_mediump>	aligned_mediump_ivec4;
+
+	/// 4 components vector aligned in memory of signed integer numbers.
+	typedef vec<4, int, aligned_lowp>		aligned_lowp_ivec4;
+
+	/// 4 components vector aligned in memory of unsigned integer numbers.
+	typedef vec<4, uint, aligned_highp>		aligned_highp_uvec4;
+
+	/// 4 components vector aligned in memory of unsigned integer numbers.
+	typedef vec<4, uint, aligned_mediump>	aligned_mediump_uvec4;
+
+	/// 4 components vector aligned in memory of unsigned integer numbers.
+	typedef vec<4, uint, aligned_lowp>		aligned_lowp_uvec4;
+
+	/// 4 components vector aligned in memory of bool values.
+	typedef vec<4, bool, aligned_highp>		aligned_highp_bvec4;
+
+	/// 4 components vector aligned in memory of bool values.
+	typedef vec<4, bool, aligned_mediump>	aligned_mediump_bvec4;
+
+	/// 4 components vector aligned in memory of bool values.
+	typedef vec<4, bool, aligned_lowp>		aligned_lowp_bvec4;
+
+	/// 4 components vector tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef vec<4, float, packed_highp>		packed_highp_vec4;
+
+	/// 4 components vector tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef vec<4, float, packed_mediump>	packed_mediump_vec4;
+
+	/// 4 components vector tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef vec<4, float, packed_lowp>		packed_lowp_vec4;
+
+	/// 4 components vector tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef vec<4, double, packed_highp>	packed_highp_dvec4;
+
+	/// 4 components vector tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef vec<4, double, packed_mediump>	packed_mediump_dvec4;
+
+	/// 4 components vector tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef vec<4, double, packed_lowp>		packed_lowp_dvec4;
+
+	/// 4 components vector tightly packed in memory of signed integer numbers.
+	typedef vec<4, int, packed_highp>		packed_highp_ivec4;
+
+	/// 4 components vector tightly packed in memory of signed integer numbers.
+	typedef vec<4, int, packed_mediump>		packed_mediump_ivec4;
+
+	/// 4 components vector tightly packed in memory of signed integer numbers.
+	typedef vec<4, int, packed_lowp>		packed_lowp_ivec4;
+
+	/// 4 components vector tightly packed in memory of unsigned integer numbers.
+	typedef vec<4, uint, packed_highp>		packed_highp_uvec4;
+
+	/// 4 components vector tightly packed in memory of unsigned integer numbers.
+	typedef vec<4, uint, packed_mediump>	packed_mediump_uvec4;
+
+	/// 4 components vector tightly packed in memory of unsigned integer numbers.
+	typedef vec<4, uint, packed_lowp>		packed_lowp_uvec4;
+
+	/// 4 components vector tightly packed in memory of bool values.
+	typedef vec<4, bool, packed_highp>		packed_highp_bvec4;
+
+	/// 4 components vector tightly packed in memory of bool values.
+	typedef vec<4, bool, packed_mediump>	packed_mediump_bvec4;
+
+	/// 4 components vector tightly packed in memory of bool values.
+	typedef vec<4, bool, packed_lowp>		packed_lowp_bvec4;
+
+	// -- *mat2 --
+
+	/// 2 by 2 matrix aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<2, 2, float, aligned_highp>		aligned_highp_mat2;
+
+	/// 2 by 2 matrix aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<2, 2, float, aligned_mediump>	aligned_mediump_mat2;
+
+	/// 2 by 2 matrix aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<2, 2, float, aligned_lowp>		aligned_lowp_mat2;
+
+	/// 2 by 2 matrix aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<2, 2, double, aligned_highp>	aligned_highp_dmat2;
+
+	/// 2 by 2 matrix aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<2, 2, double, aligned_mediump>	aligned_mediump_dmat2;
+
+	/// 2 by 2 matrix aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<2, 2, double, aligned_lowp>		aligned_lowp_dmat2;
+
+	/// 2 by 2 matrix tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<2, 2, float, packed_highp>		packed_highp_mat2;
+
+	/// 2 by 2 matrix tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<2, 2, float, packed_mediump>	packed_mediump_mat2;
+
+	/// 2 by 2 matrix tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<2, 2, float, packed_lowp>		packed_lowp_mat2;
+
+	/// 2 by 2 matrix tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<2, 2, double, packed_highp>		packed_highp_dmat2;
+
+	/// 2 by 2 matrix tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<2, 2, double, packed_mediump>	packed_mediump_dmat2;
+
+	/// 2 by 2 matrix tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<2, 2, double, packed_lowp>		packed_lowp_dmat2;
+
+	// -- *mat3 --
+
+	/// 3 by 3 matrix aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<3, 3, float, aligned_highp>		aligned_highp_mat3;
+
+	/// 3 by 3 matrix aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<3, 3, float, aligned_mediump>	aligned_mediump_mat3;
+
+	/// 3 by 3 matrix aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<3, 3, float, aligned_lowp>		aligned_lowp_mat3;
+
+	/// 3 by 3 matrix aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<3, 3, double, aligned_highp>	aligned_highp_dmat3;
+
+	/// 3 by 3 matrix aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<3, 3, double, aligned_mediump>	aligned_mediump_dmat3;
+
+	/// 3 by 3 matrix aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<3, 3, double, aligned_lowp>		aligned_lowp_dmat3;
+
+	/// 3 by 3 matrix tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<3, 3, float, packed_highp>		packed_highp_mat3;
+
+	/// 3 by 3 matrix tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<3, 3, float, packed_mediump>	packed_mediump_mat3;
+
+	/// 3 by 3 matrix tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<3, 3, float, packed_lowp>		packed_lowp_mat3;
+
+	/// 3 by 3 matrix tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<3, 3, double, packed_highp>		packed_highp_dmat3;
+
+	/// 3 by 3 matrix tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<3, 3, double, packed_mediump>	packed_mediump_dmat3;
+
+	/// 3 by 3 matrix tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<3, 3, double, packed_lowp>		packed_lowp_dmat3;
+
+	// -- *mat4 --
+
+	/// 4 by 4 matrix aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<4, 4, float, aligned_highp>		aligned_highp_mat4;
+
+	/// 4 by 4 matrix aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<4, 4, float, aligned_mediump>	aligned_mediump_mat4;
+
+	/// 4 by 4 matrix aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<4, 4, float, aligned_lowp>		aligned_lowp_mat4;
+
+	/// 4 by 4 matrix aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<4, 4, double, aligned_highp>	aligned_highp_dmat4;
+
+	/// 4 by 4 matrix aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<4, 4, double, aligned_mediump>	aligned_mediump_dmat4;
+
+	/// 4 by 4 matrix aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<4, 4, double, aligned_lowp>		aligned_lowp_dmat4;
+
+	/// 4 by 4 matrix tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<4, 4, float, packed_highp>		packed_highp_mat4;
+
+	/// 4 by 4 matrix tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<4, 4, float, packed_mediump>	packed_mediump_mat4;
+
+	/// 4 by 4 matrix tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<4, 4, float, packed_lowp>		packed_lowp_mat4;
+
+	/// 4 by 4 matrix tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<4, 4, double, packed_highp>		packed_highp_dmat4;
+
+	/// 4 by 4 matrix tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<4, 4, double, packed_mediump>	packed_mediump_dmat4;
+
+	/// 4 by 4 matrix tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<4, 4, double, packed_lowp>		packed_lowp_dmat4;
+
+	// -- *mat2x2 --
+
+	/// 2 by 2 matrix aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<2, 2, float, aligned_highp>		aligned_highp_mat2x2;
+
+	/// 2 by 2 matrix aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<2, 2, float, aligned_mediump>	aligned_mediump_mat2x2;
+
+	/// 2 by 2 matrix aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<2, 2, float, aligned_lowp>		aligned_lowp_mat2x2;
+
+	/// 2 by 2 matrix aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<2, 2, double, aligned_highp>	aligned_highp_dmat2x2;
+
+	/// 2 by 2 matrix aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<2, 2, double, aligned_mediump>	aligned_mediump_dmat2x2;
+
+	/// 2 by 2 matrix aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<2, 2, double, aligned_lowp>		aligned_lowp_dmat2x2;
+
+	/// 2 by 2 matrix tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<2, 2, float, packed_highp>		packed_highp_mat2x2;
+
+	/// 2 by 2 matrix tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<2, 2, float, packed_mediump>	packed_mediump_mat2x2;
+
+	/// 2 by 2 matrix tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<2, 2, float, packed_lowp>		packed_lowp_mat2x2;
+
+	/// 2 by 2 matrix tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<2, 2, double, packed_highp>		packed_highp_dmat2x2;
+
+	/// 2 by 2 matrix tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<2, 2, double, packed_mediump>	packed_mediump_dmat2x2;
+
+	/// 2 by 2 matrix tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<2, 2, double, packed_lowp>		packed_lowp_dmat2x2;
+
+	// -- *mat2x3 --
+
+	/// 2 by 3 matrix aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<2, 3, float, aligned_highp>		aligned_highp_mat2x3;
+
+	/// 2 by 3 matrix aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<2, 3, float, aligned_mediump>	aligned_mediump_mat2x3;
+
+	/// 2 by 3 matrix aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<2, 3, float, aligned_lowp>		aligned_lowp_mat2x3;
+
+	/// 2 by 3 matrix aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<2, 3, double, aligned_highp>	aligned_highp_dmat2x3;
+
+	/// 2 by 3 matrix aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<2, 3, double, aligned_mediump>	aligned_mediump_dmat2x3;
+
+	/// 2 by 3 matrix aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<2, 3, double, aligned_lowp>		aligned_lowp_dmat2x3;
+
+	/// 2 by 3 matrix tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<2, 3, float, packed_highp>		packed_highp_mat2x3;
+
+	/// 2 by 3 matrix tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<2, 3, float, packed_mediump>	packed_mediump_mat2x3;
+
+	/// 2 by 3 matrix tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<2, 3, float, packed_lowp>		packed_lowp_mat2x3;
+
+	/// 2 by 3 matrix tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<2, 3, double, packed_highp>		packed_highp_dmat2x3;
+
+	/// 2 by 3 matrix tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<2, 3, double, packed_mediump>	packed_mediump_dmat2x3;
+
+	/// 2 by 3 matrix tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<2, 3, double, packed_lowp>		packed_lowp_dmat2x3;
+
+	// -- *mat2x4 --
+
+	/// 2 by 4 matrix aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<2, 4, float, aligned_highp>		aligned_highp_mat2x4;
+
+	/// 2 by 4 matrix aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<2, 4, float, aligned_mediump>	aligned_mediump_mat2x4;
+
+	/// 2 by 4 matrix aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<2, 4, float, aligned_lowp>		aligned_lowp_mat2x4;
+
+	/// 2 by 4 matrix aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<2, 4, double, aligned_highp>	aligned_highp_dmat2x4;
+
+	/// 2 by 4 matrix aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<2, 4, double, aligned_mediump>	aligned_mediump_dmat2x4;
+
+	/// 2 by 4 matrix aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<2, 4, double, aligned_lowp>		aligned_lowp_dmat2x4;
+
+	/// 2 by 4 matrix tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<2, 4, float, packed_highp>		packed_highp_mat2x4;
+
+	/// 2 by 4 matrix tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<2, 4, float, packed_mediump>	packed_mediump_mat2x4;
+
+	/// 2 by 4 matrix tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<2, 4, float, packed_lowp>		packed_lowp_mat2x4;
+
+	/// 2 by 4 matrix tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<2, 4, double, packed_highp>		packed_highp_dmat2x4;
+
+	/// 2 by 4 matrix tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<2, 4, double, packed_mediump>	packed_mediump_dmat2x4;
+
+	/// 2 by 4 matrix tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<2, 4, double, packed_lowp>		packed_lowp_dmat2x4;
+
+	// -- *mat3x2 --
+
+	/// 3 by 2 matrix aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<3, 2, float, aligned_highp>		aligned_highp_mat3x2;
+
+	/// 3 by 2 matrix aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<3, 2, float, aligned_mediump>	aligned_mediump_mat3x2;
+
+	/// 3 by 2 matrix aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<3, 2, float, aligned_lowp>		aligned_lowp_mat3x2;
+
+	/// 3 by 2 matrix aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<3, 2, double, aligned_highp>	aligned_highp_dmat3x2;
+
+	/// 3 by 2 matrix aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<3, 2, double, aligned_mediump>	aligned_mediump_dmat3x2;
+
+	/// 3 by 2 matrix aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<3, 2, double, aligned_lowp>		aligned_lowp_dmat3x2;
+
+	/// 3 by 2 matrix tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<3, 2, float, packed_highp>		packed_highp_mat3x2;
+
+	/// 3 by 2 matrix tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<3, 2, float, packed_mediump>	packed_mediump_mat3x2;
+
+	/// 3 by 2 matrix tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<3, 2, float, packed_lowp>		packed_lowp_mat3x2;
+
+	/// 3 by 2 matrix tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<3, 2, double, packed_highp>		packed_highp_dmat3x2;
+
+	/// 3 by 2 matrix tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<3, 2, double, packed_mediump>	packed_mediump_dmat3x2;
+
+	/// 3 by 2 matrix tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<3, 2, double, packed_lowp>		packed_lowp_dmat3x2;
+
+	// -- *mat3x3 --
+
+	/// 3 by 3 matrix aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<3, 3, float, aligned_highp>		aligned_highp_mat3x3;
+
+	/// 3 by 3 matrix aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<3, 3, float, aligned_mediump>	aligned_mediump_mat3x3;
+
+	/// 3 by 3 matrix aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<3, 3, float, aligned_lowp>		aligned_lowp_mat3x3;
+
+	/// 3 by 3 matrix aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<3, 3, double, aligned_highp>	aligned_highp_dmat3x3;
+
+	/// 3 by 3 matrix aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<3, 3, double, aligned_mediump>	aligned_mediump_dmat3x3;
+
+	/// 3 by 3 matrix aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<3, 3, double, aligned_lowp>		aligned_lowp_dmat3x3;
+
+	/// 3 by 3 matrix tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<3, 3, float, packed_highp>		packed_highp_mat3x3;
+
+	/// 3 by 3 matrix tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<3, 3, float, packed_mediump>	packed_mediump_mat3x3;
+
+	/// 3 by 3 matrix tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<3, 3, float, packed_lowp>		packed_lowp_mat3x3;
+
+	/// 3 by 3 matrix tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<3, 3, double, packed_highp>		packed_highp_dmat3x3;
+
+	/// 3 by 3 matrix tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<3, 3, double, packed_mediump>	packed_mediump_dmat3x3;
+
+	/// 3 by 3 matrix tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<3, 3, double, packed_lowp>		packed_lowp_dmat3x3;
+
+	// -- *mat3x4 --
+
+	/// 3 by 4 matrix aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<3, 4, float, aligned_highp>		aligned_highp_mat3x4;
+
+	/// 3 by 4 matrix aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<3, 4, float, aligned_mediump>	aligned_mediump_mat3x4;
+
+	/// 3 by 4 matrix aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<3, 4, float, aligned_lowp>		aligned_lowp_mat3x4;
+
+	/// 3 by 4 matrix aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<3, 4, double, aligned_highp>	aligned_highp_dmat3x4;
+
+	/// 3 by 4 matrix aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<3, 4, double, aligned_mediump>	aligned_mediump_dmat3x4;
+
+	/// 3 by 4 matrix aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<3, 4, double, aligned_lowp>		aligned_lowp_dmat3x4;
+
+	/// 3 by 4 matrix tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<3, 4, float, packed_highp>		packed_highp_mat3x4;
+
+	/// 3 by 4 matrix tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<3, 4, float, packed_mediump>	packed_mediump_mat3x4;
+
+	/// 3 by 4 matrix tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<3, 4, float, packed_lowp>		packed_lowp_mat3x4;
+
+	/// 3 by 4 matrix tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<3, 4, double, packed_highp>		packed_highp_dmat3x4;
+
+	/// 3 by 4 matrix tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<3, 4, double, packed_mediump>	packed_mediump_dmat3x4;
+
+	/// 3 by 4 matrix tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<3, 4, double, packed_lowp>		packed_lowp_dmat3x4;
+
+	// -- *mat4x2 --
+
+	/// 4 by 2 matrix aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<4, 2, float, aligned_highp>		aligned_highp_mat4x2;
+
+	/// 4 by 2 matrix aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<4, 2, float, aligned_mediump>	aligned_mediump_mat4x2;
+
+	/// 4 by 2 matrix aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<4, 2, float, aligned_lowp>		aligned_lowp_mat4x2;
+
+	/// 4 by 2 matrix aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<4, 2, double, aligned_highp>	aligned_highp_dmat4x2;
+
+	/// 4 by 2 matrix aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<4, 2, double, aligned_mediump>	aligned_mediump_dmat4x2;
+
+	/// 4 by 2 matrix aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<4, 2, double, aligned_lowp>		aligned_lowp_dmat4x2;
+
+	/// 4 by 2 matrix tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<4, 2, float, packed_highp>		packed_highp_mat4x2;
+
+	/// 4 by 2 matrix tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<4, 2, float, packed_mediump>	packed_mediump_mat4x2;
+
+	/// 4 by 2 matrix tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<4, 2, float, packed_lowp>		packed_lowp_mat4x2;
+
+	/// 4 by 2 matrix tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<4, 2, double, packed_highp>		packed_highp_dmat4x2;
+
+	/// 4 by 2 matrix tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<4, 2, double, packed_mediump>	packed_mediump_dmat4x2;
+
+	/// 4 by 2 matrix tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<4, 2, double, packed_lowp>		packed_lowp_dmat4x2;
+
+	// -- *mat4x3 --
+
+	/// 4 by 3 matrix aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<4, 3, float, aligned_highp>		aligned_highp_mat4x3;
+
+	/// 4 by 3 matrix aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<4, 3, float, aligned_mediump>	aligned_mediump_mat4x3;
+
+	/// 4 by 3 matrix aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<4, 3, float, aligned_lowp>		aligned_lowp_mat4x3;
+
+	/// 4 by 3 matrix aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<4, 3, double, aligned_highp>	aligned_highp_dmat4x3;
+
+	/// 4 by 3 matrix aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<4, 3, double, aligned_mediump>	aligned_mediump_dmat4x3;
+
+	/// 4 by 3 matrix aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<4, 3, double, aligned_lowp>		aligned_lowp_dmat4x3;
+
+	/// 4 by 3 matrix tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<4, 3, float, packed_highp>		packed_highp_mat4x3;
+
+	/// 4 by 3 matrix tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<4, 3, float, packed_mediump>	packed_mediump_mat4x3;
+
+	/// 4 by 3 matrix tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<4, 3, float, packed_lowp>		packed_lowp_mat4x3;
+
+	/// 4 by 3 matrix tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<4, 3, double, packed_highp>		packed_highp_dmat4x3;
+
+	/// 4 by 3 matrix tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<4, 3, double, packed_mediump>	packed_mediump_dmat4x3;
+
+	/// 4 by 3 matrix tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<4, 3, double, packed_lowp>		packed_lowp_dmat4x3;
+
+	// -- *mat4x4 --
+
+	/// 4 by 4 matrix aligned in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<4, 4, float, aligned_highp>		aligned_highp_mat4x4;
+
+	/// 4 by 4 matrix aligned in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<4, 4, float, aligned_mediump>	aligned_mediump_mat4x4;
+
+	/// 4 by 4 matrix aligned in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<4, 4, float, aligned_lowp>		aligned_lowp_mat4x4;
+
+	/// 4 by 4 matrix aligned in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<4, 4, double, aligned_highp>	aligned_highp_dmat4x4;
+
+	/// 4 by 4 matrix aligned in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<4, 4, double, aligned_mediump>	aligned_mediump_dmat4x4;
+
+	/// 4 by 4 matrix aligned in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<4, 4, double, aligned_lowp>		aligned_lowp_dmat4x4;
+
+	/// 4 by 4 matrix tightly packed in memory of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<4, 4, float, packed_highp>		packed_highp_mat4x4;
+
+	/// 4 by 4 matrix tightly packed in memory of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<4, 4, float, packed_mediump>	packed_mediump_mat4x4;
+
+	/// 4 by 4 matrix tightly packed in memory of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<4, 4, float, packed_lowp>		packed_lowp_mat4x4;
+
+	/// 4 by 4 matrix tightly packed in memory of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
+	typedef mat<4, 4, double, packed_highp>		packed_highp_dmat4x4;
+
+	/// 4 by 4 matrix tightly packed in memory of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
+	typedef mat<4, 4, double, packed_mediump>	packed_mediump_dmat4x4;
+
+	/// 4 by 4 matrix tightly packed in memory of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
+	typedef mat<4, 4, double, packed_lowp>		packed_lowp_dmat4x4;
+
+	// -- default --
+
+#if(defined(GLM_PRECISION_LOWP_FLOAT))
+	typedef aligned_lowp_vec1			aligned_vec1;
+	typedef aligned_lowp_vec2			aligned_vec2;
+	typedef aligned_lowp_vec3			aligned_vec3;
+	typedef aligned_lowp_vec4			aligned_vec4;
+	typedef packed_lowp_vec1			packed_vec1;
+	typedef packed_lowp_vec2			packed_vec2;
+	typedef packed_lowp_vec3			packed_vec3;
+	typedef packed_lowp_vec4			packed_vec4;
+
+	typedef aligned_lowp_mat2			aligned_mat2;
+	typedef aligned_lowp_mat3			aligned_mat3;
+	typedef aligned_lowp_mat4			aligned_mat4;
+	typedef packed_lowp_mat2			packed_mat2;
+	typedef packed_lowp_mat3			packed_mat3;
+	typedef packed_lowp_mat4			packed_mat4;
+
+	typedef aligned_lowp_mat2x2			aligned_mat2x2;
+	typedef aligned_lowp_mat2x3			aligned_mat2x3;
+	typedef aligned_lowp_mat2x4			aligned_mat2x4;
+	typedef aligned_lowp_mat3x2			aligned_mat3x2;
+	typedef aligned_lowp_mat3x3			aligned_mat3x3;
+	typedef aligned_lowp_mat3x4			aligned_mat3x4;
+	typedef aligned_lowp_mat4x2			aligned_mat4x2;
+	typedef aligned_lowp_mat4x3			aligned_mat4x3;
+	typedef aligned_lowp_mat4x4			aligned_mat4x4;
+	typedef packed_lowp_mat2x2			packed_mat2x2;
+	typedef packed_lowp_mat2x3			packed_mat2x3;
+	typedef packed_lowp_mat2x4			packed_mat2x4;
+	typedef packed_lowp_mat3x2			packed_mat3x2;
+	typedef packed_lowp_mat3x3			packed_mat3x3;
+	typedef packed_lowp_mat3x4			packed_mat3x4;
+	typedef packed_lowp_mat4x2			packed_mat4x2;
+	typedef packed_lowp_mat4x3			packed_mat4x3;
+	typedef packed_lowp_mat4x4			packed_mat4x4;
+#elif(defined(GLM_PRECISION_MEDIUMP_FLOAT))
+	typedef aligned_mediump_vec1		aligned_vec1;
+	typedef aligned_mediump_vec2		aligned_vec2;
+	typedef aligned_mediump_vec3		aligned_vec3;
+	typedef aligned_mediump_vec4		aligned_vec4;
+	typedef packed_mediump_vec1			packed_vec1;
+	typedef packed_mediump_vec2			packed_vec2;
+	typedef packed_mediump_vec3			packed_vec3;
+	typedef packed_mediump_vec4			packed_vec4;
+
+	typedef aligned_mediump_mat2		aligned_mat2;
+	typedef aligned_mediump_mat3		aligned_mat3;
+	typedef aligned_mediump_mat4		aligned_mat4;
+	typedef packed_mediump_mat2			packed_mat2;
+	typedef packed_mediump_mat3			packed_mat3;
+	typedef packed_mediump_mat4			packed_mat4;
+
+	typedef aligned_mediump_mat2x2		aligned_mat2x2;
+	typedef aligned_mediump_mat2x3		aligned_mat2x3;
+	typedef aligned_mediump_mat2x4		aligned_mat2x4;
+	typedef aligned_mediump_mat3x2		aligned_mat3x2;
+	typedef aligned_mediump_mat3x3		aligned_mat3x3;
+	typedef aligned_mediump_mat3x4		aligned_mat3x4;
+	typedef aligned_mediump_mat4x2		aligned_mat4x2;
+	typedef aligned_mediump_mat4x3		aligned_mat4x3;
+	typedef aligned_mediump_mat4x4		aligned_mat4x4;
+	typedef packed_mediump_mat2x2		packed_mat2x2;
+	typedef packed_mediump_mat2x3		packed_mat2x3;
+	typedef packed_mediump_mat2x4		packed_mat2x4;
+	typedef packed_mediump_mat3x2		packed_mat3x2;
+	typedef packed_mediump_mat3x3		packed_mat3x3;
+	typedef packed_mediump_mat3x4		packed_mat3x4;
+	typedef packed_mediump_mat4x2		packed_mat4x2;
+	typedef packed_mediump_mat4x3		packed_mat4x3;
+	typedef packed_mediump_mat4x4		packed_mat4x4;
+#else //defined(GLM_PRECISION_HIGHP_FLOAT)
+	/// 1 component vector aligned in memory of single-precision floating-point numbers.
+	typedef aligned_highp_vec1			aligned_vec1;
+
+	/// 2 components vector aligned in memory of single-precision floating-point numbers.
+	typedef aligned_highp_vec2			aligned_vec2;
+
+	/// 3 components vector aligned in memory of single-precision floating-point numbers.
+	typedef aligned_highp_vec3			aligned_vec3;
+
+	/// 4 components vector aligned in memory of single-precision floating-point numbers.
+	typedef aligned_highp_vec4 			aligned_vec4;
+
+	/// 1 component vector tightly packed in memory of single-precision floating-point numbers.
+	typedef packed_highp_vec1			packed_vec1;
+
+	/// 2 components vector tightly packed in memory of single-precision floating-point numbers.
+	typedef packed_highp_vec2			packed_vec2;
+
+	/// 3 components vector tightly packed in memory of single-precision floating-point numbers.
+	typedef packed_highp_vec3			packed_vec3;
+
+	/// 4 components vector tightly packed in memory of single-precision floating-point numbers.
+	typedef packed_highp_vec4			packed_vec4;
+
+	/// 2 by 2 matrix tightly aligned in memory of single-precision floating-point numbers.
+	typedef aligned_highp_mat2			aligned_mat2;
+
+	/// 3 by 3 matrix tightly aligned in memory of single-precision floating-point numbers.
+	typedef aligned_highp_mat3			aligned_mat3;
+
+	/// 4 by 4 matrix tightly aligned in memory of single-precision floating-point numbers.
+	typedef aligned_highp_mat4			aligned_mat4;
+
+	/// 2 by 2 matrix tightly packed in memory of single-precision floating-point numbers.
+	typedef packed_highp_mat2			packed_mat2;
+
+	/// 3 by 3 matrix tightly packed in memory of single-precision floating-point numbers.
+	typedef packed_highp_mat3			packed_mat3;
+
+	/// 4 by 4 matrix tightly packed in memory of single-precision floating-point numbers.
+	typedef packed_highp_mat4			packed_mat4;
+
+	/// 2 by 2 matrix tightly aligned in memory of single-precision floating-point numbers.
+	typedef aligned_highp_mat2x2		aligned_mat2x2;
+
+	/// 2 by 3 matrix tightly aligned in memory of single-precision floating-point numbers.
+	typedef aligned_highp_mat2x3		aligned_mat2x3;
+
+	/// 2 by 4 matrix tightly aligned in memory of single-precision floating-point numbers.
+	typedef aligned_highp_mat2x4		aligned_mat2x4;
+
+	/// 3 by 2 matrix tightly aligned in memory of single-precision floating-point numbers.
+	typedef aligned_highp_mat3x2		aligned_mat3x2;
+
+	/// 3 by 3 matrix tightly aligned in memory of single-precision floating-point numbers.
+	typedef aligned_highp_mat3x3		aligned_mat3x3;
+
+	/// 3 by 4 matrix tightly aligned in memory of single-precision floating-point numbers.
+	typedef aligned_highp_mat3x4		aligned_mat3x4;
+
+	/// 4 by 2 matrix tightly aligned in memory of single-precision floating-point numbers.
+	typedef aligned_highp_mat4x2		aligned_mat4x2;
+
+	/// 4 by 3 matrix tightly aligned in memory of single-precision floating-point numbers.
+	typedef aligned_highp_mat4x3		aligned_mat4x3;
+
+	/// 4 by 4 matrix tightly aligned in memory of single-precision floating-point numbers.
+	typedef aligned_highp_mat4x4		aligned_mat4x4;
+
+	/// 2 by 2 matrix tightly packed in memory of single-precision floating-point numbers.
+	typedef packed_highp_mat2x2			packed_mat2x2;
+
+	/// 2 by 3 matrix tightly packed in memory of single-precision floating-point numbers.
+	typedef packed_highp_mat2x3			packed_mat2x3;
+
+	/// 2 by 4 matrix tightly packed in memory of single-precision floating-point numbers.
+	typedef packed_highp_mat2x4			packed_mat2x4;
+
+	/// 3 by 2 matrix tightly packed in memory of single-precision floating-point numbers.
+	typedef packed_highp_mat3x2			packed_mat3x2;
+
+	/// 3 by 3 matrix tightly packed in memory of single-precision floating-point numbers.
+	typedef packed_highp_mat3x3			packed_mat3x3;
+
+	/// 3 by 4 matrix tightly packed in memory of single-precision floating-point numbers.
+	typedef packed_highp_mat3x4			packed_mat3x4;
+
+	/// 4 by 2 matrix tightly packed in memory of single-precision floating-point numbers.
+	typedef packed_highp_mat4x2			packed_mat4x2;
+
+	/// 4 by 3 matrix tightly packed in memory of single-precision floating-point numbers.
+	typedef packed_highp_mat4x3			packed_mat4x3;
+
+	/// 4 by 4 matrix tightly packed in memory of single-precision floating-point numbers.
+	typedef packed_highp_mat4x4			packed_mat4x4;
+#endif//GLM_PRECISION
+
+#if(defined(GLM_PRECISION_LOWP_DOUBLE))
+	typedef aligned_lowp_dvec1			aligned_dvec1;
+	typedef aligned_lowp_dvec2			aligned_dvec2;
+	typedef aligned_lowp_dvec3			aligned_dvec3;
+	typedef aligned_lowp_dvec4			aligned_dvec4;
+	typedef packed_lowp_dvec1			packed_dvec1;
+	typedef packed_lowp_dvec2			packed_dvec2;
+	typedef packed_lowp_dvec3			packed_dvec3;
+	typedef packed_lowp_dvec4			packed_dvec4;
+
+	typedef aligned_lowp_dmat2			aligned_dmat2;
+	typedef aligned_lowp_dmat3			aligned_dmat3;
+	typedef aligned_lowp_dmat4			aligned_dmat4;
+	typedef packed_lowp_dmat2			packed_dmat2;
+	typedef packed_lowp_dmat3			packed_dmat3;
+	typedef packed_lowp_dmat4			packed_dmat4;
+
+	typedef aligned_lowp_dmat2x2		aligned_dmat2x2;
+	typedef aligned_lowp_dmat2x3		aligned_dmat2x3;
+	typedef aligned_lowp_dmat2x4		aligned_dmat2x4;
+	typedef aligned_lowp_dmat3x2		aligned_dmat3x2;
+	typedef aligned_lowp_dmat3x3		aligned_dmat3x3;
+	typedef aligned_lowp_dmat3x4		aligned_dmat3x4;
+	typedef aligned_lowp_dmat4x2		aligned_dmat4x2;
+	typedef aligned_lowp_dmat4x3		aligned_dmat4x3;
+	typedef aligned_lowp_dmat4x4		aligned_dmat4x4;
+	typedef packed_lowp_dmat2x2			packed_dmat2x2;
+	typedef packed_lowp_dmat2x3			packed_dmat2x3;
+	typedef packed_lowp_dmat2x4			packed_dmat2x4;
+	typedef packed_lowp_dmat3x2			packed_dmat3x2;
+	typedef packed_lowp_dmat3x3			packed_dmat3x3;
+	typedef packed_lowp_dmat3x4			packed_dmat3x4;
+	typedef packed_lowp_dmat4x2			packed_dmat4x2;
+	typedef packed_lowp_dmat4x3			packed_dmat4x3;
+	typedef packed_lowp_dmat4x4			packed_dmat4x4;
+#elif(defined(GLM_PRECISION_MEDIUMP_DOUBLE))
+	typedef aligned_mediump_dvec1		aligned_dvec1;
+	typedef aligned_mediump_dvec2		aligned_dvec2;
+	typedef aligned_mediump_dvec3		aligned_dvec3;
+	typedef aligned_mediump_dvec4		aligned_dvec4;
+	typedef packed_mediump_dvec1		packed_dvec1;
+	typedef packed_mediump_dvec2		packed_dvec2;
+	typedef packed_mediump_dvec3		packed_dvec3;
+	typedef packed_mediump_dvec4		packed_dvec4;
+
+	typedef aligned_mediump_dmat2		aligned_dmat2;
+	typedef aligned_mediump_dmat3		aligned_dmat3;
+	typedef aligned_mediump_dmat4		aligned_dmat4;
+	typedef packed_mediump_dmat2		packed_dmat2;
+	typedef packed_mediump_dmat3		packed_dmat3;
+	typedef packed_mediump_dmat4		packed_dmat4;
+
+	typedef aligned_mediump_dmat2x2		aligned_dmat2x2;
+	typedef aligned_mediump_dmat2x3		aligned_dmat2x3;
+	typedef aligned_mediump_dmat2x4		aligned_dmat2x4;
+	typedef aligned_mediump_dmat3x2		aligned_dmat3x2;
+	typedef aligned_mediump_dmat3x3		aligned_dmat3x3;
+	typedef aligned_mediump_dmat3x4		aligned_dmat3x4;
+	typedef aligned_mediump_dmat4x2		aligned_dmat4x2;
+	typedef aligned_mediump_dmat4x3		aligned_dmat4x3;
+	typedef aligned_mediump_dmat4x4		aligned_dmat4x4;
+	typedef packed_mediump_dmat2x2		packed_dmat2x2;
+	typedef packed_mediump_dmat2x3		packed_dmat2x3;
+	typedef packed_mediump_dmat2x4		packed_dmat2x4;
+	typedef packed_mediump_dmat3x2		packed_dmat3x2;
+	typedef packed_mediump_dmat3x3		packed_dmat3x3;
+	typedef packed_mediump_dmat3x4		packed_dmat3x4;
+	typedef packed_mediump_dmat4x2		packed_dmat4x2;
+	typedef packed_mediump_dmat4x3		packed_dmat4x3;
+	typedef packed_mediump_dmat4x4		packed_dmat4x4;
+#else //defined(GLM_PRECISION_HIGHP_DOUBLE)
+	/// 1 component vector aligned in memory of double-precision floating-point numbers.
+	typedef aligned_highp_dvec1			aligned_dvec1;
+
+	/// 2 components vector aligned in memory of double-precision floating-point numbers.
+	typedef aligned_highp_dvec2			aligned_dvec2;
+
+	/// 3 components vector aligned in memory of double-precision floating-point numbers.
+	typedef aligned_highp_dvec3			aligned_dvec3;
+
+	/// 4 components vector aligned in memory of double-precision floating-point numbers.
+	typedef aligned_highp_dvec4			aligned_dvec4;
+
+	/// 1 component vector tightly packed in memory of double-precision floating-point numbers.
+	typedef packed_highp_dvec1			packed_dvec1;
+
+	/// 2 components vector tightly packed in memory of double-precision floating-point numbers.
+	typedef packed_highp_dvec2			packed_dvec2;
+
+	/// 3 components vector tightly packed in memory of double-precision floating-point numbers.
+	typedef packed_highp_dvec3			packed_dvec3;
+
+	/// 4 components vector tightly packed in memory of double-precision floating-point numbers.
+	typedef packed_highp_dvec4			packed_dvec4;
+
+	/// 2 by 2 matrix tightly aligned in memory of double-precision floating-point numbers.
+	typedef aligned_highp_dmat2			aligned_dmat2;
+
+	/// 3 by 3 matrix tightly aligned in memory of double-precision floating-point numbers.
+	typedef aligned_highp_dmat3			aligned_dmat3;
+
+	/// 4 by 4 matrix tightly aligned in memory of double-precision floating-point numbers.
+	typedef aligned_highp_dmat4			aligned_dmat4;
+
+	/// 2 by 2 matrix tightly packed in memory of double-precision floating-point numbers.
+	typedef packed_highp_dmat2			packed_dmat2;
+
+	/// 3 by 3 matrix tightly packed in memory of double-precision floating-point numbers.
+	typedef packed_highp_dmat3			packed_dmat3;
+
+	/// 4 by 4 matrix tightly packed in memory of double-precision floating-point numbers.
+	typedef packed_highp_dmat4			packed_dmat4;
+
+	/// 2 by 2 matrix tightly aligned in memory of double-precision floating-point numbers.
+	typedef aligned_highp_dmat2x2		aligned_dmat2x2;
+
+	/// 2 by 3 matrix tightly aligned in memory of double-precision floating-point numbers.
+	typedef aligned_highp_dmat2x3		aligned_dmat2x3;
+
+	/// 2 by 4 matrix tightly aligned in memory of double-precision floating-point numbers.
+	typedef aligned_highp_dmat2x4		aligned_dmat2x4;
+
+	/// 3 by 2 matrix tightly aligned in memory of double-precision floating-point numbers.
+	typedef aligned_highp_dmat3x2		aligned_dmat3x2;
+
+	/// 3 by 3 matrix tightly aligned in memory of double-precision floating-point numbers.
+	typedef aligned_highp_dmat3x3		aligned_dmat3x3;
+
+	/// 3 by 4 matrix tightly aligned in memory of double-precision floating-point numbers.
+	typedef aligned_highp_dmat3x4		aligned_dmat3x4;
+
+	/// 4 by 2 matrix tightly aligned in memory of double-precision floating-point numbers.
+	typedef aligned_highp_dmat4x2		aligned_dmat4x2;
+
+	/// 4 by 3 matrix tightly aligned in memory of double-precision floating-point numbers.
+	typedef aligned_highp_dmat4x3		aligned_dmat4x3;
+
+	/// 4 by 4 matrix tightly aligned in memory of double-precision floating-point numbers.
+	typedef aligned_highp_dmat4x4		aligned_dmat4x4;
+
+	/// 2 by 2 matrix tightly packed in memory of double-precision floating-point numbers.
+	typedef packed_highp_dmat2x2		packed_dmat2x2;
+
+	/// 2 by 3 matrix tightly packed in memory of double-precision floating-point numbers.
+	typedef packed_highp_dmat2x3		packed_dmat2x3;
+
+	/// 2 by 4 matrix tightly packed in memory of double-precision floating-point numbers.
+	typedef packed_highp_dmat2x4		packed_dmat2x4;
+
+	/// 3 by 2 matrix tightly packed in memory of double-precision floating-point numbers.
+	typedef packed_highp_dmat3x2		packed_dmat3x2;
+
+	/// 3 by 3 matrix tightly packed in memory of double-precision floating-point numbers.
+	typedef packed_highp_dmat3x3		packed_dmat3x3;
+
+	/// 3 by 4 matrix tightly packed in memory of double-precision floating-point numbers.
+	typedef packed_highp_dmat3x4		packed_dmat3x4;
+
+	/// 4 by 2 matrix tightly packed in memory of double-precision floating-point numbers.
+	typedef packed_highp_dmat4x2		packed_dmat4x2;
+
+	/// 4 by 3 matrix tightly packed in memory of double-precision floating-point numbers.
+	typedef packed_highp_dmat4x3		packed_dmat4x3;
+
+	/// 4 by 4 matrix tightly packed in memory of double-precision floating-point numbers.
+	typedef packed_highp_dmat4x4		packed_dmat4x4;
+#endif//GLM_PRECISION
+
+#if(defined(GLM_PRECISION_LOWP_INT))
+	typedef aligned_lowp_ivec1			aligned_ivec1;
+	typedef aligned_lowp_ivec2			aligned_ivec2;
+	typedef aligned_lowp_ivec3			aligned_ivec3;
+	typedef aligned_lowp_ivec4			aligned_ivec4;
+#elif(defined(GLM_PRECISION_MEDIUMP_INT))
+	typedef aligned_mediump_ivec1		aligned_ivec1;
+	typedef aligned_mediump_ivec2		aligned_ivec2;
+	typedef aligned_mediump_ivec3		aligned_ivec3;
+	typedef aligned_mediump_ivec4		aligned_ivec4;
+#else //defined(GLM_PRECISION_HIGHP_INT)
+	/// 1 component vector aligned in memory of signed integer numbers.
+	typedef aligned_highp_ivec1			aligned_ivec1;
+
+	/// 2 components vector aligned in memory of signed integer numbers.
+	typedef aligned_highp_ivec2			aligned_ivec2;
+
+	/// 3 components vector aligned in memory of signed integer numbers.
+	typedef aligned_highp_ivec3			aligned_ivec3;
+
+	/// 4 components vector aligned in memory of signed integer numbers.
+	typedef aligned_highp_ivec4			aligned_ivec4;
+
+	/// 1 component vector tightly packed in memory of signed integer numbers.
+	typedef packed_highp_ivec1			packed_ivec1;
+
+	/// 2 components vector tightly packed in memory of signed integer numbers.
+	typedef packed_highp_ivec2			packed_ivec2;
+
+	/// 3 components vector tightly packed in memory of signed integer numbers.
+	typedef packed_highp_ivec3			packed_ivec3;
+
+	/// 4 components vector tightly packed in memory of signed integer numbers.
+	typedef packed_highp_ivec4			packed_ivec4;
+#endif//GLM_PRECISION
+
+	// -- Unsigned integer definition --
+
+#if(defined(GLM_PRECISION_LOWP_UINT))
+	typedef aligned_lowp_uvec1			aligned_uvec1;
+	typedef aligned_lowp_uvec2			aligned_uvec2;
+	typedef aligned_lowp_uvec3			aligned_uvec3;
+	typedef aligned_lowp_uvec4			aligned_uvec4;
+#elif(defined(GLM_PRECISION_MEDIUMP_UINT))
+	typedef aligned_mediump_uvec1		aligned_uvec1;
+	typedef aligned_mediump_uvec2		aligned_uvec2;
+	typedef aligned_mediump_uvec3		aligned_uvec3;
+	typedef aligned_mediump_uvec4		aligned_uvec4;
+#else //defined(GLM_PRECISION_HIGHP_UINT)
+	/// 1 component vector aligned in memory of unsigned integer numbers.
+	typedef aligned_highp_uvec1			aligned_uvec1;
+
+	/// 2 components vector aligned in memory of unsigned integer numbers.
+	typedef aligned_highp_uvec2			aligned_uvec2;
+
+	/// 3 components vector aligned in memory of unsigned integer numbers.
+	typedef aligned_highp_uvec3			aligned_uvec3;
+
+	/// 4 components vector aligned in memory of unsigned integer numbers.
+	typedef aligned_highp_uvec4			aligned_uvec4;
+
+	/// 1 component vector tightly packed in memory of unsigned integer numbers.
+	typedef packed_highp_uvec1			packed_uvec1;
+
+	/// 2 components vector tightly packed in memory of unsigned integer numbers.
+	typedef packed_highp_uvec2			packed_uvec2;
+
+	/// 3 components vector tightly packed in memory of unsigned integer numbers.
+	typedef packed_highp_uvec3			packed_uvec3;
+
+	/// 4 components vector tightly packed in memory of unsigned integer numbers.
+	typedef packed_highp_uvec4			packed_uvec4;
+#endif//GLM_PRECISION
+
+#if(defined(GLM_PRECISION_LOWP_BOOL))
+	typedef aligned_lowp_bvec1			aligned_bvec1;
+	typedef aligned_lowp_bvec2			aligned_bvec2;
+	typedef aligned_lowp_bvec3			aligned_bvec3;
+	typedef aligned_lowp_bvec4			aligned_bvec4;
+#elif(defined(GLM_PRECISION_MEDIUMP_BOOL))
+	typedef aligned_mediump_bvec1		aligned_bvec1;
+	typedef aligned_mediump_bvec2		aligned_bvec2;
+	typedef aligned_mediump_bvec3		aligned_bvec3;
+	typedef aligned_mediump_bvec4		aligned_bvec4;
+#else //defined(GLM_PRECISION_HIGHP_BOOL)
+	/// 1 component vector aligned in memory of bool values.
+	typedef aligned_highp_bvec1			aligned_bvec1;
+
+	/// 2 components vector aligned in memory of bool values.
+	typedef aligned_highp_bvec2			aligned_bvec2;
+
+	/// 3 components vector aligned in memory of bool values.
+	typedef aligned_highp_bvec3			aligned_bvec3;
+
+	/// 4 components vector aligned in memory of bool values.
+	typedef aligned_highp_bvec4			aligned_bvec4;
+
+	/// 1 components vector tightly packed in memory of bool values.
+	typedef packed_highp_bvec1			packed_bvec1;
+
+	/// 2 components vector tightly packed in memory of bool values.
+	typedef packed_highp_bvec2			packed_bvec2;
+
+	/// 3 components vector tightly packed in memory of bool values.
+	typedef packed_highp_bvec3			packed_bvec3;
+
+	/// 4 components vector tightly packed in memory of bool values.
+	typedef packed_highp_bvec4			packed_bvec4;
+#endif//GLM_PRECISION
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/gtc/type_precision.hpp b/engine/inc/glm/gtc/type_precision.hpp
new file mode 100644
index 00000000..250bc4f9
--- /dev/null
+++ b/engine/inc/glm/gtc/type_precision.hpp
@@ -0,0 +1,2138 @@
+/// @ref gtc_type_precision
+/// @file glm/gtc/type_precision.hpp
+///
+/// @see core (dependence)
+/// @see gtc_quaternion (dependence)
+///
+/// @defgroup gtc_type_precision GLM_GTC_type_precision
+/// @ingroup gtc
+///
+/// Include <glm/gtc/type_precision.hpp> to use the features of this extension.
+///
+/// Defines specific C++-based qualifier types.
+
+#pragma once
+
+// Dependency:
+#include "../gtc/quaternion.hpp"
+#include "../gtc/vec1.hpp"
+#include "../ext/scalar_int_sized.hpp"
+#include "../ext/scalar_uint_sized.hpp"
+#include "../detail/type_vec2.hpp"
+#include "../detail/type_vec3.hpp"
+#include "../detail/type_vec4.hpp"
+#include "../detail/type_mat2x2.hpp"
+#include "../detail/type_mat2x3.hpp"
+#include "../detail/type_mat2x4.hpp"
+#include "../detail/type_mat3x2.hpp"
+#include "../detail/type_mat3x3.hpp"
+#include "../detail/type_mat3x4.hpp"
+#include "../detail/type_mat4x2.hpp"
+#include "../detail/type_mat4x3.hpp"
+#include "../detail/type_mat4x4.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTC_type_precision extension included")
+#endif
+
+namespace glm
+{
+	///////////////////////////
+	// Signed int vector types
+
+	/// @addtogroup gtc_type_precision
+	/// @{
+
+	/// Low qualifier 8 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int8 lowp_int8;
+
+	/// Low qualifier 16 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int16 lowp_int16;
+
+	/// Low qualifier 32 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int32 lowp_int32;
+
+	/// Low qualifier 64 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int64 lowp_int64;
+
+	/// Low qualifier 8 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int8 lowp_int8_t;
+
+	/// Low qualifier 16 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int16 lowp_int16_t;
+
+	/// Low qualifier 32 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int32 lowp_int32_t;
+
+	/// Low qualifier 64 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int64 lowp_int64_t;
+
+	/// Low qualifier 8 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int8 lowp_i8;
+
+	/// Low qualifier 16 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int16 lowp_i16;
+
+	/// Low qualifier 32 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int32 lowp_i32;
+
+	/// Low qualifier 64 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int64 lowp_i64;
+
+	/// Medium qualifier 8 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int8 mediump_int8;
+
+	/// Medium qualifier 16 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int16 mediump_int16;
+
+	/// Medium qualifier 32 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int32 mediump_int32;
+
+	/// Medium qualifier 64 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int64 mediump_int64;
+
+	/// Medium qualifier 8 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int8 mediump_int8_t;
+
+	/// Medium qualifier 16 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int16 mediump_int16_t;
+
+	/// Medium qualifier 32 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int32 mediump_int32_t;
+
+	/// Medium qualifier 64 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int64 mediump_int64_t;
+
+	/// Medium qualifier 8 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int8 mediump_i8;
+
+	/// Medium qualifier 16 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int16 mediump_i16;
+
+	/// Medium qualifier 32 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int32 mediump_i32;
+
+	/// Medium qualifier 64 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int64 mediump_i64;
+
+	/// High qualifier 8 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int8 highp_int8;
+
+	/// High qualifier 16 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int16 highp_int16;
+
+	/// High qualifier 32 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int32 highp_int32;
+
+	/// High qualifier 64 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int64 highp_int64;
+
+	/// High qualifier 8 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int8 highp_int8_t;
+
+	/// High qualifier 16 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int16 highp_int16_t;
+
+	/// 32 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int32 highp_int32_t;
+
+	/// High qualifier 64 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int64 highp_int64_t;
+
+	/// High qualifier 8 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int8 highp_i8;
+
+	/// High qualifier 16 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int16 highp_i16;
+
+	/// High qualifier 32 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int32 highp_i32;
+
+	/// High qualifier 64 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int64 highp_i64;
+
+
+#if GLM_HAS_EXTENDED_INTEGER_TYPE
+	using std::int8_t;
+	using std::int16_t;
+	using std::int32_t;
+	using std::int64_t;
+#else
+	/// 8 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int8 int8_t;
+
+	/// 16 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int16 int16_t;
+
+	/// 32 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int32 int32_t;
+
+	/// 64 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int64 int64_t;
+#endif
+
+	/// 8 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int8 i8;
+
+	/// 16 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int16 i16;
+
+	/// 32 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int32 i32;
+
+	/// 64 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int64 i64;
+
+
+
+	/// Low qualifier 8 bit signed integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, i8, lowp> lowp_i8vec1;
+
+	/// Low qualifier 8 bit signed integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, i8, lowp> lowp_i8vec2;
+
+	/// Low qualifier 8 bit signed integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, i8, lowp> lowp_i8vec3;
+
+	/// Low qualifier 8 bit signed integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, i8, lowp> lowp_i8vec4;
+
+
+	/// Medium qualifier 8 bit signed integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, i8, mediump> mediump_i8vec1;
+
+	/// Medium qualifier 8 bit signed integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, i8, mediump> mediump_i8vec2;
+
+	/// Medium qualifier 8 bit signed integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, i8, mediump> mediump_i8vec3;
+
+	/// Medium qualifier 8 bit signed integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, i8, mediump> mediump_i8vec4;
+
+
+	/// High qualifier 8 bit signed integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, i8, highp> highp_i8vec1;
+
+	/// High qualifier 8 bit signed integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, i8, highp> highp_i8vec2;
+
+	/// High qualifier 8 bit signed integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, i8, highp> highp_i8vec3;
+
+	/// High qualifier 8 bit signed integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, i8, highp> highp_i8vec4;
+
+
+
+	/// 8 bit signed integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, i8, defaultp> i8vec1;
+
+	/// 8 bit signed integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, i8, defaultp> i8vec2;
+
+	/// 8 bit signed integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, i8, defaultp> i8vec3;
+
+	/// 8 bit signed integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, i8, defaultp> i8vec4;
+
+
+
+
+
+	/// Low qualifier 16 bit signed integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, i16, lowp>		lowp_i16vec1;
+
+	/// Low qualifier 16 bit signed integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, i16, lowp>		lowp_i16vec2;
+
+	/// Low qualifier 16 bit signed integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, i16, lowp>		lowp_i16vec3;
+
+	/// Low qualifier 16 bit signed integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, i16, lowp>		lowp_i16vec4;
+
+
+	/// Medium qualifier 16 bit signed integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, i16, mediump>		mediump_i16vec1;
+
+	/// Medium qualifier 16 bit signed integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, i16, mediump>		mediump_i16vec2;
+
+	/// Medium qualifier 16 bit signed integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, i16, mediump>		mediump_i16vec3;
+
+	/// Medium qualifier 16 bit signed integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, i16, mediump>		mediump_i16vec4;
+
+
+	/// High qualifier 16 bit signed integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, i16, highp>		highp_i16vec1;
+
+	/// High qualifier 16 bit signed integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, i16, highp>		highp_i16vec2;
+
+	/// High qualifier 16 bit signed integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, i16, highp>		highp_i16vec3;
+
+	/// High qualifier 16 bit signed integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, i16, highp>		highp_i16vec4;
+
+
+
+
+	/// 16 bit signed integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, i16, defaultp> i16vec1;
+
+	/// 16 bit signed integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, i16, defaultp> i16vec2;
+
+	/// 16 bit signed integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, i16, defaultp> i16vec3;
+
+	/// 16 bit signed integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, i16, defaultp> i16vec4;
+
+
+
+	/// Low qualifier 32 bit signed integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, i32, lowp>		lowp_i32vec1;
+
+	/// Low qualifier 32 bit signed integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, i32, lowp>		lowp_i32vec2;
+
+	/// Low qualifier 32 bit signed integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, i32, lowp>		lowp_i32vec3;
+
+	/// Low qualifier 32 bit signed integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, i32, lowp>		lowp_i32vec4;
+
+
+	/// Medium qualifier 32 bit signed integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, i32, mediump>		mediump_i32vec1;
+
+	/// Medium qualifier 32 bit signed integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, i32, mediump>		mediump_i32vec2;
+
+	/// Medium qualifier 32 bit signed integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, i32, mediump>		mediump_i32vec3;
+
+	/// Medium qualifier 32 bit signed integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, i32, mediump>		mediump_i32vec4;
+
+
+	/// High qualifier 32 bit signed integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, i32, highp>		highp_i32vec1;
+
+	/// High qualifier 32 bit signed integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, i32, highp>		highp_i32vec2;
+
+	/// High qualifier 32 bit signed integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, i32, highp>		highp_i32vec3;
+
+	/// High qualifier 32 bit signed integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, i32, highp>		highp_i32vec4;
+
+
+	/// 32 bit signed integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, i32, defaultp> i32vec1;
+
+	/// 32 bit signed integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, i32, defaultp> i32vec2;
+
+	/// 32 bit signed integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, i32, defaultp> i32vec3;
+
+	/// 32 bit signed integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, i32, defaultp> i32vec4;
+
+
+
+
+	/// Low qualifier 64 bit signed integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, i64, lowp>		lowp_i64vec1;
+
+	/// Low qualifier 64 bit signed integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, i64, lowp>		lowp_i64vec2;
+
+	/// Low qualifier 64 bit signed integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, i64, lowp>		lowp_i64vec3;
+
+	/// Low qualifier 64 bit signed integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, i64, lowp>		lowp_i64vec4;
+
+
+	/// Medium qualifier 64 bit signed integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, i64, mediump>		mediump_i64vec1;
+
+	/// Medium qualifier 64 bit signed integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, i64, mediump>		mediump_i64vec2;
+
+	/// Medium qualifier 64 bit signed integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, i64, mediump>		mediump_i64vec3;
+
+	/// Medium qualifier 64 bit signed integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, i64, mediump>		mediump_i64vec4;
+
+
+	/// High qualifier 64 bit signed integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, i64, highp>		highp_i64vec1;
+
+	/// High qualifier 64 bit signed integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, i64, highp>		highp_i64vec2;
+
+	/// High qualifier 64 bit signed integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, i64, highp>		highp_i64vec3;
+
+	/// High qualifier 64 bit signed integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, i64, highp>		highp_i64vec4;
+
+
+	/// 64 bit signed integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, i64, defaultp> i64vec1;
+
+	/// 64 bit signed integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, i64, defaultp> i64vec2;
+
+	/// 64 bit signed integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, i64, defaultp> i64vec3;
+
+	/// 64 bit signed integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, i64, defaultp> i64vec4;
+
+
+	/////////////////////////////
+	// Unsigned int vector types
+
+	/// Low qualifier 8 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint8 lowp_uint8;
+
+	/// Low qualifier 16 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint16 lowp_uint16;
+
+	/// Low qualifier 32 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint32 lowp_uint32;
+
+	/// Low qualifier 64 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint64 lowp_uint64;
+
+	/// Low qualifier 8 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint8 lowp_uint8_t;
+
+	/// Low qualifier 16 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint16 lowp_uint16_t;
+
+	/// Low qualifier 32 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint32 lowp_uint32_t;
+
+	/// Low qualifier 64 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint64 lowp_uint64_t;
+
+	/// Low qualifier 8 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint8 lowp_u8;
+
+	/// Low qualifier 16 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint16 lowp_u16;
+
+	/// Low qualifier 32 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint32 lowp_u32;
+
+	/// Low qualifier 64 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint64 lowp_u64;
+
+	/// Medium qualifier 8 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint8 mediump_uint8;
+
+	/// Medium qualifier 16 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint16 mediump_uint16;
+
+	/// Medium qualifier 32 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint32 mediump_uint32;
+
+	/// Medium qualifier 64 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint64 mediump_uint64;
+
+	/// Medium qualifier 8 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint8 mediump_uint8_t;
+
+	/// Medium qualifier 16 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint16 mediump_uint16_t;
+
+	/// Medium qualifier 32 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint32 mediump_uint32_t;
+
+	/// Medium qualifier 64 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint64 mediump_uint64_t;
+
+	/// Medium qualifier 8 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint8 mediump_u8;
+
+	/// Medium qualifier 16 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint16 mediump_u16;
+
+	/// Medium qualifier 32 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint32 mediump_u32;
+
+	/// Medium qualifier 64 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint64 mediump_u64;
+
+	/// High qualifier 8 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint8 highp_uint8;
+
+	/// High qualifier 16 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint16 highp_uint16;
+
+	/// High qualifier 32 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint32 highp_uint32;
+
+	/// High qualifier 64 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint64 highp_uint64;
+
+	/// High qualifier 8 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint8 highp_uint8_t;
+
+	/// High qualifier 16 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint16 highp_uint16_t;
+
+	/// High qualifier 32 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint32 highp_uint32_t;
+
+	/// High qualifier 64 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint64 highp_uint64_t;
+
+	/// High qualifier 8 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint8 highp_u8;
+
+	/// High qualifier 16 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint16 highp_u16;
+
+	/// High qualifier 32 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint32 highp_u32;
+
+	/// High qualifier 64 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint64 highp_u64;
+
+#if GLM_HAS_EXTENDED_INTEGER_TYPE
+	using std::uint8_t;
+	using std::uint16_t;
+	using std::uint32_t;
+	using std::uint64_t;
+#else
+	/// Default qualifier 8 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint8 uint8_t;
+
+	/// Default qualifier 16 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint16 uint16_t;
+
+	/// Default qualifier 32 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint32 uint32_t;
+
+	/// Default qualifier 64 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint64 uint64_t;
+#endif
+
+	/// Default qualifier 8 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint8 u8;
+
+	/// Default qualifier 16 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint16 u16;
+
+	/// Default qualifier 32 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint32 u32;
+
+	/// Default qualifier 64 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint64 u64;
+
+
+
+
+
+	//////////////////////
+	// Float vector types
+
+	/// Single-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float float32;
+
+	/// Double-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef double float64;
+
+	/// Low 32 bit single-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float32 lowp_float32;
+
+	/// Low 64 bit double-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float64 lowp_float64;
+
+	/// Low 32 bit single-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float32 lowp_float32_t;
+
+	/// Low 64 bit double-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float64 lowp_float64_t;
+
+	/// Low 32 bit single-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float32 lowp_f32;
+
+	/// Low 64 bit double-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float64 lowp_f64;
+
+	/// Low 32 bit single-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float32 lowp_float32;
+
+	/// Low 64 bit double-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float64 lowp_float64;
+
+	/// Low 32 bit single-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float32 lowp_float32_t;
+
+	/// Low 64 bit double-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float64 lowp_float64_t;
+
+	/// Low 32 bit single-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float32 lowp_f32;
+
+	/// Low 64 bit double-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float64 lowp_f64;
+
+
+	/// Low 32 bit single-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float32 lowp_float32;
+
+	/// Low 64 bit double-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float64 lowp_float64;
+
+	/// Low 32 bit single-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float32 lowp_float32_t;
+
+	/// Low 64 bit double-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float64 lowp_float64_t;
+
+	/// Low 32 bit single-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float32 lowp_f32;
+
+	/// Low 64 bit double-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float64 lowp_f64;
+
+
+	/// Medium 32 bit single-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float32 mediump_float32;
+
+	/// Medium 64 bit double-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float64 mediump_float64;
+
+	/// Medium 32 bit single-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float32 mediump_float32_t;
+
+	/// Medium 64 bit double-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float64 mediump_float64_t;
+
+	/// Medium 32 bit single-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float32 mediump_f32;
+
+	/// Medium 64 bit double-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float64 mediump_f64;
+
+
+	/// High 32 bit single-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float32 highp_float32;
+
+	/// High 64 bit double-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float64 highp_float64;
+
+	/// High 32 bit single-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float32 highp_float32_t;
+
+	/// High 64 bit double-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float64 highp_float64_t;
+
+	/// High 32 bit single-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float32 highp_f32;
+
+	/// High 64 bit double-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float64 highp_f64;
+
+
+#if(defined(GLM_PRECISION_LOWP_FLOAT))
+	/// Default 32 bit single-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef lowp_float32_t float32_t;
+
+	/// Default 64 bit double-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef lowp_float64_t float64_t;
+
+	/// Default 32 bit single-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef lowp_f32 f32;
+
+	/// Default 64 bit double-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef lowp_f64 f64;
+
+#elif(defined(GLM_PRECISION_MEDIUMP_FLOAT))
+	/// Default 32 bit single-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef mediump_float32 float32_t;
+
+	/// Default 64 bit double-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef mediump_float64 float64_t;
+
+	/// Default 32 bit single-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef mediump_float32 f32;
+
+	/// Default 64 bit double-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef mediump_float64 f64;
+
+#else//(defined(GLM_PRECISION_HIGHP_FLOAT))
+
+	/// Default 32 bit single-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef highp_float32_t float32_t;
+
+	/// Default 64 bit double-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef highp_float64_t float64_t;
+
+	/// Default 32 bit single-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef highp_float32_t f32;
+
+	/// Default 64 bit double-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef highp_float64_t f64;
+#endif
+
+
+	/// Low single-qualifier floating-point vector of 1 component.
+	/// @see gtc_type_precision
+	typedef vec<1, float, lowp> lowp_fvec1;
+
+	/// Low single-qualifier floating-point vector of 2 components.
+	/// @see gtc_type_precision
+	typedef vec<2, float, lowp> lowp_fvec2;
+
+	/// Low single-qualifier floating-point vector of 3 components.
+	/// @see gtc_type_precision
+	typedef vec<3, float, lowp> lowp_fvec3;
+
+	/// Low single-qualifier floating-point vector of 4 components.
+	/// @see gtc_type_precision
+	typedef vec<4, float, lowp> lowp_fvec4;
+
+
+	/// Medium single-qualifier floating-point vector of 1 component.
+	/// @see gtc_type_precision
+	typedef vec<1, float, mediump> mediump_fvec1;
+
+	/// Medium Single-qualifier floating-point vector of 2 components.
+	/// @see gtc_type_precision
+	typedef vec<2, float, mediump> mediump_fvec2;
+
+	/// Medium Single-qualifier floating-point vector of 3 components.
+	/// @see gtc_type_precision
+	typedef vec<3, float, mediump> mediump_fvec3;
+
+	/// Medium Single-qualifier floating-point vector of 4 components.
+	/// @see gtc_type_precision
+	typedef vec<4, float, mediump> mediump_fvec4;
+
+
+	/// High single-qualifier floating-point vector of 1 component.
+	/// @see gtc_type_precision
+	typedef vec<1, float, highp> highp_fvec1;
+
+	/// High Single-qualifier floating-point vector of 2 components.
+	/// @see core_precision
+	typedef vec<2, float, highp> highp_fvec2;
+
+	/// High Single-qualifier floating-point vector of 3 components.
+	/// @see core_precision
+	typedef vec<3, float, highp> highp_fvec3;
+
+	/// High Single-qualifier floating-point vector of 4 components.
+	/// @see core_precision
+	typedef vec<4, float, highp> highp_fvec4;
+
+
+	/// Low single-qualifier floating-point vector of 1 component.
+	/// @see gtc_type_precision
+	typedef vec<1, f32, lowp> lowp_f32vec1;
+
+	/// Low single-qualifier floating-point vector of 2 components.
+	/// @see core_precision
+	typedef vec<2, f32, lowp> lowp_f32vec2;
+
+	/// Low single-qualifier floating-point vector of 3 components.
+	/// @see core_precision
+	typedef vec<3, f32, lowp> lowp_f32vec3;
+
+	/// Low single-qualifier floating-point vector of 4 components.
+	/// @see core_precision
+	typedef vec<4, f32, lowp> lowp_f32vec4;
+
+	/// Medium single-qualifier floating-point vector of 1 component.
+	/// @see gtc_type_precision
+	typedef vec<1, f32, mediump> mediump_f32vec1;
+
+	/// Medium single-qualifier floating-point vector of 2 components.
+	/// @see core_precision
+	typedef vec<2, f32, mediump> mediump_f32vec2;
+
+	/// Medium single-qualifier floating-point vector of 3 components.
+	/// @see core_precision
+	typedef vec<3, f32, mediump> mediump_f32vec3;
+
+	/// Medium single-qualifier floating-point vector of 4 components.
+	/// @see core_precision
+	typedef vec<4, f32, mediump> mediump_f32vec4;
+
+	/// High single-qualifier floating-point vector of 1 component.
+	/// @see gtc_type_precision
+	typedef vec<1, f32, highp> highp_f32vec1;
+
+	/// High single-qualifier floating-point vector of 2 components.
+	/// @see gtc_type_precision
+	typedef vec<2, f32, highp> highp_f32vec2;
+
+	/// High single-qualifier floating-point vector of 3 components.
+	/// @see gtc_type_precision
+	typedef vec<3, f32, highp> highp_f32vec3;
+
+	/// High single-qualifier floating-point vector of 4 components.
+	/// @see gtc_type_precision
+	typedef vec<4, f32, highp> highp_f32vec4;
+
+
+	/// Low double-qualifier floating-point vector of 1 component.
+	/// @see gtc_type_precision
+	typedef vec<1, f64, lowp> lowp_f64vec1;
+
+	/// Low double-qualifier floating-point vector of 2 components.
+	/// @see gtc_type_precision
+	typedef vec<2, f64, lowp> lowp_f64vec2;
+
+	/// Low double-qualifier floating-point vector of 3 components.
+	/// @see gtc_type_precision
+	typedef vec<3, f64, lowp> lowp_f64vec3;
+
+	/// Low double-qualifier floating-point vector of 4 components.
+	/// @see gtc_type_precision
+	typedef vec<4, f64, lowp> lowp_f64vec4;
+
+	/// Medium double-qualifier floating-point vector of 1 component.
+	/// @see gtc_type_precision
+	typedef vec<1, f64, mediump> mediump_f64vec1;
+
+	/// Medium double-qualifier floating-point vector of 2 components.
+	/// @see gtc_type_precision
+	typedef vec<2, f64, mediump> mediump_f64vec2;
+
+	/// Medium double-qualifier floating-point vector of 3 components.
+	/// @see gtc_type_precision
+	typedef vec<3, f64, mediump> mediump_f64vec3;
+
+	/// Medium double-qualifier floating-point vector of 4 components.
+	/// @see gtc_type_precision
+	typedef vec<4, f64, mediump> mediump_f64vec4;
+
+	/// High double-qualifier floating-point vector of 1 component.
+	/// @see gtc_type_precision
+	typedef vec<1, f64, highp> highp_f64vec1;
+
+	/// High double-qualifier floating-point vector of 2 components.
+	/// @see gtc_type_precision
+	typedef vec<2, f64, highp> highp_f64vec2;
+
+	/// High double-qualifier floating-point vector of 3 components.
+	/// @see gtc_type_precision
+	typedef vec<3, f64, highp> highp_f64vec3;
+
+	/// High double-qualifier floating-point vector of 4 components.
+	/// @see gtc_type_precision
+	typedef vec<4, f64, highp> highp_f64vec4;
+
+
+
+	//////////////////////
+	// Float matrix types
+
+	/// Low single-qualifier floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef lowp_f32 lowp_fmat1x1;
+
+	/// Low single-qualifier floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 2, f32, lowp> lowp_fmat2x2;
+
+	/// Low single-qualifier floating-point 2x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 3, f32, lowp> lowp_fmat2x3;
+
+	/// Low single-qualifier floating-point 2x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 4, f32, lowp> lowp_fmat2x4;
+
+	/// Low single-qualifier floating-point 3x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 2, f32, lowp> lowp_fmat3x2;
+
+	/// Low single-qualifier floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 3, f32, lowp> lowp_fmat3x3;
+
+	/// Low single-qualifier floating-point 3x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 4, f32, lowp> lowp_fmat3x4;
+
+	/// Low single-qualifier floating-point 4x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 2, f32, lowp> lowp_fmat4x2;
+
+	/// Low single-qualifier floating-point 4x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 3, f32, lowp> lowp_fmat4x3;
+
+	/// Low single-qualifier floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 4, f32, lowp> lowp_fmat4x4;
+
+	/// Low single-qualifier floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef lowp_fmat1x1 lowp_fmat1;
+
+	/// Low single-qualifier floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef lowp_fmat2x2 lowp_fmat2;
+
+	/// Low single-qualifier floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef lowp_fmat3x3 lowp_fmat3;
+
+	/// Low single-qualifier floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef lowp_fmat4x4 lowp_fmat4;
+
+
+	/// Medium single-qualifier floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef mediump_f32 mediump_fmat1x1;
+
+	/// Medium single-qualifier floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 2, f32, mediump> mediump_fmat2x2;
+
+	/// Medium single-qualifier floating-point 2x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 3, f32, mediump> mediump_fmat2x3;
+
+	/// Medium single-qualifier floating-point 2x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 4, f32, mediump> mediump_fmat2x4;
+
+	/// Medium single-qualifier floating-point 3x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 2, f32, mediump> mediump_fmat3x2;
+
+	/// Medium single-qualifier floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 3, f32, mediump> mediump_fmat3x3;
+
+	/// Medium single-qualifier floating-point 3x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 4, f32, mediump> mediump_fmat3x4;
+
+	/// Medium single-qualifier floating-point 4x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 2, f32, mediump> mediump_fmat4x2;
+
+	/// Medium single-qualifier floating-point 4x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 3, f32, mediump> mediump_fmat4x3;
+
+	/// Medium single-qualifier floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 4, f32, mediump> mediump_fmat4x4;
+
+	/// Medium single-qualifier floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef mediump_fmat1x1 mediump_fmat1;
+
+	/// Medium single-qualifier floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef mediump_fmat2x2 mediump_fmat2;
+
+	/// Medium single-qualifier floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef mediump_fmat3x3 mediump_fmat3;
+
+	/// Medium single-qualifier floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef mediump_fmat4x4 mediump_fmat4;
+
+
+	/// High single-qualifier floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef highp_f32 highp_fmat1x1;
+
+	/// High single-qualifier floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 2, f32, highp> highp_fmat2x2;
+
+	/// High single-qualifier floating-point 2x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 3, f32, highp> highp_fmat2x3;
+
+	/// High single-qualifier floating-point 2x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 4, f32, highp> highp_fmat2x4;
+
+	/// High single-qualifier floating-point 3x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 2, f32, highp> highp_fmat3x2;
+
+	/// High single-qualifier floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 3, f32, highp> highp_fmat3x3;
+
+	/// High single-qualifier floating-point 3x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 4, f32, highp> highp_fmat3x4;
+
+	/// High single-qualifier floating-point 4x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 2, f32, highp> highp_fmat4x2;
+
+	/// High single-qualifier floating-point 4x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 3, f32, highp> highp_fmat4x3;
+
+	/// High single-qualifier floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 4, f32, highp> highp_fmat4x4;
+
+	/// High single-qualifier floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef highp_fmat1x1 highp_fmat1;
+
+	/// High single-qualifier floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef highp_fmat2x2 highp_fmat2;
+
+	/// High single-qualifier floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef highp_fmat3x3 highp_fmat3;
+
+	/// High single-qualifier floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef highp_fmat4x4 highp_fmat4;
+
+
+	/// Low single-qualifier floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef f32 lowp_f32mat1x1;
+
+	/// Low single-qualifier floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 2, f32, lowp> lowp_f32mat2x2;
+
+	/// Low single-qualifier floating-point 2x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 3, f32, lowp> lowp_f32mat2x3;
+
+	/// Low single-qualifier floating-point 2x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 4, f32, lowp> lowp_f32mat2x4;
+
+	/// Low single-qualifier floating-point 3x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 2, f32, lowp> lowp_f32mat3x2;
+
+	/// Low single-qualifier floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 3, f32, lowp> lowp_f32mat3x3;
+
+	/// Low single-qualifier floating-point 3x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 4, f32, lowp> lowp_f32mat3x4;
+
+	/// Low single-qualifier floating-point 4x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 2, f32, lowp> lowp_f32mat4x2;
+
+	/// Low single-qualifier floating-point 4x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 3, f32, lowp> lowp_f32mat4x3;
+
+	/// Low single-qualifier floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 4, f32, lowp> lowp_f32mat4x4;
+
+	/// Low single-qualifier floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef detail::tmat1x1<f32, lowp> lowp_f32mat1;
+
+	/// Low single-qualifier floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef lowp_f32mat2x2 lowp_f32mat2;
+
+	/// Low single-qualifier floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef lowp_f32mat3x3 lowp_f32mat3;
+
+	/// Low single-qualifier floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef lowp_f32mat4x4 lowp_f32mat4;
+
+
+	/// High single-qualifier floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef f32 mediump_f32mat1x1;
+
+	/// Low single-qualifier floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 2, f32, mediump> mediump_f32mat2x2;
+
+	/// Medium single-qualifier floating-point 2x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 3, f32, mediump> mediump_f32mat2x3;
+
+	/// Medium single-qualifier floating-point 2x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 4, f32, mediump> mediump_f32mat2x4;
+
+	/// Medium single-qualifier floating-point 3x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 2, f32, mediump> mediump_f32mat3x2;
+
+	/// Medium single-qualifier floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 3, f32, mediump> mediump_f32mat3x3;
+
+	/// Medium single-qualifier floating-point 3x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 4, f32, mediump> mediump_f32mat3x4;
+
+	/// Medium single-qualifier floating-point 4x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 2, f32, mediump> mediump_f32mat4x2;
+
+	/// Medium single-qualifier floating-point 4x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 3, f32, mediump> mediump_f32mat4x3;
+
+	/// Medium single-qualifier floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 4, f32, mediump> mediump_f32mat4x4;
+
+	/// Medium single-qualifier floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef detail::tmat1x1<f32, mediump> f32mat1;
+
+	/// Medium single-qualifier floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef mediump_f32mat2x2 mediump_f32mat2;
+
+	/// Medium single-qualifier floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef mediump_f32mat3x3 mediump_f32mat3;
+
+	/// Medium single-qualifier floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef mediump_f32mat4x4 mediump_f32mat4;
+
+
+	/// High single-qualifier floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef f32 highp_f32mat1x1;
+
+	/// High single-qualifier floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 2, f32, highp> highp_f32mat2x2;
+
+	/// High single-qualifier floating-point 2x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 3, f32, highp> highp_f32mat2x3;
+
+	/// High single-qualifier floating-point 2x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 4, f32, highp> highp_f32mat2x4;
+
+	/// High single-qualifier floating-point 3x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 2, f32, highp> highp_f32mat3x2;
+
+	/// High single-qualifier floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 3, f32, highp> highp_f32mat3x3;
+
+	/// High single-qualifier floating-point 3x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 4, f32, highp> highp_f32mat3x4;
+
+	/// High single-qualifier floating-point 4x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 2, f32, highp> highp_f32mat4x2;
+
+	/// High single-qualifier floating-point 4x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 3, f32, highp> highp_f32mat4x3;
+
+	/// High single-qualifier floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 4, f32, highp> highp_f32mat4x4;
+
+	/// High single-qualifier floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef detail::tmat1x1<f32, highp> f32mat1;
+
+	/// High single-qualifier floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f32mat2x2 highp_f32mat2;
+
+	/// High single-qualifier floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f32mat3x3 highp_f32mat3;
+
+	/// High single-qualifier floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f32mat4x4 highp_f32mat4;
+
+
+	/// Low double-qualifier floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef f64 lowp_f64mat1x1;
+
+	/// Low double-qualifier floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 2, f64, lowp> lowp_f64mat2x2;
+
+	/// Low double-qualifier floating-point 2x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 3, f64, lowp> lowp_f64mat2x3;
+
+	/// Low double-qualifier floating-point 2x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 4, f64, lowp> lowp_f64mat2x4;
+
+	/// Low double-qualifier floating-point 3x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 2, f64, lowp> lowp_f64mat3x2;
+
+	/// Low double-qualifier floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 3, f64, lowp> lowp_f64mat3x3;
+
+	/// Low double-qualifier floating-point 3x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 4, f64, lowp> lowp_f64mat3x4;
+
+	/// Low double-qualifier floating-point 4x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 2, f64, lowp> lowp_f64mat4x2;
+
+	/// Low double-qualifier floating-point 4x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 3, f64, lowp> lowp_f64mat4x3;
+
+	/// Low double-qualifier floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 4, f64, lowp> lowp_f64mat4x4;
+
+	/// Low double-qualifier floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef lowp_f64mat1x1 lowp_f64mat1;
+
+	/// Low double-qualifier floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef lowp_f64mat2x2 lowp_f64mat2;
+
+	/// Low double-qualifier floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef lowp_f64mat3x3 lowp_f64mat3;
+
+	/// Low double-qualifier floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef lowp_f64mat4x4 lowp_f64mat4;
+
+
+	/// Medium double-qualifier floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef f64 Highp_f64mat1x1;
+
+	/// Medium double-qualifier floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 2, f64, mediump> mediump_f64mat2x2;
+
+	/// Medium double-qualifier floating-point 2x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 3, f64, mediump> mediump_f64mat2x3;
+
+	/// Medium double-qualifier floating-point 2x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 4, f64, mediump> mediump_f64mat2x4;
+
+	/// Medium double-qualifier floating-point 3x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 2, f64, mediump> mediump_f64mat3x2;
+
+	/// Medium double-qualifier floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 3, f64, mediump> mediump_f64mat3x3;
+
+	/// Medium double-qualifier floating-point 3x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 4, f64, mediump> mediump_f64mat3x4;
+
+	/// Medium double-qualifier floating-point 4x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 2, f64, mediump> mediump_f64mat4x2;
+
+	/// Medium double-qualifier floating-point 4x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 3, f64, mediump> mediump_f64mat4x3;
+
+	/// Medium double-qualifier floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 4, f64, mediump> mediump_f64mat4x4;
+
+	/// Medium double-qualifier floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef mediump_f64mat1x1 mediump_f64mat1;
+
+	/// Medium double-qualifier floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef mediump_f64mat2x2 mediump_f64mat2;
+
+	/// Medium double-qualifier floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef mediump_f64mat3x3 mediump_f64mat3;
+
+	/// Medium double-qualifier floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef mediump_f64mat4x4 mediump_f64mat4;
+
+	/// High double-qualifier floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef f64 highp_f64mat1x1;
+
+	/// High double-qualifier floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 2, f64, highp> highp_f64mat2x2;
+
+	/// High double-qualifier floating-point 2x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 3, f64, highp> highp_f64mat2x3;
+
+	/// High double-qualifier floating-point 2x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 4, f64, highp> highp_f64mat2x4;
+
+	/// High double-qualifier floating-point 3x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 2, f64, highp> highp_f64mat3x2;
+
+	/// High double-qualifier floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 3, f64, highp> highp_f64mat3x3;
+
+	/// High double-qualifier floating-point 3x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 4, f64, highp> highp_f64mat3x4;
+
+	/// High double-qualifier floating-point 4x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 2, f64, highp> highp_f64mat4x2;
+
+	/// High double-qualifier floating-point 4x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 3, f64, highp> highp_f64mat4x3;
+
+	/// High double-qualifier floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 4, f64, highp> highp_f64mat4x4;
+
+	/// High double-qualifier floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef highp_f64mat1x1 highp_f64mat1;
+
+	/// High double-qualifier floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f64mat2x2 highp_f64mat2;
+
+	/// High double-qualifier floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f64mat3x3 highp_f64mat3;
+
+	/// High double-qualifier floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f64mat4x4 highp_f64mat4;
+
+
+
+
+	/// Low qualifier 8 bit unsigned integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, u8, lowp> lowp_u8vec1;
+
+	/// Low qualifier 8 bit unsigned integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, u8, lowp> lowp_u8vec2;
+
+	/// Low qualifier 8 bit unsigned integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, u8, lowp> lowp_u8vec3;
+
+	/// Low qualifier 8 bit unsigned integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, u8, lowp> lowp_u8vec4;
+
+
+	/// Medium qualifier 8 bit unsigned integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, u8, mediump> mediump_u8vec1;
+
+	/// Medium qualifier 8 bit unsigned integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, u8, mediump> mediump_u8vec2;
+
+	/// Medium qualifier 8 bit unsigned integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, u8, mediump> mediump_u8vec3;
+
+	/// Medium qualifier 8 bit unsigned integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, u8, mediump> mediump_u8vec4;
+
+
+	/// High qualifier 8 bit unsigned integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, u8, highp> highp_u8vec1;
+
+	/// High qualifier 8 bit unsigned integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, u8, highp> highp_u8vec2;
+
+	/// High qualifier 8 bit unsigned integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, u8, highp> highp_u8vec3;
+
+	/// High qualifier 8 bit unsigned integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, u8, highp> highp_u8vec4;
+
+
+
+	/// Default qualifier 8 bit unsigned integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, u8, defaultp> u8vec1;
+
+	/// Default qualifier 8 bit unsigned integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, u8, defaultp> u8vec2;
+
+	/// Default qualifier 8 bit unsigned integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, u8, defaultp> u8vec3;
+
+	/// Default qualifier 8 bit unsigned integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, u8, defaultp> u8vec4;
+
+
+
+
+	/// Low qualifier 16 bit unsigned integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, u16, lowp>		lowp_u16vec1;
+
+	/// Low qualifier 16 bit unsigned integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, u16, lowp>		lowp_u16vec2;
+
+	/// Low qualifier 16 bit unsigned integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, u16, lowp>		lowp_u16vec3;
+
+	/// Low qualifier 16 bit unsigned integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, u16, lowp>		lowp_u16vec4;
+
+
+	/// Medium qualifier 16 bit unsigned integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, u16, mediump>		mediump_u16vec1;
+
+	/// Medium qualifier 16 bit unsigned integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, u16, mediump>		mediump_u16vec2;
+
+	/// Medium qualifier 16 bit unsigned integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, u16, mediump>		mediump_u16vec3;
+
+	/// Medium qualifier 16 bit unsigned integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, u16, mediump>		mediump_u16vec4;
+
+
+	/// High qualifier 16 bit unsigned integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, u16, highp>		highp_u16vec1;
+
+	/// High qualifier 16 bit unsigned integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, u16, highp>		highp_u16vec2;
+
+	/// High qualifier 16 bit unsigned integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, u16, highp>		highp_u16vec3;
+
+	/// High qualifier 16 bit unsigned integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, u16, highp>		highp_u16vec4;
+
+
+
+
+	/// Default qualifier 16 bit unsigned integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, u16, defaultp> u16vec1;
+
+	/// Default qualifier 16 bit unsigned integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, u16, defaultp> u16vec2;
+
+	/// Default qualifier 16 bit unsigned integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, u16, defaultp> u16vec3;
+
+	/// Default qualifier 16 bit unsigned integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, u16, defaultp> u16vec4;
+
+
+
+	/// Low qualifier 32 bit unsigned integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, u32, lowp>		lowp_u32vec1;
+
+	/// Low qualifier 32 bit unsigned integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, u32, lowp>		lowp_u32vec2;
+
+	/// Low qualifier 32 bit unsigned integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, u32, lowp>		lowp_u32vec3;
+
+	/// Low qualifier 32 bit unsigned integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, u32, lowp>		lowp_u32vec4;
+
+
+	/// Medium qualifier 32 bit unsigned integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, u32, mediump>		mediump_u32vec1;
+
+	/// Medium qualifier 32 bit unsigned integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, u32, mediump>		mediump_u32vec2;
+
+	/// Medium qualifier 32 bit unsigned integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, u32, mediump>		mediump_u32vec3;
+
+	/// Medium qualifier 32 bit unsigned integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, u32, mediump>		mediump_u32vec4;
+
+
+	/// High qualifier 32 bit unsigned integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, u32, highp>		highp_u32vec1;
+
+	/// High qualifier 32 bit unsigned integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, u32, highp>		highp_u32vec2;
+
+	/// High qualifier 32 bit unsigned integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, u32, highp>		highp_u32vec3;
+
+	/// High qualifier 32 bit unsigned integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, u32, highp>		highp_u32vec4;
+
+
+
+	/// Default qualifier 32 bit unsigned integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, u32, defaultp> u32vec1;
+
+	/// Default qualifier 32 bit unsigned integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, u32, defaultp> u32vec2;
+
+	/// Default qualifier 32 bit unsigned integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, u32, defaultp> u32vec3;
+
+	/// Default qualifier 32 bit unsigned integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, u32, defaultp> u32vec4;
+
+
+
+
+	/// Low qualifier 64 bit unsigned integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, u64, lowp>		lowp_u64vec1;
+
+	/// Low qualifier 64 bit unsigned integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, u64, lowp>		lowp_u64vec2;
+
+	/// Low qualifier 64 bit unsigned integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, u64, lowp>		lowp_u64vec3;
+
+	/// Low qualifier 64 bit unsigned integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, u64, lowp>		lowp_u64vec4;
+
+
+	/// Medium qualifier 64 bit unsigned integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, u64, mediump>		mediump_u64vec1;
+
+	/// Medium qualifier 64 bit unsigned integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, u64, mediump>		mediump_u64vec2;
+
+	/// Medium qualifier 64 bit unsigned integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, u64, mediump>		mediump_u64vec3;
+
+	/// Medium qualifier 64 bit unsigned integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, u64, mediump>		mediump_u64vec4;
+
+
+	/// High qualifier 64 bit unsigned integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, u64, highp>		highp_u64vec1;
+
+	/// High qualifier 64 bit unsigned integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, u64, highp>		highp_u64vec2;
+
+	/// High qualifier 64 bit unsigned integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, u64, highp>		highp_u64vec3;
+
+	/// High qualifier 64 bit unsigned integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, u64, highp>		highp_u64vec4;
+
+
+
+
+	/// Default qualifier 64 bit unsigned integer scalar type.
+	/// @see gtc_type_precision
+	typedef vec<1, u64, defaultp> u64vec1;
+
+	/// Default qualifier 64 bit unsigned integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef vec<2, u64, defaultp> u64vec2;
+
+	/// Default qualifier 64 bit unsigned integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef vec<3, u64, defaultp> u64vec3;
+
+	/// Default qualifier 64 bit unsigned integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef vec<4, u64, defaultp> u64vec4;
+
+
+	//////////////////////
+	// Float vector types
+
+	/// 32 bit single-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float32 float32_t;
+
+	/// 32 bit single-qualifier floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float32 f32;
+
+#	ifndef GLM_FORCE_SINGLE_ONLY
+
+		/// 64 bit double-qualifier floating-point scalar.
+		/// @see gtc_type_precision
+		typedef float64 float64_t;
+
+		/// 64 bit double-qualifier floating-point scalar.
+		/// @see gtc_type_precision
+		typedef float64 f64;
+#	endif//GLM_FORCE_SINGLE_ONLY
+
+	/// Single-qualifier floating-point vector of 1 component.
+	/// @see gtc_type_precision
+	typedef vec<1, float, defaultp> fvec1;
+
+	/// Single-qualifier floating-point vector of 2 components.
+	/// @see gtc_type_precision
+	typedef vec<2, float, defaultp> fvec2;
+
+	/// Single-qualifier floating-point vector of 3 components.
+	/// @see gtc_type_precision
+	typedef vec<3, float, defaultp> fvec3;
+
+	/// Single-qualifier floating-point vector of 4 components.
+	/// @see gtc_type_precision
+	typedef vec<4, float, defaultp> fvec4;
+
+
+	/// Single-qualifier floating-point vector of 1 component.
+	/// @see gtc_type_precision
+	typedef vec<1, f32, defaultp> f32vec1;
+
+	/// Single-qualifier floating-point vector of 2 components.
+	/// @see gtc_type_precision
+	typedef vec<2, f32, defaultp> f32vec2;
+
+	/// Single-qualifier floating-point vector of 3 components.
+	/// @see gtc_type_precision
+	typedef vec<3, f32, defaultp> f32vec3;
+
+	/// Single-qualifier floating-point vector of 4 components.
+	/// @see gtc_type_precision
+	typedef vec<4, f32, defaultp> f32vec4;
+
+#	ifndef GLM_FORCE_SINGLE_ONLY
+		/// Double-qualifier floating-point vector of 1 component.
+		/// @see gtc_type_precision
+		typedef vec<1, f64, defaultp> f64vec1;
+
+		/// Double-qualifier floating-point vector of 2 components.
+		/// @see gtc_type_precision
+		typedef vec<2, f64, defaultp> f64vec2;
+
+		/// Double-qualifier floating-point vector of 3 components.
+		/// @see gtc_type_precision
+		typedef vec<3, f64, defaultp> f64vec3;
+
+		/// Double-qualifier floating-point vector of 4 components.
+		/// @see gtc_type_precision
+		typedef vec<4, f64, defaultp> f64vec4;
+#	endif//GLM_FORCE_SINGLE_ONLY
+
+
+	//////////////////////
+	// Float matrix types
+
+	/// Single-qualifier floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef detail::tmat1x1<f32> fmat1;
+
+	/// Single-qualifier floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 2, f32, defaultp> fmat2;
+
+	/// Single-qualifier floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 3, f32, defaultp> fmat3;
+
+	/// Single-qualifier floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 4, f32, defaultp> fmat4;
+
+
+	/// Single-qualifier floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef f32 fmat1x1;
+
+	/// Single-qualifier floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 2, f32, defaultp> fmat2x2;
+
+	/// Single-qualifier floating-point 2x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 3, f32, defaultp> fmat2x3;
+
+	/// Single-qualifier floating-point 2x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 4, f32, defaultp> fmat2x4;
+
+	/// Single-qualifier floating-point 3x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 2, f32, defaultp> fmat3x2;
+
+	/// Single-qualifier floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 3, f32, defaultp> fmat3x3;
+
+	/// Single-qualifier floating-point 3x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 4, f32, defaultp> fmat3x4;
+
+	/// Single-qualifier floating-point 4x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 2, f32, defaultp> fmat4x2;
+
+	/// Single-qualifier floating-point 4x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 3, f32, defaultp> fmat4x3;
+
+	/// Single-qualifier floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 4, f32, defaultp> fmat4x4;
+
+
+	/// Single-qualifier floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef detail::tmat1x1<f32, defaultp> f32mat1;
+
+	/// Single-qualifier floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 2, f32, defaultp> f32mat2;
+
+	/// Single-qualifier floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 3, f32, defaultp> f32mat3;
+
+	/// Single-qualifier floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 4, f32, defaultp> f32mat4;
+
+
+	/// Single-qualifier floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef f32 f32mat1x1;
+
+	/// Single-qualifier floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 2, f32, defaultp> f32mat2x2;
+
+	/// Single-qualifier floating-point 2x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 3, f32, defaultp> f32mat2x3;
+
+	/// Single-qualifier floating-point 2x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 4, f32, defaultp> f32mat2x4;
+
+	/// Single-qualifier floating-point 3x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 2, f32, defaultp> f32mat3x2;
+
+	/// Single-qualifier floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 3, f32, defaultp> f32mat3x3;
+
+	/// Single-qualifier floating-point 3x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 4, f32, defaultp> f32mat3x4;
+
+	/// Single-qualifier floating-point 4x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 2, f32, defaultp> f32mat4x2;
+
+	/// Single-qualifier floating-point 4x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 3, f32, defaultp> f32mat4x3;
+
+	/// Single-qualifier floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 4, f32, defaultp> f32mat4x4;
+
+
+#	ifndef GLM_FORCE_SINGLE_ONLY
+
+	/// Double-qualifier floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef detail::tmat1x1<f64, defaultp> f64mat1;
+
+	/// Double-qualifier floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 2, f64, defaultp> f64mat2;
+
+	/// Double-qualifier floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 3, f64, defaultp> f64mat3;
+
+	/// Double-qualifier floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 4, f64, defaultp> f64mat4;
+
+
+	/// Double-qualifier floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef f64 f64mat1x1;
+
+	/// Double-qualifier floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 2, f64, defaultp> f64mat2x2;
+
+	/// Double-qualifier floating-point 2x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 3, f64, defaultp> f64mat2x3;
+
+	/// Double-qualifier floating-point 2x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<2, 4, f64, defaultp> f64mat2x4;
+
+	/// Double-qualifier floating-point 3x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 2, f64, defaultp> f64mat3x2;
+
+	/// Double-qualifier floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 3, f64, defaultp> f64mat3x3;
+
+	/// Double-qualifier floating-point 3x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<3, 4, f64, defaultp> f64mat3x4;
+
+	/// Double-qualifier floating-point 4x2 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 2, f64, defaultp> f64mat4x2;
+
+	/// Double-qualifier floating-point 4x3 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 3, f64, defaultp> f64mat4x3;
+
+	/// Double-qualifier floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef mat<4, 4, f64, defaultp> f64mat4x4;
+
+#	endif//GLM_FORCE_SINGLE_ONLY
+
+	//////////////////////////
+	// Quaternion types
+
+	/// Single-qualifier floating-point quaternion.
+	/// @see gtc_type_precision
+	typedef qua<f32, defaultp> f32quat;
+
+	/// Low single-qualifier floating-point quaternion.
+	/// @see gtc_type_precision
+	typedef qua<f32, lowp> lowp_f32quat;
+
+	/// Low double-qualifier floating-point quaternion.
+	/// @see gtc_type_precision
+	typedef qua<f64, lowp> lowp_f64quat;
+
+	/// Medium single-qualifier floating-point quaternion.
+	/// @see gtc_type_precision
+	typedef qua<f32, mediump> mediump_f32quat;
+
+#	ifndef GLM_FORCE_SINGLE_ONLY
+
+	/// Medium double-qualifier floating-point quaternion.
+	/// @see gtc_type_precision
+	typedef qua<f64, mediump> mediump_f64quat;
+
+	/// High single-qualifier floating-point quaternion.
+	/// @see gtc_type_precision
+	typedef qua<f32, highp> highp_f32quat;
+
+	/// High double-qualifier floating-point quaternion.
+	/// @see gtc_type_precision
+	typedef qua<f64, highp> highp_f64quat;
+
+	/// Double-qualifier floating-point quaternion.
+	/// @see gtc_type_precision
+	typedef qua<f64, defaultp> f64quat;
+
+#	endif//GLM_FORCE_SINGLE_ONLY
+
+	/// @}
+}//namespace glm
+
+#include "type_precision.inl"
diff --git a/engine/inc/glm/gtc/type_precision.inl b/engine/inc/glm/gtc/type_precision.inl
new file mode 100644
index 00000000..ae809120
--- /dev/null
+++ b/engine/inc/glm/gtc/type_precision.inl
@@ -0,0 +1,6 @@
+/// @ref gtc_precision
+
+namespace glm
+{
+
+}
diff --git a/engine/inc/glm/gtc/type_ptr.hpp b/engine/inc/glm/gtc/type_ptr.hpp
new file mode 100644
index 00000000..d7e625aa
--- /dev/null
+++ b/engine/inc/glm/gtc/type_ptr.hpp
@@ -0,0 +1,230 @@
+/// @ref gtc_type_ptr
+/// @file glm/gtc/type_ptr.hpp
+///
+/// @see core (dependence)
+/// @see gtc_quaternion (dependence)
+///
+/// @defgroup gtc_type_ptr GLM_GTC_type_ptr
+/// @ingroup gtc
+///
+/// Include <glm/gtc/type_ptr.hpp> to use the features of this extension.
+///
+/// Handles the interaction between pointers and vector, matrix types.
+///
+/// This extension defines an overloaded function, glm::value_ptr. It returns
+/// a pointer to the memory layout of the object. Matrix types store their values
+/// in column-major order.
+///
+/// This is useful for uploading data to matrices or copying data to buffer objects.
+///
+/// Example:
+/// @code
+/// #include <glm/glm.hpp>
+/// #include <glm/gtc/type_ptr.hpp>
+///
+/// glm::vec3 aVector(3);
+/// glm::mat4 someMatrix(1.0);
+///
+/// glUniform3fv(uniformLoc, 1, glm::value_ptr(aVector));
+/// glUniformMatrix4fv(uniformMatrixLoc, 1, GL_FALSE, glm::value_ptr(someMatrix));
+/// @endcode
+///
+/// <glm/gtc/type_ptr.hpp> need to be included to use the features of this extension.
+
+#pragma once
+
+// Dependency:
+#include "../gtc/quaternion.hpp"
+#include "../gtc/vec1.hpp"
+#include "../vec2.hpp"
+#include "../vec3.hpp"
+#include "../vec4.hpp"
+#include "../mat2x2.hpp"
+#include "../mat2x3.hpp"
+#include "../mat2x4.hpp"
+#include "../mat3x2.hpp"
+#include "../mat3x3.hpp"
+#include "../mat3x4.hpp"
+#include "../mat4x2.hpp"
+#include "../mat4x3.hpp"
+#include "../mat4x4.hpp"
+#include <cstring>
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTC_type_ptr extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtc_type_ptr
+	/// @{
+
+	/// Return the constant address to the data of the input parameter.
+	/// @see gtc_type_ptr
+	template<typename genType>
+	GLM_FUNC_DECL typename genType::value_type const * value_ptr(genType const& v);
+
+	/// Build a vector from a pointer.
+	/// @see gtc_type_ptr
+	template <typename T, qualifier Q>
+	GLM_FUNC_DECL vec<1, T, Q> make_vec1(vec<1, T, Q> const& v);
+
+	/// Build a vector from a pointer.
+	/// @see gtc_type_ptr
+	template <typename T, qualifier Q>
+	GLM_FUNC_DECL vec<1, T, Q> make_vec1(vec<2, T, Q> const& v);
+
+	/// Build a vector from a pointer.
+	/// @see gtc_type_ptr
+	template <typename T, qualifier Q>
+	GLM_FUNC_DECL vec<1, T, Q> make_vec1(vec<3, T, Q> const& v);
+
+	/// Build a vector from a pointer.
+	/// @see gtc_type_ptr
+	template <typename T, qualifier Q>
+	GLM_FUNC_DECL vec<1, T, Q> make_vec1(vec<4, T, Q> const& v);
+
+	/// Build a vector from a pointer.
+	/// @see gtc_type_ptr
+	template <typename T, qualifier Q>
+	GLM_FUNC_DECL vec<2, T, Q> make_vec2(vec<1, T, Q> const& v);
+
+	/// Build a vector from a pointer.
+	/// @see gtc_type_ptr
+	template <typename T, qualifier Q>
+	GLM_FUNC_DECL vec<2, T, Q> make_vec2(vec<2, T, Q> const& v);
+
+	/// Build a vector from a pointer.
+	/// @see gtc_type_ptr
+	template <typename T, qualifier Q>
+	GLM_FUNC_DECL vec<2, T, Q> make_vec2(vec<3, T, Q> const& v);
+
+	/// Build a vector from a pointer.
+	/// @see gtc_type_ptr
+	template <typename T, qualifier Q>
+	GLM_FUNC_DECL vec<2, T, Q> make_vec2(vec<4, T, Q> const& v);
+
+	/// Build a vector from a pointer.
+	/// @see gtc_type_ptr
+	template <typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> make_vec3(vec<1, T, Q> const& v);
+
+	/// Build a vector from a pointer.
+	/// @see gtc_type_ptr
+	template <typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> make_vec3(vec<2, T, Q> const& v);
+
+	/// Build a vector from a pointer.
+	/// @see gtc_type_ptr
+	template <typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> make_vec3(vec<3, T, Q> const& v);
+
+	/// Build a vector from a pointer.
+	/// @see gtc_type_ptr
+	template <typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> make_vec3(vec<4, T, Q> const& v);
+
+	/// Build a vector from a pointer.
+	/// @see gtc_type_ptr
+	template <typename T, qualifier Q>
+	GLM_FUNC_DECL vec<4, T, Q> make_vec4(vec<1, T, Q> const& v);
+
+	/// Build a vector from a pointer.
+	/// @see gtc_type_ptr
+	template <typename T, qualifier Q>
+	GLM_FUNC_DECL vec<4, T, Q> make_vec4(vec<2, T, Q> const& v);
+
+	/// Build a vector from a pointer.
+	/// @see gtc_type_ptr
+	template <typename T, qualifier Q>
+	GLM_FUNC_DECL vec<4, T, Q> make_vec4(vec<3, T, Q> const& v);
+
+	/// Build a vector from a pointer.
+	/// @see gtc_type_ptr
+	template <typename T, qualifier Q>
+	GLM_FUNC_DECL vec<4, T, Q> make_vec4(vec<4, T, Q> const& v);
+
+	/// Build a vector from a pointer.
+	/// @see gtc_type_ptr
+	template<typename T>
+	GLM_FUNC_DECL vec<2, T, defaultp> make_vec2(T const * const ptr);
+
+	/// Build a vector from a pointer.
+	/// @see gtc_type_ptr
+	template<typename T>
+	GLM_FUNC_DECL vec<3, T, defaultp> make_vec3(T const * const ptr);
+
+	/// Build a vector from a pointer.
+	/// @see gtc_type_ptr
+	template<typename T>
+	GLM_FUNC_DECL vec<4, T, defaultp> make_vec4(T const * const ptr);
+
+	/// Build a matrix from a pointer.
+	/// @see gtc_type_ptr
+	template<typename T>
+	GLM_FUNC_DECL mat<2, 2, T, defaultp> make_mat2x2(T const * const ptr);
+
+	/// Build a matrix from a pointer.
+	/// @see gtc_type_ptr
+	template<typename T>
+	GLM_FUNC_DECL mat<2, 3, T, defaultp> make_mat2x3(T const * const ptr);
+
+	/// Build a matrix from a pointer.
+	/// @see gtc_type_ptr
+	template<typename T>
+	GLM_FUNC_DECL mat<2, 4, T, defaultp> make_mat2x4(T const * const ptr);
+
+	/// Build a matrix from a pointer.
+	/// @see gtc_type_ptr
+	template<typename T>
+	GLM_FUNC_DECL mat<3, 2, T, defaultp> make_mat3x2(T const * const ptr);
+
+	/// Build a matrix from a pointer.
+	/// @see gtc_type_ptr
+	template<typename T>
+	GLM_FUNC_DECL mat<3, 3, T, defaultp> make_mat3x3(T const * const ptr);
+
+	/// Build a matrix from a pointer.
+	/// @see gtc_type_ptr
+	template<typename T>
+	GLM_FUNC_DECL mat<3, 4, T, defaultp> make_mat3x4(T const * const ptr);
+
+	/// Build a matrix from a pointer.
+	/// @see gtc_type_ptr
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 2, T, defaultp> make_mat4x2(T const * const ptr);
+
+	/// Build a matrix from a pointer.
+	/// @see gtc_type_ptr
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 3, T, defaultp> make_mat4x3(T const * const ptr);
+
+	/// Build a matrix from a pointer.
+	/// @see gtc_type_ptr
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> make_mat4x4(T const * const ptr);
+
+	/// Build a matrix from a pointer.
+	/// @see gtc_type_ptr
+	template<typename T>
+	GLM_FUNC_DECL mat<2, 2, T, defaultp> make_mat2(T const * const ptr);
+
+	/// Build a matrix from a pointer.
+	/// @see gtc_type_ptr
+	template<typename T>
+	GLM_FUNC_DECL mat<3, 3, T, defaultp> make_mat3(T const * const ptr);
+
+	/// Build a matrix from a pointer.
+	/// @see gtc_type_ptr
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> make_mat4(T const * const ptr);
+
+	/// Build a quaternion from a pointer.
+	/// @see gtc_type_ptr
+	template<typename T>
+	GLM_FUNC_DECL qua<T, defaultp> make_quat(T const * const ptr);
+
+	/// @}
+}//namespace glm
+
+#include "type_ptr.inl"
diff --git a/engine/inc/glm/gtc/type_ptr.inl b/engine/inc/glm/gtc/type_ptr.inl
new file mode 100644
index 00000000..71df4d30
--- /dev/null
+++ b/engine/inc/glm/gtc/type_ptr.inl
@@ -0,0 +1,386 @@
+/// @ref gtc_type_ptr
+
+#include <cstring>
+
+namespace glm
+{
+	/// @addtogroup gtc_type_ptr
+	/// @{
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T const* value_ptr(vec<2, T, Q> const& v)
+	{
+		return &(v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T* value_ptr(vec<2, T, Q>& v)
+	{
+		return &(v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T const * value_ptr(vec<3, T, Q> const& v)
+	{
+		return &(v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T* value_ptr(vec<3, T, Q>& v)
+	{
+		return &(v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T const* value_ptr(vec<4, T, Q> const& v)
+	{
+		return &(v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T* value_ptr(vec<4, T, Q>& v)
+	{
+		return &(v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T const* value_ptr(mat<2, 2, T, Q> const& m)
+	{
+		return &(m[0].x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T* value_ptr(mat<2, 2, T, Q>& m)
+	{
+		return &(m[0].x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T const* value_ptr(mat<3, 3, T, Q> const& m)
+	{
+		return &(m[0].x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T* value_ptr(mat<3, 3, T, Q>& m)
+	{
+		return &(m[0].x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T const* value_ptr(mat<4, 4, T, Q> const& m)
+	{
+		return &(m[0].x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T* value_ptr(mat<4, 4, T, Q>& m)
+	{
+		return &(m[0].x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T const* value_ptr(mat<2, 3, T, Q> const& m)
+	{
+		return &(m[0].x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T* value_ptr(mat<2, 3, T, Q>& m)
+	{
+		return &(m[0].x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T const* value_ptr(mat<3, 2, T, Q> const& m)
+	{
+		return &(m[0].x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T* value_ptr(mat<3, 2, T, Q>& m)
+	{
+		return &(m[0].x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T const* value_ptr(mat<2, 4, T, Q> const& m)
+	{
+		return &(m[0].x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T* value_ptr(mat<2, 4, T, Q>& m)
+	{
+		return &(m[0].x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T const* value_ptr(mat<4, 2, T, Q> const& m)
+	{
+		return &(m[0].x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T* value_ptr(mat<4, 2, T, Q>& m)
+	{
+		return &(m[0].x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T const* value_ptr(mat<3, 4, T, Q> const& m)
+	{
+		return &(m[0].x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T* value_ptr(mat<3, 4, T, Q>& m)
+	{
+		return &(m[0].x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T const* value_ptr(mat<4, 3, T, Q> const& m)
+	{
+		return &(m[0].x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T * value_ptr(mat<4, 3, T, Q>& m)
+	{
+		return &(m[0].x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T const * value_ptr(qua<T, Q> const& q)
+	{
+		return &(q[0]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T* value_ptr(qua<T, Q>& q)
+	{
+		return &(q[0]);
+	}
+
+	template <typename T, qualifier Q>
+	inline vec<1, T, Q> make_vec1(vec<1, T, Q> const& v)
+	{
+		return v;
+	}
+
+	template <typename T, qualifier Q>
+	inline vec<1, T, Q> make_vec1(vec<2, T, Q> const& v)
+	{
+		return vec<1, T, Q>(v);
+	}
+
+	template <typename T, qualifier Q>
+	inline vec<1, T, Q> make_vec1(vec<3, T, Q> const& v)
+	{
+		return vec<1, T, Q>(v);
+	}
+
+	template <typename T, qualifier Q>
+	inline vec<1, T, Q> make_vec1(vec<4, T, Q> const& v)
+	{
+		return vec<1, T, Q>(v);
+	}
+
+	template <typename T, qualifier Q>
+	inline vec<2, T, Q> make_vec2(vec<1, T, Q> const& v)
+	{
+		return vec<2, T, Q>(v.x, static_cast<T>(0));
+	}
+
+	template <typename T, qualifier Q>
+	inline vec<2, T, Q> make_vec2(vec<2, T, Q> const& v)
+	{
+		return v;
+	}
+
+	template <typename T, qualifier Q>
+	inline vec<2, T, Q> make_vec2(vec<3, T, Q> const& v)
+	{
+		return vec<2, T, Q>(v);
+	}
+
+	template <typename T, qualifier Q>
+	inline vec<2, T, Q> make_vec2(vec<4, T, Q> const& v)
+	{
+		return vec<2, T, Q>(v);
+	}
+
+	template <typename T, qualifier Q>
+	inline vec<3, T, Q> make_vec3(vec<1, T, Q> const& v)
+	{
+		return vec<3, T, Q>(v.x, static_cast<T>(0), static_cast<T>(0));
+	}
+
+	template <typename T, qualifier Q>
+	inline vec<3, T, Q> make_vec3(vec<2, T, Q> const& v)
+	{
+		return vec<3, T, Q>(v.x, v.y, static_cast<T>(0));
+	}
+
+	template <typename T, qualifier Q>
+	inline vec<3, T, Q> make_vec3(vec<3, T, Q> const& v)
+	{
+		return v;
+	}
+
+	template <typename T, qualifier Q>
+	inline vec<3, T, Q> make_vec3(vec<4, T, Q> const& v)
+	{
+		return vec<3, T, Q>(v);
+	}
+
+	template <typename T, qualifier Q>
+	inline vec<4, T, Q> make_vec4(vec<1, T, Q> const& v)
+	{
+		return vec<4, T, Q>(v.x, static_cast<T>(0), static_cast<T>(0), static_cast<T>(1));
+	}
+
+	template <typename T, qualifier Q>
+	inline vec<4, T, Q> make_vec4(vec<2, T, Q> const& v)
+	{
+		return vec<4, T, Q>(v.x, v.y, static_cast<T>(0), static_cast<T>(1));
+	}
+
+	template <typename T, qualifier Q>
+	inline vec<4, T, Q> make_vec4(vec<3, T, Q> const& v)
+	{
+		return vec<4, T, Q>(v.x, v.y, v.z, static_cast<T>(1));
+	}
+
+	template <typename T, qualifier Q>
+	inline vec<4, T, Q> make_vec4(vec<4, T, Q> const& v)
+	{
+		return v;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER vec<2, T, defaultp> make_vec2(T const *const ptr)
+	{
+		vec<2, T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(vec<2, T, defaultp>));
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER vec<3, T, defaultp> make_vec3(T const *const ptr)
+	{
+		vec<3, T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(vec<3, T, defaultp>));
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER vec<4, T, defaultp> make_vec4(T const *const ptr)
+	{
+		vec<4, T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(vec<4, T, defaultp>));
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, defaultp> make_mat2x2(T const *const ptr)
+	{
+		mat<2, 2, T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(mat<2, 2, T, defaultp>));
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, defaultp> make_mat2x3(T const *const ptr)
+	{
+		mat<2, 3, T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(mat<2, 3, T, defaultp>));
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, defaultp> make_mat2x4(T const *const ptr)
+	{
+		mat<2, 4, T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(mat<2, 4, T, defaultp>));
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, defaultp> make_mat3x2(T const *const ptr)
+	{
+		mat<3, 2, T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(mat<3, 2, T, defaultp>));
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, defaultp> make_mat3x3(T const *const ptr)
+	{
+		mat<3, 3, T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(mat<3, 3, T, defaultp>));
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, defaultp> make_mat3x4(T const *const ptr)
+	{
+		mat<3, 4, T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(mat<3, 4, T, defaultp>));
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, defaultp> make_mat4x2(T const *const ptr)
+	{
+		mat<4, 2, T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(mat<4, 2, T, defaultp>));
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, defaultp> make_mat4x3(T const *const ptr)
+	{
+		mat<4, 3, T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(mat<4, 3, T, defaultp>));
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> make_mat4x4(T const *const ptr)
+	{
+		mat<4, 4, T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(mat<4, 4, T, defaultp>));
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, defaultp> make_mat2(T const *const ptr)
+	{
+		return make_mat2x2(ptr);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, defaultp> make_mat3(T const *const ptr)
+	{
+		return make_mat3x3(ptr);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> make_mat4(T const *const ptr)
+	{
+		return make_mat4x4(ptr);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER qua<T, defaultp> make_quat(T const *const ptr)
+	{
+		qua<T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(qua<T, defaultp>));
+		return Result;
+	}
+
+	/// @}
+}//namespace glm
+
diff --git a/engine/inc/glm/gtc/ulp.hpp b/engine/inc/glm/gtc/ulp.hpp
new file mode 100644
index 00000000..01f4f11e
--- /dev/null
+++ b/engine/inc/glm/gtc/ulp.hpp
@@ -0,0 +1,24 @@
+/// @ref gtc_ulp
+/// @file glm/gtc/ulp.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtc_ulp GLM_GTC_ulp
+/// @ingroup gtc
+///
+/// Include <glm/gtc/ulp.hpp> to use the features of this extension.
+///
+/// Allow the measurement of the accuracy of a function against a reference
+/// implementation. This extension works on floating-point data and provide results
+/// in ULP.
+
+#pragma once
+
+// Dependencies
+#include "../ext/scalar_ulp.hpp"
+#include "../ext/vector_ulp.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTC_ulp extension included")
+#endif
+
diff --git a/engine/inc/glm/gtc/ulp.inl b/engine/inc/glm/gtc/ulp.inl
new file mode 100644
index 00000000..53f4950a
--- /dev/null
+++ b/engine/inc/glm/gtc/ulp.inl
@@ -0,0 +1,3 @@
+/// @ref gtc_ulp
+///
+
diff --git a/engine/inc/glm/gtc/vec1.hpp b/engine/inc/glm/gtc/vec1.hpp
new file mode 100644
index 00000000..c20be874
--- /dev/null
+++ b/engine/inc/glm/gtc/vec1.hpp
@@ -0,0 +1,30 @@
+/// @ref gtc_vec1
+/// @file glm/gtc/vec1.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtc_vec1 GLM_GTC_vec1
+/// @ingroup gtc
+///
+/// Include <glm/gtc/vec1.hpp> to use the features of this extension.
+///
+/// Add vec1, ivec1, uvec1 and bvec1 types.
+
+#pragma once
+
+// Dependency:
+#include "../ext/vector_bool1.hpp"
+#include "../ext/vector_bool1_precision.hpp"
+#include "../ext/vector_float1.hpp"
+#include "../ext/vector_float1_precision.hpp"
+#include "../ext/vector_double1.hpp"
+#include "../ext/vector_double1_precision.hpp"
+#include "../ext/vector_int1.hpp"
+#include "../ext/vector_int1_precision.hpp"
+#include "../ext/vector_uint1.hpp"
+#include "../ext/vector_uint1_precision.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTC_vec1 extension included")
+#endif
+
diff --git a/engine/inc/glm/gtx/associated_min_max.hpp b/engine/inc/glm/gtx/associated_min_max.hpp
new file mode 100644
index 00000000..1042c13e
--- /dev/null
+++ b/engine/inc/glm/gtx/associated_min_max.hpp
@@ -0,0 +1,207 @@
+/// @ref gtx_associated_min_max
+/// @file glm/gtx/associated_min_max.hpp
+///
+/// @see core (dependence)
+/// @see gtx_extented_min_max (dependence)
+///
+/// @defgroup gtx_associated_min_max GLM_GTX_associated_min_max
+/// @ingroup gtx
+///
+/// Include <glm/gtx/associated_min_max.hpp> to use the features of this extension.
+///
+/// @brief Min and max functions that return associated values not the compared onces.
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GTX_associated_min_max is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_associated_min_max extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_associated_min_max
+	/// @{
+
+	/// Minimum comparison between 2 variables and returns 2 associated variable values
+	/// @see gtx_associated_min_max
+	template<typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL U associatedMin(T x, U a, T y, U b);
+
+	/// Minimum comparison between 2 variables and returns 2 associated variable values
+	/// @see gtx_associated_min_max
+	template<length_t L, typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL vec<2, U, Q> associatedMin(
+		vec<L, T, Q> const& x, vec<L, U, Q> const& a,
+		vec<L, T, Q> const& y, vec<L, U, Q> const& b);
+
+	/// Minimum comparison between 2 variables and returns 2 associated variable values
+	/// @see gtx_associated_min_max
+	template<length_t L, typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL vec<L, U, Q> associatedMin(
+		T x, const vec<L, U, Q>& a,
+		T y, const vec<L, U, Q>& b);
+
+	/// Minimum comparison between 2 variables and returns 2 associated variable values
+	/// @see gtx_associated_min_max
+	template<length_t L, typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL vec<L, U, Q> associatedMin(
+		vec<L, T, Q> const& x, U a,
+		vec<L, T, Q> const& y, U b);
+
+	/// Minimum comparison between 3 variables and returns 3 associated variable values
+	/// @see gtx_associated_min_max
+	template<typename T, typename U>
+	GLM_FUNC_DECL U associatedMin(
+		T x, U a,
+		T y, U b,
+		T z, U c);
+
+	/// Minimum comparison between 3 variables and returns 3 associated variable values
+	/// @see gtx_associated_min_max
+	template<length_t L, typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL vec<L, U, Q> associatedMin(
+		vec<L, T, Q> const& x, vec<L, U, Q> const& a,
+		vec<L, T, Q> const& y, vec<L, U, Q> const& b,
+		vec<L, T, Q> const& z, vec<L, U, Q> const& c);
+
+	/// Minimum comparison between 4 variables and returns 4 associated variable values
+	/// @see gtx_associated_min_max
+	template<typename T, typename U>
+	GLM_FUNC_DECL U associatedMin(
+		T x, U a,
+		T y, U b,
+		T z, U c,
+		T w, U d);
+
+	/// Minimum comparison between 4 variables and returns 4 associated variable values
+	/// @see gtx_associated_min_max
+	template<length_t L, typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL vec<L, U, Q> associatedMin(
+		vec<L, T, Q> const& x, vec<L, U, Q> const& a,
+		vec<L, T, Q> const& y, vec<L, U, Q> const& b,
+		vec<L, T, Q> const& z, vec<L, U, Q> const& c,
+		vec<L, T, Q> const& w, vec<L, U, Q> const& d);
+
+	/// Minimum comparison between 4 variables and returns 4 associated variable values
+	/// @see gtx_associated_min_max
+	template<length_t L, typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL vec<L, U, Q> associatedMin(
+		T x, vec<L, U, Q> const& a,
+		T y, vec<L, U, Q> const& b,
+		T z, vec<L, U, Q> const& c,
+		T w, vec<L, U, Q> const& d);
+
+	/// Minimum comparison between 4 variables and returns 4 associated variable values
+	/// @see gtx_associated_min_max
+	template<length_t L, typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL vec<L, U, Q> associatedMin(
+		vec<L, T, Q> const& x, U a,
+		vec<L, T, Q> const& y, U b,
+		vec<L, T, Q> const& z, U c,
+		vec<L, T, Q> const& w, U d);
+
+	/// Maximum comparison between 2 variables and returns 2 associated variable values
+	/// @see gtx_associated_min_max
+	template<typename T, typename U>
+	GLM_FUNC_DECL U associatedMax(T x, U a, T y, U b);
+
+	/// Maximum comparison between 2 variables and returns 2 associated variable values
+	/// @see gtx_associated_min_max
+	template<length_t L, typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL vec<2, U, Q> associatedMax(
+		vec<L, T, Q> const& x, vec<L, U, Q> const& a,
+		vec<L, T, Q> const& y, vec<L, U, Q> const& b);
+
+	/// Maximum comparison between 2 variables and returns 2 associated variable values
+	/// @see gtx_associated_min_max
+	template<length_t L, typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> associatedMax(
+		T x, vec<L, U, Q> const& a,
+		T y, vec<L, U, Q> const& b);
+
+	/// Maximum comparison between 2 variables and returns 2 associated variable values
+	/// @see gtx_associated_min_max
+	template<length_t L, typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL vec<L, U, Q> associatedMax(
+		vec<L, T, Q> const& x, U a,
+		vec<L, T, Q> const& y, U b);
+
+	/// Maximum comparison between 3 variables and returns 3 associated variable values
+	/// @see gtx_associated_min_max
+	template<typename T, typename U>
+	GLM_FUNC_DECL U associatedMax(
+		T x, U a,
+		T y, U b,
+		T z, U c);
+
+	/// Maximum comparison between 3 variables and returns 3 associated variable values
+	/// @see gtx_associated_min_max
+	template<length_t L, typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL vec<L, U, Q> associatedMax(
+		vec<L, T, Q> const& x, vec<L, U, Q> const& a,
+		vec<L, T, Q> const& y, vec<L, U, Q> const& b,
+		vec<L, T, Q> const& z, vec<L, U, Q> const& c);
+
+	/// Maximum comparison between 3 variables and returns 3 associated variable values
+	/// @see gtx_associated_min_max
+	template<length_t L, typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> associatedMax(
+		T x, vec<L, U, Q> const& a,
+		T y, vec<L, U, Q> const& b,
+		T z, vec<L, U, Q> const& c);
+
+	/// Maximum comparison between 3 variables and returns 3 associated variable values
+	/// @see gtx_associated_min_max
+	template<length_t L, typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL vec<L, U, Q> associatedMax(
+		vec<L, T, Q> const& x, U a,
+		vec<L, T, Q> const& y, U b,
+		vec<L, T, Q> const& z, U c);
+
+	/// Maximum comparison between 4 variables and returns 4 associated variable values
+	/// @see gtx_associated_min_max
+	template<typename T, typename U>
+	GLM_FUNC_DECL U associatedMax(
+		T x, U a,
+		T y, U b,
+		T z, U c,
+		T w, U d);
+
+	/// Maximum comparison between 4 variables and returns 4 associated variable values
+	/// @see gtx_associated_min_max
+	template<length_t L, typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL vec<L, U, Q> associatedMax(
+		vec<L, T, Q> const& x, vec<L, U, Q> const& a,
+		vec<L, T, Q> const& y, vec<L, U, Q> const& b,
+		vec<L, T, Q> const& z, vec<L, U, Q> const& c,
+		vec<L, T, Q> const& w, vec<L, U, Q> const& d);
+
+	/// Maximum comparison between 4 variables and returns 4 associated variable values
+	/// @see gtx_associated_min_max
+	template<length_t L, typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL vec<L, U, Q> associatedMax(
+		T x, vec<L, U, Q> const& a,
+		T y, vec<L, U, Q> const& b,
+		T z, vec<L, U, Q> const& c,
+		T w, vec<L, U, Q> const& d);
+
+	/// Maximum comparison between 4 variables and returns 4 associated variable values
+	/// @see gtx_associated_min_max
+	template<length_t L, typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL vec<L, U, Q> associatedMax(
+		vec<L, T, Q> const& x, U a,
+		vec<L, T, Q> const& y, U b,
+		vec<L, T, Q> const& z, U c,
+		vec<L, T, Q> const& w, U d);
+
+	/// @}
+} //namespace glm
+
+#include "associated_min_max.inl"
diff --git a/engine/inc/glm/gtx/associated_min_max.inl b/engine/inc/glm/gtx/associated_min_max.inl
new file mode 100644
index 00000000..1a459add
--- /dev/null
+++ b/engine/inc/glm/gtx/associated_min_max.inl
@@ -0,0 +1,354 @@
+/// @ref gtx_associated_min_max
+
+namespace glm{
+
+// Min comparison between 2 variables
+template<typename T, typename U, qualifier Q>
+GLM_FUNC_QUALIFIER U associatedMin(T x, U a, T y, U b)
+{
+	return x < y ? a : b;
+}
+
+template<length_t L, typename T, typename U, qualifier Q>
+GLM_FUNC_QUALIFIER vec<2, U, Q> associatedMin
+(
+	vec<L, T, Q> const& x, vec<L, U, Q> const& a,
+	vec<L, T, Q> const& y, vec<L, U, Q> const& b
+)
+{
+	vec<L, U, Q> Result;
+	for(length_t i = 0, n = Result.length(); i < n; ++i)
+		Result[i] = x[i] < y[i] ? a[i] : b[i];
+	return Result;
+}
+
+template<length_t L, typename T, typename U, qualifier Q>
+GLM_FUNC_QUALIFIER vec<L, U, Q> associatedMin
+(
+	T x, const vec<L, U, Q>& a,
+	T y, const vec<L, U, Q>& b
+)
+{
+	vec<L, U, Q> Result;
+	for(length_t i = 0, n = Result.length(); i < n; ++i)
+		Result[i] = x < y ? a[i] : b[i];
+	return Result;
+}
+
+template<length_t L, typename T, typename U, qualifier Q>
+GLM_FUNC_QUALIFIER vec<L, U, Q> associatedMin
+(
+	vec<L, T, Q> const& x, U a,
+	vec<L, T, Q> const& y, U b
+)
+{
+	vec<L, U, Q> Result;
+	for(length_t i = 0, n = Result.length(); i < n; ++i)
+		Result[i] = x[i] < y[i] ? a : b;
+	return Result;
+}
+
+// Min comparison between 3 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER U associatedMin
+(
+	T x, U a,
+	T y, U b,
+	T z, U c
+)
+{
+	U Result = x < y ? (x < z ? a : c) : (y < z ? b : c);
+	return Result;
+}
+
+template<length_t L, typename T, typename U, qualifier Q>
+GLM_FUNC_QUALIFIER vec<L, U, Q> associatedMin
+(
+	vec<L, T, Q> const& x, vec<L, U, Q> const& a,
+	vec<L, T, Q> const& y, vec<L, U, Q> const& b,
+	vec<L, T, Q> const& z, vec<L, U, Q> const& c
+)
+{
+	vec<L, U, Q> Result;
+	for(length_t i = 0, n = Result.length(); i < n; ++i)
+		Result[i] = x[i] < y[i] ? (x[i] < z[i] ? a[i] : c[i]) : (y[i] < z[i] ? b[i] : c[i]);
+	return Result;
+}
+
+// Min comparison between 4 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER U associatedMin
+(
+	T x, U a,
+	T y, U b,
+	T z, U c,
+	T w, U d
+)
+{
+	T Test1 = min(x, y);
+	T Test2 = min(z, w);;
+	U Result1 = x < y ? a : b;
+	U Result2 = z < w ? c : d;
+	U Result = Test1 < Test2 ? Result1 : Result2;
+	return Result;
+}
+
+// Min comparison between 4 variables
+template<length_t L, typename T, typename U, qualifier Q>
+GLM_FUNC_QUALIFIER vec<L, U, Q> associatedMin
+(
+	vec<L, T, Q> const& x, vec<L, U, Q> const& a,
+	vec<L, T, Q> const& y, vec<L, U, Q> const& b,
+	vec<L, T, Q> const& z, vec<L, U, Q> const& c,
+	vec<L, T, Q> const& w, vec<L, U, Q> const& d
+)
+{
+	vec<L, U, Q> Result;
+	for(length_t i = 0, n = Result.length(); i < n; ++i)
+	{
+		T Test1 = min(x[i], y[i]);
+		T Test2 = min(z[i], w[i]);
+		U Result1 = x[i] < y[i] ? a[i] : b[i];
+		U Result2 = z[i] < w[i] ? c[i] : d[i];
+		Result[i] = Test1 < Test2 ? Result1 : Result2;
+	}
+	return Result;
+}
+
+// Min comparison between 4 variables
+template<length_t L, typename T, typename U, qualifier Q>
+GLM_FUNC_QUALIFIER vec<L, U, Q> associatedMin
+(
+	T x, vec<L, U, Q> const& a,
+	T y, vec<L, U, Q> const& b,
+	T z, vec<L, U, Q> const& c,
+	T w, vec<L, U, Q> const& d
+)
+{
+	T Test1 = min(x, y);
+	T Test2 = min(z, w);
+
+	vec<L, U, Q> Result;
+	for(length_t i = 0, n = Result.length(); i < n; ++i)
+	{
+		U Result1 = x < y ? a[i] : b[i];
+		U Result2 = z < w ? c[i] : d[i];
+		Result[i] = Test1 < Test2 ? Result1 : Result2;
+	}
+	return Result;
+}
+
+// Min comparison between 4 variables
+template<length_t L, typename T, typename U, qualifier Q>
+GLM_FUNC_QUALIFIER vec<L, U, Q> associatedMin
+(
+	vec<L, T, Q> const& x, U a,
+	vec<L, T, Q> const& y, U b,
+	vec<L, T, Q> const& z, U c,
+	vec<L, T, Q> const& w, U d
+)
+{
+	vec<L, U, Q> Result;
+	for(length_t i = 0, n = Result.length(); i < n; ++i)
+	{
+		T Test1 = min(x[i], y[i]);
+		T Test2 = min(z[i], w[i]);;
+		U Result1 = x[i] < y[i] ? a : b;
+		U Result2 = z[i] < w[i] ? c : d;
+		Result[i] = Test1 < Test2 ? Result1 : Result2;
+	}
+	return Result;
+}
+
+// Max comparison between 2 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER U associatedMax(T x, U a, T y, U b)
+{
+	return x > y ? a : b;
+}
+
+// Max comparison between 2 variables
+template<length_t L, typename T, typename U, qualifier Q>
+GLM_FUNC_QUALIFIER vec<2, U, Q> associatedMax
+(
+	vec<L, T, Q> const& x, vec<L, U, Q> const& a,
+	vec<L, T, Q> const& y, vec<L, U, Q> const& b
+)
+{
+	vec<L, U, Q> Result;
+	for(length_t i = 0, n = Result.length(); i < n; ++i)
+		Result[i] = x[i] > y[i] ? a[i] : b[i];
+	return Result;
+}
+
+// Max comparison between 2 variables
+template<length_t L, typename T, typename U, qualifier Q>
+GLM_FUNC_QUALIFIER vec<L, T, Q> associatedMax
+(
+	T x, vec<L, U, Q> const& a,
+	T y, vec<L, U, Q> const& b
+)
+{
+	vec<L, U, Q> Result;
+	for(length_t i = 0, n = Result.length(); i < n; ++i)
+		Result[i] = x > y ? a[i] : b[i];
+	return Result;
+}
+
+// Max comparison between 2 variables
+template<length_t L, typename T, typename U, qualifier Q>
+GLM_FUNC_QUALIFIER vec<L, U, Q> associatedMax
+(
+	vec<L, T, Q> const& x, U a,
+	vec<L, T, Q> const& y, U b
+)
+{
+	vec<L, T, Q> Result;
+	for(length_t i = 0, n = Result.length(); i < n; ++i)
+		Result[i] = x[i] > y[i] ? a : b;
+	return Result;
+}
+
+// Max comparison between 3 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER U associatedMax
+(
+	T x, U a,
+	T y, U b,
+	T z, U c
+)
+{
+	U Result = x > y ? (x > z ? a : c) : (y > z ? b : c);
+	return Result;
+}
+
+// Max comparison between 3 variables
+template<length_t L, typename T, typename U, qualifier Q>
+GLM_FUNC_QUALIFIER vec<L, U, Q> associatedMax
+(
+	vec<L, T, Q> const& x, vec<L, U, Q> const& a,
+	vec<L, T, Q> const& y, vec<L, U, Q> const& b,
+	vec<L, T, Q> const& z, vec<L, U, Q> const& c
+)
+{
+	vec<L, U, Q> Result;
+	for(length_t i = 0, n = Result.length(); i < n; ++i)
+		Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a[i] : c[i]) : (y[i] > z[i] ? b[i] : c[i]);
+	return Result;
+}
+
+// Max comparison between 3 variables
+template<length_t L, typename T, typename U, qualifier Q>
+GLM_FUNC_QUALIFIER vec<L, T, Q> associatedMax
+(
+	T x, vec<L, U, Q> const& a,
+	T y, vec<L, U, Q> const& b,
+	T z, vec<L, U, Q> const& c
+)
+{
+	vec<L, U, Q> Result;
+	for(length_t i = 0, n = Result.length(); i < n; ++i)
+		Result[i] = x > y ? (x > z ? a[i] : c[i]) : (y > z ? b[i] : c[i]);
+	return Result;
+}
+
+// Max comparison between 3 variables
+template<length_t L, typename T, typename U, qualifier Q>
+GLM_FUNC_QUALIFIER vec<L, U, Q> associatedMax
+(
+	vec<L, T, Q> const& x, U a,
+	vec<L, T, Q> const& y, U b,
+	vec<L, T, Q> const& z, U c
+)
+{
+	vec<L, T, Q> Result;
+	for(length_t i = 0, n = Result.length(); i < n; ++i)
+		Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a : c) : (y[i] > z[i] ? b : c);
+	return Result;
+}
+
+// Max comparison between 4 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER U associatedMax
+(
+	T x, U a,
+	T y, U b,
+	T z, U c,
+	T w, U d
+)
+{
+	T Test1 = max(x, y);
+	T Test2 = max(z, w);;
+	U Result1 = x > y ? a : b;
+	U Result2 = z > w ? c : d;
+	U Result = Test1 > Test2 ? Result1 : Result2;
+	return Result;
+}
+
+// Max comparison between 4 variables
+template<length_t L, typename T, typename U, qualifier Q>
+GLM_FUNC_QUALIFIER vec<L, U, Q> associatedMax
+(
+	vec<L, T, Q> const& x, vec<L, U, Q> const& a,
+	vec<L, T, Q> const& y, vec<L, U, Q> const& b,
+	vec<L, T, Q> const& z, vec<L, U, Q> const& c,
+	vec<L, T, Q> const& w, vec<L, U, Q> const& d
+)
+{
+	vec<L, U, Q> Result;
+	for(length_t i = 0, n = Result.length(); i < n; ++i)
+	{
+		T Test1 = max(x[i], y[i]);
+		T Test2 = max(z[i], w[i]);
+		U Result1 = x[i] > y[i] ? a[i] : b[i];
+		U Result2 = z[i] > w[i] ? c[i] : d[i];
+		Result[i] = Test1 > Test2 ? Result1 : Result2;
+	}
+	return Result;
+}
+
+// Max comparison between 4 variables
+template<length_t L, typename T, typename U, qualifier Q>
+GLM_FUNC_QUALIFIER vec<L, U, Q> associatedMax
+(
+	T x, vec<L, U, Q> const& a,
+	T y, vec<L, U, Q> const& b,
+	T z, vec<L, U, Q> const& c,
+	T w, vec<L, U, Q> const& d
+)
+{
+	T Test1 = max(x, y);
+	T Test2 = max(z, w);
+
+	vec<L, U, Q> Result;
+	for(length_t i = 0, n = Result.length(); i < n; ++i)
+	{
+		U Result1 = x > y ? a[i] : b[i];
+		U Result2 = z > w ? c[i] : d[i];
+		Result[i] = Test1 > Test2 ? Result1 : Result2;
+	}
+	return Result;
+}
+
+// Max comparison between 4 variables
+template<length_t L, typename T, typename U, qualifier Q>
+GLM_FUNC_QUALIFIER vec<L, U, Q> associatedMax
+(
+	vec<L, T, Q> const& x, U a,
+	vec<L, T, Q> const& y, U b,
+	vec<L, T, Q> const& z, U c,
+	vec<L, T, Q> const& w, U d
+)
+{
+	vec<L, U, Q> Result;
+	for(length_t i = 0, n = Result.length(); i < n; ++i)
+	{
+		T Test1 = max(x[i], y[i]);
+		T Test2 = max(z[i], w[i]);;
+		U Result1 = x[i] > y[i] ? a : b;
+		U Result2 = z[i] > w[i] ? c : d;
+		Result[i] = Test1 > Test2 ? Result1 : Result2;
+	}
+	return Result;
+}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/bit.hpp b/engine/inc/glm/gtx/bit.hpp
new file mode 100644
index 00000000..31a7c069
--- /dev/null
+++ b/engine/inc/glm/gtx/bit.hpp
@@ -0,0 +1,98 @@
+/// @ref gtx_bit
+/// @file glm/gtx/bit.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_bit GLM_GTX_bit
+/// @ingroup gtx
+///
+/// Include <glm/gtx/bit.hpp> to use the features of this extension.
+///
+/// Allow to perform bit operations on integer values
+
+#pragma once
+
+// Dependencies
+#include "../gtc/bitfield.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_bit is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_bit extension is deprecated, include GLM_GTC_bitfield and GLM_GTC_integer instead")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_bit
+	/// @{
+
+	/// @see gtx_bit
+	template<typename genIUType>
+	GLM_FUNC_DECL genIUType highestBitValue(genIUType Value);
+
+	/// @see gtx_bit
+	template<typename genIUType>
+	GLM_FUNC_DECL genIUType lowestBitValue(genIUType Value);
+
+	/// Find the highest bit set to 1 in a integer variable and return its value.
+	///
+	/// @see gtx_bit
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> highestBitValue(vec<L, T, Q> const& value);
+
+	/// Return the power of two number which value is just higher the input value.
+	/// Deprecated, use ceilPowerOfTwo from GTC_round instead
+	///
+	/// @see gtc_round
+	/// @see gtx_bit
+	template<typename genIUType>
+	GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoAbove(genIUType Value);
+
+	/// Return the power of two number which value is just higher the input value.
+	/// Deprecated, use ceilPowerOfTwo from GTC_round instead
+	///
+	/// @see gtc_round
+	/// @see gtx_bit
+	template<length_t L, typename T, qualifier Q>
+	GLM_DEPRECATED GLM_FUNC_DECL vec<L, T, Q> powerOfTwoAbove(vec<L, T, Q> const& value);
+
+	/// Return the power of two number which value is just lower the input value.
+	/// Deprecated, use floorPowerOfTwo from GTC_round instead
+	///
+	/// @see gtc_round
+	/// @see gtx_bit
+	template<typename genIUType>
+	GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoBelow(genIUType Value);
+
+	/// Return the power of two number which value is just lower the input value.
+	/// Deprecated, use floorPowerOfTwo from GTC_round instead
+	///
+	/// @see gtc_round
+	/// @see gtx_bit
+	template<length_t L, typename T, qualifier Q>
+	GLM_DEPRECATED GLM_FUNC_DECL vec<L, T, Q> powerOfTwoBelow(vec<L, T, Q> const& value);
+
+	/// Return the power of two number which value is the closet to the input value.
+	/// Deprecated, use roundPowerOfTwo from GTC_round instead
+	///
+	/// @see gtc_round
+	/// @see gtx_bit
+	template<typename genIUType>
+	GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoNearest(genIUType Value);
+
+	/// Return the power of two number which value is the closet to the input value.
+	/// Deprecated, use roundPowerOfTwo from GTC_round instead
+	///
+	/// @see gtc_round
+	/// @see gtx_bit
+	template<length_t L, typename T, qualifier Q>
+	GLM_DEPRECATED GLM_FUNC_DECL vec<L, T, Q> powerOfTwoNearest(vec<L, T, Q> const& value);
+
+	/// @}
+} //namespace glm
+
+
+#include "bit.inl"
+
diff --git a/engine/inc/glm/gtx/bit.inl b/engine/inc/glm/gtx/bit.inl
new file mode 100644
index 00000000..621b6262
--- /dev/null
+++ b/engine/inc/glm/gtx/bit.inl
@@ -0,0 +1,92 @@
+/// @ref gtx_bit
+
+namespace glm
+{
+	///////////////////
+	// highestBitValue
+
+	template<typename genIUType>
+	GLM_FUNC_QUALIFIER genIUType highestBitValue(genIUType Value)
+	{
+		genIUType tmp = Value;
+		genIUType result = genIUType(0);
+		while(tmp)
+		{
+			result = (tmp & (~tmp + 1)); // grab lowest bit
+			tmp &= ~result; // clear lowest bit
+		}
+		return result;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> highestBitValue(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(highestBitValue, v);
+	}
+
+	///////////////////
+	// lowestBitValue
+
+	template<typename genIUType>
+	GLM_FUNC_QUALIFIER genIUType lowestBitValue(genIUType Value)
+	{
+		return (Value & (~Value + 1));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> lowestBitValue(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(lowestBitValue, v);
+	}
+
+	///////////////////
+	// powerOfTwoAbove
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType powerOfTwoAbove(genType value)
+	{
+		return isPowerOfTwo(value) ? value : highestBitValue(value) << 1;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> powerOfTwoAbove(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(powerOfTwoAbove, v);
+	}
+
+	///////////////////
+	// powerOfTwoBelow
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType powerOfTwoBelow(genType value)
+	{
+		return isPowerOfTwo(value) ? value : highestBitValue(value);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> powerOfTwoBelow(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(powerOfTwoBelow, v);
+	}
+
+	/////////////////////
+	// powerOfTwoNearest
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType powerOfTwoNearest(genType value)
+	{
+		if(isPowerOfTwo(value))
+			return value;
+
+		genType const prev = highestBitValue(value);
+		genType const next = prev << 1;
+		return (next - value) < (value - prev) ? next : prev;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> powerOfTwoNearest(vec<L, T, Q> const& v)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(powerOfTwoNearest, v);
+	}
+
+}//namespace glm
diff --git a/engine/inc/glm/gtx/closest_point.hpp b/engine/inc/glm/gtx/closest_point.hpp
new file mode 100644
index 00000000..d257bdc1
--- /dev/null
+++ b/engine/inc/glm/gtx/closest_point.hpp
@@ -0,0 +1,49 @@
+/// @ref gtx_closest_point
+/// @file glm/gtx/closest_point.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_closest_point GLM_GTX_closest_point
+/// @ingroup gtx
+///
+/// Include <glm/gtx/closest_point.hpp> to use the features of this extension.
+///
+/// Find the point on a straight line which is the closet of a point.
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_closest_point is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_closest_point extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_closest_point
+	/// @{
+
+	/// Find the point on a straight line which is the closet of a point.
+	/// @see gtx_closest_point
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> closestPointOnLine(
+		vec<3, T, Q> const& point,
+		vec<3, T, Q> const& a,
+		vec<3, T, Q> const& b);
+
+	/// 2d lines work as well
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<2, T, Q> closestPointOnLine(
+		vec<2, T, Q> const& point,
+		vec<2, T, Q> const& a,
+		vec<2, T, Q> const& b);
+
+	/// @}
+}// namespace glm
+
+#include "closest_point.inl"
diff --git a/engine/inc/glm/gtx/closest_point.inl b/engine/inc/glm/gtx/closest_point.inl
new file mode 100644
index 00000000..0a39b042
--- /dev/null
+++ b/engine/inc/glm/gtx/closest_point.inl
@@ -0,0 +1,45 @@
+/// @ref gtx_closest_point
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> closestPointOnLine
+	(
+		vec<3, T, Q> const& point,
+		vec<3, T, Q> const& a,
+		vec<3, T, Q> const& b
+	)
+	{
+		T LineLength = distance(a, b);
+		vec<3, T, Q> Vector = point - a;
+		vec<3, T, Q> LineDirection = (b - a) / LineLength;
+
+		// Project Vector to LineDirection to get the distance of point from a
+		T Distance = dot(Vector, LineDirection);
+
+		if(Distance <= T(0)) return a;
+		if(Distance >= LineLength) return b;
+		return a + LineDirection * Distance;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<2, T, Q> closestPointOnLine
+	(
+		vec<2, T, Q> const& point,
+		vec<2, T, Q> const& a,
+		vec<2, T, Q> const& b
+	)
+	{
+		T LineLength = distance(a, b);
+		vec<2, T, Q> Vector = point - a;
+		vec<2, T, Q> LineDirection = (b - a) / LineLength;
+
+		// Project Vector to LineDirection to get the distance of point from a
+		T Distance = dot(Vector, LineDirection);
+
+		if(Distance <= T(0)) return a;
+		if(Distance >= LineLength) return b;
+		return a + LineDirection * Distance;
+	}
+
+}//namespace glm
diff --git a/engine/inc/glm/gtx/color_encoding.hpp b/engine/inc/glm/gtx/color_encoding.hpp
new file mode 100644
index 00000000..8581b159
--- /dev/null
+++ b/engine/inc/glm/gtx/color_encoding.hpp
@@ -0,0 +1,50 @@
+/// @ref gtx_color_encoding
+/// @file glm/gtx/color_encoding.hpp
+///
+/// @see core (dependence)
+/// @see gtx_color_encoding (dependence)
+///
+/// @defgroup gtx_color_encoding GLM_GTX_color_encoding
+/// @ingroup gtx
+///
+/// Include <glm/gtx/color_encoding.hpp> to use the features of this extension.
+///
+/// @brief Allow to perform bit operations on integer values
+
+#pragma once
+
+// Dependencies
+#include "../detail/setup.hpp"
+#include "../detail/qualifier.hpp"
+#include "../vec3.hpp"
+#include <limits>
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTC_color_encoding extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_color_encoding
+	/// @{
+
+	/// Convert a linear sRGB color to D65 YUV.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> convertLinearSRGBToD65XYZ(vec<3, T, Q> const& ColorLinearSRGB);
+
+	/// Convert a linear sRGB color to D50 YUV.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> convertLinearSRGBToD50XYZ(vec<3, T, Q> const& ColorLinearSRGB);
+
+	/// Convert a D65 YUV color to linear sRGB.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> convertD65XYZToLinearSRGB(vec<3, T, Q> const& ColorD65XYZ);
+
+	/// Convert a D65 YUV color to D50 YUV.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> convertD65XYZToD50XYZ(vec<3, T, Q> const& ColorD65XYZ);
+
+	/// @}
+} //namespace glm
+
+#include "color_encoding.inl"
diff --git a/engine/inc/glm/gtx/color_encoding.inl b/engine/inc/glm/gtx/color_encoding.inl
new file mode 100644
index 00000000..e50fa3ef
--- /dev/null
+++ b/engine/inc/glm/gtx/color_encoding.inl
@@ -0,0 +1,45 @@
+/// @ref gtx_color_encoding
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> convertLinearSRGBToD65XYZ(vec<3, T, Q> const& ColorLinearSRGB)
+	{
+		vec<3, T, Q> const M(0.490f, 0.17697f, 0.2f);
+		vec<3, T, Q> const N(0.31f,  0.8124f, 0.01063f);
+		vec<3, T, Q> const O(0.490f, 0.01f, 0.99f);
+
+		return (M * ColorLinearSRGB + N * ColorLinearSRGB + O * ColorLinearSRGB) * static_cast<T>(5.650675255693055f);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> convertLinearSRGBToD50XYZ(vec<3, T, Q> const& ColorLinearSRGB)
+	{
+		vec<3, T, Q> const M(0.436030342570117f, 0.222438466210245f, 0.013897440074263f);
+		vec<3, T, Q> const N(0.385101860087134f, 0.716942745571917f, 0.097076381494207f);
+		vec<3, T, Q> const O(0.143067806654203f, 0.060618777416563f, 0.713926257896652f);
+
+		return M * ColorLinearSRGB + N * ColorLinearSRGB + O * ColorLinearSRGB;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> convertD65XYZToLinearSRGB(vec<3, T, Q> const& ColorD65XYZ)
+	{
+		vec<3, T, Q> const M(0.41847f, -0.091169f, 0.0009209f);
+		vec<3, T, Q> const N(-0.15866f, 0.25243f, 0.015708f);
+		vec<3, T, Q> const O(0.0009209f, -0.0025498f, 0.1786f);
+
+		return M * ColorD65XYZ + N * ColorD65XYZ + O * ColorD65XYZ;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> convertD65XYZToD50XYZ(vec<3, T, Q> const& ColorD65XYZ)
+	{
+		vec<3, T, Q> const M(+1.047844353856414f, +0.029549007606644f, -0.009250984365223f);
+		vec<3, T, Q> const N(+0.022898981050086f, +0.990508028941971f, +0.015072338237051f);
+		vec<3, T, Q> const O(-0.050206647741605f, -0.017074711360960f, +0.751717835079977f);
+
+		return M * ColorD65XYZ + N * ColorD65XYZ + O * ColorD65XYZ;
+	}
+
+}//namespace glm
diff --git a/engine/inc/glm/gtx/color_space.hpp b/engine/inc/glm/gtx/color_space.hpp
new file mode 100644
index 00000000..edc959ad
--- /dev/null
+++ b/engine/inc/glm/gtx/color_space.hpp
@@ -0,0 +1,72 @@
+/// @ref gtx_color_space
+/// @file glm/gtx/color_space.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_color_space GLM_GTX_color_space
+/// @ingroup gtx
+///
+/// Include <glm/gtx/color_space.hpp> to use the features of this extension.
+///
+/// Related to RGB to HSV conversions and operations.
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_color_space is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_color_space extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_color_space
+	/// @{
+
+	/// Converts a color from HSV color space to its color in RGB color space.
+	/// @see gtx_color_space
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> rgbColor(
+		vec<3, T, Q> const& hsvValue);
+
+	/// Converts a color from RGB color space to its color in HSV color space.
+	/// @see gtx_color_space
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> hsvColor(
+		vec<3, T, Q> const& rgbValue);
+
+	/// Build a saturation matrix.
+	/// @see gtx_color_space
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> saturation(
+		T const s);
+
+	/// Modify the saturation of a color.
+	/// @see gtx_color_space
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> saturation(
+		T const s,
+		vec<3, T, Q> const& color);
+
+	/// Modify the saturation of a color.
+	/// @see gtx_color_space
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<4, T, Q> saturation(
+		T const s,
+		vec<4, T, Q> const& color);
+
+	/// Compute color luminosity associating ratios (0.33, 0.59, 0.11) to RGB canals.
+	/// @see gtx_color_space
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL T luminosity(
+		vec<3, T, Q> const& color);
+
+	/// @}
+}//namespace glm
+
+#include "color_space.inl"
diff --git a/engine/inc/glm/gtx/color_space.inl b/engine/inc/glm/gtx/color_space.inl
new file mode 100644
index 00000000..f698afe1
--- /dev/null
+++ b/engine/inc/glm/gtx/color_space.inl
@@ -0,0 +1,141 @@
+/// @ref gtx_color_space
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> rgbColor(const vec<3, T, Q>& hsvColor)
+	{
+		vec<3, T, Q> hsv = hsvColor;
+		vec<3, T, Q> rgbColor;
+
+		if(hsv.y == static_cast<T>(0))
+			// achromatic (grey)
+			rgbColor = vec<3, T, Q>(hsv.z);
+		else
+		{
+			T sector = floor(hsv.x * (T(1) / T(60)));
+			T frac = (hsv.x * (T(1) / T(60))) - sector;
+			// factorial part of h
+			T o = hsv.z * (T(1) - hsv.y);
+			T p = hsv.z * (T(1) - hsv.y * frac);
+			T q = hsv.z * (T(1) - hsv.y * (T(1) - frac));
+
+			switch(int(sector))
+			{
+			default:
+			case 0:
+				rgbColor.r = hsv.z;
+				rgbColor.g = q;
+				rgbColor.b = o;
+				break;
+			case 1:
+				rgbColor.r = p;
+				rgbColor.g = hsv.z;
+				rgbColor.b = o;
+				break;
+			case 2:
+				rgbColor.r = o;
+				rgbColor.g = hsv.z;
+				rgbColor.b = q;
+				break;
+			case 3:
+				rgbColor.r = o;
+				rgbColor.g = p;
+				rgbColor.b = hsv.z;
+				break;
+			case 4:
+				rgbColor.r = q;
+				rgbColor.g = o;
+				rgbColor.b = hsv.z;
+				break;
+			case 5:
+				rgbColor.r = hsv.z;
+				rgbColor.g = o;
+				rgbColor.b = p;
+				break;
+			}
+		}
+
+		return rgbColor;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> hsvColor(const vec<3, T, Q>& rgbColor)
+	{
+		vec<3, T, Q> hsv = rgbColor;
+		float Min   = min(min(rgbColor.r, rgbColor.g), rgbColor.b);
+		float Max   = max(max(rgbColor.r, rgbColor.g), rgbColor.b);
+		float Delta = Max - Min;
+
+		hsv.z = Max;
+
+		if(Max != static_cast<T>(0))
+		{
+			hsv.y = Delta / hsv.z;
+			T h = static_cast<T>(0);
+
+			if(rgbColor.r == Max)
+				// between yellow & magenta
+				h = static_cast<T>(0) + T(60) * (rgbColor.g - rgbColor.b) / Delta;
+			else if(rgbColor.g == Max)
+				// between cyan & yellow
+				h = static_cast<T>(120) + T(60) * (rgbColor.b - rgbColor.r) / Delta;
+			else
+				// between magenta & cyan
+				h = static_cast<T>(240) + T(60) * (rgbColor.r - rgbColor.g) / Delta;
+
+			if(h < T(0))
+				hsv.x = h + T(360);
+			else
+				hsv.x = h;
+		}
+		else
+		{
+			// If r = g = b = 0 then s = 0, h is undefined
+			hsv.y = static_cast<T>(0);
+			hsv.x = static_cast<T>(0);
+		}
+
+		return hsv;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> saturation(T const s)
+	{
+		vec<3, T, defaultp> rgbw = vec<3, T, defaultp>(T(0.2126), T(0.7152), T(0.0722));
+
+		vec<3, T, defaultp> const col((T(1) - s) * rgbw);
+
+		mat<4, 4, T, defaultp> result(T(1));
+		result[0][0] = col.x + s;
+		result[0][1] = col.x;
+		result[0][2] = col.x;
+		result[1][0] = col.y;
+		result[1][1] = col.y + s;
+		result[1][2] = col.y;
+		result[2][0] = col.z;
+		result[2][1] = col.z;
+		result[2][2] = col.z + s;
+
+		return result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> saturation(const T s, const vec<3, T, Q>& color)
+	{
+		return vec<3, T, Q>(saturation(s) * vec<4, T, Q>(color, T(0)));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, T, Q> saturation(const T s, const vec<4, T, Q>& color)
+	{
+		return saturation(s) * color;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T luminosity(const vec<3, T, Q>& color)
+	{
+		const vec<3, T, Q> tmp = vec<3, T, Q>(0.33, 0.59, 0.11);
+		return dot(color, tmp);
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/color_space_YCoCg.hpp b/engine/inc/glm/gtx/color_space_YCoCg.hpp
new file mode 100644
index 00000000..fd9069e0
--- /dev/null
+++ b/engine/inc/glm/gtx/color_space_YCoCg.hpp
@@ -0,0 +1,60 @@
+/// @ref gtx_color_space_YCoCg
+/// @file glm/gtx/color_space_YCoCg.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_color_space_YCoCg GLM_GTX_color_space_YCoCg
+/// @ingroup gtx
+///
+/// Include <glm/gtx/color_space_YCoCg.hpp> to use the features of this extension.
+///
+/// RGB to YCoCg conversions and operations
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_color_space_YCoCg is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_color_space_YCoCg extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_color_space_YCoCg
+	/// @{
+
+	/// Convert a color from RGB color space to YCoCg color space.
+	/// @see gtx_color_space_YCoCg
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> rgb2YCoCg(
+		vec<3, T, Q> const& rgbColor);
+
+	/// Convert a color from YCoCg color space to RGB color space.
+	/// @see gtx_color_space_YCoCg
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> YCoCg2rgb(
+		vec<3, T, Q> const& YCoCgColor);
+
+	/// Convert a color from RGB color space to YCoCgR color space.
+	/// @see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range"
+	/// @see gtx_color_space_YCoCg
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> rgb2YCoCgR(
+		vec<3, T, Q> const& rgbColor);
+
+	/// Convert a color from YCoCgR color space to RGB color space.
+	/// @see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range"
+	/// @see gtx_color_space_YCoCg
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> YCoCgR2rgb(
+		vec<3, T, Q> const& YCoCgColor);
+
+	/// @}
+}//namespace glm
+
+#include "color_space_YCoCg.inl"
diff --git a/engine/inc/glm/gtx/color_space_YCoCg.inl b/engine/inc/glm/gtx/color_space_YCoCg.inl
new file mode 100644
index 00000000..83ba857c
--- /dev/null
+++ b/engine/inc/glm/gtx/color_space_YCoCg.inl
@@ -0,0 +1,107 @@
+/// @ref gtx_color_space_YCoCg
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> rgb2YCoCg
+	(
+		vec<3, T, Q> const& rgbColor
+	)
+	{
+		vec<3, T, Q> result;
+		result.x/*Y */ =   rgbColor.r / T(4) + rgbColor.g / T(2) + rgbColor.b / T(4);
+		result.y/*Co*/ =   rgbColor.r / T(2) + rgbColor.g * T(0) - rgbColor.b / T(2);
+		result.z/*Cg*/ = - rgbColor.r / T(4) + rgbColor.g / T(2) - rgbColor.b / T(4);
+		return result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> YCoCg2rgb
+	(
+		vec<3, T, Q> const& YCoCgColor
+	)
+	{
+		vec<3, T, Q> result;
+		result.r = YCoCgColor.x + YCoCgColor.y - YCoCgColor.z;
+		result.g = YCoCgColor.x				   + YCoCgColor.z;
+		result.b = YCoCgColor.x - YCoCgColor.y - YCoCgColor.z;
+		return result;
+	}
+
+	template<typename T, qualifier Q, bool isInteger>
+	class compute_YCoCgR {
+	public:
+		static GLM_FUNC_QUALIFIER vec<3, T, Q> rgb2YCoCgR
+		(
+			vec<3, T, Q> const& rgbColor
+		)
+		{
+			vec<3, T, Q> result;
+			result.x/*Y */ = rgbColor.g * static_cast<T>(0.5) + (rgbColor.r + rgbColor.b) * static_cast<T>(0.25);
+			result.y/*Co*/ = rgbColor.r - rgbColor.b;
+			result.z/*Cg*/ = rgbColor.g - (rgbColor.r + rgbColor.b) * static_cast<T>(0.5);
+			return result;
+		}
+
+		static GLM_FUNC_QUALIFIER vec<3, T, Q> YCoCgR2rgb
+		(
+			vec<3, T, Q> const& YCoCgRColor
+		)
+		{
+			vec<3, T, Q> result;
+			T tmp = YCoCgRColor.x - (YCoCgRColor.z * static_cast<T>(0.5));
+			result.g = YCoCgRColor.z + tmp;
+			result.b = tmp - (YCoCgRColor.y * static_cast<T>(0.5));
+			result.r = result.b + YCoCgRColor.y;
+			return result;
+		}
+	};
+
+	template<typename T, qualifier Q>
+	class compute_YCoCgR<T, Q, true> {
+	public:
+		static GLM_FUNC_QUALIFIER vec<3, T, Q> rgb2YCoCgR
+		(
+			vec<3, T, Q> const& rgbColor
+		)
+		{
+			vec<3, T, Q> result;
+			result.y/*Co*/ = rgbColor.r - rgbColor.b;
+			T tmp = rgbColor.b + (result.y >> 1);
+			result.z/*Cg*/ = rgbColor.g - tmp;
+			result.x/*Y */ = tmp + (result.z >> 1);
+			return result;
+		}
+
+		static GLM_FUNC_QUALIFIER vec<3, T, Q> YCoCgR2rgb
+		(
+			vec<3, T, Q> const& YCoCgRColor
+		)
+		{
+			vec<3, T, Q> result;
+			T tmp = YCoCgRColor.x - (YCoCgRColor.z >> 1);
+			result.g = YCoCgRColor.z + tmp;
+			result.b = tmp - (YCoCgRColor.y >> 1);
+			result.r = result.b + YCoCgRColor.y;
+			return result;
+		}
+	};
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> rgb2YCoCgR
+	(
+		vec<3, T, Q> const& rgbColor
+	)
+	{
+		return compute_YCoCgR<T, Q, std::numeric_limits<T>::is_integer>::rgb2YCoCgR(rgbColor);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> YCoCgR2rgb
+	(
+		vec<3, T, Q> const& YCoCgRColor
+	)
+	{
+		return compute_YCoCgR<T, Q, std::numeric_limits<T>::is_integer>::YCoCgR2rgb(YCoCgRColor);
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/common.hpp b/engine/inc/glm/gtx/common.hpp
new file mode 100644
index 00000000..c36f850e
--- /dev/null
+++ b/engine/inc/glm/gtx/common.hpp
@@ -0,0 +1,76 @@
+/// @ref gtx_common
+/// @file glm/gtx/common.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_common GLM_GTX_common
+/// @ingroup gtx
+///
+/// Include <glm/gtx/common.hpp> to use the features of this extension.
+///
+/// @brief Provide functions to increase the compatibility with Cg and HLSL languages
+
+#pragma once
+
+// Dependencies:
+#include "../vec2.hpp"
+#include "../vec3.hpp"
+#include "../vec4.hpp"
+#include "../gtc/vec1.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_common is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_common extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_common
+	/// @{
+
+	/// Returns true if x is a denormalized number
+	/// Numbers whose absolute value is too small to be represented in the normal format are represented in an alternate, denormalized format.
+	/// This format is less precise but can represent values closer to zero.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isnan.xml">GLSL isnan man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template<typename genType>
+	GLM_FUNC_DECL typename genType::bool_type isdenormal(genType const& x);
+
+	/// Similar to 'mod' but with a different rounding and integer support.
+	/// Returns 'x - y * trunc(x/y)' instead of 'x - y * floor(x/y)'
+	///
+	/// @see <a href="http://stackoverflow.com/questions/7610631/glsl-mod-vs-hlsl-fmod">GLSL mod vs HLSL fmod</a>
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> fmod(vec<L, T, Q> const& v);
+
+	/// Returns whether vector components values are within an interval. A open interval excludes its endpoints, and is denoted with square brackets.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see ext_vector_relational
+	template <length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, bool, Q> openBounded(vec<L, T, Q> const& Value, vec<L, T, Q> const& Min, vec<L, T, Q> const& Max);
+
+	/// Returns whether vector components values are within an interval. A closed interval includes its endpoints, and is denoted with square brackets.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see ext_vector_relational
+	template <length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, bool, Q> closeBounded(vec<L, T, Q> const& Value, vec<L, T, Q> const& Min, vec<L, T, Q> const& Max);
+
+	/// @}
+}//namespace glm
+
+#include "common.inl"
diff --git a/engine/inc/glm/gtx/common.inl b/engine/inc/glm/gtx/common.inl
new file mode 100644
index 00000000..4ad2126d
--- /dev/null
+++ b/engine/inc/glm/gtx/common.inl
@@ -0,0 +1,125 @@
+/// @ref gtx_common
+
+#include <cmath>
+#include "../gtc/epsilon.hpp"
+#include "../gtc/constants.hpp"
+
+namespace glm{
+namespace detail
+{
+	template<length_t L, typename T, qualifier Q, bool isFloat = true>
+	struct compute_fmod
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& a, vec<L, T, Q> const& b)
+		{
+			return detail::functor2<vec, L, T, Q>::call(std::fmod, a, b);
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q>
+	struct compute_fmod<L, T, Q, false>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& a, vec<L, T, Q> const& b)
+		{
+			return a % b;
+		}
+	};
+}//namespace detail
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER bool isdenormal(T const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isdenormal' only accept floating-point inputs");
+
+#		if GLM_HAS_CXX11_STL
+			return std::fpclassify(x) == FP_SUBNORMAL;
+#		else
+			return epsilonNotEqual(x, static_cast<T>(0), epsilon<T>()) && std::fabs(x) < std::numeric_limits<T>::min();
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename vec<1, T, Q>::bool_type isdenormal
+	(
+		vec<1, T, Q> const& x
+	)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isdenormal' only accept floating-point inputs");
+
+		return typename vec<1, T, Q>::bool_type(
+			isdenormal(x.x));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename vec<2, T, Q>::bool_type isdenormal
+	(
+		vec<2, T, Q> const& x
+	)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isdenormal' only accept floating-point inputs");
+
+		return typename vec<2, T, Q>::bool_type(
+			isdenormal(x.x),
+			isdenormal(x.y));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename vec<3, T, Q>::bool_type isdenormal
+	(
+		vec<3, T, Q> const& x
+	)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isdenormal' only accept floating-point inputs");
+
+		return typename vec<3, T, Q>::bool_type(
+			isdenormal(x.x),
+			isdenormal(x.y),
+			isdenormal(x.z));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename vec<4, T, Q>::bool_type isdenormal
+	(
+		vec<4, T, Q> const& x
+	)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isdenormal' only accept floating-point inputs");
+
+		return typename vec<4, T, Q>::bool_type(
+			isdenormal(x.x),
+			isdenormal(x.y),
+			isdenormal(x.z),
+			isdenormal(x.w));
+	}
+
+	// fmod
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType fmod(genType x, genType y)
+	{
+		return fmod(vec<1, genType>(x), y).x;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fmod(vec<L, T, Q> const& x, T y)
+	{
+		return detail::compute_fmod<L, T, Q, std::numeric_limits<T>::is_iec559>::call(x, vec<L, T, Q>(y));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fmod(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+	{
+		return detail::compute_fmod<L, T, Q, std::numeric_limits<T>::is_iec559>::call(x, y);
+	}
+
+	template <length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, bool, Q> openBounded(vec<L, T, Q> const& Value, vec<L, T, Q> const& Min, vec<L, T, Q> const& Max)
+	{
+		return greaterThan(Value, Min) && lessThan(Value, Max);
+	}
+
+	template <length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, bool, Q> closeBounded(vec<L, T, Q> const& Value, vec<L, T, Q> const& Min, vec<L, T, Q> const& Max)
+	{
+		return greaterThanEqual(Value, Min) && lessThanEqual(Value, Max);
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/compatibility.hpp b/engine/inc/glm/gtx/compatibility.hpp
new file mode 100644
index 00000000..31147103
--- /dev/null
+++ b/engine/inc/glm/gtx/compatibility.hpp
@@ -0,0 +1,133 @@
+/// @ref gtx_compatibility
+/// @file glm/gtx/compatibility.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_compatibility GLM_GTX_compatibility
+/// @ingroup gtx
+///
+/// Include <glm/gtx/compatibility.hpp> to use the features of this extension.
+///
+/// Provide functions to increase the compatibility with Cg and HLSL languages
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtc/quaternion.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_compatibility is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_compatibility extension included")
+#endif
+
+#if GLM_COMPILER & GLM_COMPILER_VC
+#	include <cfloat>
+#elif GLM_COMPILER & GLM_COMPILER_GCC
+#	include <cmath>
+#	if(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
+#		undef isfinite
+#	endif
+#endif//GLM_COMPILER
+
+namespace glm
+{
+	/// @addtogroup gtx_compatibility
+	/// @{
+
+	template<typename T> GLM_FUNC_QUALIFIER T lerp(T x, T y, T a){return mix(x, y, a);}																					//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template<typename T, qualifier Q> GLM_FUNC_QUALIFIER vec<2, T, Q> lerp(const vec<2, T, Q>& x, const vec<2, T, Q>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+
+	template<typename T, qualifier Q> GLM_FUNC_QUALIFIER vec<3, T, Q> lerp(const vec<3, T, Q>& x, const vec<3, T, Q>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template<typename T, qualifier Q> GLM_FUNC_QUALIFIER vec<4, T, Q> lerp(const vec<4, T, Q>& x, const vec<4, T, Q>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template<typename T, qualifier Q> GLM_FUNC_QUALIFIER vec<2, T, Q> lerp(const vec<2, T, Q>& x, const vec<2, T, Q>& y, const vec<2, T, Q>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template<typename T, qualifier Q> GLM_FUNC_QUALIFIER vec<3, T, Q> lerp(const vec<3, T, Q>& x, const vec<3, T, Q>& y, const vec<3, T, Q>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template<typename T, qualifier Q> GLM_FUNC_QUALIFIER vec<4, T, Q> lerp(const vec<4, T, Q>& x, const vec<4, T, Q>& y, const vec<4, T, Q>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+
+	template<typename T, qualifier Q> GLM_FUNC_QUALIFIER T saturate(T x){return clamp(x, T(0), T(1));}														//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
+	template<typename T, qualifier Q> GLM_FUNC_QUALIFIER vec<2, T, Q> saturate(const vec<2, T, Q>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
+	template<typename T, qualifier Q> GLM_FUNC_QUALIFIER vec<3, T, Q> saturate(const vec<3, T, Q>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
+	template<typename T, qualifier Q> GLM_FUNC_QUALIFIER vec<4, T, Q> saturate(const vec<4, T, Q>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
+
+	template<typename T, qualifier Q> GLM_FUNC_QUALIFIER T atan2(T x, T y){return atan(x, y);}																//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
+	template<typename T, qualifier Q> GLM_FUNC_QUALIFIER vec<2, T, Q> atan2(const vec<2, T, Q>& x, const vec<2, T, Q>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
+	template<typename T, qualifier Q> GLM_FUNC_QUALIFIER vec<3, T, Q> atan2(const vec<3, T, Q>& x, const vec<3, T, Q>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
+	template<typename T, qualifier Q> GLM_FUNC_QUALIFIER vec<4, T, Q> atan2(const vec<4, T, Q>& x, const vec<4, T, Q>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
+
+	template<typename genType> GLM_FUNC_DECL bool isfinite(genType const& x);											//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
+	template<typename T, qualifier Q> GLM_FUNC_DECL vec<1, bool, Q> isfinite(const vec<1, T, Q>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
+	template<typename T, qualifier Q> GLM_FUNC_DECL vec<2, bool, Q> isfinite(const vec<2, T, Q>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
+	template<typename T, qualifier Q> GLM_FUNC_DECL vec<3, bool, Q> isfinite(const vec<3, T, Q>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
+	template<typename T, qualifier Q> GLM_FUNC_DECL vec<4, bool, Q> isfinite(const vec<4, T, Q>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
+
+	typedef bool						bool1;			//!< \brief boolean type with 1 component. (From GLM_GTX_compatibility extension)
+	typedef vec<2, bool, highp>			bool2;			//!< \brief boolean type with 2 components. (From GLM_GTX_compatibility extension)
+	typedef vec<3, bool, highp>			bool3;			//!< \brief boolean type with 3 components. (From GLM_GTX_compatibility extension)
+	typedef vec<4, bool, highp>			bool4;			//!< \brief boolean type with 4 components. (From GLM_GTX_compatibility extension)
+
+	typedef bool						bool1x1;		//!< \brief boolean matrix with 1 x 1 component. (From GLM_GTX_compatibility extension)
+	typedef mat<2, 2, bool, highp>		bool2x2;		//!< \brief boolean matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef mat<2, 3, bool, highp>		bool2x3;		//!< \brief boolean matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef mat<2, 4, bool, highp>		bool2x4;		//!< \brief boolean matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef mat<3, 2, bool, highp>		bool3x2;		//!< \brief boolean matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef mat<3, 3, bool, highp>		bool3x3;		//!< \brief boolean matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef mat<3, 4, bool, highp>		bool3x4;		//!< \brief boolean matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef mat<4, 2, bool, highp>		bool4x2;		//!< \brief boolean matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef mat<4, 3, bool, highp>		bool4x3;		//!< \brief boolean matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef mat<4, 4, bool, highp>		bool4x4;		//!< \brief boolean matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
+
+	typedef int							int1;			//!< \brief integer vector with 1 component. (From GLM_GTX_compatibility extension)
+	typedef vec<2, int, highp>			int2;			//!< \brief integer vector with 2 components. (From GLM_GTX_compatibility extension)
+	typedef vec<3, int, highp>			int3;			//!< \brief integer vector with 3 components. (From GLM_GTX_compatibility extension)
+	typedef vec<4, int, highp>			int4;			//!< \brief integer vector with 4 components. (From GLM_GTX_compatibility extension)
+
+	typedef int							int1x1;			//!< \brief integer matrix with 1 component. (From GLM_GTX_compatibility extension)
+	typedef mat<2, 2, int, highp>		int2x2;			//!< \brief integer matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef mat<2, 3, int, highp>		int2x3;			//!< \brief integer matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef mat<2, 4, int, highp>		int2x4;			//!< \brief integer matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef mat<3, 2, int, highp>		int3x2;			//!< \brief integer matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef mat<3, 3, int, highp>		int3x3;			//!< \brief integer matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef mat<3, 4, int, highp>		int3x4;			//!< \brief integer matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef mat<4, 2, int, highp>		int4x2;			//!< \brief integer matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef mat<4, 3, int, highp>		int4x3;			//!< \brief integer matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef mat<4, 4, int, highp>		int4x4;			//!< \brief integer matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
+
+	typedef float						float1;			//!< \brief single-qualifier floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
+	typedef vec<2, float, highp>		float2;			//!< \brief single-qualifier floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
+	typedef vec<3, float, highp>		float3;			//!< \brief single-qualifier floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
+	typedef vec<4, float, highp>		float4;			//!< \brief single-qualifier floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
+
+	typedef float						float1x1;		//!< \brief single-qualifier floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
+	typedef mat<2, 2, float, highp>		float2x2;		//!< \brief single-qualifier floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef mat<2, 3, float, highp>		float2x3;		//!< \brief single-qualifier floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef mat<2, 4, float, highp>		float2x4;		//!< \brief single-qualifier floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef mat<3, 2, float, highp>		float3x2;		//!< \brief single-qualifier floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef mat<3, 3, float, highp>		float3x3;		//!< \brief single-qualifier floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef mat<3, 4, float, highp>		float3x4;		//!< \brief single-qualifier floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef mat<4, 2, float, highp>		float4x2;		//!< \brief single-qualifier floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef mat<4, 3, float, highp>		float4x3;		//!< \brief single-qualifier floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef mat<4, 4, float, highp>		float4x4;		//!< \brief single-qualifier floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
+
+	typedef double						double1;		//!< \brief double-qualifier floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
+	typedef vec<2, double, highp>		double2;		//!< \brief double-qualifier floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
+	typedef vec<3, double, highp>		double3;		//!< \brief double-qualifier floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
+	typedef vec<4, double, highp>		double4;		//!< \brief double-qualifier floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
+
+	typedef double						double1x1;		//!< \brief double-qualifier floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
+	typedef mat<2, 2, double, highp>		double2x2;		//!< \brief double-qualifier floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef mat<2, 3, double, highp>		double2x3;		//!< \brief double-qualifier floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef mat<2, 4, double, highp>		double2x4;		//!< \brief double-qualifier floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef mat<3, 2, double, highp>		double3x2;		//!< \brief double-qualifier floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef mat<3, 3, double, highp>		double3x3;		//!< \brief double-qualifier floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef mat<3, 4, double, highp>		double3x4;		//!< \brief double-qualifier floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef mat<4, 2, double, highp>		double4x2;		//!< \brief double-qualifier floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef mat<4, 3, double, highp>		double4x3;		//!< \brief double-qualifier floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef mat<4, 4, double, highp>		double4x4;		//!< \brief double-qualifier floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
+
+	/// @}
+}//namespace glm
+
+#include "compatibility.inl"
diff --git a/engine/inc/glm/gtx/compatibility.inl b/engine/inc/glm/gtx/compatibility.inl
new file mode 100644
index 00000000..1d49496b
--- /dev/null
+++ b/engine/inc/glm/gtx/compatibility.inl
@@ -0,0 +1,62 @@
+#include <limits>
+
+namespace glm
+{
+	// isfinite
+	template<typename genType>
+	GLM_FUNC_QUALIFIER bool isfinite(
+		genType const& x)
+	{
+#		if GLM_HAS_CXX11_STL
+			return std::isfinite(x) != 0;
+#		elif GLM_COMPILER & GLM_COMPILER_VC
+			return _finite(x) != 0;
+#		elif GLM_COMPILER & GLM_COMPILER_GCC && GLM_PLATFORM & GLM_PLATFORM_ANDROID
+			return _isfinite(x) != 0;
+#		else
+			if (std::numeric_limits<genType>::is_integer || std::denorm_absent == std::numeric_limits<genType>::has_denorm)
+				return std::numeric_limits<genType>::min() <= x && std::numeric_limits<genType>::max() >= x;
+			else
+				return -std::numeric_limits<genType>::max() <= x && std::numeric_limits<genType>::max() >= x;
+#		endif
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<1, bool, Q> isfinite(
+		vec<1, T, Q> const& x)
+	{
+		return vec<1, bool, Q>(
+			isfinite(x.x));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<2, bool, Q> isfinite(
+		vec<2, T, Q> const& x)
+	{
+		return vec<2, bool, Q>(
+			isfinite(x.x),
+			isfinite(x.y));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, bool, Q> isfinite(
+		vec<3, T, Q> const& x)
+	{
+		return vec<3, bool, Q>(
+			isfinite(x.x),
+			isfinite(x.y),
+			isfinite(x.z));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, bool, Q> isfinite(
+		vec<4, T, Q> const& x)
+	{
+		return vec<4, bool, Q>(
+			isfinite(x.x),
+			isfinite(x.y),
+			isfinite(x.z),
+			isfinite(x.w));
+	}
+
+}//namespace glm
diff --git a/engine/inc/glm/gtx/component_wise.hpp b/engine/inc/glm/gtx/component_wise.hpp
new file mode 100644
index 00000000..717ae82c
--- /dev/null
+++ b/engine/inc/glm/gtx/component_wise.hpp
@@ -0,0 +1,69 @@
+/// @ref gtx_component_wise
+/// @file glm/gtx/component_wise.hpp
+/// @date 2007-05-21 / 2011-06-07
+/// @author Christophe Riccio
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_component_wise GLM_GTX_component_wise
+/// @ingroup gtx
+///
+/// Include <glm/gtx/component_wise.hpp> to use the features of this extension.
+///
+/// Operations between components of a type
+
+#pragma once
+
+// Dependencies
+#include "../detail/setup.hpp"
+#include "../detail/qualifier.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_component_wise is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_component_wise extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_component_wise
+	/// @{
+
+	/// Convert an integer vector to a normalized float vector.
+	/// If the parameter value type is already a floating qualifier type, the value is passed through.
+	/// @see gtx_component_wise
+	template<typename floatType, length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, floatType, Q> compNormalize(vec<L, T, Q> const& v);
+
+	/// Convert a normalized float vector to an integer vector.
+	/// If the parameter value type is already a floating qualifier type, the value is passed through.
+	/// @see gtx_component_wise
+	template<length_t L, typename T, typename floatType, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> compScale(vec<L, floatType, Q> const& v);
+
+	/// Add all vector components together.
+	/// @see gtx_component_wise
+	template<typename genType>
+	GLM_FUNC_DECL typename genType::value_type compAdd(genType const& v);
+
+	/// Multiply all vector components together.
+	/// @see gtx_component_wise
+	template<typename genType>
+	GLM_FUNC_DECL typename genType::value_type compMul(genType const& v);
+
+	/// Find the minimum value between single vector components.
+	/// @see gtx_component_wise
+	template<typename genType>
+	GLM_FUNC_DECL typename genType::value_type compMin(genType const& v);
+
+	/// Find the maximum value between single vector components.
+	/// @see gtx_component_wise
+	template<typename genType>
+	GLM_FUNC_DECL typename genType::value_type compMax(genType const& v);
+
+	/// @}
+}//namespace glm
+
+#include "component_wise.inl"
diff --git a/engine/inc/glm/gtx/component_wise.inl b/engine/inc/glm/gtx/component_wise.inl
new file mode 100644
index 00000000..cbbc7d41
--- /dev/null
+++ b/engine/inc/glm/gtx/component_wise.inl
@@ -0,0 +1,127 @@
+/// @ref gtx_component_wise
+
+#include <limits>
+
+namespace glm{
+namespace detail
+{
+	template<length_t L, typename T, typename floatType, qualifier Q, bool isInteger, bool signedType>
+	struct compute_compNormalize
+	{};
+
+	template<length_t L, typename T, typename floatType, qualifier Q>
+	struct compute_compNormalize<L, T, floatType, Q, true, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, floatType, Q> call(vec<L, T, Q> const& v)
+		{
+			floatType const Min = static_cast<floatType>(std::numeric_limits<T>::min());
+			floatType const Max = static_cast<floatType>(std::numeric_limits<T>::max());
+			return (vec<L, floatType, Q>(v) - Min) / (Max - Min) * static_cast<floatType>(2) - static_cast<floatType>(1);
+		}
+	};
+
+	template<length_t L, typename T, typename floatType, qualifier Q>
+	struct compute_compNormalize<L, T, floatType, Q, true, false>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, floatType, Q> call(vec<L, T, Q> const& v)
+		{
+			return vec<L, floatType, Q>(v) / static_cast<floatType>(std::numeric_limits<T>::max());
+		}
+	};
+
+	template<length_t L, typename T, typename floatType, qualifier Q>
+	struct compute_compNormalize<L, T, floatType, Q, false, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, floatType, Q> call(vec<L, T, Q> const& v)
+		{
+			return v;
+		}
+	};
+
+	template<length_t L, typename T, typename floatType, qualifier Q, bool isInteger, bool signedType>
+	struct compute_compScale
+	{};
+
+	template<length_t L, typename T, typename floatType, qualifier Q>
+	struct compute_compScale<L, T, floatType, Q, true, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, floatType, Q> const& v)
+		{
+			floatType const Max = static_cast<floatType>(std::numeric_limits<T>::max()) + static_cast<floatType>(0.5);
+			vec<L, floatType, Q> const Scaled(v * Max);
+			vec<L, T, Q> const Result(Scaled - static_cast<floatType>(0.5));
+			return Result;
+		}
+	};
+
+	template<length_t L, typename T, typename floatType, qualifier Q>
+	struct compute_compScale<L, T, floatType, Q, true, false>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, floatType, Q> const& v)
+		{
+			return vec<L, T, Q>(vec<L, floatType, Q>(v) * static_cast<floatType>(std::numeric_limits<T>::max()));
+		}
+	};
+
+	template<length_t L, typename T, typename floatType, qualifier Q>
+	struct compute_compScale<L, T, floatType, Q, false, true>
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, floatType, Q> const& v)
+		{
+			return v;
+		}
+	};
+}//namespace detail
+
+	template<typename floatType, length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, floatType, Q> compNormalize(vec<L, T, Q> const& v)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<floatType>::is_iec559, "'compNormalize' accepts only floating-point types for 'floatType' template parameter");
+
+		return detail::compute_compNormalize<L, T, floatType, Q, std::numeric_limits<T>::is_integer, std::numeric_limits<T>::is_signed>::call(v);
+	}
+
+	template<typename T, length_t L, typename floatType, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> compScale(vec<L, floatType, Q> const& v)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<floatType>::is_iec559, "'compScale' accepts only floating-point types for 'floatType' template parameter");
+
+		return detail::compute_compScale<L, T, floatType, Q, std::numeric_limits<T>::is_integer, std::numeric_limits<T>::is_signed>::call(v);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T compAdd(vec<L, T, Q> const& v)
+	{
+		T Result(0);
+		for(length_t i = 0, n = v.length(); i < n; ++i)
+			Result += v[i];
+		return Result;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T compMul(vec<L, T, Q> const& v)
+	{
+		T Result(1);
+		for(length_t i = 0, n = v.length(); i < n; ++i)
+			Result *= v[i];
+		return Result;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T compMin(vec<L, T, Q> const& v)
+	{
+		T Result(v[0]);
+		for(length_t i = 1, n = v.length(); i < n; ++i)
+			Result = min(Result, v[i]);
+		return Result;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T compMax(vec<L, T, Q> const& v)
+	{
+		T Result(v[0]);
+		for(length_t i = 1, n = v.length(); i < n; ++i)
+			Result = max(Result, v[i]);
+		return Result;
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/dual_quaternion.hpp b/engine/inc/glm/gtx/dual_quaternion.hpp
new file mode 100644
index 00000000..1732b7dc
--- /dev/null
+++ b/engine/inc/glm/gtx/dual_quaternion.hpp
@@ -0,0 +1,274 @@
+/// @ref gtx_dual_quaternion
+/// @file glm/gtx/dual_quaternion.hpp
+/// @author Maksim Vorobiev (msomeone@gmail.com)
+///
+/// @see core (dependence)
+/// @see gtc_constants (dependence)
+/// @see gtc_quaternion (dependence)
+///
+/// @defgroup gtx_dual_quaternion GLM_GTX_dual_quaternion
+/// @ingroup gtx
+///
+/// Include <glm/gtx/dual_quaternion.hpp> to use the features of this extension.
+///
+/// Defines a templated dual-quaternion type and several dual-quaternion operations.
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtc/constants.hpp"
+#include "../gtc/quaternion.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_dual_quaternion is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_dual_quaternion extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_dual_quaternion
+	/// @{
+
+	template<typename T, qualifier Q = defaultp>
+	struct tdualquat
+	{
+		// -- Implementation detail --
+
+		typedef T value_type;
+		typedef qua<T, Q> part_type;
+
+		// -- Data --
+
+		qua<T, Q> real, dual;
+
+		// -- Component accesses --
+
+		typedef length_t length_type;
+		/// Return the count of components of a dual quaternion
+		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 2;}
+
+		GLM_FUNC_DECL part_type & operator[](length_type i);
+		GLM_FUNC_DECL part_type const& operator[](length_type i) const;
+
+		// -- Implicit basic constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR tdualquat() GLM_DEFAULT;
+		GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(tdualquat<T, Q> const& d) GLM_DEFAULT;
+		template<qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(tdualquat<T, P> const& d);
+
+		// -- Explicit basic constructors --
+
+		GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(qua<T, Q> const& real);
+		GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(qua<T, Q> const& orientation, vec<3, T, Q> const& translation);
+		GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(qua<T, Q> const& real, qua<T, Q> const& dual);
+
+		// -- Conversion constructors --
+
+		template<typename U, qualifier P>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tdualquat(tdualquat<U, P> const& q);
+
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR tdualquat(mat<2, 4, T, Q> const& holder_mat);
+		GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR tdualquat(mat<3, 4, T, Q> const& aug_mat);
+
+		// -- Unary arithmetic operators --
+
+		GLM_FUNC_DECL tdualquat<T, Q> & operator=(tdualquat<T, Q> const& m) GLM_DEFAULT;
+
+		template<typename U>
+		GLM_FUNC_DECL tdualquat<T, Q> & operator=(tdualquat<U, Q> const& m);
+		template<typename U>
+		GLM_FUNC_DECL tdualquat<T, Q> & operator*=(U s);
+		template<typename U>
+		GLM_FUNC_DECL tdualquat<T, Q> & operator/=(U s);
+	};
+
+	// -- Unary bit operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL tdualquat<T, Q> operator+(tdualquat<T, Q> const& q);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL tdualquat<T, Q> operator-(tdualquat<T, Q> const& q);
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL tdualquat<T, Q> operator+(tdualquat<T, Q> const& q, tdualquat<T, Q> const& p);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL tdualquat<T, Q> operator*(tdualquat<T, Q> const& q, tdualquat<T, Q> const& p);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> operator*(tdualquat<T, Q> const& q, vec<3, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> operator*(vec<3, T, Q> const& v, tdualquat<T, Q> const& q);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<4, T, Q> operator*(tdualquat<T, Q> const& q, vec<4, T, Q> const& v);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<4, T, Q> operator*(vec<4, T, Q> const& v, tdualquat<T, Q> const& q);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL tdualquat<T, Q> operator*(tdualquat<T, Q> const& q, T const& s);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL tdualquat<T, Q> operator*(T const& s, tdualquat<T, Q> const& q);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL tdualquat<T, Q> operator/(tdualquat<T, Q> const& q, T const& s);
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator==(tdualquat<T, Q> const& q1, tdualquat<T, Q> const& q2);
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool operator!=(tdualquat<T, Q> const& q1, tdualquat<T, Q> const& q2);
+
+	/// Creates an identity dual quaternion.
+	///
+	/// @see gtx_dual_quaternion
+	template <typename T, qualifier Q>
+	GLM_FUNC_DECL tdualquat<T, Q> dual_quat_identity();
+
+	/// Returns the normalized quaternion.
+	///
+	/// @see gtx_dual_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL tdualquat<T, Q> normalize(tdualquat<T, Q> const& q);
+
+	/// Returns the linear interpolation of two dual quaternion.
+	///
+	/// @see gtc_dual_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL tdualquat<T, Q> lerp(tdualquat<T, Q> const& x, tdualquat<T, Q> const& y, T const& a);
+
+	/// Returns the q inverse.
+	///
+	/// @see gtx_dual_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL tdualquat<T, Q> inverse(tdualquat<T, Q> const& q);
+
+	/// Converts a quaternion to a 2 * 4 matrix.
+	///
+	/// @see gtx_dual_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 4, T, Q> mat2x4_cast(tdualquat<T, Q> const& x);
+
+	/// Converts a quaternion to a 3 * 4 matrix.
+	///
+	/// @see gtx_dual_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 4, T, Q> mat3x4_cast(tdualquat<T, Q> const& x);
+
+	/// Converts a 2 * 4 matrix (matrix which holds real and dual parts) to a quaternion.
+	///
+	/// @see gtx_dual_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL tdualquat<T, Q> dualquat_cast(mat<2, 4, T, Q> const& x);
+
+	/// Converts a 3 * 4 matrix (augmented matrix rotation + translation) to a quaternion.
+	///
+	/// @see gtx_dual_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL tdualquat<T, Q> dualquat_cast(mat<3, 4, T, Q> const& x);
+
+
+	/// Dual-quaternion of low single-qualifier floating-point numbers.
+	///
+	/// @see gtx_dual_quaternion
+	typedef tdualquat<float, lowp>		lowp_dualquat;
+
+	/// Dual-quaternion of medium single-qualifier floating-point numbers.
+	///
+	/// @see gtx_dual_quaternion
+	typedef tdualquat<float, mediump>	mediump_dualquat;
+
+	/// Dual-quaternion of high single-qualifier floating-point numbers.
+	///
+	/// @see gtx_dual_quaternion
+	typedef tdualquat<float, highp>		highp_dualquat;
+
+
+	/// Dual-quaternion of low single-qualifier floating-point numbers.
+	///
+	/// @see gtx_dual_quaternion
+	typedef tdualquat<float, lowp>		lowp_fdualquat;
+
+	/// Dual-quaternion of medium single-qualifier floating-point numbers.
+	///
+	/// @see gtx_dual_quaternion
+	typedef tdualquat<float, mediump>	mediump_fdualquat;
+
+	/// Dual-quaternion of high single-qualifier floating-point numbers.
+	///
+	/// @see gtx_dual_quaternion
+	typedef tdualquat<float, highp>		highp_fdualquat;
+
+
+	/// Dual-quaternion of low double-qualifier floating-point numbers.
+	///
+	/// @see gtx_dual_quaternion
+	typedef tdualquat<double, lowp>		lowp_ddualquat;
+
+	/// Dual-quaternion of medium double-qualifier floating-point numbers.
+	///
+	/// @see gtx_dual_quaternion
+	typedef tdualquat<double, mediump>	mediump_ddualquat;
+
+	/// Dual-quaternion of high double-qualifier floating-point numbers.
+	///
+	/// @see gtx_dual_quaternion
+	typedef tdualquat<double, highp>	highp_ddualquat;
+
+
+#if(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
+	/// Dual-quaternion of floating-point numbers.
+	///
+	/// @see gtx_dual_quaternion
+	typedef highp_fdualquat			dualquat;
+
+	/// Dual-quaternion of single-qualifier floating-point numbers.
+	///
+	/// @see gtx_dual_quaternion
+	typedef highp_fdualquat			fdualquat;
+#elif(defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
+	typedef highp_fdualquat			dualquat;
+	typedef highp_fdualquat			fdualquat;
+#elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
+	typedef mediump_fdualquat		dualquat;
+	typedef mediump_fdualquat		fdualquat;
+#elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && defined(GLM_PRECISION_LOWP_FLOAT))
+	typedef lowp_fdualquat			dualquat;
+	typedef lowp_fdualquat			fdualquat;
+#else
+#	error "GLM error: multiple default precision requested for single-precision floating-point types"
+#endif
+
+
+#if(!defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE))
+	/// Dual-quaternion of default double-qualifier floating-point numbers.
+	///
+	/// @see gtx_dual_quaternion
+	typedef highp_ddualquat			ddualquat;
+#elif(defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE))
+	typedef highp_ddualquat			ddualquat;
+#elif(!defined(GLM_PRECISION_HIGHP_DOUBLE) && defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE))
+	typedef mediump_ddualquat		ddualquat;
+#elif(!defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && defined(GLM_PRECISION_LOWP_DOUBLE))
+	typedef lowp_ddualquat			ddualquat;
+#else
+#	error "GLM error: Multiple default precision requested for double-precision floating-point types"
+#endif
+
+	/// @}
+} //namespace glm
+
+#include "dual_quaternion.inl"
diff --git a/engine/inc/glm/gtx/dual_quaternion.inl b/engine/inc/glm/gtx/dual_quaternion.inl
new file mode 100644
index 00000000..fad07ea8
--- /dev/null
+++ b/engine/inc/glm/gtx/dual_quaternion.inl
@@ -0,0 +1,352 @@
+/// @ref gtx_dual_quaternion
+
+#include "../geometric.hpp"
+#include <limits>
+
+namespace glm
+{
+	// -- Component accesses --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename tdualquat<T, Q>::part_type & tdualquat<T, Q>::operator[](typename tdualquat<T, Q>::length_type i)
+	{
+		assert(i >= 0 && i < this->length());
+		return (&real)[i];
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER typename tdualquat<T, Q>::part_type const& tdualquat<T, Q>::operator[](typename tdualquat<T, Q>::length_type i) const
+	{
+		assert(i >= 0 && i < this->length());
+		return (&real)[i];
+	}
+
+	// -- Implicit basic constructors --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat<T, Q>::tdualquat()
+#			if GLM_CONFIG_DEFAULTED_FUNCTIONS != GLM_DISABLE
+			: real(qua<T, Q>())
+			, dual(qua<T, Q>(0, 0, 0, 0))
+#			endif
+		{}
+
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat<T, Q>::tdualquat(tdualquat<T, Q> const& d)
+			: real(d.real)
+			, dual(d.dual)
+		{}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat<T, Q>::tdualquat(tdualquat<T, P> const& d)
+		: real(d.real)
+		, dual(d.dual)
+	{}
+
+	// -- Explicit basic constructors --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat<T, Q>::tdualquat(qua<T, Q> const& r)
+		: real(r), dual(qua<T, Q>(0, 0, 0, 0))
+	{}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat<T, Q>::tdualquat(qua<T, Q> const& q, vec<3, T, Q> const& p)
+		: real(q), dual(
+			T(-0.5) * ( p.x*q.x + p.y*q.y + p.z*q.z),
+			T(+0.5) * ( p.x*q.w + p.y*q.z - p.z*q.y),
+			T(+0.5) * (-p.x*q.z + p.y*q.w + p.z*q.x),
+			T(+0.5) * ( p.x*q.y - p.y*q.x + p.z*q.w))
+	{}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat<T, Q>::tdualquat(qua<T, Q> const& r, qua<T, Q> const& d)
+		: real(r), dual(d)
+	{}
+
+	// -- Conversion constructors --
+
+	template<typename T, qualifier Q>
+	template<typename U, qualifier P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat<T, Q>::tdualquat(tdualquat<U, P> const& q)
+		: real(q.real)
+		, dual(q.dual)
+	{}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat<T, Q>::tdualquat(mat<2, 4, T, Q> const& m)
+	{
+		*this = dualquat_cast(m);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat<T, Q>::tdualquat(mat<3, 4, T, Q> const& m)
+	{
+		*this = dualquat_cast(m);
+	}
+
+	// -- Unary arithmetic operators --
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER tdualquat<T, Q> & tdualquat<T, Q>::operator=(tdualquat<T, Q> const& q)
+		{
+			this->real = q.real;
+			this->dual = q.dual;
+			return *this;
+		}
+#	endif
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER tdualquat<T, Q> & tdualquat<T, Q>::operator=(tdualquat<U, Q> const& q)
+	{
+		this->real = q.real;
+		this->dual = q.dual;
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER tdualquat<T, Q> & tdualquat<T, Q>::operator*=(U s)
+	{
+		this->real *= static_cast<T>(s);
+		this->dual *= static_cast<T>(s);
+		return *this;
+	}
+
+	template<typename T, qualifier Q>
+	template<typename U>
+	GLM_FUNC_QUALIFIER tdualquat<T, Q> & tdualquat<T, Q>::operator/=(U s)
+	{
+		this->real /= static_cast<T>(s);
+		this->dual /= static_cast<T>(s);
+		return *this;
+	}
+
+	// -- Unary bit operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER tdualquat<T, Q> operator+(tdualquat<T, Q> const& q)
+	{
+		return q;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER tdualquat<T, Q> operator-(tdualquat<T, Q> const& q)
+	{
+		return tdualquat<T, Q>(-q.real, -q.dual);
+	}
+
+	// -- Binary operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER tdualquat<T, Q> operator+(tdualquat<T, Q> const& q, tdualquat<T, Q> const& p)
+	{
+		return tdualquat<T, Q>(q.real + p.real,q.dual + p.dual);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER tdualquat<T, Q> operator*(tdualquat<T, Q> const& p, tdualquat<T, Q> const& o)
+	{
+		return tdualquat<T, Q>(p.real * o.real,p.real * o.dual + p.dual * o.real);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> operator*(tdualquat<T, Q> const& q, vec<3, T, Q> const& v)
+	{
+		vec<3, T, Q> const real_v3(q.real.x,q.real.y,q.real.z);
+		vec<3, T, Q> const dual_v3(q.dual.x,q.dual.y,q.dual.z);
+		return (cross(real_v3, cross(real_v3,v) + v * q.real.w + dual_v3) + dual_v3 * q.real.w - real_v3 * q.dual.w) * T(2) + v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> operator*(vec<3, T, Q> const& v,	tdualquat<T, Q> const& q)
+	{
+		return glm::inverse(q) * v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, T, Q> operator*(tdualquat<T, Q> const& q, vec<4, T, Q> const& v)
+	{
+		return vec<4, T, Q>(q * vec<3, T, Q>(v), v.w);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, T, Q> operator*(vec<4, T, Q> const& v,	tdualquat<T, Q> const& q)
+	{
+		return glm::inverse(q) * v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER tdualquat<T, Q> operator*(tdualquat<T, Q> const& q, T const& s)
+	{
+		return tdualquat<T, Q>(q.real * s, q.dual * s);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER tdualquat<T, Q> operator*(T const& s, tdualquat<T, Q> const& q)
+	{
+		return q * s;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER tdualquat<T, Q> operator/(tdualquat<T, Q> const& q,	T const& s)
+	{
+		return tdualquat<T, Q>(q.real / s, q.dual / s);
+	}
+
+	// -- Boolean operators --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator==(tdualquat<T, Q> const& q1, tdualquat<T, Q> const& q2)
+	{
+		return (q1.real == q2.real) && (q1.dual == q2.dual);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool operator!=(tdualquat<T, Q> const& q1, tdualquat<T, Q> const& q2)
+	{
+		return (q1.real != q2.real) || (q1.dual != q2.dual);
+	}
+
+	// -- Operations --
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER tdualquat<T, Q> dual_quat_identity()
+	{
+		return tdualquat<T, Q>(
+			qua<T, Q>(static_cast<T>(1), static_cast<T>(0), static_cast<T>(0), static_cast<T>(0)),
+			qua<T, Q>(static_cast<T>(0), static_cast<T>(0), static_cast<T>(0), static_cast<T>(0)));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER tdualquat<T, Q> normalize(tdualquat<T, Q> const& q)
+	{
+		return q / length(q.real);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER tdualquat<T, Q> lerp(tdualquat<T, Q> const& x, tdualquat<T, Q> const& y, T const& a)
+	{
+		// Dual Quaternion Linear blend aka DLB:
+		// Lerp is only defined in [0, 1]
+		assert(a >= static_cast<T>(0));
+		assert(a <= static_cast<T>(1));
+		T const k = dot(x.real,y.real) < static_cast<T>(0) ? -a : a;
+		T const one(1);
+		return tdualquat<T, Q>(x * (one - a) + y * k);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER tdualquat<T, Q> inverse(tdualquat<T, Q> const& q)
+	{
+		const glm::qua<T, Q> real = conjugate(q.real);
+		const glm::qua<T, Q> dual = conjugate(q.dual);
+		return tdualquat<T, Q>(real, dual + (real * (-2.0f * dot(real,dual))));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> mat2x4_cast(tdualquat<T, Q> const& x)
+	{
+		return mat<2, 4, T, Q>( x[0].x, x[0].y, x[0].z, x[0].w, x[1].x, x[1].y, x[1].z, x[1].w );
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> mat3x4_cast(tdualquat<T, Q> const& x)
+	{
+		qua<T, Q> r = x.real / length2(x.real);
+
+		qua<T, Q> const rr(r.w * x.real.w, r.x * x.real.x, r.y * x.real.y, r.z * x.real.z);
+		r *= static_cast<T>(2);
+
+		T const xy = r.x * x.real.y;
+		T const xz = r.x * x.real.z;
+		T const yz = r.y * x.real.z;
+		T const wx = r.w * x.real.x;
+		T const wy = r.w * x.real.y;
+		T const wz = r.w * x.real.z;
+
+		vec<4, T, Q> const a(
+			rr.w + rr.x - rr.y - rr.z,
+			xy - wz,
+			xz + wy,
+			-(x.dual.w * r.x - x.dual.x * r.w + x.dual.y * r.z - x.dual.z * r.y));
+
+		vec<4, T, Q> const b(
+			xy + wz,
+			rr.w + rr.y - rr.x - rr.z,
+			yz - wx,
+			-(x.dual.w * r.y - x.dual.x * r.z - x.dual.y * r.w + x.dual.z * r.x));
+
+		vec<4, T, Q> const c(
+			xz - wy,
+			yz + wx,
+			rr.w + rr.z - rr.x - rr.y,
+			-(x.dual.w * r.z + x.dual.x * r.y - x.dual.y * r.x - x.dual.z * r.w));
+
+		return mat<3, 4, T, Q>(a, b, c);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER tdualquat<T, Q> dualquat_cast(mat<2, 4, T, Q> const& x)
+	{
+		return tdualquat<T, Q>(
+			qua<T, Q>( x[0].w, x[0].x, x[0].y, x[0].z ),
+			qua<T, Q>( x[1].w, x[1].x, x[1].y, x[1].z ));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER tdualquat<T, Q> dualquat_cast(mat<3, 4, T, Q> const& x)
+	{
+		qua<T, Q> real;
+
+		T const trace = x[0].x + x[1].y + x[2].z;
+		if(trace > static_cast<T>(0))
+		{
+			T const r = sqrt(T(1) + trace);
+			T const invr = static_cast<T>(0.5) / r;
+			real.w = static_cast<T>(0.5) * r;
+			real.x = (x[2].y - x[1].z) * invr;
+			real.y = (x[0].z - x[2].x) * invr;
+			real.z = (x[1].x - x[0].y) * invr;
+		}
+		else if(x[0].x > x[1].y && x[0].x > x[2].z)
+		{
+			T const r = sqrt(T(1) + x[0].x - x[1].y - x[2].z);
+			T const invr = static_cast<T>(0.5) / r;
+			real.x = static_cast<T>(0.5)*r;
+			real.y = (x[1].x + x[0].y) * invr;
+			real.z = (x[0].z + x[2].x) * invr;
+			real.w = (x[2].y - x[1].z) * invr;
+		}
+		else if(x[1].y > x[2].z)
+		{
+			T const r = sqrt(T(1) + x[1].y - x[0].x - x[2].z);
+			T const invr = static_cast<T>(0.5) / r;
+			real.x = (x[1].x + x[0].y) * invr;
+			real.y = static_cast<T>(0.5) * r;
+			real.z = (x[2].y + x[1].z) * invr;
+			real.w = (x[0].z - x[2].x) * invr;
+		}
+		else
+		{
+			T const r = sqrt(T(1) + x[2].z - x[0].x - x[1].y);
+			T const invr = static_cast<T>(0.5) / r;
+			real.x = (x[0].z + x[2].x) * invr;
+			real.y = (x[2].y + x[1].z) * invr;
+			real.z = static_cast<T>(0.5) * r;
+			real.w = (x[1].x - x[0].y) * invr;
+		}
+
+		qua<T, Q> dual;
+		dual.x =  static_cast<T>(0.5) * ( x[0].w * real.w + x[1].w * real.z - x[2].w * real.y);
+		dual.y =  static_cast<T>(0.5) * (-x[0].w * real.z + x[1].w * real.w + x[2].w * real.x);
+		dual.z =  static_cast<T>(0.5) * ( x[0].w * real.y - x[1].w * real.x + x[2].w * real.w);
+		dual.w = -static_cast<T>(0.5) * ( x[0].w * real.x + x[1].w * real.y + x[2].w * real.z);
+		return tdualquat<T, Q>(real, dual);
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/easing.hpp b/engine/inc/glm/gtx/easing.hpp
new file mode 100644
index 00000000..eec96c4b
--- /dev/null
+++ b/engine/inc/glm/gtx/easing.hpp
@@ -0,0 +1,219 @@
+/// @ref gtx_easing
+/// @file glm/gtx/easing.hpp
+/// @author Robert Chisholm
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_easing GLM_GTX_easing
+/// @ingroup gtx
+///
+/// Include <glm/gtx/easing.hpp> to use the features of this extension.
+///
+/// Easing functions for animations and transitons
+/// All functions take a parameter x in the range [0.0,1.0]
+///
+/// Based on the AHEasing project of Warren Moore (https://github.com/warrenm/AHEasing)
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtc/constants.hpp"
+#include "../detail/qualifier.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_easing is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_easing extension included")
+#endif
+
+namespace glm{
+	/// @addtogroup gtx_easing
+	/// @{
+
+	/// Modelled after the line y = x
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType linearInterpolation(genType const & a);
+
+	/// Modelled after the parabola y = x^2
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType quadraticEaseIn(genType const & a);
+
+	/// Modelled after the parabola y = -x^2 + 2x
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType quadraticEaseOut(genType const & a);
+
+	/// Modelled after the piecewise quadratic
+	/// y = (1/2)((2x)^2)				; [0, 0.5)
+	/// y = -(1/2)((2x-1)*(2x-3) - 1)	; [0.5, 1]
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType quadraticEaseInOut(genType const & a);
+
+	/// Modelled after the cubic y = x^3
+	template <typename genType>
+	GLM_FUNC_DECL genType cubicEaseIn(genType const & a);
+
+	/// Modelled after the cubic y = (x - 1)^3 + 1
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType cubicEaseOut(genType const & a);
+
+	/// Modelled after the piecewise cubic
+	/// y = (1/2)((2x)^3)		; [0, 0.5)
+	/// y = (1/2)((2x-2)^3 + 2)	; [0.5, 1]
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType cubicEaseInOut(genType const & a);
+
+	/// Modelled after the quartic x^4
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType quarticEaseIn(genType const & a);
+
+	/// Modelled after the quartic y = 1 - (x - 1)^4
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType quarticEaseOut(genType const & a);
+
+	/// Modelled after the piecewise quartic
+	/// y = (1/2)((2x)^4)			; [0, 0.5)
+	/// y = -(1/2)((2x-2)^4 - 2)	; [0.5, 1]
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType quarticEaseInOut(genType const & a);
+
+	/// Modelled after the quintic y = x^5
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType quinticEaseIn(genType const & a);
+
+	/// Modelled after the quintic y = (x - 1)^5 + 1
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType quinticEaseOut(genType const & a);
+
+	/// Modelled after the piecewise quintic
+	/// y = (1/2)((2x)^5)		; [0, 0.5)
+	/// y = (1/2)((2x-2)^5 + 2) ; [0.5, 1]
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType quinticEaseInOut(genType const & a);
+
+	/// Modelled after quarter-cycle of sine wave
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType sineEaseIn(genType const & a);
+
+	/// Modelled after quarter-cycle of sine wave (different phase)
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType sineEaseOut(genType const & a);
+
+	/// Modelled after half sine wave
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType sineEaseInOut(genType const & a);
+
+	/// Modelled after shifted quadrant IV of unit circle
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType circularEaseIn(genType const & a);
+
+	/// Modelled after shifted quadrant II of unit circle
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType circularEaseOut(genType const & a);
+
+	/// Modelled after the piecewise circular function
+	/// y = (1/2)(1 - sqrt(1 - 4x^2))			; [0, 0.5)
+	/// y = (1/2)(sqrt(-(2x - 3)*(2x - 1)) + 1) ; [0.5, 1]
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType circularEaseInOut(genType const & a);
+
+	/// Modelled after the exponential function y = 2^(10(x - 1))
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType exponentialEaseIn(genType const & a);
+
+	/// Modelled after the exponential function y = -2^(-10x) + 1
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType exponentialEaseOut(genType const & a);
+
+	/// Modelled after the piecewise exponential
+	/// y = (1/2)2^(10(2x - 1))			; [0,0.5)
+	/// y = -(1/2)*2^(-10(2x - 1))) + 1 ; [0.5,1]
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType exponentialEaseInOut(genType const & a);
+
+	/// Modelled after the damped sine wave y = sin(13pi/2*x)*pow(2, 10 * (x - 1))
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType elasticEaseIn(genType const & a);
+
+	/// Modelled after the damped sine wave y = sin(-13pi/2*(x + 1))*pow(2, -10x) + 1
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType elasticEaseOut(genType const & a);
+
+	/// Modelled after the piecewise exponentially-damped sine wave:
+	/// y = (1/2)*sin(13pi/2*(2*x))*pow(2, 10 * ((2*x) - 1))		; [0,0.5)
+	/// y = (1/2)*(sin(-13pi/2*((2x-1)+1))*pow(2,-10(2*x-1)) + 2)	; [0.5, 1]
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType elasticEaseInOut(genType const & a);
+
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType backEaseIn(genType const& a);
+
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType backEaseOut(genType const& a);
+
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType backEaseInOut(genType const& a);
+
+	/// @param a parameter
+	/// @param o Optional overshoot modifier
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType backEaseIn(genType const& a, genType const& o);
+
+	/// @param a parameter
+	/// @param o Optional overshoot modifier
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType backEaseOut(genType const& a, genType const& o);
+
+	/// @param a parameter
+	/// @param o Optional overshoot modifier
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType backEaseInOut(genType const& a, genType const& o);
+
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType bounceEaseIn(genType const& a);
+
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType bounceEaseOut(genType const& a);
+
+	/// @see gtx_easing
+	template <typename genType>
+	GLM_FUNC_DECL genType bounceEaseInOut(genType const& a);
+
+	/// @}
+}//namespace glm
+
+#include "easing.inl"
diff --git a/engine/inc/glm/gtx/easing.inl b/engine/inc/glm/gtx/easing.inl
new file mode 100644
index 00000000..4b7d05b7
--- /dev/null
+++ b/engine/inc/glm/gtx/easing.inl
@@ -0,0 +1,436 @@
+/// @ref gtx_easing
+
+#include <cmath>
+
+namespace glm{
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType linearInterpolation(genType const& a)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		return a;
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType quadraticEaseIn(genType const& a)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		return a * a;
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType quadraticEaseOut(genType const& a)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		return -(a * (a - static_cast<genType>(2)));
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType quadraticEaseInOut(genType const& a)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		if(a < static_cast<genType>(0.5))
+		{
+			return static_cast<genType>(2) * a * a;
+		}
+		else
+		{
+			return (-static_cast<genType>(2) * a * a) + (4 * a) - one<genType>();
+		}
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType cubicEaseIn(genType const& a)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		return a * a * a;
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType cubicEaseOut(genType const& a)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		genType const f = a - one<genType>();
+		return f * f * f + one<genType>();
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType cubicEaseInOut(genType const& a)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		if (a < static_cast<genType>(0.5))
+		{
+			return static_cast<genType>(4) * a * a * a;
+		}
+		else
+		{
+			genType const f = ((static_cast<genType>(2) * a) - static_cast<genType>(2));
+			return static_cast<genType>(0.5) * f * f * f + one<genType>();
+		}
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType quarticEaseIn(genType const& a)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		return a * a * a * a;
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType quarticEaseOut(genType const& a)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		genType const f = (a - one<genType>());
+		return f * f * f * (one<genType>() - a) + one<genType>();
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType quarticEaseInOut(genType const& a)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		if(a < static_cast<genType>(0.5))
+		{
+			return static_cast<genType>(8) * a * a * a * a;
+		}
+		else
+		{
+			genType const f = (a - one<genType>());
+			return -static_cast<genType>(8) * f * f * f * f + one<genType>();
+		}
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType quinticEaseIn(genType const& a)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		return a * a * a * a * a;
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType quinticEaseOut(genType const& a)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		genType const f = (a - one<genType>());
+		return f * f * f * f * f + one<genType>();
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType quinticEaseInOut(genType const& a)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		if(a < static_cast<genType>(0.5))
+		{
+			return static_cast<genType>(16) * a * a * a * a * a;
+		}
+		else
+		{
+			genType const f = ((static_cast<genType>(2) * a) - static_cast<genType>(2));
+			return static_cast<genType>(0.5) * f * f * f * f * f + one<genType>();
+		}
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType sineEaseIn(genType const& a)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		return sin((a - one<genType>()) * half_pi<genType>()) + one<genType>();
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType sineEaseOut(genType const& a)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		return sin(a * half_pi<genType>());
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType sineEaseInOut(genType const& a)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		return static_cast<genType>(0.5) * (one<genType>() - cos(a * pi<genType>()));
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType circularEaseIn(genType const& a)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		return one<genType>() - sqrt(one<genType>() - (a * a));
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType circularEaseOut(genType const& a)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		return sqrt((static_cast<genType>(2) - a) * a);
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType circularEaseInOut(genType const& a)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		if(a < static_cast<genType>(0.5))
+		{
+			return static_cast<genType>(0.5) * (one<genType>() - std::sqrt(one<genType>() - static_cast<genType>(4) * (a * a)));
+		}
+		else
+		{
+			return static_cast<genType>(0.5) * (std::sqrt(-((static_cast<genType>(2) * a) - static_cast<genType>(3)) * ((static_cast<genType>(2) * a) - one<genType>())) + one<genType>());
+		}
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType exponentialEaseIn(genType const& a)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		if(a <= zero<genType>())
+			return a;
+		else
+		{
+			genType const Complementary = a - one<genType>();
+			genType const Two = static_cast<genType>(2);
+			
+			return glm::pow(Two, Complementary * static_cast<genType>(10));
+		}
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType exponentialEaseOut(genType const& a)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		if(a >= one<genType>())
+			return a;
+		else
+		{
+			return one<genType>() - glm::pow(static_cast<genType>(2), -static_cast<genType>(10) * a);
+		}
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType exponentialEaseInOut(genType const& a)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		if(a < static_cast<genType>(0.5))
+			return static_cast<genType>(0.5) * glm::pow(static_cast<genType>(2), (static_cast<genType>(20) * a) - static_cast<genType>(10));
+		else
+			return -static_cast<genType>(0.5) * glm::pow(static_cast<genType>(2), (-static_cast<genType>(20) * a) + static_cast<genType>(10)) + one<genType>();
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType elasticEaseIn(genType const& a)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		return std::sin(static_cast<genType>(13) * half_pi<genType>() * a) * glm::pow(static_cast<genType>(2), static_cast<genType>(10) * (a - one<genType>()));
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType elasticEaseOut(genType const& a)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		return std::sin(-static_cast<genType>(13) * half_pi<genType>() * (a + one<genType>())) * glm::pow(static_cast<genType>(2), -static_cast<genType>(10) * a) + one<genType>();
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType elasticEaseInOut(genType const& a)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		if(a < static_cast<genType>(0.5))
+			return static_cast<genType>(0.5) * std::sin(static_cast<genType>(13) * half_pi<genType>() * (static_cast<genType>(2) * a)) * glm::pow(static_cast<genType>(2), static_cast<genType>(10) * ((static_cast<genType>(2) * a) - one<genType>()));
+		else
+			return static_cast<genType>(0.5) * (std::sin(-static_cast<genType>(13) * half_pi<genType>() * ((static_cast<genType>(2) * a - one<genType>()) + one<genType>())) * glm::pow(static_cast<genType>(2), -static_cast<genType>(10) * (static_cast<genType>(2) * a - one<genType>())) + static_cast<genType>(2));
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType backEaseIn(genType const& a, genType const& o)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		genType z = ((o + one<genType>()) * a) - o;
+		return (a * a * z);
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType backEaseOut(genType const& a, genType const& o)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		genType n = a - one<genType>();
+		genType z = ((o + one<genType>()) * n) + o;
+		return (n * n * z) + one<genType>();
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType backEaseInOut(genType const& a, genType const& o)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		genType s = o * static_cast<genType>(1.525);
+		genType x = static_cast<genType>(0.5);
+		genType n = a / static_cast<genType>(0.5);
+
+		if (n < static_cast<genType>(1))
+		{
+			genType z = ((s + static_cast<genType>(1)) * n) - s;
+			genType m = n * n * z;
+			return x * m;
+		}
+		else 
+		{
+			n -= static_cast<genType>(2);
+			genType z = ((s + static_cast<genType>(1)) * n) + s;
+			genType m = (n*n*z) + static_cast<genType>(2);
+			return x * m;
+		}
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType backEaseIn(genType const& a)
+	{
+		return backEaseIn(a, static_cast<genType>(1.70158));
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType backEaseOut(genType const& a)
+	{
+		return backEaseOut(a, static_cast<genType>(1.70158));
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType backEaseInOut(genType const& a)
+	{
+		return backEaseInOut(a, static_cast<genType>(1.70158));
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType bounceEaseOut(genType const& a)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		if(a < static_cast<genType>(4.0 / 11.0))
+		{
+			return (static_cast<genType>(121) * a * a) / static_cast<genType>(16);
+		}
+		else if(a < static_cast<genType>(8.0 / 11.0))
+		{
+			return (static_cast<genType>(363.0 / 40.0) * a * a) - (static_cast<genType>(99.0 / 10.0) * a) + static_cast<genType>(17.0 / 5.0);
+		}
+		else if(a < static_cast<genType>(9.0 / 10.0))
+		{
+			return (static_cast<genType>(4356.0 / 361.0) * a * a) - (static_cast<genType>(35442.0 / 1805.0) * a) + static_cast<genType>(16061.0 / 1805.0);
+		}
+		else
+		{
+			return (static_cast<genType>(54.0 / 5.0) * a * a) - (static_cast<genType>(513.0 / 25.0) * a) + static_cast<genType>(268.0 / 25.0);
+		}
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType bounceEaseIn(genType const& a)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		return one<genType>() - bounceEaseOut(one<genType>() - a);
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType bounceEaseInOut(genType const& a)
+	{
+		// Only defined in [0, 1]
+		assert(a >= zero<genType>());
+		assert(a <= one<genType>());
+
+		if(a < static_cast<genType>(0.5))
+		{
+			return static_cast<genType>(0.5) * (one<genType>() - bounceEaseOut(a * static_cast<genType>(2)));
+		}
+		else
+		{
+			return static_cast<genType>(0.5) * bounceEaseOut(a * static_cast<genType>(2) - one<genType>()) + static_cast<genType>(0.5);
+		}
+	}
+
+}//namespace glm
diff --git a/engine/inc/glm/gtx/euler_angles.hpp b/engine/inc/glm/gtx/euler_angles.hpp
new file mode 100644
index 00000000..17eb8414
--- /dev/null
+++ b/engine/inc/glm/gtx/euler_angles.hpp
@@ -0,0 +1,335 @@
+/// @ref gtx_euler_angles
+/// @file glm/gtx/euler_angles.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_euler_angles GLM_GTX_euler_angles
+/// @ingroup gtx
+///
+/// Include <glm/gtx/euler_angles.hpp> to use the features of this extension.
+///
+/// Build matrices from Euler angles.
+///
+/// Extraction of Euler angles from rotation matrix.
+/// Based on the original paper 2014 Mike Day - Extracting Euler Angles from a Rotation Matrix.
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_euler_angles is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_euler_angles extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_euler_angles
+	/// @{
+
+	/// Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle X.
+	/// @see gtx_euler_angles
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleX(
+		T const& angleX);
+
+	/// Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Y.
+	/// @see gtx_euler_angles
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleY(
+		T const& angleY);
+
+	/// Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Z.
+	/// @see gtx_euler_angles
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZ(
+		T const& angleZ);
+
+	/// Creates a 3D 4 * 4 homogeneous derived matrix from the rotation matrix about X-axis.
+	/// @see gtx_euler_angles
+	template <typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> derivedEulerAngleX(
+		T const & angleX, T const & angularVelocityX);
+
+	/// Creates a 3D 4 * 4 homogeneous derived matrix from the rotation matrix about Y-axis.
+	/// @see gtx_euler_angles
+	template <typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> derivedEulerAngleY(
+		T const & angleY, T const & angularVelocityY);
+
+	/// Creates a 3D 4 * 4 homogeneous derived matrix from the rotation matrix about Z-axis.
+	/// @see gtx_euler_angles
+	template <typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> derivedEulerAngleZ(
+		T const & angleZ, T const & angularVelocityZ);
+
+	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y).
+	/// @see gtx_euler_angles
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleXY(
+		T const& angleX,
+		T const& angleY);
+
+	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X).
+	/// @see gtx_euler_angles
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleYX(
+		T const& angleY,
+		T const& angleX);
+
+	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Z).
+	/// @see gtx_euler_angles
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleXZ(
+		T const& angleX,
+		T const& angleZ);
+
+	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * X).
+	/// @see gtx_euler_angles
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZX(
+		T const& angle,
+		T const& angleX);
+
+	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * Z).
+	/// @see gtx_euler_angles
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleYZ(
+		T const& angleY,
+		T const& angleZ);
+
+	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * Y).
+	/// @see gtx_euler_angles
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZY(
+		T const& angleZ,
+		T const& angleY);
+
+    /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y * Z).
+    /// @see gtx_euler_angles
+    template<typename T>
+    GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleXYZ(
+        T const& t1,
+        T const& t2,
+        T const& t3);
+
+	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
+	/// @see gtx_euler_angles
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleYXZ(
+		T const& yaw,
+		T const& pitch,
+		T const& roll);
+
+	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Z * X).
+	/// @see gtx_euler_angles
+	template <typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleXZX(
+		T const & t1,
+		T const & t2,
+		T const & t3);
+
+	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y * X).
+	/// @see gtx_euler_angles
+	template <typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleXYX(
+		T const & t1,
+		T const & t2,
+		T const & t3);
+
+	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Y).
+	/// @see gtx_euler_angles
+	template <typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleYXY(
+		T const & t1,
+		T const & t2,
+		T const & t3);
+
+	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * Z * Y).
+	/// @see gtx_euler_angles
+	template <typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleYZY(
+		T const & t1,
+		T const & t2,
+		T const & t3);
+
+	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * Y * Z).
+	/// @see gtx_euler_angles
+	template <typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZYZ(
+		T const & t1,
+		T const & t2,
+		T const & t3);
+
+	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * X * Z).
+	/// @see gtx_euler_angles
+	template <typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZXZ(
+		T const & t1,
+		T const & t2,
+		T const & t3);
+
+	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Z * Y).
+	/// @see gtx_euler_angles
+	template <typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleXZY(
+		T const & t1,
+		T const & t2,
+		T const & t3);
+
+	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * Z * X).
+	/// @see gtx_euler_angles
+	template <typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleYZX(
+		T const & t1,
+		T const & t2,
+		T const & t3);
+
+	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * Y * X).
+	/// @see gtx_euler_angles
+	template <typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZYX(
+		T const & t1,
+		T const & t2,
+		T const & t3);
+
+	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * X * Y).
+	/// @see gtx_euler_angles
+	template <typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZXY(
+		T const & t1,
+		T const & t2,
+		T const & t3);
+
+	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
+	/// @see gtx_euler_angles
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> yawPitchRoll(
+		T const& yaw,
+		T const& pitch,
+		T const& roll);
+
+	/// Creates a 2D 2 * 2 rotation matrix from an euler angle.
+	/// @see gtx_euler_angles
+	template<typename T>
+	GLM_FUNC_DECL mat<2, 2, T, defaultp> orientate2(T const& angle);
+
+	/// Creates a 2D 4 * 4 homogeneous rotation matrix from an euler angle.
+	/// @see gtx_euler_angles
+	template<typename T>
+	GLM_FUNC_DECL mat<3, 3, T, defaultp> orientate3(T const& angle);
+
+	/// Creates a 3D 3 * 3 rotation matrix from euler angles (Y * X * Z).
+	/// @see gtx_euler_angles
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> orientate3(vec<3, T, Q> const& angles);
+
+	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
+	/// @see gtx_euler_angles
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> orientate4(vec<3, T, Q> const& angles);
+
+    /// Extracts the (X * Y * Z) Euler angles from the rotation matrix M
+    /// @see gtx_euler_angles
+    template<typename T>
+    GLM_FUNC_DECL void extractEulerAngleXYZ(mat<4, 4, T, defaultp> const& M,
+                                            T & t1,
+                                            T & t2,
+                                            T & t3);
+
+	/// Extracts the (Y * X * Z) Euler angles from the rotation matrix M
+	/// @see gtx_euler_angles
+	template <typename T>
+	GLM_FUNC_DECL void extractEulerAngleYXZ(mat<4, 4, T, defaultp> const & M,
+											T & t1,
+											T & t2,
+											T & t3);
+
+	/// Extracts the (X * Z * X) Euler angles from the rotation matrix M
+	/// @see gtx_euler_angles
+	template <typename T>
+	GLM_FUNC_DECL void extractEulerAngleXZX(mat<4, 4, T, defaultp> const & M,
+											T & t1,
+											T & t2,
+											T & t3);
+
+	/// Extracts the (X * Y * X) Euler angles from the rotation matrix M
+	/// @see gtx_euler_angles
+	template <typename T>
+	GLM_FUNC_DECL void extractEulerAngleXYX(mat<4, 4, T, defaultp> const & M,
+											T & t1,
+											T & t2,
+											T & t3);
+
+	/// Extracts the (Y * X * Y) Euler angles from the rotation matrix M
+	/// @see gtx_euler_angles
+	template <typename T>
+	GLM_FUNC_DECL void extractEulerAngleYXY(mat<4, 4, T, defaultp> const & M,
+											T & t1,
+											T & t2,
+											T & t3);
+
+	/// Extracts the (Y * Z * Y) Euler angles from the rotation matrix M
+	/// @see gtx_euler_angles
+	template <typename T>
+	GLM_FUNC_DECL void extractEulerAngleYZY(mat<4, 4, T, defaultp> const & M,
+											T & t1,
+											T & t2,
+											T & t3);
+
+	/// Extracts the (Z * Y * Z) Euler angles from the rotation matrix M
+	/// @see gtx_euler_angles
+	template <typename T>
+	GLM_FUNC_DECL void extractEulerAngleZYZ(mat<4, 4, T, defaultp> const & M,
+											T & t1,
+											T & t2,
+											T & t3);
+
+	/// Extracts the (Z * X * Z) Euler angles from the rotation matrix M
+	/// @see gtx_euler_angles
+	template <typename T>
+	GLM_FUNC_DECL void extractEulerAngleZXZ(mat<4, 4, T, defaultp> const & M,
+											T & t1,
+											T & t2,
+											T & t3);
+
+	/// Extracts the (X * Z * Y) Euler angles from the rotation matrix M
+	/// @see gtx_euler_angles
+	template <typename T>
+	GLM_FUNC_DECL void extractEulerAngleXZY(mat<4, 4, T, defaultp> const & M,
+											T & t1,
+											T & t2,
+											T & t3);
+
+	/// Extracts the (Y * Z * X) Euler angles from the rotation matrix M
+	/// @see gtx_euler_angles
+	template <typename T>
+	GLM_FUNC_DECL void extractEulerAngleYZX(mat<4, 4, T, defaultp> const & M,
+											T & t1,
+											T & t2,
+											T & t3);
+
+	/// Extracts the (Z * Y * X) Euler angles from the rotation matrix M
+	/// @see gtx_euler_angles
+	template <typename T>
+	GLM_FUNC_DECL void extractEulerAngleZYX(mat<4, 4, T, defaultp> const & M,
+											T & t1,
+											T & t2,
+											T & t3);
+
+	/// Extracts the (Z * X * Y) Euler angles from the rotation matrix M
+	/// @see gtx_euler_angles
+	template <typename T>
+	GLM_FUNC_DECL void extractEulerAngleZXY(mat<4, 4, T, defaultp> const & M,
+											T & t1,
+											T & t2,
+											T & t3);
+
+	/// @}
+}//namespace glm
+
+#include "euler_angles.inl"
diff --git a/engine/inc/glm/gtx/euler_angles.inl b/engine/inc/glm/gtx/euler_angles.inl
new file mode 100644
index 00000000..68c50124
--- /dev/null
+++ b/engine/inc/glm/gtx/euler_angles.inl
@@ -0,0 +1,899 @@
+/// @ref gtx_euler_angles
+
+#include "compatibility.hpp" // glm::atan2
+
+namespace glm
+{
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleX
+	(
+		T const& angleX
+	)
+	{
+		T cosX = glm::cos(angleX);
+		T sinX = glm::sin(angleX);
+
+		return mat<4, 4, T, defaultp>(
+			T(1), T(0), T(0), T(0),
+			T(0), cosX, sinX, T(0),
+			T(0),-sinX, cosX, T(0),
+			T(0), T(0), T(0), T(1));
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleY
+	(
+		T const& angleY
+	)
+	{
+		T cosY = glm::cos(angleY);
+		T sinY = glm::sin(angleY);
+
+		return mat<4, 4, T, defaultp>(
+			cosY,	T(0),	-sinY,	T(0),
+			T(0),	T(1),	T(0),	T(0),
+			sinY,	T(0),	cosY,	T(0),
+			T(0),	T(0),	T(0),	T(1));
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleZ
+	(
+		T const& angleZ
+	)
+	{
+		T cosZ = glm::cos(angleZ);
+		T sinZ = glm::sin(angleZ);
+
+		return mat<4, 4, T, defaultp>(
+			cosZ,	sinZ,	T(0), T(0),
+			-sinZ,	cosZ,	T(0), T(0),
+			T(0),	T(0),	T(1), T(0),
+			T(0),	T(0),	T(0), T(1));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> derivedEulerAngleX
+	(
+		T const & angleX,
+		T const & angularVelocityX
+	)
+	{
+		T cosX = glm::cos(angleX) * angularVelocityX;
+		T sinX = glm::sin(angleX) * angularVelocityX;
+
+		return mat<4, 4, T, defaultp>(
+			T(0), T(0), T(0), T(0),
+			T(0),-sinX, cosX, T(0),
+			T(0),-cosX,-sinX, T(0),
+			T(0), T(0), T(0), T(0));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> derivedEulerAngleY
+	(
+		T const & angleY,
+		T const & angularVelocityY
+	)
+	{
+		T cosY = glm::cos(angleY) * angularVelocityY;
+		T sinY = glm::sin(angleY) * angularVelocityY;
+
+		return mat<4, 4, T, defaultp>(
+			-sinY, T(0), -cosY, T(0),
+			 T(0), T(0),  T(0), T(0),
+			 cosY, T(0), -sinY, T(0),
+			 T(0), T(0),  T(0), T(0));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> derivedEulerAngleZ
+	(
+		T const & angleZ,
+		T const & angularVelocityZ
+	)
+	{
+		T cosZ = glm::cos(angleZ) * angularVelocityZ;
+		T sinZ = glm::sin(angleZ) * angularVelocityZ;
+
+		return mat<4, 4, T, defaultp>(
+			-sinZ,  cosZ, T(0), T(0),
+			-cosZ, -sinZ, T(0), T(0),
+			 T(0),  T(0), T(0), T(0),
+			 T(0),  T(0), T(0), T(0));
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleXY
+	(
+		T const& angleX,
+		T const& angleY
+	)
+	{
+		T cosX = glm::cos(angleX);
+		T sinX = glm::sin(angleX);
+		T cosY = glm::cos(angleY);
+		T sinY = glm::sin(angleY);
+
+		return mat<4, 4, T, defaultp>(
+			cosY,   -sinX * -sinY,  cosX * -sinY,   T(0),
+			T(0),   cosX,           sinX,           T(0),
+			sinY,   -sinX * cosY,   cosX * cosY,    T(0),
+			T(0),   T(0),           T(0),           T(1));
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleYX
+	(
+		T const& angleY,
+		T const& angleX
+	)
+	{
+		T cosX = glm::cos(angleX);
+		T sinX = glm::sin(angleX);
+		T cosY = glm::cos(angleY);
+		T sinY = glm::sin(angleY);
+
+		return mat<4, 4, T, defaultp>(
+			cosY,          0,      -sinY,    T(0),
+			sinY * sinX,  cosX, cosY * sinX, T(0),
+			sinY * cosX, -sinX, cosY * cosX, T(0),
+			T(0),         T(0),     T(0),    T(1));
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleXZ
+	(
+		T const& angleX,
+		T const& angleZ
+	)
+	{
+		return eulerAngleX(angleX) * eulerAngleZ(angleZ);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleZX
+	(
+		T const& angleZ,
+		T const& angleX
+	)
+	{
+		return eulerAngleZ(angleZ) * eulerAngleX(angleX);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleYZ
+	(
+		T const& angleY,
+		T const& angleZ
+	)
+	{
+		return eulerAngleY(angleY) * eulerAngleZ(angleZ);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleZY
+	(
+		T const& angleZ,
+		T const& angleY
+	)
+	{
+		return eulerAngleZ(angleZ) * eulerAngleY(angleY);
+	}
+
+    template<typename T>
+    GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleXYZ
+    (
+     T const& t1,
+     T const& t2,
+     T const& t3
+     )
+    {
+        T c1 = glm::cos(-t1);
+        T c2 = glm::cos(-t2);
+        T c3 = glm::cos(-t3);
+        T s1 = glm::sin(-t1);
+        T s2 = glm::sin(-t2);
+        T s3 = glm::sin(-t3);
+
+        mat<4, 4, T, defaultp> Result;
+        Result[0][0] = c2 * c3;
+        Result[0][1] =-c1 * s3 + s1 * s2 * c3;
+        Result[0][2] = s1 * s3 + c1 * s2 * c3;
+        Result[0][3] = static_cast<T>(0);
+        Result[1][0] = c2 * s3;
+        Result[1][1] = c1 * c3 + s1 * s2 * s3;
+        Result[1][2] =-s1 * c3 + c1 * s2 * s3;
+        Result[1][3] = static_cast<T>(0);
+        Result[2][0] =-s2;
+        Result[2][1] = s1 * c2;
+        Result[2][2] = c1 * c2;
+        Result[2][3] = static_cast<T>(0);
+        Result[3][0] = static_cast<T>(0);
+        Result[3][1] = static_cast<T>(0);
+        Result[3][2] = static_cast<T>(0);
+        Result[3][3] = static_cast<T>(1);
+        return Result;
+    }
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleYXZ
+	(
+		T const& yaw,
+		T const& pitch,
+		T const& roll
+	)
+	{
+		T tmp_ch = glm::cos(yaw);
+		T tmp_sh = glm::sin(yaw);
+		T tmp_cp = glm::cos(pitch);
+		T tmp_sp = glm::sin(pitch);
+		T tmp_cb = glm::cos(roll);
+		T tmp_sb = glm::sin(roll);
+
+		mat<4, 4, T, defaultp> Result;
+		Result[0][0] = tmp_ch * tmp_cb + tmp_sh * tmp_sp * tmp_sb;
+		Result[0][1] = tmp_sb * tmp_cp;
+		Result[0][2] = -tmp_sh * tmp_cb + tmp_ch * tmp_sp * tmp_sb;
+		Result[0][3] = static_cast<T>(0);
+		Result[1][0] = -tmp_ch * tmp_sb + tmp_sh * tmp_sp * tmp_cb;
+		Result[1][1] = tmp_cb * tmp_cp;
+		Result[1][2] = tmp_sb * tmp_sh + tmp_ch * tmp_sp * tmp_cb;
+		Result[1][3] = static_cast<T>(0);
+		Result[2][0] = tmp_sh * tmp_cp;
+		Result[2][1] = -tmp_sp;
+		Result[2][2] = tmp_ch * tmp_cp;
+		Result[2][3] = static_cast<T>(0);
+		Result[3][0] = static_cast<T>(0);
+		Result[3][1] = static_cast<T>(0);
+		Result[3][2] = static_cast<T>(0);
+		Result[3][3] = static_cast<T>(1);
+		return Result;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleXZX
+	(
+		T const & t1,
+		T const & t2,
+		T const & t3
+	)
+	{
+		T c1 = glm::cos(t1);
+		T s1 = glm::sin(t1);
+		T c2 = glm::cos(t2);
+		T s2 = glm::sin(t2);
+		T c3 = glm::cos(t3);
+		T s3 = glm::sin(t3);
+
+		mat<4, 4, T, defaultp> Result;
+		Result[0][0] = c2;
+		Result[0][1] = c1 * s2;
+		Result[0][2] = s1 * s2;
+		Result[0][3] = static_cast<T>(0);
+		Result[1][0] =-c3 * s2;
+		Result[1][1] = c1 * c2 * c3 - s1 * s3;
+		Result[1][2] = c1 * s3 + c2 * c3 * s1;
+		Result[1][3] = static_cast<T>(0);
+		Result[2][0] = s2 * s3;
+		Result[2][1] =-c3 * s1 - c1 * c2 * s3;
+		Result[2][2] = c1 * c3 - c2 * s1 * s3;
+		Result[2][3] = static_cast<T>(0);
+		Result[3][0] = static_cast<T>(0);
+		Result[3][1] = static_cast<T>(0);
+		Result[3][2] = static_cast<T>(0);
+		Result[3][3] = static_cast<T>(1);
+		return Result;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleXYX
+	(
+		T const & t1,
+		T const & t2,
+		T const & t3
+	)
+	{
+		T c1 = glm::cos(t1);
+		T s1 = glm::sin(t1);
+		T c2 = glm::cos(t2);
+		T s2 = glm::sin(t2);
+		T c3 = glm::cos(t3);
+		T s3 = glm::sin(t3);
+
+		mat<4, 4, T, defaultp> Result;
+		Result[0][0] = c2;
+		Result[0][1] = s1 * s2;
+		Result[0][2] =-c1 * s2;
+		Result[0][3] = static_cast<T>(0);
+		Result[1][0] = s2 * s3;
+		Result[1][1] = c1 * c3 - c2 * s1 * s3;
+		Result[1][2] = c3 * s1 + c1 * c2 * s3;
+		Result[1][3] = static_cast<T>(0);
+		Result[2][0] = c3 * s2;
+		Result[2][1] =-c1 * s3 - c2 * c3 * s1;
+		Result[2][2] = c1 * c2 * c3 - s1 * s3;
+		Result[2][3] = static_cast<T>(0);
+		Result[3][0] = static_cast<T>(0);
+		Result[3][1] = static_cast<T>(0);
+		Result[3][2] = static_cast<T>(0);
+		Result[3][3] = static_cast<T>(1);
+		return Result;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleYXY
+	(
+		T const & t1,
+		T const & t2,
+		T const & t3
+	)
+	{
+		T c1 = glm::cos(t1);
+		T s1 = glm::sin(t1);
+		T c2 = glm::cos(t2);
+		T s2 = glm::sin(t2);
+		T c3 = glm::cos(t3);
+		T s3 = glm::sin(t3);
+
+		mat<4, 4, T, defaultp> Result;
+		Result[0][0] = c1 * c3 - c2 * s1 * s3;
+		Result[0][1] = s2* s3;
+		Result[0][2] =-c3 * s1 - c1 * c2 * s3;
+		Result[0][3] = static_cast<T>(0);
+		Result[1][0] = s1 * s2;
+		Result[1][1] = c2;
+		Result[1][2] = c1 * s2;
+		Result[1][3] = static_cast<T>(0);
+		Result[2][0] = c1 * s3 + c2 * c3 * s1;
+		Result[2][1] =-c3 * s2;
+		Result[2][2] = c1 * c2 * c3 - s1 * s3;
+		Result[2][3] = static_cast<T>(0);
+		Result[3][0] = static_cast<T>(0);
+		Result[3][1] = static_cast<T>(0);
+		Result[3][2] = static_cast<T>(0);
+		Result[3][3] = static_cast<T>(1);
+		return Result;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleYZY
+	(
+		T const & t1,
+		T const & t2,
+		T const & t3
+	)
+	{
+		T c1 = glm::cos(t1);
+		T s1 = glm::sin(t1);
+		T c2 = glm::cos(t2);
+		T s2 = glm::sin(t2);
+		T c3 = glm::cos(t3);
+		T s3 = glm::sin(t3);
+
+		mat<4, 4, T, defaultp> Result;
+		Result[0][0] = c1 * c2 * c3 - s1 * s3;
+		Result[0][1] = c3 * s2;
+		Result[0][2] =-c1 * s3 - c2 * c3 * s1;
+		Result[0][3] = static_cast<T>(0);
+		Result[1][0] =-c1 * s2;
+		Result[1][1] = c2;
+		Result[1][2] = s1 * s2;
+		Result[1][3] = static_cast<T>(0);
+		Result[2][0] = c3 * s1 + c1 * c2 * s3;
+		Result[2][1] = s2 * s3;
+		Result[2][2] = c1 * c3 - c2 * s1 * s3;
+		Result[2][3] = static_cast<T>(0);
+		Result[3][0] = static_cast<T>(0);
+		Result[3][1] = static_cast<T>(0);
+		Result[3][2] = static_cast<T>(0);
+		Result[3][3] = static_cast<T>(1);
+		return Result;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleZYZ
+	(
+		T const & t1,
+		T const & t2,
+		T const & t3
+	)
+	{
+		T c1 = glm::cos(t1);
+		T s1 = glm::sin(t1);
+		T c2 = glm::cos(t2);
+		T s2 = glm::sin(t2);
+		T c3 = glm::cos(t3);
+		T s3 = glm::sin(t3);
+
+		mat<4, 4, T, defaultp> Result;
+		Result[0][0] = c1 * c2 * c3 - s1 * s3;
+		Result[0][1] = c1 * s3 + c2 * c3 * s1;
+		Result[0][2] =-c3 * s2;
+		Result[0][3] = static_cast<T>(0);
+		Result[1][0] =-c3 * s1 - c1 * c2 * s3;
+		Result[1][1] = c1 * c3 - c2 * s1 * s3;
+		Result[1][2] = s2 * s3;
+		Result[1][3] = static_cast<T>(0);
+		Result[2][0] = c1 * s2;
+		Result[2][1] = s1 * s2;
+		Result[2][2] = c2;
+		Result[2][3] = static_cast<T>(0);
+		Result[3][0] = static_cast<T>(0);
+		Result[3][1] = static_cast<T>(0);
+		Result[3][2] = static_cast<T>(0);
+		Result[3][3] = static_cast<T>(1);
+		return Result;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleZXZ
+	(
+		T const & t1,
+		T const & t2,
+		T const & t3
+	)
+	{
+		T c1 = glm::cos(t1);
+		T s1 = glm::sin(t1);
+		T c2 = glm::cos(t2);
+		T s2 = glm::sin(t2);
+		T c3 = glm::cos(t3);
+		T s3 = glm::sin(t3);
+
+		mat<4, 4, T, defaultp> Result;
+		Result[0][0] = c1 * c3 - c2 * s1 * s3;
+		Result[0][1] = c3 * s1 + c1 * c2 * s3;
+		Result[0][2] = s2 *s3;
+		Result[0][3] = static_cast<T>(0);
+		Result[1][0] =-c1 * s3 - c2 * c3 * s1;
+		Result[1][1] = c1 * c2 * c3 - s1 * s3;
+		Result[1][2] = c3 * s2;
+		Result[1][3] = static_cast<T>(0);
+		Result[2][0] = s1 * s2;
+		Result[2][1] =-c1 * s2;
+		Result[2][2] = c2;
+		Result[2][3] = static_cast<T>(0);
+		Result[3][0] = static_cast<T>(0);
+		Result[3][1] = static_cast<T>(0);
+		Result[3][2] = static_cast<T>(0);
+		Result[3][3] = static_cast<T>(1);
+		return Result;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleXZY
+	(
+		T const & t1,
+		T const & t2,
+		T const & t3
+	)
+	{
+		T c1 = glm::cos(t1);
+		T s1 = glm::sin(t1);
+		T c2 = glm::cos(t2);
+		T s2 = glm::sin(t2);
+		T c3 = glm::cos(t3);
+		T s3 = glm::sin(t3);
+
+		mat<4, 4, T, defaultp> Result;
+		Result[0][0] = c2 * c3;
+		Result[0][1] = s1 * s3 + c1 * c3 * s2;
+		Result[0][2] = c3 * s1 * s2 - c1 * s3;
+		Result[0][3] = static_cast<T>(0);
+		Result[1][0] =-s2;
+		Result[1][1] = c1 * c2;
+		Result[1][2] = c2 * s1;
+		Result[1][3] = static_cast<T>(0);
+		Result[2][0] = c2 * s3;
+		Result[2][1] = c1 * s2 * s3 - c3 * s1;
+		Result[2][2] = c1 * c3 + s1 * s2 *s3;
+		Result[2][3] = static_cast<T>(0);
+		Result[3][0] = static_cast<T>(0);
+		Result[3][1] = static_cast<T>(0);
+		Result[3][2] = static_cast<T>(0);
+		Result[3][3] = static_cast<T>(1);
+		return Result;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleYZX
+	(
+		T const & t1,
+		T const & t2,
+		T const & t3
+	)
+	{
+		T c1 = glm::cos(t1);
+		T s1 = glm::sin(t1);
+		T c2 = glm::cos(t2);
+		T s2 = glm::sin(t2);
+		T c3 = glm::cos(t3);
+		T s3 = glm::sin(t3);
+
+		mat<4, 4, T, defaultp> Result;
+		Result[0][0] = c1 * c2;
+		Result[0][1] = s2;
+		Result[0][2] =-c2 * s1;
+		Result[0][3] = static_cast<T>(0);
+		Result[1][0] = s1 * s3 - c1 * c3 * s2;
+		Result[1][1] = c2 * c3;
+		Result[1][2] = c1 * s3 + c3 * s1 * s2;
+		Result[1][3] = static_cast<T>(0);
+		Result[2][0] = c3 * s1 + c1 * s2 * s3;
+		Result[2][1] =-c2 * s3;
+		Result[2][2] = c1 * c3 - s1 * s2 * s3;
+		Result[2][3] = static_cast<T>(0);
+		Result[3][0] = static_cast<T>(0);
+		Result[3][1] = static_cast<T>(0);
+		Result[3][2] = static_cast<T>(0);
+		Result[3][3] = static_cast<T>(1);
+		return Result;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleZYX
+	(
+		T const & t1,
+		T const & t2,
+		T const & t3
+	)
+	{
+		T c1 = glm::cos(t1);
+		T s1 = glm::sin(t1);
+		T c2 = glm::cos(t2);
+		T s2 = glm::sin(t2);
+		T c3 = glm::cos(t3);
+		T s3 = glm::sin(t3);
+
+		mat<4, 4, T, defaultp> Result;
+		Result[0][0] = c1 * c2;
+		Result[0][1] = c2 * s1;
+		Result[0][2] =-s2;
+		Result[0][3] = static_cast<T>(0);
+		Result[1][0] = c1 * s2 * s3 - c3 * s1;
+		Result[1][1] = c1 * c3 + s1 * s2 * s3;
+		Result[1][2] = c2 * s3;
+		Result[1][3] = static_cast<T>(0);
+		Result[2][0] = s1 * s3 + c1 * c3 * s2;
+		Result[2][1] = c3 * s1 * s2 - c1 * s3;
+		Result[2][2] = c2 * c3;
+		Result[2][3] = static_cast<T>(0);
+		Result[3][0] = static_cast<T>(0);
+		Result[3][1] = static_cast<T>(0);
+		Result[3][2] = static_cast<T>(0);
+		Result[3][3] = static_cast<T>(1);
+		return Result;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleZXY
+	(
+		T const & t1,
+		T const & t2,
+		T const & t3
+	)
+	{
+		T c1 = glm::cos(t1);
+		T s1 = glm::sin(t1);
+		T c2 = glm::cos(t2);
+		T s2 = glm::sin(t2);
+		T c3 = glm::cos(t3);
+		T s3 = glm::sin(t3);
+
+		mat<4, 4, T, defaultp> Result;
+		Result[0][0] = c1 * c3 - s1 * s2 * s3;
+		Result[0][1] = c3 * s1 + c1 * s2 * s3;
+		Result[0][2] =-c2 * s3;
+		Result[0][3] = static_cast<T>(0);
+		Result[1][0] =-c2 * s1;
+		Result[1][1] = c1 * c2;
+		Result[1][2] = s2;
+		Result[1][3] = static_cast<T>(0);
+		Result[2][0] = c1 * s3 + c3 * s1 * s2;
+		Result[2][1] = s1 * s3 - c1 * c3 * s2;
+		Result[2][2] = c2 * c3;
+		Result[2][3] = static_cast<T>(0);
+		Result[3][0] = static_cast<T>(0);
+		Result[3][1] = static_cast<T>(0);
+		Result[3][2] = static_cast<T>(0);
+		Result[3][3] = static_cast<T>(1);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> yawPitchRoll
+	(
+		T const& yaw,
+		T const& pitch,
+		T const& roll
+	)
+	{
+		T tmp_ch = glm::cos(yaw);
+		T tmp_sh = glm::sin(yaw);
+		T tmp_cp = glm::cos(pitch);
+		T tmp_sp = glm::sin(pitch);
+		T tmp_cb = glm::cos(roll);
+		T tmp_sb = glm::sin(roll);
+
+		mat<4, 4, T, defaultp> Result;
+		Result[0][0] = tmp_ch * tmp_cb + tmp_sh * tmp_sp * tmp_sb;
+		Result[0][1] = tmp_sb * tmp_cp;
+		Result[0][2] = -tmp_sh * tmp_cb + tmp_ch * tmp_sp * tmp_sb;
+		Result[0][3] = static_cast<T>(0);
+		Result[1][0] = -tmp_ch * tmp_sb + tmp_sh * tmp_sp * tmp_cb;
+		Result[1][1] = tmp_cb * tmp_cp;
+		Result[1][2] = tmp_sb * tmp_sh + tmp_ch * tmp_sp * tmp_cb;
+		Result[1][3] = static_cast<T>(0);
+		Result[2][0] = tmp_sh * tmp_cp;
+		Result[2][1] = -tmp_sp;
+		Result[2][2] = tmp_ch * tmp_cp;
+		Result[2][3] = static_cast<T>(0);
+		Result[3][0] = static_cast<T>(0);
+		Result[3][1] = static_cast<T>(0);
+		Result[3][2] = static_cast<T>(0);
+		Result[3][3] = static_cast<T>(1);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, defaultp> orientate2
+	(
+		T const& angle
+	)
+	{
+		T c = glm::cos(angle);
+		T s = glm::sin(angle);
+
+		mat<2, 2, T, defaultp> Result;
+		Result[0][0] = c;
+		Result[0][1] = s;
+		Result[1][0] = -s;
+		Result[1][1] = c;
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, defaultp> orientate3
+	(
+		T const& angle
+	)
+	{
+		T c = glm::cos(angle);
+		T s = glm::sin(angle);
+
+		mat<3, 3, T, defaultp> Result;
+		Result[0][0] = c;
+		Result[0][1] = s;
+		Result[0][2] = 0.0f;
+		Result[1][0] = -s;
+		Result[1][1] = c;
+		Result[1][2] = 0.0f;
+		Result[2][0] = 0.0f;
+		Result[2][1] = 0.0f;
+		Result[2][2] = 1.0f;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> orientate3
+	(
+		vec<3, T, Q> const& angles
+	)
+	{
+		return mat<3, 3, T, Q>(yawPitchRoll(angles.z, angles.x, angles.y));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> orientate4
+	(
+		vec<3, T, Q> const& angles
+	)
+	{
+		return yawPitchRoll(angles.z, angles.x, angles.y);
+	}
+
+    template<typename T>
+    GLM_FUNC_DECL void extractEulerAngleXYZ(mat<4, 4, T, defaultp> const& M,
+                                            T & t1,
+                                            T & t2,
+                                            T & t3)
+    {
+        T T1 = glm::atan2<T, defaultp>(M[2][1], M[2][2]);
+        T C2 = glm::sqrt(M[0][0]*M[0][0] + M[1][0]*M[1][0]);
+        T T2 = glm::atan2<T, defaultp>(-M[2][0], C2);
+        T S1 = glm::sin(T1);
+        T C1 = glm::cos(T1);
+        T T3 = glm::atan2<T, defaultp>(S1*M[0][2] - C1*M[0][1], C1*M[1][1] - S1*M[1][2  ]);
+        t1 = -T1;
+        t2 = -T2;
+        t3 = -T3;
+    }
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER void extractEulerAngleYXZ(mat<4, 4, T, defaultp> const & M,
+												 T & t1,
+												 T & t2,
+												 T & t3)
+	{
+		T T1 = glm::atan2<T, defaultp>(M[2][0], M[2][2]);
+		T C2 = glm::sqrt(M[0][1]*M[0][1] + M[1][1]*M[1][1]);
+		T T2 = glm::atan2<T, defaultp>(-M[2][1], C2);
+		T S1 = glm::sin(T1);
+		T C1 = glm::cos(T1);
+		T T3 = glm::atan2<T, defaultp>(S1*M[1][2] - C1*M[1][0], C1*M[0][0] - S1*M[0][2]);
+		t1 = T1;
+		t2 = T2;
+		t3 = T3;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER void extractEulerAngleXZX(mat<4, 4, T, defaultp> const & M,
+												 T & t1,
+												 T & t2,
+												 T & t3)
+	{
+		T T1 = glm::atan2<T, defaultp>(M[0][2], M[0][1]);
+		T S2 = glm::sqrt(M[1][0]*M[1][0] + M[2][0]*M[2][0]);
+		T T2 = glm::atan2<T, defaultp>(S2, M[0][0]);
+		T S1 = glm::sin(T1);
+		T C1 = glm::cos(T1);
+		T T3 = glm::atan2<T, defaultp>(C1*M[1][2] - S1*M[1][1], C1*M[2][2] - S1*M[2][1]);
+		t1 = T1;
+		t2 = T2;
+		t3 = T3;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER void extractEulerAngleXYX(mat<4, 4, T, defaultp> const & M,
+												 T & t1,
+												 T & t2,
+												 T & t3)
+	{
+		T T1 = glm::atan2<T, defaultp>(M[0][1], -M[0][2]);
+		T S2 = glm::sqrt(M[1][0]*M[1][0] + M[2][0]*M[2][0]);
+		T T2 = glm::atan2<T, defaultp>(S2, M[0][0]);
+		T S1 = glm::sin(T1);
+		T C1 = glm::cos(T1);
+		T T3 = glm::atan2<T, defaultp>(-C1*M[2][1] - S1*M[2][2], C1*M[1][1] + S1*M[1][2]);
+		t1 = T1;
+		t2 = T2;
+		t3 = T3;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER void extractEulerAngleYXY(mat<4, 4, T, defaultp> const & M,
+												 T & t1,
+												 T & t2,
+												 T & t3)
+	{
+		T T1 = glm::atan2<T, defaultp>(M[1][0], M[1][2]);
+		T S2 = glm::sqrt(M[0][1]*M[0][1] + M[2][1]*M[2][1]);
+		T T2 = glm::atan2<T, defaultp>(S2, M[1][1]);
+		T S1 = glm::sin(T1);
+		T C1 = glm::cos(T1);
+		T T3 = glm::atan2<T, defaultp>(C1*M[2][0] - S1*M[2][2], C1*M[0][0] - S1*M[0][2]);
+		t1 = T1;
+		t2 = T2;
+		t3 = T3;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER void extractEulerAngleYZY(mat<4, 4, T, defaultp> const & M,
+												 T & t1,
+												 T & t2,
+												 T & t3)
+	{
+		T T1 = glm::atan2<T, defaultp>(M[1][2], -M[1][0]);
+		T S2 = glm::sqrt(M[0][1]*M[0][1] + M[2][1]*M[2][1]);
+		T T2 = glm::atan2<T, defaultp>(S2, M[1][1]);
+		T S1 = glm::sin(T1);
+		T C1 = glm::cos(T1);
+		T T3 = glm::atan2<T, defaultp>(-S1*M[0][0] - C1*M[0][2], S1*M[2][0] + C1*M[2][2]);
+		t1 = T1;
+		t2 = T2;
+		t3 = T3;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER void extractEulerAngleZYZ(mat<4, 4, T, defaultp> const & M,
+												 T & t1,
+												 T & t2,
+												 T & t3)
+	{
+		T T1 = glm::atan2<T, defaultp>(M[2][1], M[2][0]);
+		T S2 = glm::sqrt(M[0][2]*M[0][2] + M[1][2]*M[1][2]);
+		T T2 = glm::atan2<T, defaultp>(S2, M[2][2]);
+		T S1 = glm::sin(T1);
+		T C1 = glm::cos(T1);
+		T T3 = glm::atan2<T, defaultp>(C1*M[0][1] - S1*M[0][0], C1*M[1][1] - S1*M[1][0]);
+		t1 = T1;
+		t2 = T2;
+		t3 = T3;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER void extractEulerAngleZXZ(mat<4, 4, T, defaultp> const & M,
+												 T & t1,
+												 T & t2,
+												 T & t3)
+	{
+		T T1 = glm::atan2<T, defaultp>(M[2][0], -M[2][1]);
+		T S2 = glm::sqrt(M[0][2]*M[0][2] + M[1][2]*M[1][2]);
+		T T2 = glm::atan2<T, defaultp>(S2, M[2][2]);
+		T S1 = glm::sin(T1);
+		T C1 = glm::cos(T1);
+		T T3 = glm::atan2<T, defaultp>(-C1*M[1][0] - S1*M[1][1], C1*M[0][0] + S1*M[0][1]);
+		t1 = T1;
+		t2 = T2;
+		t3 = T3;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER void extractEulerAngleXZY(mat<4, 4, T, defaultp> const & M,
+												 T & t1,
+												 T & t2,
+												 T & t3)
+	{
+		T T1 = glm::atan2<T, defaultp>(M[1][2], M[1][1]);
+		T C2 = glm::sqrt(M[0][0]*M[0][0] + M[2][0]*M[2][0]);
+		T T2 = glm::atan2<T, defaultp>(-M[1][0], C2);
+		T S1 = glm::sin(T1);
+		T C1 = glm::cos(T1);
+		T T3 = glm::atan2<T, defaultp>(S1*M[0][1] - C1*M[0][2], C1*M[2][2] - S1*M[2][1]);
+		t1 = T1;
+		t2 = T2;
+		t3 = T3;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER void extractEulerAngleYZX(mat<4, 4, T, defaultp> const & M,
+												 T & t1,
+												 T & t2,
+												 T & t3)
+	{
+		T T1 = glm::atan2<T, defaultp>(-M[0][2], M[0][0]);
+		T C2 = glm::sqrt(M[1][1]*M[1][1] + M[2][1]*M[2][1]);
+		T T2 = glm::atan2<T, defaultp>(M[0][1], C2);
+		T S1 = glm::sin(T1);
+		T C1 = glm::cos(T1);
+		T T3 = glm::atan2<T, defaultp>(S1*M[1][0] + C1*M[1][2], S1*M[2][0] + C1*M[2][2]);
+		t1 = T1;
+		t2 = T2;
+		t3 = T3;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER void extractEulerAngleZYX(mat<4, 4, T, defaultp> const & M,
+												 T & t1,
+												 T & t2,
+												 T & t3)
+	{
+		T T1 = glm::atan2<T, defaultp>(M[0][1], M[0][0]);
+		T C2 = glm::sqrt(M[1][2]*M[1][2] + M[2][2]*M[2][2]);
+		T T2 = glm::atan2<T, defaultp>(-M[0][2], C2);
+		T S1 = glm::sin(T1);
+		T C1 = glm::cos(T1);
+		T T3 = glm::atan2<T, defaultp>(S1*M[2][0] - C1*M[2][1], C1*M[1][1] - S1*M[1][0]);
+		t1 = T1;
+		t2 = T2;
+		t3 = T3;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER void extractEulerAngleZXY(mat<4, 4, T, defaultp> const & M,
+												 T & t1,
+												 T & t2,
+												 T & t3)
+	{
+		T T1 = glm::atan2<T, defaultp>(-M[1][0], M[1][1]);
+		T C2 = glm::sqrt(M[0][2]*M[0][2] + M[2][2]*M[2][2]);
+		T T2 = glm::atan2<T, defaultp>(M[1][2], C2);
+		T S1 = glm::sin(T1);
+		T C1 = glm::cos(T1);
+		T T3 = glm::atan2<T, defaultp>(C1*M[2][0] + S1*M[2][1], C1*M[0][0] + S1*M[0][1]);
+		t1 = T1;
+		t2 = T2;
+		t3 = T3;
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/extend.hpp b/engine/inc/glm/gtx/extend.hpp
new file mode 100644
index 00000000..914d4072
--- /dev/null
+++ b/engine/inc/glm/gtx/extend.hpp
@@ -0,0 +1,42 @@
+/// @ref gtx_extend
+/// @file glm/gtx/extend.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_extend GLM_GTX_extend
+/// @ingroup gtx
+///
+/// Include <glm/gtx/extend.hpp> to use the features of this extension.
+///
+/// Extend a position from a source to a position at a defined length.
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_extend is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_extend extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_extend
+	/// @{
+
+	/// Extends of Length the Origin position using the (Source - Origin) direction.
+	/// @see gtx_extend
+	template<typename genType>
+	GLM_FUNC_DECL genType extend(
+		genType const& Origin,
+		genType const& Source,
+		typename genType::value_type const Length);
+
+	/// @}
+}//namespace glm
+
+#include "extend.inl"
diff --git a/engine/inc/glm/gtx/extend.inl b/engine/inc/glm/gtx/extend.inl
new file mode 100644
index 00000000..32128eb2
--- /dev/null
+++ b/engine/inc/glm/gtx/extend.inl
@@ -0,0 +1,48 @@
+/// @ref gtx_extend
+
+namespace glm
+{
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType extend
+	(
+		genType const& Origin,
+		genType const& Source,
+		genType const& Distance
+	)
+	{
+		return Origin + (Source - Origin) * Distance;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<2, T, Q> extend
+	(
+		vec<2, T, Q> const& Origin,
+		vec<2, T, Q> const& Source,
+		T const& Distance
+	)
+	{
+		return Origin + (Source - Origin) * Distance;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> extend
+	(
+		vec<3, T, Q> const& Origin,
+		vec<3, T, Q> const& Source,
+		T const& Distance
+	)
+	{
+		return Origin + (Source - Origin) * Distance;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, T, Q> extend
+	(
+		vec<4, T, Q> const& Origin,
+		vec<4, T, Q> const& Source,
+		T const& Distance
+	)
+	{
+		return Origin + (Source - Origin) * Distance;
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/extended_min_max.hpp b/engine/inc/glm/gtx/extended_min_max.hpp
new file mode 100644
index 00000000..26802c32
--- /dev/null
+++ b/engine/inc/glm/gtx/extended_min_max.hpp
@@ -0,0 +1,182 @@
+/// @ref gtx_extended_min_max
+/// @file glm/gtx/extended_min_max.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_extended_min_max GLM_GTX_extented_min_max
+/// @ingroup gtx
+///
+/// Include <glm/gtx/extented_min_max.hpp> to use the features of this extension.
+///
+/// Min and max functions for 3 to 4 parameters.
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_extented_min_max is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_extented_min_max extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_extended_min_max
+	/// @{
+
+	/// Return the minimum component-wise values of 3 inputs
+	/// @see gtx_extented_min_max
+	template<typename T>
+	GLM_FUNC_DECL T min(
+		T const& x,
+		T const& y,
+		T const& z);
+
+	/// Return the minimum component-wise values of 3 inputs
+	/// @see gtx_extented_min_max
+	template<typename T, template<typename> class C>
+	GLM_FUNC_DECL C<T> min(
+		C<T> const& x,
+		typename C<T>::T const& y,
+		typename C<T>::T const& z);
+
+	/// Return the minimum component-wise values of 3 inputs
+	/// @see gtx_extented_min_max
+	template<typename T, template<typename> class C>
+	GLM_FUNC_DECL C<T> min(
+		C<T> const& x,
+		C<T> const& y,
+		C<T> const& z);
+
+	/// Return the minimum component-wise values of 4 inputs
+	/// @see gtx_extented_min_max
+	template<typename T>
+	GLM_FUNC_DECL T min(
+		T const& x,
+		T const& y,
+		T const& z,
+		T const& w);
+
+	/// Return the minimum component-wise values of 4 inputs
+	/// @see gtx_extented_min_max
+	template<typename T, template<typename> class C>
+	GLM_FUNC_DECL C<T> min(
+		C<T> const& x,
+		typename C<T>::T const& y,
+		typename C<T>::T const& z,
+		typename C<T>::T const& w);
+
+	/// Return the minimum component-wise values of 4 inputs
+	/// @see gtx_extented_min_max
+	template<typename T, template<typename> class C>
+	GLM_FUNC_DECL C<T> min(
+		C<T> const& x,
+		C<T> const& y,
+		C<T> const& z,
+		C<T> const& w);
+
+	/// Return the maximum component-wise values of 3 inputs
+	/// @see gtx_extented_min_max
+	template<typename T>
+	GLM_FUNC_DECL T max(
+		T const& x,
+		T const& y,
+		T const& z);
+
+	/// Return the maximum component-wise values of 3 inputs
+	/// @see gtx_extented_min_max
+	template<typename T, template<typename> class C>
+	GLM_FUNC_DECL C<T> max(
+		C<T> const& x,
+		typename C<T>::T const& y,
+		typename C<T>::T const& z);
+
+	/// Return the maximum component-wise values of 3 inputs
+	/// @see gtx_extented_min_max
+	template<typename T, template<typename> class C>
+	GLM_FUNC_DECL C<T> max(
+		C<T> const& x,
+		C<T> const& y,
+		C<T> const& z);
+
+	/// Return the maximum component-wise values of 4 inputs
+	/// @see gtx_extented_min_max
+	template<typename T>
+	GLM_FUNC_DECL T max(
+		T const& x,
+		T const& y,
+		T const& z,
+		T const& w);
+
+	/// Return the maximum component-wise values of 4 inputs
+	/// @see gtx_extented_min_max
+	template<typename T, template<typename> class C>
+	GLM_FUNC_DECL C<T> max(
+		C<T> const& x,
+		typename C<T>::T const& y,
+		typename C<T>::T const& z,
+		typename C<T>::T const& w);
+
+	/// Return the maximum component-wise values of 4 inputs
+	/// @see gtx_extented_min_max
+	template<typename T, template<typename> class C>
+	GLM_FUNC_DECL C<T> max(
+		C<T> const& x,
+		C<T> const& y,
+		C<T> const& z,
+		C<T> const& w);
+
+	/// Returns y if y < x; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
+	///
+	/// @tparam genType Floating-point or integer; scalar or vector types.
+	///
+	/// @see gtx_extented_min_max
+	template<typename genType>
+	GLM_FUNC_DECL genType fmin(genType x, genType y);
+
+	/// Returns y if x < y; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
+	///
+	/// @tparam genType Floating-point; scalar or vector types.
+	///
+	/// @see gtx_extented_min_max
+	/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmax">std::fmax documentation</a>
+	template<typename genType>
+	GLM_FUNC_DECL genType fmax(genType x, genType y);
+
+	/// Returns min(max(x, minVal), maxVal) for each component in x. If one of the two arguments is NaN, the value of the other argument is returned.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see gtx_extented_min_max
+	template<typename genType>
+	GLM_FUNC_DECL genType fclamp(genType x, genType minVal, genType maxVal);
+
+	/// Returns min(max(x, minVal), maxVal) for each component in x. If one of the two arguments is NaN, the value of the other argument is returned.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see gtx_extented_min_max
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> fclamp(vec<L, T, Q> const& x, T minVal, T maxVal);
+
+	/// Returns min(max(x, minVal), maxVal) for each component in x. If one of the two arguments is NaN, the value of the other argument is returned.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see gtx_extented_min_max
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> fclamp(vec<L, T, Q> const& x, vec<L, T, Q> const& minVal, vec<L, T, Q> const& maxVal);
+
+
+	/// @}
+}//namespace glm
+
+#include "extended_min_max.inl"
diff --git a/engine/inc/glm/gtx/extended_min_max.inl b/engine/inc/glm/gtx/extended_min_max.inl
new file mode 100644
index 00000000..e72d1ccf
--- /dev/null
+++ b/engine/inc/glm/gtx/extended_min_max.inl
@@ -0,0 +1,218 @@
+/// @ref gtx_extended_min_max
+
+namespace glm
+{
+	template<typename T>
+	GLM_FUNC_QUALIFIER T min(
+		T const& x,
+		T const& y,
+		T const& z)
+	{
+		return glm::min(glm::min(x, y), z);
+	}
+
+	template<typename T, template<typename> class C>
+	GLM_FUNC_QUALIFIER C<T> min
+	(
+		C<T> const& x,
+		typename C<T>::T const& y,
+		typename C<T>::T const& z
+	)
+	{
+		return glm::min(glm::min(x, y), z);
+	}
+
+	template<typename T, template<typename> class C>
+	GLM_FUNC_QUALIFIER C<T> min
+	(
+		C<T> const& x,
+		C<T> const& y,
+		C<T> const& z
+	)
+	{
+		return glm::min(glm::min(x, y), z);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER T min
+	(
+		T const& x,
+		T const& y,
+		T const& z,
+		T const& w
+	)
+	{
+		return glm::min(glm::min(x, y), glm::min(z, w));
+	}
+
+	template<typename T, template<typename> class C>
+	GLM_FUNC_QUALIFIER C<T> min
+	(
+		C<T> const& x,
+		typename C<T>::T const& y,
+		typename C<T>::T const& z,
+		typename C<T>::T const& w
+	)
+	{
+		return glm::min(glm::min(x, y), glm::min(z, w));
+	}
+
+	template<typename T, template<typename> class C>
+	GLM_FUNC_QUALIFIER C<T> min
+	(
+		C<T> const& x,
+		C<T> const& y,
+		C<T> const& z,
+		C<T> const& w
+	)
+	{
+		return glm::min(glm::min(x, y), glm::min(z, w));
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER T max(
+		T const& x,
+		T const& y,
+		T const& z)
+	{
+		return glm::max(glm::max(x, y), z);
+	}
+
+	template<typename T, template<typename> class C>
+	GLM_FUNC_QUALIFIER C<T> max
+	(
+		C<T> const& x,
+		typename C<T>::T const& y,
+		typename C<T>::T const& z
+	)
+	{
+		return glm::max(glm::max(x, y), z);
+	}
+
+	template<typename T, template<typename> class C>
+	GLM_FUNC_QUALIFIER C<T> max
+	(
+		C<T> const& x,
+		C<T> const& y,
+		C<T> const& z
+	)
+	{
+		return glm::max(glm::max(x, y), z);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER T max
+	(
+		T const& x,
+		T const& y,
+		T const& z,
+		T const& w
+	)
+	{
+		return glm::max(glm::max(x, y), glm::max(z, w));
+	}
+
+	template<typename T, template<typename> class C>
+	GLM_FUNC_QUALIFIER C<T> max
+	(
+		C<T> const& x,
+		typename C<T>::T const& y,
+		typename C<T>::T const& z,
+		typename C<T>::T const& w
+	)
+	{
+		return glm::max(glm::max(x, y), glm::max(z, w));
+	}
+
+	template<typename T, template<typename> class C>
+	GLM_FUNC_QUALIFIER C<T> max
+	(
+		C<T> const& x,
+		C<T> const& y,
+		C<T> const& z,
+		C<T> const& w
+	)
+	{
+		return glm::max(glm::max(x, y), glm::max(z, w));
+	}
+
+	// fmin
+#	if GLM_HAS_CXX11_STL
+		using std::fmin;
+#	else
+		template<typename genType>
+		GLM_FUNC_QUALIFIER genType fmin(genType x, genType y)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'fmin' only accept floating-point input");
+
+			if (isnan(x))
+				return y;
+			if (isnan(y))
+				return x;
+
+			return min(x, y);
+		}
+#	endif
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fmin(vec<L, T, Q> const& a, T b)
+	{
+		return detail::functor2<vec, L, T, Q>::call(fmin, a, vec<L, T, Q>(b));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fmin(vec<L, T, Q> const& a, vec<L, T, Q> const& b)
+	{
+		return detail::functor2<vec, L, T, Q>::call(fmin, a, b);
+	}
+
+	// fmax
+#	if GLM_HAS_CXX11_STL
+		using std::fmax;
+#	else
+		template<typename genType>
+		GLM_FUNC_QUALIFIER genType fmax(genType x, genType y)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'fmax' only accept floating-point input");
+
+			if (isnan(x))
+				return y;
+			if (isnan(y))
+				return x;
+
+			return max(x, y);
+		}
+#	endif
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fmax(vec<L, T, Q> const& a, T b)
+	{
+		return detail::functor2<vec, L, T, Q>::call(fmax, a, vec<L, T, Q>(b));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fmax(vec<L, T, Q> const& a, vec<L, T, Q> const& b)
+	{
+		return detail::functor2<vec, L, T, Q>::call(fmax, a, b);
+	}
+
+	// fclamp
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType fclamp(genType x, genType minVal, genType maxVal)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'fclamp' only accept floating-point or integer inputs");
+		return fmin(fmax(x, minVal), maxVal);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fclamp(vec<L, T, Q> const& x, T minVal, T maxVal)
+	{
+		return fmin(fmax(x, vec<L, T, Q>(minVal)), vec<L, T, Q>(maxVal));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fclamp(vec<L, T, Q> const& x, vec<L, T, Q> const& minVal, vec<L, T, Q> const& maxVal)
+	{
+		return fmin(fmax(x, minVal), maxVal);
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/exterior_product.hpp b/engine/inc/glm/gtx/exterior_product.hpp
new file mode 100644
index 00000000..473630e3
--- /dev/null
+++ b/engine/inc/glm/gtx/exterior_product.hpp
@@ -0,0 +1,41 @@
+/// @ref gtx_exterior_product
+/// @file glm/gtx/exterior_product.hpp
+///
+/// @see core (dependence)
+/// @see gtx_exterior_product (dependence)
+///
+/// @defgroup gtx_exterior_product GLM_GTX_exterior_product
+/// @ingroup gtx
+///
+/// Include <glm/gtx/exterior_product.hpp> to use the features of this extension.
+///
+/// @brief Allow to perform bit operations on integer values
+
+#pragma once
+
+// Dependencies
+#include "../detail/setup.hpp"
+#include "../detail/qualifier.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_exterior_product extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_exterior_product
+	/// @{
+
+	/// Returns the cross product of x and y.
+	///
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="https://en.wikipedia.org/wiki/Exterior_algebra#Cross_and_triple_products">Exterior product</a>
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL T cross(vec<2, T, Q> const& v, vec<2, T, Q> const& u);
+
+	/// @}
+} //namespace glm
+
+#include "exterior_product.inl"
diff --git a/engine/inc/glm/gtx/exterior_product.inl b/engine/inc/glm/gtx/exterior_product.inl
new file mode 100644
index 00000000..93661fd3
--- /dev/null
+++ b/engine/inc/glm/gtx/exterior_product.inl
@@ -0,0 +1,26 @@
+/// @ref gtx_exterior_product
+
+#include <limits>
+
+namespace glm {
+namespace detail
+{
+	template<typename T, qualifier Q, bool Aligned>
+	struct compute_cross_vec2
+	{
+		GLM_FUNC_QUALIFIER static T call(vec<2, T, Q> const& v, vec<2, T, Q> const& u)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'cross' accepts only floating-point inputs");
+
+			return v.x * u.y - u.x * v.y;
+		}
+	};
+}//namespace detail
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T cross(vec<2, T, Q> const& x, vec<2, T, Q> const& y)
+	{
+		return detail::compute_cross_vec2<T, Q, detail::is_aligned<Q>::value>::call(x, y);
+	}
+}//namespace glm
+
diff --git a/engine/inc/glm/gtx/fast_exponential.hpp b/engine/inc/glm/gtx/fast_exponential.hpp
new file mode 100644
index 00000000..64e68ac2
--- /dev/null
+++ b/engine/inc/glm/gtx/fast_exponential.hpp
@@ -0,0 +1,95 @@
+/// @ref gtx_fast_exponential
+/// @file glm/gtx/fast_exponential.hpp
+///
+/// @see core (dependence)
+/// @see gtx_half_float (dependence)
+///
+/// @defgroup gtx_fast_exponential GLM_GTX_fast_exponential
+/// @ingroup gtx
+///
+/// Include <glm/gtx/fast_exponential.hpp> to use the features of this extension.
+///
+/// Fast but less accurate implementations of exponential based functions.
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_fast_exponential is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_fast_exponential extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_fast_exponential
+	/// @{
+
+	/// Faster than the common pow function but less accurate.
+	/// @see gtx_fast_exponential
+	template<typename genType>
+	GLM_FUNC_DECL genType fastPow(genType x, genType y);
+
+	/// Faster than the common pow function but less accurate.
+	/// @see gtx_fast_exponential
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> fastPow(vec<L, T, Q> const& x, vec<L, T, Q> const& y);
+
+	/// Faster than the common pow function but less accurate.
+	/// @see gtx_fast_exponential
+	template<typename genTypeT, typename genTypeU>
+	GLM_FUNC_DECL genTypeT fastPow(genTypeT x, genTypeU y);
+
+	/// Faster than the common pow function but less accurate.
+	/// @see gtx_fast_exponential
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> fastPow(vec<L, T, Q> const& x);
+
+	/// Faster than the common exp function but less accurate.
+	/// @see gtx_fast_exponential
+	template<typename T>
+	GLM_FUNC_DECL T fastExp(T x);
+
+	/// Faster than the common exp function but less accurate.
+	/// @see gtx_fast_exponential
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> fastExp(vec<L, T, Q> const& x);
+
+	/// Faster than the common log function but less accurate.
+	/// @see gtx_fast_exponential
+	template<typename T>
+	GLM_FUNC_DECL T fastLog(T x);
+
+	/// Faster than the common exp2 function but less accurate.
+	/// @see gtx_fast_exponential
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> fastLog(vec<L, T, Q> const& x);
+
+	/// Faster than the common exp2 function but less accurate.
+	/// @see gtx_fast_exponential
+	template<typename T>
+	GLM_FUNC_DECL T fastExp2(T x);
+
+	/// Faster than the common exp2 function but less accurate.
+	/// @see gtx_fast_exponential
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> fastExp2(vec<L, T, Q> const& x);
+
+	/// Faster than the common log2 function but less accurate.
+	/// @see gtx_fast_exponential
+	template<typename T>
+	GLM_FUNC_DECL T fastLog2(T x);
+
+	/// Faster than the common log2 function but less accurate.
+	/// @see gtx_fast_exponential
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> fastLog2(vec<L, T, Q> const& x);
+
+	/// @}
+}//namespace glm
+
+#include "fast_exponential.inl"
diff --git a/engine/inc/glm/gtx/fast_exponential.inl b/engine/inc/glm/gtx/fast_exponential.inl
new file mode 100644
index 00000000..f139e505
--- /dev/null
+++ b/engine/inc/glm/gtx/fast_exponential.inl
@@ -0,0 +1,136 @@
+/// @ref gtx_fast_exponential
+
+namespace glm
+{
+	// fastPow:
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType fastPow(genType x, genType y)
+	{
+		return exp(y * log(x));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fastPow(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+	{
+		return exp(y * log(x));
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER T fastPow(T x, int y)
+	{
+		T f = static_cast<T>(1);
+		for(int i = 0; i < y; ++i)
+			f *= x;
+		return f;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fastPow(vec<L, T, Q> const& x, vec<L, int, Q> const& y)
+	{
+		vec<L, T, Q> Result;
+		for(length_t i = 0, n = x.length(); i < n; ++i)
+			Result[i] = fastPow(x[i], y[i]);
+		return Result;
+	}
+
+	// fastExp
+	// Note: This function provides accurate results only for value between -1 and 1, else avoid it.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T fastExp(T x)
+	{
+		// This has a better looking and same performance in release mode than the following code. However, in debug mode it's slower.
+		// return 1.0f + x * (1.0f + x * 0.5f * (1.0f + x * 0.3333333333f * (1.0f + x * 0.25 * (1.0f + x * 0.2f))));
+		T x2 = x * x;
+		T x3 = x2 * x;
+		T x4 = x3 * x;
+		T x5 = x4 * x;
+		return T(1) + x + (x2 * T(0.5)) + (x3 * T(0.1666666667)) + (x4 * T(0.041666667)) + (x5 * T(0.008333333333));
+	}
+	/*  // Try to handle all values of float... but often shower than std::exp, glm::floor and the loop kill the performance
+	GLM_FUNC_QUALIFIER float fastExp(float x)
+	{
+		const float e = 2.718281828f;
+		const float IntegerPart = floor(x);
+		const float FloatPart = x - IntegerPart;
+		float z = 1.f;
+
+		for(int i = 0; i < int(IntegerPart); ++i)
+			z *= e;
+
+		const float x2 = FloatPart * FloatPart;
+		const float x3 = x2 * FloatPart;
+		const float x4 = x3 * FloatPart;
+		const float x5 = x4 * FloatPart;
+		return z * (1.0f + FloatPart + (x2 * 0.5f) + (x3 * 0.1666666667f) + (x4 * 0.041666667f) + (x5 * 0.008333333333f));
+	}
+
+	// Increase accuracy on number bigger that 1 and smaller than -1 but it's not enough for high and negative numbers
+	GLM_FUNC_QUALIFIER float fastExp(float x)
+	{
+		// This has a better looking and same performance in release mode than the following code. However, in debug mode it's slower.
+		// return 1.0f + x * (1.0f + x * 0.5f * (1.0f + x * 0.3333333333f * (1.0f + x * 0.25 * (1.0f + x * 0.2f))));
+		float x2 = x * x;
+		float x3 = x2 * x;
+		float x4 = x3 * x;
+		float x5 = x4 * x;
+		float x6 = x5 * x;
+		float x7 = x6 * x;
+		float x8 = x7 * x;
+		return 1.0f + x + (x2 * 0.5f) + (x3 * 0.1666666667f) + (x4 * 0.041666667f) + (x5 * 0.008333333333f)+ (x6 * 0.00138888888888f) + (x7 * 0.000198412698f) + (x8 * 0.0000248015873f);;
+	}
+	*/
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fastExp(vec<L, T, Q> const& x)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(fastExp, x);
+	}
+
+	// fastLog
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType fastLog(genType x)
+	{
+		return std::log(x);
+	}
+
+	/* Slower than the VC7.1 function...
+	GLM_FUNC_QUALIFIER float fastLog(float x)
+	{
+		float y1 = (x - 1.0f) / (x + 1.0f);
+		float y2 = y1 * y1;
+		return 2.0f * y1 * (1.0f + y2 * (0.3333333333f + y2 * (0.2f + y2 * 0.1428571429f)));
+	}
+	*/
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fastLog(vec<L, T, Q> const& x)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(fastLog, x);
+	}
+
+	//fastExp2, ln2 = 0.69314718055994530941723212145818f
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType fastExp2(genType x)
+	{
+		return fastExp(0.69314718055994530941723212145818f * x);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fastExp2(vec<L, T, Q> const& x)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(fastExp2, x);
+	}
+
+	// fastLog2, ln2 = 0.69314718055994530941723212145818f
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType fastLog2(genType x)
+	{
+		return fastLog(x) / 0.69314718055994530941723212145818f;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fastLog2(vec<L, T, Q> const& x)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(fastLog2, x);
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/fast_square_root.hpp b/engine/inc/glm/gtx/fast_square_root.hpp
new file mode 100644
index 00000000..275ac11a
--- /dev/null
+++ b/engine/inc/glm/gtx/fast_square_root.hpp
@@ -0,0 +1,92 @@
+/// @ref gtx_fast_square_root
+/// @file glm/gtx/fast_square_root.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_fast_square_root GLM_GTX_fast_square_root
+/// @ingroup gtx
+///
+/// Include <glm/gtx/fast_square_root.hpp> to use the features of this extension.
+///
+/// Fast but less accurate implementations of square root based functions.
+/// - Sqrt optimisation based on Newton's method,
+/// www.gamedev.net/community/forums/topic.asp?topic id=139956
+
+#pragma once
+
+// Dependency:
+#include "../common.hpp"
+#include "../exponential.hpp"
+#include "../geometric.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_fast_square_root is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_fast_square_root extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_fast_square_root
+	/// @{
+
+	/// Faster than the common sqrt function but less accurate.
+	///
+	/// @see gtx_fast_square_root extension.
+	template<typename genType>
+	GLM_FUNC_DECL genType fastSqrt(genType x);
+
+	/// Faster than the common sqrt function but less accurate.
+	///
+	/// @see gtx_fast_square_root extension.
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> fastSqrt(vec<L, T, Q> const& x);
+
+	/// Faster than the common inversesqrt function but less accurate.
+	///
+	/// @see gtx_fast_square_root extension.
+	template<typename genType>
+	GLM_FUNC_DECL genType fastInverseSqrt(genType x);
+
+	/// Faster than the common inversesqrt function but less accurate.
+	///
+	/// @see gtx_fast_square_root extension.
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> fastInverseSqrt(vec<L, T, Q> const& x);
+
+	/// Faster than the common length function but less accurate.
+	///
+	/// @see gtx_fast_square_root extension.
+	template<typename genType>
+	GLM_FUNC_DECL genType fastLength(genType x);
+
+	/// Faster than the common length function but less accurate.
+	///
+	/// @see gtx_fast_square_root extension.
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL T fastLength(vec<L, T, Q> const& x);
+
+	/// Faster than the common distance function but less accurate.
+	///
+	/// @see gtx_fast_square_root extension.
+	template<typename genType>
+	GLM_FUNC_DECL genType fastDistance(genType x, genType y);
+
+	/// Faster than the common distance function but less accurate.
+	///
+	/// @see gtx_fast_square_root extension.
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL T fastDistance(vec<L, T, Q> const& x, vec<L, T, Q> const& y);
+
+	/// Faster than the common normalize function but less accurate.
+	///
+	/// @see gtx_fast_square_root extension.
+	template<typename genType>
+	GLM_FUNC_DECL genType fastNormalize(genType const& x);
+
+	/// @}
+}// namespace glm
+
+#include "fast_square_root.inl"
diff --git a/engine/inc/glm/gtx/fast_square_root.inl b/engine/inc/glm/gtx/fast_square_root.inl
new file mode 100644
index 00000000..0bc35900
--- /dev/null
+++ b/engine/inc/glm/gtx/fast_square_root.inl
@@ -0,0 +1,80 @@
+/// @ref gtx_fast_square_root
+
+namespace glm
+{
+	// fastSqrt
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType fastSqrt(genType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'fastSqrt' only accept floating-point input");
+
+		return genType(1) / fastInverseSqrt(x);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fastSqrt(vec<L, T, Q> const& x)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(fastSqrt, x);
+	}
+
+	// fastInversesqrt
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType fastInverseSqrt(genType x)
+	{
+#		ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6
+			vec<1, T, Q> tmp(detail::compute_inversesqrt<tvec1, genType, lowp, detail::is_aligned<lowp>::value>::call(vec<1, genType, lowp>(x)));
+			return tmp.x;
+#		else
+			return detail::compute_inversesqrt<1, genType, lowp, detail::is_aligned<lowp>::value>::call(vec<1, genType, lowp>(x)).x;
+#		endif
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fastInverseSqrt(vec<L, T, Q> const& x)
+	{
+		return detail::compute_inversesqrt<L, T, Q, detail::is_aligned<Q>::value>::call(x);
+	}
+
+	// fastLength
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType fastLength(genType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'fastLength' only accept floating-point inputs");
+
+		return abs(x);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T fastLength(vec<L, T, Q> const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'fastLength' only accept floating-point inputs");
+
+		return fastSqrt(dot(x, x));
+	}
+
+	// fastDistance
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType fastDistance(genType x, genType y)
+	{
+		return fastLength(y - x);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T fastDistance(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+	{
+		return fastLength(y - x);
+	}
+
+	// fastNormalize
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType fastNormalize(genType x)
+	{
+		return x > genType(0) ? genType(1) : -genType(1);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fastNormalize(vec<L, T, Q> const& x)
+	{
+		return x * fastInverseSqrt(dot(x, x));
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/fast_trigonometry.hpp b/engine/inc/glm/gtx/fast_trigonometry.hpp
new file mode 100644
index 00000000..c49dd7d8
--- /dev/null
+++ b/engine/inc/glm/gtx/fast_trigonometry.hpp
@@ -0,0 +1,79 @@
+/// @ref gtx_fast_trigonometry
+/// @file glm/gtx/fast_trigonometry.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_fast_trigonometry GLM_GTX_fast_trigonometry
+/// @ingroup gtx
+///
+/// Include <glm/gtx/fast_trigonometry.hpp> to use the features of this extension.
+///
+/// Fast but less accurate implementations of trigonometric functions.
+
+#pragma once
+
+// Dependency:
+#include "../gtc/constants.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_fast_trigonometry is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_fast_trigonometry extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_fast_trigonometry
+	/// @{
+
+	/// Wrap an angle to [0 2pi[
+	/// From GLM_GTX_fast_trigonometry extension.
+	template<typename T>
+	GLM_FUNC_DECL T wrapAngle(T angle);
+
+	/// Faster than the common sin function but less accurate.
+	/// From GLM_GTX_fast_trigonometry extension.
+	template<typename T>
+	GLM_FUNC_DECL T fastSin(T angle);
+
+	/// Faster than the common cos function but less accurate.
+	/// From GLM_GTX_fast_trigonometry extension.
+	template<typename T>
+	GLM_FUNC_DECL T fastCos(T angle);
+
+	/// Faster than the common tan function but less accurate.
+	/// Defined between -2pi and 2pi.
+	/// From GLM_GTX_fast_trigonometry extension.
+	template<typename T>
+	GLM_FUNC_DECL T fastTan(T angle);
+
+	/// Faster than the common asin function but less accurate.
+	/// Defined between -2pi and 2pi.
+	/// From GLM_GTX_fast_trigonometry extension.
+	template<typename T>
+	GLM_FUNC_DECL T fastAsin(T angle);
+
+	/// Faster than the common acos function but less accurate.
+	/// Defined between -2pi and 2pi.
+	/// From GLM_GTX_fast_trigonometry extension.
+	template<typename T>
+	GLM_FUNC_DECL T fastAcos(T angle);
+
+	/// Faster than the common atan function but less accurate.
+	/// Defined between -2pi and 2pi.
+	/// From GLM_GTX_fast_trigonometry extension.
+	template<typename T>
+	GLM_FUNC_DECL T fastAtan(T y, T x);
+
+	/// Faster than the common atan function but less accurate.
+	/// Defined between -2pi and 2pi.
+	/// From GLM_GTX_fast_trigonometry extension.
+	template<typename T>
+	GLM_FUNC_DECL T fastAtan(T angle);
+
+	/// @}
+}//namespace glm
+
+#include "fast_trigonometry.inl"
diff --git a/engine/inc/glm/gtx/fast_trigonometry.inl b/engine/inc/glm/gtx/fast_trigonometry.inl
new file mode 100644
index 00000000..1a710cbc
--- /dev/null
+++ b/engine/inc/glm/gtx/fast_trigonometry.inl
@@ -0,0 +1,142 @@
+/// @ref gtx_fast_trigonometry
+
+namespace glm{
+namespace detail
+{
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> taylorCos(vec<L, T, Q> const& x)
+	{
+		return static_cast<T>(1)
+			- (x * x) * (1.f / 2.f)
+			+ ((x * x) * (x * x)) * (1.f / 24.f)
+			- (((x * x) * (x * x)) * (x * x)) * (1.f / 720.f)
+			+ (((x * x) * (x * x)) * ((x * x) * (x * x))) * (1.f / 40320.f);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER T cos_52s(T x)
+	{
+		T const xx(x * x);
+		return (T(0.9999932946) + xx * (T(-0.4999124376) + xx * (T(0.0414877472) + xx * T(-0.0012712095))));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> cos_52s(vec<L, T, Q> const& x)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(cos_52s, x);
+	}
+}//namespace detail
+
+	// wrapAngle
+	template<typename T>
+	GLM_FUNC_QUALIFIER T wrapAngle(T angle)
+	{
+		return abs<T>(mod<T>(angle, two_pi<T>()));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> wrapAngle(vec<L, T, Q> const& x)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(wrapAngle, x);
+	}
+
+	// cos
+	template<typename T>
+	GLM_FUNC_QUALIFIER T fastCos(T x)
+	{
+		T const angle(wrapAngle<T>(x));
+
+		if(angle < half_pi<T>())
+			return detail::cos_52s(angle);
+		if(angle < pi<T>())
+			return -detail::cos_52s(pi<T>() - angle);
+		if(angle < (T(3) * half_pi<T>()))
+			return -detail::cos_52s(angle - pi<T>());
+
+		return detail::cos_52s(two_pi<T>() - angle);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fastCos(vec<L, T, Q> const& x)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(fastCos, x);
+	}
+
+	// sin
+	template<typename T>
+	GLM_FUNC_QUALIFIER T fastSin(T x)
+	{
+		return fastCos<T>(half_pi<T>() - x);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fastSin(vec<L, T, Q> const& x)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(fastSin, x);
+	}
+
+	// tan
+	template<typename T>
+	GLM_FUNC_QUALIFIER T fastTan(T x)
+	{
+		return x + (x * x * x * T(0.3333333333)) + (x * x * x * x * x * T(0.1333333333333)) + (x * x * x * x * x * x * x * T(0.0539682539));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fastTan(vec<L, T, Q> const& x)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(fastTan, x);
+	}
+
+	// asin
+	template<typename T>
+	GLM_FUNC_QUALIFIER T fastAsin(T x)
+	{
+		return x + (x * x * x * T(0.166666667)) + (x * x * x * x * x * T(0.075)) + (x * x * x * x * x * x * x * T(0.0446428571)) + (x * x * x * x * x * x * x * x * x * T(0.0303819444));// + (x * x * x * x * x * x * x * x * x * x * x * T(0.022372159));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fastAsin(vec<L, T, Q> const& x)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(fastAsin, x);
+	}
+
+	// acos
+	template<typename T>
+	GLM_FUNC_QUALIFIER T fastAcos(T x)
+	{
+		return T(1.5707963267948966192313216916398) - fastAsin(x); //(PI / 2)
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fastAcos(vec<L, T, Q> const& x)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(fastAcos, x);
+	}
+
+	// atan
+	template<typename T>
+	GLM_FUNC_QUALIFIER T fastAtan(T y, T x)
+	{
+		T sgn = sign(y) * sign(x);
+		return abs(fastAtan(y / x)) * sgn;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fastAtan(vec<L, T, Q> const& y, vec<L, T, Q> const& x)
+	{
+		return detail::functor2<vec, L, T, Q>::call(fastAtan, y, x);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER T fastAtan(T x)
+	{
+		return x - (x * x * x * T(0.333333333333)) + (x * x * x * x * x * T(0.2)) - (x * x * x * x * x * x * x * T(0.1428571429)) + (x * x * x * x * x * x * x * x * x * T(0.111111111111)) - (x * x * x * x * x * x * x * x * x * x * x * T(0.0909090909));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fastAtan(vec<L, T, Q> const& x)
+	{
+		return detail::functor1<vec, L, T, T, Q>::call(fastAtan, x);
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/float_notmalize.inl b/engine/inc/glm/gtx/float_notmalize.inl
new file mode 100644
index 00000000..8cdbc5aa
--- /dev/null
+++ b/engine/inc/glm/gtx/float_notmalize.inl
@@ -0,0 +1,13 @@
+/// @ref gtx_float_normalize
+
+#include <limits>
+
+namespace glm
+{
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, float, Q> floatNormalize(vec<L, T, Q> const& v)
+	{
+		return vec<L, float, Q>(v) / static_cast<float>(std::numeric_limits<T>::max());
+	}
+
+}//namespace glm
diff --git a/engine/inc/glm/gtx/functions.hpp b/engine/inc/glm/gtx/functions.hpp
new file mode 100644
index 00000000..6bd746c4
--- /dev/null
+++ b/engine/inc/glm/gtx/functions.hpp
@@ -0,0 +1,52 @@
+/// @ref gtx_functions
+/// @file glm/gtx/functions.hpp
+///
+/// @see core (dependence)
+/// @see gtc_quaternion (dependence)
+///
+/// @defgroup gtx_functions GLM_GTX_functions
+/// @ingroup gtx
+///
+/// Include <glm/gtx/functions.hpp> to use the features of this extension.
+///
+/// List of useful common functions.
+
+#pragma once
+
+// Dependencies
+#include "../detail/setup.hpp"
+#include "../detail/qualifier.hpp"
+#include "../detail/type_vec2.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_functions extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_functions
+	/// @{
+
+	/// 1D gauss function
+	///
+	/// @see gtc_epsilon
+	template<typename T>
+	GLM_FUNC_DECL T gauss(
+		T x,
+		T ExpectedValue,
+		T StandardDeviation);
+
+	/// 2D gauss function
+	///
+	/// @see gtc_epsilon
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL T gauss(
+		vec<2, T, Q> const& Coord,
+		vec<2, T, Q> const& ExpectedValue,
+		vec<2, T, Q> const& StandardDeviation);
+
+	/// @}
+}//namespace glm
+
+#include "functions.inl"
+
diff --git a/engine/inc/glm/gtx/functions.inl b/engine/inc/glm/gtx/functions.inl
new file mode 100644
index 00000000..29cbb20b
--- /dev/null
+++ b/engine/inc/glm/gtx/functions.inl
@@ -0,0 +1,30 @@
+/// @ref gtx_functions
+
+#include "../exponential.hpp"
+
+namespace glm
+{
+	template<typename T>
+	GLM_FUNC_QUALIFIER T gauss
+	(
+		T x,
+		T ExpectedValue,
+		T StandardDeviation
+	)
+	{
+		return exp(-((x - ExpectedValue) * (x - ExpectedValue)) / (static_cast<T>(2) * StandardDeviation * StandardDeviation)) / (StandardDeviation * sqrt(static_cast<T>(6.28318530717958647692528676655900576)));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T gauss
+	(
+		vec<2, T, Q> const& Coord,
+		vec<2, T, Q> const& ExpectedValue,
+		vec<2, T, Q> const& StandardDeviation
+	)
+	{
+		vec<2, T, Q> const Squared = ((Coord - ExpectedValue) * (Coord - ExpectedValue)) / (static_cast<T>(2) * StandardDeviation * StandardDeviation);
+		return exp(-(Squared.x + Squared.y));
+	}
+}//namespace glm
+
diff --git a/engine/inc/glm/gtx/gradient_paint.hpp b/engine/inc/glm/gtx/gradient_paint.hpp
new file mode 100644
index 00000000..2749c080
--- /dev/null
+++ b/engine/inc/glm/gtx/gradient_paint.hpp
@@ -0,0 +1,53 @@
+/// @ref gtx_gradient_paint
+/// @file glm/gtx/gradient_paint.hpp
+///
+/// @see core (dependence)
+/// @see gtx_optimum_pow (dependence)
+///
+/// @defgroup gtx_gradient_paint GLM_GTX_gradient_paint
+/// @ingroup gtx
+///
+/// Include <glm/gtx/gradient_paint.hpp> to use the features of this extension.
+///
+/// Functions that return the color of procedural gradient for specific coordinates.
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtx/optimum_pow.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_gradient_paint is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_gradient_paint extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_gradient_paint
+	/// @{
+
+	/// Return a color from a radial gradient.
+	/// @see - gtx_gradient_paint
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL T radialGradient(
+		vec<2, T, Q> const& Center,
+		T const& Radius,
+		vec<2, T, Q> const& Focal,
+		vec<2, T, Q> const& Position);
+
+	/// Return a color from a linear gradient.
+	/// @see - gtx_gradient_paint
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL T linearGradient(
+		vec<2, T, Q> const& Point0,
+		vec<2, T, Q> const& Point1,
+		vec<2, T, Q> const& Position);
+
+	/// @}
+}// namespace glm
+
+#include "gradient_paint.inl"
diff --git a/engine/inc/glm/gtx/gradient_paint.inl b/engine/inc/glm/gtx/gradient_paint.inl
new file mode 100644
index 00000000..4c495e62
--- /dev/null
+++ b/engine/inc/glm/gtx/gradient_paint.inl
@@ -0,0 +1,36 @@
+/// @ref gtx_gradient_paint
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T radialGradient
+	(
+		vec<2, T, Q> const& Center,
+		T const& Radius,
+		vec<2, T, Q> const& Focal,
+		vec<2, T, Q> const& Position
+	)
+	{
+		vec<2, T, Q> F = Focal - Center;
+		vec<2, T, Q> D = Position - Focal;
+		T Radius2 = pow2(Radius);
+		T Fx2 = pow2(F.x);
+		T Fy2 = pow2(F.y);
+
+		T Numerator = (D.x * F.x + D.y * F.y) + sqrt(Radius2 * (pow2(D.x) + pow2(D.y)) - pow2(D.x * F.y - D.y * F.x));
+		T Denominator = Radius2 - (Fx2 + Fy2);
+		return Numerator / Denominator;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T linearGradient
+	(
+		vec<2, T, Q> const& Point0,
+		vec<2, T, Q> const& Point1,
+		vec<2, T, Q> const& Position
+	)
+	{
+		vec<2, T, Q> Dist = Point1 - Point0;
+		return (Dist.x * (Position.x - Point0.x) + Dist.y * (Position.y - Point0.y)) / glm::dot(Dist, Dist);
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/handed_coordinate_space.hpp b/engine/inc/glm/gtx/handed_coordinate_space.hpp
new file mode 100644
index 00000000..d47230fc
--- /dev/null
+++ b/engine/inc/glm/gtx/handed_coordinate_space.hpp
@@ -0,0 +1,50 @@
+/// @ref gtx_handed_coordinate_space
+/// @file glm/gtx/handed_coordinate_space.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_handed_coordinate_space GLM_GTX_handed_coordinate_space
+/// @ingroup gtx
+///
+/// Include <glm/gtx/handed_coordinate_system.hpp> to use the features of this extension.
+///
+/// To know if a set of three basis vectors defines a right or left-handed coordinate system.
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_handed_coordinate_space is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_handed_coordinate_space extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_handed_coordinate_space
+	/// @{
+
+	//! Return if a trihedron right handed or not.
+	//! From GLM_GTX_handed_coordinate_space extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool rightHanded(
+		vec<3, T, Q> const& tangent,
+		vec<3, T, Q> const& binormal,
+		vec<3, T, Q> const& normal);
+
+	//! Return if a trihedron left handed or not.
+	//! From GLM_GTX_handed_coordinate_space extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool leftHanded(
+		vec<3, T, Q> const& tangent,
+		vec<3, T, Q> const& binormal,
+		vec<3, T, Q> const& normal);
+
+	/// @}
+}// namespace glm
+
+#include "handed_coordinate_space.inl"
diff --git a/engine/inc/glm/gtx/handed_coordinate_space.inl b/engine/inc/glm/gtx/handed_coordinate_space.inl
new file mode 100644
index 00000000..e43c17bd
--- /dev/null
+++ b/engine/inc/glm/gtx/handed_coordinate_space.inl
@@ -0,0 +1,26 @@
+/// @ref gtx_handed_coordinate_space
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool rightHanded
+	(
+		vec<3, T, Q> const& tangent,
+		vec<3, T, Q> const& binormal,
+		vec<3, T, Q> const& normal
+	)
+	{
+		return dot(cross(normal, tangent), binormal) > T(0);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool leftHanded
+	(
+		vec<3, T, Q> const& tangent,
+		vec<3, T, Q> const& binormal,
+		vec<3, T, Q> const& normal
+	)
+	{
+		return dot(cross(normal, tangent), binormal) < T(0);
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/hash.hpp b/engine/inc/glm/gtx/hash.hpp
new file mode 100644
index 00000000..3196be7e
--- /dev/null
+++ b/engine/inc/glm/gtx/hash.hpp
@@ -0,0 +1,138 @@
+/// @ref gtx_hash
+/// @file glm/gtx/hash.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_hash GLM_GTX_hash
+/// @ingroup gtx
+///
+/// Include <glm/gtx/hash.hpp> to use the features of this extension.
+///
+/// Add std::hash support for glm types
+
+#pragma once
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_hash is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#include <functional>
+
+#include "../vec2.hpp"
+#include "../vec3.hpp"
+#include "../vec4.hpp"
+#include "../gtc/vec1.hpp"
+
+#include "../gtc/quaternion.hpp"
+#include "../gtx/dual_quaternion.hpp"
+
+#include "../mat2x2.hpp"
+#include "../mat2x3.hpp"
+#include "../mat2x4.hpp"
+
+#include "../mat3x2.hpp"
+#include "../mat3x3.hpp"
+#include "../mat3x4.hpp"
+
+#include "../mat4x2.hpp"
+#include "../mat4x3.hpp"
+#include "../mat4x4.hpp"
+
+#if !GLM_HAS_CXX11_STL
+#	error "GLM_GTX_hash requires C++11 standard library support"
+#endif
+
+namespace std
+{
+	template<typename T, glm::qualifier Q>
+	struct hash<glm::vec<1, T,Q> >
+	{
+		GLM_FUNC_DECL size_t operator()(glm::vec<1, T, Q> const& v) const;
+	};
+
+	template<typename T, glm::qualifier Q>
+	struct hash<glm::vec<2, T,Q> >
+	{
+		GLM_FUNC_DECL size_t operator()(glm::vec<2, T, Q> const& v) const;
+	};
+
+	template<typename T, glm::qualifier Q>
+	struct hash<glm::vec<3, T,Q> >
+	{
+		GLM_FUNC_DECL size_t operator()(glm::vec<3, T, Q> const& v) const;
+	};
+
+	template<typename T, glm::qualifier Q>
+	struct hash<glm::vec<4, T,Q> >
+	{
+		GLM_FUNC_DECL size_t operator()(glm::vec<4, T, Q> const& v) const;
+	};
+
+	template<typename T, glm::qualifier Q>
+	struct hash<glm::tquat<T,Q>>
+	{
+		GLM_FUNC_DECL size_t operator()(glm::tquat<T, Q> const& q) const;
+	};
+
+	template<typename T, glm::qualifier Q>
+	struct hash<glm::tdualquat<T,Q> >
+	{
+		GLM_FUNC_DECL size_t operator()(glm::tdualquat<T,Q> const& q) const;
+	};
+
+	template<typename T, glm::qualifier Q>
+	struct hash<glm::mat<2, 2, T,Q> >
+	{
+		GLM_FUNC_DECL size_t operator()(glm::mat<2, 2, T,Q> const& m) const;
+	};
+
+	template<typename T, glm::qualifier Q>
+	struct hash<glm::mat<2, 3, T,Q> >
+	{
+		GLM_FUNC_DECL size_t operator()(glm::mat<2, 3, T,Q> const& m) const;
+	};
+
+	template<typename T, glm::qualifier Q>
+	struct hash<glm::mat<2, 4, T,Q> >
+	{
+		GLM_FUNC_DECL size_t operator()(glm::mat<2, 4, T,Q> const& m) const;
+	};
+
+	template<typename T, glm::qualifier Q>
+	struct hash<glm::mat<3, 2, T,Q> >
+	{
+		GLM_FUNC_DECL size_t operator()(glm::mat<3, 2, T,Q> const& m) const;
+	};
+
+	template<typename T, glm::qualifier Q>
+	struct hash<glm::mat<3, 3, T,Q> >
+	{
+		GLM_FUNC_DECL size_t operator()(glm::mat<3, 3, T,Q> const& m) const;
+	};
+
+	template<typename T, glm::qualifier Q>
+	struct hash<glm::mat<3, 4, T,Q> >
+	{
+		GLM_FUNC_DECL size_t operator()(glm::mat<3, 4, T,Q> const& m) const;
+	};
+
+	template<typename T, glm::qualifier Q>
+	struct hash<glm::mat<4, 2, T,Q> >
+	{
+		GLM_FUNC_DECL size_t operator()(glm::mat<4, 2, T,Q> const& m) const;
+	};
+
+	template<typename T, glm::qualifier Q>
+	struct hash<glm::mat<4, 3, T,Q> >
+	{
+		GLM_FUNC_DECL size_t operator()(glm::mat<4, 3, T,Q> const& m) const;
+	};
+
+	template<typename T, glm::qualifier Q>
+	struct hash<glm::mat<4, 4, T,Q> >
+	{
+		GLM_FUNC_DECL size_t operator()(glm::mat<4, 4, T,Q> const& m) const;
+	};
+} // namespace std
+
+#include "hash.inl"
diff --git a/engine/inc/glm/gtx/hash.inl b/engine/inc/glm/gtx/hash.inl
new file mode 100644
index 00000000..64443ef8
--- /dev/null
+++ b/engine/inc/glm/gtx/hash.inl
@@ -0,0 +1,184 @@
+/// @ref gtx_hash
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_hash GLM_GTX_hash
+/// @ingroup gtx
+///
+/// @brief Add std::hash support for glm types
+///
+/// <glm/gtx/hash.inl> need to be included to use the features of this extension.
+
+namespace glm {
+namespace detail
+{
+	GLM_INLINE void hash_combine(size_t &seed, size_t hash)
+	{
+		hash += 0x9e3779b9 + (seed << 6) + (seed >> 2);
+		seed ^= hash;
+	}
+}}
+
+namespace std
+{
+	template<typename T, glm::qualifier Q>
+	GLM_FUNC_QUALIFIER size_t hash<glm::vec<1, T, Q>>::operator()(glm::vec<1, T, Q> const& v) const
+	{
+		hash<T> hasher;
+		return hasher(v.x);
+	}
+
+	template<typename T, glm::qualifier Q>
+	GLM_FUNC_QUALIFIER size_t hash<glm::vec<2, T, Q>>::operator()(glm::vec<2, T, Q> const& v) const
+	{
+		size_t seed = 0;
+		hash<T> hasher;
+		glm::detail::hash_combine(seed, hasher(v.x));
+		glm::detail::hash_combine(seed, hasher(v.y));
+		return seed;
+	}
+
+	template<typename T, glm::qualifier Q>
+	GLM_FUNC_QUALIFIER size_t hash<glm::vec<3, T, Q>>::operator()(glm::vec<3, T, Q> const& v) const
+	{
+		size_t seed = 0;
+		hash<T> hasher;
+		glm::detail::hash_combine(seed, hasher(v.x));
+		glm::detail::hash_combine(seed, hasher(v.y));
+		glm::detail::hash_combine(seed, hasher(v.z));
+		return seed;
+	}
+
+	template<typename T, glm::qualifier Q>
+	GLM_FUNC_QUALIFIER size_t hash<glm::vec<4, T, Q>>::operator()(glm::vec<4, T, Q> const& v) const
+	{
+		size_t seed = 0;
+		hash<T> hasher;
+		glm::detail::hash_combine(seed, hasher(v.x));
+		glm::detail::hash_combine(seed, hasher(v.y));
+		glm::detail::hash_combine(seed, hasher(v.z));
+		glm::detail::hash_combine(seed, hasher(v.w));
+		return seed;
+	}
+
+	template<typename T, glm::qualifier Q>
+	GLM_FUNC_QUALIFIER size_t hash<glm::tquat<T, Q>>::operator()(glm::tquat<T,Q> const& q) const
+	{
+		size_t seed = 0;
+		hash<T> hasher;
+		glm::detail::hash_combine(seed, hasher(q.x));
+		glm::detail::hash_combine(seed, hasher(q.y));
+		glm::detail::hash_combine(seed, hasher(q.z));
+		glm::detail::hash_combine(seed, hasher(q.w));
+		return seed;
+	}
+
+	template<typename T, glm::qualifier Q>
+	GLM_FUNC_QUALIFIER size_t hash<glm::tdualquat<T, Q>>::operator()(glm::tdualquat<T, Q> const& q) const
+	{
+		size_t seed = 0;
+		hash<glm::tquat<T, Q>> hasher;
+		glm::detail::hash_combine(seed, hasher(q.real));
+		glm::detail::hash_combine(seed, hasher(q.dual));
+		return seed;
+	}
+
+	template<typename T, glm::qualifier Q>
+	GLM_FUNC_QUALIFIER size_t hash<glm::mat<2, 2, T, Q>>::operator()(glm::mat<2, 2, T, Q> const& m) const
+	{
+		size_t seed = 0;
+		hash<glm::vec<2, T, Q>> hasher;
+		glm::detail::hash_combine(seed, hasher(m[0]));
+		glm::detail::hash_combine(seed, hasher(m[1]));
+		return seed;
+	}
+
+	template<typename T, glm::qualifier Q>
+	GLM_FUNC_QUALIFIER size_t hash<glm::mat<2, 3, T, Q>>::operator()(glm::mat<2, 3, T, Q> const& m) const
+	{
+		size_t seed = 0;
+		hash<glm::vec<3, T, Q>> hasher;
+		glm::detail::hash_combine(seed, hasher(m[0]));
+		glm::detail::hash_combine(seed, hasher(m[1]));
+		return seed;
+	}
+
+	template<typename T, glm::qualifier Q>
+	GLM_FUNC_QUALIFIER size_t hash<glm::mat<2, 4, T, Q>>::operator()(glm::mat<2, 4, T, Q> const& m) const
+	{
+		size_t seed = 0;
+		hash<glm::vec<4, T, Q>> hasher;
+		glm::detail::hash_combine(seed, hasher(m[0]));
+		glm::detail::hash_combine(seed, hasher(m[1]));
+		return seed;
+	}
+
+	template<typename T, glm::qualifier Q>
+	GLM_FUNC_QUALIFIER size_t hash<glm::mat<3, 2, T, Q>>::operator()(glm::mat<3, 2, T, Q> const& m) const
+	{
+		size_t seed = 0;
+		hash<glm::vec<2, T, Q>> hasher;
+		glm::detail::hash_combine(seed, hasher(m[0]));
+		glm::detail::hash_combine(seed, hasher(m[1]));
+		glm::detail::hash_combine(seed, hasher(m[2]));
+		return seed;
+	}
+
+	template<typename T, glm::qualifier Q>
+	GLM_FUNC_QUALIFIER size_t hash<glm::mat<3, 3, T, Q>>::operator()(glm::mat<3, 3, T, Q> const& m) const
+	{
+		size_t seed = 0;
+		hash<glm::vec<3, T, Q>> hasher;
+		glm::detail::hash_combine(seed, hasher(m[0]));
+		glm::detail::hash_combine(seed, hasher(m[1]));
+		glm::detail::hash_combine(seed, hasher(m[2]));
+		return seed;
+	}
+
+	template<typename T, glm::qualifier Q>
+	GLM_FUNC_QUALIFIER size_t hash<glm::mat<3, 4, T, Q>>::operator()(glm::mat<3, 4, T, Q> const& m) const
+	{
+		size_t seed = 0;
+		hash<glm::vec<4, T, Q>> hasher;
+		glm::detail::hash_combine(seed, hasher(m[0]));
+		glm::detail::hash_combine(seed, hasher(m[1]));
+		glm::detail::hash_combine(seed, hasher(m[2]));
+		return seed;
+	}
+
+	template<typename T, glm::qualifier Q>
+	GLM_FUNC_QUALIFIER size_t hash<glm::mat<4, 2, T,Q>>::operator()(glm::mat<4, 2, T,Q> const& m) const
+	{
+		size_t seed = 0;
+		hash<glm::vec<2, T, Q>> hasher;
+		glm::detail::hash_combine(seed, hasher(m[0]));
+		glm::detail::hash_combine(seed, hasher(m[1]));
+		glm::detail::hash_combine(seed, hasher(m[2]));
+		glm::detail::hash_combine(seed, hasher(m[3]));
+		return seed;
+	}
+
+	template<typename T, glm::qualifier Q>
+	GLM_FUNC_QUALIFIER size_t hash<glm::mat<4, 3, T,Q>>::operator()(glm::mat<4, 3, T,Q> const& m) const
+	{
+		size_t seed = 0;
+		hash<glm::vec<3, T, Q>> hasher;
+		glm::detail::hash_combine(seed, hasher(m[0]));
+		glm::detail::hash_combine(seed, hasher(m[1]));
+		glm::detail::hash_combine(seed, hasher(m[2]));
+		glm::detail::hash_combine(seed, hasher(m[3]));
+		return seed;
+	}
+
+	template<typename T, glm::qualifier Q>
+	GLM_FUNC_QUALIFIER size_t hash<glm::mat<4, 4, T,Q>>::operator()(glm::mat<4, 4, T, Q> const& m) const
+	{
+		size_t seed = 0;
+		hash<glm::vec<4, T, Q>> hasher;
+		glm::detail::hash_combine(seed, hasher(m[0]));
+		glm::detail::hash_combine(seed, hasher(m[1]));
+		glm::detail::hash_combine(seed, hasher(m[2]));
+		glm::detail::hash_combine(seed, hasher(m[3]));
+		return seed;
+	}
+}
diff --git a/engine/inc/glm/gtx/integer.hpp b/engine/inc/glm/gtx/integer.hpp
new file mode 100644
index 00000000..338a0355
--- /dev/null
+++ b/engine/inc/glm/gtx/integer.hpp
@@ -0,0 +1,76 @@
+/// @ref gtx_integer
+/// @file glm/gtx/integer.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_integer GLM_GTX_integer
+/// @ingroup gtx
+///
+/// Include <glm/gtx/integer.hpp> to use the features of this extension.
+///
+/// Add support for integer for core functions
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtc/integer.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_integer is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_integer extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_integer
+	/// @{
+
+	//! Returns x raised to the y power.
+	//! From GLM_GTX_integer extension.
+	GLM_FUNC_DECL int pow(int x, uint y);
+
+	//! Returns the positive square root of x.
+	//! From GLM_GTX_integer extension.
+	GLM_FUNC_DECL int sqrt(int x);
+
+	//! Returns the floor log2 of x.
+	//! From GLM_GTX_integer extension.
+	GLM_FUNC_DECL unsigned int floor_log2(unsigned int x);
+
+	//! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y.
+	//! From GLM_GTX_integer extension.
+	GLM_FUNC_DECL int mod(int x, int y);
+
+	//! Return the factorial value of a number (!12 max, integer only)
+	//! From GLM_GTX_integer extension.
+	template<typename genType>
+	GLM_FUNC_DECL genType factorial(genType const& x);
+
+	//! 32bit signed integer.
+	//! From GLM_GTX_integer extension.
+	typedef signed int					sint;
+
+	//! Returns x raised to the y power.
+	//! From GLM_GTX_integer extension.
+	GLM_FUNC_DECL uint pow(uint x, uint y);
+
+	//! Returns the positive square root of x.
+	//! From GLM_GTX_integer extension.
+	GLM_FUNC_DECL uint sqrt(uint x);
+
+	//! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y.
+	//! From GLM_GTX_integer extension.
+	GLM_FUNC_DECL uint mod(uint x, uint y);
+
+	//! Returns the number of leading zeros.
+	//! From GLM_GTX_integer extension.
+	GLM_FUNC_DECL uint nlz(uint x);
+
+	/// @}
+}//namespace glm
+
+#include "integer.inl"
diff --git a/engine/inc/glm/gtx/integer.inl b/engine/inc/glm/gtx/integer.inl
new file mode 100644
index 00000000..956366b2
--- /dev/null
+++ b/engine/inc/glm/gtx/integer.inl
@@ -0,0 +1,185 @@
+/// @ref gtx_integer
+
+namespace glm
+{
+	// pow
+	GLM_FUNC_QUALIFIER int pow(int x, uint y)
+	{
+		if(y == 0)
+			return x >= 0 ? 1 : -1;
+
+		int result = x;
+		for(uint i = 1; i < y; ++i)
+			result *= x;
+		return result;
+	}
+
+	// sqrt: From Christopher J. Musial, An integer square root, Graphics Gems, 1990, page 387
+	GLM_FUNC_QUALIFIER int sqrt(int x)
+	{
+		if(x <= 1) return x;
+
+		int NextTrial = x >> 1;
+		int CurrentAnswer;
+
+		do
+		{
+			CurrentAnswer = NextTrial;
+			NextTrial = (NextTrial + x / NextTrial) >> 1;
+		} while(NextTrial < CurrentAnswer);
+
+		return CurrentAnswer;
+	}
+
+// Henry Gordon Dietz: http://aggregate.org/MAGIC/
+namespace detail
+{
+	GLM_FUNC_QUALIFIER unsigned int ones32(unsigned int x)
+	{
+		/* 32-bit recursive reduction using SWAR...
+		but first step is mapping 2-bit values
+		into sum of 2 1-bit values in sneaky way
+		*/
+		x -= ((x >> 1) & 0x55555555);
+		x = (((x >> 2) & 0x33333333) + (x & 0x33333333));
+		x = (((x >> 4) + x) & 0x0f0f0f0f);
+		x += (x >> 8);
+		x += (x >> 16);
+		return(x & 0x0000003f);
+	}
+}//namespace detail
+
+	// Henry Gordon Dietz: http://aggregate.org/MAGIC/
+/*
+	GLM_FUNC_QUALIFIER unsigned int floor_log2(unsigned int x)
+	{
+		x |= (x >> 1);
+		x |= (x >> 2);
+		x |= (x >> 4);
+		x |= (x >> 8);
+		x |= (x >> 16);
+
+		return _detail::ones32(x) >> 1;
+	}
+*/
+	// mod
+	GLM_FUNC_QUALIFIER int mod(int x, int y)
+	{
+		return ((x % y) + y) % y;
+	}
+
+	// factorial (!12 max, integer only)
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType factorial(genType const& x)
+	{
+		genType Temp = x;
+		genType Result;
+		for(Result = 1; Temp > 1; --Temp)
+			Result *= Temp;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<2, T, Q> factorial(
+		vec<2, T, Q> const& x)
+	{
+		return vec<2, T, Q>(
+			factorial(x.x),
+			factorial(x.y));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> factorial(
+		vec<3, T, Q> const& x)
+	{
+		return vec<3, T, Q>(
+			factorial(x.x),
+			factorial(x.y),
+			factorial(x.z));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, T, Q> factorial(
+		vec<4, T, Q> const& x)
+	{
+		return vec<4, T, Q>(
+			factorial(x.x),
+			factorial(x.y),
+			factorial(x.z),
+			factorial(x.w));
+	}
+
+	GLM_FUNC_QUALIFIER uint pow(uint x, uint y)
+	{
+		if (y == 0)
+			return 1u;
+
+		uint result = x;
+		for(uint i = 1; i < y; ++i)
+			result *= x;
+		return result;
+	}
+
+	GLM_FUNC_QUALIFIER uint sqrt(uint x)
+	{
+		if(x <= 1) return x;
+
+		uint NextTrial = x >> 1;
+		uint CurrentAnswer;
+
+		do
+		{
+			CurrentAnswer = NextTrial;
+			NextTrial = (NextTrial + x / NextTrial) >> 1;
+		} while(NextTrial < CurrentAnswer);
+
+		return CurrentAnswer;
+	}
+
+	GLM_FUNC_QUALIFIER uint mod(uint x, uint y)
+	{
+		return x - y * (x / y);
+	}
+
+#if(GLM_COMPILER & (GLM_COMPILER_VC | GLM_COMPILER_GCC))
+
+	GLM_FUNC_QUALIFIER unsigned int nlz(unsigned int x)
+	{
+		return 31u - findMSB(x);
+	}
+
+#else
+
+	// Hackers Delight: http://www.hackersdelight.org/HDcode/nlz.c.txt
+	GLM_FUNC_QUALIFIER unsigned int nlz(unsigned int x)
+	{
+		int y, m, n;
+
+		y = -int(x >> 16);      // If left half of x is 0,
+		m = (y >> 16) & 16;  // set n = 16.  If left half
+		n = 16 - m;          // is nonzero, set n = 0 and
+		x = x >> m;          // shift x right 16.
+							// Now x is of the form 0000xxxx.
+		y = x - 0x100;       // If positions 8-15 are 0,
+		m = (y >> 16) & 8;   // add 8 to n and shift x left 8.
+		n = n + m;
+		x = x << m;
+
+		y = x - 0x1000;      // If positions 12-15 are 0,
+		m = (y >> 16) & 4;   // add 4 to n and shift x left 4.
+		n = n + m;
+		x = x << m;
+
+		y = x - 0x4000;      // If positions 14-15 are 0,
+		m = (y >> 16) & 2;   // add 2 to n and shift x left 2.
+		n = n + m;
+		x = x << m;
+
+		y = x >> 14;         // Set y = 0, 1, 2, or 3.
+		m = y & ~(y >> 1);   // Set m = 0, 1, 2, or 2 resp.
+		return unsigned(n + 2 - m);
+	}
+
+#endif//(GLM_COMPILER)
+
+}//namespace glm
diff --git a/engine/inc/glm/gtx/intersect.hpp b/engine/inc/glm/gtx/intersect.hpp
new file mode 100644
index 00000000..8caa17e4
--- /dev/null
+++ b/engine/inc/glm/gtx/intersect.hpp
@@ -0,0 +1,92 @@
+/// @ref gtx_intersect
+/// @file glm/gtx/intersect.hpp
+///
+/// @see core (dependence)
+/// @see gtx_closest_point (dependence)
+///
+/// @defgroup gtx_intersect GLM_GTX_intersect
+/// @ingroup gtx
+///
+/// Include <glm/gtx/intersect.hpp> to use the features of this extension.
+///
+/// Add intersection functions
+
+#pragma once
+
+// Dependency:
+#include <cfloat>
+#include <limits>
+#include "../glm.hpp"
+#include "../geometric.hpp"
+#include "../gtx/closest_point.hpp"
+#include "../gtx/vector_query.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_closest_point is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_closest_point extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_intersect
+	/// @{
+
+	//! Compute the intersection of a ray and a plane.
+	//! Ray direction and plane normal must be unit length.
+	//! From GLM_GTX_intersect extension.
+	template<typename genType>
+	GLM_FUNC_DECL bool intersectRayPlane(
+		genType const& orig, genType const& dir,
+		genType const& planeOrig, genType const& planeNormal,
+		typename genType::value_type & intersectionDistance);
+
+	//! Compute the intersection of a ray and a triangle.
+	/// Based om Tomas Möller implementation http://fileadmin.cs.lth.se/cs/Personal/Tomas_Akenine-Moller/raytri/
+	//! From GLM_GTX_intersect extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool intersectRayTriangle(
+		vec<3, T, Q> const& orig, vec<3, T, Q> const& dir,
+		vec<3, T, Q> const& v0, vec<3, T, Q> const& v1, vec<3, T, Q> const& v2,
+		vec<2, T, Q>& baryPosition, T& distance);
+
+	//! Compute the intersection of a line and a triangle.
+	//! From GLM_GTX_intersect extension.
+	template<typename genType>
+	GLM_FUNC_DECL bool intersectLineTriangle(
+		genType const& orig, genType const& dir,
+		genType const& vert0, genType const& vert1, genType const& vert2,
+		genType & position);
+
+	//! Compute the intersection distance of a ray and a sphere.
+	//! The ray direction vector is unit length.
+	//! From GLM_GTX_intersect extension.
+	template<typename genType>
+	GLM_FUNC_DECL bool intersectRaySphere(
+		genType const& rayStarting, genType const& rayNormalizedDirection,
+		genType const& sphereCenter, typename genType::value_type const sphereRadiusSquered,
+		typename genType::value_type & intersectionDistance);
+
+	//! Compute the intersection of a ray and a sphere.
+	//! From GLM_GTX_intersect extension.
+	template<typename genType>
+	GLM_FUNC_DECL bool intersectRaySphere(
+		genType const& rayStarting, genType const& rayNormalizedDirection,
+		genType const& sphereCenter, const typename genType::value_type sphereRadius,
+		genType & intersectionPosition, genType & intersectionNormal);
+
+	//! Compute the intersection of a line and a sphere.
+	//! From GLM_GTX_intersect extension
+	template<typename genType>
+	GLM_FUNC_DECL bool intersectLineSphere(
+		genType const& point0, genType const& point1,
+		genType const& sphereCenter, typename genType::value_type sphereRadius,
+		genType & intersectionPosition1, genType & intersectionNormal1,
+		genType & intersectionPosition2 = genType(), genType & intersectionNormal2 = genType());
+
+	/// @}
+}//namespace glm
+
+#include "intersect.inl"
diff --git a/engine/inc/glm/gtx/intersect.inl b/engine/inc/glm/gtx/intersect.inl
new file mode 100644
index 00000000..e76fd628
--- /dev/null
+++ b/engine/inc/glm/gtx/intersect.inl
@@ -0,0 +1,197 @@
+/// @ref gtx_intersect
+
+namespace glm
+{
+	template<typename genType>
+	GLM_FUNC_QUALIFIER bool intersectRayPlane
+	(
+		genType const& orig, genType const& dir,
+		genType const& planeOrig, genType const& planeNormal,
+		typename genType::value_type & intersectionDistance
+	)
+	{
+		typename genType::value_type d = glm::dot(dir, planeNormal);
+		typename genType::value_type Epsilon = std::numeric_limits<typename genType::value_type>::epsilon();
+
+		if(d < -Epsilon)
+		{
+			intersectionDistance = glm::dot(planeOrig - orig, planeNormal) / d;
+			return true;
+		}
+
+		return false;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool intersectRayTriangle
+	(
+		vec<3, T, Q> const& orig, vec<3, T, Q> const& dir,
+		vec<3, T, Q> const& vert0, vec<3, T, Q> const& vert1, vec<3, T, Q> const& vert2,
+		vec<2, T, Q>& baryPosition, T& distance
+	)
+	{
+		// find vectors for two edges sharing vert0
+		vec<3, T, Q> const edge1 = vert1 - vert0;
+		vec<3, T, Q> const edge2 = vert2 - vert0;
+
+		// begin calculating determinant - also used to calculate U parameter
+		vec<3, T, Q> const p = glm::cross(dir, edge2);
+
+		// if determinant is near zero, ray lies in plane of triangle
+		T const det = glm::dot(edge1, p);
+
+		vec<3, T, Q> Perpendicular(0);
+
+		if(det > std::numeric_limits<T>::epsilon())
+		{
+			// calculate distance from vert0 to ray origin
+			vec<3, T, Q> const dist = orig - vert0;
+
+			// calculate U parameter and test bounds
+			baryPosition.x = glm::dot(dist, p);
+			if(baryPosition.x < static_cast<T>(0) || baryPosition.x > det)
+				return false;
+
+			// prepare to test V parameter
+			Perpendicular = glm::cross(dist, edge1);
+
+			// calculate V parameter and test bounds
+			baryPosition.y = glm::dot(dir, Perpendicular);
+			if((baryPosition.y < static_cast<T>(0)) || ((baryPosition.x + baryPosition.y) > det))
+				return false;
+		}
+		else if(det < -std::numeric_limits<T>::epsilon())
+		{
+			// calculate distance from vert0 to ray origin
+			vec<3, T, Q> const dist = orig - vert0;
+
+			// calculate U parameter and test bounds
+			baryPosition.x = glm::dot(dist, p);
+			if((baryPosition.x > static_cast<T>(0)) || (baryPosition.x < det))
+				return false;
+
+			// prepare to test V parameter
+			Perpendicular = glm::cross(dist, edge1);
+
+			// calculate V parameter and test bounds
+			baryPosition.y = glm::dot(dir, Perpendicular);
+			if((baryPosition.y > static_cast<T>(0)) || (baryPosition.x + baryPosition.y < det))
+				return false;
+		}
+		else
+			return false; // ray is parallel to the plane of the triangle
+
+		T inv_det = static_cast<T>(1) / det;
+
+		// calculate distance, ray intersects triangle
+		distance = glm::dot(edge2, Perpendicular) * inv_det;
+		baryPosition *= inv_det;
+
+		return true;
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER bool intersectLineTriangle
+	(
+		genType const& orig, genType const& dir,
+		genType const& vert0, genType const& vert1, genType const& vert2,
+		genType & position
+	)
+	{
+		typename genType::value_type Epsilon = std::numeric_limits<typename genType::value_type>::epsilon();
+
+		genType edge1 = vert1 - vert0;
+		genType edge2 = vert2 - vert0;
+
+		genType Perpendicular = cross(dir, edge2);
+
+		float det = dot(edge1, Perpendicular);
+
+		if (det > -Epsilon && det < Epsilon)
+			return false;
+		typename genType::value_type inv_det = typename genType::value_type(1) / det;
+
+		genType Tengant = orig - vert0;
+
+		position.y = dot(Tengant, Perpendicular) * inv_det;
+		if (position.y < typename genType::value_type(0) || position.y > typename genType::value_type(1))
+			return false;
+
+		genType Cotengant = cross(Tengant, edge1);
+
+		position.z = dot(dir, Cotengant) * inv_det;
+		if (position.z < typename genType::value_type(0) || position.y + position.z > typename genType::value_type(1))
+			return false;
+
+		position.x = dot(edge2, Cotengant) * inv_det;
+
+		return true;
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER bool intersectRaySphere
+	(
+		genType const& rayStarting, genType const& rayNormalizedDirection,
+		genType const& sphereCenter, const typename genType::value_type sphereRadiusSquered,
+		typename genType::value_type & intersectionDistance
+	)
+	{
+		typename genType::value_type Epsilon = std::numeric_limits<typename genType::value_type>::epsilon();
+		genType diff = sphereCenter - rayStarting;
+		typename genType::value_type t0 = dot(diff, rayNormalizedDirection);
+		typename genType::value_type dSquared = dot(diff, diff) - t0 * t0;
+		if( dSquared > sphereRadiusSquered )
+		{
+			return false;
+		}
+		typename genType::value_type t1 = sqrt( sphereRadiusSquered - dSquared );
+		intersectionDistance = t0 > t1 + Epsilon ? t0 - t1 : t0 + t1;
+		return intersectionDistance > Epsilon;
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER bool intersectRaySphere
+	(
+		genType const& rayStarting, genType const& rayNormalizedDirection,
+		genType const& sphereCenter, const typename genType::value_type sphereRadius,
+		genType & intersectionPosition, genType & intersectionNormal
+	)
+	{
+		typename genType::value_type distance;
+		if( intersectRaySphere( rayStarting, rayNormalizedDirection, sphereCenter, sphereRadius * sphereRadius, distance ) )
+		{
+			intersectionPosition = rayStarting + rayNormalizedDirection * distance;
+			intersectionNormal = (intersectionPosition - sphereCenter) / sphereRadius;
+			return true;
+		}
+		return false;
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER bool intersectLineSphere
+	(
+		genType const& point0, genType const& point1,
+		genType const& sphereCenter, typename genType::value_type sphereRadius,
+		genType & intersectionPoint1, genType & intersectionNormal1,
+		genType & intersectionPoint2, genType & intersectionNormal2
+	)
+	{
+		typename genType::value_type Epsilon = std::numeric_limits<typename genType::value_type>::epsilon();
+		genType dir = normalize(point1 - point0);
+		genType diff = sphereCenter - point0;
+		typename genType::value_type t0 = dot(diff, dir);
+		typename genType::value_type dSquared = dot(diff, diff) - t0 * t0;
+		if( dSquared > sphereRadius * sphereRadius )
+		{
+			return false;
+		}
+		typename genType::value_type t1 = sqrt( sphereRadius * sphereRadius - dSquared );
+		if( t0 < t1 + Epsilon )
+			t1 = -t1;
+		intersectionPoint1 = point0 + dir * (t0 - t1);
+		intersectionNormal1 = (intersectionPoint1 - sphereCenter) / sphereRadius;
+		intersectionPoint2 = point0 + dir * (t0 + t1);
+		intersectionNormal2 = (intersectionPoint2 - sphereCenter) / sphereRadius;
+		return true;
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/io.hpp b/engine/inc/glm/gtx/io.hpp
new file mode 100644
index 00000000..c2476449
--- /dev/null
+++ b/engine/inc/glm/gtx/io.hpp
@@ -0,0 +1,201 @@
+/// @ref gtx_io
+/// @file glm/gtx/io.hpp
+/// @author Jan P Springer (regnirpsj@gmail.com)
+///
+/// @see core (dependence)
+/// @see gtc_matrix_access (dependence)
+/// @see gtc_quaternion (dependence)
+///
+/// @defgroup gtx_io GLM_GTX_io
+/// @ingroup gtx
+///
+/// Include <glm/gtx/io.hpp> to use the features of this extension.
+///
+/// std::[w]ostream support for glm types
+///
+/// std::[w]ostream support for glm types + qualifier/width/etc. manipulators
+/// based on howard hinnant's std::chrono io proposal
+/// [http://home.roadrunner.com/~hinnant/bloomington/chrono_io.html]
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtx/quaternion.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_io is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+# pragma message("GLM: GLM_GTX_io extension included")
+#endif
+
+#include <iosfwd>  // std::basic_ostream<> (fwd)
+#include <locale>  // std::locale, std::locale::facet, std::locale::id
+#include <utility> // std::pair<>
+
+namespace glm
+{
+	/// @addtogroup gtx_io
+	/// @{
+
+	namespace io
+	{
+		enum order_type { column_major, row_major};
+
+		template<typename CTy>
+		class format_punct : public std::locale::facet
+		{
+			typedef CTy char_type;
+
+		public:
+
+			static std::locale::id id;
+
+			bool       formatted;
+			unsigned   precision;
+			unsigned   width;
+			char_type  separator;
+			char_type  delim_left;
+			char_type  delim_right;
+			char_type  space;
+			char_type  newline;
+			order_type order;
+
+			GLM_FUNC_DECL explicit format_punct(size_t a = 0);
+			GLM_FUNC_DECL explicit format_punct(format_punct const&);
+		};
+
+		template<typename CTy, typename CTr = std::char_traits<CTy> >
+		class basic_state_saver {
+
+		public:
+
+			GLM_FUNC_DECL explicit basic_state_saver(std::basic_ios<CTy,CTr>&);
+			GLM_FUNC_DECL ~basic_state_saver();
+
+		private:
+
+			typedef ::std::basic_ios<CTy,CTr>      state_type;
+			typedef typename state_type::char_type char_type;
+			typedef ::std::ios_base::fmtflags      flags_type;
+			typedef ::std::streamsize              streamsize_type;
+			typedef ::std::locale const            locale_type;
+
+			state_type&     state_;
+			flags_type      flags_;
+			streamsize_type precision_;
+			streamsize_type width_;
+			char_type       fill_;
+			locale_type     locale_;
+
+			GLM_FUNC_DECL basic_state_saver& operator=(basic_state_saver const&);
+		};
+
+		typedef basic_state_saver<char>     state_saver;
+		typedef basic_state_saver<wchar_t> wstate_saver;
+
+		template<typename CTy, typename CTr = std::char_traits<CTy> >
+		class basic_format_saver
+		{
+		public:
+
+			GLM_FUNC_DECL explicit basic_format_saver(std::basic_ios<CTy,CTr>&);
+			GLM_FUNC_DECL ~basic_format_saver();
+
+		private:
+
+			basic_state_saver<CTy> const bss_;
+
+			GLM_FUNC_DECL basic_format_saver& operator=(basic_format_saver const&);
+		};
+
+		typedef basic_format_saver<char>     format_saver;
+		typedef basic_format_saver<wchar_t> wformat_saver;
+
+		struct precision
+		{
+			unsigned value;
+
+			GLM_FUNC_DECL explicit precision(unsigned);
+		};
+
+		struct width
+		{
+			unsigned value;
+
+			GLM_FUNC_DECL explicit width(unsigned);
+		};
+
+		template<typename CTy>
+		struct delimeter
+		{
+			CTy value[3];
+
+			GLM_FUNC_DECL explicit delimeter(CTy /* left */, CTy /* right */, CTy /* separator */ = ',');
+		};
+
+		struct order
+		{
+			order_type value;
+
+			GLM_FUNC_DECL explicit order(order_type);
+		};
+
+		// functions, inlined (inline)
+
+		template<typename FTy, typename CTy, typename CTr>
+		FTy const& get_facet(std::basic_ios<CTy,CTr>&);
+		template<typename FTy, typename CTy, typename CTr>
+		std::basic_ios<CTy,CTr>& formatted(std::basic_ios<CTy,CTr>&);
+		template<typename FTy, typename CTy, typename CTr>
+		std::basic_ios<CTy,CTr>& unformattet(std::basic_ios<CTy,CTr>&);
+
+		template<typename CTy, typename CTr>
+		std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, precision const&);
+		template<typename CTy, typename CTr>
+		std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, width const&);
+		template<typename CTy, typename CTr>
+		std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, delimeter<CTy> const&);
+		template<typename CTy, typename CTr>
+		std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, order const&);
+	}//namespace io
+
+	template<typename CTy, typename CTr, typename T, qualifier Q>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, qua<T, Q> const&);
+	template<typename CTy, typename CTr, typename T, qualifier Q>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, vec<1, T, Q> const&);
+	template<typename CTy, typename CTr, typename T, qualifier Q>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, vec<2, T, Q> const&);
+	template<typename CTy, typename CTr, typename T, qualifier Q>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, vec<3, T, Q> const&);
+	template<typename CTy, typename CTr, typename T, qualifier Q>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, vec<4, T, Q> const&);
+	template<typename CTy, typename CTr, typename T, qualifier Q>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<2, 2, T, Q> const&);
+	template<typename CTy, typename CTr, typename T, qualifier Q>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<2, 3, T, Q> const&);
+	template<typename CTy, typename CTr, typename T, qualifier Q>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<2, 4, T, Q> const&);
+	template<typename CTy, typename CTr, typename T, qualifier Q>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<3, 2, T, Q> const&);
+	template<typename CTy, typename CTr, typename T, qualifier Q>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<3, 3, T, Q> const&);
+	template<typename CTy, typename CTr, typename T, qualifier Q>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<3, 4, T, Q> const&);
+	template<typename CTy, typename CTr, typename T, qualifier Q>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<4, 2, T, Q> const&);
+	template<typename CTy, typename CTr, typename T, qualifier Q>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<4, 3, T, Q> const&);
+	template<typename CTy, typename CTr, typename T, qualifier Q>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<4, 4, T, Q> const&);
+
+  template<typename CTy, typename CTr, typename T, qualifier Q>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr> & operator<<(std::basic_ostream<CTy,CTr> &,
+                                                         std::pair<mat<4, 4, T, Q> const, mat<4, 4, T, Q> const> const&);
+
+	/// @}
+}//namespace glm
+
+#include "io.inl"
diff --git a/engine/inc/glm/gtx/io.inl b/engine/inc/glm/gtx/io.inl
new file mode 100644
index 00000000..a3a1bb6c
--- /dev/null
+++ b/engine/inc/glm/gtx/io.inl
@@ -0,0 +1,440 @@
+/// @ref gtx_io
+/// @author Jan P Springer (regnirpsj@gmail.com)
+
+#include <iomanip>                  // std::fixed, std::setfill<>, std::setprecision, std::right, std::setw
+#include <ostream>                  // std::basic_ostream<>
+#include "../gtc/matrix_access.hpp" // glm::col, glm::row
+#include "../gtx/type_trait.hpp"    // glm::type<>
+
+namespace glm{
+namespace io
+{
+	template<typename CTy>
+	GLM_FUNC_QUALIFIER format_punct<CTy>::format_punct(size_t a)
+		: std::locale::facet(a)
+		, formatted(true)
+		, precision(3)
+		, width(1 + 4 + 1 + precision)
+		, separator(',')
+		, delim_left('[')
+		, delim_right(']')
+		, space(' ')
+		, newline('\n')
+		, order(column_major)
+	{}
+
+	template<typename CTy>
+	GLM_FUNC_QUALIFIER format_punct<CTy>::format_punct(format_punct const& a)
+		: std::locale::facet(0)
+		, formatted(a.formatted)
+		, precision(a.precision)
+		, width(a.width)
+		, separator(a.separator)
+		, delim_left(a.delim_left)
+		, delim_right(a.delim_right)
+		, space(a.space)
+		, newline(a.newline)
+		, order(a.order)
+	{}
+
+	template<typename CTy> std::locale::id format_punct<CTy>::id;
+
+	template<typename CTy, typename CTr>
+	GLM_FUNC_QUALIFIER basic_state_saver<CTy, CTr>::basic_state_saver(std::basic_ios<CTy, CTr>& a)
+		: state_(a)
+		, flags_(a.flags())
+		, precision_(a.precision())
+		, width_(a.width())
+		, fill_(a.fill())
+		, locale_(a.getloc())
+	{}
+
+	template<typename CTy, typename CTr>
+	GLM_FUNC_QUALIFIER basic_state_saver<CTy, CTr>::~basic_state_saver()
+	{
+		state_.imbue(locale_);
+		state_.fill(fill_);
+		state_.width(width_);
+		state_.precision(precision_);
+		state_.flags(flags_);
+	}
+
+	template<typename CTy, typename CTr>
+	GLM_FUNC_QUALIFIER basic_format_saver<CTy, CTr>::basic_format_saver(std::basic_ios<CTy, CTr>& a)
+		: bss_(a)
+	{
+		a.imbue(std::locale(a.getloc(), new format_punct<CTy>(get_facet<format_punct<CTy> >(a))));
+	}
+
+	template<typename CTy, typename CTr>
+	GLM_FUNC_QUALIFIER
+	basic_format_saver<CTy, CTr>::~basic_format_saver()
+	{}
+
+	GLM_FUNC_QUALIFIER precision::precision(unsigned a)
+		: value(a)
+	{}
+
+	GLM_FUNC_QUALIFIER width::width(unsigned a)
+		: value(a)
+	{}
+
+	template<typename CTy>
+	GLM_FUNC_QUALIFIER delimeter<CTy>::delimeter(CTy a, CTy b, CTy c)
+		: value()
+	{
+		value[0] = a;
+		value[1] = b;
+		value[2] = c;
+	}
+
+	GLM_FUNC_QUALIFIER order::order(order_type a)
+		: value(a)
+	{}
+
+	template<typename FTy, typename CTy, typename CTr>
+	GLM_FUNC_QUALIFIER FTy const& get_facet(std::basic_ios<CTy, CTr>& ios)
+	{
+		if(!std::has_facet<FTy>(ios.getloc()))
+			ios.imbue(std::locale(ios.getloc(), new FTy));
+
+		return std::use_facet<FTy>(ios.getloc());
+	}
+
+	template<typename CTy, typename CTr>
+	GLM_FUNC_QUALIFIER std::basic_ios<CTy, CTr>& formatted(std::basic_ios<CTy, CTr>& ios)
+	{
+		const_cast<format_punct<CTy>&>(get_facet<format_punct<CTy> >(ios)).formatted = true;
+		return ios;
+	}
+
+	template<typename CTy, typename CTr>
+	GLM_FUNC_QUALIFIER std::basic_ios<CTy, CTr>& unformatted(std::basic_ios<CTy, CTr>& ios)
+	{
+		const_cast<format_punct<CTy>&>(get_facet<format_punct<CTy> >(ios)).formatted = false;
+		return ios;
+	}
+
+	template<typename CTy, typename CTr>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>& os, precision const& a)
+	{
+		const_cast<format_punct<CTy>&>(get_facet<format_punct<CTy> >(os)).precision = a.value;
+		return os;
+	}
+
+	template<typename CTy, typename CTr>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>& os, width const& a)
+	{
+		const_cast<format_punct<CTy>&>(get_facet<format_punct<CTy> >(os)).width = a.value;
+		return os;
+	}
+
+	template<typename CTy, typename CTr>
+	GLM_FUNC_QUALIFIER  std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>& os, delimeter<CTy> const& a)
+	{
+		format_punct<CTy> & fmt(const_cast<format_punct<CTy>&>(get_facet<format_punct<CTy> >(os)));
+
+		fmt.delim_left  = a.value[0];
+		fmt.delim_right = a.value[1];
+		fmt.separator   = a.value[2];
+
+		return os;
+	}
+
+	template<typename CTy, typename CTr>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>& os, order const& a)
+	{
+		const_cast<format_punct<CTy>&>(get_facet<format_punct<CTy> >(os)).order = a.value;
+		return os;
+	}
+} // namespace io
+
+namespace detail
+{
+	template<typename CTy, typename CTr, typename V>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy, CTr>&
+	print_vector_on(std::basic_ostream<CTy, CTr>& os, V const& a)
+	{
+		typename std::basic_ostream<CTy, CTr>::sentry const cerberus(os);
+
+		if(cerberus)
+		{
+			io::format_punct<CTy> const& fmt(io::get_facet<io::format_punct<CTy> >(os));
+
+			length_t const& components(type<V>::components);
+
+			if(fmt.formatted)
+			{
+				io::basic_state_saver<CTy> const bss(os);
+
+				os << std::fixed << std::right << std::setprecision(fmt.precision) << std::setfill(fmt.space) << fmt.delim_left;
+
+				for(length_t i(0); i < components; ++i)
+				{
+					os << std::setw(fmt.width) << a[i];
+					if(components-1 != i)
+						os << fmt.separator;
+				}
+
+				os << fmt.delim_right;
+			}
+			else
+			{
+				for(length_t i(0); i < components; ++i)
+				{
+					os << a[i];
+
+					if(components-1 != i)
+						os << fmt.space;
+				}
+			}
+		}
+
+		return os;
+	}
+}//namespace detail
+
+	template<typename CTy, typename CTr, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, qua<T, Q> const& a)
+	{
+		return detail::print_vector_on(os, a);
+	}
+
+	template<typename CTy, typename CTr, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, vec<1, T, Q> const& a)
+	{
+		return detail::print_vector_on(os, a);
+	}
+
+	template<typename CTy, typename CTr, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, vec<2, T, Q> const& a)
+	{
+		return detail::print_vector_on(os, a);
+	}
+
+	template<typename CTy, typename CTr, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, vec<3, T, Q> const& a)
+	{
+		return detail::print_vector_on(os, a);
+	}
+
+	template<typename CTy, typename CTr, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, vec<4, T, Q> const& a)
+	{
+		return detail::print_vector_on(os, a);
+	}
+
+namespace detail
+{
+	template<typename CTy, typename CTr, template<length_t, length_t, typename, qualifier> class M, length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy, CTr>& print_matrix_on(std::basic_ostream<CTy, CTr>& os, M<C, R, T, Q> const& a)
+	{
+		typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
+
+		if(cerberus)
+		{
+			io::format_punct<CTy> const& fmt(io::get_facet<io::format_punct<CTy> >(os));
+
+			length_t const& cols(type<M<C, R, T, Q> >::cols);
+			length_t const& rows(type<M<C, R, T, Q> >::rows);
+
+			if(fmt.formatted)
+			{
+				os << fmt.newline << fmt.delim_left;
+
+				switch(fmt.order)
+				{
+					case io::column_major:
+					{
+						for(length_t i(0); i < rows; ++i)
+						{
+							if (0 != i)
+								os << fmt.space;
+
+							os << row(a, i);
+
+							if(rows-1 != i)
+								os << fmt.newline;
+						}
+					}
+					break;
+
+					case io::row_major:
+					{
+						for(length_t i(0); i < cols; ++i)
+						{
+							if(0 != i)
+								os << fmt.space;
+
+							os << column(a, i);
+
+							if(cols-1 != i)
+								os << fmt.newline;
+						}
+					}
+					break;
+				}
+
+				os << fmt.delim_right;
+			}
+			else
+			{
+				switch (fmt.order)
+				{
+					case io::column_major:
+					{
+						for(length_t i(0); i < cols; ++i)
+						{
+							os << column(a, i);
+
+							if(cols - 1 != i)
+								os << fmt.space;
+						}
+					}
+					break;
+
+					case io::row_major:
+					{
+						for (length_t i(0); i < rows; ++i)
+						{
+							os << row(a, i);
+
+							if (rows-1 != i)
+								os << fmt.space;
+						}
+					}
+					break;
+				}
+			}
+		}
+
+		return os;
+	}
+}//namespace detail
+
+	template<typename CTy, typename CTr, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, mat<2, 2, T, Q> const& a)
+	{
+		return detail::print_matrix_on(os, a);
+	}
+
+	template<typename CTy, typename CTr, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, mat<2, 3, T, Q> const& a)
+	{
+		return detail::print_matrix_on(os, a);
+	}
+
+	template<typename CTy, typename CTr, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, mat<2, 4, T, Q> const& a)
+	{
+		return detail::print_matrix_on(os, a);
+	}
+
+	template<typename CTy, typename CTr, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, mat<3, 2, T, Q> const& a)
+	{
+		return detail::print_matrix_on(os, a);
+	}
+
+	template<typename CTy, typename CTr, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, mat<3, 3, T, Q> const& a)
+	{
+		return detail::print_matrix_on(os, a);
+	}
+
+	template<typename CTy, typename CTr, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr> & operator<<(std::basic_ostream<CTy,CTr>& os, mat<3, 4, T, Q> const& a)
+	{
+		return detail::print_matrix_on(os, a);
+	}
+
+	template<typename CTy, typename CTr, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr> & operator<<(std::basic_ostream<CTy,CTr>& os, mat<4, 2, T, Q> const& a)
+	{
+		return detail::print_matrix_on(os, a);
+	}
+
+	template<typename CTy, typename CTr, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr> & operator<<(std::basic_ostream<CTy,CTr>& os, mat<4, 3, T, Q> const& a)
+	{
+		return detail::print_matrix_on(os, a);
+	}
+
+	template<typename CTy, typename CTr, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr> & operator<<(std::basic_ostream<CTy,CTr>& os, mat<4, 4, T, Q> const& a)
+	{
+		return detail::print_matrix_on(os, a);
+	}
+
+namespace detail
+{
+	template<typename CTy, typename CTr, template<length_t, length_t, typename, qualifier> class M, length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy, CTr>& print_matrix_pair_on(std::basic_ostream<CTy, CTr>& os, std::pair<M<C, R, T, Q> const, M<C, R, T, Q> const> const& a)
+	{
+		typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
+
+		if(cerberus)
+		{
+			io::format_punct<CTy> const& fmt(io::get_facet<io::format_punct<CTy> >(os));
+			M<C, R, T, Q> const& ml(a.first);
+			M<C, R, T, Q> const& mr(a.second);
+			length_t const& cols(type<M<C, R, T, Q> >::cols);
+			length_t const& rows(type<M<C, R, T, Q> >::rows);
+
+			if(fmt.formatted)
+			{
+				os << fmt.newline << fmt.delim_left;
+
+				switch(fmt.order)
+				{
+					case io::column_major:
+					{
+						for(length_t i(0); i < rows; ++i)
+						{
+							if(0 != i)
+								os << fmt.space;
+
+							os << row(ml, i) << ((rows-1 != i) ? fmt.space : fmt.delim_right) << fmt.space << ((0 != i) ? fmt.space : fmt.delim_left) << row(mr, i);
+
+							if(rows-1 != i)
+								os << fmt.newline;
+						}
+					}
+					break;
+					case io::row_major:
+					{
+						for(length_t i(0); i < cols; ++i)
+						{
+							if(0 != i)
+								os << fmt.space;
+
+							os << column(ml, i) << ((cols-1 != i) ? fmt.space : fmt.delim_right) << fmt.space << ((0 != i) ? fmt.space : fmt.delim_left) << column(mr, i);
+
+							if(cols-1 != i)
+								os << fmt.newline;
+						}
+					}
+					break;
+				}
+
+				os << fmt.delim_right;
+			}
+			else
+			{
+				os << ml << fmt.space << mr;
+			}
+		}
+
+		return os;
+	}
+}//namespace detail
+
+	template<typename CTy, typename CTr, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy, CTr>& operator<<(
+		std::basic_ostream<CTy, CTr> & os,
+		std::pair<mat<4, 4, T, Q> const,
+		mat<4, 4, T, Q> const> const& a)
+	{
+		return detail::print_matrix_pair_on(os, a);
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/log_base.hpp b/engine/inc/glm/gtx/log_base.hpp
new file mode 100644
index 00000000..6e8e1f8e
--- /dev/null
+++ b/engine/inc/glm/gtx/log_base.hpp
@@ -0,0 +1,48 @@
+/// @ref gtx_log_base
+/// @file glm/gtx/log_base.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_log_base GLM_GTX_log_base
+/// @ingroup gtx
+///
+/// Include <glm/gtx/log_base.hpp> to use the features of this extension.
+///
+/// Logarithm for any base. base can be a vector or a scalar.
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_log_base is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_log_base extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_log_base
+	/// @{
+
+	/// Logarithm for any base.
+	/// From GLM_GTX_log_base.
+	template<typename genType>
+	GLM_FUNC_DECL genType log(
+		genType const& x,
+		genType const& base);
+
+	/// Logarithm for any base.
+	/// From GLM_GTX_log_base.
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> sign(
+		vec<L, T, Q> const& x,
+		vec<L, T, Q> const& base);
+
+	/// @}
+}//namespace glm
+
+#include "log_base.inl"
diff --git a/engine/inc/glm/gtx/log_base.inl b/engine/inc/glm/gtx/log_base.inl
new file mode 100644
index 00000000..4bbb8e89
--- /dev/null
+++ b/engine/inc/glm/gtx/log_base.inl
@@ -0,0 +1,16 @@
+/// @ref gtx_log_base
+
+namespace glm
+{
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType log(genType const& x, genType const& base)
+	{
+		return glm::log(x) / glm::log(base);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> log(vec<L, T, Q> const& x, vec<L, T, Q> const& base)
+	{
+		return glm::log(x) / glm::log(base);
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/matrix_cross_product.hpp b/engine/inc/glm/gtx/matrix_cross_product.hpp
new file mode 100644
index 00000000..6feb4f12
--- /dev/null
+++ b/engine/inc/glm/gtx/matrix_cross_product.hpp
@@ -0,0 +1,47 @@
+/// @ref gtx_matrix_cross_product
+/// @file glm/gtx/matrix_cross_product.hpp
+///
+/// @see core (dependence)
+/// @see gtx_extented_min_max (dependence)
+///
+/// @defgroup gtx_matrix_cross_product GLM_GTX_matrix_cross_product
+/// @ingroup gtx
+///
+/// Include <glm/gtx/matrix_cross_product.hpp> to use the features of this extension.
+///
+/// Build cross product matrices
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_matrix_cross_product is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_matrix_cross_product extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_matrix_cross_product
+	/// @{
+
+	//! Build a cross product matrix.
+	//! From GLM_GTX_matrix_cross_product extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> matrixCross3(
+		vec<3, T, Q> const& x);
+
+	//! Build a cross product matrix.
+	//! From GLM_GTX_matrix_cross_product extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> matrixCross4(
+		vec<3, T, Q> const& x);
+
+	/// @}
+}//namespace glm
+
+#include "matrix_cross_product.inl"
diff --git a/engine/inc/glm/gtx/matrix_cross_product.inl b/engine/inc/glm/gtx/matrix_cross_product.inl
new file mode 100644
index 00000000..3a153977
--- /dev/null
+++ b/engine/inc/glm/gtx/matrix_cross_product.inl
@@ -0,0 +1,37 @@
+/// @ref gtx_matrix_cross_product
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> matrixCross3
+	(
+		vec<3, T, Q> const& x
+	)
+	{
+		mat<3, 3, T, Q> Result(T(0));
+		Result[0][1] = x.z;
+		Result[1][0] = -x.z;
+		Result[0][2] = -x.y;
+		Result[2][0] = x.y;
+		Result[1][2] = x.x;
+		Result[2][1] = -x.x;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> matrixCross4
+	(
+		vec<3, T, Q> const& x
+	)
+	{
+		mat<4, 4, T, Q> Result(T(0));
+		Result[0][1] = x.z;
+		Result[1][0] = -x.z;
+		Result[0][2] = -x.y;
+		Result[2][0] = x.y;
+		Result[1][2] = x.x;
+		Result[2][1] = -x.x;
+		return Result;
+	}
+
+}//namespace glm
diff --git a/engine/inc/glm/gtx/matrix_decompose.hpp b/engine/inc/glm/gtx/matrix_decompose.hpp
new file mode 100644
index 00000000..bf75b93a
--- /dev/null
+++ b/engine/inc/glm/gtx/matrix_decompose.hpp
@@ -0,0 +1,46 @@
+/// @ref gtx_matrix_decompose
+/// @file glm/gtx/matrix_decompose.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_matrix_decompose GLM_GTX_matrix_decompose
+/// @ingroup gtx
+///
+/// Include <glm/gtx/matrix_decompose.hpp> to use the features of this extension.
+///
+/// Decomposes a model matrix to translations, rotation and scale components
+
+#pragma once
+
+// Dependencies
+#include "../mat4x4.hpp"
+#include "../vec3.hpp"
+#include "../vec4.hpp"
+#include "../geometric.hpp"
+#include "../gtc/quaternion.hpp"
+#include "../gtc/matrix_transform.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_matrix_decompose is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_matrix_decompose extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_matrix_decompose
+	/// @{
+
+	/// Decomposes a model matrix to translations, rotation and scale components
+	/// @see gtx_matrix_decompose
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool decompose(
+		mat<4, 4, T, Q> const& modelMatrix,
+		vec<3, T, Q> & scale, qua<T, Q> & orientation, vec<3, T, Q> & translation, vec<3, T, Q> & skew, vec<4, T, Q> & perspective);
+
+	/// @}
+}//namespace glm
+
+#include "matrix_decompose.inl"
diff --git a/engine/inc/glm/gtx/matrix_decompose.inl b/engine/inc/glm/gtx/matrix_decompose.inl
new file mode 100644
index 00000000..134103f3
--- /dev/null
+++ b/engine/inc/glm/gtx/matrix_decompose.inl
@@ -0,0 +1,186 @@
+/// @ref gtx_matrix_decompose
+
+#include "../gtc/constants.hpp"
+#include "../gtc/epsilon.hpp"
+
+namespace glm{
+namespace detail
+{
+	/// Make a linear combination of two vectors and return the result.
+	// result = (a * ascl) + (b * bscl)
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> combine(
+		vec<3, T, Q> const& a,
+		vec<3, T, Q> const& b,
+		T ascl, T bscl)
+	{
+		return (a * ascl) + (b * bscl);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> scale(vec<3, T, Q> const& v, T desiredLength)
+	{
+		return v * desiredLength / length(v);
+	}
+}//namespace detail
+
+	// Matrix decompose
+	// http://www.opensource.apple.com/source/WebCore/WebCore-514/platform/graphics/transforms/TransformationMatrix.cpp
+	// Decomposes the mode matrix to translations,rotation scale components
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool decompose(mat<4, 4, T, Q> const& ModelMatrix, vec<3, T, Q> & Scale, qua<T, Q> & Orientation, vec<3, T, Q> & Translation, vec<3, T, Q> & Skew, vec<4, T, Q> & Perspective)
+	{
+		mat<4, 4, T, Q> LocalMatrix(ModelMatrix);
+
+		// Normalize the matrix.
+		if(epsilonEqual(LocalMatrix[3][3], static_cast<T>(0), epsilon<T>()))
+			return false;
+
+		for(length_t i = 0; i < 4; ++i)
+		for(length_t j = 0; j < 4; ++j)
+			LocalMatrix[i][j] /= LocalMatrix[3][3];
+
+		// perspectiveMatrix is used to solve for perspective, but it also provides
+		// an easy way to test for singularity of the upper 3x3 component.
+		mat<4, 4, T, Q> PerspectiveMatrix(LocalMatrix);
+
+		for(length_t i = 0; i < 3; i++)
+			PerspectiveMatrix[i][3] = static_cast<T>(0);
+		PerspectiveMatrix[3][3] = static_cast<T>(1);
+
+		/// TODO: Fixme!
+		if(epsilonEqual(determinant(PerspectiveMatrix), static_cast<T>(0), epsilon<T>()))
+			return false;
+
+		// First, isolate perspective.  This is the messiest.
+		if(
+			epsilonNotEqual(LocalMatrix[0][3], static_cast<T>(0), epsilon<T>()) ||
+			epsilonNotEqual(LocalMatrix[1][3], static_cast<T>(0), epsilon<T>()) ||
+			epsilonNotEqual(LocalMatrix[2][3], static_cast<T>(0), epsilon<T>()))
+		{
+			// rightHandSide is the right hand side of the equation.
+			vec<4, T, Q> RightHandSide;
+			RightHandSide[0] = LocalMatrix[0][3];
+			RightHandSide[1] = LocalMatrix[1][3];
+			RightHandSide[2] = LocalMatrix[2][3];
+			RightHandSide[3] = LocalMatrix[3][3];
+
+			// Solve the equation by inverting PerspectiveMatrix and multiplying
+			// rightHandSide by the inverse.  (This is the easiest way, not
+			// necessarily the best.)
+			mat<4, 4, T, Q> InversePerspectiveMatrix = glm::inverse(PerspectiveMatrix);//   inverse(PerspectiveMatrix, inversePerspectiveMatrix);
+			mat<4, 4, T, Q> TransposedInversePerspectiveMatrix = glm::transpose(InversePerspectiveMatrix);//   transposeMatrix4(inversePerspectiveMatrix, transposedInversePerspectiveMatrix);
+
+			Perspective = TransposedInversePerspectiveMatrix * RightHandSide;
+			//  v4MulPointByMatrix(rightHandSide, transposedInversePerspectiveMatrix, perspectivePoint);
+
+			// Clear the perspective partition
+			LocalMatrix[0][3] = LocalMatrix[1][3] = LocalMatrix[2][3] = static_cast<T>(0);
+			LocalMatrix[3][3] = static_cast<T>(1);
+		}
+		else
+		{
+			// No perspective.
+			Perspective = vec<4, T, Q>(0, 0, 0, 1);
+		}
+
+		// Next take care of translation (easy).
+		Translation = vec<3, T, Q>(LocalMatrix[3]);
+		LocalMatrix[3] = vec<4, T, Q>(0, 0, 0, LocalMatrix[3].w);
+
+		vec<3, T, Q> Row[3], Pdum3;
+
+		// Now get scale and shear.
+		for(length_t i = 0; i < 3; ++i)
+		for(length_t j = 0; j < 3; ++j)
+			Row[i][j] = LocalMatrix[i][j];
+
+		// Compute X scale factor and normalize first row.
+		Scale.x = length(Row[0]);// v3Length(Row[0]);
+
+		Row[0] = detail::scale(Row[0], static_cast<T>(1));
+
+		// Compute XY shear factor and make 2nd row orthogonal to 1st.
+		Skew.z = dot(Row[0], Row[1]);
+		Row[1] = detail::combine(Row[1], Row[0], static_cast<T>(1), -Skew.z);
+
+		// Now, compute Y scale and normalize 2nd row.
+		Scale.y = length(Row[1]);
+		Row[1] = detail::scale(Row[1], static_cast<T>(1));
+		Skew.z /= Scale.y;
+
+		// Compute XZ and YZ shears, orthogonalize 3rd row.
+		Skew.y = glm::dot(Row[0], Row[2]);
+		Row[2] = detail::combine(Row[2], Row[0], static_cast<T>(1), -Skew.y);
+		Skew.x = glm::dot(Row[1], Row[2]);
+		Row[2] = detail::combine(Row[2], Row[1], static_cast<T>(1), -Skew.x);
+
+		// Next, get Z scale and normalize 3rd row.
+		Scale.z = length(Row[2]);
+		Row[2] = detail::scale(Row[2], static_cast<T>(1));
+		Skew.y /= Scale.z;
+		Skew.x /= Scale.z;
+
+		// At this point, the matrix (in rows[]) is orthonormal.
+		// Check for a coordinate system flip.  If the determinant
+		// is -1, then negate the matrix and the scaling factors.
+		Pdum3 = cross(Row[1], Row[2]); // v3Cross(row[1], row[2], Pdum3);
+		if(dot(Row[0], Pdum3) < 0)
+		{
+			for(length_t i = 0; i < 3; i++)
+			{
+				Scale[i] *= static_cast<T>(-1);
+				Row[i] *= static_cast<T>(-1);
+			}
+		}
+
+		// Now, get the rotations out, as described in the gem.
+
+		// FIXME - Add the ability to return either quaternions (which are
+		// easier to recompose with) or Euler angles (rx, ry, rz), which
+		// are easier for authors to deal with. The latter will only be useful
+		// when we fix https://bugs.webkit.org/show_bug.cgi?id=23799, so I
+		// will leave the Euler angle code here for now.
+
+		// ret.rotateY = asin(-Row[0][2]);
+		// if (cos(ret.rotateY) != 0) {
+		//     ret.rotateX = atan2(Row[1][2], Row[2][2]);
+		//     ret.rotateZ = atan2(Row[0][1], Row[0][0]);
+		// } else {
+		//     ret.rotateX = atan2(-Row[2][0], Row[1][1]);
+		//     ret.rotateZ = 0;
+		// }
+
+		int i, j, k = 0;
+		float root, trace = Row[0].x + Row[1].y + Row[2].z;
+		if(trace > static_cast<T>(0))
+		{
+			root = sqrt(trace + static_cast<T>(1.0));
+			Orientation.w = static_cast<T>(0.5) * root;
+			root = static_cast<T>(0.5) / root;
+			Orientation.x = root * (Row[1].z - Row[2].y);
+			Orientation.y = root * (Row[2].x - Row[0].z);
+			Orientation.z = root * (Row[0].y - Row[1].x);
+		} // End if > 0
+		else
+		{
+			static int Next[3] = {1, 2, 0};
+			i = 0;
+			if(Row[1].y > Row[0].x) i = 1;
+			if(Row[2].z > Row[i][i]) i = 2;
+			j = Next[i];
+			k = Next[j];
+
+			root = sqrt(Row[i][i] - Row[j][j] - Row[k][k] + static_cast<T>(1.0));
+
+			Orientation[i] = static_cast<T>(0.5) * root;
+			root = static_cast<T>(0.5) / root;
+			Orientation[j] = root * (Row[i][j] + Row[j][i]);
+			Orientation[k] = root * (Row[i][k] + Row[k][i]);
+			Orientation.w = root * (Row[j][k] - Row[k][j]);
+		} // End if <= 0
+
+		return true;
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/matrix_factorisation.hpp b/engine/inc/glm/gtx/matrix_factorisation.hpp
new file mode 100644
index 00000000..109eb643
--- /dev/null
+++ b/engine/inc/glm/gtx/matrix_factorisation.hpp
@@ -0,0 +1,69 @@
+/// @ref gtx_matrix_factorisation
+/// @file glm/gtx/matrix_factorisation.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_matrix_factorisation GLM_GTX_matrix_factorisation
+/// @ingroup gtx
+///
+/// Include <glm/gtx/matrix_factorisation.hpp> to use the features of this extension.
+///
+/// Functions to factor matrices in various forms
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_matrix_factorisation is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_matrix_factorisation extension included")
+#endif
+
+/*
+Suggestions:
+ - Move helper functions flipud and fliplr to another file: They may be helpful in more general circumstances.
+ - Implement other types of matrix factorisation, such as: QL and LQ, L(D)U, eigendecompositions, etc...
+*/
+
+namespace glm
+{
+	/// @addtogroup gtx_matrix_factorisation
+	/// @{
+
+	/// Flips the matrix rows up and down.
+	///
+	/// From GLM_GTX_matrix_factorisation extension.
+	template <length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_DECL mat<C, R, T, Q> flipud(mat<C, R, T, Q> const& in);
+
+	/// Flips the matrix columns right and left.
+	///
+	/// From GLM_GTX_matrix_factorisation extension.
+	template <length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_DECL mat<C, R, T, Q> fliplr(mat<C, R, T, Q> const& in);
+
+	/// Performs QR factorisation of a matrix.
+	/// Returns 2 matrices, q and r, such that the columns of q are orthonormal and span the same subspace than those of the input matrix, r is an upper triangular matrix, and q*r=in.
+	/// Given an n-by-m input matrix, q has dimensions min(n,m)-by-m, and r has dimensions n-by-min(n,m).
+	///
+	/// From GLM_GTX_matrix_factorisation extension.
+	template <length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_DECL void qr_decompose(mat<C, R, T, Q> const& in, mat<(C < R ? C : R), R, T, Q>& q, mat<C, (C < R ? C : R), T, Q>& r);
+
+	/// Performs RQ factorisation of a matrix.
+	/// Returns 2 matrices, r and q, such that r is an upper triangular matrix, the rows of q are orthonormal and span the same subspace than those of the input matrix, and r*q=in.
+	/// Note that in the context of RQ factorisation, the diagonal is seen as starting in the lower-right corner of the matrix, instead of the usual upper-left.
+	/// Given an n-by-m input matrix, r has dimensions min(n,m)-by-m, and q has dimensions n-by-min(n,m).
+	///
+	/// From GLM_GTX_matrix_factorisation extension.
+	template <length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_DECL void rq_decompose(mat<C, R, T, Q> const& in, mat<(C < R ? C : R), R, T, Q>& r, mat<C, (C < R ? C : R), T, Q>& q);
+
+	/// @}
+}
+
+#include "matrix_factorisation.inl"
diff --git a/engine/inc/glm/gtx/matrix_factorisation.inl b/engine/inc/glm/gtx/matrix_factorisation.inl
new file mode 100644
index 00000000..c479b8ad
--- /dev/null
+++ b/engine/inc/glm/gtx/matrix_factorisation.inl
@@ -0,0 +1,84 @@
+/// @ref gtx_matrix_factorisation
+
+namespace glm
+{
+	template <length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<C, R, T, Q> flipud(mat<C, R, T, Q> const& in)
+	{
+		mat<R, C, T, Q> tin = transpose(in);
+		tin = fliplr(tin);
+		mat<C, R, T, Q> out = transpose(tin);
+
+		return out;
+	}
+
+	template <length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<C, R, T, Q> fliplr(mat<C, R, T, Q> const& in)
+	{
+		mat<C, R, T, Q> out;
+		for (length_t i = 0; i < C; i++)
+		{
+			out[i] = in[(C - i) - 1];
+		}
+
+		return out;
+	}
+
+	template <length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER void qr_decompose(mat<C, R, T, Q> const& in, mat<(C < R ? C : R), R, T, Q>& q, mat<C, (C < R ? C : R), T, Q>& r)
+	{
+		// Uses modified Gram-Schmidt method
+		// Source: https://en.wikipedia.org/wiki/Gram–Schmidt_process
+		// And https://en.wikipedia.org/wiki/QR_decomposition
+
+		//For all the linearly independs columns of the input...
+		// (there can be no more linearly independents columns than there are rows.)
+		for (length_t i = 0; i < (C < R ? C : R); i++)
+		{
+			//Copy in Q the input's i-th column.
+			q[i] = in[i];
+
+			//j = [0,i[
+			// Make that column orthogonal to all the previous ones by substracting to it the non-orthogonal projection of all the previous columns.
+			// Also: Fill the zero elements of R
+			for (length_t j = 0; j < i; j++)
+			{
+				q[i] -= dot(q[i], q[j])*q[j];
+				r[j][i] = 0;
+			}
+
+			//Now, Q i-th column is orthogonal to all the previous columns. Normalize it.
+			q[i] = normalize(q[i]);
+
+			//j = [i,C[
+			//Finally, compute the corresponding coefficients of R by computing the projection of the resulting column on the other columns of the input.
+			for (length_t j = i; j < C; j++)
+			{
+				r[j][i] = dot(in[j], q[i]);
+			}
+		}
+	}
+
+	template <length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER void rq_decompose(mat<C, R, T, Q> const& in, mat<(C < R ? C : R), R, T, Q>& r, mat<C, (C < R ? C : R), T, Q>& q)
+	{
+		// From https://en.wikipedia.org/wiki/QR_decomposition:
+		// The RQ decomposition transforms a matrix A into the product of an upper triangular matrix R (also known as right-triangular) and an orthogonal matrix Q. The only difference from QR decomposition is the order of these matrices.
+		// QR decomposition is Gram–Schmidt orthogonalization of columns of A, started from the first column.
+		// RQ decomposition is Gram–Schmidt orthogonalization of rows of A, started from the last row.
+
+		mat<R, C, T, Q> tin = transpose(in);
+		tin = fliplr(tin);
+
+		mat<R, (C < R ? C : R), T, Q> tr;
+		mat<(C < R ? C : R), C, T, Q> tq;
+		qr_decompose(tin, tq, tr);
+
+		tr = fliplr(tr);
+		r = transpose(tr);
+		r = fliplr(r);
+
+		tq = fliplr(tq);
+		q = transpose(tq);
+	}
+} //namespace glm
diff --git a/engine/inc/glm/gtx/matrix_interpolation.hpp b/engine/inc/glm/gtx/matrix_interpolation.hpp
new file mode 100644
index 00000000..da76df02
--- /dev/null
+++ b/engine/inc/glm/gtx/matrix_interpolation.hpp
@@ -0,0 +1,60 @@
+/// @ref gtx_matrix_interpolation
+/// @file glm/gtx/matrix_interpolation.hpp
+/// @author Ghenadii Ursachi (the.asteroth@gmail.com)
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_matrix_interpolation GLM_GTX_matrix_interpolation
+/// @ingroup gtx
+///
+/// Include <glm/gtx/matrix_interpolation.hpp> to use the features of this extension.
+///
+/// Allows to directly interpolate two matrices.
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_matrix_interpolation is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_matrix_interpolation extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_matrix_interpolation
+	/// @{
+
+	/// Get the axis and angle of the rotation from a matrix.
+	/// From GLM_GTX_matrix_interpolation extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL void axisAngle(
+		mat<4, 4, T, Q> const& Mat, vec<3, T, Q> & Axis, T & Angle);
+
+	/// Build a matrix from axis and angle.
+	/// From GLM_GTX_matrix_interpolation extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> axisAngleMatrix(
+		vec<3, T, Q> const& Axis, T const Angle);
+
+	/// Extracts the rotation part of a matrix.
+	/// From GLM_GTX_matrix_interpolation extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> extractMatrixRotation(
+		mat<4, 4, T, Q> const& Mat);
+
+	/// Build a interpolation of 4 * 4 matrixes.
+	/// From GLM_GTX_matrix_interpolation extension.
+	/// Warning! works only with rotation and/or translation matrixes, scale will generate unexpected results.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> interpolate(
+		mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2, T const Delta);
+
+	/// @}
+}//namespace glm
+
+#include "matrix_interpolation.inl"
diff --git a/engine/inc/glm/gtx/matrix_interpolation.inl b/engine/inc/glm/gtx/matrix_interpolation.inl
new file mode 100644
index 00000000..de40b7d7
--- /dev/null
+++ b/engine/inc/glm/gtx/matrix_interpolation.inl
@@ -0,0 +1,129 @@
+/// @ref gtx_matrix_interpolation
+
+#include "../gtc/constants.hpp"
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER void axisAngle(mat<4, 4, T, Q> const& m, vec<3, T, Q> & axis, T& angle)
+	{
+		T epsilon = static_cast<T>(0.01);
+		T epsilon2 = static_cast<T>(0.1);
+
+		if((abs(m[1][0] - m[0][1]) < epsilon) && (abs(m[2][0] - m[0][2]) < epsilon) && (abs(m[2][1] - m[1][2]) < epsilon))
+		{
+			if ((abs(m[1][0] + m[0][1]) < epsilon2) && (abs(m[2][0] + m[0][2]) < epsilon2) && (abs(m[2][1] + m[1][2]) < epsilon2) && (abs(m[0][0] + m[1][1] + m[2][2] - static_cast<T>(3.0)) < epsilon2))
+			{
+				angle = static_cast<T>(0.0);
+				axis.x = static_cast<T>(1.0);
+				axis.y = static_cast<T>(0.0);
+				axis.z = static_cast<T>(0.0);
+				return;
+			}
+			angle = static_cast<T>(3.1415926535897932384626433832795);
+			T xx = (m[0][0] + static_cast<T>(1.0)) * static_cast<T>(0.5);
+			T yy = (m[1][1] + static_cast<T>(1.0)) * static_cast<T>(0.5);
+			T zz = (m[2][2] + static_cast<T>(1.0)) * static_cast<T>(0.5);
+			T xy = (m[1][0] + m[0][1]) * static_cast<T>(0.25);
+			T xz = (m[2][0] + m[0][2]) * static_cast<T>(0.25);
+			T yz = (m[2][1] + m[1][2]) * static_cast<T>(0.25);
+			if((xx > yy) && (xx > zz))
+			{
+				if(xx < epsilon)
+				{
+					axis.x = static_cast<T>(0.0);
+					axis.y = static_cast<T>(0.7071);
+					axis.z = static_cast<T>(0.7071);
+				}
+				else
+				{
+					axis.x = sqrt(xx);
+					axis.y = xy / axis.x;
+					axis.z = xz / axis.x;
+				}
+			}
+			else if (yy > zz)
+			{
+				if(yy < epsilon)
+				{
+					axis.x = static_cast<T>(0.7071);
+					axis.y = static_cast<T>(0.0);
+					axis.z = static_cast<T>(0.7071);
+				}
+				else
+				{
+					axis.y = sqrt(yy);
+					axis.x = xy / axis.y;
+					axis.z = yz / axis.y;
+				}
+			}
+			else
+			{
+				if (zz < epsilon)
+				{
+					axis.x = static_cast<T>(0.7071);
+					axis.y = static_cast<T>(0.7071);
+					axis.z = static_cast<T>(0.0);
+				}
+				else
+				{
+					axis.z = sqrt(zz);
+					axis.x = xz / axis.z;
+					axis.y = yz / axis.z;
+				}
+			}
+			return;
+		}
+		T s = sqrt((m[2][1] - m[1][2]) * (m[2][1] - m[1][2]) + (m[2][0] - m[0][2]) * (m[2][0] - m[0][2]) + (m[1][0] - m[0][1]) * (m[1][0] - m[0][1]));
+		if (glm::abs(s) < T(0.001))
+			s = static_cast<T>(1);
+		T const angleCos = (m[0][0] + m[1][1] + m[2][2] - static_cast<T>(1)) * static_cast<T>(0.5);
+		if(angleCos - static_cast<T>(1) < epsilon)
+			angle = pi<T>() * static_cast<T>(0.25);
+		else
+			angle = acos(angleCos);
+		axis.x = (m[1][2] - m[2][1]) / s;
+		axis.y = (m[2][0] - m[0][2]) / s;
+		axis.z = (m[0][1] - m[1][0]) / s;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> axisAngleMatrix(vec<3, T, Q> const& axis, T const angle)
+	{
+		T c = cos(angle);
+		T s = sin(angle);
+		T t = static_cast<T>(1) - c;
+		vec<3, T, Q> n = normalize(axis);
+
+		return mat<4, 4, T, Q>(
+			t * n.x * n.x + c,          t * n.x * n.y + n.z * s,    t * n.x * n.z - n.y * s,    static_cast<T>(0.0),
+			t * n.x * n.y - n.z * s,    t * n.y * n.y + c,          t * n.y * n.z + n.x * s,    static_cast<T>(0.0),
+			t * n.x * n.z + n.y * s,    t * n.y * n.z - n.x * s,    t * n.z * n.z + c,          static_cast<T>(0.0),
+			static_cast<T>(0.0),        static_cast<T>(0.0),        static_cast<T>(0.0),        static_cast<T>(1.0));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> extractMatrixRotation(mat<4, 4, T, Q> const& m)
+	{
+		return mat<4, 4, T, Q>(
+			m[0][0], m[0][1], m[0][2], static_cast<T>(0.0),
+			m[1][0], m[1][1], m[1][2], static_cast<T>(0.0),
+			m[2][0], m[2][1], m[2][2], static_cast<T>(0.0),
+			static_cast<T>(0.0), static_cast<T>(0.0), static_cast<T>(0.0), static_cast<T>(1.0));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> interpolate(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2, T const delta)
+	{
+		mat<4, 4, T, Q> m1rot = extractMatrixRotation(m1);
+		mat<4, 4, T, Q> dltRotation = m2 * transpose(m1rot);
+		vec<3, T, Q> dltAxis;
+		T dltAngle;
+		axisAngle(dltRotation, dltAxis, dltAngle);
+		mat<4, 4, T, Q> out = axisAngleMatrix(dltAxis, dltAngle * delta) * m1rot;
+		out[3][0] = m1[3][0] + delta * (m2[3][0] - m1[3][0]);
+		out[3][1] = m1[3][1] + delta * (m2[3][1] - m1[3][1]);
+		out[3][2] = m1[3][2] + delta * (m2[3][2] - m1[3][2]);
+		return out;
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/matrix_major_storage.hpp b/engine/inc/glm/gtx/matrix_major_storage.hpp
new file mode 100644
index 00000000..d3020f7d
--- /dev/null
+++ b/engine/inc/glm/gtx/matrix_major_storage.hpp
@@ -0,0 +1,119 @@
+/// @ref gtx_matrix_major_storage
+/// @file glm/gtx/matrix_major_storage.hpp
+///
+/// @see core (dependence)
+/// @see gtx_extented_min_max (dependence)
+///
+/// @defgroup gtx_matrix_major_storage GLM_GTX_matrix_major_storage
+/// @ingroup gtx
+///
+/// Include <glm/gtx/matrix_major_storage.hpp> to use the features of this extension.
+///
+/// Build matrices with specific matrix order, row or column
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_matrix_major_storage is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_matrix_major_storage extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_matrix_major_storage
+	/// @{
+
+	//! Build a row major matrix from row vectors.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> rowMajor2(
+		vec<2, T, Q> const& v1,
+		vec<2, T, Q> const& v2);
+
+	//! Build a row major matrix from other matrix.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> rowMajor2(
+		mat<2, 2, T, Q> const& m);
+
+	//! Build a row major matrix from row vectors.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> rowMajor3(
+		vec<3, T, Q> const& v1,
+		vec<3, T, Q> const& v2,
+		vec<3, T, Q> const& v3);
+
+	//! Build a row major matrix from other matrix.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> rowMajor3(
+		mat<3, 3, T, Q> const& m);
+
+	//! Build a row major matrix from row vectors.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> rowMajor4(
+		vec<4, T, Q> const& v1,
+		vec<4, T, Q> const& v2,
+		vec<4, T, Q> const& v3,
+		vec<4, T, Q> const& v4);
+
+	//! Build a row major matrix from other matrix.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> rowMajor4(
+		mat<4, 4, T, Q> const& m);
+
+	//! Build a column major matrix from column vectors.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> colMajor2(
+		vec<2, T, Q> const& v1,
+		vec<2, T, Q> const& v2);
+
+	//! Build a column major matrix from other matrix.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> colMajor2(
+		mat<2, 2, T, Q> const& m);
+
+	//! Build a column major matrix from column vectors.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> colMajor3(
+		vec<3, T, Q> const& v1,
+		vec<3, T, Q> const& v2,
+		vec<3, T, Q> const& v3);
+
+	//! Build a column major matrix from other matrix.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> colMajor3(
+		mat<3, 3, T, Q> const& m);
+
+	//! Build a column major matrix from column vectors.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> colMajor4(
+		vec<4, T, Q> const& v1,
+		vec<4, T, Q> const& v2,
+		vec<4, T, Q> const& v3,
+		vec<4, T, Q> const& v4);
+
+	//! Build a column major matrix from other matrix.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> colMajor4(
+		mat<4, 4, T, Q> const& m);
+
+	/// @}
+}//namespace glm
+
+#include "matrix_major_storage.inl"
diff --git a/engine/inc/glm/gtx/matrix_major_storage.inl b/engine/inc/glm/gtx/matrix_major_storage.inl
new file mode 100644
index 00000000..279dd343
--- /dev/null
+++ b/engine/inc/glm/gtx/matrix_major_storage.inl
@@ -0,0 +1,166 @@
+/// @ref gtx_matrix_major_storage
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> rowMajor2
+	(
+		vec<2, T, Q> const& v1,
+		vec<2, T, Q> const& v2
+	)
+	{
+		mat<2, 2, T, Q> Result;
+		Result[0][0] = v1.x;
+		Result[1][0] = v1.y;
+		Result[0][1] = v2.x;
+		Result[1][1] = v2.y;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> rowMajor2(
+		const mat<2, 2, T, Q>& m)
+	{
+		mat<2, 2, T, Q> Result;
+		Result[0][0] = m[0][0];
+		Result[0][1] = m[1][0];
+		Result[1][0] = m[0][1];
+		Result[1][1] = m[1][1];
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> rowMajor3(
+		const vec<3, T, Q>& v1,
+		const vec<3, T, Q>& v2,
+		const vec<3, T, Q>& v3)
+	{
+		mat<3, 3, T, Q> Result;
+		Result[0][0] = v1.x;
+		Result[1][0] = v1.y;
+		Result[2][0] = v1.z;
+		Result[0][1] = v2.x;
+		Result[1][1] = v2.y;
+		Result[2][1] = v2.z;
+		Result[0][2] = v3.x;
+		Result[1][2] = v3.y;
+		Result[2][2] = v3.z;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> rowMajor3(
+		const mat<3, 3, T, Q>& m)
+	{
+		mat<3, 3, T, Q> Result;
+		Result[0][0] = m[0][0];
+		Result[0][1] = m[1][0];
+		Result[0][2] = m[2][0];
+		Result[1][0] = m[0][1];
+		Result[1][1] = m[1][1];
+		Result[1][2] = m[2][1];
+		Result[2][0] = m[0][2];
+		Result[2][1] = m[1][2];
+		Result[2][2] = m[2][2];
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> rowMajor4(
+		const vec<4, T, Q>& v1,
+		const vec<4, T, Q>& v2,
+		const vec<4, T, Q>& v3,
+		const vec<4, T, Q>& v4)
+	{
+		mat<4, 4, T, Q> Result;
+		Result[0][0] = v1.x;
+		Result[1][0] = v1.y;
+		Result[2][0] = v1.z;
+		Result[3][0] = v1.w;
+		Result[0][1] = v2.x;
+		Result[1][1] = v2.y;
+		Result[2][1] = v2.z;
+		Result[3][1] = v2.w;
+		Result[0][2] = v3.x;
+		Result[1][2] = v3.y;
+		Result[2][2] = v3.z;
+		Result[3][2] = v3.w;
+		Result[0][3] = v4.x;
+		Result[1][3] = v4.y;
+		Result[2][3] = v4.z;
+		Result[3][3] = v4.w;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> rowMajor4(
+		const mat<4, 4, T, Q>& m)
+	{
+		mat<4, 4, T, Q> Result;
+		Result[0][0] = m[0][0];
+		Result[0][1] = m[1][0];
+		Result[0][2] = m[2][0];
+		Result[0][3] = m[3][0];
+		Result[1][0] = m[0][1];
+		Result[1][1] = m[1][1];
+		Result[1][2] = m[2][1];
+		Result[1][3] = m[3][1];
+		Result[2][0] = m[0][2];
+		Result[2][1] = m[1][2];
+		Result[2][2] = m[2][2];
+		Result[2][3] = m[3][2];
+		Result[3][0] = m[0][3];
+		Result[3][1] = m[1][3];
+		Result[3][2] = m[2][3];
+		Result[3][3] = m[3][3];
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> colMajor2(
+		const vec<2, T, Q>& v1,
+		const vec<2, T, Q>& v2)
+	{
+		return mat<2, 2, T, Q>(v1, v2);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> colMajor2(
+		const mat<2, 2, T, Q>& m)
+	{
+		return mat<2, 2, T, Q>(m);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> colMajor3(
+		const vec<3, T, Q>& v1,
+		const vec<3, T, Q>& v2,
+		const vec<3, T, Q>& v3)
+	{
+		return mat<3, 3, T, Q>(v1, v2, v3);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> colMajor3(
+		const mat<3, 3, T, Q>& m)
+	{
+		return mat<3, 3, T, Q>(m);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> colMajor4(
+		const vec<4, T, Q>& v1,
+		const vec<4, T, Q>& v2,
+		const vec<4, T, Q>& v3,
+		const vec<4, T, Q>& v4)
+	{
+		return mat<4, 4, T, Q>(v1, v2, v3, v4);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> colMajor4(
+		const mat<4, 4, T, Q>& m)
+	{
+		return mat<4, 4, T, Q>(m);
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/matrix_operation.hpp b/engine/inc/glm/gtx/matrix_operation.hpp
new file mode 100644
index 00000000..97617783
--- /dev/null
+++ b/engine/inc/glm/gtx/matrix_operation.hpp
@@ -0,0 +1,103 @@
+/// @ref gtx_matrix_operation
+/// @file glm/gtx/matrix_operation.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_matrix_operation GLM_GTX_matrix_operation
+/// @ingroup gtx
+///
+/// Include <glm/gtx/matrix_operation.hpp> to use the features of this extension.
+///
+/// Build diagonal matrices from vectors.
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_matrix_operation is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_matrix_operation extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_matrix_operation
+	/// @{
+
+	//! Build a diagonal matrix.
+	//! From GLM_GTX_matrix_operation extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> diagonal2x2(
+		vec<2, T, Q> const& v);
+
+	//! Build a diagonal matrix.
+	//! From GLM_GTX_matrix_operation extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 3, T, Q> diagonal2x3(
+		vec<2, T, Q> const& v);
+
+	//! Build a diagonal matrix.
+	//! From GLM_GTX_matrix_operation extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 4, T, Q> diagonal2x4(
+		vec<2, T, Q> const& v);
+
+	//! Build a diagonal matrix.
+	//! From GLM_GTX_matrix_operation extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 2, T, Q> diagonal3x2(
+		vec<2, T, Q> const& v);
+
+	//! Build a diagonal matrix.
+	//! From GLM_GTX_matrix_operation extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> diagonal3x3(
+		vec<3, T, Q> const& v);
+
+	//! Build a diagonal matrix.
+	//! From GLM_GTX_matrix_operation extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 4, T, Q> diagonal3x4(
+		vec<3, T, Q> const& v);
+
+	//! Build a diagonal matrix.
+	//! From GLM_GTX_matrix_operation extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 2, T, Q> diagonal4x2(
+		vec<2, T, Q> const& v);
+
+	//! Build a diagonal matrix.
+	//! From GLM_GTX_matrix_operation extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 3, T, Q> diagonal4x3(
+		vec<3, T, Q> const& v);
+
+	//! Build a diagonal matrix.
+	//! From GLM_GTX_matrix_operation extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> diagonal4x4(
+		vec<4, T, Q> const& v);
+
+	/// Build an adjugate  matrix.
+	/// From GLM_GTX_matrix_operation extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<2, 2, T, Q> adjugate(mat<2, 2, T, Q> const& m);
+
+	/// Build an adjugate  matrix.
+	/// From GLM_GTX_matrix_operation extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> adjugate(mat<3, 3, T, Q> const& m);
+
+	/// Build an adjugate  matrix.
+	/// From GLM_GTX_matrix_operation extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> adjugate(mat<4, 4, T, Q> const& m);
+
+	/// @}
+}//namespace glm
+
+#include "matrix_operation.inl"
diff --git a/engine/inc/glm/gtx/matrix_operation.inl b/engine/inc/glm/gtx/matrix_operation.inl
new file mode 100644
index 00000000..9de83f82
--- /dev/null
+++ b/engine/inc/glm/gtx/matrix_operation.inl
@@ -0,0 +1,176 @@
+/// @ref gtx_matrix_operation
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> diagonal2x2
+	(
+		vec<2, T, Q> const& v
+	)
+	{
+		mat<2, 2, T, Q> Result(static_cast<T>(1));
+		Result[0][0] = v[0];
+		Result[1][1] = v[1];
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, Q> diagonal2x3
+	(
+		vec<2, T, Q> const& v
+	)
+	{
+		mat<2, 3, T, Q> Result(static_cast<T>(1));
+		Result[0][0] = v[0];
+		Result[1][1] = v[1];
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, Q> diagonal2x4
+	(
+		vec<2, T, Q> const& v
+	)
+	{
+		mat<2, 4, T, Q> Result(static_cast<T>(1));
+		Result[0][0] = v[0];
+		Result[1][1] = v[1];
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, Q> diagonal3x2
+	(
+		vec<2, T, Q> const& v
+	)
+	{
+		mat<3, 2, T, Q> Result(static_cast<T>(1));
+		Result[0][0] = v[0];
+		Result[1][1] = v[1];
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> diagonal3x3
+	(
+		vec<3, T, Q> const& v
+	)
+	{
+		mat<3, 3, T, Q> Result(static_cast<T>(1));
+		Result[0][0] = v[0];
+		Result[1][1] = v[1];
+		Result[2][2] = v[2];
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, Q> diagonal3x4
+	(
+		vec<3, T, Q> const& v
+	)
+	{
+		mat<3, 4, T, Q> Result(static_cast<T>(1));
+		Result[0][0] = v[0];
+		Result[1][1] = v[1];
+		Result[2][2] = v[2];
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> diagonal4x4
+	(
+		vec<4, T, Q> const& v
+	)
+	{
+		mat<4, 4, T, Q> Result(static_cast<T>(1));
+		Result[0][0] = v[0];
+		Result[1][1] = v[1];
+		Result[2][2] = v[2];
+		Result[3][3] = v[3];
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, Q> diagonal4x3
+	(
+		vec<3, T, Q> const& v
+	)
+	{
+		mat<4, 3, T, Q> Result(static_cast<T>(1));
+		Result[0][0] = v[0];
+		Result[1][1] = v[1];
+		Result[2][2] = v[2];
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, Q> diagonal4x2
+	(
+		vec<2, T, Q> const& v
+	)
+	{
+		mat<4, 2, T, Q> Result(static_cast<T>(1));
+		Result[0][0] = v[0];
+		Result[1][1] = v[1];
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, Q> adjugate(mat<2, 2, T, Q> const& m)
+	{
+		return mat<2, 2, T, Q>(
+			+m[1][1], -m[1][0],
+			-m[0][1], +m[0][0]);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> adjugate(mat<3, 3, T, Q> const& m)
+	{
+		T const m00 = determinant(mat<2, 2, T, Q>(m[1][1], m[2][1], m[1][2], m[2][2]));
+		T const m01 = determinant(mat<2, 2, T, Q>(m[0][1], m[2][1], m[0][2], m[2][2]));
+		T const m02 = determinant(mat<2, 2, T, Q>(m[0][1], m[1][1], m[0][2], m[1][2]));
+
+		T const m10 = determinant(mat<2, 2, T, Q>(m[1][0], m[2][0], m[1][2], m[2][2]));
+		T const m11 = determinant(mat<2, 2, T, Q>(m[0][0], m[2][0], m[0][2], m[2][2]));
+		T const m12 = determinant(mat<2, 2, T, Q>(m[0][0], m[1][0], m[0][2], m[1][2]));
+
+		T const m20 = determinant(mat<2, 2, T, Q>(m[1][0], m[2][0], m[1][1], m[2][1]));
+		T const m21 = determinant(mat<2, 2, T, Q>(m[0][0], m[2][0], m[0][1], m[2][1]));
+		T const m22 = determinant(mat<2, 2, T, Q>(m[0][0], m[1][0], m[0][1], m[1][1]));
+
+		return mat<3, 3, T, Q>(
+			+m00, -m01, +m02,
+			-m10, +m11, -m12,
+			+m20, -m21, +m22);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> adjugate(mat<4, 4, T, Q> const& m)
+	{
+		T const m00 = determinant(mat<3, 3, T, Q>(m[1][1], m[1][2], m[1][3], m[2][1], m[2][2], m[2][3], m[3][1], m[3][2], m[3][3]));
+		T const m01 = determinant(mat<3, 3, T, Q>(m[1][0], m[1][2], m[1][3], m[2][0], m[2][2], m[2][3], m[3][0], m[3][2], m[3][3]));
+		T const m02 = determinant(mat<3, 3, T, Q>(m[1][0], m[1][1], m[1][3], m[2][0], m[2][2], m[2][3], m[3][0], m[3][1], m[3][3]));
+		T const m03 = determinant(mat<3, 3, T, Q>(m[1][0], m[1][1], m[1][2], m[2][0], m[2][1], m[2][2], m[3][0], m[3][1], m[3][2]));
+
+		T const m10 = determinant(mat<3, 3, T, Q>(m[0][1], m[0][2], m[0][3], m[2][1], m[2][2], m[2][3], m[3][1], m[3][2], m[3][3]));
+		T const m11 = determinant(mat<3, 3, T, Q>(m[0][0], m[0][2], m[0][3], m[2][0], m[2][2], m[2][3], m[3][0], m[3][2], m[3][3]));
+		T const m12 = determinant(mat<3, 3, T, Q>(m[0][0], m[0][1], m[0][3], m[2][0], m[2][1], m[2][3], m[3][0], m[3][1], m[3][3]));
+		T const m13 = determinant(mat<3, 3, T, Q>(m[0][0], m[0][1], m[0][2], m[2][0], m[2][1], m[2][2], m[3][0], m[3][1], m[3][2]));
+
+		T const m20 = determinant(mat<3, 3, T, Q>(m[0][1], m[0][2], m[0][3], m[1][1], m[1][2], m[1][3], m[3][1], m[3][2], m[3][3]));
+		T const m21 = determinant(mat<3, 3, T, Q>(m[0][0], m[0][2], m[0][3], m[1][0], m[1][2], m[1][3], m[3][0], m[3][2], m[3][3]));
+		T const m22 = determinant(mat<3, 3, T, Q>(m[0][0], m[0][1], m[0][3], m[1][0], m[1][1], m[1][3], m[3][0], m[3][1], m[3][3]));
+		T const m23 = determinant(mat<3, 3, T, Q>(m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[3][0], m[3][1], m[3][2]));
+
+		T const m30 = determinant(mat<3, 3, T, Q>(m[0][1], m[0][2], m[0][3], m[1][1], m[1][2], m[1][3], m[2][1], m[2][2], m[2][3]));
+		T const m31 = determinant(mat<3, 3, T, Q>(m[0][0], m[0][2], m[0][3], m[1][0], m[1][2], m[1][3], m[2][0], m[2][2], m[2][3]));
+		T const m32 = determinant(mat<3, 3, T, Q>(m[0][0], m[0][1], m[0][3], m[1][0], m[1][1], m[1][3], m[2][0], m[2][1], m[2][3]));
+		T const m33 = determinant(mat<3, 3, T, Q>(m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[2][0], m[2][1], m[2][2]));
+
+		return mat<4, 4, T, Q>(
+			+m00, -m01, +m02, -m03,
+			-m10, +m11, -m12, +m13,
+			+m20, -m21, +m22, -m23,
+			-m30, +m31, -m32, +m33);
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/matrix_query.hpp b/engine/inc/glm/gtx/matrix_query.hpp
new file mode 100644
index 00000000..4a3f72f2
--- /dev/null
+++ b/engine/inc/glm/gtx/matrix_query.hpp
@@ -0,0 +1,77 @@
+/// @ref gtx_matrix_query
+/// @file glm/gtx/matrix_query.hpp
+///
+/// @see core (dependence)
+/// @see gtx_vector_query (dependence)
+///
+/// @defgroup gtx_matrix_query GLM_GTX_matrix_query
+/// @ingroup gtx
+///
+/// Include <glm/gtx/matrix_query.hpp> to use the features of this extension.
+///
+/// Query to evaluate matrix properties
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtx/vector_query.hpp"
+#include <limits>
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_matrix_query is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_matrix_query extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_matrix_query
+	/// @{
+
+	/// Return whether a matrix a null matrix.
+	/// From GLM_GTX_matrix_query extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool isNull(mat<2, 2, T, Q> const& m, T const& epsilon);
+
+	/// Return whether a matrix a null matrix.
+	/// From GLM_GTX_matrix_query extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool isNull(mat<3, 3, T, Q> const& m, T const& epsilon);
+
+	/// Return whether a matrix is a null matrix.
+	/// From GLM_GTX_matrix_query extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool isNull(mat<4, 4, T, Q> const& m, T const& epsilon);
+
+	/// Return whether a matrix is an identity matrix.
+	/// From GLM_GTX_matrix_query extension.
+	template<length_t C, length_t R, typename T, qualifier Q, template<length_t, length_t, typename, qualifier> class matType>
+	GLM_FUNC_DECL bool isIdentity(matType<C, R, T, Q> const& m, T const& epsilon);
+
+	/// Return whether a matrix is a normalized matrix.
+	/// From GLM_GTX_matrix_query extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool isNormalized(mat<2, 2, T, Q> const& m, T const& epsilon);
+
+	/// Return whether a matrix is a normalized matrix.
+	/// From GLM_GTX_matrix_query extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool isNormalized(mat<3, 3, T, Q> const& m, T const& epsilon);
+
+	/// Return whether a matrix is a normalized matrix.
+	/// From GLM_GTX_matrix_query extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL bool isNormalized(mat<4, 4, T, Q> const& m, T const& epsilon);
+
+	/// Return whether a matrix is an orthonormalized matrix.
+	/// From GLM_GTX_matrix_query extension.
+	template<length_t C, length_t R, typename T, qualifier Q, template<length_t, length_t, typename, qualifier> class matType>
+	GLM_FUNC_DECL bool isOrthogonal(matType<C, R, T, Q> const& m, T const& epsilon);
+
+	/// @}
+}//namespace glm
+
+#include "matrix_query.inl"
diff --git a/engine/inc/glm/gtx/matrix_query.inl b/engine/inc/glm/gtx/matrix_query.inl
new file mode 100644
index 00000000..77bd2310
--- /dev/null
+++ b/engine/inc/glm/gtx/matrix_query.inl
@@ -0,0 +1,113 @@
+/// @ref gtx_matrix_query
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool isNull(mat<2, 2, T, Q> const& m, T const& epsilon)
+	{
+		bool result = true;
+		for(length_t i = 0; result && i < m.length() ; ++i)
+			result = isNull(m[i], epsilon);
+		return result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool isNull(mat<3, 3, T, Q> const& m, T const& epsilon)
+	{
+		bool result = true;
+		for(length_t i = 0; result && i < m.length() ; ++i)
+			result = isNull(m[i], epsilon);
+		return result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool isNull(mat<4, 4, T, Q> const& m, T const& epsilon)
+	{
+		bool result = true;
+		for(length_t i = 0; result && i < m.length() ; ++i)
+			result = isNull(m[i], epsilon);
+		return result;
+	}
+
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool isIdentity(mat<C, R, T, Q> const& m, T const& epsilon)
+	{
+		bool result = true;
+		for(length_t i = 0; result && i < m[0].length() ; ++i)
+		{
+			for(length_t j = 0; result && j < i ; ++j)
+				result = abs(m[i][j]) <= epsilon;
+			if(result)
+				result = abs(m[i][i] - 1) <= epsilon;
+			for(length_t j = i + 1; result && j < m.length(); ++j)
+				result = abs(m[i][j]) <= epsilon;
+		}
+		return result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool isNormalized(mat<2, 2, T, Q> const& m, T const& epsilon)
+	{
+		bool result(true);
+		for(length_t i = 0; result && i < m.length(); ++i)
+			result = isNormalized(m[i], epsilon);
+		for(length_t i = 0; result && i < m.length(); ++i)
+		{
+			typename mat<2, 2, T, Q>::col_type v;
+			for(length_t j = 0; j < m.length(); ++j)
+				v[j] = m[j][i];
+			result = isNormalized(v, epsilon);
+		}
+		return result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool isNormalized(mat<3, 3, T, Q> const& m, T const& epsilon)
+	{
+		bool result(true);
+		for(length_t i = 0; result && i < m.length(); ++i)
+			result = isNormalized(m[i], epsilon);
+		for(length_t i = 0; result && i < m.length(); ++i)
+		{
+			typename mat<3, 3, T, Q>::col_type v;
+			for(length_t j = 0; j < m.length(); ++j)
+				v[j] = m[j][i];
+			result = isNormalized(v, epsilon);
+		}
+		return result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool isNormalized(mat<4, 4, T, Q> const& m, T const& epsilon)
+	{
+		bool result(true);
+		for(length_t i = 0; result && i < m.length(); ++i)
+			result = isNormalized(m[i], epsilon);
+		for(length_t i = 0; result && i < m.length(); ++i)
+		{
+			typename mat<4, 4, T, Q>::col_type v;
+			for(length_t j = 0; j < m.length(); ++j)
+				v[j] = m[j][i];
+			result = isNormalized(v, epsilon);
+		}
+		return result;
+	}
+
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool isOrthogonal(mat<C, R, T, Q> const& m, T const& epsilon)
+	{
+		bool result = true;
+		for(length_t i(0); result && i < m.length() - 1; ++i)
+		for(length_t j(i + 1); result && j < m.length(); ++j)
+			result = areOrthogonal(m[i], m[j], epsilon);
+
+		if(result)
+		{
+			mat<C, R, T, Q> tmp = transpose(m);
+			for(length_t i(0); result && i < m.length() - 1 ; ++i)
+			for(length_t j(i + 1); result && j < m.length(); ++j)
+				result = areOrthogonal(tmp[i], tmp[j], epsilon);
+		}
+		return result;
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/matrix_transform_2d.hpp b/engine/inc/glm/gtx/matrix_transform_2d.hpp
new file mode 100644
index 00000000..af4cde8a
--- /dev/null
+++ b/engine/inc/glm/gtx/matrix_transform_2d.hpp
@@ -0,0 +1,81 @@
+/// @ref gtx_matrix_transform_2d
+/// @file glm/gtx/matrix_transform_2d.hpp
+/// @author Miguel �ngel Pérez Martínez
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_matrix_transform_2d GLM_GTX_matrix_transform_2d
+/// @ingroup gtx
+///
+/// Include <glm/gtx/matrix_transform_2d.hpp> to use the features of this extension.
+///
+/// Defines functions that generate common 2d transformation matrices.
+
+#pragma once
+
+// Dependency:
+#include "../mat3x3.hpp"
+#include "../vec2.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_matrix_transform_2d is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_matrix_transform_2d extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_matrix_transform_2d
+	/// @{
+
+	/// Builds a translation 3 * 3 matrix created from a vector of 2 components.
+	///
+	/// @param m Input matrix multiplied by this translation matrix.
+	/// @param v Coordinates of a translation vector.
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> translate(
+		mat<3, 3, T, Q> const& m,
+		vec<2, T, Q> const& v);
+
+	/// Builds a rotation 3 * 3 matrix created from an angle.
+	///
+	/// @param m Input matrix multiplied by this translation matrix.
+	/// @param angle Rotation angle expressed in radians.
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> rotate(
+		mat<3, 3, T, Q> const& m,
+		T angle);
+
+	/// Builds a scale 3 * 3 matrix created from a vector of 2 components.
+	///
+	/// @param m Input matrix multiplied by this translation matrix.
+	/// @param v Coordinates of a scale vector.
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> scale(
+		mat<3, 3, T, Q> const& m,
+		vec<2, T, Q> const& v);
+
+	/// Builds an horizontal (parallel to the x axis) shear 3 * 3 matrix.
+	///
+	/// @param m Input matrix multiplied by this translation matrix.
+	/// @param y Shear factor.
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> shearX(
+		mat<3, 3, T, Q> const& m,
+		T y);
+
+	/// Builds a vertical (parallel to the y axis) shear 3 * 3 matrix.
+	///
+	/// @param m Input matrix multiplied by this translation matrix.
+	/// @param x Shear factor.
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> shearY(
+		mat<3, 3, T, Q> const& m,
+		T x);
+
+	/// @}
+}//namespace glm
+
+#include "matrix_transform_2d.inl"
diff --git a/engine/inc/glm/gtx/matrix_transform_2d.inl b/engine/inc/glm/gtx/matrix_transform_2d.inl
new file mode 100644
index 00000000..a68d24dc
--- /dev/null
+++ b/engine/inc/glm/gtx/matrix_transform_2d.inl
@@ -0,0 +1,68 @@
+/// @ref gtx_matrix_transform_2d
+/// @author Miguel �ngel Pérez Martínez
+
+#include "../trigonometric.hpp"
+
+namespace glm
+{
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> translate(
+		mat<3, 3, T, Q> const& m,
+		vec<2, T, Q> const& v)
+	{
+		mat<3, 3, T, Q> Result(m);
+		Result[2] = m[0] * v[0] + m[1] * v[1] + m[2];
+		return Result;
+	}
+
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> rotate(
+		mat<3, 3, T, Q> const& m,
+		T angle)
+	{
+		T const a = angle;
+		T const c = cos(a);
+		T const s = sin(a);
+
+		mat<3, 3, T, Q> Result;
+		Result[0] = m[0] * c + m[1] * s;
+		Result[1] = m[0] * -s + m[1] * c;
+		Result[2] = m[2];
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> scale(
+		mat<3, 3, T, Q> const& m,
+		vec<2, T, Q> const& v)
+	{
+		mat<3, 3, T, Q> Result;
+		Result[0] = m[0] * v[0];
+		Result[1] = m[1] * v[1];
+		Result[2] = m[2];
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> shearX(
+		mat<3, 3, T, Q> const& m,
+		T y)
+	{
+		mat<3, 3, T, Q> Result(1);
+		Result[0][1] = y;
+		return m * Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> shearY(
+		mat<3, 3, T, Q> const& m,
+		T x)
+	{
+		mat<3, 3, T, Q> Result(1);
+		Result[1][0] = x;
+		return m * Result;
+	}
+
+}//namespace glm
diff --git a/engine/inc/glm/gtx/mixed_product.hpp b/engine/inc/glm/gtx/mixed_product.hpp
new file mode 100644
index 00000000..50e5d25c
--- /dev/null
+++ b/engine/inc/glm/gtx/mixed_product.hpp
@@ -0,0 +1,41 @@
+/// @ref gtx_mixed_product
+/// @file glm/gtx/mixed_product.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_mixed_product GLM_GTX_mixed_producte
+/// @ingroup gtx
+///
+/// Include <glm/gtx/mixed_product.hpp> to use the features of this extension.
+///
+/// Mixed product of 3 vectors.
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_mixed_product is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_mixed_product extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_mixed_product
+	/// @{
+
+	/// @brief Mixed product of 3 vectors (from GLM_GTX_mixed_product extension)
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL T mixedProduct(
+		vec<3, T, Q> const& v1,
+		vec<3, T, Q> const& v2,
+		vec<3, T, Q> const& v3);
+
+	/// @}
+}// namespace glm
+
+#include "mixed_product.inl"
diff --git a/engine/inc/glm/gtx/mixed_product.inl b/engine/inc/glm/gtx/mixed_product.inl
new file mode 100644
index 00000000..e5cdbdb4
--- /dev/null
+++ b/engine/inc/glm/gtx/mixed_product.inl
@@ -0,0 +1,15 @@
+/// @ref gtx_mixed_product
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T mixedProduct
+	(
+		vec<3, T, Q> const& v1,
+		vec<3, T, Q> const& v2,
+		vec<3, T, Q> const& v3
+	)
+	{
+		return dot(cross(v1, v2), v3);
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/norm.hpp b/engine/inc/glm/gtx/norm.hpp
new file mode 100644
index 00000000..8ea0cca3
--- /dev/null
+++ b/engine/inc/glm/gtx/norm.hpp
@@ -0,0 +1,76 @@
+/// @ref gtx_norm
+/// @file glm/gtx/norm.hpp
+///
+/// @see core (dependence)
+/// @see gtx_quaternion (dependence)
+///
+/// @defgroup gtx_norm GLM_GTX_norm
+/// @ingroup gtx
+///
+/// Include <glm/gtx/norm.hpp> to use the features of this extension.
+///
+/// Various ways to compute vector norms.
+
+#pragma once
+
+// Dependency:
+#include "../geometric.hpp"
+#include "../gtx/quaternion.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_norm is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_norm extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_norm
+	/// @{
+
+	/// Returns the squared length of x.
+	/// From GLM_GTX_norm extension.
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL T length2(vec<L, T, Q> const& x);
+
+	/// Returns the squared distance between p0 and p1, i.e., length2(p0 - p1).
+	/// From GLM_GTX_norm extension.
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL T distance2(vec<L, T, Q> const& p0, vec<L, T, Q> const& p1);
+
+	//! Returns the L1 norm between x and y.
+	//! From GLM_GTX_norm extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL T l1Norm(vec<3, T, Q> const& x, vec<3, T, Q> const& y);
+
+	//! Returns the L1 norm of v.
+	//! From GLM_GTX_norm extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL T l1Norm(vec<3, T, Q> const& v);
+
+	//! Returns the L2 norm between x and y.
+	//! From GLM_GTX_norm extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL T l2Norm(vec<3, T, Q> const& x, vec<3, T, Q> const& y);
+
+	//! Returns the L2 norm of v.
+	//! From GLM_GTX_norm extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL T l2Norm(vec<3, T, Q> const& x);
+
+	//! Returns the L norm between x and y.
+	//! From GLM_GTX_norm extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL T lxNorm(vec<3, T, Q> const& x, vec<3, T, Q> const& y, unsigned int Depth);
+
+	//! Returns the L norm of v.
+	//! From GLM_GTX_norm extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL T lxNorm(vec<3, T, Q> const& x, unsigned int Depth);
+
+	/// @}
+}//namespace glm
+
+#include "norm.inl"
diff --git a/engine/inc/glm/gtx/norm.inl b/engine/inc/glm/gtx/norm.inl
new file mode 100644
index 00000000..c3f468c3
--- /dev/null
+++ b/engine/inc/glm/gtx/norm.inl
@@ -0,0 +1,83 @@
+/// @ref gtx_norm
+
+#include "../detail/qualifier.hpp"
+
+namespace glm{
+namespace detail
+{
+	template<length_t L, typename T, qualifier Q, bool Aligned>
+	struct compute_length2
+	{
+		GLM_FUNC_QUALIFIER static T call(vec<L, T, Q> const& v)
+		{
+			return dot(v, v);
+		}
+	};
+}//namespace detail
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType length2(genType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'length2' accepts only floating-point inputs");
+		return x * x;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T length2(vec<L, T, Q> const& v)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'length2' accepts only floating-point inputs");
+		return detail::compute_length2<L, T, Q, detail::is_aligned<Q>::value>::call(v);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER T distance2(T p0, T p1)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'distance2' accepts only floating-point inputs");
+		return length2(p1 - p0);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T distance2(vec<L, T, Q> const& p0, vec<L, T, Q> const& p1)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'distance2' accepts only floating-point inputs");
+		return length2(p1 - p0);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T l1Norm(vec<3, T, Q> const& a, vec<3, T, Q> const& b)
+	{
+		return abs(b.x - a.x) + abs(b.y - a.y) + abs(b.z - a.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T l1Norm(vec<3, T, Q> const& v)
+	{
+		return abs(v.x) + abs(v.y) + abs(v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T l2Norm(vec<3, T, Q> const& a, vec<3, T, Q> const& b
+	)
+	{
+		return length(b - a);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T l2Norm(vec<3, T, Q> const& v)
+	{
+		return length(v);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T lxNorm(vec<3, T, Q> const& x, vec<3, T, Q> const& y, unsigned int Depth)
+	{
+		return pow(pow(y.x - x.x, T(Depth)) + pow(y.y - x.y, T(Depth)) + pow(y.z - x.z, T(Depth)), T(1) / T(Depth));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T lxNorm(vec<3, T, Q> const& v, unsigned int Depth)
+	{
+		return pow(pow(v.x, T(Depth)) + pow(v.y, T(Depth)) + pow(v.z, T(Depth)), T(1) / T(Depth));
+	}
+
+}//namespace glm
diff --git a/engine/inc/glm/gtx/normal.hpp b/engine/inc/glm/gtx/normal.hpp
new file mode 100644
index 00000000..1089d875
--- /dev/null
+++ b/engine/inc/glm/gtx/normal.hpp
@@ -0,0 +1,41 @@
+/// @ref gtx_normal
+/// @file glm/gtx/normal.hpp
+///
+/// @see core (dependence)
+/// @see gtx_extented_min_max (dependence)
+///
+/// @defgroup gtx_normal GLM_GTX_normal
+/// @ingroup gtx
+///
+/// Include <glm/gtx/normal.hpp> to use the features of this extension.
+///
+/// Compute the normal of a triangle.
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_normal is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_normal extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_normal
+	/// @{
+
+	/// Computes triangle normal from triangle points.
+	///
+	/// @see gtx_normal
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> triangleNormal(vec<3, T, Q> const& p1, vec<3, T, Q> const& p2, vec<3, T, Q> const& p3);
+
+	/// @}
+}//namespace glm
+
+#include "normal.inl"
diff --git a/engine/inc/glm/gtx/normal.inl b/engine/inc/glm/gtx/normal.inl
new file mode 100644
index 00000000..74f9fc99
--- /dev/null
+++ b/engine/inc/glm/gtx/normal.inl
@@ -0,0 +1,15 @@
+/// @ref gtx_normal
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> triangleNormal
+	(
+		vec<3, T, Q> const& p1,
+		vec<3, T, Q> const& p2,
+		vec<3, T, Q> const& p3
+	)
+	{
+		return normalize(cross(p1 - p2, p1 - p3));
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/normalize_dot.hpp b/engine/inc/glm/gtx/normalize_dot.hpp
new file mode 100644
index 00000000..1cb02020
--- /dev/null
+++ b/engine/inc/glm/gtx/normalize_dot.hpp
@@ -0,0 +1,49 @@
+/// @ref gtx_normalize_dot
+/// @file glm/gtx/normalize_dot.hpp
+///
+/// @see core (dependence)
+/// @see gtx_fast_square_root (dependence)
+///
+/// @defgroup gtx_normalize_dot GLM_GTX_normalize_dot
+/// @ingroup gtx
+///
+/// Include <glm/gtx/normalized_dot.hpp> to use the features of this extension.
+///
+/// Dot product of vectors that need to be normalize with a single square root.
+
+#pragma once
+
+// Dependency:
+#include "../gtx/fast_square_root.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_normalize_dot is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_normalize_dot extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_normalize_dot
+	/// @{
+
+	/// Normalize parameters and returns the dot product of x and y.
+	/// It's faster that dot(normalize(x), normalize(y)).
+	///
+	/// @see gtx_normalize_dot extension.
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL T normalizeDot(vec<L, T, Q> const& x, vec<L, T, Q> const& y);
+
+	/// Normalize parameters and returns the dot product of x and y.
+	/// Faster that dot(fastNormalize(x), fastNormalize(y)).
+	///
+	/// @see gtx_normalize_dot extension.
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL T fastNormalizeDot(vec<L, T, Q> const& x, vec<L, T, Q> const& y);
+
+	/// @}
+}//namespace glm
+
+#include "normalize_dot.inl"
diff --git a/engine/inc/glm/gtx/normalize_dot.inl b/engine/inc/glm/gtx/normalize_dot.inl
new file mode 100644
index 00000000..7bcd9a53
--- /dev/null
+++ b/engine/inc/glm/gtx/normalize_dot.inl
@@ -0,0 +1,16 @@
+/// @ref gtx_normalize_dot
+
+namespace glm
+{
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T normalizeDot(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+	{
+		return glm::dot(x, y) * glm::inversesqrt(glm::dot(x, x) * glm::dot(y, y));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T fastNormalizeDot(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+	{
+		return glm::dot(x, y) * glm::fastInverseSqrt(glm::dot(x, x) * glm::dot(y, y));
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/number_precision.hpp b/engine/inc/glm/gtx/number_precision.hpp
new file mode 100644
index 00000000..88064e62
--- /dev/null
+++ b/engine/inc/glm/gtx/number_precision.hpp
@@ -0,0 +1,61 @@
+/// @ref gtx_number_precision
+/// @file glm/gtx/number_precision.hpp
+///
+/// @see core (dependence)
+/// @see gtc_type_precision (dependence)
+/// @see gtc_quaternion (dependence)
+///
+/// @defgroup gtx_number_precision GLM_GTX_number_precision
+/// @ingroup gtx
+///
+/// Include <glm/gtx/number_precision.hpp> to use the features of this extension.
+///
+/// Defined size types.
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtc/type_precision.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_number_precision is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_number_precision extension included")
+#endif
+
+namespace glm{
+namespace gtx
+{
+	/////////////////////////////
+	// Unsigned int vector types
+
+	/// @addtogroup gtx_number_precision
+	/// @{
+
+	typedef u8			u8vec1;		//!< \brief 8bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
+	typedef u16			u16vec1;    //!< \brief 16bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
+	typedef u32			u32vec1;    //!< \brief 32bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
+	typedef u64			u64vec1;    //!< \brief 64bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
+
+	//////////////////////
+	// Float vector types
+
+	typedef f32			f32vec1;    //!< \brief Single-qualifier floating-point scalar. (from GLM_GTX_number_precision extension)
+	typedef f64			f64vec1;    //!< \brief Single-qualifier floating-point scalar. (from GLM_GTX_number_precision extension)
+
+	//////////////////////
+	// Float matrix types
+
+	typedef f32			f32mat1;	//!< \brief Single-qualifier floating-point scalar. (from GLM_GTX_number_precision extension)
+	typedef f32			f32mat1x1;	//!< \brief Single-qualifier floating-point scalar. (from GLM_GTX_number_precision extension)
+	typedef f64			f64mat1;	//!< \brief Double-qualifier floating-point scalar. (from GLM_GTX_number_precision extension)
+	typedef f64			f64mat1x1;	//!< \brief Double-qualifier floating-point scalar. (from GLM_GTX_number_precision extension)
+
+	/// @}
+}//namespace gtx
+}//namespace glm
+
+#include "number_precision.inl"
diff --git a/engine/inc/glm/gtx/number_precision.inl b/engine/inc/glm/gtx/number_precision.inl
new file mode 100644
index 00000000..b39d71c3
--- /dev/null
+++ b/engine/inc/glm/gtx/number_precision.inl
@@ -0,0 +1,6 @@
+/// @ref gtx_number_precision
+
+namespace glm
+{
+
+}
diff --git a/engine/inc/glm/gtx/optimum_pow.hpp b/engine/inc/glm/gtx/optimum_pow.hpp
new file mode 100644
index 00000000..cb068ccf
--- /dev/null
+++ b/engine/inc/glm/gtx/optimum_pow.hpp
@@ -0,0 +1,54 @@
+/// @ref gtx_optimum_pow
+/// @file glm/gtx/optimum_pow.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_optimum_pow GLM_GTX_optimum_pow
+/// @ingroup gtx
+///
+/// Include <glm/gtx/optimum_pow.hpp> to use the features of this extension.
+///
+/// Integer exponentiation of power functions.
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_optimum_pow is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_optimum_pow extension included")
+#endif
+
+namespace glm{
+namespace gtx
+{
+	/// @addtogroup gtx_optimum_pow
+	/// @{
+
+	/// Returns x raised to the power of 2.
+	///
+	/// @see gtx_optimum_pow
+	template<typename genType>
+	GLM_FUNC_DECL genType pow2(genType const& x);
+
+	/// Returns x raised to the power of 3.
+	///
+	/// @see gtx_optimum_pow
+	template<typename genType>
+	GLM_FUNC_DECL genType pow3(genType const& x);
+
+	/// Returns x raised to the power of 4.
+	///
+	/// @see gtx_optimum_pow
+	template<typename genType>
+	GLM_FUNC_DECL genType pow4(genType const& x);
+
+	/// @}
+}//namespace gtx
+}//namespace glm
+
+#include "optimum_pow.inl"
diff --git a/engine/inc/glm/gtx/optimum_pow.inl b/engine/inc/glm/gtx/optimum_pow.inl
new file mode 100644
index 00000000..a26c19c1
--- /dev/null
+++ b/engine/inc/glm/gtx/optimum_pow.inl
@@ -0,0 +1,22 @@
+/// @ref gtx_optimum_pow
+
+namespace glm
+{
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType pow2(genType const& x)
+	{
+		return x * x;
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType pow3(genType const& x)
+	{
+		return x * x * x;
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType pow4(genType const& x)
+	{
+		return (x * x) * (x * x);
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/orthonormalize.hpp b/engine/inc/glm/gtx/orthonormalize.hpp
new file mode 100644
index 00000000..47b10c66
--- /dev/null
+++ b/engine/inc/glm/gtx/orthonormalize.hpp
@@ -0,0 +1,49 @@
+/// @ref gtx_orthonormalize
+/// @file glm/gtx/orthonormalize.hpp
+///
+/// @see core (dependence)
+/// @see gtx_extented_min_max (dependence)
+///
+/// @defgroup gtx_orthonormalize GLM_GTX_orthonormalize
+/// @ingroup gtx
+///
+/// Include <glm/gtx/orthonormalize.hpp> to use the features of this extension.
+///
+/// Orthonormalize matrices.
+
+#pragma once
+
+// Dependency:
+#include "../vec3.hpp"
+#include "../mat3x3.hpp"
+#include "../geometric.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_orthonormalize is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_orthonormalize extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_orthonormalize
+	/// @{
+
+	/// Returns the orthonormalized matrix of m.
+	///
+	/// @see gtx_orthonormalize
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> orthonormalize(mat<3, 3, T, Q> const& m);
+
+	/// Orthonormalizes x according y.
+	///
+	/// @see gtx_orthonormalize
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> orthonormalize(vec<3, T, Q> const& x, vec<3, T, Q> const& y);
+
+	/// @}
+}//namespace glm
+
+#include "orthonormalize.inl"
diff --git a/engine/inc/glm/gtx/orthonormalize.inl b/engine/inc/glm/gtx/orthonormalize.inl
new file mode 100644
index 00000000..cb553ba6
--- /dev/null
+++ b/engine/inc/glm/gtx/orthonormalize.inl
@@ -0,0 +1,29 @@
+/// @ref gtx_orthonormalize
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> orthonormalize(mat<3, 3, T, Q> const& m)
+	{
+		mat<3, 3, T, Q> r = m;
+
+		r[0] = normalize(r[0]);
+
+		T d0 = dot(r[0], r[1]);
+		r[1] -= r[0] * d0;
+		r[1] = normalize(r[1]);
+
+		T d1 = dot(r[1], r[2]);
+		d0 = dot(r[0], r[2]);
+		r[2] -= r[0] * d0 + r[1] * d1;
+		r[2] = normalize(r[2]);
+
+		return r;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> orthonormalize(vec<3, T, Q> const& x, vec<3, T, Q> const& y)
+	{
+		return normalize(x - y * dot(y, x));
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/perpendicular.hpp b/engine/inc/glm/gtx/perpendicular.hpp
new file mode 100644
index 00000000..d294fd31
--- /dev/null
+++ b/engine/inc/glm/gtx/perpendicular.hpp
@@ -0,0 +1,41 @@
+/// @ref gtx_perpendicular
+/// @file glm/gtx/perpendicular.hpp
+///
+/// @see core (dependence)
+/// @see gtx_projection (dependence)
+///
+/// @defgroup gtx_perpendicular GLM_GTX_perpendicular
+/// @ingroup gtx
+///
+/// Include <glm/gtx/perpendicular.hpp> to use the features of this extension.
+///
+/// Perpendicular of a vector from other one
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtx/projection.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_perpendicular is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_perpendicular extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_perpendicular
+	/// @{
+
+	//! Projects x a perpendicular axis of Normal.
+	//! From GLM_GTX_perpendicular extension.
+	template<typename genType>
+	GLM_FUNC_DECL genType perp(genType const& x, genType const& Normal);
+
+	/// @}
+}//namespace glm
+
+#include "perpendicular.inl"
diff --git a/engine/inc/glm/gtx/perpendicular.inl b/engine/inc/glm/gtx/perpendicular.inl
new file mode 100644
index 00000000..1e72f334
--- /dev/null
+++ b/engine/inc/glm/gtx/perpendicular.inl
@@ -0,0 +1,10 @@
+/// @ref gtx_perpendicular
+
+namespace glm
+{
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType perp(genType const& x, genType const& Normal)
+	{
+		return x - proj(x, Normal);
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/polar_coordinates.hpp b/engine/inc/glm/gtx/polar_coordinates.hpp
new file mode 100644
index 00000000..48ddf7f4
--- /dev/null
+++ b/engine/inc/glm/gtx/polar_coordinates.hpp
@@ -0,0 +1,48 @@
+/// @ref gtx_polar_coordinates
+/// @file glm/gtx/polar_coordinates.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_polar_coordinates GLM_GTX_polar_coordinates
+/// @ingroup gtx
+///
+/// Include <glm/gtx/polar_coordinates.hpp> to use the features of this extension.
+///
+/// Conversion from Euclidean space to polar space and revert.
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_polar_coordinates is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_polar_coordinates extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_polar_coordinates
+	/// @{
+
+	/// Convert Euclidean to Polar coordinates, x is the xz distance, y, the latitude and z the longitude.
+	///
+	/// @see gtx_polar_coordinates
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> polar(
+		vec<3, T, Q> const& euclidean);
+
+	/// Convert Polar to Euclidean coordinates.
+	///
+	/// @see gtx_polar_coordinates
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> euclidean(
+		vec<2, T, Q> const& polar);
+
+	/// @}
+}//namespace glm
+
+#include "polar_coordinates.inl"
diff --git a/engine/inc/glm/gtx/polar_coordinates.inl b/engine/inc/glm/gtx/polar_coordinates.inl
new file mode 100644
index 00000000..371c8ddd
--- /dev/null
+++ b/engine/inc/glm/gtx/polar_coordinates.inl
@@ -0,0 +1,36 @@
+/// @ref gtx_polar_coordinates
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> polar
+	(
+		vec<3, T, Q> const& euclidean
+	)
+	{
+		T const Length(length(euclidean));
+		vec<3, T, Q> const tmp(euclidean / Length);
+		T const xz_dist(sqrt(tmp.x * tmp.x + tmp.z * tmp.z));
+
+		return vec<3, T, Q>(
+			asin(tmp.y),	// latitude
+			atan(tmp.x, tmp.z),		// longitude
+			xz_dist);				// xz distance
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> euclidean
+	(
+		vec<2, T, Q> const& polar
+	)
+	{
+		T const latitude(polar.x);
+		T const longitude(polar.y);
+
+		return vec<3, T, Q>(
+			cos(latitude) * sin(longitude),
+			sin(latitude),
+			cos(latitude) * cos(longitude));
+	}
+
+}//namespace glm
diff --git a/engine/inc/glm/gtx/projection.hpp b/engine/inc/glm/gtx/projection.hpp
new file mode 100644
index 00000000..dda5f8bc
--- /dev/null
+++ b/engine/inc/glm/gtx/projection.hpp
@@ -0,0 +1,40 @@
+/// @ref gtx_projection
+/// @file glm/gtx/projection.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_projection GLM_GTX_projection
+/// @ingroup gtx
+///
+/// Include <glm/gtx/projection.hpp> to use the features of this extension.
+///
+/// Projection of a vector to other one
+
+#pragma once
+
+// Dependency:
+#include "../geometric.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_projection is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_projection extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_projection
+	/// @{
+
+	/// Projects x on Normal.
+	///
+	/// @see gtx_projection
+	template<typename genType>
+	GLM_FUNC_DECL genType proj(genType const& x, genType const& Normal);
+
+	/// @}
+}//namespace glm
+
+#include "projection.inl"
diff --git a/engine/inc/glm/gtx/projection.inl b/engine/inc/glm/gtx/projection.inl
new file mode 100644
index 00000000..f23f884f
--- /dev/null
+++ b/engine/inc/glm/gtx/projection.inl
@@ -0,0 +1,10 @@
+/// @ref gtx_projection
+
+namespace glm
+{
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType proj(genType const& x, genType const& Normal)
+	{
+		return glm::dot(x, Normal) / glm::dot(Normal, Normal) * Normal;
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/quaternion.hpp b/engine/inc/glm/gtx/quaternion.hpp
new file mode 100644
index 00000000..e3c03de9
--- /dev/null
+++ b/engine/inc/glm/gtx/quaternion.hpp
@@ -0,0 +1,174 @@
+/// @ref gtx_quaternion
+/// @file glm/gtx/quaternion.hpp
+///
+/// @see core (dependence)
+/// @see gtx_extented_min_max (dependence)
+///
+/// @defgroup gtx_quaternion GLM_GTX_quaternion
+/// @ingroup gtx
+///
+/// Include <glm/gtx/quaternion.hpp> to use the features of this extension.
+///
+/// Extented quaternion types and functions
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtc/constants.hpp"
+#include "../gtc/quaternion.hpp"
+#include "../ext/quaternion_exponential.hpp"
+#include "../gtx/norm.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_quaternion is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_quaternion extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_quaternion
+	/// @{
+
+	/// Create an identity quaternion.
+	///
+	/// @see gtx_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> quat_identity();
+
+	/// Compute a cross product between a quaternion and a vector.
+	///
+	/// @see gtx_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> cross(
+		qua<T, Q> const& q,
+		vec<3, T, Q> const& v);
+
+	//! Compute a cross product between a vector and a quaternion.
+	///
+	/// @see gtx_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> cross(
+		vec<3, T, Q> const& v,
+		qua<T, Q> const& q);
+
+	//! Compute a point on a path according squad equation.
+	//! q1 and q2 are control points; s1 and s2 are intermediate control points.
+	///
+	/// @see gtx_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> squad(
+		qua<T, Q> const& q1,
+		qua<T, Q> const& q2,
+		qua<T, Q> const& s1,
+		qua<T, Q> const& s2,
+		T const& h);
+
+	//! Returns an intermediate control point for squad interpolation.
+	///
+	/// @see gtx_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> intermediate(
+		qua<T, Q> const& prev,
+		qua<T, Q> const& curr,
+		qua<T, Q> const& next);
+
+	//! Returns quarternion square root.
+	///
+	/// @see gtx_quaternion
+	//template<typename T, qualifier Q>
+	//qua<T, Q> sqrt(
+	//	qua<T, Q> const& q);
+
+	//! Rotates a 3 components vector by a quaternion.
+	///
+	/// @see gtx_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> rotate(
+		qua<T, Q> const& q,
+		vec<3, T, Q> const& v);
+
+	/// Rotates a 4 components vector by a quaternion.
+	///
+	/// @see gtx_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<4, T, Q> rotate(
+		qua<T, Q> const& q,
+		vec<4, T, Q> const& v);
+
+	/// Extract the real component of a quaternion.
+	///
+	/// @see gtx_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL T extractRealComponent(
+		qua<T, Q> const& q);
+
+	/// Converts a quaternion to a 3 * 3 matrix.
+	///
+	/// @see gtx_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> toMat3(
+		qua<T, Q> const& x){return mat3_cast(x);}
+
+	/// Converts a quaternion to a 4 * 4 matrix.
+	///
+	/// @see gtx_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> toMat4(
+		qua<T, Q> const& x){return mat4_cast(x);}
+
+	/// Converts a 3 * 3 matrix to a quaternion.
+	///
+	/// @see gtx_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> toQuat(
+		mat<3, 3, T, Q> const& x){return quat_cast(x);}
+
+	/// Converts a 4 * 4 matrix to a quaternion.
+	///
+	/// @see gtx_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> toQuat(
+		mat<4, 4, T, Q> const& x){return quat_cast(x);}
+
+	/// Quaternion interpolation using the rotation short path.
+	///
+	/// @see gtx_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> shortMix(
+		qua<T, Q> const& x,
+		qua<T, Q> const& y,
+		T const& a);
+
+	/// Quaternion normalized linear interpolation.
+	///
+	/// @see gtx_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> fastMix(
+		qua<T, Q> const& x,
+		qua<T, Q> const& y,
+		T const& a);
+
+	/// Compute the rotation between two vectors.
+	/// param orig vector, needs to be normalized
+	/// param dest vector, needs to be normalized
+	///
+	/// @see gtx_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> rotation(
+		vec<3, T, Q> const& orig,
+		vec<3, T, Q> const& dest);
+
+	/// Returns the squared length of x.
+	///
+	/// @see gtx_quaternion
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL T length2(qua<T, Q> const& q);
+
+	/// @}
+}//namespace glm
+
+#include "quaternion.inl"
diff --git a/engine/inc/glm/gtx/quaternion.inl b/engine/inc/glm/gtx/quaternion.inl
new file mode 100644
index 00000000..679b39f1
--- /dev/null
+++ b/engine/inc/glm/gtx/quaternion.inl
@@ -0,0 +1,159 @@
+/// @ref gtx_quaternion
+
+#include <limits>
+#include "../gtc/constants.hpp"
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> quat_identity()
+	{
+		return qua<T, Q>(static_cast<T>(1), static_cast<T>(0), static_cast<T>(0), static_cast<T>(0));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> cross(vec<3, T, Q> const& v, qua<T, Q> const& q)
+	{
+		return inverse(q) * v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> cross(qua<T, Q> const& q, vec<3, T, Q> const& v)
+	{
+		return q * v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> squad
+	(
+		qua<T, Q> const& q1,
+		qua<T, Q> const& q2,
+		qua<T, Q> const& s1,
+		qua<T, Q> const& s2,
+		T const& h)
+	{
+		return mix(mix(q1, q2, h), mix(s1, s2, h), static_cast<T>(2) * (static_cast<T>(1) - h) * h);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> intermediate
+	(
+		qua<T, Q> const& prev,
+		qua<T, Q> const& curr,
+		qua<T, Q> const& next
+	)
+	{
+		qua<T, Q> invQuat = inverse(curr);
+		return exp((log(next * invQuat) + log(prev * invQuat)) / static_cast<T>(-4)) * curr;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> rotate(qua<T, Q> const& q, vec<3, T, Q> const& v)
+	{
+		return q * v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, T, Q> rotate(qua<T, Q> const& q, vec<4, T, Q> const& v)
+	{
+		return q * v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T extractRealComponent(qua<T, Q> const& q)
+	{
+		T w = static_cast<T>(1) - q.x * q.x - q.y * q.y - q.z * q.z;
+		if(w < T(0))
+			return T(0);
+		else
+			return -sqrt(w);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T length2(qua<T, Q> const& q)
+	{
+		return q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> shortMix(qua<T, Q> const& x, qua<T, Q> const& y, T const& a)
+	{
+		if(a <= static_cast<T>(0)) return x;
+		if(a >= static_cast<T>(1)) return y;
+
+		T fCos = dot(x, y);
+		qua<T, Q> y2(y); //BUG!!! qua<T> y2;
+		if(fCos < static_cast<T>(0))
+		{
+			y2 = -y;
+			fCos = -fCos;
+		}
+
+		//if(fCos > 1.0f) // problem
+		T k0, k1;
+		if(fCos > (static_cast<T>(1) - epsilon<T>()))
+		{
+			k0 = static_cast<T>(1) - a;
+			k1 = static_cast<T>(0) + a; //BUG!!! 1.0f + a;
+		}
+		else
+		{
+			T fSin = sqrt(T(1) - fCos * fCos);
+			T fAngle = atan(fSin, fCos);
+			T fOneOverSin = static_cast<T>(1) / fSin;
+			k0 = sin((static_cast<T>(1) - a) * fAngle) * fOneOverSin;
+			k1 = sin((static_cast<T>(0) + a) * fAngle) * fOneOverSin;
+		}
+
+		return qua<T, Q>(
+			k0 * x.w + k1 * y2.w,
+			k0 * x.x + k1 * y2.x,
+			k0 * x.y + k1 * y2.y,
+			k0 * x.z + k1 * y2.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> fastMix(qua<T, Q> const& x, qua<T, Q> const& y, T const& a)
+	{
+		return glm::normalize(x * (static_cast<T>(1) - a) + (y * a));
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> rotation(vec<3, T, Q> const& orig, vec<3, T, Q> const& dest)
+	{
+		T cosTheta = dot(orig, dest);
+		vec<3, T, Q> rotationAxis;
+
+		if(cosTheta >= static_cast<T>(1) - epsilon<T>()) {
+			// orig and dest point in the same direction
+			return quat_identity<T,Q>();
+		}
+
+		if(cosTheta < static_cast<T>(-1) + epsilon<T>())
+		{
+			// special case when vectors in opposite directions :
+			// there is no "ideal" rotation axis
+			// So guess one; any will do as long as it's perpendicular to start
+			// This implementation favors a rotation around the Up axis (Y),
+			// since it's often what you want to do.
+			rotationAxis = cross(vec<3, T, Q>(0, 0, 1), orig);
+			if(length2(rotationAxis) < epsilon<T>()) // bad luck, they were parallel, try again!
+				rotationAxis = cross(vec<3, T, Q>(1, 0, 0), orig);
+
+			rotationAxis = normalize(rotationAxis);
+			return angleAxis(pi<T>(), rotationAxis);
+		}
+
+		// Implementation from Stan Melax's Game Programming Gems 1 article
+		rotationAxis = cross(orig, dest);
+
+		T s = sqrt((T(1) + cosTheta) * static_cast<T>(2));
+		T invs = static_cast<T>(1) / s;
+
+		return qua<T, Q>(
+			s * static_cast<T>(0.5f),
+			rotationAxis.x * invs,
+			rotationAxis.y * invs,
+			rotationAxis.z * invs);
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/range.hpp b/engine/inc/glm/gtx/range.hpp
new file mode 100644
index 00000000..38c5713a
--- /dev/null
+++ b/engine/inc/glm/gtx/range.hpp
@@ -0,0 +1,98 @@
+/// @ref gtx_range
+/// @file glm/gtx/range.hpp
+/// @author Joshua Moerman
+///
+/// @defgroup gtx_range GLM_GTX_range
+/// @ingroup gtx
+///
+/// Include <glm/gtx/range.hpp> to use the features of this extension.
+///
+/// Defines begin and end for vectors and matrices. Useful for range-based for loop.
+/// The range is defined over the elements, not over columns or rows (e.g. mat4 has 16 elements).
+
+#pragma once
+
+// Dependencies
+#include "../detail/setup.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_range is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if !GLM_HAS_RANGE_FOR
+#	error "GLM_GTX_range requires C++11 suppport or 'range for'"
+#endif
+
+#include "../gtc/type_ptr.hpp"
+#include "../gtc/vec1.hpp"
+
+namespace glm
+{
+	/// @addtogroup gtx_range
+	/// @{
+
+#	if GLM_COMPILER & GLM_COMPILER_VC
+#		pragma warning(push)
+#		pragma warning(disable : 4100) // unreferenced formal parameter
+#	endif
+
+	template<typename T, qualifier Q>
+	inline length_t components(vec<1, T, Q> const& v)
+	{
+		return v.length();
+	}
+
+	template<typename T, qualifier Q>
+	inline length_t components(vec<2, T, Q> const& v)
+	{
+		return v.length();
+	}
+
+	template<typename T, qualifier Q>
+	inline length_t components(vec<3, T, Q> const& v)
+	{
+		return v.length();
+	}
+
+	template<typename T, qualifier Q>
+	inline length_t components(vec<4, T, Q> const& v)
+	{
+		return v.length();
+	}
+
+	template<typename genType>
+	inline length_t components(genType const& m)
+	{
+		return m.length() * m[0].length();
+	}
+
+	template<typename genType>
+	inline typename genType::value_type const * begin(genType const& v)
+	{
+		return value_ptr(v);
+	}
+
+	template<typename genType>
+	inline typename genType::value_type const * end(genType const& v)
+	{
+		return begin(v) + components(v);
+	}
+
+	template<typename genType>
+	inline typename genType::value_type * begin(genType& v)
+	{
+		return value_ptr(v);
+	}
+
+	template<typename genType>
+	inline typename genType::value_type * end(genType& v)
+	{
+		return begin(v) + components(v);
+	}
+
+#	if GLM_COMPILER & GLM_COMPILER_VC
+#		pragma warning(pop)
+#	endif
+
+	/// @}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/raw_data.hpp b/engine/inc/glm/gtx/raw_data.hpp
new file mode 100644
index 00000000..f4d7fd96
--- /dev/null
+++ b/engine/inc/glm/gtx/raw_data.hpp
@@ -0,0 +1,51 @@
+/// @ref gtx_raw_data
+/// @file glm/gtx/raw_data.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_raw_data GLM_GTX_raw_data
+/// @ingroup gtx
+///
+/// Include <glm/gtx/raw_data.hpp> to use the features of this extension.
+///
+/// Projection of a vector to other one
+
+#pragma once
+
+// Dependencies
+#include "../ext/scalar_uint_sized.hpp"
+#include "../detail/setup.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_raw_data is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_raw_data extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_raw_data
+	/// @{
+
+	//! Type for byte numbers.
+	//! From GLM_GTX_raw_data extension.
+	typedef detail::uint8		byte;
+
+	//! Type for word numbers.
+	//! From GLM_GTX_raw_data extension.
+	typedef detail::uint16		word;
+
+	//! Type for dword numbers.
+	//! From GLM_GTX_raw_data extension.
+	typedef detail::uint32		dword;
+
+	//! Type for qword numbers.
+	//! From GLM_GTX_raw_data extension.
+	typedef detail::uint64		qword;
+
+	/// @}
+}// namespace glm
+
+#include "raw_data.inl"
diff --git a/engine/inc/glm/gtx/raw_data.inl b/engine/inc/glm/gtx/raw_data.inl
new file mode 100644
index 00000000..c740317d
--- /dev/null
+++ b/engine/inc/glm/gtx/raw_data.inl
@@ -0,0 +1,2 @@
+/// @ref gtx_raw_data
+
diff --git a/engine/inc/glm/gtx/rotate_normalized_axis.hpp b/engine/inc/glm/gtx/rotate_normalized_axis.hpp
new file mode 100644
index 00000000..87a63eb8
--- /dev/null
+++ b/engine/inc/glm/gtx/rotate_normalized_axis.hpp
@@ -0,0 +1,68 @@
+/// @ref gtx_rotate_normalized_axis
+/// @file glm/gtx/rotate_normalized_axis.hpp
+///
+/// @see core (dependence)
+/// @see gtc_matrix_transform
+/// @see gtc_quaternion
+///
+/// @defgroup gtx_rotate_normalized_axis GLM_GTX_rotate_normalized_axis
+/// @ingroup gtx
+///
+/// Include <glm/gtx/rotate_normalized_axis.hpp> to use the features of this extension.
+///
+/// Quaternions and matrices rotations around normalized axis.
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtc/epsilon.hpp"
+#include "../gtc/quaternion.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_rotate_normalized_axis is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_rotate_normalized_axis extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_rotate_normalized_axis
+	/// @{
+
+	/// Builds a rotation 4 * 4 matrix created from a normalized axis and an angle.
+	///
+	/// @param m Input matrix multiplied by this rotation matrix.
+	/// @param angle Rotation angle expressed in radians.
+	/// @param axis Rotation axis, must be normalized.
+	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
+	///
+	/// @see gtx_rotate_normalized_axis
+	/// @see - rotate(T angle, T x, T y, T z)
+	/// @see - rotate(mat<4, 4, T, Q> const& m, T angle, T x, T y, T z)
+	/// @see - rotate(T angle, vec<3, T, Q> const& v)
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> rotateNormalizedAxis(
+		mat<4, 4, T, Q> const& m,
+		T const& angle,
+		vec<3, T, Q> const& axis);
+
+	/// Rotates a quaternion from a vector of 3 components normalized axis and an angle.
+	///
+	/// @param q Source orientation
+	/// @param angle Angle expressed in radians.
+	/// @param axis Normalized axis of the rotation, must be normalized.
+	///
+	/// @see gtx_rotate_normalized_axis
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL qua<T, Q> rotateNormalizedAxis(
+		qua<T, Q> const& q,
+		T const& angle,
+		vec<3, T, Q> const& axis);
+
+	/// @}
+}//namespace glm
+
+#include "rotate_normalized_axis.inl"
diff --git a/engine/inc/glm/gtx/rotate_normalized_axis.inl b/engine/inc/glm/gtx/rotate_normalized_axis.inl
new file mode 100644
index 00000000..b2e9278c
--- /dev/null
+++ b/engine/inc/glm/gtx/rotate_normalized_axis.inl
@@ -0,0 +1,58 @@
+/// @ref gtx_rotate_normalized_axis
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> rotateNormalizedAxis
+	(
+		mat<4, 4, T, Q> const& m,
+		T const& angle,
+		vec<3, T, Q> const& v
+	)
+	{
+		T const a = angle;
+		T const c = cos(a);
+		T const s = sin(a);
+
+		vec<3, T, Q> const axis(v);
+
+		vec<3, T, Q> const temp((static_cast<T>(1) - c) * axis);
+
+		mat<4, 4, T, Q> Rotate;
+		Rotate[0][0] = c + temp[0] * axis[0];
+		Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2];
+		Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1];
+
+		Rotate[1][0] = 0 + temp[1] * axis[0] - s * axis[2];
+		Rotate[1][1] = c + temp[1] * axis[1];
+		Rotate[1][2] = 0 + temp[1] * axis[2] + s * axis[0];
+
+		Rotate[2][0] = 0 + temp[2] * axis[0] + s * axis[1];
+		Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0];
+		Rotate[2][2] = c + temp[2] * axis[2];
+
+		mat<4, 4, T, Q> Result;
+		Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2];
+		Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2];
+		Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2];
+		Result[3] = m[3];
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER qua<T, Q> rotateNormalizedAxis
+	(
+		qua<T, Q> const& q,
+		T const& angle,
+		vec<3, T, Q> const& v
+	)
+	{
+		vec<3, T, Q> const Tmp(v);
+
+		T const AngleRad(angle);
+		T const Sin = sin(AngleRad * T(0.5));
+
+		return q * qua<T, Q>(cos(AngleRad * static_cast<T>(0.5)), Tmp.x * Sin, Tmp.y * Sin, Tmp.z * Sin);
+		//return gtc::quaternion::cross(q, tquat<T, Q>(cos(AngleRad * T(0.5)), Tmp.x * fSin, Tmp.y * fSin, Tmp.z * fSin));
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/rotate_vector.hpp b/engine/inc/glm/gtx/rotate_vector.hpp
new file mode 100644
index 00000000..f918c6c2
--- /dev/null
+++ b/engine/inc/glm/gtx/rotate_vector.hpp
@@ -0,0 +1,123 @@
+/// @ref gtx_rotate_vector
+/// @file glm/gtx/rotate_vector.hpp
+///
+/// @see core (dependence)
+/// @see gtx_transform (dependence)
+///
+/// @defgroup gtx_rotate_vector GLM_GTX_rotate_vector
+/// @ingroup gtx
+///
+/// Include <glm/gtx/rotate_vector.hpp> to use the features of this extension.
+///
+/// Function to directly rotate a vector
+
+#pragma once
+
+// Dependency:
+#include "../gtx/transform.hpp"
+#include "../gtc/epsilon.hpp"
+#include "../ext/vector_relational.hpp"
+#include "../glm.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_rotate_vector is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_rotate_vector extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_rotate_vector
+	/// @{
+
+	/// Returns Spherical interpolation between two vectors
+	///
+	/// @param x A first vector
+	/// @param y A second vector
+	/// @param a Interpolation factor. The interpolation is defined beyond the range [0, 1].
+	///
+	/// @see gtx_rotate_vector
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> slerp(
+		vec<3, T, Q> const& x,
+		vec<3, T, Q> const& y,
+		T const& a);
+
+	//! Rotate a two dimensional vector.
+	//! From GLM_GTX_rotate_vector extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<2, T, Q> rotate(
+		vec<2, T, Q> const& v,
+		T const& angle);
+
+	//! Rotate a three dimensional vector around an axis.
+	//! From GLM_GTX_rotate_vector extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> rotate(
+		vec<3, T, Q> const& v,
+		T const& angle,
+		vec<3, T, Q> const& normal);
+
+	//! Rotate a four dimensional vector around an axis.
+	//! From GLM_GTX_rotate_vector extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<4, T, Q> rotate(
+		vec<4, T, Q> const& v,
+		T const& angle,
+		vec<3, T, Q> const& normal);
+
+	//! Rotate a three dimensional vector around the X axis.
+	//! From GLM_GTX_rotate_vector extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> rotateX(
+		vec<3, T, Q> const& v,
+		T const& angle);
+
+	//! Rotate a three dimensional vector around the Y axis.
+	//! From GLM_GTX_rotate_vector extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> rotateY(
+		vec<3, T, Q> const& v,
+		T const& angle);
+
+	//! Rotate a three dimensional vector around the Z axis.
+	//! From GLM_GTX_rotate_vector extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> rotateZ(
+		vec<3, T, Q> const& v,
+		T const& angle);
+
+	//! Rotate a four dimensional vector around the X axis.
+	//! From GLM_GTX_rotate_vector extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<4, T, Q> rotateX(
+		vec<4, T, Q> const& v,
+		T const& angle);
+
+	//! Rotate a four dimensional vector around the Y axis.
+	//! From GLM_GTX_rotate_vector extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<4, T, Q> rotateY(
+		vec<4, T, Q> const& v,
+		T const& angle);
+
+	//! Rotate a four dimensional vector around the Z axis.
+	//! From GLM_GTX_rotate_vector extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL vec<4, T, Q> rotateZ(
+		vec<4, T, Q> const& v,
+		T const& angle);
+
+	//! Build a rotation matrix from a normal and a up vector.
+	//! From GLM_GTX_rotate_vector extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> orientation(
+		vec<3, T, Q> const& Normal,
+		vec<3, T, Q> const& Up);
+
+	/// @}
+}//namespace glm
+
+#include "rotate_vector.inl"
diff --git a/engine/inc/glm/gtx/rotate_vector.inl b/engine/inc/glm/gtx/rotate_vector.inl
new file mode 100644
index 00000000..f8136e76
--- /dev/null
+++ b/engine/inc/glm/gtx/rotate_vector.inl
@@ -0,0 +1,187 @@
+/// @ref gtx_rotate_vector
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> slerp
+	(
+		vec<3, T, Q> const& x,
+		vec<3, T, Q> const& y,
+		T const& a
+	)
+	{
+		// get cosine of angle between vectors (-1 -> 1)
+		T CosAlpha = dot(x, y);
+		// get angle (0 -> pi)
+		T Alpha = acos(CosAlpha);
+		// get sine of angle between vectors (0 -> 1)
+		T SinAlpha = sin(Alpha);
+		// this breaks down when SinAlpha = 0, i.e. Alpha = 0 or pi
+		T t1 = sin((static_cast<T>(1) - a) * Alpha) / SinAlpha;
+		T t2 = sin(a * Alpha) / SinAlpha;
+
+		// interpolate src vectors
+		return x * t1 + y * t2;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<2, T, Q> rotate
+	(
+		vec<2, T, Q> const& v,
+		T const& angle
+	)
+	{
+		vec<2, T, Q> Result;
+		T const Cos(cos(angle));
+		T const Sin(sin(angle));
+
+		Result.x = v.x * Cos - v.y * Sin;
+		Result.y = v.x * Sin + v.y * Cos;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> rotate
+	(
+		vec<3, T, Q> const& v,
+		T const& angle,
+		vec<3, T, Q> const& normal
+	)
+	{
+		return mat<3, 3, T, Q>(glm::rotate(angle, normal)) * v;
+	}
+	/*
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> rotateGTX(
+		const vec<3, T, Q>& x,
+		T angle,
+		const vec<3, T, Q>& normal)
+	{
+		const T Cos = cos(radians(angle));
+		const T Sin = sin(radians(angle));
+		return x * Cos + ((x * normal) * (T(1) - Cos)) * normal + cross(x, normal) * Sin;
+	}
+	*/
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, T, Q> rotate
+	(
+		vec<4, T, Q> const& v,
+		T const& angle,
+		vec<3, T, Q> const& normal
+	)
+	{
+		return rotate(angle, normal) * v;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> rotateX
+	(
+		vec<3, T, Q> const& v,
+		T const& angle
+	)
+	{
+		vec<3, T, Q> Result(v);
+		T const Cos(cos(angle));
+		T const Sin(sin(angle));
+
+		Result.y = v.y * Cos - v.z * Sin;
+		Result.z = v.y * Sin + v.z * Cos;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> rotateY
+	(
+		vec<3, T, Q> const& v,
+		T const& angle
+	)
+	{
+		vec<3, T, Q> Result = v;
+		T const Cos(cos(angle));
+		T const Sin(sin(angle));
+
+		Result.x =  v.x * Cos + v.z * Sin;
+		Result.z = -v.x * Sin + v.z * Cos;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> rotateZ
+	(
+		vec<3, T, Q> const& v,
+		T const& angle
+	)
+	{
+		vec<3, T, Q> Result = v;
+		T const Cos(cos(angle));
+		T const Sin(sin(angle));
+
+		Result.x = v.x * Cos - v.y * Sin;
+		Result.y = v.x * Sin + v.y * Cos;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, T, Q> rotateX
+	(
+		vec<4, T, Q> const& v,
+		T const& angle
+	)
+	{
+		vec<4, T, Q> Result = v;
+		T const Cos(cos(angle));
+		T const Sin(sin(angle));
+
+		Result.y = v.y * Cos - v.z * Sin;
+		Result.z = v.y * Sin + v.z * Cos;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, T, Q> rotateY
+	(
+		vec<4, T, Q> const& v,
+		T const& angle
+	)
+	{
+		vec<4, T, Q> Result = v;
+		T const Cos(cos(angle));
+		T const Sin(sin(angle));
+
+		Result.x =  v.x * Cos + v.z * Sin;
+		Result.z = -v.x * Sin + v.z * Cos;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, T, Q> rotateZ
+	(
+		vec<4, T, Q> const& v,
+		T const& angle
+	)
+	{
+		vec<4, T, Q> Result = v;
+		T const Cos(cos(angle));
+		T const Sin(sin(angle));
+
+		Result.x = v.x * Cos - v.y * Sin;
+		Result.y = v.x * Sin + v.y * Cos;
+		return Result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> orientation
+	(
+		vec<3, T, Q> const& Normal,
+		vec<3, T, Q> const& Up
+	)
+	{
+		if(all(equal(Normal, Up, epsilon<T>())))
+			return mat<4, 4, T, Q>(static_cast<T>(1));
+
+		vec<3, T, Q> RotationAxis = cross(Up, Normal);
+		T Angle = acos(dot(Normal, Up));
+
+		return rotate(Angle, RotationAxis);
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/scalar_multiplication.hpp b/engine/inc/glm/gtx/scalar_multiplication.hpp
new file mode 100644
index 00000000..b73edf67
--- /dev/null
+++ b/engine/inc/glm/gtx/scalar_multiplication.hpp
@@ -0,0 +1,75 @@
+/// @ref gtx
+/// @file glm/gtx/scalar_multiplication.hpp
+/// @author Joshua Moerman
+///
+/// Include <glm/gtx/scalar_multiplication.hpp> to use the features of this extension.
+///
+/// Enables scalar multiplication for all types
+///
+/// Since GLSL is very strict about types, the following (often used) combinations do not work:
+///    double * vec4
+///    int * vec4
+///    vec4 / int
+/// So we'll fix that! Of course "float * vec4" should remain the same (hence the enable_if magic)
+
+#pragma once
+
+#include "../detail/setup.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_scalar_multiplication is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if !GLM_HAS_TEMPLATE_ALIASES && !(GLM_COMPILER & GLM_COMPILER_GCC)
+#	error "GLM_GTX_scalar_multiplication requires C++11 support or alias templates and if not support for GCC"
+#endif
+
+#include "../vec2.hpp"
+#include "../vec3.hpp"
+#include "../vec4.hpp"
+#include "../mat2x2.hpp"
+#include <type_traits>
+
+namespace glm
+{
+	template<typename T, typename Vec>
+	using return_type_scalar_multiplication = typename std::enable_if<
+		!std::is_same<T, float>::value       // T may not be a float
+		&& std::is_arithmetic<T>::value, Vec // But it may be an int or double (no vec3 or mat3, ...)
+	>::type;
+
+#define GLM_IMPLEMENT_SCAL_MULT(Vec) \
+	template<typename T> \
+	return_type_scalar_multiplication<T, Vec> \
+	operator*(T const& s, Vec rh){ \
+		return rh *= static_cast<float>(s); \
+	} \
+	 \
+	template<typename T> \
+	return_type_scalar_multiplication<T, Vec> \
+	operator*(Vec lh, T const& s){ \
+		return lh *= static_cast<float>(s); \
+	} \
+	 \
+	template<typename T> \
+	return_type_scalar_multiplication<T, Vec> \
+	operator/(Vec lh, T const& s){ \
+		return lh *= 1.0f / s; \
+	}
+
+GLM_IMPLEMENT_SCAL_MULT(vec2)
+GLM_IMPLEMENT_SCAL_MULT(vec3)
+GLM_IMPLEMENT_SCAL_MULT(vec4)
+
+GLM_IMPLEMENT_SCAL_MULT(mat2)
+GLM_IMPLEMENT_SCAL_MULT(mat2x3)
+GLM_IMPLEMENT_SCAL_MULT(mat2x4)
+GLM_IMPLEMENT_SCAL_MULT(mat3x2)
+GLM_IMPLEMENT_SCAL_MULT(mat3)
+GLM_IMPLEMENT_SCAL_MULT(mat3x4)
+GLM_IMPLEMENT_SCAL_MULT(mat4x2)
+GLM_IMPLEMENT_SCAL_MULT(mat4x3)
+GLM_IMPLEMENT_SCAL_MULT(mat4)
+
+#undef GLM_IMPLEMENT_SCAL_MULT
+} // namespace glm
diff --git a/engine/inc/glm/gtx/scalar_relational.hpp b/engine/inc/glm/gtx/scalar_relational.hpp
new file mode 100644
index 00000000..491c62ab
--- /dev/null
+++ b/engine/inc/glm/gtx/scalar_relational.hpp
@@ -0,0 +1,36 @@
+/// @ref gtx_scalar_relational
+/// @file glm/gtx/scalar_relational.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_scalar_relational GLM_GTX_scalar_relational
+/// @ingroup gtx
+///
+/// Include <glm/gtx/scalar_relational.hpp> to use the features of this extension.
+///
+/// Extend a position from a source to a position at a defined length.
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_extend is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_extend extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_scalar_relational
+	/// @{
+
+
+
+	/// @}
+}//namespace glm
+
+#include "scalar_relational.inl"
diff --git a/engine/inc/glm/gtx/scalar_relational.inl b/engine/inc/glm/gtx/scalar_relational.inl
new file mode 100644
index 00000000..c2a121cf
--- /dev/null
+++ b/engine/inc/glm/gtx/scalar_relational.inl
@@ -0,0 +1,88 @@
+/// @ref gtx_scalar_relational
+
+namespace glm
+{
+	template<typename T>
+	GLM_FUNC_QUALIFIER bool lessThan
+	(
+		T const& x,
+		T const& y
+	)
+	{
+		return x < y;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER bool lessThanEqual
+	(
+		T const& x,
+		T const& y
+	)
+	{
+		return x <= y;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER bool greaterThan
+	(
+		T const& x,
+		T const& y
+	)
+	{
+		return x > y;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER bool greaterThanEqual
+	(
+		T const& x,
+		T const& y
+	)
+	{
+		return x >= y;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER bool equal
+	(
+		T const& x,
+		T const& y
+	)
+	{
+		return detail::compute_equal<T, std::numeric_limits<T>::is_iec559>::call(x, y);
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER bool notEqual
+	(
+		T const& x,
+		T const& y
+	)
+	{
+		return !detail::compute_equal<T, std::numeric_limits<T>::is_iec559>::call(x, y);
+	}
+
+	GLM_FUNC_QUALIFIER bool any
+	(
+		bool const& x
+	)
+	{
+		return x;
+	}
+
+	GLM_FUNC_QUALIFIER bool all
+	(
+		bool const& x
+	)
+	{
+		return x;
+	}
+
+	GLM_FUNC_QUALIFIER bool not_
+	(
+		bool const& x
+	)
+	{
+		return !x;
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/spline.hpp b/engine/inc/glm/gtx/spline.hpp
new file mode 100644
index 00000000..d59fa76a
--- /dev/null
+++ b/engine/inc/glm/gtx/spline.hpp
@@ -0,0 +1,65 @@
+/// @ref gtx_spline
+/// @file glm/gtx/spline.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_spline GLM_GTX_spline
+/// @ingroup gtx
+///
+/// Include <glm/gtx/spline.hpp> to use the features of this extension.
+///
+/// Spline functions
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtx/optimum_pow.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_spline is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_spline extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_spline
+	/// @{
+
+	/// Return a point from a catmull rom curve.
+	/// @see gtx_spline extension.
+	template<typename genType>
+	GLM_FUNC_DECL genType catmullRom(
+		genType const& v1,
+		genType const& v2,
+		genType const& v3,
+		genType const& v4,
+		typename genType::value_type const& s);
+
+	/// Return a point from a hermite curve.
+	/// @see gtx_spline extension.
+	template<typename genType>
+	GLM_FUNC_DECL genType hermite(
+		genType const& v1,
+		genType const& t1,
+		genType const& v2,
+		genType const& t2,
+		typename genType::value_type const& s);
+
+	/// Return a point from a cubic curve.
+	/// @see gtx_spline extension.
+	template<typename genType>
+	GLM_FUNC_DECL genType cubic(
+		genType const& v1,
+		genType const& v2,
+		genType const& v3,
+		genType const& v4,
+		typename genType::value_type const& s);
+
+	/// @}
+}//namespace glm
+
+#include "spline.inl"
diff --git a/engine/inc/glm/gtx/spline.inl b/engine/inc/glm/gtx/spline.inl
new file mode 100644
index 00000000..c3fd0565
--- /dev/null
+++ b/engine/inc/glm/gtx/spline.inl
@@ -0,0 +1,60 @@
+/// @ref gtx_spline
+
+namespace glm
+{
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType catmullRom
+	(
+		genType const& v1,
+		genType const& v2,
+		genType const& v3,
+		genType const& v4,
+		typename genType::value_type const& s
+	)
+	{
+		typename genType::value_type s2 = pow2(s);
+		typename genType::value_type s3 = pow3(s);
+
+		typename genType::value_type f1 = -s3 + typename genType::value_type(2) * s2 - s;
+		typename genType::value_type f2 = typename genType::value_type(3) * s3 - typename genType::value_type(5) * s2 + typename genType::value_type(2);
+		typename genType::value_type f3 = typename genType::value_type(-3) * s3 + typename genType::value_type(4) * s2 + s;
+		typename genType::value_type f4 = s3 - s2;
+
+		return (f1 * v1 + f2 * v2 + f3 * v3 + f4 * v4) / typename genType::value_type(2);
+
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType hermite
+	(
+		genType const& v1,
+		genType const& t1,
+		genType const& v2,
+		genType const& t2,
+		typename genType::value_type const& s
+	)
+	{
+		typename genType::value_type s2 = pow2(s);
+		typename genType::value_type s3 = pow3(s);
+
+		typename genType::value_type f1 = typename genType::value_type(2) * s3 - typename genType::value_type(3) * s2 + typename genType::value_type(1);
+		typename genType::value_type f2 = typename genType::value_type(-2) * s3 + typename genType::value_type(3) * s2;
+		typename genType::value_type f3 = s3 - typename genType::value_type(2) * s2 + s;
+		typename genType::value_type f4 = s3 - s2;
+
+		return f1 * v1 + f2 * v2 + f3 * t1 + f4 * t2;
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType cubic
+	(
+		genType const& v1,
+		genType const& v2,
+		genType const& v3,
+		genType const& v4,
+		typename genType::value_type const& s
+	)
+	{
+		return ((v1 * s + v2) * s + v3) * s + v4;
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/std_based_type.hpp b/engine/inc/glm/gtx/std_based_type.hpp
new file mode 100644
index 00000000..6183a622
--- /dev/null
+++ b/engine/inc/glm/gtx/std_based_type.hpp
@@ -0,0 +1,68 @@
+/// @ref gtx_std_based_type
+/// @file glm/gtx/std_based_type.hpp
+///
+/// @see core (dependence)
+/// @see gtx_extented_min_max (dependence)
+///
+/// @defgroup gtx_std_based_type GLM_GTX_std_based_type
+/// @ingroup gtx
+///
+/// Include <glm/gtx/std_based_type.hpp> to use the features of this extension.
+///
+/// Adds vector types based on STL value types.
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+#include <cstdlib>
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_std_based_type is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_std_based_type extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_std_based_type
+	/// @{
+
+	/// Vector type based of one std::size_t component.
+	/// @see GLM_GTX_std_based_type
+	typedef vec<1, std::size_t, defaultp>		size1;
+
+	/// Vector type based of two std::size_t components.
+	/// @see GLM_GTX_std_based_type
+	typedef vec<2, std::size_t, defaultp>		size2;
+
+	/// Vector type based of three std::size_t components.
+	/// @see GLM_GTX_std_based_type
+	typedef vec<3, std::size_t, defaultp>		size3;
+
+	/// Vector type based of four std::size_t components.
+	/// @see GLM_GTX_std_based_type
+	typedef vec<4, std::size_t, defaultp>		size4;
+
+	/// Vector type based of one std::size_t component.
+	/// @see GLM_GTX_std_based_type
+	typedef vec<1, std::size_t, defaultp>		size1_t;
+
+	/// Vector type based of two std::size_t components.
+	/// @see GLM_GTX_std_based_type
+	typedef vec<2, std::size_t, defaultp>		size2_t;
+
+	/// Vector type based of three std::size_t components.
+	/// @see GLM_GTX_std_based_type
+	typedef vec<3, std::size_t, defaultp>		size3_t;
+
+	/// Vector type based of four std::size_t components.
+	/// @see GLM_GTX_std_based_type
+	typedef vec<4, std::size_t, defaultp>		size4_t;
+
+	/// @}
+}//namespace glm
+
+#include "std_based_type.inl"
diff --git a/engine/inc/glm/gtx/std_based_type.inl b/engine/inc/glm/gtx/std_based_type.inl
new file mode 100644
index 00000000..9c34bdb6
--- /dev/null
+++ b/engine/inc/glm/gtx/std_based_type.inl
@@ -0,0 +1,6 @@
+/// @ref gtx_std_based_type
+
+namespace glm
+{
+
+}
diff --git a/engine/inc/glm/gtx/string_cast.hpp b/engine/inc/glm/gtx/string_cast.hpp
new file mode 100644
index 00000000..0564e57b
--- /dev/null
+++ b/engine/inc/glm/gtx/string_cast.hpp
@@ -0,0 +1,52 @@
+/// @ref gtx_string_cast
+/// @file glm/gtx/string_cast.hpp
+///
+/// @see core (dependence)
+/// @see gtx_integer (dependence)
+/// @see gtx_quaternion (dependence)
+///
+/// @defgroup gtx_string_cast GLM_GTX_string_cast
+/// @ingroup gtx
+///
+/// Include <glm/gtx/string_cast.hpp> to use the features of this extension.
+///
+/// Setup strings for GLM type values
+///
+/// This extension is not supported with CUDA
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtc/type_precision.hpp"
+#include "../gtc/quaternion.hpp"
+#include "../gtx/dual_quaternion.hpp"
+#include <string>
+#include <cmath>
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_string_cast is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if(GLM_COMPILER & GLM_COMPILER_CUDA)
+#	error "GLM_GTX_string_cast is not supported on CUDA compiler"
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_string_cast extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_string_cast
+	/// @{
+
+	/// Create a string from a GLM vector or matrix typed variable.
+	/// @see gtx_string_cast extension.
+	template<typename genType>
+	GLM_FUNC_DECL std::string to_string(genType const& x);
+
+	/// @}
+}//namespace glm
+
+#include "string_cast.inl"
diff --git a/engine/inc/glm/gtx/string_cast.inl b/engine/inc/glm/gtx/string_cast.inl
new file mode 100644
index 00000000..4ba7da3b
--- /dev/null
+++ b/engine/inc/glm/gtx/string_cast.inl
@@ -0,0 +1,492 @@
+/// @ref gtx_string_cast
+
+#include <cstdarg>
+#include <cstdio>
+
+namespace glm{
+namespace detail
+{
+	template <typename T>
+	struct cast
+	{
+		typedef T value_type;
+	};
+
+	template <>
+	struct cast<float>
+	{
+		typedef double value_type;
+	};
+
+	GLM_FUNC_QUALIFIER std::string format(const char* msg, ...)
+	{
+		std::size_t const STRING_BUFFER(4096);
+		char text[STRING_BUFFER];
+		va_list list;
+
+		if(msg == GLM_NULLPTR)
+			return std::string();
+
+		va_start(list, msg);
+#		if(GLM_COMPILER & GLM_COMPILER_VC)
+			vsprintf_s(text, STRING_BUFFER, msg, list);
+#		else//
+			vsprintf(text, msg, list);
+#		endif//
+		va_end(list);
+
+		return std::string(text);
+	}
+
+	static const char* LabelTrue = "true";
+	static const char* LabelFalse = "false";
+
+	template<typename T, bool isFloat = false>
+	struct literal
+	{
+		GLM_FUNC_QUALIFIER static char const * value() {return "%d";}
+	};
+
+	template<typename T>
+	struct literal<T, true>
+	{
+		GLM_FUNC_QUALIFIER static char const * value() {return "%f";}
+	};
+
+#	if GLM_MODEL == GLM_MODEL_32 && GLM_COMPILER && GLM_COMPILER_VC
+	template<>
+	struct literal<uint64_t, false>
+	{
+		GLM_FUNC_QUALIFIER static char const * value() {return "%lld";}
+	};
+
+	template<>
+	struct literal<int64_t, false>
+	{
+		GLM_FUNC_QUALIFIER static char const * value() {return "%lld";}
+	};
+#	endif//GLM_MODEL == GLM_MODEL_32 && GLM_COMPILER && GLM_COMPILER_VC
+
+	template<typename T>
+	struct prefix{};
+
+	template<>
+	struct prefix<float>
+	{
+		GLM_FUNC_QUALIFIER static char const * value() {return "";}
+	};
+
+	template<>
+	struct prefix<double>
+	{
+		GLM_FUNC_QUALIFIER static char const * value() {return "d";}
+	};
+
+	template<>
+	struct prefix<bool>
+	{
+		GLM_FUNC_QUALIFIER static char const * value() {return "b";}
+	};
+
+	template<>
+	struct prefix<uint8_t>
+	{
+		GLM_FUNC_QUALIFIER static char const * value() {return "u8";}
+	};
+
+	template<>
+	struct prefix<int8_t>
+	{
+		GLM_FUNC_QUALIFIER static char const * value() {return "i8";}
+	};
+
+	template<>
+	struct prefix<uint16_t>
+	{
+		GLM_FUNC_QUALIFIER static char const * value() {return "u16";}
+	};
+
+	template<>
+	struct prefix<int16_t>
+	{
+		GLM_FUNC_QUALIFIER static char const * value() {return "i16";}
+	};
+
+	template<>
+	struct prefix<uint32_t>
+	{
+		GLM_FUNC_QUALIFIER static char const * value() {return "u";}
+	};
+
+	template<>
+	struct prefix<int32_t>
+	{
+		GLM_FUNC_QUALIFIER static char const * value() {return "i";}
+	};
+
+	template<>
+	struct prefix<uint64_t>
+	{
+		GLM_FUNC_QUALIFIER static char const * value() {return "u64";}
+	};
+
+	template<>
+	struct prefix<int64_t>
+	{
+		GLM_FUNC_QUALIFIER static char const * value() {return "i64";}
+	};
+
+	template<typename matType>
+	struct compute_to_string
+	{};
+
+	template<qualifier Q>
+	struct compute_to_string<vec<1, bool, Q> >
+	{
+		GLM_FUNC_QUALIFIER static std::string call(vec<1, bool, Q> const& x)
+		{
+			return detail::format("bvec1(%s)",
+				x[0] ? detail::LabelTrue : detail::LabelFalse);
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_to_string<vec<2, bool, Q> >
+	{
+		GLM_FUNC_QUALIFIER static std::string call(vec<2, bool, Q> const& x)
+		{
+			return detail::format("bvec2(%s, %s)",
+				x[0] ? detail::LabelTrue : detail::LabelFalse,
+				x[1] ? detail::LabelTrue : detail::LabelFalse);
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_to_string<vec<3, bool, Q> >
+	{
+		GLM_FUNC_QUALIFIER static std::string call(vec<3, bool, Q> const& x)
+		{
+			return detail::format("bvec3(%s, %s, %s)",
+				x[0] ? detail::LabelTrue : detail::LabelFalse,
+				x[1] ? detail::LabelTrue : detail::LabelFalse,
+				x[2] ? detail::LabelTrue : detail::LabelFalse);
+		}
+	};
+
+	template<qualifier Q>
+	struct compute_to_string<vec<4, bool, Q> >
+	{
+		GLM_FUNC_QUALIFIER static std::string call(vec<4, bool, Q> const& x)
+		{
+			return detail::format("bvec4(%s, %s, %s, %s)",
+				x[0] ? detail::LabelTrue : detail::LabelFalse,
+				x[1] ? detail::LabelTrue : detail::LabelFalse,
+				x[2] ? detail::LabelTrue : detail::LabelFalse,
+				x[3] ? detail::LabelTrue : detail::LabelFalse);
+		}
+	};
+
+	template<typename T, qualifier Q>
+	struct compute_to_string<vec<1, T, Q> >
+	{
+		GLM_FUNC_QUALIFIER static std::string call(vec<1, T, Q> const& x)
+		{
+			char const * PrefixStr = prefix<T>::value();
+			char const * LiteralStr = literal<T, std::numeric_limits<T>::is_iec559>::value();
+			std::string FormatStr(detail::format("%svec1(%s)",
+				PrefixStr,
+				LiteralStr));
+
+			return detail::format(FormatStr.c_str(),
+				static_cast<typename cast<T>::value_type>(x[0]));
+		}
+	};
+
+	template<typename T, qualifier Q>
+	struct compute_to_string<vec<2, T, Q> >
+	{
+		GLM_FUNC_QUALIFIER static std::string call(vec<2, T, Q> const& x)
+		{
+			char const * PrefixStr = prefix<T>::value();
+			char const * LiteralStr = literal<T, std::numeric_limits<T>::is_iec559>::value();
+			std::string FormatStr(detail::format("%svec2(%s, %s)",
+				PrefixStr,
+				LiteralStr, LiteralStr));
+
+			return detail::format(FormatStr.c_str(),
+				static_cast<typename cast<T>::value_type>(x[0]),
+				static_cast<typename cast<T>::value_type>(x[1]));
+		}
+	};
+
+	template<typename T, qualifier Q>
+	struct compute_to_string<vec<3, T, Q> >
+	{
+		GLM_FUNC_QUALIFIER static std::string call(vec<3, T, Q> const& x)
+		{
+			char const * PrefixStr = prefix<T>::value();
+			char const * LiteralStr = literal<T, std::numeric_limits<T>::is_iec559>::value();
+			std::string FormatStr(detail::format("%svec3(%s, %s, %s)",
+				PrefixStr,
+				LiteralStr, LiteralStr, LiteralStr));
+
+			return detail::format(FormatStr.c_str(),
+				static_cast<typename cast<T>::value_type>(x[0]),
+				static_cast<typename cast<T>::value_type>(x[1]),
+				static_cast<typename cast<T>::value_type>(x[2]));
+		}
+	};
+
+	template<typename T, qualifier Q>
+	struct compute_to_string<vec<4, T, Q> >
+	{
+		GLM_FUNC_QUALIFIER static std::string call(vec<4, T, Q> const& x)
+		{
+			char const * PrefixStr = prefix<T>::value();
+			char const * LiteralStr = literal<T, std::numeric_limits<T>::is_iec559>::value();
+			std::string FormatStr(detail::format("%svec4(%s, %s, %s, %s)",
+				PrefixStr,
+				LiteralStr, LiteralStr, LiteralStr, LiteralStr));
+
+			return detail::format(FormatStr.c_str(),
+				static_cast<typename cast<T>::value_type>(x[0]),
+				static_cast<typename cast<T>::value_type>(x[1]),
+				static_cast<typename cast<T>::value_type>(x[2]),
+				static_cast<typename cast<T>::value_type>(x[3]));
+		}
+	};
+
+
+	template<typename T, qualifier Q>
+	struct compute_to_string<mat<2, 2, T, Q> >
+	{
+		GLM_FUNC_QUALIFIER static std::string call(mat<2, 2, T, Q> const& x)
+		{
+			char const * PrefixStr = prefix<T>::value();
+			char const * LiteralStr = literal<T, std::numeric_limits<T>::is_iec559>::value();
+			std::string FormatStr(detail::format("%smat2x2((%s, %s), (%s, %s))",
+				PrefixStr,
+				LiteralStr, LiteralStr,
+				LiteralStr, LiteralStr));
+
+			return detail::format(FormatStr.c_str(),
+				static_cast<typename cast<T>::value_type>(x[0][0]), static_cast<typename cast<T>::value_type>(x[0][1]),
+				static_cast<typename cast<T>::value_type>(x[1][0]), static_cast<typename cast<T>::value_type>(x[1][1]));
+		}
+	};
+
+	template<typename T, qualifier Q>
+	struct compute_to_string<mat<2, 3, T, Q> >
+	{
+		GLM_FUNC_QUALIFIER static std::string call(mat<2, 3, T, Q> const& x)
+		{
+			char const * PrefixStr = prefix<T>::value();
+			char const * LiteralStr = literal<T, std::numeric_limits<T>::is_iec559>::value();
+			std::string FormatStr(detail::format("%smat2x3((%s, %s, %s), (%s, %s, %s))",
+				PrefixStr,
+				LiteralStr, LiteralStr, LiteralStr,
+				LiteralStr, LiteralStr, LiteralStr));
+
+			return detail::format(FormatStr.c_str(),
+				static_cast<typename cast<T>::value_type>(x[0][0]), static_cast<typename cast<T>::value_type>(x[0][1]), static_cast<typename cast<T>::value_type>(x[0][2]),
+				static_cast<typename cast<T>::value_type>(x[1][0]), static_cast<typename cast<T>::value_type>(x[1][1]), static_cast<typename cast<T>::value_type>(x[1][2]));
+		}
+	};
+
+	template<typename T, qualifier Q>
+	struct compute_to_string<mat<2, 4, T, Q> >
+	{
+		GLM_FUNC_QUALIFIER static std::string call(mat<2, 4, T, Q> const& x)
+		{
+			char const * PrefixStr = prefix<T>::value();
+			char const * LiteralStr = literal<T, std::numeric_limits<T>::is_iec559>::value();
+			std::string FormatStr(detail::format("%smat2x4((%s, %s, %s, %s), (%s, %s, %s, %s))",
+				PrefixStr,
+				LiteralStr, LiteralStr, LiteralStr, LiteralStr,
+				LiteralStr, LiteralStr, LiteralStr, LiteralStr));
+
+			return detail::format(FormatStr.c_str(),
+				static_cast<typename cast<T>::value_type>(x[0][0]), static_cast<typename cast<T>::value_type>(x[0][1]), static_cast<typename cast<T>::value_type>(x[0][2]), static_cast<typename cast<T>::value_type>(x[0][3]),
+				static_cast<typename cast<T>::value_type>(x[1][0]), static_cast<typename cast<T>::value_type>(x[1][1]), static_cast<typename cast<T>::value_type>(x[1][2]), static_cast<typename cast<T>::value_type>(x[1][3]));
+		}
+	};
+
+	template<typename T, qualifier Q>
+	struct compute_to_string<mat<3, 2, T, Q> >
+	{
+		GLM_FUNC_QUALIFIER static std::string call(mat<3, 2, T, Q> const& x)
+		{
+			char const * PrefixStr = prefix<T>::value();
+			char const * LiteralStr = literal<T, std::numeric_limits<T>::is_iec559>::value();
+			std::string FormatStr(detail::format("%smat3x2((%s, %s), (%s, %s), (%s, %s))",
+				PrefixStr,
+				LiteralStr, LiteralStr,
+				LiteralStr, LiteralStr,
+				LiteralStr, LiteralStr));
+
+			return detail::format(FormatStr.c_str(),
+				static_cast<typename cast<T>::value_type>(x[0][0]), static_cast<typename cast<T>::value_type>(x[0][1]),
+				static_cast<typename cast<T>::value_type>(x[1][0]), static_cast<typename cast<T>::value_type>(x[1][1]),
+				static_cast<typename cast<T>::value_type>(x[2][0]), static_cast<typename cast<T>::value_type>(x[2][1]));
+		}
+	};
+
+	template<typename T, qualifier Q>
+	struct compute_to_string<mat<3, 3, T, Q> >
+	{
+		GLM_FUNC_QUALIFIER static std::string call(mat<3, 3, T, Q> const& x)
+		{
+			char const * PrefixStr = prefix<T>::value();
+			char const * LiteralStr = literal<T, std::numeric_limits<T>::is_iec559>::value();
+			std::string FormatStr(detail::format("%smat3x3((%s, %s, %s), (%s, %s, %s), (%s, %s, %s))",
+				PrefixStr,
+				LiteralStr, LiteralStr, LiteralStr,
+				LiteralStr, LiteralStr, LiteralStr,
+				LiteralStr, LiteralStr, LiteralStr));
+
+			return detail::format(FormatStr.c_str(),
+				static_cast<typename cast<T>::value_type>(x[0][0]), static_cast<typename cast<T>::value_type>(x[0][1]), static_cast<typename cast<T>::value_type>(x[0][2]),
+				static_cast<typename cast<T>::value_type>(x[1][0]), static_cast<typename cast<T>::value_type>(x[1][1]), static_cast<typename cast<T>::value_type>(x[1][2]),
+				static_cast<typename cast<T>::value_type>(x[2][0]), static_cast<typename cast<T>::value_type>(x[2][1]), static_cast<typename cast<T>::value_type>(x[2][2]));
+		}
+	};
+
+	template<typename T, qualifier Q>
+	struct compute_to_string<mat<3, 4, T, Q> >
+	{
+		GLM_FUNC_QUALIFIER static std::string call(mat<3, 4, T, Q> const& x)
+		{
+			char const * PrefixStr = prefix<T>::value();
+			char const * LiteralStr = literal<T, std::numeric_limits<T>::is_iec559>::value();
+			std::string FormatStr(detail::format("%smat3x4((%s, %s, %s, %s), (%s, %s, %s, %s), (%s, %s, %s, %s))",
+				PrefixStr,
+				LiteralStr, LiteralStr, LiteralStr, LiteralStr,
+				LiteralStr, LiteralStr, LiteralStr, LiteralStr,
+				LiteralStr, LiteralStr, LiteralStr, LiteralStr));
+
+			return detail::format(FormatStr.c_str(),
+				static_cast<typename cast<T>::value_type>(x[0][0]), static_cast<typename cast<T>::value_type>(x[0][1]), static_cast<typename cast<T>::value_type>(x[0][2]), static_cast<typename cast<T>::value_type>(x[0][3]),
+				static_cast<typename cast<T>::value_type>(x[1][0]), static_cast<typename cast<T>::value_type>(x[1][1]), static_cast<typename cast<T>::value_type>(x[1][2]), static_cast<typename cast<T>::value_type>(x[1][3]),
+				static_cast<typename cast<T>::value_type>(x[2][0]), static_cast<typename cast<T>::value_type>(x[2][1]), static_cast<typename cast<T>::value_type>(x[2][2]), static_cast<typename cast<T>::value_type>(x[2][3]));
+		}
+	};
+
+	template<typename T, qualifier Q>
+	struct compute_to_string<mat<4, 2, T, Q> >
+	{
+		GLM_FUNC_QUALIFIER static std::string call(mat<4, 2, T, Q> const& x)
+		{
+			char const * PrefixStr = prefix<T>::value();
+			char const * LiteralStr = literal<T, std::numeric_limits<T>::is_iec559>::value();
+			std::string FormatStr(detail::format("%smat4x2((%s, %s), (%s, %s), (%s, %s), (%s, %s))",
+				PrefixStr,
+				LiteralStr, LiteralStr,
+				LiteralStr, LiteralStr,
+				LiteralStr, LiteralStr,
+				LiteralStr, LiteralStr));
+
+			return detail::format(FormatStr.c_str(),
+				static_cast<typename cast<T>::value_type>(x[0][0]), static_cast<typename cast<T>::value_type>(x[0][1]),
+				static_cast<typename cast<T>::value_type>(x[1][0]), static_cast<typename cast<T>::value_type>(x[1][1]),
+				static_cast<typename cast<T>::value_type>(x[2][0]), static_cast<typename cast<T>::value_type>(x[2][1]),
+				static_cast<typename cast<T>::value_type>(x[3][0]), static_cast<typename cast<T>::value_type>(x[3][1]));
+		}
+	};
+
+	template<typename T, qualifier Q>
+	struct compute_to_string<mat<4, 3, T, Q> >
+	{
+		GLM_FUNC_QUALIFIER static std::string call(mat<4, 3, T, Q> const& x)
+		{
+			char const * PrefixStr = prefix<T>::value();
+			char const * LiteralStr = literal<T, std::numeric_limits<T>::is_iec559>::value();
+			std::string FormatStr(detail::format("%smat4x3((%s, %s, %s), (%s, %s, %s), (%s, %s, %s), (%s, %s, %s))",
+				PrefixStr,
+				LiteralStr, LiteralStr, LiteralStr,
+				LiteralStr, LiteralStr, LiteralStr,
+				LiteralStr, LiteralStr, LiteralStr,
+				LiteralStr, LiteralStr, LiteralStr));
+
+			return detail::format(FormatStr.c_str(),
+				static_cast<typename cast<T>::value_type>(x[0][0]), static_cast<typename cast<T>::value_type>(x[0][1]), static_cast<typename cast<T>::value_type>(x[0][2]),
+				static_cast<typename cast<T>::value_type>(x[1][0]), static_cast<typename cast<T>::value_type>(x[1][1]), static_cast<typename cast<T>::value_type>(x[1][2]),
+				static_cast<typename cast<T>::value_type>(x[2][0]), static_cast<typename cast<T>::value_type>(x[2][1]), static_cast<typename cast<T>::value_type>(x[2][2]),
+				static_cast<typename cast<T>::value_type>(x[3][0]), static_cast<typename cast<T>::value_type>(x[3][1]), static_cast<typename cast<T>::value_type>(x[3][2]));
+		}
+	};
+
+	template<typename T, qualifier Q>
+	struct compute_to_string<mat<4, 4, T, Q> >
+	{
+		GLM_FUNC_QUALIFIER static std::string call(mat<4, 4, T, Q> const& x)
+		{
+			char const * PrefixStr = prefix<T>::value();
+			char const * LiteralStr = literal<T, std::numeric_limits<T>::is_iec559>::value();
+			std::string FormatStr(detail::format("%smat4x4((%s, %s, %s, %s), (%s, %s, %s, %s), (%s, %s, %s, %s), (%s, %s, %s, %s))",
+				PrefixStr,
+				LiteralStr, LiteralStr, LiteralStr, LiteralStr,
+				LiteralStr, LiteralStr, LiteralStr, LiteralStr,
+				LiteralStr, LiteralStr, LiteralStr, LiteralStr,
+				LiteralStr, LiteralStr, LiteralStr, LiteralStr));
+
+			return detail::format(FormatStr.c_str(),
+				static_cast<typename cast<T>::value_type>(x[0][0]), static_cast<typename cast<T>::value_type>(x[0][1]), static_cast<typename cast<T>::value_type>(x[0][2]), static_cast<typename cast<T>::value_type>(x[0][3]),
+				static_cast<typename cast<T>::value_type>(x[1][0]), static_cast<typename cast<T>::value_type>(x[1][1]), static_cast<typename cast<T>::value_type>(x[1][2]), static_cast<typename cast<T>::value_type>(x[1][3]),
+				static_cast<typename cast<T>::value_type>(x[2][0]), static_cast<typename cast<T>::value_type>(x[2][1]), static_cast<typename cast<T>::value_type>(x[2][2]), static_cast<typename cast<T>::value_type>(x[2][3]),
+				static_cast<typename cast<T>::value_type>(x[3][0]), static_cast<typename cast<T>::value_type>(x[3][1]), static_cast<typename cast<T>::value_type>(x[3][2]), static_cast<typename cast<T>::value_type>(x[3][3]));
+		}
+	};
+
+
+	template<typename T, qualifier Q>
+	struct compute_to_string<qua<T, Q> >
+	{
+		GLM_FUNC_QUALIFIER static std::string call(qua<T, Q> const& x)
+		{
+			char const * PrefixStr = prefix<T>::value();
+			char const * LiteralStr = literal<T, std::numeric_limits<T>::is_iec559>::value();
+			std::string FormatStr(detail::format("%squat(%s, {%s, %s, %s})",
+				PrefixStr,
+				LiteralStr, LiteralStr, LiteralStr, LiteralStr));
+
+			return detail::format(FormatStr.c_str(),
+				static_cast<typename cast<T>::value_type>(x[3]),
+				static_cast<typename cast<T>::value_type>(x[0]),
+				static_cast<typename cast<T>::value_type>(x[1]),
+				static_cast<typename cast<T>::value_type>(x[2]));
+		}
+	};
+
+	template<typename T, qualifier Q>
+	struct compute_to_string<tdualquat<T, Q> >
+	{
+		GLM_FUNC_QUALIFIER static std::string call(tdualquat<T, Q> const& x)
+		{
+			char const * PrefixStr = prefix<T>::value();
+			char const * LiteralStr = literal<T, std::numeric_limits<T>::is_iec559>::value();
+			std::string FormatStr(detail::format("%sdualquat((%s, {%s, %s, %s}), (%s, {%s, %s, %s}))",
+				PrefixStr,
+				LiteralStr, LiteralStr, LiteralStr, LiteralStr,
+				LiteralStr, LiteralStr, LiteralStr, LiteralStr));
+
+			return detail::format(FormatStr.c_str(),
+				static_cast<typename cast<T>::value_type>(x.real[3]),
+				static_cast<typename cast<T>::value_type>(x.real[0]),
+				static_cast<typename cast<T>::value_type>(x.real[1]),
+				static_cast<typename cast<T>::value_type>(x.real[2]),
+				static_cast<typename cast<T>::value_type>(x.dual[3]),
+				static_cast<typename cast<T>::value_type>(x.dual[0]),
+				static_cast<typename cast<T>::value_type>(x.dual[1]),
+				static_cast<typename cast<T>::value_type>(x.dual[2]));
+		}
+	};
+
+}//namespace detail
+
+template<class matType>
+GLM_FUNC_QUALIFIER std::string to_string(matType const& x)
+{
+	return detail::compute_to_string<matType>::call(x);
+}
+
+}//namespace glm
diff --git a/engine/inc/glm/gtx/texture.hpp b/engine/inc/glm/gtx/texture.hpp
new file mode 100644
index 00000000..ee3bf7ce
--- /dev/null
+++ b/engine/inc/glm/gtx/texture.hpp
@@ -0,0 +1,46 @@
+/// @ref gtx_texture
+/// @file glm/gtx/texture.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_texture GLM_GTX_texture
+/// @ingroup gtx
+///
+/// Include <glm/gtx/texture.hpp> to use the features of this extension.
+///
+/// Wrapping mode of texture coordinates.
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtc/integer.hpp"
+#include "../gtx/component_wise.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_texture is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_texture extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_texture
+	/// @{
+
+	/// Compute the number of mipmaps levels necessary to create a mipmap complete texture
+	///
+	/// @param Extent Extent of the texture base level mipmap
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point or signed integer scalar types
+	/// @tparam Q Value from qualifier enum
+	template <length_t L, typename T, qualifier Q>
+	T levels(vec<L, T, Q> const& Extent);
+
+	/// @}
+}// namespace glm
+
+#include "texture.inl"
+
diff --git a/engine/inc/glm/gtx/texture.inl b/engine/inc/glm/gtx/texture.inl
new file mode 100644
index 00000000..593c8261
--- /dev/null
+++ b/engine/inc/glm/gtx/texture.inl
@@ -0,0 +1,17 @@
+/// @ref gtx_texture
+
+namespace glm
+{
+	template <length_t L, typename T, qualifier Q>
+	inline T levels(vec<L, T, Q> const& Extent)
+	{
+		return glm::log2(compMax(Extent)) + static_cast<T>(1);
+	}
+
+	template <typename T>
+	inline T levels(T Extent)
+	{
+		return vec<1, T, defaultp>(Extent).x;
+	}
+}//namespace glm
+
diff --git a/engine/inc/glm/gtx/transform.hpp b/engine/inc/glm/gtx/transform.hpp
new file mode 100644
index 00000000..eded01a3
--- /dev/null
+++ b/engine/inc/glm/gtx/transform.hpp
@@ -0,0 +1,60 @@
+/// @ref gtx_transform
+/// @file glm/gtx/transform.hpp
+///
+/// @see core (dependence)
+/// @see gtc_matrix_transform (dependence)
+/// @see gtx_transform
+/// @see gtx_transform2
+///
+/// @defgroup gtx_transform GLM_GTX_transform
+/// @ingroup gtx
+///
+/// Include <glm/gtx/transform.hpp> to use the features of this extension.
+///
+/// Add transformation matrices
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtc/matrix_transform.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_transform is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_transform extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_transform
+	/// @{
+
+	/// Transforms a matrix with a translation 4 * 4 matrix created from 3 scalars.
+	/// @see gtc_matrix_transform
+	/// @see gtx_transform
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> translate(
+		vec<3, T, Q> const& v);
+
+	/// Builds a rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in radians.
+	/// @see gtc_matrix_transform
+	/// @see gtx_transform
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> rotate(
+		T angle,
+		vec<3, T, Q> const& v);
+
+	/// Transforms a matrix with a scale 4 * 4 matrix created from a vector of 3 components.
+	/// @see gtc_matrix_transform
+	/// @see gtx_transform
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> scale(
+		vec<3, T, Q> const& v);
+
+	/// @}
+}// namespace glm
+
+#include "transform.inl"
diff --git a/engine/inc/glm/gtx/transform.inl b/engine/inc/glm/gtx/transform.inl
new file mode 100644
index 00000000..48ee6801
--- /dev/null
+++ b/engine/inc/glm/gtx/transform.inl
@@ -0,0 +1,23 @@
+/// @ref gtx_transform
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> translate(vec<3, T, Q> const& v)
+	{
+		return translate(mat<4, 4, T, Q>(static_cast<T>(1)), v);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> rotate(T angle, vec<3, T, Q> const& v)
+	{
+		return rotate(mat<4, 4, T, Q>(static_cast<T>(1)), angle, v);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> scale(vec<3, T, Q> const& v)
+	{
+		return scale(mat<4, 4, T, Q>(static_cast<T>(1)), v);
+	}
+
+}//namespace glm
diff --git a/engine/inc/glm/gtx/transform2.hpp b/engine/inc/glm/gtx/transform2.hpp
new file mode 100644
index 00000000..19fdf6cc
--- /dev/null
+++ b/engine/inc/glm/gtx/transform2.hpp
@@ -0,0 +1,89 @@
+/// @ref gtx_transform2
+/// @file glm/gtx/transform2.hpp
+///
+/// @see core (dependence)
+/// @see gtx_transform (dependence)
+///
+/// @defgroup gtx_transform2 GLM_GTX_transform2
+/// @ingroup gtx
+///
+/// Include <glm/gtx/transform2.hpp> to use the features of this extension.
+///
+/// Add extra transformation matrices
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtx/transform.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_transform2 is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_transform2 extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_transform2
+	/// @{
+
+	//! Transforms a matrix with a shearing on X axis.
+	//! From GLM_GTX_transform2 extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> shearX2D(mat<3, 3, T, Q> const& m, T y);
+
+	//! Transforms a matrix with a shearing on Y axis.
+	//! From GLM_GTX_transform2 extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> shearY2D(mat<3, 3, T, Q> const& m, T x);
+
+	//! Transforms a matrix with a shearing on X axis
+	//! From GLM_GTX_transform2 extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> shearX3D(mat<4, 4, T, Q> const& m, T y, T z);
+
+	//! Transforms a matrix with a shearing on Y axis.
+	//! From GLM_GTX_transform2 extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> shearY3D(mat<4, 4, T, Q> const& m, T x, T z);
+
+	//! Transforms a matrix with a shearing on Z axis.
+	//! From GLM_GTX_transform2 extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> shearZ3D(mat<4, 4, T, Q> const& m, T x, T y);
+
+	//template<typename T> GLM_FUNC_QUALIFIER mat<4, 4, T, Q> shear(const mat<4, 4, T, Q> & m, shearPlane, planePoint, angle)
+	// Identity + tan(angle) * cross(Normal, OnPlaneVector)     0
+	// - dot(PointOnPlane, normal) * OnPlaneVector              1
+
+	// Reflect functions seem to don't work
+	//template<typename T> mat<3, 3, T, Q> reflect2D(const mat<3, 3, T, Q> & m, const vec<3, T, Q>& normal){return reflect2DGTX(m, normal);}									//!< \brief Build a reflection matrix (from GLM_GTX_transform2 extension)
+	//template<typename T> mat<4, 4, T, Q> reflect3D(const mat<4, 4, T, Q> & m, const vec<3, T, Q>& normal){return reflect3DGTX(m, normal);}									//!< \brief Build a reflection matrix (from GLM_GTX_transform2 extension)
+
+	//! Build planar projection matrix along normal axis.
+	//! From GLM_GTX_transform2 extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<3, 3, T, Q> proj2D(mat<3, 3, T, Q> const& m, vec<3, T, Q> const& normal);
+
+	//! Build planar projection matrix along normal axis.
+	//! From GLM_GTX_transform2 extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> proj3D(mat<4, 4, T, Q> const & m, vec<3, T, Q> const& normal);
+
+	//! Build a scale bias matrix.
+	//! From GLM_GTX_transform2 extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> scaleBias(T scale, T bias);
+
+	//! Build a scale bias matrix.
+	//! From GLM_GTX_transform2 extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL mat<4, 4, T, Q> scaleBias(mat<4, 4, T, Q> const& m, T scale, T bias);
+
+	/// @}
+}// namespace glm
+
+#include "transform2.inl"
diff --git a/engine/inc/glm/gtx/transform2.inl b/engine/inc/glm/gtx/transform2.inl
new file mode 100644
index 00000000..2b53198b
--- /dev/null
+++ b/engine/inc/glm/gtx/transform2.inl
@@ -0,0 +1,125 @@
+/// @ref gtx_transform2
+
+namespace glm
+{
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> shearX2D(mat<3, 3, T, Q> const& m, T s)
+	{
+		mat<3, 3, T, Q> r(1);
+		r[1][0] = s;
+		return m * r;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> shearY2D(mat<3, 3, T, Q> const& m, T s)
+	{
+		mat<3, 3, T, Q> r(1);
+		r[0][1] = s;
+		return m * r;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> shearX3D(mat<4, 4, T, Q> const& m, T s, T t)
+	{
+		mat<4, 4, T, Q> r(1);
+		r[0][1] = s;
+		r[0][2] = t;
+		return m * r;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> shearY3D(mat<4, 4, T, Q> const& m, T s, T t)
+	{
+		mat<4, 4, T, Q> r(1);
+		r[1][0] = s;
+		r[1][2] = t;
+		return m * r;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> shearZ3D(mat<4, 4, T, Q> const& m, T s, T t)
+	{
+		mat<4, 4, T, Q> r(1);
+		r[2][0] = s;
+		r[2][1] = t;
+		return m * r;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> reflect2D(mat<3, 3, T, Q> const& m, vec<3, T, Q> const& normal)
+	{
+		mat<3, 3, T, Q> r(static_cast<T>(1));
+		r[0][0] = static_cast<T>(1) - static_cast<T>(2) * normal.x * normal.x;
+		r[0][1] = -static_cast<T>(2) * normal.x * normal.y;
+		r[1][0] = -static_cast<T>(2) * normal.x * normal.y;
+		r[1][1] = static_cast<T>(1) - static_cast<T>(2) * normal.y * normal.y;
+		return m * r;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> reflect3D(mat<4, 4, T, Q> const& m, vec<3, T, Q> const& normal)
+	{
+		mat<4, 4, T, Q> r(static_cast<T>(1));
+		r[0][0] = static_cast<T>(1) - static_cast<T>(2) * normal.x * normal.x;
+		r[0][1] = -static_cast<T>(2) * normal.x * normal.y;
+		r[0][2] = -static_cast<T>(2) * normal.x * normal.z;
+
+		r[1][0] = -static_cast<T>(2) * normal.x * normal.y;
+		r[1][1] = static_cast<T>(1) - static_cast<T>(2) * normal.y * normal.y;
+		r[1][2] = -static_cast<T>(2) * normal.y * normal.z;
+
+		r[2][0] = -static_cast<T>(2) * normal.x * normal.z;
+		r[2][1] = -static_cast<T>(2) * normal.y * normal.z;
+		r[2][2] = static_cast<T>(1) - static_cast<T>(2) * normal.z * normal.z;
+		return m * r;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, Q> proj2D(
+		const mat<3, 3, T, Q>& m,
+		const vec<3, T, Q>& normal)
+	{
+		mat<3, 3, T, Q> r(static_cast<T>(1));
+		r[0][0] = static_cast<T>(1) - normal.x * normal.x;
+		r[0][1] = - normal.x * normal.y;
+		r[1][0] = - normal.x * normal.y;
+		r[1][1] = static_cast<T>(1) - normal.y * normal.y;
+		return m * r;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> proj3D(
+		const mat<4, 4, T, Q>& m,
+		const vec<3, T, Q>& normal)
+	{
+		mat<4, 4, T, Q> r(static_cast<T>(1));
+		r[0][0] = static_cast<T>(1) - normal.x * normal.x;
+		r[0][1] = - normal.x * normal.y;
+		r[0][2] = - normal.x * normal.z;
+		r[1][0] = - normal.x * normal.y;
+		r[1][1] = static_cast<T>(1) - normal.y * normal.y;
+		r[1][2] = - normal.y * normal.z;
+		r[2][0] = - normal.x * normal.z;
+		r[2][1] = - normal.y * normal.z;
+		r[2][2] = static_cast<T>(1) - normal.z * normal.z;
+		return m * r;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> scaleBias(T scale, T bias)
+	{
+		mat<4, 4, T, Q> result;
+		result[3] = vec<4, T, Q>(vec<3, T, Q>(bias), static_cast<T>(1));
+		result[0][0] = scale;
+		result[1][1] = scale;
+		result[2][2] = scale;
+		return result;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> scaleBias(mat<4, 4, T, Q> const& m, T scale, T bias)
+	{
+		return m * scaleBias(scale, bias);
+	}
+}//namespace glm
+
diff --git a/engine/inc/glm/gtx/type_aligned.hpp b/engine/inc/glm/gtx/type_aligned.hpp
new file mode 100644
index 00000000..130f4cd6
--- /dev/null
+++ b/engine/inc/glm/gtx/type_aligned.hpp
@@ -0,0 +1,982 @@
+/// @ref gtx_type_aligned
+/// @file glm/gtx/type_aligned.hpp
+///
+/// @see core (dependence)
+/// @see gtc_quaternion (dependence)
+///
+/// @defgroup gtx_type_aligned GLM_GTX_type_aligned
+/// @ingroup gtx
+///
+/// Include <glm/gtx/type_aligned.hpp> to use the features of this extension.
+///
+/// Defines aligned types.
+
+#pragma once
+
+// Dependency:
+#include "../gtc/type_precision.hpp"
+#include "../gtc/quaternion.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_type_aligned is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_type_aligned extension included")
+#endif
+
+namespace glm
+{
+	///////////////////////////
+	// Signed int vector types
+
+	/// @addtogroup gtx_type_aligned
+	/// @{
+
+	/// Low qualifier 8 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(lowp_int8, aligned_lowp_int8, 1);
+
+	/// Low qualifier 16 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(lowp_int16, aligned_lowp_int16, 2);
+
+	/// Low qualifier 32 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(lowp_int32, aligned_lowp_int32, 4);
+
+	/// Low qualifier 64 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(lowp_int64, aligned_lowp_int64, 8);
+
+
+	/// Low qualifier 8 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(lowp_int8_t, aligned_lowp_int8_t, 1);
+
+	/// Low qualifier 16 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(lowp_int16_t, aligned_lowp_int16_t, 2);
+
+	/// Low qualifier 32 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(lowp_int32_t, aligned_lowp_int32_t, 4);
+
+	/// Low qualifier 64 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(lowp_int64_t, aligned_lowp_int64_t, 8);
+
+
+	/// Low qualifier 8 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(lowp_i8, aligned_lowp_i8, 1);
+
+	/// Low qualifier 16 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(lowp_i16, aligned_lowp_i16, 2);
+
+	/// Low qualifier 32 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(lowp_i32, aligned_lowp_i32, 4);
+
+	/// Low qualifier 64 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(lowp_i64, aligned_lowp_i64, 8);
+
+
+	/// Medium qualifier 8 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(mediump_int8, aligned_mediump_int8, 1);
+
+	/// Medium qualifier 16 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(mediump_int16, aligned_mediump_int16, 2);
+
+	/// Medium qualifier 32 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(mediump_int32, aligned_mediump_int32, 4);
+
+	/// Medium qualifier 64 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(mediump_int64, aligned_mediump_int64, 8);
+
+
+	/// Medium qualifier 8 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(mediump_int8_t, aligned_mediump_int8_t, 1);
+
+	/// Medium qualifier 16 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(mediump_int16_t, aligned_mediump_int16_t, 2);
+
+	/// Medium qualifier 32 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(mediump_int32_t, aligned_mediump_int32_t, 4);
+
+	/// Medium qualifier 64 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(mediump_int64_t, aligned_mediump_int64_t, 8);
+
+
+	/// Medium qualifier 8 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(mediump_i8, aligned_mediump_i8, 1);
+
+	/// Medium qualifier 16 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(mediump_i16, aligned_mediump_i16, 2);
+
+	/// Medium qualifier 32 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(mediump_i32, aligned_mediump_i32, 4);
+
+	/// Medium qualifier 64 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(mediump_i64, aligned_mediump_i64, 8);
+
+
+	/// High qualifier 8 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(highp_int8, aligned_highp_int8, 1);
+
+	/// High qualifier 16 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(highp_int16, aligned_highp_int16, 2);
+
+	/// High qualifier 32 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(highp_int32, aligned_highp_int32, 4);
+
+	/// High qualifier 64 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(highp_int64, aligned_highp_int64, 8);
+
+
+	/// High qualifier 8 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(highp_int8_t, aligned_highp_int8_t, 1);
+
+	/// High qualifier 16 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(highp_int16_t, aligned_highp_int16_t, 2);
+
+	/// High qualifier 32 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(highp_int32_t, aligned_highp_int32_t, 4);
+
+	/// High qualifier 64 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(highp_int64_t, aligned_highp_int64_t, 8);
+
+
+	/// High qualifier 8 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(highp_i8, aligned_highp_i8, 1);
+
+	/// High qualifier 16 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(highp_i16, aligned_highp_i16, 2);
+
+	/// High qualifier 32 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(highp_i32, aligned_highp_i32, 4);
+
+	/// High qualifier 64 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(highp_i64, aligned_highp_i64, 8);
+
+
+	/// Default qualifier 8 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(int8, aligned_int8, 1);
+
+	/// Default qualifier 16 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(int16, aligned_int16, 2);
+
+	/// Default qualifier 32 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(int32, aligned_int32, 4);
+
+	/// Default qualifier 64 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(int64, aligned_int64, 8);
+
+
+	/// Default qualifier 8 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(int8_t, aligned_int8_t, 1);
+
+	/// Default qualifier 16 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(int16_t, aligned_int16_t, 2);
+
+	/// Default qualifier 32 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(int32_t, aligned_int32_t, 4);
+
+	/// Default qualifier 64 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(int64_t, aligned_int64_t, 8);
+
+
+	/// Default qualifier 8 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(i8, aligned_i8, 1);
+
+	/// Default qualifier 16 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(i16, aligned_i16, 2);
+
+	/// Default qualifier 32 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(i32, aligned_i32, 4);
+
+	/// Default qualifier 64 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(i64, aligned_i64, 8);
+
+
+	/// Default qualifier 32 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(ivec1, aligned_ivec1, 4);
+
+	/// Default qualifier 32 bit signed integer aligned vector of 2 components type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(ivec2, aligned_ivec2, 8);
+
+	/// Default qualifier 32 bit signed integer aligned vector of 3 components type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(ivec3, aligned_ivec3, 16);
+
+	/// Default qualifier 32 bit signed integer aligned vector of 4 components type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(ivec4, aligned_ivec4, 16);
+
+
+	/// Default qualifier 8 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(i8vec1, aligned_i8vec1, 1);
+
+	/// Default qualifier 8 bit signed integer aligned vector of 2 components type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(i8vec2, aligned_i8vec2, 2);
+
+	/// Default qualifier 8 bit signed integer aligned vector of 3 components type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(i8vec3, aligned_i8vec3, 4);
+
+	/// Default qualifier 8 bit signed integer aligned vector of 4 components type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(i8vec4, aligned_i8vec4, 4);
+
+
+	/// Default qualifier 16 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(i16vec1, aligned_i16vec1, 2);
+
+	/// Default qualifier 16 bit signed integer aligned vector of 2 components type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(i16vec2, aligned_i16vec2, 4);
+
+	/// Default qualifier 16 bit signed integer aligned vector of 3 components type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(i16vec3, aligned_i16vec3, 8);
+
+	/// Default qualifier 16 bit signed integer aligned vector of 4 components type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(i16vec4, aligned_i16vec4, 8);
+
+
+	/// Default qualifier 32 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(i32vec1, aligned_i32vec1, 4);
+
+	/// Default qualifier 32 bit signed integer aligned vector of 2 components type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(i32vec2, aligned_i32vec2, 8);
+
+	/// Default qualifier 32 bit signed integer aligned vector of 3 components type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(i32vec3, aligned_i32vec3, 16);
+
+	/// Default qualifier 32 bit signed integer aligned vector of 4 components type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(i32vec4, aligned_i32vec4, 16);
+
+
+	/// Default qualifier 64 bit signed integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(i64vec1, aligned_i64vec1, 8);
+
+	/// Default qualifier 64 bit signed integer aligned vector of 2 components type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(i64vec2, aligned_i64vec2, 16);
+
+	/// Default qualifier 64 bit signed integer aligned vector of 3 components type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(i64vec3, aligned_i64vec3, 32);
+
+	/// Default qualifier 64 bit signed integer aligned vector of 4 components type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(i64vec4, aligned_i64vec4, 32);
+
+
+	/////////////////////////////
+	// Unsigned int vector types
+
+	/// Low qualifier 8 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(lowp_uint8, aligned_lowp_uint8, 1);
+
+	/// Low qualifier 16 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(lowp_uint16, aligned_lowp_uint16, 2);
+
+	/// Low qualifier 32 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(lowp_uint32, aligned_lowp_uint32, 4);
+
+	/// Low qualifier 64 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(lowp_uint64, aligned_lowp_uint64, 8);
+
+
+	/// Low qualifier 8 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(lowp_uint8_t, aligned_lowp_uint8_t, 1);
+
+	/// Low qualifier 16 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(lowp_uint16_t, aligned_lowp_uint16_t, 2);
+
+	/// Low qualifier 32 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(lowp_uint32_t, aligned_lowp_uint32_t, 4);
+
+	/// Low qualifier 64 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(lowp_uint64_t, aligned_lowp_uint64_t, 8);
+
+
+	/// Low qualifier 8 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(lowp_u8, aligned_lowp_u8, 1);
+
+	/// Low qualifier 16 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(lowp_u16, aligned_lowp_u16, 2);
+
+	/// Low qualifier 32 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(lowp_u32, aligned_lowp_u32, 4);
+
+	/// Low qualifier 64 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(lowp_u64, aligned_lowp_u64, 8);
+
+
+	/// Medium qualifier 8 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(mediump_uint8, aligned_mediump_uint8, 1);
+
+	/// Medium qualifier 16 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(mediump_uint16, aligned_mediump_uint16, 2);
+
+	/// Medium qualifier 32 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(mediump_uint32, aligned_mediump_uint32, 4);
+
+	/// Medium qualifier 64 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(mediump_uint64, aligned_mediump_uint64, 8);
+
+
+	/// Medium qualifier 8 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(mediump_uint8_t, aligned_mediump_uint8_t, 1);
+
+	/// Medium qualifier 16 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(mediump_uint16_t, aligned_mediump_uint16_t, 2);
+
+	/// Medium qualifier 32 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(mediump_uint32_t, aligned_mediump_uint32_t, 4);
+
+	/// Medium qualifier 64 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(mediump_uint64_t, aligned_mediump_uint64_t, 8);
+
+
+	/// Medium qualifier 8 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(mediump_u8, aligned_mediump_u8, 1);
+
+	/// Medium qualifier 16 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(mediump_u16, aligned_mediump_u16, 2);
+
+	/// Medium qualifier 32 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(mediump_u32, aligned_mediump_u32, 4);
+
+	/// Medium qualifier 64 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(mediump_u64, aligned_mediump_u64, 8);
+
+
+	/// High qualifier 8 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(highp_uint8, aligned_highp_uint8, 1);
+
+	/// High qualifier 16 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(highp_uint16, aligned_highp_uint16, 2);
+
+	/// High qualifier 32 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(highp_uint32, aligned_highp_uint32, 4);
+
+	/// High qualifier 64 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(highp_uint64, aligned_highp_uint64, 8);
+
+
+	/// High qualifier 8 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(highp_uint8_t, aligned_highp_uint8_t, 1);
+
+	/// High qualifier 16 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(highp_uint16_t, aligned_highp_uint16_t, 2);
+
+	/// High qualifier 32 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(highp_uint32_t, aligned_highp_uint32_t, 4);
+
+	/// High qualifier 64 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(highp_uint64_t, aligned_highp_uint64_t, 8);
+
+
+	/// High qualifier 8 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(highp_u8, aligned_highp_u8, 1);
+
+	/// High qualifier 16 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(highp_u16, aligned_highp_u16, 2);
+
+	/// High qualifier 32 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(highp_u32, aligned_highp_u32, 4);
+
+	/// High qualifier 64 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(highp_u64, aligned_highp_u64, 8);
+
+
+	/// Default qualifier 8 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(uint8, aligned_uint8, 1);
+
+	/// Default qualifier 16 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(uint16, aligned_uint16, 2);
+
+	/// Default qualifier 32 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(uint32, aligned_uint32, 4);
+
+	/// Default qualifier 64 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(uint64, aligned_uint64, 8);
+
+
+	/// Default qualifier 8 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(uint8_t, aligned_uint8_t, 1);
+
+	/// Default qualifier 16 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(uint16_t, aligned_uint16_t, 2);
+
+	/// Default qualifier 32 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(uint32_t, aligned_uint32_t, 4);
+
+	/// Default qualifier 64 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(uint64_t, aligned_uint64_t, 8);
+
+
+	/// Default qualifier 8 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(u8, aligned_u8, 1);
+
+	/// Default qualifier 16 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(u16, aligned_u16, 2);
+
+	/// Default qualifier 32 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(u32, aligned_u32, 4);
+
+	/// Default qualifier 64 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(u64, aligned_u64, 8);
+
+
+	/// Default qualifier 32 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(uvec1, aligned_uvec1, 4);
+
+	/// Default qualifier 32 bit unsigned integer aligned vector of 2 components type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(uvec2, aligned_uvec2, 8);
+
+	/// Default qualifier 32 bit unsigned integer aligned vector of 3 components type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(uvec3, aligned_uvec3, 16);
+
+	/// Default qualifier 32 bit unsigned integer aligned vector of 4 components type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(uvec4, aligned_uvec4, 16);
+
+
+	/// Default qualifier 8 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(u8vec1, aligned_u8vec1, 1);
+
+	/// Default qualifier 8 bit unsigned integer aligned vector of 2 components type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(u8vec2, aligned_u8vec2, 2);
+
+	/// Default qualifier 8 bit unsigned integer aligned vector of 3 components type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(u8vec3, aligned_u8vec3, 4);
+
+	/// Default qualifier 8 bit unsigned integer aligned vector of 4 components type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(u8vec4, aligned_u8vec4, 4);
+
+
+	/// Default qualifier 16 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(u16vec1, aligned_u16vec1, 2);
+
+	/// Default qualifier 16 bit unsigned integer aligned vector of 2 components type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(u16vec2, aligned_u16vec2, 4);
+
+	/// Default qualifier 16 bit unsigned integer aligned vector of 3 components type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(u16vec3, aligned_u16vec3, 8);
+
+	/// Default qualifier 16 bit unsigned integer aligned vector of 4 components type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(u16vec4, aligned_u16vec4, 8);
+
+
+	/// Default qualifier 32 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(u32vec1, aligned_u32vec1, 4);
+
+	/// Default qualifier 32 bit unsigned integer aligned vector of 2 components type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(u32vec2, aligned_u32vec2, 8);
+
+	/// Default qualifier 32 bit unsigned integer aligned vector of 3 components type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(u32vec3, aligned_u32vec3, 16);
+
+	/// Default qualifier 32 bit unsigned integer aligned vector of 4 components type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(u32vec4, aligned_u32vec4, 16);
+
+
+	/// Default qualifier 64 bit unsigned integer aligned scalar type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(u64vec1, aligned_u64vec1, 8);
+
+	/// Default qualifier 64 bit unsigned integer aligned vector of 2 components type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(u64vec2, aligned_u64vec2, 16);
+
+	/// Default qualifier 64 bit unsigned integer aligned vector of 3 components type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(u64vec3, aligned_u64vec3, 32);
+
+	/// Default qualifier 64 bit unsigned integer aligned vector of 4 components type.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(u64vec4, aligned_u64vec4, 32);
+
+
+	//////////////////////
+	// Float vector types
+
+	/// 32 bit single-qualifier floating-point aligned scalar.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(float32, aligned_float32, 4);
+
+	/// 32 bit single-qualifier floating-point aligned scalar.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(float32_t, aligned_float32_t, 4);
+
+	/// 32 bit single-qualifier floating-point aligned scalar.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(float32, aligned_f32, 4);
+
+#	ifndef GLM_FORCE_SINGLE_ONLY
+
+	/// 64 bit double-qualifier floating-point aligned scalar.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(float64, aligned_float64, 8);
+
+	/// 64 bit double-qualifier floating-point aligned scalar.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(float64_t, aligned_float64_t, 8);
+
+	/// 64 bit double-qualifier floating-point aligned scalar.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(float64, aligned_f64, 8);
+
+#	endif//GLM_FORCE_SINGLE_ONLY
+
+
+	/// Single-qualifier floating-point aligned vector of 1 component.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(vec1, aligned_vec1, 4);
+
+	/// Single-qualifier floating-point aligned vector of 2 components.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(vec2, aligned_vec2, 8);
+
+	/// Single-qualifier floating-point aligned vector of 3 components.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(vec3, aligned_vec3, 16);
+
+	/// Single-qualifier floating-point aligned vector of 4 components.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(vec4, aligned_vec4, 16);
+
+
+	/// Single-qualifier floating-point aligned vector of 1 component.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(fvec1, aligned_fvec1, 4);
+
+	/// Single-qualifier floating-point aligned vector of 2 components.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(fvec2, aligned_fvec2, 8);
+
+	/// Single-qualifier floating-point aligned vector of 3 components.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(fvec3, aligned_fvec3, 16);
+
+	/// Single-qualifier floating-point aligned vector of 4 components.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(fvec4, aligned_fvec4, 16);
+
+
+	/// Single-qualifier floating-point aligned vector of 1 component.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f32vec1, aligned_f32vec1, 4);
+
+	/// Single-qualifier floating-point aligned vector of 2 components.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f32vec2, aligned_f32vec2, 8);
+
+	/// Single-qualifier floating-point aligned vector of 3 components.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f32vec3, aligned_f32vec3, 16);
+
+	/// Single-qualifier floating-point aligned vector of 4 components.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f32vec4, aligned_f32vec4, 16);
+
+
+	/// Double-qualifier floating-point aligned vector of 1 component.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(dvec1, aligned_dvec1, 8);
+
+	/// Double-qualifier floating-point aligned vector of 2 components.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(dvec2, aligned_dvec2, 16);
+
+	/// Double-qualifier floating-point aligned vector of 3 components.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(dvec3, aligned_dvec3, 32);
+
+	/// Double-qualifier floating-point aligned vector of 4 components.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(dvec4, aligned_dvec4, 32);
+
+
+#	ifndef GLM_FORCE_SINGLE_ONLY
+
+	/// Double-qualifier floating-point aligned vector of 1 component.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f64vec1, aligned_f64vec1, 8);
+
+	/// Double-qualifier floating-point aligned vector of 2 components.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f64vec2, aligned_f64vec2, 16);
+
+	/// Double-qualifier floating-point aligned vector of 3 components.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f64vec3, aligned_f64vec3, 32);
+
+	/// Double-qualifier floating-point aligned vector of 4 components.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f64vec4, aligned_f64vec4, 32);
+
+#	endif//GLM_FORCE_SINGLE_ONLY
+
+	//////////////////////
+	// Float matrix types
+
+	/// Single-qualifier floating-point aligned 1x1 matrix.
+	/// @see gtx_type_aligned
+	//typedef detail::tmat1<f32> mat1;
+
+	/// Single-qualifier floating-point aligned 2x2 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(mat2, aligned_mat2, 16);
+
+	/// Single-qualifier floating-point aligned 3x3 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(mat3, aligned_mat3, 16);
+
+	/// Single-qualifier floating-point aligned 4x4 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(mat4, aligned_mat4, 16);
+
+
+	/// Single-qualifier floating-point aligned 1x1 matrix.
+	/// @see gtx_type_aligned
+	//typedef detail::tmat1x1<f32> mat1;
+
+	/// Single-qualifier floating-point aligned 2x2 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(mat2x2, aligned_mat2x2, 16);
+
+	/// Single-qualifier floating-point aligned 3x3 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(mat3x3, aligned_mat3x3, 16);
+
+	/// Single-qualifier floating-point aligned 4x4 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(mat4x4, aligned_mat4x4, 16);
+
+
+	/// Single-qualifier floating-point aligned 1x1 matrix.
+	/// @see gtx_type_aligned
+	//typedef detail::tmat1x1<f32> fmat1;
+
+	/// Single-qualifier floating-point aligned 2x2 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(fmat2x2, aligned_fmat2, 16);
+
+	/// Single-qualifier floating-point aligned 3x3 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(fmat3x3, aligned_fmat3, 16);
+
+	/// Single-qualifier floating-point aligned 4x4 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(fmat4x4, aligned_fmat4, 16);
+
+
+	/// Single-qualifier floating-point aligned 1x1 matrix.
+	/// @see gtx_type_aligned
+	//typedef f32 fmat1x1;
+
+	/// Single-qualifier floating-point aligned 2x2 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(fmat2x2, aligned_fmat2x2, 16);
+
+	/// Single-qualifier floating-point aligned 2x3 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(fmat2x3, aligned_fmat2x3, 16);
+
+	/// Single-qualifier floating-point aligned 2x4 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(fmat2x4, aligned_fmat2x4, 16);
+
+	/// Single-qualifier floating-point aligned 3x2 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(fmat3x2, aligned_fmat3x2, 16);
+
+	/// Single-qualifier floating-point aligned 3x3 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(fmat3x3, aligned_fmat3x3, 16);
+
+	/// Single-qualifier floating-point aligned 3x4 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(fmat3x4, aligned_fmat3x4, 16);
+
+	/// Single-qualifier floating-point aligned 4x2 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(fmat4x2, aligned_fmat4x2, 16);
+
+	/// Single-qualifier floating-point aligned 4x3 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(fmat4x3, aligned_fmat4x3, 16);
+
+	/// Single-qualifier floating-point aligned 4x4 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(fmat4x4, aligned_fmat4x4, 16);
+
+
+	/// Single-qualifier floating-point aligned 1x1 matrix.
+	/// @see gtx_type_aligned
+	//typedef detail::tmat1x1<f32, defaultp> f32mat1;
+
+	/// Single-qualifier floating-point aligned 2x2 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f32mat2x2, aligned_f32mat2, 16);
+
+	/// Single-qualifier floating-point aligned 3x3 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f32mat3x3, aligned_f32mat3, 16);
+
+	/// Single-qualifier floating-point aligned 4x4 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f32mat4x4, aligned_f32mat4, 16);
+
+
+	/// Single-qualifier floating-point aligned 1x1 matrix.
+	/// @see gtx_type_aligned
+	//typedef f32 f32mat1x1;
+
+	/// Single-qualifier floating-point aligned 2x2 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f32mat2x2, aligned_f32mat2x2, 16);
+
+	/// Single-qualifier floating-point aligned 2x3 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f32mat2x3, aligned_f32mat2x3, 16);
+
+	/// Single-qualifier floating-point aligned 2x4 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f32mat2x4, aligned_f32mat2x4, 16);
+
+	/// Single-qualifier floating-point aligned 3x2 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f32mat3x2, aligned_f32mat3x2, 16);
+
+	/// Single-qualifier floating-point aligned 3x3 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f32mat3x3, aligned_f32mat3x3, 16);
+
+	/// Single-qualifier floating-point aligned 3x4 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f32mat3x4, aligned_f32mat3x4, 16);
+
+	/// Single-qualifier floating-point aligned 4x2 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f32mat4x2, aligned_f32mat4x2, 16);
+
+	/// Single-qualifier floating-point aligned 4x3 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f32mat4x3, aligned_f32mat4x3, 16);
+
+	/// Single-qualifier floating-point aligned 4x4 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f32mat4x4, aligned_f32mat4x4, 16);
+
+
+#	ifndef GLM_FORCE_SINGLE_ONLY
+
+	/// Double-qualifier floating-point aligned 1x1 matrix.
+	/// @see gtx_type_aligned
+	//typedef detail::tmat1x1<f64, defaultp> f64mat1;
+
+	/// Double-qualifier floating-point aligned 2x2 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f64mat2x2, aligned_f64mat2, 32);
+
+	/// Double-qualifier floating-point aligned 3x3 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f64mat3x3, aligned_f64mat3, 32);
+
+	/// Double-qualifier floating-point aligned 4x4 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f64mat4x4, aligned_f64mat4, 32);
+
+
+	/// Double-qualifier floating-point aligned 1x1 matrix.
+	/// @see gtx_type_aligned
+	//typedef f64 f64mat1x1;
+
+	/// Double-qualifier floating-point aligned 2x2 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f64mat2x2, aligned_f64mat2x2, 32);
+
+	/// Double-qualifier floating-point aligned 2x3 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f64mat2x3, aligned_f64mat2x3, 32);
+
+	/// Double-qualifier floating-point aligned 2x4 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f64mat2x4, aligned_f64mat2x4, 32);
+
+	/// Double-qualifier floating-point aligned 3x2 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f64mat3x2, aligned_f64mat3x2, 32);
+
+	/// Double-qualifier floating-point aligned 3x3 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f64mat3x3, aligned_f64mat3x3, 32);
+
+	/// Double-qualifier floating-point aligned 3x4 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f64mat3x4, aligned_f64mat3x4, 32);
+
+	/// Double-qualifier floating-point aligned 4x2 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f64mat4x2, aligned_f64mat4x2, 32);
+
+	/// Double-qualifier floating-point aligned 4x3 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f64mat4x3, aligned_f64mat4x3, 32);
+
+	/// Double-qualifier floating-point aligned 4x4 matrix.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f64mat4x4, aligned_f64mat4x4, 32);
+
+#	endif//GLM_FORCE_SINGLE_ONLY
+
+
+	//////////////////////////
+	// Quaternion types
+
+	/// Single-qualifier floating-point aligned quaternion.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(quat, aligned_quat, 16);
+
+	/// Single-qualifier floating-point aligned quaternion.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(quat, aligned_fquat, 16);
+
+	/// Double-qualifier floating-point aligned quaternion.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(dquat, aligned_dquat, 32);
+
+	/// Single-qualifier floating-point aligned quaternion.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f32quat, aligned_f32quat, 16);
+
+#	ifndef GLM_FORCE_SINGLE_ONLY
+
+	/// Double-qualifier floating-point aligned quaternion.
+	/// @see gtx_type_aligned
+	GLM_ALIGNED_TYPEDEF(f64quat, aligned_f64quat, 32);
+
+#	endif//GLM_FORCE_SINGLE_ONLY
+
+	/// @}
+}//namespace glm
+
+#include "type_aligned.inl"
diff --git a/engine/inc/glm/gtx/type_aligned.inl b/engine/inc/glm/gtx/type_aligned.inl
new file mode 100644
index 00000000..54c1b818
--- /dev/null
+++ b/engine/inc/glm/gtx/type_aligned.inl
@@ -0,0 +1,6 @@
+/// @ref gtc_type_aligned
+
+namespace glm
+{
+
+}
diff --git a/engine/inc/glm/gtx/type_trait.hpp b/engine/inc/glm/gtx/type_trait.hpp
new file mode 100644
index 00000000..6a7bed6c
--- /dev/null
+++ b/engine/inc/glm/gtx/type_trait.hpp
@@ -0,0 +1,85 @@
+/// @ref gtx_type_trait
+/// @file glm/gtx/type_trait.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_type_trait GLM_GTX_type_trait
+/// @ingroup gtx
+///
+/// Include <glm/gtx/type_trait.hpp> to use the features of this extension.
+///
+/// Defines traits for each type.
+
+#pragma once
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_type_trait is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+// Dependency:
+#include "../detail/qualifier.hpp"
+#include "../gtc/quaternion.hpp"
+#include "../gtx/dual_quaternion.hpp"
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_type_trait extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_type_trait
+	/// @{
+
+	template<typename T>
+	struct type
+	{
+		static bool const is_vec = false;
+		static bool const is_mat = false;
+		static bool const is_quat = false;
+		static length_t const components = 0;
+		static length_t const cols = 0;
+		static length_t const rows = 0;
+	};
+
+	template<length_t L, typename T, qualifier Q>
+	struct type<vec<L, T, Q> >
+	{
+		static bool const is_vec = true;
+		static bool const is_mat = false;
+		static bool const is_quat = false;
+		static length_t const components = L;
+	};
+
+	template<length_t C, length_t R, typename T, qualifier Q>
+	struct type<mat<C, R, T, Q> >
+	{
+		static bool const is_vec = false;
+		static bool const is_mat = true;
+		static bool const is_quat = false;
+		static length_t const components = C;
+		static length_t const cols = C;
+		static length_t const rows = R;
+	};
+
+	template<typename T, qualifier Q>
+	struct type<qua<T, Q> >
+	{
+		static bool const is_vec = false;
+		static bool const is_mat = false;
+		static bool const is_quat = true;
+		static length_t const components = 4;
+	};
+
+	template<typename T, qualifier Q>
+	struct type<tdualquat<T, Q> >
+	{
+		static bool const is_vec = false;
+		static bool const is_mat = false;
+		static bool const is_quat = true;
+		static length_t const components = 8;
+	};
+
+	/// @}
+}//namespace glm
+
+#include "type_trait.inl"
diff --git a/engine/inc/glm/gtx/type_trait.inl b/engine/inc/glm/gtx/type_trait.inl
new file mode 100644
index 00000000..045de959
--- /dev/null
+++ b/engine/inc/glm/gtx/type_trait.inl
@@ -0,0 +1,61 @@
+/// @ref gtx_type_trait
+
+namespace glm
+{
+	template<typename T>
+	bool const type<T>::is_vec;
+	template<typename T>
+	bool const type<T>::is_mat;
+	template<typename T>
+	bool const type<T>::is_quat;
+	template<typename T>
+	length_t const type<T>::components;
+	template<typename T>
+	length_t const type<T>::cols;
+	template<typename T>
+	length_t const type<T>::rows;
+
+	// vec
+	template<length_t L, typename T, qualifier Q>
+	bool const type<vec<L, T, Q> >::is_vec;
+	template<length_t L, typename T, qualifier Q>
+	bool const type<vec<L, T, Q> >::is_mat;
+	template<length_t L, typename T, qualifier Q>
+	bool const type<vec<L, T, Q> >::is_quat;
+	template<length_t L, typename T, qualifier Q>
+	length_t const type<vec<L, T, Q> >::components;
+
+	// mat
+	template<length_t C, length_t R, typename T, qualifier Q>
+	bool const type<mat<C, R, T, Q> >::is_vec;
+	template<length_t C, length_t R, typename T, qualifier Q>
+	bool const type<mat<C, R, T, Q> >::is_mat;
+	template<length_t C, length_t R, typename T, qualifier Q>
+	bool const type<mat<C, R, T, Q> >::is_quat;
+	template<length_t C, length_t R, typename T, qualifier Q>
+	length_t const type<mat<C, R, T, Q> >::components;
+	template<length_t C, length_t R, typename T, qualifier Q>
+	length_t const type<mat<C, R, T, Q> >::cols;
+	template<length_t C, length_t R, typename T, qualifier Q>
+	length_t const type<mat<C, R, T, Q> >::rows;
+
+	// tquat
+	template<typename T, qualifier Q>
+	bool const type<qua<T, Q> >::is_vec;
+	template<typename T, qualifier Q>
+	bool const type<qua<T, Q> >::is_mat;
+	template<typename T, qualifier Q>
+	bool const type<qua<T, Q> >::is_quat;
+	template<typename T, qualifier Q>
+	length_t const type<qua<T, Q> >::components;
+
+	// tdualquat
+	template<typename T, qualifier Q>
+	bool const type<tdualquat<T, Q> >::is_vec;
+	template<typename T, qualifier Q>
+	bool const type<tdualquat<T, Q> >::is_mat;
+	template<typename T, qualifier Q>
+	bool const type<tdualquat<T, Q> >::is_quat;
+	template<typename T, qualifier Q>
+	length_t const type<tdualquat<T, Q> >::components;
+}//namespace glm
diff --git a/engine/inc/glm/gtx/vec_swizzle.hpp b/engine/inc/glm/gtx/vec_swizzle.hpp
new file mode 100644
index 00000000..daebac38
--- /dev/null
+++ b/engine/inc/glm/gtx/vec_swizzle.hpp
@@ -0,0 +1,2778 @@
+/// @ref gtx_vec_swizzle
+/// @file glm/gtx/vec_swizzle.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_vec_swizzle GLM_GTX_vec_swizzle
+/// @ingroup gtx
+///
+/// Include <glm/gtx/vec_swizzle.hpp> to use the features of this extension.
+///
+/// Functions to perform swizzle operation.
+
+#pragma once
+
+#include "../glm.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_vec_swizzle is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+namespace glm {
+	// xx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<2, T, Q> xx(const glm::vec<1, T, Q> &v) {
+		return glm::vec<2, T, Q>(v.x, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<2, T, Q> xx(const glm::vec<2, T, Q> &v) {
+		return glm::vec<2, T, Q>(v.x, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<2, T, Q> xx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<2, T, Q>(v.x, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<2, T, Q> xx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<2, T, Q>(v.x, v.x);
+	}
+
+	// xy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<2, T, Q> xy(const glm::vec<2, T, Q> &v) {
+		return glm::vec<2, T, Q>(v.x, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<2, T, Q> xy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<2, T, Q>(v.x, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<2, T, Q> xy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<2, T, Q>(v.x, v.y);
+	}
+
+	// xz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<2, T, Q> xz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<2, T, Q>(v.x, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<2, T, Q> xz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<2, T, Q>(v.x, v.z);
+	}
+
+	// xw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<2, T, Q> xw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<2, T, Q>(v.x, v.w);
+	}
+
+	// yx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<2, T, Q> yx(const glm::vec<2, T, Q> &v) {
+		return glm::vec<2, T, Q>(v.y, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<2, T, Q> yx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<2, T, Q>(v.y, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<2, T, Q> yx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<2, T, Q>(v.y, v.x);
+	}
+
+	// yy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<2, T, Q> yy(const glm::vec<2, T, Q> &v) {
+		return glm::vec<2, T, Q>(v.y, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<2, T, Q> yy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<2, T, Q>(v.y, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<2, T, Q> yy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<2, T, Q>(v.y, v.y);
+	}
+
+	// yz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<2, T, Q> yz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<2, T, Q>(v.y, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<2, T, Q> yz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<2, T, Q>(v.y, v.z);
+	}
+
+	// yw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<2, T, Q> yw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<2, T, Q>(v.y, v.w);
+	}
+
+	// zx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<2, T, Q> zx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<2, T, Q>(v.z, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<2, T, Q> zx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<2, T, Q>(v.z, v.x);
+	}
+
+	// zy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<2, T, Q> zy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<2, T, Q>(v.z, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<2, T, Q> zy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<2, T, Q>(v.z, v.y);
+	}
+
+	// zz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<2, T, Q> zz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<2, T, Q>(v.z, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<2, T, Q> zz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<2, T, Q>(v.z, v.z);
+	}
+
+	// zw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<2, T, Q> zw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<2, T, Q>(v.z, v.w);
+	}
+
+	// wx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<2, T, Q> wx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<2, T, Q>(v.w, v.x);
+	}
+
+	// wy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<2, T, Q> wy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<2, T, Q>(v.w, v.y);
+	}
+
+	// wz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<2, T, Q> wz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<2, T, Q>(v.w, v.z);
+	}
+
+	// ww
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<2, T, Q> ww(const glm::vec<4, T, Q> &v) {
+		return glm::vec<2, T, Q>(v.w, v.w);
+	}
+
+	// xxx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> xxx(const glm::vec<1, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.x, v.x, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> xxx(const glm::vec<2, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.x, v.x, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> xxx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.x, v.x, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> xxx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.x, v.x, v.x);
+	}
+
+	// xxy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> xxy(const glm::vec<2, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.x, v.x, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> xxy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.x, v.x, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> xxy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.x, v.x, v.y);
+	}
+
+	// xxz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> xxz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.x, v.x, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> xxz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.x, v.x, v.z);
+	}
+
+	// xxw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> xxw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.x, v.x, v.w);
+	}
+
+	// xyx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> xyx(const glm::vec<2, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.x, v.y, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> xyx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.x, v.y, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> xyx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.x, v.y, v.x);
+	}
+
+	// xyy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> xyy(const glm::vec<2, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.x, v.y, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> xyy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.x, v.y, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> xyy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.x, v.y, v.y);
+	}
+
+	// xyz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> xyz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.x, v.y, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> xyz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.x, v.y, v.z);
+	}
+
+	// xyw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> xyw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.x, v.y, v.w);
+	}
+
+	// xzx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> xzx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.x, v.z, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> xzx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.x, v.z, v.x);
+	}
+
+	// xzy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> xzy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.x, v.z, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> xzy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.x, v.z, v.y);
+	}
+
+	// xzz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> xzz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.x, v.z, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> xzz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.x, v.z, v.z);
+	}
+
+	// xzw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> xzw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.x, v.z, v.w);
+	}
+
+	// xwx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> xwx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.x, v.w, v.x);
+	}
+
+	// xwy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> xwy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.x, v.w, v.y);
+	}
+
+	// xwz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> xwz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.x, v.w, v.z);
+	}
+
+	// xww
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> xww(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.x, v.w, v.w);
+	}
+
+	// yxx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> yxx(const glm::vec<2, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.y, v.x, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> yxx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.y, v.x, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> yxx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.y, v.x, v.x);
+	}
+
+	// yxy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> yxy(const glm::vec<2, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.y, v.x, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> yxy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.y, v.x, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> yxy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.y, v.x, v.y);
+	}
+
+	// yxz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> yxz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.y, v.x, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> yxz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.y, v.x, v.z);
+	}
+
+	// yxw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> yxw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.y, v.x, v.w);
+	}
+
+	// yyx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> yyx(const glm::vec<2, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.y, v.y, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> yyx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.y, v.y, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> yyx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.y, v.y, v.x);
+	}
+
+	// yyy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> yyy(const glm::vec<2, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.y, v.y, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> yyy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.y, v.y, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> yyy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.y, v.y, v.y);
+	}
+
+	// yyz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> yyz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.y, v.y, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> yyz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.y, v.y, v.z);
+	}
+
+	// yyw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> yyw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.y, v.y, v.w);
+	}
+
+	// yzx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> yzx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.y, v.z, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> yzx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.y, v.z, v.x);
+	}
+
+	// yzy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> yzy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.y, v.z, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> yzy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.y, v.z, v.y);
+	}
+
+	// yzz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> yzz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.y, v.z, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> yzz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.y, v.z, v.z);
+	}
+
+	// yzw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> yzw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.y, v.z, v.w);
+	}
+
+	// ywx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> ywx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.y, v.w, v.x);
+	}
+
+	// ywy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> ywy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.y, v.w, v.y);
+	}
+
+	// ywz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> ywz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.y, v.w, v.z);
+	}
+
+	// yww
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> yww(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.y, v.w, v.w);
+	}
+
+	// zxx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> zxx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.z, v.x, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> zxx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.z, v.x, v.x);
+	}
+
+	// zxy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> zxy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.z, v.x, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> zxy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.z, v.x, v.y);
+	}
+
+	// zxz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> zxz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.z, v.x, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> zxz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.z, v.x, v.z);
+	}
+
+	// zxw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> zxw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.z, v.x, v.w);
+	}
+
+	// zyx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> zyx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.z, v.y, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> zyx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.z, v.y, v.x);
+	}
+
+	// zyy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> zyy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.z, v.y, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> zyy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.z, v.y, v.y);
+	}
+
+	// zyz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> zyz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.z, v.y, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> zyz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.z, v.y, v.z);
+	}
+
+	// zyw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> zyw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.z, v.y, v.w);
+	}
+
+	// zzx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> zzx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.z, v.z, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> zzx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.z, v.z, v.x);
+	}
+
+	// zzy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> zzy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.z, v.z, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> zzy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.z, v.z, v.y);
+	}
+
+	// zzz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> zzz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.z, v.z, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> zzz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.z, v.z, v.z);
+	}
+
+	// zzw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> zzw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.z, v.z, v.w);
+	}
+
+	// zwx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> zwx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.z, v.w, v.x);
+	}
+
+	// zwy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> zwy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.z, v.w, v.y);
+	}
+
+	// zwz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> zwz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.z, v.w, v.z);
+	}
+
+	// zww
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> zww(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.z, v.w, v.w);
+	}
+
+	// wxx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> wxx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.w, v.x, v.x);
+	}
+
+	// wxy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> wxy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.w, v.x, v.y);
+	}
+
+	// wxz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> wxz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.w, v.x, v.z);
+	}
+
+	// wxw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> wxw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.w, v.x, v.w);
+	}
+
+	// wyx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> wyx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.w, v.y, v.x);
+	}
+
+	// wyy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> wyy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.w, v.y, v.y);
+	}
+
+	// wyz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> wyz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.w, v.y, v.z);
+	}
+
+	// wyw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> wyw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.w, v.y, v.w);
+	}
+
+	// wzx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> wzx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.w, v.z, v.x);
+	}
+
+	// wzy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> wzy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.w, v.z, v.y);
+	}
+
+	// wzz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> wzz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.w, v.z, v.z);
+	}
+
+	// wzw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> wzw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.w, v.z, v.w);
+	}
+
+	// wwx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> wwx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.w, v.w, v.x);
+	}
+
+	// wwy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> wwy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.w, v.w, v.y);
+	}
+
+	// wwz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> wwz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.w, v.w, v.z);
+	}
+
+	// www
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<3, T, Q> www(const glm::vec<4, T, Q> &v) {
+		return glm::vec<3, T, Q>(v.w, v.w, v.w);
+	}
+
+	// xxxx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xxxx(const glm::vec<1, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.x, v.x, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xxxx(const glm::vec<2, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.x, v.x, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xxxx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.x, v.x, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xxxx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.x, v.x, v.x);
+	}
+
+	// xxxy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xxxy(const glm::vec<2, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.x, v.x, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xxxy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.x, v.x, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xxxy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.x, v.x, v.y);
+	}
+
+	// xxxz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xxxz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.x, v.x, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xxxz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.x, v.x, v.z);
+	}
+
+	// xxxw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xxxw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.x, v.x, v.w);
+	}
+
+	// xxyx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xxyx(const glm::vec<2, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.x, v.y, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xxyx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.x, v.y, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xxyx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.x, v.y, v.x);
+	}
+
+	// xxyy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xxyy(const glm::vec<2, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.x, v.y, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xxyy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.x, v.y, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xxyy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.x, v.y, v.y);
+	}
+
+	// xxyz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xxyz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.x, v.y, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xxyz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.x, v.y, v.z);
+	}
+
+	// xxyw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xxyw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.x, v.y, v.w);
+	}
+
+	// xxzx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xxzx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.x, v.z, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xxzx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.x, v.z, v.x);
+	}
+
+	// xxzy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xxzy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.x, v.z, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xxzy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.x, v.z, v.y);
+	}
+
+	// xxzz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xxzz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.x, v.z, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xxzz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.x, v.z, v.z);
+	}
+
+	// xxzw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xxzw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.x, v.z, v.w);
+	}
+
+	// xxwx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xxwx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.x, v.w, v.x);
+	}
+
+	// xxwy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xxwy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.x, v.w, v.y);
+	}
+
+	// xxwz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xxwz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.x, v.w, v.z);
+	}
+
+	// xxww
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xxww(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.x, v.w, v.w);
+	}
+
+	// xyxx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xyxx(const glm::vec<2, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.y, v.x, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xyxx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.y, v.x, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xyxx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.y, v.x, v.x);
+	}
+
+	// xyxy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xyxy(const glm::vec<2, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.y, v.x, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xyxy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.y, v.x, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xyxy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.y, v.x, v.y);
+	}
+
+	// xyxz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xyxz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.y, v.x, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xyxz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.y, v.x, v.z);
+	}
+
+	// xyxw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xyxw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.y, v.x, v.w);
+	}
+
+	// xyyx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xyyx(const glm::vec<2, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.y, v.y, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xyyx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.y, v.y, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xyyx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.y, v.y, v.x);
+	}
+
+	// xyyy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xyyy(const glm::vec<2, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.y, v.y, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xyyy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.y, v.y, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xyyy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.y, v.y, v.y);
+	}
+
+	// xyyz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xyyz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.y, v.y, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xyyz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.y, v.y, v.z);
+	}
+
+	// xyyw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xyyw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.y, v.y, v.w);
+	}
+
+	// xyzx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xyzx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.y, v.z, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xyzx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.y, v.z, v.x);
+	}
+
+	// xyzy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xyzy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.y, v.z, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xyzy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.y, v.z, v.y);
+	}
+
+	// xyzz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xyzz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.y, v.z, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xyzz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.y, v.z, v.z);
+	}
+
+	// xyzw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xyzw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.y, v.z, v.w);
+	}
+
+	// xywx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xywx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.y, v.w, v.x);
+	}
+
+	// xywy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xywy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.y, v.w, v.y);
+	}
+
+	// xywz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xywz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.y, v.w, v.z);
+	}
+
+	// xyww
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xyww(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.y, v.w, v.w);
+	}
+
+	// xzxx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xzxx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.z, v.x, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xzxx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.z, v.x, v.x);
+	}
+
+	// xzxy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xzxy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.z, v.x, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xzxy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.z, v.x, v.y);
+	}
+
+	// xzxz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xzxz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.z, v.x, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xzxz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.z, v.x, v.z);
+	}
+
+	// xzxw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xzxw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.z, v.x, v.w);
+	}
+
+	// xzyx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xzyx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.z, v.y, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xzyx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.z, v.y, v.x);
+	}
+
+	// xzyy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xzyy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.z, v.y, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xzyy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.z, v.y, v.y);
+	}
+
+	// xzyz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xzyz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.z, v.y, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xzyz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.z, v.y, v.z);
+	}
+
+	// xzyw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xzyw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.z, v.y, v.w);
+	}
+
+	// xzzx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xzzx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.z, v.z, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xzzx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.z, v.z, v.x);
+	}
+
+	// xzzy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xzzy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.z, v.z, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xzzy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.z, v.z, v.y);
+	}
+
+	// xzzz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xzzz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.z, v.z, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xzzz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.z, v.z, v.z);
+	}
+
+	// xzzw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xzzw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.z, v.z, v.w);
+	}
+
+	// xzwx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xzwx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.z, v.w, v.x);
+	}
+
+	// xzwy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xzwy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.z, v.w, v.y);
+	}
+
+	// xzwz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xzwz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.z, v.w, v.z);
+	}
+
+	// xzww
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xzww(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.z, v.w, v.w);
+	}
+
+	// xwxx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xwxx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.w, v.x, v.x);
+	}
+
+	// xwxy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xwxy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.w, v.x, v.y);
+	}
+
+	// xwxz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xwxz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.w, v.x, v.z);
+	}
+
+	// xwxw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xwxw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.w, v.x, v.w);
+	}
+
+	// xwyx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xwyx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.w, v.y, v.x);
+	}
+
+	// xwyy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xwyy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.w, v.y, v.y);
+	}
+
+	// xwyz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xwyz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.w, v.y, v.z);
+	}
+
+	// xwyw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xwyw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.w, v.y, v.w);
+	}
+
+	// xwzx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xwzx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.w, v.z, v.x);
+	}
+
+	// xwzy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xwzy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.w, v.z, v.y);
+	}
+
+	// xwzz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xwzz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.w, v.z, v.z);
+	}
+
+	// xwzw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xwzw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.w, v.z, v.w);
+	}
+
+	// xwwx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xwwx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.w, v.w, v.x);
+	}
+
+	// xwwy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xwwy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.w, v.w, v.y);
+	}
+
+	// xwwz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xwwz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.w, v.w, v.z);
+	}
+
+	// xwww
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> xwww(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.x, v.w, v.w, v.w);
+	}
+
+	// yxxx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yxxx(const glm::vec<2, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.x, v.x, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yxxx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.x, v.x, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yxxx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.x, v.x, v.x);
+	}
+
+	// yxxy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yxxy(const glm::vec<2, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.x, v.x, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yxxy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.x, v.x, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yxxy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.x, v.x, v.y);
+	}
+
+	// yxxz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yxxz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.x, v.x, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yxxz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.x, v.x, v.z);
+	}
+
+	// yxxw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yxxw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.x, v.x, v.w);
+	}
+
+	// yxyx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yxyx(const glm::vec<2, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.x, v.y, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yxyx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.x, v.y, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yxyx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.x, v.y, v.x);
+	}
+
+	// yxyy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yxyy(const glm::vec<2, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.x, v.y, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yxyy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.x, v.y, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yxyy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.x, v.y, v.y);
+	}
+
+	// yxyz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yxyz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.x, v.y, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yxyz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.x, v.y, v.z);
+	}
+
+	// yxyw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yxyw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.x, v.y, v.w);
+	}
+
+	// yxzx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yxzx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.x, v.z, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yxzx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.x, v.z, v.x);
+	}
+
+	// yxzy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yxzy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.x, v.z, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yxzy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.x, v.z, v.y);
+	}
+
+	// yxzz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yxzz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.x, v.z, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yxzz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.x, v.z, v.z);
+	}
+
+	// yxzw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yxzw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.x, v.z, v.w);
+	}
+
+	// yxwx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yxwx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.x, v.w, v.x);
+	}
+
+	// yxwy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yxwy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.x, v.w, v.y);
+	}
+
+	// yxwz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yxwz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.x, v.w, v.z);
+	}
+
+	// yxww
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yxww(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.x, v.w, v.w);
+	}
+
+	// yyxx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yyxx(const glm::vec<2, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.y, v.x, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yyxx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.y, v.x, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yyxx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.y, v.x, v.x);
+	}
+
+	// yyxy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yyxy(const glm::vec<2, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.y, v.x, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yyxy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.y, v.x, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yyxy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.y, v.x, v.y);
+	}
+
+	// yyxz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yyxz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.y, v.x, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yyxz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.y, v.x, v.z);
+	}
+
+	// yyxw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yyxw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.y, v.x, v.w);
+	}
+
+	// yyyx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yyyx(const glm::vec<2, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.y, v.y, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yyyx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.y, v.y, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yyyx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.y, v.y, v.x);
+	}
+
+	// yyyy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yyyy(const glm::vec<2, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.y, v.y, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yyyy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.y, v.y, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yyyy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.y, v.y, v.y);
+	}
+
+	// yyyz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yyyz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.y, v.y, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yyyz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.y, v.y, v.z);
+	}
+
+	// yyyw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yyyw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.y, v.y, v.w);
+	}
+
+	// yyzx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yyzx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.y, v.z, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yyzx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.y, v.z, v.x);
+	}
+
+	// yyzy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yyzy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.y, v.z, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yyzy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.y, v.z, v.y);
+	}
+
+	// yyzz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yyzz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.y, v.z, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yyzz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.y, v.z, v.z);
+	}
+
+	// yyzw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yyzw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.y, v.z, v.w);
+	}
+
+	// yywx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yywx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.y, v.w, v.x);
+	}
+
+	// yywy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yywy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.y, v.w, v.y);
+	}
+
+	// yywz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yywz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.y, v.w, v.z);
+	}
+
+	// yyww
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yyww(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.y, v.w, v.w);
+	}
+
+	// yzxx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yzxx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.z, v.x, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yzxx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.z, v.x, v.x);
+	}
+
+	// yzxy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yzxy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.z, v.x, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yzxy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.z, v.x, v.y);
+	}
+
+	// yzxz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yzxz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.z, v.x, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yzxz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.z, v.x, v.z);
+	}
+
+	// yzxw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yzxw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.z, v.x, v.w);
+	}
+
+	// yzyx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yzyx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.z, v.y, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yzyx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.z, v.y, v.x);
+	}
+
+	// yzyy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yzyy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.z, v.y, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yzyy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.z, v.y, v.y);
+	}
+
+	// yzyz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yzyz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.z, v.y, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yzyz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.z, v.y, v.z);
+	}
+
+	// yzyw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yzyw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.z, v.y, v.w);
+	}
+
+	// yzzx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yzzx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.z, v.z, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yzzx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.z, v.z, v.x);
+	}
+
+	// yzzy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yzzy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.z, v.z, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yzzy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.z, v.z, v.y);
+	}
+
+	// yzzz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yzzz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.z, v.z, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yzzz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.z, v.z, v.z);
+	}
+
+	// yzzw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yzzw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.z, v.z, v.w);
+	}
+
+	// yzwx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yzwx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.z, v.w, v.x);
+	}
+
+	// yzwy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yzwy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.z, v.w, v.y);
+	}
+
+	// yzwz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yzwz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.z, v.w, v.z);
+	}
+
+	// yzww
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> yzww(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.z, v.w, v.w);
+	}
+
+	// ywxx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> ywxx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.w, v.x, v.x);
+	}
+
+	// ywxy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> ywxy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.w, v.x, v.y);
+	}
+
+	// ywxz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> ywxz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.w, v.x, v.z);
+	}
+
+	// ywxw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> ywxw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.w, v.x, v.w);
+	}
+
+	// ywyx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> ywyx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.w, v.y, v.x);
+	}
+
+	// ywyy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> ywyy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.w, v.y, v.y);
+	}
+
+	// ywyz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> ywyz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.w, v.y, v.z);
+	}
+
+	// ywyw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> ywyw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.w, v.y, v.w);
+	}
+
+	// ywzx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> ywzx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.w, v.z, v.x);
+	}
+
+	// ywzy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> ywzy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.w, v.z, v.y);
+	}
+
+	// ywzz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> ywzz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.w, v.z, v.z);
+	}
+
+	// ywzw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> ywzw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.w, v.z, v.w);
+	}
+
+	// ywwx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> ywwx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.w, v.w, v.x);
+	}
+
+	// ywwy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> ywwy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.w, v.w, v.y);
+	}
+
+	// ywwz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> ywwz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.w, v.w, v.z);
+	}
+
+	// ywww
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> ywww(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.y, v.w, v.w, v.w);
+	}
+
+	// zxxx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zxxx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.x, v.x, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zxxx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.x, v.x, v.x);
+	}
+
+	// zxxy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zxxy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.x, v.x, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zxxy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.x, v.x, v.y);
+	}
+
+	// zxxz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zxxz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.x, v.x, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zxxz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.x, v.x, v.z);
+	}
+
+	// zxxw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zxxw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.x, v.x, v.w);
+	}
+
+	// zxyx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zxyx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.x, v.y, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zxyx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.x, v.y, v.x);
+	}
+
+	// zxyy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zxyy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.x, v.y, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zxyy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.x, v.y, v.y);
+	}
+
+	// zxyz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zxyz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.x, v.y, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zxyz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.x, v.y, v.z);
+	}
+
+	// zxyw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zxyw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.x, v.y, v.w);
+	}
+
+	// zxzx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zxzx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.x, v.z, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zxzx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.x, v.z, v.x);
+	}
+
+	// zxzy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zxzy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.x, v.z, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zxzy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.x, v.z, v.y);
+	}
+
+	// zxzz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zxzz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.x, v.z, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zxzz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.x, v.z, v.z);
+	}
+
+	// zxzw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zxzw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.x, v.z, v.w);
+	}
+
+	// zxwx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zxwx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.x, v.w, v.x);
+	}
+
+	// zxwy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zxwy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.x, v.w, v.y);
+	}
+
+	// zxwz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zxwz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.x, v.w, v.z);
+	}
+
+	// zxww
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zxww(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.x, v.w, v.w);
+	}
+
+	// zyxx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zyxx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.y, v.x, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zyxx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.y, v.x, v.x);
+	}
+
+	// zyxy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zyxy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.y, v.x, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zyxy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.y, v.x, v.y);
+	}
+
+	// zyxz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zyxz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.y, v.x, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zyxz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.y, v.x, v.z);
+	}
+
+	// zyxw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zyxw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.y, v.x, v.w);
+	}
+
+	// zyyx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zyyx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.y, v.y, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zyyx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.y, v.y, v.x);
+	}
+
+	// zyyy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zyyy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.y, v.y, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zyyy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.y, v.y, v.y);
+	}
+
+	// zyyz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zyyz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.y, v.y, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zyyz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.y, v.y, v.z);
+	}
+
+	// zyyw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zyyw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.y, v.y, v.w);
+	}
+
+	// zyzx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zyzx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.y, v.z, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zyzx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.y, v.z, v.x);
+	}
+
+	// zyzy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zyzy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.y, v.z, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zyzy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.y, v.z, v.y);
+	}
+
+	// zyzz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zyzz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.y, v.z, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zyzz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.y, v.z, v.z);
+	}
+
+	// zyzw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zyzw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.y, v.z, v.w);
+	}
+
+	// zywx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zywx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.y, v.w, v.x);
+	}
+
+	// zywy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zywy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.y, v.w, v.y);
+	}
+
+	// zywz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zywz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.y, v.w, v.z);
+	}
+
+	// zyww
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zyww(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.y, v.w, v.w);
+	}
+
+	// zzxx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zzxx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.z, v.x, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zzxx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.z, v.x, v.x);
+	}
+
+	// zzxy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zzxy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.z, v.x, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zzxy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.z, v.x, v.y);
+	}
+
+	// zzxz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zzxz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.z, v.x, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zzxz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.z, v.x, v.z);
+	}
+
+	// zzxw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zzxw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.z, v.x, v.w);
+	}
+
+	// zzyx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zzyx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.z, v.y, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zzyx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.z, v.y, v.x);
+	}
+
+	// zzyy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zzyy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.z, v.y, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zzyy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.z, v.y, v.y);
+	}
+
+	// zzyz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zzyz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.z, v.y, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zzyz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.z, v.y, v.z);
+	}
+
+	// zzyw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zzyw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.z, v.y, v.w);
+	}
+
+	// zzzx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zzzx(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.z, v.z, v.x);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zzzx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.z, v.z, v.x);
+	}
+
+	// zzzy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zzzy(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.z, v.z, v.y);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zzzy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.z, v.z, v.y);
+	}
+
+	// zzzz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zzzz(const glm::vec<3, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.z, v.z, v.z);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zzzz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.z, v.z, v.z);
+	}
+
+	// zzzw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zzzw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.z, v.z, v.w);
+	}
+
+	// zzwx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zzwx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.z, v.w, v.x);
+	}
+
+	// zzwy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zzwy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.z, v.w, v.y);
+	}
+
+	// zzwz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zzwz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.z, v.w, v.z);
+	}
+
+	// zzww
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zzww(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.z, v.w, v.w);
+	}
+
+	// zwxx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zwxx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.w, v.x, v.x);
+	}
+
+	// zwxy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zwxy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.w, v.x, v.y);
+	}
+
+	// zwxz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zwxz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.w, v.x, v.z);
+	}
+
+	// zwxw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zwxw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.w, v.x, v.w);
+	}
+
+	// zwyx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zwyx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.w, v.y, v.x);
+	}
+
+	// zwyy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zwyy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.w, v.y, v.y);
+	}
+
+	// zwyz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zwyz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.w, v.y, v.z);
+	}
+
+	// zwyw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zwyw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.w, v.y, v.w);
+	}
+
+	// zwzx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zwzx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.w, v.z, v.x);
+	}
+
+	// zwzy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zwzy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.w, v.z, v.y);
+	}
+
+	// zwzz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zwzz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.w, v.z, v.z);
+	}
+
+	// zwzw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zwzw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.w, v.z, v.w);
+	}
+
+	// zwwx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zwwx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.w, v.w, v.x);
+	}
+
+	// zwwy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zwwy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.w, v.w, v.y);
+	}
+
+	// zwwz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zwwz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.w, v.w, v.z);
+	}
+
+	// zwww
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> zwww(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.z, v.w, v.w, v.w);
+	}
+
+	// wxxx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wxxx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.x, v.x, v.x);
+	}
+
+	// wxxy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wxxy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.x, v.x, v.y);
+	}
+
+	// wxxz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wxxz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.x, v.x, v.z);
+	}
+
+	// wxxw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wxxw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.x, v.x, v.w);
+	}
+
+	// wxyx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wxyx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.x, v.y, v.x);
+	}
+
+	// wxyy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wxyy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.x, v.y, v.y);
+	}
+
+	// wxyz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wxyz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.x, v.y, v.z);
+	}
+
+	// wxyw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wxyw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.x, v.y, v.w);
+	}
+
+	// wxzx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wxzx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.x, v.z, v.x);
+	}
+
+	// wxzy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wxzy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.x, v.z, v.y);
+	}
+
+	// wxzz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wxzz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.x, v.z, v.z);
+	}
+
+	// wxzw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wxzw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.x, v.z, v.w);
+	}
+
+	// wxwx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wxwx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.x, v.w, v.x);
+	}
+
+	// wxwy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wxwy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.x, v.w, v.y);
+	}
+
+	// wxwz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wxwz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.x, v.w, v.z);
+	}
+
+	// wxww
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wxww(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.x, v.w, v.w);
+	}
+
+	// wyxx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wyxx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.y, v.x, v.x);
+	}
+
+	// wyxy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wyxy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.y, v.x, v.y);
+	}
+
+	// wyxz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wyxz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.y, v.x, v.z);
+	}
+
+	// wyxw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wyxw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.y, v.x, v.w);
+	}
+
+	// wyyx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wyyx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.y, v.y, v.x);
+	}
+
+	// wyyy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wyyy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.y, v.y, v.y);
+	}
+
+	// wyyz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wyyz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.y, v.y, v.z);
+	}
+
+	// wyyw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wyyw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.y, v.y, v.w);
+	}
+
+	// wyzx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wyzx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.y, v.z, v.x);
+	}
+
+	// wyzy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wyzy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.y, v.z, v.y);
+	}
+
+	// wyzz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wyzz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.y, v.z, v.z);
+	}
+
+	// wyzw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wyzw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.y, v.z, v.w);
+	}
+
+	// wywx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wywx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.y, v.w, v.x);
+	}
+
+	// wywy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wywy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.y, v.w, v.y);
+	}
+
+	// wywz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wywz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.y, v.w, v.z);
+	}
+
+	// wyww
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wyww(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.y, v.w, v.w);
+	}
+
+	// wzxx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wzxx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.z, v.x, v.x);
+	}
+
+	// wzxy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wzxy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.z, v.x, v.y);
+	}
+
+	// wzxz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wzxz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.z, v.x, v.z);
+	}
+
+	// wzxw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wzxw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.z, v.x, v.w);
+	}
+
+	// wzyx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wzyx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.z, v.y, v.x);
+	}
+
+	// wzyy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wzyy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.z, v.y, v.y);
+	}
+
+	// wzyz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wzyz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.z, v.y, v.z);
+	}
+
+	// wzyw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wzyw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.z, v.y, v.w);
+	}
+
+	// wzzx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wzzx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.z, v.z, v.x);
+	}
+
+	// wzzy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wzzy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.z, v.z, v.y);
+	}
+
+	// wzzz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wzzz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.z, v.z, v.z);
+	}
+
+	// wzzw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wzzw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.z, v.z, v.w);
+	}
+
+	// wzwx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wzwx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.z, v.w, v.x);
+	}
+
+	// wzwy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wzwy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.z, v.w, v.y);
+	}
+
+	// wzwz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wzwz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.z, v.w, v.z);
+	}
+
+	// wzww
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wzww(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.z, v.w, v.w);
+	}
+
+	// wwxx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wwxx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.w, v.x, v.x);
+	}
+
+	// wwxy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wwxy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.w, v.x, v.y);
+	}
+
+	// wwxz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wwxz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.w, v.x, v.z);
+	}
+
+	// wwxw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wwxw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.w, v.x, v.w);
+	}
+
+	// wwyx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wwyx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.w, v.y, v.x);
+	}
+
+	// wwyy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wwyy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.w, v.y, v.y);
+	}
+
+	// wwyz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wwyz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.w, v.y, v.z);
+	}
+
+	// wwyw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wwyw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.w, v.y, v.w);
+	}
+
+	// wwzx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wwzx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.w, v.z, v.x);
+	}
+
+	// wwzy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wwzy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.w, v.z, v.y);
+	}
+
+	// wwzz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wwzz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.w, v.z, v.z);
+	}
+
+	// wwzw
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wwzw(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.w, v.z, v.w);
+	}
+
+	// wwwx
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wwwx(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.w, v.w, v.x);
+	}
+
+	// wwwy
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wwwy(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.w, v.w, v.y);
+	}
+
+	// wwwz
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wwwz(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.w, v.w, v.z);
+	}
+
+	// wwww
+	template<typename T, qualifier Q>
+	GLM_INLINE glm::vec<4, T, Q> wwww(const glm::vec<4, T, Q> &v) {
+		return glm::vec<4, T, Q>(v.w, v.w, v.w, v.w);
+	}
+
+}
diff --git a/engine/inc/glm/gtx/vector_angle.hpp b/engine/inc/glm/gtx/vector_angle.hpp
new file mode 100644
index 00000000..c3660ca4
--- /dev/null
+++ b/engine/inc/glm/gtx/vector_angle.hpp
@@ -0,0 +1,57 @@
+/// @ref gtx_vector_angle
+/// @file glm/gtx/vector_angle.hpp
+///
+/// @see core (dependence)
+/// @see gtx_quaternion (dependence)
+/// @see gtx_epsilon (dependence)
+///
+/// @defgroup gtx_vector_angle GLM_GTX_vector_angle
+/// @ingroup gtx
+///
+/// Include <glm/gtx/vector_angle.hpp> to use the features of this extension.
+///
+/// Compute angle between vectors
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtc/epsilon.hpp"
+#include "../gtx/quaternion.hpp"
+#include "../gtx/rotate_vector.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_vector_angle is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_vector_angle extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_vector_angle
+	/// @{
+
+	//! Returns the absolute angle between two vectors.
+	//! Parameters need to be normalized.
+	/// @see gtx_vector_angle extension.
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL T angle(vec<L, T, Q> const& x, vec<L, T, Q> const& y);
+
+	//! Returns the oriented angle between two 2d vectors.
+	//! Parameters need to be normalized.
+	/// @see gtx_vector_angle extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL T orientedAngle(vec<2, T, Q> const& x, vec<2, T, Q> const& y);
+
+	//! Returns the oriented angle between two 3d vectors based from a reference axis.
+	//! Parameters need to be normalized.
+	/// @see gtx_vector_angle extension.
+	template<typename T, qualifier Q>
+	GLM_FUNC_DECL T orientedAngle(vec<3, T, Q> const& x, vec<3, T, Q> const& y, vec<3, T, Q> const& ref);
+
+	/// @}
+}// namespace glm
+
+#include "vector_angle.inl"
diff --git a/engine/inc/glm/gtx/vector_angle.inl b/engine/inc/glm/gtx/vector_angle.inl
new file mode 100644
index 00000000..a1f957a5
--- /dev/null
+++ b/engine/inc/glm/gtx/vector_angle.inl
@@ -0,0 +1,44 @@
+/// @ref gtx_vector_angle
+
+namespace glm
+{
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType angle
+	(
+		genType const& x,
+		genType const& y
+	)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'angle' only accept floating-point inputs");
+		return acos(clamp(dot(x, y), genType(-1), genType(1)));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T angle(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'angle' only accept floating-point inputs");
+		return acos(clamp(dot(x, y), T(-1), T(1)));
+	}
+
+	//! \todo epsilon is hard coded to 0.01
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T orientedAngle(vec<2, T, Q> const& x, vec<2, T, Q> const& y)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'orientedAngle' only accept floating-point inputs");
+		T const Angle(acos(clamp(dot(x, y), T(-1), T(1))));
+
+		if(all(epsilonEqual(y, glm::rotate(x, Angle), T(0.0001))))
+			return Angle;
+		else
+			return -Angle;
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER T orientedAngle(vec<3, T, Q> const& x, vec<3, T, Q> const& y, vec<3, T, Q> const& ref)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'orientedAngle' only accept floating-point inputs");
+
+		T const Angle(acos(clamp(dot(x, y), T(-1), T(1))));
+		return mix(Angle, -Angle, dot(ref, cross(x, y)) < T(0));
+	}
+}//namespace glm
diff --git a/engine/inc/glm/gtx/vector_query.hpp b/engine/inc/glm/gtx/vector_query.hpp
new file mode 100644
index 00000000..7d663d74
--- /dev/null
+++ b/engine/inc/glm/gtx/vector_query.hpp
@@ -0,0 +1,66 @@
+/// @ref gtx_vector_query
+/// @file glm/gtx/vector_query.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_vector_query GLM_GTX_vector_query
+/// @ingroup gtx
+///
+/// Include <glm/gtx/vector_query.hpp> to use the features of this extension.
+///
+/// Query informations of vector types
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+#include <cfloat>
+#include <limits>
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_vector_query is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_vector_query extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_vector_query
+	/// @{
+
+	//! Check whether two vectors are collinears.
+	/// @see gtx_vector_query extensions.
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL bool areCollinear(vec<L, T, Q> const& v0, vec<L, T, Q> const& v1, T const& epsilon);
+
+	//! Check whether two vectors are orthogonals.
+	/// @see gtx_vector_query extensions.
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL bool areOrthogonal(vec<L, T, Q> const& v0, vec<L, T, Q> const& v1, T const& epsilon);
+
+	//! Check whether a vector is normalized.
+	/// @see gtx_vector_query extensions.
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL bool isNormalized(vec<L, T, Q> const& v, T const& epsilon);
+
+	//! Check whether a vector is null.
+	/// @see gtx_vector_query extensions.
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL bool isNull(vec<L, T, Q> const& v, T const& epsilon);
+
+	//! Check whether a each component of a vector is null.
+	/// @see gtx_vector_query extensions.
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, bool, Q> isCompNull(vec<L, T, Q> const& v, T const& epsilon);
+
+	//! Check whether two vectors are orthonormal.
+	/// @see gtx_vector_query extensions.
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL bool areOrthonormal(vec<L, T, Q> const& v0, vec<L, T, Q> const& v1, T const& epsilon);
+
+	/// @}
+}// namespace glm
+
+#include "vector_query.inl"
diff --git a/engine/inc/glm/gtx/vector_query.inl b/engine/inc/glm/gtx/vector_query.inl
new file mode 100644
index 00000000..d1a5c9be
--- /dev/null
+++ b/engine/inc/glm/gtx/vector_query.inl
@@ -0,0 +1,154 @@
+/// @ref gtx_vector_query
+
+#include <cassert>
+
+namespace glm{
+namespace detail
+{
+	template<length_t L, typename T, qualifier Q>
+	struct compute_areCollinear{};
+
+	template<typename T, qualifier Q>
+	struct compute_areCollinear<2, T, Q>
+	{
+		GLM_FUNC_QUALIFIER static bool call(vec<2, T, Q> const& v0, vec<2, T, Q> const& v1, T const& epsilon)
+		{
+			return length(cross(vec<3, T, Q>(v0, static_cast<T>(0)), vec<3, T, Q>(v1, static_cast<T>(0)))) < epsilon;
+		}
+	};
+
+	template<typename T, qualifier Q>
+	struct compute_areCollinear<3, T, Q>
+	{
+		GLM_FUNC_QUALIFIER static bool call(vec<3, T, Q> const& v0, vec<3, T, Q> const& v1, T const& epsilon)
+		{
+			return length(cross(v0, v1)) < epsilon;
+		}
+	};
+
+	template<typename T, qualifier Q>
+	struct compute_areCollinear<4, T, Q>
+	{
+		GLM_FUNC_QUALIFIER static bool call(vec<4, T, Q> const& v0, vec<4, T, Q> const& v1, T const& epsilon)
+		{
+			return length(cross(vec<3, T, Q>(v0), vec<3, T, Q>(v1))) < epsilon;
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q>
+	struct compute_isCompNull{};
+
+	template<typename T, qualifier Q>
+	struct compute_isCompNull<2, T, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<2, bool, Q> call(vec<2, T, Q> const& v, T const& epsilon)
+		{
+			return vec<2, bool, Q>(
+				(abs(v.x) < epsilon),
+				(abs(v.y) < epsilon));
+		}
+	};
+
+	template<typename T, qualifier Q>
+	struct compute_isCompNull<3, T, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<3, bool, Q> call(vec<3, T, Q> const& v, T const& epsilon)
+		{
+			return vec<3, bool, Q>(
+				(abs(v.x) < epsilon),
+				(abs(v.y) < epsilon),
+				(abs(v.z) < epsilon));
+		}
+	};
+
+	template<typename T, qualifier Q>
+	struct compute_isCompNull<4, T, Q>
+	{
+		GLM_FUNC_QUALIFIER static vec<4, bool, Q> call(vec<4, T, Q> const& v, T const& epsilon)
+		{
+			return vec<4, bool, Q>(
+				(abs(v.x) < epsilon),
+				(abs(v.y) < epsilon),
+				(abs(v.z) < epsilon),
+				(abs(v.w) < epsilon));
+		}
+	};
+
+}//namespace detail
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool areCollinear(vec<L, T, Q> const& v0, vec<L, T, Q> const& v1, T const& epsilon)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'areCollinear' only accept floating-point inputs");
+
+		return detail::compute_areCollinear<L, T, Q>::call(v0, v1, epsilon);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool areOrthogonal(vec<L, T, Q> const& v0, vec<L, T, Q> const& v1, T const& epsilon)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'areOrthogonal' only accept floating-point inputs");
+
+		return abs(dot(v0, v1)) <= max(
+			static_cast<T>(1),
+			length(v0)) * max(static_cast<T>(1), length(v1)) * epsilon;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool isNormalized(vec<L, T, Q> const& v, T const& epsilon)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isNormalized' only accept floating-point inputs");
+
+		return abs(length(v) - static_cast<T>(1)) <= static_cast<T>(2) * epsilon;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool isNull(vec<L, T, Q> const& v, T const& epsilon)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isNull' only accept floating-point inputs");
+
+		return length(v) <= epsilon;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, bool, Q> isCompNull(vec<L, T, Q> const& v, T const& epsilon)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isCompNull' only accept floating-point inputs");
+
+		return detail::compute_isCompNull<L, T, Q>::call(v, epsilon);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<2, bool, Q> isCompNull(vec<2, T, Q> const& v, T const& epsilon)
+	{
+		return vec<2, bool, Q>(
+			abs(v.x) < epsilon,
+			abs(v.y) < epsilon);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, bool, Q> isCompNull(vec<3, T, Q> const& v, T const& epsilon)
+	{
+		return vec<3, bool, Q>(
+			abs(v.x) < epsilon,
+			abs(v.y) < epsilon,
+			abs(v.z) < epsilon);
+	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<4, bool, Q> isCompNull(vec<4, T, Q> const& v, T const& epsilon)
+	{
+		return vec<4, bool, Q>(
+			abs(v.x) < epsilon,
+			abs(v.y) < epsilon,
+			abs(v.z) < epsilon,
+			abs(v.w) < epsilon);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER bool areOrthonormal(vec<L, T, Q> const& v0, vec<L, T, Q> const& v1, T const& epsilon)
+	{
+		return isNormalized(v0, epsilon) && isNormalized(v1, epsilon) && (abs(dot(v0, v1)) <= epsilon);
+	}
+
+}//namespace glm
diff --git a/engine/inc/glm/gtx/wrap.hpp b/engine/inc/glm/gtx/wrap.hpp
new file mode 100644
index 00000000..ecd0f048
--- /dev/null
+++ b/engine/inc/glm/gtx/wrap.hpp
@@ -0,0 +1,55 @@
+/// @ref gtx_wrap
+/// @file glm/gtx/wrap.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_wrap GLM_GTX_wrap
+/// @ingroup gtx
+///
+/// Include <glm/gtx/wrap.hpp> to use the features of this extension.
+///
+/// Wrapping mode of texture coordinates.
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtc/vec1.hpp"
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#	error "GLM: GLM_GTX_wrap is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
+#endif
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_wrap extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_wrap
+	/// @{
+
+	/// Simulate GL_CLAMP OpenGL wrap mode
+	/// @see gtx_wrap extension.
+	template<typename genType>
+	GLM_FUNC_DECL genType clamp(genType const& Texcoord);
+
+	/// Simulate GL_REPEAT OpenGL wrap mode
+	/// @see gtx_wrap extension.
+	template<typename genType>
+	GLM_FUNC_DECL genType repeat(genType const& Texcoord);
+
+	/// Simulate GL_MIRRORED_REPEAT OpenGL wrap mode
+	/// @see gtx_wrap extension.
+	template<typename genType>
+	GLM_FUNC_DECL genType mirrorClamp(genType const& Texcoord);
+
+	/// Simulate GL_MIRROR_REPEAT OpenGL wrap mode
+	/// @see gtx_wrap extension.
+	template<typename genType>
+	GLM_FUNC_DECL genType mirrorRepeat(genType const& Texcoord);
+
+	/// @}
+}// namespace glm
+
+#include "wrap.inl"
diff --git a/engine/inc/glm/gtx/wrap.inl b/engine/inc/glm/gtx/wrap.inl
new file mode 100644
index 00000000..409a316a
--- /dev/null
+++ b/engine/inc/glm/gtx/wrap.inl
@@ -0,0 +1,57 @@
+/// @ref gtx_wrap
+
+namespace glm
+{
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> clamp(vec<L, T, Q> const& Texcoord)
+	{
+		return glm::clamp(Texcoord, vec<L, T, Q>(0), vec<L, T, Q>(1));
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType clamp(genType const& Texcoord)
+	{
+		return clamp(vec<1, genType, defaultp>(Texcoord)).x;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> repeat(vec<L, T, Q> const& Texcoord)
+	{
+		return glm::fract(Texcoord);
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType repeat(genType const& Texcoord)
+	{
+		return repeat(vec<1, genType, defaultp>(Texcoord)).x;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> mirrorClamp(vec<L, T, Q> const& Texcoord)
+	{
+		return glm::fract(glm::abs(Texcoord));
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType mirrorClamp(genType const& Texcoord)
+	{
+		return mirrorClamp(vec<1, genType, defaultp>(Texcoord)).x;
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> mirrorRepeat(vec<L, T, Q> const& Texcoord)
+	{
+		vec<L, T, Q> const Abs = glm::abs(Texcoord);
+		vec<L, T, Q> const Clamp = glm::mod(glm::floor(Abs), vec<L, T, Q>(2));
+		vec<L, T, Q> const Floor = glm::floor(Abs);
+		vec<L, T, Q> const Rest = Abs - Floor;
+		vec<L, T, Q> const Mirror = Clamp + Rest;
+		return mix(Rest, vec<L, T, Q>(1) - Rest, glm::greaterThanEqual(Mirror, vec<L, T, Q>(1)));
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType mirrorRepeat(genType const& Texcoord)
+	{
+		return mirrorRepeat(vec<1, genType, defaultp>(Texcoord)).x;
+	}
+}//namespace glm
diff --git a/engine/inc/glm/integer.hpp b/engine/inc/glm/integer.hpp
new file mode 100644
index 00000000..8817db3f
--- /dev/null
+++ b/engine/inc/glm/integer.hpp
@@ -0,0 +1,212 @@
+/// @ref core
+/// @file glm/integer.hpp
+///
+/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+///
+/// @defgroup core_func_integer Integer functions
+/// @ingroup core
+///
+/// Provides GLSL functions on integer types
+///
+/// These all operate component-wise. The description is per component.
+/// The notation [a, b] means the set of bits from bit-number a through bit-number
+/// b, inclusive. The lowest-order bit is bit 0.
+///
+/// Include <glm/integer.hpp> to use these core features.
+
+#pragma once
+
+#include "detail/qualifier.hpp"
+#include "common.hpp"
+#include "vector_relational.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_func_integer
+	/// @{
+
+	/// Adds 32-bit unsigned integer x and y, returning the sum
+	/// modulo pow(2, 32). The value carry is set to 0 if the sum was
+	/// less than pow(2, 32), or to 1 otherwise.
+	///
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uaddCarry.xml">GLSL uaddCarry man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template<length_t L, qualifier Q>
+	GLM_FUNC_DECL vec<L, uint, Q> uaddCarry(
+		vec<L, uint, Q> const& x,
+		vec<L, uint, Q> const& y,
+		vec<L, uint, Q> & carry);
+
+	/// Subtracts the 32-bit unsigned integer y from x, returning
+	/// the difference if non-negative, or pow(2, 32) plus the difference
+	/// otherwise. The value borrow is set to 0 if x >= y, or to 1 otherwise.
+	///
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/usubBorrow.xml">GLSL usubBorrow man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template<length_t L, qualifier Q>
+	GLM_FUNC_DECL vec<L, uint, Q> usubBorrow(
+		vec<L, uint, Q> const& x,
+		vec<L, uint, Q> const& y,
+		vec<L, uint, Q> & borrow);
+
+	/// Multiplies 32-bit integers x and y, producing a 64-bit
+	/// result. The 32 least-significant bits are returned in lsb.
+	/// The 32 most-significant bits are returned in msb.
+	///
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/umulExtended.xml">GLSL umulExtended man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template<length_t L, qualifier Q>
+	GLM_FUNC_DECL void umulExtended(
+		vec<L, uint, Q> const& x,
+		vec<L, uint, Q> const& y,
+		vec<L, uint, Q> & msb,
+		vec<L, uint, Q> & lsb);
+
+	/// Multiplies 32-bit integers x and y, producing a 64-bit
+	/// result. The 32 least-significant bits are returned in lsb.
+	/// The 32 most-significant bits are returned in msb.
+	///
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/imulExtended.xml">GLSL imulExtended man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template<length_t L, qualifier Q>
+	GLM_FUNC_DECL void imulExtended(
+		vec<L, int, Q> const& x,
+		vec<L, int, Q> const& y,
+		vec<L, int, Q> & msb,
+		vec<L, int, Q> & lsb);
+
+	/// Extracts bits [offset, offset + bits - 1] from value,
+	/// returning them in the least significant bits of the result.
+	/// For unsigned data types, the most significant bits of the
+	/// result will be set to zero. For signed data types, the
+	/// most significant bits will be set to the value of bit offset + base - 1.
+	///
+	/// If bits is zero, the result will be zero. The result will be
+	/// undefined if offset or bits is negative, or if the sum of
+	/// offset and bits is greater than the number of bits used
+	/// to store the operand.
+	///
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	/// @tparam T Signed or unsigned integer scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldExtract.xml">GLSL bitfieldExtract man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> bitfieldExtract(
+		vec<L, T, Q> const& Value,
+		int Offset,
+		int Bits);
+
+	/// Returns the insertion the bits least-significant bits of insert into base.
+	///
+	/// The result will have bits [offset, offset + bits - 1] taken
+	/// from bits [0, bits - 1] of insert, and all other bits taken
+	/// directly from the corresponding bits of base. If bits is
+	/// zero, the result will simply be base. The result will be
+	/// undefined if offset or bits is negative, or if the sum of
+	/// offset and bits is greater than the number of bits used to
+	/// store the operand.
+	///
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	/// @tparam T Signed or unsigned integer scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldInsert.xml">GLSL bitfieldInsert man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> bitfieldInsert(
+		vec<L, T, Q> const& Base,
+		vec<L, T, Q> const& Insert,
+		int Offset,
+		int Bits);
+
+	/// Returns the reversal of the bits of value.
+	/// The bit numbered n of the result will be taken from bit (bits - 1) - n of value,
+	/// where bits is the total number of bits used to represent value.
+	///
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	/// @tparam T Signed or unsigned integer scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldReverse.xml">GLSL bitfieldReverse man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> bitfieldReverse(vec<L, T, Q> const& v);
+
+	/// Returns the number of bits set to 1 in the binary representation of value.
+	///
+	/// @tparam genType Signed or unsigned integer scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitCount.xml">GLSL bitCount man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template<typename genType>
+	GLM_FUNC_DECL int bitCount(genType v);
+
+	/// Returns the number of bits set to 1 in the binary representation of value.
+	///
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	/// @tparam T Signed or unsigned integer scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitCount.xml">GLSL bitCount man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, int, Q> bitCount(vec<L, T, Q> const& v);
+
+	/// Returns the bit number of the least significant bit set to
+	/// 1 in the binary representation of value.
+	/// If value is zero, -1 will be returned.
+	///
+	/// @tparam genIUType Signed or unsigned integer scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findLSB.xml">GLSL findLSB man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template<typename genIUType>
+	GLM_FUNC_DECL int findLSB(genIUType x);
+
+	/// Returns the bit number of the least significant bit set to
+	/// 1 in the binary representation of value.
+	/// If value is zero, -1 will be returned.
+	///
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	/// @tparam T Signed or unsigned integer scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findLSB.xml">GLSL findLSB man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, int, Q> findLSB(vec<L, T, Q> const& v);
+
+	/// Returns the bit number of the most significant bit in the binary representation of value.
+	/// For positive integers, the result will be the bit number of the most significant bit set to 1.
+	/// For negative integers, the result will be the bit number of the most significant
+	/// bit set to 0. For a value of zero or negative one, -1 will be returned.
+	///
+	/// @tparam genIUType Signed or unsigned integer scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findMSB.xml">GLSL findMSB man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template<typename genIUType>
+	GLM_FUNC_DECL int findMSB(genIUType x);
+
+	/// Returns the bit number of the most significant bit in the binary representation of value.
+	/// For positive integers, the result will be the bit number of the most significant bit set to 1.
+	/// For negative integers, the result will be the bit number of the most significant
+	/// bit set to 0. For a value of zero or negative one, -1 will be returned.
+	///
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	/// @tparam T Signed or unsigned integer scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findMSB.xml">GLSL findMSB man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, int, Q> findMSB(vec<L, T, Q> const& v);
+
+	/// @}
+}//namespace glm
+
+#include "detail/func_integer.inl"
diff --git a/engine/inc/glm/mat2x2.hpp b/engine/inc/glm/mat2x2.hpp
new file mode 100644
index 00000000..96bec96b
--- /dev/null
+++ b/engine/inc/glm/mat2x2.hpp
@@ -0,0 +1,9 @@
+/// @ref core
+/// @file glm/mat2x2.hpp
+
+#pragma once
+#include "./ext/matrix_double2x2.hpp"
+#include "./ext/matrix_double2x2_precision.hpp"
+#include "./ext/matrix_float2x2.hpp"
+#include "./ext/matrix_float2x2_precision.hpp"
+
diff --git a/engine/inc/glm/mat2x3.hpp b/engine/inc/glm/mat2x3.hpp
new file mode 100644
index 00000000..d68dc25e
--- /dev/null
+++ b/engine/inc/glm/mat2x3.hpp
@@ -0,0 +1,9 @@
+/// @ref core
+/// @file glm/mat2x3.hpp
+
+#pragma once
+#include "./ext/matrix_double2x3.hpp"
+#include "./ext/matrix_double2x3_precision.hpp"
+#include "./ext/matrix_float2x3.hpp"
+#include "./ext/matrix_float2x3_precision.hpp"
+
diff --git a/engine/inc/glm/mat2x4.hpp b/engine/inc/glm/mat2x4.hpp
new file mode 100644
index 00000000..b04b7387
--- /dev/null
+++ b/engine/inc/glm/mat2x4.hpp
@@ -0,0 +1,9 @@
+/// @ref core
+/// @file glm/mat2x4.hpp
+
+#pragma once
+#include "./ext/matrix_double2x4.hpp"
+#include "./ext/matrix_double2x4_precision.hpp"
+#include "./ext/matrix_float2x4.hpp"
+#include "./ext/matrix_float2x4_precision.hpp"
+
diff --git a/engine/inc/glm/mat3x2.hpp b/engine/inc/glm/mat3x2.hpp
new file mode 100644
index 00000000..c8531537
--- /dev/null
+++ b/engine/inc/glm/mat3x2.hpp
@@ -0,0 +1,9 @@
+/// @ref core
+/// @file glm/mat3x2.hpp
+
+#pragma once
+#include "./ext/matrix_double3x2.hpp"
+#include "./ext/matrix_double3x2_precision.hpp"
+#include "./ext/matrix_float3x2.hpp"
+#include "./ext/matrix_float3x2_precision.hpp"
+
diff --git a/engine/inc/glm/mat3x3.hpp b/engine/inc/glm/mat3x3.hpp
new file mode 100644
index 00000000..fd4fa31c
--- /dev/null
+++ b/engine/inc/glm/mat3x3.hpp
@@ -0,0 +1,8 @@
+/// @ref core
+/// @file glm/mat3x3.hpp
+
+#pragma once
+#include "./ext/matrix_double3x3.hpp"
+#include "./ext/matrix_double3x3_precision.hpp"
+#include "./ext/matrix_float3x3.hpp"
+#include "./ext/matrix_float3x3_precision.hpp"
diff --git a/engine/inc/glm/mat3x4.hpp b/engine/inc/glm/mat3x4.hpp
new file mode 100644
index 00000000..6342bf5b
--- /dev/null
+++ b/engine/inc/glm/mat3x4.hpp
@@ -0,0 +1,8 @@
+/// @ref core
+/// @file glm/mat3x4.hpp
+
+#pragma once
+#include "./ext/matrix_double3x4.hpp"
+#include "./ext/matrix_double3x4_precision.hpp"
+#include "./ext/matrix_float3x4.hpp"
+#include "./ext/matrix_float3x4_precision.hpp"
diff --git a/engine/inc/glm/mat4x2.hpp b/engine/inc/glm/mat4x2.hpp
new file mode 100644
index 00000000..e013e46b
--- /dev/null
+++ b/engine/inc/glm/mat4x2.hpp
@@ -0,0 +1,9 @@
+/// @ref core
+/// @file glm/mat4x2.hpp
+
+#pragma once
+#include "./ext/matrix_double4x2.hpp"
+#include "./ext/matrix_double4x2_precision.hpp"
+#include "./ext/matrix_float4x2.hpp"
+#include "./ext/matrix_float4x2_precision.hpp"
+
diff --git a/engine/inc/glm/mat4x3.hpp b/engine/inc/glm/mat4x3.hpp
new file mode 100644
index 00000000..205725ab
--- /dev/null
+++ b/engine/inc/glm/mat4x3.hpp
@@ -0,0 +1,8 @@
+/// @ref core
+/// @file glm/mat4x3.hpp
+
+#pragma once
+#include "./ext/matrix_double4x3.hpp"
+#include "./ext/matrix_double4x3_precision.hpp"
+#include "./ext/matrix_float4x3.hpp"
+#include "./ext/matrix_float4x3_precision.hpp"
diff --git a/engine/inc/glm/mat4x4.hpp b/engine/inc/glm/mat4x4.hpp
new file mode 100644
index 00000000..3515f7f3
--- /dev/null
+++ b/engine/inc/glm/mat4x4.hpp
@@ -0,0 +1,9 @@
+/// @ref core
+/// @file glm/mat4x4.hpp
+
+#pragma once
+#include "./ext/matrix_double4x4.hpp"
+#include "./ext/matrix_double4x4_precision.hpp"
+#include "./ext/matrix_float4x4.hpp"
+#include "./ext/matrix_float4x4_precision.hpp"
+
diff --git a/engine/inc/glm/matrix.hpp b/engine/inc/glm/matrix.hpp
new file mode 100644
index 00000000..6badf538
--- /dev/null
+++ b/engine/inc/glm/matrix.hpp
@@ -0,0 +1,161 @@
+/// @ref core
+/// @file glm/matrix.hpp
+///
+/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
+///
+/// @defgroup core_func_matrix Matrix functions
+/// @ingroup core
+///
+/// Provides GLSL matrix functions.
+///
+/// Include <glm/matrix.hpp> to use these core features.
+
+#pragma once
+
+// Dependencies
+#include "detail/qualifier.hpp"
+#include "detail/setup.hpp"
+#include "vec2.hpp"
+#include "vec3.hpp"
+#include "vec4.hpp"
+#include "mat2x2.hpp"
+#include "mat2x3.hpp"
+#include "mat2x4.hpp"
+#include "mat3x2.hpp"
+#include "mat3x3.hpp"
+#include "mat3x4.hpp"
+#include "mat4x2.hpp"
+#include "mat4x3.hpp"
+#include "mat4x4.hpp"
+
+namespace glm {
+namespace detail
+{
+	template<length_t C, length_t R, typename T, qualifier Q>
+	struct outerProduct_trait{};
+
+	template<typename T, qualifier Q>
+	struct outerProduct_trait<2, 2, T, Q>
+	{
+		typedef mat<2, 2, T, Q> type;
+	};
+
+	template<typename T, qualifier Q>
+	struct outerProduct_trait<2, 3, T, Q>
+	{
+		typedef mat<3, 2, T, Q> type;
+	};
+
+	template<typename T, qualifier Q>
+	struct outerProduct_trait<2, 4, T, Q>
+	{
+		typedef mat<4, 2, T, Q> type;
+	};
+
+	template<typename T, qualifier Q>
+	struct outerProduct_trait<3, 2, T, Q>
+	{
+		typedef mat<2, 3, T, Q> type;
+	};
+
+	template<typename T, qualifier Q>
+	struct outerProduct_trait<3, 3, T, Q>
+	{
+		typedef mat<3, 3, T, Q> type;
+	};
+
+	template<typename T, qualifier Q>
+	struct outerProduct_trait<3, 4, T, Q>
+	{
+		typedef mat<4, 3, T, Q> type;
+	};
+
+	template<typename T, qualifier Q>
+	struct outerProduct_trait<4, 2, T, Q>
+	{
+		typedef mat<2, 4, T, Q> type;
+	};
+
+	template<typename T, qualifier Q>
+	struct outerProduct_trait<4, 3, T, Q>
+	{
+		typedef mat<3, 4, T, Q> type;
+	};
+
+	template<typename T, qualifier Q>
+	struct outerProduct_trait<4, 4, T, Q>
+	{
+		typedef mat<4, 4, T, Q> type;
+	};
+}//namespace detail
+
+	 /// @addtogroup core_func_matrix
+	 /// @{
+
+	 /// Multiply matrix x by matrix y component-wise, i.e.,
+	 /// result[i][j] is the scalar product of x[i][j] and y[i][j].
+	 ///
+	 /// @tparam C Integer between 1 and 4 included that qualify the number a column
+	 /// @tparam R Integer between 1 and 4 included that qualify the number a row
+	 /// @tparam T Floating-point or signed integer scalar types
+	 /// @tparam Q Value from qualifier enum
+	 ///
+	 /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/matrixCompMult.xml">GLSL matrixCompMult man page</a>
+	 /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_DECL mat<C, R, T, Q> matrixCompMult(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y);
+
+	/// Treats the first parameter c as a column vector
+	/// and the second parameter r as a row vector
+	/// and does a linear algebraic matrix multiply c * r.
+	///
+	/// @tparam C Integer between 1 and 4 included that qualify the number a column
+	/// @tparam R Integer between 1 and 4 included that qualify the number a row
+	/// @tparam T Floating-point or signed integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/outerProduct.xml">GLSL outerProduct man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_DECL typename detail::outerProduct_trait<C, R, T, Q>::type outerProduct(vec<C, T, Q> const& c, vec<R, T, Q> const& r);
+
+	/// Returns the transposed matrix of x
+	///
+	/// @tparam C Integer between 1 and 4 included that qualify the number a column
+	/// @tparam R Integer between 1 and 4 included that qualify the number a row
+	/// @tparam T Floating-point or signed integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/transpose.xml">GLSL transpose man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_DECL typename mat<C, R, T, Q>::transpose_type transpose(mat<C, R, T, Q> const& x);
+
+	/// Return the determinant of a squared matrix.
+	///
+	/// @tparam C Integer between 1 and 4 included that qualify the number a column
+	/// @tparam R Integer between 1 and 4 included that qualify the number a row
+	/// @tparam T Floating-point or signed integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/determinant.xml">GLSL determinant man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_DECL T determinant(mat<C, R, T, Q> const& m);
+
+	/// Return the inverse of a squared matrix.
+	///
+	/// @tparam C Integer between 1 and 4 included that qualify the number a column
+	/// @tparam R Integer between 1 and 4 included that qualify the number a row
+	/// @tparam T Floating-point or signed integer scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inverse.xml">GLSL inverse man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
+	template<length_t C, length_t R, typename T, qualifier Q>
+	GLM_FUNC_DECL mat<C, R, T, Q> inverse(mat<C, R, T, Q> const& m);
+
+	/// @}
+}//namespace glm
+
+#include "detail/func_matrix.inl"
diff --git a/engine/inc/glm/packing.hpp b/engine/inc/glm/packing.hpp
new file mode 100644
index 00000000..ca83ac1d
--- /dev/null
+++ b/engine/inc/glm/packing.hpp
@@ -0,0 +1,173 @@
+/// @ref core
+/// @file glm/packing.hpp
+///
+/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+/// @see gtc_packing
+///
+/// @defgroup core_func_packing Floating-Point Pack and Unpack Functions
+/// @ingroup core
+///
+/// Provides GLSL functions to pack and unpack half, single and double-precision floating point values into more compact integer types.
+///
+/// These functions do not operate component-wise, rather as described in each case.
+///
+/// Include <glm/packing.hpp> to use these core features.
+
+#pragma once
+
+#include "./ext/vector_uint2.hpp"
+#include "./ext/vector_float2.hpp"
+#include "./ext/vector_float4.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_func_packing
+	/// @{
+
+	/// First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values.
+	/// Then, the results are packed into the returned 32-bit unsigned integer.
+	///
+	/// The conversion for component c of v to fixed point is done as follows:
+	/// packUnorm2x16: round(clamp(c, 0, +1) * 65535.0)
+	///
+	/// The first component of the vector will be written to the least significant bits of the output;
+	/// the last component will be written to the most significant bits.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm2x16.xml">GLSL packUnorm2x16 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL uint packUnorm2x16(vec2 const& v);
+
+	/// First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values.
+	/// Then, the results are packed into the returned 32-bit unsigned integer.
+	///
+	/// The conversion for component c of v to fixed point is done as follows:
+	/// packSnorm2x16: round(clamp(v, -1, +1) * 32767.0)
+	///
+	/// The first component of the vector will be written to the least significant bits of the output;
+	/// the last component will be written to the most significant bits.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm2x16.xml">GLSL packSnorm2x16 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL uint packSnorm2x16(vec2 const& v);
+
+	/// First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values.
+	/// Then, the results are packed into the returned 32-bit unsigned integer.
+	///
+	/// The conversion for component c of v to fixed point is done as follows:
+	/// packUnorm4x8:	round(clamp(c, 0, +1) * 255.0)
+	///
+	/// The first component of the vector will be written to the least significant bits of the output;
+	/// the last component will be written to the most significant bits.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm4x8.xml">GLSL packUnorm4x8 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL uint packUnorm4x8(vec4 const& v);
+
+	/// First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values.
+	/// Then, the results are packed into the returned 32-bit unsigned integer.
+	///
+	/// The conversion for component c of v to fixed point is done as follows:
+	/// packSnorm4x8:	round(clamp(c, -1, +1) * 127.0)
+	///
+	/// The first component of the vector will be written to the least significant bits of the output;
+	/// the last component will be written to the most significant bits.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm4x8.xml">GLSL packSnorm4x8 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL uint packSnorm4x8(vec4 const& v);
+
+	/// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers.
+	/// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
+	///
+	/// The conversion for unpacked fixed-point value f to floating point is done as follows:
+	/// unpackUnorm2x16: f / 65535.0
+	///
+	/// The first component of the returned vector will be extracted from the least significant bits of the input;
+	/// the last component will be extracted from the most significant bits.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm2x16.xml">GLSL unpackUnorm2x16 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL vec2 unpackUnorm2x16(uint p);
+
+	/// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers.
+	/// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
+	///
+	/// The conversion for unpacked fixed-point value f to floating point is done as follows:
+	/// unpackSnorm2x16: clamp(f / 32767.0, -1, +1)
+	///
+	/// The first component of the returned vector will be extracted from the least significant bits of the input;
+	/// the last component will be extracted from the most significant bits.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm2x16.xml">GLSL unpackSnorm2x16 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL vec2 unpackSnorm2x16(uint p);
+
+	/// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers.
+	/// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
+	///
+	/// The conversion for unpacked fixed-point value f to floating point is done as follows:
+	/// unpackUnorm4x8: f / 255.0
+	///
+	/// The first component of the returned vector will be extracted from the least significant bits of the input;
+	/// the last component will be extracted from the most significant bits.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm4x8.xml">GLSL unpackUnorm4x8 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL vec4 unpackUnorm4x8(uint p);
+
+	/// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers.
+	/// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
+	///
+	/// The conversion for unpacked fixed-point value f to floating point is done as follows:
+	/// unpackSnorm4x8: clamp(f / 127.0, -1, +1)
+	///
+	/// The first component of the returned vector will be extracted from the least significant bits of the input;
+	/// the last component will be extracted from the most significant bits.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm4x8.xml">GLSL unpackSnorm4x8 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL vec4 unpackSnorm4x8(uint p);
+
+	/// Returns a double-qualifier value obtained by packing the components of v into a 64-bit value.
+	/// If an IEEE 754 Inf or NaN is created, it will not signal, and the resulting floating point value is unspecified.
+	/// Otherwise, the bit- level representation of v is preserved.
+	/// The first vector component specifies the 32 least significant bits;
+	/// the second component specifies the 32 most significant bits.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packDouble2x32.xml">GLSL packDouble2x32 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL double packDouble2x32(uvec2 const& v);
+
+	/// Returns a two-component unsigned integer vector representation of v.
+	/// The bit-level representation of v is preserved.
+	/// The first component of the vector contains the 32 least significant bits of the double;
+	/// the second component consists the 32 most significant bits.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackDouble2x32.xml">GLSL unpackDouble2x32 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL uvec2 unpackDouble2x32(double v);
+
+	/// Returns an unsigned integer obtained by converting the components of a two-component floating-point vector
+	/// to the 16-bit floating-point representation found in the OpenGL Specification,
+	/// and then packing these two 16- bit integers into a 32-bit unsigned integer.
+	/// The first vector component specifies the 16 least-significant bits of the result;
+	/// the second component specifies the 16 most-significant bits.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packHalf2x16.xml">GLSL packHalf2x16 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL uint packHalf2x16(vec2 const& v);
+
+	/// Returns a two-component floating-point vector with components obtained by unpacking a 32-bit unsigned integer into a pair of 16-bit values,
+	/// interpreting those values as 16-bit floating-point numbers according to the OpenGL Specification,
+	/// and converting them to 32-bit floating-point values.
+	/// The first component of the vector is obtained from the 16 least-significant bits of v;
+	/// the second component is obtained from the 16 most-significant bits of v.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackHalf2x16.xml">GLSL unpackHalf2x16 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL vec2 unpackHalf2x16(uint v);
+
+	/// @}
+}//namespace glm
+
+#include "detail/func_packing.inl"
diff --git a/engine/inc/glm/simd/common.h b/engine/inc/glm/simd/common.h
new file mode 100644
index 00000000..d07920a3
--- /dev/null
+++ b/engine/inc/glm/simd/common.h
@@ -0,0 +1,240 @@
+/// @ref simd
+/// @file glm/simd/common.h
+
+#pragma once
+
+#include "platform.h"
+
+#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_add(glm_f32vec4 a, glm_f32vec4 b)
+{
+	return _mm_add_ps(a, b);
+}
+
+GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec1_add(glm_f32vec4 a, glm_f32vec4 b)
+{
+	return _mm_add_ss(a, b);
+}
+
+GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_sub(glm_f32vec4 a, glm_f32vec4 b)
+{
+	return _mm_sub_ps(a, b);
+}
+
+GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec1_sub(glm_f32vec4 a, glm_f32vec4 b)
+{
+	return _mm_sub_ss(a, b);
+}
+
+GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_mul(glm_f32vec4 a, glm_f32vec4 b)
+{
+	return _mm_mul_ps(a, b);
+}
+
+GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec1_mul(glm_f32vec4 a, glm_f32vec4 b)
+{
+	return _mm_mul_ss(a, b);
+}
+
+GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_div(glm_f32vec4 a, glm_f32vec4 b)
+{
+	return _mm_div_ps(a, b);
+}
+
+GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec1_div(glm_f32vec4 a, glm_f32vec4 b)
+{
+	return _mm_div_ss(a, b);
+}
+
+GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_div_lowp(glm_f32vec4 a, glm_f32vec4 b)
+{
+	return glm_vec4_mul(a, _mm_rcp_ps(b));
+}
+
+GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_swizzle_xyzw(glm_f32vec4 a)
+{
+#	if GLM_ARCH & GLM_ARCH_AVX2_BIT
+		return _mm_permute_ps(a, _MM_SHUFFLE(3, 2, 1, 0));
+#	else
+		return _mm_shuffle_ps(a, a, _MM_SHUFFLE(3, 2, 1, 0));
+#	endif
+}
+
+GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec1_fma(glm_f32vec4 a, glm_f32vec4 b, glm_f32vec4 c)
+{
+#	if (GLM_ARCH & GLM_ARCH_AVX2_BIT) && !(GLM_COMPILER & GLM_COMPILER_CLANG)
+		return _mm_fmadd_ss(a, b, c);
+#	else
+		return _mm_add_ss(_mm_mul_ss(a, b), c);
+#	endif
+}
+
+GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_fma(glm_f32vec4 a, glm_f32vec4 b, glm_f32vec4 c)
+{
+#	if (GLM_ARCH & GLM_ARCH_AVX2_BIT) && !(GLM_COMPILER & GLM_COMPILER_CLANG)
+		return _mm_fmadd_ps(a, b, c);
+#	else
+		return glm_vec4_add(glm_vec4_mul(a, b), c);
+#	endif
+}
+
+GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_abs(glm_f32vec4 x)
+{
+	return _mm_and_ps(x, _mm_castsi128_ps(_mm_set1_epi32(0x7FFFFFFF)));
+}
+
+GLM_FUNC_QUALIFIER glm_ivec4 glm_ivec4_abs(glm_ivec4 x)
+{
+#	if GLM_ARCH & GLM_ARCH_SSSE3_BIT
+		return _mm_sign_epi32(x, x);
+#	else
+		glm_ivec4 const sgn0 = _mm_srai_epi32(x, 31);
+		glm_ivec4 const inv0 = _mm_xor_si128(x, sgn0);
+		glm_ivec4 const sub0 = _mm_sub_epi32(inv0, sgn0);
+		return sub0;
+#	endif
+}
+
+GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_sign(glm_vec4 x)
+{
+	glm_vec4 const zro0 = _mm_setzero_ps();
+	glm_vec4 const cmp0 = _mm_cmplt_ps(x, zro0);
+	glm_vec4 const cmp1 = _mm_cmpgt_ps(x, zro0);
+	glm_vec4 const and0 = _mm_and_ps(cmp0, _mm_set1_ps(-1.0f));
+	glm_vec4 const and1 = _mm_and_ps(cmp1, _mm_set1_ps(1.0f));
+	glm_vec4 const or0 = _mm_or_ps(and0, and1);;
+	return or0;
+}
+
+GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_round(glm_vec4 x)
+{
+#	if GLM_ARCH & GLM_ARCH_SSE41_BIT
+		return _mm_round_ps(x, _MM_FROUND_TO_NEAREST_INT);
+#	else
+		glm_vec4 const sgn0 = _mm_castsi128_ps(_mm_set1_epi32(int(0x80000000)));
+		glm_vec4 const and0 = _mm_and_ps(sgn0, x);
+		glm_vec4 const or0 = _mm_or_ps(and0, _mm_set_ps1(8388608.0f));
+		glm_vec4 const add0 = glm_vec4_add(x, or0);
+		glm_vec4 const sub0 = glm_vec4_sub(add0, or0);
+		return sub0;
+#	endif
+}
+
+GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_floor(glm_vec4 x)
+{
+#	if GLM_ARCH & GLM_ARCH_SSE41_BIT
+		return _mm_floor_ps(x);
+#	else
+		glm_vec4 const rnd0 = glm_vec4_round(x);
+		glm_vec4 const cmp0 = _mm_cmplt_ps(x, rnd0);
+		glm_vec4 const and0 = _mm_and_ps(cmp0, _mm_set1_ps(1.0f));
+		glm_vec4 const sub0 = glm_vec4_sub(rnd0, and0);
+		return sub0;
+#	endif
+}
+
+/* trunc TODO
+GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_trunc(glm_vec4 x)
+{
+	return glm_vec4();
+}
+*/
+
+//roundEven
+GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_roundEven(glm_vec4 x)
+{
+	glm_vec4 const sgn0 = _mm_castsi128_ps(_mm_set1_epi32(int(0x80000000)));
+	glm_vec4 const and0 = _mm_and_ps(sgn0, x);
+	glm_vec4 const or0 = _mm_or_ps(and0, _mm_set_ps1(8388608.0f));
+	glm_vec4 const add0 = glm_vec4_add(x, or0);
+	glm_vec4 const sub0 = glm_vec4_sub(add0, or0);
+	return sub0;
+}
+
+GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_ceil(glm_vec4 x)
+{
+#	if GLM_ARCH & GLM_ARCH_SSE41_BIT
+		return _mm_ceil_ps(x);
+#	else
+		glm_vec4 const rnd0 = glm_vec4_round(x);
+		glm_vec4 const cmp0 = _mm_cmpgt_ps(x, rnd0);
+		glm_vec4 const and0 = _mm_and_ps(cmp0, _mm_set1_ps(1.0f));
+		glm_vec4 const add0 = glm_vec4_add(rnd0, and0);
+		return add0;
+#	endif
+}
+
+GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_fract(glm_vec4 x)
+{
+	glm_vec4 const flr0 = glm_vec4_floor(x);
+	glm_vec4 const sub0 = glm_vec4_sub(x, flr0);
+	return sub0;
+}
+
+GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_mod(glm_vec4 x, glm_vec4 y)
+{
+	glm_vec4 const div0 = glm_vec4_div(x, y);
+	glm_vec4 const flr0 = glm_vec4_floor(div0);
+	glm_vec4 const mul0 = glm_vec4_mul(y, flr0);
+	glm_vec4 const sub0 = glm_vec4_sub(x, mul0);
+	return sub0;
+}
+
+GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_clamp(glm_vec4 v, glm_vec4 minVal, glm_vec4 maxVal)
+{
+	glm_vec4 const min0 = _mm_min_ps(v, maxVal);
+	glm_vec4 const max0 = _mm_max_ps(min0, minVal);
+	return max0;
+}
+
+GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_mix(glm_vec4 v1, glm_vec4 v2, glm_vec4 a)
+{
+	glm_vec4 const sub0 = glm_vec4_sub(_mm_set1_ps(1.0f), a);
+	glm_vec4 const mul0 = glm_vec4_mul(v1, sub0);
+	glm_vec4 const mad0 = glm_vec4_fma(v2, a, mul0);
+	return mad0;
+}
+
+GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_step(glm_vec4 edge, glm_vec4 x)
+{
+	glm_vec4 const cmp = _mm_cmple_ps(x, edge);
+	return _mm_movemask_ps(cmp) == 0 ? _mm_set1_ps(1.0f) : _mm_setzero_ps();
+}
+
+GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_smoothstep(glm_vec4 edge0, glm_vec4 edge1, glm_vec4 x)
+{
+	glm_vec4 const sub0 = glm_vec4_sub(x, edge0);
+	glm_vec4 const sub1 = glm_vec4_sub(edge1, edge0);
+	glm_vec4 const div0 = glm_vec4_sub(sub0, sub1);
+	glm_vec4 const clp0 = glm_vec4_clamp(div0, _mm_setzero_ps(), _mm_set1_ps(1.0f));
+	glm_vec4 const mul0 = glm_vec4_mul(_mm_set1_ps(2.0f), clp0);
+	glm_vec4 const sub2 = glm_vec4_sub(_mm_set1_ps(3.0f), mul0);
+	glm_vec4 const mul1 = glm_vec4_mul(clp0, clp0);
+	glm_vec4 const mul2 = glm_vec4_mul(mul1, sub2);
+	return mul2;
+}
+
+// Agner Fog method
+GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_nan(glm_vec4 x)
+{
+	glm_ivec4 const t1 = _mm_castps_si128(x);						// reinterpret as 32-bit integer
+	glm_ivec4 const t2 = _mm_sll_epi32(t1, _mm_cvtsi32_si128(1));	// shift out sign bit
+	glm_ivec4 const t3 = _mm_set1_epi32(int(0xFF000000));				// exponent mask
+	glm_ivec4 const t4 = _mm_and_si128(t2, t3);						// exponent
+	glm_ivec4 const t5 = _mm_andnot_si128(t3, t2);					// fraction
+	glm_ivec4 const Equal = _mm_cmpeq_epi32(t3, t4);
+	glm_ivec4 const Nequal = _mm_cmpeq_epi32(t5, _mm_setzero_si128());
+	glm_ivec4 const And = _mm_and_si128(Equal, Nequal);
+	return _mm_castsi128_ps(And);									// exponent = all 1s and fraction != 0
+}
+
+// Agner Fog method
+GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_inf(glm_vec4 x)
+{
+	glm_ivec4 const t1 = _mm_castps_si128(x);										// reinterpret as 32-bit integer
+	glm_ivec4 const t2 = _mm_sll_epi32(t1, _mm_cvtsi32_si128(1));					// shift out sign bit
+	return _mm_castsi128_ps(_mm_cmpeq_epi32(t2, _mm_set1_epi32(int(0xFF000000))));		// exponent is all 1s, fraction is 0
+}
+
+#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
diff --git a/engine/inc/glm/simd/exponential.h b/engine/inc/glm/simd/exponential.h
new file mode 100644
index 00000000..bc351d01
--- /dev/null
+++ b/engine/inc/glm/simd/exponential.h
@@ -0,0 +1,20 @@
+/// @ref simd
+/// @file glm/simd/experimental.h
+
+#pragma once
+
+#include "platform.h"
+
+#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec1_sqrt_lowp(glm_f32vec4 x)
+{
+	return _mm_mul_ss(_mm_rsqrt_ss(x), x);
+}
+
+GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_sqrt_lowp(glm_f32vec4 x)
+{
+	return _mm_mul_ps(_mm_rsqrt_ps(x), x);
+}
+
+#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
diff --git a/engine/inc/glm/simd/geometric.h b/engine/inc/glm/simd/geometric.h
new file mode 100644
index 00000000..07d7cbcc
--- /dev/null
+++ b/engine/inc/glm/simd/geometric.h
@@ -0,0 +1,124 @@
+/// @ref simd
+/// @file glm/simd/geometric.h
+
+#pragma once
+
+#include "common.h"
+
+#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+GLM_FUNC_DECL glm_vec4 glm_vec4_dot(glm_vec4 v1, glm_vec4 v2);
+GLM_FUNC_DECL glm_vec4 glm_vec1_dot(glm_vec4 v1, glm_vec4 v2);
+
+GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_length(glm_vec4 x)
+{
+	glm_vec4 const dot0 = glm_vec4_dot(x, x);
+	glm_vec4 const sqt0 = _mm_sqrt_ps(dot0);
+	return sqt0;
+}
+
+GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_distance(glm_vec4 p0, glm_vec4 p1)
+{
+	glm_vec4 const sub0 = _mm_sub_ps(p0, p1);
+	glm_vec4 const len0 = glm_vec4_length(sub0);
+	return len0;
+}
+
+GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_dot(glm_vec4 v1, glm_vec4 v2)
+{
+#	if GLM_ARCH & GLM_ARCH_AVX_BIT
+		return _mm_dp_ps(v1, v2, 0xff);
+#	elif GLM_ARCH & GLM_ARCH_SSE3_BIT
+		glm_vec4 const mul0 = _mm_mul_ps(v1, v2);
+		glm_vec4 const hadd0 = _mm_hadd_ps(mul0, mul0);
+		glm_vec4 const hadd1 = _mm_hadd_ps(hadd0, hadd0);
+		return hadd1;
+#	else
+		glm_vec4 const mul0 = _mm_mul_ps(v1, v2);
+		glm_vec4 const swp0 = _mm_shuffle_ps(mul0, mul0, _MM_SHUFFLE(2, 3, 0, 1));
+		glm_vec4 const add0 = _mm_add_ps(mul0, swp0);
+		glm_vec4 const swp1 = _mm_shuffle_ps(add0, add0, _MM_SHUFFLE(0, 1, 2, 3));
+		glm_vec4 const add1 = _mm_add_ps(add0, swp1);
+		return add1;
+#	endif
+}
+
+GLM_FUNC_QUALIFIER glm_vec4 glm_vec1_dot(glm_vec4 v1, glm_vec4 v2)
+{
+#	if GLM_ARCH & GLM_ARCH_AVX_BIT
+		return _mm_dp_ps(v1, v2, 0xff);
+#	elif GLM_ARCH & GLM_ARCH_SSE3_BIT
+		glm_vec4 const mul0 = _mm_mul_ps(v1, v2);
+		glm_vec4 const had0 = _mm_hadd_ps(mul0, mul0);
+		glm_vec4 const had1 = _mm_hadd_ps(had0, had0);
+		return had1;
+#	else
+		glm_vec4 const mul0 = _mm_mul_ps(v1, v2);
+		glm_vec4 const mov0 = _mm_movehl_ps(mul0, mul0);
+		glm_vec4 const add0 = _mm_add_ps(mov0, mul0);
+		glm_vec4 const swp1 = _mm_shuffle_ps(add0, add0, 1);
+		glm_vec4 const add1 = _mm_add_ss(add0, swp1);
+		return add1;
+#	endif
+}
+
+GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_cross(glm_vec4 v1, glm_vec4 v2)
+{
+	glm_vec4 const swp0 = _mm_shuffle_ps(v1, v1, _MM_SHUFFLE(3, 0, 2, 1));
+	glm_vec4 const swp1 = _mm_shuffle_ps(v1, v1, _MM_SHUFFLE(3, 1, 0, 2));
+	glm_vec4 const swp2 = _mm_shuffle_ps(v2, v2, _MM_SHUFFLE(3, 0, 2, 1));
+	glm_vec4 const swp3 = _mm_shuffle_ps(v2, v2, _MM_SHUFFLE(3, 1, 0, 2));
+	glm_vec4 const mul0 = _mm_mul_ps(swp0, swp3);
+	glm_vec4 const mul1 = _mm_mul_ps(swp1, swp2);
+	glm_vec4 const sub0 = _mm_sub_ps(mul0, mul1);
+	return sub0;
+}
+
+GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_normalize(glm_vec4 v)
+{
+	glm_vec4 const dot0 = glm_vec4_dot(v, v);
+	glm_vec4 const isr0 = _mm_rsqrt_ps(dot0);
+	glm_vec4 const mul0 = _mm_mul_ps(v, isr0);
+	return mul0;
+}
+
+GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_faceforward(glm_vec4 N, glm_vec4 I, glm_vec4 Nref)
+{
+	glm_vec4 const dot0 = glm_vec4_dot(Nref, I);
+	glm_vec4 const sgn0 = glm_vec4_sign(dot0);
+	glm_vec4 const mul0 = _mm_mul_ps(sgn0, _mm_set1_ps(-1.0f));
+	glm_vec4 const mul1 = _mm_mul_ps(N, mul0);
+	return mul1;
+}
+
+GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_reflect(glm_vec4 I, glm_vec4 N)
+{
+	glm_vec4 const dot0 = glm_vec4_dot(N, I);
+	glm_vec4 const mul0 = _mm_mul_ps(N, dot0);
+	glm_vec4 const mul1 = _mm_mul_ps(mul0, _mm_set1_ps(2.0f));
+	glm_vec4 const sub0 = _mm_sub_ps(I, mul1);
+	return sub0;
+}
+
+GLM_FUNC_QUALIFIER __m128 glm_vec4_refract(glm_vec4 I, glm_vec4 N, glm_vec4 eta)
+{
+	glm_vec4 const dot0 = glm_vec4_dot(N, I);
+	glm_vec4 const mul0 = _mm_mul_ps(eta, eta);
+	glm_vec4 const mul1 = _mm_mul_ps(dot0, dot0);
+	glm_vec4 const sub0 = _mm_sub_ps(_mm_set1_ps(1.0f), mul0);
+	glm_vec4 const sub1 = _mm_sub_ps(_mm_set1_ps(1.0f), mul1);
+	glm_vec4 const mul2 = _mm_mul_ps(sub0, sub1);
+
+	if(_mm_movemask_ps(_mm_cmplt_ss(mul2, _mm_set1_ps(0.0f))) == 0)
+		return _mm_set1_ps(0.0f);
+
+	glm_vec4 const sqt0 = _mm_sqrt_ps(mul2);
+	glm_vec4 const mad0 = glm_vec4_fma(eta, dot0, sqt0);
+	glm_vec4 const mul4 = _mm_mul_ps(mad0, N);
+	glm_vec4 const mul5 = _mm_mul_ps(eta, I);
+	glm_vec4 const sub2 = _mm_sub_ps(mul5, mul4);
+
+	return sub2;
+}
+
+#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
diff --git a/engine/inc/glm/simd/integer.h b/engine/inc/glm/simd/integer.h
new file mode 100644
index 00000000..93814183
--- /dev/null
+++ b/engine/inc/glm/simd/integer.h
@@ -0,0 +1,115 @@
+/// @ref simd
+/// @file glm/simd/integer.h
+
+#pragma once
+
+#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+GLM_FUNC_QUALIFIER glm_uvec4 glm_i128_interleave(glm_uvec4 x)
+{
+	glm_uvec4 const Mask4 = _mm_set1_epi32(0x0000FFFF);
+	glm_uvec4 const Mask3 = _mm_set1_epi32(0x00FF00FF);
+	glm_uvec4 const Mask2 = _mm_set1_epi32(0x0F0F0F0F);
+	glm_uvec4 const Mask1 = _mm_set1_epi32(0x33333333);
+	glm_uvec4 const Mask0 = _mm_set1_epi32(0x55555555);
+
+	glm_uvec4 Reg1;
+	glm_uvec4 Reg2;
+
+	// REG1 = x;
+	// REG2 = y;
+	//Reg1 = _mm_unpacklo_epi64(x, y);
+	Reg1 = x;
+
+	//REG1 = ((REG1 << 16) | REG1) & glm::uint64(0x0000FFFF0000FFFF);
+	//REG2 = ((REG2 << 16) | REG2) & glm::uint64(0x0000FFFF0000FFFF);
+	Reg2 = _mm_slli_si128(Reg1, 2);
+	Reg1 = _mm_or_si128(Reg2, Reg1);
+	Reg1 = _mm_and_si128(Reg1, Mask4);
+
+	//REG1 = ((REG1 <<  8) | REG1) & glm::uint64(0x00FF00FF00FF00FF);
+	//REG2 = ((REG2 <<  8) | REG2) & glm::uint64(0x00FF00FF00FF00FF);
+	Reg2 = _mm_slli_si128(Reg1, 1);
+	Reg1 = _mm_or_si128(Reg2, Reg1);
+	Reg1 = _mm_and_si128(Reg1, Mask3);
+
+	//REG1 = ((REG1 <<  4) | REG1) & glm::uint64(0x0F0F0F0F0F0F0F0F);
+	//REG2 = ((REG2 <<  4) | REG2) & glm::uint64(0x0F0F0F0F0F0F0F0F);
+	Reg2 = _mm_slli_epi32(Reg1, 4);
+	Reg1 = _mm_or_si128(Reg2, Reg1);
+	Reg1 = _mm_and_si128(Reg1, Mask2);
+
+	//REG1 = ((REG1 <<  2) | REG1) & glm::uint64(0x3333333333333333);
+	//REG2 = ((REG2 <<  2) | REG2) & glm::uint64(0x3333333333333333);
+	Reg2 = _mm_slli_epi32(Reg1, 2);
+	Reg1 = _mm_or_si128(Reg2, Reg1);
+	Reg1 = _mm_and_si128(Reg1, Mask1);
+
+	//REG1 = ((REG1 <<  1) | REG1) & glm::uint64(0x5555555555555555);
+	//REG2 = ((REG2 <<  1) | REG2) & glm::uint64(0x5555555555555555);
+	Reg2 = _mm_slli_epi32(Reg1, 1);
+	Reg1 = _mm_or_si128(Reg2, Reg1);
+	Reg1 = _mm_and_si128(Reg1, Mask0);
+
+	//return REG1 | (REG2 << 1);
+	Reg2 = _mm_slli_epi32(Reg1, 1);
+	Reg2 = _mm_srli_si128(Reg2, 8);
+	Reg1 = _mm_or_si128(Reg1, Reg2);
+
+	return Reg1;
+}
+
+GLM_FUNC_QUALIFIER glm_uvec4 glm_i128_interleave2(glm_uvec4 x, glm_uvec4 y)
+{
+	glm_uvec4 const Mask4 = _mm_set1_epi32(0x0000FFFF);
+	glm_uvec4 const Mask3 = _mm_set1_epi32(0x00FF00FF);
+	glm_uvec4 const Mask2 = _mm_set1_epi32(0x0F0F0F0F);
+	glm_uvec4 const Mask1 = _mm_set1_epi32(0x33333333);
+	glm_uvec4 const Mask0 = _mm_set1_epi32(0x55555555);
+
+	glm_uvec4 Reg1;
+	glm_uvec4 Reg2;
+
+	// REG1 = x;
+	// REG2 = y;
+	Reg1 = _mm_unpacklo_epi64(x, y);
+
+	//REG1 = ((REG1 << 16) | REG1) & glm::uint64(0x0000FFFF0000FFFF);
+	//REG2 = ((REG2 << 16) | REG2) & glm::uint64(0x0000FFFF0000FFFF);
+	Reg2 = _mm_slli_si128(Reg1, 2);
+	Reg1 = _mm_or_si128(Reg2, Reg1);
+	Reg1 = _mm_and_si128(Reg1, Mask4);
+
+	//REG1 = ((REG1 <<  8) | REG1) & glm::uint64(0x00FF00FF00FF00FF);
+	//REG2 = ((REG2 <<  8) | REG2) & glm::uint64(0x00FF00FF00FF00FF);
+	Reg2 = _mm_slli_si128(Reg1, 1);
+	Reg1 = _mm_or_si128(Reg2, Reg1);
+	Reg1 = _mm_and_si128(Reg1, Mask3);
+
+	//REG1 = ((REG1 <<  4) | REG1) & glm::uint64(0x0F0F0F0F0F0F0F0F);
+	//REG2 = ((REG2 <<  4) | REG2) & glm::uint64(0x0F0F0F0F0F0F0F0F);
+	Reg2 = _mm_slli_epi32(Reg1, 4);
+	Reg1 = _mm_or_si128(Reg2, Reg1);
+	Reg1 = _mm_and_si128(Reg1, Mask2);
+
+	//REG1 = ((REG1 <<  2) | REG1) & glm::uint64(0x3333333333333333);
+	//REG2 = ((REG2 <<  2) | REG2) & glm::uint64(0x3333333333333333);
+	Reg2 = _mm_slli_epi32(Reg1, 2);
+	Reg1 = _mm_or_si128(Reg2, Reg1);
+	Reg1 = _mm_and_si128(Reg1, Mask1);
+
+	//REG1 = ((REG1 <<  1) | REG1) & glm::uint64(0x5555555555555555);
+	//REG2 = ((REG2 <<  1) | REG2) & glm::uint64(0x5555555555555555);
+	Reg2 = _mm_slli_epi32(Reg1, 1);
+	Reg1 = _mm_or_si128(Reg2, Reg1);
+	Reg1 = _mm_and_si128(Reg1, Mask0);
+
+	//return REG1 | (REG2 << 1);
+	Reg2 = _mm_slli_epi32(Reg1, 1);
+	Reg2 = _mm_srli_si128(Reg2, 8);
+	Reg1 = _mm_or_si128(Reg1, Reg2);
+
+	return Reg1;
+}
+
+#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
diff --git a/engine/inc/glm/simd/matrix.h b/engine/inc/glm/simd/matrix.h
new file mode 100644
index 00000000..b6c42ea4
--- /dev/null
+++ b/engine/inc/glm/simd/matrix.h
@@ -0,0 +1,1028 @@
+/// @ref simd
+/// @file glm/simd/matrix.h
+
+#pragma once
+
+#include "geometric.h"
+
+#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+GLM_FUNC_QUALIFIER void glm_mat4_matrixCompMult(glm_vec4 const in1[4], glm_vec4 const in2[4], glm_vec4 out[4])
+{
+	out[0] = _mm_mul_ps(in1[0], in2[0]);
+	out[1] = _mm_mul_ps(in1[1], in2[1]);
+	out[2] = _mm_mul_ps(in1[2], in2[2]);
+	out[3] = _mm_mul_ps(in1[3], in2[3]);
+}
+
+GLM_FUNC_QUALIFIER void glm_mat4_add(glm_vec4 const in1[4], glm_vec4 const in2[4], glm_vec4 out[4])
+{
+	out[0] = _mm_add_ps(in1[0], in2[0]);
+	out[1] = _mm_add_ps(in1[1], in2[1]);
+	out[2] = _mm_add_ps(in1[2], in2[2]);
+	out[3] = _mm_add_ps(in1[3], in2[3]);
+}
+
+GLM_FUNC_QUALIFIER void glm_mat4_sub(glm_vec4 const in1[4], glm_vec4 const in2[4], glm_vec4 out[4])
+{
+	out[0] = _mm_sub_ps(in1[0], in2[0]);
+	out[1] = _mm_sub_ps(in1[1], in2[1]);
+	out[2] = _mm_sub_ps(in1[2], in2[2]);
+	out[3] = _mm_sub_ps(in1[3], in2[3]);
+}
+
+GLM_FUNC_QUALIFIER glm_vec4 glm_mat4_mul_vec4(glm_vec4 const m[4], glm_vec4 v)
+{
+	__m128 v0 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 v1 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(1, 1, 1, 1));
+	__m128 v2 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(2, 2, 2, 2));
+	__m128 v3 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(3, 3, 3, 3));
+
+	__m128 m0 = _mm_mul_ps(m[0], v0);
+	__m128 m1 = _mm_mul_ps(m[1], v1);
+	__m128 m2 = _mm_mul_ps(m[2], v2);
+	__m128 m3 = _mm_mul_ps(m[3], v3);
+
+	__m128 a0 = _mm_add_ps(m0, m1);
+	__m128 a1 = _mm_add_ps(m2, m3);
+	__m128 a2 = _mm_add_ps(a0, a1);
+
+	return a2;
+}
+
+GLM_FUNC_QUALIFIER __m128 glm_vec4_mul_mat4(glm_vec4 v, glm_vec4 const m[4])
+{
+	__m128 i0 = m[0];
+	__m128 i1 = m[1];
+	__m128 i2 = m[2];
+	__m128 i3 = m[3];
+
+	__m128 m0 = _mm_mul_ps(v, i0);
+	__m128 m1 = _mm_mul_ps(v, i1);
+	__m128 m2 = _mm_mul_ps(v, i2);
+	__m128 m3 = _mm_mul_ps(v, i3);
+
+	__m128 u0 = _mm_unpacklo_ps(m0, m1);
+	__m128 u1 = _mm_unpackhi_ps(m0, m1);
+	__m128 a0 = _mm_add_ps(u0, u1);
+
+	__m128 u2 = _mm_unpacklo_ps(m2, m3);
+	__m128 u3 = _mm_unpackhi_ps(m2, m3);
+	__m128 a1 = _mm_add_ps(u2, u3);
+
+	__m128 f0 = _mm_movelh_ps(a0, a1);
+	__m128 f1 = _mm_movehl_ps(a1, a0);
+	__m128 f2 = _mm_add_ps(f0, f1);
+
+	return f2;
+}
+
+GLM_FUNC_QUALIFIER void glm_mat4_mul(glm_vec4 const in1[4], glm_vec4 const in2[4], glm_vec4 out[4])
+{
+	{
+		__m128 e0 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 e1 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 e2 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 e3 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 m0 = _mm_mul_ps(in1[0], e0);
+		__m128 m1 = _mm_mul_ps(in1[1], e1);
+		__m128 m2 = _mm_mul_ps(in1[2], e2);
+		__m128 m3 = _mm_mul_ps(in1[3], e3);
+
+		__m128 a0 = _mm_add_ps(m0, m1);
+		__m128 a1 = _mm_add_ps(m2, m3);
+		__m128 a2 = _mm_add_ps(a0, a1);
+
+		out[0] = a2;
+	}
+
+	{
+		__m128 e0 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 e1 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 e2 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 e3 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 m0 = _mm_mul_ps(in1[0], e0);
+		__m128 m1 = _mm_mul_ps(in1[1], e1);
+		__m128 m2 = _mm_mul_ps(in1[2], e2);
+		__m128 m3 = _mm_mul_ps(in1[3], e3);
+
+		__m128 a0 = _mm_add_ps(m0, m1);
+		__m128 a1 = _mm_add_ps(m2, m3);
+		__m128 a2 = _mm_add_ps(a0, a1);
+
+		out[1] = a2;
+	}
+
+	{
+		__m128 e0 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 e1 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 e2 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 e3 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 m0 = _mm_mul_ps(in1[0], e0);
+		__m128 m1 = _mm_mul_ps(in1[1], e1);
+		__m128 m2 = _mm_mul_ps(in1[2], e2);
+		__m128 m3 = _mm_mul_ps(in1[3], e3);
+
+		__m128 a0 = _mm_add_ps(m0, m1);
+		__m128 a1 = _mm_add_ps(m2, m3);
+		__m128 a2 = _mm_add_ps(a0, a1);
+
+		out[2] = a2;
+	}
+
+	{
+		//(__m128&)_mm_shuffle_epi32(__m128i&)in2[0], _MM_SHUFFLE(3, 3, 3, 3))
+		__m128 e0 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 e1 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 e2 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 e3 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 m0 = _mm_mul_ps(in1[0], e0);
+		__m128 m1 = _mm_mul_ps(in1[1], e1);
+		__m128 m2 = _mm_mul_ps(in1[2], e2);
+		__m128 m3 = _mm_mul_ps(in1[3], e3);
+
+		__m128 a0 = _mm_add_ps(m0, m1);
+		__m128 a1 = _mm_add_ps(m2, m3);
+		__m128 a2 = _mm_add_ps(a0, a1);
+
+		out[3] = a2;
+	}
+}
+
+GLM_FUNC_QUALIFIER void glm_mat4_transpose(glm_vec4 const in[4], glm_vec4 out[4])
+{
+	__m128 tmp0 = _mm_shuffle_ps(in[0], in[1], 0x44);
+	__m128 tmp2 = _mm_shuffle_ps(in[0], in[1], 0xEE);
+	__m128 tmp1 = _mm_shuffle_ps(in[2], in[3], 0x44);
+	__m128 tmp3 = _mm_shuffle_ps(in[2], in[3], 0xEE);
+
+	out[0] = _mm_shuffle_ps(tmp0, tmp1, 0x88);
+	out[1] = _mm_shuffle_ps(tmp0, tmp1, 0xDD);
+	out[2] = _mm_shuffle_ps(tmp2, tmp3, 0x88);
+	out[3] = _mm_shuffle_ps(tmp2, tmp3, 0xDD);
+}
+
+GLM_FUNC_QUALIFIER glm_vec4 glm_mat4_determinant_highp(glm_vec4 const in[4])
+{
+	__m128 Fac0;
+	{
+		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+		//	valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
+		//	valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac0 = _mm_sub_ps(Mul00, Mul01);
+	}
+
+	__m128 Fac1;
+	{
+		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+		//	valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
+		//	valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac1 = _mm_sub_ps(Mul00, Mul01);
+	}
+
+
+	__m128 Fac2;
+	{
+		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+		//	valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
+		//	valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac2 = _mm_sub_ps(Mul00, Mul01);
+	}
+
+	__m128 Fac3;
+	{
+		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+		//	valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
+		//	valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac3 = _mm_sub_ps(Mul00, Mul01);
+	}
+
+	__m128 Fac4;
+	{
+		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+		//	valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
+		//	valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac4 = _mm_sub_ps(Mul00, Mul01);
+	}
+
+	__m128 Fac5;
+	{
+		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+		//	valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
+		//	valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac5 = _mm_sub_ps(Mul00, Mul01);
+	}
+
+	__m128 SignA = _mm_set_ps( 1.0f,-1.0f, 1.0f,-1.0f);
+	__m128 SignB = _mm_set_ps(-1.0f, 1.0f,-1.0f, 1.0f);
+
+	// m[1][0]
+	// m[0][0]
+	// m[0][0]
+	// m[0][0]
+	__m128 Temp0 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 Vec0 = _mm_shuffle_ps(Temp0, Temp0, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// m[1][1]
+	// m[0][1]
+	// m[0][1]
+	// m[0][1]
+	__m128 Temp1 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(1, 1, 1, 1));
+	__m128 Vec1 = _mm_shuffle_ps(Temp1, Temp1, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// m[1][2]
+	// m[0][2]
+	// m[0][2]
+	// m[0][2]
+	__m128 Temp2 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(2, 2, 2, 2));
+	__m128 Vec2 = _mm_shuffle_ps(Temp2, Temp2, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// m[1][3]
+	// m[0][3]
+	// m[0][3]
+	// m[0][3]
+	__m128 Temp3 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(3, 3, 3, 3));
+	__m128 Vec3 = _mm_shuffle_ps(Temp3, Temp3, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// col0
+	// + (Vec1[0] * Fac0[0] - Vec2[0] * Fac1[0] + Vec3[0] * Fac2[0]),
+	// - (Vec1[1] * Fac0[1] - Vec2[1] * Fac1[1] + Vec3[1] * Fac2[1]),
+	// + (Vec1[2] * Fac0[2] - Vec2[2] * Fac1[2] + Vec3[2] * Fac2[2]),
+	// - (Vec1[3] * Fac0[3] - Vec2[3] * Fac1[3] + Vec3[3] * Fac2[3]),
+	__m128 Mul00 = _mm_mul_ps(Vec1, Fac0);
+	__m128 Mul01 = _mm_mul_ps(Vec2, Fac1);
+	__m128 Mul02 = _mm_mul_ps(Vec3, Fac2);
+	__m128 Sub00 = _mm_sub_ps(Mul00, Mul01);
+	__m128 Add00 = _mm_add_ps(Sub00, Mul02);
+	__m128 Inv0 = _mm_mul_ps(SignB, Add00);
+
+	// col1
+	// - (Vec0[0] * Fac0[0] - Vec2[0] * Fac3[0] + Vec3[0] * Fac4[0]),
+	// + (Vec0[0] * Fac0[1] - Vec2[1] * Fac3[1] + Vec3[1] * Fac4[1]),
+	// - (Vec0[0] * Fac0[2] - Vec2[2] * Fac3[2] + Vec3[2] * Fac4[2]),
+	// + (Vec0[0] * Fac0[3] - Vec2[3] * Fac3[3] + Vec3[3] * Fac4[3]),
+	__m128 Mul03 = _mm_mul_ps(Vec0, Fac0);
+	__m128 Mul04 = _mm_mul_ps(Vec2, Fac3);
+	__m128 Mul05 = _mm_mul_ps(Vec3, Fac4);
+	__m128 Sub01 = _mm_sub_ps(Mul03, Mul04);
+	__m128 Add01 = _mm_add_ps(Sub01, Mul05);
+	__m128 Inv1 = _mm_mul_ps(SignA, Add01);
+
+	// col2
+	// + (Vec0[0] * Fac1[0] - Vec1[0] * Fac3[0] + Vec3[0] * Fac5[0]),
+	// - (Vec0[0] * Fac1[1] - Vec1[1] * Fac3[1] + Vec3[1] * Fac5[1]),
+	// + (Vec0[0] * Fac1[2] - Vec1[2] * Fac3[2] + Vec3[2] * Fac5[2]),
+	// - (Vec0[0] * Fac1[3] - Vec1[3] * Fac3[3] + Vec3[3] * Fac5[3]),
+	__m128 Mul06 = _mm_mul_ps(Vec0, Fac1);
+	__m128 Mul07 = _mm_mul_ps(Vec1, Fac3);
+	__m128 Mul08 = _mm_mul_ps(Vec3, Fac5);
+	__m128 Sub02 = _mm_sub_ps(Mul06, Mul07);
+	__m128 Add02 = _mm_add_ps(Sub02, Mul08);
+	__m128 Inv2 = _mm_mul_ps(SignB, Add02);
+
+	// col3
+	// - (Vec1[0] * Fac2[0] - Vec1[0] * Fac4[0] + Vec2[0] * Fac5[0]),
+	// + (Vec1[0] * Fac2[1] - Vec1[1] * Fac4[1] + Vec2[1] * Fac5[1]),
+	// - (Vec1[0] * Fac2[2] - Vec1[2] * Fac4[2] + Vec2[2] * Fac5[2]),
+	// + (Vec1[0] * Fac2[3] - Vec1[3] * Fac4[3] + Vec2[3] * Fac5[3]));
+	__m128 Mul09 = _mm_mul_ps(Vec0, Fac2);
+	__m128 Mul10 = _mm_mul_ps(Vec1, Fac4);
+	__m128 Mul11 = _mm_mul_ps(Vec2, Fac5);
+	__m128 Sub03 = _mm_sub_ps(Mul09, Mul10);
+	__m128 Add03 = _mm_add_ps(Sub03, Mul11);
+	__m128 Inv3 = _mm_mul_ps(SignA, Add03);
+
+	__m128 Row0 = _mm_shuffle_ps(Inv0, Inv1, _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 Row1 = _mm_shuffle_ps(Inv2, Inv3, _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 Row2 = _mm_shuffle_ps(Row0, Row1, _MM_SHUFFLE(2, 0, 2, 0));
+
+	//	valType Determinant = m[0][0] * Inverse[0][0]
+	//						+ m[0][1] * Inverse[1][0]
+	//						+ m[0][2] * Inverse[2][0]
+	//						+ m[0][3] * Inverse[3][0];
+	__m128 Det0 = glm_vec4_dot(in[0], Row2);
+	return Det0;
+}
+
+GLM_FUNC_QUALIFIER glm_vec4 glm_mat4_determinant_lowp(glm_vec4 const m[4])
+{
+	// _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(
+
+	//T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+	//T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+	//T SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+	//T SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+	//T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+	//T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+
+	// First 2 columns
+ 	__m128 Swp2A = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[2]), _MM_SHUFFLE(0, 1, 1, 2)));
+ 	__m128 Swp3A = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[3]), _MM_SHUFFLE(3, 2, 3, 3)));
+	__m128 MulA = _mm_mul_ps(Swp2A, Swp3A);
+
+	// Second 2 columns
+	__m128 Swp2B = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[2]), _MM_SHUFFLE(3, 2, 3, 3)));
+	__m128 Swp3B = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[3]), _MM_SHUFFLE(0, 1, 1, 2)));
+	__m128 MulB = _mm_mul_ps(Swp2B, Swp3B);
+
+	// Columns subtraction
+	__m128 SubE = _mm_sub_ps(MulA, MulB);
+
+	// Last 2 rows
+	__m128 Swp2C = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[2]), _MM_SHUFFLE(0, 0, 1, 2)));
+	__m128 Swp3C = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[3]), _MM_SHUFFLE(1, 2, 0, 0)));
+	__m128 MulC = _mm_mul_ps(Swp2C, Swp3C);
+	__m128 SubF = _mm_sub_ps(_mm_movehl_ps(MulC, MulC), MulC);
+
+	//vec<4, T, Q> DetCof(
+	//	+ (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02),
+	//	- (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04),
+	//	+ (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05),
+	//	- (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05));
+
+	__m128 SubFacA = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(SubE), _MM_SHUFFLE(2, 1, 0, 0)));
+	__m128 SwpFacA = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[1]), _MM_SHUFFLE(0, 0, 0, 1)));
+	__m128 MulFacA = _mm_mul_ps(SwpFacA, SubFacA);
+
+	__m128 SubTmpB = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(0, 0, 3, 1));
+	__m128 SubFacB = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(SubTmpB), _MM_SHUFFLE(3, 1, 1, 0)));//SubF[0], SubE[3], SubE[3], SubE[1];
+	__m128 SwpFacB = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[1]), _MM_SHUFFLE(1, 1, 2, 2)));
+	__m128 MulFacB = _mm_mul_ps(SwpFacB, SubFacB);
+
+	__m128 SubRes = _mm_sub_ps(MulFacA, MulFacB);
+
+	__m128 SubTmpC = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(1, 0, 2, 2));
+	__m128 SubFacC = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(SubTmpC), _MM_SHUFFLE(3, 3, 2, 0)));
+	__m128 SwpFacC = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[1]), _MM_SHUFFLE(2, 3, 3, 3)));
+	__m128 MulFacC = _mm_mul_ps(SwpFacC, SubFacC);
+
+	__m128 AddRes = _mm_add_ps(SubRes, MulFacC);
+	__m128 DetCof = _mm_mul_ps(AddRes, _mm_setr_ps( 1.0f,-1.0f, 1.0f,-1.0f));
+
+	//return m[0][0] * DetCof[0]
+	//	 + m[0][1] * DetCof[1]
+	//	 + m[0][2] * DetCof[2]
+	//	 + m[0][3] * DetCof[3];
+
+	return glm_vec4_dot(m[0], DetCof);
+}
+
+GLM_FUNC_QUALIFIER glm_vec4 glm_mat4_determinant(glm_vec4 const m[4])
+{
+	// _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(add)
+
+	//T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+	//T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+	//T SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+	//T SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+	//T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+	//T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+
+	// First 2 columns
+ 	__m128 Swp2A = _mm_shuffle_ps(m[2], m[2], _MM_SHUFFLE(0, 1, 1, 2));
+ 	__m128 Swp3A = _mm_shuffle_ps(m[3], m[3], _MM_SHUFFLE(3, 2, 3, 3));
+	__m128 MulA = _mm_mul_ps(Swp2A, Swp3A);
+
+	// Second 2 columns
+	__m128 Swp2B = _mm_shuffle_ps(m[2], m[2], _MM_SHUFFLE(3, 2, 3, 3));
+	__m128 Swp3B = _mm_shuffle_ps(m[3], m[3], _MM_SHUFFLE(0, 1, 1, 2));
+	__m128 MulB = _mm_mul_ps(Swp2B, Swp3B);
+
+	// Columns subtraction
+	__m128 SubE = _mm_sub_ps(MulA, MulB);
+
+	// Last 2 rows
+	__m128 Swp2C = _mm_shuffle_ps(m[2], m[2], _MM_SHUFFLE(0, 0, 1, 2));
+	__m128 Swp3C = _mm_shuffle_ps(m[3], m[3], _MM_SHUFFLE(1, 2, 0, 0));
+	__m128 MulC = _mm_mul_ps(Swp2C, Swp3C);
+	__m128 SubF = _mm_sub_ps(_mm_movehl_ps(MulC, MulC), MulC);
+
+	//vec<4, T, Q> DetCof(
+	//	+ (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02),
+	//	- (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04),
+	//	+ (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05),
+	//	- (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05));
+
+	__m128 SubFacA = _mm_shuffle_ps(SubE, SubE, _MM_SHUFFLE(2, 1, 0, 0));
+	__m128 SwpFacA = _mm_shuffle_ps(m[1], m[1], _MM_SHUFFLE(0, 0, 0, 1));
+	__m128 MulFacA = _mm_mul_ps(SwpFacA, SubFacA);
+
+	__m128 SubTmpB = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(0, 0, 3, 1));
+	__m128 SubFacB = _mm_shuffle_ps(SubTmpB, SubTmpB, _MM_SHUFFLE(3, 1, 1, 0));//SubF[0], SubE[3], SubE[3], SubE[1];
+	__m128 SwpFacB = _mm_shuffle_ps(m[1], m[1], _MM_SHUFFLE(1, 1, 2, 2));
+	__m128 MulFacB = _mm_mul_ps(SwpFacB, SubFacB);
+
+	__m128 SubRes = _mm_sub_ps(MulFacA, MulFacB);
+
+	__m128 SubTmpC = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(1, 0, 2, 2));
+	__m128 SubFacC = _mm_shuffle_ps(SubTmpC, SubTmpC, _MM_SHUFFLE(3, 3, 2, 0));
+	__m128 SwpFacC = _mm_shuffle_ps(m[1], m[1], _MM_SHUFFLE(2, 3, 3, 3));
+	__m128 MulFacC = _mm_mul_ps(SwpFacC, SubFacC);
+
+	__m128 AddRes = _mm_add_ps(SubRes, MulFacC);
+	__m128 DetCof = _mm_mul_ps(AddRes, _mm_setr_ps( 1.0f,-1.0f, 1.0f,-1.0f));
+
+	//return m[0][0] * DetCof[0]
+	//	 + m[0][1] * DetCof[1]
+	//	 + m[0][2] * DetCof[2]
+	//	 + m[0][3] * DetCof[3];
+
+	return glm_vec4_dot(m[0], DetCof);
+}
+
+GLM_FUNC_QUALIFIER void glm_mat4_inverse(glm_vec4 const in[4], glm_vec4 out[4])
+{
+	__m128 Fac0;
+	{
+		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+		//	valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
+		//	valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac0 = _mm_sub_ps(Mul00, Mul01);
+	}
+
+	__m128 Fac1;
+	{
+		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+		//	valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
+		//	valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac1 = _mm_sub_ps(Mul00, Mul01);
+	}
+
+
+	__m128 Fac2;
+	{
+		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+		//	valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
+		//	valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac2 = _mm_sub_ps(Mul00, Mul01);
+	}
+
+	__m128 Fac3;
+	{
+		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+		//	valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
+		//	valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac3 = _mm_sub_ps(Mul00, Mul01);
+	}
+
+	__m128 Fac4;
+	{
+		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+		//	valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
+		//	valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac4 = _mm_sub_ps(Mul00, Mul01);
+	}
+
+	__m128 Fac5;
+	{
+		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+		//	valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
+		//	valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac5 = _mm_sub_ps(Mul00, Mul01);
+	}
+
+	__m128 SignA = _mm_set_ps( 1.0f,-1.0f, 1.0f,-1.0f);
+	__m128 SignB = _mm_set_ps(-1.0f, 1.0f,-1.0f, 1.0f);
+
+	// m[1][0]
+	// m[0][0]
+	// m[0][0]
+	// m[0][0]
+	__m128 Temp0 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 Vec0 = _mm_shuffle_ps(Temp0, Temp0, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// m[1][1]
+	// m[0][1]
+	// m[0][1]
+	// m[0][1]
+	__m128 Temp1 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(1, 1, 1, 1));
+	__m128 Vec1 = _mm_shuffle_ps(Temp1, Temp1, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// m[1][2]
+	// m[0][2]
+	// m[0][2]
+	// m[0][2]
+	__m128 Temp2 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(2, 2, 2, 2));
+	__m128 Vec2 = _mm_shuffle_ps(Temp2, Temp2, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// m[1][3]
+	// m[0][3]
+	// m[0][3]
+	// m[0][3]
+	__m128 Temp3 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(3, 3, 3, 3));
+	__m128 Vec3 = _mm_shuffle_ps(Temp3, Temp3, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// col0
+	// + (Vec1[0] * Fac0[0] - Vec2[0] * Fac1[0] + Vec3[0] * Fac2[0]),
+	// - (Vec1[1] * Fac0[1] - Vec2[1] * Fac1[1] + Vec3[1] * Fac2[1]),
+	// + (Vec1[2] * Fac0[2] - Vec2[2] * Fac1[2] + Vec3[2] * Fac2[2]),
+	// - (Vec1[3] * Fac0[3] - Vec2[3] * Fac1[3] + Vec3[3] * Fac2[3]),
+	__m128 Mul00 = _mm_mul_ps(Vec1, Fac0);
+	__m128 Mul01 = _mm_mul_ps(Vec2, Fac1);
+	__m128 Mul02 = _mm_mul_ps(Vec3, Fac2);
+	__m128 Sub00 = _mm_sub_ps(Mul00, Mul01);
+	__m128 Add00 = _mm_add_ps(Sub00, Mul02);
+	__m128 Inv0 = _mm_mul_ps(SignB, Add00);
+
+	// col1
+	// - (Vec0[0] * Fac0[0] - Vec2[0] * Fac3[0] + Vec3[0] * Fac4[0]),
+	// + (Vec0[0] * Fac0[1] - Vec2[1] * Fac3[1] + Vec3[1] * Fac4[1]),
+	// - (Vec0[0] * Fac0[2] - Vec2[2] * Fac3[2] + Vec3[2] * Fac4[2]),
+	// + (Vec0[0] * Fac0[3] - Vec2[3] * Fac3[3] + Vec3[3] * Fac4[3]),
+	__m128 Mul03 = _mm_mul_ps(Vec0, Fac0);
+	__m128 Mul04 = _mm_mul_ps(Vec2, Fac3);
+	__m128 Mul05 = _mm_mul_ps(Vec3, Fac4);
+	__m128 Sub01 = _mm_sub_ps(Mul03, Mul04);
+	__m128 Add01 = _mm_add_ps(Sub01, Mul05);
+	__m128 Inv1 = _mm_mul_ps(SignA, Add01);
+
+	// col2
+	// + (Vec0[0] * Fac1[0] - Vec1[0] * Fac3[0] + Vec3[0] * Fac5[0]),
+	// - (Vec0[0] * Fac1[1] - Vec1[1] * Fac3[1] + Vec3[1] * Fac5[1]),
+	// + (Vec0[0] * Fac1[2] - Vec1[2] * Fac3[2] + Vec3[2] * Fac5[2]),
+	// - (Vec0[0] * Fac1[3] - Vec1[3] * Fac3[3] + Vec3[3] * Fac5[3]),
+	__m128 Mul06 = _mm_mul_ps(Vec0, Fac1);
+	__m128 Mul07 = _mm_mul_ps(Vec1, Fac3);
+	__m128 Mul08 = _mm_mul_ps(Vec3, Fac5);
+	__m128 Sub02 = _mm_sub_ps(Mul06, Mul07);
+	__m128 Add02 = _mm_add_ps(Sub02, Mul08);
+	__m128 Inv2 = _mm_mul_ps(SignB, Add02);
+
+	// col3
+	// - (Vec1[0] * Fac2[0] - Vec1[0] * Fac4[0] + Vec2[0] * Fac5[0]),
+	// + (Vec1[0] * Fac2[1] - Vec1[1] * Fac4[1] + Vec2[1] * Fac5[1]),
+	// - (Vec1[0] * Fac2[2] - Vec1[2] * Fac4[2] + Vec2[2] * Fac5[2]),
+	// + (Vec1[0] * Fac2[3] - Vec1[3] * Fac4[3] + Vec2[3] * Fac5[3]));
+	__m128 Mul09 = _mm_mul_ps(Vec0, Fac2);
+	__m128 Mul10 = _mm_mul_ps(Vec1, Fac4);
+	__m128 Mul11 = _mm_mul_ps(Vec2, Fac5);
+	__m128 Sub03 = _mm_sub_ps(Mul09, Mul10);
+	__m128 Add03 = _mm_add_ps(Sub03, Mul11);
+	__m128 Inv3 = _mm_mul_ps(SignA, Add03);
+
+	__m128 Row0 = _mm_shuffle_ps(Inv0, Inv1, _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 Row1 = _mm_shuffle_ps(Inv2, Inv3, _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 Row2 = _mm_shuffle_ps(Row0, Row1, _MM_SHUFFLE(2, 0, 2, 0));
+
+	//	valType Determinant = m[0][0] * Inverse[0][0]
+	//						+ m[0][1] * Inverse[1][0]
+	//						+ m[0][2] * Inverse[2][0]
+	//						+ m[0][3] * Inverse[3][0];
+	__m128 Det0 = glm_vec4_dot(in[0], Row2);
+	__m128 Rcp0 = _mm_div_ps(_mm_set1_ps(1.0f), Det0);
+	//__m128 Rcp0 = _mm_rcp_ps(Det0);
+
+	//	Inverse /= Determinant;
+	out[0] = _mm_mul_ps(Inv0, Rcp0);
+	out[1] = _mm_mul_ps(Inv1, Rcp0);
+	out[2] = _mm_mul_ps(Inv2, Rcp0);
+	out[3] = _mm_mul_ps(Inv3, Rcp0);
+}
+
+GLM_FUNC_QUALIFIER void glm_mat4_inverse_lowp(glm_vec4 const in[4], glm_vec4 out[4])
+{
+	__m128 Fac0;
+	{
+		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+		//	valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
+		//	valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac0 = _mm_sub_ps(Mul00, Mul01);
+	}
+
+	__m128 Fac1;
+	{
+		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+		//	valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
+		//	valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac1 = _mm_sub_ps(Mul00, Mul01);
+	}
+
+
+	__m128 Fac2;
+	{
+		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+		//	valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
+		//	valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac2 = _mm_sub_ps(Mul00, Mul01);
+	}
+
+	__m128 Fac3;
+	{
+		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+		//	valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
+		//	valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac3 = _mm_sub_ps(Mul00, Mul01);
+	}
+
+	__m128 Fac4;
+	{
+		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+		//	valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
+		//	valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac4 = _mm_sub_ps(Mul00, Mul01);
+	}
+
+	__m128 Fac5;
+	{
+		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+		//	valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
+		//	valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac5 = _mm_sub_ps(Mul00, Mul01);
+	}
+
+	__m128 SignA = _mm_set_ps( 1.0f,-1.0f, 1.0f,-1.0f);
+	__m128 SignB = _mm_set_ps(-1.0f, 1.0f,-1.0f, 1.0f);
+
+	// m[1][0]
+	// m[0][0]
+	// m[0][0]
+	// m[0][0]
+	__m128 Temp0 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 Vec0 = _mm_shuffle_ps(Temp0, Temp0, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// m[1][1]
+	// m[0][1]
+	// m[0][1]
+	// m[0][1]
+	__m128 Temp1 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(1, 1, 1, 1));
+	__m128 Vec1 = _mm_shuffle_ps(Temp1, Temp1, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// m[1][2]
+	// m[0][2]
+	// m[0][2]
+	// m[0][2]
+	__m128 Temp2 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(2, 2, 2, 2));
+	__m128 Vec2 = _mm_shuffle_ps(Temp2, Temp2, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// m[1][3]
+	// m[0][3]
+	// m[0][3]
+	// m[0][3]
+	__m128 Temp3 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(3, 3, 3, 3));
+	__m128 Vec3 = _mm_shuffle_ps(Temp3, Temp3, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// col0
+	// + (Vec1[0] * Fac0[0] - Vec2[0] * Fac1[0] + Vec3[0] * Fac2[0]),
+	// - (Vec1[1] * Fac0[1] - Vec2[1] * Fac1[1] + Vec3[1] * Fac2[1]),
+	// + (Vec1[2] * Fac0[2] - Vec2[2] * Fac1[2] + Vec3[2] * Fac2[2]),
+	// - (Vec1[3] * Fac0[3] - Vec2[3] * Fac1[3] + Vec3[3] * Fac2[3]),
+	__m128 Mul00 = _mm_mul_ps(Vec1, Fac0);
+	__m128 Mul01 = _mm_mul_ps(Vec2, Fac1);
+	__m128 Mul02 = _mm_mul_ps(Vec3, Fac2);
+	__m128 Sub00 = _mm_sub_ps(Mul00, Mul01);
+	__m128 Add00 = _mm_add_ps(Sub00, Mul02);
+	__m128 Inv0 = _mm_mul_ps(SignB, Add00);
+
+	// col1
+	// - (Vec0[0] * Fac0[0] - Vec2[0] * Fac3[0] + Vec3[0] * Fac4[0]),
+	// + (Vec0[0] * Fac0[1] - Vec2[1] * Fac3[1] + Vec3[1] * Fac4[1]),
+	// - (Vec0[0] * Fac0[2] - Vec2[2] * Fac3[2] + Vec3[2] * Fac4[2]),
+	// + (Vec0[0] * Fac0[3] - Vec2[3] * Fac3[3] + Vec3[3] * Fac4[3]),
+	__m128 Mul03 = _mm_mul_ps(Vec0, Fac0);
+	__m128 Mul04 = _mm_mul_ps(Vec2, Fac3);
+	__m128 Mul05 = _mm_mul_ps(Vec3, Fac4);
+	__m128 Sub01 = _mm_sub_ps(Mul03, Mul04);
+	__m128 Add01 = _mm_add_ps(Sub01, Mul05);
+	__m128 Inv1 = _mm_mul_ps(SignA, Add01);
+
+	// col2
+	// + (Vec0[0] * Fac1[0] - Vec1[0] * Fac3[0] + Vec3[0] * Fac5[0]),
+	// - (Vec0[0] * Fac1[1] - Vec1[1] * Fac3[1] + Vec3[1] * Fac5[1]),
+	// + (Vec0[0] * Fac1[2] - Vec1[2] * Fac3[2] + Vec3[2] * Fac5[2]),
+	// - (Vec0[0] * Fac1[3] - Vec1[3] * Fac3[3] + Vec3[3] * Fac5[3]),
+	__m128 Mul06 = _mm_mul_ps(Vec0, Fac1);
+	__m128 Mul07 = _mm_mul_ps(Vec1, Fac3);
+	__m128 Mul08 = _mm_mul_ps(Vec3, Fac5);
+	__m128 Sub02 = _mm_sub_ps(Mul06, Mul07);
+	__m128 Add02 = _mm_add_ps(Sub02, Mul08);
+	__m128 Inv2 = _mm_mul_ps(SignB, Add02);
+
+	// col3
+	// - (Vec1[0] * Fac2[0] - Vec1[0] * Fac4[0] + Vec2[0] * Fac5[0]),
+	// + (Vec1[0] * Fac2[1] - Vec1[1] * Fac4[1] + Vec2[1] * Fac5[1]),
+	// - (Vec1[0] * Fac2[2] - Vec1[2] * Fac4[2] + Vec2[2] * Fac5[2]),
+	// + (Vec1[0] * Fac2[3] - Vec1[3] * Fac4[3] + Vec2[3] * Fac5[3]));
+	__m128 Mul09 = _mm_mul_ps(Vec0, Fac2);
+	__m128 Mul10 = _mm_mul_ps(Vec1, Fac4);
+	__m128 Mul11 = _mm_mul_ps(Vec2, Fac5);
+	__m128 Sub03 = _mm_sub_ps(Mul09, Mul10);
+	__m128 Add03 = _mm_add_ps(Sub03, Mul11);
+	__m128 Inv3 = _mm_mul_ps(SignA, Add03);
+
+	__m128 Row0 = _mm_shuffle_ps(Inv0, Inv1, _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 Row1 = _mm_shuffle_ps(Inv2, Inv3, _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 Row2 = _mm_shuffle_ps(Row0, Row1, _MM_SHUFFLE(2, 0, 2, 0));
+
+	//	valType Determinant = m[0][0] * Inverse[0][0]
+	//						+ m[0][1] * Inverse[1][0]
+	//						+ m[0][2] * Inverse[2][0]
+	//						+ m[0][3] * Inverse[3][0];
+	__m128 Det0 = glm_vec4_dot(in[0], Row2);
+	__m128 Rcp0 = _mm_rcp_ps(Det0);
+	//__m128 Rcp0 = _mm_div_ps(one, Det0);
+	//	Inverse /= Determinant;
+	out[0] = _mm_mul_ps(Inv0, Rcp0);
+	out[1] = _mm_mul_ps(Inv1, Rcp0);
+	out[2] = _mm_mul_ps(Inv2, Rcp0);
+	out[3] = _mm_mul_ps(Inv3, Rcp0);
+}
+/*
+GLM_FUNC_QUALIFIER void glm_mat4_rotate(__m128 const in[4], float Angle, float const v[3], __m128 out[4])
+{
+	float a = glm::radians(Angle);
+	float c = cos(a);
+	float s = sin(a);
+
+	glm::vec4 AxisA(v[0], v[1], v[2], float(0));
+	__m128 AxisB = _mm_set_ps(AxisA.w, AxisA.z, AxisA.y, AxisA.x);
+	__m128 AxisC = detail::sse_nrm_ps(AxisB);
+
+	__m128 Cos0 = _mm_set_ss(c);
+	__m128 CosA = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 Sin0 = _mm_set_ss(s);
+	__m128 SinA = _mm_shuffle_ps(Sin0, Sin0, _MM_SHUFFLE(0, 0, 0, 0));
+
+	// vec<3, T, Q> temp = (valType(1) - c) * axis;
+	__m128 Temp0 = _mm_sub_ps(one, CosA);
+	__m128 Temp1 = _mm_mul_ps(Temp0, AxisC);
+
+	//Rotate[0][0] = c + temp[0] * axis[0];
+	//Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2];
+	//Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1];
+	__m128 Axis0 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 TmpA0 = _mm_mul_ps(Axis0, AxisC);
+	__m128 CosA0 = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(1, 1, 1, 0));
+	__m128 TmpA1 = _mm_add_ps(CosA0, TmpA0);
+	__m128 SinA0 = SinA;//_mm_set_ps(0.0f, s, -s, 0.0f);
+	__m128 TmpA2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(3, 1, 2, 3));
+	__m128 TmpA3 = _mm_mul_ps(SinA0, TmpA2);
+	__m128 TmpA4 = _mm_add_ps(TmpA1, TmpA3);
+
+	//Rotate[1][0] = 0 + temp[1] * axis[0] - s * axis[2];
+	//Rotate[1][1] = c + temp[1] * axis[1];
+	//Rotate[1][2] = 0 + temp[1] * axis[2] + s * axis[0];
+	__m128 Axis1 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(1, 1, 1, 1));
+	__m128 TmpB0 = _mm_mul_ps(Axis1, AxisC);
+	__m128 CosA1 = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(1, 1, 0, 1));
+	__m128 TmpB1 = _mm_add_ps(CosA1, TmpB0);
+	__m128 SinB0 = SinA;//_mm_set_ps(-s, 0.0f, s, 0.0f);
+	__m128 TmpB2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(3, 0, 3, 2));
+	__m128 TmpB3 = _mm_mul_ps(SinA0, TmpB2);
+	__m128 TmpB4 = _mm_add_ps(TmpB1, TmpB3);
+
+	//Rotate[2][0] = 0 + temp[2] * axis[0] + s * axis[1];
+	//Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0];
+	//Rotate[2][2] = c + temp[2] * axis[2];
+	__m128 Axis2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(2, 2, 2, 2));
+	__m128 TmpC0 = _mm_mul_ps(Axis2, AxisC);
+	__m128 CosA2 = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(1, 0, 1, 1));
+	__m128 TmpC1 = _mm_add_ps(CosA2, TmpC0);
+	__m128 SinC0 = SinA;//_mm_set_ps(s, -s, 0.0f, 0.0f);
+	__m128 TmpC2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(3, 3, 0, 1));
+	__m128 TmpC3 = _mm_mul_ps(SinA0, TmpC2);
+	__m128 TmpC4 = _mm_add_ps(TmpC1, TmpC3);
+
+	__m128 Result[4];
+	Result[0] = TmpA4;
+	Result[1] = TmpB4;
+	Result[2] = TmpC4;
+	Result[3] = _mm_set_ps(1, 0, 0, 0);
+
+	//mat<4, 4, valType> Result;
+	//Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2];
+	//Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2];
+	//Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2];
+	//Result[3] = m[3];
+	//return Result;
+	sse_mul_ps(in, Result, out);
+}
+*/
+GLM_FUNC_QUALIFIER void glm_mat4_outerProduct(__m128 const& c, __m128 const& r, __m128 out[4])
+{
+	out[0] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(0, 0, 0, 0)));
+	out[1] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(1, 1, 1, 1)));
+	out[2] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(2, 2, 2, 2)));
+	out[3] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(3, 3, 3, 3)));
+}
+
+#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
diff --git a/engine/inc/glm/simd/packing.h b/engine/inc/glm/simd/packing.h
new file mode 100644
index 00000000..609163eb
--- /dev/null
+++ b/engine/inc/glm/simd/packing.h
@@ -0,0 +1,8 @@
+/// @ref simd
+/// @file glm/simd/packing.h
+
+#pragma once
+
+#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
diff --git a/engine/inc/glm/simd/platform.h b/engine/inc/glm/simd/platform.h
new file mode 100644
index 00000000..717e9aab
--- /dev/null
+++ b/engine/inc/glm/simd/platform.h
@@ -0,0 +1,357 @@
+#pragma once
+
+///////////////////////////////////////////////////////////////////////////////////
+// Platform
+
+#define GLM_PLATFORM_UNKNOWN		0x00000000
+#define GLM_PLATFORM_WINDOWS		0x00010000
+#define GLM_PLATFORM_LINUX			0x00020000
+#define GLM_PLATFORM_APPLE			0x00040000
+//#define GLM_PLATFORM_IOS			0x00080000
+#define GLM_PLATFORM_ANDROID		0x00100000
+#define GLM_PLATFORM_CHROME_NACL	0x00200000
+#define GLM_PLATFORM_UNIX			0x00400000
+#define GLM_PLATFORM_QNXNTO			0x00800000
+#define GLM_PLATFORM_WINCE			0x01000000
+#define GLM_PLATFORM_CYGWIN			0x02000000
+
+#ifdef GLM_FORCE_PLATFORM_UNKNOWN
+#	define GLM_PLATFORM GLM_PLATFORM_UNKNOWN
+#elif defined(__CYGWIN__)
+#	define GLM_PLATFORM GLM_PLATFORM_CYGWIN
+#elif defined(__QNXNTO__)
+#	define GLM_PLATFORM GLM_PLATFORM_QNXNTO
+#elif defined(__APPLE__)
+#	define GLM_PLATFORM GLM_PLATFORM_APPLE
+#elif defined(WINCE)
+#	define GLM_PLATFORM GLM_PLATFORM_WINCE
+#elif defined(_WIN32)
+#	define GLM_PLATFORM GLM_PLATFORM_WINDOWS
+#elif defined(__native_client__)
+#	define GLM_PLATFORM GLM_PLATFORM_CHROME_NACL
+#elif defined(__ANDROID__)
+#	define GLM_PLATFORM GLM_PLATFORM_ANDROID
+#elif defined(__linux)
+#	define GLM_PLATFORM GLM_PLATFORM_LINUX
+#elif defined(__unix)
+#	define GLM_PLATFORM GLM_PLATFORM_UNIX
+#else
+#	define GLM_PLATFORM GLM_PLATFORM_UNKNOWN
+#endif//
+
+///////////////////////////////////////////////////////////////////////////////////
+// Compiler
+
+#define GLM_COMPILER_UNKNOWN		0x00000000
+
+// Intel
+#define GLM_COMPILER_INTEL			0x00100000
+#define GLM_COMPILER_INTEL14		0x00100040
+#define GLM_COMPILER_INTEL15		0x00100050
+#define GLM_COMPILER_INTEL16		0x00100060
+#define GLM_COMPILER_INTEL17		0x00100070
+
+// Visual C++ defines
+#define GLM_COMPILER_VC				0x01000000
+#define GLM_COMPILER_VC12			0x01000001
+#define GLM_COMPILER_VC14			0x01000002
+#define GLM_COMPILER_VC15			0x01000003
+#define GLM_COMPILER_VC15_3			0x01000004
+#define GLM_COMPILER_VC15_5			0x01000005
+#define GLM_COMPILER_VC15_6			0x01000006
+#define GLM_COMPILER_VC15_7			0x01000007
+
+// GCC defines
+#define GLM_COMPILER_GCC			0x02000000
+#define GLM_COMPILER_GCC46			0x020000D0
+#define GLM_COMPILER_GCC47			0x020000E0
+#define GLM_COMPILER_GCC48			0x020000F0
+#define GLM_COMPILER_GCC49			0x02000100
+#define GLM_COMPILER_GCC5			0x02000200
+#define GLM_COMPILER_GCC6			0x02000300
+#define GLM_COMPILER_GCC7			0x02000400
+#define GLM_COMPILER_GCC8			0x02000500
+
+// CUDA
+#define GLM_COMPILER_CUDA			0x10000000
+#define GLM_COMPILER_CUDA70			0x100000A0
+#define GLM_COMPILER_CUDA75			0x100000B0
+#define GLM_COMPILER_CUDA80			0x100000C0
+
+// Clang
+#define GLM_COMPILER_CLANG			0x20000000
+#define GLM_COMPILER_CLANG34		0x20000050
+#define GLM_COMPILER_CLANG35		0x20000060
+#define GLM_COMPILER_CLANG36		0x20000070
+#define GLM_COMPILER_CLANG37		0x20000080
+#define GLM_COMPILER_CLANG38		0x20000090
+#define GLM_COMPILER_CLANG39		0x200000A0
+#define GLM_COMPILER_CLANG40		0x200000B0
+#define GLM_COMPILER_CLANG41		0x200000C0
+#define GLM_COMPILER_CLANG42		0x200000D0
+
+// Build model
+#define GLM_MODEL_32				0x00000010
+#define GLM_MODEL_64				0x00000020
+
+// Force generic C++ compiler
+#ifdef GLM_FORCE_COMPILER_UNKNOWN
+#	define GLM_COMPILER GLM_COMPILER_UNKNOWN
+
+#elif defined(__INTEL_COMPILER)
+#	if (__INTEL_COMPILER < 1400)
+#		error "GLM requires ICC 2013 SP1 or newer"
+#	elif __INTEL_COMPILER == 1400
+#		define GLM_COMPILER GLM_COMPILER_INTEL14
+#	elif __INTEL_COMPILER == 1500
+#		define GLM_COMPILER GLM_COMPILER_INTEL15
+#	elif __INTEL_COMPILER == 1600
+#		define GLM_COMPILER GLM_COMPILER_INTEL16
+#	elif __INTEL_COMPILER >= 1700
+#		define GLM_COMPILER GLM_COMPILER_INTEL17
+#	endif
+
+// CUDA
+#elif defined(__CUDACC__)
+#	if !defined(CUDA_VERSION) && !defined(GLM_FORCE_CUDA)
+#		include <cuda.h>  // make sure version is defined since nvcc does not define it itself!
+#	endif
+#	if CUDA_VERSION < 7000
+#		error "GLM requires CUDA 7.0 or higher"
+#	elif (CUDA_VERSION >= 7000 && CUDA_VERSION < 7500)
+#		define GLM_COMPILER GLM_COMPILER_CUDA70
+#	elif (CUDA_VERSION >= 7500 && CUDA_VERSION < 8000)
+#		define GLM_COMPILER GLM_COMPILER_CUDA75
+#	elif (CUDA_VERSION >= 8000)
+#		define GLM_COMPILER GLM_COMPILER_CUDA80
+#	endif
+
+// Clang
+#elif defined(__clang__)
+#	if defined(__apple_build_version__)
+#		if (__clang_major__ < 6)
+#			error "GLM requires Clang 3.4 / Apple Clang 6.0 or higher"
+#		elif __clang_major__ == 6 && __clang_minor__ == 0
+#			define GLM_COMPILER GLM_COMPILER_CLANG35
+#		elif __clang_major__ == 6 && __clang_minor__ >= 1
+#			define GLM_COMPILER GLM_COMPILER_CLANG36
+#		elif __clang_major__ >= 7
+#			define GLM_COMPILER GLM_COMPILER_CLANG37
+#		endif
+#	else
+#		if ((__clang_major__ == 3) && (__clang_minor__ < 4)) || (__clang_major__ < 3)
+#			error "GLM requires Clang 3.4 or higher"
+#		elif __clang_major__ == 3 && __clang_minor__ == 4
+#			define GLM_COMPILER GLM_COMPILER_CLANG34
+#		elif __clang_major__ == 3 && __clang_minor__ == 5
+#			define GLM_COMPILER GLM_COMPILER_CLANG35
+#		elif __clang_major__ == 3 && __clang_minor__ == 6
+#			define GLM_COMPILER GLM_COMPILER_CLANG36
+#		elif __clang_major__ == 3 && __clang_minor__ == 7
+#			define GLM_COMPILER GLM_COMPILER_CLANG37
+#		elif __clang_major__ == 3 && __clang_minor__ == 8
+#			define GLM_COMPILER GLM_COMPILER_CLANG38
+#		elif __clang_major__ == 3 && __clang_minor__ >= 9
+#			define GLM_COMPILER GLM_COMPILER_CLANG39
+#		elif __clang_major__ == 4 && __clang_minor__ == 0
+#			define GLM_COMPILER GLM_COMPILER_CLANG40
+#		elif __clang_major__ == 4 && __clang_minor__ == 1
+#			define GLM_COMPILER GLM_COMPILER_CLANG41
+#		elif __clang_major__ == 4 && __clang_minor__ >= 2
+#			define GLM_COMPILER GLM_COMPILER_CLANG42
+#		elif __clang_major__ >= 4
+#			define GLM_COMPILER GLM_COMPILER_CLANG42
+#		endif
+#	endif
+
+// Visual C++
+#elif defined(_MSC_VER)
+#	if _MSC_VER < 1800
+#		error "GLM requires Visual C++ 12 - 2013 or higher"
+#	elif _MSC_VER == 1800
+#		define GLM_COMPILER GLM_COMPILER_VC12
+#	elif _MSC_VER == 1900
+#		define GLM_COMPILER GLM_COMPILER_VC14
+#	elif _MSC_VER == 1910
+#		define GLM_COMPILER GLM_COMPILER_VC15
+#	elif _MSC_VER == 1911
+#		define GLM_COMPILER GLM_COMPILER_VC15_3
+#	elif _MSC_VER == 1912
+#		define GLM_COMPILER GLM_COMPILER_VC15_5
+#	elif _MSC_VER == 1913
+#		define GLM_COMPILER GLM_COMPILER_VC15_6
+#	elif _MSC_VER >= 1914
+#		define GLM_COMPILER GLM_COMPILER_VC15_7
+#	endif//_MSC_VER
+
+// G++
+#elif defined(__GNUC__) || defined(__MINGW32__)
+#	if ((__GNUC__ == 4) && (__GNUC_MINOR__ < 6)) || (__GNUC__ < 4)
+#		error "GLM requires GCC 4.7 or higher"
+#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 6)
+#		define GLM_COMPILER (GLM_COMPILER_GCC46)
+#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 7)
+#		define GLM_COMPILER (GLM_COMPILER_GCC47)
+#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 8)
+#		define GLM_COMPILER (GLM_COMPILER_GCC48)
+#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)
+#		define GLM_COMPILER (GLM_COMPILER_GCC49)
+#	elif (__GNUC__ == 5)
+#		define GLM_COMPILER (GLM_COMPILER_GCC5)
+#	elif (__GNUC__ == 6)
+#		define GLM_COMPILER (GLM_COMPILER_GCC6)
+#	elif (__GNUC__ == 7)
+#		define GLM_COMPILER (GLM_COMPILER_GCC7)
+#	elif (__GNUC__ >= 8)
+#		define GLM_COMPILER (GLM_COMPILER_GCC8)
+#	endif
+
+#else
+#	define GLM_COMPILER GLM_COMPILER_UNKNOWN
+#endif
+
+#ifndef GLM_COMPILER
+#	error "GLM_COMPILER undefined, your compiler may not be supported by GLM. Add #define GLM_COMPILER 0 to ignore this message."
+#endif//GLM_COMPILER
+
+///////////////////////////////////////////////////////////////////////////////////
+// Instruction sets
+
+// User defines: GLM_FORCE_PURE GLM_FORCE_SSE2 GLM_FORCE_SSE3 GLM_FORCE_AVX GLM_FORCE_AVX2 GLM_FORCE_AVX2
+
+#define GLM_ARCH_MIPS_BIT	(0x10000000)
+#define GLM_ARCH_PPC_BIT	(0x20000000)
+#define GLM_ARCH_ARM_BIT	(0x40000000)
+#define GLM_ARCH_X86_BIT	(0x80000000)
+
+#define GLM_ARCH_SIMD_BIT	(0x00001000)
+
+#define GLM_ARCH_NEON_BIT	(0x00000001)
+#define GLM_ARCH_SSE_BIT	(0x00000002)
+#define GLM_ARCH_SSE2_BIT	(0x00000004)
+#define GLM_ARCH_SSE3_BIT	(0x00000008)
+#define GLM_ARCH_SSSE3_BIT	(0x00000010)
+#define GLM_ARCH_SSE41_BIT	(0x00000020)
+#define GLM_ARCH_SSE42_BIT	(0x00000040)
+#define GLM_ARCH_AVX_BIT	(0x00000080)
+#define GLM_ARCH_AVX2_BIT	(0x00000100)
+
+#define GLM_ARCH_UNKNOWN	(0)
+#define GLM_ARCH_X86		(GLM_ARCH_X86_BIT)
+#define GLM_ARCH_SSE		(GLM_ARCH_SSE_BIT | GLM_ARCH_SIMD_BIT | GLM_ARCH_X86)
+#define GLM_ARCH_SSE2		(GLM_ARCH_SSE2_BIT | GLM_ARCH_SSE)
+#define GLM_ARCH_SSE3		(GLM_ARCH_SSE3_BIT | GLM_ARCH_SSE2)
+#define GLM_ARCH_SSSE3		(GLM_ARCH_SSSE3_BIT | GLM_ARCH_SSE3)
+#define GLM_ARCH_SSE41		(GLM_ARCH_SSE41_BIT | GLM_ARCH_SSSE3)
+#define GLM_ARCH_SSE42		(GLM_ARCH_SSE42_BIT | GLM_ARCH_SSE41)
+#define GLM_ARCH_AVX		(GLM_ARCH_AVX_BIT | GLM_ARCH_SSE42)
+#define GLM_ARCH_AVX2		(GLM_ARCH_AVX2_BIT | GLM_ARCH_AVX)
+#define GLM_ARCH_ARM		(GLM_ARCH_ARM_BIT)
+#define GLM_ARCH_NEON		(GLM_ARCH_NEON_BIT | GLM_ARCH_SIMD_BIT | GLM_ARCH_ARM)
+#define GLM_ARCH_MIPS		(GLM_ARCH_MIPS_BIT)
+#define GLM_ARCH_PPC		(GLM_ARCH_PPC_BIT)
+
+#ifdef GLM_FORCE_ARCH_UNKNOWN
+#	define GLM_ARCH GLM_ARCH_UNKNOWN
+#elif defined(GLM_FORCE_PURE) || defined(GLM_FORCE_XYZW_ONLY)
+#	if defined(__x86_64__) || defined(_M_X64) || defined(_M_IX86) || defined(__i386__)
+#		define GLM_ARCH (GLM_ARCH_X86)
+#	elif defined(__arm__ ) || defined(_M_ARM)
+#		define GLM_ARCH (GLM_ARCH_ARM)
+#	elif defined(__powerpc__ ) || defined(_M_PPC)
+#		define GLM_ARCH (GLM_ARCH_PPC)
+#	elif defined(__mips__ )
+#		define GLM_ARCH (GLM_ARCH_MIPS)
+#	else
+#		define GLM_ARCH (GLM_ARCH_UNKNOWN)
+#	endif
+#elif defined(GLM_FORCE_NEON)
+#	define GLM_ARCH (GLM_ARCH_NEON)
+#elif defined(GLM_FORCE_AVX2)
+#	define GLM_ARCH (GLM_ARCH_AVX2)
+#elif defined(GLM_FORCE_AVX)
+#	define GLM_ARCH (GLM_ARCH_AVX)
+#elif defined(GLM_FORCE_SSE42)
+#	define GLM_ARCH (GLM_ARCH_SSE42)
+#elif defined(GLM_FORCE_SSE41)
+#	define GLM_ARCH (GLM_ARCH_SSE41)
+#elif defined(GLM_FORCE_SSSE3)
+#	define GLM_ARCH (GLM_ARCH_SSSE3)
+#elif defined(GLM_FORCE_SSE3)
+#	define GLM_ARCH (GLM_ARCH_SSE3)
+#elif defined(GLM_FORCE_SSE2)
+#	define GLM_ARCH (GLM_ARCH_SSE2)
+#elif defined(GLM_FORCE_SSE)
+#	define GLM_ARCH (GLM_ARCH_SSE)
+#else
+#	if defined(__AVX2__)
+#		define GLM_ARCH (GLM_ARCH_AVX2)
+#	elif defined(__AVX__)
+#		define GLM_ARCH (GLM_ARCH_AVX)
+#	elif defined(__SSE4_2__)
+#		define GLM_ARCH (GLM_ARCH_SSE42)
+#	elif defined(__SSE4_1__)
+#		define GLM_ARCH (GLM_ARCH_SSE41)
+#	elif defined(__SSSE3__)
+#		define GLM_ARCH (GLM_ARCH_SSSE3)
+#	elif defined(__SSE3__)
+#		define GLM_ARCH (GLM_ARCH_SSE3)
+#	elif defined(__SSE2__) || defined(__x86_64__) || defined(_M_X64) || defined(_M_IX86_FP)
+#		define GLM_ARCH (GLM_ARCH_SSE2)
+#	elif defined(__i386__)
+#		define GLM_ARCH (GLM_ARCH_X86)
+#	elif defined(__ARM_NEON)
+#		define GLM_ARCH (GLM_ARCH_ARM | GLM_ARCH_NEON)
+#	elif defined(__arm__ ) || defined(_M_ARM)
+#		define GLM_ARCH (GLM_ARCH_ARM)
+#	elif defined(__mips__ )
+#		define GLM_ARCH (GLM_ARCH_MIPS)
+#	elif defined(__powerpc__ ) || defined(_M_PPC)
+#		define GLM_ARCH (GLM_ARCH_PPC)
+#	else
+#		define GLM_ARCH (GLM_ARCH_UNKNOWN)
+#	endif
+#endif
+
+#if GLM_ARCH & GLM_ARCH_AVX2_BIT
+#	include <immintrin.h>
+#elif GLM_ARCH & GLM_ARCH_AVX_BIT
+#	include <immintrin.h>
+#elif GLM_ARCH & GLM_ARCH_SSE42_BIT
+#	if GLM_COMPILER & GLM_COMPILER_CLANG
+#		include <popcntintrin.h>
+#	endif
+#	include <nmmintrin.h>
+#elif GLM_ARCH & GLM_ARCH_SSE41_BIT
+#	include <smmintrin.h>
+#elif GLM_ARCH & GLM_ARCH_SSSE3_BIT
+#	include <tmmintrin.h>
+#elif GLM_ARCH & GLM_ARCH_SSE3_BIT
+#	include <pmmintrin.h>
+#elif GLM_ARCH & GLM_ARCH_SSE2_BIT
+#	include <emmintrin.h>
+#endif//GLM_ARCH
+
+#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+	typedef __m128			glm_f32vec4;
+	typedef __m128i			glm_i32vec4;
+	typedef __m128i			glm_u32vec4;
+	typedef __m128d			glm_f64vec2;
+	typedef __m128i			glm_i64vec2;
+	typedef __m128i			glm_u64vec2;
+
+	typedef glm_f32vec4		glm_vec4;
+	typedef glm_i32vec4		glm_ivec4;
+	typedef glm_u32vec4		glm_uvec4;
+	typedef glm_f64vec2		glm_dvec2;
+#endif
+
+#if GLM_ARCH & GLM_ARCH_AVX_BIT
+	typedef __m256d			glm_f64vec4;
+	typedef glm_f64vec4		glm_dvec4;
+#endif
+
+#if GLM_ARCH & GLM_ARCH_AVX2_BIT
+	typedef __m256i			glm_i64vec4;
+	typedef __m256i			glm_u64vec4;
+#endif
diff --git a/engine/inc/glm/simd/trigonometric.h b/engine/inc/glm/simd/trigonometric.h
new file mode 100644
index 00000000..739b796e
--- /dev/null
+++ b/engine/inc/glm/simd/trigonometric.h
@@ -0,0 +1,9 @@
+/// @ref simd
+/// @file glm/simd/trigonometric.h
+
+#pragma once
+
+#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
+
diff --git a/engine/inc/glm/simd/vector_relational.h b/engine/inc/glm/simd/vector_relational.h
new file mode 100644
index 00000000..f7385e97
--- /dev/null
+++ b/engine/inc/glm/simd/vector_relational.h
@@ -0,0 +1,8 @@
+/// @ref simd
+/// @file glm/simd/vector_relational.h
+
+#pragma once
+
+#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
diff --git a/engine/inc/glm/trigonometric.hpp b/engine/inc/glm/trigonometric.hpp
new file mode 100644
index 00000000..fcf07f89
--- /dev/null
+++ b/engine/inc/glm/trigonometric.hpp
@@ -0,0 +1,210 @@
+/// @ref core
+/// @file glm/trigonometric.hpp
+///
+/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+///
+/// @defgroup core_func_trigonometric Angle and Trigonometry Functions
+/// @ingroup core
+///
+/// Function parameters specified as angle are assumed to be in units of radians.
+/// In no case will any of these functions result in a divide by zero error. If
+/// the divisor of a ratio is 0, then results will be undefined.
+///
+/// These all operate component-wise. The description is per component.
+///
+/// Include <glm/trigonometric.hpp> to use these core features.
+///
+/// @see ext_vector_trigonometric
+
+#pragma once
+
+#include "detail/setup.hpp"
+#include "detail/qualifier.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_func_trigonometric
+	/// @{
+
+	/// Converts degrees to radians and returns the result.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/radians.xml">GLSL radians man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> radians(vec<L, T, Q> const& degrees);
+
+	/// Converts radians to degrees and returns the result.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/degrees.xml">GLSL degrees man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> degrees(vec<L, T, Q> const& radians);
+
+	/// The standard trigonometric sine function.
+	/// The values returned by this function will range from [-1, 1].
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sin.xml">GLSL sin man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> sin(vec<L, T, Q> const& angle);
+
+	/// The standard trigonometric cosine function.
+	/// The values returned by this function will range from [-1, 1].
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cos.xml">GLSL cos man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> cos(vec<L, T, Q> const& angle);
+
+	/// The standard trigonometric tangent function.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/tan.xml">GLSL tan man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> tan(vec<L, T, Q> const& angle);
+
+	/// Arc sine. Returns an angle whose sine is x.
+	/// The range of values returned by this function is [-PI/2, PI/2].
+	/// Results are undefined if |x| > 1.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/asin.xml">GLSL asin man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> asin(vec<L, T, Q> const& x);
+
+	/// Arc cosine. Returns an angle whose sine is x.
+	/// The range of values returned by this function is [0, PI].
+	/// Results are undefined if |x| > 1.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/acos.xml">GLSL acos man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> acos(vec<L, T, Q> const& x);
+
+	/// Arc tangent. Returns an angle whose tangent is y/x.
+	/// The signs of x and y are used to determine what
+	/// quadrant the angle is in. The range of values returned
+	/// by this function is [-PI, PI]. Results are undefined
+	/// if x and y are both 0.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atan.xml">GLSL atan man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> atan(vec<L, T, Q> const& y, vec<L, T, Q> const& x);
+
+	/// Arc tangent. Returns an angle whose tangent is y_over_x.
+	/// The range of values returned by this function is [-PI/2, PI/2].
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atan.xml">GLSL atan man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> atan(vec<L, T, Q> const& y_over_x);
+
+	/// Returns the hyperbolic sine function, (exp(x) - exp(-x)) / 2
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sinh.xml">GLSL sinh man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> sinh(vec<L, T, Q> const& angle);
+
+	/// Returns the hyperbolic cosine function, (exp(x) + exp(-x)) / 2
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cosh.xml">GLSL cosh man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> cosh(vec<L, T, Q> const& angle);
+
+	/// Returns the hyperbolic tangent function, sinh(angle) / cosh(angle)
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/tanh.xml">GLSL tanh man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> tanh(vec<L, T, Q> const& angle);
+
+	/// Arc hyperbolic sine; returns the inverse of sinh.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/asinh.xml">GLSL asinh man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> asinh(vec<L, T, Q> const& x);
+
+	/// Arc hyperbolic cosine; returns the non-negative inverse
+	/// of cosh. Results are undefined if x < 1.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/acosh.xml">GLSL acosh man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> acosh(vec<L, T, Q> const& x);
+
+	/// Arc hyperbolic tangent; returns the inverse of tanh.
+	/// Results are undefined if abs(x) >= 1.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atanh.xml">GLSL atanh man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> atanh(vec<L, T, Q> const& x);
+
+	/// @}
+}//namespace glm
+
+#include "detail/func_trigonometric.inl"
diff --git a/engine/inc/glm/vec2.hpp b/engine/inc/glm/vec2.hpp
new file mode 100644
index 00000000..be768bf5
--- /dev/null
+++ b/engine/inc/glm/vec2.hpp
@@ -0,0 +1,14 @@
+/// @ref core
+/// @file glm/vec2.hpp
+
+#pragma once
+#include "./ext/vector_bool2.hpp"
+#include "./ext/vector_bool2_precision.hpp"
+#include "./ext/vector_float2.hpp"
+#include "./ext/vector_float2_precision.hpp"
+#include "./ext/vector_double2.hpp"
+#include "./ext/vector_double2_precision.hpp"
+#include "./ext/vector_int2.hpp"
+#include "./ext/vector_int2_precision.hpp"
+#include "./ext/vector_uint2.hpp"
+#include "./ext/vector_uint2_precision.hpp"
diff --git a/engine/inc/glm/vec3.hpp b/engine/inc/glm/vec3.hpp
new file mode 100644
index 00000000..f5707223
--- /dev/null
+++ b/engine/inc/glm/vec3.hpp
@@ -0,0 +1,14 @@
+/// @ref core
+/// @file glm/vec3.hpp
+
+#pragma once
+#include "./ext/vector_bool3.hpp"
+#include "./ext/vector_bool3_precision.hpp"
+#include "./ext/vector_float3.hpp"
+#include "./ext/vector_float3_precision.hpp"
+#include "./ext/vector_double3.hpp"
+#include "./ext/vector_double3_precision.hpp"
+#include "./ext/vector_int3.hpp"
+#include "./ext/vector_int3_precision.hpp"
+#include "./ext/vector_uint3.hpp"
+#include "./ext/vector_uint3_precision.hpp"
diff --git a/engine/inc/glm/vec4.hpp b/engine/inc/glm/vec4.hpp
new file mode 100644
index 00000000..91170207
--- /dev/null
+++ b/engine/inc/glm/vec4.hpp
@@ -0,0 +1,15 @@
+/// @ref core
+/// @file glm/vec4.hpp
+
+#pragma once
+#include "./ext/vector_bool4.hpp"
+#include "./ext/vector_bool4_precision.hpp"
+#include "./ext/vector_float4.hpp"
+#include "./ext/vector_float4_precision.hpp"
+#include "./ext/vector_double4.hpp"
+#include "./ext/vector_double4_precision.hpp"
+#include "./ext/vector_int4.hpp"
+#include "./ext/vector_int4_precision.hpp"
+#include "./ext/vector_uint4.hpp"
+#include "./ext/vector_uint4_precision.hpp"
+
diff --git a/engine/inc/glm/vector_relational.hpp b/engine/inc/glm/vector_relational.hpp
new file mode 100644
index 00000000..a0fe17eb
--- /dev/null
+++ b/engine/inc/glm/vector_relational.hpp
@@ -0,0 +1,121 @@
+/// @ref core
+/// @file glm/vector_relational.hpp
+///
+/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
+///
+/// @defgroup core_func_vector_relational Vector Relational Functions
+/// @ingroup core
+///
+/// Relational and equality operators (<, <=, >, >=, ==, !=) are defined to
+/// operate on scalars and produce scalar Boolean results. For vector results,
+/// use the following built-in functions.
+///
+/// In all cases, the sizes of all the input and return vectors for any particular
+/// call must match.
+///
+/// Include <glm/vector_relational.hpp> to use these core features.
+///
+/// @see ext_vector_relational
+
+#pragma once
+
+#include "detail/qualifier.hpp"
+#include "detail/setup.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_func_vector_relational
+	/// @{
+
+	/// Returns the component-wise comparison result of x < y.
+	///
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	/// @tparam T A floating-point or integer scalar type.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/lessThan.xml">GLSL lessThan man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, bool, Q> lessThan(vec<L, T, Q> const& x, vec<L, T, Q> const& y);
+
+	/// Returns the component-wise comparison of result x <= y.
+	///
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	/// @tparam T A floating-point or integer scalar type.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/lessThanEqual.xml">GLSL lessThanEqual man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, bool, Q> lessThanEqual(vec<L, T, Q> const& x, vec<L, T, Q> const& y);
+
+	/// Returns the component-wise comparison of result x > y.
+	///
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	/// @tparam T A floating-point or integer scalar type.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/greaterThan.xml">GLSL greaterThan man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, bool, Q> greaterThan(vec<L, T, Q> const& x, vec<L, T, Q> const& y);
+
+	/// Returns the component-wise comparison of result x >= y.
+	///
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	/// @tparam T A floating-point or integer scalar type.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/greaterThanEqual.xml">GLSL greaterThanEqual man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, bool, Q> greaterThanEqual(vec<L, T, Q> const& x, vec<L, T, Q> const& y);
+
+	/// Returns the component-wise comparison of result x == y.
+	///
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	/// @tparam T A floating-point, integer or bool scalar type.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/equal.xml">GLSL equal man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, bool, Q> equal(vec<L, T, Q> const& x, vec<L, T, Q> const& y);
+
+	/// Returns the component-wise comparison of result x != y.
+	///
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	/// @tparam T A floating-point, integer or bool scalar type.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/notEqual.xml">GLSL notEqual man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, bool, Q> notEqual(vec<L, T, Q> const& x, vec<L, T, Q> const& y);
+
+	/// Returns true if any component of x is true.
+	///
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/any.xml">GLSL any man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
+	template<length_t L, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR bool any(vec<L, bool, Q> const& v);
+
+	/// Returns true if all components of x are true.
+	///
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/all.xml">GLSL all man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
+	template<length_t L, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR bool all(vec<L, bool, Q> const& v);
+
+	/// Returns the component-wise logical complement of x.
+	/// /!\ Because of language incompatibilities between C++ and GLSL, GLM defines the function not but not_ instead.
+	///
+	/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/not.xml">GLSL not man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
+	template<length_t L, qualifier Q>
+	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, bool, Q> not_(vec<L, bool, Q> const& v);
+
+	/// @}
+}//namespace glm
+
+#include "detail/func_vector_relational.inl"
diff --git a/engine/inc/gltf/json.hpp b/engine/inc/gltf/json.hpp
new file mode 100644
index 00000000..c9af0bed
--- /dev/null
+++ b/engine/inc/gltf/json.hpp
@@ -0,0 +1,20406 @@
+/*
+    __ _____ _____ _____
+ __|  |   __|     |   | |  JSON for Modern C++
+|  |  |__   |  |  | | | |  version 3.5.0
+|_____|_____|_____|_|___|  https://github.com/nlohmann/json
+
+Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+SPDX-License-Identifier: MIT
+Copyright (c) 2013-2018 Niels Lohmann <http://nlohmann.me>.
+
+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.
+*/
+
+#ifndef NLOHMANN_JSON_HPP
+#define NLOHMANN_JSON_HPP
+
+#define NLOHMANN_JSON_VERSION_MAJOR 3
+#define NLOHMANN_JSON_VERSION_MINOR 5
+#define NLOHMANN_JSON_VERSION_PATCH 0
+
+#include <algorithm> // all_of, find, for_each
+#include <cassert> // assert
+#include <ciso646> // and, not, or
+#include <cstddef> // nullptr_t, ptrdiff_t, size_t
+#include <functional> // hash, less
+#include <initializer_list> // initializer_list
+#include <iosfwd> // istream, ostream
+#include <iterator> // random_access_iterator_tag
+#include <numeric> // accumulate
+#include <string> // string, stoi, to_string
+#include <utility> // declval, forward, move, pair, swap
+
+// #include <nlohmann/json_fwd.hpp>
+#ifndef NLOHMANN_JSON_FWD_HPP
+#define NLOHMANN_JSON_FWD_HPP
+
+#include <cstdint> // int64_t, uint64_t
+#include <map> // map
+#include <memory> // allocator
+#include <string> // string
+#include <vector> // vector
+
+/*!
+@brief namespace for Niels Lohmann
+@see https://github.com/nlohmann
+@since version 1.0.0
+*/
+namespace nlohmann
+{
+/*!
+@brief default JSONSerializer template argument
+
+This serializer ignores the template arguments and uses ADL
+([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl))
+for serialization.
+*/
+template<typename T = void, typename SFINAE = void>
+struct adl_serializer;
+
+template<template<typename U, typename V, typename... Args> class ObjectType =
+         std::map,
+         template<typename U, typename... Args> class ArrayType = std::vector,
+         class StringType = std::string, class BooleanType = bool,
+         class NumberIntegerType = std::int64_t,
+         class NumberUnsignedType = std::uint64_t,
+         class NumberFloatType = double,
+         template<typename U> class AllocatorType = std::allocator,
+         template<typename T, typename SFINAE = void> class JSONSerializer =
+         adl_serializer>
+class basic_json;
+
+/*!
+@brief JSON Pointer
+
+A JSON pointer defines a string syntax for identifying a specific value
+within a JSON document. It can be used with functions `at` and
+`operator[]`. Furthermore, JSON pointers are the base for JSON patches.
+
+@sa [RFC 6901](https://tools.ietf.org/html/rfc6901)
+
+@since version 2.0.0
+*/
+template<typename BasicJsonType>
+class json_pointer;
+
+/*!
+@brief default JSON class
+
+This type is the default specialization of the @ref basic_json class which
+uses the standard template types.
+
+@since version 1.0.0
+*/
+using json = basic_json<>;
+}  // namespace nlohmann
+
+#endif
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+// This file contains all internal macro definitions
+// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them
+
+// exclude unsupported compilers
+#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)
+    #if defined(__clang__)
+        #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400
+            #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
+        #endif
+    #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))
+        #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800
+            #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
+        #endif
+    #endif
+#endif
+
+// disable float-equal warnings on GCC/clang
+#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+
+// disable documentation warnings on clang
+#if defined(__clang__)
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wdocumentation"
+#endif
+
+// allow for portable deprecation warnings
+#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
+    #define JSON_DEPRECATED __attribute__((deprecated))
+#elif defined(_MSC_VER)
+    #define JSON_DEPRECATED __declspec(deprecated)
+#else
+    #define JSON_DEPRECATED
+#endif
+
+// allow to disable exceptions
+#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
+    #define JSON_THROW(exception) throw exception
+    #define JSON_TRY try
+    #define JSON_CATCH(exception) catch(exception)
+    #define JSON_INTERNAL_CATCH(exception) catch(exception)
+#else
+    #define JSON_THROW(exception) std::abort()
+    #define JSON_TRY if(true)
+    #define JSON_CATCH(exception) if(false)
+    #define JSON_INTERNAL_CATCH(exception) if(false)
+#endif
+
+// override exception macros
+#if defined(JSON_THROW_USER)
+    #undef JSON_THROW
+    #define JSON_THROW JSON_THROW_USER
+#endif
+#if defined(JSON_TRY_USER)
+    #undef JSON_TRY
+    #define JSON_TRY JSON_TRY_USER
+#endif
+#if defined(JSON_CATCH_USER)
+    #undef JSON_CATCH
+    #define JSON_CATCH JSON_CATCH_USER
+    #undef JSON_INTERNAL_CATCH
+    #define JSON_INTERNAL_CATCH JSON_CATCH_USER
+#endif
+#if defined(JSON_INTERNAL_CATCH_USER)
+    #undef JSON_INTERNAL_CATCH
+    #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER
+#endif
+
+// manual branch prediction
+#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
+    #define JSON_LIKELY(x)      __builtin_expect(!!(x), 1)
+    #define JSON_UNLIKELY(x)    __builtin_expect(!!(x), 0)
+#else
+    #define JSON_LIKELY(x)      x
+    #define JSON_UNLIKELY(x)    x
+#endif
+
+// C++ language standard detection
+#if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
+    #define JSON_HAS_CPP_17
+    #define JSON_HAS_CPP_14
+#elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
+    #define JSON_HAS_CPP_14
+#endif
+
+/*!
+@brief macro to briefly define a mapping between an enum and JSON
+@def NLOHMANN_JSON_SERIALIZE_ENUM
+@since version 3.4.0
+*/
+#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...)                                           \
+    template<typename BasicJsonType>                                                           \
+    inline void to_json(BasicJsonType& j, const ENUM_TYPE& e)                                  \
+    {                                                                                          \
+        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");         \
+        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                    \
+        auto it = std::find_if(std::begin(m), std::end(m),                                     \
+                               [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
+        {                                                                                      \
+            return ej_pair.first == e;                                                         \
+        });                                                                                    \
+        j = ((it != std::end(m)) ? it : std::begin(m))->second;                                \
+    }                                                                                          \
+    template<typename BasicJsonType>                                                           \
+    inline void from_json(const BasicJsonType& j, ENUM_TYPE& e)                                \
+    {                                                                                          \
+        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");         \
+        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                    \
+        auto it = std::find_if(std::begin(m), std::end(m),                                     \
+                               [j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
+        {                                                                                      \
+            return ej_pair.second == j;                                                        \
+        });                                                                                    \
+        e = ((it != std::end(m)) ? it : std::begin(m))->first;                                 \
+    }
+
+// Ugly macros to avoid uglier copy-paste when specializing basic_json. They
+// may be removed in the future once the class is split.
+
+#define NLOHMANN_BASIC_JSON_TPL_DECLARATION                                \
+    template<template<typename, typename, typename...> class ObjectType,   \
+             template<typename, typename...> class ArrayType,              \
+             class StringType, class BooleanType, class NumberIntegerType, \
+             class NumberUnsignedType, class NumberFloatType,              \
+             template<typename> class AllocatorType,                       \
+             template<typename, typename = void> class JSONSerializer>
+
+#define NLOHMANN_BASIC_JSON_TPL                                            \
+    basic_json<ObjectType, ArrayType, StringType, BooleanType,             \
+    NumberIntegerType, NumberUnsignedType, NumberFloatType,                \
+    AllocatorType, JSONSerializer>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+
+#include <ciso646> // not
+#include <cstddef> // size_t
+#include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type
+
+namespace nlohmann
+{
+namespace detail
+{
+// alias templates to reduce boilerplate
+template<bool B, typename T = void>
+using enable_if_t = typename std::enable_if<B, T>::type;
+
+template<typename T>
+using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+
+// implementation of C++14 index_sequence and affiliates
+// source: https://stackoverflow.com/a/32223343
+template<std::size_t... Ints>
+struct index_sequence
+{
+    using type = index_sequence;
+    using value_type = std::size_t;
+    static constexpr std::size_t size() noexcept
+    {
+        return sizeof...(Ints);
+    }
+};
+
+template<class Sequence1, class Sequence2>
+struct merge_and_renumber;
+
+template<std::size_t... I1, std::size_t... I2>
+struct merge_and_renumber<index_sequence<I1...>, index_sequence<I2...>>
+        : index_sequence < I1..., (sizeof...(I1) + I2)... > {};
+
+template<std::size_t N>
+struct make_index_sequence
+    : merge_and_renumber < typename make_index_sequence < N / 2 >::type,
+      typename make_index_sequence < N - N / 2 >::type > {};
+
+template<> struct make_index_sequence<0> : index_sequence<> {};
+template<> struct make_index_sequence<1> : index_sequence<0> {};
+
+template<typename... Ts>
+using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
+
+// dispatch utility (taken from ranges-v3)
+template<unsigned N> struct priority_tag : priority_tag < N - 1 > {};
+template<> struct priority_tag<0> {};
+
+// taken from ranges-v3
+template<typename T>
+struct static_const
+{
+    static constexpr T value{};
+};
+
+template<typename T>
+constexpr T static_const<T>::value;
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+#include <ciso646> // not
+#include <limits> // numeric_limits
+#include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type
+#include <utility> // declval
+
+// #include <nlohmann/json_fwd.hpp>
+
+// #include <nlohmann/detail/iterators/iterator_traits.hpp>
+
+
+#include <iterator> // random_access_iterator_tag
+
+// #include <nlohmann/detail/meta/void_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+template <typename ...Ts> struct make_void
+{
+    using type = void;
+};
+template <typename ...Ts> using void_t = typename make_void<Ts...>::type;
+} // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+template <typename It, typename = void>
+struct iterator_types {};
+
+template <typename It>
+struct iterator_types <
+    It,
+    void_t<typename It::difference_type, typename It::value_type, typename It::pointer,
+    typename It::reference, typename It::iterator_category >>
+{
+    using difference_type = typename It::difference_type;
+    using value_type = typename It::value_type;
+    using pointer = typename It::pointer;
+    using reference = typename It::reference;
+    using iterator_category = typename It::iterator_category;
+};
+
+// This is required as some compilers implement std::iterator_traits in a way that
+// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341.
+template <typename T, typename = void>
+struct iterator_traits
+{
+};
+
+template <typename T>
+struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>
+            : iterator_types<T>
+{
+};
+
+template <typename T>
+struct iterator_traits<T*, enable_if_t<std::is_object<T>::value>>
+{
+    using iterator_category = std::random_access_iterator_tag;
+    using value_type = T;
+    using difference_type = ptrdiff_t;
+    using pointer = T*;
+    using reference = T&;
+};
+}
+}
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/detected.hpp>
+
+
+#include <type_traits>
+
+// #include <nlohmann/detail/meta/void_t.hpp>
+
+
+// http://en.cppreference.com/w/cpp/experimental/is_detected
+namespace nlohmann
+{
+namespace detail
+{
+struct nonesuch
+{
+    nonesuch() = delete;
+    ~nonesuch() = delete;
+    nonesuch(nonesuch const&) = delete;
+    void operator=(nonesuch const&) = delete;
+};
+
+template <class Default,
+          class AlwaysVoid,
+          template <class...> class Op,
+          class... Args>
+struct detector
+{
+    using value_t = std::false_type;
+    using type = Default;
+};
+
+template <class Default, template <class...> class Op, class... Args>
+struct detector<Default, void_t<Op<Args...>>, Op, Args...>
+{
+    using value_t = std::true_type;
+    using type = Op<Args...>;
+};
+
+template <template <class...> class Op, class... Args>
+using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;
+
+template <template <class...> class Op, class... Args>
+using detected_t = typename detector<nonesuch, void, Op, Args...>::type;
+
+template <class Default, template <class...> class Op, class... Args>
+using detected_or = detector<Default, void, Op, Args...>;
+
+template <class Default, template <class...> class Op, class... Args>
+using detected_or_t = typename detected_or<Default, Op, Args...>::type;
+
+template <class Expected, template <class...> class Op, class... Args>
+using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
+
+template <class To, template <class...> class Op, class... Args>
+using is_detected_convertible =
+    std::is_convertible<detected_t<Op, Args...>, To>;
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+namespace nlohmann
+{
+/*!
+@brief detail namespace with internal helper functions
+
+This namespace collects functions that should not be exposed,
+implementations of some @ref basic_json methods, and meta-programming helpers.
+
+@since version 2.1.0
+*/
+namespace detail
+{
+/////////////
+// helpers //
+/////////////
+
+// Note to maintainers:
+//
+// Every trait in this file expects a non CV-qualified type.
+// The only exceptions are in the 'aliases for detected' section
+// (i.e. those of the form: decltype(T::member_function(std::declval<T>())))
+//
+// In this case, T has to be properly CV-qualified to constraint the function arguments
+// (e.g. to_json(BasicJsonType&, const T&))
+
+template<typename> struct is_basic_json : std::false_type {};
+
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
+
+//////////////////////////
+// aliases for detected //
+//////////////////////////
+
+template <typename T>
+using mapped_type_t = typename T::mapped_type;
+
+template <typename T>
+using key_type_t = typename T::key_type;
+
+template <typename T>
+using value_type_t = typename T::value_type;
+
+template <typename T>
+using difference_type_t = typename T::difference_type;
+
+template <typename T>
+using pointer_t = typename T::pointer;
+
+template <typename T>
+using reference_t = typename T::reference;
+
+template <typename T>
+using iterator_category_t = typename T::iterator_category;
+
+template <typename T>
+using iterator_t = typename T::iterator;
+
+template <typename T, typename... Args>
+using to_json_function = decltype(T::to_json(std::declval<Args>()...));
+
+template <typename T, typename... Args>
+using from_json_function = decltype(T::from_json(std::declval<Args>()...));
+
+template <typename T, typename U>
+using get_template_function = decltype(std::declval<T>().template get<U>());
+
+// trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists
+template <typename BasicJsonType, typename T, typename = void>
+struct has_from_json : std::false_type {};
+
+template <typename BasicJsonType, typename T>
+struct has_from_json<BasicJsonType, T,
+           enable_if_t<not is_basic_json<T>::value>>
+{
+    using serializer = typename BasicJsonType::template json_serializer<T, void>;
+
+    static constexpr bool value =
+        is_detected_exact<void, from_json_function, serializer,
+        const BasicJsonType&, T&>::value;
+};
+
+// This trait checks if JSONSerializer<T>::from_json(json const&) exists
+// this overload is used for non-default-constructible user-defined-types
+template <typename BasicJsonType, typename T, typename = void>
+struct has_non_default_from_json : std::false_type {};
+
+template<typename BasicJsonType, typename T>
+struct has_non_default_from_json<BasicJsonType, T, enable_if_t<not is_basic_json<T>::value>>
+{
+    using serializer = typename BasicJsonType::template json_serializer<T, void>;
+
+    static constexpr bool value =
+        is_detected_exact<T, from_json_function, serializer,
+        const BasicJsonType&>::value;
+};
+
+// This trait checks if BasicJsonType::json_serializer<T>::to_json exists
+// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion.
+template <typename BasicJsonType, typename T, typename = void>
+struct has_to_json : std::false_type {};
+
+template <typename BasicJsonType, typename T>
+struct has_to_json<BasicJsonType, T, enable_if_t<not is_basic_json<T>::value>>
+{
+    using serializer = typename BasicJsonType::template json_serializer<T, void>;
+
+    static constexpr bool value =
+        is_detected_exact<void, to_json_function, serializer, BasicJsonType&,
+        T>::value;
+};
+
+
+///////////////////
+// is_ functions //
+///////////////////
+
+template <typename T, typename = void>
+struct is_iterator_traits : std::false_type {};
+
+template <typename T>
+struct is_iterator_traits<iterator_traits<T>>
+{
+  private:
+    using traits = iterator_traits<T>;
+
+  public:
+    static constexpr auto value =
+        is_detected<value_type_t, traits>::value &&
+        is_detected<difference_type_t, traits>::value &&
+        is_detected<pointer_t, traits>::value &&
+        is_detected<iterator_category_t, traits>::value &&
+        is_detected<reference_t, traits>::value;
+};
+
+// source: https://stackoverflow.com/a/37193089/4116453
+
+template <typename T, typename = void>
+struct is_complete_type : std::false_type {};
+
+template <typename T>
+struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
+
+template <typename BasicJsonType, typename CompatibleObjectType,
+          typename = void>
+struct is_compatible_object_type_impl : std::false_type {};
+
+template <typename BasicJsonType, typename CompatibleObjectType>
+struct is_compatible_object_type_impl <
+    BasicJsonType, CompatibleObjectType,
+    enable_if_t<is_detected<mapped_type_t, CompatibleObjectType>::value and
+    is_detected<key_type_t, CompatibleObjectType>::value >>
+{
+
+    using object_t = typename BasicJsonType::object_t;
+
+    // macOS's is_constructible does not play well with nonesuch...
+    static constexpr bool value =
+        std::is_constructible<typename object_t::key_type,
+        typename CompatibleObjectType::key_type>::value and
+        std::is_constructible<typename object_t::mapped_type,
+        typename CompatibleObjectType::mapped_type>::value;
+};
+
+template <typename BasicJsonType, typename CompatibleObjectType>
+struct is_compatible_object_type
+    : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
+
+template <typename BasicJsonType, typename ConstructibleObjectType,
+          typename = void>
+struct is_constructible_object_type_impl : std::false_type {};
+
+template <typename BasicJsonType, typename ConstructibleObjectType>
+struct is_constructible_object_type_impl <
+    BasicJsonType, ConstructibleObjectType,
+    enable_if_t<is_detected<mapped_type_t, ConstructibleObjectType>::value and
+    is_detected<key_type_t, ConstructibleObjectType>::value >>
+{
+    using object_t = typename BasicJsonType::object_t;
+
+    static constexpr bool value =
+        (std::is_constructible<typename ConstructibleObjectType::key_type, typename object_t::key_type>::value and
+         std::is_same<typename object_t::mapped_type, typename ConstructibleObjectType::mapped_type>::value) or
+        (has_from_json<BasicJsonType, typename ConstructibleObjectType::mapped_type>::value or
+         has_non_default_from_json<BasicJsonType, typename ConstructibleObjectType::mapped_type >::value);
+};
+
+template <typename BasicJsonType, typename ConstructibleObjectType>
+struct is_constructible_object_type
+    : is_constructible_object_type_impl<BasicJsonType,
+      ConstructibleObjectType> {};
+
+template <typename BasicJsonType, typename CompatibleStringType,
+          typename = void>
+struct is_compatible_string_type_impl : std::false_type {};
+
+template <typename BasicJsonType, typename CompatibleStringType>
+struct is_compatible_string_type_impl <
+    BasicJsonType, CompatibleStringType,
+    enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type,
+    value_type_t, CompatibleStringType>::value >>
+{
+    static constexpr auto value =
+        std::is_constructible<typename BasicJsonType::string_t, CompatibleStringType>::value;
+};
+
+template <typename BasicJsonType, typename ConstructibleStringType>
+struct is_compatible_string_type
+    : is_compatible_string_type_impl<BasicJsonType, ConstructibleStringType> {};
+
+template <typename BasicJsonType, typename ConstructibleStringType,
+          typename = void>
+struct is_constructible_string_type_impl : std::false_type {};
+
+template <typename BasicJsonType, typename ConstructibleStringType>
+struct is_constructible_string_type_impl <
+    BasicJsonType, ConstructibleStringType,
+    enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type,
+    value_type_t, ConstructibleStringType>::value >>
+{
+    static constexpr auto value =
+        std::is_constructible<ConstructibleStringType,
+        typename BasicJsonType::string_t>::value;
+};
+
+template <typename BasicJsonType, typename ConstructibleStringType>
+struct is_constructible_string_type
+    : is_constructible_string_type_impl<BasicJsonType, ConstructibleStringType> {};
+
+template <typename BasicJsonType, typename CompatibleArrayType, typename = void>
+struct is_compatible_array_type_impl : std::false_type {};
+
+template <typename BasicJsonType, typename CompatibleArrayType>
+struct is_compatible_array_type_impl <
+    BasicJsonType, CompatibleArrayType,
+    enable_if_t<is_detected<value_type_t, CompatibleArrayType>::value and
+    is_detected<iterator_t, CompatibleArrayType>::value and
+// This is needed because json_reverse_iterator has a ::iterator type...
+// Therefore it is detected as a CompatibleArrayType.
+// The real fix would be to have an Iterable concept.
+    not is_iterator_traits<
+    iterator_traits<CompatibleArrayType>>::value >>
+{
+    static constexpr bool value =
+        std::is_constructible<BasicJsonType,
+        typename CompatibleArrayType::value_type>::value;
+};
+
+template <typename BasicJsonType, typename CompatibleArrayType>
+struct is_compatible_array_type
+    : is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {};
+
+template <typename BasicJsonType, typename ConstructibleArrayType, typename = void>
+struct is_constructible_array_type_impl : std::false_type {};
+
+template <typename BasicJsonType, typename ConstructibleArrayType>
+struct is_constructible_array_type_impl <
+    BasicJsonType, ConstructibleArrayType,
+    enable_if_t<std::is_same<ConstructibleArrayType,
+    typename BasicJsonType::value_type>::value >>
+            : std::true_type {};
+
+template <typename BasicJsonType, typename ConstructibleArrayType>
+struct is_constructible_array_type_impl <
+    BasicJsonType, ConstructibleArrayType,
+    enable_if_t<not std::is_same<ConstructibleArrayType,
+    typename BasicJsonType::value_type>::value and
+    is_detected<value_type_t, ConstructibleArrayType>::value and
+    is_detected<iterator_t, ConstructibleArrayType>::value and
+    is_complete_type<
+    detected_t<value_type_t, ConstructibleArrayType>>::value >>
+{
+    static constexpr bool value =
+        // This is needed because json_reverse_iterator has a ::iterator type,
+        // furthermore, std::back_insert_iterator (and other iterators) have a base class `iterator`...
+        // Therefore it is detected as a ConstructibleArrayType.
+        // The real fix would be to have an Iterable concept.
+        not is_iterator_traits <
+        iterator_traits<ConstructibleArrayType >>::value and
+
+        (std::is_same<typename ConstructibleArrayType::value_type, typename BasicJsonType::array_t::value_type>::value or
+         has_from_json<BasicJsonType,
+         typename ConstructibleArrayType::value_type>::value or
+         has_non_default_from_json <
+         BasicJsonType, typename ConstructibleArrayType::value_type >::value);
+};
+
+template <typename BasicJsonType, typename ConstructibleArrayType>
+struct is_constructible_array_type
+    : is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {};
+
+template <typename RealIntegerType, typename CompatibleNumberIntegerType,
+          typename = void>
+struct is_compatible_integer_type_impl : std::false_type {};
+
+template <typename RealIntegerType, typename CompatibleNumberIntegerType>
+struct is_compatible_integer_type_impl <
+    RealIntegerType, CompatibleNumberIntegerType,
+    enable_if_t<std::is_integral<RealIntegerType>::value and
+    std::is_integral<CompatibleNumberIntegerType>::value and
+    not std::is_same<bool, CompatibleNumberIntegerType>::value >>
+{
+    // is there an assert somewhere on overflows?
+    using RealLimits = std::numeric_limits<RealIntegerType>;
+    using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
+
+    static constexpr auto value =
+        std::is_constructible<RealIntegerType,
+        CompatibleNumberIntegerType>::value and
+        CompatibleLimits::is_integer and
+        RealLimits::is_signed == CompatibleLimits::is_signed;
+};
+
+template <typename RealIntegerType, typename CompatibleNumberIntegerType>
+struct is_compatible_integer_type
+    : is_compatible_integer_type_impl<RealIntegerType,
+      CompatibleNumberIntegerType> {};
+
+template <typename BasicJsonType, typename CompatibleType, typename = void>
+struct is_compatible_type_impl: std::false_type {};
+
+template <typename BasicJsonType, typename CompatibleType>
+struct is_compatible_type_impl <
+    BasicJsonType, CompatibleType,
+    enable_if_t<is_complete_type<CompatibleType>::value >>
+{
+    static constexpr bool value =
+        has_to_json<BasicJsonType, CompatibleType>::value;
+};
+
+template <typename BasicJsonType, typename CompatibleType>
+struct is_compatible_type
+    : is_compatible_type_impl<BasicJsonType, CompatibleType> {};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+
+#include <exception> // exception
+#include <stdexcept> // runtime_error
+#include <string> // to_string
+
+// #include <nlohmann/detail/input/position_t.hpp>
+
+
+#include <cstddef> // size_t
+
+namespace nlohmann
+{
+namespace detail
+{
+/// struct to capture the start position of the current token
+struct position_t
+{
+    /// the total number of characters read
+    std::size_t chars_read_total = 0;
+    /// the number of characters read in the current line
+    std::size_t chars_read_current_line = 0;
+    /// the number of lines read
+    std::size_t lines_read = 0;
+
+    /// conversion to size_t to preserve SAX interface
+    constexpr operator size_t() const
+    {
+        return chars_read_total;
+    }
+};
+
+}
+}
+
+
+namespace nlohmann
+{
+namespace detail
+{
+////////////////
+// exceptions //
+////////////////
+
+/*!
+@brief general exception of the @ref basic_json class
+
+This class is an extension of `std::exception` objects with a member @a id for
+exception ids. It is used as the base class for all exceptions thrown by the
+@ref basic_json class. This class can hence be used as "wildcard" to catch
+exceptions.
+
+Subclasses:
+- @ref parse_error for exceptions indicating a parse error
+- @ref invalid_iterator for exceptions indicating errors with iterators
+- @ref type_error for exceptions indicating executing a member function with
+                  a wrong type
+- @ref out_of_range for exceptions indicating access out of the defined range
+- @ref other_error for exceptions indicating other library errors
+
+@internal
+@note To have nothrow-copy-constructible exceptions, we internally use
+      `std::runtime_error` which can cope with arbitrary-length error messages.
+      Intermediate strings are built with static functions and then passed to
+      the actual constructor.
+@endinternal
+
+@liveexample{The following code shows how arbitrary library exceptions can be
+caught.,exception}
+
+@since version 3.0.0
+*/
+class exception : public std::exception
+{
+  public:
+    /// returns the explanatory string
+    const char* what() const noexcept override
+    {
+        return m.what();
+    }
+
+    /// the id of the exception
+    const int id;
+
+  protected:
+    exception(int id_, const char* what_arg) : id(id_), m(what_arg) {}
+
+    static std::string name(const std::string& ename, int id_)
+    {
+        return "[json.exception." + ename + "." + std::to_string(id_) + "] ";
+    }
+
+  private:
+    /// an exception object as storage for error messages
+    std::runtime_error m;
+};
+
+/*!
+@brief exception indicating a parse error
+
+This exception is thrown by the library when a parse error occurs. Parse errors
+can occur during the deserialization of JSON text, CBOR, MessagePack, as well
+as when using JSON Patch.
+
+Member @a byte holds the byte index of the last read character in the input
+file.
+
+Exceptions have ids 1xx.
+
+name / id                      | example message | description
+------------------------------ | --------------- | -------------------------
+json.exception.parse_error.101 | parse error at 2: unexpected end of input; expected string literal | This error indicates a syntax error while deserializing a JSON text. The error message describes that an unexpected token (character) was encountered, and the member @a byte indicates the error position.
+json.exception.parse_error.102 | parse error at 14: missing or wrong low surrogate | JSON uses the `\uxxxx` format to describe Unicode characters. Code points above above 0xFFFF are split into two `\uxxxx` entries ("surrogate pairs"). This error indicates that the surrogate pair is incomplete or contains an invalid code point.
+json.exception.parse_error.103 | parse error: code points above 0x10FFFF are invalid | Unicode supports code points up to 0x10FFFF. Code points above 0x10FFFF are invalid.
+json.exception.parse_error.104 | parse error: JSON patch must be an array of objects | [RFC 6902](https://tools.ietf.org/html/rfc6902) requires a JSON Patch document to be a JSON document that represents an array of objects.
+json.exception.parse_error.105 | parse error: operation must have string member 'op' | An operation of a JSON Patch document must contain exactly one "op" member, whose value indicates the operation to perform. Its value must be one of "add", "remove", "replace", "move", "copy", or "test"; other values are errors.
+json.exception.parse_error.106 | parse error: array index '01' must not begin with '0' | An array index in a JSON Pointer ([RFC 6901](https://tools.ietf.org/html/rfc6901)) may be `0` or any number without a leading `0`.
+json.exception.parse_error.107 | parse error: JSON pointer must be empty or begin with '/' - was: 'foo' | A JSON Pointer must be a Unicode string containing a sequence of zero or more reference tokens, each prefixed by a `/` character.
+json.exception.parse_error.108 | parse error: escape character '~' must be followed with '0' or '1' | In a JSON Pointer, only `~0` and `~1` are valid escape sequences.
+json.exception.parse_error.109 | parse error: array index 'one' is not a number | A JSON Pointer array index must be a number.
+json.exception.parse_error.110 | parse error at 1: cannot read 2 bytes from vector | When parsing CBOR or MessagePack, the byte vector ends before the complete value has been read.
+json.exception.parse_error.112 | parse error at 1: error reading CBOR; last byte: 0xF8 | Not all types of CBOR or MessagePack are supported. This exception occurs if an unsupported byte was read.
+json.exception.parse_error.113 | parse error at 2: expected a CBOR string; last byte: 0x98 | While parsing a map key, a value that is not a string has been read.
+json.exception.parse_error.114 | parse error: Unsupported BSON record type 0x0F | The parsing of the corresponding BSON record type is not implemented (yet).
+
+@note For an input with n bytes, 1 is the index of the first character and n+1
+      is the index of the terminating null byte or the end of file. This also
+      holds true when reading a byte vector (CBOR or MessagePack).
+
+@liveexample{The following code shows how a `parse_error` exception can be
+caught.,parse_error}
+
+@sa @ref exception for the base class of the library exceptions
+@sa @ref invalid_iterator for exceptions indicating errors with iterators
+@sa @ref type_error for exceptions indicating executing a member function with
+                    a wrong type
+@sa @ref out_of_range for exceptions indicating access out of the defined range
+@sa @ref other_error for exceptions indicating other library errors
+
+@since version 3.0.0
+*/
+class parse_error : public exception
+{
+  public:
+    /*!
+    @brief create a parse error exception
+    @param[in] id_       the id of the exception
+    @param[in] position  the position where the error occurred (or with
+                         chars_read_total=0 if the position cannot be
+                         determined)
+    @param[in] what_arg  the explanatory string
+    @return parse_error object
+    */
+    static parse_error create(int id_, const position_t& pos, const std::string& what_arg)
+    {
+        std::string w = exception::name("parse_error", id_) + "parse error" +
+                        position_string(pos) + ": " + what_arg;
+        return parse_error(id_, pos.chars_read_total, w.c_str());
+    }
+
+    static parse_error create(int id_, std::size_t byte_, const std::string& what_arg)
+    {
+        std::string w = exception::name("parse_error", id_) + "parse error" +
+                        (byte_ != 0 ? (" at byte " + std::to_string(byte_)) : "") +
+                        ": " + what_arg;
+        return parse_error(id_, byte_, w.c_str());
+    }
+
+    /*!
+    @brief byte index of the parse error
+
+    The byte index of the last read character in the input file.
+
+    @note For an input with n bytes, 1 is the index of the first character and
+          n+1 is the index of the terminating null byte or the end of file.
+          This also holds true when reading a byte vector (CBOR or MessagePack).
+    */
+    const std::size_t byte;
+
+  private:
+    parse_error(int id_, std::size_t byte_, const char* what_arg)
+        : exception(id_, what_arg), byte(byte_) {}
+
+    static std::string position_string(const position_t& pos)
+    {
+        return " at line " + std::to_string(pos.lines_read + 1) +
+               ", column " + std::to_string(pos.chars_read_current_line);
+    }
+};
+
+/*!
+@brief exception indicating errors with iterators
+
+This exception is thrown if iterators passed to a library function do not match
+the expected semantics.
+
+Exceptions have ids 2xx.
+
+name / id                           | example message | description
+----------------------------------- | --------------- | -------------------------
+json.exception.invalid_iterator.201 | iterators are not compatible | The iterators passed to constructor @ref basic_json(InputIT first, InputIT last) are not compatible, meaning they do not belong to the same container. Therefore, the range (@a first, @a last) is invalid.
+json.exception.invalid_iterator.202 | iterator does not fit current value | In an erase or insert function, the passed iterator @a pos does not belong to the JSON value for which the function was called. It hence does not define a valid position for the deletion/insertion.
+json.exception.invalid_iterator.203 | iterators do not fit current value | Either iterator passed to function @ref erase(IteratorType first, IteratorType last) does not belong to the JSON value from which values shall be erased. It hence does not define a valid range to delete values from.
+json.exception.invalid_iterator.204 | iterators out of range | When an iterator range for a primitive type (number, boolean, or string) is passed to a constructor or an erase function, this range has to be exactly (@ref begin(), @ref end()), because this is the only way the single stored value is expressed. All other ranges are invalid.
+json.exception.invalid_iterator.205 | iterator out of range | When an iterator for a primitive type (number, boolean, or string) is passed to an erase function, the iterator has to be the @ref begin() iterator, because it is the only way to address the stored value. All other iterators are invalid.
+json.exception.invalid_iterator.206 | cannot construct with iterators from null | The iterators passed to constructor @ref basic_json(InputIT first, InputIT last) belong to a JSON null value and hence to not define a valid range.
+json.exception.invalid_iterator.207 | cannot use key() for non-object iterators | The key() member function can only be used on iterators belonging to a JSON object, because other types do not have a concept of a key.
+json.exception.invalid_iterator.208 | cannot use operator[] for object iterators | The operator[] to specify a concrete offset cannot be used on iterators belonging to a JSON object, because JSON objects are unordered.
+json.exception.invalid_iterator.209 | cannot use offsets with object iterators | The offset operators (+, -, +=, -=) cannot be used on iterators belonging to a JSON object, because JSON objects are unordered.
+json.exception.invalid_iterator.210 | iterators do not fit | The iterator range passed to the insert function are not compatible, meaning they do not belong to the same container. Therefore, the range (@a first, @a last) is invalid.
+json.exception.invalid_iterator.211 | passed iterators may not belong to container | The iterator range passed to the insert function must not be a subrange of the container to insert to.
+json.exception.invalid_iterator.212 | cannot compare iterators of different containers | When two iterators are compared, they must belong to the same container.
+json.exception.invalid_iterator.213 | cannot compare order of object iterators | The order of object iterators cannot be compared, because JSON objects are unordered.
+json.exception.invalid_iterator.214 | cannot get value | Cannot get value for iterator: Either the iterator belongs to a null value or it is an iterator to a primitive type (number, boolean, or string), but the iterator is different to @ref begin().
+
+@liveexample{The following code shows how an `invalid_iterator` exception can be
+caught.,invalid_iterator}
+
+@sa @ref exception for the base class of the library exceptions
+@sa @ref parse_error for exceptions indicating a parse error
+@sa @ref type_error for exceptions indicating executing a member function with
+                    a wrong type
+@sa @ref out_of_range for exceptions indicating access out of the defined range
+@sa @ref other_error for exceptions indicating other library errors
+
+@since version 3.0.0
+*/
+class invalid_iterator : public exception
+{
+  public:
+    static invalid_iterator create(int id_, const std::string& what_arg)
+    {
+        std::string w = exception::name("invalid_iterator", id_) + what_arg;
+        return invalid_iterator(id_, w.c_str());
+    }
+
+  private:
+    invalid_iterator(int id_, const char* what_arg)
+        : exception(id_, what_arg) {}
+};
+
+/*!
+@brief exception indicating executing a member function with a wrong type
+
+This exception is thrown in case of a type error; that is, a library function is
+executed on a JSON value whose type does not match the expected semantics.
+
+Exceptions have ids 3xx.
+
+name / id                     | example message | description
+----------------------------- | --------------- | -------------------------
+json.exception.type_error.301 | cannot create object from initializer list | To create an object from an initializer list, the initializer list must consist only of a list of pairs whose first element is a string. When this constraint is violated, an array is created instead.
+json.exception.type_error.302 | type must be object, but is array | During implicit or explicit value conversion, the JSON type must be compatible to the target type. For instance, a JSON string can only be converted into string types, but not into numbers or boolean types.
+json.exception.type_error.303 | incompatible ReferenceType for get_ref, actual type is object | To retrieve a reference to a value stored in a @ref basic_json object with @ref get_ref, the type of the reference must match the value type. For instance, for a JSON array, the @a ReferenceType must be @ref array_t&.
+json.exception.type_error.304 | cannot use at() with string | The @ref at() member functions can only be executed for certain JSON types.
+json.exception.type_error.305 | cannot use operator[] with string | The @ref operator[] member functions can only be executed for certain JSON types.
+json.exception.type_error.306 | cannot use value() with string | The @ref value() member functions can only be executed for certain JSON types.
+json.exception.type_error.307 | cannot use erase() with string | The @ref erase() member functions can only be executed for certain JSON types.
+json.exception.type_error.308 | cannot use push_back() with string | The @ref push_back() and @ref operator+= member functions can only be executed for certain JSON types.
+json.exception.type_error.309 | cannot use insert() with | The @ref insert() member functions can only be executed for certain JSON types.
+json.exception.type_error.310 | cannot use swap() with number | The @ref swap() member functions can only be executed for certain JSON types.
+json.exception.type_error.311 | cannot use emplace_back() with string | The @ref emplace_back() member function can only be executed for certain JSON types.
+json.exception.type_error.312 | cannot use update() with string | The @ref update() member functions can only be executed for certain JSON types.
+json.exception.type_error.313 | invalid value to unflatten | The @ref unflatten function converts an object whose keys are JSON Pointers back into an arbitrary nested JSON value. The JSON Pointers must not overlap, because then the resulting value would not be well defined.
+json.exception.type_error.314 | only objects can be unflattened | The @ref unflatten function only works for an object whose keys are JSON Pointers.
+json.exception.type_error.315 | values in object must be primitive | The @ref unflatten function only works for an object whose keys are JSON Pointers and whose values are primitive.
+json.exception.type_error.316 | invalid UTF-8 byte at index 10: 0x7E | The @ref dump function only works with UTF-8 encoded strings; that is, if you assign a `std::string` to a JSON value, make sure it is UTF-8 encoded. |
+json.exception.type_error.317 | JSON value cannot be serialized to requested format | The dynamic type of the object cannot be represented in the requested serialization format (e.g. a raw `true` or `null` JSON object cannot be serialized to BSON) |
+
+@liveexample{The following code shows how a `type_error` exception can be
+caught.,type_error}
+
+@sa @ref exception for the base class of the library exceptions
+@sa @ref parse_error for exceptions indicating a parse error
+@sa @ref invalid_iterator for exceptions indicating errors with iterators
+@sa @ref out_of_range for exceptions indicating access out of the defined range
+@sa @ref other_error for exceptions indicating other library errors
+
+@since version 3.0.0
+*/
+class type_error : public exception
+{
+  public:
+    static type_error create(int id_, const std::string& what_arg)
+    {
+        std::string w = exception::name("type_error", id_) + what_arg;
+        return type_error(id_, w.c_str());
+    }
+
+  private:
+    type_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
+};
+
+/*!
+@brief exception indicating access out of the defined range
+
+This exception is thrown in case a library function is called on an input
+parameter that exceeds the expected range, for instance in case of array
+indices or nonexisting object keys.
+
+Exceptions have ids 4xx.
+
+name / id                       | example message | description
+------------------------------- | --------------- | -------------------------
+json.exception.out_of_range.401 | array index 3 is out of range | The provided array index @a i is larger than @a size-1.
+json.exception.out_of_range.402 | array index '-' (3) is out of range | The special array index `-` in a JSON Pointer never describes a valid element of the array, but the index past the end. That is, it can only be used to add elements at this position, but not to read it.
+json.exception.out_of_range.403 | key 'foo' not found | The provided key was not found in the JSON object.
+json.exception.out_of_range.404 | unresolved reference token 'foo' | A reference token in a JSON Pointer could not be resolved.
+json.exception.out_of_range.405 | JSON pointer has no parent | The JSON Patch operations 'remove' and 'add' can not be applied to the root element of the JSON value.
+json.exception.out_of_range.406 | number overflow parsing '10E1000' | A parsed number could not be stored as without changing it to NaN or INF.
+json.exception.out_of_range.407 | number overflow serializing '9223372036854775808' | UBJSON and BSON only support integer numbers up to 9223372036854775807. |
+json.exception.out_of_range.408 | excessive array size: 8658170730974374167 | The size (following `#`) of an UBJSON array or object exceeds the maximal capacity. |
+json.exception.out_of_range.409 | BSON key cannot contain code point U+0000 (at byte 2) | Key identifiers to be serialized to BSON cannot contain code point U+0000, since the key is stored as zero-terminated c-string |
+
+@liveexample{The following code shows how an `out_of_range` exception can be
+caught.,out_of_range}
+
+@sa @ref exception for the base class of the library exceptions
+@sa @ref parse_error for exceptions indicating a parse error
+@sa @ref invalid_iterator for exceptions indicating errors with iterators
+@sa @ref type_error for exceptions indicating executing a member function with
+                    a wrong type
+@sa @ref other_error for exceptions indicating other library errors
+
+@since version 3.0.0
+*/
+class out_of_range : public exception
+{
+  public:
+    static out_of_range create(int id_, const std::string& what_arg)
+    {
+        std::string w = exception::name("out_of_range", id_) + what_arg;
+        return out_of_range(id_, w.c_str());
+    }
+
+  private:
+    out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {}
+};
+
+/*!
+@brief exception indicating other library errors
+
+This exception is thrown in case of errors that cannot be classified with the
+other exception types.
+
+Exceptions have ids 5xx.
+
+name / id                      | example message | description
+------------------------------ | --------------- | -------------------------
+json.exception.other_error.501 | unsuccessful: {"op":"test","path":"/baz", "value":"bar"} | A JSON Patch operation 'test' failed. The unsuccessful operation is also printed.
+
+@sa @ref exception for the base class of the library exceptions
+@sa @ref parse_error for exceptions indicating a parse error
+@sa @ref invalid_iterator for exceptions indicating errors with iterators
+@sa @ref type_error for exceptions indicating executing a member function with
+                    a wrong type
+@sa @ref out_of_range for exceptions indicating access out of the defined range
+
+@liveexample{The following code shows how an `other_error` exception can be
+caught.,other_error}
+
+@since version 3.0.0
+*/
+class other_error : public exception
+{
+  public:
+    static other_error create(int id_, const std::string& what_arg)
+    {
+        std::string w = exception::name("other_error", id_) + what_arg;
+        return other_error(id_, w.c_str());
+    }
+
+  private:
+    other_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+#include <array> // array
+#include <ciso646> // and
+#include <cstddef> // size_t
+#include <cstdint> // uint8_t
+
+namespace nlohmann
+{
+namespace detail
+{
+///////////////////////////
+// JSON type enumeration //
+///////////////////////////
+
+/*!
+@brief the JSON type enumeration
+
+This enumeration collects the different JSON types. It is internally used to
+distinguish the stored values, and the functions @ref basic_json::is_null(),
+@ref basic_json::is_object(), @ref basic_json::is_array(),
+@ref basic_json::is_string(), @ref basic_json::is_boolean(),
+@ref basic_json::is_number() (with @ref basic_json::is_number_integer(),
+@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()),
+@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and
+@ref basic_json::is_structured() rely on it.
+
+@note There are three enumeration entries (number_integer, number_unsigned, and
+number_float), because the library distinguishes these three types for numbers:
+@ref basic_json::number_unsigned_t is used for unsigned integers,
+@ref basic_json::number_integer_t is used for signed integers, and
+@ref basic_json::number_float_t is used for floating-point numbers or to
+approximate integers which do not fit in the limits of their respective type.
+
+@sa @ref basic_json::basic_json(const value_t value_type) -- create a JSON
+value with the default value for a given type
+
+@since version 1.0.0
+*/
+enum class value_t : std::uint8_t
+{
+    null,             ///< null value
+    object,           ///< object (unordered set of name/value pairs)
+    array,            ///< array (ordered collection of values)
+    string,           ///< string value
+    boolean,          ///< boolean value
+    number_integer,   ///< number value (signed integer)
+    number_unsigned,  ///< number value (unsigned integer)
+    number_float,     ///< number value (floating-point)
+    discarded         ///< discarded by the the parser callback function
+};
+
+/*!
+@brief comparison operator for JSON types
+
+Returns an ordering that is similar to Python:
+- order: null < boolean < number < object < array < string
+- furthermore, each type is not smaller than itself
+- discarded values are not comparable
+
+@since version 1.0.0
+*/
+inline bool operator<(const value_t lhs, const value_t rhs) noexcept
+{
+    static constexpr std::array<std::uint8_t, 8> order = {{
+            0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,
+            1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */
+        }
+    };
+
+    const auto l_index = static_cast<std::size_t>(lhs);
+    const auto r_index = static_cast<std::size_t>(rhs);
+    return l_index < order.size() and r_index < order.size() and order[l_index] < order[r_index];
+}
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/conversions/from_json.hpp>
+
+
+#include <algorithm> // transform
+#include <array> // array
+#include <ciso646> // and, not
+#include <forward_list> // forward_list
+#include <iterator> // inserter, front_inserter, end
+#include <map> // map
+#include <string> // string
+#include <tuple> // tuple, make_tuple
+#include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
+#include <unordered_map> // unordered_map
+#include <utility> // pair, declval
+#include <valarray> // valarray
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
+{
+    if (JSON_UNLIKELY(not j.is_null()))
+    {
+        JSON_THROW(type_error::create(302, "type must be null, but is " + std::string(j.type_name())));
+    }
+    n = nullptr;
+}
+
+// overloads for basic_json template parameters
+template<typename BasicJsonType, typename ArithmeticType,
+         enable_if_t<std::is_arithmetic<ArithmeticType>::value and
+                     not std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
+                     int> = 0>
+void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
+{
+    switch (static_cast<value_t>(j))
+    {
+        case value_t::number_unsigned:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
+            break;
+        }
+        case value_t::number_integer:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
+            break;
+        }
+        case value_t::number_float:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
+            break;
+        }
+
+        default:
+            JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));
+    }
+}
+
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
+{
+    if (JSON_UNLIKELY(not j.is_boolean()))
+    {
+        JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(j.type_name())));
+    }
+    b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
+}
+
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
+{
+    if (JSON_UNLIKELY(not j.is_string()))
+    {
+        JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
+    }
+    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
+}
+
+template <
+    typename BasicJsonType, typename ConstructibleStringType,
+    enable_if_t <
+        is_constructible_string_type<BasicJsonType, ConstructibleStringType>::value and
+        not std::is_same<typename BasicJsonType::string_t,
+                         ConstructibleStringType>::value,
+        int > = 0 >
+void from_json(const BasicJsonType& j, ConstructibleStringType& s)
+{
+    if (JSON_UNLIKELY(not j.is_string()))
+    {
+        JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
+    }
+
+    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
+}
+
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)
+{
+    get_arithmetic_value(j, val);
+}
+
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)
+{
+    get_arithmetic_value(j, val);
+}
+
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)
+{
+    get_arithmetic_value(j, val);
+}
+
+template<typename BasicJsonType, typename EnumType,
+         enable_if_t<std::is_enum<EnumType>::value, int> = 0>
+void from_json(const BasicJsonType& j, EnumType& e)
+{
+    typename std::underlying_type<EnumType>::type val;
+    get_arithmetic_value(j, val);
+    e = static_cast<EnumType>(val);
+}
+
+// forward_list doesn't have an insert method
+template<typename BasicJsonType, typename T, typename Allocator,
+         enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0>
+void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
+{
+    if (JSON_UNLIKELY(not j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
+    }
+    std::transform(j.rbegin(), j.rend(),
+                   std::front_inserter(l), [](const BasicJsonType & i)
+    {
+        return i.template get<T>();
+    });
+}
+
+// valarray doesn't have an insert method
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0>
+void from_json(const BasicJsonType& j, std::valarray<T>& l)
+{
+    if (JSON_UNLIKELY(not j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
+    }
+    l.resize(j.size());
+    std::copy(j.m_value.array->begin(), j.m_value.array->end(), std::begin(l));
+}
+
+template<typename BasicJsonType>
+void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /*unused*/)
+{
+    arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
+}
+
+template <typename BasicJsonType, typename T, std::size_t N>
+auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
+                          priority_tag<2> /*unused*/)
+-> decltype(j.template get<T>(), void())
+{
+    for (std::size_t i = 0; i < N; ++i)
+    {
+        arr[i] = j.at(i).template get<T>();
+    }
+}
+
+template<typename BasicJsonType, typename ConstructibleArrayType>
+auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> /*unused*/)
+-> decltype(
+    arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
+    j.template get<typename ConstructibleArrayType::value_type>(),
+    void())
+{
+    using std::end;
+
+    arr.reserve(j.size());
+    std::transform(j.begin(), j.end(),
+                   std::inserter(arr, end(arr)), [](const BasicJsonType & i)
+    {
+        // get<BasicJsonType>() returns *this, this won't call a from_json
+        // method when value_type is BasicJsonType
+        return i.template get<typename ConstructibleArrayType::value_type>();
+    });
+}
+
+template <typename BasicJsonType, typename ConstructibleArrayType>
+void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,
+                          priority_tag<0> /*unused*/)
+{
+    using std::end;
+
+    std::transform(
+        j.begin(), j.end(), std::inserter(arr, end(arr)),
+        [](const BasicJsonType & i)
+    {
+        // get<BasicJsonType>() returns *this, this won't call a from_json
+        // method when value_type is BasicJsonType
+        return i.template get<typename ConstructibleArrayType::value_type>();
+    });
+}
+
+template <typename BasicJsonType, typename ConstructibleArrayType,
+          enable_if_t <
+              is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value and
+              not is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value and
+              not is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value and
+              not is_basic_json<ConstructibleArrayType>::value,
+              int > = 0 >
+
+auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
+-> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
+j.template get<typename ConstructibleArrayType::value_type>(),
+void())
+{
+    if (JSON_UNLIKELY(not j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, "type must be array, but is " +
+                                      std::string(j.type_name())));
+    }
+
+    from_json_array_impl(j, arr, priority_tag<3> {});
+}
+
+template<typename BasicJsonType, typename ConstructibleObjectType,
+         enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
+void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
+{
+    if (JSON_UNLIKELY(not j.is_object()))
+    {
+        JSON_THROW(type_error::create(302, "type must be object, but is " + std::string(j.type_name())));
+    }
+
+    auto inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
+    using value_type = typename ConstructibleObjectType::value_type;
+    std::transform(
+        inner_object->begin(), inner_object->end(),
+        std::inserter(obj, obj.begin()),
+        [](typename BasicJsonType::object_t::value_type const & p)
+    {
+        return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
+    });
+}
+
+// overload for arithmetic types, not chosen for basic_json template arguments
+// (BooleanType, etc..); note: Is it really necessary to provide explicit
+// overloads for boolean_t etc. in case of a custom BooleanType which is not
+// an arithmetic type?
+template<typename BasicJsonType, typename ArithmeticType,
+         enable_if_t <
+             std::is_arithmetic<ArithmeticType>::value and
+             not std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value and
+             not std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value and
+             not std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value and
+             not std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
+             int> = 0>
+void from_json(const BasicJsonType& j, ArithmeticType& val)
+{
+    switch (static_cast<value_t>(j))
+    {
+        case value_t::number_unsigned:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
+            break;
+        }
+        case value_t::number_integer:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
+            break;
+        }
+        case value_t::number_float:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
+            break;
+        }
+        case value_t::boolean:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
+            break;
+        }
+
+        default:
+            JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));
+    }
+}
+
+template<typename BasicJsonType, typename A1, typename A2>
+void from_json(const BasicJsonType& j, std::pair<A1, A2>& p)
+{
+    p = {j.at(0).template get<A1>(), j.at(1).template get<A2>()};
+}
+
+template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
+void from_json_tuple_impl(const BasicJsonType& j, Tuple& t, index_sequence<Idx...> /*unused*/)
+{
+    t = std::make_tuple(j.at(Idx).template get<typename std::tuple_element<Idx, Tuple>::type>()...);
+}
+
+template<typename BasicJsonType, typename... Args>
+void from_json(const BasicJsonType& j, std::tuple<Args...>& t)
+{
+    from_json_tuple_impl(j, t, index_sequence_for<Args...> {});
+}
+
+template <typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
+          typename = enable_if_t<not std::is_constructible<
+                                     typename BasicJsonType::string_t, Key>::value>>
+void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
+{
+    if (JSON_UNLIKELY(not j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
+    }
+    for (const auto& p : j)
+    {
+        if (JSON_UNLIKELY(not p.is_array()))
+        {
+            JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
+        }
+        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
+    }
+}
+
+template <typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
+          typename = enable_if_t<not std::is_constructible<
+                                     typename BasicJsonType::string_t, Key>::value>>
+void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
+{
+    if (JSON_UNLIKELY(not j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
+    }
+    for (const auto& p : j)
+    {
+        if (JSON_UNLIKELY(not p.is_array()))
+        {
+            JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
+        }
+        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
+    }
+}
+
+struct from_json_fn
+{
+    template<typename BasicJsonType, typename T>
+    auto operator()(const BasicJsonType& j, T& val) const
+    noexcept(noexcept(from_json(j, val)))
+    -> decltype(from_json(j, val), void())
+    {
+        return from_json(j, val);
+    }
+};
+}  // namespace detail
+
+/// namespace to hold default `from_json` function
+/// to see why this is required:
+/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
+namespace
+{
+constexpr const auto& from_json = detail::static_const<detail::from_json_fn>::value;
+} // namespace
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/conversions/to_json.hpp>
+
+
+#include <ciso646> // or, and, not
+#include <iterator> // begin, end
+#include <tuple> // tuple, get
+#include <type_traits> // is_same, is_constructible, is_floating_point, is_enum, underlying_type
+#include <utility> // move, forward, declval, pair
+#include <valarray> // valarray
+#include <vector> // vector
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
+
+
+#include <cstddef> // size_t
+#include <string> // string, to_string
+#include <iterator> // input_iterator_tag
+#include <tuple> // tuple_size, get, tuple_element
+
+// #include <nlohmann/detail/value_t.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+template <typename IteratorType> class iteration_proxy_value
+{
+  public:
+    using difference_type = std::ptrdiff_t;
+    using value_type = iteration_proxy_value;
+    using pointer = value_type * ;
+    using reference = value_type & ;
+    using iterator_category = std::input_iterator_tag;
+
+  private:
+    /// the iterator
+    IteratorType anchor;
+    /// an index for arrays (used to create key names)
+    std::size_t array_index = 0;
+    /// last stringified array index
+    mutable std::size_t array_index_last = 0;
+    /// a string representation of the array index
+    mutable std::string array_index_str = "0";
+    /// an empty string (to return a reference for primitive values)
+    const std::string empty_str = "";
+
+  public:
+    explicit iteration_proxy_value(IteratorType it) noexcept : anchor(it) {}
+
+    /// dereference operator (needed for range-based for)
+    iteration_proxy_value& operator*()
+    {
+        return *this;
+    }
+
+    /// increment operator (needed for range-based for)
+    iteration_proxy_value& operator++()
+    {
+        ++anchor;
+        ++array_index;
+
+        return *this;
+    }
+
+    /// equality operator (needed for InputIterator)
+    bool operator==(const iteration_proxy_value& o) const noexcept
+    {
+        return anchor == o.anchor;
+    }
+
+    /// inequality operator (needed for range-based for)
+    bool operator!=(const iteration_proxy_value& o) const noexcept
+    {
+        return anchor != o.anchor;
+    }
+
+    /// return key of the iterator
+    const std::string& key() const
+    {
+        assert(anchor.m_object != nullptr);
+
+        switch (anchor.m_object->type())
+        {
+            // use integer array index as key
+            case value_t::array:
+            {
+                if (array_index != array_index_last)
+                {
+                    array_index_str = std::to_string(array_index);
+                    array_index_last = array_index;
+                }
+                return array_index_str;
+            }
+
+            // use key from the object
+            case value_t::object:
+                return anchor.key();
+
+            // use an empty key for all primitive types
+            default:
+                return empty_str;
+        }
+    }
+
+    /// return value of the iterator
+    typename IteratorType::reference value() const
+    {
+        return anchor.value();
+    }
+};
+
+/// proxy class for the items() function
+template<typename IteratorType> class iteration_proxy
+{
+  private:
+    /// the container to iterate
+    typename IteratorType::reference container;
+
+  public:
+    /// construct iteration proxy from a container
+    explicit iteration_proxy(typename IteratorType::reference cont) noexcept
+        : container(cont) {}
+
+    /// return iterator begin (needed for range-based for)
+    iteration_proxy_value<IteratorType> begin() noexcept
+    {
+        return iteration_proxy_value<IteratorType>(container.begin());
+    }
+
+    /// return iterator end (needed for range-based for)
+    iteration_proxy_value<IteratorType> end() noexcept
+    {
+        return iteration_proxy_value<IteratorType>(container.end());
+    }
+};
+// Structured Bindings Support
+// For further reference see https://blog.tartanllama.xyz/structured-bindings/
+// And see https://github.com/nlohmann/json/pull/1391
+template <std::size_t N, typename IteratorType, enable_if_t<N == 0, int> = 0>
+auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.key())
+{
+    return i.key();
+}
+// Structured Bindings Support
+// For further reference see https://blog.tartanllama.xyz/structured-bindings/
+// And see https://github.com/nlohmann/json/pull/1391
+template <std::size_t N, typename IteratorType, enable_if_t<N == 1, int> = 0>
+auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.value())
+{
+    return i.value();
+}
+}  // namespace detail
+}  // namespace nlohmann
+
+// The Addition to the STD Namespace is required to add
+// Structured Bindings Support to the iteration_proxy_value class
+// For further reference see https://blog.tartanllama.xyz/structured-bindings/
+// And see https://github.com/nlohmann/json/pull/1391
+namespace std
+{
+template <typename IteratorType>
+class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>>
+            : public std::integral_constant<std::size_t, 2> {};
+
+template <std::size_t N, typename IteratorType>
+class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >>
+{
+  public:
+    using type = decltype(
+                     get<N>(std::declval <
+                            ::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));
+};
+}
+
+namespace nlohmann
+{
+namespace detail
+{
+//////////////////
+// constructors //
+//////////////////
+
+template<value_t> struct external_constructor;
+
+template<>
+struct external_constructor<value_t::boolean>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept
+    {
+        j.m_type = value_t::boolean;
+        j.m_value = b;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::string>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
+    {
+        j.m_type = value_t::string;
+        j.m_value = s;
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s)
+    {
+        j.m_type = value_t::string;
+        j.m_value = std::move(s);
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType, typename CompatibleStringType,
+             enable_if_t<not std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,
+                         int> = 0>
+    static void construct(BasicJsonType& j, const CompatibleStringType& str)
+    {
+        j.m_type = value_t::string;
+        j.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::number_float>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept
+    {
+        j.m_type = value_t::number_float;
+        j.m_value = val;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::number_unsigned>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept
+    {
+        j.m_type = value_t::number_unsigned;
+        j.m_value = val;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::number_integer>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept
+    {
+        j.m_type = value_t::number_integer;
+        j.m_value = val;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::array>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)
+    {
+        j.m_type = value_t::array;
+        j.m_value = arr;
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
+    {
+        j.m_type = value_t::array;
+        j.m_value = std::move(arr);
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType, typename CompatibleArrayType,
+             enable_if_t<not std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
+                         int> = 0>
+    static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
+    {
+        using std::begin;
+        using std::end;
+        j.m_type = value_t::array;
+        j.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const std::vector<bool>& arr)
+    {
+        j.m_type = value_t::array;
+        j.m_value = value_t::array;
+        j.m_value.array->reserve(arr.size());
+        for (const bool x : arr)
+        {
+            j.m_value.array->push_back(x);
+        }
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType, typename T,
+             enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
+    static void construct(BasicJsonType& j, const std::valarray<T>& arr)
+    {
+        j.m_type = value_t::array;
+        j.m_value = value_t::array;
+        j.m_value.array->resize(arr.size());
+        std::copy(std::begin(arr), std::end(arr), j.m_value.array->begin());
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::object>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)
+    {
+        j.m_type = value_t::object;
+        j.m_value = obj;
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
+    {
+        j.m_type = value_t::object;
+        j.m_value = std::move(obj);
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType, typename CompatibleObjectType,
+             enable_if_t<not std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value, int> = 0>
+    static void construct(BasicJsonType& j, const CompatibleObjectType& obj)
+    {
+        using std::begin;
+        using std::end;
+
+        j.m_type = value_t::object;
+        j.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
+        j.assert_invariant();
+    }
+};
+
+/////////////
+// to_json //
+/////////////
+
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_same<T, typename BasicJsonType::boolean_t>::value, int> = 0>
+void to_json(BasicJsonType& j, T b) noexcept
+{
+    external_constructor<value_t::boolean>::construct(j, b);
+}
+
+template<typename BasicJsonType, typename CompatibleString,
+         enable_if_t<std::is_constructible<typename BasicJsonType::string_t, CompatibleString>::value, int> = 0>
+void to_json(BasicJsonType& j, const CompatibleString& s)
+{
+    external_constructor<value_t::string>::construct(j, s);
+}
+
+template<typename BasicJsonType>
+void to_json(BasicJsonType& j, typename BasicJsonType::string_t&& s)
+{
+    external_constructor<value_t::string>::construct(j, std::move(s));
+}
+
+template<typename BasicJsonType, typename FloatType,
+         enable_if_t<std::is_floating_point<FloatType>::value, int> = 0>
+void to_json(BasicJsonType& j, FloatType val) noexcept
+{
+    external_constructor<value_t::number_float>::construct(j, static_cast<typename BasicJsonType::number_float_t>(val));
+}
+
+template<typename BasicJsonType, typename CompatibleNumberUnsignedType,
+         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType>::value, int> = 0>
+void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept
+{
+    external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val));
+}
+
+template<typename BasicJsonType, typename CompatibleNumberIntegerType,
+         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType>::value, int> = 0>
+void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept
+{
+    external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val));
+}
+
+template<typename BasicJsonType, typename EnumType,
+         enable_if_t<std::is_enum<EnumType>::value, int> = 0>
+void to_json(BasicJsonType& j, EnumType e) noexcept
+{
+    using underlying_type = typename std::underlying_type<EnumType>::type;
+    external_constructor<value_t::number_integer>::construct(j, static_cast<underlying_type>(e));
+}
+
+template<typename BasicJsonType>
+void to_json(BasicJsonType& j, const std::vector<bool>& e)
+{
+    external_constructor<value_t::array>::construct(j, e);
+}
+
+template <typename BasicJsonType, typename CompatibleArrayType,
+          enable_if_t<is_compatible_array_type<BasicJsonType,
+                      CompatibleArrayType>::value and
+                      not is_compatible_object_type<
+                          BasicJsonType, CompatibleArrayType>::value and
+                      not is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value and
+                      not is_basic_json<CompatibleArrayType>::value,
+                      int> = 0>
+void to_json(BasicJsonType& j, const CompatibleArrayType& arr)
+{
+    external_constructor<value_t::array>::construct(j, arr);
+}
+
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
+void to_json(BasicJsonType& j, const std::valarray<T>& arr)
+{
+    external_constructor<value_t::array>::construct(j, std::move(arr));
+}
+
+template<typename BasicJsonType>
+void to_json(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
+{
+    external_constructor<value_t::array>::construct(j, std::move(arr));
+}
+
+template<typename BasicJsonType, typename CompatibleObjectType,
+         enable_if_t<is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value and not is_basic_json<CompatibleObjectType>::value, int> = 0>
+void to_json(BasicJsonType& j, const CompatibleObjectType& obj)
+{
+    external_constructor<value_t::object>::construct(j, obj);
+}
+
+template<typename BasicJsonType>
+void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
+{
+    external_constructor<value_t::object>::construct(j, std::move(obj));
+}
+
+template <
+    typename BasicJsonType, typename T, std::size_t N,
+    enable_if_t<not std::is_constructible<typename BasicJsonType::string_t,
+                const T(&)[N]>::value,
+                int> = 0 >
+void to_json(BasicJsonType& j, const T(&arr)[N])
+{
+    external_constructor<value_t::array>::construct(j, arr);
+}
+
+template<typename BasicJsonType, typename... Args>
+void to_json(BasicJsonType& j, const std::pair<Args...>& p)
+{
+    j = { p.first, p.second };
+}
+
+// for https://github.com/nlohmann/json/pull/1134
+template < typename BasicJsonType, typename T,
+           enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value, int> = 0>
+void to_json(BasicJsonType& j, const T& b)
+{
+    j = { {b.key(), b.value()} };
+}
+
+template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
+void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<Idx...> /*unused*/)
+{
+    j = { std::get<Idx>(t)... };
+}
+
+template<typename BasicJsonType, typename... Args>
+void to_json(BasicJsonType& j, const std::tuple<Args...>& t)
+{
+    to_json_tuple_impl(j, t, index_sequence_for<Args...> {});
+}
+
+struct to_json_fn
+{
+    template<typename BasicJsonType, typename T>
+    auto operator()(BasicJsonType& j, T&& val) const noexcept(noexcept(to_json(j, std::forward<T>(val))))
+    -> decltype(to_json(j, std::forward<T>(val)), void())
+    {
+        return to_json(j, std::forward<T>(val));
+    }
+};
+}  // namespace detail
+
+/// namespace to hold default `to_json` function
+namespace
+{
+constexpr const auto& to_json = detail::static_const<detail::to_json_fn>::value;
+} // namespace
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+
+#include <cassert> // assert
+#include <cstddef> // size_t
+#include <cstring> // strlen
+#include <istream> // istream
+#include <iterator> // begin, end, iterator_traits, random_access_iterator_tag, distance, next
+#include <memory> // shared_ptr, make_shared, addressof
+#include <numeric> // accumulate
+#include <string> // string, char_traits
+#include <type_traits> // enable_if, is_base_of, is_pointer, is_integral, remove_pointer
+#include <utility> // pair, declval
+#include <cstdio> //FILE *
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+/// the supported input formats
+enum class input_format_t { json, cbor, msgpack, ubjson, bson };
+
+////////////////////
+// input adapters //
+////////////////////
+
+/*!
+@brief abstract input adapter interface
+
+Produces a stream of std::char_traits<char>::int_type characters from a
+std::istream, a buffer, or some other input type. Accepts the return of
+exactly one non-EOF character for future input. The int_type characters
+returned consist of all valid char values as positive values (typically
+unsigned char), plus an EOF value outside that range, specified by the value
+of the function std::char_traits<char>::eof(). This value is typically -1, but
+could be any arbitrary value which is not a valid char value.
+*/
+struct input_adapter_protocol
+{
+    /// get a character [0,255] or std::char_traits<char>::eof().
+    virtual std::char_traits<char>::int_type get_character() = 0;
+    virtual ~input_adapter_protocol() = default;
+};
+
+/// a type to simplify interfaces
+using input_adapter_t = std::shared_ptr<input_adapter_protocol>;
+
+/*!
+Input adapter for stdio file access. This adapter read only 1 byte and do not use any
+ buffer. This adapter is a very low level adapter.
+*/
+class file_input_adapter : public input_adapter_protocol
+{
+  public:
+    explicit file_input_adapter(std::FILE* f)  noexcept
+        : m_file(f)
+    {}
+
+    std::char_traits<char>::int_type get_character() noexcept override
+    {
+        return std::fgetc(m_file);
+    }
+  private:
+    /// the file pointer to read from
+    std::FILE* m_file;
+};
+
+
+/*!
+Input adapter for a (caching) istream. Ignores a UFT Byte Order Mark at
+beginning of input. Does not support changing the underlying std::streambuf
+in mid-input. Maintains underlying std::istream and std::streambuf to support
+subsequent use of standard std::istream operations to process any input
+characters following those used in parsing the JSON input.  Clears the
+std::istream flags; any input errors (e.g., EOF) will be detected by the first
+subsequent call for input from the std::istream.
+*/
+class input_stream_adapter : public input_adapter_protocol
+{
+  public:
+    ~input_stream_adapter() override
+    {
+        // clear stream flags; we use underlying streambuf I/O, do not
+        // maintain ifstream flags, except eof
+        is.clear(is.rdstate() & std::ios::eofbit);
+    }
+
+    explicit input_stream_adapter(std::istream& i)
+        : is(i), sb(*i.rdbuf())
+    {}
+
+    // delete because of pointer members
+    input_stream_adapter(const input_stream_adapter&) = delete;
+    input_stream_adapter& operator=(input_stream_adapter&) = delete;
+    input_stream_adapter(input_stream_adapter&&) = delete;
+    input_stream_adapter& operator=(input_stream_adapter&&) = delete;
+
+    // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to
+    // ensure that std::char_traits<char>::eof() and the character 0xFF do not
+    // end up as the same value, eg. 0xFFFFFFFF.
+    std::char_traits<char>::int_type get_character() override
+    {
+        auto res = sb.sbumpc();
+        // set eof manually, as we don't use the istream interface.
+        if (res == EOF)
+        {
+            is.clear(is.rdstate() | std::ios::eofbit);
+        }
+        return res;
+    }
+
+  private:
+    /// the associated input stream
+    std::istream& is;
+    std::streambuf& sb;
+};
+
+/// input adapter for buffer input
+class input_buffer_adapter : public input_adapter_protocol
+{
+  public:
+    input_buffer_adapter(const char* b, const std::size_t l) noexcept
+        : cursor(b), limit(b + l)
+    {}
+
+    // delete because of pointer members
+    input_buffer_adapter(const input_buffer_adapter&) = delete;
+    input_buffer_adapter& operator=(input_buffer_adapter&) = delete;
+    input_buffer_adapter(input_buffer_adapter&&) = delete;
+    input_buffer_adapter& operator=(input_buffer_adapter&&) = delete;
+    ~input_buffer_adapter() override = default;
+
+    std::char_traits<char>::int_type get_character() noexcept override
+    {
+        if (JSON_LIKELY(cursor < limit))
+        {
+            return std::char_traits<char>::to_int_type(*(cursor++));
+        }
+
+        return std::char_traits<char>::eof();
+    }
+
+  private:
+    /// pointer to the current character
+    const char* cursor;
+    /// pointer past the last character
+    const char* const limit;
+};
+
+template<typename WideStringType, size_t T>
+struct wide_string_input_helper
+{
+    // UTF-32
+    static void fill_buffer(const WideStringType& str, size_t& current_wchar, std::array<std::char_traits<char>::int_type, 4>& utf8_bytes, size_t& utf8_bytes_index, size_t& utf8_bytes_filled)
+    {
+        utf8_bytes_index = 0;
+
+        if (current_wchar == str.size())
+        {
+            utf8_bytes[0] = std::char_traits<char>::eof();
+            utf8_bytes_filled = 1;
+        }
+        else
+        {
+            // get the current character
+            const auto wc = static_cast<int>(str[current_wchar++]);
+
+            // UTF-32 to UTF-8 encoding
+            if (wc < 0x80)
+            {
+                utf8_bytes[0] = wc;
+                utf8_bytes_filled = 1;
+            }
+            else if (wc <= 0x7FF)
+            {
+                utf8_bytes[0] = 0xC0 | ((wc >> 6) & 0x1F);
+                utf8_bytes[1] = 0x80 | (wc & 0x3F);
+                utf8_bytes_filled = 2;
+            }
+            else if (wc <= 0xFFFF)
+            {
+                utf8_bytes[0] = 0xE0 | ((wc >> 12) & 0x0F);
+                utf8_bytes[1] = 0x80 | ((wc >> 6) & 0x3F);
+                utf8_bytes[2] = 0x80 | (wc & 0x3F);
+                utf8_bytes_filled = 3;
+            }
+            else if (wc <= 0x10FFFF)
+            {
+                utf8_bytes[0] = 0xF0 | ((wc >> 18) & 0x07);
+                utf8_bytes[1] = 0x80 | ((wc >> 12) & 0x3F);
+                utf8_bytes[2] = 0x80 | ((wc >> 6) & 0x3F);
+                utf8_bytes[3] = 0x80 | (wc & 0x3F);
+                utf8_bytes_filled = 4;
+            }
+            else
+            {
+                // unknown character
+                utf8_bytes[0] = wc;
+                utf8_bytes_filled = 1;
+            }
+        }
+    }
+};
+
+template<typename WideStringType>
+struct wide_string_input_helper<WideStringType, 2>
+{
+    // UTF-16
+    static void fill_buffer(const WideStringType& str, size_t& current_wchar, std::array<std::char_traits<char>::int_type, 4>& utf8_bytes, size_t& utf8_bytes_index, size_t& utf8_bytes_filled)
+    {
+        utf8_bytes_index = 0;
+
+        if (current_wchar == str.size())
+        {
+            utf8_bytes[0] = std::char_traits<char>::eof();
+            utf8_bytes_filled = 1;
+        }
+        else
+        {
+            // get the current character
+            const auto wc = static_cast<int>(str[current_wchar++]);
+
+            // UTF-16 to UTF-8 encoding
+            if (wc < 0x80)
+            {
+                utf8_bytes[0] = wc;
+                utf8_bytes_filled = 1;
+            }
+            else if (wc <= 0x7FF)
+            {
+                utf8_bytes[0] = 0xC0 | ((wc >> 6));
+                utf8_bytes[1] = 0x80 | (wc & 0x3F);
+                utf8_bytes_filled = 2;
+            }
+            else if (0xD800 > wc or wc >= 0xE000)
+            {
+                utf8_bytes[0] = 0xE0 | ((wc >> 12));
+                utf8_bytes[1] = 0x80 | ((wc >> 6) & 0x3F);
+                utf8_bytes[2] = 0x80 | (wc & 0x3F);
+                utf8_bytes_filled = 3;
+            }
+            else
+            {
+                if (current_wchar < str.size())
+                {
+                    const auto wc2 = static_cast<int>(str[current_wchar++]);
+                    const int charcode = 0x10000 + (((wc & 0x3FF) << 10) | (wc2 & 0x3FF));
+                    utf8_bytes[0] = 0xf0 | (charcode >> 18);
+                    utf8_bytes[1] = 0x80 | ((charcode >> 12) & 0x3F);
+                    utf8_bytes[2] = 0x80 | ((charcode >> 6) & 0x3F);
+                    utf8_bytes[3] = 0x80 | (charcode & 0x3F);
+                    utf8_bytes_filled = 4;
+                }
+                else
+                {
+                    // unknown character
+                    ++current_wchar;
+                    utf8_bytes[0] = wc;
+                    utf8_bytes_filled = 1;
+                }
+            }
+        }
+    }
+};
+
+template<typename WideStringType>
+class wide_string_input_adapter : public input_adapter_protocol
+{
+  public:
+    explicit wide_string_input_adapter(const WideStringType& w)  noexcept
+        : str(w)
+    {}
+
+    std::char_traits<char>::int_type get_character() noexcept override
+    {
+        // check if buffer needs to be filled
+        if (utf8_bytes_index == utf8_bytes_filled)
+        {
+            fill_buffer<sizeof(typename WideStringType::value_type)>();
+
+            assert(utf8_bytes_filled > 0);
+            assert(utf8_bytes_index == 0);
+        }
+
+        // use buffer
+        assert(utf8_bytes_filled > 0);
+        assert(utf8_bytes_index < utf8_bytes_filled);
+        return utf8_bytes[utf8_bytes_index++];
+    }
+
+  private:
+    template<size_t T>
+    void fill_buffer()
+    {
+        wide_string_input_helper<WideStringType, T>::fill_buffer(str, current_wchar, utf8_bytes, utf8_bytes_index, utf8_bytes_filled);
+    }
+
+    /// the wstring to process
+    const WideStringType& str;
+
+    /// index of the current wchar in str
+    std::size_t current_wchar = 0;
+
+    /// a buffer for UTF-8 bytes
+    std::array<std::char_traits<char>::int_type, 4> utf8_bytes = {{0, 0, 0, 0}};
+
+    /// index to the utf8_codes array for the next valid byte
+    std::size_t utf8_bytes_index = 0;
+    /// number of valid bytes in the utf8_codes array
+    std::size_t utf8_bytes_filled = 0;
+};
+
+class input_adapter
+{
+  public:
+    // native support
+    input_adapter(std::FILE* file)
+        : ia(std::make_shared<file_input_adapter>(file)) {}
+    /// input adapter for input stream
+    input_adapter(std::istream& i)
+        : ia(std::make_shared<input_stream_adapter>(i)) {}
+
+    /// input adapter for input stream
+    input_adapter(std::istream&& i)
+        : ia(std::make_shared<input_stream_adapter>(i)) {}
+
+    input_adapter(const std::wstring& ws)
+        : ia(std::make_shared<wide_string_input_adapter<std::wstring>>(ws)) {}
+
+    input_adapter(const std::u16string& ws)
+        : ia(std::make_shared<wide_string_input_adapter<std::u16string>>(ws)) {}
+
+    input_adapter(const std::u32string& ws)
+        : ia(std::make_shared<wide_string_input_adapter<std::u32string>>(ws)) {}
+
+    /// input adapter for buffer
+    template<typename CharT,
+             typename std::enable_if<
+                 std::is_pointer<CharT>::value and
+                 std::is_integral<typename std::remove_pointer<CharT>::type>::value and
+                 sizeof(typename std::remove_pointer<CharT>::type) == 1,
+                 int>::type = 0>
+    input_adapter(CharT b, std::size_t l)
+        : ia(std::make_shared<input_buffer_adapter>(reinterpret_cast<const char*>(b), l)) {}
+
+    // derived support
+
+    /// input adapter for string literal
+    template<typename CharT,
+             typename std::enable_if<
+                 std::is_pointer<CharT>::value and
+                 std::is_integral<typename std::remove_pointer<CharT>::type>::value and
+                 sizeof(typename std::remove_pointer<CharT>::type) == 1,
+                 int>::type = 0>
+    input_adapter(CharT b)
+        : input_adapter(reinterpret_cast<const char*>(b),
+                        std::strlen(reinterpret_cast<const char*>(b))) {}
+
+    /// input adapter for iterator range with contiguous storage
+    template<class IteratorType,
+             typename std::enable_if<
+                 std::is_same<typename iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,
+                 int>::type = 0>
+    input_adapter(IteratorType first, IteratorType last)
+    {
+#ifndef NDEBUG
+        // assertion to check that the iterator range is indeed contiguous,
+        // see http://stackoverflow.com/a/35008842/266378 for more discussion
+        const auto is_contiguous = std::accumulate(
+                                       first, last, std::pair<bool, int>(true, 0),
+                                       [&first](std::pair<bool, int> res, decltype(*first) val)
+        {
+            res.first &= (val == *(std::next(std::addressof(*first), res.second++)));
+            return res;
+        }).first;
+        assert(is_contiguous);
+#endif
+
+        // assertion to check that each element is 1 byte long
+        static_assert(
+            sizeof(typename iterator_traits<IteratorType>::value_type) == 1,
+            "each element in the iterator range must have the size of 1 byte");
+
+        const auto len = static_cast<size_t>(std::distance(first, last));
+        if (JSON_LIKELY(len > 0))
+        {
+            // there is at least one element: use the address of first
+            ia = std::make_shared<input_buffer_adapter>(reinterpret_cast<const char*>(&(*first)), len);
+        }
+        else
+        {
+            // the address of first cannot be used: use nullptr
+            ia = std::make_shared<input_buffer_adapter>(nullptr, len);
+        }
+    }
+
+    /// input adapter for array
+    template<class T, std::size_t N>
+    input_adapter(T (&array)[N])
+        : input_adapter(std::begin(array), std::end(array)) {}
+
+    /// input adapter for contiguous container
+    template<class ContiguousContainer, typename
+             std::enable_if<not std::is_pointer<ContiguousContainer>::value and
+                            std::is_base_of<std::random_access_iterator_tag, typename iterator_traits<decltype(std::begin(std::declval<ContiguousContainer const>()))>::iterator_category>::value,
+                            int>::type = 0>
+    input_adapter(const ContiguousContainer& c)
+        : input_adapter(std::begin(c), std::end(c)) {}
+
+    operator input_adapter_t()
+    {
+        return ia;
+    }
+
+  private:
+    /// the actual adapter
+    input_adapter_t ia = nullptr;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/input/lexer.hpp>
+
+
+#include <clocale> // localeconv
+#include <cstddef> // size_t
+#include <cstdlib> // strtof, strtod, strtold, strtoll, strtoull
+#include <cstdio> // snprintf
+#include <initializer_list> // initializer_list
+#include <string> // char_traits, string
+#include <vector> // vector
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+// #include <nlohmann/detail/input/position_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+///////////
+// lexer //
+///////////
+
+/*!
+@brief lexical analysis
+
+This class organizes the lexical analysis during JSON deserialization.
+*/
+template<typename BasicJsonType>
+class lexer
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+
+  public:
+    /// token types for the parser
+    enum class token_type
+    {
+        uninitialized,    ///< indicating the scanner is uninitialized
+        literal_true,     ///< the `true` literal
+        literal_false,    ///< the `false` literal
+        literal_null,     ///< the `null` literal
+        value_string,     ///< a string -- use get_string() for actual value
+        value_unsigned,   ///< an unsigned integer -- use get_number_unsigned() for actual value
+        value_integer,    ///< a signed integer -- use get_number_integer() for actual value
+        value_float,      ///< an floating point number -- use get_number_float() for actual value
+        begin_array,      ///< the character for array begin `[`
+        begin_object,     ///< the character for object begin `{`
+        end_array,        ///< the character for array end `]`
+        end_object,       ///< the character for object end `}`
+        name_separator,   ///< the name separator `:`
+        value_separator,  ///< the value separator `,`
+        parse_error,      ///< indicating a parse error
+        end_of_input,     ///< indicating the end of the input buffer
+        literal_or_value  ///< a literal or the begin of a value (only for diagnostics)
+    };
+
+    /// return name of values of type token_type (only used for errors)
+    static const char* token_type_name(const token_type t) noexcept
+    {
+        switch (t)
+        {
+            case token_type::uninitialized:
+                return "<uninitialized>";
+            case token_type::literal_true:
+                return "true literal";
+            case token_type::literal_false:
+                return "false literal";
+            case token_type::literal_null:
+                return "null literal";
+            case token_type::value_string:
+                return "string literal";
+            case lexer::token_type::value_unsigned:
+            case lexer::token_type::value_integer:
+            case lexer::token_type::value_float:
+                return "number literal";
+            case token_type::begin_array:
+                return "'['";
+            case token_type::begin_object:
+                return "'{'";
+            case token_type::end_array:
+                return "']'";
+            case token_type::end_object:
+                return "'}'";
+            case token_type::name_separator:
+                return "':'";
+            case token_type::value_separator:
+                return "','";
+            case token_type::parse_error:
+                return "<parse error>";
+            case token_type::end_of_input:
+                return "end of input";
+            case token_type::literal_or_value:
+                return "'[', '{', or a literal";
+            // LCOV_EXCL_START
+            default: // catch non-enum values
+                return "unknown token";
+                // LCOV_EXCL_STOP
+        }
+    }
+
+    explicit lexer(detail::input_adapter_t&& adapter)
+        : ia(std::move(adapter)), decimal_point_char(get_decimal_point()) {}
+
+    // delete because of pointer members
+    lexer(const lexer&) = delete;
+    lexer(lexer&&) = delete;
+    lexer& operator=(lexer&) = delete;
+    lexer& operator=(lexer&&) = delete;
+    ~lexer() = default;
+
+  private:
+    /////////////////////
+    // locales
+    /////////////////////
+
+    /// return the locale-dependent decimal point
+    static char get_decimal_point() noexcept
+    {
+        const auto loc = localeconv();
+        assert(loc != nullptr);
+        return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);
+    }
+
+    /////////////////////
+    // scan functions
+    /////////////////////
+
+    /*!
+    @brief get codepoint from 4 hex characters following `\u`
+
+    For input "\u c1 c2 c3 c4" the codepoint is:
+      (c1 * 0x1000) + (c2 * 0x0100) + (c3 * 0x0010) + c4
+    = (c1 << 12) + (c2 << 8) + (c3 << 4) + (c4 << 0)
+
+    Furthermore, the possible characters '0'..'9', 'A'..'F', and 'a'..'f'
+    must be converted to the integers 0x0..0x9, 0xA..0xF, 0xA..0xF, resp. The
+    conversion is done by subtracting the offset (0x30, 0x37, and 0x57)
+    between the ASCII value of the character and the desired integer value.
+
+    @return codepoint (0x0000..0xFFFF) or -1 in case of an error (e.g. EOF or
+            non-hex character)
+    */
+    int get_codepoint()
+    {
+        // this function only makes sense after reading `\u`
+        assert(current == 'u');
+        int codepoint = 0;
+
+        const auto factors = { 12, 8, 4, 0 };
+        for (const auto factor : factors)
+        {
+            get();
+
+            if (current >= '0' and current <= '9')
+            {
+                codepoint += ((current - 0x30) << factor);
+            }
+            else if (current >= 'A' and current <= 'F')
+            {
+                codepoint += ((current - 0x37) << factor);
+            }
+            else if (current >= 'a' and current <= 'f')
+            {
+                codepoint += ((current - 0x57) << factor);
+            }
+            else
+            {
+                return -1;
+            }
+        }
+
+        assert(0x0000 <= codepoint and codepoint <= 0xFFFF);
+        return codepoint;
+    }
+
+    /*!
+    @brief check if the next byte(s) are inside a given range
+
+    Adds the current byte and, for each passed range, reads a new byte and
+    checks if it is inside the range. If a violation was detected, set up an
+    error message and return false. Otherwise, return true.
+
+    @param[in] ranges  list of integers; interpreted as list of pairs of
+                       inclusive lower and upper bound, respectively
+
+    @pre The passed list @a ranges must have 2, 4, or 6 elements; that is,
+         1, 2, or 3 pairs. This precondition is enforced by an assertion.
+
+    @return true if and only if no range violation was detected
+    */
+    bool next_byte_in_range(std::initializer_list<int> ranges)
+    {
+        assert(ranges.size() == 2 or ranges.size() == 4 or ranges.size() == 6);
+        add(current);
+
+        for (auto range = ranges.begin(); range != ranges.end(); ++range)
+        {
+            get();
+            if (JSON_LIKELY(*range <= current and current <= *(++range)))
+            {
+                add(current);
+            }
+            else
+            {
+                error_message = "invalid string: ill-formed UTF-8 byte";
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /*!
+    @brief scan a string literal
+
+    This function scans a string according to Sect. 7 of RFC 7159. While
+    scanning, bytes are escaped and copied into buffer token_buffer. Then the
+    function returns successfully, token_buffer is *not* null-terminated (as it
+    may contain \0 bytes), and token_buffer.size() is the number of bytes in the
+    string.
+
+    @return token_type::value_string if string could be successfully scanned,
+            token_type::parse_error otherwise
+
+    @note In case of errors, variable error_message contains a textual
+          description.
+    */
+    token_type scan_string()
+    {
+        // reset token_buffer (ignore opening quote)
+        reset();
+
+        // we entered the function by reading an open quote
+        assert(current == '\"');
+
+        while (true)
+        {
+            // get next character
+            switch (get())
+            {
+                // end of file while parsing string
+                case std::char_traits<char>::eof():
+                {
+                    error_message = "invalid string: missing closing quote";
+                    return token_type::parse_error;
+                }
+
+                // closing quote
+                case '\"':
+                {
+                    return token_type::value_string;
+                }
+
+                // escapes
+                case '\\':
+                {
+                    switch (get())
+                    {
+                        // quotation mark
+                        case '\"':
+                            add('\"');
+                            break;
+                        // reverse solidus
+                        case '\\':
+                            add('\\');
+                            break;
+                        // solidus
+                        case '/':
+                            add('/');
+                            break;
+                        // backspace
+                        case 'b':
+                            add('\b');
+                            break;
+                        // form feed
+                        case 'f':
+                            add('\f');
+                            break;
+                        // line feed
+                        case 'n':
+                            add('\n');
+                            break;
+                        // carriage return
+                        case 'r':
+                            add('\r');
+                            break;
+                        // tab
+                        case 't':
+                            add('\t');
+                            break;
+
+                        // unicode escapes
+                        case 'u':
+                        {
+                            const int codepoint1 = get_codepoint();
+                            int codepoint = codepoint1; // start with codepoint1
+
+                            if (JSON_UNLIKELY(codepoint1 == -1))
+                            {
+                                error_message = "invalid string: '\\u' must be followed by 4 hex digits";
+                                return token_type::parse_error;
+                            }
+
+                            // check if code point is a high surrogate
+                            if (0xD800 <= codepoint1 and codepoint1 <= 0xDBFF)
+                            {
+                                // expect next \uxxxx entry
+                                if (JSON_LIKELY(get() == '\\' and get() == 'u'))
+                                {
+                                    const int codepoint2 = get_codepoint();
+
+                                    if (JSON_UNLIKELY(codepoint2 == -1))
+                                    {
+                                        error_message = "invalid string: '\\u' must be followed by 4 hex digits";
+                                        return token_type::parse_error;
+                                    }
+
+                                    // check if codepoint2 is a low surrogate
+                                    if (JSON_LIKELY(0xDC00 <= codepoint2 and codepoint2 <= 0xDFFF))
+                                    {
+                                        // overwrite codepoint
+                                        codepoint =
+                                            // high surrogate occupies the most significant 22 bits
+                                            (codepoint1 << 10)
+                                            // low surrogate occupies the least significant 15 bits
+                                            + codepoint2
+                                            // there is still the 0xD800, 0xDC00 and 0x10000 noise
+                                            // in the result so we have to subtract with:
+                                            // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
+                                            - 0x35FDC00;
+                                    }
+                                    else
+                                    {
+                                        error_message = "invalid string: surrogate U+DC00..U+DFFF must be followed by U+DC00..U+DFFF";
+                                        return token_type::parse_error;
+                                    }
+                                }
+                                else
+                                {
+                                    error_message = "invalid string: surrogate U+DC00..U+DFFF must be followed by U+DC00..U+DFFF";
+                                    return token_type::parse_error;
+                                }
+                            }
+                            else
+                            {
+                                if (JSON_UNLIKELY(0xDC00 <= codepoint1 and codepoint1 <= 0xDFFF))
+                                {
+                                    error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
+                                    return token_type::parse_error;
+                                }
+                            }
+
+                            // result of the above calculation yields a proper codepoint
+                            assert(0x00 <= codepoint and codepoint <= 0x10FFFF);
+
+                            // translate codepoint into bytes
+                            if (codepoint < 0x80)
+                            {
+                                // 1-byte characters: 0xxxxxxx (ASCII)
+                                add(codepoint);
+                            }
+                            else if (codepoint <= 0x7FF)
+                            {
+                                // 2-byte characters: 110xxxxx 10xxxxxx
+                                add(0xC0 | (codepoint >> 6));
+                                add(0x80 | (codepoint & 0x3F));
+                            }
+                            else if (codepoint <= 0xFFFF)
+                            {
+                                // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
+                                add(0xE0 | (codepoint >> 12));
+                                add(0x80 | ((codepoint >> 6) & 0x3F));
+                                add(0x80 | (codepoint & 0x3F));
+                            }
+                            else
+                            {
+                                // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+                                add(0xF0 | (codepoint >> 18));
+                                add(0x80 | ((codepoint >> 12) & 0x3F));
+                                add(0x80 | ((codepoint >> 6) & 0x3F));
+                                add(0x80 | (codepoint & 0x3F));
+                            }
+
+                            break;
+                        }
+
+                        // other characters after escape
+                        default:
+                            error_message = "invalid string: forbidden character after backslash";
+                            return token_type::parse_error;
+                    }
+
+                    break;
+                }
+
+                // invalid control characters
+                case 0x00:
+                {
+                    error_message = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
+                    return token_type::parse_error;
+                }
+
+                case 0x01:
+                {
+                    error_message = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
+                    return token_type::parse_error;
+                }
+
+                case 0x02:
+                {
+                    error_message = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
+                    return token_type::parse_error;
+                }
+
+                case 0x03:
+                {
+                    error_message = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
+                    return token_type::parse_error;
+                }
+
+                case 0x04:
+                {
+                    error_message = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
+                    return token_type::parse_error;
+                }
+
+                case 0x05:
+                {
+                    error_message = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
+                    return token_type::parse_error;
+                }
+
+                case 0x06:
+                {
+                    error_message = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
+                    return token_type::parse_error;
+                }
+
+                case 0x07:
+                {
+                    error_message = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
+                    return token_type::parse_error;
+                }
+
+                case 0x08:
+                {
+                    error_message = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
+                    return token_type::parse_error;
+                }
+
+                case 0x09:
+                {
+                    error_message = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
+                    return token_type::parse_error;
+                }
+
+                case 0x0A:
+                {
+                    error_message = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
+                    return token_type::parse_error;
+                }
+
+                case 0x0B:
+                {
+                    error_message = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
+                    return token_type::parse_error;
+                }
+
+                case 0x0C:
+                {
+                    error_message = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
+                    return token_type::parse_error;
+                }
+
+                case 0x0D:
+                {
+                    error_message = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
+                    return token_type::parse_error;
+                }
+
+                case 0x0E:
+                {
+                    error_message = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
+                    return token_type::parse_error;
+                }
+
+                case 0x0F:
+                {
+                    error_message = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
+                    return token_type::parse_error;
+                }
+
+                case 0x10:
+                {
+                    error_message = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
+                    return token_type::parse_error;
+                }
+
+                case 0x11:
+                {
+                    error_message = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
+                    return token_type::parse_error;
+                }
+
+                case 0x12:
+                {
+                    error_message = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
+                    return token_type::parse_error;
+                }
+
+                case 0x13:
+                {
+                    error_message = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
+                    return token_type::parse_error;
+                }
+
+                case 0x14:
+                {
+                    error_message = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
+                    return token_type::parse_error;
+                }
+
+                case 0x15:
+                {
+                    error_message = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
+                    return token_type::parse_error;
+                }
+
+                case 0x16:
+                {
+                    error_message = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
+                    return token_type::parse_error;
+                }
+
+                case 0x17:
+                {
+                    error_message = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
+                    return token_type::parse_error;
+                }
+
+                case 0x18:
+                {
+                    error_message = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
+                    return token_type::parse_error;
+                }
+
+                case 0x19:
+                {
+                    error_message = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
+                    return token_type::parse_error;
+                }
+
+                case 0x1A:
+                {
+                    error_message = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
+                    return token_type::parse_error;
+                }
+
+                case 0x1B:
+                {
+                    error_message = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
+                    return token_type::parse_error;
+                }
+
+                case 0x1C:
+                {
+                    error_message = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
+                    return token_type::parse_error;
+                }
+
+                case 0x1D:
+                {
+                    error_message = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
+                    return token_type::parse_error;
+                }
+
+                case 0x1E:
+                {
+                    error_message = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
+                    return token_type::parse_error;
+                }
+
+                case 0x1F:
+                {
+                    error_message = "invalid string: control character U+001F (US) must be escaped to \\u001F";
+                    return token_type::parse_error;
+                }
+
+                // U+0020..U+007F (except U+0022 (quote) and U+005C (backspace))
+                case 0x20:
+                case 0x21:
+                case 0x23:
+                case 0x24:
+                case 0x25:
+                case 0x26:
+                case 0x27:
+                case 0x28:
+                case 0x29:
+                case 0x2A:
+                case 0x2B:
+                case 0x2C:
+                case 0x2D:
+                case 0x2E:
+                case 0x2F:
+                case 0x30:
+                case 0x31:
+                case 0x32:
+                case 0x33:
+                case 0x34:
+                case 0x35:
+                case 0x36:
+                case 0x37:
+                case 0x38:
+                case 0x39:
+                case 0x3A:
+                case 0x3B:
+                case 0x3C:
+                case 0x3D:
+                case 0x3E:
+                case 0x3F:
+                case 0x40:
+                case 0x41:
+                case 0x42:
+                case 0x43:
+                case 0x44:
+                case 0x45:
+                case 0x46:
+                case 0x47:
+                case 0x48:
+                case 0x49:
+                case 0x4A:
+                case 0x4B:
+                case 0x4C:
+                case 0x4D:
+                case 0x4E:
+                case 0x4F:
+                case 0x50:
+                case 0x51:
+                case 0x52:
+                case 0x53:
+                case 0x54:
+                case 0x55:
+                case 0x56:
+                case 0x57:
+                case 0x58:
+                case 0x59:
+                case 0x5A:
+                case 0x5B:
+                case 0x5D:
+                case 0x5E:
+                case 0x5F:
+                case 0x60:
+                case 0x61:
+                case 0x62:
+                case 0x63:
+                case 0x64:
+                case 0x65:
+                case 0x66:
+                case 0x67:
+                case 0x68:
+                case 0x69:
+                case 0x6A:
+                case 0x6B:
+                case 0x6C:
+                case 0x6D:
+                case 0x6E:
+                case 0x6F:
+                case 0x70:
+                case 0x71:
+                case 0x72:
+                case 0x73:
+                case 0x74:
+                case 0x75:
+                case 0x76:
+                case 0x77:
+                case 0x78:
+                case 0x79:
+                case 0x7A:
+                case 0x7B:
+                case 0x7C:
+                case 0x7D:
+                case 0x7E:
+                case 0x7F:
+                {
+                    add(current);
+                    break;
+                }
+
+                // U+0080..U+07FF: bytes C2..DF 80..BF
+                case 0xC2:
+                case 0xC3:
+                case 0xC4:
+                case 0xC5:
+                case 0xC6:
+                case 0xC7:
+                case 0xC8:
+                case 0xC9:
+                case 0xCA:
+                case 0xCB:
+                case 0xCC:
+                case 0xCD:
+                case 0xCE:
+                case 0xCF:
+                case 0xD0:
+                case 0xD1:
+                case 0xD2:
+                case 0xD3:
+                case 0xD4:
+                case 0xD5:
+                case 0xD6:
+                case 0xD7:
+                case 0xD8:
+                case 0xD9:
+                case 0xDA:
+                case 0xDB:
+                case 0xDC:
+                case 0xDD:
+                case 0xDE:
+                case 0xDF:
+                {
+                    if (JSON_UNLIKELY(not next_byte_in_range({0x80, 0xBF})))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+0800..U+0FFF: bytes E0 A0..BF 80..BF
+                case 0xE0:
+                {
+                    if (JSON_UNLIKELY(not (next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF
+                // U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF
+                case 0xE1:
+                case 0xE2:
+                case 0xE3:
+                case 0xE4:
+                case 0xE5:
+                case 0xE6:
+                case 0xE7:
+                case 0xE8:
+                case 0xE9:
+                case 0xEA:
+                case 0xEB:
+                case 0xEC:
+                case 0xEE:
+                case 0xEF:
+                {
+                    if (JSON_UNLIKELY(not (next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+D000..U+D7FF: bytes ED 80..9F 80..BF
+                case 0xED:
+                {
+                    if (JSON_UNLIKELY(not (next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
+                case 0xF0:
+                {
+                    if (JSON_UNLIKELY(not (next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
+                case 0xF1:
+                case 0xF2:
+                case 0xF3:
+                {
+                    if (JSON_UNLIKELY(not (next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
+                case 0xF4:
+                {
+                    if (JSON_UNLIKELY(not (next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // remaining bytes (80..C1 and F5..FF) are ill-formed
+                default:
+                {
+                    error_message = "invalid string: ill-formed UTF-8 byte";
+                    return token_type::parse_error;
+                }
+            }
+        }
+    }
+
+    static void strtof(float& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtof(str, endptr);
+    }
+
+    static void strtof(double& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtod(str, endptr);
+    }
+
+    static void strtof(long double& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtold(str, endptr);
+    }
+
+    /*!
+    @brief scan a number literal
+
+    This function scans a string according to Sect. 6 of RFC 7159.
+
+    The function is realized with a deterministic finite state machine derived
+    from the grammar described in RFC 7159. Starting in state "init", the
+    input is read and used to determined the next state. Only state "done"
+    accepts the number. State "error" is a trap state to model errors. In the
+    table below, "anything" means any character but the ones listed before.
+
+    state    | 0        | 1-9      | e E      | +       | -       | .        | anything
+    ---------|----------|----------|----------|---------|---------|----------|-----------
+    init     | zero     | any1     | [error]  | [error] | minus   | [error]  | [error]
+    minus    | zero     | any1     | [error]  | [error] | [error] | [error]  | [error]
+    zero     | done     | done     | exponent | done    | done    | decimal1 | done
+    any1     | any1     | any1     | exponent | done    | done    | decimal1 | done
+    decimal1 | decimal2 | [error]  | [error]  | [error] | [error] | [error]  | [error]
+    decimal2 | decimal2 | decimal2 | exponent | done    | done    | done     | done
+    exponent | any2     | any2     | [error]  | sign    | sign    | [error]  | [error]
+    sign     | any2     | any2     | [error]  | [error] | [error] | [error]  | [error]
+    any2     | any2     | any2     | done     | done    | done    | done     | done
+
+    The state machine is realized with one label per state (prefixed with
+    "scan_number_") and `goto` statements between them. The state machine
+    contains cycles, but any cycle can be left when EOF is read. Therefore,
+    the function is guaranteed to terminate.
+
+    During scanning, the read bytes are stored in token_buffer. This string is
+    then converted to a signed integer, an unsigned integer, or a
+    floating-point number.
+
+    @return token_type::value_unsigned, token_type::value_integer, or
+            token_type::value_float if number could be successfully scanned,
+            token_type::parse_error otherwise
+
+    @note The scanner is independent of the current locale. Internally, the
+          locale's decimal point is used instead of `.` to work with the
+          locale-dependent converters.
+    */
+    token_type scan_number()  // lgtm [cpp/use-of-goto]
+    {
+        // reset token_buffer to store the number's bytes
+        reset();
+
+        // the type of the parsed number; initially set to unsigned; will be
+        // changed if minus sign, decimal point or exponent is read
+        token_type number_type = token_type::value_unsigned;
+
+        // state (init): we just found out we need to scan a number
+        switch (current)
+        {
+            case '-':
+            {
+                add(current);
+                goto scan_number_minus;
+            }
+
+            case '0':
+            {
+                add(current);
+                goto scan_number_zero;
+            }
+
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any1;
+            }
+
+            // LCOV_EXCL_START
+            default:
+            {
+                // all other characters are rejected outside scan_number()
+                assert(false);
+            }
+                // LCOV_EXCL_STOP
+        }
+
+scan_number_minus:
+        // state: we just parsed a leading minus sign
+        number_type = token_type::value_integer;
+        switch (get())
+        {
+            case '0':
+            {
+                add(current);
+                goto scan_number_zero;
+            }
+
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any1;
+            }
+
+            default:
+            {
+                error_message = "invalid number; expected digit after '-'";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_zero:
+        // state: we just parse a zero (maybe with a leading minus sign)
+        switch (get())
+        {
+            case '.':
+            {
+                add(decimal_point_char);
+                goto scan_number_decimal1;
+            }
+
+            case 'e':
+            case 'E':
+            {
+                add(current);
+                goto scan_number_exponent;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_any1:
+        // state: we just parsed a number 0-9 (maybe with a leading minus sign)
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any1;
+            }
+
+            case '.':
+            {
+                add(decimal_point_char);
+                goto scan_number_decimal1;
+            }
+
+            case 'e':
+            case 'E':
+            {
+                add(current);
+                goto scan_number_exponent;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_decimal1:
+        // state: we just parsed a decimal point
+        number_type = token_type::value_float;
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_decimal2;
+            }
+
+            default:
+            {
+                error_message = "invalid number; expected digit after '.'";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_decimal2:
+        // we just parsed at least one number after a decimal point
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_decimal2;
+            }
+
+            case 'e':
+            case 'E':
+            {
+                add(current);
+                goto scan_number_exponent;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_exponent:
+        // we just parsed an exponent
+        number_type = token_type::value_float;
+        switch (get())
+        {
+            case '+':
+            case '-':
+            {
+                add(current);
+                goto scan_number_sign;
+            }
+
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any2;
+            }
+
+            default:
+            {
+                error_message =
+                    "invalid number; expected '+', '-', or digit after exponent";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_sign:
+        // we just parsed an exponent sign
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any2;
+            }
+
+            default:
+            {
+                error_message = "invalid number; expected digit after exponent sign";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_any2:
+        // we just parsed a number after the exponent or exponent sign
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any2;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_done:
+        // unget the character after the number (we only read it to know that
+        // we are done scanning a number)
+        unget();
+
+        char* endptr = nullptr;
+        errno = 0;
+
+        // try to parse integers first and fall back to floats
+        if (number_type == token_type::value_unsigned)
+        {
+            const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
+
+            // we checked the number format before
+            assert(endptr == token_buffer.data() + token_buffer.size());
+
+            if (errno == 0)
+            {
+                value_unsigned = static_cast<number_unsigned_t>(x);
+                if (value_unsigned == x)
+                {
+                    return token_type::value_unsigned;
+                }
+            }
+        }
+        else if (number_type == token_type::value_integer)
+        {
+            const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
+
+            // we checked the number format before
+            assert(endptr == token_buffer.data() + token_buffer.size());
+
+            if (errno == 0)
+            {
+                value_integer = static_cast<number_integer_t>(x);
+                if (value_integer == x)
+                {
+                    return token_type::value_integer;
+                }
+            }
+        }
+
+        // this code is reached if we parse a floating-point number or if an
+        // integer conversion above failed
+        strtof(value_float, token_buffer.data(), &endptr);
+
+        // we checked the number format before
+        assert(endptr == token_buffer.data() + token_buffer.size());
+
+        return token_type::value_float;
+    }
+
+    /*!
+    @param[in] literal_text  the literal text to expect
+    @param[in] length        the length of the passed literal text
+    @param[in] return_type   the token type to return on success
+    */
+    token_type scan_literal(const char* literal_text, const std::size_t length,
+                            token_type return_type)
+    {
+        assert(current == literal_text[0]);
+        for (std::size_t i = 1; i < length; ++i)
+        {
+            if (JSON_UNLIKELY(get() != literal_text[i]))
+            {
+                error_message = "invalid literal";
+                return token_type::parse_error;
+            }
+        }
+        return return_type;
+    }
+
+    /////////////////////
+    // input management
+    /////////////////////
+
+    /// reset token_buffer; current character is beginning of token
+    void reset() noexcept
+    {
+        token_buffer.clear();
+        token_string.clear();
+        token_string.push_back(std::char_traits<char>::to_char_type(current));
+    }
+
+    /*
+    @brief get next character from the input
+
+    This function provides the interface to the used input adapter. It does
+    not throw in case the input reached EOF, but returns a
+    `std::char_traits<char>::eof()` in that case.  Stores the scanned characters
+    for use in error messages.
+
+    @return character read from the input
+    */
+    std::char_traits<char>::int_type get()
+    {
+        ++position.chars_read_total;
+        ++position.chars_read_current_line;
+
+        if (next_unget)
+        {
+            // just reset the next_unget variable and work with current
+            next_unget = false;
+        }
+        else
+        {
+            current = ia->get_character();
+        }
+
+        if (JSON_LIKELY(current != std::char_traits<char>::eof()))
+        {
+            token_string.push_back(std::char_traits<char>::to_char_type(current));
+        }
+
+        if (current == '\n')
+        {
+            ++position.lines_read;
+            ++position.chars_read_current_line = 0;
+        }
+
+        return current;
+    }
+
+    /*!
+    @brief unget current character (read it again on next get)
+
+    We implement unget by setting variable next_unget to true. The input is not
+    changed - we just simulate ungetting by modifying chars_read_total,
+    chars_read_current_line, and token_string. The next call to get() will
+    behave as if the unget character is read again.
+    */
+    void unget()
+    {
+        next_unget = true;
+
+        --position.chars_read_total;
+
+        // in case we "unget" a newline, we have to also decrement the lines_read
+        if (position.chars_read_current_line == 0)
+        {
+            if (position.lines_read > 0)
+            {
+                --position.lines_read;
+            }
+        }
+        else
+        {
+            --position.chars_read_current_line;
+        }
+
+        if (JSON_LIKELY(current != std::char_traits<char>::eof()))
+        {
+            assert(token_string.size() != 0);
+            token_string.pop_back();
+        }
+    }
+
+    /// add a character to token_buffer
+    void add(int c)
+    {
+        token_buffer.push_back(std::char_traits<char>::to_char_type(c));
+    }
+
+  public:
+    /////////////////////
+    // value getters
+    /////////////////////
+
+    /// return integer value
+    constexpr number_integer_t get_number_integer() const noexcept
+    {
+        return value_integer;
+    }
+
+    /// return unsigned integer value
+    constexpr number_unsigned_t get_number_unsigned() const noexcept
+    {
+        return value_unsigned;
+    }
+
+    /// return floating-point value
+    constexpr number_float_t get_number_float() const noexcept
+    {
+        return value_float;
+    }
+
+    /// return current string value (implicitly resets the token; useful only once)
+    string_t& get_string()
+    {
+        return token_buffer;
+    }
+
+    /////////////////////
+    // diagnostics
+    /////////////////////
+
+    /// return position of last read token
+    constexpr position_t get_position() const noexcept
+    {
+        return position;
+    }
+
+    /// return the last read token (for errors only).  Will never contain EOF
+    /// (an arbitrary value that is not a valid char value, often -1), because
+    /// 255 may legitimately occur.  May contain NUL, which should be escaped.
+    std::string get_token_string() const
+    {
+        // escape control characters
+        std::string result;
+        for (const auto c : token_string)
+        {
+            if ('\x00' <= c and c <= '\x1F')
+            {
+                // escape control characters
+                char cs[9];
+                (std::snprintf)(cs, 9, "<U+%.4X>", static_cast<unsigned char>(c));
+                result += cs;
+            }
+            else
+            {
+                // add character as is
+                result.push_back(c);
+            }
+        }
+
+        return result;
+    }
+
+    /// return syntax error message
+    constexpr const char* get_error_message() const noexcept
+    {
+        return error_message;
+    }
+
+    /////////////////////
+    // actual scanner
+    /////////////////////
+
+    /*!
+    @brief skip the UTF-8 byte order mark
+    @return true iff there is no BOM or the correct BOM has been skipped
+    */
+    bool skip_bom()
+    {
+        if (get() == 0xEF)
+        {
+            // check if we completely parse the BOM
+            return get() == 0xBB and get() == 0xBF;
+        }
+
+        // the first character is not the beginning of the BOM; unget it to
+        // process is later
+        unget();
+        return true;
+    }
+
+    token_type scan()
+    {
+        // initially, skip the BOM
+        if (position.chars_read_total == 0 and not skip_bom())
+        {
+            error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
+            return token_type::parse_error;
+        }
+
+        // read next character and ignore whitespace
+        do
+        {
+            get();
+        }
+        while (current == ' ' or current == '\t' or current == '\n' or current == '\r');
+
+        switch (current)
+        {
+            // structural characters
+            case '[':
+                return token_type::begin_array;
+            case ']':
+                return token_type::end_array;
+            case '{':
+                return token_type::begin_object;
+            case '}':
+                return token_type::end_object;
+            case ':':
+                return token_type::name_separator;
+            case ',':
+                return token_type::value_separator;
+
+            // literals
+            case 't':
+                return scan_literal("true", 4, token_type::literal_true);
+            case 'f':
+                return scan_literal("false", 5, token_type::literal_false);
+            case 'n':
+                return scan_literal("null", 4, token_type::literal_null);
+
+            // string
+            case '\"':
+                return scan_string();
+
+            // number
+            case '-':
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+                return scan_number();
+
+            // end of input (the null byte is needed when parsing from
+            // string literals)
+            case '\0':
+            case std::char_traits<char>::eof():
+                return token_type::end_of_input;
+
+            // error
+            default:
+                error_message = "invalid literal";
+                return token_type::parse_error;
+        }
+    }
+
+  private:
+    /// input adapter
+    detail::input_adapter_t ia = nullptr;
+
+    /// the current character
+    std::char_traits<char>::int_type current = std::char_traits<char>::eof();
+
+    /// whether the next get() call should just return current
+    bool next_unget = false;
+
+    /// the start position of the current token
+    position_t position;
+
+    /// raw input token string (for error messages)
+    std::vector<char> token_string {};
+
+    /// buffer for variable-length tokens (numbers, strings)
+    string_t token_buffer {};
+
+    /// a description of occurred lexer errors
+    const char* error_message = "";
+
+    // number values
+    number_integer_t value_integer = 0;
+    number_unsigned_t value_unsigned = 0;
+    number_float_t value_float = 0;
+
+    /// the decimal point
+    const char decimal_point_char = '.';
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/input/parser.hpp>
+
+
+#include <cassert> // assert
+#include <cmath> // isfinite
+#include <cstdint> // uint8_t
+#include <functional> // function
+#include <string> // string
+#include <utility> // move
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/is_sax.hpp>
+
+
+#include <cstdint> // size_t
+#include <utility> // declval
+
+// #include <nlohmann/detail/meta/detected.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+template <typename T>
+using null_function_t = decltype(std::declval<T&>().null());
+
+template <typename T>
+using boolean_function_t =
+    decltype(std::declval<T&>().boolean(std::declval<bool>()));
+
+template <typename T, typename Integer>
+using number_integer_function_t =
+    decltype(std::declval<T&>().number_integer(std::declval<Integer>()));
+
+template <typename T, typename Unsigned>
+using number_unsigned_function_t =
+    decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));
+
+template <typename T, typename Float, typename String>
+using number_float_function_t = decltype(std::declval<T&>().number_float(
+                                    std::declval<Float>(), std::declval<const String&>()));
+
+template <typename T, typename String>
+using string_function_t =
+    decltype(std::declval<T&>().string(std::declval<String&>()));
+
+template <typename T>
+using start_object_function_t =
+    decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));
+
+template <typename T, typename String>
+using key_function_t =
+    decltype(std::declval<T&>().key(std::declval<String&>()));
+
+template <typename T>
+using end_object_function_t = decltype(std::declval<T&>().end_object());
+
+template <typename T>
+using start_array_function_t =
+    decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));
+
+template <typename T>
+using end_array_function_t = decltype(std::declval<T&>().end_array());
+
+template <typename T, typename Exception>
+using parse_error_function_t = decltype(std::declval<T&>().parse_error(
+        std::declval<std::size_t>(), std::declval<const std::string&>(),
+        std::declval<const Exception&>()));
+
+template <typename SAX, typename BasicJsonType>
+struct is_sax
+{
+  private:
+    static_assert(is_basic_json<BasicJsonType>::value,
+                  "BasicJsonType must be of type basic_json<...>");
+
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using exception_t = typename BasicJsonType::exception;
+
+  public:
+    static constexpr bool value =
+        is_detected_exact<bool, null_function_t, SAX>::value &&
+        is_detected_exact<bool, boolean_function_t, SAX>::value &&
+        is_detected_exact<bool, number_integer_function_t, SAX,
+        number_integer_t>::value &&
+        is_detected_exact<bool, number_unsigned_function_t, SAX,
+        number_unsigned_t>::value &&
+        is_detected_exact<bool, number_float_function_t, SAX, number_float_t,
+        string_t>::value &&
+        is_detected_exact<bool, string_function_t, SAX, string_t>::value &&
+        is_detected_exact<bool, start_object_function_t, SAX>::value &&
+        is_detected_exact<bool, key_function_t, SAX, string_t>::value &&
+        is_detected_exact<bool, end_object_function_t, SAX>::value &&
+        is_detected_exact<bool, start_array_function_t, SAX>::value &&
+        is_detected_exact<bool, end_array_function_t, SAX>::value &&
+        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value;
+};
+
+template <typename SAX, typename BasicJsonType>
+struct is_sax_static_asserts
+{
+  private:
+    static_assert(is_basic_json<BasicJsonType>::value,
+                  "BasicJsonType must be of type basic_json<...>");
+
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using exception_t = typename BasicJsonType::exception;
+
+  public:
+    static_assert(is_detected_exact<bool, null_function_t, SAX>::value,
+                  "Missing/invalid function: bool null()");
+    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
+                  "Missing/invalid function: bool boolean(bool)");
+    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
+                  "Missing/invalid function: bool boolean(bool)");
+    static_assert(
+        is_detected_exact<bool, number_integer_function_t, SAX,
+        number_integer_t>::value,
+        "Missing/invalid function: bool number_integer(number_integer_t)");
+    static_assert(
+        is_detected_exact<bool, number_unsigned_function_t, SAX,
+        number_unsigned_t>::value,
+        "Missing/invalid function: bool number_unsigned(number_unsigned_t)");
+    static_assert(is_detected_exact<bool, number_float_function_t, SAX,
+                  number_float_t, string_t>::value,
+                  "Missing/invalid function: bool number_float(number_float_t, const string_t&)");
+    static_assert(
+        is_detected_exact<bool, string_function_t, SAX, string_t>::value,
+        "Missing/invalid function: bool string(string_t&)");
+    static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value,
+                  "Missing/invalid function: bool start_object(std::size_t)");
+    static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value,
+                  "Missing/invalid function: bool key(string_t&)");
+    static_assert(is_detected_exact<bool, end_object_function_t, SAX>::value,
+                  "Missing/invalid function: bool end_object()");
+    static_assert(is_detected_exact<bool, start_array_function_t, SAX>::value,
+                  "Missing/invalid function: bool start_array(std::size_t)");
+    static_assert(is_detected_exact<bool, end_array_function_t, SAX>::value,
+                  "Missing/invalid function: bool end_array()");
+    static_assert(
+        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value,
+        "Missing/invalid function: bool parse_error(std::size_t, const "
+        "std::string&, const exception&)");
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+// #include <nlohmann/detail/input/json_sax.hpp>
+
+
+#include <cstddef>
+#include <string>
+#include <vector>
+
+// #include <nlohmann/detail/input/parser.hpp>
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+
+namespace nlohmann
+{
+
+/*!
+@brief SAX interface
+
+This class describes the SAX interface used by @ref nlohmann::json::sax_parse.
+Each function is called in different situations while the input is parsed. The
+boolean return value informs the parser whether to continue processing the
+input.
+*/
+template<typename BasicJsonType>
+struct json_sax
+{
+    /// type for (signed) integers
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    /// type for unsigned integers
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    /// type for floating-point numbers
+    using number_float_t = typename BasicJsonType::number_float_t;
+    /// type for strings
+    using string_t = typename BasicJsonType::string_t;
+
+    /*!
+    @brief a null value was read
+    @return whether parsing should proceed
+    */
+    virtual bool null() = 0;
+
+    /*!
+    @brief a boolean value was read
+    @param[in] val  boolean value
+    @return whether parsing should proceed
+    */
+    virtual bool boolean(bool val) = 0;
+
+    /*!
+    @brief an integer number was read
+    @param[in] val  integer value
+    @return whether parsing should proceed
+    */
+    virtual bool number_integer(number_integer_t val) = 0;
+
+    /*!
+    @brief an unsigned integer number was read
+    @param[in] val  unsigned integer value
+    @return whether parsing should proceed
+    */
+    virtual bool number_unsigned(number_unsigned_t val) = 0;
+
+    /*!
+    @brief an floating-point number was read
+    @param[in] val  floating-point value
+    @param[in] s    raw token value
+    @return whether parsing should proceed
+    */
+    virtual bool number_float(number_float_t val, const string_t& s) = 0;
+
+    /*!
+    @brief a string was read
+    @param[in] val  string value
+    @return whether parsing should proceed
+    @note It is safe to move the passed string.
+    */
+    virtual bool string(string_t& val) = 0;
+
+    /*!
+    @brief the beginning of an object was read
+    @param[in] elements  number of object elements or -1 if unknown
+    @return whether parsing should proceed
+    @note binary formats may report the number of elements
+    */
+    virtual bool start_object(std::size_t elements) = 0;
+
+    /*!
+    @brief an object key was read
+    @param[in] val  object key
+    @return whether parsing should proceed
+    @note It is safe to move the passed string.
+    */
+    virtual bool key(string_t& val) = 0;
+
+    /*!
+    @brief the end of an object was read
+    @return whether parsing should proceed
+    */
+    virtual bool end_object() = 0;
+
+    /*!
+    @brief the beginning of an array was read
+    @param[in] elements  number of array elements or -1 if unknown
+    @return whether parsing should proceed
+    @note binary formats may report the number of elements
+    */
+    virtual bool start_array(std::size_t elements) = 0;
+
+    /*!
+    @brief the end of an array was read
+    @return whether parsing should proceed
+    */
+    virtual bool end_array() = 0;
+
+    /*!
+    @brief a parse error occurred
+    @param[in] position    the position in the input where the error occurs
+    @param[in] last_token  the last read token
+    @param[in] ex          an exception object describing the error
+    @return whether parsing should proceed (must return false)
+    */
+    virtual bool parse_error(std::size_t position,
+                             const std::string& last_token,
+                             const detail::exception& ex) = 0;
+
+    virtual ~json_sax() = default;
+};
+
+
+namespace detail
+{
+/*!
+@brief SAX implementation to create a JSON value from SAX events
+
+This class implements the @ref json_sax interface and processes the SAX events
+to create a JSON value which makes it basically a DOM parser. The structure or
+hierarchy of the JSON value is managed by the stack `ref_stack` which contains
+a pointer to the respective array or object for each recursion depth.
+
+After successful parsing, the value that is passed by reference to the
+constructor contains the parsed value.
+
+@tparam BasicJsonType  the JSON type
+*/
+template<typename BasicJsonType>
+class json_sax_dom_parser
+{
+  public:
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+
+    /*!
+    @param[in, out] r  reference to a JSON value that is manipulated while
+                       parsing
+    @param[in] allow_exceptions_  whether parse errors yield exceptions
+    */
+    explicit json_sax_dom_parser(BasicJsonType& r, const bool allow_exceptions_ = true)
+        : root(r), allow_exceptions(allow_exceptions_)
+    {}
+
+    bool null()
+    {
+        handle_value(nullptr);
+        return true;
+    }
+
+    bool boolean(bool val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_integer(number_integer_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_float(number_float_t val, const string_t& /*unused*/)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool string(string_t& val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool start_object(std::size_t len)
+    {
+        ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
+
+        if (JSON_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408,
+                                            "excessive object size: " + std::to_string(len)));
+        }
+
+        return true;
+    }
+
+    bool key(string_t& val)
+    {
+        // add null at given key and store the reference for later
+        object_element = &(ref_stack.back()->m_value.object->operator[](val));
+        return true;
+    }
+
+    bool end_object()
+    {
+        ref_stack.pop_back();
+        return true;
+    }
+
+    bool start_array(std::size_t len)
+    {
+        ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
+
+        if (JSON_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408,
+                                            "excessive array size: " + std::to_string(len)));
+        }
+
+        return true;
+    }
+
+    bool end_array()
+    {
+        ref_stack.pop_back();
+        return true;
+    }
+
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
+                     const detail::exception& ex)
+    {
+        errored = true;
+        if (allow_exceptions)
+        {
+            // determine the proper exception type from the id
+            switch ((ex.id / 100) % 100)
+            {
+                case 1:
+                    JSON_THROW(*reinterpret_cast<const detail::parse_error*>(&ex));
+                case 4:
+                    JSON_THROW(*reinterpret_cast<const detail::out_of_range*>(&ex));
+                // LCOV_EXCL_START
+                case 2:
+                    JSON_THROW(*reinterpret_cast<const detail::invalid_iterator*>(&ex));
+                case 3:
+                    JSON_THROW(*reinterpret_cast<const detail::type_error*>(&ex));
+                case 5:
+                    JSON_THROW(*reinterpret_cast<const detail::other_error*>(&ex));
+                default:
+                    assert(false);
+                    // LCOV_EXCL_STOP
+            }
+        }
+        return false;
+    }
+
+    constexpr bool is_errored() const
+    {
+        return errored;
+    }
+
+  private:
+    /*!
+    @invariant If the ref stack is empty, then the passed value will be the new
+               root.
+    @invariant If the ref stack contains a value, then it is an array or an
+               object to which we can add elements
+    */
+    template<typename Value>
+    BasicJsonType* handle_value(Value&& v)
+    {
+        if (ref_stack.empty())
+        {
+            root = BasicJsonType(std::forward<Value>(v));
+            return &root;
+        }
+
+        assert(ref_stack.back()->is_array() or ref_stack.back()->is_object());
+
+        if (ref_stack.back()->is_array())
+        {
+            ref_stack.back()->m_value.array->emplace_back(std::forward<Value>(v));
+            return &(ref_stack.back()->m_value.array->back());
+        }
+        else
+        {
+            assert(object_element);
+            *object_element = BasicJsonType(std::forward<Value>(v));
+            return object_element;
+        }
+    }
+
+    /// the parsed JSON value
+    BasicJsonType& root;
+    /// stack to model hierarchy of values
+    std::vector<BasicJsonType*> ref_stack;
+    /// helper to hold the reference for the next object element
+    BasicJsonType* object_element = nullptr;
+    /// whether a syntax error occurred
+    bool errored = false;
+    /// whether to throw exceptions in case of errors
+    const bool allow_exceptions = true;
+};
+
+template<typename BasicJsonType>
+class json_sax_dom_callback_parser
+{
+  public:
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using parser_callback_t = typename BasicJsonType::parser_callback_t;
+    using parse_event_t = typename BasicJsonType::parse_event_t;
+
+    json_sax_dom_callback_parser(BasicJsonType& r,
+                                 const parser_callback_t cb,
+                                 const bool allow_exceptions_ = true)
+        : root(r), callback(cb), allow_exceptions(allow_exceptions_)
+    {
+        keep_stack.push_back(true);
+    }
+
+    bool null()
+    {
+        handle_value(nullptr);
+        return true;
+    }
+
+    bool boolean(bool val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_integer(number_integer_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_float(number_float_t val, const string_t& /*unused*/)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool string(string_t& val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool start_object(std::size_t len)
+    {
+        // check callback for object start
+        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
+        keep_stack.push_back(keep);
+
+        auto val = handle_value(BasicJsonType::value_t::object, true);
+        ref_stack.push_back(val.second);
+
+        // check object limit
+        if (ref_stack.back())
+        {
+            if (JSON_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
+            {
+                JSON_THROW(out_of_range::create(408,
+                                                "excessive object size: " + std::to_string(len)));
+            }
+        }
+
+        return true;
+    }
+
+    bool key(string_t& val)
+    {
+        BasicJsonType k = BasicJsonType(val);
+
+        // check callback for key
+        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
+        key_keep_stack.push_back(keep);
+
+        // add discarded value at given key and store the reference for later
+        if (keep and ref_stack.back())
+        {
+            object_element = &(ref_stack.back()->m_value.object->operator[](val) = discarded);
+        }
+
+        return true;
+    }
+
+    bool end_object()
+    {
+        if (ref_stack.back())
+        {
+            if (not callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
+            {
+                // discard object
+                *ref_stack.back() = discarded;
+            }
+        }
+
+        assert(not ref_stack.empty());
+        assert(not keep_stack.empty());
+        ref_stack.pop_back();
+        keep_stack.pop_back();
+
+        if (not ref_stack.empty() and ref_stack.back())
+        {
+            // remove discarded value
+            if (ref_stack.back()->is_object())
+            {
+                for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
+                {
+                    if (it->is_discarded())
+                    {
+                        ref_stack.back()->erase(it);
+                        break;
+                    }
+                }
+            }
+        }
+
+        return true;
+    }
+
+    bool start_array(std::size_t len)
+    {
+        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
+        keep_stack.push_back(keep);
+
+        auto val = handle_value(BasicJsonType::value_t::array, true);
+        ref_stack.push_back(val.second);
+
+        // check array limit
+        if (ref_stack.back())
+        {
+            if (JSON_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
+            {
+                JSON_THROW(out_of_range::create(408,
+                                                "excessive array size: " + std::to_string(len)));
+            }
+        }
+
+        return true;
+    }
+
+    bool end_array()
+    {
+        bool keep = true;
+
+        if (ref_stack.back())
+        {
+            keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
+            if (not keep)
+            {
+                // discard array
+                *ref_stack.back() = discarded;
+            }
+        }
+
+        assert(not ref_stack.empty());
+        assert(not keep_stack.empty());
+        ref_stack.pop_back();
+        keep_stack.pop_back();
+
+        // remove discarded value
+        if (not keep and not ref_stack.empty())
+        {
+            if (ref_stack.back()->is_array())
+            {
+                ref_stack.back()->m_value.array->pop_back();
+            }
+        }
+
+        return true;
+    }
+
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
+                     const detail::exception& ex)
+    {
+        errored = true;
+        if (allow_exceptions)
+        {
+            // determine the proper exception type from the id
+            switch ((ex.id / 100) % 100)
+            {
+                case 1:
+                    JSON_THROW(*reinterpret_cast<const detail::parse_error*>(&ex));
+                case 4:
+                    JSON_THROW(*reinterpret_cast<const detail::out_of_range*>(&ex));
+                // LCOV_EXCL_START
+                case 2:
+                    JSON_THROW(*reinterpret_cast<const detail::invalid_iterator*>(&ex));
+                case 3:
+                    JSON_THROW(*reinterpret_cast<const detail::type_error*>(&ex));
+                case 5:
+                    JSON_THROW(*reinterpret_cast<const detail::other_error*>(&ex));
+                default:
+                    assert(false);
+                    // LCOV_EXCL_STOP
+            }
+        }
+        return false;
+    }
+
+    constexpr bool is_errored() const
+    {
+        return errored;
+    }
+
+  private:
+    /*!
+    @param[in] v  value to add to the JSON value we build during parsing
+    @param[in] skip_callback  whether we should skip calling the callback
+               function; this is required after start_array() and
+               start_object() SAX events, because otherwise we would call the
+               callback function with an empty array or object, respectively.
+
+    @invariant If the ref stack is empty, then the passed value will be the new
+               root.
+    @invariant If the ref stack contains a value, then it is an array or an
+               object to which we can add elements
+
+    @return pair of boolean (whether value should be kept) and pointer (to the
+            passed value in the ref_stack hierarchy; nullptr if not kept)
+    */
+    template<typename Value>
+    std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
+    {
+        assert(not keep_stack.empty());
+
+        // do not handle this value if we know it would be added to a discarded
+        // container
+        if (not keep_stack.back())
+        {
+            return {false, nullptr};
+        }
+
+        // create value
+        auto value = BasicJsonType(std::forward<Value>(v));
+
+        // check callback
+        const bool keep = skip_callback or callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
+
+        // do not handle this value if we just learnt it shall be discarded
+        if (not keep)
+        {
+            return {false, nullptr};
+        }
+
+        if (ref_stack.empty())
+        {
+            root = std::move(value);
+            return {true, &root};
+        }
+
+        // skip this value if we already decided to skip the parent
+        // (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
+        if (not ref_stack.back())
+        {
+            return {false, nullptr};
+        }
+
+        // we now only expect arrays and objects
+        assert(ref_stack.back()->is_array() or ref_stack.back()->is_object());
+
+        if (ref_stack.back()->is_array())
+        {
+            ref_stack.back()->m_value.array->push_back(std::move(value));
+            return {true, &(ref_stack.back()->m_value.array->back())};
+        }
+        else
+        {
+            // check if we should store an element for the current key
+            assert(not key_keep_stack.empty());
+            const bool store_element = key_keep_stack.back();
+            key_keep_stack.pop_back();
+
+            if (not store_element)
+            {
+                return {false, nullptr};
+            }
+
+            assert(object_element);
+            *object_element = std::move(value);
+            return {true, object_element};
+        }
+    }
+
+    /// the parsed JSON value
+    BasicJsonType& root;
+    /// stack to model hierarchy of values
+    std::vector<BasicJsonType*> ref_stack;
+    /// stack to manage which values to keep
+    std::vector<bool> keep_stack;
+    /// stack to manage which object keys to keep
+    std::vector<bool> key_keep_stack;
+    /// helper to hold the reference for the next object element
+    BasicJsonType* object_element = nullptr;
+    /// whether a syntax error occurred
+    bool errored = false;
+    /// callback function
+    const parser_callback_t callback = nullptr;
+    /// whether to throw exceptions in case of errors
+    const bool allow_exceptions = true;
+    /// a discarded value for the callback
+    BasicJsonType discarded = BasicJsonType::value_t::discarded;
+};
+
+template<typename BasicJsonType>
+class json_sax_acceptor
+{
+  public:
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+
+    bool null()
+    {
+        return true;
+    }
+
+    bool boolean(bool /*unused*/)
+    {
+        return true;
+    }
+
+    bool number_integer(number_integer_t /*unused*/)
+    {
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t /*unused*/)
+    {
+        return true;
+    }
+
+    bool number_float(number_float_t /*unused*/, const string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool string(string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool start_object(std::size_t  /*unused*/ = std::size_t(-1))
+    {
+        return true;
+    }
+
+    bool key(string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool end_object()
+    {
+        return true;
+    }
+
+    bool start_array(std::size_t  /*unused*/ = std::size_t(-1))
+    {
+        return true;
+    }
+
+    bool end_array()
+    {
+        return true;
+    }
+
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const detail::exception& /*unused*/)
+    {
+        return false;
+    }
+};
+}  // namespace detail
+
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/input/lexer.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+////////////
+// parser //
+////////////
+
+/*!
+@brief syntax analysis
+
+This class implements a recursive decent parser.
+*/
+template<typename BasicJsonType>
+class parser
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using lexer_t = lexer<BasicJsonType>;
+    using token_type = typename lexer_t::token_type;
+
+  public:
+    enum class parse_event_t : uint8_t
+    {
+        /// the parser read `{` and started to process a JSON object
+        object_start,
+        /// the parser read `}` and finished processing a JSON object
+        object_end,
+        /// the parser read `[` and started to process a JSON array
+        array_start,
+        /// the parser read `]` and finished processing a JSON array
+        array_end,
+        /// the parser read a key of a value in an object
+        key,
+        /// the parser finished reading a JSON value
+        value
+    };
+
+    using parser_callback_t =
+        std::function<bool(int depth, parse_event_t event, BasicJsonType& parsed)>;
+
+    /// a parser reading from an input adapter
+    explicit parser(detail::input_adapter_t&& adapter,
+                    const parser_callback_t cb = nullptr,
+                    const bool allow_exceptions_ = true)
+        : callback(cb), m_lexer(std::move(adapter)), allow_exceptions(allow_exceptions_)
+    {
+        // read first token
+        get_token();
+    }
+
+    /*!
+    @brief public parser interface
+
+    @param[in] strict      whether to expect the last token to be EOF
+    @param[in,out] result  parsed JSON value
+
+    @throw parse_error.101 in case of an unexpected token
+    @throw parse_error.102 if to_unicode fails or surrogate error
+    @throw parse_error.103 if to_unicode fails
+    */
+    void parse(const bool strict, BasicJsonType& result)
+    {
+        if (callback)
+        {
+            json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions);
+            sax_parse_internal(&sdp);
+            result.assert_invariant();
+
+            // in strict mode, input must be completely read
+            if (strict and (get_token() != token_type::end_of_input))
+            {
+                sdp.parse_error(m_lexer.get_position(),
+                                m_lexer.get_token_string(),
+                                parse_error::create(101, m_lexer.get_position(),
+                                                    exception_message(token_type::end_of_input, "value")));
+            }
+
+            // in case of an error, return discarded value
+            if (sdp.is_errored())
+            {
+                result = value_t::discarded;
+                return;
+            }
+
+            // set top-level value to null if it was discarded by the callback
+            // function
+            if (result.is_discarded())
+            {
+                result = nullptr;
+            }
+        }
+        else
+        {
+            json_sax_dom_parser<BasicJsonType> sdp(result, allow_exceptions);
+            sax_parse_internal(&sdp);
+            result.assert_invariant();
+
+            // in strict mode, input must be completely read
+            if (strict and (get_token() != token_type::end_of_input))
+            {
+                sdp.parse_error(m_lexer.get_position(),
+                                m_lexer.get_token_string(),
+                                parse_error::create(101, m_lexer.get_position(),
+                                                    exception_message(token_type::end_of_input, "value")));
+            }
+
+            // in case of an error, return discarded value
+            if (sdp.is_errored())
+            {
+                result = value_t::discarded;
+                return;
+            }
+        }
+    }
+
+    /*!
+    @brief public accept interface
+
+    @param[in] strict  whether to expect the last token to be EOF
+    @return whether the input is a proper JSON text
+    */
+    bool accept(const bool strict = true)
+    {
+        json_sax_acceptor<BasicJsonType> sax_acceptor;
+        return sax_parse(&sax_acceptor, strict);
+    }
+
+    template <typename SAX>
+    bool sax_parse(SAX* sax, const bool strict = true)
+    {
+        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
+        const bool result = sax_parse_internal(sax);
+
+        // strict mode: next byte must be EOF
+        if (result and strict and (get_token() != token_type::end_of_input))
+        {
+            return sax->parse_error(m_lexer.get_position(),
+                                    m_lexer.get_token_string(),
+                                    parse_error::create(101, m_lexer.get_position(),
+                                            exception_message(token_type::end_of_input, "value")));
+        }
+
+        return result;
+    }
+
+  private:
+    template <typename SAX>
+    bool sax_parse_internal(SAX* sax)
+    {
+        // stack to remember the hierarchy of structured values we are parsing
+        // true = array; false = object
+        std::vector<bool> states;
+        // value to avoid a goto (see comment where set to true)
+        bool skip_to_state_evaluation = false;
+
+        while (true)
+        {
+            if (not skip_to_state_evaluation)
+            {
+                // invariant: get_token() was called before each iteration
+                switch (last_token)
+                {
+                    case token_type::begin_object:
+                    {
+                        if (JSON_UNLIKELY(not sax->start_object(std::size_t(-1))))
+                        {
+                            return false;
+                        }
+
+                        // closing } -> we are done
+                        if (get_token() == token_type::end_object)
+                        {
+                            if (JSON_UNLIKELY(not sax->end_object()))
+                            {
+                                return false;
+                            }
+                            break;
+                        }
+
+                        // parse key
+                        if (JSON_UNLIKELY(last_token != token_type::value_string))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    parse_error::create(101, m_lexer.get_position(),
+                                                            exception_message(token_type::value_string, "object key")));
+                        }
+                        if (JSON_UNLIKELY(not sax->key(m_lexer.get_string())))
+                        {
+                            return false;
+                        }
+
+                        // parse separator (:)
+                        if (JSON_UNLIKELY(get_token() != token_type::name_separator))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    parse_error::create(101, m_lexer.get_position(),
+                                                            exception_message(token_type::name_separator, "object separator")));
+                        }
+
+                        // remember we are now inside an object
+                        states.push_back(false);
+
+                        // parse values
+                        get_token();
+                        continue;
+                    }
+
+                    case token_type::begin_array:
+                    {
+                        if (JSON_UNLIKELY(not sax->start_array(std::size_t(-1))))
+                        {
+                            return false;
+                        }
+
+                        // closing ] -> we are done
+                        if (get_token() == token_type::end_array)
+                        {
+                            if (JSON_UNLIKELY(not sax->end_array()))
+                            {
+                                return false;
+                            }
+                            break;
+                        }
+
+                        // remember we are now inside an array
+                        states.push_back(true);
+
+                        // parse values (no need to call get_token)
+                        continue;
+                    }
+
+                    case token_type::value_float:
+                    {
+                        const auto res = m_lexer.get_number_float();
+
+                        if (JSON_UNLIKELY(not std::isfinite(res)))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    out_of_range::create(406, "number overflow parsing '" + m_lexer.get_token_string() + "'"));
+                        }
+                        else
+                        {
+                            if (JSON_UNLIKELY(not sax->number_float(res, m_lexer.get_string())))
+                            {
+                                return false;
+                            }
+                            break;
+                        }
+                    }
+
+                    case token_type::literal_false:
+                    {
+                        if (JSON_UNLIKELY(not sax->boolean(false)))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::literal_null:
+                    {
+                        if (JSON_UNLIKELY(not sax->null()))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::literal_true:
+                    {
+                        if (JSON_UNLIKELY(not sax->boolean(true)))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::value_integer:
+                    {
+                        if (JSON_UNLIKELY(not sax->number_integer(m_lexer.get_number_integer())))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::value_string:
+                    {
+                        if (JSON_UNLIKELY(not sax->string(m_lexer.get_string())))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::value_unsigned:
+                    {
+                        if (JSON_UNLIKELY(not sax->number_unsigned(m_lexer.get_number_unsigned())))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::parse_error:
+                    {
+                        // using "uninitialized" to avoid "expected" message
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(),
+                                                        exception_message(token_type::uninitialized, "value")));
+                    }
+
+                    default: // the last token was unexpected
+                    {
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(),
+                                                        exception_message(token_type::literal_or_value, "value")));
+                    }
+                }
+            }
+            else
+            {
+                skip_to_state_evaluation = false;
+            }
+
+            // we reached this line after we successfully parsed a value
+            if (states.empty())
+            {
+                // empty stack: we reached the end of the hierarchy: done
+                return true;
+            }
+            else
+            {
+                if (states.back())  // array
+                {
+                    // comma -> next value
+                    if (get_token() == token_type::value_separator)
+                    {
+                        // parse a new value
+                        get_token();
+                        continue;
+                    }
+
+                    // closing ]
+                    if (JSON_LIKELY(last_token == token_type::end_array))
+                    {
+                        if (JSON_UNLIKELY(not sax->end_array()))
+                        {
+                            return false;
+                        }
+
+                        // We are done with this array. Before we can parse a
+                        // new value, we need to evaluate the new state first.
+                        // By setting skip_to_state_evaluation to false, we
+                        // are effectively jumping to the beginning of this if.
+                        assert(not states.empty());
+                        states.pop_back();
+                        skip_to_state_evaluation = true;
+                        continue;
+                    }
+                    else
+                    {
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(),
+                                                        exception_message(token_type::end_array, "array")));
+                    }
+                }
+                else  // object
+                {
+                    // comma -> next value
+                    if (get_token() == token_type::value_separator)
+                    {
+                        // parse key
+                        if (JSON_UNLIKELY(get_token() != token_type::value_string))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    parse_error::create(101, m_lexer.get_position(),
+                                                            exception_message(token_type::value_string, "object key")));
+                        }
+                        else
+                        {
+                            if (JSON_UNLIKELY(not sax->key(m_lexer.get_string())))
+                            {
+                                return false;
+                            }
+                        }
+
+                        // parse separator (:)
+                        if (JSON_UNLIKELY(get_token() != token_type::name_separator))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    parse_error::create(101, m_lexer.get_position(),
+                                                            exception_message(token_type::name_separator, "object separator")));
+                        }
+
+                        // parse values
+                        get_token();
+                        continue;
+                    }
+
+                    // closing }
+                    if (JSON_LIKELY(last_token == token_type::end_object))
+                    {
+                        if (JSON_UNLIKELY(not sax->end_object()))
+                        {
+                            return false;
+                        }
+
+                        // We are done with this object. Before we can parse a
+                        // new value, we need to evaluate the new state first.
+                        // By setting skip_to_state_evaluation to false, we
+                        // are effectively jumping to the beginning of this if.
+                        assert(not states.empty());
+                        states.pop_back();
+                        skip_to_state_evaluation = true;
+                        continue;
+                    }
+                    else
+                    {
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(),
+                                                        exception_message(token_type::end_object, "object")));
+                    }
+                }
+            }
+        }
+    }
+
+    /// get next token from lexer
+    token_type get_token()
+    {
+        return (last_token = m_lexer.scan());
+    }
+
+    std::string exception_message(const token_type expected, const std::string& context)
+    {
+        std::string error_msg = "syntax error ";
+
+        if (not context.empty())
+        {
+            error_msg += "while parsing " + context + " ";
+        }
+
+        error_msg += "- ";
+
+        if (last_token == token_type::parse_error)
+        {
+            error_msg += std::string(m_lexer.get_error_message()) + "; last read: '" +
+                         m_lexer.get_token_string() + "'";
+        }
+        else
+        {
+            error_msg += "unexpected " + std::string(lexer_t::token_type_name(last_token));
+        }
+
+        if (expected != token_type::uninitialized)
+        {
+            error_msg += "; expected " + std::string(lexer_t::token_type_name(expected));
+        }
+
+        return error_msg;
+    }
+
+  private:
+    /// callback function
+    const parser_callback_t callback = nullptr;
+    /// the type of the last read token
+    token_type last_token = token_type::uninitialized;
+    /// the lexer
+    lexer_t m_lexer;
+    /// whether to throw exceptions in case of errors
+    const bool allow_exceptions = true;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
+
+
+#include <cstddef> // ptrdiff_t
+#include <limits>  // numeric_limits
+
+namespace nlohmann
+{
+namespace detail
+{
+/*
+@brief an iterator for primitive JSON types
+
+This class models an iterator for primitive JSON types (boolean, number,
+string). It's only purpose is to allow the iterator/const_iterator classes
+to "iterate" over primitive values. Internally, the iterator is modeled by
+a `difference_type` variable. Value begin_value (`0`) models the begin,
+end_value (`1`) models past the end.
+*/
+class primitive_iterator_t
+{
+  private:
+    using difference_type = std::ptrdiff_t;
+    static constexpr difference_type begin_value = 0;
+    static constexpr difference_type end_value = begin_value + 1;
+
+    /// iterator as signed integer type
+    difference_type m_it = (std::numeric_limits<std::ptrdiff_t>::min)();
+
+  public:
+    constexpr difference_type get_value() const noexcept
+    {
+        return m_it;
+    }
+
+    /// set iterator to a defined beginning
+    void set_begin() noexcept
+    {
+        m_it = begin_value;
+    }
+
+    /// set iterator to a defined past the end
+    void set_end() noexcept
+    {
+        m_it = end_value;
+    }
+
+    /// return whether the iterator can be dereferenced
+    constexpr bool is_begin() const noexcept
+    {
+        return m_it == begin_value;
+    }
+
+    /// return whether the iterator is at end
+    constexpr bool is_end() const noexcept
+    {
+        return m_it == end_value;
+    }
+
+    friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it == rhs.m_it;
+    }
+
+    friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it < rhs.m_it;
+    }
+
+    primitive_iterator_t operator+(difference_type n) noexcept
+    {
+        auto result = *this;
+        result += n;
+        return result;
+    }
+
+    friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it - rhs.m_it;
+    }
+
+    primitive_iterator_t& operator++() noexcept
+    {
+        ++m_it;
+        return *this;
+    }
+
+    primitive_iterator_t const operator++(int) noexcept
+    {
+        auto result = *this;
+        ++m_it;
+        return result;
+    }
+
+    primitive_iterator_t& operator--() noexcept
+    {
+        --m_it;
+        return *this;
+    }
+
+    primitive_iterator_t const operator--(int) noexcept
+    {
+        auto result = *this;
+        --m_it;
+        return result;
+    }
+
+    primitive_iterator_t& operator+=(difference_type n) noexcept
+    {
+        m_it += n;
+        return *this;
+    }
+
+    primitive_iterator_t& operator-=(difference_type n) noexcept
+    {
+        m_it -= n;
+        return *this;
+    }
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/iterators/internal_iterator.hpp>
+
+
+// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+/*!
+@brief an iterator value
+
+@note This structure could easily be a union, but MSVC currently does not allow
+unions members with complex constructors, see https://github.com/nlohmann/json/pull/105.
+*/
+template<typename BasicJsonType> struct internal_iterator
+{
+    /// iterator for JSON objects
+    typename BasicJsonType::object_t::iterator object_iterator {};
+    /// iterator for JSON arrays
+    typename BasicJsonType::array_t::iterator array_iterator {};
+    /// generic iterator for all other types
+    primitive_iterator_t primitive_iterator {};
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/iterators/iter_impl.hpp>
+
+
+#include <ciso646> // not
+#include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next
+#include <type_traits> // conditional, is_const, remove_const
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/iterators/internal_iterator.hpp>
+
+// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+// forward declare, to be able to friend it later on
+template<typename IteratorType> class iteration_proxy;
+template<typename IteratorType> class iteration_proxy_value;
+
+/*!
+@brief a template for a bidirectional iterator for the @ref basic_json class
+This class implements a both iterators (iterator and const_iterator) for the
+@ref basic_json class.
+@note An iterator is called *initialized* when a pointer to a JSON value has
+      been set (e.g., by a constructor or a copy assignment). If the iterator is
+      default-constructed, it is *uninitialized* and most methods are undefined.
+      **The library uses assertions to detect calls on uninitialized iterators.**
+@requirement The class satisfies the following concept requirements:
+-
+[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
+  The iterator that can be moved can be moved in both directions (i.e.
+  incremented and decremented).
+@since version 1.0.0, simplified in version 2.0.9, change to bidirectional
+       iterators in version 3.0.0 (see https://github.com/nlohmann/json/issues/593)
+*/
+template<typename BasicJsonType>
+class iter_impl
+{
+    /// allow basic_json to access private members
+    friend iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value, typename std::remove_const<BasicJsonType>::type, const BasicJsonType>::type>;
+    friend BasicJsonType;
+    friend iteration_proxy<iter_impl>;
+    friend iteration_proxy_value<iter_impl>;
+
+    using object_t = typename BasicJsonType::object_t;
+    using array_t = typename BasicJsonType::array_t;
+    // make sure BasicJsonType is basic_json or const basic_json
+    static_assert(is_basic_json<typename std::remove_const<BasicJsonType>::type>::value,
+                  "iter_impl only accepts (const) basic_json");
+
+  public:
+
+    /// The std::iterator class template (used as a base class to provide typedefs) is deprecated in C++17.
+    /// The C++ Standard has never required user-defined iterators to derive from std::iterator.
+    /// A user-defined iterator should provide publicly accessible typedefs named
+    /// iterator_category, value_type, difference_type, pointer, and reference.
+    /// Note that value_type is required to be non-const, even for constant iterators.
+    using iterator_category = std::bidirectional_iterator_tag;
+
+    /// the type of the values when the iterator is dereferenced
+    using value_type = typename BasicJsonType::value_type;
+    /// a type to represent differences between iterators
+    using difference_type = typename BasicJsonType::difference_type;
+    /// defines a pointer to the type iterated over (value_type)
+    using pointer = typename std::conditional<std::is_const<BasicJsonType>::value,
+          typename BasicJsonType::const_pointer,
+          typename BasicJsonType::pointer>::type;
+    /// defines a reference to the type iterated over (value_type)
+    using reference =
+        typename std::conditional<std::is_const<BasicJsonType>::value,
+        typename BasicJsonType::const_reference,
+        typename BasicJsonType::reference>::type;
+
+    /// default constructor
+    iter_impl() = default;
+
+    /*!
+    @brief constructor for a given JSON instance
+    @param[in] object  pointer to a JSON object for this iterator
+    @pre object != nullptr
+    @post The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    explicit iter_impl(pointer object) noexcept : m_object(object)
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                m_it.object_iterator = typename object_t::iterator();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_it.array_iterator = typename array_t::iterator();
+                break;
+            }
+
+            default:
+            {
+                m_it.primitive_iterator = primitive_iterator_t();
+                break;
+            }
+        }
+    }
+
+    /*!
+    @note The conventional copy constructor and copy assignment are implicitly
+          defined. Combined with the following converting constructor and
+          assignment, they support: (1) copy from iterator to iterator, (2)
+          copy from const iterator to const iterator, and (3) conversion from
+          iterator to const iterator. However conversion from const iterator
+          to iterator is not defined.
+    */
+
+    /*!
+    @brief converting constructor
+    @param[in] other  non-const iterator to copy from
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
+        : m_object(other.m_object), m_it(other.m_it) {}
+
+    /*!
+    @brief converting assignment
+    @param[in,out] other  non-const iterator to copy from
+    @return const/non-const iterator
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl& operator=(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
+    {
+        m_object = other.m_object;
+        m_it = other.m_it;
+        return *this;
+    }
+
+  private:
+    /*!
+    @brief set the iterator to the first value
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    void set_begin() noexcept
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                m_it.object_iterator = m_object->m_value.object->begin();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_it.array_iterator = m_object->m_value.array->begin();
+                break;
+            }
+
+            case value_t::null:
+            {
+                // set to end so begin()==end() is true: null is empty
+                m_it.primitive_iterator.set_end();
+                break;
+            }
+
+            default:
+            {
+                m_it.primitive_iterator.set_begin();
+                break;
+            }
+        }
+    }
+
+    /*!
+    @brief set the iterator past the last value
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    void set_end() noexcept
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                m_it.object_iterator = m_object->m_value.object->end();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_it.array_iterator = m_object->m_value.array->end();
+                break;
+            }
+
+            default:
+            {
+                m_it.primitive_iterator.set_end();
+                break;
+            }
+        }
+    }
+
+  public:
+    /*!
+    @brief return a reference to the value pointed to by the iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference operator*() const
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                assert(m_it.object_iterator != m_object->m_value.object->end());
+                return m_it.object_iterator->second;
+            }
+
+            case value_t::array:
+            {
+                assert(m_it.array_iterator != m_object->m_value.array->end());
+                return *m_it.array_iterator;
+            }
+
+            case value_t::null:
+                JSON_THROW(invalid_iterator::create(214, "cannot get value"));
+
+            default:
+            {
+                if (JSON_LIKELY(m_it.primitive_iterator.is_begin()))
+                {
+                    return *m_object;
+                }
+
+                JSON_THROW(invalid_iterator::create(214, "cannot get value"));
+            }
+        }
+    }
+
+    /*!
+    @brief dereference the iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    pointer operator->() const
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                assert(m_it.object_iterator != m_object->m_value.object->end());
+                return &(m_it.object_iterator->second);
+            }
+
+            case value_t::array:
+            {
+                assert(m_it.array_iterator != m_object->m_value.array->end());
+                return &*m_it.array_iterator;
+            }
+
+            default:
+            {
+                if (JSON_LIKELY(m_it.primitive_iterator.is_begin()))
+                {
+                    return m_object;
+                }
+
+                JSON_THROW(invalid_iterator::create(214, "cannot get value"));
+            }
+        }
+    }
+
+    /*!
+    @brief post-increment (it++)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl const operator++(int)
+    {
+        auto result = *this;
+        ++(*this);
+        return result;
+    }
+
+    /*!
+    @brief pre-increment (++it)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator++()
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                std::advance(m_it.object_iterator, 1);
+                break;
+            }
+
+            case value_t::array:
+            {
+                std::advance(m_it.array_iterator, 1);
+                break;
+            }
+
+            default:
+            {
+                ++m_it.primitive_iterator;
+                break;
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    @brief post-decrement (it--)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl const operator--(int)
+    {
+        auto result = *this;
+        --(*this);
+        return result;
+    }
+
+    /*!
+    @brief pre-decrement (--it)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator--()
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                std::advance(m_it.object_iterator, -1);
+                break;
+            }
+
+            case value_t::array:
+            {
+                std::advance(m_it.array_iterator, -1);
+                break;
+            }
+
+            default:
+            {
+                --m_it.primitive_iterator;
+                break;
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    @brief  comparison: equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator==(const iter_impl& other) const
+    {
+        // if objects are not the same, the comparison is undefined
+        if (JSON_UNLIKELY(m_object != other.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
+        }
+
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+                return (m_it.object_iterator == other.m_it.object_iterator);
+
+            case value_t::array:
+                return (m_it.array_iterator == other.m_it.array_iterator);
+
+            default:
+                return (m_it.primitive_iterator == other.m_it.primitive_iterator);
+        }
+    }
+
+    /*!
+    @brief  comparison: not equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator!=(const iter_impl& other) const
+    {
+        return not operator==(other);
+    }
+
+    /*!
+    @brief  comparison: smaller
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator<(const iter_impl& other) const
+    {
+        // if objects are not the same, the comparison is undefined
+        if (JSON_UNLIKELY(m_object != other.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
+        }
+
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(213, "cannot compare order of object iterators"));
+
+            case value_t::array:
+                return (m_it.array_iterator < other.m_it.array_iterator);
+
+            default:
+                return (m_it.primitive_iterator < other.m_it.primitive_iterator);
+        }
+    }
+
+    /*!
+    @brief  comparison: less than or equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator<=(const iter_impl& other) const
+    {
+        return not other.operator < (*this);
+    }
+
+    /*!
+    @brief  comparison: greater than
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator>(const iter_impl& other) const
+    {
+        return not operator<=(other);
+    }
+
+    /*!
+    @brief  comparison: greater than or equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator>=(const iter_impl& other) const
+    {
+        return not operator<(other);
+    }
+
+    /*!
+    @brief  add to iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator+=(difference_type i)
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators"));
+
+            case value_t::array:
+            {
+                std::advance(m_it.array_iterator, i);
+                break;
+            }
+
+            default:
+            {
+                m_it.primitive_iterator += i;
+                break;
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    @brief  subtract from iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator-=(difference_type i)
+    {
+        return operator+=(-i);
+    }
+
+    /*!
+    @brief  add to iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator+(difference_type i) const
+    {
+        auto result = *this;
+        result += i;
+        return result;
+    }
+
+    /*!
+    @brief  addition of distance and iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    friend iter_impl operator+(difference_type i, const iter_impl& it)
+    {
+        auto result = it;
+        result += i;
+        return result;
+    }
+
+    /*!
+    @brief  subtract from iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator-(difference_type i) const
+    {
+        auto result = *this;
+        result -= i;
+        return result;
+    }
+
+    /*!
+    @brief  return difference
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    difference_type operator-(const iter_impl& other) const
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators"));
+
+            case value_t::array:
+                return m_it.array_iterator - other.m_it.array_iterator;
+
+            default:
+                return m_it.primitive_iterator - other.m_it.primitive_iterator;
+        }
+    }
+
+    /*!
+    @brief  access to successor
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference operator[](difference_type n) const
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(208, "cannot use operator[] for object iterators"));
+
+            case value_t::array:
+                return *std::next(m_it.array_iterator, n);
+
+            case value_t::null:
+                JSON_THROW(invalid_iterator::create(214, "cannot get value"));
+
+            default:
+            {
+                if (JSON_LIKELY(m_it.primitive_iterator.get_value() == -n))
+                {
+                    return *m_object;
+                }
+
+                JSON_THROW(invalid_iterator::create(214, "cannot get value"));
+            }
+        }
+    }
+
+    /*!
+    @brief  return the key of an object iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    const typename object_t::key_type& key() const
+    {
+        assert(m_object != nullptr);
+
+        if (JSON_LIKELY(m_object->is_object()))
+        {
+            return m_it.object_iterator->first;
+        }
+
+        JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators"));
+    }
+
+    /*!
+    @brief  return the value of an iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference value() const
+    {
+        return operator*();
+    }
+
+  private:
+    /// associated JSON instance
+    pointer m_object = nullptr;
+    /// the actual iterator of the associated instance
+    internal_iterator<typename std::remove_const<BasicJsonType>::type> m_it;
+};
+}  // namespace detail
+} // namespace nlohmann
+// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
+
+// #include <nlohmann/detail/iterators/json_reverse_iterator.hpp>
+
+
+#include <cstddef> // ptrdiff_t
+#include <iterator> // reverse_iterator
+#include <utility> // declval
+
+namespace nlohmann
+{
+namespace detail
+{
+//////////////////////
+// reverse_iterator //
+//////////////////////
+
+/*!
+@brief a template for a reverse iterator class
+
+@tparam Base the base iterator type to reverse. Valid types are @ref
+iterator (to create @ref reverse_iterator) and @ref const_iterator (to
+create @ref const_reverse_iterator).
+
+@requirement The class satisfies the following concept requirements:
+-
+[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
+  The iterator that can be moved can be moved in both directions (i.e.
+  incremented and decremented).
+- [OutputIterator](https://en.cppreference.com/w/cpp/named_req/OutputIterator):
+  It is possible to write to the pointed-to element (only if @a Base is
+  @ref iterator).
+
+@since version 1.0.0
+*/
+template<typename Base>
+class json_reverse_iterator : public std::reverse_iterator<Base>
+{
+  public:
+    using difference_type = std::ptrdiff_t;
+    /// shortcut to the reverse iterator adapter
+    using base_iterator = std::reverse_iterator<Base>;
+    /// the reference type for the pointed-to element
+    using reference = typename Base::reference;
+
+    /// create reverse iterator from iterator
+    explicit json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept
+        : base_iterator(it) {}
+
+    /// create reverse iterator from base class
+    explicit json_reverse_iterator(const base_iterator& it) noexcept : base_iterator(it) {}
+
+    /// post-increment (it++)
+    json_reverse_iterator const operator++(int)
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator++(1));
+    }
+
+    /// pre-increment (++it)
+    json_reverse_iterator& operator++()
+    {
+        return static_cast<json_reverse_iterator&>(base_iterator::operator++());
+    }
+
+    /// post-decrement (it--)
+    json_reverse_iterator const operator--(int)
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator--(1));
+    }
+
+    /// pre-decrement (--it)
+    json_reverse_iterator& operator--()
+    {
+        return static_cast<json_reverse_iterator&>(base_iterator::operator--());
+    }
+
+    /// add to iterator
+    json_reverse_iterator& operator+=(difference_type i)
+    {
+        return static_cast<json_reverse_iterator&>(base_iterator::operator+=(i));
+    }
+
+    /// add to iterator
+    json_reverse_iterator operator+(difference_type i) const
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator+(i));
+    }
+
+    /// subtract from iterator
+    json_reverse_iterator operator-(difference_type i) const
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator-(i));
+    }
+
+    /// return difference
+    difference_type operator-(const json_reverse_iterator& other) const
+    {
+        return base_iterator(*this) - base_iterator(other);
+    }
+
+    /// access to successor
+    reference operator[](difference_type n) const
+    {
+        return *(this->operator+(n));
+    }
+
+    /// return the key of an object iterator
+    auto key() const -> decltype(std::declval<Base>().key())
+    {
+        auto it = --this->base();
+        return it.key();
+    }
+
+    /// return the value of an iterator
+    reference value() const
+    {
+        auto it = --this->base();
+        return it.operator * ();
+    }
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/output/output_adapters.hpp>
+
+
+#include <algorithm> // copy
+#include <cstddef> // size_t
+#include <ios> // streamsize
+#include <iterator> // back_inserter
+#include <memory> // shared_ptr, make_shared
+#include <ostream> // basic_ostream
+#include <string> // basic_string
+#include <vector> // vector
+
+namespace nlohmann
+{
+namespace detail
+{
+/// abstract output adapter interface
+template<typename CharType> struct output_adapter_protocol
+{
+    virtual void write_character(CharType c) = 0;
+    virtual void write_characters(const CharType* s, std::size_t length) = 0;
+    virtual ~output_adapter_protocol() = default;
+};
+
+/// a type to simplify interfaces
+template<typename CharType>
+using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
+
+/// output adapter for byte vectors
+template<typename CharType>
+class output_vector_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_vector_adapter(std::vector<CharType>& vec) noexcept
+        : v(vec)
+    {}
+
+    void write_character(CharType c) override
+    {
+        v.push_back(c);
+    }
+
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        std::copy(s, s + length, std::back_inserter(v));
+    }
+
+  private:
+    std::vector<CharType>& v;
+};
+
+/// output adapter for output streams
+template<typename CharType>
+class output_stream_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_stream_adapter(std::basic_ostream<CharType>& s) noexcept
+        : stream(s)
+    {}
+
+    void write_character(CharType c) override
+    {
+        stream.put(c);
+    }
+
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        stream.write(s, static_cast<std::streamsize>(length));
+    }
+
+  private:
+    std::basic_ostream<CharType>& stream;
+};
+
+/// output adapter for basic_string
+template<typename CharType, typename StringType = std::basic_string<CharType>>
+class output_string_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_string_adapter(StringType& s) noexcept
+        : str(s)
+    {}
+
+    void write_character(CharType c) override
+    {
+        str.push_back(c);
+    }
+
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        str.append(s, length);
+    }
+
+  private:
+    StringType& str;
+};
+
+template<typename CharType, typename StringType = std::basic_string<CharType>>
+class output_adapter
+{
+  public:
+    output_adapter(std::vector<CharType>& vec)
+        : oa(std::make_shared<output_vector_adapter<CharType>>(vec)) {}
+
+    output_adapter(std::basic_ostream<CharType>& s)
+        : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}
+
+    output_adapter(StringType& s)
+        : oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}
+
+    operator output_adapter_t<CharType>()
+    {
+        return oa;
+    }
+
+  private:
+    output_adapter_t<CharType> oa = nullptr;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/input/binary_reader.hpp>
+
+
+#include <algorithm> // generate_n
+#include <array> // array
+#include <cassert> // assert
+#include <cmath> // ldexp
+#include <cstddef> // size_t
+#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
+#include <cstdio> // snprintf
+#include <cstring> // memcpy
+#include <iterator> // back_inserter
+#include <limits> // numeric_limits
+#include <string> // char_traits, string
+#include <utility> // make_pair, move
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+// #include <nlohmann/detail/input/json_sax.hpp>
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/is_sax.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+///////////////////
+// binary reader //
+///////////////////
+
+/*!
+@brief deserialization of CBOR, MessagePack, and UBJSON values
+*/
+template<typename BasicJsonType, typename SAX = json_sax_dom_parser<BasicJsonType>>
+class binary_reader
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using json_sax_t = SAX;
+
+  public:
+    /*!
+    @brief create a binary reader
+
+    @param[in] adapter  input adapter to read from
+    */
+    explicit binary_reader(input_adapter_t adapter) : ia(std::move(adapter))
+    {
+        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
+        assert(ia);
+    }
+
+    /*!
+    @param[in] format  the binary format to parse
+    @param[in] sax_    a SAX event processor
+    @param[in] strict  whether to expect the input to be consumed completed
+
+    @return
+    */
+    bool sax_parse(const input_format_t format,
+                   json_sax_t* sax_,
+                   const bool strict = true)
+    {
+        sax = sax_;
+        bool result = false;
+
+        switch (format)
+        {
+            case input_format_t::bson:
+                result = parse_bson_internal();
+                break;
+
+            case input_format_t::cbor:
+                result = parse_cbor_internal();
+                break;
+
+            case input_format_t::msgpack:
+                result = parse_msgpack_internal();
+                break;
+
+            case input_format_t::ubjson:
+                result = parse_ubjson_internal();
+                break;
+
+            // LCOV_EXCL_START
+            default:
+                assert(false);
+                // LCOV_EXCL_STOP
+        }
+
+        // strict mode: next byte must be EOF
+        if (result and strict)
+        {
+            if (format == input_format_t::ubjson)
+            {
+                get_ignore_noop();
+            }
+            else
+            {
+                get();
+            }
+
+            if (JSON_UNLIKELY(current != std::char_traits<char>::eof()))
+            {
+                return sax->parse_error(chars_read, get_token_string(),
+                                        parse_error::create(110, chars_read, exception_message(format, "expected end of input; last byte: 0x" + get_token_string(), "value")));
+            }
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief determine system byte order
+
+    @return true if and only if system's byte order is little endian
+
+    @note from http://stackoverflow.com/a/1001328/266378
+    */
+    static constexpr bool little_endianess(int num = 1) noexcept
+    {
+        return (*reinterpret_cast<char*>(&num) == 1);
+    }
+
+  private:
+    //////////
+    // BSON //
+    //////////
+
+    /*!
+    @brief Reads in a BSON-object and passes it to the SAX-parser.
+    @return whether a valid BSON-value was passed to the SAX parser
+    */
+    bool parse_bson_internal()
+    {
+        std::int32_t document_size;
+        get_number<std::int32_t, true>(input_format_t::bson, document_size);
+
+        if (JSON_UNLIKELY(not sax->start_object(std::size_t(-1))))
+        {
+            return false;
+        }
+
+        if (JSON_UNLIKELY(not parse_bson_element_list(/*is_array*/false)))
+        {
+            return false;
+        }
+
+        return sax->end_object();
+    }
+
+    /*!
+    @brief Parses a C-style string from the BSON input.
+    @param[in, out] result  A reference to the string variable where the read
+                            string is to be stored.
+    @return `true` if the \x00-byte indicating the end of the string was
+             encountered before the EOF; false` indicates an unexpected EOF.
+    */
+    bool get_bson_cstr(string_t& result)
+    {
+        auto out = std::back_inserter(result);
+        while (true)
+        {
+            get();
+            if (JSON_UNLIKELY(not unexpect_eof(input_format_t::bson, "cstring")))
+            {
+                return false;
+            }
+            if (current == 0x00)
+            {
+                return true;
+            }
+            *out++ = static_cast<char>(current);
+        }
+
+        return true;
+    }
+
+    /*!
+    @brief Parses a zero-terminated string of length @a len from the BSON
+           input.
+    @param[in] len  The length (including the zero-byte at the end) of the
+                    string to be read.
+    @param[in, out] result  A reference to the string variable where the read
+                            string is to be stored.
+    @tparam NumberType The type of the length @a len
+    @pre len >= 1
+    @return `true` if the string was successfully parsed
+    */
+    template<typename NumberType>
+    bool get_bson_string(const NumberType len, string_t& result)
+    {
+        if (JSON_UNLIKELY(len < 1))
+        {
+            auto last_token = get_token_string();
+            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::bson, "string length must be at least 1, is " + std::to_string(len), "string")));
+        }
+
+        return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) and get() != std::char_traits<char>::eof();
+    }
+
+    /*!
+    @brief Read a BSON document element of the given @a element_type.
+    @param[in] element_type The BSON element type, c.f. http://bsonspec.org/spec.html
+    @param[in] element_type_parse_position The position in the input stream,
+               where the `element_type` was read.
+    @warning Not all BSON element types are supported yet. An unsupported
+             @a element_type will give rise to a parse_error.114:
+             Unsupported BSON record type 0x...
+    @return whether a valid BSON-object/array was passed to the SAX parser
+    */
+    bool parse_bson_element_internal(const int element_type,
+                                     const std::size_t element_type_parse_position)
+    {
+        switch (element_type)
+        {
+            case 0x01: // double
+            {
+                double number;
+                return get_number<double, true>(input_format_t::bson, number) and sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0x02: // string
+            {
+                std::int32_t len;
+                string_t value;
+                return get_number<std::int32_t, true>(input_format_t::bson, len) and get_bson_string(len, value) and sax->string(value);
+            }
+
+            case 0x03: // object
+            {
+                return parse_bson_internal();
+            }
+
+            case 0x04: // array
+            {
+                return parse_bson_array();
+            }
+
+            case 0x08: // boolean
+            {
+                return sax->boolean(get() != 0);
+            }
+
+            case 0x0A: // null
+            {
+                return sax->null();
+            }
+
+            case 0x10: // int32
+            {
+                std::int32_t value;
+                return get_number<std::int32_t, true>(input_format_t::bson, value) and sax->number_integer(value);
+            }
+
+            case 0x12: // int64
+            {
+                std::int64_t value;
+                return get_number<std::int64_t, true>(input_format_t::bson, value) and sax->number_integer(value);
+            }
+
+            default: // anything else not supported (yet)
+            {
+                char cr[3];
+                (std::snprintf)(cr, sizeof(cr), "%.2hhX", static_cast<unsigned char>(element_type));
+                return sax->parse_error(element_type_parse_position, std::string(cr), parse_error::create(114, element_type_parse_position, "Unsupported BSON record type 0x" + std::string(cr)));
+            }
+        }
+    }
+
+    /*!
+    @brief Read a BSON element list (as specified in the BSON-spec)
+
+    The same binary layout is used for objects and arrays, hence it must be
+    indicated with the argument @a is_array which one is expected
+    (true --> array, false --> object).
+
+    @param[in] is_array Determines if the element list being read is to be
+                        treated as an object (@a is_array == false), or as an
+                        array (@a is_array == true).
+    @return whether a valid BSON-object/array was passed to the SAX parser
+    */
+    bool parse_bson_element_list(const bool is_array)
+    {
+        string_t key;
+        while (int element_type = get())
+        {
+            if (JSON_UNLIKELY(not unexpect_eof(input_format_t::bson, "element list")))
+            {
+                return false;
+            }
+
+            const std::size_t element_type_parse_position = chars_read;
+            if (JSON_UNLIKELY(not get_bson_cstr(key)))
+            {
+                return false;
+            }
+
+            if (not is_array)
+            {
+                if (not sax->key(key))
+                {
+                    return false;
+                }
+            }
+
+            if (JSON_UNLIKELY(not parse_bson_element_internal(element_type, element_type_parse_position)))
+            {
+                return false;
+            }
+
+            // get_bson_cstr only appends
+            key.clear();
+        }
+
+        return true;
+    }
+
+    /*!
+    @brief Reads an array from the BSON input and passes it to the SAX-parser.
+    @return whether a valid BSON-array was passed to the SAX parser
+    */
+    bool parse_bson_array()
+    {
+        std::int32_t document_size;
+        get_number<std::int32_t, true>(input_format_t::bson, document_size);
+
+        if (JSON_UNLIKELY(not sax->start_array(std::size_t(-1))))
+        {
+            return false;
+        }
+
+        if (JSON_UNLIKELY(not parse_bson_element_list(/*is_array*/true)))
+        {
+            return false;
+        }
+
+        return sax->end_array();
+    }
+
+    //////////
+    // CBOR //
+    //////////
+
+    /*!
+    @param[in] get_char  whether a new character should be retrieved from the
+                         input (true, default) or whether the last read
+                         character should be considered instead
+
+    @return whether a valid CBOR value was passed to the SAX parser
+    */
+    bool parse_cbor_internal(const bool get_char = true)
+    {
+        switch (get_char ? get() : current)
+        {
+            // EOF
+            case std::char_traits<char>::eof():
+                return unexpect_eof(input_format_t::cbor, "value");
+
+            // Integer 0x00..0x17 (0..23)
+            case 0x00:
+            case 0x01:
+            case 0x02:
+            case 0x03:
+            case 0x04:
+            case 0x05:
+            case 0x06:
+            case 0x07:
+            case 0x08:
+            case 0x09:
+            case 0x0A:
+            case 0x0B:
+            case 0x0C:
+            case 0x0D:
+            case 0x0E:
+            case 0x0F:
+            case 0x10:
+            case 0x11:
+            case 0x12:
+            case 0x13:
+            case 0x14:
+            case 0x15:
+            case 0x16:
+            case 0x17:
+                return sax->number_unsigned(static_cast<number_unsigned_t>(current));
+
+            case 0x18: // Unsigned integer (one-byte uint8_t follows)
+            {
+                uint8_t number;
+                return get_number(input_format_t::cbor, number) and sax->number_unsigned(number);
+            }
+
+            case 0x19: // Unsigned integer (two-byte uint16_t follows)
+            {
+                uint16_t number;
+                return get_number(input_format_t::cbor, number) and sax->number_unsigned(number);
+            }
+
+            case 0x1A: // Unsigned integer (four-byte uint32_t follows)
+            {
+                uint32_t number;
+                return get_number(input_format_t::cbor, number) and sax->number_unsigned(number);
+            }
+
+            case 0x1B: // Unsigned integer (eight-byte uint64_t follows)
+            {
+                uint64_t number;
+                return get_number(input_format_t::cbor, number) and sax->number_unsigned(number);
+            }
+
+            // Negative integer -1-0x00..-1-0x17 (-1..-24)
+            case 0x20:
+            case 0x21:
+            case 0x22:
+            case 0x23:
+            case 0x24:
+            case 0x25:
+            case 0x26:
+            case 0x27:
+            case 0x28:
+            case 0x29:
+            case 0x2A:
+            case 0x2B:
+            case 0x2C:
+            case 0x2D:
+            case 0x2E:
+            case 0x2F:
+            case 0x30:
+            case 0x31:
+            case 0x32:
+            case 0x33:
+            case 0x34:
+            case 0x35:
+            case 0x36:
+            case 0x37:
+                return sax->number_integer(static_cast<int8_t>(0x20 - 1 - current));
+
+            case 0x38: // Negative integer (one-byte uint8_t follows)
+            {
+                uint8_t number;
+                return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1) - number);
+            }
+
+            case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
+            {
+                uint16_t number;
+                return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1) - number);
+            }
+
+            case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)
+            {
+                uint32_t number;
+                return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1) - number);
+            }
+
+            case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)
+            {
+                uint64_t number;
+                return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1)
+                        - static_cast<number_integer_t>(number));
+            }
+
+            // UTF-8 string (0x00..0x17 bytes follow)
+            case 0x60:
+            case 0x61:
+            case 0x62:
+            case 0x63:
+            case 0x64:
+            case 0x65:
+            case 0x66:
+            case 0x67:
+            case 0x68:
+            case 0x69:
+            case 0x6A:
+            case 0x6B:
+            case 0x6C:
+            case 0x6D:
+            case 0x6E:
+            case 0x6F:
+            case 0x70:
+            case 0x71:
+            case 0x72:
+            case 0x73:
+            case 0x74:
+            case 0x75:
+            case 0x76:
+            case 0x77:
+            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
+            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
+            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
+            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
+            case 0x7F: // UTF-8 string (indefinite length)
+            {
+                string_t s;
+                return get_cbor_string(s) and sax->string(s);
+            }
+
+            // array (0x00..0x17 data items follow)
+            case 0x80:
+            case 0x81:
+            case 0x82:
+            case 0x83:
+            case 0x84:
+            case 0x85:
+            case 0x86:
+            case 0x87:
+            case 0x88:
+            case 0x89:
+            case 0x8A:
+            case 0x8B:
+            case 0x8C:
+            case 0x8D:
+            case 0x8E:
+            case 0x8F:
+            case 0x90:
+            case 0x91:
+            case 0x92:
+            case 0x93:
+            case 0x94:
+            case 0x95:
+            case 0x96:
+            case 0x97:
+                return get_cbor_array(static_cast<std::size_t>(current & 0x1F));
+
+            case 0x98: // array (one-byte uint8_t for n follows)
+            {
+                uint8_t len;
+                return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len));
+            }
+
+            case 0x99: // array (two-byte uint16_t for n follow)
+            {
+                uint16_t len;
+                return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len));
+            }
+
+            case 0x9A: // array (four-byte uint32_t for n follow)
+            {
+                uint32_t len;
+                return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len));
+            }
+
+            case 0x9B: // array (eight-byte uint64_t for n follow)
+            {
+                uint64_t len;
+                return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len));
+            }
+
+            case 0x9F: // array (indefinite length)
+                return get_cbor_array(std::size_t(-1));
+
+            // map (0x00..0x17 pairs of data items follow)
+            case 0xA0:
+            case 0xA1:
+            case 0xA2:
+            case 0xA3:
+            case 0xA4:
+            case 0xA5:
+            case 0xA6:
+            case 0xA7:
+            case 0xA8:
+            case 0xA9:
+            case 0xAA:
+            case 0xAB:
+            case 0xAC:
+            case 0xAD:
+            case 0xAE:
+            case 0xAF:
+            case 0xB0:
+            case 0xB1:
+            case 0xB2:
+            case 0xB3:
+            case 0xB4:
+            case 0xB5:
+            case 0xB6:
+            case 0xB7:
+                return get_cbor_object(static_cast<std::size_t>(current & 0x1F));
+
+            case 0xB8: // map (one-byte uint8_t for n follows)
+            {
+                uint8_t len;
+                return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len));
+            }
+
+            case 0xB9: // map (two-byte uint16_t for n follow)
+            {
+                uint16_t len;
+                return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len));
+            }
+
+            case 0xBA: // map (four-byte uint32_t for n follow)
+            {
+                uint32_t len;
+                return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len));
+            }
+
+            case 0xBB: // map (eight-byte uint64_t for n follow)
+            {
+                uint64_t len;
+                return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len));
+            }
+
+            case 0xBF: // map (indefinite length)
+                return get_cbor_object(std::size_t(-1));
+
+            case 0xF4: // false
+                return sax->boolean(false);
+
+            case 0xF5: // true
+                return sax->boolean(true);
+
+            case 0xF6: // null
+                return sax->null();
+
+            case 0xF9: // Half-Precision Float (two-byte IEEE 754)
+            {
+                const int byte1_raw = get();
+                if (JSON_UNLIKELY(not unexpect_eof(input_format_t::cbor, "number")))
+                {
+                    return false;
+                }
+                const int byte2_raw = get();
+                if (JSON_UNLIKELY(not unexpect_eof(input_format_t::cbor, "number")))
+                {
+                    return false;
+                }
+
+                const auto byte1 = static_cast<unsigned char>(byte1_raw);
+                const auto byte2 = static_cast<unsigned char>(byte2_raw);
+
+                // code from RFC 7049, Appendix D, Figure 3:
+                // As half-precision floating-point numbers were only added
+                // to IEEE 754 in 2008, today's programming platforms often
+                // still only have limited support for them. It is very
+                // easy to include at least decoding support for them even
+                // without such support. An example of a small decoder for
+                // half-precision floating-point numbers in the C language
+                // is shown in Fig. 3.
+                const int half = (byte1 << 8) + byte2;
+                const double val = [&half]
+                {
+                    const int exp = (half >> 10) & 0x1F;
+                    const int mant = half & 0x3FF;
+                    assert(0 <= exp and exp <= 32);
+                    assert(0 <= mant and mant <= 1024);
+                    switch (exp)
+                    {
+                        case 0:
+                            return std::ldexp(mant, -24);
+                        case 31:
+                            return (mant == 0)
+                            ? std::numeric_limits<double>::infinity()
+                            : std::numeric_limits<double>::quiet_NaN();
+                        default:
+                            return std::ldexp(mant + 1024, exp - 25);
+                    }
+                }();
+                return sax->number_float((half & 0x8000) != 0
+                                         ? static_cast<number_float_t>(-val)
+                                         : static_cast<number_float_t>(val), "");
+            }
+
+            case 0xFA: // Single-Precision Float (four-byte IEEE 754)
+            {
+                float number;
+                return get_number(input_format_t::cbor, number) and sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0xFB: // Double-Precision Float (eight-byte IEEE 754)
+            {
+                double number;
+                return get_number(input_format_t::cbor, number) and sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            default: // anything else (0xFF is handled inside the other types)
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::cbor, "invalid byte: 0x" + last_token, "value")));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a CBOR string
+
+    This function first reads starting bytes to determine the expected
+    string length and then copies this number of bytes into a string.
+    Additionally, CBOR's strings with indefinite lengths are supported.
+
+    @param[out] result  created string
+
+    @return whether string creation completed
+    */
+    bool get_cbor_string(string_t& result)
+    {
+        if (JSON_UNLIKELY(not unexpect_eof(input_format_t::cbor, "string")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            // UTF-8 string (0x00..0x17 bytes follow)
+            case 0x60:
+            case 0x61:
+            case 0x62:
+            case 0x63:
+            case 0x64:
+            case 0x65:
+            case 0x66:
+            case 0x67:
+            case 0x68:
+            case 0x69:
+            case 0x6A:
+            case 0x6B:
+            case 0x6C:
+            case 0x6D:
+            case 0x6E:
+            case 0x6F:
+            case 0x70:
+            case 0x71:
+            case 0x72:
+            case 0x73:
+            case 0x74:
+            case 0x75:
+            case 0x76:
+            case 0x77:
+            {
+                return get_string(input_format_t::cbor, current & 0x1F, result);
+            }
+
+            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
+            {
+                uint8_t len;
+                return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
+            {
+                uint16_t len;
+                return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
+            {
+                uint32_t len;
+                return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
+            {
+                uint64_t len;
+                return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x7F: // UTF-8 string (indefinite length)
+            {
+                while (get() != 0xFF)
+                {
+                    string_t chunk;
+                    if (not get_cbor_string(chunk))
+                    {
+                        return false;
+                    }
+                    result.append(chunk);
+                }
+                return true;
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::cbor, "expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x" + last_token, "string")));
+            }
+        }
+    }
+
+    /*!
+    @param[in] len  the length of the array or std::size_t(-1) for an
+                    array of indefinite size
+    @return whether array creation completed
+    */
+    bool get_cbor_array(const std::size_t len)
+    {
+        if (JSON_UNLIKELY(not sax->start_array(len)))
+        {
+            return false;
+        }
+
+        if (len != std::size_t(-1))
+        {
+            for (std::size_t i = 0; i < len; ++i)
+            {
+                if (JSON_UNLIKELY(not parse_cbor_internal()))
+                {
+                    return false;
+                }
+            }
+        }
+        else
+        {
+            while (get() != 0xFF)
+            {
+                if (JSON_UNLIKELY(not parse_cbor_internal(false)))
+                {
+                    return false;
+                }
+            }
+        }
+
+        return sax->end_array();
+    }
+
+    /*!
+    @param[in] len  the length of the object or std::size_t(-1) for an
+                    object of indefinite size
+    @return whether object creation completed
+    */
+    bool get_cbor_object(const std::size_t len)
+    {
+        if (not JSON_UNLIKELY(sax->start_object(len)))
+        {
+            return false;
+        }
+
+        string_t key;
+        if (len != std::size_t(-1))
+        {
+            for (std::size_t i = 0; i < len; ++i)
+            {
+                get();
+                if (JSON_UNLIKELY(not get_cbor_string(key) or not sax->key(key)))
+                {
+                    return false;
+                }
+
+                if (JSON_UNLIKELY(not parse_cbor_internal()))
+                {
+                    return false;
+                }
+                key.clear();
+            }
+        }
+        else
+        {
+            while (get() != 0xFF)
+            {
+                if (JSON_UNLIKELY(not get_cbor_string(key) or not sax->key(key)))
+                {
+                    return false;
+                }
+
+                if (JSON_UNLIKELY(not parse_cbor_internal()))
+                {
+                    return false;
+                }
+                key.clear();
+            }
+        }
+
+        return sax->end_object();
+    }
+
+    /////////////
+    // MsgPack //
+    /////////////
+
+    /*!
+    @return whether a valid MessagePack value was passed to the SAX parser
+    */
+    bool parse_msgpack_internal()
+    {
+        switch (get())
+        {
+            // EOF
+            case std::char_traits<char>::eof():
+                return unexpect_eof(input_format_t::msgpack, "value");
+
+            // positive fixint
+            case 0x00:
+            case 0x01:
+            case 0x02:
+            case 0x03:
+            case 0x04:
+            case 0x05:
+            case 0x06:
+            case 0x07:
+            case 0x08:
+            case 0x09:
+            case 0x0A:
+            case 0x0B:
+            case 0x0C:
+            case 0x0D:
+            case 0x0E:
+            case 0x0F:
+            case 0x10:
+            case 0x11:
+            case 0x12:
+            case 0x13:
+            case 0x14:
+            case 0x15:
+            case 0x16:
+            case 0x17:
+            case 0x18:
+            case 0x19:
+            case 0x1A:
+            case 0x1B:
+            case 0x1C:
+            case 0x1D:
+            case 0x1E:
+            case 0x1F:
+            case 0x20:
+            case 0x21:
+            case 0x22:
+            case 0x23:
+            case 0x24:
+            case 0x25:
+            case 0x26:
+            case 0x27:
+            case 0x28:
+            case 0x29:
+            case 0x2A:
+            case 0x2B:
+            case 0x2C:
+            case 0x2D:
+            case 0x2E:
+            case 0x2F:
+            case 0x30:
+            case 0x31:
+            case 0x32:
+            case 0x33:
+            case 0x34:
+            case 0x35:
+            case 0x36:
+            case 0x37:
+            case 0x38:
+            case 0x39:
+            case 0x3A:
+            case 0x3B:
+            case 0x3C:
+            case 0x3D:
+            case 0x3E:
+            case 0x3F:
+            case 0x40:
+            case 0x41:
+            case 0x42:
+            case 0x43:
+            case 0x44:
+            case 0x45:
+            case 0x46:
+            case 0x47:
+            case 0x48:
+            case 0x49:
+            case 0x4A:
+            case 0x4B:
+            case 0x4C:
+            case 0x4D:
+            case 0x4E:
+            case 0x4F:
+            case 0x50:
+            case 0x51:
+            case 0x52:
+            case 0x53:
+            case 0x54:
+            case 0x55:
+            case 0x56:
+            case 0x57:
+            case 0x58:
+            case 0x59:
+            case 0x5A:
+            case 0x5B:
+            case 0x5C:
+            case 0x5D:
+            case 0x5E:
+            case 0x5F:
+            case 0x60:
+            case 0x61:
+            case 0x62:
+            case 0x63:
+            case 0x64:
+            case 0x65:
+            case 0x66:
+            case 0x67:
+            case 0x68:
+            case 0x69:
+            case 0x6A:
+            case 0x6B:
+            case 0x6C:
+            case 0x6D:
+            case 0x6E:
+            case 0x6F:
+            case 0x70:
+            case 0x71:
+            case 0x72:
+            case 0x73:
+            case 0x74:
+            case 0x75:
+            case 0x76:
+            case 0x77:
+            case 0x78:
+            case 0x79:
+            case 0x7A:
+            case 0x7B:
+            case 0x7C:
+            case 0x7D:
+            case 0x7E:
+            case 0x7F:
+                return sax->number_unsigned(static_cast<number_unsigned_t>(current));
+
+            // fixmap
+            case 0x80:
+            case 0x81:
+            case 0x82:
+            case 0x83:
+            case 0x84:
+            case 0x85:
+            case 0x86:
+            case 0x87:
+            case 0x88:
+            case 0x89:
+            case 0x8A:
+            case 0x8B:
+            case 0x8C:
+            case 0x8D:
+            case 0x8E:
+            case 0x8F:
+                return get_msgpack_object(static_cast<std::size_t>(current & 0x0F));
+
+            // fixarray
+            case 0x90:
+            case 0x91:
+            case 0x92:
+            case 0x93:
+            case 0x94:
+            case 0x95:
+            case 0x96:
+            case 0x97:
+            case 0x98:
+            case 0x99:
+            case 0x9A:
+            case 0x9B:
+            case 0x9C:
+            case 0x9D:
+            case 0x9E:
+            case 0x9F:
+                return get_msgpack_array(static_cast<std::size_t>(current & 0x0F));
+
+            // fixstr
+            case 0xA0:
+            case 0xA1:
+            case 0xA2:
+            case 0xA3:
+            case 0xA4:
+            case 0xA5:
+            case 0xA6:
+            case 0xA7:
+            case 0xA8:
+            case 0xA9:
+            case 0xAA:
+            case 0xAB:
+            case 0xAC:
+            case 0xAD:
+            case 0xAE:
+            case 0xAF:
+            case 0xB0:
+            case 0xB1:
+            case 0xB2:
+            case 0xB3:
+            case 0xB4:
+            case 0xB5:
+            case 0xB6:
+            case 0xB7:
+            case 0xB8:
+            case 0xB9:
+            case 0xBA:
+            case 0xBB:
+            case 0xBC:
+            case 0xBD:
+            case 0xBE:
+            case 0xBF:
+            {
+                string_t s;
+                return get_msgpack_string(s) and sax->string(s);
+            }
+
+            case 0xC0: // nil
+                return sax->null();
+
+            case 0xC2: // false
+                return sax->boolean(false);
+
+            case 0xC3: // true
+                return sax->boolean(true);
+
+            case 0xCA: // float 32
+            {
+                float number;
+                return get_number(input_format_t::msgpack, number) and sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0xCB: // float 64
+            {
+                double number;
+                return get_number(input_format_t::msgpack, number) and sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0xCC: // uint 8
+            {
+                uint8_t number;
+                return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number);
+            }
+
+            case 0xCD: // uint 16
+            {
+                uint16_t number;
+                return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number);
+            }
+
+            case 0xCE: // uint 32
+            {
+                uint32_t number;
+                return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number);
+            }
+
+            case 0xCF: // uint 64
+            {
+                uint64_t number;
+                return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number);
+            }
+
+            case 0xD0: // int 8
+            {
+                int8_t number;
+                return get_number(input_format_t::msgpack, number) and sax->number_integer(number);
+            }
+
+            case 0xD1: // int 16
+            {
+                int16_t number;
+                return get_number(input_format_t::msgpack, number) and sax->number_integer(number);
+            }
+
+            case 0xD2: // int 32
+            {
+                int32_t number;
+                return get_number(input_format_t::msgpack, number) and sax->number_integer(number);
+            }
+
+            case 0xD3: // int 64
+            {
+                int64_t number;
+                return get_number(input_format_t::msgpack, number) and sax->number_integer(number);
+            }
+
+            case 0xD9: // str 8
+            case 0xDA: // str 16
+            case 0xDB: // str 32
+            {
+                string_t s;
+                return get_msgpack_string(s) and sax->string(s);
+            }
+
+            case 0xDC: // array 16
+            {
+                uint16_t len;
+                return get_number(input_format_t::msgpack, len) and get_msgpack_array(static_cast<std::size_t>(len));
+            }
+
+            case 0xDD: // array 32
+            {
+                uint32_t len;
+                return get_number(input_format_t::msgpack, len) and get_msgpack_array(static_cast<std::size_t>(len));
+            }
+
+            case 0xDE: // map 16
+            {
+                uint16_t len;
+                return get_number(input_format_t::msgpack, len) and get_msgpack_object(static_cast<std::size_t>(len));
+            }
+
+            case 0xDF: // map 32
+            {
+                uint32_t len;
+                return get_number(input_format_t::msgpack, len) and get_msgpack_object(static_cast<std::size_t>(len));
+            }
+
+            // negative fixint
+            case 0xE0:
+            case 0xE1:
+            case 0xE2:
+            case 0xE3:
+            case 0xE4:
+            case 0xE5:
+            case 0xE6:
+            case 0xE7:
+            case 0xE8:
+            case 0xE9:
+            case 0xEA:
+            case 0xEB:
+            case 0xEC:
+            case 0xED:
+            case 0xEE:
+            case 0xEF:
+            case 0xF0:
+            case 0xF1:
+            case 0xF2:
+            case 0xF3:
+            case 0xF4:
+            case 0xF5:
+            case 0xF6:
+            case 0xF7:
+            case 0xF8:
+            case 0xF9:
+            case 0xFA:
+            case 0xFB:
+            case 0xFC:
+            case 0xFD:
+            case 0xFE:
+            case 0xFF:
+                return sax->number_integer(static_cast<int8_t>(current));
+
+            default: // anything else
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::msgpack, "invalid byte: 0x" + last_token, "value")));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a MessagePack string
+
+    This function first reads starting bytes to determine the expected
+    string length and then copies this number of bytes into a string.
+
+    @param[out] result  created string
+
+    @return whether string creation completed
+    */
+    bool get_msgpack_string(string_t& result)
+    {
+        if (JSON_UNLIKELY(not unexpect_eof(input_format_t::msgpack, "string")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            // fixstr
+            case 0xA0:
+            case 0xA1:
+            case 0xA2:
+            case 0xA3:
+            case 0xA4:
+            case 0xA5:
+            case 0xA6:
+            case 0xA7:
+            case 0xA8:
+            case 0xA9:
+            case 0xAA:
+            case 0xAB:
+            case 0xAC:
+            case 0xAD:
+            case 0xAE:
+            case 0xAF:
+            case 0xB0:
+            case 0xB1:
+            case 0xB2:
+            case 0xB3:
+            case 0xB4:
+            case 0xB5:
+            case 0xB6:
+            case 0xB7:
+            case 0xB8:
+            case 0xB9:
+            case 0xBA:
+            case 0xBB:
+            case 0xBC:
+            case 0xBD:
+            case 0xBE:
+            case 0xBF:
+            {
+                return get_string(input_format_t::msgpack, current & 0x1F, result);
+            }
+
+            case 0xD9: // str 8
+            {
+                uint8_t len;
+                return get_number(input_format_t::msgpack, len) and get_string(input_format_t::msgpack, len, result);
+            }
+
+            case 0xDA: // str 16
+            {
+                uint16_t len;
+                return get_number(input_format_t::msgpack, len) and get_string(input_format_t::msgpack, len, result);
+            }
+
+            case 0xDB: // str 32
+            {
+                uint32_t len;
+                return get_number(input_format_t::msgpack, len) and get_string(input_format_t::msgpack, len, result);
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::msgpack, "expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x" + last_token, "string")));
+            }
+        }
+    }
+
+    /*!
+    @param[in] len  the length of the array
+    @return whether array creation completed
+    */
+    bool get_msgpack_array(const std::size_t len)
+    {
+        if (JSON_UNLIKELY(not sax->start_array(len)))
+        {
+            return false;
+        }
+
+        for (std::size_t i = 0; i < len; ++i)
+        {
+            if (JSON_UNLIKELY(not parse_msgpack_internal()))
+            {
+                return false;
+            }
+        }
+
+        return sax->end_array();
+    }
+
+    /*!
+    @param[in] len  the length of the object
+    @return whether object creation completed
+    */
+    bool get_msgpack_object(const std::size_t len)
+    {
+        if (JSON_UNLIKELY(not sax->start_object(len)))
+        {
+            return false;
+        }
+
+        string_t key;
+        for (std::size_t i = 0; i < len; ++i)
+        {
+            get();
+            if (JSON_UNLIKELY(not get_msgpack_string(key) or not sax->key(key)))
+            {
+                return false;
+            }
+
+            if (JSON_UNLIKELY(not parse_msgpack_internal()))
+            {
+                return false;
+            }
+            key.clear();
+        }
+
+        return sax->end_object();
+    }
+
+    ////////////
+    // UBJSON //
+    ////////////
+
+    /*!
+    @param[in] get_char  whether a new character should be retrieved from the
+                         input (true, default) or whether the last read
+                         character should be considered instead
+
+    @return whether a valid UBJSON value was passed to the SAX parser
+    */
+    bool parse_ubjson_internal(const bool get_char = true)
+    {
+        return get_ubjson_value(get_char ? get_ignore_noop() : current);
+    }
+
+    /*!
+    @brief reads a UBJSON string
+
+    This function is either called after reading the 'S' byte explicitly
+    indicating a string, or in case of an object key where the 'S' byte can be
+    left out.
+
+    @param[out] result   created string
+    @param[in] get_char  whether a new character should be retrieved from the
+                         input (true, default) or whether the last read
+                         character should be considered instead
+
+    @return whether string creation completed
+    */
+    bool get_ubjson_string(string_t& result, const bool get_char = true)
+    {
+        if (get_char)
+        {
+            get();  // TODO: may we ignore N here?
+        }
+
+        if (JSON_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "value")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            case 'U':
+            {
+                uint8_t len;
+                return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
+            }
+
+            case 'i':
+            {
+                int8_t len;
+                return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
+            }
+
+            case 'I':
+            {
+                int16_t len;
+                return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
+            }
+
+            case 'l':
+            {
+                int32_t len;
+                return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
+            }
+
+            case 'L':
+            {
+                int64_t len;
+                return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
+            }
+
+            default:
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "expected length type specification (U, i, I, l, L); last byte: 0x" + last_token, "string")));
+        }
+    }
+
+    /*!
+    @param[out] result  determined size
+    @return whether size determination completed
+    */
+    bool get_ubjson_size_value(std::size_t& result)
+    {
+        switch (get_ignore_noop())
+        {
+            case 'U':
+            {
+                uint8_t number;
+                if (JSON_UNLIKELY(not get_number(input_format_t::ubjson, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'i':
+            {
+                int8_t number;
+                if (JSON_UNLIKELY(not get_number(input_format_t::ubjson, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'I':
+            {
+                int16_t number;
+                if (JSON_UNLIKELY(not get_number(input_format_t::ubjson, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'l':
+            {
+                int32_t number;
+                if (JSON_UNLIKELY(not get_number(input_format_t::ubjson, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'L':
+            {
+                int64_t number;
+                if (JSON_UNLIKELY(not get_number(input_format_t::ubjson, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "expected length type specification (U, i, I, l, L) after '#'; last byte: 0x" + last_token, "size")));
+            }
+        }
+    }
+
+    /*!
+    @brief determine the type and size for a container
+
+    In the optimized UBJSON format, a type and a size can be provided to allow
+    for a more compact representation.
+
+    @param[out] result  pair of the size and the type
+
+    @return whether pair creation completed
+    */
+    bool get_ubjson_size_type(std::pair<std::size_t, int>& result)
+    {
+        result.first = string_t::npos; // size
+        result.second = 0; // type
+
+        get_ignore_noop();
+
+        if (current == '$')
+        {
+            result.second = get();  // must not ignore 'N', because 'N' maybe the type
+            if (JSON_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "type")))
+            {
+                return false;
+            }
+
+            get_ignore_noop();
+            if (JSON_UNLIKELY(current != '#'))
+            {
+                if (JSON_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "value")))
+                {
+                    return false;
+                }
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::ubjson, "expected '#' after type information; last byte: 0x" + last_token, "size")));
+            }
+
+            return get_ubjson_size_value(result.first);
+        }
+        else if (current == '#')
+        {
+            return get_ubjson_size_value(result.first);
+        }
+        return true;
+    }
+
+    /*!
+    @param prefix  the previously read or set type prefix
+    @return whether value creation completed
+    */
+    bool get_ubjson_value(const int prefix)
+    {
+        switch (prefix)
+        {
+            case std::char_traits<char>::eof():  // EOF
+                return unexpect_eof(input_format_t::ubjson, "value");
+
+            case 'T':  // true
+                return sax->boolean(true);
+            case 'F':  // false
+                return sax->boolean(false);
+
+            case 'Z':  // null
+                return sax->null();
+
+            case 'U':
+            {
+                uint8_t number;
+                return get_number(input_format_t::ubjson, number) and sax->number_unsigned(number);
+            }
+
+            case 'i':
+            {
+                int8_t number;
+                return get_number(input_format_t::ubjson, number) and sax->number_integer(number);
+            }
+
+            case 'I':
+            {
+                int16_t number;
+                return get_number(input_format_t::ubjson, number) and sax->number_integer(number);
+            }
+
+            case 'l':
+            {
+                int32_t number;
+                return get_number(input_format_t::ubjson, number) and sax->number_integer(number);
+            }
+
+            case 'L':
+            {
+                int64_t number;
+                return get_number(input_format_t::ubjson, number) and sax->number_integer(number);
+            }
+
+            case 'd':
+            {
+                float number;
+                return get_number(input_format_t::ubjson, number) and sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 'D':
+            {
+                double number;
+                return get_number(input_format_t::ubjson, number) and sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 'C':  // char
+            {
+                get();
+                if (JSON_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "char")))
+                {
+                    return false;
+                }
+                if (JSON_UNLIKELY(current > 127))
+                {
+                    auto last_token = get_token_string();
+                    return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "byte after 'C' must be in range 0x00..0x7F; last byte: 0x" + last_token, "char")));
+                }
+                string_t s(1, static_cast<char>(current));
+                return sax->string(s);
+            }
+
+            case 'S':  // string
+            {
+                string_t s;
+                return get_ubjson_string(s) and sax->string(s);
+            }
+
+            case '[':  // array
+                return get_ubjson_array();
+
+            case '{':  // object
+                return get_ubjson_object();
+
+            default: // anything else
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::ubjson, "invalid byte: 0x" + last_token, "value")));
+            }
+        }
+    }
+
+    /*!
+    @return whether array creation completed
+    */
+    bool get_ubjson_array()
+    {
+        std::pair<std::size_t, int> size_and_type;
+        if (JSON_UNLIKELY(not get_ubjson_size_type(size_and_type)))
+        {
+            return false;
+        }
+
+        if (size_and_type.first != string_t::npos)
+        {
+            if (JSON_UNLIKELY(not sax->start_array(size_and_type.first)))
+            {
+                return false;
+            }
+
+            if (size_and_type.second != 0)
+            {
+                if (size_and_type.second != 'N')
+                {
+                    for (std::size_t i = 0; i < size_and_type.first; ++i)
+                    {
+                        if (JSON_UNLIKELY(not get_ubjson_value(size_and_type.second)))
+                        {
+                            return false;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_UNLIKELY(not parse_ubjson_internal()))
+                    {
+                        return false;
+                    }
+                }
+            }
+        }
+        else
+        {
+            if (JSON_UNLIKELY(not sax->start_array(std::size_t(-1))))
+            {
+                return false;
+            }
+
+            while (current != ']')
+            {
+                if (JSON_UNLIKELY(not parse_ubjson_internal(false)))
+                {
+                    return false;
+                }
+                get_ignore_noop();
+            }
+        }
+
+        return sax->end_array();
+    }
+
+    /*!
+    @return whether object creation completed
+    */
+    bool get_ubjson_object()
+    {
+        std::pair<std::size_t, int> size_and_type;
+        if (JSON_UNLIKELY(not get_ubjson_size_type(size_and_type)))
+        {
+            return false;
+        }
+
+        string_t key;
+        if (size_and_type.first != string_t::npos)
+        {
+            if (JSON_UNLIKELY(not sax->start_object(size_and_type.first)))
+            {
+                return false;
+            }
+
+            if (size_and_type.second != 0)
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_UNLIKELY(not get_ubjson_string(key) or not sax->key(key)))
+                    {
+                        return false;
+                    }
+                    if (JSON_UNLIKELY(not get_ubjson_value(size_and_type.second)))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+            else
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_UNLIKELY(not get_ubjson_string(key) or not sax->key(key)))
+                    {
+                        return false;
+                    }
+                    if (JSON_UNLIKELY(not parse_ubjson_internal()))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+        }
+        else
+        {
+            if (JSON_UNLIKELY(not sax->start_object(std::size_t(-1))))
+            {
+                return false;
+            }
+
+            while (current != '}')
+            {
+                if (JSON_UNLIKELY(not get_ubjson_string(key, false) or not sax->key(key)))
+                {
+                    return false;
+                }
+                if (JSON_UNLIKELY(not parse_ubjson_internal()))
+                {
+                    return false;
+                }
+                get_ignore_noop();
+                key.clear();
+            }
+        }
+
+        return sax->end_object();
+    }
+
+    ///////////////////////
+    // Utility functions //
+    ///////////////////////
+
+    /*!
+    @brief get next character from the input
+
+    This function provides the interface to the used input adapter. It does
+    not throw in case the input reached EOF, but returns a -'ve valued
+    `std::char_traits<char>::eof()` in that case.
+
+    @return character read from the input
+    */
+    int get()
+    {
+        ++chars_read;
+        return (current = ia->get_character());
+    }
+
+    /*!
+    @return character read from the input after ignoring all 'N' entries
+    */
+    int get_ignore_noop()
+    {
+        do
+        {
+            get();
+        }
+        while (current == 'N');
+
+        return current;
+    }
+
+    /*
+    @brief read a number from the input
+
+    @tparam NumberType the type of the number
+    @param[in] format   the current format (for diagnostics)
+    @param[out] result  number of type @a NumberType
+
+    @return whether conversion completed
+
+    @note This function needs to respect the system's endianess, because
+          bytes in CBOR, MessagePack, and UBJSON are stored in network order
+          (big endian) and therefore need reordering on little endian systems.
+    */
+    template<typename NumberType, bool InputIsLittleEndian = false>
+    bool get_number(const input_format_t format, NumberType& result)
+    {
+        // step 1: read input into array with system's byte order
+        std::array<uint8_t, sizeof(NumberType)> vec;
+        for (std::size_t i = 0; i < sizeof(NumberType); ++i)
+        {
+            get();
+            if (JSON_UNLIKELY(not unexpect_eof(format, "number")))
+            {
+                return false;
+            }
+
+            // reverse byte order prior to conversion if necessary
+            if (is_little_endian && !InputIsLittleEndian)
+            {
+                vec[sizeof(NumberType) - i - 1] = static_cast<uint8_t>(current);
+            }
+            else
+            {
+                vec[i] = static_cast<uint8_t>(current); // LCOV_EXCL_LINE
+            }
+        }
+
+        // step 2: convert array into number of type T and return
+        std::memcpy(&result, vec.data(), sizeof(NumberType));
+        return true;
+    }
+
+    /*!
+    @brief create a string by reading characters from the input
+
+    @tparam NumberType the type of the number
+    @param[in] format the current format (for diagnostics)
+    @param[in] len number of characters to read
+    @param[out] result string created by reading @a len bytes
+
+    @return whether string creation completed
+
+    @note We can not reserve @a len bytes for the result, because @a len
+          may be too large. Usually, @ref unexpect_eof() detects the end of
+          the input before we run out of string memory.
+    */
+    template<typename NumberType>
+    bool get_string(const input_format_t format,
+                    const NumberType len,
+                    string_t& result)
+    {
+        bool success = true;
+        std::generate_n(std::back_inserter(result), len, [this, &success, &format]()
+        {
+            get();
+            if (JSON_UNLIKELY(not unexpect_eof(format, "string")))
+            {
+                success = false;
+            }
+            return static_cast<char>(current);
+        });
+        return success;
+    }
+
+    /*!
+    @param[in] format   the current format (for diagnostics)
+    @param[in] context  further context information (for diagnostics)
+    @return whether the last read character is not EOF
+    */
+    bool unexpect_eof(const input_format_t format, const char* context) const
+    {
+        if (JSON_UNLIKELY(current == std::char_traits<char>::eof()))
+        {
+            return sax->parse_error(chars_read, "<end of file>",
+                                    parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context)));
+        }
+        return true;
+    }
+
+    /*!
+    @return a string representation of the last read byte
+    */
+    std::string get_token_string() const
+    {
+        char cr[3];
+        (std::snprintf)(cr, 3, "%.2hhX", static_cast<unsigned char>(current));
+        return std::string{cr};
+    }
+
+    /*!
+    @param[in] format   the current format
+    @param[in] detail   a detailed error message
+    @param[in] context  further contect information
+    @return a message string to use in the parse_error exceptions
+    */
+    std::string exception_message(const input_format_t format,
+                                  const std::string& detail,
+                                  const std::string& context) const
+    {
+        std::string error_msg = "syntax error while parsing ";
+
+        switch (format)
+        {
+            case input_format_t::cbor:
+                error_msg += "CBOR";
+                break;
+
+            case input_format_t::msgpack:
+                error_msg += "MessagePack";
+                break;
+
+            case input_format_t::ubjson:
+                error_msg += "UBJSON";
+                break;
+
+            case input_format_t::bson:
+                error_msg += "BSON";
+                break;
+
+            // LCOV_EXCL_START
+            default:
+                assert(false);
+                // LCOV_EXCL_STOP
+        }
+
+        return error_msg + " " + context + ": " + detail;
+    }
+
+  private:
+    /// input adapter
+    input_adapter_t ia = nullptr;
+
+    /// the current character
+    int current = std::char_traits<char>::eof();
+
+    /// the number of characters read
+    std::size_t chars_read = 0;
+
+    /// whether we can assume little endianess
+    const bool is_little_endian = little_endianess();
+
+    /// the SAX parser
+    json_sax_t* sax = nullptr;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/output/binary_writer.hpp>
+
+
+#include <algorithm> // reverse
+#include <array> // array
+#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
+#include <cstring> // memcpy
+#include <limits> // numeric_limits
+
+// #include <nlohmann/detail/input/binary_reader.hpp>
+
+// #include <nlohmann/detail/output/output_adapters.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+///////////////////
+// binary writer //
+///////////////////
+
+/*!
+@brief serialization to CBOR and MessagePack values
+*/
+template<typename BasicJsonType, typename CharType>
+class binary_writer
+{
+    using string_t = typename BasicJsonType::string_t;
+
+  public:
+    /*!
+    @brief create a binary writer
+
+    @param[in] adapter  output adapter to write to
+    */
+    explicit binary_writer(output_adapter_t<CharType> adapter) : oa(adapter)
+    {
+        assert(oa);
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    @pre       j.type() == value_t::object
+    */
+    void write_bson(const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::object:
+            {
+                write_bson_object(*j.m_value.object);
+                break;
+            }
+
+            default:
+            {
+                JSON_THROW(type_error::create(317, "to serialize to BSON, top-level type must be object, but is " + std::string(j.type_name())));
+            }
+        }
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    */
+    void write_cbor(const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::null:
+            {
+                oa->write_character(to_char_type(0xF6));
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                oa->write_character(j.m_value.boolean
+                                    ? to_char_type(0xF5)
+                                    : to_char_type(0xF4));
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                if (j.m_value.number_integer >= 0)
+                {
+                    // CBOR does not differentiate between positive signed
+                    // integers and unsigned integers. Therefore, we used the
+                    // code from the value_t::number_unsigned case here.
+                    if (j.m_value.number_integer <= 0x17)
+                    {
+                        write_number(static_cast<uint8_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer <= (std::numeric_limits<uint8_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x18));
+                        write_number(static_cast<uint8_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer <= (std::numeric_limits<uint16_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x19));
+                        write_number(static_cast<uint16_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer <= (std::numeric_limits<uint32_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x1A));
+                        write_number(static_cast<uint32_t>(j.m_value.number_integer));
+                    }
+                    else
+                    {
+                        oa->write_character(to_char_type(0x1B));
+                        write_number(static_cast<uint64_t>(j.m_value.number_integer));
+                    }
+                }
+                else
+                {
+                    // The conversions below encode the sign in the first
+                    // byte, and the value is converted to a positive number.
+                    const auto positive_number = -1 - j.m_value.number_integer;
+                    if (j.m_value.number_integer >= -24)
+                    {
+                        write_number(static_cast<uint8_t>(0x20 + positive_number));
+                    }
+                    else if (positive_number <= (std::numeric_limits<uint8_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x38));
+                        write_number(static_cast<uint8_t>(positive_number));
+                    }
+                    else if (positive_number <= (std::numeric_limits<uint16_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x39));
+                        write_number(static_cast<uint16_t>(positive_number));
+                    }
+                    else if (positive_number <= (std::numeric_limits<uint32_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x3A));
+                        write_number(static_cast<uint32_t>(positive_number));
+                    }
+                    else
+                    {
+                        oa->write_character(to_char_type(0x3B));
+                        write_number(static_cast<uint64_t>(positive_number));
+                    }
+                }
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                if (j.m_value.number_unsigned <= 0x17)
+                {
+                    write_number(static_cast<uint8_t>(j.m_value.number_unsigned));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x18));
+                    write_number(static_cast<uint8_t>(j.m_value.number_unsigned));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x19));
+                    write_number(static_cast<uint16_t>(j.m_value.number_unsigned));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x1A));
+                    write_number(static_cast<uint32_t>(j.m_value.number_unsigned));
+                }
+                else
+                {
+                    oa->write_character(to_char_type(0x1B));
+                    write_number(static_cast<uint64_t>(j.m_value.number_unsigned));
+                }
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                oa->write_character(get_cbor_float_prefix(j.m_value.number_float));
+                write_number(j.m_value.number_float);
+                break;
+            }
+
+            case value_t::string:
+            {
+                // step 1: write control byte and the string length
+                const auto N = j.m_value.string->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<uint8_t>(0x60 + N));
+                }
+                else if (N <= (std::numeric_limits<uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x78));
+                    write_number(static_cast<uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x79));
+                    write_number(static_cast<uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x7A));
+                    write_number(static_cast<uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x7B));
+                    write_number(static_cast<uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write the string
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
+                    j.m_value.string->size());
+                break;
+            }
+
+            case value_t::array:
+            {
+                // step 1: write control byte and the array size
+                const auto N = j.m_value.array->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<uint8_t>(0x80 + N));
+                }
+                else if (N <= (std::numeric_limits<uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x98));
+                    write_number(static_cast<uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x99));
+                    write_number(static_cast<uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x9A));
+                    write_number(static_cast<uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x9B));
+                    write_number(static_cast<uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write each element
+                for (const auto& el : *j.m_value.array)
+                {
+                    write_cbor(el);
+                }
+                break;
+            }
+
+            case value_t::object:
+            {
+                // step 1: write control byte and the object size
+                const auto N = j.m_value.object->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<uint8_t>(0xA0 + N));
+                }
+                else if (N <= (std::numeric_limits<uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xB8));
+                    write_number(static_cast<uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xB9));
+                    write_number(static_cast<uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xBA));
+                    write_number(static_cast<uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xBB));
+                    write_number(static_cast<uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write each element
+                for (const auto& el : *j.m_value.object)
+                {
+                    write_cbor(el.first);
+                    write_cbor(el.second);
+                }
+                break;
+            }
+
+            default:
+                break;
+        }
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    */
+    void write_msgpack(const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::null: // nil
+            {
+                oa->write_character(to_char_type(0xC0));
+                break;
+            }
+
+            case value_t::boolean: // true and false
+            {
+                oa->write_character(j.m_value.boolean
+                                    ? to_char_type(0xC3)
+                                    : to_char_type(0xC2));
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                if (j.m_value.number_integer >= 0)
+                {
+                    // MessagePack does not differentiate between positive
+                    // signed integers and unsigned integers. Therefore, we used
+                    // the code from the value_t::number_unsigned case here.
+                    if (j.m_value.number_unsigned < 128)
+                    {
+                        // positive fixnum
+                        write_number(static_cast<uint8_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_unsigned <= (std::numeric_limits<uint8_t>::max)())
+                    {
+                        // uint 8
+                        oa->write_character(to_char_type(0xCC));
+                        write_number(static_cast<uint8_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_unsigned <= (std::numeric_limits<uint16_t>::max)())
+                    {
+                        // uint 16
+                        oa->write_character(to_char_type(0xCD));
+                        write_number(static_cast<uint16_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_unsigned <= (std::numeric_limits<uint32_t>::max)())
+                    {
+                        // uint 32
+                        oa->write_character(to_char_type(0xCE));
+                        write_number(static_cast<uint32_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_unsigned <= (std::numeric_limits<uint64_t>::max)())
+                    {
+                        // uint 64
+                        oa->write_character(to_char_type(0xCF));
+                        write_number(static_cast<uint64_t>(j.m_value.number_integer));
+                    }
+                }
+                else
+                {
+                    if (j.m_value.number_integer >= -32)
+                    {
+                        // negative fixnum
+                        write_number(static_cast<int8_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer >= (std::numeric_limits<int8_t>::min)() and
+                             j.m_value.number_integer <= (std::numeric_limits<int8_t>::max)())
+                    {
+                        // int 8
+                        oa->write_character(to_char_type(0xD0));
+                        write_number(static_cast<int8_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer >= (std::numeric_limits<int16_t>::min)() and
+                             j.m_value.number_integer <= (std::numeric_limits<int16_t>::max)())
+                    {
+                        // int 16
+                        oa->write_character(to_char_type(0xD1));
+                        write_number(static_cast<int16_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer >= (std::numeric_limits<int32_t>::min)() and
+                             j.m_value.number_integer <= (std::numeric_limits<int32_t>::max)())
+                    {
+                        // int 32
+                        oa->write_character(to_char_type(0xD2));
+                        write_number(static_cast<int32_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer >= (std::numeric_limits<int64_t>::min)() and
+                             j.m_value.number_integer <= (std::numeric_limits<int64_t>::max)())
+                    {
+                        // int 64
+                        oa->write_character(to_char_type(0xD3));
+                        write_number(static_cast<int64_t>(j.m_value.number_integer));
+                    }
+                }
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                if (j.m_value.number_unsigned < 128)
+                {
+                    // positive fixnum
+                    write_number(static_cast<uint8_t>(j.m_value.number_integer));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<uint8_t>::max)())
+                {
+                    // uint 8
+                    oa->write_character(to_char_type(0xCC));
+                    write_number(static_cast<uint8_t>(j.m_value.number_integer));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<uint16_t>::max)())
+                {
+                    // uint 16
+                    oa->write_character(to_char_type(0xCD));
+                    write_number(static_cast<uint16_t>(j.m_value.number_integer));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<uint32_t>::max)())
+                {
+                    // uint 32
+                    oa->write_character(to_char_type(0xCE));
+                    write_number(static_cast<uint32_t>(j.m_value.number_integer));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<uint64_t>::max)())
+                {
+                    // uint 64
+                    oa->write_character(to_char_type(0xCF));
+                    write_number(static_cast<uint64_t>(j.m_value.number_integer));
+                }
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                oa->write_character(get_msgpack_float_prefix(j.m_value.number_float));
+                write_number(j.m_value.number_float);
+                break;
+            }
+
+            case value_t::string:
+            {
+                // step 1: write control byte and the string length
+                const auto N = j.m_value.string->size();
+                if (N <= 31)
+                {
+                    // fixstr
+                    write_number(static_cast<uint8_t>(0xA0 | N));
+                }
+                else if (N <= (std::numeric_limits<uint8_t>::max)())
+                {
+                    // str 8
+                    oa->write_character(to_char_type(0xD9));
+                    write_number(static_cast<uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<uint16_t>::max)())
+                {
+                    // str 16
+                    oa->write_character(to_char_type(0xDA));
+                    write_number(static_cast<uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<uint32_t>::max)())
+                {
+                    // str 32
+                    oa->write_character(to_char_type(0xDB));
+                    write_number(static_cast<uint32_t>(N));
+                }
+
+                // step 2: write the string
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
+                    j.m_value.string->size());
+                break;
+            }
+
+            case value_t::array:
+            {
+                // step 1: write control byte and the array size
+                const auto N = j.m_value.array->size();
+                if (N <= 15)
+                {
+                    // fixarray
+                    write_number(static_cast<uint8_t>(0x90 | N));
+                }
+                else if (N <= (std::numeric_limits<uint16_t>::max)())
+                {
+                    // array 16
+                    oa->write_character(to_char_type(0xDC));
+                    write_number(static_cast<uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<uint32_t>::max)())
+                {
+                    // array 32
+                    oa->write_character(to_char_type(0xDD));
+                    write_number(static_cast<uint32_t>(N));
+                }
+
+                // step 2: write each element
+                for (const auto& el : *j.m_value.array)
+                {
+                    write_msgpack(el);
+                }
+                break;
+            }
+
+            case value_t::object:
+            {
+                // step 1: write control byte and the object size
+                const auto N = j.m_value.object->size();
+                if (N <= 15)
+                {
+                    // fixmap
+                    write_number(static_cast<uint8_t>(0x80 | (N & 0xF)));
+                }
+                else if (N <= (std::numeric_limits<uint16_t>::max)())
+                {
+                    // map 16
+                    oa->write_character(to_char_type(0xDE));
+                    write_number(static_cast<uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<uint32_t>::max)())
+                {
+                    // map 32
+                    oa->write_character(to_char_type(0xDF));
+                    write_number(static_cast<uint32_t>(N));
+                }
+
+                // step 2: write each element
+                for (const auto& el : *j.m_value.object)
+                {
+                    write_msgpack(el.first);
+                    write_msgpack(el.second);
+                }
+                break;
+            }
+
+            default:
+                break;
+        }
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    @param[in] use_count   whether to use '#' prefixes (optimized format)
+    @param[in] use_type    whether to use '$' prefixes (optimized format)
+    @param[in] add_prefix  whether prefixes need to be used for this value
+    */
+    void write_ubjson(const BasicJsonType& j, const bool use_count,
+                      const bool use_type, const bool add_prefix = true)
+    {
+        switch (j.type())
+        {
+            case value_t::null:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('Z'));
+                }
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(j.m_value.boolean
+                                        ? to_char_type('T')
+                                        : to_char_type('F'));
+                }
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                write_number_with_ubjson_prefix(j.m_value.number_integer, add_prefix);
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                write_number_with_ubjson_prefix(j.m_value.number_unsigned, add_prefix);
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                write_number_with_ubjson_prefix(j.m_value.number_float, add_prefix);
+                break;
+            }
+
+            case value_t::string:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('S'));
+                }
+                write_number_with_ubjson_prefix(j.m_value.string->size(), true);
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
+                    j.m_value.string->size());
+                break;
+            }
+
+            case value_t::array:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('['));
+                }
+
+                bool prefix_required = true;
+                if (use_type and not j.m_value.array->empty())
+                {
+                    assert(use_count);
+                    const CharType first_prefix = ubjson_prefix(j.front());
+                    const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
+                                                         [this, first_prefix](const BasicJsonType & v)
+                    {
+                        return ubjson_prefix(v) == first_prefix;
+                    });
+
+                    if (same_prefix)
+                    {
+                        prefix_required = false;
+                        oa->write_character(to_char_type('$'));
+                        oa->write_character(first_prefix);
+                    }
+                }
+
+                if (use_count)
+                {
+                    oa->write_character(to_char_type('#'));
+                    write_number_with_ubjson_prefix(j.m_value.array->size(), true);
+                }
+
+                for (const auto& el : *j.m_value.array)
+                {
+                    write_ubjson(el, use_count, use_type, prefix_required);
+                }
+
+                if (not use_count)
+                {
+                    oa->write_character(to_char_type(']'));
+                }
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('{'));
+                }
+
+                bool prefix_required = true;
+                if (use_type and not j.m_value.object->empty())
+                {
+                    assert(use_count);
+                    const CharType first_prefix = ubjson_prefix(j.front());
+                    const bool same_prefix = std::all_of(j.begin(), j.end(),
+                                                         [this, first_prefix](const BasicJsonType & v)
+                    {
+                        return ubjson_prefix(v) == first_prefix;
+                    });
+
+                    if (same_prefix)
+                    {
+                        prefix_required = false;
+                        oa->write_character(to_char_type('$'));
+                        oa->write_character(first_prefix);
+                    }
+                }
+
+                if (use_count)
+                {
+                    oa->write_character(to_char_type('#'));
+                    write_number_with_ubjson_prefix(j.m_value.object->size(), true);
+                }
+
+                for (const auto& el : *j.m_value.object)
+                {
+                    write_number_with_ubjson_prefix(el.first.size(), true);
+                    oa->write_characters(
+                        reinterpret_cast<const CharType*>(el.first.c_str()),
+                        el.first.size());
+                    write_ubjson(el.second, use_count, use_type, prefix_required);
+                }
+
+                if (not use_count)
+                {
+                    oa->write_character(to_char_type('}'));
+                }
+
+                break;
+            }
+
+            default:
+                break;
+        }
+    }
+
+  private:
+    //////////
+    // BSON //
+    //////////
+
+    /*!
+    @return The size of a BSON document entry header, including the id marker
+            and the entry name size (and its null-terminator).
+    */
+    static std::size_t calc_bson_entry_header_size(const string_t& name)
+    {
+        const auto it = name.find(static_cast<typename string_t::value_type>(0));
+        if (JSON_UNLIKELY(it != BasicJsonType::string_t::npos))
+        {
+            JSON_THROW(out_of_range::create(409,
+                                            "BSON key cannot contain code point U+0000 (at byte " + std::to_string(it) + ")"));
+        }
+
+        return /*id*/ 1ul + name.size() + /*zero-terminator*/1u;
+    }
+
+    /*!
+    @brief Writes the given @a element_type and @a name to the output adapter
+    */
+    void write_bson_entry_header(const string_t& name,
+                                 const std::uint8_t element_type)
+    {
+        oa->write_character(to_char_type(element_type)); // boolean
+        oa->write_characters(
+            reinterpret_cast<const CharType*>(name.c_str()),
+            name.size() + 1u);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and boolean value @a value
+    */
+    void write_bson_boolean(const string_t& name,
+                            const bool value)
+    {
+        write_bson_entry_header(name, 0x08);
+        oa->write_character(value ? to_char_type(0x01) : to_char_type(0x00));
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and double value @a value
+    */
+    void write_bson_double(const string_t& name,
+                           const double value)
+    {
+        write_bson_entry_header(name, 0x01);
+        write_number<double, true>(value);
+    }
+
+    /*!
+    @return The size of the BSON-encoded string in @a value
+    */
+    static std::size_t calc_bson_string_size(const string_t& value)
+    {
+        return sizeof(std::int32_t) + value.size() + 1ul;
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and string value @a value
+    */
+    void write_bson_string(const string_t& name,
+                           const string_t& value)
+    {
+        write_bson_entry_header(name, 0x02);
+
+        write_number<std::int32_t, true>(static_cast<std::int32_t>(value.size() + 1ul));
+        oa->write_characters(
+            reinterpret_cast<const CharType*>(value.c_str()),
+            value.size() + 1);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and null value
+    */
+    void write_bson_null(const string_t& name)
+    {
+        write_bson_entry_header(name, 0x0A);
+    }
+
+    /*!
+    @return The size of the BSON-encoded integer @a value
+    */
+    static std::size_t calc_bson_integer_size(const std::int64_t value)
+    {
+        if ((std::numeric_limits<std::int32_t>::min)() <= value and value <= (std::numeric_limits<std::int32_t>::max)())
+        {
+            return sizeof(std::int32_t);
+        }
+        else
+        {
+            return sizeof(std::int64_t);
+        }
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and integer @a value
+    */
+    void write_bson_integer(const string_t& name,
+                            const std::int64_t value)
+    {
+        if ((std::numeric_limits<std::int32_t>::min)() <= value and value <= (std::numeric_limits<std::int32_t>::max)())
+        {
+            write_bson_entry_header(name, 0x10); // int32
+            write_number<std::int32_t, true>(static_cast<std::int32_t>(value));
+        }
+        else
+        {
+            write_bson_entry_header(name, 0x12); // int64
+            write_number<std::int64_t, true>(static_cast<std::int64_t>(value));
+        }
+    }
+
+    /*!
+    @return The size of the BSON-encoded unsigned integer in @a j
+    */
+    static constexpr std::size_t calc_bson_unsigned_size(const std::uint64_t value) noexcept
+    {
+        return (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+               ? sizeof(std::int32_t)
+               : sizeof(std::int64_t);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and unsigned @a value
+    */
+    void write_bson_unsigned(const string_t& name,
+                             const std::uint64_t value)
+    {
+        if (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+        {
+            write_bson_entry_header(name, 0x10 /* int32 */);
+            write_number<std::int32_t, true>(static_cast<std::int32_t>(value));
+        }
+        else if (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+        {
+            write_bson_entry_header(name, 0x12 /* int64 */);
+            write_number<std::int64_t, true>(static_cast<std::int64_t>(value));
+        }
+        else
+        {
+            JSON_THROW(out_of_range::create(407, "integer number " + std::to_string(value) + " cannot be represented by BSON as it does not fit int64"));
+        }
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and object @a value
+    */
+    void write_bson_object_entry(const string_t& name,
+                                 const typename BasicJsonType::object_t& value)
+    {
+        write_bson_entry_header(name, 0x03); // object
+        write_bson_object(value);
+    }
+
+    /*!
+    @return The size of the BSON-encoded array @a value
+    */
+    static std::size_t calc_bson_array_size(const typename BasicJsonType::array_t& value)
+    {
+        std::size_t embedded_document_size = 0ul;
+        std::size_t array_index = 0ul;
+
+        for (const auto& el : value)
+        {
+            embedded_document_size += calc_bson_element_size(std::to_string(array_index++), el);
+        }
+
+        return sizeof(std::int32_t) + embedded_document_size + 1ul;
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and array @a value
+    */
+    void write_bson_array(const string_t& name,
+                          const typename BasicJsonType::array_t& value)
+    {
+        write_bson_entry_header(name, 0x04); // array
+        write_number<std::int32_t, true>(static_cast<std::int32_t>(calc_bson_array_size(value)));
+
+        std::size_t array_index = 0ul;
+
+        for (const auto& el : value)
+        {
+            write_bson_element(std::to_string(array_index++), el);
+        }
+
+        oa->write_character(to_char_type(0x00));
+    }
+
+    /*!
+    @brief Calculates the size necessary to serialize the JSON value @a j with its @a name
+    @return The calculated size for the BSON document entry for @a j with the given @a name.
+    */
+    static std::size_t calc_bson_element_size(const string_t& name,
+            const BasicJsonType& j)
+    {
+        const auto header_size = calc_bson_entry_header_size(name);
+        switch (j.type())
+        {
+            case value_t::object:
+                return header_size + calc_bson_object_size(*j.m_value.object);
+
+            case value_t::array:
+                return header_size + calc_bson_array_size(*j.m_value.array);
+
+            case value_t::boolean:
+                return header_size + 1ul;
+
+            case value_t::number_float:
+                return header_size + 8ul;
+
+            case value_t::number_integer:
+                return header_size + calc_bson_integer_size(j.m_value.number_integer);
+
+            case value_t::number_unsigned:
+                return header_size + calc_bson_unsigned_size(j.m_value.number_unsigned);
+
+            case value_t::string:
+                return header_size + calc_bson_string_size(*j.m_value.string);
+
+            case value_t::null:
+                return header_size + 0ul;
+
+            // LCOV_EXCL_START
+            default:
+                assert(false);
+                return 0ul;
+                // LCOV_EXCL_STOP
+        };
+    }
+
+    /*!
+    @brief Serializes the JSON value @a j to BSON and associates it with the
+           key @a name.
+    @param name The name to associate with the JSON entity @a j within the
+                current BSON document
+    @return The size of the BSON entry
+    */
+    void write_bson_element(const string_t& name,
+                            const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::object:
+                return write_bson_object_entry(name, *j.m_value.object);
+
+            case value_t::array:
+                return write_bson_array(name, *j.m_value.array);
+
+            case value_t::boolean:
+                return write_bson_boolean(name, j.m_value.boolean);
+
+            case value_t::number_float:
+                return write_bson_double(name, j.m_value.number_float);
+
+            case value_t::number_integer:
+                return write_bson_integer(name, j.m_value.number_integer);
+
+            case value_t::number_unsigned:
+                return write_bson_unsigned(name, j.m_value.number_unsigned);
+
+            case value_t::string:
+                return write_bson_string(name, *j.m_value.string);
+
+            case value_t::null:
+                return write_bson_null(name);
+
+            // LCOV_EXCL_START
+            default:
+                assert(false);
+                return;
+                // LCOV_EXCL_STOP
+        };
+    }
+
+    /*!
+    @brief Calculates the size of the BSON serialization of the given
+           JSON-object @a j.
+    @param[in] j  JSON value to serialize
+    @pre       j.type() == value_t::object
+    */
+    static std::size_t calc_bson_object_size(const typename BasicJsonType::object_t& value)
+    {
+        std::size_t document_size = std::accumulate(value.begin(), value.end(), 0ul,
+                                    [](size_t result, const typename BasicJsonType::object_t::value_type & el)
+        {
+            return result += calc_bson_element_size(el.first, el.second);
+        });
+
+        return sizeof(std::int32_t) + document_size + 1ul;
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    @pre       j.type() == value_t::object
+    */
+    void write_bson_object(const typename BasicJsonType::object_t& value)
+    {
+        write_number<std::int32_t, true>(static_cast<std::int32_t>(calc_bson_object_size(value)));
+
+        for (const auto& el : value)
+        {
+            write_bson_element(el.first, el.second);
+        }
+
+        oa->write_character(to_char_type(0x00));
+    }
+
+    //////////
+    // CBOR //
+    //////////
+
+    static constexpr CharType get_cbor_float_prefix(float /*unused*/)
+    {
+        return to_char_type(0xFA);  // Single-Precision Float
+    }
+
+    static constexpr CharType get_cbor_float_prefix(double /*unused*/)
+    {
+        return to_char_type(0xFB);  // Double-Precision Float
+    }
+
+    /////////////
+    // MsgPack //
+    /////////////
+
+    static constexpr CharType get_msgpack_float_prefix(float /*unused*/)
+    {
+        return to_char_type(0xCA);  // float 32
+    }
+
+    static constexpr CharType get_msgpack_float_prefix(double /*unused*/)
+    {
+        return to_char_type(0xCB);  // float 64
+    }
+
+    ////////////
+    // UBJSON //
+    ////////////
+
+    // UBJSON: write number (floating point)
+    template<typename NumberType, typename std::enable_if<
+                 std::is_floating_point<NumberType>::value, int>::type = 0>
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix)
+    {
+        if (add_prefix)
+        {
+            oa->write_character(get_ubjson_float_prefix(n));
+        }
+        write_number(n);
+    }
+
+    // UBJSON: write number (unsigned integer)
+    template<typename NumberType, typename std::enable_if<
+                 std::is_unsigned<NumberType>::value, int>::type = 0>
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix)
+    {
+        if (n <= static_cast<uint64_t>((std::numeric_limits<int8_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('i'));  // int8
+            }
+            write_number(static_cast<uint8_t>(n));
+        }
+        else if (n <= (std::numeric_limits<uint8_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('U'));  // uint8
+            }
+            write_number(static_cast<uint8_t>(n));
+        }
+        else if (n <= static_cast<uint64_t>((std::numeric_limits<int16_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('I'));  // int16
+            }
+            write_number(static_cast<int16_t>(n));
+        }
+        else if (n <= static_cast<uint64_t>((std::numeric_limits<int32_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('l'));  // int32
+            }
+            write_number(static_cast<int32_t>(n));
+        }
+        else if (n <= static_cast<uint64_t>((std::numeric_limits<int64_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('L'));  // int64
+            }
+            write_number(static_cast<int64_t>(n));
+        }
+        else
+        {
+            JSON_THROW(out_of_range::create(407, "integer number " + std::to_string(n) + " cannot be represented by UBJSON as it does not fit int64"));
+        }
+    }
+
+    // UBJSON: write number (signed integer)
+    template<typename NumberType, typename std::enable_if<
+                 std::is_signed<NumberType>::value and
+                 not std::is_floating_point<NumberType>::value, int>::type = 0>
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix)
+    {
+        if ((std::numeric_limits<int8_t>::min)() <= n and n <= (std::numeric_limits<int8_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('i'));  // int8
+            }
+            write_number(static_cast<int8_t>(n));
+        }
+        else if (static_cast<int64_t>((std::numeric_limits<uint8_t>::min)()) <= n and n <= static_cast<int64_t>((std::numeric_limits<uint8_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('U'));  // uint8
+            }
+            write_number(static_cast<uint8_t>(n));
+        }
+        else if ((std::numeric_limits<int16_t>::min)() <= n and n <= (std::numeric_limits<int16_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('I'));  // int16
+            }
+            write_number(static_cast<int16_t>(n));
+        }
+        else if ((std::numeric_limits<int32_t>::min)() <= n and n <= (std::numeric_limits<int32_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('l'));  // int32
+            }
+            write_number(static_cast<int32_t>(n));
+        }
+        else if ((std::numeric_limits<int64_t>::min)() <= n and n <= (std::numeric_limits<int64_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('L'));  // int64
+            }
+            write_number(static_cast<int64_t>(n));
+        }
+        // LCOV_EXCL_START
+        else
+        {
+            JSON_THROW(out_of_range::create(407, "integer number " + std::to_string(n) + " cannot be represented by UBJSON as it does not fit int64"));
+        }
+        // LCOV_EXCL_STOP
+    }
+
+    /*!
+    @brief determine the type prefix of container values
+
+    @note This function does not need to be 100% accurate when it comes to
+          integer limits. In case a number exceeds the limits of int64_t,
+          this will be detected by a later call to function
+          write_number_with_ubjson_prefix. Therefore, we return 'L' for any
+          value that does not fit the previous limits.
+    */
+    CharType ubjson_prefix(const BasicJsonType& j) const noexcept
+    {
+        switch (j.type())
+        {
+            case value_t::null:
+                return 'Z';
+
+            case value_t::boolean:
+                return j.m_value.boolean ? 'T' : 'F';
+
+            case value_t::number_integer:
+            {
+                if ((std::numeric_limits<int8_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<int8_t>::max)())
+                {
+                    return 'i';
+                }
+                if ((std::numeric_limits<uint8_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<uint8_t>::max)())
+                {
+                    return 'U';
+                }
+                if ((std::numeric_limits<int16_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<int16_t>::max)())
+                {
+                    return 'I';
+                }
+                if ((std::numeric_limits<int32_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<int32_t>::max)())
+                {
+                    return 'l';
+                }
+                // no check and assume int64_t (see note above)
+                return 'L';
+            }
+
+            case value_t::number_unsigned:
+            {
+                if (j.m_value.number_unsigned <= (std::numeric_limits<int8_t>::max)())
+                {
+                    return 'i';
+                }
+                if (j.m_value.number_unsigned <= (std::numeric_limits<uint8_t>::max)())
+                {
+                    return 'U';
+                }
+                if (j.m_value.number_unsigned <= (std::numeric_limits<int16_t>::max)())
+                {
+                    return 'I';
+                }
+                if (j.m_value.number_unsigned <= (std::numeric_limits<int32_t>::max)())
+                {
+                    return 'l';
+                }
+                // no check and assume int64_t (see note above)
+                return 'L';
+            }
+
+            case value_t::number_float:
+                return get_ubjson_float_prefix(j.m_value.number_float);
+
+            case value_t::string:
+                return 'S';
+
+            case value_t::array:
+                return '[';
+
+            case value_t::object:
+                return '{';
+
+            default:  // discarded values
+                return 'N';
+        }
+    }
+
+    static constexpr CharType get_ubjson_float_prefix(float /*unused*/)
+    {
+        return 'd';  // float 32
+    }
+
+    static constexpr CharType get_ubjson_float_prefix(double /*unused*/)
+    {
+        return 'D';  // float 64
+    }
+
+    ///////////////////////
+    // Utility functions //
+    ///////////////////////
+
+    /*
+    @brief write a number to output input
+    @param[in] n number of type @a NumberType
+    @tparam NumberType the type of the number
+    @tparam OutputIsLittleEndian Set to true if output data is
+                                 required to be little endian
+
+    @note This function needs to respect the system's endianess, because bytes
+          in CBOR, MessagePack, and UBJSON are stored in network order (big
+          endian) and therefore need reordering on little endian systems.
+    */
+    template<typename NumberType, bool OutputIsLittleEndian = false>
+    void write_number(const NumberType n)
+    {
+        // step 1: write number to array of length NumberType
+        std::array<CharType, sizeof(NumberType)> vec;
+        std::memcpy(vec.data(), &n, sizeof(NumberType));
+
+        // step 2: write array to output (with possible reordering)
+        if (is_little_endian and not OutputIsLittleEndian)
+        {
+            // reverse byte order prior to conversion if necessary
+            std::reverse(vec.begin(), vec.end());
+        }
+
+        oa->write_characters(vec.data(), sizeof(NumberType));
+    }
+
+  public:
+    // The following to_char_type functions are implement the conversion
+    // between uint8_t and CharType. In case CharType is not unsigned,
+    // such a conversion is required to allow values greater than 128.
+    // See <https://github.com/nlohmann/json/issues/1286> for a discussion.
+    template < typename C = CharType,
+               enable_if_t < std::is_signed<C>::value and std::is_signed<char>::value > * = nullptr >
+    static constexpr CharType to_char_type(std::uint8_t x) noexcept
+    {
+        return *reinterpret_cast<char*>(&x);
+    }
+
+    template < typename C = CharType,
+               enable_if_t < std::is_signed<C>::value and std::is_unsigned<char>::value > * = nullptr >
+    static CharType to_char_type(std::uint8_t x) noexcept
+    {
+        static_assert(sizeof(std::uint8_t) == sizeof(CharType), "size of CharType must be equal to std::uint8_t");
+        static_assert(std::is_pod<CharType>::value, "CharType must be POD");
+        CharType result;
+        std::memcpy(&result, &x, sizeof(x));
+        return result;
+    }
+
+    template<typename C = CharType,
+             enable_if_t<std::is_unsigned<C>::value>* = nullptr>
+    static constexpr CharType to_char_type(std::uint8_t x) noexcept
+    {
+        return x;
+    }
+
+    template < typename InputCharType, typename C = CharType,
+               enable_if_t <
+                   std::is_signed<C>::value and
+                   std::is_signed<char>::value and
+                   std::is_same<char, typename std::remove_cv<InputCharType>::type>::value
+                   > * = nullptr >
+    static constexpr CharType to_char_type(InputCharType x) noexcept
+    {
+        return x;
+    }
+
+  private:
+    /// whether we can assume little endianess
+    const bool is_little_endian = binary_reader<BasicJsonType>::little_endianess();
+
+    /// the output
+    output_adapter_t<CharType> oa = nullptr;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/output/serializer.hpp>
+
+
+#include <algorithm> // reverse, remove, fill, find, none_of
+#include <array> // array
+#include <cassert> // assert
+#include <ciso646> // and, or
+#include <clocale> // localeconv, lconv
+#include <cmath> // labs, isfinite, isnan, signbit
+#include <cstddef> // size_t, ptrdiff_t
+#include <cstdint> // uint8_t
+#include <cstdio> // snprintf
+#include <limits> // numeric_limits
+#include <string> // string
+#include <type_traits> // is_same
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/conversions/to_chars.hpp>
+
+
+#include <cassert> // assert
+#include <ciso646> // or, and, not
+#include <cmath>   // signbit, isfinite
+#include <cstdint> // intN_t, uintN_t
+#include <cstring> // memcpy, memmove
+
+namespace nlohmann
+{
+namespace detail
+{
+
+/*!
+@brief implements the Grisu2 algorithm for binary to decimal floating-point
+conversion.
+
+This implementation is a slightly modified version of the reference
+implementation which may be obtained from
+http://florian.loitsch.com/publications (bench.tar.gz).
+
+The code is distributed under the MIT license, Copyright (c) 2009 Florian Loitsch.
+
+For a detailed description of the algorithm see:
+
+[1] Loitsch, "Printing Floating-Point Numbers Quickly and Accurately with
+    Integers", Proceedings of the ACM SIGPLAN 2010 Conference on Programming
+    Language Design and Implementation, PLDI 2010
+[2] Burger, Dybvig, "Printing Floating-Point Numbers Quickly and Accurately",
+    Proceedings of the ACM SIGPLAN 1996 Conference on Programming Language
+    Design and Implementation, PLDI 1996
+*/
+namespace dtoa_impl
+{
+
+template <typename Target, typename Source>
+Target reinterpret_bits(const Source source)
+{
+    static_assert(sizeof(Target) == sizeof(Source), "size mismatch");
+
+    Target target;
+    std::memcpy(&target, &source, sizeof(Source));
+    return target;
+}
+
+struct diyfp // f * 2^e
+{
+    static constexpr int kPrecision = 64; // = q
+
+    uint64_t f = 0;
+    int e = 0;
+
+    constexpr diyfp(uint64_t f_, int e_) noexcept : f(f_), e(e_) {}
+
+    /*!
+    @brief returns x - y
+    @pre x.e == y.e and x.f >= y.f
+    */
+    static diyfp sub(const diyfp& x, const diyfp& y) noexcept
+    {
+        assert(x.e == y.e);
+        assert(x.f >= y.f);
+
+        return {x.f - y.f, x.e};
+    }
+
+    /*!
+    @brief returns x * y
+    @note The result is rounded. (Only the upper q bits are returned.)
+    */
+    static diyfp mul(const diyfp& x, const diyfp& y) noexcept
+    {
+        static_assert(kPrecision == 64, "internal error");
+
+        // Computes:
+        //  f = round((x.f * y.f) / 2^q)
+        //  e = x.e + y.e + q
+
+        // Emulate the 64-bit * 64-bit multiplication:
+        //
+        // p = u * v
+        //   = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi)
+        //   = (u_lo v_lo         ) + 2^32 ((u_lo v_hi         ) + (u_hi v_lo         )) + 2^64 (u_hi v_hi         )
+        //   = (p0                ) + 2^32 ((p1                ) + (p2                )) + 2^64 (p3                )
+        //   = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3                )
+        //   = (p0_lo             ) + 2^32 (p0_hi + p1_lo + p2_lo                      ) + 2^64 (p1_hi + p2_hi + p3)
+        //   = (p0_lo             ) + 2^32 (Q                                          ) + 2^64 (H                 )
+        //   = (p0_lo             ) + 2^32 (Q_lo + 2^32 Q_hi                           ) + 2^64 (H                 )
+        //
+        // (Since Q might be larger than 2^32 - 1)
+        //
+        //   = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H)
+        //
+        // (Q_hi + H does not overflow a 64-bit int)
+        //
+        //   = p_lo + 2^64 p_hi
+
+        const uint64_t u_lo = x.f & 0xFFFFFFFF;
+        const uint64_t u_hi = x.f >> 32;
+        const uint64_t v_lo = y.f & 0xFFFFFFFF;
+        const uint64_t v_hi = y.f >> 32;
+
+        const uint64_t p0 = u_lo * v_lo;
+        const uint64_t p1 = u_lo * v_hi;
+        const uint64_t p2 = u_hi * v_lo;
+        const uint64_t p3 = u_hi * v_hi;
+
+        const uint64_t p0_hi = p0 >> 32;
+        const uint64_t p1_lo = p1 & 0xFFFFFFFF;
+        const uint64_t p1_hi = p1 >> 32;
+        const uint64_t p2_lo = p2 & 0xFFFFFFFF;
+        const uint64_t p2_hi = p2 >> 32;
+
+        uint64_t Q = p0_hi + p1_lo + p2_lo;
+
+        // The full product might now be computed as
+        //
+        // p_hi = p3 + p2_hi + p1_hi + (Q >> 32)
+        // p_lo = p0_lo + (Q << 32)
+        //
+        // But in this particular case here, the full p_lo is not required.
+        // Effectively we only need to add the highest bit in p_lo to p_hi (and
+        // Q_hi + 1 does not overflow).
+
+        Q += uint64_t{1} << (64 - 32 - 1); // round, ties up
+
+        const uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32);
+
+        return {h, x.e + y.e + 64};
+    }
+
+    /*!
+    @brief normalize x such that the significand is >= 2^(q-1)
+    @pre x.f != 0
+    */
+    static diyfp normalize(diyfp x) noexcept
+    {
+        assert(x.f != 0);
+
+        while ((x.f >> 63) == 0)
+        {
+            x.f <<= 1;
+            x.e--;
+        }
+
+        return x;
+    }
+
+    /*!
+    @brief normalize x such that the result has the exponent E
+    @pre e >= x.e and the upper e - x.e bits of x.f must be zero.
+    */
+    static diyfp normalize_to(const diyfp& x, const int target_exponent) noexcept
+    {
+        const int delta = x.e - target_exponent;
+
+        assert(delta >= 0);
+        assert(((x.f << delta) >> delta) == x.f);
+
+        return {x.f << delta, target_exponent};
+    }
+};
+
+struct boundaries
+{
+    diyfp w;
+    diyfp minus;
+    diyfp plus;
+};
+
+/*!
+Compute the (normalized) diyfp representing the input number 'value' and its
+boundaries.
+
+@pre value must be finite and positive
+*/
+template <typename FloatType>
+boundaries compute_boundaries(FloatType value)
+{
+    assert(std::isfinite(value));
+    assert(value > 0);
+
+    // Convert the IEEE representation into a diyfp.
+    //
+    // If v is denormal:
+    //      value = 0.F * 2^(1 - bias) = (          F) * 2^(1 - bias - (p-1))
+    // If v is normalized:
+    //      value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1))
+
+    static_assert(std::numeric_limits<FloatType>::is_iec559,
+                  "internal error: dtoa_short requires an IEEE-754 floating-point implementation");
+
+    constexpr int      kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)
+    constexpr int      kBias      = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
+    constexpr int      kMinExp    = 1 - kBias;
+    constexpr uint64_t kHiddenBit = uint64_t{1} << (kPrecision - 1); // = 2^(p-1)
+
+    using bits_type = typename std::conditional< kPrecision == 24, uint32_t, uint64_t >::type;
+
+    const uint64_t bits = reinterpret_bits<bits_type>(value);
+    const uint64_t E = bits >> (kPrecision - 1);
+    const uint64_t F = bits & (kHiddenBit - 1);
+
+    const bool is_denormal = (E == 0);
+    const diyfp v = is_denormal
+                    ? diyfp(F, kMinExp)
+                    : diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);
+
+    // Compute the boundaries m- and m+ of the floating-point value
+    // v = f * 2^e.
+    //
+    // Determine v- and v+, the floating-point predecessor and successor if v,
+    // respectively.
+    //
+    //      v- = v - 2^e        if f != 2^(p-1) or e == e_min                (A)
+    //         = v - 2^(e-1)    if f == 2^(p-1) and e > e_min                (B)
+    //
+    //      v+ = v + 2^e
+    //
+    // Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_
+    // between m- and m+ round to v, regardless of how the input rounding
+    // algorithm breaks ties.
+    //
+    //      ---+-------------+-------------+-------------+-------------+---  (A)
+    //         v-            m-            v             m+            v+
+    //
+    //      -----------------+------+------+-------------+-------------+---  (B)
+    //                       v-     m-     v             m+            v+
+
+    const bool lower_boundary_is_closer = (F == 0 and E > 1);
+    const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);
+    const diyfp m_minus = lower_boundary_is_closer
+                          ? diyfp(4 * v.f - 1, v.e - 2)  // (B)
+                          : diyfp(2 * v.f - 1, v.e - 1); // (A)
+
+    // Determine the normalized w+ = m+.
+    const diyfp w_plus = diyfp::normalize(m_plus);
+
+    // Determine w- = m- such that e_(w-) = e_(w+).
+    const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);
+
+    return {diyfp::normalize(v), w_minus, w_plus};
+}
+
+// Given normalized diyfp w, Grisu needs to find a (normalized) cached
+// power-of-ten c, such that the exponent of the product c * w = f * 2^e lies
+// within a certain range [alpha, gamma] (Definition 3.2 from [1])
+//
+//      alpha <= e = e_c + e_w + q <= gamma
+//
+// or
+//
+//      f_c * f_w * 2^alpha <= f_c 2^(e_c) * f_w 2^(e_w) * 2^q
+//                          <= f_c * f_w * 2^gamma
+//
+// Since c and w are normalized, i.e. 2^(q-1) <= f < 2^q, this implies
+//
+//      2^(q-1) * 2^(q-1) * 2^alpha <= c * w * 2^q < 2^q * 2^q * 2^gamma
+//
+// or
+//
+//      2^(q - 2 + alpha) <= c * w < 2^(q + gamma)
+//
+// The choice of (alpha,gamma) determines the size of the table and the form of
+// the digit generation procedure. Using (alpha,gamma)=(-60,-32) works out well
+// in practice:
+//
+// The idea is to cut the number c * w = f * 2^e into two parts, which can be
+// processed independently: An integral part p1, and a fractional part p2:
+//
+//      f * 2^e = ( (f div 2^-e) * 2^-e + (f mod 2^-e) ) * 2^e
+//              = (f div 2^-e) + (f mod 2^-e) * 2^e
+//              = p1 + p2 * 2^e
+//
+// The conversion of p1 into decimal form requires a series of divisions and
+// modulos by (a power of) 10. These operations are faster for 32-bit than for
+// 64-bit integers, so p1 should ideally fit into a 32-bit integer. This can be
+// achieved by choosing
+//
+//      -e >= 32   or   e <= -32 := gamma
+//
+// In order to convert the fractional part
+//
+//      p2 * 2^e = p2 / 2^-e = d[-1] / 10^1 + d[-2] / 10^2 + ...
+//
+// into decimal form, the fraction is repeatedly multiplied by 10 and the digits
+// d[-i] are extracted in order:
+//
+//      (10 * p2) div 2^-e = d[-1]
+//      (10 * p2) mod 2^-e = d[-2] / 10^1 + ...
+//
+// The multiplication by 10 must not overflow. It is sufficient to choose
+//
+//      10 * p2 < 16 * p2 = 2^4 * p2 <= 2^64.
+//
+// Since p2 = f mod 2^-e < 2^-e,
+//
+//      -e <= 60   or   e >= -60 := alpha
+
+constexpr int kAlpha = -60;
+constexpr int kGamma = -32;
+
+struct cached_power // c = f * 2^e ~= 10^k
+{
+    uint64_t f;
+    int e;
+    int k;
+};
+
+/*!
+For a normalized diyfp w = f * 2^e, this function returns a (normalized) cached
+power-of-ten c = f_c * 2^e_c, such that the exponent of the product w * c
+satisfies (Definition 3.2 from [1])
+
+     alpha <= e_c + e + q <= gamma.
+*/
+inline cached_power get_cached_power_for_binary_exponent(int e)
+{
+    // Now
+    //
+    //      alpha <= e_c + e + q <= gamma                                    (1)
+    //      ==> f_c * 2^alpha <= c * 2^e * 2^q
+    //
+    // and since the c's are normalized, 2^(q-1) <= f_c,
+    //
+    //      ==> 2^(q - 1 + alpha) <= c * 2^(e + q)
+    //      ==> 2^(alpha - e - 1) <= c
+    //
+    // If c were an exakt power of ten, i.e. c = 10^k, one may determine k as
+    //
+    //      k = ceil( log_10( 2^(alpha - e - 1) ) )
+    //        = ceil( (alpha - e - 1) * log_10(2) )
+    //
+    // From the paper:
+    // "In theory the result of the procedure could be wrong since c is rounded,
+    //  and the computation itself is approximated [...]. In practice, however,
+    //  this simple function is sufficient."
+    //
+    // For IEEE double precision floating-point numbers converted into
+    // normalized diyfp's w = f * 2^e, with q = 64,
+    //
+    //      e >= -1022      (min IEEE exponent)
+    //           -52        (p - 1)
+    //           -52        (p - 1, possibly normalize denormal IEEE numbers)
+    //           -11        (normalize the diyfp)
+    //         = -1137
+    //
+    // and
+    //
+    //      e <= +1023      (max IEEE exponent)
+    //           -52        (p - 1)
+    //           -11        (normalize the diyfp)
+    //         = 960
+    //
+    // This binary exponent range [-1137,960] results in a decimal exponent
+    // range [-307,324]. One does not need to store a cached power for each
+    // k in this range. For each such k it suffices to find a cached power
+    // such that the exponent of the product lies in [alpha,gamma].
+    // This implies that the difference of the decimal exponents of adjacent
+    // table entries must be less than or equal to
+    //
+    //      floor( (gamma - alpha) * log_10(2) ) = 8.
+    //
+    // (A smaller distance gamma-alpha would require a larger table.)
+
+    // NB:
+    // Actually this function returns c, such that -60 <= e_c + e + 64 <= -34.
+
+    constexpr int kCachedPowersSize = 79;
+    constexpr int kCachedPowersMinDecExp = -300;
+    constexpr int kCachedPowersDecStep = 8;
+
+    static constexpr cached_power kCachedPowers[] =
+    {
+        { 0xAB70FE17C79AC6CA, -1060, -300 },
+        { 0xFF77B1FCBEBCDC4F, -1034, -292 },
+        { 0xBE5691EF416BD60C, -1007, -284 },
+        { 0x8DD01FAD907FFC3C,  -980, -276 },
+        { 0xD3515C2831559A83,  -954, -268 },
+        { 0x9D71AC8FADA6C9B5,  -927, -260 },
+        { 0xEA9C227723EE8BCB,  -901, -252 },
+        { 0xAECC49914078536D,  -874, -244 },
+        { 0x823C12795DB6CE57,  -847, -236 },
+        { 0xC21094364DFB5637,  -821, -228 },
+        { 0x9096EA6F3848984F,  -794, -220 },
+        { 0xD77485CB25823AC7,  -768, -212 },
+        { 0xA086CFCD97BF97F4,  -741, -204 },
+        { 0xEF340A98172AACE5,  -715, -196 },
+        { 0xB23867FB2A35B28E,  -688, -188 },
+        { 0x84C8D4DFD2C63F3B,  -661, -180 },
+        { 0xC5DD44271AD3CDBA,  -635, -172 },
+        { 0x936B9FCEBB25C996,  -608, -164 },
+        { 0xDBAC6C247D62A584,  -582, -156 },
+        { 0xA3AB66580D5FDAF6,  -555, -148 },
+        { 0xF3E2F893DEC3F126,  -529, -140 },
+        { 0xB5B5ADA8AAFF80B8,  -502, -132 },
+        { 0x87625F056C7C4A8B,  -475, -124 },
+        { 0xC9BCFF6034C13053,  -449, -116 },
+        { 0x964E858C91BA2655,  -422, -108 },
+        { 0xDFF9772470297EBD,  -396, -100 },
+        { 0xA6DFBD9FB8E5B88F,  -369,  -92 },
+        { 0xF8A95FCF88747D94,  -343,  -84 },
+        { 0xB94470938FA89BCF,  -316,  -76 },
+        { 0x8A08F0F8BF0F156B,  -289,  -68 },
+        { 0xCDB02555653131B6,  -263,  -60 },
+        { 0x993FE2C6D07B7FAC,  -236,  -52 },
+        { 0xE45C10C42A2B3B06,  -210,  -44 },
+        { 0xAA242499697392D3,  -183,  -36 },
+        { 0xFD87B5F28300CA0E,  -157,  -28 },
+        { 0xBCE5086492111AEB,  -130,  -20 },
+        { 0x8CBCCC096F5088CC,  -103,  -12 },
+        { 0xD1B71758E219652C,   -77,   -4 },
+        { 0x9C40000000000000,   -50,    4 },
+        { 0xE8D4A51000000000,   -24,   12 },
+        { 0xAD78EBC5AC620000,     3,   20 },
+        { 0x813F3978F8940984,    30,   28 },
+        { 0xC097CE7BC90715B3,    56,   36 },
+        { 0x8F7E32CE7BEA5C70,    83,   44 },
+        { 0xD5D238A4ABE98068,   109,   52 },
+        { 0x9F4F2726179A2245,   136,   60 },
+        { 0xED63A231D4C4FB27,   162,   68 },
+        { 0xB0DE65388CC8ADA8,   189,   76 },
+        { 0x83C7088E1AAB65DB,   216,   84 },
+        { 0xC45D1DF942711D9A,   242,   92 },
+        { 0x924D692CA61BE758,   269,  100 },
+        { 0xDA01EE641A708DEA,   295,  108 },
+        { 0xA26DA3999AEF774A,   322,  116 },
+        { 0xF209787BB47D6B85,   348,  124 },
+        { 0xB454E4A179DD1877,   375,  132 },
+        { 0x865B86925B9BC5C2,   402,  140 },
+        { 0xC83553C5C8965D3D,   428,  148 },
+        { 0x952AB45CFA97A0B3,   455,  156 },
+        { 0xDE469FBD99A05FE3,   481,  164 },
+        { 0xA59BC234DB398C25,   508,  172 },
+        { 0xF6C69A72A3989F5C,   534,  180 },
+        { 0xB7DCBF5354E9BECE,   561,  188 },
+        { 0x88FCF317F22241E2,   588,  196 },
+        { 0xCC20CE9BD35C78A5,   614,  204 },
+        { 0x98165AF37B2153DF,   641,  212 },
+        { 0xE2A0B5DC971F303A,   667,  220 },
+        { 0xA8D9D1535CE3B396,   694,  228 },
+        { 0xFB9B7CD9A4A7443C,   720,  236 },
+        { 0xBB764C4CA7A44410,   747,  244 },
+        { 0x8BAB8EEFB6409C1A,   774,  252 },
+        { 0xD01FEF10A657842C,   800,  260 },
+        { 0x9B10A4E5E9913129,   827,  268 },
+        { 0xE7109BFBA19C0C9D,   853,  276 },
+        { 0xAC2820D9623BF429,   880,  284 },
+        { 0x80444B5E7AA7CF85,   907,  292 },
+        { 0xBF21E44003ACDD2D,   933,  300 },
+        { 0x8E679C2F5E44FF8F,   960,  308 },
+        { 0xD433179D9C8CB841,   986,  316 },
+        { 0x9E19DB92B4E31BA9,  1013,  324 },
+    };
+
+    // This computation gives exactly the same results for k as
+    //      k = ceil((kAlpha - e - 1) * 0.30102999566398114)
+    // for |e| <= 1500, but doesn't require floating-point operations.
+    // NB: log_10(2) ~= 78913 / 2^18
+    assert(e >= -1500);
+    assert(e <=  1500);
+    const int f = kAlpha - e - 1;
+    const int k = (f * 78913) / (1 << 18) + static_cast<int>(f > 0);
+
+    const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
+    assert(index >= 0);
+    assert(index < kCachedPowersSize);
+    static_cast<void>(kCachedPowersSize); // Fix warning.
+
+    const cached_power cached = kCachedPowers[index];
+    assert(kAlpha <= cached.e + e + 64);
+    assert(kGamma >= cached.e + e + 64);
+
+    return cached;
+}
+
+/*!
+For n != 0, returns k, such that pow10 := 10^(k-1) <= n < 10^k.
+For n == 0, returns 1 and sets pow10 := 1.
+*/
+inline int find_largest_pow10(const uint32_t n, uint32_t& pow10)
+{
+    // LCOV_EXCL_START
+    if (n >= 1000000000)
+    {
+        pow10 = 1000000000;
+        return 10;
+    }
+    // LCOV_EXCL_STOP
+    else if (n >= 100000000)
+    {
+        pow10 = 100000000;
+        return  9;
+    }
+    else if (n >= 10000000)
+    {
+        pow10 = 10000000;
+        return  8;
+    }
+    else if (n >= 1000000)
+    {
+        pow10 = 1000000;
+        return  7;
+    }
+    else if (n >= 100000)
+    {
+        pow10 = 100000;
+        return  6;
+    }
+    else if (n >= 10000)
+    {
+        pow10 = 10000;
+        return  5;
+    }
+    else if (n >= 1000)
+    {
+        pow10 = 1000;
+        return  4;
+    }
+    else if (n >= 100)
+    {
+        pow10 = 100;
+        return  3;
+    }
+    else if (n >= 10)
+    {
+        pow10 = 10;
+        return  2;
+    }
+    else
+    {
+        pow10 = 1;
+        return 1;
+    }
+}
+
+inline void grisu2_round(char* buf, int len, uint64_t dist, uint64_t delta,
+                         uint64_t rest, uint64_t ten_k)
+{
+    assert(len >= 1);
+    assert(dist <= delta);
+    assert(rest <= delta);
+    assert(ten_k > 0);
+
+    //               <--------------------------- delta ---->
+    //                                  <---- dist --------->
+    // --------------[------------------+-------------------]--------------
+    //               M-                 w                   M+
+    //
+    //                                  ten_k
+    //                                <------>
+    //                                       <---- rest ---->
+    // --------------[------------------+----+--------------]--------------
+    //                                  w    V
+    //                                       = buf * 10^k
+    //
+    // ten_k represents a unit-in-the-last-place in the decimal representation
+    // stored in buf.
+    // Decrement buf by ten_k while this takes buf closer to w.
+
+    // The tests are written in this order to avoid overflow in unsigned
+    // integer arithmetic.
+
+    while (rest < dist
+            and delta - rest >= ten_k
+            and (rest + ten_k < dist or dist - rest > rest + ten_k - dist))
+    {
+        assert(buf[len - 1] != '0');
+        buf[len - 1]--;
+        rest += ten_k;
+    }
+}
+
+/*!
+Generates V = buffer * 10^decimal_exponent, such that M- <= V <= M+.
+M- and M+ must be normalized and share the same exponent -60 <= e <= -32.
+*/
+inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
+                             diyfp M_minus, diyfp w, diyfp M_plus)
+{
+    static_assert(kAlpha >= -60, "internal error");
+    static_assert(kGamma <= -32, "internal error");
+
+    // Generates the digits (and the exponent) of a decimal floating-point
+    // number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's
+    // w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma.
+    //
+    //               <--------------------------- delta ---->
+    //                                  <---- dist --------->
+    // --------------[------------------+-------------------]--------------
+    //               M-                 w                   M+
+    //
+    // Grisu2 generates the digits of M+ from left to right and stops as soon as
+    // V is in [M-,M+].
+
+    assert(M_plus.e >= kAlpha);
+    assert(M_plus.e <= kGamma);
+
+    uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
+    uint64_t dist  = diyfp::sub(M_plus, w      ).f; // (significand of (M+ - w ), implicit exponent is e)
+
+    // Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
+    //
+    //      M+ = f * 2^e
+    //         = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e
+    //         = ((p1        ) * 2^-e + (p2        )) * 2^e
+    //         = p1 + p2 * 2^e
+
+    const diyfp one(uint64_t{1} << -M_plus.e, M_plus.e);
+
+    auto p1 = static_cast<uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
+    uint64_t p2 = M_plus.f & (one.f - 1);                    // p2 = f mod 2^-e
+
+    // 1)
+    //
+    // Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]
+
+    assert(p1 > 0);
+
+    uint32_t pow10;
+    const int k = find_largest_pow10(p1, pow10);
+
+    //      10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
+    //
+    //      p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))
+    //         = (d[k-1]         ) * 10^(k-1) + (p1 mod 10^(k-1))
+    //
+    //      M+ = p1                                             + p2 * 2^e
+    //         = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1))          + p2 * 2^e
+    //         = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e
+    //         = d[k-1] * 10^(k-1) + (                         rest) * 2^e
+    //
+    // Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)
+    //
+    //      p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]
+    //
+    // but stop as soon as
+    //
+    //      rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e
+
+    int n = k;
+    while (n > 0)
+    {
+        // Invariants:
+        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)    (buffer = 0 for n = k)
+        //      pow10 = 10^(n-1) <= p1 < 10^n
+        //
+        const uint32_t d = p1 / pow10;  // d = p1 div 10^(n-1)
+        const uint32_t r = p1 % pow10;  // r = p1 mod 10^(n-1)
+        //
+        //      M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
+        //         = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
+        //
+        assert(d <= 9);
+        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
+        //
+        //      M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
+        //
+        p1 = r;
+        n--;
+        //
+        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)
+        //      pow10 = 10^n
+        //
+
+        // Now check if enough digits have been generated.
+        // Compute
+        //
+        //      p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e
+        //
+        // Note:
+        // Since rest and delta share the same exponent e, it suffices to
+        // compare the significands.
+        const uint64_t rest = (uint64_t{p1} << -one.e) + p2;
+        if (rest <= delta)
+        {
+            // V = buffer * 10^n, with M- <= V <= M+.
+
+            decimal_exponent += n;
+
+            // We may now just stop. But instead look if the buffer could be
+            // decremented to bring V closer to w.
+            //
+            // pow10 = 10^n is now 1 ulp in the decimal representation V.
+            // The rounding procedure works with diyfp's with an implicit
+            // exponent of e.
+            //
+            //      10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
+            //
+            const uint64_t ten_n = uint64_t{pow10} << -one.e;
+            grisu2_round(buffer, length, dist, delta, rest, ten_n);
+
+            return;
+        }
+
+        pow10 /= 10;
+        //
+        //      pow10 = 10^(n-1) <= p1 < 10^n
+        // Invariants restored.
+    }
+
+    // 2)
+    //
+    // The digits of the integral part have been generated:
+    //
+    //      M+ = d[k-1]...d[1]d[0] + p2 * 2^e
+    //         = buffer            + p2 * 2^e
+    //
+    // Now generate the digits of the fractional part p2 * 2^e.
+    //
+    // Note:
+    // No decimal point is generated: the exponent is adjusted instead.
+    //
+    // p2 actually represents the fraction
+    //
+    //      p2 * 2^e
+    //          = p2 / 2^-e
+    //          = d[-1] / 10^1 + d[-2] / 10^2 + ...
+    //
+    // Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)
+    //
+    //      p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m
+    //                      + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)
+    //
+    // using
+    //
+    //      10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)
+    //                = (                   d) * 2^-e + (                   r)
+    //
+    // or
+    //      10^m * p2 * 2^e = d + r * 2^e
+    //
+    // i.e.
+    //
+    //      M+ = buffer + p2 * 2^e
+    //         = buffer + 10^-m * (d + r * 2^e)
+    //         = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e
+    //
+    // and stop as soon as 10^-m * r * 2^e <= delta * 2^e
+
+    assert(p2 > delta);
+
+    int m = 0;
+    for (;;)
+    {
+        // Invariant:
+        //      M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e
+        //         = buffer * 10^-m + 10^-m * (p2                                 ) * 2^e
+        //         = buffer * 10^-m + 10^-m * (1/10 * (10 * p2)                   ) * 2^e
+        //         = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e
+        //
+        assert(p2 <= UINT64_MAX / 10);
+        p2 *= 10;
+        const uint64_t d = p2 >> -one.e;     // d = (10 * p2) div 2^-e
+        const uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
+        //
+        //      M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
+        //         = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
+        //         = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
+        //
+        assert(d <= 9);
+        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
+        //
+        //      M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
+        //
+        p2 = r;
+        m++;
+        //
+        //      M+ = buffer * 10^-m + 10^-m * p2 * 2^e
+        // Invariant restored.
+
+        // Check if enough digits have been generated.
+        //
+        //      10^-m * p2 * 2^e <= delta * 2^e
+        //              p2 * 2^e <= 10^m * delta * 2^e
+        //                    p2 <= 10^m * delta
+        delta *= 10;
+        dist  *= 10;
+        if (p2 <= delta)
+        {
+            break;
+        }
+    }
+
+    // V = buffer * 10^-m, with M- <= V <= M+.
+
+    decimal_exponent -= m;
+
+    // 1 ulp in the decimal representation is now 10^-m.
+    // Since delta and dist are now scaled by 10^m, we need to do the
+    // same with ulp in order to keep the units in sync.
+    //
+    //      10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
+    //
+    const uint64_t ten_m = one.f;
+    grisu2_round(buffer, length, dist, delta, p2, ten_m);
+
+    // By construction this algorithm generates the shortest possible decimal
+    // number (Loitsch, Theorem 6.2) which rounds back to w.
+    // For an input number of precision p, at least
+    //
+    //      N = 1 + ceil(p * log_10(2))
+    //
+    // decimal digits are sufficient to identify all binary floating-point
+    // numbers (Matula, "In-and-Out conversions").
+    // This implies that the algorithm does not produce more than N decimal
+    // digits.
+    //
+    //      N = 17 for p = 53 (IEEE double precision)
+    //      N = 9  for p = 24 (IEEE single precision)
+}
+
+/*!
+v = buf * 10^decimal_exponent
+len is the length of the buffer (number of decimal digits)
+The buffer must be large enough, i.e. >= max_digits10.
+*/
+inline void grisu2(char* buf, int& len, int& decimal_exponent,
+                   diyfp m_minus, diyfp v, diyfp m_plus)
+{
+    assert(m_plus.e == m_minus.e);
+    assert(m_plus.e == v.e);
+
+    //  --------(-----------------------+-----------------------)--------    (A)
+    //          m-                      v                       m+
+    //
+    //  --------------------(-----------+-----------------------)--------    (B)
+    //                      m-          v                       m+
+    //
+    // First scale v (and m- and m+) such that the exponent is in the range
+    // [alpha, gamma].
+
+    const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
+
+    const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k
+
+    // The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]
+    const diyfp w       = diyfp::mul(v,       c_minus_k);
+    const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
+    const diyfp w_plus  = diyfp::mul(m_plus,  c_minus_k);
+
+    //  ----(---+---)---------------(---+---)---------------(---+---)----
+    //          w-                      w                       w+
+    //          = c*m-                  = c*v                   = c*m+
+    //
+    // diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
+    // w+ are now off by a small amount.
+    // In fact:
+    //
+    //      w - v * 10^k < 1 ulp
+    //
+    // To account for this inaccuracy, add resp. subtract 1 ulp.
+    //
+    //  --------+---[---------------(---+---)---------------]---+--------
+    //          w-  M-                  w                   M+  w+
+    //
+    // Now any number in [M-, M+] (bounds included) will round to w when input,
+    // regardless of how the input rounding algorithm breaks ties.
+    //
+    // And digit_gen generates the shortest possible such number in [M-, M+].
+    // Note that this does not mean that Grisu2 always generates the shortest
+    // possible number in the interval (m-, m+).
+    const diyfp M_minus(w_minus.f + 1, w_minus.e);
+    const diyfp M_plus (w_plus.f  - 1, w_plus.e );
+
+    decimal_exponent = -cached.k; // = -(-k) = k
+
+    grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
+}
+
+/*!
+v = buf * 10^decimal_exponent
+len is the length of the buffer (number of decimal digits)
+The buffer must be large enough, i.e. >= max_digits10.
+*/
+template <typename FloatType>
+void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
+{
+    static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
+                  "internal error: not enough precision");
+
+    assert(std::isfinite(value));
+    assert(value > 0);
+
+    // If the neighbors (and boundaries) of 'value' are always computed for double-precision
+    // numbers, all float's can be recovered using strtod (and strtof). However, the resulting
+    // decimal representations are not exactly "short".
+    //
+    // The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars)
+    // says "value is converted to a string as if by std::sprintf in the default ("C") locale"
+    // and since sprintf promotes float's to double's, I think this is exactly what 'std::to_chars'
+    // does.
+    // On the other hand, the documentation for 'std::to_chars' requires that "parsing the
+    // representation using the corresponding std::from_chars function recovers value exactly". That
+    // indicates that single precision floating-point numbers should be recovered using
+    // 'std::strtof'.
+    //
+    // NB: If the neighbors are computed for single-precision numbers, there is a single float
+    //     (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision
+    //     value is off by 1 ulp.
+#if 0
+    const boundaries w = compute_boundaries(static_cast<double>(value));
+#else
+    const boundaries w = compute_boundaries(value);
+#endif
+
+    grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
+}
+
+/*!
+@brief appends a decimal representation of e to buf
+@return a pointer to the element following the exponent.
+@pre -1000 < e < 1000
+*/
+inline char* append_exponent(char* buf, int e)
+{
+    assert(e > -1000);
+    assert(e <  1000);
+
+    if (e < 0)
+    {
+        e = -e;
+        *buf++ = '-';
+    }
+    else
+    {
+        *buf++ = '+';
+    }
+
+    auto k = static_cast<uint32_t>(e);
+    if (k < 10)
+    {
+        // Always print at least two digits in the exponent.
+        // This is for compatibility with printf("%g").
+        *buf++ = '0';
+        *buf++ = static_cast<char>('0' + k);
+    }
+    else if (k < 100)
+    {
+        *buf++ = static_cast<char>('0' + k / 10);
+        k %= 10;
+        *buf++ = static_cast<char>('0' + k);
+    }
+    else
+    {
+        *buf++ = static_cast<char>('0' + k / 100);
+        k %= 100;
+        *buf++ = static_cast<char>('0' + k / 10);
+        k %= 10;
+        *buf++ = static_cast<char>('0' + k);
+    }
+
+    return buf;
+}
+
+/*!
+@brief prettify v = buf * 10^decimal_exponent
+
+If v is in the range [10^min_exp, 10^max_exp) it will be printed in fixed-point
+notation. Otherwise it will be printed in exponential notation.
+
+@pre min_exp < 0
+@pre max_exp > 0
+*/
+inline char* format_buffer(char* buf, int len, int decimal_exponent,
+                           int min_exp, int max_exp)
+{
+    assert(min_exp < 0);
+    assert(max_exp > 0);
+
+    const int k = len;
+    const int n = len + decimal_exponent;
+
+    // v = buf * 10^(n-k)
+    // k is the length of the buffer (number of decimal digits)
+    // n is the position of the decimal point relative to the start of the buffer.
+
+    if (k <= n and n <= max_exp)
+    {
+        // digits[000]
+        // len <= max_exp + 2
+
+        std::memset(buf + k, '0', static_cast<size_t>(n - k));
+        // Make it look like a floating-point number (#362, #378)
+        buf[n + 0] = '.';
+        buf[n + 1] = '0';
+        return buf + (n + 2);
+    }
+
+    if (0 < n and n <= max_exp)
+    {
+        // dig.its
+        // len <= max_digits10 + 1
+
+        assert(k > n);
+
+        std::memmove(buf + (n + 1), buf + n, static_cast<size_t>(k - n));
+        buf[n] = '.';
+        return buf + (k + 1);
+    }
+
+    if (min_exp < n and n <= 0)
+    {
+        // 0.[000]digits
+        // len <= 2 + (-min_exp - 1) + max_digits10
+
+        std::memmove(buf + (2 + -n), buf, static_cast<size_t>(k));
+        buf[0] = '0';
+        buf[1] = '.';
+        std::memset(buf + 2, '0', static_cast<size_t>(-n));
+        return buf + (2 + (-n) + k);
+    }
+
+    if (k == 1)
+    {
+        // dE+123
+        // len <= 1 + 5
+
+        buf += 1;
+    }
+    else
+    {
+        // d.igitsE+123
+        // len <= max_digits10 + 1 + 5
+
+        std::memmove(buf + 2, buf + 1, static_cast<size_t>(k - 1));
+        buf[1] = '.';
+        buf += 1 + k;
+    }
+
+    *buf++ = 'e';
+    return append_exponent(buf, n - 1);
+}
+
+} // namespace dtoa_impl
+
+/*!
+@brief generates a decimal representation of the floating-point number value in [first, last).
+
+The format of the resulting decimal representation is similar to printf's %g
+format. Returns an iterator pointing past-the-end of the decimal representation.
+
+@note The input number must be finite, i.e. NaN's and Inf's are not supported.
+@note The buffer must be large enough.
+@note The result is NOT null-terminated.
+*/
+template <typename FloatType>
+char* to_chars(char* first, const char* last, FloatType value)
+{
+    static_cast<void>(last); // maybe unused - fix warning
+    assert(std::isfinite(value));
+
+    // Use signbit(value) instead of (value < 0) since signbit works for -0.
+    if (std::signbit(value))
+    {
+        value = -value;
+        *first++ = '-';
+    }
+
+    if (value == 0) // +-0
+    {
+        *first++ = '0';
+        // Make it look like a floating-point number (#362, #378)
+        *first++ = '.';
+        *first++ = '0';
+        return first;
+    }
+
+    assert(last - first >= std::numeric_limits<FloatType>::max_digits10);
+
+    // Compute v = buffer * 10^decimal_exponent.
+    // The decimal digits are stored in the buffer, which needs to be interpreted
+    // as an unsigned decimal integer.
+    // len is the length of the buffer, i.e. the number of decimal digits.
+    int len = 0;
+    int decimal_exponent = 0;
+    dtoa_impl::grisu2(first, len, decimal_exponent, value);
+
+    assert(len <= std::numeric_limits<FloatType>::max_digits10);
+
+    // Format the buffer like printf("%.*g", prec, value)
+    constexpr int kMinExp = -4;
+    // Use digits10 here to increase compatibility with version 2.
+    constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;
+
+    assert(last - first >= kMaxExp + 2);
+    assert(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
+    assert(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
+
+    return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
+}
+
+} // namespace detail
+} // namespace nlohmann
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/output/binary_writer.hpp>
+
+// #include <nlohmann/detail/output/output_adapters.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+///////////////////
+// serialization //
+///////////////////
+
+/// how to treat decoding errors
+enum class error_handler_t
+{
+    strict,  ///< throw a type_error exception in case of invalid UTF-8
+    replace, ///< replace invalid UTF-8 sequences with U+FFFD
+    ignore   ///< ignore invalid UTF-8 sequences
+};
+
+template<typename BasicJsonType>
+class serializer
+{
+    using string_t = typename BasicJsonType::string_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    static constexpr uint8_t UTF8_ACCEPT = 0;
+    static constexpr uint8_t UTF8_REJECT = 1;
+
+  public:
+    /*!
+    @param[in] s  output stream to serialize to
+    @param[in] ichar  indentation character to use
+    @param[in] error_handler_  how to react on decoding errors
+    */
+    serializer(output_adapter_t<char> s, const char ichar,
+               error_handler_t error_handler_ = error_handler_t::strict)
+        : o(std::move(s))
+        , loc(std::localeconv())
+        , thousands_sep(loc->thousands_sep == nullptr ? '\0' : * (loc->thousands_sep))
+        , decimal_point(loc->decimal_point == nullptr ? '\0' : * (loc->decimal_point))
+        , indent_char(ichar)
+        , indent_string(512, indent_char)
+        , error_handler(error_handler_)
+    {}
+
+    // delete because of pointer members
+    serializer(const serializer&) = delete;
+    serializer& operator=(const serializer&) = delete;
+    serializer(serializer&&) = delete;
+    serializer& operator=(serializer&&) = delete;
+    ~serializer() = default;
+
+    /*!
+    @brief internal implementation of the serialization function
+
+    This function is called by the public member function dump and organizes
+    the serialization internally. The indentation level is propagated as
+    additional parameter. In case of arrays and objects, the function is
+    called recursively.
+
+    - strings and object keys are escaped using `escape_string()`
+    - integer numbers are converted implicitly via `operator<<`
+    - floating-point numbers are converted to a string using `"%g"` format
+
+    @param[in] val             value to serialize
+    @param[in] pretty_print    whether the output shall be pretty-printed
+    @param[in] indent_step     the indent level
+    @param[in] current_indent  the current indent level (only used internally)
+    */
+    void dump(const BasicJsonType& val, const bool pretty_print,
+              const bool ensure_ascii,
+              const unsigned int indent_step,
+              const unsigned int current_indent = 0)
+    {
+        switch (val.m_type)
+        {
+            case value_t::object:
+            {
+                if (val.m_value.object->empty())
+                {
+                    o->write_characters("{}", 2);
+                    return;
+                }
+
+                if (pretty_print)
+                {
+                    o->write_characters("{\n", 2);
+
+                    // variable to hold indentation for recursive calls
+                    const auto new_indent = current_indent + indent_step;
+                    if (JSON_UNLIKELY(indent_string.size() < new_indent))
+                    {
+                        indent_string.resize(indent_string.size() * 2, ' ');
+                    }
+
+                    // first n-1 elements
+                    auto i = val.m_value.object->cbegin();
+                    for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
+                    {
+                        o->write_characters(indent_string.c_str(), new_indent);
+                        o->write_character('\"');
+                        dump_escaped(i->first, ensure_ascii);
+                        o->write_characters("\": ", 3);
+                        dump(i->second, true, ensure_ascii, indent_step, new_indent);
+                        o->write_characters(",\n", 2);
+                    }
+
+                    // last element
+                    assert(i != val.m_value.object->cend());
+                    assert(std::next(i) == val.m_value.object->cend());
+                    o->write_characters(indent_string.c_str(), new_indent);
+                    o->write_character('\"');
+                    dump_escaped(i->first, ensure_ascii);
+                    o->write_characters("\": ", 3);
+                    dump(i->second, true, ensure_ascii, indent_step, new_indent);
+
+                    o->write_character('\n');
+                    o->write_characters(indent_string.c_str(), current_indent);
+                    o->write_character('}');
+                }
+                else
+                {
+                    o->write_character('{');
+
+                    // first n-1 elements
+                    auto i = val.m_value.object->cbegin();
+                    for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
+                    {
+                        o->write_character('\"');
+                        dump_escaped(i->first, ensure_ascii);
+                        o->write_characters("\":", 2);
+                        dump(i->second, false, ensure_ascii, indent_step, current_indent);
+                        o->write_character(',');
+                    }
+
+                    // last element
+                    assert(i != val.m_value.object->cend());
+                    assert(std::next(i) == val.m_value.object->cend());
+                    o->write_character('\"');
+                    dump_escaped(i->first, ensure_ascii);
+                    o->write_characters("\":", 2);
+                    dump(i->second, false, ensure_ascii, indent_step, current_indent);
+
+                    o->write_character('}');
+                }
+
+                return;
+            }
+
+            case value_t::array:
+            {
+                if (val.m_value.array->empty())
+                {
+                    o->write_characters("[]", 2);
+                    return;
+                }
+
+                if (pretty_print)
+                {
+                    o->write_characters("[\n", 2);
+
+                    // variable to hold indentation for recursive calls
+                    const auto new_indent = current_indent + indent_step;
+                    if (JSON_UNLIKELY(indent_string.size() < new_indent))
+                    {
+                        indent_string.resize(indent_string.size() * 2, ' ');
+                    }
+
+                    // first n-1 elements
+                    for (auto i = val.m_value.array->cbegin();
+                            i != val.m_value.array->cend() - 1; ++i)
+                    {
+                        o->write_characters(indent_string.c_str(), new_indent);
+                        dump(*i, true, ensure_ascii, indent_step, new_indent);
+                        o->write_characters(",\n", 2);
+                    }
+
+                    // last element
+                    assert(not val.m_value.array->empty());
+                    o->write_characters(indent_string.c_str(), new_indent);
+                    dump(val.m_value.array->back(), true, ensure_ascii, indent_step, new_indent);
+
+                    o->write_character('\n');
+                    o->write_characters(indent_string.c_str(), current_indent);
+                    o->write_character(']');
+                }
+                else
+                {
+                    o->write_character('[');
+
+                    // first n-1 elements
+                    for (auto i = val.m_value.array->cbegin();
+                            i != val.m_value.array->cend() - 1; ++i)
+                    {
+                        dump(*i, false, ensure_ascii, indent_step, current_indent);
+                        o->write_character(',');
+                    }
+
+                    // last element
+                    assert(not val.m_value.array->empty());
+                    dump(val.m_value.array->back(), false, ensure_ascii, indent_step, current_indent);
+
+                    o->write_character(']');
+                }
+
+                return;
+            }
+
+            case value_t::string:
+            {
+                o->write_character('\"');
+                dump_escaped(*val.m_value.string, ensure_ascii);
+                o->write_character('\"');
+                return;
+            }
+
+            case value_t::boolean:
+            {
+                if (val.m_value.boolean)
+                {
+                    o->write_characters("true", 4);
+                }
+                else
+                {
+                    o->write_characters("false", 5);
+                }
+                return;
+            }
+
+            case value_t::number_integer:
+            {
+                dump_integer(val.m_value.number_integer);
+                return;
+            }
+
+            case value_t::number_unsigned:
+            {
+                dump_integer(val.m_value.number_unsigned);
+                return;
+            }
+
+            case value_t::number_float:
+            {
+                dump_float(val.m_value.number_float);
+                return;
+            }
+
+            case value_t::discarded:
+            {
+                o->write_characters("<discarded>", 11);
+                return;
+            }
+
+            case value_t::null:
+            {
+                o->write_characters("null", 4);
+                return;
+            }
+        }
+    }
+
+  private:
+    /*!
+    @brief dump escaped string
+
+    Escape a string by replacing certain special characters by a sequence of an
+    escape character (backslash) and another character and other control
+    characters by a sequence of "\u" followed by a four-digit hex
+    representation. The escaped string is written to output stream @a o.
+
+    @param[in] s  the string to escape
+    @param[in] ensure_ascii  whether to escape non-ASCII characters with
+                             \uXXXX sequences
+
+    @complexity Linear in the length of string @a s.
+    */
+    void dump_escaped(const string_t& s, const bool ensure_ascii)
+    {
+        uint32_t codepoint;
+        uint8_t state = UTF8_ACCEPT;
+        std::size_t bytes = 0;  // number of bytes written to string_buffer
+
+        // number of bytes written at the point of the last valid byte
+        std::size_t bytes_after_last_accept = 0;
+        std::size_t undumped_chars = 0;
+
+        for (std::size_t i = 0; i < s.size(); ++i)
+        {
+            const auto byte = static_cast<uint8_t>(s[i]);
+
+            switch (decode(state, codepoint, byte))
+            {
+                case UTF8_ACCEPT:  // decode found a new code point
+                {
+                    switch (codepoint)
+                    {
+                        case 0x08: // backspace
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'b';
+                            break;
+                        }
+
+                        case 0x09: // horizontal tab
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 't';
+                            break;
+                        }
+
+                        case 0x0A: // newline
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'n';
+                            break;
+                        }
+
+                        case 0x0C: // formfeed
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'f';
+                            break;
+                        }
+
+                        case 0x0D: // carriage return
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'r';
+                            break;
+                        }
+
+                        case 0x22: // quotation mark
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = '\"';
+                            break;
+                        }
+
+                        case 0x5C: // reverse solidus
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = '\\';
+                            break;
+                        }
+
+                        default:
+                        {
+                            // escape control characters (0x00..0x1F) or, if
+                            // ensure_ascii parameter is used, non-ASCII characters
+                            if ((codepoint <= 0x1F) or (ensure_ascii and (codepoint >= 0x7F)))
+                            {
+                                if (codepoint <= 0xFFFF)
+                                {
+                                    (std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x",
+                                                    static_cast<uint16_t>(codepoint));
+                                    bytes += 6;
+                                }
+                                else
+                                {
+                                    (std::snprintf)(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",
+                                                    static_cast<uint16_t>(0xD7C0 + (codepoint >> 10)),
+                                                    static_cast<uint16_t>(0xDC00 + (codepoint & 0x3FF)));
+                                    bytes += 12;
+                                }
+                            }
+                            else
+                            {
+                                // copy byte to buffer (all previous bytes
+                                // been copied have in default case above)
+                                string_buffer[bytes++] = s[i];
+                            }
+                            break;
+                        }
+                    }
+
+                    // write buffer and reset index; there must be 13 bytes
+                    // left, as this is the maximal number of bytes to be
+                    // written ("\uxxxx\uxxxx\0") for one code point
+                    if (string_buffer.size() - bytes < 13)
+                    {
+                        o->write_characters(string_buffer.data(), bytes);
+                        bytes = 0;
+                    }
+
+                    // remember the byte position of this accept
+                    bytes_after_last_accept = bytes;
+                    undumped_chars = 0;
+                    break;
+                }
+
+                case UTF8_REJECT:  // decode found invalid UTF-8 byte
+                {
+                    switch (error_handler)
+                    {
+                        case error_handler_t::strict:
+                        {
+                            std::string sn(3, '\0');
+                            (std::snprintf)(&sn[0], sn.size(), "%.2X", byte);
+                            JSON_THROW(type_error::create(316, "invalid UTF-8 byte at index " + std::to_string(i) + ": 0x" + sn));
+                        }
+
+                        case error_handler_t::ignore:
+                        case error_handler_t::replace:
+                        {
+                            // in case we saw this character the first time, we
+                            // would like to read it again, because the byte
+                            // may be OK for itself, but just not OK for the
+                            // previous sequence
+                            if (undumped_chars > 0)
+                            {
+                                --i;
+                            }
+
+                            // reset length buffer to the last accepted index;
+                            // thus removing/ignoring the invalid characters
+                            bytes = bytes_after_last_accept;
+
+                            if (error_handler == error_handler_t::replace)
+                            {
+                                // add a replacement character
+                                if (ensure_ascii)
+                                {
+                                    string_buffer[bytes++] = '\\';
+                                    string_buffer[bytes++] = 'u';
+                                    string_buffer[bytes++] = 'f';
+                                    string_buffer[bytes++] = 'f';
+                                    string_buffer[bytes++] = 'f';
+                                    string_buffer[bytes++] = 'd';
+                                }
+                                else
+                                {
+                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xEF');
+                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBF');
+                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBD');
+                                }
+                                bytes_after_last_accept = bytes;
+                            }
+
+                            undumped_chars = 0;
+
+                            // continue processing the string
+                            state = UTF8_ACCEPT;
+                            break;
+                        }
+                    }
+                    break;
+                }
+
+                default:  // decode found yet incomplete multi-byte code point
+                {
+                    if (not ensure_ascii)
+                    {
+                        // code point will not be escaped - copy byte to buffer
+                        string_buffer[bytes++] = s[i];
+                    }
+                    ++undumped_chars;
+                    break;
+                }
+            }
+        }
+
+        // we finished processing the string
+        if (JSON_LIKELY(state == UTF8_ACCEPT))
+        {
+            // write buffer
+            if (bytes > 0)
+            {
+                o->write_characters(string_buffer.data(), bytes);
+            }
+        }
+        else
+        {
+            // we finish reading, but do not accept: string was incomplete
+            switch (error_handler)
+            {
+                case error_handler_t::strict:
+                {
+                    std::string sn(3, '\0');
+                    (std::snprintf)(&sn[0], sn.size(), "%.2X", static_cast<uint8_t>(s.back()));
+                    JSON_THROW(type_error::create(316, "incomplete UTF-8 string; last byte: 0x" + sn));
+                }
+
+                case error_handler_t::ignore:
+                {
+                    // write all accepted bytes
+                    o->write_characters(string_buffer.data(), bytes_after_last_accept);
+                    break;
+                }
+
+                case error_handler_t::replace:
+                {
+                    // write all accepted bytes
+                    o->write_characters(string_buffer.data(), bytes_after_last_accept);
+                    // add a replacement character
+                    if (ensure_ascii)
+                    {
+                        o->write_characters("\\ufffd", 6);
+                    }
+                    else
+                    {
+                        o->write_characters("\xEF\xBF\xBD", 3);
+                    }
+                    break;
+                }
+            }
+        }
+    }
+
+    /*!
+    @brief dump an integer
+
+    Dump a given integer to output stream @a o. Works internally with
+    @a number_buffer.
+
+    @param[in] x  integer number (signed or unsigned) to dump
+    @tparam NumberType either @a number_integer_t or @a number_unsigned_t
+    */
+    template<typename NumberType, detail::enable_if_t<
+                 std::is_same<NumberType, number_unsigned_t>::value or
+                 std::is_same<NumberType, number_integer_t>::value,
+                 int> = 0>
+    void dump_integer(NumberType x)
+    {
+        // special case for "0"
+        if (x == 0)
+        {
+            o->write_character('0');
+            return;
+        }
+
+        const bool is_negative = std::is_same<NumberType, number_integer_t>::value and not (x >= 0);  // see issue #755
+        std::size_t i = 0;
+
+        while (x != 0)
+        {
+            // spare 1 byte for '\0'
+            assert(i < number_buffer.size() - 1);
+
+            const auto digit = std::labs(static_cast<long>(x % 10));
+            number_buffer[i++] = static_cast<char>('0' + digit);
+            x /= 10;
+        }
+
+        if (is_negative)
+        {
+            // make sure there is capacity for the '-'
+            assert(i < number_buffer.size() - 2);
+            number_buffer[i++] = '-';
+        }
+
+        std::reverse(number_buffer.begin(), number_buffer.begin() + i);
+        o->write_characters(number_buffer.data(), i);
+    }
+
+    /*!
+    @brief dump a floating-point number
+
+    Dump a given floating-point number to output stream @a o. Works internally
+    with @a number_buffer.
+
+    @param[in] x  floating-point number to dump
+    */
+    void dump_float(number_float_t x)
+    {
+        // NaN / inf
+        if (not std::isfinite(x))
+        {
+            o->write_characters("null", 4);
+            return;
+        }
+
+        // If number_float_t is an IEEE-754 single or double precision number,
+        // use the Grisu2 algorithm to produce short numbers which are
+        // guaranteed to round-trip, using strtof and strtod, resp.
+        //
+        // NB: The test below works if <long double> == <double>.
+        static constexpr bool is_ieee_single_or_double
+            = (std::numeric_limits<number_float_t>::is_iec559 and std::numeric_limits<number_float_t>::digits == 24 and std::numeric_limits<number_float_t>::max_exponent == 128) or
+              (std::numeric_limits<number_float_t>::is_iec559 and std::numeric_limits<number_float_t>::digits == 53 and std::numeric_limits<number_float_t>::max_exponent == 1024);
+
+        dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
+    }
+
+    void dump_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/)
+    {
+        char* begin = number_buffer.data();
+        char* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);
+
+        o->write_characters(begin, static_cast<size_t>(end - begin));
+    }
+
+    void dump_float(number_float_t x, std::false_type /*is_ieee_single_or_double*/)
+    {
+        // get number of digits for a float -> text -> float round-trip
+        static constexpr auto d = std::numeric_limits<number_float_t>::max_digits10;
+
+        // the actual conversion
+        std::ptrdiff_t len = (std::snprintf)(number_buffer.data(), number_buffer.size(), "%.*g", d, x);
+
+        // negative value indicates an error
+        assert(len > 0);
+        // check if buffer was large enough
+        assert(static_cast<std::size_t>(len) < number_buffer.size());
+
+        // erase thousands separator
+        if (thousands_sep != '\0')
+        {
+            const auto end = std::remove(number_buffer.begin(),
+                                         number_buffer.begin() + len, thousands_sep);
+            std::fill(end, number_buffer.end(), '\0');
+            assert((end - number_buffer.begin()) <= len);
+            len = (end - number_buffer.begin());
+        }
+
+        // convert decimal point to '.'
+        if (decimal_point != '\0' and decimal_point != '.')
+        {
+            const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
+            if (dec_pos != number_buffer.end())
+            {
+                *dec_pos = '.';
+            }
+        }
+
+        o->write_characters(number_buffer.data(), static_cast<std::size_t>(len));
+
+        // determine if need to append ".0"
+        const bool value_is_int_like =
+            std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
+                         [](char c)
+        {
+            return (c == '.' or c == 'e');
+        });
+
+        if (value_is_int_like)
+        {
+            o->write_characters(".0", 2);
+        }
+    }
+
+    /*!
+    @brief check whether a string is UTF-8 encoded
+
+    The function checks each byte of a string whether it is UTF-8 encoded. The
+    result of the check is stored in the @a state parameter. The function must
+    be called initially with state 0 (accept). State 1 means the string must
+    be rejected, because the current byte is not allowed. If the string is
+    completely processed, but the state is non-zero, the string ended
+    prematurely; that is, the last byte indicated more bytes should have
+    followed.
+
+    @param[in,out] state  the state of the decoding
+    @param[in,out] codep  codepoint (valid only if resulting state is UTF8_ACCEPT)
+    @param[in] byte       next byte to decode
+    @return               new state
+
+    @note The function has been edited: a std::array is used.
+
+    @copyright Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
+    @sa http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
+    */
+    static uint8_t decode(uint8_t& state, uint32_t& codep, const uint8_t byte) noexcept
+    {
+        static const std::array<uint8_t, 400> utf8d =
+        {
+            {
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00..1F
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20..3F
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 40..5F
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 60..7F
+                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // 80..9F
+                7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // A0..BF
+                8, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // C0..DF
+                0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF
+                0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF
+                0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0
+                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, // s1..s2
+                1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, // s3..s4
+                1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, // s5..s6
+                1, 3, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // s7..s8
+            }
+        };
+
+        const uint8_t type = utf8d[byte];
+
+        codep = (state != UTF8_ACCEPT)
+                ? (byte & 0x3fu) | (codep << 6)
+                : static_cast<uint32_t>(0xff >> type) & (byte);
+
+        state = utf8d[256u + state * 16u + type];
+        return state;
+    }
+
+  private:
+    /// the output of the serializer
+    output_adapter_t<char> o = nullptr;
+
+    /// a (hopefully) large enough character buffer
+    std::array<char, 64> number_buffer{{}};
+
+    /// the locale
+    const std::lconv* loc = nullptr;
+    /// the locale's thousand separator character
+    const char thousands_sep = '\0';
+    /// the locale's decimal point character
+    const char decimal_point = '\0';
+
+    /// string buffer
+    std::array<char, 512> string_buffer{{}};
+
+    /// the indentation character
+    const char indent_char;
+    /// the indentation string
+    string_t indent_string;
+
+    /// error_handler how to react on decoding errors
+    const error_handler_t error_handler;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/json_ref.hpp>
+
+
+#include <initializer_list>
+#include <utility>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+template<typename BasicJsonType>
+class json_ref
+{
+  public:
+    using value_type = BasicJsonType;
+
+    json_ref(value_type&& value)
+        : owned_value(std::move(value)), value_ref(&owned_value), is_rvalue(true)
+    {}
+
+    json_ref(const value_type& value)
+        : value_ref(const_cast<value_type*>(&value)), is_rvalue(false)
+    {}
+
+    json_ref(std::initializer_list<json_ref> init)
+        : owned_value(init), value_ref(&owned_value), is_rvalue(true)
+    {}
+
+    template <
+        class... Args,
+        enable_if_t<std::is_constructible<value_type, Args...>::value, int> = 0 >
+    json_ref(Args && ... args)
+        : owned_value(std::forward<Args>(args)...), value_ref(&owned_value),
+          is_rvalue(true) {}
+
+    // class should be movable only
+    json_ref(json_ref&&) = default;
+    json_ref(const json_ref&) = delete;
+    json_ref& operator=(const json_ref&) = delete;
+    json_ref& operator=(json_ref&&) = delete;
+    ~json_ref() = default;
+
+    value_type moved_or_copied() const
+    {
+        if (is_rvalue)
+        {
+            return std::move(*value_ref);
+        }
+        return *value_ref;
+    }
+
+    value_type const& operator*() const
+    {
+        return *static_cast<value_type const*>(value_ref);
+    }
+
+    value_type const* operator->() const
+    {
+        return static_cast<value_type const*>(value_ref);
+    }
+
+  private:
+    mutable value_type owned_value = nullptr;
+    value_type* value_ref = nullptr;
+    const bool is_rvalue;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/json_pointer.hpp>
+
+
+#include <cassert> // assert
+#include <numeric> // accumulate
+#include <string> // string
+#include <vector> // vector
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+template<typename BasicJsonType>
+class json_pointer
+{
+    // allow basic_json to access private members
+    NLOHMANN_BASIC_JSON_TPL_DECLARATION
+    friend class basic_json;
+
+  public:
+    /*!
+    @brief create JSON pointer
+
+    Create a JSON pointer according to the syntax described in
+    [Section 3 of RFC6901](https://tools.ietf.org/html/rfc6901#section-3).
+
+    @param[in] s  string representing the JSON pointer; if omitted, the empty
+                  string is assumed which references the whole JSON value
+
+    @throw parse_error.107 if the given JSON pointer @a s is nonempty and does
+                           not begin with a slash (`/`); see example below
+
+    @throw parse_error.108 if a tilde (`~`) in the given JSON pointer @a s is
+    not followed by `0` (representing `~`) or `1` (representing `/`); see
+    example below
+
+    @liveexample{The example shows the construction several valid JSON pointers
+    as well as the exceptional behavior.,json_pointer}
+
+    @since version 2.0.0
+    */
+    explicit json_pointer(const std::string& s = "")
+        : reference_tokens(split(s))
+    {}
+
+    /*!
+    @brief return a string representation of the JSON pointer
+
+    @invariant For each JSON pointer `ptr`, it holds:
+    @code {.cpp}
+    ptr == json_pointer(ptr.to_string());
+    @endcode
+
+    @return a string representation of the JSON pointer
+
+    @liveexample{The example shows the result of `to_string`.,
+    json_pointer__to_string}
+
+    @since version 2.0.0
+    */
+    std::string to_string() const
+    {
+        return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
+                               std::string{},
+                               [](const std::string & a, const std::string & b)
+        {
+            return a + "/" + escape(b);
+        });
+    }
+
+    /// @copydoc to_string()
+    operator std::string() const
+    {
+        return to_string();
+    }
+
+    /*!
+    @param[in] s  reference token to be converted into an array index
+
+    @return integer representation of @a s
+
+    @throw out_of_range.404 if string @a s could not be converted to an integer
+    */
+    static int array_index(const std::string& s)
+    {
+        std::size_t processed_chars = 0;
+        const int res = std::stoi(s, &processed_chars);
+
+        // check if the string was completely read
+        if (JSON_UNLIKELY(processed_chars != s.size()))
+        {
+            JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'"));
+        }
+
+        return res;
+    }
+
+  private:
+    /*!
+    @brief remove and return last reference pointer
+    @throw out_of_range.405 if JSON pointer has no parent
+    */
+    std::string pop_back()
+    {
+        if (JSON_UNLIKELY(is_root()))
+        {
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
+        }
+
+        auto last = reference_tokens.back();
+        reference_tokens.pop_back();
+        return last;
+    }
+
+    /// return whether pointer points to the root document
+    bool is_root() const noexcept
+    {
+        return reference_tokens.empty();
+    }
+
+    json_pointer top() const
+    {
+        if (JSON_UNLIKELY(is_root()))
+        {
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
+        }
+
+        json_pointer result = *this;
+        result.reference_tokens = {reference_tokens[0]};
+        return result;
+    }
+
+    /*!
+    @brief create and return a reference to the pointed to value
+
+    @complexity Linear in the number of reference tokens.
+
+    @throw parse_error.109 if array index is not a number
+    @throw type_error.313 if value cannot be unflattened
+    */
+    BasicJsonType& get_and_create(BasicJsonType& j) const
+    {
+        using size_type = typename BasicJsonType::size_type;
+        auto result = &j;
+
+        // in case no reference tokens exist, return a reference to the JSON value
+        // j which will be overwritten by a primitive value
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (result->m_type)
+            {
+                case detail::value_t::null:
+                {
+                    if (reference_token == "0")
+                    {
+                        // start a new array if reference token is 0
+                        result = &result->operator[](0);
+                    }
+                    else
+                    {
+                        // start a new object otherwise
+                        result = &result->operator[](reference_token);
+                    }
+                    break;
+                }
+
+                case detail::value_t::object:
+                {
+                    // create an entry in the object
+                    result = &result->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    // create an entry in the array
+                    JSON_TRY
+                    {
+                        result = &result->operator[](static_cast<size_type>(array_index(reference_token)));
+                    }
+                    JSON_CATCH(std::invalid_argument&)
+                    {
+                        JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
+                    }
+                    break;
+                }
+
+                /*
+                The following code is only reached if there exists a reference
+                token _and_ the current value is primitive. In this case, we have
+                an error situation, because primitive values may only occur as
+                single value; that is, with an empty list of reference tokens.
+                */
+                default:
+                    JSON_THROW(detail::type_error::create(313, "invalid value to unflatten"));
+            }
+        }
+
+        return *result;
+    }
+
+    /*!
+    @brief return a reference to the pointed to value
+
+    @note This version does not throw if a value is not present, but tries to
+          create nested values instead. For instance, calling this function
+          with pointer `"/this/that"` on a null value is equivalent to calling
+          `operator[]("this").operator[]("that")` on that value, effectively
+          changing the null value to an object.
+
+    @param[in] ptr  a JSON value
+
+    @return reference to the JSON value pointed to by the JSON pointer
+
+    @complexity Linear in the length of the JSON pointer.
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    BasicJsonType& get_unchecked(BasicJsonType* ptr) const
+    {
+        using size_type = typename BasicJsonType::size_type;
+        for (const auto& reference_token : reference_tokens)
+        {
+            // convert null values to arrays or objects before continuing
+            if (ptr->m_type == detail::value_t::null)
+            {
+                // check if reference token is a number
+                const bool nums =
+                    std::all_of(reference_token.begin(), reference_token.end(),
+                                [](const char x)
+                {
+                    return (x >= '0' and x <= '9');
+                });
+
+                // change value to array for numbers or "-" or to object otherwise
+                *ptr = (nums or reference_token == "-")
+                       ? detail::value_t::array
+                       : detail::value_t::object;
+            }
+
+            switch (ptr->m_type)
+            {
+                case detail::value_t::object:
+                {
+                    // use unchecked object access
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    // error condition (cf. RFC 6901, Sect. 4)
+                    if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
+                    {
+                        JSON_THROW(detail::parse_error::create(106, 0,
+                                                               "array index '" + reference_token +
+                                                               "' must not begin with '0'"));
+                    }
+
+                    if (reference_token == "-")
+                    {
+                        // explicitly treat "-" as index beyond the end
+                        ptr = &ptr->operator[](ptr->m_value.array->size());
+                    }
+                    else
+                    {
+                        // convert array index to number; unchecked access
+                        JSON_TRY
+                        {
+                            ptr = &ptr->operator[](
+                                static_cast<size_type>(array_index(reference_token)));
+                        }
+                        JSON_CATCH(std::invalid_argument&)
+                        {
+                            JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
+                        }
+                    }
+                    break;
+                }
+
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    BasicJsonType& get_checked(BasicJsonType* ptr) const
+    {
+        using size_type = typename BasicJsonType::size_type;
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->m_type)
+            {
+                case detail::value_t::object:
+                {
+                    // note: at performs range check
+                    ptr = &ptr->at(reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" always fails the range check
+                        JSON_THROW(detail::out_of_range::create(402,
+                                                                "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
+                                                                ") is out of range"));
+                    }
+
+                    // error condition (cf. RFC 6901, Sect. 4)
+                    if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
+                    {
+                        JSON_THROW(detail::parse_error::create(106, 0,
+                                                               "array index '" + reference_token +
+                                                               "' must not begin with '0'"));
+                    }
+
+                    // note: at performs range check
+                    JSON_TRY
+                    {
+                        ptr = &ptr->at(static_cast<size_type>(array_index(reference_token)));
+                    }
+                    JSON_CATCH(std::invalid_argument&)
+                    {
+                        JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
+                    }
+                    break;
+                }
+
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @brief return a const reference to the pointed to value
+
+    @param[in] ptr  a JSON value
+
+    @return const reference to the JSON value pointed to by the JSON
+    pointer
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const
+    {
+        using size_type = typename BasicJsonType::size_type;
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->m_type)
+            {
+                case detail::value_t::object:
+                {
+                    // use unchecked object access
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" cannot be used for const access
+                        JSON_THROW(detail::out_of_range::create(402,
+                                                                "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
+                                                                ") is out of range"));
+                    }
+
+                    // error condition (cf. RFC 6901, Sect. 4)
+                    if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
+                    {
+                        JSON_THROW(detail::parse_error::create(106, 0,
+                                                               "array index '" + reference_token +
+                                                               "' must not begin with '0'"));
+                    }
+
+                    // use unchecked array access
+                    JSON_TRY
+                    {
+                        ptr = &ptr->operator[](
+                            static_cast<size_type>(array_index(reference_token)));
+                    }
+                    JSON_CATCH(std::invalid_argument&)
+                    {
+                        JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
+                    }
+                    break;
+                }
+
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    const BasicJsonType& get_checked(const BasicJsonType* ptr) const
+    {
+        using size_type = typename BasicJsonType::size_type;
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->m_type)
+            {
+                case detail::value_t::object:
+                {
+                    // note: at performs range check
+                    ptr = &ptr->at(reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" always fails the range check
+                        JSON_THROW(detail::out_of_range::create(402,
+                                                                "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
+                                                                ") is out of range"));
+                    }
+
+                    // error condition (cf. RFC 6901, Sect. 4)
+                    if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
+                    {
+                        JSON_THROW(detail::parse_error::create(106, 0,
+                                                               "array index '" + reference_token +
+                                                               "' must not begin with '0'"));
+                    }
+
+                    // note: at performs range check
+                    JSON_TRY
+                    {
+                        ptr = &ptr->at(static_cast<size_type>(array_index(reference_token)));
+                    }
+                    JSON_CATCH(std::invalid_argument&)
+                    {
+                        JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
+                    }
+                    break;
+                }
+
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @brief split the string input to reference tokens
+
+    @note This function is only called by the json_pointer constructor.
+          All exceptions below are documented there.
+
+    @throw parse_error.107  if the pointer is not empty or begins with '/'
+    @throw parse_error.108  if character '~' is not followed by '0' or '1'
+    */
+    static std::vector<std::string> split(const std::string& reference_string)
+    {
+        std::vector<std::string> result;
+
+        // special case: empty reference string -> no reference tokens
+        if (reference_string.empty())
+        {
+            return result;
+        }
+
+        // check if nonempty reference string begins with slash
+        if (JSON_UNLIKELY(reference_string[0] != '/'))
+        {
+            JSON_THROW(detail::parse_error::create(107, 1,
+                                                   "JSON pointer must be empty or begin with '/' - was: '" +
+                                                   reference_string + "'"));
+        }
+
+        // extract the reference tokens:
+        // - slash: position of the last read slash (or end of string)
+        // - start: position after the previous slash
+        for (
+            // search for the first slash after the first character
+            std::size_t slash = reference_string.find_first_of('/', 1),
+            // set the beginning of the first reference token
+            start = 1;
+            // we can stop if start == 0 (if slash == std::string::npos)
+            start != 0;
+            // set the beginning of the next reference token
+            // (will eventually be 0 if slash == std::string::npos)
+            start = (slash == std::string::npos) ? 0 : slash + 1,
+            // find next slash
+            slash = reference_string.find_first_of('/', start))
+        {
+            // use the text between the beginning of the reference token
+            // (start) and the last slash (slash).
+            auto reference_token = reference_string.substr(start, slash - start);
+
+            // check reference tokens are properly escaped
+            for (std::size_t pos = reference_token.find_first_of('~');
+                    pos != std::string::npos;
+                    pos = reference_token.find_first_of('~', pos + 1))
+            {
+                assert(reference_token[pos] == '~');
+
+                // ~ must be followed by 0 or 1
+                if (JSON_UNLIKELY(pos == reference_token.size() - 1 or
+                                  (reference_token[pos + 1] != '0' and
+                                   reference_token[pos + 1] != '1')))
+                {
+                    JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'"));
+                }
+            }
+
+            // finally, store the reference token
+            unescape(reference_token);
+            result.push_back(reference_token);
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief replace all occurrences of a substring by another string
+
+    @param[in,out] s  the string to manipulate; changed so that all
+                   occurrences of @a f are replaced with @a t
+    @param[in]     f  the substring to replace with @a t
+    @param[in]     t  the string to replace @a f
+
+    @pre The search string @a f must not be empty. **This precondition is
+    enforced with an assertion.**
+
+    @since version 2.0.0
+    */
+    static void replace_substring(std::string& s, const std::string& f,
+                                  const std::string& t)
+    {
+        assert(not f.empty());
+        for (auto pos = s.find(f);                // find first occurrence of f
+                pos != std::string::npos;         // make sure f was found
+                s.replace(pos, f.size(), t),      // replace with t, and
+                pos = s.find(f, pos + t.size()))  // find next occurrence of f
+        {}
+    }
+
+    /// escape "~" to "~0" and "/" to "~1"
+    static std::string escape(std::string s)
+    {
+        replace_substring(s, "~", "~0");
+        replace_substring(s, "/", "~1");
+        return s;
+    }
+
+    /// unescape "~1" to tilde and "~0" to slash (order is important!)
+    static void unescape(std::string& s)
+    {
+        replace_substring(s, "~1", "/");
+        replace_substring(s, "~0", "~");
+    }
+
+    /*!
+    @param[in] reference_string  the reference string to the current value
+    @param[in] value             the value to consider
+    @param[in,out] result        the result object to insert values to
+
+    @note Empty objects or arrays are flattened to `null`.
+    */
+    static void flatten(const std::string& reference_string,
+                        const BasicJsonType& value,
+                        BasicJsonType& result)
+    {
+        switch (value.m_type)
+        {
+            case detail::value_t::array:
+            {
+                if (value.m_value.array->empty())
+                {
+                    // flatten empty array as null
+                    result[reference_string] = nullptr;
+                }
+                else
+                {
+                    // iterate array and use index as reference string
+                    for (std::size_t i = 0; i < value.m_value.array->size(); ++i)
+                    {
+                        flatten(reference_string + "/" + std::to_string(i),
+                                value.m_value.array->operator[](i), result);
+                    }
+                }
+                break;
+            }
+
+            case detail::value_t::object:
+            {
+                if (value.m_value.object->empty())
+                {
+                    // flatten empty object as null
+                    result[reference_string] = nullptr;
+                }
+                else
+                {
+                    // iterate object and use keys as reference string
+                    for (const auto& element : *value.m_value.object)
+                    {
+                        flatten(reference_string + "/" + escape(element.first), element.second, result);
+                    }
+                }
+                break;
+            }
+
+            default:
+            {
+                // add primitive value with its reference string
+                result[reference_string] = value;
+                break;
+            }
+        }
+    }
+
+    /*!
+    @param[in] value  flattened JSON
+
+    @return unflattened JSON
+
+    @throw parse_error.109 if array index is not a number
+    @throw type_error.314  if value is not an object
+    @throw type_error.315  if object values are not primitive
+    @throw type_error.313  if value cannot be unflattened
+    */
+    static BasicJsonType
+    unflatten(const BasicJsonType& value)
+    {
+        if (JSON_UNLIKELY(not value.is_object()))
+        {
+            JSON_THROW(detail::type_error::create(314, "only objects can be unflattened"));
+        }
+
+        BasicJsonType result;
+
+        // iterate the JSON object values
+        for (const auto& element : *value.m_value.object)
+        {
+            if (JSON_UNLIKELY(not element.second.is_primitive()))
+            {
+                JSON_THROW(detail::type_error::create(315, "values in object must be primitive"));
+            }
+
+            // assign value to reference pointed to by JSON pointer; Note that if
+            // the JSON pointer is "" (i.e., points to the whole value), function
+            // get_and_create returns a reference to result itself. An assignment
+            // will then create a primitive value.
+            json_pointer(element.first).get_and_create(result) = element.second;
+        }
+
+        return result;
+    }
+
+    friend bool operator==(json_pointer const& lhs,
+                           json_pointer const& rhs) noexcept
+    {
+        return (lhs.reference_tokens == rhs.reference_tokens);
+    }
+
+    friend bool operator!=(json_pointer const& lhs,
+                           json_pointer const& rhs) noexcept
+    {
+        return not (lhs == rhs);
+    }
+
+    /// the reference tokens
+    std::vector<std::string> reference_tokens;
+};
+}  // namespace nlohmann
+
+// #include <nlohmann/adl_serializer.hpp>
+
+
+#include <utility>
+
+// #include <nlohmann/detail/conversions/from_json.hpp>
+
+// #include <nlohmann/detail/conversions/to_json.hpp>
+
+
+namespace nlohmann
+{
+
+template<typename, typename>
+struct adl_serializer
+{
+    /*!
+    @brief convert a JSON value to any value type
+
+    This function is usually called by the `get()` function of the
+    @ref basic_json class (either explicit or via conversion operators).
+
+    @param[in] j        JSON value to read from
+    @param[in,out] val  value to write to
+    */
+    template<typename BasicJsonType, typename ValueType>
+    static auto from_json(BasicJsonType&& j, ValueType& val) noexcept(
+        noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
+    -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void())
+    {
+        ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
+    }
+
+    /*!
+    @brief convert any value type to a JSON value
+
+    This function is usually called by the constructors of the @ref basic_json
+    class.
+
+    @param[in,out] j  JSON value to write to
+    @param[in] val    value to read from
+    */
+    template <typename BasicJsonType, typename ValueType>
+    static auto to_json(BasicJsonType& j, ValueType&& val) noexcept(
+        noexcept(::nlohmann::to_json(j, std::forward<ValueType>(val))))
+    -> decltype(::nlohmann::to_json(j, std::forward<ValueType>(val)), void())
+    {
+        ::nlohmann::to_json(j, std::forward<ValueType>(val));
+    }
+};
+
+}  // namespace nlohmann
+
+
+/*!
+@brief namespace for Niels Lohmann
+@see https://github.com/nlohmann
+@since version 1.0.0
+*/
+namespace nlohmann
+{
+
+/*!
+@brief a class to store JSON values
+
+@tparam ObjectType type for JSON objects (`std::map` by default; will be used
+in @ref object_t)
+@tparam ArrayType type for JSON arrays (`std::vector` by default; will be used
+in @ref array_t)
+@tparam StringType type for JSON strings and object keys (`std::string` by
+default; will be used in @ref string_t)
+@tparam BooleanType type for JSON booleans (`bool` by default; will be used
+in @ref boolean_t)
+@tparam NumberIntegerType type for JSON integer numbers (`int64_t` by
+default; will be used in @ref number_integer_t)
+@tparam NumberUnsignedType type for JSON unsigned integer numbers (@c
+`uint64_t` by default; will be used in @ref number_unsigned_t)
+@tparam NumberFloatType type for JSON floating-point numbers (`double` by
+default; will be used in @ref number_float_t)
+@tparam AllocatorType type of the allocator to use (`std::allocator` by
+default)
+@tparam JSONSerializer the serializer to resolve internal calls to `to_json()`
+and `from_json()` (@ref adl_serializer by default)
+
+@requirement The class satisfies the following concept requirements:
+- Basic
+ - [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible):
+   JSON values can be default constructed. The result will be a JSON null
+   value.
+ - [MoveConstructible](https://en.cppreference.com/w/cpp/named_req/MoveConstructible):
+   A JSON value can be constructed from an rvalue argument.
+ - [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible):
+   A JSON value can be copy-constructed from an lvalue expression.
+ - [MoveAssignable](https://en.cppreference.com/w/cpp/named_req/MoveAssignable):
+   A JSON value van be assigned from an rvalue argument.
+ - [CopyAssignable](https://en.cppreference.com/w/cpp/named_req/CopyAssignable):
+   A JSON value can be copy-assigned from an lvalue expression.
+ - [Destructible](https://en.cppreference.com/w/cpp/named_req/Destructible):
+   JSON values can be destructed.
+- Layout
+ - [StandardLayoutType](https://en.cppreference.com/w/cpp/named_req/StandardLayoutType):
+   JSON values have
+   [standard layout](https://en.cppreference.com/w/cpp/language/data_members#Standard_layout):
+   All non-static data members are private and standard layout types, the
+   class has no virtual functions or (virtual) base classes.
+- Library-wide
+ - [EqualityComparable](https://en.cppreference.com/w/cpp/named_req/EqualityComparable):
+   JSON values can be compared with `==`, see @ref
+   operator==(const_reference,const_reference).
+ - [LessThanComparable](https://en.cppreference.com/w/cpp/named_req/LessThanComparable):
+   JSON values can be compared with `<`, see @ref
+   operator<(const_reference,const_reference).
+ - [Swappable](https://en.cppreference.com/w/cpp/named_req/Swappable):
+   Any JSON lvalue or rvalue of can be swapped with any lvalue or rvalue of
+   other compatible types, using unqualified function call @ref swap().
+ - [NullablePointer](https://en.cppreference.com/w/cpp/named_req/NullablePointer):
+   JSON values can be compared against `std::nullptr_t` objects which are used
+   to model the `null` value.
+- Container
+ - [Container](https://en.cppreference.com/w/cpp/named_req/Container):
+   JSON values can be used like STL containers and provide iterator access.
+ - [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer);
+   JSON values can be used like STL containers and provide reverse iterator
+   access.
+
+@invariant The member variables @a m_value and @a m_type have the following
+relationship:
+- If `m_type == value_t::object`, then `m_value.object != nullptr`.
+- If `m_type == value_t::array`, then `m_value.array != nullptr`.
+- If `m_type == value_t::string`, then `m_value.string != nullptr`.
+The invariants are checked by member function assert_invariant().
+
+@internal
+@note ObjectType trick from http://stackoverflow.com/a/9860911
+@endinternal
+
+@see [RFC 7159: The JavaScript Object Notation (JSON) Data Interchange
+Format](http://rfc7159.net/rfc7159)
+
+@since version 1.0.0
+
+@nosubgrouping
+*/
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+class basic_json
+{
+  private:
+    template<detail::value_t> friend struct detail::external_constructor;
+    friend ::nlohmann::json_pointer<basic_json>;
+    friend ::nlohmann::detail::parser<basic_json>;
+    friend ::nlohmann::detail::serializer<basic_json>;
+    template<typename BasicJsonType>
+    friend class ::nlohmann::detail::iter_impl;
+    template<typename BasicJsonType, typename CharType>
+    friend class ::nlohmann::detail::binary_writer;
+    template<typename BasicJsonType, typename SAX>
+    friend class ::nlohmann::detail::binary_reader;
+    template<typename BasicJsonType>
+    friend class ::nlohmann::detail::json_sax_dom_parser;
+    template<typename BasicJsonType>
+    friend class ::nlohmann::detail::json_sax_dom_callback_parser;
+
+    /// workaround type for MSVC
+    using basic_json_t = NLOHMANN_BASIC_JSON_TPL;
+
+    // convenience aliases for types residing in namespace detail;
+    using lexer = ::nlohmann::detail::lexer<basic_json>;
+    using parser = ::nlohmann::detail::parser<basic_json>;
+
+    using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;
+    template<typename BasicJsonType>
+    using internal_iterator = ::nlohmann::detail::internal_iterator<BasicJsonType>;
+    template<typename BasicJsonType>
+    using iter_impl = ::nlohmann::detail::iter_impl<BasicJsonType>;
+    template<typename Iterator>
+    using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>;
+    template<typename Base> using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>;
+
+    template<typename CharType>
+    using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>;
+
+    using binary_reader = ::nlohmann::detail::binary_reader<basic_json>;
+    template<typename CharType> using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;
+
+    using serializer = ::nlohmann::detail::serializer<basic_json>;
+
+  public:
+    using value_t = detail::value_t;
+    /// JSON Pointer, see @ref nlohmann::json_pointer
+    using json_pointer = ::nlohmann::json_pointer<basic_json>;
+    template<typename T, typename SFINAE>
+    using json_serializer = JSONSerializer<T, SFINAE>;
+    /// how to treat decoding errors
+    using error_handler_t = detail::error_handler_t;
+    /// helper type for initializer lists of basic_json values
+    using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;
+
+    using input_format_t = detail::input_format_t;
+    /// SAX interface type, see @ref nlohmann::json_sax
+    using json_sax_t = json_sax<basic_json>;
+
+    ////////////////
+    // exceptions //
+    ////////////////
+
+    /// @name exceptions
+    /// Classes to implement user-defined exceptions.
+    /// @{
+
+    /// @copydoc detail::exception
+    using exception = detail::exception;
+    /// @copydoc detail::parse_error
+    using parse_error = detail::parse_error;
+    /// @copydoc detail::invalid_iterator
+    using invalid_iterator = detail::invalid_iterator;
+    /// @copydoc detail::type_error
+    using type_error = detail::type_error;
+    /// @copydoc detail::out_of_range
+    using out_of_range = detail::out_of_range;
+    /// @copydoc detail::other_error
+    using other_error = detail::other_error;
+
+    /// @}
+
+
+    /////////////////////
+    // container types //
+    /////////////////////
+
+    /// @name container types
+    /// The canonic container types to use @ref basic_json like any other STL
+    /// container.
+    /// @{
+
+    /// the type of elements in a basic_json container
+    using value_type = basic_json;
+
+    /// the type of an element reference
+    using reference = value_type&;
+    /// the type of an element const reference
+    using const_reference = const value_type&;
+
+    /// a type to represent differences between iterators
+    using difference_type = std::ptrdiff_t;
+    /// a type to represent container sizes
+    using size_type = std::size_t;
+
+    /// the allocator type
+    using allocator_type = AllocatorType<basic_json>;
+
+    /// the type of an element pointer
+    using pointer = typename std::allocator_traits<allocator_type>::pointer;
+    /// the type of an element const pointer
+    using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
+
+    /// an iterator for a basic_json container
+    using iterator = iter_impl<basic_json>;
+    /// a const iterator for a basic_json container
+    using const_iterator = iter_impl<const basic_json>;
+    /// a reverse iterator for a basic_json container
+    using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>;
+    /// a const reverse iterator for a basic_json container
+    using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>;
+
+    /// @}
+
+
+    /*!
+    @brief returns the allocator associated with the container
+    */
+    static allocator_type get_allocator()
+    {
+        return allocator_type();
+    }
+
+    /*!
+    @brief returns version information on the library
+
+    This function returns a JSON object with information about the library,
+    including the version number and information on the platform and compiler.
+
+    @return JSON object holding version information
+    key         | description
+    ----------- | ---------------
+    `compiler`  | Information on the used compiler. It is an object with the following keys: `c++` (the used C++ standard), `family` (the compiler family; possible values are `clang`, `icc`, `gcc`, `ilecpp`, `msvc`, `pgcpp`, `sunpro`, and `unknown`), and `version` (the compiler version).
+    `copyright` | The copyright line for the library as string.
+    `name`      | The name of the library as string.
+    `platform`  | The used platform as string. Possible values are `win32`, `linux`, `apple`, `unix`, and `unknown`.
+    `url`       | The URL of the project as string.
+    `version`   | The version of the library. It is an object with the following keys: `major`, `minor`, and `patch` as defined by [Semantic Versioning](http://semver.org), and `string` (the version string).
+
+    @liveexample{The following code shows an example output of the `meta()`
+    function.,meta}
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @complexity Constant.
+
+    @since 2.1.0
+    */
+    static basic_json meta()
+    {
+        basic_json result;
+
+        result["copyright"] = "(C) 2013-2017 Niels Lohmann";
+        result["name"] = "JSON for Modern C++";
+        result["url"] = "https://github.com/nlohmann/json";
+        result["version"]["string"] =
+            std::to_string(NLOHMANN_JSON_VERSION_MAJOR) + "." +
+            std::to_string(NLOHMANN_JSON_VERSION_MINOR) + "." +
+            std::to_string(NLOHMANN_JSON_VERSION_PATCH);
+        result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR;
+        result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR;
+        result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH;
+
+#ifdef _WIN32
+        result["platform"] = "win32";
+#elif defined __linux__
+        result["platform"] = "linux";
+#elif defined __APPLE__
+        result["platform"] = "apple";
+#elif defined __unix__
+        result["platform"] = "unix";
+#else
+        result["platform"] = "unknown";
+#endif
+
+#if defined(__ICC) || defined(__INTEL_COMPILER)
+        result["compiler"] = {{"family", "icc"}, {"version", __INTEL_COMPILER}};
+#elif defined(__clang__)
+        result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}};
+#elif defined(__GNUC__) || defined(__GNUG__)
+        result["compiler"] = {{"family", "gcc"}, {"version", std::to_string(__GNUC__) + "." + std::to_string(__GNUC_MINOR__) + "." + std::to_string(__GNUC_PATCHLEVEL__)}};
+#elif defined(__HP_cc) || defined(__HP_aCC)
+        result["compiler"] = "hp"
+#elif defined(__IBMCPP__)
+        result["compiler"] = {{"family", "ilecpp"}, {"version", __IBMCPP__}};
+#elif defined(_MSC_VER)
+        result["compiler"] = {{"family", "msvc"}, {"version", _MSC_VER}};
+#elif defined(__PGI)
+        result["compiler"] = {{"family", "pgcpp"}, {"version", __PGI}};
+#elif defined(__SUNPRO_CC)
+        result["compiler"] = {{"family", "sunpro"}, {"version", __SUNPRO_CC}};
+#else
+        result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};
+#endif
+
+#ifdef __cplusplus
+        result["compiler"]["c++"] = std::to_string(__cplusplus);
+#else
+        result["compiler"]["c++"] = "unknown";
+#endif
+        return result;
+    }
+
+
+    ///////////////////////////
+    // JSON value data types //
+    ///////////////////////////
+
+    /// @name JSON value data types
+    /// The data types to store a JSON value. These types are derived from
+    /// the template arguments passed to class @ref basic_json.
+    /// @{
+
+#if defined(JSON_HAS_CPP_14)
+    // Use transparent comparator if possible, combined with perfect forwarding
+    // on find() and count() calls prevents unnecessary string construction.
+    using object_comparator_t = std::less<>;
+#else
+    using object_comparator_t = std::less<StringType>;
+#endif
+
+    /*!
+    @brief a type for an object
+
+    [RFC 7159](http://rfc7159.net/rfc7159) describes JSON objects as follows:
+    > An object is an unordered collection of zero or more name/value pairs,
+    > where a name is a string and a value is a string, number, boolean, null,
+    > object, or array.
+
+    To store objects in C++, a type is defined by the template parameters
+    described below.
+
+    @tparam ObjectType  the container to store objects (e.g., `std::map` or
+    `std::unordered_map`)
+    @tparam StringType the type of the keys or names (e.g., `std::string`).
+    The comparison function `std::less<StringType>` is used to order elements
+    inside the container.
+    @tparam AllocatorType the allocator to use for objects (e.g.,
+    `std::allocator`)
+
+    #### Default type
+
+    With the default values for @a ObjectType (`std::map`), @a StringType
+    (`std::string`), and @a AllocatorType (`std::allocator`), the default
+    value for @a object_t is:
+
+    @code {.cpp}
+    std::map<
+      std::string, // key_type
+      basic_json, // value_type
+      std::less<std::string>, // key_compare
+      std::allocator<std::pair<const std::string, basic_json>> // allocator_type
+    >
+    @endcode
+
+    #### Behavior
+
+    The choice of @a object_t influences the behavior of the JSON class. With
+    the default type, objects have the following behavior:
+
+    - When all names are unique, objects will be interoperable in the sense
+      that all software implementations receiving that object will agree on
+      the name-value mappings.
+    - When the names within an object are not unique, it is unspecified which
+      one of the values for a given key will be chosen. For instance,
+      `{"key": 2, "key": 1}` could be equal to either `{"key": 1}` or
+      `{"key": 2}`.
+    - Internally, name/value pairs are stored in lexicographical order of the
+      names. Objects will also be serialized (see @ref dump) in this order.
+      For instance, `{"b": 1, "a": 2}` and `{"a": 2, "b": 1}` will be stored
+      and serialized as `{"a": 2, "b": 1}`.
+    - When comparing objects, the order of the name/value pairs is irrelevant.
+      This makes objects interoperable in the sense that they will not be
+      affected by these differences. For instance, `{"b": 1, "a": 2}` and
+      `{"a": 2, "b": 1}` will be treated as equal.
+
+    #### Limits
+
+    [RFC 7159](http://rfc7159.net/rfc7159) specifies:
+    > An implementation may set limits on the maximum depth of nesting.
+
+    In this class, the object's limit of nesting is not explicitly constrained.
+    However, a maximum depth of nesting may be introduced by the compiler or
+    runtime environment. A theoretical limit can be queried by calling the
+    @ref max_size function of a JSON object.
+
+    #### Storage
+
+    Objects are stored as pointers in a @ref basic_json type. That is, for any
+    access to object values, a pointer of type `object_t*` must be
+    dereferenced.
+
+    @sa @ref array_t -- type for an array value
+
+    @since version 1.0.0
+
+    @note The order name/value pairs are added to the object is *not*
+    preserved by the library. Therefore, iterating an object may return
+    name/value pairs in a different order than they were originally stored. In
+    fact, keys will be traversed in alphabetical order as `std::map` with
+    `std::less` is used by default. Please note this behavior conforms to [RFC
+    7159](http://rfc7159.net/rfc7159), because any order implements the
+    specified "unordered" nature of JSON objects.
+    */
+    using object_t = ObjectType<StringType,
+          basic_json,
+          object_comparator_t,
+          AllocatorType<std::pair<const StringType,
+          basic_json>>>;
+
+    /*!
+    @brief a type for an array
+
+    [RFC 7159](http://rfc7159.net/rfc7159) describes JSON arrays as follows:
+    > An array is an ordered sequence of zero or more values.
+
+    To store objects in C++, a type is defined by the template parameters
+    explained below.
+
+    @tparam ArrayType  container type to store arrays (e.g., `std::vector` or
+    `std::list`)
+    @tparam AllocatorType allocator to use for arrays (e.g., `std::allocator`)
+
+    #### Default type
+
+    With the default values for @a ArrayType (`std::vector`) and @a
+    AllocatorType (`std::allocator`), the default value for @a array_t is:
+
+    @code {.cpp}
+    std::vector<
+      basic_json, // value_type
+      std::allocator<basic_json> // allocator_type
+    >
+    @endcode
+
+    #### Limits
+
+    [RFC 7159](http://rfc7159.net/rfc7159) specifies:
+    > An implementation may set limits on the maximum depth of nesting.
+
+    In this class, the array's limit of nesting is not explicitly constrained.
+    However, a maximum depth of nesting may be introduced by the compiler or
+    runtime environment. A theoretical limit can be queried by calling the
+    @ref max_size function of a JSON array.
+
+    #### Storage
+
+    Arrays are stored as pointers in a @ref basic_json type. That is, for any
+    access to array values, a pointer of type `array_t*` must be dereferenced.
+
+    @sa @ref object_t -- type for an object value
+
+    @since version 1.0.0
+    */
+    using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
+
+    /*!
+    @brief a type for a string
+
+    [RFC 7159](http://rfc7159.net/rfc7159) describes JSON strings as follows:
+    > A string is a sequence of zero or more Unicode characters.
+
+    To store objects in C++, a type is defined by the template parameter
+    described below. Unicode values are split by the JSON class into
+    byte-sized characters during deserialization.
+
+    @tparam StringType  the container to store strings (e.g., `std::string`).
+    Note this container is used for keys/names in objects, see @ref object_t.
+
+    #### Default type
+
+    With the default values for @a StringType (`std::string`), the default
+    value for @a string_t is:
+
+    @code {.cpp}
+    std::string
+    @endcode
+
+    #### Encoding
+
+    Strings are stored in UTF-8 encoding. Therefore, functions like
+    `std::string::size()` or `std::string::length()` return the number of
+    bytes in the string rather than the number of characters or glyphs.
+
+    #### String comparison
+
+    [RFC 7159](http://rfc7159.net/rfc7159) states:
+    > Software implementations are typically required to test names of object
+    > members for equality. Implementations that transform the textual
+    > representation into sequences of Unicode code units and then perform the
+    > comparison numerically, code unit by code unit, are interoperable in the
+    > sense that implementations will agree in all cases on equality or
+    > inequality of two strings. For example, implementations that compare
+    > strings with escaped characters unconverted may incorrectly find that
+    > `"a\\b"` and `"a\u005Cb"` are not equal.
+
+    This implementation is interoperable as it does compare strings code unit
+    by code unit.
+
+    #### Storage
+
+    String values are stored as pointers in a @ref basic_json type. That is,
+    for any access to string values, a pointer of type `string_t*` must be
+    dereferenced.
+
+    @since version 1.0.0
+    */
+    using string_t = StringType;
+
+    /*!
+    @brief a type for a boolean
+
+    [RFC 7159](http://rfc7159.net/rfc7159) implicitly describes a boolean as a
+    type which differentiates the two literals `true` and `false`.
+
+    To store objects in C++, a type is defined by the template parameter @a
+    BooleanType which chooses the type to use.
+
+    #### Default type
+
+    With the default values for @a BooleanType (`bool`), the default value for
+    @a boolean_t is:
+
+    @code {.cpp}
+    bool
+    @endcode
+
+    #### Storage
+
+    Boolean values are stored directly inside a @ref basic_json type.
+
+    @since version 1.0.0
+    */
+    using boolean_t = BooleanType;
+
+    /*!
+    @brief a type for a number (integer)
+
+    [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
+    > The representation of numbers is similar to that used in most
+    > programming languages. A number is represented in base 10 using decimal
+    > digits. It contains an integer component that may be prefixed with an
+    > optional minus sign, which may be followed by a fraction part and/or an
+    > exponent part. Leading zeros are not allowed. (...) Numeric values that
+    > cannot be represented in the grammar below (such as Infinity and NaN)
+    > are not permitted.
+
+    This description includes both integer and floating-point numbers.
+    However, C++ allows more precise storage if it is known whether the number
+    is a signed integer, an unsigned integer or a floating-point number.
+    Therefore, three different types, @ref number_integer_t, @ref
+    number_unsigned_t and @ref number_float_t are used.
+
+    To store integer numbers in C++, a type is defined by the template
+    parameter @a NumberIntegerType which chooses the type to use.
+
+    #### Default type
+
+    With the default values for @a NumberIntegerType (`int64_t`), the default
+    value for @a number_integer_t is:
+
+    @code {.cpp}
+    int64_t
+    @endcode
+
+    #### Default behavior
+
+    - The restrictions about leading zeros is not enforced in C++. Instead,
+      leading zeros in integer literals lead to an interpretation as octal
+      number. Internally, the value will be stored as decimal number. For
+      instance, the C++ integer literal `010` will be serialized to `8`.
+      During deserialization, leading zeros yield an error.
+    - Not-a-number (NaN) values will be serialized to `null`.
+
+    #### Limits
+
+    [RFC 7159](http://rfc7159.net/rfc7159) specifies:
+    > An implementation may set limits on the range and precision of numbers.
+
+    When the default type is used, the maximal integer number that can be
+    stored is `9223372036854775807` (INT64_MAX) and the minimal integer number
+    that can be stored is `-9223372036854775808` (INT64_MIN). Integer numbers
+    that are out of range will yield over/underflow when used in a
+    constructor. During deserialization, too large or small integer numbers
+    will be automatically be stored as @ref number_unsigned_t or @ref
+    number_float_t.
+
+    [RFC 7159](http://rfc7159.net/rfc7159) further states:
+    > Note that when such software is used, numbers that are integers and are
+    > in the range \f$[-2^{53}+1, 2^{53}-1]\f$ are interoperable in the sense
+    > that implementations will agree exactly on their numeric values.
+
+    As this range is a subrange of the exactly supported range [INT64_MIN,
+    INT64_MAX], this class's integer type is interoperable.
+
+    #### Storage
+
+    Integer number values are stored directly inside a @ref basic_json type.
+
+    @sa @ref number_float_t -- type for number values (floating-point)
+
+    @sa @ref number_unsigned_t -- type for number values (unsigned integer)
+
+    @since version 1.0.0
+    */
+    using number_integer_t = NumberIntegerType;
+
+    /*!
+    @brief a type for a number (unsigned)
+
+    [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
+    > The representation of numbers is similar to that used in most
+    > programming languages. A number is represented in base 10 using decimal
+    > digits. It contains an integer component that may be prefixed with an
+    > optional minus sign, which may be followed by a fraction part and/or an
+    > exponent part. Leading zeros are not allowed. (...) Numeric values that
+    > cannot be represented in the grammar below (such as Infinity and NaN)
+    > are not permitted.
+
+    This description includes both integer and floating-point numbers.
+    However, C++ allows more precise storage if it is known whether the number
+    is a signed integer, an unsigned integer or a floating-point number.
+    Therefore, three different types, @ref number_integer_t, @ref
+    number_unsigned_t and @ref number_float_t are used.
+
+    To store unsigned integer numbers in C++, a type is defined by the
+    template parameter @a NumberUnsignedType which chooses the type to use.
+
+    #### Default type
+
+    With the default values for @a NumberUnsignedType (`uint64_t`), the
+    default value for @a number_unsigned_t is:
+
+    @code {.cpp}
+    uint64_t
+    @endcode
+
+    #### Default behavior
+
+    - The restrictions about leading zeros is not enforced in C++. Instead,
+      leading zeros in integer literals lead to an interpretation as octal
+      number. Internally, the value will be stored as decimal number. For
+      instance, the C++ integer literal `010` will be serialized to `8`.
+      During deserialization, leading zeros yield an error.
+    - Not-a-number (NaN) values will be serialized to `null`.
+
+    #### Limits
+
+    [RFC 7159](http://rfc7159.net/rfc7159) specifies:
+    > An implementation may set limits on the range and precision of numbers.
+
+    When the default type is used, the maximal integer number that can be
+    stored is `18446744073709551615` (UINT64_MAX) and the minimal integer
+    number that can be stored is `0`. Integer numbers that are out of range
+    will yield over/underflow when used in a constructor. During
+    deserialization, too large or small integer numbers will be automatically
+    be stored as @ref number_integer_t or @ref number_float_t.
+
+    [RFC 7159](http://rfc7159.net/rfc7159) further states:
+    > Note that when such software is used, numbers that are integers and are
+    > in the range \f$[-2^{53}+1, 2^{53}-1]\f$ are interoperable in the sense
+    > that implementations will agree exactly on their numeric values.
+
+    As this range is a subrange (when considered in conjunction with the
+    number_integer_t type) of the exactly supported range [0, UINT64_MAX],
+    this class's integer type is interoperable.
+
+    #### Storage
+
+    Integer number values are stored directly inside a @ref basic_json type.
+
+    @sa @ref number_float_t -- type for number values (floating-point)
+    @sa @ref number_integer_t -- type for number values (integer)
+
+    @since version 2.0.0
+    */
+    using number_unsigned_t = NumberUnsignedType;
+
+    /*!
+    @brief a type for a number (floating-point)
+
+    [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
+    > The representation of numbers is similar to that used in most
+    > programming languages. A number is represented in base 10 using decimal
+    > digits. It contains an integer component that may be prefixed with an
+    > optional minus sign, which may be followed by a fraction part and/or an
+    > exponent part. Leading zeros are not allowed. (...) Numeric values that
+    > cannot be represented in the grammar below (such as Infinity and NaN)
+    > are not permitted.
+
+    This description includes both integer and floating-point numbers.
+    However, C++ allows more precise storage if it is known whether the number
+    is a signed integer, an unsigned integer or a floating-point number.
+    Therefore, three different types, @ref number_integer_t, @ref
+    number_unsigned_t and @ref number_float_t are used.
+
+    To store floating-point numbers in C++, a type is defined by the template
+    parameter @a NumberFloatType which chooses the type to use.
+
+    #### Default type
+
+    With the default values for @a NumberFloatType (`double`), the default
+    value for @a number_float_t is:
+
+    @code {.cpp}
+    double
+    @endcode
+
+    #### Default behavior
+
+    - The restrictions about leading zeros is not enforced in C++. Instead,
+      leading zeros in floating-point literals will be ignored. Internally,
+      the value will be stored as decimal number. For instance, the C++
+      floating-point literal `01.2` will be serialized to `1.2`. During
+      deserialization, leading zeros yield an error.
+    - Not-a-number (NaN) values will be serialized to `null`.
+
+    #### Limits
+
+    [RFC 7159](http://rfc7159.net/rfc7159) states:
+    > This specification allows implementations to set limits on the range and
+    > precision of numbers accepted. Since software that implements IEEE
+    > 754-2008 binary64 (double precision) numbers is generally available and
+    > widely used, good interoperability can be achieved by implementations
+    > that expect no more precision or range than these provide, in the sense
+    > that implementations will approximate JSON numbers within the expected
+    > precision.
+
+    This implementation does exactly follow this approach, as it uses double
+    precision floating-point numbers. Note values smaller than
+    `-1.79769313486232e+308` and values greater than `1.79769313486232e+308`
+    will be stored as NaN internally and be serialized to `null`.
+
+    #### Storage
+
+    Floating-point number values are stored directly inside a @ref basic_json
+    type.
+
+    @sa @ref number_integer_t -- type for number values (integer)
+
+    @sa @ref number_unsigned_t -- type for number values (unsigned integer)
+
+    @since version 1.0.0
+    */
+    using number_float_t = NumberFloatType;
+
+    /// @}
+
+  private:
+
+    /// helper for exception-safe object creation
+    template<typename T, typename... Args>
+    static T* create(Args&& ... args)
+    {
+        AllocatorType<T> alloc;
+        using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
+
+        auto deleter = [&](T * object)
+        {
+            AllocatorTraits::deallocate(alloc, object, 1);
+        };
+        std::unique_ptr<T, decltype(deleter)> object(AllocatorTraits::allocate(alloc, 1), deleter);
+        AllocatorTraits::construct(alloc, object.get(), std::forward<Args>(args)...);
+        assert(object != nullptr);
+        return object.release();
+    }
+
+    ////////////////////////
+    // JSON value storage //
+    ////////////////////////
+
+    /*!
+    @brief a JSON value
+
+    The actual storage for a JSON value of the @ref basic_json class. This
+    union combines the different storage types for the JSON value types
+    defined in @ref value_t.
+
+    JSON type | value_t type    | used type
+    --------- | --------------- | ------------------------
+    object    | object          | pointer to @ref object_t
+    array     | array           | pointer to @ref array_t
+    string    | string          | pointer to @ref string_t
+    boolean   | boolean         | @ref boolean_t
+    number    | number_integer  | @ref number_integer_t
+    number    | number_unsigned | @ref number_unsigned_t
+    number    | number_float    | @ref number_float_t
+    null      | null            | *no value is stored*
+
+    @note Variable-length types (objects, arrays, and strings) are stored as
+    pointers. The size of the union should not exceed 64 bits if the default
+    value types are used.
+
+    @since version 1.0.0
+    */
+    union json_value
+    {
+        /// object (stored with pointer to save storage)
+        object_t* object;
+        /// array (stored with pointer to save storage)
+        array_t* array;
+        /// string (stored with pointer to save storage)
+        string_t* string;
+        /// boolean
+        boolean_t boolean;
+        /// number (integer)
+        number_integer_t number_integer;
+        /// number (unsigned integer)
+        number_unsigned_t number_unsigned;
+        /// number (floating-point)
+        number_float_t number_float;
+
+        /// default constructor (for null values)
+        json_value() = default;
+        /// constructor for booleans
+        json_value(boolean_t v) noexcept : boolean(v) {}
+        /// constructor for numbers (integer)
+        json_value(number_integer_t v) noexcept : number_integer(v) {}
+        /// constructor for numbers (unsigned)
+        json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}
+        /// constructor for numbers (floating-point)
+        json_value(number_float_t v) noexcept : number_float(v) {}
+        /// constructor for empty values of a given type
+        json_value(value_t t)
+        {
+            switch (t)
+            {
+                case value_t::object:
+                {
+                    object = create<object_t>();
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    array = create<array_t>();
+                    break;
+                }
+
+                case value_t::string:
+                {
+                    string = create<string_t>("");
+                    break;
+                }
+
+                case value_t::boolean:
+                {
+                    boolean = boolean_t(false);
+                    break;
+                }
+
+                case value_t::number_integer:
+                {
+                    number_integer = number_integer_t(0);
+                    break;
+                }
+
+                case value_t::number_unsigned:
+                {
+                    number_unsigned = number_unsigned_t(0);
+                    break;
+                }
+
+                case value_t::number_float:
+                {
+                    number_float = number_float_t(0.0);
+                    break;
+                }
+
+                case value_t::null:
+                {
+                    object = nullptr;  // silence warning, see #821
+                    break;
+                }
+
+                default:
+                {
+                    object = nullptr;  // silence warning, see #821
+                    if (JSON_UNLIKELY(t == value_t::null))
+                    {
+                        JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.5.0")); // LCOV_EXCL_LINE
+                    }
+                    break;
+                }
+            }
+        }
+
+        /// constructor for strings
+        json_value(const string_t& value)
+        {
+            string = create<string_t>(value);
+        }
+
+        /// constructor for rvalue strings
+        json_value(string_t&& value)
+        {
+            string = create<string_t>(std::move(value));
+        }
+
+        /// constructor for objects
+        json_value(const object_t& value)
+        {
+            object = create<object_t>(value);
+        }
+
+        /// constructor for rvalue objects
+        json_value(object_t&& value)
+        {
+            object = create<object_t>(std::move(value));
+        }
+
+        /// constructor for arrays
+        json_value(const array_t& value)
+        {
+            array = create<array_t>(value);
+        }
+
+        /// constructor for rvalue arrays
+        json_value(array_t&& value)
+        {
+            array = create<array_t>(std::move(value));
+        }
+
+        void destroy(value_t t) noexcept
+        {
+            switch (t)
+            {
+                case value_t::object:
+                {
+                    AllocatorType<object_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    AllocatorType<array_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
+                    break;
+                }
+
+                case value_t::string:
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
+                    break;
+                }
+
+                default:
+                {
+                    break;
+                }
+            }
+        }
+    };
+
+    /*!
+    @brief checks the class invariants
+
+    This function asserts the class invariants. It needs to be called at the
+    end of every constructor to make sure that created objects respect the
+    invariant. Furthermore, it has to be called each time the type of a JSON
+    value is changed, because the invariant expresses a relationship between
+    @a m_type and @a m_value.
+    */
+    void assert_invariant() const noexcept
+    {
+        assert(m_type != value_t::object or m_value.object != nullptr);
+        assert(m_type != value_t::array or m_value.array != nullptr);
+        assert(m_type != value_t::string or m_value.string != nullptr);
+    }
+
+  public:
+    //////////////////////////
+    // JSON parser callback //
+    //////////////////////////
+
+    /*!
+    @brief parser event types
+
+    The parser callback distinguishes the following events:
+    - `object_start`: the parser read `{` and started to process a JSON object
+    - `key`: the parser read a key of a value in an object
+    - `object_end`: the parser read `}` and finished processing a JSON object
+    - `array_start`: the parser read `[` and started to process a JSON array
+    - `array_end`: the parser read `]` and finished processing a JSON array
+    - `value`: the parser finished reading a JSON value
+
+    @image html callback_events.png "Example when certain parse events are triggered"
+
+    @sa @ref parser_callback_t for more information and examples
+    */
+    using parse_event_t = typename parser::parse_event_t;
+
+    /*!
+    @brief per-element parser callback type
+
+    With a parser callback function, the result of parsing a JSON text can be
+    influenced. When passed to @ref parse, it is called on certain events
+    (passed as @ref parse_event_t via parameter @a event) with a set recursion
+    depth @a depth and context JSON value @a parsed. The return value of the
+    callback function is a boolean indicating whether the element that emitted
+    the callback shall be kept or not.
+
+    We distinguish six scenarios (determined by the event type) in which the
+    callback function can be called. The following table describes the values
+    of the parameters @a depth, @a event, and @a parsed.
+
+    parameter @a event | description | parameter @a depth | parameter @a parsed
+    ------------------ | ----------- | ------------------ | -------------------
+    parse_event_t::object_start | the parser read `{` and started to process a JSON object | depth of the parent of the JSON object | a JSON value with type discarded
+    parse_event_t::key | the parser read a key of a value in an object | depth of the currently parsed JSON object | a JSON string containing the key
+    parse_event_t::object_end | the parser read `}` and finished processing a JSON object | depth of the parent of the JSON object | the parsed JSON object
+    parse_event_t::array_start | the parser read `[` and started to process a JSON array | depth of the parent of the JSON array | a JSON value with type discarded
+    parse_event_t::array_end | the parser read `]` and finished processing a JSON array | depth of the parent of the JSON array | the parsed JSON array
+    parse_event_t::value | the parser finished reading a JSON value | depth of the value | the parsed JSON value
+
+    @image html callback_events.png "Example when certain parse events are triggered"
+
+    Discarding a value (i.e., returning `false`) has different effects
+    depending on the context in which function was called:
+
+    - Discarded values in structured types are skipped. That is, the parser
+      will behave as if the discarded value was never read.
+    - In case a value outside a structured type is skipped, it is replaced
+      with `null`. This case happens if the top-level element is skipped.
+
+    @param[in] depth  the depth of the recursion during parsing
+
+    @param[in] event  an event of type parse_event_t indicating the context in
+    the callback function has been called
+
+    @param[in,out] parsed  the current intermediate parse result; note that
+    writing to this value has no effect for parse_event_t::key events
+
+    @return Whether the JSON value which called the function during parsing
+    should be kept (`true`) or not (`false`). In the latter case, it is either
+    skipped completely or replaced by an empty discarded object.
+
+    @sa @ref parse for examples
+
+    @since version 1.0.0
+    */
+    using parser_callback_t = typename parser::parser_callback_t;
+
+    //////////////////
+    // constructors //
+    //////////////////
+
+    /// @name constructors and destructors
+    /// Constructors of class @ref basic_json, copy/move constructor, copy
+    /// assignment, static functions creating objects, and the destructor.
+    /// @{
+
+    /*!
+    @brief create an empty value with a given type
+
+    Create an empty JSON value with a given type. The value will be default
+    initialized with an empty value which depends on the type:
+
+    Value type  | initial value
+    ----------- | -------------
+    null        | `null`
+    boolean     | `false`
+    string      | `""`
+    number      | `0`
+    object      | `{}`
+    array       | `[]`
+
+    @param[in] v  the type of the value to create
+
+    @complexity Constant.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @liveexample{The following code shows the constructor for different @ref
+    value_t values,basic_json__value_t}
+
+    @sa @ref clear() -- restores the postcondition of this constructor
+
+    @since version 1.0.0
+    */
+    basic_json(const value_t v)
+        : m_type(v), m_value(v)
+    {
+        assert_invariant();
+    }
+
+    /*!
+    @brief create a null object
+
+    Create a `null` JSON value. It either takes a null pointer as parameter
+    (explicitly creating `null`) or no parameter (implicitly creating `null`).
+    The passed null pointer itself is not read -- it is only used to choose
+    the right constructor.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this constructor never throws
+    exceptions.
+
+    @liveexample{The following code shows the constructor with and without a
+    null pointer parameter.,basic_json__nullptr_t}
+
+    @since version 1.0.0
+    */
+    basic_json(std::nullptr_t = nullptr) noexcept
+        : basic_json(value_t::null)
+    {
+        assert_invariant();
+    }
+
+    /*!
+    @brief create a JSON value
+
+    This is a "catch all" constructor for all compatible JSON types; that is,
+    types for which a `to_json()` method exists. The constructor forwards the
+    parameter @a val to that method (to `json_serializer<U>::to_json` method
+    with `U = uncvref_t<CompatibleType>`, to be exact).
+
+    Template type @a CompatibleType includes, but is not limited to, the
+    following types:
+    - **arrays**: @ref array_t and all kinds of compatible containers such as
+      `std::vector`, `std::deque`, `std::list`, `std::forward_list`,
+      `std::array`, `std::valarray`, `std::set`, `std::unordered_set`,
+      `std::multiset`, and `std::unordered_multiset` with a `value_type` from
+      which a @ref basic_json value can be constructed.
+    - **objects**: @ref object_t and all kinds of compatible associative
+      containers such as `std::map`, `std::unordered_map`, `std::multimap`,
+      and `std::unordered_multimap` with a `key_type` compatible to
+      @ref string_t and a `value_type` from which a @ref basic_json value can
+      be constructed.
+    - **strings**: @ref string_t, string literals, and all compatible string
+      containers can be used.
+    - **numbers**: @ref number_integer_t, @ref number_unsigned_t,
+      @ref number_float_t, and all convertible number types such as `int`,
+      `size_t`, `int64_t`, `float` or `double` can be used.
+    - **boolean**: @ref boolean_t / `bool` can be used.
+
+    See the examples below.
+
+    @tparam CompatibleType a type such that:
+    - @a CompatibleType is not derived from `std::istream`,
+    - @a CompatibleType is not @ref basic_json (to avoid hijacking copy/move
+         constructors),
+    - @a CompatibleType is not a different @ref basic_json type (i.e. with different template arguments)
+    - @a CompatibleType is not a @ref basic_json nested type (e.g.,
+         @ref json_pointer, @ref iterator, etc ...)
+    - @ref @ref json_serializer<U> has a
+         `to_json(basic_json_t&, CompatibleType&&)` method
+
+    @tparam U = `uncvref_t<CompatibleType>`
+
+    @param[in] val the value to be forwarded to the respective constructor
+
+    @complexity Usually linear in the size of the passed @a val, also
+                depending on the implementation of the called `to_json()`
+                method.
+
+    @exceptionsafety Depends on the called constructor. For types directly
+    supported by the library (i.e., all types for which no `to_json()` function
+    was provided), strong guarantee holds: if an exception is thrown, there are
+    no changes to any JSON value.
+
+    @liveexample{The following code shows the constructor with several
+    compatible types.,basic_json__CompatibleType}
+
+    @since version 2.1.0
+    */
+    template <typename CompatibleType,
+              typename U = detail::uncvref_t<CompatibleType>,
+              detail::enable_if_t<
+                  not detail::is_basic_json<U>::value and detail::is_compatible_type<basic_json_t, U>::value, int> = 0>
+    basic_json(CompatibleType && val) noexcept(noexcept(
+                JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
+                                           std::forward<CompatibleType>(val))))
+    {
+        JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
+        assert_invariant();
+    }
+
+    /*!
+    @brief create a JSON value from an existing one
+
+    This is a constructor for existing @ref basic_json types.
+    It does not hijack copy/move constructors, since the parameter has different
+    template arguments than the current ones.
+
+    The constructor tries to convert the internal @ref m_value of the parameter.
+
+    @tparam BasicJsonType a type such that:
+    - @a BasicJsonType is a @ref basic_json type.
+    - @a BasicJsonType has different template arguments than @ref basic_json_t.
+
+    @param[in] val the @ref basic_json value to be converted.
+
+    @complexity Usually linear in the size of the passed @a val, also
+                depending on the implementation of the called `to_json()`
+                method.
+
+    @exceptionsafety Depends on the called constructor. For types directly
+    supported by the library (i.e., all types for which no `to_json()` function
+    was provided), strong guarantee holds: if an exception is thrown, there are
+    no changes to any JSON value.
+
+    @since version 3.2.0
+    */
+    template <typename BasicJsonType,
+              detail::enable_if_t<
+                  detail::is_basic_json<BasicJsonType>::value and not std::is_same<basic_json, BasicJsonType>::value, int> = 0>
+    basic_json(const BasicJsonType& val)
+    {
+        using other_boolean_t = typename BasicJsonType::boolean_t;
+        using other_number_float_t = typename BasicJsonType::number_float_t;
+        using other_number_integer_t = typename BasicJsonType::number_integer_t;
+        using other_number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+        using other_string_t = typename BasicJsonType::string_t;
+        using other_object_t = typename BasicJsonType::object_t;
+        using other_array_t = typename BasicJsonType::array_t;
+
+        switch (val.type())
+        {
+            case value_t::boolean:
+                JSONSerializer<other_boolean_t>::to_json(*this, val.template get<other_boolean_t>());
+                break;
+            case value_t::number_float:
+                JSONSerializer<other_number_float_t>::to_json(*this, val.template get<other_number_float_t>());
+                break;
+            case value_t::number_integer:
+                JSONSerializer<other_number_integer_t>::to_json(*this, val.template get<other_number_integer_t>());
+                break;
+            case value_t::number_unsigned:
+                JSONSerializer<other_number_unsigned_t>::to_json(*this, val.template get<other_number_unsigned_t>());
+                break;
+            case value_t::string:
+                JSONSerializer<other_string_t>::to_json(*this, val.template get_ref<const other_string_t&>());
+                break;
+            case value_t::object:
+                JSONSerializer<other_object_t>::to_json(*this, val.template get_ref<const other_object_t&>());
+                break;
+            case value_t::array:
+                JSONSerializer<other_array_t>::to_json(*this, val.template get_ref<const other_array_t&>());
+                break;
+            case value_t::null:
+                *this = nullptr;
+                break;
+            case value_t::discarded:
+                m_type = value_t::discarded;
+                break;
+        }
+        assert_invariant();
+    }
+
+    /*!
+    @brief create a container (array or object) from an initializer list
+
+    Creates a JSON value of type array or object from the passed initializer
+    list @a init. In case @a type_deduction is `true` (default), the type of
+    the JSON value to be created is deducted from the initializer list @a init
+    according to the following rules:
+
+    1. If the list is empty, an empty JSON object value `{}` is created.
+    2. If the list consists of pairs whose first element is a string, a JSON
+       object value is created where the first elements of the pairs are
+       treated as keys and the second elements are as values.
+    3. In all other cases, an array is created.
+
+    The rules aim to create the best fit between a C++ initializer list and
+    JSON values. The rationale is as follows:
+
+    1. The empty initializer list is written as `{}` which is exactly an empty
+       JSON object.
+    2. C++ has no way of describing mapped types other than to list a list of
+       pairs. As JSON requires that keys must be of type string, rule 2 is the
+       weakest constraint one can pose on initializer lists to interpret them
+       as an object.
+    3. In all other cases, the initializer list could not be interpreted as
+       JSON object type, so interpreting it as JSON array type is safe.
+
+    With the rules described above, the following JSON values cannot be
+    expressed by an initializer list:
+
+    - the empty array (`[]`): use @ref array(initializer_list_t)
+      with an empty initializer list in this case
+    - arrays whose elements satisfy rule 2: use @ref
+      array(initializer_list_t) with the same initializer list
+      in this case
+
+    @note When used without parentheses around an empty initializer list, @ref
+    basic_json() is called instead of this function, yielding the JSON null
+    value.
+
+    @param[in] init  initializer list with JSON values
+
+    @param[in] type_deduction internal parameter; when set to `true`, the type
+    of the JSON value is deducted from the initializer list @a init; when set
+    to `false`, the type provided via @a manual_type is forced. This mode is
+    used by the functions @ref array(initializer_list_t) and
+    @ref object(initializer_list_t).
+
+    @param[in] manual_type internal parameter; when @a type_deduction is set
+    to `false`, the created JSON value will use the provided type (only @ref
+    value_t::array and @ref value_t::object are valid); when @a type_deduction
+    is set to `true`, this parameter has no effect
+
+    @throw type_error.301 if @a type_deduction is `false`, @a manual_type is
+    `value_t::object`, but @a init contains an element which is not a pair
+    whose first element is a string. In this case, the constructor could not
+    create an object. If @a type_deduction would have be `true`, an array
+    would have been created. See @ref object(initializer_list_t)
+    for an example.
+
+    @complexity Linear in the size of the initializer list @a init.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @liveexample{The example below shows how JSON values are created from
+    initializer lists.,basic_json__list_init_t}
+
+    @sa @ref array(initializer_list_t) -- create a JSON array
+    value from an initializer list
+    @sa @ref object(initializer_list_t) -- create a JSON object
+    value from an initializer list
+
+    @since version 1.0.0
+    */
+    basic_json(initializer_list_t init,
+               bool type_deduction = true,
+               value_t manual_type = value_t::array)
+    {
+        // check if each element is an array with two elements whose first
+        // element is a string
+        bool is_an_object = std::all_of(init.begin(), init.end(),
+                                        [](const detail::json_ref<basic_json>& element_ref)
+        {
+            return (element_ref->is_array() and element_ref->size() == 2 and (*element_ref)[0].is_string());
+        });
+
+        // adjust type if type deduction is not wanted
+        if (not type_deduction)
+        {
+            // if array is wanted, do not create an object though possible
+            if (manual_type == value_t::array)
+            {
+                is_an_object = false;
+            }
+
+            // if object is wanted but impossible, throw an exception
+            if (JSON_UNLIKELY(manual_type == value_t::object and not is_an_object))
+            {
+                JSON_THROW(type_error::create(301, "cannot create object from initializer list"));
+            }
+        }
+
+        if (is_an_object)
+        {
+            // the initializer list is a list of pairs -> create object
+            m_type = value_t::object;
+            m_value = value_t::object;
+
+            std::for_each(init.begin(), init.end(), [this](const detail::json_ref<basic_json>& element_ref)
+            {
+                auto element = element_ref.moved_or_copied();
+                m_value.object->emplace(
+                    std::move(*((*element.m_value.array)[0].m_value.string)),
+                    std::move((*element.m_value.array)[1]));
+            });
+        }
+        else
+        {
+            // the initializer list describes an array -> create array
+            m_type = value_t::array;
+            m_value.array = create<array_t>(init.begin(), init.end());
+        }
+
+        assert_invariant();
+    }
+
+    /*!
+    @brief explicitly create an array from an initializer list
+
+    Creates a JSON array value from a given initializer list. That is, given a
+    list of values `a, b, c`, creates the JSON value `[a, b, c]`. If the
+    initializer list is empty, the empty array `[]` is created.
+
+    @note This function is only needed to express two edge cases that cannot
+    be realized with the initializer list constructor (@ref
+    basic_json(initializer_list_t, bool, value_t)). These cases
+    are:
+    1. creating an array whose elements are all pairs whose first element is a
+    string -- in this case, the initializer list constructor would create an
+    object, taking the first elements as keys
+    2. creating an empty array -- passing the empty initializer list to the
+    initializer list constructor yields an empty object
+
+    @param[in] init  initializer list with JSON values to create an array from
+    (optional)
+
+    @return JSON array value
+
+    @complexity Linear in the size of @a init.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @liveexample{The following code shows an example for the `array`
+    function.,array}
+
+    @sa @ref basic_json(initializer_list_t, bool, value_t) --
+    create a JSON value from an initializer list
+    @sa @ref object(initializer_list_t) -- create a JSON object
+    value from an initializer list
+
+    @since version 1.0.0
+    */
+    static basic_json array(initializer_list_t init = {})
+    {
+        return basic_json(init, false, value_t::array);
+    }
+
+    /*!
+    @brief explicitly create an object from an initializer list
+
+    Creates a JSON object value from a given initializer list. The initializer
+    lists elements must be pairs, and their first elements must be strings. If
+    the initializer list is empty, the empty object `{}` is created.
+
+    @note This function is only added for symmetry reasons. In contrast to the
+    related function @ref array(initializer_list_t), there are
+    no cases which can only be expressed by this function. That is, any
+    initializer list @a init can also be passed to the initializer list
+    constructor @ref basic_json(initializer_list_t, bool, value_t).
+
+    @param[in] init  initializer list to create an object from (optional)
+
+    @return JSON object value
+
+    @throw type_error.301 if @a init is not a list of pairs whose first
+    elements are strings. In this case, no object can be created. When such a
+    value is passed to @ref basic_json(initializer_list_t, bool, value_t),
+    an array would have been created from the passed initializer list @a init.
+    See example below.
+
+    @complexity Linear in the size of @a init.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @liveexample{The following code shows an example for the `object`
+    function.,object}
+
+    @sa @ref basic_json(initializer_list_t, bool, value_t) --
+    create a JSON value from an initializer list
+    @sa @ref array(initializer_list_t) -- create a JSON array
+    value from an initializer list
+
+    @since version 1.0.0
+    */
+    static basic_json object(initializer_list_t init = {})
+    {
+        return basic_json(init, false, value_t::object);
+    }
+
+    /*!
+    @brief construct an array with count copies of given value
+
+    Constructs a JSON array value by creating @a cnt copies of a passed value.
+    In case @a cnt is `0`, an empty array is created.
+
+    @param[in] cnt  the number of JSON copies of @a val to create
+    @param[in] val  the JSON value to copy
+
+    @post `std::distance(begin(),end()) == cnt` holds.
+
+    @complexity Linear in @a cnt.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @liveexample{The following code shows examples for the @ref
+    basic_json(size_type\, const basic_json&)
+    constructor.,basic_json__size_type_basic_json}
+
+    @since version 1.0.0
+    */
+    basic_json(size_type cnt, const basic_json& val)
+        : m_type(value_t::array)
+    {
+        m_value.array = create<array_t>(cnt, val);
+        assert_invariant();
+    }
+
+    /*!
+    @brief construct a JSON container given an iterator range
+
+    Constructs the JSON value with the contents of the range `[first, last)`.
+    The semantics depends on the different types a JSON value can have:
+    - In case of a null type, invalid_iterator.206 is thrown.
+    - In case of other primitive types (number, boolean, or string), @a first
+      must be `begin()` and @a last must be `end()`. In this case, the value is
+      copied. Otherwise, invalid_iterator.204 is thrown.
+    - In case of structured types (array, object), the constructor behaves as
+      similar versions for `std::vector` or `std::map`; that is, a JSON array
+      or object is constructed from the values in the range.
+
+    @tparam InputIT an input iterator type (@ref iterator or @ref
+    const_iterator)
+
+    @param[in] first begin of the range to copy from (included)
+    @param[in] last end of the range to copy from (excluded)
+
+    @pre Iterators @a first and @a last must be initialized. **This
+         precondition is enforced with an assertion (see warning).** If
+         assertions are switched off, a violation of this precondition yields
+         undefined behavior.
+
+    @pre Range `[first, last)` is valid. Usually, this precondition cannot be
+         checked efficiently. Only certain edge cases are detected; see the
+         description of the exceptions below. A violation of this precondition
+         yields undefined behavior.
+
+    @warning A precondition is enforced with a runtime assertion that will
+             result in calling `std::abort` if this precondition is not met.
+             Assertions can be disabled by defining `NDEBUG` at compile time.
+             See https://en.cppreference.com/w/cpp/error/assert for more
+             information.
+
+    @throw invalid_iterator.201 if iterators @a first and @a last are not
+    compatible (i.e., do not belong to the same JSON value). In this case,
+    the range `[first, last)` is undefined.
+    @throw invalid_iterator.204 if iterators @a first and @a last belong to a
+    primitive type (number, boolean, or string), but @a first does not point
+    to the first element any more. In this case, the range `[first, last)` is
+    undefined. See example code below.
+    @throw invalid_iterator.206 if iterators @a first and @a last belong to a
+    null value. In this case, the range `[first, last)` is undefined.
+
+    @complexity Linear in distance between @a first and @a last.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @liveexample{The example below shows several ways to create JSON values by
+    specifying a subrange with iterators.,basic_json__InputIt_InputIt}
+
+    @since version 1.0.0
+    */
+    template<class InputIT, typename std::enable_if<
+                 std::is_same<InputIT, typename basic_json_t::iterator>::value or
+                 std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int>::type = 0>
+    basic_json(InputIT first, InputIT last)
+    {
+        assert(first.m_object != nullptr);
+        assert(last.m_object != nullptr);
+
+        // make sure iterator fits the current value
+        if (JSON_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(201, "iterators are not compatible"));
+        }
+
+        // copy type from first iterator
+        m_type = first.m_object->m_type;
+
+        // check if iterator range is complete for primitive values
+        switch (m_type)
+        {
+            case value_t::boolean:
+            case value_t::number_float:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::string:
+            {
+                if (JSON_UNLIKELY(not first.m_it.primitive_iterator.is_begin()
+                                  or not last.m_it.primitive_iterator.is_end()))
+                {
+                    JSON_THROW(invalid_iterator::create(204, "iterators out of range"));
+                }
+                break;
+            }
+
+            default:
+                break;
+        }
+
+        switch (m_type)
+        {
+            case value_t::number_integer:
+            {
+                m_value.number_integer = first.m_object->m_value.number_integer;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_value.number_unsigned = first.m_object->m_value.number_unsigned;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_value.number_float = first.m_object->m_value.number_float;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_value.boolean = first.m_object->m_value.boolean;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_value = *first.m_object->m_value.string;
+                break;
+            }
+
+            case value_t::object:
+            {
+                m_value.object = create<object_t>(first.m_it.object_iterator,
+                                                  last.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_value.array = create<array_t>(first.m_it.array_iterator,
+                                                last.m_it.array_iterator);
+                break;
+            }
+
+            default:
+                JSON_THROW(invalid_iterator::create(206, "cannot construct with iterators from " +
+                                                    std::string(first.m_object->type_name())));
+        }
+
+        assert_invariant();
+    }
+
+
+    ///////////////////////////////////////
+    // other constructors and destructor //
+    ///////////////////////////////////////
+
+    /// @private
+    basic_json(const detail::json_ref<basic_json>& ref)
+        : basic_json(ref.moved_or_copied())
+    {}
+
+    /*!
+    @brief copy constructor
+
+    Creates a copy of a given JSON value.
+
+    @param[in] other  the JSON value to copy
+
+    @post `*this == other`
+
+    @complexity Linear in the size of @a other.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is linear.
+    - As postcondition, it holds: `other == basic_json(other)`.
+
+    @liveexample{The following code shows an example for the copy
+    constructor.,basic_json__basic_json}
+
+    @since version 1.0.0
+    */
+    basic_json(const basic_json& other)
+        : m_type(other.m_type)
+    {
+        // check of passed value is valid
+        other.assert_invariant();
+
+        switch (m_type)
+        {
+            case value_t::object:
+            {
+                m_value = *other.m_value.object;
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_value = *other.m_value.array;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_value = *other.m_value.string;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_value = other.m_value.boolean;
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                m_value = other.m_value.number_integer;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_value = other.m_value.number_unsigned;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_value = other.m_value.number_float;
+                break;
+            }
+
+            default:
+                break;
+        }
+
+        assert_invariant();
+    }
+
+    /*!
+    @brief move constructor
+
+    Move constructor. Constructs a JSON value with the contents of the given
+    value @a other using move semantics. It "steals" the resources from @a
+    other and leaves it as JSON null value.
+
+    @param[in,out] other  value to move to this object
+
+    @post `*this` has the same value as @a other before the call.
+    @post @a other is a JSON null value.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this constructor never throws
+    exceptions.
+
+    @requirement This function helps `basic_json` satisfying the
+    [MoveConstructible](https://en.cppreference.com/w/cpp/named_req/MoveConstructible)
+    requirements.
+
+    @liveexample{The code below shows the move constructor explicitly called
+    via std::move.,basic_json__moveconstructor}
+
+    @since version 1.0.0
+    */
+    basic_json(basic_json&& other) noexcept
+        : m_type(std::move(other.m_type)),
+          m_value(std::move(other.m_value))
+    {
+        // check that passed value is valid
+        other.assert_invariant();
+
+        // invalidate payload
+        other.m_type = value_t::null;
+        other.m_value = {};
+
+        assert_invariant();
+    }
+
+    /*!
+    @brief copy assignment
+
+    Copy assignment operator. Copies a JSON value via the "copy and swap"
+    strategy: It is expressed in terms of the copy constructor, destructor,
+    and the `swap()` member function.
+
+    @param[in] other  value to copy from
+
+    @complexity Linear.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is linear.
+
+    @liveexample{The code below shows and example for the copy assignment. It
+    creates a copy of value `a` which is then swapped with `b`. Finally\, the
+    copy of `a` (which is the null value after the swap) is
+    destroyed.,basic_json__copyassignment}
+
+    @since version 1.0.0
+    */
+    basic_json& operator=(basic_json other) noexcept (
+        std::is_nothrow_move_constructible<value_t>::value and
+        std::is_nothrow_move_assignable<value_t>::value and
+        std::is_nothrow_move_constructible<json_value>::value and
+        std::is_nothrow_move_assignable<json_value>::value
+    )
+    {
+        // check that passed value is valid
+        other.assert_invariant();
+
+        using std::swap;
+        swap(m_type, other.m_type);
+        swap(m_value, other.m_value);
+
+        assert_invariant();
+        return *this;
+    }
+
+    /*!
+    @brief destructor
+
+    Destroys the JSON value and frees all allocated memory.
+
+    @complexity Linear.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is linear.
+    - All stored elements are destroyed and all memory is freed.
+
+    @since version 1.0.0
+    */
+    ~basic_json() noexcept
+    {
+        assert_invariant();
+        m_value.destroy(m_type);
+    }
+
+    /// @}
+
+  public:
+    ///////////////////////
+    // object inspection //
+    ///////////////////////
+
+    /// @name object inspection
+    /// Functions to inspect the type of a JSON value.
+    /// @{
+
+    /*!
+    @brief serialization
+
+    Serialization function for JSON values. The function tries to mimic
+    Python's `json.dumps()` function, and currently supports its @a indent
+    and @a ensure_ascii parameters.
+
+    @param[in] indent If indent is nonnegative, then array elements and object
+    members will be pretty-printed with that indent level. An indent level of
+    `0` will only insert newlines. `-1` (the default) selects the most compact
+    representation.
+    @param[in] indent_char The character to use for indentation if @a indent is
+    greater than `0`. The default is ` ` (space).
+    @param[in] ensure_ascii If @a ensure_ascii is true, all non-ASCII characters
+    in the output are escaped with `\uXXXX` sequences, and the result consists
+    of ASCII characters only.
+    @param[in] error_handler  how to react on decoding errors; there are three
+    possible values: `strict` (throws and exception in case a decoding error
+    occurs; default), `replace` (replace invalid UTF-8 sequences with U+FFFD),
+    and `ignore` (ignore invalid UTF-8 sequences during serialization).
+
+    @return string containing the serialization of the JSON value
+
+    @throw type_error.316 if a string stored inside the JSON value is not
+                          UTF-8 encoded
+
+    @complexity Linear.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @liveexample{The following example shows the effect of different @a indent\,
+    @a indent_char\, and @a ensure_ascii parameters to the result of the
+    serialization.,dump}
+
+    @see https://docs.python.org/2/library/json.html#json.dump
+
+    @since version 1.0.0; indentation character @a indent_char, option
+           @a ensure_ascii and exceptions added in version 3.0.0; error
+           handlers added in version 3.4.0.
+    */
+    string_t dump(const int indent = -1,
+                  const char indent_char = ' ',
+                  const bool ensure_ascii = false,
+                  const error_handler_t error_handler = error_handler_t::strict) const
+    {
+        string_t result;
+        serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);
+
+        if (indent >= 0)
+        {
+            s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent));
+        }
+        else
+        {
+            s.dump(*this, false, ensure_ascii, 0);
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief return the type of the JSON value (explicit)
+
+    Return the type of the JSON value as a value from the @ref value_t
+    enumeration.
+
+    @return the type of the JSON value
+            Value type                | return value
+            ------------------------- | -------------------------
+            null                      | value_t::null
+            boolean                   | value_t::boolean
+            string                    | value_t::string
+            number (integer)          | value_t::number_integer
+            number (unsigned integer) | value_t::number_unsigned
+            number (floating-point)   | value_t::number_float
+            object                    | value_t::object
+            array                     | value_t::array
+            discarded                 | value_t::discarded
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `type()` for all JSON
+    types.,type}
+
+    @sa @ref operator value_t() -- return the type of the JSON value (implicit)
+    @sa @ref type_name() -- return the type as string
+
+    @since version 1.0.0
+    */
+    constexpr value_t type() const noexcept
+    {
+        return m_type;
+    }
+
+    /*!
+    @brief return whether type is primitive
+
+    This function returns true if and only if the JSON type is primitive
+    (string, number, boolean, or null).
+
+    @return `true` if type is primitive (string, number, boolean, or null),
+    `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_primitive()` for all JSON
+    types.,is_primitive}
+
+    @sa @ref is_structured() -- returns whether JSON value is structured
+    @sa @ref is_null() -- returns whether JSON value is `null`
+    @sa @ref is_string() -- returns whether JSON value is a string
+    @sa @ref is_boolean() -- returns whether JSON value is a boolean
+    @sa @ref is_number() -- returns whether JSON value is a number
+
+    @since version 1.0.0
+    */
+    constexpr bool is_primitive() const noexcept
+    {
+        return is_null() or is_string() or is_boolean() or is_number();
+    }
+
+    /*!
+    @brief return whether type is structured
+
+    This function returns true if and only if the JSON type is structured
+    (array or object).
+
+    @return `true` if type is structured (array or object), `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_structured()` for all JSON
+    types.,is_structured}
+
+    @sa @ref is_primitive() -- returns whether value is primitive
+    @sa @ref is_array() -- returns whether value is an array
+    @sa @ref is_object() -- returns whether value is an object
+
+    @since version 1.0.0
+    */
+    constexpr bool is_structured() const noexcept
+    {
+        return is_array() or is_object();
+    }
+
+    /*!
+    @brief return whether value is null
+
+    This function returns true if and only if the JSON value is null.
+
+    @return `true` if type is null, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_null()` for all JSON
+    types.,is_null}
+
+    @since version 1.0.0
+    */
+    constexpr bool is_null() const noexcept
+    {
+        return (m_type == value_t::null);
+    }
+
+    /*!
+    @brief return whether value is a boolean
+
+    This function returns true if and only if the JSON value is a boolean.
+
+    @return `true` if type is boolean, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_boolean()` for all JSON
+    types.,is_boolean}
+
+    @since version 1.0.0
+    */
+    constexpr bool is_boolean() const noexcept
+    {
+        return (m_type == value_t::boolean);
+    }
+
+    /*!
+    @brief return whether value is a number
+
+    This function returns true if and only if the JSON value is a number. This
+    includes both integer (signed and unsigned) and floating-point values.
+
+    @return `true` if type is number (regardless whether integer, unsigned
+    integer or floating-type), `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_number()` for all JSON
+    types.,is_number}
+
+    @sa @ref is_number_integer() -- check if value is an integer or unsigned
+    integer number
+    @sa @ref is_number_unsigned() -- check if value is an unsigned integer
+    number
+    @sa @ref is_number_float() -- check if value is a floating-point number
+
+    @since version 1.0.0
+    */
+    constexpr bool is_number() const noexcept
+    {
+        return is_number_integer() or is_number_float();
+    }
+
+    /*!
+    @brief return whether value is an integer number
+
+    This function returns true if and only if the JSON value is a signed or
+    unsigned integer number. This excludes floating-point values.
+
+    @return `true` if type is an integer or unsigned integer number, `false`
+    otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_number_integer()` for all
+    JSON types.,is_number_integer}
+
+    @sa @ref is_number() -- check if value is a number
+    @sa @ref is_number_unsigned() -- check if value is an unsigned integer
+    number
+    @sa @ref is_number_float() -- check if value is a floating-point number
+
+    @since version 1.0.0
+    */
+    constexpr bool is_number_integer() const noexcept
+    {
+        return (m_type == value_t::number_integer or m_type == value_t::number_unsigned);
+    }
+
+    /*!
+    @brief return whether value is an unsigned integer number
+
+    This function returns true if and only if the JSON value is an unsigned
+    integer number. This excludes floating-point and signed integer values.
+
+    @return `true` if type is an unsigned integer number, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_number_unsigned()` for all
+    JSON types.,is_number_unsigned}
+
+    @sa @ref is_number() -- check if value is a number
+    @sa @ref is_number_integer() -- check if value is an integer or unsigned
+    integer number
+    @sa @ref is_number_float() -- check if value is a floating-point number
+
+    @since version 2.0.0
+    */
+    constexpr bool is_number_unsigned() const noexcept
+    {
+        return (m_type == value_t::number_unsigned);
+    }
+
+    /*!
+    @brief return whether value is a floating-point number
+
+    This function returns true if and only if the JSON value is a
+    floating-point number. This excludes signed and unsigned integer values.
+
+    @return `true` if type is a floating-point number, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_number_float()` for all
+    JSON types.,is_number_float}
+
+    @sa @ref is_number() -- check if value is number
+    @sa @ref is_number_integer() -- check if value is an integer number
+    @sa @ref is_number_unsigned() -- check if value is an unsigned integer
+    number
+
+    @since version 1.0.0
+    */
+    constexpr bool is_number_float() const noexcept
+    {
+        return (m_type == value_t::number_float);
+    }
+
+    /*!
+    @brief return whether value is an object
+
+    This function returns true if and only if the JSON value is an object.
+
+    @return `true` if type is object, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_object()` for all JSON
+    types.,is_object}
+
+    @since version 1.0.0
+    */
+    constexpr bool is_object() const noexcept
+    {
+        return (m_type == value_t::object);
+    }
+
+    /*!
+    @brief return whether value is an array
+
+    This function returns true if and only if the JSON value is an array.
+
+    @return `true` if type is array, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_array()` for all JSON
+    types.,is_array}
+
+    @since version 1.0.0
+    */
+    constexpr bool is_array() const noexcept
+    {
+        return (m_type == value_t::array);
+    }
+
+    /*!
+    @brief return whether value is a string
+
+    This function returns true if and only if the JSON value is a string.
+
+    @return `true` if type is string, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_string()` for all JSON
+    types.,is_string}
+
+    @since version 1.0.0
+    */
+    constexpr bool is_string() const noexcept
+    {
+        return (m_type == value_t::string);
+    }
+
+    /*!
+    @brief return whether value is discarded
+
+    This function returns true if and only if the JSON value was discarded
+    during parsing with a callback function (see @ref parser_callback_t).
+
+    @note This function will always be `false` for JSON values after parsing.
+    That is, discarded values can only occur during parsing, but will be
+    removed when inside a structured value or replaced by null in other cases.
+
+    @return `true` if type is discarded, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_discarded()` for all JSON
+    types.,is_discarded}
+
+    @since version 1.0.0
+    */
+    constexpr bool is_discarded() const noexcept
+    {
+        return (m_type == value_t::discarded);
+    }
+
+    /*!
+    @brief return the type of the JSON value (implicit)
+
+    Implicitly return the type of the JSON value as a value from the @ref
+    value_t enumeration.
+
+    @return the type of the JSON value
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies the @ref value_t operator for
+    all JSON types.,operator__value_t}
+
+    @sa @ref type() -- return the type of the JSON value (explicit)
+    @sa @ref type_name() -- return the type as string
+
+    @since version 1.0.0
+    */
+    constexpr operator value_t() const noexcept
+    {
+        return m_type;
+    }
+
+    /// @}
+
+  private:
+    //////////////////
+    // value access //
+    //////////////////
+
+    /// get a boolean (explicit)
+    boolean_t get_impl(boolean_t* /*unused*/) const
+    {
+        if (JSON_LIKELY(is_boolean()))
+        {
+            return m_value.boolean;
+        }
+
+        JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(type_name())));
+    }
+
+    /// get a pointer to the value (object)
+    object_t* get_impl_ptr(object_t* /*unused*/) noexcept
+    {
+        return is_object() ? m_value.object : nullptr;
+    }
+
+    /// get a pointer to the value (object)
+    constexpr const object_t* get_impl_ptr(const object_t* /*unused*/) const noexcept
+    {
+        return is_object() ? m_value.object : nullptr;
+    }
+
+    /// get a pointer to the value (array)
+    array_t* get_impl_ptr(array_t* /*unused*/) noexcept
+    {
+        return is_array() ? m_value.array : nullptr;
+    }
+
+    /// get a pointer to the value (array)
+    constexpr const array_t* get_impl_ptr(const array_t* /*unused*/) const noexcept
+    {
+        return is_array() ? m_value.array : nullptr;
+    }
+
+    /// get a pointer to the value (string)
+    string_t* get_impl_ptr(string_t* /*unused*/) noexcept
+    {
+        return is_string() ? m_value.string : nullptr;
+    }
+
+    /// get a pointer to the value (string)
+    constexpr const string_t* get_impl_ptr(const string_t* /*unused*/) const noexcept
+    {
+        return is_string() ? m_value.string : nullptr;
+    }
+
+    /// get a pointer to the value (boolean)
+    boolean_t* get_impl_ptr(boolean_t* /*unused*/) noexcept
+    {
+        return is_boolean() ? &m_value.boolean : nullptr;
+    }
+
+    /// get a pointer to the value (boolean)
+    constexpr const boolean_t* get_impl_ptr(const boolean_t* /*unused*/) const noexcept
+    {
+        return is_boolean() ? &m_value.boolean : nullptr;
+    }
+
+    /// get a pointer to the value (integer number)
+    number_integer_t* get_impl_ptr(number_integer_t* /*unused*/) noexcept
+    {
+        return is_number_integer() ? &m_value.number_integer : nullptr;
+    }
+
+    /// get a pointer to the value (integer number)
+    constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /*unused*/) const noexcept
+    {
+        return is_number_integer() ? &m_value.number_integer : nullptr;
+    }
+
+    /// get a pointer to the value (unsigned number)
+    number_unsigned_t* get_impl_ptr(number_unsigned_t* /*unused*/) noexcept
+    {
+        return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
+    }
+
+    /// get a pointer to the value (unsigned number)
+    constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t* /*unused*/) const noexcept
+    {
+        return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
+    }
+
+    /// get a pointer to the value (floating-point number)
+    number_float_t* get_impl_ptr(number_float_t* /*unused*/) noexcept
+    {
+        return is_number_float() ? &m_value.number_float : nullptr;
+    }
+
+    /// get a pointer to the value (floating-point number)
+    constexpr const number_float_t* get_impl_ptr(const number_float_t* /*unused*/) const noexcept
+    {
+        return is_number_float() ? &m_value.number_float : nullptr;
+    }
+
+    /*!
+    @brief helper function to implement get_ref()
+
+    This function helps to implement get_ref() without code duplication for
+    const and non-const overloads
+
+    @tparam ThisType will be deduced as `basic_json` or `const basic_json`
+
+    @throw type_error.303 if ReferenceType does not match underlying value
+    type of the current JSON
+    */
+    template<typename ReferenceType, typename ThisType>
+    static ReferenceType get_ref_impl(ThisType& obj)
+    {
+        // delegate the call to get_ptr<>()
+        auto ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
+
+        if (JSON_LIKELY(ptr != nullptr))
+        {
+            return *ptr;
+        }
+
+        JSON_THROW(type_error::create(303, "incompatible ReferenceType for get_ref, actual type is " + std::string(obj.type_name())));
+    }
+
+  public:
+    /// @name value access
+    /// Direct access to the stored value of a JSON value.
+    /// @{
+
+    /*!
+    @brief get special-case overload
+
+    This overloads avoids a lot of template boilerplate, it can be seen as the
+    identity method
+
+    @tparam BasicJsonType == @ref basic_json
+
+    @return a copy of *this
+
+    @complexity Constant.
+
+    @since version 2.1.0
+    */
+    template<typename BasicJsonType, detail::enable_if_t<
+                 std::is_same<typename std::remove_const<BasicJsonType>::type, basic_json_t>::value,
+                 int> = 0>
+    basic_json get() const
+    {
+        return *this;
+    }
+
+    /*!
+    @brief get special-case overload
+
+    This overloads converts the current @ref basic_json in a different
+    @ref basic_json type
+
+    @tparam BasicJsonType == @ref basic_json
+
+    @return a copy of *this, converted into @tparam BasicJsonType
+
+    @complexity Depending on the implementation of the called `from_json()`
+                method.
+
+    @since version 3.2.0
+    */
+    template<typename BasicJsonType, detail::enable_if_t<
+                 not std::is_same<BasicJsonType, basic_json>::value and
+                 detail::is_basic_json<BasicJsonType>::value, int> = 0>
+    BasicJsonType get() const
+    {
+        return *this;
+    }
+
+    /*!
+    @brief get a value (explicit)
+
+    Explicit type conversion between the JSON value and a compatible value
+    which is [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
+    and [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
+    The value is converted by calling the @ref json_serializer<ValueType>
+    `from_json()` method.
+
+    The function is equivalent to executing
+    @code {.cpp}
+    ValueType ret;
+    JSONSerializer<ValueType>::from_json(*this, ret);
+    return ret;
+    @endcode
+
+    This overloads is chosen if:
+    - @a ValueType is not @ref basic_json,
+    - @ref json_serializer<ValueType> has a `from_json()` method of the form
+      `void from_json(const basic_json&, ValueType&)`, and
+    - @ref json_serializer<ValueType> does not have a `from_json()` method of
+      the form `ValueType from_json(const basic_json&)`
+
+    @tparam ValueTypeCV the provided value type
+    @tparam ValueType the returned value type
+
+    @return copy of the JSON value, converted to @a ValueType
+
+    @throw what @ref json_serializer<ValueType> `from_json()` method throws
+
+    @liveexample{The example below shows several conversions from JSON values
+    to other types. There a few things to note: (1) Floating-point numbers can
+    be converted to integers\, (2) A JSON array can be converted to a standard
+    `std::vector<short>`\, (3) A JSON object can be converted to C++
+    associative containers such as `std::unordered_map<std::string\,
+    json>`.,get__ValueType_const}
+
+    @since version 2.1.0
+    */
+    template<typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,
+             detail::enable_if_t <
+                 not detail::is_basic_json<ValueType>::value and
+                 detail::has_from_json<basic_json_t, ValueType>::value and
+                 not detail::has_non_default_from_json<basic_json_t, ValueType>::value,
+                 int> = 0>
+    ValueType get() const noexcept(noexcept(
+                                       JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
+    {
+        // we cannot static_assert on ValueTypeCV being non-const, because
+        // there is support for get<const basic_json_t>(), which is why we
+        // still need the uncvref
+        static_assert(not std::is_reference<ValueTypeCV>::value,
+                      "get() cannot be used with reference types, you might want to use get_ref()");
+        static_assert(std::is_default_constructible<ValueType>::value,
+                      "types must be DefaultConstructible when used with get()");
+
+        ValueType ret;
+        JSONSerializer<ValueType>::from_json(*this, ret);
+        return ret;
+    }
+
+    /*!
+    @brief get a value (explicit); special case
+
+    Explicit type conversion between the JSON value and a compatible value
+    which is **not** [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
+    and **not** [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
+    The value is converted by calling the @ref json_serializer<ValueType>
+    `from_json()` method.
+
+    The function is equivalent to executing
+    @code {.cpp}
+    return JSONSerializer<ValueTypeCV>::from_json(*this);
+    @endcode
+
+    This overloads is chosen if:
+    - @a ValueType is not @ref basic_json and
+    - @ref json_serializer<ValueType> has a `from_json()` method of the form
+      `ValueType from_json(const basic_json&)`
+
+    @note If @ref json_serializer<ValueType> has both overloads of
+    `from_json()`, this one is chosen.
+
+    @tparam ValueTypeCV the provided value type
+    @tparam ValueType the returned value type
+
+    @return copy of the JSON value, converted to @a ValueType
+
+    @throw what @ref json_serializer<ValueType> `from_json()` method throws
+
+    @since version 2.1.0
+    */
+    template<typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,
+             detail::enable_if_t<not std::is_same<basic_json_t, ValueType>::value and
+                                 detail::has_non_default_from_json<basic_json_t, ValueType>::value,
+                                 int> = 0>
+    ValueType get() const noexcept(noexcept(
+                                       JSONSerializer<ValueTypeCV>::from_json(std::declval<const basic_json_t&>())))
+    {
+        static_assert(not std::is_reference<ValueTypeCV>::value,
+                      "get() cannot be used with reference types, you might want to use get_ref()");
+        return JSONSerializer<ValueTypeCV>::from_json(*this);
+    }
+
+    /*!
+    @brief get a value (explicit)
+
+    Explicit type conversion between the JSON value and a compatible value.
+    The value is filled into the input parameter by calling the @ref json_serializer<ValueType>
+    `from_json()` method.
+
+    The function is equivalent to executing
+    @code {.cpp}
+    ValueType v;
+    JSONSerializer<ValueType>::from_json(*this, v);
+    @endcode
+
+    This overloads is chosen if:
+    - @a ValueType is not @ref basic_json,
+    - @ref json_serializer<ValueType> has a `from_json()` method of the form
+      `void from_json(const basic_json&, ValueType&)`, and
+
+    @tparam ValueType the input parameter type.
+
+    @return the input parameter, allowing chaining calls.
+
+    @throw what @ref json_serializer<ValueType> `from_json()` method throws
+
+    @liveexample{The example below shows several conversions from JSON values
+    to other types. There a few things to note: (1) Floating-point numbers can
+    be converted to integers\, (2) A JSON array can be converted to a standard
+    `std::vector<short>`\, (3) A JSON object can be converted to C++
+    associative containers such as `std::unordered_map<std::string\,
+    json>`.,get_to}
+
+    @since version 3.3.0
+    */
+    template<typename ValueType,
+             detail::enable_if_t <
+                 not detail::is_basic_json<ValueType>::value and
+                 detail::has_from_json<basic_json_t, ValueType>::value,
+                 int> = 0>
+    ValueType & get_to(ValueType& v) const noexcept(noexcept(
+                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
+    {
+        JSONSerializer<ValueType>::from_json(*this, v);
+        return v;
+    }
+
+
+    /*!
+    @brief get a pointer value (implicit)
+
+    Implicit pointer access to the internally stored JSON value. No copies are
+    made.
+
+    @warning Writing data to the pointee of the result yields an undefined
+    state.
+
+    @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
+    object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
+    @ref number_unsigned_t, or @ref number_float_t. Enforced by a static
+    assertion.
+
+    @return pointer to the internally stored JSON value if the requested
+    pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how pointers to internal values of a
+    JSON value can be requested. Note that no type conversions are made and a
+    `nullptr` is returned if the value and the requested pointer type does not
+    match.,get_ptr}
+
+    @since version 1.0.0
+    */
+    template<typename PointerType, typename std::enable_if<
+                 std::is_pointer<PointerType>::value, int>::type = 0>
+    auto get_ptr() noexcept -> decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
+    {
+        // delegate the call to get_impl_ptr<>()
+        return get_impl_ptr(static_cast<PointerType>(nullptr));
+    }
+
+    /*!
+    @brief get a pointer value (implicit)
+    @copydoc get_ptr()
+    */
+    template<typename PointerType, typename std::enable_if<
+                 std::is_pointer<PointerType>::value and
+                 std::is_const<typename std::remove_pointer<PointerType>::type>::value, int>::type = 0>
+    constexpr auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
+    {
+        // delegate the call to get_impl_ptr<>() const
+        return get_impl_ptr(static_cast<PointerType>(nullptr));
+    }
+
+    /*!
+    @brief get a pointer value (explicit)
+
+    Explicit pointer access to the internally stored JSON value. No copies are
+    made.
+
+    @warning The pointer becomes invalid if the underlying JSON object
+    changes.
+
+    @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
+    object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
+    @ref number_unsigned_t, or @ref number_float_t.
+
+    @return pointer to the internally stored JSON value if the requested
+    pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how pointers to internal values of a
+    JSON value can be requested. Note that no type conversions are made and a
+    `nullptr` is returned if the value and the requested pointer type does not
+    match.,get__PointerType}
+
+    @sa @ref get_ptr() for explicit pointer-member access
+
+    @since version 1.0.0
+    */
+    template<typename PointerType, typename std::enable_if<
+                 std::is_pointer<PointerType>::value, int>::type = 0>
+    auto get() noexcept -> decltype(std::declval<basic_json_t&>().template get_ptr<PointerType>())
+    {
+        // delegate the call to get_ptr
+        return get_ptr<PointerType>();
+    }
+
+    /*!
+    @brief get a pointer value (explicit)
+    @copydoc get()
+    */
+    template<typename PointerType, typename std::enable_if<
+                 std::is_pointer<PointerType>::value, int>::type = 0>
+    constexpr auto get() const noexcept -> decltype(std::declval<const basic_json_t&>().template get_ptr<PointerType>())
+    {
+        // delegate the call to get_ptr
+        return get_ptr<PointerType>();
+    }
+
+    /*!
+    @brief get a reference value (implicit)
+
+    Implicit reference access to the internally stored JSON value. No copies
+    are made.
+
+    @warning Writing data to the referee of the result yields an undefined
+    state.
+
+    @tparam ReferenceType reference type; must be a reference to @ref array_t,
+    @ref object_t, @ref string_t, @ref boolean_t, @ref number_integer_t, or
+    @ref number_float_t. Enforced by static assertion.
+
+    @return reference to the internally stored JSON value if the requested
+    reference type @a ReferenceType fits to the JSON value; throws
+    type_error.303 otherwise
+
+    @throw type_error.303 in case passed type @a ReferenceType is incompatible
+    with the stored JSON value; see example below
+
+    @complexity Constant.
+
+    @liveexample{The example shows several calls to `get_ref()`.,get_ref}
+
+    @since version 1.1.0
+    */
+    template<typename ReferenceType, typename std::enable_if<
+                 std::is_reference<ReferenceType>::value, int>::type = 0>
+    ReferenceType get_ref()
+    {
+        // delegate call to get_ref_impl
+        return get_ref_impl<ReferenceType>(*this);
+    }
+
+    /*!
+    @brief get a reference value (implicit)
+    @copydoc get_ref()
+    */
+    template<typename ReferenceType, typename std::enable_if<
+                 std::is_reference<ReferenceType>::value and
+                 std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int>::type = 0>
+    ReferenceType get_ref() const
+    {
+        // delegate call to get_ref_impl
+        return get_ref_impl<ReferenceType>(*this);
+    }
+
+    /*!
+    @brief get a value (implicit)
+
+    Implicit type conversion between the JSON value and a compatible value.
+    The call is realized by calling @ref get() const.
+
+    @tparam ValueType non-pointer type compatible to the JSON value, for
+    instance `int` for JSON integer numbers, `bool` for JSON booleans, or
+    `std::vector` types for JSON arrays. The character type of @ref string_t
+    as well as an initializer list of this type is excluded to avoid
+    ambiguities as these types implicitly convert to `std::string`.
+
+    @return copy of the JSON value, converted to type @a ValueType
+
+    @throw type_error.302 in case passed type @a ValueType is incompatible
+    to the JSON value type (e.g., the JSON value is of type boolean, but a
+    string is requested); see example below
+
+    @complexity Linear in the size of the JSON value.
+
+    @liveexample{The example below shows several conversions from JSON values
+    to other types. There a few things to note: (1) Floating-point numbers can
+    be converted to integers\, (2) A JSON array can be converted to a standard
+    `std::vector<short>`\, (3) A JSON object can be converted to C++
+    associative containers such as `std::unordered_map<std::string\,
+    json>`.,operator__ValueType}
+
+    @since version 1.0.0
+    */
+    template < typename ValueType, typename std::enable_if <
+                   not std::is_pointer<ValueType>::value and
+                   not std::is_same<ValueType, detail::json_ref<basic_json>>::value and
+                   not std::is_same<ValueType, typename string_t::value_type>::value and
+                   not detail::is_basic_json<ValueType>::value
+
+#ifndef _MSC_VER  // fix for issue #167 operator<< ambiguity under VS2015
+                   and not std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>::value
+#if defined(JSON_HAS_CPP_17) && defined(_MSC_VER) and _MSC_VER <= 1914
+                   and not std::is_same<ValueType, typename std::string_view>::value
+#endif
+#endif
+                   and detail::is_detected<detail::get_template_function, const basic_json_t&, ValueType>::value
+                   , int >::type = 0 >
+    operator ValueType() const
+    {
+        // delegate the call to get<>() const
+        return get<ValueType>();
+    }
+
+    /// @}
+
+
+    ////////////////////
+    // element access //
+    ////////////////////
+
+    /// @name element access
+    /// Access to the JSON value.
+    /// @{
+
+    /*!
+    @brief access specified array element with bounds checking
+
+    Returns a reference to the element at specified location @a idx, with
+    bounds checking.
+
+    @param[in] idx  index of the element to access
+
+    @return reference to the element at index @a idx
+
+    @throw type_error.304 if the JSON value is not an array; in this case,
+    calling `at` with an index makes no sense. See example below.
+    @throw out_of_range.401 if the index @a idx is out of range of the array;
+    that is, `idx >= size()`. See example below.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Constant.
+
+    @since version 1.0.0
+
+    @liveexample{The example below shows how array elements can be read and
+    written using `at()`. It also demonstrates the different exceptions that
+    can be thrown.,at__size_type}
+    */
+    reference at(size_type idx)
+    {
+        // at only works for arrays
+        if (JSON_LIKELY(is_array()))
+        {
+            JSON_TRY
+            {
+                return m_value.array->at(idx);
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create better exception explanation
+                JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
+            }
+        }
+        else
+        {
+            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
+        }
+    }
+
+    /*!
+    @brief access specified array element with bounds checking
+
+    Returns a const reference to the element at specified location @a idx,
+    with bounds checking.
+
+    @param[in] idx  index of the element to access
+
+    @return const reference to the element at index @a idx
+
+    @throw type_error.304 if the JSON value is not an array; in this case,
+    calling `at` with an index makes no sense. See example below.
+    @throw out_of_range.401 if the index @a idx is out of range of the array;
+    that is, `idx >= size()`. See example below.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Constant.
+
+    @since version 1.0.0
+
+    @liveexample{The example below shows how array elements can be read using
+    `at()`. It also demonstrates the different exceptions that can be thrown.,
+    at__size_type_const}
+    */
+    const_reference at(size_type idx) const
+    {
+        // at only works for arrays
+        if (JSON_LIKELY(is_array()))
+        {
+            JSON_TRY
+            {
+                return m_value.array->at(idx);
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create better exception explanation
+                JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
+            }
+        }
+        else
+        {
+            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
+        }
+    }
+
+    /*!
+    @brief access specified object element with bounds checking
+
+    Returns a reference to the element at with specified key @a key, with
+    bounds checking.
+
+    @param[in] key  key of the element to access
+
+    @return reference to the element at key @a key
+
+    @throw type_error.304 if the JSON value is not an object; in this case,
+    calling `at` with a key makes no sense. See example below.
+    @throw out_of_range.403 if the key @a key is is not stored in the object;
+    that is, `find(key) == end()`. See example below.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Logarithmic in the size of the container.
+
+    @sa @ref operator[](const typename object_t::key_type&) for unchecked
+    access by reference
+    @sa @ref value() for access by value with a default value
+
+    @since version 1.0.0
+
+    @liveexample{The example below shows how object elements can be read and
+    written using `at()`. It also demonstrates the different exceptions that
+    can be thrown.,at__object_t_key_type}
+    */
+    reference at(const typename object_t::key_type& key)
+    {
+        // at only works for objects
+        if (JSON_LIKELY(is_object()))
+        {
+            JSON_TRY
+            {
+                return m_value.object->at(key);
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create better exception explanation
+                JSON_THROW(out_of_range::create(403, "key '" + key + "' not found"));
+            }
+        }
+        else
+        {
+            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
+        }
+    }
+
+    /*!
+    @brief access specified object element with bounds checking
+
+    Returns a const reference to the element at with specified key @a key,
+    with bounds checking.
+
+    @param[in] key  key of the element to access
+
+    @return const reference to the element at key @a key
+
+    @throw type_error.304 if the JSON value is not an object; in this case,
+    calling `at` with a key makes no sense. See example below.
+    @throw out_of_range.403 if the key @a key is is not stored in the object;
+    that is, `find(key) == end()`. See example below.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Logarithmic in the size of the container.
+
+    @sa @ref operator[](const typename object_t::key_type&) for unchecked
+    access by reference
+    @sa @ref value() for access by value with a default value
+
+    @since version 1.0.0
+
+    @liveexample{The example below shows how object elements can be read using
+    `at()`. It also demonstrates the different exceptions that can be thrown.,
+    at__object_t_key_type_const}
+    */
+    const_reference at(const typename object_t::key_type& key) const
+    {
+        // at only works for objects
+        if (JSON_LIKELY(is_object()))
+        {
+            JSON_TRY
+            {
+                return m_value.object->at(key);
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create better exception explanation
+                JSON_THROW(out_of_range::create(403, "key '" + key + "' not found"));
+            }
+        }
+        else
+        {
+            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
+        }
+    }
+
+    /*!
+    @brief access specified array element
+
+    Returns a reference to the element at specified location @a idx.
+
+    @note If @a idx is beyond the range of the array (i.e., `idx >= size()`),
+    then the array is silently filled up with `null` values to make `idx` a
+    valid reference to the last stored element.
+
+    @param[in] idx  index of the element to access
+
+    @return reference to the element at index @a idx
+
+    @throw type_error.305 if the JSON value is not an array or null; in that
+    cases, using the [] operator with an index makes no sense.
+
+    @complexity Constant if @a idx is in the range of the array. Otherwise
+    linear in `idx - size()`.
+
+    @liveexample{The example below shows how array elements can be read and
+    written using `[]` operator. Note the addition of `null`
+    values.,operatorarray__size_type}
+
+    @since version 1.0.0
+    */
+    reference operator[](size_type idx)
+    {
+        // implicitly convert null value to an empty array
+        if (is_null())
+        {
+            m_type = value_t::array;
+            m_value.array = create<array_t>();
+            assert_invariant();
+        }
+
+        // operator[] only works for arrays
+        if (JSON_LIKELY(is_array()))
+        {
+            // fill up array with null values if given idx is outside range
+            if (idx >= m_value.array->size())
+            {
+                m_value.array->insert(m_value.array->end(),
+                                      idx - m_value.array->size() + 1,
+                                      basic_json());
+            }
+
+            return m_value.array->operator[](idx);
+        }
+
+        JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief access specified array element
+
+    Returns a const reference to the element at specified location @a idx.
+
+    @param[in] idx  index of the element to access
+
+    @return const reference to the element at index @a idx
+
+    @throw type_error.305 if the JSON value is not an array; in that case,
+    using the [] operator with an index makes no sense.
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how array elements can be read using
+    the `[]` operator.,operatorarray__size_type_const}
+
+    @since version 1.0.0
+    */
+    const_reference operator[](size_type idx) const
+    {
+        // const operator[] only works for arrays
+        if (JSON_LIKELY(is_array()))
+        {
+            return m_value.array->operator[](idx);
+        }
+
+        JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief access specified object element
+
+    Returns a reference to the element at with specified key @a key.
+
+    @note If @a key is not found in the object, then it is silently added to
+    the object and filled with a `null` value to make `key` a valid reference.
+    In case the value was `null` before, it is converted to an object.
+
+    @param[in] key  key of the element to access
+
+    @return reference to the element at key @a key
+
+    @throw type_error.305 if the JSON value is not an object or null; in that
+    cases, using the [] operator with a key makes no sense.
+
+    @complexity Logarithmic in the size of the container.
+
+    @liveexample{The example below shows how object elements can be read and
+    written using the `[]` operator.,operatorarray__key_type}
+
+    @sa @ref at(const typename object_t::key_type&) for access by reference
+    with range checking
+    @sa @ref value() for access by value with a default value
+
+    @since version 1.0.0
+    */
+    reference operator[](const typename object_t::key_type& key)
+    {
+        // implicitly convert null value to an empty object
+        if (is_null())
+        {
+            m_type = value_t::object;
+            m_value.object = create<object_t>();
+            assert_invariant();
+        }
+
+        // operator[] only works for objects
+        if (JSON_LIKELY(is_object()))
+        {
+            return m_value.object->operator[](key);
+        }
+
+        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief read-only access specified object element
+
+    Returns a const reference to the element at with specified key @a key. No
+    bounds checking is performed.
+
+    @warning If the element with key @a key does not exist, the behavior is
+    undefined.
+
+    @param[in] key  key of the element to access
+
+    @return const reference to the element at key @a key
+
+    @pre The element with key @a key must exist. **This precondition is
+         enforced with an assertion.**
+
+    @throw type_error.305 if the JSON value is not an object; in that case,
+    using the [] operator with a key makes no sense.
+
+    @complexity Logarithmic in the size of the container.
+
+    @liveexample{The example below shows how object elements can be read using
+    the `[]` operator.,operatorarray__key_type_const}
+
+    @sa @ref at(const typename object_t::key_type&) for access by reference
+    with range checking
+    @sa @ref value() for access by value with a default value
+
+    @since version 1.0.0
+    */
+    const_reference operator[](const typename object_t::key_type& key) const
+    {
+        // const operator[] only works for objects
+        if (JSON_LIKELY(is_object()))
+        {
+            assert(m_value.object->find(key) != m_value.object->end());
+            return m_value.object->find(key)->second;
+        }
+
+        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief access specified object element
+
+    Returns a reference to the element at with specified key @a key.
+
+    @note If @a key is not found in the object, then it is silently added to
+    the object and filled with a `null` value to make `key` a valid reference.
+    In case the value was `null` before, it is converted to an object.
+
+    @param[in] key  key of the element to access
+
+    @return reference to the element at key @a key
+
+    @throw type_error.305 if the JSON value is not an object or null; in that
+    cases, using the [] operator with a key makes no sense.
+
+    @complexity Logarithmic in the size of the container.
+
+    @liveexample{The example below shows how object elements can be read and
+    written using the `[]` operator.,operatorarray__key_type}
+
+    @sa @ref at(const typename object_t::key_type&) for access by reference
+    with range checking
+    @sa @ref value() for access by value with a default value
+
+    @since version 1.1.0
+    */
+    template<typename T>
+    reference operator[](T* key)
+    {
+        // implicitly convert null to object
+        if (is_null())
+        {
+            m_type = value_t::object;
+            m_value = value_t::object;
+            assert_invariant();
+        }
+
+        // at only works for objects
+        if (JSON_LIKELY(is_object()))
+        {
+            return m_value.object->operator[](key);
+        }
+
+        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief read-only access specified object element
+
+    Returns a const reference to the element at with specified key @a key. No
+    bounds checking is performed.
+
+    @warning If the element with key @a key does not exist, the behavior is
+    undefined.
+
+    @param[in] key  key of the element to access
+
+    @return const reference to the element at key @a key
+
+    @pre The element with key @a key must exist. **This precondition is
+         enforced with an assertion.**
+
+    @throw type_error.305 if the JSON value is not an object; in that case,
+    using the [] operator with a key makes no sense.
+
+    @complexity Logarithmic in the size of the container.
+
+    @liveexample{The example below shows how object elements can be read using
+    the `[]` operator.,operatorarray__key_type_const}
+
+    @sa @ref at(const typename object_t::key_type&) for access by reference
+    with range checking
+    @sa @ref value() for access by value with a default value
+
+    @since version 1.1.0
+    */
+    template<typename T>
+    const_reference operator[](T* key) const
+    {
+        // at only works for objects
+        if (JSON_LIKELY(is_object()))
+        {
+            assert(m_value.object->find(key) != m_value.object->end());
+            return m_value.object->find(key)->second;
+        }
+
+        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief access specified object element with default value
+
+    Returns either a copy of an object's element at the specified key @a key
+    or a given default value if no element with key @a key exists.
+
+    The function is basically equivalent to executing
+    @code {.cpp}
+    try {
+        return at(key);
+    } catch(out_of_range) {
+        return default_value;
+    }
+    @endcode
+
+    @note Unlike @ref at(const typename object_t::key_type&), this function
+    does not throw if the given key @a key was not found.
+
+    @note Unlike @ref operator[](const typename object_t::key_type& key), this
+    function does not implicitly add an element to the position defined by @a
+    key. This function is furthermore also applicable to const objects.
+
+    @param[in] key  key of the element to access
+    @param[in] default_value  the value to return if @a key is not found
+
+    @tparam ValueType type compatible to JSON values, for instance `int` for
+    JSON integer numbers, `bool` for JSON booleans, or `std::vector` types for
+    JSON arrays. Note the type of the expected value at @a key and the default
+    value @a default_value must be compatible.
+
+    @return copy of the element at key @a key or @a default_value if @a key
+    is not found
+
+    @throw type_error.306 if the JSON value is not an object; in that case,
+    using `value()` with a key makes no sense.
+
+    @complexity Logarithmic in the size of the container.
+
+    @liveexample{The example below shows how object elements can be queried
+    with a default value.,basic_json__value}
+
+    @sa @ref at(const typename object_t::key_type&) for access by reference
+    with range checking
+    @sa @ref operator[](const typename object_t::key_type&) for unchecked
+    access by reference
+
+    @since version 1.0.0
+    */
+    template<class ValueType, typename std::enable_if<
+                 std::is_convertible<basic_json_t, ValueType>::value, int>::type = 0>
+    ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const
+    {
+        // at only works for objects
+        if (JSON_LIKELY(is_object()))
+        {
+            // if key is found, return value and given default value otherwise
+            const auto it = find(key);
+            if (it != end())
+            {
+                return *it;
+            }
+
+            return default_value;
+        }
+
+        JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief overload for a default value of type const char*
+    @copydoc basic_json::value(const typename object_t::key_type&, const ValueType&) const
+    */
+    string_t value(const typename object_t::key_type& key, const char* default_value) const
+    {
+        return value(key, string_t(default_value));
+    }
+
+    /*!
+    @brief access specified object element via JSON Pointer with default value
+
+    Returns either a copy of an object's element at the specified key @a key
+    or a given default value if no element with key @a key exists.
+
+    The function is basically equivalent to executing
+    @code {.cpp}
+    try {
+        return at(ptr);
+    } catch(out_of_range) {
+        return default_value;
+    }
+    @endcode
+
+    @note Unlike @ref at(const json_pointer&), this function does not throw
+    if the given key @a key was not found.
+
+    @param[in] ptr  a JSON pointer to the element to access
+    @param[in] default_value  the value to return if @a ptr found no value
+
+    @tparam ValueType type compatible to JSON values, for instance `int` for
+    JSON integer numbers, `bool` for JSON booleans, or `std::vector` types for
+    JSON arrays. Note the type of the expected value at @a key and the default
+    value @a default_value must be compatible.
+
+    @return copy of the element at key @a key or @a default_value if @a key
+    is not found
+
+    @throw type_error.306 if the JSON value is not an object; in that case,
+    using `value()` with a key makes no sense.
+
+    @complexity Logarithmic in the size of the container.
+
+    @liveexample{The example below shows how object elements can be queried
+    with a default value.,basic_json__value_ptr}
+
+    @sa @ref operator[](const json_pointer&) for unchecked access by reference
+
+    @since version 2.0.2
+    */
+    template<class ValueType, typename std::enable_if<
+                 std::is_convertible<basic_json_t, ValueType>::value, int>::type = 0>
+    ValueType value(const json_pointer& ptr, const ValueType& default_value) const
+    {
+        // at only works for objects
+        if (JSON_LIKELY(is_object()))
+        {
+            // if pointer resolves a value, return it or use default value
+            JSON_TRY
+            {
+                return ptr.get_checked(this);
+            }
+            JSON_INTERNAL_CATCH (out_of_range&)
+            {
+                return default_value;
+            }
+        }
+
+        JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief overload for a default value of type const char*
+    @copydoc basic_json::value(const json_pointer&, ValueType) const
+    */
+    string_t value(const json_pointer& ptr, const char* default_value) const
+    {
+        return value(ptr, string_t(default_value));
+    }
+
+    /*!
+    @brief access the first element
+
+    Returns a reference to the first element in the container. For a JSON
+    container `c`, the expression `c.front()` is equivalent to `*c.begin()`.
+
+    @return In case of a structured type (array or object), a reference to the
+    first element is returned. In case of number, string, or boolean values, a
+    reference to the value is returned.
+
+    @complexity Constant.
+
+    @pre The JSON value must not be `null` (would throw `std::out_of_range`)
+    or an empty array or object (undefined behavior, **guarded by
+    assertions**).
+    @post The JSON value remains unchanged.
+
+    @throw invalid_iterator.214 when called on `null` value
+
+    @liveexample{The following code shows an example for `front()`.,front}
+
+    @sa @ref back() -- access the last element
+
+    @since version 1.0.0
+    */
+    reference front()
+    {
+        return *begin();
+    }
+
+    /*!
+    @copydoc basic_json::front()
+    */
+    const_reference front() const
+    {
+        return *cbegin();
+    }
+
+    /*!
+    @brief access the last element
+
+    Returns a reference to the last element in the container. For a JSON
+    container `c`, the expression `c.back()` is equivalent to
+    @code {.cpp}
+    auto tmp = c.end();
+    --tmp;
+    return *tmp;
+    @endcode
+
+    @return In case of a structured type (array or object), a reference to the
+    last element is returned. In case of number, string, or boolean values, a
+    reference to the value is returned.
+
+    @complexity Constant.
+
+    @pre The JSON value must not be `null` (would throw `std::out_of_range`)
+    or an empty array or object (undefined behavior, **guarded by
+    assertions**).
+    @post The JSON value remains unchanged.
+
+    @throw invalid_iterator.214 when called on a `null` value. See example
+    below.
+
+    @liveexample{The following code shows an example for `back()`.,back}
+
+    @sa @ref front() -- access the first element
+
+    @since version 1.0.0
+    */
+    reference back()
+    {
+        auto tmp = end();
+        --tmp;
+        return *tmp;
+    }
+
+    /*!
+    @copydoc basic_json::back()
+    */
+    const_reference back() const
+    {
+        auto tmp = cend();
+        --tmp;
+        return *tmp;
+    }
+
+    /*!
+    @brief remove element given an iterator
+
+    Removes the element specified by iterator @a pos. The iterator @a pos must
+    be valid and dereferenceable. Thus the `end()` iterator (which is valid,
+    but is not dereferenceable) cannot be used as a value for @a pos.
+
+    If called on a primitive type other than `null`, the resulting JSON value
+    will be `null`.
+
+    @param[in] pos iterator to the element to remove
+    @return Iterator following the last removed element. If the iterator @a
+    pos refers to the last element, the `end()` iterator is returned.
+
+    @tparam IteratorType an @ref iterator or @ref const_iterator
+
+    @post Invalidates iterators and references at or after the point of the
+    erase, including the `end()` iterator.
+
+    @throw type_error.307 if called on a `null` value; example: `"cannot use
+    erase() with null"`
+    @throw invalid_iterator.202 if called on an iterator which does not belong
+    to the current JSON value; example: `"iterator does not fit current
+    value"`
+    @throw invalid_iterator.205 if called on a primitive type with invalid
+    iterator (i.e., any iterator which is not `begin()`); example: `"iterator
+    out of range"`
+
+    @complexity The complexity depends on the type:
+    - objects: amortized constant
+    - arrays: linear in distance between @a pos and the end of the container
+    - strings: linear in the length of the string
+    - other types: constant
+
+    @liveexample{The example shows the result of `erase()` for different JSON
+    types.,erase__IteratorType}
+
+    @sa @ref erase(IteratorType, IteratorType) -- removes the elements in
+    the given range
+    @sa @ref erase(const typename object_t::key_type&) -- removes the element
+    from an object at the given key
+    @sa @ref erase(const size_type) -- removes the element from an array at
+    the given index
+
+    @since version 1.0.0
+    */
+    template<class IteratorType, typename std::enable_if<
+                 std::is_same<IteratorType, typename basic_json_t::iterator>::value or
+                 std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int>::type
+             = 0>
+    IteratorType erase(IteratorType pos)
+    {
+        // make sure iterator fits the current value
+        if (JSON_UNLIKELY(this != pos.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
+        }
+
+        IteratorType result = end();
+
+        switch (m_type)
+        {
+            case value_t::boolean:
+            case value_t::number_float:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::string:
+            {
+                if (JSON_UNLIKELY(not pos.m_it.primitive_iterator.is_begin()))
+                {
+                    JSON_THROW(invalid_iterator::create(205, "iterator out of range"));
+                }
+
+                if (is_string())
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
+                    m_value.string = nullptr;
+                }
+
+                m_type = value_t::null;
+                assert_invariant();
+                break;
+            }
+
+            case value_t::object:
+            {
+                result.m_it.object_iterator = m_value.object->erase(pos.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                result.m_it.array_iterator = m_value.array->erase(pos.m_it.array_iterator);
+                break;
+            }
+
+            default:
+                JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief remove elements given an iterator range
+
+    Removes the element specified by the range `[first; last)`. The iterator
+    @a first does not need to be dereferenceable if `first == last`: erasing
+    an empty range is a no-op.
+
+    If called on a primitive type other than `null`, the resulting JSON value
+    will be `null`.
+
+    @param[in] first iterator to the beginning of the range to remove
+    @param[in] last iterator past the end of the range to remove
+    @return Iterator following the last removed element. If the iterator @a
+    second refers to the last element, the `end()` iterator is returned.
+
+    @tparam IteratorType an @ref iterator or @ref const_iterator
+
+    @post Invalidates iterators and references at or after the point of the
+    erase, including the `end()` iterator.
+
+    @throw type_error.307 if called on a `null` value; example: `"cannot use
+    erase() with null"`
+    @throw invalid_iterator.203 if called on iterators which does not belong
+    to the current JSON value; example: `"iterators do not fit current value"`
+    @throw invalid_iterator.204 if called on a primitive type with invalid
+    iterators (i.e., if `first != begin()` and `last != end()`); example:
+    `"iterators out of range"`
+
+    @complexity The complexity depends on the type:
+    - objects: `log(size()) + std::distance(first, last)`
+    - arrays: linear in the distance between @a first and @a last, plus linear
+      in the distance between @a last and end of the container
+    - strings: linear in the length of the string
+    - other types: constant
+
+    @liveexample{The example shows the result of `erase()` for different JSON
+    types.,erase__IteratorType_IteratorType}
+
+    @sa @ref erase(IteratorType) -- removes the element at a given position
+    @sa @ref erase(const typename object_t::key_type&) -- removes the element
+    from an object at the given key
+    @sa @ref erase(const size_type) -- removes the element from an array at
+    the given index
+
+    @since version 1.0.0
+    */
+    template<class IteratorType, typename std::enable_if<
+                 std::is_same<IteratorType, typename basic_json_t::iterator>::value or
+                 std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int>::type
+             = 0>
+    IteratorType erase(IteratorType first, IteratorType last)
+    {
+        // make sure iterator fits the current value
+        if (JSON_UNLIKELY(this != first.m_object or this != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value"));
+        }
+
+        IteratorType result = end();
+
+        switch (m_type)
+        {
+            case value_t::boolean:
+            case value_t::number_float:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::string:
+            {
+                if (JSON_LIKELY(not first.m_it.primitive_iterator.is_begin()
+                                or not last.m_it.primitive_iterator.is_end()))
+                {
+                    JSON_THROW(invalid_iterator::create(204, "iterators out of range"));
+                }
+
+                if (is_string())
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
+                    m_value.string = nullptr;
+                }
+
+                m_type = value_t::null;
+                assert_invariant();
+                break;
+            }
+
+            case value_t::object:
+            {
+                result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,
+                                              last.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,
+                                             last.m_it.array_iterator);
+                break;
+            }
+
+            default:
+                JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief remove element from a JSON object given a key
+
+    Removes elements from a JSON object with the key value @a key.
+
+    @param[in] key value of the elements to remove
+
+    @return Number of elements removed. If @a ObjectType is the default
+    `std::map` type, the return value will always be `0` (@a key was not
+    found) or `1` (@a key was found).
+
+    @post References and iterators to the erased elements are invalidated.
+    Other references and iterators are not affected.
+
+    @throw type_error.307 when called on a type other than JSON object;
+    example: `"cannot use erase() with null"`
+
+    @complexity `log(size()) + count(key)`
+
+    @liveexample{The example shows the effect of `erase()`.,erase__key_type}
+
+    @sa @ref erase(IteratorType) -- removes the element at a given position
+    @sa @ref erase(IteratorType, IteratorType) -- removes the elements in
+    the given range
+    @sa @ref erase(const size_type) -- removes the element from an array at
+    the given index
+
+    @since version 1.0.0
+    */
+    size_type erase(const typename object_t::key_type& key)
+    {
+        // this erase only works for objects
+        if (JSON_LIKELY(is_object()))
+        {
+            return m_value.object->erase(key);
+        }
+
+        JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief remove element from a JSON array given an index
+
+    Removes element from a JSON array at the index @a idx.
+
+    @param[in] idx index of the element to remove
+
+    @throw type_error.307 when called on a type other than JSON object;
+    example: `"cannot use erase() with null"`
+    @throw out_of_range.401 when `idx >= size()`; example: `"array index 17
+    is out of range"`
+
+    @complexity Linear in distance between @a idx and the end of the container.
+
+    @liveexample{The example shows the effect of `erase()`.,erase__size_type}
+
+    @sa @ref erase(IteratorType) -- removes the element at a given position
+    @sa @ref erase(IteratorType, IteratorType) -- removes the elements in
+    the given range
+    @sa @ref erase(const typename object_t::key_type&) -- removes the element
+    from an object at the given key
+
+    @since version 1.0.0
+    */
+    void erase(const size_type idx)
+    {
+        // this erase only works for arrays
+        if (JSON_LIKELY(is_array()))
+        {
+            if (JSON_UNLIKELY(idx >= size()))
+            {
+                JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
+            }
+
+            m_value.array->erase(m_value.array->begin() + static_cast<difference_type>(idx));
+        }
+        else
+        {
+            JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
+        }
+    }
+
+    /// @}
+
+
+    ////////////
+    // lookup //
+    ////////////
+
+    /// @name lookup
+    /// @{
+
+    /*!
+    @brief find an element in a JSON object
+
+    Finds an element in a JSON object with key equivalent to @a key. If the
+    element is not found or the JSON value is not an object, end() is
+    returned.
+
+    @note This method always returns @ref end() when executed on a JSON type
+          that is not an object.
+
+    @param[in] key key value of the element to search for.
+
+    @return Iterator to an element with key equivalent to @a key. If no such
+    element is found or the JSON value is not an object, past-the-end (see
+    @ref end()) iterator is returned.
+
+    @complexity Logarithmic in the size of the JSON object.
+
+    @liveexample{The example shows how `find()` is used.,find__key_type}
+
+    @since version 1.0.0
+    */
+    template<typename KeyT>
+    iterator find(KeyT&& key)
+    {
+        auto result = end();
+
+        if (is_object())
+        {
+            result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief find an element in a JSON object
+    @copydoc find(KeyT&&)
+    */
+    template<typename KeyT>
+    const_iterator find(KeyT&& key) const
+    {
+        auto result = cend();
+
+        if (is_object())
+        {
+            result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief returns the number of occurrences of a key in a JSON object
+
+    Returns the number of elements with key @a key. If ObjectType is the
+    default `std::map` type, the return value will always be `0` (@a key was
+    not found) or `1` (@a key was found).
+
+    @note This method always returns `0` when executed on a JSON type that is
+          not an object.
+
+    @param[in] key key value of the element to count
+
+    @return Number of elements with key @a key. If the JSON value is not an
+    object, the return value will be `0`.
+
+    @complexity Logarithmic in the size of the JSON object.
+
+    @liveexample{The example shows how `count()` is used.,count}
+
+    @since version 1.0.0
+    */
+    template<typename KeyT>
+    size_type count(KeyT&& key) const
+    {
+        // return 0 for all nonobject types
+        return is_object() ? m_value.object->count(std::forward<KeyT>(key)) : 0;
+    }
+
+    /// @}
+
+
+    ///////////////
+    // iterators //
+    ///////////////
+
+    /// @name iterators
+    /// @{
+
+    /*!
+    @brief returns an iterator to the first element
+
+    Returns an iterator to the first element.
+
+    @image html range-begin-end.svg "Illustration from cppreference.com"
+
+    @return iterator to the first element
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is constant.
+
+    @liveexample{The following code shows an example for `begin()`.,begin}
+
+    @sa @ref cbegin() -- returns a const iterator to the beginning
+    @sa @ref end() -- returns an iterator to the end
+    @sa @ref cend() -- returns a const iterator to the end
+
+    @since version 1.0.0
+    */
+    iterator begin() noexcept
+    {
+        iterator result(this);
+        result.set_begin();
+        return result;
+    }
+
+    /*!
+    @copydoc basic_json::cbegin()
+    */
+    const_iterator begin() const noexcept
+    {
+        return cbegin();
+    }
+
+    /*!
+    @brief returns a const iterator to the first element
+
+    Returns a const iterator to the first element.
+
+    @image html range-begin-end.svg "Illustration from cppreference.com"
+
+    @return const iterator to the first element
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `const_cast<const basic_json&>(*this).begin()`.
+
+    @liveexample{The following code shows an example for `cbegin()`.,cbegin}
+
+    @sa @ref begin() -- returns an iterator to the beginning
+    @sa @ref end() -- returns an iterator to the end
+    @sa @ref cend() -- returns a const iterator to the end
+
+    @since version 1.0.0
+    */
+    const_iterator cbegin() const noexcept
+    {
+        const_iterator result(this);
+        result.set_begin();
+        return result;
+    }
+
+    /*!
+    @brief returns an iterator to one past the last element
+
+    Returns an iterator to one past the last element.
+
+    @image html range-begin-end.svg "Illustration from cppreference.com"
+
+    @return iterator one past the last element
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is constant.
+
+    @liveexample{The following code shows an example for `end()`.,end}
+
+    @sa @ref cend() -- returns a const iterator to the end
+    @sa @ref begin() -- returns an iterator to the beginning
+    @sa @ref cbegin() -- returns a const iterator to the beginning
+
+    @since version 1.0.0
+    */
+    iterator end() noexcept
+    {
+        iterator result(this);
+        result.set_end();
+        return result;
+    }
+
+    /*!
+    @copydoc basic_json::cend()
+    */
+    const_iterator end() const noexcept
+    {
+        return cend();
+    }
+
+    /*!
+    @brief returns a const iterator to one past the last element
+
+    Returns a const iterator to one past the last element.
+
+    @image html range-begin-end.svg "Illustration from cppreference.com"
+
+    @return const iterator one past the last element
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `const_cast<const basic_json&>(*this).end()`.
+
+    @liveexample{The following code shows an example for `cend()`.,cend}
+
+    @sa @ref end() -- returns an iterator to the end
+    @sa @ref begin() -- returns an iterator to the beginning
+    @sa @ref cbegin() -- returns a const iterator to the beginning
+
+    @since version 1.0.0
+    */
+    const_iterator cend() const noexcept
+    {
+        const_iterator result(this);
+        result.set_end();
+        return result;
+    }
+
+    /*!
+    @brief returns an iterator to the reverse-beginning
+
+    Returns an iterator to the reverse-beginning; that is, the last element.
+
+    @image html range-rbegin-rend.svg "Illustration from cppreference.com"
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `reverse_iterator(end())`.
+
+    @liveexample{The following code shows an example for `rbegin()`.,rbegin}
+
+    @sa @ref crbegin() -- returns a const reverse iterator to the beginning
+    @sa @ref rend() -- returns a reverse iterator to the end
+    @sa @ref crend() -- returns a const reverse iterator to the end
+
+    @since version 1.0.0
+    */
+    reverse_iterator rbegin() noexcept
+    {
+        return reverse_iterator(end());
+    }
+
+    /*!
+    @copydoc basic_json::crbegin()
+    */
+    const_reverse_iterator rbegin() const noexcept
+    {
+        return crbegin();
+    }
+
+    /*!
+    @brief returns an iterator to the reverse-end
+
+    Returns an iterator to the reverse-end; that is, one before the first
+    element.
+
+    @image html range-rbegin-rend.svg "Illustration from cppreference.com"
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `reverse_iterator(begin())`.
+
+    @liveexample{The following code shows an example for `rend()`.,rend}
+
+    @sa @ref crend() -- returns a const reverse iterator to the end
+    @sa @ref rbegin() -- returns a reverse iterator to the beginning
+    @sa @ref crbegin() -- returns a const reverse iterator to the beginning
+
+    @since version 1.0.0
+    */
+    reverse_iterator rend() noexcept
+    {
+        return reverse_iterator(begin());
+    }
+
+    /*!
+    @copydoc basic_json::crend()
+    */
+    const_reverse_iterator rend() const noexcept
+    {
+        return crend();
+    }
+
+    /*!
+    @brief returns a const reverse iterator to the last element
+
+    Returns a const iterator to the reverse-beginning; that is, the last
+    element.
+
+    @image html range-rbegin-rend.svg "Illustration from cppreference.com"
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `const_cast<const basic_json&>(*this).rbegin()`.
+
+    @liveexample{The following code shows an example for `crbegin()`.,crbegin}
+
+    @sa @ref rbegin() -- returns a reverse iterator to the beginning
+    @sa @ref rend() -- returns a reverse iterator to the end
+    @sa @ref crend() -- returns a const reverse iterator to the end
+
+    @since version 1.0.0
+    */
+    const_reverse_iterator crbegin() const noexcept
+    {
+        return const_reverse_iterator(cend());
+    }
+
+    /*!
+    @brief returns a const reverse iterator to one before the first
+
+    Returns a const reverse iterator to the reverse-end; that is, one before
+    the first element.
+
+    @image html range-rbegin-rend.svg "Illustration from cppreference.com"
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `const_cast<const basic_json&>(*this).rend()`.
+
+    @liveexample{The following code shows an example for `crend()`.,crend}
+
+    @sa @ref rend() -- returns a reverse iterator to the end
+    @sa @ref rbegin() -- returns a reverse iterator to the beginning
+    @sa @ref crbegin() -- returns a const reverse iterator to the beginning
+
+    @since version 1.0.0
+    */
+    const_reverse_iterator crend() const noexcept
+    {
+        return const_reverse_iterator(cbegin());
+    }
+
+  public:
+    /*!
+    @brief wrapper to access iterator member functions in range-based for
+
+    This function allows to access @ref iterator::key() and @ref
+    iterator::value() during range-based for loops. In these loops, a
+    reference to the JSON values is returned, so there is no access to the
+    underlying iterator.
+
+    For loop without iterator_wrapper:
+
+    @code{cpp}
+    for (auto it = j_object.begin(); it != j_object.end(); ++it)
+    {
+        std::cout << "key: " << it.key() << ", value:" << it.value() << '\n';
+    }
+    @endcode
+
+    Range-based for loop without iterator proxy:
+
+    @code{cpp}
+    for (auto it : j_object)
+    {
+        // "it" is of type json::reference and has no key() member
+        std::cout << "value: " << it << '\n';
+    }
+    @endcode
+
+    Range-based for loop with iterator proxy:
+
+    @code{cpp}
+    for (auto it : json::iterator_wrapper(j_object))
+    {
+        std::cout << "key: " << it.key() << ", value:" << it.value() << '\n';
+    }
+    @endcode
+
+    @note When iterating over an array, `key()` will return the index of the
+          element as string (see example).
+
+    @param[in] ref  reference to a JSON value
+    @return iteration proxy object wrapping @a ref with an interface to use in
+            range-based for loops
+
+    @liveexample{The following code shows how the wrapper is used,iterator_wrapper}
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Constant.
+
+    @note The name of this function is not yet final and may change in the
+    future.
+
+    @deprecated This stream operator is deprecated and will be removed in
+                future 4.0.0 of the library. Please use @ref items() instead;
+                that is, replace `json::iterator_wrapper(j)` with `j.items()`.
+    */
+    JSON_DEPRECATED
+    static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept
+    {
+        return ref.items();
+    }
+
+    /*!
+    @copydoc iterator_wrapper(reference)
+    */
+    JSON_DEPRECATED
+    static iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept
+    {
+        return ref.items();
+    }
+
+    /*!
+    @brief helper to access iterator member functions in range-based for
+
+    This function allows to access @ref iterator::key() and @ref
+    iterator::value() during range-based for loops. In these loops, a
+    reference to the JSON values is returned, so there is no access to the
+    underlying iterator.
+
+    For loop without `items()` function:
+
+    @code{cpp}
+    for (auto it = j_object.begin(); it != j_object.end(); ++it)
+    {
+        std::cout << "key: " << it.key() << ", value:" << it.value() << '\n';
+    }
+    @endcode
+
+    Range-based for loop without `items()` function:
+
+    @code{cpp}
+    for (auto it : j_object)
+    {
+        // "it" is of type json::reference and has no key() member
+        std::cout << "value: " << it << '\n';
+    }
+    @endcode
+
+    Range-based for loop with `items()` function:
+
+    @code{cpp}
+    for (auto& el : j_object.items())
+    {
+        std::cout << "key: " << el.key() << ", value:" << el.value() << '\n';
+    }
+    @endcode
+
+    The `items()` function also allows to use
+    [structured bindings](https://en.cppreference.com/w/cpp/language/structured_binding)
+    (C++17):
+
+    @code{cpp}
+    for (auto& [key, val] : j_object.items())
+    {
+        std::cout << "key: " << key << ", value:" << val << '\n';
+    }
+    @endcode
+
+    @note When iterating over an array, `key()` will return the index of the
+          element as string (see example). For primitive types (e.g., numbers),
+          `key()` returns an empty string.
+
+    @return iteration proxy object wrapping @a ref with an interface to use in
+            range-based for loops
+
+    @liveexample{The following code shows how the function is used.,items}
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Constant.
+
+    @since version 3.1.0, structured bindings support since 3.5.0.
+    */
+    iteration_proxy<iterator> items() noexcept
+    {
+        return iteration_proxy<iterator>(*this);
+    }
+
+    /*!
+    @copydoc items()
+    */
+    iteration_proxy<const_iterator> items() const noexcept
+    {
+        return iteration_proxy<const_iterator>(*this);
+    }
+
+    /// @}
+
+
+    //////////////
+    // capacity //
+    //////////////
+
+    /// @name capacity
+    /// @{
+
+    /*!
+    @brief checks whether the container is empty.
+
+    Checks if a JSON value has no elements (i.e. whether its @ref size is `0`).
+
+    @return The return value depends on the different types and is
+            defined as follows:
+            Value type  | return value
+            ----------- | -------------
+            null        | `true`
+            boolean     | `false`
+            string      | `false`
+            number      | `false`
+            object      | result of function `object_t::empty()`
+            array       | result of function `array_t::empty()`
+
+    @liveexample{The following code uses `empty()` to check if a JSON
+    object contains any elements.,empty}
+
+    @complexity Constant, as long as @ref array_t and @ref object_t satisfy
+    the Container concept; that is, their `empty()` functions have constant
+    complexity.
+
+    @iterators No changes.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @note This function does not return whether a string stored as JSON value
+    is empty - it returns whether the JSON container itself is empty which is
+    false in the case of a string.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `begin() == end()`.
+
+    @sa @ref size() -- returns the number of elements
+
+    @since version 1.0.0
+    */
+    bool empty() const noexcept
+    {
+        switch (m_type)
+        {
+            case value_t::null:
+            {
+                // null values are empty
+                return true;
+            }
+
+            case value_t::array:
+            {
+                // delegate call to array_t::empty()
+                return m_value.array->empty();
+            }
+
+            case value_t::object:
+            {
+                // delegate call to object_t::empty()
+                return m_value.object->empty();
+            }
+
+            default:
+            {
+                // all other types are nonempty
+                return false;
+            }
+        }
+    }
+
+    /*!
+    @brief returns the number of elements
+
+    Returns the number of elements in a JSON value.
+
+    @return The return value depends on the different types and is
+            defined as follows:
+            Value type  | return value
+            ----------- | -------------
+            null        | `0`
+            boolean     | `1`
+            string      | `1`
+            number      | `1`
+            object      | result of function object_t::size()
+            array       | result of function array_t::size()
+
+    @liveexample{The following code calls `size()` on the different value
+    types.,size}
+
+    @complexity Constant, as long as @ref array_t and @ref object_t satisfy
+    the Container concept; that is, their size() functions have constant
+    complexity.
+
+    @iterators No changes.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @note This function does not return the length of a string stored as JSON
+    value - it returns the number of elements in the JSON value which is 1 in
+    the case of a string.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `std::distance(begin(), end())`.
+
+    @sa @ref empty() -- checks whether the container is empty
+    @sa @ref max_size() -- returns the maximal number of elements
+
+    @since version 1.0.0
+    */
+    size_type size() const noexcept
+    {
+        switch (m_type)
+        {
+            case value_t::null:
+            {
+                // null values are empty
+                return 0;
+            }
+
+            case value_t::array:
+            {
+                // delegate call to array_t::size()
+                return m_value.array->size();
+            }
+
+            case value_t::object:
+            {
+                // delegate call to object_t::size()
+                return m_value.object->size();
+            }
+
+            default:
+            {
+                // all other types have size 1
+                return 1;
+            }
+        }
+    }
+
+    /*!
+    @brief returns the maximum possible number of elements
+
+    Returns the maximum number of elements a JSON value is able to hold due to
+    system or library implementation limitations, i.e. `std::distance(begin(),
+    end())` for the JSON value.
+
+    @return The return value depends on the different types and is
+            defined as follows:
+            Value type  | return value
+            ----------- | -------------
+            null        | `0` (same as `size()`)
+            boolean     | `1` (same as `size()`)
+            string      | `1` (same as `size()`)
+            number      | `1` (same as `size()`)
+            object      | result of function `object_t::max_size()`
+            array       | result of function `array_t::max_size()`
+
+    @liveexample{The following code calls `max_size()` on the different value
+    types. Note the output is implementation specific.,max_size}
+
+    @complexity Constant, as long as @ref array_t and @ref object_t satisfy
+    the Container concept; that is, their `max_size()` functions have constant
+    complexity.
+
+    @iterators No changes.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of returning `b.size()` where `b` is the largest
+      possible JSON value.
+
+    @sa @ref size() -- returns the number of elements
+
+    @since version 1.0.0
+    */
+    size_type max_size() const noexcept
+    {
+        switch (m_type)
+        {
+            case value_t::array:
+            {
+                // delegate call to array_t::max_size()
+                return m_value.array->max_size();
+            }
+
+            case value_t::object:
+            {
+                // delegate call to object_t::max_size()
+                return m_value.object->max_size();
+            }
+
+            default:
+            {
+                // all other types have max_size() == size()
+                return size();
+            }
+        }
+    }
+
+    /// @}
+
+
+    ///////////////
+    // modifiers //
+    ///////////////
+
+    /// @name modifiers
+    /// @{
+
+    /*!
+    @brief clears the contents
+
+    Clears the content of a JSON value and resets it to the default value as
+    if @ref basic_json(value_t) would have been called with the current value
+    type from @ref type():
+
+    Value type  | initial value
+    ----------- | -------------
+    null        | `null`
+    boolean     | `false`
+    string      | `""`
+    number      | `0`
+    object      | `{}`
+    array       | `[]`
+
+    @post Has the same effect as calling
+    @code {.cpp}
+    *this = basic_json(type());
+    @endcode
+
+    @liveexample{The example below shows the effect of `clear()` to different
+    JSON types.,clear}
+
+    @complexity Linear in the size of the JSON value.
+
+    @iterators All iterators, pointers and references related to this container
+               are invalidated.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @sa @ref basic_json(value_t) -- constructor that creates an object with the
+        same value than calling `clear()`
+
+    @since version 1.0.0
+    */
+    void clear() noexcept
+    {
+        switch (m_type)
+        {
+            case value_t::number_integer:
+            {
+                m_value.number_integer = 0;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_value.number_unsigned = 0;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_value.number_float = 0.0;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_value.boolean = false;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_value.string->clear();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_value.array->clear();
+                break;
+            }
+
+            case value_t::object:
+            {
+                m_value.object->clear();
+                break;
+            }
+
+            default:
+                break;
+        }
+    }
+
+    /*!
+    @brief add an object to an array
+
+    Appends the given element @a val to the end of the JSON value. If the
+    function is called on a JSON null value, an empty array is created before
+    appending @a val.
+
+    @param[in] val the value to add to the JSON array
+
+    @throw type_error.308 when called on a type other than JSON array or
+    null; example: `"cannot use push_back() with number"`
+
+    @complexity Amortized constant.
+
+    @liveexample{The example shows how `push_back()` and `+=` can be used to
+    add elements to a JSON array. Note how the `null` value was silently
+    converted to a JSON array.,push_back}
+
+    @since version 1.0.0
+    */
+    void push_back(basic_json&& val)
+    {
+        // push_back only works for null objects or arrays
+        if (JSON_UNLIKELY(not(is_null() or is_array())))
+        {
+            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
+        }
+
+        // transform null object into an array
+        if (is_null())
+        {
+            m_type = value_t::array;
+            m_value = value_t::array;
+            assert_invariant();
+        }
+
+        // add element to array (move semantics)
+        m_value.array->push_back(std::move(val));
+        // invalidate object
+        val.m_type = value_t::null;
+    }
+
+    /*!
+    @brief add an object to an array
+    @copydoc push_back(basic_json&&)
+    */
+    reference operator+=(basic_json&& val)
+    {
+        push_back(std::move(val));
+        return *this;
+    }
+
+    /*!
+    @brief add an object to an array
+    @copydoc push_back(basic_json&&)
+    */
+    void push_back(const basic_json& val)
+    {
+        // push_back only works for null objects or arrays
+        if (JSON_UNLIKELY(not(is_null() or is_array())))
+        {
+            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
+        }
+
+        // transform null object into an array
+        if (is_null())
+        {
+            m_type = value_t::array;
+            m_value = value_t::array;
+            assert_invariant();
+        }
+
+        // add element to array
+        m_value.array->push_back(val);
+    }
+
+    /*!
+    @brief add an object to an array
+    @copydoc push_back(basic_json&&)
+    */
+    reference operator+=(const basic_json& val)
+    {
+        push_back(val);
+        return *this;
+    }
+
+    /*!
+    @brief add an object to an object
+
+    Inserts the given element @a val to the JSON object. If the function is
+    called on a JSON null value, an empty object is created before inserting
+    @a val.
+
+    @param[in] val the value to add to the JSON object
+
+    @throw type_error.308 when called on a type other than JSON object or
+    null; example: `"cannot use push_back() with number"`
+
+    @complexity Logarithmic in the size of the container, O(log(`size()`)).
+
+    @liveexample{The example shows how `push_back()` and `+=` can be used to
+    add elements to a JSON object. Note how the `null` value was silently
+    converted to a JSON object.,push_back__object_t__value}
+
+    @since version 1.0.0
+    */
+    void push_back(const typename object_t::value_type& val)
+    {
+        // push_back only works for null objects or objects
+        if (JSON_UNLIKELY(not(is_null() or is_object())))
+        {
+            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
+        }
+
+        // transform null object into an object
+        if (is_null())
+        {
+            m_type = value_t::object;
+            m_value = value_t::object;
+            assert_invariant();
+        }
+
+        // add element to array
+        m_value.object->insert(val);
+    }
+
+    /*!
+    @brief add an object to an object
+    @copydoc push_back(const typename object_t::value_type&)
+    */
+    reference operator+=(const typename object_t::value_type& val)
+    {
+        push_back(val);
+        return *this;
+    }
+
+    /*!
+    @brief add an object to an object
+
+    This function allows to use `push_back` with an initializer list. In case
+
+    1. the current value is an object,
+    2. the initializer list @a init contains only two elements, and
+    3. the first element of @a init is a string,
+
+    @a init is converted into an object element and added using
+    @ref push_back(const typename object_t::value_type&). Otherwise, @a init
+    is converted to a JSON value and added using @ref push_back(basic_json&&).
+
+    @param[in] init  an initializer list
+
+    @complexity Linear in the size of the initializer list @a init.
+
+    @note This function is required to resolve an ambiguous overload error,
+          because pairs like `{"key", "value"}` can be both interpreted as
+          `object_t::value_type` or `std::initializer_list<basic_json>`, see
+          https://github.com/nlohmann/json/issues/235 for more information.
+
+    @liveexample{The example shows how initializer lists are treated as
+    objects when possible.,push_back__initializer_list}
+    */
+    void push_back(initializer_list_t init)
+    {
+        if (is_object() and init.size() == 2 and (*init.begin())->is_string())
+        {
+            basic_json&& key = init.begin()->moved_or_copied();
+            push_back(typename object_t::value_type(
+                          std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));
+        }
+        else
+        {
+            push_back(basic_json(init));
+        }
+    }
+
+    /*!
+    @brief add an object to an object
+    @copydoc push_back(initializer_list_t)
+    */
+    reference operator+=(initializer_list_t init)
+    {
+        push_back(init);
+        return *this;
+    }
+
+    /*!
+    @brief add an object to an array
+
+    Creates a JSON value from the passed parameters @a args to the end of the
+    JSON value. If the function is called on a JSON null value, an empty array
+    is created before appending the value created from @a args.
+
+    @param[in] args arguments to forward to a constructor of @ref basic_json
+    @tparam Args compatible types to create a @ref basic_json object
+
+    @throw type_error.311 when called on a type other than JSON array or
+    null; example: `"cannot use emplace_back() with number"`
+
+    @complexity Amortized constant.
+
+    @liveexample{The example shows how `push_back()` can be used to add
+    elements to a JSON array. Note how the `null` value was silently converted
+    to a JSON array.,emplace_back}
+
+    @since version 2.0.8
+    */
+    template<class... Args>
+    void emplace_back(Args&& ... args)
+    {
+        // emplace_back only works for null objects or arrays
+        if (JSON_UNLIKELY(not(is_null() or is_array())))
+        {
+            JSON_THROW(type_error::create(311, "cannot use emplace_back() with " + std::string(type_name())));
+        }
+
+        // transform null object into an array
+        if (is_null())
+        {
+            m_type = value_t::array;
+            m_value = value_t::array;
+            assert_invariant();
+        }
+
+        // add element to array (perfect forwarding)
+        m_value.array->emplace_back(std::forward<Args>(args)...);
+    }
+
+    /*!
+    @brief add an object to an object if key does not exist
+
+    Inserts a new element into a JSON object constructed in-place with the
+    given @a args if there is no element with the key in the container. If the
+    function is called on a JSON null value, an empty object is created before
+    appending the value created from @a args.
+
+    @param[in] args arguments to forward to a constructor of @ref basic_json
+    @tparam Args compatible types to create a @ref basic_json object
+
+    @return a pair consisting of an iterator to the inserted element, or the
+            already-existing element if no insertion happened, and a bool
+            denoting whether the insertion took place.
+
+    @throw type_error.311 when called on a type other than JSON object or
+    null; example: `"cannot use emplace() with number"`
+
+    @complexity Logarithmic in the size of the container, O(log(`size()`)).
+
+    @liveexample{The example shows how `emplace()` can be used to add elements
+    to a JSON object. Note how the `null` value was silently converted to a
+    JSON object. Further note how no value is added if there was already one
+    value stored with the same key.,emplace}
+
+    @since version 2.0.8
+    */
+    template<class... Args>
+    std::pair<iterator, bool> emplace(Args&& ... args)
+    {
+        // emplace only works for null objects or arrays
+        if (JSON_UNLIKELY(not(is_null() or is_object())))
+        {
+            JSON_THROW(type_error::create(311, "cannot use emplace() with " + std::string(type_name())));
+        }
+
+        // transform null object into an object
+        if (is_null())
+        {
+            m_type = value_t::object;
+            m_value = value_t::object;
+            assert_invariant();
+        }
+
+        // add element to array (perfect forwarding)
+        auto res = m_value.object->emplace(std::forward<Args>(args)...);
+        // create result iterator and set iterator to the result of emplace
+        auto it = begin();
+        it.m_it.object_iterator = res.first;
+
+        // return pair of iterator and boolean
+        return {it, res.second};
+    }
+
+    /// Helper for insertion of an iterator
+    /// @note: This uses std::distance to support GCC 4.8,
+    ///        see https://github.com/nlohmann/json/pull/1257
+    template<typename... Args>
+    iterator insert_iterator(const_iterator pos, Args&& ... args)
+    {
+        iterator result(this);
+        assert(m_value.array != nullptr);
+
+        auto insert_pos = std::distance(m_value.array->begin(), pos.m_it.array_iterator);
+        m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
+        result.m_it.array_iterator = m_value.array->begin() + insert_pos;
+
+        // This could have been written as:
+        // result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, cnt, val);
+        // but the return value of insert is missing in GCC 4.8, so it is written this way instead.
+
+        return result;
+    }
+
+    /*!
+    @brief inserts element
+
+    Inserts element @a val before iterator @a pos.
+
+    @param[in] pos iterator before which the content will be inserted; may be
+    the end() iterator
+    @param[in] val element to insert
+    @return iterator pointing to the inserted @a val.
+
+    @throw type_error.309 if called on JSON values other than arrays;
+    example: `"cannot use insert() with string"`
+    @throw invalid_iterator.202 if @a pos is not an iterator of *this;
+    example: `"iterator does not fit current value"`
+
+    @complexity Constant plus linear in the distance between @a pos and end of
+    the container.
+
+    @liveexample{The example shows how `insert()` is used.,insert}
+
+    @since version 1.0.0
+    */
+    iterator insert(const_iterator pos, const basic_json& val)
+    {
+        // insert only works for arrays
+        if (JSON_LIKELY(is_array()))
+        {
+            // check if iterator pos fits to this JSON value
+            if (JSON_UNLIKELY(pos.m_object != this))
+            {
+                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
+            }
+
+            // insert to array and return iterator
+            return insert_iterator(pos, val);
+        }
+
+        JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief inserts element
+    @copydoc insert(const_iterator, const basic_json&)
+    */
+    iterator insert(const_iterator pos, basic_json&& val)
+    {
+        return insert(pos, val);
+    }
+
+    /*!
+    @brief inserts elements
+
+    Inserts @a cnt copies of @a val before iterator @a pos.
+
+    @param[in] pos iterator before which the content will be inserted; may be
+    the end() iterator
+    @param[in] cnt number of copies of @a val to insert
+    @param[in] val element to insert
+    @return iterator pointing to the first element inserted, or @a pos if
+    `cnt==0`
+
+    @throw type_error.309 if called on JSON values other than arrays; example:
+    `"cannot use insert() with string"`
+    @throw invalid_iterator.202 if @a pos is not an iterator of *this;
+    example: `"iterator does not fit current value"`
+
+    @complexity Linear in @a cnt plus linear in the distance between @a pos
+    and end of the container.
+
+    @liveexample{The example shows how `insert()` is used.,insert__count}
+
+    @since version 1.0.0
+    */
+    iterator insert(const_iterator pos, size_type cnt, const basic_json& val)
+    {
+        // insert only works for arrays
+        if (JSON_LIKELY(is_array()))
+        {
+            // check if iterator pos fits to this JSON value
+            if (JSON_UNLIKELY(pos.m_object != this))
+            {
+                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
+            }
+
+            // insert to array and return iterator
+            return insert_iterator(pos, cnt, val);
+        }
+
+        JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief inserts elements
+
+    Inserts elements from range `[first, last)` before iterator @a pos.
+
+    @param[in] pos iterator before which the content will be inserted; may be
+    the end() iterator
+    @param[in] first begin of the range of elements to insert
+    @param[in] last end of the range of elements to insert
+
+    @throw type_error.309 if called on JSON values other than arrays; example:
+    `"cannot use insert() with string"`
+    @throw invalid_iterator.202 if @a pos is not an iterator of *this;
+    example: `"iterator does not fit current value"`
+    @throw invalid_iterator.210 if @a first and @a last do not belong to the
+    same JSON value; example: `"iterators do not fit"`
+    @throw invalid_iterator.211 if @a first or @a last are iterators into
+    container for which insert is called; example: `"passed iterators may not
+    belong to container"`
+
+    @return iterator pointing to the first element inserted, or @a pos if
+    `first==last`
+
+    @complexity Linear in `std::distance(first, last)` plus linear in the
+    distance between @a pos and end of the container.
+
+    @liveexample{The example shows how `insert()` is used.,insert__range}
+
+    @since version 1.0.0
+    */
+    iterator insert(const_iterator pos, const_iterator first, const_iterator last)
+    {
+        // insert only works for arrays
+        if (JSON_UNLIKELY(not is_array()))
+        {
+            JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
+        }
+
+        // check if iterator pos fits to this JSON value
+        if (JSON_UNLIKELY(pos.m_object != this))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
+        }
+
+        // check if range iterators belong to the same JSON object
+        if (JSON_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
+        }
+
+        if (JSON_UNLIKELY(first.m_object == this))
+        {
+            JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container"));
+        }
+
+        // insert to array and return iterator
+        return insert_iterator(pos, first.m_it.array_iterator, last.m_it.array_iterator);
+    }
+
+    /*!
+    @brief inserts elements
+
+    Inserts elements from initializer list @a ilist before iterator @a pos.
+
+    @param[in] pos iterator before which the content will be inserted; may be
+    the end() iterator
+    @param[in] ilist initializer list to insert the values from
+
+    @throw type_error.309 if called on JSON values other than arrays; example:
+    `"cannot use insert() with string"`
+    @throw invalid_iterator.202 if @a pos is not an iterator of *this;
+    example: `"iterator does not fit current value"`
+
+    @return iterator pointing to the first element inserted, or @a pos if
+    `ilist` is empty
+
+    @complexity Linear in `ilist.size()` plus linear in the distance between
+    @a pos and end of the container.
+
+    @liveexample{The example shows how `insert()` is used.,insert__ilist}
+
+    @since version 1.0.0
+    */
+    iterator insert(const_iterator pos, initializer_list_t ilist)
+    {
+        // insert only works for arrays
+        if (JSON_UNLIKELY(not is_array()))
+        {
+            JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
+        }
+
+        // check if iterator pos fits to this JSON value
+        if (JSON_UNLIKELY(pos.m_object != this))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
+        }
+
+        // insert to array and return iterator
+        return insert_iterator(pos, ilist.begin(), ilist.end());
+    }
+
+    /*!
+    @brief inserts elements
+
+    Inserts elements from range `[first, last)`.
+
+    @param[in] first begin of the range of elements to insert
+    @param[in] last end of the range of elements to insert
+
+    @throw type_error.309 if called on JSON values other than objects; example:
+    `"cannot use insert() with string"`
+    @throw invalid_iterator.202 if iterator @a first or @a last does does not
+    point to an object; example: `"iterators first and last must point to
+    objects"`
+    @throw invalid_iterator.210 if @a first and @a last do not belong to the
+    same JSON value; example: `"iterators do not fit"`
+
+    @complexity Logarithmic: `O(N*log(size() + N))`, where `N` is the number
+    of elements to insert.
+
+    @liveexample{The example shows how `insert()` is used.,insert__range_object}
+
+    @since version 3.0.0
+    */
+    void insert(const_iterator first, const_iterator last)
+    {
+        // insert only works for objects
+        if (JSON_UNLIKELY(not is_object()))
+        {
+            JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
+        }
+
+        // check if range iterators belong to the same JSON object
+        if (JSON_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
+        }
+
+        // passed iterators must belong to objects
+        if (JSON_UNLIKELY(not first.m_object->is_object()))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));
+        }
+
+        m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
+    }
+
+    /*!
+    @brief updates a JSON object from another object, overwriting existing keys
+
+    Inserts all values from JSON object @a j and overwrites existing keys.
+
+    @param[in] j  JSON object to read values from
+
+    @throw type_error.312 if called on JSON values other than objects; example:
+    `"cannot use update() with string"`
+
+    @complexity O(N*log(size() + N)), where N is the number of elements to
+                insert.
+
+    @liveexample{The example shows how `update()` is used.,update}
+
+    @sa https://docs.python.org/3.6/library/stdtypes.html#dict.update
+
+    @since version 3.0.0
+    */
+    void update(const_reference j)
+    {
+        // implicitly convert null value to an empty object
+        if (is_null())
+        {
+            m_type = value_t::object;
+            m_value.object = create<object_t>();
+            assert_invariant();
+        }
+
+        if (JSON_UNLIKELY(not is_object()))
+        {
+            JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name())));
+        }
+        if (JSON_UNLIKELY(not j.is_object()))
+        {
+            JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(j.type_name())));
+        }
+
+        for (auto it = j.cbegin(); it != j.cend(); ++it)
+        {
+            m_value.object->operator[](it.key()) = it.value();
+        }
+    }
+
+    /*!
+    @brief updates a JSON object from another object, overwriting existing keys
+
+    Inserts all values from from range `[first, last)` and overwrites existing
+    keys.
+
+    @param[in] first begin of the range of elements to insert
+    @param[in] last end of the range of elements to insert
+
+    @throw type_error.312 if called on JSON values other than objects; example:
+    `"cannot use update() with string"`
+    @throw invalid_iterator.202 if iterator @a first or @a last does does not
+    point to an object; example: `"iterators first and last must point to
+    objects"`
+    @throw invalid_iterator.210 if @a first and @a last do not belong to the
+    same JSON value; example: `"iterators do not fit"`
+
+    @complexity O(N*log(size() + N)), where N is the number of elements to
+                insert.
+
+    @liveexample{The example shows how `update()` is used__range.,update}
+
+    @sa https://docs.python.org/3.6/library/stdtypes.html#dict.update
+
+    @since version 3.0.0
+    */
+    void update(const_iterator first, const_iterator last)
+    {
+        // implicitly convert null value to an empty object
+        if (is_null())
+        {
+            m_type = value_t::object;
+            m_value.object = create<object_t>();
+            assert_invariant();
+        }
+
+        if (JSON_UNLIKELY(not is_object()))
+        {
+            JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name())));
+        }
+
+        // check if range iterators belong to the same JSON object
+        if (JSON_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
+        }
+
+        // passed iterators must belong to objects
+        if (JSON_UNLIKELY(not first.m_object->is_object()
+                          or not last.m_object->is_object()))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));
+        }
+
+        for (auto it = first; it != last; ++it)
+        {
+            m_value.object->operator[](it.key()) = it.value();
+        }
+    }
+
+    /*!
+    @brief exchanges the values
+
+    Exchanges the contents of the JSON value with those of @a other. Does not
+    invoke any move, copy, or swap operations on individual elements. All
+    iterators and references remain valid. The past-the-end iterator is
+    invalidated.
+
+    @param[in,out] other JSON value to exchange the contents with
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how JSON values can be swapped with
+    `swap()`.,swap__reference}
+
+    @since version 1.0.0
+    */
+    void swap(reference other) noexcept (
+        std::is_nothrow_move_constructible<value_t>::value and
+        std::is_nothrow_move_assignable<value_t>::value and
+        std::is_nothrow_move_constructible<json_value>::value and
+        std::is_nothrow_move_assignable<json_value>::value
+    )
+    {
+        std::swap(m_type, other.m_type);
+        std::swap(m_value, other.m_value);
+        assert_invariant();
+    }
+
+    /*!
+    @brief exchanges the values
+
+    Exchanges the contents of a JSON array with those of @a other. Does not
+    invoke any move, copy, or swap operations on individual elements. All
+    iterators and references remain valid. The past-the-end iterator is
+    invalidated.
+
+    @param[in,out] other array to exchange the contents with
+
+    @throw type_error.310 when JSON value is not an array; example: `"cannot
+    use swap() with string"`
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how arrays can be swapped with
+    `swap()`.,swap__array_t}
+
+    @since version 1.0.0
+    */
+    void swap(array_t& other)
+    {
+        // swap only works for arrays
+        if (JSON_LIKELY(is_array()))
+        {
+            std::swap(*(m_value.array), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
+        }
+    }
+
+    /*!
+    @brief exchanges the values
+
+    Exchanges the contents of a JSON object with those of @a other. Does not
+    invoke any move, copy, or swap operations on individual elements. All
+    iterators and references remain valid. The past-the-end iterator is
+    invalidated.
+
+    @param[in,out] other object to exchange the contents with
+
+    @throw type_error.310 when JSON value is not an object; example:
+    `"cannot use swap() with string"`
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how objects can be swapped with
+    `swap()`.,swap__object_t}
+
+    @since version 1.0.0
+    */
+    void swap(object_t& other)
+    {
+        // swap only works for objects
+        if (JSON_LIKELY(is_object()))
+        {
+            std::swap(*(m_value.object), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
+        }
+    }
+
+    /*!
+    @brief exchanges the values
+
+    Exchanges the contents of a JSON string with those of @a other. Does not
+    invoke any move, copy, or swap operations on individual elements. All
+    iterators and references remain valid. The past-the-end iterator is
+    invalidated.
+
+    @param[in,out] other string to exchange the contents with
+
+    @throw type_error.310 when JSON value is not a string; example: `"cannot
+    use swap() with boolean"`
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how strings can be swapped with
+    `swap()`.,swap__string_t}
+
+    @since version 1.0.0
+    */
+    void swap(string_t& other)
+    {
+        // swap only works for strings
+        if (JSON_LIKELY(is_string()))
+        {
+            std::swap(*(m_value.string), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
+        }
+    }
+
+    /// @}
+
+  public:
+    //////////////////////////////////////////
+    // lexicographical comparison operators //
+    //////////////////////////////////////////
+
+    /// @name lexicographical comparison operators
+    /// @{
+
+    /*!
+    @brief comparison: equal
+
+    Compares two JSON values for equality according to the following rules:
+    - Two JSON values are equal if (1) they are from the same type and (2)
+      their stored values are the same according to their respective
+      `operator==`.
+    - Integer and floating-point numbers are automatically converted before
+      comparison. Note than two NaN values are always treated as unequal.
+    - Two JSON null values are equal.
+
+    @note Floating-point inside JSON values numbers are compared with
+    `json::number_float_t::operator==` which is `double::operator==` by
+    default. To compare floating-point while respecting an epsilon, an alternative
+    [comparison function](https://github.com/mariokonrad/marnav/blob/master/src/marnav/math/floatingpoint.hpp#L34-#L39)
+    could be used, for instance
+    @code {.cpp}
+    template<typename T, typename = typename std::enable_if<std::is_floating_point<T>::value, T>::type>
+    inline bool is_same(T a, T b, T epsilon = std::numeric_limits<T>::epsilon()) noexcept
+    {
+        return std::abs(a - b) <= epsilon;
+    }
+    @endcode
+
+    @note NaN values never compare equal to themselves or to other NaN values.
+
+    @param[in] lhs  first JSON value to consider
+    @param[in] rhs  second JSON value to consider
+    @return whether the values @a lhs and @a rhs are equal
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @complexity Linear.
+
+    @liveexample{The example demonstrates comparing several JSON
+    types.,operator__equal}
+
+    @since version 1.0.0
+    */
+    friend bool operator==(const_reference lhs, const_reference rhs) noexcept
+    {
+        const auto lhs_type = lhs.type();
+        const auto rhs_type = rhs.type();
+
+        if (lhs_type == rhs_type)
+        {
+            switch (lhs_type)
+            {
+                case value_t::array:
+                    return (*lhs.m_value.array == *rhs.m_value.array);
+
+                case value_t::object:
+                    return (*lhs.m_value.object == *rhs.m_value.object);
+
+                case value_t::null:
+                    return true;
+
+                case value_t::string:
+                    return (*lhs.m_value.string == *rhs.m_value.string);
+
+                case value_t::boolean:
+                    return (lhs.m_value.boolean == rhs.m_value.boolean);
+
+                case value_t::number_integer:
+                    return (lhs.m_value.number_integer == rhs.m_value.number_integer);
+
+                case value_t::number_unsigned:
+                    return (lhs.m_value.number_unsigned == rhs.m_value.number_unsigned);
+
+                case value_t::number_float:
+                    return (lhs.m_value.number_float == rhs.m_value.number_float);
+
+                default:
+                    return false;
+            }
+        }
+        else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)
+        {
+            return (static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float);
+        }
+        else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)
+        {
+            return (lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_integer));
+        }
+        else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float)
+        {
+            return (static_cast<number_float_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_float);
+        }
+        else if (lhs_type == value_t::number_float and rhs_type == value_t::number_unsigned)
+        {
+            return (lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_unsigned));
+        }
+        else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer)
+        {
+            return (static_cast<number_integer_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_integer);
+        }
+        else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_unsigned)
+        {
+            return (lhs.m_value.number_integer == static_cast<number_integer_t>(rhs.m_value.number_unsigned));
+        }
+
+        return false;
+    }
+
+    /*!
+    @brief comparison: equal
+    @copydoc operator==(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator==(const_reference lhs, const ScalarType rhs) noexcept
+    {
+        return (lhs == basic_json(rhs));
+    }
+
+    /*!
+    @brief comparison: equal
+    @copydoc operator==(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator==(const ScalarType lhs, const_reference rhs) noexcept
+    {
+        return (basic_json(lhs) == rhs);
+    }
+
+    /*!
+    @brief comparison: not equal
+
+    Compares two JSON values for inequality by calculating `not (lhs == rhs)`.
+
+    @param[in] lhs  first JSON value to consider
+    @param[in] rhs  second JSON value to consider
+    @return whether the values @a lhs and @a rhs are not equal
+
+    @complexity Linear.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @liveexample{The example demonstrates comparing several JSON
+    types.,operator__notequal}
+
+    @since version 1.0.0
+    */
+    friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
+    {
+        return not (lhs == rhs);
+    }
+
+    /*!
+    @brief comparison: not equal
+    @copydoc operator!=(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator!=(const_reference lhs, const ScalarType rhs) noexcept
+    {
+        return (lhs != basic_json(rhs));
+    }
+
+    /*!
+    @brief comparison: not equal
+    @copydoc operator!=(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator!=(const ScalarType lhs, const_reference rhs) noexcept
+    {
+        return (basic_json(lhs) != rhs);
+    }
+
+    /*!
+    @brief comparison: less than
+
+    Compares whether one JSON value @a lhs is less than another JSON value @a
+    rhs according to the following rules:
+    - If @a lhs and @a rhs have the same type, the values are compared using
+      the default `<` operator.
+    - Integer and floating-point numbers are automatically converted before
+      comparison
+    - In case @a lhs and @a rhs have different types, the values are ignored
+      and the order of the types is considered, see
+      @ref operator<(const value_t, const value_t).
+
+    @param[in] lhs  first JSON value to consider
+    @param[in] rhs  second JSON value to consider
+    @return whether @a lhs is less than @a rhs
+
+    @complexity Linear.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @liveexample{The example demonstrates comparing several JSON
+    types.,operator__less}
+
+    @since version 1.0.0
+    */
+    friend bool operator<(const_reference lhs, const_reference rhs) noexcept
+    {
+        const auto lhs_type = lhs.type();
+        const auto rhs_type = rhs.type();
+
+        if (lhs_type == rhs_type)
+        {
+            switch (lhs_type)
+            {
+                case value_t::array:
+                    return (*lhs.m_value.array) < (*rhs.m_value.array);
+
+                case value_t::object:
+                    return *lhs.m_value.object < *rhs.m_value.object;
+
+                case value_t::null:
+                    return false;
+
+                case value_t::string:
+                    return *lhs.m_value.string < *rhs.m_value.string;
+
+                case value_t::boolean:
+                    return lhs.m_value.boolean < rhs.m_value.boolean;
+
+                case value_t::number_integer:
+                    return lhs.m_value.number_integer < rhs.m_value.number_integer;
+
+                case value_t::number_unsigned:
+                    return lhs.m_value.number_unsigned < rhs.m_value.number_unsigned;
+
+                case value_t::number_float:
+                    return lhs.m_value.number_float < rhs.m_value.number_float;
+
+                default:
+                    return false;
+            }
+        }
+        else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)
+        {
+            return static_cast<number_float_t>(lhs.m_value.number_integer) < rhs.m_value.number_float;
+        }
+        else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)
+        {
+            return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_integer);
+        }
+        else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float)
+        {
+            return static_cast<number_float_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_float;
+        }
+        else if (lhs_type == value_t::number_float and rhs_type == value_t::number_unsigned)
+        {
+            return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_unsigned);
+        }
+        else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_unsigned)
+        {
+            return lhs.m_value.number_integer < static_cast<number_integer_t>(rhs.m_value.number_unsigned);
+        }
+        else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer)
+        {
+            return static_cast<number_integer_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_integer;
+        }
+
+        // We only reach this line if we cannot compare values. In that case,
+        // we compare types. Note we have to call the operator explicitly,
+        // because MSVC has problems otherwise.
+        return operator<(lhs_type, rhs_type);
+    }
+
+    /*!
+    @brief comparison: less than
+    @copydoc operator<(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<(const_reference lhs, const ScalarType rhs) noexcept
+    {
+        return (lhs < basic_json(rhs));
+    }
+
+    /*!
+    @brief comparison: less than
+    @copydoc operator<(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<(const ScalarType lhs, const_reference rhs) noexcept
+    {
+        return (basic_json(lhs) < rhs);
+    }
+
+    /*!
+    @brief comparison: less than or equal
+
+    Compares whether one JSON value @a lhs is less than or equal to another
+    JSON value by calculating `not (rhs < lhs)`.
+
+    @param[in] lhs  first JSON value to consider
+    @param[in] rhs  second JSON value to consider
+    @return whether @a lhs is less than or equal to @a rhs
+
+    @complexity Linear.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @liveexample{The example demonstrates comparing several JSON
+    types.,operator__greater}
+
+    @since version 1.0.0
+    */
+    friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
+    {
+        return not (rhs < lhs);
+    }
+
+    /*!
+    @brief comparison: less than or equal
+    @copydoc operator<=(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<=(const_reference lhs, const ScalarType rhs) noexcept
+    {
+        return (lhs <= basic_json(rhs));
+    }
+
+    /*!
+    @brief comparison: less than or equal
+    @copydoc operator<=(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<=(const ScalarType lhs, const_reference rhs) noexcept
+    {
+        return (basic_json(lhs) <= rhs);
+    }
+
+    /*!
+    @brief comparison: greater than
+
+    Compares whether one JSON value @a lhs is greater than another
+    JSON value by calculating `not (lhs <= rhs)`.
+
+    @param[in] lhs  first JSON value to consider
+    @param[in] rhs  second JSON value to consider
+    @return whether @a lhs is greater than to @a rhs
+
+    @complexity Linear.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @liveexample{The example demonstrates comparing several JSON
+    types.,operator__lessequal}
+
+    @since version 1.0.0
+    */
+    friend bool operator>(const_reference lhs, const_reference rhs) noexcept
+    {
+        return not (lhs <= rhs);
+    }
+
+    /*!
+    @brief comparison: greater than
+    @copydoc operator>(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>(const_reference lhs, const ScalarType rhs) noexcept
+    {
+        return (lhs > basic_json(rhs));
+    }
+
+    /*!
+    @brief comparison: greater than
+    @copydoc operator>(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>(const ScalarType lhs, const_reference rhs) noexcept
+    {
+        return (basic_json(lhs) > rhs);
+    }
+
+    /*!
+    @brief comparison: greater than or equal
+
+    Compares whether one JSON value @a lhs is greater than or equal to another
+    JSON value by calculating `not (lhs < rhs)`.
+
+    @param[in] lhs  first JSON value to consider
+    @param[in] rhs  second JSON value to consider
+    @return whether @a lhs is greater than or equal to @a rhs
+
+    @complexity Linear.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @liveexample{The example demonstrates comparing several JSON
+    types.,operator__greaterequal}
+
+    @since version 1.0.0
+    */
+    friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
+    {
+        return not (lhs < rhs);
+    }
+
+    /*!
+    @brief comparison: greater than or equal
+    @copydoc operator>=(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>=(const_reference lhs, const ScalarType rhs) noexcept
+    {
+        return (lhs >= basic_json(rhs));
+    }
+
+    /*!
+    @brief comparison: greater than or equal
+    @copydoc operator>=(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>=(const ScalarType lhs, const_reference rhs) noexcept
+    {
+        return (basic_json(lhs) >= rhs);
+    }
+
+    /// @}
+
+    ///////////////////
+    // serialization //
+    ///////////////////
+
+    /// @name serialization
+    /// @{
+
+    /*!
+    @brief serialize to stream
+
+    Serialize the given JSON value @a j to the output stream @a o. The JSON
+    value will be serialized using the @ref dump member function.
+
+    - The indentation of the output can be controlled with the member variable
+      `width` of the output stream @a o. For instance, using the manipulator
+      `std::setw(4)` on @a o sets the indentation level to `4` and the
+      serialization result is the same as calling `dump(4)`.
+
+    - The indentation character can be controlled with the member variable
+      `fill` of the output stream @a o. For instance, the manipulator
+      `std::setfill('\\t')` sets indentation to use a tab character rather than
+      the default space character.
+
+    @param[in,out] o  stream to serialize to
+    @param[in] j  JSON value to serialize
+
+    @return the stream @a o
+
+    @throw type_error.316 if a string stored inside the JSON value is not
+                          UTF-8 encoded
+
+    @complexity Linear.
+
+    @liveexample{The example below shows the serialization with different
+    parameters to `width` to adjust the indentation level.,operator_serialize}
+
+    @since version 1.0.0; indentation character added in version 3.0.0
+    */
+    friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
+    {
+        // read width member and use it as indentation parameter if nonzero
+        const bool pretty_print = (o.width() > 0);
+        const auto indentation = (pretty_print ? o.width() : 0);
+
+        // reset width to 0 for subsequent calls to this stream
+        o.width(0);
+
+        // do the actual serialization
+        serializer s(detail::output_adapter<char>(o), o.fill());
+        s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));
+        return o;
+    }
+
+    /*!
+    @brief serialize to stream
+    @deprecated This stream operator is deprecated and will be removed in
+                future 4.0.0 of the library. Please use
+                @ref operator<<(std::ostream&, const basic_json&)
+                instead; that is, replace calls like `j >> o;` with `o << j;`.
+    @since version 1.0.0; deprecated since version 3.0.0
+    */
+    JSON_DEPRECATED
+    friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
+    {
+        return o << j;
+    }
+
+    /// @}
+
+
+    /////////////////////
+    // deserialization //
+    /////////////////////
+
+    /// @name deserialization
+    /// @{
+
+    /*!
+    @brief deserialize from a compatible input
+
+    This function reads from a compatible input. Examples are:
+    - an array of 1-byte values
+    - strings with character/literal type with size of 1 byte
+    - input streams
+    - container with contiguous storage of 1-byte values. Compatible container
+      types include `std::vector`, `std::string`, `std::array`,
+      `std::valarray`, and `std::initializer_list`. Furthermore, C-style
+      arrays can be used with `std::begin()`/`std::end()`. User-defined
+      containers can be used as long as they implement random-access iterators
+      and a contiguous storage.
+
+    @pre Each element of the container has a size of 1 byte. Violating this
+    precondition yields undefined behavior. **This precondition is enforced
+    with a static assertion.**
+
+    @pre The container storage is contiguous. Violating this precondition
+    yields undefined behavior. **This precondition is enforced with an
+    assertion.**
+    @pre Each element of the container has a size of 1 byte. Violating this
+    precondition yields undefined behavior. **This precondition is enforced
+    with a static assertion.**
+
+    @warning There is no way to enforce all preconditions at compile-time. If
+             the function is called with a noncompliant container and with
+             assertions switched off, the behavior is undefined and will most
+             likely yield segmentation violation.
+
+    @param[in] i  input to read from
+    @param[in] cb  a parser callback function of type @ref parser_callback_t
+    which is used to control the deserialization by filtering unwanted values
+    (optional)
+    @param[in] allow_exceptions  whether to throw exceptions in case of a
+    parse error (optional, true by default)
+
+    @return result of the deserialization
+
+    @throw parse_error.101 if a parse error occurs; example: `""unexpected end
+    of input; expected string literal""`
+    @throw parse_error.102 if to_unicode fails or surrogate error
+    @throw parse_error.103 if to_unicode fails
+
+    @complexity Linear in the length of the input. The parser is a predictive
+    LL(1) parser. The complexity can be higher if the parser callback function
+    @a cb has a super-linear complexity.
+
+    @note A UTF-8 byte order mark is silently ignored.
+
+    @liveexample{The example below demonstrates the `parse()` function reading
+    from an array.,parse__array__parser_callback_t}
+
+    @liveexample{The example below demonstrates the `parse()` function with
+    and without callback function.,parse__string__parser_callback_t}
+
+    @liveexample{The example below demonstrates the `parse()` function with
+    and without callback function.,parse__istream__parser_callback_t}
+
+    @liveexample{The example below demonstrates the `parse()` function reading
+    from a contiguous container.,parse__contiguouscontainer__parser_callback_t}
+
+    @since version 2.0.3 (contiguous containers)
+    */
+    static basic_json parse(detail::input_adapter&& i,
+                            const parser_callback_t cb = nullptr,
+                            const bool allow_exceptions = true)
+    {
+        basic_json result;
+        parser(i, cb, allow_exceptions).parse(true, result);
+        return result;
+    }
+
+    static bool accept(detail::input_adapter&& i)
+    {
+        return parser(i).accept(true);
+    }
+
+    /*!
+    @brief generate SAX events
+
+    The SAX event lister must follow the interface of @ref json_sax.
+
+    This function reads from a compatible input. Examples are:
+    - an array of 1-byte values
+    - strings with character/literal type with size of 1 byte
+    - input streams
+    - container with contiguous storage of 1-byte values. Compatible container
+      types include `std::vector`, `std::string`, `std::array`,
+      `std::valarray`, and `std::initializer_list`. Furthermore, C-style
+      arrays can be used with `std::begin()`/`std::end()`. User-defined
+      containers can be used as long as they implement random-access iterators
+      and a contiguous storage.
+
+    @pre Each element of the container has a size of 1 byte. Violating this
+    precondition yields undefined behavior. **This precondition is enforced
+    with a static assertion.**
+
+    @pre The container storage is contiguous. Violating this precondition
+    yields undefined behavior. **This precondition is enforced with an
+    assertion.**
+    @pre Each element of the container has a size of 1 byte. Violating this
+    precondition yields undefined behavior. **This precondition is enforced
+    with a static assertion.**
+
+    @warning There is no way to enforce all preconditions at compile-time. If
+             the function is called with a noncompliant container and with
+             assertions switched off, the behavior is undefined and will most
+             likely yield segmentation violation.
+
+    @param[in] i  input to read from
+    @param[in,out] sax  SAX event listener
+    @param[in] format  the format to parse (JSON, CBOR, MessagePack, or UBJSON)
+    @param[in] strict  whether the input has to be consumed completely
+
+    @return return value of the last processed SAX event
+
+    @throw parse_error.101 if a parse error occurs; example: `""unexpected end
+    of input; expected string literal""`
+    @throw parse_error.102 if to_unicode fails or surrogate error
+    @throw parse_error.103 if to_unicode fails
+
+    @complexity Linear in the length of the input. The parser is a predictive
+    LL(1) parser. The complexity can be higher if the SAX consumer @a sax has
+    a super-linear complexity.
+
+    @note A UTF-8 byte order mark is silently ignored.
+
+    @liveexample{The example below demonstrates the `sax_parse()` function
+    reading from string and processing the events with a user-defined SAX
+    event consumer.,sax_parse}
+
+    @since version 3.2.0
+    */
+    template <typename SAX>
+    static bool sax_parse(detail::input_adapter&& i, SAX* sax,
+                          input_format_t format = input_format_t::json,
+                          const bool strict = true)
+    {
+        assert(sax);
+        switch (format)
+        {
+            case input_format_t::json:
+                return parser(std::move(i)).sax_parse(sax, strict);
+            default:
+                return detail::binary_reader<basic_json, SAX>(std::move(i)).sax_parse(format, sax, strict);
+        }
+    }
+
+    /*!
+    @brief deserialize from an iterator range with contiguous storage
+
+    This function reads from an iterator range of a container with contiguous
+    storage of 1-byte values. Compatible container types include
+    `std::vector`, `std::string`, `std::array`, `std::valarray`, and
+    `std::initializer_list`. Furthermore, C-style arrays can be used with
+    `std::begin()`/`std::end()`. User-defined containers can be used as long
+    as they implement random-access iterators and a contiguous storage.
+
+    @pre The iterator range is contiguous. Violating this precondition yields
+    undefined behavior. **This precondition is enforced with an assertion.**
+    @pre Each element in the range has a size of 1 byte. Violating this
+    precondition yields undefined behavior. **This precondition is enforced
+    with a static assertion.**
+
+    @warning There is no way to enforce all preconditions at compile-time. If
+             the function is called with noncompliant iterators and with
+             assertions switched off, the behavior is undefined and will most
+             likely yield segmentation violation.
+
+    @tparam IteratorType iterator of container with contiguous storage
+    @param[in] first  begin of the range to parse (included)
+    @param[in] last  end of the range to parse (excluded)
+    @param[in] cb  a parser callback function of type @ref parser_callback_t
+    which is used to control the deserialization by filtering unwanted values
+    (optional)
+    @param[in] allow_exceptions  whether to throw exceptions in case of a
+    parse error (optional, true by default)
+
+    @return result of the deserialization
+
+    @throw parse_error.101 in case of an unexpected token
+    @throw parse_error.102 if to_unicode fails or surrogate error
+    @throw parse_error.103 if to_unicode fails
+
+    @complexity Linear in the length of the input. The parser is a predictive
+    LL(1) parser. The complexity can be higher if the parser callback function
+    @a cb has a super-linear complexity.
+
+    @note A UTF-8 byte order mark is silently ignored.
+
+    @liveexample{The example below demonstrates the `parse()` function reading
+    from an iterator range.,parse__iteratortype__parser_callback_t}
+
+    @since version 2.0.3
+    */
+    template<class IteratorType, typename std::enable_if<
+                 std::is_base_of<
+                     std::random_access_iterator_tag,
+                     typename std::iterator_traits<IteratorType>::iterator_category>::value, int>::type = 0>
+    static basic_json parse(IteratorType first, IteratorType last,
+                            const parser_callback_t cb = nullptr,
+                            const bool allow_exceptions = true)
+    {
+        basic_json result;
+        parser(detail::input_adapter(first, last), cb, allow_exceptions).parse(true, result);
+        return result;
+    }
+
+    template<class IteratorType, typename std::enable_if<
+                 std::is_base_of<
+                     std::random_access_iterator_tag,
+                     typename std::iterator_traits<IteratorType>::iterator_category>::value, int>::type = 0>
+    static bool accept(IteratorType first, IteratorType last)
+    {
+        return parser(detail::input_adapter(first, last)).accept(true);
+    }
+
+    template<class IteratorType, class SAX, typename std::enable_if<
+                 std::is_base_of<
+                     std::random_access_iterator_tag,
+                     typename std::iterator_traits<IteratorType>::iterator_category>::value, int>::type = 0>
+    static bool sax_parse(IteratorType first, IteratorType last, SAX* sax)
+    {
+        return parser(detail::input_adapter(first, last)).sax_parse(sax);
+    }
+
+    /*!
+    @brief deserialize from stream
+    @deprecated This stream operator is deprecated and will be removed in
+                version 4.0.0 of the library. Please use
+                @ref operator>>(std::istream&, basic_json&)
+                instead; that is, replace calls like `j << i;` with `i >> j;`.
+    @since version 1.0.0; deprecated since version 3.0.0
+    */
+    JSON_DEPRECATED
+    friend std::istream& operator<<(basic_json& j, std::istream& i)
+    {
+        return operator>>(i, j);
+    }
+
+    /*!
+    @brief deserialize from stream
+
+    Deserializes an input stream to a JSON value.
+
+    @param[in,out] i  input stream to read a serialized JSON value from
+    @param[in,out] j  JSON value to write the deserialized input to
+
+    @throw parse_error.101 in case of an unexpected token
+    @throw parse_error.102 if to_unicode fails or surrogate error
+    @throw parse_error.103 if to_unicode fails
+
+    @complexity Linear in the length of the input. The parser is a predictive
+    LL(1) parser.
+
+    @note A UTF-8 byte order mark is silently ignored.
+
+    @liveexample{The example below shows how a JSON value is constructed by
+    reading a serialization from a stream.,operator_deserialize}
+
+    @sa parse(std::istream&, const parser_callback_t) for a variant with a
+    parser callback function to filter values while parsing
+
+    @since version 1.0.0
+    */
+    friend std::istream& operator>>(std::istream& i, basic_json& j)
+    {
+        parser(detail::input_adapter(i)).parse(false, j);
+        return i;
+    }
+
+    /// @}
+
+    ///////////////////////////
+    // convenience functions //
+    ///////////////////////////
+
+    /*!
+    @brief return the type as string
+
+    Returns the type name as string to be used in error messages - usually to
+    indicate that a function was called on a wrong JSON type.
+
+    @return a string representation of a the @a m_type member:
+            Value type  | return value
+            ----------- | -------------
+            null        | `"null"`
+            boolean     | `"boolean"`
+            string      | `"string"`
+            number      | `"number"` (for all number types)
+            object      | `"object"`
+            array       | `"array"`
+            discarded   | `"discarded"`
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @complexity Constant.
+
+    @liveexample{The following code exemplifies `type_name()` for all JSON
+    types.,type_name}
+
+    @sa @ref type() -- return the type of the JSON value
+    @sa @ref operator value_t() -- return the type of the JSON value (implicit)
+
+    @since version 1.0.0, public since 2.1.0, `const char*` and `noexcept`
+    since 3.0.0
+    */
+    const char* type_name() const noexcept
+    {
+        {
+            switch (m_type)
+            {
+                case value_t::null:
+                    return "null";
+                case value_t::object:
+                    return "object";
+                case value_t::array:
+                    return "array";
+                case value_t::string:
+                    return "string";
+                case value_t::boolean:
+                    return "boolean";
+                case value_t::discarded:
+                    return "discarded";
+                default:
+                    return "number";
+            }
+        }
+    }
+
+
+  private:
+    //////////////////////
+    // member variables //
+    //////////////////////
+
+    /// the type of the current element
+    value_t m_type = value_t::null;
+
+    /// the value of the current element
+    json_value m_value = {};
+
+    //////////////////////////////////////////
+    // binary serialization/deserialization //
+    //////////////////////////////////////////
+
+    /// @name binary serialization/deserialization support
+    /// @{
+
+  public:
+    /*!
+    @brief create a CBOR serialization of a given JSON value
+
+    Serializes a given JSON value @a j to a byte vector using the CBOR (Concise
+    Binary Object Representation) serialization format. CBOR is a binary
+    serialization format which aims to be more compact than JSON itself, yet
+    more efficient to parse.
+
+    The library uses the following mapping from JSON values types to
+    CBOR types according to the CBOR specification (RFC 7049):
+
+    JSON value type | value/range                                | CBOR type                          | first byte
+    --------------- | ------------------------------------------ | ---------------------------------- | ---------------
+    null            | `null`                                     | Null                               | 0xF6
+    boolean         | `true`                                     | True                               | 0xF5
+    boolean         | `false`                                    | False                              | 0xF4
+    number_integer  | -9223372036854775808..-2147483649          | Negative integer (8 bytes follow)  | 0x3B
+    number_integer  | -2147483648..-32769                        | Negative integer (4 bytes follow)  | 0x3A
+    number_integer  | -32768..-129                               | Negative integer (2 bytes follow)  | 0x39
+    number_integer  | -128..-25                                  | Negative integer (1 byte follow)   | 0x38
+    number_integer  | -24..-1                                    | Negative integer                   | 0x20..0x37
+    number_integer  | 0..23                                      | Integer                            | 0x00..0x17
+    number_integer  | 24..255                                    | Unsigned integer (1 byte follow)   | 0x18
+    number_integer  | 256..65535                                 | Unsigned integer (2 bytes follow)  | 0x19
+    number_integer  | 65536..4294967295                          | Unsigned integer (4 bytes follow)  | 0x1A
+    number_integer  | 4294967296..18446744073709551615           | Unsigned integer (8 bytes follow)  | 0x1B
+    number_unsigned | 0..23                                      | Integer                            | 0x00..0x17
+    number_unsigned | 24..255                                    | Unsigned integer (1 byte follow)   | 0x18
+    number_unsigned | 256..65535                                 | Unsigned integer (2 bytes follow)  | 0x19
+    number_unsigned | 65536..4294967295                          | Unsigned integer (4 bytes follow)  | 0x1A
+    number_unsigned | 4294967296..18446744073709551615           | Unsigned integer (8 bytes follow)  | 0x1B
+    number_float    | *any value*                                | Double-Precision Float             | 0xFB
+    string          | *length*: 0..23                            | UTF-8 string                       | 0x60..0x77
+    string          | *length*: 23..255                          | UTF-8 string (1 byte follow)       | 0x78
+    string          | *length*: 256..65535                       | UTF-8 string (2 bytes follow)      | 0x79
+    string          | *length*: 65536..4294967295                | UTF-8 string (4 bytes follow)      | 0x7A
+    string          | *length*: 4294967296..18446744073709551615 | UTF-8 string (8 bytes follow)      | 0x7B
+    array           | *size*: 0..23                              | array                              | 0x80..0x97
+    array           | *size*: 23..255                            | array (1 byte follow)              | 0x98
+    array           | *size*: 256..65535                         | array (2 bytes follow)             | 0x99
+    array           | *size*: 65536..4294967295                  | array (4 bytes follow)             | 0x9A
+    array           | *size*: 4294967296..18446744073709551615   | array (8 bytes follow)             | 0x9B
+    object          | *size*: 0..23                              | map                                | 0xA0..0xB7
+    object          | *size*: 23..255                            | map (1 byte follow)                | 0xB8
+    object          | *size*: 256..65535                         | map (2 bytes follow)               | 0xB9
+    object          | *size*: 65536..4294967295                  | map (4 bytes follow)               | 0xBA
+    object          | *size*: 4294967296..18446744073709551615   | map (8 bytes follow)               | 0xBB
+
+    @note The mapping is **complete** in the sense that any JSON value type
+          can be converted to a CBOR value.
+
+    @note If NaN or Infinity are stored inside a JSON number, they are
+          serialized properly. This behavior differs from the @ref dump()
+          function which serializes NaN or Infinity to `null`.
+
+    @note The following CBOR types are not used in the conversion:
+          - byte strings (0x40..0x5F)
+          - UTF-8 strings terminated by "break" (0x7F)
+          - arrays terminated by "break" (0x9F)
+          - maps terminated by "break" (0xBF)
+          - date/time (0xC0..0xC1)
+          - bignum (0xC2..0xC3)
+          - decimal fraction (0xC4)
+          - bigfloat (0xC5)
+          - tagged items (0xC6..0xD4, 0xD8..0xDB)
+          - expected conversions (0xD5..0xD7)
+          - simple values (0xE0..0xF3, 0xF8)
+          - undefined (0xF7)
+          - half and single-precision floats (0xF9-0xFA)
+          - break (0xFF)
+
+    @param[in] j  JSON value to serialize
+    @return MessagePack serialization as byte vector
+
+    @complexity Linear in the size of the JSON value @a j.
+
+    @liveexample{The example shows the serialization of a JSON value to a byte
+    vector in CBOR format.,to_cbor}
+
+    @sa http://cbor.io
+    @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool) for the
+        analogous deserialization
+    @sa @ref to_msgpack(const basic_json&) for the related MessagePack format
+    @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
+             related UBJSON format
+
+    @since version 2.0.9
+    */
+    static std::vector<uint8_t> to_cbor(const basic_json& j)
+    {
+        std::vector<uint8_t> result;
+        to_cbor(j, result);
+        return result;
+    }
+
+    static void to_cbor(const basic_json& j, detail::output_adapter<uint8_t> o)
+    {
+        binary_writer<uint8_t>(o).write_cbor(j);
+    }
+
+    static void to_cbor(const basic_json& j, detail::output_adapter<char> o)
+    {
+        binary_writer<char>(o).write_cbor(j);
+    }
+
+    /*!
+    @brief create a MessagePack serialization of a given JSON value
+
+    Serializes a given JSON value @a j to a byte vector using the MessagePack
+    serialization format. MessagePack is a binary serialization format which
+    aims to be more compact than JSON itself, yet more efficient to parse.
+
+    The library uses the following mapping from JSON values types to
+    MessagePack types according to the MessagePack specification:
+
+    JSON value type | value/range                       | MessagePack type | first byte
+    --------------- | --------------------------------- | ---------------- | ----------
+    null            | `null`                            | nil              | 0xC0
+    boolean         | `true`                            | true             | 0xC3
+    boolean         | `false`                           | false            | 0xC2
+    number_integer  | -9223372036854775808..-2147483649 | int64            | 0xD3
+    number_integer  | -2147483648..-32769               | int32            | 0xD2
+    number_integer  | -32768..-129                      | int16            | 0xD1
+    number_integer  | -128..-33                         | int8             | 0xD0
+    number_integer  | -32..-1                           | negative fixint  | 0xE0..0xFF
+    number_integer  | 0..127                            | positive fixint  | 0x00..0x7F
+    number_integer  | 128..255                          | uint 8           | 0xCC
+    number_integer  | 256..65535                        | uint 16          | 0xCD
+    number_integer  | 65536..4294967295                 | uint 32          | 0xCE
+    number_integer  | 4294967296..18446744073709551615  | uint 64          | 0xCF
+    number_unsigned | 0..127                            | positive fixint  | 0x00..0x7F
+    number_unsigned | 128..255                          | uint 8           | 0xCC
+    number_unsigned | 256..65535                        | uint 16          | 0xCD
+    number_unsigned | 65536..4294967295                 | uint 32          | 0xCE
+    number_unsigned | 4294967296..18446744073709551615  | uint 64          | 0xCF
+    number_float    | *any value*                       | float 64         | 0xCB
+    string          | *length*: 0..31                   | fixstr           | 0xA0..0xBF
+    string          | *length*: 32..255                 | str 8            | 0xD9
+    string          | *length*: 256..65535              | str 16           | 0xDA
+    string          | *length*: 65536..4294967295       | str 32           | 0xDB
+    array           | *size*: 0..15                     | fixarray         | 0x90..0x9F
+    array           | *size*: 16..65535                 | array 16         | 0xDC
+    array           | *size*: 65536..4294967295         | array 32         | 0xDD
+    object          | *size*: 0..15                     | fix map          | 0x80..0x8F
+    object          | *size*: 16..65535                 | map 16           | 0xDE
+    object          | *size*: 65536..4294967295         | map 32           | 0xDF
+
+    @note The mapping is **complete** in the sense that any JSON value type
+          can be converted to a MessagePack value.
+
+    @note The following values can **not** be converted to a MessagePack value:
+          - strings with more than 4294967295 bytes
+          - arrays with more than 4294967295 elements
+          - objects with more than 4294967295 elements
+
+    @note The following MessagePack types are not used in the conversion:
+          - bin 8 - bin 32 (0xC4..0xC6)
+          - ext 8 - ext 32 (0xC7..0xC9)
+          - float 32 (0xCA)
+          - fixext 1 - fixext 16 (0xD4..0xD8)
+
+    @note Any MessagePack output created @ref to_msgpack can be successfully
+          parsed by @ref from_msgpack.
+
+    @note If NaN or Infinity are stored inside a JSON number, they are
+          serialized properly. This behavior differs from the @ref dump()
+          function which serializes NaN or Infinity to `null`.
+
+    @param[in] j  JSON value to serialize
+    @return MessagePack serialization as byte vector
+
+    @complexity Linear in the size of the JSON value @a j.
+
+    @liveexample{The example shows the serialization of a JSON value to a byte
+    vector in MessagePack format.,to_msgpack}
+
+    @sa http://msgpack.org
+    @sa @ref from_msgpack for the analogous deserialization
+    @sa @ref to_cbor(const basic_json& for the related CBOR format
+    @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
+             related UBJSON format
+
+    @since version 2.0.9
+    */
+    static std::vector<uint8_t> to_msgpack(const basic_json& j)
+    {
+        std::vector<uint8_t> result;
+        to_msgpack(j, result);
+        return result;
+    }
+
+    static void to_msgpack(const basic_json& j, detail::output_adapter<uint8_t> o)
+    {
+        binary_writer<uint8_t>(o).write_msgpack(j);
+    }
+
+    static void to_msgpack(const basic_json& j, detail::output_adapter<char> o)
+    {
+        binary_writer<char>(o).write_msgpack(j);
+    }
+
+    /*!
+    @brief create a UBJSON serialization of a given JSON value
+
+    Serializes a given JSON value @a j to a byte vector using the UBJSON
+    (Universal Binary JSON) serialization format. UBJSON aims to be more compact
+    than JSON itself, yet more efficient to parse.
+
+    The library uses the following mapping from JSON values types to
+    UBJSON types according to the UBJSON specification:
+
+    JSON value type | value/range                       | UBJSON type | marker
+    --------------- | --------------------------------- | ----------- | ------
+    null            | `null`                            | null        | `Z`
+    boolean         | `true`                            | true        | `T`
+    boolean         | `false`                           | false       | `F`
+    number_integer  | -9223372036854775808..-2147483649 | int64       | `L`
+    number_integer  | -2147483648..-32769               | int32       | `l`
+    number_integer  | -32768..-129                      | int16       | `I`
+    number_integer  | -128..127                         | int8        | `i`
+    number_integer  | 128..255                          | uint8       | `U`
+    number_integer  | 256..32767                        | int16       | `I`
+    number_integer  | 32768..2147483647                 | int32       | `l`
+    number_integer  | 2147483648..9223372036854775807   | int64       | `L`
+    number_unsigned | 0..127                            | int8        | `i`
+    number_unsigned | 128..255                          | uint8       | `U`
+    number_unsigned | 256..32767                        | int16       | `I`
+    number_unsigned | 32768..2147483647                 | int32       | `l`
+    number_unsigned | 2147483648..9223372036854775807   | int64       | `L`
+    number_float    | *any value*                       | float64     | `D`
+    string          | *with shortest length indicator*  | string      | `S`
+    array           | *see notes on optimized format*   | array       | `[`
+    object          | *see notes on optimized format*   | map         | `{`
+
+    @note The mapping is **complete** in the sense that any JSON value type
+          can be converted to a UBJSON value.
+
+    @note The following values can **not** be converted to a UBJSON value:
+          - strings with more than 9223372036854775807 bytes (theoretical)
+          - unsigned integer numbers above 9223372036854775807
+
+    @note The following markers are not used in the conversion:
+          - `Z`: no-op values are not created.
+          - `C`: single-byte strings are serialized with `S` markers.
+
+    @note Any UBJSON output created @ref to_ubjson can be successfully parsed
+          by @ref from_ubjson.
+
+    @note If NaN or Infinity are stored inside a JSON number, they are
+          serialized properly. This behavior differs from the @ref dump()
+          function which serializes NaN or Infinity to `null`.
+
+    @note The optimized formats for containers are supported: Parameter
+          @a use_size adds size information to the beginning of a container and
+          removes the closing marker. Parameter @a use_type further checks
+          whether all elements of a container have the same type and adds the
+          type marker to the beginning of the container. The @a use_type
+          parameter must only be used together with @a use_size = true. Note
+          that @a use_size = true alone may result in larger representations -
+          the benefit of this parameter is that the receiving side is
+          immediately informed on the number of elements of the container.
+
+    @param[in] j  JSON value to serialize
+    @param[in] use_size  whether to add size annotations to container types
+    @param[in] use_type  whether to add type annotations to container types
+                         (must be combined with @a use_size = true)
+    @return UBJSON serialization as byte vector
+
+    @complexity Linear in the size of the JSON value @a j.
+
+    @liveexample{The example shows the serialization of a JSON value to a byte
+    vector in UBJSON format.,to_ubjson}
+
+    @sa http://ubjson.org
+    @sa @ref from_ubjson(detail::input_adapter&&, const bool, const bool) for the
+        analogous deserialization
+    @sa @ref to_cbor(const basic_json& for the related CBOR format
+    @sa @ref to_msgpack(const basic_json&) for the related MessagePack format
+
+    @since version 3.1.0
+    */
+    static std::vector<uint8_t> to_ubjson(const basic_json& j,
+                                          const bool use_size = false,
+                                          const bool use_type = false)
+    {
+        std::vector<uint8_t> result;
+        to_ubjson(j, result, use_size, use_type);
+        return result;
+    }
+
+    static void to_ubjson(const basic_json& j, detail::output_adapter<uint8_t> o,
+                          const bool use_size = false, const bool use_type = false)
+    {
+        binary_writer<uint8_t>(o).write_ubjson(j, use_size, use_type);
+    }
+
+    static void to_ubjson(const basic_json& j, detail::output_adapter<char> o,
+                          const bool use_size = false, const bool use_type = false)
+    {
+        binary_writer<char>(o).write_ubjson(j, use_size, use_type);
+    }
+
+
+    /*!
+    @brief Serializes the given JSON object `j` to BSON and returns a vector
+           containing the corresponding BSON-representation.
+
+    BSON (Binary JSON) is a binary format in which zero or more ordered key/value pairs are
+    stored as a single entity (a so-called document).
+
+    The library uses the following mapping from JSON values types to BSON types:
+
+    JSON value type | value/range                       | BSON type   | marker
+    --------------- | --------------------------------- | ----------- | ------
+    null            | `null`                            | null        | 0x0A
+    boolean         | `true`, `false`                   | boolean     | 0x08
+    number_integer  | -9223372036854775808..-2147483649 | int64       | 0x12
+    number_integer  | -2147483648..2147483647           | int32       | 0x10
+    number_integer  | 2147483648..9223372036854775807   | int64       | 0x12
+    number_unsigned | 0..2147483647                     | int32       | 0x10
+    number_unsigned | 2147483648..9223372036854775807   | int64       | 0x12
+    number_unsigned | 9223372036854775808..18446744073709551615| --   | --
+    number_float    | *any value*                       | double      | 0x01
+    string          | *any value*                       | string      | 0x02
+    array           | *any value*                       | document    | 0x04
+    object          | *any value*                       | document    | 0x03
+
+    @warning The mapping is **incomplete**, since only JSON-objects (and things
+    contained therein) can be serialized to BSON.
+    Also, integers larger than 9223372036854775807 cannot be serialized to BSON,
+    and the keys may not contain U+0000, since they are serialized a
+    zero-terminated c-strings.
+
+    @throw out_of_range.407  if `j.is_number_unsigned() && j.get<std::uint64_t>() > 9223372036854775807`
+    @throw out_of_range.409  if a key in `j` contains a NULL (U+0000)
+    @throw type_error.317    if `!j.is_object()`
+
+    @pre The input `j` is required to be an object: `j.is_object() == true`.
+
+    @note Any BSON output created via @ref to_bson can be successfully parsed
+          by @ref from_bson.
+
+    @param[in] j  JSON value to serialize
+    @return BSON serialization as byte vector
+
+    @complexity Linear in the size of the JSON value @a j.
+
+    @liveexample{The example shows the serialization of a JSON value to a byte
+    vector in BSON format.,to_bson}
+
+    @sa http://bsonspec.org/spec.html
+    @sa @ref from_bson(detail::input_adapter&&, const bool strict) for the
+        analogous deserialization
+    @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
+             related UBJSON format
+    @sa @ref to_cbor(const basic_json&) for the related CBOR format
+    @sa @ref to_msgpack(const basic_json&) for the related MessagePack format
+    */
+    static std::vector<uint8_t> to_bson(const basic_json& j)
+    {
+        std::vector<uint8_t> result;
+        to_bson(j, result);
+        return result;
+    }
+
+    /*!
+    @brief Serializes the given JSON object `j` to BSON and forwards the
+           corresponding BSON-representation to the given output_adapter `o`.
+    @param j The JSON object to convert to BSON.
+    @param o The output adapter that receives the binary BSON representation.
+    @pre The input `j` shall be an object: `j.is_object() == true`
+    @sa @ref to_bson(const basic_json&)
+    */
+    static void to_bson(const basic_json& j, detail::output_adapter<uint8_t> o)
+    {
+        binary_writer<uint8_t>(o).write_bson(j);
+    }
+
+    /*!
+    @copydoc to_bson(const basic_json&, detail::output_adapter<uint8_t>)
+    */
+    static void to_bson(const basic_json& j, detail::output_adapter<char> o)
+    {
+        binary_writer<char>(o).write_bson(j);
+    }
+
+
+    /*!
+    @brief create a JSON value from an input in CBOR format
+
+    Deserializes a given input @a i to a JSON value using the CBOR (Concise
+    Binary Object Representation) serialization format.
+
+    The library maps CBOR types to JSON value types as follows:
+
+    CBOR type              | JSON value type | first byte
+    ---------------------- | --------------- | ----------
+    Integer                | number_unsigned | 0x00..0x17
+    Unsigned integer       | number_unsigned | 0x18
+    Unsigned integer       | number_unsigned | 0x19
+    Unsigned integer       | number_unsigned | 0x1A
+    Unsigned integer       | number_unsigned | 0x1B
+    Negative integer       | number_integer  | 0x20..0x37
+    Negative integer       | number_integer  | 0x38
+    Negative integer       | number_integer  | 0x39
+    Negative integer       | number_integer  | 0x3A
+    Negative integer       | number_integer  | 0x3B
+    Negative integer       | number_integer  | 0x40..0x57
+    UTF-8 string           | string          | 0x60..0x77
+    UTF-8 string           | string          | 0x78
+    UTF-8 string           | string          | 0x79
+    UTF-8 string           | string          | 0x7A
+    UTF-8 string           | string          | 0x7B
+    UTF-8 string           | string          | 0x7F
+    array                  | array           | 0x80..0x97
+    array                  | array           | 0x98
+    array                  | array           | 0x99
+    array                  | array           | 0x9A
+    array                  | array           | 0x9B
+    array                  | array           | 0x9F
+    map                    | object          | 0xA0..0xB7
+    map                    | object          | 0xB8
+    map                    | object          | 0xB9
+    map                    | object          | 0xBA
+    map                    | object          | 0xBB
+    map                    | object          | 0xBF
+    False                  | `false`         | 0xF4
+    True                   | `true`          | 0xF5
+    Null                   | `null`          | 0xF6
+    Half-Precision Float   | number_float    | 0xF9
+    Single-Precision Float | number_float    | 0xFA
+    Double-Precision Float | number_float    | 0xFB
+
+    @warning The mapping is **incomplete** in the sense that not all CBOR
+             types can be converted to a JSON value. The following CBOR types
+             are not supported and will yield parse errors (parse_error.112):
+             - byte strings (0x40..0x5F)
+             - date/time (0xC0..0xC1)
+             - bignum (0xC2..0xC3)
+             - decimal fraction (0xC4)
+             - bigfloat (0xC5)
+             - tagged items (0xC6..0xD4, 0xD8..0xDB)
+             - expected conversions (0xD5..0xD7)
+             - simple values (0xE0..0xF3, 0xF8)
+             - undefined (0xF7)
+
+    @warning CBOR allows map keys of any type, whereas JSON only allows
+             strings as keys in object values. Therefore, CBOR maps with keys
+             other than UTF-8 strings are rejected (parse_error.113).
+
+    @note Any CBOR output created @ref to_cbor can be successfully parsed by
+          @ref from_cbor.
+
+    @param[in] i  an input in CBOR format convertible to an input adapter
+    @param[in] strict  whether to expect the input to be consumed until EOF
+                       (true by default)
+    @param[in] allow_exceptions  whether to throw exceptions in case of a
+    parse error (optional, true by default)
+
+    @return deserialized JSON value
+
+    @throw parse_error.110 if the given input ends prematurely or the end of
+    file was not reached when @a strict was set to true
+    @throw parse_error.112 if unsupported features from CBOR were
+    used in the given input @a v or if the input is not valid CBOR
+    @throw parse_error.113 if a string was expected as map key, but not found
+
+    @complexity Linear in the size of the input @a i.
+
+    @liveexample{The example shows the deserialization of a byte vector in CBOR
+    format to a JSON value.,from_cbor}
+
+    @sa http://cbor.io
+    @sa @ref to_cbor(const basic_json&) for the analogous serialization
+    @sa @ref from_msgpack(detail::input_adapter&&, const bool, const bool) for the
+        related MessagePack format
+    @sa @ref from_ubjson(detail::input_adapter&&, const bool, const bool) for the
+        related UBJSON format
+
+    @since version 2.0.9; parameter @a start_index since 2.1.1; changed to
+           consume input adapters, removed start_index parameter, and added
+           @a strict parameter since 3.0.0; added @a allow_exceptions parameter
+           since 3.2.0
+    */
+    static basic_json from_cbor(detail::input_adapter&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        const bool res = binary_reader(detail::input_adapter(i)).sax_parse(input_format_t::cbor, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /*!
+    @copydoc from_cbor(detail::input_adapter&&, const bool, const bool)
+    */
+    template<typename A1, typename A2,
+             detail::enable_if_t<std::is_constructible<detail::input_adapter, A1, A2>::value, int> = 0>
+    static basic_json from_cbor(A1 && a1, A2 && a2,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        const bool res = binary_reader(detail::input_adapter(std::forward<A1>(a1), std::forward<A2>(a2))).sax_parse(input_format_t::cbor, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /*!
+    @brief create a JSON value from an input in MessagePack format
+
+    Deserializes a given input @a i to a JSON value using the MessagePack
+    serialization format.
+
+    The library maps MessagePack types to JSON value types as follows:
+
+    MessagePack type | JSON value type | first byte
+    ---------------- | --------------- | ----------
+    positive fixint  | number_unsigned | 0x00..0x7F
+    fixmap           | object          | 0x80..0x8F
+    fixarray         | array           | 0x90..0x9F
+    fixstr           | string          | 0xA0..0xBF
+    nil              | `null`          | 0xC0
+    false            | `false`         | 0xC2
+    true             | `true`          | 0xC3
+    float 32         | number_float    | 0xCA
+    float 64         | number_float    | 0xCB
+    uint 8           | number_unsigned | 0xCC
+    uint 16          | number_unsigned | 0xCD
+    uint 32          | number_unsigned | 0xCE
+    uint 64          | number_unsigned | 0xCF
+    int 8            | number_integer  | 0xD0
+    int 16           | number_integer  | 0xD1
+    int 32           | number_integer  | 0xD2
+    int 64           | number_integer  | 0xD3
+    str 8            | string          | 0xD9
+    str 16           | string          | 0xDA
+    str 32           | string          | 0xDB
+    array 16         | array           | 0xDC
+    array 32         | array           | 0xDD
+    map 16           | object          | 0xDE
+    map 32           | object          | 0xDF
+    negative fixint  | number_integer  | 0xE0-0xFF
+
+    @warning The mapping is **incomplete** in the sense that not all
+             MessagePack types can be converted to a JSON value. The following
+             MessagePack types are not supported and will yield parse errors:
+              - bin 8 - bin 32 (0xC4..0xC6)
+              - ext 8 - ext 32 (0xC7..0xC9)
+              - fixext 1 - fixext 16 (0xD4..0xD8)
+
+    @note Any MessagePack output created @ref to_msgpack can be successfully
+          parsed by @ref from_msgpack.
+
+    @param[in] i  an input in MessagePack format convertible to an input
+                  adapter
+    @param[in] strict  whether to expect the input to be consumed until EOF
+                       (true by default)
+    @param[in] allow_exceptions  whether to throw exceptions in case of a
+    parse error (optional, true by default)
+
+    @return deserialized JSON value
+
+    @throw parse_error.110 if the given input ends prematurely or the end of
+    file was not reached when @a strict was set to true
+    @throw parse_error.112 if unsupported features from MessagePack were
+    used in the given input @a i or if the input is not valid MessagePack
+    @throw parse_error.113 if a string was expected as map key, but not found
+
+    @complexity Linear in the size of the input @a i.
+
+    @liveexample{The example shows the deserialization of a byte vector in
+    MessagePack format to a JSON value.,from_msgpack}
+
+    @sa http://msgpack.org
+    @sa @ref to_msgpack(const basic_json&) for the analogous serialization
+    @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool) for the
+        related CBOR format
+    @sa @ref from_ubjson(detail::input_adapter&&, const bool, const bool) for
+        the related UBJSON format
+    @sa @ref from_bson(detail::input_adapter&&, const bool, const bool) for
+        the related BSON format
+
+    @since version 2.0.9; parameter @a start_index since 2.1.1; changed to
+           consume input adapters, removed start_index parameter, and added
+           @a strict parameter since 3.0.0; added @a allow_exceptions parameter
+           since 3.2.0
+    */
+    static basic_json from_msgpack(detail::input_adapter&& i,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        const bool res = binary_reader(detail::input_adapter(i)).sax_parse(input_format_t::msgpack, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /*!
+    @copydoc from_msgpack(detail::input_adapter&&, const bool, const bool)
+    */
+    template<typename A1, typename A2,
+             detail::enable_if_t<std::is_constructible<detail::input_adapter, A1, A2>::value, int> = 0>
+    static basic_json from_msgpack(A1 && a1, A2 && a2,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        const bool res = binary_reader(detail::input_adapter(std::forward<A1>(a1), std::forward<A2>(a2))).sax_parse(input_format_t::msgpack, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /*!
+    @brief create a JSON value from an input in UBJSON format
+
+    Deserializes a given input @a i to a JSON value using the UBJSON (Universal
+    Binary JSON) serialization format.
+
+    The library maps UBJSON types to JSON value types as follows:
+
+    UBJSON type | JSON value type                         | marker
+    ----------- | --------------------------------------- | ------
+    no-op       | *no value, next value is read*          | `N`
+    null        | `null`                                  | `Z`
+    false       | `false`                                 | `F`
+    true        | `true`                                  | `T`
+    float32     | number_float                            | `d`
+    float64     | number_float                            | `D`
+    uint8       | number_unsigned                         | `U`
+    int8        | number_integer                          | `i`
+    int16       | number_integer                          | `I`
+    int32       | number_integer                          | `l`
+    int64       | number_integer                          | `L`
+    string      | string                                  | `S`
+    char        | string                                  | `C`
+    array       | array (optimized values are supported)  | `[`
+    object      | object (optimized values are supported) | `{`
+
+    @note The mapping is **complete** in the sense that any UBJSON value can
+          be converted to a JSON value.
+
+    @param[in] i  an input in UBJSON format convertible to an input adapter
+    @param[in] strict  whether to expect the input to be consumed until EOF
+                       (true by default)
+    @param[in] allow_exceptions  whether to throw exceptions in case of a
+    parse error (optional, true by default)
+
+    @return deserialized JSON value
+
+    @throw parse_error.110 if the given input ends prematurely or the end of
+    file was not reached when @a strict was set to true
+    @throw parse_error.112 if a parse error occurs
+    @throw parse_error.113 if a string could not be parsed successfully
+
+    @complexity Linear in the size of the input @a i.
+
+    @liveexample{The example shows the deserialization of a byte vector in
+    UBJSON format to a JSON value.,from_ubjson}
+
+    @sa http://ubjson.org
+    @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
+             analogous serialization
+    @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool) for the
+        related CBOR format
+    @sa @ref from_msgpack(detail::input_adapter&&, const bool, const bool) for
+        the related MessagePack format
+    @sa @ref from_bson(detail::input_adapter&&, const bool, const bool) for
+        the related BSON format
+
+    @since version 3.1.0; added @a allow_exceptions parameter since 3.2.0
+    */
+    static basic_json from_ubjson(detail::input_adapter&& i,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        const bool res = binary_reader(detail::input_adapter(i)).sax_parse(input_format_t::ubjson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /*!
+    @copydoc from_ubjson(detail::input_adapter&&, const bool, const bool)
+    */
+    template<typename A1, typename A2,
+             detail::enable_if_t<std::is_constructible<detail::input_adapter, A1, A2>::value, int> = 0>
+    static basic_json from_ubjson(A1 && a1, A2 && a2,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        const bool res = binary_reader(detail::input_adapter(std::forward<A1>(a1), std::forward<A2>(a2))).sax_parse(input_format_t::ubjson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /*!
+    @brief Create a JSON value from an input in BSON format
+
+    Deserializes a given input @a i to a JSON value using the BSON (Binary JSON)
+    serialization format.
+
+    The library maps BSON record types to JSON value types as follows:
+
+    BSON type       | BSON marker byte | JSON value type
+    --------------- | ---------------- | ---------------------------
+    double          | 0x01             | number_float
+    string          | 0x02             | string
+    document        | 0x03             | object
+    array           | 0x04             | array
+    binary          | 0x05             | still unsupported
+    undefined       | 0x06             | still unsupported
+    ObjectId        | 0x07             | still unsupported
+    boolean         | 0x08             | boolean
+    UTC Date-Time   | 0x09             | still unsupported
+    null            | 0x0A             | null
+    Regular Expr.   | 0x0B             | still unsupported
+    DB Pointer      | 0x0C             | still unsupported
+    JavaScript Code | 0x0D             | still unsupported
+    Symbol          | 0x0E             | still unsupported
+    JavaScript Code | 0x0F             | still unsupported
+    int32           | 0x10             | number_integer
+    Timestamp       | 0x11             | still unsupported
+    128-bit decimal float | 0x13       | still unsupported
+    Max Key         | 0x7F             | still unsupported
+    Min Key         | 0xFF             | still unsupported
+
+    @warning The mapping is **incomplete**. The unsupported mappings
+             are indicated in the table above.
+
+    @param[in] i  an input in BSON format convertible to an input adapter
+    @param[in] strict  whether to expect the input to be consumed until EOF
+                       (true by default)
+    @param[in] allow_exceptions  whether to throw exceptions in case of a
+    parse error (optional, true by default)
+
+    @return deserialized JSON value
+
+    @throw parse_error.114 if an unsupported BSON record type is encountered
+
+    @complexity Linear in the size of the input @a i.
+
+    @liveexample{The example shows the deserialization of a byte vector in
+    BSON format to a JSON value.,from_bson}
+
+    @sa http://bsonspec.org/spec.html
+    @sa @ref to_bson(const basic_json&) for the analogous serialization
+    @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool) for the
+        related CBOR format
+    @sa @ref from_msgpack(detail::input_adapter&&, const bool, const bool) for
+        the related MessagePack format
+    @sa @ref from_ubjson(detail::input_adapter&&, const bool, const bool) for the
+        related UBJSON format
+    */
+    static basic_json from_bson(detail::input_adapter&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        const bool res = binary_reader(detail::input_adapter(i)).sax_parse(input_format_t::bson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /*!
+    @copydoc from_bson(detail::input_adapter&&, const bool, const bool)
+    */
+    template<typename A1, typename A2,
+             detail::enable_if_t<std::is_constructible<detail::input_adapter, A1, A2>::value, int> = 0>
+    static basic_json from_bson(A1 && a1, A2 && a2,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        const bool res = binary_reader(detail::input_adapter(std::forward<A1>(a1), std::forward<A2>(a2))).sax_parse(input_format_t::bson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+
+
+    /// @}
+
+    //////////////////////////
+    // JSON Pointer support //
+    //////////////////////////
+
+    /// @name JSON Pointer functions
+    /// @{
+
+    /*!
+    @brief access specified element via JSON Pointer
+
+    Uses a JSON pointer to retrieve a reference to the respective JSON value.
+    No bound checking is performed. Similar to @ref operator[](const typename
+    object_t::key_type&), `null` values are created in arrays and objects if
+    necessary.
+
+    In particular:
+    - If the JSON pointer points to an object key that does not exist, it
+      is created an filled with a `null` value before a reference to it
+      is returned.
+    - If the JSON pointer points to an array index that does not exist, it
+      is created an filled with a `null` value before a reference to it
+      is returned. All indices between the current maximum and the given
+      index are also filled with `null`.
+    - The special value `-` is treated as a synonym for the index past the
+      end.
+
+    @param[in] ptr  a JSON pointer
+
+    @return reference to the element pointed to by @a ptr
+
+    @complexity Constant.
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+
+    @liveexample{The behavior is shown in the example.,operatorjson_pointer}
+
+    @since version 2.0.0
+    */
+    reference operator[](const json_pointer& ptr)
+    {
+        return ptr.get_unchecked(this);
+    }
+
+    /*!
+    @brief access specified element via JSON Pointer
+
+    Uses a JSON pointer to retrieve a reference to the respective JSON value.
+    No bound checking is performed. The function does not change the JSON
+    value; no `null` values are created. In particular, the the special value
+    `-` yields an exception.
+
+    @param[in] ptr  JSON pointer to the desired element
+
+    @return const reference to the element pointed to by @a ptr
+
+    @complexity Constant.
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+
+    @liveexample{The behavior is shown in the example.,operatorjson_pointer_const}
+
+    @since version 2.0.0
+    */
+    const_reference operator[](const json_pointer& ptr) const
+    {
+        return ptr.get_unchecked(this);
+    }
+
+    /*!
+    @brief access specified element via JSON Pointer
+
+    Returns a reference to the element at with specified JSON pointer @a ptr,
+    with bounds checking.
+
+    @param[in] ptr  JSON pointer to the desired element
+
+    @return reference to the element pointed to by @a ptr
+
+    @throw parse_error.106 if an array index in the passed JSON pointer @a ptr
+    begins with '0'. See example below.
+
+    @throw parse_error.109 if an array index in the passed JSON pointer @a ptr
+    is not a number. See example below.
+
+    @throw out_of_range.401 if an array index in the passed JSON pointer @a ptr
+    is out of range. See example below.
+
+    @throw out_of_range.402 if the array index '-' is used in the passed JSON
+    pointer @a ptr. As `at` provides checked access (and no elements are
+    implicitly inserted), the index '-' is always invalid. See example below.
+
+    @throw out_of_range.403 if the JSON pointer describes a key of an object
+    which cannot be found. See example below.
+
+    @throw out_of_range.404 if the JSON pointer @a ptr can not be resolved.
+    See example below.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Constant.
+
+    @since version 2.0.0
+
+    @liveexample{The behavior is shown in the example.,at_json_pointer}
+    */
+    reference at(const json_pointer& ptr)
+    {
+        return ptr.get_checked(this);
+    }
+
+    /*!
+    @brief access specified element via JSON Pointer
+
+    Returns a const reference to the element at with specified JSON pointer @a
+    ptr, with bounds checking.
+
+    @param[in] ptr  JSON pointer to the desired element
+
+    @return reference to the element pointed to by @a ptr
+
+    @throw parse_error.106 if an array index in the passed JSON pointer @a ptr
+    begins with '0'. See example below.
+
+    @throw parse_error.109 if an array index in the passed JSON pointer @a ptr
+    is not a number. See example below.
+
+    @throw out_of_range.401 if an array index in the passed JSON pointer @a ptr
+    is out of range. See example below.
+
+    @throw out_of_range.402 if the array index '-' is used in the passed JSON
+    pointer @a ptr. As `at` provides checked access (and no elements are
+    implicitly inserted), the index '-' is always invalid. See example below.
+
+    @throw out_of_range.403 if the JSON pointer describes a key of an object
+    which cannot be found. See example below.
+
+    @throw out_of_range.404 if the JSON pointer @a ptr can not be resolved.
+    See example below.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Constant.
+
+    @since version 2.0.0
+
+    @liveexample{The behavior is shown in the example.,at_json_pointer_const}
+    */
+    const_reference at(const json_pointer& ptr) const
+    {
+        return ptr.get_checked(this);
+    }
+
+    /*!
+    @brief return flattened JSON value
+
+    The function creates a JSON object whose keys are JSON pointers (see [RFC
+    6901](https://tools.ietf.org/html/rfc6901)) and whose values are all
+    primitive. The original JSON value can be restored using the @ref
+    unflatten() function.
+
+    @return an object that maps JSON pointers to primitive values
+
+    @note Empty objects and arrays are flattened to `null` and will not be
+          reconstructed correctly by the @ref unflatten() function.
+
+    @complexity Linear in the size the JSON value.
+
+    @liveexample{The following code shows how a JSON object is flattened to an
+    object whose keys consist of JSON pointers.,flatten}
+
+    @sa @ref unflatten() for the reverse function
+
+    @since version 2.0.0
+    */
+    basic_json flatten() const
+    {
+        basic_json result(value_t::object);
+        json_pointer::flatten("", *this, result);
+        return result;
+    }
+
+    /*!
+    @brief unflatten a previously flattened JSON value
+
+    The function restores the arbitrary nesting of a JSON value that has been
+    flattened before using the @ref flatten() function. The JSON value must
+    meet certain constraints:
+    1. The value must be an object.
+    2. The keys must be JSON pointers (see
+       [RFC 6901](https://tools.ietf.org/html/rfc6901))
+    3. The mapped values must be primitive JSON types.
+
+    @return the original JSON from a flattened version
+
+    @note Empty objects and arrays are flattened by @ref flatten() to `null`
+          values and can not unflattened to their original type. Apart from
+          this example, for a JSON value `j`, the following is always true:
+          `j == j.flatten().unflatten()`.
+
+    @complexity Linear in the size the JSON value.
+
+    @throw type_error.314  if value is not an object
+    @throw type_error.315  if object values are not primitive
+
+    @liveexample{The following code shows how a flattened JSON object is
+    unflattened into the original nested JSON object.,unflatten}
+
+    @sa @ref flatten() for the reverse function
+
+    @since version 2.0.0
+    */
+    basic_json unflatten() const
+    {
+        return json_pointer::unflatten(*this);
+    }
+
+    /// @}
+
+    //////////////////////////
+    // JSON Patch functions //
+    //////////////////////////
+
+    /// @name JSON Patch functions
+    /// @{
+
+    /*!
+    @brief applies a JSON patch
+
+    [JSON Patch](http://jsonpatch.com) defines a JSON document structure for
+    expressing a sequence of operations to apply to a JSON) document. With
+    this function, a JSON Patch is applied to the current JSON value by
+    executing all operations from the patch.
+
+    @param[in] json_patch  JSON patch document
+    @return patched document
+
+    @note The application of a patch is atomic: Either all operations succeed
+          and the patched document is returned or an exception is thrown. In
+          any case, the original value is not changed: the patch is applied
+          to a copy of the value.
+
+    @throw parse_error.104 if the JSON patch does not consist of an array of
+    objects
+
+    @throw parse_error.105 if the JSON patch is malformed (e.g., mandatory
+    attributes are missing); example: `"operation add must have member path"`
+
+    @throw out_of_range.401 if an array index is out of range.
+
+    @throw out_of_range.403 if a JSON pointer inside the patch could not be
+    resolved successfully in the current JSON value; example: `"key baz not
+    found"`
+
+    @throw out_of_range.405 if JSON pointer has no parent ("add", "remove",
+    "move")
+
+    @throw other_error.501 if "test" operation was unsuccessful
+
+    @complexity Linear in the size of the JSON value and the length of the
+    JSON patch. As usually only a fraction of the JSON value is affected by
+    the patch, the complexity can usually be neglected.
+
+    @liveexample{The following code shows how a JSON patch is applied to a
+    value.,patch}
+
+    @sa @ref diff -- create a JSON patch by comparing two JSON values
+
+    @sa [RFC 6902 (JSON Patch)](https://tools.ietf.org/html/rfc6902)
+    @sa [RFC 6901 (JSON Pointer)](https://tools.ietf.org/html/rfc6901)
+
+    @since version 2.0.0
+    */
+    basic_json patch(const basic_json& json_patch) const
+    {
+        // make a working copy to apply the patch to
+        basic_json result = *this;
+
+        // the valid JSON Patch operations
+        enum class patch_operations {add, remove, replace, move, copy, test, invalid};
+
+        const auto get_op = [](const std::string & op)
+        {
+            if (op == "add")
+            {
+                return patch_operations::add;
+            }
+            if (op == "remove")
+            {
+                return patch_operations::remove;
+            }
+            if (op == "replace")
+            {
+                return patch_operations::replace;
+            }
+            if (op == "move")
+            {
+                return patch_operations::move;
+            }
+            if (op == "copy")
+            {
+                return patch_operations::copy;
+            }
+            if (op == "test")
+            {
+                return patch_operations::test;
+            }
+
+            return patch_operations::invalid;
+        };
+
+        // wrapper for "add" operation; add value at ptr
+        const auto operation_add = [&result](json_pointer & ptr, basic_json val)
+        {
+            // adding to the root of the target document means replacing it
+            if (ptr.is_root())
+            {
+                result = val;
+            }
+            else
+            {
+                // make sure the top element of the pointer exists
+                json_pointer top_pointer = ptr.top();
+                if (top_pointer != ptr)
+                {
+                    result.at(top_pointer);
+                }
+
+                // get reference to parent of JSON pointer ptr
+                const auto last_path = ptr.pop_back();
+                basic_json& parent = result[ptr];
+
+                switch (parent.m_type)
+                {
+                    case value_t::null:
+                    case value_t::object:
+                    {
+                        // use operator[] to add value
+                        parent[last_path] = val;
+                        break;
+                    }
+
+                    case value_t::array:
+                    {
+                        if (last_path == "-")
+                        {
+                            // special case: append to back
+                            parent.push_back(val);
+                        }
+                        else
+                        {
+                            const auto idx = json_pointer::array_index(last_path);
+                            if (JSON_UNLIKELY(static_cast<size_type>(idx) > parent.size()))
+                            {
+                                // avoid undefined behavior
+                                JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
+                            }
+
+                            // default case: insert add offset
+                            parent.insert(parent.begin() + static_cast<difference_type>(idx), val);
+                        }
+                        break;
+                    }
+
+                    // LCOV_EXCL_START
+                    default:
+                    {
+                        // if there exists a parent it cannot be primitive
+                        assert(false);
+                    }
+                        // LCOV_EXCL_STOP
+                }
+            }
+        };
+
+        // wrapper for "remove" operation; remove value at ptr
+        const auto operation_remove = [&result](json_pointer & ptr)
+        {
+            // get reference to parent of JSON pointer ptr
+            const auto last_path = ptr.pop_back();
+            basic_json& parent = result.at(ptr);
+
+            // remove child
+            if (parent.is_object())
+            {
+                // perform range check
+                auto it = parent.find(last_path);
+                if (JSON_LIKELY(it != parent.end()))
+                {
+                    parent.erase(it);
+                }
+                else
+                {
+                    JSON_THROW(out_of_range::create(403, "key '" + last_path + "' not found"));
+                }
+            }
+            else if (parent.is_array())
+            {
+                // note erase performs range check
+                parent.erase(static_cast<size_type>(json_pointer::array_index(last_path)));
+            }
+        };
+
+        // type check: top level value must be an array
+        if (JSON_UNLIKELY(not json_patch.is_array()))
+        {
+            JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));
+        }
+
+        // iterate and apply the operations
+        for (const auto& val : json_patch)
+        {
+            // wrapper to get a value for an operation
+            const auto get_value = [&val](const std::string & op,
+                                          const std::string & member,
+                                          bool string_type) -> basic_json &
+            {
+                // find value
+                auto it = val.m_value.object->find(member);
+
+                // context-sensitive error message
+                const auto error_msg = (op == "op") ? "operation" : "operation '" + op + "'";
+
+                // check if desired value is present
+                if (JSON_UNLIKELY(it == val.m_value.object->end()))
+                {
+                    JSON_THROW(parse_error::create(105, 0, error_msg + " must have member '" + member + "'"));
+                }
+
+                // check if result is of type string
+                if (JSON_UNLIKELY(string_type and not it->second.is_string()))
+                {
+                    JSON_THROW(parse_error::create(105, 0, error_msg + " must have string member '" + member + "'"));
+                }
+
+                // no error: return value
+                return it->second;
+            };
+
+            // type check: every element of the array must be an object
+            if (JSON_UNLIKELY(not val.is_object()))
+            {
+                JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));
+            }
+
+            // collect mandatory members
+            const std::string op = get_value("op", "op", true);
+            const std::string path = get_value(op, "path", true);
+            json_pointer ptr(path);
+
+            switch (get_op(op))
+            {
+                case patch_operations::add:
+                {
+                    operation_add(ptr, get_value("add", "value", false));
+                    break;
+                }
+
+                case patch_operations::remove:
+                {
+                    operation_remove(ptr);
+                    break;
+                }
+
+                case patch_operations::replace:
+                {
+                    // the "path" location must exist - use at()
+                    result.at(ptr) = get_value("replace", "value", false);
+                    break;
+                }
+
+                case patch_operations::move:
+                {
+                    const std::string from_path = get_value("move", "from", true);
+                    json_pointer from_ptr(from_path);
+
+                    // the "from" location must exist - use at()
+                    basic_json v = result.at(from_ptr);
+
+                    // The move operation is functionally identical to a
+                    // "remove" operation on the "from" location, followed
+                    // immediately by an "add" operation at the target
+                    // location with the value that was just removed.
+                    operation_remove(from_ptr);
+                    operation_add(ptr, v);
+                    break;
+                }
+
+                case patch_operations::copy:
+                {
+                    const std::string from_path = get_value("copy", "from", true);
+                    const json_pointer from_ptr(from_path);
+
+                    // the "from" location must exist - use at()
+                    basic_json v = result.at(from_ptr);
+
+                    // The copy is functionally identical to an "add"
+                    // operation at the target location using the value
+                    // specified in the "from" member.
+                    operation_add(ptr, v);
+                    break;
+                }
+
+                case patch_operations::test:
+                {
+                    bool success = false;
+                    JSON_TRY
+                    {
+                        // check if "value" matches the one at "path"
+                        // the "path" location must exist - use at()
+                        success = (result.at(ptr) == get_value("test", "value", false));
+                    }
+                    JSON_INTERNAL_CATCH (out_of_range&)
+                    {
+                        // ignore out of range errors: success remains false
+                    }
+
+                    // throw an exception if test fails
+                    if (JSON_UNLIKELY(not success))
+                    {
+                        JSON_THROW(other_error::create(501, "unsuccessful: " + val.dump()));
+                    }
+
+                    break;
+                }
+
+                case patch_operations::invalid:
+                {
+                    // op must be "add", "remove", "replace", "move", "copy", or
+                    // "test"
+                    JSON_THROW(parse_error::create(105, 0, "operation value '" + op + "' is invalid"));
+                }
+            }
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief creates a diff as a JSON patch
+
+    Creates a [JSON Patch](http://jsonpatch.com) so that value @a source can
+    be changed into the value @a target by calling @ref patch function.
+
+    @invariant For two JSON values @a source and @a target, the following code
+    yields always `true`:
+    @code {.cpp}
+    source.patch(diff(source, target)) == target;
+    @endcode
+
+    @note Currently, only `remove`, `add`, and `replace` operations are
+          generated.
+
+    @param[in] source  JSON value to compare from
+    @param[in] target  JSON value to compare against
+    @param[in] path    helper value to create JSON pointers
+
+    @return a JSON patch to convert the @a source to @a target
+
+    @complexity Linear in the lengths of @a source and @a target.
+
+    @liveexample{The following code shows how a JSON patch is created as a
+    diff for two JSON values.,diff}
+
+    @sa @ref patch -- apply a JSON patch
+    @sa @ref merge_patch -- apply a JSON Merge Patch
+
+    @sa [RFC 6902 (JSON Patch)](https://tools.ietf.org/html/rfc6902)
+
+    @since version 2.0.0
+    */
+    static basic_json diff(const basic_json& source, const basic_json& target,
+                           const std::string& path = "")
+    {
+        // the patch
+        basic_json result(value_t::array);
+
+        // if the values are the same, return empty patch
+        if (source == target)
+        {
+            return result;
+        }
+
+        if (source.type() != target.type())
+        {
+            // different types: replace value
+            result.push_back(
+            {
+                {"op", "replace"}, {"path", path}, {"value", target}
+            });
+        }
+        else
+        {
+            switch (source.type())
+            {
+                case value_t::array:
+                {
+                    // first pass: traverse common elements
+                    std::size_t i = 0;
+                    while (i < source.size() and i < target.size())
+                    {
+                        // recursive call to compare array values at index i
+                        auto temp_diff = diff(source[i], target[i], path + "/" + std::to_string(i));
+                        result.insert(result.end(), temp_diff.begin(), temp_diff.end());
+                        ++i;
+                    }
+
+                    // i now reached the end of at least one array
+                    // in a second pass, traverse the remaining elements
+
+                    // remove my remaining elements
+                    const auto end_index = static_cast<difference_type>(result.size());
+                    while (i < source.size())
+                    {
+                        // add operations in reverse order to avoid invalid
+                        // indices
+                        result.insert(result.begin() + end_index, object(
+                        {
+                            {"op", "remove"},
+                            {"path", path + "/" + std::to_string(i)}
+                        }));
+                        ++i;
+                    }
+
+                    // add other remaining elements
+                    while (i < target.size())
+                    {
+                        result.push_back(
+                        {
+                            {"op", "add"},
+                            {"path", path + "/" + std::to_string(i)},
+                            {"value", target[i]}
+                        });
+                        ++i;
+                    }
+
+                    break;
+                }
+
+                case value_t::object:
+                {
+                    // first pass: traverse this object's elements
+                    for (auto it = source.cbegin(); it != source.cend(); ++it)
+                    {
+                        // escape the key name to be used in a JSON patch
+                        const auto key = json_pointer::escape(it.key());
+
+                        if (target.find(it.key()) != target.end())
+                        {
+                            // recursive call to compare object values at key it
+                            auto temp_diff = diff(it.value(), target[it.key()], path + "/" + key);
+                            result.insert(result.end(), temp_diff.begin(), temp_diff.end());
+                        }
+                        else
+                        {
+                            // found a key that is not in o -> remove it
+                            result.push_back(object(
+                            {
+                                {"op", "remove"}, {"path", path + "/" + key}
+                            }));
+                        }
+                    }
+
+                    // second pass: traverse other object's elements
+                    for (auto it = target.cbegin(); it != target.cend(); ++it)
+                    {
+                        if (source.find(it.key()) == source.end())
+                        {
+                            // found a key that is not in this -> add it
+                            const auto key = json_pointer::escape(it.key());
+                            result.push_back(
+                            {
+                                {"op", "add"}, {"path", path + "/" + key},
+                                {"value", it.value()}
+                            });
+                        }
+                    }
+
+                    break;
+                }
+
+                default:
+                {
+                    // both primitive type: replace value
+                    result.push_back(
+                    {
+                        {"op", "replace"}, {"path", path}, {"value", target}
+                    });
+                    break;
+                }
+            }
+        }
+
+        return result;
+    }
+
+    /// @}
+
+    ////////////////////////////////
+    // JSON Merge Patch functions //
+    ////////////////////////////////
+
+    /// @name JSON Merge Patch functions
+    /// @{
+
+    /*!
+    @brief applies a JSON Merge Patch
+
+    The merge patch format is primarily intended for use with the HTTP PATCH
+    method as a means of describing a set of modifications to a target
+    resource's content. This function applies a merge patch to the current
+    JSON value.
+
+    The function implements the following algorithm from Section 2 of
+    [RFC 7396 (JSON Merge Patch)](https://tools.ietf.org/html/rfc7396):
+
+    ```
+    define MergePatch(Target, Patch):
+      if Patch is an Object:
+        if Target is not an Object:
+          Target = {} // Ignore the contents and set it to an empty Object
+        for each Name/Value pair in Patch:
+          if Value is null:
+            if Name exists in Target:
+              remove the Name/Value pair from Target
+          else:
+            Target[Name] = MergePatch(Target[Name], Value)
+        return Target
+      else:
+        return Patch
+    ```
+
+    Thereby, `Target` is the current object; that is, the patch is applied to
+    the current value.
+
+    @param[in] apply_patch  the patch to apply
+
+    @complexity Linear in the lengths of @a patch.
+
+    @liveexample{The following code shows how a JSON Merge Patch is applied to
+    a JSON document.,merge_patch}
+
+    @sa @ref patch -- apply a JSON patch
+    @sa [RFC 7396 (JSON Merge Patch)](https://tools.ietf.org/html/rfc7396)
+
+    @since version 3.0.0
+    */
+    void merge_patch(const basic_json& apply_patch)
+    {
+        if (apply_patch.is_object())
+        {
+            if (not is_object())
+            {
+                *this = object();
+            }
+            for (auto it = apply_patch.begin(); it != apply_patch.end(); ++it)
+            {
+                if (it.value().is_null())
+                {
+                    erase(it.key());
+                }
+                else
+                {
+                    operator[](it.key()).merge_patch(it.value());
+                }
+            }
+        }
+        else
+        {
+            *this = apply_patch;
+        }
+    }
+
+    /// @}
+};
+} // namespace nlohmann
+
+///////////////////////
+// nonmember support //
+///////////////////////
+
+// specialization of std::swap, and std::hash
+namespace std
+{
+
+/// hash value for JSON objects
+template<>
+struct hash<nlohmann::json>
+{
+    /*!
+    @brief return a hash value for a JSON object
+
+    @since version 1.0.0
+    */
+    std::size_t operator()(const nlohmann::json& j) const
+    {
+        // a naive hashing via the string representation
+        const auto& h = hash<nlohmann::json::string_t>();
+        return h(j.dump());
+    }
+};
+
+/// specialization for std::less<value_t>
+/// @note: do not remove the space after '<',
+///        see https://github.com/nlohmann/json/pull/679
+template<>
+struct less< ::nlohmann::detail::value_t>
+{
+    /*!
+    @brief compare two value_t enum values
+    @since version 3.0.0
+    */
+    bool operator()(nlohmann::detail::value_t lhs,
+                    nlohmann::detail::value_t rhs) const noexcept
+    {
+        return nlohmann::detail::operator<(lhs, rhs);
+    }
+};
+
+/*!
+@brief exchanges the values of two JSON objects
+
+@since version 1.0.0
+*/
+template<>
+inline void swap<nlohmann::json>(nlohmann::json& j1, nlohmann::json& j2) noexcept(
+    is_nothrow_move_constructible<nlohmann::json>::value and
+    is_nothrow_move_assignable<nlohmann::json>::value
+)
+{
+    j1.swap(j2);
+}
+
+} // namespace std
+
+/*!
+@brief user-defined string literal for JSON values
+
+This operator implements a user-defined string literal for JSON objects. It
+can be used by adding `"_json"` to a string literal and returns a JSON object
+if no parse error occurred.
+
+@param[in] s  a string representation of a JSON object
+@param[in] n  the length of string @a s
+@return a JSON object
+
+@since version 1.0.0
+*/
+inline nlohmann::json operator "" _json(const char* s, std::size_t n)
+{
+    return nlohmann::json::parse(s, s + n);
+}
+
+/*!
+@brief user-defined string literal for JSON pointer
+
+This operator implements a user-defined string literal for JSON Pointers. It
+can be used by adding `"_json_pointer"` to a string literal and returns a JSON pointer
+object if no parse error occurred.
+
+@param[in] s  a string representation of a JSON Pointer
+@param[in] n  the length of string @a s
+@return a JSON pointer object
+
+@since version 2.0.0
+*/
+inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)
+{
+    return nlohmann::json::json_pointer(std::string(s, n));
+}
+
+// #include <nlohmann/detail/macro_unscope.hpp>
+
+
+// restore GCC/clang diagnostic settings
+#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
+    #pragma GCC diagnostic pop
+#endif
+#if defined(__clang__)
+    #pragma GCC diagnostic pop
+#endif
+
+// clean up
+#undef JSON_INTERNAL_CATCH
+#undef JSON_CATCH
+#undef JSON_THROW
+#undef JSON_TRY
+#undef JSON_LIKELY
+#undef JSON_UNLIKELY
+#undef JSON_DEPRECATED
+#undef JSON_HAS_CPP_14
+#undef JSON_HAS_CPP_17
+#undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
+#undef NLOHMANN_BASIC_JSON_TPL
+
+
+#endif
diff --git a/engine/inc/gltf/stb_image.h b/engine/inc/gltf/stb_image.h
new file mode 100644
index 00000000..8b710609
--- /dev/null
+++ b/engine/inc/gltf/stb_image.h
@@ -0,0 +1,7530 @@
+/* stb_image - v2.21 - public domain image loader - http://nothings.org/stb
+                                  no warranty implied; use at your own risk
+
+   Do this:
+      #define STB_IMAGE_IMPLEMENTATION
+   before you include this file in *one* C or C++ file to create the implementation.
+
+   // i.e. it should look like this:
+   #include ...
+   #include ...
+   #include ...
+   #define STB_IMAGE_IMPLEMENTATION
+   #include "stb_image.h"
+
+   You can #define STBI_ASSERT(x) before the #include to avoid using assert.h.
+   And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free
+
+
+   QUICK NOTES:
+      Primarily of interest to game developers and other people who can
+          avoid problematic images and only need the trivial interface
+
+      JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib)
+      PNG 1/2/4/8/16-bit-per-channel
+
+      TGA (not sure what subset, if a subset)
+      BMP non-1bpp, non-RLE
+      PSD (composited view only, no extra channels, 8/16 bit-per-channel)
+
+      GIF (*comp always reports as 4-channel)
+      HDR (radiance rgbE format)
+      PIC (Softimage PIC)
+      PNM (PPM and PGM binary only)
+
+      Animated GIF still needs a proper API, but here's one way to do it:
+          http://gist.github.com/urraka/685d9a6340b26b830d49
+
+      - decode from memory or through FILE (define STBI_NO_STDIO to remove code)
+      - decode from arbitrary I/O callbacks
+      - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON)
+
+   Full documentation under "DOCUMENTATION" below.
+
+
+LICENSE
+
+  See end of file for license information.
+
+RECENT REVISION HISTORY:
+
+      2.21  (2019-02-25) fix typo in comment
+      2.20  (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs 
+      2.19  (2018-02-11) fix warning
+      2.18  (2018-01-30) fix warnings
+      2.17  (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings
+      2.16  (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes
+      2.15  (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC
+      2.14  (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs
+      2.13  (2016-12-04) experimental 16-bit API, only for PNG so far; fixes
+      2.12  (2016-04-02) fix typo in 2.11 PSD fix that caused crashes
+      2.11  (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64
+                         RGB-format JPEG; remove white matting in PSD;
+                         allocate large structures on the stack;
+                         correct channel count for PNG & BMP
+      2.10  (2016-01-22) avoid warning introduced in 2.09
+      2.09  (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED
+
+   See end of file for full revision history.
+
+
+ ============================    Contributors    =========================
+
+ Image formats                          Extensions, features
+    Sean Barrett (jpeg, png, bmp)          Jetro Lauha (stbi_info)
+    Nicolas Schulz (hdr, psd)              Martin "SpartanJ" Golini (stbi_info)
+    Jonathan Dummer (tga)                  James "moose2000" Brown (iPhone PNG)
+    Jean-Marc Lienher (gif)                Ben "Disch" Wenger (io callbacks)
+    Tom Seddon (pic)                       Omar Cornut (1/2/4-bit PNG)
+    Thatcher Ulrich (psd)                  Nicolas Guillemot (vertical flip)
+    Ken Miller (pgm, ppm)                  Richard Mitton (16-bit PSD)
+    github:urraka (animated gif)           Junggon Kim (PNM comments)
+    Christopher Forseth (animated gif)     Daniel Gibson (16-bit TGA)
+                                           socks-the-fox (16-bit PNG)
+                                           Jeremy Sawicki (handle all ImageNet JPGs)
+ Optimizations & bugfixes                  Mikhail Morozov (1-bit BMP)
+    Fabian "ryg" Giesen                    Anael Seghezzi (is-16-bit query)
+    Arseny Kapoulkine
+    John-Mark Allen
+    Carmelo J Fdez-Aguera
+
+ Bug & warning fixes
+    Marc LeBlanc            David Woo          Guillaume George   Martins Mozeiko
+    Christpher Lloyd        Jerry Jansson      Joseph Thomson     Phil Jordan
+    Dave Moore              Roy Eltham         Hayaki Saito       Nathan Reed
+    Won Chun                Luke Graham        Johan Duparc       Nick Verigakis
+    the Horde3D community   Thomas Ruf         Ronny Chevalier    github:rlyeh
+    Janez Zemva             John Bartholomew   Michal Cichon      github:romigrou
+    Jonathan Blow           Ken Hamada         Tero Hanninen      github:svdijk
+    Laurent Gomila          Cort Stratton      Sergio Gonzalez    github:snagar
+    Aruelien Pocheville     Thibault Reuille   Cass Everitt       github:Zelex
+    Ryamond Barbiero        Paul Du Bois       Engin Manap        github:grim210
+    Aldo Culquicondor       Philipp Wiesemann  Dale Weiler        github:sammyhw
+    Oriol Ferrer Mesia      Josh Tobin         Matthew Gregan     github:phprus
+    Julian Raschke          Gregory Mullen     Baldur Karlsson    github:poppolopoppo
+    Christian Floisand      Kevin Schmidt      JR Smith           github:darealshinji
+    Blazej Dariusz Roszkowski                                     github:Michaelangel007
+*/
+
+#ifndef STBI_INCLUDE_STB_IMAGE_H
+#define STBI_INCLUDE_STB_IMAGE_H
+
+// DOCUMENTATION
+//
+// Limitations:
+//    - no 12-bit-per-channel JPEG
+//    - no JPEGs with arithmetic coding
+//    - GIF always returns *comp=4
+//
+// Basic usage (see HDR discussion below for HDR usage):
+//    int x,y,n;
+//    unsigned char *data = stbi_load(filename, &x, &y, &n, 0);
+//    // ... process data if not NULL ...
+//    // ... x = width, y = height, n = # 8-bit components per pixel ...
+//    // ... replace '0' with '1'..'4' to force that many components per pixel
+//    // ... but 'n' will always be the number that it would have been if you said 0
+//    stbi_image_free(data)
+//
+// Standard parameters:
+//    int *x                 -- outputs image width in pixels
+//    int *y                 -- outputs image height in pixels
+//    int *channels_in_file  -- outputs # of image components in image file
+//    int desired_channels   -- if non-zero, # of image components requested in result
+//
+// The return value from an image loader is an 'unsigned char *' which points
+// to the pixel data, or NULL on an allocation failure or if the image is
+// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels,
+// with each pixel consisting of N interleaved 8-bit components; the first
+// pixel pointed to is top-left-most in the image. There is no padding between
+// image scanlines or between pixels, regardless of format. The number of
+// components N is 'desired_channels' if desired_channels is non-zero, or
+// *channels_in_file otherwise. If desired_channels is non-zero,
+// *channels_in_file has the number of components that _would_ have been
+// output otherwise. E.g. if you set desired_channels to 4, you will always
+// get RGBA output, but you can check *channels_in_file to see if it's trivially
+// opaque because e.g. there were only 3 channels in the source image.
+//
+// An output image with N components has the following components interleaved
+// in this order in each pixel:
+//
+//     N=#comp     components
+//       1           grey
+//       2           grey, alpha
+//       3           red, green, blue
+//       4           red, green, blue, alpha
+//
+// If image loading fails for any reason, the return value will be NULL,
+// and *x, *y, *channels_in_file will be unchanged. The function
+// stbi_failure_reason() can be queried for an extremely brief, end-user
+// unfriendly explanation of why the load failed. Define STBI_NO_FAILURE_STRINGS
+// to avoid compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly
+// more user-friendly ones.
+//
+// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized.
+//
+// ===========================================================================
+//
+// UNICODE:
+//
+//   If compiling for Windows and you wish to use Unicode filenames, compile
+//   with
+//       #define STBI_WINDOWS_UTF8
+//   and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert
+//   Windows wchar_t filenames to utf8.
+//
+// ===========================================================================
+//
+// Philosophy
+//
+// stb libraries are designed with the following priorities:
+//
+//    1. easy to use
+//    2. easy to maintain
+//    3. good performance
+//
+// Sometimes I let "good performance" creep up in priority over "easy to maintain",
+// and for best performance I may provide less-easy-to-use APIs that give higher
+// performance, in addition to the easy-to-use ones. Nevertheless, it's important
+// to keep in mind that from the standpoint of you, a client of this library,
+// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all.
+//
+// Some secondary priorities arise directly from the first two, some of which
+// provide more explicit reasons why performance can't be emphasized.
+//
+//    - Portable ("ease of use")
+//    - Small source code footprint ("easy to maintain")
+//    - No dependencies ("ease of use")
+//
+// ===========================================================================
+//
+// I/O callbacks
+//
+// I/O callbacks allow you to read from arbitrary sources, like packaged
+// files or some other source. Data read from callbacks are processed
+// through a small internal buffer (currently 128 bytes) to try to reduce
+// overhead.
+//
+// The three functions you must define are "read" (reads some bytes of data),
+// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end).
+//
+// ===========================================================================
+//
+// SIMD support
+//
+// The JPEG decoder will try to automatically use SIMD kernels on x86 when
+// supported by the compiler. For ARM Neon support, you must explicitly
+// request it.
+//
+// (The old do-it-yourself SIMD API is no longer supported in the current
+// code.)
+//
+// On x86, SSE2 will automatically be used when available based on a run-time
+// test; if not, the generic C versions are used as a fall-back. On ARM targets,
+// the typical path is to have separate builds for NEON and non-NEON devices
+// (at least this is true for iOS and Android). Therefore, the NEON support is
+// toggled by a build flag: define STBI_NEON to get NEON loops.
+//
+// If for some reason you do not want to use any of SIMD code, or if
+// you have issues compiling it, you can disable it entirely by
+// defining STBI_NO_SIMD.
+//
+// ===========================================================================
+//
+// HDR image support   (disable by defining STBI_NO_HDR)
+//
+// stb_image supports loading HDR images in general, and currently the Radiance
+// .HDR file format specifically. You can still load any file through the existing
+// interface; if you attempt to load an HDR file, it will be automatically remapped
+// to LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1;
+// both of these constants can be reconfigured through this interface:
+//
+//     stbi_hdr_to_ldr_gamma(2.2f);
+//     stbi_hdr_to_ldr_scale(1.0f);
+//
+// (note, do not use _inverse_ constants; stbi_image will invert them
+// appropriately).
+//
+// Additionally, there is a new, parallel interface for loading files as
+// (linear) floats to preserve the full dynamic range:
+//
+//    float *data = stbi_loadf(filename, &x, &y, &n, 0);
+//
+// If you load LDR images through this interface, those images will
+// be promoted to floating point values, run through the inverse of
+// constants corresponding to the above:
+//
+//     stbi_ldr_to_hdr_scale(1.0f);
+//     stbi_ldr_to_hdr_gamma(2.2f);
+//
+// Finally, given a filename (or an open file or memory block--see header
+// file for details) containing image data, you can query for the "most
+// appropriate" interface to use (that is, whether the image is HDR or
+// not), using:
+//
+//     stbi_is_hdr(char *filename);
+//
+// ===========================================================================
+//
+// iPhone PNG support:
+//
+// By default we convert iphone-formatted PNGs back to RGB, even though
+// they are internally encoded differently. You can disable this conversion
+// by calling stbi_convert_iphone_png_to_rgb(0), in which case
+// you will always just get the native iphone "format" through (which
+// is BGR stored in RGB).
+//
+// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per
+// pixel to remove any premultiplied alpha *only* if the image file explicitly
+// says there's premultiplied data (currently only happens in iPhone images,
+// and only if iPhone convert-to-rgb processing is on).
+//
+// ===========================================================================
+//
+// ADDITIONAL CONFIGURATION
+//
+//  - You can suppress implementation of any of the decoders to reduce
+//    your code footprint by #defining one or more of the following
+//    symbols before creating the implementation.
+//
+//        STBI_NO_JPEG
+//        STBI_NO_PNG
+//        STBI_NO_BMP
+//        STBI_NO_PSD
+//        STBI_NO_TGA
+//        STBI_NO_GIF
+//        STBI_NO_HDR
+//        STBI_NO_PIC
+//        STBI_NO_PNM   (.ppm and .pgm)
+//
+//  - You can request *only* certain decoders and suppress all other ones
+//    (this will be more forward-compatible, as addition of new decoders
+//    doesn't require you to disable them explicitly):
+//
+//        STBI_ONLY_JPEG
+//        STBI_ONLY_PNG
+//        STBI_ONLY_BMP
+//        STBI_ONLY_PSD
+//        STBI_ONLY_TGA
+//        STBI_ONLY_GIF
+//        STBI_ONLY_HDR
+//        STBI_ONLY_PIC
+//        STBI_ONLY_PNM   (.ppm and .pgm)
+//
+//   - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still
+//     want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB
+//
+
+
+#ifndef STBI_NO_STDIO
+#include <stdio.h>
+#endif // STBI_NO_STDIO
+
+#define STBI_VERSION 1
+
+enum
+{
+   STBI_default = 0, // only used for desired_channels
+
+   STBI_grey       = 1,
+   STBI_grey_alpha = 2,
+   STBI_rgb        = 3,
+   STBI_rgb_alpha  = 4
+};
+
+#include <stdlib.h>
+typedef unsigned char stbi_uc;
+typedef unsigned short stbi_us;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef STB_IMAGE_STATIC
+#define STBIDEF static
+#else
+#define STBIDEF extern
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// PRIMARY API - works on images of any type
+//
+
+//
+// load image by filename, open file, or memory buffer
+//
+
+typedef struct
+{
+   int      (*read)  (void *user,char *data,int size);   // fill 'data' with 'size' bytes.  return number of bytes actually read
+   void     (*skip)  (void *user,int n);                 // skip the next 'n' bytes, or 'unget' the last -n bytes if negative
+   int      (*eof)   (void *user);                       // returns nonzero if we are at end of file/data
+} stbi_io_callbacks;
+
+////////////////////////////////////
+//
+// 8-bits-per-channel interface
+//
+
+STBIDEF stbi_uc *stbi_load_from_memory   (stbi_uc           const *buffer, int len   , int *x, int *y, int *channels_in_file, int desired_channels);
+STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk  , void *user, int *x, int *y, int *channels_in_file, int desired_channels);
+
+#ifndef STBI_NO_STDIO
+STBIDEF stbi_uc *stbi_load            (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);
+STBIDEF stbi_uc *stbi_load_from_file  (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);
+// for stbi_load_from_file, file pointer is left pointing immediately after image
+#endif
+
+#ifndef STBI_NO_GIF
+STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp);
+#endif
+
+#ifdef STBI_WINDOWS_UTF8
+STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input);
+#endif
+
+////////////////////////////////////
+//
+// 16-bits-per-channel interface
+//
+
+STBIDEF stbi_us *stbi_load_16_from_memory   (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels);
+STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels);
+
+#ifndef STBI_NO_STDIO
+STBIDEF stbi_us *stbi_load_16          (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);
+STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);
+#endif
+
+////////////////////////////////////
+//
+// float-per-channel interface
+//
+#ifndef STBI_NO_LINEAR
+   STBIDEF float *stbi_loadf_from_memory     (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels);
+   STBIDEF float *stbi_loadf_from_callbacks  (stbi_io_callbacks const *clbk, void *user, int *x, int *y,  int *channels_in_file, int desired_channels);
+
+   #ifndef STBI_NO_STDIO
+   STBIDEF float *stbi_loadf            (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);
+   STBIDEF float *stbi_loadf_from_file  (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);
+   #endif
+#endif
+
+#ifndef STBI_NO_HDR
+   STBIDEF void   stbi_hdr_to_ldr_gamma(float gamma);
+   STBIDEF void   stbi_hdr_to_ldr_scale(float scale);
+#endif // STBI_NO_HDR
+
+#ifndef STBI_NO_LINEAR
+   STBIDEF void   stbi_ldr_to_hdr_gamma(float gamma);
+   STBIDEF void   stbi_ldr_to_hdr_scale(float scale);
+#endif // STBI_NO_LINEAR
+
+// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR
+STBIDEF int    stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user);
+STBIDEF int    stbi_is_hdr_from_memory(stbi_uc const *buffer, int len);
+#ifndef STBI_NO_STDIO
+STBIDEF int      stbi_is_hdr          (char const *filename);
+STBIDEF int      stbi_is_hdr_from_file(FILE *f);
+#endif // STBI_NO_STDIO
+
+
+// get a VERY brief reason for failure
+// NOT THREADSAFE
+STBIDEF const char *stbi_failure_reason  (void);
+
+// free the loaded image -- this is just free()
+STBIDEF void     stbi_image_free      (void *retval_from_stbi_load);
+
+// get image dimensions & components without fully decoding
+STBIDEF int      stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);
+STBIDEF int      stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp);
+STBIDEF int      stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len);
+STBIDEF int      stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user);
+
+#ifndef STBI_NO_STDIO
+STBIDEF int      stbi_info               (char const *filename,     int *x, int *y, int *comp);
+STBIDEF int      stbi_info_from_file     (FILE *f,                  int *x, int *y, int *comp);
+STBIDEF int      stbi_is_16_bit          (char const *filename);
+STBIDEF int      stbi_is_16_bit_from_file(FILE *f);
+#endif
+
+
+
+// for image formats that explicitly notate that they have premultiplied alpha,
+// we just return the colors as stored in the file. set this flag to force
+// unpremultiplication. results are undefined if the unpremultiply overflow.
+STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply);
+
+// indicate whether we should process iphone images back to canonical format,
+// or just pass them through "as-is"
+STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert);
+
+// flip the image vertically, so the first pixel in the output array is the bottom left
+STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip);
+
+// ZLIB client - used by PNG, available for other purposes
+
+STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen);
+STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header);
+STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen);
+STBIDEF int   stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
+
+STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen);
+STBIDEF int   stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+//
+//
+////   end header file   /////////////////////////////////////////////////////
+#endif // STBI_INCLUDE_STB_IMAGE_H
+
+#ifdef STB_IMAGE_IMPLEMENTATION
+
+#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \
+  || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \
+  || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \
+  || defined(STBI_ONLY_ZLIB)
+   #ifndef STBI_ONLY_JPEG
+   #define STBI_NO_JPEG
+   #endif
+   #ifndef STBI_ONLY_PNG
+   #define STBI_NO_PNG
+   #endif
+   #ifndef STBI_ONLY_BMP
+   #define STBI_NO_BMP
+   #endif
+   #ifndef STBI_ONLY_PSD
+   #define STBI_NO_PSD
+   #endif
+   #ifndef STBI_ONLY_TGA
+   #define STBI_NO_TGA
+   #endif
+   #ifndef STBI_ONLY_GIF
+   #define STBI_NO_GIF
+   #endif
+   #ifndef STBI_ONLY_HDR
+   #define STBI_NO_HDR
+   #endif
+   #ifndef STBI_ONLY_PIC
+   #define STBI_NO_PIC
+   #endif
+   #ifndef STBI_ONLY_PNM
+   #define STBI_NO_PNM
+   #endif
+#endif
+
+#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB)
+#define STBI_NO_ZLIB
+#endif
+
+
+#include <stdarg.h>
+#include <stddef.h> // ptrdiff_t on osx
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+
+#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)
+#include <math.h>  // ldexp, pow
+#endif
+
+#ifndef STBI_NO_STDIO
+#include <stdio.h>
+#endif
+
+#ifndef STBI_ASSERT
+#include <assert.h>
+#define STBI_ASSERT(x) assert(x)
+#endif
+
+#ifdef __cplusplus
+#define STBI_EXTERN extern "C"
+#else
+#define STBI_EXTERN extern
+#endif
+
+
+#ifndef _MSC_VER
+   #ifdef __cplusplus
+   #define stbi_inline inline
+   #else
+   #define stbi_inline
+   #endif
+#else
+   #define stbi_inline __forceinline
+#endif
+
+
+#ifdef _MSC_VER
+typedef unsigned short stbi__uint16;
+typedef   signed short stbi__int16;
+typedef unsigned int   stbi__uint32;
+typedef   signed int   stbi__int32;
+#else
+#include <stdint.h>
+typedef uint16_t stbi__uint16;
+typedef int16_t  stbi__int16;
+typedef uint32_t stbi__uint32;
+typedef int32_t  stbi__int32;
+#endif
+
+// should produce compiler error if size is wrong
+typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1];
+
+#ifdef _MSC_VER
+#define STBI_NOTUSED(v)  (void)(v)
+#else
+#define STBI_NOTUSED(v)  (void)sizeof(v)
+#endif
+
+#ifdef _MSC_VER
+#define STBI_HAS_LROTL
+#endif
+
+#ifdef STBI_HAS_LROTL
+   #define stbi_lrot(x,y)  _lrotl(x,y)
+#else
+   #define stbi_lrot(x,y)  (((x) << (y)) | ((x) >> (32 - (y))))
+#endif
+
+#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED))
+// ok
+#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED)
+// ok
+#else
+#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)."
+#endif
+
+#ifndef STBI_MALLOC
+#define STBI_MALLOC(sz)           malloc(sz)
+#define STBI_REALLOC(p,newsz)     realloc(p,newsz)
+#define STBI_FREE(p)              free(p)
+#endif
+
+#ifndef STBI_REALLOC_SIZED
+#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz)
+#endif
+
+// x86/x64 detection
+#if defined(__x86_64__) || defined(_M_X64)
+#define STBI__X64_TARGET
+#elif defined(__i386) || defined(_M_IX86)
+#define STBI__X86_TARGET
+#endif
+
+#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD)
+// gcc doesn't support sse2 intrinsics unless you compile with -msse2,
+// which in turn means it gets to use SSE2 everywhere. This is unfortunate,
+// but previous attempts to provide the SSE2 functions with runtime
+// detection caused numerous issues. The way architecture extensions are
+// exposed in GCC/Clang is, sadly, not really suited for one-file libs.
+// New behavior: if compiled with -msse2, we use SSE2 without any
+// detection; if not, we don't use it at all.
+#define STBI_NO_SIMD
+#endif
+
+#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD)
+// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET
+//
+// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the
+// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant.
+// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not
+// simultaneously enabling "-mstackrealign".
+//
+// See https://github.com/nothings/stb/issues/81 for more information.
+//
+// So default to no SSE2 on 32-bit MinGW. If you've read this far and added
+// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2.
+#define STBI_NO_SIMD
+#endif
+
+#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET))
+#define STBI_SSE2
+#include <emmintrin.h>
+
+#ifdef _MSC_VER
+
+#if _MSC_VER >= 1400  // not VC6
+#include <intrin.h> // __cpuid
+static int stbi__cpuid3(void)
+{
+   int info[4];
+   __cpuid(info,1);
+   return info[3];
+}
+#else
+static int stbi__cpuid3(void)
+{
+   int res;
+   __asm {
+      mov  eax,1
+      cpuid
+      mov  res,edx
+   }
+   return res;
+}
+#endif
+
+#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name
+
+#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
+static int stbi__sse2_available(void)
+{
+   int info3 = stbi__cpuid3();
+   return ((info3 >> 26) & 1) != 0;
+}
+#endif
+
+#else // assume GCC-style if not VC++
+#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
+
+#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
+static int stbi__sse2_available(void)
+{
+   // If we're even attempting to compile this on GCC/Clang, that means
+   // -msse2 is on, which means the compiler is allowed to use SSE2
+   // instructions at will, and so are we.
+   return 1;
+}
+#endif
+
+#endif
+#endif
+
+// ARM NEON
+#if defined(STBI_NO_SIMD) && defined(STBI_NEON)
+#undef STBI_NEON
+#endif
+
+#ifdef STBI_NEON
+#include <arm_neon.h>
+// assume GCC or Clang on ARM targets
+#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
+#endif
+
+#ifndef STBI_SIMD_ALIGN
+#define STBI_SIMD_ALIGN(type, name) type name
+#endif
+
+///////////////////////////////////////////////
+//
+//  stbi__context struct and start_xxx functions
+
+// stbi__context structure is our basic context used by all images, so it
+// contains all the IO context, plus some basic image information
+typedef struct
+{
+   stbi__uint32 img_x, img_y;
+   int img_n, img_out_n;
+
+   stbi_io_callbacks io;
+   void *io_user_data;
+
+   int read_from_callbacks;
+   int buflen;
+   stbi_uc buffer_start[128];
+
+   stbi_uc *img_buffer, *img_buffer_end;
+   stbi_uc *img_buffer_original, *img_buffer_original_end;
+} stbi__context;
+
+
+static void stbi__refill_buffer(stbi__context *s);
+
+// initialize a memory-decode context
+static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len)
+{
+   s->io.read = NULL;
+   s->read_from_callbacks = 0;
+   s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer;
+   s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len;
+}
+
+// initialize a callback-based context
+static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user)
+{
+   s->io = *c;
+   s->io_user_data = user;
+   s->buflen = sizeof(s->buffer_start);
+   s->read_from_callbacks = 1;
+   s->img_buffer_original = s->buffer_start;
+   stbi__refill_buffer(s);
+   s->img_buffer_original_end = s->img_buffer_end;
+}
+
+#ifndef STBI_NO_STDIO
+
+static int stbi__stdio_read(void *user, char *data, int size)
+{
+   return (int) fread(data,1,size,(FILE*) user);
+}
+
+static void stbi__stdio_skip(void *user, int n)
+{
+   fseek((FILE*) user, n, SEEK_CUR);
+}
+
+static int stbi__stdio_eof(void *user)
+{
+   return feof((FILE*) user);
+}
+
+static stbi_io_callbacks stbi__stdio_callbacks =
+{
+   stbi__stdio_read,
+   stbi__stdio_skip,
+   stbi__stdio_eof,
+};
+
+static void stbi__start_file(stbi__context *s, FILE *f)
+{
+   stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f);
+}
+
+//static void stop_file(stbi__context *s) { }
+
+#endif // !STBI_NO_STDIO
+
+static void stbi__rewind(stbi__context *s)
+{
+   // conceptually rewind SHOULD rewind to the beginning of the stream,
+   // but we just rewind to the beginning of the initial buffer, because
+   // we only use it after doing 'test', which only ever looks at at most 92 bytes
+   s->img_buffer = s->img_buffer_original;
+   s->img_buffer_end = s->img_buffer_original_end;
+}
+
+enum
+{
+   STBI_ORDER_RGB,
+   STBI_ORDER_BGR
+};
+
+typedef struct
+{
+   int bits_per_channel;
+   int num_channels;
+   int channel_order;
+} stbi__result_info;
+
+#ifndef STBI_NO_JPEG
+static int      stbi__jpeg_test(stbi__context *s);
+static void    *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_PNG
+static int      stbi__png_test(stbi__context *s);
+static void    *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__png_info(stbi__context *s, int *x, int *y, int *comp);
+static int      stbi__png_is16(stbi__context *s);
+#endif
+
+#ifndef STBI_NO_BMP
+static int      stbi__bmp_test(stbi__context *s);
+static void    *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_TGA
+static int      stbi__tga_test(stbi__context *s);
+static void    *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__tga_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_PSD
+static int      stbi__psd_test(stbi__context *s);
+static void    *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc);
+static int      stbi__psd_info(stbi__context *s, int *x, int *y, int *comp);
+static int      stbi__psd_is16(stbi__context *s);
+#endif
+
+#ifndef STBI_NO_HDR
+static int      stbi__hdr_test(stbi__context *s);
+static float   *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_PIC
+static int      stbi__pic_test(stbi__context *s);
+static void    *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__pic_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_GIF
+static int      stbi__gif_test(stbi__context *s);
+static void    *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static void    *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp);
+static int      stbi__gif_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_PNM
+static int      stbi__pnm_test(stbi__context *s);
+static void    *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+// this is not threadsafe
+static const char *stbi__g_failure_reason;
+
+STBIDEF const char *stbi_failure_reason(void)
+{
+   return stbi__g_failure_reason;
+}
+
+static int stbi__err(const char *str)
+{
+   stbi__g_failure_reason = str;
+   return 0;
+}
+
+static void *stbi__malloc(size_t size)
+{
+    return STBI_MALLOC(size);
+}
+
+// stb_image uses ints pervasively, including for offset calculations.
+// therefore the largest decoded image size we can support with the
+// current code, even on 64-bit targets, is INT_MAX. this is not a
+// significant limitation for the intended use case.
+//
+// we do, however, need to make sure our size calculations don't
+// overflow. hence a few helper functions for size calculations that
+// multiply integers together, making sure that they're non-negative
+// and no overflow occurs.
+
+// return 1 if the sum is valid, 0 on overflow.
+// negative terms are considered invalid.
+static int stbi__addsizes_valid(int a, int b)
+{
+   if (b < 0) return 0;
+   // now 0 <= b <= INT_MAX, hence also
+   // 0 <= INT_MAX - b <= INTMAX.
+   // And "a + b <= INT_MAX" (which might overflow) is the
+   // same as a <= INT_MAX - b (no overflow)
+   return a <= INT_MAX - b;
+}
+
+// returns 1 if the product is valid, 0 on overflow.
+// negative factors are considered invalid.
+static int stbi__mul2sizes_valid(int a, int b)
+{
+   if (a < 0 || b < 0) return 0;
+   if (b == 0) return 1; // mul-by-0 is always safe
+   // portable way to check for no overflows in a*b
+   return a <= INT_MAX/b;
+}
+
+// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow
+static int stbi__mad2sizes_valid(int a, int b, int add)
+{
+   return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add);
+}
+
+// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow
+static int stbi__mad3sizes_valid(int a, int b, int c, int add)
+{
+   return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
+      stbi__addsizes_valid(a*b*c, add);
+}
+
+// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow
+#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)
+static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add)
+{
+   return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
+      stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add);
+}
+#endif
+
+// mallocs with size overflow checking
+static void *stbi__malloc_mad2(int a, int b, int add)
+{
+   if (!stbi__mad2sizes_valid(a, b, add)) return NULL;
+   return stbi__malloc(a*b + add);
+}
+
+static void *stbi__malloc_mad3(int a, int b, int c, int add)
+{
+   if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL;
+   return stbi__malloc(a*b*c + add);
+}
+
+#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)
+static void *stbi__malloc_mad4(int a, int b, int c, int d, int add)
+{
+   if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL;
+   return stbi__malloc(a*b*c*d + add);
+}
+#endif
+
+// stbi__err - error
+// stbi__errpf - error returning pointer to float
+// stbi__errpuc - error returning pointer to unsigned char
+
+#ifdef STBI_NO_FAILURE_STRINGS
+   #define stbi__err(x,y)  0
+#elif defined(STBI_FAILURE_USERMSG)
+   #define stbi__err(x,y)  stbi__err(y)
+#else
+   #define stbi__err(x,y)  stbi__err(x)
+#endif
+
+#define stbi__errpf(x,y)   ((float *)(size_t) (stbi__err(x,y)?NULL:NULL))
+#define stbi__errpuc(x,y)  ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL))
+
+STBIDEF void stbi_image_free(void *retval_from_stbi_load)
+{
+   STBI_FREE(retval_from_stbi_load);
+}
+
+#ifndef STBI_NO_LINEAR
+static float   *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp);
+#endif
+
+#ifndef STBI_NO_HDR
+static stbi_uc *stbi__hdr_to_ldr(float   *data, int x, int y, int comp);
+#endif
+
+static int stbi__vertically_flip_on_load = 0;
+
+STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip)
+{
+    stbi__vertically_flip_on_load = flag_true_if_should_flip;
+}
+
+static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)
+{
+   memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields
+   ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed
+   ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order
+   ri->num_channels = 0;
+
+   #ifndef STBI_NO_JPEG
+   if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri);
+   #endif
+   #ifndef STBI_NO_PNG
+   if (stbi__png_test(s))  return stbi__png_load(s,x,y,comp,req_comp, ri);
+   #endif
+   #ifndef STBI_NO_BMP
+   if (stbi__bmp_test(s))  return stbi__bmp_load(s,x,y,comp,req_comp, ri);
+   #endif
+   #ifndef STBI_NO_GIF
+   if (stbi__gif_test(s))  return stbi__gif_load(s,x,y,comp,req_comp, ri);
+   #endif
+   #ifndef STBI_NO_PSD
+   if (stbi__psd_test(s))  return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc);
+   #endif
+   #ifndef STBI_NO_PIC
+   if (stbi__pic_test(s))  return stbi__pic_load(s,x,y,comp,req_comp, ri);
+   #endif
+   #ifndef STBI_NO_PNM
+   if (stbi__pnm_test(s))  return stbi__pnm_load(s,x,y,comp,req_comp, ri);
+   #endif
+
+   #ifndef STBI_NO_HDR
+   if (stbi__hdr_test(s)) {
+      float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri);
+      return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp);
+   }
+   #endif
+
+   #ifndef STBI_NO_TGA
+   // test tga last because it's a crappy test!
+   if (stbi__tga_test(s))
+      return stbi__tga_load(s,x,y,comp,req_comp, ri);
+   #endif
+
+   return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt");
+}
+
+static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels)
+{
+   int i;
+   int img_len = w * h * channels;
+   stbi_uc *reduced;
+
+   reduced = (stbi_uc *) stbi__malloc(img_len);
+   if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory");
+
+   for (i = 0; i < img_len; ++i)
+      reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling
+
+   STBI_FREE(orig);
+   return reduced;
+}
+
+static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels)
+{
+   int i;
+   int img_len = w * h * channels;
+   stbi__uint16 *enlarged;
+
+   enlarged = (stbi__uint16 *) stbi__malloc(img_len*2);
+   if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory");
+
+   for (i = 0; i < img_len; ++i)
+      enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff
+
+   STBI_FREE(orig);
+   return enlarged;
+}
+
+static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel)
+{
+   int row;
+   size_t bytes_per_row = (size_t)w * bytes_per_pixel;
+   stbi_uc temp[2048];
+   stbi_uc *bytes = (stbi_uc *)image;
+
+   for (row = 0; row < (h>>1); row++) {
+      stbi_uc *row0 = bytes + row*bytes_per_row;
+      stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row;
+      // swap row0 with row1
+      size_t bytes_left = bytes_per_row;
+      while (bytes_left) {
+         size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp);
+         memcpy(temp, row0, bytes_copy);
+         memcpy(row0, row1, bytes_copy);
+         memcpy(row1, temp, bytes_copy);
+         row0 += bytes_copy;
+         row1 += bytes_copy;
+         bytes_left -= bytes_copy;
+      }
+   }
+}
+
+#ifndef STBI_NO_GIF
+static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel)
+{
+   int slice;
+   int slice_size = w * h * bytes_per_pixel;
+
+   stbi_uc *bytes = (stbi_uc *)image;
+   for (slice = 0; slice < z; ++slice) {
+      stbi__vertical_flip(bytes, w, h, bytes_per_pixel); 
+      bytes += slice_size; 
+   }
+}
+#endif
+
+static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__result_info ri;
+   void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8);
+
+   if (result == NULL)
+      return NULL;
+
+   if (ri.bits_per_channel != 8) {
+      STBI_ASSERT(ri.bits_per_channel == 16);
+      result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp);
+      ri.bits_per_channel = 8;
+   }
+
+   // @TODO: move stbi__convert_format to here
+
+   if (stbi__vertically_flip_on_load) {
+      int channels = req_comp ? req_comp : *comp;
+      stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc));
+   }
+
+   return (unsigned char *) result;
+}
+
+static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__result_info ri;
+   void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16);
+
+   if (result == NULL)
+      return NULL;
+
+   if (ri.bits_per_channel != 16) {
+      STBI_ASSERT(ri.bits_per_channel == 8);
+      result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp);
+      ri.bits_per_channel = 16;
+   }
+
+   // @TODO: move stbi__convert_format16 to here
+   // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision
+
+   if (stbi__vertically_flip_on_load) {
+      int channels = req_comp ? req_comp : *comp;
+      stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16));
+   }
+
+   return (stbi__uint16 *) result;
+}
+
+#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR)
+static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp)
+{
+   if (stbi__vertically_flip_on_load && result != NULL) {
+      int channels = req_comp ? req_comp : *comp;
+      stbi__vertical_flip(result, *x, *y, channels * sizeof(float));
+   }
+}
+#endif
+
+#ifndef STBI_NO_STDIO
+
+#if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8)
+STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide);
+STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default);
+#endif
+
+#if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8)
+STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)
+{
+	return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, bufferlen, NULL, NULL);
+}
+#endif
+
+static FILE *stbi__fopen(char const *filename, char const *mode)
+{
+   FILE *f;
+#if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8)
+   wchar_t wMode[64];
+   wchar_t wFilename[1024];
+	if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)))
+      return 0;
+	
+	if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)))
+      return 0;
+
+#if _MSC_VER >= 1400
+	if (0 != _wfopen_s(&f, wFilename, wMode))
+		f = 0;
+#else
+   f = _wfopen(wFilename, wMode);
+#endif
+
+#elif defined(_MSC_VER) && _MSC_VER >= 1400
+   if (0 != fopen_s(&f, filename, mode))
+      f=0;
+#else
+   f = fopen(filename, mode);
+#endif
+   return f;
+}
+
+
+STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)
+{
+   FILE *f = stbi__fopen(filename, "rb");
+   unsigned char *result;
+   if (!f) return stbi__errpuc("can't fopen", "Unable to open file");
+   result = stbi_load_from_file(f,x,y,comp,req_comp);
+   fclose(f);
+   return result;
+}
+
+STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
+{
+   unsigned char *result;
+   stbi__context s;
+   stbi__start_file(&s,f);
+   result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
+   if (result) {
+      // need to 'unget' all the characters in the IO buffer
+      fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
+   }
+   return result;
+}
+
+STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__uint16 *result;
+   stbi__context s;
+   stbi__start_file(&s,f);
+   result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp);
+   if (result) {
+      // need to 'unget' all the characters in the IO buffer
+      fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
+   }
+   return result;
+}
+
+STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp)
+{
+   FILE *f = stbi__fopen(filename, "rb");
+   stbi__uint16 *result;
+   if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file");
+   result = stbi_load_from_file_16(f,x,y,comp,req_comp);
+   fclose(f);
+   return result;
+}
+
+
+#endif //!STBI_NO_STDIO
+
+STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels)
+{
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
+}
+
+STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels)
+{
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user);
+   return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
+}
+
+STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
+}
+
+STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+   return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
+}
+
+#ifndef STBI_NO_GIF
+STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp)
+{
+   unsigned char *result;
+   stbi__context s; 
+   stbi__start_mem(&s,buffer,len); 
+   
+   result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp);
+   if (stbi__vertically_flip_on_load) {
+      stbi__vertical_flip_slices( result, *x, *y, *z, *comp ); 
+   }
+
+   return result; 
+}
+#endif
+
+#ifndef STBI_NO_LINEAR
+static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp)
+{
+   unsigned char *data;
+   #ifndef STBI_NO_HDR
+   if (stbi__hdr_test(s)) {
+      stbi__result_info ri;
+      float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri);
+      if (hdr_data)
+         stbi__float_postprocess(hdr_data,x,y,comp,req_comp);
+      return hdr_data;
+   }
+   #endif
+   data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp);
+   if (data)
+      return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);
+   return stbi__errpf("unknown image type", "Image not of any known type, or corrupt");
+}
+
+STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__loadf_main(&s,x,y,comp,req_comp);
+}
+
+STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+   return stbi__loadf_main(&s,x,y,comp,req_comp);
+}
+
+#ifndef STBI_NO_STDIO
+STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)
+{
+   float *result;
+   FILE *f = stbi__fopen(filename, "rb");
+   if (!f) return stbi__errpf("can't fopen", "Unable to open file");
+   result = stbi_loadf_from_file(f,x,y,comp,req_comp);
+   fclose(f);
+   return result;
+}
+
+STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__context s;
+   stbi__start_file(&s,f);
+   return stbi__loadf_main(&s,x,y,comp,req_comp);
+}
+#endif // !STBI_NO_STDIO
+
+#endif // !STBI_NO_LINEAR
+
+// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is
+// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always
+// reports false!
+
+STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)
+{
+   #ifndef STBI_NO_HDR
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__hdr_test(&s);
+   #else
+   STBI_NOTUSED(buffer);
+   STBI_NOTUSED(len);
+   return 0;
+   #endif
+}
+
+#ifndef STBI_NO_STDIO
+STBIDEF int      stbi_is_hdr          (char const *filename)
+{
+   FILE *f = stbi__fopen(filename, "rb");
+   int result=0;
+   if (f) {
+      result = stbi_is_hdr_from_file(f);
+      fclose(f);
+   }
+   return result;
+}
+
+STBIDEF int stbi_is_hdr_from_file(FILE *f)
+{
+   #ifndef STBI_NO_HDR
+   long pos = ftell(f);
+   int res;
+   stbi__context s;
+   stbi__start_file(&s,f);
+   res = stbi__hdr_test(&s);
+   fseek(f, pos, SEEK_SET);
+   return res;
+   #else
+   STBI_NOTUSED(f);
+   return 0;
+   #endif
+}
+#endif // !STBI_NO_STDIO
+
+STBIDEF int      stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user)
+{
+   #ifndef STBI_NO_HDR
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+   return stbi__hdr_test(&s);
+   #else
+   STBI_NOTUSED(clbk);
+   STBI_NOTUSED(user);
+   return 0;
+   #endif
+}
+
+#ifndef STBI_NO_LINEAR
+static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f;
+
+STBIDEF void   stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; }
+STBIDEF void   stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; }
+#endif
+
+static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f;
+
+STBIDEF void   stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; }
+STBIDEF void   stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; }
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Common code used by all image loaders
+//
+
+enum
+{
+   STBI__SCAN_load=0,
+   STBI__SCAN_type,
+   STBI__SCAN_header
+};
+
+static void stbi__refill_buffer(stbi__context *s)
+{
+   int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen);
+   if (n == 0) {
+      // at end of file, treat same as if from memory, but need to handle case
+      // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file
+      s->read_from_callbacks = 0;
+      s->img_buffer = s->buffer_start;
+      s->img_buffer_end = s->buffer_start+1;
+      *s->img_buffer = 0;
+   } else {
+      s->img_buffer = s->buffer_start;
+      s->img_buffer_end = s->buffer_start + n;
+   }
+}
+
+stbi_inline static stbi_uc stbi__get8(stbi__context *s)
+{
+   if (s->img_buffer < s->img_buffer_end)
+      return *s->img_buffer++;
+   if (s->read_from_callbacks) {
+      stbi__refill_buffer(s);
+      return *s->img_buffer++;
+   }
+   return 0;
+}
+
+stbi_inline static int stbi__at_eof(stbi__context *s)
+{
+   if (s->io.read) {
+      if (!(s->io.eof)(s->io_user_data)) return 0;
+      // if feof() is true, check if buffer = end
+      // special case: we've only got the special 0 character at the end
+      if (s->read_from_callbacks == 0) return 1;
+   }
+
+   return s->img_buffer >= s->img_buffer_end;
+}
+
+static void stbi__skip(stbi__context *s, int n)
+{
+   if (n < 0) {
+      s->img_buffer = s->img_buffer_end;
+      return;
+   }
+   if (s->io.read) {
+      int blen = (int) (s->img_buffer_end - s->img_buffer);
+      if (blen < n) {
+         s->img_buffer = s->img_buffer_end;
+         (s->io.skip)(s->io_user_data, n - blen);
+         return;
+      }
+   }
+   s->img_buffer += n;
+}
+
+static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)
+{
+   if (s->io.read) {
+      int blen = (int) (s->img_buffer_end - s->img_buffer);
+      if (blen < n) {
+         int res, count;
+
+         memcpy(buffer, s->img_buffer, blen);
+
+         count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen);
+         res = (count == (n-blen));
+         s->img_buffer = s->img_buffer_end;
+         return res;
+      }
+   }
+
+   if (s->img_buffer+n <= s->img_buffer_end) {
+      memcpy(buffer, s->img_buffer, n);
+      s->img_buffer += n;
+      return 1;
+   } else
+      return 0;
+}
+
+static int stbi__get16be(stbi__context *s)
+{
+   int z = stbi__get8(s);
+   return (z << 8) + stbi__get8(s);
+}
+
+static stbi__uint32 stbi__get32be(stbi__context *s)
+{
+   stbi__uint32 z = stbi__get16be(s);
+   return (z << 16) + stbi__get16be(s);
+}
+
+#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF)
+// nothing
+#else
+static int stbi__get16le(stbi__context *s)
+{
+   int z = stbi__get8(s);
+   return z + (stbi__get8(s) << 8);
+}
+#endif
+
+#ifndef STBI_NO_BMP
+static stbi__uint32 stbi__get32le(stbi__context *s)
+{
+   stbi__uint32 z = stbi__get16le(s);
+   return z + (stbi__get16le(s) << 16);
+}
+#endif
+
+#define STBI__BYTECAST(x)  ((stbi_uc) ((x) & 255))  // truncate int to byte without warnings
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  generic converter from built-in img_n to req_comp
+//    individual types do this automatically as much as possible (e.g. jpeg
+//    does all cases internally since it needs to colorspace convert anyway,
+//    and it never has alpha, so very few cases ). png can automatically
+//    interleave an alpha=255 channel, but falls back to this for other cases
+//
+//  assume data buffer is malloced, so malloc a new one and free that one
+//  only failure mode is malloc failing
+
+static stbi_uc stbi__compute_y(int r, int g, int b)
+{
+   return (stbi_uc) (((r*77) + (g*150) +  (29*b)) >> 8);
+}
+
+static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y)
+{
+   int i,j;
+   unsigned char *good;
+
+   if (req_comp == img_n) return data;
+   STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
+
+   good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0);
+   if (good == NULL) {
+      STBI_FREE(data);
+      return stbi__errpuc("outofmem", "Out of memory");
+   }
+
+   for (j=0; j < (int) y; ++j) {
+      unsigned char *src  = data + j * x * img_n   ;
+      unsigned char *dest = good + j * x * req_comp;
+
+      #define STBI__COMBO(a,b)  ((a)*8+(b))
+      #define STBI__CASE(a,b)   case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
+      // convert source image with img_n components to one with req_comp components;
+      // avoid switch per pixel, so use switch per scanline and massive macros
+      switch (STBI__COMBO(img_n, req_comp)) {
+         STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255;                                     } break;
+         STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0];                                  } break;
+         STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255;                     } break;
+         STBI__CASE(2,1) { dest[0]=src[0];                                                  } break;
+         STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0];                                  } break;
+         STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1];                  } break;
+         STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255;        } break;
+         STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]);                   } break;
+         STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255;    } break;
+         STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]);                   } break;
+         STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break;
+         STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];                    } break;
+         default: STBI_ASSERT(0);
+      }
+      #undef STBI__CASE
+   }
+
+   STBI_FREE(data);
+   return good;
+}
+
+static stbi__uint16 stbi__compute_y_16(int r, int g, int b)
+{
+   return (stbi__uint16) (((r*77) + (g*150) +  (29*b)) >> 8);
+}
+
+static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y)
+{
+   int i,j;
+   stbi__uint16 *good;
+
+   if (req_comp == img_n) return data;
+   STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
+
+   good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2);
+   if (good == NULL) {
+      STBI_FREE(data);
+      return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory");
+   }
+
+   for (j=0; j < (int) y; ++j) {
+      stbi__uint16 *src  = data + j * x * img_n   ;
+      stbi__uint16 *dest = good + j * x * req_comp;
+
+      #define STBI__COMBO(a,b)  ((a)*8+(b))
+      #define STBI__CASE(a,b)   case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
+      // convert source image with img_n components to one with req_comp components;
+      // avoid switch per pixel, so use switch per scanline and massive macros
+      switch (STBI__COMBO(img_n, req_comp)) {
+         STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff;                                     } break;
+         STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0];                                     } break;
+         STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff;                     } break;
+         STBI__CASE(2,1) { dest[0]=src[0];                                                     } break;
+         STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0];                                     } break;
+         STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1];                     } break;
+         STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff;        } break;
+         STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]);                   } break;
+         STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; } break;
+         STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]);                   } break;
+         STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; } break;
+         STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];                       } break;
+         default: STBI_ASSERT(0);
+      }
+      #undef STBI__CASE
+   }
+
+   STBI_FREE(data);
+   return good;
+}
+
+#ifndef STBI_NO_LINEAR
+static float   *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
+{
+   int i,k,n;
+   float *output;
+   if (!data) return NULL;
+   output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0);
+   if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); }
+   // compute number of non-alpha components
+   if (comp & 1) n = comp; else n = comp-1;
+   for (i=0; i < x*y; ++i) {
+      for (k=0; k < n; ++k) {
+         output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale);
+      }
+   }
+   if (n < comp) {
+      for (i=0; i < x*y; ++i) {
+         output[i*comp + n] = data[i*comp + n]/255.0f;
+      }
+   }
+   STBI_FREE(data);
+   return output;
+}
+#endif
+
+#ifndef STBI_NO_HDR
+#define stbi__float2int(x)   ((int) (x))
+static stbi_uc *stbi__hdr_to_ldr(float   *data, int x, int y, int comp)
+{
+   int i,k,n;
+   stbi_uc *output;
+   if (!data) return NULL;
+   output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0);
+   if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); }
+   // compute number of non-alpha components
+   if (comp & 1) n = comp; else n = comp-1;
+   for (i=0; i < x*y; ++i) {
+      for (k=0; k < n; ++k) {
+         float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f;
+         if (z < 0) z = 0;
+         if (z > 255) z = 255;
+         output[i*comp + k] = (stbi_uc) stbi__float2int(z);
+      }
+      if (k < comp) {
+         float z = data[i*comp+k] * 255 + 0.5f;
+         if (z < 0) z = 0;
+         if (z > 255) z = 255;
+         output[i*comp + k] = (stbi_uc) stbi__float2int(z);
+      }
+   }
+   STBI_FREE(data);
+   return output;
+}
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  "baseline" JPEG/JFIF decoder
+//
+//    simple implementation
+//      - doesn't support delayed output of y-dimension
+//      - simple interface (only one output format: 8-bit interleaved RGB)
+//      - doesn't try to recover corrupt jpegs
+//      - doesn't allow partial loading, loading multiple at once
+//      - still fast on x86 (copying globals into locals doesn't help x86)
+//      - allocates lots of intermediate memory (full size of all components)
+//        - non-interleaved case requires this anyway
+//        - allows good upsampling (see next)
+//    high-quality
+//      - upsampled channels are bilinearly interpolated, even across blocks
+//      - quality integer IDCT derived from IJG's 'slow'
+//    performance
+//      - fast huffman; reasonable integer IDCT
+//      - some SIMD kernels for common paths on targets with SSE2/NEON
+//      - uses a lot of intermediate memory, could cache poorly
+
+#ifndef STBI_NO_JPEG
+
+// huffman decoding acceleration
+#define FAST_BITS   9  // larger handles more cases; smaller stomps less cache
+
+typedef struct
+{
+   stbi_uc  fast[1 << FAST_BITS];
+   // weirdly, repacking this into AoS is a 10% speed loss, instead of a win
+   stbi__uint16 code[256];
+   stbi_uc  values[256];
+   stbi_uc  size[257];
+   unsigned int maxcode[18];
+   int    delta[17];   // old 'firstsymbol' - old 'firstcode'
+} stbi__huffman;
+
+typedef struct
+{
+   stbi__context *s;
+   stbi__huffman huff_dc[4];
+   stbi__huffman huff_ac[4];
+   stbi__uint16 dequant[4][64];
+   stbi__int16 fast_ac[4][1 << FAST_BITS];
+
+// sizes for components, interleaved MCUs
+   int img_h_max, img_v_max;
+   int img_mcu_x, img_mcu_y;
+   int img_mcu_w, img_mcu_h;
+
+// definition of jpeg image component
+   struct
+   {
+      int id;
+      int h,v;
+      int tq;
+      int hd,ha;
+      int dc_pred;
+
+      int x,y,w2,h2;
+      stbi_uc *data;
+      void *raw_data, *raw_coeff;
+      stbi_uc *linebuf;
+      short   *coeff;   // progressive only
+      int      coeff_w, coeff_h; // number of 8x8 coefficient blocks
+   } img_comp[4];
+
+   stbi__uint32   code_buffer; // jpeg entropy-coded buffer
+   int            code_bits;   // number of valid bits
+   unsigned char  marker;      // marker seen while filling entropy buffer
+   int            nomore;      // flag if we saw a marker so must stop
+
+   int            progressive;
+   int            spec_start;
+   int            spec_end;
+   int            succ_high;
+   int            succ_low;
+   int            eob_run;
+   int            jfif;
+   int            app14_color_transform; // Adobe APP14 tag
+   int            rgb;
+
+   int scan_n, order[4];
+   int restart_interval, todo;
+
+// kernels
+   void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]);
+   void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step);
+   stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs);
+} stbi__jpeg;
+
+static int stbi__build_huffman(stbi__huffman *h, int *count)
+{
+   int i,j,k=0;
+   unsigned int code;
+   // build size list for each symbol (from JPEG spec)
+   for (i=0; i < 16; ++i)
+      for (j=0; j < count[i]; ++j)
+         h->size[k++] = (stbi_uc) (i+1);
+   h->size[k] = 0;
+
+   // compute actual symbols (from jpeg spec)
+   code = 0;
+   k = 0;
+   for(j=1; j <= 16; ++j) {
+      // compute delta to add to code to compute symbol id
+      h->delta[j] = k - code;
+      if (h->size[k] == j) {
+         while (h->size[k] == j)
+            h->code[k++] = (stbi__uint16) (code++);
+         if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt JPEG");
+      }
+      // compute largest code + 1 for this size, preshifted as needed later
+      h->maxcode[j] = code << (16-j);
+      code <<= 1;
+   }
+   h->maxcode[j] = 0xffffffff;
+
+   // build non-spec acceleration table; 255 is flag for not-accelerated
+   memset(h->fast, 255, 1 << FAST_BITS);
+   for (i=0; i < k; ++i) {
+      int s = h->size[i];
+      if (s <= FAST_BITS) {
+         int c = h->code[i] << (FAST_BITS-s);
+         int m = 1 << (FAST_BITS-s);
+         for (j=0; j < m; ++j) {
+            h->fast[c+j] = (stbi_uc) i;
+         }
+      }
+   }
+   return 1;
+}
+
+// build a table that decodes both magnitude and value of small ACs in
+// one go.
+static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h)
+{
+   int i;
+   for (i=0; i < (1 << FAST_BITS); ++i) {
+      stbi_uc fast = h->fast[i];
+      fast_ac[i] = 0;
+      if (fast < 255) {
+         int rs = h->values[fast];
+         int run = (rs >> 4) & 15;
+         int magbits = rs & 15;
+         int len = h->size[fast];
+
+         if (magbits && len + magbits <= FAST_BITS) {
+            // magnitude code followed by receive_extend code
+            int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits);
+            int m = 1 << (magbits - 1);
+            if (k < m) k += (~0U << magbits) + 1;
+            // if the result is small enough, we can fit it in fast_ac table
+            if (k >= -128 && k <= 127)
+               fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits));
+         }
+      }
+   }
+}
+
+static void stbi__grow_buffer_unsafe(stbi__jpeg *j)
+{
+   do {
+      unsigned int b = j->nomore ? 0 : stbi__get8(j->s);
+      if (b == 0xff) {
+         int c = stbi__get8(j->s);
+         while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes
+         if (c != 0) {
+            j->marker = (unsigned char) c;
+            j->nomore = 1;
+            return;
+         }
+      }
+      j->code_buffer |= b << (24 - j->code_bits);
+      j->code_bits += 8;
+   } while (j->code_bits <= 24);
+}
+
+// (1 << n) - 1
+static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535};
+
+// decode a jpeg huffman value from the bitstream
+stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h)
+{
+   unsigned int temp;
+   int c,k;
+
+   if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+
+   // look at the top FAST_BITS and determine what symbol ID it is,
+   // if the code is <= FAST_BITS
+   c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
+   k = h->fast[c];
+   if (k < 255) {
+      int s = h->size[k];
+      if (s > j->code_bits)
+         return -1;
+      j->code_buffer <<= s;
+      j->code_bits -= s;
+      return h->values[k];
+   }
+
+   // naive test is to shift the code_buffer down so k bits are
+   // valid, then test against maxcode. To speed this up, we've
+   // preshifted maxcode left so that it has (16-k) 0s at the
+   // end; in other words, regardless of the number of bits, it
+   // wants to be compared against something shifted to have 16;
+   // that way we don't need to shift inside the loop.
+   temp = j->code_buffer >> 16;
+   for (k=FAST_BITS+1 ; ; ++k)
+      if (temp < h->maxcode[k])
+         break;
+   if (k == 17) {
+      // error! code not found
+      j->code_bits -= 16;
+      return -1;
+   }
+
+   if (k > j->code_bits)
+      return -1;
+
+   // convert the huffman code to the symbol id
+   c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k];
+   STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]);
+
+   // convert the id to a symbol
+   j->code_bits -= k;
+   j->code_buffer <<= k;
+   return h->values[c];
+}
+
+// bias[n] = (-1<<n) + 1
+static const int stbi__jbias[16] = {0,-1,-3,-7,-15,-31,-63,-127,-255,-511,-1023,-2047,-4095,-8191,-16383,-32767};
+
+// combined JPEG 'receive' and JPEG 'extend', since baseline
+// always extends everything it receives.
+stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)
+{
+   unsigned int k;
+   int sgn;
+   if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
+
+   sgn = (stbi__int32)j->code_buffer >> 31; // sign bit is always in MSB
+   k = stbi_lrot(j->code_buffer, n);
+   STBI_ASSERT(n >= 0 && n < (int) (sizeof(stbi__bmask)/sizeof(*stbi__bmask)));
+   j->code_buffer = k & ~stbi__bmask[n];
+   k &= stbi__bmask[n];
+   j->code_bits -= n;
+   return k + (stbi__jbias[n] & ~sgn);
+}
+
+// get some unsigned bits
+stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n)
+{
+   unsigned int k;
+   if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
+   k = stbi_lrot(j->code_buffer, n);
+   j->code_buffer = k & ~stbi__bmask[n];
+   k &= stbi__bmask[n];
+   j->code_bits -= n;
+   return k;
+}
+
+stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j)
+{
+   unsigned int k;
+   if (j->code_bits < 1) stbi__grow_buffer_unsafe(j);
+   k = j->code_buffer;
+   j->code_buffer <<= 1;
+   --j->code_bits;
+   return k & 0x80000000;
+}
+
+// given a value that's at position X in the zigzag stream,
+// where does it appear in the 8x8 matrix coded as row-major?
+static const stbi_uc stbi__jpeg_dezigzag[64+15] =
+{
+    0,  1,  8, 16,  9,  2,  3, 10,
+   17, 24, 32, 25, 18, 11,  4,  5,
+   12, 19, 26, 33, 40, 48, 41, 34,
+   27, 20, 13,  6,  7, 14, 21, 28,
+   35, 42, 49, 56, 57, 50, 43, 36,
+   29, 22, 15, 23, 30, 37, 44, 51,
+   58, 59, 52, 45, 38, 31, 39, 46,
+   53, 60, 61, 54, 47, 55, 62, 63,
+   // let corrupt input sample past end
+   63, 63, 63, 63, 63, 63, 63, 63,
+   63, 63, 63, 63, 63, 63, 63
+};
+
+// decode one 64-entry block--
+static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant)
+{
+   int diff,dc,k;
+   int t;
+
+   if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+   t = stbi__jpeg_huff_decode(j, hdc);
+   if (t < 0) return stbi__err("bad huffman code","Corrupt JPEG");
+
+   // 0 all the ac values now so we can do it 32-bits at a time
+   memset(data,0,64*sizeof(data[0]));
+
+   diff = t ? stbi__extend_receive(j, t) : 0;
+   dc = j->img_comp[b].dc_pred + diff;
+   j->img_comp[b].dc_pred = dc;
+   data[0] = (short) (dc * dequant[0]);
+
+   // decode AC components, see JPEG spec
+   k = 1;
+   do {
+      unsigned int zig;
+      int c,r,s;
+      if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+      c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
+      r = fac[c];
+      if (r) { // fast-AC path
+         k += (r >> 4) & 15; // run
+         s = r & 15; // combined length
+         j->code_buffer <<= s;
+         j->code_bits -= s;
+         // decode into unzigzag'd location
+         zig = stbi__jpeg_dezigzag[k++];
+         data[zig] = (short) ((r >> 8) * dequant[zig]);
+      } else {
+         int rs = stbi__jpeg_huff_decode(j, hac);
+         if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
+         s = rs & 15;
+         r = rs >> 4;
+         if (s == 0) {
+            if (rs != 0xf0) break; // end block
+            k += 16;
+         } else {
+            k += r;
+            // decode into unzigzag'd location
+            zig = stbi__jpeg_dezigzag[k++];
+            data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]);
+         }
+      }
+   } while (k < 64);
+   return 1;
+}
+
+static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b)
+{
+   int diff,dc;
+   int t;
+   if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
+
+   if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+
+   if (j->succ_high == 0) {
+      // first scan for DC coefficient, must be first
+      memset(data,0,64*sizeof(data[0])); // 0 all the ac values now
+      t = stbi__jpeg_huff_decode(j, hdc);
+      diff = t ? stbi__extend_receive(j, t) : 0;
+
+      dc = j->img_comp[b].dc_pred + diff;
+      j->img_comp[b].dc_pred = dc;
+      data[0] = (short) (dc << j->succ_low);
+   } else {
+      // refinement scan for DC coefficient
+      if (stbi__jpeg_get_bit(j))
+         data[0] += (short) (1 << j->succ_low);
+   }
+   return 1;
+}
+
+// @OPTIMIZE: store non-zigzagged during the decode passes,
+// and only de-zigzag when dequantizing
+static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac)
+{
+   int k;
+   if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
+
+   if (j->succ_high == 0) {
+      int shift = j->succ_low;
+
+      if (j->eob_run) {
+         --j->eob_run;
+         return 1;
+      }
+
+      k = j->spec_start;
+      do {
+         unsigned int zig;
+         int c,r,s;
+         if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+         c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
+         r = fac[c];
+         if (r) { // fast-AC path
+            k += (r >> 4) & 15; // run
+            s = r & 15; // combined length
+            j->code_buffer <<= s;
+            j->code_bits -= s;
+            zig = stbi__jpeg_dezigzag[k++];
+            data[zig] = (short) ((r >> 8) << shift);
+         } else {
+            int rs = stbi__jpeg_huff_decode(j, hac);
+            if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
+            s = rs & 15;
+            r = rs >> 4;
+            if (s == 0) {
+               if (r < 15) {
+                  j->eob_run = (1 << r);
+                  if (r)
+                     j->eob_run += stbi__jpeg_get_bits(j, r);
+                  --j->eob_run;
+                  break;
+               }
+               k += 16;
+            } else {
+               k += r;
+               zig = stbi__jpeg_dezigzag[k++];
+               data[zig] = (short) (stbi__extend_receive(j,s) << shift);
+            }
+         }
+      } while (k <= j->spec_end);
+   } else {
+      // refinement scan for these AC coefficients
+
+      short bit = (short) (1 << j->succ_low);
+
+      if (j->eob_run) {
+         --j->eob_run;
+         for (k = j->spec_start; k <= j->spec_end; ++k) {
+            short *p = &data[stbi__jpeg_dezigzag[k]];
+            if (*p != 0)
+               if (stbi__jpeg_get_bit(j))
+                  if ((*p & bit)==0) {
+                     if (*p > 0)
+                        *p += bit;
+                     else
+                        *p -= bit;
+                  }
+         }
+      } else {
+         k = j->spec_start;
+         do {
+            int r,s;
+            int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh
+            if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
+            s = rs & 15;
+            r = rs >> 4;
+            if (s == 0) {
+               if (r < 15) {
+                  j->eob_run = (1 << r) - 1;
+                  if (r)
+                     j->eob_run += stbi__jpeg_get_bits(j, r);
+                  r = 64; // force end of block
+               } else {
+                  // r=15 s=0 should write 16 0s, so we just do
+                  // a run of 15 0s and then write s (which is 0),
+                  // so we don't have to do anything special here
+               }
+            } else {
+               if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG");
+               // sign bit
+               if (stbi__jpeg_get_bit(j))
+                  s = bit;
+               else
+                  s = -bit;
+            }
+
+            // advance by r
+            while (k <= j->spec_end) {
+               short *p = &data[stbi__jpeg_dezigzag[k++]];
+               if (*p != 0) {
+                  if (stbi__jpeg_get_bit(j))
+                     if ((*p & bit)==0) {
+                        if (*p > 0)
+                           *p += bit;
+                        else
+                           *p -= bit;
+                     }
+               } else {
+                  if (r == 0) {
+                     *p = (short) s;
+                     break;
+                  }
+                  --r;
+               }
+            }
+         } while (k <= j->spec_end);
+      }
+   }
+   return 1;
+}
+
+// take a -128..127 value and stbi__clamp it and convert to 0..255
+stbi_inline static stbi_uc stbi__clamp(int x)
+{
+   // trick to use a single test to catch both cases
+   if ((unsigned int) x > 255) {
+      if (x < 0) return 0;
+      if (x > 255) return 255;
+   }
+   return (stbi_uc) x;
+}
+
+#define stbi__f2f(x)  ((int) (((x) * 4096 + 0.5)))
+#define stbi__fsh(x)  ((x) * 4096)
+
+// derived from jidctint -- DCT_ISLOW
+#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \
+   int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \
+   p2 = s2;                                    \
+   p3 = s6;                                    \
+   p1 = (p2+p3) * stbi__f2f(0.5411961f);       \
+   t2 = p1 + p3*stbi__f2f(-1.847759065f);      \
+   t3 = p1 + p2*stbi__f2f( 0.765366865f);      \
+   p2 = s0;                                    \
+   p3 = s4;                                    \
+   t0 = stbi__fsh(p2+p3);                      \
+   t1 = stbi__fsh(p2-p3);                      \
+   x0 = t0+t3;                                 \
+   x3 = t0-t3;                                 \
+   x1 = t1+t2;                                 \
+   x2 = t1-t2;                                 \
+   t0 = s7;                                    \
+   t1 = s5;                                    \
+   t2 = s3;                                    \
+   t3 = s1;                                    \
+   p3 = t0+t2;                                 \
+   p4 = t1+t3;                                 \
+   p1 = t0+t3;                                 \
+   p2 = t1+t2;                                 \
+   p5 = (p3+p4)*stbi__f2f( 1.175875602f);      \
+   t0 = t0*stbi__f2f( 0.298631336f);           \
+   t1 = t1*stbi__f2f( 2.053119869f);           \
+   t2 = t2*stbi__f2f( 3.072711026f);           \
+   t3 = t3*stbi__f2f( 1.501321110f);           \
+   p1 = p5 + p1*stbi__f2f(-0.899976223f);      \
+   p2 = p5 + p2*stbi__f2f(-2.562915447f);      \
+   p3 = p3*stbi__f2f(-1.961570560f);           \
+   p4 = p4*stbi__f2f(-0.390180644f);           \
+   t3 += p1+p4;                                \
+   t2 += p2+p3;                                \
+   t1 += p2+p4;                                \
+   t0 += p1+p3;
+
+static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64])
+{
+   int i,val[64],*v=val;
+   stbi_uc *o;
+   short *d = data;
+
+   // columns
+   for (i=0; i < 8; ++i,++d, ++v) {
+      // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing
+      if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0
+           && d[40]==0 && d[48]==0 && d[56]==0) {
+         //    no shortcut                 0     seconds
+         //    (1|2|3|4|5|6|7)==0          0     seconds
+         //    all separate               -0.047 seconds
+         //    1 && 2|3 && 4|5 && 6|7:    -0.047 seconds
+         int dcterm = d[0]*4;
+         v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm;
+      } else {
+         STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56])
+         // constants scaled things up by 1<<12; let's bring them back
+         // down, but keep 2 extra bits of precision
+         x0 += 512; x1 += 512; x2 += 512; x3 += 512;
+         v[ 0] = (x0+t3) >> 10;
+         v[56] = (x0-t3) >> 10;
+         v[ 8] = (x1+t2) >> 10;
+         v[48] = (x1-t2) >> 10;
+         v[16] = (x2+t1) >> 10;
+         v[40] = (x2-t1) >> 10;
+         v[24] = (x3+t0) >> 10;
+         v[32] = (x3-t0) >> 10;
+      }
+   }
+
+   for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) {
+      // no fast case since the first 1D IDCT spread components out
+      STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7])
+      // constants scaled things up by 1<<12, plus we had 1<<2 from first
+      // loop, plus horizontal and vertical each scale by sqrt(8) so together
+      // we've got an extra 1<<3, so 1<<17 total we need to remove.
+      // so we want to round that, which means adding 0.5 * 1<<17,
+      // aka 65536. Also, we'll end up with -128 to 127 that we want
+      // to encode as 0..255 by adding 128, so we'll add that before the shift
+      x0 += 65536 + (128<<17);
+      x1 += 65536 + (128<<17);
+      x2 += 65536 + (128<<17);
+      x3 += 65536 + (128<<17);
+      // tried computing the shifts into temps, or'ing the temps to see
+      // if any were out of range, but that was slower
+      o[0] = stbi__clamp((x0+t3) >> 17);
+      o[7] = stbi__clamp((x0-t3) >> 17);
+      o[1] = stbi__clamp((x1+t2) >> 17);
+      o[6] = stbi__clamp((x1-t2) >> 17);
+      o[2] = stbi__clamp((x2+t1) >> 17);
+      o[5] = stbi__clamp((x2-t1) >> 17);
+      o[3] = stbi__clamp((x3+t0) >> 17);
+      o[4] = stbi__clamp((x3-t0) >> 17);
+   }
+}
+
+#ifdef STBI_SSE2
+// sse2 integer IDCT. not the fastest possible implementation but it
+// produces bit-identical results to the generic C version so it's
+// fully "transparent".
+static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
+{
+   // This is constructed to match our regular (generic) integer IDCT exactly.
+   __m128i row0, row1, row2, row3, row4, row5, row6, row7;
+   __m128i tmp;
+
+   // dot product constant: even elems=x, odd elems=y
+   #define dct_const(x,y)  _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y))
+
+   // out(0) = c0[even]*x + c0[odd]*y   (c0, x, y 16-bit, out 32-bit)
+   // out(1) = c1[even]*x + c1[odd]*y
+   #define dct_rot(out0,out1, x,y,c0,c1) \
+      __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \
+      __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \
+      __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \
+      __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \
+      __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \
+      __m128i out1##_h = _mm_madd_epi16(c0##hi, c1)
+
+   // out = in << 12  (in 16-bit, out 32-bit)
+   #define dct_widen(out, in) \
+      __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \
+      __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4)
+
+   // wide add
+   #define dct_wadd(out, a, b) \
+      __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \
+      __m128i out##_h = _mm_add_epi32(a##_h, b##_h)
+
+   // wide sub
+   #define dct_wsub(out, a, b) \
+      __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \
+      __m128i out##_h = _mm_sub_epi32(a##_h, b##_h)
+
+   // butterfly a/b, add bias, then shift by "s" and pack
+   #define dct_bfly32o(out0, out1, a,b,bias,s) \
+      { \
+         __m128i abiased_l = _mm_add_epi32(a##_l, bias); \
+         __m128i abiased_h = _mm_add_epi32(a##_h, bias); \
+         dct_wadd(sum, abiased, b); \
+         dct_wsub(dif, abiased, b); \
+         out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \
+         out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \
+      }
+
+   // 8-bit interleave step (for transposes)
+   #define dct_interleave8(a, b) \
+      tmp = a; \
+      a = _mm_unpacklo_epi8(a, b); \
+      b = _mm_unpackhi_epi8(tmp, b)
+
+   // 16-bit interleave step (for transposes)
+   #define dct_interleave16(a, b) \
+      tmp = a; \
+      a = _mm_unpacklo_epi16(a, b); \
+      b = _mm_unpackhi_epi16(tmp, b)
+
+   #define dct_pass(bias,shift) \
+      { \
+         /* even part */ \
+         dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \
+         __m128i sum04 = _mm_add_epi16(row0, row4); \
+         __m128i dif04 = _mm_sub_epi16(row0, row4); \
+         dct_widen(t0e, sum04); \
+         dct_widen(t1e, dif04); \
+         dct_wadd(x0, t0e, t3e); \
+         dct_wsub(x3, t0e, t3e); \
+         dct_wadd(x1, t1e, t2e); \
+         dct_wsub(x2, t1e, t2e); \
+         /* odd part */ \
+         dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \
+         dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \
+         __m128i sum17 = _mm_add_epi16(row1, row7); \
+         __m128i sum35 = _mm_add_epi16(row3, row5); \
+         dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \
+         dct_wadd(x4, y0o, y4o); \
+         dct_wadd(x5, y1o, y5o); \
+         dct_wadd(x6, y2o, y5o); \
+         dct_wadd(x7, y3o, y4o); \
+         dct_bfly32o(row0,row7, x0,x7,bias,shift); \
+         dct_bfly32o(row1,row6, x1,x6,bias,shift); \
+         dct_bfly32o(row2,row5, x2,x5,bias,shift); \
+         dct_bfly32o(row3,row4, x3,x4,bias,shift); \
+      }
+
+   __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f));
+   __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f));
+   __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f));
+   __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f));
+   __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f));
+   __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f));
+   __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f));
+   __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f));
+
+   // rounding biases in column/row passes, see stbi__idct_block for explanation.
+   __m128i bias_0 = _mm_set1_epi32(512);
+   __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17));
+
+   // load
+   row0 = _mm_load_si128((const __m128i *) (data + 0*8));
+   row1 = _mm_load_si128((const __m128i *) (data + 1*8));
+   row2 = _mm_load_si128((const __m128i *) (data + 2*8));
+   row3 = _mm_load_si128((const __m128i *) (data + 3*8));
+   row4 = _mm_load_si128((const __m128i *) (data + 4*8));
+   row5 = _mm_load_si128((const __m128i *) (data + 5*8));
+   row6 = _mm_load_si128((const __m128i *) (data + 6*8));
+   row7 = _mm_load_si128((const __m128i *) (data + 7*8));
+
+   // column pass
+   dct_pass(bias_0, 10);
+
+   {
+      // 16bit 8x8 transpose pass 1
+      dct_interleave16(row0, row4);
+      dct_interleave16(row1, row5);
+      dct_interleave16(row2, row6);
+      dct_interleave16(row3, row7);
+
+      // transpose pass 2
+      dct_interleave16(row0, row2);
+      dct_interleave16(row1, row3);
+      dct_interleave16(row4, row6);
+      dct_interleave16(row5, row7);
+
+      // transpose pass 3
+      dct_interleave16(row0, row1);
+      dct_interleave16(row2, row3);
+      dct_interleave16(row4, row5);
+      dct_interleave16(row6, row7);
+   }
+
+   // row pass
+   dct_pass(bias_1, 17);
+
+   {
+      // pack
+      __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7
+      __m128i p1 = _mm_packus_epi16(row2, row3);
+      __m128i p2 = _mm_packus_epi16(row4, row5);
+      __m128i p3 = _mm_packus_epi16(row6, row7);
+
+      // 8bit 8x8 transpose pass 1
+      dct_interleave8(p0, p2); // a0e0a1e1...
+      dct_interleave8(p1, p3); // c0g0c1g1...
+
+      // transpose pass 2
+      dct_interleave8(p0, p1); // a0c0e0g0...
+      dct_interleave8(p2, p3); // b0d0f0h0...
+
+      // transpose pass 3
+      dct_interleave8(p0, p2); // a0b0c0d0...
+      dct_interleave8(p1, p3); // a4b4c4d4...
+
+      // store
+      _mm_storel_epi64((__m128i *) out, p0); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, p2); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, p1); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, p3); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e));
+   }
+
+#undef dct_const
+#undef dct_rot
+#undef dct_widen
+#undef dct_wadd
+#undef dct_wsub
+#undef dct_bfly32o
+#undef dct_interleave8
+#undef dct_interleave16
+#undef dct_pass
+}
+
+#endif // STBI_SSE2
+
+#ifdef STBI_NEON
+
+// NEON integer IDCT. should produce bit-identical
+// results to the generic C version.
+static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
+{
+   int16x8_t row0, row1, row2, row3, row4, row5, row6, row7;
+
+   int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f));
+   int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f));
+   int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f));
+   int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f));
+   int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f));
+   int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f));
+   int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f));
+   int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f));
+   int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f));
+   int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f));
+   int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f));
+   int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f));
+
+#define dct_long_mul(out, inq, coeff) \
+   int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \
+   int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff)
+
+#define dct_long_mac(out, acc, inq, coeff) \
+   int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \
+   int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff)
+
+#define dct_widen(out, inq) \
+   int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \
+   int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12)
+
+// wide add
+#define dct_wadd(out, a, b) \
+   int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \
+   int32x4_t out##_h = vaddq_s32(a##_h, b##_h)
+
+// wide sub
+#define dct_wsub(out, a, b) \
+   int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \
+   int32x4_t out##_h = vsubq_s32(a##_h, b##_h)
+
+// butterfly a/b, then shift using "shiftop" by "s" and pack
+#define dct_bfly32o(out0,out1, a,b,shiftop,s) \
+   { \
+      dct_wadd(sum, a, b); \
+      dct_wsub(dif, a, b); \
+      out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \
+      out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \
+   }
+
+#define dct_pass(shiftop, shift) \
+   { \
+      /* even part */ \
+      int16x8_t sum26 = vaddq_s16(row2, row6); \
+      dct_long_mul(p1e, sum26, rot0_0); \
+      dct_long_mac(t2e, p1e, row6, rot0_1); \
+      dct_long_mac(t3e, p1e, row2, rot0_2); \
+      int16x8_t sum04 = vaddq_s16(row0, row4); \
+      int16x8_t dif04 = vsubq_s16(row0, row4); \
+      dct_widen(t0e, sum04); \
+      dct_widen(t1e, dif04); \
+      dct_wadd(x0, t0e, t3e); \
+      dct_wsub(x3, t0e, t3e); \
+      dct_wadd(x1, t1e, t2e); \
+      dct_wsub(x2, t1e, t2e); \
+      /* odd part */ \
+      int16x8_t sum15 = vaddq_s16(row1, row5); \
+      int16x8_t sum17 = vaddq_s16(row1, row7); \
+      int16x8_t sum35 = vaddq_s16(row3, row5); \
+      int16x8_t sum37 = vaddq_s16(row3, row7); \
+      int16x8_t sumodd = vaddq_s16(sum17, sum35); \
+      dct_long_mul(p5o, sumodd, rot1_0); \
+      dct_long_mac(p1o, p5o, sum17, rot1_1); \
+      dct_long_mac(p2o, p5o, sum35, rot1_2); \
+      dct_long_mul(p3o, sum37, rot2_0); \
+      dct_long_mul(p4o, sum15, rot2_1); \
+      dct_wadd(sump13o, p1o, p3o); \
+      dct_wadd(sump24o, p2o, p4o); \
+      dct_wadd(sump23o, p2o, p3o); \
+      dct_wadd(sump14o, p1o, p4o); \
+      dct_long_mac(x4, sump13o, row7, rot3_0); \
+      dct_long_mac(x5, sump24o, row5, rot3_1); \
+      dct_long_mac(x6, sump23o, row3, rot3_2); \
+      dct_long_mac(x7, sump14o, row1, rot3_3); \
+      dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \
+      dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \
+      dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \
+      dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \
+   }
+
+   // load
+   row0 = vld1q_s16(data + 0*8);
+   row1 = vld1q_s16(data + 1*8);
+   row2 = vld1q_s16(data + 2*8);
+   row3 = vld1q_s16(data + 3*8);
+   row4 = vld1q_s16(data + 4*8);
+   row5 = vld1q_s16(data + 5*8);
+   row6 = vld1q_s16(data + 6*8);
+   row7 = vld1q_s16(data + 7*8);
+
+   // add DC bias
+   row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0));
+
+   // column pass
+   dct_pass(vrshrn_n_s32, 10);
+
+   // 16bit 8x8 transpose
+   {
+// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively.
+// whether compilers actually get this is another story, sadly.
+#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; }
+#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); }
+#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); }
+
+      // pass 1
+      dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6
+      dct_trn16(row2, row3);
+      dct_trn16(row4, row5);
+      dct_trn16(row6, row7);
+
+      // pass 2
+      dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4
+      dct_trn32(row1, row3);
+      dct_trn32(row4, row6);
+      dct_trn32(row5, row7);
+
+      // pass 3
+      dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0
+      dct_trn64(row1, row5);
+      dct_trn64(row2, row6);
+      dct_trn64(row3, row7);
+
+#undef dct_trn16
+#undef dct_trn32
+#undef dct_trn64
+   }
+
+   // row pass
+   // vrshrn_n_s32 only supports shifts up to 16, we need
+   // 17. so do a non-rounding shift of 16 first then follow
+   // up with a rounding shift by 1.
+   dct_pass(vshrn_n_s32, 16);
+
+   {
+      // pack and round
+      uint8x8_t p0 = vqrshrun_n_s16(row0, 1);
+      uint8x8_t p1 = vqrshrun_n_s16(row1, 1);
+      uint8x8_t p2 = vqrshrun_n_s16(row2, 1);
+      uint8x8_t p3 = vqrshrun_n_s16(row3, 1);
+      uint8x8_t p4 = vqrshrun_n_s16(row4, 1);
+      uint8x8_t p5 = vqrshrun_n_s16(row5, 1);
+      uint8x8_t p6 = vqrshrun_n_s16(row6, 1);
+      uint8x8_t p7 = vqrshrun_n_s16(row7, 1);
+
+      // again, these can translate into one instruction, but often don't.
+#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; }
+#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); }
+#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); }
+
+      // sadly can't use interleaved stores here since we only write
+      // 8 bytes to each scan line!
+
+      // 8x8 8-bit transpose pass 1
+      dct_trn8_8(p0, p1);
+      dct_trn8_8(p2, p3);
+      dct_trn8_8(p4, p5);
+      dct_trn8_8(p6, p7);
+
+      // pass 2
+      dct_trn8_16(p0, p2);
+      dct_trn8_16(p1, p3);
+      dct_trn8_16(p4, p6);
+      dct_trn8_16(p5, p7);
+
+      // pass 3
+      dct_trn8_32(p0, p4);
+      dct_trn8_32(p1, p5);
+      dct_trn8_32(p2, p6);
+      dct_trn8_32(p3, p7);
+
+      // store
+      vst1_u8(out, p0); out += out_stride;
+      vst1_u8(out, p1); out += out_stride;
+      vst1_u8(out, p2); out += out_stride;
+      vst1_u8(out, p3); out += out_stride;
+      vst1_u8(out, p4); out += out_stride;
+      vst1_u8(out, p5); out += out_stride;
+      vst1_u8(out, p6); out += out_stride;
+      vst1_u8(out, p7);
+
+#undef dct_trn8_8
+#undef dct_trn8_16
+#undef dct_trn8_32
+   }
+
+#undef dct_long_mul
+#undef dct_long_mac
+#undef dct_widen
+#undef dct_wadd
+#undef dct_wsub
+#undef dct_bfly32o
+#undef dct_pass
+}
+
+#endif // STBI_NEON
+
+#define STBI__MARKER_none  0xff
+// if there's a pending marker from the entropy stream, return that
+// otherwise, fetch from the stream and get a marker. if there's no
+// marker, return 0xff, which is never a valid marker value
+static stbi_uc stbi__get_marker(stbi__jpeg *j)
+{
+   stbi_uc x;
+   if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; }
+   x = stbi__get8(j->s);
+   if (x != 0xff) return STBI__MARKER_none;
+   while (x == 0xff)
+      x = stbi__get8(j->s); // consume repeated 0xff fill bytes
+   return x;
+}
+
+// in each scan, we'll have scan_n components, and the order
+// of the components is specified by order[]
+#define STBI__RESTART(x)     ((x) >= 0xd0 && (x) <= 0xd7)
+
+// after a restart interval, stbi__jpeg_reset the entropy decoder and
+// the dc prediction
+static void stbi__jpeg_reset(stbi__jpeg *j)
+{
+   j->code_bits = 0;
+   j->code_buffer = 0;
+   j->nomore = 0;
+   j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = j->img_comp[3].dc_pred = 0;
+   j->marker = STBI__MARKER_none;
+   j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff;
+   j->eob_run = 0;
+   // no more than 1<<31 MCUs if no restart_interal? that's plenty safe,
+   // since we don't even allow 1<<30 pixels
+}
+
+static int stbi__parse_entropy_coded_data(stbi__jpeg *z)
+{
+   stbi__jpeg_reset(z);
+   if (!z->progressive) {
+      if (z->scan_n == 1) {
+         int i,j;
+         STBI_SIMD_ALIGN(short, data[64]);
+         int n = z->order[0];
+         // non-interleaved data, we just need to process one block at a time,
+         // in trivial scanline order
+         // number of blocks to do just depends on how many actual "pixels" this
+         // component has, independent of interleaved MCU blocking and such
+         int w = (z->img_comp[n].x+7) >> 3;
+         int h = (z->img_comp[n].y+7) >> 3;
+         for (j=0; j < h; ++j) {
+            for (i=0; i < w; ++i) {
+               int ha = z->img_comp[n].ha;
+               if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0;
+               z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);
+               // every data block is an MCU, so countdown the restart interval
+               if (--z->todo <= 0) {
+                  if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
+                  // if it's NOT a restart, then just bail, so we get corrupt data
+                  // rather than no data
+                  if (!STBI__RESTART(z->marker)) return 1;
+                  stbi__jpeg_reset(z);
+               }
+            }
+         }
+         return 1;
+      } else { // interleaved
+         int i,j,k,x,y;
+         STBI_SIMD_ALIGN(short, data[64]);
+         for (j=0; j < z->img_mcu_y; ++j) {
+            for (i=0; i < z->img_mcu_x; ++i) {
+               // scan an interleaved mcu... process scan_n components in order
+               for (k=0; k < z->scan_n; ++k) {
+                  int n = z->order[k];
+                  // scan out an mcu's worth of this component; that's just determined
+                  // by the basic H and V specified for the component
+                  for (y=0; y < z->img_comp[n].v; ++y) {
+                     for (x=0; x < z->img_comp[n].h; ++x) {
+                        int x2 = (i*z->img_comp[n].h + x)*8;
+                        int y2 = (j*z->img_comp[n].v + y)*8;
+                        int ha = z->img_comp[n].ha;
+                        if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0;
+                        z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data);
+                     }
+                  }
+               }
+               // after all interleaved components, that's an interleaved MCU,
+               // so now count down the restart interval
+               if (--z->todo <= 0) {
+                  if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
+                  if (!STBI__RESTART(z->marker)) return 1;
+                  stbi__jpeg_reset(z);
+               }
+            }
+         }
+         return 1;
+      }
+   } else {
+      if (z->scan_n == 1) {
+         int i,j;
+         int n = z->order[0];
+         // non-interleaved data, we just need to process one block at a time,
+         // in trivial scanline order
+         // number of blocks to do just depends on how many actual "pixels" this
+         // component has, independent of interleaved MCU blocking and such
+         int w = (z->img_comp[n].x+7) >> 3;
+         int h = (z->img_comp[n].y+7) >> 3;
+         for (j=0; j < h; ++j) {
+            for (i=0; i < w; ++i) {
+               short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);
+               if (z->spec_start == 0) {
+                  if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))
+                     return 0;
+               } else {
+                  int ha = z->img_comp[n].ha;
+                  if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha]))
+                     return 0;
+               }
+               // every data block is an MCU, so countdown the restart interval
+               if (--z->todo <= 0) {
+                  if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
+                  if (!STBI__RESTART(z->marker)) return 1;
+                  stbi__jpeg_reset(z);
+               }
+            }
+         }
+         return 1;
+      } else { // interleaved
+         int i,j,k,x,y;
+         for (j=0; j < z->img_mcu_y; ++j) {
+            for (i=0; i < z->img_mcu_x; ++i) {
+               // scan an interleaved mcu... process scan_n components in order
+               for (k=0; k < z->scan_n; ++k) {
+                  int n = z->order[k];
+                  // scan out an mcu's worth of this component; that's just determined
+                  // by the basic H and V specified for the component
+                  for (y=0; y < z->img_comp[n].v; ++y) {
+                     for (x=0; x < z->img_comp[n].h; ++x) {
+                        int x2 = (i*z->img_comp[n].h + x);
+                        int y2 = (j*z->img_comp[n].v + y);
+                        short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w);
+                        if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))
+                           return 0;
+                     }
+                  }
+               }
+               // after all interleaved components, that's an interleaved MCU,
+               // so now count down the restart interval
+               if (--z->todo <= 0) {
+                  if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
+                  if (!STBI__RESTART(z->marker)) return 1;
+                  stbi__jpeg_reset(z);
+               }
+            }
+         }
+         return 1;
+      }
+   }
+}
+
+static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant)
+{
+   int i;
+   for (i=0; i < 64; ++i)
+      data[i] *= dequant[i];
+}
+
+static void stbi__jpeg_finish(stbi__jpeg *z)
+{
+   if (z->progressive) {
+      // dequantize and idct the data
+      int i,j,n;
+      for (n=0; n < z->s->img_n; ++n) {
+         int w = (z->img_comp[n].x+7) >> 3;
+         int h = (z->img_comp[n].y+7) >> 3;
+         for (j=0; j < h; ++j) {
+            for (i=0; i < w; ++i) {
+               short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);
+               stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]);
+               z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);
+            }
+         }
+      }
+   }
+}
+
+static int stbi__process_marker(stbi__jpeg *z, int m)
+{
+   int L;
+   switch (m) {
+      case STBI__MARKER_none: // no marker found
+         return stbi__err("expected marker","Corrupt JPEG");
+
+      case 0xDD: // DRI - specify restart interval
+         if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG");
+         z->restart_interval = stbi__get16be(z->s);
+         return 1;
+
+      case 0xDB: // DQT - define quantization table
+         L = stbi__get16be(z->s)-2;
+         while (L > 0) {
+            int q = stbi__get8(z->s);
+            int p = q >> 4, sixteen = (p != 0);
+            int t = q & 15,i;
+            if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG");
+            if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG");
+
+            for (i=0; i < 64; ++i)
+               z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s));
+            L -= (sixteen ? 129 : 65);
+         }
+         return L==0;
+
+      case 0xC4: // DHT - define huffman table
+         L = stbi__get16be(z->s)-2;
+         while (L > 0) {
+            stbi_uc *v;
+            int sizes[16],i,n=0;
+            int q = stbi__get8(z->s);
+            int tc = q >> 4;
+            int th = q & 15;
+            if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG");
+            for (i=0; i < 16; ++i) {
+               sizes[i] = stbi__get8(z->s);
+               n += sizes[i];
+            }
+            L -= 17;
+            if (tc == 0) {
+               if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0;
+               v = z->huff_dc[th].values;
+            } else {
+               if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0;
+               v = z->huff_ac[th].values;
+            }
+            for (i=0; i < n; ++i)
+               v[i] = stbi__get8(z->s);
+            if (tc != 0)
+               stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th);
+            L -= n;
+         }
+         return L==0;
+   }
+
+   // check for comment block or APP blocks
+   if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) {
+      L = stbi__get16be(z->s);
+      if (L < 2) {
+         if (m == 0xFE)
+            return stbi__err("bad COM len","Corrupt JPEG");
+         else
+            return stbi__err("bad APP len","Corrupt JPEG");
+      }
+      L -= 2;
+
+      if (m == 0xE0 && L >= 5) { // JFIF APP0 segment
+         static const unsigned char tag[5] = {'J','F','I','F','\0'};
+         int ok = 1;
+         int i;
+         for (i=0; i < 5; ++i)
+            if (stbi__get8(z->s) != tag[i])
+               ok = 0;
+         L -= 5;
+         if (ok)
+            z->jfif = 1;
+      } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment
+         static const unsigned char tag[6] = {'A','d','o','b','e','\0'};
+         int ok = 1;
+         int i;
+         for (i=0; i < 6; ++i)
+            if (stbi__get8(z->s) != tag[i])
+               ok = 0;
+         L -= 6;
+         if (ok) {
+            stbi__get8(z->s); // version
+            stbi__get16be(z->s); // flags0
+            stbi__get16be(z->s); // flags1
+            z->app14_color_transform = stbi__get8(z->s); // color transform
+            L -= 6;
+         }
+      }
+
+      stbi__skip(z->s, L);
+      return 1;
+   }
+
+   return stbi__err("unknown marker","Corrupt JPEG");
+}
+
+// after we see SOS
+static int stbi__process_scan_header(stbi__jpeg *z)
+{
+   int i;
+   int Ls = stbi__get16be(z->s);
+   z->scan_n = stbi__get8(z->s);
+   if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad SOS component count","Corrupt JPEG");
+   if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG");
+   for (i=0; i < z->scan_n; ++i) {
+      int id = stbi__get8(z->s), which;
+      int q = stbi__get8(z->s);
+      for (which = 0; which < z->s->img_n; ++which)
+         if (z->img_comp[which].id == id)
+            break;
+      if (which == z->s->img_n) return 0; // no match
+      z->img_comp[which].hd = q >> 4;   if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG");
+      z->img_comp[which].ha = q & 15;   if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG");
+      z->order[i] = which;
+   }
+
+   {
+      int aa;
+      z->spec_start = stbi__get8(z->s);
+      z->spec_end   = stbi__get8(z->s); // should be 63, but might be 0
+      aa = stbi__get8(z->s);
+      z->succ_high = (aa >> 4);
+      z->succ_low  = (aa & 15);
+      if (z->progressive) {
+         if (z->spec_start > 63 || z->spec_end > 63  || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13)
+            return stbi__err("bad SOS", "Corrupt JPEG");
+      } else {
+         if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG");
+         if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG");
+         z->spec_end = 63;
+      }
+   }
+
+   return 1;
+}
+
+static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why)
+{
+   int i;
+   for (i=0; i < ncomp; ++i) {
+      if (z->img_comp[i].raw_data) {
+         STBI_FREE(z->img_comp[i].raw_data);
+         z->img_comp[i].raw_data = NULL;
+         z->img_comp[i].data = NULL;
+      }
+      if (z->img_comp[i].raw_coeff) {
+         STBI_FREE(z->img_comp[i].raw_coeff);
+         z->img_comp[i].raw_coeff = 0;
+         z->img_comp[i].coeff = 0;
+      }
+      if (z->img_comp[i].linebuf) {
+         STBI_FREE(z->img_comp[i].linebuf);
+         z->img_comp[i].linebuf = NULL;
+      }
+   }
+   return why;
+}
+
+static int stbi__process_frame_header(stbi__jpeg *z, int scan)
+{
+   stbi__context *s = z->s;
+   int Lf,p,i,q, h_max=1,v_max=1,c;
+   Lf = stbi__get16be(s);         if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG
+   p  = stbi__get8(s);            if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline
+   s->img_y = stbi__get16be(s);   if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG
+   s->img_x = stbi__get16be(s);   if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires
+   c = stbi__get8(s);
+   if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG");
+   s->img_n = c;
+   for (i=0; i < c; ++i) {
+      z->img_comp[i].data = NULL;
+      z->img_comp[i].linebuf = NULL;
+   }
+
+   if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG");
+
+   z->rgb = 0;
+   for (i=0; i < s->img_n; ++i) {
+      static const unsigned char rgb[3] = { 'R', 'G', 'B' };
+      z->img_comp[i].id = stbi__get8(s);
+      if (s->img_n == 3 && z->img_comp[i].id == rgb[i])
+         ++z->rgb;
+      q = stbi__get8(s);
+      z->img_comp[i].h = (q >> 4);  if (!z->img_comp[i].h || z->img_comp[i].h > 4) return stbi__err("bad H","Corrupt JPEG");
+      z->img_comp[i].v = q & 15;    if (!z->img_comp[i].v || z->img_comp[i].v > 4) return stbi__err("bad V","Corrupt JPEG");
+      z->img_comp[i].tq = stbi__get8(s);  if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG");
+   }
+
+   if (scan != STBI__SCAN_load) return 1;
+
+   if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode");
+
+   for (i=0; i < s->img_n; ++i) {
+      if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h;
+      if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v;
+   }
+
+   // compute interleaved mcu info
+   z->img_h_max = h_max;
+   z->img_v_max = v_max;
+   z->img_mcu_w = h_max * 8;
+   z->img_mcu_h = v_max * 8;
+   // these sizes can't be more than 17 bits
+   z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w;
+   z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h;
+
+   for (i=0; i < s->img_n; ++i) {
+      // number of effective pixels (e.g. for non-interleaved MCU)
+      z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max;
+      z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max;
+      // to simplify generation, we'll allocate enough memory to decode
+      // the bogus oversized data from using interleaved MCUs and their
+      // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't
+      // discard the extra data until colorspace conversion
+      //
+      // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier)
+      // so these muls can't overflow with 32-bit ints (which we require)
+      z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8;
+      z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8;
+      z->img_comp[i].coeff = 0;
+      z->img_comp[i].raw_coeff = 0;
+      z->img_comp[i].linebuf = NULL;
+      z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15);
+      if (z->img_comp[i].raw_data == NULL)
+         return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory"));
+      // align blocks for idct using mmx/sse
+      z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15);
+      if (z->progressive) {
+         // w2, h2 are multiples of 8 (see above)
+         z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8;
+         z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8;
+         z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15);
+         if (z->img_comp[i].raw_coeff == NULL)
+            return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory"));
+         z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15);
+      }
+   }
+
+   return 1;
+}
+
+// use comparisons since in some cases we handle more than one case (e.g. SOF)
+#define stbi__DNL(x)         ((x) == 0xdc)
+#define stbi__SOI(x)         ((x) == 0xd8)
+#define stbi__EOI(x)         ((x) == 0xd9)
+#define stbi__SOF(x)         ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2)
+#define stbi__SOS(x)         ((x) == 0xda)
+
+#define stbi__SOF_progressive(x)   ((x) == 0xc2)
+
+static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan)
+{
+   int m;
+   z->jfif = 0;
+   z->app14_color_transform = -1; // valid values are 0,1,2
+   z->marker = STBI__MARKER_none; // initialize cached marker to empty
+   m = stbi__get_marker(z);
+   if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG");
+   if (scan == STBI__SCAN_type) return 1;
+   m = stbi__get_marker(z);
+   while (!stbi__SOF(m)) {
+      if (!stbi__process_marker(z,m)) return 0;
+      m = stbi__get_marker(z);
+      while (m == STBI__MARKER_none) {
+         // some files have extra padding after their blocks, so ok, we'll scan
+         if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG");
+         m = stbi__get_marker(z);
+      }
+   }
+   z->progressive = stbi__SOF_progressive(m);
+   if (!stbi__process_frame_header(z, scan)) return 0;
+   return 1;
+}
+
+// decode image to YCbCr format
+static int stbi__decode_jpeg_image(stbi__jpeg *j)
+{
+   int m;
+   for (m = 0; m < 4; m++) {
+      j->img_comp[m].raw_data = NULL;
+      j->img_comp[m].raw_coeff = NULL;
+   }
+   j->restart_interval = 0;
+   if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0;
+   m = stbi__get_marker(j);
+   while (!stbi__EOI(m)) {
+      if (stbi__SOS(m)) {
+         if (!stbi__process_scan_header(j)) return 0;
+         if (!stbi__parse_entropy_coded_data(j)) return 0;
+         if (j->marker == STBI__MARKER_none ) {
+            // handle 0s at the end of image data from IP Kamera 9060
+            while (!stbi__at_eof(j->s)) {
+               int x = stbi__get8(j->s);
+               if (x == 255) {
+                  j->marker = stbi__get8(j->s);
+                  break;
+               }
+            }
+            // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0
+         }
+      } else if (stbi__DNL(m)) {
+         int Ld = stbi__get16be(j->s);
+         stbi__uint32 NL = stbi__get16be(j->s);
+         if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG");
+         if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG");
+      } else {
+         if (!stbi__process_marker(j, m)) return 0;
+      }
+      m = stbi__get_marker(j);
+   }
+   if (j->progressive)
+      stbi__jpeg_finish(j);
+   return 1;
+}
+
+// static jfif-centered resampling (across block boundaries)
+
+typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1,
+                                    int w, int hs);
+
+#define stbi__div4(x) ((stbi_uc) ((x) >> 2))
+
+static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+   STBI_NOTUSED(out);
+   STBI_NOTUSED(in_far);
+   STBI_NOTUSED(w);
+   STBI_NOTUSED(hs);
+   return in_near;
+}
+
+static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+   // need to generate two samples vertically for every one in input
+   int i;
+   STBI_NOTUSED(hs);
+   for (i=0; i < w; ++i)
+      out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2);
+   return out;
+}
+
+static stbi_uc*  stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+   // need to generate two samples horizontally for every one in input
+   int i;
+   stbi_uc *input = in_near;
+
+   if (w == 1) {
+      // if only one sample, can't do any interpolation
+      out[0] = out[1] = input[0];
+      return out;
+   }
+
+   out[0] = input[0];
+   out[1] = stbi__div4(input[0]*3 + input[1] + 2);
+   for (i=1; i < w-1; ++i) {
+      int n = 3*input[i]+2;
+      out[i*2+0] = stbi__div4(n+input[i-1]);
+      out[i*2+1] = stbi__div4(n+input[i+1]);
+   }
+   out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2);
+   out[i*2+1] = input[w-1];
+
+   STBI_NOTUSED(in_far);
+   STBI_NOTUSED(hs);
+
+   return out;
+}
+
+#define stbi__div16(x) ((stbi_uc) ((x) >> 4))
+
+static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+   // need to generate 2x2 samples for every one in input
+   int i,t0,t1;
+   if (w == 1) {
+      out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
+      return out;
+   }
+
+   t1 = 3*in_near[0] + in_far[0];
+   out[0] = stbi__div4(t1+2);
+   for (i=1; i < w; ++i) {
+      t0 = t1;
+      t1 = 3*in_near[i]+in_far[i];
+      out[i*2-1] = stbi__div16(3*t0 + t1 + 8);
+      out[i*2  ] = stbi__div16(3*t1 + t0 + 8);
+   }
+   out[w*2-1] = stbi__div4(t1+2);
+
+   STBI_NOTUSED(hs);
+
+   return out;
+}
+
+#if defined(STBI_SSE2) || defined(STBI_NEON)
+static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+   // need to generate 2x2 samples for every one in input
+   int i=0,t0,t1;
+
+   if (w == 1) {
+      out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
+      return out;
+   }
+
+   t1 = 3*in_near[0] + in_far[0];
+   // process groups of 8 pixels for as long as we can.
+   // note we can't handle the last pixel in a row in this loop
+   // because we need to handle the filter boundary conditions.
+   for (; i < ((w-1) & ~7); i += 8) {
+#if defined(STBI_SSE2)
+      // load and perform the vertical filtering pass
+      // this uses 3*x + y = 4*x + (y - x)
+      __m128i zero  = _mm_setzero_si128();
+      __m128i farb  = _mm_loadl_epi64((__m128i *) (in_far + i));
+      __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i));
+      __m128i farw  = _mm_unpacklo_epi8(farb, zero);
+      __m128i nearw = _mm_unpacklo_epi8(nearb, zero);
+      __m128i diff  = _mm_sub_epi16(farw, nearw);
+      __m128i nears = _mm_slli_epi16(nearw, 2);
+      __m128i curr  = _mm_add_epi16(nears, diff); // current row
+
+      // horizontal filter works the same based on shifted vers of current
+      // row. "prev" is current row shifted right by 1 pixel; we need to
+      // insert the previous pixel value (from t1).
+      // "next" is current row shifted left by 1 pixel, with first pixel
+      // of next block of 8 pixels added in.
+      __m128i prv0 = _mm_slli_si128(curr, 2);
+      __m128i nxt0 = _mm_srli_si128(curr, 2);
+      __m128i prev = _mm_insert_epi16(prv0, t1, 0);
+      __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7);
+
+      // horizontal filter, polyphase implementation since it's convenient:
+      // even pixels = 3*cur + prev = cur*4 + (prev - cur)
+      // odd  pixels = 3*cur + next = cur*4 + (next - cur)
+      // note the shared term.
+      __m128i bias  = _mm_set1_epi16(8);
+      __m128i curs = _mm_slli_epi16(curr, 2);
+      __m128i prvd = _mm_sub_epi16(prev, curr);
+      __m128i nxtd = _mm_sub_epi16(next, curr);
+      __m128i curb = _mm_add_epi16(curs, bias);
+      __m128i even = _mm_add_epi16(prvd, curb);
+      __m128i odd  = _mm_add_epi16(nxtd, curb);
+
+      // interleave even and odd pixels, then undo scaling.
+      __m128i int0 = _mm_unpacklo_epi16(even, odd);
+      __m128i int1 = _mm_unpackhi_epi16(even, odd);
+      __m128i de0  = _mm_srli_epi16(int0, 4);
+      __m128i de1  = _mm_srli_epi16(int1, 4);
+
+      // pack and write output
+      __m128i outv = _mm_packus_epi16(de0, de1);
+      _mm_storeu_si128((__m128i *) (out + i*2), outv);
+#elif defined(STBI_NEON)
+      // load and perform the vertical filtering pass
+      // this uses 3*x + y = 4*x + (y - x)
+      uint8x8_t farb  = vld1_u8(in_far + i);
+      uint8x8_t nearb = vld1_u8(in_near + i);
+      int16x8_t diff  = vreinterpretq_s16_u16(vsubl_u8(farb, nearb));
+      int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2));
+      int16x8_t curr  = vaddq_s16(nears, diff); // current row
+
+      // horizontal filter works the same based on shifted vers of current
+      // row. "prev" is current row shifted right by 1 pixel; we need to
+      // insert the previous pixel value (from t1).
+      // "next" is current row shifted left by 1 pixel, with first pixel
+      // of next block of 8 pixels added in.
+      int16x8_t prv0 = vextq_s16(curr, curr, 7);
+      int16x8_t nxt0 = vextq_s16(curr, curr, 1);
+      int16x8_t prev = vsetq_lane_s16(t1, prv0, 0);
+      int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7);
+
+      // horizontal filter, polyphase implementation since it's convenient:
+      // even pixels = 3*cur + prev = cur*4 + (prev - cur)
+      // odd  pixels = 3*cur + next = cur*4 + (next - cur)
+      // note the shared term.
+      int16x8_t curs = vshlq_n_s16(curr, 2);
+      int16x8_t prvd = vsubq_s16(prev, curr);
+      int16x8_t nxtd = vsubq_s16(next, curr);
+      int16x8_t even = vaddq_s16(curs, prvd);
+      int16x8_t odd  = vaddq_s16(curs, nxtd);
+
+      // undo scaling and round, then store with even/odd phases interleaved
+      uint8x8x2_t o;
+      o.val[0] = vqrshrun_n_s16(even, 4);
+      o.val[1] = vqrshrun_n_s16(odd,  4);
+      vst2_u8(out + i*2, o);
+#endif
+
+      // "previous" value for next iter
+      t1 = 3*in_near[i+7] + in_far[i+7];
+   }
+
+   t0 = t1;
+   t1 = 3*in_near[i] + in_far[i];
+   out[i*2] = stbi__div16(3*t1 + t0 + 8);
+
+   for (++i; i < w; ++i) {
+      t0 = t1;
+      t1 = 3*in_near[i]+in_far[i];
+      out[i*2-1] = stbi__div16(3*t0 + t1 + 8);
+      out[i*2  ] = stbi__div16(3*t1 + t0 + 8);
+   }
+   out[w*2-1] = stbi__div4(t1+2);
+
+   STBI_NOTUSED(hs);
+
+   return out;
+}
+#endif
+
+static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+   // resample with nearest-neighbor
+   int i,j;
+   STBI_NOTUSED(in_far);
+   for (i=0; i < w; ++i)
+      for (j=0; j < hs; ++j)
+         out[i*hs+j] = in_near[i];
+   return out;
+}
+
+// this is a reduced-precision calculation of YCbCr-to-RGB introduced
+// to make sure the code produces the same results in both SIMD and scalar
+#define stbi__float2fixed(x)  (((int) ((x) * 4096.0f + 0.5f)) << 8)
+static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step)
+{
+   int i;
+   for (i=0; i < count; ++i) {
+      int y_fixed = (y[i] << 20) + (1<<19); // rounding
+      int r,g,b;
+      int cr = pcr[i] - 128;
+      int cb = pcb[i] - 128;
+      r = y_fixed +  cr* stbi__float2fixed(1.40200f);
+      g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);
+      b = y_fixed                                     +   cb* stbi__float2fixed(1.77200f);
+      r >>= 20;
+      g >>= 20;
+      b >>= 20;
+      if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }
+      if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }
+      if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }
+      out[0] = (stbi_uc)r;
+      out[1] = (stbi_uc)g;
+      out[2] = (stbi_uc)b;
+      out[3] = 255;
+      out += step;
+   }
+}
+
+#if defined(STBI_SSE2) || defined(STBI_NEON)
+static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step)
+{
+   int i = 0;
+
+#ifdef STBI_SSE2
+   // step == 3 is pretty ugly on the final interleave, and i'm not convinced
+   // it's useful in practice (you wouldn't use it for textures, for example).
+   // so just accelerate step == 4 case.
+   if (step == 4) {
+      // this is a fairly straightforward implementation and not super-optimized.
+      __m128i signflip  = _mm_set1_epi8(-0x80);
+      __m128i cr_const0 = _mm_set1_epi16(   (short) ( 1.40200f*4096.0f+0.5f));
+      __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f));
+      __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f));
+      __m128i cb_const1 = _mm_set1_epi16(   (short) ( 1.77200f*4096.0f+0.5f));
+      __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128);
+      __m128i xw = _mm_set1_epi16(255); // alpha channel
+
+      for (; i+7 < count; i += 8) {
+         // load
+         __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i));
+         __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i));
+         __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i));
+         __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128
+         __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128
+
+         // unpack to short (and left-shift cr, cb by 8)
+         __m128i yw  = _mm_unpacklo_epi8(y_bias, y_bytes);
+         __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased);
+         __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased);
+
+         // color transform
+         __m128i yws = _mm_srli_epi16(yw, 4);
+         __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw);
+         __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw);
+         __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1);
+         __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1);
+         __m128i rws = _mm_add_epi16(cr0, yws);
+         __m128i gwt = _mm_add_epi16(cb0, yws);
+         __m128i bws = _mm_add_epi16(yws, cb1);
+         __m128i gws = _mm_add_epi16(gwt, cr1);
+
+         // descale
+         __m128i rw = _mm_srai_epi16(rws, 4);
+         __m128i bw = _mm_srai_epi16(bws, 4);
+         __m128i gw = _mm_srai_epi16(gws, 4);
+
+         // back to byte, set up for transpose
+         __m128i brb = _mm_packus_epi16(rw, bw);
+         __m128i gxb = _mm_packus_epi16(gw, xw);
+
+         // transpose to interleave channels
+         __m128i t0 = _mm_unpacklo_epi8(brb, gxb);
+         __m128i t1 = _mm_unpackhi_epi8(brb, gxb);
+         __m128i o0 = _mm_unpacklo_epi16(t0, t1);
+         __m128i o1 = _mm_unpackhi_epi16(t0, t1);
+
+         // store
+         _mm_storeu_si128((__m128i *) (out + 0), o0);
+         _mm_storeu_si128((__m128i *) (out + 16), o1);
+         out += 32;
+      }
+   }
+#endif
+
+#ifdef STBI_NEON
+   // in this version, step=3 support would be easy to add. but is there demand?
+   if (step == 4) {
+      // this is a fairly straightforward implementation and not super-optimized.
+      uint8x8_t signflip = vdup_n_u8(0x80);
+      int16x8_t cr_const0 = vdupq_n_s16(   (short) ( 1.40200f*4096.0f+0.5f));
+      int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f));
+      int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f));
+      int16x8_t cb_const1 = vdupq_n_s16(   (short) ( 1.77200f*4096.0f+0.5f));
+
+      for (; i+7 < count; i += 8) {
+         // load
+         uint8x8_t y_bytes  = vld1_u8(y + i);
+         uint8x8_t cr_bytes = vld1_u8(pcr + i);
+         uint8x8_t cb_bytes = vld1_u8(pcb + i);
+         int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip));
+         int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip));
+
+         // expand to s16
+         int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4));
+         int16x8_t crw = vshll_n_s8(cr_biased, 7);
+         int16x8_t cbw = vshll_n_s8(cb_biased, 7);
+
+         // color transform
+         int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0);
+         int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0);
+         int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1);
+         int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1);
+         int16x8_t rws = vaddq_s16(yws, cr0);
+         int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1);
+         int16x8_t bws = vaddq_s16(yws, cb1);
+
+         // undo scaling, round, convert to byte
+         uint8x8x4_t o;
+         o.val[0] = vqrshrun_n_s16(rws, 4);
+         o.val[1] = vqrshrun_n_s16(gws, 4);
+         o.val[2] = vqrshrun_n_s16(bws, 4);
+         o.val[3] = vdup_n_u8(255);
+
+         // store, interleaving r/g/b/a
+         vst4_u8(out, o);
+         out += 8*4;
+      }
+   }
+#endif
+
+   for (; i < count; ++i) {
+      int y_fixed = (y[i] << 20) + (1<<19); // rounding
+      int r,g,b;
+      int cr = pcr[i] - 128;
+      int cb = pcb[i] - 128;
+      r = y_fixed + cr* stbi__float2fixed(1.40200f);
+      g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);
+      b = y_fixed                                   +   cb* stbi__float2fixed(1.77200f);
+      r >>= 20;
+      g >>= 20;
+      b >>= 20;
+      if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }
+      if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }
+      if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }
+      out[0] = (stbi_uc)r;
+      out[1] = (stbi_uc)g;
+      out[2] = (stbi_uc)b;
+      out[3] = 255;
+      out += step;
+   }
+}
+#endif
+
+// set up the kernels
+static void stbi__setup_jpeg(stbi__jpeg *j)
+{
+   j->idct_block_kernel = stbi__idct_block;
+   j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row;
+   j->resample_row_hv_2_kernel = stbi__resample_row_hv_2;
+
+#ifdef STBI_SSE2
+   if (stbi__sse2_available()) {
+      j->idct_block_kernel = stbi__idct_simd;
+      j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
+      j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
+   }
+#endif
+
+#ifdef STBI_NEON
+   j->idct_block_kernel = stbi__idct_simd;
+   j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
+   j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
+#endif
+}
+
+// clean up the temporary component buffers
+static void stbi__cleanup_jpeg(stbi__jpeg *j)
+{
+   stbi__free_jpeg_components(j, j->s->img_n, 0);
+}
+
+typedef struct
+{
+   resample_row_func resample;
+   stbi_uc *line0,*line1;
+   int hs,vs;   // expansion factor in each axis
+   int w_lores; // horizontal pixels pre-expansion
+   int ystep;   // how far through vertical expansion we are
+   int ypos;    // which pre-expansion row we're on
+} stbi__resample;
+
+// fast 0..255 * 0..255 => 0..255 rounded multiplication
+static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y)
+{
+   unsigned int t = x*y + 128;
+   return (stbi_uc) ((t + (t >>8)) >> 8);
+}
+
+static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp)
+{
+   int n, decode_n, is_rgb;
+   z->s->img_n = 0; // make stbi__cleanup_jpeg safe
+
+   // validate req_comp
+   if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");
+
+   // load a jpeg image from whichever source, but leave in YCbCr format
+   if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; }
+
+   // determine actual number of components to generate
+   n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1;
+
+   is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif));
+
+   if (z->s->img_n == 3 && n < 3 && !is_rgb)
+      decode_n = 1;
+   else
+      decode_n = z->s->img_n;
+
+   // resample and color-convert
+   {
+      int k;
+      unsigned int i,j;
+      stbi_uc *output;
+      stbi_uc *coutput[4];
+
+      stbi__resample res_comp[4];
+
+      for (k=0; k < decode_n; ++k) {
+         stbi__resample *r = &res_comp[k];
+
+         // allocate line buffer big enough for upsampling off the edges
+         // with upsample factor of 4
+         z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3);
+         if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }
+
+         r->hs      = z->img_h_max / z->img_comp[k].h;
+         r->vs      = z->img_v_max / z->img_comp[k].v;
+         r->ystep   = r->vs >> 1;
+         r->w_lores = (z->s->img_x + r->hs-1) / r->hs;
+         r->ypos    = 0;
+         r->line0   = r->line1 = z->img_comp[k].data;
+
+         if      (r->hs == 1 && r->vs == 1) r->resample = resample_row_1;
+         else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2;
+         else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2;
+         else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel;
+         else                               r->resample = stbi__resample_row_generic;
+      }
+
+      // can't error after this so, this is safe
+      output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1);
+      if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }
+
+      // now go ahead and resample
+      for (j=0; j < z->s->img_y; ++j) {
+         stbi_uc *out = output + n * z->s->img_x * j;
+         for (k=0; k < decode_n; ++k) {
+            stbi__resample *r = &res_comp[k];
+            int y_bot = r->ystep >= (r->vs >> 1);
+            coutput[k] = r->resample(z->img_comp[k].linebuf,
+                                     y_bot ? r->line1 : r->line0,
+                                     y_bot ? r->line0 : r->line1,
+                                     r->w_lores, r->hs);
+            if (++r->ystep >= r->vs) {
+               r->ystep = 0;
+               r->line0 = r->line1;
+               if (++r->ypos < z->img_comp[k].y)
+                  r->line1 += z->img_comp[k].w2;
+            }
+         }
+         if (n >= 3) {
+            stbi_uc *y = coutput[0];
+            if (z->s->img_n == 3) {
+               if (is_rgb) {
+                  for (i=0; i < z->s->img_x; ++i) {
+                     out[0] = y[i];
+                     out[1] = coutput[1][i];
+                     out[2] = coutput[2][i];
+                     out[3] = 255;
+                     out += n;
+                  }
+               } else {
+                  z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
+               }
+            } else if (z->s->img_n == 4) {
+               if (z->app14_color_transform == 0) { // CMYK
+                  for (i=0; i < z->s->img_x; ++i) {
+                     stbi_uc m = coutput[3][i];
+                     out[0] = stbi__blinn_8x8(coutput[0][i], m);
+                     out[1] = stbi__blinn_8x8(coutput[1][i], m);
+                     out[2] = stbi__blinn_8x8(coutput[2][i], m);
+                     out[3] = 255;
+                     out += n;
+                  }
+               } else if (z->app14_color_transform == 2) { // YCCK
+                  z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
+                  for (i=0; i < z->s->img_x; ++i) {
+                     stbi_uc m = coutput[3][i];
+                     out[0] = stbi__blinn_8x8(255 - out[0], m);
+                     out[1] = stbi__blinn_8x8(255 - out[1], m);
+                     out[2] = stbi__blinn_8x8(255 - out[2], m);
+                     out += n;
+                  }
+               } else { // YCbCr + alpha?  Ignore the fourth channel for now
+                  z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
+               }
+            } else
+               for (i=0; i < z->s->img_x; ++i) {
+                  out[0] = out[1] = out[2] = y[i];
+                  out[3] = 255; // not used if n==3
+                  out += n;
+               }
+         } else {
+            if (is_rgb) {
+               if (n == 1)
+                  for (i=0; i < z->s->img_x; ++i)
+                     *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);
+               else {
+                  for (i=0; i < z->s->img_x; ++i, out += 2) {
+                     out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);
+                     out[1] = 255;
+                  }
+               }
+            } else if (z->s->img_n == 4 && z->app14_color_transform == 0) {
+               for (i=0; i < z->s->img_x; ++i) {
+                  stbi_uc m = coutput[3][i];
+                  stbi_uc r = stbi__blinn_8x8(coutput[0][i], m);
+                  stbi_uc g = stbi__blinn_8x8(coutput[1][i], m);
+                  stbi_uc b = stbi__blinn_8x8(coutput[2][i], m);
+                  out[0] = stbi__compute_y(r, g, b);
+                  out[1] = 255;
+                  out += n;
+               }
+            } else if (z->s->img_n == 4 && z->app14_color_transform == 2) {
+               for (i=0; i < z->s->img_x; ++i) {
+                  out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]);
+                  out[1] = 255;
+                  out += n;
+               }
+            } else {
+               stbi_uc *y = coutput[0];
+               if (n == 1)
+                  for (i=0; i < z->s->img_x; ++i) out[i] = y[i];
+               else
+                  for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; }
+            }
+         }
+      }
+      stbi__cleanup_jpeg(z);
+      *out_x = z->s->img_x;
+      *out_y = z->s->img_y;
+      if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output
+      return output;
+   }
+}
+
+static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   unsigned char* result;
+   stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg));
+   STBI_NOTUSED(ri);
+   j->s = s;
+   stbi__setup_jpeg(j);
+   result = load_jpeg_image(j, x,y,comp,req_comp);
+   STBI_FREE(j);
+   return result;
+}
+
+static int stbi__jpeg_test(stbi__context *s)
+{
+   int r;
+   stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg));
+   j->s = s;
+   stbi__setup_jpeg(j);
+   r = stbi__decode_jpeg_header(j, STBI__SCAN_type);
+   stbi__rewind(s);
+   STBI_FREE(j);
+   return r;
+}
+
+static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp)
+{
+   if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) {
+      stbi__rewind( j->s );
+      return 0;
+   }
+   if (x) *x = j->s->img_x;
+   if (y) *y = j->s->img_y;
+   if (comp) *comp = j->s->img_n >= 3 ? 3 : 1;
+   return 1;
+}
+
+static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   int result;
+   stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg)));
+   j->s = s;
+   result = stbi__jpeg_info_raw(j, x, y, comp);
+   STBI_FREE(j);
+   return result;
+}
+#endif
+
+// public domain zlib decode    v0.2  Sean Barrett 2006-11-18
+//    simple implementation
+//      - all input must be provided in an upfront buffer
+//      - all output is written to a single output buffer (can malloc/realloc)
+//    performance
+//      - fast huffman
+
+#ifndef STBI_NO_ZLIB
+
+// fast-way is faster to check than jpeg huffman, but slow way is slower
+#define STBI__ZFAST_BITS  9 // accelerate all cases in default tables
+#define STBI__ZFAST_MASK  ((1 << STBI__ZFAST_BITS) - 1)
+
+// zlib-style huffman encoding
+// (jpegs packs from left, zlib from right, so can't share code)
+typedef struct
+{
+   stbi__uint16 fast[1 << STBI__ZFAST_BITS];
+   stbi__uint16 firstcode[16];
+   int maxcode[17];
+   stbi__uint16 firstsymbol[16];
+   stbi_uc  size[288];
+   stbi__uint16 value[288];
+} stbi__zhuffman;
+
+stbi_inline static int stbi__bitreverse16(int n)
+{
+  n = ((n & 0xAAAA) >>  1) | ((n & 0x5555) << 1);
+  n = ((n & 0xCCCC) >>  2) | ((n & 0x3333) << 2);
+  n = ((n & 0xF0F0) >>  4) | ((n & 0x0F0F) << 4);
+  n = ((n & 0xFF00) >>  8) | ((n & 0x00FF) << 8);
+  return n;
+}
+
+stbi_inline static int stbi__bit_reverse(int v, int bits)
+{
+   STBI_ASSERT(bits <= 16);
+   // to bit reverse n bits, reverse 16 and shift
+   // e.g. 11 bits, bit reverse and shift away 5
+   return stbi__bitreverse16(v) >> (16-bits);
+}
+
+static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num)
+{
+   int i,k=0;
+   int code, next_code[16], sizes[17];
+
+   // DEFLATE spec for generating codes
+   memset(sizes, 0, sizeof(sizes));
+   memset(z->fast, 0, sizeof(z->fast));
+   for (i=0; i < num; ++i)
+      ++sizes[sizelist[i]];
+   sizes[0] = 0;
+   for (i=1; i < 16; ++i)
+      if (sizes[i] > (1 << i))
+         return stbi__err("bad sizes", "Corrupt PNG");
+   code = 0;
+   for (i=1; i < 16; ++i) {
+      next_code[i] = code;
+      z->firstcode[i] = (stbi__uint16) code;
+      z->firstsymbol[i] = (stbi__uint16) k;
+      code = (code + sizes[i]);
+      if (sizes[i])
+         if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG");
+      z->maxcode[i] = code << (16-i); // preshift for inner loop
+      code <<= 1;
+      k += sizes[i];
+   }
+   z->maxcode[16] = 0x10000; // sentinel
+   for (i=0; i < num; ++i) {
+      int s = sizelist[i];
+      if (s) {
+         int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s];
+         stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i);
+         z->size [c] = (stbi_uc     ) s;
+         z->value[c] = (stbi__uint16) i;
+         if (s <= STBI__ZFAST_BITS) {
+            int j = stbi__bit_reverse(next_code[s],s);
+            while (j < (1 << STBI__ZFAST_BITS)) {
+               z->fast[j] = fastv;
+               j += (1 << s);
+            }
+         }
+         ++next_code[s];
+      }
+   }
+   return 1;
+}
+
+// zlib-from-memory implementation for PNG reading
+//    because PNG allows splitting the zlib stream arbitrarily,
+//    and it's annoying structurally to have PNG call ZLIB call PNG,
+//    we require PNG read all the IDATs and combine them into a single
+//    memory buffer
+
+typedef struct
+{
+   stbi_uc *zbuffer, *zbuffer_end;
+   int num_bits;
+   stbi__uint32 code_buffer;
+
+   char *zout;
+   char *zout_start;
+   char *zout_end;
+   int   z_expandable;
+
+   stbi__zhuffman z_length, z_distance;
+} stbi__zbuf;
+
+stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z)
+{
+   if (z->zbuffer >= z->zbuffer_end) return 0;
+   return *z->zbuffer++;
+}
+
+static void stbi__fill_bits(stbi__zbuf *z)
+{
+   do {
+      STBI_ASSERT(z->code_buffer < (1U << z->num_bits));
+      z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits;
+      z->num_bits += 8;
+   } while (z->num_bits <= 24);
+}
+
+stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n)
+{
+   unsigned int k;
+   if (z->num_bits < n) stbi__fill_bits(z);
+   k = z->code_buffer & ((1 << n) - 1);
+   z->code_buffer >>= n;
+   z->num_bits -= n;
+   return k;
+}
+
+static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z)
+{
+   int b,s,k;
+   // not resolved by fast table, so compute it the slow way
+   // use jpeg approach, which requires MSbits at top
+   k = stbi__bit_reverse(a->code_buffer, 16);
+   for (s=STBI__ZFAST_BITS+1; ; ++s)
+      if (k < z->maxcode[s])
+         break;
+   if (s == 16) return -1; // invalid code!
+   // code size is s, so:
+   b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s];
+   STBI_ASSERT(z->size[b] == s);
+   a->code_buffer >>= s;
+   a->num_bits -= s;
+   return z->value[b];
+}
+
+stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z)
+{
+   int b,s;
+   if (a->num_bits < 16) stbi__fill_bits(a);
+   b = z->fast[a->code_buffer & STBI__ZFAST_MASK];
+   if (b) {
+      s = b >> 9;
+      a->code_buffer >>= s;
+      a->num_bits -= s;
+      return b & 511;
+   }
+   return stbi__zhuffman_decode_slowpath(a, z);
+}
+
+static int stbi__zexpand(stbi__zbuf *z, char *zout, int n)  // need to make room for n bytes
+{
+   char *q;
+   int cur, limit, old_limit;
+   z->zout = zout;
+   if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG");
+   cur   = (int) (z->zout     - z->zout_start);
+   limit = old_limit = (int) (z->zout_end - z->zout_start);
+   while (cur + n > limit)
+      limit *= 2;
+   q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit);
+   STBI_NOTUSED(old_limit);
+   if (q == NULL) return stbi__err("outofmem", "Out of memory");
+   z->zout_start = q;
+   z->zout       = q + cur;
+   z->zout_end   = q + limit;
+   return 1;
+}
+
+static const int stbi__zlength_base[31] = {
+   3,4,5,6,7,8,9,10,11,13,
+   15,17,19,23,27,31,35,43,51,59,
+   67,83,99,115,131,163,195,227,258,0,0 };
+
+static const int stbi__zlength_extra[31]=
+{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 };
+
+static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,
+257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0};
+
+static const int stbi__zdist_extra[32] =
+{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
+
+static int stbi__parse_huffman_block(stbi__zbuf *a)
+{
+   char *zout = a->zout;
+   for(;;) {
+      int z = stbi__zhuffman_decode(a, &a->z_length);
+      if (z < 256) {
+         if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes
+         if (zout >= a->zout_end) {
+            if (!stbi__zexpand(a, zout, 1)) return 0;
+            zout = a->zout;
+         }
+         *zout++ = (char) z;
+      } else {
+         stbi_uc *p;
+         int len,dist;
+         if (z == 256) {
+            a->zout = zout;
+            return 1;
+         }
+         z -= 257;
+         len = stbi__zlength_base[z];
+         if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]);
+         z = stbi__zhuffman_decode(a, &a->z_distance);
+         if (z < 0) return stbi__err("bad huffman code","Corrupt PNG");
+         dist = stbi__zdist_base[z];
+         if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]);
+         if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG");
+         if (zout + len > a->zout_end) {
+            if (!stbi__zexpand(a, zout, len)) return 0;
+            zout = a->zout;
+         }
+         p = (stbi_uc *) (zout - dist);
+         if (dist == 1) { // run of one byte; common in images.
+            stbi_uc v = *p;
+            if (len) { do *zout++ = v; while (--len); }
+         } else {
+            if (len) { do *zout++ = *p++; while (--len); }
+         }
+      }
+   }
+}
+
+static int stbi__compute_huffman_codes(stbi__zbuf *a)
+{
+   static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 };
+   stbi__zhuffman z_codelength;
+   stbi_uc lencodes[286+32+137];//padding for maximum single op
+   stbi_uc codelength_sizes[19];
+   int i,n;
+
+   int hlit  = stbi__zreceive(a,5) + 257;
+   int hdist = stbi__zreceive(a,5) + 1;
+   int hclen = stbi__zreceive(a,4) + 4;
+   int ntot  = hlit + hdist;
+
+   memset(codelength_sizes, 0, sizeof(codelength_sizes));
+   for (i=0; i < hclen; ++i) {
+      int s = stbi__zreceive(a,3);
+      codelength_sizes[length_dezigzag[i]] = (stbi_uc) s;
+   }
+   if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0;
+
+   n = 0;
+   while (n < ntot) {
+      int c = stbi__zhuffman_decode(a, &z_codelength);
+      if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG");
+      if (c < 16)
+         lencodes[n++] = (stbi_uc) c;
+      else {
+         stbi_uc fill = 0;
+         if (c == 16) {
+            c = stbi__zreceive(a,2)+3;
+            if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG");
+            fill = lencodes[n-1];
+         } else if (c == 17)
+            c = stbi__zreceive(a,3)+3;
+         else {
+            STBI_ASSERT(c == 18);
+            c = stbi__zreceive(a,7)+11;
+         }
+         if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG");
+         memset(lencodes+n, fill, c);
+         n += c;
+      }
+   }
+   if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG");
+   if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0;
+   if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0;
+   return 1;
+}
+
+static int stbi__parse_uncompressed_block(stbi__zbuf *a)
+{
+   stbi_uc header[4];
+   int len,nlen,k;
+   if (a->num_bits & 7)
+      stbi__zreceive(a, a->num_bits & 7); // discard
+   // drain the bit-packed data into header
+   k = 0;
+   while (a->num_bits > 0) {
+      header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check
+      a->code_buffer >>= 8;
+      a->num_bits -= 8;
+   }
+   STBI_ASSERT(a->num_bits == 0);
+   // now fill header the normal way
+   while (k < 4)
+      header[k++] = stbi__zget8(a);
+   len  = header[1] * 256 + header[0];
+   nlen = header[3] * 256 + header[2];
+   if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG");
+   if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG");
+   if (a->zout + len > a->zout_end)
+      if (!stbi__zexpand(a, a->zout, len)) return 0;
+   memcpy(a->zout, a->zbuffer, len);
+   a->zbuffer += len;
+   a->zout += len;
+   return 1;
+}
+
+static int stbi__parse_zlib_header(stbi__zbuf *a)
+{
+   int cmf   = stbi__zget8(a);
+   int cm    = cmf & 15;
+   /* int cinfo = cmf >> 4; */
+   int flg   = stbi__zget8(a);
+   if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec
+   if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png
+   if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png
+   // window = 1 << (8 + cinfo)... but who cares, we fully buffer output
+   return 1;
+}
+
+static const stbi_uc stbi__zdefault_length[288] =
+{
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+   9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+   9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+   9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8
+};
+static const stbi_uc stbi__zdefault_distance[32] =
+{
+   5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5
+};
+/*
+Init algorithm:
+{
+   int i;   // use <= to match clearly with spec
+   for (i=0; i <= 143; ++i)     stbi__zdefault_length[i]   = 8;
+   for (   ; i <= 255; ++i)     stbi__zdefault_length[i]   = 9;
+   for (   ; i <= 279; ++i)     stbi__zdefault_length[i]   = 7;
+   for (   ; i <= 287; ++i)     stbi__zdefault_length[i]   = 8;
+
+   for (i=0; i <=  31; ++i)     stbi__zdefault_distance[i] = 5;
+}
+*/
+
+static int stbi__parse_zlib(stbi__zbuf *a, int parse_header)
+{
+   int final, type;
+   if (parse_header)
+      if (!stbi__parse_zlib_header(a)) return 0;
+   a->num_bits = 0;
+   a->code_buffer = 0;
+   do {
+      final = stbi__zreceive(a,1);
+      type = stbi__zreceive(a,2);
+      if (type == 0) {
+         if (!stbi__parse_uncompressed_block(a)) return 0;
+      } else if (type == 3) {
+         return 0;
+      } else {
+         if (type == 1) {
+            // use fixed code lengths
+            if (!stbi__zbuild_huffman(&a->z_length  , stbi__zdefault_length  , 288)) return 0;
+            if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance,  32)) return 0;
+         } else {
+            if (!stbi__compute_huffman_codes(a)) return 0;
+         }
+         if (!stbi__parse_huffman_block(a)) return 0;
+      }
+   } while (!final);
+   return 1;
+}
+
+static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header)
+{
+   a->zout_start = obuf;
+   a->zout       = obuf;
+   a->zout_end   = obuf + olen;
+   a->z_expandable = exp;
+
+   return stbi__parse_zlib(a, parse_header);
+}
+
+STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)
+{
+   stbi__zbuf a;
+   char *p = (char *) stbi__malloc(initial_size);
+   if (p == NULL) return NULL;
+   a.zbuffer = (stbi_uc *) buffer;
+   a.zbuffer_end = (stbi_uc *) buffer + len;
+   if (stbi__do_zlib(&a, p, initial_size, 1, 1)) {
+      if (outlen) *outlen = (int) (a.zout - a.zout_start);
+      return a.zout_start;
+   } else {
+      STBI_FREE(a.zout_start);
+      return NULL;
+   }
+}
+
+STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen)
+{
+   return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen);
+}
+
+STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)
+{
+   stbi__zbuf a;
+   char *p = (char *) stbi__malloc(initial_size);
+   if (p == NULL) return NULL;
+   a.zbuffer = (stbi_uc *) buffer;
+   a.zbuffer_end = (stbi_uc *) buffer + len;
+   if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) {
+      if (outlen) *outlen = (int) (a.zout - a.zout_start);
+      return a.zout_start;
+   } else {
+      STBI_FREE(a.zout_start);
+      return NULL;
+   }
+}
+
+STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen)
+{
+   stbi__zbuf a;
+   a.zbuffer = (stbi_uc *) ibuffer;
+   a.zbuffer_end = (stbi_uc *) ibuffer + ilen;
+   if (stbi__do_zlib(&a, obuffer, olen, 0, 1))
+      return (int) (a.zout - a.zout_start);
+   else
+      return -1;
+}
+
+STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)
+{
+   stbi__zbuf a;
+   char *p = (char *) stbi__malloc(16384);
+   if (p == NULL) return NULL;
+   a.zbuffer = (stbi_uc *) buffer;
+   a.zbuffer_end = (stbi_uc *) buffer+len;
+   if (stbi__do_zlib(&a, p, 16384, 1, 0)) {
+      if (outlen) *outlen = (int) (a.zout - a.zout_start);
+      return a.zout_start;
+   } else {
+      STBI_FREE(a.zout_start);
+      return NULL;
+   }
+}
+
+STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen)
+{
+   stbi__zbuf a;
+   a.zbuffer = (stbi_uc *) ibuffer;
+   a.zbuffer_end = (stbi_uc *) ibuffer + ilen;
+   if (stbi__do_zlib(&a, obuffer, olen, 0, 0))
+      return (int) (a.zout - a.zout_start);
+   else
+      return -1;
+}
+#endif
+
+// public domain "baseline" PNG decoder   v0.10  Sean Barrett 2006-11-18
+//    simple implementation
+//      - only 8-bit samples
+//      - no CRC checking
+//      - allocates lots of intermediate memory
+//        - avoids problem of streaming data between subsystems
+//        - avoids explicit window management
+//    performance
+//      - uses stb_zlib, a PD zlib implementation with fast huffman decoding
+
+#ifndef STBI_NO_PNG
+typedef struct
+{
+   stbi__uint32 length;
+   stbi__uint32 type;
+} stbi__pngchunk;
+
+static stbi__pngchunk stbi__get_chunk_header(stbi__context *s)
+{
+   stbi__pngchunk c;
+   c.length = stbi__get32be(s);
+   c.type   = stbi__get32be(s);
+   return c;
+}
+
+static int stbi__check_png_header(stbi__context *s)
+{
+   static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 };
+   int i;
+   for (i=0; i < 8; ++i)
+      if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG");
+   return 1;
+}
+
+typedef struct
+{
+   stbi__context *s;
+   stbi_uc *idata, *expanded, *out;
+   int depth;
+} stbi__png;
+
+
+enum {
+   STBI__F_none=0,
+   STBI__F_sub=1,
+   STBI__F_up=2,
+   STBI__F_avg=3,
+   STBI__F_paeth=4,
+   // synthetic filters used for first scanline to avoid needing a dummy row of 0s
+   STBI__F_avg_first,
+   STBI__F_paeth_first
+};
+
+static stbi_uc first_row_filter[5] =
+{
+   STBI__F_none,
+   STBI__F_sub,
+   STBI__F_none,
+   STBI__F_avg_first,
+   STBI__F_paeth_first
+};
+
+static int stbi__paeth(int a, int b, int c)
+{
+   int p = a + b - c;
+   int pa = abs(p-a);
+   int pb = abs(p-b);
+   int pc = abs(p-c);
+   if (pa <= pb && pa <= pc) return a;
+   if (pb <= pc) return b;
+   return c;
+}
+
+static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 };
+
+// create the png data from post-deflated data
+static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color)
+{
+   int bytes = (depth == 16? 2 : 1);
+   stbi__context *s = a->s;
+   stbi__uint32 i,j,stride = x*out_n*bytes;
+   stbi__uint32 img_len, img_width_bytes;
+   int k;
+   int img_n = s->img_n; // copy it into a local for later
+
+   int output_bytes = out_n*bytes;
+   int filter_bytes = img_n*bytes;
+   int width = x;
+
+   STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1);
+   a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into
+   if (!a->out) return stbi__err("outofmem", "Out of memory");
+
+   if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG");
+   img_width_bytes = (((img_n * x * depth) + 7) >> 3);
+   img_len = (img_width_bytes + 1) * y;
+
+   // we used to check for exact match between raw_len and img_len on non-interlaced PNGs,
+   // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros),
+   // so just check for raw_len < img_len always.
+   if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG");
+
+   for (j=0; j < y; ++j) {
+      stbi_uc *cur = a->out + stride*j;
+      stbi_uc *prior;
+      int filter = *raw++;
+
+      if (filter > 4)
+         return stbi__err("invalid filter","Corrupt PNG");
+
+      if (depth < 8) {
+         STBI_ASSERT(img_width_bytes <= x);
+         cur += x*out_n - img_width_bytes; // store output to the rightmost img_len bytes, so we can decode in place
+         filter_bytes = 1;
+         width = img_width_bytes;
+      }
+      prior = cur - stride; // bugfix: need to compute this after 'cur +=' computation above
+
+      // if first row, use special filter that doesn't sample previous row
+      if (j == 0) filter = first_row_filter[filter];
+
+      // handle first byte explicitly
+      for (k=0; k < filter_bytes; ++k) {
+         switch (filter) {
+            case STBI__F_none       : cur[k] = raw[k]; break;
+            case STBI__F_sub        : cur[k] = raw[k]; break;
+            case STBI__F_up         : cur[k] = STBI__BYTECAST(raw[k] + prior[k]); break;
+            case STBI__F_avg        : cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); break;
+            case STBI__F_paeth      : cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(0,prior[k],0)); break;
+            case STBI__F_avg_first  : cur[k] = raw[k]; break;
+            case STBI__F_paeth_first: cur[k] = raw[k]; break;
+         }
+      }
+
+      if (depth == 8) {
+         if (img_n != out_n)
+            cur[img_n] = 255; // first pixel
+         raw += img_n;
+         cur += out_n;
+         prior += out_n;
+      } else if (depth == 16) {
+         if (img_n != out_n) {
+            cur[filter_bytes]   = 255; // first pixel top byte
+            cur[filter_bytes+1] = 255; // first pixel bottom byte
+         }
+         raw += filter_bytes;
+         cur += output_bytes;
+         prior += output_bytes;
+      } else {
+         raw += 1;
+         cur += 1;
+         prior += 1;
+      }
+
+      // this is a little gross, so that we don't switch per-pixel or per-component
+      if (depth < 8 || img_n == out_n) {
+         int nk = (width - 1)*filter_bytes;
+         #define STBI__CASE(f) \
+             case f:     \
+                for (k=0; k < nk; ++k)
+         switch (filter) {
+            // "none" filter turns into a memcpy here; make that explicit.
+            case STBI__F_none:         memcpy(cur, raw, nk); break;
+            STBI__CASE(STBI__F_sub)          { cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); } break;
+            STBI__CASE(STBI__F_up)           { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break;
+            STBI__CASE(STBI__F_avg)          { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); } break;
+            STBI__CASE(STBI__F_paeth)        { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],prior[k],prior[k-filter_bytes])); } break;
+            STBI__CASE(STBI__F_avg_first)    { cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); } break;
+            STBI__CASE(STBI__F_paeth_first)  { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],0,0)); } break;
+         }
+         #undef STBI__CASE
+         raw += nk;
+      } else {
+         STBI_ASSERT(img_n+1 == out_n);
+         #define STBI__CASE(f) \
+             case f:     \
+                for (i=x-1; i >= 1; --i, cur[filter_bytes]=255,raw+=filter_bytes,cur+=output_bytes,prior+=output_bytes) \
+                   for (k=0; k < filter_bytes; ++k)
+         switch (filter) {
+            STBI__CASE(STBI__F_none)         { cur[k] = raw[k]; } break;
+            STBI__CASE(STBI__F_sub)          { cur[k] = STBI__BYTECAST(raw[k] + cur[k- output_bytes]); } break;
+            STBI__CASE(STBI__F_up)           { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break;
+            STBI__CASE(STBI__F_avg)          { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k- output_bytes])>>1)); } break;
+            STBI__CASE(STBI__F_paeth)        { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],prior[k],prior[k- output_bytes])); } break;
+            STBI__CASE(STBI__F_avg_first)    { cur[k] = STBI__BYTECAST(raw[k] + (cur[k- output_bytes] >> 1)); } break;
+            STBI__CASE(STBI__F_paeth_first)  { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],0,0)); } break;
+         }
+         #undef STBI__CASE
+
+         // the loop above sets the high byte of the pixels' alpha, but for
+         // 16 bit png files we also need the low byte set. we'll do that here.
+         if (depth == 16) {
+            cur = a->out + stride*j; // start at the beginning of the row again
+            for (i=0; i < x; ++i,cur+=output_bytes) {
+               cur[filter_bytes+1] = 255;
+            }
+         }
+      }
+   }
+
+   // we make a separate pass to expand bits to pixels; for performance,
+   // this could run two scanlines behind the above code, so it won't
+   // intefere with filtering but will still be in the cache.
+   if (depth < 8) {
+      for (j=0; j < y; ++j) {
+         stbi_uc *cur = a->out + stride*j;
+         stbi_uc *in  = a->out + stride*j + x*out_n - img_width_bytes;
+         // unpack 1/2/4-bit into a 8-bit buffer. allows us to keep the common 8-bit path optimal at minimal cost for 1/2/4-bit
+         // png guarante byte alignment, if width is not multiple of 8/4/2 we'll decode dummy trailing data that will be skipped in the later loop
+         stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range
+
+         // note that the final byte might overshoot and write more data than desired.
+         // we can allocate enough data that this never writes out of memory, but it
+         // could also overwrite the next scanline. can it overwrite non-empty data
+         // on the next scanline? yes, consider 1-pixel-wide scanlines with 1-bit-per-pixel.
+         // so we need to explicitly clamp the final ones
+
+         if (depth == 4) {
+            for (k=x*img_n; k >= 2; k-=2, ++in) {
+               *cur++ = scale * ((*in >> 4)       );
+               *cur++ = scale * ((*in     ) & 0x0f);
+            }
+            if (k > 0) *cur++ = scale * ((*in >> 4)       );
+         } else if (depth == 2) {
+            for (k=x*img_n; k >= 4; k-=4, ++in) {
+               *cur++ = scale * ((*in >> 6)       );
+               *cur++ = scale * ((*in >> 4) & 0x03);
+               *cur++ = scale * ((*in >> 2) & 0x03);
+               *cur++ = scale * ((*in     ) & 0x03);
+            }
+            if (k > 0) *cur++ = scale * ((*in >> 6)       );
+            if (k > 1) *cur++ = scale * ((*in >> 4) & 0x03);
+            if (k > 2) *cur++ = scale * ((*in >> 2) & 0x03);
+         } else if (depth == 1) {
+            for (k=x*img_n; k >= 8; k-=8, ++in) {
+               *cur++ = scale * ((*in >> 7)       );
+               *cur++ = scale * ((*in >> 6) & 0x01);
+               *cur++ = scale * ((*in >> 5) & 0x01);
+               *cur++ = scale * ((*in >> 4) & 0x01);
+               *cur++ = scale * ((*in >> 3) & 0x01);
+               *cur++ = scale * ((*in >> 2) & 0x01);
+               *cur++ = scale * ((*in >> 1) & 0x01);
+               *cur++ = scale * ((*in     ) & 0x01);
+            }
+            if (k > 0) *cur++ = scale * ((*in >> 7)       );
+            if (k > 1) *cur++ = scale * ((*in >> 6) & 0x01);
+            if (k > 2) *cur++ = scale * ((*in >> 5) & 0x01);
+            if (k > 3) *cur++ = scale * ((*in >> 4) & 0x01);
+            if (k > 4) *cur++ = scale * ((*in >> 3) & 0x01);
+            if (k > 5) *cur++ = scale * ((*in >> 2) & 0x01);
+            if (k > 6) *cur++ = scale * ((*in >> 1) & 0x01);
+         }
+         if (img_n != out_n) {
+            int q;
+            // insert alpha = 255
+            cur = a->out + stride*j;
+            if (img_n == 1) {
+               for (q=x-1; q >= 0; --q) {
+                  cur[q*2+1] = 255;
+                  cur[q*2+0] = cur[q];
+               }
+            } else {
+               STBI_ASSERT(img_n == 3);
+               for (q=x-1; q >= 0; --q) {
+                  cur[q*4+3] = 255;
+                  cur[q*4+2] = cur[q*3+2];
+                  cur[q*4+1] = cur[q*3+1];
+                  cur[q*4+0] = cur[q*3+0];
+               }
+            }
+         }
+      }
+   } else if (depth == 16) {
+      // force the image data from big-endian to platform-native.
+      // this is done in a separate pass due to the decoding relying
+      // on the data being untouched, but could probably be done
+      // per-line during decode if care is taken.
+      stbi_uc *cur = a->out;
+      stbi__uint16 *cur16 = (stbi__uint16*)cur;
+
+      for(i=0; i < x*y*out_n; ++i,cur16++,cur+=2) {
+         *cur16 = (cur[0] << 8) | cur[1];
+      }
+   }
+
+   return 1;
+}
+
+static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced)
+{
+   int bytes = (depth == 16 ? 2 : 1);
+   int out_bytes = out_n * bytes;
+   stbi_uc *final;
+   int p;
+   if (!interlaced)
+      return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color);
+
+   // de-interlacing
+   final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0);
+   for (p=0; p < 7; ++p) {
+      int xorig[] = { 0,4,0,2,0,1,0 };
+      int yorig[] = { 0,0,4,0,2,0,1 };
+      int xspc[]  = { 8,8,4,4,2,2,1 };
+      int yspc[]  = { 8,8,8,4,4,2,2 };
+      int i,j,x,y;
+      // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1
+      x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p];
+      y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p];
+      if (x && y) {
+         stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y;
+         if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) {
+            STBI_FREE(final);
+            return 0;
+         }
+         for (j=0; j < y; ++j) {
+            for (i=0; i < x; ++i) {
+               int out_y = j*yspc[p]+yorig[p];
+               int out_x = i*xspc[p]+xorig[p];
+               memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes,
+                      a->out + (j*x+i)*out_bytes, out_bytes);
+            }
+         }
+         STBI_FREE(a->out);
+         image_data += img_len;
+         image_data_len -= img_len;
+      }
+   }
+   a->out = final;
+
+   return 1;
+}
+
+static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n)
+{
+   stbi__context *s = z->s;
+   stbi__uint32 i, pixel_count = s->img_x * s->img_y;
+   stbi_uc *p = z->out;
+
+   // compute color-based transparency, assuming we've
+   // already got 255 as the alpha value in the output
+   STBI_ASSERT(out_n == 2 || out_n == 4);
+
+   if (out_n == 2) {
+      for (i=0; i < pixel_count; ++i) {
+         p[1] = (p[0] == tc[0] ? 0 : 255);
+         p += 2;
+      }
+   } else {
+      for (i=0; i < pixel_count; ++i) {
+         if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
+            p[3] = 0;
+         p += 4;
+      }
+   }
+   return 1;
+}
+
+static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n)
+{
+   stbi__context *s = z->s;
+   stbi__uint32 i, pixel_count = s->img_x * s->img_y;
+   stbi__uint16 *p = (stbi__uint16*) z->out;
+
+   // compute color-based transparency, assuming we've
+   // already got 65535 as the alpha value in the output
+   STBI_ASSERT(out_n == 2 || out_n == 4);
+
+   if (out_n == 2) {
+      for (i = 0; i < pixel_count; ++i) {
+         p[1] = (p[0] == tc[0] ? 0 : 65535);
+         p += 2;
+      }
+   } else {
+      for (i = 0; i < pixel_count; ++i) {
+         if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
+            p[3] = 0;
+         p += 4;
+      }
+   }
+   return 1;
+}
+
+static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n)
+{
+   stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y;
+   stbi_uc *p, *temp_out, *orig = a->out;
+
+   p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0);
+   if (p == NULL) return stbi__err("outofmem", "Out of memory");
+
+   // between here and free(out) below, exitting would leak
+   temp_out = p;
+
+   if (pal_img_n == 3) {
+      for (i=0; i < pixel_count; ++i) {
+         int n = orig[i]*4;
+         p[0] = palette[n  ];
+         p[1] = palette[n+1];
+         p[2] = palette[n+2];
+         p += 3;
+      }
+   } else {
+      for (i=0; i < pixel_count; ++i) {
+         int n = orig[i]*4;
+         p[0] = palette[n  ];
+         p[1] = palette[n+1];
+         p[2] = palette[n+2];
+         p[3] = palette[n+3];
+         p += 4;
+      }
+   }
+   STBI_FREE(a->out);
+   a->out = temp_out;
+
+   STBI_NOTUSED(len);
+
+   return 1;
+}
+
+static int stbi__unpremultiply_on_load = 0;
+static int stbi__de_iphone_flag = 0;
+
+STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply)
+{
+   stbi__unpremultiply_on_load = flag_true_if_should_unpremultiply;
+}
+
+STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)
+{
+   stbi__de_iphone_flag = flag_true_if_should_convert;
+}
+
+static void stbi__de_iphone(stbi__png *z)
+{
+   stbi__context *s = z->s;
+   stbi__uint32 i, pixel_count = s->img_x * s->img_y;
+   stbi_uc *p = z->out;
+
+   if (s->img_out_n == 3) {  // convert bgr to rgb
+      for (i=0; i < pixel_count; ++i) {
+         stbi_uc t = p[0];
+         p[0] = p[2];
+         p[2] = t;
+         p += 3;
+      }
+   } else {
+      STBI_ASSERT(s->img_out_n == 4);
+      if (stbi__unpremultiply_on_load) {
+         // convert bgr to rgb and unpremultiply
+         for (i=0; i < pixel_count; ++i) {
+            stbi_uc a = p[3];
+            stbi_uc t = p[0];
+            if (a) {
+               stbi_uc half = a / 2;
+               p[0] = (p[2] * 255 + half) / a;
+               p[1] = (p[1] * 255 + half) / a;
+               p[2] = ( t   * 255 + half) / a;
+            } else {
+               p[0] = p[2];
+               p[2] = t;
+            }
+            p += 4;
+         }
+      } else {
+         // convert bgr to rgb
+         for (i=0; i < pixel_count; ++i) {
+            stbi_uc t = p[0];
+            p[0] = p[2];
+            p[2] = t;
+            p += 4;
+         }
+      }
+   }
+}
+
+#define STBI__PNG_TYPE(a,b,c,d)  (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d))
+
+static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)
+{
+   stbi_uc palette[1024], pal_img_n=0;
+   stbi_uc has_trans=0, tc[3]={0};
+   stbi__uint16 tc16[3];
+   stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0;
+   int first=1,k,interlace=0, color=0, is_iphone=0;
+   stbi__context *s = z->s;
+
+   z->expanded = NULL;
+   z->idata = NULL;
+   z->out = NULL;
+
+   if (!stbi__check_png_header(s)) return 0;
+
+   if (scan == STBI__SCAN_type) return 1;
+
+   for (;;) {
+      stbi__pngchunk c = stbi__get_chunk_header(s);
+      switch (c.type) {
+         case STBI__PNG_TYPE('C','g','B','I'):
+            is_iphone = 1;
+            stbi__skip(s, c.length);
+            break;
+         case STBI__PNG_TYPE('I','H','D','R'): {
+            int comp,filter;
+            if (!first) return stbi__err("multiple IHDR","Corrupt PNG");
+            first = 0;
+            if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG");
+            s->img_x = stbi__get32be(s); if (s->img_x > (1 << 24)) return stbi__err("too large","Very large image (corrupt?)");
+            s->img_y = stbi__get32be(s); if (s->img_y > (1 << 24)) return stbi__err("too large","Very large image (corrupt?)");
+            z->depth = stbi__get8(s);  if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16)  return stbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only");
+            color = stbi__get8(s);  if (color > 6)         return stbi__err("bad ctype","Corrupt PNG");
+            if (color == 3 && z->depth == 16)                  return stbi__err("bad ctype","Corrupt PNG");
+            if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG");
+            comp  = stbi__get8(s);  if (comp) return stbi__err("bad comp method","Corrupt PNG");
+            filter= stbi__get8(s);  if (filter) return stbi__err("bad filter method","Corrupt PNG");
+            interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG");
+            if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG");
+            if (!pal_img_n) {
+               s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0);
+               if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode");
+               if (scan == STBI__SCAN_header) return 1;
+            } else {
+               // if paletted, then pal_n is our final components, and
+               // img_n is # components to decompress/filter.
+               s->img_n = 1;
+               if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG");
+               // if SCAN_header, have to scan to see if we have a tRNS
+            }
+            break;
+         }
+
+         case STBI__PNG_TYPE('P','L','T','E'):  {
+            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
+            if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG");
+            pal_len = c.length / 3;
+            if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG");
+            for (i=0; i < pal_len; ++i) {
+               palette[i*4+0] = stbi__get8(s);
+               palette[i*4+1] = stbi__get8(s);
+               palette[i*4+2] = stbi__get8(s);
+               palette[i*4+3] = 255;
+            }
+            break;
+         }
+
+         case STBI__PNG_TYPE('t','R','N','S'): {
+            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
+            if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG");
+            if (pal_img_n) {
+               if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; }
+               if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG");
+               if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG");
+               pal_img_n = 4;
+               for (i=0; i < c.length; ++i)
+                  palette[i*4+3] = stbi__get8(s);
+            } else {
+               if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG");
+               if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG");
+               has_trans = 1;
+               if (z->depth == 16) {
+                  for (k = 0; k < s->img_n; ++k) tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is
+               } else {
+                  for (k = 0; k < s->img_n; ++k) tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger
+               }
+            }
+            break;
+         }
+
+         case STBI__PNG_TYPE('I','D','A','T'): {
+            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
+            if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG");
+            if (scan == STBI__SCAN_header) { s->img_n = pal_img_n; return 1; }
+            if ((int)(ioff + c.length) < (int)ioff) return 0;
+            if (ioff + c.length > idata_limit) {
+               stbi__uint32 idata_limit_old = idata_limit;
+               stbi_uc *p;
+               if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096;
+               while (ioff + c.length > idata_limit)
+                  idata_limit *= 2;
+               STBI_NOTUSED(idata_limit_old);
+               p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory");
+               z->idata = p;
+            }
+            if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG");
+            ioff += c.length;
+            break;
+         }
+
+         case STBI__PNG_TYPE('I','E','N','D'): {
+            stbi__uint32 raw_len, bpl;
+            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
+            if (scan != STBI__SCAN_load) return 1;
+            if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG");
+            // initial guess for decoded data size to avoid unnecessary reallocs
+            bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component
+            raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */;
+            z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone);
+            if (z->expanded == NULL) return 0; // zlib should set error
+            STBI_FREE(z->idata); z->idata = NULL;
+            if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans)
+               s->img_out_n = s->img_n+1;
+            else
+               s->img_out_n = s->img_n;
+            if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0;
+            if (has_trans) {
+               if (z->depth == 16) {
+                  if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0;
+               } else {
+                  if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0;
+               }
+            }
+            if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2)
+               stbi__de_iphone(z);
+            if (pal_img_n) {
+               // pal_img_n == 3 or 4
+               s->img_n = pal_img_n; // record the actual colors we had
+               s->img_out_n = pal_img_n;
+               if (req_comp >= 3) s->img_out_n = req_comp;
+               if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n))
+                  return 0;
+            } else if (has_trans) {
+               // non-paletted image with tRNS -> source image has (constant) alpha
+               ++s->img_n;
+            }
+            STBI_FREE(z->expanded); z->expanded = NULL;
+            return 1;
+         }
+
+         default:
+            // if critical, fail
+            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
+            if ((c.type & (1 << 29)) == 0) {
+               #ifndef STBI_NO_FAILURE_STRINGS
+               // not threadsafe
+               static char invalid_chunk[] = "XXXX PNG chunk not known";
+               invalid_chunk[0] = STBI__BYTECAST(c.type >> 24);
+               invalid_chunk[1] = STBI__BYTECAST(c.type >> 16);
+               invalid_chunk[2] = STBI__BYTECAST(c.type >>  8);
+               invalid_chunk[3] = STBI__BYTECAST(c.type >>  0);
+               #endif
+               return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type");
+            }
+            stbi__skip(s, c.length);
+            break;
+      }
+      // end of PNG chunk, read and skip CRC
+      stbi__get32be(s);
+   }
+}
+
+static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri)
+{
+   void *result=NULL;
+   if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");
+   if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) {
+      if (p->depth < 8)
+         ri->bits_per_channel = 8;
+      else
+         ri->bits_per_channel = p->depth;
+      result = p->out;
+      p->out = NULL;
+      if (req_comp && req_comp != p->s->img_out_n) {
+         if (ri->bits_per_channel == 8)
+            result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
+         else
+            result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
+         p->s->img_out_n = req_comp;
+         if (result == NULL) return result;
+      }
+      *x = p->s->img_x;
+      *y = p->s->img_y;
+      if (n) *n = p->s->img_n;
+   }
+   STBI_FREE(p->out);      p->out      = NULL;
+   STBI_FREE(p->expanded); p->expanded = NULL;
+   STBI_FREE(p->idata);    p->idata    = NULL;
+
+   return result;
+}
+
+static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   stbi__png p;
+   p.s = s;
+   return stbi__do_png(&p, x,y,comp,req_comp, ri);
+}
+
+static int stbi__png_test(stbi__context *s)
+{
+   int r;
+   r = stbi__check_png_header(s);
+   stbi__rewind(s);
+   return r;
+}
+
+static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp)
+{
+   if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) {
+      stbi__rewind( p->s );
+      return 0;
+   }
+   if (x) *x = p->s->img_x;
+   if (y) *y = p->s->img_y;
+   if (comp) *comp = p->s->img_n;
+   return 1;
+}
+
+static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   stbi__png p;
+   p.s = s;
+   return stbi__png_info_raw(&p, x, y, comp);
+}
+
+static int stbi__png_is16(stbi__context *s)
+{
+   stbi__png p;
+   p.s = s;
+   if (!stbi__png_info_raw(&p, NULL, NULL, NULL))
+	   return 0;
+   if (p.depth != 16) {
+      stbi__rewind(p.s);
+      return 0;
+   }
+   return 1;
+}
+#endif
+
+// Microsoft/Windows BMP image
+
+#ifndef STBI_NO_BMP
+static int stbi__bmp_test_raw(stbi__context *s)
+{
+   int r;
+   int sz;
+   if (stbi__get8(s) != 'B') return 0;
+   if (stbi__get8(s) != 'M') return 0;
+   stbi__get32le(s); // discard filesize
+   stbi__get16le(s); // discard reserved
+   stbi__get16le(s); // discard reserved
+   stbi__get32le(s); // discard data offset
+   sz = stbi__get32le(s);
+   r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124);
+   return r;
+}
+
+static int stbi__bmp_test(stbi__context *s)
+{
+   int r = stbi__bmp_test_raw(s);
+   stbi__rewind(s);
+   return r;
+}
+
+
+// returns 0..31 for the highest set bit
+static int stbi__high_bit(unsigned int z)
+{
+   int n=0;
+   if (z == 0) return -1;
+   if (z >= 0x10000) { n += 16; z >>= 16; }
+   if (z >= 0x00100) { n +=  8; z >>=  8; }
+   if (z >= 0x00010) { n +=  4; z >>=  4; }
+   if (z >= 0x00004) { n +=  2; z >>=  2; }
+   if (z >= 0x00002) { n +=  1; z >>=  1; }
+   return n;
+}
+
+static int stbi__bitcount(unsigned int a)
+{
+   a = (a & 0x55555555) + ((a >>  1) & 0x55555555); // max 2
+   a = (a & 0x33333333) + ((a >>  2) & 0x33333333); // max 4
+   a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits
+   a = (a + (a >> 8)); // max 16 per 8 bits
+   a = (a + (a >> 16)); // max 32 per 8 bits
+   return a & 0xff;
+}
+
+// extract an arbitrarily-aligned N-bit value (N=bits)
+// from v, and then make it 8-bits long and fractionally
+// extend it to full full range.
+static int stbi__shiftsigned(unsigned int v, int shift, int bits)
+{
+   static unsigned int mul_table[9] = {
+      0,
+      0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/,
+      0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/,
+   };
+   static unsigned int shift_table[9] = {
+      0, 0,0,1,0,2,4,6,0,
+   };
+   if (shift < 0)
+      v <<= -shift;
+   else
+      v >>= shift;
+   STBI_ASSERT(v >= 0 && v < 256);
+   v >>= (8-bits);
+   STBI_ASSERT(bits >= 0 && bits <= 8);
+   return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits];
+}
+
+typedef struct
+{
+   int bpp, offset, hsz;
+   unsigned int mr,mg,mb,ma, all_a;
+} stbi__bmp_data;
+
+static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info)
+{
+   int hsz;
+   if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP");
+   stbi__get32le(s); // discard filesize
+   stbi__get16le(s); // discard reserved
+   stbi__get16le(s); // discard reserved
+   info->offset = stbi__get32le(s);
+   info->hsz = hsz = stbi__get32le(s);
+   info->mr = info->mg = info->mb = info->ma = 0;
+
+   if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown");
+   if (hsz == 12) {
+      s->img_x = stbi__get16le(s);
+      s->img_y = stbi__get16le(s);
+   } else {
+      s->img_x = stbi__get32le(s);
+      s->img_y = stbi__get32le(s);
+   }
+   if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP");
+   info->bpp = stbi__get16le(s);
+   if (hsz != 12) {
+      int compress = stbi__get32le(s);
+      if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE");
+      stbi__get32le(s); // discard sizeof
+      stbi__get32le(s); // discard hres
+      stbi__get32le(s); // discard vres
+      stbi__get32le(s); // discard colorsused
+      stbi__get32le(s); // discard max important
+      if (hsz == 40 || hsz == 56) {
+         if (hsz == 56) {
+            stbi__get32le(s);
+            stbi__get32le(s);
+            stbi__get32le(s);
+            stbi__get32le(s);
+         }
+         if (info->bpp == 16 || info->bpp == 32) {
+            if (compress == 0) {
+               if (info->bpp == 32) {
+                  info->mr = 0xffu << 16;
+                  info->mg = 0xffu <<  8;
+                  info->mb = 0xffu <<  0;
+                  info->ma = 0xffu << 24;
+                  info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0
+               } else {
+                  info->mr = 31u << 10;
+                  info->mg = 31u <<  5;
+                  info->mb = 31u <<  0;
+               }
+            } else if (compress == 3) {
+               info->mr = stbi__get32le(s);
+               info->mg = stbi__get32le(s);
+               info->mb = stbi__get32le(s);
+               // not documented, but generated by photoshop and handled by mspaint
+               if (info->mr == info->mg && info->mg == info->mb) {
+                  // ?!?!?
+                  return stbi__errpuc("bad BMP", "bad BMP");
+               }
+            } else
+               return stbi__errpuc("bad BMP", "bad BMP");
+         }
+      } else {
+         int i;
+         if (hsz != 108 && hsz != 124)
+            return stbi__errpuc("bad BMP", "bad BMP");
+         info->mr = stbi__get32le(s);
+         info->mg = stbi__get32le(s);
+         info->mb = stbi__get32le(s);
+         info->ma = stbi__get32le(s);
+         stbi__get32le(s); // discard color space
+         for (i=0; i < 12; ++i)
+            stbi__get32le(s); // discard color space parameters
+         if (hsz == 124) {
+            stbi__get32le(s); // discard rendering intent
+            stbi__get32le(s); // discard offset of profile data
+            stbi__get32le(s); // discard size of profile data
+            stbi__get32le(s); // discard reserved
+         }
+      }
+   }
+   return (void *) 1;
+}
+
+
+static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   stbi_uc *out;
+   unsigned int mr=0,mg=0,mb=0,ma=0, all_a;
+   stbi_uc pal[256][4];
+   int psize=0,i,j,width;
+   int flip_vertically, pad, target;
+   stbi__bmp_data info;
+   STBI_NOTUSED(ri);
+
+   info.all_a = 255;
+   if (stbi__bmp_parse_header(s, &info) == NULL)
+      return NULL; // error code already set
+
+   flip_vertically = ((int) s->img_y) > 0;
+   s->img_y = abs((int) s->img_y);
+
+   mr = info.mr;
+   mg = info.mg;
+   mb = info.mb;
+   ma = info.ma;
+   all_a = info.all_a;
+
+   if (info.hsz == 12) {
+      if (info.bpp < 24)
+         psize = (info.offset - 14 - 24) / 3;
+   } else {
+      if (info.bpp < 16)
+         psize = (info.offset - 14 - info.hsz) >> 2;
+   }
+
+   s->img_n = ma ? 4 : 3;
+   if (req_comp && req_comp >= 3) // we can directly decode 3 or 4
+      target = req_comp;
+   else
+      target = s->img_n; // if they want monochrome, we'll post-convert
+
+   // sanity-check size
+   if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0))
+      return stbi__errpuc("too large", "Corrupt BMP");
+
+   out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0);
+   if (!out) return stbi__errpuc("outofmem", "Out of memory");
+   if (info.bpp < 16) {
+      int z=0;
+      if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); }
+      for (i=0; i < psize; ++i) {
+         pal[i][2] = stbi__get8(s);
+         pal[i][1] = stbi__get8(s);
+         pal[i][0] = stbi__get8(s);
+         if (info.hsz != 12) stbi__get8(s);
+         pal[i][3] = 255;
+      }
+      stbi__skip(s, info.offset - 14 - info.hsz - psize * (info.hsz == 12 ? 3 : 4));
+      if (info.bpp == 1) width = (s->img_x + 7) >> 3;
+      else if (info.bpp == 4) width = (s->img_x + 1) >> 1;
+      else if (info.bpp == 8) width = s->img_x;
+      else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); }
+      pad = (-width)&3;
+      if (info.bpp == 1) {
+         for (j=0; j < (int) s->img_y; ++j) {
+            int bit_offset = 7, v = stbi__get8(s);
+            for (i=0; i < (int) s->img_x; ++i) {
+               int color = (v>>bit_offset)&0x1;
+               out[z++] = pal[color][0];
+               out[z++] = pal[color][1];
+               out[z++] = pal[color][2];
+               if (target == 4) out[z++] = 255;
+               if (i+1 == (int) s->img_x) break;
+               if((--bit_offset) < 0) {
+                  bit_offset = 7;
+                  v = stbi__get8(s);
+               }
+            }
+            stbi__skip(s, pad);
+         }
+      } else {
+         for (j=0; j < (int) s->img_y; ++j) {
+            for (i=0; i < (int) s->img_x; i += 2) {
+               int v=stbi__get8(s),v2=0;
+               if (info.bpp == 4) {
+                  v2 = v & 15;
+                  v >>= 4;
+               }
+               out[z++] = pal[v][0];
+               out[z++] = pal[v][1];
+               out[z++] = pal[v][2];
+               if (target == 4) out[z++] = 255;
+               if (i+1 == (int) s->img_x) break;
+               v = (info.bpp == 8) ? stbi__get8(s) : v2;
+               out[z++] = pal[v][0];
+               out[z++] = pal[v][1];
+               out[z++] = pal[v][2];
+               if (target == 4) out[z++] = 255;
+            }
+            stbi__skip(s, pad);
+         }
+      }
+   } else {
+      int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0;
+      int z = 0;
+      int easy=0;
+      stbi__skip(s, info.offset - 14 - info.hsz);
+      if (info.bpp == 24) width = 3 * s->img_x;
+      else if (info.bpp == 16) width = 2*s->img_x;
+      else /* bpp = 32 and pad = 0 */ width=0;
+      pad = (-width) & 3;
+      if (info.bpp == 24) {
+         easy = 1;
+      } else if (info.bpp == 32) {
+         if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000)
+            easy = 2;
+      }
+      if (!easy) {
+         if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); }
+         // right shift amt to put high bit in position #7
+         rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr);
+         gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg);
+         bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb);
+         ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma);
+      }
+      for (j=0; j < (int) s->img_y; ++j) {
+         if (easy) {
+            for (i=0; i < (int) s->img_x; ++i) {
+               unsigned char a;
+               out[z+2] = stbi__get8(s);
+               out[z+1] = stbi__get8(s);
+               out[z+0] = stbi__get8(s);
+               z += 3;
+               a = (easy == 2 ? stbi__get8(s) : 255);
+               all_a |= a;
+               if (target == 4) out[z++] = a;
+            }
+         } else {
+            int bpp = info.bpp;
+            for (i=0; i < (int) s->img_x; ++i) {
+               stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s));
+               unsigned int a;
+               out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount));
+               out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount));
+               out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount));
+               a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255);
+               all_a |= a;
+               if (target == 4) out[z++] = STBI__BYTECAST(a);
+            }
+         }
+         stbi__skip(s, pad);
+      }
+   }
+
+   // if alpha channel is all 0s, replace with all 255s
+   if (target == 4 && all_a == 0)
+      for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4)
+         out[i] = 255;
+
+   if (flip_vertically) {
+      stbi_uc t;
+      for (j=0; j < (int) s->img_y>>1; ++j) {
+         stbi_uc *p1 = out +      j     *s->img_x*target;
+         stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target;
+         for (i=0; i < (int) s->img_x*target; ++i) {
+            t = p1[i]; p1[i] = p2[i]; p2[i] = t;
+         }
+      }
+   }
+
+   if (req_comp && req_comp != target) {
+      out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y);
+      if (out == NULL) return out; // stbi__convert_format frees input on failure
+   }
+
+   *x = s->img_x;
+   *y = s->img_y;
+   if (comp) *comp = s->img_n;
+   return out;
+}
+#endif
+
+// Targa Truevision - TGA
+// by Jonathan Dummer
+#ifndef STBI_NO_TGA
+// returns STBI_rgb or whatever, 0 on error
+static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16)
+{
+   // only RGB or RGBA (incl. 16bit) or grey allowed
+   if (is_rgb16) *is_rgb16 = 0;
+   switch(bits_per_pixel) {
+      case 8:  return STBI_grey;
+      case 16: if(is_grey) return STBI_grey_alpha;
+               // fallthrough
+      case 15: if(is_rgb16) *is_rgb16 = 1;
+               return STBI_rgb;
+      case 24: // fallthrough
+      case 32: return bits_per_pixel/8;
+      default: return 0;
+   }
+}
+
+static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp)
+{
+    int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp;
+    int sz, tga_colormap_type;
+    stbi__get8(s);                   // discard Offset
+    tga_colormap_type = stbi__get8(s); // colormap type
+    if( tga_colormap_type > 1 ) {
+        stbi__rewind(s);
+        return 0;      // only RGB or indexed allowed
+    }
+    tga_image_type = stbi__get8(s); // image type
+    if ( tga_colormap_type == 1 ) { // colormapped (paletted) image
+        if (tga_image_type != 1 && tga_image_type != 9) {
+            stbi__rewind(s);
+            return 0;
+        }
+        stbi__skip(s,4);       // skip index of first colormap entry and number of entries
+        sz = stbi__get8(s);    //   check bits per palette color entry
+        if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) {
+            stbi__rewind(s);
+            return 0;
+        }
+        stbi__skip(s,4);       // skip image x and y origin
+        tga_colormap_bpp = sz;
+    } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE
+        if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) {
+            stbi__rewind(s);
+            return 0; // only RGB or grey allowed, +/- RLE
+        }
+        stbi__skip(s,9); // skip colormap specification and image x/y origin
+        tga_colormap_bpp = 0;
+    }
+    tga_w = stbi__get16le(s);
+    if( tga_w < 1 ) {
+        stbi__rewind(s);
+        return 0;   // test width
+    }
+    tga_h = stbi__get16le(s);
+    if( tga_h < 1 ) {
+        stbi__rewind(s);
+        return 0;   // test height
+    }
+    tga_bits_per_pixel = stbi__get8(s); // bits per pixel
+    stbi__get8(s); // ignore alpha bits
+    if (tga_colormap_bpp != 0) {
+        if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) {
+            // when using a colormap, tga_bits_per_pixel is the size of the indexes
+            // I don't think anything but 8 or 16bit indexes makes sense
+            stbi__rewind(s);
+            return 0;
+        }
+        tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL);
+    } else {
+        tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL);
+    }
+    if(!tga_comp) {
+      stbi__rewind(s);
+      return 0;
+    }
+    if (x) *x = tga_w;
+    if (y) *y = tga_h;
+    if (comp) *comp = tga_comp;
+    return 1;                   // seems to have passed everything
+}
+
+static int stbi__tga_test(stbi__context *s)
+{
+   int res = 0;
+   int sz, tga_color_type;
+   stbi__get8(s);      //   discard Offset
+   tga_color_type = stbi__get8(s);   //   color type
+   if ( tga_color_type > 1 ) goto errorEnd;   //   only RGB or indexed allowed
+   sz = stbi__get8(s);   //   image type
+   if ( tga_color_type == 1 ) { // colormapped (paletted) image
+      if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9
+      stbi__skip(s,4);       // skip index of first colormap entry and number of entries
+      sz = stbi__get8(s);    //   check bits per palette color entry
+      if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd;
+      stbi__skip(s,4);       // skip image x and y origin
+   } else { // "normal" image w/o colormap
+      if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE
+      stbi__skip(s,9); // skip colormap specification and image x/y origin
+   }
+   if ( stbi__get16le(s) < 1 ) goto errorEnd;      //   test width
+   if ( stbi__get16le(s) < 1 ) goto errorEnd;      //   test height
+   sz = stbi__get8(s);   //   bits per pixel
+   if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index
+   if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd;
+
+   res = 1; // if we got this far, everything's good and we can return 1 instead of 0
+
+errorEnd:
+   stbi__rewind(s);
+   return res;
+}
+
+// read 16bit value and convert to 24bit RGB
+static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out)
+{
+   stbi__uint16 px = (stbi__uint16)stbi__get16le(s);
+   stbi__uint16 fiveBitMask = 31;
+   // we have 3 channels with 5bits each
+   int r = (px >> 10) & fiveBitMask;
+   int g = (px >> 5) & fiveBitMask;
+   int b = px & fiveBitMask;
+   // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later
+   out[0] = (stbi_uc)((r * 255)/31);
+   out[1] = (stbi_uc)((g * 255)/31);
+   out[2] = (stbi_uc)((b * 255)/31);
+
+   // some people claim that the most significant bit might be used for alpha
+   // (possibly if an alpha-bit is set in the "image descriptor byte")
+   // but that only made 16bit test images completely translucent..
+   // so let's treat all 15 and 16bit TGAs as RGB with no alpha.
+}
+
+static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   //   read in the TGA header stuff
+   int tga_offset = stbi__get8(s);
+   int tga_indexed = stbi__get8(s);
+   int tga_image_type = stbi__get8(s);
+   int tga_is_RLE = 0;
+   int tga_palette_start = stbi__get16le(s);
+   int tga_palette_len = stbi__get16le(s);
+   int tga_palette_bits = stbi__get8(s);
+   int tga_x_origin = stbi__get16le(s);
+   int tga_y_origin = stbi__get16le(s);
+   int tga_width = stbi__get16le(s);
+   int tga_height = stbi__get16le(s);
+   int tga_bits_per_pixel = stbi__get8(s);
+   int tga_comp, tga_rgb16=0;
+   int tga_inverted = stbi__get8(s);
+   // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?)
+   //   image data
+   unsigned char *tga_data;
+   unsigned char *tga_palette = NULL;
+   int i, j;
+   unsigned char raw_data[4] = {0};
+   int RLE_count = 0;
+   int RLE_repeating = 0;
+   int read_next_pixel = 1;
+   STBI_NOTUSED(ri);
+
+   //   do a tiny bit of precessing
+   if ( tga_image_type >= 8 )
+   {
+      tga_image_type -= 8;
+      tga_is_RLE = 1;
+   }
+   tga_inverted = 1 - ((tga_inverted >> 5) & 1);
+
+   //   If I'm paletted, then I'll use the number of bits from the palette
+   if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16);
+   else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16);
+
+   if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency
+      return stbi__errpuc("bad format", "Can't find out TGA pixelformat");
+
+   //   tga info
+   *x = tga_width;
+   *y = tga_height;
+   if (comp) *comp = tga_comp;
+
+   if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0))
+      return stbi__errpuc("too large", "Corrupt TGA");
+
+   tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0);
+   if (!tga_data) return stbi__errpuc("outofmem", "Out of memory");
+
+   // skip to the data's starting position (offset usually = 0)
+   stbi__skip(s, tga_offset );
+
+   if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) {
+      for (i=0; i < tga_height; ++i) {
+         int row = tga_inverted ? tga_height -i - 1 : i;
+         stbi_uc *tga_row = tga_data + row*tga_width*tga_comp;
+         stbi__getn(s, tga_row, tga_width * tga_comp);
+      }
+   } else  {
+      //   do I need to load a palette?
+      if ( tga_indexed)
+      {
+         //   any data to skip? (offset usually = 0)
+         stbi__skip(s, tga_palette_start );
+         //   load the palette
+         tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0);
+         if (!tga_palette) {
+            STBI_FREE(tga_data);
+            return stbi__errpuc("outofmem", "Out of memory");
+         }
+         if (tga_rgb16) {
+            stbi_uc *pal_entry = tga_palette;
+            STBI_ASSERT(tga_comp == STBI_rgb);
+            for (i=0; i < tga_palette_len; ++i) {
+               stbi__tga_read_rgb16(s, pal_entry);
+               pal_entry += tga_comp;
+            }
+         } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) {
+               STBI_FREE(tga_data);
+               STBI_FREE(tga_palette);
+               return stbi__errpuc("bad palette", "Corrupt TGA");
+         }
+      }
+      //   load the data
+      for (i=0; i < tga_width * tga_height; ++i)
+      {
+         //   if I'm in RLE mode, do I need to get a RLE stbi__pngchunk?
+         if ( tga_is_RLE )
+         {
+            if ( RLE_count == 0 )
+            {
+               //   yep, get the next byte as a RLE command
+               int RLE_cmd = stbi__get8(s);
+               RLE_count = 1 + (RLE_cmd & 127);
+               RLE_repeating = RLE_cmd >> 7;
+               read_next_pixel = 1;
+            } else if ( !RLE_repeating )
+            {
+               read_next_pixel = 1;
+            }
+         } else
+         {
+            read_next_pixel = 1;
+         }
+         //   OK, if I need to read a pixel, do it now
+         if ( read_next_pixel )
+         {
+            //   load however much data we did have
+            if ( tga_indexed )
+            {
+               // read in index, then perform the lookup
+               int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s);
+               if ( pal_idx >= tga_palette_len ) {
+                  // invalid index
+                  pal_idx = 0;
+               }
+               pal_idx *= tga_comp;
+               for (j = 0; j < tga_comp; ++j) {
+                  raw_data[j] = tga_palette[pal_idx+j];
+               }
+            } else if(tga_rgb16) {
+               STBI_ASSERT(tga_comp == STBI_rgb);
+               stbi__tga_read_rgb16(s, raw_data);
+            } else {
+               //   read in the data raw
+               for (j = 0; j < tga_comp; ++j) {
+                  raw_data[j] = stbi__get8(s);
+               }
+            }
+            //   clear the reading flag for the next pixel
+            read_next_pixel = 0;
+         } // end of reading a pixel
+
+         // copy data
+         for (j = 0; j < tga_comp; ++j)
+           tga_data[i*tga_comp+j] = raw_data[j];
+
+         //   in case we're in RLE mode, keep counting down
+         --RLE_count;
+      }
+      //   do I need to invert the image?
+      if ( tga_inverted )
+      {
+         for (j = 0; j*2 < tga_height; ++j)
+         {
+            int index1 = j * tga_width * tga_comp;
+            int index2 = (tga_height - 1 - j) * tga_width * tga_comp;
+            for (i = tga_width * tga_comp; i > 0; --i)
+            {
+               unsigned char temp = tga_data[index1];
+               tga_data[index1] = tga_data[index2];
+               tga_data[index2] = temp;
+               ++index1;
+               ++index2;
+            }
+         }
+      }
+      //   clear my palette, if I had one
+      if ( tga_palette != NULL )
+      {
+         STBI_FREE( tga_palette );
+      }
+   }
+
+   // swap RGB - if the source data was RGB16, it already is in the right order
+   if (tga_comp >= 3 && !tga_rgb16)
+   {
+      unsigned char* tga_pixel = tga_data;
+      for (i=0; i < tga_width * tga_height; ++i)
+      {
+         unsigned char temp = tga_pixel[0];
+         tga_pixel[0] = tga_pixel[2];
+         tga_pixel[2] = temp;
+         tga_pixel += tga_comp;
+      }
+   }
+
+   // convert to target component count
+   if (req_comp && req_comp != tga_comp)
+      tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height);
+
+   //   the things I do to get rid of an error message, and yet keep
+   //   Microsoft's C compilers happy... [8^(
+   tga_palette_start = tga_palette_len = tga_palette_bits =
+         tga_x_origin = tga_y_origin = 0;
+   //   OK, done
+   return tga_data;
+}
+#endif
+
+// *************************************************************************************************
+// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB
+
+#ifndef STBI_NO_PSD
+static int stbi__psd_test(stbi__context *s)
+{
+   int r = (stbi__get32be(s) == 0x38425053);
+   stbi__rewind(s);
+   return r;
+}
+
+static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount)
+{
+   int count, nleft, len;
+
+   count = 0;
+   while ((nleft = pixelCount - count) > 0) {
+      len = stbi__get8(s);
+      if (len == 128) {
+         // No-op.
+      } else if (len < 128) {
+         // Copy next len+1 bytes literally.
+         len++;
+         if (len > nleft) return 0; // corrupt data
+         count += len;
+         while (len) {
+            *p = stbi__get8(s);
+            p += 4;
+            len--;
+         }
+      } else if (len > 128) {
+         stbi_uc   val;
+         // Next -len+1 bytes in the dest are replicated from next source byte.
+         // (Interpret len as a negative 8-bit int.)
+         len = 257 - len;
+         if (len > nleft) return 0; // corrupt data
+         val = stbi__get8(s);
+         count += len;
+         while (len) {
+            *p = val;
+            p += 4;
+            len--;
+         }
+      }
+   }
+
+   return 1;
+}
+
+static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)
+{
+   int pixelCount;
+   int channelCount, compression;
+   int channel, i;
+   int bitdepth;
+   int w,h;
+   stbi_uc *out;
+   STBI_NOTUSED(ri);
+
+   // Check identifier
+   if (stbi__get32be(s) != 0x38425053)   // "8BPS"
+      return stbi__errpuc("not PSD", "Corrupt PSD image");
+
+   // Check file type version.
+   if (stbi__get16be(s) != 1)
+      return stbi__errpuc("wrong version", "Unsupported version of PSD image");
+
+   // Skip 6 reserved bytes.
+   stbi__skip(s, 6 );
+
+   // Read the number of channels (R, G, B, A, etc).
+   channelCount = stbi__get16be(s);
+   if (channelCount < 0 || channelCount > 16)
+      return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image");
+
+   // Read the rows and columns of the image.
+   h = stbi__get32be(s);
+   w = stbi__get32be(s);
+
+   // Make sure the depth is 8 bits.
+   bitdepth = stbi__get16be(s);
+   if (bitdepth != 8 && bitdepth != 16)
+      return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit");
+
+   // Make sure the color mode is RGB.
+   // Valid options are:
+   //   0: Bitmap
+   //   1: Grayscale
+   //   2: Indexed color
+   //   3: RGB color
+   //   4: CMYK color
+   //   7: Multichannel
+   //   8: Duotone
+   //   9: Lab color
+   if (stbi__get16be(s) != 3)
+      return stbi__errpuc("wrong color format", "PSD is not in RGB color format");
+
+   // Skip the Mode Data.  (It's the palette for indexed color; other info for other modes.)
+   stbi__skip(s,stbi__get32be(s) );
+
+   // Skip the image resources.  (resolution, pen tool paths, etc)
+   stbi__skip(s, stbi__get32be(s) );
+
+   // Skip the reserved data.
+   stbi__skip(s, stbi__get32be(s) );
+
+   // Find out if the data is compressed.
+   // Known values:
+   //   0: no compression
+   //   1: RLE compressed
+   compression = stbi__get16be(s);
+   if (compression > 1)
+      return stbi__errpuc("bad compression", "PSD has an unknown compression format");
+
+   // Check size
+   if (!stbi__mad3sizes_valid(4, w, h, 0))
+      return stbi__errpuc("too large", "Corrupt PSD");
+
+   // Create the destination image.
+
+   if (!compression && bitdepth == 16 && bpc == 16) {
+      out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0);
+      ri->bits_per_channel = 16;
+   } else
+      out = (stbi_uc *) stbi__malloc(4 * w*h);
+
+   if (!out) return stbi__errpuc("outofmem", "Out of memory");
+   pixelCount = w*h;
+
+   // Initialize the data to zero.
+   //memset( out, 0, pixelCount * 4 );
+
+   // Finally, the image data.
+   if (compression) {
+      // RLE as used by .PSD and .TIFF
+      // Loop until you get the number of unpacked bytes you are expecting:
+      //     Read the next source byte into n.
+      //     If n is between 0 and 127 inclusive, copy the next n+1 bytes literally.
+      //     Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times.
+      //     Else if n is 128, noop.
+      // Endloop
+
+      // The RLE-compressed data is preceded by a 2-byte data count for each row in the data,
+      // which we're going to just skip.
+      stbi__skip(s, h * channelCount * 2 );
+
+      // Read the RLE data by channel.
+      for (channel = 0; channel < 4; channel++) {
+         stbi_uc *p;
+
+         p = out+channel;
+         if (channel >= channelCount) {
+            // Fill this channel with default data.
+            for (i = 0; i < pixelCount; i++, p += 4)
+               *p = (channel == 3 ? 255 : 0);
+         } else {
+            // Read the RLE data.
+            if (!stbi__psd_decode_rle(s, p, pixelCount)) {
+               STBI_FREE(out);
+               return stbi__errpuc("corrupt", "bad RLE data");
+            }
+         }
+      }
+
+   } else {
+      // We're at the raw image data.  It's each channel in order (Red, Green, Blue, Alpha, ...)
+      // where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image.
+
+      // Read the data by channel.
+      for (channel = 0; channel < 4; channel++) {
+         if (channel >= channelCount) {
+            // Fill this channel with default data.
+            if (bitdepth == 16 && bpc == 16) {
+               stbi__uint16 *q = ((stbi__uint16 *) out) + channel;
+               stbi__uint16 val = channel == 3 ? 65535 : 0;
+               for (i = 0; i < pixelCount; i++, q += 4)
+                  *q = val;
+            } else {
+               stbi_uc *p = out+channel;
+               stbi_uc val = channel == 3 ? 255 : 0;
+               for (i = 0; i < pixelCount; i++, p += 4)
+                  *p = val;
+            }
+         } else {
+            if (ri->bits_per_channel == 16) {    // output bpc
+               stbi__uint16 *q = ((stbi__uint16 *) out) + channel;
+               for (i = 0; i < pixelCount; i++, q += 4)
+                  *q = (stbi__uint16) stbi__get16be(s);
+            } else {
+               stbi_uc *p = out+channel;
+               if (bitdepth == 16) {  // input bpc
+                  for (i = 0; i < pixelCount; i++, p += 4)
+                     *p = (stbi_uc) (stbi__get16be(s) >> 8);
+               } else {
+                  for (i = 0; i < pixelCount; i++, p += 4)
+                     *p = stbi__get8(s);
+               }
+            }
+         }
+      }
+   }
+
+   // remove weird white matte from PSD
+   if (channelCount >= 4) {
+      if (ri->bits_per_channel == 16) {
+         for (i=0; i < w*h; ++i) {
+            stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i;
+            if (pixel[3] != 0 && pixel[3] != 65535) {
+               float a = pixel[3] / 65535.0f;
+               float ra = 1.0f / a;
+               float inv_a = 65535.0f * (1 - ra);
+               pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a);
+               pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a);
+               pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a);
+            }
+         }
+      } else {
+         for (i=0; i < w*h; ++i) {
+            unsigned char *pixel = out + 4*i;
+            if (pixel[3] != 0 && pixel[3] != 255) {
+               float a = pixel[3] / 255.0f;
+               float ra = 1.0f / a;
+               float inv_a = 255.0f * (1 - ra);
+               pixel[0] = (unsigned char) (pixel[0]*ra + inv_a);
+               pixel[1] = (unsigned char) (pixel[1]*ra + inv_a);
+               pixel[2] = (unsigned char) (pixel[2]*ra + inv_a);
+            }
+         }
+      }
+   }
+
+   // convert to desired output format
+   if (req_comp && req_comp != 4) {
+      if (ri->bits_per_channel == 16)
+         out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h);
+      else
+         out = stbi__convert_format(out, 4, req_comp, w, h);
+      if (out == NULL) return out; // stbi__convert_format frees input on failure
+   }
+
+   if (comp) *comp = 4;
+   *y = h;
+   *x = w;
+
+   return out;
+}
+#endif
+
+// *************************************************************************************************
+// Softimage PIC loader
+// by Tom Seddon
+//
+// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format
+// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/
+
+#ifndef STBI_NO_PIC
+static int stbi__pic_is4(stbi__context *s,const char *str)
+{
+   int i;
+   for (i=0; i<4; ++i)
+      if (stbi__get8(s) != (stbi_uc)str[i])
+         return 0;
+
+   return 1;
+}
+
+static int stbi__pic_test_core(stbi__context *s)
+{
+   int i;
+
+   if (!stbi__pic_is4(s,"\x53\x80\xF6\x34"))
+      return 0;
+
+   for(i=0;i<84;++i)
+      stbi__get8(s);
+
+   if (!stbi__pic_is4(s,"PICT"))
+      return 0;
+
+   return 1;
+}
+
+typedef struct
+{
+   stbi_uc size,type,channel;
+} stbi__pic_packet;
+
+static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest)
+{
+   int mask=0x80, i;
+
+   for (i=0; i<4; ++i, mask>>=1) {
+      if (channel & mask) {
+         if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short");
+         dest[i]=stbi__get8(s);
+      }
+   }
+
+   return dest;
+}
+
+static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src)
+{
+   int mask=0x80,i;
+
+   for (i=0;i<4; ++i, mask>>=1)
+      if (channel&mask)
+         dest[i]=src[i];
+}
+
+static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result)
+{
+   int act_comp=0,num_packets=0,y,chained;
+   stbi__pic_packet packets[10];
+
+   // this will (should...) cater for even some bizarre stuff like having data
+    // for the same channel in multiple packets.
+   do {
+      stbi__pic_packet *packet;
+
+      if (num_packets==sizeof(packets)/sizeof(packets[0]))
+         return stbi__errpuc("bad format","too many packets");
+
+      packet = &packets[num_packets++];
+
+      chained = stbi__get8(s);
+      packet->size    = stbi__get8(s);
+      packet->type    = stbi__get8(s);
+      packet->channel = stbi__get8(s);
+
+      act_comp |= packet->channel;
+
+      if (stbi__at_eof(s))          return stbi__errpuc("bad file","file too short (reading packets)");
+      if (packet->size != 8)  return stbi__errpuc("bad format","packet isn't 8bpp");
+   } while (chained);
+
+   *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel?
+
+   for(y=0; y<height; ++y) {
+      int packet_idx;
+
+      for(packet_idx=0; packet_idx < num_packets; ++packet_idx) {
+         stbi__pic_packet *packet = &packets[packet_idx];
+         stbi_uc *dest = result+y*width*4;
+
+         switch (packet->type) {
+            default:
+               return stbi__errpuc("bad format","packet has bad compression type");
+
+            case 0: {//uncompressed
+               int x;
+
+               for(x=0;x<width;++x, dest+=4)
+                  if (!stbi__readval(s,packet->channel,dest))
+                     return 0;
+               break;
+            }
+
+            case 1://Pure RLE
+               {
+                  int left=width, i;
+
+                  while (left>0) {
+                     stbi_uc count,value[4];
+
+                     count=stbi__get8(s);
+                     if (stbi__at_eof(s))   return stbi__errpuc("bad file","file too short (pure read count)");
+
+                     if (count > left)
+                        count = (stbi_uc) left;
+
+                     if (!stbi__readval(s,packet->channel,value))  return 0;
+
+                     for(i=0; i<count; ++i,dest+=4)
+                        stbi__copyval(packet->channel,dest,value);
+                     left -= count;
+                  }
+               }
+               break;
+
+            case 2: {//Mixed RLE
+               int left=width;
+               while (left>0) {
+                  int count = stbi__get8(s), i;
+                  if (stbi__at_eof(s))  return stbi__errpuc("bad file","file too short (mixed read count)");
+
+                  if (count >= 128) { // Repeated
+                     stbi_uc value[4];
+
+                     if (count==128)
+                        count = stbi__get16be(s);
+                     else
+                        count -= 127;
+                     if (count > left)
+                        return stbi__errpuc("bad file","scanline overrun");
+
+                     if (!stbi__readval(s,packet->channel,value))
+                        return 0;
+
+                     for(i=0;i<count;++i, dest += 4)
+                        stbi__copyval(packet->channel,dest,value);
+                  } else { // Raw
+                     ++count;
+                     if (count>left) return stbi__errpuc("bad file","scanline overrun");
+
+                     for(i=0;i<count;++i, dest+=4)
+                        if (!stbi__readval(s,packet->channel,dest))
+                           return 0;
+                  }
+                  left-=count;
+               }
+               break;
+            }
+         }
+      }
+   }
+
+   return result;
+}
+
+static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri)
+{
+   stbi_uc *result;
+   int i, x,y, internal_comp;
+   STBI_NOTUSED(ri);
+
+   if (!comp) comp = &internal_comp;
+
+   for (i=0; i<92; ++i)
+      stbi__get8(s);
+
+   x = stbi__get16be(s);
+   y = stbi__get16be(s);
+   if (stbi__at_eof(s))  return stbi__errpuc("bad file","file too short (pic header)");
+   if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode");
+
+   stbi__get32be(s); //skip `ratio'
+   stbi__get16be(s); //skip `fields'
+   stbi__get16be(s); //skip `pad'
+
+   // intermediate buffer is RGBA
+   result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0);
+   memset(result, 0xff, x*y*4);
+
+   if (!stbi__pic_load_core(s,x,y,comp, result)) {
+      STBI_FREE(result);
+      result=0;
+   }
+   *px = x;
+   *py = y;
+   if (req_comp == 0) req_comp = *comp;
+   result=stbi__convert_format(result,4,req_comp,x,y);
+
+   return result;
+}
+
+static int stbi__pic_test(stbi__context *s)
+{
+   int r = stbi__pic_test_core(s);
+   stbi__rewind(s);
+   return r;
+}
+#endif
+
+// *************************************************************************************************
+// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb
+
+#ifndef STBI_NO_GIF
+typedef struct
+{
+   stbi__int16 prefix;
+   stbi_uc first;
+   stbi_uc suffix;
+} stbi__gif_lzw;
+
+typedef struct
+{
+   int w,h;
+   stbi_uc *out;                 // output buffer (always 4 components)
+   stbi_uc *background;          // The current "background" as far as a gif is concerned
+   stbi_uc *history; 
+   int flags, bgindex, ratio, transparent, eflags;
+   stbi_uc  pal[256][4];
+   stbi_uc lpal[256][4];
+   stbi__gif_lzw codes[8192];
+   stbi_uc *color_table;
+   int parse, step;
+   int lflags;
+   int start_x, start_y;
+   int max_x, max_y;
+   int cur_x, cur_y;
+   int line_size;
+   int delay;
+} stbi__gif;
+
+static int stbi__gif_test_raw(stbi__context *s)
+{
+   int sz;
+   if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0;
+   sz = stbi__get8(s);
+   if (sz != '9' && sz != '7') return 0;
+   if (stbi__get8(s) != 'a') return 0;
+   return 1;
+}
+
+static int stbi__gif_test(stbi__context *s)
+{
+   int r = stbi__gif_test_raw(s);
+   stbi__rewind(s);
+   return r;
+}
+
+static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp)
+{
+   int i;
+   for (i=0; i < num_entries; ++i) {
+      pal[i][2] = stbi__get8(s);
+      pal[i][1] = stbi__get8(s);
+      pal[i][0] = stbi__get8(s);
+      pal[i][3] = transp == i ? 0 : 255;
+   }
+}
+
+static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info)
+{
+   stbi_uc version;
+   if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8')
+      return stbi__err("not GIF", "Corrupt GIF");
+
+   version = stbi__get8(s);
+   if (version != '7' && version != '9')    return stbi__err("not GIF", "Corrupt GIF");
+   if (stbi__get8(s) != 'a')                return stbi__err("not GIF", "Corrupt GIF");
+
+   stbi__g_failure_reason = "";
+   g->w = stbi__get16le(s);
+   g->h = stbi__get16le(s);
+   g->flags = stbi__get8(s);
+   g->bgindex = stbi__get8(s);
+   g->ratio = stbi__get8(s);
+   g->transparent = -1;
+
+   if (comp != 0) *comp = 4;  // can't actually tell whether it's 3 or 4 until we parse the comments
+
+   if (is_info) return 1;
+
+   if (g->flags & 0x80)
+      stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1);
+
+   return 1;
+}
+
+static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp)
+{
+   stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif));
+   if (!stbi__gif_header(s, g, comp, 1)) {
+      STBI_FREE(g);
+      stbi__rewind( s );
+      return 0;
+   }
+   if (x) *x = g->w;
+   if (y) *y = g->h;
+   STBI_FREE(g);
+   return 1;
+}
+
+static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)
+{
+   stbi_uc *p, *c;
+   int idx; 
+
+   // recurse to decode the prefixes, since the linked-list is backwards,
+   // and working backwards through an interleaved image would be nasty
+   if (g->codes[code].prefix >= 0)
+      stbi__out_gif_code(g, g->codes[code].prefix);
+
+   if (g->cur_y >= g->max_y) return;
+
+   idx = g->cur_x + g->cur_y; 
+   p = &g->out[idx];
+   g->history[idx / 4] = 1;  
+
+   c = &g->color_table[g->codes[code].suffix * 4];
+   if (c[3] > 128) { // don't render transparent pixels; 
+      p[0] = c[2];
+      p[1] = c[1];
+      p[2] = c[0];
+      p[3] = c[3];
+   }
+   g->cur_x += 4;
+
+   if (g->cur_x >= g->max_x) {
+      g->cur_x = g->start_x;
+      g->cur_y += g->step;
+
+      while (g->cur_y >= g->max_y && g->parse > 0) {
+         g->step = (1 << g->parse) * g->line_size;
+         g->cur_y = g->start_y + (g->step >> 1);
+         --g->parse;
+      }
+   }
+}
+
+static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g)
+{
+   stbi_uc lzw_cs;
+   stbi__int32 len, init_code;
+   stbi__uint32 first;
+   stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear;
+   stbi__gif_lzw *p;
+
+   lzw_cs = stbi__get8(s);
+   if (lzw_cs > 12) return NULL;
+   clear = 1 << lzw_cs;
+   first = 1;
+   codesize = lzw_cs + 1;
+   codemask = (1 << codesize) - 1;
+   bits = 0;
+   valid_bits = 0;
+   for (init_code = 0; init_code < clear; init_code++) {
+      g->codes[init_code].prefix = -1;
+      g->codes[init_code].first = (stbi_uc) init_code;
+      g->codes[init_code].suffix = (stbi_uc) init_code;
+   }
+
+   // support no starting clear code
+   avail = clear+2;
+   oldcode = -1;
+
+   len = 0;
+   for(;;) {
+      if (valid_bits < codesize) {
+         if (len == 0) {
+            len = stbi__get8(s); // start new block
+            if (len == 0)
+               return g->out;
+         }
+         --len;
+         bits |= (stbi__int32) stbi__get8(s) << valid_bits;
+         valid_bits += 8;
+      } else {
+         stbi__int32 code = bits & codemask;
+         bits >>= codesize;
+         valid_bits -= codesize;
+         // @OPTIMIZE: is there some way we can accelerate the non-clear path?
+         if (code == clear) {  // clear code
+            codesize = lzw_cs + 1;
+            codemask = (1 << codesize) - 1;
+            avail = clear + 2;
+            oldcode = -1;
+            first = 0;
+         } else if (code == clear + 1) { // end of stream code
+            stbi__skip(s, len);
+            while ((len = stbi__get8(s)) > 0)
+               stbi__skip(s,len);
+            return g->out;
+         } else if (code <= avail) {
+            if (first) {
+               return stbi__errpuc("no clear code", "Corrupt GIF");
+            }
+
+            if (oldcode >= 0) {
+               p = &g->codes[avail++];
+               if (avail > 8192) {
+                  return stbi__errpuc("too many codes", "Corrupt GIF");
+               }
+
+               p->prefix = (stbi__int16) oldcode;
+               p->first = g->codes[oldcode].first;
+               p->suffix = (code == avail) ? p->first : g->codes[code].first;
+            } else if (code == avail)
+               return stbi__errpuc("illegal code in raster", "Corrupt GIF");
+
+            stbi__out_gif_code(g, (stbi__uint16) code);
+
+            if ((avail & codemask) == 0 && avail <= 0x0FFF) {
+               codesize++;
+               codemask = (1 << codesize) - 1;
+            }
+
+            oldcode = code;
+         } else {
+            return stbi__errpuc("illegal code in raster", "Corrupt GIF");
+         }
+      }
+   }
+}
+
+// this function is designed to support animated gifs, although stb_image doesn't support it
+// two back is the image from two frames ago, used for a very specific disposal format
+static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back)
+{
+   int dispose; 
+   int first_frame; 
+   int pi; 
+   int pcount; 
+   STBI_NOTUSED(req_comp);
+
+   // on first frame, any non-written pixels get the background colour (non-transparent)
+   first_frame = 0; 
+   if (g->out == 0) {
+      if (!stbi__gif_header(s, g, comp,0))     return 0; // stbi__g_failure_reason set by stbi__gif_header
+      g->out = (stbi_uc *) stbi__malloc(4 * g->w * g->h);
+      g->background = (stbi_uc *) stbi__malloc(4 * g->w * g->h); 
+      g->history = (stbi_uc *) stbi__malloc(g->w * g->h); 
+      if (g->out == 0)                      return stbi__errpuc("outofmem", "Out of memory");
+
+      // image is treated as "transparent" at the start - ie, nothing overwrites the current background; 
+      // background colour is only used for pixels that are not rendered first frame, after that "background"
+      // color refers to the color that was there the previous frame. 
+      memset( g->out, 0x00, 4 * g->w * g->h ); 
+      memset( g->background, 0x00, 4 * g->w * g->h ); // state of the background (starts transparent)
+      memset( g->history, 0x00, g->w * g->h );        // pixels that were affected previous frame
+      first_frame = 1; 
+   } else {
+      // second frame - how do we dispoase of the previous one?
+      dispose = (g->eflags & 0x1C) >> 2; 
+      pcount = g->w * g->h; 
+
+      if ((dispose == 3) && (two_back == 0)) {
+         dispose = 2; // if I don't have an image to revert back to, default to the old background
+      }
+
+      if (dispose == 3) { // use previous graphic
+         for (pi = 0; pi < pcount; ++pi) {
+            if (g->history[pi]) {
+               memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 ); 
+            }
+         }
+      } else if (dispose == 2) { 
+         // restore what was changed last frame to background before that frame; 
+         for (pi = 0; pi < pcount; ++pi) {
+            if (g->history[pi]) {
+               memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 ); 
+            }
+         }
+      } else {
+         // This is a non-disposal case eithe way, so just 
+         // leave the pixels as is, and they will become the new background
+         // 1: do not dispose
+         // 0:  not specified.
+      }
+
+      // background is what out is after the undoing of the previou frame; 
+      memcpy( g->background, g->out, 4 * g->w * g->h ); 
+   }
+
+   // clear my history; 
+   memset( g->history, 0x00, g->w * g->h );        // pixels that were affected previous frame
+
+   for (;;) {
+      int tag = stbi__get8(s); 
+      switch (tag) {
+         case 0x2C: /* Image Descriptor */
+         {
+            stbi__int32 x, y, w, h;
+            stbi_uc *o;
+
+            x = stbi__get16le(s);
+            y = stbi__get16le(s);
+            w = stbi__get16le(s);
+            h = stbi__get16le(s);
+            if (((x + w) > (g->w)) || ((y + h) > (g->h)))
+               return stbi__errpuc("bad Image Descriptor", "Corrupt GIF");
+
+            g->line_size = g->w * 4;
+            g->start_x = x * 4;
+            g->start_y = y * g->line_size;
+            g->max_x   = g->start_x + w * 4;
+            g->max_y   = g->start_y + h * g->line_size;
+            g->cur_x   = g->start_x;
+            g->cur_y   = g->start_y;
+
+            g->lflags = stbi__get8(s);
+
+            if (g->lflags & 0x40) {
+               g->step = 8 * g->line_size; // first interlaced spacing
+               g->parse = 3;
+            } else {
+               g->step = g->line_size;
+               g->parse = 0;
+            }
+
+            if (g->lflags & 0x80) {
+               stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1);
+               g->color_table = (stbi_uc *) g->lpal;
+            } else if (g->flags & 0x80) {
+               g->color_table = (stbi_uc *) g->pal;
+            } else
+               return stbi__errpuc("missing color table", "Corrupt GIF");            
+            
+            o = stbi__process_gif_raster(s, g);
+            if (o == NULL) return NULL;
+
+            // if this was the first frame, 
+            pcount = g->w * g->h; 
+            if (first_frame && (g->bgindex > 0)) {
+               // if first frame, any pixel not drawn to gets the background color
+               for (pi = 0; pi < pcount; ++pi) {
+                  if (g->history[pi] == 0) {
+                     g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be; 
+                     memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 ); 
+                  }
+               }
+            }
+
+            return o;
+         }
+
+         case 0x21: // Comment Extension.
+         {
+            int len;
+            int ext = stbi__get8(s); 
+            if (ext == 0xF9) { // Graphic Control Extension.
+               len = stbi__get8(s);
+               if (len == 4) {
+                  g->eflags = stbi__get8(s);
+                  g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths.
+
+                  // unset old transparent
+                  if (g->transparent >= 0) {
+                     g->pal[g->transparent][3] = 255; 
+                  } 
+                  if (g->eflags & 0x01) {
+                     g->transparent = stbi__get8(s);
+                     if (g->transparent >= 0) {
+                        g->pal[g->transparent][3] = 0; 
+                     }
+                  } else {
+                     // don't need transparent
+                     stbi__skip(s, 1); 
+                     g->transparent = -1; 
+                  }
+               } else {
+                  stbi__skip(s, len);
+                  break;
+               }
+            } 
+            while ((len = stbi__get8(s)) != 0) {
+               stbi__skip(s, len);
+            }
+            break;
+         }
+
+         case 0x3B: // gif stream termination code
+            return (stbi_uc *) s; // using '1' causes warning on some compilers
+
+         default:
+            return stbi__errpuc("unknown code", "Corrupt GIF");
+      }
+   }
+}
+
+static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp)
+{
+   if (stbi__gif_test(s)) {
+      int layers = 0; 
+      stbi_uc *u = 0;
+      stbi_uc *out = 0;
+      stbi_uc *two_back = 0; 
+      stbi__gif g;
+      int stride; 
+      memset(&g, 0, sizeof(g));
+      if (delays) {
+         *delays = 0; 
+      }
+
+      do {
+         u = stbi__gif_load_next(s, &g, comp, req_comp, two_back);
+         if (u == (stbi_uc *) s) u = 0;  // end of animated gif marker
+
+         if (u) {
+            *x = g.w;
+            *y = g.h;
+            ++layers; 
+            stride = g.w * g.h * 4; 
+         
+            if (out) {
+               out = (stbi_uc*) STBI_REALLOC( out, layers * stride ); 
+               if (delays) {
+                  *delays = (int*) STBI_REALLOC( *delays, sizeof(int) * layers ); 
+               }
+            } else {
+               out = (stbi_uc*)stbi__malloc( layers * stride ); 
+               if (delays) {
+                  *delays = (int*) stbi__malloc( layers * sizeof(int) ); 
+               }
+            }
+            memcpy( out + ((layers - 1) * stride), u, stride ); 
+            if (layers >= 2) {
+               two_back = out - 2 * stride; 
+            }
+
+            if (delays) {
+               (*delays)[layers - 1U] = g.delay; 
+            }
+         }
+      } while (u != 0); 
+
+      // free temp buffer; 
+      STBI_FREE(g.out); 
+      STBI_FREE(g.history); 
+      STBI_FREE(g.background); 
+
+      // do the final conversion after loading everything; 
+      if (req_comp && req_comp != 4)
+         out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h);
+
+      *z = layers; 
+      return out;
+   } else {
+      return stbi__errpuc("not GIF", "Image was not as a gif type."); 
+   }
+}
+
+static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   stbi_uc *u = 0;
+   stbi__gif g;
+   memset(&g, 0, sizeof(g));
+   STBI_NOTUSED(ri);
+
+   u = stbi__gif_load_next(s, &g, comp, req_comp, 0);
+   if (u == (stbi_uc *) s) u = 0;  // end of animated gif marker
+   if (u) {
+      *x = g.w;
+      *y = g.h;
+
+      // moved conversion to after successful load so that the same
+      // can be done for multiple frames. 
+      if (req_comp && req_comp != 4)
+         u = stbi__convert_format(u, 4, req_comp, g.w, g.h);
+   }
+
+   // free buffers needed for multiple frame loading; 
+   STBI_FREE(g.history);
+   STBI_FREE(g.background); 
+
+   return u;
+}
+
+static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   return stbi__gif_info_raw(s,x,y,comp);
+}
+#endif
+
+// *************************************************************************************************
+// Radiance RGBE HDR loader
+// originally by Nicolas Schulz
+#ifndef STBI_NO_HDR
+static int stbi__hdr_test_core(stbi__context *s, const char *signature)
+{
+   int i;
+   for (i=0; signature[i]; ++i)
+      if (stbi__get8(s) != signature[i])
+          return 0;
+   stbi__rewind(s);
+   return 1;
+}
+
+static int stbi__hdr_test(stbi__context* s)
+{
+   int r = stbi__hdr_test_core(s, "#?RADIANCE\n");
+   stbi__rewind(s);
+   if(!r) {
+       r = stbi__hdr_test_core(s, "#?RGBE\n");
+       stbi__rewind(s);
+   }
+   return r;
+}
+
+#define STBI__HDR_BUFLEN  1024
+static char *stbi__hdr_gettoken(stbi__context *z, char *buffer)
+{
+   int len=0;
+   char c = '\0';
+
+   c = (char) stbi__get8(z);
+
+   while (!stbi__at_eof(z) && c != '\n') {
+      buffer[len++] = c;
+      if (len == STBI__HDR_BUFLEN-1) {
+         // flush to end of line
+         while (!stbi__at_eof(z) && stbi__get8(z) != '\n')
+            ;
+         break;
+      }
+      c = (char) stbi__get8(z);
+   }
+
+   buffer[len] = 0;
+   return buffer;
+}
+
+static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp)
+{
+   if ( input[3] != 0 ) {
+      float f1;
+      // Exponent
+      f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8));
+      if (req_comp <= 2)
+         output[0] = (input[0] + input[1] + input[2]) * f1 / 3;
+      else {
+         output[0] = input[0] * f1;
+         output[1] = input[1] * f1;
+         output[2] = input[2] * f1;
+      }
+      if (req_comp == 2) output[1] = 1;
+      if (req_comp == 4) output[3] = 1;
+   } else {
+      switch (req_comp) {
+         case 4: output[3] = 1; /* fallthrough */
+         case 3: output[0] = output[1] = output[2] = 0;
+                 break;
+         case 2: output[1] = 1; /* fallthrough */
+         case 1: output[0] = 0;
+                 break;
+      }
+   }
+}
+
+static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   char buffer[STBI__HDR_BUFLEN];
+   char *token;
+   int valid = 0;
+   int width, height;
+   stbi_uc *scanline;
+   float *hdr_data;
+   int len;
+   unsigned char count, value;
+   int i, j, k, c1,c2, z;
+   const char *headerToken;
+   STBI_NOTUSED(ri);
+
+   // Check identifier
+   headerToken = stbi__hdr_gettoken(s,buffer);
+   if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0)
+      return stbi__errpf("not HDR", "Corrupt HDR image");
+
+   // Parse header
+   for(;;) {
+      token = stbi__hdr_gettoken(s,buffer);
+      if (token[0] == 0) break;
+      if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
+   }
+
+   if (!valid)    return stbi__errpf("unsupported format", "Unsupported HDR format");
+
+   // Parse width and height
+   // can't use sscanf() if we're not using stdio!
+   token = stbi__hdr_gettoken(s,buffer);
+   if (strncmp(token, "-Y ", 3))  return stbi__errpf("unsupported data layout", "Unsupported HDR format");
+   token += 3;
+   height = (int) strtol(token, &token, 10);
+   while (*token == ' ') ++token;
+   if (strncmp(token, "+X ", 3))  return stbi__errpf("unsupported data layout", "Unsupported HDR format");
+   token += 3;
+   width = (int) strtol(token, NULL, 10);
+
+   *x = width;
+   *y = height;
+
+   if (comp) *comp = 3;
+   if (req_comp == 0) req_comp = 3;
+
+   if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0))
+      return stbi__errpf("too large", "HDR image is too large");
+
+   // Read data
+   hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0);
+   if (!hdr_data)
+      return stbi__errpf("outofmem", "Out of memory");
+
+   // Load image data
+   // image data is stored as some number of sca
+   if ( width < 8 || width >= 32768) {
+      // Read flat data
+      for (j=0; j < height; ++j) {
+         for (i=0; i < width; ++i) {
+            stbi_uc rgbe[4];
+           main_decode_loop:
+            stbi__getn(s, rgbe, 4);
+            stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp);
+         }
+      }
+   } else {
+      // Read RLE-encoded data
+      scanline = NULL;
+
+      for (j = 0; j < height; ++j) {
+         c1 = stbi__get8(s);
+         c2 = stbi__get8(s);
+         len = stbi__get8(s);
+         if (c1 != 2 || c2 != 2 || (len & 0x80)) {
+            // not run-length encoded, so we have to actually use THIS data as a decoded
+            // pixel (note this can't be a valid pixel--one of RGB must be >= 128)
+            stbi_uc rgbe[4];
+            rgbe[0] = (stbi_uc) c1;
+            rgbe[1] = (stbi_uc) c2;
+            rgbe[2] = (stbi_uc) len;
+            rgbe[3] = (stbi_uc) stbi__get8(s);
+            stbi__hdr_convert(hdr_data, rgbe, req_comp);
+            i = 1;
+            j = 0;
+            STBI_FREE(scanline);
+            goto main_decode_loop; // yes, this makes no sense
+         }
+         len <<= 8;
+         len |= stbi__get8(s);
+         if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); }
+         if (scanline == NULL) {
+            scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0);
+            if (!scanline) {
+               STBI_FREE(hdr_data);
+               return stbi__errpf("outofmem", "Out of memory");
+            }
+         }
+
+         for (k = 0; k < 4; ++k) {
+            int nleft;
+            i = 0;
+            while ((nleft = width - i) > 0) {
+               count = stbi__get8(s);
+               if (count > 128) {
+                  // Run
+                  value = stbi__get8(s);
+                  count -= 128;
+                  if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); }
+                  for (z = 0; z < count; ++z)
+                     scanline[i++ * 4 + k] = value;
+               } else {
+                  // Dump
+                  if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); }
+                  for (z = 0; z < count; ++z)
+                     scanline[i++ * 4 + k] = stbi__get8(s);
+               }
+            }
+         }
+         for (i=0; i < width; ++i)
+            stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp);
+      }
+      if (scanline)
+         STBI_FREE(scanline);
+   }
+
+   return hdr_data;
+}
+
+static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   char buffer[STBI__HDR_BUFLEN];
+   char *token;
+   int valid = 0;
+   int dummy;
+
+   if (!x) x = &dummy;
+   if (!y) y = &dummy;
+   if (!comp) comp = &dummy;
+
+   if (stbi__hdr_test(s) == 0) {
+       stbi__rewind( s );
+       return 0;
+   }
+
+   for(;;) {
+      token = stbi__hdr_gettoken(s,buffer);
+      if (token[0] == 0) break;
+      if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
+   }
+
+   if (!valid) {
+       stbi__rewind( s );
+       return 0;
+   }
+   token = stbi__hdr_gettoken(s,buffer);
+   if (strncmp(token, "-Y ", 3)) {
+       stbi__rewind( s );
+       return 0;
+   }
+   token += 3;
+   *y = (int) strtol(token, &token, 10);
+   while (*token == ' ') ++token;
+   if (strncmp(token, "+X ", 3)) {
+       stbi__rewind( s );
+       return 0;
+   }
+   token += 3;
+   *x = (int) strtol(token, NULL, 10);
+   *comp = 3;
+   return 1;
+}
+#endif // STBI_NO_HDR
+
+#ifndef STBI_NO_BMP
+static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   void *p;
+   stbi__bmp_data info;
+
+   info.all_a = 255;
+   p = stbi__bmp_parse_header(s, &info);
+   stbi__rewind( s );
+   if (p == NULL)
+      return 0;
+   if (x) *x = s->img_x;
+   if (y) *y = s->img_y;
+   if (comp) *comp = info.ma ? 4 : 3;
+   return 1;
+}
+#endif
+
+#ifndef STBI_NO_PSD
+static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   int channelCount, dummy, depth;
+   if (!x) x = &dummy;
+   if (!y) y = &dummy;
+   if (!comp) comp = &dummy;
+   if (stbi__get32be(s) != 0x38425053) {
+       stbi__rewind( s );
+       return 0;
+   }
+   if (stbi__get16be(s) != 1) {
+       stbi__rewind( s );
+       return 0;
+   }
+   stbi__skip(s, 6);
+   channelCount = stbi__get16be(s);
+   if (channelCount < 0 || channelCount > 16) {
+       stbi__rewind( s );
+       return 0;
+   }
+   *y = stbi__get32be(s);
+   *x = stbi__get32be(s);
+   depth = stbi__get16be(s);
+   if (depth != 8 && depth != 16) {
+       stbi__rewind( s );
+       return 0;
+   }
+   if (stbi__get16be(s) != 3) {
+       stbi__rewind( s );
+       return 0;
+   }
+   *comp = 4;
+   return 1;
+}
+
+static int stbi__psd_is16(stbi__context *s)
+{
+   int channelCount, depth;
+   if (stbi__get32be(s) != 0x38425053) {
+       stbi__rewind( s );
+       return 0;
+   }
+   if (stbi__get16be(s) != 1) {
+       stbi__rewind( s );
+       return 0;
+   }
+   stbi__skip(s, 6);
+   channelCount = stbi__get16be(s);
+   if (channelCount < 0 || channelCount > 16) {
+       stbi__rewind( s );
+       return 0;
+   }
+   (void) stbi__get32be(s);
+   (void) stbi__get32be(s);
+   depth = stbi__get16be(s);
+   if (depth != 16) {
+       stbi__rewind( s );
+       return 0;
+   }
+   return 1;
+}
+#endif
+
+#ifndef STBI_NO_PIC
+static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   int act_comp=0,num_packets=0,chained,dummy;
+   stbi__pic_packet packets[10];
+
+   if (!x) x = &dummy;
+   if (!y) y = &dummy;
+   if (!comp) comp = &dummy;
+
+   if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) {
+      stbi__rewind(s);
+      return 0;
+   }
+
+   stbi__skip(s, 88);
+
+   *x = stbi__get16be(s);
+   *y = stbi__get16be(s);
+   if (stbi__at_eof(s)) {
+      stbi__rewind( s);
+      return 0;
+   }
+   if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) {
+      stbi__rewind( s );
+      return 0;
+   }
+
+   stbi__skip(s, 8);
+
+   do {
+      stbi__pic_packet *packet;
+
+      if (num_packets==sizeof(packets)/sizeof(packets[0]))
+         return 0;
+
+      packet = &packets[num_packets++];
+      chained = stbi__get8(s);
+      packet->size    = stbi__get8(s);
+      packet->type    = stbi__get8(s);
+      packet->channel = stbi__get8(s);
+      act_comp |= packet->channel;
+
+      if (stbi__at_eof(s)) {
+          stbi__rewind( s );
+          return 0;
+      }
+      if (packet->size != 8) {
+          stbi__rewind( s );
+          return 0;
+      }
+   } while (chained);
+
+   *comp = (act_comp & 0x10 ? 4 : 3);
+
+   return 1;
+}
+#endif
+
+// *************************************************************************************************
+// Portable Gray Map and Portable Pixel Map loader
+// by Ken Miller
+//
+// PGM: http://netpbm.sourceforge.net/doc/pgm.html
+// PPM: http://netpbm.sourceforge.net/doc/ppm.html
+//
+// Known limitations:
+//    Does not support comments in the header section
+//    Does not support ASCII image data (formats P2 and P3)
+//    Does not support 16-bit-per-channel
+
+#ifndef STBI_NO_PNM
+
+static int      stbi__pnm_test(stbi__context *s)
+{
+   char p, t;
+   p = (char) stbi__get8(s);
+   t = (char) stbi__get8(s);
+   if (p != 'P' || (t != '5' && t != '6')) {
+       stbi__rewind( s );
+       return 0;
+   }
+   return 1;
+}
+
+static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   stbi_uc *out;
+   STBI_NOTUSED(ri);
+
+   if (!stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n))
+      return 0;
+
+   *x = s->img_x;
+   *y = s->img_y;
+   if (comp) *comp = s->img_n;
+
+   if (!stbi__mad3sizes_valid(s->img_n, s->img_x, s->img_y, 0))
+      return stbi__errpuc("too large", "PNM too large");
+
+   out = (stbi_uc *) stbi__malloc_mad3(s->img_n, s->img_x, s->img_y, 0);
+   if (!out) return stbi__errpuc("outofmem", "Out of memory");
+   stbi__getn(s, out, s->img_n * s->img_x * s->img_y);
+
+   if (req_comp && req_comp != s->img_n) {
+      out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y);
+      if (out == NULL) return out; // stbi__convert_format frees input on failure
+   }
+   return out;
+}
+
+static int      stbi__pnm_isspace(char c)
+{
+   return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
+}
+
+static void     stbi__pnm_skip_whitespace(stbi__context *s, char *c)
+{
+   for (;;) {
+      while (!stbi__at_eof(s) && stbi__pnm_isspace(*c))
+         *c = (char) stbi__get8(s);
+
+      if (stbi__at_eof(s) || *c != '#')
+         break;
+
+      while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' )
+         *c = (char) stbi__get8(s);
+   }
+}
+
+static int      stbi__pnm_isdigit(char c)
+{
+   return c >= '0' && c <= '9';
+}
+
+static int      stbi__pnm_getinteger(stbi__context *s, char *c)
+{
+   int value = 0;
+
+   while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) {
+      value = value*10 + (*c - '0');
+      *c = (char) stbi__get8(s);
+   }
+
+   return value;
+}
+
+static int      stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   int maxv, dummy;
+   char c, p, t;
+
+   if (!x) x = &dummy;
+   if (!y) y = &dummy;
+   if (!comp) comp = &dummy;
+
+   stbi__rewind(s);
+
+   // Get identifier
+   p = (char) stbi__get8(s);
+   t = (char) stbi__get8(s);
+   if (p != 'P' || (t != '5' && t != '6')) {
+       stbi__rewind(s);
+       return 0;
+   }
+
+   *comp = (t == '6') ? 3 : 1;  // '5' is 1-component .pgm; '6' is 3-component .ppm
+
+   c = (char) stbi__get8(s);
+   stbi__pnm_skip_whitespace(s, &c);
+
+   *x = stbi__pnm_getinteger(s, &c); // read width
+   stbi__pnm_skip_whitespace(s, &c);
+
+   *y = stbi__pnm_getinteger(s, &c); // read height
+   stbi__pnm_skip_whitespace(s, &c);
+
+   maxv = stbi__pnm_getinteger(s, &c);  // read max value
+
+   if (maxv > 255)
+      return stbi__err("max value > 255", "PPM image not 8-bit");
+   else
+      return 1;
+}
+#endif
+
+static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp)
+{
+   #ifndef STBI_NO_JPEG
+   if (stbi__jpeg_info(s, x, y, comp)) return 1;
+   #endif
+
+   #ifndef STBI_NO_PNG
+   if (stbi__png_info(s, x, y, comp))  return 1;
+   #endif
+
+   #ifndef STBI_NO_GIF
+   if (stbi__gif_info(s, x, y, comp))  return 1;
+   #endif
+
+   #ifndef STBI_NO_BMP
+   if (stbi__bmp_info(s, x, y, comp))  return 1;
+   #endif
+
+   #ifndef STBI_NO_PSD
+   if (stbi__psd_info(s, x, y, comp))  return 1;
+   #endif
+
+   #ifndef STBI_NO_PIC
+   if (stbi__pic_info(s, x, y, comp))  return 1;
+   #endif
+
+   #ifndef STBI_NO_PNM
+   if (stbi__pnm_info(s, x, y, comp))  return 1;
+   #endif
+
+   #ifndef STBI_NO_HDR
+   if (stbi__hdr_info(s, x, y, comp))  return 1;
+   #endif
+
+   // test tga last because it's a crappy test!
+   #ifndef STBI_NO_TGA
+   if (stbi__tga_info(s, x, y, comp))
+       return 1;
+   #endif
+   return stbi__err("unknown image type", "Image not of any known type, or corrupt");
+}
+
+static int stbi__is_16_main(stbi__context *s)
+{
+   #ifndef STBI_NO_PNG
+   if (stbi__png_is16(s))  return 1;
+   #endif
+
+   #ifndef STBI_NO_PSD
+   if (stbi__psd_is16(s))  return 1;
+   #endif
+
+   return 0;
+}
+
+#ifndef STBI_NO_STDIO
+STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp)
+{
+    FILE *f = stbi__fopen(filename, "rb");
+    int result;
+    if (!f) return stbi__err("can't fopen", "Unable to open file");
+    result = stbi_info_from_file(f, x, y, comp);
+    fclose(f);
+    return result;
+}
+
+STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)
+{
+   int r;
+   stbi__context s;
+   long pos = ftell(f);
+   stbi__start_file(&s, f);
+   r = stbi__info_main(&s,x,y,comp);
+   fseek(f,pos,SEEK_SET);
+   return r;
+}
+
+STBIDEF int stbi_is_16_bit(char const *filename)
+{
+    FILE *f = stbi__fopen(filename, "rb");
+    int result;
+    if (!f) return stbi__err("can't fopen", "Unable to open file");
+    result = stbi_is_16_bit_from_file(f);
+    fclose(f);
+    return result;
+}
+
+STBIDEF int stbi_is_16_bit_from_file(FILE *f)
+{
+   int r;
+   stbi__context s;
+   long pos = ftell(f);
+   stbi__start_file(&s, f);
+   r = stbi__is_16_main(&s);
+   fseek(f,pos,SEEK_SET);
+   return r;
+}
+#endif // !STBI_NO_STDIO
+
+STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp)
+{
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__info_main(&s,x,y,comp);
+}
+
+STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp)
+{
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);
+   return stbi__info_main(&s,x,y,comp);
+}
+
+STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len)
+{
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__is_16_main(&s);
+}
+
+STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user)
+{
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);
+   return stbi__is_16_main(&s);
+}
+
+#endif // STB_IMAGE_IMPLEMENTATION
+
+/*
+   revision history:
+      2.20  (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs 
+      2.19  (2018-02-11) fix warning
+      2.18  (2018-01-30) fix warnings
+      2.17  (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug
+                         1-bit BMP
+                         *_is_16_bit api
+                         avoid warnings
+      2.16  (2017-07-23) all functions have 16-bit variants;
+                         STBI_NO_STDIO works again;
+                         compilation fixes;
+                         fix rounding in unpremultiply;
+                         optimize vertical flip;
+                         disable raw_len validation;
+                         documentation fixes
+      2.15  (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode;
+                         warning fixes; disable run-time SSE detection on gcc;
+                         uniform handling of optional "return" values;
+                         thread-safe initialization of zlib tables
+      2.14  (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs
+      2.13  (2016-11-29) add 16-bit API, only supported for PNG right now
+      2.12  (2016-04-02) fix typo in 2.11 PSD fix that caused crashes
+      2.11  (2016-04-02) allocate large structures on the stack
+                         remove white matting for transparent PSD
+                         fix reported channel count for PNG & BMP
+                         re-enable SSE2 in non-gcc 64-bit
+                         support RGB-formatted JPEG
+                         read 16-bit PNGs (only as 8-bit)
+      2.10  (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED
+      2.09  (2016-01-16) allow comments in PNM files
+                         16-bit-per-pixel TGA (not bit-per-component)
+                         info() for TGA could break due to .hdr handling
+                         info() for BMP to shares code instead of sloppy parse
+                         can use STBI_REALLOC_SIZED if allocator doesn't support realloc
+                         code cleanup
+      2.08  (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA
+      2.07  (2015-09-13) fix compiler warnings
+                         partial animated GIF support
+                         limited 16-bpc PSD support
+                         #ifdef unused functions
+                         bug with < 92 byte PIC,PNM,HDR,TGA
+      2.06  (2015-04-19) fix bug where PSD returns wrong '*comp' value
+      2.05  (2015-04-19) fix bug in progressive JPEG handling, fix warning
+      2.04  (2015-04-15) try to re-enable SIMD on MinGW 64-bit
+      2.03  (2015-04-12) extra corruption checking (mmozeiko)
+                         stbi_set_flip_vertically_on_load (nguillemot)
+                         fix NEON support; fix mingw support
+      2.02  (2015-01-19) fix incorrect assert, fix warning
+      2.01  (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2
+      2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG
+      2.00  (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg)
+                         progressive JPEG (stb)
+                         PGM/PPM support (Ken Miller)
+                         STBI_MALLOC,STBI_REALLOC,STBI_FREE
+                         GIF bugfix -- seemingly never worked
+                         STBI_NO_*, STBI_ONLY_*
+      1.48  (2014-12-14) fix incorrectly-named assert()
+      1.47  (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb)
+                         optimize PNG (ryg)
+                         fix bug in interlaced PNG with user-specified channel count (stb)
+      1.46  (2014-08-26)
+              fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG
+      1.45  (2014-08-16)
+              fix MSVC-ARM internal compiler error by wrapping malloc
+      1.44  (2014-08-07)
+              various warning fixes from Ronny Chevalier
+      1.43  (2014-07-15)
+              fix MSVC-only compiler problem in code changed in 1.42
+      1.42  (2014-07-09)
+              don't define _CRT_SECURE_NO_WARNINGS (affects user code)
+              fixes to stbi__cleanup_jpeg path
+              added STBI_ASSERT to avoid requiring assert.h
+      1.41  (2014-06-25)
+              fix search&replace from 1.36 that messed up comments/error messages
+      1.40  (2014-06-22)
+              fix gcc struct-initialization warning
+      1.39  (2014-06-15)
+              fix to TGA optimization when req_comp != number of components in TGA;
+              fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite)
+              add support for BMP version 5 (more ignored fields)
+      1.38  (2014-06-06)
+              suppress MSVC warnings on integer casts truncating values
+              fix accidental rename of 'skip' field of I/O
+      1.37  (2014-06-04)
+              remove duplicate typedef
+      1.36  (2014-06-03)
+              convert to header file single-file library
+              if de-iphone isn't set, load iphone images color-swapped instead of returning NULL
+      1.35  (2014-05-27)
+              various warnings
+              fix broken STBI_SIMD path
+              fix bug where stbi_load_from_file no longer left file pointer in correct place
+              fix broken non-easy path for 32-bit BMP (possibly never used)
+              TGA optimization by Arseny Kapoulkine
+      1.34  (unknown)
+              use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case
+      1.33  (2011-07-14)
+              make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements
+      1.32  (2011-07-13)
+              support for "info" function for all supported filetypes (SpartanJ)
+      1.31  (2011-06-20)
+              a few more leak fixes, bug in PNG handling (SpartanJ)
+      1.30  (2011-06-11)
+              added ability to load files via callbacks to accomidate custom input streams (Ben Wenger)
+              removed deprecated format-specific test/load functions
+              removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway
+              error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha)
+              fix inefficiency in decoding 32-bit BMP (David Woo)
+      1.29  (2010-08-16)
+              various warning fixes from Aurelien Pocheville
+      1.28  (2010-08-01)
+              fix bug in GIF palette transparency (SpartanJ)
+      1.27  (2010-08-01)
+              cast-to-stbi_uc to fix warnings
+      1.26  (2010-07-24)
+              fix bug in file buffering for PNG reported by SpartanJ
+      1.25  (2010-07-17)
+              refix trans_data warning (Won Chun)
+      1.24  (2010-07-12)
+              perf improvements reading from files on platforms with lock-heavy fgetc()
+              minor perf improvements for jpeg
+              deprecated type-specific functions so we'll get feedback if they're needed
+              attempt to fix trans_data warning (Won Chun)
+      1.23    fixed bug in iPhone support
+      1.22  (2010-07-10)
+              removed image *writing* support
+              stbi_info support from Jetro Lauha
+              GIF support from Jean-Marc Lienher
+              iPhone PNG-extensions from James Brown
+              warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva)
+      1.21    fix use of 'stbi_uc' in header (reported by jon blow)
+      1.20    added support for Softimage PIC, by Tom Seddon
+      1.19    bug in interlaced PNG corruption check (found by ryg)
+      1.18  (2008-08-02)
+              fix a threading bug (local mutable static)
+      1.17    support interlaced PNG
+      1.16    major bugfix - stbi__convert_format converted one too many pixels
+      1.15    initialize some fields for thread safety
+      1.14    fix threadsafe conversion bug
+              header-file-only version (#define STBI_HEADER_FILE_ONLY before including)
+      1.13    threadsafe
+      1.12    const qualifiers in the API
+      1.11    Support installable IDCT, colorspace conversion routines
+      1.10    Fixes for 64-bit (don't use "unsigned long")
+              optimized upsampling by Fabian "ryg" Giesen
+      1.09    Fix format-conversion for PSD code (bad global variables!)
+      1.08    Thatcher Ulrich's PSD code integrated by Nicolas Schulz
+      1.07    attempt to fix C++ warning/errors again
+      1.06    attempt to fix C++ warning/errors again
+      1.05    fix TGA loading to return correct *comp and use good luminance calc
+      1.04    default float alpha is 1, not 255; use 'void *' for stbi_image_free
+      1.03    bugfixes to STBI_NO_STDIO, STBI_NO_HDR
+      1.02    support for (subset of) HDR files, float interface for preferred access to them
+      1.01    fix bug: possible bug in handling right-side up bmps... not sure
+              fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all
+      1.00    interface to zlib that skips zlib header
+      0.99    correct handling of alpha in palette
+      0.98    TGA loader by lonesock; dynamically add loaders (untested)
+      0.97    jpeg errors on too large a file; also catch another malloc failure
+      0.96    fix detection of invalid v value - particleman@mollyrocket forum
+      0.95    during header scan, seek to markers in case of padding
+      0.94    STBI_NO_STDIO to disable stdio usage; rename all #defines the same
+      0.93    handle jpegtran output; verbose errors
+      0.92    read 4,8,16,24,32-bit BMP files of several formats
+      0.91    output 24-bit Windows 3.0 BMP files
+      0.90    fix a few more warnings; bump version number to approach 1.0
+      0.61    bugfixes due to Marc LeBlanc, Christopher Lloyd
+      0.60    fix compiling as c++
+      0.59    fix warnings: merge Dave Moore's -Wall fixes
+      0.58    fix bug: zlib uncompressed mode len/nlen was wrong endian
+      0.57    fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available
+      0.56    fix bug: zlib uncompressed mode len vs. nlen
+      0.55    fix bug: restart_interval not initialized to 0
+      0.54    allow NULL for 'int *comp'
+      0.53    fix bug in png 3->4; speedup png decoding
+      0.52    png handles req_comp=3,4 directly; minor cleanup; jpeg comments
+      0.51    obey req_comp requests, 1-component jpegs return as 1-component,
+              on 'test' only check type, not whether we support this variant
+      0.50  (2006-11-19)
+              first released version
+*/
+
+
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+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.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+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 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.
+------------------------------------------------------------------------------
+*/
diff --git a/engine/inc/gltf/stb_image_write.h b/engine/inc/gltf/stb_image_write.h
new file mode 100644
index 00000000..ebaa0c55
--- /dev/null
+++ b/engine/inc/gltf/stb_image_write.h
@@ -0,0 +1,1621 @@
+/* stb_image_write - v1.11 - public domain - http://nothings.org/stb/stb_image_write.h
+   writes out PNG/BMP/TGA/JPEG/HDR images to C stdio - Sean Barrett 2010-2015
+                                     no warranty implied; use at your own risk
+
+   Before #including,
+
+       #define STB_IMAGE_WRITE_IMPLEMENTATION
+
+   in the file that you want to have the implementation.
+
+   Will probably not work correctly with strict-aliasing optimizations.
+
+   If using a modern Microsoft Compiler, non-safe versions of CRT calls may cause 
+   compilation warnings or even errors. To avoid this, also before #including,
+
+       #define STBI_MSC_SECURE_CRT
+
+ABOUT:
+
+   This header file is a library for writing images to C stdio or a callback.
+
+   The PNG output is not optimal; it is 20-50% larger than the file
+   written by a decent optimizing implementation; though providing a custom
+   zlib compress function (see STBIW_ZLIB_COMPRESS) can mitigate that.
+   This library is designed for source code compactness and simplicity,
+   not optimal image file size or run-time performance.
+
+BUILDING:
+
+   You can #define STBIW_ASSERT(x) before the #include to avoid using assert.h.
+   You can #define STBIW_MALLOC(), STBIW_REALLOC(), and STBIW_FREE() to replace
+   malloc,realloc,free.
+   You can #define STBIW_MEMMOVE() to replace memmove()
+   You can #define STBIW_ZLIB_COMPRESS to use a custom zlib-style compress function
+   for PNG compression (instead of the builtin one), it must have the following signature:
+   unsigned char * my_compress(unsigned char *data, int data_len, int *out_len, int quality);
+   The returned data will be freed with STBIW_FREE() (free() by default),
+   so it must be heap allocated with STBIW_MALLOC() (malloc() by default),
+
+UNICODE:
+
+   If compiling for Windows and you wish to use Unicode filenames, compile
+   with
+       #define STBIW_WINDOWS_UTF8
+   and pass utf8-encoded filenames. Call stbiw_convert_wchar_to_utf8 to convert
+   Windows wchar_t filenames to utf8.
+
+USAGE:
+
+   There are five functions, one for each image file format:
+
+     int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes);
+     int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data);
+     int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data);
+     int stbi_write_jpg(char const *filename, int w, int h, int comp, const void *data, int quality);
+     int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data);
+
+     void stbi_flip_vertically_on_write(int flag); // flag is non-zero to flip data vertically
+
+   There are also five equivalent functions that use an arbitrary write function. You are
+   expected to open/close your file-equivalent before and after calling these:
+
+     int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void  *data, int stride_in_bytes);
+     int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void  *data);
+     int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void  *data);
+     int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data);
+     int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality);
+
+   where the callback is:
+      void stbi_write_func(void *context, void *data, int size);
+
+   You can configure it with these global variables:
+      int stbi_write_tga_with_rle;             // defaults to true; set to 0 to disable RLE
+      int stbi_write_png_compression_level;    // defaults to 8; set to higher for more compression
+      int stbi_write_force_png_filter;         // defaults to -1; set to 0..5 to force a filter mode
+
+
+   You can define STBI_WRITE_NO_STDIO to disable the file variant of these
+   functions, so the library will not use stdio.h at all. However, this will
+   also disable HDR writing, because it requires stdio for formatted output.
+
+   Each function returns 0 on failure and non-0 on success.
+
+   The functions create an image file defined by the parameters. The image
+   is a rectangle of pixels stored from left-to-right, top-to-bottom.
+   Each pixel contains 'comp' channels of data stored interleaved with 8-bits
+   per channel, in the following order: 1=Y, 2=YA, 3=RGB, 4=RGBA. (Y is
+   monochrome color.) The rectangle is 'w' pixels wide and 'h' pixels tall.
+   The *data pointer points to the first byte of the top-left-most pixel.
+   For PNG, "stride_in_bytes" is the distance in bytes from the first byte of
+   a row of pixels to the first byte of the next row of pixels.
+
+   PNG creates output files with the same number of components as the input.
+   The BMP format expands Y to RGB in the file format and does not
+   output alpha.
+
+   PNG supports writing rectangles of data even when the bytes storing rows of
+   data are not consecutive in memory (e.g. sub-rectangles of a larger image),
+   by supplying the stride between the beginning of adjacent rows. The other
+   formats do not. (Thus you cannot write a native-format BMP through the BMP
+   writer, both because it is in BGR order and because it may have padding
+   at the end of the line.)
+
+   PNG allows you to set the deflate compression level by setting the global
+   variable 'stbi_write_png_compression_level' (it defaults to 8).
+
+   HDR expects linear float data. Since the format is always 32-bit rgb(e)
+   data, alpha (if provided) is discarded, and for monochrome data it is
+   replicated across all three channels.
+
+   TGA supports RLE or non-RLE compressed data. To use non-RLE-compressed
+   data, set the global variable 'stbi_write_tga_with_rle' to 0.
+   
+   JPEG does ignore alpha channels in input data; quality is between 1 and 100.
+   Higher quality looks better but results in a bigger image.
+   JPEG baseline (no JPEG progressive).
+
+CREDITS:
+
+
+   Sean Barrett           -    PNG/BMP/TGA 
+   Baldur Karlsson        -    HDR
+   Jean-Sebastien Guay    -    TGA monochrome
+   Tim Kelsey             -    misc enhancements
+   Alan Hickman           -    TGA RLE
+   Emmanuel Julien        -    initial file IO callback implementation
+   Jon Olick              -    original jo_jpeg.cpp code
+   Daniel Gibson          -    integrate JPEG, allow external zlib
+   Aarni Koskela          -    allow choosing PNG filter
+
+   bugfixes:
+      github:Chribba
+      Guillaume Chereau
+      github:jry2
+      github:romigrou
+      Sergio Gonzalez
+      Jonas Karlsson
+      Filip Wasil
+      Thatcher Ulrich
+      github:poppolopoppo
+      Patrick Boettcher
+      github:xeekworx
+      Cap Petschulat
+      Simon Rodriguez
+      Ivan Tikhonov
+      github:ignotion
+      Adam Schackart
+
+LICENSE
+
+  See end of file for license information.
+
+*/
+
+#ifndef INCLUDE_STB_IMAGE_WRITE_H
+#define INCLUDE_STB_IMAGE_WRITE_H
+
+#include <stdlib.h>
+
+// if STB_IMAGE_WRITE_STATIC causes problems, try defining STBIWDEF to 'inline' or 'static inline'
+#ifndef STBIWDEF
+#ifdef STB_IMAGE_WRITE_STATIC
+#define STBIWDEF  static
+#else
+#ifdef __cplusplus
+#define STBIWDEF  extern "C"
+#else
+#define STBIWDEF  extern
+#endif
+#endif
+#endif
+
+#ifndef STB_IMAGE_WRITE_STATIC  // C++ forbids static forward declarations
+extern int stbi_write_tga_with_rle;
+extern int stbi_write_png_compression_level;
+extern int stbi_write_force_png_filter;
+#endif
+
+#ifndef STBI_WRITE_NO_STDIO
+STBIWDEF int stbi_write_png(char const *filename, int w, int h, int comp, const void  *data, int stride_in_bytes);
+STBIWDEF int stbi_write_bmp(char const *filename, int w, int h, int comp, const void  *data);
+STBIWDEF int stbi_write_tga(char const *filename, int w, int h, int comp, const void  *data);
+STBIWDEF int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data);
+STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void  *data, int quality);
+
+#ifdef STBI_WINDOWS_UTF8
+STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input);
+#endif
+#endif
+
+typedef void stbi_write_func(void *context, void *data, int size);
+
+STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void  *data, int stride_in_bytes);
+STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void  *data);
+STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void  *data);
+STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data);
+STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void  *data, int quality);
+
+STBIWDEF void stbi_flip_vertically_on_write(int flip_boolean);
+
+#endif//INCLUDE_STB_IMAGE_WRITE_H
+
+#ifdef STB_IMAGE_WRITE_IMPLEMENTATION
+
+#ifdef _WIN32
+   #ifndef _CRT_SECURE_NO_WARNINGS
+   #define _CRT_SECURE_NO_WARNINGS
+   #endif
+   #ifndef _CRT_NONSTDC_NO_DEPRECATE
+   #define _CRT_NONSTDC_NO_DEPRECATE
+   #endif
+#endif
+
+#ifndef STBI_WRITE_NO_STDIO
+#include <stdio.h>
+#endif // STBI_WRITE_NO_STDIO
+
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#if defined(STBIW_MALLOC) && defined(STBIW_FREE) && (defined(STBIW_REALLOC) || defined(STBIW_REALLOC_SIZED))
+// ok
+#elif !defined(STBIW_MALLOC) && !defined(STBIW_FREE) && !defined(STBIW_REALLOC) && !defined(STBIW_REALLOC_SIZED)
+// ok
+#else
+#error "Must define all or none of STBIW_MALLOC, STBIW_FREE, and STBIW_REALLOC (or STBIW_REALLOC_SIZED)."
+#endif
+
+#ifndef STBIW_MALLOC
+#define STBIW_MALLOC(sz)        malloc(sz)
+#define STBIW_REALLOC(p,newsz)  realloc(p,newsz)
+#define STBIW_FREE(p)           free(p)
+#endif
+
+#ifndef STBIW_REALLOC_SIZED
+#define STBIW_REALLOC_SIZED(p,oldsz,newsz) STBIW_REALLOC(p,newsz)
+#endif
+
+
+#ifndef STBIW_MEMMOVE
+#define STBIW_MEMMOVE(a,b,sz) memmove(a,b,sz)
+#endif
+
+
+#ifndef STBIW_ASSERT
+#include <assert.h>
+#define STBIW_ASSERT(x) assert(x)
+#endif
+
+#define STBIW_UCHAR(x) (unsigned char) ((x) & 0xff)
+
+#ifdef STB_IMAGE_WRITE_STATIC
+static int stbi__flip_vertically_on_write=0;
+static int stbi_write_png_compression_level = 8;
+static int stbi_write_tga_with_rle = 1;
+static int stbi_write_force_png_filter = -1;
+#else
+int stbi_write_png_compression_level = 8;
+int stbi__flip_vertically_on_write=0;
+int stbi_write_tga_with_rle = 1;
+int stbi_write_force_png_filter = -1;
+#endif
+
+STBIWDEF void stbi_flip_vertically_on_write(int flag)
+{
+   stbi__flip_vertically_on_write = flag;
+}
+
+typedef struct
+{
+   stbi_write_func *func;
+   void *context;
+} stbi__write_context;
+
+// initialize a callback-based context
+static void stbi__start_write_callbacks(stbi__write_context *s, stbi_write_func *c, void *context)
+{
+   s->func    = c;
+   s->context = context;
+}
+
+#ifndef STBI_WRITE_NO_STDIO
+
+static void stbi__stdio_write(void *context, void *data, int size)
+{
+   fwrite(data,1,size,(FILE*) context);
+}
+
+#if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8)
+#ifdef __cplusplus
+#define STBIW_EXTERN extern "C"
+#else
+#define STBIW_EXTERN extern
+#endif
+STBIW_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide);
+STBIW_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default);
+
+STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)
+{
+	return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, bufferlen, NULL, NULL);
+}
+#endif
+
+static FILE *stbiw__fopen(char const *filename, char const *mode)
+{
+   FILE *f;
+#if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8)
+   wchar_t wMode[64];
+   wchar_t wFilename[1024];
+	if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)))
+      return 0;
+	
+	if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)))
+      return 0;
+
+#if _MSC_VER >= 1400
+	if (0 != _wfopen_s(&f, wFilename, wMode))
+		f = 0;
+#else
+   f = _wfopen(wFilename, wMode);
+#endif
+
+#elif defined(_MSC_VER) && _MSC_VER >= 1400
+   if (0 != fopen_s(&f, filename, mode))
+      f=0;
+#else
+   f = fopen(filename, mode);
+#endif
+   return f;
+}
+
+static int stbi__start_write_file(stbi__write_context *s, const char *filename)
+{
+   FILE *f = stbiw__fopen(filename, "wb");
+   stbi__start_write_callbacks(s, stbi__stdio_write, (void *) f);
+   return f != NULL;
+}
+
+static void stbi__end_write_file(stbi__write_context *s)
+{
+   fclose((FILE *)s->context);
+}
+
+#endif // !STBI_WRITE_NO_STDIO
+
+typedef unsigned int stbiw_uint32;
+typedef int stb_image_write_test[sizeof(stbiw_uint32)==4 ? 1 : -1];
+
+static void stbiw__writefv(stbi__write_context *s, const char *fmt, va_list v)
+{
+   while (*fmt) {
+      switch (*fmt++) {
+         case ' ': break;
+         case '1': { unsigned char x = STBIW_UCHAR(va_arg(v, int));
+                     s->func(s->context,&x,1);
+                     break; }
+         case '2': { int x = va_arg(v,int);
+                     unsigned char b[2];
+                     b[0] = STBIW_UCHAR(x);
+                     b[1] = STBIW_UCHAR(x>>8);
+                     s->func(s->context,b,2);
+                     break; }
+         case '4': { stbiw_uint32 x = va_arg(v,int);
+                     unsigned char b[4];
+                     b[0]=STBIW_UCHAR(x);
+                     b[1]=STBIW_UCHAR(x>>8);
+                     b[2]=STBIW_UCHAR(x>>16);
+                     b[3]=STBIW_UCHAR(x>>24);
+                     s->func(s->context,b,4);
+                     break; }
+         default:
+            STBIW_ASSERT(0);
+            return;
+      }
+   }
+}
+
+static void stbiw__writef(stbi__write_context *s, const char *fmt, ...)
+{
+   va_list v;
+   va_start(v, fmt);
+   stbiw__writefv(s, fmt, v);
+   va_end(v);
+}
+
+static void stbiw__putc(stbi__write_context *s, unsigned char c)
+{
+   s->func(s->context, &c, 1);
+}
+
+static void stbiw__write3(stbi__write_context *s, unsigned char a, unsigned char b, unsigned char c)
+{
+   unsigned char arr[3];
+   arr[0] = a, arr[1] = b, arr[2] = c;
+   s->func(s->context, arr, 3);
+}
+
+static void stbiw__write_pixel(stbi__write_context *s, int rgb_dir, int comp, int write_alpha, int expand_mono, unsigned char *d)
+{
+   unsigned char bg[3] = { 255, 0, 255}, px[3];
+   int k;
+
+   if (write_alpha < 0)
+      s->func(s->context, &d[comp - 1], 1);
+
+   switch (comp) {
+      case 2: // 2 pixels = mono + alpha, alpha is written separately, so same as 1-channel case
+      case 1:
+         if (expand_mono)
+            stbiw__write3(s, d[0], d[0], d[0]); // monochrome bmp
+         else
+            s->func(s->context, d, 1);  // monochrome TGA
+         break;
+      case 4:
+         if (!write_alpha) {
+            // composite against pink background
+            for (k = 0; k < 3; ++k)
+               px[k] = bg[k] + ((d[k] - bg[k]) * d[3]) / 255;
+            stbiw__write3(s, px[1 - rgb_dir], px[1], px[1 + rgb_dir]);
+            break;
+         }
+         /* FALLTHROUGH */
+      case 3:
+         stbiw__write3(s, d[1 - rgb_dir], d[1], d[1 + rgb_dir]);
+         break;
+   }
+   if (write_alpha > 0)
+      s->func(s->context, &d[comp - 1], 1);
+}
+
+static void stbiw__write_pixels(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, void *data, int write_alpha, int scanline_pad, int expand_mono)
+{
+   stbiw_uint32 zero = 0;
+   int i,j, j_end;
+
+   if (y <= 0)
+      return;
+
+   if (stbi__flip_vertically_on_write)
+      vdir *= -1;
+
+   if (vdir < 0)
+      j_end = -1, j = y-1;
+   else
+      j_end =  y, j = 0;
+
+   for (; j != j_end; j += vdir) {
+      for (i=0; i < x; ++i) {
+         unsigned char *d = (unsigned char *) data + (j*x+i)*comp;
+         stbiw__write_pixel(s, rgb_dir, comp, write_alpha, expand_mono, d);
+      }
+      s->func(s->context, &zero, scanline_pad);
+   }
+}
+
+static int stbiw__outfile(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, int expand_mono, void *data, int alpha, int pad, const char *fmt, ...)
+{
+   if (y < 0 || x < 0) {
+      return 0;
+   } else {
+      va_list v;
+      va_start(v, fmt);
+      stbiw__writefv(s, fmt, v);
+      va_end(v);
+      stbiw__write_pixels(s,rgb_dir,vdir,x,y,comp,data,alpha,pad, expand_mono);
+      return 1;
+   }
+}
+
+static int stbi_write_bmp_core(stbi__write_context *s, int x, int y, int comp, const void *data)
+{
+   int pad = (-x*3) & 3;
+   return stbiw__outfile(s,-1,-1,x,y,comp,1,(void *) data,0,pad,
+           "11 4 22 4" "4 44 22 444444",
+           'B', 'M', 14+40+(x*3+pad)*y, 0,0, 14+40,  // file header
+            40, x,y, 1,24, 0,0,0,0,0,0);             // bitmap header
+}
+
+STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data)
+{
+   stbi__write_context s;
+   stbi__start_write_callbacks(&s, func, context);
+   return stbi_write_bmp_core(&s, x, y, comp, data);
+}
+
+#ifndef STBI_WRITE_NO_STDIO
+STBIWDEF int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data)
+{
+   stbi__write_context s;
+   if (stbi__start_write_file(&s,filename)) {
+      int r = stbi_write_bmp_core(&s, x, y, comp, data);
+      stbi__end_write_file(&s);
+      return r;
+   } else
+      return 0;
+}
+#endif //!STBI_WRITE_NO_STDIO
+
+static int stbi_write_tga_core(stbi__write_context *s, int x, int y, int comp, void *data)
+{
+   int has_alpha = (comp == 2 || comp == 4);
+   int colorbytes = has_alpha ? comp-1 : comp;
+   int format = colorbytes < 2 ? 3 : 2; // 3 color channels (RGB/RGBA) = 2, 1 color channel (Y/YA) = 3
+
+   if (y < 0 || x < 0)
+      return 0;
+
+   if (!stbi_write_tga_with_rle) {
+      return stbiw__outfile(s, -1, -1, x, y, comp, 0, (void *) data, has_alpha, 0,
+         "111 221 2222 11", 0, 0, format, 0, 0, 0, 0, 0, x, y, (colorbytes + has_alpha) * 8, has_alpha * 8);
+   } else {
+      int i,j,k;
+      int jend, jdir;
+
+      stbiw__writef(s, "111 221 2222 11", 0,0,format+8, 0,0,0, 0,0,x,y, (colorbytes + has_alpha) * 8, has_alpha * 8);
+
+      if (stbi__flip_vertically_on_write) {
+         j = 0;
+         jend = y;
+         jdir = 1;
+      } else {
+         j = y-1;
+         jend = -1;
+         jdir = -1;
+      }
+      for (; j != jend; j += jdir) {
+         unsigned char *row = (unsigned char *) data + j * x * comp;
+         int len;
+
+         for (i = 0; i < x; i += len) {
+            unsigned char *begin = row + i * comp;
+            int diff = 1;
+            len = 1;
+
+            if (i < x - 1) {
+               ++len;
+               diff = memcmp(begin, row + (i + 1) * comp, comp);
+               if (diff) {
+                  const unsigned char *prev = begin;
+                  for (k = i + 2; k < x && len < 128; ++k) {
+                     if (memcmp(prev, row + k * comp, comp)) {
+                        prev += comp;
+                        ++len;
+                     } else {
+                        --len;
+                        break;
+                     }
+                  }
+               } else {
+                  for (k = i + 2; k < x && len < 128; ++k) {
+                     if (!memcmp(begin, row + k * comp, comp)) {
+                        ++len;
+                     } else {
+                        break;
+                     }
+                  }
+               }
+            }
+
+            if (diff) {
+               unsigned char header = STBIW_UCHAR(len - 1);
+               s->func(s->context, &header, 1);
+               for (k = 0; k < len; ++k) {
+                  stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin + k * comp);
+               }
+            } else {
+               unsigned char header = STBIW_UCHAR(len - 129);
+               s->func(s->context, &header, 1);
+               stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin);
+            }
+         }
+      }
+   }
+   return 1;
+}
+
+STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data)
+{
+   stbi__write_context s;
+   stbi__start_write_callbacks(&s, func, context);
+   return stbi_write_tga_core(&s, x, y, comp, (void *) data);
+}
+
+#ifndef STBI_WRITE_NO_STDIO
+STBIWDEF int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data)
+{
+   stbi__write_context s;
+   if (stbi__start_write_file(&s,filename)) {
+      int r = stbi_write_tga_core(&s, x, y, comp, (void *) data);
+      stbi__end_write_file(&s);
+      return r;
+   } else
+      return 0;
+}
+#endif
+
+// *************************************************************************************************
+// Radiance RGBE HDR writer
+// by Baldur Karlsson
+
+#define stbiw__max(a, b)  ((a) > (b) ? (a) : (b))
+
+static void stbiw__linear_to_rgbe(unsigned char *rgbe, float *linear)
+{
+   int exponent;
+   float maxcomp = stbiw__max(linear[0], stbiw__max(linear[1], linear[2]));
+
+   if (maxcomp < 1e-32f) {
+      rgbe[0] = rgbe[1] = rgbe[2] = rgbe[3] = 0;
+   } else {
+      float normalize = (float) frexp(maxcomp, &exponent) * 256.0f/maxcomp;
+
+      rgbe[0] = (unsigned char)(linear[0] * normalize);
+      rgbe[1] = (unsigned char)(linear[1] * normalize);
+      rgbe[2] = (unsigned char)(linear[2] * normalize);
+      rgbe[3] = (unsigned char)(exponent + 128);
+   }
+}
+
+static void stbiw__write_run_data(stbi__write_context *s, int length, unsigned char databyte)
+{
+   unsigned char lengthbyte = STBIW_UCHAR(length+128);
+   STBIW_ASSERT(length+128 <= 255);
+   s->func(s->context, &lengthbyte, 1);
+   s->func(s->context, &databyte, 1);
+}
+
+static void stbiw__write_dump_data(stbi__write_context *s, int length, unsigned char *data)
+{
+   unsigned char lengthbyte = STBIW_UCHAR(length);
+   STBIW_ASSERT(length <= 128); // inconsistent with spec but consistent with official code
+   s->func(s->context, &lengthbyte, 1);
+   s->func(s->context, data, length);
+}
+
+static void stbiw__write_hdr_scanline(stbi__write_context *s, int width, int ncomp, unsigned char *scratch, float *scanline)
+{
+   unsigned char scanlineheader[4] = { 2, 2, 0, 0 };
+   unsigned char rgbe[4];
+   float linear[3];
+   int x;
+
+   scanlineheader[2] = (width&0xff00)>>8;
+   scanlineheader[3] = (width&0x00ff);
+
+   /* skip RLE for images too small or large */
+   if (width < 8 || width >= 32768) {
+      for (x=0; x < width; x++) {
+         switch (ncomp) {
+            case 4: /* fallthrough */
+            case 3: linear[2] = scanline[x*ncomp + 2];
+                    linear[1] = scanline[x*ncomp + 1];
+                    linear[0] = scanline[x*ncomp + 0];
+                    break;
+            default:
+                    linear[0] = linear[1] = linear[2] = scanline[x*ncomp + 0];
+                    break;
+         }
+         stbiw__linear_to_rgbe(rgbe, linear);
+         s->func(s->context, rgbe, 4);
+      }
+   } else {
+      int c,r;
+      /* encode into scratch buffer */
+      for (x=0; x < width; x++) {
+         switch(ncomp) {
+            case 4: /* fallthrough */
+            case 3: linear[2] = scanline[x*ncomp + 2];
+                    linear[1] = scanline[x*ncomp + 1];
+                    linear[0] = scanline[x*ncomp + 0];
+                    break;
+            default:
+                    linear[0] = linear[1] = linear[2] = scanline[x*ncomp + 0];
+                    break;
+         }
+         stbiw__linear_to_rgbe(rgbe, linear);
+         scratch[x + width*0] = rgbe[0];
+         scratch[x + width*1] = rgbe[1];
+         scratch[x + width*2] = rgbe[2];
+         scratch[x + width*3] = rgbe[3];
+      }
+
+      s->func(s->context, scanlineheader, 4);
+
+      /* RLE each component separately */
+      for (c=0; c < 4; c++) {
+         unsigned char *comp = &scratch[width*c];
+
+         x = 0;
+         while (x < width) {
+            // find first run
+            r = x;
+            while (r+2 < width) {
+               if (comp[r] == comp[r+1] && comp[r] == comp[r+2])
+                  break;
+               ++r;
+            }
+            if (r+2 >= width)
+               r = width;
+            // dump up to first run
+            while (x < r) {
+               int len = r-x;
+               if (len > 128) len = 128;
+               stbiw__write_dump_data(s, len, &comp[x]);
+               x += len;
+            }
+            // if there's a run, output it
+            if (r+2 < width) { // same test as what we break out of in search loop, so only true if we break'd
+               // find next byte after run
+               while (r < width && comp[r] == comp[x])
+                  ++r;
+               // output run up to r
+               while (x < r) {
+                  int len = r-x;
+                  if (len > 127) len = 127;
+                  stbiw__write_run_data(s, len, comp[x]);
+                  x += len;
+               }
+            }
+         }
+      }
+   }
+}
+
+static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp, float *data)
+{
+   if (y <= 0 || x <= 0 || data == NULL)
+      return 0;
+   else {
+      // Each component is stored separately. Allocate scratch space for full output scanline.
+      unsigned char *scratch = (unsigned char *) STBIW_MALLOC(x*4);
+      int i, len;
+      char buffer[128];
+      char header[] = "#?RADIANCE\n# Written by stb_image_write.h\nFORMAT=32-bit_rle_rgbe\n";
+      s->func(s->context, header, sizeof(header)-1);
+
+#ifdef STBI_MSC_SECURE_CRT
+      len = sprintf_s(buffer, "EXPOSURE=          1.0000000000000\n\n-Y %d +X %d\n", y, x);
+#else
+      len = sprintf(buffer, "EXPOSURE=          1.0000000000000\n\n-Y %d +X %d\n", y, x);
+#endif
+      s->func(s->context, buffer, len);
+
+      for(i=0; i < y; i++)
+         stbiw__write_hdr_scanline(s, x, comp, scratch, data + comp*x*(stbi__flip_vertically_on_write ? y-1-i : i));
+      STBIW_FREE(scratch);
+      return 1;
+   }
+}
+
+STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const float *data)
+{
+   stbi__write_context s;
+   stbi__start_write_callbacks(&s, func, context);
+   return stbi_write_hdr_core(&s, x, y, comp, (float *) data);
+}
+
+#ifndef STBI_WRITE_NO_STDIO
+STBIWDEF int stbi_write_hdr(char const *filename, int x, int y, int comp, const float *data)
+{
+   stbi__write_context s;
+   if (stbi__start_write_file(&s,filename)) {
+      int r = stbi_write_hdr_core(&s, x, y, comp, (float *) data);
+      stbi__end_write_file(&s);
+      return r;
+   } else
+      return 0;
+}
+#endif // STBI_WRITE_NO_STDIO
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// PNG writer
+//
+
+#ifndef STBIW_ZLIB_COMPRESS
+// stretchy buffer; stbiw__sbpush() == vector<>::push_back() -- stbiw__sbcount() == vector<>::size()
+#define stbiw__sbraw(a) ((int *) (a) - 2)
+#define stbiw__sbm(a)   stbiw__sbraw(a)[0]
+#define stbiw__sbn(a)   stbiw__sbraw(a)[1]
+
+#define stbiw__sbneedgrow(a,n)  ((a)==0 || stbiw__sbn(a)+n >= stbiw__sbm(a))
+#define stbiw__sbmaybegrow(a,n) (stbiw__sbneedgrow(a,(n)) ? stbiw__sbgrow(a,n) : 0)
+#define stbiw__sbgrow(a,n)  stbiw__sbgrowf((void **) &(a), (n), sizeof(*(a)))
+
+#define stbiw__sbpush(a, v)      (stbiw__sbmaybegrow(a,1), (a)[stbiw__sbn(a)++] = (v))
+#define stbiw__sbcount(a)        ((a) ? stbiw__sbn(a) : 0)
+#define stbiw__sbfree(a)         ((a) ? STBIW_FREE(stbiw__sbraw(a)),0 : 0)
+
+static void *stbiw__sbgrowf(void **arr, int increment, int itemsize)
+{
+   int m = *arr ? 2*stbiw__sbm(*arr)+increment : increment+1;
+   void *p = STBIW_REALLOC_SIZED(*arr ? stbiw__sbraw(*arr) : 0, *arr ? (stbiw__sbm(*arr)*itemsize + sizeof(int)*2) : 0, itemsize * m + sizeof(int)*2);
+   STBIW_ASSERT(p);
+   if (p) {
+      if (!*arr) ((int *) p)[1] = 0;
+      *arr = (void *) ((int *) p + 2);
+      stbiw__sbm(*arr) = m;
+   }
+   return *arr;
+}
+
+static unsigned char *stbiw__zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount)
+{
+   while (*bitcount >= 8) {
+      stbiw__sbpush(data, STBIW_UCHAR(*bitbuffer));
+      *bitbuffer >>= 8;
+      *bitcount -= 8;
+   }
+   return data;
+}
+
+static int stbiw__zlib_bitrev(int code, int codebits)
+{
+   int res=0;
+   while (codebits--) {
+      res = (res << 1) | (code & 1);
+      code >>= 1;
+   }
+   return res;
+}
+
+static unsigned int stbiw__zlib_countm(unsigned char *a, unsigned char *b, int limit)
+{
+   int i;
+   for (i=0; i < limit && i < 258; ++i)
+      if (a[i] != b[i]) break;
+   return i;
+}
+
+static unsigned int stbiw__zhash(unsigned char *data)
+{
+   stbiw_uint32 hash = data[0] + (data[1] << 8) + (data[2] << 16);
+   hash ^= hash << 3;
+   hash += hash >> 5;
+   hash ^= hash << 4;
+   hash += hash >> 17;
+   hash ^= hash << 25;
+   hash += hash >> 6;
+   return hash;
+}
+
+#define stbiw__zlib_flush() (out = stbiw__zlib_flushf(out, &bitbuf, &bitcount))
+#define stbiw__zlib_add(code,codebits) \
+      (bitbuf |= (code) << bitcount, bitcount += (codebits), stbiw__zlib_flush())
+#define stbiw__zlib_huffa(b,c)  stbiw__zlib_add(stbiw__zlib_bitrev(b,c),c)
+// default huffman tables
+#define stbiw__zlib_huff1(n)  stbiw__zlib_huffa(0x30 + (n), 8)
+#define stbiw__zlib_huff2(n)  stbiw__zlib_huffa(0x190 + (n)-144, 9)
+#define stbiw__zlib_huff3(n)  stbiw__zlib_huffa(0 + (n)-256,7)
+#define stbiw__zlib_huff4(n)  stbiw__zlib_huffa(0xc0 + (n)-280,8)
+#define stbiw__zlib_huff(n)  ((n) <= 143 ? stbiw__zlib_huff1(n) : (n) <= 255 ? stbiw__zlib_huff2(n) : (n) <= 279 ? stbiw__zlib_huff3(n) : stbiw__zlib_huff4(n))
+#define stbiw__zlib_huffb(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : stbiw__zlib_huff2(n))
+
+#define stbiw__ZHASH   16384
+
+#endif // STBIW_ZLIB_COMPRESS
+
+STBIWDEF unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality)
+{
+#ifdef STBIW_ZLIB_COMPRESS
+   // user provided a zlib compress implementation, use that
+   return STBIW_ZLIB_COMPRESS(data, data_len, out_len, quality);
+#else // use builtin
+   static unsigned short lengthc[] = { 3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258, 259 };
+   static unsigned char  lengtheb[]= { 0,0,0,0,0,0,0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4,  4,  5,  5,  5,  5,  0 };
+   static unsigned short distc[]   = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577, 32768 };
+   static unsigned char  disteb[]  = { 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13 };
+   unsigned int bitbuf=0;
+   int i,j, bitcount=0;
+   unsigned char *out = NULL;
+   unsigned char ***hash_table = (unsigned char***) STBIW_MALLOC(stbiw__ZHASH * sizeof(char**));
+   if (hash_table == NULL)
+      return NULL;
+   if (quality < 5) quality = 5;
+
+   stbiw__sbpush(out, 0x78);   // DEFLATE 32K window
+   stbiw__sbpush(out, 0x5e);   // FLEVEL = 1
+   stbiw__zlib_add(1,1);  // BFINAL = 1
+   stbiw__zlib_add(1,2);  // BTYPE = 1 -- fixed huffman
+
+   for (i=0; i < stbiw__ZHASH; ++i)
+      hash_table[i] = NULL;
+
+   i=0;
+   while (i < data_len-3) {
+      // hash next 3 bytes of data to be compressed
+      int h = stbiw__zhash(data+i)&(stbiw__ZHASH-1), best=3;
+      unsigned char *bestloc = 0;
+      unsigned char **hlist = hash_table[h];
+      int n = stbiw__sbcount(hlist);
+      for (j=0; j < n; ++j) {
+         if (hlist[j]-data > i-32768) { // if entry lies within window
+            int d = stbiw__zlib_countm(hlist[j], data+i, data_len-i);
+            if (d >= best) best=d,bestloc=hlist[j];
+         }
+      }
+      // when hash table entry is too long, delete half the entries
+      if (hash_table[h] && stbiw__sbn(hash_table[h]) == 2*quality) {
+         STBIW_MEMMOVE(hash_table[h], hash_table[h]+quality, sizeof(hash_table[h][0])*quality);
+         stbiw__sbn(hash_table[h]) = quality;
+      }
+      stbiw__sbpush(hash_table[h],data+i);
+
+      if (bestloc) {
+         // "lazy matching" - check match at *next* byte, and if it's better, do cur byte as literal
+         h = stbiw__zhash(data+i+1)&(stbiw__ZHASH-1);
+         hlist = hash_table[h];
+         n = stbiw__sbcount(hlist);
+         for (j=0; j < n; ++j) {
+            if (hlist[j]-data > i-32767) {
+               int e = stbiw__zlib_countm(hlist[j], data+i+1, data_len-i-1);
+               if (e > best) { // if next match is better, bail on current match
+                  bestloc = NULL;
+                  break;
+               }
+            }
+         }
+      }
+
+      if (bestloc) {
+         int d = (int) (data+i - bestloc); // distance back
+         STBIW_ASSERT(d <= 32767 && best <= 258);
+         for (j=0; best > lengthc[j+1]-1; ++j);
+         stbiw__zlib_huff(j+257);
+         if (lengtheb[j]) stbiw__zlib_add(best - lengthc[j], lengtheb[j]);
+         for (j=0; d > distc[j+1]-1; ++j);
+         stbiw__zlib_add(stbiw__zlib_bitrev(j,5),5);
+         if (disteb[j]) stbiw__zlib_add(d - distc[j], disteb[j]);
+         i += best;
+      } else {
+         stbiw__zlib_huffb(data[i]);
+         ++i;
+      }
+   }
+   // write out final bytes
+   for (;i < data_len; ++i)
+      stbiw__zlib_huffb(data[i]);
+   stbiw__zlib_huff(256); // end of block
+   // pad with 0 bits to byte boundary
+   while (bitcount)
+      stbiw__zlib_add(0,1);
+
+   for (i=0; i < stbiw__ZHASH; ++i)
+      (void) stbiw__sbfree(hash_table[i]);
+   STBIW_FREE(hash_table);
+
+   {
+      // compute adler32 on input
+      unsigned int s1=1, s2=0;
+      int blocklen = (int) (data_len % 5552);
+      j=0;
+      while (j < data_len) {
+         for (i=0; i < blocklen; ++i) s1 += data[j+i], s2 += s1;
+         s1 %= 65521, s2 %= 65521;
+         j += blocklen;
+         blocklen = 5552;
+      }
+      stbiw__sbpush(out, STBIW_UCHAR(s2 >> 8));
+      stbiw__sbpush(out, STBIW_UCHAR(s2));
+      stbiw__sbpush(out, STBIW_UCHAR(s1 >> 8));
+      stbiw__sbpush(out, STBIW_UCHAR(s1));
+   }
+   *out_len = stbiw__sbn(out);
+   // make returned pointer freeable
+   STBIW_MEMMOVE(stbiw__sbraw(out), out, *out_len);
+   return (unsigned char *) stbiw__sbraw(out);
+#endif // STBIW_ZLIB_COMPRESS
+}
+
+static unsigned int stbiw__crc32(unsigned char *buffer, int len)
+{
+#ifdef STBIW_CRC32
+    return STBIW_CRC32(buffer, len);
+#else
+   static unsigned int crc_table[256] =
+   {
+      0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
+      0x0eDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
+      0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
+      0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
+      0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
+      0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
+      0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
+      0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
+      0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
+      0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
+      0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
+      0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
+      0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
+      0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
+      0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
+      0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
+      0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
+      0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
+      0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
+      0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
+      0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
+      0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
+      0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
+      0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
+      0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
+      0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
+      0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
+      0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
+      0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
+      0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
+      0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
+      0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
+   };
+
+   unsigned int crc = ~0u;
+   int i;
+   for (i=0; i < len; ++i)
+      crc = (crc >> 8) ^ crc_table[buffer[i] ^ (crc & 0xff)];
+   return ~crc;
+#endif
+}
+
+#define stbiw__wpng4(o,a,b,c,d) ((o)[0]=STBIW_UCHAR(a),(o)[1]=STBIW_UCHAR(b),(o)[2]=STBIW_UCHAR(c),(o)[3]=STBIW_UCHAR(d),(o)+=4)
+#define stbiw__wp32(data,v) stbiw__wpng4(data, (v)>>24,(v)>>16,(v)>>8,(v));
+#define stbiw__wptag(data,s) stbiw__wpng4(data, s[0],s[1],s[2],s[3])
+
+static void stbiw__wpcrc(unsigned char **data, int len)
+{
+   unsigned int crc = stbiw__crc32(*data - len - 4, len+4);
+   stbiw__wp32(*data, crc);
+}
+
+static unsigned char stbiw__paeth(int a, int b, int c)
+{
+   int p = a + b - c, pa = abs(p-a), pb = abs(p-b), pc = abs(p-c);
+   if (pa <= pb && pa <= pc) return STBIW_UCHAR(a);
+   if (pb <= pc) return STBIW_UCHAR(b);
+   return STBIW_UCHAR(c);
+}
+
+// @OPTIMIZE: provide an option that always forces left-predict or paeth predict
+static void stbiw__encode_png_line(unsigned char *pixels, int stride_bytes, int width, int height, int y, int n, int filter_type, signed char *line_buffer)
+{
+   static int mapping[] = { 0,1,2,3,4 };
+   static int firstmap[] = { 0,1,0,5,6 };
+   int *mymap = (y != 0) ? mapping : firstmap;
+   int i;
+   int type = mymap[filter_type];
+   unsigned char *z = pixels + stride_bytes * (stbi__flip_vertically_on_write ? height-1-y : y);
+   int signed_stride = stbi__flip_vertically_on_write ? -stride_bytes : stride_bytes;
+    
+   if (type==0) {
+      memcpy(line_buffer, z, width*n);
+      return;
+   }
+
+   // first loop isn't optimized since it's just one pixel    
+   for (i = 0; i < n; ++i) {
+      switch (type) {
+         case 1: line_buffer[i] = z[i]; break;
+         case 2: line_buffer[i] = z[i] - z[i-signed_stride]; break;
+         case 3: line_buffer[i] = z[i] - (z[i-signed_stride]>>1); break;
+         case 4: line_buffer[i] = (signed char) (z[i] - stbiw__paeth(0,z[i-signed_stride],0)); break;
+         case 5: line_buffer[i] = z[i]; break;
+         case 6: line_buffer[i] = z[i]; break;
+      }
+   }
+   switch (type) {
+      case 1: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - z[i-n]; break;
+      case 2: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - z[i-signed_stride]; break;
+      case 3: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - ((z[i-n] + z[i-signed_stride])>>1); break;
+      case 4: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - stbiw__paeth(z[i-n], z[i-signed_stride], z[i-signed_stride-n]); break;
+      case 5: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - (z[i-n]>>1); break;
+      case 6: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - stbiw__paeth(z[i-n], 0,0); break;
+   }
+}
+
+STBIWDEF unsigned char *stbi_write_png_to_mem(const unsigned char *pixels, int stride_bytes, int x, int y, int n, int *out_len)
+{
+   int force_filter = stbi_write_force_png_filter;
+   int ctype[5] = { -1, 0, 4, 2, 6 };
+   unsigned char sig[8] = { 137,80,78,71,13,10,26,10 };
+   unsigned char *out,*o, *filt, *zlib;
+   signed char *line_buffer;
+   int j,zlen;
+
+   if (stride_bytes == 0)
+      stride_bytes = x * n;
+
+   if (force_filter >= 5) {
+      force_filter = -1;
+   }
+
+   filt = (unsigned char *) STBIW_MALLOC((x*n+1) * y); if (!filt) return 0;
+   line_buffer = (signed char *) STBIW_MALLOC(x * n); if (!line_buffer) { STBIW_FREE(filt); return 0; }
+   for (j=0; j < y; ++j) {
+      int filter_type;
+      if (force_filter > -1) {
+         filter_type = force_filter;
+         stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, force_filter, line_buffer);
+      } else { // Estimate the best filter by running through all of them:
+         int best_filter = 0, best_filter_val = 0x7fffffff, est, i;
+         for (filter_type = 0; filter_type < 5; filter_type++) {
+            stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, filter_type, line_buffer);
+
+            // Estimate the entropy of the line using this filter; the less, the better.
+            est = 0;
+            for (i = 0; i < x*n; ++i) {
+               est += abs((signed char) line_buffer[i]);
+            }
+            if (est < best_filter_val) {
+               best_filter_val = est;
+               best_filter = filter_type;
+            }
+         }
+         if (filter_type != best_filter) {  // If the last iteration already got us the best filter, don't redo it
+            stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, best_filter, line_buffer);
+            filter_type = best_filter;
+         }
+      }
+      // when we get here, filter_type contains the filter type, and line_buffer contains the data
+      filt[j*(x*n+1)] = (unsigned char) filter_type;
+      STBIW_MEMMOVE(filt+j*(x*n+1)+1, line_buffer, x*n);
+   }
+   STBIW_FREE(line_buffer);
+   zlib = stbi_zlib_compress(filt, y*( x*n+1), &zlen, stbi_write_png_compression_level);
+   STBIW_FREE(filt);
+   if (!zlib) return 0;
+
+   // each tag requires 12 bytes of overhead
+   out = (unsigned char *) STBIW_MALLOC(8 + 12+13 + 12+zlen + 12);
+   if (!out) return 0;
+   *out_len = 8 + 12+13 + 12+zlen + 12;
+
+   o=out;
+   STBIW_MEMMOVE(o,sig,8); o+= 8;
+   stbiw__wp32(o, 13); // header length
+   stbiw__wptag(o, "IHDR");
+   stbiw__wp32(o, x);
+   stbiw__wp32(o, y);
+   *o++ = 8;
+   *o++ = STBIW_UCHAR(ctype[n]);
+   *o++ = 0;
+   *o++ = 0;
+   *o++ = 0;
+   stbiw__wpcrc(&o,13);
+
+   stbiw__wp32(o, zlen);
+   stbiw__wptag(o, "IDAT");
+   STBIW_MEMMOVE(o, zlib, zlen);
+   o += zlen;
+   STBIW_FREE(zlib);
+   stbiw__wpcrc(&o, zlen);
+
+   stbiw__wp32(o,0);
+   stbiw__wptag(o, "IEND");
+   stbiw__wpcrc(&o,0);
+
+   STBIW_ASSERT(o == out + *out_len);
+
+   return out;
+}
+
+#ifndef STBI_WRITE_NO_STDIO
+STBIWDEF int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes)
+{
+   FILE *f;
+   int len;
+   unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len);
+   if (png == NULL) return 0;
+
+   f = stbiw__fopen(filename, "wb");
+   if (!f) { STBIW_FREE(png); return 0; }
+   fwrite(png, 1, len, f);
+   fclose(f);
+   STBIW_FREE(png);
+   return 1;
+}
+#endif
+
+STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int stride_bytes)
+{
+   int len;
+   unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len);
+   if (png == NULL) return 0;
+   func(context, png, len);
+   STBIW_FREE(png);
+   return 1;
+}
+
+
+/* ***************************************************************************
+ *
+ * JPEG writer
+ *
+ * This is based on Jon Olick's jo_jpeg.cpp:
+ * public domain Simple, Minimalistic JPEG writer - http://www.jonolick.com/code.html
+ */
+
+static const unsigned char stbiw__jpg_ZigZag[] = { 0,1,5,6,14,15,27,28,2,4,7,13,16,26,29,42,3,8,12,17,25,30,41,43,9,11,18,
+      24,31,40,44,53,10,19,23,32,39,45,52,54,20,22,33,38,46,51,55,60,21,34,37,47,50,56,59,61,35,36,48,49,57,58,62,63 };
+
+static void stbiw__jpg_writeBits(stbi__write_context *s, int *bitBufP, int *bitCntP, const unsigned short *bs) {
+   int bitBuf = *bitBufP, bitCnt = *bitCntP;
+   bitCnt += bs[1];
+   bitBuf |= bs[0] << (24 - bitCnt);
+   while(bitCnt >= 8) {
+      unsigned char c = (bitBuf >> 16) & 255;
+      stbiw__putc(s, c);
+      if(c == 255) {
+         stbiw__putc(s, 0);
+      }
+      bitBuf <<= 8;
+      bitCnt -= 8;
+   }
+   *bitBufP = bitBuf;
+   *bitCntP = bitCnt;
+}
+
+static void stbiw__jpg_DCT(float *d0p, float *d1p, float *d2p, float *d3p, float *d4p, float *d5p, float *d6p, float *d7p) {
+   float d0 = *d0p, d1 = *d1p, d2 = *d2p, d3 = *d3p, d4 = *d4p, d5 = *d5p, d6 = *d6p, d7 = *d7p;
+   float z1, z2, z3, z4, z5, z11, z13;
+
+   float tmp0 = d0 + d7;
+   float tmp7 = d0 - d7;
+   float tmp1 = d1 + d6;
+   float tmp6 = d1 - d6;
+   float tmp2 = d2 + d5;
+   float tmp5 = d2 - d5;
+   float tmp3 = d3 + d4;
+   float tmp4 = d3 - d4;
+
+   // Even part
+   float tmp10 = tmp0 + tmp3;   // phase 2
+   float tmp13 = tmp0 - tmp3;
+   float tmp11 = tmp1 + tmp2;
+   float tmp12 = tmp1 - tmp2;
+
+   d0 = tmp10 + tmp11;       // phase 3
+   d4 = tmp10 - tmp11;
+
+   z1 = (tmp12 + tmp13) * 0.707106781f; // c4
+   d2 = tmp13 + z1;       // phase 5
+   d6 = tmp13 - z1;
+
+   // Odd part
+   tmp10 = tmp4 + tmp5;       // phase 2
+   tmp11 = tmp5 + tmp6;
+   tmp12 = tmp6 + tmp7;
+
+   // The rotator is modified from fig 4-8 to avoid extra negations.
+   z5 = (tmp10 - tmp12) * 0.382683433f; // c6
+   z2 = tmp10 * 0.541196100f + z5; // c2-c6
+   z4 = tmp12 * 1.306562965f + z5; // c2+c6
+   z3 = tmp11 * 0.707106781f; // c4
+
+   z11 = tmp7 + z3;      // phase 5
+   z13 = tmp7 - z3;
+
+   *d5p = z13 + z2;         // phase 6
+   *d3p = z13 - z2;
+   *d1p = z11 + z4;
+   *d7p = z11 - z4;
+
+   *d0p = d0;  *d2p = d2;  *d4p = d4;  *d6p = d6;
+}
+
+static void stbiw__jpg_calcBits(int val, unsigned short bits[2]) {
+   int tmp1 = val < 0 ? -val : val;
+   val = val < 0 ? val-1 : val;
+   bits[1] = 1;
+   while(tmp1 >>= 1) {
+      ++bits[1];
+   }
+   bits[0] = val & ((1<<bits[1])-1);
+}
+
+static int stbiw__jpg_processDU(stbi__write_context *s, int *bitBuf, int *bitCnt, float *CDU, float *fdtbl, int DC, const unsigned short HTDC[256][2], const unsigned short HTAC[256][2]) {
+   const unsigned short EOB[2] = { HTAC[0x00][0], HTAC[0x00][1] };
+   const unsigned short M16zeroes[2] = { HTAC[0xF0][0], HTAC[0xF0][1] };
+   int dataOff, i, diff, end0pos;
+   int DU[64];
+
+   // DCT rows
+   for(dataOff=0; dataOff<64; dataOff+=8) {
+      stbiw__jpg_DCT(&CDU[dataOff], &CDU[dataOff+1], &CDU[dataOff+2], &CDU[dataOff+3], &CDU[dataOff+4], &CDU[dataOff+5], &CDU[dataOff+6], &CDU[dataOff+7]);
+   }
+   // DCT columns
+   for(dataOff=0; dataOff<8; ++dataOff) {
+      stbiw__jpg_DCT(&CDU[dataOff], &CDU[dataOff+8], &CDU[dataOff+16], &CDU[dataOff+24], &CDU[dataOff+32], &CDU[dataOff+40], &CDU[dataOff+48], &CDU[dataOff+56]);
+   }
+   // Quantize/descale/zigzag the coefficients
+   for(i=0; i<64; ++i) {
+      float v = CDU[i]*fdtbl[i];
+      // DU[stbiw__jpg_ZigZag[i]] = (int)(v < 0 ? ceilf(v - 0.5f) : floorf(v + 0.5f));
+      // ceilf() and floorf() are C99, not C89, but I /think/ they're not needed here anyway?
+      DU[stbiw__jpg_ZigZag[i]] = (int)(v < 0 ? v - 0.5f : v + 0.5f);
+   }
+
+   // Encode DC
+   diff = DU[0] - DC;
+   if (diff == 0) {
+      stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTDC[0]);
+   } else {
+      unsigned short bits[2];
+      stbiw__jpg_calcBits(diff, bits);
+      stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTDC[bits[1]]);
+      stbiw__jpg_writeBits(s, bitBuf, bitCnt, bits);
+   }
+   // Encode ACs
+   end0pos = 63;
+   for(; (end0pos>0)&&(DU[end0pos]==0); --end0pos) {
+   }
+   // end0pos = first element in reverse order !=0
+   if(end0pos == 0) {
+      stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB);
+      return DU[0];
+   }
+   for(i = 1; i <= end0pos; ++i) {
+      int startpos = i;
+      int nrzeroes;
+      unsigned short bits[2];
+      for (; DU[i]==0 && i<=end0pos; ++i) {
+      }
+      nrzeroes = i-startpos;
+      if ( nrzeroes >= 16 ) {
+         int lng = nrzeroes>>4;
+         int nrmarker;
+         for (nrmarker=1; nrmarker <= lng; ++nrmarker)
+            stbiw__jpg_writeBits(s, bitBuf, bitCnt, M16zeroes);
+         nrzeroes &= 15;
+      }
+      stbiw__jpg_calcBits(DU[i], bits);
+      stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTAC[(nrzeroes<<4)+bits[1]]);
+      stbiw__jpg_writeBits(s, bitBuf, bitCnt, bits);
+   }
+   if(end0pos != 63) {
+      stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB);
+   }
+   return DU[0];
+}
+
+static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, int comp, const void* data, int quality) {
+   // Constants that don't pollute global namespace
+   static const unsigned char std_dc_luminance_nrcodes[] = {0,0,1,5,1,1,1,1,1,1,0,0,0,0,0,0,0};
+   static const unsigned char std_dc_luminance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11};
+   static const unsigned char std_ac_luminance_nrcodes[] = {0,0,2,1,3,3,2,4,3,5,5,4,4,0,0,1,0x7d};
+   static const unsigned char std_ac_luminance_values[] = {
+      0x01,0x02,0x03,0x00,0x04,0x11,0x05,0x12,0x21,0x31,0x41,0x06,0x13,0x51,0x61,0x07,0x22,0x71,0x14,0x32,0x81,0x91,0xa1,0x08,
+      0x23,0x42,0xb1,0xc1,0x15,0x52,0xd1,0xf0,0x24,0x33,0x62,0x72,0x82,0x09,0x0a,0x16,0x17,0x18,0x19,0x1a,0x25,0x26,0x27,0x28,
+      0x29,0x2a,0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58,0x59,
+      0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x83,0x84,0x85,0x86,0x87,0x88,0x89,
+      0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,0xb5,0xb6,
+      0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xe1,0xe2,
+      0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa
+   };
+   static const unsigned char std_dc_chrominance_nrcodes[] = {0,0,3,1,1,1,1,1,1,1,1,1,0,0,0,0,0};
+   static const unsigned char std_dc_chrominance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11};
+   static const unsigned char std_ac_chrominance_nrcodes[] = {0,0,2,1,2,4,4,3,4,7,5,4,4,0,1,2,0x77};
+   static const unsigned char std_ac_chrominance_values[] = {
+      0x00,0x01,0x02,0x03,0x11,0x04,0x05,0x21,0x31,0x06,0x12,0x41,0x51,0x07,0x61,0x71,0x13,0x22,0x32,0x81,0x08,0x14,0x42,0x91,
+      0xa1,0xb1,0xc1,0x09,0x23,0x33,0x52,0xf0,0x15,0x62,0x72,0xd1,0x0a,0x16,0x24,0x34,0xe1,0x25,0xf1,0x17,0x18,0x19,0x1a,0x26,
+      0x27,0x28,0x29,0x2a,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58,
+      0x59,0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x82,0x83,0x84,0x85,0x86,0x87,
+      0x88,0x89,0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,
+      0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,
+      0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa
+   };
+   // Huffman tables
+   static const unsigned short YDC_HT[256][2] = { {0,2},{2,3},{3,3},{4,3},{5,3},{6,3},{14,4},{30,5},{62,6},{126,7},{254,8},{510,9}};
+   static const unsigned short UVDC_HT[256][2] = { {0,2},{1,2},{2,2},{6,3},{14,4},{30,5},{62,6},{126,7},{254,8},{510,9},{1022,10},{2046,11}};
+   static const unsigned short YAC_HT[256][2] = {
+      {10,4},{0,2},{1,2},{4,3},{11,4},{26,5},{120,7},{248,8},{1014,10},{65410,16},{65411,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {12,4},{27,5},{121,7},{502,9},{2038,11},{65412,16},{65413,16},{65414,16},{65415,16},{65416,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {28,5},{249,8},{1015,10},{4084,12},{65417,16},{65418,16},{65419,16},{65420,16},{65421,16},{65422,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {58,6},{503,9},{4085,12},{65423,16},{65424,16},{65425,16},{65426,16},{65427,16},{65428,16},{65429,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {59,6},{1016,10},{65430,16},{65431,16},{65432,16},{65433,16},{65434,16},{65435,16},{65436,16},{65437,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {122,7},{2039,11},{65438,16},{65439,16},{65440,16},{65441,16},{65442,16},{65443,16},{65444,16},{65445,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {123,7},{4086,12},{65446,16},{65447,16},{65448,16},{65449,16},{65450,16},{65451,16},{65452,16},{65453,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {250,8},{4087,12},{65454,16},{65455,16},{65456,16},{65457,16},{65458,16},{65459,16},{65460,16},{65461,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {504,9},{32704,15},{65462,16},{65463,16},{65464,16},{65465,16},{65466,16},{65467,16},{65468,16},{65469,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {505,9},{65470,16},{65471,16},{65472,16},{65473,16},{65474,16},{65475,16},{65476,16},{65477,16},{65478,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {506,9},{65479,16},{65480,16},{65481,16},{65482,16},{65483,16},{65484,16},{65485,16},{65486,16},{65487,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {1017,10},{65488,16},{65489,16},{65490,16},{65491,16},{65492,16},{65493,16},{65494,16},{65495,16},{65496,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {1018,10},{65497,16},{65498,16},{65499,16},{65500,16},{65501,16},{65502,16},{65503,16},{65504,16},{65505,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {2040,11},{65506,16},{65507,16},{65508,16},{65509,16},{65510,16},{65511,16},{65512,16},{65513,16},{65514,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {65515,16},{65516,16},{65517,16},{65518,16},{65519,16},{65520,16},{65521,16},{65522,16},{65523,16},{65524,16},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {2041,11},{65525,16},{65526,16},{65527,16},{65528,16},{65529,16},{65530,16},{65531,16},{65532,16},{65533,16},{65534,16},{0,0},{0,0},{0,0},{0,0},{0,0}
+   };
+   static const unsigned short UVAC_HT[256][2] = {
+      {0,2},{1,2},{4,3},{10,4},{24,5},{25,5},{56,6},{120,7},{500,9},{1014,10},{4084,12},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {11,4},{57,6},{246,8},{501,9},{2038,11},{4085,12},{65416,16},{65417,16},{65418,16},{65419,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {26,5},{247,8},{1015,10},{4086,12},{32706,15},{65420,16},{65421,16},{65422,16},{65423,16},{65424,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {27,5},{248,8},{1016,10},{4087,12},{65425,16},{65426,16},{65427,16},{65428,16},{65429,16},{65430,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {58,6},{502,9},{65431,16},{65432,16},{65433,16},{65434,16},{65435,16},{65436,16},{65437,16},{65438,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {59,6},{1017,10},{65439,16},{65440,16},{65441,16},{65442,16},{65443,16},{65444,16},{65445,16},{65446,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {121,7},{2039,11},{65447,16},{65448,16},{65449,16},{65450,16},{65451,16},{65452,16},{65453,16},{65454,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {122,7},{2040,11},{65455,16},{65456,16},{65457,16},{65458,16},{65459,16},{65460,16},{65461,16},{65462,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {249,8},{65463,16},{65464,16},{65465,16},{65466,16},{65467,16},{65468,16},{65469,16},{65470,16},{65471,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {503,9},{65472,16},{65473,16},{65474,16},{65475,16},{65476,16},{65477,16},{65478,16},{65479,16},{65480,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {504,9},{65481,16},{65482,16},{65483,16},{65484,16},{65485,16},{65486,16},{65487,16},{65488,16},{65489,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {505,9},{65490,16},{65491,16},{65492,16},{65493,16},{65494,16},{65495,16},{65496,16},{65497,16},{65498,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {506,9},{65499,16},{65500,16},{65501,16},{65502,16},{65503,16},{65504,16},{65505,16},{65506,16},{65507,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {2041,11},{65508,16},{65509,16},{65510,16},{65511,16},{65512,16},{65513,16},{65514,16},{65515,16},{65516,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {16352,14},{65517,16},{65518,16},{65519,16},{65520,16},{65521,16},{65522,16},{65523,16},{65524,16},{65525,16},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {1018,10},{32707,15},{65526,16},{65527,16},{65528,16},{65529,16},{65530,16},{65531,16},{65532,16},{65533,16},{65534,16},{0,0},{0,0},{0,0},{0,0},{0,0}
+   };
+   static const int YQT[] = {16,11,10,16,24,40,51,61,12,12,14,19,26,58,60,55,14,13,16,24,40,57,69,56,14,17,22,29,51,87,80,62,18,22,
+                             37,56,68,109,103,77,24,35,55,64,81,104,113,92,49,64,78,87,103,121,120,101,72,92,95,98,112,100,103,99};
+   static const int UVQT[] = {17,18,24,47,99,99,99,99,18,21,26,66,99,99,99,99,24,26,56,99,99,99,99,99,47,66,99,99,99,99,99,99,
+                              99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99};
+   static const float aasf[] = { 1.0f * 2.828427125f, 1.387039845f * 2.828427125f, 1.306562965f * 2.828427125f, 1.175875602f * 2.828427125f, 
+                                 1.0f * 2.828427125f, 0.785694958f * 2.828427125f, 0.541196100f * 2.828427125f, 0.275899379f * 2.828427125f };
+
+   int row, col, i, k;
+   float fdtbl_Y[64], fdtbl_UV[64];
+   unsigned char YTable[64], UVTable[64];
+
+   if(!data || !width || !height || comp > 4 || comp < 1) {
+      return 0;
+   }
+
+   quality = quality ? quality : 90;
+   quality = quality < 1 ? 1 : quality > 100 ? 100 : quality;
+   quality = quality < 50 ? 5000 / quality : 200 - quality * 2;
+
+   for(i = 0; i < 64; ++i) {
+      int uvti, yti = (YQT[i]*quality+50)/100;
+      YTable[stbiw__jpg_ZigZag[i]] = (unsigned char) (yti < 1 ? 1 : yti > 255 ? 255 : yti);
+      uvti = (UVQT[i]*quality+50)/100;
+      UVTable[stbiw__jpg_ZigZag[i]] = (unsigned char) (uvti < 1 ? 1 : uvti > 255 ? 255 : uvti);
+   }
+
+   for(row = 0, k = 0; row < 8; ++row) {
+      for(col = 0; col < 8; ++col, ++k) {
+         fdtbl_Y[k]  = 1 / (YTable [stbiw__jpg_ZigZag[k]] * aasf[row] * aasf[col]);
+         fdtbl_UV[k] = 1 / (UVTable[stbiw__jpg_ZigZag[k]] * aasf[row] * aasf[col]);
+      }
+   }
+
+   // Write Headers
+   {
+      static const unsigned char head0[] = { 0xFF,0xD8,0xFF,0xE0,0,0x10,'J','F','I','F',0,1,1,0,0,1,0,1,0,0,0xFF,0xDB,0,0x84,0 };
+      static const unsigned char head2[] = { 0xFF,0xDA,0,0xC,3,1,0,2,0x11,3,0x11,0,0x3F,0 };
+      const unsigned char head1[] = { 0xFF,0xC0,0,0x11,8,(unsigned char)(height>>8),STBIW_UCHAR(height),(unsigned char)(width>>8),STBIW_UCHAR(width),
+                                      3,1,0x11,0,2,0x11,1,3,0x11,1,0xFF,0xC4,0x01,0xA2,0 };
+      s->func(s->context, (void*)head0, sizeof(head0));
+      s->func(s->context, (void*)YTable, sizeof(YTable));
+      stbiw__putc(s, 1);
+      s->func(s->context, UVTable, sizeof(UVTable));
+      s->func(s->context, (void*)head1, sizeof(head1));
+      s->func(s->context, (void*)(std_dc_luminance_nrcodes+1), sizeof(std_dc_luminance_nrcodes)-1);
+      s->func(s->context, (void*)std_dc_luminance_values, sizeof(std_dc_luminance_values));
+      stbiw__putc(s, 0x10); // HTYACinfo
+      s->func(s->context, (void*)(std_ac_luminance_nrcodes+1), sizeof(std_ac_luminance_nrcodes)-1);
+      s->func(s->context, (void*)std_ac_luminance_values, sizeof(std_ac_luminance_values));
+      stbiw__putc(s, 1); // HTUDCinfo
+      s->func(s->context, (void*)(std_dc_chrominance_nrcodes+1), sizeof(std_dc_chrominance_nrcodes)-1);
+      s->func(s->context, (void*)std_dc_chrominance_values, sizeof(std_dc_chrominance_values));
+      stbiw__putc(s, 0x11); // HTUACinfo
+      s->func(s->context, (void*)(std_ac_chrominance_nrcodes+1), sizeof(std_ac_chrominance_nrcodes)-1);
+      s->func(s->context, (void*)std_ac_chrominance_values, sizeof(std_ac_chrominance_values));
+      s->func(s->context, (void*)head2, sizeof(head2));
+   }
+
+   // Encode 8x8 macroblocks
+   {
+      static const unsigned short fillBits[] = {0x7F, 7};
+      const unsigned char *imageData = (const unsigned char *)data;
+      int DCY=0, DCU=0, DCV=0;
+      int bitBuf=0, bitCnt=0;
+      // comp == 2 is grey+alpha (alpha is ignored)
+      int ofsG = comp > 2 ? 1 : 0, ofsB = comp > 2 ? 2 : 0;
+      int x, y, pos;
+      for(y = 0; y < height; y += 8) {
+         for(x = 0; x < width; x += 8) {
+            float YDU[64], UDU[64], VDU[64];
+            for(row = y, pos = 0; row < y+8; ++row) {
+               // row >= height => use last input row
+               int clamped_row = (row < height) ? row : height - 1;
+               int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp;
+               for(col = x; col < x+8; ++col, ++pos) {
+                  float r, g, b;
+                  // if col >= width => use pixel from last input column
+                  int p = base_p + ((col < width) ? col : (width-1))*comp;
+
+                  r = imageData[p+0];
+                  g = imageData[p+ofsG];
+                  b = imageData[p+ofsB];
+                  YDU[pos]=+0.29900f*r+0.58700f*g+0.11400f*b-128;
+                  UDU[pos]=-0.16874f*r-0.33126f*g+0.50000f*b;
+                  VDU[pos]=+0.50000f*r-0.41869f*g-0.08131f*b;
+               }
+            }
+
+            DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, YDU, fdtbl_Y, DCY, YDC_HT, YAC_HT);
+            DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, UDU, fdtbl_UV, DCU, UVDC_HT, UVAC_HT);
+            DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, VDU, fdtbl_UV, DCV, UVDC_HT, UVAC_HT);
+         }
+      }
+
+      // Do the bit alignment of the EOI marker
+      stbiw__jpg_writeBits(s, &bitBuf, &bitCnt, fillBits);
+   }
+
+   // EOI
+   stbiw__putc(s, 0xFF);
+   stbiw__putc(s, 0xD9);
+
+   return 1;
+}
+
+STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality)
+{
+   stbi__write_context s;
+   stbi__start_write_callbacks(&s, func, context);
+   return stbi_write_jpg_core(&s, x, y, comp, (void *) data, quality);
+}
+
+
+#ifndef STBI_WRITE_NO_STDIO
+STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality)
+{
+   stbi__write_context s;
+   if (stbi__start_write_file(&s,filename)) {
+      int r = stbi_write_jpg_core(&s, x, y, comp, data, quality);
+      stbi__end_write_file(&s);
+      return r;
+   } else
+      return 0;
+}
+#endif
+
+#endif // STB_IMAGE_WRITE_IMPLEMENTATION
+
+/* Revision history
+      1.10  (2019-02-07)
+             support utf8 filenames in Windows; fix warnings and platform ifdefs 
+      1.09  (2018-02-11)
+             fix typo in zlib quality API, improve STB_I_W_STATIC in C++
+      1.08  (2018-01-29)
+             add stbi__flip_vertically_on_write, external zlib, zlib quality, choose PNG filter
+      1.07  (2017-07-24)
+             doc fix
+      1.06 (2017-07-23)
+             writing JPEG (using Jon Olick's code)
+      1.05   ???
+      1.04 (2017-03-03)
+             monochrome BMP expansion
+      1.03   ???
+      1.02 (2016-04-02)
+             avoid allocating large structures on the stack
+      1.01 (2016-01-16)
+             STBIW_REALLOC_SIZED: support allocators with no realloc support
+             avoid race-condition in crc initialization
+             minor compile issues
+      1.00 (2015-09-14)
+             installable file IO function
+      0.99 (2015-09-13)
+             warning fixes; TGA rle support
+      0.98 (2015-04-08)
+             added STBIW_MALLOC, STBIW_ASSERT etc
+      0.97 (2015-01-18)
+             fixed HDR asserts, rewrote HDR rle logic
+      0.96 (2015-01-17)
+             add HDR output
+             fix monochrome BMP
+      0.95 (2014-08-17)
+		       add monochrome TGA output
+      0.94 (2014-05-31)
+             rename private functions to avoid conflicts with stb_image.h
+      0.93 (2014-05-27)
+             warning fixes
+      0.92 (2010-08-01)
+             casts to unsigned char to fix warnings
+      0.91 (2010-07-17)
+             first public release
+      0.90   first internal release
+*/
+
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+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.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this 
+software, either in source code form or as a compiled binary, for any purpose, 
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this 
+software dedicate any and all copyright interest in the software to the public 
+domain. We make this dedication for the benefit of the public at large and to 
+the detriment of our heirs and successors. We intend this dedication to be an 
+overt act of relinquishment in perpetuity of all present and future rights to 
+this software under copyright law.
+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 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.
+------------------------------------------------------------------------------
+*/
diff --git a/engine/inc/gltf/tiny_gltf.h b/engine/inc/gltf/tiny_gltf.h
new file mode 100644
index 00000000..c37be273
--- /dev/null
+++ b/engine/inc/gltf/tiny_gltf.h
@@ -0,0 +1,7639 @@
+//
+// Header-only tiny glTF 2.0 loader and serializer.
+//
+//
+// The MIT License (MIT)
+//
+// Copyright (c) 2015 - 2020 Syoyo Fujita, Aurélien Chatelain and many
+// contributors.
+//
+// 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.
+
+// Version:
+//  - v2.4.2 Decode percent-encoded URI.
+//  - v2.4.1 Fix some glTF object class does not have `extensions` and/or
+//  `extras` property.
+//  - v2.4.0 Experimental RapidJSON and C++14 support(Thanks to @jrkoone).
+//  - v2.3.1 Set default value of minFilter and magFilter in Sampler to -1.
+//  - v2.3.0 Modified Material representation according to glTF 2.0 schema
+//           (and introduced TextureInfo class)
+//           Change the behavior of `Value::IsNumber`. It return true either the
+//           value is int or real.
+//  - v2.2.0 Add loading 16bit PNG support. Add Sparse accessor support(Thanks
+//  to @Ybalrid)
+//  - v2.1.0 Add draco compression.
+//  - v2.0.1 Add comparsion feature(Thanks to @Selmar).
+//  - v2.0.0 glTF 2.0!.
+//
+// Tiny glTF loader is using following third party libraries:
+//
+//  - jsonhpp: C++ JSON library.
+//  - base64: base64 decode/encode library.
+//  - stb_image: Image loading library.
+//
+#ifndef TINY_GLTF_H_
+#define TINY_GLTF_H_
+
+#include <array>
+#include <cassert>
+#include <cmath>  // std::fabs
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <limits>
+#include <map>
+#include <string>
+#include <vector>
+
+#ifndef TINYGLTF_USE_CPP14
+#include <functional>
+#endif
+
+#ifdef __ANDROID__
+#ifdef TINYGLTF_ANDROID_LOAD_FROM_ASSETS
+#include <android/asset_manager.h>
+#endif
+#endif
+
+#ifdef __GNUC__
+#if (__GNUC__ < 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ <= 8))
+#define TINYGLTF_NOEXCEPT
+#else
+#define TINYGLTF_NOEXCEPT noexcept
+#endif
+#else
+#define TINYGLTF_NOEXCEPT noexcept
+#endif
+
+#define DEFAULT_METHODS(x)             \
+  ~x() = default;                      \
+  x(const x &) = default;              \
+  x(x &&) TINYGLTF_NOEXCEPT = default; \
+  x &operator=(const x &) = default;   \
+  x &operator=(x &&) TINYGLTF_NOEXCEPT = default;
+
+namespace tinygltf {
+
+#define TINYGLTF_MODE_POINTS (0)
+#define TINYGLTF_MODE_LINE (1)
+#define TINYGLTF_MODE_LINE_LOOP (2)
+#define TINYGLTF_MODE_LINE_STRIP (3)
+#define TINYGLTF_MODE_TRIANGLES (4)
+#define TINYGLTF_MODE_TRIANGLE_STRIP (5)
+#define TINYGLTF_MODE_TRIANGLE_FAN (6)
+
+#define TINYGLTF_COMPONENT_TYPE_BYTE (5120)
+#define TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE (5121)
+#define TINYGLTF_COMPONENT_TYPE_SHORT (5122)
+#define TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT (5123)
+#define TINYGLTF_COMPONENT_TYPE_INT (5124)
+#define TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT (5125)
+#define TINYGLTF_COMPONENT_TYPE_FLOAT (5126)
+#define TINYGLTF_COMPONENT_TYPE_DOUBLE (5130)
+
+#define TINYGLTF_TEXTURE_FILTER_NEAREST (9728)
+#define TINYGLTF_TEXTURE_FILTER_LINEAR (9729)
+#define TINYGLTF_TEXTURE_FILTER_NEAREST_MIPMAP_NEAREST (9984)
+#define TINYGLTF_TEXTURE_FILTER_LINEAR_MIPMAP_NEAREST (9985)
+#define TINYGLTF_TEXTURE_FILTER_NEAREST_MIPMAP_LINEAR (9986)
+#define TINYGLTF_TEXTURE_FILTER_LINEAR_MIPMAP_LINEAR (9987)
+
+#define TINYGLTF_TEXTURE_WRAP_REPEAT (10497)
+#define TINYGLTF_TEXTURE_WRAP_CLAMP_TO_EDGE (33071)
+#define TINYGLTF_TEXTURE_WRAP_MIRRORED_REPEAT (33648)
+
+// Redeclarations of the above for technique.parameters.
+#define TINYGLTF_PARAMETER_TYPE_BYTE (5120)
+#define TINYGLTF_PARAMETER_TYPE_UNSIGNED_BYTE (5121)
+#define TINYGLTF_PARAMETER_TYPE_SHORT (5122)
+#define TINYGLTF_PARAMETER_TYPE_UNSIGNED_SHORT (5123)
+#define TINYGLTF_PARAMETER_TYPE_INT (5124)
+#define TINYGLTF_PARAMETER_TYPE_UNSIGNED_INT (5125)
+#define TINYGLTF_PARAMETER_TYPE_FLOAT (5126)
+
+#define TINYGLTF_PARAMETER_TYPE_FLOAT_VEC2 (35664)
+#define TINYGLTF_PARAMETER_TYPE_FLOAT_VEC3 (35665)
+#define TINYGLTF_PARAMETER_TYPE_FLOAT_VEC4 (35666)
+
+#define TINYGLTF_PARAMETER_TYPE_INT_VEC2 (35667)
+#define TINYGLTF_PARAMETER_TYPE_INT_VEC3 (35668)
+#define TINYGLTF_PARAMETER_TYPE_INT_VEC4 (35669)
+
+#define TINYGLTF_PARAMETER_TYPE_BOOL (35670)
+#define TINYGLTF_PARAMETER_TYPE_BOOL_VEC2 (35671)
+#define TINYGLTF_PARAMETER_TYPE_BOOL_VEC3 (35672)
+#define TINYGLTF_PARAMETER_TYPE_BOOL_VEC4 (35673)
+
+#define TINYGLTF_PARAMETER_TYPE_FLOAT_MAT2 (35674)
+#define TINYGLTF_PARAMETER_TYPE_FLOAT_MAT3 (35675)
+#define TINYGLTF_PARAMETER_TYPE_FLOAT_MAT4 (35676)
+
+#define TINYGLTF_PARAMETER_TYPE_SAMPLER_2D (35678)
+
+// End parameter types
+
+#define TINYGLTF_TYPE_VEC2 (2)
+#define TINYGLTF_TYPE_VEC3 (3)
+#define TINYGLTF_TYPE_VEC4 (4)
+#define TINYGLTF_TYPE_MAT2 (32 + 2)
+#define TINYGLTF_TYPE_MAT3 (32 + 3)
+#define TINYGLTF_TYPE_MAT4 (32 + 4)
+#define TINYGLTF_TYPE_SCALAR (64 + 1)
+#define TINYGLTF_TYPE_VECTOR (64 + 4)
+#define TINYGLTF_TYPE_MATRIX (64 + 16)
+
+#define TINYGLTF_IMAGE_FORMAT_JPEG (0)
+#define TINYGLTF_IMAGE_FORMAT_PNG (1)
+#define TINYGLTF_IMAGE_FORMAT_BMP (2)
+#define TINYGLTF_IMAGE_FORMAT_GIF (3)
+
+#define TINYGLTF_TEXTURE_FORMAT_ALPHA (6406)
+#define TINYGLTF_TEXTURE_FORMAT_RGB (6407)
+#define TINYGLTF_TEXTURE_FORMAT_RGBA (6408)
+#define TINYGLTF_TEXTURE_FORMAT_LUMINANCE (6409)
+#define TINYGLTF_TEXTURE_FORMAT_LUMINANCE_ALPHA (6410)
+
+#define TINYGLTF_TEXTURE_TARGET_TEXTURE2D (3553)
+#define TINYGLTF_TEXTURE_TYPE_UNSIGNED_BYTE (5121)
+
+#define TINYGLTF_TARGET_ARRAY_BUFFER (34962)
+#define TINYGLTF_TARGET_ELEMENT_ARRAY_BUFFER (34963)
+
+#define TINYGLTF_SHADER_TYPE_VERTEX_SHADER (35633)
+#define TINYGLTF_SHADER_TYPE_FRAGMENT_SHADER (35632)
+
+#define TINYGLTF_DOUBLE_EPS (1.e-12)
+#define TINYGLTF_DOUBLE_EQUAL(a, b) (std::fabs((b) - (a)) < TINYGLTF_DOUBLE_EPS)
+
+#ifdef __ANDROID__
+#ifdef TINYGLTF_ANDROID_LOAD_FROM_ASSETS
+AAssetManager *asset_manager = nullptr;
+#endif
+#endif
+
+typedef enum {
+  NULL_TYPE = 0,
+  REAL_TYPE = 1,
+  INT_TYPE = 2,
+  BOOL_TYPE = 3,
+  STRING_TYPE = 4,
+  ARRAY_TYPE = 5,
+  BINARY_TYPE = 6,
+  OBJECT_TYPE = 7
+} Type;
+
+static inline int32_t GetComponentSizeInBytes(uint32_t componentType) {
+  if (componentType == TINYGLTF_COMPONENT_TYPE_BYTE) {
+    return 1;
+  } else if (componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE) {
+    return 1;
+  } else if (componentType == TINYGLTF_COMPONENT_TYPE_SHORT) {
+    return 2;
+  } else if (componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT) {
+    return 2;
+  } else if (componentType == TINYGLTF_COMPONENT_TYPE_INT) {
+    return 4;
+  } else if (componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT) {
+    return 4;
+  } else if (componentType == TINYGLTF_COMPONENT_TYPE_FLOAT) {
+    return 4;
+  } else if (componentType == TINYGLTF_COMPONENT_TYPE_DOUBLE) {
+    return 8;
+  } else {
+    // Unknown componenty type
+    return -1;
+  }
+}
+
+static inline int32_t GetNumComponentsInType(uint32_t ty) {
+  if (ty == TINYGLTF_TYPE_SCALAR) {
+    return 1;
+  } else if (ty == TINYGLTF_TYPE_VEC2) {
+    return 2;
+  } else if (ty == TINYGLTF_TYPE_VEC3) {
+    return 3;
+  } else if (ty == TINYGLTF_TYPE_VEC4) {
+    return 4;
+  } else if (ty == TINYGLTF_TYPE_MAT2) {
+    return 4;
+  } else if (ty == TINYGLTF_TYPE_MAT3) {
+    return 9;
+  } else if (ty == TINYGLTF_TYPE_MAT4) {
+    return 16;
+  } else {
+    // Unknown componenty type
+    return -1;
+  }
+}
+
+// TODO(syoyo): Move these functions to TinyGLTF class
+bool IsDataURI(const std::string &in);
+bool DecodeDataURI(std::vector<unsigned char> *out, std::string &mime_type,
+                   const std::string &in, size_t reqBytes, bool checkSize);
+
+#ifdef __clang__
+#pragma clang diagnostic push
+// Suppress warning for : static Value null_value
+// https://stackoverflow.com/questions/15708411/how-to-deal-with-global-constructor-warning-in-clang
+#pragma clang diagnostic ignored "-Wexit-time-destructors"
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+// Simple class to represent JSON object
+class Value {
+ public:
+  typedef std::vector<Value> Array;
+  typedef std::map<std::string, Value> Object;
+
+  Value()
+      : type_(NULL_TYPE),
+        int_value_(0),
+        real_value_(0.0),
+        boolean_value_(false) {}
+
+  explicit Value(bool b) : type_(BOOL_TYPE) { boolean_value_ = b; }
+  explicit Value(int i) : type_(INT_TYPE) {
+    int_value_ = i;
+    real_value_ = i;
+  }
+  explicit Value(double n) : type_(REAL_TYPE) { real_value_ = n; }
+  explicit Value(const std::string &s) : type_(STRING_TYPE) {
+    string_value_ = s;
+  }
+  explicit Value(std::string &&s)
+      : type_(STRING_TYPE), string_value_(std::move(s)) {}
+  explicit Value(const unsigned char *p, size_t n) : type_(BINARY_TYPE) {
+    binary_value_.resize(n);
+    memcpy(binary_value_.data(), p, n);
+  }
+  explicit Value(std::vector<unsigned char> &&v) noexcept
+      : type_(BINARY_TYPE),
+        binary_value_(std::move(v)) {}
+  explicit Value(const Array &a) : type_(ARRAY_TYPE) { array_value_ = a; }
+  explicit Value(Array &&a) noexcept : type_(ARRAY_TYPE),
+                                       array_value_(std::move(a)) {}
+
+  explicit Value(const Object &o) : type_(OBJECT_TYPE) { object_value_ = o; }
+  explicit Value(Object &&o) noexcept : type_(OBJECT_TYPE),
+                                        object_value_(std::move(o)) {}
+
+  DEFAULT_METHODS(Value)
+
+  char Type() const { return static_cast<const char>(type_); }
+
+  bool IsBool() const { return (type_ == BOOL_TYPE); }
+
+  bool IsInt() const { return (type_ == INT_TYPE); }
+
+  bool IsNumber() const { return (type_ == REAL_TYPE) || (type_ == INT_TYPE); }
+
+  bool IsReal() const { return (type_ == REAL_TYPE); }
+
+  bool IsString() const { return (type_ == STRING_TYPE); }
+
+  bool IsBinary() const { return (type_ == BINARY_TYPE); }
+
+  bool IsArray() const { return (type_ == ARRAY_TYPE); }
+
+  bool IsObject() const { return (type_ == OBJECT_TYPE); }
+
+  // Use this function if you want to have number value as double.
+  double GetNumberAsDouble() const {
+    if (type_ == INT_TYPE) {
+      return double(int_value_);
+    } else {
+      return real_value_;
+    }
+  }
+
+  // Use this function if you want to have number value as int.
+  // TODO(syoyo): Support int value larger than 32 bits
+  int GetNumberAsInt() const {
+    if (type_ == REAL_TYPE) {
+      return int(real_value_);
+    } else {
+      return int_value_;
+    }
+  }
+
+  // Accessor
+  template <typename T>
+  const T &Get() const;
+  template <typename T>
+  T &Get();
+
+  // Lookup value from an array
+  const Value &Get(int idx) const {
+    static Value null_value;
+    assert(IsArray());
+    assert(idx >= 0);
+    return (static_cast<size_t>(idx) < array_value_.size())
+               ? array_value_[static_cast<size_t>(idx)]
+               : null_value;
+  }
+
+  // Lookup value from a key-value pair
+  const Value &Get(const std::string &key) const {
+    static Value null_value;
+    assert(IsObject());
+    Object::const_iterator it = object_value_.find(key);
+    return (it != object_value_.end()) ? it->second : null_value;
+  }
+
+  size_t ArrayLen() const {
+    if (!IsArray()) return 0;
+    return array_value_.size();
+  }
+
+  // Valid only for object type.
+  bool Has(const std::string &key) const {
+    if (!IsObject()) return false;
+    Object::const_iterator it = object_value_.find(key);
+    return (it != object_value_.end()) ? true : false;
+  }
+
+  // List keys
+  std::vector<std::string> Keys() const {
+    std::vector<std::string> keys;
+    if (!IsObject()) return keys;  // empty
+
+    for (Object::const_iterator it = object_value_.begin();
+         it != object_value_.end(); ++it) {
+      keys.push_back(it->first);
+    }
+
+    return keys;
+  }
+
+  size_t Size() const { return (IsArray() ? ArrayLen() : Keys().size()); }
+
+  bool operator==(const tinygltf::Value &other) const;
+
+ protected:
+  int type_ = NULL_TYPE;
+
+  int int_value_ = 0;
+  double real_value_ = 0.0;
+  std::string string_value_;
+  std::vector<unsigned char> binary_value_;
+  Array array_value_;
+  Object object_value_;
+  bool boolean_value_ = false;
+};
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#define TINYGLTF_VALUE_GET(ctype, var)            \
+  template <>                                     \
+  inline const ctype &Value::Get<ctype>() const { \
+    return var;                                   \
+  }                                               \
+  template <>                                     \
+  inline ctype &Value::Get<ctype>() {             \
+    return var;                                   \
+  }
+TINYGLTF_VALUE_GET(bool, boolean_value_)
+TINYGLTF_VALUE_GET(double, real_value_)
+TINYGLTF_VALUE_GET(int, int_value_)
+TINYGLTF_VALUE_GET(std::string, string_value_)
+TINYGLTF_VALUE_GET(std::vector<unsigned char>, binary_value_)
+TINYGLTF_VALUE_GET(Value::Array, array_value_)
+TINYGLTF_VALUE_GET(Value::Object, object_value_)
+#undef TINYGLTF_VALUE_GET
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wc++98-compat"
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+/// Agregate object for representing a color
+using ColorValue = std::array<double, 4>;
+
+// === legacy interface ====
+// TODO(syoyo): Deprecate `Parameter` class.
+struct Parameter {
+  bool bool_value = false;
+  bool has_number_value = false;
+  std::string string_value;
+  std::vector<double> number_array;
+  std::map<std::string, double> json_double_value;
+  double number_value = 0.0;
+
+  // context sensitive methods. depending the type of the Parameter you are
+  // accessing, these are either valid or not
+  // If this parameter represent a texture map in a material, will return the
+  // texture index
+
+  /// Return the index of a texture if this Parameter is a texture map.
+  /// Returned value is only valid if the parameter represent a texture from a
+  /// material
+  int TextureIndex() const {
+    const auto it = json_double_value.find("index");
+    if (it != std::end(json_double_value)) {
+      return int(it->second);
+    }
+    return -1;
+  }
+
+  /// Return the index of a texture coordinate set if this Parameter is a
+  /// texture map. Returned value is only valid if the parameter represent a
+  /// texture from a material
+  int TextureTexCoord() const {
+    const auto it = json_double_value.find("texCoord");
+    if (it != std::end(json_double_value)) {
+      return int(it->second);
+    }
+    // As per the spec, if texCoord is ommited, this parameter is 0
+    return 0;
+  }
+
+  /// Return the scale of a texture if this Parameter is a normal texture map.
+  /// Returned value is only valid if the parameter represent a normal texture
+  /// from a material
+  double TextureScale() const {
+    const auto it = json_double_value.find("scale");
+    if (it != std::end(json_double_value)) {
+      return it->second;
+    }
+    // As per the spec, if scale is ommited, this paramter is 1
+    return 1;
+  }
+
+  /// Return the strength of a texture if this Parameter is a an occlusion map.
+  /// Returned value is only valid if the parameter represent an occlusion map
+  /// from a material
+  double TextureStrength() const {
+    const auto it = json_double_value.find("strength");
+    if (it != std::end(json_double_value)) {
+      return it->second;
+    }
+    // As per the spec, if strenghth is ommited, this parameter is 1
+    return 1;
+  }
+
+  /// Material factor, like the roughness or metalness of a material
+  /// Returned value is only valid if the parameter represent a texture from a
+  /// material
+  double Factor() const { return number_value; }
+
+  /// Return the color of a material
+  /// Returned value is only valid if the parameter represent a texture from a
+  /// material
+  ColorValue ColorFactor() const {
+    return {
+        {// this agregate intialize the std::array object, and uses C++11 RVO.
+         number_array[0], number_array[1], number_array[2],
+         (number_array.size() > 3 ? number_array[3] : 1.0)}};
+  }
+
+  Parameter() = default;
+  DEFAULT_METHODS(Parameter)
+  bool operator==(const Parameter &) const;
+};
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+typedef std::map<std::string, Parameter> ParameterMap;
+typedef std::map<std::string, Value> ExtensionMap;
+
+struct AnimationChannel {
+  int sampler;              // required
+  int target_node;          // required (index of the node to target)
+  std::string target_path;  // required in ["translation", "rotation", "scale",
+                            // "weights"]
+  Value extras;
+  ExtensionMap extensions;
+  ExtensionMap target_extensions;
+
+  // Filled when SetStoreOriginalJSONForExtrasAndExtensions is enabled.
+  std::string extras_json_string;
+  std::string extensions_json_string;
+  std::string target_extensions_json_string;
+
+  AnimationChannel() : sampler(-1), target_node(-1) {}
+  DEFAULT_METHODS(AnimationChannel)
+  bool operator==(const AnimationChannel &) const;
+};
+
+struct AnimationSampler {
+  int input;                  // required
+  int output;                 // required
+  std::string interpolation;  // "LINEAR", "STEP","CUBICSPLINE" or user defined
+                              // string. default "LINEAR"
+  Value extras;
+  ExtensionMap extensions;
+
+  // Filled when SetStoreOriginalJSONForExtrasAndExtensions is enabled.
+  std::string extras_json_string;
+  std::string extensions_json_string;
+
+  AnimationSampler() : input(-1), output(-1), interpolation("LINEAR") {}
+  DEFAULT_METHODS(AnimationSampler)
+  bool operator==(const AnimationSampler &) const;
+};
+
+struct Animation {
+  std::string name;
+  std::vector<AnimationChannel> channels;
+  std::vector<AnimationSampler> samplers;
+  Value extras;
+  ExtensionMap extensions;
+
+  // Filled when SetStoreOriginalJSONForExtrasAndExtensions is enabled.
+  std::string extras_json_string;
+  std::string extensions_json_string;
+
+  Animation() = default;
+  DEFAULT_METHODS(Animation)
+  bool operator==(const Animation &) const;
+};
+
+struct Skin {
+  std::string name;
+  int inverseBindMatrices;  // required here but not in the spec
+  int skeleton;             // The index of the node used as a skeleton root
+  std::vector<int> joints;  // Indices of skeleton nodes
+
+  Value extras;
+  ExtensionMap extensions;
+
+  // Filled when SetStoreOriginalJSONForExtrasAndExtensions is enabled.
+  std::string extras_json_string;
+  std::string extensions_json_string;
+
+  Skin() {
+    inverseBindMatrices = -1;
+    skeleton = -1;
+  }
+  DEFAULT_METHODS(Skin)
+  bool operator==(const Skin &) const;
+};
+
+struct Sampler {
+  std::string name;
+  // glTF 2.0 spec does not define default value for `minFilter` and
+  // `magFilter`. Set -1 in TinyGLTF(issue #186)
+  int minFilter =
+      -1;  // optional. -1 = no filter defined. ["NEAREST", "LINEAR",
+           // "NEAREST_MIPMAP_LINEAR", "LINEAR_MIPMAP_NEAREST",
+           // "NEAREST_MIPMAP_LINEAR", "LINEAR_MIPMAP_LINEAR"]
+  int magFilter =
+      -1;  // optional. -1 = no filter defined. ["NEAREST", "LINEAR"]
+  int wrapS =
+      TINYGLTF_TEXTURE_WRAP_REPEAT;  // ["CLAMP_TO_EDGE", "MIRRORED_REPEAT",
+                                     // "REPEAT"], default "REPEAT"
+  int wrapT =
+      TINYGLTF_TEXTURE_WRAP_REPEAT;  // ["CLAMP_TO_EDGE", "MIRRORED_REPEAT",
+                                     // "REPEAT"], default "REPEAT"
+  int wrapR = TINYGLTF_TEXTURE_WRAP_REPEAT;  // TinyGLTF extension
+
+  Value extras;
+  ExtensionMap extensions;
+
+  // Filled when SetStoreOriginalJSONForExtrasAndExtensions is enabled.
+  std::string extras_json_string;
+  std::string extensions_json_string;
+
+  Sampler()
+      : minFilter(-1),
+        magFilter(-1),
+        wrapS(TINYGLTF_TEXTURE_WRAP_REPEAT),
+        wrapT(TINYGLTF_TEXTURE_WRAP_REPEAT),
+        wrapR(TINYGLTF_TEXTURE_WRAP_REPEAT) {}
+  DEFAULT_METHODS(Sampler)
+  bool operator==(const Sampler &) const;
+};
+
+struct Image {
+  std::string name;
+  int width;
+  int height;
+  int component;
+  int bits;        // bit depth per channel. 8(byte), 16 or 32.
+  int pixel_type;  // pixel type(TINYGLTF_COMPONENT_TYPE_***). usually
+                   // UBYTE(bits = 8) or USHORT(bits = 16)
+  std::vector<unsigned char> image;
+  int bufferView;        // (required if no uri)
+  std::string mimeType;  // (required if no uri) ["image/jpeg", "image/png",
+                         // "image/bmp", "image/gif"]
+  std::string uri;       // (required if no mimeType) uri is not decoded(e.g.
+                         // whitespace may be represented as %20)
+  Value extras;
+  ExtensionMap extensions;
+
+  // Filled when SetStoreOriginalJSONForExtrasAndExtensions is enabled.
+  std::string extras_json_string;
+  std::string extensions_json_string;
+
+  // When this flag is true, data is stored to `image` in as-is format(e.g. jpeg
+  // compressed for "image/jpeg" mime) This feature is good if you use custom
+  // image loader function. (e.g. delayed decoding of images for faster glTF
+  // parsing) Default parser for Image does not provide as-is loading feature at
+  // the moment. (You can manipulate this by providing your own LoadImageData
+  // function)
+  bool as_is;
+
+  Image() : as_is(false) {
+    bufferView = -1;
+    width = -1;
+    height = -1;
+    component = -1;
+    bits = -1;
+    pixel_type = -1;
+  }
+  DEFAULT_METHODS(Image)
+
+  bool operator==(const Image &) const;
+};
+
+struct Texture {
+  std::string name;
+
+  int sampler;
+  int source;
+  Value extras;
+  ExtensionMap extensions;
+
+  // Filled when SetStoreOriginalJSONForExtrasAndExtensions is enabled.
+  std::string extras_json_string;
+  std::string extensions_json_string;
+
+  Texture() : sampler(-1), source(-1) {}
+  DEFAULT_METHODS(Texture)
+
+  bool operator==(const Texture &) const;
+};
+
+struct TextureInfo {
+  int index = -1;  // required.
+  int texCoord;    // The set index of texture's TEXCOORD attribute used for
+                   // texture coordinate mapping.
+
+  Value extras;
+  ExtensionMap extensions;
+
+  // Filled when SetStoreOriginalJSONForExtrasAndExtensions is enabled.
+  std::string extras_json_string;
+  std::string extensions_json_string;
+
+  TextureInfo() : index(-1), texCoord(0) {}
+  DEFAULT_METHODS(TextureInfo)
+  bool operator==(const TextureInfo &) const;
+};
+
+struct NormalTextureInfo {
+  int index = -1;  // required
+  int texCoord;    // The set index of texture's TEXCOORD attribute used for
+                   // texture coordinate mapping.
+  double scale;    // scaledNormal = normalize((<sampled normal texture value>
+                   // * 2.0 - 1.0) * vec3(<normal scale>, <normal scale>, 1.0))
+
+  Value extras;
+  ExtensionMap extensions;
+
+  // Filled when SetStoreOriginalJSONForExtrasAndExtensions is enabled.
+  std::string extras_json_string;
+  std::string extensions_json_string;
+
+  NormalTextureInfo() : index(-1), texCoord(0), scale(1.0) {}
+  DEFAULT_METHODS(NormalTextureInfo)
+  bool operator==(const NormalTextureInfo &) const;
+};
+
+struct OcclusionTextureInfo {
+  int index = -1;   // required
+  int texCoord;     // The set index of texture's TEXCOORD attribute used for
+                    // texture coordinate mapping.
+  double strength;  // occludedColor = lerp(color, color * <sampled occlusion
+                    // texture value>, <occlusion strength>)
+
+  Value extras;
+  ExtensionMap extensions;
+
+  // Filled when SetStoreOriginalJSONForExtrasAndExtensions is enabled.
+  std::string extras_json_string;
+  std::string extensions_json_string;
+
+  OcclusionTextureInfo() : index(-1), texCoord(0), strength(1.0) {}
+  DEFAULT_METHODS(OcclusionTextureInfo)
+  bool operator==(const OcclusionTextureInfo &) const;
+};
+
+// pbrMetallicRoughness class defined in glTF 2.0 spec.
+struct PbrMetallicRoughness {
+  std::vector<double> baseColorFactor;  // len = 4. default [1,1,1,1]
+  TextureInfo baseColorTexture;
+  double metallicFactor;   // default 1
+  double roughnessFactor;  // default 1
+  TextureInfo metallicRoughnessTexture;
+
+  Value extras;
+  ExtensionMap extensions;
+
+  // Filled when SetStoreOriginalJSONForExtrasAndExtensions is enabled.
+  std::string extras_json_string;
+  std::string extensions_json_string;
+
+  PbrMetallicRoughness()
+      : baseColorFactor(std::vector<double>{1.0, 1.0, 1.0, 1.0}),
+        metallicFactor(1.0),
+        roughnessFactor(1.0) {}
+  DEFAULT_METHODS(PbrMetallicRoughness)
+  bool operator==(const PbrMetallicRoughness &) const;
+};
+
+// Each extension should be stored in a ParameterMap.
+// members not in the values could be included in the ParameterMap
+// to keep a single material model
+struct Material {
+  std::string name;
+
+  std::vector<double> emissiveFactor;  // length 3. default [0, 0, 0]
+  std::string alphaMode;               // default "OPAQUE"
+  double alphaCutoff;                  // default 0.5
+  bool doubleSided;                    // default false;
+
+  PbrMetallicRoughness pbrMetallicRoughness;
+
+  NormalTextureInfo normalTexture;
+  OcclusionTextureInfo occlusionTexture;
+  TextureInfo emissiveTexture;
+
+  // For backward compatibility
+  // TODO(syoyo): Remove `values` and `additionalValues` in the next release.
+  ParameterMap values;
+  ParameterMap additionalValues;
+
+  ExtensionMap extensions;
+  Value extras;
+
+  // Filled when SetStoreOriginalJSONForExtrasAndExtensions is enabled.
+  std::string extras_json_string;
+  std::string extensions_json_string;
+
+  Material() : alphaMode("OPAQUE"), alphaCutoff(0.5), doubleSided(false) {}
+  DEFAULT_METHODS(Material)
+
+  bool operator==(const Material &) const;
+};
+
+struct BufferView {
+  std::string name;
+  int buffer{-1};        // Required
+  size_t byteOffset{0};  // minimum 0, default 0
+  size_t byteLength{0};  // required, minimum 1. 0 = invalid
+  size_t byteStride{0};  // minimum 4, maximum 252 (multiple of 4), default 0 =
+                         // understood to be tightly packed
+  int target{0};  // ["ARRAY_BUFFER", "ELEMENT_ARRAY_BUFFER"] for vertex indices
+                  // or atttribs. Could be 0 for other data
+  Value extras;
+  ExtensionMap extensions;
+
+  // Filled when SetStoreOriginalJSONForExtrasAndExtensions is enabled.
+  std::string extras_json_string;
+  std::string extensions_json_string;
+
+  bool dracoDecoded{false};  // Flag indicating this has been draco decoded
+
+  BufferView()
+      : buffer(-1),
+        byteOffset(0),
+        byteLength(0),
+        byteStride(0),
+        target(0),
+        dracoDecoded(false) {}
+  DEFAULT_METHODS(BufferView)
+  bool operator==(const BufferView &) const;
+};
+
+struct Accessor {
+  int bufferView;  // optional in spec but required here since sparse accessor
+                   // are not supported
+  std::string name;
+  size_t byteOffset;
+  bool normalized;    // optional.
+  int componentType;  // (required) One of TINYGLTF_COMPONENT_TYPE_***
+  size_t count;       // required
+  int type;           // (required) One of TINYGLTF_TYPE_***   ..
+  Value extras;
+  ExtensionMap extensions;
+
+  // Filled when SetStoreOriginalJSONForExtrasAndExtensions is enabled.
+  std::string extras_json_string;
+  std::string extensions_json_string;
+
+  std::vector<double> minValues;  // optional
+  std::vector<double> maxValues;  // optional
+
+  struct {
+    int count;
+    bool isSparse;
+    struct {
+      int byteOffset;
+      int bufferView;
+      int componentType;  // a TINYGLTF_COMPONENT_TYPE_ value
+    } indices;
+    struct {
+      int bufferView;
+      int byteOffset;
+    } values;
+  } sparse;
+
+  ///
+  /// Utility function to compute byteStride for a given bufferView object.
+  /// Returns -1 upon invalid glTF value or parameter configuration.
+  ///
+  int ByteStride(const BufferView &bufferViewObject) const {
+    if (bufferViewObject.byteStride == 0) {
+      // Assume data is tightly packed.
+      int componentSizeInBytes =
+          GetComponentSizeInBytes(static_cast<uint32_t>(componentType));
+      if (componentSizeInBytes <= 0) {
+        return -1;
+      }
+
+      int numComponents = GetNumComponentsInType(static_cast<uint32_t>(type));
+      if (numComponents <= 0) {
+        return -1;
+      }
+
+      return componentSizeInBytes * numComponents;
+    } else {
+      // Check if byteStride is a mulple of the size of the accessor's component
+      // type.
+      int componentSizeInBytes =
+          GetComponentSizeInBytes(static_cast<uint32_t>(componentType));
+      if (componentSizeInBytes <= 0) {
+        return -1;
+      }
+
+      if ((bufferViewObject.byteStride % uint32_t(componentSizeInBytes)) != 0) {
+        return -1;
+      }
+      return static_cast<int>(bufferViewObject.byteStride);
+    }
+
+    // unreachable return 0;
+  }
+
+  Accessor()
+      : bufferView(-1),
+        byteOffset(0),
+        normalized(false),
+        componentType(-1),
+        count(0),
+        type(-1) {
+    sparse.isSparse = false;
+  }
+  DEFAULT_METHODS(Accessor)
+  bool operator==(const tinygltf::Accessor &) const;
+};
+
+struct PerspectiveCamera {
+  double aspectRatio;  // min > 0
+  double yfov;         // required. min > 0
+  double zfar;         // min > 0
+  double znear;        // required. min > 0
+
+  PerspectiveCamera()
+      : aspectRatio(0.0),
+        yfov(0.0),
+        zfar(0.0)  // 0 = use infinite projecton matrix
+        ,
+        znear(0.0) {}
+  DEFAULT_METHODS(PerspectiveCamera)
+  bool operator==(const PerspectiveCamera &) const;
+
+  ExtensionMap extensions;
+  Value extras;
+
+  // Filled when SetStoreOriginalJSONForExtrasAndExtensions is enabled.
+  std::string extras_json_string;
+  std::string extensions_json_string;
+};
+
+struct OrthographicCamera {
+  double xmag;   // required. must not be zero.
+  double ymag;   // required. must not be zero.
+  double zfar;   // required. `zfar` must be greater than `znear`.
+  double znear;  // required
+
+  OrthographicCamera() : xmag(0.0), ymag(0.0), zfar(0.0), znear(0.0) {}
+  DEFAULT_METHODS(OrthographicCamera)
+  bool operator==(const OrthographicCamera &) const;
+
+  ExtensionMap extensions;
+  Value extras;
+
+  // Filled when SetStoreOriginalJSONForExtrasAndExtensions is enabled.
+  std::string extras_json_string;
+  std::string extensions_json_string;
+};
+
+struct Camera {
+  std::string type;  // required. "perspective" or "orthographic"
+  std::string name;
+
+  PerspectiveCamera perspective;
+  OrthographicCamera orthographic;
+
+  Camera() {}
+  DEFAULT_METHODS(Camera)
+  bool operator==(const Camera &) const;
+
+  ExtensionMap extensions;
+  Value extras;
+
+  // Filled when SetStoreOriginalJSONForExtrasAndExtensions is enabled.
+  std::string extras_json_string;
+  std::string extensions_json_string;
+};
+
+struct Primitive {
+  std::map<std::string, int> attributes;  // (required) A dictionary object of
+                                          // integer, where each integer
+                                          // is the index of the accessor
+                                          // containing an attribute.
+  int material;  // The index of the material to apply to this primitive
+                 // when rendering.
+  int indices;   // The index of the accessor that contains the indices.
+  int mode;      // one of TINYGLTF_MODE_***
+  std::vector<std::map<std::string, int> > targets;  // array of morph targets,
+  // where each target is a dict with attribues in ["POSITION, "NORMAL",
+  // "TANGENT"] pointing
+  // to their corresponding accessors
+  ExtensionMap extensions;
+  Value extras;
+
+  // Filled when SetStoreOriginalJSONForExtrasAndExtensions is enabled.
+  std::string extras_json_string;
+  std::string extensions_json_string;
+
+  Primitive() {
+    material = -1;
+    indices = -1;
+    mode = -1;
+  }
+  DEFAULT_METHODS(Primitive)
+  bool operator==(const Primitive &) const;
+};
+
+struct Mesh {
+  std::string name;
+  std::vector<Primitive> primitives;
+  std::vector<double> weights;  // weights to be applied to the Morph Targets
+  ExtensionMap extensions;
+  Value extras;
+
+  // Filled when SetStoreOriginalJSONForExtrasAndExtensions is enabled.
+  std::string extras_json_string;
+  std::string extensions_json_string;
+
+  Mesh() = default;
+  DEFAULT_METHODS(Mesh)
+  bool operator==(const Mesh &) const;
+};
+
+class Node {
+ public:
+  Node() : camera(-1), skin(-1), mesh(-1) {}
+
+  DEFAULT_METHODS(Node)
+
+  bool operator==(const Node &) const;
+
+  int camera;  // the index of the camera referenced by this node
+
+  std::string name;
+  int skin;
+  int mesh;
+  std::vector<int> children;
+  std::vector<double> rotation;     // length must be 0 or 4
+  std::vector<double> scale;        // length must be 0 or 3
+  std::vector<double> translation;  // length must be 0 or 3
+  std::vector<double> matrix;       // length must be 0 or 16
+  std::vector<double> weights;  // The weights of the instantiated Morph Target
+
+  ExtensionMap extensions;
+  Value extras;
+
+  // Filled when SetStoreOriginalJSONForExtrasAndExtensions is enabled.
+  std::string extras_json_string;
+  std::string extensions_json_string;
+};
+
+struct Buffer {
+  std::string name;
+  std::vector<unsigned char> data;
+  std::string
+      uri;  // considered as required here but not in the spec (need to clarify)
+            // uri is not decoded(e.g. whitespace may be represented as %20)
+  Value extras;
+  ExtensionMap extensions;
+
+  // Filled when SetStoreOriginalJSONForExtrasAndExtensions is enabled.
+  std::string extras_json_string;
+  std::string extensions_json_string;
+
+  Buffer() = default;
+  DEFAULT_METHODS(Buffer)
+  bool operator==(const Buffer &) const;
+};
+
+struct Asset {
+  std::string version;  // required
+  std::string generator;
+  std::string minVersion;
+  std::string copyright;
+  ExtensionMap extensions;
+  Value extras;
+
+  // Filled when SetStoreOriginalJSONForExtrasAndExtensions is enabled.
+  std::string extras_json_string;
+  std::string extensions_json_string;
+
+  Asset() = default;
+  DEFAULT_METHODS(Asset)
+  bool operator==(const Asset &) const;
+};
+
+struct Scene {
+  std::string name;
+  std::vector<int> nodes;
+
+  ExtensionMap extensions;
+  Value extras;
+
+  // Filled when SetStoreOriginalJSONForExtrasAndExtensions is enabled.
+  std::string extras_json_string;
+  std::string extensions_json_string;
+
+  Scene() = default;
+  DEFAULT_METHODS(Scene)
+  bool operator==(const Scene &) const;
+};
+
+struct SpotLight {
+  double innerConeAngle;
+  double outerConeAngle;
+
+  SpotLight() : innerConeAngle(0.0), outerConeAngle(0.7853981634) {}
+  DEFAULT_METHODS(SpotLight)
+  bool operator==(const SpotLight &) const;
+
+  ExtensionMap extensions;
+  Value extras;
+
+  // Filled when SetStoreOriginalJSONForExtrasAndExtensions is enabled.
+  std::string extras_json_string;
+  std::string extensions_json_string;
+};
+
+struct Light {
+  std::string name;
+  std::vector<double> color;
+  double intensity{1.0};
+  std::string type;
+  double range{0.0};  // 0.0 = inifinite
+  SpotLight spot;
+
+  Light() : intensity(1.0), range(0.0) {}
+  DEFAULT_METHODS(Light)
+
+  bool operator==(const Light &) const;
+
+  ExtensionMap extensions;
+  Value extras;
+
+  // Filled when SetStoreOriginalJSONForExtrasAndExtensions is enabled.
+  std::string extras_json_string;
+  std::string extensions_json_string;
+};
+
+class Model {
+ public:
+  Model() = default;
+  DEFAULT_METHODS(Model)
+
+  bool operator==(const Model &) const;
+
+  std::vector<Accessor> accessors;
+  std::vector<Animation> animations;
+  std::vector<Buffer> buffers;
+  std::vector<BufferView> bufferViews;
+  std::vector<Material> materials;
+  std::vector<Mesh> meshes;
+  std::vector<Node> nodes;
+  std::vector<Texture> textures;
+  std::vector<Image> images;
+  std::vector<Skin> skins;
+  std::vector<Sampler> samplers;
+  std::vector<Camera> cameras;
+  std::vector<Scene> scenes;
+  std::vector<Light> lights;
+
+  int defaultScene = -1;
+  std::vector<std::string> extensionsUsed;
+  std::vector<std::string> extensionsRequired;
+
+  Asset asset;
+
+  Value extras;
+  ExtensionMap extensions;
+
+  // Filled when SetStoreOriginalJSONForExtrasAndExtensions is enabled.
+  std::string extras_json_string;
+  std::string extensions_json_string;
+};
+
+enum SectionCheck {
+  NO_REQUIRE = 0x00,
+  REQUIRE_VERSION = 0x01,
+  REQUIRE_SCENE = 0x02,
+  REQUIRE_SCENES = 0x04,
+  REQUIRE_NODES = 0x08,
+  REQUIRE_ACCESSORS = 0x10,
+  REQUIRE_BUFFERS = 0x20,
+  REQUIRE_BUFFER_VIEWS = 0x40,
+  REQUIRE_ALL = 0x7f
+};
+
+///
+/// LoadImageDataFunction type. Signature for custom image loading callbacks.
+///
+typedef bool (*LoadImageDataFunction)(Image *, const int, std::string *,
+                                      std::string *, int, int,
+                                      const unsigned char *, int, void *);
+
+///
+/// WriteImageDataFunction type. Signature for custom image writing callbacks.
+///
+typedef bool (*WriteImageDataFunction)(const std::string *, const std::string *,
+                                       Image *, bool, void *);
+
+#ifndef TINYGLTF_NO_STB_IMAGE
+// Declaration of default image loader callback
+bool LoadImageData(Image *image, const int image_idx, std::string *err,
+                   std::string *warn, int req_width, int req_height,
+                   const unsigned char *bytes, int size, void *);
+#endif
+
+#ifndef TINYGLTF_NO_STB_IMAGE_WRITE
+// Declaration of default image writer callback
+bool WriteImageData(const std::string *basepath, const std::string *filename,
+                    Image *image, bool embedImages, void *);
+#endif
+
+///
+/// FilExistsFunction type. Signature for custom filesystem callbacks.
+///
+typedef bool (*FileExistsFunction)(const std::string &abs_filename, void *);
+
+///
+/// ExpandFilePathFunction type. Signature for custom filesystem callbacks.
+///
+typedef std::string (*ExpandFilePathFunction)(const std::string &, void *);
+
+///
+/// ReadWholeFileFunction type. Signature for custom filesystem callbacks.
+///
+typedef bool (*ReadWholeFileFunction)(std::vector<unsigned char> *,
+                                      std::string *, const std::string &,
+                                      void *);
+
+///
+/// WriteWholeFileFunction type. Signature for custom filesystem callbacks.
+///
+typedef bool (*WriteWholeFileFunction)(std::string *, const std::string &,
+                                       const std::vector<unsigned char> &,
+                                       void *);
+
+///
+/// A structure containing all required filesystem callbacks and a pointer to
+/// their user data.
+///
+struct FsCallbacks {
+  FileExistsFunction FileExists;
+  ExpandFilePathFunction ExpandFilePath;
+  ReadWholeFileFunction ReadWholeFile;
+  WriteWholeFileFunction WriteWholeFile;
+
+  void *user_data;  // An argument that is passed to all fs callbacks
+};
+
+#ifndef TINYGLTF_NO_FS
+// Declaration of default filesystem callbacks
+
+bool FileExists(const std::string &abs_filename, void *);
+
+///
+/// Expand file path(e.g. `~` to home directory on posix, `%APPDATA%` to
+/// `C:\Users\tinygltf\AppData`)
+///
+/// @param[in] filepath File path string. Assume UTF-8
+/// @param[in] userdata User data. Set to `nullptr` if you don't need it.
+///
+std::string ExpandFilePath(const std::string &filepath, void *userdata);
+
+bool ReadWholeFile(std::vector<unsigned char> *out, std::string *err,
+                   const std::string &filepath, void *);
+
+bool WriteWholeFile(std::string *err, const std::string &filepath,
+                    const std::vector<unsigned char> &contents, void *);
+#endif
+
+///
+/// glTF Parser/Serialier context.
+///
+class TinyGLTF {
+ public:
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wc++98-compat"
+#endif
+
+  TinyGLTF() : bin_data_(nullptr), bin_size_(0), is_binary_(false) {}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+  ~TinyGLTF() {}
+
+  ///
+  /// Loads glTF ASCII asset from a file.
+  /// Set warning message to `warn` for example it fails to load asserts.
+  /// Returns false and set error string to `err` if there's an error.
+  ///
+  bool LoadASCIIFromFile(Model *model, std::string *err, std::string *warn,
+                         const std::string &filename,
+                         unsigned int check_sections = REQUIRE_VERSION);
+
+  ///
+  /// Loads glTF ASCII asset from string(memory).
+  /// `length` = strlen(str);
+  /// Set warning message to `warn` for example it fails to load asserts.
+  /// Returns false and set error string to `err` if there's an error.
+  ///
+  bool LoadASCIIFromString(Model *model, std::string *err, std::string *warn,
+                           const char *str, const unsigned int length,
+                           const std::string &base_dir,
+                           unsigned int check_sections = REQUIRE_VERSION);
+
+  ///
+  /// Loads glTF binary asset from a file.
+  /// Set warning message to `warn` for example it fails to load asserts.
+  /// Returns false and set error string to `err` if there's an error.
+  ///
+  bool LoadBinaryFromFile(Model *model, std::string *err, std::string *warn,
+                          const std::string &filename,
+                          unsigned int check_sections = REQUIRE_VERSION);
+
+  ///
+  /// Loads glTF binary asset from memory.
+  /// `length` = strlen(str);
+  /// Set warning message to `warn` for example it fails to load asserts.
+  /// Returns false and set error string to `err` if there's an error.
+  ///
+  bool LoadBinaryFromMemory(Model *model, std::string *err, std::string *warn,
+                            const unsigned char *bytes,
+                            const unsigned int length,
+                            const std::string &base_dir = "",
+                            unsigned int check_sections = REQUIRE_VERSION);
+
+  ///
+  /// Write glTF to stream, buffers and images will be embeded
+  ///
+  bool WriteGltfSceneToStream(Model *model, std::ostream &stream,
+                              bool prettyPrint, bool writeBinary);
+
+  ///
+  /// Write glTF to file.
+  ///
+  bool WriteGltfSceneToFile(Model *model, const std::string &filename,
+                            bool embedImages, bool embedBuffers,
+                            bool prettyPrint, bool writeBinary);
+
+  ///
+  /// Set callback to use for loading image data
+  ///
+  void SetImageLoader(LoadImageDataFunction LoadImageData, void *user_data);
+
+  ///
+  /// Set callback to use for writing image data
+  ///
+  void SetImageWriter(WriteImageDataFunction WriteImageData, void *user_data);
+
+  ///
+  /// Set callbacks to use for filesystem (fs) access and their user data
+  ///
+  void SetFsCallbacks(FsCallbacks callbacks);
+
+  ///
+  /// Set serializing default values(default = false).
+  /// When true, default values are force serialized to .glTF.
+  /// This may be helpfull if you want to serialize a full description of glTF
+  /// data.
+  ///
+  /// TODO(LTE): Supply parsing option as function arguments to
+  /// `LoadASCIIFromFile()` and others, not by a class method
+  ///
+  void SetSerializeDefaultValues(const bool enabled) {
+    serialize_default_values_ = enabled;
+  }
+
+  bool GetSerializeDefaultValues() const { return serialize_default_values_; }
+
+  ///
+  /// Store original JSON string for `extras` and `extensions`.
+  /// This feature will be useful when the user want to reconstruct custom data
+  /// structure from JSON string.
+  ///
+  void SetStoreOriginalJSONForExtrasAndExtensions(const bool enabled) {
+    store_original_json_for_extras_and_extensions_ = enabled;
+  }
+
+  bool GetStoreOriginalJSONForExtrasAndExtensions() const {
+    return store_original_json_for_extras_and_extensions_;
+  }
+
+ private:
+  ///
+  /// Loads glTF asset from string(memory).
+  /// `length` = strlen(str);
+  /// Set warning message to `warn` for example it fails to load asserts
+  /// Returns false and set error string to `err` if there's an error.
+  ///
+  bool LoadFromString(Model *model, std::string *err, std::string *warn,
+                      const char *str, const unsigned int length,
+                      const std::string &base_dir, unsigned int check_sections);
+
+  const unsigned char *bin_data_ = nullptr;
+  size_t bin_size_ = 0;
+  bool is_binary_ = false;
+
+  bool serialize_default_values_ = false;  ///< Serialize default values?
+
+  bool store_original_json_for_extras_and_extensions_ = false;
+
+  FsCallbacks fs = {
+#ifndef TINYGLTF_NO_FS
+      &tinygltf::FileExists, &tinygltf::ExpandFilePath,
+      &tinygltf::ReadWholeFile, &tinygltf::WriteWholeFile,
+
+      nullptr  // Fs callback user data
+#else
+      nullptr, nullptr, nullptr, nullptr,
+
+      nullptr  // Fs callback user data
+#endif
+  };
+
+  LoadImageDataFunction LoadImageData =
+#ifndef TINYGLTF_NO_STB_IMAGE
+      &tinygltf::LoadImageData;
+#else
+      nullptr;
+#endif
+  void *load_image_user_data_ = reinterpret_cast<void *>(&fs);
+
+  WriteImageDataFunction WriteImageData =
+#ifndef TINYGLTF_NO_STB_IMAGE_WRITE
+      &tinygltf::WriteImageData;
+#else
+      nullptr;
+#endif
+  void *write_image_user_data_ = reinterpret_cast<void *>(&fs);
+};
+
+#ifdef __clang__
+#pragma clang diagnostic pop  // -Wpadded
+#endif
+
+}  // namespace tinygltf
+
+#endif  // TINY_GLTF_H_
+
+#if defined(TINYGLTF_IMPLEMENTATION) || defined(__INTELLISENSE__)
+#include <algorithm>
+//#include <cassert>
+#ifndef TINYGLTF_NO_FS
+#include <cstdio>
+#include <fstream>
+#endif
+#include <sstream>
+
+#ifdef __clang__
+// Disable some warnings for external files.
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wfloat-equal"
+#pragma clang diagnostic ignored "-Wexit-time-destructors"
+#pragma clang diagnostic ignored "-Wconversion"
+#pragma clang diagnostic ignored "-Wold-style-cast"
+#pragma clang diagnostic ignored "-Wglobal-constructors"
+#if __has_warning("-Wreserved-id-macro")
+#pragma clang diagnostic ignored "-Wreserved-id-macro"
+#endif
+#pragma clang diagnostic ignored "-Wdisabled-macro-expansion"
+#pragma clang diagnostic ignored "-Wpadded"
+#pragma clang diagnostic ignored "-Wc++98-compat"
+#pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
+#pragma clang diagnostic ignored "-Wdocumentation-unknown-command"
+#pragma clang diagnostic ignored "-Wswitch-enum"
+#pragma clang diagnostic ignored "-Wimplicit-fallthrough"
+#pragma clang diagnostic ignored "-Wweak-vtables"
+#pragma clang diagnostic ignored "-Wcovered-switch-default"
+#if __has_warning("-Wdouble-promotion")
+#pragma clang diagnostic ignored "-Wdouble-promotion"
+#endif
+#if __has_warning("-Wcomma")
+#pragma clang diagnostic ignored "-Wcomma"
+#endif
+#if __has_warning("-Wzero-as-null-pointer-constant")
+#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"
+#endif
+#if __has_warning("-Wcast-qual")
+#pragma clang diagnostic ignored "-Wcast-qual"
+#endif
+#if __has_warning("-Wmissing-variable-declarations")
+#pragma clang diagnostic ignored "-Wmissing-variable-declarations"
+#endif
+#if __has_warning("-Wmissing-prototypes")
+#pragma clang diagnostic ignored "-Wmissing-prototypes"
+#endif
+#if __has_warning("-Wcast-align")
+#pragma clang diagnostic ignored "-Wcast-align"
+#endif
+#if __has_warning("-Wnewline-eof")
+#pragma clang diagnostic ignored "-Wnewline-eof"
+#endif
+#if __has_warning("-Wunused-parameter")
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#endif
+#if __has_warning("-Wmismatched-tags")
+#pragma clang diagnostic ignored "-Wmismatched-tags"
+#endif
+#if __has_warning("-Wextra-semi-stmt")
+#pragma clang diagnostic ignored "-Wextra-semi-stmt"
+#endif
+#endif
+
+// Disable GCC warnigs
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wtype-limits"
+#endif  // __GNUC__
+
+#ifndef TINYGLTF_NO_INCLUDE_JSON
+#ifndef TINYGLTF_USE_RAPIDJSON
+#include "json.hpp"
+#else
+#include "document.h"
+#include "prettywriter.h"
+#include "rapidjson.h"
+#include "stringbuffer.h"
+#include "writer.h"
+#endif
+#endif
+
+#ifdef TINYGLTF_ENABLE_DRACO
+#include <draco/compression/decode.h>
+#include <draco/core/decoder_buffer.h>
+#endif
+
+#ifndef TINYGLTF_NO_STB_IMAGE
+#ifndef TINYGLTF_NO_INCLUDE_STB_IMAGE
+#include "stb_image.h"
+#endif
+#endif
+
+#ifndef TINYGLTF_NO_STB_IMAGE_WRITE
+#ifndef TINYGLTF_NO_INCLUDE_STB_IMAGE_WRITE
+#include "stb_image_write.h"
+#endif
+#endif
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
+#ifdef _WIN32
+
+// issue 143.
+// Define NOMINMAX to avoid min/max defines,
+// but undef it after included windows.h
+#ifndef NOMINMAX
+#define TINYGLTF_INTERNAL_NOMINMAX
+#define NOMINMAX
+#endif
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#define TINYGLTF_INTERNAL_WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>  // include API for expanding a file path
+
+#ifdef TINYGLTF_INTERNAL_WIN32_LEAN_AND_MEAN
+#undef WIN32_LEAN_AND_MEAN
+#endif
+
+#if defined(TINYGLTF_INTERNAL_NOMINMAX)
+#undef NOMINMAX
+#endif
+
+#if defined(__GLIBCXX__)  // mingw
+
+#include <fcntl.h>  // _O_RDONLY
+
+#include <ext/stdio_filebuf.h>  // fstream (all sorts of IO stuff) + stdio_filebuf (=streambuf)
+
+#endif
+
+#elif !defined(__ANDROID__) && !defined(__sh__)
+#include <wordexp.h>
+#endif
+
+#if defined(__sparcv9)
+// Big endian
+#else
+#if (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) || MINIZ_X86_OR_X64_CPU
+#define TINYGLTF_LITTLE_ENDIAN 1
+#endif
+#endif
+
+namespace {
+#ifdef TINYGLTF_USE_RAPIDJSON
+
+#ifdef TINYGLTF_USE_RAPIDJSON_CRTALLOCATOR
+// This uses the RapidJSON CRTAllocator.  It is thread safe and multiple
+// documents may be active at once.
+using json =
+    rapidjson::GenericValue<rapidjson::UTF8<>, rapidjson::CrtAllocator>;
+using json_const_iterator = json::ConstMemberIterator;
+using json_const_array_iterator = json const *;
+using JsonDocument =
+    rapidjson::GenericDocument<rapidjson::UTF8<>, rapidjson::CrtAllocator>;
+rapidjson::CrtAllocator s_CrtAllocator;  // stateless and thread safe
+rapidjson::CrtAllocator &GetAllocator() { return s_CrtAllocator; }
+#else
+// This uses the default RapidJSON MemoryPoolAllocator.  It is very fast, but
+// not thread safe. Only a single JsonDocument may be active at any one time,
+// meaning only a single gltf load/save can be active any one time.
+using json = rapidjson::Value;
+using json_const_iterator = json::ConstMemberIterator;
+using json_const_array_iterator = json const *;
+rapidjson::Document *s_pActiveDocument = nullptr;
+rapidjson::Document::AllocatorType &GetAllocator() {
+  assert(s_pActiveDocument);  // Root json node must be JsonDocument type
+  return s_pActiveDocument->GetAllocator();
+}
+
+#ifdef __clang__
+#pragma clang diagnostic push
+// Suppress JsonDocument(JsonDocument &&rhs) noexcept
+#pragma clang diagnostic ignored "-Wunused-member-function"
+#endif
+
+struct JsonDocument : public rapidjson::Document {
+  JsonDocument() {
+    assert(s_pActiveDocument ==
+           nullptr);  // When using default allocator, only one document can be
+                      // active at a time, if you need multiple active at once,
+                      // define TINYGLTF_USE_RAPIDJSON_CRTALLOCATOR
+    s_pActiveDocument = this;
+  }
+  JsonDocument(const JsonDocument &) = delete;
+  JsonDocument(JsonDocument &&rhs) noexcept
+      : rapidjson::Document(std::move(rhs)) {
+    s_pActiveDocument = this;
+    rhs.isNil = true;
+  }
+  ~JsonDocument() {
+    if (!isNil) {
+      s_pActiveDocument = nullptr;
+    }
+  }
+
+ private:
+  bool isNil = false;
+};
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#endif  // TINYGLTF_USE_RAPIDJSON_CRTALLOCATOR
+
+#else
+using nlohmann::json;
+using json_const_iterator = json::const_iterator;
+using json_const_array_iterator = json_const_iterator;
+using JsonDocument = json;
+#endif
+
+void JsonParse(JsonDocument &doc, const char *str, size_t length,
+               bool throwExc = false) {
+#ifdef TINYGLTF_USE_RAPIDJSON
+  (void)throwExc;
+  doc.Parse(str, length);
+#else
+  doc = json::parse(str, str + length, nullptr, throwExc);
+#endif
+}
+}  // namespace
+
+#ifdef __APPLE__
+#include "TargetConditionals.h"
+#endif
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wc++98-compat"
+#endif
+
+namespace tinygltf {
+
+// Equals function for Value, for recursivity
+static bool Equals(const tinygltf::Value &one, const tinygltf::Value &other) {
+  if (one.Type() != other.Type()) return false;
+
+  switch (one.Type()) {
+    case NULL_TYPE:
+      return true;
+    case BOOL_TYPE:
+      return one.Get<bool>() == other.Get<bool>();
+    case REAL_TYPE:
+      return TINYGLTF_DOUBLE_EQUAL(one.Get<double>(), other.Get<double>());
+    case INT_TYPE:
+      return one.Get<int>() == other.Get<int>();
+    case OBJECT_TYPE: {
+      auto oneObj = one.Get<tinygltf::Value::Object>();
+      auto otherObj = other.Get<tinygltf::Value::Object>();
+      if (oneObj.size() != otherObj.size()) return false;
+      for (auto &it : oneObj) {
+        auto otherIt = otherObj.find(it.first);
+        if (otherIt == otherObj.end()) return false;
+
+        if (!Equals(it.second, otherIt->second)) return false;
+      }
+      return true;
+    }
+    case ARRAY_TYPE: {
+      if (one.Size() != other.Size()) return false;
+      for (int i = 0; i < int(one.Size()); ++i)
+        if (!Equals(one.Get(i), other.Get(i))) return false;
+      return true;
+    }
+    case STRING_TYPE:
+      return one.Get<std::string>() == other.Get<std::string>();
+    case BINARY_TYPE:
+      return one.Get<std::vector<unsigned char> >() ==
+             other.Get<std::vector<unsigned char> >();
+    default: {
+      // unhandled type
+      return false;
+    }
+  }
+}
+
+// Equals function for std::vector<double> using TINYGLTF_DOUBLE_EPSILON
+static bool Equals(const std::vector<double> &one,
+                   const std::vector<double> &other) {
+  if (one.size() != other.size()) return false;
+  for (int i = 0; i < int(one.size()); ++i) {
+    if (!TINYGLTF_DOUBLE_EQUAL(one[size_t(i)], other[size_t(i)])) return false;
+  }
+  return true;
+}
+
+bool Accessor::operator==(const Accessor &other) const {
+  return this->bufferView == other.bufferView &&
+         this->byteOffset == other.byteOffset &&
+         this->componentType == other.componentType &&
+         this->count == other.count && this->extensions == other.extensions &&
+         this->extras == other.extras &&
+         Equals(this->maxValues, other.maxValues) &&
+         Equals(this->minValues, other.minValues) && this->name == other.name &&
+         this->normalized == other.normalized && this->type == other.type;
+}
+bool Animation::operator==(const Animation &other) const {
+  return this->channels == other.channels &&
+         this->extensions == other.extensions && this->extras == other.extras &&
+         this->name == other.name && this->samplers == other.samplers;
+}
+bool AnimationChannel::operator==(const AnimationChannel &other) const {
+  return this->extensions == other.extensions && this->extras == other.extras &&
+         this->target_node == other.target_node &&
+         this->target_path == other.target_path &&
+         this->sampler == other.sampler;
+}
+bool AnimationSampler::operator==(const AnimationSampler &other) const {
+  return this->extras == other.extras && this->extensions == other.extensions &&
+         this->input == other.input &&
+         this->interpolation == other.interpolation &&
+         this->output == other.output;
+}
+bool Asset::operator==(const Asset &other) const {
+  return this->copyright == other.copyright &&
+         this->extensions == other.extensions && this->extras == other.extras &&
+         this->generator == other.generator &&
+         this->minVersion == other.minVersion && this->version == other.version;
+}
+bool Buffer::operator==(const Buffer &other) const {
+  return this->data == other.data && this->extensions == other.extensions &&
+         this->extras == other.extras && this->name == other.name &&
+         this->uri == other.uri;
+}
+bool BufferView::operator==(const BufferView &other) const {
+  return this->buffer == other.buffer && this->byteLength == other.byteLength &&
+         this->byteOffset == other.byteOffset &&
+         this->byteStride == other.byteStride && this->name == other.name &&
+         this->target == other.target && this->extensions == other.extensions &&
+         this->extras == other.extras &&
+         this->dracoDecoded == other.dracoDecoded;
+}
+bool Camera::operator==(const Camera &other) const {
+  return this->name == other.name && this->extensions == other.extensions &&
+         this->extras == other.extras &&
+         this->orthographic == other.orthographic &&
+         this->perspective == other.perspective && this->type == other.type;
+}
+bool Image::operator==(const Image &other) const {
+  return this->bufferView == other.bufferView &&
+         this->component == other.component &&
+         this->extensions == other.extensions && this->extras == other.extras &&
+         this->height == other.height && this->image == other.image &&
+         this->mimeType == other.mimeType && this->name == other.name &&
+         this->uri == other.uri && this->width == other.width;
+}
+bool Light::operator==(const Light &other) const {
+  return Equals(this->color, other.color) && this->name == other.name &&
+         this->type == other.type;
+}
+bool Material::operator==(const Material &other) const {
+  return (this->pbrMetallicRoughness == other.pbrMetallicRoughness) &&
+         (this->normalTexture == other.normalTexture) &&
+         (this->occlusionTexture == other.occlusionTexture) &&
+         (this->emissiveTexture == other.emissiveTexture) &&
+         Equals(this->emissiveFactor, other.emissiveFactor) &&
+         (this->alphaMode == other.alphaMode) &&
+         TINYGLTF_DOUBLE_EQUAL(this->alphaCutoff, other.alphaCutoff) &&
+         (this->doubleSided == other.doubleSided) &&
+         (this->extensions == other.extensions) &&
+         (this->extras == other.extras) && (this->values == other.values) &&
+         (this->additionalValues == other.additionalValues) &&
+         (this->name == other.name);
+}
+bool Mesh::operator==(const Mesh &other) const {
+  return this->extensions == other.extensions && this->extras == other.extras &&
+         this->name == other.name && Equals(this->weights, other.weights) &&
+         this->primitives == other.primitives;
+}
+bool Model::operator==(const Model &other) const {
+  return this->accessors == other.accessors &&
+         this->animations == other.animations && this->asset == other.asset &&
+         this->buffers == other.buffers &&
+         this->bufferViews == other.bufferViews &&
+         this->cameras == other.cameras &&
+         this->defaultScene == other.defaultScene &&
+         this->extensions == other.extensions &&
+         this->extensionsRequired == other.extensionsRequired &&
+         this->extensionsUsed == other.extensionsUsed &&
+         this->extras == other.extras && this->images == other.images &&
+         this->lights == other.lights && this->materials == other.materials &&
+         this->meshes == other.meshes && this->nodes == other.nodes &&
+         this->samplers == other.samplers && this->scenes == other.scenes &&
+         this->skins == other.skins && this->textures == other.textures;
+}
+bool Node::operator==(const Node &other) const {
+  return this->camera == other.camera && this->children == other.children &&
+         this->extensions == other.extensions && this->extras == other.extras &&
+         Equals(this->matrix, other.matrix) && this->mesh == other.mesh &&
+         this->name == other.name && Equals(this->rotation, other.rotation) &&
+         Equals(this->scale, other.scale) && this->skin == other.skin &&
+         Equals(this->translation, other.translation) &&
+         Equals(this->weights, other.weights);
+}
+bool SpotLight::operator==(const SpotLight &other) const {
+  return this->extensions == other.extensions && this->extras == other.extras &&
+         TINYGLTF_DOUBLE_EQUAL(this->innerConeAngle, other.innerConeAngle) &&
+         TINYGLTF_DOUBLE_EQUAL(this->outerConeAngle, other.outerConeAngle);
+}
+bool OrthographicCamera::operator==(const OrthographicCamera &other) const {
+  return this->extensions == other.extensions && this->extras == other.extras &&
+         TINYGLTF_DOUBLE_EQUAL(this->xmag, other.xmag) &&
+         TINYGLTF_DOUBLE_EQUAL(this->ymag, other.ymag) &&
+         TINYGLTF_DOUBLE_EQUAL(this->zfar, other.zfar) &&
+         TINYGLTF_DOUBLE_EQUAL(this->znear, other.znear);
+}
+bool Parameter::operator==(const Parameter &other) const {
+  if (this->bool_value != other.bool_value ||
+      this->has_number_value != other.has_number_value)
+    return false;
+
+  if (!TINYGLTF_DOUBLE_EQUAL(this->number_value, other.number_value))
+    return false;
+
+  if (this->json_double_value.size() != other.json_double_value.size())
+    return false;
+  for (auto &it : this->json_double_value) {
+    auto otherIt = other.json_double_value.find(it.first);
+    if (otherIt == other.json_double_value.end()) return false;
+
+    if (!TINYGLTF_DOUBLE_EQUAL(it.second, otherIt->second)) return false;
+  }
+
+  if (!Equals(this->number_array, other.number_array)) return false;
+
+  if (this->string_value != other.string_value) return false;
+
+  return true;
+}
+bool PerspectiveCamera::operator==(const PerspectiveCamera &other) const {
+  return TINYGLTF_DOUBLE_EQUAL(this->aspectRatio, other.aspectRatio) &&
+         this->extensions == other.extensions && this->extras == other.extras &&
+         TINYGLTF_DOUBLE_EQUAL(this->yfov, other.yfov) &&
+         TINYGLTF_DOUBLE_EQUAL(this->zfar, other.zfar) &&
+         TINYGLTF_DOUBLE_EQUAL(this->znear, other.znear);
+}
+bool Primitive::operator==(const Primitive &other) const {
+  return this->attributes == other.attributes && this->extras == other.extras &&
+         this->indices == other.indices && this->material == other.material &&
+         this->mode == other.mode && this->targets == other.targets;
+}
+bool Sampler::operator==(const Sampler &other) const {
+  return this->extensions == other.extensions && this->extras == other.extras &&
+         this->magFilter == other.magFilter &&
+         this->minFilter == other.minFilter && this->name == other.name &&
+         this->wrapR == other.wrapR && this->wrapS == other.wrapS &&
+         this->wrapT == other.wrapT;
+}
+bool Scene::operator==(const Scene &other) const {
+  return this->extensions == other.extensions && this->extras == other.extras &&
+         this->name == other.name && this->nodes == other.nodes;
+}
+bool Skin::operator==(const Skin &other) const {
+  return this->extensions == other.extensions && this->extras == other.extras &&
+         this->inverseBindMatrices == other.inverseBindMatrices &&
+         this->joints == other.joints && this->name == other.name &&
+         this->skeleton == other.skeleton;
+}
+bool Texture::operator==(const Texture &other) const {
+  return this->extensions == other.extensions && this->extras == other.extras &&
+         this->name == other.name && this->sampler == other.sampler &&
+         this->source == other.source;
+}
+bool TextureInfo::operator==(const TextureInfo &other) const {
+  return this->extensions == other.extensions && this->extras == other.extras &&
+         this->index == other.index && this->texCoord == other.texCoord;
+}
+bool NormalTextureInfo::operator==(const NormalTextureInfo &other) const {
+  return this->extensions == other.extensions && this->extras == other.extras &&
+         this->index == other.index && this->texCoord == other.texCoord &&
+         TINYGLTF_DOUBLE_EQUAL(this->scale, other.scale);
+}
+bool OcclusionTextureInfo::operator==(const OcclusionTextureInfo &other) const {
+  return this->extensions == other.extensions && this->extras == other.extras &&
+         this->index == other.index && this->texCoord == other.texCoord &&
+         TINYGLTF_DOUBLE_EQUAL(this->strength, other.strength);
+}
+bool PbrMetallicRoughness::operator==(const PbrMetallicRoughness &other) const {
+  return this->extensions == other.extensions && this->extras == other.extras &&
+         (this->baseColorTexture == other.baseColorTexture) &&
+         (this->metallicRoughnessTexture == other.metallicRoughnessTexture) &&
+         Equals(this->baseColorFactor, other.baseColorFactor) &&
+         TINYGLTF_DOUBLE_EQUAL(this->metallicFactor, other.metallicFactor) &&
+         TINYGLTF_DOUBLE_EQUAL(this->roughnessFactor, other.roughnessFactor);
+}
+bool Value::operator==(const Value &other) const {
+  return Equals(*this, other);
+}
+
+static void swap4(unsigned int *val) {
+#ifdef TINYGLTF_LITTLE_ENDIAN
+  (void)val;
+#else
+  unsigned int tmp = *val;
+  unsigned char *dst = reinterpret_cast<unsigned char *>(val);
+  unsigned char *src = reinterpret_cast<unsigned char *>(&tmp);
+
+  dst[0] = src[3];
+  dst[1] = src[2];
+  dst[2] = src[1];
+  dst[3] = src[0];
+#endif
+}
+
+static std::string JoinPath(const std::string &path0,
+                            const std::string &path1) {
+  if (path0.empty()) {
+    return path1;
+  } else {
+    // check '/'
+    char lastChar = *path0.rbegin();
+    if (lastChar != '/') {
+      return path0 + std::string("/") + path1;
+    } else {
+      return path0 + path1;
+    }
+  }
+}
+
+static std::string FindFile(const std::vector<std::string> &paths,
+                            const std::string &filepath, FsCallbacks *fs) {
+  if (fs == nullptr || fs->ExpandFilePath == nullptr ||
+      fs->FileExists == nullptr) {
+    // Error, fs callback[s] missing
+    return std::string();
+  }
+
+  for (size_t i = 0; i < paths.size(); i++) {
+    std::string absPath =
+        fs->ExpandFilePath(JoinPath(paths[i], filepath), fs->user_data);
+    if (fs->FileExists(absPath, fs->user_data)) {
+      return absPath;
+    }
+  }
+
+  return std::string();
+}
+
+static std::string GetFilePathExtension(const std::string &FileName) {
+  if (FileName.find_last_of(".") != std::string::npos)
+    return FileName.substr(FileName.find_last_of(".") + 1);
+  return "";
+}
+
+static std::string GetBaseDir(const std::string &filepath) {
+  if (filepath.find_last_of("/\\") != std::string::npos)
+    return filepath.substr(0, filepath.find_last_of("/\\"));
+  return "";
+}
+
+// https://stackoverflow.com/questions/8520560/get-a-file-name-from-a-path
+static std::string GetBaseFilename(const std::string &filepath) {
+  return filepath.substr(filepath.find_last_of("/\\") + 1);
+}
+
+std::string base64_encode(unsigned char const *, unsigned int len);
+std::string base64_decode(std::string const &s);
+
+/*
+   base64.cpp and base64.h
+
+   Copyright (C) 2004-2008 René Nyffenegger
+
+   This source code is provided 'as-is', without any express or implied
+   warranty. In no event will the author be held liable for any damages
+   arising from the use of this software.
+
+   Permission is granted to anyone to use this software for any purpose,
+   including commercial applications, and to alter it and redistribute it
+   freely, subject to the following restrictions:
+
+   1. The origin of this source code must not be misrepresented; you must not
+      claim that you wrote the original source code. If you use this source code
+      in a product, an acknowledgment in the product documentation would be
+      appreciated but is not required.
+
+   2. Altered source versions must be plainly marked as such, and must not be
+      misrepresented as being the original source code.
+
+   3. This notice may not be removed or altered from any source distribution.
+
+   René Nyffenegger rene.nyffenegger@adp-gmbh.ch
+
+*/
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wsign-conversion"
+#pragma clang diagnostic ignored "-Wconversion"
+#endif
+
+static inline bool is_base64(unsigned char c) {
+  return (isalnum(c) || (c == '+') || (c == '/'));
+}
+
+std::string base64_encode(unsigned char const *bytes_to_encode,
+                          unsigned int in_len) {
+  std::string ret;
+  int i = 0;
+  int j = 0;
+  unsigned char char_array_3[3];
+  unsigned char char_array_4[4];
+
+  const char *base64_chars =
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+      "abcdefghijklmnopqrstuvwxyz"
+      "0123456789+/";
+
+  while (in_len--) {
+    char_array_3[i++] = *(bytes_to_encode++);
+    if (i == 3) {
+      char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
+      char_array_4[1] =
+          ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
+      char_array_4[2] =
+          ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
+      char_array_4[3] = char_array_3[2] & 0x3f;
+
+      for (i = 0; (i < 4); i++) ret += base64_chars[char_array_4[i]];
+      i = 0;
+    }
+  }
+
+  if (i) {
+    for (j = i; j < 3; j++) char_array_3[j] = '\0';
+
+    char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
+    char_array_4[1] =
+        ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
+    char_array_4[2] =
+        ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
+
+    for (j = 0; (j < i + 1); j++) ret += base64_chars[char_array_4[j]];
+
+    while ((i++ < 3)) ret += '=';
+  }
+
+  return ret;
+}
+
+std::string base64_decode(std::string const &encoded_string) {
+  int in_len = static_cast<int>(encoded_string.size());
+  int i = 0;
+  int j = 0;
+  int in_ = 0;
+  unsigned char char_array_4[4], char_array_3[3];
+  std::string ret;
+
+  const std::string base64_chars =
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+      "abcdefghijklmnopqrstuvwxyz"
+      "0123456789+/";
+
+  while (in_len-- && (encoded_string[in_] != '=') &&
+         is_base64(encoded_string[in_])) {
+    char_array_4[i++] = encoded_string[in_];
+    in_++;
+    if (i == 4) {
+      for (i = 0; i < 4; i++)
+        char_array_4[i] =
+            static_cast<unsigned char>(base64_chars.find(char_array_4[i]));
+
+      char_array_3[0] =
+          (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
+      char_array_3[1] =
+          ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
+      char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+
+      for (i = 0; (i < 3); i++) ret += char_array_3[i];
+      i = 0;
+    }
+  }
+
+  if (i) {
+    for (j = i; j < 4; j++) char_array_4[j] = 0;
+
+    for (j = 0; j < 4; j++)
+      char_array_4[j] =
+          static_cast<unsigned char>(base64_chars.find(char_array_4[j]));
+
+    char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
+    char_array_3[1] =
+        ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
+    char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+
+    for (j = 0; (j < i - 1); j++) ret += char_array_3[j];
+  }
+
+  return ret;
+}
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// https://github.com/syoyo/tinygltf/issues/228
+// TODO(syoyo): Use uriparser https://uriparser.github.io/ for stricter Uri
+// decoding?
+//
+// https://stackoverflow.com/questions/18307429/encode-decode-url-in-c
+// http://dlib.net/dlib/server/server_http.cpp.html
+
+// --- dlib beign ------------------------------------------------------------
+// Copyright (C) 2003  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+
+namespace dlib {
+
+#if 0
+        inline unsigned char to_hex( unsigned char x )
+        {
+            return x + (x > 9 ? ('A'-10) : '0');
+        }
+
+        const std::string urlencode( const std::string& s )
+        {
+            std::ostringstream os;
+
+            for ( std::string::const_iterator ci = s.begin(); ci != s.end(); ++ci )
+            {
+                if ( (*ci >= 'a' && *ci <= 'z') ||
+                     (*ci >= 'A' && *ci <= 'Z') ||
+                     (*ci >= '0' && *ci <= '9') )
+                { // allowed
+                    os << *ci;
+                }
+                else if ( *ci == ' ')
+                {
+                    os << '+';
+                }
+                else
+                {
+                    os << '%' << to_hex(static_cast<unsigned char>(*ci >> 4)) << to_hex(static_cast<unsigned char>(*ci % 16));
+                }
+            }
+
+            return os.str();
+        }
+#endif
+
+inline unsigned char from_hex(unsigned char ch) {
+  if (ch <= '9' && ch >= '0')
+    ch -= '0';
+  else if (ch <= 'f' && ch >= 'a')
+    ch -= 'a' - 10;
+  else if (ch <= 'F' && ch >= 'A')
+    ch -= 'A' - 10;
+  else
+    ch = 0;
+  return ch;
+}
+
+static const std::string urldecode(const std::string &str) {
+  using namespace std;
+  string result;
+  string::size_type i;
+  for (i = 0; i < str.size(); ++i) {
+    if (str[i] == '+') {
+      result += ' ';
+    } else if (str[i] == '%' && str.size() > i + 2) {
+      const unsigned char ch1 =
+          from_hex(static_cast<unsigned char>(str[i + 1]));
+      const unsigned char ch2 =
+          from_hex(static_cast<unsigned char>(str[i + 2]));
+      const unsigned char ch = static_cast<unsigned char>((ch1 << 4) | ch2);
+      result += static_cast<char>(ch);
+      i += 2;
+    } else {
+      result += str[i];
+    }
+  }
+  return result;
+}
+
+}  // namespace dlib
+// --- dlib end --------------------------------------------------------------
+
+static bool LoadExternalFile(std::vector<unsigned char> *out, std::string *err,
+                             std::string *warn, const std::string &filename,
+                             const std::string &basedir, bool required,
+                             size_t reqBytes, bool checkSize, FsCallbacks *fs) {
+  if (fs == nullptr || fs->FileExists == nullptr ||
+      fs->ExpandFilePath == nullptr || fs->ReadWholeFile == nullptr) {
+    // This is a developer error, assert() ?
+    if (err) {
+      (*err) += "FS callback[s] not set\n";
+    }
+    return false;
+  }
+
+  std::string *failMsgOut = required ? err : warn;
+
+  out->clear();
+
+  std::vector<std::string> paths;
+  paths.push_back(basedir);
+  paths.push_back(".");
+
+  std::string filepath = FindFile(paths, filename, fs);
+  if (filepath.empty() || filename.empty()) {
+    if (failMsgOut) {
+      (*failMsgOut) += "File not found : " + filename + "\n";
+    }
+    return false;
+  }
+
+  std::vector<unsigned char> buf;
+  std::string fileReadErr;
+  bool fileRead =
+      fs->ReadWholeFile(&buf, &fileReadErr, filepath, fs->user_data);
+  if (!fileRead) {
+    if (failMsgOut) {
+      (*failMsgOut) +=
+          "File read error : " + filepath + " : " + fileReadErr + "\n";
+    }
+    return false;
+  }
+
+  size_t sz = buf.size();
+  if (sz == 0) {
+    if (failMsgOut) {
+      (*failMsgOut) += "File is empty : " + filepath + "\n";
+    }
+    return false;
+  }
+
+  if (checkSize) {
+    if (reqBytes == sz) {
+      out->swap(buf);
+      return true;
+    } else {
+      std::stringstream ss;
+      ss << "File size mismatch : " << filepath << ", requestedBytes "
+         << reqBytes << ", but got " << sz << std::endl;
+      if (failMsgOut) {
+        (*failMsgOut) += ss.str();
+      }
+      return false;
+    }
+  }
+
+  out->swap(buf);
+  return true;
+}
+
+void TinyGLTF::SetImageLoader(LoadImageDataFunction func, void *user_data) {
+  LoadImageData = func;
+  load_image_user_data_ = user_data;
+}
+
+#ifndef TINYGLTF_NO_STB_IMAGE
+bool LoadImageData(Image *image, const int image_idx, std::string *err,
+                   std::string *warn, int req_width, int req_height,
+                   const unsigned char *bytes, int size, void *user_data) {
+  (void)user_data;
+  (void)warn;
+
+  int w = 0, h = 0, comp = 0, req_comp = 0;
+
+  unsigned char *data = nullptr;
+
+  // force 32-bit textures for common Vulkan compatibility. It appears that
+  // some GPU drivers do not support 24-bit images for Vulkan
+  req_comp = 4;
+  int bits = 8;
+  int pixel_type = TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE;
+
+  // It is possible that the image we want to load is a 16bit per channel image
+  // We are going to attempt to load it as 16bit per channel, and if it worked,
+  // set the image data accodingly. We are casting the returned pointer into
+  // unsigned char, because we are representing "bytes". But we are updating
+  // the Image metadata to signal that this image uses 2 bytes (16bits) per
+  // channel:
+  if (stbi_is_16_bit_from_memory(bytes, size)) {
+    data = reinterpret_cast<unsigned char *>(
+        stbi_load_16_from_memory(bytes, size, &w, &h, &comp, req_comp));
+    if (data) {
+      bits = 16;
+      pixel_type = TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT;
+    }
+  }
+
+  // at this point, if data is still NULL, it means that the image wasn't
+  // 16bit per channel, we are going to load it as a normal 8bit per channel
+  // mage as we used to do:
+  // if image cannot be decoded, ignore parsing and keep it by its path
+  // don't break in this case
+  // FIXME we should only enter this function if the image is embedded. If
+  // image->uri references
+  // an image file, it should be left as it is. Image loading should not be
+  // mandatory (to support other formats)
+  if (!data) data = stbi_load_from_memory(bytes, size, &w, &h, &comp, req_comp);
+  if (!data) {
+    // NOTE: you can use `warn` instead of `err`
+    if (err) {
+      (*err) +=
+          "Unknown image format. STB cannot decode image data for image[" +
+          std::to_string(image_idx) + "] name = \"" + image->name + "\".\n";
+    }
+    return false;
+  }
+
+  if ((w < 1) || (h < 1)) {
+    stbi_image_free(data);
+    if (err) {
+      (*err) += "Invalid image data for image[" + std::to_string(image_idx) +
+                "] name = \"" + image->name + "\"\n";
+    }
+    return false;
+  }
+
+  if (req_width > 0) {
+    if (req_width != w) {
+      stbi_image_free(data);
+      if (err) {
+        (*err) += "Image width mismatch for image[" +
+                  std::to_string(image_idx) + "] name = \"" + image->name +
+                  "\"\n";
+      }
+      return false;
+    }
+  }
+
+  if (req_height > 0) {
+    if (req_height != h) {
+      stbi_image_free(data);
+      if (err) {
+        (*err) += "Image height mismatch. for image[" +
+                  std::to_string(image_idx) + "] name = \"" + image->name +
+                  "\"\n";
+      }
+      return false;
+    }
+  }
+
+  image->width = w;
+  image->height = h;
+  image->component = req_comp;
+  image->bits = bits;
+  image->pixel_type = pixel_type;
+  image->image.resize(static_cast<size_t>(w * h * req_comp) * size_t(bits / 8));
+  std::copy(data, data + w * h * req_comp * (bits / 8), image->image.begin());
+  stbi_image_free(data);
+
+  return true;
+}
+#endif
+
+void TinyGLTF::SetImageWriter(WriteImageDataFunction func, void *user_data) {
+  WriteImageData = func;
+  write_image_user_data_ = user_data;
+}
+
+#ifndef TINYGLTF_NO_STB_IMAGE_WRITE
+static void WriteToMemory_stbi(void *context, void *data, int size) {
+  std::vector<unsigned char> *buffer =
+      reinterpret_cast<std::vector<unsigned char> *>(context);
+
+  unsigned char *pData = reinterpret_cast<unsigned char *>(data);
+
+  buffer->insert(buffer->end(), pData, pData + size);
+}
+
+bool WriteImageData(const std::string *basepath, const std::string *filename,
+                    Image *image, bool embedImages, void *fsPtr) {
+  const std::string ext = GetFilePathExtension(*filename);
+
+  // Write image to temporary buffer
+  std::string header;
+  std::vector<unsigned char> data;
+
+  if (ext == "png") {
+    if ((image->bits != 8) ||
+        (image->pixel_type != TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE)) {
+      // Unsupported pixel format
+      return false;
+    }
+
+    if (!stbi_write_png_to_func(WriteToMemory_stbi, &data, image->width,
+                                image->height, image->component,
+                                &image->image[0], 0)) {
+      return false;
+    }
+    header = "data:image/png;base64,";
+  } else if (ext == "jpg") {
+    if (!stbi_write_jpg_to_func(WriteToMemory_stbi, &data, image->width,
+                                image->height, image->component,
+                                &image->image[0], 100)) {
+      return false;
+    }
+    header = "data:image/jpeg;base64,";
+  } else if (ext == "bmp") {
+    if (!stbi_write_bmp_to_func(WriteToMemory_stbi, &data, image->width,
+                                image->height, image->component,
+                                &image->image[0])) {
+      return false;
+    }
+    header = "data:image/bmp;base64,";
+  } else if (!embedImages) {
+    // Error: can't output requested format to file
+    return false;
+  }
+
+  if (embedImages) {
+    // Embed base64-encoded image into URI
+    if (data.size()) {
+      image->uri =
+          header +
+          base64_encode(&data[0], static_cast<unsigned int>(data.size()));
+    } else {
+      // Throw error?
+    }
+  } else {
+    // Write image to disc
+    FsCallbacks *fs = reinterpret_cast<FsCallbacks *>(fsPtr);
+    if ((fs != nullptr) && (fs->WriteWholeFile != nullptr)) {
+      const std::string imagefilepath = JoinPath(*basepath, *filename);
+      std::string writeError;
+      if (!fs->WriteWholeFile(&writeError, imagefilepath, data,
+                              fs->user_data)) {
+        // Could not write image file to disc; Throw error ?
+        return false;
+      }
+    } else {
+      // Throw error?
+    }
+    image->uri = *filename;
+  }
+
+  return true;
+}
+#endif
+
+void TinyGLTF::SetFsCallbacks(FsCallbacks callbacks) { fs = callbacks; }
+
+#ifdef _WIN32
+static inline std::wstring UTF8ToWchar(const std::string &str) {
+  int wstr_size =
+      MultiByteToWideChar(CP_UTF8, 0, str.data(), (int)str.size(), nullptr, 0);
+  std::wstring wstr(wstr_size, 0);
+  MultiByteToWideChar(CP_UTF8, 0, str.data(), (int)str.size(), &wstr[0],
+                      (int)wstr.size());
+  return wstr;
+}
+
+static inline std::string WcharToUTF8(const std::wstring &wstr) {
+  int str_size = WideCharToMultiByte(CP_UTF8, 0, wstr.data(), (int)wstr.size(),
+                                     nullptr, 0, NULL, NULL);
+  std::string str(str_size, 0);
+  WideCharToMultiByte(CP_UTF8, 0, wstr.data(), (int)wstr.size(), &str[0],
+                      (int)str.size(), NULL, NULL);
+  return str;
+}
+#endif
+
+#ifndef TINYGLTF_NO_FS
+// Default implementations of filesystem functions
+
+bool FileExists(const std::string &abs_filename, void *) {
+  bool ret;
+#ifdef TINYGLTF_ANDROID_LOAD_FROM_ASSETS
+  if (asset_manager) {
+    AAsset *asset = AAssetManager_open(asset_manager, abs_filename.c_str(),
+                                       AASSET_MODE_STREAMING);
+    if (!asset) {
+      return false;
+    }
+    AAsset_close(asset);
+    ret = true;
+  } else {
+    return false;
+  }
+#else
+#ifdef _WIN32
+#if defined(_MSC_VER) || defined(__GLIBCXX__)
+  FILE *fp = nullptr;
+  errno_t err = _wfopen_s(&fp, UTF8ToWchar(abs_filename).c_str(), L"rb");
+  if (err != 0) {
+    return false;
+  }
+#else
+  FILE *fp = nullptr;
+  errno_t err = fopen_s(&fp, abs_filename.c_str(), "rb");
+  if (err != 0) {
+    return false;
+  }
+#endif
+
+#else
+  FILE *fp = fopen(abs_filename.c_str(), "rb");
+#endif
+  if (fp) {
+    ret = true;
+    fclose(fp);
+  } else {
+    ret = false;
+  }
+#endif
+
+  return ret;
+}
+
+std::string ExpandFilePath(const std::string &filepath, void *) {
+#ifdef _WIN32
+  // Assume input `filepath` is encoded in UTF-8
+  std::wstring wfilepath = UTF8ToWchar(filepath);
+  DWORD wlen = ExpandEnvironmentStringsW(wfilepath.c_str(), nullptr, 0);
+  wchar_t *wstr = new wchar_t[wlen];
+  ExpandEnvironmentStringsW(wfilepath.c_str(), wstr, wlen);
+
+  std::wstring ws(wstr);
+  delete[] wstr;
+  return WcharToUTF8(ws);
+
+#else
+
+#if defined(TARGET_OS_IPHONE) || defined(TARGET_IPHONE_SIMULATOR) || \
+    defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__sh__)
+  // no expansion
+  std::string s = filepath;
+#else
+  std::string s;
+  wordexp_t p;
+
+  if (filepath.empty()) {
+    return "";
+  }
+
+  // Quote the string to keep any spaces in filepath intact.
+  std::string quoted_path = "\"" + filepath + "\"";
+  // char** w;
+  int ret = wordexp(quoted_path.c_str(), &p, 0);
+  if (ret) {
+    // err
+    s = filepath;
+    return s;
+  }
+
+  // Use first element only.
+  if (p.we_wordv) {
+    s = std::string(p.we_wordv[0]);
+    wordfree(&p);
+  } else {
+    s = filepath;
+  }
+
+#endif
+
+  return s;
+#endif
+}
+
+bool ReadWholeFile(std::vector<unsigned char> *out, std::string *err,
+                   const std::string &filepath, void *) {
+#ifdef TINYGLTF_ANDROID_LOAD_FROM_ASSETS
+  if (asset_manager) {
+    AAsset *asset = AAssetManager_open(asset_manager, filepath.c_str(),
+                                       AASSET_MODE_STREAMING);
+    if (!asset) {
+      if (err) {
+        (*err) += "File open error : " + filepath + "\n";
+      }
+      return false;
+    }
+    size_t size = AAsset_getLength(asset);
+    if (size == 0) {
+      if (err) {
+        (*err) += "Invalid file size : " + filepath +
+                  " (does the path point to a directory?)";
+      }
+      return false;
+    }
+    out->resize(size);
+    AAsset_read(asset, reinterpret_cast<char *>(&out->at(0)), size);
+    AAsset_close(asset);
+    return true;
+  } else {
+    if (err) {
+      (*err) += "No asset manager specified : " + filepath + "\n";
+    }
+    return false;
+  }
+#else
+#ifdef _WIN32
+#if defined(__GLIBCXX__)  // mingw
+  int file_descriptor =
+      _wopen(UTF8ToWchar(filepath).c_str(), _O_RDONLY | _O_BINARY);
+  __gnu_cxx::stdio_filebuf<char> wfile_buf(file_descriptor, std::ios_base::in);
+  std::istream f(&wfile_buf);
+#elif defined(_MSC_VER) || defined(_LIBCPP_VERSION)
+  // For libcxx, assume _LIBCPP_HAS_OPEN_WITH_WCHAR is defined to accept
+  // `wchar_t *`
+  std::ifstream f(UTF8ToWchar(filepath).c_str(), std::ifstream::binary);
+#else
+  // Unknown compiler/runtime
+  std::ifstream f(filepath.c_str(), std::ifstream::binary);
+#endif
+#else
+  std::ifstream f(filepath.c_str(), std::ifstream::binary);
+#endif
+  if (!f) {
+    if (err) {
+      (*err) += "File open error : " + filepath + "\n";
+    }
+    return false;
+  }
+
+  f.seekg(0, f.end);
+  size_t sz = static_cast<size_t>(f.tellg());
+  f.seekg(0, f.beg);
+
+  if (int64_t(sz) < 0) {
+    if (err) {
+      (*err) += "Invalid file size : " + filepath +
+                " (does the path point to a directory?)";
+    }
+    return false;
+  } else if (sz == 0) {
+    if (err) {
+      (*err) += "File is empty : " + filepath + "\n";
+    }
+    return false;
+  }
+
+  out->resize(sz);
+  f.read(reinterpret_cast<char *>(&out->at(0)),
+         static_cast<std::streamsize>(sz));
+
+  return true;
+#endif
+}
+
+bool WriteWholeFile(std::string *err, const std::string &filepath,
+                    const std::vector<unsigned char> &contents, void *) {
+#ifdef _WIN32
+#if defined(__GLIBCXX__)  // mingw
+  int file_descriptor = _wopen(UTF8ToWchar(filepath).c_str(),
+                               _O_CREAT | _O_WRONLY | _O_TRUNC | _O_BINARY);
+  __gnu_cxx::stdio_filebuf<char> wfile_buf(
+      file_descriptor, std::ios_base::out | std::ios_base::binary);
+  std::ostream f(&wfile_buf);
+#elif defined(_MSC_VER)
+  std::ofstream f(UTF8ToWchar(filepath).c_str(), std::ofstream::binary);
+#else  // clang?
+  std::ofstream f(filepath.c_str(), std::ofstream::binary);
+#endif
+#else
+  std::ofstream f(filepath.c_str(), std::ofstream::binary);
+#endif
+  if (!f) {
+    if (err) {
+      (*err) += "File open error for writing : " + filepath + "\n";
+    }
+    return false;
+  }
+
+  f.write(reinterpret_cast<const char *>(&contents.at(0)),
+          static_cast<std::streamsize>(contents.size()));
+  if (!f) {
+    if (err) {
+      (*err) += "File write error: " + filepath + "\n";
+    }
+    return false;
+  }
+
+  return true;
+}
+
+#endif  // TINYGLTF_NO_FS
+
+static std::string MimeToExt(const std::string &mimeType) {
+  if (mimeType == "image/jpeg") {
+    return "jpg";
+  } else if (mimeType == "image/png") {
+    return "png";
+  } else if (mimeType == "image/bmp") {
+    return "bmp";
+  } else if (mimeType == "image/gif") {
+    return "gif";
+  }
+
+  return "";
+}
+
+static void UpdateImageObject(Image &image, std::string &baseDir, int index,
+                              bool embedImages,
+                              WriteImageDataFunction *WriteImageData = nullptr,
+                              void *user_data = nullptr) {
+  std::string filename;
+  std::string ext;
+  // If image has uri, use it it as a filename
+  if (image.uri.size()) {
+    filename = GetBaseFilename(image.uri);
+    ext = GetFilePathExtension(filename);
+  } else if (image.bufferView != -1) {
+    // If there's no URI and the data exists in a buffer,
+    // don't change properties or write images
+  } else if (image.name.size()) {
+    ext = MimeToExt(image.mimeType);
+    // Otherwise use name as filename
+    filename = image.name + "." + ext;
+  } else {
+    ext = MimeToExt(image.mimeType);
+    // Fallback to index of image as filename
+    filename = std::to_string(index) + "." + ext;
+  }
+
+  // If callback is set, modify image data object
+  if (*WriteImageData != nullptr && !filename.empty()) {
+    std::string uri;
+    (*WriteImageData)(&baseDir, &filename, &image, embedImages, user_data);
+  }
+}
+
+bool IsDataURI(const std::string &in) {
+  std::string header = "data:application/octet-stream;base64,";
+  if (in.find(header) == 0) {
+    return true;
+  }
+
+  header = "data:image/jpeg;base64,";
+  if (in.find(header) == 0) {
+    return true;
+  }
+
+  header = "data:image/png;base64,";
+  if (in.find(header) == 0) {
+    return true;
+  }
+
+  header = "data:image/bmp;base64,";
+  if (in.find(header) == 0) {
+    return true;
+  }
+
+  header = "data:image/gif;base64,";
+  if (in.find(header) == 0) {
+    return true;
+  }
+
+  header = "data:text/plain;base64,";
+  if (in.find(header) == 0) {
+    return true;
+  }
+
+  header = "data:application/gltf-buffer;base64,";
+  if (in.find(header) == 0) {
+    return true;
+  }
+
+  return false;
+}
+
+bool DecodeDataURI(std::vector<unsigned char> *out, std::string &mime_type,
+                   const std::string &in, size_t reqBytes, bool checkSize) {
+  std::string header = "data:application/octet-stream;base64,";
+  std::string data;
+  if (in.find(header) == 0) {
+    data = base64_decode(in.substr(header.size()));  // cut mime string.
+  }
+
+  if (data.empty()) {
+    header = "data:image/jpeg;base64,";
+    if (in.find(header) == 0) {
+      mime_type = "image/jpeg";
+      data = base64_decode(in.substr(header.size()));  // cut mime string.
+    }
+  }
+
+  if (data.empty()) {
+    header = "data:image/png;base64,";
+    if (in.find(header) == 0) {
+      mime_type = "image/png";
+      data = base64_decode(in.substr(header.size()));  // cut mime string.
+    }
+  }
+
+  if (data.empty()) {
+    header = "data:image/bmp;base64,";
+    if (in.find(header) == 0) {
+      mime_type = "image/bmp";
+      data = base64_decode(in.substr(header.size()));  // cut mime string.
+    }
+  }
+
+  if (data.empty()) {
+    header = "data:image/gif;base64,";
+    if (in.find(header) == 0) {
+      mime_type = "image/gif";
+      data = base64_decode(in.substr(header.size()));  // cut mime string.
+    }
+  }
+
+  if (data.empty()) {
+    header = "data:text/plain;base64,";
+    if (in.find(header) == 0) {
+      mime_type = "text/plain";
+      data = base64_decode(in.substr(header.size()));
+    }
+  }
+
+  if (data.empty()) {
+    header = "data:application/gltf-buffer;base64,";
+    if (in.find(header) == 0) {
+      data = base64_decode(in.substr(header.size()));
+    }
+  }
+
+  // TODO(syoyo): Allow empty buffer? #229
+  if (data.empty()) {
+    return false;
+  }
+
+  if (checkSize) {
+    if (data.size() != reqBytes) {
+      return false;
+    }
+    out->resize(reqBytes);
+  } else {
+    out->resize(data.size());
+  }
+  std::copy(data.begin(), data.end(), out->begin());
+  return true;
+}
+
+namespace {
+bool GetInt(const json &o, int &val) {
+#ifdef TINYGLTF_USE_RAPIDJSON
+  if (!o.IsDouble()) {
+    if (o.IsInt()) {
+      val = o.GetInt();
+      return true;
+    } else if (o.IsUint()) {
+      val = static_cast<int>(o.GetUint());
+      return true;
+    } else if (o.IsInt64()) {
+      val = static_cast<int>(o.GetInt64());
+      return true;
+    } else if (o.IsUint64()) {
+      val = static_cast<int>(o.GetUint64());
+      return true;
+    }
+  }
+
+  return false;
+#else
+  auto type = o.type();
+
+  if ((type == json::value_t::number_integer) ||
+      (type == json::value_t::number_unsigned)) {
+    val = static_cast<int>(o.get<int64_t>());
+    return true;
+  }
+
+  return false;
+#endif
+}
+
+#ifdef TINYGLTF_USE_RAPIDJSON
+bool GetDouble(const json &o, double &val) {
+  if (o.IsDouble()) {
+    val = o.GetDouble();
+    return true;
+  }
+
+  return false;
+}
+#endif
+
+bool GetNumber(const json &o, double &val) {
+#ifdef TINYGLTF_USE_RAPIDJSON
+  if (o.IsNumber()) {
+    val = o.GetDouble();
+    return true;
+  }
+
+  return false;
+#else
+  if (o.is_number()) {
+    val = o.get<double>();
+    return true;
+  }
+
+  return false;
+#endif
+}
+
+bool GetString(const json &o, std::string &val) {
+#ifdef TINYGLTF_USE_RAPIDJSON
+  if (o.IsString()) {
+    val = o.GetString();
+    return true;
+  }
+
+  return false;
+#else
+  if (o.type() == json::value_t::string) {
+    val = o.get<std::string>();
+    return true;
+  }
+
+  return false;
+#endif
+}
+
+bool IsArray(const json &o) {
+#ifdef TINYGLTF_USE_RAPIDJSON
+  return o.IsArray();
+#else
+  return o.is_array();
+#endif
+}
+
+json_const_array_iterator ArrayBegin(const json &o) {
+#ifdef TINYGLTF_USE_RAPIDJSON
+  return o.Begin();
+#else
+  return o.begin();
+#endif
+}
+
+json_const_array_iterator ArrayEnd(const json &o) {
+#ifdef TINYGLTF_USE_RAPIDJSON
+  return o.End();
+#else
+  return o.end();
+#endif
+}
+
+bool IsObject(const json &o) {
+#ifdef TINYGLTF_USE_RAPIDJSON
+  return o.IsObject();
+#else
+  return o.is_object();
+#endif
+}
+
+json_const_iterator ObjectBegin(const json &o) {
+#ifdef TINYGLTF_USE_RAPIDJSON
+  return o.MemberBegin();
+#else
+  return o.begin();
+#endif
+}
+
+json_const_iterator ObjectEnd(const json &o) {
+#ifdef TINYGLTF_USE_RAPIDJSON
+  return o.MemberEnd();
+#else
+  return o.end();
+#endif
+}
+
+// Making this a const char* results in a pointer to a temporary when
+// TINYGLTF_USE_RAPIDJSON is off.
+std::string GetKey(json_const_iterator &it) {
+#ifdef TINYGLTF_USE_RAPIDJSON
+  return it->name.GetString();
+#else
+  return it.key().c_str();
+#endif
+}
+
+bool FindMember(const json &o, const char *member, json_const_iterator &it) {
+#ifdef TINYGLTF_USE_RAPIDJSON
+  if (!o.IsObject()) {
+    return false;
+  }
+  it = o.FindMember(member);
+  return it != o.MemberEnd();
+#else
+  it = o.find(member);
+  return it != o.end();
+#endif
+}
+
+const json &GetValue(json_const_iterator &it) {
+#ifdef TINYGLTF_USE_RAPIDJSON
+  return it->value;
+#else
+  return it.value();
+#endif
+}
+
+std::string JsonToString(const json &o, int spacing = -1) {
+#ifdef TINYGLTF_USE_RAPIDJSON
+  using namespace rapidjson;
+  StringBuffer buffer;
+  if (spacing == -1) {
+    Writer<StringBuffer> writer(buffer);
+    o.Accept(writer);
+  } else {
+    PrettyWriter<StringBuffer> writer(buffer);
+    writer.SetIndent(' ', uint32_t(spacing));
+    o.Accept(writer);
+  }
+  return buffer.GetString();
+#else
+  return o.dump(spacing);
+#endif
+}
+
+}  // namespace
+
+static bool ParseJsonAsValue(Value *ret, const json &o) {
+  Value val{};
+#ifdef TINYGLTF_USE_RAPIDJSON
+  using rapidjson::Type;
+  switch (o.GetType()) {
+    case Type::kObjectType: {
+      Value::Object value_object;
+      for (auto it = o.MemberBegin(); it != o.MemberEnd(); ++it) {
+        Value entry;
+        ParseJsonAsValue(&entry, it->value);
+        if (entry.Type() != NULL_TYPE)
+          value_object.emplace(GetKey(it), std::move(entry));
+      }
+      if (value_object.size() > 0) val = Value(std::move(value_object));
+    } break;
+    case Type::kArrayType: {
+      Value::Array value_array;
+      value_array.reserve(o.Size());
+      for (auto it = o.Begin(); it != o.End(); ++it) {
+        Value entry;
+        ParseJsonAsValue(&entry, *it);
+        if (entry.Type() != NULL_TYPE)
+          value_array.emplace_back(std::move(entry));
+      }
+      if (value_array.size() > 0) val = Value(std::move(value_array));
+    } break;
+    case Type::kStringType:
+      val = Value(std::string(o.GetString()));
+      break;
+    case Type::kFalseType:
+    case Type::kTrueType:
+      val = Value(o.GetBool());
+      break;
+    case Type::kNumberType:
+      if (!o.IsDouble()) {
+        int i = 0;
+        GetInt(o, i);
+        val = Value(i);
+      } else {
+        double d = 0.0;
+        GetDouble(o, d);
+        val = Value(d);
+      }
+      break;
+    case Type::kNullType:
+      break;
+      // all types are covered, so no `case default`
+  }
+#else
+  switch (o.type()) {
+    case json::value_t::object: {
+      Value::Object value_object;
+      for (auto it = o.begin(); it != o.end(); it++) {
+        Value entry;
+        ParseJsonAsValue(&entry, it.value());
+        if (entry.Type() != NULL_TYPE)
+          value_object.emplace(it.key(), std::move(entry));
+      }
+      if (value_object.size() > 0) val = Value(std::move(value_object));
+    } break;
+    case json::value_t::array: {
+      Value::Array value_array;
+      value_array.reserve(o.size());
+      for (auto it = o.begin(); it != o.end(); it++) {
+        Value entry;
+        ParseJsonAsValue(&entry, it.value());
+        if (entry.Type() != NULL_TYPE)
+          value_array.emplace_back(std::move(entry));
+      }
+      if (value_array.size() > 0) val = Value(std::move(value_array));
+    } break;
+    case json::value_t::string:
+      val = Value(o.get<std::string>());
+      break;
+    case json::value_t::boolean:
+      val = Value(o.get<bool>());
+      break;
+    case json::value_t::number_integer:
+    case json::value_t::number_unsigned:
+      val = Value(static_cast<int>(o.get<int64_t>()));
+      break;
+    case json::value_t::number_float:
+      val = Value(o.get<double>());
+      break;
+    case json::value_t::null:
+    case json::value_t::discarded:
+      // default:
+      break;
+  }
+#endif
+  if (ret) *ret = std::move(val);
+
+  return val.Type() != NULL_TYPE;
+}
+
+static bool ParseExtrasProperty(Value *ret, const json &o) {
+  json_const_iterator it;
+  if (!FindMember(o, "extras", it)) {
+    return false;
+  }
+
+  return ParseJsonAsValue(ret, GetValue(it));
+}
+
+static bool ParseBooleanProperty(bool *ret, std::string *err, const json &o,
+                                 const std::string &property,
+                                 const bool required,
+                                 const std::string &parent_node = "") {
+  json_const_iterator it;
+  if (!FindMember(o, property.c_str(), it)) {
+    if (required) {
+      if (err) {
+        (*err) += "'" + property + "' property is missing";
+        if (!parent_node.empty()) {
+          (*err) += " in " + parent_node;
+        }
+        (*err) += ".\n";
+      }
+    }
+    return false;
+  }
+
+  auto &value = GetValue(it);
+
+  bool isBoolean;
+  bool boolValue = false;
+#ifdef TINYGLTF_USE_RAPIDJSON
+  isBoolean = value.IsBool();
+  if (isBoolean) {
+    boolValue = value.GetBool();
+  }
+#else
+  isBoolean = value.is_boolean();
+  if (isBoolean) {
+    boolValue = value.get<bool>();
+  }
+#endif
+  if (!isBoolean) {
+    if (required) {
+      if (err) {
+        (*err) += "'" + property + "' property is not a bool type.\n";
+      }
+    }
+    return false;
+  }
+
+  if (ret) {
+    (*ret) = boolValue;
+  }
+
+  return true;
+}
+
+static bool ParseIntegerProperty(int *ret, std::string *err, const json &o,
+                                 const std::string &property,
+                                 const bool required,
+                                 const std::string &parent_node = "") {
+  json_const_iterator it;
+  if (!FindMember(o, property.c_str(), it)) {
+    if (required) {
+      if (err) {
+        (*err) += "'" + property + "' property is missing";
+        if (!parent_node.empty()) {
+          (*err) += " in " + parent_node;
+        }
+        (*err) += ".\n";
+      }
+    }
+    return false;
+  }
+
+  int intValue;
+  bool isInt = GetInt(GetValue(it), intValue);
+  if (!isInt) {
+    if (required) {
+      if (err) {
+        (*err) += "'" + property + "' property is not an integer type.\n";
+      }
+    }
+    return false;
+  }
+
+  if (ret) {
+    (*ret) = intValue;
+  }
+
+  return true;
+}
+
+static bool ParseUnsignedProperty(size_t *ret, std::string *err, const json &o,
+                                  const std::string &property,
+                                  const bool required,
+                                  const std::string &parent_node = "") {
+  json_const_iterator it;
+  if (!FindMember(o, property.c_str(), it)) {
+    if (required) {
+      if (err) {
+        (*err) += "'" + property + "' property is missing";
+        if (!parent_node.empty()) {
+          (*err) += " in " + parent_node;
+        }
+        (*err) += ".\n";
+      }
+    }
+    return false;
+  }
+
+  auto &value = GetValue(it);
+
+  size_t uValue = 0;
+  bool isUValue;
+#ifdef TINYGLTF_USE_RAPIDJSON
+  isUValue = false;
+  if (value.IsUint()) {
+    uValue = value.GetUint();
+    isUValue = true;
+  } else if (value.IsUint64()) {
+    uValue = value.GetUint64();
+    isUValue = true;
+  }
+#else
+  isUValue = value.is_number_unsigned();
+  if (isUValue) {
+    uValue = value.get<size_t>();
+  }
+#endif
+  if (!isUValue) {
+    if (required) {
+      if (err) {
+        (*err) += "'" + property + "' property is not a positive integer.\n";
+      }
+    }
+    return false;
+  }
+
+  if (ret) {
+    (*ret) = uValue;
+  }
+
+  return true;
+}
+
+static bool ParseNumberProperty(double *ret, std::string *err, const json &o,
+                                const std::string &property,
+                                const bool required,
+                                const std::string &parent_node = "") {
+  json_const_iterator it;
+
+  if (!FindMember(o, property.c_str(), it)) {
+    if (required) {
+      if (err) {
+        (*err) += "'" + property + "' property is missing";
+        if (!parent_node.empty()) {
+          (*err) += " in " + parent_node;
+        }
+        (*err) += ".\n";
+      }
+    }
+    return false;
+  }
+
+  double numberValue;
+  bool isNumber = GetNumber(GetValue(it), numberValue);
+
+  if (!isNumber) {
+    if (required) {
+      if (err) {
+        (*err) += "'" + property + "' property is not a number type.\n";
+      }
+    }
+    return false;
+  }
+
+  if (ret) {
+    (*ret) = numberValue;
+  }
+
+  return true;
+}
+
+static bool ParseNumberArrayProperty(std::vector<double> *ret, std::string *err,
+                                     const json &o, const std::string &property,
+                                     bool required,
+                                     const std::string &parent_node = "") {
+  json_const_iterator it;
+  if (!FindMember(o, property.c_str(), it)) {
+    if (required) {
+      if (err) {
+        (*err) += "'" + property + "' property is missing";
+        if (!parent_node.empty()) {
+          (*err) += " in " + parent_node;
+        }
+        (*err) += ".\n";
+      }
+    }
+    return false;
+  }
+
+  if (!IsArray(GetValue(it))) {
+    if (required) {
+      if (err) {
+        (*err) += "'" + property + "' property is not an array";
+        if (!parent_node.empty()) {
+          (*err) += " in " + parent_node;
+        }
+        (*err) += ".\n";
+      }
+    }
+    return false;
+  }
+
+  ret->clear();
+  auto end = ArrayEnd(GetValue(it));
+  for (auto i = ArrayBegin(GetValue(it)); i != end; ++i) {
+    double numberValue;
+    const bool isNumber = GetNumber(*i, numberValue);
+    if (!isNumber) {
+      if (required) {
+        if (err) {
+          (*err) += "'" + property + "' property is not a number.\n";
+          if (!parent_node.empty()) {
+            (*err) += " in " + parent_node;
+          }
+          (*err) += ".\n";
+        }
+      }
+      return false;
+    }
+    ret->push_back(numberValue);
+  }
+
+  return true;
+}
+
+static bool ParseIntegerArrayProperty(std::vector<int> *ret, std::string *err,
+                                      const json &o,
+                                      const std::string &property,
+                                      bool required,
+                                      const std::string &parent_node = "") {
+  json_const_iterator it;
+  if (!FindMember(o, property.c_str(), it)) {
+    if (required) {
+      if (err) {
+        (*err) += "'" + property + "' property is missing";
+        if (!parent_node.empty()) {
+          (*err) += " in " + parent_node;
+        }
+        (*err) += ".\n";
+      }
+    }
+    return false;
+  }
+
+  if (!IsArray(GetValue(it))) {
+    if (required) {
+      if (err) {
+        (*err) += "'" + property + "' property is not an array";
+        if (!parent_node.empty()) {
+          (*err) += " in " + parent_node;
+        }
+        (*err) += ".\n";
+      }
+    }
+    return false;
+  }
+
+  ret->clear();
+  auto end = ArrayEnd(GetValue(it));
+  for (auto i = ArrayBegin(GetValue(it)); i != end; ++i) {
+    int numberValue;
+    bool isNumber = GetInt(*i, numberValue);
+    if (!isNumber) {
+      if (required) {
+        if (err) {
+          (*err) += "'" + property + "' property is not an integer type.\n";
+          if (!parent_node.empty()) {
+            (*err) += " in " + parent_node;
+          }
+          (*err) += ".\n";
+        }
+      }
+      return false;
+    }
+    ret->push_back(numberValue);
+  }
+
+  return true;
+}
+
+static bool ParseStringProperty(
+    std::string *ret, std::string *err, const json &o,
+    const std::string &property, bool required,
+    const std::string &parent_node = std::string()) {
+  json_const_iterator it;
+  if (!FindMember(o, property.c_str(), it)) {
+    if (required) {
+      if (err) {
+        (*err) += "'" + property + "' property is missing";
+        if (parent_node.empty()) {
+          (*err) += ".\n";
+        } else {
+          (*err) += " in `" + parent_node + "'.\n";
+        }
+      }
+    }
+    return false;
+  }
+
+  std::string strValue;
+  if (!GetString(GetValue(it), strValue)) {
+    if (required) {
+      if (err) {
+        (*err) += "'" + property + "' property is not a string type.\n";
+      }
+    }
+    return false;
+  }
+
+  if (ret) {
+    (*ret) = std::move(strValue);
+  }
+
+  return true;
+}
+
+static bool ParseStringIntegerProperty(std::map<std::string, int> *ret,
+                                       std::string *err, const json &o,
+                                       const std::string &property,
+                                       bool required,
+                                       const std::string &parent = "") {
+  json_const_iterator it;
+  if (!FindMember(o, property.c_str(), it)) {
+    if (required) {
+      if (err) {
+        if (!parent.empty()) {
+          (*err) +=
+              "'" + property + "' property is missing in " + parent + ".\n";
+        } else {
+          (*err) += "'" + property + "' property is missing.\n";
+        }
+      }
+    }
+    return false;
+  }
+
+  const json &dict = GetValue(it);
+
+  // Make sure we are dealing with an object / dictionary.
+  if (!IsObject(dict)) {
+    if (required) {
+      if (err) {
+        (*err) += "'" + property + "' property is not an object.\n";
+      }
+    }
+    return false;
+  }
+
+  ret->clear();
+
+  json_const_iterator dictIt(ObjectBegin(dict));
+  json_const_iterator dictItEnd(ObjectEnd(dict));
+
+  for (; dictIt != dictItEnd; ++dictIt) {
+    int intVal;
+    if (!GetInt(GetValue(dictIt), intVal)) {
+      if (required) {
+        if (err) {
+          (*err) += "'" + property + "' value is not an integer type.\n";
+        }
+      }
+      return false;
+    }
+
+    // Insert into the list.
+    (*ret)[GetKey(dictIt)] = intVal;
+  }
+  return true;
+}
+
+static bool ParseJSONProperty(std::map<std::string, double> *ret,
+                              std::string *err, const json &o,
+                              const std::string &property, bool required) {
+  json_const_iterator it;
+  if (!FindMember(o, property.c_str(), it)) {
+    if (required) {
+      if (err) {
+        (*err) += "'" + property + "' property is missing. \n'";
+      }
+    }
+    return false;
+  }
+
+  const json &obj = GetValue(it);
+
+  if (!IsObject(obj)) {
+    if (required) {
+      if (err) {
+        (*err) += "'" + property + "' property is not a JSON object.\n";
+      }
+    }
+    return false;
+  }
+
+  ret->clear();
+
+  json_const_iterator it2(ObjectBegin(obj));
+  json_const_iterator itEnd(ObjectEnd(obj));
+  for (; it2 != itEnd; ++it2) {
+    double numVal;
+    if (GetNumber(GetValue(it2), numVal))
+      ret->emplace(std::string(GetKey(it2)), numVal);
+  }
+
+  return true;
+}
+
+static bool ParseParameterProperty(Parameter *param, std::string *err,
+                                   const json &o, const std::string &prop,
+                                   bool required) {
+  // A parameter value can either be a string or an array of either a boolean or
+  // a number. Booleans of any kind aren't supported here. Granted, it
+  // complicates the Parameter structure and breaks it semantically in the sense
+  // that the client probably works off the assumption that if the string is
+  // empty the vector is used, etc. Would a tagged union work?
+  if (ParseStringProperty(&param->string_value, err, o, prop, false)) {
+    // Found string property.
+    return true;
+  } else if (ParseNumberArrayProperty(&param->number_array, err, o, prop,
+                                      false)) {
+    // Found a number array.
+    return true;
+  } else if (ParseNumberProperty(&param->number_value, err, o, prop, false)) {
+    return param->has_number_value = true;
+  } else if (ParseJSONProperty(&param->json_double_value, err, o, prop,
+                               false)) {
+    return true;
+  } else if (ParseBooleanProperty(&param->bool_value, err, o, prop, false)) {
+    return true;
+  } else {
+    if (required) {
+      if (err) {
+        (*err) += "parameter must be a string or number / number array.\n";
+      }
+    }
+    return false;
+  }
+}
+
+static bool ParseExtensionsProperty(ExtensionMap *ret, std::string *err,
+                                    const json &o) {
+  (void)err;
+
+  json_const_iterator it;
+  if (!FindMember(o, "extensions", it)) {
+    return false;
+  }
+
+  auto &obj = GetValue(it);
+  if (!IsObject(obj)) {
+    return false;
+  }
+  ExtensionMap extensions;
+  json_const_iterator extIt = ObjectBegin(obj);  // it.value().begin();
+  json_const_iterator extEnd = ObjectEnd(obj);
+  for (; extIt != extEnd; ++extIt) {
+    auto &itObj = GetValue(extIt);
+    if (!IsObject(itObj)) continue;
+    std::string key(GetKey(extIt));
+    if (!ParseJsonAsValue(&extensions[key], itObj)) {
+      if (!key.empty()) {
+        // create empty object so that an extension object is still of type
+        // object
+        extensions[key] = Value{Value::Object{}};
+      }
+    }
+  }
+  if (ret) {
+    (*ret) = std::move(extensions);
+  }
+  return true;
+}
+
+static bool ParseAsset(Asset *asset, std::string *err, const json &o,
+                       bool store_original_json_for_extras_and_extensions) {
+  ParseStringProperty(&asset->version, err, o, "version", true, "Asset");
+  ParseStringProperty(&asset->generator, err, o, "generator", false, "Asset");
+  ParseStringProperty(&asset->minVersion, err, o, "minVersion", false, "Asset");
+  ParseStringProperty(&asset->copyright, err, o, "copyright", false, "Asset");
+
+  ParseExtensionsProperty(&asset->extensions, err, o);
+
+  // Unity exporter version is added as extra here
+  ParseExtrasProperty(&(asset->extras), o);
+
+  if (store_original_json_for_extras_and_extensions) {
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extensions", it)) {
+        asset->extensions_json_string = JsonToString(GetValue(it));
+      }
+    }
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extras", it)) {
+        asset->extras_json_string = JsonToString(GetValue(it));
+      }
+    }
+  }
+
+  return true;
+}
+
+static bool ParseImage(Image *image, const int image_idx, std::string *err,
+                       std::string *warn, const json &o,
+                       bool store_original_json_for_extras_and_extensions,
+                       const std::string &basedir, FsCallbacks *fs,
+                       LoadImageDataFunction *LoadImageData = nullptr,
+                       void *load_image_user_data = nullptr) {
+  // A glTF image must either reference a bufferView or an image uri
+
+  // schema says oneOf [`bufferView`, `uri`]
+  // TODO(syoyo): Check the type of each parameters.
+  json_const_iterator it;
+  bool hasBufferView = FindMember(o, "bufferView", it);
+  bool hasURI = FindMember(o, "uri", it);
+
+  ParseStringProperty(&image->name, err, o, "name", false);
+
+  if (hasBufferView && hasURI) {
+    // Should not both defined.
+    if (err) {
+      (*err) +=
+          "Only one of `bufferView` or `uri` should be defined, but both are "
+          "defined for image[" +
+          std::to_string(image_idx) + "] name = \"" + image->name + "\"\n";
+    }
+    return false;
+  }
+
+  if (!hasBufferView && !hasURI) {
+    if (err) {
+      (*err) += "Neither required `bufferView` nor `uri` defined for image[" +
+                std::to_string(image_idx) + "] name = \"" + image->name +
+                "\"\n";
+    }
+    return false;
+  }
+
+  ParseExtensionsProperty(&image->extensions, err, o);
+  ParseExtrasProperty(&image->extras, o);
+
+  if (store_original_json_for_extras_and_extensions) {
+    {
+      json_const_iterator eit;
+      if (FindMember(o, "extensions", eit)) {
+        image->extensions_json_string = JsonToString(GetValue(eit));
+      }
+    }
+    {
+      json_const_iterator eit;
+      if (FindMember(o, "extras", eit)) {
+        image->extras_json_string = JsonToString(GetValue(eit));
+      }
+    }
+  }
+
+  if (hasBufferView) {
+    int bufferView = -1;
+    if (!ParseIntegerProperty(&bufferView, err, o, "bufferView", true)) {
+      if (err) {
+        (*err) += "Failed to parse `bufferView` for image[" +
+                  std::to_string(image_idx) + "] name = \"" + image->name +
+                  "\"\n";
+      }
+      return false;
+    }
+
+    std::string mime_type;
+    ParseStringProperty(&mime_type, err, o, "mimeType", false);
+
+    int width = 0;
+    ParseIntegerProperty(&width, err, o, "width", false);
+
+    int height = 0;
+    ParseIntegerProperty(&height, err, o, "height", false);
+
+    // Just only save some information here. Loading actual image data from
+    // bufferView is done after this `ParseImage` function.
+    image->bufferView = bufferView;
+    image->mimeType = mime_type;
+    image->width = width;
+    image->height = height;
+
+    return true;
+  }
+
+  // Parse URI & Load image data.
+
+  std::string uri;
+  std::string tmp_err;
+  if (!ParseStringProperty(&uri, &tmp_err, o, "uri", true)) {
+    if (err) {
+      (*err) += "Failed to parse `uri` for image[" + std::to_string(image_idx) +
+                "] name = \"" + image->name + "\".\n";
+    }
+    return false;
+  }
+
+  std::vector<unsigned char> img;
+
+  if (IsDataURI(uri)) {
+    if (!DecodeDataURI(&img, image->mimeType, uri, 0, false)) {
+      if (err) {
+        (*err) += "Failed to decode 'uri' for image[" +
+                  std::to_string(image_idx) + "] name = [" + image->name +
+                  "]\n";
+      }
+      return false;
+    }
+  } else {
+    // Assume external file
+    // Keep texture path (for textures that cannot be decoded)
+    image->uri = uri;
+#ifdef TINYGLTF_NO_EXTERNAL_IMAGE
+    return true;
+#endif
+    std::string decoded_uri = dlib::urldecode(uri);
+    if (!LoadExternalFile(&img, err, warn, decoded_uri, basedir,
+                          /* required */ false, /* required bytes */ 0,
+                          /* checksize */ false, fs)) {
+      if (warn) {
+        (*warn) += "Failed to load external 'uri' for image[" +
+                   std::to_string(image_idx) + "] name = [" + image->name +
+                   "]\n";
+      }
+      // If the image cannot be loaded, keep uri as image->uri.
+      return true;
+    }
+
+    if (img.empty()) {
+      if (warn) {
+        (*warn) += "Image data is empty for image[" +
+                   std::to_string(image_idx) + "] name = [" + image->name +
+                   "] \n";
+      }
+      return false;
+    }
+  }
+
+  if (*LoadImageData == nullptr) {
+    if (err) {
+      (*err) += "No LoadImageData callback specified.\n";
+    }
+    return false;
+  }
+  return (*LoadImageData)(image, image_idx, err, warn, 0, 0, &img.at(0),
+                          static_cast<int>(img.size()), load_image_user_data);
+}
+
+static bool ParseTexture(Texture *texture, std::string *err, const json &o,
+                         bool store_original_json_for_extras_and_extensions,
+                         const std::string &basedir) {
+  (void)basedir;
+  int sampler = -1;
+  int source = -1;
+  ParseIntegerProperty(&sampler, err, o, "sampler", false);
+
+  ParseIntegerProperty(&source, err, o, "source", false);
+
+  texture->sampler = sampler;
+  texture->source = source;
+
+  ParseExtensionsProperty(&texture->extensions, err, o);
+  ParseExtrasProperty(&texture->extras, o);
+
+  if (store_original_json_for_extras_and_extensions) {
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extensions", it)) {
+        texture->extensions_json_string = JsonToString(GetValue(it));
+      }
+    }
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extras", it)) {
+        texture->extras_json_string = JsonToString(GetValue(it));
+      }
+    }
+  }
+
+  ParseStringProperty(&texture->name, err, o, "name", false);
+
+  return true;
+}
+
+static bool ParseTextureInfo(
+    TextureInfo *texinfo, std::string *err, const json &o,
+    bool store_original_json_for_extras_and_extensions) {
+  if (texinfo == nullptr) {
+    return false;
+  }
+
+  if (!ParseIntegerProperty(&texinfo->index, err, o, "index",
+                            /* required */ true, "TextureInfo")) {
+    return false;
+  }
+
+  ParseIntegerProperty(&texinfo->texCoord, err, o, "texCoord", false);
+
+  ParseExtensionsProperty(&texinfo->extensions, err, o);
+  ParseExtrasProperty(&texinfo->extras, o);
+
+  if (store_original_json_for_extras_and_extensions) {
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extensions", it)) {
+        texinfo->extensions_json_string = JsonToString(GetValue(it));
+      }
+    }
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extras", it)) {
+        texinfo->extras_json_string = JsonToString(GetValue(it));
+      }
+    }
+  }
+
+  return true;
+}
+
+static bool ParseNormalTextureInfo(
+    NormalTextureInfo *texinfo, std::string *err, const json &o,
+    bool store_original_json_for_extras_and_extensions) {
+  if (texinfo == nullptr) {
+    return false;
+  }
+
+  if (!ParseIntegerProperty(&texinfo->index, err, o, "index",
+                            /* required */ true, "NormalTextureInfo")) {
+    return false;
+  }
+
+  ParseIntegerProperty(&texinfo->texCoord, err, o, "texCoord", false);
+  ParseNumberProperty(&texinfo->scale, err, o, "scale", false);
+
+  ParseExtensionsProperty(&texinfo->extensions, err, o);
+  ParseExtrasProperty(&texinfo->extras, o);
+
+  if (store_original_json_for_extras_and_extensions) {
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extensions", it)) {
+        texinfo->extensions_json_string = JsonToString(GetValue(it));
+      }
+    }
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extras", it)) {
+        texinfo->extras_json_string = JsonToString(GetValue(it));
+      }
+    }
+  }
+
+  return true;
+}
+
+static bool ParseOcclusionTextureInfo(
+    OcclusionTextureInfo *texinfo, std::string *err, const json &o,
+    bool store_original_json_for_extras_and_extensions) {
+  if (texinfo == nullptr) {
+    return false;
+  }
+
+  if (!ParseIntegerProperty(&texinfo->index, err, o, "index",
+                            /* required */ true, "NormalTextureInfo")) {
+    return false;
+  }
+
+  ParseIntegerProperty(&texinfo->texCoord, err, o, "texCoord", false);
+  ParseNumberProperty(&texinfo->strength, err, o, "strength", false);
+
+  ParseExtensionsProperty(&texinfo->extensions, err, o);
+  ParseExtrasProperty(&texinfo->extras, o);
+
+  if (store_original_json_for_extras_and_extensions) {
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extensions", it)) {
+        texinfo->extensions_json_string = JsonToString(GetValue(it));
+      }
+    }
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extras", it)) {
+        texinfo->extras_json_string = JsonToString(GetValue(it));
+      }
+    }
+  }
+
+  return true;
+}
+
+static bool ParseBuffer(Buffer *buffer, std::string *err, const json &o,
+                        bool store_original_json_for_extras_and_extensions,
+                        FsCallbacks *fs, const std::string &basedir,
+                        bool is_binary = false,
+                        const unsigned char *bin_data = nullptr,
+                        size_t bin_size = 0) {
+  size_t byteLength;
+  if (!ParseUnsignedProperty(&byteLength, err, o, "byteLength", true,
+                             "Buffer")) {
+    return false;
+  }
+
+  // In glTF 2.0, uri is not mandatory anymore
+  buffer->uri.clear();
+  ParseStringProperty(&buffer->uri, err, o, "uri", false, "Buffer");
+
+  // having an empty uri for a non embedded image should not be valid
+  if (!is_binary && buffer->uri.empty()) {
+    if (err) {
+      (*err) += "'uri' is missing from non binary glTF file buffer.\n";
+    }
+  }
+
+  json_const_iterator type;
+  if (FindMember(o, "type", type)) {
+    std::string typeStr;
+    if (GetString(GetValue(type), typeStr)) {
+      if (typeStr.compare("arraybuffer") == 0) {
+        // buffer.type = "arraybuffer";
+      }
+    }
+  }
+
+  if (is_binary) {
+    // Still binary glTF accepts external dataURI.
+    if (!buffer->uri.empty()) {
+      // First try embedded data URI.
+      if (IsDataURI(buffer->uri)) {
+        std::string mime_type;
+        if (!DecodeDataURI(&buffer->data, mime_type, buffer->uri, byteLength,
+                           true)) {
+          if (err) {
+            (*err) +=
+                "Failed to decode 'uri' : " + buffer->uri + " in Buffer\n";
+          }
+          return false;
+        }
+      } else {
+        // External .bin file.
+        std::string decoded_uri = dlib::urldecode(buffer->uri);
+        if (!LoadExternalFile(&buffer->data, err, /* warn */ nullptr,
+                              decoded_uri, basedir, /* required */ true,
+                              byteLength, /* checkSize */ true, fs)) {
+          return false;
+        }
+      }
+    } else {
+      // load data from (embedded) binary data
+
+      if ((bin_size == 0) || (bin_data == nullptr)) {
+        if (err) {
+          (*err) += "Invalid binary data in `Buffer'.\n";
+        }
+        return false;
+      }
+
+      if (byteLength > bin_size) {
+        if (err) {
+          std::stringstream ss;
+          ss << "Invalid `byteLength'. Must be equal or less than binary size: "
+                "`byteLength' = "
+             << byteLength << ", binary size = " << bin_size << std::endl;
+          (*err) += ss.str();
+        }
+        return false;
+      }
+
+      // Read buffer data
+      buffer->data.resize(static_cast<size_t>(byteLength));
+      memcpy(&(buffer->data.at(0)), bin_data, static_cast<size_t>(byteLength));
+    }
+
+  } else {
+    if (IsDataURI(buffer->uri)) {
+      std::string mime_type;
+      if (!DecodeDataURI(&buffer->data, mime_type, buffer->uri, byteLength,
+                         true)) {
+        if (err) {
+          (*err) += "Failed to decode 'uri' : " + buffer->uri + " in Buffer\n";
+        }
+        return false;
+      }
+    } else {
+      // Assume external .bin file.
+      std::string decoded_uri = dlib::urldecode(buffer->uri);
+      if (!LoadExternalFile(&buffer->data, err, /* warn */ nullptr, decoded_uri,
+                            basedir, /* required */ true, byteLength,
+                            /* checkSize */ true, fs)) {
+        return false;
+      }
+    }
+  }
+
+  ParseStringProperty(&buffer->name, err, o, "name", false);
+
+  ParseExtensionsProperty(&buffer->extensions, err, o);
+  ParseExtrasProperty(&buffer->extras, o);
+
+  if (store_original_json_for_extras_and_extensions) {
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extensions", it)) {
+        buffer->extensions_json_string = JsonToString(GetValue(it));
+      }
+    }
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extras", it)) {
+        buffer->extras_json_string = JsonToString(GetValue(it));
+      }
+    }
+  }
+
+  return true;
+}
+
+static bool ParseBufferView(
+    BufferView *bufferView, std::string *err, const json &o,
+    bool store_original_json_for_extras_and_extensions) {
+  int buffer = -1;
+  if (!ParseIntegerProperty(&buffer, err, o, "buffer", true, "BufferView")) {
+    return false;
+  }
+
+  size_t byteOffset = 0;
+  ParseUnsignedProperty(&byteOffset, err, o, "byteOffset", false);
+
+  size_t byteLength = 1;
+  if (!ParseUnsignedProperty(&byteLength, err, o, "byteLength", true,
+                             "BufferView")) {
+    return false;
+  }
+
+  size_t byteStride = 0;
+  if (!ParseUnsignedProperty(&byteStride, err, o, "byteStride", false)) {
+    // Spec says: When byteStride of referenced bufferView is not defined, it
+    // means that accessor elements are tightly packed, i.e., effective stride
+    // equals the size of the element.
+    // We cannot determine the actual byteStride until Accessor are parsed, thus
+    // set 0(= tightly packed) here(as done in OpenGL's VertexAttribPoiner)
+    byteStride = 0;
+  }
+
+  if ((byteStride > 252) || ((byteStride % 4) != 0)) {
+    if (err) {
+      std::stringstream ss;
+      ss << "Invalid `byteStride' value. `byteStride' must be the multiple of "
+            "4 : "
+         << byteStride << std::endl;
+
+      (*err) += ss.str();
+    }
+    return false;
+  }
+
+  int target = 0;
+  ParseIntegerProperty(&target, err, o, "target", false);
+  if ((target == TINYGLTF_TARGET_ARRAY_BUFFER) ||
+      (target == TINYGLTF_TARGET_ELEMENT_ARRAY_BUFFER)) {
+    // OK
+  } else {
+    target = 0;
+  }
+  bufferView->target = target;
+
+  ParseStringProperty(&bufferView->name, err, o, "name", false);
+
+  ParseExtensionsProperty(&bufferView->extensions, err, o);
+  ParseExtrasProperty(&bufferView->extras, o);
+
+  if (store_original_json_for_extras_and_extensions) {
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extensions", it)) {
+        bufferView->extensions_json_string = JsonToString(GetValue(it));
+      }
+    }
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extras", it)) {
+        bufferView->extras_json_string = JsonToString(GetValue(it));
+      }
+    }
+  }
+
+  bufferView->buffer = buffer;
+  bufferView->byteOffset = byteOffset;
+  bufferView->byteLength = byteLength;
+  bufferView->byteStride = byteStride;
+  return true;
+}
+
+static bool ParseSparseAccessor(Accessor *accessor, std::string *err,
+                                const json &o) {
+  accessor->sparse.isSparse = true;
+
+  int count = 0;
+  ParseIntegerProperty(&count, err, o, "count", true);
+
+  json_const_iterator indices_iterator;
+  json_const_iterator values_iterator;
+  if (!FindMember(o, "indices", indices_iterator)) {
+    (*err) = "the sparse object of this accessor doesn't have indices";
+    return false;
+  }
+
+  if (!FindMember(o, "values", values_iterator)) {
+    (*err) = "the sparse object ob ths accessor doesn't have values";
+    return false;
+  }
+
+  const json &indices_obj = GetValue(indices_iterator);
+  const json &values_obj = GetValue(values_iterator);
+
+  int indices_buffer_view = 0, indices_byte_offset = 0, component_type = 0;
+  ParseIntegerProperty(&indices_buffer_view, err, indices_obj, "bufferView",
+                       true);
+  ParseIntegerProperty(&indices_byte_offset, err, indices_obj, "byteOffset",
+                       true);
+  ParseIntegerProperty(&component_type, err, indices_obj, "componentType",
+                       true);
+
+  int values_buffer_view = 0, values_byte_offset = 0;
+  ParseIntegerProperty(&values_buffer_view, err, values_obj, "bufferView",
+                       true);
+  ParseIntegerProperty(&values_byte_offset, err, values_obj, "byteOffset",
+                       true);
+
+  accessor->sparse.count = count;
+  accessor->sparse.indices.bufferView = indices_buffer_view;
+  accessor->sparse.indices.byteOffset = indices_byte_offset;
+  accessor->sparse.indices.componentType = component_type;
+  accessor->sparse.values.bufferView = values_buffer_view;
+  accessor->sparse.values.byteOffset = values_byte_offset;
+
+  // todo check theses values
+
+  return true;
+}
+
+static bool ParseAccessor(Accessor *accessor, std::string *err, const json &o,
+                          bool store_original_json_for_extras_and_extensions) {
+  int bufferView = -1;
+  ParseIntegerProperty(&bufferView, err, o, "bufferView", false, "Accessor");
+
+  size_t byteOffset = 0;
+  ParseUnsignedProperty(&byteOffset, err, o, "byteOffset", false, "Accessor");
+
+  bool normalized = false;
+  ParseBooleanProperty(&normalized, err, o, "normalized", false, "Accessor");
+
+  size_t componentType = 0;
+  if (!ParseUnsignedProperty(&componentType, err, o, "componentType", true,
+                             "Accessor")) {
+    return false;
+  }
+
+  size_t count = 0;
+  if (!ParseUnsignedProperty(&count, err, o, "count", true, "Accessor")) {
+    return false;
+  }
+
+  std::string type;
+  if (!ParseStringProperty(&type, err, o, "type", true, "Accessor")) {
+    return false;
+  }
+
+  if (type.compare("SCALAR") == 0) {
+    accessor->type = TINYGLTF_TYPE_SCALAR;
+  } else if (type.compare("VEC2") == 0) {
+    accessor->type = TINYGLTF_TYPE_VEC2;
+  } else if (type.compare("VEC3") == 0) {
+    accessor->type = TINYGLTF_TYPE_VEC3;
+  } else if (type.compare("VEC4") == 0) {
+    accessor->type = TINYGLTF_TYPE_VEC4;
+  } else if (type.compare("MAT2") == 0) {
+    accessor->type = TINYGLTF_TYPE_MAT2;
+  } else if (type.compare("MAT3") == 0) {
+    accessor->type = TINYGLTF_TYPE_MAT3;
+  } else if (type.compare("MAT4") == 0) {
+    accessor->type = TINYGLTF_TYPE_MAT4;
+  } else {
+    std::stringstream ss;
+    ss << "Unsupported `type` for accessor object. Got \"" << type << "\"\n";
+    if (err) {
+      (*err) += ss.str();
+    }
+    return false;
+  }
+
+  ParseStringProperty(&accessor->name, err, o, "name", false);
+
+  accessor->minValues.clear();
+  accessor->maxValues.clear();
+  ParseNumberArrayProperty(&accessor->minValues, err, o, "min", false,
+                           "Accessor");
+
+  ParseNumberArrayProperty(&accessor->maxValues, err, o, "max", false,
+                           "Accessor");
+
+  accessor->count = count;
+  accessor->bufferView = bufferView;
+  accessor->byteOffset = byteOffset;
+  accessor->normalized = normalized;
+  {
+    if (componentType >= TINYGLTF_COMPONENT_TYPE_BYTE &&
+        componentType <= TINYGLTF_COMPONENT_TYPE_DOUBLE) {
+      // OK
+      accessor->componentType = int(componentType);
+    } else {
+      std::stringstream ss;
+      ss << "Invalid `componentType` in accessor. Got " << componentType
+         << "\n";
+      if (err) {
+        (*err) += ss.str();
+      }
+      return false;
+    }
+  }
+
+  ParseExtensionsProperty(&(accessor->extensions), err, o);
+  ParseExtrasProperty(&(accessor->extras), o);
+
+  if (store_original_json_for_extras_and_extensions) {
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extensions", it)) {
+        accessor->extensions_json_string = JsonToString(GetValue(it));
+      }
+    }
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extras", it)) {
+        accessor->extras_json_string = JsonToString(GetValue(it));
+      }
+    }
+  }
+
+  // check if accessor has a "sparse" object:
+  json_const_iterator iterator;
+  if (FindMember(o, "sparse", iterator)) {
+    // here this accessor has a "sparse" subobject
+    return ParseSparseAccessor(accessor, err, GetValue(iterator));
+  }
+
+  return true;
+}
+
+#ifdef TINYGLTF_ENABLE_DRACO
+
+static void DecodeIndexBuffer(draco::Mesh *mesh, size_t componentSize,
+                              std::vector<uint8_t> &outBuffer) {
+  if (componentSize == 4) {
+    assert(sizeof(mesh->face(draco::FaceIndex(0))[0]) == componentSize);
+    memcpy(outBuffer.data(), &mesh->face(draco::FaceIndex(0))[0],
+           outBuffer.size());
+  } else {
+    size_t faceStride = componentSize * 3;
+    for (draco::FaceIndex f(0); f < mesh->num_faces(); ++f) {
+      const draco::Mesh::Face &face = mesh->face(f);
+      if (componentSize == 2) {
+        uint16_t indices[3] = {(uint16_t)face[0].value(),
+                               (uint16_t)face[1].value(),
+                               (uint16_t)face[2].value()};
+        memcpy(outBuffer.data() + f.value() * faceStride, &indices[0],
+               faceStride);
+      } else {
+        uint8_t indices[3] = {(uint8_t)face[0].value(),
+                              (uint8_t)face[1].value(),
+                              (uint8_t)face[2].value()};
+        memcpy(outBuffer.data() + f.value() * faceStride, &indices[0],
+               faceStride);
+      }
+    }
+  }
+}
+
+template <typename T>
+static bool GetAttributeForAllPoints(draco::Mesh *mesh,
+                                     const draco::PointAttribute *pAttribute,
+                                     std::vector<uint8_t> &outBuffer) {
+  size_t byteOffset = 0;
+  T values[4] = {0, 0, 0, 0};
+  for (draco::PointIndex i(0); i < mesh->num_points(); ++i) {
+    const draco::AttributeValueIndex val_index = pAttribute->mapped_index(i);
+    if (!pAttribute->ConvertValue<T>(val_index, pAttribute->num_components(),
+                                     values))
+      return false;
+
+    memcpy(outBuffer.data() + byteOffset, &values[0],
+           sizeof(T) * pAttribute->num_components());
+    byteOffset += sizeof(T) * pAttribute->num_components();
+  }
+
+  return true;
+}
+
+static bool GetAttributeForAllPoints(uint32_t componentType, draco::Mesh *mesh,
+                                     const draco::PointAttribute *pAttribute,
+                                     std::vector<uint8_t> &outBuffer) {
+  bool decodeResult = false;
+  switch (componentType) {
+    case TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE:
+      decodeResult =
+          GetAttributeForAllPoints<uint8_t>(mesh, pAttribute, outBuffer);
+      break;
+    case TINYGLTF_COMPONENT_TYPE_BYTE:
+      decodeResult =
+          GetAttributeForAllPoints<int8_t>(mesh, pAttribute, outBuffer);
+      break;
+    case TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT:
+      decodeResult =
+          GetAttributeForAllPoints<uint16_t>(mesh, pAttribute, outBuffer);
+      break;
+    case TINYGLTF_COMPONENT_TYPE_SHORT:
+      decodeResult =
+          GetAttributeForAllPoints<int16_t>(mesh, pAttribute, outBuffer);
+      break;
+    case TINYGLTF_COMPONENT_TYPE_INT:
+      decodeResult =
+          GetAttributeForAllPoints<int32_t>(mesh, pAttribute, outBuffer);
+      break;
+    case TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT:
+      decodeResult =
+          GetAttributeForAllPoints<uint32_t>(mesh, pAttribute, outBuffer);
+      break;
+    case TINYGLTF_COMPONENT_TYPE_FLOAT:
+      decodeResult =
+          GetAttributeForAllPoints<float>(mesh, pAttribute, outBuffer);
+      break;
+    case TINYGLTF_COMPONENT_TYPE_DOUBLE:
+      decodeResult =
+          GetAttributeForAllPoints<double>(mesh, pAttribute, outBuffer);
+      break;
+    default:
+      return false;
+  }
+
+  return decodeResult;
+}
+
+static bool ParseDracoExtension(Primitive *primitive, Model *model,
+                                std::string *err,
+                                const Value &dracoExtensionValue) {
+  auto bufferViewValue = dracoExtensionValue.Get("bufferView");
+  if (!bufferViewValue.IsInt()) return false;
+  auto attributesValue = dracoExtensionValue.Get("attributes");
+  if (!attributesValue.IsObject()) return false;
+
+  auto attributesObject = attributesValue.Get<Value::Object>();
+  int bufferView = bufferViewValue.Get<int>();
+
+  BufferView &view = model->bufferViews[bufferView];
+  Buffer &buffer = model->buffers[view.buffer];
+  // BufferView has already been decoded
+  if (view.dracoDecoded) return true;
+  view.dracoDecoded = true;
+
+  const char *bufferViewData =
+      reinterpret_cast<const char *>(buffer.data.data() + view.byteOffset);
+  size_t bufferViewSize = view.byteLength;
+
+  // decode draco
+  draco::DecoderBuffer decoderBuffer;
+  decoderBuffer.Init(bufferViewData, bufferViewSize);
+  draco::Decoder decoder;
+  auto decodeResult = decoder.DecodeMeshFromBuffer(&decoderBuffer);
+  if (!decodeResult.ok()) {
+    return false;
+  }
+  const std::unique_ptr<draco::Mesh> &mesh = decodeResult.value();
+
+  // create new bufferView for indices
+  if (primitive->indices >= 0) {
+    int32_t componentSize = GetComponentSizeInBytes(
+        model->accessors[primitive->indices].componentType);
+    Buffer decodedIndexBuffer;
+    decodedIndexBuffer.data.resize(mesh->num_faces() * 3 * componentSize);
+
+    DecodeIndexBuffer(mesh.get(), componentSize, decodedIndexBuffer.data);
+
+    model->buffers.emplace_back(std::move(decodedIndexBuffer));
+
+    BufferView decodedIndexBufferView;
+    decodedIndexBufferView.buffer = int(model->buffers.size() - 1);
+    decodedIndexBufferView.byteLength =
+        int(mesh->num_faces() * 3 * componentSize);
+    decodedIndexBufferView.byteOffset = 0;
+    decodedIndexBufferView.byteStride = 0;
+    decodedIndexBufferView.target = TINYGLTF_TARGET_ARRAY_BUFFER;
+    model->bufferViews.emplace_back(std::move(decodedIndexBufferView));
+
+    model->accessors[primitive->indices].bufferView =
+        int(model->bufferViews.size() - 1);
+    model->accessors[primitive->indices].count = int(mesh->num_faces() * 3);
+  }
+
+  for (const auto &attribute : attributesObject) {
+    if (!attribute.second.IsInt()) return false;
+    auto primitiveAttribute = primitive->attributes.find(attribute.first);
+    if (primitiveAttribute == primitive->attributes.end()) return false;
+
+    int dracoAttributeIndex = attribute.second.Get<int>();
+    const auto pAttribute = mesh->GetAttributeByUniqueId(dracoAttributeIndex);
+    const auto pBuffer = pAttribute->buffer();
+    const auto componentType =
+        model->accessors[primitiveAttribute->second].componentType;
+
+    // Create a new buffer for this decoded buffer
+    Buffer decodedBuffer;
+    size_t bufferSize = mesh->num_points() * pAttribute->num_components() *
+                        GetComponentSizeInBytes(componentType);
+    decodedBuffer.data.resize(bufferSize);
+
+    if (!GetAttributeForAllPoints(componentType, mesh.get(), pAttribute,
+                                  decodedBuffer.data))
+      return false;
+
+    model->buffers.emplace_back(std::move(decodedBuffer));
+
+    BufferView decodedBufferView;
+    decodedBufferView.buffer = int(model->buffers.size() - 1);
+    decodedBufferView.byteLength = bufferSize;
+    decodedBufferView.byteOffset = pAttribute->byte_offset();
+    decodedBufferView.byteStride = pAttribute->byte_stride();
+    decodedBufferView.target = primitive->indices >= 0
+                                   ? TINYGLTF_TARGET_ELEMENT_ARRAY_BUFFER
+                                   : TINYGLTF_TARGET_ARRAY_BUFFER;
+    model->bufferViews.emplace_back(std::move(decodedBufferView));
+
+    model->accessors[primitiveAttribute->second].bufferView =
+        int(model->bufferViews.size() - 1);
+    model->accessors[primitiveAttribute->second].count =
+        int(mesh->num_points());
+  }
+
+  return true;
+}
+#endif
+
+static bool ParsePrimitive(Primitive *primitive, Model *model, std::string *err,
+                           const json &o,
+                           bool store_original_json_for_extras_and_extensions) {
+  int material = -1;
+  ParseIntegerProperty(&material, err, o, "material", false);
+  primitive->material = material;
+
+  int mode = TINYGLTF_MODE_TRIANGLES;
+  ParseIntegerProperty(&mode, err, o, "mode", false);
+  primitive->mode = mode;  // Why only triangled were supported ?
+
+  int indices = -1;
+  ParseIntegerProperty(&indices, err, o, "indices", false);
+  primitive->indices = indices;
+  if (!ParseStringIntegerProperty(&primitive->attributes, err, o, "attributes",
+                                  true, "Primitive")) {
+    return false;
+  }
+
+  // Look for morph targets
+  json_const_iterator targetsObject;
+  if (FindMember(o, "targets", targetsObject) &&
+      IsArray(GetValue(targetsObject))) {
+    auto targetsObjectEnd = ArrayEnd(GetValue(targetsObject));
+    for (json_const_array_iterator i = ArrayBegin(GetValue(targetsObject));
+         i != targetsObjectEnd; ++i) {
+      std::map<std::string, int> targetAttribues;
+
+      const json &dict = *i;
+      if (IsObject(dict)) {
+        json_const_iterator dictIt(ObjectBegin(dict));
+        json_const_iterator dictItEnd(ObjectEnd(dict));
+
+        for (; dictIt != dictItEnd; ++dictIt) {
+          int iVal;
+          if (GetInt(GetValue(dictIt), iVal))
+            targetAttribues[GetKey(dictIt)] = iVal;
+        }
+        primitive->targets.emplace_back(std::move(targetAttribues));
+      }
+    }
+  }
+
+  ParseExtrasProperty(&(primitive->extras), o);
+  ParseExtensionsProperty(&primitive->extensions, err, o);
+
+  if (store_original_json_for_extras_and_extensions) {
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extensions", it)) {
+        primitive->extensions_json_string = JsonToString(GetValue(it));
+      }
+    }
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extras", it)) {
+        primitive->extras_json_string = JsonToString(GetValue(it));
+      }
+    }
+  }
+
+#ifdef TINYGLTF_ENABLE_DRACO
+  auto dracoExtension =
+      primitive->extensions.find("KHR_draco_mesh_compression");
+  if (dracoExtension != primitive->extensions.end()) {
+    ParseDracoExtension(primitive, model, err, dracoExtension->second);
+  }
+#else
+  (void)model;
+#endif
+
+  return true;
+}
+
+static bool ParseMesh(Mesh *mesh, Model *model, std::string *err, const json &o,
+                      bool store_original_json_for_extras_and_extensions) {
+  ParseStringProperty(&mesh->name, err, o, "name", false);
+
+  mesh->primitives.clear();
+  json_const_iterator primObject;
+  if (FindMember(o, "primitives", primObject) &&
+      IsArray(GetValue(primObject))) {
+    json_const_array_iterator primEnd = ArrayEnd(GetValue(primObject));
+    for (json_const_array_iterator i = ArrayBegin(GetValue(primObject));
+         i != primEnd; ++i) {
+      Primitive primitive;
+      if (ParsePrimitive(&primitive, model, err, *i,
+                         store_original_json_for_extras_and_extensions)) {
+        // Only add the primitive if the parsing succeeds.
+        mesh->primitives.emplace_back(std::move(primitive));
+      }
+    }
+  }
+
+  // Should probably check if has targets and if dimensions fit
+  ParseNumberArrayProperty(&mesh->weights, err, o, "weights", false);
+
+  ParseExtensionsProperty(&mesh->extensions, err, o);
+  ParseExtrasProperty(&(mesh->extras), o);
+
+  if (store_original_json_for_extras_and_extensions) {
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extensions", it)) {
+        mesh->extensions_json_string = JsonToString(GetValue(it));
+      }
+    }
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extras", it)) {
+        mesh->extras_json_string = JsonToString(GetValue(it));
+      }
+    }
+  }
+
+  return true;
+}
+
+static bool ParseNode(Node *node, std::string *err, const json &o,
+                      bool store_original_json_for_extras_and_extensions) {
+  ParseStringProperty(&node->name, err, o, "name", false);
+
+  int skin = -1;
+  ParseIntegerProperty(&skin, err, o, "skin", false);
+  node->skin = skin;
+
+  // Matrix and T/R/S are exclusive
+  if (!ParseNumberArrayProperty(&node->matrix, err, o, "matrix", false)) {
+    ParseNumberArrayProperty(&node->rotation, err, o, "rotation", false);
+    ParseNumberArrayProperty(&node->scale, err, o, "scale", false);
+    ParseNumberArrayProperty(&node->translation, err, o, "translation", false);
+  }
+
+  int camera = -1;
+  ParseIntegerProperty(&camera, err, o, "camera", false);
+  node->camera = camera;
+
+  int mesh = -1;
+  ParseIntegerProperty(&mesh, err, o, "mesh", false);
+  node->mesh = mesh;
+
+  node->children.clear();
+  ParseIntegerArrayProperty(&node->children, err, o, "children", false);
+
+  ParseNumberArrayProperty(&node->weights, err, o, "weights", false);
+
+  ParseExtensionsProperty(&node->extensions, err, o);
+  ParseExtrasProperty(&(node->extras), o);
+
+  if (store_original_json_for_extras_and_extensions) {
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extensions", it)) {
+        node->extensions_json_string = JsonToString(GetValue(it));
+      }
+    }
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extras", it)) {
+        node->extras_json_string = JsonToString(GetValue(it));
+      }
+    }
+  }
+
+  return true;
+}
+
+static bool ParsePbrMetallicRoughness(
+    PbrMetallicRoughness *pbr, std::string *err, const json &o,
+    bool store_original_json_for_extras_and_extensions) {
+  if (pbr == nullptr) {
+    return false;
+  }
+
+  std::vector<double> baseColorFactor;
+  if (ParseNumberArrayProperty(&baseColorFactor, err, o, "baseColorFactor",
+                               /* required */ false)) {
+    if (baseColorFactor.size() != 4) {
+      if (err) {
+        (*err) +=
+            "Array length of `baseColorFactor` parameter in "
+            "pbrMetallicRoughness must be 4, but got " +
+            std::to_string(baseColorFactor.size()) + "\n";
+      }
+      return false;
+    }
+    pbr->baseColorFactor = baseColorFactor;
+  }
+
+  {
+    json_const_iterator it;
+    if (FindMember(o, "baseColorTexture", it)) {
+      ParseTextureInfo(&pbr->baseColorTexture, err, GetValue(it),
+                       store_original_json_for_extras_and_extensions);
+    }
+  }
+
+  {
+    json_const_iterator it;
+    if (FindMember(o, "metallicRoughnessTexture", it)) {
+      ParseTextureInfo(&pbr->metallicRoughnessTexture, err, GetValue(it),
+                       store_original_json_for_extras_and_extensions);
+    }
+  }
+
+  ParseNumberProperty(&pbr->metallicFactor, err, o, "metallicFactor", false);
+  ParseNumberProperty(&pbr->roughnessFactor, err, o, "roughnessFactor", false);
+
+  ParseExtensionsProperty(&pbr->extensions, err, o);
+  ParseExtrasProperty(&pbr->extras, o);
+
+  if (store_original_json_for_extras_and_extensions) {
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extensions", it)) {
+        pbr->extensions_json_string = JsonToString(GetValue(it));
+      }
+    }
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extras", it)) {
+        pbr->extras_json_string = JsonToString(GetValue(it));
+      }
+    }
+  }
+
+  return true;
+}
+
+static bool ParseMaterial(Material *material, std::string *err, const json &o,
+                          bool store_original_json_for_extras_and_extensions) {
+  ParseStringProperty(&material->name, err, o, "name", /* required */ false);
+
+  if (ParseNumberArrayProperty(&material->emissiveFactor, err, o,
+                               "emissiveFactor",
+                               /* required */ false)) {
+    if (material->emissiveFactor.size() != 3) {
+      if (err) {
+        (*err) +=
+            "Array length of `emissiveFactor` parameter in "
+            "material must be 3, but got " +
+            std::to_string(material->emissiveFactor.size()) + "\n";
+      }
+      return false;
+    }
+  } else {
+    // fill with default values
+    material->emissiveFactor = {0.0, 0.0, 0.0};
+  }
+
+  ParseStringProperty(&material->alphaMode, err, o, "alphaMode",
+                      /* required */ false);
+  ParseNumberProperty(&material->alphaCutoff, err, o, "alphaCutoff",
+                      /* required */ false);
+  ParseBooleanProperty(&material->doubleSided, err, o, "doubleSided",
+                       /* required */ false);
+
+  {
+    json_const_iterator it;
+    if (FindMember(o, "pbrMetallicRoughness", it)) {
+      ParsePbrMetallicRoughness(&material->pbrMetallicRoughness, err,
+                                GetValue(it),
+                                store_original_json_for_extras_and_extensions);
+    }
+  }
+
+  {
+    json_const_iterator it;
+    if (FindMember(o, "normalTexture", it)) {
+      ParseNormalTextureInfo(&material->normalTexture, err, GetValue(it),
+                             store_original_json_for_extras_and_extensions);
+    }
+  }
+
+  {
+    json_const_iterator it;
+    if (FindMember(o, "occlusionTexture", it)) {
+      ParseOcclusionTextureInfo(&material->occlusionTexture, err, GetValue(it),
+                                store_original_json_for_extras_and_extensions);
+    }
+  }
+
+  {
+    json_const_iterator it;
+    if (FindMember(o, "emissiveTexture", it)) {
+      ParseTextureInfo(&material->emissiveTexture, err, GetValue(it),
+                       store_original_json_for_extras_and_extensions);
+    }
+  }
+
+  // Old code path. For backward compatibility, we still store material values
+  // as Parameter. This will create duplicated information for
+  // example(pbrMetallicRoughness), but should be neglible in terms of memory
+  // consumption.
+  // TODO(syoyo): Remove in the next major release.
+  material->values.clear();
+  material->additionalValues.clear();
+
+  json_const_iterator it(ObjectBegin(o));
+  json_const_iterator itEnd(ObjectEnd(o));
+
+  for (; it != itEnd; ++it) {
+    std::string key(GetKey(it));
+    if (key == "pbrMetallicRoughness") {
+      if (IsObject(GetValue(it))) {
+        const json &values_object = GetValue(it);
+
+        json_const_iterator itVal(ObjectBegin(values_object));
+        json_const_iterator itValEnd(ObjectEnd(values_object));
+
+        for (; itVal != itValEnd; ++itVal) {
+          Parameter param;
+          if (ParseParameterProperty(&param, err, values_object, GetKey(itVal),
+                                     false)) {
+            material->values.emplace(GetKey(itVal), std::move(param));
+          }
+        }
+      }
+    } else if (key == "extensions" || key == "extras") {
+      // done later, skip, otherwise poorly parsed contents will be saved in the
+      // parametermap and serialized again later
+    } else {
+      Parameter param;
+      if (ParseParameterProperty(&param, err, o, key, false)) {
+        // names of materials have already been parsed. Putting it in this map
+        // doesn't correctly reflext the glTF specification
+        if (key != "name")
+          material->additionalValues.emplace(std::move(key), std::move(param));
+      }
+    }
+  }
+
+  material->extensions.clear();
+  ParseExtensionsProperty(&material->extensions, err, o);
+  ParseExtrasProperty(&(material->extras), o);
+
+  if (store_original_json_for_extras_and_extensions) {
+    {
+      json_const_iterator eit;
+      if (FindMember(o, "extensions", eit)) {
+        material->extensions_json_string = JsonToString(GetValue(eit));
+      }
+    }
+    {
+      json_const_iterator eit;
+      if (FindMember(o, "extras", eit)) {
+        material->extras_json_string = JsonToString(GetValue(eit));
+      }
+    }
+  }
+
+  return true;
+}
+
+static bool ParseAnimationChannel(
+    AnimationChannel *channel, std::string *err, const json &o,
+    bool store_original_json_for_extras_and_extensions) {
+  int samplerIndex = -1;
+  int targetIndex = -1;
+  if (!ParseIntegerProperty(&samplerIndex, err, o, "sampler", true,
+                            "AnimationChannel")) {
+    if (err) {
+      (*err) += "`sampler` field is missing in animation channels\n";
+    }
+    return false;
+  }
+
+  json_const_iterator targetIt;
+  if (FindMember(o, "target", targetIt) && IsObject(GetValue(targetIt))) {
+    const json &target_object = GetValue(targetIt);
+
+    if (!ParseIntegerProperty(&targetIndex, err, target_object, "node", true)) {
+      if (err) {
+        (*err) += "`node` field is missing in animation.channels.target\n";
+      }
+      return false;
+    }
+
+    if (!ParseStringProperty(&channel->target_path, err, target_object, "path",
+                             true)) {
+      if (err) {
+        (*err) += "`path` field is missing in animation.channels.target\n";
+      }
+      return false;
+    }
+    ParseExtensionsProperty(&channel->target_extensions, err, target_object);
+    if (store_original_json_for_extras_and_extensions) {
+      json_const_iterator it;
+      if (FindMember(target_object, "extensions", it)) {
+        channel->target_extensions_json_string = JsonToString(GetValue(it));
+      }
+    }
+  }
+
+  channel->sampler = samplerIndex;
+  channel->target_node = targetIndex;
+
+  ParseExtensionsProperty(&channel->extensions, err, o);
+  ParseExtrasProperty(&(channel->extras), o);
+
+  if (store_original_json_for_extras_and_extensions) {
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extensions", it)) {
+        channel->extensions_json_string = JsonToString(GetValue(it));
+      }
+    }
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extras", it)) {
+        channel->extras_json_string = JsonToString(GetValue(it));
+      }
+    }
+  }
+
+  return true;
+}
+
+static bool ParseAnimation(Animation *animation, std::string *err,
+                           const json &o,
+                           bool store_original_json_for_extras_and_extensions) {
+  {
+    json_const_iterator channelsIt;
+    if (FindMember(o, "channels", channelsIt) &&
+        IsArray(GetValue(channelsIt))) {
+      json_const_array_iterator channelEnd = ArrayEnd(GetValue(channelsIt));
+      for (json_const_array_iterator i = ArrayBegin(GetValue(channelsIt));
+           i != channelEnd; ++i) {
+        AnimationChannel channel;
+        if (ParseAnimationChannel(
+                &channel, err, *i,
+                store_original_json_for_extras_and_extensions)) {
+          // Only add the channel if the parsing succeeds.
+          animation->channels.emplace_back(std::move(channel));
+        }
+      }
+    }
+  }
+
+  {
+    json_const_iterator samplerIt;
+    if (FindMember(o, "samplers", samplerIt) && IsArray(GetValue(samplerIt))) {
+      const json &sampler_array = GetValue(samplerIt);
+
+      json_const_array_iterator it = ArrayBegin(sampler_array);
+      json_const_array_iterator itEnd = ArrayEnd(sampler_array);
+
+      for (; it != itEnd; ++it) {
+        const json &s = *it;
+
+        AnimationSampler sampler;
+        int inputIndex = -1;
+        int outputIndex = -1;
+        if (!ParseIntegerProperty(&inputIndex, err, s, "input", true)) {
+          if (err) {
+            (*err) += "`input` field is missing in animation.sampler\n";
+          }
+          return false;
+        }
+        ParseStringProperty(&sampler.interpolation, err, s, "interpolation",
+                            false);
+        if (!ParseIntegerProperty(&outputIndex, err, s, "output", true)) {
+          if (err) {
+            (*err) += "`output` field is missing in animation.sampler\n";
+          }
+          return false;
+        }
+        sampler.input = inputIndex;
+        sampler.output = outputIndex;
+        ParseExtensionsProperty(&(sampler.extensions), err, o);
+        ParseExtrasProperty(&(sampler.extras), s);
+
+        if (store_original_json_for_extras_and_extensions) {
+          {
+            json_const_iterator eit;
+            if (FindMember(o, "extensions", eit)) {
+              sampler.extensions_json_string = JsonToString(GetValue(eit));
+            }
+          }
+          {
+            json_const_iterator eit;
+            if (FindMember(o, "extras", eit)) {
+              sampler.extras_json_string = JsonToString(GetValue(eit));
+            }
+          }
+        }
+
+        animation->samplers.emplace_back(std::move(sampler));
+      }
+    }
+  }
+
+  ParseStringProperty(&animation->name, err, o, "name", false);
+
+  ParseExtensionsProperty(&animation->extensions, err, o);
+  ParseExtrasProperty(&(animation->extras), o);
+
+  if (store_original_json_for_extras_and_extensions) {
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extensions", it)) {
+        animation->extensions_json_string = JsonToString(GetValue(it));
+      }
+    }
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extras", it)) {
+        animation->extras_json_string = JsonToString(GetValue(it));
+      }
+    }
+  }
+
+  return true;
+}
+
+static bool ParseSampler(Sampler *sampler, std::string *err, const json &o,
+                         bool store_original_json_for_extras_and_extensions) {
+  ParseStringProperty(&sampler->name, err, o, "name", false);
+
+  int minFilter = -1;
+  int magFilter = -1;
+  int wrapS = TINYGLTF_TEXTURE_WRAP_REPEAT;
+  int wrapT = TINYGLTF_TEXTURE_WRAP_REPEAT;
+  int wrapR = TINYGLTF_TEXTURE_WRAP_REPEAT;
+  ParseIntegerProperty(&minFilter, err, o, "minFilter", false);
+  ParseIntegerProperty(&magFilter, err, o, "magFilter", false);
+  ParseIntegerProperty(&wrapS, err, o, "wrapS", false);
+  ParseIntegerProperty(&wrapT, err, o, "wrapT", false);
+  ParseIntegerProperty(&wrapR, err, o, "wrapR", false);  // tinygltf extension
+
+  // TODO(syoyo): Check the value is alloed one.
+  // (e.g. we allow 9728(NEAREST), but don't allow 9727)
+
+  sampler->minFilter = minFilter;
+  sampler->magFilter = magFilter;
+  sampler->wrapS = wrapS;
+  sampler->wrapT = wrapT;
+  sampler->wrapR = wrapR;
+
+  ParseExtensionsProperty(&(sampler->extensions), err, o);
+  ParseExtrasProperty(&(sampler->extras), o);
+
+  if (store_original_json_for_extras_and_extensions) {
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extensions", it)) {
+        sampler->extensions_json_string = JsonToString(GetValue(it));
+      }
+    }
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extras", it)) {
+        sampler->extras_json_string = JsonToString(GetValue(it));
+      }
+    }
+  }
+
+  return true;
+}
+
+static bool ParseSkin(Skin *skin, std::string *err, const json &o,
+                      bool store_original_json_for_extras_and_extensions) {
+  ParseStringProperty(&skin->name, err, o, "name", false, "Skin");
+
+  std::vector<int> joints;
+  if (!ParseIntegerArrayProperty(&joints, err, o, "joints", false, "Skin")) {
+    return false;
+  }
+  skin->joints = std::move(joints);
+
+  int skeleton = -1;
+  ParseIntegerProperty(&skeleton, err, o, "skeleton", false, "Skin");
+  skin->skeleton = skeleton;
+
+  int invBind = -1;
+  ParseIntegerProperty(&invBind, err, o, "inverseBindMatrices", true, "Skin");
+  skin->inverseBindMatrices = invBind;
+
+  ParseExtensionsProperty(&(skin->extensions), err, o);
+  ParseExtrasProperty(&(skin->extras), o);
+
+  if (store_original_json_for_extras_and_extensions) {
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extensions", it)) {
+        skin->extensions_json_string = JsonToString(GetValue(it));
+      }
+    }
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extras", it)) {
+        skin->extras_json_string = JsonToString(GetValue(it));
+      }
+    }
+  }
+
+  return true;
+}
+
+static bool ParsePerspectiveCamera(
+    PerspectiveCamera *camera, std::string *err, const json &o,
+    bool store_original_json_for_extras_and_extensions) {
+  double yfov = 0.0;
+  if (!ParseNumberProperty(&yfov, err, o, "yfov", true, "OrthographicCamera")) {
+    return false;
+  }
+
+  double znear = 0.0;
+  if (!ParseNumberProperty(&znear, err, o, "znear", true,
+                           "PerspectiveCamera")) {
+    return false;
+  }
+
+  double aspectRatio = 0.0;  // = invalid
+  ParseNumberProperty(&aspectRatio, err, o, "aspectRatio", false,
+                      "PerspectiveCamera");
+
+  double zfar = 0.0;  // = invalid
+  ParseNumberProperty(&zfar, err, o, "zfar", false, "PerspectiveCamera");
+
+  camera->aspectRatio = aspectRatio;
+  camera->zfar = zfar;
+  camera->yfov = yfov;
+  camera->znear = znear;
+
+  ParseExtensionsProperty(&camera->extensions, err, o);
+  ParseExtrasProperty(&(camera->extras), o);
+
+  if (store_original_json_for_extras_and_extensions) {
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extensions", it)) {
+        camera->extensions_json_string = JsonToString(GetValue(it));
+      }
+    }
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extras", it)) {
+        camera->extras_json_string = JsonToString(GetValue(it));
+      }
+    }
+  }
+
+  // TODO(syoyo): Validate parameter values.
+
+  return true;
+}
+
+static bool ParseSpotLight(SpotLight *light, std::string *err, const json &o,
+                           bool store_original_json_for_extras_and_extensions) {
+  ParseNumberProperty(&light->innerConeAngle, err, o, "innerConeAngle", false);
+  ParseNumberProperty(&light->outerConeAngle, err, o, "outerConeAngle", false);
+
+  ParseExtensionsProperty(&light->extensions, err, o);
+  ParseExtrasProperty(&light->extras, o);
+
+  if (store_original_json_for_extras_and_extensions) {
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extensions", it)) {
+        light->extensions_json_string = JsonToString(GetValue(it));
+      }
+    }
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extras", it)) {
+        light->extras_json_string = JsonToString(GetValue(it));
+      }
+    }
+  }
+
+  // TODO(syoyo): Validate parameter values.
+
+  return true;
+}
+
+static bool ParseOrthographicCamera(
+    OrthographicCamera *camera, std::string *err, const json &o,
+    bool store_original_json_for_extras_and_extensions) {
+  double xmag = 0.0;
+  if (!ParseNumberProperty(&xmag, err, o, "xmag", true, "OrthographicCamera")) {
+    return false;
+  }
+
+  double ymag = 0.0;
+  if (!ParseNumberProperty(&ymag, err, o, "ymag", true, "OrthographicCamera")) {
+    return false;
+  }
+
+  double zfar = 0.0;
+  if (!ParseNumberProperty(&zfar, err, o, "zfar", true, "OrthographicCamera")) {
+    return false;
+  }
+
+  double znear = 0.0;
+  if (!ParseNumberProperty(&znear, err, o, "znear", true,
+                           "OrthographicCamera")) {
+    return false;
+  }
+
+  ParseExtensionsProperty(&camera->extensions, err, o);
+  ParseExtrasProperty(&(camera->extras), o);
+
+  if (store_original_json_for_extras_and_extensions) {
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extensions", it)) {
+        camera->extensions_json_string = JsonToString(GetValue(it));
+      }
+    }
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extras", it)) {
+        camera->extras_json_string = JsonToString(GetValue(it));
+      }
+    }
+  }
+
+  camera->xmag = xmag;
+  camera->ymag = ymag;
+  camera->zfar = zfar;
+  camera->znear = znear;
+
+  // TODO(syoyo): Validate parameter values.
+
+  return true;
+}
+
+static bool ParseCamera(Camera *camera, std::string *err, const json &o,
+                        bool store_original_json_for_extras_and_extensions) {
+  if (!ParseStringProperty(&camera->type, err, o, "type", true, "Camera")) {
+    return false;
+  }
+
+  if (camera->type.compare("orthographic") == 0) {
+    json_const_iterator orthoIt;
+    if (!FindMember(o, "orthographic", orthoIt)) {
+      if (err) {
+        std::stringstream ss;
+        ss << "Orhographic camera description not found." << std::endl;
+        (*err) += ss.str();
+      }
+      return false;
+    }
+
+    const json &v = GetValue(orthoIt);
+    if (!IsObject(v)) {
+      if (err) {
+        std::stringstream ss;
+        ss << "\"orthographic\" is not a JSON object." << std::endl;
+        (*err) += ss.str();
+      }
+      return false;
+    }
+
+    if (!ParseOrthographicCamera(
+            &camera->orthographic, err, v,
+            store_original_json_for_extras_and_extensions)) {
+      return false;
+    }
+  } else if (camera->type.compare("perspective") == 0) {
+    json_const_iterator perspIt;
+    if (!FindMember(o, "perspective", perspIt)) {
+      if (err) {
+        std::stringstream ss;
+        ss << "Perspective camera description not found." << std::endl;
+        (*err) += ss.str();
+      }
+      return false;
+    }
+
+    const json &v = GetValue(perspIt);
+    if (!IsObject(v)) {
+      if (err) {
+        std::stringstream ss;
+        ss << "\"perspective\" is not a JSON object." << std::endl;
+        (*err) += ss.str();
+      }
+      return false;
+    }
+
+    if (!ParsePerspectiveCamera(
+            &camera->perspective, err, v,
+            store_original_json_for_extras_and_extensions)) {
+      return false;
+    }
+  } else {
+    if (err) {
+      std::stringstream ss;
+      ss << "Invalid camera type: \"" << camera->type
+         << "\". Must be \"perspective\" or \"orthographic\"" << std::endl;
+      (*err) += ss.str();
+    }
+    return false;
+  }
+
+  ParseStringProperty(&camera->name, err, o, "name", false);
+
+  ParseExtensionsProperty(&camera->extensions, err, o);
+  ParseExtrasProperty(&(camera->extras), o);
+
+  if (store_original_json_for_extras_and_extensions) {
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extensions", it)) {
+        camera->extensions_json_string = JsonToString(GetValue(it));
+      }
+    }
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extras", it)) {
+        camera->extras_json_string = JsonToString(GetValue(it));
+      }
+    }
+  }
+
+  return true;
+}
+
+static bool ParseLight(Light *light, std::string *err, const json &o,
+                       bool store_original_json_for_extras_and_extensions) {
+  if (!ParseStringProperty(&light->type, err, o, "type", true)) {
+    return false;
+  }
+
+  if (light->type == "spot") {
+    json_const_iterator spotIt;
+    if (!FindMember(o, "spot", spotIt)) {
+      if (err) {
+        std::stringstream ss;
+        ss << "Spot light description not found." << std::endl;
+        (*err) += ss.str();
+      }
+      return false;
+    }
+
+    const json &v = GetValue(spotIt);
+    if (!IsObject(v)) {
+      if (err) {
+        std::stringstream ss;
+        ss << "\"spot\" is not a JSON object." << std::endl;
+        (*err) += ss.str();
+      }
+      return false;
+    }
+
+    if (!ParseSpotLight(&light->spot, err, v,
+                        store_original_json_for_extras_and_extensions)) {
+      return false;
+    }
+  }
+
+  ParseStringProperty(&light->name, err, o, "name", false);
+  ParseNumberArrayProperty(&light->color, err, o, "color", false);
+  ParseNumberProperty(&light->range, err, o, "range", false);
+  ParseNumberProperty(&light->intensity, err, o, "intensity", false);
+  ParseExtensionsProperty(&light->extensions, err, o);
+  ParseExtrasProperty(&(light->extras), o);
+
+  if (store_original_json_for_extras_and_extensions) {
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extensions", it)) {
+        light->extensions_json_string = JsonToString(GetValue(it));
+      }
+    }
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extras", it)) {
+        light->extras_json_string = JsonToString(GetValue(it));
+      }
+    }
+  }
+
+  return true;
+}
+
+bool TinyGLTF::LoadFromString(Model *model, std::string *err, std::string *warn,
+                              const char *json_str,
+                              unsigned int json_str_length,
+                              const std::string &base_dir,
+                              unsigned int check_sections) {
+  if (json_str_length < 4) {
+    if (err) {
+      (*err) = "JSON string too short.\n";
+    }
+    return false;
+  }
+
+  JsonDocument v;
+
+#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || \
+     defined(_CPPUNWIND)) &&                               \
+    !defined(TINYGLTF_NOEXCEPTION)
+  try {
+    JsonParse(v, json_str, json_str_length, true);
+
+  } catch (const std::exception &e) {
+    if (err) {
+      (*err) = e.what();
+    }
+    return false;
+  }
+#else
+  {
+    JsonParse(v, json_str, json_str_length);
+
+    if (!IsObject(v)) {
+      // Assume parsing was failed.
+      if (err) {
+        (*err) = "Failed to parse JSON object\n";
+      }
+      return false;
+    }
+  }
+#endif
+
+  if (!IsObject(v)) {
+    // root is not an object.
+    if (err) {
+      (*err) = "Root element is not a JSON object\n";
+    }
+    return false;
+  }
+
+  {
+    bool version_found = false;
+    json_const_iterator it;
+    if (FindMember(v, "asset", it) && IsObject(GetValue(it))) {
+      auto &itObj = GetValue(it);
+      json_const_iterator version_it;
+      std::string versionStr;
+      if (FindMember(itObj, "version", version_it) &&
+          GetString(GetValue(version_it), versionStr)) {
+        version_found = true;
+      }
+    }
+    if (version_found) {
+      // OK
+    } else if (check_sections & REQUIRE_VERSION) {
+      if (err) {
+        (*err) += "\"asset\" object not found in .gltf or not an object type\n";
+      }
+      return false;
+    }
+  }
+
+  // scene is not mandatory.
+  // FIXME Maybe a better way to handle it than removing the code
+
+  auto IsArrayMemberPresent = [](const json &_v, const char *name) -> bool {
+    json_const_iterator it;
+    return FindMember(_v, name, it) && IsArray(GetValue(it));
+  };
+
+  {
+    if ((check_sections & REQUIRE_SCENES) &&
+        !IsArrayMemberPresent(v, "scenes")) {
+      if (err) {
+        (*err) += "\"scenes\" object not found in .gltf or not an array type\n";
+      }
+      return false;
+    }
+  }
+
+  {
+    if ((check_sections & REQUIRE_NODES) && !IsArrayMemberPresent(v, "nodes")) {
+      if (err) {
+        (*err) += "\"nodes\" object not found in .gltf\n";
+      }
+      return false;
+    }
+  }
+
+  {
+    if ((check_sections & REQUIRE_ACCESSORS) &&
+        !IsArrayMemberPresent(v, "accessors")) {
+      if (err) {
+        (*err) += "\"accessors\" object not found in .gltf\n";
+      }
+      return false;
+    }
+  }
+
+  {
+    if ((check_sections & REQUIRE_BUFFERS) &&
+        !IsArrayMemberPresent(v, "buffers")) {
+      if (err) {
+        (*err) += "\"buffers\" object not found in .gltf\n";
+      }
+      return false;
+    }
+  }
+
+  {
+    if ((check_sections & REQUIRE_BUFFER_VIEWS) &&
+        !IsArrayMemberPresent(v, "bufferViews")) {
+      if (err) {
+        (*err) += "\"bufferViews\" object not found in .gltf\n";
+      }
+      return false;
+    }
+  }
+
+  model->buffers.clear();
+  model->bufferViews.clear();
+  model->accessors.clear();
+  model->meshes.clear();
+  model->cameras.clear();
+  model->nodes.clear();
+  model->extensionsUsed.clear();
+  model->extensionsRequired.clear();
+  model->extensions.clear();
+  model->defaultScene = -1;
+
+  // 1. Parse Asset
+  {
+    json_const_iterator it;
+    if (FindMember(v, "asset", it) && IsObject(GetValue(it))) {
+      const json &root = GetValue(it);
+
+      ParseAsset(&model->asset, err, root,
+                 store_original_json_for_extras_and_extensions_);
+    }
+  }
+
+#ifdef TINYGLTF_USE_CPP14
+  auto ForEachInArray = [](const json &_v, const char *member,
+                           const auto &cb) -> bool
+#else
+  // The std::function<> implementation can be less efficient because it will
+  // allocate heap when the size of the captured lambda is above 16 bytes with
+  // clang and gcc, but it does not require C++14.
+  auto ForEachInArray = [](const json &_v, const char *member,
+                           const std::function<bool(const json &)> &cb) -> bool
+#endif
+  {
+    json_const_iterator itm;
+    if (FindMember(_v, member, itm) && IsArray(GetValue(itm))) {
+      const json &root = GetValue(itm);
+      auto it = ArrayBegin(root);
+      auto end = ArrayEnd(root);
+      for (; it != end; ++it) {
+        if (!cb(*it)) return false;
+      }
+    }
+    return true;
+  };
+
+  // 2. Parse extensionUsed
+  {
+    ForEachInArray(v, "extensionsUsed", [&](const json &o) {
+      std::string str;
+      GetString(o, str);
+      model->extensionsUsed.emplace_back(std::move(str));
+      return true;
+    });
+  }
+
+  {
+    ForEachInArray(v, "extensionsRequired", [&](const json &o) {
+      std::string str;
+      GetString(o, str);
+      model->extensionsRequired.emplace_back(std::move(str));
+      return true;
+    });
+  }
+
+  // 3. Parse Buffer
+  {
+    bool success = ForEachInArray(v, "buffers", [&](const json &o) {
+      if (!IsObject(o)) {
+        if (err) {
+          (*err) += "`buffers' does not contain an JSON object.";
+        }
+        return false;
+      }
+      Buffer buffer;
+      if (!ParseBuffer(&buffer, err, o,
+                       store_original_json_for_extras_and_extensions_, &fs,
+                       base_dir, is_binary_, bin_data_, bin_size_)) {
+        return false;
+      }
+
+      model->buffers.emplace_back(std::move(buffer));
+      return true;
+    });
+
+    if (!success) {
+      return false;
+    }
+  }
+  // 4. Parse BufferView
+  {
+    bool success = ForEachInArray(v, "bufferViews", [&](const json &o) {
+      if (!IsObject(o)) {
+        if (err) {
+          (*err) += "`bufferViews' does not contain an JSON object.";
+        }
+        return false;
+      }
+      BufferView bufferView;
+      if (!ParseBufferView(&bufferView, err, o,
+                           store_original_json_for_extras_and_extensions_)) {
+        return false;
+      }
+
+      model->bufferViews.emplace_back(std::move(bufferView));
+      return true;
+    });
+
+    if (!success) {
+      return false;
+    }
+  }
+
+  // 5. Parse Accessor
+  {
+    bool success = ForEachInArray(v, "accessors", [&](const json &o) {
+      if (!IsObject(o)) {
+        if (err) {
+          (*err) += "`accessors' does not contain an JSON object.";
+        }
+        return false;
+      }
+      Accessor accessor;
+      if (!ParseAccessor(&accessor, err, o,
+                         store_original_json_for_extras_and_extensions_)) {
+        return false;
+      }
+
+      model->accessors.emplace_back(std::move(accessor));
+      return true;
+    });
+
+    if (!success) {
+      return false;
+    }
+  }
+
+  // 6. Parse Mesh
+  {
+    bool success = ForEachInArray(v, "meshes", [&](const json &o) {
+      if (!IsObject(o)) {
+        if (err) {
+          (*err) += "`meshes' does not contain an JSON object.";
+        }
+        return false;
+      }
+      Mesh mesh;
+      if (!ParseMesh(&mesh, model, err, o,
+                     store_original_json_for_extras_and_extensions_)) {
+        return false;
+      }
+
+      model->meshes.emplace_back(std::move(mesh));
+      return true;
+    });
+
+    if (!success) {
+      return false;
+    }
+  }
+
+  // Assign missing bufferView target types
+  // - Look for missing Mesh indices
+  // - Look for missing Mesh attributes
+  for (auto &mesh : model->meshes) {
+    for (auto &primitive : mesh.primitives) {
+      if (primitive.indices >
+          -1)  // has indices from parsing step, must be Element Array Buffer
+      {
+        if (size_t(primitive.indices) >= model->accessors.size()) {
+          if (err) {
+            (*err) += "primitive indices accessor out of bounds";
+          }
+          return false;
+        }
+
+        auto bufferView =
+            model->accessors[size_t(primitive.indices)].bufferView;
+        if (bufferView < 0 || size_t(bufferView) >= model->bufferViews.size()) {
+          if (err) {
+            (*err) += "accessor[" + std::to_string(primitive.indices) +
+                      "] invalid bufferView";
+          }
+          return false;
+        }
+
+        model->bufferViews[size_t(bufferView)].target =
+            TINYGLTF_TARGET_ELEMENT_ARRAY_BUFFER;
+        // we could optionally check if acessors' bufferView type is Scalar, as
+        // it should be
+      }
+
+      for (auto &attribute : primitive.attributes) {
+        model
+            ->bufferViews[size_t(
+                model->accessors[size_t(attribute.second)].bufferView)]
+            .target = TINYGLTF_TARGET_ARRAY_BUFFER;
+      }
+
+      for (auto &target : primitive.targets) {
+        for (auto &attribute : target) {
+          auto bufferView =
+              model->accessors[size_t(attribute.second)].bufferView;
+          // bufferView could be null(-1) for sparse morph target
+          if (bufferView >= 0) {
+            model->bufferViews[size_t(bufferView)].target =
+                TINYGLTF_TARGET_ARRAY_BUFFER;
+          }
+        }
+      }
+    }
+  }
+
+  // 7. Parse Node
+  {
+    bool success = ForEachInArray(v, "nodes", [&](const json &o) {
+      if (!IsObject(o)) {
+        if (err) {
+          (*err) += "`nodes' does not contain an JSON object.";
+        }
+        return false;
+      }
+      Node node;
+      if (!ParseNode(&node, err, o,
+                     store_original_json_for_extras_and_extensions_)) {
+        return false;
+      }
+
+      model->nodes.emplace_back(std::move(node));
+      return true;
+    });
+
+    if (!success) {
+      return false;
+    }
+  }
+
+  // 8. Parse scenes.
+  {
+    bool success = ForEachInArray(v, "scenes", [&](const json &o) {
+      if (!IsObject(o)) {
+        if (err) {
+          (*err) += "`scenes' does not contain an JSON object.";
+        }
+        return false;
+      }
+      std::vector<int> nodes;
+      ParseIntegerArrayProperty(&nodes, err, o, "nodes", false);
+
+      Scene scene;
+      scene.nodes = std::move(nodes);
+
+      ParseStringProperty(&scene.name, err, o, "name", false);
+
+      ParseExtensionsProperty(&scene.extensions, err, o);
+      ParseExtrasProperty(&scene.extras, o);
+
+      if (store_original_json_for_extras_and_extensions_) {
+        {
+          json_const_iterator it;
+          if (FindMember(o, "extensions", it)) {
+            model->extensions_json_string = JsonToString(GetValue(it));
+          }
+        }
+        {
+          json_const_iterator it;
+          if (FindMember(o, "extras", it)) {
+            model->extras_json_string = JsonToString(GetValue(it));
+          }
+        }
+      }
+
+      model->scenes.emplace_back(std::move(scene));
+      return true;
+    });
+
+    if (!success) {
+      return false;
+    }
+  }
+
+  // 9. Parse default scenes.
+  {
+    json_const_iterator rootIt;
+    int iVal;
+    if (FindMember(v, "scene", rootIt) && GetInt(GetValue(rootIt), iVal)) {
+      model->defaultScene = iVal;
+    }
+  }
+
+  // 10. Parse Material
+  {
+    bool success = ForEachInArray(v, "materials", [&](const json &o) {
+      if (!IsObject(o)) {
+        if (err) {
+          (*err) += "`materials' does not contain an JSON object.";
+        }
+        return false;
+      }
+      Material material;
+      ParseStringProperty(&material.name, err, o, "name", false);
+
+      if (!ParseMaterial(&material, err, o,
+                         store_original_json_for_extras_and_extensions_)) {
+        return false;
+      }
+
+      model->materials.emplace_back(std::move(material));
+      return true;
+    });
+
+    if (!success) {
+      return false;
+    }
+  }
+
+  // 11. Parse Image
+  {
+    int idx = 0;
+    bool success = ForEachInArray(v, "images", [&](const json &o) {
+      if (!IsObject(o)) {
+        if (err) {
+          (*err) += "image[" + std::to_string(idx) + "] is not a JSON object.";
+        }
+        return false;
+      }
+      Image image;
+      if (!ParseImage(&image, idx, err, warn, o,
+                      store_original_json_for_extras_and_extensions_, base_dir,
+                      &fs, &this->LoadImageData, load_image_user_data_)) {
+        return false;
+      }
+
+      if (image.bufferView != -1) {
+        // Load image from the buffer view.
+        if (size_t(image.bufferView) >= model->bufferViews.size()) {
+          if (err) {
+            std::stringstream ss;
+            ss << "image[" << idx << "] bufferView \"" << image.bufferView
+               << "\" not found in the scene." << std::endl;
+            (*err) += ss.str();
+          }
+          return false;
+        }
+
+        const BufferView &bufferView =
+            model->bufferViews[size_t(image.bufferView)];
+        if (size_t(bufferView.buffer) >= model->buffers.size()) {
+          if (err) {
+            std::stringstream ss;
+            ss << "image[" << idx << "] buffer \"" << bufferView.buffer
+               << "\" not found in the scene." << std::endl;
+            (*err) += ss.str();
+          }
+          return false;
+        }
+        const Buffer &buffer = model->buffers[size_t(bufferView.buffer)];
+
+        if (*LoadImageData == nullptr) {
+          if (err) {
+            (*err) += "No LoadImageData callback specified.\n";
+          }
+          return false;
+        }
+        bool ret = LoadImageData(
+            &image, idx, err, warn, image.width, image.height,
+            &buffer.data[bufferView.byteOffset],
+            static_cast<int>(bufferView.byteLength), load_image_user_data_);
+        if (!ret) {
+          return false;
+        }
+      }
+
+      model->images.emplace_back(std::move(image));
+      ++idx;
+      return true;
+    });
+
+    if (!success) {
+      return false;
+    }
+  }
+
+  // 12. Parse Texture
+  {
+    bool success = ForEachInArray(v, "textures", [&](const json &o) {
+      if (!IsObject(o)) {
+        if (err) {
+          (*err) += "`textures' does not contain an JSON object.";
+        }
+        return false;
+      }
+      Texture texture;
+      if (!ParseTexture(&texture, err, o,
+                        store_original_json_for_extras_and_extensions_,
+                        base_dir)) {
+        return false;
+      }
+
+      model->textures.emplace_back(std::move(texture));
+      return true;
+    });
+
+    if (!success) {
+      return false;
+    }
+  }
+
+  // 13. Parse Animation
+  {
+    bool success = ForEachInArray(v, "animations", [&](const json &o) {
+      if (!IsObject(o)) {
+        if (err) {
+          (*err) += "`animations' does not contain an JSON object.";
+        }
+        return false;
+      }
+      Animation animation;
+      if (!ParseAnimation(&animation, err, o,
+                          store_original_json_for_extras_and_extensions_)) {
+        return false;
+      }
+
+      model->animations.emplace_back(std::move(animation));
+      return true;
+    });
+
+    if (!success) {
+      return false;
+    }
+  }
+
+  // 14. Parse Skin
+  {
+    bool success = ForEachInArray(v, "skins", [&](const json &o) {
+      if (!IsObject(o)) {
+        if (err) {
+          (*err) += "`skins' does not contain an JSON object.";
+        }
+        return false;
+      }
+      Skin skin;
+      if (!ParseSkin(&skin, err, o,
+                     store_original_json_for_extras_and_extensions_)) {
+        return false;
+      }
+
+      model->skins.emplace_back(std::move(skin));
+      return true;
+    });
+
+    if (!success) {
+      return false;
+    }
+  }
+
+  // 15. Parse Sampler
+  {
+    bool success = ForEachInArray(v, "samplers", [&](const json &o) {
+      if (!IsObject(o)) {
+        if (err) {
+          (*err) += "`samplers' does not contain an JSON object.";
+        }
+        return false;
+      }
+      Sampler sampler;
+      if (!ParseSampler(&sampler, err, o,
+                        store_original_json_for_extras_and_extensions_)) {
+        return false;
+      }
+
+      model->samplers.emplace_back(std::move(sampler));
+      return true;
+    });
+
+    if (!success) {
+      return false;
+    }
+  }
+
+  // 16. Parse Camera
+  {
+    bool success = ForEachInArray(v, "cameras", [&](const json &o) {
+      if (!IsObject(o)) {
+        if (err) {
+          (*err) += "`cameras' does not contain an JSON object.";
+        }
+        return false;
+      }
+      Camera camera;
+      if (!ParseCamera(&camera, err, o,
+                       store_original_json_for_extras_and_extensions_)) {
+        return false;
+      }
+
+      model->cameras.emplace_back(std::move(camera));
+      return true;
+    });
+
+    if (!success) {
+      return false;
+    }
+  }
+
+  // 17. Parse Extensions
+  ParseExtensionsProperty(&model->extensions, err, v);
+
+  // 18. Specific extension implementations
+  {
+    json_const_iterator rootIt;
+    if (FindMember(v, "extensions", rootIt) && IsObject(GetValue(rootIt))) {
+      const json &root = GetValue(rootIt);
+
+      json_const_iterator it(ObjectBegin(root));
+      json_const_iterator itEnd(ObjectEnd(root));
+      for (; it != itEnd; ++it) {
+        // parse KHR_lights_punctual extension
+        std::string key(GetKey(it));
+        if ((key == "KHR_lights_punctual") && IsObject(GetValue(it))) {
+          const json &object = GetValue(it);
+          json_const_iterator itLight;
+          if (FindMember(object, "lights", itLight)) {
+            const json &lights = GetValue(itLight);
+            if (!IsArray(lights)) {
+              continue;
+            }
+
+            auto arrayIt(ArrayBegin(lights));
+            auto arrayItEnd(ArrayEnd(lights));
+            for (; arrayIt != arrayItEnd; ++arrayIt) {
+              Light light;
+              if (!ParseLight(&light, err, *arrayIt,
+                              store_original_json_for_extras_and_extensions_)) {
+                return false;
+              }
+              model->lights.emplace_back(std::move(light));
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // 19. Parse Extras
+  ParseExtrasProperty(&model->extras, v);
+
+  if (store_original_json_for_extras_and_extensions_) {
+    model->extras_json_string = JsonToString(v["extras"]);
+    model->extensions_json_string = JsonToString(v["extensions"]);
+  }
+
+  return true;
+}
+
+bool TinyGLTF::LoadASCIIFromString(Model *model, std::string *err,
+                                   std::string *warn, const char *str,
+                                   unsigned int length,
+                                   const std::string &base_dir,
+                                   unsigned int check_sections) {
+  is_binary_ = false;
+  bin_data_ = nullptr;
+  bin_size_ = 0;
+
+  return LoadFromString(model, err, warn, str, length, base_dir,
+                        check_sections);
+}
+
+bool TinyGLTF::LoadASCIIFromFile(Model *model, std::string *err,
+                                 std::string *warn, const std::string &filename,
+                                 unsigned int check_sections) {
+  std::stringstream ss;
+
+  if (fs.ReadWholeFile == nullptr) {
+    // Programmer error, assert() ?
+    ss << "Failed to read file: " << filename
+       << ": one or more FS callback not set" << std::endl;
+    if (err) {
+      (*err) = ss.str();
+    }
+    return false;
+  }
+
+  std::vector<unsigned char> data;
+  std::string fileerr;
+  bool fileread = fs.ReadWholeFile(&data, &fileerr, filename, fs.user_data);
+  if (!fileread) {
+    ss << "Failed to read file: " << filename << ": " << fileerr << std::endl;
+    if (err) {
+      (*err) = ss.str();
+    }
+    return false;
+  }
+
+  size_t sz = data.size();
+  if (sz == 0) {
+    if (err) {
+      (*err) = "Empty file.";
+    }
+    return false;
+  }
+
+  std::string basedir = GetBaseDir(filename);
+
+  bool ret = LoadASCIIFromString(
+      model, err, warn, reinterpret_cast<const char *>(&data.at(0)),
+      static_cast<unsigned int>(data.size()), basedir, check_sections);
+
+  return ret;
+}
+
+bool TinyGLTF::LoadBinaryFromMemory(Model *model, std::string *err,
+                                    std::string *warn,
+                                    const unsigned char *bytes,
+                                    unsigned int size,
+                                    const std::string &base_dir,
+                                    unsigned int check_sections) {
+  if (size < 20) {
+    if (err) {
+      (*err) = "Too short data size for glTF Binary.";
+    }
+    return false;
+  }
+
+  if (bytes[0] == 'g' && bytes[1] == 'l' && bytes[2] == 'T' &&
+      bytes[3] == 'F') {
+    // ok
+  } else {
+    if (err) {
+      (*err) = "Invalid magic.";
+    }
+    return false;
+  }
+
+  unsigned int version;       // 4 bytes
+  unsigned int length;        // 4 bytes
+  unsigned int model_length;  // 4 bytes
+  unsigned int model_format;  // 4 bytes;
+
+  // @todo { Endian swap for big endian machine. }
+  memcpy(&version, bytes + 4, 4);
+  swap4(&version);
+  memcpy(&length, bytes + 8, 4);
+  swap4(&length);
+  memcpy(&model_length, bytes + 12, 4);
+  swap4(&model_length);
+  memcpy(&model_format, bytes + 16, 4);
+  swap4(&model_format);
+
+  // In case the Bin buffer is not present, the size is exactly 20 + size of
+  // JSON contents,
+  // so use "greater than" operator.
+  if ((20 + model_length > size) || (model_length < 1) || (length > size) ||
+      (20 + model_length > length) ||
+      (model_format != 0x4E4F534A)) {  // 0x4E4F534A = JSON format.
+    if (err) {
+      (*err) = "Invalid glTF binary.";
+    }
+    return false;
+  }
+
+  // Extract JSON string.
+  std::string jsonString(reinterpret_cast<const char *>(&bytes[20]),
+                         model_length);
+
+  is_binary_ = true;
+  bin_data_ = bytes + 20 + model_length +
+              8;  // 4 bytes (buffer_length) + 4 bytes(buffer_format)
+  bin_size_ =
+      length - (20 + model_length);  // extract header + JSON scene data.
+
+  bool ret = LoadFromString(model, err, warn,
+                            reinterpret_cast<const char *>(&bytes[20]),
+                            model_length, base_dir, check_sections);
+  if (!ret) {
+    return ret;
+  }
+
+  return true;
+}
+
+bool TinyGLTF::LoadBinaryFromFile(Model *model, std::string *err,
+                                  std::string *warn,
+                                  const std::string &filename,
+                                  unsigned int check_sections) {
+  std::stringstream ss;
+
+  if (fs.ReadWholeFile == nullptr) {
+    // Programmer error, assert() ?
+    ss << "Failed to read file: " << filename
+       << ": one or more FS callback not set" << std::endl;
+    if (err) {
+      (*err) = ss.str();
+    }
+    return false;
+  }
+
+  std::vector<unsigned char> data;
+  std::string fileerr;
+  bool fileread = fs.ReadWholeFile(&data, &fileerr, filename, fs.user_data);
+  if (!fileread) {
+    ss << "Failed to read file: " << filename << ": " << fileerr << std::endl;
+    if (err) {
+      (*err) = ss.str();
+    }
+    return false;
+  }
+
+  std::string basedir = GetBaseDir(filename);
+
+  bool ret = LoadBinaryFromMemory(model, err, warn, &data.at(0),
+                                  static_cast<unsigned int>(data.size()),
+                                  basedir, check_sections);
+
+  return ret;
+}
+
+///////////////////////
+// GLTF Serialization
+///////////////////////
+namespace {
+json JsonFromString(const char *s) {
+#ifdef TINYGLTF_USE_RAPIDJSON
+  return json(s, GetAllocator());
+#else
+  return json(s);
+#endif
+}
+
+void JsonAssign(json &dest, const json &src) {
+#ifdef TINYGLTF_USE_RAPIDJSON
+  dest.CopyFrom(src, GetAllocator());
+#else
+  dest = src;
+#endif
+}
+
+void JsonAddMember(json &o, const char *key, json &&value) {
+#ifdef TINYGLTF_USE_RAPIDJSON
+  if (!o.IsObject()) {
+    o.SetObject();
+  }
+  o.AddMember(json(key, GetAllocator()), std::move(value), GetAllocator());
+#else
+  o[key] = std::move(value);
+#endif
+}
+
+void JsonPushBack(json &o, json &&value) {
+#ifdef TINYGLTF_USE_RAPIDJSON
+  o.PushBack(std::move(value), GetAllocator());
+#else
+  o.push_back(std::move(value));
+#endif
+}
+
+bool JsonIsNull(const json &o) {
+#ifdef TINYGLTF_USE_RAPIDJSON
+  return o.IsNull();
+#else
+  return o.is_null();
+#endif
+}
+
+void JsonSetObject(json &o) {
+#ifdef TINYGLTF_USE_RAPIDJSON
+  o.SetObject();
+#else
+  o = o.object({});
+#endif
+}
+
+void JsonReserveArray(json &o, size_t s) {
+#ifdef TINYGLTF_USE_RAPIDJSON
+  o.SetArray();
+  o.Reserve(static_cast<rapidjson::SizeType>(s), GetAllocator());
+#endif
+  (void)(o);
+  (void)(s);
+}
+}  // namespace
+
+// typedef std::pair<std::string, json> json_object_pair;
+
+template <typename T>
+static void SerializeNumberProperty(const std::string &key, T number,
+                                    json &obj) {
+  // obj.insert(
+  //    json_object_pair(key, json(static_cast<double>(number))));
+  // obj[key] = static_cast<double>(number);
+  JsonAddMember(obj, key.c_str(), json(number));
+}
+
+#ifdef TINYGLTF_USE_RAPIDJSON
+template <>
+void SerializeNumberProperty(const std::string &key, size_t number, json &obj) {
+  JsonAddMember(obj, key.c_str(), json(static_cast<uint64_t>(number)));
+}
+#endif
+
+template <typename T>
+static void SerializeNumberArrayProperty(const std::string &key,
+                                         const std::vector<T> &value,
+                                         json &obj) {
+  if (value.empty()) return;
+
+  json ary;
+  JsonReserveArray(ary, value.size());
+  for (const auto &s : value) {
+    JsonPushBack(ary, json(s));
+  }
+  JsonAddMember(obj, key.c_str(), std::move(ary));
+}
+
+static void SerializeStringProperty(const std::string &key,
+                                    const std::string &value, json &obj) {
+  JsonAddMember(obj, key.c_str(), JsonFromString(value.c_str()));
+}
+
+static void SerializeStringArrayProperty(const std::string &key,
+                                         const std::vector<std::string> &value,
+                                         json &obj) {
+  json ary;
+  JsonReserveArray(ary, value.size());
+  for (auto &s : value) {
+    JsonPushBack(ary, JsonFromString(s.c_str()));
+  }
+  JsonAddMember(obj, key.c_str(), std::move(ary));
+}
+
+static bool ValueToJson(const Value &value, json *ret) {
+  json obj;
+#ifdef TINYGLTF_USE_RAPIDJSON
+  switch (value.Type()) {
+    case REAL_TYPE:
+      obj.SetDouble(value.Get<double>());
+      break;
+    case INT_TYPE:
+      obj.SetInt(value.Get<int>());
+      break;
+    case BOOL_TYPE:
+      obj.SetBool(value.Get<bool>());
+      break;
+    case STRING_TYPE:
+      obj.SetString(value.Get<std::string>().c_str(), GetAllocator());
+      break;
+    case ARRAY_TYPE: {
+      obj.SetArray();
+      obj.Reserve(static_cast<rapidjson::SizeType>(value.ArrayLen()),
+                  GetAllocator());
+      for (unsigned int i = 0; i < value.ArrayLen(); ++i) {
+        Value elementValue = value.Get(int(i));
+        json elementJson;
+        if (ValueToJson(value.Get(int(i)), &elementJson))
+          obj.PushBack(std::move(elementJson), GetAllocator());
+      }
+      break;
+    }
+    case BINARY_TYPE:
+      // TODO
+      // obj = json(value.Get<std::vector<unsigned char>>());
+      return false;
+      break;
+    case OBJECT_TYPE: {
+      obj.SetObject();
+      Value::Object objMap = value.Get<Value::Object>();
+      for (auto &it : objMap) {
+        json elementJson;
+        if (ValueToJson(it.second, &elementJson)) {
+          obj.AddMember(json(it.first.c_str(), GetAllocator()),
+                        std::move(elementJson), GetAllocator());
+        }
+      }
+      break;
+    }
+    case NULL_TYPE:
+    default:
+      return false;
+  }
+#else
+  switch (value.Type()) {
+    case REAL_TYPE:
+      obj = json(value.Get<double>());
+      break;
+    case INT_TYPE:
+      obj = json(value.Get<int>());
+      break;
+    case BOOL_TYPE:
+      obj = json(value.Get<bool>());
+      break;
+    case STRING_TYPE:
+      obj = json(value.Get<std::string>());
+      break;
+    case ARRAY_TYPE: {
+      for (unsigned int i = 0; i < value.ArrayLen(); ++i) {
+        Value elementValue = value.Get(int(i));
+        json elementJson;
+        if (ValueToJson(value.Get(int(i)), &elementJson))
+          obj.push_back(elementJson);
+      }
+      break;
+    }
+    case BINARY_TYPE:
+      // TODO
+      // obj = json(value.Get<std::vector<unsigned char>>());
+      return false;
+      break;
+    case OBJECT_TYPE: {
+      Value::Object objMap = value.Get<Value::Object>();
+      for (auto &it : objMap) {
+        json elementJson;
+        if (ValueToJson(it.second, &elementJson)) obj[it.first] = elementJson;
+      }
+      break;
+    }
+    case NULL_TYPE:
+    default:
+      return false;
+  }
+#endif
+  if (ret) *ret = std::move(obj);
+  return true;
+}
+
+static void SerializeValue(const std::string &key, const Value &value,
+                           json &obj) {
+  json ret;
+  if (ValueToJson(value, &ret)) {
+    JsonAddMember(obj, key.c_str(), std::move(ret));
+  }
+}
+
+static void SerializeGltfBufferData(const std::vector<unsigned char> &data,
+                                    json &o) {
+  std::string header = "data:application/octet-stream;base64,";
+  if (data.size() > 0) {
+    std::string encodedData =
+        base64_encode(&data[0], static_cast<unsigned int>(data.size()));
+    SerializeStringProperty("uri", header + encodedData, o);
+  } else {
+    // Issue #229
+    // size 0 is allowd. Just emit mime header.
+    SerializeStringProperty("uri", header, o);
+  }
+}
+
+static bool SerializeGltfBufferData(const std::vector<unsigned char> &data,
+                                    const std::string &binFilename) {
+#ifdef _WIN32
+#if defined(__GLIBCXX__)  // mingw
+  int file_descriptor = _wopen(UTF8ToWchar(binFilename).c_str(),
+                               _O_CREAT | _O_WRONLY | _O_TRUNC | _O_BINARY);
+  __gnu_cxx::stdio_filebuf<char> wfile_buf(
+      file_descriptor, std::ios_base::out | std::ios_base::binary);
+  std::ostream output(&wfile_buf);
+  if (!wfile_buf.is_open()) return false;
+#elif defined(_MSC_VER)
+  std::ofstream output(UTF8ToWchar(binFilename).c_str(), std::ofstream::binary);
+  if (!output.is_open()) return false;
+#else
+  std::ofstream output(binFilename.c_str(), std::ofstream::binary);
+  if (!output.is_open()) return false;
+#endif
+#else
+  std::ofstream output(binFilename.c_str(), std::ofstream::binary);
+  if (!output.is_open()) return false;
+#endif
+  if (data.size() > 0) {
+    output.write(reinterpret_cast<const char *>(&data[0]),
+                 std::streamsize(data.size()));
+  } else {
+    // Issue #229
+    // size 0 will be still valid buffer data.
+    // write empty file.
+  }
+  return true;
+}
+
+#if 0  // FIXME(syoyo): not used. will be removed in the future release.
+static void SerializeParameterMap(ParameterMap &param, json &o) {
+  for (ParameterMap::iterator paramIt = param.begin(); paramIt != param.end();
+       ++paramIt) {
+    if (paramIt->second.number_array.size()) {
+      SerializeNumberArrayProperty<double>(paramIt->first,
+                                           paramIt->second.number_array, o);
+    } else if (paramIt->second.json_double_value.size()) {
+      json json_double_value;
+      for (std::map<std::string, double>::iterator it =
+               paramIt->second.json_double_value.begin();
+           it != paramIt->second.json_double_value.end(); ++it) {
+        if (it->first == "index") {
+          json_double_value[it->first] = paramIt->second.TextureIndex();
+        } else {
+          json_double_value[it->first] = it->second;
+        }
+      }
+
+      o[paramIt->first] = json_double_value;
+    } else if (!paramIt->second.string_value.empty()) {
+      SerializeStringProperty(paramIt->first, paramIt->second.string_value, o);
+    } else if (paramIt->second.has_number_value) {
+      o[paramIt->first] = paramIt->second.number_value;
+    } else {
+      o[paramIt->first] = paramIt->second.bool_value;
+    }
+  }
+}
+#endif
+
+static void SerializeExtensionMap(const ExtensionMap &extensions, json &o) {
+  if (!extensions.size()) return;
+
+  json extMap;
+  for (ExtensionMap::const_iterator extIt = extensions.begin();
+       extIt != extensions.end(); ++extIt) {
+    // Allow an empty object for extension(#97)
+    json ret;
+    bool isNull = true;
+    if (ValueToJson(extIt->second, &ret)) {
+      isNull = JsonIsNull(ret);
+      JsonAddMember(extMap, extIt->first.c_str(), std::move(ret));
+    }
+    if (isNull) {
+      if (!(extIt->first.empty())) {  // name should not be empty, but for sure
+        // create empty object so that an extension name is still included in
+        // json.
+        json empty;
+        JsonSetObject(empty);
+        JsonAddMember(extMap, extIt->first.c_str(), std::move(empty));
+      }
+    }
+  }
+  JsonAddMember(o, "extensions", std::move(extMap));
+}
+
+static void SerializeGltfAccessor(Accessor &accessor, json &o) {
+  if (accessor.bufferView >= 0)
+    SerializeNumberProperty<int>("bufferView", accessor.bufferView, o);
+
+  if (accessor.byteOffset != 0)
+    SerializeNumberProperty<int>("byteOffset", int(accessor.byteOffset), o);
+
+  SerializeNumberProperty<int>("componentType", accessor.componentType, o);
+  SerializeNumberProperty<size_t>("count", accessor.count, o);
+  SerializeNumberArrayProperty<double>("min", accessor.minValues, o);
+  SerializeNumberArrayProperty<double>("max", accessor.maxValues, o);
+  if (accessor.normalized)
+    SerializeValue("normalized", Value(accessor.normalized), o);
+  std::string type;
+  switch (accessor.type) {
+    case TINYGLTF_TYPE_SCALAR:
+      type = "SCALAR";
+      break;
+    case TINYGLTF_TYPE_VEC2:
+      type = "VEC2";
+      break;
+    case TINYGLTF_TYPE_VEC3:
+      type = "VEC3";
+      break;
+    case TINYGLTF_TYPE_VEC4:
+      type = "VEC4";
+      break;
+    case TINYGLTF_TYPE_MAT2:
+      type = "MAT2";
+      break;
+    case TINYGLTF_TYPE_MAT3:
+      type = "MAT3";
+      break;
+    case TINYGLTF_TYPE_MAT4:
+      type = "MAT4";
+      break;
+  }
+
+  SerializeStringProperty("type", type, o);
+  if (!accessor.name.empty()) SerializeStringProperty("name", accessor.name, o);
+
+  if (accessor.extras.Type() != NULL_TYPE) {
+    SerializeValue("extras", accessor.extras, o);
+  }
+}
+
+static void SerializeGltfAnimationChannel(AnimationChannel &channel, json &o) {
+  SerializeNumberProperty("sampler", channel.sampler, o);
+  {
+    json target;
+    SerializeNumberProperty("node", channel.target_node, target);
+    SerializeStringProperty("path", channel.target_path, target);
+
+    SerializeExtensionMap(channel.target_extensions, target);
+
+    JsonAddMember(o, "target", std::move(target));
+  }
+
+  if (channel.extras.Type() != NULL_TYPE) {
+    SerializeValue("extras", channel.extras, o);
+  }
+
+  SerializeExtensionMap(channel.extensions, o);
+}
+
+static void SerializeGltfAnimationSampler(AnimationSampler &sampler, json &o) {
+  SerializeNumberProperty("input", sampler.input, o);
+  SerializeNumberProperty("output", sampler.output, o);
+  SerializeStringProperty("interpolation", sampler.interpolation, o);
+
+  if (sampler.extras.Type() != NULL_TYPE) {
+    SerializeValue("extras", sampler.extras, o);
+  }
+}
+
+static void SerializeGltfAnimation(Animation &animation, json &o) {
+  if (!animation.name.empty())
+    SerializeStringProperty("name", animation.name, o);
+
+  {
+    json channels;
+    JsonReserveArray(channels, animation.channels.size());
+    for (unsigned int i = 0; i < animation.channels.size(); ++i) {
+      json channel;
+      AnimationChannel gltfChannel = animation.channels[i];
+      SerializeGltfAnimationChannel(gltfChannel, channel);
+      JsonPushBack(channels, std::move(channel));
+    }
+
+    JsonAddMember(o, "channels", std::move(channels));
+  }
+
+  {
+    json samplers;
+    JsonReserveArray(samplers, animation.samplers.size());
+    for (unsigned int i = 0; i < animation.samplers.size(); ++i) {
+      json sampler;
+      AnimationSampler gltfSampler = animation.samplers[i];
+      SerializeGltfAnimationSampler(gltfSampler, sampler);
+      JsonPushBack(samplers, std::move(sampler));
+    }
+    JsonAddMember(o, "samplers", std::move(samplers));
+  }
+
+  if (animation.extras.Type() != NULL_TYPE) {
+    SerializeValue("extras", animation.extras, o);
+  }
+
+  SerializeExtensionMap(animation.extensions, o);
+}
+
+static void SerializeGltfAsset(Asset &asset, json &o) {
+  if (!asset.generator.empty()) {
+    SerializeStringProperty("generator", asset.generator, o);
+  }
+
+  if (!asset.copyright.empty()) {
+    SerializeStringProperty("copyright", asset.copyright, o);
+  }
+
+  if (!asset.version.empty()) {
+    SerializeStringProperty("version", asset.version, o);
+  }
+
+  if (asset.extras.Keys().size()) {
+    SerializeValue("extras", asset.extras, o);
+  }
+
+  SerializeExtensionMap(asset.extensions, o);
+}
+
+static void SerializeGltfBufferBin(Buffer &buffer, json &o,
+                                   std::vector<unsigned char> &binBuffer) {
+  SerializeNumberProperty("byteLength", buffer.data.size(), o);
+  binBuffer = buffer.data;
+
+  if (buffer.name.size()) SerializeStringProperty("name", buffer.name, o);
+
+  if (buffer.extras.Type() != NULL_TYPE) {
+    SerializeValue("extras", buffer.extras, o);
+  }
+}
+
+static void SerializeGltfBuffer(Buffer &buffer, json &o) {
+  SerializeNumberProperty("byteLength", buffer.data.size(), o);
+  SerializeGltfBufferData(buffer.data, o);
+
+  if (buffer.name.size()) SerializeStringProperty("name", buffer.name, o);
+
+  if (buffer.extras.Type() != NULL_TYPE) {
+    SerializeValue("extras", buffer.extras, o);
+  }
+}
+
+static bool SerializeGltfBuffer(Buffer &buffer, json &o,
+                                const std::string &binFilename,
+                                const std::string &binBaseFilename) {
+  if (!SerializeGltfBufferData(buffer.data, binFilename)) return false;
+  SerializeNumberProperty("byteLength", buffer.data.size(), o);
+  SerializeStringProperty("uri", binBaseFilename, o);
+
+  if (buffer.name.size()) SerializeStringProperty("name", buffer.name, o);
+
+  if (buffer.extras.Type() != NULL_TYPE) {
+    SerializeValue("extras", buffer.extras, o);
+  }
+  return true;
+}
+
+static void SerializeGltfBufferView(BufferView &bufferView, json &o) {
+  SerializeNumberProperty("buffer", bufferView.buffer, o);
+  SerializeNumberProperty<size_t>("byteLength", bufferView.byteLength, o);
+
+  // byteStride is optional, minimum allowed is 4
+  if (bufferView.byteStride >= 4) {
+    SerializeNumberProperty<size_t>("byteStride", bufferView.byteStride, o);
+  }
+  // byteOffset is optional, default is 0
+  if (bufferView.byteOffset > 0) {
+    SerializeNumberProperty<size_t>("byteOffset", bufferView.byteOffset, o);
+  }
+  // Target is optional, check if it contains a valid value
+  if (bufferView.target == TINYGLTF_TARGET_ARRAY_BUFFER ||
+      bufferView.target == TINYGLTF_TARGET_ELEMENT_ARRAY_BUFFER) {
+    SerializeNumberProperty("target", bufferView.target, o);
+  }
+  if (bufferView.name.size()) {
+    SerializeStringProperty("name", bufferView.name, o);
+  }
+
+  if (bufferView.extras.Type() != NULL_TYPE) {
+    SerializeValue("extras", bufferView.extras, o);
+  }
+}
+
+static void SerializeGltfImage(Image &image, json &o) {
+  // if uri empty, the mimeType and bufferview should be set
+  if (image.uri.empty()) {
+    SerializeStringProperty("mimeType", image.mimeType, o);
+    SerializeNumberProperty<int>("bufferView", image.bufferView, o);
+  } else {
+    // TODO(syoyo): dlib::urilencode?
+    SerializeStringProperty("uri", image.uri, o);
+  }
+
+  if (image.name.size()) {
+    SerializeStringProperty("name", image.name, o);
+  }
+
+  if (image.extras.Type() != NULL_TYPE) {
+    SerializeValue("extras", image.extras, o);
+  }
+
+  SerializeExtensionMap(image.extensions, o);
+}
+
+static void SerializeGltfTextureInfo(TextureInfo &texinfo, json &o) {
+  SerializeNumberProperty("index", texinfo.index, o);
+
+  if (texinfo.texCoord != 0) {
+    SerializeNumberProperty("texCoord", texinfo.texCoord, o);
+  }
+
+  if (texinfo.extras.Type() != NULL_TYPE) {
+    SerializeValue("extras", texinfo.extras, o);
+  }
+
+  SerializeExtensionMap(texinfo.extensions, o);
+}
+
+static void SerializeGltfNormalTextureInfo(NormalTextureInfo &texinfo,
+                                           json &o) {
+  SerializeNumberProperty("index", texinfo.index, o);
+
+  if (texinfo.texCoord != 0) {
+    SerializeNumberProperty("texCoord", texinfo.texCoord, o);
+  }
+
+  if (!TINYGLTF_DOUBLE_EQUAL(texinfo.scale, 1.0)) {
+    SerializeNumberProperty("scale", texinfo.scale, o);
+  }
+
+  if (texinfo.extras.Type() != NULL_TYPE) {
+    SerializeValue("extras", texinfo.extras, o);
+  }
+
+  SerializeExtensionMap(texinfo.extensions, o);
+}
+
+static void SerializeGltfOcclusionTextureInfo(OcclusionTextureInfo &texinfo,
+                                              json &o) {
+  SerializeNumberProperty("index", texinfo.index, o);
+
+  if (texinfo.texCoord != 0) {
+    SerializeNumberProperty("texCoord", texinfo.texCoord, o);
+  }
+
+  if (!TINYGLTF_DOUBLE_EQUAL(texinfo.strength, 1.0)) {
+    SerializeNumberProperty("strength", texinfo.strength, o);
+  }
+
+  if (texinfo.extras.Type() != NULL_TYPE) {
+    SerializeValue("extras", texinfo.extras, o);
+  }
+
+  SerializeExtensionMap(texinfo.extensions, o);
+}
+
+static void SerializeGltfPbrMetallicRoughness(PbrMetallicRoughness &pbr,
+                                              json &o) {
+  std::vector<double> default_baseColorFactor = {1.0, 1.0, 1.0, 1.0};
+  if (!Equals(pbr.baseColorFactor, default_baseColorFactor)) {
+    SerializeNumberArrayProperty<double>("baseColorFactor", pbr.baseColorFactor,
+                                         o);
+  }
+
+  if (!TINYGLTF_DOUBLE_EQUAL(pbr.metallicFactor, 1.0)) {
+    SerializeNumberProperty("metallicFactor", pbr.metallicFactor, o);
+  }
+
+  if (!TINYGLTF_DOUBLE_EQUAL(pbr.roughnessFactor, 1.0)) {
+    SerializeNumberProperty("roughnessFactor", pbr.roughnessFactor, o);
+  }
+
+  if (pbr.baseColorTexture.index > -1) {
+    json texinfo;
+    SerializeGltfTextureInfo(pbr.baseColorTexture, texinfo);
+    JsonAddMember(o, "baseColorTexture", std::move(texinfo));
+  }
+
+  if (pbr.metallicRoughnessTexture.index > -1) {
+    json texinfo;
+    SerializeGltfTextureInfo(pbr.metallicRoughnessTexture, texinfo);
+    JsonAddMember(o, "metallicRoughnessTexture", std::move(texinfo));
+  }
+
+  SerializeExtensionMap(pbr.extensions, o);
+
+  if (pbr.extras.Type() != NULL_TYPE) {
+    SerializeValue("extras", pbr.extras, o);
+  }
+}
+
+static void SerializeGltfMaterial(Material &material, json &o) {
+  if (material.name.size()) {
+    SerializeStringProperty("name", material.name, o);
+  }
+
+  // QUESTION(syoyo): Write material parameters regardless of its default value?
+
+  if (!TINYGLTF_DOUBLE_EQUAL(material.alphaCutoff, 0.5)) {
+    SerializeNumberProperty("alphaCutoff", material.alphaCutoff, o);
+  }
+
+  if (material.alphaMode.compare("OPAQUE") != 0) {
+    SerializeStringProperty("alphaMode", material.alphaMode, o);
+  }
+
+  if (material.doubleSided != false)
+    JsonAddMember(o, "doubleSided", json(material.doubleSided));
+
+  if (material.normalTexture.index > -1) {
+    json texinfo;
+    SerializeGltfNormalTextureInfo(material.normalTexture, texinfo);
+    JsonAddMember(o, "normalTexture", std::move(texinfo));
+  }
+
+  if (material.occlusionTexture.index > -1) {
+    json texinfo;
+    SerializeGltfOcclusionTextureInfo(material.occlusionTexture, texinfo);
+    JsonAddMember(o, "occlusionTexture", std::move(texinfo));
+  }
+
+  if (material.emissiveTexture.index > -1) {
+    json texinfo;
+    SerializeGltfTextureInfo(material.emissiveTexture, texinfo);
+    JsonAddMember(o, "emissiveTexture", std::move(texinfo));
+  }
+
+  std::vector<double> default_emissiveFactor = {0.0, 0.0, 0.0};
+  if (!Equals(material.emissiveFactor, default_emissiveFactor)) {
+    SerializeNumberArrayProperty<double>("emissiveFactor",
+                                         material.emissiveFactor, o);
+  }
+
+  {
+    json pbrMetallicRoughness;
+    SerializeGltfPbrMetallicRoughness(material.pbrMetallicRoughness,
+                                      pbrMetallicRoughness);
+    // Issue 204
+    // Do not serialize `pbrMetallicRoughness` if pbrMetallicRoughness has all
+    // default values(json is null). Otherwise it will serialize to
+    // `pbrMetallicRoughness : null`, which cannot be read by other glTF
+    // importers(and validators).
+    //
+    if (!JsonIsNull(pbrMetallicRoughness)) {
+      JsonAddMember(o, "pbrMetallicRoughness", std::move(pbrMetallicRoughness));
+    }
+  }
+
+#if 0  // legacy way. just for the record.
+  if (material.values.size()) {
+    json pbrMetallicRoughness;
+    SerializeParameterMap(material.values, pbrMetallicRoughness);
+    JsonAddMember(o, "pbrMetallicRoughness", std::move(pbrMetallicRoughness));
+  }
+
+  SerializeParameterMap(material.additionalValues, o);
+#else
+
+#endif
+
+  SerializeExtensionMap(material.extensions, o);
+
+  if (material.extras.Type() != NULL_TYPE) {
+    SerializeValue("extras", material.extras, o);
+  }
+}
+
+static void SerializeGltfMesh(Mesh &mesh, json &o) {
+  json primitives;
+  JsonReserveArray(primitives, mesh.primitives.size());
+  for (unsigned int i = 0; i < mesh.primitives.size(); ++i) {
+    json primitive;
+    const Primitive &gltfPrimitive = mesh.primitives[i];  // don't make a copy
+    {
+      json attributes;
+      for (auto attrIt = gltfPrimitive.attributes.begin();
+           attrIt != gltfPrimitive.attributes.end(); ++attrIt) {
+        SerializeNumberProperty<int>(attrIt->first, attrIt->second, attributes);
+      }
+
+      JsonAddMember(primitive, "attributes", std::move(attributes));
+    }
+
+    // Indicies is optional
+    if (gltfPrimitive.indices > -1) {
+      SerializeNumberProperty<int>("indices", gltfPrimitive.indices, primitive);
+    }
+    // Material is optional
+    if (gltfPrimitive.material > -1) {
+      SerializeNumberProperty<int>("material", gltfPrimitive.material,
+                                   primitive);
+    }
+    SerializeNumberProperty<int>("mode", gltfPrimitive.mode, primitive);
+
+    // Morph targets
+    if (gltfPrimitive.targets.size()) {
+      json targets;
+      JsonReserveArray(targets, gltfPrimitive.targets.size());
+      for (unsigned int k = 0; k < gltfPrimitive.targets.size(); ++k) {
+        json targetAttributes;
+        std::map<std::string, int> targetData = gltfPrimitive.targets[k];
+        for (std::map<std::string, int>::iterator attrIt = targetData.begin();
+             attrIt != targetData.end(); ++attrIt) {
+          SerializeNumberProperty<int>(attrIt->first, attrIt->second,
+                                       targetAttributes);
+        }
+        JsonPushBack(targets, std::move(targetAttributes));
+      }
+      JsonAddMember(primitive, "targets", std::move(targets));
+    }
+
+    SerializeExtensionMap(gltfPrimitive.extensions, primitive);
+
+    if (gltfPrimitive.extras.Type() != NULL_TYPE) {
+      SerializeValue("extras", gltfPrimitive.extras, primitive);
+    }
+
+    JsonPushBack(primitives, std::move(primitive));
+  }
+
+  JsonAddMember(o, "primitives", std::move(primitives));
+
+  if (mesh.weights.size()) {
+    SerializeNumberArrayProperty<double>("weights", mesh.weights, o);
+  }
+
+  if (mesh.name.size()) {
+    SerializeStringProperty("name", mesh.name, o);
+  }
+
+  SerializeExtensionMap(mesh.extensions, o);
+  if (mesh.extras.Type() != NULL_TYPE) {
+    SerializeValue("extras", mesh.extras, o);
+  }
+}
+
+static void SerializeSpotLight(SpotLight &spot, json &o) {
+  SerializeNumberProperty("innerConeAngle", spot.innerConeAngle, o);
+  SerializeNumberProperty("outerConeAngle", spot.outerConeAngle, o);
+  SerializeExtensionMap(spot.extensions, o);
+  if (spot.extras.Type() != NULL_TYPE) {
+    SerializeValue("extras", spot.extras, o);
+  }
+}
+
+static void SerializeGltfLight(Light &light, json &o) {
+  if (!light.name.empty()) SerializeStringProperty("name", light.name, o);
+  SerializeNumberProperty("intensity", light.intensity, o);
+  if (light.range > 0.0) {
+    SerializeNumberProperty("range", light.range, o);
+  }
+  SerializeNumberArrayProperty("color", light.color, o);
+  SerializeStringProperty("type", light.type, o);
+  if (light.type == "spot") {
+    json spot;
+    SerializeSpotLight(light.spot, spot);
+    JsonAddMember(o, "spot", std::move(spot));
+  }
+  SerializeExtensionMap(light.extensions, o);
+  if (light.extras.Type() != NULL_TYPE) {
+    SerializeValue("extras", light.extras, o);
+  }
+}
+
+static void SerializeGltfNode(Node &node, json &o) {
+  if (node.translation.size() > 0) {
+    SerializeNumberArrayProperty<double>("translation", node.translation, o);
+  }
+  if (node.rotation.size() > 0) {
+    SerializeNumberArrayProperty<double>("rotation", node.rotation, o);
+  }
+  if (node.scale.size() > 0) {
+    SerializeNumberArrayProperty<double>("scale", node.scale, o);
+  }
+  if (node.matrix.size() > 0) {
+    SerializeNumberArrayProperty<double>("matrix", node.matrix, o);
+  }
+  if (node.mesh != -1) {
+    SerializeNumberProperty<int>("mesh", node.mesh, o);
+  }
+
+  if (node.skin != -1) {
+    SerializeNumberProperty<int>("skin", node.skin, o);
+  }
+
+  if (node.camera != -1) {
+    SerializeNumberProperty<int>("camera", node.camera, o);
+  }
+
+  if (node.weights.size() > 0) {
+    SerializeNumberArrayProperty<double>("weights", node.weights, o);
+  }
+
+  if (node.extras.Type() != NULL_TYPE) {
+    SerializeValue("extras", node.extras, o);
+  }
+
+  SerializeExtensionMap(node.extensions, o);
+  if (!node.name.empty()) SerializeStringProperty("name", node.name, o);
+  SerializeNumberArrayProperty<int>("children", node.children, o);
+}
+
+static void SerializeGltfSampler(Sampler &sampler, json &o) {
+  if (sampler.magFilter != -1) {
+    SerializeNumberProperty("magFilter", sampler.magFilter, o);
+  }
+  if (sampler.minFilter != -1) {
+    SerializeNumberProperty("minFilter", sampler.minFilter, o);
+  }
+  SerializeNumberProperty("wrapR", sampler.wrapR, o);
+  SerializeNumberProperty("wrapS", sampler.wrapS, o);
+  SerializeNumberProperty("wrapT", sampler.wrapT, o);
+
+  if (sampler.extras.Type() != NULL_TYPE) {
+    SerializeValue("extras", sampler.extras, o);
+  }
+}
+
+static void SerializeGltfOrthographicCamera(const OrthographicCamera &camera,
+                                            json &o) {
+  SerializeNumberProperty("zfar", camera.zfar, o);
+  SerializeNumberProperty("znear", camera.znear, o);
+  SerializeNumberProperty("xmag", camera.xmag, o);
+  SerializeNumberProperty("ymag", camera.ymag, o);
+
+  if (camera.extras.Type() != NULL_TYPE) {
+    SerializeValue("extras", camera.extras, o);
+  }
+}
+
+static void SerializeGltfPerspectiveCamera(const PerspectiveCamera &camera,
+                                           json &o) {
+  SerializeNumberProperty("zfar", camera.zfar, o);
+  SerializeNumberProperty("znear", camera.znear, o);
+  if (camera.aspectRatio > 0) {
+    SerializeNumberProperty("aspectRatio", camera.aspectRatio, o);
+  }
+
+  if (camera.yfov > 0) {
+    SerializeNumberProperty("yfov", camera.yfov, o);
+  }
+
+  if (camera.extras.Type() != NULL_TYPE) {
+    SerializeValue("extras", camera.extras, o);
+  }
+}
+
+static void SerializeGltfCamera(const Camera &camera, json &o) {
+  SerializeStringProperty("type", camera.type, o);
+  if (!camera.name.empty()) {
+    SerializeStringProperty("name", camera.name, o);
+  }
+
+  if (camera.type.compare("orthographic") == 0) {
+    json orthographic;
+    SerializeGltfOrthographicCamera(camera.orthographic, orthographic);
+    JsonAddMember(o, "orthographic", std::move(orthographic));
+  } else if (camera.type.compare("perspective") == 0) {
+    json perspective;
+    SerializeGltfPerspectiveCamera(camera.perspective, perspective);
+    JsonAddMember(o, "perspective", std::move(perspective));
+  } else {
+    // ???
+  }
+
+  if (camera.extras.Type() != NULL_TYPE) {
+    SerializeValue("extras", camera.extras, o);
+  }
+  SerializeExtensionMap(camera.extensions, o);
+}
+
+static void SerializeGltfScene(Scene &scene, json &o) {
+  SerializeNumberArrayProperty<int>("nodes", scene.nodes, o);
+
+  if (scene.name.size()) {
+    SerializeStringProperty("name", scene.name, o);
+  }
+  if (scene.extras.Type() != NULL_TYPE) {
+    SerializeValue("extras", scene.extras, o);
+  }
+  SerializeExtensionMap(scene.extensions, o);
+}
+
+static void SerializeGltfSkin(Skin &skin, json &o) {
+  if (skin.inverseBindMatrices != -1)
+    SerializeNumberProperty("inverseBindMatrices", skin.inverseBindMatrices, o);
+
+  SerializeNumberArrayProperty<int>("joints", skin.joints, o);
+  SerializeNumberProperty("skeleton", skin.skeleton, o);
+  if (skin.name.size()) {
+    SerializeStringProperty("name", skin.name, o);
+  }
+}
+
+static void SerializeGltfTexture(Texture &texture, json &o) {
+  if (texture.sampler > -1) {
+    SerializeNumberProperty("sampler", texture.sampler, o);
+  }
+  if (texture.source > -1) {
+    SerializeNumberProperty("source", texture.source, o);
+  }
+  if (texture.name.size()) {
+    SerializeStringProperty("name", texture.name, o);
+  }
+  if (texture.extras.Type() != NULL_TYPE) {
+    SerializeValue("extras", texture.extras, o);
+  }
+  SerializeExtensionMap(texture.extensions, o);
+}
+
+///
+/// Serialize all properties except buffers and images.
+///
+static void SerializeGltfModel(Model *model, json &o) {
+  // ACCESSORS
+  if (model->accessors.size()) {
+    json accessors;
+    JsonReserveArray(accessors, model->accessors.size());
+    for (unsigned int i = 0; i < model->accessors.size(); ++i) {
+      json accessor;
+      SerializeGltfAccessor(model->accessors[i], accessor);
+      JsonPushBack(accessors, std::move(accessor));
+    }
+    JsonAddMember(o, "accessors", std::move(accessors));
+  }
+
+  // ANIMATIONS
+  if (model->animations.size()) {
+    json animations;
+    JsonReserveArray(animations, model->animations.size());
+    for (unsigned int i = 0; i < model->animations.size(); ++i) {
+      if (model->animations[i].channels.size()) {
+        json animation;
+        SerializeGltfAnimation(model->animations[i], animation);
+        JsonPushBack(animations, std::move(animation));
+      }
+    }
+
+    JsonAddMember(o, "animations", std::move(animations));
+  }
+
+  // ASSET
+  json asset;
+  SerializeGltfAsset(model->asset, asset);
+  JsonAddMember(o, "asset", std::move(asset));
+
+  // BUFFERVIEWS
+  if (model->bufferViews.size()) {
+    json bufferViews;
+    JsonReserveArray(bufferViews, model->bufferViews.size());
+    for (unsigned int i = 0; i < model->bufferViews.size(); ++i) {
+      json bufferView;
+      SerializeGltfBufferView(model->bufferViews[i], bufferView);
+      JsonPushBack(bufferViews, std::move(bufferView));
+    }
+    JsonAddMember(o, "bufferViews", std::move(bufferViews));
+  }
+
+  // Extensions required
+  if (model->extensionsRequired.size()) {
+    SerializeStringArrayProperty("extensionsRequired",
+                                 model->extensionsRequired, o);
+  }
+
+  // MATERIALS
+  if (model->materials.size()) {
+    json materials;
+    JsonReserveArray(materials, model->materials.size());
+    for (unsigned int i = 0; i < model->materials.size(); ++i) {
+      json material;
+      SerializeGltfMaterial(model->materials[i], material);
+      JsonPushBack(materials, std::move(material));
+    }
+    JsonAddMember(o, "materials", std::move(materials));
+  }
+
+  // MESHES
+  if (model->meshes.size()) {
+    json meshes;
+    JsonReserveArray(meshes, model->meshes.size());
+    for (unsigned int i = 0; i < model->meshes.size(); ++i) {
+      json mesh;
+      SerializeGltfMesh(model->meshes[i], mesh);
+      JsonPushBack(meshes, std::move(mesh));
+    }
+    JsonAddMember(o, "meshes", std::move(meshes));
+  }
+
+  // NODES
+  if (model->nodes.size()) {
+    json nodes;
+    JsonReserveArray(nodes, model->nodes.size());
+    for (unsigned int i = 0; i < model->nodes.size(); ++i) {
+      json node;
+      SerializeGltfNode(model->nodes[i], node);
+      JsonPushBack(nodes, std::move(node));
+    }
+    JsonAddMember(o, "nodes", std::move(nodes));
+  }
+
+  // SCENE
+  if (model->defaultScene > -1) {
+    SerializeNumberProperty<int>("scene", model->defaultScene, o);
+  }
+
+  // SCENES
+  if (model->scenes.size()) {
+    json scenes;
+    JsonReserveArray(scenes, model->scenes.size());
+    for (unsigned int i = 0; i < model->scenes.size(); ++i) {
+      json currentScene;
+      SerializeGltfScene(model->scenes[i], currentScene);
+      JsonPushBack(scenes, std::move(currentScene));
+    }
+    JsonAddMember(o, "scenes", std::move(scenes));
+  }
+
+  // SKINS
+  if (model->skins.size()) {
+    json skins;
+    JsonReserveArray(skins, model->skins.size());
+    for (unsigned int i = 0; i < model->skins.size(); ++i) {
+      json skin;
+      SerializeGltfSkin(model->skins[i], skin);
+      JsonPushBack(skins, std::move(skin));
+    }
+    JsonAddMember(o, "skins", std::move(skins));
+  }
+
+  // TEXTURES
+  if (model->textures.size()) {
+    json textures;
+    JsonReserveArray(textures, model->textures.size());
+    for (unsigned int i = 0; i < model->textures.size(); ++i) {
+      json texture;
+      SerializeGltfTexture(model->textures[i], texture);
+      JsonPushBack(textures, std::move(texture));
+    }
+    JsonAddMember(o, "textures", std::move(textures));
+  }
+
+  // SAMPLERS
+  if (model->samplers.size()) {
+    json samplers;
+    JsonReserveArray(samplers, model->samplers.size());
+    for (unsigned int i = 0; i < model->samplers.size(); ++i) {
+      json sampler;
+      SerializeGltfSampler(model->samplers[i], sampler);
+      JsonPushBack(samplers, std::move(sampler));
+    }
+    JsonAddMember(o, "samplers", std::move(samplers));
+  }
+
+  // CAMERAS
+  if (model->cameras.size()) {
+    json cameras;
+    JsonReserveArray(cameras, model->cameras.size());
+    for (unsigned int i = 0; i < model->cameras.size(); ++i) {
+      json camera;
+      SerializeGltfCamera(model->cameras[i], camera);
+      JsonPushBack(cameras, std::move(camera));
+    }
+    JsonAddMember(o, "cameras", std::move(cameras));
+  }
+
+  // EXTENSIONS
+  SerializeExtensionMap(model->extensions, o);
+
+  auto extensionsUsed = model->extensionsUsed;
+
+  // LIGHTS as KHR_lights_punctual
+  if (model->lights.size()) {
+    json lights;
+    JsonReserveArray(lights, model->lights.size());
+    for (unsigned int i = 0; i < model->lights.size(); ++i) {
+      json light;
+      SerializeGltfLight(model->lights[i], light);
+      JsonPushBack(lights, std::move(light));
+    }
+    json khr_lights_cmn;
+    JsonAddMember(khr_lights_cmn, "lights", std::move(lights));
+    json ext_j;
+
+    {
+      json_const_iterator it;
+      if (FindMember(o, "extensions", it)) {
+        JsonAssign(ext_j, GetValue(it));
+      }
+    }
+
+    JsonAddMember(ext_j, "KHR_lights_punctual", std::move(khr_lights_cmn));
+
+    JsonAddMember(o, "extensions", std::move(ext_j));
+
+    // Also add "KHR_lights_punctual" to `extensionsUsed`
+    {
+      auto has_khr_lights_punctual =
+          std::find_if(extensionsUsed.begin(), extensionsUsed.end(),
+                       [](const std::string &s) {
+                         return (s.compare("KHR_lights_punctual") == 0);
+                       });
+
+      if (has_khr_lights_punctual == extensionsUsed.end()) {
+        extensionsUsed.push_back("KHR_lights_punctual");
+      }
+    }
+  }
+
+  // Extensions used
+  if (model->extensionsUsed.size()) {
+    SerializeStringArrayProperty("extensionsUsed", extensionsUsed, o);
+  }
+
+  // EXTRAS
+  if (model->extras.Type() != NULL_TYPE) {
+    SerializeValue("extras", model->extras, o);
+  }
+}
+
+static bool WriteGltfStream(std::ostream &stream, const std::string &content) {
+  stream << content << std::endl;
+  return true;
+}
+
+static bool WriteGltfFile(const std::string &output,
+                          const std::string &content) {
+#ifdef _WIN32
+#if defined(_MSC_VER)
+  std::ofstream gltfFile(UTF8ToWchar(output).c_str());
+#elif defined(__GLIBCXX__)
+  int file_descriptor = _wopen(UTF8ToWchar(output).c_str(),
+                               _O_CREAT | _O_WRONLY | _O_TRUNC | _O_BINARY);
+  __gnu_cxx::stdio_filebuf<char> wfile_buf(
+      file_descriptor, std::ios_base::out | std::ios_base::binary);
+  std::ostream gltfFile(&wfile_buf);
+  if (!wfile_buf.is_open()) return false;
+#else
+  std::ofstream gltfFile(output.c_str());
+  if (!gltfFile.is_open()) return false;
+#endif
+#else
+  std::ofstream gltfFile(output.c_str());
+  if (!gltfFile.is_open()) return false;
+#endif
+  return WriteGltfStream(gltfFile, content);
+}
+
+static void WriteBinaryGltfStream(std::ostream &stream,
+                                  const std::string &content,
+                                  const std::vector<unsigned char> &binBuffer) {
+  const std::string header = "glTF";
+  const int version = 2;
+
+  // https://stackoverflow.com/questions/3407012/c-rounding-up-to-the-nearest-multiple-of-a-number
+  auto roundUp = [](uint32_t numToRound, uint32_t multiple) {
+    if (multiple == 0) return numToRound;
+
+    uint32_t remainder = numToRound % multiple;
+    if (remainder == 0) return numToRound;
+
+    return numToRound + multiple - remainder;
+  };
+
+  const uint32_t padding_size =
+      roundUp(uint32_t(content.size()), 4) - uint32_t(content.size());
+
+  // 12 bytes for header, JSON content length, 8 bytes for JSON chunk info.
+  // Chunk data must be located at 4-byte boundary.
+  const uint32_t length =
+      12 + 8 + roundUp(uint32_t(content.size()), 4) +
+      (binBuffer.size() ? (8 + roundUp(uint32_t(binBuffer.size()), 4)) : 0);
+
+  stream.write(header.c_str(), std::streamsize(header.size()));
+  stream.write(reinterpret_cast<const char *>(&version), sizeof(version));
+  stream.write(reinterpret_cast<const char *>(&length), sizeof(length));
+
+  // JSON chunk info, then JSON data
+  const uint32_t model_length = uint32_t(content.size()) + padding_size;
+  const uint32_t model_format = 0x4E4F534A;
+  stream.write(reinterpret_cast<const char *>(&model_length),
+               sizeof(model_length));
+  stream.write(reinterpret_cast<const char *>(&model_format),
+               sizeof(model_format));
+  stream.write(content.c_str(), std::streamsize(content.size()));
+
+  // Chunk must be multiplies of 4, so pad with spaces
+  if (padding_size > 0) {
+    const std::string padding = std::string(size_t(padding_size), ' ');
+    stream.write(padding.c_str(), std::streamsize(padding.size()));
+  }
+  if (binBuffer.size() > 0) {
+    const uint32_t bin_padding_size =
+        roundUp(uint32_t(binBuffer.size()), 4) - uint32_t(binBuffer.size());
+    // BIN chunk info, then BIN data
+    const uint32_t bin_length = uint32_t(binBuffer.size()) + bin_padding_size;
+    const uint32_t bin_format = 0x004e4942;
+    stream.write(reinterpret_cast<const char *>(&bin_length),
+                 sizeof(bin_length));
+    stream.write(reinterpret_cast<const char *>(&bin_format),
+                 sizeof(bin_format));
+    stream.write(reinterpret_cast<const char *>(binBuffer.data()),
+                 std::streamsize(binBuffer.size()));
+    // Chunksize must be multiplies of 4, so pad with zeroes
+    if (bin_padding_size > 0) {
+      const std::vector<unsigned char> padding =
+          std::vector<unsigned char>(size_t(bin_padding_size), 0);
+      stream.write(reinterpret_cast<const char *>(padding.data()),
+                   std::streamsize(padding.size()));
+    }
+  }
+}
+
+static void WriteBinaryGltfFile(const std::string &output,
+                                const std::string &content,
+                                const std::vector<unsigned char> &binBuffer) {
+#ifdef _WIN32
+#if defined(_MSC_VER)
+  std::ofstream gltfFile(UTF8ToWchar(output).c_str(), std::ios::binary);
+#elif defined(__GLIBCXX__)
+  int file_descriptor = _wopen(UTF8ToWchar(output).c_str(),
+                               _O_CREAT | _O_WRONLY | _O_TRUNC | _O_BINARY);
+  __gnu_cxx::stdio_filebuf<char> wfile_buf(
+      file_descriptor, std::ios_base::out | std::ios_base::binary);
+  std::ostream gltfFile(&wfile_buf);
+#else
+  std::ofstream gltfFile(output.c_str(), std::ios::binary);
+#endif
+#else
+  std::ofstream gltfFile(output.c_str(), std::ios::binary);
+#endif
+  WriteBinaryGltfStream(gltfFile, content, binBuffer);
+}
+
+bool TinyGLTF::WriteGltfSceneToStream(Model *model, std::ostream &stream,
+                                      bool prettyPrint = true,
+                                      bool writeBinary = false) {
+  JsonDocument output;
+
+  /// Serialize all properties except buffers and images.
+  SerializeGltfModel(model, output);
+
+  // BUFFERS
+  std::vector<unsigned char> binBuffer;
+  if (model->buffers.size()) {
+    json buffers;
+    JsonReserveArray(buffers, model->buffers.size());
+    for (unsigned int i = 0; i < model->buffers.size(); ++i) {
+      json buffer;
+      if (writeBinary && i == 0 && model->buffers[i].uri.empty()) {
+        SerializeGltfBufferBin(model->buffers[i], buffer, binBuffer);
+      } else {
+        SerializeGltfBuffer(model->buffers[i], buffer);
+      }
+      JsonPushBack(buffers, std::move(buffer));
+    }
+    JsonAddMember(output, "buffers", std::move(buffers));
+  }
+
+  // IMAGES
+  if (model->images.size()) {
+    json images;
+    JsonReserveArray(images, model->images.size());
+    for (unsigned int i = 0; i < model->images.size(); ++i) {
+      json image;
+
+      std::string dummystring = "";
+      // UpdateImageObject need baseDir but only uses it if embeddedImages is
+      // enabled, since we won't write separate images when writing to a stream
+      // we
+      UpdateImageObject(model->images[i], dummystring, int(i), false,
+                        &this->WriteImageData, this->write_image_user_data_);
+      SerializeGltfImage(model->images[i], image);
+      JsonPushBack(images, std::move(image));
+    }
+    JsonAddMember(output, "images", std::move(images));
+  }
+
+  if (writeBinary) {
+    WriteBinaryGltfStream(stream, JsonToString(output), binBuffer);
+  } else {
+    WriteGltfStream(stream, JsonToString(output, prettyPrint ? 2 : -1));
+  }
+
+  return true;
+}
+
+bool TinyGLTF::WriteGltfSceneToFile(Model *model, const std::string &filename,
+                                    bool embedImages = false,
+                                    bool embedBuffers = false,
+                                    bool prettyPrint = true,
+                                    bool writeBinary = false) {
+  JsonDocument output;
+  std::string defaultBinFilename = GetBaseFilename(filename);
+  std::string defaultBinFileExt = ".bin";
+  std::string::size_type pos =
+      defaultBinFilename.rfind('.', defaultBinFilename.length());
+
+  if (pos != std::string::npos) {
+    defaultBinFilename = defaultBinFilename.substr(0, pos);
+  }
+  std::string baseDir = GetBaseDir(filename);
+  if (baseDir.empty()) {
+    baseDir = "./";
+  }
+  /// Serialize all properties except buffers and images.
+  SerializeGltfModel(model, output);
+
+  // BUFFERS
+  std::vector<std::string> usedUris;
+  std::vector<unsigned char> binBuffer;
+  if (model->buffers.size()) {
+    json buffers;
+    JsonReserveArray(buffers, model->buffers.size());
+    for (unsigned int i = 0; i < model->buffers.size(); ++i) {
+      json buffer;
+      if (writeBinary && i == 0 && model->buffers[i].uri.empty()) {
+        SerializeGltfBufferBin(model->buffers[i], buffer, binBuffer);
+      } else if (embedBuffers) {
+        SerializeGltfBuffer(model->buffers[i], buffer);
+      } else {
+        std::string binSavePath;
+        std::string binUri;
+        if (!model->buffers[i].uri.empty() &&
+            !IsDataURI(model->buffers[i].uri)) {
+          binUri = model->buffers[i].uri;
+        } else {
+          binUri = defaultBinFilename + defaultBinFileExt;
+          bool inUse = true;
+          int numUsed = 0;
+          while (inUse) {
+            inUse = false;
+            for (const std::string &usedName : usedUris) {
+              if (binUri.compare(usedName) != 0) continue;
+              inUse = true;
+              binUri = defaultBinFilename + std::to_string(numUsed++) +
+                       defaultBinFileExt;
+              break;
+            }
+          }
+        }
+        usedUris.push_back(binUri);
+        binSavePath = JoinPath(baseDir, binUri);
+        if (!SerializeGltfBuffer(model->buffers[i], buffer, binSavePath,
+                                 binUri)) {
+          return false;
+        }
+      }
+      JsonPushBack(buffers, std::move(buffer));
+    }
+    JsonAddMember(output, "buffers", std::move(buffers));
+  }
+
+  // IMAGES
+  if (model->images.size()) {
+    json images;
+    JsonReserveArray(images, model->images.size());
+    for (unsigned int i = 0; i < model->images.size(); ++i) {
+      json image;
+
+      UpdateImageObject(model->images[i], baseDir, int(i), embedImages,
+                        &this->WriteImageData, this->write_image_user_data_);
+      SerializeGltfImage(model->images[i], image);
+      JsonPushBack(images, std::move(image));
+    }
+    JsonAddMember(output, "images", std::move(images));
+  }
+
+  if (writeBinary) {
+    WriteBinaryGltfFile(filename, JsonToString(output), binBuffer);
+  } else {
+    WriteGltfFile(filename, JsonToString(output, (prettyPrint ? 2 : -1)));
+  }
+
+  return true;
+}
+
+}  // namespace tinygltf
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#endif  // TINYGLTF_IMPLEMENTATION
diff --git a/engine/inc/json/json-forwards.h b/engine/inc/json/json-forwards.h
new file mode 100644
index 00000000..9330e4e6
--- /dev/null
+++ b/engine/inc/json/json-forwards.h
@@ -0,0 +1,446 @@
+/// Json-cpp amalgamated forward header (http://jsoncpp.sourceforge.net/).
+/// It is intended to be used with #include "json/json-forwards.h"
+/// This header provides forward declaration for all JsonCpp types.
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: LICENSE
+// //////////////////////////////////////////////////////////////////////
+
+/*
+The JsonCpp library's source code, including accompanying documentation, 
+tests and demonstration applications, are licensed under the following
+conditions...
+
+Baptiste Lepilleur and The JsonCpp Authors explicitly disclaim copyright in all 
+jurisdictions which recognize such a disclaimer. In such jurisdictions, 
+this software is released into the Public Domain.
+
+In jurisdictions which do not recognize Public Domain property (e.g. Germany as of
+2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur and
+The JsonCpp Authors, and is released under the terms of the MIT License (see below).
+
+In jurisdictions which recognize Public Domain property, the user of this 
+software may choose to accept it either as 1) Public Domain, 2) under the 
+conditions of the MIT License (see below), or 3) under the terms of dual 
+Public Domain/MIT License conditions described here, as they choose.
+
+The MIT License is about as close to Public Domain as a license can get, and is
+described in clear, concise terms at:
+
+   http://en.wikipedia.org/wiki/MIT_License
+   
+The full text of the MIT License follows:
+
+========================================================================
+Copyright (c) 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+
+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.
+========================================================================
+(END LICENSE TEXT)
+
+The MIT license is compatible with both the GPL and commercial
+software, affording one all of the rights of Public Domain with the
+minor nuisance of being required to keep the above copyright notice
+and license text in the source code. Note also that by accepting the
+Public Domain "license" you can re-license your copy using whatever
+license you like.
+
+*/
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: LICENSE
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+#ifndef JSON_FORWARD_AMALGAMATED_H_INCLUDED
+# define JSON_FORWARD_AMALGAMATED_H_INCLUDED
+/// If defined, indicates that the source file is amalgamated
+/// to prevent private header inclusion.
+#define JSON_IS_AMALGAMATION
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: include/json/version.h
+// //////////////////////////////////////////////////////////////////////
+
+#ifndef JSON_VERSION_H_INCLUDED
+#define JSON_VERSION_H_INCLUDED
+
+// Note: version must be updated in three places when doing a release. This
+// annoying process ensures that amalgamate, CMake, and meson all report the
+// correct version.
+// 1. /meson.build
+// 2. /include/json/version.h
+// 3. /CMakeLists.txt
+// IMPORTANT: also update the SOVERSION!!
+
+#define JSONCPP_VERSION_STRING "1.9.4"
+#define JSONCPP_VERSION_MAJOR 1
+#define JSONCPP_VERSION_MINOR 9
+#define JSONCPP_VERSION_PATCH 4
+#define JSONCPP_VERSION_QUALIFIER
+#define JSONCPP_VERSION_HEXA                                                   \
+  ((JSONCPP_VERSION_MAJOR << 24) | (JSONCPP_VERSION_MINOR << 16) |             \
+   (JSONCPP_VERSION_PATCH << 8))
+
+#ifdef JSONCPP_USING_SECURE_MEMORY
+#undef JSONCPP_USING_SECURE_MEMORY
+#endif
+#define JSONCPP_USING_SECURE_MEMORY 0
+// If non-zero, the library zeroes any memory that it has allocated before
+// it frees its memory.
+
+#endif // JSON_VERSION_H_INCLUDED
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: include/json/version.h
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: include/json/allocator.h
+// //////////////////////////////////////////////////////////////////////
+
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_ALLOCATOR_H_INCLUDED
+#define JSON_ALLOCATOR_H_INCLUDED
+
+#include <cstring>
+#include <memory>
+
+#pragma pack(push, 8)
+
+namespace Json {
+template <typename T> class SecureAllocator {
+public:
+  // Type definitions
+  using value_type = T;
+  using pointer = T*;
+  using const_pointer = const T*;
+  using reference = T&;
+  using const_reference = const T&;
+  using size_type = std::size_t;
+  using difference_type = std::ptrdiff_t;
+
+  /**
+   * Allocate memory for N items using the standard allocator.
+   */
+  pointer allocate(size_type n) {
+    // allocate using "global operator new"
+    return static_cast<pointer>(::operator new(n * sizeof(T)));
+  }
+
+  /**
+   * Release memory which was allocated for N items at pointer P.
+   *
+   * The memory block is filled with zeroes before being released.
+   */
+  void deallocate(pointer p, size_type n) {
+    // memset_s is used because memset may be optimized away by the compiler
+    memset_s(p, n * sizeof(T), 0, n * sizeof(T));
+    // free using "global operator delete"
+    ::operator delete(p);
+  }
+
+  /**
+   * Construct an item in-place at pointer P.
+   */
+  template <typename... Args> void construct(pointer p, Args&&... args) {
+    // construct using "placement new" and "perfect forwarding"
+    ::new (static_cast<void*>(p)) T(std::forward<Args>(args)...);
+  }
+
+  size_type max_size() const { return size_t(-1) / sizeof(T); }
+
+  pointer address(reference x) const { return std::addressof(x); }
+
+  const_pointer address(const_reference x) const { return std::addressof(x); }
+
+  /**
+   * Destroy an item in-place at pointer P.
+   */
+  void destroy(pointer p) {
+    // destroy using "explicit destructor"
+    p->~T();
+  }
+
+  // Boilerplate
+  SecureAllocator() {}
+  template <typename U> SecureAllocator(const SecureAllocator<U>&) {}
+  template <typename U> struct rebind { using other = SecureAllocator<U>; };
+};
+
+template <typename T, typename U>
+bool operator==(const SecureAllocator<T>&, const SecureAllocator<U>&) {
+  return true;
+}
+
+template <typename T, typename U>
+bool operator!=(const SecureAllocator<T>&, const SecureAllocator<U>&) {
+  return false;
+}
+
+} // namespace Json
+
+#pragma pack(pop)
+
+#endif // JSON_ALLOCATOR_H_INCLUDED
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: include/json/allocator.h
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: include/json/config.h
+// //////////////////////////////////////////////////////////////////////
+
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_CONFIG_H_INCLUDED
+#define JSON_CONFIG_H_INCLUDED
+#include <cstddef>
+#include <cstdint>
+#include <istream>
+#include <memory>
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <type_traits>
+
+// If non-zero, the library uses exceptions to report bad input instead of C
+// assertion macros. The default is to use exceptions.
+#ifndef JSON_USE_EXCEPTION
+#define JSON_USE_EXCEPTION 1
+#endif
+
+// Temporary, tracked for removal with issue #982.
+#ifndef JSON_USE_NULLREF
+#define JSON_USE_NULLREF 1
+#endif
+
+/// If defined, indicates that the source file is amalgamated
+/// to prevent private header inclusion.
+/// Remarks: it is automatically defined in the generated amalgamated header.
+// #define JSON_IS_AMALGAMATION
+
+// Export macros for DLL visibility
+#if defined(JSON_DLL_BUILD)
+#if defined(_MSC_VER) || defined(__MINGW32__)
+#define JSON_API __declspec(dllexport)
+#define JSONCPP_DISABLE_DLL_INTERFACE_WARNING
+#elif defined(__GNUC__) || defined(__clang__)
+#define JSON_API __attribute__((visibility("default")))
+#endif // if defined(_MSC_VER)
+
+#elif defined(JSON_DLL)
+#if defined(_MSC_VER) || defined(__MINGW32__)
+#define JSON_API __declspec(dllimport)
+#define JSONCPP_DISABLE_DLL_INTERFACE_WARNING
+#endif // if defined(_MSC_VER)
+#endif // ifdef JSON_DLL_BUILD
+
+#if !defined(JSON_API)
+#define JSON_API
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER < 1800
+#error                                                                         \
+    "ERROR:  Visual Studio 12 (2013) with _MSC_VER=1800 is the oldest supported compiler with sufficient C++11 capabilities"
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER < 1900
+// As recommended at
+// https://stackoverflow.com/questions/2915672/snprintf-and-visual-studio-2010
+extern JSON_API int msvc_pre1900_c99_snprintf(char* outBuf, size_t size,
+                                              const char* format, ...);
+#define jsoncpp_snprintf msvc_pre1900_c99_snprintf
+#else
+#define jsoncpp_snprintf std::snprintf
+#endif
+
+// If JSON_NO_INT64 is defined, then Json only support C++ "int" type for
+// integer
+// Storages, and 64 bits integer support is disabled.
+// #define JSON_NO_INT64 1
+
+// JSONCPP_OVERRIDE is maintained for backwards compatibility of external tools.
+// C++11 should be used directly in JSONCPP.
+#define JSONCPP_OVERRIDE override
+
+#ifdef __clang__
+#if __has_extension(attribute_deprecated_with_message)
+#define JSONCPP_DEPRECATED(message) __attribute__((deprecated(message)))
+#endif
+#elif defined(__GNUC__) // not clang (gcc comes later since clang emulates gcc)
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5))
+#define JSONCPP_DEPRECATED(message) __attribute__((deprecated(message)))
+#elif (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
+#define JSONCPP_DEPRECATED(message) __attribute__((__deprecated__))
+#endif                  // GNUC version
+#elif defined(_MSC_VER) // MSVC (after clang because clang on Windows emulates
+                        // MSVC)
+#define JSONCPP_DEPRECATED(message) __declspec(deprecated(message))
+#endif // __clang__ || __GNUC__ || _MSC_VER
+
+#if !defined(JSONCPP_DEPRECATED)
+#define JSONCPP_DEPRECATED(message)
+#endif // if !defined(JSONCPP_DEPRECATED)
+
+#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 6))
+#define JSON_USE_INT64_DOUBLE_CONVERSION 1
+#endif
+
+#if !defined(JSON_IS_AMALGAMATION)
+
+#include "allocator.h"
+#include "version.h"
+
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+namespace Json {
+using Int = int;
+using UInt = unsigned int;
+#if defined(JSON_NO_INT64)
+using LargestInt = int;
+using LargestUInt = unsigned int;
+#undef JSON_HAS_INT64
+#else                 // if defined(JSON_NO_INT64)
+// For Microsoft Visual use specific types as long long is not supported
+#if defined(_MSC_VER) // Microsoft Visual Studio
+using Int64 = __int64;
+using UInt64 = unsigned __int64;
+#else                 // if defined(_MSC_VER) // Other platforms, use long long
+using Int64 = int64_t;
+using UInt64 = uint64_t;
+#endif                // if defined(_MSC_VER)
+using LargestInt = Int64;
+using LargestUInt = UInt64;
+#define JSON_HAS_INT64
+#endif // if defined(JSON_NO_INT64)
+
+template <typename T>
+using Allocator =
+    typename std::conditional<JSONCPP_USING_SECURE_MEMORY, SecureAllocator<T>,
+                              std::allocator<T>>::type;
+using String = std::basic_string<char, std::char_traits<char>, Allocator<char>>;
+using IStringStream =
+    std::basic_istringstream<String::value_type, String::traits_type,
+                             String::allocator_type>;
+using OStringStream =
+    std::basic_ostringstream<String::value_type, String::traits_type,
+                             String::allocator_type>;
+using IStream = std::istream;
+using OStream = std::ostream;
+} // namespace Json
+
+// Legacy names (formerly macros).
+using JSONCPP_STRING = Json::String;
+using JSONCPP_ISTRINGSTREAM = Json::IStringStream;
+using JSONCPP_OSTRINGSTREAM = Json::OStringStream;
+using JSONCPP_ISTREAM = Json::IStream;
+using JSONCPP_OSTREAM = Json::OStream;
+
+#endif // JSON_CONFIG_H_INCLUDED
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: include/json/config.h
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: include/json/forwards.h
+// //////////////////////////////////////////////////////////////////////
+
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_FORWARDS_H_INCLUDED
+#define JSON_FORWARDS_H_INCLUDED
+
+#if !defined(JSON_IS_AMALGAMATION)
+#include "config.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+namespace Json {
+
+// writer.h
+class StreamWriter;
+class StreamWriterBuilder;
+class Writer;
+class FastWriter;
+class StyledWriter;
+class StyledStreamWriter;
+
+// reader.h
+class Reader;
+class CharReader;
+class CharReaderBuilder;
+
+// json_features.h
+class Features;
+
+// value.h
+using ArrayIndex = unsigned int;
+class StaticString;
+class Path;
+class PathArgument;
+class Value;
+class ValueIteratorBase;
+class ValueIterator;
+class ValueConstIterator;
+
+} // namespace Json
+
+#endif // JSON_FORWARDS_H_INCLUDED
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: include/json/forwards.h
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+#endif //ifndef JSON_FORWARD_AMALGAMATED_H_INCLUDED
diff --git a/engine/inc/json/json.h b/engine/inc/json/json.h
new file mode 100644
index 00000000..a1ac7b43
--- /dev/null
+++ b/engine/inc/json/json.h
@@ -0,0 +1,2343 @@
+/// Json-cpp amalgamated header (http://jsoncpp.sourceforge.net/).
+/// It is intended to be used with #include "json/json.h"
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: LICENSE
+// //////////////////////////////////////////////////////////////////////
+
+/*
+The JsonCpp library's source code, including accompanying documentation, 
+tests and demonstration applications, are licensed under the following
+conditions...
+
+Baptiste Lepilleur and The JsonCpp Authors explicitly disclaim copyright in all 
+jurisdictions which recognize such a disclaimer. In such jurisdictions, 
+this software is released into the Public Domain.
+
+In jurisdictions which do not recognize Public Domain property (e.g. Germany as of
+2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur and
+The JsonCpp Authors, and is released under the terms of the MIT License (see below).
+
+In jurisdictions which recognize Public Domain property, the user of this 
+software may choose to accept it either as 1) Public Domain, 2) under the 
+conditions of the MIT License (see below), or 3) under the terms of dual 
+Public Domain/MIT License conditions described here, as they choose.
+
+The MIT License is about as close to Public Domain as a license can get, and is
+described in clear, concise terms at:
+
+   http://en.wikipedia.org/wiki/MIT_License
+   
+The full text of the MIT License follows:
+
+========================================================================
+Copyright (c) 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+
+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.
+========================================================================
+(END LICENSE TEXT)
+
+The MIT license is compatible with both the GPL and commercial
+software, affording one all of the rights of Public Domain with the
+minor nuisance of being required to keep the above copyright notice
+and license text in the source code. Note also that by accepting the
+Public Domain "license" you can re-license your copy using whatever
+license you like.
+
+*/
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: LICENSE
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+#ifndef JSON_AMALGAMATED_H_INCLUDED
+# define JSON_AMALGAMATED_H_INCLUDED
+/// If defined, indicates that the source file is amalgamated
+/// to prevent private header inclusion.
+#define JSON_IS_AMALGAMATION
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: include/json/version.h
+// //////////////////////////////////////////////////////////////////////
+
+#ifndef JSON_VERSION_H_INCLUDED
+#define JSON_VERSION_H_INCLUDED
+
+// Note: version must be updated in three places when doing a release. This
+// annoying process ensures that amalgamate, CMake, and meson all report the
+// correct version.
+// 1. /meson.build
+// 2. /include/json/version.h
+// 3. /CMakeLists.txt
+// IMPORTANT: also update the SOVERSION!!
+
+#define JSONCPP_VERSION_STRING "1.9.4"
+#define JSONCPP_VERSION_MAJOR 1
+#define JSONCPP_VERSION_MINOR 9
+#define JSONCPP_VERSION_PATCH 4
+#define JSONCPP_VERSION_QUALIFIER
+#define JSONCPP_VERSION_HEXA                                                   \
+  ((JSONCPP_VERSION_MAJOR << 24) | (JSONCPP_VERSION_MINOR << 16) |             \
+   (JSONCPP_VERSION_PATCH << 8))
+
+#ifdef JSONCPP_USING_SECURE_MEMORY
+#undef JSONCPP_USING_SECURE_MEMORY
+#endif
+#define JSONCPP_USING_SECURE_MEMORY 0
+// If non-zero, the library zeroes any memory that it has allocated before
+// it frees its memory.
+
+#endif // JSON_VERSION_H_INCLUDED
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: include/json/version.h
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: include/json/allocator.h
+// //////////////////////////////////////////////////////////////////////
+
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_ALLOCATOR_H_INCLUDED
+#define JSON_ALLOCATOR_H_INCLUDED
+
+#include <cstring>
+#include <memory>
+
+#pragma pack(push, 8)
+
+namespace Json {
+template <typename T> class SecureAllocator {
+public:
+  // Type definitions
+  using value_type = T;
+  using pointer = T*;
+  using const_pointer = const T*;
+  using reference = T&;
+  using const_reference = const T&;
+  using size_type = std::size_t;
+  using difference_type = std::ptrdiff_t;
+
+  /**
+   * Allocate memory for N items using the standard allocator.
+   */
+  pointer allocate(size_type n) {
+    // allocate using "global operator new"
+    return static_cast<pointer>(::operator new(n * sizeof(T)));
+  }
+
+  /**
+   * Release memory which was allocated for N items at pointer P.
+   *
+   * The memory block is filled with zeroes before being released.
+   */
+  void deallocate(pointer p, size_type n) {
+    // memset_s is used because memset may be optimized away by the compiler
+    memset_s(p, n * sizeof(T), 0, n * sizeof(T));
+    // free using "global operator delete"
+    ::operator delete(p);
+  }
+
+  /**
+   * Construct an item in-place at pointer P.
+   */
+  template <typename... Args> void construct(pointer p, Args&&... args) {
+    // construct using "placement new" and "perfect forwarding"
+    ::new (static_cast<void*>(p)) T(std::forward<Args>(args)...);
+  }
+
+  size_type max_size() const { return size_t(-1) / sizeof(T); }
+
+  pointer address(reference x) const { return std::addressof(x); }
+
+  const_pointer address(const_reference x) const { return std::addressof(x); }
+
+  /**
+   * Destroy an item in-place at pointer P.
+   */
+  void destroy(pointer p) {
+    // destroy using "explicit destructor"
+    p->~T();
+  }
+
+  // Boilerplate
+  SecureAllocator() {}
+  template <typename U> SecureAllocator(const SecureAllocator<U>&) {}
+  template <typename U> struct rebind { using other = SecureAllocator<U>; };
+};
+
+template <typename T, typename U>
+bool operator==(const SecureAllocator<T>&, const SecureAllocator<U>&) {
+  return true;
+}
+
+template <typename T, typename U>
+bool operator!=(const SecureAllocator<T>&, const SecureAllocator<U>&) {
+  return false;
+}
+
+} // namespace Json
+
+#pragma pack(pop)
+
+#endif // JSON_ALLOCATOR_H_INCLUDED
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: include/json/allocator.h
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: include/json/config.h
+// //////////////////////////////////////////////////////////////////////
+
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_CONFIG_H_INCLUDED
+#define JSON_CONFIG_H_INCLUDED
+#include <cstddef>
+#include <cstdint>
+#include <istream>
+#include <memory>
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <type_traits>
+
+// If non-zero, the library uses exceptions to report bad input instead of C
+// assertion macros. The default is to use exceptions.
+#ifndef JSON_USE_EXCEPTION
+#define JSON_USE_EXCEPTION 1
+#endif
+
+// Temporary, tracked for removal with issue #982.
+#ifndef JSON_USE_NULLREF
+#define JSON_USE_NULLREF 1
+#endif
+
+/// If defined, indicates that the source file is amalgamated
+/// to prevent private header inclusion.
+/// Remarks: it is automatically defined in the generated amalgamated header.
+// #define JSON_IS_AMALGAMATION
+
+// Export macros for DLL visibility
+#if defined(JSON_DLL_BUILD)
+#if defined(_MSC_VER) || defined(__MINGW32__)
+#define JSON_API __declspec(dllexport)
+#define JSONCPP_DISABLE_DLL_INTERFACE_WARNING
+#elif defined(__GNUC__) || defined(__clang__)
+#define JSON_API __attribute__((visibility("default")))
+#endif // if defined(_MSC_VER)
+
+#elif defined(JSON_DLL)
+#if defined(_MSC_VER) || defined(__MINGW32__)
+#define JSON_API __declspec(dllimport)
+#define JSONCPP_DISABLE_DLL_INTERFACE_WARNING
+#endif // if defined(_MSC_VER)
+#endif // ifdef JSON_DLL_BUILD
+
+#if !defined(JSON_API)
+#define JSON_API
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER < 1800
+#error                                                                         \
+    "ERROR:  Visual Studio 12 (2013) with _MSC_VER=1800 is the oldest supported compiler with sufficient C++11 capabilities"
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER < 1900
+// As recommended at
+// https://stackoverflow.com/questions/2915672/snprintf-and-visual-studio-2010
+extern JSON_API int msvc_pre1900_c99_snprintf(char* outBuf, size_t size,
+                                              const char* format, ...);
+#define jsoncpp_snprintf msvc_pre1900_c99_snprintf
+#else
+#define jsoncpp_snprintf std::snprintf
+#endif
+
+// If JSON_NO_INT64 is defined, then Json only support C++ "int" type for
+// integer
+// Storages, and 64 bits integer support is disabled.
+// #define JSON_NO_INT64 1
+
+// JSONCPP_OVERRIDE is maintained for backwards compatibility of external tools.
+// C++11 should be used directly in JSONCPP.
+#define JSONCPP_OVERRIDE override
+
+#ifdef __clang__
+#if __has_extension(attribute_deprecated_with_message)
+#define JSONCPP_DEPRECATED(message) __attribute__((deprecated(message)))
+#endif
+#elif defined(__GNUC__) // not clang (gcc comes later since clang emulates gcc)
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5))
+#define JSONCPP_DEPRECATED(message) __attribute__((deprecated(message)))
+#elif (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
+#define JSONCPP_DEPRECATED(message) __attribute__((__deprecated__))
+#endif                  // GNUC version
+#elif defined(_MSC_VER) // MSVC (after clang because clang on Windows emulates
+                        // MSVC)
+#define JSONCPP_DEPRECATED(message) __declspec(deprecated(message))
+#endif // __clang__ || __GNUC__ || _MSC_VER
+
+#if !defined(JSONCPP_DEPRECATED)
+#define JSONCPP_DEPRECATED(message)
+#endif // if !defined(JSONCPP_DEPRECATED)
+
+#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 6))
+#define JSON_USE_INT64_DOUBLE_CONVERSION 1
+#endif
+
+#if !defined(JSON_IS_AMALGAMATION)
+
+#include "allocator.h"
+#include "version.h"
+
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+namespace Json {
+using Int = int;
+using UInt = unsigned int;
+#if defined(JSON_NO_INT64)
+using LargestInt = int;
+using LargestUInt = unsigned int;
+#undef JSON_HAS_INT64
+#else                 // if defined(JSON_NO_INT64)
+// For Microsoft Visual use specific types as long long is not supported
+#if defined(_MSC_VER) // Microsoft Visual Studio
+using Int64 = __int64;
+using UInt64 = unsigned __int64;
+#else                 // if defined(_MSC_VER) // Other platforms, use long long
+using Int64 = int64_t;
+using UInt64 = uint64_t;
+#endif                // if defined(_MSC_VER)
+using LargestInt = Int64;
+using LargestUInt = UInt64;
+#define JSON_HAS_INT64
+#endif // if defined(JSON_NO_INT64)
+
+template <typename T>
+using Allocator =
+    typename std::conditional<JSONCPP_USING_SECURE_MEMORY, SecureAllocator<T>,
+                              std::allocator<T>>::type;
+using String = std::basic_string<char, std::char_traits<char>, Allocator<char>>;
+using IStringStream =
+    std::basic_istringstream<String::value_type, String::traits_type,
+                             String::allocator_type>;
+using OStringStream =
+    std::basic_ostringstream<String::value_type, String::traits_type,
+                             String::allocator_type>;
+using IStream = std::istream;
+using OStream = std::ostream;
+} // namespace Json
+
+// Legacy names (formerly macros).
+using JSONCPP_STRING = Json::String;
+using JSONCPP_ISTRINGSTREAM = Json::IStringStream;
+using JSONCPP_OSTRINGSTREAM = Json::OStringStream;
+using JSONCPP_ISTREAM = Json::IStream;
+using JSONCPP_OSTREAM = Json::OStream;
+
+#endif // JSON_CONFIG_H_INCLUDED
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: include/json/config.h
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: include/json/forwards.h
+// //////////////////////////////////////////////////////////////////////
+
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_FORWARDS_H_INCLUDED
+#define JSON_FORWARDS_H_INCLUDED
+
+#if !defined(JSON_IS_AMALGAMATION)
+#include "config.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+namespace Json {
+
+// writer.h
+class StreamWriter;
+class StreamWriterBuilder;
+class Writer;
+class FastWriter;
+class StyledWriter;
+class StyledStreamWriter;
+
+// reader.h
+class Reader;
+class CharReader;
+class CharReaderBuilder;
+
+// json_features.h
+class Features;
+
+// value.h
+using ArrayIndex = unsigned int;
+class StaticString;
+class Path;
+class PathArgument;
+class Value;
+class ValueIteratorBase;
+class ValueIterator;
+class ValueConstIterator;
+
+} // namespace Json
+
+#endif // JSON_FORWARDS_H_INCLUDED
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: include/json/forwards.h
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: include/json/json_features.h
+// //////////////////////////////////////////////////////////////////////
+
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_FEATURES_H_INCLUDED
+#define JSON_FEATURES_H_INCLUDED
+
+#if !defined(JSON_IS_AMALGAMATION)
+#include "forwards.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+#pragma pack(push, 8)
+
+namespace Json {
+
+/** \brief Configuration passed to reader and writer.
+ * This configuration object can be used to force the Reader or Writer
+ * to behave in a standard conforming way.
+ */
+class JSON_API Features {
+public:
+  /** \brief A configuration that allows all features and assumes all strings
+   * are UTF-8.
+   * - C & C++ comments are allowed
+   * - Root object can be any JSON value
+   * - Assumes Value strings are encoded in UTF-8
+   */
+  static Features all();
+
+  /** \brief A configuration that is strictly compatible with the JSON
+   * specification.
+   * - Comments are forbidden.
+   * - Root object must be either an array or an object value.
+   * - Assumes Value strings are encoded in UTF-8
+   */
+  static Features strictMode();
+
+  /** \brief Initialize the configuration like JsonConfig::allFeatures;
+   */
+  Features();
+
+  /// \c true if comments are allowed. Default: \c true.
+  bool allowComments_{true};
+
+  /// \c true if root must be either an array or an object value. Default: \c
+  /// false.
+  bool strictRoot_{false};
+
+  /// \c true if dropped null placeholders are allowed. Default: \c false.
+  bool allowDroppedNullPlaceholders_{false};
+
+  /// \c true if numeric object key are allowed. Default: \c false.
+  bool allowNumericKeys_{false};
+};
+
+} // namespace Json
+
+#pragma pack(pop)
+
+#endif // JSON_FEATURES_H_INCLUDED
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: include/json/json_features.h
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: include/json/value.h
+// //////////////////////////////////////////////////////////////////////
+
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_H_INCLUDED
+#define JSON_H_INCLUDED
+
+#if !defined(JSON_IS_AMALGAMATION)
+#include "forwards.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+// Conditional NORETURN attribute on the throw functions would:
+// a) suppress false positives from static code analysis
+// b) possibly improve optimization opportunities.
+#if !defined(JSONCPP_NORETURN)
+#if defined(_MSC_VER) && _MSC_VER == 1800
+#define JSONCPP_NORETURN __declspec(noreturn)
+#else
+#define JSONCPP_NORETURN [[noreturn]]
+#endif
+#endif
+
+// Support for '= delete' with template declarations was a late addition
+// to the c++11 standard and is rejected by clang 3.8 and Apple clang 8.2
+// even though these declare themselves to be c++11 compilers.
+#if !defined(JSONCPP_TEMPLATE_DELETE)
+#if defined(__clang__) && defined(__apple_build_version__)
+#if __apple_build_version__ <= 8000042
+#define JSONCPP_TEMPLATE_DELETE
+#endif
+#elif defined(__clang__)
+#if __clang_major__ == 3 && __clang_minor__ <= 8
+#define JSONCPP_TEMPLATE_DELETE
+#endif
+#endif
+#if !defined(JSONCPP_TEMPLATE_DELETE)
+#define JSONCPP_TEMPLATE_DELETE = delete
+#endif
+#endif
+
+#include <array>
+#include <exception>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+// Disable warning C4251: <data member>: <type> needs to have dll-interface to
+// be used by...
+#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
+#pragma warning(push)
+#pragma warning(disable : 4251)
+#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
+
+#pragma pack(push, 8)
+
+/** \brief JSON (JavaScript Object Notation).
+ */
+namespace Json {
+
+#if JSON_USE_EXCEPTION
+/** Base class for all exceptions we throw.
+ *
+ * We use nothing but these internally. Of course, STL can throw others.
+ */
+class JSON_API Exception : public std::exception {
+public:
+  Exception(String msg);
+  ~Exception() noexcept override;
+  char const* what() const noexcept override;
+
+protected:
+  String msg_;
+};
+
+/** Exceptions which the user cannot easily avoid.
+ *
+ * E.g. out-of-memory (when we use malloc), stack-overflow, malicious input
+ *
+ * \remark derived from Json::Exception
+ */
+class JSON_API RuntimeError : public Exception {
+public:
+  RuntimeError(String const& msg);
+};
+
+/** Exceptions thrown by JSON_ASSERT/JSON_FAIL macros.
+ *
+ * These are precondition-violations (user bugs) and internal errors (our bugs).
+ *
+ * \remark derived from Json::Exception
+ */
+class JSON_API LogicError : public Exception {
+public:
+  LogicError(String const& msg);
+};
+#endif
+
+/// used internally
+JSONCPP_NORETURN void throwRuntimeError(String const& msg);
+/// used internally
+JSONCPP_NORETURN void throwLogicError(String const& msg);
+
+/** \brief Type of the value held by a Value object.
+ */
+enum ValueType {
+  nullValue = 0, ///< 'null' value
+  intValue,      ///< signed integer value
+  uintValue,     ///< unsigned integer value
+  realValue,     ///< double value
+  stringValue,   ///< UTF-8 string value
+  booleanValue,  ///< bool value
+  arrayValue,    ///< array value (ordered list)
+  objectValue    ///< object value (collection of name/value pairs).
+};
+
+enum CommentPlacement {
+  commentBefore = 0,      ///< a comment placed on the line before a value
+  commentAfterOnSameLine, ///< a comment just after a value on the same line
+  commentAfter, ///< a comment on the line after a value (only make sense for
+  /// root value)
+  numberOfCommentPlacement
+};
+
+/** \brief Type of precision for formatting of real values.
+ */
+enum PrecisionType {
+  significantDigits = 0, ///< we set max number of significant digits in string
+  decimalPlaces          ///< we set max number of digits after "." in string
+};
+
+/** \brief Lightweight wrapper to tag static string.
+ *
+ * Value constructor and objectValue member assignment takes advantage of the
+ * StaticString and avoid the cost of string duplication when storing the
+ * string or the member name.
+ *
+ * Example of usage:
+ * \code
+ * Json::Value aValue( StaticString("some text") );
+ * Json::Value object;
+ * static const StaticString code("code");
+ * object[code] = 1234;
+ * \endcode
+ */
+class JSON_API StaticString {
+public:
+  explicit StaticString(const char* czstring) : c_str_(czstring) {}
+
+  operator const char*() const { return c_str_; }
+
+  const char* c_str() const { return c_str_; }
+
+private:
+  const char* c_str_;
+};
+
+/** \brief Represents a <a HREF="http://www.json.org">JSON</a> value.
+ *
+ * This class is a discriminated union wrapper that can represents a:
+ * - signed integer [range: Value::minInt - Value::maxInt]
+ * - unsigned integer (range: 0 - Value::maxUInt)
+ * - double
+ * - UTF-8 string
+ * - boolean
+ * - 'null'
+ * - an ordered list of Value
+ * - collection of name/value pairs (javascript object)
+ *
+ * The type of the held value is represented by a #ValueType and
+ * can be obtained using type().
+ *
+ * Values of an #objectValue or #arrayValue can be accessed using operator[]()
+ * methods.
+ * Non-const methods will automatically create the a #nullValue element
+ * if it does not exist.
+ * The sequence of an #arrayValue will be automatically resized and initialized
+ * with #nullValue. resize() can be used to enlarge or truncate an #arrayValue.
+ *
+ * The get() methods can be used to obtain default value in the case the
+ * required element does not exist.
+ *
+ * It is possible to iterate over the list of member keys of an object using
+ * the getMemberNames() method.
+ *
+ * \note #Value string-length fit in size_t, but keys must be < 2^30.
+ * (The reason is an implementation detail.) A #CharReader will raise an
+ * exception if a bound is exceeded to avoid security holes in your app,
+ * but the Value API does *not* check bounds. That is the responsibility
+ * of the caller.
+ */
+class JSON_API Value {
+  friend class ValueIteratorBase;
+
+public:
+  using Members = std::vector<String>;
+  using iterator = ValueIterator;
+  using const_iterator = ValueConstIterator;
+  using UInt = Json::UInt;
+  using Int = Json::Int;
+#if defined(JSON_HAS_INT64)
+  using UInt64 = Json::UInt64;
+  using Int64 = Json::Int64;
+#endif // defined(JSON_HAS_INT64)
+  using LargestInt = Json::LargestInt;
+  using LargestUInt = Json::LargestUInt;
+  using ArrayIndex = Json::ArrayIndex;
+
+  // Required for boost integration, e. g. BOOST_TEST
+  using value_type = std::string;
+
+#if JSON_USE_NULLREF
+  // Binary compatibility kludges, do not use.
+  static const Value& null;
+  static const Value& nullRef;
+#endif
+
+  // null and nullRef are deprecated, use this instead.
+  static Value const& nullSingleton();
+
+  /// Minimum signed integer value that can be stored in a Json::Value.
+  static constexpr LargestInt minLargestInt =
+      LargestInt(~(LargestUInt(-1) / 2));
+  /// Maximum signed integer value that can be stored in a Json::Value.
+  static constexpr LargestInt maxLargestInt = LargestInt(LargestUInt(-1) / 2);
+  /// Maximum unsigned integer value that can be stored in a Json::Value.
+  static constexpr LargestUInt maxLargestUInt = LargestUInt(-1);
+
+  /// Minimum signed int value that can be stored in a Json::Value.
+  static constexpr Int minInt = Int(~(UInt(-1) / 2));
+  /// Maximum signed int value that can be stored in a Json::Value.
+  static constexpr Int maxInt = Int(UInt(-1) / 2);
+  /// Maximum unsigned int value that can be stored in a Json::Value.
+  static constexpr UInt maxUInt = UInt(-1);
+
+#if defined(JSON_HAS_INT64)
+  /// Minimum signed 64 bits int value that can be stored in a Json::Value.
+  static constexpr Int64 minInt64 = Int64(~(UInt64(-1) / 2));
+  /// Maximum signed 64 bits int value that can be stored in a Json::Value.
+  static constexpr Int64 maxInt64 = Int64(UInt64(-1) / 2);
+  /// Maximum unsigned 64 bits int value that can be stored in a Json::Value.
+  static constexpr UInt64 maxUInt64 = UInt64(-1);
+#endif // defined(JSON_HAS_INT64)
+  /// Default precision for real value for string representation.
+  static constexpr UInt defaultRealPrecision = 17;
+  // The constant is hard-coded because some compiler have trouble
+  // converting Value::maxUInt64 to a double correctly (AIX/xlC).
+  // Assumes that UInt64 is a 64 bits integer.
+  static constexpr double maxUInt64AsDouble = 18446744073709551615.0;
+// Workaround for bug in the NVIDIAs CUDA 9.1 nvcc compiler
+// when using gcc and clang backend compilers.  CZString
+// cannot be defined as private.  See issue #486
+#ifdef __NVCC__
+public:
+#else
+private:
+#endif
+#ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+  class CZString {
+  public:
+    enum DuplicationPolicy { noDuplication = 0, duplicate, duplicateOnCopy };
+    CZString(ArrayIndex index);
+    CZString(char const* str, unsigned length, DuplicationPolicy allocate);
+    CZString(CZString const& other);
+    CZString(CZString&& other) noexcept;
+    ~CZString();
+    CZString& operator=(const CZString& other);
+    CZString& operator=(CZString&& other) noexcept;
+
+    bool operator<(CZString const& other) const;
+    bool operator==(CZString const& other) const;
+    ArrayIndex index() const;
+    // const char* c_str() const; ///< \deprecated
+    char const* data() const;
+    unsigned length() const;
+    bool isStaticString() const;
+
+  private:
+    void swap(CZString& other);
+
+    struct StringStorage {
+      unsigned policy_ : 2;
+      unsigned length_ : 30; // 1GB max
+    };
+
+    char const* cstr_; // actually, a prefixed string, unless policy is noDup
+    union {
+      ArrayIndex index_;
+      StringStorage storage_;
+    };
+  };
+
+public:
+  typedef std::map<CZString, Value> ObjectValues;
+#endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+
+public:
+  /**
+   * \brief Create a default Value of the given type.
+   *
+   * This is a very useful constructor.
+   * To create an empty array, pass arrayValue.
+   * To create an empty object, pass objectValue.
+   * Another Value can then be set to this one by assignment.
+   * This is useful since clear() and resize() will not alter types.
+   *
+   * Examples:
+   *   \code
+   *   Json::Value null_value; // null
+   *   Json::Value arr_value(Json::arrayValue); // []
+   *   Json::Value obj_value(Json::objectValue); // {}
+   *   \endcode
+   */
+  Value(ValueType type = nullValue);
+  Value(Int value);
+  Value(UInt value);
+#if defined(JSON_HAS_INT64)
+  Value(Int64 value);
+  Value(UInt64 value);
+#endif // if defined(JSON_HAS_INT64)
+  Value(double value);
+  Value(const char* value); ///< Copy til first 0. (NULL causes to seg-fault.)
+  Value(const char* begin, const char* end); ///< Copy all, incl zeroes.
+  /**
+   * \brief Constructs a value from a static string.
+   *
+   * Like other value string constructor but do not duplicate the string for
+   * internal storage. The given string must remain alive after the call to
+   * this constructor.
+   *
+   * \note This works only for null-terminated strings. (We cannot change the
+   * size of this class, so we have nowhere to store the length, which might be
+   * computed later for various operations.)
+   *
+   * Example of usage:
+   *   \code
+   *   static StaticString foo("some text");
+   *   Json::Value aValue(foo);
+   *   \endcode
+   */
+  Value(const StaticString& value);
+  Value(const String& value);
+  Value(bool value);
+  Value(std::nullptr_t ptr) = delete;
+  Value(const Value& other);
+  Value(Value&& other) noexcept;
+  ~Value();
+
+  /// \note Overwrite existing comments. To preserve comments, use
+  /// #swapPayload().
+  Value& operator=(const Value& other);
+  Value& operator=(Value&& other) noexcept;
+
+  /// Swap everything.
+  void swap(Value& other);
+  /// Swap values but leave comments and source offsets in place.
+  void swapPayload(Value& other);
+
+  /// copy everything.
+  void copy(const Value& other);
+  /// copy values but leave comments and source offsets in place.
+  void copyPayload(const Value& other);
+
+  ValueType type() const;
+
+  /// Compare payload only, not comments etc.
+  bool operator<(const Value& other) const;
+  bool operator<=(const Value& other) const;
+  bool operator>=(const Value& other) const;
+  bool operator>(const Value& other) const;
+  bool operator==(const Value& other) const;
+  bool operator!=(const Value& other) const;
+  int compare(const Value& other) const;
+
+  const char* asCString() const; ///< Embedded zeroes could cause you trouble!
+#if JSONCPP_USING_SECURE_MEMORY
+  unsigned getCStringLength() const; // Allows you to understand the length of
+                                     // the CString
+#endif
+  String asString() const; ///< Embedded zeroes are possible.
+  /** Get raw char* of string-value.
+   *  \return false if !string. (Seg-fault if str or end are NULL.)
+   */
+  bool getString(char const** begin, char const** end) const;
+  Int asInt() const;
+  UInt asUInt() const;
+#if defined(JSON_HAS_INT64)
+  Int64 asInt64() const;
+  UInt64 asUInt64() const;
+#endif // if defined(JSON_HAS_INT64)
+  LargestInt asLargestInt() const;
+  LargestUInt asLargestUInt() const;
+  float asFloat() const;
+  double asDouble() const;
+  bool asBool() const;
+
+  bool isNull() const;
+  bool isBool() const;
+  bool isInt() const;
+  bool isInt64() const;
+  bool isUInt() const;
+  bool isUInt64() const;
+  bool isIntegral() const;
+  bool isDouble() const;
+  bool isNumeric() const;
+  bool isString() const;
+  bool isArray() const;
+  bool isObject() const;
+
+  /// The `as<T>` and `is<T>` member function templates and specializations.
+  template <typename T> T as() const JSONCPP_TEMPLATE_DELETE;
+  template <typename T> bool is() const JSONCPP_TEMPLATE_DELETE;
+
+  bool isConvertibleTo(ValueType other) const;
+
+  /// Number of values in array or object
+  ArrayIndex size() const;
+
+  /// \brief Return true if empty array, empty object, or null;
+  /// otherwise, false.
+  bool empty() const;
+
+  /// Return !isNull()
+  explicit operator bool() const;
+
+  /// Remove all object members and array elements.
+  /// \pre type() is arrayValue, objectValue, or nullValue
+  /// \post type() is unchanged
+  void clear();
+
+  /// Resize the array to newSize elements.
+  /// New elements are initialized to null.
+  /// May only be called on nullValue or arrayValue.
+  /// \pre type() is arrayValue or nullValue
+  /// \post type() is arrayValue
+  void resize(ArrayIndex newSize);
+
+  //@{
+  /// Access an array element (zero based index). If the array contains less
+  /// than index element, then null value are inserted in the array so that
+  /// its size is index+1.
+  /// (You may need to say 'value[0u]' to get your compiler to distinguish
+  /// this from the operator[] which takes a string.)
+  Value& operator[](ArrayIndex index);
+  Value& operator[](int index);
+  //@}
+
+  //@{
+  /// Access an array element (zero based index).
+  /// (You may need to say 'value[0u]' to get your compiler to distinguish
+  /// this from the operator[] which takes a string.)
+  const Value& operator[](ArrayIndex index) const;
+  const Value& operator[](int index) const;
+  //@}
+
+  /// If the array contains at least index+1 elements, returns the element
+  /// value, otherwise returns defaultValue.
+  Value get(ArrayIndex index, const Value& defaultValue) const;
+  /// Return true if index < size().
+  bool isValidIndex(ArrayIndex index) const;
+  /// \brief Append value to array at the end.
+  ///
+  /// Equivalent to jsonvalue[jsonvalue.size()] = value;
+  Value& append(const Value& value);
+  Value& append(Value&& value);
+
+  /// \brief Insert value in array at specific index
+  bool insert(ArrayIndex index, const Value& newValue);
+  bool insert(ArrayIndex index, Value&& newValue);
+
+  /// Access an object value by name, create a null member if it does not exist.
+  /// \note Because of our implementation, keys are limited to 2^30 -1 chars.
+  /// Exceeding that will cause an exception.
+  Value& operator[](const char* key);
+  /// Access an object value by name, returns null if there is no member with
+  /// that name.
+  const Value& operator[](const char* key) const;
+  /// Access an object value by name, create a null member if it does not exist.
+  /// \param key may contain embedded nulls.
+  Value& operator[](const String& key);
+  /// Access an object value by name, returns null if there is no member with
+  /// that name.
+  /// \param key may contain embedded nulls.
+  const Value& operator[](const String& key) const;
+  /** \brief Access an object value by name, create a null member if it does not
+   * exist.
+   *
+   * If the object has no entry for that name, then the member name used to
+   * store the new entry is not duplicated.
+   * Example of use:
+   *   \code
+   *   Json::Value object;
+   *   static const StaticString code("code");
+   *   object[code] = 1234;
+   *   \endcode
+   */
+  Value& operator[](const StaticString& key);
+  /// Return the member named key if it exist, defaultValue otherwise.
+  /// \note deep copy
+  Value get(const char* key, const Value& defaultValue) const;
+  /// Return the member named key if it exist, defaultValue otherwise.
+  /// \note deep copy
+  /// \note key may contain embedded nulls.
+  Value get(const char* begin, const char* end,
+            const Value& defaultValue) const;
+  /// Return the member named key if it exist, defaultValue otherwise.
+  /// \note deep copy
+  /// \param key may contain embedded nulls.
+  Value get(const String& key, const Value& defaultValue) const;
+  /// Most general and efficient version of isMember()const, get()const,
+  /// and operator[]const
+  /// \note As stated elsewhere, behavior is undefined if (end-begin) >= 2^30
+  Value const* find(char const* begin, char const* end) const;
+  /// Most general and efficient version of object-mutators.
+  /// \note As stated elsewhere, behavior is undefined if (end-begin) >= 2^30
+  /// \return non-zero, but JSON_ASSERT if this is neither object nor nullValue.
+  Value* demand(char const* begin, char const* end);
+  /// \brief Remove and return the named member.
+  ///
+  /// Do nothing if it did not exist.
+  /// \pre type() is objectValue or nullValue
+  /// \post type() is unchanged
+  void removeMember(const char* key);
+  /// Same as removeMember(const char*)
+  /// \param key may contain embedded nulls.
+  void removeMember(const String& key);
+  /// Same as removeMember(const char* begin, const char* end, Value* removed),
+  /// but 'key' is null-terminated.
+  bool removeMember(const char* key, Value* removed);
+  /** \brief Remove the named map member.
+   *
+   *  Update 'removed' iff removed.
+   *  \param key may contain embedded nulls.
+   *  \return true iff removed (no exceptions)
+   */
+  bool removeMember(String const& key, Value* removed);
+  /// Same as removeMember(String const& key, Value* removed)
+  bool removeMember(const char* begin, const char* end, Value* removed);
+  /** \brief Remove the indexed array element.
+   *
+   *  O(n) expensive operations.
+   *  Update 'removed' iff removed.
+   *  \return true if removed (no exceptions)
+   */
+  bool removeIndex(ArrayIndex index, Value* removed);
+
+  /// Return true if the object has a member named key.
+  /// \note 'key' must be null-terminated.
+  bool isMember(const char* key) const;
+  /// Return true if the object has a member named key.
+  /// \param key may contain embedded nulls.
+  bool isMember(const String& key) const;
+  /// Same as isMember(String const& key)const
+  bool isMember(const char* begin, const char* end) const;
+
+  /// \brief Return a list of the member names.
+  ///
+  /// If null, return an empty list.
+  /// \pre type() is objectValue or nullValue
+  /// \post if type() was nullValue, it remains nullValue
+  Members getMemberNames() const;
+
+  /// \deprecated Always pass len.
+  JSONCPP_DEPRECATED("Use setComment(String const&) instead.")
+  void setComment(const char* comment, CommentPlacement placement) {
+    setComment(String(comment, strlen(comment)), placement);
+  }
+  /// Comments must be //... or /* ... */
+  void setComment(const char* comment, size_t len, CommentPlacement placement) {
+    setComment(String(comment, len), placement);
+  }
+  /// Comments must be //... or /* ... */
+  void setComment(String comment, CommentPlacement placement);
+  bool hasComment(CommentPlacement placement) const;
+  /// Include delimiters and embedded newlines.
+  String getComment(CommentPlacement placement) const;
+
+  String toStyledString() const;
+
+  const_iterator begin() const;
+  const_iterator end() const;
+
+  iterator begin();
+  iterator end();
+
+  // Accessors for the [start, limit) range of bytes within the JSON text from
+  // which this value was parsed, if any.
+  void setOffsetStart(ptrdiff_t start);
+  void setOffsetLimit(ptrdiff_t limit);
+  ptrdiff_t getOffsetStart() const;
+  ptrdiff_t getOffsetLimit() const;
+
+private:
+  void setType(ValueType v) {
+    bits_.value_type_ = static_cast<unsigned char>(v);
+  }
+  bool isAllocated() const { return bits_.allocated_; }
+  void setIsAllocated(bool v) { bits_.allocated_ = v; }
+
+  void initBasic(ValueType type, bool allocated = false);
+  void dupPayload(const Value& other);
+  void releasePayload();
+  void dupMeta(const Value& other);
+
+  Value& resolveReference(const char* key);
+  Value& resolveReference(const char* key, const char* end);
+
+  // struct MemberNamesTransform
+  //{
+  //   typedef const char *result_type;
+  //   const char *operator()( const CZString &name ) const
+  //   {
+  //      return name.c_str();
+  //   }
+  //};
+
+  union ValueHolder {
+    LargestInt int_;
+    LargestUInt uint_;
+    double real_;
+    bool bool_;
+    char* string_; // if allocated_, ptr to { unsigned, char[] }.
+    ObjectValues* map_;
+  } value_;
+
+  struct {
+    // Really a ValueType, but types should agree for bitfield packing.
+    unsigned int value_type_ : 8;
+    // Unless allocated_, string_ must be null-terminated.
+    unsigned int allocated_ : 1;
+  } bits_;
+
+  class Comments {
+  public:
+    Comments() = default;
+    Comments(const Comments& that);
+    Comments(Comments&& that) noexcept;
+    Comments& operator=(const Comments& that);
+    Comments& operator=(Comments&& that) noexcept;
+    bool has(CommentPlacement slot) const;
+    String get(CommentPlacement slot) const;
+    void set(CommentPlacement slot, String comment);
+
+  private:
+    using Array = std::array<String, numberOfCommentPlacement>;
+    std::unique_ptr<Array> ptr_;
+  };
+  Comments comments_;
+
+  // [start, limit) byte offsets in the source JSON text from which this Value
+  // was extracted.
+  ptrdiff_t start_;
+  ptrdiff_t limit_;
+};
+
+template <> inline bool Value::as<bool>() const { return asBool(); }
+template <> inline bool Value::is<bool>() const { return isBool(); }
+
+template <> inline Int Value::as<Int>() const { return asInt(); }
+template <> inline bool Value::is<Int>() const { return isInt(); }
+
+template <> inline UInt Value::as<UInt>() const { return asUInt(); }
+template <> inline bool Value::is<UInt>() const { return isUInt(); }
+
+#if defined(JSON_HAS_INT64)
+template <> inline Int64 Value::as<Int64>() const { return asInt64(); }
+template <> inline bool Value::is<Int64>() const { return isInt64(); }
+
+template <> inline UInt64 Value::as<UInt64>() const { return asUInt64(); }
+template <> inline bool Value::is<UInt64>() const { return isUInt64(); }
+#endif
+
+template <> inline double Value::as<double>() const { return asDouble(); }
+template <> inline bool Value::is<double>() const { return isDouble(); }
+
+template <> inline String Value::as<String>() const { return asString(); }
+template <> inline bool Value::is<String>() const { return isString(); }
+
+/// These `as` specializations are type conversions, and do not have a
+/// corresponding `is`.
+template <> inline float Value::as<float>() const { return asFloat(); }
+template <> inline bool Value::is<float>() const { return isDouble(); }
+template <> inline const char* Value::as<const char*>() const {
+  return asCString();
+}
+
+/** \brief Experimental and untested: represents an element of the "path" to
+ * access a node.
+ */
+class JSON_API PathArgument {
+public:
+  friend class Path;
+
+  PathArgument();
+  PathArgument(ArrayIndex index);
+  PathArgument(const char* key);
+  PathArgument(String key);
+
+private:
+  enum Kind { kindNone = 0, kindIndex, kindKey };
+  String key_;
+  ArrayIndex index_{};
+  Kind kind_{kindNone};
+};
+
+/** \brief Experimental and untested: represents a "path" to access a node.
+ *
+ * Syntax:
+ * - "." => root node
+ * - ".[n]" => elements at index 'n' of root node (an array value)
+ * - ".name" => member named 'name' of root node (an object value)
+ * - ".name1.name2.name3"
+ * - ".[0][1][2].name1[3]"
+ * - ".%" => member name is provided as parameter
+ * - ".[%]" => index is provided as parameter
+ */
+class JSON_API Path {
+public:
+  Path(const String& path, const PathArgument& a1 = PathArgument(),
+       const PathArgument& a2 = PathArgument(),
+       const PathArgument& a3 = PathArgument(),
+       const PathArgument& a4 = PathArgument(),
+       const PathArgument& a5 = PathArgument());
+
+  const Value& resolve(const Value& root) const;
+  Value resolve(const Value& root, const Value& defaultValue) const;
+  /// Creates the "path" to access the specified node and returns a reference on
+  /// the node.
+  Value& make(Value& root) const;
+
+private:
+  using InArgs = std::vector<const PathArgument*>;
+  using Args = std::vector<PathArgument>;
+
+  void makePath(const String& path, const InArgs& in);
+  void addPathInArg(const String& path, const InArgs& in,
+                    InArgs::const_iterator& itInArg, PathArgument::Kind kind);
+  static void invalidPath(const String& path, int location);
+
+  Args args_;
+};
+
+/** \brief base class for Value iterators.
+ *
+ */
+class JSON_API ValueIteratorBase {
+public:
+  using iterator_category = std::bidirectional_iterator_tag;
+  using size_t = unsigned int;
+  using difference_type = int;
+  using SelfType = ValueIteratorBase;
+
+  bool operator==(const SelfType& other) const { return isEqual(other); }
+
+  bool operator!=(const SelfType& other) const { return !isEqual(other); }
+
+  difference_type operator-(const SelfType& other) const {
+    return other.computeDistance(*this);
+  }
+
+  /// Return either the index or the member name of the referenced value as a
+  /// Value.
+  Value key() const;
+
+  /// Return the index of the referenced Value, or -1 if it is not an
+  /// arrayValue.
+  UInt index() const;
+
+  /// Return the member name of the referenced Value, or "" if it is not an
+  /// objectValue.
+  /// \note Avoid `c_str()` on result, as embedded zeroes are possible.
+  String name() const;
+
+  /// Return the member name of the referenced Value. "" if it is not an
+  /// objectValue.
+  /// \deprecated This cannot be used for UTF-8 strings, since there can be
+  /// embedded nulls.
+  JSONCPP_DEPRECATED("Use `key = name();` instead.")
+  char const* memberName() const;
+  /// Return the member name of the referenced Value, or NULL if it is not an
+  /// objectValue.
+  /// \note Better version than memberName(). Allows embedded nulls.
+  char const* memberName(char const** end) const;
+
+protected:
+  /*! Internal utility functions to assist with implementing
+   *   other iterator functions. The const and non-const versions
+   *   of the "deref" protected methods expose the protected
+   *   current_ member variable in a way that can often be
+   *   optimized away by the compiler.
+   */
+  const Value& deref() const;
+  Value& deref();
+
+  void increment();
+
+  void decrement();
+
+  difference_type computeDistance(const SelfType& other) const;
+
+  bool isEqual(const SelfType& other) const;
+
+  void copy(const SelfType& other);
+
+private:
+  Value::ObjectValues::iterator current_;
+  // Indicates that iterator is for a null value.
+  bool isNull_{true};
+
+public:
+  // For some reason, BORLAND needs these at the end, rather
+  // than earlier. No idea why.
+  ValueIteratorBase();
+  explicit ValueIteratorBase(const Value::ObjectValues::iterator& current);
+};
+
+/** \brief const iterator for object and array value.
+ *
+ */
+class JSON_API ValueConstIterator : public ValueIteratorBase {
+  friend class Value;
+
+public:
+  using value_type = const Value;
+  // typedef unsigned int size_t;
+  // typedef int difference_type;
+  using reference = const Value&;
+  using pointer = const Value*;
+  using SelfType = ValueConstIterator;
+
+  ValueConstIterator();
+  ValueConstIterator(ValueIterator const& other);
+
+private:
+  /*! \internal Use by Value to create an iterator.
+   */
+  explicit ValueConstIterator(const Value::ObjectValues::iterator& current);
+
+public:
+  SelfType& operator=(const ValueIteratorBase& other);
+
+  SelfType operator++(int) {
+    SelfType temp(*this);
+    ++*this;
+    return temp;
+  }
+
+  SelfType operator--(int) {
+    SelfType temp(*this);
+    --*this;
+    return temp;
+  }
+
+  SelfType& operator--() {
+    decrement();
+    return *this;
+  }
+
+  SelfType& operator++() {
+    increment();
+    return *this;
+  }
+
+  reference operator*() const { return deref(); }
+
+  pointer operator->() const { return &deref(); }
+};
+
+/** \brief Iterator for object and array value.
+ */
+class JSON_API ValueIterator : public ValueIteratorBase {
+  friend class Value;
+
+public:
+  using value_type = Value;
+  using size_t = unsigned int;
+  using difference_type = int;
+  using reference = Value&;
+  using pointer = Value*;
+  using SelfType = ValueIterator;
+
+  ValueIterator();
+  explicit ValueIterator(const ValueConstIterator& other);
+  ValueIterator(const ValueIterator& other);
+
+private:
+  /*! \internal Use by Value to create an iterator.
+   */
+  explicit ValueIterator(const Value::ObjectValues::iterator& current);
+
+public:
+  SelfType& operator=(const SelfType& other);
+
+  SelfType operator++(int) {
+    SelfType temp(*this);
+    ++*this;
+    return temp;
+  }
+
+  SelfType operator--(int) {
+    SelfType temp(*this);
+    --*this;
+    return temp;
+  }
+
+  SelfType& operator--() {
+    decrement();
+    return *this;
+  }
+
+  SelfType& operator++() {
+    increment();
+    return *this;
+  }
+
+  /*! The return value of non-const iterators can be
+   *  changed, so the these functions are not const
+   *  because the returned references/pointers can be used
+   *  to change state of the base class.
+   */
+  reference operator*() { return deref(); }
+  pointer operator->() { return &deref(); }
+};
+
+inline void swap(Value& a, Value& b) { a.swap(b); }
+
+} // namespace Json
+
+#pragma pack(pop)
+
+#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
+#pragma warning(pop)
+#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
+
+#endif // JSON_H_INCLUDED
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: include/json/value.h
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: include/json/reader.h
+// //////////////////////////////////////////////////////////////////////
+
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_READER_H_INCLUDED
+#define JSON_READER_H_INCLUDED
+
+#if !defined(JSON_IS_AMALGAMATION)
+#include "json_features.h"
+#include "value.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+#include <deque>
+#include <iosfwd>
+#include <istream>
+#include <stack>
+#include <string>
+
+// Disable warning C4251: <data member>: <type> needs to have dll-interface to
+// be used by...
+#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
+#pragma warning(push)
+#pragma warning(disable : 4251)
+#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
+
+#pragma pack(push, 8)
+
+namespace Json {
+
+/** \brief Unserialize a <a HREF="http://www.json.org">JSON</a> document into a
+ * Value.
+ *
+ * \deprecated Use CharReader and CharReaderBuilder.
+ */
+
+class JSONCPP_DEPRECATED(
+    "Use CharReader and CharReaderBuilder instead.") JSON_API Reader {
+public:
+  using Char = char;
+  using Location = const Char*;
+
+  /** \brief An error tagged with where in the JSON text it was encountered.
+   *
+   * The offsets give the [start, limit) range of bytes within the text. Note
+   * that this is bytes, not codepoints.
+   */
+  struct StructuredError {
+    ptrdiff_t offset_start;
+    ptrdiff_t offset_limit;
+    String message;
+  };
+
+  /** \brief Constructs a Reader allowing all features for parsing.
+   */
+  JSONCPP_DEPRECATED("Use CharReader and CharReaderBuilder instead")
+  Reader();
+
+  /** \brief Constructs a Reader allowing the specified feature set for parsing.
+   */
+  JSONCPP_DEPRECATED("Use CharReader and CharReaderBuilder instead")
+  Reader(const Features& features);
+
+  /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a>
+   * document.
+   *
+   * \param      document        UTF-8 encoded string containing the document
+   *                             to read.
+   * \param[out] root            Contains the root value of the document if it
+   *                             was successfully parsed.
+   * \param      collectComments \c true to collect comment and allow writing
+   *                             them back during serialization, \c false to
+   *                             discard comments.  This parameter is ignored
+   *                             if Features::allowComments_ is \c false.
+   * \return \c true if the document was successfully parsed, \c false if an
+   * error occurred.
+   */
+  bool parse(const std::string& document, Value& root,
+             bool collectComments = true);
+
+  /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a>
+   * document.
+   *
+   * \param      beginDoc        Pointer on the beginning of the UTF-8 encoded
+   *                             string of the document to read.
+   * \param      endDoc          Pointer on the end of the UTF-8 encoded string
+   *                             of the document to read.  Must be >= beginDoc.
+   * \param[out] root            Contains the root value of the document if it
+   *                             was successfully parsed.
+   * \param      collectComments \c true to collect comment and allow writing
+   *                             them back during serialization, \c false to
+   *                             discard comments.  This parameter is ignored
+   *                             if Features::allowComments_ is \c false.
+   * \return \c true if the document was successfully parsed, \c false if an
+   * error occurred.
+   */
+  bool parse(const char* beginDoc, const char* endDoc, Value& root,
+             bool collectComments = true);
+
+  /// \brief Parse from input stream.
+  /// \see Json::operator>>(std::istream&, Json::Value&).
+  bool parse(IStream& is, Value& root, bool collectComments = true);
+
+  /** \brief Returns a user friendly string that list errors in the parsed
+   * document.
+   *
+   * \return Formatted error message with the list of errors with their
+   * location in the parsed document. An empty string is returned if no error
+   * occurred during parsing.
+   * \deprecated Use getFormattedErrorMessages() instead (typo fix).
+   */
+  JSONCPP_DEPRECATED("Use getFormattedErrorMessages() instead.")
+  String getFormatedErrorMessages() const;
+
+  /** \brief Returns a user friendly string that list errors in the parsed
+   * document.
+   *
+   * \return Formatted error message with the list of errors with their
+   * location in the parsed document. An empty string is returned if no error
+   * occurred during parsing.
+   */
+  String getFormattedErrorMessages() const;
+
+  /** \brief Returns a vector of structured errors encountered while parsing.
+   *
+   * \return A (possibly empty) vector of StructuredError objects. Currently
+   * only one error can be returned, but the caller should tolerate multiple
+   * errors.  This can occur if the parser recovers from a non-fatal parse
+   * error and then encounters additional errors.
+   */
+  std::vector<StructuredError> getStructuredErrors() const;
+
+  /** \brief Add a semantic error message.
+   *
+   * \param value   JSON Value location associated with the error
+   * \param message The error message.
+   * \return \c true if the error was successfully added, \c false if the Value
+   * offset exceeds the document size.
+   */
+  bool pushError(const Value& value, const String& message);
+
+  /** \brief Add a semantic error message with extra context.
+   *
+   * \param value   JSON Value location associated with the error
+   * \param message The error message.
+   * \param extra   Additional JSON Value location to contextualize the error
+   * \return \c true if the error was successfully added, \c false if either
+   * Value offset exceeds the document size.
+   */
+  bool pushError(const Value& value, const String& message, const Value& extra);
+
+  /** \brief Return whether there are any errors.
+   *
+   * \return \c true if there are no errors to report \c false if errors have
+   * occurred.
+   */
+  bool good() const;
+
+private:
+  enum TokenType {
+    tokenEndOfStream = 0,
+    tokenObjectBegin,
+    tokenObjectEnd,
+    tokenArrayBegin,
+    tokenArrayEnd,
+    tokenString,
+    tokenNumber,
+    tokenTrue,
+    tokenFalse,
+    tokenNull,
+    tokenArraySeparator,
+    tokenMemberSeparator,
+    tokenComment,
+    tokenError
+  };
+
+  class Token {
+  public:
+    TokenType type_;
+    Location start_;
+    Location end_;
+  };
+
+  class ErrorInfo {
+  public:
+    Token token_;
+    String message_;
+    Location extra_;
+  };
+
+  using Errors = std::deque<ErrorInfo>;
+
+  bool readToken(Token& token);
+  void skipSpaces();
+  bool match(const Char* pattern, int patternLength);
+  bool readComment();
+  bool readCStyleComment();
+  bool readCppStyleComment();
+  bool readString();
+  void readNumber();
+  bool readValue();
+  bool readObject(Token& token);
+  bool readArray(Token& token);
+  bool decodeNumber(Token& token);
+  bool decodeNumber(Token& token, Value& decoded);
+  bool decodeString(Token& token);
+  bool decodeString(Token& token, String& decoded);
+  bool decodeDouble(Token& token);
+  bool decodeDouble(Token& token, Value& decoded);
+  bool decodeUnicodeCodePoint(Token& token, Location& current, Location end,
+                              unsigned int& unicode);
+  bool decodeUnicodeEscapeSequence(Token& token, Location& current,
+                                   Location end, unsigned int& unicode);
+  bool addError(const String& message, Token& token, Location extra = nullptr);
+  bool recoverFromError(TokenType skipUntilToken);
+  bool addErrorAndRecover(const String& message, Token& token,
+                          TokenType skipUntilToken);
+  void skipUntilSpace();
+  Value& currentValue();
+  Char getNextChar();
+  void getLocationLineAndColumn(Location location, int& line,
+                                int& column) const;
+  String getLocationLineAndColumn(Location location) const;
+  void addComment(Location begin, Location end, CommentPlacement placement);
+  void skipCommentTokens(Token& token);
+
+  static bool containsNewLine(Location begin, Location end);
+  static String normalizeEOL(Location begin, Location end);
+
+  using Nodes = std::stack<Value*>;
+  Nodes nodes_;
+  Errors errors_;
+  String document_;
+  Location begin_{};
+  Location end_{};
+  Location current_{};
+  Location lastValueEnd_{};
+  Value* lastValue_{};
+  String commentsBefore_;
+  Features features_;
+  bool collectComments_{};
+}; // Reader
+
+/** Interface for reading JSON from a char array.
+ */
+class JSON_API CharReader {
+public:
+  virtual ~CharReader() = default;
+  /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a>
+   * document. The document must be a UTF-8 encoded string containing the
+   * document to read.
+   *
+   * \param      beginDoc Pointer on the beginning of the UTF-8 encoded string
+   *                      of the document to read.
+   * \param      endDoc   Pointer on the end of the UTF-8 encoded string of the
+   *                      document to read. Must be >= beginDoc.
+   * \param[out] root     Contains the root value of the document if it was
+   *                      successfully parsed.
+   * \param[out] errs     Formatted error messages (if not NULL) a user
+   *                      friendly string that lists errors in the parsed
+   *                      document.
+   * \return \c true if the document was successfully parsed, \c false if an
+   * error occurred.
+   */
+  virtual bool parse(char const* beginDoc, char const* endDoc, Value* root,
+                     String* errs) = 0;
+
+  class JSON_API Factory {
+  public:
+    virtual ~Factory() = default;
+    /** \brief Allocate a CharReader via operator new().
+     * \throw std::exception if something goes wrong (e.g. invalid settings)
+     */
+    virtual CharReader* newCharReader() const = 0;
+  }; // Factory
+};   // CharReader
+
+/** \brief Build a CharReader implementation.
+ *
+ * Usage:
+ *   \code
+ *   using namespace Json;
+ *   CharReaderBuilder builder;
+ *   builder["collectComments"] = false;
+ *   Value value;
+ *   String errs;
+ *   bool ok = parseFromStream(builder, std::cin, &value, &errs);
+ *   \endcode
+ */
+class JSON_API CharReaderBuilder : public CharReader::Factory {
+public:
+  // Note: We use a Json::Value so that we can add data-members to this class
+  // without a major version bump.
+  /** Configuration of this builder.
+   * These are case-sensitive.
+   * Available settings (case-sensitive):
+   * - `"collectComments": false or true`
+   *   - true to collect comment and allow writing them back during
+   *     serialization, false to discard comments.  This parameter is ignored
+   *     if allowComments is false.
+   * - `"allowComments": false or true`
+   *   - true if comments are allowed.
+   * - `"allowTrailingCommas": false or true`
+   *   - true if trailing commas in objects and arrays are allowed.
+   * - `"strictRoot": false or true`
+   *   - true if root must be either an array or an object value
+   * - `"allowDroppedNullPlaceholders": false or true`
+   *   - true if dropped null placeholders are allowed. (See
+   *     StreamWriterBuilder.)
+   * - `"allowNumericKeys": false or true`
+   *   - true if numeric object keys are allowed.
+   * - `"allowSingleQuotes": false or true`
+   *   - true if '' are allowed for strings (both keys and values)
+   * - `"stackLimit": integer`
+   *   - Exceeding stackLimit (recursive depth of `readValue()`) will cause an
+   *     exception.
+   *   - This is a security issue (seg-faults caused by deeply nested JSON), so
+   *     the default is low.
+   * - `"failIfExtra": false or true`
+   *   - If true, `parse()` returns false when extra non-whitespace trails the
+   *     JSON value in the input string.
+   * - `"rejectDupKeys": false or true`
+   *   - If true, `parse()` returns false when a key is duplicated within an
+   *     object.
+   * - `"allowSpecialFloats": false or true`
+   *   - If true, special float values (NaNs and infinities) are allowed and
+   *     their values are lossfree restorable.
+   *
+   * You can examine 'settings_` yourself to see the defaults. You can also
+   * write and read them just like any JSON Value.
+   * \sa setDefaults()
+   */
+  Json::Value settings_;
+
+  CharReaderBuilder();
+  ~CharReaderBuilder() override;
+
+  CharReader* newCharReader() const override;
+
+  /** \return true if 'settings' are legal and consistent;
+   *   otherwise, indicate bad settings via 'invalid'.
+   */
+  bool validate(Json::Value* invalid) const;
+
+  /** A simple way to update a specific setting.
+   */
+  Value& operator[](const String& key);
+
+  /** Called by ctor, but you can use this to reset settings_.
+   * \pre 'settings' != NULL (but Json::null is fine)
+   * \remark Defaults:
+   * \snippet src/lib_json/json_reader.cpp CharReaderBuilderDefaults
+   */
+  static void setDefaults(Json::Value* settings);
+  /** Same as old Features::strictMode().
+   * \pre 'settings' != NULL (but Json::null is fine)
+   * \remark Defaults:
+   * \snippet src/lib_json/json_reader.cpp CharReaderBuilderStrictMode
+   */
+  static void strictMode(Json::Value* settings);
+};
+
+/** Consume entire stream and use its begin/end.
+ * Someday we might have a real StreamReader, but for now this
+ * is convenient.
+ */
+bool JSON_API parseFromStream(CharReader::Factory const&, IStream&, Value* root,
+                              String* errs);
+
+/** \brief Read from 'sin' into 'root'.
+ *
+ * Always keep comments from the input JSON.
+ *
+ * This can be used to read a file into a particular sub-object.
+ * For example:
+ *   \code
+ *   Json::Value root;
+ *   cin >> root["dir"]["file"];
+ *   cout << root;
+ *   \endcode
+ * Result:
+ * \verbatim
+ * {
+ * "dir": {
+ *    "file": {
+ *    // The input stream JSON would be nested here.
+ *    }
+ * }
+ * }
+ * \endverbatim
+ * \throw std::exception on parse error.
+ * \see Json::operator<<()
+ */
+JSON_API IStream& operator>>(IStream&, Value&);
+
+} // namespace Json
+
+#pragma pack(pop)
+
+#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
+#pragma warning(pop)
+#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
+
+#endif // JSON_READER_H_INCLUDED
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: include/json/reader.h
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: include/json/writer.h
+// //////////////////////////////////////////////////////////////////////
+
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_WRITER_H_INCLUDED
+#define JSON_WRITER_H_INCLUDED
+
+#if !defined(JSON_IS_AMALGAMATION)
+#include "value.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+#include <ostream>
+#include <string>
+#include <vector>
+
+// Disable warning C4251: <data member>: <type> needs to have dll-interface to
+// be used by...
+#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING) && defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4251)
+#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
+
+#pragma pack(push, 8)
+
+namespace Json {
+
+class Value;
+
+/**
+ *
+ * Usage:
+ *  \code
+ *  using namespace Json;
+ *  void writeToStdout(StreamWriter::Factory const& factory, Value const& value)
+ * { std::unique_ptr<StreamWriter> const writer( factory.newStreamWriter());
+ *    writer->write(value, &std::cout);
+ *    std::cout << std::endl;  // add lf and flush
+ *  }
+ *  \endcode
+ */
+class JSON_API StreamWriter {
+protected:
+  OStream* sout_; // not owned; will not delete
+public:
+  StreamWriter();
+  virtual ~StreamWriter();
+  /** Write Value into document as configured in sub-class.
+   *   Do not take ownership of sout, but maintain a reference during function.
+   *   \pre sout != NULL
+   *   \return zero on success (For now, we always return zero, so check the
+   *   stream instead.) \throw std::exception possibly, depending on
+   * configuration
+   */
+  virtual int write(Value const& root, OStream* sout) = 0;
+
+  /** \brief A simple abstract factory.
+   */
+  class JSON_API Factory {
+  public:
+    virtual ~Factory();
+    /** \brief Allocate a CharReader via operator new().
+     * \throw std::exception if something goes wrong (e.g. invalid settings)
+     */
+    virtual StreamWriter* newStreamWriter() const = 0;
+  }; // Factory
+};   // StreamWriter
+
+/** \brief Write into stringstream, then return string, for convenience.
+ * A StreamWriter will be created from the factory, used, and then deleted.
+ */
+String JSON_API writeString(StreamWriter::Factory const& factory,
+                            Value const& root);
+
+/** \brief Build a StreamWriter implementation.
+
+* Usage:
+*   \code
+*   using namespace Json;
+*   Value value = ...;
+*   StreamWriterBuilder builder;
+*   builder["commentStyle"] = "None";
+*   builder["indentation"] = "   ";  // or whatever you like
+*   std::unique_ptr<Json::StreamWriter> writer(
+*      builder.newStreamWriter());
+*   writer->write(value, &std::cout);
+*   std::cout << std::endl;  // add lf and flush
+*   \endcode
+*/
+class JSON_API StreamWriterBuilder : public StreamWriter::Factory {
+public:
+  // Note: We use a Json::Value so that we can add data-members to this class
+  // without a major version bump.
+  /** Configuration of this builder.
+   *  Available settings (case-sensitive):
+   *  - "commentStyle": "None" or "All"
+   *  - "indentation":  "<anything>".
+   *  - Setting this to an empty string also omits newline characters.
+   *  - "enableYAMLCompatibility": false or true
+   *  - slightly change the whitespace around colons
+   *  - "dropNullPlaceholders": false or true
+   *  - Drop the "null" string from the writer's output for nullValues.
+   *    Strictly speaking, this is not valid JSON. But when the output is being
+   *    fed to a browser's JavaScript, it makes for smaller output and the
+   *    browser can handle the output just fine.
+   *  - "useSpecialFloats": false or true
+   *  - If true, outputs non-finite floating point values in the following way:
+   *    NaN values as "NaN", positive infinity as "Infinity", and negative
+   *  infinity as "-Infinity".
+   *  - "precision": int
+   *  - Number of precision digits for formatting of real values.
+   *  - "precisionType": "significant"(default) or "decimal"
+   *  - Type of precision for formatting of real values.
+
+   *  You can examine 'settings_` yourself
+   *  to see the defaults. You can also write and read them just like any
+   *  JSON Value.
+   *  \sa setDefaults()
+   */
+  Json::Value settings_;
+
+  StreamWriterBuilder();
+  ~StreamWriterBuilder() override;
+
+  /**
+   * \throw std::exception if something goes wrong (e.g. invalid settings)
+   */
+  StreamWriter* newStreamWriter() const override;
+
+  /** \return true if 'settings' are legal and consistent;
+   *   otherwise, indicate bad settings via 'invalid'.
+   */
+  bool validate(Json::Value* invalid) const;
+  /** A simple way to update a specific setting.
+   */
+  Value& operator[](const String& key);
+
+  /** Called by ctor, but you can use this to reset settings_.
+   * \pre 'settings' != NULL (but Json::null is fine)
+   * \remark Defaults:
+   * \snippet src/lib_json/json_writer.cpp StreamWriterBuilderDefaults
+   */
+  static void setDefaults(Json::Value* settings);
+};
+
+/** \brief Abstract class for writers.
+ * \deprecated Use StreamWriter. (And really, this is an implementation detail.)
+ */
+class JSONCPP_DEPRECATED("Use StreamWriter instead") JSON_API Writer {
+public:
+  virtual ~Writer();
+
+  virtual String write(const Value& root) = 0;
+};
+
+/** \brief Outputs a Value in <a HREF="http://www.json.org">JSON</a> format
+ *without formatting (not human friendly).
+ *
+ * The JSON document is written in a single line. It is not intended for 'human'
+ *consumption,
+ * but may be useful to support feature such as RPC where bandwidth is limited.
+ * \sa Reader, Value
+ * \deprecated Use StreamWriterBuilder.
+ */
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4996) // Deriving from deprecated class
+#endif
+class JSONCPP_DEPRECATED("Use StreamWriterBuilder instead") JSON_API FastWriter
+    : public Writer {
+public:
+  FastWriter();
+  ~FastWriter() override = default;
+
+  void enableYAMLCompatibility();
+
+  /** \brief Drop the "null" string from the writer's output for nullValues.
+   * Strictly speaking, this is not valid JSON. But when the output is being
+   * fed to a browser's JavaScript, it makes for smaller output and the
+   * browser can handle the output just fine.
+   */
+  void dropNullPlaceholders();
+
+  void omitEndingLineFeed();
+
+public: // overridden from Writer
+  String write(const Value& root) override;
+
+private:
+  void writeValue(const Value& value);
+
+  String document_;
+  bool yamlCompatibilityEnabled_{false};
+  bool dropNullPlaceholders_{false};
+  bool omitEndingLineFeed_{false};
+};
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+/** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a
+ *human friendly way.
+ *
+ * The rules for line break and indent are as follow:
+ * - Object value:
+ *     - if empty then print {} without indent and line break
+ *     - if not empty the print '{', line break & indent, print one value per
+ *line
+ *       and then unindent and line break and print '}'.
+ * - Array value:
+ *     - if empty then print [] without indent and line break
+ *     - if the array contains no object value, empty array or some other value
+ *types,
+ *       and all the values fit on one lines, then print the array on a single
+ *line.
+ *     - otherwise, it the values do not fit on one line, or the array contains
+ *       object or non empty array, then print one value per line.
+ *
+ * If the Value have comments then they are outputed according to their
+ *#CommentPlacement.
+ *
+ * \sa Reader, Value, Value::setComment()
+ * \deprecated Use StreamWriterBuilder.
+ */
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4996) // Deriving from deprecated class
+#endif
+class JSONCPP_DEPRECATED("Use StreamWriterBuilder instead") JSON_API
+    StyledWriter : public Writer {
+public:
+  StyledWriter();
+  ~StyledWriter() override = default;
+
+public: // overridden from Writer
+  /** \brief Serialize a Value in <a HREF="http://www.json.org">JSON</a> format.
+   * \param root Value to serialize.
+   * \return String containing the JSON document that represents the root value.
+   */
+  String write(const Value& root) override;
+
+private:
+  void writeValue(const Value& value);
+  void writeArrayValue(const Value& value);
+  bool isMultilineArray(const Value& value);
+  void pushValue(const String& value);
+  void writeIndent();
+  void writeWithIndent(const String& value);
+  void indent();
+  void unindent();
+  void writeCommentBeforeValue(const Value& root);
+  void writeCommentAfterValueOnSameLine(const Value& root);
+  static bool hasCommentForValue(const Value& value);
+  static String normalizeEOL(const String& text);
+
+  using ChildValues = std::vector<String>;
+
+  ChildValues childValues_;
+  String document_;
+  String indentString_;
+  unsigned int rightMargin_{74};
+  unsigned int indentSize_{3};
+  bool addChildValues_{false};
+};
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+/** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a
+ human friendly way,
+     to a stream rather than to a string.
+ *
+ * The rules for line break and indent are as follow:
+ * - Object value:
+ *     - if empty then print {} without indent and line break
+ *     - if not empty the print '{', line break & indent, print one value per
+ line
+ *       and then unindent and line break and print '}'.
+ * - Array value:
+ *     - if empty then print [] without indent and line break
+ *     - if the array contains no object value, empty array or some other value
+ types,
+ *       and all the values fit on one lines, then print the array on a single
+ line.
+ *     - otherwise, it the values do not fit on one line, or the array contains
+ *       object or non empty array, then print one value per line.
+ *
+ * If the Value have comments then they are outputed according to their
+ #CommentPlacement.
+ *
+ * \sa Reader, Value, Value::setComment()
+ * \deprecated Use StreamWriterBuilder.
+ */
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4996) // Deriving from deprecated class
+#endif
+class JSONCPP_DEPRECATED("Use StreamWriterBuilder instead") JSON_API
+    StyledStreamWriter {
+public:
+  /**
+   * \param indentation Each level will be indented by this amount extra.
+   */
+  StyledStreamWriter(String indentation = "\t");
+  ~StyledStreamWriter() = default;
+
+public:
+  /** \brief Serialize a Value in <a HREF="http://www.json.org">JSON</a> format.
+   * \param out Stream to write to. (Can be ostringstream, e.g.)
+   * \param root Value to serialize.
+   * \note There is no point in deriving from Writer, since write() should not
+   * return a value.
+   */
+  void write(OStream& out, const Value& root);
+
+private:
+  void writeValue(const Value& value);
+  void writeArrayValue(const Value& value);
+  bool isMultilineArray(const Value& value);
+  void pushValue(const String& value);
+  void writeIndent();
+  void writeWithIndent(const String& value);
+  void indent();
+  void unindent();
+  void writeCommentBeforeValue(const Value& root);
+  void writeCommentAfterValueOnSameLine(const Value& root);
+  static bool hasCommentForValue(const Value& value);
+  static String normalizeEOL(const String& text);
+
+  using ChildValues = std::vector<String>;
+
+  ChildValues childValues_;
+  OStream* document_;
+  String indentString_;
+  unsigned int rightMargin_{74};
+  String indentation_;
+  bool addChildValues_ : 1;
+  bool indented_ : 1;
+};
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+#if defined(JSON_HAS_INT64)
+String JSON_API valueToString(Int value);
+String JSON_API valueToString(UInt value);
+#endif // if defined(JSON_HAS_INT64)
+String JSON_API valueToString(LargestInt value);
+String JSON_API valueToString(LargestUInt value);
+String JSON_API valueToString(
+    double value, unsigned int precision = Value::defaultRealPrecision,
+    PrecisionType precisionType = PrecisionType::significantDigits);
+String JSON_API valueToString(bool value);
+String JSON_API valueToQuotedString(const char* value);
+
+/// \brief Output using the StyledStreamWriter.
+/// \see Json::operator>>()
+JSON_API OStream& operator<<(OStream&, const Value& root);
+
+} // namespace Json
+
+#pragma pack(pop)
+
+#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
+#pragma warning(pop)
+#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
+
+#endif // JSON_WRITER_H_INCLUDED
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: include/json/writer.h
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: include/json/assertions.h
+// //////////////////////////////////////////////////////////////////////
+
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_ASSERTIONS_H_INCLUDED
+#define JSON_ASSERTIONS_H_INCLUDED
+
+#include <cstdlib>
+#include <sstream>
+
+#if !defined(JSON_IS_AMALGAMATION)
+#include "config.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+/** It should not be possible for a maliciously designed file to
+ *  cause an abort() or seg-fault, so these macros are used only
+ *  for pre-condition violations and internal logic errors.
+ */
+#if JSON_USE_EXCEPTION
+
+// @todo <= add detail about condition in exception
+#define JSON_ASSERT(condition)                                                 \
+  do {                                                                         \
+    if (!(condition)) {                                                        \
+      Json::throwLogicError("assert json failed");                             \
+    }                                                                          \
+  } while (0)
+
+#define JSON_FAIL_MESSAGE(message)                                             \
+  do {                                                                         \
+    OStringStream oss;                                                         \
+    oss << message;                                                            \
+    Json::throwLogicError(oss.str());                                          \
+    abort();                                                                   \
+  } while (0)
+
+#else // JSON_USE_EXCEPTION
+
+#define JSON_ASSERT(condition) assert(condition)
+
+// The call to assert() will show the failure message in debug builds. In
+// release builds we abort, for a core-dump or debugger.
+#define JSON_FAIL_MESSAGE(message)                                             \
+  {                                                                            \
+    OStringStream oss;                                                         \
+    oss << message;                                                            \
+    assert(false && oss.str().c_str());                                        \
+    abort();                                                                   \
+  }
+
+#endif
+
+#define JSON_ASSERT_MESSAGE(condition, message)                                \
+  do {                                                                         \
+    if (!(condition)) {                                                        \
+      JSON_FAIL_MESSAGE(message);                                              \
+    }                                                                          \
+  } while (0)
+
+#endif // JSON_ASSERTIONS_H_INCLUDED
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: include/json/assertions.h
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+#endif //ifndef JSON_AMALGAMATED_H_INCLUDED
diff --git a/engine/inc/meshoptimizer.h b/engine/inc/meshoptimizer.h
new file mode 100644
index 00000000..665e27ef
--- /dev/null
+++ b/engine/inc/meshoptimizer.h
@@ -0,0 +1,943 @@
+/**
+ * meshoptimizer - version 0.15
+ *
+ * Copyright (C) 2016-2020, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
+ * Report bugs and download new versions at https://github.com/zeux/meshoptimizer
+ *
+ * This library is distributed under the MIT License. See notice at the end of this file.
+ */
+#pragma once
+
+#include <assert.h>
+#include <stddef.h>
+
+/* Version macro; major * 1000 + minor * 10 + patch */
+#define MESHOPTIMIZER_VERSION 150 /* 0.15 */
+
+/* If no API is defined, assume default */
+#ifndef MESHOPTIMIZER_API
+#define MESHOPTIMIZER_API
+#endif
+
+/* Experimental APIs have unstable interface and might have implementation that's not fully tested or optimized */
+#define MESHOPTIMIZER_EXPERIMENTAL MESHOPTIMIZER_API
+
+/* C interface */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Vertex attribute stream, similar to glVertexPointer
+ * Each element takes size bytes, with stride controlling the spacing between successive elements.
+ */
+struct meshopt_Stream
+{
+	const void* data;
+	size_t size;
+	size_t stride;
+};
+
+/**
+ * Generates a vertex remap table from the vertex buffer and an optional index buffer and returns number of unique vertices
+ * As a result, all vertices that are binary equivalent map to the same (new) location, with no gaps in the resulting sequence.
+ * Resulting remap table maps old vertices to new vertices and can be used in meshopt_remapVertexBuffer/meshopt_remapIndexBuffer.
+ *
+ * destination must contain enough space for the resulting remap table (vertex_count elements)
+ * indices can be NULL if the input is unindexed
+ */
+MESHOPTIMIZER_API size_t meshopt_generateVertexRemap(uint32_t* destination, const uint32_t* indices, size_t index_count, const void* vertices, size_t vertex_count, size_t vertex_size);
+
+/**
+ * Generates a vertex remap table from multiple vertex streams and an optional index buffer and returns number of unique vertices
+ * As a result, all vertices that are binary equivalent map to the same (new) location, with no gaps in the resulting sequence.
+ * Resulting remap table maps old vertices to new vertices and can be used in meshopt_remapVertexBuffer/meshopt_remapIndexBuffer.
+ * To remap vertex buffers, you will need to call meshopt_remapVertexBuffer for each vertex stream.
+ *
+ * destination must contain enough space for the resulting remap table (vertex_count elements)
+ * indices can be NULL if the input is unindexed
+ */
+MESHOPTIMIZER_API size_t meshopt_generateVertexRemapMulti(uint32_t* destination, const uint32_t* indices, size_t index_count, size_t vertex_count, const struct meshopt_Stream* streams, size_t stream_count);
+
+/**
+ * Generates vertex buffer from the source vertex buffer and remap table generated by meshopt_generateVertexRemap
+ *
+ * destination must contain enough space for the resulting vertex buffer (unique_vertex_count elements, returned by meshopt_generateVertexRemap)
+ * vertex_count should be the initial vertex count and not the value returned by meshopt_generateVertexRemap
+ */
+MESHOPTIMIZER_API void meshopt_remapVertexBuffer(void* destination, const void* vertices, size_t vertex_count, size_t vertex_size, const uint32_t* remap);
+
+/**
+ * Generate index buffer from the source index buffer and remap table generated by meshopt_generateVertexRemap
+ *
+ * destination must contain enough space for the resulting index buffer (index_count elements)
+ * indices can be NULL if the input is unindexed
+ */
+MESHOPTIMIZER_API void meshopt_remapIndexBuffer(uint32_t* destination, const uint32_t* indices, size_t index_count, const uint32_t* remap);
+
+/**
+ * Generate index buffer that can be used for more efficient rendering when only a subset of the vertex attributes is necessary
+ * All vertices that are binary equivalent (wrt first vertex_size bytes) map to the first vertex in the original vertex buffer.
+ * This makes it possible to use the index buffer for Z pre-pass or shadowmap rendering, while using the original index buffer for regular rendering.
+ *
+ * destination must contain enough space for the resulting index buffer (index_count elements)
+ */
+MESHOPTIMIZER_API void meshopt_generateShadowIndexBuffer(uint32_t* destination, const uint32_t* indices, size_t index_count, const void* vertices, size_t vertex_count, size_t vertex_size, size_t vertex_stride);
+
+/**
+ * Generate index buffer that can be used for more efficient rendering when only a subset of the vertex attributes is necessary
+ * All vertices that are binary equivalent (wrt specified streams) map to the first vertex in the original vertex buffer.
+ * This makes it possible to use the index buffer for Z pre-pass or shadowmap rendering, while using the original index buffer for regular rendering.
+ *
+ * destination must contain enough space for the resulting index buffer (index_count elements)
+ */
+MESHOPTIMIZER_API void meshopt_generateShadowIndexBufferMulti(uint32_t* destination, const uint32_t* indices, size_t index_count, size_t vertex_count, const struct meshopt_Stream* streams, size_t stream_count);
+
+/**
+ * Vertex transform cache optimizer
+ * Reorders indices to reduce the number of GPU vertex shader invocations
+ * If index buffer contains multiple ranges for multiple draw calls, this functions needs to be called on each range individually.
+ *
+ * destination must contain enough space for the resulting index buffer (index_count elements)
+ */
+MESHOPTIMIZER_API void meshopt_optimizeVertexCache(uint32_t* destination, const uint32_t* indices, size_t index_count, size_t vertex_count);
+
+/**
+ * Vertex transform cache optimizer for strip-like caches
+ * Produces inferior results to meshopt_optimizeVertexCache from the GPU vertex cache perspective
+ * However, the resulting index order is more optimal if the goal is to reduce the triangle strip length or improve compression efficiency
+ *
+ * destination must contain enough space for the resulting index buffer (index_count elements)
+ */
+MESHOPTIMIZER_API void meshopt_optimizeVertexCacheStrip(uint32_t* destination, const uint32_t* indices, size_t index_count, size_t vertex_count);
+
+/**
+ * Vertex transform cache optimizer for FIFO caches
+ * Reorders indices to reduce the number of GPU vertex shader invocations
+ * Generally takes ~3x less time to optimize meshes but produces inferior results compared to meshopt_optimizeVertexCache
+ * If index buffer contains multiple ranges for multiple draw calls, this functions needs to be called on each range individually.
+ *
+ * destination must contain enough space for the resulting index buffer (index_count elements)
+ * cache_size should be less than the actual GPU cache size to avoid cache thrashing
+ */
+MESHOPTIMIZER_API void meshopt_optimizeVertexCacheFifo(uint32_t* destination, const uint32_t* indices, size_t index_count, size_t vertex_count, uint32_t cache_size);
+
+/**
+ * Overdraw optimizer
+ * Reorders indices to reduce the number of GPU vertex shader invocations and the pixel overdraw
+ * If index buffer contains multiple ranges for multiple draw calls, this functions needs to be called on each range individually.
+ *
+ * destination must contain enough space for the resulting index buffer (index_count elements)
+ * indices must contain index data that is the result of meshopt_optimizeVertexCache (*not* the original mesh indices!)
+ * vertex_positions should have float3 position in the first 12 bytes of each vertex - similar to glVertexPointer
+ * threshold indicates how much the overdraw optimizer can degrade vertex cache efficiency (1.05 = up to 5%) to reduce overdraw more efficiently
+ */
+MESHOPTIMIZER_API void meshopt_optimizeOverdraw(uint32_t* destination, const uint32_t* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, float threshold);
+
+/**
+ * Vertex fetch cache optimizer
+ * Reorders vertices and changes indices to reduce the amount of GPU memory fetches during vertex processing
+ * Returns the number of unique vertices, which is the same as input vertex count unless some vertices are unused
+ * This functions works for a single vertex stream; for multiple vertex streams, use meshopt_optimizeVertexFetchRemap + meshopt_remapVertexBuffer for each stream.
+ *
+ * destination must contain enough space for the resulting vertex buffer (vertex_count elements)
+ * indices is used both as an input and as an output index buffer
+ */
+MESHOPTIMIZER_API size_t meshopt_optimizeVertexFetch(void* destination, uint32_t* indices, size_t index_count, const void* vertices, size_t vertex_count, size_t vertex_size);
+
+/**
+ * Vertex fetch cache optimizer
+ * Generates vertex remap to reduce the amount of GPU memory fetches during vertex processing
+ * Returns the number of unique vertices, which is the same as input vertex count unless some vertices are unused
+ * The resulting remap table should be used to reorder vertex/index buffers using meshopt_remapVertexBuffer/meshopt_remapIndexBuffer
+ *
+ * destination must contain enough space for the resulting remap table (vertex_count elements)
+ */
+MESHOPTIMIZER_API size_t meshopt_optimizeVertexFetchRemap(uint32_t* destination, const uint32_t* indices, size_t index_count, size_t vertex_count);
+
+/**
+ * Index buffer encoder
+ * Encodes index data into an array of bytes that is generally much smaller (<1.5 bytes/triangle) and compresses better (<1 bytes/triangle) compared to original.
+ * Input index buffer must represent a triangle list.
+ * Returns encoded data size on success, 0 on error; the only error condition is if buffer doesn't have enough space
+ * For maximum efficiency the index buffer being encoded has to be optimized for vertex cache and vertex fetch first.
+ *
+ * buffer must contain enough space for the encoded index buffer (use meshopt_encodeIndexBufferBound to compute worst case size)
+ */
+MESHOPTIMIZER_API size_t meshopt_encodeIndexBuffer(unsigned char* buffer, size_t buffer_size, const uint32_t* indices, size_t index_count);
+MESHOPTIMIZER_API size_t meshopt_encodeIndexBufferBound(size_t index_count, size_t vertex_count);
+
+/**
+ * Experimental: Set index encoder format version
+ * version must specify the data format version to encode; valid values are 0 (decodable by all library versions) and 1 (decodable by 0.14+)
+ */
+MESHOPTIMIZER_EXPERIMENTAL void meshopt_encodeIndexVersion(int version);
+
+/**
+ * Index buffer decoder
+ * Decodes index data from an array of bytes generated by meshopt_encodeIndexBuffer
+ * Returns 0 if decoding was successful, and an error code otherwise
+ * The decoder is safe to use for untrusted input, but it may produce garbage data (e.g. out of range indices).
+ *
+ * destination must contain enough space for the resulting index buffer (index_count elements)
+ */
+MESHOPTIMIZER_API int meshopt_decodeIndexBuffer(void* destination, size_t index_count, size_t index_size, const unsigned char* buffer, size_t buffer_size);
+
+/**
+ * Experimental: Index sequence encoder
+ * Encodes index sequence into an array of bytes that is generally smaller and compresses better compared to original.
+ * Input index sequence can represent arbitrary topology; for triangle lists meshopt_encodeIndexBuffer is likely to be better.
+ * Returns encoded data size on success, 0 on error; the only error condition is if buffer doesn't have enough space
+ *
+ * buffer must contain enough space for the encoded index sequence (use meshopt_encodeIndexSequenceBound to compute worst case size)
+ */
+MESHOPTIMIZER_EXPERIMENTAL size_t meshopt_encodeIndexSequence(unsigned char* buffer, size_t buffer_size, const uint32_t* indices, size_t index_count);
+MESHOPTIMIZER_EXPERIMENTAL size_t meshopt_encodeIndexSequenceBound(size_t index_count, size_t vertex_count);
+
+/**
+ * Index sequence decoder
+ * Decodes index data from an array of bytes generated by meshopt_encodeIndexSequence
+ * Returns 0 if decoding was successful, and an error code otherwise
+ * The decoder is safe to use for untrusted input, but it may produce garbage data (e.g. out of range indices).
+ *
+ * destination must contain enough space for the resulting index sequence (index_count elements)
+ */
+MESHOPTIMIZER_EXPERIMENTAL int meshopt_decodeIndexSequence(void* destination, size_t index_count, size_t index_size, const unsigned char* buffer, size_t buffer_size);
+
+/**
+ * Vertex buffer encoder
+ * Encodes vertex data into an array of bytes that is generally smaller and compresses better compared to original.
+ * Returns encoded data size on success, 0 on error; the only error condition is if buffer doesn't have enough space
+ * This function works for a single vertex stream; for multiple vertex streams, call meshopt_encodeVertexBuffer for each stream.
+ *
+ * buffer must contain enough space for the encoded vertex buffer (use meshopt_encodeVertexBufferBound to compute worst case size)
+ */
+MESHOPTIMIZER_API size_t meshopt_encodeVertexBuffer(unsigned char* buffer, size_t buffer_size, const void* vertices, size_t vertex_count, size_t vertex_size);
+MESHOPTIMIZER_API size_t meshopt_encodeVertexBufferBound(size_t vertex_count, size_t vertex_size);
+
+/**
+ * Experimental: Set vertex encoder format version
+ * version must specify the data format version to encode; valid values are 0 (decodable by all library versions)
+ */
+MESHOPTIMIZER_EXPERIMENTAL void meshopt_encodeVertexVersion(int version);
+
+/**
+ * Vertex buffer decoder
+ * Decodes vertex data from an array of bytes generated by meshopt_encodeVertexBuffer
+ * Returns 0 if decoding was successful, and an error code otherwise
+ * The decoder is safe to use for untrusted input, but it may produce garbage data.
+ *
+ * destination must contain enough space for the resulting vertex buffer (vertex_count * vertex_size bytes)
+ */
+MESHOPTIMIZER_API int meshopt_decodeVertexBuffer(void* destination, size_t vertex_count, size_t vertex_size, const unsigned char* buffer, size_t buffer_size);
+
+/**
+ * Vertex buffer filters
+ * These functions can be used to filter output of meshopt_decodeVertexBuffer in-place.
+ * count must be aligned by 4 and stride is fixed for each function to facilitate SIMD implementation.
+ *
+ * meshopt_decodeFilterOct decodes octahedral encoding of a unit vector with K-bit (K <= 16) signed X/Y as an input; Z must store 1.0f.
+ * Each component is stored as an 8-bit or 16-bit normalized integer; stride must be equal to 4 or 8. W is preserved as is.
+ *
+ * meshopt_decodeFilterQuat decodes 3-component quaternion encoding with K-bit (4 <= K <= 16) component encoding and a 2-bit component index indicating which component to reconstruct.
+ * Each component is stored as an 16-bit integer; stride must be equal to 8.
+ *
+ * meshopt_decodeFilterExp decodes exponential encoding of floating-point data with 8-bit exponent and 24-bit integer mantissa as 2^E*M.
+ * Each 32-bit component is decoded in isolation; stride must be divisible by 4.
+ */
+MESHOPTIMIZER_EXPERIMENTAL void meshopt_decodeFilterOct(void* buffer, size_t vertex_count, size_t vertex_size);
+MESHOPTIMIZER_EXPERIMENTAL void meshopt_decodeFilterQuat(void* buffer, size_t vertex_count, size_t vertex_size);
+MESHOPTIMIZER_EXPERIMENTAL void meshopt_decodeFilterExp(void* buffer, size_t vertex_count, size_t vertex_size);
+
+/**
+ * Experimental: Mesh simplifier
+ * Reduces the number of triangles in the mesh, attempting to preserve mesh appearance as much as possible
+ * The algorithm tries to preserve mesh topology and can stop short of the target goal based on topology constraints or target error.
+ * If not all attributes from the input mesh are required, it's recommended to reindex the mesh using meshopt_generateShadowIndexBuffer prior to simplification.
+ * Returns the number of indices after simplification, with destination containing new index data
+ * The resulting index buffer references vertices from the original vertex buffer.
+ * If the original vertex data isn't required, creating a compact vertex buffer using meshopt_optimizeVertexFetch is recommended.
+ *
+ * destination must contain enough space for the *source* index buffer (since optimization is iterative, this means index_count elements - *not* target_index_count!)
+ * vertex_positions should have float3 position in the first 12 bytes of each vertex - similar to glVertexPointer
+ */
+MESHOPTIMIZER_EXPERIMENTAL size_t meshopt_simplify(uint32_t* destination, const uint32_t* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t target_index_count, float target_error);
+
+/**
+ * Experimental: Mesh simplifier (sloppy)
+ * Reduces the number of triangles in the mesh, sacrificing mesh apperance for simplification performance
+ * The algorithm doesn't preserve mesh topology but is always able to reach target triangle count.
+ * Returns the number of indices after simplification, with destination containing new index data
+ * The resulting index buffer references vertices from the original vertex buffer.
+ * If the original vertex data isn't required, creating a compact vertex buffer using meshopt_optimizeVertexFetch is recommended.
+ *
+ * destination must contain enough space for the target index buffer
+ * vertex_positions should have float3 position in the first 12 bytes of each vertex - similar to glVertexPointer
+ */
+MESHOPTIMIZER_EXPERIMENTAL size_t meshopt_simplifySloppy(uint32_t* destination, const uint32_t* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t target_index_count);
+
+/**
+ * Experimental: Point cloud simplifier
+ * Reduces the number of points in the cloud to reach the given target
+ * Returns the number of points after simplification, with destination containing new index data
+ * The resulting index buffer references vertices from the original vertex buffer.
+ * If the original vertex data isn't required, creating a compact vertex buffer using meshopt_optimizeVertexFetch is recommended.
+ *
+ * destination must contain enough space for the target index buffer
+ * vertex_positions should have float3 position in the first 12 bytes of each vertex - similar to glVertexPointer
+ */
+MESHOPTIMIZER_EXPERIMENTAL size_t meshopt_simplifyPoints(uint32_t* destination, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t target_vertex_count);
+
+/**
+ * Mesh stripifier
+ * Converts a previously vertex cache optimized triangle list to triangle strip, stitching strips using restart index or degenerate triangles
+ * Returns the number of indices in the resulting strip, with destination containing new index data
+ * For maximum efficiency the index buffer being converted has to be optimized for vertex cache first.
+ * Using restart indices can result in ~10% smaller index buffers, but on some GPUs restart indices may result in decreased performance.
+ *
+ * destination must contain enough space for the target index buffer, worst case can be computed with meshopt_stripifyBound
+ * restart_index should be 0xffff or 0xffffffff depending on index size, or 0 to use degenerate triangles
+ */
+MESHOPTIMIZER_API size_t meshopt_stripify(uint32_t* destination, const uint32_t* indices, size_t index_count, size_t vertex_count, uint32_t restart_index);
+MESHOPTIMIZER_API size_t meshopt_stripifyBound(size_t index_count);
+
+/**
+ * Mesh unstripifier
+ * Converts a triangle strip to a triangle list
+ * Returns the number of indices in the resulting list, with destination containing new index data
+ *
+ * destination must contain enough space for the target index buffer, worst case can be computed with meshopt_unstripifyBound
+ */
+MESHOPTIMIZER_API size_t meshopt_unstripify(uint32_t* destination, const uint32_t* indices, size_t index_count, uint32_t restart_index);
+MESHOPTIMIZER_API size_t meshopt_unstripifyBound(size_t index_count);
+
+struct meshopt_VertexCacheStatistics
+{
+	uint32_t vertices_transformed;
+	uint32_t warps_executed;
+	float acmr; /* transformed vertices / triangle count; best case 0.5, worst case 3.0, optimum depends on topology */
+	float atvr; /* transformed vertices / vertex count; best case 1.0, worst case 6.0, optimum is 1.0 (each vertex is transformed once) */
+};
+
+/**
+ * Vertex transform cache analyzer
+ * Returns cache hit statistics using a simplified FIFO model
+ * Results may not match actual GPU performance
+ */
+MESHOPTIMIZER_API struct meshopt_VertexCacheStatistics meshopt_analyzeVertexCache(const uint32_t* indices, size_t index_count, size_t vertex_count, uint32_t cache_size, uint32_t warp_size, uint32_t primgroup_size);
+
+struct meshopt_OverdrawStatistics
+{
+	uint32_t pixels_covered;
+	uint32_t pixels_shaded;
+	float overdraw; /* shaded pixels / covered pixels; best case 1.0 */
+};
+
+/**
+ * Overdraw analyzer
+ * Returns overdraw statistics using a software rasterizer
+ * Results may not match actual GPU performance
+ *
+ * vertex_positions should have float3 position in the first 12 bytes of each vertex - similar to glVertexPointer
+ */
+MESHOPTIMIZER_API struct meshopt_OverdrawStatistics meshopt_analyzeOverdraw(const uint32_t* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
+
+struct meshopt_VertexFetchStatistics
+{
+	uint32_t bytes_fetched;
+	float overfetch; /* fetched bytes / vertex buffer size; best case 1.0 (each byte is fetched once) */
+};
+
+/**
+ * Vertex fetch cache analyzer
+ * Returns cache hit statistics using a simplified direct mapped model
+ * Results may not match actual GPU performance
+ */
+MESHOPTIMIZER_API struct meshopt_VertexFetchStatistics meshopt_analyzeVertexFetch(const uint32_t* indices, size_t index_count, size_t vertex_count, size_t vertex_size);
+
+struct meshopt_Meshlet
+{
+	uint32_t vertices[64];
+	unsigned char indices[126][3];
+	unsigned char triangle_count;
+	unsigned char vertex_count;
+};
+
+/**
+ * Experimental: Meshlet builder
+ * Splits the mesh into a set of meshlets where each meshlet has a micro index buffer indexing into meshlet vertices that refer to the original vertex buffer
+ * The resulting data can be used to render meshes using NVidia programmable mesh shading pipeline, or in other cluster-based renderers.
+ * For maximum efficiency the index buffer being converted has to be optimized for vertex cache first.
+ *
+ * destination must contain enough space for all meshlets, worst case size can be computed with meshopt_buildMeshletsBound
+ * max_vertices and max_triangles can't exceed limits statically declared in meshopt_Meshlet (max_vertices <= 64, max_triangles <= 126)
+ */
+MESHOPTIMIZER_EXPERIMENTAL size_t meshopt_buildMeshlets(struct meshopt_Meshlet* destination, const uint32_t* indices, size_t index_count, size_t vertex_count, size_t max_vertices, size_t max_triangles);
+MESHOPTIMIZER_EXPERIMENTAL size_t meshopt_buildMeshletsBound(size_t index_count, size_t max_vertices, size_t max_triangles);
+
+struct meshopt_Bounds
+{
+	/* bounding sphere, useful for frustum and occlusion culling */
+	float center[3];
+	float radius;
+
+	/* normal cone, useful for backface culling */
+	float cone_apex[3];
+	float cone_axis[3];
+	float cone_cutoff; /* = cos(angle/2) */
+
+	/* normal cone axis and cutoff, stored in 8-bit SNORM format; decode using x/127.0 */
+	signed char cone_axis_s8[3];
+	signed char cone_cutoff_s8;
+};
+
+/**
+ * Experimental: Cluster bounds generator
+ * Creates bounding volumes that can be used for frustum, backface and occlusion culling.
+ *
+ * For backface culling with orthographic projection, use the following formula to reject backfacing clusters:
+ *   dot(view, cone_axis) >= cone_cutoff
+ *
+ * For perspective projection, you can the formula that needs cone apex in addition to axis & cutoff:
+ *   dot(normalize(cone_apex - camera_position), cone_axis) >= cone_cutoff
+ *
+ * Alternatively, you can use the formula that doesn't need cone apex and uses bounding sphere instead:
+ *   dot(normalize(center - camera_position), cone_axis) >= cone_cutoff + radius / length(center - camera_position)
+ * or an equivalent formula that doesn't have a singularity at center = camera_position:
+ *   dot(center - camera_position, cone_axis) >= cone_cutoff * length(center - camera_position) + radius
+ *
+ * The formula that uses the apex is slightly more accurate but needs the apex; if you are already using bounding sphere
+ * to do frustum/occlusion culling, the formula that doesn't use the apex may be preferable.
+ *
+ * vertex_positions should have float3 position in the first 12 bytes of each vertex - similar to glVertexPointer
+ * index_count should be less than or equal to 256*3 (the function assumes clusters of limited size)
+ */
+MESHOPTIMIZER_EXPERIMENTAL struct meshopt_Bounds meshopt_computeClusterBounds(const uint32_t* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
+MESHOPTIMIZER_EXPERIMENTAL struct meshopt_Bounds meshopt_computeMeshletBounds(const struct meshopt_Meshlet* meshlet, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
+
+/**
+ * Experimental: Spatial sorter
+ * Generates a remap table that can be used to reorder points for spatial locality.
+ * Resulting remap table maps old vertices to new vertices and can be used in meshopt_remapVertexBuffer.
+ *
+ * destination must contain enough space for the resulting remap table (vertex_count elements)
+ */
+MESHOPTIMIZER_EXPERIMENTAL void meshopt_spatialSortRemap(uint32_t* destination, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
+
+/**
+ * Experimental: Spatial sorter
+ * Reorders triangles for spatial locality, and generates a new index buffer. The resulting index buffer can be used with other functions like optimizeVertexCache.
+ *
+ * destination must contain enough space for the resulting index buffer (index_count elements)
+ * vertex_positions should have float3 position in the first 12 bytes of each vertex - similar to glVertexPointer
+ */
+MESHOPTIMIZER_EXPERIMENTAL void meshopt_spatialSortTriangles(uint32_t* destination, const uint32_t* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
+
+/**
+ * Set allocation callbacks
+ * These callbacks will be used instead of the default operator new/operator delete for all temporary allocations in the library.
+ * Note that all algorithms only allocate memory for temporary use.
+ * allocate/deallocate are always called in a stack-like order - last pointer to be allocated is deallocated first.
+ */
+MESHOPTIMIZER_API void meshopt_setAllocator(void* (*allocate)(size_t), void (*deallocate)(void*));
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+/* Quantization into commonly supported data formats */
+#ifdef __cplusplus
+/**
+ * Quantize a float in [0..1] range into an N-bit fixed point unorm value
+ * Assumes reconstruction function (q / (2^N-1)), which is the case for fixed-function normalized fixed point conversion
+ * Maximum reconstruction error: 1/2^(N+1)
+ */
+inline int meshopt_quantizeUnorm(float v, int N);
+
+/**
+ * Quantize a float in [-1..1] range into an N-bit fixed point snorm value
+ * Assumes reconstruction function (q / (2^(N-1)-1)), which is the case for fixed-function normalized fixed point conversion (except early OpenGL versions)
+ * Maximum reconstruction error: 1/2^N
+ */
+inline int meshopt_quantizeSnorm(float v, int N);
+
+/**
+ * Quantize a float into half-precision floating point value
+ * Generates +-inf for overflow, preserves NaN, flushes denormals to zero, rounds to nearest
+ * Representable magnitude range: [6e-5; 65504]
+ * Maximum relative reconstruction error: 5e-4
+ */
+inline unsigned short meshopt_quantizeHalf(float v);
+
+/**
+ * Quantize a float into a floating point value with a limited number of significant mantissa bits
+ * Generates +-inf for overflow, preserves NaN, flushes denormals to zero, rounds to nearest
+ * Assumes N is in a valid mantissa precision range, which is 1..23
+ */
+inline float meshopt_quantizeFloat(float v, int N);
+#endif
+
+/**
+ * C++ template interface
+ *
+ * These functions mirror the C interface the library provides, providing template-based overloads so that
+ * the caller can use an arbitrary type for the index data, both for input and output.
+ * When the supplied type is the same size as that of uint32_t, the wrappers are zero-cost; when it's not,
+ * the wrappers end up allocating memory and copying index data to convert from one type to another.
+ */
+#if defined(__cplusplus) && !defined(MESHOPTIMIZER_NO_WRAPPERS)
+template <typename T>
+inline size_t meshopt_generateVertexRemap(uint32_t* destination, const T* indices, size_t index_count, const void* vertices, size_t vertex_count, size_t vertex_size);
+template <typename T>
+inline size_t meshopt_generateVertexRemapMulti(uint32_t* destination, const T* indices, size_t index_count, size_t vertex_count, const meshopt_Stream* streams, size_t stream_count);
+template <typename T>
+inline void meshopt_remapIndexBuffer(T* destination, const T* indices, size_t index_count, const uint32_t* remap);
+template <typename T>
+inline void meshopt_generateShadowIndexBuffer(T* destination, const T* indices, size_t index_count, const void* vertices, size_t vertex_count, size_t vertex_size, size_t vertex_stride);
+template <typename T>
+inline void meshopt_generateShadowIndexBufferMulti(T* destination, const T* indices, size_t index_count, size_t vertex_count, const meshopt_Stream* streams, size_t stream_count);
+template <typename T>
+inline void meshopt_optimizeVertexCache(T* destination, const T* indices, size_t index_count, size_t vertex_count);
+template <typename T>
+inline void meshopt_optimizeVertexCacheStrip(T* destination, const T* indices, size_t index_count, size_t vertex_count);
+template <typename T>
+inline void meshopt_optimizeVertexCacheFifo(T* destination, const T* indices, size_t index_count, size_t vertex_count, uint32_t cache_size);
+template <typename T>
+inline void meshopt_optimizeOverdraw(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, float threshold);
+template <typename T>
+inline size_t meshopt_optimizeVertexFetchRemap(uint32_t* destination, const T* indices, size_t index_count, size_t vertex_count);
+template <typename T>
+inline size_t meshopt_optimizeVertexFetch(void* destination, T* indices, size_t index_count, const void* vertices, size_t vertex_count, size_t vertex_size);
+template <typename T>
+inline size_t meshopt_encodeIndexBuffer(unsigned char* buffer, size_t buffer_size, const T* indices, size_t index_count);
+template <typename T>
+inline int meshopt_decodeIndexBuffer(T* destination, size_t index_count, const unsigned char* buffer, size_t buffer_size);
+template <typename T>
+inline size_t meshopt_encodeIndexSequence(unsigned char* buffer, size_t buffer_size, const T* indices, size_t index_count);
+template <typename T>
+inline int meshopt_decodeIndexSequence(T* destination, size_t index_count, const unsigned char* buffer, size_t buffer_size);
+template <typename T>
+inline size_t meshopt_simplify(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t target_index_count, float target_error);
+template <typename T>
+inline size_t meshopt_simplifySloppy(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t target_index_count);
+template <typename T>
+inline size_t meshopt_stripify(T* destination, const T* indices, size_t index_count, size_t vertex_count, T restart_index);
+template <typename T>
+inline size_t meshopt_unstripify(T* destination, const T* indices, size_t index_count, T restart_index);
+template <typename T>
+inline meshopt_VertexCacheStatistics meshopt_analyzeVertexCache(const T* indices, size_t index_count, size_t vertex_count, uint32_t cache_size, uint32_t warp_size, uint32_t buffer_size);
+template <typename T>
+inline meshopt_OverdrawStatistics meshopt_analyzeOverdraw(const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
+template <typename T>
+inline meshopt_VertexFetchStatistics meshopt_analyzeVertexFetch(const T* indices, size_t index_count, size_t vertex_count, size_t vertex_size);
+template <typename T>
+inline size_t meshopt_buildMeshlets(meshopt_Meshlet* destination, const T* indices, size_t index_count, size_t vertex_count, size_t max_vertices, size_t max_triangles);
+template <typename T>
+inline meshopt_Bounds meshopt_computeClusterBounds(const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
+template <typename T>
+inline void meshopt_spatialSortTriangles(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
+#endif
+
+/* Inline implementation */
+#ifdef __cplusplus
+inline int meshopt_quantizeUnorm(float v, int N)
+{
+	const float scale = float((1 << N) - 1);
+
+	v = (v >= 0) ? v : 0;
+	v = (v <= 1) ? v : 1;
+
+	return int(v * scale + 0.5f);
+}
+
+inline int meshopt_quantizeSnorm(float v, int N)
+{
+	const float scale = float((1 << (N - 1)) - 1);
+
+	float round = (v >= 0 ? 0.5f : -0.5f);
+
+	v = (v >= -1) ? v : -1;
+	v = (v <= +1) ? v : +1;
+
+	return int(v * scale + round);
+}
+
+inline unsigned short meshopt_quantizeHalf(float v)
+{
+	union { float f; uint32_t ui; } u = {v};
+	uint32_t ui = u.ui;
+
+	int s = (ui >> 16) & 0x8000;
+	int em = ui & 0x7fffffff;
+
+	/* bias exponent and round to nearest; 112 is relative exponent bias (127-15) */
+	int h = (em - (112 << 23) + (1 << 12)) >> 13;
+
+	/* underflow: flush to zero; 113 encodes exponent -14 */
+	h = (em < (113 << 23)) ? 0 : h;
+
+	/* overflow: infinity; 143 encodes exponent 16 */
+	h = (em >= (143 << 23)) ? 0x7c00 : h;
+
+	/* NaN; note that we convert all types of NaN to qNaN */
+	h = (em > (255 << 23)) ? 0x7e00 : h;
+
+	return (unsigned short)(s | h);
+}
+
+inline float meshopt_quantizeFloat(float v, int N)
+{
+	union { float f; uint32_t ui; } u = {v};
+	uint32_t ui = u.ui;
+
+	const int mask = (1 << (23 - N)) - 1;
+	const int round = (1 << (23 - N)) >> 1;
+
+	int e = ui & 0x7f800000;
+	uint32_t rui = (ui + round) & ~mask;
+
+	/* round all numbers except inf/nan; this is important to make sure nan doesn't overflow into -0 */
+	ui = e == 0x7f800000 ? ui : rui;
+
+	/* flush denormals to zero */
+	ui = e == 0 ? 0 : ui;
+
+	u.ui = ui;
+	return u.f;
+}
+#endif
+
+/* Internal implementation helpers */
+#ifdef __cplusplus
+class meshopt_Allocator
+{
+public:
+	template <typename T>
+	struct StorageT
+	{
+		static void* (*allocate)(size_t);
+		static void (*deallocate)(void*);
+	};
+
+	typedef StorageT<void> Storage;
+
+	meshopt_Allocator()
+		: blocks()
+		, count(0)
+	{
+	}
+
+	~meshopt_Allocator()
+	{
+		for (size_t i = count; i > 0; --i)
+			Storage::deallocate(blocks[i - 1]);
+	}
+
+	template <typename T> T* allocate(size_t size)
+	{
+		assert(count < sizeof(blocks) / sizeof(blocks[0]));
+		T* result = static_cast<T*>(Storage::allocate(size > size_t(-1) / sizeof(T) ? size_t(-1) : size * sizeof(T)));
+		blocks[count++] = result;
+		return result;
+	}
+
+private:
+	void* blocks[24];
+	size_t count;
+};
+
+// This makes sure that allocate/deallocate are lazily generated in translation units that need them and are deduplicated by the linker
+template <typename T> void* (*meshopt_Allocator::StorageT<T>::allocate)(size_t) = operator new;
+template <typename T> void (*meshopt_Allocator::StorageT<T>::deallocate)(void*) = operator delete;
+#endif
+
+/* Inline implementation for C++ templated wrappers */
+#if defined(__cplusplus) && !defined(MESHOPTIMIZER_NO_WRAPPERS)
+template <typename T, bool ZeroCopy = sizeof(T) == sizeof(uint32_t)>
+struct meshopt_IndexAdapter;
+
+template <typename T>
+struct meshopt_IndexAdapter<T, false>
+{
+	T* result;
+	uint32_t* data;
+	size_t count;
+
+	meshopt_IndexAdapter(T* result_, const T* input, size_t count_)
+	    : result(result_)
+	    , data(0)
+	    , count(count_)
+	{
+		size_t size = count > size_t(-1) / sizeof(uint32_t) ? size_t(-1) : count * sizeof(uint32_t);
+
+		data = static_cast<uint32_t*>(meshopt_Allocator::Storage::allocate(size));
+
+		if (input)
+		{
+			for (size_t i = 0; i < count; ++i)
+				data[i] = input[i];
+		}
+	}
+
+	~meshopt_IndexAdapter()
+	{
+		if (result)
+		{
+			for (size_t i = 0; i < count; ++i)
+				result[i] = T(data[i]);
+		}
+
+		meshopt_Allocator::Storage::deallocate(data);
+	}
+};
+
+template <typename T>
+struct meshopt_IndexAdapter<T, true>
+{
+	uint32_t* data;
+
+	meshopt_IndexAdapter(T* result, const T* input, size_t)
+	    : data(reinterpret_cast<uint32_t*>(result ? result : const_cast<T*>(input)))
+	{
+	}
+};
+
+template <typename T>
+inline size_t meshopt_generateVertexRemap(uint32_t* destination, const T* indices, size_t index_count, const void* vertices, size_t vertex_count, size_t vertex_size)
+{
+	meshopt_IndexAdapter<T> in(0, indices, indices ? index_count : 0);
+
+	return meshopt_generateVertexRemap(destination, indices ? in.data : 0, index_count, vertices, vertex_count, vertex_size);
+}
+
+template <typename T>
+inline size_t meshopt_generateVertexRemapMulti(uint32_t* destination, const T* indices, size_t index_count, size_t vertex_count, const meshopt_Stream* streams, size_t stream_count)
+{
+	meshopt_IndexAdapter<T> in(0, indices, indices ? index_count : 0);
+
+	return meshopt_generateVertexRemapMulti(destination, indices ? in.data : 0, index_count, vertex_count, streams, stream_count);
+}
+
+template <typename T>
+inline void meshopt_remapIndexBuffer(T* destination, const T* indices, size_t index_count, const uint32_t* remap)
+{
+	meshopt_IndexAdapter<T> in(0, indices, indices ? index_count : 0);
+	meshopt_IndexAdapter<T> out(destination, 0, index_count);
+
+	meshopt_remapIndexBuffer(out.data, indices ? in.data : 0, index_count, remap);
+}
+
+template <typename T>
+inline void meshopt_generateShadowIndexBuffer(T* destination, const T* indices, size_t index_count, const void* vertices, size_t vertex_count, size_t vertex_size, size_t vertex_stride)
+{
+	meshopt_IndexAdapter<T> in(0, indices, index_count);
+	meshopt_IndexAdapter<T> out(destination, 0, index_count);
+
+	meshopt_generateShadowIndexBuffer(out.data, in.data, index_count, vertices, vertex_count, vertex_size, vertex_stride);
+}
+
+template <typename T>
+inline void meshopt_generateShadowIndexBufferMulti(T* destination, const T* indices, size_t index_count, size_t vertex_count, const meshopt_Stream* streams, size_t stream_count)
+{
+	meshopt_IndexAdapter<T> in(0, indices, index_count);
+	meshopt_IndexAdapter<T> out(destination, 0, index_count);
+
+	meshopt_generateShadowIndexBufferMulti(out.data, in.data, index_count, vertex_count, streams, stream_count);
+}
+
+template <typename T>
+inline void meshopt_optimizeVertexCache(T* destination, const T* indices, size_t index_count, size_t vertex_count)
+{
+	meshopt_IndexAdapter<T> in(0, indices, index_count);
+	meshopt_IndexAdapter<T> out(destination, 0, index_count);
+
+	meshopt_optimizeVertexCache(out.data, in.data, index_count, vertex_count);
+}
+
+template <typename T>
+inline void meshopt_optimizeVertexCacheStrip(T* destination, const T* indices, size_t index_count, size_t vertex_count)
+{
+	meshopt_IndexAdapter<T> in(0, indices, index_count);
+	meshopt_IndexAdapter<T> out(destination, 0, index_count);
+
+	meshopt_optimizeVertexCacheStrip(out.data, in.data, index_count, vertex_count);
+}
+
+template <typename T>
+inline void meshopt_optimizeVertexCacheFifo(T* destination, const T* indices, size_t index_count, size_t vertex_count, uint32_t cache_size)
+{
+	meshopt_IndexAdapter<T> in(0, indices, index_count);
+	meshopt_IndexAdapter<T> out(destination, 0, index_count);
+
+	meshopt_optimizeVertexCacheFifo(out.data, in.data, index_count, vertex_count, cache_size);
+}
+
+template <typename T>
+inline void meshopt_optimizeOverdraw(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, float threshold)
+{
+	meshopt_IndexAdapter<T> in(0, indices, index_count);
+	meshopt_IndexAdapter<T> out(destination, 0, index_count);
+
+	meshopt_optimizeOverdraw(out.data, in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride, threshold);
+}
+
+template <typename T>
+inline size_t meshopt_optimizeVertexFetchRemap(uint32_t* destination, const T* indices, size_t index_count, size_t vertex_count)
+{
+	meshopt_IndexAdapter<T> in(0, indices, index_count);
+
+	return meshopt_optimizeVertexFetchRemap(destination, in.data, index_count, vertex_count);
+}
+
+template <typename T>
+inline size_t meshopt_optimizeVertexFetch(void* destination, T* indices, size_t index_count, const void* vertices, size_t vertex_count, size_t vertex_size)
+{
+	meshopt_IndexAdapter<T> inout(indices, indices, index_count);
+
+	return meshopt_optimizeVertexFetch(destination, inout.data, index_count, vertices, vertex_count, vertex_size);
+}
+
+template <typename T>
+inline size_t meshopt_encodeIndexBuffer(unsigned char* buffer, size_t buffer_size, const T* indices, size_t index_count)
+{
+	meshopt_IndexAdapter<T> in(0, indices, index_count);
+
+	return meshopt_encodeIndexBuffer(buffer, buffer_size, in.data, index_count);
+}
+
+template <typename T>
+inline int meshopt_decodeIndexBuffer(T* destination, size_t index_count, const unsigned char* buffer, size_t buffer_size)
+{
+	char index_size_valid[sizeof(T) == 2 || sizeof(T) == 4 ? 1 : -1];
+	(void)index_size_valid;
+
+	return meshopt_decodeIndexBuffer(destination, index_count, sizeof(T), buffer, buffer_size);
+}
+
+template <typename T>
+inline size_t meshopt_encodeIndexSequence(unsigned char* buffer, size_t buffer_size, const T* indices, size_t index_count)
+{
+	meshopt_IndexAdapter<T> in(0, indices, index_count);
+
+	return meshopt_encodeIndexSequence(buffer, buffer_size, in.data, index_count);
+}
+
+template <typename T>
+inline int meshopt_decodeIndexSequence(T* destination, size_t index_count, const unsigned char* buffer, size_t buffer_size)
+{
+	char index_size_valid[sizeof(T) == 2 || sizeof(T) == 4 ? 1 : -1];
+	(void)index_size_valid;
+
+	return meshopt_decodeIndexSequence(destination, index_count, sizeof(T), buffer, buffer_size);
+}
+
+template <typename T>
+inline size_t meshopt_simplify(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t target_index_count, float target_error)
+{
+	meshopt_IndexAdapter<T> in(0, indices, index_count);
+	meshopt_IndexAdapter<T> out(destination, 0, index_count);
+
+	return meshopt_simplify(out.data, in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride, target_index_count, target_error);
+}
+
+template <typename T>
+inline size_t meshopt_simplifySloppy(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t target_index_count)
+{
+	meshopt_IndexAdapter<T> in(0, indices, index_count);
+	meshopt_IndexAdapter<T> out(destination, 0, target_index_count);
+
+	return meshopt_simplifySloppy(out.data, in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride, target_index_count);
+}
+
+template <typename T>
+inline size_t meshopt_stripify(T* destination, const T* indices, size_t index_count, size_t vertex_count, T restart_index)
+{
+	meshopt_IndexAdapter<T> in(0, indices, index_count);
+	meshopt_IndexAdapter<T> out(destination, 0, (index_count / 3) * 5);
+
+	return meshopt_stripify(out.data, in.data, index_count, vertex_count, unsigned(restart_index));
+}
+
+template <typename T>
+inline size_t meshopt_unstripify(T* destination, const T* indices, size_t index_count, T restart_index)
+{
+	meshopt_IndexAdapter<T> in(0, indices, index_count);
+	meshopt_IndexAdapter<T> out(destination, 0, (index_count - 2) * 3);
+
+	return meshopt_unstripify(out.data, in.data, index_count, unsigned(restart_index));
+}
+
+template <typename T>
+inline meshopt_VertexCacheStatistics meshopt_analyzeVertexCache(const T* indices, size_t index_count, size_t vertex_count, uint32_t cache_size, uint32_t warp_size, uint32_t buffer_size)
+{
+	meshopt_IndexAdapter<T> in(0, indices, index_count);
+
+	return meshopt_analyzeVertexCache(in.data, index_count, vertex_count, cache_size, warp_size, buffer_size);
+}
+
+template <typename T>
+inline meshopt_OverdrawStatistics meshopt_analyzeOverdraw(const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride)
+{
+	meshopt_IndexAdapter<T> in(0, indices, index_count);
+
+	return meshopt_analyzeOverdraw(in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride);
+}
+
+template <typename T>
+inline meshopt_VertexFetchStatistics meshopt_analyzeVertexFetch(const T* indices, size_t index_count, size_t vertex_count, size_t vertex_size)
+{
+	meshopt_IndexAdapter<T> in(0, indices, index_count);
+
+	return meshopt_analyzeVertexFetch(in.data, index_count, vertex_count, vertex_size);
+}
+
+template <typename T>
+inline size_t meshopt_buildMeshlets(meshopt_Meshlet* destination, const T* indices, size_t index_count, size_t vertex_count, size_t max_vertices, size_t max_triangles)
+{
+	meshopt_IndexAdapter<T> in(0, indices, index_count);
+
+	return meshopt_buildMeshlets(destination, in.data, index_count, vertex_count, max_vertices, max_triangles);
+}
+
+template <typename T>
+inline meshopt_Bounds meshopt_computeClusterBounds(const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride)
+{
+	meshopt_IndexAdapter<T> in(0, indices, index_count);
+
+	return meshopt_computeClusterBounds(in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride);
+}
+
+template <typename T>
+inline void meshopt_spatialSortTriangles(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride)
+{
+	meshopt_IndexAdapter<T> in(0, indices, index_count);
+	meshopt_IndexAdapter<T> out(destination, 0, index_count);
+
+	meshopt_spatialSortTriangles(out.data, in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride);
+}
+#endif
+
+/**
+ * Copyright (c) 2016-2020 Arseny Kapoulkine
+ *
+ * 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.
+ */
diff --git a/engine/inc/nlohmann/fifo_map.hpp b/engine/inc/nlohmann/fifo_map.hpp
new file mode 100644
index 00000000..2b55ae28
--- /dev/null
+++ b/engine/inc/nlohmann/fifo_map.hpp
@@ -0,0 +1,547 @@
+/*
+The code is licensed under the MIT License <http://opensource.org/licenses/MIT>:
+
+Copyright (c) 2015-2017 Niels Lohmann.
+
+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.
+*/
+
+#ifndef NLOHMANN_FIFO_MAP_HPP
+#define NLOHMANN_FIFO_MAP_HPP
+
+#include <algorithm>
+#include <cstdlib>
+#include <functional>
+#include <iostream>
+#include <limits>
+#include <map>
+#include <memory>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+/*!
+@brief namespace for Niels Lohmann
+@see https://github.com/nlohmann
+*/
+namespace nlohmann
+{
+
+template<class Key>
+class fifo_map_compare
+{
+  public:
+    /// constructor given a pointer to a key storage
+    fifo_map_compare(
+        std::unordered_map<Key, std::size_t>* keys,
+        std::size_t timestamp = 1)
+        :
+        m_timestamp(timestamp),
+        m_keys(keys)
+    {}
+
+    /*!
+    This function compares two keys with respect to the order in which they
+    were added to the container. For this, the mapping keys is used.
+    */
+    bool operator()(const Key& lhs, const Key& rhs) const
+    {
+        // look up timestamps for both keys
+        const auto timestamp_lhs = m_keys->find(lhs);
+        const auto timestamp_rhs = m_keys->find(rhs);
+
+        if (timestamp_lhs == m_keys->end())
+        {
+            // timestamp for lhs not found - cannot be smaller than for rhs
+            return false;
+        }
+
+        if (timestamp_rhs == m_keys->end())
+        {
+            // timestamp for rhs not found - timestamp for lhs is smaller
+            return true;
+        }
+
+        // compare timestamps
+        return timestamp_lhs->second < timestamp_rhs->second;
+    }
+
+    void add_key(const Key& key)
+    {
+        m_keys->insert({key, m_timestamp++});
+    }
+
+    void remove_key(const Key& key)
+    {
+        m_keys->erase(key);
+    }
+
+  private:
+    /// helper to access m_timestamp from fifo_map copy ctor,
+    /// must have same number of template args as fifo_map
+    template <
+        class MapKey,
+        class MapT,
+        class MapCompare,
+        class MapAllocator
+        > friend class fifo_map;
+
+  private:
+    /// the next valid insertion timestamp
+    std::size_t m_timestamp = 1;
+
+    /// pointer to a mapping from keys to insertion timestamps
+    std::unordered_map<Key, std::size_t>* m_keys = nullptr;
+};
+
+
+template <
+    class Key,
+    class T,
+    class Compare = fifo_map_compare<Key>,
+    class Allocator = std::allocator<std::pair<const Key, T>>
+    > class fifo_map
+{
+  public:
+    using key_type = Key;
+    using mapped_type = T;
+    using value_type = std::pair<const Key, T>;
+    using size_type = std::size_t;
+    using difference_type = std::ptrdiff_t;
+    using key_compare = Compare;
+    using allocator_type = Allocator;
+    using reference = value_type&;
+    using const_reference = const value_type&;
+    using pointer = typename std::allocator_traits<Allocator>::pointer;
+    using const_pointer = typename std::allocator_traits<Allocator>::const_pointer;
+
+    using internal_map_type = std::map<Key, T, Compare, Allocator>;
+
+    using iterator = typename internal_map_type::iterator;
+    using const_iterator = typename internal_map_type::const_iterator;
+    using reverse_iterator = typename internal_map_type::reverse_iterator;
+    using const_reverse_iterator = typename internal_map_type::const_reverse_iterator;
+
+  public:
+    /// default constructor
+    fifo_map() : m_keys(), m_compare(&m_keys), m_map(m_compare) {}
+
+    /// copy constructor
+    fifo_map(const fifo_map &f) : m_keys(f.m_keys), m_compare(&m_keys, f.m_compare.m_timestamp), m_map(f.m_map.begin(), f.m_map.end(), m_compare) {}
+
+    /// constructor for a range of elements
+    template<class InputIterator>
+    fifo_map(InputIterator first, InputIterator last)
+        : m_keys(), m_compare(&m_keys), m_map(m_compare)
+    {
+        for (auto it = first; it != last; ++it)
+        {
+            insert(*it);
+        }
+    }
+
+    /// constructor for a list of elements
+    fifo_map(std::initializer_list<value_type> init) : fifo_map()
+    {
+        for (auto x : init)
+        {
+            insert(x);
+        }
+    }
+
+
+    /*
+     * Element access
+     */
+
+    /// access specified element with bounds checking
+    T& at(const Key& key)
+    {
+        return m_map.at(key);
+    }
+
+    /// access specified element with bounds checking
+    const T& at(const Key& key) const
+    {
+        return m_map.at(key);
+    }
+
+    /// access specified element
+    T& operator[](const Key& key)
+    {
+        m_compare.add_key(key);
+        return m_map[key];
+    }
+
+    /// access specified element
+    T& operator[](Key&& key)
+    {
+        m_compare.add_key(key);
+        return m_map[key];
+    }
+
+
+    /*
+     * Iterators
+     */
+
+    /// returns an iterator to the beginning
+    iterator begin() noexcept
+    {
+        return m_map.begin();
+    }
+
+    /// returns an iterator to the end
+    iterator end() noexcept
+    {
+        return m_map.end();
+    }
+
+    /// returns an iterator to the beginning
+    const_iterator begin() const noexcept
+    {
+        return m_map.begin();
+    }
+
+    /// returns an iterator to the end
+    const_iterator end() const noexcept
+    {
+        return m_map.end();
+    }
+
+    /// returns an iterator to the beginning
+    const_iterator cbegin() const noexcept
+    {
+        return m_map.cbegin();
+    }
+
+    /// returns an iterator to the end
+    const_iterator cend() const noexcept
+    {
+        return m_map.cend();
+    }
+
+    /// returns a reverse iterator to the beginning
+    reverse_iterator rbegin() noexcept
+    {
+        return m_map.rbegin();
+    }
+
+    /// returns a reverse iterator to the end
+    reverse_iterator rend() noexcept
+    {
+        return m_map.rend();
+    }
+
+    /// returns a reverse iterator to the beginning
+    const_reverse_iterator rbegin() const noexcept
+    {
+        return m_map.rbegin();
+    }
+
+    /// returns a reverse iterator to the end
+    const_reverse_iterator rend() const noexcept
+    {
+        return m_map.rend();
+    }
+
+    /// returns a reverse iterator to the beginning
+    const_reverse_iterator crbegin() const noexcept
+    {
+        return m_map.crbegin();
+    }
+
+    /// returns a reverse iterator to the end
+    const_reverse_iterator crend() const noexcept
+    {
+        return m_map.crend();
+    }
+
+
+    /*
+     * Capacity
+     */
+
+    /// checks whether the container is empty
+    bool empty() const noexcept
+    {
+        return m_map.empty();
+    }
+
+    /// returns the number of elements
+    size_type size() const noexcept
+    {
+        return m_map.size();
+    }
+
+    /// returns the maximum possible number of elements
+    size_type max_size() const noexcept
+    {
+        return m_map.max_size();
+    }
+
+
+    /*
+     * Modifiers
+     */
+
+    /// clears the contents
+    void clear() noexcept
+    {
+        m_map.clear();
+        m_keys.clear();
+    }
+
+    /// insert value
+    std::pair<iterator, bool> insert(const value_type& value)
+    {
+        m_compare.add_key(value.first);
+        return m_map.insert(value);
+    }
+
+    /// insert value
+    template<class P>
+    std::pair<iterator, bool> insert( P&& value )
+    {
+        m_compare.add_key(value.first);
+        return m_map.insert(value);
+    }
+
+    /// insert value with hint
+    iterator insert(const_iterator hint, const value_type& value)
+    {
+        m_compare.add_key(value.first);
+        return m_map.insert(hint, value);
+    }
+
+    /// insert value with hint
+    iterator insert(const_iterator hint, value_type&& value)
+    {
+        m_compare.add_key(value.first);
+        return m_map.insert(hint, value);
+    }
+
+    /// insert value range
+    template<class InputIt>
+    void insert(InputIt first, InputIt last)
+    {
+        for (const_iterator it = first; it != last; ++it)
+        {
+            m_compare.add_key(it->first);
+        }
+
+        m_map.insert(first, last);
+    }
+
+    /// insert value list
+    void insert(std::initializer_list<value_type> ilist)
+    {
+        for (auto value : ilist)
+        {
+            m_compare.add_key(value.first);
+        }
+
+        m_map.insert(ilist);
+    }
+
+    /// constructs element in-place
+    template<class... Args>
+    std::pair<iterator, bool> emplace(Args&& ... args)
+    {
+        typename fifo_map::value_type value(std::forward<Args>(args)...);
+        m_compare.add_key(value.first);
+        return m_map.emplace(std::move(value));
+    }
+
+    /// constructs element in-place with hint
+    template<class... Args>
+    iterator emplace_hint(const_iterator hint, Args&& ... args)
+    {
+        typename fifo_map::value_type value(std::forward<Args>(args)...);
+        m_compare.add_key(value.first);
+        return m_map.emplace_hint(hint, std::move(value));
+    }
+
+    /// remove element at position
+    iterator erase(const_iterator pos)
+    {
+        m_compare.remove_key(pos->first);
+        return m_map.erase(pos);
+    }
+
+    /// remove elements in range
+    iterator erase(const_iterator first, const_iterator last)
+    {
+        for (const_iterator it = first; it != last; ++it)
+        {
+            m_compare.remove_key(it->first);
+        }
+
+        return m_map.erase(first, last);
+    }
+
+    /// remove elements with key
+    size_type erase(const key_type& key)
+    {
+        size_type res = m_map.erase(key);
+
+        if (res > 0)
+        {
+            m_compare.remove_key(key);
+        }
+
+        return res;
+    }
+
+    /// swaps the contents
+    void swap(fifo_map& other)
+    {
+        std::swap(m_map, other.m_map);
+        std::swap(m_compare, other.m_compare);
+        std::swap(m_keys, other.m_keys);
+    }
+
+
+    /*
+     * Lookup
+     */
+
+    /// returns the number of elements matching specific key
+    size_type count(const Key& key) const
+    {
+        return m_map.count(key);
+    }
+
+    /// finds element with specific key
+    iterator find(const Key& key)
+    {
+        return m_map.find(key);
+    }
+
+    /// finds element with specific key
+    const_iterator find(const Key& key) const
+    {
+        return m_map.find(key);
+    }
+
+    /// returns range of elements matching a specific key
+    std::pair<iterator, iterator> equal_range(const Key& key)
+    {
+        return m_map.equal_range(key);
+    }
+
+    /// returns range of elements matching a specific key
+    std::pair<const_iterator, const_iterator> equal_range(const Key& key) const
+    {
+        return m_map.equal_range(key);
+    }
+
+    /// returns an iterator to the first element not less than the given key
+    iterator lower_bound(const Key& key)
+    {
+        return m_map.lower_bound(key);
+    }
+
+    /// returns an iterator to the first element not less than the given key
+    const_iterator lower_bound(const Key& key) const
+    {
+        return m_map.lower_bound(key);
+    }
+
+    /// returns an iterator to the first element greater than the given key
+    iterator upper_bound(const Key& key)
+    {
+        return m_map.upper_bound(key);
+    }
+
+    /// returns an iterator to the first element greater than the given key
+    const_iterator upper_bound(const Key& key) const
+    {
+        return m_map.upper_bound(key);
+    }
+
+
+    /*
+     * Observers
+     */
+
+    /// returns the function that compares keys
+    key_compare key_comp() const
+    {
+        return m_compare;
+    }
+
+
+    /*
+     * Non-member functions
+     */
+
+    friend bool operator==(const fifo_map& lhs, const fifo_map& rhs)
+    {
+        return lhs.m_map == rhs.m_map;
+    }
+
+    friend bool operator!=(const fifo_map& lhs, const fifo_map& rhs)
+    {
+        return lhs.m_map != rhs.m_map;
+    }
+
+    friend bool operator<(const fifo_map& lhs, const fifo_map& rhs)
+    {
+        return lhs.m_map < rhs.m_map;
+    }
+
+    friend bool operator<=(const fifo_map& lhs, const fifo_map& rhs)
+    {
+        return lhs.m_map <= rhs.m_map;
+    }
+
+    friend bool operator>(const fifo_map& lhs, const fifo_map& rhs)
+    {
+        return lhs.m_map > rhs.m_map;
+    }
+
+    friend bool operator>=(const fifo_map& lhs, const fifo_map& rhs)
+    {
+        return lhs.m_map >= rhs.m_map;
+    }
+
+  private:
+    /// the keys
+    std::unordered_map<Key, std::size_t> m_keys;
+    /// the comparison object
+    Compare m_compare;
+    /// the internal data structure
+    internal_map_type m_map;
+};
+
+}
+
+// specialization of std::swap
+namespace std
+{
+template <class Key, class T, class Compare, class Allocator>
+inline void swap(nlohmann::fifo_map<Key, T, Compare, Allocator>& m1,
+                 nlohmann::fifo_map<Key, T, Compare, Allocator>& m2)
+{
+    m1.swap(m2);
+}
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/inc/nlohmann/json.hpp b/engine/inc/nlohmann/json.hpp
new file mode 100644
index 00000000..15e79496
--- /dev/null
+++ b/engine/inc/nlohmann/json.hpp
@@ -0,0 +1,25545 @@
+/*
+    __ _____ _____ _____
+ __|  |   __|     |   | |  JSON for Modern C++
+|  |  |__   |  |  | | | |  version 3.9.1
+|_____|_____|_____|_|___|  https://github.com/nlohmann/json
+
+Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+SPDX-License-Identifier: MIT
+Copyright (c) 2013-2019 Niels Lohmann <http://nlohmann.me>.
+
+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.
+*/
+
+#ifndef INCLUDE_NLOHMANN_JSON_HPP_
+#define INCLUDE_NLOHMANN_JSON_HPP_
+
+#define NLOHMANN_JSON_VERSION_MAJOR 3
+#define NLOHMANN_JSON_VERSION_MINOR 9
+#define NLOHMANN_JSON_VERSION_PATCH 1
+
+#include <algorithm> // all_of, find, for_each
+#include <cstddef> // nullptr_t, ptrdiff_t, size_t
+#include <functional> // hash, less
+#include <initializer_list> // initializer_list
+#include <iosfwd> // istream, ostream
+#include <iterator> // random_access_iterator_tag
+#include <memory> // unique_ptr
+#include <numeric> // accumulate
+#include <string> // string, stoi, to_string
+#include <utility> // declval, forward, move, pair, swap
+#include <vector> // vector
+
+// #include <nlohmann/adl_serializer.hpp>
+
+
+#include <utility>
+
+// #include <nlohmann/detail/conversions/from_json.hpp>
+
+
+#include <algorithm> // transform
+#include <array> // array
+#include <forward_list> // forward_list
+#include <iterator> // inserter, front_inserter, end
+#include <map> // map
+#include <string> // string
+#include <tuple> // tuple, make_tuple
+#include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
+#include <unordered_map> // unordered_map
+#include <utility> // pair, declval
+#include <valarray> // valarray
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+
+#include <exception> // exception
+#include <stdexcept> // runtime_error
+#include <string> // to_string
+
+// #include <nlohmann/detail/input/position_t.hpp>
+
+
+#include <cstddef> // size_t
+
+namespace nlohmann
+{
+namespace detail
+{
+/// struct to capture the start position of the current token
+struct position_t
+{
+    /// the total number of characters read
+    std::size_t chars_read_total = 0;
+    /// the number of characters read in the current line
+    std::size_t chars_read_current_line = 0;
+    /// the number of lines read
+    std::size_t lines_read = 0;
+
+    /// conversion to size_t to preserve SAX interface
+    constexpr operator size_t() const
+    {
+        return chars_read_total;
+    }
+};
+
+} // namespace detail
+} // namespace nlohmann
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+#include <utility> // pair
+// #include <nlohmann/thirdparty/hedley/hedley.hpp>
+/* Hedley - https://nemequ.github.io/hedley
+ * Created by Evan Nemerson <evan@nemerson.com>
+ *
+ * To the extent possible under law, the author(s) have dedicated all
+ * copyright and related and neighboring rights to this software to
+ * the public domain worldwide. This software is distributed without
+ * any warranty.
+ *
+ * For details, see <http://creativecommons.org/publicdomain/zero/1.0/>.
+ * SPDX-License-Identifier: CC0-1.0
+ */
+
+#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 14)
+#if defined(JSON_HEDLEY_VERSION)
+    #undef JSON_HEDLEY_VERSION
+#endif
+#define JSON_HEDLEY_VERSION 14
+
+#if defined(JSON_HEDLEY_STRINGIFY_EX)
+    #undef JSON_HEDLEY_STRINGIFY_EX
+#endif
+#define JSON_HEDLEY_STRINGIFY_EX(x) #x
+
+#if defined(JSON_HEDLEY_STRINGIFY)
+    #undef JSON_HEDLEY_STRINGIFY
+#endif
+#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)
+
+#if defined(JSON_HEDLEY_CONCAT_EX)
+    #undef JSON_HEDLEY_CONCAT_EX
+#endif
+#define JSON_HEDLEY_CONCAT_EX(a,b) a##b
+
+#if defined(JSON_HEDLEY_CONCAT)
+    #undef JSON_HEDLEY_CONCAT
+#endif
+#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)
+
+#if defined(JSON_HEDLEY_CONCAT3_EX)
+    #undef JSON_HEDLEY_CONCAT3_EX
+#endif
+#define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c
+
+#if defined(JSON_HEDLEY_CONCAT3)
+    #undef JSON_HEDLEY_CONCAT3
+#endif
+#define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c)
+
+#if defined(JSON_HEDLEY_VERSION_ENCODE)
+    #undef JSON_HEDLEY_VERSION_ENCODE
+#endif
+#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))
+
+#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)
+    #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
+#endif
+#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)
+
+#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)
+    #undef JSON_HEDLEY_VERSION_DECODE_MINOR
+#endif
+#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)
+
+#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)
+    #undef JSON_HEDLEY_VERSION_DECODE_REVISION
+#endif
+#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)
+
+#if defined(JSON_HEDLEY_GNUC_VERSION)
+    #undef JSON_HEDLEY_GNUC_VERSION
+#endif
+#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
+    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
+#elif defined(__GNUC__)
+    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)
+    #undef JSON_HEDLEY_GNUC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_GNUC_VERSION)
+    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_MSVC_VERSION)
+    #undef JSON_HEDLEY_MSVC_VERSION
+#endif
+#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL)
+    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)
+#elif defined(_MSC_FULL_VER) && !defined(__ICL)
+    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)
+#elif defined(_MSC_VER) && !defined(__ICL)
+    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)
+#endif
+
+#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)
+    #undef JSON_HEDLEY_MSVC_VERSION_CHECK
+#endif
+#if !defined(JSON_HEDLEY_MSVC_VERSION)
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)
+#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
+#elif defined(_MSC_VER) && (_MSC_VER >= 1200)
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
+#else
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_VERSION)
+    #undef JSON_HEDLEY_INTEL_VERSION
+#endif
+#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL)
+    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)
+#elif defined(__INTEL_COMPILER) && !defined(__ICL)
+    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)
+    #undef JSON_HEDLEY_INTEL_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_INTEL_VERSION)
+    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_CL_VERSION)
+    #undef JSON_HEDLEY_INTEL_CL_VERSION
+#endif
+#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL)
+    #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0)
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK)
+    #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_INTEL_CL_VERSION)
+    #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_PGI_VERSION)
+    #undef JSON_HEDLEY_PGI_VERSION
+#endif
+#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
+    #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
+#endif
+
+#if defined(JSON_HEDLEY_PGI_VERSION_CHECK)
+    #undef JSON_HEDLEY_PGI_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_PGI_VERSION)
+    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_SUNPRO_VERSION)
+    #undef JSON_HEDLEY_SUNPRO_VERSION
+#endif
+#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10)
+#elif defined(__SUNPRO_C)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)
+#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10)
+#elif defined(__SUNPRO_CC)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)
+#endif
+
+#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)
+    #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_SUNPRO_VERSION)
+    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
+    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
+#endif
+#if defined(__EMSCRIPTEN__)
+    #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)
+#endif
+
+#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)
+    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
+    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_ARM_VERSION)
+    #undef JSON_HEDLEY_ARM_VERSION
+#endif
+#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
+    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)
+#elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
+    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)
+#endif
+
+#if defined(JSON_HEDLEY_ARM_VERSION_CHECK)
+    #undef JSON_HEDLEY_ARM_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_ARM_VERSION)
+    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_IBM_VERSION)
+    #undef JSON_HEDLEY_IBM_VERSION
+#endif
+#if defined(__ibmxl__)
+    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)
+#elif defined(__xlC__) && defined(__xlC_ver__)
+    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)
+#elif defined(__xlC__)
+    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)
+#endif
+
+#if defined(JSON_HEDLEY_IBM_VERSION_CHECK)
+    #undef JSON_HEDLEY_IBM_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_IBM_VERSION)
+    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_VERSION)
+    #undef JSON_HEDLEY_TI_VERSION
+#endif
+#if \
+    defined(__TI_COMPILER_VERSION__) && \
+    ( \
+      defined(__TMS470__) || defined(__TI_ARM__) || \
+      defined(__MSP430__) || \
+      defined(__TMS320C2000__) \
+    )
+#if (__TI_COMPILER_VERSION__ >= 16000000)
+    #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+#endif
+
+#if defined(JSON_HEDLEY_TI_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_VERSION)
+    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL2000_VERSION)
+    #undef JSON_HEDLEY_TI_CL2000_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)
+    #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL2000_VERSION)
+    #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL430_VERSION)
+    #undef JSON_HEDLEY_TI_CL430_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__)
+    #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL430_VERSION)
+    #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
+    #undef JSON_HEDLEY_TI_ARMCL_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__))
+    #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
+    #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL6X_VERSION)
+    #undef JSON_HEDLEY_TI_CL6X_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__)
+    #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL6X_VERSION)
+    #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL7X_VERSION)
+    #undef JSON_HEDLEY_TI_CL7X_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__)
+    #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL7X_VERSION)
+    #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
+    #undef JSON_HEDLEY_TI_CLPRU_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__)
+    #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
+    #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_CRAY_VERSION)
+    #undef JSON_HEDLEY_CRAY_VERSION
+#endif
+#if defined(_CRAYC)
+    #if defined(_RELEASE_PATCHLEVEL)
+        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)
+    #else
+        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
+    #endif
+#endif
+
+#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)
+    #undef JSON_HEDLEY_CRAY_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_CRAY_VERSION)
+    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_IAR_VERSION)
+    #undef JSON_HEDLEY_IAR_VERSION
+#endif
+#if defined(__IAR_SYSTEMS_ICC__)
+    #if __VER__ > 1000
+        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))
+    #else
+        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(VER / 100, __VER__ % 100, 0)
+    #endif
+#endif
+
+#if defined(JSON_HEDLEY_IAR_VERSION_CHECK)
+    #undef JSON_HEDLEY_IAR_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_IAR_VERSION)
+    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TINYC_VERSION)
+    #undef JSON_HEDLEY_TINYC_VERSION
+#endif
+#if defined(__TINYC__)
+    #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
+#endif
+
+#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)
+    #undef JSON_HEDLEY_TINYC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TINYC_VERSION)
+    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_DMC_VERSION)
+    #undef JSON_HEDLEY_DMC_VERSION
+#endif
+#if defined(__DMC__)
+    #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)
+#endif
+
+#if defined(JSON_HEDLEY_DMC_VERSION_CHECK)
+    #undef JSON_HEDLEY_DMC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_DMC_VERSION)
+    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_COMPCERT_VERSION)
+    #undef JSON_HEDLEY_COMPCERT_VERSION
+#endif
+#if defined(__COMPCERT_VERSION__)
+    #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)
+#endif
+
+#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)
+    #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_COMPCERT_VERSION)
+    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_PELLES_VERSION)
+    #undef JSON_HEDLEY_PELLES_VERSION
+#endif
+#if defined(__POCC__)
+    #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
+#endif
+
+#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)
+    #undef JSON_HEDLEY_PELLES_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_PELLES_VERSION)
+    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_VERSION)
+    #undef JSON_HEDLEY_GCC_VERSION
+#endif
+#if \
+    defined(JSON_HEDLEY_GNUC_VERSION) && \
+    !defined(__clang__) && \
+    !defined(JSON_HEDLEY_INTEL_VERSION) && \
+    !defined(JSON_HEDLEY_PGI_VERSION) && \
+    !defined(JSON_HEDLEY_ARM_VERSION) && \
+    !defined(JSON_HEDLEY_TI_VERSION) && \
+    !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL430_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \
+    !defined(__COMPCERT__)
+    #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION
+#endif
+
+#if defined(JSON_HEDLEY_GCC_VERSION_CHECK)
+    #undef JSON_HEDLEY_GCC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_GCC_VERSION)
+    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_HAS_ATTRIBUTE
+#endif
+#if defined(__has_attribute)
+    #define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
+#else
+    #define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
+#endif
+#if defined(__has_attribute)
+    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) __has_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
+#endif
+#if defined(__has_attribute)
+    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) __has_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
+#endif
+#if \
+    defined(__has_cpp_attribute) && \
+    defined(__cplusplus) && \
+    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0))
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)
+#else
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)
+    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
+#endif
+#if !defined(__cplusplus) || !defined(__has_cpp_attribute)
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
+#elif \
+    !defined(JSON_HEDLEY_PGI_VERSION) && \
+    !defined(JSON_HEDLEY_IAR_VERSION) && \
+    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \
+    (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0))
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)
+#else
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
+#endif
+#if defined(__has_cpp_attribute) && defined(__cplusplus)
+    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
+#endif
+#if defined(__has_cpp_attribute) && defined(__cplusplus)
+    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_BUILTIN)
+    #undef JSON_HEDLEY_HAS_BUILTIN
+#endif
+#if defined(__has_builtin)
+    #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
+#else
+    #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)
+    #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
+#endif
+#if defined(__has_builtin)
+    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)
+    #undef JSON_HEDLEY_GCC_HAS_BUILTIN
+#endif
+#if defined(__has_builtin)
+    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
+#else
+    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_FEATURE)
+    #undef JSON_HEDLEY_HAS_FEATURE
+#endif
+#if defined(__has_feature)
+    #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
+#else
+    #define JSON_HEDLEY_HAS_FEATURE(feature) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)
+    #undef JSON_HEDLEY_GNUC_HAS_FEATURE
+#endif
+#if defined(__has_feature)
+    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_FEATURE)
+    #undef JSON_HEDLEY_GCC_HAS_FEATURE
+#endif
+#if defined(__has_feature)
+    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
+#else
+    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_EXTENSION)
+    #undef JSON_HEDLEY_HAS_EXTENSION
+#endif
+#if defined(__has_extension)
+    #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
+#else
+    #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)
+    #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
+#endif
+#if defined(__has_extension)
+    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)
+    #undef JSON_HEDLEY_GCC_HAS_EXTENSION
+#endif
+#if defined(__has_extension)
+    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
+#else
+    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
+#endif
+#if defined(__has_declspec_attribute)
+    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)
+#else
+    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
+#endif
+#if defined(__has_declspec_attribute)
+    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
+#endif
+#if defined(__has_declspec_attribute)
+    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_WARNING)
+    #undef JSON_HEDLEY_HAS_WARNING
+#endif
+#if defined(__has_warning)
+    #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)
+#else
+    #define JSON_HEDLEY_HAS_WARNING(warning) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_WARNING)
+    #undef JSON_HEDLEY_GNUC_HAS_WARNING
+#endif
+#if defined(__has_warning)
+    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_WARNING)
+    #undef JSON_HEDLEY_GCC_HAS_WARNING
+#endif
+#if defined(__has_warning)
+    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
+#else
+    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if \
+    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
+    defined(__clang__) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \
+    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \
+    (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))
+    #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+    #define JSON_HEDLEY_PRAGMA(value) __pragma(value)
+#else
+    #define JSON_HEDLEY_PRAGMA(value)
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)
+    #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
+#endif
+#if defined(JSON_HEDLEY_DIAGNOSTIC_POP)
+    #undef JSON_HEDLEY_DIAGNOSTIC_POP
+#endif
+#if defined(__clang__)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))
+    #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))
+#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop")
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH
+    #define JSON_HEDLEY_DIAGNOSTIC_POP
+#endif
+
+/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for
+   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
+#endif
+#if defined(__cplusplus)
+#  if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")
+#    if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions")
+#      if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions")
+#        define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
+    _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
+    _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \
+    xpr \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#      else
+#        define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
+    _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
+    xpr \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#      endif
+#    else
+#      define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
+    xpr \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#    endif
+#  endif
+#endif
+#if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
+#endif
+
+#if defined(JSON_HEDLEY_CONST_CAST)
+    #undef JSON_HEDLEY_CONST_CAST
+#endif
+#if defined(__cplusplus)
+#  define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
+#elif \
+  JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+#  define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \
+        JSON_HEDLEY_DIAGNOSTIC_PUSH \
+        JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \
+        ((T) (expr)); \
+        JSON_HEDLEY_DIAGNOSTIC_POP \
+    }))
+#else
+#  define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))
+#endif
+
+#if defined(JSON_HEDLEY_REINTERPRET_CAST)
+    #undef JSON_HEDLEY_REINTERPRET_CAST
+#endif
+#if defined(__cplusplus)
+    #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
+#else
+    #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr))
+#endif
+
+#if defined(JSON_HEDLEY_STATIC_CAST)
+    #undef JSON_HEDLEY_STATIC_CAST
+#endif
+#if defined(__cplusplus)
+    #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
+#else
+    #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))
+#endif
+
+#if defined(JSON_HEDLEY_CPP_CAST)
+    #undef JSON_HEDLEY_CPP_CAST
+#endif
+#if defined(__cplusplus)
+#  if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast")
+#    define JSON_HEDLEY_CPP_CAST(T, expr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \
+    ((T) (expr)) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#  elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0)
+#    define JSON_HEDLEY_CPP_CAST(T, expr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("diag_suppress=Pe137") \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#  else
+#    define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr))
+#  endif
+#else
+#  define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)")
+#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786))
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445")
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718")
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215")
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)")
+#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161))
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068))
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
+#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)")
+#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292))
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030))
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098")
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)")
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wcast-qual")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
+#endif
+
+#if defined(JSON_HEDLEY_DEPRECATED)
+    #undef JSON_HEDLEY_DEPRECATED
+#endif
+#if defined(JSON_HEDLEY_DEPRECATED_FOR)
+    #undef JSON_HEDLEY_DEPRECATED_FOR
+#endif
+#if \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since))
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement))
+#elif \
+    JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)
+    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))
+#elif defined(__cplusplus) && (__cplusplus >= 201402L)
+    #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]])
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]])
+#elif \
+    JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
+    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated)
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated")
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")
+#else
+    #define JSON_HEDLEY_DEPRECATED(since)
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
+#endif
+
+#if defined(JSON_HEDLEY_UNAVAILABLE)
+    #undef JSON_HEDLEY_UNAVAILABLE
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since)))
+#else
+    #define JSON_HEDLEY_UNAVAILABLE(available_since)
+#endif
+
+#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)
+    #undef JSON_HEDLEY_WARN_UNUSED_RESULT
+#endif
+#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG)
+    #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__))
+#elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])
+#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
+#elif defined(_Check_return_) /* SAL */
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_
+#else
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg)
+#endif
+
+#if defined(JSON_HEDLEY_SENTINEL)
+    #undef JSON_HEDLEY_SENTINEL
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0)
+    #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))
+#else
+    #define JSON_HEDLEY_SENTINEL(position)
+#endif
+
+#if defined(JSON_HEDLEY_NO_RETURN)
+    #undef JSON_HEDLEY_NO_RETURN
+#endif
+#if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_NO_RETURN __noreturn
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
+#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+    #define JSON_HEDLEY_NO_RETURN _Noreturn
+#elif defined(__cplusplus) && (__cplusplus >= 201103L)
+    #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])
+#elif \
+    JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
+    #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+    #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return")
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
+#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")
+#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
+    #define JSON_HEDLEY_NO_RETURN __attribute((noreturn))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
+    #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
+#else
+    #define JSON_HEDLEY_NO_RETURN
+#endif
+
+#if defined(JSON_HEDLEY_NO_ESCAPE)
+    #undef JSON_HEDLEY_NO_ESCAPE
+#endif
+#if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)
+    #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))
+#else
+    #define JSON_HEDLEY_NO_ESCAPE
+#endif
+
+#if defined(JSON_HEDLEY_UNREACHABLE)
+    #undef JSON_HEDLEY_UNREACHABLE
+#endif
+#if defined(JSON_HEDLEY_UNREACHABLE_RETURN)
+    #undef JSON_HEDLEY_UNREACHABLE_RETURN
+#endif
+#if defined(JSON_HEDLEY_ASSUME)
+    #undef JSON_HEDLEY_ASSUME
+#endif
+#if \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_ASSUME(expr) __assume(expr)
+#elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)
+    #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)
+#elif \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
+    #if defined(__cplusplus)
+        #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)
+    #else
+        #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
+    #endif
+#endif
+#if \
+    (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5)
+    #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()
+#elif defined(JSON_HEDLEY_ASSUME)
+    #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
+#endif
+#if !defined(JSON_HEDLEY_ASSUME)
+    #if defined(JSON_HEDLEY_UNREACHABLE)
+        #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1)))
+    #else
+        #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr)
+    #endif
+#endif
+#if defined(JSON_HEDLEY_UNREACHABLE)
+    #if  \
+        JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
+        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
+        #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value))
+    #else
+        #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
+    #endif
+#else
+    #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value)
+#endif
+#if !defined(JSON_HEDLEY_UNREACHABLE)
+    #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
+#endif
+
+JSON_HEDLEY_DIAGNOSTIC_PUSH
+#if JSON_HEDLEY_HAS_WARNING("-Wpedantic")
+    #pragma clang diagnostic ignored "-Wpedantic"
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
+    #pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
+#endif
+#if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0)
+    #if defined(__clang__)
+        #pragma clang diagnostic ignored "-Wvariadic-macros"
+    #elif defined(JSON_HEDLEY_GCC_VERSION)
+        #pragma GCC diagnostic ignored "-Wvariadic-macros"
+    #endif
+#endif
+#if defined(JSON_HEDLEY_NON_NULL)
+    #undef JSON_HEDLEY_NON_NULL
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
+    #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
+#else
+    #define JSON_HEDLEY_NON_NULL(...)
+#endif
+JSON_HEDLEY_DIAGNOSTIC_POP
+
+#if defined(JSON_HEDLEY_PRINTF_FORMAT)
+    #undef JSON_HEDLEY_PRINTF_FORMAT
+#endif
+#if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))
+#elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check)))
+#elif \
+    JSON_HEDLEY_HAS_ATTRIBUTE(format) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check))
+#else
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)
+#endif
+
+#if defined(JSON_HEDLEY_CONSTEXPR)
+    #undef JSON_HEDLEY_CONSTEXPR
+#endif
+#if defined(__cplusplus)
+    #if __cplusplus >= 201103L
+        #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
+    #endif
+#endif
+#if !defined(JSON_HEDLEY_CONSTEXPR)
+    #define JSON_HEDLEY_CONSTEXPR
+#endif
+
+#if defined(JSON_HEDLEY_PREDICT)
+    #undef JSON_HEDLEY_PREDICT
+#endif
+#if defined(JSON_HEDLEY_LIKELY)
+    #undef JSON_HEDLEY_LIKELY
+#endif
+#if defined(JSON_HEDLEY_UNLIKELY)
+    #undef JSON_HEDLEY_UNLIKELY
+#endif
+#if defined(JSON_HEDLEY_UNPREDICTABLE)
+    #undef JSON_HEDLEY_UNPREDICTABLE
+#endif
+#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
+    #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr))
+#endif
+#if \
+  (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0)
+#  define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability(  (expr), (value), (probability))
+#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability)   __builtin_expect_with_probability(!!(expr),    1   , (probability))
+#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability)  __builtin_expect_with_probability(!!(expr),    0   , (probability))
+#  define JSON_HEDLEY_LIKELY(expr)                      __builtin_expect                 (!!(expr),    1                  )
+#  define JSON_HEDLEY_UNLIKELY(expr)                    __builtin_expect                 (!!(expr),    0                  )
+#elif \
+  (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+  (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
+  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
+  JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
+  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
+  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
+  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+  JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \
+  JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0)
+#  define JSON_HEDLEY_PREDICT(expr, expected, probability) \
+    (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)))
+#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \
+    (__extension__ ({ \
+        double hedley_probability_ = (probability); \
+        ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \
+    }))
+#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \
+    (__extension__ ({ \
+        double hedley_probability_ = (probability); \
+        ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \
+    }))
+#  define JSON_HEDLEY_LIKELY(expr)   __builtin_expect(!!(expr), 1)
+#  define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
+#else
+#  define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))
+#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))
+#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))
+#  define JSON_HEDLEY_LIKELY(expr) (!!(expr))
+#  define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))
+#endif
+#if !defined(JSON_HEDLEY_UNPREDICTABLE)
+    #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)
+#endif
+
+#if defined(JSON_HEDLEY_MALLOC)
+    #undef JSON_HEDLEY_MALLOC
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
+    #define JSON_HEDLEY_MALLOC __attribute__((__malloc__))
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+    #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory")
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_MALLOC __declspec(restrict)
+#else
+    #define JSON_HEDLEY_MALLOC
+#endif
+
+#if defined(JSON_HEDLEY_PURE)
+    #undef JSON_HEDLEY_PURE
+#endif
+#if \
+  JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+  JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+#  define JSON_HEDLEY_PURE __attribute__((__pure__))
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+#  define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data")
+#elif defined(__cplusplus) && \
+    ( \
+      JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
+      JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \
+      JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \
+    )
+#  define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
+#else
+#  define JSON_HEDLEY_PURE
+#endif
+
+#if defined(JSON_HEDLEY_CONST)
+    #undef JSON_HEDLEY_CONST
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(const) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_CONST __attribute__((__const__))
+#elif \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+    #define JSON_HEDLEY_CONST _Pragma("no_side_effect")
+#else
+    #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE
+#endif
+
+#if defined(JSON_HEDLEY_RESTRICT)
+    #undef JSON_HEDLEY_RESTRICT
+#endif
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)
+    #define JSON_HEDLEY_RESTRICT restrict
+#elif \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
+    defined(__clang__)
+    #define JSON_HEDLEY_RESTRICT __restrict
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)
+    #define JSON_HEDLEY_RESTRICT _Restrict
+#else
+    #define JSON_HEDLEY_RESTRICT
+#endif
+
+#if defined(JSON_HEDLEY_INLINE)
+    #undef JSON_HEDLEY_INLINE
+#endif
+#if \
+    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
+    (defined(__cplusplus) && (__cplusplus >= 199711L))
+    #define JSON_HEDLEY_INLINE inline
+#elif \
+    defined(JSON_HEDLEY_GCC_VERSION) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)
+    #define JSON_HEDLEY_INLINE __inline__
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
+    #define JSON_HEDLEY_INLINE __inline
+#else
+    #define JSON_HEDLEY_INLINE
+#endif
+
+#if defined(JSON_HEDLEY_ALWAYS_INLINE)
+    #undef JSON_HEDLEY_ALWAYS_INLINE
+#endif
+#if \
+  JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
+#  define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE
+#elif \
+  JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
+  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+#  define JSON_HEDLEY_ALWAYS_INLINE __forceinline
+#elif defined(__cplusplus) && \
+    ( \
+      JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+      JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+      JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+      JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
+      JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+      JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \
+    )
+#  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+#  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")
+#else
+#  define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE
+#endif
+
+#if defined(JSON_HEDLEY_NEVER_INLINE)
+    #undef JSON_HEDLEY_NEVER_INLINE
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
+    #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0)
+    #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline")
+#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never")
+#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
+    #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
+    #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
+#else
+    #define JSON_HEDLEY_NEVER_INLINE
+#endif
+
+#if defined(JSON_HEDLEY_PRIVATE)
+    #undef JSON_HEDLEY_PRIVATE
+#endif
+#if defined(JSON_HEDLEY_PUBLIC)
+    #undef JSON_HEDLEY_PUBLIC
+#endif
+#if defined(JSON_HEDLEY_IMPORT)
+    #undef JSON_HEDLEY_IMPORT
+#endif
+#if defined(_WIN32) || defined(__CYGWIN__)
+#  define JSON_HEDLEY_PRIVATE
+#  define JSON_HEDLEY_PUBLIC   __declspec(dllexport)
+#  define JSON_HEDLEY_IMPORT   __declspec(dllimport)
+#else
+#  if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
+    ( \
+      defined(__TI_EABI__) && \
+      ( \
+        (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \
+      ) \
+    )
+#    define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
+#    define JSON_HEDLEY_PUBLIC  __attribute__((__visibility__("default")))
+#  else
+#    define JSON_HEDLEY_PRIVATE
+#    define JSON_HEDLEY_PUBLIC
+#  endif
+#  define JSON_HEDLEY_IMPORT    extern
+#endif
+
+#if defined(JSON_HEDLEY_NO_THROW)
+    #undef JSON_HEDLEY_NO_THROW
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
+    #define JSON_HEDLEY_NO_THROW __declspec(nothrow)
+#else
+    #define JSON_HEDLEY_NO_THROW
+#endif
+
+#if defined(JSON_HEDLEY_FALL_THROUGH)
+    #undef JSON_HEDLEY_FALL_THROUGH
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0)
+    #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
+#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough)
+    #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])
+#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)
+    #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])
+#elif defined(__fallthrough) /* SAL */
+    #define JSON_HEDLEY_FALL_THROUGH __fallthrough
+#else
+    #define JSON_HEDLEY_FALL_THROUGH
+#endif
+
+#if defined(JSON_HEDLEY_RETURNS_NON_NULL)
+    #undef JSON_HEDLEY_RETURNS_NON_NULL
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
+    #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))
+#elif defined(_Ret_notnull_) /* SAL */
+    #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_
+#else
+    #define JSON_HEDLEY_RETURNS_NON_NULL
+#endif
+
+#if defined(JSON_HEDLEY_ARRAY_PARAM)
+    #undef JSON_HEDLEY_ARRAY_PARAM
+#endif
+#if \
+    defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
+    !defined(__STDC_NO_VLA__) && \
+    !defined(__cplusplus) && \
+    !defined(JSON_HEDLEY_PGI_VERSION) && \
+    !defined(JSON_HEDLEY_TINYC_VERSION)
+    #define JSON_HEDLEY_ARRAY_PARAM(name) (name)
+#else
+    #define JSON_HEDLEY_ARRAY_PARAM(name)
+#endif
+
+#if defined(JSON_HEDLEY_IS_CONSTANT)
+    #undef JSON_HEDLEY_IS_CONSTANT
+#endif
+#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
+    #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
+#endif
+/* JSON_HEDLEY_IS_CONSTEXPR_ is for
+   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
+#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
+    #undef JSON_HEDLEY_IS_CONSTEXPR_
+#endif
+#if \
+    JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
+    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \
+    JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0)
+    #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
+#endif
+#if !defined(__cplusplus)
+#  if \
+       JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \
+       JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
+       JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+       JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
+       JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
+       JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
+       JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24)
+#if defined(__INTPTR_TYPE__)
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)
+#else
+    #include <stdint.h>
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)
+#endif
+#  elif \
+       ( \
+          defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \
+          !defined(JSON_HEDLEY_SUNPRO_VERSION) && \
+          !defined(JSON_HEDLEY_PGI_VERSION) && \
+          !defined(JSON_HEDLEY_IAR_VERSION)) || \
+       JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) || \
+       JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
+       JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \
+       JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
+       JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0)
+#if defined(__INTPTR_TYPE__)
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0)
+#else
+    #include <stdint.h>
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)
+#endif
+#  elif \
+       defined(JSON_HEDLEY_GCC_VERSION) || \
+       defined(JSON_HEDLEY_INTEL_VERSION) || \
+       defined(JSON_HEDLEY_TINYC_VERSION) || \
+       defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \
+       JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \
+       defined(JSON_HEDLEY_TI_CL2000_VERSION) || \
+       defined(JSON_HEDLEY_TI_CL6X_VERSION) || \
+       defined(JSON_HEDLEY_TI_CL7X_VERSION) || \
+       defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \
+       defined(__clang__)
+#    define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \
+        sizeof(void) != \
+        sizeof(*( \
+                  1 ? \
+                  ((void*) ((expr) * 0L) ) : \
+((struct { char v[sizeof(void) * 2]; } *) 1) \
+                ) \
+              ) \
+                                            )
+#  endif
+#endif
+#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
+    #if !defined(JSON_HEDLEY_IS_CONSTANT)
+        #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)
+    #endif
+    #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
+#else
+    #if !defined(JSON_HEDLEY_IS_CONSTANT)
+        #define JSON_HEDLEY_IS_CONSTANT(expr) (0)
+    #endif
+    #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
+#endif
+
+#if defined(JSON_HEDLEY_BEGIN_C_DECLS)
+    #undef JSON_HEDLEY_BEGIN_C_DECLS
+#endif
+#if defined(JSON_HEDLEY_END_C_DECLS)
+    #undef JSON_HEDLEY_END_C_DECLS
+#endif
+#if defined(JSON_HEDLEY_C_DECL)
+    #undef JSON_HEDLEY_C_DECL
+#endif
+#if defined(__cplusplus)
+    #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" {
+    #define JSON_HEDLEY_END_C_DECLS }
+    #define JSON_HEDLEY_C_DECL extern "C"
+#else
+    #define JSON_HEDLEY_BEGIN_C_DECLS
+    #define JSON_HEDLEY_END_C_DECLS
+    #define JSON_HEDLEY_C_DECL
+#endif
+
+#if defined(JSON_HEDLEY_STATIC_ASSERT)
+    #undef JSON_HEDLEY_STATIC_ASSERT
+#endif
+#if \
+  !defined(__cplusplus) && ( \
+      (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \
+      (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
+      JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \
+      JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+      defined(_Static_assert) \
+    )
+#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
+#elif \
+  (defined(__cplusplus) && (__cplusplus >= 201103L)) || \
+  JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \
+  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))
+#else
+#  define JSON_HEDLEY_STATIC_ASSERT(expr, message)
+#endif
+
+#if defined(JSON_HEDLEY_NULL)
+    #undef JSON_HEDLEY_NULL
+#endif
+#if defined(__cplusplus)
+    #if __cplusplus >= 201103L
+        #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
+    #elif defined(NULL)
+        #define JSON_HEDLEY_NULL NULL
+    #else
+        #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)
+    #endif
+#elif defined(NULL)
+    #define JSON_HEDLEY_NULL NULL
+#else
+    #define JSON_HEDLEY_NULL ((void*) 0)
+#endif
+
+#if defined(JSON_HEDLEY_MESSAGE)
+    #undef JSON_HEDLEY_MESSAGE
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
+#  define JSON_HEDLEY_MESSAGE(msg) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
+    JSON_HEDLEY_PRAGMA(message msg) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#elif \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)
+#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
+#else
+#  define JSON_HEDLEY_MESSAGE(msg)
+#endif
+
+#if defined(JSON_HEDLEY_WARNING)
+    #undef JSON_HEDLEY_WARNING
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
+#  define JSON_HEDLEY_WARNING(msg) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
+    JSON_HEDLEY_PRAGMA(clang warning msg) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#elif \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \
+  JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)
+#elif \
+  JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
+  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))
+#else
+#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
+#endif
+
+#if defined(JSON_HEDLEY_REQUIRE)
+    #undef JSON_HEDLEY_REQUIRE
+#endif
+#if defined(JSON_HEDLEY_REQUIRE_MSG)
+    #undef JSON_HEDLEY_REQUIRE_MSG
+#endif
+#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)
+#  if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat")
+#    define JSON_HEDLEY_REQUIRE(expr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
+    __attribute__((diagnose_if(!(expr), #expr, "error"))) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
+    __attribute__((diagnose_if(!(expr), msg, "error"))) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#  else
+#    define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error")))
+#    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error")))
+#  endif
+#else
+#  define JSON_HEDLEY_REQUIRE(expr)
+#  define JSON_HEDLEY_REQUIRE_MSG(expr,msg)
+#endif
+
+#if defined(JSON_HEDLEY_FLAGS)
+    #undef JSON_HEDLEY_FLAGS
+#endif
+#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum)
+    #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
+#else
+    #define JSON_HEDLEY_FLAGS
+#endif
+
+#if defined(JSON_HEDLEY_FLAGS_CAST)
+    #undef JSON_HEDLEY_FLAGS_CAST
+#endif
+#if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0)
+#  define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \
+        JSON_HEDLEY_DIAGNOSTIC_PUSH \
+        _Pragma("warning(disable:188)") \
+        ((T) (expr)); \
+        JSON_HEDLEY_DIAGNOSTIC_POP \
+    }))
+#else
+#  define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
+#endif
+
+#if defined(JSON_HEDLEY_EMPTY_BASES)
+    #undef JSON_HEDLEY_EMPTY_BASES
+#endif
+#if \
+    (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)
+#else
+    #define JSON_HEDLEY_EMPTY_BASES
+#endif
+
+/* Remaining macros are deprecated. */
+
+#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
+    #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
+#endif
+#if defined(__clang__)
+    #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)
+#else
+    #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
+    #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
+#endif
+#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
+    #undef JSON_HEDLEY_CLANG_HAS_FEATURE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
+    #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
+#endif
+#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
+    #undef JSON_HEDLEY_CLANG_HAS_WARNING
+#endif
+#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)
+
+#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */
+
+
+// This file contains all internal macro definitions
+// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them
+
+// exclude unsupported compilers
+#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)
+    #if defined(__clang__)
+        #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400
+            #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
+        #endif
+    #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))
+        #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800
+            #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
+        #endif
+    #endif
+#endif
+
+// C++ language standard detection
+#if (defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
+    #define JSON_HAS_CPP_20
+    #define JSON_HAS_CPP_17
+    #define JSON_HAS_CPP_14
+#elif (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
+    #define JSON_HAS_CPP_17
+    #define JSON_HAS_CPP_14
+#elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
+    #define JSON_HAS_CPP_14
+#endif
+
+// disable float-equal warnings on GCC/clang
+#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+
+// disable documentation warnings on clang
+#if defined(__clang__)
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wdocumentation"
+#endif
+
+// allow to disable exceptions
+#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
+    #define JSON_THROW(exception) throw exception
+    #define JSON_TRY try
+    #define JSON_CATCH(exception) catch(exception)
+    #define JSON_INTERNAL_CATCH(exception) catch(exception)
+#else
+    #include <cstdlib>
+    #define JSON_THROW(exception) std::abort()
+    #define JSON_TRY if(true)
+    #define JSON_CATCH(exception) if(false)
+    #define JSON_INTERNAL_CATCH(exception) if(false)
+#endif
+
+// override exception macros
+#if defined(JSON_THROW_USER)
+    #undef JSON_THROW
+    #define JSON_THROW JSON_THROW_USER
+#endif
+#if defined(JSON_TRY_USER)
+    #undef JSON_TRY
+    #define JSON_TRY JSON_TRY_USER
+#endif
+#if defined(JSON_CATCH_USER)
+    #undef JSON_CATCH
+    #define JSON_CATCH JSON_CATCH_USER
+    #undef JSON_INTERNAL_CATCH
+    #define JSON_INTERNAL_CATCH JSON_CATCH_USER
+#endif
+#if defined(JSON_INTERNAL_CATCH_USER)
+    #undef JSON_INTERNAL_CATCH
+    #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER
+#endif
+
+// allow to override assert
+#if !defined(JSON_ASSERT)
+    #include <cassert> // assert
+    #define JSON_ASSERT(x) assert(x)
+#endif
+
+// allow to access some private functions (needed by the test suite)
+#if defined(JSON_TESTS_PRIVATE)
+    #define JSON_PRIVATE_UNLESS_TESTED public
+    #define JSON_PROTECTED_UNLESS_TESTED public
+#else
+    #define JSON_PRIVATE_UNLESS_TESTED private
+    #define JSON_PROTECTED_UNLESS_TESTED protected
+#endif
+
+/*!
+@brief macro to briefly define a mapping between an enum and JSON
+@def NLOHMANN_JSON_SERIALIZE_ENUM
+@since version 3.4.0
+*/
+#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...)                                            \
+    template<typename BasicJsonType>                                                            \
+    inline void to_json(BasicJsonType& j, const ENUM_TYPE& e)                                   \
+    {                                                                                           \
+        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
+        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
+        auto it = std::find_if(std::begin(m), std::end(m),                                      \
+                               [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool  \
+        {                                                                                       \
+            return ej_pair.first == e;                                                          \
+        });                                                                                     \
+        j = ((it != std::end(m)) ? it : std::begin(m))->second;                                 \
+    }                                                                                           \
+    template<typename BasicJsonType>                                                            \
+    inline void from_json(const BasicJsonType& j, ENUM_TYPE& e)                                 \
+    {                                                                                           \
+        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
+        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
+        auto it = std::find_if(std::begin(m), std::end(m),                                      \
+                               [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
+        {                                                                                       \
+            return ej_pair.second == j;                                                         \
+        });                                                                                     \
+        e = ((it != std::end(m)) ? it : std::begin(m))->first;                                  \
+    }
+
+// Ugly macros to avoid uglier copy-paste when specializing basic_json. They
+// may be removed in the future once the class is split.
+
+#define NLOHMANN_BASIC_JSON_TPL_DECLARATION                                \
+    template<template<typename, typename, typename...> class ObjectType,   \
+             template<typename, typename...> class ArrayType,              \
+             class StringType, class BooleanType, class NumberIntegerType, \
+             class NumberUnsignedType, class NumberFloatType,              \
+             template<typename> class AllocatorType,                       \
+             template<typename, typename = void> class JSONSerializer,     \
+             class BinaryType>
+
+#define NLOHMANN_BASIC_JSON_TPL                                            \
+    basic_json<ObjectType, ArrayType, StringType, BooleanType,             \
+    NumberIntegerType, NumberUnsignedType, NumberFloatType,                \
+    AllocatorType, JSONSerializer, BinaryType>
+
+// Macros to simplify conversion from/to types
+
+#define NLOHMANN_JSON_EXPAND( x ) x
+#define NLOHMANN_JSON_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME
+#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \
+        NLOHMANN_JSON_PASTE64, \
+        NLOHMANN_JSON_PASTE63, \
+        NLOHMANN_JSON_PASTE62, \
+        NLOHMANN_JSON_PASTE61, \
+        NLOHMANN_JSON_PASTE60, \
+        NLOHMANN_JSON_PASTE59, \
+        NLOHMANN_JSON_PASTE58, \
+        NLOHMANN_JSON_PASTE57, \
+        NLOHMANN_JSON_PASTE56, \
+        NLOHMANN_JSON_PASTE55, \
+        NLOHMANN_JSON_PASTE54, \
+        NLOHMANN_JSON_PASTE53, \
+        NLOHMANN_JSON_PASTE52, \
+        NLOHMANN_JSON_PASTE51, \
+        NLOHMANN_JSON_PASTE50, \
+        NLOHMANN_JSON_PASTE49, \
+        NLOHMANN_JSON_PASTE48, \
+        NLOHMANN_JSON_PASTE47, \
+        NLOHMANN_JSON_PASTE46, \
+        NLOHMANN_JSON_PASTE45, \
+        NLOHMANN_JSON_PASTE44, \
+        NLOHMANN_JSON_PASTE43, \
+        NLOHMANN_JSON_PASTE42, \
+        NLOHMANN_JSON_PASTE41, \
+        NLOHMANN_JSON_PASTE40, \
+        NLOHMANN_JSON_PASTE39, \
+        NLOHMANN_JSON_PASTE38, \
+        NLOHMANN_JSON_PASTE37, \
+        NLOHMANN_JSON_PASTE36, \
+        NLOHMANN_JSON_PASTE35, \
+        NLOHMANN_JSON_PASTE34, \
+        NLOHMANN_JSON_PASTE33, \
+        NLOHMANN_JSON_PASTE32, \
+        NLOHMANN_JSON_PASTE31, \
+        NLOHMANN_JSON_PASTE30, \
+        NLOHMANN_JSON_PASTE29, \
+        NLOHMANN_JSON_PASTE28, \
+        NLOHMANN_JSON_PASTE27, \
+        NLOHMANN_JSON_PASTE26, \
+        NLOHMANN_JSON_PASTE25, \
+        NLOHMANN_JSON_PASTE24, \
+        NLOHMANN_JSON_PASTE23, \
+        NLOHMANN_JSON_PASTE22, \
+        NLOHMANN_JSON_PASTE21, \
+        NLOHMANN_JSON_PASTE20, \
+        NLOHMANN_JSON_PASTE19, \
+        NLOHMANN_JSON_PASTE18, \
+        NLOHMANN_JSON_PASTE17, \
+        NLOHMANN_JSON_PASTE16, \
+        NLOHMANN_JSON_PASTE15, \
+        NLOHMANN_JSON_PASTE14, \
+        NLOHMANN_JSON_PASTE13, \
+        NLOHMANN_JSON_PASTE12, \
+        NLOHMANN_JSON_PASTE11, \
+        NLOHMANN_JSON_PASTE10, \
+        NLOHMANN_JSON_PASTE9, \
+        NLOHMANN_JSON_PASTE8, \
+        NLOHMANN_JSON_PASTE7, \
+        NLOHMANN_JSON_PASTE6, \
+        NLOHMANN_JSON_PASTE5, \
+        NLOHMANN_JSON_PASTE4, \
+        NLOHMANN_JSON_PASTE3, \
+        NLOHMANN_JSON_PASTE2, \
+        NLOHMANN_JSON_PASTE1)(__VA_ARGS__))
+#define NLOHMANN_JSON_PASTE2(func, v1) func(v1)
+#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2)
+#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3)
+#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4)
+#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5)
+#define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6)
+#define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7)
+#define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8)
+#define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9)
+#define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10)
+#define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)
+#define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12)
+#define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13)
+#define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14)
+#define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15)
+#define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16)
+#define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17)
+#define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18)
+#define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19)
+#define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20)
+#define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21)
+#define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22)
+#define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23)
+#define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24)
+#define NLOHMANN_JSON_PASTE26(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25)
+#define NLOHMANN_JSON_PASTE27(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26)
+#define NLOHMANN_JSON_PASTE28(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27)
+#define NLOHMANN_JSON_PASTE29(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28)
+#define NLOHMANN_JSON_PASTE30(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29)
+#define NLOHMANN_JSON_PASTE31(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30)
+#define NLOHMANN_JSON_PASTE32(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31)
+#define NLOHMANN_JSON_PASTE33(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32)
+#define NLOHMANN_JSON_PASTE34(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33)
+#define NLOHMANN_JSON_PASTE35(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34)
+#define NLOHMANN_JSON_PASTE36(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35)
+#define NLOHMANN_JSON_PASTE37(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36)
+#define NLOHMANN_JSON_PASTE38(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37)
+#define NLOHMANN_JSON_PASTE39(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38)
+#define NLOHMANN_JSON_PASTE40(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39)
+#define NLOHMANN_JSON_PASTE41(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40)
+#define NLOHMANN_JSON_PASTE42(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41)
+#define NLOHMANN_JSON_PASTE43(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42)
+#define NLOHMANN_JSON_PASTE44(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43)
+#define NLOHMANN_JSON_PASTE45(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44)
+#define NLOHMANN_JSON_PASTE46(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45)
+#define NLOHMANN_JSON_PASTE47(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46)
+#define NLOHMANN_JSON_PASTE48(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47)
+#define NLOHMANN_JSON_PASTE49(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48)
+#define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49)
+#define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50)
+#define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51)
+#define NLOHMANN_JSON_PASTE53(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52)
+#define NLOHMANN_JSON_PASTE54(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53)
+#define NLOHMANN_JSON_PASTE55(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54)
+#define NLOHMANN_JSON_PASTE56(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55)
+#define NLOHMANN_JSON_PASTE57(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56)
+#define NLOHMANN_JSON_PASTE58(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57)
+#define NLOHMANN_JSON_PASTE59(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58)
+#define NLOHMANN_JSON_PASTE60(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59)
+#define NLOHMANN_JSON_PASTE61(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60)
+#define NLOHMANN_JSON_PASTE62(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61)
+#define NLOHMANN_JSON_PASTE63(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62)
+#define NLOHMANN_JSON_PASTE64(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63)
+
+#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1;
+#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1);
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_TYPE_INTRUSIVE
+@since version 3.9.0
+*/
+#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...)  \
+    friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE
+@since version 3.9.0
+*/
+#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...)  \
+    inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
+
+#ifndef JSON_USE_IMPLICIT_CONVERSIONS
+    #define JSON_USE_IMPLICIT_CONVERSIONS 1
+#endif
+
+#if JSON_USE_IMPLICIT_CONVERSIONS
+    #define JSON_EXPLICIT
+#else
+    #define JSON_EXPLICIT explicit
+#endif
+
+
+namespace nlohmann
+{
+namespace detail
+{
+////////////////
+// exceptions //
+////////////////
+
+/*!
+@brief general exception of the @ref basic_json class
+
+This class is an extension of `std::exception` objects with a member @a id for
+exception ids. It is used as the base class for all exceptions thrown by the
+@ref basic_json class. This class can hence be used as "wildcard" to catch
+exceptions.
+
+Subclasses:
+- @ref parse_error for exceptions indicating a parse error
+- @ref invalid_iterator for exceptions indicating errors with iterators
+- @ref type_error for exceptions indicating executing a member function with
+                  a wrong type
+- @ref out_of_range for exceptions indicating access out of the defined range
+- @ref other_error for exceptions indicating other library errors
+
+@internal
+@note To have nothrow-copy-constructible exceptions, we internally use
+      `std::runtime_error` which can cope with arbitrary-length error messages.
+      Intermediate strings are built with static functions and then passed to
+      the actual constructor.
+@endinternal
+
+@liveexample{The following code shows how arbitrary library exceptions can be
+caught.,exception}
+
+@since version 3.0.0
+*/
+class exception : public std::exception
+{
+  public:
+    /// returns the explanatory string
+    JSON_HEDLEY_RETURNS_NON_NULL
+    const char* what() const noexcept override
+    {
+        return m.what();
+    }
+
+    /// the id of the exception
+    const int id;
+
+  protected:
+    JSON_HEDLEY_NON_NULL(3)
+    exception(int id_, const char* what_arg) : id(id_), m(what_arg) {}
+
+    static std::string name(const std::string& ename, int id_)
+    {
+        return "[json.exception." + ename + "." + std::to_string(id_) + "] ";
+    }
+
+  private:
+    /// an exception object as storage for error messages
+    std::runtime_error m;
+};
+
+/*!
+@brief exception indicating a parse error
+
+This exception is thrown by the library when a parse error occurs. Parse errors
+can occur during the deserialization of JSON text, CBOR, MessagePack, as well
+as when using JSON Patch.
+
+Member @a byte holds the byte index of the last read character in the input
+file.
+
+Exceptions have ids 1xx.
+
+name / id                      | example message | description
+------------------------------ | --------------- | -------------------------
+json.exception.parse_error.101 | parse error at 2: unexpected end of input; expected string literal | This error indicates a syntax error while deserializing a JSON text. The error message describes that an unexpected token (character) was encountered, and the member @a byte indicates the error position.
+json.exception.parse_error.102 | parse error at 14: missing or wrong low surrogate | JSON uses the `\uxxxx` format to describe Unicode characters. Code points above above 0xFFFF are split into two `\uxxxx` entries ("surrogate pairs"). This error indicates that the surrogate pair is incomplete or contains an invalid code point.
+json.exception.parse_error.103 | parse error: code points above 0x10FFFF are invalid | Unicode supports code points up to 0x10FFFF. Code points above 0x10FFFF are invalid.
+json.exception.parse_error.104 | parse error: JSON patch must be an array of objects | [RFC 6902](https://tools.ietf.org/html/rfc6902) requires a JSON Patch document to be a JSON document that represents an array of objects.
+json.exception.parse_error.105 | parse error: operation must have string member 'op' | An operation of a JSON Patch document must contain exactly one "op" member, whose value indicates the operation to perform. Its value must be one of "add", "remove", "replace", "move", "copy", or "test"; other values are errors.
+json.exception.parse_error.106 | parse error: array index '01' must not begin with '0' | An array index in a JSON Pointer ([RFC 6901](https://tools.ietf.org/html/rfc6901)) may be `0` or any number without a leading `0`.
+json.exception.parse_error.107 | parse error: JSON pointer must be empty or begin with '/' - was: 'foo' | A JSON Pointer must be a Unicode string containing a sequence of zero or more reference tokens, each prefixed by a `/` character.
+json.exception.parse_error.108 | parse error: escape character '~' must be followed with '0' or '1' | In a JSON Pointer, only `~0` and `~1` are valid escape sequences.
+json.exception.parse_error.109 | parse error: array index 'one' is not a number | A JSON Pointer array index must be a number.
+json.exception.parse_error.110 | parse error at 1: cannot read 2 bytes from vector | When parsing CBOR or MessagePack, the byte vector ends before the complete value has been read.
+json.exception.parse_error.112 | parse error at 1: error reading CBOR; last byte: 0xF8 | Not all types of CBOR or MessagePack are supported. This exception occurs if an unsupported byte was read.
+json.exception.parse_error.113 | parse error at 2: expected a CBOR string; last byte: 0x98 | While parsing a map key, a value that is not a string has been read.
+json.exception.parse_error.114 | parse error: Unsupported BSON record type 0x0F | The parsing of the corresponding BSON record type is not implemented (yet).
+json.exception.parse_error.115 | parse error at byte 5: syntax error while parsing UBJSON high-precision number: invalid number text: 1A | A UBJSON high-precision number could not be parsed.
+
+@note For an input with n bytes, 1 is the index of the first character and n+1
+      is the index of the terminating null byte or the end of file. This also
+      holds true when reading a byte vector (CBOR or MessagePack).
+
+@liveexample{The following code shows how a `parse_error` exception can be
+caught.,parse_error}
+
+@sa - @ref exception for the base class of the library exceptions
+@sa - @ref invalid_iterator for exceptions indicating errors with iterators
+@sa - @ref type_error for exceptions indicating executing a member function with
+                    a wrong type
+@sa - @ref out_of_range for exceptions indicating access out of the defined range
+@sa - @ref other_error for exceptions indicating other library errors
+
+@since version 3.0.0
+*/
+class parse_error : public exception
+{
+  public:
+    /*!
+    @brief create a parse error exception
+    @param[in] id_       the id of the exception
+    @param[in] pos       the position where the error occurred (or with
+                         chars_read_total=0 if the position cannot be
+                         determined)
+    @param[in] what_arg  the explanatory string
+    @return parse_error object
+    */
+    static parse_error create(int id_, const position_t& pos, const std::string& what_arg)
+    {
+        std::string w = exception::name("parse_error", id_) + "parse error" +
+                        position_string(pos) + ": " + what_arg;
+        return parse_error(id_, pos.chars_read_total, w.c_str());
+    }
+
+    static parse_error create(int id_, std::size_t byte_, const std::string& what_arg)
+    {
+        std::string w = exception::name("parse_error", id_) + "parse error" +
+                        (byte_ != 0 ? (" at byte " + std::to_string(byte_)) : "") +
+                        ": " + what_arg;
+        return parse_error(id_, byte_, w.c_str());
+    }
+
+    /*!
+    @brief byte index of the parse error
+
+    The byte index of the last read character in the input file.
+
+    @note For an input with n bytes, 1 is the index of the first character and
+          n+1 is the index of the terminating null byte or the end of file.
+          This also holds true when reading a byte vector (CBOR or MessagePack).
+    */
+    const std::size_t byte;
+
+  private:
+    parse_error(int id_, std::size_t byte_, const char* what_arg)
+        : exception(id_, what_arg), byte(byte_) {}
+
+    static std::string position_string(const position_t& pos)
+    {
+        return " at line " + std::to_string(pos.lines_read + 1) +
+               ", column " + std::to_string(pos.chars_read_current_line);
+    }
+};
+
+/*!
+@brief exception indicating errors with iterators
+
+This exception is thrown if iterators passed to a library function do not match
+the expected semantics.
+
+Exceptions have ids 2xx.
+
+name / id                           | example message | description
+----------------------------------- | --------------- | -------------------------
+json.exception.invalid_iterator.201 | iterators are not compatible | The iterators passed to constructor @ref basic_json(InputIT first, InputIT last) are not compatible, meaning they do not belong to the same container. Therefore, the range (@a first, @a last) is invalid.
+json.exception.invalid_iterator.202 | iterator does not fit current value | In an erase or insert function, the passed iterator @a pos does not belong to the JSON value for which the function was called. It hence does not define a valid position for the deletion/insertion.
+json.exception.invalid_iterator.203 | iterators do not fit current value | Either iterator passed to function @ref erase(IteratorType first, IteratorType last) does not belong to the JSON value from which values shall be erased. It hence does not define a valid range to delete values from.
+json.exception.invalid_iterator.204 | iterators out of range | When an iterator range for a primitive type (number, boolean, or string) is passed to a constructor or an erase function, this range has to be exactly (@ref begin(), @ref end()), because this is the only way the single stored value is expressed. All other ranges are invalid.
+json.exception.invalid_iterator.205 | iterator out of range | When an iterator for a primitive type (number, boolean, or string) is passed to an erase function, the iterator has to be the @ref begin() iterator, because it is the only way to address the stored value. All other iterators are invalid.
+json.exception.invalid_iterator.206 | cannot construct with iterators from null | The iterators passed to constructor @ref basic_json(InputIT first, InputIT last) belong to a JSON null value and hence to not define a valid range.
+json.exception.invalid_iterator.207 | cannot use key() for non-object iterators | The key() member function can only be used on iterators belonging to a JSON object, because other types do not have a concept of a key.
+json.exception.invalid_iterator.208 | cannot use operator[] for object iterators | The operator[] to specify a concrete offset cannot be used on iterators belonging to a JSON object, because JSON objects are unordered.
+json.exception.invalid_iterator.209 | cannot use offsets with object iterators | The offset operators (+, -, +=, -=) cannot be used on iterators belonging to a JSON object, because JSON objects are unordered.
+json.exception.invalid_iterator.210 | iterators do not fit | The iterator range passed to the insert function are not compatible, meaning they do not belong to the same container. Therefore, the range (@a first, @a last) is invalid.
+json.exception.invalid_iterator.211 | passed iterators may not belong to container | The iterator range passed to the insert function must not be a subrange of the container to insert to.
+json.exception.invalid_iterator.212 | cannot compare iterators of different containers | When two iterators are compared, they must belong to the same container.
+json.exception.invalid_iterator.213 | cannot compare order of object iterators | The order of object iterators cannot be compared, because JSON objects are unordered.
+json.exception.invalid_iterator.214 | cannot get value | Cannot get value for iterator: Either the iterator belongs to a null value or it is an iterator to a primitive type (number, boolean, or string), but the iterator is different to @ref begin().
+
+@liveexample{The following code shows how an `invalid_iterator` exception can be
+caught.,invalid_iterator}
+
+@sa - @ref exception for the base class of the library exceptions
+@sa - @ref parse_error for exceptions indicating a parse error
+@sa - @ref type_error for exceptions indicating executing a member function with
+                    a wrong type
+@sa - @ref out_of_range for exceptions indicating access out of the defined range
+@sa - @ref other_error for exceptions indicating other library errors
+
+@since version 3.0.0
+*/
+class invalid_iterator : public exception
+{
+  public:
+    static invalid_iterator create(int id_, const std::string& what_arg)
+    {
+        std::string w = exception::name("invalid_iterator", id_) + what_arg;
+        return invalid_iterator(id_, w.c_str());
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    invalid_iterator(int id_, const char* what_arg)
+        : exception(id_, what_arg) {}
+};
+
+/*!
+@brief exception indicating executing a member function with a wrong type
+
+This exception is thrown in case of a type error; that is, a library function is
+executed on a JSON value whose type does not match the expected semantics.
+
+Exceptions have ids 3xx.
+
+name / id                     | example message | description
+----------------------------- | --------------- | -------------------------
+json.exception.type_error.301 | cannot create object from initializer list | To create an object from an initializer list, the initializer list must consist only of a list of pairs whose first element is a string. When this constraint is violated, an array is created instead.
+json.exception.type_error.302 | type must be object, but is array | During implicit or explicit value conversion, the JSON type must be compatible to the target type. For instance, a JSON string can only be converted into string types, but not into numbers or boolean types.
+json.exception.type_error.303 | incompatible ReferenceType for get_ref, actual type is object | To retrieve a reference to a value stored in a @ref basic_json object with @ref get_ref, the type of the reference must match the value type. For instance, for a JSON array, the @a ReferenceType must be @ref array_t &.
+json.exception.type_error.304 | cannot use at() with string | The @ref at() member functions can only be executed for certain JSON types.
+json.exception.type_error.305 | cannot use operator[] with string | The @ref operator[] member functions can only be executed for certain JSON types.
+json.exception.type_error.306 | cannot use value() with string | The @ref value() member functions can only be executed for certain JSON types.
+json.exception.type_error.307 | cannot use erase() with string | The @ref erase() member functions can only be executed for certain JSON types.
+json.exception.type_error.308 | cannot use push_back() with string | The @ref push_back() and @ref operator+= member functions can only be executed for certain JSON types.
+json.exception.type_error.309 | cannot use insert() with | The @ref insert() member functions can only be executed for certain JSON types.
+json.exception.type_error.310 | cannot use swap() with number | The @ref swap() member functions can only be executed for certain JSON types.
+json.exception.type_error.311 | cannot use emplace_back() with string | The @ref emplace_back() member function can only be executed for certain JSON types.
+json.exception.type_error.312 | cannot use update() with string | The @ref update() member functions can only be executed for certain JSON types.
+json.exception.type_error.313 | invalid value to unflatten | The @ref unflatten function converts an object whose keys are JSON Pointers back into an arbitrary nested JSON value. The JSON Pointers must not overlap, because then the resulting value would not be well defined.
+json.exception.type_error.314 | only objects can be unflattened | The @ref unflatten function only works for an object whose keys are JSON Pointers.
+json.exception.type_error.315 | values in object must be primitive | The @ref unflatten function only works for an object whose keys are JSON Pointers and whose values are primitive.
+json.exception.type_error.316 | invalid UTF-8 byte at index 10: 0x7E | The @ref dump function only works with UTF-8 encoded strings; that is, if you assign a `std::string` to a JSON value, make sure it is UTF-8 encoded. |
+json.exception.type_error.317 | JSON value cannot be serialized to requested format | The dynamic type of the object cannot be represented in the requested serialization format (e.g. a raw `true` or `null` JSON object cannot be serialized to BSON) |
+
+@liveexample{The following code shows how a `type_error` exception can be
+caught.,type_error}
+
+@sa - @ref exception for the base class of the library exceptions
+@sa - @ref parse_error for exceptions indicating a parse error
+@sa - @ref invalid_iterator for exceptions indicating errors with iterators
+@sa - @ref out_of_range for exceptions indicating access out of the defined range
+@sa - @ref other_error for exceptions indicating other library errors
+
+@since version 3.0.0
+*/
+class type_error : public exception
+{
+  public:
+    static type_error create(int id_, const std::string& what_arg)
+    {
+        std::string w = exception::name("type_error", id_) + what_arg;
+        return type_error(id_, w.c_str());
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    type_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
+};
+
+/*!
+@brief exception indicating access out of the defined range
+
+This exception is thrown in case a library function is called on an input
+parameter that exceeds the expected range, for instance in case of array
+indices or nonexisting object keys.
+
+Exceptions have ids 4xx.
+
+name / id                       | example message | description
+------------------------------- | --------------- | -------------------------
+json.exception.out_of_range.401 | array index 3 is out of range | The provided array index @a i is larger than @a size-1.
+json.exception.out_of_range.402 | array index '-' (3) is out of range | The special array index `-` in a JSON Pointer never describes a valid element of the array, but the index past the end. That is, it can only be used to add elements at this position, but not to read it.
+json.exception.out_of_range.403 | key 'foo' not found | The provided key was not found in the JSON object.
+json.exception.out_of_range.404 | unresolved reference token 'foo' | A reference token in a JSON Pointer could not be resolved.
+json.exception.out_of_range.405 | JSON pointer has no parent | The JSON Patch operations 'remove' and 'add' can not be applied to the root element of the JSON value.
+json.exception.out_of_range.406 | number overflow parsing '10E1000' | A parsed number could not be stored as without changing it to NaN or INF.
+json.exception.out_of_range.407 | number overflow serializing '9223372036854775808' | UBJSON and BSON only support integer numbers up to 9223372036854775807. (until version 3.8.0) |
+json.exception.out_of_range.408 | excessive array size: 8658170730974374167 | The size (following `#`) of an UBJSON array or object exceeds the maximal capacity. |
+json.exception.out_of_range.409 | BSON key cannot contain code point U+0000 (at byte 2) | Key identifiers to be serialized to BSON cannot contain code point U+0000, since the key is stored as zero-terminated c-string |
+
+@liveexample{The following code shows how an `out_of_range` exception can be
+caught.,out_of_range}
+
+@sa - @ref exception for the base class of the library exceptions
+@sa - @ref parse_error for exceptions indicating a parse error
+@sa - @ref invalid_iterator for exceptions indicating errors with iterators
+@sa - @ref type_error for exceptions indicating executing a member function with
+                    a wrong type
+@sa - @ref other_error for exceptions indicating other library errors
+
+@since version 3.0.0
+*/
+class out_of_range : public exception
+{
+  public:
+    static out_of_range create(int id_, const std::string& what_arg)
+    {
+        std::string w = exception::name("out_of_range", id_) + what_arg;
+        return out_of_range(id_, w.c_str());
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {}
+};
+
+/*!
+@brief exception indicating other library errors
+
+This exception is thrown in case of errors that cannot be classified with the
+other exception types.
+
+Exceptions have ids 5xx.
+
+name / id                      | example message | description
+------------------------------ | --------------- | -------------------------
+json.exception.other_error.501 | unsuccessful: {"op":"test","path":"/baz", "value":"bar"} | A JSON Patch operation 'test' failed. The unsuccessful operation is also printed.
+
+@sa - @ref exception for the base class of the library exceptions
+@sa - @ref parse_error for exceptions indicating a parse error
+@sa - @ref invalid_iterator for exceptions indicating errors with iterators
+@sa - @ref type_error for exceptions indicating executing a member function with
+                    a wrong type
+@sa - @ref out_of_range for exceptions indicating access out of the defined range
+
+@liveexample{The following code shows how an `other_error` exception can be
+caught.,other_error}
+
+@since version 3.0.0
+*/
+class other_error : public exception
+{
+  public:
+    static other_error create(int id_, const std::string& what_arg)
+    {
+        std::string w = exception::name("other_error", id_) + what_arg;
+        return other_error(id_, w.c_str());
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    other_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+
+#include <cstddef> // size_t
+#include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type
+
+namespace nlohmann
+{
+namespace detail
+{
+// alias templates to reduce boilerplate
+template<bool B, typename T = void>
+using enable_if_t = typename std::enable_if<B, T>::type;
+
+template<typename T>
+using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+
+// implementation of C++14 index_sequence and affiliates
+// source: https://stackoverflow.com/a/32223343
+template<std::size_t... Ints>
+struct index_sequence
+{
+    using type = index_sequence;
+    using value_type = std::size_t;
+    static constexpr std::size_t size() noexcept
+    {
+        return sizeof...(Ints);
+    }
+};
+
+template<class Sequence1, class Sequence2>
+struct merge_and_renumber;
+
+template<std::size_t... I1, std::size_t... I2>
+struct merge_and_renumber<index_sequence<I1...>, index_sequence<I2...>>
+        : index_sequence < I1..., (sizeof...(I1) + I2)... > {};
+
+template<std::size_t N>
+struct make_index_sequence
+    : merge_and_renumber < typename make_index_sequence < N / 2 >::type,
+      typename make_index_sequence < N - N / 2 >::type > {};
+
+template<> struct make_index_sequence<0> : index_sequence<> {};
+template<> struct make_index_sequence<1> : index_sequence<0> {};
+
+template<typename... Ts>
+using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
+
+// dispatch utility (taken from ranges-v3)
+template<unsigned N> struct priority_tag : priority_tag < N - 1 > {};
+template<> struct priority_tag<0> {};
+
+// taken from ranges-v3
+template<typename T>
+struct static_const
+{
+    static constexpr T value{};
+};
+
+template<typename T>
+constexpr T static_const<T>::value;
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+#include <limits> // numeric_limits
+#include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type
+#include <utility> // declval
+
+// #include <nlohmann/detail/iterators/iterator_traits.hpp>
+
+
+#include <iterator> // random_access_iterator_tag
+
+// #include <nlohmann/detail/meta/void_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+template<typename ...Ts> struct make_void
+{
+    using type = void;
+};
+template<typename ...Ts> using void_t = typename make_void<Ts...>::type;
+} // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+template<typename It, typename = void>
+struct iterator_types {};
+
+template<typename It>
+struct iterator_types <
+    It,
+    void_t<typename It::difference_type, typename It::value_type, typename It::pointer,
+    typename It::reference, typename It::iterator_category >>
+{
+    using difference_type = typename It::difference_type;
+    using value_type = typename It::value_type;
+    using pointer = typename It::pointer;
+    using reference = typename It::reference;
+    using iterator_category = typename It::iterator_category;
+};
+
+// This is required as some compilers implement std::iterator_traits in a way that
+// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341.
+template<typename T, typename = void>
+struct iterator_traits
+{
+};
+
+template<typename T>
+struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>
+            : iterator_types<T>
+{
+};
+
+template<typename T>
+struct iterator_traits<T*, enable_if_t<std::is_object<T>::value>>
+{
+    using iterator_category = std::random_access_iterator_tag;
+    using value_type = T;
+    using difference_type = ptrdiff_t;
+    using pointer = T*;
+    using reference = T&;
+};
+} // namespace detail
+} // namespace nlohmann
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/detected.hpp>
+
+
+#include <type_traits>
+
+// #include <nlohmann/detail/meta/void_t.hpp>
+
+
+// https://en.cppreference.com/w/cpp/experimental/is_detected
+namespace nlohmann
+{
+namespace detail
+{
+struct nonesuch
+{
+    nonesuch() = delete;
+    ~nonesuch() = delete;
+    nonesuch(nonesuch const&) = delete;
+    nonesuch(nonesuch const&&) = delete;
+    void operator=(nonesuch const&) = delete;
+    void operator=(nonesuch&&) = delete;
+};
+
+template<class Default,
+         class AlwaysVoid,
+         template<class...> class Op,
+         class... Args>
+struct detector
+{
+    using value_t = std::false_type;
+    using type = Default;
+};
+
+template<class Default, template<class...> class Op, class... Args>
+struct detector<Default, void_t<Op<Args...>>, Op, Args...>
+{
+    using value_t = std::true_type;
+    using type = Op<Args...>;
+};
+
+template<template<class...> class Op, class... Args>
+using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;
+
+template<template<class...> class Op, class... Args>
+using detected_t = typename detector<nonesuch, void, Op, Args...>::type;
+
+template<class Default, template<class...> class Op, class... Args>
+using detected_or = detector<Default, void, Op, Args...>;
+
+template<class Default, template<class...> class Op, class... Args>
+using detected_or_t = typename detected_or<Default, Op, Args...>::type;
+
+template<class Expected, template<class...> class Op, class... Args>
+using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
+
+template<class To, template<class...> class Op, class... Args>
+using is_detected_convertible =
+    std::is_convertible<detected_t<Op, Args...>, To>;
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/json_fwd.hpp>
+#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
+#define INCLUDE_NLOHMANN_JSON_FWD_HPP_
+
+#include <cstdint> // int64_t, uint64_t
+#include <map> // map
+#include <memory> // allocator
+#include <string> // string
+#include <vector> // vector
+
+/*!
+@brief namespace for Niels Lohmann
+@see https://github.com/nlohmann
+@since version 1.0.0
+*/
+namespace nlohmann
+{
+/*!
+@brief default JSONSerializer template argument
+
+This serializer ignores the template arguments and uses ADL
+([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl))
+for serialization.
+*/
+template<typename T = void, typename SFINAE = void>
+struct adl_serializer;
+
+template<template<typename U, typename V, typename... Args> class ObjectType =
+         std::map,
+         template<typename U, typename... Args> class ArrayType = std::vector,
+         class StringType = std::string, class BooleanType = bool,
+         class NumberIntegerType = std::int64_t,
+         class NumberUnsignedType = std::uint64_t,
+         class NumberFloatType = double,
+         template<typename U> class AllocatorType = std::allocator,
+         template<typename T, typename SFINAE = void> class JSONSerializer =
+         adl_serializer,
+         class BinaryType = std::vector<std::uint8_t>>
+class basic_json;
+
+/*!
+@brief JSON Pointer
+
+A JSON pointer defines a string syntax for identifying a specific value
+within a JSON document. It can be used with functions `at` and
+`operator[]`. Furthermore, JSON pointers are the base for JSON patches.
+
+@sa [RFC 6901](https://tools.ietf.org/html/rfc6901)
+
+@since version 2.0.0
+*/
+template<typename BasicJsonType>
+class json_pointer;
+
+/*!
+@brief default JSON class
+
+This type is the default specialization of the @ref basic_json class which
+uses the standard template types.
+
+@since version 1.0.0
+*/
+using json = basic_json<>;
+
+template<class Key, class T, class IgnoredLess, class Allocator>
+struct ordered_map;
+
+/*!
+@brief ordered JSON class
+
+This type preserves the insertion order of object keys.
+
+@since version 3.9.0
+*/
+using ordered_json = basic_json<nlohmann::ordered_map>;
+
+}  // namespace nlohmann
+
+#endif  // INCLUDE_NLOHMANN_JSON_FWD_HPP_
+
+
+namespace nlohmann
+{
+/*!
+@brief detail namespace with internal helper functions
+
+This namespace collects functions that should not be exposed,
+implementations of some @ref basic_json methods, and meta-programming helpers.
+
+@since version 2.1.0
+*/
+namespace detail
+{
+/////////////
+// helpers //
+/////////////
+
+// Note to maintainers:
+//
+// Every trait in this file expects a non CV-qualified type.
+// The only exceptions are in the 'aliases for detected' section
+// (i.e. those of the form: decltype(T::member_function(std::declval<T>())))
+//
+// In this case, T has to be properly CV-qualified to constraint the function arguments
+// (e.g. to_json(BasicJsonType&, const T&))
+
+template<typename> struct is_basic_json : std::false_type {};
+
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
+
+//////////////////////
+// json_ref helpers //
+//////////////////////
+
+template<typename>
+class json_ref;
+
+template<typename>
+struct is_json_ref : std::false_type {};
+
+template<typename T>
+struct is_json_ref<json_ref<T>> : std::true_type {};
+
+//////////////////////////
+// aliases for detected //
+//////////////////////////
+
+template<typename T>
+using mapped_type_t = typename T::mapped_type;
+
+template<typename T>
+using key_type_t = typename T::key_type;
+
+template<typename T>
+using value_type_t = typename T::value_type;
+
+template<typename T>
+using difference_type_t = typename T::difference_type;
+
+template<typename T>
+using pointer_t = typename T::pointer;
+
+template<typename T>
+using reference_t = typename T::reference;
+
+template<typename T>
+using iterator_category_t = typename T::iterator_category;
+
+template<typename T>
+using iterator_t = typename T::iterator;
+
+template<typename T, typename... Args>
+using to_json_function = decltype(T::to_json(std::declval<Args>()...));
+
+template<typename T, typename... Args>
+using from_json_function = decltype(T::from_json(std::declval<Args>()...));
+
+template<typename T, typename U>
+using get_template_function = decltype(std::declval<T>().template get<U>());
+
+// trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists
+template<typename BasicJsonType, typename T, typename = void>
+struct has_from_json : std::false_type {};
+
+// trait checking if j.get<T> is valid
+// use this trait instead of std::is_constructible or std::is_convertible,
+// both rely on, or make use of implicit conversions, and thus fail when T
+// has several constructors/operator= (see https://github.com/nlohmann/json/issues/958)
+template <typename BasicJsonType, typename T>
+struct is_getable
+{
+    static constexpr bool value = is_detected<get_template_function, const BasicJsonType&, T>::value;
+};
+
+template<typename BasicJsonType, typename T>
+struct has_from_json < BasicJsonType, T,
+           enable_if_t < !is_basic_json<T>::value >>
+{
+    using serializer = typename BasicJsonType::template json_serializer<T, void>;
+
+    static constexpr bool value =
+        is_detected_exact<void, from_json_function, serializer,
+        const BasicJsonType&, T&>::value;
+};
+
+// This trait checks if JSONSerializer<T>::from_json(json const&) exists
+// this overload is used for non-default-constructible user-defined-types
+template<typename BasicJsonType, typename T, typename = void>
+struct has_non_default_from_json : std::false_type {};
+
+template<typename BasicJsonType, typename T>
+struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
+{
+    using serializer = typename BasicJsonType::template json_serializer<T, void>;
+
+    static constexpr bool value =
+        is_detected_exact<T, from_json_function, serializer,
+        const BasicJsonType&>::value;
+};
+
+// This trait checks if BasicJsonType::json_serializer<T>::to_json exists
+// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion.
+template<typename BasicJsonType, typename T, typename = void>
+struct has_to_json : std::false_type {};
+
+template<typename BasicJsonType, typename T>
+struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
+{
+    using serializer = typename BasicJsonType::template json_serializer<T, void>;
+
+    static constexpr bool value =
+        is_detected_exact<void, to_json_function, serializer, BasicJsonType&,
+        T>::value;
+};
+
+
+///////////////////
+// is_ functions //
+///////////////////
+
+template<typename T, typename = void>
+struct is_iterator_traits : std::false_type {};
+
+template<typename T>
+struct is_iterator_traits<iterator_traits<T>>
+{
+  private:
+    using traits = iterator_traits<T>;
+
+  public:
+    static constexpr auto value =
+        is_detected<value_type_t, traits>::value &&
+        is_detected<difference_type_t, traits>::value &&
+        is_detected<pointer_t, traits>::value &&
+        is_detected<iterator_category_t, traits>::value &&
+        is_detected<reference_t, traits>::value;
+};
+
+// source: https://stackoverflow.com/a/37193089/4116453
+
+template<typename T, typename = void>
+struct is_complete_type : std::false_type {};
+
+template<typename T>
+struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
+
+template<typename BasicJsonType, typename CompatibleObjectType,
+         typename = void>
+struct is_compatible_object_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename CompatibleObjectType>
+struct is_compatible_object_type_impl <
+    BasicJsonType, CompatibleObjectType,
+    enable_if_t < is_detected<mapped_type_t, CompatibleObjectType>::value&&
+    is_detected<key_type_t, CompatibleObjectType>::value >>
+{
+
+    using object_t = typename BasicJsonType::object_t;
+
+    // macOS's is_constructible does not play well with nonesuch...
+    static constexpr bool value =
+        std::is_constructible<typename object_t::key_type,
+        typename CompatibleObjectType::key_type>::value &&
+        std::is_constructible<typename object_t::mapped_type,
+        typename CompatibleObjectType::mapped_type>::value;
+};
+
+template<typename BasicJsonType, typename CompatibleObjectType>
+struct is_compatible_object_type
+    : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
+
+template<typename BasicJsonType, typename ConstructibleObjectType,
+         typename = void>
+struct is_constructible_object_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename ConstructibleObjectType>
+struct is_constructible_object_type_impl <
+    BasicJsonType, ConstructibleObjectType,
+    enable_if_t < is_detected<mapped_type_t, ConstructibleObjectType>::value&&
+    is_detected<key_type_t, ConstructibleObjectType>::value >>
+{
+    using object_t = typename BasicJsonType::object_t;
+
+    static constexpr bool value =
+        (std::is_default_constructible<ConstructibleObjectType>::value &&
+         (std::is_move_assignable<ConstructibleObjectType>::value ||
+          std::is_copy_assignable<ConstructibleObjectType>::value) &&
+         (std::is_constructible<typename ConstructibleObjectType::key_type,
+          typename object_t::key_type>::value &&
+          std::is_same <
+          typename object_t::mapped_type,
+          typename ConstructibleObjectType::mapped_type >::value)) ||
+        (has_from_json<BasicJsonType,
+         typename ConstructibleObjectType::mapped_type>::value ||
+         has_non_default_from_json <
+         BasicJsonType,
+         typename ConstructibleObjectType::mapped_type >::value);
+};
+
+template<typename BasicJsonType, typename ConstructibleObjectType>
+struct is_constructible_object_type
+    : is_constructible_object_type_impl<BasicJsonType,
+      ConstructibleObjectType> {};
+
+template<typename BasicJsonType, typename CompatibleStringType,
+         typename = void>
+struct is_compatible_string_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename CompatibleStringType>
+struct is_compatible_string_type_impl <
+    BasicJsonType, CompatibleStringType,
+    enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type,
+    value_type_t, CompatibleStringType>::value >>
+{
+    static constexpr auto value =
+        std::is_constructible<typename BasicJsonType::string_t, CompatibleStringType>::value;
+};
+
+template<typename BasicJsonType, typename ConstructibleStringType>
+struct is_compatible_string_type
+    : is_compatible_string_type_impl<BasicJsonType, ConstructibleStringType> {};
+
+template<typename BasicJsonType, typename ConstructibleStringType,
+         typename = void>
+struct is_constructible_string_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename ConstructibleStringType>
+struct is_constructible_string_type_impl <
+    BasicJsonType, ConstructibleStringType,
+    enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type,
+    value_type_t, ConstructibleStringType>::value >>
+{
+    static constexpr auto value =
+        std::is_constructible<ConstructibleStringType,
+        typename BasicJsonType::string_t>::value;
+};
+
+template<typename BasicJsonType, typename ConstructibleStringType>
+struct is_constructible_string_type
+    : is_constructible_string_type_impl<BasicJsonType, ConstructibleStringType> {};
+
+template<typename BasicJsonType, typename CompatibleArrayType, typename = void>
+struct is_compatible_array_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename CompatibleArrayType>
+struct is_compatible_array_type_impl <
+    BasicJsonType, CompatibleArrayType,
+    enable_if_t < is_detected<value_type_t, CompatibleArrayType>::value&&
+    is_detected<iterator_t, CompatibleArrayType>::value&&
+// This is needed because json_reverse_iterator has a ::iterator type...
+// Therefore it is detected as a CompatibleArrayType.
+// The real fix would be to have an Iterable concept.
+    !is_iterator_traits <
+    iterator_traits<CompatibleArrayType >>::value >>
+{
+    static constexpr bool value =
+        std::is_constructible<BasicJsonType,
+        typename CompatibleArrayType::value_type>::value;
+};
+
+template<typename BasicJsonType, typename CompatibleArrayType>
+struct is_compatible_array_type
+    : is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {};
+
+template<typename BasicJsonType, typename ConstructibleArrayType, typename = void>
+struct is_constructible_array_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename ConstructibleArrayType>
+struct is_constructible_array_type_impl <
+    BasicJsonType, ConstructibleArrayType,
+    enable_if_t<std::is_same<ConstructibleArrayType,
+    typename BasicJsonType::value_type>::value >>
+            : std::true_type {};
+
+template<typename BasicJsonType, typename ConstructibleArrayType>
+struct is_constructible_array_type_impl <
+    BasicJsonType, ConstructibleArrayType,
+    enable_if_t < !std::is_same<ConstructibleArrayType,
+    typename BasicJsonType::value_type>::value&&
+    std::is_default_constructible<ConstructibleArrayType>::value&&
+(std::is_move_assignable<ConstructibleArrayType>::value ||
+ std::is_copy_assignable<ConstructibleArrayType>::value)&&
+is_detected<value_type_t, ConstructibleArrayType>::value&&
+is_detected<iterator_t, ConstructibleArrayType>::value&&
+is_complete_type <
+detected_t<value_type_t, ConstructibleArrayType >>::value >>
+{
+    static constexpr bool value =
+        // This is needed because json_reverse_iterator has a ::iterator type,
+        // furthermore, std::back_insert_iterator (and other iterators) have a
+        // base class `iterator`... Therefore it is detected as a
+        // ConstructibleArrayType. The real fix would be to have an Iterable
+        // concept.
+        !is_iterator_traits<iterator_traits<ConstructibleArrayType>>::value &&
+
+        (std::is_same<typename ConstructibleArrayType::value_type,
+         typename BasicJsonType::array_t::value_type>::value ||
+         has_from_json<BasicJsonType,
+         typename ConstructibleArrayType::value_type>::value ||
+         has_non_default_from_json <
+         BasicJsonType, typename ConstructibleArrayType::value_type >::value);
+};
+
+template<typename BasicJsonType, typename ConstructibleArrayType>
+struct is_constructible_array_type
+    : is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {};
+
+template<typename RealIntegerType, typename CompatibleNumberIntegerType,
+         typename = void>
+struct is_compatible_integer_type_impl : std::false_type {};
+
+template<typename RealIntegerType, typename CompatibleNumberIntegerType>
+struct is_compatible_integer_type_impl <
+    RealIntegerType, CompatibleNumberIntegerType,
+    enable_if_t < std::is_integral<RealIntegerType>::value&&
+    std::is_integral<CompatibleNumberIntegerType>::value&&
+    !std::is_same<bool, CompatibleNumberIntegerType>::value >>
+{
+    // is there an assert somewhere on overflows?
+    using RealLimits = std::numeric_limits<RealIntegerType>;
+    using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
+
+    static constexpr auto value =
+        std::is_constructible<RealIntegerType,
+        CompatibleNumberIntegerType>::value &&
+        CompatibleLimits::is_integer &&
+        RealLimits::is_signed == CompatibleLimits::is_signed;
+};
+
+template<typename RealIntegerType, typename CompatibleNumberIntegerType>
+struct is_compatible_integer_type
+    : is_compatible_integer_type_impl<RealIntegerType,
+      CompatibleNumberIntegerType> {};
+
+template<typename BasicJsonType, typename CompatibleType, typename = void>
+struct is_compatible_type_impl: std::false_type {};
+
+template<typename BasicJsonType, typename CompatibleType>
+struct is_compatible_type_impl <
+    BasicJsonType, CompatibleType,
+    enable_if_t<is_complete_type<CompatibleType>::value >>
+{
+    static constexpr bool value =
+        has_to_json<BasicJsonType, CompatibleType>::value;
+};
+
+template<typename BasicJsonType, typename CompatibleType>
+struct is_compatible_type
+    : is_compatible_type_impl<BasicJsonType, CompatibleType> {};
+
+// https://en.cppreference.com/w/cpp/types/conjunction
+template<class...> struct conjunction : std::true_type { };
+template<class B1> struct conjunction<B1> : B1 { };
+template<class B1, class... Bn>
+struct conjunction<B1, Bn...>
+: std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
+
+template<typename T1, typename T2>
+struct is_constructible_tuple : std::false_type {};
+
+template<typename T1, typename... Args>
+struct is_constructible_tuple<T1, std::tuple<Args...>> : conjunction<std::is_constructible<T1, Args>...> {};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+#include <array> // array
+#include <cstddef> // size_t
+#include <cstdint> // uint8_t
+#include <string> // string
+
+namespace nlohmann
+{
+namespace detail
+{
+///////////////////////////
+// JSON type enumeration //
+///////////////////////////
+
+/*!
+@brief the JSON type enumeration
+
+This enumeration collects the different JSON types. It is internally used to
+distinguish the stored values, and the functions @ref basic_json::is_null(),
+@ref basic_json::is_object(), @ref basic_json::is_array(),
+@ref basic_json::is_string(), @ref basic_json::is_boolean(),
+@ref basic_json::is_number() (with @ref basic_json::is_number_integer(),
+@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()),
+@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and
+@ref basic_json::is_structured() rely on it.
+
+@note There are three enumeration entries (number_integer, number_unsigned, and
+number_float), because the library distinguishes these three types for numbers:
+@ref basic_json::number_unsigned_t is used for unsigned integers,
+@ref basic_json::number_integer_t is used for signed integers, and
+@ref basic_json::number_float_t is used for floating-point numbers or to
+approximate integers which do not fit in the limits of their respective type.
+
+@sa @ref basic_json::basic_json(const value_t value_type) -- create a JSON
+value with the default value for a given type
+
+@since version 1.0.0
+*/
+enum class value_t : std::uint8_t
+{
+    null,             ///< null value
+    object,           ///< object (unordered set of name/value pairs)
+    array,            ///< array (ordered collection of values)
+    string,           ///< string value
+    boolean,          ///< boolean value
+    number_integer,   ///< number value (signed integer)
+    number_unsigned,  ///< number value (unsigned integer)
+    number_float,     ///< number value (floating-point)
+    binary,           ///< binary array (ordered collection of bytes)
+    discarded         ///< discarded by the parser callback function
+};
+
+/*!
+@brief comparison operator for JSON types
+
+Returns an ordering that is similar to Python:
+- order: null < boolean < number < object < array < string < binary
+- furthermore, each type is not smaller than itself
+- discarded values are not comparable
+- binary is represented as a b"" string in python and directly comparable to a
+  string; however, making a binary array directly comparable with a string would
+  be surprising behavior in a JSON file.
+
+@since version 1.0.0
+*/
+inline bool operator<(const value_t lhs, const value_t rhs) noexcept
+{
+    static constexpr std::array<std::uint8_t, 9> order = {{
+            0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,
+            1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */,
+            6 /* binary */
+        }
+    };
+
+    const auto l_index = static_cast<std::size_t>(lhs);
+    const auto r_index = static_cast<std::size_t>(rhs);
+    return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index];
+}
+}  // namespace detail
+}  // namespace nlohmann
+
+
+namespace nlohmann
+{
+namespace detail
+{
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_null()))
+    {
+        JSON_THROW(type_error::create(302, "type must be null, but is " + std::string(j.type_name())));
+    }
+    n = nullptr;
+}
+
+// overloads for basic_json template parameters
+template < typename BasicJsonType, typename ArithmeticType,
+           enable_if_t < std::is_arithmetic<ArithmeticType>::value&&
+                         !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
+                         int > = 0 >
+void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
+{
+    switch (static_cast<value_t>(j))
+    {
+        case value_t::number_unsigned:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
+            break;
+        }
+        case value_t::number_integer:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
+            break;
+        }
+        case value_t::number_float:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
+            break;
+        }
+
+        default:
+            JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));
+    }
+}
+
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
+    {
+        JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(j.type_name())));
+    }
+    b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
+}
+
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
+    {
+        JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
+    }
+    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
+}
+
+template <
+    typename BasicJsonType, typename ConstructibleStringType,
+    enable_if_t <
+        is_constructible_string_type<BasicJsonType, ConstructibleStringType>::value&&
+        !std::is_same<typename BasicJsonType::string_t,
+                      ConstructibleStringType>::value,
+        int > = 0 >
+void from_json(const BasicJsonType& j, ConstructibleStringType& s)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
+    {
+        JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
+    }
+
+    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
+}
+
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)
+{
+    get_arithmetic_value(j, val);
+}
+
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)
+{
+    get_arithmetic_value(j, val);
+}
+
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)
+{
+    get_arithmetic_value(j, val);
+}
+
+template<typename BasicJsonType, typename EnumType,
+         enable_if_t<std::is_enum<EnumType>::value, int> = 0>
+void from_json(const BasicJsonType& j, EnumType& e)
+{
+    typename std::underlying_type<EnumType>::type val;
+    get_arithmetic_value(j, val);
+    e = static_cast<EnumType>(val);
+}
+
+// forward_list doesn't have an insert method
+template<typename BasicJsonType, typename T, typename Allocator,
+         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
+void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
+    }
+    l.clear();
+    std::transform(j.rbegin(), j.rend(),
+                   std::front_inserter(l), [](const BasicJsonType & i)
+    {
+        return i.template get<T>();
+    });
+}
+
+// valarray doesn't have an insert method
+template<typename BasicJsonType, typename T,
+         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
+void from_json(const BasicJsonType& j, std::valarray<T>& l)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
+    }
+    l.resize(j.size());
+    std::transform(j.begin(), j.end(), std::begin(l),
+                   [](const BasicJsonType & elem)
+    {
+        return elem.template get<T>();
+    });
+}
+
+template<typename BasicJsonType, typename T, std::size_t N>
+auto from_json(const BasicJsonType& j, T (&arr)[N])
+-> decltype(j.template get<T>(), void())
+{
+    for (std::size_t i = 0; i < N; ++i)
+    {
+        arr[i] = j.at(i).template get<T>();
+    }
+}
+
+template<typename BasicJsonType>
+void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /*unused*/)
+{
+    arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
+}
+
+template<typename BasicJsonType, typename T, std::size_t N>
+auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
+                          priority_tag<2> /*unused*/)
+-> decltype(j.template get<T>(), void())
+{
+    for (std::size_t i = 0; i < N; ++i)
+    {
+        arr[i] = j.at(i).template get<T>();
+    }
+}
+
+template<typename BasicJsonType, typename ConstructibleArrayType>
+auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> /*unused*/)
+-> decltype(
+    arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
+    j.template get<typename ConstructibleArrayType::value_type>(),
+    void())
+{
+    using std::end;
+
+    ConstructibleArrayType ret;
+    ret.reserve(j.size());
+    std::transform(j.begin(), j.end(),
+                   std::inserter(ret, end(ret)), [](const BasicJsonType & i)
+    {
+        // get<BasicJsonType>() returns *this, this won't call a from_json
+        // method when value_type is BasicJsonType
+        return i.template get<typename ConstructibleArrayType::value_type>();
+    });
+    arr = std::move(ret);
+}
+
+template<typename BasicJsonType, typename ConstructibleArrayType>
+void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,
+                          priority_tag<0> /*unused*/)
+{
+    using std::end;
+
+    ConstructibleArrayType ret;
+    std::transform(
+        j.begin(), j.end(), std::inserter(ret, end(ret)),
+        [](const BasicJsonType & i)
+    {
+        // get<BasicJsonType>() returns *this, this won't call a from_json
+        // method when value_type is BasicJsonType
+        return i.template get<typename ConstructibleArrayType::value_type>();
+    });
+    arr = std::move(ret);
+}
+
+template < typename BasicJsonType, typename ConstructibleArrayType,
+           enable_if_t <
+               is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value&&
+               !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
+               !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
+               !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
+               !is_basic_json<ConstructibleArrayType>::value,
+               int > = 0 >
+auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
+-> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
+j.template get<typename ConstructibleArrayType::value_type>(),
+void())
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, "type must be array, but is " +
+                                      std::string(j.type_name())));
+    }
+
+    from_json_array_impl(j, arr, priority_tag<3> {});
+}
+
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t& bin)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_binary()))
+    {
+        JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(j.type_name())));
+    }
+
+    bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
+}
+
+template<typename BasicJsonType, typename ConstructibleObjectType,
+         enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
+void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
+    {
+        JSON_THROW(type_error::create(302, "type must be object, but is " + std::string(j.type_name())));
+    }
+
+    ConstructibleObjectType ret;
+    auto inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
+    using value_type = typename ConstructibleObjectType::value_type;
+    std::transform(
+        inner_object->begin(), inner_object->end(),
+        std::inserter(ret, ret.begin()),
+        [](typename BasicJsonType::object_t::value_type const & p)
+    {
+        return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
+    });
+    obj = std::move(ret);
+}
+
+// overload for arithmetic types, not chosen for basic_json template arguments
+// (BooleanType, etc..); note: Is it really necessary to provide explicit
+// overloads for boolean_t etc. in case of a custom BooleanType which is not
+// an arithmetic type?
+template < typename BasicJsonType, typename ArithmeticType,
+           enable_if_t <
+               std::is_arithmetic<ArithmeticType>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
+               int > = 0 >
+void from_json(const BasicJsonType& j, ArithmeticType& val)
+{
+    switch (static_cast<value_t>(j))
+    {
+        case value_t::number_unsigned:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
+            break;
+        }
+        case value_t::number_integer:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
+            break;
+        }
+        case value_t::number_float:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
+            break;
+        }
+        case value_t::boolean:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
+            break;
+        }
+
+        default:
+            JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));
+    }
+}
+
+template<typename BasicJsonType, typename A1, typename A2>
+void from_json(const BasicJsonType& j, std::pair<A1, A2>& p)
+{
+    p = {j.at(0).template get<A1>(), j.at(1).template get<A2>()};
+}
+
+template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
+void from_json_tuple_impl(const BasicJsonType& j, Tuple& t, index_sequence<Idx...> /*unused*/)
+{
+    t = std::make_tuple(j.at(Idx).template get<typename std::tuple_element<Idx, Tuple>::type>()...);
+}
+
+template<typename BasicJsonType, typename... Args>
+void from_json(const BasicJsonType& j, std::tuple<Args...>& t)
+{
+    from_json_tuple_impl(j, t, index_sequence_for<Args...> {});
+}
+
+template < typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
+           typename = enable_if_t < !std::is_constructible <
+                                        typename BasicJsonType::string_t, Key >::value >>
+void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
+    }
+    m.clear();
+    for (const auto& p : j)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
+        {
+            JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
+        }
+        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
+    }
+}
+
+template < typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
+           typename = enable_if_t < !std::is_constructible <
+                                        typename BasicJsonType::string_t, Key >::value >>
+void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
+    }
+    m.clear();
+    for (const auto& p : j)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
+        {
+            JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
+        }
+        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
+    }
+}
+
+struct from_json_fn
+{
+    template<typename BasicJsonType, typename T>
+    auto operator()(const BasicJsonType& j, T& val) const
+    noexcept(noexcept(from_json(j, val)))
+    -> decltype(from_json(j, val), void())
+    {
+        return from_json(j, val);
+    }
+};
+}  // namespace detail
+
+/// namespace to hold default `from_json` function
+/// to see why this is required:
+/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
+namespace
+{
+constexpr const auto& from_json = detail::static_const<detail::from_json_fn>::value;
+} // namespace
+} // namespace nlohmann
+
+// #include <nlohmann/detail/conversions/to_json.hpp>
+
+
+#include <algorithm> // copy
+#include <iterator> // begin, end
+#include <string> // string
+#include <tuple> // tuple, get
+#include <type_traits> // is_same, is_constructible, is_floating_point, is_enum, underlying_type
+#include <utility> // move, forward, declval, pair
+#include <valarray> // valarray
+#include <vector> // vector
+
+// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
+
+
+#include <cstddef> // size_t
+#include <iterator> // input_iterator_tag
+#include <string> // string, to_string
+#include <tuple> // tuple_size, get, tuple_element
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+template<typename string_type>
+void int_to_string( string_type& target, std::size_t value )
+{
+    // For ADL
+    using std::to_string;
+    target = to_string(value);
+}
+template<typename IteratorType> class iteration_proxy_value
+{
+  public:
+    using difference_type = std::ptrdiff_t;
+    using value_type = iteration_proxy_value;
+    using pointer = value_type * ;
+    using reference = value_type & ;
+    using iterator_category = std::input_iterator_tag;
+    using string_type = typename std::remove_cv< typename std::remove_reference<decltype( std::declval<IteratorType>().key() ) >::type >::type;
+
+  private:
+    /// the iterator
+    IteratorType anchor;
+    /// an index for arrays (used to create key names)
+    std::size_t array_index = 0;
+    /// last stringified array index
+    mutable std::size_t array_index_last = 0;
+    /// a string representation of the array index
+    mutable string_type array_index_str = "0";
+    /// an empty string (to return a reference for primitive values)
+    const string_type empty_str = "";
+
+  public:
+    explicit iteration_proxy_value(IteratorType it) noexcept : anchor(it) {}
+
+    /// dereference operator (needed for range-based for)
+    iteration_proxy_value& operator*()
+    {
+        return *this;
+    }
+
+    /// increment operator (needed for range-based for)
+    iteration_proxy_value& operator++()
+    {
+        ++anchor;
+        ++array_index;
+
+        return *this;
+    }
+
+    /// equality operator (needed for InputIterator)
+    bool operator==(const iteration_proxy_value& o) const
+    {
+        return anchor == o.anchor;
+    }
+
+    /// inequality operator (needed for range-based for)
+    bool operator!=(const iteration_proxy_value& o) const
+    {
+        return anchor != o.anchor;
+    }
+
+    /// return key of the iterator
+    const string_type& key() const
+    {
+        JSON_ASSERT(anchor.m_object != nullptr);
+
+        switch (anchor.m_object->type())
+        {
+            // use integer array index as key
+            case value_t::array:
+            {
+                if (array_index != array_index_last)
+                {
+                    int_to_string( array_index_str, array_index );
+                    array_index_last = array_index;
+                }
+                return array_index_str;
+            }
+
+            // use key from the object
+            case value_t::object:
+                return anchor.key();
+
+            // use an empty key for all primitive types
+            default:
+                return empty_str;
+        }
+    }
+
+    /// return value of the iterator
+    typename IteratorType::reference value() const
+    {
+        return anchor.value();
+    }
+};
+
+/// proxy class for the items() function
+template<typename IteratorType> class iteration_proxy
+{
+  private:
+    /// the container to iterate
+    typename IteratorType::reference container;
+
+  public:
+    /// construct iteration proxy from a container
+    explicit iteration_proxy(typename IteratorType::reference cont) noexcept
+        : container(cont) {}
+
+    /// return iterator begin (needed for range-based for)
+    iteration_proxy_value<IteratorType> begin() noexcept
+    {
+        return iteration_proxy_value<IteratorType>(container.begin());
+    }
+
+    /// return iterator end (needed for range-based for)
+    iteration_proxy_value<IteratorType> end() noexcept
+    {
+        return iteration_proxy_value<IteratorType>(container.end());
+    }
+};
+// Structured Bindings Support
+// For further reference see https://blog.tartanllama.xyz/structured-bindings/
+// And see https://github.com/nlohmann/json/pull/1391
+template<std::size_t N, typename IteratorType, enable_if_t<N == 0, int> = 0>
+auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.key())
+{
+    return i.key();
+}
+// Structured Bindings Support
+// For further reference see https://blog.tartanllama.xyz/structured-bindings/
+// And see https://github.com/nlohmann/json/pull/1391
+template<std::size_t N, typename IteratorType, enable_if_t<N == 1, int> = 0>
+auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.value())
+{
+    return i.value();
+}
+}  // namespace detail
+}  // namespace nlohmann
+
+// The Addition to the STD Namespace is required to add
+// Structured Bindings Support to the iteration_proxy_value class
+// For further reference see https://blog.tartanllama.xyz/structured-bindings/
+// And see https://github.com/nlohmann/json/pull/1391
+namespace std
+{
+#if defined(__clang__)
+    // Fix: https://github.com/nlohmann/json/issues/1401
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wmismatched-tags"
+#endif
+template<typename IteratorType>
+class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>>
+            : public std::integral_constant<std::size_t, 2> {};
+
+template<std::size_t N, typename IteratorType>
+class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >>
+{
+  public:
+    using type = decltype(
+                     get<N>(std::declval <
+                            ::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));
+};
+#if defined(__clang__)
+    #pragma clang diagnostic pop
+#endif
+} // namespace std
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+//////////////////
+// constructors //
+//////////////////
+
+template<value_t> struct external_constructor;
+
+template<>
+struct external_constructor<value_t::boolean>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept
+    {
+        j.m_type = value_t::boolean;
+        j.m_value = b;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::string>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
+    {
+        j.m_type = value_t::string;
+        j.m_value = s;
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s)
+    {
+        j.m_type = value_t::string;
+        j.m_value = std::move(s);
+        j.assert_invariant();
+    }
+
+    template < typename BasicJsonType, typename CompatibleStringType,
+               enable_if_t < !std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,
+                             int > = 0 >
+    static void construct(BasicJsonType& j, const CompatibleStringType& str)
+    {
+        j.m_type = value_t::string;
+        j.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::binary>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::binary_t& b)
+    {
+        j.m_type = value_t::binary;
+        typename BasicJsonType::binary_t value{b};
+        j.m_value = value;
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::binary_t&& b)
+    {
+        j.m_type = value_t::binary;
+        typename BasicJsonType::binary_t value{std::move(b)};
+        j.m_value = value;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::number_float>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept
+    {
+        j.m_type = value_t::number_float;
+        j.m_value = val;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::number_unsigned>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept
+    {
+        j.m_type = value_t::number_unsigned;
+        j.m_value = val;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::number_integer>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept
+    {
+        j.m_type = value_t::number_integer;
+        j.m_value = val;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::array>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)
+    {
+        j.m_type = value_t::array;
+        j.m_value = arr;
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
+    {
+        j.m_type = value_t::array;
+        j.m_value = std::move(arr);
+        j.assert_invariant();
+    }
+
+    template < typename BasicJsonType, typename CompatibleArrayType,
+               enable_if_t < !std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
+                             int > = 0 >
+    static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
+    {
+        using std::begin;
+        using std::end;
+        j.m_type = value_t::array;
+        j.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const std::vector<bool>& arr)
+    {
+        j.m_type = value_t::array;
+        j.m_value = value_t::array;
+        j.m_value.array->reserve(arr.size());
+        for (const bool x : arr)
+        {
+            j.m_value.array->push_back(x);
+        }
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType, typename T,
+             enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
+    static void construct(BasicJsonType& j, const std::valarray<T>& arr)
+    {
+        j.m_type = value_t::array;
+        j.m_value = value_t::array;
+        j.m_value.array->resize(arr.size());
+        if (arr.size() > 0)
+        {
+            std::copy(std::begin(arr), std::end(arr), j.m_value.array->begin());
+        }
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::object>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)
+    {
+        j.m_type = value_t::object;
+        j.m_value = obj;
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
+    {
+        j.m_type = value_t::object;
+        j.m_value = std::move(obj);
+        j.assert_invariant();
+    }
+
+    template < typename BasicJsonType, typename CompatibleObjectType,
+               enable_if_t < !std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value, int > = 0 >
+    static void construct(BasicJsonType& j, const CompatibleObjectType& obj)
+    {
+        using std::begin;
+        using std::end;
+
+        j.m_type = value_t::object;
+        j.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
+        j.assert_invariant();
+    }
+};
+
+/////////////
+// to_json //
+/////////////
+
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_same<T, typename BasicJsonType::boolean_t>::value, int> = 0>
+void to_json(BasicJsonType& j, T b) noexcept
+{
+    external_constructor<value_t::boolean>::construct(j, b);
+}
+
+template<typename BasicJsonType, typename CompatibleString,
+         enable_if_t<std::is_constructible<typename BasicJsonType::string_t, CompatibleString>::value, int> = 0>
+void to_json(BasicJsonType& j, const CompatibleString& s)
+{
+    external_constructor<value_t::string>::construct(j, s);
+}
+
+template<typename BasicJsonType>
+void to_json(BasicJsonType& j, typename BasicJsonType::string_t&& s)
+{
+    external_constructor<value_t::string>::construct(j, std::move(s));
+}
+
+template<typename BasicJsonType, typename FloatType,
+         enable_if_t<std::is_floating_point<FloatType>::value, int> = 0>
+void to_json(BasicJsonType& j, FloatType val) noexcept
+{
+    external_constructor<value_t::number_float>::construct(j, static_cast<typename BasicJsonType::number_float_t>(val));
+}
+
+template<typename BasicJsonType, typename CompatibleNumberUnsignedType,
+         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType>::value, int> = 0>
+void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept
+{
+    external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val));
+}
+
+template<typename BasicJsonType, typename CompatibleNumberIntegerType,
+         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType>::value, int> = 0>
+void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept
+{
+    external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val));
+}
+
+template<typename BasicJsonType, typename EnumType,
+         enable_if_t<std::is_enum<EnumType>::value, int> = 0>
+void to_json(BasicJsonType& j, EnumType e) noexcept
+{
+    using underlying_type = typename std::underlying_type<EnumType>::type;
+    external_constructor<value_t::number_integer>::construct(j, static_cast<underlying_type>(e));
+}
+
+template<typename BasicJsonType>
+void to_json(BasicJsonType& j, const std::vector<bool>& e)
+{
+    external_constructor<value_t::array>::construct(j, e);
+}
+
+template < typename BasicJsonType, typename CompatibleArrayType,
+           enable_if_t < is_compatible_array_type<BasicJsonType,
+                         CompatibleArrayType>::value&&
+                         !is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value&&
+                         !is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value&&
+                         !std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value&&
+                         !is_basic_json<CompatibleArrayType>::value,
+                         int > = 0 >
+void to_json(BasicJsonType& j, const CompatibleArrayType& arr)
+{
+    external_constructor<value_t::array>::construct(j, arr);
+}
+
+template<typename BasicJsonType>
+void to_json(BasicJsonType& j, const typename BasicJsonType::binary_t& bin)
+{
+    external_constructor<value_t::binary>::construct(j, bin);
+}
+
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
+void to_json(BasicJsonType& j, const std::valarray<T>& arr)
+{
+    external_constructor<value_t::array>::construct(j, std::move(arr));
+}
+
+template<typename BasicJsonType>
+void to_json(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
+{
+    external_constructor<value_t::array>::construct(j, std::move(arr));
+}
+
+template < typename BasicJsonType, typename CompatibleObjectType,
+           enable_if_t < is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value&& !is_basic_json<CompatibleObjectType>::value, int > = 0 >
+void to_json(BasicJsonType& j, const CompatibleObjectType& obj)
+{
+    external_constructor<value_t::object>::construct(j, obj);
+}
+
+template<typename BasicJsonType>
+void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
+{
+    external_constructor<value_t::object>::construct(j, std::move(obj));
+}
+
+template <
+    typename BasicJsonType, typename T, std::size_t N,
+    enable_if_t < !std::is_constructible<typename BasicJsonType::string_t,
+                  const T(&)[N]>::value,
+                  int > = 0 >
+void to_json(BasicJsonType& j, const T(&arr)[N])
+{
+    external_constructor<value_t::array>::construct(j, arr);
+}
+
+template < typename BasicJsonType, typename T1, typename T2, enable_if_t < std::is_constructible<BasicJsonType, T1>::value&& std::is_constructible<BasicJsonType, T2>::value, int > = 0 >
+void to_json(BasicJsonType& j, const std::pair<T1, T2>& p)
+{
+    j = { p.first, p.second };
+}
+
+// for https://github.com/nlohmann/json/pull/1134
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value, int> = 0>
+void to_json(BasicJsonType& j, const T& b)
+{
+    j = { {b.key(), b.value()} };
+}
+
+template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
+void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<Idx...> /*unused*/)
+{
+    j = { std::get<Idx>(t)... };
+}
+
+template<typename BasicJsonType, typename T, enable_if_t<is_constructible_tuple<BasicJsonType, T>::value, int > = 0>
+void to_json(BasicJsonType& j, const T& t)
+{
+    to_json_tuple_impl(j, t, make_index_sequence<std::tuple_size<T>::value> {});
+}
+
+struct to_json_fn
+{
+    template<typename BasicJsonType, typename T>
+    auto operator()(BasicJsonType& j, T&& val) const noexcept(noexcept(to_json(j, std::forward<T>(val))))
+    -> decltype(to_json(j, std::forward<T>(val)), void())
+    {
+        return to_json(j, std::forward<T>(val));
+    }
+};
+}  // namespace detail
+
+/// namespace to hold default `to_json` function
+namespace
+{
+constexpr const auto& to_json = detail::static_const<detail::to_json_fn>::value;
+} // namespace
+} // namespace nlohmann
+
+
+namespace nlohmann
+{
+
+template<typename, typename>
+struct adl_serializer
+{
+    /*!
+    @brief convert a JSON value to any value type
+
+    This function is usually called by the `get()` function of the
+    @ref basic_json class (either explicit or via conversion operators).
+
+    @param[in] j        JSON value to read from
+    @param[in,out] val  value to write to
+    */
+    template<typename BasicJsonType, typename ValueType>
+    static auto from_json(BasicJsonType&& j, ValueType& val) noexcept(
+        noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
+    -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void())
+    {
+        ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
+    }
+
+    /*!
+    @brief convert any value type to a JSON value
+
+    This function is usually called by the constructors of the @ref basic_json
+    class.
+
+    @param[in,out] j  JSON value to write to
+    @param[in] val    value to read from
+    */
+    template<typename BasicJsonType, typename ValueType>
+    static auto to_json(BasicJsonType& j, ValueType&& val) noexcept(
+        noexcept(::nlohmann::to_json(j, std::forward<ValueType>(val))))
+    -> decltype(::nlohmann::to_json(j, std::forward<ValueType>(val)), void())
+    {
+        ::nlohmann::to_json(j, std::forward<ValueType>(val));
+    }
+};
+
+}  // namespace nlohmann
+
+// #include <nlohmann/byte_container_with_subtype.hpp>
+
+
+#include <cstdint> // uint8_t
+#include <tuple> // tie
+#include <utility> // move
+
+namespace nlohmann
+{
+
+/*!
+@brief an internal type for a backed binary type
+
+This type extends the template parameter @a BinaryType provided to `basic_json`
+with a subtype used by BSON and MessagePack. This type exists so that the user
+does not have to specify a type themselves with a specific naming scheme in
+order to override the binary type.
+
+@tparam BinaryType container to store bytes (`std::vector<std::uint8_t>` by
+                   default)
+
+@since version 3.8.0
+*/
+template<typename BinaryType>
+class byte_container_with_subtype : public BinaryType
+{
+  public:
+    /// the type of the underlying container
+    using container_type = BinaryType;
+
+    byte_container_with_subtype() noexcept(noexcept(container_type()))
+        : container_type()
+    {}
+
+    byte_container_with_subtype(const container_type& b) noexcept(noexcept(container_type(b)))
+        : container_type(b)
+    {}
+
+    byte_container_with_subtype(container_type&& b) noexcept(noexcept(container_type(std::move(b))))
+        : container_type(std::move(b))
+    {}
+
+    byte_container_with_subtype(const container_type& b, std::uint8_t subtype) noexcept(noexcept(container_type(b)))
+        : container_type(b)
+        , m_subtype(subtype)
+        , m_has_subtype(true)
+    {}
+
+    byte_container_with_subtype(container_type&& b, std::uint8_t subtype) noexcept(noexcept(container_type(std::move(b))))
+        : container_type(std::move(b))
+        , m_subtype(subtype)
+        , m_has_subtype(true)
+    {}
+
+    bool operator==(const byte_container_with_subtype& rhs) const
+    {
+        return std::tie(static_cast<const BinaryType&>(*this), m_subtype, m_has_subtype) ==
+               std::tie(static_cast<const BinaryType&>(rhs), rhs.m_subtype, rhs.m_has_subtype);
+    }
+
+    bool operator!=(const byte_container_with_subtype& rhs) const
+    {
+        return !(rhs == *this);
+    }
+
+    /*!
+    @brief sets the binary subtype
+
+    Sets the binary subtype of the value, also flags a binary JSON value as
+    having a subtype, which has implications for serialization.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @sa @ref subtype() -- return the binary subtype
+    @sa @ref clear_subtype() -- clears the binary subtype
+    @sa @ref has_subtype() -- returns whether or not the binary value has a
+    subtype
+
+    @since version 3.8.0
+    */
+    void set_subtype(std::uint8_t subtype) noexcept
+    {
+        m_subtype = subtype;
+        m_has_subtype = true;
+    }
+
+    /*!
+    @brief return the binary subtype
+
+    Returns the numerical subtype of the value if it has a subtype. If it does
+    not have a subtype, this function will return size_t(-1) as a sentinel
+    value.
+
+    @return the numerical subtype of the binary value
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @sa @ref set_subtype() -- sets the binary subtype
+    @sa @ref clear_subtype() -- clears the binary subtype
+    @sa @ref has_subtype() -- returns whether or not the binary value has a
+    subtype
+
+    @since version 3.8.0
+    */
+    constexpr std::uint8_t subtype() const noexcept
+    {
+        return m_subtype;
+    }
+
+    /*!
+    @brief return whether the value has a subtype
+
+    @return whether the value has a subtype
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @sa @ref subtype() -- return the binary subtype
+    @sa @ref set_subtype() -- sets the binary subtype
+    @sa @ref clear_subtype() -- clears the binary subtype
+
+    @since version 3.8.0
+    */
+    constexpr bool has_subtype() const noexcept
+    {
+        return m_has_subtype;
+    }
+
+    /*!
+    @brief clears the binary subtype
+
+    Clears the binary subtype and flags the value as not having a subtype, which
+    has implications for serialization; for instance MessagePack will prefer the
+    bin family over the ext family.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @sa @ref subtype() -- return the binary subtype
+    @sa @ref set_subtype() -- sets the binary subtype
+    @sa @ref has_subtype() -- returns whether or not the binary value has a
+    subtype
+
+    @since version 3.8.0
+    */
+    void clear_subtype() noexcept
+    {
+        m_subtype = 0;
+        m_has_subtype = false;
+    }
+
+  private:
+    std::uint8_t m_subtype = 0;
+    bool m_has_subtype = false;
+};
+
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/conversions/from_json.hpp>
+
+// #include <nlohmann/detail/conversions/to_json.hpp>
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/hash.hpp>
+
+
+#include <cstddef> // size_t, uint8_t
+#include <functional> // hash
+
+namespace nlohmann
+{
+namespace detail
+{
+
+// boost::hash_combine
+inline std::size_t combine(std::size_t seed, std::size_t h) noexcept
+{
+    seed ^= h + 0x9e3779b9 + (seed << 6U) + (seed >> 2U);
+    return seed;
+}
+
+/*!
+@brief hash a JSON value
+
+The hash function tries to rely on std::hash where possible. Furthermore, the
+type of the JSON value is taken into account to have different hash values for
+null, 0, 0U, and false, etc.
+
+@tparam BasicJsonType basic_json specialization
+@param j JSON value to hash
+@return hash value of j
+*/
+template<typename BasicJsonType>
+std::size_t hash(const BasicJsonType& j)
+{
+    using string_t = typename BasicJsonType::string_t;
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+
+    const auto type = static_cast<std::size_t>(j.type());
+    switch (j.type())
+    {
+        case BasicJsonType::value_t::null:
+        case BasicJsonType::value_t::discarded:
+        {
+            return combine(type, 0);
+        }
+
+        case BasicJsonType::value_t::object:
+        {
+            auto seed = combine(type, j.size());
+            for (const auto& element : j.items())
+            {
+                const auto h = std::hash<string_t> {}(element.key());
+                seed = combine(seed, h);
+                seed = combine(seed, hash(element.value()));
+            }
+            return seed;
+        }
+
+        case BasicJsonType::value_t::array:
+        {
+            auto seed = combine(type, j.size());
+            for (const auto& element : j)
+            {
+                seed = combine(seed, hash(element));
+            }
+            return seed;
+        }
+
+        case BasicJsonType::value_t::string:
+        {
+            const auto h = std::hash<string_t> {}(j.template get_ref<const string_t&>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::boolean:
+        {
+            const auto h = std::hash<bool> {}(j.template get<bool>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::number_integer:
+        {
+            const auto h = std::hash<number_integer_t> {}(j.template get<number_integer_t>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::number_unsigned:
+        {
+            const auto h = std::hash<number_unsigned_t> {}(j.template get<number_unsigned_t>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::number_float:
+        {
+            const auto h = std::hash<number_float_t> {}(j.template get<number_float_t>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::binary:
+        {
+            auto seed = combine(type, j.get_binary().size());
+            const auto h = std::hash<bool> {}(j.get_binary().has_subtype());
+            seed = combine(seed, h);
+            seed = combine(seed, j.get_binary().subtype());
+            for (const auto byte : j.get_binary())
+            {
+                seed = combine(seed, std::hash<std::uint8_t> {}(byte));
+            }
+            return seed;
+        }
+
+        default:                   // LCOV_EXCL_LINE
+            JSON_ASSERT(false);    // LCOV_EXCL_LINE
+            return 0;              // LCOV_EXCL_LINE
+    }
+}
+
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/input/binary_reader.hpp>
+
+
+#include <algorithm> // generate_n
+#include <array> // array
+#include <cmath> // ldexp
+#include <cstddef> // size_t
+#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
+#include <cstdio> // snprintf
+#include <cstring> // memcpy
+#include <iterator> // back_inserter
+#include <limits> // numeric_limits
+#include <string> // char_traits, string
+#include <utility> // make_pair, move
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+
+#include <array> // array
+#include <cstddef> // size_t
+#include <cstdio> //FILE *
+#include <cstring> // strlen
+#include <istream> // istream
+#include <iterator> // begin, end, iterator_traits, random_access_iterator_tag, distance, next
+#include <memory> // shared_ptr, make_shared, addressof
+#include <numeric> // accumulate
+#include <string> // string, char_traits
+#include <type_traits> // enable_if, is_base_of, is_pointer, is_integral, remove_pointer
+#include <utility> // pair, declval
+
+// #include <nlohmann/detail/iterators/iterator_traits.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+/// the supported input formats
+enum class input_format_t { json, cbor, msgpack, ubjson, bson };
+
+////////////////////
+// input adapters //
+////////////////////
+
+/*!
+Input adapter for stdio file access. This adapter read only 1 byte and do not use any
+ buffer. This adapter is a very low level adapter.
+*/
+class file_input_adapter
+{
+  public:
+    using char_type = char;
+
+    JSON_HEDLEY_NON_NULL(2)
+    explicit file_input_adapter(std::FILE* f) noexcept
+        : m_file(f)
+    {}
+
+    // make class move-only
+    file_input_adapter(const file_input_adapter&) = delete;
+    file_input_adapter(file_input_adapter&&) = default;
+    file_input_adapter& operator=(const file_input_adapter&) = delete;
+    file_input_adapter& operator=(file_input_adapter&&) = delete;
+
+    std::char_traits<char>::int_type get_character() noexcept
+    {
+        return std::fgetc(m_file);
+    }
+
+  private:
+    /// the file pointer to read from
+    std::FILE* m_file;
+};
+
+
+/*!
+Input adapter for a (caching) istream. Ignores a UFT Byte Order Mark at
+beginning of input. Does not support changing the underlying std::streambuf
+in mid-input. Maintains underlying std::istream and std::streambuf to support
+subsequent use of standard std::istream operations to process any input
+characters following those used in parsing the JSON input.  Clears the
+std::istream flags; any input errors (e.g., EOF) will be detected by the first
+subsequent call for input from the std::istream.
+*/
+class input_stream_adapter
+{
+  public:
+    using char_type = char;
+
+    ~input_stream_adapter()
+    {
+        // clear stream flags; we use underlying streambuf I/O, do not
+        // maintain ifstream flags, except eof
+        if (is != nullptr)
+        {
+            is->clear(is->rdstate() & std::ios::eofbit);
+        }
+    }
+
+    explicit input_stream_adapter(std::istream& i)
+        : is(&i), sb(i.rdbuf())
+    {}
+
+    // delete because of pointer members
+    input_stream_adapter(const input_stream_adapter&) = delete;
+    input_stream_adapter& operator=(input_stream_adapter&) = delete;
+    input_stream_adapter& operator=(input_stream_adapter&& rhs) = delete;
+
+    input_stream_adapter(input_stream_adapter&& rhs) noexcept : is(rhs.is), sb(rhs.sb)
+    {
+        rhs.is = nullptr;
+        rhs.sb = nullptr;
+    }
+
+    // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to
+    // ensure that std::char_traits<char>::eof() and the character 0xFF do not
+    // end up as the same value, eg. 0xFFFFFFFF.
+    std::char_traits<char>::int_type get_character()
+    {
+        auto res = sb->sbumpc();
+        // set eof manually, as we don't use the istream interface.
+        if (JSON_HEDLEY_UNLIKELY(res == EOF))
+        {
+            is->clear(is->rdstate() | std::ios::eofbit);
+        }
+        return res;
+    }
+
+  private:
+    /// the associated input stream
+    std::istream* is = nullptr;
+    std::streambuf* sb = nullptr;
+};
+
+// General-purpose iterator-based adapter. It might not be as fast as
+// theoretically possible for some containers, but it is extremely versatile.
+template<typename IteratorType>
+class iterator_input_adapter
+{
+  public:
+    using char_type = typename std::iterator_traits<IteratorType>::value_type;
+
+    iterator_input_adapter(IteratorType first, IteratorType last)
+        : current(std::move(first)), end(std::move(last)) {}
+
+    typename std::char_traits<char_type>::int_type get_character()
+    {
+        if (JSON_HEDLEY_LIKELY(current != end))
+        {
+            auto result = std::char_traits<char_type>::to_int_type(*current);
+            std::advance(current, 1);
+            return result;
+        }
+        else
+        {
+            return std::char_traits<char_type>::eof();
+        }
+    }
+
+  private:
+    IteratorType current;
+    IteratorType end;
+
+    template<typename BaseInputAdapter, size_t T>
+    friend struct wide_string_input_helper;
+
+    bool empty() const
+    {
+        return current == end;
+    }
+
+};
+
+
+template<typename BaseInputAdapter, size_t T>
+struct wide_string_input_helper;
+
+template<typename BaseInputAdapter>
+struct wide_string_input_helper<BaseInputAdapter, 4>
+{
+    // UTF-32
+    static void fill_buffer(BaseInputAdapter& input,
+                            std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
+                            size_t& utf8_bytes_index,
+                            size_t& utf8_bytes_filled)
+    {
+        utf8_bytes_index = 0;
+
+        if (JSON_HEDLEY_UNLIKELY(input.empty()))
+        {
+            utf8_bytes[0] = std::char_traits<char>::eof();
+            utf8_bytes_filled = 1;
+        }
+        else
+        {
+            // get the current character
+            const auto wc = input.get_character();
+
+            // UTF-32 to UTF-8 encoding
+            if (wc < 0x80)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                utf8_bytes_filled = 1;
+            }
+            else if (wc <= 0x7FF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u) & 0x1Fu));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 2;
+            }
+            else if (wc <= 0xFFFF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u) & 0x0Fu));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
+                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 3;
+            }
+            else if (wc <= 0x10FFFF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | ((static_cast<unsigned int>(wc) >> 18u) & 0x07u));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 12u) & 0x3Fu));
+                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
+                utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 4;
+            }
+            else
+            {
+                // unknown character
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                utf8_bytes_filled = 1;
+            }
+        }
+    }
+};
+
+template<typename BaseInputAdapter>
+struct wide_string_input_helper<BaseInputAdapter, 2>
+{
+    // UTF-16
+    static void fill_buffer(BaseInputAdapter& input,
+                            std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
+                            size_t& utf8_bytes_index,
+                            size_t& utf8_bytes_filled)
+    {
+        utf8_bytes_index = 0;
+
+        if (JSON_HEDLEY_UNLIKELY(input.empty()))
+        {
+            utf8_bytes[0] = std::char_traits<char>::eof();
+            utf8_bytes_filled = 1;
+        }
+        else
+        {
+            // get the current character
+            const auto wc = input.get_character();
+
+            // UTF-16 to UTF-8 encoding
+            if (wc < 0x80)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                utf8_bytes_filled = 1;
+            }
+            else if (wc <= 0x7FF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u)));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 2;
+            }
+            else if (0xD800 > wc || wc >= 0xE000)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u)));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
+                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 3;
+            }
+            else
+            {
+                if (JSON_HEDLEY_UNLIKELY(!input.empty()))
+                {
+                    const auto wc2 = static_cast<unsigned int>(input.get_character());
+                    const auto charcode = 0x10000u + (((static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
+                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | (charcode >> 18u));
+                    utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 12u) & 0x3Fu));
+                    utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 6u) & 0x3Fu));
+                    utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (charcode & 0x3Fu));
+                    utf8_bytes_filled = 4;
+                }
+                else
+                {
+                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                    utf8_bytes_filled = 1;
+                }
+            }
+        }
+    }
+};
+
+// Wraps another input apdater to convert wide character types into individual bytes.
+template<typename BaseInputAdapter, typename WideCharType>
+class wide_string_input_adapter
+{
+  public:
+    using char_type = char;
+
+    wide_string_input_adapter(BaseInputAdapter base)
+        : base_adapter(base) {}
+
+    typename std::char_traits<char>::int_type get_character() noexcept
+    {
+        // check if buffer needs to be filled
+        if (utf8_bytes_index == utf8_bytes_filled)
+        {
+            fill_buffer<sizeof(WideCharType)>();
+
+            JSON_ASSERT(utf8_bytes_filled > 0);
+            JSON_ASSERT(utf8_bytes_index == 0);
+        }
+
+        // use buffer
+        JSON_ASSERT(utf8_bytes_filled > 0);
+        JSON_ASSERT(utf8_bytes_index < utf8_bytes_filled);
+        return utf8_bytes[utf8_bytes_index++];
+    }
+
+  private:
+    BaseInputAdapter base_adapter;
+
+    template<size_t T>
+    void fill_buffer()
+    {
+        wide_string_input_helper<BaseInputAdapter, T>::fill_buffer(base_adapter, utf8_bytes, utf8_bytes_index, utf8_bytes_filled);
+    }
+
+    /// a buffer for UTF-8 bytes
+    std::array<std::char_traits<char>::int_type, 4> utf8_bytes = {{0, 0, 0, 0}};
+
+    /// index to the utf8_codes array for the next valid byte
+    std::size_t utf8_bytes_index = 0;
+    /// number of valid bytes in the utf8_codes array
+    std::size_t utf8_bytes_filled = 0;
+};
+
+
+template<typename IteratorType, typename Enable = void>
+struct iterator_input_adapter_factory
+{
+    using iterator_type = IteratorType;
+    using char_type = typename std::iterator_traits<iterator_type>::value_type;
+    using adapter_type = iterator_input_adapter<iterator_type>;
+
+    static adapter_type create(IteratorType first, IteratorType last)
+    {
+        return adapter_type(std::move(first), std::move(last));
+    }
+};
+
+template<typename T>
+struct is_iterator_of_multibyte
+{
+    using value_type = typename std::iterator_traits<T>::value_type;
+    enum
+    {
+        value = sizeof(value_type) > 1
+    };
+};
+
+template<typename IteratorType>
+struct iterator_input_adapter_factory<IteratorType, enable_if_t<is_iterator_of_multibyte<IteratorType>::value>>
+{
+    using iterator_type = IteratorType;
+    using char_type = typename std::iterator_traits<iterator_type>::value_type;
+    using base_adapter_type = iterator_input_adapter<iterator_type>;
+    using adapter_type = wide_string_input_adapter<base_adapter_type, char_type>;
+
+    static adapter_type create(IteratorType first, IteratorType last)
+    {
+        return adapter_type(base_adapter_type(std::move(first), std::move(last)));
+    }
+};
+
+// General purpose iterator-based input
+template<typename IteratorType>
+typename iterator_input_adapter_factory<IteratorType>::adapter_type input_adapter(IteratorType first, IteratorType last)
+{
+    using factory_type = iterator_input_adapter_factory<IteratorType>;
+    return factory_type::create(first, last);
+}
+
+// Convenience shorthand from container to iterator
+template<typename ContainerType>
+auto input_adapter(const ContainerType& container) -> decltype(input_adapter(begin(container), end(container)))
+{
+    // Enable ADL
+    using std::begin;
+    using std::end;
+
+    return input_adapter(begin(container), end(container));
+}
+
+// Special cases with fast paths
+inline file_input_adapter input_adapter(std::FILE* file)
+{
+    return file_input_adapter(file);
+}
+
+inline input_stream_adapter input_adapter(std::istream& stream)
+{
+    return input_stream_adapter(stream);
+}
+
+inline input_stream_adapter input_adapter(std::istream&& stream)
+{
+    return input_stream_adapter(stream);
+}
+
+using contiguous_bytes_input_adapter = decltype(input_adapter(std::declval<const char*>(), std::declval<const char*>()));
+
+// Null-delimited strings, and the like.
+template < typename CharT,
+           typename std::enable_if <
+               std::is_pointer<CharT>::value&&
+               !std::is_array<CharT>::value&&
+               std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
+               sizeof(typename std::remove_pointer<CharT>::type) == 1,
+               int >::type = 0 >
+contiguous_bytes_input_adapter input_adapter(CharT b)
+{
+    auto length = std::strlen(reinterpret_cast<const char*>(b));
+    const auto* ptr = reinterpret_cast<const char*>(b);
+    return input_adapter(ptr, ptr + length);
+}
+
+template<typename T, std::size_t N>
+auto input_adapter(T (&array)[N]) -> decltype(input_adapter(array, array + N))
+{
+    return input_adapter(array, array + N);
+}
+
+// This class only handles inputs of input_buffer_adapter type.
+// It's required so that expressions like {ptr, len} can be implicitely casted
+// to the correct adapter.
+class span_input_adapter
+{
+  public:
+    template < typename CharT,
+               typename std::enable_if <
+                   std::is_pointer<CharT>::value&&
+                   std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
+                   sizeof(typename std::remove_pointer<CharT>::type) == 1,
+                   int >::type = 0 >
+    span_input_adapter(CharT b, std::size_t l)
+        : ia(reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(b) + l) {}
+
+    template<class IteratorType,
+             typename std::enable_if<
+                 std::is_same<typename iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,
+                 int>::type = 0>
+    span_input_adapter(IteratorType first, IteratorType last)
+        : ia(input_adapter(first, last)) {}
+
+    contiguous_bytes_input_adapter&& get()
+    {
+        return std::move(ia);
+    }
+
+  private:
+    contiguous_bytes_input_adapter ia;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/input/json_sax.hpp>
+
+
+#include <cstddef>
+#include <string> // string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+namespace nlohmann
+{
+
+/*!
+@brief SAX interface
+
+This class describes the SAX interface used by @ref nlohmann::json::sax_parse.
+Each function is called in different situations while the input is parsed. The
+boolean return value informs the parser whether to continue processing the
+input.
+*/
+template<typename BasicJsonType>
+struct json_sax
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+
+    /*!
+    @brief a null value was read
+    @return whether parsing should proceed
+    */
+    virtual bool null() = 0;
+
+    /*!
+    @brief a boolean value was read
+    @param[in] val  boolean value
+    @return whether parsing should proceed
+    */
+    virtual bool boolean(bool val) = 0;
+
+    /*!
+    @brief an integer number was read
+    @param[in] val  integer value
+    @return whether parsing should proceed
+    */
+    virtual bool number_integer(number_integer_t val) = 0;
+
+    /*!
+    @brief an unsigned integer number was read
+    @param[in] val  unsigned integer value
+    @return whether parsing should proceed
+    */
+    virtual bool number_unsigned(number_unsigned_t val) = 0;
+
+    /*!
+    @brief an floating-point number was read
+    @param[in] val  floating-point value
+    @param[in] s    raw token value
+    @return whether parsing should proceed
+    */
+    virtual bool number_float(number_float_t val, const string_t& s) = 0;
+
+    /*!
+    @brief a string was read
+    @param[in] val  string value
+    @return whether parsing should proceed
+    @note It is safe to move the passed string.
+    */
+    virtual bool string(string_t& val) = 0;
+
+    /*!
+    @brief a binary string was read
+    @param[in] val  binary value
+    @return whether parsing should proceed
+    @note It is safe to move the passed binary.
+    */
+    virtual bool binary(binary_t& val) = 0;
+
+    /*!
+    @brief the beginning of an object was read
+    @param[in] elements  number of object elements or -1 if unknown
+    @return whether parsing should proceed
+    @note binary formats may report the number of elements
+    */
+    virtual bool start_object(std::size_t elements) = 0;
+
+    /*!
+    @brief an object key was read
+    @param[in] val  object key
+    @return whether parsing should proceed
+    @note It is safe to move the passed string.
+    */
+    virtual bool key(string_t& val) = 0;
+
+    /*!
+    @brief the end of an object was read
+    @return whether parsing should proceed
+    */
+    virtual bool end_object() = 0;
+
+    /*!
+    @brief the beginning of an array was read
+    @param[in] elements  number of array elements or -1 if unknown
+    @return whether parsing should proceed
+    @note binary formats may report the number of elements
+    */
+    virtual bool start_array(std::size_t elements) = 0;
+
+    /*!
+    @brief the end of an array was read
+    @return whether parsing should proceed
+    */
+    virtual bool end_array() = 0;
+
+    /*!
+    @brief a parse error occurred
+    @param[in] position    the position in the input where the error occurs
+    @param[in] last_token  the last read token
+    @param[in] ex          an exception object describing the error
+    @return whether parsing should proceed (must return false)
+    */
+    virtual bool parse_error(std::size_t position,
+                             const std::string& last_token,
+                             const detail::exception& ex) = 0;
+
+    virtual ~json_sax() = default;
+};
+
+
+namespace detail
+{
+/*!
+@brief SAX implementation to create a JSON value from SAX events
+
+This class implements the @ref json_sax interface and processes the SAX events
+to create a JSON value which makes it basically a DOM parser. The structure or
+hierarchy of the JSON value is managed by the stack `ref_stack` which contains
+a pointer to the respective array or object for each recursion depth.
+
+After successful parsing, the value that is passed by reference to the
+constructor contains the parsed value.
+
+@tparam BasicJsonType  the JSON type
+*/
+template<typename BasicJsonType>
+class json_sax_dom_parser
+{
+  public:
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+
+    /*!
+    @param[in, out] r  reference to a JSON value that is manipulated while
+                       parsing
+    @param[in] allow_exceptions_  whether parse errors yield exceptions
+    */
+    explicit json_sax_dom_parser(BasicJsonType& r, const bool allow_exceptions_ = true)
+        : root(r), allow_exceptions(allow_exceptions_)
+    {}
+
+    // make class move-only
+    json_sax_dom_parser(const json_sax_dom_parser&) = delete;
+    json_sax_dom_parser(json_sax_dom_parser&&) = default;
+    json_sax_dom_parser& operator=(const json_sax_dom_parser&) = delete;
+    json_sax_dom_parser& operator=(json_sax_dom_parser&&) = default;
+    ~json_sax_dom_parser() = default;
+
+    bool null()
+    {
+        handle_value(nullptr);
+        return true;
+    }
+
+    bool boolean(bool val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_integer(number_integer_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_float(number_float_t val, const string_t& /*unused*/)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool string(string_t& val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool binary(binary_t& val)
+    {
+        handle_value(std::move(val));
+        return true;
+    }
+
+    bool start_object(std::size_t len)
+    {
+        ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
+
+        if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408,
+                                            "excessive object size: " + std::to_string(len)));
+        }
+
+        return true;
+    }
+
+    bool key(string_t& val)
+    {
+        // add null at given key and store the reference for later
+        object_element = &(ref_stack.back()->m_value.object->operator[](val));
+        return true;
+    }
+
+    bool end_object()
+    {
+        ref_stack.pop_back();
+        return true;
+    }
+
+    bool start_array(std::size_t len)
+    {
+        ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
+
+        if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408,
+                                            "excessive array size: " + std::to_string(len)));
+        }
+
+        return true;
+    }
+
+    bool end_array()
+    {
+        ref_stack.pop_back();
+        return true;
+    }
+
+    template<class Exception>
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
+                     const Exception& ex)
+    {
+        errored = true;
+        static_cast<void>(ex);
+        if (allow_exceptions)
+        {
+            JSON_THROW(ex);
+        }
+        return false;
+    }
+
+    constexpr bool is_errored() const
+    {
+        return errored;
+    }
+
+  private:
+    /*!
+    @invariant If the ref stack is empty, then the passed value will be the new
+               root.
+    @invariant If the ref stack contains a value, then it is an array or an
+               object to which we can add elements
+    */
+    template<typename Value>
+    JSON_HEDLEY_RETURNS_NON_NULL
+    BasicJsonType* handle_value(Value&& v)
+    {
+        if (ref_stack.empty())
+        {
+            root = BasicJsonType(std::forward<Value>(v));
+            return &root;
+        }
+
+        JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
+
+        if (ref_stack.back()->is_array())
+        {
+            ref_stack.back()->m_value.array->emplace_back(std::forward<Value>(v));
+            return &(ref_stack.back()->m_value.array->back());
+        }
+
+        JSON_ASSERT(ref_stack.back()->is_object());
+        JSON_ASSERT(object_element);
+        *object_element = BasicJsonType(std::forward<Value>(v));
+        return object_element;
+    }
+
+    /// the parsed JSON value
+    BasicJsonType& root;
+    /// stack to model hierarchy of values
+    std::vector<BasicJsonType*> ref_stack {};
+    /// helper to hold the reference for the next object element
+    BasicJsonType* object_element = nullptr;
+    /// whether a syntax error occurred
+    bool errored = false;
+    /// whether to throw exceptions in case of errors
+    const bool allow_exceptions = true;
+};
+
+template<typename BasicJsonType>
+class json_sax_dom_callback_parser
+{
+  public:
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using parser_callback_t = typename BasicJsonType::parser_callback_t;
+    using parse_event_t = typename BasicJsonType::parse_event_t;
+
+    json_sax_dom_callback_parser(BasicJsonType& r,
+                                 const parser_callback_t cb,
+                                 const bool allow_exceptions_ = true)
+        : root(r), callback(cb), allow_exceptions(allow_exceptions_)
+    {
+        keep_stack.push_back(true);
+    }
+
+    // make class move-only
+    json_sax_dom_callback_parser(const json_sax_dom_callback_parser&) = delete;
+    json_sax_dom_callback_parser(json_sax_dom_callback_parser&&) = default;
+    json_sax_dom_callback_parser& operator=(const json_sax_dom_callback_parser&) = delete;
+    json_sax_dom_callback_parser& operator=(json_sax_dom_callback_parser&&) = default;
+    ~json_sax_dom_callback_parser() = default;
+
+    bool null()
+    {
+        handle_value(nullptr);
+        return true;
+    }
+
+    bool boolean(bool val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_integer(number_integer_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_float(number_float_t val, const string_t& /*unused*/)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool string(string_t& val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool binary(binary_t& val)
+    {
+        handle_value(std::move(val));
+        return true;
+    }
+
+    bool start_object(std::size_t len)
+    {
+        // check callback for object start
+        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
+        keep_stack.push_back(keep);
+
+        auto val = handle_value(BasicJsonType::value_t::object, true);
+        ref_stack.push_back(val.second);
+
+        // check object limit
+        if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408, "excessive object size: " + std::to_string(len)));
+        }
+
+        return true;
+    }
+
+    bool key(string_t& val)
+    {
+        BasicJsonType k = BasicJsonType(val);
+
+        // check callback for key
+        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
+        key_keep_stack.push_back(keep);
+
+        // add discarded value at given key and store the reference for later
+        if (keep && ref_stack.back())
+        {
+            object_element = &(ref_stack.back()->m_value.object->operator[](val) = discarded);
+        }
+
+        return true;
+    }
+
+    bool end_object()
+    {
+        if (ref_stack.back() && !callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
+        {
+            // discard object
+            *ref_stack.back() = discarded;
+        }
+
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(!keep_stack.empty());
+        ref_stack.pop_back();
+        keep_stack.pop_back();
+
+        if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
+        {
+            // remove discarded value
+            for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
+            {
+                if (it->is_discarded())
+                {
+                    ref_stack.back()->erase(it);
+                    break;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    bool start_array(std::size_t len)
+    {
+        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
+        keep_stack.push_back(keep);
+
+        auto val = handle_value(BasicJsonType::value_t::array, true);
+        ref_stack.push_back(val.second);
+
+        // check array limit
+        if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408, "excessive array size: " + std::to_string(len)));
+        }
+
+        return true;
+    }
+
+    bool end_array()
+    {
+        bool keep = true;
+
+        if (ref_stack.back())
+        {
+            keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
+            if (!keep)
+            {
+                // discard array
+                *ref_stack.back() = discarded;
+            }
+        }
+
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(!keep_stack.empty());
+        ref_stack.pop_back();
+        keep_stack.pop_back();
+
+        // remove discarded value
+        if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
+        {
+            ref_stack.back()->m_value.array->pop_back();
+        }
+
+        return true;
+    }
+
+    template<class Exception>
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
+                     const Exception& ex)
+    {
+        errored = true;
+        static_cast<void>(ex);
+        if (allow_exceptions)
+        {
+            JSON_THROW(ex);
+        }
+        return false;
+    }
+
+    constexpr bool is_errored() const
+    {
+        return errored;
+    }
+
+  private:
+    /*!
+    @param[in] v  value to add to the JSON value we build during parsing
+    @param[in] skip_callback  whether we should skip calling the callback
+               function; this is required after start_array() and
+               start_object() SAX events, because otherwise we would call the
+               callback function with an empty array or object, respectively.
+
+    @invariant If the ref stack is empty, then the passed value will be the new
+               root.
+    @invariant If the ref stack contains a value, then it is an array or an
+               object to which we can add elements
+
+    @return pair of boolean (whether value should be kept) and pointer (to the
+            passed value in the ref_stack hierarchy; nullptr if not kept)
+    */
+    template<typename Value>
+    std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
+    {
+        JSON_ASSERT(!keep_stack.empty());
+
+        // do not handle this value if we know it would be added to a discarded
+        // container
+        if (!keep_stack.back())
+        {
+            return {false, nullptr};
+        }
+
+        // create value
+        auto value = BasicJsonType(std::forward<Value>(v));
+
+        // check callback
+        const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
+
+        // do not handle this value if we just learnt it shall be discarded
+        if (!keep)
+        {
+            return {false, nullptr};
+        }
+
+        if (ref_stack.empty())
+        {
+            root = std::move(value);
+            return {true, &root};
+        }
+
+        // skip this value if we already decided to skip the parent
+        // (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
+        if (!ref_stack.back())
+        {
+            return {false, nullptr};
+        }
+
+        // we now only expect arrays and objects
+        JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
+
+        // array
+        if (ref_stack.back()->is_array())
+        {
+            ref_stack.back()->m_value.array->push_back(std::move(value));
+            return {true, &(ref_stack.back()->m_value.array->back())};
+        }
+
+        // object
+        JSON_ASSERT(ref_stack.back()->is_object());
+        // check if we should store an element for the current key
+        JSON_ASSERT(!key_keep_stack.empty());
+        const bool store_element = key_keep_stack.back();
+        key_keep_stack.pop_back();
+
+        if (!store_element)
+        {
+            return {false, nullptr};
+        }
+
+        JSON_ASSERT(object_element);
+        *object_element = std::move(value);
+        return {true, object_element};
+    }
+
+    /// the parsed JSON value
+    BasicJsonType& root;
+    /// stack to model hierarchy of values
+    std::vector<BasicJsonType*> ref_stack {};
+    /// stack to manage which values to keep
+    std::vector<bool> keep_stack {};
+    /// stack to manage which object keys to keep
+    std::vector<bool> key_keep_stack {};
+    /// helper to hold the reference for the next object element
+    BasicJsonType* object_element = nullptr;
+    /// whether a syntax error occurred
+    bool errored = false;
+    /// callback function
+    const parser_callback_t callback = nullptr;
+    /// whether to throw exceptions in case of errors
+    const bool allow_exceptions = true;
+    /// a discarded value for the callback
+    BasicJsonType discarded = BasicJsonType::value_t::discarded;
+};
+
+template<typename BasicJsonType>
+class json_sax_acceptor
+{
+  public:
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+
+    bool null()
+    {
+        return true;
+    }
+
+    bool boolean(bool /*unused*/)
+    {
+        return true;
+    }
+
+    bool number_integer(number_integer_t /*unused*/)
+    {
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t /*unused*/)
+    {
+        return true;
+    }
+
+    bool number_float(number_float_t /*unused*/, const string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool string(string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool binary(binary_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool start_object(std::size_t /*unused*/ = std::size_t(-1))
+    {
+        return true;
+    }
+
+    bool key(string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool end_object()
+    {
+        return true;
+    }
+
+    bool start_array(std::size_t /*unused*/ = std::size_t(-1))
+    {
+        return true;
+    }
+
+    bool end_array()
+    {
+        return true;
+    }
+
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const detail::exception& /*unused*/)
+    {
+        return false;
+    }
+};
+}  // namespace detail
+
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/input/lexer.hpp>
+
+
+#include <array> // array
+#include <clocale> // localeconv
+#include <cstddef> // size_t
+#include <cstdio> // snprintf
+#include <cstdlib> // strtof, strtod, strtold, strtoll, strtoull
+#include <initializer_list> // initializer_list
+#include <string> // char_traits, string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+// #include <nlohmann/detail/input/position_t.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+///////////
+// lexer //
+///////////
+
+template<typename BasicJsonType>
+class lexer_base
+{
+  public:
+    /// token types for the parser
+    enum class token_type
+    {
+        uninitialized,    ///< indicating the scanner is uninitialized
+        literal_true,     ///< the `true` literal
+        literal_false,    ///< the `false` literal
+        literal_null,     ///< the `null` literal
+        value_string,     ///< a string -- use get_string() for actual value
+        value_unsigned,   ///< an unsigned integer -- use get_number_unsigned() for actual value
+        value_integer,    ///< a signed integer -- use get_number_integer() for actual value
+        value_float,      ///< an floating point number -- use get_number_float() for actual value
+        begin_array,      ///< the character for array begin `[`
+        begin_object,     ///< the character for object begin `{`
+        end_array,        ///< the character for array end `]`
+        end_object,       ///< the character for object end `}`
+        name_separator,   ///< the name separator `:`
+        value_separator,  ///< the value separator `,`
+        parse_error,      ///< indicating a parse error
+        end_of_input,     ///< indicating the end of the input buffer
+        literal_or_value  ///< a literal or the begin of a value (only for diagnostics)
+    };
+
+    /// return name of values of type token_type (only used for errors)
+    JSON_HEDLEY_RETURNS_NON_NULL
+    JSON_HEDLEY_CONST
+    static const char* token_type_name(const token_type t) noexcept
+    {
+        switch (t)
+        {
+            case token_type::uninitialized:
+                return "<uninitialized>";
+            case token_type::literal_true:
+                return "true literal";
+            case token_type::literal_false:
+                return "false literal";
+            case token_type::literal_null:
+                return "null literal";
+            case token_type::value_string:
+                return "string literal";
+            case token_type::value_unsigned:
+            case token_type::value_integer:
+            case token_type::value_float:
+                return "number literal";
+            case token_type::begin_array:
+                return "'['";
+            case token_type::begin_object:
+                return "'{'";
+            case token_type::end_array:
+                return "']'";
+            case token_type::end_object:
+                return "'}'";
+            case token_type::name_separator:
+                return "':'";
+            case token_type::value_separator:
+                return "','";
+            case token_type::parse_error:
+                return "<parse error>";
+            case token_type::end_of_input:
+                return "end of input";
+            case token_type::literal_or_value:
+                return "'[', '{', or a literal";
+            // LCOV_EXCL_START
+            default: // catch non-enum values
+                return "unknown token";
+                // LCOV_EXCL_STOP
+        }
+    }
+};
+/*!
+@brief lexical analysis
+
+This class organizes the lexical analysis during JSON deserialization.
+*/
+template<typename BasicJsonType, typename InputAdapterType>
+class lexer : public lexer_base<BasicJsonType>
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using char_type = typename InputAdapterType::char_type;
+    using char_int_type = typename std::char_traits<char_type>::int_type;
+
+  public:
+    using token_type = typename lexer_base<BasicJsonType>::token_type;
+
+    explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false)
+        : ia(std::move(adapter))
+        , ignore_comments(ignore_comments_)
+        , decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
+    {}
+
+    // delete because of pointer members
+    lexer(const lexer&) = delete;
+    lexer(lexer&&) = default;
+    lexer& operator=(lexer&) = delete;
+    lexer& operator=(lexer&&) = default;
+    ~lexer() = default;
+
+  private:
+    /////////////////////
+    // locales
+    /////////////////////
+
+    /// return the locale-dependent decimal point
+    JSON_HEDLEY_PURE
+    static char get_decimal_point() noexcept
+    {
+        const auto* loc = localeconv();
+        JSON_ASSERT(loc != nullptr);
+        return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);
+    }
+
+    /////////////////////
+    // scan functions
+    /////////////////////
+
+    /*!
+    @brief get codepoint from 4 hex characters following `\u`
+
+    For input "\u c1 c2 c3 c4" the codepoint is:
+      (c1 * 0x1000) + (c2 * 0x0100) + (c3 * 0x0010) + c4
+    = (c1 << 12) + (c2 << 8) + (c3 << 4) + (c4 << 0)
+
+    Furthermore, the possible characters '0'..'9', 'A'..'F', and 'a'..'f'
+    must be converted to the integers 0x0..0x9, 0xA..0xF, 0xA..0xF, resp. The
+    conversion is done by subtracting the offset (0x30, 0x37, and 0x57)
+    between the ASCII value of the character and the desired integer value.
+
+    @return codepoint (0x0000..0xFFFF) or -1 in case of an error (e.g. EOF or
+            non-hex character)
+    */
+    int get_codepoint()
+    {
+        // this function only makes sense after reading `\u`
+        JSON_ASSERT(current == 'u');
+        int codepoint = 0;
+
+        const auto factors = { 12u, 8u, 4u, 0u };
+        for (const auto factor : factors)
+        {
+            get();
+
+            if (current >= '0' && current <= '9')
+            {
+                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
+            }
+            else if (current >= 'A' && current <= 'F')
+            {
+                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
+            }
+            else if (current >= 'a' && current <= 'f')
+            {
+                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
+            }
+            else
+            {
+                return -1;
+            }
+        }
+
+        JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
+        return codepoint;
+    }
+
+    /*!
+    @brief check if the next byte(s) are inside a given range
+
+    Adds the current byte and, for each passed range, reads a new byte and
+    checks if it is inside the range. If a violation was detected, set up an
+    error message and return false. Otherwise, return true.
+
+    @param[in] ranges  list of integers; interpreted as list of pairs of
+                       inclusive lower and upper bound, respectively
+
+    @pre The passed list @a ranges must have 2, 4, or 6 elements; that is,
+         1, 2, or 3 pairs. This precondition is enforced by an assertion.
+
+    @return true if and only if no range violation was detected
+    */
+    bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
+    {
+        JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
+        add(current);
+
+        for (auto range = ranges.begin(); range != ranges.end(); ++range)
+        {
+            get();
+            if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range)))
+            {
+                add(current);
+            }
+            else
+            {
+                error_message = "invalid string: ill-formed UTF-8 byte";
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /*!
+    @brief scan a string literal
+
+    This function scans a string according to Sect. 7 of RFC 7159. While
+    scanning, bytes are escaped and copied into buffer token_buffer. Then the
+    function returns successfully, token_buffer is *not* null-terminated (as it
+    may contain \0 bytes), and token_buffer.size() is the number of bytes in the
+    string.
+
+    @return token_type::value_string if string could be successfully scanned,
+            token_type::parse_error otherwise
+
+    @note In case of errors, variable error_message contains a textual
+          description.
+    */
+    token_type scan_string()
+    {
+        // reset token_buffer (ignore opening quote)
+        reset();
+
+        // we entered the function by reading an open quote
+        JSON_ASSERT(current == '\"');
+
+        while (true)
+        {
+            // get next character
+            switch (get())
+            {
+                // end of file while parsing string
+                case std::char_traits<char_type>::eof():
+                {
+                    error_message = "invalid string: missing closing quote";
+                    return token_type::parse_error;
+                }
+
+                // closing quote
+                case '\"':
+                {
+                    return token_type::value_string;
+                }
+
+                // escapes
+                case '\\':
+                {
+                    switch (get())
+                    {
+                        // quotation mark
+                        case '\"':
+                            add('\"');
+                            break;
+                        // reverse solidus
+                        case '\\':
+                            add('\\');
+                            break;
+                        // solidus
+                        case '/':
+                            add('/');
+                            break;
+                        // backspace
+                        case 'b':
+                            add('\b');
+                            break;
+                        // form feed
+                        case 'f':
+                            add('\f');
+                            break;
+                        // line feed
+                        case 'n':
+                            add('\n');
+                            break;
+                        // carriage return
+                        case 'r':
+                            add('\r');
+                            break;
+                        // tab
+                        case 't':
+                            add('\t');
+                            break;
+
+                        // unicode escapes
+                        case 'u':
+                        {
+                            const int codepoint1 = get_codepoint();
+                            int codepoint = codepoint1; // start with codepoint1
+
+                            if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
+                            {
+                                error_message = "invalid string: '\\u' must be followed by 4 hex digits";
+                                return token_type::parse_error;
+                            }
+
+                            // check if code point is a high surrogate
+                            if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
+                            {
+                                // expect next \uxxxx entry
+                                if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u'))
+                                {
+                                    const int codepoint2 = get_codepoint();
+
+                                    if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
+                                    {
+                                        error_message = "invalid string: '\\u' must be followed by 4 hex digits";
+                                        return token_type::parse_error;
+                                    }
+
+                                    // check if codepoint2 is a low surrogate
+                                    if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF))
+                                    {
+                                        // overwrite codepoint
+                                        codepoint = static_cast<int>(
+                                                        // high surrogate occupies the most significant 22 bits
+                                                        (static_cast<unsigned int>(codepoint1) << 10u)
+                                                        // low surrogate occupies the least significant 15 bits
+                                                        + static_cast<unsigned int>(codepoint2)
+                                                        // there is still the 0xD800, 0xDC00 and 0x10000 noise
+                                                        // in the result so we have to subtract with:
+                                                        // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
+                                                        - 0x35FDC00u);
+                                    }
+                                    else
+                                    {
+                                        error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
+                                        return token_type::parse_error;
+                                    }
+                                }
+                                else
+                                {
+                                    error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
+                                    return token_type::parse_error;
+                                }
+                            }
+                            else
+                            {
+                                if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
+                                {
+                                    error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
+                                    return token_type::parse_error;
+                                }
+                            }
+
+                            // result of the above calculation yields a proper codepoint
+                            JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
+
+                            // translate codepoint into bytes
+                            if (codepoint < 0x80)
+                            {
+                                // 1-byte characters: 0xxxxxxx (ASCII)
+                                add(static_cast<char_int_type>(codepoint));
+                            }
+                            else if (codepoint <= 0x7FF)
+                            {
+                                // 2-byte characters: 110xxxxx 10xxxxxx
+                                add(static_cast<char_int_type>(0xC0u | (static_cast<unsigned int>(codepoint) >> 6u)));
+                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
+                            }
+                            else if (codepoint <= 0xFFFF)
+                            {
+                                // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
+                                add(static_cast<char_int_type>(0xE0u | (static_cast<unsigned int>(codepoint) >> 12u)));
+                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
+                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
+                            }
+                            else
+                            {
+                                // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+                                add(static_cast<char_int_type>(0xF0u | (static_cast<unsigned int>(codepoint) >> 18u)));
+                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
+                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
+                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
+                            }
+
+                            break;
+                        }
+
+                        // other characters after escape
+                        default:
+                            error_message = "invalid string: forbidden character after backslash";
+                            return token_type::parse_error;
+                    }
+
+                    break;
+                }
+
+                // invalid control characters
+                case 0x00:
+                {
+                    error_message = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
+                    return token_type::parse_error;
+                }
+
+                case 0x01:
+                {
+                    error_message = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
+                    return token_type::parse_error;
+                }
+
+                case 0x02:
+                {
+                    error_message = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
+                    return token_type::parse_error;
+                }
+
+                case 0x03:
+                {
+                    error_message = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
+                    return token_type::parse_error;
+                }
+
+                case 0x04:
+                {
+                    error_message = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
+                    return token_type::parse_error;
+                }
+
+                case 0x05:
+                {
+                    error_message = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
+                    return token_type::parse_error;
+                }
+
+                case 0x06:
+                {
+                    error_message = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
+                    return token_type::parse_error;
+                }
+
+                case 0x07:
+                {
+                    error_message = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
+                    return token_type::parse_error;
+                }
+
+                case 0x08:
+                {
+                    error_message = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
+                    return token_type::parse_error;
+                }
+
+                case 0x09:
+                {
+                    error_message = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
+                    return token_type::parse_error;
+                }
+
+                case 0x0A:
+                {
+                    error_message = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
+                    return token_type::parse_error;
+                }
+
+                case 0x0B:
+                {
+                    error_message = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
+                    return token_type::parse_error;
+                }
+
+                case 0x0C:
+                {
+                    error_message = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
+                    return token_type::parse_error;
+                }
+
+                case 0x0D:
+                {
+                    error_message = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
+                    return token_type::parse_error;
+                }
+
+                case 0x0E:
+                {
+                    error_message = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
+                    return token_type::parse_error;
+                }
+
+                case 0x0F:
+                {
+                    error_message = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
+                    return token_type::parse_error;
+                }
+
+                case 0x10:
+                {
+                    error_message = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
+                    return token_type::parse_error;
+                }
+
+                case 0x11:
+                {
+                    error_message = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
+                    return token_type::parse_error;
+                }
+
+                case 0x12:
+                {
+                    error_message = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
+                    return token_type::parse_error;
+                }
+
+                case 0x13:
+                {
+                    error_message = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
+                    return token_type::parse_error;
+                }
+
+                case 0x14:
+                {
+                    error_message = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
+                    return token_type::parse_error;
+                }
+
+                case 0x15:
+                {
+                    error_message = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
+                    return token_type::parse_error;
+                }
+
+                case 0x16:
+                {
+                    error_message = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
+                    return token_type::parse_error;
+                }
+
+                case 0x17:
+                {
+                    error_message = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
+                    return token_type::parse_error;
+                }
+
+                case 0x18:
+                {
+                    error_message = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
+                    return token_type::parse_error;
+                }
+
+                case 0x19:
+                {
+                    error_message = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
+                    return token_type::parse_error;
+                }
+
+                case 0x1A:
+                {
+                    error_message = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
+                    return token_type::parse_error;
+                }
+
+                case 0x1B:
+                {
+                    error_message = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
+                    return token_type::parse_error;
+                }
+
+                case 0x1C:
+                {
+                    error_message = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
+                    return token_type::parse_error;
+                }
+
+                case 0x1D:
+                {
+                    error_message = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
+                    return token_type::parse_error;
+                }
+
+                case 0x1E:
+                {
+                    error_message = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
+                    return token_type::parse_error;
+                }
+
+                case 0x1F:
+                {
+                    error_message = "invalid string: control character U+001F (US) must be escaped to \\u001F";
+                    return token_type::parse_error;
+                }
+
+                // U+0020..U+007F (except U+0022 (quote) and U+005C (backspace))
+                case 0x20:
+                case 0x21:
+                case 0x23:
+                case 0x24:
+                case 0x25:
+                case 0x26:
+                case 0x27:
+                case 0x28:
+                case 0x29:
+                case 0x2A:
+                case 0x2B:
+                case 0x2C:
+                case 0x2D:
+                case 0x2E:
+                case 0x2F:
+                case 0x30:
+                case 0x31:
+                case 0x32:
+                case 0x33:
+                case 0x34:
+                case 0x35:
+                case 0x36:
+                case 0x37:
+                case 0x38:
+                case 0x39:
+                case 0x3A:
+                case 0x3B:
+                case 0x3C:
+                case 0x3D:
+                case 0x3E:
+                case 0x3F:
+                case 0x40:
+                case 0x41:
+                case 0x42:
+                case 0x43:
+                case 0x44:
+                case 0x45:
+                case 0x46:
+                case 0x47:
+                case 0x48:
+                case 0x49:
+                case 0x4A:
+                case 0x4B:
+                case 0x4C:
+                case 0x4D:
+                case 0x4E:
+                case 0x4F:
+                case 0x50:
+                case 0x51:
+                case 0x52:
+                case 0x53:
+                case 0x54:
+                case 0x55:
+                case 0x56:
+                case 0x57:
+                case 0x58:
+                case 0x59:
+                case 0x5A:
+                case 0x5B:
+                case 0x5D:
+                case 0x5E:
+                case 0x5F:
+                case 0x60:
+                case 0x61:
+                case 0x62:
+                case 0x63:
+                case 0x64:
+                case 0x65:
+                case 0x66:
+                case 0x67:
+                case 0x68:
+                case 0x69:
+                case 0x6A:
+                case 0x6B:
+                case 0x6C:
+                case 0x6D:
+                case 0x6E:
+                case 0x6F:
+                case 0x70:
+                case 0x71:
+                case 0x72:
+                case 0x73:
+                case 0x74:
+                case 0x75:
+                case 0x76:
+                case 0x77:
+                case 0x78:
+                case 0x79:
+                case 0x7A:
+                case 0x7B:
+                case 0x7C:
+                case 0x7D:
+                case 0x7E:
+                case 0x7F:
+                {
+                    add(current);
+                    break;
+                }
+
+                // U+0080..U+07FF: bytes C2..DF 80..BF
+                case 0xC2:
+                case 0xC3:
+                case 0xC4:
+                case 0xC5:
+                case 0xC6:
+                case 0xC7:
+                case 0xC8:
+                case 0xC9:
+                case 0xCA:
+                case 0xCB:
+                case 0xCC:
+                case 0xCD:
+                case 0xCE:
+                case 0xCF:
+                case 0xD0:
+                case 0xD1:
+                case 0xD2:
+                case 0xD3:
+                case 0xD4:
+                case 0xD5:
+                case 0xD6:
+                case 0xD7:
+                case 0xD8:
+                case 0xD9:
+                case 0xDA:
+                case 0xDB:
+                case 0xDC:
+                case 0xDD:
+                case 0xDE:
+                case 0xDF:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF})))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+0800..U+0FFF: bytes E0 A0..BF 80..BF
+                case 0xE0:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF
+                // U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF
+                case 0xE1:
+                case 0xE2:
+                case 0xE3:
+                case 0xE4:
+                case 0xE5:
+                case 0xE6:
+                case 0xE7:
+                case 0xE8:
+                case 0xE9:
+                case 0xEA:
+                case 0xEB:
+                case 0xEC:
+                case 0xEE:
+                case 0xEF:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+D000..U+D7FF: bytes ED 80..9F 80..BF
+                case 0xED:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
+                case 0xF0:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
+                case 0xF1:
+                case 0xF2:
+                case 0xF3:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
+                case 0xF4:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // remaining bytes (80..C1 and F5..FF) are ill-formed
+                default:
+                {
+                    error_message = "invalid string: ill-formed UTF-8 byte";
+                    return token_type::parse_error;
+                }
+            }
+        }
+    }
+
+    /*!
+     * @brief scan a comment
+     * @return whether comment could be scanned successfully
+     */
+    bool scan_comment()
+    {
+        switch (get())
+        {
+            // single-line comments skip input until a newline or EOF is read
+            case '/':
+            {
+                while (true)
+                {
+                    switch (get())
+                    {
+                        case '\n':
+                        case '\r':
+                        case std::char_traits<char_type>::eof():
+                        case '\0':
+                            return true;
+
+                        default:
+                            break;
+                    }
+                }
+            }
+
+            // multi-line comments skip input until */ is read
+            case '*':
+            {
+                while (true)
+                {
+                    switch (get())
+                    {
+                        case std::char_traits<char_type>::eof():
+                        case '\0':
+                        {
+                            error_message = "invalid comment; missing closing '*/'";
+                            return false;
+                        }
+
+                        case '*':
+                        {
+                            switch (get())
+                            {
+                                case '/':
+                                    return true;
+
+                                default:
+                                {
+                                    unget();
+                                    continue;
+                                }
+                            }
+                        }
+
+                        default:
+                            continue;
+                    }
+                }
+            }
+
+            // unexpected character after reading '/'
+            default:
+            {
+                error_message = "invalid comment; expecting '/' or '*' after '/'";
+                return false;
+            }
+        }
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    static void strtof(float& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtof(str, endptr);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    static void strtof(double& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtod(str, endptr);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    static void strtof(long double& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtold(str, endptr);
+    }
+
+    /*!
+    @brief scan a number literal
+
+    This function scans a string according to Sect. 6 of RFC 7159.
+
+    The function is realized with a deterministic finite state machine derived
+    from the grammar described in RFC 7159. Starting in state "init", the
+    input is read and used to determined the next state. Only state "done"
+    accepts the number. State "error" is a trap state to model errors. In the
+    table below, "anything" means any character but the ones listed before.
+
+    state    | 0        | 1-9      | e E      | +       | -       | .        | anything
+    ---------|----------|----------|----------|---------|---------|----------|-----------
+    init     | zero     | any1     | [error]  | [error] | minus   | [error]  | [error]
+    minus    | zero     | any1     | [error]  | [error] | [error] | [error]  | [error]
+    zero     | done     | done     | exponent | done    | done    | decimal1 | done
+    any1     | any1     | any1     | exponent | done    | done    | decimal1 | done
+    decimal1 | decimal2 | decimal2 | [error]  | [error] | [error] | [error]  | [error]
+    decimal2 | decimal2 | decimal2 | exponent | done    | done    | done     | done
+    exponent | any2     | any2     | [error]  | sign    | sign    | [error]  | [error]
+    sign     | any2     | any2     | [error]  | [error] | [error] | [error]  | [error]
+    any2     | any2     | any2     | done     | done    | done    | done     | done
+
+    The state machine is realized with one label per state (prefixed with
+    "scan_number_") and `goto` statements between them. The state machine
+    contains cycles, but any cycle can be left when EOF is read. Therefore,
+    the function is guaranteed to terminate.
+
+    During scanning, the read bytes are stored in token_buffer. This string is
+    then converted to a signed integer, an unsigned integer, or a
+    floating-point number.
+
+    @return token_type::value_unsigned, token_type::value_integer, or
+            token_type::value_float if number could be successfully scanned,
+            token_type::parse_error otherwise
+
+    @note The scanner is independent of the current locale. Internally, the
+          locale's decimal point is used instead of `.` to work with the
+          locale-dependent converters.
+    */
+    token_type scan_number()  // lgtm [cpp/use-of-goto]
+    {
+        // reset token_buffer to store the number's bytes
+        reset();
+
+        // the type of the parsed number; initially set to unsigned; will be
+        // changed if minus sign, decimal point or exponent is read
+        token_type number_type = token_type::value_unsigned;
+
+        // state (init): we just found out we need to scan a number
+        switch (current)
+        {
+            case '-':
+            {
+                add(current);
+                goto scan_number_minus;
+            }
+
+            case '0':
+            {
+                add(current);
+                goto scan_number_zero;
+            }
+
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any1;
+            }
+
+            // all other characters are rejected outside scan_number()
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false);  // LCOV_EXCL_LINE
+        }
+
+scan_number_minus:
+        // state: we just parsed a leading minus sign
+        number_type = token_type::value_integer;
+        switch (get())
+        {
+            case '0':
+            {
+                add(current);
+                goto scan_number_zero;
+            }
+
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any1;
+            }
+
+            default:
+            {
+                error_message = "invalid number; expected digit after '-'";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_zero:
+        // state: we just parse a zero (maybe with a leading minus sign)
+        switch (get())
+        {
+            case '.':
+            {
+                add(decimal_point_char);
+                goto scan_number_decimal1;
+            }
+
+            case 'e':
+            case 'E':
+            {
+                add(current);
+                goto scan_number_exponent;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_any1:
+        // state: we just parsed a number 0-9 (maybe with a leading minus sign)
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any1;
+            }
+
+            case '.':
+            {
+                add(decimal_point_char);
+                goto scan_number_decimal1;
+            }
+
+            case 'e':
+            case 'E':
+            {
+                add(current);
+                goto scan_number_exponent;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_decimal1:
+        // state: we just parsed a decimal point
+        number_type = token_type::value_float;
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_decimal2;
+            }
+
+            default:
+            {
+                error_message = "invalid number; expected digit after '.'";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_decimal2:
+        // we just parsed at least one number after a decimal point
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_decimal2;
+            }
+
+            case 'e':
+            case 'E':
+            {
+                add(current);
+                goto scan_number_exponent;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_exponent:
+        // we just parsed an exponent
+        number_type = token_type::value_float;
+        switch (get())
+        {
+            case '+':
+            case '-':
+            {
+                add(current);
+                goto scan_number_sign;
+            }
+
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any2;
+            }
+
+            default:
+            {
+                error_message =
+                    "invalid number; expected '+', '-', or digit after exponent";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_sign:
+        // we just parsed an exponent sign
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any2;
+            }
+
+            default:
+            {
+                error_message = "invalid number; expected digit after exponent sign";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_any2:
+        // we just parsed a number after the exponent or exponent sign
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any2;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_done:
+        // unget the character after the number (we only read it to know that
+        // we are done scanning a number)
+        unget();
+
+        char* endptr = nullptr;
+        errno = 0;
+
+        // try to parse integers first and fall back to floats
+        if (number_type == token_type::value_unsigned)
+        {
+            const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
+
+            // we checked the number format before
+            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
+
+            if (errno == 0)
+            {
+                value_unsigned = static_cast<number_unsigned_t>(x);
+                if (value_unsigned == x)
+                {
+                    return token_type::value_unsigned;
+                }
+            }
+        }
+        else if (number_type == token_type::value_integer)
+        {
+            const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
+
+            // we checked the number format before
+            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
+
+            if (errno == 0)
+            {
+                value_integer = static_cast<number_integer_t>(x);
+                if (value_integer == x)
+                {
+                    return token_type::value_integer;
+                }
+            }
+        }
+
+        // this code is reached if we parse a floating-point number or if an
+        // integer conversion above failed
+        strtof(value_float, token_buffer.data(), &endptr);
+
+        // we checked the number format before
+        JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
+
+        return token_type::value_float;
+    }
+
+    /*!
+    @param[in] literal_text  the literal text to expect
+    @param[in] length        the length of the passed literal text
+    @param[in] return_type   the token type to return on success
+    */
+    JSON_HEDLEY_NON_NULL(2)
+    token_type scan_literal(const char_type* literal_text, const std::size_t length,
+                            token_type return_type)
+    {
+        JSON_ASSERT(std::char_traits<char_type>::to_char_type(current) == literal_text[0]);
+        for (std::size_t i = 1; i < length; ++i)
+        {
+            if (JSON_HEDLEY_UNLIKELY(std::char_traits<char_type>::to_char_type(get()) != literal_text[i]))
+            {
+                error_message = "invalid literal";
+                return token_type::parse_error;
+            }
+        }
+        return return_type;
+    }
+
+    /////////////////////
+    // input management
+    /////////////////////
+
+    /// reset token_buffer; current character is beginning of token
+    void reset() noexcept
+    {
+        token_buffer.clear();
+        token_string.clear();
+        token_string.push_back(std::char_traits<char_type>::to_char_type(current));
+    }
+
+    /*
+    @brief get next character from the input
+
+    This function provides the interface to the used input adapter. It does
+    not throw in case the input reached EOF, but returns a
+    `std::char_traits<char>::eof()` in that case.  Stores the scanned characters
+    for use in error messages.
+
+    @return character read from the input
+    */
+    char_int_type get()
+    {
+        ++position.chars_read_total;
+        ++position.chars_read_current_line;
+
+        if (next_unget)
+        {
+            // just reset the next_unget variable and work with current
+            next_unget = false;
+        }
+        else
+        {
+            current = ia.get_character();
+        }
+
+        if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
+        {
+            token_string.push_back(std::char_traits<char_type>::to_char_type(current));
+        }
+
+        if (current == '\n')
+        {
+            ++position.lines_read;
+            position.chars_read_current_line = 0;
+        }
+
+        return current;
+    }
+
+    /*!
+    @brief unget current character (read it again on next get)
+
+    We implement unget by setting variable next_unget to true. The input is not
+    changed - we just simulate ungetting by modifying chars_read_total,
+    chars_read_current_line, and token_string. The next call to get() will
+    behave as if the unget character is read again.
+    */
+    void unget()
+    {
+        next_unget = true;
+
+        --position.chars_read_total;
+
+        // in case we "unget" a newline, we have to also decrement the lines_read
+        if (position.chars_read_current_line == 0)
+        {
+            if (position.lines_read > 0)
+            {
+                --position.lines_read;
+            }
+        }
+        else
+        {
+            --position.chars_read_current_line;
+        }
+
+        if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
+        {
+            JSON_ASSERT(!token_string.empty());
+            token_string.pop_back();
+        }
+    }
+
+    /// add a character to token_buffer
+    void add(char_int_type c)
+    {
+        token_buffer.push_back(static_cast<typename string_t::value_type>(c));
+    }
+
+  public:
+    /////////////////////
+    // value getters
+    /////////////////////
+
+    /// return integer value
+    constexpr number_integer_t get_number_integer() const noexcept
+    {
+        return value_integer;
+    }
+
+    /// return unsigned integer value
+    constexpr number_unsigned_t get_number_unsigned() const noexcept
+    {
+        return value_unsigned;
+    }
+
+    /// return floating-point value
+    constexpr number_float_t get_number_float() const noexcept
+    {
+        return value_float;
+    }
+
+    /// return current string value (implicitly resets the token; useful only once)
+    string_t& get_string()
+    {
+        return token_buffer;
+    }
+
+    /////////////////////
+    // diagnostics
+    /////////////////////
+
+    /// return position of last read token
+    constexpr position_t get_position() const noexcept
+    {
+        return position;
+    }
+
+    /// return the last read token (for errors only).  Will never contain EOF
+    /// (an arbitrary value that is not a valid char value, often -1), because
+    /// 255 may legitimately occur.  May contain NUL, which should be escaped.
+    std::string get_token_string() const
+    {
+        // escape control characters
+        std::string result;
+        for (const auto c : token_string)
+        {
+            if (static_cast<unsigned char>(c) <= '\x1F')
+            {
+                // escape control characters
+                std::array<char, 9> cs{{}};
+                (std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c));
+                result += cs.data();
+            }
+            else
+            {
+                // add character as is
+                result.push_back(static_cast<std::string::value_type>(c));
+            }
+        }
+
+        return result;
+    }
+
+    /// return syntax error message
+    JSON_HEDLEY_RETURNS_NON_NULL
+    constexpr const char* get_error_message() const noexcept
+    {
+        return error_message;
+    }
+
+    /////////////////////
+    // actual scanner
+    /////////////////////
+
+    /*!
+    @brief skip the UTF-8 byte order mark
+    @return true iff there is no BOM or the correct BOM has been skipped
+    */
+    bool skip_bom()
+    {
+        if (get() == 0xEF)
+        {
+            // check if we completely parse the BOM
+            return get() == 0xBB && get() == 0xBF;
+        }
+
+        // the first character is not the beginning of the BOM; unget it to
+        // process is later
+        unget();
+        return true;
+    }
+
+    void skip_whitespace()
+    {
+        do
+        {
+            get();
+        }
+        while (current == ' ' || current == '\t' || current == '\n' || current == '\r');
+    }
+
+    token_type scan()
+    {
+        // initially, skip the BOM
+        if (position.chars_read_total == 0 && !skip_bom())
+        {
+            error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
+            return token_type::parse_error;
+        }
+
+        // read next character and ignore whitespace
+        skip_whitespace();
+
+        // ignore comments
+        while (ignore_comments && current == '/')
+        {
+            if (!scan_comment())
+            {
+                return token_type::parse_error;
+            }
+
+            // skip following whitespace
+            skip_whitespace();
+        }
+
+        switch (current)
+        {
+            // structural characters
+            case '[':
+                return token_type::begin_array;
+            case ']':
+                return token_type::end_array;
+            case '{':
+                return token_type::begin_object;
+            case '}':
+                return token_type::end_object;
+            case ':':
+                return token_type::name_separator;
+            case ',':
+                return token_type::value_separator;
+
+            // literals
+            case 't':
+            {
+                std::array<char_type, 4> true_literal = {{'t', 'r', 'u', 'e'}};
+                return scan_literal(true_literal.data(), true_literal.size(), token_type::literal_true);
+            }
+            case 'f':
+            {
+                std::array<char_type, 5> false_literal = {{'f', 'a', 'l', 's', 'e'}};
+                return scan_literal(false_literal.data(), false_literal.size(), token_type::literal_false);
+            }
+            case 'n':
+            {
+                std::array<char_type, 4> null_literal = {{'n', 'u', 'l', 'l'}};
+                return scan_literal(null_literal.data(), null_literal.size(), token_type::literal_null);
+            }
+
+            // string
+            case '\"':
+                return scan_string();
+
+            // number
+            case '-':
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+                return scan_number();
+
+            // end of input (the null byte is needed when parsing from
+            // string literals)
+            case '\0':
+            case std::char_traits<char_type>::eof():
+                return token_type::end_of_input;
+
+            // error
+            default:
+                error_message = "invalid literal";
+                return token_type::parse_error;
+        }
+    }
+
+  private:
+    /// input adapter
+    InputAdapterType ia;
+
+    /// whether comments should be ignored (true) or signaled as errors (false)
+    const bool ignore_comments = false;
+
+    /// the current character
+    char_int_type current = std::char_traits<char_type>::eof();
+
+    /// whether the next get() call should just return current
+    bool next_unget = false;
+
+    /// the start position of the current token
+    position_t position {};
+
+    /// raw input token string (for error messages)
+    std::vector<char_type> token_string {};
+
+    /// buffer for variable-length tokens (numbers, strings)
+    string_t token_buffer {};
+
+    /// a description of occurred lexer errors
+    const char* error_message = "";
+
+    // number values
+    number_integer_t value_integer = 0;
+    number_unsigned_t value_unsigned = 0;
+    number_float_t value_float = 0;
+
+    /// the decimal point
+    const char_int_type decimal_point_char = '.';
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/is_sax.hpp>
+
+
+#include <cstdint> // size_t
+#include <utility> // declval
+#include <string> // string
+
+// #include <nlohmann/detail/meta/detected.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+template<typename T>
+using null_function_t = decltype(std::declval<T&>().null());
+
+template<typename T>
+using boolean_function_t =
+    decltype(std::declval<T&>().boolean(std::declval<bool>()));
+
+template<typename T, typename Integer>
+using number_integer_function_t =
+    decltype(std::declval<T&>().number_integer(std::declval<Integer>()));
+
+template<typename T, typename Unsigned>
+using number_unsigned_function_t =
+    decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));
+
+template<typename T, typename Float, typename String>
+using number_float_function_t = decltype(std::declval<T&>().number_float(
+                                    std::declval<Float>(), std::declval<const String&>()));
+
+template<typename T, typename String>
+using string_function_t =
+    decltype(std::declval<T&>().string(std::declval<String&>()));
+
+template<typename T, typename Binary>
+using binary_function_t =
+    decltype(std::declval<T&>().binary(std::declval<Binary&>()));
+
+template<typename T>
+using start_object_function_t =
+    decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));
+
+template<typename T, typename String>
+using key_function_t =
+    decltype(std::declval<T&>().key(std::declval<String&>()));
+
+template<typename T>
+using end_object_function_t = decltype(std::declval<T&>().end_object());
+
+template<typename T>
+using start_array_function_t =
+    decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));
+
+template<typename T>
+using end_array_function_t = decltype(std::declval<T&>().end_array());
+
+template<typename T, typename Exception>
+using parse_error_function_t = decltype(std::declval<T&>().parse_error(
+        std::declval<std::size_t>(), std::declval<const std::string&>(),
+        std::declval<const Exception&>()));
+
+template<typename SAX, typename BasicJsonType>
+struct is_sax
+{
+  private:
+    static_assert(is_basic_json<BasicJsonType>::value,
+                  "BasicJsonType must be of type basic_json<...>");
+
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using exception_t = typename BasicJsonType::exception;
+
+  public:
+    static constexpr bool value =
+        is_detected_exact<bool, null_function_t, SAX>::value &&
+        is_detected_exact<bool, boolean_function_t, SAX>::value &&
+        is_detected_exact<bool, number_integer_function_t, SAX, number_integer_t>::value &&
+        is_detected_exact<bool, number_unsigned_function_t, SAX, number_unsigned_t>::value &&
+        is_detected_exact<bool, number_float_function_t, SAX, number_float_t, string_t>::value &&
+        is_detected_exact<bool, string_function_t, SAX, string_t>::value &&
+        is_detected_exact<bool, binary_function_t, SAX, binary_t>::value &&
+        is_detected_exact<bool, start_object_function_t, SAX>::value &&
+        is_detected_exact<bool, key_function_t, SAX, string_t>::value &&
+        is_detected_exact<bool, end_object_function_t, SAX>::value &&
+        is_detected_exact<bool, start_array_function_t, SAX>::value &&
+        is_detected_exact<bool, end_array_function_t, SAX>::value &&
+        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value;
+};
+
+template<typename SAX, typename BasicJsonType>
+struct is_sax_static_asserts
+{
+  private:
+    static_assert(is_basic_json<BasicJsonType>::value,
+                  "BasicJsonType must be of type basic_json<...>");
+
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using exception_t = typename BasicJsonType::exception;
+
+  public:
+    static_assert(is_detected_exact<bool, null_function_t, SAX>::value,
+                  "Missing/invalid function: bool null()");
+    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
+                  "Missing/invalid function: bool boolean(bool)");
+    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
+                  "Missing/invalid function: bool boolean(bool)");
+    static_assert(
+        is_detected_exact<bool, number_integer_function_t, SAX,
+        number_integer_t>::value,
+        "Missing/invalid function: bool number_integer(number_integer_t)");
+    static_assert(
+        is_detected_exact<bool, number_unsigned_function_t, SAX,
+        number_unsigned_t>::value,
+        "Missing/invalid function: bool number_unsigned(number_unsigned_t)");
+    static_assert(is_detected_exact<bool, number_float_function_t, SAX,
+                  number_float_t, string_t>::value,
+                  "Missing/invalid function: bool number_float(number_float_t, const string_t&)");
+    static_assert(
+        is_detected_exact<bool, string_function_t, SAX, string_t>::value,
+        "Missing/invalid function: bool string(string_t&)");
+    static_assert(
+        is_detected_exact<bool, binary_function_t, SAX, binary_t>::value,
+        "Missing/invalid function: bool binary(binary_t&)");
+    static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value,
+                  "Missing/invalid function: bool start_object(std::size_t)");
+    static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value,
+                  "Missing/invalid function: bool key(string_t&)");
+    static_assert(is_detected_exact<bool, end_object_function_t, SAX>::value,
+                  "Missing/invalid function: bool end_object()");
+    static_assert(is_detected_exact<bool, start_array_function_t, SAX>::value,
+                  "Missing/invalid function: bool start_array(std::size_t)");
+    static_assert(is_detected_exact<bool, end_array_function_t, SAX>::value,
+                  "Missing/invalid function: bool end_array()");
+    static_assert(
+        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value,
+        "Missing/invalid function: bool parse_error(std::size_t, const "
+        "std::string&, const exception&)");
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+
+/// how to treat CBOR tags
+enum class cbor_tag_handler_t
+{
+    error,  ///< throw a parse_error exception in case of a tag
+    ignore   ///< ignore tags
+};
+
+/*!
+@brief determine system byte order
+
+@return true if and only if system's byte order is little endian
+
+@note from https://stackoverflow.com/a/1001328/266378
+*/
+static inline bool little_endianess(int num = 1) noexcept
+{
+    return *reinterpret_cast<char*>(&num) == 1;
+}
+
+
+///////////////////
+// binary reader //
+///////////////////
+
+/*!
+@brief deserialization of CBOR, MessagePack, and UBJSON values
+*/
+template<typename BasicJsonType, typename InputAdapterType, typename SAX = json_sax_dom_parser<BasicJsonType>>
+class binary_reader
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using json_sax_t = SAX;
+    using char_type = typename InputAdapterType::char_type;
+    using char_int_type = typename std::char_traits<char_type>::int_type;
+
+  public:
+    /*!
+    @brief create a binary reader
+
+    @param[in] adapter  input adapter to read from
+    */
+    explicit binary_reader(InputAdapterType&& adapter) : ia(std::move(adapter))
+    {
+        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
+    }
+
+    // make class move-only
+    binary_reader(const binary_reader&) = delete;
+    binary_reader(binary_reader&&) = default;
+    binary_reader& operator=(const binary_reader&) = delete;
+    binary_reader& operator=(binary_reader&&) = default;
+    ~binary_reader() = default;
+
+    /*!
+    @param[in] format  the binary format to parse
+    @param[in] sax_    a SAX event processor
+    @param[in] strict  whether to expect the input to be consumed completed
+    @param[in] tag_handler  how to treat CBOR tags
+
+    @return
+    */
+    JSON_HEDLEY_NON_NULL(3)
+    bool sax_parse(const input_format_t format,
+                   json_sax_t* sax_,
+                   const bool strict = true,
+                   const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        sax = sax_;
+        bool result = false;
+
+        switch (format)
+        {
+            case input_format_t::bson:
+                result = parse_bson_internal();
+                break;
+
+            case input_format_t::cbor:
+                result = parse_cbor_internal(true, tag_handler);
+                break;
+
+            case input_format_t::msgpack:
+                result = parse_msgpack_internal();
+                break;
+
+            case input_format_t::ubjson:
+                result = parse_ubjson_internal();
+                break;
+
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false);  // LCOV_EXCL_LINE
+        }
+
+        // strict mode: next byte must be EOF
+        if (result && strict)
+        {
+            if (format == input_format_t::ubjson)
+            {
+                get_ignore_noop();
+            }
+            else
+            {
+                get();
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(current != std::char_traits<char_type>::eof()))
+            {
+                return sax->parse_error(chars_read, get_token_string(),
+                                        parse_error::create(110, chars_read, exception_message(format, "expected end of input; last byte: 0x" + get_token_string(), "value")));
+            }
+        }
+
+        return result;
+    }
+
+  private:
+    //////////
+    // BSON //
+    //////////
+
+    /*!
+    @brief Reads in a BSON-object and passes it to the SAX-parser.
+    @return whether a valid BSON-value was passed to the SAX parser
+    */
+    bool parse_bson_internal()
+    {
+        std::int32_t document_size{};
+        get_number<std::int32_t, true>(input_format_t::bson, document_size);
+
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
+        {
+            return false;
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/false)))
+        {
+            return false;
+        }
+
+        return sax->end_object();
+    }
+
+    /*!
+    @brief Parses a C-style string from the BSON input.
+    @param[in, out] result  A reference to the string variable where the read
+                            string is to be stored.
+    @return `true` if the \x00-byte indicating the end of the string was
+             encountered before the EOF; false` indicates an unexpected EOF.
+    */
+    bool get_bson_cstr(string_t& result)
+    {
+        auto out = std::back_inserter(result);
+        while (true)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "cstring")))
+            {
+                return false;
+            }
+            if (current == 0x00)
+            {
+                return true;
+            }
+            *out++ = static_cast<typename string_t::value_type>(current);
+        }
+    }
+
+    /*!
+    @brief Parses a zero-terminated string of length @a len from the BSON
+           input.
+    @param[in] len  The length (including the zero-byte at the end) of the
+                    string to be read.
+    @param[in, out] result  A reference to the string variable where the read
+                            string is to be stored.
+    @tparam NumberType The type of the length @a len
+    @pre len >= 1
+    @return `true` if the string was successfully parsed
+    */
+    template<typename NumberType>
+    bool get_bson_string(const NumberType len, string_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(len < 1))
+        {
+            auto last_token = get_token_string();
+            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::bson, "string length must be at least 1, is " + std::to_string(len), "string")));
+        }
+
+        return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) && get() != std::char_traits<char_type>::eof();
+    }
+
+    /*!
+    @brief Parses a byte array input of length @a len from the BSON input.
+    @param[in] len  The length of the byte array to be read.
+    @param[in, out] result  A reference to the binary variable where the read
+                            array is to be stored.
+    @tparam NumberType The type of the length @a len
+    @pre len >= 0
+    @return `true` if the byte array was successfully parsed
+    */
+    template<typename NumberType>
+    bool get_bson_binary(const NumberType len, binary_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(len < 0))
+        {
+            auto last_token = get_token_string();
+            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::bson, "byte array length cannot be negative, is " + std::to_string(len), "binary")));
+        }
+
+        // All BSON binary values have a subtype
+        std::uint8_t subtype{};
+        get_number<std::uint8_t>(input_format_t::bson, subtype);
+        result.set_subtype(subtype);
+
+        return get_binary(input_format_t::bson, len, result);
+    }
+
+    /*!
+    @brief Read a BSON document element of the given @a element_type.
+    @param[in] element_type The BSON element type, c.f. http://bsonspec.org/spec.html
+    @param[in] element_type_parse_position The position in the input stream,
+               where the `element_type` was read.
+    @warning Not all BSON element types are supported yet. An unsupported
+             @a element_type will give rise to a parse_error.114:
+             Unsupported BSON record type 0x...
+    @return whether a valid BSON-object/array was passed to the SAX parser
+    */
+    bool parse_bson_element_internal(const char_int_type element_type,
+                                     const std::size_t element_type_parse_position)
+    {
+        switch (element_type)
+        {
+            case 0x01: // double
+            {
+                double number{};
+                return get_number<double, true>(input_format_t::bson, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0x02: // string
+            {
+                std::int32_t len{};
+                string_t value;
+                return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_string(len, value) && sax->string(value);
+            }
+
+            case 0x03: // object
+            {
+                return parse_bson_internal();
+            }
+
+            case 0x04: // array
+            {
+                return parse_bson_array();
+            }
+
+            case 0x05: // binary
+            {
+                std::int32_t len{};
+                binary_t value;
+                return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_binary(len, value) && sax->binary(value);
+            }
+
+            case 0x08: // boolean
+            {
+                return sax->boolean(get() != 0);
+            }
+
+            case 0x0A: // null
+            {
+                return sax->null();
+            }
+
+            case 0x10: // int32
+            {
+                std::int32_t value{};
+                return get_number<std::int32_t, true>(input_format_t::bson, value) && sax->number_integer(value);
+            }
+
+            case 0x12: // int64
+            {
+                std::int64_t value{};
+                return get_number<std::int64_t, true>(input_format_t::bson, value) && sax->number_integer(value);
+            }
+
+            default: // anything else not supported (yet)
+            {
+                std::array<char, 3> cr{{}};
+                (std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(element_type));
+                return sax->parse_error(element_type_parse_position, std::string(cr.data()), parse_error::create(114, element_type_parse_position, "Unsupported BSON record type 0x" + std::string(cr.data())));
+            }
+        }
+    }
+
+    /*!
+    @brief Read a BSON element list (as specified in the BSON-spec)
+
+    The same binary layout is used for objects and arrays, hence it must be
+    indicated with the argument @a is_array which one is expected
+    (true --> array, false --> object).
+
+    @param[in] is_array Determines if the element list being read is to be
+                        treated as an object (@a is_array == false), or as an
+                        array (@a is_array == true).
+    @return whether a valid BSON-object/array was passed to the SAX parser
+    */
+    bool parse_bson_element_list(const bool is_array)
+    {
+        string_t key;
+
+        while (auto element_type = get())
+        {
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "element list")))
+            {
+                return false;
+            }
+
+            const std::size_t element_type_parse_position = chars_read;
+            if (JSON_HEDLEY_UNLIKELY(!get_bson_cstr(key)))
+            {
+                return false;
+            }
+
+            if (!is_array && !sax->key(key))
+            {
+                return false;
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_internal(element_type, element_type_parse_position)))
+            {
+                return false;
+            }
+
+            // get_bson_cstr only appends
+            key.clear();
+        }
+
+        return true;
+    }
+
+    /*!
+    @brief Reads an array from the BSON input and passes it to the SAX-parser.
+    @return whether a valid BSON-array was passed to the SAX parser
+    */
+    bool parse_bson_array()
+    {
+        std::int32_t document_size{};
+        get_number<std::int32_t, true>(input_format_t::bson, document_size);
+
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
+        {
+            return false;
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/true)))
+        {
+            return false;
+        }
+
+        return sax->end_array();
+    }
+
+    //////////
+    // CBOR //
+    //////////
+
+    /*!
+    @param[in] get_char  whether a new character should be retrieved from the
+                         input (true) or whether the last read character should
+                         be considered instead (false)
+    @param[in] tag_handler how CBOR tags should be treated
+
+    @return whether a valid CBOR value was passed to the SAX parser
+    */
+    bool parse_cbor_internal(const bool get_char,
+                             const cbor_tag_handler_t tag_handler)
+    {
+        switch (get_char ? get() : current)
+        {
+            // EOF
+            case std::char_traits<char_type>::eof():
+                return unexpect_eof(input_format_t::cbor, "value");
+
+            // Integer 0x00..0x17 (0..23)
+            case 0x00:
+            case 0x01:
+            case 0x02:
+            case 0x03:
+            case 0x04:
+            case 0x05:
+            case 0x06:
+            case 0x07:
+            case 0x08:
+            case 0x09:
+            case 0x0A:
+            case 0x0B:
+            case 0x0C:
+            case 0x0D:
+            case 0x0E:
+            case 0x0F:
+            case 0x10:
+            case 0x11:
+            case 0x12:
+            case 0x13:
+            case 0x14:
+            case 0x15:
+            case 0x16:
+            case 0x17:
+                return sax->number_unsigned(static_cast<number_unsigned_t>(current));
+
+            case 0x18: // Unsigned integer (one-byte uint8_t follows)
+            {
+                std::uint8_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            case 0x19: // Unsigned integer (two-byte uint16_t follows)
+            {
+                std::uint16_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            case 0x1A: // Unsigned integer (four-byte uint32_t follows)
+            {
+                std::uint32_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            case 0x1B: // Unsigned integer (eight-byte uint64_t follows)
+            {
+                std::uint64_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            // Negative integer -1-0x00..-1-0x17 (-1..-24)
+            case 0x20:
+            case 0x21:
+            case 0x22:
+            case 0x23:
+            case 0x24:
+            case 0x25:
+            case 0x26:
+            case 0x27:
+            case 0x28:
+            case 0x29:
+            case 0x2A:
+            case 0x2B:
+            case 0x2C:
+            case 0x2D:
+            case 0x2E:
+            case 0x2F:
+            case 0x30:
+            case 0x31:
+            case 0x32:
+            case 0x33:
+            case 0x34:
+            case 0x35:
+            case 0x36:
+            case 0x37:
+                return sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - current));
+
+            case 0x38: // Negative integer (one-byte uint8_t follows)
+            {
+                std::uint8_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
+            }
+
+            case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
+            {
+                std::uint16_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
+            }
+
+            case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)
+            {
+                std::uint32_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
+            }
+
+            case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)
+            {
+                std::uint64_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1)
+                        - static_cast<number_integer_t>(number));
+            }
+
+            // Binary data (0x00..0x17 bytes follow)
+            case 0x40:
+            case 0x41:
+            case 0x42:
+            case 0x43:
+            case 0x44:
+            case 0x45:
+            case 0x46:
+            case 0x47:
+            case 0x48:
+            case 0x49:
+            case 0x4A:
+            case 0x4B:
+            case 0x4C:
+            case 0x4D:
+            case 0x4E:
+            case 0x4F:
+            case 0x50:
+            case 0x51:
+            case 0x52:
+            case 0x53:
+            case 0x54:
+            case 0x55:
+            case 0x56:
+            case 0x57:
+            case 0x58: // Binary data (one-byte uint8_t for n follows)
+            case 0x59: // Binary data (two-byte uint16_t for n follow)
+            case 0x5A: // Binary data (four-byte uint32_t for n follow)
+            case 0x5B: // Binary data (eight-byte uint64_t for n follow)
+            case 0x5F: // Binary data (indefinite length)
+            {
+                binary_t b;
+                return get_cbor_binary(b) && sax->binary(b);
+            }
+
+            // UTF-8 string (0x00..0x17 bytes follow)
+            case 0x60:
+            case 0x61:
+            case 0x62:
+            case 0x63:
+            case 0x64:
+            case 0x65:
+            case 0x66:
+            case 0x67:
+            case 0x68:
+            case 0x69:
+            case 0x6A:
+            case 0x6B:
+            case 0x6C:
+            case 0x6D:
+            case 0x6E:
+            case 0x6F:
+            case 0x70:
+            case 0x71:
+            case 0x72:
+            case 0x73:
+            case 0x74:
+            case 0x75:
+            case 0x76:
+            case 0x77:
+            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
+            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
+            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
+            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
+            case 0x7F: // UTF-8 string (indefinite length)
+            {
+                string_t s;
+                return get_cbor_string(s) && sax->string(s);
+            }
+
+            // array (0x00..0x17 data items follow)
+            case 0x80:
+            case 0x81:
+            case 0x82:
+            case 0x83:
+            case 0x84:
+            case 0x85:
+            case 0x86:
+            case 0x87:
+            case 0x88:
+            case 0x89:
+            case 0x8A:
+            case 0x8B:
+            case 0x8C:
+            case 0x8D:
+            case 0x8E:
+            case 0x8F:
+            case 0x90:
+            case 0x91:
+            case 0x92:
+            case 0x93:
+            case 0x94:
+            case 0x95:
+            case 0x96:
+            case 0x97:
+                return get_cbor_array(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
+
+            case 0x98: // array (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x99: // array (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x9A: // array (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x9B: // array (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x9F: // array (indefinite length)
+                return get_cbor_array(std::size_t(-1), tag_handler);
+
+            // map (0x00..0x17 pairs of data items follow)
+            case 0xA0:
+            case 0xA1:
+            case 0xA2:
+            case 0xA3:
+            case 0xA4:
+            case 0xA5:
+            case 0xA6:
+            case 0xA7:
+            case 0xA8:
+            case 0xA9:
+            case 0xAA:
+            case 0xAB:
+            case 0xAC:
+            case 0xAD:
+            case 0xAE:
+            case 0xAF:
+            case 0xB0:
+            case 0xB1:
+            case 0xB2:
+            case 0xB3:
+            case 0xB4:
+            case 0xB5:
+            case 0xB6:
+            case 0xB7:
+                return get_cbor_object(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
+
+            case 0xB8: // map (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xB9: // map (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xBA: // map (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xBB: // map (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xBF: // map (indefinite length)
+                return get_cbor_object(std::size_t(-1), tag_handler);
+
+            case 0xC6: // tagged item
+            case 0xC7:
+            case 0xC8:
+            case 0xC9:
+            case 0xCA:
+            case 0xCB:
+            case 0xCC:
+            case 0xCD:
+            case 0xCE:
+            case 0xCF:
+            case 0xD0:
+            case 0xD1:
+            case 0xD2:
+            case 0xD3:
+            case 0xD4:
+            case 0xD8: // tagged item (1 bytes follow)
+            case 0xD9: // tagged item (2 bytes follow)
+            case 0xDA: // tagged item (4 bytes follow)
+            case 0xDB: // tagged item (8 bytes follow)
+            {
+                switch (tag_handler)
+                {
+                    case cbor_tag_handler_t::error:
+                    {
+                        auto last_token = get_token_string();
+                        return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::cbor, "invalid byte: 0x" + last_token, "value")));
+                    }
+
+                    case cbor_tag_handler_t::ignore:
+                    {
+                        switch (current)
+                        {
+                            case 0xD8:
+                            {
+                                std::uint8_t len{};
+                                get_number(input_format_t::cbor, len);
+                                break;
+                            }
+                            case 0xD9:
+                            {
+                                std::uint16_t len{};
+                                get_number(input_format_t::cbor, len);
+                                break;
+                            }
+                            case 0xDA:
+                            {
+                                std::uint32_t len{};
+                                get_number(input_format_t::cbor, len);
+                                break;
+                            }
+                            case 0xDB:
+                            {
+                                std::uint64_t len{};
+                                get_number(input_format_t::cbor, len);
+                                break;
+                            }
+                            default:
+                                break;
+                        }
+                        return parse_cbor_internal(true, tag_handler);
+                    }
+
+                    default:                 // LCOV_EXCL_LINE
+                        JSON_ASSERT(false);  // LCOV_EXCL_LINE
+                        return false;        // LCOV_EXCL_LINE
+                }
+            }
+
+            case 0xF4: // false
+                return sax->boolean(false);
+
+            case 0xF5: // true
+                return sax->boolean(true);
+
+            case 0xF6: // null
+                return sax->null();
+
+            case 0xF9: // Half-Precision Float (two-byte IEEE 754)
+            {
+                const auto byte1_raw = get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
+                {
+                    return false;
+                }
+                const auto byte2_raw = get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
+                {
+                    return false;
+                }
+
+                const auto byte1 = static_cast<unsigned char>(byte1_raw);
+                const auto byte2 = static_cast<unsigned char>(byte2_raw);
+
+                // code from RFC 7049, Appendix D, Figure 3:
+                // As half-precision floating-point numbers were only added
+                // to IEEE 754 in 2008, today's programming platforms often
+                // still only have limited support for them. It is very
+                // easy to include at least decoding support for them even
+                // without such support. An example of a small decoder for
+                // half-precision floating-point numbers in the C language
+                // is shown in Fig. 3.
+                const auto half = static_cast<unsigned int>((byte1 << 8u) + byte2);
+                const double val = [&half]
+                {
+                    const int exp = (half >> 10u) & 0x1Fu;
+                    const unsigned int mant = half & 0x3FFu;
+                    JSON_ASSERT(0 <= exp&& exp <= 32);
+                    JSON_ASSERT(mant <= 1024);
+                    switch (exp)
+                    {
+                        case 0:
+                            return std::ldexp(mant, -24);
+                        case 31:
+                            return (mant == 0)
+                            ? std::numeric_limits<double>::infinity()
+                            : std::numeric_limits<double>::quiet_NaN();
+                        default:
+                            return std::ldexp(mant + 1024, exp - 25);
+                    }
+                }();
+                return sax->number_float((half & 0x8000u) != 0
+                                         ? static_cast<number_float_t>(-val)
+                                         : static_cast<number_float_t>(val), "");
+            }
+
+            case 0xFA: // Single-Precision Float (four-byte IEEE 754)
+            {
+                float number{};
+                return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0xFB: // Double-Precision Float (eight-byte IEEE 754)
+            {
+                double number{};
+                return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            default: // anything else (0xFF is handled inside the other types)
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::cbor, "invalid byte: 0x" + last_token, "value")));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a CBOR string
+
+    This function first reads starting bytes to determine the expected
+    string length and then copies this number of bytes into a string.
+    Additionally, CBOR's strings with indefinite lengths are supported.
+
+    @param[out] result  created string
+
+    @return whether string creation completed
+    */
+    bool get_cbor_string(string_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "string")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            // UTF-8 string (0x00..0x17 bytes follow)
+            case 0x60:
+            case 0x61:
+            case 0x62:
+            case 0x63:
+            case 0x64:
+            case 0x65:
+            case 0x66:
+            case 0x67:
+            case 0x68:
+            case 0x69:
+            case 0x6A:
+            case 0x6B:
+            case 0x6C:
+            case 0x6D:
+            case 0x6E:
+            case 0x6F:
+            case 0x70:
+            case 0x71:
+            case 0x72:
+            case 0x73:
+            case 0x74:
+            case 0x75:
+            case 0x76:
+            case 0x77:
+            {
+                return get_string(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
+            }
+
+            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x7F: // UTF-8 string (indefinite length)
+            {
+                while (get() != 0xFF)
+                {
+                    string_t chunk;
+                    if (!get_cbor_string(chunk))
+                    {
+                        return false;
+                    }
+                    result.append(chunk);
+                }
+                return true;
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::cbor, "expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x" + last_token, "string")));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a CBOR byte array
+
+    This function first reads starting bytes to determine the expected
+    byte array length and then copies this number of bytes into the byte array.
+    Additionally, CBOR's byte arrays with indefinite lengths are supported.
+
+    @param[out] result  created byte array
+
+    @return whether byte array creation completed
+    */
+    bool get_cbor_binary(binary_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "binary")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            // Binary data (0x00..0x17 bytes follow)
+            case 0x40:
+            case 0x41:
+            case 0x42:
+            case 0x43:
+            case 0x44:
+            case 0x45:
+            case 0x46:
+            case 0x47:
+            case 0x48:
+            case 0x49:
+            case 0x4A:
+            case 0x4B:
+            case 0x4C:
+            case 0x4D:
+            case 0x4E:
+            case 0x4F:
+            case 0x50:
+            case 0x51:
+            case 0x52:
+            case 0x53:
+            case 0x54:
+            case 0x55:
+            case 0x56:
+            case 0x57:
+            {
+                return get_binary(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
+            }
+
+            case 0x58: // Binary data (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x59: // Binary data (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x5A: // Binary data (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x5B: // Binary data (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x5F: // Binary data (indefinite length)
+            {
+                while (get() != 0xFF)
+                {
+                    binary_t chunk;
+                    if (!get_cbor_binary(chunk))
+                    {
+                        return false;
+                    }
+                    result.insert(result.end(), chunk.begin(), chunk.end());
+                }
+                return true;
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::cbor, "expected length specification (0x40-0x5B) or indefinite binary array type (0x5F); last byte: 0x" + last_token, "binary")));
+            }
+        }
+    }
+
+    /*!
+    @param[in] len  the length of the array or std::size_t(-1) for an
+                    array of indefinite size
+    @param[in] tag_handler how CBOR tags should be treated
+    @return whether array creation completed
+    */
+    bool get_cbor_array(const std::size_t len,
+                        const cbor_tag_handler_t tag_handler)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
+        {
+            return false;
+        }
+
+        if (len != std::size_t(-1))
+        {
+            for (std::size_t i = 0; i < len; ++i)
+            {
+                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+                {
+                    return false;
+                }
+            }
+        }
+        else
+        {
+            while (get() != 0xFF)
+            {
+                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(false, tag_handler)))
+                {
+                    return false;
+                }
+            }
+        }
+
+        return sax->end_array();
+    }
+
+    /*!
+    @param[in] len  the length of the object or std::size_t(-1) for an
+                    object of indefinite size
+    @param[in] tag_handler how CBOR tags should be treated
+    @return whether object creation completed
+    */
+    bool get_cbor_object(const std::size_t len,
+                         const cbor_tag_handler_t tag_handler)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
+        {
+            return false;
+        }
+
+        string_t key;
+        if (len != std::size_t(-1))
+        {
+            for (std::size_t i = 0; i < len; ++i)
+            {
+                get();
+                if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
+                {
+                    return false;
+                }
+
+                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+                {
+                    return false;
+                }
+                key.clear();
+            }
+        }
+        else
+        {
+            while (get() != 0xFF)
+            {
+                if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
+                {
+                    return false;
+                }
+
+                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+                {
+                    return false;
+                }
+                key.clear();
+            }
+        }
+
+        return sax->end_object();
+    }
+
+    /////////////
+    // MsgPack //
+    /////////////
+
+    /*!
+    @return whether a valid MessagePack value was passed to the SAX parser
+    */
+    bool parse_msgpack_internal()
+    {
+        switch (get())
+        {
+            // EOF
+            case std::char_traits<char_type>::eof():
+                return unexpect_eof(input_format_t::msgpack, "value");
+
+            // positive fixint
+            case 0x00:
+            case 0x01:
+            case 0x02:
+            case 0x03:
+            case 0x04:
+            case 0x05:
+            case 0x06:
+            case 0x07:
+            case 0x08:
+            case 0x09:
+            case 0x0A:
+            case 0x0B:
+            case 0x0C:
+            case 0x0D:
+            case 0x0E:
+            case 0x0F:
+            case 0x10:
+            case 0x11:
+            case 0x12:
+            case 0x13:
+            case 0x14:
+            case 0x15:
+            case 0x16:
+            case 0x17:
+            case 0x18:
+            case 0x19:
+            case 0x1A:
+            case 0x1B:
+            case 0x1C:
+            case 0x1D:
+            case 0x1E:
+            case 0x1F:
+            case 0x20:
+            case 0x21:
+            case 0x22:
+            case 0x23:
+            case 0x24:
+            case 0x25:
+            case 0x26:
+            case 0x27:
+            case 0x28:
+            case 0x29:
+            case 0x2A:
+            case 0x2B:
+            case 0x2C:
+            case 0x2D:
+            case 0x2E:
+            case 0x2F:
+            case 0x30:
+            case 0x31:
+            case 0x32:
+            case 0x33:
+            case 0x34:
+            case 0x35:
+            case 0x36:
+            case 0x37:
+            case 0x38:
+            case 0x39:
+            case 0x3A:
+            case 0x3B:
+            case 0x3C:
+            case 0x3D:
+            case 0x3E:
+            case 0x3F:
+            case 0x40:
+            case 0x41:
+            case 0x42:
+            case 0x43:
+            case 0x44:
+            case 0x45:
+            case 0x46:
+            case 0x47:
+            case 0x48:
+            case 0x49:
+            case 0x4A:
+            case 0x4B:
+            case 0x4C:
+            case 0x4D:
+            case 0x4E:
+            case 0x4F:
+            case 0x50:
+            case 0x51:
+            case 0x52:
+            case 0x53:
+            case 0x54:
+            case 0x55:
+            case 0x56:
+            case 0x57:
+            case 0x58:
+            case 0x59:
+            case 0x5A:
+            case 0x5B:
+            case 0x5C:
+            case 0x5D:
+            case 0x5E:
+            case 0x5F:
+            case 0x60:
+            case 0x61:
+            case 0x62:
+            case 0x63:
+            case 0x64:
+            case 0x65:
+            case 0x66:
+            case 0x67:
+            case 0x68:
+            case 0x69:
+            case 0x6A:
+            case 0x6B:
+            case 0x6C:
+            case 0x6D:
+            case 0x6E:
+            case 0x6F:
+            case 0x70:
+            case 0x71:
+            case 0x72:
+            case 0x73:
+            case 0x74:
+            case 0x75:
+            case 0x76:
+            case 0x77:
+            case 0x78:
+            case 0x79:
+            case 0x7A:
+            case 0x7B:
+            case 0x7C:
+            case 0x7D:
+            case 0x7E:
+            case 0x7F:
+                return sax->number_unsigned(static_cast<number_unsigned_t>(current));
+
+            // fixmap
+            case 0x80:
+            case 0x81:
+            case 0x82:
+            case 0x83:
+            case 0x84:
+            case 0x85:
+            case 0x86:
+            case 0x87:
+            case 0x88:
+            case 0x89:
+            case 0x8A:
+            case 0x8B:
+            case 0x8C:
+            case 0x8D:
+            case 0x8E:
+            case 0x8F:
+                return get_msgpack_object(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
+
+            // fixarray
+            case 0x90:
+            case 0x91:
+            case 0x92:
+            case 0x93:
+            case 0x94:
+            case 0x95:
+            case 0x96:
+            case 0x97:
+            case 0x98:
+            case 0x99:
+            case 0x9A:
+            case 0x9B:
+            case 0x9C:
+            case 0x9D:
+            case 0x9E:
+            case 0x9F:
+                return get_msgpack_array(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
+
+            // fixstr
+            case 0xA0:
+            case 0xA1:
+            case 0xA2:
+            case 0xA3:
+            case 0xA4:
+            case 0xA5:
+            case 0xA6:
+            case 0xA7:
+            case 0xA8:
+            case 0xA9:
+            case 0xAA:
+            case 0xAB:
+            case 0xAC:
+            case 0xAD:
+            case 0xAE:
+            case 0xAF:
+            case 0xB0:
+            case 0xB1:
+            case 0xB2:
+            case 0xB3:
+            case 0xB4:
+            case 0xB5:
+            case 0xB6:
+            case 0xB7:
+            case 0xB8:
+            case 0xB9:
+            case 0xBA:
+            case 0xBB:
+            case 0xBC:
+            case 0xBD:
+            case 0xBE:
+            case 0xBF:
+            case 0xD9: // str 8
+            case 0xDA: // str 16
+            case 0xDB: // str 32
+            {
+                string_t s;
+                return get_msgpack_string(s) && sax->string(s);
+            }
+
+            case 0xC0: // nil
+                return sax->null();
+
+            case 0xC2: // false
+                return sax->boolean(false);
+
+            case 0xC3: // true
+                return sax->boolean(true);
+
+            case 0xC4: // bin 8
+            case 0xC5: // bin 16
+            case 0xC6: // bin 32
+            case 0xC7: // ext 8
+            case 0xC8: // ext 16
+            case 0xC9: // ext 32
+            case 0xD4: // fixext 1
+            case 0xD5: // fixext 2
+            case 0xD6: // fixext 4
+            case 0xD7: // fixext 8
+            case 0xD8: // fixext 16
+            {
+                binary_t b;
+                return get_msgpack_binary(b) && sax->binary(b);
+            }
+
+            case 0xCA: // float 32
+            {
+                float number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0xCB: // float 64
+            {
+                double number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0xCC: // uint 8
+            {
+                std::uint8_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xCD: // uint 16
+            {
+                std::uint16_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xCE: // uint 32
+            {
+                std::uint32_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xCF: // uint 64
+            {
+                std::uint64_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xD0: // int 8
+            {
+                std::int8_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xD1: // int 16
+            {
+                std::int16_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xD2: // int 32
+            {
+                std::int32_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xD3: // int 64
+            {
+                std::int64_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xDC: // array 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
+            }
+
+            case 0xDD: // array 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
+            }
+
+            case 0xDE: // map 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
+            }
+
+            case 0xDF: // map 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
+            }
+
+            // negative fixint
+            case 0xE0:
+            case 0xE1:
+            case 0xE2:
+            case 0xE3:
+            case 0xE4:
+            case 0xE5:
+            case 0xE6:
+            case 0xE7:
+            case 0xE8:
+            case 0xE9:
+            case 0xEA:
+            case 0xEB:
+            case 0xEC:
+            case 0xED:
+            case 0xEE:
+            case 0xEF:
+            case 0xF0:
+            case 0xF1:
+            case 0xF2:
+            case 0xF3:
+            case 0xF4:
+            case 0xF5:
+            case 0xF6:
+            case 0xF7:
+            case 0xF8:
+            case 0xF9:
+            case 0xFA:
+            case 0xFB:
+            case 0xFC:
+            case 0xFD:
+            case 0xFE:
+            case 0xFF:
+                return sax->number_integer(static_cast<std::int8_t>(current));
+
+            default: // anything else
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::msgpack, "invalid byte: 0x" + last_token, "value")));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a MessagePack string
+
+    This function first reads starting bytes to determine the expected
+    string length and then copies this number of bytes into a string.
+
+    @param[out] result  created string
+
+    @return whether string creation completed
+    */
+    bool get_msgpack_string(string_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::msgpack, "string")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            // fixstr
+            case 0xA0:
+            case 0xA1:
+            case 0xA2:
+            case 0xA3:
+            case 0xA4:
+            case 0xA5:
+            case 0xA6:
+            case 0xA7:
+            case 0xA8:
+            case 0xA9:
+            case 0xAA:
+            case 0xAB:
+            case 0xAC:
+            case 0xAD:
+            case 0xAE:
+            case 0xAF:
+            case 0xB0:
+            case 0xB1:
+            case 0xB2:
+            case 0xB3:
+            case 0xB4:
+            case 0xB5:
+            case 0xB6:
+            case 0xB7:
+            case 0xB8:
+            case 0xB9:
+            case 0xBA:
+            case 0xBB:
+            case 0xBC:
+            case 0xBD:
+            case 0xBE:
+            case 0xBF:
+            {
+                return get_string(input_format_t::msgpack, static_cast<unsigned int>(current) & 0x1Fu, result);
+            }
+
+            case 0xD9: // str 8
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
+            }
+
+            case 0xDA: // str 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
+            }
+
+            case 0xDB: // str 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::msgpack, "expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x" + last_token, "string")));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a MessagePack byte array
+
+    This function first reads starting bytes to determine the expected
+    byte array length and then copies this number of bytes into a byte array.
+
+    @param[out] result  created byte array
+
+    @return whether byte array creation completed
+    */
+    bool get_msgpack_binary(binary_t& result)
+    {
+        // helper function to set the subtype
+        auto assign_and_return_true = [&result](std::int8_t subtype)
+        {
+            result.set_subtype(static_cast<std::uint8_t>(subtype));
+            return true;
+        };
+
+        switch (current)
+        {
+            case 0xC4: // bin 8
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_binary(input_format_t::msgpack, len, result);
+            }
+
+            case 0xC5: // bin 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_binary(input_format_t::msgpack, len, result);
+            }
+
+            case 0xC6: // bin 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_binary(input_format_t::msgpack, len, result);
+            }
+
+            case 0xC7: // ext 8
+            {
+                std::uint8_t len{};
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, len, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xC8: // ext 16
+            {
+                std::uint16_t len{};
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, len, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xC9: // ext 32
+            {
+                std::uint32_t len{};
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, len, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD4: // fixext 1
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 1, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD5: // fixext 2
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 2, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD6: // fixext 4
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 4, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD7: // fixext 8
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 8, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD8: // fixext 16
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 16, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            default:           // LCOV_EXCL_LINE
+                return false;  // LCOV_EXCL_LINE
+        }
+    }
+
+    /*!
+    @param[in] len  the length of the array
+    @return whether array creation completed
+    */
+    bool get_msgpack_array(const std::size_t len)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
+        {
+            return false;
+        }
+
+        for (std::size_t i = 0; i < len; ++i)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
+            {
+                return false;
+            }
+        }
+
+        return sax->end_array();
+    }
+
+    /*!
+    @param[in] len  the length of the object
+    @return whether object creation completed
+    */
+    bool get_msgpack_object(const std::size_t len)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
+        {
+            return false;
+        }
+
+        string_t key;
+        for (std::size_t i = 0; i < len; ++i)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key)))
+            {
+                return false;
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
+            {
+                return false;
+            }
+            key.clear();
+        }
+
+        return sax->end_object();
+    }
+
+    ////////////
+    // UBJSON //
+    ////////////
+
+    /*!
+    @param[in] get_char  whether a new character should be retrieved from the
+                         input (true, default) or whether the last read
+                         character should be considered instead
+
+    @return whether a valid UBJSON value was passed to the SAX parser
+    */
+    bool parse_ubjson_internal(const bool get_char = true)
+    {
+        return get_ubjson_value(get_char ? get_ignore_noop() : current);
+    }
+
+    /*!
+    @brief reads a UBJSON string
+
+    This function is either called after reading the 'S' byte explicitly
+    indicating a string, or in case of an object key where the 'S' byte can be
+    left out.
+
+    @param[out] result   created string
+    @param[in] get_char  whether a new character should be retrieved from the
+                         input (true, default) or whether the last read
+                         character should be considered instead
+
+    @return whether string creation completed
+    */
+    bool get_ubjson_string(string_t& result, const bool get_char = true)
+    {
+        if (get_char)
+        {
+            get();  // TODO(niels): may we ignore N here?
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "value")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            case 'U':
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
+            }
+
+            case 'i':
+            {
+                std::int8_t len{};
+                return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
+            }
+
+            case 'I':
+            {
+                std::int16_t len{};
+                return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
+            }
+
+            case 'l':
+            {
+                std::int32_t len{};
+                return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
+            }
+
+            case 'L':
+            {
+                std::int64_t len{};
+                return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
+            }
+
+            default:
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "expected length type specification (U, i, I, l, L); last byte: 0x" + last_token, "string")));
+        }
+    }
+
+    /*!
+    @param[out] result  determined size
+    @return whether size determination completed
+    */
+    bool get_ubjson_size_value(std::size_t& result)
+    {
+        switch (get_ignore_noop())
+        {
+            case 'U':
+            {
+                std::uint8_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'i':
+            {
+                std::int8_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'I':
+            {
+                std::int16_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'l':
+            {
+                std::int32_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'L':
+            {
+                std::int64_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "expected length type specification (U, i, I, l, L) after '#'; last byte: 0x" + last_token, "size")));
+            }
+        }
+    }
+
+    /*!
+    @brief determine the type and size for a container
+
+    In the optimized UBJSON format, a type and a size can be provided to allow
+    for a more compact representation.
+
+    @param[out] result  pair of the size and the type
+
+    @return whether pair creation completed
+    */
+    bool get_ubjson_size_type(std::pair<std::size_t, char_int_type>& result)
+    {
+        result.first = string_t::npos; // size
+        result.second = 0; // type
+
+        get_ignore_noop();
+
+        if (current == '$')
+        {
+            result.second = get();  // must not ignore 'N', because 'N' maybe the type
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "type")))
+            {
+                return false;
+            }
+
+            get_ignore_noop();
+            if (JSON_HEDLEY_UNLIKELY(current != '#'))
+            {
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "value")))
+                {
+                    return false;
+                }
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::ubjson, "expected '#' after type information; last byte: 0x" + last_token, "size")));
+            }
+
+            return get_ubjson_size_value(result.first);
+        }
+
+        if (current == '#')
+        {
+            return get_ubjson_size_value(result.first);
+        }
+
+        return true;
+    }
+
+    /*!
+    @param prefix  the previously read or set type prefix
+    @return whether value creation completed
+    */
+    bool get_ubjson_value(const char_int_type prefix)
+    {
+        switch (prefix)
+        {
+            case std::char_traits<char_type>::eof():  // EOF
+                return unexpect_eof(input_format_t::ubjson, "value");
+
+            case 'T':  // true
+                return sax->boolean(true);
+            case 'F':  // false
+                return sax->boolean(false);
+
+            case 'Z':  // null
+                return sax->null();
+
+            case 'U':
+            {
+                std::uint8_t number{};
+                return get_number(input_format_t::ubjson, number) && sax->number_unsigned(number);
+            }
+
+            case 'i':
+            {
+                std::int8_t number{};
+                return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
+            }
+
+            case 'I':
+            {
+                std::int16_t number{};
+                return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
+            }
+
+            case 'l':
+            {
+                std::int32_t number{};
+                return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
+            }
+
+            case 'L':
+            {
+                std::int64_t number{};
+                return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
+            }
+
+            case 'd':
+            {
+                float number{};
+                return get_number(input_format_t::ubjson, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 'D':
+            {
+                double number{};
+                return get_number(input_format_t::ubjson, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 'H':
+            {
+                return get_ubjson_high_precision_number();
+            }
+
+            case 'C':  // char
+            {
+                get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "char")))
+                {
+                    return false;
+                }
+                if (JSON_HEDLEY_UNLIKELY(current > 127))
+                {
+                    auto last_token = get_token_string();
+                    return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "byte after 'C' must be in range 0x00..0x7F; last byte: 0x" + last_token, "char")));
+                }
+                string_t s(1, static_cast<typename string_t::value_type>(current));
+                return sax->string(s);
+            }
+
+            case 'S':  // string
+            {
+                string_t s;
+                return get_ubjson_string(s) && sax->string(s);
+            }
+
+            case '[':  // array
+                return get_ubjson_array();
+
+            case '{':  // object
+                return get_ubjson_object();
+
+            default: // anything else
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::ubjson, "invalid byte: 0x" + last_token, "value")));
+            }
+        }
+    }
+
+    /*!
+    @return whether array creation completed
+    */
+    bool get_ubjson_array()
+    {
+        std::pair<std::size_t, char_int_type> size_and_type;
+        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
+        {
+            return false;
+        }
+
+        if (size_and_type.first != string_t::npos)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(size_and_type.first)))
+            {
+                return false;
+            }
+
+            if (size_and_type.second != 0)
+            {
+                if (size_and_type.second != 'N')
+                {
+                    for (std::size_t i = 0; i < size_and_type.first; ++i)
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
+                        {
+                            return false;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
+                    {
+                        return false;
+                    }
+                }
+            }
+        }
+        else
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
+            {
+                return false;
+            }
+
+            while (current != ']')
+            {
+                if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal(false)))
+                {
+                    return false;
+                }
+                get_ignore_noop();
+            }
+        }
+
+        return sax->end_array();
+    }
+
+    /*!
+    @return whether object creation completed
+    */
+    bool get_ubjson_object()
+    {
+        std::pair<std::size_t, char_int_type> size_and_type;
+        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
+        {
+            return false;
+        }
+
+        string_t key;
+        if (size_and_type.first != string_t::npos)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_object(size_and_type.first)))
+            {
+                return false;
+            }
+
+            if (size_and_type.second != 0)
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
+                    {
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+            else
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
+                    {
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+        }
+        else
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
+            {
+                return false;
+            }
+
+            while (current != '}')
+            {
+                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key, false) || !sax->key(key)))
+                {
+                    return false;
+                }
+                if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
+                {
+                    return false;
+                }
+                get_ignore_noop();
+                key.clear();
+            }
+        }
+
+        return sax->end_object();
+    }
+
+    // Note, no reader for UBJSON binary types is implemented because they do
+    // not exist
+
+    bool get_ubjson_high_precision_number()
+    {
+        // get size of following number string
+        std::size_t size{};
+        auto res = get_ubjson_size_value(size);
+        if (JSON_HEDLEY_UNLIKELY(!res))
+        {
+            return res;
+        }
+
+        // get number string
+        std::vector<char> number_vector;
+        for (std::size_t i = 0; i < size; ++i)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "number")))
+            {
+                return false;
+            }
+            number_vector.push_back(static_cast<char>(current));
+        }
+
+        // parse number string
+        auto number_ia = detail::input_adapter(std::forward<decltype(number_vector)>(number_vector));
+        auto number_lexer = detail::lexer<BasicJsonType, decltype(number_ia)>(std::move(number_ia), false);
+        const auto result_number = number_lexer.scan();
+        const auto number_string = number_lexer.get_token_string();
+        const auto result_remainder = number_lexer.scan();
+
+        using token_type = typename detail::lexer_base<BasicJsonType>::token_type;
+
+        if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input))
+        {
+            return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, exception_message(input_format_t::ubjson, "invalid number text: " + number_lexer.get_token_string(), "high-precision number")));
+        }
+
+        switch (result_number)
+        {
+            case token_type::value_integer:
+                return sax->number_integer(number_lexer.get_number_integer());
+            case token_type::value_unsigned:
+                return sax->number_unsigned(number_lexer.get_number_unsigned());
+            case token_type::value_float:
+                return sax->number_float(number_lexer.get_number_float(), std::move(number_string));
+            default:
+                return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, exception_message(input_format_t::ubjson, "invalid number text: " + number_lexer.get_token_string(), "high-precision number")));
+        }
+    }
+
+    ///////////////////////
+    // Utility functions //
+    ///////////////////////
+
+    /*!
+    @brief get next character from the input
+
+    This function provides the interface to the used input adapter. It does
+    not throw in case the input reached EOF, but returns a -'ve valued
+    `std::char_traits<char_type>::eof()` in that case.
+
+    @return character read from the input
+    */
+    char_int_type get()
+    {
+        ++chars_read;
+        return current = ia.get_character();
+    }
+
+    /*!
+    @return character read from the input after ignoring all 'N' entries
+    */
+    char_int_type get_ignore_noop()
+    {
+        do
+        {
+            get();
+        }
+        while (current == 'N');
+
+        return current;
+    }
+
+    /*
+    @brief read a number from the input
+
+    @tparam NumberType the type of the number
+    @param[in] format   the current format (for diagnostics)
+    @param[out] result  number of type @a NumberType
+
+    @return whether conversion completed
+
+    @note This function needs to respect the system's endianess, because
+          bytes in CBOR, MessagePack, and UBJSON are stored in network order
+          (big endian) and therefore need reordering on little endian systems.
+    */
+    template<typename NumberType, bool InputIsLittleEndian = false>
+    bool get_number(const input_format_t format, NumberType& result)
+    {
+        // step 1: read input into array with system's byte order
+        std::array<std::uint8_t, sizeof(NumberType)> vec;
+        for (std::size_t i = 0; i < sizeof(NumberType); ++i)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "number")))
+            {
+                return false;
+            }
+
+            // reverse byte order prior to conversion if necessary
+            if (is_little_endian != InputIsLittleEndian)
+            {
+                vec[sizeof(NumberType) - i - 1] = static_cast<std::uint8_t>(current);
+            }
+            else
+            {
+                vec[i] = static_cast<std::uint8_t>(current); // LCOV_EXCL_LINE
+            }
+        }
+
+        // step 2: convert array into number of type T and return
+        std::memcpy(&result, vec.data(), sizeof(NumberType));
+        return true;
+    }
+
+    /*!
+    @brief create a string by reading characters from the input
+
+    @tparam NumberType the type of the number
+    @param[in] format the current format (for diagnostics)
+    @param[in] len number of characters to read
+    @param[out] result string created by reading @a len bytes
+
+    @return whether string creation completed
+
+    @note We can not reserve @a len bytes for the result, because @a len
+          may be too large. Usually, @ref unexpect_eof() detects the end of
+          the input before we run out of string memory.
+    */
+    template<typename NumberType>
+    bool get_string(const input_format_t format,
+                    const NumberType len,
+                    string_t& result)
+    {
+        bool success = true;
+        for (NumberType i = 0; i < len; i++)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "string")))
+            {
+                success = false;
+                break;
+            }
+            result.push_back(static_cast<typename string_t::value_type>(current));
+        };
+        return success;
+    }
+
+    /*!
+    @brief create a byte array by reading bytes from the input
+
+    @tparam NumberType the type of the number
+    @param[in] format the current format (for diagnostics)
+    @param[in] len number of bytes to read
+    @param[out] result byte array created by reading @a len bytes
+
+    @return whether byte array creation completed
+
+    @note We can not reserve @a len bytes for the result, because @a len
+          may be too large. Usually, @ref unexpect_eof() detects the end of
+          the input before we run out of memory.
+    */
+    template<typename NumberType>
+    bool get_binary(const input_format_t format,
+                    const NumberType len,
+                    binary_t& result)
+    {
+        bool success = true;
+        for (NumberType i = 0; i < len; i++)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "binary")))
+            {
+                success = false;
+                break;
+            }
+            result.push_back(static_cast<std::uint8_t>(current));
+        }
+        return success;
+    }
+
+    /*!
+    @param[in] format   the current format (for diagnostics)
+    @param[in] context  further context information (for diagnostics)
+    @return whether the last read character is not EOF
+    */
+    JSON_HEDLEY_NON_NULL(3)
+    bool unexpect_eof(const input_format_t format, const char* context) const
+    {
+        if (JSON_HEDLEY_UNLIKELY(current == std::char_traits<char_type>::eof()))
+        {
+            return sax->parse_error(chars_read, "<end of file>",
+                                    parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context)));
+        }
+        return true;
+    }
+
+    /*!
+    @return a string representation of the last read byte
+    */
+    std::string get_token_string() const
+    {
+        std::array<char, 3> cr{{}};
+        (std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(current));
+        return std::string{cr.data()};
+    }
+
+    /*!
+    @param[in] format   the current format
+    @param[in] detail   a detailed error message
+    @param[in] context  further context information
+    @return a message string to use in the parse_error exceptions
+    */
+    std::string exception_message(const input_format_t format,
+                                  const std::string& detail,
+                                  const std::string& context) const
+    {
+        std::string error_msg = "syntax error while parsing ";
+
+        switch (format)
+        {
+            case input_format_t::cbor:
+                error_msg += "CBOR";
+                break;
+
+            case input_format_t::msgpack:
+                error_msg += "MessagePack";
+                break;
+
+            case input_format_t::ubjson:
+                error_msg += "UBJSON";
+                break;
+
+            case input_format_t::bson:
+                error_msg += "BSON";
+                break;
+
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false);  // LCOV_EXCL_LINE
+        }
+
+        return error_msg + " " + context + ": " + detail;
+    }
+
+  private:
+    /// input adapter
+    InputAdapterType ia;
+
+    /// the current character
+    char_int_type current = std::char_traits<char_type>::eof();
+
+    /// the number of characters read
+    std::size_t chars_read = 0;
+
+    /// whether we can assume little endianess
+    const bool is_little_endian = little_endianess();
+
+    /// the SAX parser
+    json_sax_t* sax = nullptr;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+// #include <nlohmann/detail/input/lexer.hpp>
+
+// #include <nlohmann/detail/input/parser.hpp>
+
+
+#include <cmath> // isfinite
+#include <cstdint> // uint8_t
+#include <functional> // function
+#include <string> // string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+// #include <nlohmann/detail/input/json_sax.hpp>
+
+// #include <nlohmann/detail/input/lexer.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/is_sax.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+////////////
+// parser //
+////////////
+
+enum class parse_event_t : uint8_t
+{
+    /// the parser read `{` and started to process a JSON object
+    object_start,
+    /// the parser read `}` and finished processing a JSON object
+    object_end,
+    /// the parser read `[` and started to process a JSON array
+    array_start,
+    /// the parser read `]` and finished processing a JSON array
+    array_end,
+    /// the parser read a key of a value in an object
+    key,
+    /// the parser finished reading a JSON value
+    value
+};
+
+template<typename BasicJsonType>
+using parser_callback_t =
+    std::function<bool(int depth, parse_event_t event, BasicJsonType& parsed)>;
+
+/*!
+@brief syntax analysis
+
+This class implements a recursive descent parser.
+*/
+template<typename BasicJsonType, typename InputAdapterType>
+class parser
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using lexer_t = lexer<BasicJsonType, InputAdapterType>;
+    using token_type = typename lexer_t::token_type;
+
+  public:
+    /// a parser reading from an input adapter
+    explicit parser(InputAdapterType&& adapter,
+                    const parser_callback_t<BasicJsonType> cb = nullptr,
+                    const bool allow_exceptions_ = true,
+                    const bool skip_comments = false)
+        : callback(cb)
+        , m_lexer(std::move(adapter), skip_comments)
+        , allow_exceptions(allow_exceptions_)
+    {
+        // read first token
+        get_token();
+    }
+
+    /*!
+    @brief public parser interface
+
+    @param[in] strict      whether to expect the last token to be EOF
+    @param[in,out] result  parsed JSON value
+
+    @throw parse_error.101 in case of an unexpected token
+    @throw parse_error.102 if to_unicode fails or surrogate error
+    @throw parse_error.103 if to_unicode fails
+    */
+    void parse(const bool strict, BasicJsonType& result)
+    {
+        if (callback)
+        {
+            json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions);
+            sax_parse_internal(&sdp);
+            result.assert_invariant();
+
+            // in strict mode, input must be completely read
+            if (strict && (get_token() != token_type::end_of_input))
+            {
+                sdp.parse_error(m_lexer.get_position(),
+                                m_lexer.get_token_string(),
+                                parse_error::create(101, m_lexer.get_position(),
+                                                    exception_message(token_type::end_of_input, "value")));
+            }
+
+            // in case of an error, return discarded value
+            if (sdp.is_errored())
+            {
+                result = value_t::discarded;
+                return;
+            }
+
+            // set top-level value to null if it was discarded by the callback
+            // function
+            if (result.is_discarded())
+            {
+                result = nullptr;
+            }
+        }
+        else
+        {
+            json_sax_dom_parser<BasicJsonType> sdp(result, allow_exceptions);
+            sax_parse_internal(&sdp);
+            result.assert_invariant();
+
+            // in strict mode, input must be completely read
+            if (strict && (get_token() != token_type::end_of_input))
+            {
+                sdp.parse_error(m_lexer.get_position(),
+                                m_lexer.get_token_string(),
+                                parse_error::create(101, m_lexer.get_position(),
+                                                    exception_message(token_type::end_of_input, "value")));
+            }
+
+            // in case of an error, return discarded value
+            if (sdp.is_errored())
+            {
+                result = value_t::discarded;
+                return;
+            }
+        }
+    }
+
+    /*!
+    @brief public accept interface
+
+    @param[in] strict  whether to expect the last token to be EOF
+    @return whether the input is a proper JSON text
+    */
+    bool accept(const bool strict = true)
+    {
+        json_sax_acceptor<BasicJsonType> sax_acceptor;
+        return sax_parse(&sax_acceptor, strict);
+    }
+
+    template<typename SAX>
+    JSON_HEDLEY_NON_NULL(2)
+    bool sax_parse(SAX* sax, const bool strict = true)
+    {
+        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
+        const bool result = sax_parse_internal(sax);
+
+        // strict mode: next byte must be EOF
+        if (result && strict && (get_token() != token_type::end_of_input))
+        {
+            return sax->parse_error(m_lexer.get_position(),
+                                    m_lexer.get_token_string(),
+                                    parse_error::create(101, m_lexer.get_position(),
+                                            exception_message(token_type::end_of_input, "value")));
+        }
+
+        return result;
+    }
+
+  private:
+    template<typename SAX>
+    JSON_HEDLEY_NON_NULL(2)
+    bool sax_parse_internal(SAX* sax)
+    {
+        // stack to remember the hierarchy of structured values we are parsing
+        // true = array; false = object
+        std::vector<bool> states;
+        // value to avoid a goto (see comment where set to true)
+        bool skip_to_state_evaluation = false;
+
+        while (true)
+        {
+            if (!skip_to_state_evaluation)
+            {
+                // invariant: get_token() was called before each iteration
+                switch (last_token)
+                {
+                    case token_type::begin_object:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
+                        {
+                            return false;
+                        }
+
+                        // closing } -> we are done
+                        if (get_token() == token_type::end_object)
+                        {
+                            if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
+                            {
+                                return false;
+                            }
+                            break;
+                        }
+
+                        // parse key
+                        if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    parse_error::create(101, m_lexer.get_position(),
+                                                            exception_message(token_type::value_string, "object key")));
+                        }
+                        if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
+                        {
+                            return false;
+                        }
+
+                        // parse separator (:)
+                        if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    parse_error::create(101, m_lexer.get_position(),
+                                                            exception_message(token_type::name_separator, "object separator")));
+                        }
+
+                        // remember we are now inside an object
+                        states.push_back(false);
+
+                        // parse values
+                        get_token();
+                        continue;
+                    }
+
+                    case token_type::begin_array:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
+                        {
+                            return false;
+                        }
+
+                        // closing ] -> we are done
+                        if (get_token() == token_type::end_array)
+                        {
+                            if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
+                            {
+                                return false;
+                            }
+                            break;
+                        }
+
+                        // remember we are now inside an array
+                        states.push_back(true);
+
+                        // parse values (no need to call get_token)
+                        continue;
+                    }
+
+                    case token_type::value_float:
+                    {
+                        const auto res = m_lexer.get_number_float();
+
+                        if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res)))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    out_of_range::create(406, "number overflow parsing '" + m_lexer.get_token_string() + "'"));
+                        }
+
+                        if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string())))
+                        {
+                            return false;
+                        }
+
+                        break;
+                    }
+
+                    case token_type::literal_false:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->boolean(false)))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::literal_null:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->null()))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::literal_true:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->boolean(true)))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::value_integer:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->number_integer(m_lexer.get_number_integer())))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::value_string:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->string(m_lexer.get_string())))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::value_unsigned:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(m_lexer.get_number_unsigned())))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::parse_error:
+                    {
+                        // using "uninitialized" to avoid "expected" message
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(),
+                                                        exception_message(token_type::uninitialized, "value")));
+                    }
+
+                    default: // the last token was unexpected
+                    {
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(),
+                                                        exception_message(token_type::literal_or_value, "value")));
+                    }
+                }
+            }
+            else
+            {
+                skip_to_state_evaluation = false;
+            }
+
+            // we reached this line after we successfully parsed a value
+            if (states.empty())
+            {
+                // empty stack: we reached the end of the hierarchy: done
+                return true;
+            }
+
+            if (states.back())  // array
+            {
+                // comma -> next value
+                if (get_token() == token_type::value_separator)
+                {
+                    // parse a new value
+                    get_token();
+                    continue;
+                }
+
+                // closing ]
+                if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array))
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
+                    {
+                        return false;
+                    }
+
+                    // We are done with this array. Before we can parse a
+                    // new value, we need to evaluate the new state first.
+                    // By setting skip_to_state_evaluation to false, we
+                    // are effectively jumping to the beginning of this if.
+                    JSON_ASSERT(!states.empty());
+                    states.pop_back();
+                    skip_to_state_evaluation = true;
+                    continue;
+                }
+
+                return sax->parse_error(m_lexer.get_position(),
+                                        m_lexer.get_token_string(),
+                                        parse_error::create(101, m_lexer.get_position(),
+                                                exception_message(token_type::end_array, "array")));
+            }
+            else  // object
+            {
+                // comma -> next value
+                if (get_token() == token_type::value_separator)
+                {
+                    // parse key
+                    if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string))
+                    {
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(),
+                                                        exception_message(token_type::value_string, "object key")));
+                    }
+
+                    if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
+                    {
+                        return false;
+                    }
+
+                    // parse separator (:)
+                    if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
+                    {
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(),
+                                                        exception_message(token_type::name_separator, "object separator")));
+                    }
+
+                    // parse values
+                    get_token();
+                    continue;
+                }
+
+                // closing }
+                if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
+                    {
+                        return false;
+                    }
+
+                    // We are done with this object. Before we can parse a
+                    // new value, we need to evaluate the new state first.
+                    // By setting skip_to_state_evaluation to false, we
+                    // are effectively jumping to the beginning of this if.
+                    JSON_ASSERT(!states.empty());
+                    states.pop_back();
+                    skip_to_state_evaluation = true;
+                    continue;
+                }
+
+                return sax->parse_error(m_lexer.get_position(),
+                                        m_lexer.get_token_string(),
+                                        parse_error::create(101, m_lexer.get_position(),
+                                                exception_message(token_type::end_object, "object")));
+            }
+        }
+    }
+
+    /// get next token from lexer
+    token_type get_token()
+    {
+        return last_token = m_lexer.scan();
+    }
+
+    std::string exception_message(const token_type expected, const std::string& context)
+    {
+        std::string error_msg = "syntax error ";
+
+        if (!context.empty())
+        {
+            error_msg += "while parsing " + context + " ";
+        }
+
+        error_msg += "- ";
+
+        if (last_token == token_type::parse_error)
+        {
+            error_msg += std::string(m_lexer.get_error_message()) + "; last read: '" +
+                         m_lexer.get_token_string() + "'";
+        }
+        else
+        {
+            error_msg += "unexpected " + std::string(lexer_t::token_type_name(last_token));
+        }
+
+        if (expected != token_type::uninitialized)
+        {
+            error_msg += "; expected " + std::string(lexer_t::token_type_name(expected));
+        }
+
+        return error_msg;
+    }
+
+  private:
+    /// callback function
+    const parser_callback_t<BasicJsonType> callback = nullptr;
+    /// the type of the last read token
+    token_type last_token = token_type::uninitialized;
+    /// the lexer
+    lexer_t m_lexer;
+    /// whether to throw exceptions in case of errors
+    const bool allow_exceptions = true;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/iterators/internal_iterator.hpp>
+
+
+// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
+
+
+#include <cstddef> // ptrdiff_t
+#include <limits>  // numeric_limits
+
+namespace nlohmann
+{
+namespace detail
+{
+/*
+@brief an iterator for primitive JSON types
+
+This class models an iterator for primitive JSON types (boolean, number,
+string). It's only purpose is to allow the iterator/const_iterator classes
+to "iterate" over primitive values. Internally, the iterator is modeled by
+a `difference_type` variable. Value begin_value (`0`) models the begin,
+end_value (`1`) models past the end.
+*/
+class primitive_iterator_t
+{
+  private:
+    using difference_type = std::ptrdiff_t;
+    static constexpr difference_type begin_value = 0;
+    static constexpr difference_type end_value = begin_value + 1;
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /// iterator as signed integer type
+    difference_type m_it = (std::numeric_limits<std::ptrdiff_t>::min)();
+
+  public:
+    constexpr difference_type get_value() const noexcept
+    {
+        return m_it;
+    }
+
+    /// set iterator to a defined beginning
+    void set_begin() noexcept
+    {
+        m_it = begin_value;
+    }
+
+    /// set iterator to a defined past the end
+    void set_end() noexcept
+    {
+        m_it = end_value;
+    }
+
+    /// return whether the iterator can be dereferenced
+    constexpr bool is_begin() const noexcept
+    {
+        return m_it == begin_value;
+    }
+
+    /// return whether the iterator is at end
+    constexpr bool is_end() const noexcept
+    {
+        return m_it == end_value;
+    }
+
+    friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it == rhs.m_it;
+    }
+
+    friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it < rhs.m_it;
+    }
+
+    primitive_iterator_t operator+(difference_type n) noexcept
+    {
+        auto result = *this;
+        result += n;
+        return result;
+    }
+
+    friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it - rhs.m_it;
+    }
+
+    primitive_iterator_t& operator++() noexcept
+    {
+        ++m_it;
+        return *this;
+    }
+
+    primitive_iterator_t const operator++(int) noexcept
+    {
+        auto result = *this;
+        ++m_it;
+        return result;
+    }
+
+    primitive_iterator_t& operator--() noexcept
+    {
+        --m_it;
+        return *this;
+    }
+
+    primitive_iterator_t const operator--(int) noexcept
+    {
+        auto result = *this;
+        --m_it;
+        return result;
+    }
+
+    primitive_iterator_t& operator+=(difference_type n) noexcept
+    {
+        m_it += n;
+        return *this;
+    }
+
+    primitive_iterator_t& operator-=(difference_type n) noexcept
+    {
+        m_it -= n;
+        return *this;
+    }
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+
+namespace nlohmann
+{
+namespace detail
+{
+/*!
+@brief an iterator value
+
+@note This structure could easily be a union, but MSVC currently does not allow
+unions members with complex constructors, see https://github.com/nlohmann/json/pull/105.
+*/
+template<typename BasicJsonType> struct internal_iterator
+{
+    /// iterator for JSON objects
+    typename BasicJsonType::object_t::iterator object_iterator {};
+    /// iterator for JSON arrays
+    typename BasicJsonType::array_t::iterator array_iterator {};
+    /// generic iterator for all other types
+    primitive_iterator_t primitive_iterator {};
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/iterators/iter_impl.hpp>
+
+
+#include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next
+#include <type_traits> // conditional, is_const, remove_const
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/iterators/internal_iterator.hpp>
+
+// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+// forward declare, to be able to friend it later on
+template<typename IteratorType> class iteration_proxy;
+template<typename IteratorType> class iteration_proxy_value;
+
+/*!
+@brief a template for a bidirectional iterator for the @ref basic_json class
+This class implements a both iterators (iterator and const_iterator) for the
+@ref basic_json class.
+@note An iterator is called *initialized* when a pointer to a JSON value has
+      been set (e.g., by a constructor or a copy assignment). If the iterator is
+      default-constructed, it is *uninitialized* and most methods are undefined.
+      **The library uses assertions to detect calls on uninitialized iterators.**
+@requirement The class satisfies the following concept requirements:
+-
+[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
+  The iterator that can be moved can be moved in both directions (i.e.
+  incremented and decremented).
+@since version 1.0.0, simplified in version 2.0.9, change to bidirectional
+       iterators in version 3.0.0 (see https://github.com/nlohmann/json/issues/593)
+*/
+template<typename BasicJsonType>
+class iter_impl
+{
+    /// allow basic_json to access private members
+    friend iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value, typename std::remove_const<BasicJsonType>::type, const BasicJsonType>::type>;
+    friend BasicJsonType;
+    friend iteration_proxy<iter_impl>;
+    friend iteration_proxy_value<iter_impl>;
+
+    using object_t = typename BasicJsonType::object_t;
+    using array_t = typename BasicJsonType::array_t;
+    // make sure BasicJsonType is basic_json or const basic_json
+    static_assert(is_basic_json<typename std::remove_const<BasicJsonType>::type>::value,
+                  "iter_impl only accepts (const) basic_json");
+
+  public:
+
+    /// The std::iterator class template (used as a base class to provide typedefs) is deprecated in C++17.
+    /// The C++ Standard has never required user-defined iterators to derive from std::iterator.
+    /// A user-defined iterator should provide publicly accessible typedefs named
+    /// iterator_category, value_type, difference_type, pointer, and reference.
+    /// Note that value_type is required to be non-const, even for constant iterators.
+    using iterator_category = std::bidirectional_iterator_tag;
+
+    /// the type of the values when the iterator is dereferenced
+    using value_type = typename BasicJsonType::value_type;
+    /// a type to represent differences between iterators
+    using difference_type = typename BasicJsonType::difference_type;
+    /// defines a pointer to the type iterated over (value_type)
+    using pointer = typename std::conditional<std::is_const<BasicJsonType>::value,
+          typename BasicJsonType::const_pointer,
+          typename BasicJsonType::pointer>::type;
+    /// defines a reference to the type iterated over (value_type)
+    using reference =
+        typename std::conditional<std::is_const<BasicJsonType>::value,
+        typename BasicJsonType::const_reference,
+        typename BasicJsonType::reference>::type;
+
+    /// default constructor
+    iter_impl() = default;
+
+    /*!
+    @brief constructor for a given JSON instance
+    @param[in] object  pointer to a JSON object for this iterator
+    @pre object != nullptr
+    @post The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    explicit iter_impl(pointer object) noexcept : m_object(object)
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                m_it.object_iterator = typename object_t::iterator();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_it.array_iterator = typename array_t::iterator();
+                break;
+            }
+
+            default:
+            {
+                m_it.primitive_iterator = primitive_iterator_t();
+                break;
+            }
+        }
+    }
+
+    /*!
+    @note The conventional copy constructor and copy assignment are implicitly
+          defined. Combined with the following converting constructor and
+          assignment, they support: (1) copy from iterator to iterator, (2)
+          copy from const iterator to const iterator, and (3) conversion from
+          iterator to const iterator. However conversion from const iterator
+          to iterator is not defined.
+    */
+
+    /*!
+    @brief const copy constructor
+    @param[in] other const iterator to copy from
+    @note This copy constructor had to be defined explicitly to circumvent a bug
+          occurring on msvc v19.0 compiler (VS 2015) debug build. For more
+          information refer to: https://github.com/nlohmann/json/issues/1608
+    */
+    iter_impl(const iter_impl<const BasicJsonType>& other) noexcept
+        : m_object(other.m_object), m_it(other.m_it)
+    {}
+
+    /*!
+    @brief converting assignment
+    @param[in] other const iterator to copy from
+    @return const/non-const iterator
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl& operator=(const iter_impl<const BasicJsonType>& other) noexcept
+    {
+        m_object = other.m_object;
+        m_it = other.m_it;
+        return *this;
+    }
+
+    /*!
+    @brief converting constructor
+    @param[in] other  non-const iterator to copy from
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
+        : m_object(other.m_object), m_it(other.m_it)
+    {}
+
+    /*!
+    @brief converting assignment
+    @param[in] other  non-const iterator to copy from
+    @return const/non-const iterator
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl& operator=(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
+    {
+        m_object = other.m_object;
+        m_it = other.m_it;
+        return *this;
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /*!
+    @brief set the iterator to the first value
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    void set_begin() noexcept
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                m_it.object_iterator = m_object->m_value.object->begin();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_it.array_iterator = m_object->m_value.array->begin();
+                break;
+            }
+
+            case value_t::null:
+            {
+                // set to end so begin()==end() is true: null is empty
+                m_it.primitive_iterator.set_end();
+                break;
+            }
+
+            default:
+            {
+                m_it.primitive_iterator.set_begin();
+                break;
+            }
+        }
+    }
+
+    /*!
+    @brief set the iterator past the last value
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    void set_end() noexcept
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                m_it.object_iterator = m_object->m_value.object->end();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_it.array_iterator = m_object->m_value.array->end();
+                break;
+            }
+
+            default:
+            {
+                m_it.primitive_iterator.set_end();
+                break;
+            }
+        }
+    }
+
+  public:
+    /*!
+    @brief return a reference to the value pointed to by the iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference operator*() const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
+                return m_it.object_iterator->second;
+            }
+
+            case value_t::array:
+            {
+                JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
+                return *m_it.array_iterator;
+            }
+
+            case value_t::null:
+                JSON_THROW(invalid_iterator::create(214, "cannot get value"));
+
+            default:
+            {
+                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
+                {
+                    return *m_object;
+                }
+
+                JSON_THROW(invalid_iterator::create(214, "cannot get value"));
+            }
+        }
+    }
+
+    /*!
+    @brief dereference the iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    pointer operator->() const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
+                return &(m_it.object_iterator->second);
+            }
+
+            case value_t::array:
+            {
+                JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
+                return &*m_it.array_iterator;
+            }
+
+            default:
+            {
+                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
+                {
+                    return m_object;
+                }
+
+                JSON_THROW(invalid_iterator::create(214, "cannot get value"));
+            }
+        }
+    }
+
+    /*!
+    @brief post-increment (it++)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl const operator++(int)
+    {
+        auto result = *this;
+        ++(*this);
+        return result;
+    }
+
+    /*!
+    @brief pre-increment (++it)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator++()
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                std::advance(m_it.object_iterator, 1);
+                break;
+            }
+
+            case value_t::array:
+            {
+                std::advance(m_it.array_iterator, 1);
+                break;
+            }
+
+            default:
+            {
+                ++m_it.primitive_iterator;
+                break;
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    @brief post-decrement (it--)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl const operator--(int)
+    {
+        auto result = *this;
+        --(*this);
+        return result;
+    }
+
+    /*!
+    @brief pre-decrement (--it)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator--()
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                std::advance(m_it.object_iterator, -1);
+                break;
+            }
+
+            case value_t::array:
+            {
+                std::advance(m_it.array_iterator, -1);
+                break;
+            }
+
+            default:
+            {
+                --m_it.primitive_iterator;
+                break;
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    @brief  comparison: equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator==(const iter_impl& other) const
+    {
+        // if objects are not the same, the comparison is undefined
+        if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
+        }
+
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+                return (m_it.object_iterator == other.m_it.object_iterator);
+
+            case value_t::array:
+                return (m_it.array_iterator == other.m_it.array_iterator);
+
+            default:
+                return (m_it.primitive_iterator == other.m_it.primitive_iterator);
+        }
+    }
+
+    /*!
+    @brief  comparison: not equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator!=(const iter_impl& other) const
+    {
+        return !operator==(other);
+    }
+
+    /*!
+    @brief  comparison: smaller
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator<(const iter_impl& other) const
+    {
+        // if objects are not the same, the comparison is undefined
+        if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
+        }
+
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(213, "cannot compare order of object iterators"));
+
+            case value_t::array:
+                return (m_it.array_iterator < other.m_it.array_iterator);
+
+            default:
+                return (m_it.primitive_iterator < other.m_it.primitive_iterator);
+        }
+    }
+
+    /*!
+    @brief  comparison: less than or equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator<=(const iter_impl& other) const
+    {
+        return !other.operator < (*this);
+    }
+
+    /*!
+    @brief  comparison: greater than
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator>(const iter_impl& other) const
+    {
+        return !operator<=(other);
+    }
+
+    /*!
+    @brief  comparison: greater than or equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator>=(const iter_impl& other) const
+    {
+        return !operator<(other);
+    }
+
+    /*!
+    @brief  add to iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator+=(difference_type i)
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators"));
+
+            case value_t::array:
+            {
+                std::advance(m_it.array_iterator, i);
+                break;
+            }
+
+            default:
+            {
+                m_it.primitive_iterator += i;
+                break;
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    @brief  subtract from iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator-=(difference_type i)
+    {
+        return operator+=(-i);
+    }
+
+    /*!
+    @brief  add to iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator+(difference_type i) const
+    {
+        auto result = *this;
+        result += i;
+        return result;
+    }
+
+    /*!
+    @brief  addition of distance and iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    friend iter_impl operator+(difference_type i, const iter_impl& it)
+    {
+        auto result = it;
+        result += i;
+        return result;
+    }
+
+    /*!
+    @brief  subtract from iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator-(difference_type i) const
+    {
+        auto result = *this;
+        result -= i;
+        return result;
+    }
+
+    /*!
+    @brief  return difference
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    difference_type operator-(const iter_impl& other) const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators"));
+
+            case value_t::array:
+                return m_it.array_iterator - other.m_it.array_iterator;
+
+            default:
+                return m_it.primitive_iterator - other.m_it.primitive_iterator;
+        }
+    }
+
+    /*!
+    @brief  access to successor
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference operator[](difference_type n) const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(208, "cannot use operator[] for object iterators"));
+
+            case value_t::array:
+                return *std::next(m_it.array_iterator, n);
+
+            case value_t::null:
+                JSON_THROW(invalid_iterator::create(214, "cannot get value"));
+
+            default:
+            {
+                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.get_value() == -n))
+                {
+                    return *m_object;
+                }
+
+                JSON_THROW(invalid_iterator::create(214, "cannot get value"));
+            }
+        }
+    }
+
+    /*!
+    @brief  return the key of an object iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    const typename object_t::key_type& key() const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        if (JSON_HEDLEY_LIKELY(m_object->is_object()))
+        {
+            return m_it.object_iterator->first;
+        }
+
+        JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators"));
+    }
+
+    /*!
+    @brief  return the value of an iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference value() const
+    {
+        return operator*();
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /// associated JSON instance
+    pointer m_object = nullptr;
+    /// the actual iterator of the associated instance
+    internal_iterator<typename std::remove_const<BasicJsonType>::type> m_it {};
+};
+} // namespace detail
+} // namespace nlohmann
+
+// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
+
+// #include <nlohmann/detail/iterators/json_reverse_iterator.hpp>
+
+
+#include <cstddef> // ptrdiff_t
+#include <iterator> // reverse_iterator
+#include <utility> // declval
+
+namespace nlohmann
+{
+namespace detail
+{
+//////////////////////
+// reverse_iterator //
+//////////////////////
+
+/*!
+@brief a template for a reverse iterator class
+
+@tparam Base the base iterator type to reverse. Valid types are @ref
+iterator (to create @ref reverse_iterator) and @ref const_iterator (to
+create @ref const_reverse_iterator).
+
+@requirement The class satisfies the following concept requirements:
+-
+[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
+  The iterator that can be moved can be moved in both directions (i.e.
+  incremented and decremented).
+- [OutputIterator](https://en.cppreference.com/w/cpp/named_req/OutputIterator):
+  It is possible to write to the pointed-to element (only if @a Base is
+  @ref iterator).
+
+@since version 1.0.0
+*/
+template<typename Base>
+class json_reverse_iterator : public std::reverse_iterator<Base>
+{
+  public:
+    using difference_type = std::ptrdiff_t;
+    /// shortcut to the reverse iterator adapter
+    using base_iterator = std::reverse_iterator<Base>;
+    /// the reference type for the pointed-to element
+    using reference = typename Base::reference;
+
+    /// create reverse iterator from iterator
+    explicit json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept
+        : base_iterator(it) {}
+
+    /// create reverse iterator from base class
+    explicit json_reverse_iterator(const base_iterator& it) noexcept : base_iterator(it) {}
+
+    /// post-increment (it++)
+    json_reverse_iterator const operator++(int)
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator++(1));
+    }
+
+    /// pre-increment (++it)
+    json_reverse_iterator& operator++()
+    {
+        return static_cast<json_reverse_iterator&>(base_iterator::operator++());
+    }
+
+    /// post-decrement (it--)
+    json_reverse_iterator const operator--(int)
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator--(1));
+    }
+
+    /// pre-decrement (--it)
+    json_reverse_iterator& operator--()
+    {
+        return static_cast<json_reverse_iterator&>(base_iterator::operator--());
+    }
+
+    /// add to iterator
+    json_reverse_iterator& operator+=(difference_type i)
+    {
+        return static_cast<json_reverse_iterator&>(base_iterator::operator+=(i));
+    }
+
+    /// add to iterator
+    json_reverse_iterator operator+(difference_type i) const
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator+(i));
+    }
+
+    /// subtract from iterator
+    json_reverse_iterator operator-(difference_type i) const
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator-(i));
+    }
+
+    /// return difference
+    difference_type operator-(const json_reverse_iterator& other) const
+    {
+        return base_iterator(*this) - base_iterator(other);
+    }
+
+    /// access to successor
+    reference operator[](difference_type n) const
+    {
+        return *(this->operator+(n));
+    }
+
+    /// return the key of an object iterator
+    auto key() const -> decltype(std::declval<Base>().key())
+    {
+        auto it = --this->base();
+        return it.key();
+    }
+
+    /// return the value of an iterator
+    reference value() const
+    {
+        auto it = --this->base();
+        return it.operator * ();
+    }
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
+
+// #include <nlohmann/detail/json_pointer.hpp>
+
+
+#include <algorithm> // all_of
+#include <cctype> // isdigit
+#include <limits> // max
+#include <numeric> // accumulate
+#include <string> // string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+template<typename BasicJsonType>
+class json_pointer
+{
+    // allow basic_json to access private members
+    NLOHMANN_BASIC_JSON_TPL_DECLARATION
+    friend class basic_json;
+
+  public:
+    /*!
+    @brief create JSON pointer
+
+    Create a JSON pointer according to the syntax described in
+    [Section 3 of RFC6901](https://tools.ietf.org/html/rfc6901#section-3).
+
+    @param[in] s  string representing the JSON pointer; if omitted, the empty
+                  string is assumed which references the whole JSON value
+
+    @throw parse_error.107 if the given JSON pointer @a s is nonempty and does
+                           not begin with a slash (`/`); see example below
+
+    @throw parse_error.108 if a tilde (`~`) in the given JSON pointer @a s is
+    not followed by `0` (representing `~`) or `1` (representing `/`); see
+    example below
+
+    @liveexample{The example shows the construction several valid JSON pointers
+    as well as the exceptional behavior.,json_pointer}
+
+    @since version 2.0.0
+    */
+    explicit json_pointer(const std::string& s = "")
+        : reference_tokens(split(s))
+    {}
+
+    /*!
+    @brief return a string representation of the JSON pointer
+
+    @invariant For each JSON pointer `ptr`, it holds:
+    @code {.cpp}
+    ptr == json_pointer(ptr.to_string());
+    @endcode
+
+    @return a string representation of the JSON pointer
+
+    @liveexample{The example shows the result of `to_string`.,json_pointer__to_string}
+
+    @since version 2.0.0
+    */
+    std::string to_string() const
+    {
+        return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
+                               std::string{},
+                               [](const std::string & a, const std::string & b)
+        {
+            return a + "/" + escape(b);
+        });
+    }
+
+    /// @copydoc to_string()
+    operator std::string() const
+    {
+        return to_string();
+    }
+
+    /*!
+    @brief append another JSON pointer at the end of this JSON pointer
+
+    @param[in] ptr  JSON pointer to append
+    @return JSON pointer with @a ptr appended
+
+    @liveexample{The example shows the usage of `operator/=`.,json_pointer__operator_add}
+
+    @complexity Linear in the length of @a ptr.
+
+    @sa @ref operator/=(std::string) to append a reference token
+    @sa @ref operator/=(std::size_t) to append an array index
+    @sa @ref operator/(const json_pointer&, const json_pointer&) for a binary operator
+
+    @since version 3.6.0
+    */
+    json_pointer& operator/=(const json_pointer& ptr)
+    {
+        reference_tokens.insert(reference_tokens.end(),
+                                ptr.reference_tokens.begin(),
+                                ptr.reference_tokens.end());
+        return *this;
+    }
+
+    /*!
+    @brief append an unescaped reference token at the end of this JSON pointer
+
+    @param[in] token  reference token to append
+    @return JSON pointer with @a token appended without escaping @a token
+
+    @liveexample{The example shows the usage of `operator/=`.,json_pointer__operator_add}
+
+    @complexity Amortized constant.
+
+    @sa @ref operator/=(const json_pointer&) to append a JSON pointer
+    @sa @ref operator/=(std::size_t) to append an array index
+    @sa @ref operator/(const json_pointer&, std::size_t) for a binary operator
+
+    @since version 3.6.0
+    */
+    json_pointer& operator/=(std::string token)
+    {
+        push_back(std::move(token));
+        return *this;
+    }
+
+    /*!
+    @brief append an array index at the end of this JSON pointer
+
+    @param[in] array_idx  array index to append
+    @return JSON pointer with @a array_idx appended
+
+    @liveexample{The example shows the usage of `operator/=`.,json_pointer__operator_add}
+
+    @complexity Amortized constant.
+
+    @sa @ref operator/=(const json_pointer&) to append a JSON pointer
+    @sa @ref operator/=(std::string) to append a reference token
+    @sa @ref operator/(const json_pointer&, std::string) for a binary operator
+
+    @since version 3.6.0
+    */
+    json_pointer& operator/=(std::size_t array_idx)
+    {
+        return *this /= std::to_string(array_idx);
+    }
+
+    /*!
+    @brief create a new JSON pointer by appending the right JSON pointer at the end of the left JSON pointer
+
+    @param[in] lhs  JSON pointer
+    @param[in] rhs  JSON pointer
+    @return a new JSON pointer with @a rhs appended to @a lhs
+
+    @liveexample{The example shows the usage of `operator/`.,json_pointer__operator_add_binary}
+
+    @complexity Linear in the length of @a lhs and @a rhs.
+
+    @sa @ref operator/=(const json_pointer&) to append a JSON pointer
+
+    @since version 3.6.0
+    */
+    friend json_pointer operator/(const json_pointer& lhs,
+                                  const json_pointer& rhs)
+    {
+        return json_pointer(lhs) /= rhs;
+    }
+
+    /*!
+    @brief create a new JSON pointer by appending the unescaped token at the end of the JSON pointer
+
+    @param[in] ptr  JSON pointer
+    @param[in] token  reference token
+    @return a new JSON pointer with unescaped @a token appended to @a ptr
+
+    @liveexample{The example shows the usage of `operator/`.,json_pointer__operator_add_binary}
+
+    @complexity Linear in the length of @a ptr.
+
+    @sa @ref operator/=(std::string) to append a reference token
+
+    @since version 3.6.0
+    */
+    friend json_pointer operator/(const json_pointer& ptr, std::string token)
+    {
+        return json_pointer(ptr) /= std::move(token);
+    }
+
+    /*!
+    @brief create a new JSON pointer by appending the array-index-token at the end of the JSON pointer
+
+    @param[in] ptr  JSON pointer
+    @param[in] array_idx  array index
+    @return a new JSON pointer with @a array_idx appended to @a ptr
+
+    @liveexample{The example shows the usage of `operator/`.,json_pointer__operator_add_binary}
+
+    @complexity Linear in the length of @a ptr.
+
+    @sa @ref operator/=(std::size_t) to append an array index
+
+    @since version 3.6.0
+    */
+    friend json_pointer operator/(const json_pointer& ptr, std::size_t array_idx)
+    {
+        return json_pointer(ptr) /= array_idx;
+    }
+
+    /*!
+    @brief returns the parent of this JSON pointer
+
+    @return parent of this JSON pointer; in case this JSON pointer is the root,
+            the root itself is returned
+
+    @complexity Linear in the length of the JSON pointer.
+
+    @liveexample{The example shows the result of `parent_pointer` for different
+    JSON Pointers.,json_pointer__parent_pointer}
+
+    @since version 3.6.0
+    */
+    json_pointer parent_pointer() const
+    {
+        if (empty())
+        {
+            return *this;
+        }
+
+        json_pointer res = *this;
+        res.pop_back();
+        return res;
+    }
+
+    /*!
+    @brief remove last reference token
+
+    @pre not `empty()`
+
+    @liveexample{The example shows the usage of `pop_back`.,json_pointer__pop_back}
+
+    @complexity Constant.
+
+    @throw out_of_range.405 if JSON pointer has no parent
+
+    @since version 3.6.0
+    */
+    void pop_back()
+    {
+        if (JSON_HEDLEY_UNLIKELY(empty()))
+        {
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
+        }
+
+        reference_tokens.pop_back();
+    }
+
+    /*!
+    @brief return last reference token
+
+    @pre not `empty()`
+    @return last reference token
+
+    @liveexample{The example shows the usage of `back`.,json_pointer__back}
+
+    @complexity Constant.
+
+    @throw out_of_range.405 if JSON pointer has no parent
+
+    @since version 3.6.0
+    */
+    const std::string& back() const
+    {
+        if (JSON_HEDLEY_UNLIKELY(empty()))
+        {
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
+        }
+
+        return reference_tokens.back();
+    }
+
+    /*!
+    @brief append an unescaped token at the end of the reference pointer
+
+    @param[in] token  token to add
+
+    @complexity Amortized constant.
+
+    @liveexample{The example shows the result of `push_back` for different
+    JSON Pointers.,json_pointer__push_back}
+
+    @since version 3.6.0
+    */
+    void push_back(const std::string& token)
+    {
+        reference_tokens.push_back(token);
+    }
+
+    /// @copydoc push_back(const std::string&)
+    void push_back(std::string&& token)
+    {
+        reference_tokens.push_back(std::move(token));
+    }
+
+    /*!
+    @brief return whether pointer points to the root document
+
+    @return true iff the JSON pointer points to the root document
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @liveexample{The example shows the result of `empty` for different JSON
+    Pointers.,json_pointer__empty}
+
+    @since version 3.6.0
+    */
+    bool empty() const noexcept
+    {
+        return reference_tokens.empty();
+    }
+
+  private:
+    /*!
+    @param[in] s  reference token to be converted into an array index
+
+    @return integer representation of @a s
+
+    @throw parse_error.106  if an array index begins with '0'
+    @throw parse_error.109  if an array index begins not with a digit
+    @throw out_of_range.404 if string @a s could not be converted to an integer
+    @throw out_of_range.410 if an array index exceeds size_type
+    */
+    static typename BasicJsonType::size_type array_index(const std::string& s)
+    {
+        using size_type = typename BasicJsonType::size_type;
+
+        // error condition (cf. RFC 6901, Sect. 4)
+        if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && s[0] == '0'))
+        {
+            JSON_THROW(detail::parse_error::create(106, 0,
+                                                   "array index '" + s +
+                                                   "' must not begin with '0'"));
+        }
+
+        // error condition (cf. RFC 6901, Sect. 4)
+        if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && !(s[0] >= '1' && s[0] <= '9')))
+        {
+            JSON_THROW(detail::parse_error::create(109, 0, "array index '" + s + "' is not a number"));
+        }
+
+        std::size_t processed_chars = 0;
+        unsigned long long res = 0;
+        JSON_TRY
+        {
+            res = std::stoull(s, &processed_chars);
+        }
+        JSON_CATCH(std::out_of_range&)
+        {
+            JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'"));
+        }
+
+        // check if the string was completely read
+        if (JSON_HEDLEY_UNLIKELY(processed_chars != s.size()))
+        {
+            JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'"));
+        }
+
+        // only triggered on special platforms (like 32bit), see also
+        // https://github.com/nlohmann/json/pull/2203
+        if (res >= static_cast<unsigned long long>((std::numeric_limits<size_type>::max)()))
+        {
+            JSON_THROW(detail::out_of_range::create(410, "array index " + s + " exceeds size_type")); // LCOV_EXCL_LINE
+        }
+
+        return static_cast<size_type>(res);
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    json_pointer top() const
+    {
+        if (JSON_HEDLEY_UNLIKELY(empty()))
+        {
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
+        }
+
+        json_pointer result = *this;
+        result.reference_tokens = {reference_tokens[0]};
+        return result;
+    }
+
+  private:
+    /*!
+    @brief create and return a reference to the pointed to value
+
+    @complexity Linear in the number of reference tokens.
+
+    @throw parse_error.109 if array index is not a number
+    @throw type_error.313 if value cannot be unflattened
+    */
+    BasicJsonType& get_and_create(BasicJsonType& j) const
+    {
+        auto result = &j;
+
+        // in case no reference tokens exist, return a reference to the JSON value
+        // j which will be overwritten by a primitive value
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (result->type())
+            {
+                case detail::value_t::null:
+                {
+                    if (reference_token == "0")
+                    {
+                        // start a new array if reference token is 0
+                        result = &result->operator[](0);
+                    }
+                    else
+                    {
+                        // start a new object otherwise
+                        result = &result->operator[](reference_token);
+                    }
+                    break;
+                }
+
+                case detail::value_t::object:
+                {
+                    // create an entry in the object
+                    result = &result->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    // create an entry in the array
+                    result = &result->operator[](array_index(reference_token));
+                    break;
+                }
+
+                /*
+                The following code is only reached if there exists a reference
+                token _and_ the current value is primitive. In this case, we have
+                an error situation, because primitive values may only occur as
+                single value; that is, with an empty list of reference tokens.
+                */
+                default:
+                    JSON_THROW(detail::type_error::create(313, "invalid value to unflatten"));
+            }
+        }
+
+        return *result;
+    }
+
+    /*!
+    @brief return a reference to the pointed to value
+
+    @note This version does not throw if a value is not present, but tries to
+          create nested values instead. For instance, calling this function
+          with pointer `"/this/that"` on a null value is equivalent to calling
+          `operator[]("this").operator[]("that")` on that value, effectively
+          changing the null value to an object.
+
+    @param[in] ptr  a JSON value
+
+    @return reference to the JSON value pointed to by the JSON pointer
+
+    @complexity Linear in the length of the JSON pointer.
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    BasicJsonType& get_unchecked(BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            // convert null values to arrays or objects before continuing
+            if (ptr->is_null())
+            {
+                // check if reference token is a number
+                const bool nums =
+                    std::all_of(reference_token.begin(), reference_token.end(),
+                                [](const unsigned char x)
+                {
+                    return std::isdigit(x);
+                });
+
+                // change value to array for numbers or "-" or to object otherwise
+                *ptr = (nums || reference_token == "-")
+                       ? detail::value_t::array
+                       : detail::value_t::object;
+            }
+
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // use unchecked object access
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (reference_token == "-")
+                    {
+                        // explicitly treat "-" as index beyond the end
+                        ptr = &ptr->operator[](ptr->m_value.array->size());
+                    }
+                    else
+                    {
+                        // convert array index to number; unchecked access
+                        ptr = &ptr->operator[](array_index(reference_token));
+                    }
+                    break;
+                }
+
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    BasicJsonType& get_checked(BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // note: at performs range check
+                    ptr = &ptr->at(reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" always fails the range check
+                        JSON_THROW(detail::out_of_range::create(402,
+                                                                "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
+                                                                ") is out of range"));
+                    }
+
+                    // note: at performs range check
+                    ptr = &ptr->at(array_index(reference_token));
+                    break;
+                }
+
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @brief return a const reference to the pointed to value
+
+    @param[in] ptr  a JSON value
+
+    @return const reference to the JSON value pointed to by the JSON
+    pointer
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // use unchecked object access
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" cannot be used for const access
+                        JSON_THROW(detail::out_of_range::create(402,
+                                                                "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
+                                                                ") is out of range"));
+                    }
+
+                    // use unchecked array access
+                    ptr = &ptr->operator[](array_index(reference_token));
+                    break;
+                }
+
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    const BasicJsonType& get_checked(const BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // note: at performs range check
+                    ptr = &ptr->at(reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" always fails the range check
+                        JSON_THROW(detail::out_of_range::create(402,
+                                                                "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
+                                                                ") is out of range"));
+                    }
+
+                    // note: at performs range check
+                    ptr = &ptr->at(array_index(reference_token));
+                    break;
+                }
+
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    */
+    bool contains(const BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    if (!ptr->contains(reference_token))
+                    {
+                        // we did not find the key in the object
+                        return false;
+                    }
+
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" always fails the range check
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !("0" <= reference_token && reference_token <= "9")))
+                    {
+                        // invalid char
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1))
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!('1' <= reference_token[0] && reference_token[0] <= '9')))
+                        {
+                            // first char should be between '1' and '9'
+                            return false;
+                        }
+                        for (std::size_t i = 1; i < reference_token.size(); i++)
+                        {
+                            if (JSON_HEDLEY_UNLIKELY(!('0' <= reference_token[i] && reference_token[i] <= '9')))
+                            {
+                                // other char should be between '0' and '9'
+                                return false;
+                            }
+                        }
+                    }
+
+                    const auto idx = array_index(reference_token);
+                    if (idx >= ptr->size())
+                    {
+                        // index out of range
+                        return false;
+                    }
+
+                    ptr = &ptr->operator[](idx);
+                    break;
+                }
+
+                default:
+                {
+                    // we do not expect primitive values if there is still a
+                    // reference token to process
+                    return false;
+                }
+            }
+        }
+
+        // no reference token left means we found a primitive value
+        return true;
+    }
+
+    /*!
+    @brief split the string input to reference tokens
+
+    @note This function is only called by the json_pointer constructor.
+          All exceptions below are documented there.
+
+    @throw parse_error.107  if the pointer is not empty or begins with '/'
+    @throw parse_error.108  if character '~' is not followed by '0' or '1'
+    */
+    static std::vector<std::string> split(const std::string& reference_string)
+    {
+        std::vector<std::string> result;
+
+        // special case: empty reference string -> no reference tokens
+        if (reference_string.empty())
+        {
+            return result;
+        }
+
+        // check if nonempty reference string begins with slash
+        if (JSON_HEDLEY_UNLIKELY(reference_string[0] != '/'))
+        {
+            JSON_THROW(detail::parse_error::create(107, 1,
+                                                   "JSON pointer must be empty or begin with '/' - was: '" +
+                                                   reference_string + "'"));
+        }
+
+        // extract the reference tokens:
+        // - slash: position of the last read slash (or end of string)
+        // - start: position after the previous slash
+        for (
+            // search for the first slash after the first character
+            std::size_t slash = reference_string.find_first_of('/', 1),
+            // set the beginning of the first reference token
+            start = 1;
+            // we can stop if start == 0 (if slash == std::string::npos)
+            start != 0;
+            // set the beginning of the next reference token
+            // (will eventually be 0 if slash == std::string::npos)
+            start = (slash == std::string::npos) ? 0 : slash + 1,
+            // find next slash
+            slash = reference_string.find_first_of('/', start))
+        {
+            // use the text between the beginning of the reference token
+            // (start) and the last slash (slash).
+            auto reference_token = reference_string.substr(start, slash - start);
+
+            // check reference tokens are properly escaped
+            for (std::size_t pos = reference_token.find_first_of('~');
+                    pos != std::string::npos;
+                    pos = reference_token.find_first_of('~', pos + 1))
+            {
+                JSON_ASSERT(reference_token[pos] == '~');
+
+                // ~ must be followed by 0 or 1
+                if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 ||
+                                         (reference_token[pos + 1] != '0' &&
+                                          reference_token[pos + 1] != '1')))
+                {
+                    JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'"));
+                }
+            }
+
+            // finally, store the reference token
+            unescape(reference_token);
+            result.push_back(reference_token);
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief replace all occurrences of a substring by another string
+
+    @param[in,out] s  the string to manipulate; changed so that all
+                   occurrences of @a f are replaced with @a t
+    @param[in]     f  the substring to replace with @a t
+    @param[in]     t  the string to replace @a f
+
+    @pre The search string @a f must not be empty. **This precondition is
+    enforced with an assertion.**
+
+    @since version 2.0.0
+    */
+    static void replace_substring(std::string& s, const std::string& f,
+                                  const std::string& t)
+    {
+        JSON_ASSERT(!f.empty());
+        for (auto pos = s.find(f);                // find first occurrence of f
+                pos != std::string::npos;         // make sure f was found
+                s.replace(pos, f.size(), t),      // replace with t, and
+                pos = s.find(f, pos + t.size()))  // find next occurrence of f
+        {}
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /// escape "~" to "~0" and "/" to "~1"
+    static std::string escape(std::string s)
+    {
+        replace_substring(s, "~", "~0");
+        replace_substring(s, "/", "~1");
+        return s;
+    }
+
+    /// unescape "~1" to tilde and "~0" to slash (order is important!)
+    static void unescape(std::string& s)
+    {
+        replace_substring(s, "~1", "/");
+        replace_substring(s, "~0", "~");
+    }
+
+  private:
+    /*!
+    @param[in] reference_string  the reference string to the current value
+    @param[in] value             the value to consider
+    @param[in,out] result        the result object to insert values to
+
+    @note Empty objects or arrays are flattened to `null`.
+    */
+    static void flatten(const std::string& reference_string,
+                        const BasicJsonType& value,
+                        BasicJsonType& result)
+    {
+        switch (value.type())
+        {
+            case detail::value_t::array:
+            {
+                if (value.m_value.array->empty())
+                {
+                    // flatten empty array as null
+                    result[reference_string] = nullptr;
+                }
+                else
+                {
+                    // iterate array and use index as reference string
+                    for (std::size_t i = 0; i < value.m_value.array->size(); ++i)
+                    {
+                        flatten(reference_string + "/" + std::to_string(i),
+                                value.m_value.array->operator[](i), result);
+                    }
+                }
+                break;
+            }
+
+            case detail::value_t::object:
+            {
+                if (value.m_value.object->empty())
+                {
+                    // flatten empty object as null
+                    result[reference_string] = nullptr;
+                }
+                else
+                {
+                    // iterate object and use keys as reference string
+                    for (const auto& element : *value.m_value.object)
+                    {
+                        flatten(reference_string + "/" + escape(element.first), element.second, result);
+                    }
+                }
+                break;
+            }
+
+            default:
+            {
+                // add primitive value with its reference string
+                result[reference_string] = value;
+                break;
+            }
+        }
+    }
+
+    /*!
+    @param[in] value  flattened JSON
+
+    @return unflattened JSON
+
+    @throw parse_error.109 if array index is not a number
+    @throw type_error.314  if value is not an object
+    @throw type_error.315  if object values are not primitive
+    @throw type_error.313  if value cannot be unflattened
+    */
+    static BasicJsonType
+    unflatten(const BasicJsonType& value)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!value.is_object()))
+        {
+            JSON_THROW(detail::type_error::create(314, "only objects can be unflattened"));
+        }
+
+        BasicJsonType result;
+
+        // iterate the JSON object values
+        for (const auto& element : *value.m_value.object)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!element.second.is_primitive()))
+            {
+                JSON_THROW(detail::type_error::create(315, "values in object must be primitive"));
+            }
+
+            // assign value to reference pointed to by JSON pointer; Note that if
+            // the JSON pointer is "" (i.e., points to the whole value), function
+            // get_and_create returns a reference to result itself. An assignment
+            // will then create a primitive value.
+            json_pointer(element.first).get_and_create(result) = element.second;
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief compares two JSON pointers for equality
+
+    @param[in] lhs  JSON pointer to compare
+    @param[in] rhs  JSON pointer to compare
+    @return whether @a lhs is equal to @a rhs
+
+    @complexity Linear in the length of the JSON pointer
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+    */
+    friend bool operator==(json_pointer const& lhs,
+                           json_pointer const& rhs) noexcept
+    {
+        return lhs.reference_tokens == rhs.reference_tokens;
+    }
+
+    /*!
+    @brief compares two JSON pointers for inequality
+
+    @param[in] lhs  JSON pointer to compare
+    @param[in] rhs  JSON pointer to compare
+    @return whether @a lhs is not equal @a rhs
+
+    @complexity Linear in the length of the JSON pointer
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+    */
+    friend bool operator!=(json_pointer const& lhs,
+                           json_pointer const& rhs) noexcept
+    {
+        return !(lhs == rhs);
+    }
+
+    /// the reference tokens
+    std::vector<std::string> reference_tokens;
+};
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/json_ref.hpp>
+
+
+#include <initializer_list>
+#include <utility>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+template<typename BasicJsonType>
+class json_ref
+{
+  public:
+    using value_type = BasicJsonType;
+
+    json_ref(value_type&& value)
+        : owned_value(std::move(value))
+        , value_ref(&owned_value)
+        , is_rvalue(true)
+    {}
+
+    json_ref(const value_type& value)
+        : value_ref(const_cast<value_type*>(&value))
+        , is_rvalue(false)
+    {}
+
+    json_ref(std::initializer_list<json_ref> init)
+        : owned_value(init)
+        , value_ref(&owned_value)
+        , is_rvalue(true)
+    {}
+
+    template <
+        class... Args,
+        enable_if_t<std::is_constructible<value_type, Args...>::value, int> = 0 >
+    json_ref(Args && ... args)
+        : owned_value(std::forward<Args>(args)...)
+        , value_ref(&owned_value)
+        , is_rvalue(true)
+    {}
+
+    // class should be movable only
+    json_ref(json_ref&&) = default;
+    json_ref(const json_ref&) = delete;
+    json_ref& operator=(const json_ref&) = delete;
+    json_ref& operator=(json_ref&&) = delete;
+    ~json_ref() = default;
+
+    value_type moved_or_copied() const
+    {
+        if (is_rvalue)
+        {
+            return std::move(*value_ref);
+        }
+        return *value_ref;
+    }
+
+    value_type const& operator*() const
+    {
+        return *static_cast<value_type const*>(value_ref);
+    }
+
+    value_type const* operator->() const
+    {
+        return static_cast<value_type const*>(value_ref);
+    }
+
+  private:
+    mutable value_type owned_value = nullptr;
+    value_type* value_ref = nullptr;
+    const bool is_rvalue = true;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/output/binary_writer.hpp>
+
+
+#include <algorithm> // reverse
+#include <array> // array
+#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
+#include <cstring> // memcpy
+#include <limits> // numeric_limits
+#include <string> // string
+#include <cmath> // isnan, isinf
+
+// #include <nlohmann/detail/input/binary_reader.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/output/output_adapters.hpp>
+
+
+#include <algorithm> // copy
+#include <cstddef> // size_t
+#include <ios> // streamsize
+#include <iterator> // back_inserter
+#include <memory> // shared_ptr, make_shared
+#include <ostream> // basic_ostream
+#include <string> // basic_string
+#include <vector> // vector
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+/// abstract output adapter interface
+template<typename CharType> struct output_adapter_protocol
+{
+    virtual void write_character(CharType c) = 0;
+    virtual void write_characters(const CharType* s, std::size_t length) = 0;
+    virtual ~output_adapter_protocol() = default;
+};
+
+/// a type to simplify interfaces
+template<typename CharType>
+using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
+
+/// output adapter for byte vectors
+template<typename CharType>
+class output_vector_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_vector_adapter(std::vector<CharType>& vec) noexcept
+        : v(vec)
+    {}
+
+    void write_character(CharType c) override
+    {
+        v.push_back(c);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        std::copy(s, s + length, std::back_inserter(v));
+    }
+
+  private:
+    std::vector<CharType>& v;
+};
+
+/// output adapter for output streams
+template<typename CharType>
+class output_stream_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_stream_adapter(std::basic_ostream<CharType>& s) noexcept
+        : stream(s)
+    {}
+
+    void write_character(CharType c) override
+    {
+        stream.put(c);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        stream.write(s, static_cast<std::streamsize>(length));
+    }
+
+  private:
+    std::basic_ostream<CharType>& stream;
+};
+
+/// output adapter for basic_string
+template<typename CharType, typename StringType = std::basic_string<CharType>>
+class output_string_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_string_adapter(StringType& s) noexcept
+        : str(s)
+    {}
+
+    void write_character(CharType c) override
+    {
+        str.push_back(c);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        str.append(s, length);
+    }
+
+  private:
+    StringType& str;
+};
+
+template<typename CharType, typename StringType = std::basic_string<CharType>>
+class output_adapter
+{
+  public:
+    output_adapter(std::vector<CharType>& vec)
+        : oa(std::make_shared<output_vector_adapter<CharType>>(vec)) {}
+
+    output_adapter(std::basic_ostream<CharType>& s)
+        : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}
+
+    output_adapter(StringType& s)
+        : oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}
+
+    operator output_adapter_t<CharType>()
+    {
+        return oa;
+    }
+
+  private:
+    output_adapter_t<CharType> oa = nullptr;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+
+namespace nlohmann
+{
+namespace detail
+{
+///////////////////
+// binary writer //
+///////////////////
+
+/*!
+@brief serialization to CBOR and MessagePack values
+*/
+template<typename BasicJsonType, typename CharType>
+class binary_writer
+{
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+
+  public:
+    /*!
+    @brief create a binary writer
+
+    @param[in] adapter  output adapter to write to
+    */
+    explicit binary_writer(output_adapter_t<CharType> adapter) : oa(adapter)
+    {
+        JSON_ASSERT(oa);
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    @pre       j.type() == value_t::object
+    */
+    void write_bson(const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::object:
+            {
+                write_bson_object(*j.m_value.object);
+                break;
+            }
+
+            default:
+            {
+                JSON_THROW(type_error::create(317, "to serialize to BSON, top-level type must be object, but is " + std::string(j.type_name())));
+            }
+        }
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    */
+    void write_cbor(const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::null:
+            {
+                oa->write_character(to_char_type(0xF6));
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                oa->write_character(j.m_value.boolean
+                                    ? to_char_type(0xF5)
+                                    : to_char_type(0xF4));
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                if (j.m_value.number_integer >= 0)
+                {
+                    // CBOR does not differentiate between positive signed
+                    // integers and unsigned integers. Therefore, we used the
+                    // code from the value_t::number_unsigned case here.
+                    if (j.m_value.number_integer <= 0x17)
+                    {
+                        write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x18));
+                        write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x19));
+                        write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x1A));
+                        write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
+                    }
+                    else
+                    {
+                        oa->write_character(to_char_type(0x1B));
+                        write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
+                    }
+                }
+                else
+                {
+                    // The conversions below encode the sign in the first
+                    // byte, and the value is converted to a positive number.
+                    const auto positive_number = -1 - j.m_value.number_integer;
+                    if (j.m_value.number_integer >= -24)
+                    {
+                        write_number(static_cast<std::uint8_t>(0x20 + positive_number));
+                    }
+                    else if (positive_number <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x38));
+                        write_number(static_cast<std::uint8_t>(positive_number));
+                    }
+                    else if (positive_number <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x39));
+                        write_number(static_cast<std::uint16_t>(positive_number));
+                    }
+                    else if (positive_number <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x3A));
+                        write_number(static_cast<std::uint32_t>(positive_number));
+                    }
+                    else
+                    {
+                        oa->write_character(to_char_type(0x3B));
+                        write_number(static_cast<std::uint64_t>(positive_number));
+                    }
+                }
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                if (j.m_value.number_unsigned <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x18));
+                    write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x19));
+                    write_number(static_cast<std::uint16_t>(j.m_value.number_unsigned));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x1A));
+                    write_number(static_cast<std::uint32_t>(j.m_value.number_unsigned));
+                }
+                else
+                {
+                    oa->write_character(to_char_type(0x1B));
+                    write_number(static_cast<std::uint64_t>(j.m_value.number_unsigned));
+                }
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                if (std::isnan(j.m_value.number_float))
+                {
+                    // NaN is 0xf97e00 in CBOR
+                    oa->write_character(to_char_type(0xF9));
+                    oa->write_character(to_char_type(0x7E));
+                    oa->write_character(to_char_type(0x00));
+                }
+                else if (std::isinf(j.m_value.number_float))
+                {
+                    // Infinity is 0xf97c00, -Infinity is 0xf9fc00
+                    oa->write_character(to_char_type(0xf9));
+                    oa->write_character(j.m_value.number_float > 0 ? to_char_type(0x7C) : to_char_type(0xFC));
+                    oa->write_character(to_char_type(0x00));
+                }
+                else
+                {
+                    write_compact_float(j.m_value.number_float, detail::input_format_t::cbor);
+                }
+                break;
+            }
+
+            case value_t::string:
+            {
+                // step 1: write control byte and the string length
+                const auto N = j.m_value.string->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0x60 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x78));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x79));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x7A));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x7B));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write the string
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
+                    j.m_value.string->size());
+                break;
+            }
+
+            case value_t::array:
+            {
+                // step 1: write control byte and the array size
+                const auto N = j.m_value.array->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0x80 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x98));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x99));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x9A));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x9B));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write each element
+                for (const auto& el : *j.m_value.array)
+                {
+                    write_cbor(el);
+                }
+                break;
+            }
+
+            case value_t::binary:
+            {
+                if (j.m_value.binary->has_subtype())
+                {
+                    write_number(static_cast<std::uint8_t>(0xd8));
+                    write_number(j.m_value.binary->subtype());
+                }
+
+                // step 1: write control byte and the binary array size
+                const auto N = j.m_value.binary->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0x40 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x58));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x59));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x5A));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x5B));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write each element
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_value.binary->data()),
+                    N);
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                // step 1: write control byte and the object size
+                const auto N = j.m_value.object->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0xA0 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xB8));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xB9));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xBA));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xBB));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write each element
+                for (const auto& el : *j.m_value.object)
+                {
+                    write_cbor(el.first);
+                    write_cbor(el.second);
+                }
+                break;
+            }
+
+            default:
+                break;
+        }
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    */
+    void write_msgpack(const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::null: // nil
+            {
+                oa->write_character(to_char_type(0xC0));
+                break;
+            }
+
+            case value_t::boolean: // true and false
+            {
+                oa->write_character(j.m_value.boolean
+                                    ? to_char_type(0xC3)
+                                    : to_char_type(0xC2));
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                if (j.m_value.number_integer >= 0)
+                {
+                    // MessagePack does not differentiate between positive
+                    // signed integers and unsigned integers. Therefore, we used
+                    // the code from the value_t::number_unsigned case here.
+                    if (j.m_value.number_unsigned < 128)
+                    {
+                        // positive fixnum
+                        write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        // uint 8
+                        oa->write_character(to_char_type(0xCC));
+                        write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        // uint 16
+                        oa->write_character(to_char_type(0xCD));
+                        write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        // uint 32
+                        oa->write_character(to_char_type(0xCE));
+                        write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
+                    {
+                        // uint 64
+                        oa->write_character(to_char_type(0xCF));
+                        write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
+                    }
+                }
+                else
+                {
+                    if (j.m_value.number_integer >= -32)
+                    {
+                        // negative fixnum
+                        write_number(static_cast<std::int8_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
+                             j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
+                    {
+                        // int 8
+                        oa->write_character(to_char_type(0xD0));
+                        write_number(static_cast<std::int8_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
+                             j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
+                    {
+                        // int 16
+                        oa->write_character(to_char_type(0xD1));
+                        write_number(static_cast<std::int16_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
+                             j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
+                    {
+                        // int 32
+                        oa->write_character(to_char_type(0xD2));
+                        write_number(static_cast<std::int32_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() &&
+                             j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
+                    {
+                        // int 64
+                        oa->write_character(to_char_type(0xD3));
+                        write_number(static_cast<std::int64_t>(j.m_value.number_integer));
+                    }
+                }
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                if (j.m_value.number_unsigned < 128)
+                {
+                    // positive fixnum
+                    write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    // uint 8
+                    oa->write_character(to_char_type(0xCC));
+                    write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // uint 16
+                    oa->write_character(to_char_type(0xCD));
+                    write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // uint 32
+                    oa->write_character(to_char_type(0xCE));
+                    write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    // uint 64
+                    oa->write_character(to_char_type(0xCF));
+                    write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
+                }
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                write_compact_float(j.m_value.number_float, detail::input_format_t::msgpack);
+                break;
+            }
+
+            case value_t::string:
+            {
+                // step 1: write control byte and the string length
+                const auto N = j.m_value.string->size();
+                if (N <= 31)
+                {
+                    // fixstr
+                    write_number(static_cast<std::uint8_t>(0xA0 | N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    // str 8
+                    oa->write_character(to_char_type(0xD9));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // str 16
+                    oa->write_character(to_char_type(0xDA));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // str 32
+                    oa->write_character(to_char_type(0xDB));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 2: write the string
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
+                    j.m_value.string->size());
+                break;
+            }
+
+            case value_t::array:
+            {
+                // step 1: write control byte and the array size
+                const auto N = j.m_value.array->size();
+                if (N <= 15)
+                {
+                    // fixarray
+                    write_number(static_cast<std::uint8_t>(0x90 | N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // array 16
+                    oa->write_character(to_char_type(0xDC));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // array 32
+                    oa->write_character(to_char_type(0xDD));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 2: write each element
+                for (const auto& el : *j.m_value.array)
+                {
+                    write_msgpack(el);
+                }
+                break;
+            }
+
+            case value_t::binary:
+            {
+                // step 0: determine if the binary type has a set subtype to
+                // determine whether or not to use the ext or fixext types
+                const bool use_ext = j.m_value.binary->has_subtype();
+
+                // step 1: write control byte and the byte string length
+                const auto N = j.m_value.binary->size();
+                if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    std::uint8_t output_type{};
+                    bool fixed = true;
+                    if (use_ext)
+                    {
+                        switch (N)
+                        {
+                            case 1:
+                                output_type = 0xD4; // fixext 1
+                                break;
+                            case 2:
+                                output_type = 0xD5; // fixext 2
+                                break;
+                            case 4:
+                                output_type = 0xD6; // fixext 4
+                                break;
+                            case 8:
+                                output_type = 0xD7; // fixext 8
+                                break;
+                            case 16:
+                                output_type = 0xD8; // fixext 16
+                                break;
+                            default:
+                                output_type = 0xC7; // ext 8
+                                fixed = false;
+                                break;
+                        }
+
+                    }
+                    else
+                    {
+                        output_type = 0xC4; // bin 8
+                        fixed = false;
+                    }
+
+                    oa->write_character(to_char_type(output_type));
+                    if (!fixed)
+                    {
+                        write_number(static_cast<std::uint8_t>(N));
+                    }
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    std::uint8_t output_type = use_ext
+                                               ? 0xC8 // ext 16
+                                               : 0xC5; // bin 16
+
+                    oa->write_character(to_char_type(output_type));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    std::uint8_t output_type = use_ext
+                                               ? 0xC9 // ext 32
+                                               : 0xC6; // bin 32
+
+                    oa->write_character(to_char_type(output_type));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 1.5: if this is an ext type, write the subtype
+                if (use_ext)
+                {
+                    write_number(static_cast<std::int8_t>(j.m_value.binary->subtype()));
+                }
+
+                // step 2: write the byte string
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_value.binary->data()),
+                    N);
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                // step 1: write control byte and the object size
+                const auto N = j.m_value.object->size();
+                if (N <= 15)
+                {
+                    // fixmap
+                    write_number(static_cast<std::uint8_t>(0x80 | (N & 0xF)));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // map 16
+                    oa->write_character(to_char_type(0xDE));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // map 32
+                    oa->write_character(to_char_type(0xDF));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 2: write each element
+                for (const auto& el : *j.m_value.object)
+                {
+                    write_msgpack(el.first);
+                    write_msgpack(el.second);
+                }
+                break;
+            }
+
+            default:
+                break;
+        }
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    @param[in] use_count   whether to use '#' prefixes (optimized format)
+    @param[in] use_type    whether to use '$' prefixes (optimized format)
+    @param[in] add_prefix  whether prefixes need to be used for this value
+    */
+    void write_ubjson(const BasicJsonType& j, const bool use_count,
+                      const bool use_type, const bool add_prefix = true)
+    {
+        switch (j.type())
+        {
+            case value_t::null:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('Z'));
+                }
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(j.m_value.boolean
+                                        ? to_char_type('T')
+                                        : to_char_type('F'));
+                }
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                write_number_with_ubjson_prefix(j.m_value.number_integer, add_prefix);
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                write_number_with_ubjson_prefix(j.m_value.number_unsigned, add_prefix);
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                write_number_with_ubjson_prefix(j.m_value.number_float, add_prefix);
+                break;
+            }
+
+            case value_t::string:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('S'));
+                }
+                write_number_with_ubjson_prefix(j.m_value.string->size(), true);
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
+                    j.m_value.string->size());
+                break;
+            }
+
+            case value_t::array:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('['));
+                }
+
+                bool prefix_required = true;
+                if (use_type && !j.m_value.array->empty())
+                {
+                    JSON_ASSERT(use_count);
+                    const CharType first_prefix = ubjson_prefix(j.front());
+                    const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
+                                                         [this, first_prefix](const BasicJsonType & v)
+                    {
+                        return ubjson_prefix(v) == first_prefix;
+                    });
+
+                    if (same_prefix)
+                    {
+                        prefix_required = false;
+                        oa->write_character(to_char_type('$'));
+                        oa->write_character(first_prefix);
+                    }
+                }
+
+                if (use_count)
+                {
+                    oa->write_character(to_char_type('#'));
+                    write_number_with_ubjson_prefix(j.m_value.array->size(), true);
+                }
+
+                for (const auto& el : *j.m_value.array)
+                {
+                    write_ubjson(el, use_count, use_type, prefix_required);
+                }
+
+                if (!use_count)
+                {
+                    oa->write_character(to_char_type(']'));
+                }
+
+                break;
+            }
+
+            case value_t::binary:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('['));
+                }
+
+                if (use_type && !j.m_value.binary->empty())
+                {
+                    JSON_ASSERT(use_count);
+                    oa->write_character(to_char_type('$'));
+                    oa->write_character('U');
+                }
+
+                if (use_count)
+                {
+                    oa->write_character(to_char_type('#'));
+                    write_number_with_ubjson_prefix(j.m_value.binary->size(), true);
+                }
+
+                if (use_type)
+                {
+                    oa->write_characters(
+                        reinterpret_cast<const CharType*>(j.m_value.binary->data()),
+                        j.m_value.binary->size());
+                }
+                else
+                {
+                    for (size_t i = 0; i < j.m_value.binary->size(); ++i)
+                    {
+                        oa->write_character(to_char_type('U'));
+                        oa->write_character(j.m_value.binary->data()[i]);
+                    }
+                }
+
+                if (!use_count)
+                {
+                    oa->write_character(to_char_type(']'));
+                }
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('{'));
+                }
+
+                bool prefix_required = true;
+                if (use_type && !j.m_value.object->empty())
+                {
+                    JSON_ASSERT(use_count);
+                    const CharType first_prefix = ubjson_prefix(j.front());
+                    const bool same_prefix = std::all_of(j.begin(), j.end(),
+                                                         [this, first_prefix](const BasicJsonType & v)
+                    {
+                        return ubjson_prefix(v) == first_prefix;
+                    });
+
+                    if (same_prefix)
+                    {
+                        prefix_required = false;
+                        oa->write_character(to_char_type('$'));
+                        oa->write_character(first_prefix);
+                    }
+                }
+
+                if (use_count)
+                {
+                    oa->write_character(to_char_type('#'));
+                    write_number_with_ubjson_prefix(j.m_value.object->size(), true);
+                }
+
+                for (const auto& el : *j.m_value.object)
+                {
+                    write_number_with_ubjson_prefix(el.first.size(), true);
+                    oa->write_characters(
+                        reinterpret_cast<const CharType*>(el.first.c_str()),
+                        el.first.size());
+                    write_ubjson(el.second, use_count, use_type, prefix_required);
+                }
+
+                if (!use_count)
+                {
+                    oa->write_character(to_char_type('}'));
+                }
+
+                break;
+            }
+
+            default:
+                break;
+        }
+    }
+
+  private:
+    //////////
+    // BSON //
+    //////////
+
+    /*!
+    @return The size of a BSON document entry header, including the id marker
+            and the entry name size (and its null-terminator).
+    */
+    static std::size_t calc_bson_entry_header_size(const string_t& name)
+    {
+        const auto it = name.find(static_cast<typename string_t::value_type>(0));
+        if (JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos))
+        {
+            JSON_THROW(out_of_range::create(409,
+                                            "BSON key cannot contain code point U+0000 (at byte " + std::to_string(it) + ")"));
+        }
+
+        return /*id*/ 1ul + name.size() + /*zero-terminator*/1u;
+    }
+
+    /*!
+    @brief Writes the given @a element_type and @a name to the output adapter
+    */
+    void write_bson_entry_header(const string_t& name,
+                                 const std::uint8_t element_type)
+    {
+        oa->write_character(to_char_type(element_type)); // boolean
+        oa->write_characters(
+            reinterpret_cast<const CharType*>(name.c_str()),
+            name.size() + 1u);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and boolean value @a value
+    */
+    void write_bson_boolean(const string_t& name,
+                            const bool value)
+    {
+        write_bson_entry_header(name, 0x08);
+        oa->write_character(value ? to_char_type(0x01) : to_char_type(0x00));
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and double value @a value
+    */
+    void write_bson_double(const string_t& name,
+                           const double value)
+    {
+        write_bson_entry_header(name, 0x01);
+        write_number<double, true>(value);
+    }
+
+    /*!
+    @return The size of the BSON-encoded string in @a value
+    */
+    static std::size_t calc_bson_string_size(const string_t& value)
+    {
+        return sizeof(std::int32_t) + value.size() + 1ul;
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and string value @a value
+    */
+    void write_bson_string(const string_t& name,
+                           const string_t& value)
+    {
+        write_bson_entry_header(name, 0x02);
+
+        write_number<std::int32_t, true>(static_cast<std::int32_t>(value.size() + 1ul));
+        oa->write_characters(
+            reinterpret_cast<const CharType*>(value.c_str()),
+            value.size() + 1);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and null value
+    */
+    void write_bson_null(const string_t& name)
+    {
+        write_bson_entry_header(name, 0x0A);
+    }
+
+    /*!
+    @return The size of the BSON-encoded integer @a value
+    */
+    static std::size_t calc_bson_integer_size(const std::int64_t value)
+    {
+        return (std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)()
+               ? sizeof(std::int32_t)
+               : sizeof(std::int64_t);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and integer @a value
+    */
+    void write_bson_integer(const string_t& name,
+                            const std::int64_t value)
+    {
+        if ((std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)())
+        {
+            write_bson_entry_header(name, 0x10); // int32
+            write_number<std::int32_t, true>(static_cast<std::int32_t>(value));
+        }
+        else
+        {
+            write_bson_entry_header(name, 0x12); // int64
+            write_number<std::int64_t, true>(static_cast<std::int64_t>(value));
+        }
+    }
+
+    /*!
+    @return The size of the BSON-encoded unsigned integer in @a j
+    */
+    static constexpr std::size_t calc_bson_unsigned_size(const std::uint64_t value) noexcept
+    {
+        return (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+               ? sizeof(std::int32_t)
+               : sizeof(std::int64_t);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and unsigned @a value
+    */
+    void write_bson_unsigned(const string_t& name,
+                             const std::uint64_t value)
+    {
+        if (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+        {
+            write_bson_entry_header(name, 0x10 /* int32 */);
+            write_number<std::int32_t, true>(static_cast<std::int32_t>(value));
+        }
+        else if (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+        {
+            write_bson_entry_header(name, 0x12 /* int64 */);
+            write_number<std::int64_t, true>(static_cast<std::int64_t>(value));
+        }
+        else
+        {
+            JSON_THROW(out_of_range::create(407, "integer number " + std::to_string(value) + " cannot be represented by BSON as it does not fit int64"));
+        }
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and object @a value
+    */
+    void write_bson_object_entry(const string_t& name,
+                                 const typename BasicJsonType::object_t& value)
+    {
+        write_bson_entry_header(name, 0x03); // object
+        write_bson_object(value);
+    }
+
+    /*!
+    @return The size of the BSON-encoded array @a value
+    */
+    static std::size_t calc_bson_array_size(const typename BasicJsonType::array_t& value)
+    {
+        std::size_t array_index = 0ul;
+
+        const std::size_t embedded_document_size = std::accumulate(std::begin(value), std::end(value), std::size_t(0), [&array_index](std::size_t result, const typename BasicJsonType::array_t::value_type & el)
+        {
+            return result + calc_bson_element_size(std::to_string(array_index++), el);
+        });
+
+        return sizeof(std::int32_t) + embedded_document_size + 1ul;
+    }
+
+    /*!
+    @return The size of the BSON-encoded binary array @a value
+    */
+    static std::size_t calc_bson_binary_size(const typename BasicJsonType::binary_t& value)
+    {
+        return sizeof(std::int32_t) + value.size() + 1ul;
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and array @a value
+    */
+    void write_bson_array(const string_t& name,
+                          const typename BasicJsonType::array_t& value)
+    {
+        write_bson_entry_header(name, 0x04); // array
+        write_number<std::int32_t, true>(static_cast<std::int32_t>(calc_bson_array_size(value)));
+
+        std::size_t array_index = 0ul;
+
+        for (const auto& el : value)
+        {
+            write_bson_element(std::to_string(array_index++), el);
+        }
+
+        oa->write_character(to_char_type(0x00));
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and binary value @a value
+    */
+    void write_bson_binary(const string_t& name,
+                           const binary_t& value)
+    {
+        write_bson_entry_header(name, 0x05);
+
+        write_number<std::int32_t, true>(static_cast<std::int32_t>(value.size()));
+        write_number(value.has_subtype() ? value.subtype() : std::uint8_t(0x00));
+
+        oa->write_characters(reinterpret_cast<const CharType*>(value.data()), value.size());
+    }
+
+    /*!
+    @brief Calculates the size necessary to serialize the JSON value @a j with its @a name
+    @return The calculated size for the BSON document entry for @a j with the given @a name.
+    */
+    static std::size_t calc_bson_element_size(const string_t& name,
+            const BasicJsonType& j)
+    {
+        const auto header_size = calc_bson_entry_header_size(name);
+        switch (j.type())
+        {
+            case value_t::object:
+                return header_size + calc_bson_object_size(*j.m_value.object);
+
+            case value_t::array:
+                return header_size + calc_bson_array_size(*j.m_value.array);
+
+            case value_t::binary:
+                return header_size + calc_bson_binary_size(*j.m_value.binary);
+
+            case value_t::boolean:
+                return header_size + 1ul;
+
+            case value_t::number_float:
+                return header_size + 8ul;
+
+            case value_t::number_integer:
+                return header_size + calc_bson_integer_size(j.m_value.number_integer);
+
+            case value_t::number_unsigned:
+                return header_size + calc_bson_unsigned_size(j.m_value.number_unsigned);
+
+            case value_t::string:
+                return header_size + calc_bson_string_size(*j.m_value.string);
+
+            case value_t::null:
+                return header_size + 0ul;
+
+            // LCOV_EXCL_START
+            default:
+                JSON_ASSERT(false);
+                return 0ul;
+                // LCOV_EXCL_STOP
+        }
+    }
+
+    /*!
+    @brief Serializes the JSON value @a j to BSON and associates it with the
+           key @a name.
+    @param name The name to associate with the JSON entity @a j within the
+                current BSON document
+    @return The size of the BSON entry
+    */
+    void write_bson_element(const string_t& name,
+                            const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::object:
+                return write_bson_object_entry(name, *j.m_value.object);
+
+            case value_t::array:
+                return write_bson_array(name, *j.m_value.array);
+
+            case value_t::binary:
+                return write_bson_binary(name, *j.m_value.binary);
+
+            case value_t::boolean:
+                return write_bson_boolean(name, j.m_value.boolean);
+
+            case value_t::number_float:
+                return write_bson_double(name, j.m_value.number_float);
+
+            case value_t::number_integer:
+                return write_bson_integer(name, j.m_value.number_integer);
+
+            case value_t::number_unsigned:
+                return write_bson_unsigned(name, j.m_value.number_unsigned);
+
+            case value_t::string:
+                return write_bson_string(name, *j.m_value.string);
+
+            case value_t::null:
+                return write_bson_null(name);
+
+            // LCOV_EXCL_START
+            default:
+                JSON_ASSERT(false);
+                return;
+                // LCOV_EXCL_STOP
+        }
+    }
+
+    /*!
+    @brief Calculates the size of the BSON serialization of the given
+           JSON-object @a j.
+    @param[in] j  JSON value to serialize
+    @pre       j.type() == value_t::object
+    */
+    static std::size_t calc_bson_object_size(const typename BasicJsonType::object_t& value)
+    {
+        std::size_t document_size = std::accumulate(value.begin(), value.end(), std::size_t(0),
+                                    [](size_t result, const typename BasicJsonType::object_t::value_type & el)
+        {
+            return result += calc_bson_element_size(el.first, el.second);
+        });
+
+        return sizeof(std::int32_t) + document_size + 1ul;
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    @pre       j.type() == value_t::object
+    */
+    void write_bson_object(const typename BasicJsonType::object_t& value)
+    {
+        write_number<std::int32_t, true>(static_cast<std::int32_t>(calc_bson_object_size(value)));
+
+        for (const auto& el : value)
+        {
+            write_bson_element(el.first, el.second);
+        }
+
+        oa->write_character(to_char_type(0x00));
+    }
+
+    //////////
+    // CBOR //
+    //////////
+
+    static constexpr CharType get_cbor_float_prefix(float /*unused*/)
+    {
+        return to_char_type(0xFA);  // Single-Precision Float
+    }
+
+    static constexpr CharType get_cbor_float_prefix(double /*unused*/)
+    {
+        return to_char_type(0xFB);  // Double-Precision Float
+    }
+
+    /////////////
+    // MsgPack //
+    /////////////
+
+    static constexpr CharType get_msgpack_float_prefix(float /*unused*/)
+    {
+        return to_char_type(0xCA);  // float 32
+    }
+
+    static constexpr CharType get_msgpack_float_prefix(double /*unused*/)
+    {
+        return to_char_type(0xCB);  // float 64
+    }
+
+    ////////////
+    // UBJSON //
+    ////////////
+
+    // UBJSON: write number (floating point)
+    template<typename NumberType, typename std::enable_if<
+                 std::is_floating_point<NumberType>::value, int>::type = 0>
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix)
+    {
+        if (add_prefix)
+        {
+            oa->write_character(get_ubjson_float_prefix(n));
+        }
+        write_number(n);
+    }
+
+    // UBJSON: write number (unsigned integer)
+    template<typename NumberType, typename std::enable_if<
+                 std::is_unsigned<NumberType>::value, int>::type = 0>
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix)
+    {
+        if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('i'));  // int8
+            }
+            write_number(static_cast<std::uint8_t>(n));
+        }
+        else if (n <= (std::numeric_limits<std::uint8_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('U'));  // uint8
+            }
+            write_number(static_cast<std::uint8_t>(n));
+        }
+        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('I'));  // int16
+            }
+            write_number(static_cast<std::int16_t>(n));
+        }
+        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('l'));  // int32
+            }
+            write_number(static_cast<std::int32_t>(n));
+        }
+        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('L'));  // int64
+            }
+            write_number(static_cast<std::int64_t>(n));
+        }
+        else
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('H'));  // high-precision number
+            }
+
+            const auto number = BasicJsonType(n).dump();
+            write_number_with_ubjson_prefix(number.size(), true);
+            for (std::size_t i = 0; i < number.size(); ++i)
+            {
+                oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
+            }
+        }
+    }
+
+    // UBJSON: write number (signed integer)
+    template < typename NumberType, typename std::enable_if <
+                   std::is_signed<NumberType>::value&&
+                   !std::is_floating_point<NumberType>::value, int >::type = 0 >
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix)
+    {
+        if ((std::numeric_limits<std::int8_t>::min)() <= n && n <= (std::numeric_limits<std::int8_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('i'));  // int8
+            }
+            write_number(static_cast<std::int8_t>(n));
+        }
+        else if (static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('U'));  // uint8
+            }
+            write_number(static_cast<std::uint8_t>(n));
+        }
+        else if ((std::numeric_limits<std::int16_t>::min)() <= n && n <= (std::numeric_limits<std::int16_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('I'));  // int16
+            }
+            write_number(static_cast<std::int16_t>(n));
+        }
+        else if ((std::numeric_limits<std::int32_t>::min)() <= n && n <= (std::numeric_limits<std::int32_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('l'));  // int32
+            }
+            write_number(static_cast<std::int32_t>(n));
+        }
+        else if ((std::numeric_limits<std::int64_t>::min)() <= n && n <= (std::numeric_limits<std::int64_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('L'));  // int64
+            }
+            write_number(static_cast<std::int64_t>(n));
+        }
+        // LCOV_EXCL_START
+        else
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('H'));  // high-precision number
+            }
+
+            const auto number = BasicJsonType(n).dump();
+            write_number_with_ubjson_prefix(number.size(), true);
+            for (std::size_t i = 0; i < number.size(); ++i)
+            {
+                oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
+            }
+        }
+        // LCOV_EXCL_STOP
+    }
+
+    /*!
+    @brief determine the type prefix of container values
+    */
+    CharType ubjson_prefix(const BasicJsonType& j) const noexcept
+    {
+        switch (j.type())
+        {
+            case value_t::null:
+                return 'Z';
+
+            case value_t::boolean:
+                return j.m_value.boolean ? 'T' : 'F';
+
+            case value_t::number_integer:
+            {
+                if ((std::numeric_limits<std::int8_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
+                {
+                    return 'i';
+                }
+                if ((std::numeric_limits<std::uint8_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    return 'U';
+                }
+                if ((std::numeric_limits<std::int16_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
+                {
+                    return 'I';
+                }
+                if ((std::numeric_limits<std::int32_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
+                {
+                    return 'l';
+                }
+                if ((std::numeric_limits<std::int64_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
+                {
+                    return 'L';
+                }
+                // anything else is treated as high-precision number
+                return 'H'; // LCOV_EXCL_LINE
+            }
+
+            case value_t::number_unsigned:
+            {
+                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
+                {
+                    return 'i';
+                }
+                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint8_t>::max)()))
+                {
+                    return 'U';
+                }
+                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
+                {
+                    return 'I';
+                }
+                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+                {
+                    return 'l';
+                }
+                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+                {
+                    return 'L';
+                }
+                // anything else is treated as high-precision number
+                return 'H'; // LCOV_EXCL_LINE
+            }
+
+            case value_t::number_float:
+                return get_ubjson_float_prefix(j.m_value.number_float);
+
+            case value_t::string:
+                return 'S';
+
+            case value_t::array: // fallthrough
+            case value_t::binary:
+                return '[';
+
+            case value_t::object:
+                return '{';
+
+            default:  // discarded values
+                return 'N';
+        }
+    }
+
+    static constexpr CharType get_ubjson_float_prefix(float /*unused*/)
+    {
+        return 'd';  // float 32
+    }
+
+    static constexpr CharType get_ubjson_float_prefix(double /*unused*/)
+    {
+        return 'D';  // float 64
+    }
+
+    ///////////////////////
+    // Utility functions //
+    ///////////////////////
+
+    /*
+    @brief write a number to output input
+    @param[in] n number of type @a NumberType
+    @tparam NumberType the type of the number
+    @tparam OutputIsLittleEndian Set to true if output data is
+                                 required to be little endian
+
+    @note This function needs to respect the system's endianess, because bytes
+          in CBOR, MessagePack, and UBJSON are stored in network order (big
+          endian) and therefore need reordering on little endian systems.
+    */
+    template<typename NumberType, bool OutputIsLittleEndian = false>
+    void write_number(const NumberType n)
+    {
+        // step 1: write number to array of length NumberType
+        std::array<CharType, sizeof(NumberType)> vec;
+        std::memcpy(vec.data(), &n, sizeof(NumberType));
+
+        // step 2: write array to output (with possible reordering)
+        if (is_little_endian != OutputIsLittleEndian)
+        {
+            // reverse byte order prior to conversion if necessary
+            std::reverse(vec.begin(), vec.end());
+        }
+
+        oa->write_characters(vec.data(), sizeof(NumberType));
+    }
+
+    void write_compact_float(const number_float_t n, detail::input_format_t format)
+    {
+        if (static_cast<double>(n) >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
+                static_cast<double>(n) <= static_cast<double>((std::numeric_limits<float>::max)()) &&
+                static_cast<double>(static_cast<float>(n)) == static_cast<double>(n))
+        {
+            oa->write_character(format == detail::input_format_t::cbor
+                                ? get_cbor_float_prefix(static_cast<float>(n))
+                                : get_msgpack_float_prefix(static_cast<float>(n)));
+            write_number(static_cast<float>(n));
+        }
+        else
+        {
+            oa->write_character(format == detail::input_format_t::cbor
+                                ? get_cbor_float_prefix(n)
+                                : get_msgpack_float_prefix(n));
+            write_number(n);
+        }
+    }
+
+  public:
+    // The following to_char_type functions are implement the conversion
+    // between uint8_t and CharType. In case CharType is not unsigned,
+    // such a conversion is required to allow values greater than 128.
+    // See <https://github.com/nlohmann/json/issues/1286> for a discussion.
+    template < typename C = CharType,
+               enable_if_t < std::is_signed<C>::value && std::is_signed<char>::value > * = nullptr >
+    static constexpr CharType to_char_type(std::uint8_t x) noexcept
+    {
+        return *reinterpret_cast<char*>(&x);
+    }
+
+    template < typename C = CharType,
+               enable_if_t < std::is_signed<C>::value && std::is_unsigned<char>::value > * = nullptr >
+    static CharType to_char_type(std::uint8_t x) noexcept
+    {
+        static_assert(sizeof(std::uint8_t) == sizeof(CharType), "size of CharType must be equal to std::uint8_t");
+        static_assert(std::is_trivial<CharType>::value, "CharType must be trivial");
+        CharType result;
+        std::memcpy(&result, &x, sizeof(x));
+        return result;
+    }
+
+    template<typename C = CharType,
+             enable_if_t<std::is_unsigned<C>::value>* = nullptr>
+    static constexpr CharType to_char_type(std::uint8_t x) noexcept
+    {
+        return x;
+    }
+
+    template < typename InputCharType, typename C = CharType,
+               enable_if_t <
+                   std::is_signed<C>::value &&
+                   std::is_signed<char>::value &&
+                   std::is_same<char, typename std::remove_cv<InputCharType>::type>::value
+                   > * = nullptr >
+    static constexpr CharType to_char_type(InputCharType x) noexcept
+    {
+        return x;
+    }
+
+  private:
+    /// whether we can assume little endianess
+    const bool is_little_endian = little_endianess();
+
+    /// the output
+    output_adapter_t<CharType> oa = nullptr;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/output/output_adapters.hpp>
+
+// #include <nlohmann/detail/output/serializer.hpp>
+
+
+#include <algorithm> // reverse, remove, fill, find, none_of
+#include <array> // array
+#include <clocale> // localeconv, lconv
+#include <cmath> // labs, isfinite, isnan, signbit
+#include <cstddef> // size_t, ptrdiff_t
+#include <cstdint> // uint8_t
+#include <cstdio> // snprintf
+#include <limits> // numeric_limits
+#include <string> // string, char_traits
+#include <type_traits> // is_same
+#include <utility> // move
+
+// #include <nlohmann/detail/conversions/to_chars.hpp>
+
+
+#include <array> // array
+#include <cmath>   // signbit, isfinite
+#include <cstdint> // intN_t, uintN_t
+#include <cstring> // memcpy, memmove
+#include <limits> // numeric_limits
+#include <type_traits> // conditional
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+
+/*!
+@brief implements the Grisu2 algorithm for binary to decimal floating-point
+conversion.
+
+This implementation is a slightly modified version of the reference
+implementation which may be obtained from
+http://florian.loitsch.com/publications (bench.tar.gz).
+
+The code is distributed under the MIT license, Copyright (c) 2009 Florian Loitsch.
+
+For a detailed description of the algorithm see:
+
+[1] Loitsch, "Printing Floating-Point Numbers Quickly and Accurately with
+    Integers", Proceedings of the ACM SIGPLAN 2010 Conference on Programming
+    Language Design and Implementation, PLDI 2010
+[2] Burger, Dybvig, "Printing Floating-Point Numbers Quickly and Accurately",
+    Proceedings of the ACM SIGPLAN 1996 Conference on Programming Language
+    Design and Implementation, PLDI 1996
+*/
+namespace dtoa_impl
+{
+
+template<typename Target, typename Source>
+Target reinterpret_bits(const Source source)
+{
+    static_assert(sizeof(Target) == sizeof(Source), "size mismatch");
+
+    Target target;
+    std::memcpy(&target, &source, sizeof(Source));
+    return target;
+}
+
+struct diyfp // f * 2^e
+{
+    static constexpr int kPrecision = 64; // = q
+
+    std::uint64_t f = 0;
+    int e = 0;
+
+    constexpr diyfp(std::uint64_t f_, int e_) noexcept : f(f_), e(e_) {}
+
+    /*!
+    @brief returns x - y
+    @pre x.e == y.e and x.f >= y.f
+    */
+    static diyfp sub(const diyfp& x, const diyfp& y) noexcept
+    {
+        JSON_ASSERT(x.e == y.e);
+        JSON_ASSERT(x.f >= y.f);
+
+        return {x.f - y.f, x.e};
+    }
+
+    /*!
+    @brief returns x * y
+    @note The result is rounded. (Only the upper q bits are returned.)
+    */
+    static diyfp mul(const diyfp& x, const diyfp& y) noexcept
+    {
+        static_assert(kPrecision == 64, "internal error");
+
+        // Computes:
+        //  f = round((x.f * y.f) / 2^q)
+        //  e = x.e + y.e + q
+
+        // Emulate the 64-bit * 64-bit multiplication:
+        //
+        // p = u * v
+        //   = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi)
+        //   = (u_lo v_lo         ) + 2^32 ((u_lo v_hi         ) + (u_hi v_lo         )) + 2^64 (u_hi v_hi         )
+        //   = (p0                ) + 2^32 ((p1                ) + (p2                )) + 2^64 (p3                )
+        //   = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3                )
+        //   = (p0_lo             ) + 2^32 (p0_hi + p1_lo + p2_lo                      ) + 2^64 (p1_hi + p2_hi + p3)
+        //   = (p0_lo             ) + 2^32 (Q                                          ) + 2^64 (H                 )
+        //   = (p0_lo             ) + 2^32 (Q_lo + 2^32 Q_hi                           ) + 2^64 (H                 )
+        //
+        // (Since Q might be larger than 2^32 - 1)
+        //
+        //   = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H)
+        //
+        // (Q_hi + H does not overflow a 64-bit int)
+        //
+        //   = p_lo + 2^64 p_hi
+
+        const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
+        const std::uint64_t u_hi = x.f >> 32u;
+        const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
+        const std::uint64_t v_hi = y.f >> 32u;
+
+        const std::uint64_t p0 = u_lo * v_lo;
+        const std::uint64_t p1 = u_lo * v_hi;
+        const std::uint64_t p2 = u_hi * v_lo;
+        const std::uint64_t p3 = u_hi * v_hi;
+
+        const std::uint64_t p0_hi = p0 >> 32u;
+        const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
+        const std::uint64_t p1_hi = p1 >> 32u;
+        const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
+        const std::uint64_t p2_hi = p2 >> 32u;
+
+        std::uint64_t Q = p0_hi + p1_lo + p2_lo;
+
+        // The full product might now be computed as
+        //
+        // p_hi = p3 + p2_hi + p1_hi + (Q >> 32)
+        // p_lo = p0_lo + (Q << 32)
+        //
+        // But in this particular case here, the full p_lo is not required.
+        // Effectively we only need to add the highest bit in p_lo to p_hi (and
+        // Q_hi + 1 does not overflow).
+
+        Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up
+
+        const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
+
+        return {h, x.e + y.e + 64};
+    }
+
+    /*!
+    @brief normalize x such that the significand is >= 2^(q-1)
+    @pre x.f != 0
+    */
+    static diyfp normalize(diyfp x) noexcept
+    {
+        JSON_ASSERT(x.f != 0);
+
+        while ((x.f >> 63u) == 0)
+        {
+            x.f <<= 1u;
+            x.e--;
+        }
+
+        return x;
+    }
+
+    /*!
+    @brief normalize x such that the result has the exponent E
+    @pre e >= x.e and the upper e - x.e bits of x.f must be zero.
+    */
+    static diyfp normalize_to(const diyfp& x, const int target_exponent) noexcept
+    {
+        const int delta = x.e - target_exponent;
+
+        JSON_ASSERT(delta >= 0);
+        JSON_ASSERT(((x.f << delta) >> delta) == x.f);
+
+        return {x.f << delta, target_exponent};
+    }
+};
+
+struct boundaries
+{
+    diyfp w;
+    diyfp minus;
+    diyfp plus;
+};
+
+/*!
+Compute the (normalized) diyfp representing the input number 'value' and its
+boundaries.
+
+@pre value must be finite and positive
+*/
+template<typename FloatType>
+boundaries compute_boundaries(FloatType value)
+{
+    JSON_ASSERT(std::isfinite(value));
+    JSON_ASSERT(value > 0);
+
+    // Convert the IEEE representation into a diyfp.
+    //
+    // If v is denormal:
+    //      value = 0.F * 2^(1 - bias) = (          F) * 2^(1 - bias - (p-1))
+    // If v is normalized:
+    //      value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1))
+
+    static_assert(std::numeric_limits<FloatType>::is_iec559,
+                  "internal error: dtoa_short requires an IEEE-754 floating-point implementation");
+
+    constexpr int      kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)
+    constexpr int      kBias      = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
+    constexpr int      kMinExp    = 1 - kBias;
+    constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1); // = 2^(p-1)
+
+    using bits_type = typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
+
+    const std::uint64_t bits = reinterpret_bits<bits_type>(value);
+    const std::uint64_t E = bits >> (kPrecision - 1);
+    const std::uint64_t F = bits & (kHiddenBit - 1);
+
+    const bool is_denormal = E == 0;
+    const diyfp v = is_denormal
+                    ? diyfp(F, kMinExp)
+                    : diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);
+
+    // Compute the boundaries m- and m+ of the floating-point value
+    // v = f * 2^e.
+    //
+    // Determine v- and v+, the floating-point predecessor and successor if v,
+    // respectively.
+    //
+    //      v- = v - 2^e        if f != 2^(p-1) or e == e_min                (A)
+    //         = v - 2^(e-1)    if f == 2^(p-1) and e > e_min                (B)
+    //
+    //      v+ = v + 2^e
+    //
+    // Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_
+    // between m- and m+ round to v, regardless of how the input rounding
+    // algorithm breaks ties.
+    //
+    //      ---+-------------+-------------+-------------+-------------+---  (A)
+    //         v-            m-            v             m+            v+
+    //
+    //      -----------------+------+------+-------------+-------------+---  (B)
+    //                       v-     m-     v             m+            v+
+
+    const bool lower_boundary_is_closer = F == 0 && E > 1;
+    const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);
+    const diyfp m_minus = lower_boundary_is_closer
+                          ? diyfp(4 * v.f - 1, v.e - 2)  // (B)
+                          : diyfp(2 * v.f - 1, v.e - 1); // (A)
+
+    // Determine the normalized w+ = m+.
+    const diyfp w_plus = diyfp::normalize(m_plus);
+
+    // Determine w- = m- such that e_(w-) = e_(w+).
+    const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);
+
+    return {diyfp::normalize(v), w_minus, w_plus};
+}
+
+// Given normalized diyfp w, Grisu needs to find a (normalized) cached
+// power-of-ten c, such that the exponent of the product c * w = f * 2^e lies
+// within a certain range [alpha, gamma] (Definition 3.2 from [1])
+//
+//      alpha <= e = e_c + e_w + q <= gamma
+//
+// or
+//
+//      f_c * f_w * 2^alpha <= f_c 2^(e_c) * f_w 2^(e_w) * 2^q
+//                          <= f_c * f_w * 2^gamma
+//
+// Since c and w are normalized, i.e. 2^(q-1) <= f < 2^q, this implies
+//
+//      2^(q-1) * 2^(q-1) * 2^alpha <= c * w * 2^q < 2^q * 2^q * 2^gamma
+//
+// or
+//
+//      2^(q - 2 + alpha) <= c * w < 2^(q + gamma)
+//
+// The choice of (alpha,gamma) determines the size of the table and the form of
+// the digit generation procedure. Using (alpha,gamma)=(-60,-32) works out well
+// in practice:
+//
+// The idea is to cut the number c * w = f * 2^e into two parts, which can be
+// processed independently: An integral part p1, and a fractional part p2:
+//
+//      f * 2^e = ( (f div 2^-e) * 2^-e + (f mod 2^-e) ) * 2^e
+//              = (f div 2^-e) + (f mod 2^-e) * 2^e
+//              = p1 + p2 * 2^e
+//
+// The conversion of p1 into decimal form requires a series of divisions and
+// modulos by (a power of) 10. These operations are faster for 32-bit than for
+// 64-bit integers, so p1 should ideally fit into a 32-bit integer. This can be
+// achieved by choosing
+//
+//      -e >= 32   or   e <= -32 := gamma
+//
+// In order to convert the fractional part
+//
+//      p2 * 2^e = p2 / 2^-e = d[-1] / 10^1 + d[-2] / 10^2 + ...
+//
+// into decimal form, the fraction is repeatedly multiplied by 10 and the digits
+// d[-i] are extracted in order:
+//
+//      (10 * p2) div 2^-e = d[-1]
+//      (10 * p2) mod 2^-e = d[-2] / 10^1 + ...
+//
+// The multiplication by 10 must not overflow. It is sufficient to choose
+//
+//      10 * p2 < 16 * p2 = 2^4 * p2 <= 2^64.
+//
+// Since p2 = f mod 2^-e < 2^-e,
+//
+//      -e <= 60   or   e >= -60 := alpha
+
+constexpr int kAlpha = -60;
+constexpr int kGamma = -32;
+
+struct cached_power // c = f * 2^e ~= 10^k
+{
+    std::uint64_t f;
+    int e;
+    int k;
+};
+
+/*!
+For a normalized diyfp w = f * 2^e, this function returns a (normalized) cached
+power-of-ten c = f_c * 2^e_c, such that the exponent of the product w * c
+satisfies (Definition 3.2 from [1])
+
+     alpha <= e_c + e + q <= gamma.
+*/
+inline cached_power get_cached_power_for_binary_exponent(int e)
+{
+    // Now
+    //
+    //      alpha <= e_c + e + q <= gamma                                    (1)
+    //      ==> f_c * 2^alpha <= c * 2^e * 2^q
+    //
+    // and since the c's are normalized, 2^(q-1) <= f_c,
+    //
+    //      ==> 2^(q - 1 + alpha) <= c * 2^(e + q)
+    //      ==> 2^(alpha - e - 1) <= c
+    //
+    // If c were an exact power of ten, i.e. c = 10^k, one may determine k as
+    //
+    //      k = ceil( log_10( 2^(alpha - e - 1) ) )
+    //        = ceil( (alpha - e - 1) * log_10(2) )
+    //
+    // From the paper:
+    // "In theory the result of the procedure could be wrong since c is rounded,
+    //  and the computation itself is approximated [...]. In practice, however,
+    //  this simple function is sufficient."
+    //
+    // For IEEE double precision floating-point numbers converted into
+    // normalized diyfp's w = f * 2^e, with q = 64,
+    //
+    //      e >= -1022      (min IEEE exponent)
+    //           -52        (p - 1)
+    //           -52        (p - 1, possibly normalize denormal IEEE numbers)
+    //           -11        (normalize the diyfp)
+    //         = -1137
+    //
+    // and
+    //
+    //      e <= +1023      (max IEEE exponent)
+    //           -52        (p - 1)
+    //           -11        (normalize the diyfp)
+    //         = 960
+    //
+    // This binary exponent range [-1137,960] results in a decimal exponent
+    // range [-307,324]. One does not need to store a cached power for each
+    // k in this range. For each such k it suffices to find a cached power
+    // such that the exponent of the product lies in [alpha,gamma].
+    // This implies that the difference of the decimal exponents of adjacent
+    // table entries must be less than or equal to
+    //
+    //      floor( (gamma - alpha) * log_10(2) ) = 8.
+    //
+    // (A smaller distance gamma-alpha would require a larger table.)
+
+    // NB:
+    // Actually this function returns c, such that -60 <= e_c + e + 64 <= -34.
+
+    constexpr int kCachedPowersMinDecExp = -300;
+    constexpr int kCachedPowersDecStep = 8;
+
+    static constexpr std::array<cached_power, 79> kCachedPowers =
+    {
+        {
+            { 0xAB70FE17C79AC6CA, -1060, -300 },
+            { 0xFF77B1FCBEBCDC4F, -1034, -292 },
+            { 0xBE5691EF416BD60C, -1007, -284 },
+            { 0x8DD01FAD907FFC3C,  -980, -276 },
+            { 0xD3515C2831559A83,  -954, -268 },
+            { 0x9D71AC8FADA6C9B5,  -927, -260 },
+            { 0xEA9C227723EE8BCB,  -901, -252 },
+            { 0xAECC49914078536D,  -874, -244 },
+            { 0x823C12795DB6CE57,  -847, -236 },
+            { 0xC21094364DFB5637,  -821, -228 },
+            { 0x9096EA6F3848984F,  -794, -220 },
+            { 0xD77485CB25823AC7,  -768, -212 },
+            { 0xA086CFCD97BF97F4,  -741, -204 },
+            { 0xEF340A98172AACE5,  -715, -196 },
+            { 0xB23867FB2A35B28E,  -688, -188 },
+            { 0x84C8D4DFD2C63F3B,  -661, -180 },
+            { 0xC5DD44271AD3CDBA,  -635, -172 },
+            { 0x936B9FCEBB25C996,  -608, -164 },
+            { 0xDBAC6C247D62A584,  -582, -156 },
+            { 0xA3AB66580D5FDAF6,  -555, -148 },
+            { 0xF3E2F893DEC3F126,  -529, -140 },
+            { 0xB5B5ADA8AAFF80B8,  -502, -132 },
+            { 0x87625F056C7C4A8B,  -475, -124 },
+            { 0xC9BCFF6034C13053,  -449, -116 },
+            { 0x964E858C91BA2655,  -422, -108 },
+            { 0xDFF9772470297EBD,  -396, -100 },
+            { 0xA6DFBD9FB8E5B88F,  -369,  -92 },
+            { 0xF8A95FCF88747D94,  -343,  -84 },
+            { 0xB94470938FA89BCF,  -316,  -76 },
+            { 0x8A08F0F8BF0F156B,  -289,  -68 },
+            { 0xCDB02555653131B6,  -263,  -60 },
+            { 0x993FE2C6D07B7FAC,  -236,  -52 },
+            { 0xE45C10C42A2B3B06,  -210,  -44 },
+            { 0xAA242499697392D3,  -183,  -36 },
+            { 0xFD87B5F28300CA0E,  -157,  -28 },
+            { 0xBCE5086492111AEB,  -130,  -20 },
+            { 0x8CBCCC096F5088CC,  -103,  -12 },
+            { 0xD1B71758E219652C,   -77,   -4 },
+            { 0x9C40000000000000,   -50,    4 },
+            { 0xE8D4A51000000000,   -24,   12 },
+            { 0xAD78EBC5AC620000,     3,   20 },
+            { 0x813F3978F8940984,    30,   28 },
+            { 0xC097CE7BC90715B3,    56,   36 },
+            { 0x8F7E32CE7BEA5C70,    83,   44 },
+            { 0xD5D238A4ABE98068,   109,   52 },
+            { 0x9F4F2726179A2245,   136,   60 },
+            { 0xED63A231D4C4FB27,   162,   68 },
+            { 0xB0DE65388CC8ADA8,   189,   76 },
+            { 0x83C7088E1AAB65DB,   216,   84 },
+            { 0xC45D1DF942711D9A,   242,   92 },
+            { 0x924D692CA61BE758,   269,  100 },
+            { 0xDA01EE641A708DEA,   295,  108 },
+            { 0xA26DA3999AEF774A,   322,  116 },
+            { 0xF209787BB47D6B85,   348,  124 },
+            { 0xB454E4A179DD1877,   375,  132 },
+            { 0x865B86925B9BC5C2,   402,  140 },
+            { 0xC83553C5C8965D3D,   428,  148 },
+            { 0x952AB45CFA97A0B3,   455,  156 },
+            { 0xDE469FBD99A05FE3,   481,  164 },
+            { 0xA59BC234DB398C25,   508,  172 },
+            { 0xF6C69A72A3989F5C,   534,  180 },
+            { 0xB7DCBF5354E9BECE,   561,  188 },
+            { 0x88FCF317F22241E2,   588,  196 },
+            { 0xCC20CE9BD35C78A5,   614,  204 },
+            { 0x98165AF37B2153DF,   641,  212 },
+            { 0xE2A0B5DC971F303A,   667,  220 },
+            { 0xA8D9D1535CE3B396,   694,  228 },
+            { 0xFB9B7CD9A4A7443C,   720,  236 },
+            { 0xBB764C4CA7A44410,   747,  244 },
+            { 0x8BAB8EEFB6409C1A,   774,  252 },
+            { 0xD01FEF10A657842C,   800,  260 },
+            { 0x9B10A4E5E9913129,   827,  268 },
+            { 0xE7109BFBA19C0C9D,   853,  276 },
+            { 0xAC2820D9623BF429,   880,  284 },
+            { 0x80444B5E7AA7CF85,   907,  292 },
+            { 0xBF21E44003ACDD2D,   933,  300 },
+            { 0x8E679C2F5E44FF8F,   960,  308 },
+            { 0xD433179D9C8CB841,   986,  316 },
+            { 0x9E19DB92B4E31BA9,  1013,  324 },
+        }
+    };
+
+    // This computation gives exactly the same results for k as
+    //      k = ceil((kAlpha - e - 1) * 0.30102999566398114)
+    // for |e| <= 1500, but doesn't require floating-point operations.
+    // NB: log_10(2) ~= 78913 / 2^18
+    JSON_ASSERT(e >= -1500);
+    JSON_ASSERT(e <=  1500);
+    const int f = kAlpha - e - 1;
+    const int k = (f * 78913) / (1 << 18) + static_cast<int>(f > 0);
+
+    const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
+    JSON_ASSERT(index >= 0);
+    JSON_ASSERT(static_cast<std::size_t>(index) < kCachedPowers.size());
+
+    const cached_power cached = kCachedPowers[static_cast<std::size_t>(index)];
+    JSON_ASSERT(kAlpha <= cached.e + e + 64);
+    JSON_ASSERT(kGamma >= cached.e + e + 64);
+
+    return cached;
+}
+
+/*!
+For n != 0, returns k, such that pow10 := 10^(k-1) <= n < 10^k.
+For n == 0, returns 1 and sets pow10 := 1.
+*/
+inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10)
+{
+    // LCOV_EXCL_START
+    if (n >= 1000000000)
+    {
+        pow10 = 1000000000;
+        return 10;
+    }
+    // LCOV_EXCL_STOP
+    else if (n >= 100000000)
+    {
+        pow10 = 100000000;
+        return  9;
+    }
+    else if (n >= 10000000)
+    {
+        pow10 = 10000000;
+        return  8;
+    }
+    else if (n >= 1000000)
+    {
+        pow10 = 1000000;
+        return  7;
+    }
+    else if (n >= 100000)
+    {
+        pow10 = 100000;
+        return  6;
+    }
+    else if (n >= 10000)
+    {
+        pow10 = 10000;
+        return  5;
+    }
+    else if (n >= 1000)
+    {
+        pow10 = 1000;
+        return  4;
+    }
+    else if (n >= 100)
+    {
+        pow10 = 100;
+        return  3;
+    }
+    else if (n >= 10)
+    {
+        pow10 = 10;
+        return  2;
+    }
+    else
+    {
+        pow10 = 1;
+        return 1;
+    }
+}
+
+inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t delta,
+                         std::uint64_t rest, std::uint64_t ten_k)
+{
+    JSON_ASSERT(len >= 1);
+    JSON_ASSERT(dist <= delta);
+    JSON_ASSERT(rest <= delta);
+    JSON_ASSERT(ten_k > 0);
+
+    //               <--------------------------- delta ---->
+    //                                  <---- dist --------->
+    // --------------[------------------+-------------------]--------------
+    //               M-                 w                   M+
+    //
+    //                                  ten_k
+    //                                <------>
+    //                                       <---- rest ---->
+    // --------------[------------------+----+--------------]--------------
+    //                                  w    V
+    //                                       = buf * 10^k
+    //
+    // ten_k represents a unit-in-the-last-place in the decimal representation
+    // stored in buf.
+    // Decrement buf by ten_k while this takes buf closer to w.
+
+    // The tests are written in this order to avoid overflow in unsigned
+    // integer arithmetic.
+
+    while (rest < dist
+            && delta - rest >= ten_k
+            && (rest + ten_k < dist || dist - rest > rest + ten_k - dist))
+    {
+        JSON_ASSERT(buf[len - 1] != '0');
+        buf[len - 1]--;
+        rest += ten_k;
+    }
+}
+
+/*!
+Generates V = buffer * 10^decimal_exponent, such that M- <= V <= M+.
+M- and M+ must be normalized and share the same exponent -60 <= e <= -32.
+*/
+inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
+                             diyfp M_minus, diyfp w, diyfp M_plus)
+{
+    static_assert(kAlpha >= -60, "internal error");
+    static_assert(kGamma <= -32, "internal error");
+
+    // Generates the digits (and the exponent) of a decimal floating-point
+    // number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's
+    // w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma.
+    //
+    //               <--------------------------- delta ---->
+    //                                  <---- dist --------->
+    // --------------[------------------+-------------------]--------------
+    //               M-                 w                   M+
+    //
+    // Grisu2 generates the digits of M+ from left to right and stops as soon as
+    // V is in [M-,M+].
+
+    JSON_ASSERT(M_plus.e >= kAlpha);
+    JSON_ASSERT(M_plus.e <= kGamma);
+
+    std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
+    std::uint64_t dist  = diyfp::sub(M_plus, w      ).f; // (significand of (M+ - w ), implicit exponent is e)
+
+    // Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
+    //
+    //      M+ = f * 2^e
+    //         = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e
+    //         = ((p1        ) * 2^-e + (p2        )) * 2^e
+    //         = p1 + p2 * 2^e
+
+    const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
+
+    auto p1 = static_cast<std::uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
+    std::uint64_t p2 = M_plus.f & (one.f - 1);                    // p2 = f mod 2^-e
+
+    // 1)
+    //
+    // Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]
+
+    JSON_ASSERT(p1 > 0);
+
+    std::uint32_t pow10;
+    const int k = find_largest_pow10(p1, pow10);
+
+    //      10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
+    //
+    //      p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))
+    //         = (d[k-1]         ) * 10^(k-1) + (p1 mod 10^(k-1))
+    //
+    //      M+ = p1                                             + p2 * 2^e
+    //         = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1))          + p2 * 2^e
+    //         = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e
+    //         = d[k-1] * 10^(k-1) + (                         rest) * 2^e
+    //
+    // Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)
+    //
+    //      p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]
+    //
+    // but stop as soon as
+    //
+    //      rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e
+
+    int n = k;
+    while (n > 0)
+    {
+        // Invariants:
+        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)    (buffer = 0 for n = k)
+        //      pow10 = 10^(n-1) <= p1 < 10^n
+        //
+        const std::uint32_t d = p1 / pow10;  // d = p1 div 10^(n-1)
+        const std::uint32_t r = p1 % pow10;  // r = p1 mod 10^(n-1)
+        //
+        //      M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
+        //         = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
+        //
+        JSON_ASSERT(d <= 9);
+        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
+        //
+        //      M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
+        //
+        p1 = r;
+        n--;
+        //
+        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)
+        //      pow10 = 10^n
+        //
+
+        // Now check if enough digits have been generated.
+        // Compute
+        //
+        //      p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e
+        //
+        // Note:
+        // Since rest and delta share the same exponent e, it suffices to
+        // compare the significands.
+        const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
+        if (rest <= delta)
+        {
+            // V = buffer * 10^n, with M- <= V <= M+.
+
+            decimal_exponent += n;
+
+            // We may now just stop. But instead look if the buffer could be
+            // decremented to bring V closer to w.
+            //
+            // pow10 = 10^n is now 1 ulp in the decimal representation V.
+            // The rounding procedure works with diyfp's with an implicit
+            // exponent of e.
+            //
+            //      10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
+            //
+            const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
+            grisu2_round(buffer, length, dist, delta, rest, ten_n);
+
+            return;
+        }
+
+        pow10 /= 10;
+        //
+        //      pow10 = 10^(n-1) <= p1 < 10^n
+        // Invariants restored.
+    }
+
+    // 2)
+    //
+    // The digits of the integral part have been generated:
+    //
+    //      M+ = d[k-1]...d[1]d[0] + p2 * 2^e
+    //         = buffer            + p2 * 2^e
+    //
+    // Now generate the digits of the fractional part p2 * 2^e.
+    //
+    // Note:
+    // No decimal point is generated: the exponent is adjusted instead.
+    //
+    // p2 actually represents the fraction
+    //
+    //      p2 * 2^e
+    //          = p2 / 2^-e
+    //          = d[-1] / 10^1 + d[-2] / 10^2 + ...
+    //
+    // Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)
+    //
+    //      p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m
+    //                      + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)
+    //
+    // using
+    //
+    //      10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)
+    //                = (                   d) * 2^-e + (                   r)
+    //
+    // or
+    //      10^m * p2 * 2^e = d + r * 2^e
+    //
+    // i.e.
+    //
+    //      M+ = buffer + p2 * 2^e
+    //         = buffer + 10^-m * (d + r * 2^e)
+    //         = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e
+    //
+    // and stop as soon as 10^-m * r * 2^e <= delta * 2^e
+
+    JSON_ASSERT(p2 > delta);
+
+    int m = 0;
+    for (;;)
+    {
+        // Invariant:
+        //      M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e
+        //         = buffer * 10^-m + 10^-m * (p2                                 ) * 2^e
+        //         = buffer * 10^-m + 10^-m * (1/10 * (10 * p2)                   ) * 2^e
+        //         = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e
+        //
+        JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
+        p2 *= 10;
+        const std::uint64_t d = p2 >> -one.e;     // d = (10 * p2) div 2^-e
+        const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
+        //
+        //      M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
+        //         = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
+        //         = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
+        //
+        JSON_ASSERT(d <= 9);
+        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
+        //
+        //      M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
+        //
+        p2 = r;
+        m++;
+        //
+        //      M+ = buffer * 10^-m + 10^-m * p2 * 2^e
+        // Invariant restored.
+
+        // Check if enough digits have been generated.
+        //
+        //      10^-m * p2 * 2^e <= delta * 2^e
+        //              p2 * 2^e <= 10^m * delta * 2^e
+        //                    p2 <= 10^m * delta
+        delta *= 10;
+        dist  *= 10;
+        if (p2 <= delta)
+        {
+            break;
+        }
+    }
+
+    // V = buffer * 10^-m, with M- <= V <= M+.
+
+    decimal_exponent -= m;
+
+    // 1 ulp in the decimal representation is now 10^-m.
+    // Since delta and dist are now scaled by 10^m, we need to do the
+    // same with ulp in order to keep the units in sync.
+    //
+    //      10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
+    //
+    const std::uint64_t ten_m = one.f;
+    grisu2_round(buffer, length, dist, delta, p2, ten_m);
+
+    // By construction this algorithm generates the shortest possible decimal
+    // number (Loitsch, Theorem 6.2) which rounds back to w.
+    // For an input number of precision p, at least
+    //
+    //      N = 1 + ceil(p * log_10(2))
+    //
+    // decimal digits are sufficient to identify all binary floating-point
+    // numbers (Matula, "In-and-Out conversions").
+    // This implies that the algorithm does not produce more than N decimal
+    // digits.
+    //
+    //      N = 17 for p = 53 (IEEE double precision)
+    //      N = 9  for p = 24 (IEEE single precision)
+}
+
+/*!
+v = buf * 10^decimal_exponent
+len is the length of the buffer (number of decimal digits)
+The buffer must be large enough, i.e. >= max_digits10.
+*/
+JSON_HEDLEY_NON_NULL(1)
+inline void grisu2(char* buf, int& len, int& decimal_exponent,
+                   diyfp m_minus, diyfp v, diyfp m_plus)
+{
+    JSON_ASSERT(m_plus.e == m_minus.e);
+    JSON_ASSERT(m_plus.e == v.e);
+
+    //  --------(-----------------------+-----------------------)--------    (A)
+    //          m-                      v                       m+
+    //
+    //  --------------------(-----------+-----------------------)--------    (B)
+    //                      m-          v                       m+
+    //
+    // First scale v (and m- and m+) such that the exponent is in the range
+    // [alpha, gamma].
+
+    const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
+
+    const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k
+
+    // The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]
+    const diyfp w       = diyfp::mul(v,       c_minus_k);
+    const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
+    const diyfp w_plus  = diyfp::mul(m_plus,  c_minus_k);
+
+    //  ----(---+---)---------------(---+---)---------------(---+---)----
+    //          w-                      w                       w+
+    //          = c*m-                  = c*v                   = c*m+
+    //
+    // diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
+    // w+ are now off by a small amount.
+    // In fact:
+    //
+    //      w - v * 10^k < 1 ulp
+    //
+    // To account for this inaccuracy, add resp. subtract 1 ulp.
+    //
+    //  --------+---[---------------(---+---)---------------]---+--------
+    //          w-  M-                  w                   M+  w+
+    //
+    // Now any number in [M-, M+] (bounds included) will round to w when input,
+    // regardless of how the input rounding algorithm breaks ties.
+    //
+    // And digit_gen generates the shortest possible such number in [M-, M+].
+    // Note that this does not mean that Grisu2 always generates the shortest
+    // possible number in the interval (m-, m+).
+    const diyfp M_minus(w_minus.f + 1, w_minus.e);
+    const diyfp M_plus (w_plus.f  - 1, w_plus.e );
+
+    decimal_exponent = -cached.k; // = -(-k) = k
+
+    grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
+}
+
+/*!
+v = buf * 10^decimal_exponent
+len is the length of the buffer (number of decimal digits)
+The buffer must be large enough, i.e. >= max_digits10.
+*/
+template<typename FloatType>
+JSON_HEDLEY_NON_NULL(1)
+void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
+{
+    static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
+                  "internal error: not enough precision");
+
+    JSON_ASSERT(std::isfinite(value));
+    JSON_ASSERT(value > 0);
+
+    // If the neighbors (and boundaries) of 'value' are always computed for double-precision
+    // numbers, all float's can be recovered using strtod (and strtof). However, the resulting
+    // decimal representations are not exactly "short".
+    //
+    // The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars)
+    // says "value is converted to a string as if by std::sprintf in the default ("C") locale"
+    // and since sprintf promotes float's to double's, I think this is exactly what 'std::to_chars'
+    // does.
+    // On the other hand, the documentation for 'std::to_chars' requires that "parsing the
+    // representation using the corresponding std::from_chars function recovers value exactly". That
+    // indicates that single precision floating-point numbers should be recovered using
+    // 'std::strtof'.
+    //
+    // NB: If the neighbors are computed for single-precision numbers, there is a single float
+    //     (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision
+    //     value is off by 1 ulp.
+#if 0
+    const boundaries w = compute_boundaries(static_cast<double>(value));
+#else
+    const boundaries w = compute_boundaries(value);
+#endif
+
+    grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
+}
+
+/*!
+@brief appends a decimal representation of e to buf
+@return a pointer to the element following the exponent.
+@pre -1000 < e < 1000
+*/
+JSON_HEDLEY_NON_NULL(1)
+JSON_HEDLEY_RETURNS_NON_NULL
+inline char* append_exponent(char* buf, int e)
+{
+    JSON_ASSERT(e > -1000);
+    JSON_ASSERT(e <  1000);
+
+    if (e < 0)
+    {
+        e = -e;
+        *buf++ = '-';
+    }
+    else
+    {
+        *buf++ = '+';
+    }
+
+    auto k = static_cast<std::uint32_t>(e);
+    if (k < 10)
+    {
+        // Always print at least two digits in the exponent.
+        // This is for compatibility with printf("%g").
+        *buf++ = '0';
+        *buf++ = static_cast<char>('0' + k);
+    }
+    else if (k < 100)
+    {
+        *buf++ = static_cast<char>('0' + k / 10);
+        k %= 10;
+        *buf++ = static_cast<char>('0' + k);
+    }
+    else
+    {
+        *buf++ = static_cast<char>('0' + k / 100);
+        k %= 100;
+        *buf++ = static_cast<char>('0' + k / 10);
+        k %= 10;
+        *buf++ = static_cast<char>('0' + k);
+    }
+
+    return buf;
+}
+
+/*!
+@brief prettify v = buf * 10^decimal_exponent
+
+If v is in the range [10^min_exp, 10^max_exp) it will be printed in fixed-point
+notation. Otherwise it will be printed in exponential notation.
+
+@pre min_exp < 0
+@pre max_exp > 0
+*/
+JSON_HEDLEY_NON_NULL(1)
+JSON_HEDLEY_RETURNS_NON_NULL
+inline char* format_buffer(char* buf, int len, int decimal_exponent,
+                           int min_exp, int max_exp)
+{
+    JSON_ASSERT(min_exp < 0);
+    JSON_ASSERT(max_exp > 0);
+
+    const int k = len;
+    const int n = len + decimal_exponent;
+
+    // v = buf * 10^(n-k)
+    // k is the length of the buffer (number of decimal digits)
+    // n is the position of the decimal point relative to the start of the buffer.
+
+    if (k <= n && n <= max_exp)
+    {
+        // digits[000]
+        // len <= max_exp + 2
+
+        std::memset(buf + k, '0', static_cast<size_t>(n) - static_cast<size_t>(k));
+        // Make it look like a floating-point number (#362, #378)
+        buf[n + 0] = '.';
+        buf[n + 1] = '0';
+        return buf + (static_cast<size_t>(n) + 2);
+    }
+
+    if (0 < n && n <= max_exp)
+    {
+        // dig.its
+        // len <= max_digits10 + 1
+
+        JSON_ASSERT(k > n);
+
+        std::memmove(buf + (static_cast<size_t>(n) + 1), buf + n, static_cast<size_t>(k) - static_cast<size_t>(n));
+        buf[n] = '.';
+        return buf + (static_cast<size_t>(k) + 1U);
+    }
+
+    if (min_exp < n && n <= 0)
+    {
+        // 0.[000]digits
+        // len <= 2 + (-min_exp - 1) + max_digits10
+
+        std::memmove(buf + (2 + static_cast<size_t>(-n)), buf, static_cast<size_t>(k));
+        buf[0] = '0';
+        buf[1] = '.';
+        std::memset(buf + 2, '0', static_cast<size_t>(-n));
+        return buf + (2U + static_cast<size_t>(-n) + static_cast<size_t>(k));
+    }
+
+    if (k == 1)
+    {
+        // dE+123
+        // len <= 1 + 5
+
+        buf += 1;
+    }
+    else
+    {
+        // d.igitsE+123
+        // len <= max_digits10 + 1 + 5
+
+        std::memmove(buf + 2, buf + 1, static_cast<size_t>(k) - 1);
+        buf[1] = '.';
+        buf += 1 + static_cast<size_t>(k);
+    }
+
+    *buf++ = 'e';
+    return append_exponent(buf, n - 1);
+}
+
+} // namespace dtoa_impl
+
+/*!
+@brief generates a decimal representation of the floating-point number value in [first, last).
+
+The format of the resulting decimal representation is similar to printf's %g
+format. Returns an iterator pointing past-the-end of the decimal representation.
+
+@note The input number must be finite, i.e. NaN's and Inf's are not supported.
+@note The buffer must be large enough.
+@note The result is NOT null-terminated.
+*/
+template<typename FloatType>
+JSON_HEDLEY_NON_NULL(1, 2)
+JSON_HEDLEY_RETURNS_NON_NULL
+char* to_chars(char* first, const char* last, FloatType value)
+{
+    static_cast<void>(last); // maybe unused - fix warning
+    JSON_ASSERT(std::isfinite(value));
+
+    // Use signbit(value) instead of (value < 0) since signbit works for -0.
+    if (std::signbit(value))
+    {
+        value = -value;
+        *first++ = '-';
+    }
+
+    if (value == 0) // +-0
+    {
+        *first++ = '0';
+        // Make it look like a floating-point number (#362, #378)
+        *first++ = '.';
+        *first++ = '0';
+        return first;
+    }
+
+    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
+
+    // Compute v = buffer * 10^decimal_exponent.
+    // The decimal digits are stored in the buffer, which needs to be interpreted
+    // as an unsigned decimal integer.
+    // len is the length of the buffer, i.e. the number of decimal digits.
+    int len = 0;
+    int decimal_exponent = 0;
+    dtoa_impl::grisu2(first, len, decimal_exponent, value);
+
+    JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10);
+
+    // Format the buffer like printf("%.*g", prec, value)
+    constexpr int kMinExp = -4;
+    // Use digits10 here to increase compatibility with version 2.
+    constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;
+
+    JSON_ASSERT(last - first >= kMaxExp + 2);
+    JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
+    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
+
+    return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
+}
+
+} // namespace detail
+} // namespace nlohmann
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/output/binary_writer.hpp>
+
+// #include <nlohmann/detail/output/output_adapters.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+///////////////////
+// serialization //
+///////////////////
+
+/// how to treat decoding errors
+enum class error_handler_t
+{
+    strict,  ///< throw a type_error exception in case of invalid UTF-8
+    replace, ///< replace invalid UTF-8 sequences with U+FFFD
+    ignore   ///< ignore invalid UTF-8 sequences
+};
+
+template<typename BasicJsonType>
+class serializer
+{
+    using string_t = typename BasicJsonType::string_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using binary_char_t = typename BasicJsonType::binary_t::value_type;
+    static constexpr std::uint8_t UTF8_ACCEPT = 0;
+    static constexpr std::uint8_t UTF8_REJECT = 1;
+
+  public:
+    /*!
+    @param[in] s  output stream to serialize to
+    @param[in] ichar  indentation character to use
+    @param[in] error_handler_  how to react on decoding errors
+    */
+    serializer(output_adapter_t<char> s, const char ichar,
+               error_handler_t error_handler_ = error_handler_t::strict)
+        : o(std::move(s))
+        , loc(std::localeconv())
+        , thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
+        , decimal_point(loc->decimal_point == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point)))
+        , indent_char(ichar)
+        , indent_string(512, indent_char)
+        , error_handler(error_handler_)
+    {}
+
+    // delete because of pointer members
+    serializer(const serializer&) = delete;
+    serializer& operator=(const serializer&) = delete;
+    serializer(serializer&&) = delete;
+    serializer& operator=(serializer&&) = delete;
+    ~serializer() = default;
+
+    /*!
+    @brief internal implementation of the serialization function
+
+    This function is called by the public member function dump and organizes
+    the serialization internally. The indentation level is propagated as
+    additional parameter. In case of arrays and objects, the function is
+    called recursively.
+
+    - strings and object keys are escaped using `escape_string()`
+    - integer numbers are converted implicitly via `operator<<`
+    - floating-point numbers are converted to a string using `"%g"` format
+    - binary values are serialized as objects containing the subtype and the
+      byte array
+
+    @param[in] val               value to serialize
+    @param[in] pretty_print      whether the output shall be pretty-printed
+    @param[in] ensure_ascii If @a ensure_ascii is true, all non-ASCII characters
+    in the output are escaped with `\uXXXX` sequences, and the result consists
+    of ASCII characters only.
+    @param[in] indent_step       the indent level
+    @param[in] current_indent    the current indent level (only used internally)
+    */
+    void dump(const BasicJsonType& val,
+              const bool pretty_print,
+              const bool ensure_ascii,
+              const unsigned int indent_step,
+              const unsigned int current_indent = 0)
+    {
+        switch (val.m_type)
+        {
+            case value_t::object:
+            {
+                if (val.m_value.object->empty())
+                {
+                    o->write_characters("{}", 2);
+                    return;
+                }
+
+                if (pretty_print)
+                {
+                    o->write_characters("{\n", 2);
+
+                    // variable to hold indentation for recursive calls
+                    const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
+                    {
+                        indent_string.resize(indent_string.size() * 2, ' ');
+                    }
+
+                    // first n-1 elements
+                    auto i = val.m_value.object->cbegin();
+                    for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
+                    {
+                        o->write_characters(indent_string.c_str(), new_indent);
+                        o->write_character('\"');
+                        dump_escaped(i->first, ensure_ascii);
+                        o->write_characters("\": ", 3);
+                        dump(i->second, true, ensure_ascii, indent_step, new_indent);
+                        o->write_characters(",\n", 2);
+                    }
+
+                    // last element
+                    JSON_ASSERT(i != val.m_value.object->cend());
+                    JSON_ASSERT(std::next(i) == val.m_value.object->cend());
+                    o->write_characters(indent_string.c_str(), new_indent);
+                    o->write_character('\"');
+                    dump_escaped(i->first, ensure_ascii);
+                    o->write_characters("\": ", 3);
+                    dump(i->second, true, ensure_ascii, indent_step, new_indent);
+
+                    o->write_character('\n');
+                    o->write_characters(indent_string.c_str(), current_indent);
+                    o->write_character('}');
+                }
+                else
+                {
+                    o->write_character('{');
+
+                    // first n-1 elements
+                    auto i = val.m_value.object->cbegin();
+                    for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
+                    {
+                        o->write_character('\"');
+                        dump_escaped(i->first, ensure_ascii);
+                        o->write_characters("\":", 2);
+                        dump(i->second, false, ensure_ascii, indent_step, current_indent);
+                        o->write_character(',');
+                    }
+
+                    // last element
+                    JSON_ASSERT(i != val.m_value.object->cend());
+                    JSON_ASSERT(std::next(i) == val.m_value.object->cend());
+                    o->write_character('\"');
+                    dump_escaped(i->first, ensure_ascii);
+                    o->write_characters("\":", 2);
+                    dump(i->second, false, ensure_ascii, indent_step, current_indent);
+
+                    o->write_character('}');
+                }
+
+                return;
+            }
+
+            case value_t::array:
+            {
+                if (val.m_value.array->empty())
+                {
+                    o->write_characters("[]", 2);
+                    return;
+                }
+
+                if (pretty_print)
+                {
+                    o->write_characters("[\n", 2);
+
+                    // variable to hold indentation for recursive calls
+                    const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
+                    {
+                        indent_string.resize(indent_string.size() * 2, ' ');
+                    }
+
+                    // first n-1 elements
+                    for (auto i = val.m_value.array->cbegin();
+                            i != val.m_value.array->cend() - 1; ++i)
+                    {
+                        o->write_characters(indent_string.c_str(), new_indent);
+                        dump(*i, true, ensure_ascii, indent_step, new_indent);
+                        o->write_characters(",\n", 2);
+                    }
+
+                    // last element
+                    JSON_ASSERT(!val.m_value.array->empty());
+                    o->write_characters(indent_string.c_str(), new_indent);
+                    dump(val.m_value.array->back(), true, ensure_ascii, indent_step, new_indent);
+
+                    o->write_character('\n');
+                    o->write_characters(indent_string.c_str(), current_indent);
+                    o->write_character(']');
+                }
+                else
+                {
+                    o->write_character('[');
+
+                    // first n-1 elements
+                    for (auto i = val.m_value.array->cbegin();
+                            i != val.m_value.array->cend() - 1; ++i)
+                    {
+                        dump(*i, false, ensure_ascii, indent_step, current_indent);
+                        o->write_character(',');
+                    }
+
+                    // last element
+                    JSON_ASSERT(!val.m_value.array->empty());
+                    dump(val.m_value.array->back(), false, ensure_ascii, indent_step, current_indent);
+
+                    o->write_character(']');
+                }
+
+                return;
+            }
+
+            case value_t::string:
+            {
+                o->write_character('\"');
+                dump_escaped(*val.m_value.string, ensure_ascii);
+                o->write_character('\"');
+                return;
+            }
+
+            case value_t::binary:
+            {
+                if (pretty_print)
+                {
+                    o->write_characters("{\n", 2);
+
+                    // variable to hold indentation for recursive calls
+                    const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
+                    {
+                        indent_string.resize(indent_string.size() * 2, ' ');
+                    }
+
+                    o->write_characters(indent_string.c_str(), new_indent);
+
+                    o->write_characters("\"bytes\": [", 10);
+
+                    if (!val.m_value.binary->empty())
+                    {
+                        for (auto i = val.m_value.binary->cbegin();
+                                i != val.m_value.binary->cend() - 1; ++i)
+                        {
+                            dump_integer(*i);
+                            o->write_characters(", ", 2);
+                        }
+                        dump_integer(val.m_value.binary->back());
+                    }
+
+                    o->write_characters("],\n", 3);
+                    o->write_characters(indent_string.c_str(), new_indent);
+
+                    o->write_characters("\"subtype\": ", 11);
+                    if (val.m_value.binary->has_subtype())
+                    {
+                        dump_integer(val.m_value.binary->subtype());
+                    }
+                    else
+                    {
+                        o->write_characters("null", 4);
+                    }
+                    o->write_character('\n');
+                    o->write_characters(indent_string.c_str(), current_indent);
+                    o->write_character('}');
+                }
+                else
+                {
+                    o->write_characters("{\"bytes\":[", 10);
+
+                    if (!val.m_value.binary->empty())
+                    {
+                        for (auto i = val.m_value.binary->cbegin();
+                                i != val.m_value.binary->cend() - 1; ++i)
+                        {
+                            dump_integer(*i);
+                            o->write_character(',');
+                        }
+                        dump_integer(val.m_value.binary->back());
+                    }
+
+                    o->write_characters("],\"subtype\":", 12);
+                    if (val.m_value.binary->has_subtype())
+                    {
+                        dump_integer(val.m_value.binary->subtype());
+                        o->write_character('}');
+                    }
+                    else
+                    {
+                        o->write_characters("null}", 5);
+                    }
+                }
+                return;
+            }
+
+            case value_t::boolean:
+            {
+                if (val.m_value.boolean)
+                {
+                    o->write_characters("true", 4);
+                }
+                else
+                {
+                    o->write_characters("false", 5);
+                }
+                return;
+            }
+
+            case value_t::number_integer:
+            {
+                dump_integer(val.m_value.number_integer);
+                return;
+            }
+
+            case value_t::number_unsigned:
+            {
+                dump_integer(val.m_value.number_unsigned);
+                return;
+            }
+
+            case value_t::number_float:
+            {
+                dump_float(val.m_value.number_float);
+                return;
+            }
+
+            case value_t::discarded:
+            {
+                o->write_characters("<discarded>", 11);
+                return;
+            }
+
+            case value_t::null:
+            {
+                o->write_characters("null", 4);
+                return;
+            }
+
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false);  // LCOV_EXCL_LINE
+        }
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /*!
+    @brief dump escaped string
+
+    Escape a string by replacing certain special characters by a sequence of an
+    escape character (backslash) and another character and other control
+    characters by a sequence of "\u" followed by a four-digit hex
+    representation. The escaped string is written to output stream @a o.
+
+    @param[in] s  the string to escape
+    @param[in] ensure_ascii  whether to escape non-ASCII characters with
+                             \uXXXX sequences
+
+    @complexity Linear in the length of string @a s.
+    */
+    void dump_escaped(const string_t& s, const bool ensure_ascii)
+    {
+        std::uint32_t codepoint;
+        std::uint8_t state = UTF8_ACCEPT;
+        std::size_t bytes = 0;  // number of bytes written to string_buffer
+
+        // number of bytes written at the point of the last valid byte
+        std::size_t bytes_after_last_accept = 0;
+        std::size_t undumped_chars = 0;
+
+        for (std::size_t i = 0; i < s.size(); ++i)
+        {
+            const auto byte = static_cast<uint8_t>(s[i]);
+
+            switch (decode(state, codepoint, byte))
+            {
+                case UTF8_ACCEPT:  // decode found a new code point
+                {
+                    switch (codepoint)
+                    {
+                        case 0x08: // backspace
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'b';
+                            break;
+                        }
+
+                        case 0x09: // horizontal tab
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 't';
+                            break;
+                        }
+
+                        case 0x0A: // newline
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'n';
+                            break;
+                        }
+
+                        case 0x0C: // formfeed
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'f';
+                            break;
+                        }
+
+                        case 0x0D: // carriage return
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'r';
+                            break;
+                        }
+
+                        case 0x22: // quotation mark
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = '\"';
+                            break;
+                        }
+
+                        case 0x5C: // reverse solidus
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = '\\';
+                            break;
+                        }
+
+                        default:
+                        {
+                            // escape control characters (0x00..0x1F) or, if
+                            // ensure_ascii parameter is used, non-ASCII characters
+                            if ((codepoint <= 0x1F) || (ensure_ascii && (codepoint >= 0x7F)))
+                            {
+                                if (codepoint <= 0xFFFF)
+                                {
+                                    (std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x",
+                                                    static_cast<std::uint16_t>(codepoint));
+                                    bytes += 6;
+                                }
+                                else
+                                {
+                                    (std::snprintf)(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",
+                                                    static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)),
+                                                    static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu)));
+                                    bytes += 12;
+                                }
+                            }
+                            else
+                            {
+                                // copy byte to buffer (all previous bytes
+                                // been copied have in default case above)
+                                string_buffer[bytes++] = s[i];
+                            }
+                            break;
+                        }
+                    }
+
+                    // write buffer and reset index; there must be 13 bytes
+                    // left, as this is the maximal number of bytes to be
+                    // written ("\uxxxx\uxxxx\0") for one code point
+                    if (string_buffer.size() - bytes < 13)
+                    {
+                        o->write_characters(string_buffer.data(), bytes);
+                        bytes = 0;
+                    }
+
+                    // remember the byte position of this accept
+                    bytes_after_last_accept = bytes;
+                    undumped_chars = 0;
+                    break;
+                }
+
+                case UTF8_REJECT:  // decode found invalid UTF-8 byte
+                {
+                    switch (error_handler)
+                    {
+                        case error_handler_t::strict:
+                        {
+                            std::string sn(3, '\0');
+                            (std::snprintf)(&sn[0], sn.size(), "%.2X", byte);
+                            JSON_THROW(type_error::create(316, "invalid UTF-8 byte at index " + std::to_string(i) + ": 0x" + sn));
+                        }
+
+                        case error_handler_t::ignore:
+                        case error_handler_t::replace:
+                        {
+                            // in case we saw this character the first time, we
+                            // would like to read it again, because the byte
+                            // may be OK for itself, but just not OK for the
+                            // previous sequence
+                            if (undumped_chars > 0)
+                            {
+                                --i;
+                            }
+
+                            // reset length buffer to the last accepted index;
+                            // thus removing/ignoring the invalid characters
+                            bytes = bytes_after_last_accept;
+
+                            if (error_handler == error_handler_t::replace)
+                            {
+                                // add a replacement character
+                                if (ensure_ascii)
+                                {
+                                    string_buffer[bytes++] = '\\';
+                                    string_buffer[bytes++] = 'u';
+                                    string_buffer[bytes++] = 'f';
+                                    string_buffer[bytes++] = 'f';
+                                    string_buffer[bytes++] = 'f';
+                                    string_buffer[bytes++] = 'd';
+                                }
+                                else
+                                {
+                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xEF');
+                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBF');
+                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBD');
+                                }
+
+                                // write buffer and reset index; there must be 13 bytes
+                                // left, as this is the maximal number of bytes to be
+                                // written ("\uxxxx\uxxxx\0") for one code point
+                                if (string_buffer.size() - bytes < 13)
+                                {
+                                    o->write_characters(string_buffer.data(), bytes);
+                                    bytes = 0;
+                                }
+
+                                bytes_after_last_accept = bytes;
+                            }
+
+                            undumped_chars = 0;
+
+                            // continue processing the string
+                            state = UTF8_ACCEPT;
+                            break;
+                        }
+
+                        default:            // LCOV_EXCL_LINE
+                            JSON_ASSERT(false);  // LCOV_EXCL_LINE
+                    }
+                    break;
+                }
+
+                default:  // decode found yet incomplete multi-byte code point
+                {
+                    if (!ensure_ascii)
+                    {
+                        // code point will not be escaped - copy byte to buffer
+                        string_buffer[bytes++] = s[i];
+                    }
+                    ++undumped_chars;
+                    break;
+                }
+            }
+        }
+
+        // we finished processing the string
+        if (JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT))
+        {
+            // write buffer
+            if (bytes > 0)
+            {
+                o->write_characters(string_buffer.data(), bytes);
+            }
+        }
+        else
+        {
+            // we finish reading, but do not accept: string was incomplete
+            switch (error_handler)
+            {
+                case error_handler_t::strict:
+                {
+                    std::string sn(3, '\0');
+                    (std::snprintf)(&sn[0], sn.size(), "%.2X", static_cast<std::uint8_t>(s.back()));
+                    JSON_THROW(type_error::create(316, "incomplete UTF-8 string; last byte: 0x" + sn));
+                }
+
+                case error_handler_t::ignore:
+                {
+                    // write all accepted bytes
+                    o->write_characters(string_buffer.data(), bytes_after_last_accept);
+                    break;
+                }
+
+                case error_handler_t::replace:
+                {
+                    // write all accepted bytes
+                    o->write_characters(string_buffer.data(), bytes_after_last_accept);
+                    // add a replacement character
+                    if (ensure_ascii)
+                    {
+                        o->write_characters("\\ufffd", 6);
+                    }
+                    else
+                    {
+                        o->write_characters("\xEF\xBF\xBD", 3);
+                    }
+                    break;
+                }
+
+                default:            // LCOV_EXCL_LINE
+                    JSON_ASSERT(false);  // LCOV_EXCL_LINE
+            }
+        }
+    }
+
+  private:
+    /*!
+    @brief count digits
+
+    Count the number of decimal (base 10) digits for an input unsigned integer.
+
+    @param[in] x  unsigned integer number to count its digits
+    @return    number of decimal digits
+    */
+    inline unsigned int count_digits(number_unsigned_t x) noexcept
+    {
+        unsigned int n_digits = 1;
+        for (;;)
+        {
+            if (x < 10)
+            {
+                return n_digits;
+            }
+            if (x < 100)
+            {
+                return n_digits + 1;
+            }
+            if (x < 1000)
+            {
+                return n_digits + 2;
+            }
+            if (x < 10000)
+            {
+                return n_digits + 3;
+            }
+            x = x / 10000u;
+            n_digits += 4;
+        }
+    }
+
+    /*!
+    @brief dump an integer
+
+    Dump a given integer to output stream @a o. Works internally with
+    @a number_buffer.
+
+    @param[in] x  integer number (signed or unsigned) to dump
+    @tparam NumberType either @a number_integer_t or @a number_unsigned_t
+    */
+    template < typename NumberType, detail::enable_if_t <
+                   std::is_same<NumberType, number_unsigned_t>::value ||
+                   std::is_same<NumberType, number_integer_t>::value ||
+                   std::is_same<NumberType, binary_char_t>::value,
+                   int > = 0 >
+    void dump_integer(NumberType x)
+    {
+        static constexpr std::array<std::array<char, 2>, 100> digits_to_99
+        {
+            {
+                {{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
+                {{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}},
+                {{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}},
+                {{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}},
+                {{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}},
+                {{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}},
+                {{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}},
+                {{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}},
+                {{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}},
+                {{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}},
+            }
+        };
+
+        // special case for "0"
+        if (x == 0)
+        {
+            o->write_character('0');
+            return;
+        }
+
+        // use a pointer to fill the buffer
+        auto buffer_ptr = number_buffer.begin();
+
+        const bool is_negative = std::is_same<NumberType, number_integer_t>::value && !(x >= 0); // see issue #755
+        number_unsigned_t abs_value;
+
+        unsigned int n_chars;
+
+        if (is_negative)
+        {
+            *buffer_ptr = '-';
+            abs_value = remove_sign(static_cast<number_integer_t>(x));
+
+            // account one more byte for the minus sign
+            n_chars = 1 + count_digits(abs_value);
+        }
+        else
+        {
+            abs_value = static_cast<number_unsigned_t>(x);
+            n_chars = count_digits(abs_value);
+        }
+
+        // spare 1 byte for '\0'
+        JSON_ASSERT(n_chars < number_buffer.size() - 1);
+
+        // jump to the end to generate the string from backward
+        // so we later avoid reversing the result
+        buffer_ptr += n_chars;
+
+        // Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu
+        // See: https://www.youtube.com/watch?v=o4-CwDo2zpg
+        while (abs_value >= 100)
+        {
+            const auto digits_index = static_cast<unsigned>((abs_value % 100));
+            abs_value /= 100;
+            *(--buffer_ptr) = digits_to_99[digits_index][1];
+            *(--buffer_ptr) = digits_to_99[digits_index][0];
+        }
+
+        if (abs_value >= 10)
+        {
+            const auto digits_index = static_cast<unsigned>(abs_value);
+            *(--buffer_ptr) = digits_to_99[digits_index][1];
+            *(--buffer_ptr) = digits_to_99[digits_index][0];
+        }
+        else
+        {
+            *(--buffer_ptr) = static_cast<char>('0' + abs_value);
+        }
+
+        o->write_characters(number_buffer.data(), n_chars);
+    }
+
+    /*!
+    @brief dump a floating-point number
+
+    Dump a given floating-point number to output stream @a o. Works internally
+    with @a number_buffer.
+
+    @param[in] x  floating-point number to dump
+    */
+    void dump_float(number_float_t x)
+    {
+        // NaN / inf
+        if (!std::isfinite(x))
+        {
+            o->write_characters("null", 4);
+            return;
+        }
+
+        // If number_float_t is an IEEE-754 single or double precision number,
+        // use the Grisu2 algorithm to produce short numbers which are
+        // guaranteed to round-trip, using strtof and strtod, resp.
+        //
+        // NB: The test below works if <long double> == <double>.
+        static constexpr bool is_ieee_single_or_double
+            = (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 24 && std::numeric_limits<number_float_t>::max_exponent == 128) ||
+              (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 53 && std::numeric_limits<number_float_t>::max_exponent == 1024);
+
+        dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
+    }
+
+    void dump_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/)
+    {
+        char* begin = number_buffer.data();
+        char* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);
+
+        o->write_characters(begin, static_cast<size_t>(end - begin));
+    }
+
+    void dump_float(number_float_t x, std::false_type /*is_ieee_single_or_double*/)
+    {
+        // get number of digits for a float -> text -> float round-trip
+        static constexpr auto d = std::numeric_limits<number_float_t>::max_digits10;
+
+        // the actual conversion
+        std::ptrdiff_t len = (std::snprintf)(number_buffer.data(), number_buffer.size(), "%.*g", d, x);
+
+        // negative value indicates an error
+        JSON_ASSERT(len > 0);
+        // check if buffer was large enough
+        JSON_ASSERT(static_cast<std::size_t>(len) < number_buffer.size());
+
+        // erase thousands separator
+        if (thousands_sep != '\0')
+        {
+            const auto end = std::remove(number_buffer.begin(),
+                                         number_buffer.begin() + len, thousands_sep);
+            std::fill(end, number_buffer.end(), '\0');
+            JSON_ASSERT((end - number_buffer.begin()) <= len);
+            len = (end - number_buffer.begin());
+        }
+
+        // convert decimal point to '.'
+        if (decimal_point != '\0' && decimal_point != '.')
+        {
+            const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
+            if (dec_pos != number_buffer.end())
+            {
+                *dec_pos = '.';
+            }
+        }
+
+        o->write_characters(number_buffer.data(), static_cast<std::size_t>(len));
+
+        // determine if need to append ".0"
+        const bool value_is_int_like =
+            std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
+                         [](char c)
+        {
+            return c == '.' || c == 'e';
+        });
+
+        if (value_is_int_like)
+        {
+            o->write_characters(".0", 2);
+        }
+    }
+
+    /*!
+    @brief check whether a string is UTF-8 encoded
+
+    The function checks each byte of a string whether it is UTF-8 encoded. The
+    result of the check is stored in the @a state parameter. The function must
+    be called initially with state 0 (accept). State 1 means the string must
+    be rejected, because the current byte is not allowed. If the string is
+    completely processed, but the state is non-zero, the string ended
+    prematurely; that is, the last byte indicated more bytes should have
+    followed.
+
+    @param[in,out] state  the state of the decoding
+    @param[in,out] codep  codepoint (valid only if resulting state is UTF8_ACCEPT)
+    @param[in] byte       next byte to decode
+    @return               new state
+
+    @note The function has been edited: a std::array is used.
+
+    @copyright Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
+    @sa http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
+    */
+    static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept
+    {
+        static const std::array<std::uint8_t, 400> utf8d =
+        {
+            {
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00..1F
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20..3F
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 40..5F
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 60..7F
+                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // 80..9F
+                7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // A0..BF
+                8, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // C0..DF
+                0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF
+                0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF
+                0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0
+                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, // s1..s2
+                1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, // s3..s4
+                1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, // s5..s6
+                1, 3, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // s7..s8
+            }
+        };
+
+        const std::uint8_t type = utf8d[byte];
+
+        codep = (state != UTF8_ACCEPT)
+                ? (byte & 0x3fu) | (codep << 6u)
+                : (0xFFu >> type) & (byte);
+
+        std::size_t index = 256u + static_cast<size_t>(state) * 16u + static_cast<size_t>(type);
+        JSON_ASSERT(index < 400);
+        state = utf8d[index];
+        return state;
+    }
+
+    /*
+     * Overload to make the compiler happy while it is instantiating
+     * dump_integer for number_unsigned_t.
+     * Must never be called.
+     */
+    number_unsigned_t remove_sign(number_unsigned_t x)
+    {
+        JSON_ASSERT(false); // LCOV_EXCL_LINE
+        return x; // LCOV_EXCL_LINE
+    }
+
+    /*
+     * Helper function for dump_integer
+     *
+     * This function takes a negative signed integer and returns its absolute
+     * value as unsigned integer. The plus/minus shuffling is necessary as we can
+     * not directly remove the sign of an arbitrary signed integer as the
+     * absolute values of INT_MIN and INT_MAX are usually not the same. See
+     * #1708 for details.
+     */
+    inline number_unsigned_t remove_sign(number_integer_t x) noexcept
+    {
+        JSON_ASSERT(x < 0 && x < (std::numeric_limits<number_integer_t>::max)());
+        return static_cast<number_unsigned_t>(-(x + 1)) + 1;
+    }
+
+  private:
+    /// the output of the serializer
+    output_adapter_t<char> o = nullptr;
+
+    /// a (hopefully) large enough character buffer
+    std::array<char, 64> number_buffer{{}};
+
+    /// the locale
+    const std::lconv* loc = nullptr;
+    /// the locale's thousand separator character
+    const char thousands_sep = '\0';
+    /// the locale's decimal point character
+    const char decimal_point = '\0';
+
+    /// string buffer
+    std::array<char, 512> string_buffer{{}};
+
+    /// the indentation character
+    const char indent_char;
+    /// the indentation string
+    string_t indent_string;
+
+    /// error_handler how to react on decoding errors
+    const error_handler_t error_handler;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/value_t.hpp>
+
+// #include <nlohmann/json_fwd.hpp>
+
+// #include <nlohmann/ordered_map.hpp>
+
+
+#include <functional> // less
+#include <memory> // allocator
+#include <utility> // pair
+#include <vector> // vector
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+namespace nlohmann
+{
+
+/// ordered_map: a minimal map-like container that preserves insertion order
+/// for use within nlohmann::basic_json<ordered_map>
+template <class Key, class T, class IgnoredLess = std::less<Key>,
+          class Allocator = std::allocator<std::pair<const Key, T>>>
+                  struct ordered_map : std::vector<std::pair<const Key, T>, Allocator>
+{
+    using key_type = Key;
+    using mapped_type = T;
+    using Container = std::vector<std::pair<const Key, T>, Allocator>;
+    using typename Container::iterator;
+    using typename Container::const_iterator;
+    using typename Container::size_type;
+    using typename Container::value_type;
+
+    // Explicit constructors instead of `using Container::Container`
+    // otherwise older compilers choke on it (GCC <= 5.5, xcode <= 9.4)
+    ordered_map(const Allocator& alloc = Allocator()) : Container{alloc} {}
+    template <class It>
+    ordered_map(It first, It last, const Allocator& alloc = Allocator())
+        : Container{first, last, alloc} {}
+    ordered_map(std::initializer_list<T> init, const Allocator& alloc = Allocator() )
+        : Container{init, alloc} {}
+
+    std::pair<iterator, bool> emplace(const key_type& key, T&& t)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (it->first == key)
+            {
+                return {it, false};
+            }
+        }
+        Container::emplace_back(key, t);
+        return {--this->end(), true};
+    }
+
+    T& operator[](const Key& key)
+    {
+        return emplace(key, T{}).first->second;
+    }
+
+    const T& operator[](const Key& key) const
+    {
+        return at(key);
+    }
+
+    T& at(const Key& key)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (it->first == key)
+            {
+                return it->second;
+            }
+        }
+
+        JSON_THROW(std::out_of_range("key not found"));
+    }
+
+    const T& at(const Key& key) const
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (it->first == key)
+            {
+                return it->second;
+            }
+        }
+
+        JSON_THROW(std::out_of_range("key not found"));
+    }
+
+    size_type erase(const Key& key)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (it->first == key)
+            {
+                // Since we cannot move const Keys, re-construct them in place
+                for (auto next = it; ++next != this->end(); ++it)
+                {
+                    it->~value_type(); // Destroy but keep allocation
+                    new (&*it) value_type{std::move(*next)};
+                }
+                Container::pop_back();
+                return 1;
+            }
+        }
+        return 0;
+    }
+
+    iterator erase(iterator pos)
+    {
+        auto it = pos;
+
+        // Since we cannot move const Keys, re-construct them in place
+        for (auto next = it; ++next != this->end(); ++it)
+        {
+            it->~value_type(); // Destroy but keep allocation
+            new (&*it) value_type{std::move(*next)};
+        }
+        Container::pop_back();
+        return pos;
+    }
+
+    size_type count(const Key& key) const
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (it->first == key)
+            {
+                return 1;
+            }
+        }
+        return 0;
+    }
+
+    iterator find(const Key& key)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (it->first == key)
+            {
+                return it;
+            }
+        }
+        return Container::end();
+    }
+
+    const_iterator find(const Key& key) const
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (it->first == key)
+            {
+                return it;
+            }
+        }
+        return Container::end();
+    }
+
+    std::pair<iterator, bool> insert( value_type&& value )
+    {
+        return emplace(value.first, std::move(value.second));
+    }
+
+    std::pair<iterator, bool> insert( const value_type& value )
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (it->first == value.first)
+            {
+                return {it, false};
+            }
+        }
+        Container::push_back(value);
+        return {--this->end(), true};
+    }
+};
+
+}  // namespace nlohmann
+
+
+/*!
+@brief namespace for Niels Lohmann
+@see https://github.com/nlohmann
+@since version 1.0.0
+*/
+namespace nlohmann
+{
+
+/*!
+@brief a class to store JSON values
+
+@tparam ObjectType type for JSON objects (`std::map` by default; will be used
+in @ref object_t)
+@tparam ArrayType type for JSON arrays (`std::vector` by default; will be used
+in @ref array_t)
+@tparam StringType type for JSON strings and object keys (`std::string` by
+default; will be used in @ref string_t)
+@tparam BooleanType type for JSON booleans (`bool` by default; will be used
+in @ref boolean_t)
+@tparam NumberIntegerType type for JSON integer numbers (`int64_t` by
+default; will be used in @ref number_integer_t)
+@tparam NumberUnsignedType type for JSON unsigned integer numbers (@c
+`uint64_t` by default; will be used in @ref number_unsigned_t)
+@tparam NumberFloatType type for JSON floating-point numbers (`double` by
+default; will be used in @ref number_float_t)
+@tparam BinaryType type for packed binary data for compatibility with binary
+serialization formats (`std::vector<std::uint8_t>` by default; will be used in
+@ref binary_t)
+@tparam AllocatorType type of the allocator to use (`std::allocator` by
+default)
+@tparam JSONSerializer the serializer to resolve internal calls to `to_json()`
+and `from_json()` (@ref adl_serializer by default)
+
+@requirement The class satisfies the following concept requirements:
+- Basic
+ - [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible):
+   JSON values can be default constructed. The result will be a JSON null
+   value.
+ - [MoveConstructible](https://en.cppreference.com/w/cpp/named_req/MoveConstructible):
+   A JSON value can be constructed from an rvalue argument.
+ - [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible):
+   A JSON value can be copy-constructed from an lvalue expression.
+ - [MoveAssignable](https://en.cppreference.com/w/cpp/named_req/MoveAssignable):
+   A JSON value van be assigned from an rvalue argument.
+ - [CopyAssignable](https://en.cppreference.com/w/cpp/named_req/CopyAssignable):
+   A JSON value can be copy-assigned from an lvalue expression.
+ - [Destructible](https://en.cppreference.com/w/cpp/named_req/Destructible):
+   JSON values can be destructed.
+- Layout
+ - [StandardLayoutType](https://en.cppreference.com/w/cpp/named_req/StandardLayoutType):
+   JSON values have
+   [standard layout](https://en.cppreference.com/w/cpp/language/data_members#Standard_layout):
+   All non-static data members are private and standard layout types, the
+   class has no virtual functions or (virtual) base classes.
+- Library-wide
+ - [EqualityComparable](https://en.cppreference.com/w/cpp/named_req/EqualityComparable):
+   JSON values can be compared with `==`, see @ref
+   operator==(const_reference,const_reference).
+ - [LessThanComparable](https://en.cppreference.com/w/cpp/named_req/LessThanComparable):
+   JSON values can be compared with `<`, see @ref
+   operator<(const_reference,const_reference).
+ - [Swappable](https://en.cppreference.com/w/cpp/named_req/Swappable):
+   Any JSON lvalue or rvalue of can be swapped with any lvalue or rvalue of
+   other compatible types, using unqualified function call @ref swap().
+ - [NullablePointer](https://en.cppreference.com/w/cpp/named_req/NullablePointer):
+   JSON values can be compared against `std::nullptr_t` objects which are used
+   to model the `null` value.
+- Container
+ - [Container](https://en.cppreference.com/w/cpp/named_req/Container):
+   JSON values can be used like STL containers and provide iterator access.
+ - [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer);
+   JSON values can be used like STL containers and provide reverse iterator
+   access.
+
+@invariant The member variables @a m_value and @a m_type have the following
+relationship:
+- If `m_type == value_t::object`, then `m_value.object != nullptr`.
+- If `m_type == value_t::array`, then `m_value.array != nullptr`.
+- If `m_type == value_t::string`, then `m_value.string != nullptr`.
+The invariants are checked by member function assert_invariant().
+
+@internal
+@note ObjectType trick from https://stackoverflow.com/a/9860911
+@endinternal
+
+@see [RFC 7159: The JavaScript Object Notation (JSON) Data Interchange
+Format](http://rfc7159.net/rfc7159)
+
+@since version 1.0.0
+
+@nosubgrouping
+*/
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+class basic_json
+{
+  private:
+    template<detail::value_t> friend struct detail::external_constructor;
+    friend ::nlohmann::json_pointer<basic_json>;
+
+    template<typename BasicJsonType, typename InputType>
+    friend class ::nlohmann::detail::parser;
+    friend ::nlohmann::detail::serializer<basic_json>;
+    template<typename BasicJsonType>
+    friend class ::nlohmann::detail::iter_impl;
+    template<typename BasicJsonType, typename CharType>
+    friend class ::nlohmann::detail::binary_writer;
+    template<typename BasicJsonType, typename InputType, typename SAX>
+    friend class ::nlohmann::detail::binary_reader;
+    template<typename BasicJsonType>
+    friend class ::nlohmann::detail::json_sax_dom_parser;
+    template<typename BasicJsonType>
+    friend class ::nlohmann::detail::json_sax_dom_callback_parser;
+
+    /// workaround type for MSVC
+    using basic_json_t = NLOHMANN_BASIC_JSON_TPL;
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    // convenience aliases for types residing in namespace detail;
+    using lexer = ::nlohmann::detail::lexer_base<basic_json>;
+
+    template<typename InputAdapterType>
+    static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser(
+        InputAdapterType adapter,
+        detail::parser_callback_t<basic_json>cb = nullptr,
+        const bool allow_exceptions = true,
+        const bool ignore_comments = false
+                                 )
+    {
+        return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
+                std::move(cb), allow_exceptions, ignore_comments);
+    }
+
+  private:
+    using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;
+    template<typename BasicJsonType>
+    using internal_iterator = ::nlohmann::detail::internal_iterator<BasicJsonType>;
+    template<typename BasicJsonType>
+    using iter_impl = ::nlohmann::detail::iter_impl<BasicJsonType>;
+    template<typename Iterator>
+    using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>;
+    template<typename Base> using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>;
+
+    template<typename CharType>
+    using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>;
+
+    template<typename InputType>
+    using binary_reader = ::nlohmann::detail::binary_reader<basic_json, InputType>;
+    template<typename CharType> using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    using serializer = ::nlohmann::detail::serializer<basic_json>;
+
+  public:
+    using value_t = detail::value_t;
+    /// JSON Pointer, see @ref nlohmann::json_pointer
+    using json_pointer = ::nlohmann::json_pointer<basic_json>;
+    template<typename T, typename SFINAE>
+    using json_serializer = JSONSerializer<T, SFINAE>;
+    /// how to treat decoding errors
+    using error_handler_t = detail::error_handler_t;
+    /// how to treat CBOR tags
+    using cbor_tag_handler_t = detail::cbor_tag_handler_t;
+    /// helper type for initializer lists of basic_json values
+    using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;
+
+    using input_format_t = detail::input_format_t;
+    /// SAX interface type, see @ref nlohmann::json_sax
+    using json_sax_t = json_sax<basic_json>;
+
+    ////////////////
+    // exceptions //
+    ////////////////
+
+    /// @name exceptions
+    /// Classes to implement user-defined exceptions.
+    /// @{
+
+    /// @copydoc detail::exception
+    using exception = detail::exception;
+    /// @copydoc detail::parse_error
+    using parse_error = detail::parse_error;
+    /// @copydoc detail::invalid_iterator
+    using invalid_iterator = detail::invalid_iterator;
+    /// @copydoc detail::type_error
+    using type_error = detail::type_error;
+    /// @copydoc detail::out_of_range
+    using out_of_range = detail::out_of_range;
+    /// @copydoc detail::other_error
+    using other_error = detail::other_error;
+
+    /// @}
+
+
+    /////////////////////
+    // container types //
+    /////////////////////
+
+    /// @name container types
+    /// The canonic container types to use @ref basic_json like any other STL
+    /// container.
+    /// @{
+
+    /// the type of elements in a basic_json container
+    using value_type = basic_json;
+
+    /// the type of an element reference
+    using reference = value_type&;
+    /// the type of an element const reference
+    using const_reference = const value_type&;
+
+    /// a type to represent differences between iterators
+    using difference_type = std::ptrdiff_t;
+    /// a type to represent container sizes
+    using size_type = std::size_t;
+
+    /// the allocator type
+    using allocator_type = AllocatorType<basic_json>;
+
+    /// the type of an element pointer
+    using pointer = typename std::allocator_traits<allocator_type>::pointer;
+    /// the type of an element const pointer
+    using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
+
+    /// an iterator for a basic_json container
+    using iterator = iter_impl<basic_json>;
+    /// a const iterator for a basic_json container
+    using const_iterator = iter_impl<const basic_json>;
+    /// a reverse iterator for a basic_json container
+    using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>;
+    /// a const reverse iterator for a basic_json container
+    using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>;
+
+    /// @}
+
+
+    /*!
+    @brief returns the allocator associated with the container
+    */
+    static allocator_type get_allocator()
+    {
+        return allocator_type();
+    }
+
+    /*!
+    @brief returns version information on the library
+
+    This function returns a JSON object with information about the library,
+    including the version number and information on the platform and compiler.
+
+    @return JSON object holding version information
+    key         | description
+    ----------- | ---------------
+    `compiler`  | Information on the used compiler. It is an object with the following keys: `c++` (the used C++ standard), `family` (the compiler family; possible values are `clang`, `icc`, `gcc`, `ilecpp`, `msvc`, `pgcpp`, `sunpro`, and `unknown`), and `version` (the compiler version).
+    `copyright` | The copyright line for the library as string.
+    `name`      | The name of the library as string.
+    `platform`  | The used platform as string. Possible values are `win32`, `linux`, `apple`, `unix`, and `unknown`.
+    `url`       | The URL of the project as string.
+    `version`   | The version of the library. It is an object with the following keys: `major`, `minor`, and `patch` as defined by [Semantic Versioning](http://semver.org), and `string` (the version string).
+
+    @liveexample{The following code shows an example output of the `meta()`
+    function.,meta}
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @complexity Constant.
+
+    @since 2.1.0
+    */
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json meta()
+    {
+        basic_json result;
+
+        result["copyright"] = "(C) 2013-2020 Niels Lohmann";
+        result["name"] = "JSON for Modern C++";
+        result["url"] = "https://github.com/nlohmann/json";
+        result["version"]["string"] =
+            std::to_string(NLOHMANN_JSON_VERSION_MAJOR) + "." +
+            std::to_string(NLOHMANN_JSON_VERSION_MINOR) + "." +
+            std::to_string(NLOHMANN_JSON_VERSION_PATCH);
+        result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR;
+        result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR;
+        result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH;
+
+#ifdef _WIN32
+        result["platform"] = "win32";
+#elif defined __linux__
+        result["platform"] = "linux";
+#elif defined __APPLE__
+        result["platform"] = "apple";
+#elif defined __unix__
+        result["platform"] = "unix";
+#else
+        result["platform"] = "unknown";
+#endif
+
+#if defined(__ICC) || defined(__INTEL_COMPILER)
+        result["compiler"] = {{"family", "icc"}, {"version", __INTEL_COMPILER}};
+#elif defined(__clang__)
+        result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}};
+#elif defined(__GNUC__) || defined(__GNUG__)
+        result["compiler"] = {{"family", "gcc"}, {"version", std::to_string(__GNUC__) + "." + std::to_string(__GNUC_MINOR__) + "." + std::to_string(__GNUC_PATCHLEVEL__)}};
+#elif defined(__HP_cc) || defined(__HP_aCC)
+        result["compiler"] = "hp"
+#elif defined(__IBMCPP__)
+        result["compiler"] = {{"family", "ilecpp"}, {"version", __IBMCPP__}};
+#elif defined(_MSC_VER)
+        result["compiler"] = {{"family", "msvc"}, {"version", _MSC_VER}};
+#elif defined(__PGI)
+        result["compiler"] = {{"family", "pgcpp"}, {"version", __PGI}};
+#elif defined(__SUNPRO_CC)
+        result["compiler"] = {{"family", "sunpro"}, {"version", __SUNPRO_CC}};
+#else
+        result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};
+#endif
+
+#ifdef __cplusplus
+        result["compiler"]["c++"] = std::to_string(__cplusplus);
+#else
+        result["compiler"]["c++"] = "unknown";
+#endif
+        return result;
+    }
+
+
+    ///////////////////////////
+    // JSON value data types //
+    ///////////////////////////
+
+    /// @name JSON value data types
+    /// The data types to store a JSON value. These types are derived from
+    /// the template arguments passed to class @ref basic_json.
+    /// @{
+
+#if defined(JSON_HAS_CPP_14)
+    // Use transparent comparator if possible, combined with perfect forwarding
+    // on find() and count() calls prevents unnecessary string construction.
+    using object_comparator_t = std::less<>;
+#else
+    using object_comparator_t = std::less<StringType>;
+#endif
+
+    /*!
+    @brief a type for an object
+
+    [RFC 7159](http://rfc7159.net/rfc7159) describes JSON objects as follows:
+    > An object is an unordered collection of zero or more name/value pairs,
+    > where a name is a string and a value is a string, number, boolean, null,
+    > object, or array.
+
+    To store objects in C++, a type is defined by the template parameters
+    described below.
+
+    @tparam ObjectType  the container to store objects (e.g., `std::map` or
+    `std::unordered_map`)
+    @tparam StringType the type of the keys or names (e.g., `std::string`).
+    The comparison function `std::less<StringType>` is used to order elements
+    inside the container.
+    @tparam AllocatorType the allocator to use for objects (e.g.,
+    `std::allocator`)
+
+    #### Default type
+
+    With the default values for @a ObjectType (`std::map`), @a StringType
+    (`std::string`), and @a AllocatorType (`std::allocator`), the default
+    value for @a object_t is:
+
+    @code {.cpp}
+    std::map<
+      std::string, // key_type
+      basic_json, // value_type
+      std::less<std::string>, // key_compare
+      std::allocator<std::pair<const std::string, basic_json>> // allocator_type
+    >
+    @endcode
+
+    #### Behavior
+
+    The choice of @a object_t influences the behavior of the JSON class. With
+    the default type, objects have the following behavior:
+
+    - When all names are unique, objects will be interoperable in the sense
+      that all software implementations receiving that object will agree on
+      the name-value mappings.
+    - When the names within an object are not unique, it is unspecified which
+      one of the values for a given key will be chosen. For instance,
+      `{"key": 2, "key": 1}` could be equal to either `{"key": 1}` or
+      `{"key": 2}`.
+    - Internally, name/value pairs are stored in lexicographical order of the
+      names. Objects will also be serialized (see @ref dump) in this order.
+      For instance, `{"b": 1, "a": 2}` and `{"a": 2, "b": 1}` will be stored
+      and serialized as `{"a": 2, "b": 1}`.
+    - When comparing objects, the order of the name/value pairs is irrelevant.
+      This makes objects interoperable in the sense that they will not be
+      affected by these differences. For instance, `{"b": 1, "a": 2}` and
+      `{"a": 2, "b": 1}` will be treated as equal.
+
+    #### Limits
+
+    [RFC 7159](http://rfc7159.net/rfc7159) specifies:
+    > An implementation may set limits on the maximum depth of nesting.
+
+    In this class, the object's limit of nesting is not explicitly constrained.
+    However, a maximum depth of nesting may be introduced by the compiler or
+    runtime environment. A theoretical limit can be queried by calling the
+    @ref max_size function of a JSON object.
+
+    #### Storage
+
+    Objects are stored as pointers in a @ref basic_json type. That is, for any
+    access to object values, a pointer of type `object_t*` must be
+    dereferenced.
+
+    @sa @ref array_t -- type for an array value
+
+    @since version 1.0.0
+
+    @note The order name/value pairs are added to the object is *not*
+    preserved by the library. Therefore, iterating an object may return
+    name/value pairs in a different order than they were originally stored. In
+    fact, keys will be traversed in alphabetical order as `std::map` with
+    `std::less` is used by default. Please note this behavior conforms to [RFC
+    7159](http://rfc7159.net/rfc7159), because any order implements the
+    specified "unordered" nature of JSON objects.
+    */
+    using object_t = ObjectType<StringType,
+          basic_json,
+          object_comparator_t,
+          AllocatorType<std::pair<const StringType,
+          basic_json>>>;
+
+    /*!
+    @brief a type for an array
+
+    [RFC 7159](http://rfc7159.net/rfc7159) describes JSON arrays as follows:
+    > An array is an ordered sequence of zero or more values.
+
+    To store objects in C++, a type is defined by the template parameters
+    explained below.
+
+    @tparam ArrayType  container type to store arrays (e.g., `std::vector` or
+    `std::list`)
+    @tparam AllocatorType allocator to use for arrays (e.g., `std::allocator`)
+
+    #### Default type
+
+    With the default values for @a ArrayType (`std::vector`) and @a
+    AllocatorType (`std::allocator`), the default value for @a array_t is:
+
+    @code {.cpp}
+    std::vector<
+      basic_json, // value_type
+      std::allocator<basic_json> // allocator_type
+    >
+    @endcode
+
+    #### Limits
+
+    [RFC 7159](http://rfc7159.net/rfc7159) specifies:
+    > An implementation may set limits on the maximum depth of nesting.
+
+    In this class, the array's limit of nesting is not explicitly constrained.
+    However, a maximum depth of nesting may be introduced by the compiler or
+    runtime environment. A theoretical limit can be queried by calling the
+    @ref max_size function of a JSON array.
+
+    #### Storage
+
+    Arrays are stored as pointers in a @ref basic_json type. That is, for any
+    access to array values, a pointer of type `array_t*` must be dereferenced.
+
+    @sa @ref object_t -- type for an object value
+
+    @since version 1.0.0
+    */
+    using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
+
+    /*!
+    @brief a type for a string
+
+    [RFC 7159](http://rfc7159.net/rfc7159) describes JSON strings as follows:
+    > A string is a sequence of zero or more Unicode characters.
+
+    To store objects in C++, a type is defined by the template parameter
+    described below. Unicode values are split by the JSON class into
+    byte-sized characters during deserialization.
+
+    @tparam StringType  the container to store strings (e.g., `std::string`).
+    Note this container is used for keys/names in objects, see @ref object_t.
+
+    #### Default type
+
+    With the default values for @a StringType (`std::string`), the default
+    value for @a string_t is:
+
+    @code {.cpp}
+    std::string
+    @endcode
+
+    #### Encoding
+
+    Strings are stored in UTF-8 encoding. Therefore, functions like
+    `std::string::size()` or `std::string::length()` return the number of
+    bytes in the string rather than the number of characters or glyphs.
+
+    #### String comparison
+
+    [RFC 7159](http://rfc7159.net/rfc7159) states:
+    > Software implementations are typically required to test names of object
+    > members for equality. Implementations that transform the textual
+    > representation into sequences of Unicode code units and then perform the
+    > comparison numerically, code unit by code unit, are interoperable in the
+    > sense that implementations will agree in all cases on equality or
+    > inequality of two strings. For example, implementations that compare
+    > strings with escaped characters unconverted may incorrectly find that
+    > `"a\\b"` and `"a\u005Cb"` are not equal.
+
+    This implementation is interoperable as it does compare strings code unit
+    by code unit.
+
+    #### Storage
+
+    String values are stored as pointers in a @ref basic_json type. That is,
+    for any access to string values, a pointer of type `string_t*` must be
+    dereferenced.
+
+    @since version 1.0.0
+    */
+    using string_t = StringType;
+
+    /*!
+    @brief a type for a boolean
+
+    [RFC 7159](http://rfc7159.net/rfc7159) implicitly describes a boolean as a
+    type which differentiates the two literals `true` and `false`.
+
+    To store objects in C++, a type is defined by the template parameter @a
+    BooleanType which chooses the type to use.
+
+    #### Default type
+
+    With the default values for @a BooleanType (`bool`), the default value for
+    @a boolean_t is:
+
+    @code {.cpp}
+    bool
+    @endcode
+
+    #### Storage
+
+    Boolean values are stored directly inside a @ref basic_json type.
+
+    @since version 1.0.0
+    */
+    using boolean_t = BooleanType;
+
+    /*!
+    @brief a type for a number (integer)
+
+    [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
+    > The representation of numbers is similar to that used in most
+    > programming languages. A number is represented in base 10 using decimal
+    > digits. It contains an integer component that may be prefixed with an
+    > optional minus sign, which may be followed by a fraction part and/or an
+    > exponent part. Leading zeros are not allowed. (...) Numeric values that
+    > cannot be represented in the grammar below (such as Infinity and NaN)
+    > are not permitted.
+
+    This description includes both integer and floating-point numbers.
+    However, C++ allows more precise storage if it is known whether the number
+    is a signed integer, an unsigned integer or a floating-point number.
+    Therefore, three different types, @ref number_integer_t, @ref
+    number_unsigned_t and @ref number_float_t are used.
+
+    To store integer numbers in C++, a type is defined by the template
+    parameter @a NumberIntegerType which chooses the type to use.
+
+    #### Default type
+
+    With the default values for @a NumberIntegerType (`int64_t`), the default
+    value for @a number_integer_t is:
+
+    @code {.cpp}
+    int64_t
+    @endcode
+
+    #### Default behavior
+
+    - The restrictions about leading zeros is not enforced in C++. Instead,
+      leading zeros in integer literals lead to an interpretation as octal
+      number. Internally, the value will be stored as decimal number. For
+      instance, the C++ integer literal `010` will be serialized to `8`.
+      During deserialization, leading zeros yield an error.
+    - Not-a-number (NaN) values will be serialized to `null`.
+
+    #### Limits
+
+    [RFC 7159](http://rfc7159.net/rfc7159) specifies:
+    > An implementation may set limits on the range and precision of numbers.
+
+    When the default type is used, the maximal integer number that can be
+    stored is `9223372036854775807` (INT64_MAX) and the minimal integer number
+    that can be stored is `-9223372036854775808` (INT64_MIN). Integer numbers
+    that are out of range will yield over/underflow when used in a
+    constructor. During deserialization, too large or small integer numbers
+    will be automatically be stored as @ref number_unsigned_t or @ref
+    number_float_t.
+
+    [RFC 7159](http://rfc7159.net/rfc7159) further states:
+    > Note that when such software is used, numbers that are integers and are
+    > in the range \f$[-2^{53}+1, 2^{53}-1]\f$ are interoperable in the sense
+    > that implementations will agree exactly on their numeric values.
+
+    As this range is a subrange of the exactly supported range [INT64_MIN,
+    INT64_MAX], this class's integer type is interoperable.
+
+    #### Storage
+
+    Integer number values are stored directly inside a @ref basic_json type.
+
+    @sa @ref number_float_t -- type for number values (floating-point)
+
+    @sa @ref number_unsigned_t -- type for number values (unsigned integer)
+
+    @since version 1.0.0
+    */
+    using number_integer_t = NumberIntegerType;
+
+    /*!
+    @brief a type for a number (unsigned)
+
+    [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
+    > The representation of numbers is similar to that used in most
+    > programming languages. A number is represented in base 10 using decimal
+    > digits. It contains an integer component that may be prefixed with an
+    > optional minus sign, which may be followed by a fraction part and/or an
+    > exponent part. Leading zeros are not allowed. (...) Numeric values that
+    > cannot be represented in the grammar below (such as Infinity and NaN)
+    > are not permitted.
+
+    This description includes both integer and floating-point numbers.
+    However, C++ allows more precise storage if it is known whether the number
+    is a signed integer, an unsigned integer or a floating-point number.
+    Therefore, three different types, @ref number_integer_t, @ref
+    number_unsigned_t and @ref number_float_t are used.
+
+    To store unsigned integer numbers in C++, a type is defined by the
+    template parameter @a NumberUnsignedType which chooses the type to use.
+
+    #### Default type
+
+    With the default values for @a NumberUnsignedType (`uint64_t`), the
+    default value for @a number_unsigned_t is:
+
+    @code {.cpp}
+    uint64_t
+    @endcode
+
+    #### Default behavior
+
+    - The restrictions about leading zeros is not enforced in C++. Instead,
+      leading zeros in integer literals lead to an interpretation as octal
+      number. Internally, the value will be stored as decimal number. For
+      instance, the C++ integer literal `010` will be serialized to `8`.
+      During deserialization, leading zeros yield an error.
+    - Not-a-number (NaN) values will be serialized to `null`.
+
+    #### Limits
+
+    [RFC 7159](http://rfc7159.net/rfc7159) specifies:
+    > An implementation may set limits on the range and precision of numbers.
+
+    When the default type is used, the maximal integer number that can be
+    stored is `18446744073709551615` (UINT64_MAX) and the minimal integer
+    number that can be stored is `0`. Integer numbers that are out of range
+    will yield over/underflow when used in a constructor. During
+    deserialization, too large or small integer numbers will be automatically
+    be stored as @ref number_integer_t or @ref number_float_t.
+
+    [RFC 7159](http://rfc7159.net/rfc7159) further states:
+    > Note that when such software is used, numbers that are integers and are
+    > in the range \f$[-2^{53}+1, 2^{53}-1]\f$ are interoperable in the sense
+    > that implementations will agree exactly on their numeric values.
+
+    As this range is a subrange (when considered in conjunction with the
+    number_integer_t type) of the exactly supported range [0, UINT64_MAX],
+    this class's integer type is interoperable.
+
+    #### Storage
+
+    Integer number values are stored directly inside a @ref basic_json type.
+
+    @sa @ref number_float_t -- type for number values (floating-point)
+    @sa @ref number_integer_t -- type for number values (integer)
+
+    @since version 2.0.0
+    */
+    using number_unsigned_t = NumberUnsignedType;
+
+    /*!
+    @brief a type for a number (floating-point)
+
+    [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
+    > The representation of numbers is similar to that used in most
+    > programming languages. A number is represented in base 10 using decimal
+    > digits. It contains an integer component that may be prefixed with an
+    > optional minus sign, which may be followed by a fraction part and/or an
+    > exponent part. Leading zeros are not allowed. (...) Numeric values that
+    > cannot be represented in the grammar below (such as Infinity and NaN)
+    > are not permitted.
+
+    This description includes both integer and floating-point numbers.
+    However, C++ allows more precise storage if it is known whether the number
+    is a signed integer, an unsigned integer or a floating-point number.
+    Therefore, three different types, @ref number_integer_t, @ref
+    number_unsigned_t and @ref number_float_t are used.
+
+    To store floating-point numbers in C++, a type is defined by the template
+    parameter @a NumberFloatType which chooses the type to use.
+
+    #### Default type
+
+    With the default values for @a NumberFloatType (`double`), the default
+    value for @a number_float_t is:
+
+    @code {.cpp}
+    double
+    @endcode
+
+    #### Default behavior
+
+    - The restrictions about leading zeros is not enforced in C++. Instead,
+      leading zeros in floating-point literals will be ignored. Internally,
+      the value will be stored as decimal number. For instance, the C++
+      floating-point literal `01.2` will be serialized to `1.2`. During
+      deserialization, leading zeros yield an error.
+    - Not-a-number (NaN) values will be serialized to `null`.
+
+    #### Limits
+
+    [RFC 7159](http://rfc7159.net/rfc7159) states:
+    > This specification allows implementations to set limits on the range and
+    > precision of numbers accepted. Since software that implements IEEE
+    > 754-2008 binary64 (double precision) numbers is generally available and
+    > widely used, good interoperability can be achieved by implementations
+    > that expect no more precision or range than these provide, in the sense
+    > that implementations will approximate JSON numbers within the expected
+    > precision.
+
+    This implementation does exactly follow this approach, as it uses double
+    precision floating-point numbers. Note values smaller than
+    `-1.79769313486232e+308` and values greater than `1.79769313486232e+308`
+    will be stored as NaN internally and be serialized to `null`.
+
+    #### Storage
+
+    Floating-point number values are stored directly inside a @ref basic_json
+    type.
+
+    @sa @ref number_integer_t -- type for number values (integer)
+
+    @sa @ref number_unsigned_t -- type for number values (unsigned integer)
+
+    @since version 1.0.0
+    */
+    using number_float_t = NumberFloatType;
+
+    /*!
+    @brief a type for a packed binary type
+
+    This type is a type designed to carry binary data that appears in various
+    serialized formats, such as CBOR's Major Type 2, MessagePack's bin, and
+    BSON's generic binary subtype. This type is NOT a part of standard JSON and
+    exists solely for compatibility with these binary types. As such, it is
+    simply defined as an ordered sequence of zero or more byte values.
+
+    Additionally, as an implementation detail, the subtype of the binary data is
+    carried around as a `std::uint8_t`, which is compatible with both of the
+    binary data formats that use binary subtyping, (though the specific
+    numbering is incompatible with each other, and it is up to the user to
+    translate between them).
+
+    [CBOR's RFC 7049](https://tools.ietf.org/html/rfc7049) describes this type
+    as:
+    > Major type 2: a byte string. The string's length in bytes is represented
+    > following the rules for positive integers (major type 0).
+
+    [MessagePack's documentation on the bin type
+    family](https://github.com/msgpack/msgpack/blob/master/spec.md#bin-format-family)
+    describes this type as:
+    > Bin format family stores an byte array in 2, 3, or 5 bytes of extra bytes
+    > in addition to the size of the byte array.
+
+    [BSON's specifications](http://bsonspec.org/spec.html) describe several
+    binary types; however, this type is intended to represent the generic binary
+    type which has the description:
+    > Generic binary subtype - This is the most commonly used binary subtype and
+    > should be the 'default' for drivers and tools.
+
+    None of these impose any limitations on the internal representation other
+    than the basic unit of storage be some type of array whose parts are
+    decomposable into bytes.
+
+    The default representation of this binary format is a
+    `std::vector<std::uint8_t>`, which is a very common way to represent a byte
+    array in modern C++.
+
+    #### Default type
+
+    The default values for @a BinaryType is `std::vector<std::uint8_t>`
+
+    #### Storage
+
+    Binary Arrays are stored as pointers in a @ref basic_json type. That is,
+    for any access to array values, a pointer of the type `binary_t*` must be
+    dereferenced.
+
+    #### Notes on subtypes
+
+    - CBOR
+       - Binary values are represented as byte strings. No subtypes are
+         supported and will be ignored when CBOR is written.
+    - MessagePack
+       - If a subtype is given and the binary array contains exactly 1, 2, 4, 8,
+         or 16 elements, the fixext family (fixext1, fixext2, fixext4, fixext8)
+         is used. For other sizes, the ext family (ext8, ext16, ext32) is used.
+         The subtype is then added as singed 8-bit integer.
+       - If no subtype is given, the bin family (bin8, bin16, bin32) is used.
+    - BSON
+       - If a subtype is given, it is used and added as unsigned 8-bit integer.
+       - If no subtype is given, the generic binary subtype 0x00 is used.
+
+    @sa @ref binary -- create a binary array
+
+    @since version 3.8.0
+    */
+    using binary_t = nlohmann::byte_container_with_subtype<BinaryType>;
+    /// @}
+
+  private:
+
+    /// helper for exception-safe object creation
+    template<typename T, typename... Args>
+    JSON_HEDLEY_RETURNS_NON_NULL
+    static T* create(Args&& ... args)
+    {
+        AllocatorType<T> alloc;
+        using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
+
+        auto deleter = [&](T * object)
+        {
+            AllocatorTraits::deallocate(alloc, object, 1);
+        };
+        std::unique_ptr<T, decltype(deleter)> object(AllocatorTraits::allocate(alloc, 1), deleter);
+        AllocatorTraits::construct(alloc, object.get(), std::forward<Args>(args)...);
+        JSON_ASSERT(object != nullptr);
+        return object.release();
+    }
+
+    ////////////////////////
+    // JSON value storage //
+    ////////////////////////
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /*!
+    @brief a JSON value
+
+    The actual storage for a JSON value of the @ref basic_json class. This
+    union combines the different storage types for the JSON value types
+    defined in @ref value_t.
+
+    JSON type | value_t type    | used type
+    --------- | --------------- | ------------------------
+    object    | object          | pointer to @ref object_t
+    array     | array           | pointer to @ref array_t
+    string    | string          | pointer to @ref string_t
+    boolean   | boolean         | @ref boolean_t
+    number    | number_integer  | @ref number_integer_t
+    number    | number_unsigned | @ref number_unsigned_t
+    number    | number_float    | @ref number_float_t
+    binary    | binary          | pointer to @ref binary_t
+    null      | null            | *no value is stored*
+
+    @note Variable-length types (objects, arrays, and strings) are stored as
+    pointers. The size of the union should not exceed 64 bits if the default
+    value types are used.
+
+    @since version 1.0.0
+    */
+    union json_value
+    {
+        /// object (stored with pointer to save storage)
+        object_t* object;
+        /// array (stored with pointer to save storage)
+        array_t* array;
+        /// string (stored with pointer to save storage)
+        string_t* string;
+        /// binary (stored with pointer to save storage)
+        binary_t* binary;
+        /// boolean
+        boolean_t boolean;
+        /// number (integer)
+        number_integer_t number_integer;
+        /// number (unsigned integer)
+        number_unsigned_t number_unsigned;
+        /// number (floating-point)
+        number_float_t number_float;
+
+        /// default constructor (for null values)
+        json_value() = default;
+        /// constructor for booleans
+        json_value(boolean_t v) noexcept : boolean(v) {}
+        /// constructor for numbers (integer)
+        json_value(number_integer_t v) noexcept : number_integer(v) {}
+        /// constructor for numbers (unsigned)
+        json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}
+        /// constructor for numbers (floating-point)
+        json_value(number_float_t v) noexcept : number_float(v) {}
+        /// constructor for empty values of a given type
+        json_value(value_t t)
+        {
+            switch (t)
+            {
+                case value_t::object:
+                {
+                    object = create<object_t>();
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    array = create<array_t>();
+                    break;
+                }
+
+                case value_t::string:
+                {
+                    string = create<string_t>("");
+                    break;
+                }
+
+                case value_t::binary:
+                {
+                    binary = create<binary_t>();
+                    break;
+                }
+
+                case value_t::boolean:
+                {
+                    boolean = boolean_t(false);
+                    break;
+                }
+
+                case value_t::number_integer:
+                {
+                    number_integer = number_integer_t(0);
+                    break;
+                }
+
+                case value_t::number_unsigned:
+                {
+                    number_unsigned = number_unsigned_t(0);
+                    break;
+                }
+
+                case value_t::number_float:
+                {
+                    number_float = number_float_t(0.0);
+                    break;
+                }
+
+                case value_t::null:
+                {
+                    object = nullptr;  // silence warning, see #821
+                    break;
+                }
+
+                default:
+                {
+                    object = nullptr;  // silence warning, see #821
+                    if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
+                    {
+                        JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.9.1")); // LCOV_EXCL_LINE
+                    }
+                    break;
+                }
+            }
+        }
+
+        /// constructor for strings
+        json_value(const string_t& value)
+        {
+            string = create<string_t>(value);
+        }
+
+        /// constructor for rvalue strings
+        json_value(string_t&& value)
+        {
+            string = create<string_t>(std::move(value));
+        }
+
+        /// constructor for objects
+        json_value(const object_t& value)
+        {
+            object = create<object_t>(value);
+        }
+
+        /// constructor for rvalue objects
+        json_value(object_t&& value)
+        {
+            object = create<object_t>(std::move(value));
+        }
+
+        /// constructor for arrays
+        json_value(const array_t& value)
+        {
+            array = create<array_t>(value);
+        }
+
+        /// constructor for rvalue arrays
+        json_value(array_t&& value)
+        {
+            array = create<array_t>(std::move(value));
+        }
+
+        /// constructor for binary arrays
+        json_value(const typename binary_t::container_type& value)
+        {
+            binary = create<binary_t>(value);
+        }
+
+        /// constructor for rvalue binary arrays
+        json_value(typename binary_t::container_type&& value)
+        {
+            binary = create<binary_t>(std::move(value));
+        }
+
+        /// constructor for binary arrays (internal type)
+        json_value(const binary_t& value)
+        {
+            binary = create<binary_t>(value);
+        }
+
+        /// constructor for rvalue binary arrays (internal type)
+        json_value(binary_t&& value)
+        {
+            binary = create<binary_t>(std::move(value));
+        }
+
+        void destroy(value_t t) noexcept
+        {
+            // flatten the current json_value to a heap-allocated stack
+            std::vector<basic_json> stack;
+
+            // move the top-level items to stack
+            if (t == value_t::array)
+            {
+                stack.reserve(array->size());
+                std::move(array->begin(), array->end(), std::back_inserter(stack));
+            }
+            else if (t == value_t::object)
+            {
+                stack.reserve(object->size());
+                for (auto&& it : *object)
+                {
+                    stack.push_back(std::move(it.second));
+                }
+            }
+
+            while (!stack.empty())
+            {
+                // move the last item to local variable to be processed
+                basic_json current_item(std::move(stack.back()));
+                stack.pop_back();
+
+                // if current_item is array/object, move
+                // its children to the stack to be processed later
+                if (current_item.is_array())
+                {
+                    std::move(current_item.m_value.array->begin(), current_item.m_value.array->end(),
+                              std::back_inserter(stack));
+
+                    current_item.m_value.array->clear();
+                }
+                else if (current_item.is_object())
+                {
+                    for (auto&& it : *current_item.m_value.object)
+                    {
+                        stack.push_back(std::move(it.second));
+                    }
+
+                    current_item.m_value.object->clear();
+                }
+
+                // it's now safe that current_item get destructed
+                // since it doesn't have any children
+            }
+
+            switch (t)
+            {
+                case value_t::object:
+                {
+                    AllocatorType<object_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    AllocatorType<array_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
+                    break;
+                }
+
+                case value_t::string:
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
+                    break;
+                }
+
+                case value_t::binary:
+                {
+                    AllocatorType<binary_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
+                    break;
+                }
+
+                default:
+                {
+                    break;
+                }
+            }
+        }
+    };
+
+  private:
+    /*!
+    @brief checks the class invariants
+
+    This function asserts the class invariants. It needs to be called at the
+    end of every constructor to make sure that created objects respect the
+    invariant. Furthermore, it has to be called each time the type of a JSON
+    value is changed, because the invariant expresses a relationship between
+    @a m_type and @a m_value.
+    */
+    void assert_invariant() const noexcept
+    {
+        JSON_ASSERT(m_type != value_t::object || m_value.object != nullptr);
+        JSON_ASSERT(m_type != value_t::array || m_value.array != nullptr);
+        JSON_ASSERT(m_type != value_t::string || m_value.string != nullptr);
+        JSON_ASSERT(m_type != value_t::binary || m_value.binary != nullptr);
+    }
+
+  public:
+    //////////////////////////
+    // JSON parser callback //
+    //////////////////////////
+
+    /*!
+    @brief parser event types
+
+    The parser callback distinguishes the following events:
+    - `object_start`: the parser read `{` and started to process a JSON object
+    - `key`: the parser read a key of a value in an object
+    - `object_end`: the parser read `}` and finished processing a JSON object
+    - `array_start`: the parser read `[` and started to process a JSON array
+    - `array_end`: the parser read `]` and finished processing a JSON array
+    - `value`: the parser finished reading a JSON value
+
+    @image html callback_events.png "Example when certain parse events are triggered"
+
+    @sa @ref parser_callback_t for more information and examples
+    */
+    using parse_event_t = detail::parse_event_t;
+
+    /*!
+    @brief per-element parser callback type
+
+    With a parser callback function, the result of parsing a JSON text can be
+    influenced. When passed to @ref parse, it is called on certain events
+    (passed as @ref parse_event_t via parameter @a event) with a set recursion
+    depth @a depth and context JSON value @a parsed. The return value of the
+    callback function is a boolean indicating whether the element that emitted
+    the callback shall be kept or not.
+
+    We distinguish six scenarios (determined by the event type) in which the
+    callback function can be called. The following table describes the values
+    of the parameters @a depth, @a event, and @a parsed.
+
+    parameter @a event | description | parameter @a depth | parameter @a parsed
+    ------------------ | ----------- | ------------------ | -------------------
+    parse_event_t::object_start | the parser read `{` and started to process a JSON object | depth of the parent of the JSON object | a JSON value with type discarded
+    parse_event_t::key | the parser read a key of a value in an object | depth of the currently parsed JSON object | a JSON string containing the key
+    parse_event_t::object_end | the parser read `}` and finished processing a JSON object | depth of the parent of the JSON object | the parsed JSON object
+    parse_event_t::array_start | the parser read `[` and started to process a JSON array | depth of the parent of the JSON array | a JSON value with type discarded
+    parse_event_t::array_end | the parser read `]` and finished processing a JSON array | depth of the parent of the JSON array | the parsed JSON array
+    parse_event_t::value | the parser finished reading a JSON value | depth of the value | the parsed JSON value
+
+    @image html callback_events.png "Example when certain parse events are triggered"
+
+    Discarding a value (i.e., returning `false`) has different effects
+    depending on the context in which function was called:
+
+    - Discarded values in structured types are skipped. That is, the parser
+      will behave as if the discarded value was never read.
+    - In case a value outside a structured type is skipped, it is replaced
+      with `null`. This case happens if the top-level element is skipped.
+
+    @param[in] depth  the depth of the recursion during parsing
+
+    @param[in] event  an event of type parse_event_t indicating the context in
+    the callback function has been called
+
+    @param[in,out] parsed  the current intermediate parse result; note that
+    writing to this value has no effect for parse_event_t::key events
+
+    @return Whether the JSON value which called the function during parsing
+    should be kept (`true`) or not (`false`). In the latter case, it is either
+    skipped completely or replaced by an empty discarded object.
+
+    @sa @ref parse for examples
+
+    @since version 1.0.0
+    */
+    using parser_callback_t = detail::parser_callback_t<basic_json>;
+
+    //////////////////
+    // constructors //
+    //////////////////
+
+    /// @name constructors and destructors
+    /// Constructors of class @ref basic_json, copy/move constructor, copy
+    /// assignment, static functions creating objects, and the destructor.
+    /// @{
+
+    /*!
+    @brief create an empty value with a given type
+
+    Create an empty JSON value with a given type. The value will be default
+    initialized with an empty value which depends on the type:
+
+    Value type  | initial value
+    ----------- | -------------
+    null        | `null`
+    boolean     | `false`
+    string      | `""`
+    number      | `0`
+    object      | `{}`
+    array       | `[]`
+    binary      | empty array
+
+    @param[in] v  the type of the value to create
+
+    @complexity Constant.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @liveexample{The following code shows the constructor for different @ref
+    value_t values,basic_json__value_t}
+
+    @sa @ref clear() -- restores the postcondition of this constructor
+
+    @since version 1.0.0
+    */
+    basic_json(const value_t v)
+        : m_type(v), m_value(v)
+    {
+        assert_invariant();
+    }
+
+    /*!
+    @brief create a null object
+
+    Create a `null` JSON value. It either takes a null pointer as parameter
+    (explicitly creating `null`) or no parameter (implicitly creating `null`).
+    The passed null pointer itself is not read -- it is only used to choose
+    the right constructor.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this constructor never throws
+    exceptions.
+
+    @liveexample{The following code shows the constructor with and without a
+    null pointer parameter.,basic_json__nullptr_t}
+
+    @since version 1.0.0
+    */
+    basic_json(std::nullptr_t = nullptr) noexcept
+        : basic_json(value_t::null)
+    {
+        assert_invariant();
+    }
+
+    /*!
+    @brief create a JSON value
+
+    This is a "catch all" constructor for all compatible JSON types; that is,
+    types for which a `to_json()` method exists. The constructor forwards the
+    parameter @a val to that method (to `json_serializer<U>::to_json` method
+    with `U = uncvref_t<CompatibleType>`, to be exact).
+
+    Template type @a CompatibleType includes, but is not limited to, the
+    following types:
+    - **arrays**: @ref array_t and all kinds of compatible containers such as
+      `std::vector`, `std::deque`, `std::list`, `std::forward_list`,
+      `std::array`, `std::valarray`, `std::set`, `std::unordered_set`,
+      `std::multiset`, and `std::unordered_multiset` with a `value_type` from
+      which a @ref basic_json value can be constructed.
+    - **objects**: @ref object_t and all kinds of compatible associative
+      containers such as `std::map`, `std::unordered_map`, `std::multimap`,
+      and `std::unordered_multimap` with a `key_type` compatible to
+      @ref string_t and a `value_type` from which a @ref basic_json value can
+      be constructed.
+    - **strings**: @ref string_t, string literals, and all compatible string
+      containers can be used.
+    - **numbers**: @ref number_integer_t, @ref number_unsigned_t,
+      @ref number_float_t, and all convertible number types such as `int`,
+      `size_t`, `int64_t`, `float` or `double` can be used.
+    - **boolean**: @ref boolean_t / `bool` can be used.
+    - **binary**: @ref binary_t / `std::vector<uint8_t>` may be used,
+      unfortunately because string literals cannot be distinguished from binary
+      character arrays by the C++ type system, all types compatible with `const
+      char*` will be directed to the string constructor instead.  This is both
+      for backwards compatibility, and due to the fact that a binary type is not
+      a standard JSON type.
+
+    See the examples below.
+
+    @tparam CompatibleType a type such that:
+    - @a CompatibleType is not derived from `std::istream`,
+    - @a CompatibleType is not @ref basic_json (to avoid hijacking copy/move
+         constructors),
+    - @a CompatibleType is not a different @ref basic_json type (i.e. with different template arguments)
+    - @a CompatibleType is not a @ref basic_json nested type (e.g.,
+         @ref json_pointer, @ref iterator, etc ...)
+    - @ref @ref json_serializer<U> has a
+         `to_json(basic_json_t&, CompatibleType&&)` method
+
+    @tparam U = `uncvref_t<CompatibleType>`
+
+    @param[in] val the value to be forwarded to the respective constructor
+
+    @complexity Usually linear in the size of the passed @a val, also
+                depending on the implementation of the called `to_json()`
+                method.
+
+    @exceptionsafety Depends on the called constructor. For types directly
+    supported by the library (i.e., all types for which no `to_json()` function
+    was provided), strong guarantee holds: if an exception is thrown, there are
+    no changes to any JSON value.
+
+    @liveexample{The following code shows the constructor with several
+    compatible types.,basic_json__CompatibleType}
+
+    @since version 2.1.0
+    */
+    template < typename CompatibleType,
+               typename U = detail::uncvref_t<CompatibleType>,
+               detail::enable_if_t <
+                   !detail::is_basic_json<U>::value && detail::is_compatible_type<basic_json_t, U>::value, int > = 0 >
+    basic_json(CompatibleType && val) noexcept(noexcept(
+                JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
+                                           std::forward<CompatibleType>(val))))
+    {
+        JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
+        assert_invariant();
+    }
+
+    /*!
+    @brief create a JSON value from an existing one
+
+    This is a constructor for existing @ref basic_json types.
+    It does not hijack copy/move constructors, since the parameter has different
+    template arguments than the current ones.
+
+    The constructor tries to convert the internal @ref m_value of the parameter.
+
+    @tparam BasicJsonType a type such that:
+    - @a BasicJsonType is a @ref basic_json type.
+    - @a BasicJsonType has different template arguments than @ref basic_json_t.
+
+    @param[in] val the @ref basic_json value to be converted.
+
+    @complexity Usually linear in the size of the passed @a val, also
+                depending on the implementation of the called `to_json()`
+                method.
+
+    @exceptionsafety Depends on the called constructor. For types directly
+    supported by the library (i.e., all types for which no `to_json()` function
+    was provided), strong guarantee holds: if an exception is thrown, there are
+    no changes to any JSON value.
+
+    @since version 3.2.0
+    */
+    template < typename BasicJsonType,
+               detail::enable_if_t <
+                   detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value, int > = 0 >
+    basic_json(const BasicJsonType& val)
+    {
+        using other_boolean_t = typename BasicJsonType::boolean_t;
+        using other_number_float_t = typename BasicJsonType::number_float_t;
+        using other_number_integer_t = typename BasicJsonType::number_integer_t;
+        using other_number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+        using other_string_t = typename BasicJsonType::string_t;
+        using other_object_t = typename BasicJsonType::object_t;
+        using other_array_t = typename BasicJsonType::array_t;
+        using other_binary_t = typename BasicJsonType::binary_t;
+
+        switch (val.type())
+        {
+            case value_t::boolean:
+                JSONSerializer<other_boolean_t>::to_json(*this, val.template get<other_boolean_t>());
+                break;
+            case value_t::number_float:
+                JSONSerializer<other_number_float_t>::to_json(*this, val.template get<other_number_float_t>());
+                break;
+            case value_t::number_integer:
+                JSONSerializer<other_number_integer_t>::to_json(*this, val.template get<other_number_integer_t>());
+                break;
+            case value_t::number_unsigned:
+                JSONSerializer<other_number_unsigned_t>::to_json(*this, val.template get<other_number_unsigned_t>());
+                break;
+            case value_t::string:
+                JSONSerializer<other_string_t>::to_json(*this, val.template get_ref<const other_string_t&>());
+                break;
+            case value_t::object:
+                JSONSerializer<other_object_t>::to_json(*this, val.template get_ref<const other_object_t&>());
+                break;
+            case value_t::array:
+                JSONSerializer<other_array_t>::to_json(*this, val.template get_ref<const other_array_t&>());
+                break;
+            case value_t::binary:
+                JSONSerializer<other_binary_t>::to_json(*this, val.template get_ref<const other_binary_t&>());
+                break;
+            case value_t::null:
+                *this = nullptr;
+                break;
+            case value_t::discarded:
+                m_type = value_t::discarded;
+                break;
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false);  // LCOV_EXCL_LINE
+        }
+        assert_invariant();
+    }
+
+    /*!
+    @brief create a container (array or object) from an initializer list
+
+    Creates a JSON value of type array or object from the passed initializer
+    list @a init. In case @a type_deduction is `true` (default), the type of
+    the JSON value to be created is deducted from the initializer list @a init
+    according to the following rules:
+
+    1. If the list is empty, an empty JSON object value `{}` is created.
+    2. If the list consists of pairs whose first element is a string, a JSON
+       object value is created where the first elements of the pairs are
+       treated as keys and the second elements are as values.
+    3. In all other cases, an array is created.
+
+    The rules aim to create the best fit between a C++ initializer list and
+    JSON values. The rationale is as follows:
+
+    1. The empty initializer list is written as `{}` which is exactly an empty
+       JSON object.
+    2. C++ has no way of describing mapped types other than to list a list of
+       pairs. As JSON requires that keys must be of type string, rule 2 is the
+       weakest constraint one can pose on initializer lists to interpret them
+       as an object.
+    3. In all other cases, the initializer list could not be interpreted as
+       JSON object type, so interpreting it as JSON array type is safe.
+
+    With the rules described above, the following JSON values cannot be
+    expressed by an initializer list:
+
+    - the empty array (`[]`): use @ref array(initializer_list_t)
+      with an empty initializer list in this case
+    - arrays whose elements satisfy rule 2: use @ref
+      array(initializer_list_t) with the same initializer list
+      in this case
+
+    @note When used without parentheses around an empty initializer list, @ref
+    basic_json() is called instead of this function, yielding the JSON null
+    value.
+
+    @param[in] init  initializer list with JSON values
+
+    @param[in] type_deduction internal parameter; when set to `true`, the type
+    of the JSON value is deducted from the initializer list @a init; when set
+    to `false`, the type provided via @a manual_type is forced. This mode is
+    used by the functions @ref array(initializer_list_t) and
+    @ref object(initializer_list_t).
+
+    @param[in] manual_type internal parameter; when @a type_deduction is set
+    to `false`, the created JSON value will use the provided type (only @ref
+    value_t::array and @ref value_t::object are valid); when @a type_deduction
+    is set to `true`, this parameter has no effect
+
+    @throw type_error.301 if @a type_deduction is `false`, @a manual_type is
+    `value_t::object`, but @a init contains an element which is not a pair
+    whose first element is a string. In this case, the constructor could not
+    create an object. If @a type_deduction would have be `true`, an array
+    would have been created. See @ref object(initializer_list_t)
+    for an example.
+
+    @complexity Linear in the size of the initializer list @a init.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @liveexample{The example below shows how JSON values are created from
+    initializer lists.,basic_json__list_init_t}
+
+    @sa @ref array(initializer_list_t) -- create a JSON array
+    value from an initializer list
+    @sa @ref object(initializer_list_t) -- create a JSON object
+    value from an initializer list
+
+    @since version 1.0.0
+    */
+    basic_json(initializer_list_t init,
+               bool type_deduction = true,
+               value_t manual_type = value_t::array)
+    {
+        // check if each element is an array with two elements whose first
+        // element is a string
+        bool is_an_object = std::all_of(init.begin(), init.end(),
+                                        [](const detail::json_ref<basic_json>& element_ref)
+        {
+            return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[0].is_string();
+        });
+
+        // adjust type if type deduction is not wanted
+        if (!type_deduction)
+        {
+            // if array is wanted, do not create an object though possible
+            if (manual_type == value_t::array)
+            {
+                is_an_object = false;
+            }
+
+            // if object is wanted but impossible, throw an exception
+            if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
+            {
+                JSON_THROW(type_error::create(301, "cannot create object from initializer list"));
+            }
+        }
+
+        if (is_an_object)
+        {
+            // the initializer list is a list of pairs -> create object
+            m_type = value_t::object;
+            m_value = value_t::object;
+
+            std::for_each(init.begin(), init.end(), [this](const detail::json_ref<basic_json>& element_ref)
+            {
+                auto element = element_ref.moved_or_copied();
+                m_value.object->emplace(
+                    std::move(*((*element.m_value.array)[0].m_value.string)),
+                    std::move((*element.m_value.array)[1]));
+            });
+        }
+        else
+        {
+            // the initializer list describes an array -> create array
+            m_type = value_t::array;
+            m_value.array = create<array_t>(init.begin(), init.end());
+        }
+
+        assert_invariant();
+    }
+
+    /*!
+    @brief explicitly create a binary array (without subtype)
+
+    Creates a JSON binary array value from a given binary container. Binary
+    values are part of various binary formats, such as CBOR, MessagePack, and
+    BSON. This constructor is used to create a value for serialization to those
+    formats.
+
+    @note Note, this function exists because of the difficulty in correctly
+    specifying the correct template overload in the standard value ctor, as both
+    JSON arrays and JSON binary arrays are backed with some form of a
+    `std::vector`. Because JSON binary arrays are a non-standard extension it
+    was decided that it would be best to prevent automatic initialization of a
+    binary array type, for backwards compatibility and so it does not happen on
+    accident.
+
+    @param[in] init container containing bytes to use as binary type
+
+    @return JSON binary array value
+
+    @complexity Linear in the size of @a init.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @since version 3.8.0
+    */
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(const typename binary_t::container_type& init)
+    {
+        auto res = basic_json();
+        res.m_type = value_t::binary;
+        res.m_value = init;
+        return res;
+    }
+
+    /*!
+    @brief explicitly create a binary array (with subtype)
+
+    Creates a JSON binary array value from a given binary container. Binary
+    values are part of various binary formats, such as CBOR, MessagePack, and
+    BSON. This constructor is used to create a value for serialization to those
+    formats.
+
+    @note Note, this function exists because of the difficulty in correctly
+    specifying the correct template overload in the standard value ctor, as both
+    JSON arrays and JSON binary arrays are backed with some form of a
+    `std::vector`. Because JSON binary arrays are a non-standard extension it
+    was decided that it would be best to prevent automatic initialization of a
+    binary array type, for backwards compatibility and so it does not happen on
+    accident.
+
+    @param[in] init container containing bytes to use as binary type
+    @param[in] subtype subtype to use in MessagePack and BSON
+
+    @return JSON binary array value
+
+    @complexity Linear in the size of @a init.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @since version 3.8.0
+    */
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(const typename binary_t::container_type& init, std::uint8_t subtype)
+    {
+        auto res = basic_json();
+        res.m_type = value_t::binary;
+        res.m_value = binary_t(init, subtype);
+        return res;
+    }
+
+    /// @copydoc binary(const typename binary_t::container_type&)
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(typename binary_t::container_type&& init)
+    {
+        auto res = basic_json();
+        res.m_type = value_t::binary;
+        res.m_value = std::move(init);
+        return res;
+    }
+
+    /// @copydoc binary(const typename binary_t::container_type&, std::uint8_t)
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(typename binary_t::container_type&& init, std::uint8_t subtype)
+    {
+        auto res = basic_json();
+        res.m_type = value_t::binary;
+        res.m_value = binary_t(std::move(init), subtype);
+        return res;
+    }
+
+    /*!
+    @brief explicitly create an array from an initializer list
+
+    Creates a JSON array value from a given initializer list. That is, given a
+    list of values `a, b, c`, creates the JSON value `[a, b, c]`. If the
+    initializer list is empty, the empty array `[]` is created.
+
+    @note This function is only needed to express two edge cases that cannot
+    be realized with the initializer list constructor (@ref
+    basic_json(initializer_list_t, bool, value_t)). These cases
+    are:
+    1. creating an array whose elements are all pairs whose first element is a
+    string -- in this case, the initializer list constructor would create an
+    object, taking the first elements as keys
+    2. creating an empty array -- passing the empty initializer list to the
+    initializer list constructor yields an empty object
+
+    @param[in] init  initializer list with JSON values to create an array from
+    (optional)
+
+    @return JSON array value
+
+    @complexity Linear in the size of @a init.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @liveexample{The following code shows an example for the `array`
+    function.,array}
+
+    @sa @ref basic_json(initializer_list_t, bool, value_t) --
+    create a JSON value from an initializer list
+    @sa @ref object(initializer_list_t) -- create a JSON object
+    value from an initializer list
+
+    @since version 1.0.0
+    */
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json array(initializer_list_t init = {})
+    {
+        return basic_json(init, false, value_t::array);
+    }
+
+    /*!
+    @brief explicitly create an object from an initializer list
+
+    Creates a JSON object value from a given initializer list. The initializer
+    lists elements must be pairs, and their first elements must be strings. If
+    the initializer list is empty, the empty object `{}` is created.
+
+    @note This function is only added for symmetry reasons. In contrast to the
+    related function @ref array(initializer_list_t), there are
+    no cases which can only be expressed by this function. That is, any
+    initializer list @a init can also be passed to the initializer list
+    constructor @ref basic_json(initializer_list_t, bool, value_t).
+
+    @param[in] init  initializer list to create an object from (optional)
+
+    @return JSON object value
+
+    @throw type_error.301 if @a init is not a list of pairs whose first
+    elements are strings. In this case, no object can be created. When such a
+    value is passed to @ref basic_json(initializer_list_t, bool, value_t),
+    an array would have been created from the passed initializer list @a init.
+    See example below.
+
+    @complexity Linear in the size of @a init.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @liveexample{The following code shows an example for the `object`
+    function.,object}
+
+    @sa @ref basic_json(initializer_list_t, bool, value_t) --
+    create a JSON value from an initializer list
+    @sa @ref array(initializer_list_t) -- create a JSON array
+    value from an initializer list
+
+    @since version 1.0.0
+    */
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json object(initializer_list_t init = {})
+    {
+        return basic_json(init, false, value_t::object);
+    }
+
+    /*!
+    @brief construct an array with count copies of given value
+
+    Constructs a JSON array value by creating @a cnt copies of a passed value.
+    In case @a cnt is `0`, an empty array is created.
+
+    @param[in] cnt  the number of JSON copies of @a val to create
+    @param[in] val  the JSON value to copy
+
+    @post `std::distance(begin(),end()) == cnt` holds.
+
+    @complexity Linear in @a cnt.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @liveexample{The following code shows examples for the @ref
+    basic_json(size_type\, const basic_json&)
+    constructor.,basic_json__size_type_basic_json}
+
+    @since version 1.0.0
+    */
+    basic_json(size_type cnt, const basic_json& val)
+        : m_type(value_t::array)
+    {
+        m_value.array = create<array_t>(cnt, val);
+        assert_invariant();
+    }
+
+    /*!
+    @brief construct a JSON container given an iterator range
+
+    Constructs the JSON value with the contents of the range `[first, last)`.
+    The semantics depends on the different types a JSON value can have:
+    - In case of a null type, invalid_iterator.206 is thrown.
+    - In case of other primitive types (number, boolean, or string), @a first
+      must be `begin()` and @a last must be `end()`. In this case, the value is
+      copied. Otherwise, invalid_iterator.204 is thrown.
+    - In case of structured types (array, object), the constructor behaves as
+      similar versions for `std::vector` or `std::map`; that is, a JSON array
+      or object is constructed from the values in the range.
+
+    @tparam InputIT an input iterator type (@ref iterator or @ref
+    const_iterator)
+
+    @param[in] first begin of the range to copy from (included)
+    @param[in] last end of the range to copy from (excluded)
+
+    @pre Iterators @a first and @a last must be initialized. **This
+         precondition is enforced with an assertion (see warning).** If
+         assertions are switched off, a violation of this precondition yields
+         undefined behavior.
+
+    @pre Range `[first, last)` is valid. Usually, this precondition cannot be
+         checked efficiently. Only certain edge cases are detected; see the
+         description of the exceptions below. A violation of this precondition
+         yields undefined behavior.
+
+    @warning A precondition is enforced with a runtime assertion that will
+             result in calling `std::abort` if this precondition is not met.
+             Assertions can be disabled by defining `NDEBUG` at compile time.
+             See https://en.cppreference.com/w/cpp/error/assert for more
+             information.
+
+    @throw invalid_iterator.201 if iterators @a first and @a last are not
+    compatible (i.e., do not belong to the same JSON value). In this case,
+    the range `[first, last)` is undefined.
+    @throw invalid_iterator.204 if iterators @a first and @a last belong to a
+    primitive type (number, boolean, or string), but @a first does not point
+    to the first element any more. In this case, the range `[first, last)` is
+    undefined. See example code below.
+    @throw invalid_iterator.206 if iterators @a first and @a last belong to a
+    null value. In this case, the range `[first, last)` is undefined.
+
+    @complexity Linear in distance between @a first and @a last.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @liveexample{The example below shows several ways to create JSON values by
+    specifying a subrange with iterators.,basic_json__InputIt_InputIt}
+
+    @since version 1.0.0
+    */
+    template < class InputIT, typename std::enable_if <
+                   std::is_same<InputIT, typename basic_json_t::iterator>::value ||
+                   std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int >::type = 0 >
+    basic_json(InputIT first, InputIT last)
+    {
+        JSON_ASSERT(first.m_object != nullptr);
+        JSON_ASSERT(last.m_object != nullptr);
+
+        // make sure iterator fits the current value
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(201, "iterators are not compatible"));
+        }
+
+        // copy type from first iterator
+        m_type = first.m_object->m_type;
+
+        // check if iterator range is complete for primitive values
+        switch (m_type)
+        {
+            case value_t::boolean:
+            case value_t::number_float:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::string:
+            {
+                if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin()
+                                         || !last.m_it.primitive_iterator.is_end()))
+                {
+                    JSON_THROW(invalid_iterator::create(204, "iterators out of range"));
+                }
+                break;
+            }
+
+            default:
+                break;
+        }
+
+        switch (m_type)
+        {
+            case value_t::number_integer:
+            {
+                m_value.number_integer = first.m_object->m_value.number_integer;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_value.number_unsigned = first.m_object->m_value.number_unsigned;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_value.number_float = first.m_object->m_value.number_float;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_value.boolean = first.m_object->m_value.boolean;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_value = *first.m_object->m_value.string;
+                break;
+            }
+
+            case value_t::object:
+            {
+                m_value.object = create<object_t>(first.m_it.object_iterator,
+                                                  last.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_value.array = create<array_t>(first.m_it.array_iterator,
+                                                last.m_it.array_iterator);
+                break;
+            }
+
+            case value_t::binary:
+            {
+                m_value = *first.m_object->m_value.binary;
+                break;
+            }
+
+            default:
+                JSON_THROW(invalid_iterator::create(206, "cannot construct with iterators from " +
+                                                    std::string(first.m_object->type_name())));
+        }
+
+        assert_invariant();
+    }
+
+
+    ///////////////////////////////////////
+    // other constructors and destructor //
+    ///////////////////////////////////////
+
+    template<typename JsonRef,
+             detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>,
+                                 std::is_same<typename JsonRef::value_type, basic_json>>::value, int> = 0 >
+    basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {}
+
+    /*!
+    @brief copy constructor
+
+    Creates a copy of a given JSON value.
+
+    @param[in] other  the JSON value to copy
+
+    @post `*this == other`
+
+    @complexity Linear in the size of @a other.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is linear.
+    - As postcondition, it holds: `other == basic_json(other)`.
+
+    @liveexample{The following code shows an example for the copy
+    constructor.,basic_json__basic_json}
+
+    @since version 1.0.0
+    */
+    basic_json(const basic_json& other)
+        : m_type(other.m_type)
+    {
+        // check of passed value is valid
+        other.assert_invariant();
+
+        switch (m_type)
+        {
+            case value_t::object:
+            {
+                m_value = *other.m_value.object;
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_value = *other.m_value.array;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_value = *other.m_value.string;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_value = other.m_value.boolean;
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                m_value = other.m_value.number_integer;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_value = other.m_value.number_unsigned;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_value = other.m_value.number_float;
+                break;
+            }
+
+            case value_t::binary:
+            {
+                m_value = *other.m_value.binary;
+                break;
+            }
+
+            default:
+                break;
+        }
+
+        assert_invariant();
+    }
+
+    /*!
+    @brief move constructor
+
+    Move constructor. Constructs a JSON value with the contents of the given
+    value @a other using move semantics. It "steals" the resources from @a
+    other and leaves it as JSON null value.
+
+    @param[in,out] other  value to move to this object
+
+    @post `*this` has the same value as @a other before the call.
+    @post @a other is a JSON null value.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this constructor never throws
+    exceptions.
+
+    @requirement This function helps `basic_json` satisfying the
+    [MoveConstructible](https://en.cppreference.com/w/cpp/named_req/MoveConstructible)
+    requirements.
+
+    @liveexample{The code below shows the move constructor explicitly called
+    via std::move.,basic_json__moveconstructor}
+
+    @since version 1.0.0
+    */
+    basic_json(basic_json&& other) noexcept
+        : m_type(std::move(other.m_type)),
+          m_value(std::move(other.m_value))
+    {
+        // check that passed value is valid
+        other.assert_invariant();
+
+        // invalidate payload
+        other.m_type = value_t::null;
+        other.m_value = {};
+
+        assert_invariant();
+    }
+
+    /*!
+    @brief copy assignment
+
+    Copy assignment operator. Copies a JSON value via the "copy and swap"
+    strategy: It is expressed in terms of the copy constructor, destructor,
+    and the `swap()` member function.
+
+    @param[in] other  value to copy from
+
+    @complexity Linear.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is linear.
+
+    @liveexample{The code below shows and example for the copy assignment. It
+    creates a copy of value `a` which is then swapped with `b`. Finally\, the
+    copy of `a` (which is the null value after the swap) is
+    destroyed.,basic_json__copyassignment}
+
+    @since version 1.0.0
+    */
+    basic_json& operator=(basic_json other) noexcept (
+        std::is_nothrow_move_constructible<value_t>::value&&
+        std::is_nothrow_move_assignable<value_t>::value&&
+        std::is_nothrow_move_constructible<json_value>::value&&
+        std::is_nothrow_move_assignable<json_value>::value
+    )
+    {
+        // check that passed value is valid
+        other.assert_invariant();
+
+        using std::swap;
+        swap(m_type, other.m_type);
+        swap(m_value, other.m_value);
+
+        assert_invariant();
+        return *this;
+    }
+
+    /*!
+    @brief destructor
+
+    Destroys the JSON value and frees all allocated memory.
+
+    @complexity Linear.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is linear.
+    - All stored elements are destroyed and all memory is freed.
+
+    @since version 1.0.0
+    */
+    ~basic_json() noexcept
+    {
+        assert_invariant();
+        m_value.destroy(m_type);
+    }
+
+    /// @}
+
+  public:
+    ///////////////////////
+    // object inspection //
+    ///////////////////////
+
+    /// @name object inspection
+    /// Functions to inspect the type of a JSON value.
+    /// @{
+
+    /*!
+    @brief serialization
+
+    Serialization function for JSON values. The function tries to mimic
+    Python's `json.dumps()` function, and currently supports its @a indent
+    and @a ensure_ascii parameters.
+
+    @param[in] indent If indent is nonnegative, then array elements and object
+    members will be pretty-printed with that indent level. An indent level of
+    `0` will only insert newlines. `-1` (the default) selects the most compact
+    representation.
+    @param[in] indent_char The character to use for indentation if @a indent is
+    greater than `0`. The default is ` ` (space).
+    @param[in] ensure_ascii If @a ensure_ascii is true, all non-ASCII characters
+    in the output are escaped with `\uXXXX` sequences, and the result consists
+    of ASCII characters only.
+    @param[in] error_handler  how to react on decoding errors; there are three
+    possible values: `strict` (throws and exception in case a decoding error
+    occurs; default), `replace` (replace invalid UTF-8 sequences with U+FFFD),
+    and `ignore` (ignore invalid UTF-8 sequences during serialization; all
+    bytes are copied to the output unchanged).
+
+    @return string containing the serialization of the JSON value
+
+    @throw type_error.316 if a string stored inside the JSON value is not
+                          UTF-8 encoded and @a error_handler is set to strict
+
+    @note Binary values are serialized as object containing two keys:
+      - "bytes": an array of bytes as integers
+      - "subtype": the subtype as integer or "null" if the binary has no subtype
+
+    @complexity Linear.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @liveexample{The following example shows the effect of different @a indent\,
+    @a indent_char\, and @a ensure_ascii parameters to the result of the
+    serialization.,dump}
+
+    @see https://docs.python.org/2/library/json.html#json.dump
+
+    @since version 1.0.0; indentation character @a indent_char, option
+           @a ensure_ascii and exceptions added in version 3.0.0; error
+           handlers added in version 3.4.0; serialization of binary values added
+           in version 3.8.0.
+    */
+    string_t dump(const int indent = -1,
+                  const char indent_char = ' ',
+                  const bool ensure_ascii = false,
+                  const error_handler_t error_handler = error_handler_t::strict) const
+    {
+        string_t result;
+        serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);
+
+        if (indent >= 0)
+        {
+            s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent));
+        }
+        else
+        {
+            s.dump(*this, false, ensure_ascii, 0);
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief return the type of the JSON value (explicit)
+
+    Return the type of the JSON value as a value from the @ref value_t
+    enumeration.
+
+    @return the type of the JSON value
+            Value type                | return value
+            ------------------------- | -------------------------
+            null                      | value_t::null
+            boolean                   | value_t::boolean
+            string                    | value_t::string
+            number (integer)          | value_t::number_integer
+            number (unsigned integer) | value_t::number_unsigned
+            number (floating-point)   | value_t::number_float
+            object                    | value_t::object
+            array                     | value_t::array
+            binary                    | value_t::binary
+            discarded                 | value_t::discarded
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `type()` for all JSON
+    types.,type}
+
+    @sa @ref operator value_t() -- return the type of the JSON value (implicit)
+    @sa @ref type_name() -- return the type as string
+
+    @since version 1.0.0
+    */
+    constexpr value_t type() const noexcept
+    {
+        return m_type;
+    }
+
+    /*!
+    @brief return whether type is primitive
+
+    This function returns true if and only if the JSON type is primitive
+    (string, number, boolean, or null).
+
+    @return `true` if type is primitive (string, number, boolean, or null),
+    `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_primitive()` for all JSON
+    types.,is_primitive}
+
+    @sa @ref is_structured() -- returns whether JSON value is structured
+    @sa @ref is_null() -- returns whether JSON value is `null`
+    @sa @ref is_string() -- returns whether JSON value is a string
+    @sa @ref is_boolean() -- returns whether JSON value is a boolean
+    @sa @ref is_number() -- returns whether JSON value is a number
+    @sa @ref is_binary() -- returns whether JSON value is a binary array
+
+    @since version 1.0.0
+    */
+    constexpr bool is_primitive() const noexcept
+    {
+        return is_null() || is_string() || is_boolean() || is_number() || is_binary();
+    }
+
+    /*!
+    @brief return whether type is structured
+
+    This function returns true if and only if the JSON type is structured
+    (array or object).
+
+    @return `true` if type is structured (array or object), `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_structured()` for all JSON
+    types.,is_structured}
+
+    @sa @ref is_primitive() -- returns whether value is primitive
+    @sa @ref is_array() -- returns whether value is an array
+    @sa @ref is_object() -- returns whether value is an object
+
+    @since version 1.0.0
+    */
+    constexpr bool is_structured() const noexcept
+    {
+        return is_array() || is_object();
+    }
+
+    /*!
+    @brief return whether value is null
+
+    This function returns true if and only if the JSON value is null.
+
+    @return `true` if type is null, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_null()` for all JSON
+    types.,is_null}
+
+    @since version 1.0.0
+    */
+    constexpr bool is_null() const noexcept
+    {
+        return m_type == value_t::null;
+    }
+
+    /*!
+    @brief return whether value is a boolean
+
+    This function returns true if and only if the JSON value is a boolean.
+
+    @return `true` if type is boolean, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_boolean()` for all JSON
+    types.,is_boolean}
+
+    @since version 1.0.0
+    */
+    constexpr bool is_boolean() const noexcept
+    {
+        return m_type == value_t::boolean;
+    }
+
+    /*!
+    @brief return whether value is a number
+
+    This function returns true if and only if the JSON value is a number. This
+    includes both integer (signed and unsigned) and floating-point values.
+
+    @return `true` if type is number (regardless whether integer, unsigned
+    integer or floating-type), `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_number()` for all JSON
+    types.,is_number}
+
+    @sa @ref is_number_integer() -- check if value is an integer or unsigned
+    integer number
+    @sa @ref is_number_unsigned() -- check if value is an unsigned integer
+    number
+    @sa @ref is_number_float() -- check if value is a floating-point number
+
+    @since version 1.0.0
+    */
+    constexpr bool is_number() const noexcept
+    {
+        return is_number_integer() || is_number_float();
+    }
+
+    /*!
+    @brief return whether value is an integer number
+
+    This function returns true if and only if the JSON value is a signed or
+    unsigned integer number. This excludes floating-point values.
+
+    @return `true` if type is an integer or unsigned integer number, `false`
+    otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_number_integer()` for all
+    JSON types.,is_number_integer}
+
+    @sa @ref is_number() -- check if value is a number
+    @sa @ref is_number_unsigned() -- check if value is an unsigned integer
+    number
+    @sa @ref is_number_float() -- check if value is a floating-point number
+
+    @since version 1.0.0
+    */
+    constexpr bool is_number_integer() const noexcept
+    {
+        return m_type == value_t::number_integer || m_type == value_t::number_unsigned;
+    }
+
+    /*!
+    @brief return whether value is an unsigned integer number
+
+    This function returns true if and only if the JSON value is an unsigned
+    integer number. This excludes floating-point and signed integer values.
+
+    @return `true` if type is an unsigned integer number, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_number_unsigned()` for all
+    JSON types.,is_number_unsigned}
+
+    @sa @ref is_number() -- check if value is a number
+    @sa @ref is_number_integer() -- check if value is an integer or unsigned
+    integer number
+    @sa @ref is_number_float() -- check if value is a floating-point number
+
+    @since version 2.0.0
+    */
+    constexpr bool is_number_unsigned() const noexcept
+    {
+        return m_type == value_t::number_unsigned;
+    }
+
+    /*!
+    @brief return whether value is a floating-point number
+
+    This function returns true if and only if the JSON value is a
+    floating-point number. This excludes signed and unsigned integer values.
+
+    @return `true` if type is a floating-point number, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_number_float()` for all
+    JSON types.,is_number_float}
+
+    @sa @ref is_number() -- check if value is number
+    @sa @ref is_number_integer() -- check if value is an integer number
+    @sa @ref is_number_unsigned() -- check if value is an unsigned integer
+    number
+
+    @since version 1.0.0
+    */
+    constexpr bool is_number_float() const noexcept
+    {
+        return m_type == value_t::number_float;
+    }
+
+    /*!
+    @brief return whether value is an object
+
+    This function returns true if and only if the JSON value is an object.
+
+    @return `true` if type is object, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_object()` for all JSON
+    types.,is_object}
+
+    @since version 1.0.0
+    */
+    constexpr bool is_object() const noexcept
+    {
+        return m_type == value_t::object;
+    }
+
+    /*!
+    @brief return whether value is an array
+
+    This function returns true if and only if the JSON value is an array.
+
+    @return `true` if type is array, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_array()` for all JSON
+    types.,is_array}
+
+    @since version 1.0.0
+    */
+    constexpr bool is_array() const noexcept
+    {
+        return m_type == value_t::array;
+    }
+
+    /*!
+    @brief return whether value is a string
+
+    This function returns true if and only if the JSON value is a string.
+
+    @return `true` if type is string, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_string()` for all JSON
+    types.,is_string}
+
+    @since version 1.0.0
+    */
+    constexpr bool is_string() const noexcept
+    {
+        return m_type == value_t::string;
+    }
+
+    /*!
+    @brief return whether value is a binary array
+
+    This function returns true if and only if the JSON value is a binary array.
+
+    @return `true` if type is binary array, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_binary()` for all JSON
+    types.,is_binary}
+
+    @since version 3.8.0
+    */
+    constexpr bool is_binary() const noexcept
+    {
+        return m_type == value_t::binary;
+    }
+
+    /*!
+    @brief return whether value is discarded
+
+    This function returns true if and only if the JSON value was discarded
+    during parsing with a callback function (see @ref parser_callback_t).
+
+    @note This function will always be `false` for JSON values after parsing.
+    That is, discarded values can only occur during parsing, but will be
+    removed when inside a structured value or replaced by null in other cases.
+
+    @return `true` if type is discarded, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_discarded()` for all JSON
+    types.,is_discarded}
+
+    @since version 1.0.0
+    */
+    constexpr bool is_discarded() const noexcept
+    {
+        return m_type == value_t::discarded;
+    }
+
+    /*!
+    @brief return the type of the JSON value (implicit)
+
+    Implicitly return the type of the JSON value as a value from the @ref
+    value_t enumeration.
+
+    @return the type of the JSON value
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies the @ref value_t operator for
+    all JSON types.,operator__value_t}
+
+    @sa @ref type() -- return the type of the JSON value (explicit)
+    @sa @ref type_name() -- return the type as string
+
+    @since version 1.0.0
+    */
+    constexpr operator value_t() const noexcept
+    {
+        return m_type;
+    }
+
+    /// @}
+
+  private:
+    //////////////////
+    // value access //
+    //////////////////
+
+    /// get a boolean (explicit)
+    boolean_t get_impl(boolean_t* /*unused*/) const
+    {
+        if (JSON_HEDLEY_LIKELY(is_boolean()))
+        {
+            return m_value.boolean;
+        }
+
+        JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(type_name())));
+    }
+
+    /// get a pointer to the value (object)
+    object_t* get_impl_ptr(object_t* /*unused*/) noexcept
+    {
+        return is_object() ? m_value.object : nullptr;
+    }
+
+    /// get a pointer to the value (object)
+    constexpr const object_t* get_impl_ptr(const object_t* /*unused*/) const noexcept
+    {
+        return is_object() ? m_value.object : nullptr;
+    }
+
+    /// get a pointer to the value (array)
+    array_t* get_impl_ptr(array_t* /*unused*/) noexcept
+    {
+        return is_array() ? m_value.array : nullptr;
+    }
+
+    /// get a pointer to the value (array)
+    constexpr const array_t* get_impl_ptr(const array_t* /*unused*/) const noexcept
+    {
+        return is_array() ? m_value.array : nullptr;
+    }
+
+    /// get a pointer to the value (string)
+    string_t* get_impl_ptr(string_t* /*unused*/) noexcept
+    {
+        return is_string() ? m_value.string : nullptr;
+    }
+
+    /// get a pointer to the value (string)
+    constexpr const string_t* get_impl_ptr(const string_t* /*unused*/) const noexcept
+    {
+        return is_string() ? m_value.string : nullptr;
+    }
+
+    /// get a pointer to the value (boolean)
+    boolean_t* get_impl_ptr(boolean_t* /*unused*/) noexcept
+    {
+        return is_boolean() ? &m_value.boolean : nullptr;
+    }
+
+    /// get a pointer to the value (boolean)
+    constexpr const boolean_t* get_impl_ptr(const boolean_t* /*unused*/) const noexcept
+    {
+        return is_boolean() ? &m_value.boolean : nullptr;
+    }
+
+    /// get a pointer to the value (integer number)
+    number_integer_t* get_impl_ptr(number_integer_t* /*unused*/) noexcept
+    {
+        return is_number_integer() ? &m_value.number_integer : nullptr;
+    }
+
+    /// get a pointer to the value (integer number)
+    constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /*unused*/) const noexcept
+    {
+        return is_number_integer() ? &m_value.number_integer : nullptr;
+    }
+
+    /// get a pointer to the value (unsigned number)
+    number_unsigned_t* get_impl_ptr(number_unsigned_t* /*unused*/) noexcept
+    {
+        return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
+    }
+
+    /// get a pointer to the value (unsigned number)
+    constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t* /*unused*/) const noexcept
+    {
+        return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
+    }
+
+    /// get a pointer to the value (floating-point number)
+    number_float_t* get_impl_ptr(number_float_t* /*unused*/) noexcept
+    {
+        return is_number_float() ? &m_value.number_float : nullptr;
+    }
+
+    /// get a pointer to the value (floating-point number)
+    constexpr const number_float_t* get_impl_ptr(const number_float_t* /*unused*/) const noexcept
+    {
+        return is_number_float() ? &m_value.number_float : nullptr;
+    }
+
+    /// get a pointer to the value (binary)
+    binary_t* get_impl_ptr(binary_t* /*unused*/) noexcept
+    {
+        return is_binary() ? m_value.binary : nullptr;
+    }
+
+    /// get a pointer to the value (binary)
+    constexpr const binary_t* get_impl_ptr(const binary_t* /*unused*/) const noexcept
+    {
+        return is_binary() ? m_value.binary : nullptr;
+    }
+
+    /*!
+    @brief helper function to implement get_ref()
+
+    This function helps to implement get_ref() without code duplication for
+    const and non-const overloads
+
+    @tparam ThisType will be deduced as `basic_json` or `const basic_json`
+
+    @throw type_error.303 if ReferenceType does not match underlying value
+    type of the current JSON
+    */
+    template<typename ReferenceType, typename ThisType>
+    static ReferenceType get_ref_impl(ThisType& obj)
+    {
+        // delegate the call to get_ptr<>()
+        auto ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
+
+        if (JSON_HEDLEY_LIKELY(ptr != nullptr))
+        {
+            return *ptr;
+        }
+
+        JSON_THROW(type_error::create(303, "incompatible ReferenceType for get_ref, actual type is " + std::string(obj.type_name())));
+    }
+
+  public:
+    /// @name value access
+    /// Direct access to the stored value of a JSON value.
+    /// @{
+
+    /*!
+    @brief get special-case overload
+
+    This overloads avoids a lot of template boilerplate, it can be seen as the
+    identity method
+
+    @tparam BasicJsonType == @ref basic_json
+
+    @return a copy of *this
+
+    @complexity Constant.
+
+    @since version 2.1.0
+    */
+    template<typename BasicJsonType, detail::enable_if_t<
+                 std::is_same<typename std::remove_const<BasicJsonType>::type, basic_json_t>::value,
+                 int> = 0>
+    basic_json get() const
+    {
+        return *this;
+    }
+
+    /*!
+    @brief get special-case overload
+
+    This overloads converts the current @ref basic_json in a different
+    @ref basic_json type
+
+    @tparam BasicJsonType == @ref basic_json
+
+    @return a copy of *this, converted into @tparam BasicJsonType
+
+    @complexity Depending on the implementation of the called `from_json()`
+                method.
+
+    @since version 3.2.0
+    */
+    template < typename BasicJsonType, detail::enable_if_t <
+                   !std::is_same<BasicJsonType, basic_json>::value&&
+                   detail::is_basic_json<BasicJsonType>::value, int > = 0 >
+    BasicJsonType get() const
+    {
+        return *this;
+    }
+
+    /*!
+    @brief get a value (explicit)
+
+    Explicit type conversion between the JSON value and a compatible value
+    which is [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
+    and [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
+    The value is converted by calling the @ref json_serializer<ValueType>
+    `from_json()` method.
+
+    The function is equivalent to executing
+    @code {.cpp}
+    ValueType ret;
+    JSONSerializer<ValueType>::from_json(*this, ret);
+    return ret;
+    @endcode
+
+    This overloads is chosen if:
+    - @a ValueType is not @ref basic_json,
+    - @ref json_serializer<ValueType> has a `from_json()` method of the form
+      `void from_json(const basic_json&, ValueType&)`, and
+    - @ref json_serializer<ValueType> does not have a `from_json()` method of
+      the form `ValueType from_json(const basic_json&)`
+
+    @tparam ValueTypeCV the provided value type
+    @tparam ValueType the returned value type
+
+    @return copy of the JSON value, converted to @a ValueType
+
+    @throw what @ref json_serializer<ValueType> `from_json()` method throws
+
+    @liveexample{The example below shows several conversions from JSON values
+    to other types. There a few things to note: (1) Floating-point numbers can
+    be converted to integers\, (2) A JSON array can be converted to a standard
+    `std::vector<short>`\, (3) A JSON object can be converted to C++
+    associative containers such as `std::unordered_map<std::string\,
+    json>`.,get__ValueType_const}
+
+    @since version 2.1.0
+    */
+    template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,
+               detail::enable_if_t <
+                   !detail::is_basic_json<ValueType>::value &&
+                   detail::has_from_json<basic_json_t, ValueType>::value &&
+                   !detail::has_non_default_from_json<basic_json_t, ValueType>::value,
+                   int > = 0 >
+    ValueType get() const noexcept(noexcept(
+                                       JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
+    {
+        // we cannot static_assert on ValueTypeCV being non-const, because
+        // there is support for get<const basic_json_t>(), which is why we
+        // still need the uncvref
+        static_assert(!std::is_reference<ValueTypeCV>::value,
+                      "get() cannot be used with reference types, you might want to use get_ref()");
+        static_assert(std::is_default_constructible<ValueType>::value,
+                      "types must be DefaultConstructible when used with get()");
+
+        ValueType ret;
+        JSONSerializer<ValueType>::from_json(*this, ret);
+        return ret;
+    }
+
+    /*!
+    @brief get a value (explicit); special case
+
+    Explicit type conversion between the JSON value and a compatible value
+    which is **not** [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
+    and **not** [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
+    The value is converted by calling the @ref json_serializer<ValueType>
+    `from_json()` method.
+
+    The function is equivalent to executing
+    @code {.cpp}
+    return JSONSerializer<ValueTypeCV>::from_json(*this);
+    @endcode
+
+    This overloads is chosen if:
+    - @a ValueType is not @ref basic_json and
+    - @ref json_serializer<ValueType> has a `from_json()` method of the form
+      `ValueType from_json(const basic_json&)`
+
+    @note If @ref json_serializer<ValueType> has both overloads of
+    `from_json()`, this one is chosen.
+
+    @tparam ValueTypeCV the provided value type
+    @tparam ValueType the returned value type
+
+    @return copy of the JSON value, converted to @a ValueType
+
+    @throw what @ref json_serializer<ValueType> `from_json()` method throws
+
+    @since version 2.1.0
+    */
+    template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,
+               detail::enable_if_t < !std::is_same<basic_json_t, ValueType>::value &&
+                                     detail::has_non_default_from_json<basic_json_t, ValueType>::value,
+                                     int > = 0 >
+    ValueType get() const noexcept(noexcept(
+                                       JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
+    {
+        static_assert(!std::is_reference<ValueTypeCV>::value,
+                      "get() cannot be used with reference types, you might want to use get_ref()");
+        return JSONSerializer<ValueType>::from_json(*this);
+    }
+
+    /*!
+    @brief get a value (explicit)
+
+    Explicit type conversion between the JSON value and a compatible value.
+    The value is filled into the input parameter by calling the @ref json_serializer<ValueType>
+    `from_json()` method.
+
+    The function is equivalent to executing
+    @code {.cpp}
+    ValueType v;
+    JSONSerializer<ValueType>::from_json(*this, v);
+    @endcode
+
+    This overloads is chosen if:
+    - @a ValueType is not @ref basic_json,
+    - @ref json_serializer<ValueType> has a `from_json()` method of the form
+      `void from_json(const basic_json&, ValueType&)`, and
+
+    @tparam ValueType the input parameter type.
+
+    @return the input parameter, allowing chaining calls.
+
+    @throw what @ref json_serializer<ValueType> `from_json()` method throws
+
+    @liveexample{The example below shows several conversions from JSON values
+    to other types. There a few things to note: (1) Floating-point numbers can
+    be converted to integers\, (2) A JSON array can be converted to a standard
+    `std::vector<short>`\, (3) A JSON object can be converted to C++
+    associative containers such as `std::unordered_map<std::string\,
+    json>`.,get_to}
+
+    @since version 3.3.0
+    */
+    template < typename ValueType,
+               detail::enable_if_t <
+                   !detail::is_basic_json<ValueType>::value&&
+                   detail::has_from_json<basic_json_t, ValueType>::value,
+                   int > = 0 >
+    ValueType & get_to(ValueType& v) const noexcept(noexcept(
+                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
+    {
+        JSONSerializer<ValueType>::from_json(*this, v);
+        return v;
+    }
+
+    // specialization to allow to call get_to with a basic_json value
+    // see https://github.com/nlohmann/json/issues/2175
+    template<typename ValueType,
+             detail::enable_if_t <
+                 detail::is_basic_json<ValueType>::value,
+                 int> = 0>
+    ValueType & get_to(ValueType& v) const
+    {
+        v = *this;
+        return v;
+    }
+
+    template <
+        typename T, std::size_t N,
+        typename Array = T (&)[N],
+        detail::enable_if_t <
+            detail::has_from_json<basic_json_t, Array>::value, int > = 0 >
+    Array get_to(T (&v)[N]) const
+    noexcept(noexcept(JSONSerializer<Array>::from_json(
+                          std::declval<const basic_json_t&>(), v)))
+    {
+        JSONSerializer<Array>::from_json(*this, v);
+        return v;
+    }
+
+
+    /*!
+    @brief get a pointer value (implicit)
+
+    Implicit pointer access to the internally stored JSON value. No copies are
+    made.
+
+    @warning Writing data to the pointee of the result yields an undefined
+    state.
+
+    @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
+    object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
+    @ref number_unsigned_t, or @ref number_float_t. Enforced by a static
+    assertion.
+
+    @return pointer to the internally stored JSON value if the requested
+    pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how pointers to internal values of a
+    JSON value can be requested. Note that no type conversions are made and a
+    `nullptr` is returned if the value and the requested pointer type does not
+    match.,get_ptr}
+
+    @since version 1.0.0
+    */
+    template<typename PointerType, typename std::enable_if<
+                 std::is_pointer<PointerType>::value, int>::type = 0>
+    auto get_ptr() noexcept -> decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
+    {
+        // delegate the call to get_impl_ptr<>()
+        return get_impl_ptr(static_cast<PointerType>(nullptr));
+    }
+
+    /*!
+    @brief get a pointer value (implicit)
+    @copydoc get_ptr()
+    */
+    template < typename PointerType, typename std::enable_if <
+                   std::is_pointer<PointerType>::value&&
+                   std::is_const<typename std::remove_pointer<PointerType>::type>::value, int >::type = 0 >
+    constexpr auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
+    {
+        // delegate the call to get_impl_ptr<>() const
+        return get_impl_ptr(static_cast<PointerType>(nullptr));
+    }
+
+    /*!
+    @brief get a pointer value (explicit)
+
+    Explicit pointer access to the internally stored JSON value. No copies are
+    made.
+
+    @warning The pointer becomes invalid if the underlying JSON object
+    changes.
+
+    @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
+    object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
+    @ref number_unsigned_t, or @ref number_float_t.
+
+    @return pointer to the internally stored JSON value if the requested
+    pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how pointers to internal values of a
+    JSON value can be requested. Note that no type conversions are made and a
+    `nullptr` is returned if the value and the requested pointer type does not
+    match.,get__PointerType}
+
+    @sa @ref get_ptr() for explicit pointer-member access
+
+    @since version 1.0.0
+    */
+    template<typename PointerType, typename std::enable_if<
+                 std::is_pointer<PointerType>::value, int>::type = 0>
+    auto get() noexcept -> decltype(std::declval<basic_json_t&>().template get_ptr<PointerType>())
+    {
+        // delegate the call to get_ptr
+        return get_ptr<PointerType>();
+    }
+
+    /*!
+    @brief get a pointer value (explicit)
+    @copydoc get()
+    */
+    template<typename PointerType, typename std::enable_if<
+                 std::is_pointer<PointerType>::value, int>::type = 0>
+    constexpr auto get() const noexcept -> decltype(std::declval<const basic_json_t&>().template get_ptr<PointerType>())
+    {
+        // delegate the call to get_ptr
+        return get_ptr<PointerType>();
+    }
+
+    /*!
+    @brief get a reference value (implicit)
+
+    Implicit reference access to the internally stored JSON value. No copies
+    are made.
+
+    @warning Writing data to the referee of the result yields an undefined
+    state.
+
+    @tparam ReferenceType reference type; must be a reference to @ref array_t,
+    @ref object_t, @ref string_t, @ref boolean_t, @ref number_integer_t, or
+    @ref number_float_t. Enforced by static assertion.
+
+    @return reference to the internally stored JSON value if the requested
+    reference type @a ReferenceType fits to the JSON value; throws
+    type_error.303 otherwise
+
+    @throw type_error.303 in case passed type @a ReferenceType is incompatible
+    with the stored JSON value; see example below
+
+    @complexity Constant.
+
+    @liveexample{The example shows several calls to `get_ref()`.,get_ref}
+
+    @since version 1.1.0
+    */
+    template<typename ReferenceType, typename std::enable_if<
+                 std::is_reference<ReferenceType>::value, int>::type = 0>
+    ReferenceType get_ref()
+    {
+        // delegate call to get_ref_impl
+        return get_ref_impl<ReferenceType>(*this);
+    }
+
+    /*!
+    @brief get a reference value (implicit)
+    @copydoc get_ref()
+    */
+    template < typename ReferenceType, typename std::enable_if <
+                   std::is_reference<ReferenceType>::value&&
+                   std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int >::type = 0 >
+    ReferenceType get_ref() const
+    {
+        // delegate call to get_ref_impl
+        return get_ref_impl<ReferenceType>(*this);
+    }
+
+    /*!
+    @brief get a value (implicit)
+
+    Implicit type conversion between the JSON value and a compatible value.
+    The call is realized by calling @ref get() const.
+
+    @tparam ValueType non-pointer type compatible to the JSON value, for
+    instance `int` for JSON integer numbers, `bool` for JSON booleans, or
+    `std::vector` types for JSON arrays. The character type of @ref string_t
+    as well as an initializer list of this type is excluded to avoid
+    ambiguities as these types implicitly convert to `std::string`.
+
+    @return copy of the JSON value, converted to type @a ValueType
+
+    @throw type_error.302 in case passed type @a ValueType is incompatible
+    to the JSON value type (e.g., the JSON value is of type boolean, but a
+    string is requested); see example below
+
+    @complexity Linear in the size of the JSON value.
+
+    @liveexample{The example below shows several conversions from JSON values
+    to other types. There a few things to note: (1) Floating-point numbers can
+    be converted to integers\, (2) A JSON array can be converted to a standard
+    `std::vector<short>`\, (3) A JSON object can be converted to C++
+    associative containers such as `std::unordered_map<std::string\,
+    json>`.,operator__ValueType}
+
+    @since version 1.0.0
+    */
+    template < typename ValueType, typename std::enable_if <
+                   !std::is_pointer<ValueType>::value&&
+                   !std::is_same<ValueType, detail::json_ref<basic_json>>::value&&
+                   !std::is_same<ValueType, typename string_t::value_type>::value&&
+                   !detail::is_basic_json<ValueType>::value
+                   && !std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>::value
+#if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
+                   && !std::is_same<ValueType, typename std::string_view>::value
+#endif
+                   && detail::is_detected<detail::get_template_function, const basic_json_t&, ValueType>::value
+                   , int >::type = 0 >
+    JSON_EXPLICIT operator ValueType() const
+    {
+        // delegate the call to get<>() const
+        return get<ValueType>();
+    }
+
+    /*!
+    @return reference to the binary value
+
+    @throw type_error.302 if the value is not binary
+
+    @sa @ref is_binary() to check if the value is binary
+
+    @since version 3.8.0
+    */
+    binary_t& get_binary()
+    {
+        if (!is_binary())
+        {
+            JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(type_name())));
+        }
+
+        return *get_ptr<binary_t*>();
+    }
+
+    /// @copydoc get_binary()
+    const binary_t& get_binary() const
+    {
+        if (!is_binary())
+        {
+            JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(type_name())));
+        }
+
+        return *get_ptr<const binary_t*>();
+    }
+
+    /// @}
+
+
+    ////////////////////
+    // element access //
+    ////////////////////
+
+    /// @name element access
+    /// Access to the JSON value.
+    /// @{
+
+    /*!
+    @brief access specified array element with bounds checking
+
+    Returns a reference to the element at specified location @a idx, with
+    bounds checking.
+
+    @param[in] idx  index of the element to access
+
+    @return reference to the element at index @a idx
+
+    @throw type_error.304 if the JSON value is not an array; in this case,
+    calling `at` with an index makes no sense. See example below.
+    @throw out_of_range.401 if the index @a idx is out of range of the array;
+    that is, `idx >= size()`. See example below.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Constant.
+
+    @since version 1.0.0
+
+    @liveexample{The example below shows how array elements can be read and
+    written using `at()`. It also demonstrates the different exceptions that
+    can be thrown.,at__size_type}
+    */
+    reference at(size_type idx)
+    {
+        // at only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            JSON_TRY
+            {
+                return m_value.array->at(idx);
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create better exception explanation
+                JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
+            }
+        }
+        else
+        {
+            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
+        }
+    }
+
+    /*!
+    @brief access specified array element with bounds checking
+
+    Returns a const reference to the element at specified location @a idx,
+    with bounds checking.
+
+    @param[in] idx  index of the element to access
+
+    @return const reference to the element at index @a idx
+
+    @throw type_error.304 if the JSON value is not an array; in this case,
+    calling `at` with an index makes no sense. See example below.
+    @throw out_of_range.401 if the index @a idx is out of range of the array;
+    that is, `idx >= size()`. See example below.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Constant.
+
+    @since version 1.0.0
+
+    @liveexample{The example below shows how array elements can be read using
+    `at()`. It also demonstrates the different exceptions that can be thrown.,
+    at__size_type_const}
+    */
+    const_reference at(size_type idx) const
+    {
+        // at only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            JSON_TRY
+            {
+                return m_value.array->at(idx);
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create better exception explanation
+                JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
+            }
+        }
+        else
+        {
+            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
+        }
+    }
+
+    /*!
+    @brief access specified object element with bounds checking
+
+    Returns a reference to the element at with specified key @a key, with
+    bounds checking.
+
+    @param[in] key  key of the element to access
+
+    @return reference to the element at key @a key
+
+    @throw type_error.304 if the JSON value is not an object; in this case,
+    calling `at` with a key makes no sense. See example below.
+    @throw out_of_range.403 if the key @a key is is not stored in the object;
+    that is, `find(key) == end()`. See example below.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Logarithmic in the size of the container.
+
+    @sa @ref operator[](const typename object_t::key_type&) for unchecked
+    access by reference
+    @sa @ref value() for access by value with a default value
+
+    @since version 1.0.0
+
+    @liveexample{The example below shows how object elements can be read and
+    written using `at()`. It also demonstrates the different exceptions that
+    can be thrown.,at__object_t_key_type}
+    */
+    reference at(const typename object_t::key_type& key)
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            JSON_TRY
+            {
+                return m_value.object->at(key);
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create better exception explanation
+                JSON_THROW(out_of_range::create(403, "key '" + key + "' not found"));
+            }
+        }
+        else
+        {
+            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
+        }
+    }
+
+    /*!
+    @brief access specified object element with bounds checking
+
+    Returns a const reference to the element at with specified key @a key,
+    with bounds checking.
+
+    @param[in] key  key of the element to access
+
+    @return const reference to the element at key @a key
+
+    @throw type_error.304 if the JSON value is not an object; in this case,
+    calling `at` with a key makes no sense. See example below.
+    @throw out_of_range.403 if the key @a key is is not stored in the object;
+    that is, `find(key) == end()`. See example below.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Logarithmic in the size of the container.
+
+    @sa @ref operator[](const typename object_t::key_type&) for unchecked
+    access by reference
+    @sa @ref value() for access by value with a default value
+
+    @since version 1.0.0
+
+    @liveexample{The example below shows how object elements can be read using
+    `at()`. It also demonstrates the different exceptions that can be thrown.,
+    at__object_t_key_type_const}
+    */
+    const_reference at(const typename object_t::key_type& key) const
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            JSON_TRY
+            {
+                return m_value.object->at(key);
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create better exception explanation
+                JSON_THROW(out_of_range::create(403, "key '" + key + "' not found"));
+            }
+        }
+        else
+        {
+            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
+        }
+    }
+
+    /*!
+    @brief access specified array element
+
+    Returns a reference to the element at specified location @a idx.
+
+    @note If @a idx is beyond the range of the array (i.e., `idx >= size()`),
+    then the array is silently filled up with `null` values to make `idx` a
+    valid reference to the last stored element.
+
+    @param[in] idx  index of the element to access
+
+    @return reference to the element at index @a idx
+
+    @throw type_error.305 if the JSON value is not an array or null; in that
+    cases, using the [] operator with an index makes no sense.
+
+    @complexity Constant if @a idx is in the range of the array. Otherwise
+    linear in `idx - size()`.
+
+    @liveexample{The example below shows how array elements can be read and
+    written using `[]` operator. Note the addition of `null`
+    values.,operatorarray__size_type}
+
+    @since version 1.0.0
+    */
+    reference operator[](size_type idx)
+    {
+        // implicitly convert null value to an empty array
+        if (is_null())
+        {
+            m_type = value_t::array;
+            m_value.array = create<array_t>();
+            assert_invariant();
+        }
+
+        // operator[] only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            // fill up array with null values if given idx is outside range
+            if (idx >= m_value.array->size())
+            {
+                m_value.array->insert(m_value.array->end(),
+                                      idx - m_value.array->size() + 1,
+                                      basic_json());
+            }
+
+            return m_value.array->operator[](idx);
+        }
+
+        JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief access specified array element
+
+    Returns a const reference to the element at specified location @a idx.
+
+    @param[in] idx  index of the element to access
+
+    @return const reference to the element at index @a idx
+
+    @throw type_error.305 if the JSON value is not an array; in that case,
+    using the [] operator with an index makes no sense.
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how array elements can be read using
+    the `[]` operator.,operatorarray__size_type_const}
+
+    @since version 1.0.0
+    */
+    const_reference operator[](size_type idx) const
+    {
+        // const operator[] only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            return m_value.array->operator[](idx);
+        }
+
+        JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief access specified object element
+
+    Returns a reference to the element at with specified key @a key.
+
+    @note If @a key is not found in the object, then it is silently added to
+    the object and filled with a `null` value to make `key` a valid reference.
+    In case the value was `null` before, it is converted to an object.
+
+    @param[in] key  key of the element to access
+
+    @return reference to the element at key @a key
+
+    @throw type_error.305 if the JSON value is not an object or null; in that
+    cases, using the [] operator with a key makes no sense.
+
+    @complexity Logarithmic in the size of the container.
+
+    @liveexample{The example below shows how object elements can be read and
+    written using the `[]` operator.,operatorarray__key_type}
+
+    @sa @ref at(const typename object_t::key_type&) for access by reference
+    with range checking
+    @sa @ref value() for access by value with a default value
+
+    @since version 1.0.0
+    */
+    reference operator[](const typename object_t::key_type& key)
+    {
+        // implicitly convert null value to an empty object
+        if (is_null())
+        {
+            m_type = value_t::object;
+            m_value.object = create<object_t>();
+            assert_invariant();
+        }
+
+        // operator[] only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            return m_value.object->operator[](key);
+        }
+
+        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief read-only access specified object element
+
+    Returns a const reference to the element at with specified key @a key. No
+    bounds checking is performed.
+
+    @warning If the element with key @a key does not exist, the behavior is
+    undefined.
+
+    @param[in] key  key of the element to access
+
+    @return const reference to the element at key @a key
+
+    @pre The element with key @a key must exist. **This precondition is
+         enforced with an assertion.**
+
+    @throw type_error.305 if the JSON value is not an object; in that case,
+    using the [] operator with a key makes no sense.
+
+    @complexity Logarithmic in the size of the container.
+
+    @liveexample{The example below shows how object elements can be read using
+    the `[]` operator.,operatorarray__key_type_const}
+
+    @sa @ref at(const typename object_t::key_type&) for access by reference
+    with range checking
+    @sa @ref value() for access by value with a default value
+
+    @since version 1.0.0
+    */
+    const_reference operator[](const typename object_t::key_type& key) const
+    {
+        // const operator[] only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            JSON_ASSERT(m_value.object->find(key) != m_value.object->end());
+            return m_value.object->find(key)->second;
+        }
+
+        static auto null = object();
+        return null;
+
+        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief access specified object element
+
+    Returns a reference to the element at with specified key @a key.
+
+    @note If @a key is not found in the object, then it is silently added to
+    the object and filled with a `null` value to make `key` a valid reference.
+    In case the value was `null` before, it is converted to an object.
+
+    @param[in] key  key of the element to access
+
+    @return reference to the element at key @a key
+
+    @throw type_error.305 if the JSON value is not an object or null; in that
+    cases, using the [] operator with a key makes no sense.
+
+    @complexity Logarithmic in the size of the container.
+
+    @liveexample{The example below shows how object elements can be read and
+    written using the `[]` operator.,operatorarray__key_type}
+
+    @sa @ref at(const typename object_t::key_type&) for access by reference
+    with range checking
+    @sa @ref value() for access by value with a default value
+
+    @since version 1.1.0
+    */
+    template<typename T>
+    JSON_HEDLEY_NON_NULL(2)
+    reference operator[](T* key)
+    {
+        // implicitly convert null to object
+        if (is_null())
+        {
+            m_type = value_t::object;
+            m_value = value_t::object;
+            assert_invariant();
+        }
+
+        // at only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            return m_value.object->operator[](key);
+        }
+
+        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief read-only access specified object element
+
+    Returns a const reference to the element at with specified key @a key. No
+    bounds checking is performed.
+
+    @warning If the element with key @a key does not exist, the behavior is
+    undefined.
+
+    @param[in] key  key of the element to access
+
+    @return const reference to the element at key @a key
+
+    @pre The element with key @a key must exist. **This precondition is
+         enforced with an assertion.**
+
+    @throw type_error.305 if the JSON value is not an object; in that case,
+    using the [] operator with a key makes no sense.
+
+    @complexity Logarithmic in the size of the container.
+
+    @liveexample{The example below shows how object elements can be read using
+    the `[]` operator.,operatorarray__key_type_const}
+
+    @sa @ref at(const typename object_t::key_type&) for access by reference
+    with range checking
+    @sa @ref value() for access by value with a default value
+
+    @since version 1.1.0
+    */
+    template<typename T>
+    JSON_HEDLEY_NON_NULL(2)
+    const_reference operator[](T* key) const
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            JSON_ASSERT(m_value.object->find(key) != m_value.object->end());
+            return m_value.object->find(key)->second;
+        }
+
+        static auto null = object();
+        return null;
+
+        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief access specified object element with default value
+
+    Returns either a copy of an object's element at the specified key @a key
+    or a given default value if no element with key @a key exists.
+
+    The function is basically equivalent to executing
+    @code {.cpp}
+    try {
+        return at(key);
+    } catch(out_of_range) {
+        return default_value;
+    }
+    @endcode
+
+    @note Unlike @ref at(const typename object_t::key_type&), this function
+    does not throw if the given key @a key was not found.
+
+    @note Unlike @ref operator[](const typename object_t::key_type& key), this
+    function does not implicitly add an element to the position defined by @a
+    key. This function is furthermore also applicable to const objects.
+
+    @param[in] key  key of the element to access
+    @param[in] default_value  the value to return if @a key is not found
+
+    @tparam ValueType type compatible to JSON values, for instance `int` for
+    JSON integer numbers, `bool` for JSON booleans, or `std::vector` types for
+    JSON arrays. Note the type of the expected value at @a key and the default
+    value @a default_value must be compatible.
+
+    @return copy of the element at key @a key or @a default_value if @a key
+    is not found
+
+    @throw type_error.302 if @a default_value does not match the type of the
+    value at @a key
+    @throw type_error.306 if the JSON value is not an object; in that case,
+    using `value()` with a key makes no sense.
+
+    @complexity Logarithmic in the size of the container.
+
+    @liveexample{The example below shows how object elements can be queried
+    with a default value.,basic_json__value}
+
+    @sa @ref at(const typename object_t::key_type&) for access by reference
+    with range checking
+    @sa @ref operator[](const typename object_t::key_type&) for unchecked
+    access by reference
+
+    @since version 1.0.0
+    */
+    // using std::is_convertible in a std::enable_if will fail when using explicit conversions
+    template < class ValueType, typename std::enable_if <
+                   detail::is_getable<basic_json_t, ValueType>::value
+                   && !std::is_same<value_t, ValueType>::value, int >::type = 0 >
+    ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // if key is found, return value and given default value otherwise
+            const auto it = find(key);
+            if (it != end())
+            {
+                return it->template get<ValueType>();
+            }
+
+            return default_value;
+        }
+
+        JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief overload for a default value of type const char*
+    @copydoc basic_json::value(const typename object_t::key_type&, const ValueType&) const
+    */
+    string_t value(const typename object_t::key_type& key, const char* default_value) const
+    {
+        return value(key, string_t(default_value));
+    }
+
+    /*!
+    @brief access specified object element via JSON Pointer with default value
+
+    Returns either a copy of an object's element at the specified key @a key
+    or a given default value if no element with key @a key exists.
+
+    The function is basically equivalent to executing
+    @code {.cpp}
+    try {
+        return at(ptr);
+    } catch(out_of_range) {
+        return default_value;
+    }
+    @endcode
+
+    @note Unlike @ref at(const json_pointer&), this function does not throw
+    if the given key @a key was not found.
+
+    @param[in] ptr  a JSON pointer to the element to access
+    @param[in] default_value  the value to return if @a ptr found no value
+
+    @tparam ValueType type compatible to JSON values, for instance `int` for
+    JSON integer numbers, `bool` for JSON booleans, or `std::vector` types for
+    JSON arrays. Note the type of the expected value at @a key and the default
+    value @a default_value must be compatible.
+
+    @return copy of the element at key @a key or @a default_value if @a key
+    is not found
+
+    @throw type_error.302 if @a default_value does not match the type of the
+    value at @a ptr
+    @throw type_error.306 if the JSON value is not an object; in that case,
+    using `value()` with a key makes no sense.
+
+    @complexity Logarithmic in the size of the container.
+
+    @liveexample{The example below shows how object elements can be queried
+    with a default value.,basic_json__value_ptr}
+
+    @sa @ref operator[](const json_pointer&) for unchecked access by reference
+
+    @since version 2.0.2
+    */
+    template<class ValueType, typename std::enable_if<
+                 detail::is_getable<basic_json_t, ValueType>::value, int>::type = 0>
+    ValueType value(const json_pointer& ptr, const ValueType& default_value) const
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // if pointer resolves a value, return it or use default value
+            JSON_TRY
+            {
+                return ptr.get_checked(this).template get<ValueType>();
+            }
+            JSON_INTERNAL_CATCH (out_of_range&)
+            {
+                return default_value;
+            }
+        }
+
+        JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief overload for a default value of type const char*
+    @copydoc basic_json::value(const json_pointer&, ValueType) const
+    */
+    JSON_HEDLEY_NON_NULL(3)
+    string_t value(const json_pointer& ptr, const char* default_value) const
+    {
+        return value(ptr, string_t(default_value));
+    }
+
+    /*!
+    @brief access the first element
+
+    Returns a reference to the first element in the container. For a JSON
+    container `c`, the expression `c.front()` is equivalent to `*c.begin()`.
+
+    @return In case of a structured type (array or object), a reference to the
+    first element is returned. In case of number, string, boolean, or binary
+    values, a reference to the value is returned.
+
+    @complexity Constant.
+
+    @pre The JSON value must not be `null` (would throw `std::out_of_range`)
+    or an empty array or object (undefined behavior, **guarded by
+    assertions**).
+    @post The JSON value remains unchanged.
+
+    @throw invalid_iterator.214 when called on `null` value
+
+    @liveexample{The following code shows an example for `front()`.,front}
+
+    @sa @ref back() -- access the last element
+
+    @since version 1.0.0
+    */
+    reference front()
+    {
+        return *begin();
+    }
+
+    /*!
+    @copydoc basic_json::front()
+    */
+    const_reference front() const
+    {
+        return *cbegin();
+    }
+
+    /*!
+    @brief access the last element
+
+    Returns a reference to the last element in the container. For a JSON
+    container `c`, the expression `c.back()` is equivalent to
+    @code {.cpp}
+    auto tmp = c.end();
+    --tmp;
+    return *tmp;
+    @endcode
+
+    @return In case of a structured type (array or object), a reference to the
+    last element is returned. In case of number, string, boolean, or binary
+    values, a reference to the value is returned.
+
+    @complexity Constant.
+
+    @pre The JSON value must not be `null` (would throw `std::out_of_range`)
+    or an empty array or object (undefined behavior, **guarded by
+    assertions**).
+    @post The JSON value remains unchanged.
+
+    @throw invalid_iterator.214 when called on a `null` value. See example
+    below.
+
+    @liveexample{The following code shows an example for `back()`.,back}
+
+    @sa @ref front() -- access the first element
+
+    @since version 1.0.0
+    */
+    reference back()
+    {
+        auto tmp = end();
+        --tmp;
+        return *tmp;
+    }
+
+    /*!
+    @copydoc basic_json::back()
+    */
+    const_reference back() const
+    {
+        auto tmp = cend();
+        --tmp;
+        return *tmp;
+    }
+
+    /*!
+    @brief remove element given an iterator
+
+    Removes the element specified by iterator @a pos. The iterator @a pos must
+    be valid and dereferenceable. Thus the `end()` iterator (which is valid,
+    but is not dereferenceable) cannot be used as a value for @a pos.
+
+    If called on a primitive type other than `null`, the resulting JSON value
+    will be `null`.
+
+    @param[in] pos iterator to the element to remove
+    @return Iterator following the last removed element. If the iterator @a
+    pos refers to the last element, the `end()` iterator is returned.
+
+    @tparam IteratorType an @ref iterator or @ref const_iterator
+
+    @post Invalidates iterators and references at or after the point of the
+    erase, including the `end()` iterator.
+
+    @throw type_error.307 if called on a `null` value; example: `"cannot use
+    erase() with null"`
+    @throw invalid_iterator.202 if called on an iterator which does not belong
+    to the current JSON value; example: `"iterator does not fit current
+    value"`
+    @throw invalid_iterator.205 if called on a primitive type with invalid
+    iterator (i.e., any iterator which is not `begin()`); example: `"iterator
+    out of range"`
+
+    @complexity The complexity depends on the type:
+    - objects: amortized constant
+    - arrays: linear in distance between @a pos and the end of the container
+    - strings and binary: linear in the length of the member
+    - other types: constant
+
+    @liveexample{The example shows the result of `erase()` for different JSON
+    types.,erase__IteratorType}
+
+    @sa @ref erase(IteratorType, IteratorType) -- removes the elements in
+    the given range
+    @sa @ref erase(const typename object_t::key_type&) -- removes the element
+    from an object at the given key
+    @sa @ref erase(const size_type) -- removes the element from an array at
+    the given index
+
+    @since version 1.0.0
+    */
+    template < class IteratorType, typename std::enable_if <
+                   std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
+                   std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int >::type
+               = 0 >
+    IteratorType erase(IteratorType pos)
+    {
+        // make sure iterator fits the current value
+        if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
+        }
+
+        IteratorType result = end();
+
+        switch (m_type)
+        {
+            case value_t::boolean:
+            case value_t::number_float:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::string:
+            case value_t::binary:
+            {
+                if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
+                {
+                    JSON_THROW(invalid_iterator::create(205, "iterator out of range"));
+                }
+
+                if (is_string())
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
+                    m_value.string = nullptr;
+                }
+                else if (is_binary())
+                {
+                    AllocatorType<binary_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.binary);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.binary, 1);
+                    m_value.binary = nullptr;
+                }
+
+                m_type = value_t::null;
+                assert_invariant();
+                break;
+            }
+
+            case value_t::object:
+            {
+                result.m_it.object_iterator = m_value.object->erase(pos.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                result.m_it.array_iterator = m_value.array->erase(pos.m_it.array_iterator);
+                break;
+            }
+
+            default:
+                JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief remove elements given an iterator range
+
+    Removes the element specified by the range `[first; last)`. The iterator
+    @a first does not need to be dereferenceable if `first == last`: erasing
+    an empty range is a no-op.
+
+    If called on a primitive type other than `null`, the resulting JSON value
+    will be `null`.
+
+    @param[in] first iterator to the beginning of the range to remove
+    @param[in] last iterator past the end of the range to remove
+    @return Iterator following the last removed element. If the iterator @a
+    second refers to the last element, the `end()` iterator is returned.
+
+    @tparam IteratorType an @ref iterator or @ref const_iterator
+
+    @post Invalidates iterators and references at or after the point of the
+    erase, including the `end()` iterator.
+
+    @throw type_error.307 if called on a `null` value; example: `"cannot use
+    erase() with null"`
+    @throw invalid_iterator.203 if called on iterators which does not belong
+    to the current JSON value; example: `"iterators do not fit current value"`
+    @throw invalid_iterator.204 if called on a primitive type with invalid
+    iterators (i.e., if `first != begin()` and `last != end()`); example:
+    `"iterators out of range"`
+
+    @complexity The complexity depends on the type:
+    - objects: `log(size()) + std::distance(first, last)`
+    - arrays: linear in the distance between @a first and @a last, plus linear
+      in the distance between @a last and end of the container
+    - strings and binary: linear in the length of the member
+    - other types: constant
+
+    @liveexample{The example shows the result of `erase()` for different JSON
+    types.,erase__IteratorType_IteratorType}
+
+    @sa @ref erase(IteratorType) -- removes the element at a given position
+    @sa @ref erase(const typename object_t::key_type&) -- removes the element
+    from an object at the given key
+    @sa @ref erase(const size_type) -- removes the element from an array at
+    the given index
+
+    @since version 1.0.0
+    */
+    template < class IteratorType, typename std::enable_if <
+                   std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
+                   std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int >::type
+               = 0 >
+    IteratorType erase(IteratorType first, IteratorType last)
+    {
+        // make sure iterator fits the current value
+        if (JSON_HEDLEY_UNLIKELY(this != first.m_object || this != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value"));
+        }
+
+        IteratorType result = end();
+
+        switch (m_type)
+        {
+            case value_t::boolean:
+            case value_t::number_float:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::string:
+            case value_t::binary:
+            {
+                if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin()
+                                       || !last.m_it.primitive_iterator.is_end()))
+                {
+                    JSON_THROW(invalid_iterator::create(204, "iterators out of range"));
+                }
+
+                if (is_string())
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
+                    m_value.string = nullptr;
+                }
+                else if (is_binary())
+                {
+                    AllocatorType<binary_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.binary);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.binary, 1);
+                    m_value.binary = nullptr;
+                }
+
+                m_type = value_t::null;
+                assert_invariant();
+                break;
+            }
+
+            case value_t::object:
+            {
+                result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,
+                                              last.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,
+                                             last.m_it.array_iterator);
+                break;
+            }
+
+            default:
+                JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief remove element from a JSON object given a key
+
+    Removes elements from a JSON object with the key value @a key.
+
+    @param[in] key value of the elements to remove
+
+    @return Number of elements removed. If @a ObjectType is the default
+    `std::map` type, the return value will always be `0` (@a key was not
+    found) or `1` (@a key was found).
+
+    @post References and iterators to the erased elements are invalidated.
+    Other references and iterators are not affected.
+
+    @throw type_error.307 when called on a type other than JSON object;
+    example: `"cannot use erase() with null"`
+
+    @complexity `log(size()) + count(key)`
+
+    @liveexample{The example shows the effect of `erase()`.,erase__key_type}
+
+    @sa @ref erase(IteratorType) -- removes the element at a given position
+    @sa @ref erase(IteratorType, IteratorType) -- removes the elements in
+    the given range
+    @sa @ref erase(const size_type) -- removes the element from an array at
+    the given index
+
+    @since version 1.0.0
+    */
+    size_type erase(const typename object_t::key_type& key)
+    {
+        // this erase only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            return m_value.object->erase(key);
+        }
+
+        JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief remove element from a JSON array given an index
+
+    Removes element from a JSON array at the index @a idx.
+
+    @param[in] idx index of the element to remove
+
+    @throw type_error.307 when called on a type other than JSON object;
+    example: `"cannot use erase() with null"`
+    @throw out_of_range.401 when `idx >= size()`; example: `"array index 17
+    is out of range"`
+
+    @complexity Linear in distance between @a idx and the end of the container.
+
+    @liveexample{The example shows the effect of `erase()`.,erase__size_type}
+
+    @sa @ref erase(IteratorType) -- removes the element at a given position
+    @sa @ref erase(IteratorType, IteratorType) -- removes the elements in
+    the given range
+    @sa @ref erase(const typename object_t::key_type&) -- removes the element
+    from an object at the given key
+
+    @since version 1.0.0
+    */
+    void erase(const size_type idx)
+    {
+        // this erase only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            if (JSON_HEDLEY_UNLIKELY(idx >= size()))
+            {
+                JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
+            }
+
+            m_value.array->erase(m_value.array->begin() + static_cast<difference_type>(idx));
+        }
+        else
+        {
+            JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
+        }
+    }
+
+    /// @}
+
+
+    ////////////
+    // lookup //
+    ////////////
+
+    /// @name lookup
+    /// @{
+
+    /*!
+    @brief find an element in a JSON object
+
+    Finds an element in a JSON object with key equivalent to @a key. If the
+    element is not found or the JSON value is not an object, end() is
+    returned.
+
+    @note This method always returns @ref end() when executed on a JSON type
+          that is not an object.
+
+    @param[in] key key value of the element to search for.
+
+    @return Iterator to an element with key equivalent to @a key. If no such
+    element is found or the JSON value is not an object, past-the-end (see
+    @ref end()) iterator is returned.
+
+    @complexity Logarithmic in the size of the JSON object.
+
+    @liveexample{The example shows how `find()` is used.,find__key_type}
+
+    @sa @ref contains(KeyT&&) const -- checks whether a key exists
+
+    @since version 1.0.0
+    */
+    template<typename KeyT>
+    iterator find(KeyT&& key)
+    {
+        auto result = end();
+
+        if (is_object())
+        {
+            result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief find an element in a JSON object
+    @copydoc find(KeyT&&)
+    */
+    template<typename KeyT>
+    const_iterator find(KeyT&& key) const
+    {
+        auto result = cend();
+
+        if (is_object())
+        {
+            result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief returns the number of occurrences of a key in a JSON object
+
+    Returns the number of elements with key @a key. If ObjectType is the
+    default `std::map` type, the return value will always be `0` (@a key was
+    not found) or `1` (@a key was found).
+
+    @note This method always returns `0` when executed on a JSON type that is
+          not an object.
+
+    @param[in] key key value of the element to count
+
+    @return Number of elements with key @a key. If the JSON value is not an
+    object, the return value will be `0`.
+
+    @complexity Logarithmic in the size of the JSON object.
+
+    @liveexample{The example shows how `count()` is used.,count}
+
+    @since version 1.0.0
+    */
+    template<typename KeyT>
+    size_type count(KeyT&& key) const
+    {
+        // return 0 for all nonobject types
+        return is_object() ? m_value.object->count(std::forward<KeyT>(key)) : 0;
+    }
+
+    /*!
+    @brief check the existence of an element in a JSON object
+
+    Check whether an element exists in a JSON object with key equivalent to
+    @a key. If the element is not found or the JSON value is not an object,
+    false is returned.
+
+    @note This method always returns false when executed on a JSON type
+          that is not an object.
+
+    @param[in] key key value to check its existence.
+
+    @return true if an element with specified @a key exists. If no such
+    element with such key is found or the JSON value is not an object,
+    false is returned.
+
+    @complexity Logarithmic in the size of the JSON object.
+
+    @liveexample{The following code shows an example for `contains()`.,contains}
+
+    @sa @ref find(KeyT&&) -- returns an iterator to an object element
+    @sa @ref contains(const json_pointer&) const -- checks the existence for a JSON pointer
+
+    @since version 3.6.0
+    */
+    template < typename KeyT, typename std::enable_if <
+                   !std::is_same<typename std::decay<KeyT>::type, json_pointer>::value, int >::type = 0 >
+    bool contains(KeyT && key) const
+    {
+        return is_object() && m_value.object->find(std::forward<KeyT>(key)) != m_value.object->end();
+    }
+
+    /*!
+    @brief check the existence of an element in a JSON object given a JSON pointer
+
+    Check whether the given JSON pointer @a ptr can be resolved in the current
+    JSON value.
+
+    @note This method can be executed on any JSON value type.
+
+    @param[in] ptr JSON pointer to check its existence.
+
+    @return true if the JSON pointer can be resolved to a stored value, false
+    otherwise.
+
+    @post If `j.contains(ptr)` returns true, it is safe to call `j[ptr]`.
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+
+    @complexity Logarithmic in the size of the JSON object.
+
+    @liveexample{The following code shows an example for `contains()`.,contains_json_pointer}
+
+    @sa @ref contains(KeyT &&) const -- checks the existence of a key
+
+    @since version 3.7.0
+    */
+    bool contains(const json_pointer& ptr) const
+    {
+        return ptr.contains(this);
+    }
+
+    /// @}
+
+
+    ///////////////
+    // iterators //
+    ///////////////
+
+    /// @name iterators
+    /// @{
+
+    /*!
+    @brief returns an iterator to the first element
+
+    Returns an iterator to the first element.
+
+    @image html range-begin-end.svg "Illustration from cppreference.com"
+
+    @return iterator to the first element
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is constant.
+
+    @liveexample{The following code shows an example for `begin()`.,begin}
+
+    @sa @ref cbegin() -- returns a const iterator to the beginning
+    @sa @ref end() -- returns an iterator to the end
+    @sa @ref cend() -- returns a const iterator to the end
+
+    @since version 1.0.0
+    */
+    iterator begin() noexcept
+    {
+        iterator result(this);
+        result.set_begin();
+        return result;
+    }
+
+    /*!
+    @copydoc basic_json::cbegin()
+    */
+    const_iterator begin() const noexcept
+    {
+        return cbegin();
+    }
+
+    /*!
+    @brief returns a const iterator to the first element
+
+    Returns a const iterator to the first element.
+
+    @image html range-begin-end.svg "Illustration from cppreference.com"
+
+    @return const iterator to the first element
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `const_cast<const basic_json&>(*this).begin()`.
+
+    @liveexample{The following code shows an example for `cbegin()`.,cbegin}
+
+    @sa @ref begin() -- returns an iterator to the beginning
+    @sa @ref end() -- returns an iterator to the end
+    @sa @ref cend() -- returns a const iterator to the end
+
+    @since version 1.0.0
+    */
+    const_iterator cbegin() const noexcept
+    {
+        const_iterator result(this);
+        result.set_begin();
+        return result;
+    }
+
+    /*!
+    @brief returns an iterator to one past the last element
+
+    Returns an iterator to one past the last element.
+
+    @image html range-begin-end.svg "Illustration from cppreference.com"
+
+    @return iterator one past the last element
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is constant.
+
+    @liveexample{The following code shows an example for `end()`.,end}
+
+    @sa @ref cend() -- returns a const iterator to the end
+    @sa @ref begin() -- returns an iterator to the beginning
+    @sa @ref cbegin() -- returns a const iterator to the beginning
+
+    @since version 1.0.0
+    */
+    iterator end() noexcept
+    {
+        iterator result(this);
+        result.set_end();
+        return result;
+    }
+
+    /*!
+    @copydoc basic_json::cend()
+    */
+    const_iterator end() const noexcept
+    {
+        return cend();
+    }
+
+    /*!
+    @brief returns a const iterator to one past the last element
+
+    Returns a const iterator to one past the last element.
+
+    @image html range-begin-end.svg "Illustration from cppreference.com"
+
+    @return const iterator one past the last element
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `const_cast<const basic_json&>(*this).end()`.
+
+    @liveexample{The following code shows an example for `cend()`.,cend}
+
+    @sa @ref end() -- returns an iterator to the end
+    @sa @ref begin() -- returns an iterator to the beginning
+    @sa @ref cbegin() -- returns a const iterator to the beginning
+
+    @since version 1.0.0
+    */
+    const_iterator cend() const noexcept
+    {
+        const_iterator result(this);
+        result.set_end();
+        return result;
+    }
+
+    /*!
+    @brief returns an iterator to the reverse-beginning
+
+    Returns an iterator to the reverse-beginning; that is, the last element.
+
+    @image html range-rbegin-rend.svg "Illustration from cppreference.com"
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `reverse_iterator(end())`.
+
+    @liveexample{The following code shows an example for `rbegin()`.,rbegin}
+
+    @sa @ref crbegin() -- returns a const reverse iterator to the beginning
+    @sa @ref rend() -- returns a reverse iterator to the end
+    @sa @ref crend() -- returns a const reverse iterator to the end
+
+    @since version 1.0.0
+    */
+    reverse_iterator rbegin() noexcept
+    {
+        return reverse_iterator(end());
+    }
+
+    /*!
+    @copydoc basic_json::crbegin()
+    */
+    const_reverse_iterator rbegin() const noexcept
+    {
+        return crbegin();
+    }
+
+    /*!
+    @brief returns an iterator to the reverse-end
+
+    Returns an iterator to the reverse-end; that is, one before the first
+    element.
+
+    @image html range-rbegin-rend.svg "Illustration from cppreference.com"
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `reverse_iterator(begin())`.
+
+    @liveexample{The following code shows an example for `rend()`.,rend}
+
+    @sa @ref crend() -- returns a const reverse iterator to the end
+    @sa @ref rbegin() -- returns a reverse iterator to the beginning
+    @sa @ref crbegin() -- returns a const reverse iterator to the beginning
+
+    @since version 1.0.0
+    */
+    reverse_iterator rend() noexcept
+    {
+        return reverse_iterator(begin());
+    }
+
+    /*!
+    @copydoc basic_json::crend()
+    */
+    const_reverse_iterator rend() const noexcept
+    {
+        return crend();
+    }
+
+    /*!
+    @brief returns a const reverse iterator to the last element
+
+    Returns a const iterator to the reverse-beginning; that is, the last
+    element.
+
+    @image html range-rbegin-rend.svg "Illustration from cppreference.com"
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `const_cast<const basic_json&>(*this).rbegin()`.
+
+    @liveexample{The following code shows an example for `crbegin()`.,crbegin}
+
+    @sa @ref rbegin() -- returns a reverse iterator to the beginning
+    @sa @ref rend() -- returns a reverse iterator to the end
+    @sa @ref crend() -- returns a const reverse iterator to the end
+
+    @since version 1.0.0
+    */
+    const_reverse_iterator crbegin() const noexcept
+    {
+        return const_reverse_iterator(cend());
+    }
+
+    /*!
+    @brief returns a const reverse iterator to one before the first
+
+    Returns a const reverse iterator to the reverse-end; that is, one before
+    the first element.
+
+    @image html range-rbegin-rend.svg "Illustration from cppreference.com"
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `const_cast<const basic_json&>(*this).rend()`.
+
+    @liveexample{The following code shows an example for `crend()`.,crend}
+
+    @sa @ref rend() -- returns a reverse iterator to the end
+    @sa @ref rbegin() -- returns a reverse iterator to the beginning
+    @sa @ref crbegin() -- returns a const reverse iterator to the beginning
+
+    @since version 1.0.0
+    */
+    const_reverse_iterator crend() const noexcept
+    {
+        return const_reverse_iterator(cbegin());
+    }
+
+  public:
+    /*!
+    @brief wrapper to access iterator member functions in range-based for
+
+    This function allows to access @ref iterator::key() and @ref
+    iterator::value() during range-based for loops. In these loops, a
+    reference to the JSON values is returned, so there is no access to the
+    underlying iterator.
+
+    For loop without iterator_wrapper:
+
+    @code{cpp}
+    for (auto it = j_object.begin(); it != j_object.end(); ++it)
+    {
+        std::cout << "key: " << it.key() << ", value:" << it.value() << '\n';
+    }
+    @endcode
+
+    Range-based for loop without iterator proxy:
+
+    @code{cpp}
+    for (auto it : j_object)
+    {
+        // "it" is of type json::reference and has no key() member
+        std::cout << "value: " << it << '\n';
+    }
+    @endcode
+
+    Range-based for loop with iterator proxy:
+
+    @code{cpp}
+    for (auto it : json::iterator_wrapper(j_object))
+    {
+        std::cout << "key: " << it.key() << ", value:" << it.value() << '\n';
+    }
+    @endcode
+
+    @note When iterating over an array, `key()` will return the index of the
+          element as string (see example).
+
+    @param[in] ref  reference to a JSON value
+    @return iteration proxy object wrapping @a ref with an interface to use in
+            range-based for loops
+
+    @liveexample{The following code shows how the wrapper is used,iterator_wrapper}
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Constant.
+
+    @note The name of this function is not yet final and may change in the
+    future.
+
+    @deprecated This stream operator is deprecated and will be removed in
+                future 4.0.0 of the library. Please use @ref items() instead;
+                that is, replace `json::iterator_wrapper(j)` with `j.items()`.
+    */
+    JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
+    static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept
+    {
+        return ref.items();
+    }
+
+    /*!
+    @copydoc iterator_wrapper(reference)
+    */
+    JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
+    static iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept
+    {
+        return ref.items();
+    }
+
+    /*!
+    @brief helper to access iterator member functions in range-based for
+
+    This function allows to access @ref iterator::key() and @ref
+    iterator::value() during range-based for loops. In these loops, a
+    reference to the JSON values is returned, so there is no access to the
+    underlying iterator.
+
+    For loop without `items()` function:
+
+    @code{cpp}
+    for (auto it = j_object.begin(); it != j_object.end(); ++it)
+    {
+        std::cout << "key: " << it.key() << ", value:" << it.value() << '\n';
+    }
+    @endcode
+
+    Range-based for loop without `items()` function:
+
+    @code{cpp}
+    for (auto it : j_object)
+    {
+        // "it" is of type json::reference and has no key() member
+        std::cout << "value: " << it << '\n';
+    }
+    @endcode
+
+    Range-based for loop with `items()` function:
+
+    @code{cpp}
+    for (auto& el : j_object.items())
+    {
+        std::cout << "key: " << el.key() << ", value:" << el.value() << '\n';
+    }
+    @endcode
+
+    The `items()` function also allows to use
+    [structured bindings](https://en.cppreference.com/w/cpp/language/structured_binding)
+    (C++17):
+
+    @code{cpp}
+    for (auto& [key, val] : j_object.items())
+    {
+        std::cout << "key: " << key << ", value:" << val << '\n';
+    }
+    @endcode
+
+    @note When iterating over an array, `key()` will return the index of the
+          element as string (see example). For primitive types (e.g., numbers),
+          `key()` returns an empty string.
+
+    @warning Using `items()` on temporary objects is dangerous. Make sure the
+             object's lifetime exeeds the iteration. See
+             <https://github.com/nlohmann/json/issues/2040> for more
+             information.
+
+    @return iteration proxy object wrapping @a ref with an interface to use in
+            range-based for loops
+
+    @liveexample{The following code shows how the function is used.,items}
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Constant.
+
+    @since version 3.1.0, structured bindings support since 3.5.0.
+    */
+    iteration_proxy<iterator> items() noexcept
+    {
+        return iteration_proxy<iterator>(*this);
+    }
+
+    /*!
+    @copydoc items()
+    */
+    iteration_proxy<const_iterator> items() const noexcept
+    {
+        return iteration_proxy<const_iterator>(*this);
+    }
+
+    /// @}
+
+
+    //////////////
+    // capacity //
+    //////////////
+
+    /// @name capacity
+    /// @{
+
+    /*!
+    @brief checks whether the container is empty.
+
+    Checks if a JSON value has no elements (i.e. whether its @ref size is `0`).
+
+    @return The return value depends on the different types and is
+            defined as follows:
+            Value type  | return value
+            ----------- | -------------
+            null        | `true`
+            boolean     | `false`
+            string      | `false`
+            number      | `false`
+            binary      | `false`
+            object      | result of function `object_t::empty()`
+            array       | result of function `array_t::empty()`
+
+    @liveexample{The following code uses `empty()` to check if a JSON
+    object contains any elements.,empty}
+
+    @complexity Constant, as long as @ref array_t and @ref object_t satisfy
+    the Container concept; that is, their `empty()` functions have constant
+    complexity.
+
+    @iterators No changes.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @note This function does not return whether a string stored as JSON value
+    is empty - it returns whether the JSON container itself is empty which is
+    false in the case of a string.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `begin() == end()`.
+
+    @sa @ref size() -- returns the number of elements
+
+    @since version 1.0.0
+    */
+    bool empty() const noexcept
+    {
+        switch (m_type)
+        {
+            case value_t::null:
+            {
+                // null values are empty
+                return true;
+            }
+
+            case value_t::array:
+            {
+                // delegate call to array_t::empty()
+                return m_value.array->empty();
+            }
+
+            case value_t::object:
+            {
+                // delegate call to object_t::empty()
+                return m_value.object->empty();
+            }
+
+            default:
+            {
+                // all other types are nonempty
+                return false;
+            }
+        }
+    }
+
+    /*!
+    @brief returns the number of elements
+
+    Returns the number of elements in a JSON value.
+
+    @return The return value depends on the different types and is
+            defined as follows:
+            Value type  | return value
+            ----------- | -------------
+            null        | `0`
+            boolean     | `1`
+            string      | `1`
+            number      | `1`
+            binary      | `1`
+            object      | result of function object_t::size()
+            array       | result of function array_t::size()
+
+    @liveexample{The following code calls `size()` on the different value
+    types.,size}
+
+    @complexity Constant, as long as @ref array_t and @ref object_t satisfy
+    the Container concept; that is, their size() functions have constant
+    complexity.
+
+    @iterators No changes.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @note This function does not return the length of a string stored as JSON
+    value - it returns the number of elements in the JSON value which is 1 in
+    the case of a string.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `std::distance(begin(), end())`.
+
+    @sa @ref empty() -- checks whether the container is empty
+    @sa @ref max_size() -- returns the maximal number of elements
+
+    @since version 1.0.0
+    */
+    size_type size() const noexcept
+    {
+        switch (m_type)
+        {
+            case value_t::null:
+            {
+                // null values are empty
+                return 0;
+            }
+
+            case value_t::array:
+            {
+                // delegate call to array_t::size()
+                return m_value.array->size();
+            }
+
+            case value_t::object:
+            {
+                // delegate call to object_t::size()
+                return m_value.object->size();
+            }
+
+            default:
+            {
+                // all other types have size 1
+                return 1;
+            }
+        }
+    }
+
+    /*!
+    @brief returns the maximum possible number of elements
+
+    Returns the maximum number of elements a JSON value is able to hold due to
+    system or library implementation limitations, i.e. `std::distance(begin(),
+    end())` for the JSON value.
+
+    @return The return value depends on the different types and is
+            defined as follows:
+            Value type  | return value
+            ----------- | -------------
+            null        | `0` (same as `size()`)
+            boolean     | `1` (same as `size()`)
+            string      | `1` (same as `size()`)
+            number      | `1` (same as `size()`)
+            binary      | `1` (same as `size()`)
+            object      | result of function `object_t::max_size()`
+            array       | result of function `array_t::max_size()`
+
+    @liveexample{The following code calls `max_size()` on the different value
+    types. Note the output is implementation specific.,max_size}
+
+    @complexity Constant, as long as @ref array_t and @ref object_t satisfy
+    the Container concept; that is, their `max_size()` functions have constant
+    complexity.
+
+    @iterators No changes.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of returning `b.size()` where `b` is the largest
+      possible JSON value.
+
+    @sa @ref size() -- returns the number of elements
+
+    @since version 1.0.0
+    */
+    size_type max_size() const noexcept
+    {
+        switch (m_type)
+        {
+            case value_t::array:
+            {
+                // delegate call to array_t::max_size()
+                return m_value.array->max_size();
+            }
+
+            case value_t::object:
+            {
+                // delegate call to object_t::max_size()
+                return m_value.object->max_size();
+            }
+
+            default:
+            {
+                // all other types have max_size() == size()
+                return size();
+            }
+        }
+    }
+
+    /// @}
+
+
+    ///////////////
+    // modifiers //
+    ///////////////
+
+    /// @name modifiers
+    /// @{
+
+    /*!
+    @brief clears the contents
+
+    Clears the content of a JSON value and resets it to the default value as
+    if @ref basic_json(value_t) would have been called with the current value
+    type from @ref type():
+
+    Value type  | initial value
+    ----------- | -------------
+    null        | `null`
+    boolean     | `false`
+    string      | `""`
+    number      | `0`
+    binary      | An empty byte vector
+    object      | `{}`
+    array       | `[]`
+
+    @post Has the same effect as calling
+    @code {.cpp}
+    *this = basic_json(type());
+    @endcode
+
+    @liveexample{The example below shows the effect of `clear()` to different
+    JSON types.,clear}
+
+    @complexity Linear in the size of the JSON value.
+
+    @iterators All iterators, pointers and references related to this container
+               are invalidated.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @sa @ref basic_json(value_t) -- constructor that creates an object with the
+        same value than calling `clear()`
+
+    @since version 1.0.0
+    */
+    void clear() noexcept
+    {
+        switch (m_type)
+        {
+            case value_t::number_integer:
+            {
+                m_value.number_integer = 0;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_value.number_unsigned = 0;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_value.number_float = 0.0;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_value.boolean = false;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_value.string->clear();
+                break;
+            }
+
+            case value_t::binary:
+            {
+                m_value.binary->clear();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_value.array->clear();
+                break;
+            }
+
+            case value_t::object:
+            {
+                m_value.object->clear();
+                break;
+            }
+
+            default:
+                break;
+        }
+    }
+
+    /*!
+    @brief add an object to an array
+
+    Appends the given element @a val to the end of the JSON value. If the
+    function is called on a JSON null value, an empty array is created before
+    appending @a val.
+
+    @param[in] val the value to add to the JSON array
+
+    @throw type_error.308 when called on a type other than JSON array or
+    null; example: `"cannot use push_back() with number"`
+
+    @complexity Amortized constant.
+
+    @liveexample{The example shows how `push_back()` and `+=` can be used to
+    add elements to a JSON array. Note how the `null` value was silently
+    converted to a JSON array.,push_back}
+
+    @since version 1.0.0
+    */
+    void push_back(basic_json&& val)
+    {
+        // push_back only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
+        {
+            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
+        }
+
+        // transform null object into an array
+        if (is_null())
+        {
+            m_type = value_t::array;
+            m_value = value_t::array;
+            assert_invariant();
+        }
+
+        // add element to array (move semantics)
+        m_value.array->push_back(std::move(val));
+        // if val is moved from, basic_json move constructor marks it null so we do not call the destructor
+    }
+
+    /*!
+    @brief add an object to an array
+    @copydoc push_back(basic_json&&)
+    */
+    reference operator+=(basic_json&& val)
+    {
+        push_back(std::move(val));
+        return *this;
+    }
+
+    /*!
+    @brief add an object to an array
+    @copydoc push_back(basic_json&&)
+    */
+    void push_back(const basic_json& val)
+    {
+        // push_back only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
+        {
+            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
+        }
+
+        // transform null object into an array
+        if (is_null())
+        {
+            m_type = value_t::array;
+            m_value = value_t::array;
+            assert_invariant();
+        }
+
+        // add element to array
+        m_value.array->push_back(val);
+    }
+
+    /*!
+    @brief add an object to an array
+    @copydoc push_back(basic_json&&)
+    */
+    reference operator+=(const basic_json& val)
+    {
+        push_back(val);
+        return *this;
+    }
+
+    /*!
+    @brief add an object to an object
+
+    Inserts the given element @a val to the JSON object. If the function is
+    called on a JSON null value, an empty object is created before inserting
+    @a val.
+
+    @param[in] val the value to add to the JSON object
+
+    @throw type_error.308 when called on a type other than JSON object or
+    null; example: `"cannot use push_back() with number"`
+
+    @complexity Logarithmic in the size of the container, O(log(`size()`)).
+
+    @liveexample{The example shows how `push_back()` and `+=` can be used to
+    add elements to a JSON object. Note how the `null` value was silently
+    converted to a JSON object.,push_back__object_t__value}
+
+    @since version 1.0.0
+    */
+    void push_back(const typename object_t::value_type& val)
+    {
+        // push_back only works for null objects or objects
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
+        {
+            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
+        }
+
+        // transform null object into an object
+        if (is_null())
+        {
+            m_type = value_t::object;
+            m_value = value_t::object;
+            assert_invariant();
+        }
+
+        // add element to array
+        m_value.object->insert(val);
+    }
+
+    /*!
+    @brief add an object to an object
+    @copydoc push_back(const typename object_t::value_type&)
+    */
+    reference operator+=(const typename object_t::value_type& val)
+    {
+        push_back(val);
+        return *this;
+    }
+
+    /*!
+    @brief add an object to an object
+
+    This function allows to use `push_back` with an initializer list. In case
+
+    1. the current value is an object,
+    2. the initializer list @a init contains only two elements, and
+    3. the first element of @a init is a string,
+
+    @a init is converted into an object element and added using
+    @ref push_back(const typename object_t::value_type&). Otherwise, @a init
+    is converted to a JSON value and added using @ref push_back(basic_json&&).
+
+    @param[in] init  an initializer list
+
+    @complexity Linear in the size of the initializer list @a init.
+
+    @note This function is required to resolve an ambiguous overload error,
+          because pairs like `{"key", "value"}` can be both interpreted as
+          `object_t::value_type` or `std::initializer_list<basic_json>`, see
+          https://github.com/nlohmann/json/issues/235 for more information.
+
+    @liveexample{The example shows how initializer lists are treated as
+    objects when possible.,push_back__initializer_list}
+    */
+    void push_back(initializer_list_t init)
+    {
+        if (is_object() && init.size() == 2 && (*init.begin())->is_string())
+        {
+            basic_json&& key = init.begin()->moved_or_copied();
+            push_back(typename object_t::value_type(
+                          std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));
+        }
+        else
+        {
+            push_back(basic_json(init));
+        }
+    }
+
+    /*!
+    @brief add an object to an object
+    @copydoc push_back(initializer_list_t)
+    */
+    reference operator+=(initializer_list_t init)
+    {
+        push_back(init);
+        return *this;
+    }
+
+    /*!
+    @brief add an object to an array
+
+    Creates a JSON value from the passed parameters @a args to the end of the
+    JSON value. If the function is called on a JSON null value, an empty array
+    is created before appending the value created from @a args.
+
+    @param[in] args arguments to forward to a constructor of @ref basic_json
+    @tparam Args compatible types to create a @ref basic_json object
+
+    @return reference to the inserted element
+
+    @throw type_error.311 when called on a type other than JSON array or
+    null; example: `"cannot use emplace_back() with number"`
+
+    @complexity Amortized constant.
+
+    @liveexample{The example shows how `push_back()` can be used to add
+    elements to a JSON array. Note how the `null` value was silently converted
+    to a JSON array.,emplace_back}
+
+    @since version 2.0.8, returns reference since 3.7.0
+    */
+    template<class... Args>
+    reference emplace_back(Args&& ... args)
+    {
+        // emplace_back only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
+        {
+            JSON_THROW(type_error::create(311, "cannot use emplace_back() with " + std::string(type_name())));
+        }
+
+        // transform null object into an array
+        if (is_null())
+        {
+            m_type = value_t::array;
+            m_value = value_t::array;
+            assert_invariant();
+        }
+
+        // add element to array (perfect forwarding)
+#ifdef JSON_HAS_CPP_17
+        return m_value.array->emplace_back(std::forward<Args>(args)...);
+#else
+        m_value.array->emplace_back(std::forward<Args>(args)...);
+        return m_value.array->back();
+#endif
+    }
+
+    /*!
+    @brief add an object to an object if key does not exist
+
+    Inserts a new element into a JSON object constructed in-place with the
+    given @a args if there is no element with the key in the container. If the
+    function is called on a JSON null value, an empty object is created before
+    appending the value created from @a args.
+
+    @param[in] args arguments to forward to a constructor of @ref basic_json
+    @tparam Args compatible types to create a @ref basic_json object
+
+    @return a pair consisting of an iterator to the inserted element, or the
+            already-existing element if no insertion happened, and a bool
+            denoting whether the insertion took place.
+
+    @throw type_error.311 when called on a type other than JSON object or
+    null; example: `"cannot use emplace() with number"`
+
+    @complexity Logarithmic in the size of the container, O(log(`size()`)).
+
+    @liveexample{The example shows how `emplace()` can be used to add elements
+    to a JSON object. Note how the `null` value was silently converted to a
+    JSON object. Further note how no value is added if there was already one
+    value stored with the same key.,emplace}
+
+    @since version 2.0.8
+    */
+    template<class... Args>
+    std::pair<iterator, bool> emplace(Args&& ... args)
+    {
+        // emplace only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
+        {
+            JSON_THROW(type_error::create(311, "cannot use emplace() with " + std::string(type_name())));
+        }
+
+        // transform null object into an object
+        if (is_null())
+        {
+            m_type = value_t::object;
+            m_value = value_t::object;
+            assert_invariant();
+        }
+
+        // add element to array (perfect forwarding)
+        auto res = m_value.object->emplace(std::forward<Args>(args)...);
+        // create result iterator and set iterator to the result of emplace
+        auto it = begin();
+        it.m_it.object_iterator = res.first;
+
+        // return pair of iterator and boolean
+        return {it, res.second};
+    }
+
+    /// Helper for insertion of an iterator
+    /// @note: This uses std::distance to support GCC 4.8,
+    ///        see https://github.com/nlohmann/json/pull/1257
+    template<typename... Args>
+    iterator insert_iterator(const_iterator pos, Args&& ... args)
+    {
+        iterator result(this);
+        JSON_ASSERT(m_value.array != nullptr);
+
+        auto insert_pos = std::distance(m_value.array->begin(), pos.m_it.array_iterator);
+        m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
+        result.m_it.array_iterator = m_value.array->begin() + insert_pos;
+
+        // This could have been written as:
+        // result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, cnt, val);
+        // but the return value of insert is missing in GCC 4.8, so it is written this way instead.
+
+        return result;
+    }
+
+    /*!
+    @brief inserts element
+
+    Inserts element @a val before iterator @a pos.
+
+    @param[in] pos iterator before which the content will be inserted; may be
+    the end() iterator
+    @param[in] val element to insert
+    @return iterator pointing to the inserted @a val.
+
+    @throw type_error.309 if called on JSON values other than arrays;
+    example: `"cannot use insert() with string"`
+    @throw invalid_iterator.202 if @a pos is not an iterator of *this;
+    example: `"iterator does not fit current value"`
+
+    @complexity Constant plus linear in the distance between @a pos and end of
+    the container.
+
+    @liveexample{The example shows how `insert()` is used.,insert}
+
+    @since version 1.0.0
+    */
+    iterator insert(const_iterator pos, const basic_json& val)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            // check if iterator pos fits to this JSON value
+            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+            {
+                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
+            }
+
+            // insert to array and return iterator
+            return insert_iterator(pos, val);
+        }
+
+        JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief inserts element
+    @copydoc insert(const_iterator, const basic_json&)
+    */
+    iterator insert(const_iterator pos, basic_json&& val)
+    {
+        return insert(pos, val);
+    }
+
+    /*!
+    @brief inserts elements
+
+    Inserts @a cnt copies of @a val before iterator @a pos.
+
+    @param[in] pos iterator before which the content will be inserted; may be
+    the end() iterator
+    @param[in] cnt number of copies of @a val to insert
+    @param[in] val element to insert
+    @return iterator pointing to the first element inserted, or @a pos if
+    `cnt==0`
+
+    @throw type_error.309 if called on JSON values other than arrays; example:
+    `"cannot use insert() with string"`
+    @throw invalid_iterator.202 if @a pos is not an iterator of *this;
+    example: `"iterator does not fit current value"`
+
+    @complexity Linear in @a cnt plus linear in the distance between @a pos
+    and end of the container.
+
+    @liveexample{The example shows how `insert()` is used.,insert__count}
+
+    @since version 1.0.0
+    */
+    iterator insert(const_iterator pos, size_type cnt, const basic_json& val)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            // check if iterator pos fits to this JSON value
+            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+            {
+                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
+            }
+
+            // insert to array and return iterator
+            return insert_iterator(pos, cnt, val);
+        }
+
+        JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief inserts elements
+
+    Inserts elements from range `[first, last)` before iterator @a pos.
+
+    @param[in] pos iterator before which the content will be inserted; may be
+    the end() iterator
+    @param[in] first begin of the range of elements to insert
+    @param[in] last end of the range of elements to insert
+
+    @throw type_error.309 if called on JSON values other than arrays; example:
+    `"cannot use insert() with string"`
+    @throw invalid_iterator.202 if @a pos is not an iterator of *this;
+    example: `"iterator does not fit current value"`
+    @throw invalid_iterator.210 if @a first and @a last do not belong to the
+    same JSON value; example: `"iterators do not fit"`
+    @throw invalid_iterator.211 if @a first or @a last are iterators into
+    container for which insert is called; example: `"passed iterators may not
+    belong to container"`
+
+    @return iterator pointing to the first element inserted, or @a pos if
+    `first==last`
+
+    @complexity Linear in `std::distance(first, last)` plus linear in the
+    distance between @a pos and end of the container.
+
+    @liveexample{The example shows how `insert()` is used.,insert__range}
+
+    @since version 1.0.0
+    */
+    iterator insert(const_iterator pos, const_iterator first, const_iterator last)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_UNLIKELY(!is_array()))
+        {
+            JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
+        }
+
+        // check if iterator pos fits to this JSON value
+        if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
+        }
+
+        // check if range iterators belong to the same JSON object
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(first.m_object == this))
+        {
+            JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container"));
+        }
+
+        // insert to array and return iterator
+        return insert_iterator(pos, first.m_it.array_iterator, last.m_it.array_iterator);
+    }
+
+    /*!
+    @brief inserts elements
+
+    Inserts elements from initializer list @a ilist before iterator @a pos.
+
+    @param[in] pos iterator before which the content will be inserted; may be
+    the end() iterator
+    @param[in] ilist initializer list to insert the values from
+
+    @throw type_error.309 if called on JSON values other than arrays; example:
+    `"cannot use insert() with string"`
+    @throw invalid_iterator.202 if @a pos is not an iterator of *this;
+    example: `"iterator does not fit current value"`
+
+    @return iterator pointing to the first element inserted, or @a pos if
+    `ilist` is empty
+
+    @complexity Linear in `ilist.size()` plus linear in the distance between
+    @a pos and end of the container.
+
+    @liveexample{The example shows how `insert()` is used.,insert__ilist}
+
+    @since version 1.0.0
+    */
+    iterator insert(const_iterator pos, initializer_list_t ilist)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_UNLIKELY(!is_array()))
+        {
+            JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
+        }
+
+        // check if iterator pos fits to this JSON value
+        if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
+        }
+
+        // insert to array and return iterator
+        return insert_iterator(pos, ilist.begin(), ilist.end());
+    }
+
+    /*!
+    @brief inserts elements
+
+    Inserts elements from range `[first, last)`.
+
+    @param[in] first begin of the range of elements to insert
+    @param[in] last end of the range of elements to insert
+
+    @throw type_error.309 if called on JSON values other than objects; example:
+    `"cannot use insert() with string"`
+    @throw invalid_iterator.202 if iterator @a first or @a last does does not
+    point to an object; example: `"iterators first and last must point to
+    objects"`
+    @throw invalid_iterator.210 if @a first and @a last do not belong to the
+    same JSON value; example: `"iterators do not fit"`
+
+    @complexity Logarithmic: `O(N*log(size() + N))`, where `N` is the number
+    of elements to insert.
+
+    @liveexample{The example shows how `insert()` is used.,insert__range_object}
+
+    @since version 3.0.0
+    */
+    void insert(const_iterator first, const_iterator last)
+    {
+        // insert only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
+        }
+
+        // check if range iterators belong to the same JSON object
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
+        }
+
+        // passed iterators must belong to objects
+        if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));
+        }
+
+        m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
+    }
+
+    /*!
+    @brief updates a JSON object from another object, overwriting existing keys
+
+    Inserts all values from JSON object @a j and overwrites existing keys.
+
+    @param[in] j  JSON object to read values from
+
+    @throw type_error.312 if called on JSON values other than objects; example:
+    `"cannot use update() with string"`
+
+    @complexity O(N*log(size() + N)), where N is the number of elements to
+                insert.
+
+    @liveexample{The example shows how `update()` is used.,update}
+
+    @sa https://docs.python.org/3.6/library/stdtypes.html#dict.update
+
+    @since version 3.0.0
+    */
+    void update(const_reference j)
+    {
+        // implicitly convert null value to an empty object
+        if (is_null())
+        {
+            m_type = value_t::object;
+            m_value.object = create<object_t>();
+            assert_invariant();
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name())));
+        }
+        if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
+        {
+            JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(j.type_name())));
+        }
+
+        for (auto it = j.cbegin(); it != j.cend(); ++it)
+        {
+            m_value.object->operator[](it.key()) = it.value();
+        }
+    }
+
+    /*!
+    @brief updates a JSON object from another object, overwriting existing keys
+
+    Inserts all values from from range `[first, last)` and overwrites existing
+    keys.
+
+    @param[in] first begin of the range of elements to insert
+    @param[in] last end of the range of elements to insert
+
+    @throw type_error.312 if called on JSON values other than objects; example:
+    `"cannot use update() with string"`
+    @throw invalid_iterator.202 if iterator @a first or @a last does does not
+    point to an object; example: `"iterators first and last must point to
+    objects"`
+    @throw invalid_iterator.210 if @a first and @a last do not belong to the
+    same JSON value; example: `"iterators do not fit"`
+
+    @complexity O(N*log(size() + N)), where N is the number of elements to
+                insert.
+
+    @liveexample{The example shows how `update()` is used__range.,update}
+
+    @sa https://docs.python.org/3.6/library/stdtypes.html#dict.update
+
+    @since version 3.0.0
+    */
+    void update(const_iterator first, const_iterator last)
+    {
+        // implicitly convert null value to an empty object
+        if (is_null())
+        {
+            m_type = value_t::object;
+            m_value.object = create<object_t>();
+            assert_invariant();
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name())));
+        }
+
+        // check if range iterators belong to the same JSON object
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
+        }
+
+        // passed iterators must belong to objects
+        if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()
+                                 || !last.m_object->is_object()))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));
+        }
+
+        for (auto it = first; it != last; ++it)
+        {
+            m_value.object->operator[](it.key()) = it.value();
+        }
+    }
+
+    /*!
+    @brief exchanges the values
+
+    Exchanges the contents of the JSON value with those of @a other. Does not
+    invoke any move, copy, or swap operations on individual elements. All
+    iterators and references remain valid. The past-the-end iterator is
+    invalidated.
+
+    @param[in,out] other JSON value to exchange the contents with
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how JSON values can be swapped with
+    `swap()`.,swap__reference}
+
+    @since version 1.0.0
+    */
+    void swap(reference other) noexcept (
+        std::is_nothrow_move_constructible<value_t>::value&&
+        std::is_nothrow_move_assignable<value_t>::value&&
+        std::is_nothrow_move_constructible<json_value>::value&&
+        std::is_nothrow_move_assignable<json_value>::value
+    )
+    {
+        std::swap(m_type, other.m_type);
+        std::swap(m_value, other.m_value);
+        assert_invariant();
+    }
+
+    /*!
+    @brief exchanges the values
+
+    Exchanges the contents of the JSON value from @a left with those of @a right. Does not
+    invoke any move, copy, or swap operations on individual elements. All
+    iterators and references remain valid. The past-the-end iterator is
+    invalidated. implemented as a friend function callable via ADL.
+
+    @param[in,out] left JSON value to exchange the contents with
+    @param[in,out] right JSON value to exchange the contents with
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how JSON values can be swapped with
+    `swap()`.,swap__reference}
+
+    @since version 1.0.0
+    */
+    friend void swap(reference left, reference right) noexcept (
+        std::is_nothrow_move_constructible<value_t>::value&&
+        std::is_nothrow_move_assignable<value_t>::value&&
+        std::is_nothrow_move_constructible<json_value>::value&&
+        std::is_nothrow_move_assignable<json_value>::value
+    )
+    {
+        left.swap(right);
+    }
+
+    /*!
+    @brief exchanges the values
+
+    Exchanges the contents of a JSON array with those of @a other. Does not
+    invoke any move, copy, or swap operations on individual elements. All
+    iterators and references remain valid. The past-the-end iterator is
+    invalidated.
+
+    @param[in,out] other array to exchange the contents with
+
+    @throw type_error.310 when JSON value is not an array; example: `"cannot
+    use swap() with string"`
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how arrays can be swapped with
+    `swap()`.,swap__array_t}
+
+    @since version 1.0.0
+    */
+    void swap(array_t& other)
+    {
+        // swap only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            std::swap(*(m_value.array), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
+        }
+    }
+
+    /*!
+    @brief exchanges the values
+
+    Exchanges the contents of a JSON object with those of @a other. Does not
+    invoke any move, copy, or swap operations on individual elements. All
+    iterators and references remain valid. The past-the-end iterator is
+    invalidated.
+
+    @param[in,out] other object to exchange the contents with
+
+    @throw type_error.310 when JSON value is not an object; example:
+    `"cannot use swap() with string"`
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how objects can be swapped with
+    `swap()`.,swap__object_t}
+
+    @since version 1.0.0
+    */
+    void swap(object_t& other)
+    {
+        // swap only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            std::swap(*(m_value.object), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
+        }
+    }
+
+    /*!
+    @brief exchanges the values
+
+    Exchanges the contents of a JSON string with those of @a other. Does not
+    invoke any move, copy, or swap operations on individual elements. All
+    iterators and references remain valid. The past-the-end iterator is
+    invalidated.
+
+    @param[in,out] other string to exchange the contents with
+
+    @throw type_error.310 when JSON value is not a string; example: `"cannot
+    use swap() with boolean"`
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how strings can be swapped with
+    `swap()`.,swap__string_t}
+
+    @since version 1.0.0
+    */
+    void swap(string_t& other)
+    {
+        // swap only works for strings
+        if (JSON_HEDLEY_LIKELY(is_string()))
+        {
+            std::swap(*(m_value.string), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
+        }
+    }
+
+    /*!
+    @brief exchanges the values
+
+    Exchanges the contents of a JSON string with those of @a other. Does not
+    invoke any move, copy, or swap operations on individual elements. All
+    iterators and references remain valid. The past-the-end iterator is
+    invalidated.
+
+    @param[in,out] other binary to exchange the contents with
+
+    @throw type_error.310 when JSON value is not a string; example: `"cannot
+    use swap() with boolean"`
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how strings can be swapped with
+    `swap()`.,swap__binary_t}
+
+    @since version 3.8.0
+    */
+    void swap(binary_t& other)
+    {
+        // swap only works for strings
+        if (JSON_HEDLEY_LIKELY(is_binary()))
+        {
+            std::swap(*(m_value.binary), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
+        }
+    }
+
+    /// @copydoc swap(binary_t)
+    void swap(typename binary_t::container_type& other)
+    {
+        // swap only works for strings
+        if (JSON_HEDLEY_LIKELY(is_binary()))
+        {
+            std::swap(*(m_value.binary), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
+        }
+    }
+
+    /// @}
+
+  public:
+    //////////////////////////////////////////
+    // lexicographical comparison operators //
+    //////////////////////////////////////////
+
+    /// @name lexicographical comparison operators
+    /// @{
+
+    /*!
+    @brief comparison: equal
+
+    Compares two JSON values for equality according to the following rules:
+    - Two JSON values are equal if (1) they are from the same type and (2)
+      their stored values are the same according to their respective
+      `operator==`.
+    - Integer and floating-point numbers are automatically converted before
+      comparison. Note that two NaN values are always treated as unequal.
+    - Two JSON null values are equal.
+
+    @note Floating-point inside JSON values numbers are compared with
+    `json::number_float_t::operator==` which is `double::operator==` by
+    default. To compare floating-point while respecting an epsilon, an alternative
+    [comparison function](https://github.com/mariokonrad/marnav/blob/master/include/marnav/math/floatingpoint.hpp#L34-#L39)
+    could be used, for instance
+    @code {.cpp}
+    template<typename T, typename = typename std::enable_if<std::is_floating_point<T>::value, T>::type>
+    inline bool is_same(T a, T b, T epsilon = std::numeric_limits<T>::epsilon()) noexcept
+    {
+        return std::abs(a - b) <= epsilon;
+    }
+    @endcode
+    Or you can self-defined operator equal function like this:
+    @code {.cpp}
+    bool my_equal(const_reference lhs, const_reference rhs) {
+    const auto lhs_type lhs.type();
+    const auto rhs_type rhs.type();
+    if (lhs_type == rhs_type) {
+        switch(lhs_type)
+            // self_defined case
+            case value_t::number_float:
+                return std::abs(lhs - rhs) <= std::numeric_limits<float>::epsilon();
+            // other cases remain the same with the original
+            ...
+    }
+    ...
+    }
+    @endcode
+
+    @note NaN values never compare equal to themselves or to other NaN values.
+
+    @param[in] lhs  first JSON value to consider
+    @param[in] rhs  second JSON value to consider
+    @return whether the values @a lhs and @a rhs are equal
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @complexity Linear.
+
+    @liveexample{The example demonstrates comparing several JSON
+    types.,operator__equal}
+
+    @since version 1.0.0
+    */
+    friend bool operator==(const_reference lhs, const_reference rhs) noexcept
+    {
+        const auto lhs_type = lhs.type();
+        const auto rhs_type = rhs.type();
+
+        if (lhs_type == rhs_type)
+        {
+            switch (lhs_type)
+            {
+                case value_t::array:
+                    return *lhs.m_value.array == *rhs.m_value.array;
+
+                case value_t::object:
+                    return *lhs.m_value.object == *rhs.m_value.object;
+
+                case value_t::null:
+                    return true;
+
+                case value_t::string:
+                    return *lhs.m_value.string == *rhs.m_value.string;
+
+                case value_t::boolean:
+                    return lhs.m_value.boolean == rhs.m_value.boolean;
+
+                case value_t::number_integer:
+                    return lhs.m_value.number_integer == rhs.m_value.number_integer;
+
+                case value_t::number_unsigned:
+                    return lhs.m_value.number_unsigned == rhs.m_value.number_unsigned;
+
+                case value_t::number_float:
+                    return lhs.m_value.number_float == rhs.m_value.number_float;
+
+                case value_t::binary:
+                    return *lhs.m_value.binary == *rhs.m_value.binary;
+
+                default:
+                    return false;
+            }
+        }
+        else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
+        {
+            return static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float;
+        }
+        else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
+        {
+            return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_integer);
+        }
+        else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
+        {
+            return static_cast<number_float_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_float;
+        }
+        else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
+        {
+            return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_unsigned);
+        }
+        else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
+        {
+            return static_cast<number_integer_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_integer;
+        }
+        else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
+        {
+            return lhs.m_value.number_integer == static_cast<number_integer_t>(rhs.m_value.number_unsigned);
+        }
+
+        return false;
+    }
+
+    /*!
+    @brief comparison: equal
+    @copydoc operator==(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator==(const_reference lhs, const ScalarType rhs) noexcept
+    {
+        return lhs == basic_json(rhs);
+    }
+
+    /*!
+    @brief comparison: equal
+    @copydoc operator==(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator==(const ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) == rhs;
+    }
+
+    /*!
+    @brief comparison: not equal
+
+    Compares two JSON values for inequality by calculating `not (lhs == rhs)`.
+
+    @param[in] lhs  first JSON value to consider
+    @param[in] rhs  second JSON value to consider
+    @return whether the values @a lhs and @a rhs are not equal
+
+    @complexity Linear.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @liveexample{The example demonstrates comparing several JSON
+    types.,operator__notequal}
+
+    @since version 1.0.0
+    */
+    friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
+    {
+        return !(lhs == rhs);
+    }
+
+    /*!
+    @brief comparison: not equal
+    @copydoc operator!=(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator!=(const_reference lhs, const ScalarType rhs) noexcept
+    {
+        return lhs != basic_json(rhs);
+    }
+
+    /*!
+    @brief comparison: not equal
+    @copydoc operator!=(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator!=(const ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) != rhs;
+    }
+
+    /*!
+    @brief comparison: less than
+
+    Compares whether one JSON value @a lhs is less than another JSON value @a
+    rhs according to the following rules:
+    - If @a lhs and @a rhs have the same type, the values are compared using
+      the default `<` operator.
+    - Integer and floating-point numbers are automatically converted before
+      comparison
+    - In case @a lhs and @a rhs have different types, the values are ignored
+      and the order of the types is considered, see
+      @ref operator<(const value_t, const value_t).
+
+    @param[in] lhs  first JSON value to consider
+    @param[in] rhs  second JSON value to consider
+    @return whether @a lhs is less than @a rhs
+
+    @complexity Linear.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @liveexample{The example demonstrates comparing several JSON
+    types.,operator__less}
+
+    @since version 1.0.0
+    */
+    friend bool operator<(const_reference lhs, const_reference rhs) noexcept
+    {
+        const auto lhs_type = lhs.type();
+        const auto rhs_type = rhs.type();
+
+        if (lhs_type == rhs_type)
+        {
+            switch (lhs_type)
+            {
+                case value_t::array:
+                    // note parentheses are necessary, see
+                    // https://github.com/nlohmann/json/issues/1530
+                    return (*lhs.m_value.array) < (*rhs.m_value.array);
+
+                case value_t::object:
+                    return (*lhs.m_value.object) < (*rhs.m_value.object);
+
+                case value_t::null:
+                    return false;
+
+                case value_t::string:
+                    return (*lhs.m_value.string) < (*rhs.m_value.string);
+
+                case value_t::boolean:
+                    return (lhs.m_value.boolean) < (rhs.m_value.boolean);
+
+                case value_t::number_integer:
+                    return (lhs.m_value.number_integer) < (rhs.m_value.number_integer);
+
+                case value_t::number_unsigned:
+                    return (lhs.m_value.number_unsigned) < (rhs.m_value.number_unsigned);
+
+                case value_t::number_float:
+                    return (lhs.m_value.number_float) < (rhs.m_value.number_float);
+
+                case value_t::binary:
+                    return (*lhs.m_value.binary) < (*rhs.m_value.binary);
+
+                default:
+                    return false;
+            }
+        }
+        else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
+        {
+            return static_cast<number_float_t>(lhs.m_value.number_integer) < rhs.m_value.number_float;
+        }
+        else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
+        {
+            return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_integer);
+        }
+        else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
+        {
+            return static_cast<number_float_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_float;
+        }
+        else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
+        {
+            return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_unsigned);
+        }
+        else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
+        {
+            return lhs.m_value.number_integer < static_cast<number_integer_t>(rhs.m_value.number_unsigned);
+        }
+        else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
+        {
+            return static_cast<number_integer_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_integer;
+        }
+
+        // We only reach this line if we cannot compare values. In that case,
+        // we compare types. Note we have to call the operator explicitly,
+        // because MSVC has problems otherwise.
+        return operator<(lhs_type, rhs_type);
+    }
+
+    /*!
+    @brief comparison: less than
+    @copydoc operator<(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<(const_reference lhs, const ScalarType rhs) noexcept
+    {
+        return lhs < basic_json(rhs);
+    }
+
+    /*!
+    @brief comparison: less than
+    @copydoc operator<(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<(const ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) < rhs;
+    }
+
+    /*!
+    @brief comparison: less than or equal
+
+    Compares whether one JSON value @a lhs is less than or equal to another
+    JSON value by calculating `not (rhs < lhs)`.
+
+    @param[in] lhs  first JSON value to consider
+    @param[in] rhs  second JSON value to consider
+    @return whether @a lhs is less than or equal to @a rhs
+
+    @complexity Linear.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @liveexample{The example demonstrates comparing several JSON
+    types.,operator__greater}
+
+    @since version 1.0.0
+    */
+    friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
+    {
+        return !(rhs < lhs);
+    }
+
+    /*!
+    @brief comparison: less than or equal
+    @copydoc operator<=(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<=(const_reference lhs, const ScalarType rhs) noexcept
+    {
+        return lhs <= basic_json(rhs);
+    }
+
+    /*!
+    @brief comparison: less than or equal
+    @copydoc operator<=(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<=(const ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) <= rhs;
+    }
+
+    /*!
+    @brief comparison: greater than
+
+    Compares whether one JSON value @a lhs is greater than another
+    JSON value by calculating `not (lhs <= rhs)`.
+
+    @param[in] lhs  first JSON value to consider
+    @param[in] rhs  second JSON value to consider
+    @return whether @a lhs is greater than to @a rhs
+
+    @complexity Linear.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @liveexample{The example demonstrates comparing several JSON
+    types.,operator__lessequal}
+
+    @since version 1.0.0
+    */
+    friend bool operator>(const_reference lhs, const_reference rhs) noexcept
+    {
+        return !(lhs <= rhs);
+    }
+
+    /*!
+    @brief comparison: greater than
+    @copydoc operator>(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>(const_reference lhs, const ScalarType rhs) noexcept
+    {
+        return lhs > basic_json(rhs);
+    }
+
+    /*!
+    @brief comparison: greater than
+    @copydoc operator>(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>(const ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) > rhs;
+    }
+
+    /*!
+    @brief comparison: greater than or equal
+
+    Compares whether one JSON value @a lhs is greater than or equal to another
+    JSON value by calculating `not (lhs < rhs)`.
+
+    @param[in] lhs  first JSON value to consider
+    @param[in] rhs  second JSON value to consider
+    @return whether @a lhs is greater than or equal to @a rhs
+
+    @complexity Linear.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @liveexample{The example demonstrates comparing several JSON
+    types.,operator__greaterequal}
+
+    @since version 1.0.0
+    */
+    friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
+    {
+        return !(lhs < rhs);
+    }
+
+    /*!
+    @brief comparison: greater than or equal
+    @copydoc operator>=(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>=(const_reference lhs, const ScalarType rhs) noexcept
+    {
+        return lhs >= basic_json(rhs);
+    }
+
+    /*!
+    @brief comparison: greater than or equal
+    @copydoc operator>=(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>=(const ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) >= rhs;
+    }
+
+    /// @}
+
+    ///////////////////
+    // serialization //
+    ///////////////////
+
+    /// @name serialization
+    /// @{
+
+    /*!
+    @brief serialize to stream
+
+    Serialize the given JSON value @a j to the output stream @a o. The JSON
+    value will be serialized using the @ref dump member function.
+
+    - The indentation of the output can be controlled with the member variable
+      `width` of the output stream @a o. For instance, using the manipulator
+      `std::setw(4)` on @a o sets the indentation level to `4` and the
+      serialization result is the same as calling `dump(4)`.
+
+    - The indentation character can be controlled with the member variable
+      `fill` of the output stream @a o. For instance, the manipulator
+      `std::setfill('\\t')` sets indentation to use a tab character rather than
+      the default space character.
+
+    @param[in,out] o  stream to serialize to
+    @param[in] j  JSON value to serialize
+
+    @return the stream @a o
+
+    @throw type_error.316 if a string stored inside the JSON value is not
+                          UTF-8 encoded
+
+    @complexity Linear.
+
+    @liveexample{The example below shows the serialization with different
+    parameters to `width` to adjust the indentation level.,operator_serialize}
+
+    @since version 1.0.0; indentation character added in version 3.0.0
+    */
+    friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
+    {
+        // read width member and use it as indentation parameter if nonzero
+        const bool pretty_print = o.width() > 0;
+        const auto indentation = pretty_print ? o.width() : 0;
+
+        // reset width to 0 for subsequent calls to this stream
+        o.width(0);
+
+        // do the actual serialization
+        serializer s(detail::output_adapter<char>(o), o.fill());
+        s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));
+        return o;
+    }
+
+    /*!
+    @brief serialize to stream
+    @deprecated This stream operator is deprecated and will be removed in
+                future 4.0.0 of the library. Please use
+                @ref operator<<(std::ostream&, const basic_json&)
+                instead; that is, replace calls like `j >> o;` with `o << j;`.
+    @since version 1.0.0; deprecated since version 3.0.0
+    */
+    JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator<<(std::ostream&, const basic_json&))
+    friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
+    {
+        return o << j;
+    }
+
+    /// @}
+
+
+    /////////////////////
+    // deserialization //
+    /////////////////////
+
+    /// @name deserialization
+    /// @{
+
+    /*!
+    @brief deserialize from a compatible input
+
+    @tparam InputType A compatible input, for instance
+    - an std::istream object
+    - a FILE pointer
+    - a C-style array of characters
+    - a pointer to a null-terminated string of single byte characters
+    - an object obj for which begin(obj) and end(obj) produces a valid pair of
+      iterators.
+
+    @param[in] i  input to read from
+    @param[in] cb  a parser callback function of type @ref parser_callback_t
+    which is used to control the deserialization by filtering unwanted values
+    (optional)
+    @param[in] allow_exceptions  whether to throw exceptions in case of a
+    parse error (optional, true by default)
+    @param[in] ignore_comments  whether comments should be ignored and treated
+    like whitespace (true) or yield a parse error (true); (optional, false by
+    default)
+
+    @return deserialized JSON value; in case of a parse error and
+            @a allow_exceptions set to `false`, the return value will be
+            value_t::discarded.
+
+    @throw parse_error.101 if a parse error occurs; example: `""unexpected end
+    of input; expected string literal""`
+    @throw parse_error.102 if to_unicode fails or surrogate error
+    @throw parse_error.103 if to_unicode fails
+
+    @complexity Linear in the length of the input. The parser is a predictive
+    LL(1) parser. The complexity can be higher if the parser callback function
+    @a cb or reading from the input @a i has a super-linear complexity.
+
+    @note A UTF-8 byte order mark is silently ignored.
+
+    @liveexample{The example below demonstrates the `parse()` function reading
+    from an array.,parse__array__parser_callback_t}
+
+    @liveexample{The example below demonstrates the `parse()` function with
+    and without callback function.,parse__string__parser_callback_t}
+
+    @liveexample{The example below demonstrates the `parse()` function with
+    and without callback function.,parse__istream__parser_callback_t}
+
+    @liveexample{The example below demonstrates the `parse()` function reading
+    from a contiguous container.,parse__contiguouscontainer__parser_callback_t}
+
+    @since version 2.0.3 (contiguous containers); version 3.9.0 allowed to
+    ignore comments.
+    */
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json parse(InputType&& i,
+                            const parser_callback_t cb = nullptr,
+                            const bool allow_exceptions = true,
+                            const bool ignore_comments = false)
+    {
+        basic_json result;
+        parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(true, result);
+        return result;
+    }
+
+    /*!
+    @brief deserialize from a pair of character iterators
+
+    The value_type of the iterator must be a integral type with size of 1, 2 or
+    4 bytes, which will be interpreted respectively as UTF-8, UTF-16 and UTF-32.
+
+    @param[in] first iterator to start of character range
+    @param[in] last  iterator to end of character range
+    @param[in] cb  a parser callback function of type @ref parser_callback_t
+    which is used to control the deserialization by filtering unwanted values
+    (optional)
+    @param[in] allow_exceptions  whether to throw exceptions in case of a
+    parse error (optional, true by default)
+    @param[in] ignore_comments  whether comments should be ignored and treated
+    like whitespace (true) or yield a parse error (true); (optional, false by
+    default)
+
+    @return deserialized JSON value; in case of a parse error and
+            @a allow_exceptions set to `false`, the return value will be
+            value_t::discarded.
+
+    @throw parse_error.101 if a parse error occurs; example: `""unexpected end
+    of input; expected string literal""`
+    @throw parse_error.102 if to_unicode fails or surrogate error
+    @throw parse_error.103 if to_unicode fails
+    */
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json parse(IteratorType first,
+                            IteratorType last,
+                            const parser_callback_t cb = nullptr,
+                            const bool allow_exceptions = true,
+                            const bool ignore_comments = false)
+    {
+        basic_json result;
+        parser(detail::input_adapter(std::move(first), std::move(last)), cb, allow_exceptions, ignore_comments).parse(true, result);
+        return result;
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, parse(ptr, ptr + len))
+    static basic_json parse(detail::span_input_adapter&& i,
+                            const parser_callback_t cb = nullptr,
+                            const bool allow_exceptions = true,
+                            const bool ignore_comments = false)
+    {
+        basic_json result;
+        parser(i.get(), cb, allow_exceptions, ignore_comments).parse(true, result);
+        return result;
+    }
+
+    /*!
+    @brief check if the input is valid JSON
+
+    Unlike the @ref parse(InputType&&, const parser_callback_t,const bool)
+    function, this function neither throws an exception in case of invalid JSON
+    input (i.e., a parse error) nor creates diagnostic information.
+
+    @tparam InputType A compatible input, for instance
+    - an std::istream object
+    - a FILE pointer
+    - a C-style array of characters
+    - a pointer to a null-terminated string of single byte characters
+    - an object obj for which begin(obj) and end(obj) produces a valid pair of
+      iterators.
+
+    @param[in] i input to read from
+    @param[in] ignore_comments  whether comments should be ignored and treated
+    like whitespace (true) or yield a parse error (true); (optional, false by
+    default)
+
+    @return Whether the input read from @a i is valid JSON.
+
+    @complexity Linear in the length of the input. The parser is a predictive
+    LL(1) parser.
+
+    @note A UTF-8 byte order mark is silently ignored.
+
+    @liveexample{The example below demonstrates the `accept()` function reading
+    from a string.,accept__string}
+    */
+    template<typename InputType>
+    static bool accept(InputType&& i,
+                       const bool ignore_comments = false)
+    {
+        return parser(detail::input_adapter(std::forward<InputType>(i)), nullptr, false, ignore_comments).accept(true);
+    }
+
+    template<typename IteratorType>
+    static bool accept(IteratorType first, IteratorType last,
+                       const bool ignore_comments = false)
+    {
+        return parser(detail::input_adapter(std::move(first), std::move(last)), nullptr, false, ignore_comments).accept(true);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, accept(ptr, ptr + len))
+    static bool accept(detail::span_input_adapter&& i,
+                       const bool ignore_comments = false)
+    {
+        return parser(i.get(), nullptr, false, ignore_comments).accept(true);
+    }
+
+    /*!
+    @brief generate SAX events
+
+    The SAX event lister must follow the interface of @ref json_sax.
+
+    This function reads from a compatible input. Examples are:
+    - an std::istream object
+    - a FILE pointer
+    - a C-style array of characters
+    - a pointer to a null-terminated string of single byte characters
+    - an object obj for which begin(obj) and end(obj) produces a valid pair of
+      iterators.
+
+    @param[in] i  input to read from
+    @param[in,out] sax  SAX event listener
+    @param[in] format  the format to parse (JSON, CBOR, MessagePack, or UBJSON)
+    @param[in] strict  whether the input has to be consumed completely
+    @param[in] ignore_comments  whether comments should be ignored and treated
+    like whitespace (true) or yield a parse error (true); (optional, false by
+    default); only applies to the JSON file format.
+
+    @return return value of the last processed SAX event
+
+    @throw parse_error.101 if a parse error occurs; example: `""unexpected end
+    of input; expected string literal""`
+    @throw parse_error.102 if to_unicode fails or surrogate error
+    @throw parse_error.103 if to_unicode fails
+
+    @complexity Linear in the length of the input. The parser is a predictive
+    LL(1) parser. The complexity can be higher if the SAX consumer @a sax has
+    a super-linear complexity.
+
+    @note A UTF-8 byte order mark is silently ignored.
+
+    @liveexample{The example below demonstrates the `sax_parse()` function
+    reading from string and processing the events with a user-defined SAX
+    event consumer.,sax_parse}
+
+    @since version 3.2.0
+    */
+    template <typename InputType, typename SAX>
+    JSON_HEDLEY_NON_NULL(2)
+    static bool sax_parse(InputType&& i, SAX* sax,
+                          input_format_t format = input_format_t::json,
+                          const bool strict = true,
+                          const bool ignore_comments = false)
+    {
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        return format == input_format_t::json
+               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
+               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
+    }
+
+    template<class IteratorType, class SAX>
+    JSON_HEDLEY_NON_NULL(3)
+    static bool sax_parse(IteratorType first, IteratorType last, SAX* sax,
+                          input_format_t format = input_format_t::json,
+                          const bool strict = true,
+                          const bool ignore_comments = false)
+    {
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        return format == input_format_t::json
+               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
+               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
+    }
+
+    template <typename SAX>
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, sax_parse(ptr, ptr + len, ...))
+    JSON_HEDLEY_NON_NULL(2)
+    static bool sax_parse(detail::span_input_adapter&& i, SAX* sax,
+                          input_format_t format = input_format_t::json,
+                          const bool strict = true,
+                          const bool ignore_comments = false)
+    {
+        auto ia = i.get();
+        return format == input_format_t::json
+               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
+               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
+    }
+
+    /*!
+    @brief deserialize from stream
+    @deprecated This stream operator is deprecated and will be removed in
+                version 4.0.0 of the library. Please use
+                @ref operator>>(std::istream&, basic_json&)
+                instead; that is, replace calls like `j << i;` with `i >> j;`.
+    @since version 1.0.0; deprecated since version 3.0.0
+    */
+    JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator>>(std::istream&, basic_json&))
+    friend std::istream& operator<<(basic_json& j, std::istream& i)
+    {
+        return operator>>(i, j);
+    }
+
+    /*!
+    @brief deserialize from stream
+
+    Deserializes an input stream to a JSON value.
+
+    @param[in,out] i  input stream to read a serialized JSON value from
+    @param[in,out] j  JSON value to write the deserialized input to
+
+    @throw parse_error.101 in case of an unexpected token
+    @throw parse_error.102 if to_unicode fails or surrogate error
+    @throw parse_error.103 if to_unicode fails
+
+    @complexity Linear in the length of the input. The parser is a predictive
+    LL(1) parser.
+
+    @note A UTF-8 byte order mark is silently ignored.
+
+    @liveexample{The example below shows how a JSON value is constructed by
+    reading a serialization from a stream.,operator_deserialize}
+
+    @sa parse(std::istream&, const parser_callback_t) for a variant with a
+    parser callback function to filter values while parsing
+
+    @since version 1.0.0
+    */
+    friend std::istream& operator>>(std::istream& i, basic_json& j)
+    {
+        parser(detail::input_adapter(i)).parse(false, j);
+        return i;
+    }
+
+    /// @}
+
+    ///////////////////////////
+    // convenience functions //
+    ///////////////////////////
+
+    /*!
+    @brief return the type as string
+
+    Returns the type name as string to be used in error messages - usually to
+    indicate that a function was called on a wrong JSON type.
+
+    @return a string representation of a the @a m_type member:
+            Value type  | return value
+            ----------- | -------------
+            null        | `"null"`
+            boolean     | `"boolean"`
+            string      | `"string"`
+            number      | `"number"` (for all number types)
+            object      | `"object"`
+            array       | `"array"`
+            binary      | `"binary"`
+            discarded   | `"discarded"`
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @complexity Constant.
+
+    @liveexample{The following code exemplifies `type_name()` for all JSON
+    types.,type_name}
+
+    @sa @ref type() -- return the type of the JSON value
+    @sa @ref operator value_t() -- return the type of the JSON value (implicit)
+
+    @since version 1.0.0, public since 2.1.0, `const char*` and `noexcept`
+    since 3.0.0
+    */
+    JSON_HEDLEY_RETURNS_NON_NULL
+    const char* type_name() const noexcept
+    {
+        {
+            switch (m_type)
+            {
+                case value_t::null:
+                    return "null";
+                case value_t::object:
+                    return "object";
+                case value_t::array:
+                    return "array";
+                case value_t::string:
+                    return "string";
+                case value_t::boolean:
+                    return "boolean";
+                case value_t::binary:
+                    return "binary";
+                case value_t::discarded:
+                    return "discarded";
+                default:
+                    return "number";
+            }
+        }
+    }
+
+
+  JSON_PROTECTED_UNLESS_TESTED:
+    //////////////////////
+    // member variables //
+    //////////////////////
+
+    /// the type of the current element
+    value_t m_type = value_t::null;
+
+    /// the value of the current element
+    json_value m_value = {};
+
+    //////////////////////////////////////////
+    // binary serialization/deserialization //
+    //////////////////////////////////////////
+
+    /// @name binary serialization/deserialization support
+    /// @{
+
+  public:
+    /*!
+    @brief create a CBOR serialization of a given JSON value
+
+    Serializes a given JSON value @a j to a byte vector using the CBOR (Concise
+    Binary Object Representation) serialization format. CBOR is a binary
+    serialization format which aims to be more compact than JSON itself, yet
+    more efficient to parse.
+
+    The library uses the following mapping from JSON values types to
+    CBOR types according to the CBOR specification (RFC 7049):
+
+    JSON value type | value/range                                | CBOR type                          | first byte
+    --------------- | ------------------------------------------ | ---------------------------------- | ---------------
+    null            | `null`                                     | Null                               | 0xF6
+    boolean         | `true`                                     | True                               | 0xF5
+    boolean         | `false`                                    | False                              | 0xF4
+    number_integer  | -9223372036854775808..-2147483649          | Negative integer (8 bytes follow)  | 0x3B
+    number_integer  | -2147483648..-32769                        | Negative integer (4 bytes follow)  | 0x3A
+    number_integer  | -32768..-129                               | Negative integer (2 bytes follow)  | 0x39
+    number_integer  | -128..-25                                  | Negative integer (1 byte follow)   | 0x38
+    number_integer  | -24..-1                                    | Negative integer                   | 0x20..0x37
+    number_integer  | 0..23                                      | Integer                            | 0x00..0x17
+    number_integer  | 24..255                                    | Unsigned integer (1 byte follow)   | 0x18
+    number_integer  | 256..65535                                 | Unsigned integer (2 bytes follow)  | 0x19
+    number_integer  | 65536..4294967295                          | Unsigned integer (4 bytes follow)  | 0x1A
+    number_integer  | 4294967296..18446744073709551615           | Unsigned integer (8 bytes follow)  | 0x1B
+    number_unsigned | 0..23                                      | Integer                            | 0x00..0x17
+    number_unsigned | 24..255                                    | Unsigned integer (1 byte follow)   | 0x18
+    number_unsigned | 256..65535                                 | Unsigned integer (2 bytes follow)  | 0x19
+    number_unsigned | 65536..4294967295                          | Unsigned integer (4 bytes follow)  | 0x1A
+    number_unsigned | 4294967296..18446744073709551615           | Unsigned integer (8 bytes follow)  | 0x1B
+    number_float    | *any value representable by a float*       | Single-Precision Float             | 0xFA
+    number_float    | *any value NOT representable by a float*   | Double-Precision Float             | 0xFB
+    string          | *length*: 0..23                            | UTF-8 string                       | 0x60..0x77
+    string          | *length*: 23..255                          | UTF-8 string (1 byte follow)       | 0x78
+    string          | *length*: 256..65535                       | UTF-8 string (2 bytes follow)      | 0x79
+    string          | *length*: 65536..4294967295                | UTF-8 string (4 bytes follow)      | 0x7A
+    string          | *length*: 4294967296..18446744073709551615 | UTF-8 string (8 bytes follow)      | 0x7B
+    array           | *size*: 0..23                              | array                              | 0x80..0x97
+    array           | *size*: 23..255                            | array (1 byte follow)              | 0x98
+    array           | *size*: 256..65535                         | array (2 bytes follow)             | 0x99
+    array           | *size*: 65536..4294967295                  | array (4 bytes follow)             | 0x9A
+    array           | *size*: 4294967296..18446744073709551615   | array (8 bytes follow)             | 0x9B
+    object          | *size*: 0..23                              | map                                | 0xA0..0xB7
+    object          | *size*: 23..255                            | map (1 byte follow)                | 0xB8
+    object          | *size*: 256..65535                         | map (2 bytes follow)               | 0xB9
+    object          | *size*: 65536..4294967295                  | map (4 bytes follow)               | 0xBA
+    object          | *size*: 4294967296..18446744073709551615   | map (8 bytes follow)               | 0xBB
+    binary          | *size*: 0..23                              | byte string                        | 0x40..0x57
+    binary          | *size*: 23..255                            | byte string (1 byte follow)        | 0x58
+    binary          | *size*: 256..65535                         | byte string (2 bytes follow)       | 0x59
+    binary          | *size*: 65536..4294967295                  | byte string (4 bytes follow)       | 0x5A
+    binary          | *size*: 4294967296..18446744073709551615   | byte string (8 bytes follow)       | 0x5B
+
+    @note The mapping is **complete** in the sense that any JSON value type
+          can be converted to a CBOR value.
+
+    @note If NaN or Infinity are stored inside a JSON number, they are
+          serialized properly. This behavior differs from the @ref dump()
+          function which serializes NaN or Infinity to `null`.
+
+    @note The following CBOR types are not used in the conversion:
+          - UTF-8 strings terminated by "break" (0x7F)
+          - arrays terminated by "break" (0x9F)
+          - maps terminated by "break" (0xBF)
+          - byte strings terminated by "break" (0x5F)
+          - date/time (0xC0..0xC1)
+          - bignum (0xC2..0xC3)
+          - decimal fraction (0xC4)
+          - bigfloat (0xC5)
+          - expected conversions (0xD5..0xD7)
+          - simple values (0xE0..0xF3, 0xF8)
+          - undefined (0xF7)
+          - half-precision floats (0xF9)
+          - break (0xFF)
+
+    @param[in] j  JSON value to serialize
+    @return CBOR serialization as byte vector
+
+    @complexity Linear in the size of the JSON value @a j.
+
+    @liveexample{The example shows the serialization of a JSON value to a byte
+    vector in CBOR format.,to_cbor}
+
+    @sa http://cbor.io
+    @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t) for the
+        analogous deserialization
+    @sa @ref to_msgpack(const basic_json&) for the related MessagePack format
+    @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
+             related UBJSON format
+
+    @since version 2.0.9; compact representation of floating-point numbers
+           since version 3.8.0
+    */
+    static std::vector<uint8_t> to_cbor(const basic_json& j)
+    {
+        std::vector<uint8_t> result;
+        to_cbor(j, result);
+        return result;
+    }
+
+    static void to_cbor(const basic_json& j, detail::output_adapter<uint8_t> o)
+    {
+        binary_writer<uint8_t>(o).write_cbor(j);
+    }
+
+    static void to_cbor(const basic_json& j, detail::output_adapter<char> o)
+    {
+        binary_writer<char>(o).write_cbor(j);
+    }
+
+    /*!
+    @brief create a MessagePack serialization of a given JSON value
+
+    Serializes a given JSON value @a j to a byte vector using the MessagePack
+    serialization format. MessagePack is a binary serialization format which
+    aims to be more compact than JSON itself, yet more efficient to parse.
+
+    The library uses the following mapping from JSON values types to
+    MessagePack types according to the MessagePack specification:
+
+    JSON value type | value/range                       | MessagePack type | first byte
+    --------------- | --------------------------------- | ---------------- | ----------
+    null            | `null`                            | nil              | 0xC0
+    boolean         | `true`                            | true             | 0xC3
+    boolean         | `false`                           | false            | 0xC2
+    number_integer  | -9223372036854775808..-2147483649 | int64            | 0xD3
+    number_integer  | -2147483648..-32769               | int32            | 0xD2
+    number_integer  | -32768..-129                      | int16            | 0xD1
+    number_integer  | -128..-33                         | int8             | 0xD0
+    number_integer  | -32..-1                           | negative fixint  | 0xE0..0xFF
+    number_integer  | 0..127                            | positive fixint  | 0x00..0x7F
+    number_integer  | 128..255                          | uint 8           | 0xCC
+    number_integer  | 256..65535                        | uint 16          | 0xCD
+    number_integer  | 65536..4294967295                 | uint 32          | 0xCE
+    number_integer  | 4294967296..18446744073709551615  | uint 64          | 0xCF
+    number_unsigned | 0..127                            | positive fixint  | 0x00..0x7F
+    number_unsigned | 128..255                          | uint 8           | 0xCC
+    number_unsigned | 256..65535                        | uint 16          | 0xCD
+    number_unsigned | 65536..4294967295                 | uint 32          | 0xCE
+    number_unsigned | 4294967296..18446744073709551615  | uint 64          | 0xCF
+    number_float    | *any value representable by a float*     | float 32 | 0xCA
+    number_float    | *any value NOT representable by a float* | float 64 | 0xCB
+    string          | *length*: 0..31                   | fixstr           | 0xA0..0xBF
+    string          | *length*: 32..255                 | str 8            | 0xD9
+    string          | *length*: 256..65535              | str 16           | 0xDA
+    string          | *length*: 65536..4294967295       | str 32           | 0xDB
+    array           | *size*: 0..15                     | fixarray         | 0x90..0x9F
+    array           | *size*: 16..65535                 | array 16         | 0xDC
+    array           | *size*: 65536..4294967295         | array 32         | 0xDD
+    object          | *size*: 0..15                     | fix map          | 0x80..0x8F
+    object          | *size*: 16..65535                 | map 16           | 0xDE
+    object          | *size*: 65536..4294967295         | map 32           | 0xDF
+    binary          | *size*: 0..255                    | bin 8            | 0xC4
+    binary          | *size*: 256..65535                | bin 16           | 0xC5
+    binary          | *size*: 65536..4294967295         | bin 32           | 0xC6
+
+    @note The mapping is **complete** in the sense that any JSON value type
+          can be converted to a MessagePack value.
+
+    @note The following values can **not** be converted to a MessagePack value:
+          - strings with more than 4294967295 bytes
+          - byte strings with more than 4294967295 bytes
+          - arrays with more than 4294967295 elements
+          - objects with more than 4294967295 elements
+
+    @note Any MessagePack output created @ref to_msgpack can be successfully
+          parsed by @ref from_msgpack.
+
+    @note If NaN or Infinity are stored inside a JSON number, they are
+          serialized properly. This behavior differs from the @ref dump()
+          function which serializes NaN or Infinity to `null`.
+
+    @param[in] j  JSON value to serialize
+    @return MessagePack serialization as byte vector
+
+    @complexity Linear in the size of the JSON value @a j.
+
+    @liveexample{The example shows the serialization of a JSON value to a byte
+    vector in MessagePack format.,to_msgpack}
+
+    @sa http://msgpack.org
+    @sa @ref from_msgpack for the analogous deserialization
+    @sa @ref to_cbor(const basic_json& for the related CBOR format
+    @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
+             related UBJSON format
+
+    @since version 2.0.9
+    */
+    static std::vector<uint8_t> to_msgpack(const basic_json& j)
+    {
+        std::vector<uint8_t> result;
+        to_msgpack(j, result);
+        return result;
+    }
+
+    static void to_msgpack(const basic_json& j, detail::output_adapter<uint8_t> o)
+    {
+        binary_writer<uint8_t>(o).write_msgpack(j);
+    }
+
+    static void to_msgpack(const basic_json& j, detail::output_adapter<char> o)
+    {
+        binary_writer<char>(o).write_msgpack(j);
+    }
+
+    /*!
+    @brief create a UBJSON serialization of a given JSON value
+
+    Serializes a given JSON value @a j to a byte vector using the UBJSON
+    (Universal Binary JSON) serialization format. UBJSON aims to be more compact
+    than JSON itself, yet more efficient to parse.
+
+    The library uses the following mapping from JSON values types to
+    UBJSON types according to the UBJSON specification:
+
+    JSON value type | value/range                       | UBJSON type | marker
+    --------------- | --------------------------------- | ----------- | ------
+    null            | `null`                            | null        | `Z`
+    boolean         | `true`                            | true        | `T`
+    boolean         | `false`                           | false       | `F`
+    number_integer  | -9223372036854775808..-2147483649 | int64       | `L`
+    number_integer  | -2147483648..-32769               | int32       | `l`
+    number_integer  | -32768..-129                      | int16       | `I`
+    number_integer  | -128..127                         | int8        | `i`
+    number_integer  | 128..255                          | uint8       | `U`
+    number_integer  | 256..32767                        | int16       | `I`
+    number_integer  | 32768..2147483647                 | int32       | `l`
+    number_integer  | 2147483648..9223372036854775807   | int64       | `L`
+    number_unsigned | 0..127                            | int8        | `i`
+    number_unsigned | 128..255                          | uint8       | `U`
+    number_unsigned | 256..32767                        | int16       | `I`
+    number_unsigned | 32768..2147483647                 | int32       | `l`
+    number_unsigned | 2147483648..9223372036854775807   | int64       | `L`
+    number_unsigned | 2147483649..18446744073709551615  | high-precision | `H`
+    number_float    | *any value*                       | float64     | `D`
+    string          | *with shortest length indicator*  | string      | `S`
+    array           | *see notes on optimized format*   | array       | `[`
+    object          | *see notes on optimized format*   | map         | `{`
+
+    @note The mapping is **complete** in the sense that any JSON value type
+          can be converted to a UBJSON value.
+
+    @note The following values can **not** be converted to a UBJSON value:
+          - strings with more than 9223372036854775807 bytes (theoretical)
+
+    @note The following markers are not used in the conversion:
+          - `Z`: no-op values are not created.
+          - `C`: single-byte strings are serialized with `S` markers.
+
+    @note Any UBJSON output created @ref to_ubjson can be successfully parsed
+          by @ref from_ubjson.
+
+    @note If NaN or Infinity are stored inside a JSON number, they are
+          serialized properly. This behavior differs from the @ref dump()
+          function which serializes NaN or Infinity to `null`.
+
+    @note The optimized formats for containers are supported: Parameter
+          @a use_size adds size information to the beginning of a container and
+          removes the closing marker. Parameter @a use_type further checks
+          whether all elements of a container have the same type and adds the
+          type marker to the beginning of the container. The @a use_type
+          parameter must only be used together with @a use_size = true. Note
+          that @a use_size = true alone may result in larger representations -
+          the benefit of this parameter is that the receiving side is
+          immediately informed on the number of elements of the container.
+
+    @note If the JSON data contains the binary type, the value stored is a list
+          of integers, as suggested by the UBJSON documentation.  In particular,
+          this means that serialization and the deserialization of a JSON
+          containing binary values into UBJSON and back will result in a
+          different JSON object.
+
+    @param[in] j  JSON value to serialize
+    @param[in] use_size  whether to add size annotations to container types
+    @param[in] use_type  whether to add type annotations to container types
+                         (must be combined with @a use_size = true)
+    @return UBJSON serialization as byte vector
+
+    @complexity Linear in the size of the JSON value @a j.
+
+    @liveexample{The example shows the serialization of a JSON value to a byte
+    vector in UBJSON format.,to_ubjson}
+
+    @sa http://ubjson.org
+    @sa @ref from_ubjson(detail::input_adapter&&, const bool, const bool) for the
+        analogous deserialization
+    @sa @ref to_cbor(const basic_json& for the related CBOR format
+    @sa @ref to_msgpack(const basic_json&) for the related MessagePack format
+
+    @since version 3.1.0
+    */
+    static std::vector<uint8_t> to_ubjson(const basic_json& j,
+                                          const bool use_size = false,
+                                          const bool use_type = false)
+    {
+        std::vector<uint8_t> result;
+        to_ubjson(j, result, use_size, use_type);
+        return result;
+    }
+
+    static void to_ubjson(const basic_json& j, detail::output_adapter<uint8_t> o,
+                          const bool use_size = false, const bool use_type = false)
+    {
+        binary_writer<uint8_t>(o).write_ubjson(j, use_size, use_type);
+    }
+
+    static void to_ubjson(const basic_json& j, detail::output_adapter<char> o,
+                          const bool use_size = false, const bool use_type = false)
+    {
+        binary_writer<char>(o).write_ubjson(j, use_size, use_type);
+    }
+
+
+    /*!
+    @brief Serializes the given JSON object `j` to BSON and returns a vector
+           containing the corresponding BSON-representation.
+
+    BSON (Binary JSON) is a binary format in which zero or more ordered key/value pairs are
+    stored as a single entity (a so-called document).
+
+    The library uses the following mapping from JSON values types to BSON types:
+
+    JSON value type | value/range                       | BSON type   | marker
+    --------------- | --------------------------------- | ----------- | ------
+    null            | `null`                            | null        | 0x0A
+    boolean         | `true`, `false`                   | boolean     | 0x08
+    number_integer  | -9223372036854775808..-2147483649 | int64       | 0x12
+    number_integer  | -2147483648..2147483647           | int32       | 0x10
+    number_integer  | 2147483648..9223372036854775807   | int64       | 0x12
+    number_unsigned | 0..2147483647                     | int32       | 0x10
+    number_unsigned | 2147483648..9223372036854775807   | int64       | 0x12
+    number_unsigned | 9223372036854775808..18446744073709551615| --   | --
+    number_float    | *any value*                       | double      | 0x01
+    string          | *any value*                       | string      | 0x02
+    array           | *any value*                       | document    | 0x04
+    object          | *any value*                       | document    | 0x03
+    binary          | *any value*                       | binary      | 0x05
+
+    @warning The mapping is **incomplete**, since only JSON-objects (and things
+    contained therein) can be serialized to BSON.
+    Also, integers larger than 9223372036854775807 cannot be serialized to BSON,
+    and the keys may not contain U+0000, since they are serialized a
+    zero-terminated c-strings.
+
+    @throw out_of_range.407  if `j.is_number_unsigned() && j.get<std::uint64_t>() > 9223372036854775807`
+    @throw out_of_range.409  if a key in `j` contains a NULL (U+0000)
+    @throw type_error.317    if `!j.is_object()`
+
+    @pre The input `j` is required to be an object: `j.is_object() == true`.
+
+    @note Any BSON output created via @ref to_bson can be successfully parsed
+          by @ref from_bson.
+
+    @param[in] j  JSON value to serialize
+    @return BSON serialization as byte vector
+
+    @complexity Linear in the size of the JSON value @a j.
+
+    @liveexample{The example shows the serialization of a JSON value to a byte
+    vector in BSON format.,to_bson}
+
+    @sa http://bsonspec.org/spec.html
+    @sa @ref from_bson(detail::input_adapter&&, const bool strict) for the
+        analogous deserialization
+    @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
+             related UBJSON format
+    @sa @ref to_cbor(const basic_json&) for the related CBOR format
+    @sa @ref to_msgpack(const basic_json&) for the related MessagePack format
+    */
+    static std::vector<uint8_t> to_bson(const basic_json& j)
+    {
+        std::vector<uint8_t> result;
+        to_bson(j, result);
+        return result;
+    }
+
+    /*!
+    @brief Serializes the given JSON object `j` to BSON and forwards the
+           corresponding BSON-representation to the given output_adapter `o`.
+    @param j The JSON object to convert to BSON.
+    @param o The output adapter that receives the binary BSON representation.
+    @pre The input `j` shall be an object: `j.is_object() == true`
+    @sa @ref to_bson(const basic_json&)
+    */
+    static void to_bson(const basic_json& j, detail::output_adapter<uint8_t> o)
+    {
+        binary_writer<uint8_t>(o).write_bson(j);
+    }
+
+    /*!
+    @copydoc to_bson(const basic_json&, detail::output_adapter<uint8_t>)
+    */
+    static void to_bson(const basic_json& j, detail::output_adapter<char> o)
+    {
+        binary_writer<char>(o).write_bson(j);
+    }
+
+
+    /*!
+    @brief create a JSON value from an input in CBOR format
+
+    Deserializes a given input @a i to a JSON value using the CBOR (Concise
+    Binary Object Representation) serialization format.
+
+    The library maps CBOR types to JSON value types as follows:
+
+    CBOR type              | JSON value type | first byte
+    ---------------------- | --------------- | ----------
+    Integer                | number_unsigned | 0x00..0x17
+    Unsigned integer       | number_unsigned | 0x18
+    Unsigned integer       | number_unsigned | 0x19
+    Unsigned integer       | number_unsigned | 0x1A
+    Unsigned integer       | number_unsigned | 0x1B
+    Negative integer       | number_integer  | 0x20..0x37
+    Negative integer       | number_integer  | 0x38
+    Negative integer       | number_integer  | 0x39
+    Negative integer       | number_integer  | 0x3A
+    Negative integer       | number_integer  | 0x3B
+    Byte string            | binary          | 0x40..0x57
+    Byte string            | binary          | 0x58
+    Byte string            | binary          | 0x59
+    Byte string            | binary          | 0x5A
+    Byte string            | binary          | 0x5B
+    UTF-8 string           | string          | 0x60..0x77
+    UTF-8 string           | string          | 0x78
+    UTF-8 string           | string          | 0x79
+    UTF-8 string           | string          | 0x7A
+    UTF-8 string           | string          | 0x7B
+    UTF-8 string           | string          | 0x7F
+    array                  | array           | 0x80..0x97
+    array                  | array           | 0x98
+    array                  | array           | 0x99
+    array                  | array           | 0x9A
+    array                  | array           | 0x9B
+    array                  | array           | 0x9F
+    map                    | object          | 0xA0..0xB7
+    map                    | object          | 0xB8
+    map                    | object          | 0xB9
+    map                    | object          | 0xBA
+    map                    | object          | 0xBB
+    map                    | object          | 0xBF
+    False                  | `false`         | 0xF4
+    True                   | `true`          | 0xF5
+    Null                   | `null`          | 0xF6
+    Half-Precision Float   | number_float    | 0xF9
+    Single-Precision Float | number_float    | 0xFA
+    Double-Precision Float | number_float    | 0xFB
+
+    @warning The mapping is **incomplete** in the sense that not all CBOR
+             types can be converted to a JSON value. The following CBOR types
+             are not supported and will yield parse errors (parse_error.112):
+             - date/time (0xC0..0xC1)
+             - bignum (0xC2..0xC3)
+             - decimal fraction (0xC4)
+             - bigfloat (0xC5)
+             - expected conversions (0xD5..0xD7)
+             - simple values (0xE0..0xF3, 0xF8)
+             - undefined (0xF7)
+
+    @warning CBOR allows map keys of any type, whereas JSON only allows
+             strings as keys in object values. Therefore, CBOR maps with keys
+             other than UTF-8 strings are rejected (parse_error.113).
+
+    @note Any CBOR output created @ref to_cbor can be successfully parsed by
+          @ref from_cbor.
+
+    @param[in] i  an input in CBOR format convertible to an input adapter
+    @param[in] strict  whether to expect the input to be consumed until EOF
+                       (true by default)
+    @param[in] allow_exceptions  whether to throw exceptions in case of a
+    parse error (optional, true by default)
+    @param[in] tag_handler how to treat CBOR tags (optional, error by default)
+
+    @return deserialized JSON value; in case of a parse error and
+            @a allow_exceptions set to `false`, the return value will be
+            value_t::discarded.
+
+    @throw parse_error.110 if the given input ends prematurely or the end of
+    file was not reached when @a strict was set to true
+    @throw parse_error.112 if unsupported features from CBOR were
+    used in the given input @a v or if the input is not valid CBOR
+    @throw parse_error.113 if a string was expected as map key, but not found
+
+    @complexity Linear in the size of the input @a i.
+
+    @liveexample{The example shows the deserialization of a byte vector in CBOR
+    format to a JSON value.,from_cbor}
+
+    @sa http://cbor.io
+    @sa @ref to_cbor(const basic_json&) for the analogous serialization
+    @sa @ref from_msgpack(detail::input_adapter&&, const bool, const bool) for the
+        related MessagePack format
+    @sa @ref from_ubjson(detail::input_adapter&&, const bool, const bool) for the
+        related UBJSON format
+
+    @since version 2.0.9; parameter @a start_index since 2.1.1; changed to
+           consume input adapters, removed start_index parameter, and added
+           @a strict parameter since 3.0.0; added @a allow_exceptions parameter
+           since 3.2.0; added @a tag_handler parameter since 3.9.0.
+    */
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_cbor(InputType&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /*!
+    @copydoc from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t)
+    */
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_cbor(IteratorType first, IteratorType last,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
+    static basic_json from_cbor(const T* ptr, std::size_t len,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
+    }
+
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
+    static basic_json from_cbor(detail::span_input_adapter&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = i.get();
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /*!
+    @brief create a JSON value from an input in MessagePack format
+
+    Deserializes a given input @a i to a JSON value using the MessagePack
+    serialization format.
+
+    The library maps MessagePack types to JSON value types as follows:
+
+    MessagePack type | JSON value type | first byte
+    ---------------- | --------------- | ----------
+    positive fixint  | number_unsigned | 0x00..0x7F
+    fixmap           | object          | 0x80..0x8F
+    fixarray         | array           | 0x90..0x9F
+    fixstr           | string          | 0xA0..0xBF
+    nil              | `null`          | 0xC0
+    false            | `false`         | 0xC2
+    true             | `true`          | 0xC3
+    float 32         | number_float    | 0xCA
+    float 64         | number_float    | 0xCB
+    uint 8           | number_unsigned | 0xCC
+    uint 16          | number_unsigned | 0xCD
+    uint 32          | number_unsigned | 0xCE
+    uint 64          | number_unsigned | 0xCF
+    int 8            | number_integer  | 0xD0
+    int 16           | number_integer  | 0xD1
+    int 32           | number_integer  | 0xD2
+    int 64           | number_integer  | 0xD3
+    str 8            | string          | 0xD9
+    str 16           | string          | 0xDA
+    str 32           | string          | 0xDB
+    array 16         | array           | 0xDC
+    array 32         | array           | 0xDD
+    map 16           | object          | 0xDE
+    map 32           | object          | 0xDF
+    bin 8            | binary          | 0xC4
+    bin 16           | binary          | 0xC5
+    bin 32           | binary          | 0xC6
+    ext 8            | binary          | 0xC7
+    ext 16           | binary          | 0xC8
+    ext 32           | binary          | 0xC9
+    fixext 1         | binary          | 0xD4
+    fixext 2         | binary          | 0xD5
+    fixext 4         | binary          | 0xD6
+    fixext 8         | binary          | 0xD7
+    fixext 16        | binary          | 0xD8
+    negative fixint  | number_integer  | 0xE0-0xFF
+
+    @note Any MessagePack output created @ref to_msgpack can be successfully
+          parsed by @ref from_msgpack.
+
+    @param[in] i  an input in MessagePack format convertible to an input
+                  adapter
+    @param[in] strict  whether to expect the input to be consumed until EOF
+                       (true by default)
+    @param[in] allow_exceptions  whether to throw exceptions in case of a
+    parse error (optional, true by default)
+
+    @return deserialized JSON value; in case of a parse error and
+            @a allow_exceptions set to `false`, the return value will be
+            value_t::discarded.
+
+    @throw parse_error.110 if the given input ends prematurely or the end of
+    file was not reached when @a strict was set to true
+    @throw parse_error.112 if unsupported features from MessagePack were
+    used in the given input @a i or if the input is not valid MessagePack
+    @throw parse_error.113 if a string was expected as map key, but not found
+
+    @complexity Linear in the size of the input @a i.
+
+    @liveexample{The example shows the deserialization of a byte vector in
+    MessagePack format to a JSON value.,from_msgpack}
+
+    @sa http://msgpack.org
+    @sa @ref to_msgpack(const basic_json&) for the analogous serialization
+    @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t) for the
+        related CBOR format
+    @sa @ref from_ubjson(detail::input_adapter&&, const bool, const bool) for
+        the related UBJSON format
+    @sa @ref from_bson(detail::input_adapter&&, const bool, const bool) for
+        the related BSON format
+
+    @since version 2.0.9; parameter @a start_index since 2.1.1; changed to
+           consume input adapters, removed start_index parameter, and added
+           @a strict parameter since 3.0.0; added @a allow_exceptions parameter
+           since 3.2.0
+    */
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_msgpack(InputType&& i,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /*!
+    @copydoc from_msgpack(detail::input_adapter&&, const bool, const bool)
+    */
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_msgpack(IteratorType first, IteratorType last,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
+    static basic_json from_msgpack(const T* ptr, std::size_t len,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        return from_msgpack(ptr, ptr + len, strict, allow_exceptions);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
+    static basic_json from_msgpack(detail::span_input_adapter&& i,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = i.get();
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+
+    /*!
+    @brief create a JSON value from an input in UBJSON format
+
+    Deserializes a given input @a i to a JSON value using the UBJSON (Universal
+    Binary JSON) serialization format.
+
+    The library maps UBJSON types to JSON value types as follows:
+
+    UBJSON type | JSON value type                         | marker
+    ----------- | --------------------------------------- | ------
+    no-op       | *no value, next value is read*          | `N`
+    null        | `null`                                  | `Z`
+    false       | `false`                                 | `F`
+    true        | `true`                                  | `T`
+    float32     | number_float                            | `d`
+    float64     | number_float                            | `D`
+    uint8       | number_unsigned                         | `U`
+    int8        | number_integer                          | `i`
+    int16       | number_integer                          | `I`
+    int32       | number_integer                          | `l`
+    int64       | number_integer                          | `L`
+    high-precision number | number_integer, number_unsigned, or number_float - depends on number string | 'H'
+    string      | string                                  | `S`
+    char        | string                                  | `C`
+    array       | array (optimized values are supported)  | `[`
+    object      | object (optimized values are supported) | `{`
+
+    @note The mapping is **complete** in the sense that any UBJSON value can
+          be converted to a JSON value.
+
+    @param[in] i  an input in UBJSON format convertible to an input adapter
+    @param[in] strict  whether to expect the input to be consumed until EOF
+                       (true by default)
+    @param[in] allow_exceptions  whether to throw exceptions in case of a
+    parse error (optional, true by default)
+
+    @return deserialized JSON value; in case of a parse error and
+            @a allow_exceptions set to `false`, the return value will be
+            value_t::discarded.
+
+    @throw parse_error.110 if the given input ends prematurely or the end of
+    file was not reached when @a strict was set to true
+    @throw parse_error.112 if a parse error occurs
+    @throw parse_error.113 if a string could not be parsed successfully
+
+    @complexity Linear in the size of the input @a i.
+
+    @liveexample{The example shows the deserialization of a byte vector in
+    UBJSON format to a JSON value.,from_ubjson}
+
+    @sa http://ubjson.org
+    @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
+             analogous serialization
+    @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t) for the
+        related CBOR format
+    @sa @ref from_msgpack(detail::input_adapter&&, const bool, const bool) for
+        the related MessagePack format
+    @sa @ref from_bson(detail::input_adapter&&, const bool, const bool) for
+        the related BSON format
+
+    @since version 3.1.0; added @a allow_exceptions parameter since 3.2.0
+    */
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_ubjson(InputType&& i,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /*!
+    @copydoc from_ubjson(detail::input_adapter&&, const bool, const bool)
+    */
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_ubjson(IteratorType first, IteratorType last,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
+    static basic_json from_ubjson(const T* ptr, std::size_t len,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        return from_ubjson(ptr, ptr + len, strict, allow_exceptions);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
+    static basic_json from_ubjson(detail::span_input_adapter&& i,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = i.get();
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+
+    /*!
+    @brief Create a JSON value from an input in BSON format
+
+    Deserializes a given input @a i to a JSON value using the BSON (Binary JSON)
+    serialization format.
+
+    The library maps BSON record types to JSON value types as follows:
+
+    BSON type       | BSON marker byte | JSON value type
+    --------------- | ---------------- | ---------------------------
+    double          | 0x01             | number_float
+    string          | 0x02             | string
+    document        | 0x03             | object
+    array           | 0x04             | array
+    binary          | 0x05             | binary
+    undefined       | 0x06             | still unsupported
+    ObjectId        | 0x07             | still unsupported
+    boolean         | 0x08             | boolean
+    UTC Date-Time   | 0x09             | still unsupported
+    null            | 0x0A             | null
+    Regular Expr.   | 0x0B             | still unsupported
+    DB Pointer      | 0x0C             | still unsupported
+    JavaScript Code | 0x0D             | still unsupported
+    Symbol          | 0x0E             | still unsupported
+    JavaScript Code | 0x0F             | still unsupported
+    int32           | 0x10             | number_integer
+    Timestamp       | 0x11             | still unsupported
+    128-bit decimal float | 0x13       | still unsupported
+    Max Key         | 0x7F             | still unsupported
+    Min Key         | 0xFF             | still unsupported
+
+    @warning The mapping is **incomplete**. The unsupported mappings
+             are indicated in the table above.
+
+    @param[in] i  an input in BSON format convertible to an input adapter
+    @param[in] strict  whether to expect the input to be consumed until EOF
+                       (true by default)
+    @param[in] allow_exceptions  whether to throw exceptions in case of a
+    parse error (optional, true by default)
+
+    @return deserialized JSON value; in case of a parse error and
+            @a allow_exceptions set to `false`, the return value will be
+            value_t::discarded.
+
+    @throw parse_error.114 if an unsupported BSON record type is encountered
+
+    @complexity Linear in the size of the input @a i.
+
+    @liveexample{The example shows the deserialization of a byte vector in
+    BSON format to a JSON value.,from_bson}
+
+    @sa http://bsonspec.org/spec.html
+    @sa @ref to_bson(const basic_json&) for the analogous serialization
+    @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t) for the
+        related CBOR format
+    @sa @ref from_msgpack(detail::input_adapter&&, const bool, const bool) for
+        the related MessagePack format
+    @sa @ref from_ubjson(detail::input_adapter&&, const bool, const bool) for the
+        related UBJSON format
+    */
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_bson(InputType&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /*!
+    @copydoc from_bson(detail::input_adapter&&, const bool, const bool)
+    */
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_bson(IteratorType first, IteratorType last,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
+    static basic_json from_bson(const T* ptr, std::size_t len,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        return from_bson(ptr, ptr + len, strict, allow_exceptions);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
+    static basic_json from_bson(detail::span_input_adapter&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = i.get();
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+    /// @}
+
+    //////////////////////////
+    // JSON Pointer support //
+    //////////////////////////
+
+    /// @name JSON Pointer functions
+    /// @{
+
+    /*!
+    @brief access specified element via JSON Pointer
+
+    Uses a JSON pointer to retrieve a reference to the respective JSON value.
+    No bound checking is performed. Similar to @ref operator[](const typename
+    object_t::key_type&), `null` values are created in arrays and objects if
+    necessary.
+
+    In particular:
+    - If the JSON pointer points to an object key that does not exist, it
+      is created an filled with a `null` value before a reference to it
+      is returned.
+    - If the JSON pointer points to an array index that does not exist, it
+      is created an filled with a `null` value before a reference to it
+      is returned. All indices between the current maximum and the given
+      index are also filled with `null`.
+    - The special value `-` is treated as a synonym for the index past the
+      end.
+
+    @param[in] ptr  a JSON pointer
+
+    @return reference to the element pointed to by @a ptr
+
+    @complexity Constant.
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+
+    @liveexample{The behavior is shown in the example.,operatorjson_pointer}
+
+    @since version 2.0.0
+    */
+    reference operator[](const json_pointer& ptr)
+    {
+        return ptr.get_unchecked(this);
+    }
+
+    /*!
+    @brief access specified element via JSON Pointer
+
+    Uses a JSON pointer to retrieve a reference to the respective JSON value.
+    No bound checking is performed. The function does not change the JSON
+    value; no `null` values are created. In particular, the special value
+    `-` yields an exception.
+
+    @param[in] ptr  JSON pointer to the desired element
+
+    @return const reference to the element pointed to by @a ptr
+
+    @complexity Constant.
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+
+    @liveexample{The behavior is shown in the example.,operatorjson_pointer_const}
+
+    @since version 2.0.0
+    */
+    const_reference operator[](const json_pointer& ptr) const
+    {
+        return ptr.get_unchecked(this);
+    }
+
+    /*!
+    @brief access specified element via JSON Pointer
+
+    Returns a reference to the element at with specified JSON pointer @a ptr,
+    with bounds checking.
+
+    @param[in] ptr  JSON pointer to the desired element
+
+    @return reference to the element pointed to by @a ptr
+
+    @throw parse_error.106 if an array index in the passed JSON pointer @a ptr
+    begins with '0'. See example below.
+
+    @throw parse_error.109 if an array index in the passed JSON pointer @a ptr
+    is not a number. See example below.
+
+    @throw out_of_range.401 if an array index in the passed JSON pointer @a ptr
+    is out of range. See example below.
+
+    @throw out_of_range.402 if the array index '-' is used in the passed JSON
+    pointer @a ptr. As `at` provides checked access (and no elements are
+    implicitly inserted), the index '-' is always invalid. See example below.
+
+    @throw out_of_range.403 if the JSON pointer describes a key of an object
+    which cannot be found. See example below.
+
+    @throw out_of_range.404 if the JSON pointer @a ptr can not be resolved.
+    See example below.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Constant.
+
+    @since version 2.0.0
+
+    @liveexample{The behavior is shown in the example.,at_json_pointer}
+    */
+    reference at(const json_pointer& ptr)
+    {
+        return ptr.get_checked(this);
+    }
+
+    /*!
+    @brief access specified element via JSON Pointer
+
+    Returns a const reference to the element at with specified JSON pointer @a
+    ptr, with bounds checking.
+
+    @param[in] ptr  JSON pointer to the desired element
+
+    @return reference to the element pointed to by @a ptr
+
+    @throw parse_error.106 if an array index in the passed JSON pointer @a ptr
+    begins with '0'. See example below.
+
+    @throw parse_error.109 if an array index in the passed JSON pointer @a ptr
+    is not a number. See example below.
+
+    @throw out_of_range.401 if an array index in the passed JSON pointer @a ptr
+    is out of range. See example below.
+
+    @throw out_of_range.402 if the array index '-' is used in the passed JSON
+    pointer @a ptr. As `at` provides checked access (and no elements are
+    implicitly inserted), the index '-' is always invalid. See example below.
+
+    @throw out_of_range.403 if the JSON pointer describes a key of an object
+    which cannot be found. See example below.
+
+    @throw out_of_range.404 if the JSON pointer @a ptr can not be resolved.
+    See example below.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Constant.
+
+    @since version 2.0.0
+
+    @liveexample{The behavior is shown in the example.,at_json_pointer_const}
+    */
+    const_reference at(const json_pointer& ptr) const
+    {
+        return ptr.get_checked(this);
+    }
+
+    /*!
+    @brief return flattened JSON value
+
+    The function creates a JSON object whose keys are JSON pointers (see [RFC
+    6901](https://tools.ietf.org/html/rfc6901)) and whose values are all
+    primitive. The original JSON value can be restored using the @ref
+    unflatten() function.
+
+    @return an object that maps JSON pointers to primitive values
+
+    @note Empty objects and arrays are flattened to `null` and will not be
+          reconstructed correctly by the @ref unflatten() function.
+
+    @complexity Linear in the size the JSON value.
+
+    @liveexample{The following code shows how a JSON object is flattened to an
+    object whose keys consist of JSON pointers.,flatten}
+
+    @sa @ref unflatten() for the reverse function
+
+    @since version 2.0.0
+    */
+    basic_json flatten() const
+    {
+        basic_json result(value_t::object);
+        json_pointer::flatten("", *this, result);
+        return result;
+    }
+
+    /*!
+    @brief unflatten a previously flattened JSON value
+
+    The function restores the arbitrary nesting of a JSON value that has been
+    flattened before using the @ref flatten() function. The JSON value must
+    meet certain constraints:
+    1. The value must be an object.
+    2. The keys must be JSON pointers (see
+       [RFC 6901](https://tools.ietf.org/html/rfc6901))
+    3. The mapped values must be primitive JSON types.
+
+    @return the original JSON from a flattened version
+
+    @note Empty objects and arrays are flattened by @ref flatten() to `null`
+          values and can not unflattened to their original type. Apart from
+          this example, for a JSON value `j`, the following is always true:
+          `j == j.flatten().unflatten()`.
+
+    @complexity Linear in the size the JSON value.
+
+    @throw type_error.314  if value is not an object
+    @throw type_error.315  if object values are not primitive
+
+    @liveexample{The following code shows how a flattened JSON object is
+    unflattened into the original nested JSON object.,unflatten}
+
+    @sa @ref flatten() for the reverse function
+
+    @since version 2.0.0
+    */
+    basic_json unflatten() const
+    {
+        return json_pointer::unflatten(*this);
+    }
+
+    /// @}
+
+    //////////////////////////
+    // JSON Patch functions //
+    //////////////////////////
+
+    /// @name JSON Patch functions
+    /// @{
+
+    /*!
+    @brief applies a JSON patch
+
+    [JSON Patch](http://jsonpatch.com) defines a JSON document structure for
+    expressing a sequence of operations to apply to a JSON) document. With
+    this function, a JSON Patch is applied to the current JSON value by
+    executing all operations from the patch.
+
+    @param[in] json_patch  JSON patch document
+    @return patched document
+
+    @note The application of a patch is atomic: Either all operations succeed
+          and the patched document is returned or an exception is thrown. In
+          any case, the original value is not changed: the patch is applied
+          to a copy of the value.
+
+    @throw parse_error.104 if the JSON patch does not consist of an array of
+    objects
+
+    @throw parse_error.105 if the JSON patch is malformed (e.g., mandatory
+    attributes are missing); example: `"operation add must have member path"`
+
+    @throw out_of_range.401 if an array index is out of range.
+
+    @throw out_of_range.403 if a JSON pointer inside the patch could not be
+    resolved successfully in the current JSON value; example: `"key baz not
+    found"`
+
+    @throw out_of_range.405 if JSON pointer has no parent ("add", "remove",
+    "move")
+
+    @throw other_error.501 if "test" operation was unsuccessful
+
+    @complexity Linear in the size of the JSON value and the length of the
+    JSON patch. As usually only a fraction of the JSON value is affected by
+    the patch, the complexity can usually be neglected.
+
+    @liveexample{The following code shows how a JSON patch is applied to a
+    value.,patch}
+
+    @sa @ref diff -- create a JSON patch by comparing two JSON values
+
+    @sa [RFC 6902 (JSON Patch)](https://tools.ietf.org/html/rfc6902)
+    @sa [RFC 6901 (JSON Pointer)](https://tools.ietf.org/html/rfc6901)
+
+    @since version 2.0.0
+    */
+    basic_json patch(const basic_json& json_patch) const
+    {
+        // make a working copy to apply the patch to
+        basic_json result = *this;
+
+        // the valid JSON Patch operations
+        enum class patch_operations {add, remove, replace, move, copy, test, invalid};
+
+        const auto get_op = [](const std::string & op)
+        {
+            if (op == "add")
+            {
+                return patch_operations::add;
+            }
+            if (op == "remove")
+            {
+                return patch_operations::remove;
+            }
+            if (op == "replace")
+            {
+                return patch_operations::replace;
+            }
+            if (op == "move")
+            {
+                return patch_operations::move;
+            }
+            if (op == "copy")
+            {
+                return patch_operations::copy;
+            }
+            if (op == "test")
+            {
+                return patch_operations::test;
+            }
+
+            return patch_operations::invalid;
+        };
+
+        // wrapper for "add" operation; add value at ptr
+        const auto operation_add = [&result](json_pointer & ptr, basic_json val)
+        {
+            // adding to the root of the target document means replacing it
+            if (ptr.empty())
+            {
+                result = val;
+                return;
+            }
+
+            // make sure the top element of the pointer exists
+            json_pointer top_pointer = ptr.top();
+            if (top_pointer != ptr)
+            {
+                result.at(top_pointer);
+            }
+
+            // get reference to parent of JSON pointer ptr
+            const auto last_path = ptr.back();
+            ptr.pop_back();
+            basic_json& parent = result[ptr];
+
+            switch (parent.m_type)
+            {
+                case value_t::null:
+                case value_t::object:
+                {
+                    // use operator[] to add value
+                    parent[last_path] = val;
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    if (last_path == "-")
+                    {
+                        // special case: append to back
+                        parent.push_back(val);
+                    }
+                    else
+                    {
+                        const auto idx = json_pointer::array_index(last_path);
+                        if (JSON_HEDLEY_UNLIKELY(idx > parent.size()))
+                        {
+                            // avoid undefined behavior
+                            JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
+                        }
+
+                        // default case: insert add offset
+                        parent.insert(parent.begin() + static_cast<difference_type>(idx), val);
+                    }
+                    break;
+                }
+
+                // if there exists a parent it cannot be primitive
+                default:            // LCOV_EXCL_LINE
+                    JSON_ASSERT(false);  // LCOV_EXCL_LINE
+            }
+        };
+
+        // wrapper for "remove" operation; remove value at ptr
+        const auto operation_remove = [&result](json_pointer & ptr)
+        {
+            // get reference to parent of JSON pointer ptr
+            const auto last_path = ptr.back();
+            ptr.pop_back();
+            basic_json& parent = result.at(ptr);
+
+            // remove child
+            if (parent.is_object())
+            {
+                // perform range check
+                auto it = parent.find(last_path);
+                if (JSON_HEDLEY_LIKELY(it != parent.end()))
+                {
+                    parent.erase(it);
+                }
+                else
+                {
+                    JSON_THROW(out_of_range::create(403, "key '" + last_path + "' not found"));
+                }
+            }
+            else if (parent.is_array())
+            {
+                // note erase performs range check
+                parent.erase(json_pointer::array_index(last_path));
+            }
+        };
+
+        // type check: top level value must be an array
+        if (JSON_HEDLEY_UNLIKELY(!json_patch.is_array()))
+        {
+            JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));
+        }
+
+        // iterate and apply the operations
+        for (const auto& val : json_patch)
+        {
+            // wrapper to get a value for an operation
+            const auto get_value = [&val](const std::string & op,
+                                          const std::string & member,
+                                          bool string_type) -> basic_json &
+            {
+                // find value
+                auto it = val.m_value.object->find(member);
+
+                // context-sensitive error message
+                const auto error_msg = (op == "op") ? "operation" : "operation '" + op + "'";
+
+                // check if desired value is present
+                if (JSON_HEDLEY_UNLIKELY(it == val.m_value.object->end()))
+                {
+                    JSON_THROW(parse_error::create(105, 0, error_msg + " must have member '" + member + "'"));
+                }
+
+                // check if result is of type string
+                if (JSON_HEDLEY_UNLIKELY(string_type && !it->second.is_string()))
+                {
+                    JSON_THROW(parse_error::create(105, 0, error_msg + " must have string member '" + member + "'"));
+                }
+
+                // no error: return value
+                return it->second;
+            };
+
+            // type check: every element of the array must be an object
+            if (JSON_HEDLEY_UNLIKELY(!val.is_object()))
+            {
+                JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));
+            }
+
+            // collect mandatory members
+            const auto op = get_value("op", "op", true).template get<std::string>();
+            const auto path = get_value(op, "path", true).template get<std::string>();
+            json_pointer ptr(path);
+
+            switch (get_op(op))
+            {
+                case patch_operations::add:
+                {
+                    operation_add(ptr, get_value("add", "value", false));
+                    break;
+                }
+
+                case patch_operations::remove:
+                {
+                    operation_remove(ptr);
+                    break;
+                }
+
+                case patch_operations::replace:
+                {
+                    // the "path" location must exist - use at()
+                    result.at(ptr) = get_value("replace", "value", false);
+                    break;
+                }
+
+                case patch_operations::move:
+                {
+                    const auto from_path = get_value("move", "from", true).template get<std::string>();
+                    json_pointer from_ptr(from_path);
+
+                    // the "from" location must exist - use at()
+                    basic_json v = result.at(from_ptr);
+
+                    // The move operation is functionally identical to a
+                    // "remove" operation on the "from" location, followed
+                    // immediately by an "add" operation at the target
+                    // location with the value that was just removed.
+                    operation_remove(from_ptr);
+                    operation_add(ptr, v);
+                    break;
+                }
+
+                case patch_operations::copy:
+                {
+                    const auto from_path = get_value("copy", "from", true).template get<std::string>();
+                    const json_pointer from_ptr(from_path);
+
+                    // the "from" location must exist - use at()
+                    basic_json v = result.at(from_ptr);
+
+                    // The copy is functionally identical to an "add"
+                    // operation at the target location using the value
+                    // specified in the "from" member.
+                    operation_add(ptr, v);
+                    break;
+                }
+
+                case patch_operations::test:
+                {
+                    bool success = false;
+                    JSON_TRY
+                    {
+                        // check if "value" matches the one at "path"
+                        // the "path" location must exist - use at()
+                        success = (result.at(ptr) == get_value("test", "value", false));
+                    }
+                    JSON_INTERNAL_CATCH (out_of_range&)
+                    {
+                        // ignore out of range errors: success remains false
+                    }
+
+                    // throw an exception if test fails
+                    if (JSON_HEDLEY_UNLIKELY(!success))
+                    {
+                        JSON_THROW(other_error::create(501, "unsuccessful: " + val.dump()));
+                    }
+
+                    break;
+                }
+
+                default:
+                {
+                    // op must be "add", "remove", "replace", "move", "copy", or
+                    // "test"
+                    JSON_THROW(parse_error::create(105, 0, "operation value '" + op + "' is invalid"));
+                }
+            }
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief creates a diff as a JSON patch
+
+    Creates a [JSON Patch](http://jsonpatch.com) so that value @a source can
+    be changed into the value @a target by calling @ref patch function.
+
+    @invariant For two JSON values @a source and @a target, the following code
+    yields always `true`:
+    @code {.cpp}
+    source.patch(diff(source, target)) == target;
+    @endcode
+
+    @note Currently, only `remove`, `add`, and `replace` operations are
+          generated.
+
+    @param[in] source  JSON value to compare from
+    @param[in] target  JSON value to compare against
+    @param[in] path    helper value to create JSON pointers
+
+    @return a JSON patch to convert the @a source to @a target
+
+    @complexity Linear in the lengths of @a source and @a target.
+
+    @liveexample{The following code shows how a JSON patch is created as a
+    diff for two JSON values.,diff}
+
+    @sa @ref patch -- apply a JSON patch
+    @sa @ref merge_patch -- apply a JSON Merge Patch
+
+    @sa [RFC 6902 (JSON Patch)](https://tools.ietf.org/html/rfc6902)
+
+    @since version 2.0.0
+    */
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json diff(const basic_json& source, const basic_json& target,
+                           const std::string& path = "")
+    {
+        // the patch
+        basic_json result(value_t::array);
+
+        // if the values are the same, return empty patch
+        if (source == target)
+        {
+            return result;
+        }
+
+        if (source.type() != target.type())
+        {
+            // different types: replace value
+            result.push_back(
+            {
+                {"op", "replace"}, {"path", path}, {"value", target}
+            });
+            return result;
+        }
+
+        switch (source.type())
+        {
+            case value_t::array:
+            {
+                // first pass: traverse common elements
+                std::size_t i = 0;
+                while (i < source.size() && i < target.size())
+                {
+                    // recursive call to compare array values at index i
+                    auto temp_diff = diff(source[i], target[i], path + "/" + std::to_string(i));
+                    result.insert(result.end(), temp_diff.begin(), temp_diff.end());
+                    ++i;
+                }
+
+                // i now reached the end of at least one array
+                // in a second pass, traverse the remaining elements
+
+                // remove my remaining elements
+                const auto end_index = static_cast<difference_type>(result.size());
+                while (i < source.size())
+                {
+                    // add operations in reverse order to avoid invalid
+                    // indices
+                    result.insert(result.begin() + end_index, object(
+                    {
+                        {"op", "remove"},
+                        {"path", path + "/" + std::to_string(i)}
+                    }));
+                    ++i;
+                }
+
+                // add other remaining elements
+                while (i < target.size())
+                {
+                    result.push_back(
+                    {
+                        {"op", "add"},
+                        {"path", path + "/-"},
+                        {"value", target[i]}
+                    });
+                    ++i;
+                }
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                // first pass: traverse this object's elements
+                for (auto it = source.cbegin(); it != source.cend(); ++it)
+                {
+                    // escape the key name to be used in a JSON patch
+                    const auto key = json_pointer::escape(it.key());
+
+                    if (target.find(it.key()) != target.end())
+                    {
+                        // recursive call to compare object values at key it
+                        auto temp_diff = diff(it.value(), target[it.key()], path + "/" + key);
+                        result.insert(result.end(), temp_diff.begin(), temp_diff.end());
+                    }
+                    else
+                    {
+                        // found a key that is not in o -> remove it
+                        result.push_back(object(
+                        {
+                            {"op", "remove"}, {"path", path + "/" + key}
+                        }));
+                    }
+                }
+
+                // second pass: traverse other object's elements
+                for (auto it = target.cbegin(); it != target.cend(); ++it)
+                {
+                    if (source.find(it.key()) == source.end())
+                    {
+                        // found a key that is not in this -> add it
+                        const auto key = json_pointer::escape(it.key());
+                        result.push_back(
+                        {
+                            {"op", "add"}, {"path", path + "/" + key},
+                            {"value", it.value()}
+                        });
+                    }
+                }
+
+                break;
+            }
+
+            default:
+            {
+                // both primitive type: replace value
+                result.push_back(
+                {
+                    {"op", "replace"}, {"path", path}, {"value", target}
+                });
+                break;
+            }
+        }
+
+        return result;
+    }
+
+    /// @}
+
+    ////////////////////////////////
+    // JSON Merge Patch functions //
+    ////////////////////////////////
+
+    /// @name JSON Merge Patch functions
+    /// @{
+
+    /*!
+    @brief applies a JSON Merge Patch
+
+    The merge patch format is primarily intended for use with the HTTP PATCH
+    method as a means of describing a set of modifications to a target
+    resource's content. This function applies a merge patch to the current
+    JSON value.
+
+    The function implements the following algorithm from Section 2 of
+    [RFC 7396 (JSON Merge Patch)](https://tools.ietf.org/html/rfc7396):
+
+    ```
+    define MergePatch(Target, Patch):
+      if Patch is an Object:
+        if Target is not an Object:
+          Target = {} // Ignore the contents and set it to an empty Object
+        for each Name/Value pair in Patch:
+          if Value is null:
+            if Name exists in Target:
+              remove the Name/Value pair from Target
+          else:
+            Target[Name] = MergePatch(Target[Name], Value)
+        return Target
+      else:
+        return Patch
+    ```
+
+    Thereby, `Target` is the current object; that is, the patch is applied to
+    the current value.
+
+    @param[in] apply_patch  the patch to apply
+
+    @complexity Linear in the lengths of @a patch.
+
+    @liveexample{The following code shows how a JSON Merge Patch is applied to
+    a JSON document.,merge_patch}
+
+    @sa @ref patch -- apply a JSON patch
+    @sa [RFC 7396 (JSON Merge Patch)](https://tools.ietf.org/html/rfc7396)
+
+    @since version 3.0.0
+    */
+    void merge_patch(const basic_json& apply_patch)
+    {
+        if (apply_patch.is_object())
+        {
+            if (!is_object())
+            {
+                *this = object();
+            }
+            for (auto it = apply_patch.begin(); it != apply_patch.end(); ++it)
+            {
+                if (it.value().is_null())
+                {
+                    erase(it.key());
+                }
+                else
+                {
+                    operator[](it.key()).merge_patch(it.value());
+                }
+            }
+        }
+        else
+        {
+            *this = apply_patch;
+        }
+    }
+
+    /// @}
+
+    // template<typename T> inline bool is() const = delete;
+    // template<typename T> inline T as() const;
+};
+
+/*!
+@brief user-defined to_string function for JSON values
+
+This function implements a user-defined to_string  for JSON objects.
+
+@param[in] j  a JSON object
+@return a std::string object
+*/
+
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+std::string to_string(const NLOHMANN_BASIC_JSON_TPL& j)
+{
+    return j.dump();
+}
+} // namespace nlohmann
+
+///////////////////////
+// nonmember support //
+///////////////////////
+
+// specialization of std::swap, and std::hash
+namespace std
+{
+
+/// hash value for JSON objects
+template<>
+struct hash<nlohmann::json>
+{
+    /*!
+    @brief return a hash value for a JSON object
+
+    @since version 1.0.0
+    */
+    std::size_t operator()(const nlohmann::json& j) const
+    {
+        return nlohmann::detail::hash(j);
+    }
+};
+
+/// specialization for std::less<value_t>
+/// @note: do not remove the space after '<',
+///        see https://github.com/nlohmann/json/pull/679
+template<>
+struct less<::nlohmann::detail::value_t>
+{
+    /*!
+    @brief compare two value_t enum values
+    @since version 3.0.0
+    */
+    bool operator()(nlohmann::detail::value_t lhs,
+                    nlohmann::detail::value_t rhs) const noexcept
+    {
+        return nlohmann::detail::operator<(lhs, rhs);
+    }
+};
+
+// C++20 prohibit function specialization in the std namespace.
+#ifndef JSON_HAS_CPP_20
+
+/*!
+@brief exchanges the values of two JSON objects
+
+@since version 1.0.0
+*/
+template<>
+inline void swap<nlohmann::json>(nlohmann::json& j1, nlohmann::json& j2) noexcept(
+    is_nothrow_move_constructible<nlohmann::json>::value&&
+    is_nothrow_move_assignable<nlohmann::json>::value
+                              )
+{
+    j1.swap(j2);
+}
+
+#endif
+
+} // namespace std
+
+/*!
+@brief user-defined string literal for JSON values
+
+This operator implements a user-defined string literal for JSON objects. It
+can be used by adding `"_json"` to a string literal and returns a JSON object
+if no parse error occurred.
+
+@param[in] s  a string representation of a JSON object
+@param[in] n  the length of string @a s
+@return a JSON object
+
+@since version 1.0.0
+*/
+JSON_HEDLEY_NON_NULL(1)
+inline nlohmann::json operator "" _json(const char* s, std::size_t n)
+{
+    return nlohmann::json::parse(s, s + n);
+}
+
+/*!
+@brief user-defined string literal for JSON pointer
+
+This operator implements a user-defined string literal for JSON Pointers. It
+can be used by adding `"_json_pointer"` to a string literal and returns a JSON pointer
+object if no parse error occurred.
+
+@param[in] s  a string representation of a JSON Pointer
+@param[in] n  the length of string @a s
+@return a JSON pointer object
+
+@since version 2.0.0
+*/
+JSON_HEDLEY_NON_NULL(1)
+inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)
+{
+    return nlohmann::json::json_pointer(std::string(s, n));
+}
+
+// #include <nlohmann/detail/macro_unscope.hpp>
+
+
+// restore GCC/clang diagnostic settings
+#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
+    #pragma GCC diagnostic pop
+#endif
+#if defined(__clang__)
+    #pragma GCC diagnostic pop
+#endif
+
+// clean up
+#undef JSON_ASSERT
+#undef JSON_INTERNAL_CATCH
+#undef JSON_CATCH
+#undef JSON_THROW
+#undef JSON_TRY
+#undef JSON_PRIVATE_UNLESS_TESTED
+#undef JSON_PROTECTED_UNLESS_TESTED
+#undef JSON_HAS_CPP_14
+#undef JSON_HAS_CPP_17
+#undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
+#undef NLOHMANN_BASIC_JSON_TPL
+#undef JSON_EXPLICIT
+
+// #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>
+#undef JSON_HEDLEY_ALWAYS_INLINE
+#undef JSON_HEDLEY_ARM_VERSION
+#undef JSON_HEDLEY_ARM_VERSION_CHECK
+#undef JSON_HEDLEY_ARRAY_PARAM
+#undef JSON_HEDLEY_ASSUME
+#undef JSON_HEDLEY_BEGIN_C_DECLS
+#undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_BUILTIN
+#undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_EXTENSION
+#undef JSON_HEDLEY_CLANG_HAS_FEATURE
+#undef JSON_HEDLEY_CLANG_HAS_WARNING
+#undef JSON_HEDLEY_COMPCERT_VERSION
+#undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
+#undef JSON_HEDLEY_CONCAT
+#undef JSON_HEDLEY_CONCAT3
+#undef JSON_HEDLEY_CONCAT3_EX
+#undef JSON_HEDLEY_CONCAT_EX
+#undef JSON_HEDLEY_CONST
+#undef JSON_HEDLEY_CONSTEXPR
+#undef JSON_HEDLEY_CONST_CAST
+#undef JSON_HEDLEY_CPP_CAST
+#undef JSON_HEDLEY_CRAY_VERSION
+#undef JSON_HEDLEY_CRAY_VERSION_CHECK
+#undef JSON_HEDLEY_C_DECL
+#undef JSON_HEDLEY_DEPRECATED
+#undef JSON_HEDLEY_DEPRECATED_FOR
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
+#undef JSON_HEDLEY_DIAGNOSTIC_POP
+#undef JSON_HEDLEY_DIAGNOSTIC_PUSH
+#undef JSON_HEDLEY_DMC_VERSION
+#undef JSON_HEDLEY_DMC_VERSION_CHECK
+#undef JSON_HEDLEY_EMPTY_BASES
+#undef JSON_HEDLEY_EMSCRIPTEN_VERSION
+#undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
+#undef JSON_HEDLEY_END_C_DECLS
+#undef JSON_HEDLEY_FLAGS
+#undef JSON_HEDLEY_FLAGS_CAST
+#undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_GCC_HAS_BUILTIN
+#undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_GCC_HAS_EXTENSION
+#undef JSON_HEDLEY_GCC_HAS_FEATURE
+#undef JSON_HEDLEY_GCC_HAS_WARNING
+#undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
+#undef JSON_HEDLEY_GCC_VERSION
+#undef JSON_HEDLEY_GCC_VERSION_CHECK
+#undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_GNUC_HAS_BUILTIN
+#undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_GNUC_HAS_EXTENSION
+#undef JSON_HEDLEY_GNUC_HAS_FEATURE
+#undef JSON_HEDLEY_GNUC_HAS_WARNING
+#undef JSON_HEDLEY_GNUC_VERSION
+#undef JSON_HEDLEY_GNUC_VERSION_CHECK
+#undef JSON_HEDLEY_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_HAS_BUILTIN
+#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
+#undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_HAS_EXTENSION
+#undef JSON_HEDLEY_HAS_FEATURE
+#undef JSON_HEDLEY_HAS_WARNING
+#undef JSON_HEDLEY_IAR_VERSION
+#undef JSON_HEDLEY_IAR_VERSION_CHECK
+#undef JSON_HEDLEY_IBM_VERSION
+#undef JSON_HEDLEY_IBM_VERSION_CHECK
+#undef JSON_HEDLEY_IMPORT
+#undef JSON_HEDLEY_INLINE
+#undef JSON_HEDLEY_INTEL_CL_VERSION
+#undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
+#undef JSON_HEDLEY_INTEL_VERSION
+#undef JSON_HEDLEY_INTEL_VERSION_CHECK
+#undef JSON_HEDLEY_IS_CONSTANT
+#undef JSON_HEDLEY_IS_CONSTEXPR_
+#undef JSON_HEDLEY_LIKELY
+#undef JSON_HEDLEY_MALLOC
+#undef JSON_HEDLEY_MESSAGE
+#undef JSON_HEDLEY_MSVC_VERSION
+#undef JSON_HEDLEY_MSVC_VERSION_CHECK
+#undef JSON_HEDLEY_NEVER_INLINE
+#undef JSON_HEDLEY_NON_NULL
+#undef JSON_HEDLEY_NO_ESCAPE
+#undef JSON_HEDLEY_NO_RETURN
+#undef JSON_HEDLEY_NO_THROW
+#undef JSON_HEDLEY_NULL
+#undef JSON_HEDLEY_PELLES_VERSION
+#undef JSON_HEDLEY_PELLES_VERSION_CHECK
+#undef JSON_HEDLEY_PGI_VERSION
+#undef JSON_HEDLEY_PGI_VERSION_CHECK
+#undef JSON_HEDLEY_PREDICT
+#undef JSON_HEDLEY_PRINTF_FORMAT
+#undef JSON_HEDLEY_PRIVATE
+#undef JSON_HEDLEY_PUBLIC
+#undef JSON_HEDLEY_PURE
+#undef JSON_HEDLEY_REINTERPRET_CAST
+#undef JSON_HEDLEY_REQUIRE
+#undef JSON_HEDLEY_REQUIRE_CONSTEXPR
+#undef JSON_HEDLEY_REQUIRE_MSG
+#undef JSON_HEDLEY_RESTRICT
+#undef JSON_HEDLEY_RETURNS_NON_NULL
+#undef JSON_HEDLEY_SENTINEL
+#undef JSON_HEDLEY_STATIC_ASSERT
+#undef JSON_HEDLEY_STATIC_CAST
+#undef JSON_HEDLEY_STRINGIFY
+#undef JSON_HEDLEY_STRINGIFY_EX
+#undef JSON_HEDLEY_SUNPRO_VERSION
+#undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
+#undef JSON_HEDLEY_TINYC_VERSION
+#undef JSON_HEDLEY_TINYC_VERSION_CHECK
+#undef JSON_HEDLEY_TI_ARMCL_VERSION
+#undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL2000_VERSION
+#undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL430_VERSION
+#undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL6X_VERSION
+#undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL7X_VERSION
+#undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CLPRU_VERSION
+#undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
+#undef JSON_HEDLEY_TI_VERSION
+#undef JSON_HEDLEY_TI_VERSION_CHECK
+#undef JSON_HEDLEY_UNAVAILABLE
+#undef JSON_HEDLEY_UNLIKELY
+#undef JSON_HEDLEY_UNPREDICTABLE
+#undef JSON_HEDLEY_UNREACHABLE
+#undef JSON_HEDLEY_UNREACHABLE_RETURN
+#undef JSON_HEDLEY_VERSION
+#undef JSON_HEDLEY_VERSION_DECODE_MAJOR
+#undef JSON_HEDLEY_VERSION_DECODE_MINOR
+#undef JSON_HEDLEY_VERSION_DECODE_REVISION
+#undef JSON_HEDLEY_VERSION_ENCODE
+#undef JSON_HEDLEY_WARNING
+#undef JSON_HEDLEY_WARN_UNUSED_RESULT
+#undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
+#undef JSON_HEDLEY_FALL_THROUGH
+
+
+
+#endif  // INCLUDE_NLOHMANN_JSON_HPP_
\ No newline at end of file
diff --git a/engine/inc/openvr-x/openvr.h b/engine/inc/openvr-x/openvr.h
new file mode 100644
index 00000000..ec26ef41
--- /dev/null
+++ b/engine/inc/openvr-x/openvr.h
@@ -0,0 +1,5505 @@
+#pragma once
+
+// openvr.h
+//========= Copyright Valve Corporation ============//
+// Dynamically generated file. Do not modify this file directly.
+
+#ifndef _OPENVR_API
+#define _OPENVR_API
+
+#include <stdint.h>
+
+
+
+// version.h
+namespace vr
+{
+	static const uint32_t k_nSteamVRVersionMajor = 1;
+	static const uint32_t k_nSteamVRVersionMinor = 11;
+	static const uint32_t k_nSteamVRVersionBuild = 11;
+} // namespace vr
+
+// vrtypes.h
+#ifndef _INCLUDE_VRTYPES_H
+#define _INCLUDE_VRTYPES_H
+
+// Forward declarations to avoid requiring vulkan.h
+struct VkDevice_T;
+struct VkPhysicalDevice_T;
+struct VkInstance_T;
+struct VkQueue_T;
+
+// Forward declarations to avoid requiring d3d12.h
+struct ID3D12Resource;
+struct ID3D12CommandQueue;
+
+namespace vr
+{
+#pragma pack( push, 8 )
+
+/** A handle for a spatial anchor.  This handle is only valid during the session it was created in.
+* Anchors that live beyond one session should be saved by their string descriptors. */
+typedef uint32_t SpatialAnchorHandle_t;
+
+typedef void* glSharedTextureHandle_t;
+typedef int32_t glInt_t;
+typedef uint32_t glUInt_t;
+
+// right-handed system
+// +y is up
+// +x is to the right
+// -z is forward
+// Distance unit is  meters
+struct HmdMatrix34_t
+{
+	float m[3][4];
+};
+
+struct HmdMatrix33_t
+{
+	float m[3][3];
+};
+
+struct HmdMatrix44_t
+{
+	float m[4][4];
+};
+
+struct HmdVector3_t
+{
+	float v[3];
+};
+
+struct HmdVector4_t
+{
+	float v[4];
+};
+
+struct HmdVector3d_t
+{
+	double v[3];
+};
+
+struct HmdVector2_t
+{
+	float v[2];
+};
+
+struct HmdQuaternion_t
+{
+	double w, x, y, z;
+};
+
+struct HmdQuaternionf_t
+{
+	float w, x, y, z;
+};
+
+struct HmdColor_t
+{
+	float r, g, b, a;
+};
+
+struct HmdQuad_t
+{
+	HmdVector3_t vCorners[ 4 ];
+};
+
+struct HmdRect2_t
+{
+	HmdVector2_t vTopLeft;
+	HmdVector2_t vBottomRight;
+};
+
+/** Used to return the post-distortion UVs for each color channel. 
+* UVs range from 0 to 1 with 0,0 in the upper left corner of the 
+* source render target. The 0,0 to 1,1 range covers a single eye. */
+struct DistortionCoordinates_t
+{
+	float rfRed[2];
+	float rfGreen[2];
+	float rfBlue[2];
+};
+
+enum EVREye
+{
+	Eye_Left = 0,
+	Eye_Right = 1
+};
+
+enum ETextureType
+{
+	TextureType_Invalid = -1, // Handle has been invalidated
+	TextureType_DirectX = 0, // Handle is an ID3D11Texture
+	TextureType_OpenGL = 1,  // Handle is an OpenGL texture name or an OpenGL render buffer name, depending on submit flags
+	TextureType_Vulkan = 2, // Handle is a pointer to a VRVulkanTextureData_t structure
+	TextureType_IOSurface = 3, // Handle is a macOS cross-process-sharable IOSurfaceRef, deprecated in favor of TextureType_Metal on supported platforms
+	TextureType_DirectX12 = 4, // Handle is a pointer to a D3D12TextureData_t structure
+	TextureType_DXGISharedHandle = 5, // Handle is a HANDLE DXGI share handle, only supported for Overlay render targets. 
+									  // this texture is used directly by our renderer, so only perform atomic (copyresource or resolve) on it
+	TextureType_Metal = 6, // Handle is a MTLTexture conforming to the MTLSharedTexture protocol. Textures submitted to IVRCompositor::Submit which
+						   // are of type MTLTextureType2DArray assume layer 0 is the left eye texture (vr::EVREye::Eye_left), layer 1 is the right
+						   // eye texture (vr::EVREye::Eye_Right)
+};
+
+enum EColorSpace
+{
+	ColorSpace_Auto = 0,	// Assumes 'gamma' for 8-bit per component formats, otherwise 'linear'.  This mirrors the DXGI formats which have _SRGB variants.
+	ColorSpace_Gamma = 1,	// Texture data can be displayed directly on the display without any conversion (a.k.a. display native format).
+	ColorSpace_Linear = 2,	// Same as gamma but has been converted to a linear representation using DXGI's sRGB conversion algorithm.
+};
+
+struct Texture_t
+{
+	void* handle; // See ETextureType definition above
+	ETextureType eType;
+	EColorSpace eColorSpace;
+};
+
+// Handle to a shared texture (HANDLE on Windows obtained using OpenSharedResource).
+typedef uint64_t SharedTextureHandle_t;
+#define INVALID_SHARED_TEXTURE_HANDLE	((vr::SharedTextureHandle_t)0)
+
+enum ETrackingResult
+{
+	TrackingResult_Uninitialized			= 1,
+
+	TrackingResult_Calibrating_InProgress	= 100,
+	TrackingResult_Calibrating_OutOfRange	= 101,
+
+	TrackingResult_Running_OK				= 200,
+	TrackingResult_Running_OutOfRange		= 201,
+
+	TrackingResult_Fallback_RotationOnly	= 300,
+};
+
+typedef uint32_t DriverId_t;
+static const uint32_t k_nDriverNone = 0xFFFFFFFF;
+
+static const uint32_t k_unMaxDriverDebugResponseSize = 32768;
+
+/** Used to pass device IDs to API calls */
+typedef uint32_t TrackedDeviceIndex_t;
+static const uint32_t k_unTrackedDeviceIndex_Hmd = 0;
+static const uint32_t k_unMaxTrackedDeviceCount = 64;
+static const uint32_t k_unTrackedDeviceIndexOther = 0xFFFFFFFE;
+static const uint32_t k_unTrackedDeviceIndexInvalid = 0xFFFFFFFF;
+
+/** Describes what kind of object is being tracked at a given ID */
+enum ETrackedDeviceClass
+{
+	TrackedDeviceClass_Invalid = 0,				// the ID was not valid.
+	TrackedDeviceClass_HMD = 1,					// Head-Mounted Displays
+	TrackedDeviceClass_Controller = 2,			// Tracked controllers
+	TrackedDeviceClass_GenericTracker = 3,		// Generic trackers, similar to controllers
+	TrackedDeviceClass_TrackingReference = 4,	// Camera and base stations that serve as tracking reference points
+	TrackedDeviceClass_DisplayRedirect = 5,		// Accessories that aren't necessarily tracked themselves, but may redirect video output from other tracked devices
+
+	TrackedDeviceClass_Max
+};
+
+
+/** Describes what specific role associated with a tracked device */
+enum ETrackedControllerRole
+{
+	TrackedControllerRole_Invalid = 0,					// Invalid value for controller type
+	TrackedControllerRole_LeftHand = 1,					// Tracked device associated with the left hand
+	TrackedControllerRole_RightHand = 2,				// Tracked device associated with the right hand
+	TrackedControllerRole_OptOut = 3,					// Tracked device is opting out of left/right hand selection
+	TrackedControllerRole_Treadmill = 4,				// Tracked device is a treadmill or other locomotion device
+	TrackedControllerRole_Stylus = 5,					// Tracked device is a stylus
+	TrackedControllerRole_Max = 5
+};
+
+
+/** Returns true if the tracked controller role is allowed to be a hand */
+inline bool IsRoleAllowedAsHand( ETrackedControllerRole eRole )
+{
+	switch ( eRole )
+	{
+	case TrackedControllerRole_Invalid:
+	case TrackedControllerRole_LeftHand:
+	case TrackedControllerRole_RightHand:
+		return true;
+	default:
+		return false;
+	}
+}
+
+
+/** describes a single pose for a tracked object */
+struct TrackedDevicePose_t
+{
+	HmdMatrix34_t mDeviceToAbsoluteTracking;
+	HmdVector3_t vVelocity;				// velocity in tracker space in m/s
+	HmdVector3_t vAngularVelocity;		// angular velocity in radians/s (?)
+	ETrackingResult eTrackingResult;
+	bool bPoseIsValid;
+
+	// This indicates that there is a device connected for this spot in the pose array.
+	// It could go from true to false if the user unplugs the device.
+	bool bDeviceIsConnected;
+};
+
+/** Identifies which style of tracking origin the application wants to use
+* for the poses it is requesting */
+enum ETrackingUniverseOrigin
+{
+	TrackingUniverseSeated = 0,		// Poses are provided relative to the seated zero pose
+	TrackingUniverseStanding = 1,	// Poses are provided relative to the safe bounds configured by the user
+	TrackingUniverseRawAndUncalibrated = 2,	// Poses are provided in the coordinate system defined by the driver.  It has Y up and is unified for devices of the same driver. You usually don't want this one.
+};
+
+enum EAdditionalRadioFeatures
+{
+	AdditionalRadioFeatures_None           = 0x00000000,
+	AdditionalRadioFeatures_HTCLinkBox     = 0x00000001,
+	AdditionalRadioFeatures_InternalDongle = 0x00000002,
+	AdditionalRadioFeatures_ExternalDongle = 0x00000004,
+};
+
+typedef uint64_t WebConsoleHandle_t;
+#define INVALID_WEB_CONSOLE_HANDLE	((vr::WebConsoleHandle_t)0)
+
+// Refers to a single container of properties
+typedef uint64_t PropertyContainerHandle_t;
+typedef uint32_t PropertyTypeTag_t;
+
+static const PropertyContainerHandle_t k_ulInvalidPropertyContainer = 0;
+static const PropertyTypeTag_t k_unInvalidPropertyTag = 0;
+
+typedef PropertyContainerHandle_t DriverHandle_t;
+static const PropertyContainerHandle_t k_ulInvalidDriverHandle = 0;
+
+// Use these tags to set/get common types as struct properties
+static const PropertyTypeTag_t k_unFloatPropertyTag = 1;
+static const PropertyTypeTag_t k_unInt32PropertyTag = 2;
+static const PropertyTypeTag_t k_unUint64PropertyTag = 3;
+static const PropertyTypeTag_t k_unBoolPropertyTag = 4;
+static const PropertyTypeTag_t k_unStringPropertyTag = 5;
+static const PropertyTypeTag_t k_unErrorPropertyTag = 6;
+static const PropertyTypeTag_t k_unDoublePropertyTag = 7;
+
+static const PropertyTypeTag_t k_unHmdMatrix34PropertyTag = 20;
+static const PropertyTypeTag_t k_unHmdMatrix44PropertyTag = 21;
+static const PropertyTypeTag_t k_unHmdVector3PropertyTag = 22;
+static const PropertyTypeTag_t k_unHmdVector4PropertyTag = 23;
+static const PropertyTypeTag_t k_unHmdVector2PropertyTag = 24;
+static const PropertyTypeTag_t k_unHmdQuadPropertyTag = 25;
+
+static const PropertyTypeTag_t k_unHiddenAreaPropertyTag = 30;
+static const PropertyTypeTag_t k_unPathHandleInfoTag = 31;
+static const PropertyTypeTag_t k_unActionPropertyTag = 32;
+static const PropertyTypeTag_t k_unInputValuePropertyTag = 33;
+static const PropertyTypeTag_t k_unWildcardPropertyTag = 34;
+static const PropertyTypeTag_t k_unHapticVibrationPropertyTag = 35;
+static const PropertyTypeTag_t k_unSkeletonPropertyTag = 36;
+
+static const PropertyTypeTag_t k_unSpatialAnchorPosePropertyTag = 40;
+static const PropertyTypeTag_t k_unJsonPropertyTag = 41;
+static const PropertyTypeTag_t k_unActiveActionSetPropertyTag = 42;
+
+static const PropertyTypeTag_t k_unOpenVRInternalReserved_Start = 1000;
+static const PropertyTypeTag_t k_unOpenVRInternalReserved_End = 10000;
+
+
+/** Each entry in this enum represents a property that can be retrieved about a
+* tracked device. Many fields are only valid for one ETrackedDeviceClass. */
+enum ETrackedDeviceProperty
+{
+	Prop_Invalid								= 0,
+
+	// general properties that apply to all device classes
+	Prop_TrackingSystemName_String				= 1000,
+	Prop_ModelNumber_String						= 1001,
+	Prop_SerialNumber_String					= 1002,
+	Prop_RenderModelName_String					= 1003,
+	Prop_WillDriftInYaw_Bool					= 1004,
+	Prop_ManufacturerName_String				= 1005,
+	Prop_TrackingFirmwareVersion_String			= 1006,
+	Prop_HardwareRevision_String				= 1007,
+	Prop_AllWirelessDongleDescriptions_String	= 1008,
+	Prop_ConnectedWirelessDongle_String			= 1009,
+	Prop_DeviceIsWireless_Bool					= 1010,
+	Prop_DeviceIsCharging_Bool					= 1011,
+	Prop_DeviceBatteryPercentage_Float			= 1012, // 0 is empty, 1 is full
+	Prop_StatusDisplayTransform_Matrix34		= 1013,
+	Prop_Firmware_UpdateAvailable_Bool			= 1014,
+	Prop_Firmware_ManualUpdate_Bool				= 1015,
+	Prop_Firmware_ManualUpdateURL_String		= 1016,
+	Prop_HardwareRevision_Uint64				= 1017,
+	Prop_FirmwareVersion_Uint64					= 1018,
+	Prop_FPGAVersion_Uint64						= 1019,
+	Prop_VRCVersion_Uint64						= 1020,
+	Prop_RadioVersion_Uint64					= 1021,
+	Prop_DongleVersion_Uint64					= 1022,
+	Prop_BlockServerShutdown_Bool				= 1023,
+	Prop_CanUnifyCoordinateSystemWithHmd_Bool	= 1024,
+	Prop_ContainsProximitySensor_Bool			= 1025,
+	Prop_DeviceProvidesBatteryStatus_Bool		= 1026,
+	Prop_DeviceCanPowerOff_Bool					= 1027,
+	Prop_Firmware_ProgrammingTarget_String		= 1028,
+	Prop_DeviceClass_Int32						= 1029,
+	Prop_HasCamera_Bool							= 1030,
+	Prop_DriverVersion_String                   = 1031,
+	Prop_Firmware_ForceUpdateRequired_Bool      = 1032,
+	Prop_ViveSystemButtonFixRequired_Bool		= 1033,
+	Prop_ParentDriver_Uint64					= 1034,
+	Prop_ResourceRoot_String					= 1035,
+	Prop_RegisteredDeviceType_String			= 1036,
+	Prop_InputProfilePath_String				= 1037, // input profile to use for this device in the input system. Will default to tracking system name if this isn't provided
+	Prop_NeverTracked_Bool						= 1038, // Used for devices that will never have a valid pose by design
+	Prop_NumCameras_Int32						= 1039,
+	Prop_CameraFrameLayout_Int32				= 1040, // EVRTrackedCameraFrameLayout value
+	Prop_CameraStreamFormat_Int32				= 1041, // ECameraVideoStreamFormat value
+	Prop_AdditionalDeviceSettingsPath_String	= 1042, // driver-relative path to additional device and global configuration settings
+	Prop_Identifiable_Bool						= 1043, // Whether device supports being identified from vrmonitor (e.g. blink LED, vibrate haptics, etc)
+	Prop_BootloaderVersion_Uint64			    = 1044,
+	Prop_AdditionalSystemReportData_String		= 1045, // additional string to include in system reports about a tracked device
+	Prop_CompositeFirmwareVersion_String        = 1046, // additional FW components from a device that gets propagated into reports
+	Prop_Firmware_RemindUpdate_Bool             = 1047,
+	Prop_PeripheralApplicationVersion_Uint64	= 1048,
+	Prop_ManufacturerSerialNumber_String		= 1049,
+	Prop_ComputedSerialNumber_String			= 1050,
+	Prop_EstimatedDeviceFirstUseTime_Int32		= 1051,
+
+	// Properties that are unique to TrackedDeviceClass_HMD
+	Prop_ReportsTimeSinceVSync_Bool				= 2000,
+	Prop_SecondsFromVsyncToPhotons_Float		= 2001,
+	Prop_DisplayFrequency_Float					= 2002,
+	Prop_UserIpdMeters_Float					= 2003,
+	Prop_CurrentUniverseId_Uint64				= 2004, 
+	Prop_PreviousUniverseId_Uint64				= 2005, 
+	Prop_DisplayFirmwareVersion_Uint64			= 2006,
+	Prop_IsOnDesktop_Bool						= 2007,
+	Prop_DisplayMCType_Int32					= 2008,
+	Prop_DisplayMCOffset_Float					= 2009,
+	Prop_DisplayMCScale_Float					= 2010,
+	Prop_EdidVendorID_Int32						= 2011,
+	Prop_DisplayMCImageLeft_String              = 2012,
+	Prop_DisplayMCImageRight_String             = 2013,
+	Prop_DisplayGCBlackClamp_Float				= 2014,
+	Prop_EdidProductID_Int32					= 2015,
+	Prop_CameraToHeadTransform_Matrix34			= 2016,
+	Prop_DisplayGCType_Int32					= 2017,
+	Prop_DisplayGCOffset_Float					= 2018,
+	Prop_DisplayGCScale_Float					= 2019,
+	Prop_DisplayGCPrescale_Float				= 2020,
+	Prop_DisplayGCImage_String					= 2021,
+	Prop_LensCenterLeftU_Float					= 2022,
+	Prop_LensCenterLeftV_Float					= 2023,
+	Prop_LensCenterRightU_Float					= 2024,
+	Prop_LensCenterRightV_Float					= 2025,
+	Prop_UserHeadToEyeDepthMeters_Float			= 2026,
+	Prop_CameraFirmwareVersion_Uint64			= 2027,
+	Prop_CameraFirmwareDescription_String		= 2028,
+	Prop_DisplayFPGAVersion_Uint64				= 2029,
+	Prop_DisplayBootloaderVersion_Uint64		= 2030,
+	Prop_DisplayHardwareVersion_Uint64			= 2031,
+	Prop_AudioFirmwareVersion_Uint64			= 2032,
+	Prop_CameraCompatibilityMode_Int32			= 2033,
+	Prop_ScreenshotHorizontalFieldOfViewDegrees_Float = 2034,
+	Prop_ScreenshotVerticalFieldOfViewDegrees_Float = 2035,
+	Prop_DisplaySuppressed_Bool					= 2036,
+	Prop_DisplayAllowNightMode_Bool				= 2037,
+	Prop_DisplayMCImageWidth_Int32				= 2038,
+	Prop_DisplayMCImageHeight_Int32				= 2039,
+	Prop_DisplayMCImageNumChannels_Int32		= 2040,
+	Prop_DisplayMCImageData_Binary				= 2041,
+	Prop_SecondsFromPhotonsToVblank_Float		= 2042,
+	Prop_DriverDirectModeSendsVsyncEvents_Bool	= 2043,
+	Prop_DisplayDebugMode_Bool					= 2044,
+	Prop_GraphicsAdapterLuid_Uint64				= 2045,
+	Prop_DriverProvidedChaperonePath_String		= 2048,
+	Prop_ExpectedTrackingReferenceCount_Int32	= 2049, // expected number of sensors or basestations to reserve UI space for
+	Prop_ExpectedControllerCount_Int32			= 2050, // expected number of tracked controllers to reserve UI space for
+	Prop_NamedIconPathControllerLeftDeviceOff_String	= 2051, // placeholder icon for "left" controller if not yet detected/loaded
+	Prop_NamedIconPathControllerRightDeviceOff_String	= 2052, // placeholder icon for "right" controller if not yet detected/loaded
+	Prop_NamedIconPathTrackingReferenceDeviceOff_String	= 2053, // placeholder icon for sensor/base if not yet detected/loaded
+	Prop_DoNotApplyPrediction_Bool				= 2054, // currently no effect. was used to disable HMD pose prediction on MR, which is now done by MR driver setting velocity=0
+	Prop_CameraToHeadTransforms_Matrix34_Array	= 2055,
+	Prop_DistortionMeshResolution_Int32			= 2056, // custom resolution of compositor calls to IVRSystem::ComputeDistortion
+	Prop_DriverIsDrawingControllers_Bool		= 2057,
+	Prop_DriverRequestsApplicationPause_Bool	= 2058,
+	Prop_DriverRequestsReducedRendering_Bool	= 2059,
+	Prop_MinimumIpdStepMeters_Float				= 2060,
+	Prop_AudioBridgeFirmwareVersion_Uint64		= 2061,
+	Prop_ImageBridgeFirmwareVersion_Uint64		= 2062,
+	Prop_ImuToHeadTransform_Matrix34			= 2063,
+	Prop_ImuFactoryGyroBias_Vector3				= 2064,
+	Prop_ImuFactoryGyroScale_Vector3			= 2065,
+	Prop_ImuFactoryAccelerometerBias_Vector3	= 2066,
+	Prop_ImuFactoryAccelerometerScale_Vector3	= 2067,
+	// reserved 2068
+	Prop_ConfigurationIncludesLighthouse20Features_Bool = 2069,
+	Prop_AdditionalRadioFeatures_Uint64         = 2070,
+	Prop_CameraWhiteBalance_Vector4_Array		= 2071, // Prop_NumCameras_Int32-sized array of float[4] RGBG white balance calibration data (max size is vr::k_unMaxCameras)
+	Prop_CameraDistortionFunction_Int32_Array	= 2072, // Prop_NumCameras_Int32-sized array of vr::EVRDistortionFunctionType values (max size is vr::k_unMaxCameras)
+	Prop_CameraDistortionCoefficients_Float_Array = 2073, // Prop_NumCameras_Int32-sized array of double[vr::k_unMaxDistortionFunctionParameters] (max size is vr::k_unMaxCameras)
+	Prop_ExpectedControllerType_String			= 2074,
+	Prop_HmdTrackingStyle_Int32					= 2075, // one of EHmdTrackingStyle
+	Prop_DriverProvidedChaperoneVisibility_Bool = 2076,
+	Prop_HmdColumnCorrectionSettingPrefix_String = 2077,
+	Prop_CameraSupportsCompatibilityModes_Bool	= 2078,
+
+	Prop_DisplayAvailableFrameRates_Float_Array = 2080, // populated by compositor from actual EDID list when available from GPU driver
+	Prop_DisplaySupportsMultipleFramerates_Bool = 2081, // if this is true but Prop_DisplayAvailableFrameRates_Float_Array is empty, explain to user
+	Prop_DisplayColorMultLeft_Vector3			= 2082,
+	Prop_DisplayColorMultRight_Vector3			= 2083,
+	Prop_DisplaySupportsRuntimeFramerateChange_Bool = 2084,
+	Prop_DisplaySupportsAnalogGain_Bool 		= 2085,
+	Prop_DisplayMinAnalogGain_Float 			= 2086,
+	Prop_DisplayMaxAnalogGain_Float 			= 2087,
+
+	// Prop_DashboardLayoutPathName_String 		= 2090, // DELETED
+	Prop_DashboardScale_Float 					= 2091,
+	Prop_IpdUIRangeMinMeters_Float 				= 2100,
+	Prop_IpdUIRangeMaxMeters_Float 				= 2101,
+
+	// Driver requested mura correction properties
+	Prop_DriverRequestedMuraCorrectionMode_Int32		= 2200,
+	Prop_DriverRequestedMuraFeather_InnerLeft_Int32		= 2201,
+	Prop_DriverRequestedMuraFeather_InnerRight_Int32	= 2202,
+	Prop_DriverRequestedMuraFeather_InnerTop_Int32		= 2203,
+	Prop_DriverRequestedMuraFeather_InnerBottom_Int32	= 2204,
+	Prop_DriverRequestedMuraFeather_OuterLeft_Int32		= 2205,
+	Prop_DriverRequestedMuraFeather_OuterRight_Int32	= 2206,
+	Prop_DriverRequestedMuraFeather_OuterTop_Int32		= 2207,
+	Prop_DriverRequestedMuraFeather_OuterBottom_Int32	= 2208,
+
+	Prop_Audio_DefaultPlaybackDeviceId_String		= 2300,
+	Prop_Audio_DefaultRecordingDeviceId_String		= 2301,
+	Prop_Audio_DefaultPlaybackDeviceVolume_Float	= 2302,
+
+	// Properties that are unique to TrackedDeviceClass_Controller
+	Prop_AttachedDeviceId_String				= 3000,
+	Prop_SupportedButtons_Uint64				= 3001,
+	Prop_Axis0Type_Int32						= 3002, // Return value is of type EVRControllerAxisType
+	Prop_Axis1Type_Int32						= 3003, // Return value is of type EVRControllerAxisType
+	Prop_Axis2Type_Int32						= 3004, // Return value is of type EVRControllerAxisType
+	Prop_Axis3Type_Int32						= 3005, // Return value is of type EVRControllerAxisType
+	Prop_Axis4Type_Int32						= 3006, // Return value is of type EVRControllerAxisType
+	Prop_ControllerRoleHint_Int32				= 3007, // Return value is of type ETrackedControllerRole
+
+	// Properties that are unique to TrackedDeviceClass_TrackingReference
+	Prop_FieldOfViewLeftDegrees_Float			= 4000,
+	Prop_FieldOfViewRightDegrees_Float			= 4001,
+	Prop_FieldOfViewTopDegrees_Float			= 4002,
+	Prop_FieldOfViewBottomDegrees_Float			= 4003,
+	Prop_TrackingRangeMinimumMeters_Float		= 4004,
+	Prop_TrackingRangeMaximumMeters_Float		= 4005,
+	Prop_ModeLabel_String						= 4006,
+	Prop_CanWirelessIdentify_Bool               = 4007, // volatile, based on radio presence and fw discovery
+	Prop_Nonce_Int32                            = 4008,
+
+	// Properties that are used for user interface like icons names
+	Prop_IconPathName_String						= 5000, // DEPRECATED. Value not referenced. Now expected to be part of icon path properties.
+	Prop_NamedIconPathDeviceOff_String				= 5001, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceSearching_String		= 5002, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceSearchingAlert_String	= 5003, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceReady_String			= 5004, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceReadyAlert_String		= 5005, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceNotReady_String			= 5006, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceStandby_String			= 5007, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceAlertLow_String			= 5008, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceStandbyAlert_String		= 5009, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+
+	// Properties that are used by helpers, but are opaque to applications
+	Prop_DisplayHiddenArea_Binary_Start				= 5100,
+	Prop_DisplayHiddenArea_Binary_End				= 5150,
+	Prop_ParentContainer							= 5151,
+	Prop_OverrideContainer_Uint64					= 5152,
+
+	// Properties that are unique to drivers
+	Prop_UserConfigPath_String					= 6000,
+	Prop_InstallPath_String						= 6001,
+	Prop_HasDisplayComponent_Bool				= 6002,
+	Prop_HasControllerComponent_Bool			= 6003,
+	Prop_HasCameraComponent_Bool				= 6004,
+	Prop_HasDriverDirectModeComponent_Bool		= 6005,
+	Prop_HasVirtualDisplayComponent_Bool		= 6006,
+	Prop_HasSpatialAnchorsSupport_Bool		    = 6007,
+
+	// Properties that are set internally based on other information provided by drivers
+	Prop_ControllerType_String					= 7000,
+	//Prop_LegacyInputProfile_String				= 7001, // This is no longer used. See "legacy_binding" in the input profile instead.
+	Prop_ControllerHandSelectionPriority_Int32	= 7002, // Allows hand assignments to prefer some controllers over others. High numbers are selected over low numbers
+
+	// Vendors are free to expose private debug data in this reserved region
+	Prop_VendorSpecific_Reserved_Start			= 10000,
+	Prop_VendorSpecific_Reserved_End			= 10999,
+	
+	Prop_TrackedDeviceProperty_Max				= 1000000,
+};
+
+/** No string property will ever be longer than this length */
+static const uint32_t k_unMaxPropertyStringSize = 32 * 1024;
+
+/** Used to return errors that occur when reading properties. */
+enum ETrackedPropertyError
+{
+	TrackedProp_Success						= 0,
+	TrackedProp_WrongDataType				= 1,
+	TrackedProp_WrongDeviceClass			= 2,
+	TrackedProp_BufferTooSmall				= 3,
+	TrackedProp_UnknownProperty				= 4, // Driver has not set the property (and may not ever).
+	TrackedProp_InvalidDevice				= 5,
+	TrackedProp_CouldNotContactServer		= 6,
+	TrackedProp_ValueNotProvidedByDevice	= 7,
+	TrackedProp_StringExceedsMaximumLength	= 8,
+	TrackedProp_NotYetAvailable				= 9, // The property value isn't known yet, but is expected soon. Call again later.
+	TrackedProp_PermissionDenied			= 10,
+	TrackedProp_InvalidOperation			= 11,
+	TrackedProp_CannotWriteToWildcards		= 12,
+	TrackedProp_IPCReadFailure				= 13,
+	TrackedProp_OutOfMemory					= 14,
+	TrackedProp_InvalidContainer			= 15,
+};
+
+/** Used to drive certain text in the UI when talking about the tracking system for the HMD */
+enum EHmdTrackingStyle
+{
+	HmdTrackingStyle_Unknown				= 0,
+
+	HmdTrackingStyle_Lighthouse				= 1, // base stations and lasers
+	HmdTrackingStyle_OutsideInCameras		= 2, // Cameras and LED, Rift 1 style
+	HmdTrackingStyle_InsideOutCameras		= 3, // Cameras on HMD looking at the world
+};
+
+typedef uint64_t VRActionHandle_t;
+typedef uint64_t VRActionSetHandle_t;
+typedef uint64_t VRInputValueHandle_t;
+
+static const VRActionHandle_t k_ulInvalidActionHandle = 0;
+static const VRActionSetHandle_t k_ulInvalidActionSetHandle = 0;
+static const VRInputValueHandle_t k_ulInvalidInputValueHandle = 0;
+
+
+/** Allows the application to control what part of the provided texture will be used in the
+* frame buffer. */
+struct VRTextureBounds_t
+{
+	float uMin, vMin;
+	float uMax, vMax;
+};
+
+/** Allows specifying pose used to render provided scene texture (if different from value returned by WaitGetPoses). */
+struct VRTextureWithPose_t : public Texture_t
+{
+	HmdMatrix34_t mDeviceToAbsoluteTracking; // Actual pose used to render scene textures.
+};
+
+struct VRTextureDepthInfo_t
+{
+	void* handle; // See ETextureType definition above
+	HmdMatrix44_t mProjection;
+	HmdVector2_t vRange; // 0..1
+};
+
+struct VRTextureWithDepth_t : public Texture_t
+{
+	VRTextureDepthInfo_t depth;
+};
+
+struct VRTextureWithPoseAndDepth_t : public VRTextureWithPose_t
+{
+	VRTextureDepthInfo_t depth;
+};
+
+/** Allows the application to control how scene textures are used by the compositor when calling Submit. */
+enum EVRSubmitFlags
+{
+	// Simple render path. App submits rendered left and right eye images with no lens distortion correction applied.
+	Submit_Default = 0x00,
+
+	// App submits final left and right eye images with lens distortion already applied (lens distortion makes the images appear
+	// barrel distorted with chromatic aberration correction applied). The app would have used the data returned by
+	// vr::IVRSystem::ComputeDistortion() to apply the correct distortion to the rendered images before calling Submit().
+	Submit_LensDistortionAlreadyApplied = 0x01,
+
+	// If the texture pointer passed in is actually a renderbuffer (e.g. for MSAA in OpenGL) then set this flag.
+	Submit_GlRenderBuffer = 0x02,
+
+	// Do not use
+	Submit_Reserved = 0x04,
+
+	// Set to indicate that pTexture is a pointer to a VRTextureWithPose_t.
+	// This flag can be combined with Submit_TextureWithDepth to pass a VRTextureWithPoseAndDepth_t.
+	Submit_TextureWithPose = 0x08,
+
+	// Set to indicate that pTexture is a pointer to a VRTextureWithDepth_t.
+	// This flag can be combined with Submit_TextureWithPose to pass a VRTextureWithPoseAndDepth_t.
+	Submit_TextureWithDepth = 0x10,
+
+	// Set to indicate a discontinuity between this and the last frame.
+	// This will prevent motion smoothing from attempting to extrapolate using the pair.
+	Submit_FrameDiscontinuty = 0x20,
+};
+
+/** Data required for passing Vulkan textures to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. 
+* Please see https://github.com/ValveSoftware/openvr/wiki/Vulkan for Vulkan-specific documentation */
+struct VRVulkanTextureData_t
+{
+	uint64_t m_nImage; // VkImage
+	VkDevice_T *m_pDevice;
+	VkPhysicalDevice_T *m_pPhysicalDevice;
+	VkInstance_T *m_pInstance;
+	VkQueue_T *m_pQueue;
+	uint32_t m_nQueueFamilyIndex;
+	uint32_t m_nWidth, m_nHeight, m_nFormat, m_nSampleCount;
+};
+
+/** Data required for passing D3D12 textures to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. */
+struct D3D12TextureData_t
+{
+	ID3D12Resource *m_pResource;
+	ID3D12CommandQueue *m_pCommandQueue;
+	uint32_t m_nNodeMask;
+};
+
+/** Status of the overall system or tracked objects */
+enum EVRState
+{
+	VRState_Undefined = -1,
+	VRState_Off = 0,
+	VRState_Searching = 1,
+	VRState_Searching_Alert = 2,
+	VRState_Ready = 3,
+	VRState_Ready_Alert = 4,
+	VRState_NotReady = 5,
+	VRState_Standby = 6,
+	VRState_Ready_Alert_Low = 7,
+};
+
+/** The types of events that could be posted (and what the parameters mean for each event type) */
+enum EVREventType
+{
+	VREvent_None = 0,
+
+	VREvent_TrackedDeviceActivated		= 100,
+	VREvent_TrackedDeviceDeactivated	= 101,
+	VREvent_TrackedDeviceUpdated		= 102,
+	VREvent_TrackedDeviceUserInteractionStarted	= 103,
+	VREvent_TrackedDeviceUserInteractionEnded	= 104,
+	VREvent_IpdChanged					= 105,
+	VREvent_EnterStandbyMode			= 106,
+	VREvent_LeaveStandbyMode			= 107,
+	VREvent_TrackedDeviceRoleChanged	= 108,
+	VREvent_WatchdogWakeUpRequested		= 109,
+	VREvent_LensDistortionChanged		= 110,
+	VREvent_PropertyChanged				= 111,
+	VREvent_WirelessDisconnect			= 112,
+	VREvent_WirelessReconnect			= 113,
+
+	VREvent_ButtonPress					= 200, // data is controller
+	VREvent_ButtonUnpress				= 201, // data is controller
+	VREvent_ButtonTouch					= 202, // data is controller
+	VREvent_ButtonUntouch				= 203, // data is controller
+
+	// VREvent_DualAnalog_Press			= 250, // No longer sent
+	// VREvent_DualAnalog_Unpress		= 251, // No longer sent
+	// VREvent_DualAnalog_Touch			= 252, // No longer sent
+	// VREvent_DualAnalog_Untouch		= 253, // No longer sent
+	// VREvent_DualAnalog_Move			= 254, // No longer sent
+	// VREvent_DualAnalog_ModeSwitch1	= 255, // No longer sent
+	// VREvent_DualAnalog_ModeSwitch2	= 256, // No longer sent
+	VREvent_Modal_Cancel				= 257, // Sent to overlays with the 
+
+	VREvent_MouseMove					= 300, // data is mouse
+	VREvent_MouseButtonDown				= 301, // data is mouse
+	VREvent_MouseButtonUp				= 302, // data is mouse
+	VREvent_FocusEnter					= 303, // data is overlay
+	VREvent_FocusLeave					= 304, // data is overlay
+	VREvent_ScrollDiscrete				= 305, // data is scroll
+	VREvent_TouchPadMove				= 306, // data is mouse
+	VREvent_OverlayFocusChanged			= 307, // data is overlay, global event
+	VREvent_ReloadOverlays				= 308, 
+	VREvent_ScrollSmooth				= 309, // data is scroll
+	VREvent_LockMousePosition			= 310,
+	VREvent_UnlockMousePosition			= 311,
+
+	VREvent_InputFocusCaptured			= 400, // data is process DEPRECATED
+	VREvent_InputFocusReleased			= 401, // data is process DEPRECATED
+	// VREvent_SceneFocusLost			= 402, // data is process
+	// VREvent_SceneFocusGained			= 403, // data is process
+	VREvent_SceneApplicationChanged		= 404, // data is process - The App actually drawing the scene changed (usually to or from the compositor)
+	VREvent_SceneFocusChanged			= 405, // data is process - New app got access to draw the scene
+	VREvent_InputFocusChanged			= 406, // data is process
+	// VREvent_SceneApplicationSecondaryRenderingStarted = 407,
+	VREvent_SceneApplicationUsingWrongGraphicsAdapter = 408, // data is process
+	VREvent_ActionBindingReloaded		 = 409, // data is process - The App that action binds reloaded for
+
+	VREvent_HideRenderModels			= 410, // Sent to the scene application to request hiding render models temporarily
+	VREvent_ShowRenderModels			= 411, // Sent to the scene application to request restoring render model visibility
+
+	VREvent_SceneApplicationStateChanged = 412, // No data; but query VRApplications()->GetSceneApplicationState();
+
+	VREvent_ConsoleOpened               = 420,
+	VREvent_ConsoleClosed               = 421,
+
+	VREvent_OverlayShown				= 500,
+	VREvent_OverlayHidden				= 501,
+	VREvent_DashboardActivated			= 502,
+	VREvent_DashboardDeactivated		= 503,
+	//VREvent_DashboardThumbSelected		= 504, // Sent to the overlay manager - data is overlay - No longer sent
+	VREvent_DashboardRequested			= 505, // Sent to the overlay manager - data is overlay
+	VREvent_ResetDashboard				= 506, // Send to the overlay manager
+	//VREvent_RenderToast					= 507, // Send to the dashboard to render a toast - data is the notification ID -- no longer sent
+	VREvent_ImageLoaded					= 508, // Sent to overlays when a SetOverlayRaw or SetOverlayFromFile call finishes loading
+	VREvent_ShowKeyboard				= 509, // Sent to keyboard renderer in the dashboard to invoke it
+	VREvent_HideKeyboard				= 510, // Sent to keyboard renderer in the dashboard to hide it
+	VREvent_OverlayGamepadFocusGained	= 511, // Sent to an overlay when IVROverlay::SetFocusOverlay is called on it
+	VREvent_OverlayGamepadFocusLost		= 512, // Send to an overlay when it previously had focus and IVROverlay::SetFocusOverlay is called on something else
+	VREvent_OverlaySharedTextureChanged = 513,
+	//VREvent_DashboardGuideButtonDown	= 514, // These are no longer sent
+	//VREvent_DashboardGuideButtonUp		= 515,
+	VREvent_ScreenshotTriggered			= 516, // Screenshot button combo was pressed, Dashboard should request a screenshot
+	VREvent_ImageFailed					= 517, // Sent to overlays when a SetOverlayRaw or SetOverlayfromFail fails to load
+	VREvent_DashboardOverlayCreated		= 518,
+	VREvent_SwitchGamepadFocus			= 519,
+
+	// Screenshot API
+	VREvent_RequestScreenshot				= 520, // Sent by vrclient application to compositor to take a screenshot
+	VREvent_ScreenshotTaken					= 521, // Sent by compositor to the application that the screenshot has been taken
+	VREvent_ScreenshotFailed				= 522, // Sent by compositor to the application that the screenshot failed to be taken
+	VREvent_SubmitScreenshotToDashboard		= 523, // Sent by compositor to the dashboard that a completed screenshot was submitted
+	VREvent_ScreenshotProgressToDashboard	= 524, // Sent by compositor to the dashboard that a completed screenshot was submitted
+
+	VREvent_PrimaryDashboardDeviceChanged	= 525,
+	VREvent_RoomViewShown					= 526, // Sent by compositor whenever room-view is enabled
+	VREvent_RoomViewHidden					= 527, // Sent by compositor whenever room-view is disabled
+	VREvent_ShowUI							= 528, // data is showUi
+	VREvent_ShowDevTools					= 529, // data is showDevTools
+
+	VREvent_Notification_Shown				= 600,
+	VREvent_Notification_Hidden				= 601,
+	VREvent_Notification_BeginInteraction	= 602,
+	VREvent_Notification_Destroyed			= 603,
+
+	VREvent_Quit							= 700, // data is process
+	VREvent_ProcessQuit						= 701, // data is process
+	//VREvent_QuitAborted_UserPrompt			= 702, // data is process
+	VREvent_QuitAcknowledged				= 703, // data is process
+	VREvent_DriverRequestedQuit				= 704, // The driver has requested that SteamVR shut down
+	VREvent_RestartRequested				= 705, // A driver or other component wants the user to restart SteamVR
+
+	VREvent_ChaperoneDataHasChanged			= 800, // this will never happen with the new chaperone system
+	VREvent_ChaperoneUniverseHasChanged		= 801,
+	VREvent_ChaperoneTempDataHasChanged		= 802, // this will never happen with the new chaperone system
+	VREvent_ChaperoneSettingsHaveChanged	= 803,
+	VREvent_SeatedZeroPoseReset				= 804,
+	VREvent_ChaperoneFlushCache				= 805, // Sent when the process needs to reload any cached data it retrieved from VRChaperone()
+	VREvent_ChaperoneRoomSetupStarting	    = 806, // Triggered by CVRChaperoneClient::RoomSetupStarting
+	VREvent_ChaperoneRoomSetupFinished	    = 807, // Triggered by CVRChaperoneClient::CommitWorkingCopy
+
+	VREvent_AudioSettingsHaveChanged		= 820,
+
+	VREvent_BackgroundSettingHasChanged				= 850,
+	VREvent_CameraSettingsHaveChanged				= 851,
+	VREvent_ReprojectionSettingHasChanged			= 852,
+	VREvent_ModelSkinSettingsHaveChanged			= 853,
+	VREvent_EnvironmentSettingsHaveChanged			= 854,
+	VREvent_PowerSettingsHaveChanged				= 855,
+	VREvent_EnableHomeAppSettingsHaveChanged		= 856,
+	VREvent_SteamVRSectionSettingChanged			= 857,
+	VREvent_LighthouseSectionSettingChanged			= 858,
+	VREvent_NullSectionSettingChanged				= 859,
+	VREvent_UserInterfaceSectionSettingChanged		= 860,
+	VREvent_NotificationsSectionSettingChanged		= 861,
+	VREvent_KeyboardSectionSettingChanged			= 862,
+	VREvent_PerfSectionSettingChanged				= 863,
+	VREvent_DashboardSectionSettingChanged			= 864,
+	VREvent_WebInterfaceSectionSettingChanged		= 865,
+	VREvent_TrackersSectionSettingChanged			= 866,
+	VREvent_LastKnownSectionSettingChanged			= 867,
+	VREvent_DismissedWarningsSectionSettingChanged	= 868,
+	VREvent_GpuSpeedSectionSettingChanged			= 869,
+	VREvent_WindowsMRSectionSettingChanged			= 870,
+	VREvent_OtherSectionSettingChanged				= 871,
+
+	VREvent_StatusUpdate					= 900,
+
+	VREvent_WebInterface_InstallDriverCompleted = 950,
+
+	VREvent_MCImageUpdated					= 1000,
+
+	VREvent_FirmwareUpdateStarted			= 1100,
+	VREvent_FirmwareUpdateFinished			= 1101,
+
+	VREvent_KeyboardClosed					= 1200,
+	VREvent_KeyboardCharInput				= 1201,
+	VREvent_KeyboardDone					= 1202, // Sent when DONE button clicked on keyboard
+
+	//VREvent_ApplicationTransitionStarted		= 1300,
+	//VREvent_ApplicationTransitionAborted		= 1301,
+	//VREvent_ApplicationTransitionNewAppStarted	= 1302,
+	VREvent_ApplicationListUpdated				= 1303,
+	VREvent_ApplicationMimeTypeLoad				= 1304,
+	// VREvent_ApplicationTransitionNewAppLaunchComplete = 1305,
+	VREvent_ProcessConnected					= 1306,
+	VREvent_ProcessDisconnected					= 1307,
+
+	//VREvent_Compositor_MirrorWindowShown		= 1400, // DEPRECATED
+	//VREvent_Compositor_MirrorWindowHidden		= 1401, // DEPRECATED
+	VREvent_Compositor_ChaperoneBoundsShown		= 1410,
+	VREvent_Compositor_ChaperoneBoundsHidden	= 1411,
+	VREvent_Compositor_DisplayDisconnected		= 1412,
+	VREvent_Compositor_DisplayReconnected		= 1413,
+	VREvent_Compositor_HDCPError				= 1414, // data is hdcpError
+	VREvent_Compositor_ApplicationNotResponding	= 1415,
+	VREvent_Compositor_ApplicationResumed		= 1416,
+	VREvent_Compositor_OutOfVideoMemory			= 1417,
+	VREvent_Compositor_DisplayModeNotSupported	= 1418, // k_pch_SteamVR_PreferredRefreshRate
+	VREvent_Compositor_StageOverrideReady		= 1419,
+
+	VREvent_TrackedCamera_StartVideoStream  = 1500,
+	VREvent_TrackedCamera_StopVideoStream   = 1501,
+	VREvent_TrackedCamera_PauseVideoStream  = 1502,
+	VREvent_TrackedCamera_ResumeVideoStream = 1503,
+	VREvent_TrackedCamera_EditingSurface    = 1550,
+
+	VREvent_PerformanceTest_EnableCapture	= 1600,
+	VREvent_PerformanceTest_DisableCapture	= 1601,
+	VREvent_PerformanceTest_FidelityLevel	= 1602,
+
+	VREvent_MessageOverlay_Closed			= 1650,
+	VREvent_MessageOverlayCloseRequested	= 1651,
+	
+	VREvent_Input_HapticVibration			= 1700, // data is hapticVibration
+	VREvent_Input_BindingLoadFailed			= 1701, // data is inputBinding
+	VREvent_Input_BindingLoadSuccessful		= 1702, // data is inputBinding
+	VREvent_Input_ActionManifestReloaded	= 1703, // no data
+	VREvent_Input_ActionManifestLoadFailed	= 1704, // data is actionManifest
+	VREvent_Input_ProgressUpdate			= 1705, // data is progressUpdate
+	VREvent_Input_TrackerActivated			= 1706,
+	VREvent_Input_BindingsUpdated			= 1707,
+	VREvent_Input_BindingSubscriptionChanged = 1708,
+
+	VREvent_SpatialAnchors_PoseUpdated		= 1800,        // data is spatialAnchor. broadcast
+	VREvent_SpatialAnchors_DescriptorUpdated = 1801,       // data is spatialAnchor. broadcast
+	VREvent_SpatialAnchors_RequestPoseUpdate = 1802,       // data is spatialAnchor. sent to specific driver
+	VREvent_SpatialAnchors_RequestDescriptorUpdate = 1803, // data is spatialAnchor. sent to specific driver
+
+	VREvent_SystemReport_Started			= 1900, // user or system initiated generation of a system report. broadcast
+
+	VREvent_Monitor_ShowHeadsetView			= 2000, // data is process
+	VREvent_Monitor_HideHeadsetView			= 2001, // data is process
+
+	// Vendors are free to expose private events in this reserved region
+	VREvent_VendorSpecific_Reserved_Start	= 10000,
+	VREvent_VendorSpecific_Reserved_End		= 19999,
+};
+
+
+/** Level of Hmd activity */
+// UserInteraction_Timeout means the device is in the process of timing out.
+// InUse = ( k_EDeviceActivityLevel_UserInteraction || k_EDeviceActivityLevel_UserInteraction_Timeout )
+// VREvent_TrackedDeviceUserInteractionStarted fires when the devices transitions from Standby -> UserInteraction or Idle -> UserInteraction.
+// VREvent_TrackedDeviceUserInteractionEnded fires when the devices transitions from UserInteraction_Timeout -> Idle
+enum EDeviceActivityLevel
+{	
+	k_EDeviceActivityLevel_Unknown = -1,									
+	k_EDeviceActivityLevel_Idle = 0,						// No activity for the last 10 seconds
+	k_EDeviceActivityLevel_UserInteraction = 1,				// Activity (movement or prox sensor) is happening now	
+	k_EDeviceActivityLevel_UserInteraction_Timeout = 2,		// No activity for the last 0.5 seconds
+	k_EDeviceActivityLevel_Standby = 3,						// Idle for at least 5 seconds (configurable in Settings -> Power Management)
+	k_EDeviceActivityLevel_Idle_Timeout = 4,
+};
+
+
+/** VR controller button and axis IDs */
+enum EVRButtonId
+{
+	k_EButton_System			= 0,
+	k_EButton_ApplicationMenu	= 1,
+	k_EButton_Grip				= 2,
+	k_EButton_DPad_Left			= 3,
+	k_EButton_DPad_Up			= 4,
+	k_EButton_DPad_Right		= 5,
+	k_EButton_DPad_Down			= 6,
+	k_EButton_A					= 7,
+	
+	k_EButton_ProximitySensor   = 31,
+
+	k_EButton_Axis0				= 32,
+	k_EButton_Axis1				= 33,
+	k_EButton_Axis2				= 34,
+	k_EButton_Axis3				= 35,
+	k_EButton_Axis4				= 36,
+
+	// aliases for well known controllers
+	k_EButton_SteamVR_Touchpad	= k_EButton_Axis0,
+	k_EButton_SteamVR_Trigger	= k_EButton_Axis1,
+
+	k_EButton_Dashboard_Back	= k_EButton_Grip,
+
+	k_EButton_IndexController_A		= k_EButton_Grip,
+	k_EButton_IndexController_B		= k_EButton_ApplicationMenu,
+	k_EButton_IndexController_JoyStick	= k_EButton_Axis3,
+
+	k_EButton_Max				= 64
+};
+
+inline uint64_t ButtonMaskFromId( EVRButtonId id ) { return 1ull << id; }
+
+/** used for controller button events */
+struct VREvent_Controller_t
+{
+	uint32_t button; // EVRButtonId enum
+};
+
+
+/** used for simulated mouse events in overlay space */
+enum EVRMouseButton
+{
+	VRMouseButton_Left					= 0x0001,
+	VRMouseButton_Right					= 0x0002,
+	VRMouseButton_Middle				= 0x0004,
+};
+
+
+/** used for simulated mouse events in overlay space */
+struct VREvent_Mouse_t
+{
+	float x, y; // co-ords are in GL space, bottom left of the texture is 0,0
+	uint32_t button; // EVRMouseButton enum
+};
+
+/** used for simulated mouse wheel scroll */
+struct VREvent_Scroll_t
+{
+	float xdelta, ydelta;
+	uint32_t unused;
+	float viewportscale; // For scrolling on an overlay with laser mouse, this is the overlay's vertical size relative to the overlay height. Range: [0,1]
+};
+
+/** when in mouse input mode you can receive data from the touchpad, these events are only sent if the users finger
+   is on the touchpad (or just released from it). These events are sent to overlays with the VROverlayFlags_SendVRTouchpadEvents
+   flag set.
+**/
+struct VREvent_TouchPadMove_t
+{
+	// true if the users finger is detected on the touch pad
+	bool bFingerDown;
+
+	// How long the finger has been down in seconds
+	float flSecondsFingerDown;
+
+	// These values indicate the starting finger position (so you can do some basic swipe stuff)
+	float fValueXFirst;
+	float fValueYFirst;
+
+	// This is the raw sampled coordinate without deadzoning
+	float fValueXRaw;
+	float fValueYRaw;
+};
+
+/** notification related events. Details will still change at this point */
+struct VREvent_Notification_t
+{
+	uint64_t ulUserValue;
+	uint32_t notificationId;
+};
+
+/** Used for events about processes */
+struct VREvent_Process_t
+{
+	uint32_t pid;
+	uint32_t oldPid;
+	bool bForced;
+	// If the associated event was triggered by a connection loss
+	bool bConnectionLost;
+};
+
+
+/** Used for a few events about overlays */
+struct VREvent_Overlay_t
+{
+	uint64_t overlayHandle;
+	uint64_t devicePath;
+};
+
+
+/** Used for a few events about overlays */
+struct VREvent_Status_t
+{
+	uint32_t statusState; // EVRState enum
+};
+
+/** Used for keyboard events **/
+struct VREvent_Keyboard_t
+{
+	char cNewInput[8];	// Up to 11 bytes of new input
+	uint64_t uUserValue;	// Possible flags about the new input
+};
+
+struct VREvent_Ipd_t
+{
+	float ipdMeters;
+};
+
+struct VREvent_Chaperone_t
+{
+	uint64_t m_nPreviousUniverse;
+	uint64_t m_nCurrentUniverse;
+};
+
+/** Not actually used for any events */
+struct VREvent_Reserved_t
+{
+	uint64_t reserved0;
+	uint64_t reserved1;
+	uint64_t reserved2;
+	uint64_t reserved3;
+	uint64_t reserved4;
+	uint64_t reserved5;
+};
+
+struct VREvent_PerformanceTest_t
+{
+	uint32_t m_nFidelityLevel;
+};
+
+struct VREvent_SeatedZeroPoseReset_t
+{
+	bool bResetBySystemMenu;
+};
+
+struct VREvent_Screenshot_t
+{
+	uint32_t handle;
+	uint32_t type;
+};
+
+struct VREvent_ScreenshotProgress_t
+{
+	float progress;
+};
+
+struct VREvent_ApplicationLaunch_t
+{
+	uint32_t pid;
+	uint32_t unArgsHandle;
+};
+
+struct VREvent_EditingCameraSurface_t
+{
+	uint64_t overlayHandle;
+	uint32_t nVisualMode;
+};
+
+struct VREvent_MessageOverlay_t
+{
+	uint32_t unVRMessageOverlayResponse; // vr::VRMessageOverlayResponse enum
+};
+
+struct VREvent_Property_t
+{
+	PropertyContainerHandle_t container;
+	ETrackedDeviceProperty prop;
+};
+
+struct VREvent_HapticVibration_t
+{
+	uint64_t containerHandle; // property container handle of the device with the haptic component
+	uint64_t componentHandle; // Which haptic component needs to vibrate
+	float fDurationSeconds;
+	float fFrequency;
+	float fAmplitude;
+};
+
+struct VREvent_WebConsole_t
+{
+	WebConsoleHandle_t webConsoleHandle;
+};
+
+struct VREvent_InputBindingLoad_t
+{
+	vr::PropertyContainerHandle_t ulAppContainer;
+	uint64_t pathMessage;
+	uint64_t pathUrl;
+	uint64_t pathControllerType;
+};
+
+struct VREvent_InputActionManifestLoad_t
+{
+	uint64_t pathAppKey;
+	uint64_t pathMessage;
+	uint64_t pathMessageParam;
+	uint64_t pathManifestPath;
+};
+
+struct VREvent_SpatialAnchor_t
+{
+	SpatialAnchorHandle_t unHandle;
+};
+
+struct VREvent_ProgressUpdate_t
+{
+	uint64_t ulApplicationPropertyContainer;
+	uint64_t pathDevice;
+	uint64_t pathInputSource;
+	uint64_t pathProgressAction;
+	uint64_t pathIcon;
+	float fProgress;
+};
+
+enum EShowUIType
+{
+	ShowUI_ControllerBinding = 0,
+	ShowUI_ManageTrackers = 1,
+	// ShowUI_QuickStart = 2, // Deprecated
+	ShowUI_Pairing = 3,
+	ShowUI_Settings = 4,
+	ShowUI_DebugCommands = 5,
+	ShowUI_FullControllerBinding = 6,
+	ShowUI_ManageDrivers = 7,
+};
+
+struct VREvent_ShowUI_t
+{
+	EShowUIType eType;
+};
+
+struct VREvent_ShowDevTools_t
+{
+	int32_t nBrowserIdentifier;
+};
+
+enum EHDCPError
+{
+	HDCPError_None = 0,
+	HDCPError_LinkLost = 1,
+	HDCPError_Tampered = 2,
+	HDCPError_DeviceRevoked = 3,
+	HDCPError_Unknown = 4
+};
+
+struct VREvent_HDCPError_t
+{
+	EHDCPError eCode;
+};
+
+typedef union
+{
+	VREvent_Reserved_t reserved;
+	VREvent_Controller_t controller;
+	VREvent_Mouse_t mouse;
+	VREvent_Scroll_t scroll;
+	VREvent_Process_t process;
+	VREvent_Notification_t notification;
+	VREvent_Overlay_t overlay;
+	VREvent_Status_t status;
+	VREvent_Keyboard_t keyboard;
+	VREvent_Ipd_t ipd;
+	VREvent_Chaperone_t chaperone;
+	VREvent_PerformanceTest_t performanceTest;
+	VREvent_TouchPadMove_t touchPadMove;
+	VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset;
+	VREvent_Screenshot_t screenshot;
+	VREvent_ScreenshotProgress_t screenshotProgress;
+	VREvent_ApplicationLaunch_t applicationLaunch;
+	VREvent_EditingCameraSurface_t cameraSurface;
+	VREvent_MessageOverlay_t messageOverlay;
+	VREvent_Property_t property;
+	VREvent_HapticVibration_t hapticVibration;
+	VREvent_WebConsole_t webConsole;
+	VREvent_InputBindingLoad_t inputBinding;
+	VREvent_InputActionManifestLoad_t actionManifest;
+	VREvent_SpatialAnchor_t spatialAnchor;
+	VREvent_ProgressUpdate_t progressUpdate;
+	VREvent_ShowUI_t showUi;
+	VREvent_ShowDevTools_t showDevTools;
+	VREvent_HDCPError_t hdcpError;
+    /** NOTE!!! If you change this you MUST manually update openvr_interop.cs.py */
+} VREvent_Data_t;
+
+
+#if defined(__linux__) || defined(__APPLE__) 
+// This structure was originally defined mis-packed on Linux, preserved for 
+// compatibility. 
+#pragma pack( push, 4 )
+#endif
+
+/** An event posted by the server to all running applications */
+struct VREvent_t
+{
+	uint32_t eventType; // EVREventType enum
+	TrackedDeviceIndex_t trackedDeviceIndex;
+	float eventAgeSeconds;
+	// event data must be the end of the struct as its size is variable
+	VREvent_Data_t data;
+};
+
+#if defined(__linux__) || defined(__APPLE__) 
+#pragma pack( pop )
+#endif
+
+typedef uint32_t VRComponentProperties;
+
+enum EVRComponentProperty
+{
+	VRComponentProperty_IsStatic = (1 << 0),
+	VRComponentProperty_IsVisible = (1 << 1),
+	VRComponentProperty_IsTouched = (1 << 2),
+	VRComponentProperty_IsPressed = (1 << 3),
+	VRComponentProperty_IsScrolled = (1 << 4),
+	VRComponentProperty_IsHighlighted = (1 << 5),
+};
+
+
+/** Describes state information about a render-model component, including transforms and other dynamic properties */
+struct RenderModel_ComponentState_t
+{
+	HmdMatrix34_t mTrackingToComponentRenderModel;  // Transform required when drawing the component render model
+	HmdMatrix34_t mTrackingToComponentLocal;        // Transform available for attaching to a local component coordinate system (-Z out from surface )
+	VRComponentProperties uProperties;
+};
+
+
+enum EVRInputError
+{
+	VRInputError_None = 0,
+	VRInputError_NameNotFound = 1,
+	VRInputError_WrongType = 2,
+	VRInputError_InvalidHandle = 3,
+	VRInputError_InvalidParam = 4,
+	VRInputError_NoSteam = 5,
+	VRInputError_MaxCapacityReached = 6,
+	VRInputError_IPCError = 7,
+	VRInputError_NoActiveActionSet = 8,
+	VRInputError_InvalidDevice = 9,
+	VRInputError_InvalidSkeleton = 10,
+	VRInputError_InvalidBoneCount = 11,
+	VRInputError_InvalidCompressedData = 12,
+	VRInputError_NoData = 13,
+	VRInputError_BufferTooSmall = 14,
+	VRInputError_MismatchedActionManifest = 15,
+	VRInputError_MissingSkeletonData = 16,
+	VRInputError_InvalidBoneIndex = 17,
+	VRInputError_InvalidPriority = 18,
+	VRInputError_PermissionDenied = 19,
+	VRInputError_InvalidRenderModel = 20,
+};
+
+enum EVRSpatialAnchorError
+{
+	VRSpatialAnchorError_Success = 0,
+	VRSpatialAnchorError_Internal = 1,
+	VRSpatialAnchorError_UnknownHandle = 2,
+	VRSpatialAnchorError_ArrayTooSmall = 3,
+	VRSpatialAnchorError_InvalidDescriptorChar = 4,
+	VRSpatialAnchorError_NotYetAvailable = 5,
+	VRSpatialAnchorError_NotAvailableInThisUniverse = 6,
+	VRSpatialAnchorError_PermanentlyUnavailable = 7,
+	VRSpatialAnchorError_WrongDriver = 8,
+	VRSpatialAnchorError_DescriptorTooLong = 9,
+	VRSpatialAnchorError_Unknown = 10,
+	VRSpatialAnchorError_NoRoomCalibration = 11,
+	VRSpatialAnchorError_InvalidArgument = 12,
+	VRSpatialAnchorError_UnknownDriver = 13,
+};
+
+/** The mesh to draw into the stencil (or depth) buffer to perform 
+* early stencil (or depth) kills of pixels that will never appear on the HMD.
+* This mesh draws on all the pixels that will be hidden after distortion. 
+*
+* If the HMD does not provide a visible area mesh pVertexData will be
+* NULL and unTriangleCount will be 0. */
+struct HiddenAreaMesh_t
+{
+	const HmdVector2_t *pVertexData;
+	uint32_t unTriangleCount;
+};
+
+
+enum EHiddenAreaMeshType
+{
+	k_eHiddenAreaMesh_Standard = 0,
+	k_eHiddenAreaMesh_Inverse = 1,
+	k_eHiddenAreaMesh_LineLoop = 2,
+
+	k_eHiddenAreaMesh_Max = 3,
+};
+
+
+/** Identifies what kind of axis is on the controller at index n. Read this type 
+* with pVRSystem->Get( nControllerDeviceIndex, Prop_Axis0Type_Int32 + n );
+*/
+enum EVRControllerAxisType
+{
+	k_eControllerAxis_None = 0,
+	k_eControllerAxis_TrackPad = 1,
+	k_eControllerAxis_Joystick = 2,
+	k_eControllerAxis_Trigger = 3, // Analog trigger data is in the X axis
+};
+
+
+/** contains information about one axis on the controller */
+struct VRControllerAxis_t
+{
+	float x; // Ranges from -1.0 to 1.0 for joysticks and track pads. Ranges from 0.0 to 1.0 for triggers were 0 is fully released.
+	float y; // Ranges from -1.0 to 1.0 for joysticks and track pads. Is always 0.0 for triggers.
+};
+
+
+/** the number of axes in the controller state */
+static const uint32_t k_unControllerStateAxisCount = 5;
+
+
+#if defined(__linux__) || defined(__APPLE__) 
+// This structure was originally defined mis-packed on Linux, preserved for 
+// compatibility. 
+#pragma pack( push, 4 )
+#endif
+
+/** Holds all the state of a controller at one moment in time. */
+struct VRControllerState001_t
+{
+	// If packet num matches that on your prior call, then the controller state hasn't been changed since 
+	// your last call and there is no need to process it
+	uint32_t unPacketNum;
+
+	// bit flags for each of the buttons. Use ButtonMaskFromId to turn an ID into a mask
+	uint64_t ulButtonPressed;
+	uint64_t ulButtonTouched;
+
+	// Axis data for the controller's analog inputs
+	VRControllerAxis_t rAxis[ k_unControllerStateAxisCount ];
+};
+#if defined(__linux__) || defined(__APPLE__) 
+#pragma pack( pop )
+#endif
+
+
+typedef VRControllerState001_t VRControllerState_t;
+
+
+/** determines how to provide output to the application of various event processing functions. */
+enum EVRControllerEventOutputType
+{
+	ControllerEventOutput_OSEvents = 0,
+	ControllerEventOutput_VREvents = 1,
+};
+
+
+
+/** Collision Bounds Style */
+enum ECollisionBoundsStyle
+{
+	COLLISION_BOUNDS_STYLE_BEGINNER = 0,
+	COLLISION_BOUNDS_STYLE_INTERMEDIATE,
+	COLLISION_BOUNDS_STYLE_SQUARES,
+	COLLISION_BOUNDS_STYLE_ADVANCED,
+	COLLISION_BOUNDS_STYLE_NONE,
+
+	COLLISION_BOUNDS_STYLE_COUNT
+};
+
+/** used to refer to a single VR overlay */
+typedef uint64_t VROverlayHandle_t;
+
+static const VROverlayHandle_t k_ulOverlayHandleInvalid = 0;
+
+/** Errors that can occur around VR overlays */
+enum EVROverlayError
+{
+	VROverlayError_None						= 0,
+
+	VROverlayError_UnknownOverlay			= 10,
+	VROverlayError_InvalidHandle			= 11,
+	VROverlayError_PermissionDenied			= 12,
+	VROverlayError_OverlayLimitExceeded		= 13, // No more overlays could be created because the maximum number already exist
+	VROverlayError_WrongVisibilityType		= 14,
+	VROverlayError_KeyTooLong				= 15,
+	VROverlayError_NameTooLong				= 16,
+	VROverlayError_KeyInUse					= 17,
+	VROverlayError_WrongTransformType		= 18,
+	VROverlayError_InvalidTrackedDevice		= 19,
+	VROverlayError_InvalidParameter			= 20,
+	VROverlayError_ThumbnailCantBeDestroyed	= 21,
+	VROverlayError_ArrayTooSmall			= 22,
+	VROverlayError_RequestFailed			= 23,
+	VROverlayError_InvalidTexture			= 24,
+	VROverlayError_UnableToLoadFile			= 25,
+	VROverlayError_KeyboardAlreadyInUse		= 26,
+	VROverlayError_NoNeighbor				= 27,
+	VROverlayError_TooManyMaskPrimitives	= 29,
+	VROverlayError_BadMaskPrimitive			= 30,
+	VROverlayError_TextureAlreadyLocked		= 31,
+	VROverlayError_TextureLockCapacityReached = 32,
+	VROverlayError_TextureNotLocked			= 33,
+};
+
+/** enum values to pass in to VR_Init to identify whether the application will 
+* draw a 3D scene. */
+enum EVRApplicationType
+{
+	VRApplication_Other = 0,		// Some other kind of application that isn't covered by the other entries 
+	VRApplication_Scene	= 1,		// Application will submit 3D frames 
+	VRApplication_Overlay = 2,		// Application only interacts with overlays
+	VRApplication_Background = 3,	// Application should not start SteamVR if it's not already running, and should not
+									// keep it running if everything else quits.
+	VRApplication_Utility = 4,		// Init should not try to load any drivers. The application needs access to utility
+									// interfaces (like IVRSettings and IVRApplications) but not hardware.
+	VRApplication_VRMonitor = 5,	// Reserved for vrmonitor
+	VRApplication_SteamWatchdog = 6,// Reserved for Steam
+	VRApplication_Bootstrapper = 7, // reserved for vrstartup
+	VRApplication_WebHelper = 8,	// reserved for vrwebhelper
+
+	VRApplication_Max
+};
+
+
+/** error codes for firmware */
+enum EVRFirmwareError
+{
+	VRFirmwareError_None = 0,
+	VRFirmwareError_Success = 1,
+	VRFirmwareError_Fail = 2,
+};
+
+
+/** error codes for notifications */
+enum EVRNotificationError
+{
+	VRNotificationError_OK = 0,
+	VRNotificationError_InvalidNotificationId = 100,
+	VRNotificationError_NotificationQueueFull = 101,
+	VRNotificationError_InvalidOverlayHandle = 102,
+	VRNotificationError_SystemWithUserValueAlreadyExists = 103,
+};
+
+
+enum EVRSkeletalMotionRange
+{
+	// The range of motion of the skeleton takes into account any physical limits imposed by
+	// the controller itself.  This will tend to be the most accurate pose compared to the user's
+	// actual hand pose, but might not allow a closed fist for example
+	VRSkeletalMotionRange_WithController = 0,
+
+	// Retarget the range of motion provided by the input device to make the hand appear to move
+	// as if it was not holding a controller.  eg: map "hand grasping controller" to "closed fist"
+	VRSkeletalMotionRange_WithoutController = 1,
+};
+
+enum EVRSkeletalTrackingLevel
+{
+	// body part location can't be directly determined by the device. Any skeletal pose provided by
+	// the device is estimated by assuming the position required to active buttons, triggers, joysticks, 
+	// or other input sensors. 
+	// E.g. Vive Controller, Gamepad
+	VRSkeletalTracking_Estimated = 0,
+
+	// body part location can be measured directly but with fewer degrees of freedom than the actual body 
+	// part. Certain body part positions may be unmeasured by the device and estimated from other input data. 
+	// E.g. Index Controllers, gloves that only measure finger curl
+	VRSkeletalTracking_Partial = 1,
+
+	// Body part location can be measured directly throughout the entire range of motion of the body part. 
+	// E.g. Mocap suit for the full body, gloves that measure rotation of each finger segment
+	VRSkeletalTracking_Full = 2,
+
+	VRSkeletalTrackingLevel_Count,
+	VRSkeletalTrackingLevel_Max = VRSkeletalTrackingLevel_Count - 1
+};
+
+
+
+/** Holds the transform for a single bone */
+struct VRBoneTransform_t
+{
+	HmdVector4_t position;
+	HmdQuaternionf_t orientation;
+};
+
+/** Type used for referring to bones by their index */
+typedef int32_t BoneIndex_t;
+const BoneIndex_t k_unInvalidBoneIndex = -1;
+
+
+/** error codes returned by Vr_Init */
+
+// Please add adequate error description to https://developer.valvesoftware.com/w/index.php?title=Category:SteamVRHelp
+enum EVRInitError
+{
+	VRInitError_None	= 0,
+	VRInitError_Unknown = 1,
+
+	VRInitError_Init_InstallationNotFound			= 100,
+	VRInitError_Init_InstallationCorrupt			= 101,
+	VRInitError_Init_VRClientDLLNotFound			= 102,
+	VRInitError_Init_FileNotFound					= 103,
+	VRInitError_Init_FactoryNotFound				= 104,
+	VRInitError_Init_InterfaceNotFound				= 105,
+	VRInitError_Init_InvalidInterface				= 106,
+	VRInitError_Init_UserConfigDirectoryInvalid		= 107,
+	VRInitError_Init_HmdNotFound					= 108,
+	VRInitError_Init_NotInitialized					= 109,
+	VRInitError_Init_PathRegistryNotFound			= 110,
+	VRInitError_Init_NoConfigPath					= 111,
+	VRInitError_Init_NoLogPath						= 112,
+	VRInitError_Init_PathRegistryNotWritable		= 113,
+	VRInitError_Init_AppInfoInitFailed				= 114,
+	VRInitError_Init_Retry							= 115, // Used internally to cause retries to vrserver
+	VRInitError_Init_InitCanceledByUser				= 116, // The calling application should silently exit. The user canceled app startup
+	VRInitError_Init_AnotherAppLaunching			= 117, 
+	VRInitError_Init_SettingsInitFailed				= 118, 
+	VRInitError_Init_ShuttingDown					= 119,
+	VRInitError_Init_TooManyObjects					= 120,
+	VRInitError_Init_NoServerForBackgroundApp		= 121,
+	VRInitError_Init_NotSupportedWithCompositor		= 122,
+	VRInitError_Init_NotAvailableToUtilityApps		= 123,
+	VRInitError_Init_Internal				 		= 124,
+	VRInitError_Init_HmdDriverIdIsNone		 		= 125,
+	VRInitError_Init_HmdNotFoundPresenceFailed 		= 126,
+	VRInitError_Init_VRMonitorNotFound				= 127,
+	VRInitError_Init_VRMonitorStartupFailed			= 128,
+	VRInitError_Init_LowPowerWatchdogNotSupported	= 129, 
+	VRInitError_Init_InvalidApplicationType			= 130,
+	VRInitError_Init_NotAvailableToWatchdogApps		= 131,
+	VRInitError_Init_WatchdogDisabledInSettings		= 132,
+	VRInitError_Init_VRDashboardNotFound			= 133,
+	VRInitError_Init_VRDashboardStartupFailed		= 134,
+	VRInitError_Init_VRHomeNotFound					= 135,
+	VRInitError_Init_VRHomeStartupFailed			= 136,
+	VRInitError_Init_RebootingBusy					= 137,
+	VRInitError_Init_FirmwareUpdateBusy				= 138,
+	VRInitError_Init_FirmwareRecoveryBusy			= 139,
+	VRInitError_Init_USBServiceBusy					= 140,
+	VRInitError_Init_VRWebHelperStartupFailed		= 141,
+	VRInitError_Init_TrackerManagerInitFailed		= 142,
+	VRInitError_Init_AlreadyRunning					= 143,
+	VRInitError_Init_FailedForVrMonitor				= 144,
+	VRInitError_Init_PropertyManagerInitFailed		= 145,
+	VRInitError_Init_WebServerFailed				= 146,
+
+	VRInitError_Driver_Failed						= 200,
+	VRInitError_Driver_Unknown						= 201,
+	VRInitError_Driver_HmdUnknown					= 202,
+	VRInitError_Driver_NotLoaded					= 203,
+	VRInitError_Driver_RuntimeOutOfDate				= 204,
+	VRInitError_Driver_HmdInUse						= 205,
+	VRInitError_Driver_NotCalibrated				= 206,
+	VRInitError_Driver_CalibrationInvalid			= 207,
+	VRInitError_Driver_HmdDisplayNotFound			= 208,
+	VRInitError_Driver_TrackedDeviceInterfaceUnknown = 209,
+	// VRInitError_Driver_HmdDisplayNotFoundAfterFix = 210, // not needed: here for historic reasons
+	VRInitError_Driver_HmdDriverIdOutOfBounds		= 211,
+	VRInitError_Driver_HmdDisplayMirrored			= 212,
+	VRInitError_Driver_HmdDisplayNotFoundLaptop		= 213,
+	// Never make error 259 because we return it from main and it would conflict with STILL_ACTIVE
+
+	VRInitError_IPC_ServerInitFailed				= 300,
+	VRInitError_IPC_ConnectFailed					= 301,
+	VRInitError_IPC_SharedStateInitFailed			= 302,
+	VRInitError_IPC_CompositorInitFailed			= 303,
+	VRInitError_IPC_MutexInitFailed					= 304,
+	VRInitError_IPC_Failed							= 305,
+	VRInitError_IPC_CompositorConnectFailed			= 306,
+	VRInitError_IPC_CompositorInvalidConnectResponse = 307,
+	VRInitError_IPC_ConnectFailedAfterMultipleAttempts = 308,
+	VRInitError_IPC_ConnectFailedAfterTargetExited = 309,
+	VRInitError_IPC_NamespaceUnavailable			 = 310,
+
+	VRInitError_Compositor_Failed												= 400,
+	VRInitError_Compositor_D3D11HardwareRequired								= 401,
+	VRInitError_Compositor_FirmwareRequiresUpdate								= 402,
+	VRInitError_Compositor_OverlayInitFailed									= 403,
+	VRInitError_Compositor_ScreenshotsInitFailed								= 404,
+	VRInitError_Compositor_UnableToCreateDevice									= 405,
+	VRInitError_Compositor_SharedStateIsNull									= 406,
+	VRInitError_Compositor_NotificationManagerIsNull							= 407,
+	VRInitError_Compositor_ResourceManagerClientIsNull							= 408,
+	VRInitError_Compositor_MessageOverlaySharedStateInitFailure					= 409,
+	VRInitError_Compositor_PropertiesInterfaceIsNull							= 410,
+	VRInitError_Compositor_CreateFullscreenWindowFailed							= 411,
+	VRInitError_Compositor_SettingsInterfaceIsNull								= 412,
+	VRInitError_Compositor_FailedToShowWindow									= 413,
+	VRInitError_Compositor_DistortInterfaceIsNull								= 414,
+	VRInitError_Compositor_DisplayFrequencyFailure								= 415,
+	VRInitError_Compositor_RendererInitializationFailed							= 416,
+	VRInitError_Compositor_DXGIFactoryInterfaceIsNull							= 417,
+	VRInitError_Compositor_DXGIFactoryCreateFailed								= 418,
+	VRInitError_Compositor_DXGIFactoryQueryFailed								= 419,
+	VRInitError_Compositor_InvalidAdapterDesktop								= 420,
+	VRInitError_Compositor_InvalidHmdAttachment									= 421,
+	VRInitError_Compositor_InvalidOutputDesktop									= 422,
+	VRInitError_Compositor_InvalidDeviceProvided								= 423,
+	VRInitError_Compositor_D3D11RendererInitializationFailed					= 424,
+	VRInitError_Compositor_FailedToFindDisplayMode								= 425,
+	VRInitError_Compositor_FailedToCreateSwapChain								= 426,
+	VRInitError_Compositor_FailedToGetBackBuffer								= 427,
+	VRInitError_Compositor_FailedToCreateRenderTarget							= 428,
+	VRInitError_Compositor_FailedToCreateDXGI2SwapChain							= 429,
+	VRInitError_Compositor_FailedtoGetDXGI2BackBuffer							= 430,
+	VRInitError_Compositor_FailedToCreateDXGI2RenderTarget						= 431,
+	VRInitError_Compositor_FailedToGetDXGIDeviceInterface						= 432,
+	VRInitError_Compositor_SelectDisplayMode									= 433,
+	VRInitError_Compositor_FailedToCreateNvAPIRenderTargets						= 434,
+	VRInitError_Compositor_NvAPISetDisplayMode									= 435,
+	VRInitError_Compositor_FailedToCreateDirectModeDisplay						= 436,
+	VRInitError_Compositor_InvalidHmdPropertyContainer							= 437,
+	VRInitError_Compositor_UpdateDisplayFrequency								= 438,
+	VRInitError_Compositor_CreateRasterizerState								= 439,
+	VRInitError_Compositor_CreateWireframeRasterizerState						= 440,
+	VRInitError_Compositor_CreateSamplerState									= 441,
+	VRInitError_Compositor_CreateClampToBorderSamplerState						= 442,
+	VRInitError_Compositor_CreateAnisoSamplerState								= 443,
+	VRInitError_Compositor_CreateOverlaySamplerState							= 444,
+	VRInitError_Compositor_CreatePanoramaSamplerState							= 445,
+	VRInitError_Compositor_CreateFontSamplerState								= 446,
+	VRInitError_Compositor_CreateNoBlendState									= 447,
+	VRInitError_Compositor_CreateBlendState										= 448,
+	VRInitError_Compositor_CreateAlphaBlendState								= 449,
+	VRInitError_Compositor_CreateBlendStateMaskR								= 450,
+	VRInitError_Compositor_CreateBlendStateMaskG								= 451,
+	VRInitError_Compositor_CreateBlendStateMaskB								= 452,
+	VRInitError_Compositor_CreateDepthStencilState								= 453,
+	VRInitError_Compositor_CreateDepthStencilStateNoWrite						= 454,
+	VRInitError_Compositor_CreateDepthStencilStateNoDepth						= 455,
+	VRInitError_Compositor_CreateFlushTexture									= 456,
+	VRInitError_Compositor_CreateDistortionSurfaces								= 457,
+	VRInitError_Compositor_CreateConstantBuffer									= 458,
+	VRInitError_Compositor_CreateHmdPoseConstantBuffer							= 459,
+	VRInitError_Compositor_CreateHmdPoseStagingConstantBuffer					= 460,
+	VRInitError_Compositor_CreateSharedFrameInfoConstantBuffer					= 461,
+	VRInitError_Compositor_CreateOverlayConstantBuffer							= 462,
+	VRInitError_Compositor_CreateSceneTextureIndexConstantBuffer				= 463,
+	VRInitError_Compositor_CreateReadableSceneTextureIndexConstantBuffer		= 464,
+	VRInitError_Compositor_CreateLayerGraphicsTextureIndexConstantBuffer		= 465,
+	VRInitError_Compositor_CreateLayerComputeTextureIndexConstantBuffer			= 466,
+	VRInitError_Compositor_CreateLayerComputeSceneTextureIndexConstantBuffer	= 467,
+	VRInitError_Compositor_CreateComputeHmdPoseConstantBuffer					= 468,
+	VRInitError_Compositor_CreateGeomConstantBuffer								= 469,
+	VRInitError_Compositor_CreatePanelMaskConstantBuffer						= 470,
+	VRInitError_Compositor_CreatePixelSimUBO									= 471,
+	VRInitError_Compositor_CreateMSAARenderTextures								= 472,
+	VRInitError_Compositor_CreateResolveRenderTextures							= 473,
+	VRInitError_Compositor_CreateComputeResolveRenderTextures					= 474,
+	VRInitError_Compositor_CreateDriverDirectModeResolveTextures				= 475,
+	VRInitError_Compositor_OpenDriverDirectModeResolveTextures					= 476,
+	VRInitError_Compositor_CreateFallbackSyncTexture							= 477,
+	VRInitError_Compositor_ShareFallbackSyncTexture								= 478,
+	VRInitError_Compositor_CreateOverlayIndexBuffer								= 479,
+	VRInitError_Compositor_CreateOverlayVertexBuffer							= 480,
+	VRInitError_Compositor_CreateTextVertexBuffer								= 481,
+	VRInitError_Compositor_CreateTextIndexBuffer								= 482,
+	VRInitError_Compositor_CreateMirrorTextures									= 483,
+	VRInitError_Compositor_CreateLastFrameRenderTexture							= 484,
+	VRInitError_Compositor_CreateMirrorOverlay									= 485,
+	VRInitError_Compositor_FailedToCreateVirtualDisplayBackbuffer				= 486,
+	VRInitError_Compositor_DisplayModeNotSupported								= 487,
+	VRInitError_Compositor_CreateOverlayInvalidCall								= 488,
+	VRInitError_Compositor_CreateOverlayAlreadyInitialized						= 489,
+	VRInitError_Compositor_FailedToCreateMailbox								= 490,
+	
+	VRInitError_VendorSpecific_UnableToConnectToOculusRuntime		= 1000,
+	VRInitError_VendorSpecific_WindowsNotInDevMode					= 1001,
+
+	VRInitError_VendorSpecific_HmdFound_CantOpenDevice 				= 1101,
+	VRInitError_VendorSpecific_HmdFound_UnableToRequestConfigStart	= 1102,
+	VRInitError_VendorSpecific_HmdFound_NoStoredConfig 				= 1103,
+	VRInitError_VendorSpecific_HmdFound_ConfigTooBig 				= 1104,
+	VRInitError_VendorSpecific_HmdFound_ConfigTooSmall 				= 1105,
+	VRInitError_VendorSpecific_HmdFound_UnableToInitZLib 			= 1106,
+	VRInitError_VendorSpecific_HmdFound_CantReadFirmwareVersion 	= 1107,
+	VRInitError_VendorSpecific_HmdFound_UnableToSendUserDataStart	= 1108,
+	VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataStart	= 1109,
+	VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataNext		= 1110,
+	VRInitError_VendorSpecific_HmdFound_UserDataAddressRange		= 1111,
+	VRInitError_VendorSpecific_HmdFound_UserDataError				= 1112,
+	VRInitError_VendorSpecific_HmdFound_ConfigFailedSanityCheck		= 1113,
+	VRInitError_VendorSpecific_OculusRuntimeBadInstall				= 1114,
+
+	VRInitError_Steam_SteamInstallationNotFound = 2000,
+
+	// Strictly a placeholder
+	VRInitError_LastError
+};
+
+enum EVRScreenshotType
+{
+	VRScreenshotType_None = 0,
+	VRScreenshotType_Mono = 1, // left eye only
+	VRScreenshotType_Stereo = 2,
+	VRScreenshotType_Cubemap = 3,
+	VRScreenshotType_MonoPanorama = 4,
+	VRScreenshotType_StereoPanorama = 5
+};
+
+enum EVRScreenshotPropertyFilenames
+{
+	VRScreenshotPropertyFilenames_Preview = 0,
+	VRScreenshotPropertyFilenames_VR = 1,
+};
+
+enum EVRTrackedCameraError
+{
+	VRTrackedCameraError_None                       = 0,
+	VRTrackedCameraError_OperationFailed            = 100,
+	VRTrackedCameraError_InvalidHandle              = 101,	
+	VRTrackedCameraError_InvalidFrameHeaderVersion  = 102,
+	VRTrackedCameraError_OutOfHandles               = 103,
+	VRTrackedCameraError_IPCFailure                 = 104,
+	VRTrackedCameraError_NotSupportedForThisDevice  = 105,
+	VRTrackedCameraError_SharedMemoryFailure        = 106,
+	VRTrackedCameraError_FrameBufferingFailure      = 107,
+	VRTrackedCameraError_StreamSetupFailure         = 108,
+	VRTrackedCameraError_InvalidGLTextureId         = 109,
+	VRTrackedCameraError_InvalidSharedTextureHandle = 110,
+	VRTrackedCameraError_FailedToGetGLTextureId     = 111,
+	VRTrackedCameraError_SharedTextureFailure       = 112,
+	VRTrackedCameraError_NoFrameAvailable           = 113,
+	VRTrackedCameraError_InvalidArgument            = 114,
+	VRTrackedCameraError_InvalidFrameBufferSize     = 115,
+};
+
+enum EVRTrackedCameraFrameLayout
+{
+	EVRTrackedCameraFrameLayout_Mono				= 0x0001,
+	EVRTrackedCameraFrameLayout_Stereo				= 0x0002,
+	EVRTrackedCameraFrameLayout_VerticalLayout		= 0x0010,	// Stereo frames are Top/Bottom (left/right)
+	EVRTrackedCameraFrameLayout_HorizontalLayout	= 0x0020,	// Stereo frames are Left/Right
+};
+	
+enum EVRTrackedCameraFrameType
+{
+	VRTrackedCameraFrameType_Distorted = 0,			// This is the camera video frame size in pixels, still distorted.
+	VRTrackedCameraFrameType_Undistorted,			// In pixels, an undistorted inscribed rectangle region without invalid regions. This size is subject to changes shortly.
+	VRTrackedCameraFrameType_MaximumUndistorted,	// In pixels, maximum undistorted with invalid regions. Non zero alpha component identifies valid regions.
+	MAX_CAMERA_FRAME_TYPES
+};
+
+enum EVRDistortionFunctionType
+{
+	VRDistortionFunctionType_None,
+	VRDistortionFunctionType_FTheta,
+	VRDistortionFunctionType_Extended_FTheta,
+	MAX_DISTORTION_FUNCTION_TYPES,
+};
+
+static const uint32_t k_unMaxDistortionFunctionParameters = 8;
+
+typedef uint64_t TrackedCameraHandle_t;
+#define INVALID_TRACKED_CAMERA_HANDLE	((vr::TrackedCameraHandle_t)0)
+
+struct CameraVideoStreamFrameHeader_t
+{
+	EVRTrackedCameraFrameType eFrameType;
+
+	uint32_t nWidth;
+	uint32_t nHeight;
+	uint32_t nBytesPerPixel;
+
+	uint32_t nFrameSequence;
+
+	TrackedDevicePose_t trackedDevicePose;
+	
+	uint64_t ulFrameExposureTime;						// mid-point of the exposure of the image in host system ticks
+};
+
+// Screenshot types
+typedef uint32_t ScreenshotHandle_t;
+
+static const uint32_t k_unScreenshotHandleInvalid = 0;
+
+/** Compositor frame timing reprojection flags. */
+const uint32_t VRCompositor_ReprojectionReason_Cpu = 0x01;
+const uint32_t VRCompositor_ReprojectionReason_Gpu = 0x02;
+const uint32_t VRCompositor_ReprojectionAsync = 0x04;	// This flag indicates the async reprojection mode is active,
+															// but does not indicate if reprojection actually happened or not.
+															// Use the ReprojectionReason flags above to check if reprojection
+															// was actually applied (i.e. scene texture was reused).
+															// NumFramePresents > 1 also indicates the scene texture was reused,
+															// and also the number of times that it was presented in total.
+
+const uint32_t VRCompositor_ReprojectionMotion = 0x08;	// This flag indicates whether or not motion smoothing was triggered for this frame
+
+const uint32_t VRCompositor_PredictionMask = 0x30;	// The runtime may predict more than one frame (up to four) ahead if
+															// it detects the application is taking too long to render. These two
+															// bits will contain the count of additional frames (normally zero).
+															// Use the VR_COMPOSITOR_ADDITIONAL_PREDICTED_FRAMES macro to read from
+															// the latest frame timing entry.
+
+const uint32_t VRCompositor_ThrottleMask = 0xC0;	// Number of frames the compositor is throttling the application.
+															// Use the VR_COMPOSITOR_NUMBER_OF_THROTTLED_FRAMES macro to read from
+															// the latest frame timing entry.
+
+#define VR_COMPOSITOR_ADDITIONAL_PREDICTED_FRAMES( timing ) ( ( ( timing ).m_nReprojectionFlags & vr::VRCompositor_PredictionMask ) >> 4 )
+#define VR_COMPOSITOR_NUMBER_OF_THROTTLED_FRAMES( timing ) ( ( ( timing ).m_nReprojectionFlags & vr::VRCompositor_ThrottleMask ) >> 6 )
+
+/** Provides a single frame's timing information to the app */
+struct Compositor_FrameTiming
+{
+	uint32_t m_nSize; // Set to sizeof( Compositor_FrameTiming )
+	uint32_t m_nFrameIndex;
+	uint32_t m_nNumFramePresents; // number of times this frame was presented
+	uint32_t m_nNumMisPresented; // number of times this frame was presented on a vsync other than it was originally predicted to
+	uint32_t m_nNumDroppedFrames; // number of additional times previous frame was scanned out
+	uint32_t m_nReprojectionFlags;
+
+	/** Absolute time reference for comparing frames.  This aligns with the vsync that running start is relative to. */
+	double m_flSystemTimeInSeconds;
+
+	/** These times may include work from other processes due to OS scheduling.
+	* The fewer packets of work these are broken up into, the less likely this will happen.
+	* GPU work can be broken up by calling Flush.  This can sometimes be useful to get the GPU started
+	* processing that work earlier in the frame. */
+	float m_flPreSubmitGpuMs; // time spent rendering the scene (gpu work submitted between WaitGetPoses and second Submit)
+	float m_flPostSubmitGpuMs; // additional time spent rendering by application (e.g. companion window)
+	float m_flTotalRenderGpuMs; // time between work submitted immediately after present (ideally vsync) until the end of compositor submitted work
+	float m_flCompositorRenderGpuMs; // time spend performing distortion correction, rendering chaperone, overlays, etc.
+	float m_flCompositorRenderCpuMs; // time spent on cpu submitting the above work for this frame
+	float m_flCompositorIdleCpuMs; // time spent waiting for running start (application could have used this much more time)
+
+	/** Miscellaneous measured intervals. */
+	float m_flClientFrameIntervalMs; // time between calls to WaitGetPoses
+	float m_flPresentCallCpuMs; // time blocked on call to present (usually 0.0, but can go long)
+	float m_flWaitForPresentCpuMs; // time spent spin-waiting for frame index to change (not near-zero indicates wait object failure)
+	float m_flSubmitFrameMs; // time spent in IVRCompositor::Submit (not near-zero indicates driver issue)
+
+	/** The following are all relative to this frame's SystemTimeInSeconds */
+	float m_flWaitGetPosesCalledMs;
+	float m_flNewPosesReadyMs;
+	float m_flNewFrameReadyMs; // second call to IVRCompositor::Submit
+	float m_flCompositorUpdateStartMs;
+	float m_flCompositorUpdateEndMs;
+	float m_flCompositorRenderStartMs;
+
+	vr::TrackedDevicePose_t m_HmdPose; // pose used by app to render this frame
+
+	uint32_t m_nNumVSyncsReadyForUse;
+	uint32_t m_nNumVSyncsToFirstView;
+};
+
+/** Provides compositor benchmark results to the app */
+struct Compositor_BenchmarkResults
+{
+	float m_flMegaPixelsPerSecond; // Measurement of GPU MP/s performed by compositor benchmark
+	float m_flHmdRecommendedMegaPixelsPerSecond; // Recommended default MP/s given the HMD resolution, refresh, and panel mask.
+};
+
+/** Frame timing data provided by direct mode drivers. */
+struct DriverDirectMode_FrameTiming
+{
+	uint32_t m_nSize; // Set to sizeof( DriverDirectMode_FrameTiming )
+	uint32_t m_nNumFramePresents; // number of times frame was presented
+	uint32_t m_nNumMisPresented; // number of times frame was presented on a vsync other than it was originally predicted to
+	uint32_t m_nNumDroppedFrames; // number of additional times previous frame was scanned out (i.e. compositor missed vsync)
+	uint32_t m_nReprojectionFlags;
+};
+
+/** These flags will be set on DriverDirectMode_FrameTiming::m_nReprojectionFlags when IVRDriverDirectModeComponent::GetFrameTiming is called for drivers to optionally respond to. */
+const uint32_t VRCompositor_ReprojectionMotion_Enabled = 0x100; // Motion Smoothing is enabled in the UI for the currently running application
+const uint32_t VRCompositor_ReprojectionMotion_ForcedOn = 0x200; // Motion Smoothing is forced on in the UI for the currently running application
+const uint32_t VRCompositor_ReprojectionMotion_AppThrottled = 0x400; // Application is requesting throttling via ForceInterleavedReprojectionOn
+
+
+enum EVSync
+{
+	VSync_None,
+	VSync_WaitRender,	// block following render work until vsync
+	VSync_NoWaitRender,	// do not block following render work (allow to get started early)
+};
+
+enum EVRMuraCorrectionMode
+{
+	EVRMuraCorrectionMode_Default = 0,
+	EVRMuraCorrectionMode_NoCorrection
+};
+
+/** raw IMU data provided by IVRIOBuffer from paths to tracked devices with IMUs */
+enum Imu_OffScaleFlags
+{
+	OffScale_AccelX	= 0x01,
+	OffScale_AccelY	= 0x02,
+	OffScale_AccelZ	= 0x04,
+	OffScale_GyroX	= 0x08,
+	OffScale_GyroY	= 0x10,
+	OffScale_GyroZ	= 0x20,
+};
+	
+struct ImuSample_t
+{
+	double fSampleTime;
+	HmdVector3d_t vAccel;
+	HmdVector3d_t vGyro;
+	uint32_t unOffScaleFlags;
+};
+
+#pragma pack( pop )
+
+// figure out how to import from the VR API dll
+#if defined(_WIN32)
+
+  #if !defined(OPENVR_BUILD_STATIC)
+    #ifdef VR_API_EXPORT
+      #define VR_INTERFACE extern "C" __declspec( dllexport )
+    #else
+      #define VR_INTERFACE extern "C" __declspec( dllimport )
+    #endif
+  #else
+    #define VR_INTERFACE extern "C"
+  #endif
+
+#elif defined(__GNUC__) || defined(COMPILER_GCC) || defined(__APPLE__)
+
+#ifdef VR_API_EXPORT
+  #define VR_INTERFACE extern "C" __attribute__((visibility("default")))
+#else
+  #define VR_INTERFACE extern "C" 
+#endif
+
+#else
+  #error "Unsupported Platform."
+#endif
+
+
+#if defined( _WIN32 )
+  #define VR_CALLTYPE __cdecl
+#else
+  #define VR_CALLTYPE 
+#endif
+
+} // namespace vr
+
+#endif // _INCLUDE_VRTYPES_H
+
+
+// vrannotation.h
+#ifdef API_GEN
+# define VR_CLANG_ATTR(ATTR) __attribute__((annotate( ATTR )))
+#else
+# define VR_CLANG_ATTR(ATTR)
+#endif
+
+#define VR_METHOD_DESC(DESC) VR_CLANG_ATTR( "desc:" #DESC ";" )
+#define VR_IGNOREATTR() VR_CLANG_ATTR( "ignore" )
+#define VR_OUT_STRUCT() VR_CLANG_ATTR( "out_struct: ;" )
+#define VR_OUT_STRING() VR_CLANG_ATTR( "out_string: ;" )
+#define VR_OUT_ARRAY_CALL(COUNTER,FUNCTION,PARAMS) VR_CLANG_ATTR( "out_array_call:" #COUNTER "," #FUNCTION "," #PARAMS ";" )
+#define VR_OUT_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR( "out_array_count:" #COUNTER ";" )
+#define VR_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR( "array_count:" #COUNTER ";" )
+#define VR_ARRAY_COUNT_D(COUNTER, DESC) VR_CLANG_ATTR( "array_count:" #COUNTER ";desc:" #DESC )
+#define VR_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR( "buffer_count:" #COUNTER ";" )
+#define VR_OUT_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR( "out_buffer_count:" #COUNTER ";" )
+#define VR_OUT_STRING_COUNT(COUNTER) VR_CLANG_ATTR( "out_string_count:" #COUNTER ";" )
+
+// ivrsystem.h
+namespace vr
+{
+
+class IVRSystem
+{
+public:
+
+
+	// ------------------------------------
+	// Display Methods
+	// ------------------------------------
+
+	/** Suggested size for the intermediate render target that the distortion pulls from. */
+	virtual void GetRecommendedRenderTargetSize( uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
+
+	/** The projection matrix for the specified eye */
+	virtual HmdMatrix44_t GetProjectionMatrix( EVREye eEye, float fNearZ, float fFarZ ) = 0;
+
+	/** The components necessary to build your own projection matrix in case your
+	* application is doing something fancy like infinite Z */
+	virtual void GetProjectionRaw( EVREye eEye, float *pfLeft, float *pfRight, float *pfTop, float *pfBottom ) = 0;
+
+	/** Gets the result of the distortion function for the specified eye and input UVs. UVs go from 0,0 in 
+	* the upper left of that eye's viewport and 1,1 in the lower right of that eye's viewport.
+	* Returns true for success. Otherwise, returns false, and distortion coordinates are not suitable. */
+	virtual bool ComputeDistortion( EVREye eEye, float fU, float fV, DistortionCoordinates_t *pDistortionCoordinates ) = 0;
+
+	/** Returns the transform from eye space to the head space. Eye space is the per-eye flavor of head
+	* space that provides stereo disparity. Instead of Model * View * Projection the sequence is Model * View * Eye^-1 * Projection. 
+	* Normally View and Eye^-1 will be multiplied together and treated as View in your application. 
+	*/
+	virtual HmdMatrix34_t GetEyeToHeadTransform( EVREye eEye ) = 0;
+
+	/** Returns the number of elapsed seconds since the last recorded vsync event. This 
+	*	will come from a vsync timer event in the timer if possible or from the application-reported
+	*   time if that is not available. If no vsync times are available the function will 
+	*   return zero for vsync time and frame counter and return false from the method. */
+	virtual bool GetTimeSinceLastVsync( float *pfSecondsSinceLastVsync, uint64_t *pulFrameCounter ) = 0;
+
+	/** [D3D9 Only]
+	* Returns the adapter index that the user should pass into CreateDevice to set up D3D9 in such
+	* a way that it can go full screen exclusive on the HMD. Returns -1 if there was an error.
+	*/
+	virtual int32_t GetD3D9AdapterIndex() = 0;
+
+	/** [D3D10/11 Only]
+	* Returns the adapter index that the user should pass into EnumAdapters to create the device 
+	* and swap chain in DX10 and DX11. If an error occurs the index will be set to -1.
+	*/
+	virtual void GetDXGIOutputInfo( int32_t *pnAdapterIndex ) = 0;
+	
+	/**
+	 * Returns platform- and texture-type specific adapter identification so that applications and the
+	 * compositor are creating textures and swap chains on the same GPU. If an error occurs the device
+	 * will be set to 0.
+	 * pInstance is an optional parameter that is required only when textureType is TextureType_Vulkan.
+	 * [D3D10/11/12 Only (D3D9 Not Supported)]
+	 *  Returns the adapter LUID that identifies the GPU attached to the HMD. The user should
+	 *  enumerate all adapters using IDXGIFactory::EnumAdapters and IDXGIAdapter::GetDesc to find
+	 *  the adapter with the matching LUID, or use IDXGIFactory4::EnumAdapterByLuid.
+	 *  The discovered IDXGIAdapter should be used to create the device and swap chain.
+	 * [Vulkan Only]
+	 *  Returns the VkPhysicalDevice that should be used by the application.
+	 *  pInstance must be the instance the application will use to query for the VkPhysicalDevice.  The application
+	 *  must create the VkInstance with extensions returned by IVRCompositor::GetVulkanInstanceExtensionsRequired enabled.
+	 * [macOS Only]
+	 *  For TextureType_IOSurface returns the id<MTLDevice> that should be used by the application.
+	 *  On 10.13+ for TextureType_OpenGL returns the 'registryId' of the renderer which should be used
+	 *   by the application. See Apple Technical Q&A QA1168 for information on enumerating GL Renderers, and the
+	 *   new kCGLRPRegistryIDLow and kCGLRPRegistryIDHigh CGLRendererProperty values in the 10.13 SDK.
+	 *  Pre 10.13 for TextureType_OpenGL returns 0, as there is no dependable way to correlate the HMDs MTLDevice
+	 *   with a GL Renderer.
+	 */
+	virtual void GetOutputDevice( uint64_t *pnDevice, ETextureType textureType, VkInstance_T *pInstance = nullptr ) = 0;
+
+	// ------------------------------------
+	// Display Mode methods
+	// ------------------------------------
+
+	/** Use to determine if the headset display is part of the desktop (i.e. extended) or hidden (i.e. direct mode). */
+	virtual bool IsDisplayOnDesktop() = 0;
+
+	/** Set the display visibility (true = extended, false = direct mode).  Return value of true indicates that the change was successful. */
+	virtual bool SetDisplayVisibility( bool bIsVisibleOnDesktop ) = 0;
+
+	// ------------------------------------
+	// Tracking Methods
+	// ------------------------------------
+
+	/** The pose that the tracker thinks that the HMD will be in at the specified number of seconds into the 
+	* future. Pass 0 to get the state at the instant the method is called. Most of the time the application should
+	* calculate the time until the photons will be emitted from the display and pass that time into the method.
+	*
+	* This is roughly analogous to the inverse of the view matrix in most applications, though 
+	* many games will need to do some additional rotation or translation on top of the rotation
+	* and translation provided by the head pose.
+	*
+	* For devices where bPoseIsValid is true the application can use the pose to position the device
+	* in question. The provided array can be any size up to k_unMaxTrackedDeviceCount. 
+	*
+	* Seated experiences should call this method with TrackingUniverseSeated and receive poses relative
+	* to the seated zero pose. Standing experiences should call this method with TrackingUniverseStanding 
+	* and receive poses relative to the Chaperone Play Area. TrackingUniverseRawAndUncalibrated should 
+	* probably not be used unless the application is the Chaperone calibration tool itself, but will provide
+	* poses relative to the hardware-specific coordinate system in the driver.
+	*/
+	virtual void GetDeviceToAbsoluteTrackingPose( ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, VR_ARRAY_COUNT(unTrackedDevicePoseArrayCount) TrackedDevicePose_t *pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount ) = 0;
+
+	/** Sets the zero pose for the seated tracker coordinate system to the current position and yaw of the HMD. After 
+	* ResetSeatedZeroPose all GetDeviceToAbsoluteTrackingPose calls that pass TrackingUniverseSeated as the origin 
+	* will be relative to this new zero pose. The new zero coordinate system will not change the fact that the Y axis 
+	* is up in the real world, so the next pose returned from GetDeviceToAbsoluteTrackingPose after a call to 
+	* ResetSeatedZeroPose may not be exactly an identity matrix.
+	*
+	* NOTE: This function overrides the user's previously saved seated zero pose and should only be called as the result of a user action. 
+	* Users are also able to set their seated zero pose via the OpenVR Dashboard.
+	**/
+	virtual void ResetSeatedZeroPose() = 0;
+
+	/** Returns the transform from the seated zero pose to the standing absolute tracking system. This allows 
+	* applications to represent the seated origin to used or transform object positions from one coordinate
+	* system to the other. 
+	*
+	* The seated origin may or may not be inside the Play Area or Collision Bounds returned by IVRChaperone. Its position 
+	* depends on what the user has set from the Dashboard settings and previous calls to ResetSeatedZeroPose. */
+	virtual HmdMatrix34_t GetSeatedZeroPoseToStandingAbsoluteTrackingPose() = 0;
+
+	/** Returns the transform from the tracking origin to the standing absolute tracking system. This allows
+	* applications to convert from raw tracking space to the calibrated standing coordinate system. */
+	virtual HmdMatrix34_t GetRawZeroPoseToStandingAbsoluteTrackingPose() = 0;
+
+	/** Get a sorted array of device indices of a given class of tracked devices (e.g. controllers).  Devices are sorted right to left
+	* relative to the specified tracked device (default: hmd -- pass in -1 for absolute tracking space).  Returns the number of devices
+	* in the list, or the size of the array needed if not large enough. */
+	virtual uint32_t GetSortedTrackedDeviceIndicesOfClass( ETrackedDeviceClass eTrackedDeviceClass, VR_ARRAY_COUNT(unTrackedDeviceIndexArrayCount) vr::TrackedDeviceIndex_t *punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, vr::TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex = k_unTrackedDeviceIndex_Hmd ) = 0;
+
+	/** Returns the level of activity on the device. */
+	virtual EDeviceActivityLevel GetTrackedDeviceActivityLevel( vr::TrackedDeviceIndex_t unDeviceId ) = 0;
+
+	/** Convenience utility to apply the specified transform to the specified pose.
+	*   This properly transforms all pose components, including velocity and angular velocity
+	*/
+	virtual void ApplyTransform( TrackedDevicePose_t *pOutputPose, const TrackedDevicePose_t *pTrackedDevicePose, const HmdMatrix34_t *pTransform ) = 0;
+
+	/** Returns the device index associated with a specific role, for example the left hand or the right hand. This function is deprecated in favor of the new IVRInput system. */
+	virtual vr::TrackedDeviceIndex_t GetTrackedDeviceIndexForControllerRole( vr::ETrackedControllerRole unDeviceType ) = 0;
+
+	/** Returns the controller type associated with a device index. This function is deprecated in favor of the new IVRInput system. */
+	virtual vr::ETrackedControllerRole GetControllerRoleForTrackedDeviceIndex( vr::TrackedDeviceIndex_t unDeviceIndex ) = 0;
+
+	// ------------------------------------
+	// Property methods
+	// ------------------------------------
+
+	/** Returns the device class of a tracked device. If there has not been a device connected in this slot
+	* since the application started this function will return TrackedDevice_Invalid. For previous detected
+	* devices the function will return the previously observed device class. 
+	*
+	* To determine which devices exist on the system, just loop from 0 to k_unMaxTrackedDeviceCount and check
+	* the device class. Every device with something other than TrackedDevice_Invalid is associated with an 
+	* actual tracked device. */
+	virtual ETrackedDeviceClass GetTrackedDeviceClass( vr::TrackedDeviceIndex_t unDeviceIndex ) = 0;
+
+	/** Returns true if there is a device connected in this slot. */
+	virtual bool IsTrackedDeviceConnected( vr::TrackedDeviceIndex_t unDeviceIndex ) = 0;
+
+	/** Returns a bool property. If the device index is not valid or the property is not a bool type this function will return false. */
+	virtual bool GetBoolTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) = 0;
+
+	/** Returns a float property. If the device index is not valid or the property is not a float type this function will return 0. */
+	virtual float GetFloatTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) = 0;
+
+	/** Returns an int property. If the device index is not valid or the property is not a int type this function will return 0. */
+	virtual int32_t GetInt32TrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) = 0;
+
+	/** Returns a uint64 property. If the device index is not valid or the property is not a uint64 type this function will return 0. */
+	virtual uint64_t GetUint64TrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) = 0;
+
+	/** Returns a matrix property. If the device index is not valid or the property is not a matrix type, this function will return identity. */
+	virtual HmdMatrix34_t GetMatrix34TrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) = 0;
+	
+	/** Returns an array of one type of property. If the device index is not valid or the property is not a single value or an array of the specified type,
+	* this function will return 0. Otherwise it returns the number of bytes necessary to hold the array of properties. If unBufferSize is
+	* greater than the returned size and pBuffer is non-NULL, pBuffer is filled with the contents of array of properties. */
+	virtual uint32_t GetArrayTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void *pBuffer, uint32_t unBufferSize, ETrackedPropertyError *pError = 0L ) = 0;
+
+	/** Returns a string property. If the device index is not valid or the property is not a string type this function will 
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters. */
+	virtual uint32_t GetStringTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError = 0L ) = 0;
+
+	/** returns a string that corresponds with the specified property error. The string will be the name 
+	* of the error enum value for all valid error codes */
+	virtual const char *GetPropErrorNameFromEnum( ETrackedPropertyError error ) = 0;
+
+	// ------------------------------------
+	// Event methods
+	// ------------------------------------
+
+	/** Returns true and fills the event with the next event on the queue if there is one. If there are no events
+	* this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct */
+	virtual bool PollNextEvent( VREvent_t *pEvent, uint32_t uncbVREvent ) = 0;
+
+	/** Returns true and fills the event with the next event on the queue if there is one. If there are no events
+	* this method returns false. Fills in the pose of the associated tracked device in the provided pose struct. 
+	* This pose will always be older than the call to this function and should not be used to render the device. 
+	uncbVREvent should be the size in bytes of the VREvent_t struct */
+	virtual bool PollNextEventWithPose( ETrackingUniverseOrigin eOrigin, VREvent_t *pEvent, uint32_t uncbVREvent, vr::TrackedDevicePose_t *pTrackedDevicePose ) = 0;
+
+	/** returns the name of an EVREvent enum value */
+	virtual const char *GetEventTypeNameFromEnum( EVREventType eType ) = 0;
+
+	// ------------------------------------
+	// Rendering helper methods
+	// ------------------------------------
+
+	/** Returns the hidden area mesh for the current HMD. The pixels covered by this mesh will never be seen by the user after the lens distortion is
+	* applied based on visibility to the panels. If this HMD does not have a hidden area mesh, the vertex data and count will be NULL and 0 respectively.
+	* This mesh is meant to be rendered into the stencil buffer (or into the depth buffer setting nearz) before rendering each eye's view. 
+	* This will improve performance by letting the GPU early-reject pixels the user will never see before running the pixel shader.
+	* NOTE: Render this mesh with backface culling disabled since the winding order of the vertices can be different per-HMD or per-eye.
+	* Setting the bInverse argument to true will produce the visible area mesh that is commonly used in place of full-screen quads. The visible area mesh covers all of the pixels the hidden area mesh does not cover.
+	* Setting the bLineLoop argument will return a line loop of vertices in HiddenAreaMesh_t->pVertexData with HiddenAreaMesh_t->unTriangleCount set to the number of vertices.
+	*/
+	virtual HiddenAreaMesh_t GetHiddenAreaMesh( EVREye eEye, EHiddenAreaMeshType type = k_eHiddenAreaMesh_Standard ) = 0;
+
+	// ------------------------------------
+	// Controller methods
+	// ------------------------------------
+
+	/** Fills the supplied struct with the current state of the controller. Returns false if the controller index
+	* is invalid. This function is deprecated in favor of the new IVRInput system. */
+	virtual bool GetControllerState( vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize ) = 0;
+
+	/** fills the supplied struct with the current state of the controller and the provided pose with the pose of 
+	* the controller when the controller state was updated most recently. Use this form if you need a precise controller
+	* pose as input to your application when the user presses or releases a button. This function is deprecated in favor of the new IVRInput system. */
+	virtual bool GetControllerStateWithPose( ETrackingUniverseOrigin eOrigin, vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose ) = 0;
+
+	/** Trigger a single haptic pulse on a controller. After this call the application may not trigger another haptic pulse on this controller
+	* and axis combination for 5ms. This function is deprecated in favor of the new IVRInput system. */
+	virtual void TriggerHapticPulse( vr::TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec ) = 0;
+
+	/** returns the name of an EVRButtonId enum value. This function is deprecated in favor of the new IVRInput system.  */
+	virtual const char *GetButtonIdNameFromEnum( EVRButtonId eButtonId ) = 0;
+
+	/** returns the name of an EVRControllerAxisType enum value. This function is deprecated in favor of the new IVRInput system. */
+	virtual const char *GetControllerAxisTypeNameFromEnum( EVRControllerAxisType eAxisType ) = 0;
+
+	/** Returns true if this application is receiving input from the system. This would return false if 
+	* system-related functionality is consuming the input stream. */
+	virtual bool IsInputAvailable() = 0;
+
+	/** Returns true SteamVR is drawing controllers on top of the application. Applications should consider
+	* not drawing anything attached to the user's hands in this case. */
+	virtual bool IsSteamVRDrawingControllers() = 0;
+
+	/** Returns true if the user has put SteamVR into a mode that is distracting them from the application.
+	* For applications where this is appropriate, the application should pause ongoing activity. */
+	virtual bool ShouldApplicationPause() = 0;
+
+	/** Returns true if SteamVR is doing significant rendering work and the game should do what it can to reduce
+	* its own workload. One common way to do this is to reduce the size of the render target provided for each eye. */
+	virtual bool ShouldApplicationReduceRenderingWork() = 0;
+
+	// ------------------------------------
+	// Firmware methods
+	// ------------------------------------
+	
+	/** Performs the actual firmware update if applicable. 
+	 * The following events will be sent, if VRFirmwareError_None was returned: VREvent_FirmwareUpdateStarted, VREvent_FirmwareUpdateFinished 
+	 * Use the properties Prop_Firmware_UpdateAvailable_Bool, Prop_Firmware_ManualUpdate_Bool, and Prop_Firmware_ManualUpdateURL_String
+	 * to figure our whether a firmware update is available, and to figure out whether its a manual update 
+	 * Prop_Firmware_ManualUpdateURL_String should point to an URL describing the manual update process */
+	virtual vr::EVRFirmwareError PerformFirmwareUpdate( vr::TrackedDeviceIndex_t unDeviceIndex ) = 0;
+
+	// ------------------------------------
+	// Application life cycle methods
+	// ------------------------------------
+
+	/** Call this to acknowledge to the system that VREvent_Quit has been received and that the process is exiting.
+	* This extends the timeout until the process is killed. */
+	virtual void AcknowledgeQuit_Exiting() = 0;
+
+	// -------------------------------------
+	// App container sandbox methods
+	// -------------------------------------
+
+	/** Retrieves a null-terminated, semicolon-delimited list of UTF8 file paths that an application 
+	* must have read access to when running inside of an app container. Returns the number of bytes
+	* needed to hold the list. */
+	virtual uint32_t GetAppContainerFilePaths( VR_OUT_STRING() char *pchBuffer, uint32_t unBufferSize ) = 0;
+
+	// -------------------------------------
+	// System methods
+	// -------------------------------------
+
+	/** Returns the current version of the SteamVR runtime. The returned string will remain valid until VR_Shutdown is called.
+	*
+	* NOTE: Is it not appropriate to use this version to test for the presence of any SteamVR feature. Only use this version
+	* number for logging or showing to a user, and not to try to detect anything at runtime. When appropriate, feature-specific
+	* presence information is provided by other APIs. */
+	virtual const char *GetRuntimeVersion() = 0;
+
+};
+
+static const char * const IVRSystem_Version = "IVRSystem_021";
+
+}
+
+
+// ivrapplications.h
+namespace vr
+{
+
+	/** Used for all errors reported by the IVRApplications interface */
+	enum EVRApplicationError
+	{
+		VRApplicationError_None = 0,
+
+		VRApplicationError_AppKeyAlreadyExists = 100,	// Only one application can use any given key
+		VRApplicationError_NoManifest = 101,			// the running application does not have a manifest
+		VRApplicationError_NoApplication = 102,			// No application is running
+		VRApplicationError_InvalidIndex = 103,
+		VRApplicationError_UnknownApplication = 104,	// the application could not be found
+		VRApplicationError_IPCFailed = 105,				// An IPC failure caused the request to fail
+		VRApplicationError_ApplicationAlreadyRunning = 106, 
+		VRApplicationError_InvalidManifest = 107,
+		VRApplicationError_InvalidApplication = 108,
+		VRApplicationError_LaunchFailed = 109,			// the process didn't start
+		VRApplicationError_ApplicationAlreadyStarting = 110, // the system was already starting the same application
+		VRApplicationError_LaunchInProgress = 111,		// The system was already starting a different application
+		VRApplicationError_OldApplicationQuitting = 112, 
+		VRApplicationError_TransitionAborted = 113,
+		VRApplicationError_IsTemplate = 114, // error when you try to call LaunchApplication() on a template type app (use LaunchTemplateApplication)
+		VRApplicationError_SteamVRIsExiting = 115,
+
+		VRApplicationError_BufferTooSmall = 200,		// The provided buffer was too small to fit the requested data
+		VRApplicationError_PropertyNotSet = 201,		// The requested property was not set
+		VRApplicationError_UnknownProperty = 202,
+		VRApplicationError_InvalidParameter = 203,
+	};
+
+	/** The maximum length of an application key */
+	static const uint32_t k_unMaxApplicationKeyLength = 128;
+
+	/** these are the properties available on applications. */
+	enum EVRApplicationProperty
+	{
+		VRApplicationProperty_Name_String				= 0,
+
+		VRApplicationProperty_LaunchType_String			= 11,
+		VRApplicationProperty_WorkingDirectory_String	= 12,
+		VRApplicationProperty_BinaryPath_String			= 13,
+		VRApplicationProperty_Arguments_String			= 14,
+		VRApplicationProperty_URL_String				= 15,
+
+		VRApplicationProperty_Description_String		= 50,
+		VRApplicationProperty_NewsURL_String			= 51,
+		VRApplicationProperty_ImagePath_String			= 52,
+		VRApplicationProperty_Source_String				= 53,
+		VRApplicationProperty_ActionManifestURL_String	= 54,
+
+		VRApplicationProperty_IsDashboardOverlay_Bool	= 60,
+		VRApplicationProperty_IsTemplate_Bool			= 61,
+		VRApplicationProperty_IsInstanced_Bool			= 62,
+		VRApplicationProperty_IsInternal_Bool			= 63,
+		VRApplicationProperty_WantsCompositorPauseInStandby_Bool = 64,
+		VRApplicationProperty_IsHidden_Bool				= 65,
+
+		VRApplicationProperty_LastLaunchTime_Uint64		= 70,
+	};
+
+	enum EVRSceneApplicationState
+	{
+		EVRSceneApplicationState_None						      = 0, // Scene Application is not running
+		EVRSceneApplicationState_Starting					      = 1, // Scene Application is starting
+		EVRSceneApplicationState_Quitting					      = 2, // Scene Application is quitting
+		EVRSceneApplicationState_Running						  = 3, // Scene Application is running, and submitting frames, a custom skybox, or a visible overlay
+		EVRSceneApplicationState_Waiting						  = 4, // Scene Application is running, but not drawing anything
+	};
+
+	struct AppOverrideKeys_t
+	{
+		const char *pchKey;
+		const char *pchValue;
+	};
+
+	/** Currently recognized mime types */
+	static const char * const k_pch_MimeType_HomeApp		= "vr/home";
+	static const char * const k_pch_MimeType_GameTheater	= "vr/game_theater";
+
+	class IVRApplications
+	{
+	public:
+
+		// ---------------  Application management  --------------- //
+
+		/** Adds an application manifest to the list to load when building the list of installed applications. 
+		* Temporary manifests are not automatically loaded */
+		virtual EVRApplicationError AddApplicationManifest( const char *pchApplicationManifestFullPath, bool bTemporary = false ) = 0;
+
+		/** Removes an application manifest from the list to load when building the list of installed applications. */
+		virtual EVRApplicationError RemoveApplicationManifest( const char *pchApplicationManifestFullPath ) = 0;
+
+		/** Returns true if an application is installed */
+		virtual bool IsApplicationInstalled( const char *pchAppKey ) = 0;
+
+		/** Returns the number of applications available in the list */
+		virtual uint32_t GetApplicationCount() = 0;
+
+		/** Returns the key of the specified application. The index is at least 0 and is less than the return 
+		* value of GetApplicationCount(). The buffer should be at least k_unMaxApplicationKeyLength in order to 
+		* fit the key. */
+		virtual EVRApplicationError GetApplicationKeyByIndex( uint32_t unApplicationIndex, VR_OUT_STRING() char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) = 0;
+
+		/** Returns the key of the application for the specified Process Id. The buffer should be at least 
+		* k_unMaxApplicationKeyLength in order to fit the key. */
+		virtual EVRApplicationError GetApplicationKeyByProcessId( uint32_t unProcessId, VR_OUT_STRING() char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) = 0;
+
+		/** Launches the application. The existing scene application will exit and then the new application will start.
+		* This call is not valid for dashboard overlay applications. */
+		virtual EVRApplicationError LaunchApplication( const char *pchAppKey ) = 0;
+
+		/** Launches an instance of an application of type template, with its app key being pchNewAppKey (which must be unique) and optionally override sections
+		* from the manifest file via AppOverrideKeys_t
+		*/
+		virtual EVRApplicationError LaunchTemplateApplication( const char *pchTemplateAppKey, const char *pchNewAppKey, VR_ARRAY_COUNT( unKeys ) const AppOverrideKeys_t *pKeys, uint32_t unKeys ) = 0;
+
+		/** launches the application currently associated with this mime type and passes it the option args, typically the filename or object name of the item being launched */
+		virtual vr::EVRApplicationError LaunchApplicationFromMimeType( const char *pchMimeType, const char *pchArgs ) = 0;
+
+		/** Launches the dashboard overlay application if it is not already running. This call is only valid for 
+		* dashboard overlay applications. */
+		virtual EVRApplicationError LaunchDashboardOverlay( const char *pchAppKey ) = 0;
+
+		/** Cancel a pending launch for an application */
+		virtual bool CancelApplicationLaunch( const char *pchAppKey ) = 0;
+
+		/** Identifies a running application. OpenVR can't always tell which process started in response
+		* to a URL. This function allows a URL handler (or the process itself) to identify the app key 
+		* for the now running application. Passing a process ID of 0 identifies the calling process. 
+		* The application must be one that's known to the system via a call to AddApplicationManifest. */
+		virtual EVRApplicationError IdentifyApplication( uint32_t unProcessId, const char *pchAppKey ) = 0;
+
+		/** Returns the process ID for an application. Return 0 if the application was not found or is not running. */
+		virtual uint32_t GetApplicationProcessId( const char *pchAppKey ) = 0;
+
+		/** Returns a string for an applications error */
+		virtual const char *GetApplicationsErrorNameFromEnum( EVRApplicationError error ) = 0;
+
+		// ---------------  Application properties  --------------- //
+
+		/** Returns a value for an application property. The required buffer size to fit this value will be returned. */
+		virtual uint32_t GetApplicationPropertyString( const char *pchAppKey, EVRApplicationProperty eProperty, VR_OUT_STRING() char *pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError *peError = nullptr ) = 0;
+
+		/** Returns a bool value for an application property. Returns false in all error cases. */
+		virtual bool GetApplicationPropertyBool( const char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError = nullptr ) = 0;
+
+		/** Returns a uint64 value for an application property. Returns 0 in all error cases. */
+		virtual uint64_t GetApplicationPropertyUint64( const char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError = nullptr ) = 0;
+
+		/** Sets the application auto-launch flag. This is only valid for applications which return true for VRApplicationProperty_IsDashboardOverlay_Bool. */
+		virtual EVRApplicationError SetApplicationAutoLaunch( const char *pchAppKey, bool bAutoLaunch ) = 0;
+
+		/** Gets the application auto-launch flag. This is only valid for applications which return true for VRApplicationProperty_IsDashboardOverlay_Bool. */
+		virtual bool GetApplicationAutoLaunch( const char *pchAppKey ) = 0;
+
+		/** Adds this mime-type to the list of supported mime types for this application*/
+		virtual EVRApplicationError SetDefaultApplicationForMimeType( const char *pchAppKey, const char *pchMimeType ) = 0;
+
+		/** return the app key that will open this mime type */
+		virtual bool GetDefaultApplicationForMimeType( const char *pchMimeType, VR_OUT_STRING() char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) = 0;
+
+		/** Get the list of supported mime types for this application, comma-delimited */
+		virtual bool GetApplicationSupportedMimeTypes( const char *pchAppKey, VR_OUT_STRING() char *pchMimeTypesBuffer, uint32_t unMimeTypesBuffer ) = 0;
+
+		/** Get the list of app-keys that support this mime type, comma-delimited, the return value is number of bytes you need to return the full string */
+		virtual uint32_t GetApplicationsThatSupportMimeType( const char *pchMimeType, VR_OUT_STRING() char *pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer ) = 0;
+
+		/** Get the args list from an app launch that had the process already running, you call this when you get a VREvent_ApplicationMimeTypeLoad */
+		virtual uint32_t GetApplicationLaunchArguments( uint32_t unHandle, VR_OUT_STRING() char *pchArgs, uint32_t unArgs ) = 0;
+
+		// ---------------  Transition methods --------------- //
+
+		/** Returns the app key for the application that is starting up */
+		virtual EVRApplicationError GetStartingApplication( VR_OUT_STRING() char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) = 0;
+
+		/** Returns the application transition state */
+		virtual EVRSceneApplicationState GetSceneApplicationState() = 0;
+
+		/** Returns errors that would prevent the specified application from launching immediately. Calling this function will
+		* cause the current scene application to quit, so only call it when you are actually about to launch something else.
+		* What the caller should do about these failures depends on the failure:
+		*   VRApplicationError_OldApplicationQuitting - An existing application has been told to quit. Wait for a VREvent_ProcessQuit
+		*                                               and try again.
+		*   VRApplicationError_ApplicationAlreadyStarting - This application is already starting. This is a permanent failure.
+		*   VRApplicationError_LaunchInProgress	      - A different application is already starting. This is a permanent failure.
+		*   VRApplicationError_None                   - Go ahead and launch. Everything is clear.
+		*/
+		virtual EVRApplicationError PerformApplicationPrelaunchCheck( const char *pchAppKey ) = 0;
+
+		/** Returns a string for an application transition state */
+		virtual const char *GetSceneApplicationStateNameFromEnum( EVRSceneApplicationState state ) = 0;
+
+		/** Starts a subprocess within the calling application. This
+		* suppresses all application transition UI and automatically identifies the new executable 
+		* as part of the same application. On success the calling process should exit immediately. 
+		* If working directory is NULL or "" the directory portion of the binary path will be 
+		* the working directory. */
+		virtual EVRApplicationError LaunchInternalProcess( const char *pchBinaryPath, const char *pchArguments, const char *pchWorkingDirectory ) = 0;
+
+		/** Returns the current scene process ID according to the application system. A scene process will get scene
+		* focus once it starts rendering, but it will appear here once it calls VR_Init with the Scene application
+		* type. */
+		virtual uint32_t GetCurrentSceneProcessId() = 0;
+	};
+
+	static const char * const IVRApplications_Version = "IVRApplications_007";
+
+} // namespace vr
+
+// ivrsettings.h
+#include <string>
+
+namespace vr
+{
+	enum EVRSettingsError
+	{
+		VRSettingsError_None = 0,
+		VRSettingsError_IPCFailed = 1,
+		VRSettingsError_WriteFailed = 2,
+		VRSettingsError_ReadFailed = 3,
+		VRSettingsError_JsonParseFailed = 4,
+		VRSettingsError_UnsetSettingHasNoDefault = 5, // This will be returned if the setting does not appear in the appropriate default file and has not been set
+	};
+
+	// The maximum length of a settings key
+	static const uint32_t k_unMaxSettingsKeyLength = 128;
+
+	class IVRSettings
+	{
+	public:
+		virtual const char *GetSettingsErrorNameFromEnum( EVRSettingsError eError ) = 0;
+
+		virtual void SetBool( const char *pchSection, const char *pchSettingsKey, bool bValue, EVRSettingsError *peError = nullptr ) = 0;
+		virtual void SetInt32( const char *pchSection, const char *pchSettingsKey, int32_t nValue, EVRSettingsError *peError = nullptr ) = 0;
+		virtual void SetFloat( const char *pchSection, const char *pchSettingsKey, float flValue, EVRSettingsError *peError = nullptr ) = 0;
+		virtual void SetString( const char *pchSection, const char *pchSettingsKey, const char *pchValue, EVRSettingsError *peError = nullptr ) = 0;
+
+		// Users of the system need to provide a proper default in default.vrsettings in the resources/settings/ directory
+		// of either the runtime or the driver_xxx directory. Otherwise the default will be false, 0, 0.0 or ""
+		virtual bool GetBool( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) = 0;
+		virtual int32_t GetInt32( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) = 0;
+		virtual float GetFloat( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) = 0;
+		virtual void GetString( const char *pchSection, const char *pchSettingsKey, VR_OUT_STRING() char *pchValue, uint32_t unValueLen, EVRSettingsError *peError = nullptr ) = 0;
+
+		virtual void RemoveSection( const char *pchSection, EVRSettingsError *peError = nullptr ) = 0;
+		virtual void RemoveKeyInSection( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) = 0;
+	};
+
+	//-----------------------------------------------------------------------------
+	static const char * const IVRSettings_Version = "IVRSettings_003";
+
+	class CVRSettingHelper
+	{
+		IVRSettings *m_pSettings;
+	public:
+		CVRSettingHelper( IVRSettings *pSettings ) 
+		{ 
+			m_pSettings = pSettings; 
+		}
+
+		const char *GetSettingsErrorNameFromEnum( EVRSettingsError eError ) 
+		{ 
+			return m_pSettings->GetSettingsErrorNameFromEnum( eError ); 
+		}
+
+		void SetBool( const char *pchSection, const char *pchSettingsKey, bool bValue, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->SetBool( pchSection, pchSettingsKey, bValue, peError );
+		}
+
+		void SetInt32( const char *pchSection, const char *pchSettingsKey, int32_t nValue, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->SetInt32( pchSection, pchSettingsKey, nValue, peError );
+		}
+		void SetFloat( const char *pchSection, const char *pchSettingsKey, float flValue, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->SetFloat( pchSection, pchSettingsKey, flValue, peError );
+		}
+		void SetString( const char *pchSection, const char *pchSettingsKey, const char *pchValue, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->SetString( pchSection, pchSettingsKey, pchValue, peError );
+		}
+		void SetString( const std::string & sSection, const std::string &  sSettingsKey, const std::string & sValue, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->SetString( sSection.c_str(), sSettingsKey.c_str(), sValue.c_str(), peError );
+		}
+
+		bool GetBool( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr )
+		{
+			return m_pSettings->GetBool( pchSection, pchSettingsKey, peError );
+		}
+		int32_t GetInt32( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr )
+		{
+			return m_pSettings->GetInt32( pchSection, pchSettingsKey, peError );
+		}
+		float GetFloat( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr )
+		{
+			return m_pSettings->GetFloat( pchSection, pchSettingsKey, peError );
+		}
+		void GetString( const char *pchSection, const char *pchSettingsKey, VR_OUT_STRING() char *pchValue, uint32_t unValueLen, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->GetString( pchSection, pchSettingsKey, pchValue, unValueLen, peError );
+		}
+		std::string GetString( const std::string & sSection, const std::string & sSettingsKey, EVRSettingsError *peError = nullptr )
+		{
+			char buf[4096];
+			vr::EVRSettingsError eError;
+			m_pSettings->GetString( sSection.c_str(), sSettingsKey.c_str(), buf, sizeof( buf ), &eError );
+			if ( peError )
+				*peError = eError;
+			if ( eError == vr::VRSettingsError_None )
+				return buf;
+			else
+				return "";
+		}
+
+		void RemoveSection( const char *pchSection, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->RemoveSection( pchSection, peError );
+		}
+		void RemoveKeyInSection( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->RemoveKeyInSection( pchSection, pchSettingsKey, peError );
+		}
+	};
+
+
+	//-----------------------------------------------------------------------------
+	// steamvr keys
+	static const char * const k_pch_SteamVR_Section = "steamvr";
+	static const char * const k_pch_SteamVR_RequireHmd_String = "requireHmd";
+	static const char * const k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver";
+	static const char * const k_pch_SteamVR_ForcedHmdKey_String = "forcedHmd";
+	static const char * const k_pch_SteamVR_DisplayDebug_Bool = "displayDebug";
+	static const char * const k_pch_SteamVR_DebugProcessPipe_String = "debugProcessPipe";
+	static const char * const k_pch_SteamVR_DisplayDebugX_Int32 = "displayDebugX";
+	static const char * const k_pch_SteamVR_DisplayDebugY_Int32 = "displayDebugY";
+	static const char * const k_pch_SteamVR_SendSystemButtonToAllApps_Bool= "sendSystemButtonToAllApps";
+	static const char * const k_pch_SteamVR_LogLevel_Int32 = "loglevel";
+	static const char * const k_pch_SteamVR_IPD_Float = "ipd";
+	static const char * const k_pch_SteamVR_Background_String = "background";
+	static const char * const k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection";
+	static const char * const k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight";
+	static const char * const k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius";
+	static const char * const k_pch_SteamVR_GridColor_String = "gridColor";
+	static const char * const k_pch_SteamVR_PlayAreaColor_String = "playAreaColor";
+	static const char * const k_pch_SteamVR_TrackingLossColor_String = "trackingLossColor";
+	static const char * const k_pch_SteamVR_ShowStage_Bool = "showStage";
+	static const char * const k_pch_SteamVR_ActivateMultipleDrivers_Bool = "activateMultipleDrivers";
+	static const char * const k_pch_SteamVR_UsingSpeakers_Bool = "usingSpeakers";
+	static const char * const k_pch_SteamVR_SpeakersForwardYawOffsetDegrees_Float = "speakersForwardYawOffsetDegrees";
+	static const char * const k_pch_SteamVR_BaseStationPowerManagement_Int32 = "basestationPowerManagement";
+	static const char * const k_pch_SteamVR_ShowBaseStationPowerManagementTip_Int32 = "ShowBaseStationPowerManagementTip";
+	static const char * const k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses";
+	static const char * const k_pch_SteamVR_SupersampleScale_Float = "supersampleScale";
+	static const char * const k_pch_SteamVR_MaxRecommendedResolution_Int32 = "maxRecommendedResolution";
+	static const char * const k_pch_SteamVR_MotionSmoothing_Bool = "motionSmoothing";
+	static const char * const k_pch_SteamVR_MotionSmoothingOverride_Int32 = "motionSmoothingOverride";
+	static const char * const k_pch_SteamVR_DisableAsyncReprojection_Bool = "disableAsync";
+	static const char * const k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking";
+	static const char * const k_pch_SteamVR_DefaultMirrorView_Int32 = "mirrorView";
+	static const char * const k_pch_SteamVR_ShowLegacyMirrorView_Bool = "showLegacyMirrorView";
+	static const char * const k_pch_SteamVR_MirrorViewVisibility_Bool = "showMirrorView";
+	static const char * const k_pch_SteamVR_MirrorViewDisplayMode_Int32 = "mirrorViewDisplayMode";
+	static const char * const k_pch_SteamVR_MirrorViewEye_Int32 = "mirrorViewEye";
+	static const char * const k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry";
+	static const char * const k_pch_SteamVR_MirrorViewGeometryMaximized_String = "mirrorViewGeometryMaximized";
+	static const char * const k_pch_SteamVR_PerfGraphVisibility_Bool = "showPerfGraph";
+	static const char * const k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch";
+	static const char * const k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch";
+	static const char * const k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch";
+	static const char * const k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard";
+	static const char * const k_pch_SteamVR_EnableHomeApp = "enableHomeApp";
+	static const char * const k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec";
+	static const char * const k_pch_SteamVR_RetailDemo_Bool = "retailDemo";
+	static const char * const k_pch_SteamVR_IpdOffset_Float = "ipdOffset";
+	static const char * const k_pch_SteamVR_AllowSupersampleFiltering_Bool = "allowSupersampleFiltering";
+	static const char * const k_pch_SteamVR_SupersampleManualOverride_Bool = "supersampleManualOverride";
+	static const char * const k_pch_SteamVR_EnableLinuxVulkanAsync_Bool = "enableLinuxVulkanAsync";
+	static const char * const k_pch_SteamVR_AllowDisplayLockedMode_Bool = "allowDisplayLockedMode";
+	static const char * const k_pch_SteamVR_HaveStartedTutorialForNativeChaperoneDriver_Bool = "haveStartedTutorialForNativeChaperoneDriver";
+	static const char * const k_pch_SteamVR_ForceWindows32bitVRMonitor = "forceWindows32BitVRMonitor";
+	static const char * const k_pch_SteamVR_DebugInputBinding = "debugInputBinding";
+	static const char * const k_pch_SteamVR_DoNotFadeToGrid = "doNotFadeToGrid";
+	static const char * const k_pch_SteamVR_RenderCameraMode = "renderCameraMode";
+	static const char * const k_pch_SteamVR_EnableSharedResourceJournaling = "enableSharedResourceJournaling";
+	static const char * const k_pch_SteamVR_EnableSafeMode = "enableSafeMode";
+	static const char * const k_pch_SteamVR_PreferredRefreshRate = "preferredRefreshRate";
+	static const char * const k_pch_SteamVR_LastVersionNotice = "lastVersionNotice";
+	static const char * const k_pch_SteamVR_LastVersionNoticeDate = "lastVersionNoticeDate";
+	static const char * const k_pch_SteamVR_HmdDisplayColorGainR_Float = "hmdDisplayColorGainR";
+	static const char * const k_pch_SteamVR_HmdDisplayColorGainG_Float = "hmdDisplayColorGainG";
+	static const char * const k_pch_SteamVR_HmdDisplayColorGainB_Float = "hmdDisplayColorGainB";
+	static const char * const k_pch_SteamVR_CustomIconStyle_String = "customIconStyle";
+	static const char * const k_pch_SteamVR_CustomOffIconStyle_String = "customOffIconStyle";
+	static const char * const k_pch_SteamVR_CustomIconForceUpdate_String = "customIconForceUpdate";
+	static const char * const k_pch_SteamVR_AllowGlobalActionSetPriority = "globalActionSetPriority";
+	static const char * const k_pch_SteamVR_OverlayRenderQuality = "overlayRenderQuality_2";
+
+	//-----------------------------------------------------------------------------
+	// direct mode keys
+	static const char * const k_pch_DirectMode_Section = "direct_mode";
+	static const char * const k_pch_DirectMode_Enable_Bool = "enable";
+	static const char * const k_pch_DirectMode_Count_Int32 = "count";
+	static const char * const k_pch_DirectMode_EdidVid_Int32 = "edidVid";
+	static const char * const k_pch_DirectMode_EdidPid_Int32 = "edidPid";
+
+	//-----------------------------------------------------------------------------
+	// lighthouse keys
+	static const char * const k_pch_Lighthouse_Section = "driver_lighthouse";
+	static const char * const k_pch_Lighthouse_DisableIMU_Bool = "disableimu";
+	static const char * const k_pch_Lighthouse_DisableIMUExceptHMD_Bool = "disableimuexcepthmd";
+	static const char * const k_pch_Lighthouse_UseDisambiguation_String = "usedisambiguation";
+	static const char * const k_pch_Lighthouse_DisambiguationDebug_Int32 = "disambiguationdebug";
+	static const char * const k_pch_Lighthouse_PrimaryBasestation_Int32 = "primarybasestation";
+	static const char * const k_pch_Lighthouse_DBHistory_Bool = "dbhistory";
+	static const char * const k_pch_Lighthouse_EnableBluetooth_Bool = "enableBluetooth";
+	static const char * const k_pch_Lighthouse_PowerManagedBaseStations_String = "PowerManagedBaseStations";
+	static const char * const k_pch_Lighthouse_PowerManagedBaseStations2_String = "PowerManagedBaseStations2";
+	static const char * const k_pch_Lighthouse_InactivityTimeoutForBaseStations_Int32 = "InactivityTimeoutForBaseStations";
+	static const char * const k_pch_Lighthouse_EnableImuFallback_Bool = "enableImuFallback";
+
+	//-----------------------------------------------------------------------------
+	// null keys
+	static const char * const k_pch_Null_Section = "driver_null";
+	static const char * const k_pch_Null_SerialNumber_String = "serialNumber";
+	static const char * const k_pch_Null_ModelNumber_String = "modelNumber";
+	static const char * const k_pch_Null_WindowX_Int32 = "windowX";
+	static const char * const k_pch_Null_WindowY_Int32 = "windowY";
+	static const char * const k_pch_Null_WindowWidth_Int32 = "windowWidth";
+	static const char * const k_pch_Null_WindowHeight_Int32 = "windowHeight";
+	static const char * const k_pch_Null_RenderWidth_Int32 = "renderWidth";
+	static const char * const k_pch_Null_RenderHeight_Int32 = "renderHeight";
+	static const char * const k_pch_Null_SecondsFromVsyncToPhotons_Float = "secondsFromVsyncToPhotons";
+	static const char * const k_pch_Null_DisplayFrequency_Float = "displayFrequency";
+
+	//-----------------------------------------------------------------------------
+	// Windows MR keys
+	static const char * const k_pch_WindowsMR_Section = "driver_holographic";
+
+	//-----------------------------------------------------------------------------
+	// user interface keys
+	static const char * const k_pch_UserInterface_Section = "userinterface";
+	static const char * const k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop";
+	static const char * const k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray";
+	static const char * const k_pch_UserInterface_HidePopupsWhenStatusMinimized_Bool = "HidePopupsWhenStatusMinimized";
+	static const char * const k_pch_UserInterface_Screenshots_Bool = "screenshots";
+	static const char * const k_pch_UserInterface_ScreenshotType_Int = "screenshotType";
+
+	//-----------------------------------------------------------------------------
+	// notification keys
+	static const char * const k_pch_Notifications_Section = "notifications";
+	static const char * const k_pch_Notifications_DoNotDisturb_Bool = "DoNotDisturb";
+
+	//-----------------------------------------------------------------------------
+	// keyboard keys
+	static const char * const k_pch_Keyboard_Section = "keyboard";
+	static const char * const k_pch_Keyboard_TutorialCompletions = "TutorialCompletions";
+	static const char * const k_pch_Keyboard_ScaleX = "ScaleX";
+	static const char * const k_pch_Keyboard_ScaleY = "ScaleY";
+	static const char * const k_pch_Keyboard_OffsetLeftX = "OffsetLeftX";
+	static const char * const k_pch_Keyboard_OffsetRightX = "OffsetRightX";
+	static const char * const k_pch_Keyboard_OffsetY = "OffsetY";
+	static const char * const k_pch_Keyboard_Smoothing = "Smoothing";
+
+	//-----------------------------------------------------------------------------
+	// perf keys
+	static const char * const k_pch_Perf_Section = "perfcheck";
+	static const char * const k_pch_Perf_PerfGraphInHMD_Bool = "perfGraphInHMD";
+	static const char * const k_pch_Perf_AllowTimingStore_Bool = "allowTimingStore";
+	static const char * const k_pch_Perf_SaveTimingsOnExit_Bool = "saveTimingsOnExit";
+	static const char * const k_pch_Perf_TestData_Float = "perfTestData";
+	static const char * const k_pch_Perf_GPUProfiling_Bool = "GPUProfiling";
+
+	//-----------------------------------------------------------------------------
+	// collision bounds keys
+	static const char * const k_pch_CollisionBounds_Section = "collisionBounds";
+	static const char * const k_pch_CollisionBounds_Style_Int32 = "CollisionBoundsStyle";
+	static const char * const k_pch_CollisionBounds_GroundPerimeterOn_Bool = "CollisionBoundsGroundPerimeterOn";
+	static const char * const k_pch_CollisionBounds_CenterMarkerOn_Bool = "CollisionBoundsCenterMarkerOn";
+	static const char * const k_pch_CollisionBounds_PlaySpaceOn_Bool = "CollisionBoundsPlaySpaceOn";
+	static const char * const k_pch_CollisionBounds_FadeDistance_Float = "CollisionBoundsFadeDistance";
+	static const char * const k_pch_CollisionBounds_WallHeight_Float = "CollisionBoundsWallHeight";
+	static const char * const k_pch_CollisionBounds_ColorGammaR_Int32 = "CollisionBoundsColorGammaR";
+	static const char * const k_pch_CollisionBounds_ColorGammaG_Int32 = "CollisionBoundsColorGammaG";
+	static const char * const k_pch_CollisionBounds_ColorGammaB_Int32 = "CollisionBoundsColorGammaB";
+	static const char * const k_pch_CollisionBounds_ColorGammaA_Int32 = "CollisionBoundsColorGammaA";
+	static const char * const k_pch_CollisionBounds_EnableDriverImport = "enableDriverBoundsImport";
+
+	//-----------------------------------------------------------------------------
+	// camera keys
+	static const char * const k_pch_Camera_Section = "camera";
+	static const char * const k_pch_Camera_EnableCamera_Bool = "enableCamera";
+	static const char * const k_pch_Camera_EnableCameraInDashboard_Bool = "enableCameraInDashboard";
+	static const char * const k_pch_Camera_EnableCameraForCollisionBounds_Bool = "enableCameraForCollisionBounds";
+	static const char * const k_pch_Camera_EnableCameraForRoomView_Bool = "enableCameraForRoomView";
+	static const char * const k_pch_Camera_BoundsColorGammaR_Int32 = "cameraBoundsColorGammaR";
+	static const char * const k_pch_Camera_BoundsColorGammaG_Int32 = "cameraBoundsColorGammaG";
+	static const char * const k_pch_Camera_BoundsColorGammaB_Int32 = "cameraBoundsColorGammaB";
+	static const char * const k_pch_Camera_BoundsColorGammaA_Int32 = "cameraBoundsColorGammaA";
+	static const char * const k_pch_Camera_BoundsStrength_Int32 = "cameraBoundsStrength";
+	static const char * const k_pch_Camera_RoomViewMode_Int32 = "cameraRoomViewMode";
+
+	//-----------------------------------------------------------------------------
+	// audio keys
+	static const char * const k_pch_audio_Section = "audio";
+	static const char * const k_pch_audio_SetOsDefaultPlaybackDevice_Bool = "setOsDefaultPlaybackDevice";
+	static const char * const k_pch_audio_EnablePlaybackDeviceOverride_Bool = "enablePlaybackDeviceOverride";
+	static const char * const k_pch_audio_PlaybackDeviceOverride_String = "playbackDeviceOverride";
+	static const char * const k_pch_audio_PlaybackDeviceOverrideName_String = "playbackDeviceOverrideName";
+	static const char * const k_pch_audio_SetOsDefaultRecordingDevice_Bool = "setOsDefaultRecordingDevice";
+	static const char * const k_pch_audio_EnableRecordingDeviceOverride_Bool = "enableRecordingDeviceOverride";
+	static const char * const k_pch_audio_RecordingDeviceOverride_String = "recordingDeviceOverride";
+	static const char * const k_pch_audio_RecordingDeviceOverrideName_String = "recordingDeviceOverrideName";
+	static const char * const k_pch_audio_EnablePlaybackMirror_Bool = "enablePlaybackMirror";
+	static const char * const k_pch_audio_PlaybackMirrorDevice_String = "playbackMirrorDevice";
+	static const char * const k_pch_audio_PlaybackMirrorDeviceName_String = "playbackMirrorDeviceName";
+	static const char * const k_pch_audio_OldPlaybackMirrorDevice_String = "onPlaybackMirrorDevice";
+	static const char * const k_pch_audio_ActiveMirrorDevice_String = "activePlaybackMirrorDevice";
+	static const char * const k_pch_audio_EnablePlaybackMirrorIndependentVolume_Bool = "enablePlaybackMirrorIndependentVolume";
+	static const char * const k_pch_audio_LastHmdPlaybackDeviceId_String = "lastHmdPlaybackDeviceId";
+	static const char * const k_pch_audio_VIVEHDMIGain = "viveHDMIGain";
+
+	//-----------------------------------------------------------------------------
+	// power management keys
+	static const char * const k_pch_Power_Section = "power";
+	static const char * const k_pch_Power_PowerOffOnExit_Bool = "powerOffOnExit";
+	static const char * const k_pch_Power_TurnOffScreensTimeout_Float = "turnOffScreensTimeout";
+	static const char * const k_pch_Power_TurnOffControllersTimeout_Float = "turnOffControllersTimeout";
+	static const char * const k_pch_Power_ReturnToWatchdogTimeout_Float = "returnToWatchdogTimeout";
+	static const char * const k_pch_Power_AutoLaunchSteamVROnButtonPress = "autoLaunchSteamVROnButtonPress";
+	static const char * const k_pch_Power_PauseCompositorOnStandby_Bool = "pauseCompositorOnStandby";
+
+	//-----------------------------------------------------------------------------
+	// dashboard keys
+	static const char * const k_pch_Dashboard_Section = "dashboard";
+	static const char * const k_pch_Dashboard_EnableDashboard_Bool = "enableDashboard";
+	static const char * const k_pch_Dashboard_ArcadeMode_Bool = "arcadeMode";
+	static const char * const k_pch_Dashboard_Position = "position";
+	static const char * const k_pch_Dashboard_DesktopScale = "desktopScale";
+	static const char * const k_pch_Dashboard_DashboardScale = "dashboardScale";
+
+	//-----------------------------------------------------------------------------
+	// model skin keys
+	static const char * const k_pch_modelskin_Section = "modelskins";
+
+	//-----------------------------------------------------------------------------
+	// driver keys - These could be checked in any driver_<name> section
+	static const char * const k_pch_Driver_Enable_Bool = "enable";
+	static const char * const k_pch_Driver_BlockedBySafemode_Bool = "blocked_by_safe_mode";
+	static const char * const k_pch_Driver_LoadPriority_Int32 = "loadPriority";
+
+	//-----------------------------------------------------------------------------
+	// web interface keys
+	static const char* const k_pch_WebInterface_Section = "WebInterface";
+
+	//-----------------------------------------------------------------------------
+	// vrwebhelper keys
+	static const char* const k_pch_VRWebHelper_Section = "VRWebHelper";
+	static const char* const k_pch_VRWebHelper_DebuggerEnabled_Bool = "DebuggerEnabled";
+	static const char* const k_pch_VRWebHelper_DebuggerPort_Int32 = "DebuggerPort";
+
+	//-----------------------------------------------------------------------------
+	// tracking overrides - keys are device paths, values are the device paths their
+	//  tracking/pose information overrides
+	static const char* const k_pch_TrackingOverride_Section = "TrackingOverrides";
+
+	//-----------------------------------------------------------------------------
+	// per-app keys - the section name for these is the app key itself. Some of these are prefixed by the controller type
+	static const char* const k_pch_App_BindingAutosaveURLSuffix_String = "AutosaveURL";
+	static const char* const k_pch_App_BindingLegacyAPISuffix_String = "_legacy";
+	static const char* const k_pch_App_BindingSteamVRInputAPISuffix_String = "_steamvrinput";
+	static const char* const k_pch_App_BindingCurrentURLSuffix_String = "CurrentURL";
+	static const char* const k_pch_App_BindingPreviousURLSuffix_String = "PreviousURL";
+	static const char* const k_pch_App_NeedToUpdateAutosaveSuffix_Bool = "NeedToUpdateAutosave";
+	static const char* const k_pch_App_DominantHand_Int32 = "DominantHand";
+
+	//-----------------------------------------------------------------------------
+	// configuration for trackers
+	static const char * const k_pch_Trackers_Section = "trackers";
+
+	//-----------------------------------------------------------------------------
+	// configuration for desktop UI windows
+	static const char * const k_pch_DesktopUI_Section = "DesktopUI";
+
+	//-----------------------------------------------------------------------------
+	// Last known keys for righting recovery
+	static const char * const k_pch_LastKnown_Section = "LastKnown";
+	static const char* const k_pch_LastKnown_HMDManufacturer_String = "HMDManufacturer";
+	static const char* const k_pch_LastKnown_HMDModel_String = "HMDModel";
+
+	//-----------------------------------------------------------------------------
+	// Dismissed warnings
+	static const char * const k_pch_DismissedWarnings_Section = "DismissedWarnings";
+
+	//-----------------------------------------------------------------------------
+	// Input Settings
+	static const char * const k_pch_Input_Section = "input";
+	static const char* const k_pch_Input_LeftThumbstickRotation_Float = "leftThumbstickRotation";
+	static const char* const k_pch_Input_RightThumbstickRotation_Float = "rightThumbstickRotation";
+	static const char* const k_pch_Input_ThumbstickDeadzone_Float = "thumbstickDeadzone";
+
+	//-----------------------------------------------------------------------------
+	// Log of GPU performance
+	static const char * const k_pch_GpuSpeed_Section = "GpuSpeed";
+
+} // namespace vr
+
+// ivrchaperone.h
+namespace vr
+{
+
+#pragma pack( push, 8 )
+
+enum ChaperoneCalibrationState
+{
+	// OK!
+	ChaperoneCalibrationState_OK = 1,									// Chaperone is fully calibrated and working correctly
+
+	// Warnings
+	ChaperoneCalibrationState_Warning = 100,
+	ChaperoneCalibrationState_Warning_BaseStationMayHaveMoved = 101,	// A base station thinks that it might have moved
+	ChaperoneCalibrationState_Warning_BaseStationRemoved = 102,			// There are less base stations than when calibrated
+	ChaperoneCalibrationState_Warning_SeatedBoundsInvalid = 103,		// Seated bounds haven't been calibrated for the current tracking center
+
+	// Errors
+	ChaperoneCalibrationState_Error = 200,								// The UniverseID is invalid
+	ChaperoneCalibrationState_Error_BaseStationUninitialized = 201,		// Tracking center hasn't be calibrated for at least one of the base stations
+	ChaperoneCalibrationState_Error_BaseStationConflict = 202,			// Tracking center is calibrated, but base stations disagree on the tracking space
+	ChaperoneCalibrationState_Error_PlayAreaInvalid = 203,				// Play Area hasn't been calibrated for the current tracking center
+	ChaperoneCalibrationState_Error_CollisionBoundsInvalid = 204,		// Collision Bounds haven't been calibrated for the current tracking center
+};
+
+
+/** HIGH LEVEL TRACKING SPACE ASSUMPTIONS:
+* 0,0,0 is the preferred standing area center.
+* 0Y is the floor height.
+* -Z is the preferred forward facing direction. */
+class IVRChaperone
+{
+public:
+
+	/** Get the current state of Chaperone calibration. This state can change at any time during a session due to physical base station changes. **/
+	virtual ChaperoneCalibrationState GetCalibrationState() = 0;
+
+	/** Returns the width and depth of the Play Area (formerly named Soft Bounds) in X and Z. 
+	* Tracking space center (0,0,0) is the center of the Play Area. **/
+	virtual bool GetPlayAreaSize( float *pSizeX, float *pSizeZ ) = 0;
+
+	/** Returns the 4 corner positions of the Play Area (formerly named Soft Bounds).
+	* Corners are in counter-clockwise order.
+	* Standing center (0,0,0) is the center of the Play Area.
+	* It's a rectangle.
+	* 2 sides are parallel to the X axis and 2 sides are parallel to the Z axis.
+	* Height of every corner is 0Y (on the floor). **/
+	virtual bool GetPlayAreaRect( HmdQuad_t *rect ) = 0;
+
+	/** Reload Chaperone data from the .vrchap file on disk. */
+	virtual void ReloadInfo( void ) = 0;
+
+	/** Optionally give the chaperone system a hit about the color and brightness in the scene **/
+	virtual void SetSceneColor( HmdColor_t color ) = 0;
+
+	/** Get the current chaperone bounds draw color and brightness **/
+	virtual void GetBoundsColor( HmdColor_t *pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, HmdColor_t *pOutputCameraColor ) = 0;
+
+	/** Determine whether the bounds are showing right now **/
+	virtual bool AreBoundsVisible() = 0;
+
+	/** Force the bounds to show, mostly for utilities **/
+	virtual void ForceBoundsVisible( bool bForce ) = 0;
+};
+
+static const char * const IVRChaperone_Version = "IVRChaperone_003";
+
+#pragma pack( pop )
+
+}
+
+// ivrchaperonesetup.h
+namespace vr
+{
+
+enum EChaperoneConfigFile
+{
+	EChaperoneConfigFile_Live = 1,		// The live chaperone config, used by most applications and games
+	EChaperoneConfigFile_Temp = 2,		// The temporary chaperone config, used to live-preview collision bounds in room setup
+};
+
+enum EChaperoneImportFlags
+{
+	EChaperoneImport_BoundsOnly = 0x0001,
+};
+
+/** Manages the working copy of the chaperone info. By default this will be the same as the 
+* live copy. Any changes made with this interface will stay in the working copy until 
+* CommitWorkingCopy() is called, at which point the working copy and the live copy will be 
+* the same again. */
+class IVRChaperoneSetup
+{
+public:
+
+	/** Saves the current working copy to disk */
+	virtual bool CommitWorkingCopy( EChaperoneConfigFile configFile ) = 0;
+
+	/** Reverts the working copy to match the live chaperone calibration.
+	* To modify existing data this MUST be do WHILE getting a non-error ChaperoneCalibrationStatus.
+	* Only after this should you do gets and sets on the existing data. */
+	virtual void RevertWorkingCopy() = 0;
+
+	/** Returns the width and depth of the Play Area (formerly named Soft Bounds) in X and Z from the working copy.
+	* Tracking space center (0,0,0) is the center of the Play Area. */
+	virtual bool GetWorkingPlayAreaSize( float *pSizeX, float *pSizeZ ) = 0;
+
+	/** Returns the 4 corner positions of the Play Area (formerly named Soft Bounds) from the working copy.
+	* Corners are in clockwise order.
+	* Tracking space center (0,0,0) is the center of the Play Area.
+	* It's a rectangle.
+	* 2 sides are parallel to the X axis and 2 sides are parallel to the Z axis.
+	* Height of every corner is 0Y (on the floor). **/
+	virtual bool GetWorkingPlayAreaRect( HmdQuad_t *rect ) = 0;
+
+	/** Returns the number of Quads if the buffer points to null. Otherwise it returns Quads 
+	* into the buffer up to the max specified from the working copy. */
+	virtual bool GetWorkingCollisionBoundsInfo( VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t* punQuadsCount ) = 0;
+
+	/** Returns the number of Quads if the buffer points to null. Otherwise it returns Quads 
+	* into the buffer up to the max specified. */
+	virtual bool GetLiveCollisionBoundsInfo( VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t* punQuadsCount ) = 0;
+
+	/** Returns the preferred seated position from the working copy. */
+	virtual bool GetWorkingSeatedZeroPoseToRawTrackingPose( HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose ) = 0;
+
+	/** Returns the standing origin from the working copy. */
+	virtual bool GetWorkingStandingZeroPoseToRawTrackingPose( HmdMatrix34_t *pmatStandingZeroPoseToRawTrackingPose ) = 0;
+
+	/** Sets the Play Area in the working copy. */
+	virtual void SetWorkingPlayAreaSize( float sizeX, float sizeZ ) = 0;
+
+	/** Sets the Collision Bounds in the working copy. Note: ceiling height is ignored. */
+	virtual void SetWorkingCollisionBoundsInfo( VR_ARRAY_COUNT(unQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t unQuadsCount ) = 0;
+
+	/** Sets the Collision Bounds in the working copy. */
+	virtual void SetWorkingPerimeter( VR_ARRAY_COUNT( unPointCount ) HmdVector2_t *pPointBuffer, uint32_t unPointCount ) = 0;
+
+	/** Sets the preferred seated position in the working copy. */
+	virtual void SetWorkingSeatedZeroPoseToRawTrackingPose( const HmdMatrix34_t *pMatSeatedZeroPoseToRawTrackingPose ) = 0;
+
+	/** Sets the preferred standing position in the working copy. */
+	virtual void SetWorkingStandingZeroPoseToRawTrackingPose( const HmdMatrix34_t *pMatStandingZeroPoseToRawTrackingPose ) = 0;
+
+	/** Tear everything down and reload it from the file on disk */
+	virtual void ReloadFromDisk( EChaperoneConfigFile configFile ) = 0;
+
+	/** Returns the preferred seated position. */
+	virtual bool GetLiveSeatedZeroPoseToRawTrackingPose( HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose ) = 0;
+
+	virtual bool ExportLiveToBuffer( VR_OUT_STRING() char *pBuffer, uint32_t *pnBufferLength ) = 0;
+	virtual bool ImportFromBufferToWorking( const char *pBuffer, uint32_t nImportFlags ) = 0;
+
+	/** Shows the chaperone data in the working set to preview in the compositor.*/
+	virtual void ShowWorkingSetPreview() = 0;
+
+	/** Hides the chaperone data in the working set to preview in the compositor (if it was visible).*/
+	virtual void HideWorkingSetPreview() = 0;
+
+	/** Fire an event that the tracking system can use to know room setup is about to begin. This lets the tracking
+	 * system make any last minute adjustments that should be incorporated into the new setup.  If the user is adjusting
+	 * live in HMD using a tweak tool, keep in mind that calling this might cause the user to see the room jump. */
+	virtual void RoomSetupStarting() = 0;
+};
+
+static const char * const IVRChaperoneSetup_Version = "IVRChaperoneSetup_006";
+
+
+}
+
+// ivrcompositor.h
+namespace vr
+{
+
+#pragma pack( push, 8 )
+
+/** Errors that can occur with the VR compositor */
+enum EVRCompositorError
+{
+	VRCompositorError_None						= 0,
+	VRCompositorError_RequestFailed				= 1,
+	VRCompositorError_IncompatibleVersion		= 100,
+	VRCompositorError_DoNotHaveFocus			= 101,
+	VRCompositorError_InvalidTexture			= 102,
+	VRCompositorError_IsNotSceneApplication		= 103,
+	VRCompositorError_TextureIsOnWrongDevice	= 104,
+	VRCompositorError_TextureUsesUnsupportedFormat = 105,
+	VRCompositorError_SharedTexturesNotSupported = 106,
+	VRCompositorError_IndexOutOfRange			= 107,
+	VRCompositorError_AlreadySubmitted			= 108,
+	VRCompositorError_InvalidBounds				= 109,
+	VRCompositorError_AlreadySet				= 110,
+};
+
+/** Timing mode passed to SetExplicitTimingMode(); see that function for documentation */
+enum EVRCompositorTimingMode
+{
+	VRCompositorTimingMode_Implicit											= 0,
+	VRCompositorTimingMode_Explicit_RuntimePerformsPostPresentHandoff		= 1,
+	VRCompositorTimingMode_Explicit_ApplicationPerformsPostPresentHandoff	= 2,
+};
+
+/** Cumulative stats for current application.  These are not cleared until a new app connects,
+* but they do stop accumulating once the associated app disconnects. */
+struct Compositor_CumulativeStats
+{
+	uint32_t m_nPid; // Process id associated with these stats (may no longer be running).
+	uint32_t m_nNumFramePresents; // total number of times we called present (includes reprojected frames)
+	uint32_t m_nNumDroppedFrames; // total number of times an old frame was re-scanned out (without reprojection)
+	uint32_t m_nNumReprojectedFrames; // total number of times a frame was scanned out a second time (with reprojection)
+
+	/** Values recorded at startup before application has fully faded in the first time. */
+	uint32_t m_nNumFramePresentsOnStartup;
+	uint32_t m_nNumDroppedFramesOnStartup;
+	uint32_t m_nNumReprojectedFramesOnStartup;
+
+	/** Applications may explicitly fade to the compositor.  This is usually to handle level transitions, and loading often causes
+	* system wide hitches.  The following stats are collected during this period.  Does not include values recorded during startup. */
+	uint32_t m_nNumLoading;
+	uint32_t m_nNumFramePresentsLoading;
+	uint32_t m_nNumDroppedFramesLoading;
+	uint32_t m_nNumReprojectedFramesLoading;
+
+	/** If we don't get a new frame from the app in less than 2.5 frames, then we assume the app has hung and start
+	* fading back to the compositor.  The following stats are a result of this, and are a subset of those recorded above.
+	* Does not include values recorded during start up or loading. */
+	uint32_t m_nNumTimedOut;
+	uint32_t m_nNumFramePresentsTimedOut;
+	uint32_t m_nNumDroppedFramesTimedOut;
+	uint32_t m_nNumReprojectedFramesTimedOut;
+};
+
+struct Compositor_StageRenderSettings
+{
+	/** Primary color is applied as a tint to (i.e. multiplied with) the model's texture */
+	HmdColor_t m_PrimaryColor;
+	HmdColor_t m_SecondaryColor;
+
+	/** Vignette radius is in meters and is used to fade to the specified secondary solid color over
+	* that 3D distance from the origin of the playspace. */
+	float m_flVignetteInnerRadius;
+	float m_flVignetteOuterRadius;
+
+	/** Fades to the secondary color based on view incidence.  This variable controls the linearity
+	* of the effect.  It is mutually exclusive with vignette.  Additionally, it treats the mesh as faceted. */
+	float m_flFresnelStrength;
+
+	/** Controls backface culling. */
+	bool m_bBackfaceCulling;
+
+	/** Converts the render model's texture to luma and applies to rgb equally.  This is useful to
+	* combat compression artifacts that can occur on desaturated source material. */
+	bool m_bGreyscale;
+
+	/** Renders mesh as a wireframe. */
+	bool m_bWireframe;
+};
+
+static inline Compositor_StageRenderSettings DefaultStageRenderSettings()
+{
+	Compositor_StageRenderSettings settings;
+	settings.m_PrimaryColor.r = 1.0f;
+	settings.m_PrimaryColor.g = 1.0f;
+	settings.m_PrimaryColor.b = 1.0f;
+	settings.m_PrimaryColor.a = 1.0f;
+	settings.m_SecondaryColor.r = 1.0f;
+	settings.m_SecondaryColor.g = 1.0f;
+	settings.m_SecondaryColor.b = 1.0f;
+	settings.m_SecondaryColor.a = 1.0f;
+	settings.m_flVignetteInnerRadius = 0.0f;
+	settings.m_flVignetteOuterRadius = 0.0f;
+	settings.m_flFresnelStrength = 0.0f;
+	settings.m_bBackfaceCulling = false;
+	settings.m_bGreyscale = false;
+	settings.m_bWireframe = false;
+	return settings;
+}
+
+#pragma pack( pop )
+
+/** Allows the application to interact with the compositor */
+class IVRCompositor
+{
+public:
+	/** Sets tracking space returned by WaitGetPoses */
+	virtual void SetTrackingSpace( ETrackingUniverseOrigin eOrigin ) = 0;
+
+	/** Gets current tracking space returned by WaitGetPoses */
+	virtual ETrackingUniverseOrigin GetTrackingSpace() = 0;
+
+	/** Scene applications should call this function to get poses to render with (and optionally poses predicted an additional frame out to use for gameplay).
+	* This function will block until "running start" milliseconds before the start of the frame, and should be called at the last moment before needing to
+	* start rendering.
+	*
+	* Return codes:
+	*	- IsNotSceneApplication (make sure to call VR_Init with VRApplicaiton_Scene)
+	*	- DoNotHaveFocus (some other app has taken focus - this will throttle the call to 10hz to reduce the impact on that app)
+	*/
+	virtual EVRCompositorError WaitGetPoses( VR_ARRAY_COUNT( unRenderPoseArrayCount ) TrackedDevicePose_t* pRenderPoseArray, uint32_t unRenderPoseArrayCount,
+		VR_ARRAY_COUNT( unGamePoseArrayCount ) TrackedDevicePose_t* pGamePoseArray, uint32_t unGamePoseArrayCount ) = 0;
+
+	/** Get the last set of poses returned by WaitGetPoses. */
+	virtual EVRCompositorError GetLastPoses( VR_ARRAY_COUNT( unRenderPoseArrayCount ) TrackedDevicePose_t* pRenderPoseArray, uint32_t unRenderPoseArrayCount,
+		VR_ARRAY_COUNT( unGamePoseArrayCount ) TrackedDevicePose_t* pGamePoseArray, uint32_t unGamePoseArrayCount ) = 0;
+
+	/** Interface for accessing last set of poses returned by WaitGetPoses one at a time.
+	* Returns VRCompositorError_IndexOutOfRange if unDeviceIndex not less than k_unMaxTrackedDeviceCount otherwise VRCompositorError_None.
+	* It is okay to pass NULL for either pose if you only want one of the values. */
+	virtual EVRCompositorError GetLastPoseForTrackedDeviceIndex( TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t *pOutputPose, TrackedDevicePose_t *pOutputGamePose ) = 0;
+
+	/** Updated scene texture to display. If pBounds is NULL the entire texture will be used.  If called from an OpenGL app, consider adding a glFlush after
+	* Submitting both frames to signal the driver to start processing, otherwise it may wait until the command buffer fills up, causing the app to miss frames.
+	*
+	* OpenGL dirty state:
+	*	glBindTexture
+	*
+	* Return codes:
+	*	- IsNotSceneApplication (make sure to call VR_Init with VRApplicaiton_Scene)
+	*	- DoNotHaveFocus (some other app has taken focus)
+	*	- TextureIsOnWrongDevice (application did not use proper AdapterIndex - see IVRSystem.GetDXGIOutputInfo)
+	*	- SharedTexturesNotSupported (application needs to call CreateDXGIFactory1 or later before creating DX device)
+	*	- TextureUsesUnsupportedFormat (scene textures must be compatible with DXGI sharing rules - e.g. uncompressed, no mips, etc.)
+	*	- InvalidTexture (usually means bad arguments passed in)
+	*	- AlreadySubmitted (app has submitted two left textures or two right textures in a single frame - i.e. before calling WaitGetPoses again)
+	*/
+	virtual EVRCompositorError Submit( EVREye eEye, const Texture_t *pTexture, const VRTextureBounds_t* pBounds = 0, EVRSubmitFlags nSubmitFlags = Submit_Default ) = 0;
+
+	/** Clears the frame that was sent with the last call to Submit. This will cause the 
+	* compositor to show the grid until Submit is called again. */
+	virtual void ClearLastSubmittedFrame() = 0;
+
+	/** Call immediately after presenting your app's window (i.e. companion window) to unblock the compositor.
+	* This is an optional call, which only needs to be used if you can't instead call WaitGetPoses immediately after Present.
+	* For example, if your engine's render and game loop are not on separate threads, or blocking the render thread until 3ms before the next vsync would
+	* introduce a deadlock of some sort.  This function tells the compositor that you have finished all rendering after having Submitted buffers for both
+	* eyes, and it is free to start its rendering work.  This should only be called from the same thread you are rendering on. */
+	virtual void PostPresentHandoff() = 0;
+
+	/** Returns true if timing data is filled it.  Sets oldest timing info if nFramesAgo is larger than the stored history.
+	* Be sure to set timing.size = sizeof(Compositor_FrameTiming) on struct passed in before calling this function. */
+	virtual bool GetFrameTiming( Compositor_FrameTiming *pTiming, uint32_t unFramesAgo = 0 ) = 0;
+
+	/** Interface for copying a range of timing data.  Frames are returned in ascending order (oldest to newest) with the last being the most recent frame.
+	* Only the first entry's m_nSize needs to be set, as the rest will be inferred from that.  Returns total number of entries filled out. */
+	virtual uint32_t GetFrameTimings( VR_ARRAY_COUNT( nFrames ) Compositor_FrameTiming *pTiming, uint32_t nFrames ) = 0;
+
+	/** Returns the time in seconds left in the current (as identified by FrameTiming's frameIndex) frame.
+	* Due to "running start", this value may roll over to the next frame before ever reaching 0.0. */
+	virtual float GetFrameTimeRemaining() = 0;
+
+	/** Fills out stats accumulated for the last connected application.  Pass in sizeof( Compositor_CumulativeStats ) as second parameter. */
+	virtual void GetCumulativeStats( Compositor_CumulativeStats *pStats, uint32_t nStatsSizeInBytes ) = 0;
+
+	/** Fades the view on the HMD to the specified color. The fade will take fSeconds, and the color values are between
+	* 0.0 and 1.0. This color is faded on top of the scene based on the alpha parameter. Removing the fade color instantly 
+	* would be FadeToColor( 0.0, 0.0, 0.0, 0.0, 0.0 ).  Values are in un-premultiplied alpha space. */
+	virtual void FadeToColor( float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground = false ) = 0;
+
+	/** Get current fade color value. */
+	virtual HmdColor_t GetCurrentFadeColor( bool bBackground = false ) = 0;
+
+	/** Fading the Grid in or out in fSeconds */
+	virtual void FadeGrid( float fSeconds, bool bFadeIn ) = 0;
+
+	/** Get current alpha value of grid. */
+	virtual float GetCurrentGridAlpha() = 0;
+
+	/** Override the skybox used in the compositor (e.g. for during level loads when the app can't feed scene images fast enough)
+	* Order is Front, Back, Left, Right, Top, Bottom.  If only a single texture is passed, it is assumed in lat-long format.
+	* If two are passed, it is assumed a lat-long stereo pair. */
+	virtual EVRCompositorError SetSkyboxOverride( VR_ARRAY_COUNT( unTextureCount ) const Texture_t *pTextures, uint32_t unTextureCount ) = 0;
+
+	/** Resets compositor skybox back to defaults. */
+	virtual void ClearSkyboxOverride() = 0;
+
+	/** Brings the compositor window to the front. This is useful for covering any other window that may be on the HMD
+	* and is obscuring the compositor window. */
+	virtual void CompositorBringToFront() = 0;
+
+	/** Pushes the compositor window to the back. This is useful for allowing other applications to draw directly to the HMD. */
+	virtual void CompositorGoToBack() = 0;
+
+	/** Tells the compositor process to clean up and exit. You do not need to call this function at shutdown. Under normal 
+	* circumstances the compositor will manage its own life cycle based on what applications are running. */
+	virtual void CompositorQuit() = 0;
+	
+	/** Return whether the compositor is fullscreen */
+	virtual bool IsFullscreen() = 0;
+
+	/** Returns the process ID of the process that is currently rendering the scene */
+	virtual uint32_t GetCurrentSceneFocusProcess() = 0;
+
+	/** Returns the process ID of the process that rendered the last frame (or 0 if the compositor itself rendered the frame.)
+	* Returns 0 when fading out from an app and the app's process Id when fading into an app. */
+	virtual uint32_t GetLastFrameRenderer() = 0;
+
+	/** Returns true if the current process has the scene focus */
+	virtual bool CanRenderScene() = 0;
+
+	/** DEPRECATED: Opens the headset view (as either a window or docked widget depending on user's preferences) that displays what the user
+	* sees in the headset. */
+	virtual void ShowMirrorWindow() = 0;
+
+	/** DEPRECATED: Closes the headset view, either as a window or docked widget. */
+	virtual void HideMirrorWindow() = 0;
+
+	/** DEPRECATED: Returns true if the headset view (either as a window or docked widget) is shown. */
+	virtual bool IsMirrorWindowVisible() = 0;
+
+	/** Writes back buffer and stereo left/right pair from the application to a 'screenshots' folder in the SteamVR runtime root. */
+	virtual void CompositorDumpImages() = 0;
+
+	/** Let an app know it should be rendering with low resources. */
+	virtual bool ShouldAppRenderWithLowResources() = 0;
+
+	/** Override interleaved reprojection logic to force on. */
+	virtual void ForceInterleavedReprojectionOn( bool bOverride ) = 0;
+
+	/** Force reconnecting to the compositor process. */
+	virtual void ForceReconnectProcess() = 0;
+
+	/** Temporarily suspends rendering (useful for finer control over scene transitions). */
+	virtual void SuspendRendering( bool bSuspend ) = 0;
+
+	/** Opens a shared D3D11 texture with the undistorted composited image for each eye.  Use ReleaseMirrorTextureD3D11 when finished
+	* instead of calling Release on the resource itself. */
+	virtual vr::EVRCompositorError GetMirrorTextureD3D11( vr::EVREye eEye, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView ) = 0;
+	virtual void ReleaseMirrorTextureD3D11( void *pD3D11ShaderResourceView ) = 0;
+
+	/** Access to mirror textures from OpenGL. */
+	virtual vr::EVRCompositorError GetMirrorTextureGL( vr::EVREye eEye, vr::glUInt_t *pglTextureId, vr::glSharedTextureHandle_t *pglSharedTextureHandle ) = 0;
+	virtual bool ReleaseSharedGLTexture( vr::glUInt_t glTextureId, vr::glSharedTextureHandle_t glSharedTextureHandle ) = 0;
+	virtual void LockGLSharedTextureForAccess( vr::glSharedTextureHandle_t glSharedTextureHandle ) = 0;
+	virtual void UnlockGLSharedTextureForAccess( vr::glSharedTextureHandle_t glSharedTextureHandle ) = 0;
+
+	/** [Vulkan Only]
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null.  The string will be a space separated list of-required instance extensions to enable in VkCreateInstance */
+	virtual uint32_t GetVulkanInstanceExtensionsRequired( VR_OUT_STRING() char *pchValue, uint32_t unBufferSize ) = 0;
+
+	/** [Vulkan only]
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null.  The string will be a space separated list of required device extensions to enable in VkCreateDevice */
+	virtual uint32_t GetVulkanDeviceExtensionsRequired( VkPhysicalDevice_T *pPhysicalDevice, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize ) = 0;
+
+	/** [ Vulkan/D3D12 Only ]
+	* There are two purposes for SetExplicitTimingMode:
+	*	1. To get a more accurate GPU timestamp for when the frame begins in Vulkan/D3D12 applications.
+	*	2. (Optional) To avoid having WaitGetPoses access the Vulkan queue so that the queue can be accessed from
+	*	another thread while WaitGetPoses is executing.
+	*
+	* More accurate GPU timestamp for the start of the frame is achieved by the application calling
+	* SubmitExplicitTimingData immediately before its first submission to the Vulkan/D3D12 queue.
+	* This is more accurate because normally this GPU timestamp is recorded during WaitGetPoses.  In D3D11, 
+	* WaitGetPoses queues a GPU timestamp write, but it does not actually get submitted to the GPU until the 
+	* application flushes.  By using SubmitExplicitTimingData, the timestamp is recorded at the same place for 
+	* Vulkan/D3D12 as it is for D3D11, resulting in a more accurate GPU time measurement for the frame.
+	*
+	* Avoiding WaitGetPoses accessing the Vulkan queue can be achieved using SetExplicitTimingMode as well.  If this is desired,
+	* the application should set the timing mode to Explicit_ApplicationPerformsPostPresentHandoff and *MUST* call PostPresentHandoff
+	* itself. If these conditions are met, then WaitGetPoses is guaranteed not to access the queue.  Note that PostPresentHandoff
+	* and SubmitExplicitTimingData will access the queue, so only WaitGetPoses becomes safe for accessing the queue from another
+	* thread. */
+	virtual void SetExplicitTimingMode( EVRCompositorTimingMode eTimingMode ) = 0;
+
+	/** [ Vulkan/D3D12 Only ]
+	* Submit explicit timing data.  When SetExplicitTimingMode is true, this must be called immediately before
+	* the application's first vkQueueSubmit (Vulkan) or ID3D12CommandQueue::ExecuteCommandLists (D3D12) of each frame.
+	* This function will insert a GPU timestamp write just before the application starts its rendering.  This function
+	* will perform a vkQueueSubmit on Vulkan so must not be done simultaneously with VkQueue operations on another thread.
+	* Returns VRCompositorError_RequestFailed if SetExplicitTimingMode is not enabled. */
+	virtual EVRCompositorError SubmitExplicitTimingData() = 0;
+
+	/** Indicates whether or not motion smoothing is enabled by the user settings.
+	* If you want to know if motion smoothing actually triggered due to a late frame, check Compositor_FrameTiming
+	* m_nReprojectionFlags & VRCompositor_ReprojectionMotion instead. */
+	virtual bool IsMotionSmoothingEnabled() = 0;
+
+	/** Indicates whether or not motion smoothing is supported by the current hardware. */
+	virtual bool IsMotionSmoothingSupported() = 0;
+
+	/** Indicates whether or not the current scene focus app is currently loading.  This is inferred from its use of FadeGrid to
+	* explicitly fade to the compositor to cover up the fact that it cannot render at a sustained full framerate during this time. */
+	virtual bool IsCurrentSceneFocusAppLoading() = 0;
+
+	/** Override the stage model used in the compositor to replace the grid.  RenderModelPath is a full path the an OBJ file to load.
+	* This file will be loaded asynchronously from disk and uploaded to the gpu by the runtime.  Once ready for rendering, the
+	* VREvent StageOverrideReady will be sent.  Use FadeToGrid to reveal.  Call ClearStageOverride to free the associated resources when finished. */
+	virtual EVRCompositorError SetStageOverride_Async( const char *pchRenderModelPath, const HmdMatrix34_t *pTransform = 0,
+		const Compositor_StageRenderSettings *pRenderSettings = 0, uint32_t nSizeOfRenderSettings = 0 ) = 0;
+
+	/** Resets the stage to its default user specified setting. */
+	virtual void ClearStageOverride() = 0;
+
+	/** Returns true if pBenchmarkResults is filled it.  Sets pBenchmarkResults with the result of the compositor benchmark.
+	* nSizeOfBenchmarkResults should be set to sizeof(Compositor_BenchmarkResults) */
+	virtual bool GetCompositorBenchmarkResults( Compositor_BenchmarkResults *pBenchmarkResults, uint32_t nSizeOfBenchmarkResults ) = 0;
+
+	/** Returns the frame id associated with the poses last returned by WaitGetPoses.  Deltas between IDs correspond to number of headset vsync intervals. */
+	virtual EVRCompositorError GetLastPosePredictionIDs( uint32_t *pRenderPosePredictionID, uint32_t *pGamePosePredictionID ) = 0;
+
+	/** Get the most up-to-date predicted (or recorded - up to 100ms old) set of poses for a given frame id. */
+	virtual EVRCompositorError GetPosesForFrame( uint32_t unPosePredictionID, VR_ARRAY_COUNT( unPoseArrayCount ) TrackedDevicePose_t* pPoseArray, uint32_t unPoseArrayCount ) = 0;
+};
+
+static const char * const IVRCompositor_Version = "IVRCompositor_026";
+
+} // namespace vr
+
+
+
+// ivrheadsetview.h
+namespace vr
+{
+	enum HeadsetViewMode_t
+	{
+		HeadsetViewMode_Left = 0,
+		HeadsetViewMode_Right,
+		HeadsetViewMode_Both
+	};
+
+	class IVRHeadsetView
+	{
+	public:
+		/** Sets the resolution in pixels to render the headset view. These values are clamped to k_unHeadsetViewMaxWidth
+		* and k_unHeadsetViewMaxHeight respectively. For cropped views, the rendered output will be fit to aspect ratio
+		* defined by the the specified dimensions. For uncropped views, the caller should use GetHeadsetViewAspectRation
+		* to adjust the requested render size to avoid squashing or stretching, and then apply letterboxing to compensate
+		* when displaying the results. */
+		virtual void SetHeadsetViewSize( uint32_t nWidth, uint32_t nHeight ) = 0;
+
+		/** Gets the current resolution used to render the headset view. */
+		virtual void GetHeadsetViewSize( uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
+
+		/** Set the mode used to render the headset view. */
+		virtual void SetHeadsetViewMode( HeadsetViewMode_t eHeadsetViewMode ) = 0;
+
+		/** Get the current mode used to render the headset view. */
+		virtual HeadsetViewMode_t GetHeadsetViewMode() = 0;
+
+		/** Set whether or not the headset view should be rendered cropped to hide the hidden area mesh or not. */
+		virtual void SetHeadsetViewCropped( bool bCropped ) = 0;
+
+		/** Get the current cropping status of the headset view. */
+		virtual bool GetHeadsetViewCropped() = 0;
+
+		/** Get the aspect ratio (width:height) of the uncropped headset view (accounting for the current set mode). */
+		virtual float GetHeadsetViewAspectRatio() = 0;
+
+		/** Set the range [0..1] that the headset view blends across the stereo overlapped area in cropped both mode. */
+		virtual void SetHeadsetViewBlendRange( float flStartPct, float flEndPct ) = 0;
+
+		/** Get the current range [0..1] that the headset view blends across the stereo overlapped area in cropped both mode. */
+		virtual void GetHeadsetViewBlendRange( float *pStartPct, float *pEndPct ) = 0;
+	};
+
+	static const uint32_t k_unHeadsetViewMaxWidth = 3840;
+	static const uint32_t k_unHeadsetViewMaxHeight = 2160;
+	static const char * const k_pchHeadsetViewOverlayKey = "system.HeadsetView";
+
+	static const char * const IVRHeadsetView_Version = "IVRHeadsetView_001";
+
+	/** Returns the current IVRHeadsetView pointer or NULL the interface could not be found. */
+	VR_INTERFACE vr::IVRHeadsetView *VR_CALLTYPE VRHeadsetView();
+
+} // namespace vr
+
+
+// ivrnotifications.h
+namespace vr
+{
+
+#pragma pack( push, 8 )
+
+// Used for passing graphic data
+struct NotificationBitmap_t
+{
+	NotificationBitmap_t()
+		: m_pImageData( nullptr )
+		, m_nWidth( 0 )
+		, m_nHeight( 0 )
+		, m_nBytesPerPixel( 0 )
+	{
+	}
+
+	void *m_pImageData;
+	int32_t m_nWidth;
+	int32_t m_nHeight;
+	int32_t m_nBytesPerPixel;
+};
+
+
+/** Be aware that the notification type is used as 'priority' to pick the next notification */
+enum EVRNotificationType
+{
+	/** Transient notifications are automatically hidden after a period of time set by the user. 
+	* They are used for things like information and chat messages that do not require user interaction. */
+	EVRNotificationType_Transient = 0,
+
+	/** Persistent notifications are shown to the user until they are hidden by calling RemoveNotification().
+	* They are used for things like phone calls and alarms that require user interaction. */
+	EVRNotificationType_Persistent = 1,
+
+	/** System notifications are shown no matter what. It is expected, that the ulUserValue is used as ID.
+	 * If there is already a system notification in the queue with that ID it is not accepted into the queue
+	 * to prevent spamming with system notification */
+	EVRNotificationType_Transient_SystemWithUserValue = 2,
+};
+
+enum EVRNotificationStyle
+{
+	/** Creates a notification with minimal external styling. */
+	EVRNotificationStyle_None = 0,
+
+	/** Used for notifications about overlay-level status. In Steam this is used for events like downloads completing. */
+	EVRNotificationStyle_Application = 100,
+
+	/** Used for notifications about contacts that are unknown or not available. In Steam this is used for friend invitations and offline friends. */
+	EVRNotificationStyle_Contact_Disabled = 200,
+
+	/** Used for notifications about contacts that are available but inactive. In Steam this is used for friends that are online but not playing a game. */
+	EVRNotificationStyle_Contact_Enabled = 201,
+
+	/** Used for notifications about contacts that are available and active. In Steam this is used for friends that are online and currently running a game. */
+	EVRNotificationStyle_Contact_Active = 202,
+};
+
+static const uint32_t k_unNotificationTextMaxSize = 256;
+
+typedef uint32_t VRNotificationId;
+
+
+
+#pragma pack( pop )
+
+/** Allows notification sources to interact with the VR system
+	This current interface is not yet implemented. Do not use yet. */
+class IVRNotifications
+{
+public:
+	/** Create a notification and enqueue it to be shown to the user.
+	* An overlay handle is required to create a notification, as otherwise it would be impossible for a user to act on it.
+	* To create a two-line notification, use a line break ('\n') to split the text into two lines.
+	* The pImage argument may be NULL, in which case the specified overlay's icon will be used instead. */
+	virtual EVRNotificationError CreateNotification( VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, EVRNotificationType type, const char *pchText, EVRNotificationStyle style, const NotificationBitmap_t *pImage, /* out */ VRNotificationId *pNotificationId ) = 0;
+
+	/** Destroy a notification, hiding it first if it currently shown to the user. */
+	virtual EVRNotificationError RemoveNotification( VRNotificationId notificationId ) = 0;
+
+};
+
+static const char * const IVRNotifications_Version = "IVRNotifications_002";
+
+} // namespace vr
+
+
+
+// ivroverlay.h
+namespace vr
+{
+
+	/** The maximum length of an overlay key in bytes, counting the terminating null character. */
+	static const uint32_t k_unVROverlayMaxKeyLength = 128;
+
+	/** The maximum length of an overlay name in bytes, counting the terminating null character. */
+	static const uint32_t k_unVROverlayMaxNameLength = 128;
+
+	/** The maximum number of overlays that can exist in the system at one time. */
+	static const uint32_t k_unMaxOverlayCount = 128;
+
+	/** The maximum number of overlay intersection mask primitives per overlay */
+	static const uint32_t k_unMaxOverlayIntersectionMaskPrimitivesCount = 32;
+
+	/** Types of input supported by VR Overlays */
+	enum VROverlayInputMethod
+	{
+		VROverlayInputMethod_None		= 0, // No input events will be generated automatically for this overlay
+		VROverlayInputMethod_Mouse		= 1, // Tracked controllers will get mouse events automatically
+		// VROverlayInputMethod_DualAnalog = 2, // No longer supported
+	};
+
+	/** Allows the caller to figure out which overlay transform getter to call. */
+	enum VROverlayTransformType
+	{
+		VROverlayTransform_Invalid					= -1,
+		VROverlayTransform_Absolute					= 0,
+		VROverlayTransform_TrackedDeviceRelative	= 1,
+		VROverlayTransform_SystemOverlay			= 2,
+		VROverlayTransform_TrackedComponent 		= 3,
+		VROverlayTransform_Cursor					= 4,
+		VROverlayTransform_DashboardTab				= 5,
+		VROverlayTransform_DashboardThumb			= 6,
+		VROverlayTransform_Mountable				= 7,
+	};
+
+	/** Overlay control settings */
+	enum VROverlayFlags
+	{
+		// Set this flag on a dashboard overlay to prevent a tab from showing up for that overlay
+		VROverlayFlags_NoDashboardTab = 1 << 3,
+
+		// When this is set the overlay will receive VREvent_ScrollDiscrete events like a mouse wheel. 
+		// Requires mouse input mode.
+		VROverlayFlags_SendVRDiscreteScrollEvents = 1 << 6,
+
+		// Indicates that the overlay would like to receive
+		VROverlayFlags_SendVRTouchpadEvents = 1 << 7,
+
+		// If set this will render a vertical scroll wheel on the primary controller, 
+		//  only needed if not using VROverlayFlags_SendVRScrollEvents but you still want to represent a scroll wheel
+		VROverlayFlags_ShowTouchPadScrollWheel = 1 << 8,
+
+		// If this is set ownership and render access to the overlay are transferred 
+		// to the new scene process on a call to IVRApplications::LaunchInternalProcess
+		VROverlayFlags_TransferOwnershipToInternalProcess = 1 << 9,
+
+		// If set, renders 50% of the texture in each eye, side by side
+		VROverlayFlags_SideBySide_Parallel = 1 << 10, // Texture is left/right
+		VROverlayFlags_SideBySide_Crossed = 1 << 11, // Texture is crossed and right/left
+
+		VROverlayFlags_Panorama = 1 << 12, // Texture is a panorama
+		VROverlayFlags_StereoPanorama = 1 << 13, // Texture is a stereo panorama
+
+		// If this is set on an overlay owned by the scene application that overlay
+		// will be sorted with the "Other" overlays on top of all other scene overlays
+		VROverlayFlags_SortWithNonSceneOverlays = 1 << 14,
+
+		// If set, the overlay will be shown in the dashboard, otherwise it will be hidden.
+		VROverlayFlags_VisibleInDashboard = 1 << 15,
+
+		// If this is set and the overlay's input method is not none, the system-wide laser mouse
+		// mode will be activated whenever this overlay is visible.
+		VROverlayFlags_MakeOverlaysInteractiveIfVisible = 1 << 16,
+
+		// If this is set the overlay will receive smooth VREvent_ScrollSmooth that emulate trackpad scrolling.
+		// Requires mouse input mode.
+		VROverlayFlags_SendVRSmoothScrollEvents = 1 << 17,
+
+		// If this is set, the overlay texture will be protected content, preventing unauthorized reads.
+		VROverlayFlags_ProtectedContent = 1 << 18,
+
+		// If this is set, the laser mouse splat will not be drawn over this overlay. The overlay will
+		// be responsible for drawing its own "cursor".
+		VROverlayFlags_HideLaserIntersection = 1 << 19,
+
+		// If this is set, clicking away from the overlay will cause it to receive a VREvent_Modal_Cancel event.
+		// This is ignored for dashboard overlays.
+		VROverlayFlags_WantsModalBehavior = 1 << 20,
+
+		// If this is set, alpha composition assumes the texture is pre-multiplied
+		VROverlayFlags_IsPremultiplied = 1 << 21,
+	};
+
+	enum VRMessageOverlayResponse
+	{
+		VRMessageOverlayResponse_ButtonPress_0 = 0,
+		VRMessageOverlayResponse_ButtonPress_1 = 1,
+		VRMessageOverlayResponse_ButtonPress_2 = 2,
+		VRMessageOverlayResponse_ButtonPress_3 = 3,
+		VRMessageOverlayResponse_CouldntFindSystemOverlay = 4,
+		VRMessageOverlayResponse_CouldntFindOrCreateClientOverlay= 5,
+		VRMessageOverlayResponse_ApplicationQuit = 6
+	};
+
+	struct VROverlayIntersectionParams_t
+	{
+		HmdVector3_t vSource;
+		HmdVector3_t vDirection;
+		ETrackingUniverseOrigin eOrigin;
+	};
+
+	struct VROverlayIntersectionResults_t
+	{
+		HmdVector3_t vPoint;
+		HmdVector3_t vNormal;
+		HmdVector2_t vUVs;
+		float fDistance;
+	};
+
+	// Input modes for the Big Picture gamepad text entry
+	enum EGamepadTextInputMode
+	{
+		k_EGamepadTextInputModeNormal = 0,
+		k_EGamepadTextInputModePassword = 1,
+		k_EGamepadTextInputModeSubmit = 2,
+	};
+
+	// Controls number of allowed lines for the Big Picture gamepad text entry
+	enum EGamepadTextInputLineMode
+	{
+		k_EGamepadTextInputLineModeSingleLine = 0,
+		k_EGamepadTextInputLineModeMultipleLines = 1
+	};
+
+	enum EVROverlayIntersectionMaskPrimitiveType
+	{
+		OverlayIntersectionPrimitiveType_Rectangle,
+		OverlayIntersectionPrimitiveType_Circle,
+	};
+
+	struct IntersectionMaskRectangle_t
+	{
+		float m_flTopLeftX;
+		float m_flTopLeftY;
+		float m_flWidth;
+		float m_flHeight;
+	};
+
+	struct IntersectionMaskCircle_t
+	{
+		float m_flCenterX;
+		float m_flCenterY;
+		float m_flRadius;
+	};
+
+	/** NOTE!!! If you change this you MUST manually update openvr_interop.cs.py and openvr_api_flat.h.py */
+	typedef union
+	{
+		IntersectionMaskRectangle_t m_Rectangle;
+		IntersectionMaskCircle_t m_Circle;
+	} VROverlayIntersectionMaskPrimitive_Data_t;
+
+	struct VROverlayIntersectionMaskPrimitive_t
+	{
+		EVROverlayIntersectionMaskPrimitiveType m_nPrimitiveType;
+		VROverlayIntersectionMaskPrimitive_Data_t m_Primitive;
+	};
+
+	enum EKeyboardFlags
+	{
+		KeyboardFlag_Minimal		= 1 << 0, // makes the keyboard send key events immediately instead of accumulating a buffer
+		KeyboardFlag_Modal			= 2 << 0, // makes the keyboard take all focus and dismiss when clicking off the panel
+	};
+
+
+	class IVROverlay
+	{
+	public:
+
+		// ---------------------------------------------
+		// Overlay management methods
+		// ---------------------------------------------
+
+		/** Finds an existing overlay with the specified key. */
+		virtual EVROverlayError FindOverlay( const char *pchOverlayKey, VROverlayHandle_t * pOverlayHandle ) = 0;
+
+		/** Creates a new named overlay. All overlays start hidden and with default settings. */
+		virtual EVROverlayError CreateOverlay( const char *pchOverlayKey, const char *pchOverlayName, VROverlayHandle_t * pOverlayHandle ) = 0;
+
+		/** Destroys the specified overlay. When an application calls VR_Shutdown all overlays created by that app are
+		* automatically destroyed. */
+		virtual EVROverlayError DestroyOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+		/** Fills the provided buffer with the string key of the overlay. Returns the size of buffer required to store the key, including
+		* the terminating null character. k_unVROverlayMaxKeyLength will be enough bytes to fit the string. */
+		virtual uint32_t GetOverlayKey( VROverlayHandle_t ulOverlayHandle, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, EVROverlayError *pError = 0L ) = 0;
+
+		/** Fills the provided buffer with the friendly name of the overlay. Returns the size of buffer required to store the key, including
+		* the terminating null character. k_unVROverlayMaxNameLength will be enough bytes to fit the string. */
+		virtual uint32_t GetOverlayName( VROverlayHandle_t ulOverlayHandle, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, EVROverlayError *pError = 0L ) = 0;
+
+		/** set the name to use for this overlay */
+		virtual EVROverlayError SetOverlayName( VROverlayHandle_t ulOverlayHandle, const char *pchName ) = 0;
+
+		/** Gets the raw image data from an overlay. Overlay image data is always returned as RGBA data, 4 bytes per pixel. If the buffer is not large enough, width and height 
+		* will be set and VROverlayError_ArrayTooSmall is returned. */
+		virtual EVROverlayError GetOverlayImageData( VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unBufferSize, uint32_t *punWidth, uint32_t *punHeight ) = 0;
+
+		/** returns a string that corresponds with the specified overlay error. The string will be the name 
+		* of the error enum value for all valid error codes */
+		virtual const char *GetOverlayErrorNameFromEnum( EVROverlayError error ) = 0;
+
+		// ---------------------------------------------
+		// Overlay rendering methods
+		// ---------------------------------------------
+
+		/** Sets the pid that is allowed to render to this overlay (the creator pid is always allow to render),
+		*	by default this is the pid of the process that made the overlay */
+		virtual EVROverlayError SetOverlayRenderingPid( VROverlayHandle_t ulOverlayHandle, uint32_t unPID ) = 0;
+
+		/** Gets the pid that is allowed to render to this overlay */
+		virtual uint32_t GetOverlayRenderingPid( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+		/** Specify flag setting for a given overlay */
+		virtual EVROverlayError SetOverlayFlag( VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled ) = 0;
+
+		/** Sets flag setting for a given overlay */
+		virtual EVROverlayError GetOverlayFlag( VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool *pbEnabled ) = 0;
+
+		/** Gets all the flags for a given overlay */
+		virtual EVROverlayError GetOverlayFlags( VROverlayHandle_t ulOverlayHandle, uint32_t *pFlags ) = 0;
+
+		/** Sets the color tint of the overlay quad. Use 0.0 to 1.0 per channel. */
+		virtual EVROverlayError SetOverlayColor( VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue ) = 0;
+
+		/** Gets the color tint of the overlay quad. */
+		virtual EVROverlayError GetOverlayColor( VROverlayHandle_t ulOverlayHandle, float *pfRed, float *pfGreen, float *pfBlue ) = 0;
+
+		/** Sets the alpha of the overlay quad. Use 1.0 for 100 percent opacity to 0.0 for 0 percent opacity. */
+		virtual EVROverlayError SetOverlayAlpha( VROverlayHandle_t ulOverlayHandle, float fAlpha ) = 0;
+
+		/** Gets the alpha of the overlay quad. By default overlays are rendering at 100 percent alpha (1.0). */
+		virtual EVROverlayError GetOverlayAlpha( VROverlayHandle_t ulOverlayHandle, float *pfAlpha ) = 0;
+
+		/** Sets the aspect ratio of the texels in the overlay. 1.0 means the texels are square. 2.0 means the texels
+		* are twice as wide as they are tall. Defaults to 1.0. */
+		virtual EVROverlayError SetOverlayTexelAspect( VROverlayHandle_t ulOverlayHandle, float fTexelAspect ) = 0;
+
+		/** Gets the aspect ratio of the texels in the overlay. Defaults to 1.0 */
+		virtual EVROverlayError GetOverlayTexelAspect( VROverlayHandle_t ulOverlayHandle, float *pfTexelAspect ) = 0;
+
+		/** Sets the rendering sort order for the overlay. Overlays are rendered this order:
+		*      Overlays owned by the scene application
+		*      Overlays owned by some other application
+		*
+		*	Within a category overlays are rendered lowest sort order to highest sort order. Overlays with the same 
+		*	sort order are rendered back to front base on distance from the HMD.
+		*
+		*	Sort order defaults to 0. */
+		virtual EVROverlayError SetOverlaySortOrder( VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder ) = 0;
+
+		/** Gets the sort order of the overlay. See SetOverlaySortOrder for how this works. */
+		virtual EVROverlayError GetOverlaySortOrder( VROverlayHandle_t ulOverlayHandle, uint32_t *punSortOrder ) = 0;
+
+		/** Sets the width of the overlay quad in meters. By default overlays are rendered on a quad that is 1 meter across */
+		virtual EVROverlayError SetOverlayWidthInMeters( VROverlayHandle_t ulOverlayHandle, float fWidthInMeters ) = 0;
+
+		/** Returns the width of the overlay quad in meters. By default overlays are rendered on a quad that is 1 meter across */
+		virtual EVROverlayError GetOverlayWidthInMeters( VROverlayHandle_t ulOverlayHandle, float *pfWidthInMeters ) = 0;
+
+		/** Use to draw overlay as a curved surface. Curvature is a percentage from (0..1] where 1 is a fully closed cylinder.
+		* For a specific radius, curvature can be computed as: overlay.width / (2 PI r). */
+		virtual EVROverlayError SetOverlayCurvature( VROverlayHandle_t ulOverlayHandle, float fCurvature ) = 0;
+
+		/** Returns the curvature of the overlay as a percentage from (0..1] where 1 is a fully closed cylinder. */
+		virtual EVROverlayError GetOverlayCurvature( VROverlayHandle_t ulOverlayHandle, float *pfCurvature ) = 0;
+
+		/** Sets the colorspace the overlay texture's data is in.  Defaults to 'auto'.
+		* If the texture needs to be resolved, you should call SetOverlayTexture with the appropriate colorspace instead. */
+		virtual EVROverlayError SetOverlayTextureColorSpace( VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace ) = 0;
+
+		/** Gets the overlay's current colorspace setting. */
+		virtual EVROverlayError GetOverlayTextureColorSpace( VROverlayHandle_t ulOverlayHandle, EColorSpace *peTextureColorSpace ) = 0;
+
+		/** Sets the part of the texture to use for the overlay. UV Min is the upper left corner and UV Max is the lower right corner. */
+		virtual EVROverlayError SetOverlayTextureBounds( VROverlayHandle_t ulOverlayHandle, const VRTextureBounds_t *pOverlayTextureBounds ) = 0;
+
+		/** Gets the part of the texture to use for the overlay. UV Min is the upper left corner and UV Max is the lower right corner. */
+		virtual EVROverlayError GetOverlayTextureBounds( VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t *pOverlayTextureBounds ) = 0;
+
+		/** Returns the transform type of this overlay. */
+		virtual EVROverlayError GetOverlayTransformType( VROverlayHandle_t ulOverlayHandle, VROverlayTransformType *peTransformType ) = 0;
+
+		/** Sets the transform to absolute tracking origin. */
+		virtual EVROverlayError SetOverlayTransformAbsolute( VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, const HmdMatrix34_t *pmatTrackingOriginToOverlayTransform ) = 0;
+
+		/** Gets the transform if it is absolute. Returns an error if the transform is some other type. */
+		virtual EVROverlayError GetOverlayTransformAbsolute( VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin *peTrackingOrigin, HmdMatrix34_t *pmatTrackingOriginToOverlayTransform ) = 0;
+
+		/** Sets the transform to relative to the transform of the specified tracked device. */
+		virtual EVROverlayError SetOverlayTransformTrackedDeviceRelative( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, const HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform ) = 0;
+
+		/** Gets the transform if it is relative to a tracked device. Returns an error if the transform is some other type. */
+		virtual EVROverlayError GetOverlayTransformTrackedDeviceRelative( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punTrackedDevice, HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform ) = 0;
+
+		/** Sets the transform to draw the overlay on a rendermodel component mesh instead of a quad. This will only draw when the system is
+		* drawing the device. Overlays with this transform type cannot receive mouse events. */
+		virtual EVROverlayError SetOverlayTransformTrackedDeviceComponent( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char *pchComponentName ) = 0;
+
+		/** Gets the transform information when the overlay is rendering on a component. */
+		virtual EVROverlayError GetOverlayTransformTrackedDeviceComponent( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punDeviceIndex, VR_OUT_STRING() char *pchComponentName, uint32_t unComponentNameSize ) = 0;
+
+		/** Gets the transform if it is relative to another overlay. Returns an error if the transform is some other type. */
+		virtual vr::EVROverlayError GetOverlayTransformOverlayRelative( VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t *ulOverlayHandleParent, HmdMatrix34_t *pmatParentOverlayToOverlayTransform ) = 0;
+		
+		/** Sets the transform to relative to the transform of the specified overlay. This overlays visibility will also track the parents visibility */
+		virtual vr::EVROverlayError SetOverlayTransformOverlayRelative( VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, const HmdMatrix34_t *pmatParentOverlayToOverlayTransform ) = 0;
+
+		/** Sets the hotspot for the specified overlay when that overlay is used as a cursor. These are in texture space with 0,0 in the upper left corner of
+		* the texture and 1,1 in the lower right corner of the texture. */
+		virtual EVROverlayError SetOverlayTransformCursor( VROverlayHandle_t ulCursorOverlayHandle, const HmdVector2_t *pvHotspot ) = 0;
+
+		/** Gets cursor hotspot/transform for the specified overlay */
+		virtual vr::EVROverlayError GetOverlayTransformCursor( VROverlayHandle_t ulOverlayHandle, HmdVector2_t *pvHotspot ) = 0;
+
+		/** Shows the VR overlay.  For dashboard overlays, only the Dashboard Manager is allowed to call this. */
+		virtual EVROverlayError ShowOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+		/** Hides the VR overlay.  For dashboard overlays, only the Dashboard Manager is allowed to call this. */
+		virtual EVROverlayError HideOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+		/** Returns true if the overlay is visible. */
+		virtual bool IsOverlayVisible( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+		/** Get the transform in 3d space associated with a specific 2d point in the overlay's coordinate space (where 0,0 is the lower left). -Z points out of the overlay */
+		virtual EVROverlayError GetTransformForOverlayCoordinates( VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t *pmatTransform ) = 0;
+
+		// ---------------------------------------------
+		// Overlay input methods
+		// ---------------------------------------------
+
+		/** Returns true and fills the event with the next event on the overlay's event queue, if there is one. 
+		* If there are no events this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct */
+		virtual bool PollNextOverlayEvent( VROverlayHandle_t ulOverlayHandle, VREvent_t *pEvent, uint32_t uncbVREvent ) = 0;
+
+		/** Returns the current input settings for the specified overlay. */
+		virtual EVROverlayError GetOverlayInputMethod( VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod *peInputMethod ) = 0;
+
+		/** Sets the input settings for the specified overlay. */
+		virtual EVROverlayError SetOverlayInputMethod( VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod ) = 0;
+
+		/** Gets the mouse scaling factor that is used for mouse events. The actual texture may be a different size, but this is
+		* typically the size of the underlying UI in pixels. */
+		virtual EVROverlayError GetOverlayMouseScale( VROverlayHandle_t ulOverlayHandle, HmdVector2_t *pvecMouseScale ) = 0;
+
+		/** Sets the mouse scaling factor that is used for mouse events. The actual texture may be a different size, but this is
+		* typically the size of the underlying UI in pixels (not in world space). */
+		virtual EVROverlayError SetOverlayMouseScale( VROverlayHandle_t ulOverlayHandle, const HmdVector2_t *pvecMouseScale ) = 0;
+
+		/** Computes the overlay-space pixel coordinates of where the ray intersects the overlay with the
+		* specified settings. Returns false if there is no intersection. */
+		virtual bool ComputeOverlayIntersection( VROverlayHandle_t ulOverlayHandle, const VROverlayIntersectionParams_t *pParams, VROverlayIntersectionResults_t *pResults ) = 0;
+
+		/** Returns true if the specified overlay is the hover target. An overlay is the hover target when it is the last overlay "moused over" 
+		* by the virtual mouse pointer */
+		virtual bool IsHoverTargetOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+		/** Sets a list of primitives to be used for controller ray intersection
+		* typically the size of the underlying UI in pixels (not in world space). */
+		virtual EVROverlayError SetOverlayIntersectionMask( VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t *pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize = sizeof( VROverlayIntersectionMaskPrimitive_t ) ) = 0;
+
+		/** Triggers a haptic event on the laser mouse controller for the specified overlay */
+		virtual EVROverlayError TriggerLaserMouseHapticVibration( VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude ) = 0;
+
+		/** Sets the cursor to use for the specified overlay. This will be drawn instead of the generic blob when the laser mouse is pointed at the specified overlay */
+		virtual EVROverlayError SetOverlayCursor( VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle ) = 0;
+
+		/** Sets the override cursor position to use for this overlay in overlay mouse coordinates. This position will be used to draw the cursor
+		* instead of whatever the laser mouse cursor position is. */
+		virtual EVROverlayError SetOverlayCursorPositionOverride( VROverlayHandle_t ulOverlayHandle, const HmdVector2_t *pvCursor ) = 0;
+
+		/** Clears the override cursor position for this overlay */
+		virtual EVROverlayError ClearOverlayCursorPositionOverride( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+		// ---------------------------------------------
+		// Overlay texture methods
+		// ---------------------------------------------
+
+		/** Texture to draw for the overlay. This function can only be called by the overlay's creator or renderer process (see SetOverlayRenderingPid) .
+		*
+		* OpenGL dirty state:
+		*	glBindTexture
+		*/
+		virtual EVROverlayError SetOverlayTexture( VROverlayHandle_t ulOverlayHandle, const Texture_t *pTexture ) = 0;
+
+		/** Use this to tell the overlay system to release the texture set for this overlay. */
+		virtual EVROverlayError ClearOverlayTexture( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+		/** Separate interface for providing the data as a stream of bytes, but there is an upper bound on data 
+		* that can be sent. This function can only be called by the overlay's renderer process. */
+		virtual EVROverlayError SetOverlayRaw( VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel ) = 0;
+
+		/** Separate interface for providing the image through a filename: can be png or jpg, and should not be bigger than 1920x1080.
+		* This function can only be called by the overlay's renderer process */
+		virtual EVROverlayError SetOverlayFromFile( VROverlayHandle_t ulOverlayHandle, const char *pchFilePath ) = 0;
+
+		/** Get the native texture handle/device for an overlay you have created.
+		* On windows this handle will be a ID3D11ShaderResourceView with a ID3D11Texture2D bound.
+		*
+		* The texture will always be sized to match the backing texture you supplied in SetOverlayTexture above.
+		*
+		* You MUST call ReleaseNativeOverlayHandle() with pNativeTextureHandle once you are done with this texture.
+		*
+		* pNativeTextureHandle is an OUTPUT, it will be a pointer to a ID3D11ShaderResourceView *.
+		* pNativeTextureRef is an INPUT and should be a ID3D11Resource *. The device used by pNativeTextureRef will be used to bind pNativeTextureHandle.
+		*/
+		virtual EVROverlayError GetOverlayTexture( VROverlayHandle_t ulOverlayHandle, void **pNativeTextureHandle, void *pNativeTextureRef, uint32_t *pWidth, uint32_t *pHeight, uint32_t *pNativeFormat, ETextureType *pAPIType, EColorSpace *pColorSpace, VRTextureBounds_t *pTextureBounds ) = 0;
+
+		/** Release the pNativeTextureHandle provided from the GetOverlayTexture call, this allows the system to free the underlying GPU resources for this object,
+		* so only do it once you stop rendering this texture.
+		*/
+		virtual EVROverlayError ReleaseNativeOverlayHandle( VROverlayHandle_t ulOverlayHandle, void *pNativeTextureHandle ) = 0;
+
+		/** Get the size of the overlay texture */
+		virtual EVROverlayError GetOverlayTextureSize( VROverlayHandle_t ulOverlayHandle, uint32_t *pWidth, uint32_t *pHeight ) = 0;
+
+		// ----------------------------------------------
+		// Dashboard Overlay Methods
+		// ----------------------------------------------
+
+		/** Creates a dashboard overlay and returns its handle */
+		virtual EVROverlayError CreateDashboardOverlay( const char *pchOverlayKey, const char *pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t *pThumbnailHandle ) = 0;
+
+		/** Returns true if the dashboard is visible */
+		virtual bool IsDashboardVisible() = 0;
+
+		/** returns true if the dashboard is visible and the specified overlay is the active system Overlay */
+		virtual bool IsActiveDashboardOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+		/** Sets the dashboard overlay to only appear when the specified process ID has scene focus */
+		virtual EVROverlayError SetDashboardOverlaySceneProcess( VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId ) = 0;
+
+		/** Gets the process ID that this dashboard overlay requires to have scene focus */
+		virtual EVROverlayError GetDashboardOverlaySceneProcess( VROverlayHandle_t ulOverlayHandle, uint32_t *punProcessId ) = 0;
+
+		/** Shows the dashboard. */
+		virtual void ShowDashboard( const char *pchOverlayToShow ) = 0;
+
+		/** Returns the tracked device that has the laser pointer in the dashboard */
+		virtual vr::TrackedDeviceIndex_t GetPrimaryDashboardDevice() = 0;
+
+		// ---------------------------------------------
+		// Keyboard methods
+		// ---------------------------------------------
+		
+		/** Show the virtual keyboard to accept input. In most cases, you should pass KeyboardFlag_Modal to enable modal overlay 
+		* behavior on the keyboard itself. See EKeyboardFlags for more. */
+		virtual EVROverlayError ShowKeyboard( EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, 
+			const char *pchDescription, uint32_t unCharMax, const char *pchExistingText, uint64_t uUserValue ) = 0;
+
+		/** Show the virtual keyboard to accept input for an overlay. In most cases, you should pass KeyboardFlag_Modal to enable modal 
+		* overlay behavior on the keyboard itself. See EKeyboardFlags for more. */
+		virtual EVROverlayError ShowKeyboardForOverlay( VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode,
+			EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char *pchDescription, uint32_t unCharMax, 
+			const char *pchExistingText, uint64_t uUserValue ) = 0;
+
+		/** Get the text that was entered into the text input **/
+		virtual uint32_t GetKeyboardText( VR_OUT_STRING() char *pchText, uint32_t cchText ) = 0;
+
+		/** Hide the virtual keyboard **/
+		virtual void HideKeyboard() = 0;
+
+		/** Set the position of the keyboard in world space **/
+		virtual void SetKeyboardTransformAbsolute( ETrackingUniverseOrigin eTrackingOrigin, const HmdMatrix34_t *pmatTrackingOriginToKeyboardTransform ) = 0;
+
+		/** Set the position of the keyboard in overlay space by telling it to avoid a rectangle in the overlay. Rectangle coords have (0,0) in the bottom left **/
+		virtual void SetKeyboardPositionForOverlay( VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect ) = 0;
+
+		// ---------------------------------------------
+		// Message box methods
+		// ---------------------------------------------
+
+		/** Show the message overlay. This will block and return you a result. **/
+		virtual VRMessageOverlayResponse ShowMessageOverlay( const char* pchText, const char* pchCaption, const char* pchButton0Text, const char* pchButton1Text = nullptr, const char* pchButton2Text = nullptr, const char* pchButton3Text = nullptr ) = 0;
+
+		/** If the calling process owns the overlay and it's open, this will close it. **/
+		virtual void CloseMessageOverlay() = 0;
+	};
+
+	static const char * const IVROverlay_Version = "IVROverlay_024";
+
+} // namespace vr
+
+// ivroverlayview.h
+namespace vr
+{
+	struct VROverlayView_t
+	{
+		VROverlayHandle_t overlayHandle;
+		Texture_t texture;
+		VRTextureBounds_t textureBounds;
+	};
+
+	enum EDeviceType
+	{
+		DeviceType_Invalid           = -1, // Invalid handle
+		DeviceType_DirectX11         = 0, // Handle is an ID3D11Device
+		DeviceType_Vulkan            = 1, // Handle is a pointer to a VRVulkanDevice_t structure
+	};
+
+	struct VRVulkanDevice_t
+	{
+		VkInstance_T *m_pInstance;
+		VkDevice_T *m_pDevice;
+		VkPhysicalDevice_T *m_pPhysicalDevice;
+		VkQueue_T *m_pQueue;
+		uint32_t m_uQueueFamilyIndex;
+	};
+
+	struct VRNativeDevice_t
+	{
+		void *handle; // See EDeviceType definition above
+		EDeviceType eType;
+	};
+
+	class IVROverlayView
+	{
+	public:
+		/** Acquire an OverlayView_t from an overlay handle
+		*
+		* The overlay view can be used to sample the contents directly by a native API. The
+		* contents of the OverlayView_t will remain unchanged through the lifetime of the
+		* OverlayView_t.
+		*
+		* The caller acquires read privileges over the OverlayView_t, but should not
+		* write to it.
+		*
+		* AcquireOverlayView() may be called on the same ulOverlayHandle multiple times to
+		* refresh the image contents. In this case the caller is strongly encouraged to re-use
+		* the same pOverlayView for all re-acquisition calls.
+		*
+		* If the producer has not yet queued an image, AcquireOverlayView will return success,
+		* and the Texture_t will have the expected ETextureType. However, the Texture_t->handle
+		* will be nullptr. Once the producer generates the first overlay frame, Texture_t->handle
+		* will become a valid handle.
+		*/
+		virtual EVROverlayError AcquireOverlayView(VROverlayHandle_t ulOverlayHandle, VRNativeDevice_t *pNativeDevice, VROverlayView_t *pOverlayView, uint32_t unOverlayViewSize ) = 0;
+
+		/** Release an acquired OverlayView_t
+		*
+		* Denotes that pOverlayView will no longer require access to the resources it acquired in
+		* all previous calls to AcquireOverlayView().
+		*
+		* All OverlayView_t*'s provided to AcquireOverlayView() as pOverlayViews must be
+		* passed into ReleaseOverlayView() in order for the underlying GPU resources to be freed.
+		*/
+		virtual EVROverlayError ReleaseOverlayView(VROverlayView_t *pOverlayView) = 0;
+
+		/** Posts an overlay event */
+		virtual void PostOverlayEvent(VROverlayHandle_t ulOverlayHandle, const VREvent_t *pvrEvent) = 0;
+
+		/** Determines whether this process is permitted to view an overlay's content. */
+		virtual bool IsViewingPermitted( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+	};
+
+	static const char * const IVROverlayView_Version = "IVROverlayView_003";
+
+}
+
+// ivrrendermodels.h
+namespace vr
+{
+
+static const char * const k_pch_Controller_Component_GDC2015 = "gdc2015";   // Canonical coordinate system of the gdc 2015 wired controller, provided for backwards compatibility
+static const char * const k_pch_Controller_Component_Base = "base";         // For controllers with an unambiguous 'base'.
+static const char * const k_pch_Controller_Component_Tip = "tip";           // For controllers with an unambiguous 'tip' (used for 'laser-pointing')
+static const char * const k_pch_Controller_Component_HandGrip = "handgrip"; // Neutral, ambidextrous hand-pose when holding controller. On plane between neutrally posed index finger and thumb
+static const char * const k_pch_Controller_Component_Status = "status";		// 1:1 aspect ratio status area, with canonical [0,1] uv mapping
+
+#pragma pack( push, 8 )
+
+/** Errors that can occur with the VR compositor */
+enum EVRRenderModelError
+{
+	VRRenderModelError_None = 0,
+	VRRenderModelError_Loading = 100,
+	VRRenderModelError_NotSupported = 200,
+	VRRenderModelError_InvalidArg = 300,
+	VRRenderModelError_InvalidModel = 301,
+	VRRenderModelError_NoShapes = 302,
+	VRRenderModelError_MultipleShapes = 303,
+	VRRenderModelError_TooManyVertices = 304,
+	VRRenderModelError_MultipleTextures = 305,
+	VRRenderModelError_BufferTooSmall = 306,
+	VRRenderModelError_NotEnoughNormals = 307,
+	VRRenderModelError_NotEnoughTexCoords = 308,
+
+	VRRenderModelError_InvalidTexture = 400,
+};
+
+enum EVRRenderModelTextureFormat
+{
+	VRRenderModelTextureFormat_RGBA8_SRGB = 0, // RGBA with 8 bits per channel per pixel. Data size is width * height * 4ub
+	VRRenderModelTextureFormat_BC2,
+	VRRenderModelTextureFormat_BC4,
+	VRRenderModelTextureFormat_BC7,
+	VRRenderModelTextureFormat_BC7_SRGB
+};
+
+/** A single vertex in a render model */
+struct RenderModel_Vertex_t
+{
+	HmdVector3_t vPosition;		// position in meters in device space
+	HmdVector3_t vNormal;
+	float rfTextureCoord[2];
+};
+
+/** A texture map for use on a render model */
+#if defined(__linux__) || defined(__APPLE__) 
+// This structure was originally defined mis-packed on Linux, preserved for 
+// compatibility. 
+#pragma pack( push, 4 )
+#endif
+
+struct RenderModel_TextureMap_t
+{
+	uint16_t unWidth, unHeight; // width and height of the texture map in pixels
+	const uint8_t *rubTextureMapData;	// Map texture data.
+	EVRRenderModelTextureFormat format; // Refer to EVRRenderModelTextureFormat
+};
+#if defined(__linux__) || defined(__APPLE__) 
+#pragma pack( pop )
+#endif
+
+/**  Session unique texture identifier. Rendermodels which share the same texture will have the same id.
+IDs <0 denote the texture is not present */
+
+typedef int32_t TextureID_t;
+
+const TextureID_t INVALID_TEXTURE_ID = -1;
+
+#if defined(__linux__) || defined(__APPLE__) 
+// This structure was originally defined mis-packed on Linux, preserved for 
+// compatibility. 
+#pragma pack( push, 4 )
+#endif
+
+struct RenderModel_t
+{
+	const RenderModel_Vertex_t *rVertexData;	// Vertex data for the mesh
+	uint32_t unVertexCount;						// Number of vertices in the vertex data
+	const uint16_t *rIndexData;					// Indices into the vertex data for each triangle
+	uint32_t unTriangleCount;					// Number of triangles in the mesh. Index count is 3 * TriangleCount
+	TextureID_t diffuseTextureId;				// Session unique texture identifier. Rendermodels which share the same texture will have the same id. <0 == texture not present
+};
+#if defined(__linux__) || defined(__APPLE__) 
+#pragma pack( pop )
+#endif
+
+
+struct RenderModel_ControllerMode_State_t
+{
+	bool bScrollWheelVisible; // is this controller currently set to be in a scroll wheel mode
+};
+
+#pragma pack( pop )
+
+class IVRRenderModels
+{
+public:
+
+	/** Loads and returns a render model for use in the application. pchRenderModelName should be a render model name
+	* from the Prop_RenderModelName_String property or an absolute path name to a render model on disk. 
+	*
+	* The resulting render model is valid until VR_Shutdown() is called or until FreeRenderModel() is called. When the 
+	* application is finished with the render model it should call FreeRenderModel() to free the memory associated
+	* with the model.
+	*
+	* The method returns VRRenderModelError_Loading while the render model is still being loaded.
+	* The method returns VRRenderModelError_None once loaded successfully, otherwise will return an error. */
+	virtual EVRRenderModelError LoadRenderModel_Async( const char *pchRenderModelName, RenderModel_t **ppRenderModel ) = 0;
+
+	/** Frees a previously returned render model
+	*   It is safe to call this on a null ptr. */
+	virtual void FreeRenderModel( RenderModel_t *pRenderModel ) = 0;
+
+	/** Loads and returns a texture for use in the application. */
+	virtual EVRRenderModelError LoadTexture_Async( TextureID_t textureId, RenderModel_TextureMap_t **ppTexture ) = 0;
+
+	/** Frees a previously returned texture
+	*   It is safe to call this on a null ptr. */
+	virtual void FreeTexture( RenderModel_TextureMap_t *pTexture ) = 0;
+
+	/** Creates a D3D11 texture and loads data into it. */
+	virtual EVRRenderModelError LoadTextureD3D11_Async( TextureID_t textureId, void *pD3D11Device, void **ppD3D11Texture2D ) = 0;
+
+	/** Helper function to copy the bits into an existing texture. */
+	virtual EVRRenderModelError LoadIntoTextureD3D11_Async( TextureID_t textureId, void *pDstTexture ) = 0;
+
+	/** Use this to free textures created with LoadTextureD3D11_Async instead of calling Release on them. */
+	virtual void FreeTextureD3D11( void *pD3D11Texture2D ) = 0;
+
+	/** Use this to get the names of available render models.  Index does not correlate to a tracked device index, but
+	* is only used for iterating over all available render models.  If the index is out of range, this function will return 0.
+	* Otherwise, it will return the size of the buffer required for the name. */
+	virtual uint32_t GetRenderModelName( uint32_t unRenderModelIndex, VR_OUT_STRING() char *pchRenderModelName, uint32_t unRenderModelNameLen ) = 0;
+
+	/** Returns the number of available render models. */
+	virtual uint32_t GetRenderModelCount() = 0;
+
+
+	/** Returns the number of components of the specified render model.
+	*  Components are useful when client application wish to draw, label, or otherwise interact with components of tracked objects.
+	*  Examples controller components:
+	*   renderable things such as triggers, buttons
+	*   non-renderable things which include coordinate systems such as 'tip', 'base', a neutral controller agnostic hand-pose
+	*   If all controller components are enumerated and rendered, it will be equivalent to drawing the traditional render model
+	*   Returns 0 if components not supported, >0 otherwise */
+	virtual uint32_t GetComponentCount( const char *pchRenderModelName ) = 0;
+
+	/** Use this to get the names of available components.  Index does not correlate to a tracked device index, but
+	* is only used for iterating over all available components.  If the index is out of range, this function will return 0.
+	* Otherwise, it will return the size of the buffer required for the name. */
+	virtual uint32_t GetComponentName( const char *pchRenderModelName, uint32_t unComponentIndex, VR_OUT_STRING( ) char *pchComponentName, uint32_t unComponentNameLen ) = 0;
+
+	/** Get the button mask for all buttons associated with this component
+	*   If no buttons (or axes) are associated with this component, return 0
+	*   Note: multiple components may be associated with the same button. Ex: two grip buttons on a single controller.
+	*   Note: A single component may be associated with multiple buttons. Ex: A trackpad which also provides "D-pad" functionality */
+	virtual uint64_t GetComponentButtonMask( const char *pchRenderModelName, const char *pchComponentName ) = 0;
+
+	/** Use this to get the render model name for the specified rendermode/component combination, to be passed to LoadRenderModel.
+	* If the component name is out of range, this function will return 0.
+	* Otherwise, it will return the size of the buffer required for the name. */
+	virtual uint32_t GetComponentRenderModelName( const char *pchRenderModelName, const char *pchComponentName, VR_OUT_STRING( ) char *pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen ) = 0;
+
+	/** Use this to query information about the component, as a function of the controller state.
+	*
+	* For dynamic controller components (ex: trigger) values will reflect component motions
+	* For static components this will return a consistent value independent of the VRControllerState_t
+	*
+	* If the pchRenderModelName or pchComponentName is invalid, this will return false (and transforms will be set to identity).
+	* Otherwise, return true
+	* Note: For dynamic objects, visibility may be dynamic. (I.e., true/false will be returned based on controller state and controller mode state ) */
+	virtual bool GetComponentStateForDevicePath( const char *pchRenderModelName, const char *pchComponentName, vr::VRInputValueHandle_t devicePath, const vr::RenderModel_ControllerMode_State_t *pState, vr::RenderModel_ComponentState_t *pComponentState ) = 0;
+
+	/** This version of GetComponentState takes a controller state block instead of an action origin. This function is deprecated. You should use the new input system and GetComponentStateForDevicePath instead. */
+	virtual bool GetComponentState( const char *pchRenderModelName, const char *pchComponentName, const vr::VRControllerState_t *pControllerState, const RenderModel_ControllerMode_State_t *pState, RenderModel_ComponentState_t *pComponentState ) = 0;
+
+	/** Returns true if the render model has a component with the specified name */
+	virtual bool RenderModelHasComponent( const char *pchRenderModelName, const char *pchComponentName ) = 0;
+
+	/** Returns the URL of the thumbnail image for this rendermodel */
+	virtual uint32_t GetRenderModelThumbnailURL( const char *pchRenderModelName, VR_OUT_STRING() char *pchThumbnailURL, uint32_t unThumbnailURLLen, vr::EVRRenderModelError *peError ) = 0;
+
+	/** Provides a render model path that will load the unskinned model if the model name provided has been replace by the user. If the model
+	* hasn't been replaced the path value will still be a valid path to load the model. Pass this to LoadRenderModel_Async, etc. to load the
+	* model. */
+	virtual uint32_t GetRenderModelOriginalPath( const char *pchRenderModelName, VR_OUT_STRING() char *pchOriginalPath, uint32_t unOriginalPathLen, vr::EVRRenderModelError *peError ) = 0;
+
+	/** Returns a string for a render model error */
+	virtual const char *GetRenderModelErrorNameFromEnum( vr::EVRRenderModelError error ) = 0;
+};
+
+static const char * const IVRRenderModels_Version = "IVRRenderModels_006";
+
+}
+
+
+// ivrextendeddisplay.h
+namespace vr
+{
+
+	/** NOTE: Use of this interface is not recommended in production applications. It will not work for displays which use
+	* direct-to-display mode. Creating our own window is also incompatible with the VR compositor and is not available when the compositor is running. */
+	class IVRExtendedDisplay
+	{
+	public:
+
+		/** Size and position that the window needs to be on the VR display. */
+		virtual void GetWindowBounds( int32_t *pnX, int32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
+
+		/** Gets the viewport in the frame buffer to draw the output of the distortion into */
+		virtual void GetEyeOutputViewport( EVREye eEye, uint32_t *pnX, uint32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
+
+		/** [D3D10/11 Only]
+		* Returns the adapter index and output index that the user should pass into EnumAdapters and EnumOutputs
+		* to create the device and swap chain in DX10 and DX11. If an error occurs both indices will be set to -1.
+		*/
+		virtual void GetDXGIOutputInfo( int32_t *pnAdapterIndex, int32_t *pnAdapterOutputIndex ) = 0;
+
+	};
+
+	static const char * const IVRExtendedDisplay_Version = "IVRExtendedDisplay_001";
+
+}
+
+
+// ivrtrackedcamera.h
+namespace vr
+{
+
+class IVRTrackedCamera
+{
+public:
+	/** Returns a string for an error */
+	virtual const char *GetCameraErrorNameFromEnum( vr::EVRTrackedCameraError eCameraError ) = 0;
+
+	/** For convenience, same as tracked property request Prop_HasCamera_Bool */
+	virtual vr::EVRTrackedCameraError HasCamera( vr::TrackedDeviceIndex_t nDeviceIndex, bool *pHasCamera ) = 0;
+
+	/** Gets size of the image frame. */
+	virtual vr::EVRTrackedCameraError GetCameraFrameSize( vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, uint32_t *pnWidth, uint32_t *pnHeight, uint32_t *pnFrameBufferSize ) = 0;
+
+	virtual vr::EVRTrackedCameraError GetCameraIntrinsics( vr::TrackedDeviceIndex_t nDeviceIndex, uint32_t nCameraIndex, vr::EVRTrackedCameraFrameType eFrameType, vr::HmdVector2_t *pFocalLength, vr::HmdVector2_t *pCenter ) = 0;
+
+	virtual vr::EVRTrackedCameraError GetCameraProjection( vr::TrackedDeviceIndex_t nDeviceIndex, uint32_t nCameraIndex, vr::EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, vr::HmdMatrix44_t *pProjection ) = 0;
+
+	/** Acquiring streaming service permits video streaming for the caller. Releasing hints the system that video services do not need to be maintained for this client.
+	* If the camera has not already been activated, a one time spin up may incur some auto exposure as well as initial streaming frame delays.
+	* The camera should be considered a global resource accessible for shared consumption but not exclusive to any caller.
+	* The camera may go inactive due to lack of active consumers or headset idleness. */
+	virtual vr::EVRTrackedCameraError AcquireVideoStreamingService( vr::TrackedDeviceIndex_t nDeviceIndex, vr::TrackedCameraHandle_t *pHandle ) = 0;
+	virtual vr::EVRTrackedCameraError ReleaseVideoStreamingService( vr::TrackedCameraHandle_t hTrackedCamera ) = 0;
+
+	/** Copies the image frame into a caller's provided buffer. The image data is currently provided as RGBA data, 4 bytes per pixel.
+	* A caller can provide null for the framebuffer or frameheader if not desired. Requesting the frame header first, followed by the frame buffer allows
+	* the caller to determine if the frame as advanced per the frame header sequence. 
+	* If there is no frame available yet, due to initial camera spinup or re-activation, the error will be VRTrackedCameraError_NoFrameAvailable.
+	* Ideally a caller should be polling at ~16ms intervals */
+	virtual vr::EVRTrackedCameraError GetVideoStreamFrameBuffer( vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, void *pFrameBuffer, uint32_t nFrameBufferSize, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize ) = 0;
+
+	/** Gets size of the image frame. */
+	virtual vr::EVRTrackedCameraError GetVideoStreamTextureSize( vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, vr::VRTextureBounds_t *pTextureBounds, uint32_t *pnWidth, uint32_t *pnHeight ) = 0; 
+
+	/** Access a shared D3D11 texture for the specified tracked camera stream.
+	* The camera frame type VRTrackedCameraFrameType_Undistorted is not supported directly as a shared texture. It is an interior subregion of the shared texture VRTrackedCameraFrameType_MaximumUndistorted.
+	* Instead, use GetVideoStreamTextureSize() with VRTrackedCameraFrameType_Undistorted to determine the proper interior subregion bounds along with GetVideoStreamTextureD3D11() with
+	* VRTrackedCameraFrameType_MaximumUndistorted to provide the texture. The VRTrackedCameraFrameType_MaximumUndistorted will yield an image where the invalid regions are decoded
+	* by the alpha channel having a zero component. The valid regions all have a non-zero alpha component. The subregion as described by VRTrackedCameraFrameType_Undistorted 
+	* guarantees a rectangle where all pixels are valid. */
+	virtual vr::EVRTrackedCameraError GetVideoStreamTextureD3D11( vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize ) = 0;
+
+	/** Access a shared GL texture for the specified tracked camera stream */
+	virtual vr::EVRTrackedCameraError GetVideoStreamTextureGL( vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, vr::glUInt_t *pglTextureId, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize ) = 0;
+	virtual vr::EVRTrackedCameraError ReleaseVideoStreamTextureGL( vr::TrackedCameraHandle_t hTrackedCamera, vr::glUInt_t glTextureId ) = 0;
+	virtual void SetCameraTrackingSpace( vr::ETrackingUniverseOrigin eUniverse ) = 0;
+	virtual vr::ETrackingUniverseOrigin GetCameraTrackingSpace( ) = 0;
+};
+
+static const char * const IVRTrackedCamera_Version = "IVRTrackedCamera_006";
+
+} // namespace vr
+
+
+// ivrscreenshots.h
+namespace vr
+{
+
+/** Errors that can occur with the VR compositor */
+enum EVRScreenshotError
+{
+	VRScreenshotError_None							= 0,
+	VRScreenshotError_RequestFailed					= 1,
+	VRScreenshotError_IncompatibleVersion			= 100,
+	VRScreenshotError_NotFound						= 101,
+	VRScreenshotError_BufferTooSmall				= 102,
+	VRScreenshotError_ScreenshotAlreadyInProgress	= 108,
+};
+
+/** Allows the application to generate screenshots */
+class IVRScreenshots
+{
+public:
+	/** Request a screenshot of the requested type.
+	 *  A request of the VRScreenshotType_Stereo type will always
+	 *  work. Other types will depend on the underlying application
+	 *  support.
+	 *  The first file name is for the preview image and should be a
+	 *  regular screenshot (ideally from the left eye). The second
+	 *  is the VR screenshot in the correct format. They should be
+	 *  in the same aspect ratio.  Formats per type:
+	 *  VRScreenshotType_Mono: the VR filename is ignored (can be
+	 *  nullptr), this is a normal flat single shot.
+	 *  VRScreenshotType_Stereo:  The VR image should be a
+	 *  side-by-side with the left eye image on the left.
+	 *  VRScreenshotType_Cubemap: The VR image should be six square
+	 *  images composited horizontally.
+	 *  VRScreenshotType_StereoPanorama: above/below with left eye
+	 *  panorama being the above image.  Image is typically square
+	 *  with the panorama being 2x horizontal.
+	 *  
+	 *  Note that the VR dashboard will call this function when
+	 *  the user presses the screenshot binding (currently System
+	 *  Button + Trigger).  If Steam is running, the destination
+	 *  file names will be in %TEMP% and will be copied into
+	 *  Steam's screenshot library for the running application
+	 *  once SubmitScreenshot() is called.
+	 *  If Steam is not running, the paths will be in the user's
+	 *  documents folder under Documents\SteamVR\Screenshots.
+	 *  Other VR applications can call this to initiate a
+	 *  screenshot outside of user control.
+	 *  The destination file names do not need an extension,
+	 *  will be replaced with the correct one for the format
+	 *  which is currently .png. */
+	virtual vr::EVRScreenshotError RequestScreenshot( vr::ScreenshotHandle_t *pOutScreenshotHandle, vr::EVRScreenshotType type, const char *pchPreviewFilename, const char *pchVRFilename ) = 0;
+
+	/** Called by the running VR application to indicate that it
+	 *  wishes to be in charge of screenshots.  If the
+	 *  application does not call this, the Compositor will only
+	 *  support VRScreenshotType_Stereo screenshots that will be
+	 *  captured without notification to the running app.
+	 *  Once hooked your application will receive a
+	 *  VREvent_RequestScreenshot event when the user presses the
+	 *  buttons to take a screenshot. */
+	virtual vr::EVRScreenshotError HookScreenshot( VR_ARRAY_COUNT( numTypes ) const vr::EVRScreenshotType *pSupportedTypes, int numTypes ) = 0;
+
+	/** When your application receives a
+	 *  VREvent_RequestScreenshot event, call these functions to get
+	 *  the details of the screenshot request. */
+	virtual vr::EVRScreenshotType GetScreenshotPropertyType( vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotError *pError ) = 0;
+
+	/** Get the filename for the preview or vr image (see
+	 *  vr::EScreenshotPropertyFilenames).  The return value is
+	 *  the size of the string.   */
+ 	virtual uint32_t GetScreenshotPropertyFilename( vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotPropertyFilenames filenameType, VR_OUT_STRING() char *pchFilename, uint32_t cchFilename, vr::EVRScreenshotError *pError ) = 0;
+
+	/** Call this if the application is taking the screen shot
+	 *  will take more than a few ms processing. This will result
+	 *  in an overlay being presented that shows a completion
+	 *  bar. */
+	virtual vr::EVRScreenshotError UpdateScreenshotProgress( vr::ScreenshotHandle_t screenshotHandle, float flProgress ) = 0;
+
+	/** Tells the compositor to take an internal screenshot of
+	 *  type VRScreenshotType_Stereo. It will take the current
+	 *  submitted scene textures of the running application and
+	 *  write them into the preview image and a side-by-side file
+	 *  for the VR image.
+	 *  This is similar to request screenshot, but doesn't ever
+	 *  talk to the application, just takes the shot and submits. */
+	virtual vr::EVRScreenshotError TakeStereoScreenshot( vr::ScreenshotHandle_t *pOutScreenshotHandle, const char *pchPreviewFilename, const char *pchVRFilename ) = 0;
+
+	/** Submit the completed screenshot.  If Steam is running
+	 *  this will call into the Steam client and upload the
+	 *  screenshot to the screenshots section of the library for
+	 *  the running application.  If Steam is not running, this
+	 *  function will display a notification to the user that the
+	 *  screenshot was taken. The paths should be full paths with
+	 *  extensions.
+	 *  File paths should be absolute including extensions.
+	 *  screenshotHandle can be k_unScreenshotHandleInvalid if this
+	 *  was a new shot taking by the app to be saved and not
+	 *  initiated by a user (achievement earned or something) */
+	virtual vr::EVRScreenshotError SubmitScreenshot( vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotType type, const char *pchSourcePreviewFilename, const char *pchSourceVRFilename ) = 0;
+};
+
+static const char * const IVRScreenshots_Version = "IVRScreenshots_001";
+
+} // namespace vr
+
+
+
+// ivrresources.h
+namespace vr
+{
+
+class IVRResources
+{
+public:
+
+	// ------------------------------------
+	// Shared Resource Methods
+	// ------------------------------------
+
+	/** Loads the specified resource into the provided buffer if large enough.
+	* Returns the size in bytes of the buffer required to hold the specified resource. */
+	virtual uint32_t LoadSharedResource( const char *pchResourceName, char *pchBuffer, uint32_t unBufferLen ) = 0;
+
+	/** Provides the full path to the specified resource. Resource names can include named directories for
+	* drivers and other things, and this resolves all of those and returns the actual physical path. 
+	* pchResourceTypeDirectory is the subdirectory of resources to look in. */
+	virtual uint32_t GetResourceFullPath( const char *pchResourceName, const char *pchResourceTypeDirectory, VR_OUT_STRING() char *pchPathBuffer, uint32_t unBufferLen ) = 0;
+};
+
+static const char * const IVRResources_Version = "IVRResources_001";
+
+
+}
+// ivrdrivermanager.h
+namespace vr
+{
+
+class IVRDriverManager
+{
+public:
+	virtual uint32_t GetDriverCount() const = 0;
+
+	/** Returns the length of the number of bytes necessary to hold this string including the trailing null. */
+	virtual uint32_t GetDriverName( vr::DriverId_t nDriver, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize ) = 0;
+
+	virtual DriverHandle_t GetDriverHandle( const char *pchDriverName ) = 0;
+
+	virtual bool IsEnabled( vr::DriverId_t nDriver ) const = 0;
+};
+
+static const char * const IVRDriverManager_Version = "IVRDriverManager_001";
+
+} // namespace vr
+
+
+
+// ivrinput.h
+namespace vr
+{
+	// Maximum number of characters in an action name, including the trailing null
+	static const uint32_t k_unMaxActionNameLength = 64; 
+
+	// Maximum number of characters in an action set name, including the trailing null
+	static const uint32_t k_unMaxActionSetNameLength = 64;
+
+	// Maximum number of origins for an action
+	static const uint32_t k_unMaxActionOriginCount = 16; 
+
+	// Maximum number of characters in a bone name, including the trailing null
+	static const uint32_t k_unMaxBoneNameLength = 32; 
+
+	enum EVRSkeletalTransformSpace
+	{
+		VRSkeletalTransformSpace_Model = 0, 
+		VRSkeletalTransformSpace_Parent = 1
+	};
+
+	enum EVRSkeletalReferencePose
+	{
+		VRSkeletalReferencePose_BindPose = 0,
+		VRSkeletalReferencePose_OpenHand,
+		VRSkeletalReferencePose_Fist,
+		VRSkeletalReferencePose_GripLimit
+	};
+
+	enum EVRFinger
+	{
+		VRFinger_Thumb = 0,
+		VRFinger_Index,
+		VRFinger_Middle,
+		VRFinger_Ring,
+		VRFinger_Pinky,
+		VRFinger_Count
+	};
+
+	enum EVRFingerSplay
+	{
+		VRFingerSplay_Thumb_Index = 0,
+		VRFingerSplay_Index_Middle,
+		VRFingerSplay_Middle_Ring,
+		VRFingerSplay_Ring_Pinky,
+		VRFingerSplay_Count
+	};
+
+	enum EVRSummaryType
+	{
+		// The skeletal summary data will match the animated bone transforms for the action.
+		VRSummaryType_FromAnimation = 0,	
+		
+		// The skeletal summary data will include unprocessed data directly from the device when available. 
+		// This data is generally less latent than the data that is computed from the animations.
+		VRSummaryType_FromDevice = 1,		
+	};
+
+	enum EVRInputFilterCancelType
+	{
+		VRInputFilterCancel_Timers = 0,
+		VRInputFilterCancel_Momentum = 1,
+	};
+
+	enum EVRInputStringBits
+	{
+		VRInputString_Hand = 0x01,
+		VRInputString_ControllerType = 0x02,
+		VRInputString_InputSource = 0x04,
+
+		VRInputString_All = 0xFFFFFFFF
+	};
+
+	struct InputAnalogActionData_t
+	{
+		/** Whether or not this action is currently available to be bound in the active action set */
+		bool bActive;
+
+		/** The origin that caused this action's current state */
+		VRInputValueHandle_t activeOrigin;
+
+		/** The current state of this action; will be delta updates for mouse actions */
+		float x, y, z;
+
+		/** Deltas since the previous call to UpdateActionState() */
+		float deltaX, deltaY, deltaZ;
+	
+		/** Time relative to now when this event happened. Will be negative to indicate a past time. */
+		float fUpdateTime;
+	};
+
+	struct InputDigitalActionData_t
+	{
+		/** Whether or not this action is currently available to be bound in the active action set */
+		bool bActive;
+
+		/** The origin that caused this action's current state */
+		VRInputValueHandle_t activeOrigin;
+
+		/** The current state of this action; will be true if currently pressed */
+		bool bState;
+
+		/** This is true if the state has changed since the last frame */
+		bool bChanged;
+
+		/** Time relative to now when this event happened. Will be negative to indicate a past time. */
+		float fUpdateTime;
+	};
+
+	struct InputPoseActionData_t
+	{
+		/** Whether or not this action is currently available to be bound in the active action set */
+		bool bActive;
+
+		/** The origin that caused this action's current state */
+		VRInputValueHandle_t activeOrigin;
+
+		/** The current state of this action */
+		TrackedDevicePose_t pose;
+	};
+
+	struct InputSkeletalActionData_t
+	{
+		/** Whether or not this action is currently available to be bound in the active action set */
+		bool bActive;
+
+		/** The origin that caused this action's current state */
+		VRInputValueHandle_t activeOrigin;
+	};
+
+	struct InputOriginInfo_t
+	{
+		VRInputValueHandle_t devicePath;
+		TrackedDeviceIndex_t trackedDeviceIndex;
+		char rchRenderModelComponentName[128];
+	};
+
+	struct InputBindingInfo_t
+	{
+		char rchDevicePathName[128];
+		char rchInputPathName[128];
+		char rchModeName[128];
+		char rchSlotName[128];
+		char rchInputSourceType[ 32 ];
+	};
+
+	// * Experimental global action set priority *
+	// These constants are part of the experimental support in SteamVR for overlay
+	// apps selectively overriding input in the base scene application. This may be
+	// useful for overlay applications that need to use part or all of a controller
+	// without taking away all input to the game. This system must be enabled by the 
+	// "Experimental overlay input overrides" setting in the developer section of 
+	// SteamVR settings.
+	//
+	// To use this system, set the nPriority field of an action set to any number in
+	// this range. 
+	static const int32_t k_nActionSetOverlayGlobalPriorityMin	= 0x01000000;
+	static const int32_t k_nActionSetOverlayGlobalPriorityMax	= 0x01FFFFFF;
+
+	static const int32_t k_nActionSetPriorityReservedMin		= 0x02000000;
+
+	struct VRActiveActionSet_t
+	{
+		/** This is the handle of the action set to activate for this frame. */
+		VRActionSetHandle_t ulActionSet;
+
+		/** This is the handle of a device path that this action set should be active for. To
+		* activate for all devices, set this to k_ulInvalidInputValueHandle. */
+		VRInputValueHandle_t ulRestrictedToDevice;
+
+		/** The action set to activate for all devices other than ulRestrictedDevice. If 
+		* ulRestrictedToDevice is set to k_ulInvalidInputValueHandle, this parameter is 
+		* ignored. */
+		VRActionSetHandle_t ulSecondaryActionSet;
+
+		// This field is ignored
+		uint32_t unPadding;
+
+		/** The priority of this action set relative to other action sets. Any inputs
+		* bound to a source (e.g. trackpad, joystick, trigger) will disable bindings in
+		* other active action sets with a smaller priority. 
+		*
+		* Overlay applications (i.e. ApplicationType_Overlay) may set their action set priority 
+		* to a value between k_nActionSetOverlayGlobalPriorityMin and k_nActionSetOverlayGlobalPriorityMax
+		* to cause any inputs bound to a source used by that action set to be disabled in scene applications.
+		*
+		* No action set priority may value may be larger than k_nActionSetPriorityReservedMin
+		*/
+		int32_t nPriority;
+	};
+
+	/** Contains summary information about the current skeletal pose */
+	struct VRSkeletalSummaryData_t
+	{
+		/** The amount that each finger is 'curled' inwards towards the palm.  In the case of the thumb,
+		* this represents how much the thumb is wrapped around the fist.  
+		* 0 means straight, 1 means fully curled */
+		float	flFingerCurl[ VRFinger_Count ];
+
+		/** The amount that each pair of adjacent fingers are separated.  
+		* 0 means the digits are touching, 1 means they are fully separated.
+		*/
+		float	flFingerSplay[ VRFingerSplay_Count ];
+	};
+
+
+	class IVRInput
+	{
+	public:
+
+		// ---------------  Handle management   --------------- //
+
+		/** Sets the path to the action manifest JSON file that is used by this application. If this information
+		* was set on the Steam partner site, calls to this function are ignored. If the Steam partner site
+		* setting and the path provided by this call are different, VRInputError_MismatchedActionManifest is returned. 
+		* This call must be made before the first call to UpdateActionState or IVRSystem::PollNextEvent. */
+		virtual EVRInputError SetActionManifestPath( const char *pchActionManifestPath ) = 0;
+
+		/** Returns a handle for an action set. This handle is used for all performance-sensitive calls. */
+		virtual EVRInputError GetActionSetHandle( const char *pchActionSetName, VRActionSetHandle_t *pHandle ) = 0;
+
+		/** Returns a handle for an action. This handle is used for all performance-sensitive calls. */
+		virtual EVRInputError GetActionHandle( const char *pchActionName, VRActionHandle_t *pHandle ) = 0;
+
+		/** Returns a handle for any path in the input system. E.g. /user/hand/right */
+		virtual EVRInputError GetInputSourceHandle( const char *pchInputSourcePath, VRInputValueHandle_t *pHandle ) = 0;
+
+
+
+		// --------------- Reading action state ------------------- //
+
+		/** Reads the current state into all actions. After this call, the results of Get*Action calls 
+		* will be the same until the next call to UpdateActionState. */
+		virtual EVRInputError UpdateActionState( VR_ARRAY_COUNT( unSetCount ) VRActiveActionSet_t *pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount ) = 0;
+
+		/** Reads the state of a digital action given its handle. This will return VRInputError_WrongType if the type of
+		* action is something other than digital */
+		virtual EVRInputError GetDigitalActionData( VRActionHandle_t action, InputDigitalActionData_t *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice ) = 0;
+
+		/** Reads the state of an analog action given its handle. This will return VRInputError_WrongType if the type of
+		* action is something other than analog */
+		virtual EVRInputError GetAnalogActionData( VRActionHandle_t action, InputAnalogActionData_t *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice ) = 0;
+
+		/** Reads the state of a pose action given its handle for the number of seconds relative to now. This
+		* will generally be called with negative times from the fUpdateTime fields in other actions. */
+		virtual EVRInputError GetPoseActionDataRelativeToNow( VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice ) = 0;
+
+		/** Reads the state of a pose action given its handle. The returned values will match the values returned
+		* by the last call to IVRCompositor::WaitGetPoses(). */
+		virtual EVRInputError GetPoseActionDataForNextFrame( VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, InputPoseActionData_t *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice ) = 0;
+
+		/** Reads the state of a skeletal action given its handle. */
+		virtual EVRInputError GetSkeletalActionData( VRActionHandle_t action, InputSkeletalActionData_t *pActionData, uint32_t unActionDataSize ) = 0;
+
+		/** Returns the current dominant hand for the user for this application. This function will only return success for applications
+		* which include "supports_dominant_hand_setting": true in their action manifests. The dominant hand will only change after
+		* a call to UpdateActionState, and the action data returned after that point will use the new dominant hand. */
+		virtual EVRInputError GetDominantHand( ETrackedControllerRole *peDominantHand ) = 0;
+
+		/** Sets the dominant hand for the user for this application. */
+		virtual EVRInputError SetDominantHand( ETrackedControllerRole eDominantHand ) = 0;
+
+		// ---------------  Static Skeletal Data ------------------- //
+
+		/** Reads the number of bones in skeleton associated with the given action */
+		virtual EVRInputError GetBoneCount( VRActionHandle_t action, uint32_t* pBoneCount ) = 0;
+
+		/** Fills the given array with the index of each bone's parent in the skeleton associated with the given action */
+		virtual EVRInputError GetBoneHierarchy( VRActionHandle_t action, VR_ARRAY_COUNT( unIndexArayCount ) BoneIndex_t* pParentIndices, uint32_t unIndexArayCount ) = 0;
+
+		/** Fills the given buffer with the name of the bone at the given index in the skeleton associated with the given action */
+		virtual EVRInputError GetBoneName( VRActionHandle_t action, BoneIndex_t nBoneIndex, VR_OUT_STRING() char* pchBoneName, uint32_t unNameBufferSize ) = 0;
+
+		/** Fills the given buffer with the transforms for a specific static skeletal reference pose */
+		virtual EVRInputError GetSkeletalReferenceTransforms( VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalReferencePose eReferencePose, VR_ARRAY_COUNT( unTransformArrayCount ) VRBoneTransform_t *pTransformArray, uint32_t unTransformArrayCount ) = 0;
+
+		/** Reads the level of accuracy to which the controller is able to track the user to recreate a skeletal pose */
+		virtual EVRInputError GetSkeletalTrackingLevel( VRActionHandle_t action, EVRSkeletalTrackingLevel* pSkeletalTrackingLevel ) = 0;
+
+		// ---------------  Dynamic Skeletal Data ------------------- //
+
+		/** Reads the state of the skeletal bone data associated with this action and copies it into the given buffer. */
+		virtual EVRInputError GetSkeletalBoneData( VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, VR_ARRAY_COUNT( unTransformArrayCount ) VRBoneTransform_t *pTransformArray, uint32_t unTransformArrayCount ) = 0;
+
+		/** Reads summary information about the current pose of the skeleton associated with the given action.   */
+		virtual EVRInputError GetSkeletalSummaryData( VRActionHandle_t action, EVRSummaryType eSummaryType, VRSkeletalSummaryData_t * pSkeletalSummaryData ) = 0;
+
+		/** Reads the state of the skeletal bone data in a compressed form that is suitable for
+		* sending over the network. The required buffer size will never exceed ( sizeof(VR_BoneTransform_t)*boneCount + 2).
+		* Usually the size will be much smaller. */
+		virtual EVRInputError GetSkeletalBoneDataCompressed( VRActionHandle_t action, EVRSkeletalMotionRange eMotionRange, VR_OUT_BUFFER_COUNT( unCompressedSize ) void *pvCompressedData, uint32_t unCompressedSize, uint32_t *punRequiredCompressedSize ) = 0;
+
+		/** Turns a compressed buffer from GetSkeletalBoneDataCompressed and turns it back into a bone transform array. */
+		virtual EVRInputError DecompressSkeletalBoneData( const void *pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace eTransformSpace, VR_ARRAY_COUNT( unTransformArrayCount ) VRBoneTransform_t *pTransformArray, uint32_t unTransformArrayCount ) = 0;
+
+		// --------------- Haptics ------------------- //
+
+		/** Triggers a haptic event as described by the specified action */
+		virtual EVRInputError TriggerHapticVibrationAction( VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, VRInputValueHandle_t ulRestrictToDevice ) = 0;
+
+		// --------------- Action Origins ---------------- //
+
+		/** Retrieve origin handles for an action */
+		virtual EVRInputError GetActionOrigins( VRActionSetHandle_t actionSetHandle, VRActionHandle_t digitalActionHandle, VR_ARRAY_COUNT( originOutCount ) VRInputValueHandle_t *originsOut, uint32_t originOutCount ) = 0;
+
+		/** Retrieves the name of the origin in the current language. unStringSectionsToInclude is a bitfield of values in EVRInputStringBits that allows the 
+			application to specify which parts of the origin's information it wants a string for. */
+		virtual EVRInputError GetOriginLocalizedName( VRInputValueHandle_t origin, VR_OUT_STRING() char *pchNameArray, uint32_t unNameArraySize, int32_t unStringSectionsToInclude ) = 0;
+
+		/** Retrieves useful information for the origin of this action */
+		virtual EVRInputError GetOriginTrackedDeviceInfo( VRInputValueHandle_t origin, InputOriginInfo_t *pOriginInfo, uint32_t unOriginInfoSize ) = 0;
+
+		/** Retrieves useful information about the bindings for an action */
+		virtual EVRInputError GetActionBindingInfo( VRActionHandle_t action, InputBindingInfo_t *pOriginInfo, uint32_t unBindingInfoSize, uint32_t unBindingInfoCount, uint32_t *punReturnedBindingInfoCount ) = 0;
+
+		/** Shows the current binding for the action in-headset */
+		virtual EVRInputError ShowActionOrigins( VRActionSetHandle_t actionSetHandle, VRActionHandle_t ulActionHandle ) = 0;
+
+		/** Shows the current binding all the actions in the specified action sets */
+		virtual EVRInputError ShowBindingsForActionSet( VR_ARRAY_COUNT( unSetCount ) VRActiveActionSet_t *pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight ) = 0;
+
+		/** Use this to query what action on the component returned by GetOriginTrackedDeviceInfo would trigger this binding. */
+		virtual EVRInputError GetComponentStateForBinding( const char *pchRenderModelName, const char *pchComponentName,
+			const InputBindingInfo_t *pOriginInfo, uint32_t unBindingInfoSize, uint32_t unBindingInfoCount,
+			vr::RenderModel_ComponentState_t *pComponentState ) = 0;
+
+
+		// --------------- Legacy Input ------------------- //
+		virtual bool IsUsingLegacyInput() = 0;
+
+
+		// --------------- Utilities ------------------- //
+
+		/** Opens the binding user interface. If no app key is provided it will use the key from the calling process.
+		* If no set is provided it will open to the root of the app binding page. */
+		virtual EVRInputError OpenBindingUI( const char* pchAppKey, VRActionSetHandle_t ulActionSetHandle, VRInputValueHandle_t ulDeviceHandle, bool bShowOnDesktop ) = 0;
+
+		/** Returns the variant set in the current bindings. If the binding doesn't include a variant setting, this function 
+		* will return an empty string */
+		virtual EVRInputError GetBindingVariant( vr::VRInputValueHandle_t ulDevicePath,
+			VR_OUT_STRING() char *pchVariantArray, uint32_t unVariantArraySize ) = 0;
+
+	};
+
+	static const char * const IVRInput_Version = "IVRInput_010";
+
+} // namespace vr
+
+// ivriobuffer.h
+namespace vr
+{
+
+typedef uint64_t IOBufferHandle_t;
+static const uint64_t k_ulInvalidIOBufferHandle = 0;
+	
+	enum EIOBufferError
+	{
+		IOBuffer_Success                  = 0,
+		IOBuffer_OperationFailed          = 100,
+		IOBuffer_InvalidHandle            = 101,
+		IOBuffer_InvalidArgument          = 102,
+		IOBuffer_PathExists               = 103,
+		IOBuffer_PathDoesNotExist         = 104,
+		IOBuffer_Permission               = 105,
+	};
+
+	enum EIOBufferMode
+	{
+		IOBufferMode_Read                 = 0x0001,
+		IOBufferMode_Write                = 0x0002,
+		IOBufferMode_Create               = 0x0200,
+	};
+
+	// ----------------------------------------------------------------------------------------------
+	// Purpose:
+	// ----------------------------------------------------------------------------------------------
+	class IVRIOBuffer
+	{
+	public:
+		/** opens an existing or creates a new IOBuffer of unSize bytes */
+		virtual vr::EIOBufferError Open( const char *pchPath, vr::EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, vr::IOBufferHandle_t *pulBuffer ) = 0;
+		
+		/** closes a previously opened or created buffer */
+		virtual vr::EIOBufferError Close( vr::IOBufferHandle_t ulBuffer ) = 0;
+		
+		/** reads up to unBytes from buffer into *pDst, returning number of bytes read in *punRead */
+		virtual vr::EIOBufferError Read( vr::IOBufferHandle_t ulBuffer, void *pDst, uint32_t unBytes, uint32_t *punRead ) = 0;
+		
+		/** writes unBytes of data from *pSrc into a buffer. */
+		virtual vr::EIOBufferError Write( vr::IOBufferHandle_t ulBuffer, void *pSrc, uint32_t unBytes ) = 0;
+		
+		/** retrieves the property container of an buffer. */
+		virtual vr::PropertyContainerHandle_t PropertyContainer( vr::IOBufferHandle_t ulBuffer ) = 0;
+
+		/** inexpensively checks for readers to allow writers to fast-fail potentially expensive copies and writes. */
+		virtual bool HasReaders( vr::IOBufferHandle_t ulBuffer ) = 0;
+	};
+
+	static const char *IVRIOBuffer_Version = "IVRIOBuffer_002";
+}
+
+// ivrspatialanchors.h
+namespace vr
+{
+	static const SpatialAnchorHandle_t k_ulInvalidSpatialAnchorHandle = 0;
+
+	struct SpatialAnchorPose_t
+	{
+		HmdMatrix34_t mAnchorToAbsoluteTracking;
+	};
+
+	class IVRSpatialAnchors
+	{
+	public:
+
+		/** Returns a handle for an spatial anchor described by "descriptor".  On success, pHandle
+		* will contain a handle valid for this session.  Caller can wait for an event or occasionally
+		* poll GetSpatialAnchorPose() to find the virtual coordinate associated with this anchor. */
+		virtual EVRSpatialAnchorError CreateSpatialAnchorFromDescriptor( const char *pchDescriptor, SpatialAnchorHandle_t *pHandleOut ) = 0;
+
+		/** Returns a handle for an new spatial anchor at pPose.  On success, pHandle
+		* will contain a handle valid for this session.  Caller can wait for an event or occasionally
+		* poll GetSpatialAnchorDescriptor() to find the permanent descriptor for this pose.
+		* The result of GetSpatialAnchorPose() may evolve from this initial position if the driver chooses
+		* to update it.
+		* The anchor will be associated with the driver that provides unDeviceIndex, and the driver may use that specific
+		* device as a hint for how to best create the anchor.
+		* The eOrigin must match whatever tracking origin you are working in (seated/standing/raw).
+		* This should be called when the user is close to (and ideally looking at/interacting with) the target physical
+		* location.  At that moment, the driver will have the most information about how to recover that physical point
+		* in the future, and the quality of the anchor (when the descriptor is re-used) will be highest.
+		* The caller may decide to apply offsets from this initial pose, but is advised to stay relatively close to the 
+		* original pose location for highest fidelity. */
+		virtual EVRSpatialAnchorError CreateSpatialAnchorFromPose( TrackedDeviceIndex_t unDeviceIndex, ETrackingUniverseOrigin eOrigin, SpatialAnchorPose_t *pPose, SpatialAnchorHandle_t *pHandleOut ) = 0;
+
+		/** Get the pose for a given handle.  This is intended to be cheap enough to call every frame (or fairly often)
+		* so that the driver can refine this position when it has more information available. */
+		virtual EVRSpatialAnchorError GetSpatialAnchorPose( SpatialAnchorHandle_t unHandle, ETrackingUniverseOrigin eOrigin, SpatialAnchorPose_t *pPoseOut ) = 0;
+
+		/** Get the descriptor for a given handle.  This will be empty for handles where the driver has not
+		* yet built a descriptor.  It will be the application-supplied descriptor for previously saved anchors
+		* that the application is requesting poses for.  If the driver has called UpdateSpatialAnchorDescriptor()
+		* already in this session, it will be the descriptor provided by the driver.
+		* Returns true if the descriptor fits into the buffer, else false.  Buffer size should be at least
+		* k_unMaxSpatialAnchorDescriptorSize. */
+		virtual EVRSpatialAnchorError GetSpatialAnchorDescriptor( SpatialAnchorHandle_t unHandle, VR_OUT_STRING() char *pchDescriptorOut, uint32_t *punDescriptorBufferLenInOut ) = 0;
+
+	};
+
+	static const char * const IVRSpatialAnchors_Version = "IVRSpatialAnchors_001";
+
+} // namespace vr
+
+// ivrdebug.h
+namespace vr
+{
+	enum EVRDebugError
+	{
+		VRDebugError_Success = 0,
+		VRDebugError_BadParameter
+	};
+
+	/** Handle for vr profiler events */
+	typedef uint64_t VrProfilerEventHandle_t;
+
+	class IVRDebug
+	{
+	public:
+
+		/** Create a vr profiler discrete event (point)
+		* The event will be associated with the message provided in pchMessage, and the current
+		* time will be used as the event timestamp. */
+		virtual EVRDebugError EmitVrProfilerEvent( const char *pchMessage ) = 0;
+
+		/** Create an vr profiler duration event (line)
+		* The current time will be used as the timestamp for the start of the line.
+		* On success, pHandleOut will contain a handle valid for terminating this event. */
+		virtual EVRDebugError BeginVrProfilerEvent( VrProfilerEventHandle_t *pHandleOut ) = 0;
+
+		/** Terminate a vr profiler event
+		* The event associated with hHandle will be considered completed when this method is called.
+		* The current time will be used assocaited to the termination time of the event, and
+		* pchMessage will be used as the event title. */
+		virtual EVRDebugError FinishVrProfilerEvent( VrProfilerEventHandle_t hHandle, const char *pchMessage ) = 0;
+
+		/** Sends a request to the driver for the specified device and returns the response. The maximum response size is 32k,
+		* but this method can be called with a smaller buffer. If the response exceeds the size of the buffer, it is truncated.
+		* The size of the response including its terminating null is returned. */
+		virtual uint32_t DriverDebugRequest( vr::TrackedDeviceIndex_t unDeviceIndex, const char *pchRequest, VR_OUT_STRING() char *pchResponseBuffer, uint32_t unResponseBufferSize ) = 0;
+
+	};
+
+	static const char * const IVRDebug_Version = "IVRDebug_001";
+
+} // namespace vr
+// End
+
+#endif // _OPENVR_API
+
+
+
+namespace vr
+{
+#if !defined( OPENVR_INTERFACE_INTERNAL )
+
+	/** Finds the active installation of the VR API and initializes it. The provided path must be absolute
+	* or relative to the current working directory. These are the local install versions of the equivalent
+	* functions in steamvr.h and will work without a local Steam install.
+	*
+	* This path is to the "root" of the VR API install. That's the directory with
+	* the "drivers" directory and a platform (i.e. "win32") directory in it, not the directory with the DLL itself.
+	*
+	* pStartupInfo is reserved for future use.
+	*/
+	inline IVRSystem *VR_Init( EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo = nullptr );
+
+	/** unloads vrclient.dll. Any interface pointers from the interface are
+	* invalid after this point */
+	inline void VR_Shutdown();
+
+	/** Returns true if there is an HMD attached. This check is as lightweight as possible and
+	* can be called outside of VR_Init/VR_Shutdown. It should be used when an application wants
+	* to know if initializing VR is a possibility but isn't ready to take that step yet.
+	*/
+	VR_INTERFACE bool VR_CALLTYPE VR_IsHmdPresent();
+
+	/** Returns true if the OpenVR runtime is installed. */
+	VR_INTERFACE bool VR_CALLTYPE VR_IsRuntimeInstalled();
+
+	/** Returns where the OpenVR runtime is installed. */
+	VR_INTERFACE bool VR_GetRuntimePath( VR_OUT_STRING() char *pchPathBuffer, uint32_t unBufferSize, uint32_t *punRequiredBufferSize );
+	
+	/** Returns the name of the enum value for an EVRInitError. This function may be called outside of VR_Init()/VR_Shutdown(). */
+	VR_INTERFACE const char *VR_CALLTYPE VR_GetVRInitErrorAsSymbol( EVRInitError error );
+
+	/** Returns an English string for an EVRInitError. Applications should call VR_GetVRInitErrorAsSymbol instead and
+	* use that as a key to look up their own localized error message. This function may be called outside of VR_Init()/VR_Shutdown(). */
+	VR_INTERFACE const char *VR_CALLTYPE VR_GetVRInitErrorAsEnglishDescription( EVRInitError error );
+
+	/** Returns the interface of the specified version. This method must be called after VR_Init. The
+	* pointer returned is valid until VR_Shutdown is called.
+	*/
+	VR_INTERFACE void *VR_CALLTYPE VR_GetGenericInterface( const char *pchInterfaceVersion, EVRInitError *peError );
+
+	/** Returns whether the interface of the specified version exists.
+	*/
+	VR_INTERFACE bool VR_CALLTYPE VR_IsInterfaceVersionValid( const char *pchInterfaceVersion );
+
+	/** Returns a token that represents whether the VR interface handles need to be reloaded */
+	VR_INTERFACE uint32_t VR_CALLTYPE VR_GetInitToken();
+
+	// These typedefs allow old enum names from SDK 0.9.11 to be used in applications.
+	// They will go away in the future.
+	typedef EVRInitError HmdError;
+	typedef EVREye Hmd_Eye;
+	typedef EColorSpace ColorSpace;
+	typedef ETrackingResult HmdTrackingResult;
+	typedef ETrackedDeviceClass TrackedDeviceClass;
+	typedef ETrackingUniverseOrigin TrackingUniverseOrigin;
+	typedef ETrackedDeviceProperty TrackedDeviceProperty;
+	typedef ETrackedPropertyError TrackedPropertyError;
+	typedef EVRSubmitFlags VRSubmitFlags_t;
+	typedef EVRState VRState_t;
+	typedef ECollisionBoundsStyle CollisionBoundsStyle_t;
+	typedef EVROverlayError VROverlayError;
+	typedef EVRFirmwareError VRFirmwareError;
+	typedef EVRCompositorError VRCompositorError;
+	typedef EVRScreenshotError VRScreenshotsError;
+
+	inline uint32_t &VRToken()
+	{
+		static uint32_t token;
+		return token;
+	}
+
+	class COpenVRContext
+	{
+	public:
+		COpenVRContext() { Clear(); }
+		void Clear();
+
+		inline void CheckClear()
+		{
+			if ( VRToken() != VR_GetInitToken() )
+			{
+				Clear();
+				VRToken() = VR_GetInitToken();
+			}
+		}
+
+		IVRSystem *VRSystem()
+		{
+			CheckClear();
+			if ( m_pVRSystem == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRSystem = ( IVRSystem * )VR_GetGenericInterface( IVRSystem_Version, &eError );
+			}
+			return m_pVRSystem;
+		}
+		IVRChaperone *VRChaperone()
+		{
+			CheckClear();
+			if ( m_pVRChaperone == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRChaperone = ( IVRChaperone * )VR_GetGenericInterface( IVRChaperone_Version, &eError );
+			}
+			return m_pVRChaperone;
+		}
+
+		IVRChaperoneSetup *VRChaperoneSetup()
+		{
+			CheckClear();
+			if ( m_pVRChaperoneSetup == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRChaperoneSetup = ( IVRChaperoneSetup * )VR_GetGenericInterface( IVRChaperoneSetup_Version, &eError );
+			}
+			return m_pVRChaperoneSetup;
+		}
+
+		IVRCompositor *VRCompositor()
+		{
+			CheckClear();
+			if ( m_pVRCompositor == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRCompositor = ( IVRCompositor * )VR_GetGenericInterface( IVRCompositor_Version, &eError );
+			}
+			return m_pVRCompositor;
+		}
+
+		IVROverlay *VROverlay()
+		{
+			CheckClear();
+			if ( m_pVROverlay == nullptr )
+			{
+				EVRInitError eError;
+				m_pVROverlay = ( IVROverlay * )VR_GetGenericInterface( IVROverlay_Version, &eError );
+			}
+			return m_pVROverlay;
+		}
+
+		IVROverlayView *VROverlayView()
+		{
+			CheckClear();
+			if ( m_pVROverlayView == nullptr )
+			{
+				EVRInitError eError;
+				m_pVROverlayView = ( IVROverlayView * ) VR_GetGenericInterface( IVROverlayView_Version, &eError );
+			}
+			return m_pVROverlayView;
+		}
+
+		IVRHeadsetView *VRHeadsetView()
+		{
+			CheckClear();
+			if ( m_pVRHeadsetView == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRHeadsetView = ( IVRHeadsetView * ) VR_GetGenericInterface( IVRHeadsetView_Version, &eError );
+			}
+			return m_pVRHeadsetView;
+		}
+
+		IVRResources *VRResources()
+		{
+			CheckClear();
+			if ( m_pVRResources == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRResources = (IVRResources *)VR_GetGenericInterface( IVRResources_Version, &eError );
+			}
+			return m_pVRResources;
+		}
+
+		IVRScreenshots *VRScreenshots()
+		{
+			CheckClear();
+			if ( m_pVRScreenshots == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRScreenshots = ( IVRScreenshots * )VR_GetGenericInterface( IVRScreenshots_Version, &eError );
+			}
+			return m_pVRScreenshots;
+		}
+
+		IVRRenderModels *VRRenderModels()
+		{
+			CheckClear();
+			if ( m_pVRRenderModels == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRRenderModels = ( IVRRenderModels * )VR_GetGenericInterface( IVRRenderModels_Version, &eError );
+			}
+			return m_pVRRenderModels;
+		}
+
+		IVRExtendedDisplay *VRExtendedDisplay()
+		{
+			CheckClear();
+			if ( m_pVRExtendedDisplay == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRExtendedDisplay = ( IVRExtendedDisplay * )VR_GetGenericInterface( IVRExtendedDisplay_Version, &eError );
+			}
+			return m_pVRExtendedDisplay;
+		}
+
+		IVRSettings *VRSettings()
+		{
+			CheckClear();
+			if ( m_pVRSettings == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRSettings = ( IVRSettings * )VR_GetGenericInterface( IVRSettings_Version, &eError );
+			}
+			return m_pVRSettings;
+		}
+
+		IVRApplications *VRApplications()
+		{
+			CheckClear();
+			if ( m_pVRApplications == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRApplications = ( IVRApplications * )VR_GetGenericInterface( IVRApplications_Version, &eError );
+			}
+			return m_pVRApplications;
+		}
+
+		IVRTrackedCamera *VRTrackedCamera()
+		{
+			CheckClear();
+			if ( m_pVRTrackedCamera == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRTrackedCamera = ( IVRTrackedCamera * )VR_GetGenericInterface( IVRTrackedCamera_Version, &eError );
+			}
+			return m_pVRTrackedCamera;
+		}
+
+		IVRDriverManager *VRDriverManager()
+		{
+			CheckClear();
+			if ( !m_pVRDriverManager )
+			{
+				EVRInitError eError;
+				m_pVRDriverManager = ( IVRDriverManager * )VR_GetGenericInterface( IVRDriverManager_Version, &eError );
+			}
+			return m_pVRDriverManager;
+		}
+
+		IVRInput *VRInput()
+		{
+			CheckClear();
+			if ( !m_pVRInput )
+			{
+				EVRInitError eError;
+				m_pVRInput = (IVRInput *)VR_GetGenericInterface( IVRInput_Version, &eError );
+			}
+			return m_pVRInput;
+		}
+
+		IVRIOBuffer *VRIOBuffer()
+		{
+			if ( !m_pVRIOBuffer )
+			{
+				EVRInitError eError;
+				m_pVRIOBuffer = ( IVRIOBuffer * )VR_GetGenericInterface( IVRIOBuffer_Version, &eError );
+			}
+			return m_pVRIOBuffer;
+		}
+
+		IVRSpatialAnchors *VRSpatialAnchors()
+		{
+			CheckClear();
+			if ( !m_pVRSpatialAnchors )
+			{
+				EVRInitError eError;
+				m_pVRSpatialAnchors = (IVRSpatialAnchors *)VR_GetGenericInterface( IVRSpatialAnchors_Version, &eError );
+			}
+			return m_pVRSpatialAnchors;
+		}
+
+		IVRDebug *VRDebug()
+		{
+			CheckClear();
+			if ( !m_pVRDebug )
+			{
+				EVRInitError eError;
+				m_pVRDebug = (IVRDebug *)VR_GetGenericInterface( IVRDebug_Version, &eError );
+			}
+			return m_pVRDebug;
+		}
+
+		IVRNotifications *VRNotifications()
+		{
+			CheckClear();
+			if ( !m_pVRNotifications )
+			{
+				EVRInitError eError;
+				m_pVRNotifications = ( IVRNotifications * )VR_GetGenericInterface( IVRNotifications_Version, &eError );
+			}
+			return m_pVRNotifications;
+		}
+		
+	private:
+		IVRSystem			*m_pVRSystem;
+		IVRChaperone		*m_pVRChaperone;
+		IVRChaperoneSetup	*m_pVRChaperoneSetup;
+		IVRCompositor		*m_pVRCompositor;
+		IVRHeadsetView		*m_pVRHeadsetView;
+		IVROverlay			*m_pVROverlay;
+		IVROverlayView		*m_pVROverlayView;
+		IVRResources		*m_pVRResources;
+		IVRRenderModels		*m_pVRRenderModels;
+		IVRExtendedDisplay	*m_pVRExtendedDisplay;
+		IVRSettings			*m_pVRSettings;
+		IVRApplications		*m_pVRApplications;
+		IVRTrackedCamera	*m_pVRTrackedCamera;
+		IVRScreenshots		*m_pVRScreenshots;
+		IVRDriverManager	*m_pVRDriverManager;
+		IVRInput			*m_pVRInput;
+		IVRIOBuffer			*m_pVRIOBuffer;
+		IVRSpatialAnchors   *m_pVRSpatialAnchors;
+		IVRDebug			*m_pVRDebug;
+		IVRNotifications	*m_pVRNotifications;
+	};
+
+	inline COpenVRContext &OpenVRInternal_ModuleContext()
+	{
+		static void *ctx[ sizeof( COpenVRContext ) / sizeof( void * ) ];
+		return *( COpenVRContext * )ctx; // bypass zero-init constructor
+	}
+
+	inline IVRSystem *VR_CALLTYPE VRSystem() { return OpenVRInternal_ModuleContext().VRSystem(); }
+	inline IVRChaperone *VR_CALLTYPE VRChaperone() { return OpenVRInternal_ModuleContext().VRChaperone(); }
+	inline IVRChaperoneSetup *VR_CALLTYPE VRChaperoneSetup() { return OpenVRInternal_ModuleContext().VRChaperoneSetup(); }
+	inline IVRCompositor *VR_CALLTYPE VRCompositor() { return OpenVRInternal_ModuleContext().VRCompositor(); }
+	inline IVROverlay *VR_CALLTYPE VROverlay() { return OpenVRInternal_ModuleContext().VROverlay(); }
+	inline IVROverlayView *VR_CALLTYPE VROverlayView() { return OpenVRInternal_ModuleContext().VROverlayView(); }
+	inline IVRHeadsetView *VR_CALLTYPE VRHeadsetView() { return OpenVRInternal_ModuleContext().VRHeadsetView(); }
+	inline IVRScreenshots *VR_CALLTYPE VRScreenshots() { return OpenVRInternal_ModuleContext().VRScreenshots(); }
+	inline IVRRenderModels *VR_CALLTYPE VRRenderModels() { return OpenVRInternal_ModuleContext().VRRenderModels(); }
+	inline IVRApplications *VR_CALLTYPE VRApplications() { return OpenVRInternal_ModuleContext().VRApplications(); }
+	inline IVRSettings *VR_CALLTYPE VRSettings() { return OpenVRInternal_ModuleContext().VRSettings(); }
+	inline IVRResources *VR_CALLTYPE VRResources() { return OpenVRInternal_ModuleContext().VRResources(); }
+	inline IVRExtendedDisplay *VR_CALLTYPE VRExtendedDisplay() { return OpenVRInternal_ModuleContext().VRExtendedDisplay(); }
+	inline IVRTrackedCamera *VR_CALLTYPE VRTrackedCamera() { return OpenVRInternal_ModuleContext().VRTrackedCamera(); }
+	inline IVRDriverManager *VR_CALLTYPE VRDriverManager() { return OpenVRInternal_ModuleContext().VRDriverManager(); }
+	inline IVRInput *VR_CALLTYPE VRInput() { return OpenVRInternal_ModuleContext().VRInput(); }
+	inline IVRIOBuffer *VR_CALLTYPE VRIOBuffer() { return OpenVRInternal_ModuleContext().VRIOBuffer(); }
+	inline IVRSpatialAnchors *VR_CALLTYPE VRSpatialAnchors() { return OpenVRInternal_ModuleContext().VRSpatialAnchors(); }
+	inline IVRNotifications *VR_CALLTYPE VRNotifications() { return OpenVRInternal_ModuleContext().VRNotifications(); }
+	inline IVRDebug *VR_CALLTYPE VRDebug() { return OpenVRInternal_ModuleContext().VRDebug(); }
+
+	inline void COpenVRContext::Clear()
+	{
+		m_pVRSystem = nullptr;
+		m_pVRChaperone = nullptr;
+		m_pVRChaperoneSetup = nullptr;
+		m_pVRCompositor = nullptr;
+		m_pVROverlay = nullptr;
+		m_pVROverlayView = nullptr;
+		m_pVRHeadsetView = nullptr;
+		m_pVRRenderModels = nullptr;
+		m_pVRExtendedDisplay = nullptr;
+		m_pVRSettings = nullptr;
+		m_pVRApplications = nullptr;
+		m_pVRTrackedCamera = nullptr;
+		m_pVRResources = nullptr;
+		m_pVRScreenshots = nullptr;
+		m_pVRDriverManager = nullptr;
+		m_pVRInput = nullptr;
+		m_pVRIOBuffer = nullptr;
+		m_pVRSpatialAnchors = nullptr;
+		m_pVRNotifications = nullptr;
+		m_pVRDebug = nullptr;
+	}
+	
+	VR_INTERFACE uint32_t VR_CALLTYPE VR_InitInternal2( EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo );
+	VR_INTERFACE void VR_CALLTYPE VR_ShutdownInternal();
+
+	/** Finds the active installation of vrclient.dll and initializes it */
+	inline IVRSystem *VR_Init( EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo )
+	{
+		IVRSystem *pVRSystem = nullptr;
+
+		EVRInitError eError;
+		VRToken() = VR_InitInternal2( &eError, eApplicationType, pStartupInfo );
+		COpenVRContext &ctx = OpenVRInternal_ModuleContext();
+		ctx.Clear();
+
+		if ( eError == VRInitError_None )
+		{
+			if ( VR_IsInterfaceVersionValid( IVRSystem_Version ) )
+			{
+				pVRSystem = VRSystem();
+			}
+			else
+			{
+				VR_ShutdownInternal();
+				eError = VRInitError_Init_InterfaceNotFound;
+			}
+		}
+
+		if ( peError )
+			*peError = eError;
+		return pVRSystem;
+	}
+
+	/** unloads vrclient.dll. Any interface pointers from the interface are
+	* invalid after this point */
+	inline void VR_Shutdown()
+	{
+		VR_ShutdownInternal();
+	}
+
+#endif // OPENVR_INTERFACE_INTERNAL
+}
diff --git a/engine/inc/openvr-x/openvr_capi.h b/engine/inc/openvr-x/openvr_capi.h
new file mode 100644
index 00000000..625b8dab
--- /dev/null
+++ b/engine/inc/openvr-x/openvr_capi.h
@@ -0,0 +1,2898 @@
+//======= Copyright (c) Valve Corporation, All rights reserved. ===============
+//
+// Purpose: Header for flatted SteamAPI. Use this for binding to other languages.
+// This file is auto-generated, do not edit it.
+//
+//=============================================================================
+
+#ifndef __OPENVR_API_FLAT_H__
+#define __OPENVR_API_FLAT_H__
+#if defined( _WIN32 ) || defined( __clang__ )
+#pragma once
+#endif
+
+#ifdef __cplusplus
+#define EXTERN_C extern "C"
+#else
+#define EXTERN_C
+#endif
+
+#if defined( _WIN32 )
+#define OPENVR_FNTABLE_CALLTYPE __stdcall
+#else
+#define OPENVR_FNTABLE_CALLTYPE 
+#endif
+
+// OPENVR API export macro
+#if defined( _WIN32 ) && !defined( _X360 )
+	#if defined( OPENVR_API_EXPORTS )
+	#define S_API EXTERN_C __declspec( dllexport )
+	#elif defined( OPENVR_API_NODLL )
+	#define S_API EXTERN_C
+	#else
+	#define S_API extern "C" __declspec( dllimport ) 
+	#endif // OPENVR_API_EXPORTS
+#elif defined( __GNUC__ )
+	#if defined( OPENVR_API_EXPORTS )
+	#define S_API EXTERN_C __attribute__ ((visibility("default")))
+	#else
+	#define S_API EXTERN_C
+	#endif // OPENVR_API_EXPORTS
+#else // !WIN32
+	#if defined( OPENVR_API_EXPORTS )
+	#define S_API EXTERN_C
+	#else
+	#define S_API EXTERN_C
+	#endif // OPENVR_API_EXPORTS
+#endif
+
+#include <stdint.h>
+
+#if defined( __WIN32 )
+typedef char bool;
+#else
+#include <stdbool.h>
+#endif
+
+typedef uint64_t PropertyContainerHandle_t;
+typedef uint32_t PropertyTypeTag_t;
+typedef uint64_t VRActionHandle_t;
+typedef uint64_t VRActionSetHandle_t;
+typedef uint64_t VRInputValueHandle_t;
+
+
+// OpenVR Constants
+
+static const unsigned long k_nDriverNone = 4294967295;
+static const unsigned long k_unMaxDriverDebugResponseSize = 32768;
+static const unsigned long k_unTrackedDeviceIndex_Hmd = 0;
+static const unsigned long k_unMaxTrackedDeviceCount = 64;
+static const unsigned long k_unTrackedDeviceIndexOther = 4294967294;
+static const unsigned long k_unTrackedDeviceIndexInvalid = 4294967295;
+static const unsigned long long k_ulInvalidPropertyContainer = 0;
+static const unsigned long k_unInvalidPropertyTag = 0;
+static const unsigned long long k_ulInvalidDriverHandle = 0;
+static const unsigned long k_unFloatPropertyTag = 1;
+static const unsigned long k_unInt32PropertyTag = 2;
+static const unsigned long k_unUint64PropertyTag = 3;
+static const unsigned long k_unBoolPropertyTag = 4;
+static const unsigned long k_unStringPropertyTag = 5;
+static const unsigned long k_unErrorPropertyTag = 6;
+static const unsigned long k_unDoublePropertyTag = 7;
+static const unsigned long k_unHmdMatrix34PropertyTag = 20;
+static const unsigned long k_unHmdMatrix44PropertyTag = 21;
+static const unsigned long k_unHmdVector3PropertyTag = 22;
+static const unsigned long k_unHmdVector4PropertyTag = 23;
+static const unsigned long k_unHmdVector2PropertyTag = 24;
+static const unsigned long k_unHmdQuadPropertyTag = 25;
+static const unsigned long k_unHiddenAreaPropertyTag = 30;
+static const unsigned long k_unPathHandleInfoTag = 31;
+static const unsigned long k_unActionPropertyTag = 32;
+static const unsigned long k_unInputValuePropertyTag = 33;
+static const unsigned long k_unWildcardPropertyTag = 34;
+static const unsigned long k_unHapticVibrationPropertyTag = 35;
+static const unsigned long k_unSkeletonPropertyTag = 36;
+static const unsigned long k_unSpatialAnchorPosePropertyTag = 40;
+static const unsigned long k_unJsonPropertyTag = 41;
+static const unsigned long k_unActiveActionSetPropertyTag = 42;
+static const unsigned long k_unOpenVRInternalReserved_Start = 1000;
+static const unsigned long k_unOpenVRInternalReserved_End = 10000;
+static const unsigned long k_unMaxPropertyStringSize = 32768;
+static const unsigned long long k_ulInvalidActionHandle = 0;
+static const unsigned long long k_ulInvalidActionSetHandle = 0;
+static const unsigned long long k_ulInvalidInputValueHandle = 0;
+static const unsigned long k_unControllerStateAxisCount = 5;
+static const unsigned long long k_ulOverlayHandleInvalid = 0;
+static const unsigned long k_unMaxDistortionFunctionParameters = 8;
+static const unsigned long k_unScreenshotHandleInvalid = 0;
+static const char * IVRSystem_Version = "IVRSystem_021";
+static const char * IVRExtendedDisplay_Version = "IVRExtendedDisplay_001";
+static const char * IVRTrackedCamera_Version = "IVRTrackedCamera_006";
+static const unsigned long k_unMaxApplicationKeyLength = 128;
+static const char * k_pch_MimeType_HomeApp = "vr/home";
+static const char * k_pch_MimeType_GameTheater = "vr/game_theater";
+static const char * IVRApplications_Version = "IVRApplications_007";
+static const char * IVRChaperone_Version = "IVRChaperone_003";
+static const char * IVRChaperoneSetup_Version = "IVRChaperoneSetup_006";
+static const char * IVRCompositor_Version = "IVRCompositor_026";
+static const unsigned long k_unVROverlayMaxKeyLength = 128;
+static const unsigned long k_unVROverlayMaxNameLength = 128;
+static const unsigned long k_unMaxOverlayCount = 128;
+static const unsigned long k_unMaxOverlayIntersectionMaskPrimitivesCount = 32;
+static const char * IVROverlay_Version = "IVROverlay_024";
+static const char * IVROverlayView_Version = "IVROverlayView_003";
+static const unsigned long k_unHeadsetViewMaxWidth = 3840;
+static const unsigned long k_unHeadsetViewMaxHeight = 2160;
+static const char * k_pchHeadsetViewOverlayKey = "system.HeadsetView";
+static const char * IVRHeadsetView_Version = "IVRHeadsetView_001";
+static const char * k_pch_Controller_Component_GDC2015 = "gdc2015";
+static const char * k_pch_Controller_Component_Base = "base";
+static const char * k_pch_Controller_Component_Tip = "tip";
+static const char * k_pch_Controller_Component_HandGrip = "handgrip";
+static const char * k_pch_Controller_Component_Status = "status";
+static const char * IVRRenderModels_Version = "IVRRenderModels_006";
+static const unsigned long k_unNotificationTextMaxSize = 256;
+static const char * IVRNotifications_Version = "IVRNotifications_002";
+static const unsigned long k_unMaxSettingsKeyLength = 128;
+static const char * IVRSettings_Version = "IVRSettings_003";
+static const char * k_pch_SteamVR_Section = "steamvr";
+static const char * k_pch_SteamVR_RequireHmd_String = "requireHmd";
+static const char * k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver";
+static const char * k_pch_SteamVR_ForcedHmdKey_String = "forcedHmd";
+static const char * k_pch_SteamVR_DisplayDebug_Bool = "displayDebug";
+static const char * k_pch_SteamVR_DebugProcessPipe_String = "debugProcessPipe";
+static const char * k_pch_SteamVR_DisplayDebugX_Int32 = "displayDebugX";
+static const char * k_pch_SteamVR_DisplayDebugY_Int32 = "displayDebugY";
+static const char * k_pch_SteamVR_SendSystemButtonToAllApps_Bool = "sendSystemButtonToAllApps";
+static const char * k_pch_SteamVR_LogLevel_Int32 = "loglevel";
+static const char * k_pch_SteamVR_IPD_Float = "ipd";
+static const char * k_pch_SteamVR_Background_String = "background";
+static const char * k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection";
+static const char * k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight";
+static const char * k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius";
+static const char * k_pch_SteamVR_GridColor_String = "gridColor";
+static const char * k_pch_SteamVR_PlayAreaColor_String = "playAreaColor";
+static const char * k_pch_SteamVR_TrackingLossColor_String = "trackingLossColor";
+static const char * k_pch_SteamVR_ShowStage_Bool = "showStage";
+static const char * k_pch_SteamVR_ActivateMultipleDrivers_Bool = "activateMultipleDrivers";
+static const char * k_pch_SteamVR_UsingSpeakers_Bool = "usingSpeakers";
+static const char * k_pch_SteamVR_SpeakersForwardYawOffsetDegrees_Float = "speakersForwardYawOffsetDegrees";
+static const char * k_pch_SteamVR_BaseStationPowerManagement_Int32 = "basestationPowerManagement";
+static const char * k_pch_SteamVR_ShowBaseStationPowerManagementTip_Int32 = "ShowBaseStationPowerManagementTip";
+static const char * k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses";
+static const char * k_pch_SteamVR_SupersampleScale_Float = "supersampleScale";
+static const char * k_pch_SteamVR_MaxRecommendedResolution_Int32 = "maxRecommendedResolution";
+static const char * k_pch_SteamVR_MotionSmoothing_Bool = "motionSmoothing";
+static const char * k_pch_SteamVR_MotionSmoothingOverride_Int32 = "motionSmoothingOverride";
+static const char * k_pch_SteamVR_DisableAsyncReprojection_Bool = "disableAsync";
+static const char * k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking";
+static const char * k_pch_SteamVR_DefaultMirrorView_Int32 = "mirrorView";
+static const char * k_pch_SteamVR_ShowLegacyMirrorView_Bool = "showLegacyMirrorView";
+static const char * k_pch_SteamVR_MirrorViewVisibility_Bool = "showMirrorView";
+static const char * k_pch_SteamVR_MirrorViewDisplayMode_Int32 = "mirrorViewDisplayMode";
+static const char * k_pch_SteamVR_MirrorViewEye_Int32 = "mirrorViewEye";
+static const char * k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry";
+static const char * k_pch_SteamVR_MirrorViewGeometryMaximized_String = "mirrorViewGeometryMaximized";
+static const char * k_pch_SteamVR_PerfGraphVisibility_Bool = "showPerfGraph";
+static const char * k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch";
+static const char * k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch";
+static const char * k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch";
+static const char * k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard";
+static const char * k_pch_SteamVR_EnableHomeApp = "enableHomeApp";
+static const char * k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec";
+static const char * k_pch_SteamVR_RetailDemo_Bool = "retailDemo";
+static const char * k_pch_SteamVR_IpdOffset_Float = "ipdOffset";
+static const char * k_pch_SteamVR_AllowSupersampleFiltering_Bool = "allowSupersampleFiltering";
+static const char * k_pch_SteamVR_SupersampleManualOverride_Bool = "supersampleManualOverride";
+static const char * k_pch_SteamVR_EnableLinuxVulkanAsync_Bool = "enableLinuxVulkanAsync";
+static const char * k_pch_SteamVR_AllowDisplayLockedMode_Bool = "allowDisplayLockedMode";
+static const char * k_pch_SteamVR_HaveStartedTutorialForNativeChaperoneDriver_Bool = "haveStartedTutorialForNativeChaperoneDriver";
+static const char * k_pch_SteamVR_ForceWindows32bitVRMonitor = "forceWindows32BitVRMonitor";
+static const char * k_pch_SteamVR_DebugInputBinding = "debugInputBinding";
+static const char * k_pch_SteamVR_DoNotFadeToGrid = "doNotFadeToGrid";
+static const char * k_pch_SteamVR_RenderCameraMode = "renderCameraMode";
+static const char * k_pch_SteamVR_EnableSharedResourceJournaling = "enableSharedResourceJournaling";
+static const char * k_pch_SteamVR_EnableSafeMode = "enableSafeMode";
+static const char * k_pch_SteamVR_PreferredRefreshRate = "preferredRefreshRate";
+static const char * k_pch_SteamVR_LastVersionNotice = "lastVersionNotice";
+static const char * k_pch_SteamVR_LastVersionNoticeDate = "lastVersionNoticeDate";
+static const char * k_pch_SteamVR_HmdDisplayColorGainR_Float = "hmdDisplayColorGainR";
+static const char * k_pch_SteamVR_HmdDisplayColorGainG_Float = "hmdDisplayColorGainG";
+static const char * k_pch_SteamVR_HmdDisplayColorGainB_Float = "hmdDisplayColorGainB";
+static const char * k_pch_SteamVR_CustomIconStyle_String = "customIconStyle";
+static const char * k_pch_SteamVR_CustomOffIconStyle_String = "customOffIconStyle";
+static const char * k_pch_SteamVR_CustomIconForceUpdate_String = "customIconForceUpdate";
+static const char * k_pch_SteamVR_AllowGlobalActionSetPriority = "globalActionSetPriority";
+static const char * k_pch_SteamVR_OverlayRenderQuality = "overlayRenderQuality_2";
+static const char * k_pch_DirectMode_Section = "direct_mode";
+static const char * k_pch_DirectMode_Enable_Bool = "enable";
+static const char * k_pch_DirectMode_Count_Int32 = "count";
+static const char * k_pch_DirectMode_EdidVid_Int32 = "edidVid";
+static const char * k_pch_DirectMode_EdidPid_Int32 = "edidPid";
+static const char * k_pch_Lighthouse_Section = "driver_lighthouse";
+static const char * k_pch_Lighthouse_DisableIMU_Bool = "disableimu";
+static const char * k_pch_Lighthouse_DisableIMUExceptHMD_Bool = "disableimuexcepthmd";
+static const char * k_pch_Lighthouse_UseDisambiguation_String = "usedisambiguation";
+static const char * k_pch_Lighthouse_DisambiguationDebug_Int32 = "disambiguationdebug";
+static const char * k_pch_Lighthouse_PrimaryBasestation_Int32 = "primarybasestation";
+static const char * k_pch_Lighthouse_DBHistory_Bool = "dbhistory";
+static const char * k_pch_Lighthouse_EnableBluetooth_Bool = "enableBluetooth";
+static const char * k_pch_Lighthouse_PowerManagedBaseStations_String = "PowerManagedBaseStations";
+static const char * k_pch_Lighthouse_PowerManagedBaseStations2_String = "PowerManagedBaseStations2";
+static const char * k_pch_Lighthouse_InactivityTimeoutForBaseStations_Int32 = "InactivityTimeoutForBaseStations";
+static const char * k_pch_Lighthouse_EnableImuFallback_Bool = "enableImuFallback";
+static const char * k_pch_Null_Section = "driver_null";
+static const char * k_pch_Null_SerialNumber_String = "serialNumber";
+static const char * k_pch_Null_ModelNumber_String = "modelNumber";
+static const char * k_pch_Null_WindowX_Int32 = "windowX";
+static const char * k_pch_Null_WindowY_Int32 = "windowY";
+static const char * k_pch_Null_WindowWidth_Int32 = "windowWidth";
+static const char * k_pch_Null_WindowHeight_Int32 = "windowHeight";
+static const char * k_pch_Null_RenderWidth_Int32 = "renderWidth";
+static const char * k_pch_Null_RenderHeight_Int32 = "renderHeight";
+static const char * k_pch_Null_SecondsFromVsyncToPhotons_Float = "secondsFromVsyncToPhotons";
+static const char * k_pch_Null_DisplayFrequency_Float = "displayFrequency";
+static const char * k_pch_WindowsMR_Section = "driver_holographic";
+static const char * k_pch_UserInterface_Section = "userinterface";
+static const char * k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop";
+static const char * k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray";
+static const char * k_pch_UserInterface_HidePopupsWhenStatusMinimized_Bool = "HidePopupsWhenStatusMinimized";
+static const char * k_pch_UserInterface_Screenshots_Bool = "screenshots";
+static const char * k_pch_UserInterface_ScreenshotType_Int = "screenshotType";
+static const char * k_pch_Notifications_Section = "notifications";
+static const char * k_pch_Notifications_DoNotDisturb_Bool = "DoNotDisturb";
+static const char * k_pch_Keyboard_Section = "keyboard";
+static const char * k_pch_Keyboard_TutorialCompletions = "TutorialCompletions";
+static const char * k_pch_Keyboard_ScaleX = "ScaleX";
+static const char * k_pch_Keyboard_ScaleY = "ScaleY";
+static const char * k_pch_Keyboard_OffsetLeftX = "OffsetLeftX";
+static const char * k_pch_Keyboard_OffsetRightX = "OffsetRightX";
+static const char * k_pch_Keyboard_OffsetY = "OffsetY";
+static const char * k_pch_Keyboard_Smoothing = "Smoothing";
+static const char * k_pch_Perf_Section = "perfcheck";
+static const char * k_pch_Perf_PerfGraphInHMD_Bool = "perfGraphInHMD";
+static const char * k_pch_Perf_AllowTimingStore_Bool = "allowTimingStore";
+static const char * k_pch_Perf_SaveTimingsOnExit_Bool = "saveTimingsOnExit";
+static const char * k_pch_Perf_TestData_Float = "perfTestData";
+static const char * k_pch_Perf_GPUProfiling_Bool = "GPUProfiling";
+static const char * k_pch_CollisionBounds_Section = "collisionBounds";
+static const char * k_pch_CollisionBounds_Style_Int32 = "CollisionBoundsStyle";
+static const char * k_pch_CollisionBounds_GroundPerimeterOn_Bool = "CollisionBoundsGroundPerimeterOn";
+static const char * k_pch_CollisionBounds_CenterMarkerOn_Bool = "CollisionBoundsCenterMarkerOn";
+static const char * k_pch_CollisionBounds_PlaySpaceOn_Bool = "CollisionBoundsPlaySpaceOn";
+static const char * k_pch_CollisionBounds_FadeDistance_Float = "CollisionBoundsFadeDistance";
+static const char * k_pch_CollisionBounds_WallHeight_Float = "CollisionBoundsWallHeight";
+static const char * k_pch_CollisionBounds_ColorGammaR_Int32 = "CollisionBoundsColorGammaR";
+static const char * k_pch_CollisionBounds_ColorGammaG_Int32 = "CollisionBoundsColorGammaG";
+static const char * k_pch_CollisionBounds_ColorGammaB_Int32 = "CollisionBoundsColorGammaB";
+static const char * k_pch_CollisionBounds_ColorGammaA_Int32 = "CollisionBoundsColorGammaA";
+static const char * k_pch_CollisionBounds_EnableDriverImport = "enableDriverBoundsImport";
+static const char * k_pch_Camera_Section = "camera";
+static const char * k_pch_Camera_EnableCamera_Bool = "enableCamera";
+static const char * k_pch_Camera_EnableCameraInDashboard_Bool = "enableCameraInDashboard";
+static const char * k_pch_Camera_EnableCameraForCollisionBounds_Bool = "enableCameraForCollisionBounds";
+static const char * k_pch_Camera_EnableCameraForRoomView_Bool = "enableCameraForRoomView";
+static const char * k_pch_Camera_BoundsColorGammaR_Int32 = "cameraBoundsColorGammaR";
+static const char * k_pch_Camera_BoundsColorGammaG_Int32 = "cameraBoundsColorGammaG";
+static const char * k_pch_Camera_BoundsColorGammaB_Int32 = "cameraBoundsColorGammaB";
+static const char * k_pch_Camera_BoundsColorGammaA_Int32 = "cameraBoundsColorGammaA";
+static const char * k_pch_Camera_BoundsStrength_Int32 = "cameraBoundsStrength";
+static const char * k_pch_Camera_RoomViewMode_Int32 = "cameraRoomViewMode";
+static const char * k_pch_audio_Section = "audio";
+static const char * k_pch_audio_SetOsDefaultPlaybackDevice_Bool = "setOsDefaultPlaybackDevice";
+static const char * k_pch_audio_EnablePlaybackDeviceOverride_Bool = "enablePlaybackDeviceOverride";
+static const char * k_pch_audio_PlaybackDeviceOverride_String = "playbackDeviceOverride";
+static const char * k_pch_audio_PlaybackDeviceOverrideName_String = "playbackDeviceOverrideName";
+static const char * k_pch_audio_SetOsDefaultRecordingDevice_Bool = "setOsDefaultRecordingDevice";
+static const char * k_pch_audio_EnableRecordingDeviceOverride_Bool = "enableRecordingDeviceOverride";
+static const char * k_pch_audio_RecordingDeviceOverride_String = "recordingDeviceOverride";
+static const char * k_pch_audio_RecordingDeviceOverrideName_String = "recordingDeviceOverrideName";
+static const char * k_pch_audio_EnablePlaybackMirror_Bool = "enablePlaybackMirror";
+static const char * k_pch_audio_PlaybackMirrorDevice_String = "playbackMirrorDevice";
+static const char * k_pch_audio_PlaybackMirrorDeviceName_String = "playbackMirrorDeviceName";
+static const char * k_pch_audio_OldPlaybackMirrorDevice_String = "onPlaybackMirrorDevice";
+static const char * k_pch_audio_ActiveMirrorDevice_String = "activePlaybackMirrorDevice";
+static const char * k_pch_audio_EnablePlaybackMirrorIndependentVolume_Bool = "enablePlaybackMirrorIndependentVolume";
+static const char * k_pch_audio_LastHmdPlaybackDeviceId_String = "lastHmdPlaybackDeviceId";
+static const char * k_pch_audio_VIVEHDMIGain = "viveHDMIGain";
+static const char * k_pch_Power_Section = "power";
+static const char * k_pch_Power_PowerOffOnExit_Bool = "powerOffOnExit";
+static const char * k_pch_Power_TurnOffScreensTimeout_Float = "turnOffScreensTimeout";
+static const char * k_pch_Power_TurnOffControllersTimeout_Float = "turnOffControllersTimeout";
+static const char * k_pch_Power_ReturnToWatchdogTimeout_Float = "returnToWatchdogTimeout";
+static const char * k_pch_Power_AutoLaunchSteamVROnButtonPress = "autoLaunchSteamVROnButtonPress";
+static const char * k_pch_Power_PauseCompositorOnStandby_Bool = "pauseCompositorOnStandby";
+static const char * k_pch_Dashboard_Section = "dashboard";
+static const char * k_pch_Dashboard_EnableDashboard_Bool = "enableDashboard";
+static const char * k_pch_Dashboard_ArcadeMode_Bool = "arcadeMode";
+static const char * k_pch_Dashboard_Position = "position";
+static const char * k_pch_Dashboard_DesktopScale = "desktopScale";
+static const char * k_pch_Dashboard_DashboardScale = "dashboardScale";
+static const char * k_pch_modelskin_Section = "modelskins";
+static const char * k_pch_Driver_Enable_Bool = "enable";
+static const char * k_pch_Driver_BlockedBySafemode_Bool = "blocked_by_safe_mode";
+static const char * k_pch_Driver_LoadPriority_Int32 = "loadPriority";
+static const char * k_pch_WebInterface_Section = "WebInterface";
+static const char * k_pch_VRWebHelper_Section = "VRWebHelper";
+static const char * k_pch_VRWebHelper_DebuggerEnabled_Bool = "DebuggerEnabled";
+static const char * k_pch_VRWebHelper_DebuggerPort_Int32 = "DebuggerPort";
+static const char * k_pch_TrackingOverride_Section = "TrackingOverrides";
+static const char * k_pch_App_BindingAutosaveURLSuffix_String = "AutosaveURL";
+static const char * k_pch_App_BindingLegacyAPISuffix_String = "_legacy";
+static const char * k_pch_App_BindingSteamVRInputAPISuffix_String = "_steamvrinput";
+static const char * k_pch_App_BindingCurrentURLSuffix_String = "CurrentURL";
+static const char * k_pch_App_BindingPreviousURLSuffix_String = "PreviousURL";
+static const char * k_pch_App_NeedToUpdateAutosaveSuffix_Bool = "NeedToUpdateAutosave";
+static const char * k_pch_App_DominantHand_Int32 = "DominantHand";
+static const char * k_pch_Trackers_Section = "trackers";
+static const char * k_pch_DesktopUI_Section = "DesktopUI";
+static const char * k_pch_LastKnown_Section = "LastKnown";
+static const char * k_pch_LastKnown_HMDManufacturer_String = "HMDManufacturer";
+static const char * k_pch_LastKnown_HMDModel_String = "HMDModel";
+static const char * k_pch_DismissedWarnings_Section = "DismissedWarnings";
+static const char * k_pch_Input_Section = "input";
+static const char * k_pch_Input_LeftThumbstickRotation_Float = "leftThumbstickRotation";
+static const char * k_pch_Input_RightThumbstickRotation_Float = "rightThumbstickRotation";
+static const char * k_pch_Input_ThumbstickDeadzone_Float = "thumbstickDeadzone";
+static const char * k_pch_GpuSpeed_Section = "GpuSpeed";
+static const char * IVRScreenshots_Version = "IVRScreenshots_001";
+static const char * IVRResources_Version = "IVRResources_001";
+static const char * IVRDriverManager_Version = "IVRDriverManager_001";
+static const unsigned long k_unMaxActionNameLength = 64;
+static const unsigned long k_unMaxActionSetNameLength = 64;
+static const unsigned long k_unMaxActionOriginCount = 16;
+static const unsigned long k_unMaxBoneNameLength = 32;
+static const int k_nActionSetOverlayGlobalPriorityMin = 16777216;
+static const int k_nActionSetOverlayGlobalPriorityMax = 33554431;
+static const int k_nActionSetPriorityReservedMin = 33554432;
+static const char * IVRInput_Version = "IVRInput_010";
+static const unsigned long long k_ulInvalidIOBufferHandle = 0;
+static const char * IVRIOBuffer_Version = "IVRIOBuffer_002";
+static const unsigned long k_ulInvalidSpatialAnchorHandle = 0;
+static const char * IVRSpatialAnchors_Version = "IVRSpatialAnchors_001";
+static const char * IVRDebug_Version = "IVRDebug_001";
+
+// OpenVR Enums
+
+typedef enum EVREye
+{
+	EVREye_Eye_Left = 0,
+	EVREye_Eye_Right = 1,
+} EVREye;
+
+typedef enum ETextureType
+{
+	ETextureType_TextureType_Invalid = -1,
+	ETextureType_TextureType_DirectX = 0,
+	ETextureType_TextureType_OpenGL = 1,
+	ETextureType_TextureType_Vulkan = 2,
+	ETextureType_TextureType_IOSurface = 3,
+	ETextureType_TextureType_DirectX12 = 4,
+	ETextureType_TextureType_DXGISharedHandle = 5,
+	ETextureType_TextureType_Metal = 6,
+} ETextureType;
+
+typedef enum EColorSpace
+{
+	EColorSpace_ColorSpace_Auto = 0,
+	EColorSpace_ColorSpace_Gamma = 1,
+	EColorSpace_ColorSpace_Linear = 2,
+} EColorSpace;
+
+typedef enum ETrackingResult
+{
+	ETrackingResult_TrackingResult_Uninitialized = 1,
+	ETrackingResult_TrackingResult_Calibrating_InProgress = 100,
+	ETrackingResult_TrackingResult_Calibrating_OutOfRange = 101,
+	ETrackingResult_TrackingResult_Running_OK = 200,
+	ETrackingResult_TrackingResult_Running_OutOfRange = 201,
+	ETrackingResult_TrackingResult_Fallback_RotationOnly = 300,
+} ETrackingResult;
+
+typedef enum ETrackedDeviceClass
+{
+	ETrackedDeviceClass_TrackedDeviceClass_Invalid = 0,
+	ETrackedDeviceClass_TrackedDeviceClass_HMD = 1,
+	ETrackedDeviceClass_TrackedDeviceClass_Controller = 2,
+	ETrackedDeviceClass_TrackedDeviceClass_GenericTracker = 3,
+	ETrackedDeviceClass_TrackedDeviceClass_TrackingReference = 4,
+	ETrackedDeviceClass_TrackedDeviceClass_DisplayRedirect = 5,
+	ETrackedDeviceClass_TrackedDeviceClass_Max = 6,
+} ETrackedDeviceClass;
+
+typedef enum ETrackedControllerRole
+{
+	ETrackedControllerRole_TrackedControllerRole_Invalid = 0,
+	ETrackedControllerRole_TrackedControllerRole_LeftHand = 1,
+	ETrackedControllerRole_TrackedControllerRole_RightHand = 2,
+	ETrackedControllerRole_TrackedControllerRole_OptOut = 3,
+	ETrackedControllerRole_TrackedControllerRole_Treadmill = 4,
+	ETrackedControllerRole_TrackedControllerRole_Stylus = 5,
+	ETrackedControllerRole_TrackedControllerRole_Max = 5,
+} ETrackedControllerRole;
+
+typedef enum ETrackingUniverseOrigin
+{
+	ETrackingUniverseOrigin_TrackingUniverseSeated = 0,
+	ETrackingUniverseOrigin_TrackingUniverseStanding = 1,
+	ETrackingUniverseOrigin_TrackingUniverseRawAndUncalibrated = 2,
+} ETrackingUniverseOrigin;
+
+typedef enum EAdditionalRadioFeatures
+{
+	EAdditionalRadioFeatures_AdditionalRadioFeatures_None = 0,
+	EAdditionalRadioFeatures_AdditionalRadioFeatures_HTCLinkBox = 1,
+	EAdditionalRadioFeatures_AdditionalRadioFeatures_InternalDongle = 2,
+	EAdditionalRadioFeatures_AdditionalRadioFeatures_ExternalDongle = 4,
+} EAdditionalRadioFeatures;
+
+typedef enum ETrackedDeviceProperty
+{
+	ETrackedDeviceProperty_Prop_Invalid = 0,
+	ETrackedDeviceProperty_Prop_TrackingSystemName_String = 1000,
+	ETrackedDeviceProperty_Prop_ModelNumber_String = 1001,
+	ETrackedDeviceProperty_Prop_SerialNumber_String = 1002,
+	ETrackedDeviceProperty_Prop_RenderModelName_String = 1003,
+	ETrackedDeviceProperty_Prop_WillDriftInYaw_Bool = 1004,
+	ETrackedDeviceProperty_Prop_ManufacturerName_String = 1005,
+	ETrackedDeviceProperty_Prop_TrackingFirmwareVersion_String = 1006,
+	ETrackedDeviceProperty_Prop_HardwareRevision_String = 1007,
+	ETrackedDeviceProperty_Prop_AllWirelessDongleDescriptions_String = 1008,
+	ETrackedDeviceProperty_Prop_ConnectedWirelessDongle_String = 1009,
+	ETrackedDeviceProperty_Prop_DeviceIsWireless_Bool = 1010,
+	ETrackedDeviceProperty_Prop_DeviceIsCharging_Bool = 1011,
+	ETrackedDeviceProperty_Prop_DeviceBatteryPercentage_Float = 1012,
+	ETrackedDeviceProperty_Prop_StatusDisplayTransform_Matrix34 = 1013,
+	ETrackedDeviceProperty_Prop_Firmware_UpdateAvailable_Bool = 1014,
+	ETrackedDeviceProperty_Prop_Firmware_ManualUpdate_Bool = 1015,
+	ETrackedDeviceProperty_Prop_Firmware_ManualUpdateURL_String = 1016,
+	ETrackedDeviceProperty_Prop_HardwareRevision_Uint64 = 1017,
+	ETrackedDeviceProperty_Prop_FirmwareVersion_Uint64 = 1018,
+	ETrackedDeviceProperty_Prop_FPGAVersion_Uint64 = 1019,
+	ETrackedDeviceProperty_Prop_VRCVersion_Uint64 = 1020,
+	ETrackedDeviceProperty_Prop_RadioVersion_Uint64 = 1021,
+	ETrackedDeviceProperty_Prop_DongleVersion_Uint64 = 1022,
+	ETrackedDeviceProperty_Prop_BlockServerShutdown_Bool = 1023,
+	ETrackedDeviceProperty_Prop_CanUnifyCoordinateSystemWithHmd_Bool = 1024,
+	ETrackedDeviceProperty_Prop_ContainsProximitySensor_Bool = 1025,
+	ETrackedDeviceProperty_Prop_DeviceProvidesBatteryStatus_Bool = 1026,
+	ETrackedDeviceProperty_Prop_DeviceCanPowerOff_Bool = 1027,
+	ETrackedDeviceProperty_Prop_Firmware_ProgrammingTarget_String = 1028,
+	ETrackedDeviceProperty_Prop_DeviceClass_Int32 = 1029,
+	ETrackedDeviceProperty_Prop_HasCamera_Bool = 1030,
+	ETrackedDeviceProperty_Prop_DriverVersion_String = 1031,
+	ETrackedDeviceProperty_Prop_Firmware_ForceUpdateRequired_Bool = 1032,
+	ETrackedDeviceProperty_Prop_ViveSystemButtonFixRequired_Bool = 1033,
+	ETrackedDeviceProperty_Prop_ParentDriver_Uint64 = 1034,
+	ETrackedDeviceProperty_Prop_ResourceRoot_String = 1035,
+	ETrackedDeviceProperty_Prop_RegisteredDeviceType_String = 1036,
+	ETrackedDeviceProperty_Prop_InputProfilePath_String = 1037,
+	ETrackedDeviceProperty_Prop_NeverTracked_Bool = 1038,
+	ETrackedDeviceProperty_Prop_NumCameras_Int32 = 1039,
+	ETrackedDeviceProperty_Prop_CameraFrameLayout_Int32 = 1040,
+	ETrackedDeviceProperty_Prop_CameraStreamFormat_Int32 = 1041,
+	ETrackedDeviceProperty_Prop_AdditionalDeviceSettingsPath_String = 1042,
+	ETrackedDeviceProperty_Prop_Identifiable_Bool = 1043,
+	ETrackedDeviceProperty_Prop_BootloaderVersion_Uint64 = 1044,
+	ETrackedDeviceProperty_Prop_AdditionalSystemReportData_String = 1045,
+	ETrackedDeviceProperty_Prop_CompositeFirmwareVersion_String = 1046,
+	ETrackedDeviceProperty_Prop_Firmware_RemindUpdate_Bool = 1047,
+	ETrackedDeviceProperty_Prop_PeripheralApplicationVersion_Uint64 = 1048,
+	ETrackedDeviceProperty_Prop_ManufacturerSerialNumber_String = 1049,
+	ETrackedDeviceProperty_Prop_ComputedSerialNumber_String = 1050,
+	ETrackedDeviceProperty_Prop_EstimatedDeviceFirstUseTime_Int32 = 1051,
+	ETrackedDeviceProperty_Prop_ReportsTimeSinceVSync_Bool = 2000,
+	ETrackedDeviceProperty_Prop_SecondsFromVsyncToPhotons_Float = 2001,
+	ETrackedDeviceProperty_Prop_DisplayFrequency_Float = 2002,
+	ETrackedDeviceProperty_Prop_UserIpdMeters_Float = 2003,
+	ETrackedDeviceProperty_Prop_CurrentUniverseId_Uint64 = 2004,
+	ETrackedDeviceProperty_Prop_PreviousUniverseId_Uint64 = 2005,
+	ETrackedDeviceProperty_Prop_DisplayFirmwareVersion_Uint64 = 2006,
+	ETrackedDeviceProperty_Prop_IsOnDesktop_Bool = 2007,
+	ETrackedDeviceProperty_Prop_DisplayMCType_Int32 = 2008,
+	ETrackedDeviceProperty_Prop_DisplayMCOffset_Float = 2009,
+	ETrackedDeviceProperty_Prop_DisplayMCScale_Float = 2010,
+	ETrackedDeviceProperty_Prop_EdidVendorID_Int32 = 2011,
+	ETrackedDeviceProperty_Prop_DisplayMCImageLeft_String = 2012,
+	ETrackedDeviceProperty_Prop_DisplayMCImageRight_String = 2013,
+	ETrackedDeviceProperty_Prop_DisplayGCBlackClamp_Float = 2014,
+	ETrackedDeviceProperty_Prop_EdidProductID_Int32 = 2015,
+	ETrackedDeviceProperty_Prop_CameraToHeadTransform_Matrix34 = 2016,
+	ETrackedDeviceProperty_Prop_DisplayGCType_Int32 = 2017,
+	ETrackedDeviceProperty_Prop_DisplayGCOffset_Float = 2018,
+	ETrackedDeviceProperty_Prop_DisplayGCScale_Float = 2019,
+	ETrackedDeviceProperty_Prop_DisplayGCPrescale_Float = 2020,
+	ETrackedDeviceProperty_Prop_DisplayGCImage_String = 2021,
+	ETrackedDeviceProperty_Prop_LensCenterLeftU_Float = 2022,
+	ETrackedDeviceProperty_Prop_LensCenterLeftV_Float = 2023,
+	ETrackedDeviceProperty_Prop_LensCenterRightU_Float = 2024,
+	ETrackedDeviceProperty_Prop_LensCenterRightV_Float = 2025,
+	ETrackedDeviceProperty_Prop_UserHeadToEyeDepthMeters_Float = 2026,
+	ETrackedDeviceProperty_Prop_CameraFirmwareVersion_Uint64 = 2027,
+	ETrackedDeviceProperty_Prop_CameraFirmwareDescription_String = 2028,
+	ETrackedDeviceProperty_Prop_DisplayFPGAVersion_Uint64 = 2029,
+	ETrackedDeviceProperty_Prop_DisplayBootloaderVersion_Uint64 = 2030,
+	ETrackedDeviceProperty_Prop_DisplayHardwareVersion_Uint64 = 2031,
+	ETrackedDeviceProperty_Prop_AudioFirmwareVersion_Uint64 = 2032,
+	ETrackedDeviceProperty_Prop_CameraCompatibilityMode_Int32 = 2033,
+	ETrackedDeviceProperty_Prop_ScreenshotHorizontalFieldOfViewDegrees_Float = 2034,
+	ETrackedDeviceProperty_Prop_ScreenshotVerticalFieldOfViewDegrees_Float = 2035,
+	ETrackedDeviceProperty_Prop_DisplaySuppressed_Bool = 2036,
+	ETrackedDeviceProperty_Prop_DisplayAllowNightMode_Bool = 2037,
+	ETrackedDeviceProperty_Prop_DisplayMCImageWidth_Int32 = 2038,
+	ETrackedDeviceProperty_Prop_DisplayMCImageHeight_Int32 = 2039,
+	ETrackedDeviceProperty_Prop_DisplayMCImageNumChannels_Int32 = 2040,
+	ETrackedDeviceProperty_Prop_DisplayMCImageData_Binary = 2041,
+	ETrackedDeviceProperty_Prop_SecondsFromPhotonsToVblank_Float = 2042,
+	ETrackedDeviceProperty_Prop_DriverDirectModeSendsVsyncEvents_Bool = 2043,
+	ETrackedDeviceProperty_Prop_DisplayDebugMode_Bool = 2044,
+	ETrackedDeviceProperty_Prop_GraphicsAdapterLuid_Uint64 = 2045,
+	ETrackedDeviceProperty_Prop_DriverProvidedChaperonePath_String = 2048,
+	ETrackedDeviceProperty_Prop_ExpectedTrackingReferenceCount_Int32 = 2049,
+	ETrackedDeviceProperty_Prop_ExpectedControllerCount_Int32 = 2050,
+	ETrackedDeviceProperty_Prop_NamedIconPathControllerLeftDeviceOff_String = 2051,
+	ETrackedDeviceProperty_Prop_NamedIconPathControllerRightDeviceOff_String = 2052,
+	ETrackedDeviceProperty_Prop_NamedIconPathTrackingReferenceDeviceOff_String = 2053,
+	ETrackedDeviceProperty_Prop_DoNotApplyPrediction_Bool = 2054,
+	ETrackedDeviceProperty_Prop_CameraToHeadTransforms_Matrix34_Array = 2055,
+	ETrackedDeviceProperty_Prop_DistortionMeshResolution_Int32 = 2056,
+	ETrackedDeviceProperty_Prop_DriverIsDrawingControllers_Bool = 2057,
+	ETrackedDeviceProperty_Prop_DriverRequestsApplicationPause_Bool = 2058,
+	ETrackedDeviceProperty_Prop_DriverRequestsReducedRendering_Bool = 2059,
+	ETrackedDeviceProperty_Prop_MinimumIpdStepMeters_Float = 2060,
+	ETrackedDeviceProperty_Prop_AudioBridgeFirmwareVersion_Uint64 = 2061,
+	ETrackedDeviceProperty_Prop_ImageBridgeFirmwareVersion_Uint64 = 2062,
+	ETrackedDeviceProperty_Prop_ImuToHeadTransform_Matrix34 = 2063,
+	ETrackedDeviceProperty_Prop_ImuFactoryGyroBias_Vector3 = 2064,
+	ETrackedDeviceProperty_Prop_ImuFactoryGyroScale_Vector3 = 2065,
+	ETrackedDeviceProperty_Prop_ImuFactoryAccelerometerBias_Vector3 = 2066,
+	ETrackedDeviceProperty_Prop_ImuFactoryAccelerometerScale_Vector3 = 2067,
+	ETrackedDeviceProperty_Prop_ConfigurationIncludesLighthouse20Features_Bool = 2069,
+	ETrackedDeviceProperty_Prop_AdditionalRadioFeatures_Uint64 = 2070,
+	ETrackedDeviceProperty_Prop_CameraWhiteBalance_Vector4_Array = 2071,
+	ETrackedDeviceProperty_Prop_CameraDistortionFunction_Int32_Array = 2072,
+	ETrackedDeviceProperty_Prop_CameraDistortionCoefficients_Float_Array = 2073,
+	ETrackedDeviceProperty_Prop_ExpectedControllerType_String = 2074,
+	ETrackedDeviceProperty_Prop_HmdTrackingStyle_Int32 = 2075,
+	ETrackedDeviceProperty_Prop_DriverProvidedChaperoneVisibility_Bool = 2076,
+	ETrackedDeviceProperty_Prop_HmdColumnCorrectionSettingPrefix_String = 2077,
+	ETrackedDeviceProperty_Prop_CameraSupportsCompatibilityModes_Bool = 2078,
+	ETrackedDeviceProperty_Prop_DisplayAvailableFrameRates_Float_Array = 2080,
+	ETrackedDeviceProperty_Prop_DisplaySupportsMultipleFramerates_Bool = 2081,
+	ETrackedDeviceProperty_Prop_DisplayColorMultLeft_Vector3 = 2082,
+	ETrackedDeviceProperty_Prop_DisplayColorMultRight_Vector3 = 2083,
+	ETrackedDeviceProperty_Prop_DisplaySupportsRuntimeFramerateChange_Bool = 2084,
+	ETrackedDeviceProperty_Prop_DisplaySupportsAnalogGain_Bool = 2085,
+	ETrackedDeviceProperty_Prop_DisplayMinAnalogGain_Float = 2086,
+	ETrackedDeviceProperty_Prop_DisplayMaxAnalogGain_Float = 2087,
+	ETrackedDeviceProperty_Prop_DashboardScale_Float = 2091,
+	ETrackedDeviceProperty_Prop_IpdUIRangeMinMeters_Float = 2100,
+	ETrackedDeviceProperty_Prop_IpdUIRangeMaxMeters_Float = 2101,
+	ETrackedDeviceProperty_Prop_DriverRequestedMuraCorrectionMode_Int32 = 2200,
+	ETrackedDeviceProperty_Prop_DriverRequestedMuraFeather_InnerLeft_Int32 = 2201,
+	ETrackedDeviceProperty_Prop_DriverRequestedMuraFeather_InnerRight_Int32 = 2202,
+	ETrackedDeviceProperty_Prop_DriverRequestedMuraFeather_InnerTop_Int32 = 2203,
+	ETrackedDeviceProperty_Prop_DriverRequestedMuraFeather_InnerBottom_Int32 = 2204,
+	ETrackedDeviceProperty_Prop_DriverRequestedMuraFeather_OuterLeft_Int32 = 2205,
+	ETrackedDeviceProperty_Prop_DriverRequestedMuraFeather_OuterRight_Int32 = 2206,
+	ETrackedDeviceProperty_Prop_DriverRequestedMuraFeather_OuterTop_Int32 = 2207,
+	ETrackedDeviceProperty_Prop_DriverRequestedMuraFeather_OuterBottom_Int32 = 2208,
+	ETrackedDeviceProperty_Prop_Audio_DefaultPlaybackDeviceId_String = 2300,
+	ETrackedDeviceProperty_Prop_Audio_DefaultRecordingDeviceId_String = 2301,
+	ETrackedDeviceProperty_Prop_Audio_DefaultPlaybackDeviceVolume_Float = 2302,
+	ETrackedDeviceProperty_Prop_AttachedDeviceId_String = 3000,
+	ETrackedDeviceProperty_Prop_SupportedButtons_Uint64 = 3001,
+	ETrackedDeviceProperty_Prop_Axis0Type_Int32 = 3002,
+	ETrackedDeviceProperty_Prop_Axis1Type_Int32 = 3003,
+	ETrackedDeviceProperty_Prop_Axis2Type_Int32 = 3004,
+	ETrackedDeviceProperty_Prop_Axis3Type_Int32 = 3005,
+	ETrackedDeviceProperty_Prop_Axis4Type_Int32 = 3006,
+	ETrackedDeviceProperty_Prop_ControllerRoleHint_Int32 = 3007,
+	ETrackedDeviceProperty_Prop_FieldOfViewLeftDegrees_Float = 4000,
+	ETrackedDeviceProperty_Prop_FieldOfViewRightDegrees_Float = 4001,
+	ETrackedDeviceProperty_Prop_FieldOfViewTopDegrees_Float = 4002,
+	ETrackedDeviceProperty_Prop_FieldOfViewBottomDegrees_Float = 4003,
+	ETrackedDeviceProperty_Prop_TrackingRangeMinimumMeters_Float = 4004,
+	ETrackedDeviceProperty_Prop_TrackingRangeMaximumMeters_Float = 4005,
+	ETrackedDeviceProperty_Prop_ModeLabel_String = 4006,
+	ETrackedDeviceProperty_Prop_CanWirelessIdentify_Bool = 4007,
+	ETrackedDeviceProperty_Prop_Nonce_Int32 = 4008,
+	ETrackedDeviceProperty_Prop_IconPathName_String = 5000,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceOff_String = 5001,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceSearching_String = 5002,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceSearchingAlert_String = 5003,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceReady_String = 5004,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceReadyAlert_String = 5005,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceNotReady_String = 5006,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceStandby_String = 5007,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceAlertLow_String = 5008,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceStandbyAlert_String = 5009,
+	ETrackedDeviceProperty_Prop_DisplayHiddenArea_Binary_Start = 5100,
+	ETrackedDeviceProperty_Prop_DisplayHiddenArea_Binary_End = 5150,
+	ETrackedDeviceProperty_Prop_ParentContainer = 5151,
+	ETrackedDeviceProperty_Prop_OverrideContainer_Uint64 = 5152,
+	ETrackedDeviceProperty_Prop_UserConfigPath_String = 6000,
+	ETrackedDeviceProperty_Prop_InstallPath_String = 6001,
+	ETrackedDeviceProperty_Prop_HasDisplayComponent_Bool = 6002,
+	ETrackedDeviceProperty_Prop_HasControllerComponent_Bool = 6003,
+	ETrackedDeviceProperty_Prop_HasCameraComponent_Bool = 6004,
+	ETrackedDeviceProperty_Prop_HasDriverDirectModeComponent_Bool = 6005,
+	ETrackedDeviceProperty_Prop_HasVirtualDisplayComponent_Bool = 6006,
+	ETrackedDeviceProperty_Prop_HasSpatialAnchorsSupport_Bool = 6007,
+	ETrackedDeviceProperty_Prop_ControllerType_String = 7000,
+	ETrackedDeviceProperty_Prop_ControllerHandSelectionPriority_Int32 = 7002,
+	ETrackedDeviceProperty_Prop_VendorSpecific_Reserved_Start = 10000,
+	ETrackedDeviceProperty_Prop_VendorSpecific_Reserved_End = 10999,
+	ETrackedDeviceProperty_Prop_TrackedDeviceProperty_Max = 1000000,
+} ETrackedDeviceProperty;
+
+typedef enum ETrackedPropertyError
+{
+	ETrackedPropertyError_TrackedProp_Success = 0,
+	ETrackedPropertyError_TrackedProp_WrongDataType = 1,
+	ETrackedPropertyError_TrackedProp_WrongDeviceClass = 2,
+	ETrackedPropertyError_TrackedProp_BufferTooSmall = 3,
+	ETrackedPropertyError_TrackedProp_UnknownProperty = 4,
+	ETrackedPropertyError_TrackedProp_InvalidDevice = 5,
+	ETrackedPropertyError_TrackedProp_CouldNotContactServer = 6,
+	ETrackedPropertyError_TrackedProp_ValueNotProvidedByDevice = 7,
+	ETrackedPropertyError_TrackedProp_StringExceedsMaximumLength = 8,
+	ETrackedPropertyError_TrackedProp_NotYetAvailable = 9,
+	ETrackedPropertyError_TrackedProp_PermissionDenied = 10,
+	ETrackedPropertyError_TrackedProp_InvalidOperation = 11,
+	ETrackedPropertyError_TrackedProp_CannotWriteToWildcards = 12,
+	ETrackedPropertyError_TrackedProp_IPCReadFailure = 13,
+	ETrackedPropertyError_TrackedProp_OutOfMemory = 14,
+	ETrackedPropertyError_TrackedProp_InvalidContainer = 15,
+} ETrackedPropertyError;
+
+typedef enum EHmdTrackingStyle
+{
+	EHmdTrackingStyle_HmdTrackingStyle_Unknown = 0,
+	EHmdTrackingStyle_HmdTrackingStyle_Lighthouse = 1,
+	EHmdTrackingStyle_HmdTrackingStyle_OutsideInCameras = 2,
+	EHmdTrackingStyle_HmdTrackingStyle_InsideOutCameras = 3,
+} EHmdTrackingStyle;
+
+typedef enum EVRSubmitFlags
+{
+	EVRSubmitFlags_Submit_Default = 0,
+	EVRSubmitFlags_Submit_LensDistortionAlreadyApplied = 1,
+	EVRSubmitFlags_Submit_GlRenderBuffer = 2,
+	EVRSubmitFlags_Submit_Reserved = 4,
+	EVRSubmitFlags_Submit_TextureWithPose = 8,
+	EVRSubmitFlags_Submit_TextureWithDepth = 16,
+	EVRSubmitFlags_Submit_FrameDiscontinuty = 32,
+} EVRSubmitFlags;
+
+typedef enum EVRState
+{
+	EVRState_VRState_Undefined = -1,
+	EVRState_VRState_Off = 0,
+	EVRState_VRState_Searching = 1,
+	EVRState_VRState_Searching_Alert = 2,
+	EVRState_VRState_Ready = 3,
+	EVRState_VRState_Ready_Alert = 4,
+	EVRState_VRState_NotReady = 5,
+	EVRState_VRState_Standby = 6,
+	EVRState_VRState_Ready_Alert_Low = 7,
+} EVRState;
+
+typedef enum EVREventType
+{
+	EVREventType_VREvent_None = 0,
+	EVREventType_VREvent_TrackedDeviceActivated = 100,
+	EVREventType_VREvent_TrackedDeviceDeactivated = 101,
+	EVREventType_VREvent_TrackedDeviceUpdated = 102,
+	EVREventType_VREvent_TrackedDeviceUserInteractionStarted = 103,
+	EVREventType_VREvent_TrackedDeviceUserInteractionEnded = 104,
+	EVREventType_VREvent_IpdChanged = 105,
+	EVREventType_VREvent_EnterStandbyMode = 106,
+	EVREventType_VREvent_LeaveStandbyMode = 107,
+	EVREventType_VREvent_TrackedDeviceRoleChanged = 108,
+	EVREventType_VREvent_WatchdogWakeUpRequested = 109,
+	EVREventType_VREvent_LensDistortionChanged = 110,
+	EVREventType_VREvent_PropertyChanged = 111,
+	EVREventType_VREvent_WirelessDisconnect = 112,
+	EVREventType_VREvent_WirelessReconnect = 113,
+	EVREventType_VREvent_ButtonPress = 200,
+	EVREventType_VREvent_ButtonUnpress = 201,
+	EVREventType_VREvent_ButtonTouch = 202,
+	EVREventType_VREvent_ButtonUntouch = 203,
+	EVREventType_VREvent_Modal_Cancel = 257,
+	EVREventType_VREvent_MouseMove = 300,
+	EVREventType_VREvent_MouseButtonDown = 301,
+	EVREventType_VREvent_MouseButtonUp = 302,
+	EVREventType_VREvent_FocusEnter = 303,
+	EVREventType_VREvent_FocusLeave = 304,
+	EVREventType_VREvent_ScrollDiscrete = 305,
+	EVREventType_VREvent_TouchPadMove = 306,
+	EVREventType_VREvent_OverlayFocusChanged = 307,
+	EVREventType_VREvent_ReloadOverlays = 308,
+	EVREventType_VREvent_ScrollSmooth = 309,
+	EVREventType_VREvent_LockMousePosition = 310,
+	EVREventType_VREvent_UnlockMousePosition = 311,
+	EVREventType_VREvent_InputFocusCaptured = 400,
+	EVREventType_VREvent_InputFocusReleased = 401,
+	EVREventType_VREvent_SceneApplicationChanged = 404,
+	EVREventType_VREvent_SceneFocusChanged = 405,
+	EVREventType_VREvent_InputFocusChanged = 406,
+	EVREventType_VREvent_SceneApplicationUsingWrongGraphicsAdapter = 408,
+	EVREventType_VREvent_ActionBindingReloaded = 409,
+	EVREventType_VREvent_HideRenderModels = 410,
+	EVREventType_VREvent_ShowRenderModels = 411,
+	EVREventType_VREvent_SceneApplicationStateChanged = 412,
+	EVREventType_VREvent_ConsoleOpened = 420,
+	EVREventType_VREvent_ConsoleClosed = 421,
+	EVREventType_VREvent_OverlayShown = 500,
+	EVREventType_VREvent_OverlayHidden = 501,
+	EVREventType_VREvent_DashboardActivated = 502,
+	EVREventType_VREvent_DashboardDeactivated = 503,
+	EVREventType_VREvent_DashboardRequested = 505,
+	EVREventType_VREvent_ResetDashboard = 506,
+	EVREventType_VREvent_ImageLoaded = 508,
+	EVREventType_VREvent_ShowKeyboard = 509,
+	EVREventType_VREvent_HideKeyboard = 510,
+	EVREventType_VREvent_OverlayGamepadFocusGained = 511,
+	EVREventType_VREvent_OverlayGamepadFocusLost = 512,
+	EVREventType_VREvent_OverlaySharedTextureChanged = 513,
+	EVREventType_VREvent_ScreenshotTriggered = 516,
+	EVREventType_VREvent_ImageFailed = 517,
+	EVREventType_VREvent_DashboardOverlayCreated = 518,
+	EVREventType_VREvent_SwitchGamepadFocus = 519,
+	EVREventType_VREvent_RequestScreenshot = 520,
+	EVREventType_VREvent_ScreenshotTaken = 521,
+	EVREventType_VREvent_ScreenshotFailed = 522,
+	EVREventType_VREvent_SubmitScreenshotToDashboard = 523,
+	EVREventType_VREvent_ScreenshotProgressToDashboard = 524,
+	EVREventType_VREvent_PrimaryDashboardDeviceChanged = 525,
+	EVREventType_VREvent_RoomViewShown = 526,
+	EVREventType_VREvent_RoomViewHidden = 527,
+	EVREventType_VREvent_ShowUI = 528,
+	EVREventType_VREvent_ShowDevTools = 529,
+	EVREventType_VREvent_Notification_Shown = 600,
+	EVREventType_VREvent_Notification_Hidden = 601,
+	EVREventType_VREvent_Notification_BeginInteraction = 602,
+	EVREventType_VREvent_Notification_Destroyed = 603,
+	EVREventType_VREvent_Quit = 700,
+	EVREventType_VREvent_ProcessQuit = 701,
+	EVREventType_VREvent_QuitAcknowledged = 703,
+	EVREventType_VREvent_DriverRequestedQuit = 704,
+	EVREventType_VREvent_RestartRequested = 705,
+	EVREventType_VREvent_ChaperoneDataHasChanged = 800,
+	EVREventType_VREvent_ChaperoneUniverseHasChanged = 801,
+	EVREventType_VREvent_ChaperoneTempDataHasChanged = 802,
+	EVREventType_VREvent_ChaperoneSettingsHaveChanged = 803,
+	EVREventType_VREvent_SeatedZeroPoseReset = 804,
+	EVREventType_VREvent_ChaperoneFlushCache = 805,
+	EVREventType_VREvent_ChaperoneRoomSetupStarting = 806,
+	EVREventType_VREvent_ChaperoneRoomSetupFinished = 807,
+	EVREventType_VREvent_AudioSettingsHaveChanged = 820,
+	EVREventType_VREvent_BackgroundSettingHasChanged = 850,
+	EVREventType_VREvent_CameraSettingsHaveChanged = 851,
+	EVREventType_VREvent_ReprojectionSettingHasChanged = 852,
+	EVREventType_VREvent_ModelSkinSettingsHaveChanged = 853,
+	EVREventType_VREvent_EnvironmentSettingsHaveChanged = 854,
+	EVREventType_VREvent_PowerSettingsHaveChanged = 855,
+	EVREventType_VREvent_EnableHomeAppSettingsHaveChanged = 856,
+	EVREventType_VREvent_SteamVRSectionSettingChanged = 857,
+	EVREventType_VREvent_LighthouseSectionSettingChanged = 858,
+	EVREventType_VREvent_NullSectionSettingChanged = 859,
+	EVREventType_VREvent_UserInterfaceSectionSettingChanged = 860,
+	EVREventType_VREvent_NotificationsSectionSettingChanged = 861,
+	EVREventType_VREvent_KeyboardSectionSettingChanged = 862,
+	EVREventType_VREvent_PerfSectionSettingChanged = 863,
+	EVREventType_VREvent_DashboardSectionSettingChanged = 864,
+	EVREventType_VREvent_WebInterfaceSectionSettingChanged = 865,
+	EVREventType_VREvent_TrackersSectionSettingChanged = 866,
+	EVREventType_VREvent_LastKnownSectionSettingChanged = 867,
+	EVREventType_VREvent_DismissedWarningsSectionSettingChanged = 868,
+	EVREventType_VREvent_GpuSpeedSectionSettingChanged = 869,
+	EVREventType_VREvent_WindowsMRSectionSettingChanged = 870,
+	EVREventType_VREvent_OtherSectionSettingChanged = 871,
+	EVREventType_VREvent_StatusUpdate = 900,
+	EVREventType_VREvent_WebInterface_InstallDriverCompleted = 950,
+	EVREventType_VREvent_MCImageUpdated = 1000,
+	EVREventType_VREvent_FirmwareUpdateStarted = 1100,
+	EVREventType_VREvent_FirmwareUpdateFinished = 1101,
+	EVREventType_VREvent_KeyboardClosed = 1200,
+	EVREventType_VREvent_KeyboardCharInput = 1201,
+	EVREventType_VREvent_KeyboardDone = 1202,
+	EVREventType_VREvent_ApplicationListUpdated = 1303,
+	EVREventType_VREvent_ApplicationMimeTypeLoad = 1304,
+	EVREventType_VREvent_ProcessConnected = 1306,
+	EVREventType_VREvent_ProcessDisconnected = 1307,
+	EVREventType_VREvent_Compositor_ChaperoneBoundsShown = 1410,
+	EVREventType_VREvent_Compositor_ChaperoneBoundsHidden = 1411,
+	EVREventType_VREvent_Compositor_DisplayDisconnected = 1412,
+	EVREventType_VREvent_Compositor_DisplayReconnected = 1413,
+	EVREventType_VREvent_Compositor_HDCPError = 1414,
+	EVREventType_VREvent_Compositor_ApplicationNotResponding = 1415,
+	EVREventType_VREvent_Compositor_ApplicationResumed = 1416,
+	EVREventType_VREvent_Compositor_OutOfVideoMemory = 1417,
+	EVREventType_VREvent_Compositor_DisplayModeNotSupported = 1418,
+	EVREventType_VREvent_Compositor_StageOverrideReady = 1419,
+	EVREventType_VREvent_TrackedCamera_StartVideoStream = 1500,
+	EVREventType_VREvent_TrackedCamera_StopVideoStream = 1501,
+	EVREventType_VREvent_TrackedCamera_PauseVideoStream = 1502,
+	EVREventType_VREvent_TrackedCamera_ResumeVideoStream = 1503,
+	EVREventType_VREvent_TrackedCamera_EditingSurface = 1550,
+	EVREventType_VREvent_PerformanceTest_EnableCapture = 1600,
+	EVREventType_VREvent_PerformanceTest_DisableCapture = 1601,
+	EVREventType_VREvent_PerformanceTest_FidelityLevel = 1602,
+	EVREventType_VREvent_MessageOverlay_Closed = 1650,
+	EVREventType_VREvent_MessageOverlayCloseRequested = 1651,
+	EVREventType_VREvent_Input_HapticVibration = 1700,
+	EVREventType_VREvent_Input_BindingLoadFailed = 1701,
+	EVREventType_VREvent_Input_BindingLoadSuccessful = 1702,
+	EVREventType_VREvent_Input_ActionManifestReloaded = 1703,
+	EVREventType_VREvent_Input_ActionManifestLoadFailed = 1704,
+	EVREventType_VREvent_Input_ProgressUpdate = 1705,
+	EVREventType_VREvent_Input_TrackerActivated = 1706,
+	EVREventType_VREvent_Input_BindingsUpdated = 1707,
+	EVREventType_VREvent_Input_BindingSubscriptionChanged = 1708,
+	EVREventType_VREvent_SpatialAnchors_PoseUpdated = 1800,
+	EVREventType_VREvent_SpatialAnchors_DescriptorUpdated = 1801,
+	EVREventType_VREvent_SpatialAnchors_RequestPoseUpdate = 1802,
+	EVREventType_VREvent_SpatialAnchors_RequestDescriptorUpdate = 1803,
+	EVREventType_VREvent_SystemReport_Started = 1900,
+	EVREventType_VREvent_Monitor_ShowHeadsetView = 2000,
+	EVREventType_VREvent_Monitor_HideHeadsetView = 2001,
+	EVREventType_VREvent_VendorSpecific_Reserved_Start = 10000,
+	EVREventType_VREvent_VendorSpecific_Reserved_End = 19999,
+} EVREventType;
+
+typedef enum EDeviceActivityLevel
+{
+	EDeviceActivityLevel_k_EDeviceActivityLevel_Unknown = -1,
+	EDeviceActivityLevel_k_EDeviceActivityLevel_Idle = 0,
+	EDeviceActivityLevel_k_EDeviceActivityLevel_UserInteraction = 1,
+	EDeviceActivityLevel_k_EDeviceActivityLevel_UserInteraction_Timeout = 2,
+	EDeviceActivityLevel_k_EDeviceActivityLevel_Standby = 3,
+	EDeviceActivityLevel_k_EDeviceActivityLevel_Idle_Timeout = 4,
+} EDeviceActivityLevel;
+
+typedef enum EVRButtonId
+{
+	EVRButtonId_k_EButton_System = 0,
+	EVRButtonId_k_EButton_ApplicationMenu = 1,
+	EVRButtonId_k_EButton_Grip = 2,
+	EVRButtonId_k_EButton_DPad_Left = 3,
+	EVRButtonId_k_EButton_DPad_Up = 4,
+	EVRButtonId_k_EButton_DPad_Right = 5,
+	EVRButtonId_k_EButton_DPad_Down = 6,
+	EVRButtonId_k_EButton_A = 7,
+	EVRButtonId_k_EButton_ProximitySensor = 31,
+	EVRButtonId_k_EButton_Axis0 = 32,
+	EVRButtonId_k_EButton_Axis1 = 33,
+	EVRButtonId_k_EButton_Axis2 = 34,
+	EVRButtonId_k_EButton_Axis3 = 35,
+	EVRButtonId_k_EButton_Axis4 = 36,
+	EVRButtonId_k_EButton_SteamVR_Touchpad = 32,
+	EVRButtonId_k_EButton_SteamVR_Trigger = 33,
+	EVRButtonId_k_EButton_Dashboard_Back = 2,
+	EVRButtonId_k_EButton_IndexController_A = 2,
+	EVRButtonId_k_EButton_IndexController_B = 1,
+	EVRButtonId_k_EButton_IndexController_JoyStick = 35,
+	EVRButtonId_k_EButton_Max = 64,
+} EVRButtonId;
+
+typedef enum EVRMouseButton
+{
+	EVRMouseButton_VRMouseButton_Left = 1,
+	EVRMouseButton_VRMouseButton_Right = 2,
+	EVRMouseButton_VRMouseButton_Middle = 4,
+} EVRMouseButton;
+
+typedef enum EShowUIType
+{
+	EShowUIType_ShowUI_ControllerBinding = 0,
+	EShowUIType_ShowUI_ManageTrackers = 1,
+	EShowUIType_ShowUI_Pairing = 3,
+	EShowUIType_ShowUI_Settings = 4,
+	EShowUIType_ShowUI_DebugCommands = 5,
+	EShowUIType_ShowUI_FullControllerBinding = 6,
+	EShowUIType_ShowUI_ManageDrivers = 7,
+} EShowUIType;
+
+typedef enum EHDCPError
+{
+	EHDCPError_HDCPError_None = 0,
+	EHDCPError_HDCPError_LinkLost = 1,
+	EHDCPError_HDCPError_Tampered = 2,
+	EHDCPError_HDCPError_DeviceRevoked = 3,
+	EHDCPError_HDCPError_Unknown = 4,
+} EHDCPError;
+
+typedef enum EVRComponentProperty
+{
+	EVRComponentProperty_VRComponentProperty_IsStatic = 1,
+	EVRComponentProperty_VRComponentProperty_IsVisible = 2,
+	EVRComponentProperty_VRComponentProperty_IsTouched = 4,
+	EVRComponentProperty_VRComponentProperty_IsPressed = 8,
+	EVRComponentProperty_VRComponentProperty_IsScrolled = 16,
+	EVRComponentProperty_VRComponentProperty_IsHighlighted = 32,
+} EVRComponentProperty;
+
+typedef enum EVRInputError
+{
+	EVRInputError_VRInputError_None = 0,
+	EVRInputError_VRInputError_NameNotFound = 1,
+	EVRInputError_VRInputError_WrongType = 2,
+	EVRInputError_VRInputError_InvalidHandle = 3,
+	EVRInputError_VRInputError_InvalidParam = 4,
+	EVRInputError_VRInputError_NoSteam = 5,
+	EVRInputError_VRInputError_MaxCapacityReached = 6,
+	EVRInputError_VRInputError_IPCError = 7,
+	EVRInputError_VRInputError_NoActiveActionSet = 8,
+	EVRInputError_VRInputError_InvalidDevice = 9,
+	EVRInputError_VRInputError_InvalidSkeleton = 10,
+	EVRInputError_VRInputError_InvalidBoneCount = 11,
+	EVRInputError_VRInputError_InvalidCompressedData = 12,
+	EVRInputError_VRInputError_NoData = 13,
+	EVRInputError_VRInputError_BufferTooSmall = 14,
+	EVRInputError_VRInputError_MismatchedActionManifest = 15,
+	EVRInputError_VRInputError_MissingSkeletonData = 16,
+	EVRInputError_VRInputError_InvalidBoneIndex = 17,
+	EVRInputError_VRInputError_InvalidPriority = 18,
+	EVRInputError_VRInputError_PermissionDenied = 19,
+	EVRInputError_VRInputError_InvalidRenderModel = 20,
+} EVRInputError;
+
+typedef enum EVRSpatialAnchorError
+{
+	EVRSpatialAnchorError_VRSpatialAnchorError_Success = 0,
+	EVRSpatialAnchorError_VRSpatialAnchorError_Internal = 1,
+	EVRSpatialAnchorError_VRSpatialAnchorError_UnknownHandle = 2,
+	EVRSpatialAnchorError_VRSpatialAnchorError_ArrayTooSmall = 3,
+	EVRSpatialAnchorError_VRSpatialAnchorError_InvalidDescriptorChar = 4,
+	EVRSpatialAnchorError_VRSpatialAnchorError_NotYetAvailable = 5,
+	EVRSpatialAnchorError_VRSpatialAnchorError_NotAvailableInThisUniverse = 6,
+	EVRSpatialAnchorError_VRSpatialAnchorError_PermanentlyUnavailable = 7,
+	EVRSpatialAnchorError_VRSpatialAnchorError_WrongDriver = 8,
+	EVRSpatialAnchorError_VRSpatialAnchorError_DescriptorTooLong = 9,
+	EVRSpatialAnchorError_VRSpatialAnchorError_Unknown = 10,
+	EVRSpatialAnchorError_VRSpatialAnchorError_NoRoomCalibration = 11,
+	EVRSpatialAnchorError_VRSpatialAnchorError_InvalidArgument = 12,
+	EVRSpatialAnchorError_VRSpatialAnchorError_UnknownDriver = 13,
+} EVRSpatialAnchorError;
+
+typedef enum EHiddenAreaMeshType
+{
+	EHiddenAreaMeshType_k_eHiddenAreaMesh_Standard = 0,
+	EHiddenAreaMeshType_k_eHiddenAreaMesh_Inverse = 1,
+	EHiddenAreaMeshType_k_eHiddenAreaMesh_LineLoop = 2,
+	EHiddenAreaMeshType_k_eHiddenAreaMesh_Max = 3,
+} EHiddenAreaMeshType;
+
+typedef enum EVRControllerAxisType
+{
+	EVRControllerAxisType_k_eControllerAxis_None = 0,
+	EVRControllerAxisType_k_eControllerAxis_TrackPad = 1,
+	EVRControllerAxisType_k_eControllerAxis_Joystick = 2,
+	EVRControllerAxisType_k_eControllerAxis_Trigger = 3,
+} EVRControllerAxisType;
+
+typedef enum EVRControllerEventOutputType
+{
+	EVRControllerEventOutputType_ControllerEventOutput_OSEvents = 0,
+	EVRControllerEventOutputType_ControllerEventOutput_VREvents = 1,
+} EVRControllerEventOutputType;
+
+typedef enum ECollisionBoundsStyle
+{
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_BEGINNER = 0,
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_INTERMEDIATE = 1,
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_SQUARES = 2,
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_ADVANCED = 3,
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_NONE = 4,
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_COUNT = 5,
+} ECollisionBoundsStyle;
+
+typedef enum EVROverlayError
+{
+	EVROverlayError_VROverlayError_None = 0,
+	EVROverlayError_VROverlayError_UnknownOverlay = 10,
+	EVROverlayError_VROverlayError_InvalidHandle = 11,
+	EVROverlayError_VROverlayError_PermissionDenied = 12,
+	EVROverlayError_VROverlayError_OverlayLimitExceeded = 13,
+	EVROverlayError_VROverlayError_WrongVisibilityType = 14,
+	EVROverlayError_VROverlayError_KeyTooLong = 15,
+	EVROverlayError_VROverlayError_NameTooLong = 16,
+	EVROverlayError_VROverlayError_KeyInUse = 17,
+	EVROverlayError_VROverlayError_WrongTransformType = 18,
+	EVROverlayError_VROverlayError_InvalidTrackedDevice = 19,
+	EVROverlayError_VROverlayError_InvalidParameter = 20,
+	EVROverlayError_VROverlayError_ThumbnailCantBeDestroyed = 21,
+	EVROverlayError_VROverlayError_ArrayTooSmall = 22,
+	EVROverlayError_VROverlayError_RequestFailed = 23,
+	EVROverlayError_VROverlayError_InvalidTexture = 24,
+	EVROverlayError_VROverlayError_UnableToLoadFile = 25,
+	EVROverlayError_VROverlayError_KeyboardAlreadyInUse = 26,
+	EVROverlayError_VROverlayError_NoNeighbor = 27,
+	EVROverlayError_VROverlayError_TooManyMaskPrimitives = 29,
+	EVROverlayError_VROverlayError_BadMaskPrimitive = 30,
+	EVROverlayError_VROverlayError_TextureAlreadyLocked = 31,
+	EVROverlayError_VROverlayError_TextureLockCapacityReached = 32,
+	EVROverlayError_VROverlayError_TextureNotLocked = 33,
+} EVROverlayError;
+
+typedef enum EVRApplicationType
+{
+	EVRApplicationType_VRApplication_Other = 0,
+	EVRApplicationType_VRApplication_Scene = 1,
+	EVRApplicationType_VRApplication_Overlay = 2,
+	EVRApplicationType_VRApplication_Background = 3,
+	EVRApplicationType_VRApplication_Utility = 4,
+	EVRApplicationType_VRApplication_VRMonitor = 5,
+	EVRApplicationType_VRApplication_SteamWatchdog = 6,
+	EVRApplicationType_VRApplication_Bootstrapper = 7,
+	EVRApplicationType_VRApplication_WebHelper = 8,
+	EVRApplicationType_VRApplication_Max = 9,
+} EVRApplicationType;
+
+typedef enum EVRFirmwareError
+{
+	EVRFirmwareError_VRFirmwareError_None = 0,
+	EVRFirmwareError_VRFirmwareError_Success = 1,
+	EVRFirmwareError_VRFirmwareError_Fail = 2,
+} EVRFirmwareError;
+
+typedef enum EVRNotificationError
+{
+	EVRNotificationError_VRNotificationError_OK = 0,
+	EVRNotificationError_VRNotificationError_InvalidNotificationId = 100,
+	EVRNotificationError_VRNotificationError_NotificationQueueFull = 101,
+	EVRNotificationError_VRNotificationError_InvalidOverlayHandle = 102,
+	EVRNotificationError_VRNotificationError_SystemWithUserValueAlreadyExists = 103,
+} EVRNotificationError;
+
+typedef enum EVRSkeletalMotionRange
+{
+	EVRSkeletalMotionRange_VRSkeletalMotionRange_WithController = 0,
+	EVRSkeletalMotionRange_VRSkeletalMotionRange_WithoutController = 1,
+} EVRSkeletalMotionRange;
+
+typedef enum EVRSkeletalTrackingLevel
+{
+	EVRSkeletalTrackingLevel_VRSkeletalTracking_Estimated = 0,
+	EVRSkeletalTrackingLevel_VRSkeletalTracking_Partial = 1,
+	EVRSkeletalTrackingLevel_VRSkeletalTracking_Full = 2,
+	EVRSkeletalTrackingLevel_VRSkeletalTrackingLevel_Count = 3,
+	EVRSkeletalTrackingLevel_VRSkeletalTrackingLevel_Max = 2,
+} EVRSkeletalTrackingLevel;
+
+typedef enum EVRInitError
+{
+	EVRInitError_VRInitError_None = 0,
+	EVRInitError_VRInitError_Unknown = 1,
+	EVRInitError_VRInitError_Init_InstallationNotFound = 100,
+	EVRInitError_VRInitError_Init_InstallationCorrupt = 101,
+	EVRInitError_VRInitError_Init_VRClientDLLNotFound = 102,
+	EVRInitError_VRInitError_Init_FileNotFound = 103,
+	EVRInitError_VRInitError_Init_FactoryNotFound = 104,
+	EVRInitError_VRInitError_Init_InterfaceNotFound = 105,
+	EVRInitError_VRInitError_Init_InvalidInterface = 106,
+	EVRInitError_VRInitError_Init_UserConfigDirectoryInvalid = 107,
+	EVRInitError_VRInitError_Init_HmdNotFound = 108,
+	EVRInitError_VRInitError_Init_NotInitialized = 109,
+	EVRInitError_VRInitError_Init_PathRegistryNotFound = 110,
+	EVRInitError_VRInitError_Init_NoConfigPath = 111,
+	EVRInitError_VRInitError_Init_NoLogPath = 112,
+	EVRInitError_VRInitError_Init_PathRegistryNotWritable = 113,
+	EVRInitError_VRInitError_Init_AppInfoInitFailed = 114,
+	EVRInitError_VRInitError_Init_Retry = 115,
+	EVRInitError_VRInitError_Init_InitCanceledByUser = 116,
+	EVRInitError_VRInitError_Init_AnotherAppLaunching = 117,
+	EVRInitError_VRInitError_Init_SettingsInitFailed = 118,
+	EVRInitError_VRInitError_Init_ShuttingDown = 119,
+	EVRInitError_VRInitError_Init_TooManyObjects = 120,
+	EVRInitError_VRInitError_Init_NoServerForBackgroundApp = 121,
+	EVRInitError_VRInitError_Init_NotSupportedWithCompositor = 122,
+	EVRInitError_VRInitError_Init_NotAvailableToUtilityApps = 123,
+	EVRInitError_VRInitError_Init_Internal = 124,
+	EVRInitError_VRInitError_Init_HmdDriverIdIsNone = 125,
+	EVRInitError_VRInitError_Init_HmdNotFoundPresenceFailed = 126,
+	EVRInitError_VRInitError_Init_VRMonitorNotFound = 127,
+	EVRInitError_VRInitError_Init_VRMonitorStartupFailed = 128,
+	EVRInitError_VRInitError_Init_LowPowerWatchdogNotSupported = 129,
+	EVRInitError_VRInitError_Init_InvalidApplicationType = 130,
+	EVRInitError_VRInitError_Init_NotAvailableToWatchdogApps = 131,
+	EVRInitError_VRInitError_Init_WatchdogDisabledInSettings = 132,
+	EVRInitError_VRInitError_Init_VRDashboardNotFound = 133,
+	EVRInitError_VRInitError_Init_VRDashboardStartupFailed = 134,
+	EVRInitError_VRInitError_Init_VRHomeNotFound = 135,
+	EVRInitError_VRInitError_Init_VRHomeStartupFailed = 136,
+	EVRInitError_VRInitError_Init_RebootingBusy = 137,
+	EVRInitError_VRInitError_Init_FirmwareUpdateBusy = 138,
+	EVRInitError_VRInitError_Init_FirmwareRecoveryBusy = 139,
+	EVRInitError_VRInitError_Init_USBServiceBusy = 140,
+	EVRInitError_VRInitError_Init_VRWebHelperStartupFailed = 141,
+	EVRInitError_VRInitError_Init_TrackerManagerInitFailed = 142,
+	EVRInitError_VRInitError_Init_AlreadyRunning = 143,
+	EVRInitError_VRInitError_Init_FailedForVrMonitor = 144,
+	EVRInitError_VRInitError_Init_PropertyManagerInitFailed = 145,
+	EVRInitError_VRInitError_Init_WebServerFailed = 146,
+	EVRInitError_VRInitError_Driver_Failed = 200,
+	EVRInitError_VRInitError_Driver_Unknown = 201,
+	EVRInitError_VRInitError_Driver_HmdUnknown = 202,
+	EVRInitError_VRInitError_Driver_NotLoaded = 203,
+	EVRInitError_VRInitError_Driver_RuntimeOutOfDate = 204,
+	EVRInitError_VRInitError_Driver_HmdInUse = 205,
+	EVRInitError_VRInitError_Driver_NotCalibrated = 206,
+	EVRInitError_VRInitError_Driver_CalibrationInvalid = 207,
+	EVRInitError_VRInitError_Driver_HmdDisplayNotFound = 208,
+	EVRInitError_VRInitError_Driver_TrackedDeviceInterfaceUnknown = 209,
+	EVRInitError_VRInitError_Driver_HmdDriverIdOutOfBounds = 211,
+	EVRInitError_VRInitError_Driver_HmdDisplayMirrored = 212,
+	EVRInitError_VRInitError_Driver_HmdDisplayNotFoundLaptop = 213,
+	EVRInitError_VRInitError_IPC_ServerInitFailed = 300,
+	EVRInitError_VRInitError_IPC_ConnectFailed = 301,
+	EVRInitError_VRInitError_IPC_SharedStateInitFailed = 302,
+	EVRInitError_VRInitError_IPC_CompositorInitFailed = 303,
+	EVRInitError_VRInitError_IPC_MutexInitFailed = 304,
+	EVRInitError_VRInitError_IPC_Failed = 305,
+	EVRInitError_VRInitError_IPC_CompositorConnectFailed = 306,
+	EVRInitError_VRInitError_IPC_CompositorInvalidConnectResponse = 307,
+	EVRInitError_VRInitError_IPC_ConnectFailedAfterMultipleAttempts = 308,
+	EVRInitError_VRInitError_IPC_ConnectFailedAfterTargetExited = 309,
+	EVRInitError_VRInitError_IPC_NamespaceUnavailable = 310,
+	EVRInitError_VRInitError_Compositor_Failed = 400,
+	EVRInitError_VRInitError_Compositor_D3D11HardwareRequired = 401,
+	EVRInitError_VRInitError_Compositor_FirmwareRequiresUpdate = 402,
+	EVRInitError_VRInitError_Compositor_OverlayInitFailed = 403,
+	EVRInitError_VRInitError_Compositor_ScreenshotsInitFailed = 404,
+	EVRInitError_VRInitError_Compositor_UnableToCreateDevice = 405,
+	EVRInitError_VRInitError_Compositor_SharedStateIsNull = 406,
+	EVRInitError_VRInitError_Compositor_NotificationManagerIsNull = 407,
+	EVRInitError_VRInitError_Compositor_ResourceManagerClientIsNull = 408,
+	EVRInitError_VRInitError_Compositor_MessageOverlaySharedStateInitFailure = 409,
+	EVRInitError_VRInitError_Compositor_PropertiesInterfaceIsNull = 410,
+	EVRInitError_VRInitError_Compositor_CreateFullscreenWindowFailed = 411,
+	EVRInitError_VRInitError_Compositor_SettingsInterfaceIsNull = 412,
+	EVRInitError_VRInitError_Compositor_FailedToShowWindow = 413,
+	EVRInitError_VRInitError_Compositor_DistortInterfaceIsNull = 414,
+	EVRInitError_VRInitError_Compositor_DisplayFrequencyFailure = 415,
+	EVRInitError_VRInitError_Compositor_RendererInitializationFailed = 416,
+	EVRInitError_VRInitError_Compositor_DXGIFactoryInterfaceIsNull = 417,
+	EVRInitError_VRInitError_Compositor_DXGIFactoryCreateFailed = 418,
+	EVRInitError_VRInitError_Compositor_DXGIFactoryQueryFailed = 419,
+	EVRInitError_VRInitError_Compositor_InvalidAdapterDesktop = 420,
+	EVRInitError_VRInitError_Compositor_InvalidHmdAttachment = 421,
+	EVRInitError_VRInitError_Compositor_InvalidOutputDesktop = 422,
+	EVRInitError_VRInitError_Compositor_InvalidDeviceProvided = 423,
+	EVRInitError_VRInitError_Compositor_D3D11RendererInitializationFailed = 424,
+	EVRInitError_VRInitError_Compositor_FailedToFindDisplayMode = 425,
+	EVRInitError_VRInitError_Compositor_FailedToCreateSwapChain = 426,
+	EVRInitError_VRInitError_Compositor_FailedToGetBackBuffer = 427,
+	EVRInitError_VRInitError_Compositor_FailedToCreateRenderTarget = 428,
+	EVRInitError_VRInitError_Compositor_FailedToCreateDXGI2SwapChain = 429,
+	EVRInitError_VRInitError_Compositor_FailedtoGetDXGI2BackBuffer = 430,
+	EVRInitError_VRInitError_Compositor_FailedToCreateDXGI2RenderTarget = 431,
+	EVRInitError_VRInitError_Compositor_FailedToGetDXGIDeviceInterface = 432,
+	EVRInitError_VRInitError_Compositor_SelectDisplayMode = 433,
+	EVRInitError_VRInitError_Compositor_FailedToCreateNvAPIRenderTargets = 434,
+	EVRInitError_VRInitError_Compositor_NvAPISetDisplayMode = 435,
+	EVRInitError_VRInitError_Compositor_FailedToCreateDirectModeDisplay = 436,
+	EVRInitError_VRInitError_Compositor_InvalidHmdPropertyContainer = 437,
+	EVRInitError_VRInitError_Compositor_UpdateDisplayFrequency = 438,
+	EVRInitError_VRInitError_Compositor_CreateRasterizerState = 439,
+	EVRInitError_VRInitError_Compositor_CreateWireframeRasterizerState = 440,
+	EVRInitError_VRInitError_Compositor_CreateSamplerState = 441,
+	EVRInitError_VRInitError_Compositor_CreateClampToBorderSamplerState = 442,
+	EVRInitError_VRInitError_Compositor_CreateAnisoSamplerState = 443,
+	EVRInitError_VRInitError_Compositor_CreateOverlaySamplerState = 444,
+	EVRInitError_VRInitError_Compositor_CreatePanoramaSamplerState = 445,
+	EVRInitError_VRInitError_Compositor_CreateFontSamplerState = 446,
+	EVRInitError_VRInitError_Compositor_CreateNoBlendState = 447,
+	EVRInitError_VRInitError_Compositor_CreateBlendState = 448,
+	EVRInitError_VRInitError_Compositor_CreateAlphaBlendState = 449,
+	EVRInitError_VRInitError_Compositor_CreateBlendStateMaskR = 450,
+	EVRInitError_VRInitError_Compositor_CreateBlendStateMaskG = 451,
+	EVRInitError_VRInitError_Compositor_CreateBlendStateMaskB = 452,
+	EVRInitError_VRInitError_Compositor_CreateDepthStencilState = 453,
+	EVRInitError_VRInitError_Compositor_CreateDepthStencilStateNoWrite = 454,
+	EVRInitError_VRInitError_Compositor_CreateDepthStencilStateNoDepth = 455,
+	EVRInitError_VRInitError_Compositor_CreateFlushTexture = 456,
+	EVRInitError_VRInitError_Compositor_CreateDistortionSurfaces = 457,
+	EVRInitError_VRInitError_Compositor_CreateConstantBuffer = 458,
+	EVRInitError_VRInitError_Compositor_CreateHmdPoseConstantBuffer = 459,
+	EVRInitError_VRInitError_Compositor_CreateHmdPoseStagingConstantBuffer = 460,
+	EVRInitError_VRInitError_Compositor_CreateSharedFrameInfoConstantBuffer = 461,
+	EVRInitError_VRInitError_Compositor_CreateOverlayConstantBuffer = 462,
+	EVRInitError_VRInitError_Compositor_CreateSceneTextureIndexConstantBuffer = 463,
+	EVRInitError_VRInitError_Compositor_CreateReadableSceneTextureIndexConstantBuffer = 464,
+	EVRInitError_VRInitError_Compositor_CreateLayerGraphicsTextureIndexConstantBuffer = 465,
+	EVRInitError_VRInitError_Compositor_CreateLayerComputeTextureIndexConstantBuffer = 466,
+	EVRInitError_VRInitError_Compositor_CreateLayerComputeSceneTextureIndexConstantBuffer = 467,
+	EVRInitError_VRInitError_Compositor_CreateComputeHmdPoseConstantBuffer = 468,
+	EVRInitError_VRInitError_Compositor_CreateGeomConstantBuffer = 469,
+	EVRInitError_VRInitError_Compositor_CreatePanelMaskConstantBuffer = 470,
+	EVRInitError_VRInitError_Compositor_CreatePixelSimUBO = 471,
+	EVRInitError_VRInitError_Compositor_CreateMSAARenderTextures = 472,
+	EVRInitError_VRInitError_Compositor_CreateResolveRenderTextures = 473,
+	EVRInitError_VRInitError_Compositor_CreateComputeResolveRenderTextures = 474,
+	EVRInitError_VRInitError_Compositor_CreateDriverDirectModeResolveTextures = 475,
+	EVRInitError_VRInitError_Compositor_OpenDriverDirectModeResolveTextures = 476,
+	EVRInitError_VRInitError_Compositor_CreateFallbackSyncTexture = 477,
+	EVRInitError_VRInitError_Compositor_ShareFallbackSyncTexture = 478,
+	EVRInitError_VRInitError_Compositor_CreateOverlayIndexBuffer = 479,
+	EVRInitError_VRInitError_Compositor_CreateOverlayVertexBuffer = 480,
+	EVRInitError_VRInitError_Compositor_CreateTextVertexBuffer = 481,
+	EVRInitError_VRInitError_Compositor_CreateTextIndexBuffer = 482,
+	EVRInitError_VRInitError_Compositor_CreateMirrorTextures = 483,
+	EVRInitError_VRInitError_Compositor_CreateLastFrameRenderTexture = 484,
+	EVRInitError_VRInitError_Compositor_CreateMirrorOverlay = 485,
+	EVRInitError_VRInitError_Compositor_FailedToCreateVirtualDisplayBackbuffer = 486,
+	EVRInitError_VRInitError_Compositor_DisplayModeNotSupported = 487,
+	EVRInitError_VRInitError_Compositor_CreateOverlayInvalidCall = 488,
+	EVRInitError_VRInitError_Compositor_CreateOverlayAlreadyInitialized = 489,
+	EVRInitError_VRInitError_Compositor_FailedToCreateMailbox = 490,
+	EVRInitError_VRInitError_VendorSpecific_UnableToConnectToOculusRuntime = 1000,
+	EVRInitError_VRInitError_VendorSpecific_WindowsNotInDevMode = 1001,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_CantOpenDevice = 1101,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToRequestConfigStart = 1102,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_NoStoredConfig = 1103,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_ConfigTooBig = 1104,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_ConfigTooSmall = 1105,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToInitZLib = 1106,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_CantReadFirmwareVersion = 1107,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToSendUserDataStart = 1108,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataStart = 1109,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataNext = 1110,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UserDataAddressRange = 1111,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UserDataError = 1112,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_ConfigFailedSanityCheck = 1113,
+	EVRInitError_VRInitError_VendorSpecific_OculusRuntimeBadInstall = 1114,
+	EVRInitError_VRInitError_Steam_SteamInstallationNotFound = 2000,
+	EVRInitError_VRInitError_LastError = 2001,
+} EVRInitError;
+
+typedef enum EVRScreenshotType
+{
+	EVRScreenshotType_VRScreenshotType_None = 0,
+	EVRScreenshotType_VRScreenshotType_Mono = 1,
+	EVRScreenshotType_VRScreenshotType_Stereo = 2,
+	EVRScreenshotType_VRScreenshotType_Cubemap = 3,
+	EVRScreenshotType_VRScreenshotType_MonoPanorama = 4,
+	EVRScreenshotType_VRScreenshotType_StereoPanorama = 5,
+} EVRScreenshotType;
+
+typedef enum EVRScreenshotPropertyFilenames
+{
+	EVRScreenshotPropertyFilenames_VRScreenshotPropertyFilenames_Preview = 0,
+	EVRScreenshotPropertyFilenames_VRScreenshotPropertyFilenames_VR = 1,
+} EVRScreenshotPropertyFilenames;
+
+typedef enum EVRTrackedCameraError
+{
+	EVRTrackedCameraError_VRTrackedCameraError_None = 0,
+	EVRTrackedCameraError_VRTrackedCameraError_OperationFailed = 100,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidHandle = 101,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidFrameHeaderVersion = 102,
+	EVRTrackedCameraError_VRTrackedCameraError_OutOfHandles = 103,
+	EVRTrackedCameraError_VRTrackedCameraError_IPCFailure = 104,
+	EVRTrackedCameraError_VRTrackedCameraError_NotSupportedForThisDevice = 105,
+	EVRTrackedCameraError_VRTrackedCameraError_SharedMemoryFailure = 106,
+	EVRTrackedCameraError_VRTrackedCameraError_FrameBufferingFailure = 107,
+	EVRTrackedCameraError_VRTrackedCameraError_StreamSetupFailure = 108,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidGLTextureId = 109,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidSharedTextureHandle = 110,
+	EVRTrackedCameraError_VRTrackedCameraError_FailedToGetGLTextureId = 111,
+	EVRTrackedCameraError_VRTrackedCameraError_SharedTextureFailure = 112,
+	EVRTrackedCameraError_VRTrackedCameraError_NoFrameAvailable = 113,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidArgument = 114,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidFrameBufferSize = 115,
+} EVRTrackedCameraError;
+
+typedef enum EVRTrackedCameraFrameLayout
+{
+	EVRTrackedCameraFrameLayout_Mono = 1,
+	EVRTrackedCameraFrameLayout_Stereo = 2,
+	EVRTrackedCameraFrameLayout_VerticalLayout = 16,
+	EVRTrackedCameraFrameLayout_HorizontalLayout = 32,
+} EVRTrackedCameraFrameLayout;
+
+typedef enum EVRTrackedCameraFrameType
+{
+	EVRTrackedCameraFrameType_VRTrackedCameraFrameType_Distorted = 0,
+	EVRTrackedCameraFrameType_VRTrackedCameraFrameType_Undistorted = 1,
+	EVRTrackedCameraFrameType_VRTrackedCameraFrameType_MaximumUndistorted = 2,
+	EVRTrackedCameraFrameType_MAX_CAMERA_FRAME_TYPES = 3,
+} EVRTrackedCameraFrameType;
+
+typedef enum EVRDistortionFunctionType
+{
+	EVRDistortionFunctionType_VRDistortionFunctionType_None = 0,
+	EVRDistortionFunctionType_VRDistortionFunctionType_FTheta = 1,
+	EVRDistortionFunctionType_VRDistortionFunctionType_Extended_FTheta = 2,
+	EVRDistortionFunctionType_MAX_DISTORTION_FUNCTION_TYPES = 3,
+} EVRDistortionFunctionType;
+
+typedef enum EVSync
+{
+	EVSync_VSync_None = 0,
+	EVSync_VSync_WaitRender = 1,
+	EVSync_VSync_NoWaitRender = 2,
+} EVSync;
+
+typedef enum EVRMuraCorrectionMode
+{
+	EVRMuraCorrectionMode_Default = 0,
+	EVRMuraCorrectionMode_NoCorrection = 1,
+} EVRMuraCorrectionMode;
+
+typedef enum Imu_OffScaleFlags
+{
+	Imu_OffScaleFlags_OffScale_AccelX = 1,
+	Imu_OffScaleFlags_OffScale_AccelY = 2,
+	Imu_OffScaleFlags_OffScale_AccelZ = 4,
+	Imu_OffScaleFlags_OffScale_GyroX = 8,
+	Imu_OffScaleFlags_OffScale_GyroY = 16,
+	Imu_OffScaleFlags_OffScale_GyroZ = 32,
+} Imu_OffScaleFlags;
+
+typedef enum EVRApplicationError
+{
+	EVRApplicationError_VRApplicationError_None = 0,
+	EVRApplicationError_VRApplicationError_AppKeyAlreadyExists = 100,
+	EVRApplicationError_VRApplicationError_NoManifest = 101,
+	EVRApplicationError_VRApplicationError_NoApplication = 102,
+	EVRApplicationError_VRApplicationError_InvalidIndex = 103,
+	EVRApplicationError_VRApplicationError_UnknownApplication = 104,
+	EVRApplicationError_VRApplicationError_IPCFailed = 105,
+	EVRApplicationError_VRApplicationError_ApplicationAlreadyRunning = 106,
+	EVRApplicationError_VRApplicationError_InvalidManifest = 107,
+	EVRApplicationError_VRApplicationError_InvalidApplication = 108,
+	EVRApplicationError_VRApplicationError_LaunchFailed = 109,
+	EVRApplicationError_VRApplicationError_ApplicationAlreadyStarting = 110,
+	EVRApplicationError_VRApplicationError_LaunchInProgress = 111,
+	EVRApplicationError_VRApplicationError_OldApplicationQuitting = 112,
+	EVRApplicationError_VRApplicationError_TransitionAborted = 113,
+	EVRApplicationError_VRApplicationError_IsTemplate = 114,
+	EVRApplicationError_VRApplicationError_SteamVRIsExiting = 115,
+	EVRApplicationError_VRApplicationError_BufferTooSmall = 200,
+	EVRApplicationError_VRApplicationError_PropertyNotSet = 201,
+	EVRApplicationError_VRApplicationError_UnknownProperty = 202,
+	EVRApplicationError_VRApplicationError_InvalidParameter = 203,
+} EVRApplicationError;
+
+typedef enum EVRApplicationProperty
+{
+	EVRApplicationProperty_VRApplicationProperty_Name_String = 0,
+	EVRApplicationProperty_VRApplicationProperty_LaunchType_String = 11,
+	EVRApplicationProperty_VRApplicationProperty_WorkingDirectory_String = 12,
+	EVRApplicationProperty_VRApplicationProperty_BinaryPath_String = 13,
+	EVRApplicationProperty_VRApplicationProperty_Arguments_String = 14,
+	EVRApplicationProperty_VRApplicationProperty_URL_String = 15,
+	EVRApplicationProperty_VRApplicationProperty_Description_String = 50,
+	EVRApplicationProperty_VRApplicationProperty_NewsURL_String = 51,
+	EVRApplicationProperty_VRApplicationProperty_ImagePath_String = 52,
+	EVRApplicationProperty_VRApplicationProperty_Source_String = 53,
+	EVRApplicationProperty_VRApplicationProperty_ActionManifestURL_String = 54,
+	EVRApplicationProperty_VRApplicationProperty_IsDashboardOverlay_Bool = 60,
+	EVRApplicationProperty_VRApplicationProperty_IsTemplate_Bool = 61,
+	EVRApplicationProperty_VRApplicationProperty_IsInstanced_Bool = 62,
+	EVRApplicationProperty_VRApplicationProperty_IsInternal_Bool = 63,
+	EVRApplicationProperty_VRApplicationProperty_WantsCompositorPauseInStandby_Bool = 64,
+	EVRApplicationProperty_VRApplicationProperty_IsHidden_Bool = 65,
+	EVRApplicationProperty_VRApplicationProperty_LastLaunchTime_Uint64 = 70,
+} EVRApplicationProperty;
+
+typedef enum EVRSceneApplicationState
+{
+	EVRSceneApplicationState_None = 0,
+	EVRSceneApplicationState_Starting = 1,
+	EVRSceneApplicationState_Quitting = 2,
+	EVRSceneApplicationState_Running = 3,
+	EVRSceneApplicationState_Waiting = 4,
+} EVRSceneApplicationState;
+
+typedef enum ChaperoneCalibrationState
+{
+	ChaperoneCalibrationState_OK = 1,
+	ChaperoneCalibrationState_Warning = 100,
+	ChaperoneCalibrationState_Warning_BaseStationMayHaveMoved = 101,
+	ChaperoneCalibrationState_Warning_BaseStationRemoved = 102,
+	ChaperoneCalibrationState_Warning_SeatedBoundsInvalid = 103,
+	ChaperoneCalibrationState_Error = 200,
+	ChaperoneCalibrationState_Error_BaseStationUninitialized = 201,
+	ChaperoneCalibrationState_Error_BaseStationConflict = 202,
+	ChaperoneCalibrationState_Error_PlayAreaInvalid = 203,
+	ChaperoneCalibrationState_Error_CollisionBoundsInvalid = 204,
+} ChaperoneCalibrationState;
+
+typedef enum EChaperoneConfigFile
+{
+	EChaperoneConfigFile_Live = 1,
+	EChaperoneConfigFile_Temp = 2,
+} EChaperoneConfigFile;
+
+typedef enum EChaperoneImportFlags
+{
+	EChaperoneImportFlags_EChaperoneImport_BoundsOnly = 1,
+} EChaperoneImportFlags;
+
+typedef enum EVRCompositorError
+{
+	EVRCompositorError_VRCompositorError_None = 0,
+	EVRCompositorError_VRCompositorError_RequestFailed = 1,
+	EVRCompositorError_VRCompositorError_IncompatibleVersion = 100,
+	EVRCompositorError_VRCompositorError_DoNotHaveFocus = 101,
+	EVRCompositorError_VRCompositorError_InvalidTexture = 102,
+	EVRCompositorError_VRCompositorError_IsNotSceneApplication = 103,
+	EVRCompositorError_VRCompositorError_TextureIsOnWrongDevice = 104,
+	EVRCompositorError_VRCompositorError_TextureUsesUnsupportedFormat = 105,
+	EVRCompositorError_VRCompositorError_SharedTexturesNotSupported = 106,
+	EVRCompositorError_VRCompositorError_IndexOutOfRange = 107,
+	EVRCompositorError_VRCompositorError_AlreadySubmitted = 108,
+	EVRCompositorError_VRCompositorError_InvalidBounds = 109,
+	EVRCompositorError_VRCompositorError_AlreadySet = 110,
+} EVRCompositorError;
+
+typedef enum EVRCompositorTimingMode
+{
+	EVRCompositorTimingMode_VRCompositorTimingMode_Implicit = 0,
+	EVRCompositorTimingMode_VRCompositorTimingMode_Explicit_RuntimePerformsPostPresentHandoff = 1,
+	EVRCompositorTimingMode_VRCompositorTimingMode_Explicit_ApplicationPerformsPostPresentHandoff = 2,
+} EVRCompositorTimingMode;
+
+typedef enum VROverlayInputMethod
+{
+	VROverlayInputMethod_None = 0,
+	VROverlayInputMethod_Mouse = 1,
+} VROverlayInputMethod;
+
+typedef enum VROverlayTransformType
+{
+	VROverlayTransformType_VROverlayTransform_Invalid = -1,
+	VROverlayTransformType_VROverlayTransform_Absolute = 0,
+	VROverlayTransformType_VROverlayTransform_TrackedDeviceRelative = 1,
+	VROverlayTransformType_VROverlayTransform_SystemOverlay = 2,
+	VROverlayTransformType_VROverlayTransform_TrackedComponent = 3,
+	VROverlayTransformType_VROverlayTransform_Cursor = 4,
+	VROverlayTransformType_VROverlayTransform_DashboardTab = 5,
+	VROverlayTransformType_VROverlayTransform_DashboardThumb = 6,
+	VROverlayTransformType_VROverlayTransform_Mountable = 7,
+} VROverlayTransformType;
+
+typedef enum VROverlayFlags
+{
+	VROverlayFlags_NoDashboardTab = 8,
+	VROverlayFlags_SendVRDiscreteScrollEvents = 64,
+	VROverlayFlags_SendVRTouchpadEvents = 128,
+	VROverlayFlags_ShowTouchPadScrollWheel = 256,
+	VROverlayFlags_TransferOwnershipToInternalProcess = 512,
+	VROverlayFlags_SideBySide_Parallel = 1024,
+	VROverlayFlags_SideBySide_Crossed = 2048,
+	VROverlayFlags_Panorama = 4096,
+	VROverlayFlags_StereoPanorama = 8192,
+	VROverlayFlags_SortWithNonSceneOverlays = 16384,
+	VROverlayFlags_VisibleInDashboard = 32768,
+	VROverlayFlags_MakeOverlaysInteractiveIfVisible = 65536,
+	VROverlayFlags_SendVRSmoothScrollEvents = 131072,
+	VROverlayFlags_ProtectedContent = 262144,
+	VROverlayFlags_HideLaserIntersection = 524288,
+	VROverlayFlags_WantsModalBehavior = 1048576,
+	VROverlayFlags_IsPremultiplied = 2097152,
+} VROverlayFlags;
+
+typedef enum VRMessageOverlayResponse
+{
+	VRMessageOverlayResponse_ButtonPress_0 = 0,
+	VRMessageOverlayResponse_ButtonPress_1 = 1,
+	VRMessageOverlayResponse_ButtonPress_2 = 2,
+	VRMessageOverlayResponse_ButtonPress_3 = 3,
+	VRMessageOverlayResponse_CouldntFindSystemOverlay = 4,
+	VRMessageOverlayResponse_CouldntFindOrCreateClientOverlay = 5,
+	VRMessageOverlayResponse_ApplicationQuit = 6,
+} VRMessageOverlayResponse;
+
+typedef enum EGamepadTextInputMode
+{
+	EGamepadTextInputMode_k_EGamepadTextInputModeNormal = 0,
+	EGamepadTextInputMode_k_EGamepadTextInputModePassword = 1,
+	EGamepadTextInputMode_k_EGamepadTextInputModeSubmit = 2,
+} EGamepadTextInputMode;
+
+typedef enum EGamepadTextInputLineMode
+{
+	EGamepadTextInputLineMode_k_EGamepadTextInputLineModeSingleLine = 0,
+	EGamepadTextInputLineMode_k_EGamepadTextInputLineModeMultipleLines = 1,
+} EGamepadTextInputLineMode;
+
+typedef enum EVROverlayIntersectionMaskPrimitiveType
+{
+	EVROverlayIntersectionMaskPrimitiveType_OverlayIntersectionPrimitiveType_Rectangle = 0,
+	EVROverlayIntersectionMaskPrimitiveType_OverlayIntersectionPrimitiveType_Circle = 1,
+} EVROverlayIntersectionMaskPrimitiveType;
+
+typedef enum EKeyboardFlags
+{
+	EKeyboardFlags_KeyboardFlag_Minimal = 1,
+	EKeyboardFlags_KeyboardFlag_Modal = 2,
+} EKeyboardFlags;
+
+typedef enum EDeviceType
+{
+	EDeviceType_DeviceType_Invalid = -1,
+	EDeviceType_DeviceType_DirectX11 = 0,
+	EDeviceType_DeviceType_Vulkan = 1,
+} EDeviceType;
+
+typedef enum HeadsetViewMode_t
+{
+	HeadsetViewMode_t_HeadsetViewMode_Left = 0,
+	HeadsetViewMode_t_HeadsetViewMode_Right = 1,
+	HeadsetViewMode_t_HeadsetViewMode_Both = 2,
+} HeadsetViewMode_t;
+
+typedef enum EVRRenderModelError
+{
+	EVRRenderModelError_VRRenderModelError_None = 0,
+	EVRRenderModelError_VRRenderModelError_Loading = 100,
+	EVRRenderModelError_VRRenderModelError_NotSupported = 200,
+	EVRRenderModelError_VRRenderModelError_InvalidArg = 300,
+	EVRRenderModelError_VRRenderModelError_InvalidModel = 301,
+	EVRRenderModelError_VRRenderModelError_NoShapes = 302,
+	EVRRenderModelError_VRRenderModelError_MultipleShapes = 303,
+	EVRRenderModelError_VRRenderModelError_TooManyVertices = 304,
+	EVRRenderModelError_VRRenderModelError_MultipleTextures = 305,
+	EVRRenderModelError_VRRenderModelError_BufferTooSmall = 306,
+	EVRRenderModelError_VRRenderModelError_NotEnoughNormals = 307,
+	EVRRenderModelError_VRRenderModelError_NotEnoughTexCoords = 308,
+	EVRRenderModelError_VRRenderModelError_InvalidTexture = 400,
+} EVRRenderModelError;
+
+typedef enum EVRRenderModelTextureFormat
+{
+	EVRRenderModelTextureFormat_VRRenderModelTextureFormat_RGBA8_SRGB = 0,
+	EVRRenderModelTextureFormat_VRRenderModelTextureFormat_BC2 = 1,
+	EVRRenderModelTextureFormat_VRRenderModelTextureFormat_BC4 = 2,
+	EVRRenderModelTextureFormat_VRRenderModelTextureFormat_BC7 = 3,
+	EVRRenderModelTextureFormat_VRRenderModelTextureFormat_BC7_SRGB = 4,
+} EVRRenderModelTextureFormat;
+
+typedef enum EVRNotificationType
+{
+	EVRNotificationType_Transient = 0,
+	EVRNotificationType_Persistent = 1,
+	EVRNotificationType_Transient_SystemWithUserValue = 2,
+} EVRNotificationType;
+
+typedef enum EVRNotificationStyle
+{
+	EVRNotificationStyle_None = 0,
+	EVRNotificationStyle_Application = 100,
+	EVRNotificationStyle_Contact_Disabled = 200,
+	EVRNotificationStyle_Contact_Enabled = 201,
+	EVRNotificationStyle_Contact_Active = 202,
+} EVRNotificationStyle;
+
+typedef enum EVRSettingsError
+{
+	EVRSettingsError_VRSettingsError_None = 0,
+	EVRSettingsError_VRSettingsError_IPCFailed = 1,
+	EVRSettingsError_VRSettingsError_WriteFailed = 2,
+	EVRSettingsError_VRSettingsError_ReadFailed = 3,
+	EVRSettingsError_VRSettingsError_JsonParseFailed = 4,
+	EVRSettingsError_VRSettingsError_UnsetSettingHasNoDefault = 5,
+} EVRSettingsError;
+
+typedef enum EVRScreenshotError
+{
+	EVRScreenshotError_VRScreenshotError_None = 0,
+	EVRScreenshotError_VRScreenshotError_RequestFailed = 1,
+	EVRScreenshotError_VRScreenshotError_IncompatibleVersion = 100,
+	EVRScreenshotError_VRScreenshotError_NotFound = 101,
+	EVRScreenshotError_VRScreenshotError_BufferTooSmall = 102,
+	EVRScreenshotError_VRScreenshotError_ScreenshotAlreadyInProgress = 108,
+} EVRScreenshotError;
+
+typedef enum EVRSkeletalTransformSpace
+{
+	EVRSkeletalTransformSpace_VRSkeletalTransformSpace_Model = 0,
+	EVRSkeletalTransformSpace_VRSkeletalTransformSpace_Parent = 1,
+} EVRSkeletalTransformSpace;
+
+typedef enum EVRSkeletalReferencePose
+{
+	EVRSkeletalReferencePose_VRSkeletalReferencePose_BindPose = 0,
+	EVRSkeletalReferencePose_VRSkeletalReferencePose_OpenHand = 1,
+	EVRSkeletalReferencePose_VRSkeletalReferencePose_Fist = 2,
+	EVRSkeletalReferencePose_VRSkeletalReferencePose_GripLimit = 3,
+} EVRSkeletalReferencePose;
+
+typedef enum EVRFinger
+{
+	EVRFinger_VRFinger_Thumb = 0,
+	EVRFinger_VRFinger_Index = 1,
+	EVRFinger_VRFinger_Middle = 2,
+	EVRFinger_VRFinger_Ring = 3,
+	EVRFinger_VRFinger_Pinky = 4,
+	EVRFinger_VRFinger_Count = 5,
+} EVRFinger;
+
+typedef enum EVRFingerSplay
+{
+	EVRFingerSplay_VRFingerSplay_Thumb_Index = 0,
+	EVRFingerSplay_VRFingerSplay_Index_Middle = 1,
+	EVRFingerSplay_VRFingerSplay_Middle_Ring = 2,
+	EVRFingerSplay_VRFingerSplay_Ring_Pinky = 3,
+	EVRFingerSplay_VRFingerSplay_Count = 4,
+} EVRFingerSplay;
+
+typedef enum EVRSummaryType
+{
+	EVRSummaryType_VRSummaryType_FromAnimation = 0,
+	EVRSummaryType_VRSummaryType_FromDevice = 1,
+} EVRSummaryType;
+
+typedef enum EVRInputFilterCancelType
+{
+	EVRInputFilterCancelType_VRInputFilterCancel_Timers = 0,
+	EVRInputFilterCancelType_VRInputFilterCancel_Momentum = 1,
+} EVRInputFilterCancelType;
+
+typedef enum EVRInputStringBits
+{
+	EVRInputStringBits_VRInputString_Hand = 1,
+	EVRInputStringBits_VRInputString_ControllerType = 2,
+	EVRInputStringBits_VRInputString_InputSource = 4,
+	EVRInputStringBits_VRInputString_All = -1,
+} EVRInputStringBits;
+
+typedef enum EIOBufferError
+{
+	EIOBufferError_IOBuffer_Success = 0,
+	EIOBufferError_IOBuffer_OperationFailed = 100,
+	EIOBufferError_IOBuffer_InvalidHandle = 101,
+	EIOBufferError_IOBuffer_InvalidArgument = 102,
+	EIOBufferError_IOBuffer_PathExists = 103,
+	EIOBufferError_IOBuffer_PathDoesNotExist = 104,
+	EIOBufferError_IOBuffer_Permission = 105,
+} EIOBufferError;
+
+typedef enum EIOBufferMode
+{
+	EIOBufferMode_IOBufferMode_Read = 1,
+	EIOBufferMode_IOBufferMode_Write = 2,
+	EIOBufferMode_IOBufferMode_Create = 512,
+} EIOBufferMode;
+
+typedef enum EVRDebugError
+{
+	EVRDebugError_VRDebugError_Success = 0,
+	EVRDebugError_VRDebugError_BadParameter = 1,
+} EVRDebugError;
+
+
+// OpenVR typedefs
+
+typedef uint32_t TrackedDeviceIndex_t;
+typedef uint32_t VRNotificationId;
+typedef uint64_t VROverlayHandle_t;
+
+typedef uint32_t SpatialAnchorHandle_t;
+typedef void * glSharedTextureHandle_t;
+typedef int32_t glInt_t;
+typedef uint32_t glUInt_t;
+typedef uint64_t SharedTextureHandle_t;
+typedef uint32_t DriverId_t;
+typedef uint32_t TrackedDeviceIndex_t;
+typedef uint64_t WebConsoleHandle_t;
+typedef uint64_t PropertyContainerHandle_t;
+typedef uint32_t PropertyTypeTag_t;
+typedef PropertyContainerHandle_t DriverHandle_t;
+typedef uint64_t VRActionHandle_t;
+typedef uint64_t VRActionSetHandle_t;
+typedef uint64_t VRInputValueHandle_t;
+typedef uint32_t VRComponentProperties;
+typedef uint64_t VROverlayHandle_t;
+typedef int32_t BoneIndex_t;
+typedef uint64_t TrackedCameraHandle_t;
+typedef uint32_t ScreenshotHandle_t;
+typedef int32_t TextureID_t;
+typedef uint32_t VRNotificationId;
+typedef uint64_t IOBufferHandle_t;
+typedef uint64_t VrProfilerEventHandle_t;
+typedef EVRInitError HmdError;
+typedef EVREye Hmd_Eye;
+typedef EColorSpace ColorSpace;
+typedef ETrackingResult HmdTrackingResult;
+typedef ETrackedDeviceClass TrackedDeviceClass;
+typedef ETrackingUniverseOrigin TrackingUniverseOrigin;
+typedef ETrackedDeviceProperty TrackedDeviceProperty;
+typedef ETrackedPropertyError TrackedPropertyError;
+typedef EVRSubmitFlags VRSubmitFlags_t;
+typedef EVRState VRState_t;
+typedef ECollisionBoundsStyle CollisionBoundsStyle_t;
+typedef EVROverlayError VROverlayError;
+typedef EVRFirmwareError VRFirmwareError;
+typedef EVRCompositorError VRCompositorError;
+typedef EVRScreenshotError VRScreenshotsError;
+
+// OpenVR Structs
+
+typedef struct HmdMatrix34_t
+{
+	float m[3][4]; //float[3][4]
+} HmdMatrix34_t;
+
+typedef struct HmdMatrix33_t
+{
+	float m[3][3]; //float[3][3]
+} HmdMatrix33_t;
+
+typedef struct HmdMatrix44_t
+{
+	float m[4][4]; //float[4][4]
+} HmdMatrix44_t;
+
+typedef struct HmdVector3_t
+{
+	float v[3]; //float[3]
+} HmdVector3_t;
+
+typedef struct HmdVector4_t
+{
+	float v[4]; //float[4]
+} HmdVector4_t;
+
+typedef struct HmdVector3d_t
+{
+	double v[3]; //double[3]
+} HmdVector3d_t;
+
+typedef struct HmdVector2_t
+{
+	float v[2]; //float[2]
+} HmdVector2_t;
+
+typedef struct HmdQuaternion_t
+{
+	double w;
+	double x;
+	double y;
+	double z;
+} HmdQuaternion_t;
+
+typedef struct HmdQuaternionf_t
+{
+	float w;
+	float x;
+	float y;
+	float z;
+} HmdQuaternionf_t;
+
+typedef struct HmdColor_t
+{
+	float r;
+	float g;
+	float b;
+	float a;
+} HmdColor_t;
+
+typedef struct HmdQuad_t
+{
+	struct HmdVector3_t vCorners[4]; //struct vr::HmdVector3_t[4]
+} HmdQuad_t;
+
+typedef struct HmdRect2_t
+{
+	struct HmdVector2_t vTopLeft;
+	struct HmdVector2_t vBottomRight;
+} HmdRect2_t;
+
+typedef struct DistortionCoordinates_t
+{
+	float rfRed[2]; //float[2]
+	float rfGreen[2]; //float[2]
+	float rfBlue[2]; //float[2]
+} DistortionCoordinates_t;
+
+typedef struct Texture_t
+{
+	void * handle; // void *
+	enum ETextureType eType;
+	enum EColorSpace eColorSpace;
+} Texture_t;
+
+typedef struct TrackedDevicePose_t
+{
+	struct HmdMatrix34_t mDeviceToAbsoluteTracking;
+	struct HmdVector3_t vVelocity;
+	struct HmdVector3_t vAngularVelocity;
+	enum ETrackingResult eTrackingResult;
+	bool bPoseIsValid;
+	bool bDeviceIsConnected;
+} TrackedDevicePose_t;
+
+typedef struct VRTextureBounds_t
+{
+	float uMin;
+	float vMin;
+	float uMax;
+	float vMax;
+} VRTextureBounds_t;
+
+typedef struct VRTextureWithPose_t
+{
+	struct HmdMatrix34_t mDeviceToAbsoluteTracking;
+} VRTextureWithPose_t;
+
+typedef struct VRTextureDepthInfo_t
+{
+	void * handle; // void *
+	struct HmdMatrix44_t mProjection;
+	struct HmdVector2_t vRange;
+} VRTextureDepthInfo_t;
+
+typedef struct VRTextureWithDepth_t
+{
+	struct VRTextureDepthInfo_t depth;
+} VRTextureWithDepth_t;
+
+typedef struct VRTextureWithPoseAndDepth_t
+{
+	struct VRTextureDepthInfo_t depth;
+} VRTextureWithPoseAndDepth_t;
+
+typedef struct VRVulkanTextureData_t
+{
+	uint64_t m_nImage;
+	struct VkDevice_T * m_pDevice; // struct VkDevice_T *
+	struct VkPhysicalDevice_T * m_pPhysicalDevice; // struct VkPhysicalDevice_T *
+	struct VkInstance_T * m_pInstance; // struct VkInstance_T *
+	struct VkQueue_T * m_pQueue; // struct VkQueue_T *
+	uint32_t m_nQueueFamilyIndex;
+	uint32_t m_nWidth;
+	uint32_t m_nHeight;
+	uint32_t m_nFormat;
+	uint32_t m_nSampleCount;
+} VRVulkanTextureData_t;
+
+typedef struct D3D12TextureData_t
+{
+	struct ID3D12Resource * m_pResource; // struct ID3D12Resource *
+	struct ID3D12CommandQueue * m_pCommandQueue; // struct ID3D12CommandQueue *
+	uint32_t m_nNodeMask;
+} D3D12TextureData_t;
+
+typedef struct VREvent_Controller_t
+{
+	uint32_t button;
+} VREvent_Controller_t;
+
+typedef struct VREvent_Mouse_t
+{
+	float x;
+	float y;
+	uint32_t button;
+} VREvent_Mouse_t;
+
+typedef struct VREvent_Scroll_t
+{
+	float xdelta;
+	float ydelta;
+	uint32_t unused;
+	float viewportscale;
+} VREvent_Scroll_t;
+
+typedef struct VREvent_TouchPadMove_t
+{
+	bool bFingerDown;
+	float flSecondsFingerDown;
+	float fValueXFirst;
+	float fValueYFirst;
+	float fValueXRaw;
+	float fValueYRaw;
+} VREvent_TouchPadMove_t;
+
+typedef struct VREvent_Notification_t
+{
+	uint64_t ulUserValue;
+	uint32_t notificationId;
+} VREvent_Notification_t;
+
+typedef struct VREvent_Process_t
+{
+	uint32_t pid;
+	uint32_t oldPid;
+	bool bForced;
+	bool bConnectionLost;
+} VREvent_Process_t;
+
+typedef struct VREvent_Overlay_t
+{
+	uint64_t overlayHandle;
+	uint64_t devicePath;
+} VREvent_Overlay_t;
+
+typedef struct VREvent_Status_t
+{
+	uint32_t statusState;
+} VREvent_Status_t;
+
+typedef struct VREvent_Keyboard_t
+{
+	char cNewInput[8]; //char[8]
+	uint64_t uUserValue;
+} VREvent_Keyboard_t;
+
+typedef struct VREvent_Ipd_t
+{
+	float ipdMeters;
+} VREvent_Ipd_t;
+
+typedef struct VREvent_Chaperone_t
+{
+	uint64_t m_nPreviousUniverse;
+	uint64_t m_nCurrentUniverse;
+} VREvent_Chaperone_t;
+
+typedef struct VREvent_Reserved_t
+{
+	uint64_t reserved0;
+	uint64_t reserved1;
+	uint64_t reserved2;
+	uint64_t reserved3;
+	uint64_t reserved4;
+	uint64_t reserved5;
+} VREvent_Reserved_t;
+
+typedef struct VREvent_PerformanceTest_t
+{
+	uint32_t m_nFidelityLevel;
+} VREvent_PerformanceTest_t;
+
+typedef struct VREvent_SeatedZeroPoseReset_t
+{
+	bool bResetBySystemMenu;
+} VREvent_SeatedZeroPoseReset_t;
+
+typedef struct VREvent_Screenshot_t
+{
+	uint32_t handle;
+	uint32_t type;
+} VREvent_Screenshot_t;
+
+typedef struct VREvent_ScreenshotProgress_t
+{
+	float progress;
+} VREvent_ScreenshotProgress_t;
+
+typedef struct VREvent_ApplicationLaunch_t
+{
+	uint32_t pid;
+	uint32_t unArgsHandle;
+} VREvent_ApplicationLaunch_t;
+
+typedef struct VREvent_EditingCameraSurface_t
+{
+	uint64_t overlayHandle;
+	uint32_t nVisualMode;
+} VREvent_EditingCameraSurface_t;
+
+typedef struct VREvent_MessageOverlay_t
+{
+	uint32_t unVRMessageOverlayResponse;
+} VREvent_MessageOverlay_t;
+
+typedef struct VREvent_Property_t
+{
+	PropertyContainerHandle_t container;
+	enum ETrackedDeviceProperty prop;
+} VREvent_Property_t;
+
+typedef struct VREvent_HapticVibration_t
+{
+	uint64_t containerHandle;
+	uint64_t componentHandle;
+	float fDurationSeconds;
+	float fFrequency;
+	float fAmplitude;
+} VREvent_HapticVibration_t;
+
+typedef struct VREvent_WebConsole_t
+{
+	WebConsoleHandle_t webConsoleHandle;
+} VREvent_WebConsole_t;
+
+typedef struct VREvent_InputBindingLoad_t
+{
+	PropertyContainerHandle_t ulAppContainer;
+	uint64_t pathMessage;
+	uint64_t pathUrl;
+	uint64_t pathControllerType;
+} VREvent_InputBindingLoad_t;
+
+typedef struct VREvent_InputActionManifestLoad_t
+{
+	uint64_t pathAppKey;
+	uint64_t pathMessage;
+	uint64_t pathMessageParam;
+	uint64_t pathManifestPath;
+} VREvent_InputActionManifestLoad_t;
+
+typedef struct VREvent_SpatialAnchor_t
+{
+	SpatialAnchorHandle_t unHandle;
+} VREvent_SpatialAnchor_t;
+
+typedef struct VREvent_ProgressUpdate_t
+{
+	uint64_t ulApplicationPropertyContainer;
+	uint64_t pathDevice;
+	uint64_t pathInputSource;
+	uint64_t pathProgressAction;
+	uint64_t pathIcon;
+	float fProgress;
+} VREvent_ProgressUpdate_t;
+
+typedef struct VREvent_ShowUI_t
+{
+	enum EShowUIType eType;
+} VREvent_ShowUI_t;
+
+typedef struct VREvent_ShowDevTools_t
+{
+	int32_t nBrowserIdentifier;
+} VREvent_ShowDevTools_t;
+
+typedef struct VREvent_HDCPError_t
+{
+	enum EHDCPError eCode;
+} VREvent_HDCPError_t;
+
+typedef struct RenderModel_ComponentState_t
+{
+	struct HmdMatrix34_t mTrackingToComponentRenderModel;
+	struct HmdMatrix34_t mTrackingToComponentLocal;
+	VRComponentProperties uProperties;
+} RenderModel_ComponentState_t;
+
+typedef struct HiddenAreaMesh_t
+{
+	struct HmdVector2_t * pVertexData; // const struct vr::HmdVector2_t *
+	uint32_t unTriangleCount;
+} HiddenAreaMesh_t;
+
+typedef struct VRControllerAxis_t
+{
+	float x;
+	float y;
+} VRControllerAxis_t;
+
+typedef struct VRControllerState_t
+{
+	uint32_t unPacketNum;
+	uint64_t ulButtonPressed;
+	uint64_t ulButtonTouched;
+	struct VRControllerAxis_t rAxis[5]; //struct vr::VRControllerAxis_t[5]
+} VRControllerState_t;
+
+typedef struct VRBoneTransform_t
+{
+	struct HmdVector4_t position;
+	struct HmdQuaternionf_t orientation;
+} VRBoneTransform_t;
+
+typedef struct CameraVideoStreamFrameHeader_t
+{
+	enum EVRTrackedCameraFrameType eFrameType;
+	uint32_t nWidth;
+	uint32_t nHeight;
+	uint32_t nBytesPerPixel;
+	uint32_t nFrameSequence;
+	struct TrackedDevicePose_t trackedDevicePose;
+	uint64_t ulFrameExposureTime;
+} CameraVideoStreamFrameHeader_t;
+
+typedef struct Compositor_FrameTiming
+{
+	uint32_t m_nSize;
+	uint32_t m_nFrameIndex;
+	uint32_t m_nNumFramePresents;
+	uint32_t m_nNumMisPresented;
+	uint32_t m_nNumDroppedFrames;
+	uint32_t m_nReprojectionFlags;
+	double m_flSystemTimeInSeconds;
+	float m_flPreSubmitGpuMs;
+	float m_flPostSubmitGpuMs;
+	float m_flTotalRenderGpuMs;
+	float m_flCompositorRenderGpuMs;
+	float m_flCompositorRenderCpuMs;
+	float m_flCompositorIdleCpuMs;
+	float m_flClientFrameIntervalMs;
+	float m_flPresentCallCpuMs;
+	float m_flWaitForPresentCpuMs;
+	float m_flSubmitFrameMs;
+	float m_flWaitGetPosesCalledMs;
+	float m_flNewPosesReadyMs;
+	float m_flNewFrameReadyMs;
+	float m_flCompositorUpdateStartMs;
+	float m_flCompositorUpdateEndMs;
+	float m_flCompositorRenderStartMs;
+	TrackedDevicePose_t m_HmdPose;
+	uint32_t m_nNumVSyncsReadyForUse;
+	uint32_t m_nNumVSyncsToFirstView;
+} Compositor_FrameTiming;
+
+typedef struct Compositor_BenchmarkResults
+{
+	float m_flMegaPixelsPerSecond;
+	float m_flHmdRecommendedMegaPixelsPerSecond;
+} Compositor_BenchmarkResults;
+
+typedef struct DriverDirectMode_FrameTiming
+{
+	uint32_t m_nSize;
+	uint32_t m_nNumFramePresents;
+	uint32_t m_nNumMisPresented;
+	uint32_t m_nNumDroppedFrames;
+	uint32_t m_nReprojectionFlags;
+} DriverDirectMode_FrameTiming;
+
+typedef struct ImuSample_t
+{
+	double fSampleTime;
+	struct HmdVector3d_t vAccel;
+	struct HmdVector3d_t vGyro;
+	uint32_t unOffScaleFlags;
+} ImuSample_t;
+
+typedef struct AppOverrideKeys_t
+{
+	char * pchKey; // const char *
+	char * pchValue; // const char *
+} AppOverrideKeys_t;
+
+typedef struct Compositor_CumulativeStats
+{
+	uint32_t m_nPid;
+	uint32_t m_nNumFramePresents;
+	uint32_t m_nNumDroppedFrames;
+	uint32_t m_nNumReprojectedFrames;
+	uint32_t m_nNumFramePresentsOnStartup;
+	uint32_t m_nNumDroppedFramesOnStartup;
+	uint32_t m_nNumReprojectedFramesOnStartup;
+	uint32_t m_nNumLoading;
+	uint32_t m_nNumFramePresentsLoading;
+	uint32_t m_nNumDroppedFramesLoading;
+	uint32_t m_nNumReprojectedFramesLoading;
+	uint32_t m_nNumTimedOut;
+	uint32_t m_nNumFramePresentsTimedOut;
+	uint32_t m_nNumDroppedFramesTimedOut;
+	uint32_t m_nNumReprojectedFramesTimedOut;
+} Compositor_CumulativeStats;
+
+typedef struct Compositor_StageRenderSettings
+{
+	struct HmdColor_t m_PrimaryColor;
+	struct HmdColor_t m_SecondaryColor;
+	float m_flVignetteInnerRadius;
+	float m_flVignetteOuterRadius;
+	float m_flFresnelStrength;
+	bool m_bBackfaceCulling;
+	bool m_bGreyscale;
+	bool m_bWireframe;
+} Compositor_StageRenderSettings;
+
+typedef struct VROverlayIntersectionParams_t
+{
+	struct HmdVector3_t vSource;
+	struct HmdVector3_t vDirection;
+	enum ETrackingUniverseOrigin eOrigin;
+} VROverlayIntersectionParams_t;
+
+typedef struct VROverlayIntersectionResults_t
+{
+	struct HmdVector3_t vPoint;
+	struct HmdVector3_t vNormal;
+	struct HmdVector2_t vUVs;
+	float fDistance;
+} VROverlayIntersectionResults_t;
+
+typedef struct IntersectionMaskRectangle_t
+{
+	float m_flTopLeftX;
+	float m_flTopLeftY;
+	float m_flWidth;
+	float m_flHeight;
+} IntersectionMaskRectangle_t;
+
+typedef struct IntersectionMaskCircle_t
+{
+	float m_flCenterX;
+	float m_flCenterY;
+	float m_flRadius;
+} IntersectionMaskCircle_t;
+
+typedef struct VROverlayView_t
+{
+	VROverlayHandle_t overlayHandle;
+	struct Texture_t texture;
+	struct VRTextureBounds_t textureBounds;
+} VROverlayView_t;
+
+typedef struct VRVulkanDevice_t
+{
+	struct VkInstance_T * m_pInstance; // struct VkInstance_T *
+	struct VkDevice_T * m_pDevice; // struct VkDevice_T *
+	struct VkPhysicalDevice_T * m_pPhysicalDevice; // struct VkPhysicalDevice_T *
+	struct VkQueue_T * m_pQueue; // struct VkQueue_T *
+	uint32_t m_uQueueFamilyIndex;
+} VRVulkanDevice_t;
+
+typedef struct VRNativeDevice_t
+{
+	void * handle; // void *
+	enum EDeviceType eType;
+} VRNativeDevice_t;
+
+typedef struct RenderModel_Vertex_t
+{
+	struct HmdVector3_t vPosition;
+	struct HmdVector3_t vNormal;
+	float rfTextureCoord[2]; //float[2]
+} RenderModel_Vertex_t;
+
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack( push, 4 )
+#endif
+typedef struct RenderModel_TextureMap_t
+{
+	uint16_t unWidth;
+	uint16_t unHeight;
+	uint8_t * rubTextureMapData; // const uint8_t *
+	enum EVRRenderModelTextureFormat format;
+} RenderModel_TextureMap_t;
+
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack( pop )
+#endif
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack( push, 4 )
+#endif
+typedef struct RenderModel_t
+{
+	struct RenderModel_Vertex_t * rVertexData; // const struct vr::RenderModel_Vertex_t *
+	uint32_t unVertexCount;
+	uint16_t * rIndexData; // const uint16_t *
+	uint32_t unTriangleCount;
+	TextureID_t diffuseTextureId;
+} RenderModel_t;
+
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack( pop )
+#endif
+typedef struct RenderModel_ControllerMode_State_t
+{
+	bool bScrollWheelVisible;
+} RenderModel_ControllerMode_State_t;
+
+typedef struct NotificationBitmap_t
+{
+	void * m_pImageData; // void *
+	int32_t m_nWidth;
+	int32_t m_nHeight;
+	int32_t m_nBytesPerPixel;
+} NotificationBitmap_t;
+
+typedef struct CVRSettingHelper
+{
+	intptr_t m_pSettings; // class vr::IVRSettings *
+} CVRSettingHelper;
+
+typedef struct InputAnalogActionData_t
+{
+	bool bActive;
+	VRInputValueHandle_t activeOrigin;
+	float x;
+	float y;
+	float z;
+	float deltaX;
+	float deltaY;
+	float deltaZ;
+	float fUpdateTime;
+} InputAnalogActionData_t;
+
+typedef struct InputDigitalActionData_t
+{
+	bool bActive;
+	VRInputValueHandle_t activeOrigin;
+	bool bState;
+	bool bChanged;
+	float fUpdateTime;
+} InputDigitalActionData_t;
+
+typedef struct InputPoseActionData_t
+{
+	bool bActive;
+	VRInputValueHandle_t activeOrigin;
+	struct TrackedDevicePose_t pose;
+} InputPoseActionData_t;
+
+typedef struct InputSkeletalActionData_t
+{
+	bool bActive;
+	VRInputValueHandle_t activeOrigin;
+} InputSkeletalActionData_t;
+
+typedef struct InputOriginInfo_t
+{
+	VRInputValueHandle_t devicePath;
+	TrackedDeviceIndex_t trackedDeviceIndex;
+	char rchRenderModelComponentName[128]; //char[128]
+} InputOriginInfo_t;
+
+typedef struct InputBindingInfo_t
+{
+	char rchDevicePathName[128]; //char[128]
+	char rchInputPathName[128]; //char[128]
+	char rchModeName[128]; //char[128]
+	char rchSlotName[128]; //char[128]
+	char rchInputSourceType[32]; //char[32]
+} InputBindingInfo_t;
+
+typedef struct VRActiveActionSet_t
+{
+	VRActionSetHandle_t ulActionSet;
+	VRInputValueHandle_t ulRestrictedToDevice;
+	VRActionSetHandle_t ulSecondaryActionSet;
+	uint32_t unPadding;
+	int32_t nPriority;
+} VRActiveActionSet_t;
+
+typedef struct VRSkeletalSummaryData_t
+{
+	float flFingerCurl[5]; //float[5]
+	float flFingerSplay[4]; //float[4]
+} VRSkeletalSummaryData_t;
+
+typedef struct SpatialAnchorPose_t
+{
+	struct HmdMatrix34_t mAnchorToAbsoluteTracking;
+} SpatialAnchorPose_t;
+
+typedef struct COpenVRContext
+{
+	intptr_t m_pVRSystem; // class vr::IVRSystem *
+	intptr_t m_pVRChaperone; // class vr::IVRChaperone *
+	intptr_t m_pVRChaperoneSetup; // class vr::IVRChaperoneSetup *
+	intptr_t m_pVRCompositor; // class vr::IVRCompositor *
+	intptr_t m_pVRHeadsetView; // class vr::IVRHeadsetView *
+	intptr_t m_pVROverlay; // class vr::IVROverlay *
+	intptr_t m_pVROverlayView; // class vr::IVROverlayView *
+	intptr_t m_pVRResources; // class vr::IVRResources *
+	intptr_t m_pVRRenderModels; // class vr::IVRRenderModels *
+	intptr_t m_pVRExtendedDisplay; // class vr::IVRExtendedDisplay *
+	intptr_t m_pVRSettings; // class vr::IVRSettings *
+	intptr_t m_pVRApplications; // class vr::IVRApplications *
+	intptr_t m_pVRTrackedCamera; // class vr::IVRTrackedCamera *
+	intptr_t m_pVRScreenshots; // class vr::IVRScreenshots *
+	intptr_t m_pVRDriverManager; // class vr::IVRDriverManager *
+	intptr_t m_pVRInput; // class vr::IVRInput *
+	intptr_t m_pVRIOBuffer; // class vr::IVRIOBuffer *
+	intptr_t m_pVRSpatialAnchors; // class vr::IVRSpatialAnchors *
+	intptr_t m_pVRDebug; // class vr::IVRDebug *
+	intptr_t m_pVRNotifications; // class vr::IVRNotifications *
+} COpenVRContext;
+
+
+typedef union
+{
+	VREvent_Reserved_t reserved;
+	VREvent_Controller_t controller;
+	VREvent_Mouse_t mouse;
+	VREvent_Scroll_t scroll;
+	VREvent_Process_t process;
+	VREvent_Notification_t notification;
+	VREvent_Overlay_t overlay;
+	VREvent_Status_t status;
+	VREvent_Keyboard_t keyboard;
+	VREvent_Ipd_t ipd;
+	VREvent_Chaperone_t chaperone;
+	VREvent_PerformanceTest_t performanceTest;
+	VREvent_TouchPadMove_t touchPadMove;
+	VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset;
+	VREvent_Screenshot_t screenshot;
+	VREvent_ScreenshotProgress_t screenshotProgress;
+	VREvent_ApplicationLaunch_t applicationLaunch;
+	VREvent_EditingCameraSurface_t cameraSurface;
+	VREvent_MessageOverlay_t messageOverlay;
+	VREvent_Property_t property;
+	VREvent_HapticVibration_t hapticVibration;
+	VREvent_WebConsole_t webConsole;
+	VREvent_InputBindingLoad_t inputBinding;
+	VREvent_InputActionManifestLoad_t actionManifest;
+	VREvent_SpatialAnchor_t spatialAnchor;
+} VREvent_Data_t;
+
+#if defined(__linux__) || defined(__APPLE__) 
+// This structure was originally defined mis-packed on Linux, preserved for 
+// compatibility. 
+#pragma pack( push, 4 )
+#endif
+
+/** An event posted by the server to all running applications */
+struct VREvent_t
+{
+	uint32_t eventType; // EVREventType enum
+	TrackedDeviceIndex_t trackedDeviceIndex;
+	float eventAgeSeconds;
+	// event data must be the end of the struct as its size is variable
+	VREvent_Data_t data;
+};
+
+#if defined(__linux__) || defined(__APPLE__) 
+#pragma pack( pop )
+#endif
+
+
+typedef union
+{
+	IntersectionMaskRectangle_t m_Rectangle;
+	IntersectionMaskCircle_t m_Circle;
+} VROverlayIntersectionMaskPrimitive_Data_t;
+
+struct VROverlayIntersectionMaskPrimitive_t
+{
+	EVROverlayIntersectionMaskPrimitiveType m_nPrimitiveType;
+	VROverlayIntersectionMaskPrimitive_Data_t m_Primitive;
+};
+
+
+// OpenVR Function Pointer Tables
+
+struct VR_IVRSystem_FnTable
+{
+	void (OPENVR_FNTABLE_CALLTYPE *GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight);
+	struct HmdMatrix44_t (OPENVR_FNTABLE_CALLTYPE *GetProjectionMatrix)(EVREye eEye, float fNearZ, float fFarZ);
+	void (OPENVR_FNTABLE_CALLTYPE *GetProjectionRaw)(EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom);
+	bool (OPENVR_FNTABLE_CALLTYPE *ComputeDistortion)(EVREye eEye, float fU, float fV, struct DistortionCoordinates_t * pDistortionCoordinates);
+	struct HmdMatrix34_t (OPENVR_FNTABLE_CALLTYPE *GetEyeToHeadTransform)(EVREye eEye);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter);
+	int32_t (OPENVR_FNTABLE_CALLTYPE *GetD3D9AdapterIndex)();
+	void (OPENVR_FNTABLE_CALLTYPE *GetDXGIOutputInfo)(int32_t * pnAdapterIndex);
+	void (OPENVR_FNTABLE_CALLTYPE *GetOutputDevice)(uint64_t * pnDevice, ETextureType textureType, struct VkInstance_T * pInstance);
+	bool (OPENVR_FNTABLE_CALLTYPE *IsDisplayOnDesktop)();
+	bool (OPENVR_FNTABLE_CALLTYPE *SetDisplayVisibility)(bool bIsVisibleOnDesktop);
+	void (OPENVR_FNTABLE_CALLTYPE *GetDeviceToAbsoluteTrackingPose)(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, struct TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount);
+	void (OPENVR_FNTABLE_CALLTYPE *ResetSeatedZeroPose)();
+	struct HmdMatrix34_t (OPENVR_FNTABLE_CALLTYPE *GetSeatedZeroPoseToStandingAbsoluteTrackingPose)();
+	struct HmdMatrix34_t (OPENVR_FNTABLE_CALLTYPE *GetRawZeroPoseToStandingAbsoluteTrackingPose)();
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetSortedTrackedDeviceIndicesOfClass)(ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex);
+	EDeviceActivityLevel (OPENVR_FNTABLE_CALLTYPE *GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId);
+	void (OPENVR_FNTABLE_CALLTYPE *ApplyTransform)(struct TrackedDevicePose_t * pOutputPose, struct TrackedDevicePose_t * pTrackedDevicePose, struct HmdMatrix34_t * pTransform);
+	TrackedDeviceIndex_t (OPENVR_FNTABLE_CALLTYPE *GetTrackedDeviceIndexForControllerRole)(ETrackedControllerRole unDeviceType);
+	ETrackedControllerRole (OPENVR_FNTABLE_CALLTYPE *GetControllerRoleForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex);
+	ETrackedDeviceClass (OPENVR_FNTABLE_CALLTYPE *GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex);
+	bool (OPENVR_FNTABLE_CALLTYPE *IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+	float (OPENVR_FNTABLE_CALLTYPE *GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+	int32_t (OPENVR_FNTABLE_CALLTYPE *GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+	uint64_t (OPENVR_FNTABLE_CALLTYPE *GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+	struct HmdMatrix34_t (OPENVR_FNTABLE_CALLTYPE *GetMatrix34TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetArrayTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void * pBuffer, uint32_t unBufferSize, ETrackedPropertyError * pError);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError);
+	char * (OPENVR_FNTABLE_CALLTYPE *GetPropErrorNameFromEnum)(ETrackedPropertyError error);
+	bool (OPENVR_FNTABLE_CALLTYPE *PollNextEvent)(struct VREvent_t * pEvent, uint32_t uncbVREvent);
+	bool (OPENVR_FNTABLE_CALLTYPE *PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, struct VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose);
+	char * (OPENVR_FNTABLE_CALLTYPE *GetEventTypeNameFromEnum)(EVREventType eType);
+	struct HiddenAreaMesh_t (OPENVR_FNTABLE_CALLTYPE *GetHiddenAreaMesh)(EVREye eEye, EHiddenAreaMeshType type);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, struct TrackedDevicePose_t * pTrackedDevicePose);
+	void (OPENVR_FNTABLE_CALLTYPE *TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec);
+	char * (OPENVR_FNTABLE_CALLTYPE *GetButtonIdNameFromEnum)(EVRButtonId eButtonId);
+	char * (OPENVR_FNTABLE_CALLTYPE *GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType);
+	bool (OPENVR_FNTABLE_CALLTYPE *IsInputAvailable)();
+	bool (OPENVR_FNTABLE_CALLTYPE *IsSteamVRDrawingControllers)();
+	bool (OPENVR_FNTABLE_CALLTYPE *ShouldApplicationPause)();
+	bool (OPENVR_FNTABLE_CALLTYPE *ShouldApplicationReduceRenderingWork)();
+	EVRFirmwareError (OPENVR_FNTABLE_CALLTYPE *PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex);
+	void (OPENVR_FNTABLE_CALLTYPE *AcknowledgeQuit_Exiting)();
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetAppContainerFilePaths)(char * pchBuffer, uint32_t unBufferSize);
+	char * (OPENVR_FNTABLE_CALLTYPE *GetRuntimeVersion)();
+};
+
+struct VR_IVRExtendedDisplay_FnTable
+{
+	void (OPENVR_FNTABLE_CALLTYPE *GetWindowBounds)(int32_t * pnX, int32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight);
+	void (OPENVR_FNTABLE_CALLTYPE *GetEyeOutputViewport)(EVREye eEye, uint32_t * pnX, uint32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight);
+	void (OPENVR_FNTABLE_CALLTYPE *GetDXGIOutputInfo)(int32_t * pnAdapterIndex, int32_t * pnAdapterOutputIndex);
+};
+
+struct VR_IVRTrackedCamera_FnTable
+{
+	char * (OPENVR_FNTABLE_CALLTYPE *GetCameraErrorNameFromEnum)(EVRTrackedCameraError eCameraError);
+	EVRTrackedCameraError (OPENVR_FNTABLE_CALLTYPE *HasCamera)(TrackedDeviceIndex_t nDeviceIndex, bool * pHasCamera);
+	EVRTrackedCameraError (OPENVR_FNTABLE_CALLTYPE *GetCameraFrameSize)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, uint32_t * pnWidth, uint32_t * pnHeight, uint32_t * pnFrameBufferSize);
+	EVRTrackedCameraError (OPENVR_FNTABLE_CALLTYPE *GetCameraIntrinsics)(TrackedDeviceIndex_t nDeviceIndex, uint32_t nCameraIndex, EVRTrackedCameraFrameType eFrameType, HmdVector2_t * pFocalLength, HmdVector2_t * pCenter);
+	EVRTrackedCameraError (OPENVR_FNTABLE_CALLTYPE *GetCameraProjection)(TrackedDeviceIndex_t nDeviceIndex, uint32_t nCameraIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, HmdMatrix44_t * pProjection);
+	EVRTrackedCameraError (OPENVR_FNTABLE_CALLTYPE *AcquireVideoStreamingService)(TrackedDeviceIndex_t nDeviceIndex, TrackedCameraHandle_t * pHandle);
+	EVRTrackedCameraError (OPENVR_FNTABLE_CALLTYPE *ReleaseVideoStreamingService)(TrackedCameraHandle_t hTrackedCamera);
+	EVRTrackedCameraError (OPENVR_FNTABLE_CALLTYPE *GetVideoStreamFrameBuffer)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize);
+	EVRTrackedCameraError (OPENVR_FNTABLE_CALLTYPE *GetVideoStreamTextureSize)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, VRTextureBounds_t * pTextureBounds, uint32_t * pnWidth, uint32_t * pnHeight);
+	EVRTrackedCameraError (OPENVR_FNTABLE_CALLTYPE *GetVideoStreamTextureD3D11)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize);
+	EVRTrackedCameraError (OPENVR_FNTABLE_CALLTYPE *GetVideoStreamTextureGL)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize);
+	EVRTrackedCameraError (OPENVR_FNTABLE_CALLTYPE *ReleaseVideoStreamTextureGL)(TrackedCameraHandle_t hTrackedCamera, glUInt_t glTextureId);
+	void (OPENVR_FNTABLE_CALLTYPE *SetCameraTrackingSpace)(ETrackingUniverseOrigin eUniverse);
+	ETrackingUniverseOrigin (OPENVR_FNTABLE_CALLTYPE *GetCameraTrackingSpace)();
+};
+
+struct VR_IVRApplications_FnTable
+{
+	EVRApplicationError (OPENVR_FNTABLE_CALLTYPE *AddApplicationManifest)(char * pchApplicationManifestFullPath, bool bTemporary);
+	EVRApplicationError (OPENVR_FNTABLE_CALLTYPE *RemoveApplicationManifest)(char * pchApplicationManifestFullPath);
+	bool (OPENVR_FNTABLE_CALLTYPE *IsApplicationInstalled)(char * pchAppKey);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetApplicationCount)();
+	EVRApplicationError (OPENVR_FNTABLE_CALLTYPE *GetApplicationKeyByIndex)(uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+	EVRApplicationError (OPENVR_FNTABLE_CALLTYPE *GetApplicationKeyByProcessId)(uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+	EVRApplicationError (OPENVR_FNTABLE_CALLTYPE *LaunchApplication)(char * pchAppKey);
+	EVRApplicationError (OPENVR_FNTABLE_CALLTYPE *LaunchTemplateApplication)(char * pchTemplateAppKey, char * pchNewAppKey, struct AppOverrideKeys_t * pKeys, uint32_t unKeys);
+	EVRApplicationError (OPENVR_FNTABLE_CALLTYPE *LaunchApplicationFromMimeType)(char * pchMimeType, char * pchArgs);
+	EVRApplicationError (OPENVR_FNTABLE_CALLTYPE *LaunchDashboardOverlay)(char * pchAppKey);
+	bool (OPENVR_FNTABLE_CALLTYPE *CancelApplicationLaunch)(char * pchAppKey);
+	EVRApplicationError (OPENVR_FNTABLE_CALLTYPE *IdentifyApplication)(uint32_t unProcessId, char * pchAppKey);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetApplicationProcessId)(char * pchAppKey);
+	char * (OPENVR_FNTABLE_CALLTYPE *GetApplicationsErrorNameFromEnum)(EVRApplicationError error);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetApplicationPropertyString)(char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetApplicationPropertyBool)(char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError);
+	uint64_t (OPENVR_FNTABLE_CALLTYPE *GetApplicationPropertyUint64)(char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError);
+	EVRApplicationError (OPENVR_FNTABLE_CALLTYPE *SetApplicationAutoLaunch)(char * pchAppKey, bool bAutoLaunch);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetApplicationAutoLaunch)(char * pchAppKey);
+	EVRApplicationError (OPENVR_FNTABLE_CALLTYPE *SetDefaultApplicationForMimeType)(char * pchAppKey, char * pchMimeType);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetDefaultApplicationForMimeType)(char * pchMimeType, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetApplicationSupportedMimeTypes)(char * pchAppKey, char * pchMimeTypesBuffer, uint32_t unMimeTypesBuffer);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetApplicationsThatSupportMimeType)(char * pchMimeType, char * pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetApplicationLaunchArguments)(uint32_t unHandle, char * pchArgs, uint32_t unArgs);
+	EVRApplicationError (OPENVR_FNTABLE_CALLTYPE *GetStartingApplication)(char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+	EVRSceneApplicationState (OPENVR_FNTABLE_CALLTYPE *GetSceneApplicationState)();
+	EVRApplicationError (OPENVR_FNTABLE_CALLTYPE *PerformApplicationPrelaunchCheck)(char * pchAppKey);
+	char * (OPENVR_FNTABLE_CALLTYPE *GetSceneApplicationStateNameFromEnum)(EVRSceneApplicationState state);
+	EVRApplicationError (OPENVR_FNTABLE_CALLTYPE *LaunchInternalProcess)(char * pchBinaryPath, char * pchArguments, char * pchWorkingDirectory);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetCurrentSceneProcessId)();
+};
+
+struct VR_IVRChaperone_FnTable
+{
+	ChaperoneCalibrationState (OPENVR_FNTABLE_CALLTYPE *GetCalibrationState)();
+	bool (OPENVR_FNTABLE_CALLTYPE *GetPlayAreaSize)(float * pSizeX, float * pSizeZ);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetPlayAreaRect)(struct HmdQuad_t * rect);
+	void (OPENVR_FNTABLE_CALLTYPE *ReloadInfo)();
+	void (OPENVR_FNTABLE_CALLTYPE *SetSceneColor)(struct HmdColor_t color);
+	void (OPENVR_FNTABLE_CALLTYPE *GetBoundsColor)(struct HmdColor_t * pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, struct HmdColor_t * pOutputCameraColor);
+	bool (OPENVR_FNTABLE_CALLTYPE *AreBoundsVisible)();
+	void (OPENVR_FNTABLE_CALLTYPE *ForceBoundsVisible)(bool bForce);
+};
+
+struct VR_IVRChaperoneSetup_FnTable
+{
+	bool (OPENVR_FNTABLE_CALLTYPE *CommitWorkingCopy)(EChaperoneConfigFile configFile);
+	void (OPENVR_FNTABLE_CALLTYPE *RevertWorkingCopy)();
+	bool (OPENVR_FNTABLE_CALLTYPE *GetWorkingPlayAreaSize)(float * pSizeX, float * pSizeZ);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetWorkingPlayAreaRect)(struct HmdQuad_t * rect);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetWorkingCollisionBoundsInfo)(struct HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetLiveCollisionBoundsInfo)(struct HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetWorkingSeatedZeroPoseToRawTrackingPose)(struct HmdMatrix34_t * pmatSeatedZeroPoseToRawTrackingPose);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetWorkingStandingZeroPoseToRawTrackingPose)(struct HmdMatrix34_t * pmatStandingZeroPoseToRawTrackingPose);
+	void (OPENVR_FNTABLE_CALLTYPE *SetWorkingPlayAreaSize)(float sizeX, float sizeZ);
+	void (OPENVR_FNTABLE_CALLTYPE *SetWorkingCollisionBoundsInfo)(struct HmdQuad_t * pQuadsBuffer, uint32_t unQuadsCount);
+	void (OPENVR_FNTABLE_CALLTYPE *SetWorkingPerimeter)(struct HmdVector2_t * pPointBuffer, uint32_t unPointCount);
+	void (OPENVR_FNTABLE_CALLTYPE *SetWorkingSeatedZeroPoseToRawTrackingPose)(struct HmdMatrix34_t * pMatSeatedZeroPoseToRawTrackingPose);
+	void (OPENVR_FNTABLE_CALLTYPE *SetWorkingStandingZeroPoseToRawTrackingPose)(struct HmdMatrix34_t * pMatStandingZeroPoseToRawTrackingPose);
+	void (OPENVR_FNTABLE_CALLTYPE *ReloadFromDisk)(EChaperoneConfigFile configFile);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetLiveSeatedZeroPoseToRawTrackingPose)(struct HmdMatrix34_t * pmatSeatedZeroPoseToRawTrackingPose);
+	bool (OPENVR_FNTABLE_CALLTYPE *ExportLiveToBuffer)(char * pBuffer, uint32_t * pnBufferLength);
+	bool (OPENVR_FNTABLE_CALLTYPE *ImportFromBufferToWorking)(char * pBuffer, uint32_t nImportFlags);
+	void (OPENVR_FNTABLE_CALLTYPE *ShowWorkingSetPreview)();
+	void (OPENVR_FNTABLE_CALLTYPE *HideWorkingSetPreview)();
+	void (OPENVR_FNTABLE_CALLTYPE *RoomSetupStarting)();
+};
+
+struct VR_IVRCompositor_FnTable
+{
+	void (OPENVR_FNTABLE_CALLTYPE *SetTrackingSpace)(ETrackingUniverseOrigin eOrigin);
+	ETrackingUniverseOrigin (OPENVR_FNTABLE_CALLTYPE *GetTrackingSpace)();
+	EVRCompositorError (OPENVR_FNTABLE_CALLTYPE *WaitGetPoses)(struct TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, struct TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+	EVRCompositorError (OPENVR_FNTABLE_CALLTYPE *GetLastPoses)(struct TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, struct TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+	EVRCompositorError (OPENVR_FNTABLE_CALLTYPE *GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, struct TrackedDevicePose_t * pOutputPose, struct TrackedDevicePose_t * pOutputGamePose);
+	EVRCompositorError (OPENVR_FNTABLE_CALLTYPE *Submit)(EVREye eEye, struct Texture_t * pTexture, struct VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags);
+	void (OPENVR_FNTABLE_CALLTYPE *ClearLastSubmittedFrame)();
+	void (OPENVR_FNTABLE_CALLTYPE *PostPresentHandoff)();
+	bool (OPENVR_FNTABLE_CALLTYPE *GetFrameTiming)(struct Compositor_FrameTiming * pTiming, uint32_t unFramesAgo);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetFrameTimings)(struct Compositor_FrameTiming * pTiming, uint32_t nFrames);
+	float (OPENVR_FNTABLE_CALLTYPE *GetFrameTimeRemaining)();
+	void (OPENVR_FNTABLE_CALLTYPE *GetCumulativeStats)(struct Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes);
+	void (OPENVR_FNTABLE_CALLTYPE *FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
+	struct HmdColor_t (OPENVR_FNTABLE_CALLTYPE *GetCurrentFadeColor)(bool bBackground);
+	void (OPENVR_FNTABLE_CALLTYPE *FadeGrid)(float fSeconds, bool bFadeIn);
+	float (OPENVR_FNTABLE_CALLTYPE *GetCurrentGridAlpha)();
+	EVRCompositorError (OPENVR_FNTABLE_CALLTYPE *SetSkyboxOverride)(struct Texture_t * pTextures, uint32_t unTextureCount);
+	void (OPENVR_FNTABLE_CALLTYPE *ClearSkyboxOverride)();
+	void (OPENVR_FNTABLE_CALLTYPE *CompositorBringToFront)();
+	void (OPENVR_FNTABLE_CALLTYPE *CompositorGoToBack)();
+	void (OPENVR_FNTABLE_CALLTYPE *CompositorQuit)();
+	bool (OPENVR_FNTABLE_CALLTYPE *IsFullscreen)();
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetCurrentSceneFocusProcess)();
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetLastFrameRenderer)();
+	bool (OPENVR_FNTABLE_CALLTYPE *CanRenderScene)();
+	void (OPENVR_FNTABLE_CALLTYPE *ShowMirrorWindow)();
+	void (OPENVR_FNTABLE_CALLTYPE *HideMirrorWindow)();
+	bool (OPENVR_FNTABLE_CALLTYPE *IsMirrorWindowVisible)();
+	void (OPENVR_FNTABLE_CALLTYPE *CompositorDumpImages)();
+	bool (OPENVR_FNTABLE_CALLTYPE *ShouldAppRenderWithLowResources)();
+	void (OPENVR_FNTABLE_CALLTYPE *ForceInterleavedReprojectionOn)(bool bOverride);
+	void (OPENVR_FNTABLE_CALLTYPE *ForceReconnectProcess)();
+	void (OPENVR_FNTABLE_CALLTYPE *SuspendRendering)(bool bSuspend);
+	EVRCompositorError (OPENVR_FNTABLE_CALLTYPE *GetMirrorTextureD3D11)(EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView);
+	void (OPENVR_FNTABLE_CALLTYPE *ReleaseMirrorTextureD3D11)(void * pD3D11ShaderResourceView);
+	EVRCompositorError (OPENVR_FNTABLE_CALLTYPE *GetMirrorTextureGL)(EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle);
+	bool (OPENVR_FNTABLE_CALLTYPE *ReleaseSharedGLTexture)(glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle);
+	void (OPENVR_FNTABLE_CALLTYPE *LockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle);
+	void (OPENVR_FNTABLE_CALLTYPE *UnlockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetVulkanInstanceExtensionsRequired)(char * pchValue, uint32_t unBufferSize);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetVulkanDeviceExtensionsRequired)(struct VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize);
+	void (OPENVR_FNTABLE_CALLTYPE *SetExplicitTimingMode)(EVRCompositorTimingMode eTimingMode);
+	EVRCompositorError (OPENVR_FNTABLE_CALLTYPE *SubmitExplicitTimingData)();
+	bool (OPENVR_FNTABLE_CALLTYPE *IsMotionSmoothingEnabled)();
+	bool (OPENVR_FNTABLE_CALLTYPE *IsMotionSmoothingSupported)();
+	bool (OPENVR_FNTABLE_CALLTYPE *IsCurrentSceneFocusAppLoading)();
+	EVRCompositorError (OPENVR_FNTABLE_CALLTYPE *SetStageOverride_Async)(char * pchRenderModelPath, struct HmdMatrix34_t * pTransform, struct Compositor_StageRenderSettings * pRenderSettings, uint32_t nSizeOfRenderSettings);
+	void (OPENVR_FNTABLE_CALLTYPE *ClearStageOverride)();
+	bool (OPENVR_FNTABLE_CALLTYPE *GetCompositorBenchmarkResults)(struct Compositor_BenchmarkResults * pBenchmarkResults, uint32_t nSizeOfBenchmarkResults);
+	EVRCompositorError (OPENVR_FNTABLE_CALLTYPE *GetLastPosePredictionIDs)(uint32_t * pRenderPosePredictionID, uint32_t * pGamePosePredictionID);
+	EVRCompositorError (OPENVR_FNTABLE_CALLTYPE *GetPosesForFrame)(uint32_t unPosePredictionID, struct TrackedDevicePose_t * pPoseArray, uint32_t unPoseArrayCount);
+};
+
+struct VR_IVROverlay_FnTable
+{
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *FindOverlay)(char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *CreateOverlay)(char * pchOverlayKey, char * pchOverlayName, VROverlayHandle_t * pOverlayHandle);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *DestroyOverlay)(VROverlayHandle_t ulOverlayHandle);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchName);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
+	char * (OPENVR_FNTABLE_CALLTYPE *GetOverlayErrorNameFromEnum)(EVROverlayError error);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayFlags)(VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float fTexelAspect);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayCurvature)(VROverlayHandle_t ulOverlayHandle, float fCurvature);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayCurvature)(VROverlayHandle_t ulOverlayHandle, float * pfCurvature);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, struct VRTextureBounds_t * pOverlayTextureBounds);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, struct VRTextureBounds_t * pOverlayTextureBounds);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, struct HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, struct HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, struct HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, struct HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, char * pchComponentName);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, struct HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, struct HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayTransformCursor)(VROverlayHandle_t ulCursorOverlayHandle, struct HmdVector2_t * pvHotspot);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformCursor)(VROverlayHandle_t ulOverlayHandle, struct HmdVector2_t * pvHotspot);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *ShowOverlay)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *HideOverlay)(VROverlayHandle_t ulOverlayHandle);
+	bool (OPENVR_FNTABLE_CALLTYPE *IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, struct HmdVector2_t coordinatesInOverlay, struct HmdMatrix34_t * pmatTransform);
+	bool (OPENVR_FNTABLE_CALLTYPE *PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, struct VREvent_t * pEvent, uint32_t uncbVREvent);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, struct HmdVector2_t * pvecMouseScale);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, struct HmdVector2_t * pvecMouseScale);
+	bool (OPENVR_FNTABLE_CALLTYPE *ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, struct VROverlayIntersectionParams_t * pParams, struct VROverlayIntersectionResults_t * pResults);
+	bool (OPENVR_FNTABLE_CALLTYPE *IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayIntersectionMask)(VROverlayHandle_t ulOverlayHandle, struct VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *TriggerLaserMouseHapticVibration)(VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayCursor)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayCursorPositionOverride)(VROverlayHandle_t ulOverlayHandle, struct HmdVector2_t * pvCursor);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *ClearOverlayCursorPositionOverride)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, struct Texture_t * pTexture);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, char * pchFilePath);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, struct VRTextureBounds_t * pTextureBounds);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *CreateDashboardOverlay)(char * pchOverlayKey, char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
+	bool (OPENVR_FNTABLE_CALLTYPE *IsDashboardVisible)();
+	bool (OPENVR_FNTABLE_CALLTYPE *IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
+	void (OPENVR_FNTABLE_CALLTYPE *ShowDashboard)(char * pchOverlayToShow);
+	TrackedDeviceIndex_t (OPENVR_FNTABLE_CALLTYPE *GetPrimaryDashboardDevice)();
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, char * pchDescription, uint32_t unCharMax, char * pchExistingText, uint64_t uUserValue);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, char * pchDescription, uint32_t unCharMax, char * pchExistingText, uint64_t uUserValue);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetKeyboardText)(char * pchText, uint32_t cchText);
+	void (OPENVR_FNTABLE_CALLTYPE *HideKeyboard)();
+	void (OPENVR_FNTABLE_CALLTYPE *SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, struct HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform);
+	void (OPENVR_FNTABLE_CALLTYPE *SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, struct HmdRect2_t avoidRect);
+	VRMessageOverlayResponse (OPENVR_FNTABLE_CALLTYPE *ShowMessageOverlay)(char * pchText, char * pchCaption, char * pchButton0Text, char * pchButton1Text, char * pchButton2Text, char * pchButton3Text);
+	void (OPENVR_FNTABLE_CALLTYPE *CloseMessageOverlay)();
+};
+
+struct VR_IVROverlayView_FnTable
+{
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *AcquireOverlayView)(VROverlayHandle_t ulOverlayHandle, struct VRNativeDevice_t * pNativeDevice, struct VROverlayView_t * pOverlayView, uint32_t unOverlayViewSize);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *ReleaseOverlayView)(struct VROverlayView_t * pOverlayView);
+	void (OPENVR_FNTABLE_CALLTYPE *PostOverlayEvent)(VROverlayHandle_t ulOverlayHandle, struct VREvent_t * pvrEvent);
+	bool (OPENVR_FNTABLE_CALLTYPE *IsViewingPermitted)(VROverlayHandle_t ulOverlayHandle);
+};
+
+struct VR_IVRHeadsetView_FnTable
+{
+	void (OPENVR_FNTABLE_CALLTYPE *SetHeadsetViewSize)(uint32_t nWidth, uint32_t nHeight);
+	void (OPENVR_FNTABLE_CALLTYPE *GetHeadsetViewSize)(uint32_t * pnWidth, uint32_t * pnHeight);
+	void (OPENVR_FNTABLE_CALLTYPE *SetHeadsetViewMode)(HeadsetViewMode_t eHeadsetViewMode);
+	HeadsetViewMode_t (OPENVR_FNTABLE_CALLTYPE *GetHeadsetViewMode)();
+	void (OPENVR_FNTABLE_CALLTYPE *SetHeadsetViewCropped)(bool bCropped);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetHeadsetViewCropped)();
+	float (OPENVR_FNTABLE_CALLTYPE *GetHeadsetViewAspectRatio)();
+	void (OPENVR_FNTABLE_CALLTYPE *SetHeadsetViewBlendRange)(float flStartPct, float flEndPct);
+	void (OPENVR_FNTABLE_CALLTYPE *GetHeadsetViewBlendRange)(float * pStartPct, float * pEndPct);
+};
+
+struct VR_IVRRenderModels_FnTable
+{
+	EVRRenderModelError (OPENVR_FNTABLE_CALLTYPE *LoadRenderModel_Async)(char * pchRenderModelName, struct RenderModel_t ** ppRenderModel);
+	void (OPENVR_FNTABLE_CALLTYPE *FreeRenderModel)(struct RenderModel_t * pRenderModel);
+	EVRRenderModelError (OPENVR_FNTABLE_CALLTYPE *LoadTexture_Async)(TextureID_t textureId, struct RenderModel_TextureMap_t ** ppTexture);
+	void (OPENVR_FNTABLE_CALLTYPE *FreeTexture)(struct RenderModel_TextureMap_t * pTexture);
+	EVRRenderModelError (OPENVR_FNTABLE_CALLTYPE *LoadTextureD3D11_Async)(TextureID_t textureId, void * pD3D11Device, void ** ppD3D11Texture2D);
+	EVRRenderModelError (OPENVR_FNTABLE_CALLTYPE *LoadIntoTextureD3D11_Async)(TextureID_t textureId, void * pDstTexture);
+	void (OPENVR_FNTABLE_CALLTYPE *FreeTextureD3D11)(void * pD3D11Texture2D);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetRenderModelName)(uint32_t unRenderModelIndex, char * pchRenderModelName, uint32_t unRenderModelNameLen);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetRenderModelCount)();
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetComponentCount)(char * pchRenderModelName);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetComponentName)(char * pchRenderModelName, uint32_t unComponentIndex, char * pchComponentName, uint32_t unComponentNameLen);
+	uint64_t (OPENVR_FNTABLE_CALLTYPE *GetComponentButtonMask)(char * pchRenderModelName, char * pchComponentName);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetComponentRenderModelName)(char * pchRenderModelName, char * pchComponentName, char * pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetComponentStateForDevicePath)(char * pchRenderModelName, char * pchComponentName, VRInputValueHandle_t devicePath, RenderModel_ControllerMode_State_t * pState, RenderModel_ComponentState_t * pComponentState);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetComponentState)(char * pchRenderModelName, char * pchComponentName, VRControllerState_t * pControllerState, struct RenderModel_ControllerMode_State_t * pState, struct RenderModel_ComponentState_t * pComponentState);
+	bool (OPENVR_FNTABLE_CALLTYPE *RenderModelHasComponent)(char * pchRenderModelName, char * pchComponentName);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetRenderModelThumbnailURL)(char * pchRenderModelName, char * pchThumbnailURL, uint32_t unThumbnailURLLen, EVRRenderModelError * peError);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetRenderModelOriginalPath)(char * pchRenderModelName, char * pchOriginalPath, uint32_t unOriginalPathLen, EVRRenderModelError * peError);
+	char * (OPENVR_FNTABLE_CALLTYPE *GetRenderModelErrorNameFromEnum)(EVRRenderModelError error);
+};
+
+struct VR_IVRNotifications_FnTable
+{
+	EVRNotificationError (OPENVR_FNTABLE_CALLTYPE *CreateNotification)(VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, EVRNotificationType type, char * pchText, EVRNotificationStyle style, struct NotificationBitmap_t * pImage, VRNotificationId * pNotificationId);
+	EVRNotificationError (OPENVR_FNTABLE_CALLTYPE *RemoveNotification)(VRNotificationId notificationId);
+};
+
+struct VR_IVRSettings_FnTable
+{
+	char * (OPENVR_FNTABLE_CALLTYPE *GetSettingsErrorNameFromEnum)(EVRSettingsError eError);
+	void (OPENVR_FNTABLE_CALLTYPE *SetBool)(char * pchSection, char * pchSettingsKey, bool bValue, EVRSettingsError * peError);
+	void (OPENVR_FNTABLE_CALLTYPE *SetInt32)(char * pchSection, char * pchSettingsKey, int32_t nValue, EVRSettingsError * peError);
+	void (OPENVR_FNTABLE_CALLTYPE *SetFloat)(char * pchSection, char * pchSettingsKey, float flValue, EVRSettingsError * peError);
+	void (OPENVR_FNTABLE_CALLTYPE *SetString)(char * pchSection, char * pchSettingsKey, char * pchValue, EVRSettingsError * peError);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetBool)(char * pchSection, char * pchSettingsKey, EVRSettingsError * peError);
+	int32_t (OPENVR_FNTABLE_CALLTYPE *GetInt32)(char * pchSection, char * pchSettingsKey, EVRSettingsError * peError);
+	float (OPENVR_FNTABLE_CALLTYPE *GetFloat)(char * pchSection, char * pchSettingsKey, EVRSettingsError * peError);
+	void (OPENVR_FNTABLE_CALLTYPE *GetString)(char * pchSection, char * pchSettingsKey, char * pchValue, uint32_t unValueLen, EVRSettingsError * peError);
+	void (OPENVR_FNTABLE_CALLTYPE *RemoveSection)(char * pchSection, EVRSettingsError * peError);
+	void (OPENVR_FNTABLE_CALLTYPE *RemoveKeyInSection)(char * pchSection, char * pchSettingsKey, EVRSettingsError * peError);
+};
+
+struct VR_IVRScreenshots_FnTable
+{
+	EVRScreenshotError (OPENVR_FNTABLE_CALLTYPE *RequestScreenshot)(ScreenshotHandle_t * pOutScreenshotHandle, EVRScreenshotType type, char * pchPreviewFilename, char * pchVRFilename);
+	EVRScreenshotError (OPENVR_FNTABLE_CALLTYPE *HookScreenshot)(EVRScreenshotType * pSupportedTypes, int numTypes);
+	EVRScreenshotType (OPENVR_FNTABLE_CALLTYPE *GetScreenshotPropertyType)(ScreenshotHandle_t screenshotHandle, EVRScreenshotError * pError);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetScreenshotPropertyFilename)(ScreenshotHandle_t screenshotHandle, EVRScreenshotPropertyFilenames filenameType, char * pchFilename, uint32_t cchFilename, EVRScreenshotError * pError);
+	EVRScreenshotError (OPENVR_FNTABLE_CALLTYPE *UpdateScreenshotProgress)(ScreenshotHandle_t screenshotHandle, float flProgress);
+	EVRScreenshotError (OPENVR_FNTABLE_CALLTYPE *TakeStereoScreenshot)(ScreenshotHandle_t * pOutScreenshotHandle, char * pchPreviewFilename, char * pchVRFilename);
+	EVRScreenshotError (OPENVR_FNTABLE_CALLTYPE *SubmitScreenshot)(ScreenshotHandle_t screenshotHandle, EVRScreenshotType type, char * pchSourcePreviewFilename, char * pchSourceVRFilename);
+};
+
+struct VR_IVRResources_FnTable
+{
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *LoadSharedResource)(char * pchResourceName, char * pchBuffer, uint32_t unBufferLen);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetResourceFullPath)(char * pchResourceName, char * pchResourceTypeDirectory, char * pchPathBuffer, uint32_t unBufferLen);
+};
+
+struct VR_IVRDriverManager_FnTable
+{
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetDriverCount)();
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetDriverName)(DriverId_t nDriver, char * pchValue, uint32_t unBufferSize);
+	DriverHandle_t (OPENVR_FNTABLE_CALLTYPE *GetDriverHandle)(char * pchDriverName);
+	bool (OPENVR_FNTABLE_CALLTYPE *IsEnabled)(DriverId_t nDriver);
+};
+
+struct VR_IVRInput_FnTable
+{
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *SetActionManifestPath)(char * pchActionManifestPath);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetActionSetHandle)(char * pchActionSetName, VRActionSetHandle_t * pHandle);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetActionHandle)(char * pchActionName, VRActionHandle_t * pHandle);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetInputSourceHandle)(char * pchInputSourcePath, VRInputValueHandle_t * pHandle);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *UpdateActionState)(struct VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetDigitalActionData)(VRActionHandle_t action, struct InputDigitalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetAnalogActionData)(VRActionHandle_t action, struct InputAnalogActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetPoseActionDataRelativeToNow)(VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, struct InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetPoseActionDataForNextFrame)(VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, struct InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetSkeletalActionData)(VRActionHandle_t action, struct InputSkeletalActionData_t * pActionData, uint32_t unActionDataSize);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetDominantHand)(ETrackedControllerRole * peDominantHand);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *SetDominantHand)(ETrackedControllerRole eDominantHand);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetBoneCount)(VRActionHandle_t action, uint32_t * pBoneCount);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetBoneHierarchy)(VRActionHandle_t action, BoneIndex_t * pParentIndices, uint32_t unIndexArayCount);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetBoneName)(VRActionHandle_t action, BoneIndex_t nBoneIndex, char * pchBoneName, uint32_t unNameBufferSize);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetSkeletalReferenceTransforms)(VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalReferencePose eReferencePose, struct VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetSkeletalTrackingLevel)(VRActionHandle_t action, EVRSkeletalTrackingLevel * pSkeletalTrackingLevel);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetSkeletalBoneData)(VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, struct VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetSkeletalSummaryData)(VRActionHandle_t action, EVRSummaryType eSummaryType, struct VRSkeletalSummaryData_t * pSkeletalSummaryData);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetSkeletalBoneDataCompressed)(VRActionHandle_t action, EVRSkeletalMotionRange eMotionRange, void * pvCompressedData, uint32_t unCompressedSize, uint32_t * punRequiredCompressedSize);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *DecompressSkeletalBoneData)(void * pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace eTransformSpace, struct VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *TriggerHapticVibrationAction)(VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, VRInputValueHandle_t ulRestrictToDevice);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetActionOrigins)(VRActionSetHandle_t actionSetHandle, VRActionHandle_t digitalActionHandle, VRInputValueHandle_t * originsOut, uint32_t originOutCount);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetOriginLocalizedName)(VRInputValueHandle_t origin, char * pchNameArray, uint32_t unNameArraySize, int32_t unStringSectionsToInclude);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetOriginTrackedDeviceInfo)(VRInputValueHandle_t origin, struct InputOriginInfo_t * pOriginInfo, uint32_t unOriginInfoSize);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetActionBindingInfo)(VRActionHandle_t action, struct InputBindingInfo_t * pOriginInfo, uint32_t unBindingInfoSize, uint32_t unBindingInfoCount, uint32_t * punReturnedBindingInfoCount);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *ShowActionOrigins)(VRActionSetHandle_t actionSetHandle, VRActionHandle_t ulActionHandle);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *ShowBindingsForActionSet)(struct VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetComponentStateForBinding)(char * pchRenderModelName, char * pchComponentName, struct InputBindingInfo_t * pOriginInfo, uint32_t unBindingInfoSize, uint32_t unBindingInfoCount, RenderModel_ComponentState_t * pComponentState);
+	bool (OPENVR_FNTABLE_CALLTYPE *IsUsingLegacyInput)();
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *OpenBindingUI)(char * pchAppKey, VRActionSetHandle_t ulActionSetHandle, VRInputValueHandle_t ulDeviceHandle, bool bShowOnDesktop);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetBindingVariant)(VRInputValueHandle_t ulDevicePath, char * pchVariantArray, uint32_t unVariantArraySize);
+};
+
+struct VR_IVRIOBuffer_FnTable
+{
+	EIOBufferError (OPENVR_FNTABLE_CALLTYPE *Open)(char * pchPath, EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, IOBufferHandle_t * pulBuffer);
+	EIOBufferError (OPENVR_FNTABLE_CALLTYPE *Close)(IOBufferHandle_t ulBuffer);
+	EIOBufferError (OPENVR_FNTABLE_CALLTYPE *Read)(IOBufferHandle_t ulBuffer, void * pDst, uint32_t unBytes, uint32_t * punRead);
+	EIOBufferError (OPENVR_FNTABLE_CALLTYPE *Write)(IOBufferHandle_t ulBuffer, void * pSrc, uint32_t unBytes);
+	PropertyContainerHandle_t (OPENVR_FNTABLE_CALLTYPE *PropertyContainer)(IOBufferHandle_t ulBuffer);
+	bool (OPENVR_FNTABLE_CALLTYPE *HasReaders)(IOBufferHandle_t ulBuffer);
+};
+
+struct VR_IVRSpatialAnchors_FnTable
+{
+	EVRSpatialAnchorError (OPENVR_FNTABLE_CALLTYPE *CreateSpatialAnchorFromDescriptor)(char * pchDescriptor, SpatialAnchorHandle_t * pHandleOut);
+	EVRSpatialAnchorError (OPENVR_FNTABLE_CALLTYPE *CreateSpatialAnchorFromPose)(TrackedDeviceIndex_t unDeviceIndex, ETrackingUniverseOrigin eOrigin, struct SpatialAnchorPose_t * pPose, SpatialAnchorHandle_t * pHandleOut);
+	EVRSpatialAnchorError (OPENVR_FNTABLE_CALLTYPE *GetSpatialAnchorPose)(SpatialAnchorHandle_t unHandle, ETrackingUniverseOrigin eOrigin, struct SpatialAnchorPose_t * pPoseOut);
+	EVRSpatialAnchorError (OPENVR_FNTABLE_CALLTYPE *GetSpatialAnchorDescriptor)(SpatialAnchorHandle_t unHandle, char * pchDescriptorOut, uint32_t * punDescriptorBufferLenInOut);
+};
+
+struct VR_IVRDebug_FnTable
+{
+	EVRDebugError (OPENVR_FNTABLE_CALLTYPE *EmitVrProfilerEvent)(char * pchMessage);
+	EVRDebugError (OPENVR_FNTABLE_CALLTYPE *BeginVrProfilerEvent)(VrProfilerEventHandle_t * pHandleOut);
+	EVRDebugError (OPENVR_FNTABLE_CALLTYPE *FinishVrProfilerEvent)(VrProfilerEventHandle_t hHandle, char * pchMessage);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize);
+};
+
+
+#if 0
+// Global entry points
+S_API intptr_t VR_InitInternal( EVRInitError *peError, EVRApplicationType eType );
+S_API void VR_ShutdownInternal();
+S_API bool VR_IsHmdPresent();
+S_API intptr_t VR_GetGenericInterface( const char *pchInterfaceVersion, EVRInitError *peError );
+S_API bool VR_IsRuntimeInstalled();
+S_API const char * VR_GetVRInitErrorAsSymbol( EVRInitError error );
+S_API const char * VR_GetVRInitErrorAsEnglishDescription( EVRInitError error );
+#endif
+
+#endif // __OPENVR_API_FLAT_H__
+
+
diff --git a/engine/inc/openvr-x/openvr_driver.h b/engine/inc/openvr-x/openvr_driver.h
new file mode 100644
index 00000000..8982f462
--- /dev/null
+++ b/engine/inc/openvr-x/openvr_driver.h
@@ -0,0 +1,4086 @@
+#pragma once
+
+// openvr_driver.h
+//========= Copyright Valve Corporation ============//
+// Dynamically generated file. Do not modify this file directly.
+
+#ifndef _OPENVR_DRIVER_API
+#define _OPENVR_DRIVER_API
+
+#include <stdint.h>
+
+
+
+// version.h
+namespace vr
+{
+	static const uint32_t k_nSteamVRVersionMajor = 1;
+	static const uint32_t k_nSteamVRVersionMinor = 11;
+	static const uint32_t k_nSteamVRVersionBuild = 11;
+} // namespace vr
+
+// vrtypes.h
+#ifndef _INCLUDE_VRTYPES_H
+#define _INCLUDE_VRTYPES_H
+
+// Forward declarations to avoid requiring vulkan.h
+struct VkDevice_T;
+struct VkPhysicalDevice_T;
+struct VkInstance_T;
+struct VkQueue_T;
+
+// Forward declarations to avoid requiring d3d12.h
+struct ID3D12Resource;
+struct ID3D12CommandQueue;
+
+namespace vr
+{
+#pragma pack( push, 8 )
+
+/** A handle for a spatial anchor.  This handle is only valid during the session it was created in.
+* Anchors that live beyond one session should be saved by their string descriptors. */
+typedef uint32_t SpatialAnchorHandle_t;
+
+typedef void* glSharedTextureHandle_t;
+typedef int32_t glInt_t;
+typedef uint32_t glUInt_t;
+
+// right-handed system
+// +y is up
+// +x is to the right
+// -z is forward
+// Distance unit is  meters
+struct HmdMatrix34_t
+{
+	float m[3][4];
+};
+
+struct HmdMatrix33_t
+{
+	float m[3][3];
+};
+
+struct HmdMatrix44_t
+{
+	float m[4][4];
+};
+
+struct HmdVector3_t
+{
+	float v[3];
+};
+
+struct HmdVector4_t
+{
+	float v[4];
+};
+
+struct HmdVector3d_t
+{
+	double v[3];
+};
+
+struct HmdVector2_t
+{
+	float v[2];
+};
+
+struct HmdQuaternion_t
+{
+	double w, x, y, z;
+};
+
+struct HmdQuaternionf_t
+{
+	float w, x, y, z;
+};
+
+struct HmdColor_t
+{
+	float r, g, b, a;
+};
+
+struct HmdQuad_t
+{
+	HmdVector3_t vCorners[ 4 ];
+};
+
+struct HmdRect2_t
+{
+	HmdVector2_t vTopLeft;
+	HmdVector2_t vBottomRight;
+};
+
+/** Used to return the post-distortion UVs for each color channel. 
+* UVs range from 0 to 1 with 0,0 in the upper left corner of the 
+* source render target. The 0,0 to 1,1 range covers a single eye. */
+struct DistortionCoordinates_t
+{
+	float rfRed[2];
+	float rfGreen[2];
+	float rfBlue[2];
+};
+
+enum EVREye
+{
+	Eye_Left = 0,
+	Eye_Right = 1
+};
+
+enum ETextureType
+{
+	TextureType_Invalid = -1, // Handle has been invalidated
+	TextureType_DirectX = 0, // Handle is an ID3D11Texture
+	TextureType_OpenGL = 1,  // Handle is an OpenGL texture name or an OpenGL render buffer name, depending on submit flags
+	TextureType_Vulkan = 2, // Handle is a pointer to a VRVulkanTextureData_t structure
+	TextureType_IOSurface = 3, // Handle is a macOS cross-process-sharable IOSurfaceRef, deprecated in favor of TextureType_Metal on supported platforms
+	TextureType_DirectX12 = 4, // Handle is a pointer to a D3D12TextureData_t structure
+	TextureType_DXGISharedHandle = 5, // Handle is a HANDLE DXGI share handle, only supported for Overlay render targets. 
+									  // this texture is used directly by our renderer, so only perform atomic (copyresource or resolve) on it
+	TextureType_Metal = 6, // Handle is a MTLTexture conforming to the MTLSharedTexture protocol. Textures submitted to IVRCompositor::Submit which
+						   // are of type MTLTextureType2DArray assume layer 0 is the left eye texture (vr::EVREye::Eye_left), layer 1 is the right
+						   // eye texture (vr::EVREye::Eye_Right)
+};
+
+enum EColorSpace
+{
+	ColorSpace_Auto = 0,	// Assumes 'gamma' for 8-bit per component formats, otherwise 'linear'.  This mirrors the DXGI formats which have _SRGB variants.
+	ColorSpace_Gamma = 1,	// Texture data can be displayed directly on the display without any conversion (a.k.a. display native format).
+	ColorSpace_Linear = 2,	// Same as gamma but has been converted to a linear representation using DXGI's sRGB conversion algorithm.
+};
+
+struct Texture_t
+{
+	void* handle; // See ETextureType definition above
+	ETextureType eType;
+	EColorSpace eColorSpace;
+};
+
+// Handle to a shared texture (HANDLE on Windows obtained using OpenSharedResource).
+typedef uint64_t SharedTextureHandle_t;
+#define INVALID_SHARED_TEXTURE_HANDLE	((vr::SharedTextureHandle_t)0)
+
+enum ETrackingResult
+{
+	TrackingResult_Uninitialized			= 1,
+
+	TrackingResult_Calibrating_InProgress	= 100,
+	TrackingResult_Calibrating_OutOfRange	= 101,
+
+	TrackingResult_Running_OK				= 200,
+	TrackingResult_Running_OutOfRange		= 201,
+
+	TrackingResult_Fallback_RotationOnly	= 300,
+};
+
+typedef uint32_t DriverId_t;
+static const uint32_t k_nDriverNone = 0xFFFFFFFF;
+
+static const uint32_t k_unMaxDriverDebugResponseSize = 32768;
+
+/** Used to pass device IDs to API calls */
+typedef uint32_t TrackedDeviceIndex_t;
+static const uint32_t k_unTrackedDeviceIndex_Hmd = 0;
+static const uint32_t k_unMaxTrackedDeviceCount = 64;
+static const uint32_t k_unTrackedDeviceIndexOther = 0xFFFFFFFE;
+static const uint32_t k_unTrackedDeviceIndexInvalid = 0xFFFFFFFF;
+
+/** Describes what kind of object is being tracked at a given ID */
+enum ETrackedDeviceClass
+{
+	TrackedDeviceClass_Invalid = 0,				// the ID was not valid.
+	TrackedDeviceClass_HMD = 1,					// Head-Mounted Displays
+	TrackedDeviceClass_Controller = 2,			// Tracked controllers
+	TrackedDeviceClass_GenericTracker = 3,		// Generic trackers, similar to controllers
+	TrackedDeviceClass_TrackingReference = 4,	// Camera and base stations that serve as tracking reference points
+	TrackedDeviceClass_DisplayRedirect = 5,		// Accessories that aren't necessarily tracked themselves, but may redirect video output from other tracked devices
+
+	TrackedDeviceClass_Max
+};
+
+
+/** Describes what specific role associated with a tracked device */
+enum ETrackedControllerRole
+{
+	TrackedControllerRole_Invalid = 0,					// Invalid value for controller type
+	TrackedControllerRole_LeftHand = 1,					// Tracked device associated with the left hand
+	TrackedControllerRole_RightHand = 2,				// Tracked device associated with the right hand
+	TrackedControllerRole_OptOut = 3,					// Tracked device is opting out of left/right hand selection
+	TrackedControllerRole_Treadmill = 4,				// Tracked device is a treadmill or other locomotion device
+	TrackedControllerRole_Stylus = 5,					// Tracked device is a stylus
+	TrackedControllerRole_Max = 5
+};
+
+
+/** Returns true if the tracked controller role is allowed to be a hand */
+inline bool IsRoleAllowedAsHand( ETrackedControllerRole eRole )
+{
+	switch ( eRole )
+	{
+	case TrackedControllerRole_Invalid:
+	case TrackedControllerRole_LeftHand:
+	case TrackedControllerRole_RightHand:
+		return true;
+	default:
+		return false;
+	}
+}
+
+
+/** describes a single pose for a tracked object */
+struct TrackedDevicePose_t
+{
+	HmdMatrix34_t mDeviceToAbsoluteTracking;
+	HmdVector3_t vVelocity;				// velocity in tracker space in m/s
+	HmdVector3_t vAngularVelocity;		// angular velocity in radians/s (?)
+	ETrackingResult eTrackingResult;
+	bool bPoseIsValid;
+
+	// This indicates that there is a device connected for this spot in the pose array.
+	// It could go from true to false if the user unplugs the device.
+	bool bDeviceIsConnected;
+};
+
+/** Identifies which style of tracking origin the application wants to use
+* for the poses it is requesting */
+enum ETrackingUniverseOrigin
+{
+	TrackingUniverseSeated = 0,		// Poses are provided relative to the seated zero pose
+	TrackingUniverseStanding = 1,	// Poses are provided relative to the safe bounds configured by the user
+	TrackingUniverseRawAndUncalibrated = 2,	// Poses are provided in the coordinate system defined by the driver.  It has Y up and is unified for devices of the same driver. You usually don't want this one.
+};
+
+enum EAdditionalRadioFeatures
+{
+	AdditionalRadioFeatures_None           = 0x00000000,
+	AdditionalRadioFeatures_HTCLinkBox     = 0x00000001,
+	AdditionalRadioFeatures_InternalDongle = 0x00000002,
+	AdditionalRadioFeatures_ExternalDongle = 0x00000004,
+};
+
+typedef uint64_t WebConsoleHandle_t;
+#define INVALID_WEB_CONSOLE_HANDLE	((vr::WebConsoleHandle_t)0)
+
+// Refers to a single container of properties
+typedef uint64_t PropertyContainerHandle_t;
+typedef uint32_t PropertyTypeTag_t;
+
+static const PropertyContainerHandle_t k_ulInvalidPropertyContainer = 0;
+static const PropertyTypeTag_t k_unInvalidPropertyTag = 0;
+
+typedef PropertyContainerHandle_t DriverHandle_t;
+static const PropertyContainerHandle_t k_ulInvalidDriverHandle = 0;
+
+// Use these tags to set/get common types as struct properties
+static const PropertyTypeTag_t k_unFloatPropertyTag = 1;
+static const PropertyTypeTag_t k_unInt32PropertyTag = 2;
+static const PropertyTypeTag_t k_unUint64PropertyTag = 3;
+static const PropertyTypeTag_t k_unBoolPropertyTag = 4;
+static const PropertyTypeTag_t k_unStringPropertyTag = 5;
+static const PropertyTypeTag_t k_unErrorPropertyTag = 6;
+static const PropertyTypeTag_t k_unDoublePropertyTag = 7;
+
+static const PropertyTypeTag_t k_unHmdMatrix34PropertyTag = 20;
+static const PropertyTypeTag_t k_unHmdMatrix44PropertyTag = 21;
+static const PropertyTypeTag_t k_unHmdVector3PropertyTag = 22;
+static const PropertyTypeTag_t k_unHmdVector4PropertyTag = 23;
+static const PropertyTypeTag_t k_unHmdVector2PropertyTag = 24;
+static const PropertyTypeTag_t k_unHmdQuadPropertyTag = 25;
+
+static const PropertyTypeTag_t k_unHiddenAreaPropertyTag = 30;
+static const PropertyTypeTag_t k_unPathHandleInfoTag = 31;
+static const PropertyTypeTag_t k_unActionPropertyTag = 32;
+static const PropertyTypeTag_t k_unInputValuePropertyTag = 33;
+static const PropertyTypeTag_t k_unWildcardPropertyTag = 34;
+static const PropertyTypeTag_t k_unHapticVibrationPropertyTag = 35;
+static const PropertyTypeTag_t k_unSkeletonPropertyTag = 36;
+
+static const PropertyTypeTag_t k_unSpatialAnchorPosePropertyTag = 40;
+static const PropertyTypeTag_t k_unJsonPropertyTag = 41;
+static const PropertyTypeTag_t k_unActiveActionSetPropertyTag = 42;
+
+static const PropertyTypeTag_t k_unOpenVRInternalReserved_Start = 1000;
+static const PropertyTypeTag_t k_unOpenVRInternalReserved_End = 10000;
+
+
+/** Each entry in this enum represents a property that can be retrieved about a
+* tracked device. Many fields are only valid for one ETrackedDeviceClass. */
+enum ETrackedDeviceProperty
+{
+	Prop_Invalid								= 0,
+
+	// general properties that apply to all device classes
+	Prop_TrackingSystemName_String				= 1000,
+	Prop_ModelNumber_String						= 1001,
+	Prop_SerialNumber_String					= 1002,
+	Prop_RenderModelName_String					= 1003,
+	Prop_WillDriftInYaw_Bool					= 1004,
+	Prop_ManufacturerName_String				= 1005,
+	Prop_TrackingFirmwareVersion_String			= 1006,
+	Prop_HardwareRevision_String				= 1007,
+	Prop_AllWirelessDongleDescriptions_String	= 1008,
+	Prop_ConnectedWirelessDongle_String			= 1009,
+	Prop_DeviceIsWireless_Bool					= 1010,
+	Prop_DeviceIsCharging_Bool					= 1011,
+	Prop_DeviceBatteryPercentage_Float			= 1012, // 0 is empty, 1 is full
+	Prop_StatusDisplayTransform_Matrix34		= 1013,
+	Prop_Firmware_UpdateAvailable_Bool			= 1014,
+	Prop_Firmware_ManualUpdate_Bool				= 1015,
+	Prop_Firmware_ManualUpdateURL_String		= 1016,
+	Prop_HardwareRevision_Uint64				= 1017,
+	Prop_FirmwareVersion_Uint64					= 1018,
+	Prop_FPGAVersion_Uint64						= 1019,
+	Prop_VRCVersion_Uint64						= 1020,
+	Prop_RadioVersion_Uint64					= 1021,
+	Prop_DongleVersion_Uint64					= 1022,
+	Prop_BlockServerShutdown_Bool				= 1023,
+	Prop_CanUnifyCoordinateSystemWithHmd_Bool	= 1024,
+	Prop_ContainsProximitySensor_Bool			= 1025,
+	Prop_DeviceProvidesBatteryStatus_Bool		= 1026,
+	Prop_DeviceCanPowerOff_Bool					= 1027,
+	Prop_Firmware_ProgrammingTarget_String		= 1028,
+	Prop_DeviceClass_Int32						= 1029,
+	Prop_HasCamera_Bool							= 1030,
+	Prop_DriverVersion_String                   = 1031,
+	Prop_Firmware_ForceUpdateRequired_Bool      = 1032,
+	Prop_ViveSystemButtonFixRequired_Bool		= 1033,
+	Prop_ParentDriver_Uint64					= 1034,
+	Prop_ResourceRoot_String					= 1035,
+	Prop_RegisteredDeviceType_String			= 1036,
+	Prop_InputProfilePath_String				= 1037, // input profile to use for this device in the input system. Will default to tracking system name if this isn't provided
+	Prop_NeverTracked_Bool						= 1038, // Used for devices that will never have a valid pose by design
+	Prop_NumCameras_Int32						= 1039,
+	Prop_CameraFrameLayout_Int32				= 1040, // EVRTrackedCameraFrameLayout value
+	Prop_CameraStreamFormat_Int32				= 1041, // ECameraVideoStreamFormat value
+	Prop_AdditionalDeviceSettingsPath_String	= 1042, // driver-relative path to additional device and global configuration settings
+	Prop_Identifiable_Bool						= 1043, // Whether device supports being identified from vrmonitor (e.g. blink LED, vibrate haptics, etc)
+	Prop_BootloaderVersion_Uint64			    = 1044,
+	Prop_AdditionalSystemReportData_String		= 1045, // additional string to include in system reports about a tracked device
+	Prop_CompositeFirmwareVersion_String        = 1046, // additional FW components from a device that gets propagated into reports
+	Prop_Firmware_RemindUpdate_Bool             = 1047,
+	Prop_PeripheralApplicationVersion_Uint64	= 1048,
+	Prop_ManufacturerSerialNumber_String		= 1049,
+	Prop_ComputedSerialNumber_String			= 1050,
+	Prop_EstimatedDeviceFirstUseTime_Int32		= 1051,
+
+	// Properties that are unique to TrackedDeviceClass_HMD
+	Prop_ReportsTimeSinceVSync_Bool				= 2000,
+	Prop_SecondsFromVsyncToPhotons_Float		= 2001,
+	Prop_DisplayFrequency_Float					= 2002,
+	Prop_UserIpdMeters_Float					= 2003,
+	Prop_CurrentUniverseId_Uint64				= 2004, 
+	Prop_PreviousUniverseId_Uint64				= 2005, 
+	Prop_DisplayFirmwareVersion_Uint64			= 2006,
+	Prop_IsOnDesktop_Bool						= 2007,
+	Prop_DisplayMCType_Int32					= 2008,
+	Prop_DisplayMCOffset_Float					= 2009,
+	Prop_DisplayMCScale_Float					= 2010,
+	Prop_EdidVendorID_Int32						= 2011,
+	Prop_DisplayMCImageLeft_String              = 2012,
+	Prop_DisplayMCImageRight_String             = 2013,
+	Prop_DisplayGCBlackClamp_Float				= 2014,
+	Prop_EdidProductID_Int32					= 2015,
+	Prop_CameraToHeadTransform_Matrix34			= 2016,
+	Prop_DisplayGCType_Int32					= 2017,
+	Prop_DisplayGCOffset_Float					= 2018,
+	Prop_DisplayGCScale_Float					= 2019,
+	Prop_DisplayGCPrescale_Float				= 2020,
+	Prop_DisplayGCImage_String					= 2021,
+	Prop_LensCenterLeftU_Float					= 2022,
+	Prop_LensCenterLeftV_Float					= 2023,
+	Prop_LensCenterRightU_Float					= 2024,
+	Prop_LensCenterRightV_Float					= 2025,
+	Prop_UserHeadToEyeDepthMeters_Float			= 2026,
+	Prop_CameraFirmwareVersion_Uint64			= 2027,
+	Prop_CameraFirmwareDescription_String		= 2028,
+	Prop_DisplayFPGAVersion_Uint64				= 2029,
+	Prop_DisplayBootloaderVersion_Uint64		= 2030,
+	Prop_DisplayHardwareVersion_Uint64			= 2031,
+	Prop_AudioFirmwareVersion_Uint64			= 2032,
+	Prop_CameraCompatibilityMode_Int32			= 2033,
+	Prop_ScreenshotHorizontalFieldOfViewDegrees_Float = 2034,
+	Prop_ScreenshotVerticalFieldOfViewDegrees_Float = 2035,
+	Prop_DisplaySuppressed_Bool					= 2036,
+	Prop_DisplayAllowNightMode_Bool				= 2037,
+	Prop_DisplayMCImageWidth_Int32				= 2038,
+	Prop_DisplayMCImageHeight_Int32				= 2039,
+	Prop_DisplayMCImageNumChannels_Int32		= 2040,
+	Prop_DisplayMCImageData_Binary				= 2041,
+	Prop_SecondsFromPhotonsToVblank_Float		= 2042,
+	Prop_DriverDirectModeSendsVsyncEvents_Bool	= 2043,
+	Prop_DisplayDebugMode_Bool					= 2044,
+	Prop_GraphicsAdapterLuid_Uint64				= 2045,
+	Prop_DriverProvidedChaperonePath_String		= 2048,
+	Prop_ExpectedTrackingReferenceCount_Int32	= 2049, // expected number of sensors or basestations to reserve UI space for
+	Prop_ExpectedControllerCount_Int32			= 2050, // expected number of tracked controllers to reserve UI space for
+	Prop_NamedIconPathControllerLeftDeviceOff_String	= 2051, // placeholder icon for "left" controller if not yet detected/loaded
+	Prop_NamedIconPathControllerRightDeviceOff_String	= 2052, // placeholder icon for "right" controller if not yet detected/loaded
+	Prop_NamedIconPathTrackingReferenceDeviceOff_String	= 2053, // placeholder icon for sensor/base if not yet detected/loaded
+	Prop_DoNotApplyPrediction_Bool				= 2054, // currently no effect. was used to disable HMD pose prediction on MR, which is now done by MR driver setting velocity=0
+	Prop_CameraToHeadTransforms_Matrix34_Array	= 2055,
+	Prop_DistortionMeshResolution_Int32			= 2056, // custom resolution of compositor calls to IVRSystem::ComputeDistortion
+	Prop_DriverIsDrawingControllers_Bool		= 2057,
+	Prop_DriverRequestsApplicationPause_Bool	= 2058,
+	Prop_DriverRequestsReducedRendering_Bool	= 2059,
+	Prop_MinimumIpdStepMeters_Float				= 2060,
+	Prop_AudioBridgeFirmwareVersion_Uint64		= 2061,
+	Prop_ImageBridgeFirmwareVersion_Uint64		= 2062,
+	Prop_ImuToHeadTransform_Matrix34			= 2063,
+	Prop_ImuFactoryGyroBias_Vector3				= 2064,
+	Prop_ImuFactoryGyroScale_Vector3			= 2065,
+	Prop_ImuFactoryAccelerometerBias_Vector3	= 2066,
+	Prop_ImuFactoryAccelerometerScale_Vector3	= 2067,
+	// reserved 2068
+	Prop_ConfigurationIncludesLighthouse20Features_Bool = 2069,
+	Prop_AdditionalRadioFeatures_Uint64         = 2070,
+	Prop_CameraWhiteBalance_Vector4_Array		= 2071, // Prop_NumCameras_Int32-sized array of float[4] RGBG white balance calibration data (max size is vr::k_unMaxCameras)
+	Prop_CameraDistortionFunction_Int32_Array	= 2072, // Prop_NumCameras_Int32-sized array of vr::EVRDistortionFunctionType values (max size is vr::k_unMaxCameras)
+	Prop_CameraDistortionCoefficients_Float_Array = 2073, // Prop_NumCameras_Int32-sized array of double[vr::k_unMaxDistortionFunctionParameters] (max size is vr::k_unMaxCameras)
+	Prop_ExpectedControllerType_String			= 2074,
+	Prop_HmdTrackingStyle_Int32					= 2075, // one of EHmdTrackingStyle
+	Prop_DriverProvidedChaperoneVisibility_Bool = 2076,
+	Prop_HmdColumnCorrectionSettingPrefix_String = 2077,
+	Prop_CameraSupportsCompatibilityModes_Bool	= 2078,
+
+	Prop_DisplayAvailableFrameRates_Float_Array = 2080, // populated by compositor from actual EDID list when available from GPU driver
+	Prop_DisplaySupportsMultipleFramerates_Bool = 2081, // if this is true but Prop_DisplayAvailableFrameRates_Float_Array is empty, explain to user
+	Prop_DisplayColorMultLeft_Vector3			= 2082,
+	Prop_DisplayColorMultRight_Vector3			= 2083,
+	Prop_DisplaySupportsRuntimeFramerateChange_Bool = 2084,
+	Prop_DisplaySupportsAnalogGain_Bool 		= 2085,
+	Prop_DisplayMinAnalogGain_Float 			= 2086,
+	Prop_DisplayMaxAnalogGain_Float 			= 2087,
+
+	// Prop_DashboardLayoutPathName_String 		= 2090, // DELETED
+	Prop_DashboardScale_Float 					= 2091,
+	Prop_IpdUIRangeMinMeters_Float 				= 2100,
+	Prop_IpdUIRangeMaxMeters_Float 				= 2101,
+
+	// Driver requested mura correction properties
+	Prop_DriverRequestedMuraCorrectionMode_Int32		= 2200,
+	Prop_DriverRequestedMuraFeather_InnerLeft_Int32		= 2201,
+	Prop_DriverRequestedMuraFeather_InnerRight_Int32	= 2202,
+	Prop_DriverRequestedMuraFeather_InnerTop_Int32		= 2203,
+	Prop_DriverRequestedMuraFeather_InnerBottom_Int32	= 2204,
+	Prop_DriverRequestedMuraFeather_OuterLeft_Int32		= 2205,
+	Prop_DriverRequestedMuraFeather_OuterRight_Int32	= 2206,
+	Prop_DriverRequestedMuraFeather_OuterTop_Int32		= 2207,
+	Prop_DriverRequestedMuraFeather_OuterBottom_Int32	= 2208,
+
+	Prop_Audio_DefaultPlaybackDeviceId_String		= 2300,
+	Prop_Audio_DefaultRecordingDeviceId_String		= 2301,
+	Prop_Audio_DefaultPlaybackDeviceVolume_Float	= 2302,
+
+	// Properties that are unique to TrackedDeviceClass_Controller
+	Prop_AttachedDeviceId_String				= 3000,
+	Prop_SupportedButtons_Uint64				= 3001,
+	Prop_Axis0Type_Int32						= 3002, // Return value is of type EVRControllerAxisType
+	Prop_Axis1Type_Int32						= 3003, // Return value is of type EVRControllerAxisType
+	Prop_Axis2Type_Int32						= 3004, // Return value is of type EVRControllerAxisType
+	Prop_Axis3Type_Int32						= 3005, // Return value is of type EVRControllerAxisType
+	Prop_Axis4Type_Int32						= 3006, // Return value is of type EVRControllerAxisType
+	Prop_ControllerRoleHint_Int32				= 3007, // Return value is of type ETrackedControllerRole
+
+	// Properties that are unique to TrackedDeviceClass_TrackingReference
+	Prop_FieldOfViewLeftDegrees_Float			= 4000,
+	Prop_FieldOfViewRightDegrees_Float			= 4001,
+	Prop_FieldOfViewTopDegrees_Float			= 4002,
+	Prop_FieldOfViewBottomDegrees_Float			= 4003,
+	Prop_TrackingRangeMinimumMeters_Float		= 4004,
+	Prop_TrackingRangeMaximumMeters_Float		= 4005,
+	Prop_ModeLabel_String						= 4006,
+	Prop_CanWirelessIdentify_Bool               = 4007, // volatile, based on radio presence and fw discovery
+	Prop_Nonce_Int32                            = 4008,
+
+	// Properties that are used for user interface like icons names
+	Prop_IconPathName_String						= 5000, // DEPRECATED. Value not referenced. Now expected to be part of icon path properties.
+	Prop_NamedIconPathDeviceOff_String				= 5001, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceSearching_String		= 5002, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceSearchingAlert_String	= 5003, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceReady_String			= 5004, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceReadyAlert_String		= 5005, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceNotReady_String			= 5006, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceStandby_String			= 5007, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceAlertLow_String			= 5008, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceStandbyAlert_String		= 5009, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+
+	// Properties that are used by helpers, but are opaque to applications
+	Prop_DisplayHiddenArea_Binary_Start				= 5100,
+	Prop_DisplayHiddenArea_Binary_End				= 5150,
+	Prop_ParentContainer							= 5151,
+	Prop_OverrideContainer_Uint64					= 5152,
+
+	// Properties that are unique to drivers
+	Prop_UserConfigPath_String					= 6000,
+	Prop_InstallPath_String						= 6001,
+	Prop_HasDisplayComponent_Bool				= 6002,
+	Prop_HasControllerComponent_Bool			= 6003,
+	Prop_HasCameraComponent_Bool				= 6004,
+	Prop_HasDriverDirectModeComponent_Bool		= 6005,
+	Prop_HasVirtualDisplayComponent_Bool		= 6006,
+	Prop_HasSpatialAnchorsSupport_Bool		    = 6007,
+
+	// Properties that are set internally based on other information provided by drivers
+	Prop_ControllerType_String					= 7000,
+	//Prop_LegacyInputProfile_String				= 7001, // This is no longer used. See "legacy_binding" in the input profile instead.
+	Prop_ControllerHandSelectionPriority_Int32	= 7002, // Allows hand assignments to prefer some controllers over others. High numbers are selected over low numbers
+
+	// Vendors are free to expose private debug data in this reserved region
+	Prop_VendorSpecific_Reserved_Start			= 10000,
+	Prop_VendorSpecific_Reserved_End			= 10999,
+	
+	Prop_TrackedDeviceProperty_Max				= 1000000,
+};
+
+/** No string property will ever be longer than this length */
+static const uint32_t k_unMaxPropertyStringSize = 32 * 1024;
+
+/** Used to return errors that occur when reading properties. */
+enum ETrackedPropertyError
+{
+	TrackedProp_Success						= 0,
+	TrackedProp_WrongDataType				= 1,
+	TrackedProp_WrongDeviceClass			= 2,
+	TrackedProp_BufferTooSmall				= 3,
+	TrackedProp_UnknownProperty				= 4, // Driver has not set the property (and may not ever).
+	TrackedProp_InvalidDevice				= 5,
+	TrackedProp_CouldNotContactServer		= 6,
+	TrackedProp_ValueNotProvidedByDevice	= 7,
+	TrackedProp_StringExceedsMaximumLength	= 8,
+	TrackedProp_NotYetAvailable				= 9, // The property value isn't known yet, but is expected soon. Call again later.
+	TrackedProp_PermissionDenied			= 10,
+	TrackedProp_InvalidOperation			= 11,
+	TrackedProp_CannotWriteToWildcards		= 12,
+	TrackedProp_IPCReadFailure				= 13,
+	TrackedProp_OutOfMemory					= 14,
+	TrackedProp_InvalidContainer			= 15,
+};
+
+/** Used to drive certain text in the UI when talking about the tracking system for the HMD */
+enum EHmdTrackingStyle
+{
+	HmdTrackingStyle_Unknown				= 0,
+
+	HmdTrackingStyle_Lighthouse				= 1, // base stations and lasers
+	HmdTrackingStyle_OutsideInCameras		= 2, // Cameras and LED, Rift 1 style
+	HmdTrackingStyle_InsideOutCameras		= 3, // Cameras on HMD looking at the world
+};
+
+typedef uint64_t VRActionHandle_t;
+typedef uint64_t VRActionSetHandle_t;
+typedef uint64_t VRInputValueHandle_t;
+
+static const VRActionHandle_t k_ulInvalidActionHandle = 0;
+static const VRActionSetHandle_t k_ulInvalidActionSetHandle = 0;
+static const VRInputValueHandle_t k_ulInvalidInputValueHandle = 0;
+
+
+/** Allows the application to control what part of the provided texture will be used in the
+* frame buffer. */
+struct VRTextureBounds_t
+{
+	float uMin, vMin;
+	float uMax, vMax;
+};
+
+/** Allows specifying pose used to render provided scene texture (if different from value returned by WaitGetPoses). */
+struct VRTextureWithPose_t : public Texture_t
+{
+	HmdMatrix34_t mDeviceToAbsoluteTracking; // Actual pose used to render scene textures.
+};
+
+struct VRTextureDepthInfo_t
+{
+	void* handle; // See ETextureType definition above
+	HmdMatrix44_t mProjection;
+	HmdVector2_t vRange; // 0..1
+};
+
+struct VRTextureWithDepth_t : public Texture_t
+{
+	VRTextureDepthInfo_t depth;
+};
+
+struct VRTextureWithPoseAndDepth_t : public VRTextureWithPose_t
+{
+	VRTextureDepthInfo_t depth;
+};
+
+/** Allows the application to control how scene textures are used by the compositor when calling Submit. */
+enum EVRSubmitFlags
+{
+	// Simple render path. App submits rendered left and right eye images with no lens distortion correction applied.
+	Submit_Default = 0x00,
+
+	// App submits final left and right eye images with lens distortion already applied (lens distortion makes the images appear
+	// barrel distorted with chromatic aberration correction applied). The app would have used the data returned by
+	// vr::IVRSystem::ComputeDistortion() to apply the correct distortion to the rendered images before calling Submit().
+	Submit_LensDistortionAlreadyApplied = 0x01,
+
+	// If the texture pointer passed in is actually a renderbuffer (e.g. for MSAA in OpenGL) then set this flag.
+	Submit_GlRenderBuffer = 0x02,
+
+	// Do not use
+	Submit_Reserved = 0x04,
+
+	// Set to indicate that pTexture is a pointer to a VRTextureWithPose_t.
+	// This flag can be combined with Submit_TextureWithDepth to pass a VRTextureWithPoseAndDepth_t.
+	Submit_TextureWithPose = 0x08,
+
+	// Set to indicate that pTexture is a pointer to a VRTextureWithDepth_t.
+	// This flag can be combined with Submit_TextureWithPose to pass a VRTextureWithPoseAndDepth_t.
+	Submit_TextureWithDepth = 0x10,
+
+	// Set to indicate a discontinuity between this and the last frame.
+	// This will prevent motion smoothing from attempting to extrapolate using the pair.
+	Submit_FrameDiscontinuty = 0x20,
+};
+
+/** Data required for passing Vulkan textures to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. 
+* Please see https://github.com/ValveSoftware/openvr/wiki/Vulkan for Vulkan-specific documentation */
+struct VRVulkanTextureData_t
+{
+	uint64_t m_nImage; // VkImage
+	VkDevice_T *m_pDevice;
+	VkPhysicalDevice_T *m_pPhysicalDevice;
+	VkInstance_T *m_pInstance;
+	VkQueue_T *m_pQueue;
+	uint32_t m_nQueueFamilyIndex;
+	uint32_t m_nWidth, m_nHeight, m_nFormat, m_nSampleCount;
+};
+
+/** Data required for passing D3D12 textures to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. */
+struct D3D12TextureData_t
+{
+	ID3D12Resource *m_pResource;
+	ID3D12CommandQueue *m_pCommandQueue;
+	uint32_t m_nNodeMask;
+};
+
+/** Status of the overall system or tracked objects */
+enum EVRState
+{
+	VRState_Undefined = -1,
+	VRState_Off = 0,
+	VRState_Searching = 1,
+	VRState_Searching_Alert = 2,
+	VRState_Ready = 3,
+	VRState_Ready_Alert = 4,
+	VRState_NotReady = 5,
+	VRState_Standby = 6,
+	VRState_Ready_Alert_Low = 7,
+};
+
+/** The types of events that could be posted (and what the parameters mean for each event type) */
+enum EVREventType
+{
+	VREvent_None = 0,
+
+	VREvent_TrackedDeviceActivated		= 100,
+	VREvent_TrackedDeviceDeactivated	= 101,
+	VREvent_TrackedDeviceUpdated		= 102,
+	VREvent_TrackedDeviceUserInteractionStarted	= 103,
+	VREvent_TrackedDeviceUserInteractionEnded	= 104,
+	VREvent_IpdChanged					= 105,
+	VREvent_EnterStandbyMode			= 106,
+	VREvent_LeaveStandbyMode			= 107,
+	VREvent_TrackedDeviceRoleChanged	= 108,
+	VREvent_WatchdogWakeUpRequested		= 109,
+	VREvent_LensDistortionChanged		= 110,
+	VREvent_PropertyChanged				= 111,
+	VREvent_WirelessDisconnect			= 112,
+	VREvent_WirelessReconnect			= 113,
+
+	VREvent_ButtonPress					= 200, // data is controller
+	VREvent_ButtonUnpress				= 201, // data is controller
+	VREvent_ButtonTouch					= 202, // data is controller
+	VREvent_ButtonUntouch				= 203, // data is controller
+
+	// VREvent_DualAnalog_Press			= 250, // No longer sent
+	// VREvent_DualAnalog_Unpress		= 251, // No longer sent
+	// VREvent_DualAnalog_Touch			= 252, // No longer sent
+	// VREvent_DualAnalog_Untouch		= 253, // No longer sent
+	// VREvent_DualAnalog_Move			= 254, // No longer sent
+	// VREvent_DualAnalog_ModeSwitch1	= 255, // No longer sent
+	// VREvent_DualAnalog_ModeSwitch2	= 256, // No longer sent
+	VREvent_Modal_Cancel				= 257, // Sent to overlays with the 
+
+	VREvent_MouseMove					= 300, // data is mouse
+	VREvent_MouseButtonDown				= 301, // data is mouse
+	VREvent_MouseButtonUp				= 302, // data is mouse
+	VREvent_FocusEnter					= 303, // data is overlay
+	VREvent_FocusLeave					= 304, // data is overlay
+	VREvent_ScrollDiscrete				= 305, // data is scroll
+	VREvent_TouchPadMove				= 306, // data is mouse
+	VREvent_OverlayFocusChanged			= 307, // data is overlay, global event
+	VREvent_ReloadOverlays				= 308, 
+	VREvent_ScrollSmooth				= 309, // data is scroll
+	VREvent_LockMousePosition			= 310,
+	VREvent_UnlockMousePosition			= 311,
+
+	VREvent_InputFocusCaptured			= 400, // data is process DEPRECATED
+	VREvent_InputFocusReleased			= 401, // data is process DEPRECATED
+	// VREvent_SceneFocusLost			= 402, // data is process
+	// VREvent_SceneFocusGained			= 403, // data is process
+	VREvent_SceneApplicationChanged		= 404, // data is process - The App actually drawing the scene changed (usually to or from the compositor)
+	VREvent_SceneFocusChanged			= 405, // data is process - New app got access to draw the scene
+	VREvent_InputFocusChanged			= 406, // data is process
+	// VREvent_SceneApplicationSecondaryRenderingStarted = 407,
+	VREvent_SceneApplicationUsingWrongGraphicsAdapter = 408, // data is process
+	VREvent_ActionBindingReloaded		 = 409, // data is process - The App that action binds reloaded for
+
+	VREvent_HideRenderModels			= 410, // Sent to the scene application to request hiding render models temporarily
+	VREvent_ShowRenderModels			= 411, // Sent to the scene application to request restoring render model visibility
+
+	VREvent_SceneApplicationStateChanged = 412, // No data; but query VRApplications()->GetSceneApplicationState();
+
+	VREvent_ConsoleOpened               = 420,
+	VREvent_ConsoleClosed               = 421,
+
+	VREvent_OverlayShown				= 500,
+	VREvent_OverlayHidden				= 501,
+	VREvent_DashboardActivated			= 502,
+	VREvent_DashboardDeactivated		= 503,
+	//VREvent_DashboardThumbSelected		= 504, // Sent to the overlay manager - data is overlay - No longer sent
+	VREvent_DashboardRequested			= 505, // Sent to the overlay manager - data is overlay
+	VREvent_ResetDashboard				= 506, // Send to the overlay manager
+	//VREvent_RenderToast					= 507, // Send to the dashboard to render a toast - data is the notification ID -- no longer sent
+	VREvent_ImageLoaded					= 508, // Sent to overlays when a SetOverlayRaw or SetOverlayFromFile call finishes loading
+	VREvent_ShowKeyboard				= 509, // Sent to keyboard renderer in the dashboard to invoke it
+	VREvent_HideKeyboard				= 510, // Sent to keyboard renderer in the dashboard to hide it
+	VREvent_OverlayGamepadFocusGained	= 511, // Sent to an overlay when IVROverlay::SetFocusOverlay is called on it
+	VREvent_OverlayGamepadFocusLost		= 512, // Send to an overlay when it previously had focus and IVROverlay::SetFocusOverlay is called on something else
+	VREvent_OverlaySharedTextureChanged = 513,
+	//VREvent_DashboardGuideButtonDown	= 514, // These are no longer sent
+	//VREvent_DashboardGuideButtonUp		= 515,
+	VREvent_ScreenshotTriggered			= 516, // Screenshot button combo was pressed, Dashboard should request a screenshot
+	VREvent_ImageFailed					= 517, // Sent to overlays when a SetOverlayRaw or SetOverlayfromFail fails to load
+	VREvent_DashboardOverlayCreated		= 518,
+	VREvent_SwitchGamepadFocus			= 519,
+
+	// Screenshot API
+	VREvent_RequestScreenshot				= 520, // Sent by vrclient application to compositor to take a screenshot
+	VREvent_ScreenshotTaken					= 521, // Sent by compositor to the application that the screenshot has been taken
+	VREvent_ScreenshotFailed				= 522, // Sent by compositor to the application that the screenshot failed to be taken
+	VREvent_SubmitScreenshotToDashboard		= 523, // Sent by compositor to the dashboard that a completed screenshot was submitted
+	VREvent_ScreenshotProgressToDashboard	= 524, // Sent by compositor to the dashboard that a completed screenshot was submitted
+
+	VREvent_PrimaryDashboardDeviceChanged	= 525,
+	VREvent_RoomViewShown					= 526, // Sent by compositor whenever room-view is enabled
+	VREvent_RoomViewHidden					= 527, // Sent by compositor whenever room-view is disabled
+	VREvent_ShowUI							= 528, // data is showUi
+	VREvent_ShowDevTools					= 529, // data is showDevTools
+
+	VREvent_Notification_Shown				= 600,
+	VREvent_Notification_Hidden				= 601,
+	VREvent_Notification_BeginInteraction	= 602,
+	VREvent_Notification_Destroyed			= 603,
+
+	VREvent_Quit							= 700, // data is process
+	VREvent_ProcessQuit						= 701, // data is process
+	//VREvent_QuitAborted_UserPrompt			= 702, // data is process
+	VREvent_QuitAcknowledged				= 703, // data is process
+	VREvent_DriverRequestedQuit				= 704, // The driver has requested that SteamVR shut down
+	VREvent_RestartRequested				= 705, // A driver or other component wants the user to restart SteamVR
+
+	VREvent_ChaperoneDataHasChanged			= 800, // this will never happen with the new chaperone system
+	VREvent_ChaperoneUniverseHasChanged		= 801,
+	VREvent_ChaperoneTempDataHasChanged		= 802, // this will never happen with the new chaperone system
+	VREvent_ChaperoneSettingsHaveChanged	= 803,
+	VREvent_SeatedZeroPoseReset				= 804,
+	VREvent_ChaperoneFlushCache				= 805, // Sent when the process needs to reload any cached data it retrieved from VRChaperone()
+	VREvent_ChaperoneRoomSetupStarting	    = 806, // Triggered by CVRChaperoneClient::RoomSetupStarting
+	VREvent_ChaperoneRoomSetupFinished	    = 807, // Triggered by CVRChaperoneClient::CommitWorkingCopy
+
+	VREvent_AudioSettingsHaveChanged		= 820,
+
+	VREvent_BackgroundSettingHasChanged				= 850,
+	VREvent_CameraSettingsHaveChanged				= 851,
+	VREvent_ReprojectionSettingHasChanged			= 852,
+	VREvent_ModelSkinSettingsHaveChanged			= 853,
+	VREvent_EnvironmentSettingsHaveChanged			= 854,
+	VREvent_PowerSettingsHaveChanged				= 855,
+	VREvent_EnableHomeAppSettingsHaveChanged		= 856,
+	VREvent_SteamVRSectionSettingChanged			= 857,
+	VREvent_LighthouseSectionSettingChanged			= 858,
+	VREvent_NullSectionSettingChanged				= 859,
+	VREvent_UserInterfaceSectionSettingChanged		= 860,
+	VREvent_NotificationsSectionSettingChanged		= 861,
+	VREvent_KeyboardSectionSettingChanged			= 862,
+	VREvent_PerfSectionSettingChanged				= 863,
+	VREvent_DashboardSectionSettingChanged			= 864,
+	VREvent_WebInterfaceSectionSettingChanged		= 865,
+	VREvent_TrackersSectionSettingChanged			= 866,
+	VREvent_LastKnownSectionSettingChanged			= 867,
+	VREvent_DismissedWarningsSectionSettingChanged	= 868,
+	VREvent_GpuSpeedSectionSettingChanged			= 869,
+	VREvent_WindowsMRSectionSettingChanged			= 870,
+	VREvent_OtherSectionSettingChanged				= 871,
+
+	VREvent_StatusUpdate					= 900,
+
+	VREvent_WebInterface_InstallDriverCompleted = 950,
+
+	VREvent_MCImageUpdated					= 1000,
+
+	VREvent_FirmwareUpdateStarted			= 1100,
+	VREvent_FirmwareUpdateFinished			= 1101,
+
+	VREvent_KeyboardClosed					= 1200,
+	VREvent_KeyboardCharInput				= 1201,
+	VREvent_KeyboardDone					= 1202, // Sent when DONE button clicked on keyboard
+
+	//VREvent_ApplicationTransitionStarted		= 1300,
+	//VREvent_ApplicationTransitionAborted		= 1301,
+	//VREvent_ApplicationTransitionNewAppStarted	= 1302,
+	VREvent_ApplicationListUpdated				= 1303,
+	VREvent_ApplicationMimeTypeLoad				= 1304,
+	// VREvent_ApplicationTransitionNewAppLaunchComplete = 1305,
+	VREvent_ProcessConnected					= 1306,
+	VREvent_ProcessDisconnected					= 1307,
+
+	//VREvent_Compositor_MirrorWindowShown		= 1400, // DEPRECATED
+	//VREvent_Compositor_MirrorWindowHidden		= 1401, // DEPRECATED
+	VREvent_Compositor_ChaperoneBoundsShown		= 1410,
+	VREvent_Compositor_ChaperoneBoundsHidden	= 1411,
+	VREvent_Compositor_DisplayDisconnected		= 1412,
+	VREvent_Compositor_DisplayReconnected		= 1413,
+	VREvent_Compositor_HDCPError				= 1414, // data is hdcpError
+	VREvent_Compositor_ApplicationNotResponding	= 1415,
+	VREvent_Compositor_ApplicationResumed		= 1416,
+	VREvent_Compositor_OutOfVideoMemory			= 1417,
+	VREvent_Compositor_DisplayModeNotSupported	= 1418, // k_pch_SteamVR_PreferredRefreshRate
+	VREvent_Compositor_StageOverrideReady		= 1419,
+
+	VREvent_TrackedCamera_StartVideoStream  = 1500,
+	VREvent_TrackedCamera_StopVideoStream   = 1501,
+	VREvent_TrackedCamera_PauseVideoStream  = 1502,
+	VREvent_TrackedCamera_ResumeVideoStream = 1503,
+	VREvent_TrackedCamera_EditingSurface    = 1550,
+
+	VREvent_PerformanceTest_EnableCapture	= 1600,
+	VREvent_PerformanceTest_DisableCapture	= 1601,
+	VREvent_PerformanceTest_FidelityLevel	= 1602,
+
+	VREvent_MessageOverlay_Closed			= 1650,
+	VREvent_MessageOverlayCloseRequested	= 1651,
+	
+	VREvent_Input_HapticVibration			= 1700, // data is hapticVibration
+	VREvent_Input_BindingLoadFailed			= 1701, // data is inputBinding
+	VREvent_Input_BindingLoadSuccessful		= 1702, // data is inputBinding
+	VREvent_Input_ActionManifestReloaded	= 1703, // no data
+	VREvent_Input_ActionManifestLoadFailed	= 1704, // data is actionManifest
+	VREvent_Input_ProgressUpdate			= 1705, // data is progressUpdate
+	VREvent_Input_TrackerActivated			= 1706,
+	VREvent_Input_BindingsUpdated			= 1707,
+	VREvent_Input_BindingSubscriptionChanged = 1708,
+
+	VREvent_SpatialAnchors_PoseUpdated		= 1800,        // data is spatialAnchor. broadcast
+	VREvent_SpatialAnchors_DescriptorUpdated = 1801,       // data is spatialAnchor. broadcast
+	VREvent_SpatialAnchors_RequestPoseUpdate = 1802,       // data is spatialAnchor. sent to specific driver
+	VREvent_SpatialAnchors_RequestDescriptorUpdate = 1803, // data is spatialAnchor. sent to specific driver
+
+	VREvent_SystemReport_Started			= 1900, // user or system initiated generation of a system report. broadcast
+
+	VREvent_Monitor_ShowHeadsetView			= 2000, // data is process
+	VREvent_Monitor_HideHeadsetView			= 2001, // data is process
+
+	// Vendors are free to expose private events in this reserved region
+	VREvent_VendorSpecific_Reserved_Start	= 10000,
+	VREvent_VendorSpecific_Reserved_End		= 19999,
+};
+
+
+/** Level of Hmd activity */
+// UserInteraction_Timeout means the device is in the process of timing out.
+// InUse = ( k_EDeviceActivityLevel_UserInteraction || k_EDeviceActivityLevel_UserInteraction_Timeout )
+// VREvent_TrackedDeviceUserInteractionStarted fires when the devices transitions from Standby -> UserInteraction or Idle -> UserInteraction.
+// VREvent_TrackedDeviceUserInteractionEnded fires when the devices transitions from UserInteraction_Timeout -> Idle
+enum EDeviceActivityLevel
+{	
+	k_EDeviceActivityLevel_Unknown = -1,									
+	k_EDeviceActivityLevel_Idle = 0,						// No activity for the last 10 seconds
+	k_EDeviceActivityLevel_UserInteraction = 1,				// Activity (movement or prox sensor) is happening now	
+	k_EDeviceActivityLevel_UserInteraction_Timeout = 2,		// No activity for the last 0.5 seconds
+	k_EDeviceActivityLevel_Standby = 3,						// Idle for at least 5 seconds (configurable in Settings -> Power Management)
+	k_EDeviceActivityLevel_Idle_Timeout = 4,
+};
+
+
+/** VR controller button and axis IDs */
+enum EVRButtonId
+{
+	k_EButton_System			= 0,
+	k_EButton_ApplicationMenu	= 1,
+	k_EButton_Grip				= 2,
+	k_EButton_DPad_Left			= 3,
+	k_EButton_DPad_Up			= 4,
+	k_EButton_DPad_Right		= 5,
+	k_EButton_DPad_Down			= 6,
+	k_EButton_A					= 7,
+	
+	k_EButton_ProximitySensor   = 31,
+
+	k_EButton_Axis0				= 32,
+	k_EButton_Axis1				= 33,
+	k_EButton_Axis2				= 34,
+	k_EButton_Axis3				= 35,
+	k_EButton_Axis4				= 36,
+
+	// aliases for well known controllers
+	k_EButton_SteamVR_Touchpad	= k_EButton_Axis0,
+	k_EButton_SteamVR_Trigger	= k_EButton_Axis1,
+
+	k_EButton_Dashboard_Back	= k_EButton_Grip,
+
+	k_EButton_IndexController_A		= k_EButton_Grip,
+	k_EButton_IndexController_B		= k_EButton_ApplicationMenu,
+	k_EButton_IndexController_JoyStick	= k_EButton_Axis3,
+
+	k_EButton_Max				= 64
+};
+
+inline uint64_t ButtonMaskFromId( EVRButtonId id ) { return 1ull << id; }
+
+/** used for controller button events */
+struct VREvent_Controller_t
+{
+	uint32_t button; // EVRButtonId enum
+};
+
+
+/** used for simulated mouse events in overlay space */
+enum EVRMouseButton
+{
+	VRMouseButton_Left					= 0x0001,
+	VRMouseButton_Right					= 0x0002,
+	VRMouseButton_Middle				= 0x0004,
+};
+
+
+/** used for simulated mouse events in overlay space */
+struct VREvent_Mouse_t
+{
+	float x, y; // co-ords are in GL space, bottom left of the texture is 0,0
+	uint32_t button; // EVRMouseButton enum
+};
+
+/** used for simulated mouse wheel scroll */
+struct VREvent_Scroll_t
+{
+	float xdelta, ydelta;
+	uint32_t unused;
+	float viewportscale; // For scrolling on an overlay with laser mouse, this is the overlay's vertical size relative to the overlay height. Range: [0,1]
+};
+
+/** when in mouse input mode you can receive data from the touchpad, these events are only sent if the users finger
+   is on the touchpad (or just released from it). These events are sent to overlays with the VROverlayFlags_SendVRTouchpadEvents
+   flag set.
+**/
+struct VREvent_TouchPadMove_t
+{
+	// true if the users finger is detected on the touch pad
+	bool bFingerDown;
+
+	// How long the finger has been down in seconds
+	float flSecondsFingerDown;
+
+	// These values indicate the starting finger position (so you can do some basic swipe stuff)
+	float fValueXFirst;
+	float fValueYFirst;
+
+	// This is the raw sampled coordinate without deadzoning
+	float fValueXRaw;
+	float fValueYRaw;
+};
+
+/** notification related events. Details will still change at this point */
+struct VREvent_Notification_t
+{
+	uint64_t ulUserValue;
+	uint32_t notificationId;
+};
+
+/** Used for events about processes */
+struct VREvent_Process_t
+{
+	uint32_t pid;
+	uint32_t oldPid;
+	bool bForced;
+	// If the associated event was triggered by a connection loss
+	bool bConnectionLost;
+};
+
+
+/** Used for a few events about overlays */
+struct VREvent_Overlay_t
+{
+	uint64_t overlayHandle;
+	uint64_t devicePath;
+};
+
+
+/** Used for a few events about overlays */
+struct VREvent_Status_t
+{
+	uint32_t statusState; // EVRState enum
+};
+
+/** Used for keyboard events **/
+struct VREvent_Keyboard_t
+{
+	char cNewInput[8];	// Up to 11 bytes of new input
+	uint64_t uUserValue;	// Possible flags about the new input
+};
+
+struct VREvent_Ipd_t
+{
+	float ipdMeters;
+};
+
+struct VREvent_Chaperone_t
+{
+	uint64_t m_nPreviousUniverse;
+	uint64_t m_nCurrentUniverse;
+};
+
+/** Not actually used for any events */
+struct VREvent_Reserved_t
+{
+	uint64_t reserved0;
+	uint64_t reserved1;
+	uint64_t reserved2;
+	uint64_t reserved3;
+	uint64_t reserved4;
+	uint64_t reserved5;
+};
+
+struct VREvent_PerformanceTest_t
+{
+	uint32_t m_nFidelityLevel;
+};
+
+struct VREvent_SeatedZeroPoseReset_t
+{
+	bool bResetBySystemMenu;
+};
+
+struct VREvent_Screenshot_t
+{
+	uint32_t handle;
+	uint32_t type;
+};
+
+struct VREvent_ScreenshotProgress_t
+{
+	float progress;
+};
+
+struct VREvent_ApplicationLaunch_t
+{
+	uint32_t pid;
+	uint32_t unArgsHandle;
+};
+
+struct VREvent_EditingCameraSurface_t
+{
+	uint64_t overlayHandle;
+	uint32_t nVisualMode;
+};
+
+struct VREvent_MessageOverlay_t
+{
+	uint32_t unVRMessageOverlayResponse; // vr::VRMessageOverlayResponse enum
+};
+
+struct VREvent_Property_t
+{
+	PropertyContainerHandle_t container;
+	ETrackedDeviceProperty prop;
+};
+
+struct VREvent_HapticVibration_t
+{
+	uint64_t containerHandle; // property container handle of the device with the haptic component
+	uint64_t componentHandle; // Which haptic component needs to vibrate
+	float fDurationSeconds;
+	float fFrequency;
+	float fAmplitude;
+};
+
+struct VREvent_WebConsole_t
+{
+	WebConsoleHandle_t webConsoleHandle;
+};
+
+struct VREvent_InputBindingLoad_t
+{
+	vr::PropertyContainerHandle_t ulAppContainer;
+	uint64_t pathMessage;
+	uint64_t pathUrl;
+	uint64_t pathControllerType;
+};
+
+struct VREvent_InputActionManifestLoad_t
+{
+	uint64_t pathAppKey;
+	uint64_t pathMessage;
+	uint64_t pathMessageParam;
+	uint64_t pathManifestPath;
+};
+
+struct VREvent_SpatialAnchor_t
+{
+	SpatialAnchorHandle_t unHandle;
+};
+
+struct VREvent_ProgressUpdate_t
+{
+	uint64_t ulApplicationPropertyContainer;
+	uint64_t pathDevice;
+	uint64_t pathInputSource;
+	uint64_t pathProgressAction;
+	uint64_t pathIcon;
+	float fProgress;
+};
+
+enum EShowUIType
+{
+	ShowUI_ControllerBinding = 0,
+	ShowUI_ManageTrackers = 1,
+	// ShowUI_QuickStart = 2, // Deprecated
+	ShowUI_Pairing = 3,
+	ShowUI_Settings = 4,
+	ShowUI_DebugCommands = 5,
+	ShowUI_FullControllerBinding = 6,
+	ShowUI_ManageDrivers = 7,
+};
+
+struct VREvent_ShowUI_t
+{
+	EShowUIType eType;
+};
+
+struct VREvent_ShowDevTools_t
+{
+	int32_t nBrowserIdentifier;
+};
+
+enum EHDCPError
+{
+	HDCPError_None = 0,
+	HDCPError_LinkLost = 1,
+	HDCPError_Tampered = 2,
+	HDCPError_DeviceRevoked = 3,
+	HDCPError_Unknown = 4
+};
+
+struct VREvent_HDCPError_t
+{
+	EHDCPError eCode;
+};
+
+typedef union
+{
+	VREvent_Reserved_t reserved;
+	VREvent_Controller_t controller;
+	VREvent_Mouse_t mouse;
+	VREvent_Scroll_t scroll;
+	VREvent_Process_t process;
+	VREvent_Notification_t notification;
+	VREvent_Overlay_t overlay;
+	VREvent_Status_t status;
+	VREvent_Keyboard_t keyboard;
+	VREvent_Ipd_t ipd;
+	VREvent_Chaperone_t chaperone;
+	VREvent_PerformanceTest_t performanceTest;
+	VREvent_TouchPadMove_t touchPadMove;
+	VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset;
+	VREvent_Screenshot_t screenshot;
+	VREvent_ScreenshotProgress_t screenshotProgress;
+	VREvent_ApplicationLaunch_t applicationLaunch;
+	VREvent_EditingCameraSurface_t cameraSurface;
+	VREvent_MessageOverlay_t messageOverlay;
+	VREvent_Property_t property;
+	VREvent_HapticVibration_t hapticVibration;
+	VREvent_WebConsole_t webConsole;
+	VREvent_InputBindingLoad_t inputBinding;
+	VREvent_InputActionManifestLoad_t actionManifest;
+	VREvent_SpatialAnchor_t spatialAnchor;
+	VREvent_ProgressUpdate_t progressUpdate;
+	VREvent_ShowUI_t showUi;
+	VREvent_ShowDevTools_t showDevTools;
+	VREvent_HDCPError_t hdcpError;
+    /** NOTE!!! If you change this you MUST manually update openvr_interop.cs.py */
+} VREvent_Data_t;
+
+
+#if defined(__linux__) || defined(__APPLE__) 
+// This structure was originally defined mis-packed on Linux, preserved for 
+// compatibility. 
+#pragma pack( push, 4 )
+#endif
+
+/** An event posted by the server to all running applications */
+struct VREvent_t
+{
+	uint32_t eventType; // EVREventType enum
+	TrackedDeviceIndex_t trackedDeviceIndex;
+	float eventAgeSeconds;
+	// event data must be the end of the struct as its size is variable
+	VREvent_Data_t data;
+};
+
+#if defined(__linux__) || defined(__APPLE__) 
+#pragma pack( pop )
+#endif
+
+typedef uint32_t VRComponentProperties;
+
+enum EVRComponentProperty
+{
+	VRComponentProperty_IsStatic = (1 << 0),
+	VRComponentProperty_IsVisible = (1 << 1),
+	VRComponentProperty_IsTouched = (1 << 2),
+	VRComponentProperty_IsPressed = (1 << 3),
+	VRComponentProperty_IsScrolled = (1 << 4),
+	VRComponentProperty_IsHighlighted = (1 << 5),
+};
+
+
+/** Describes state information about a render-model component, including transforms and other dynamic properties */
+struct RenderModel_ComponentState_t
+{
+	HmdMatrix34_t mTrackingToComponentRenderModel;  // Transform required when drawing the component render model
+	HmdMatrix34_t mTrackingToComponentLocal;        // Transform available for attaching to a local component coordinate system (-Z out from surface )
+	VRComponentProperties uProperties;
+};
+
+
+enum EVRInputError
+{
+	VRInputError_None = 0,
+	VRInputError_NameNotFound = 1,
+	VRInputError_WrongType = 2,
+	VRInputError_InvalidHandle = 3,
+	VRInputError_InvalidParam = 4,
+	VRInputError_NoSteam = 5,
+	VRInputError_MaxCapacityReached = 6,
+	VRInputError_IPCError = 7,
+	VRInputError_NoActiveActionSet = 8,
+	VRInputError_InvalidDevice = 9,
+	VRInputError_InvalidSkeleton = 10,
+	VRInputError_InvalidBoneCount = 11,
+	VRInputError_InvalidCompressedData = 12,
+	VRInputError_NoData = 13,
+	VRInputError_BufferTooSmall = 14,
+	VRInputError_MismatchedActionManifest = 15,
+	VRInputError_MissingSkeletonData = 16,
+	VRInputError_InvalidBoneIndex = 17,
+	VRInputError_InvalidPriority = 18,
+	VRInputError_PermissionDenied = 19,
+	VRInputError_InvalidRenderModel = 20,
+};
+
+enum EVRSpatialAnchorError
+{
+	VRSpatialAnchorError_Success = 0,
+	VRSpatialAnchorError_Internal = 1,
+	VRSpatialAnchorError_UnknownHandle = 2,
+	VRSpatialAnchorError_ArrayTooSmall = 3,
+	VRSpatialAnchorError_InvalidDescriptorChar = 4,
+	VRSpatialAnchorError_NotYetAvailable = 5,
+	VRSpatialAnchorError_NotAvailableInThisUniverse = 6,
+	VRSpatialAnchorError_PermanentlyUnavailable = 7,
+	VRSpatialAnchorError_WrongDriver = 8,
+	VRSpatialAnchorError_DescriptorTooLong = 9,
+	VRSpatialAnchorError_Unknown = 10,
+	VRSpatialAnchorError_NoRoomCalibration = 11,
+	VRSpatialAnchorError_InvalidArgument = 12,
+	VRSpatialAnchorError_UnknownDriver = 13,
+};
+
+/** The mesh to draw into the stencil (or depth) buffer to perform 
+* early stencil (or depth) kills of pixels that will never appear on the HMD.
+* This mesh draws on all the pixels that will be hidden after distortion. 
+*
+* If the HMD does not provide a visible area mesh pVertexData will be
+* NULL and unTriangleCount will be 0. */
+struct HiddenAreaMesh_t
+{
+	const HmdVector2_t *pVertexData;
+	uint32_t unTriangleCount;
+};
+
+
+enum EHiddenAreaMeshType
+{
+	k_eHiddenAreaMesh_Standard = 0,
+	k_eHiddenAreaMesh_Inverse = 1,
+	k_eHiddenAreaMesh_LineLoop = 2,
+
+	k_eHiddenAreaMesh_Max = 3,
+};
+
+
+/** Identifies what kind of axis is on the controller at index n. Read this type 
+* with pVRSystem->Get( nControllerDeviceIndex, Prop_Axis0Type_Int32 + n );
+*/
+enum EVRControllerAxisType
+{
+	k_eControllerAxis_None = 0,
+	k_eControllerAxis_TrackPad = 1,
+	k_eControllerAxis_Joystick = 2,
+	k_eControllerAxis_Trigger = 3, // Analog trigger data is in the X axis
+};
+
+
+/** contains information about one axis on the controller */
+struct VRControllerAxis_t
+{
+	float x; // Ranges from -1.0 to 1.0 for joysticks and track pads. Ranges from 0.0 to 1.0 for triggers were 0 is fully released.
+	float y; // Ranges from -1.0 to 1.0 for joysticks and track pads. Is always 0.0 for triggers.
+};
+
+
+/** the number of axes in the controller state */
+static const uint32_t k_unControllerStateAxisCount = 5;
+
+
+#if defined(__linux__) || defined(__APPLE__) 
+// This structure was originally defined mis-packed on Linux, preserved for 
+// compatibility. 
+#pragma pack( push, 4 )
+#endif
+
+/** Holds all the state of a controller at one moment in time. */
+struct VRControllerState001_t
+{
+	// If packet num matches that on your prior call, then the controller state hasn't been changed since 
+	// your last call and there is no need to process it
+	uint32_t unPacketNum;
+
+	// bit flags for each of the buttons. Use ButtonMaskFromId to turn an ID into a mask
+	uint64_t ulButtonPressed;
+	uint64_t ulButtonTouched;
+
+	// Axis data for the controller's analog inputs
+	VRControllerAxis_t rAxis[ k_unControllerStateAxisCount ];
+};
+#if defined(__linux__) || defined(__APPLE__) 
+#pragma pack( pop )
+#endif
+
+
+typedef VRControllerState001_t VRControllerState_t;
+
+
+/** determines how to provide output to the application of various event processing functions. */
+enum EVRControllerEventOutputType
+{
+	ControllerEventOutput_OSEvents = 0,
+	ControllerEventOutput_VREvents = 1,
+};
+
+
+
+/** Collision Bounds Style */
+enum ECollisionBoundsStyle
+{
+	COLLISION_BOUNDS_STYLE_BEGINNER = 0,
+	COLLISION_BOUNDS_STYLE_INTERMEDIATE,
+	COLLISION_BOUNDS_STYLE_SQUARES,
+	COLLISION_BOUNDS_STYLE_ADVANCED,
+	COLLISION_BOUNDS_STYLE_NONE,
+
+	COLLISION_BOUNDS_STYLE_COUNT
+};
+
+/** used to refer to a single VR overlay */
+typedef uint64_t VROverlayHandle_t;
+
+static const VROverlayHandle_t k_ulOverlayHandleInvalid = 0;
+
+/** Errors that can occur around VR overlays */
+enum EVROverlayError
+{
+	VROverlayError_None						= 0,
+
+	VROverlayError_UnknownOverlay			= 10,
+	VROverlayError_InvalidHandle			= 11,
+	VROverlayError_PermissionDenied			= 12,
+	VROverlayError_OverlayLimitExceeded		= 13, // No more overlays could be created because the maximum number already exist
+	VROverlayError_WrongVisibilityType		= 14,
+	VROverlayError_KeyTooLong				= 15,
+	VROverlayError_NameTooLong				= 16,
+	VROverlayError_KeyInUse					= 17,
+	VROverlayError_WrongTransformType		= 18,
+	VROverlayError_InvalidTrackedDevice		= 19,
+	VROverlayError_InvalidParameter			= 20,
+	VROverlayError_ThumbnailCantBeDestroyed	= 21,
+	VROverlayError_ArrayTooSmall			= 22,
+	VROverlayError_RequestFailed			= 23,
+	VROverlayError_InvalidTexture			= 24,
+	VROverlayError_UnableToLoadFile			= 25,
+	VROverlayError_KeyboardAlreadyInUse		= 26,
+	VROverlayError_NoNeighbor				= 27,
+	VROverlayError_TooManyMaskPrimitives	= 29,
+	VROverlayError_BadMaskPrimitive			= 30,
+	VROverlayError_TextureAlreadyLocked		= 31,
+	VROverlayError_TextureLockCapacityReached = 32,
+	VROverlayError_TextureNotLocked			= 33,
+};
+
+/** enum values to pass in to VR_Init to identify whether the application will 
+* draw a 3D scene. */
+enum EVRApplicationType
+{
+	VRApplication_Other = 0,		// Some other kind of application that isn't covered by the other entries 
+	VRApplication_Scene	= 1,		// Application will submit 3D frames 
+	VRApplication_Overlay = 2,		// Application only interacts with overlays
+	VRApplication_Background = 3,	// Application should not start SteamVR if it's not already running, and should not
+									// keep it running if everything else quits.
+	VRApplication_Utility = 4,		// Init should not try to load any drivers. The application needs access to utility
+									// interfaces (like IVRSettings and IVRApplications) but not hardware.
+	VRApplication_VRMonitor = 5,	// Reserved for vrmonitor
+	VRApplication_SteamWatchdog = 6,// Reserved for Steam
+	VRApplication_Bootstrapper = 7, // reserved for vrstartup
+	VRApplication_WebHelper = 8,	// reserved for vrwebhelper
+
+	VRApplication_Max
+};
+
+
+/** error codes for firmware */
+enum EVRFirmwareError
+{
+	VRFirmwareError_None = 0,
+	VRFirmwareError_Success = 1,
+	VRFirmwareError_Fail = 2,
+};
+
+
+/** error codes for notifications */
+enum EVRNotificationError
+{
+	VRNotificationError_OK = 0,
+	VRNotificationError_InvalidNotificationId = 100,
+	VRNotificationError_NotificationQueueFull = 101,
+	VRNotificationError_InvalidOverlayHandle = 102,
+	VRNotificationError_SystemWithUserValueAlreadyExists = 103,
+};
+
+
+enum EVRSkeletalMotionRange
+{
+	// The range of motion of the skeleton takes into account any physical limits imposed by
+	// the controller itself.  This will tend to be the most accurate pose compared to the user's
+	// actual hand pose, but might not allow a closed fist for example
+	VRSkeletalMotionRange_WithController = 0,
+
+	// Retarget the range of motion provided by the input device to make the hand appear to move
+	// as if it was not holding a controller.  eg: map "hand grasping controller" to "closed fist"
+	VRSkeletalMotionRange_WithoutController = 1,
+};
+
+enum EVRSkeletalTrackingLevel
+{
+	// body part location can't be directly determined by the device. Any skeletal pose provided by
+	// the device is estimated by assuming the position required to active buttons, triggers, joysticks, 
+	// or other input sensors. 
+	// E.g. Vive Controller, Gamepad
+	VRSkeletalTracking_Estimated = 0,
+
+	// body part location can be measured directly but with fewer degrees of freedom than the actual body 
+	// part. Certain body part positions may be unmeasured by the device and estimated from other input data. 
+	// E.g. Index Controllers, gloves that only measure finger curl
+	VRSkeletalTracking_Partial = 1,
+
+	// Body part location can be measured directly throughout the entire range of motion of the body part. 
+	// E.g. Mocap suit for the full body, gloves that measure rotation of each finger segment
+	VRSkeletalTracking_Full = 2,
+
+	VRSkeletalTrackingLevel_Count,
+	VRSkeletalTrackingLevel_Max = VRSkeletalTrackingLevel_Count - 1
+};
+
+
+
+/** Holds the transform for a single bone */
+struct VRBoneTransform_t
+{
+	HmdVector4_t position;
+	HmdQuaternionf_t orientation;
+};
+
+/** Type used for referring to bones by their index */
+typedef int32_t BoneIndex_t;
+const BoneIndex_t k_unInvalidBoneIndex = -1;
+
+
+/** error codes returned by Vr_Init */
+
+// Please add adequate error description to https://developer.valvesoftware.com/w/index.php?title=Category:SteamVRHelp
+enum EVRInitError
+{
+	VRInitError_None	= 0,
+	VRInitError_Unknown = 1,
+
+	VRInitError_Init_InstallationNotFound			= 100,
+	VRInitError_Init_InstallationCorrupt			= 101,
+	VRInitError_Init_VRClientDLLNotFound			= 102,
+	VRInitError_Init_FileNotFound					= 103,
+	VRInitError_Init_FactoryNotFound				= 104,
+	VRInitError_Init_InterfaceNotFound				= 105,
+	VRInitError_Init_InvalidInterface				= 106,
+	VRInitError_Init_UserConfigDirectoryInvalid		= 107,
+	VRInitError_Init_HmdNotFound					= 108,
+	VRInitError_Init_NotInitialized					= 109,
+	VRInitError_Init_PathRegistryNotFound			= 110,
+	VRInitError_Init_NoConfigPath					= 111,
+	VRInitError_Init_NoLogPath						= 112,
+	VRInitError_Init_PathRegistryNotWritable		= 113,
+	VRInitError_Init_AppInfoInitFailed				= 114,
+	VRInitError_Init_Retry							= 115, // Used internally to cause retries to vrserver
+	VRInitError_Init_InitCanceledByUser				= 116, // The calling application should silently exit. The user canceled app startup
+	VRInitError_Init_AnotherAppLaunching			= 117, 
+	VRInitError_Init_SettingsInitFailed				= 118, 
+	VRInitError_Init_ShuttingDown					= 119,
+	VRInitError_Init_TooManyObjects					= 120,
+	VRInitError_Init_NoServerForBackgroundApp		= 121,
+	VRInitError_Init_NotSupportedWithCompositor		= 122,
+	VRInitError_Init_NotAvailableToUtilityApps		= 123,
+	VRInitError_Init_Internal				 		= 124,
+	VRInitError_Init_HmdDriverIdIsNone		 		= 125,
+	VRInitError_Init_HmdNotFoundPresenceFailed 		= 126,
+	VRInitError_Init_VRMonitorNotFound				= 127,
+	VRInitError_Init_VRMonitorStartupFailed			= 128,
+	VRInitError_Init_LowPowerWatchdogNotSupported	= 129, 
+	VRInitError_Init_InvalidApplicationType			= 130,
+	VRInitError_Init_NotAvailableToWatchdogApps		= 131,
+	VRInitError_Init_WatchdogDisabledInSettings		= 132,
+	VRInitError_Init_VRDashboardNotFound			= 133,
+	VRInitError_Init_VRDashboardStartupFailed		= 134,
+	VRInitError_Init_VRHomeNotFound					= 135,
+	VRInitError_Init_VRHomeStartupFailed			= 136,
+	VRInitError_Init_RebootingBusy					= 137,
+	VRInitError_Init_FirmwareUpdateBusy				= 138,
+	VRInitError_Init_FirmwareRecoveryBusy			= 139,
+	VRInitError_Init_USBServiceBusy					= 140,
+	VRInitError_Init_VRWebHelperStartupFailed		= 141,
+	VRInitError_Init_TrackerManagerInitFailed		= 142,
+	VRInitError_Init_AlreadyRunning					= 143,
+	VRInitError_Init_FailedForVrMonitor				= 144,
+	VRInitError_Init_PropertyManagerInitFailed		= 145,
+	VRInitError_Init_WebServerFailed				= 146,
+
+	VRInitError_Driver_Failed						= 200,
+	VRInitError_Driver_Unknown						= 201,
+	VRInitError_Driver_HmdUnknown					= 202,
+	VRInitError_Driver_NotLoaded					= 203,
+	VRInitError_Driver_RuntimeOutOfDate				= 204,
+	VRInitError_Driver_HmdInUse						= 205,
+	VRInitError_Driver_NotCalibrated				= 206,
+	VRInitError_Driver_CalibrationInvalid			= 207,
+	VRInitError_Driver_HmdDisplayNotFound			= 208,
+	VRInitError_Driver_TrackedDeviceInterfaceUnknown = 209,
+	// VRInitError_Driver_HmdDisplayNotFoundAfterFix = 210, // not needed: here for historic reasons
+	VRInitError_Driver_HmdDriverIdOutOfBounds		= 211,
+	VRInitError_Driver_HmdDisplayMirrored			= 212,
+	VRInitError_Driver_HmdDisplayNotFoundLaptop		= 213,
+	// Never make error 259 because we return it from main and it would conflict with STILL_ACTIVE
+
+	VRInitError_IPC_ServerInitFailed				= 300,
+	VRInitError_IPC_ConnectFailed					= 301,
+	VRInitError_IPC_SharedStateInitFailed			= 302,
+	VRInitError_IPC_CompositorInitFailed			= 303,
+	VRInitError_IPC_MutexInitFailed					= 304,
+	VRInitError_IPC_Failed							= 305,
+	VRInitError_IPC_CompositorConnectFailed			= 306,
+	VRInitError_IPC_CompositorInvalidConnectResponse = 307,
+	VRInitError_IPC_ConnectFailedAfterMultipleAttempts = 308,
+	VRInitError_IPC_ConnectFailedAfterTargetExited = 309,
+	VRInitError_IPC_NamespaceUnavailable			 = 310,
+
+	VRInitError_Compositor_Failed												= 400,
+	VRInitError_Compositor_D3D11HardwareRequired								= 401,
+	VRInitError_Compositor_FirmwareRequiresUpdate								= 402,
+	VRInitError_Compositor_OverlayInitFailed									= 403,
+	VRInitError_Compositor_ScreenshotsInitFailed								= 404,
+	VRInitError_Compositor_UnableToCreateDevice									= 405,
+	VRInitError_Compositor_SharedStateIsNull									= 406,
+	VRInitError_Compositor_NotificationManagerIsNull							= 407,
+	VRInitError_Compositor_ResourceManagerClientIsNull							= 408,
+	VRInitError_Compositor_MessageOverlaySharedStateInitFailure					= 409,
+	VRInitError_Compositor_PropertiesInterfaceIsNull							= 410,
+	VRInitError_Compositor_CreateFullscreenWindowFailed							= 411,
+	VRInitError_Compositor_SettingsInterfaceIsNull								= 412,
+	VRInitError_Compositor_FailedToShowWindow									= 413,
+	VRInitError_Compositor_DistortInterfaceIsNull								= 414,
+	VRInitError_Compositor_DisplayFrequencyFailure								= 415,
+	VRInitError_Compositor_RendererInitializationFailed							= 416,
+	VRInitError_Compositor_DXGIFactoryInterfaceIsNull							= 417,
+	VRInitError_Compositor_DXGIFactoryCreateFailed								= 418,
+	VRInitError_Compositor_DXGIFactoryQueryFailed								= 419,
+	VRInitError_Compositor_InvalidAdapterDesktop								= 420,
+	VRInitError_Compositor_InvalidHmdAttachment									= 421,
+	VRInitError_Compositor_InvalidOutputDesktop									= 422,
+	VRInitError_Compositor_InvalidDeviceProvided								= 423,
+	VRInitError_Compositor_D3D11RendererInitializationFailed					= 424,
+	VRInitError_Compositor_FailedToFindDisplayMode								= 425,
+	VRInitError_Compositor_FailedToCreateSwapChain								= 426,
+	VRInitError_Compositor_FailedToGetBackBuffer								= 427,
+	VRInitError_Compositor_FailedToCreateRenderTarget							= 428,
+	VRInitError_Compositor_FailedToCreateDXGI2SwapChain							= 429,
+	VRInitError_Compositor_FailedtoGetDXGI2BackBuffer							= 430,
+	VRInitError_Compositor_FailedToCreateDXGI2RenderTarget						= 431,
+	VRInitError_Compositor_FailedToGetDXGIDeviceInterface						= 432,
+	VRInitError_Compositor_SelectDisplayMode									= 433,
+	VRInitError_Compositor_FailedToCreateNvAPIRenderTargets						= 434,
+	VRInitError_Compositor_NvAPISetDisplayMode									= 435,
+	VRInitError_Compositor_FailedToCreateDirectModeDisplay						= 436,
+	VRInitError_Compositor_InvalidHmdPropertyContainer							= 437,
+	VRInitError_Compositor_UpdateDisplayFrequency								= 438,
+	VRInitError_Compositor_CreateRasterizerState								= 439,
+	VRInitError_Compositor_CreateWireframeRasterizerState						= 440,
+	VRInitError_Compositor_CreateSamplerState									= 441,
+	VRInitError_Compositor_CreateClampToBorderSamplerState						= 442,
+	VRInitError_Compositor_CreateAnisoSamplerState								= 443,
+	VRInitError_Compositor_CreateOverlaySamplerState							= 444,
+	VRInitError_Compositor_CreatePanoramaSamplerState							= 445,
+	VRInitError_Compositor_CreateFontSamplerState								= 446,
+	VRInitError_Compositor_CreateNoBlendState									= 447,
+	VRInitError_Compositor_CreateBlendState										= 448,
+	VRInitError_Compositor_CreateAlphaBlendState								= 449,
+	VRInitError_Compositor_CreateBlendStateMaskR								= 450,
+	VRInitError_Compositor_CreateBlendStateMaskG								= 451,
+	VRInitError_Compositor_CreateBlendStateMaskB								= 452,
+	VRInitError_Compositor_CreateDepthStencilState								= 453,
+	VRInitError_Compositor_CreateDepthStencilStateNoWrite						= 454,
+	VRInitError_Compositor_CreateDepthStencilStateNoDepth						= 455,
+	VRInitError_Compositor_CreateFlushTexture									= 456,
+	VRInitError_Compositor_CreateDistortionSurfaces								= 457,
+	VRInitError_Compositor_CreateConstantBuffer									= 458,
+	VRInitError_Compositor_CreateHmdPoseConstantBuffer							= 459,
+	VRInitError_Compositor_CreateHmdPoseStagingConstantBuffer					= 460,
+	VRInitError_Compositor_CreateSharedFrameInfoConstantBuffer					= 461,
+	VRInitError_Compositor_CreateOverlayConstantBuffer							= 462,
+	VRInitError_Compositor_CreateSceneTextureIndexConstantBuffer				= 463,
+	VRInitError_Compositor_CreateReadableSceneTextureIndexConstantBuffer		= 464,
+	VRInitError_Compositor_CreateLayerGraphicsTextureIndexConstantBuffer		= 465,
+	VRInitError_Compositor_CreateLayerComputeTextureIndexConstantBuffer			= 466,
+	VRInitError_Compositor_CreateLayerComputeSceneTextureIndexConstantBuffer	= 467,
+	VRInitError_Compositor_CreateComputeHmdPoseConstantBuffer					= 468,
+	VRInitError_Compositor_CreateGeomConstantBuffer								= 469,
+	VRInitError_Compositor_CreatePanelMaskConstantBuffer						= 470,
+	VRInitError_Compositor_CreatePixelSimUBO									= 471,
+	VRInitError_Compositor_CreateMSAARenderTextures								= 472,
+	VRInitError_Compositor_CreateResolveRenderTextures							= 473,
+	VRInitError_Compositor_CreateComputeResolveRenderTextures					= 474,
+	VRInitError_Compositor_CreateDriverDirectModeResolveTextures				= 475,
+	VRInitError_Compositor_OpenDriverDirectModeResolveTextures					= 476,
+	VRInitError_Compositor_CreateFallbackSyncTexture							= 477,
+	VRInitError_Compositor_ShareFallbackSyncTexture								= 478,
+	VRInitError_Compositor_CreateOverlayIndexBuffer								= 479,
+	VRInitError_Compositor_CreateOverlayVertexBuffer							= 480,
+	VRInitError_Compositor_CreateTextVertexBuffer								= 481,
+	VRInitError_Compositor_CreateTextIndexBuffer								= 482,
+	VRInitError_Compositor_CreateMirrorTextures									= 483,
+	VRInitError_Compositor_CreateLastFrameRenderTexture							= 484,
+	VRInitError_Compositor_CreateMirrorOverlay									= 485,
+	VRInitError_Compositor_FailedToCreateVirtualDisplayBackbuffer				= 486,
+	VRInitError_Compositor_DisplayModeNotSupported								= 487,
+	VRInitError_Compositor_CreateOverlayInvalidCall								= 488,
+	VRInitError_Compositor_CreateOverlayAlreadyInitialized						= 489,
+	VRInitError_Compositor_FailedToCreateMailbox								= 490,
+	
+	VRInitError_VendorSpecific_UnableToConnectToOculusRuntime		= 1000,
+	VRInitError_VendorSpecific_WindowsNotInDevMode					= 1001,
+
+	VRInitError_VendorSpecific_HmdFound_CantOpenDevice 				= 1101,
+	VRInitError_VendorSpecific_HmdFound_UnableToRequestConfigStart	= 1102,
+	VRInitError_VendorSpecific_HmdFound_NoStoredConfig 				= 1103,
+	VRInitError_VendorSpecific_HmdFound_ConfigTooBig 				= 1104,
+	VRInitError_VendorSpecific_HmdFound_ConfigTooSmall 				= 1105,
+	VRInitError_VendorSpecific_HmdFound_UnableToInitZLib 			= 1106,
+	VRInitError_VendorSpecific_HmdFound_CantReadFirmwareVersion 	= 1107,
+	VRInitError_VendorSpecific_HmdFound_UnableToSendUserDataStart	= 1108,
+	VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataStart	= 1109,
+	VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataNext		= 1110,
+	VRInitError_VendorSpecific_HmdFound_UserDataAddressRange		= 1111,
+	VRInitError_VendorSpecific_HmdFound_UserDataError				= 1112,
+	VRInitError_VendorSpecific_HmdFound_ConfigFailedSanityCheck		= 1113,
+	VRInitError_VendorSpecific_OculusRuntimeBadInstall				= 1114,
+
+	VRInitError_Steam_SteamInstallationNotFound = 2000,
+
+	// Strictly a placeholder
+	VRInitError_LastError
+};
+
+enum EVRScreenshotType
+{
+	VRScreenshotType_None = 0,
+	VRScreenshotType_Mono = 1, // left eye only
+	VRScreenshotType_Stereo = 2,
+	VRScreenshotType_Cubemap = 3,
+	VRScreenshotType_MonoPanorama = 4,
+	VRScreenshotType_StereoPanorama = 5
+};
+
+enum EVRScreenshotPropertyFilenames
+{
+	VRScreenshotPropertyFilenames_Preview = 0,
+	VRScreenshotPropertyFilenames_VR = 1,
+};
+
+enum EVRTrackedCameraError
+{
+	VRTrackedCameraError_None                       = 0,
+	VRTrackedCameraError_OperationFailed            = 100,
+	VRTrackedCameraError_InvalidHandle              = 101,	
+	VRTrackedCameraError_InvalidFrameHeaderVersion  = 102,
+	VRTrackedCameraError_OutOfHandles               = 103,
+	VRTrackedCameraError_IPCFailure                 = 104,
+	VRTrackedCameraError_NotSupportedForThisDevice  = 105,
+	VRTrackedCameraError_SharedMemoryFailure        = 106,
+	VRTrackedCameraError_FrameBufferingFailure      = 107,
+	VRTrackedCameraError_StreamSetupFailure         = 108,
+	VRTrackedCameraError_InvalidGLTextureId         = 109,
+	VRTrackedCameraError_InvalidSharedTextureHandle = 110,
+	VRTrackedCameraError_FailedToGetGLTextureId     = 111,
+	VRTrackedCameraError_SharedTextureFailure       = 112,
+	VRTrackedCameraError_NoFrameAvailable           = 113,
+	VRTrackedCameraError_InvalidArgument            = 114,
+	VRTrackedCameraError_InvalidFrameBufferSize     = 115,
+};
+
+enum EVRTrackedCameraFrameLayout
+{
+	EVRTrackedCameraFrameLayout_Mono				= 0x0001,
+	EVRTrackedCameraFrameLayout_Stereo				= 0x0002,
+	EVRTrackedCameraFrameLayout_VerticalLayout		= 0x0010,	// Stereo frames are Top/Bottom (left/right)
+	EVRTrackedCameraFrameLayout_HorizontalLayout	= 0x0020,	// Stereo frames are Left/Right
+};
+	
+enum EVRTrackedCameraFrameType
+{
+	VRTrackedCameraFrameType_Distorted = 0,			// This is the camera video frame size in pixels, still distorted.
+	VRTrackedCameraFrameType_Undistorted,			// In pixels, an undistorted inscribed rectangle region without invalid regions. This size is subject to changes shortly.
+	VRTrackedCameraFrameType_MaximumUndistorted,	// In pixels, maximum undistorted with invalid regions. Non zero alpha component identifies valid regions.
+	MAX_CAMERA_FRAME_TYPES
+};
+
+enum EVRDistortionFunctionType
+{
+	VRDistortionFunctionType_None,
+	VRDistortionFunctionType_FTheta,
+	VRDistortionFunctionType_Extended_FTheta,
+	MAX_DISTORTION_FUNCTION_TYPES,
+};
+
+static const uint32_t k_unMaxDistortionFunctionParameters = 8;
+
+typedef uint64_t TrackedCameraHandle_t;
+#define INVALID_TRACKED_CAMERA_HANDLE	((vr::TrackedCameraHandle_t)0)
+
+struct CameraVideoStreamFrameHeader_t
+{
+	EVRTrackedCameraFrameType eFrameType;
+
+	uint32_t nWidth;
+	uint32_t nHeight;
+	uint32_t nBytesPerPixel;
+
+	uint32_t nFrameSequence;
+
+	TrackedDevicePose_t trackedDevicePose;
+	
+	uint64_t ulFrameExposureTime;						// mid-point of the exposure of the image in host system ticks
+};
+
+// Screenshot types
+typedef uint32_t ScreenshotHandle_t;
+
+static const uint32_t k_unScreenshotHandleInvalid = 0;
+
+/** Compositor frame timing reprojection flags. */
+const uint32_t VRCompositor_ReprojectionReason_Cpu = 0x01;
+const uint32_t VRCompositor_ReprojectionReason_Gpu = 0x02;
+const uint32_t VRCompositor_ReprojectionAsync = 0x04;	// This flag indicates the async reprojection mode is active,
+															// but does not indicate if reprojection actually happened or not.
+															// Use the ReprojectionReason flags above to check if reprojection
+															// was actually applied (i.e. scene texture was reused).
+															// NumFramePresents > 1 also indicates the scene texture was reused,
+															// and also the number of times that it was presented in total.
+
+const uint32_t VRCompositor_ReprojectionMotion = 0x08;	// This flag indicates whether or not motion smoothing was triggered for this frame
+
+const uint32_t VRCompositor_PredictionMask = 0x30;	// The runtime may predict more than one frame (up to four) ahead if
+															// it detects the application is taking too long to render. These two
+															// bits will contain the count of additional frames (normally zero).
+															// Use the VR_COMPOSITOR_ADDITIONAL_PREDICTED_FRAMES macro to read from
+															// the latest frame timing entry.
+
+const uint32_t VRCompositor_ThrottleMask = 0xC0;	// Number of frames the compositor is throttling the application.
+															// Use the VR_COMPOSITOR_NUMBER_OF_THROTTLED_FRAMES macro to read from
+															// the latest frame timing entry.
+
+#define VR_COMPOSITOR_ADDITIONAL_PREDICTED_FRAMES( timing ) ( ( ( timing ).m_nReprojectionFlags & vr::VRCompositor_PredictionMask ) >> 4 )
+#define VR_COMPOSITOR_NUMBER_OF_THROTTLED_FRAMES( timing ) ( ( ( timing ).m_nReprojectionFlags & vr::VRCompositor_ThrottleMask ) >> 6 )
+
+/** Provides a single frame's timing information to the app */
+struct Compositor_FrameTiming
+{
+	uint32_t m_nSize; // Set to sizeof( Compositor_FrameTiming )
+	uint32_t m_nFrameIndex;
+	uint32_t m_nNumFramePresents; // number of times this frame was presented
+	uint32_t m_nNumMisPresented; // number of times this frame was presented on a vsync other than it was originally predicted to
+	uint32_t m_nNumDroppedFrames; // number of additional times previous frame was scanned out
+	uint32_t m_nReprojectionFlags;
+
+	/** Absolute time reference for comparing frames.  This aligns with the vsync that running start is relative to. */
+	double m_flSystemTimeInSeconds;
+
+	/** These times may include work from other processes due to OS scheduling.
+	* The fewer packets of work these are broken up into, the less likely this will happen.
+	* GPU work can be broken up by calling Flush.  This can sometimes be useful to get the GPU started
+	* processing that work earlier in the frame. */
+	float m_flPreSubmitGpuMs; // time spent rendering the scene (gpu work submitted between WaitGetPoses and second Submit)
+	float m_flPostSubmitGpuMs; // additional time spent rendering by application (e.g. companion window)
+	float m_flTotalRenderGpuMs; // time between work submitted immediately after present (ideally vsync) until the end of compositor submitted work
+	float m_flCompositorRenderGpuMs; // time spend performing distortion correction, rendering chaperone, overlays, etc.
+	float m_flCompositorRenderCpuMs; // time spent on cpu submitting the above work for this frame
+	float m_flCompositorIdleCpuMs; // time spent waiting for running start (application could have used this much more time)
+
+	/** Miscellaneous measured intervals. */
+	float m_flClientFrameIntervalMs; // time between calls to WaitGetPoses
+	float m_flPresentCallCpuMs; // time blocked on call to present (usually 0.0, but can go long)
+	float m_flWaitForPresentCpuMs; // time spent spin-waiting for frame index to change (not near-zero indicates wait object failure)
+	float m_flSubmitFrameMs; // time spent in IVRCompositor::Submit (not near-zero indicates driver issue)
+
+	/** The following are all relative to this frame's SystemTimeInSeconds */
+	float m_flWaitGetPosesCalledMs;
+	float m_flNewPosesReadyMs;
+	float m_flNewFrameReadyMs; // second call to IVRCompositor::Submit
+	float m_flCompositorUpdateStartMs;
+	float m_flCompositorUpdateEndMs;
+	float m_flCompositorRenderStartMs;
+
+	vr::TrackedDevicePose_t m_HmdPose; // pose used by app to render this frame
+
+	uint32_t m_nNumVSyncsReadyForUse;
+	uint32_t m_nNumVSyncsToFirstView;
+};
+
+/** Provides compositor benchmark results to the app */
+struct Compositor_BenchmarkResults
+{
+	float m_flMegaPixelsPerSecond; // Measurement of GPU MP/s performed by compositor benchmark
+	float m_flHmdRecommendedMegaPixelsPerSecond; // Recommended default MP/s given the HMD resolution, refresh, and panel mask.
+};
+
+/** Frame timing data provided by direct mode drivers. */
+struct DriverDirectMode_FrameTiming
+{
+	uint32_t m_nSize; // Set to sizeof( DriverDirectMode_FrameTiming )
+	uint32_t m_nNumFramePresents; // number of times frame was presented
+	uint32_t m_nNumMisPresented; // number of times frame was presented on a vsync other than it was originally predicted to
+	uint32_t m_nNumDroppedFrames; // number of additional times previous frame was scanned out (i.e. compositor missed vsync)
+	uint32_t m_nReprojectionFlags;
+};
+
+/** These flags will be set on DriverDirectMode_FrameTiming::m_nReprojectionFlags when IVRDriverDirectModeComponent::GetFrameTiming is called for drivers to optionally respond to. */
+const uint32_t VRCompositor_ReprojectionMotion_Enabled = 0x100; // Motion Smoothing is enabled in the UI for the currently running application
+const uint32_t VRCompositor_ReprojectionMotion_ForcedOn = 0x200; // Motion Smoothing is forced on in the UI for the currently running application
+const uint32_t VRCompositor_ReprojectionMotion_AppThrottled = 0x400; // Application is requesting throttling via ForceInterleavedReprojectionOn
+
+
+enum EVSync
+{
+	VSync_None,
+	VSync_WaitRender,	// block following render work until vsync
+	VSync_NoWaitRender,	// do not block following render work (allow to get started early)
+};
+
+enum EVRMuraCorrectionMode
+{
+	EVRMuraCorrectionMode_Default = 0,
+	EVRMuraCorrectionMode_NoCorrection
+};
+
+/** raw IMU data provided by IVRIOBuffer from paths to tracked devices with IMUs */
+enum Imu_OffScaleFlags
+{
+	OffScale_AccelX	= 0x01,
+	OffScale_AccelY	= 0x02,
+	OffScale_AccelZ	= 0x04,
+	OffScale_GyroX	= 0x08,
+	OffScale_GyroY	= 0x10,
+	OffScale_GyroZ	= 0x20,
+};
+	
+struct ImuSample_t
+{
+	double fSampleTime;
+	HmdVector3d_t vAccel;
+	HmdVector3d_t vGyro;
+	uint32_t unOffScaleFlags;
+};
+
+#pragma pack( pop )
+
+// figure out how to import from the VR API dll
+#if defined(_WIN32)
+
+  #if !defined(OPENVR_BUILD_STATIC)
+    #ifdef VR_API_EXPORT
+      #define VR_INTERFACE extern "C" __declspec( dllexport )
+    #else
+      #define VR_INTERFACE extern "C" __declspec( dllimport )
+    #endif
+  #else
+    #define VR_INTERFACE extern "C"
+  #endif
+
+#elif defined(__GNUC__) || defined(COMPILER_GCC) || defined(__APPLE__)
+
+#ifdef VR_API_EXPORT
+  #define VR_INTERFACE extern "C" __attribute__((visibility("default")))
+#else
+  #define VR_INTERFACE extern "C" 
+#endif
+
+#else
+  #error "Unsupported Platform."
+#endif
+
+
+#if defined( _WIN32 )
+  #define VR_CALLTYPE __cdecl
+#else
+  #define VR_CALLTYPE 
+#endif
+
+} // namespace vr
+
+#endif // _INCLUDE_VRTYPES_H
+
+
+// vrannotation.h
+#ifdef API_GEN
+# define VR_CLANG_ATTR(ATTR) __attribute__((annotate( ATTR )))
+#else
+# define VR_CLANG_ATTR(ATTR)
+#endif
+
+#define VR_METHOD_DESC(DESC) VR_CLANG_ATTR( "desc:" #DESC ";" )
+#define VR_IGNOREATTR() VR_CLANG_ATTR( "ignore" )
+#define VR_OUT_STRUCT() VR_CLANG_ATTR( "out_struct: ;" )
+#define VR_OUT_STRING() VR_CLANG_ATTR( "out_string: ;" )
+#define VR_OUT_ARRAY_CALL(COUNTER,FUNCTION,PARAMS) VR_CLANG_ATTR( "out_array_call:" #COUNTER "," #FUNCTION "," #PARAMS ";" )
+#define VR_OUT_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR( "out_array_count:" #COUNTER ";" )
+#define VR_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR( "array_count:" #COUNTER ";" )
+#define VR_ARRAY_COUNT_D(COUNTER, DESC) VR_CLANG_ATTR( "array_count:" #COUNTER ";desc:" #DESC )
+#define VR_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR( "buffer_count:" #COUNTER ";" )
+#define VR_OUT_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR( "out_buffer_count:" #COUNTER ";" )
+#define VR_OUT_STRING_COUNT(COUNTER) VR_CLANG_ATTR( "out_string_count:" #COUNTER ";" )
+
+// vrtrackedcameratypes.h
+#ifndef _VRTRACKEDCAMERATYPES_H
+#define _VRTRACKEDCAMERATYPES_H 
+
+namespace vr
+{
+
+#pragma pack( push, 8 )
+
+enum ECameraVideoStreamFormat
+{
+	CVS_FORMAT_UNKNOWN = 0,
+	CVS_FORMAT_RAW10 = 1,		// 10 bits per pixel
+	CVS_FORMAT_NV12 = 2,		// 12 bits per pixel
+	CVS_FORMAT_RGB24 = 3,		// 24 bits per pixel
+	CVS_FORMAT_NV12_2 = 4,		// 12 bits per pixel, 2x height
+	CVS_FORMAT_YUYV16 = 5,		// 16 bits per pixel
+	CVS_FORMAT_BAYER16BG = 6,   // 16 bits per pixel, 10-bit BG-format Bayer, see https://docs.opencv.org/3.1.0/de/d25/imgproc_color_conversions.html
+	CVS_FORMAT_MJPEG = 7,       // variable-sized MJPEG Open DML format, see https://www.loc.gov/preservation/digital/formats/fdd/fdd000063.shtml
+	CVS_MAX_FORMATS
+};
+
+enum ECameraCompatibilityMode
+{
+	CAMERA_COMPAT_MODE_BULK_DEFAULT = 0,
+	CAMERA_COMPAT_MODE_BULK_64K_DMA = 1,
+	CAMERA_COMPAT_MODE_BULK_16K_DMA = 2,
+	CAMERA_COMPAT_MODE_BULK_8K_DMA = 3,
+	CAMERA_COMPAT_MODE_ISO_52FPS = 4,
+	CAMERA_COMPAT_MODE_ISO_50FPS = 5,
+	CAMERA_COMPAT_MODE_ISO_48FPS = 6,
+	CAMERA_COMPAT_MODE_ISO_46FPS = 7,
+	CAMERA_COMPAT_MODE_ISO_44FPS = 8,
+	CAMERA_COMPAT_MODE_ISO_42FPS = 9,
+	CAMERA_COMPAT_MODE_ISO_40FPS = 10,
+	CAMERA_COMPAT_MODE_ISO_35FPS = 11,
+	CAMERA_COMPAT_MODE_ISO_30FPS = 12,
+	CAMERA_COMPAT_MODE_ISO_15FPS = 13,
+	MAX_CAMERA_COMPAT_MODES
+};
+
+enum ETrackedCameraRoomViewMode
+{
+	TRACKED_CAMERA_ROOMVIEW_MODE_DEFAULT = 0,
+	TRACKED_CAMERA_ROOMVIEW_MODE_EDGE_A = 1,
+	TRACKED_CAMERA_ROOMVIEW_MODE_EDGE_B = 2,
+	TRACKED_CAMERA_ROOMVIEW_MODE_VIDEO_TRANSLUSCENT = 3,
+	TRACKED_CAMERA_ROOMVIEW_MODE_VIDEO_OPAQUE = 4,
+	TRACKED_CAMERA_ROOMVIEW_MODE_COUNT = 5,
+};
+
+#ifdef _MSC_VER
+#define VR_CAMERA_DECL_ALIGN( x ) __declspec( align( x ) )
+#else
+#define VR_CAMERA_DECL_ALIGN( x ) //
+#endif
+
+static const uint32_t k_unMaxCameras = 4;
+static const uint32_t k_unMaxCameraFrameSharedHandles = 4;
+
+VR_CAMERA_DECL_ALIGN( 8 ) struct CameraVideoStreamFrame_t
+{
+	ECameraVideoStreamFormat m_nStreamFormat;
+
+	uint32_t m_nWidth;
+	uint32_t m_nHeight;
+
+	uint32_t m_nImageDataSize;						// Based on stream format, width, height
+
+	uint32_t m_nFrameSequence;						// Starts from 0 when stream starts.
+
+	uint32_t m_nBufferIndex;						// Identifies which buffer the image data is hosted
+	uint32_t m_nBufferCount;						// Total number of configured buffers
+
+	uint32_t m_nExposureTime;
+
+	uint32_t m_nISPFrameTimeStamp;					// Driver provided time stamp per driver centric time base
+	uint32_t m_nISPReferenceTimeStamp;
+	uint32_t m_nSyncCounter;
+
+	uint32_t m_nCamSyncEvents;
+	uint32_t m_nISPSyncEvents;
+
+	double m_flReferenceCamSyncTime;
+
+	double m_flFrameElapsedTime;					// Starts from 0 when stream starts. In seconds.
+	double m_flFrameDeliveryRate;
+
+	double m_flFrameCaptureTime_DriverAbsolute;		// In USB time, via AuxEvent
+	double m_flFrameCaptureTime_ServerRelative;		// In System time within the server
+	uint64_t m_nFrameCaptureTicks_ServerAbsolute;	// In system ticks within the server
+	double m_flFrameCaptureTime_ClientRelative;		// At the client, relative to when the frame was exposed/captured.
+
+	double m_flSyncMarkerError;
+
+	TrackedDevicePose_t m_RawTrackedDevicePose;	// Raw-and-uncalibrated pose, supplied by HMD layer when used as a tracked camera
+
+	uint64_t m_pImageData;
+};
+
+#pragma pack( pop )
+
+}
+
+#endif // _VRTRACKEDCAMERATYPES_H
+// ivrsettings.h
+#include <string>
+
+namespace vr
+{
+	enum EVRSettingsError
+	{
+		VRSettingsError_None = 0,
+		VRSettingsError_IPCFailed = 1,
+		VRSettingsError_WriteFailed = 2,
+		VRSettingsError_ReadFailed = 3,
+		VRSettingsError_JsonParseFailed = 4,
+		VRSettingsError_UnsetSettingHasNoDefault = 5, // This will be returned if the setting does not appear in the appropriate default file and has not been set
+	};
+
+	// The maximum length of a settings key
+	static const uint32_t k_unMaxSettingsKeyLength = 128;
+
+	class IVRSettings
+	{
+	public:
+		virtual const char *GetSettingsErrorNameFromEnum( EVRSettingsError eError ) = 0;
+
+		virtual void SetBool( const char *pchSection, const char *pchSettingsKey, bool bValue, EVRSettingsError *peError = nullptr ) = 0;
+		virtual void SetInt32( const char *pchSection, const char *pchSettingsKey, int32_t nValue, EVRSettingsError *peError = nullptr ) = 0;
+		virtual void SetFloat( const char *pchSection, const char *pchSettingsKey, float flValue, EVRSettingsError *peError = nullptr ) = 0;
+		virtual void SetString( const char *pchSection, const char *pchSettingsKey, const char *pchValue, EVRSettingsError *peError = nullptr ) = 0;
+
+		// Users of the system need to provide a proper default in default.vrsettings in the resources/settings/ directory
+		// of either the runtime or the driver_xxx directory. Otherwise the default will be false, 0, 0.0 or ""
+		virtual bool GetBool( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) = 0;
+		virtual int32_t GetInt32( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) = 0;
+		virtual float GetFloat( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) = 0;
+		virtual void GetString( const char *pchSection, const char *pchSettingsKey, VR_OUT_STRING() char *pchValue, uint32_t unValueLen, EVRSettingsError *peError = nullptr ) = 0;
+
+		virtual void RemoveSection( const char *pchSection, EVRSettingsError *peError = nullptr ) = 0;
+		virtual void RemoveKeyInSection( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) = 0;
+	};
+
+	//-----------------------------------------------------------------------------
+	static const char * const IVRSettings_Version = "IVRSettings_003";
+
+	class CVRSettingHelper
+	{
+		IVRSettings *m_pSettings;
+	public:
+		CVRSettingHelper( IVRSettings *pSettings ) 
+		{ 
+			m_pSettings = pSettings; 
+		}
+
+		const char *GetSettingsErrorNameFromEnum( EVRSettingsError eError ) 
+		{ 
+			return m_pSettings->GetSettingsErrorNameFromEnum( eError ); 
+		}
+
+		void SetBool( const char *pchSection, const char *pchSettingsKey, bool bValue, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->SetBool( pchSection, pchSettingsKey, bValue, peError );
+		}
+
+		void SetInt32( const char *pchSection, const char *pchSettingsKey, int32_t nValue, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->SetInt32( pchSection, pchSettingsKey, nValue, peError );
+		}
+		void SetFloat( const char *pchSection, const char *pchSettingsKey, float flValue, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->SetFloat( pchSection, pchSettingsKey, flValue, peError );
+		}
+		void SetString( const char *pchSection, const char *pchSettingsKey, const char *pchValue, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->SetString( pchSection, pchSettingsKey, pchValue, peError );
+		}
+		void SetString( const std::string & sSection, const std::string &  sSettingsKey, const std::string & sValue, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->SetString( sSection.c_str(), sSettingsKey.c_str(), sValue.c_str(), peError );
+		}
+
+		bool GetBool( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr )
+		{
+			return m_pSettings->GetBool( pchSection, pchSettingsKey, peError );
+		}
+		int32_t GetInt32( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr )
+		{
+			return m_pSettings->GetInt32( pchSection, pchSettingsKey, peError );
+		}
+		float GetFloat( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr )
+		{
+			return m_pSettings->GetFloat( pchSection, pchSettingsKey, peError );
+		}
+		void GetString( const char *pchSection, const char *pchSettingsKey, VR_OUT_STRING() char *pchValue, uint32_t unValueLen, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->GetString( pchSection, pchSettingsKey, pchValue, unValueLen, peError );
+		}
+		std::string GetString( const std::string & sSection, const std::string & sSettingsKey, EVRSettingsError *peError = nullptr )
+		{
+			char buf[4096];
+			vr::EVRSettingsError eError;
+			m_pSettings->GetString( sSection.c_str(), sSettingsKey.c_str(), buf, sizeof( buf ), &eError );
+			if ( peError )
+				*peError = eError;
+			if ( eError == vr::VRSettingsError_None )
+				return buf;
+			else
+				return "";
+		}
+
+		void RemoveSection( const char *pchSection, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->RemoveSection( pchSection, peError );
+		}
+		void RemoveKeyInSection( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->RemoveKeyInSection( pchSection, pchSettingsKey, peError );
+		}
+	};
+
+
+	//-----------------------------------------------------------------------------
+	// steamvr keys
+	static const char * const k_pch_SteamVR_Section = "steamvr";
+	static const char * const k_pch_SteamVR_RequireHmd_String = "requireHmd";
+	static const char * const k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver";
+	static const char * const k_pch_SteamVR_ForcedHmdKey_String = "forcedHmd";
+	static const char * const k_pch_SteamVR_DisplayDebug_Bool = "displayDebug";
+	static const char * const k_pch_SteamVR_DebugProcessPipe_String = "debugProcessPipe";
+	static const char * const k_pch_SteamVR_DisplayDebugX_Int32 = "displayDebugX";
+	static const char * const k_pch_SteamVR_DisplayDebugY_Int32 = "displayDebugY";
+	static const char * const k_pch_SteamVR_SendSystemButtonToAllApps_Bool= "sendSystemButtonToAllApps";
+	static const char * const k_pch_SteamVR_LogLevel_Int32 = "loglevel";
+	static const char * const k_pch_SteamVR_IPD_Float = "ipd";
+	static const char * const k_pch_SteamVR_Background_String = "background";
+	static const char * const k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection";
+	static const char * const k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight";
+	static const char * const k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius";
+	static const char * const k_pch_SteamVR_GridColor_String = "gridColor";
+	static const char * const k_pch_SteamVR_PlayAreaColor_String = "playAreaColor";
+	static const char * const k_pch_SteamVR_TrackingLossColor_String = "trackingLossColor";
+	static const char * const k_pch_SteamVR_ShowStage_Bool = "showStage";
+	static const char * const k_pch_SteamVR_ActivateMultipleDrivers_Bool = "activateMultipleDrivers";
+	static const char * const k_pch_SteamVR_UsingSpeakers_Bool = "usingSpeakers";
+	static const char * const k_pch_SteamVR_SpeakersForwardYawOffsetDegrees_Float = "speakersForwardYawOffsetDegrees";
+	static const char * const k_pch_SteamVR_BaseStationPowerManagement_Int32 = "basestationPowerManagement";
+	static const char * const k_pch_SteamVR_ShowBaseStationPowerManagementTip_Int32 = "ShowBaseStationPowerManagementTip";
+	static const char * const k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses";
+	static const char * const k_pch_SteamVR_SupersampleScale_Float = "supersampleScale";
+	static const char * const k_pch_SteamVR_MaxRecommendedResolution_Int32 = "maxRecommendedResolution";
+	static const char * const k_pch_SteamVR_MotionSmoothing_Bool = "motionSmoothing";
+	static const char * const k_pch_SteamVR_MotionSmoothingOverride_Int32 = "motionSmoothingOverride";
+	static const char * const k_pch_SteamVR_DisableAsyncReprojection_Bool = "disableAsync";
+	static const char * const k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking";
+	static const char * const k_pch_SteamVR_DefaultMirrorView_Int32 = "mirrorView";
+	static const char * const k_pch_SteamVR_ShowLegacyMirrorView_Bool = "showLegacyMirrorView";
+	static const char * const k_pch_SteamVR_MirrorViewVisibility_Bool = "showMirrorView";
+	static const char * const k_pch_SteamVR_MirrorViewDisplayMode_Int32 = "mirrorViewDisplayMode";
+	static const char * const k_pch_SteamVR_MirrorViewEye_Int32 = "mirrorViewEye";
+	static const char * const k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry";
+	static const char * const k_pch_SteamVR_MirrorViewGeometryMaximized_String = "mirrorViewGeometryMaximized";
+	static const char * const k_pch_SteamVR_PerfGraphVisibility_Bool = "showPerfGraph";
+	static const char * const k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch";
+	static const char * const k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch";
+	static const char * const k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch";
+	static const char * const k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard";
+	static const char * const k_pch_SteamVR_EnableHomeApp = "enableHomeApp";
+	static const char * const k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec";
+	static const char * const k_pch_SteamVR_RetailDemo_Bool = "retailDemo";
+	static const char * const k_pch_SteamVR_IpdOffset_Float = "ipdOffset";
+	static const char * const k_pch_SteamVR_AllowSupersampleFiltering_Bool = "allowSupersampleFiltering";
+	static const char * const k_pch_SteamVR_SupersampleManualOverride_Bool = "supersampleManualOverride";
+	static const char * const k_pch_SteamVR_EnableLinuxVulkanAsync_Bool = "enableLinuxVulkanAsync";
+	static const char * const k_pch_SteamVR_AllowDisplayLockedMode_Bool = "allowDisplayLockedMode";
+	static const char * const k_pch_SteamVR_HaveStartedTutorialForNativeChaperoneDriver_Bool = "haveStartedTutorialForNativeChaperoneDriver";
+	static const char * const k_pch_SteamVR_ForceWindows32bitVRMonitor = "forceWindows32BitVRMonitor";
+	static const char * const k_pch_SteamVR_DebugInputBinding = "debugInputBinding";
+	static const char * const k_pch_SteamVR_DoNotFadeToGrid = "doNotFadeToGrid";
+	static const char * const k_pch_SteamVR_RenderCameraMode = "renderCameraMode";
+	static const char * const k_pch_SteamVR_EnableSharedResourceJournaling = "enableSharedResourceJournaling";
+	static const char * const k_pch_SteamVR_EnableSafeMode = "enableSafeMode";
+	static const char * const k_pch_SteamVR_PreferredRefreshRate = "preferredRefreshRate";
+	static const char * const k_pch_SteamVR_LastVersionNotice = "lastVersionNotice";
+	static const char * const k_pch_SteamVR_LastVersionNoticeDate = "lastVersionNoticeDate";
+	static const char * const k_pch_SteamVR_HmdDisplayColorGainR_Float = "hmdDisplayColorGainR";
+	static const char * const k_pch_SteamVR_HmdDisplayColorGainG_Float = "hmdDisplayColorGainG";
+	static const char * const k_pch_SteamVR_HmdDisplayColorGainB_Float = "hmdDisplayColorGainB";
+	static const char * const k_pch_SteamVR_CustomIconStyle_String = "customIconStyle";
+	static const char * const k_pch_SteamVR_CustomOffIconStyle_String = "customOffIconStyle";
+	static const char * const k_pch_SteamVR_CustomIconForceUpdate_String = "customIconForceUpdate";
+	static const char * const k_pch_SteamVR_AllowGlobalActionSetPriority = "globalActionSetPriority";
+	static const char * const k_pch_SteamVR_OverlayRenderQuality = "overlayRenderQuality_2";
+
+	//-----------------------------------------------------------------------------
+	// direct mode keys
+	static const char * const k_pch_DirectMode_Section = "direct_mode";
+	static const char * const k_pch_DirectMode_Enable_Bool = "enable";
+	static const char * const k_pch_DirectMode_Count_Int32 = "count";
+	static const char * const k_pch_DirectMode_EdidVid_Int32 = "edidVid";
+	static const char * const k_pch_DirectMode_EdidPid_Int32 = "edidPid";
+
+	//-----------------------------------------------------------------------------
+	// lighthouse keys
+	static const char * const k_pch_Lighthouse_Section = "driver_lighthouse";
+	static const char * const k_pch_Lighthouse_DisableIMU_Bool = "disableimu";
+	static const char * const k_pch_Lighthouse_DisableIMUExceptHMD_Bool = "disableimuexcepthmd";
+	static const char * const k_pch_Lighthouse_UseDisambiguation_String = "usedisambiguation";
+	static const char * const k_pch_Lighthouse_DisambiguationDebug_Int32 = "disambiguationdebug";
+	static const char * const k_pch_Lighthouse_PrimaryBasestation_Int32 = "primarybasestation";
+	static const char * const k_pch_Lighthouse_DBHistory_Bool = "dbhistory";
+	static const char * const k_pch_Lighthouse_EnableBluetooth_Bool = "enableBluetooth";
+	static const char * const k_pch_Lighthouse_PowerManagedBaseStations_String = "PowerManagedBaseStations";
+	static const char * const k_pch_Lighthouse_PowerManagedBaseStations2_String = "PowerManagedBaseStations2";
+	static const char * const k_pch_Lighthouse_InactivityTimeoutForBaseStations_Int32 = "InactivityTimeoutForBaseStations";
+	static const char * const k_pch_Lighthouse_EnableImuFallback_Bool = "enableImuFallback";
+
+	//-----------------------------------------------------------------------------
+	// null keys
+	static const char * const k_pch_Null_Section = "driver_null";
+	static const char * const k_pch_Null_SerialNumber_String = "serialNumber";
+	static const char * const k_pch_Null_ModelNumber_String = "modelNumber";
+	static const char * const k_pch_Null_WindowX_Int32 = "windowX";
+	static const char * const k_pch_Null_WindowY_Int32 = "windowY";
+	static const char * const k_pch_Null_WindowWidth_Int32 = "windowWidth";
+	static const char * const k_pch_Null_WindowHeight_Int32 = "windowHeight";
+	static const char * const k_pch_Null_RenderWidth_Int32 = "renderWidth";
+	static const char * const k_pch_Null_RenderHeight_Int32 = "renderHeight";
+	static const char * const k_pch_Null_SecondsFromVsyncToPhotons_Float = "secondsFromVsyncToPhotons";
+	static const char * const k_pch_Null_DisplayFrequency_Float = "displayFrequency";
+
+	//-----------------------------------------------------------------------------
+	// Windows MR keys
+	static const char * const k_pch_WindowsMR_Section = "driver_holographic";
+
+	//-----------------------------------------------------------------------------
+	// user interface keys
+	static const char * const k_pch_UserInterface_Section = "userinterface";
+	static const char * const k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop";
+	static const char * const k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray";
+	static const char * const k_pch_UserInterface_HidePopupsWhenStatusMinimized_Bool = "HidePopupsWhenStatusMinimized";
+	static const char * const k_pch_UserInterface_Screenshots_Bool = "screenshots";
+	static const char * const k_pch_UserInterface_ScreenshotType_Int = "screenshotType";
+
+	//-----------------------------------------------------------------------------
+	// notification keys
+	static const char * const k_pch_Notifications_Section = "notifications";
+	static const char * const k_pch_Notifications_DoNotDisturb_Bool = "DoNotDisturb";
+
+	//-----------------------------------------------------------------------------
+	// keyboard keys
+	static const char * const k_pch_Keyboard_Section = "keyboard";
+	static const char * const k_pch_Keyboard_TutorialCompletions = "TutorialCompletions";
+	static const char * const k_pch_Keyboard_ScaleX = "ScaleX";
+	static const char * const k_pch_Keyboard_ScaleY = "ScaleY";
+	static const char * const k_pch_Keyboard_OffsetLeftX = "OffsetLeftX";
+	static const char * const k_pch_Keyboard_OffsetRightX = "OffsetRightX";
+	static const char * const k_pch_Keyboard_OffsetY = "OffsetY";
+	static const char * const k_pch_Keyboard_Smoothing = "Smoothing";
+
+	//-----------------------------------------------------------------------------
+	// perf keys
+	static const char * const k_pch_Perf_Section = "perfcheck";
+	static const char * const k_pch_Perf_PerfGraphInHMD_Bool = "perfGraphInHMD";
+	static const char * const k_pch_Perf_AllowTimingStore_Bool = "allowTimingStore";
+	static const char * const k_pch_Perf_SaveTimingsOnExit_Bool = "saveTimingsOnExit";
+	static const char * const k_pch_Perf_TestData_Float = "perfTestData";
+	static const char * const k_pch_Perf_GPUProfiling_Bool = "GPUProfiling";
+
+	//-----------------------------------------------------------------------------
+	// collision bounds keys
+	static const char * const k_pch_CollisionBounds_Section = "collisionBounds";
+	static const char * const k_pch_CollisionBounds_Style_Int32 = "CollisionBoundsStyle";
+	static const char * const k_pch_CollisionBounds_GroundPerimeterOn_Bool = "CollisionBoundsGroundPerimeterOn";
+	static const char * const k_pch_CollisionBounds_CenterMarkerOn_Bool = "CollisionBoundsCenterMarkerOn";
+	static const char * const k_pch_CollisionBounds_PlaySpaceOn_Bool = "CollisionBoundsPlaySpaceOn";
+	static const char * const k_pch_CollisionBounds_FadeDistance_Float = "CollisionBoundsFadeDistance";
+	static const char * const k_pch_CollisionBounds_WallHeight_Float = "CollisionBoundsWallHeight";
+	static const char * const k_pch_CollisionBounds_ColorGammaR_Int32 = "CollisionBoundsColorGammaR";
+	static const char * const k_pch_CollisionBounds_ColorGammaG_Int32 = "CollisionBoundsColorGammaG";
+	static const char * const k_pch_CollisionBounds_ColorGammaB_Int32 = "CollisionBoundsColorGammaB";
+	static const char * const k_pch_CollisionBounds_ColorGammaA_Int32 = "CollisionBoundsColorGammaA";
+	static const char * const k_pch_CollisionBounds_EnableDriverImport = "enableDriverBoundsImport";
+
+	//-----------------------------------------------------------------------------
+	// camera keys
+	static const char * const k_pch_Camera_Section = "camera";
+	static const char * const k_pch_Camera_EnableCamera_Bool = "enableCamera";
+	static const char * const k_pch_Camera_EnableCameraInDashboard_Bool = "enableCameraInDashboard";
+	static const char * const k_pch_Camera_EnableCameraForCollisionBounds_Bool = "enableCameraForCollisionBounds";
+	static const char * const k_pch_Camera_EnableCameraForRoomView_Bool = "enableCameraForRoomView";
+	static const char * const k_pch_Camera_BoundsColorGammaR_Int32 = "cameraBoundsColorGammaR";
+	static const char * const k_pch_Camera_BoundsColorGammaG_Int32 = "cameraBoundsColorGammaG";
+	static const char * const k_pch_Camera_BoundsColorGammaB_Int32 = "cameraBoundsColorGammaB";
+	static const char * const k_pch_Camera_BoundsColorGammaA_Int32 = "cameraBoundsColorGammaA";
+	static const char * const k_pch_Camera_BoundsStrength_Int32 = "cameraBoundsStrength";
+	static const char * const k_pch_Camera_RoomViewMode_Int32 = "cameraRoomViewMode";
+
+	//-----------------------------------------------------------------------------
+	// audio keys
+	static const char * const k_pch_audio_Section = "audio";
+	static const char * const k_pch_audio_SetOsDefaultPlaybackDevice_Bool = "setOsDefaultPlaybackDevice";
+	static const char * const k_pch_audio_EnablePlaybackDeviceOverride_Bool = "enablePlaybackDeviceOverride";
+	static const char * const k_pch_audio_PlaybackDeviceOverride_String = "playbackDeviceOverride";
+	static const char * const k_pch_audio_PlaybackDeviceOverrideName_String = "playbackDeviceOverrideName";
+	static const char * const k_pch_audio_SetOsDefaultRecordingDevice_Bool = "setOsDefaultRecordingDevice";
+	static const char * const k_pch_audio_EnableRecordingDeviceOverride_Bool = "enableRecordingDeviceOverride";
+	static const char * const k_pch_audio_RecordingDeviceOverride_String = "recordingDeviceOverride";
+	static const char * const k_pch_audio_RecordingDeviceOverrideName_String = "recordingDeviceOverrideName";
+	static const char * const k_pch_audio_EnablePlaybackMirror_Bool = "enablePlaybackMirror";
+	static const char * const k_pch_audio_PlaybackMirrorDevice_String = "playbackMirrorDevice";
+	static const char * const k_pch_audio_PlaybackMirrorDeviceName_String = "playbackMirrorDeviceName";
+	static const char * const k_pch_audio_OldPlaybackMirrorDevice_String = "onPlaybackMirrorDevice";
+	static const char * const k_pch_audio_ActiveMirrorDevice_String = "activePlaybackMirrorDevice";
+	static const char * const k_pch_audio_EnablePlaybackMirrorIndependentVolume_Bool = "enablePlaybackMirrorIndependentVolume";
+	static const char * const k_pch_audio_LastHmdPlaybackDeviceId_String = "lastHmdPlaybackDeviceId";
+	static const char * const k_pch_audio_VIVEHDMIGain = "viveHDMIGain";
+
+	//-----------------------------------------------------------------------------
+	// power management keys
+	static const char * const k_pch_Power_Section = "power";
+	static const char * const k_pch_Power_PowerOffOnExit_Bool = "powerOffOnExit";
+	static const char * const k_pch_Power_TurnOffScreensTimeout_Float = "turnOffScreensTimeout";
+	static const char * const k_pch_Power_TurnOffControllersTimeout_Float = "turnOffControllersTimeout";
+	static const char * const k_pch_Power_ReturnToWatchdogTimeout_Float = "returnToWatchdogTimeout";
+	static const char * const k_pch_Power_AutoLaunchSteamVROnButtonPress = "autoLaunchSteamVROnButtonPress";
+	static const char * const k_pch_Power_PauseCompositorOnStandby_Bool = "pauseCompositorOnStandby";
+
+	//-----------------------------------------------------------------------------
+	// dashboard keys
+	static const char * const k_pch_Dashboard_Section = "dashboard";
+	static const char * const k_pch_Dashboard_EnableDashboard_Bool = "enableDashboard";
+	static const char * const k_pch_Dashboard_ArcadeMode_Bool = "arcadeMode";
+	static const char * const k_pch_Dashboard_Position = "position";
+	static const char * const k_pch_Dashboard_DesktopScale = "desktopScale";
+	static const char * const k_pch_Dashboard_DashboardScale = "dashboardScale";
+
+	//-----------------------------------------------------------------------------
+	// model skin keys
+	static const char * const k_pch_modelskin_Section = "modelskins";
+
+	//-----------------------------------------------------------------------------
+	// driver keys - These could be checked in any driver_<name> section
+	static const char * const k_pch_Driver_Enable_Bool = "enable";
+	static const char * const k_pch_Driver_BlockedBySafemode_Bool = "blocked_by_safe_mode";
+	static const char * const k_pch_Driver_LoadPriority_Int32 = "loadPriority";
+
+	//-----------------------------------------------------------------------------
+	// web interface keys
+	static const char* const k_pch_WebInterface_Section = "WebInterface";
+
+	//-----------------------------------------------------------------------------
+	// vrwebhelper keys
+	static const char* const k_pch_VRWebHelper_Section = "VRWebHelper";
+	static const char* const k_pch_VRWebHelper_DebuggerEnabled_Bool = "DebuggerEnabled";
+	static const char* const k_pch_VRWebHelper_DebuggerPort_Int32 = "DebuggerPort";
+
+	//-----------------------------------------------------------------------------
+	// tracking overrides - keys are device paths, values are the device paths their
+	//  tracking/pose information overrides
+	static const char* const k_pch_TrackingOverride_Section = "TrackingOverrides";
+
+	//-----------------------------------------------------------------------------
+	// per-app keys - the section name for these is the app key itself. Some of these are prefixed by the controller type
+	static const char* const k_pch_App_BindingAutosaveURLSuffix_String = "AutosaveURL";
+	static const char* const k_pch_App_BindingLegacyAPISuffix_String = "_legacy";
+	static const char* const k_pch_App_BindingSteamVRInputAPISuffix_String = "_steamvrinput";
+	static const char* const k_pch_App_BindingCurrentURLSuffix_String = "CurrentURL";
+	static const char* const k_pch_App_BindingPreviousURLSuffix_String = "PreviousURL";
+	static const char* const k_pch_App_NeedToUpdateAutosaveSuffix_Bool = "NeedToUpdateAutosave";
+	static const char* const k_pch_App_DominantHand_Int32 = "DominantHand";
+
+	//-----------------------------------------------------------------------------
+	// configuration for trackers
+	static const char * const k_pch_Trackers_Section = "trackers";
+
+	//-----------------------------------------------------------------------------
+	// configuration for desktop UI windows
+	static const char * const k_pch_DesktopUI_Section = "DesktopUI";
+
+	//-----------------------------------------------------------------------------
+	// Last known keys for righting recovery
+	static const char * const k_pch_LastKnown_Section = "LastKnown";
+	static const char* const k_pch_LastKnown_HMDManufacturer_String = "HMDManufacturer";
+	static const char* const k_pch_LastKnown_HMDModel_String = "HMDModel";
+
+	//-----------------------------------------------------------------------------
+	// Dismissed warnings
+	static const char * const k_pch_DismissedWarnings_Section = "DismissedWarnings";
+
+	//-----------------------------------------------------------------------------
+	// Input Settings
+	static const char * const k_pch_Input_Section = "input";
+	static const char* const k_pch_Input_LeftThumbstickRotation_Float = "leftThumbstickRotation";
+	static const char* const k_pch_Input_RightThumbstickRotation_Float = "rightThumbstickRotation";
+	static const char* const k_pch_Input_ThumbstickDeadzone_Float = "thumbstickDeadzone";
+
+	//-----------------------------------------------------------------------------
+	// Log of GPU performance
+	static const char * const k_pch_GpuSpeed_Section = "GpuSpeed";
+
+} // namespace vr
+
+// iservertrackeddevicedriver.h
+namespace vr
+{
+
+
+struct DriverPoseQuaternion_t
+{
+	double w, x, y, z;
+};
+
+struct DriverPose_t
+{
+	/* Time offset of this pose, in seconds from the actual time of the pose,
+	 * relative to the time of the PoseUpdated() call made by the driver.
+	 */
+	double poseTimeOffset;
+
+	/* Generally, the pose maintained by a driver
+	 * is in an inertial coordinate system different
+	 * from the world system of x+ right, y+ up, z+ back.
+	 * Also, the driver is not usually tracking the "head" position,
+	 * but instead an internal IMU or another reference point in the HMD.
+	 * The following two transforms transform positions and orientations
+	 * to app world space from driver world space,
+	 * and to HMD head space from driver local body space. 
+	 *
+	 * We maintain the driver pose state in its internal coordinate system,
+	 * so we can do the pose prediction math without having to
+	 * use angular acceleration.  A driver's angular acceleration is generally not measured,
+	 * and is instead calculated from successive samples of angular velocity.
+	 * This leads to a noisy angular acceleration values, which are also
+	 * lagged due to the filtering required to reduce noise to an acceptable level.
+	 */
+	vr::HmdQuaternion_t qWorldFromDriverRotation;
+	double vecWorldFromDriverTranslation[ 3 ];
+
+	vr::HmdQuaternion_t qDriverFromHeadRotation;
+	double vecDriverFromHeadTranslation[ 3 ];
+
+	/* State of driver pose, in meters and radians. */
+	/* Position of the driver tracking reference in driver world space
+	* +[0] (x) is right
+	* +[1] (y) is up
+	* -[2] (z) is forward
+	*/
+	double vecPosition[ 3 ];
+
+	/* Velocity of the pose in meters/second */
+	double vecVelocity[ 3 ];
+
+	/* Acceleration of the pose in meters/second */
+	double vecAcceleration[ 3 ];
+
+	/* Orientation of the tracker, represented as a quaternion */
+	vr::HmdQuaternion_t qRotation;
+
+	/* Angular velocity of the pose in axis-angle 
+	* representation. The direction is the angle of
+	* rotation and the magnitude is the angle around
+	* that axis in radians/second. */
+	double vecAngularVelocity[ 3 ];
+
+	/* Angular acceleration of the pose in axis-angle 
+	* representation. The direction is the angle of
+	* rotation and the magnitude is the angle around
+	* that axis in radians/second^2. */
+	double vecAngularAcceleration[ 3 ];
+
+	ETrackingResult result;
+
+	bool poseIsValid;
+	bool willDriftInYaw;
+	bool shouldApplyHeadModel;
+	bool deviceIsConnected;
+};
+
+
+// ----------------------------------------------------------------------------------------------
+// Purpose: Represents a single tracked device in a driver
+// ----------------------------------------------------------------------------------------------
+class ITrackedDeviceServerDriver
+{
+public:
+
+	// ------------------------------------
+	// Management Methods
+	// ------------------------------------
+	/** This is called before an HMD is returned to the application. It will always be
+	* called before any display or tracking methods. Memory and processor use by the
+	* ITrackedDeviceServerDriver object should be kept to a minimum until it is activated.
+	* The pose listener is guaranteed to be valid until Deactivate is called, but
+	* should not be used after that point. */
+	virtual EVRInitError Activate( uint32_t unObjectId ) = 0;
+
+	/** This is called when The VR system is switching from this Hmd being the active display
+	* to another Hmd being the active display. The driver should clean whatever memory
+	* and thread use it can when it is deactivated */
+	virtual void Deactivate() = 0;
+
+	/** Handles a request from the system to put this device into standby mode. What that means is defined per-device. */
+	virtual void EnterStandby() = 0;
+
+	/** Requests a component interface of the driver for device-specific functionality. The driver should return NULL
+	* if the requested interface or version is not supported. */
+	virtual void *GetComponent( const char *pchComponentNameAndVersion ) = 0;
+
+	/** A VR Client has made this debug request of the driver. The set of valid requests is entirely
+	* up to the driver and the client to figure out, as is the format of the response. Responses that
+	* exceed the length of the supplied buffer should be truncated and null terminated */
+	virtual void DebugRequest( const char *pchRequest, char *pchResponseBuffer, uint32_t unResponseBufferSize ) = 0;
+
+	// ------------------------------------
+	// Tracking Methods
+	// ------------------------------------
+	virtual DriverPose_t GetPose() = 0;
+};
+
+
+
+static const char *ITrackedDeviceServerDriver_Version = "ITrackedDeviceServerDriver_005";
+
+}
+// ivrdisplaycomponent.h
+namespace vr
+{
+
+
+	// ----------------------------------------------------------------------------------------------
+	// Purpose: The display component on a single tracked device
+	// ----------------------------------------------------------------------------------------------
+	class IVRDisplayComponent
+	{
+	public:
+
+		// ------------------------------------
+		// Display Methods
+		// ------------------------------------
+
+		/** Size and position that the window needs to be on the VR display. */
+		virtual void GetWindowBounds( int32_t *pnX, int32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
+
+		/** Returns true if the display is extending the desktop. */
+		virtual bool IsDisplayOnDesktop( ) = 0;
+
+		/** Returns true if the display is real and not a fictional display. */
+		virtual bool IsDisplayRealDisplay( ) = 0;
+
+		/** Suggested size for the intermediate render target that the distortion pulls from. */
+		virtual void GetRecommendedRenderTargetSize( uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
+
+		/** Gets the viewport in the frame buffer to draw the output of the distortion into */
+		virtual void GetEyeOutputViewport( EVREye eEye, uint32_t *pnX, uint32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
+
+		/** The components necessary to build your own projection matrix in case your
+		* application is doing something fancy like infinite Z */
+		virtual void GetProjectionRaw( EVREye eEye, float *pfLeft, float *pfRight, float *pfTop, float *pfBottom ) = 0;
+
+		/** Returns the result of the distortion function for the specified eye and input UVs. UVs go from 0,0 in
+		* the upper left of that eye's viewport and 1,1 in the lower right of that eye's viewport. */
+		virtual DistortionCoordinates_t ComputeDistortion( EVREye eEye, float fU, float fV ) = 0;
+
+	};
+
+	static const char *IVRDisplayComponent_Version = "IVRDisplayComponent_002";
+
+}
+
+// ivrdriverdirectmodecomponent.h
+namespace vr
+{
+
+
+	// ----------------------------------------------------------------------------------------------
+	// Purpose: This component is used for drivers that implement direct mode entirely on their own
+	//			without allowing the VR Compositor to own the window/device. Chances are you don't
+	//			need to implement this component in your driver.
+	// ----------------------------------------------------------------------------------------------
+	class IVRDriverDirectModeComponent
+	{
+	public:
+
+		// -----------------------------------
+		// Direct mode methods
+		// -----------------------------------
+
+		/** Specific to Oculus compositor support, textures supplied must be created using this method. */
+		struct SwapTextureSetDesc_t
+		{
+			uint32_t nWidth;
+			uint32_t nHeight;
+			uint32_t nFormat;
+			uint32_t nSampleCount;
+		};
+		virtual void CreateSwapTextureSet( uint32_t unPid, const SwapTextureSetDesc_t *pSwapTextureSetDesc, vr::SharedTextureHandle_t( *pSharedTextureHandles )[ 3 ] ) {}
+
+		/** Used to textures created using CreateSwapTextureSet.  Only one of the set's handles needs to be used to destroy the entire set. */
+		virtual void DestroySwapTextureSet( vr::SharedTextureHandle_t sharedTextureHandle ) {}
+
+		/** Used to purge all texture sets for a given process. */
+		virtual void DestroyAllSwapTextureSets( uint32_t unPid ) {}
+
+		/** After Present returns, calls this to get the next index to use for rendering. */
+		virtual void GetNextSwapTextureSetIndex( vr::SharedTextureHandle_t sharedTextureHandles[ 2 ], uint32_t( *pIndices )[ 2 ] ) {}
+
+		/** Call once per layer to draw for this frame.  One shared texture handle per eye.  Textures must be created
+		* using CreateSwapTextureSet and should be alternated per frame.  Call Present once all layers have been submitted. */
+		struct SubmitLayerPerEye_t
+		{
+			// Shared texture handles (depth not always provided).
+			vr::SharedTextureHandle_t hTexture, hDepthTexture;
+
+			// Valid region of provided texture (and depth).
+			vr::VRTextureBounds_t bounds;
+
+			// Projection matrix used to render the depth buffer.
+			vr::HmdMatrix44_t mProjection;
+
+			// Hmd pose used to render this layer.
+			vr::HmdMatrix34_t mHmdPose;
+		};
+		virtual void SubmitLayer( const SubmitLayerPerEye_t( &perEye )[ 2 ] ) {}
+
+		/** Submits queued layers for display. */
+		virtual void Present( vr::SharedTextureHandle_t syncTexture ) {}
+
+		/** Called after Present to allow driver to take more time until vsync after they've successfully acquired the sync texture in Present.*/
+		virtual void PostPresent() {}
+
+		/** Called to get additional frame timing stats from driver.  Check m_nSize for versioning (new members will be added to end only). */
+		virtual void GetFrameTiming( DriverDirectMode_FrameTiming *pFrameTiming ) {}
+	};
+
+	static const char *IVRDriverDirectModeComponent_Version = "IVRDriverDirectModeComponent_006";
+
+}
+
+// ivrcameracomponent.h
+namespace vr
+{
+	//-----------------------------------------------------------------------------
+	//-----------------------------------------------------------------------------
+	class ICameraVideoSinkCallback
+	{
+	public:
+		virtual void OnCameraVideoSinkCallback() = 0;
+	};
+
+	// ----------------------------------------------------------------------------------------------
+	// Purpose: The camera on a single tracked device
+	// ----------------------------------------------------------------------------------------------
+	class IVRCameraComponent
+	{
+	public:
+		// ------------------------------------
+		// Camera Methods
+		// ------------------------------------
+		virtual bool GetCameraFrameDimensions( vr::ECameraVideoStreamFormat nVideoStreamFormat, uint32_t *pWidth, uint32_t *pHeight ) = 0;
+		virtual bool GetCameraFrameBufferingRequirements( int *pDefaultFrameQueueSize, uint32_t *pFrameBufferDataSize ) = 0;
+		virtual bool SetCameraFrameBuffering( int nFrameBufferCount, void **ppFrameBuffers, uint32_t nFrameBufferDataSize ) = 0;
+		virtual bool SetCameraVideoStreamFormat( vr::ECameraVideoStreamFormat nVideoStreamFormat ) = 0;
+		virtual vr::ECameraVideoStreamFormat GetCameraVideoStreamFormat() = 0;
+		virtual bool StartVideoStream() = 0;
+		virtual void StopVideoStream() = 0;
+		virtual bool IsVideoStreamActive( bool *pbPaused, float *pflElapsedTime ) = 0;
+		virtual const vr::CameraVideoStreamFrame_t *GetVideoStreamFrame() = 0;
+		virtual void ReleaseVideoStreamFrame( const vr::CameraVideoStreamFrame_t *pFrameImage ) = 0;
+		virtual bool SetAutoExposure( bool bEnable ) = 0;
+		virtual bool PauseVideoStream() = 0;
+		virtual bool ResumeVideoStream() = 0;
+		virtual bool GetCameraDistortion( uint32_t nCameraIndex, float flInputU, float flInputV, float *pflOutputU, float *pflOutputV ) = 0;
+		virtual bool GetCameraProjection( uint32_t nCameraIndex, vr::EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, vr::HmdMatrix44_t *pProjection ) = 0;
+		virtual bool SetFrameRate( int nISPFrameRate, int nSensorFrameRate ) = 0;
+		virtual bool SetCameraVideoSinkCallback( vr::ICameraVideoSinkCallback *pCameraVideoSinkCallback ) = 0;
+		virtual bool GetCameraCompatibilityMode( vr::ECameraCompatibilityMode *pCameraCompatibilityMode ) = 0;
+		virtual bool SetCameraCompatibilityMode( vr::ECameraCompatibilityMode nCameraCompatibilityMode ) = 0;
+		virtual bool GetCameraFrameBounds( vr::EVRTrackedCameraFrameType eFrameType, uint32_t *pLeft, uint32_t *pTop, uint32_t *pWidth, uint32_t *pHeight ) = 0;
+		virtual bool GetCameraIntrinsics( uint32_t nCameraIndex, vr::EVRTrackedCameraFrameType eFrameType, HmdVector2_t *pFocalLength, HmdVector2_t *pCenter, vr::EVRDistortionFunctionType *peDistortionType, double rCoefficients[ k_unMaxDistortionFunctionParameters ] ) = 0;
+	};
+
+	static const char *IVRCameraComponent_Version = "IVRCameraComponent_003";
+}
+// itrackeddevicedriverprovider.h
+namespace vr
+{
+
+class ITrackedDeviceServerDriver;
+struct TrackedDeviceDriverInfo_t;
+struct DriverPose_t;
+
+/** This interface is provided by vrserver to allow the driver to notify 
+* the system when something changes about a device. These changes must
+* not change the serial number or class of the device because those values
+* are permanently associated with the device's index. */
+class IVRDriverContext
+{
+public:
+	/** Returns the requested interface. If the interface was not available it will return NULL and fill
+	* out the error. */
+	virtual void *GetGenericInterface( const char *pchInterfaceVersion, EVRInitError *peError = nullptr ) = 0;
+
+	/** Returns the property container handle for this driver */
+	virtual DriverHandle_t GetDriverHandle() = 0;
+};
+
+
+/** This interface must be implemented in each driver. It will be loaded in vrserver.exe */
+class IServerTrackedDeviceProvider
+{
+public:
+	/** initializes the driver. This will be called before any other methods are called.
+	* If Init returns anything other than VRInitError_None the driver DLL will be unloaded.
+	*
+	* pDriverHost will never be NULL, and will always be a pointer to a IServerDriverHost interface
+	*
+	* pchUserDriverConfigDir - The absolute path of the directory where the driver should store user
+	*	config files.
+	* pchDriverInstallDir - The absolute path of the root directory for the driver.
+	*/
+	virtual EVRInitError Init( IVRDriverContext *pDriverContext ) = 0;
+
+	/** cleans up the driver right before it is unloaded */
+	virtual void Cleanup() = 0;
+
+	/** Returns the version of the ITrackedDeviceServerDriver interface used by this driver */
+	virtual const char * const *GetInterfaceVersions() = 0;
+
+	/** Allows the driver do to some work in the main loop of the server. */
+	virtual void RunFrame() = 0;
+
+
+	// ------------  Power State Functions ----------------------- //
+
+	/** Returns true if the driver wants to block Standby mode. */
+	virtual bool ShouldBlockStandbyMode() = 0;
+
+	/** Called when the system is entering Standby mode. The driver should switch itself into whatever sort of low-power
+	* state it has. */
+	virtual void EnterStandby() = 0;
+
+	/** Called when the system is leaving Standby mode. The driver should switch itself back to
+	full operation. */
+	virtual void LeaveStandby() = 0;
+
+};
+
+
+static const char *IServerTrackedDeviceProvider_Version = "IServerTrackedDeviceProvider_004";
+
+
+
+
+/** This interface must be implemented in each driver. It will be loaded in vrclient.dll */
+class IVRWatchdogProvider
+{
+public:
+	/** initializes the driver in watchdog mode. */
+	virtual EVRInitError Init( IVRDriverContext *pDriverContext ) = 0;
+
+	/** cleans up the driver right before it is unloaded */
+	virtual void Cleanup() = 0;
+};
+
+static const char *IVRWatchdogProvider_Version = "IVRWatchdogProvider_001";
+
+
+
+
+/** This is an optional interface drivers may implement. It will be loaded in vrcompositor.exe */
+class IVRCompositorPluginProvider
+{
+public:
+	/** initializes the driver when used to load compositor plugins */
+	virtual EVRInitError Init( IVRDriverContext *pDriverContext ) = 0;
+
+	/** cleans up the driver right before it is unloaded */
+	virtual void Cleanup() = 0;
+
+	/** Returns the versions of interfaces used by this driver */
+	virtual const char * const *GetInterfaceVersions() = 0;
+
+	/** Requests a component interface of the driver for specific functionality. The driver should return NULL
+	* if the requested interface or version is not supported. */
+	virtual void *GetComponent( const char *pchComponentNameAndVersion ) = 0;
+};
+
+static const char *IVRCompositorPluginProvider_Version = "IVRCompositorPluginProvider_001";
+
+}
+// ivrproperties.h
+#include <string>
+#include <vector>
+
+namespace vr
+{
+
+	/** This container is automatically created before a display redirect device is activated.
+	* Any properties in this container will be returned when that property is read from the HMD's
+	* property container. */
+	static const PropertyContainerHandle_t k_ulDisplayRedirectContainer = 0x600000003;
+
+	enum EPropertyWriteType
+	{
+		PropertyWrite_Set = 0,
+		PropertyWrite_Erase = 1,
+		PropertyWrite_SetError = 2
+	};
+
+	struct PropertyWrite_t
+	{
+		ETrackedDeviceProperty prop;
+		EPropertyWriteType writeType;
+		ETrackedPropertyError eSetError;
+		void *pvBuffer;
+		uint32_t unBufferSize;
+		PropertyTypeTag_t unTag;
+		ETrackedPropertyError eError;
+	};
+
+	struct PropertyRead_t
+	{
+		ETrackedDeviceProperty prop;
+		void *pvBuffer;
+		uint32_t unBufferSize;
+		PropertyTypeTag_t unTag;
+		uint32_t unRequiredBufferSize;
+		ETrackedPropertyError eError;
+	};
+
+
+class IVRProperties
+{
+public:
+
+	/** Reads a set of properties atomically. See the PropertyReadBatch_t struct for more information. */
+	virtual ETrackedPropertyError ReadPropertyBatch( PropertyContainerHandle_t ulContainerHandle, PropertyRead_t *pBatch, uint32_t unBatchEntryCount ) = 0;
+
+	/** Writes a set of properties atomically. See the PropertyWriteBatch_t struct for more information. */
+	virtual ETrackedPropertyError WritePropertyBatch( PropertyContainerHandle_t ulContainerHandle, PropertyWrite_t *pBatch, uint32_t unBatchEntryCount ) = 0;
+
+	/** returns a string that corresponds with the specified property error. The string will be the name
+	* of the error enum value for all valid error codes */
+	virtual const char *GetPropErrorNameFromEnum( ETrackedPropertyError error ) = 0;
+
+	/** Returns a container handle given a tracked device index */
+	virtual PropertyContainerHandle_t TrackedDeviceToPropertyContainer( TrackedDeviceIndex_t nDevice ) = 0;
+};
+
+static const char * const IVRProperties_Version = "IVRProperties_001";
+
+class CVRPropertyHelpers
+{
+public:
+	CVRPropertyHelpers( IVRProperties * pProperties ) : m_pProperties( pProperties ) {}
+
+	/** Returns a scaler property. If the device index is not valid or the property value type does not match,
+	* this function will return false. */
+	bool GetBoolProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L );
+	float GetFloatProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L );
+	int32_t GetInt32Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L );
+	uint64_t GetUint64Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L );
+	HmdVector2_t GetVec2Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L );
+	HmdVector3_t GetVec3Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L );
+	HmdVector4_t GetVec4Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L );
+	double GetDoubleProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L );
+
+	/** Returns a single typed property. If the device index is not valid or the property is not a string type this function will
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters. */
+	uint32_t GetProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, VR_OUT_STRING() void *pvBuffer, uint32_t unBufferSize, PropertyTypeTag_t *punTag, ETrackedPropertyError *pError = 0L );
+
+
+	/** Returns a string property. If the device index is not valid or the property is not a string type this function will
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters. */
+	uint32_t GetStringProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError = 0L );
+
+	/** Returns a string property as a std::string. If the device index is not valid or the property is not a string type this function will
+	* return an empty string. */
+	std::string GetStringProperty( vr::PropertyContainerHandle_t ulContainer, vr::ETrackedDeviceProperty prop, vr::ETrackedPropertyError *peError = nullptr );
+
+	/** Reads a std::vector of data from a property. */
+	template< typename T>
+	ETrackedPropertyError GetPropertyVector( PropertyContainerHandle_t ulContainer, ETrackedDeviceProperty prop, PropertyTypeTag_t unExpectedTag, std::vector<T> *pvecResults );
+
+	/** Sets a scaler property. The new value will be returned on any subsequent call to get this property in any process. */
+	ETrackedPropertyError SetBoolProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, bool bNewValue );
+	ETrackedPropertyError SetFloatProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, float fNewValue );
+	ETrackedPropertyError SetInt32Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, int32_t nNewValue );
+	ETrackedPropertyError SetUint64Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, uint64_t ulNewValue );
+	ETrackedPropertyError SetVec2Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, const HmdVector2_t & vNewValue );
+	ETrackedPropertyError SetVec3Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, const HmdVector3_t & vNewValue );
+	ETrackedPropertyError SetVec4Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, const HmdVector4_t & vNewValue );
+	ETrackedPropertyError SetDoubleProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, double vNewValue );
+
+	/** Sets a string property. The new value will be returned on any subsequent call to get this property in any process. */
+	ETrackedPropertyError SetStringProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, const char *pchNewValue );
+
+	/** Sets a single typed property. The new value will be returned on any subsequent call to get this property in any process. */
+	ETrackedPropertyError SetProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, void *pvNewValue, uint32_t unNewValueSize, PropertyTypeTag_t unTag );
+
+	/** Sets the error return value for a property. This value will be returned on all subsequent requests to get the property */
+	ETrackedPropertyError SetPropertyError( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError eError );
+
+	/** Clears any value or error set for the property. */
+	ETrackedPropertyError EraseProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop );
+
+	/* Turns a device index into a property container handle. */
+	PropertyContainerHandle_t TrackedDeviceToPropertyContainer( TrackedDeviceIndex_t nDevice ) { return m_pProperties->TrackedDeviceToPropertyContainer( nDevice );  }
+
+	/** Sets a std::vector of typed data to a property. */
+	template< typename T>
+	ETrackedPropertyError SetPropertyVector( PropertyContainerHandle_t ulContainer, ETrackedDeviceProperty prop, PropertyTypeTag_t unExpectedTag, std::vector<T> *vecProperties );
+
+	/** Returns true if the specified property is set on the specified container */
+	bool IsPropertySet( PropertyContainerHandle_t ulContainer, ETrackedDeviceProperty prop, ETrackedPropertyError *peError = nullptr );
+private:
+	template<typename T>
+	T GetPropertyHelper( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError, T bDefault, PropertyTypeTag_t unTypeTag );
+
+	IVRProperties *m_pProperties;
+};
+
+
+inline uint32_t CVRPropertyHelpers::GetProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, VR_OUT_STRING() void *pvBuffer, uint32_t unBufferSize, PropertyTypeTag_t *punTag, ETrackedPropertyError *pError )
+{
+	PropertyRead_t batch;
+	batch.prop = prop;
+	batch.pvBuffer = pvBuffer;
+	batch.unBufferSize = unBufferSize;
+
+	m_pProperties->ReadPropertyBatch( ulContainerHandle, &batch, 1 );
+
+	if ( pError )
+	{
+		*pError = batch.eError;
+	}
+
+	if ( punTag )
+	{
+		*punTag = batch.unTag;
+	}
+
+	return batch.unRequiredBufferSize;
+}
+
+
+/** Sets a single typed property. The new value will be returned on any subsequent call to get this property in any process. */
+inline ETrackedPropertyError CVRPropertyHelpers::SetProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, void *pvNewValue, uint32_t unNewValueSize, PropertyTypeTag_t unTag )
+{
+	PropertyWrite_t batch;
+	batch.writeType = PropertyWrite_Set;
+	batch.prop = prop;
+	batch.pvBuffer = pvNewValue;
+	batch.unBufferSize = unNewValueSize;
+	batch.unTag = unTag;
+
+	m_pProperties->WritePropertyBatch( ulContainerHandle, &batch, 1 );
+
+	return batch.eError;
+}
+
+
+/** Returns a string property. If the device index is not valid or the property is not a string type this function will
+* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+* null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters. */
+inline uint32_t CVRPropertyHelpers::GetStringProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError )
+{
+	PropertyTypeTag_t unTag;
+	ETrackedPropertyError error;
+	uint32_t unRequiredSize = GetProperty( ulContainerHandle, prop, pchValue, unBufferSize, &unTag, &error );
+	if ( unTag != k_unStringPropertyTag && error == TrackedProp_Success )
+	{
+		error = TrackedProp_WrongDataType;
+	}
+
+	if ( pError )
+	{
+		*pError = error;
+	}
+
+	if ( error != TrackedProp_Success )
+	{
+		if ( pchValue && unBufferSize )
+		{
+			*pchValue = '\0';
+		}
+	}
+
+	return unRequiredSize;
+}
+
+
+/** Returns a string property as a std::string. If the device index is not valid or the property is not a string type this function will
+* return an empty string. */
+inline std::string CVRPropertyHelpers::GetStringProperty( vr::PropertyContainerHandle_t ulContainer, vr::ETrackedDeviceProperty prop, vr::ETrackedPropertyError *peError )
+{
+	char buf[1024];
+	vr::ETrackedPropertyError err;
+	uint32_t unRequiredBufferLen = GetStringProperty( ulContainer, prop, buf, sizeof(buf), &err );
+
+	std::string sResult;
+
+	if ( err == TrackedProp_Success )
+	{
+		sResult = buf;
+	}
+	else if ( err == TrackedProp_BufferTooSmall )
+	{
+		char *pchBuffer = new char[unRequiredBufferLen];
+		unRequiredBufferLen = GetStringProperty( ulContainer, prop, pchBuffer, unRequiredBufferLen, &err );
+		sResult = pchBuffer;
+		delete[] pchBuffer;
+	}
+
+	if ( peError )
+	{
+		*peError = err;
+	}
+
+	return sResult;
+}
+
+
+/** Sets a string property. The new value will be returned on any subsequent call to get this property in any process. */
+inline ETrackedPropertyError CVRPropertyHelpers::SetStringProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, const char *pchNewValue )
+{
+	if ( !pchNewValue )
+		return TrackedProp_InvalidOperation;
+
+	// this is strlen without the dependency on string.h
+	const char *pchCurr = pchNewValue;
+	while ( *pchCurr )
+	{
+		pchCurr++;
+	}
+
+	return SetProperty( ulContainerHandle, prop, (void *)pchNewValue, (uint32_t)(pchCurr - pchNewValue) + 1, k_unStringPropertyTag );
+}
+
+
+template<typename T>
+inline T CVRPropertyHelpers::GetPropertyHelper( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError, T bDefault, PropertyTypeTag_t unTypeTag )
+{
+	T bValue;
+	ETrackedPropertyError eError;
+	PropertyTypeTag_t unReadTag;
+	GetProperty( ulContainerHandle, prop, &bValue, sizeof( bValue ), &unReadTag, &eError );
+	if ( unReadTag != unTypeTag && eError == TrackedProp_Success )
+	{
+		eError = TrackedProp_WrongDataType;
+	};
+
+	if ( pError )
+		*pError = eError;
+	if ( eError != TrackedProp_Success )
+	{
+		return bDefault;
+	}
+	else
+	{
+		return bValue;
+	}
+}
+
+
+inline bool CVRPropertyHelpers::GetBoolProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError )
+{
+	return GetPropertyHelper<bool>( ulContainerHandle, prop, pError, false, k_unBoolPropertyTag );
+}
+
+inline float CVRPropertyHelpers::GetFloatProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError )
+{
+	return GetPropertyHelper<float>( ulContainerHandle, prop, pError, 0.f, k_unFloatPropertyTag );
+}
+
+inline double CVRPropertyHelpers::GetDoubleProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError )
+{
+	return GetPropertyHelper<double>( ulContainerHandle, prop, pError, 0., k_unDoublePropertyTag );
+}
+
+inline int32_t CVRPropertyHelpers::GetInt32Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError )
+{
+	return GetPropertyHelper<int32_t>( ulContainerHandle, prop, pError, 0, k_unInt32PropertyTag );
+}
+
+inline uint64_t CVRPropertyHelpers::GetUint64Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError )
+{
+	return GetPropertyHelper<uint64_t>( ulContainerHandle, prop, pError, 0, k_unUint64PropertyTag );
+}
+
+inline HmdVector2_t CVRPropertyHelpers::GetVec2Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError )
+{
+	HmdVector2_t defaultval = { 0 };
+	return GetPropertyHelper<HmdVector2_t>( ulContainerHandle, prop, pError, defaultval, k_unHmdVector2PropertyTag );
+}
+
+inline HmdVector3_t CVRPropertyHelpers::GetVec3Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError )
+{
+	HmdVector3_t defaultval = { 0 };
+	return GetPropertyHelper<HmdVector3_t>( ulContainerHandle, prop, pError, defaultval, k_unHmdVector3PropertyTag );
+}
+
+inline HmdVector4_t CVRPropertyHelpers::GetVec4Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError )
+{
+	HmdVector4_t defaultval = { 0 };
+	return GetPropertyHelper<HmdVector4_t>( ulContainerHandle, prop, pError, defaultval, k_unHmdVector4PropertyTag );
+}
+
+inline ETrackedPropertyError CVRPropertyHelpers::SetBoolProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, bool bNewValue )
+{
+	return SetProperty( ulContainerHandle, prop, &bNewValue, sizeof( bNewValue ), k_unBoolPropertyTag );
+}
+
+inline ETrackedPropertyError CVRPropertyHelpers::SetFloatProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, float fNewValue )
+{
+	return SetProperty( ulContainerHandle, prop, &fNewValue, sizeof( fNewValue ), k_unFloatPropertyTag );
+}
+
+inline ETrackedPropertyError CVRPropertyHelpers::SetDoubleProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, double fNewValue )
+{
+	return SetProperty( ulContainerHandle, prop, &fNewValue, sizeof( fNewValue ), k_unDoublePropertyTag );
+}
+
+inline ETrackedPropertyError CVRPropertyHelpers::SetInt32Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, int32_t nNewValue )
+{
+	return SetProperty( ulContainerHandle, prop, &nNewValue, sizeof( nNewValue ), k_unInt32PropertyTag );
+}
+
+inline ETrackedPropertyError CVRPropertyHelpers::SetUint64Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, uint64_t ulNewValue )
+{
+	return SetProperty( ulContainerHandle, prop, &ulNewValue, sizeof( ulNewValue ), k_unUint64PropertyTag );
+}
+
+inline ETrackedPropertyError CVRPropertyHelpers::SetVec2Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, const HmdVector2_t & vNewValue )
+{
+	return SetProperty( ulContainerHandle, prop, ( void * ) &vNewValue, sizeof( HmdVector2_t ), k_unHmdVector2PropertyTag );
+}
+
+inline ETrackedPropertyError CVRPropertyHelpers::SetVec3Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, const HmdVector3_t & vNewValue )
+{
+	return SetProperty( ulContainerHandle, prop, ( void * ) &vNewValue, sizeof( HmdVector3_t ), k_unHmdVector3PropertyTag );
+}
+
+inline ETrackedPropertyError CVRPropertyHelpers::SetVec4Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, const HmdVector4_t & vNewValue )
+{
+	return SetProperty( ulContainerHandle, prop, ( void * ) &vNewValue, sizeof( HmdVector4_t ), k_unHmdVector4PropertyTag );
+}
+
+/** Sets the error return value for a property. This value will be returned on all subsequent requests to get the property */
+inline ETrackedPropertyError CVRPropertyHelpers::SetPropertyError( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError eError )
+{
+	PropertyWrite_t batch;
+	batch.writeType = PropertyWrite_SetError;
+	batch.prop = prop;
+	batch.eSetError = eError;
+
+	m_pProperties->WritePropertyBatch( ulContainerHandle, &batch, 1 );
+
+	return batch.eError;
+}
+
+/** Clears any value or error set for the property. */
+inline ETrackedPropertyError CVRPropertyHelpers::EraseProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop )
+{
+	PropertyWrite_t batch;
+	batch.writeType = PropertyWrite_Erase;
+	batch.prop = prop;
+
+	m_pProperties->WritePropertyBatch( ulContainerHandle, &batch, 1 );
+
+	return batch.eError;
+
+}
+
+template< typename T >
+ETrackedPropertyError CVRPropertyHelpers::SetPropertyVector(PropertyContainerHandle_t ulContainer, vr::ETrackedDeviceProperty prop, PropertyTypeTag_t unTag, std::vector<T> *pvecProperties)
+{
+	return SetProperty( ulContainer, prop, &(*pvecProperties)[0], (uint32_t)(pvecProperties->size() * sizeof( T )), unTag );
+}
+
+template< typename T >
+ETrackedPropertyError CVRPropertyHelpers::GetPropertyVector( PropertyContainerHandle_t ulContainer, ETrackedDeviceProperty prop, PropertyTypeTag_t unExpectedTag, std::vector<T> *pvecResults )
+{
+	ETrackedPropertyError err;
+	PropertyTypeTag_t unTag;
+	uint32_t unNeeded;
+	if ( pvecResults->empty() )
+		unNeeded = GetProperty( ulContainer, prop, nullptr, 0, &unTag, &err );
+	else
+		unNeeded = GetProperty( ulContainer, prop, &(*pvecResults)[0], (uint32_t)(pvecResults->size() * sizeof( T )), &unTag, &err );
+	uint32_t unFound = unNeeded / sizeof( T );
+	if ( err == TrackedProp_Success )
+	{
+		if ( unTag != unExpectedTag && unFound > 0 )
+		{
+			return TrackedProp_WrongDataType;
+		}
+
+		pvecResults->resize( unFound );
+		return TrackedProp_Success;
+	}
+	else if ( err == TrackedProp_BufferTooSmall )
+	{
+		pvecResults->resize( unFound );
+		unNeeded = GetProperty( ulContainer, prop, &(*pvecResults)[0], (uint32_t)(pvecResults->size() * sizeof( T )), &unTag, &err );
+		unFound = unNeeded / sizeof( T );
+
+		if ( err == TrackedProp_Success )
+		{
+			if ( unTag != unExpectedTag )
+			{
+				return TrackedProp_WrongDataType;
+			}
+
+			pvecResults->resize( unFound );
+			return TrackedProp_Success;
+		}
+	}
+	return err;
+}
+
+inline bool CVRPropertyHelpers::IsPropertySet( PropertyContainerHandle_t ulContainer, ETrackedDeviceProperty prop, ETrackedPropertyError *peError )
+{
+	ETrackedPropertyError error;
+	GetProperty( ulContainer, prop, nullptr, 0, nullptr, &error );
+	if ( peError )
+		*peError = error;
+	return error == TrackedProp_Success || error == TrackedProp_BufferTooSmall;
+}
+
+}
+
+
+
+// ivrdriverinput.h
+namespace vr
+{
+
+	typedef uint64_t VRInputComponentHandle_t;
+	static const VRInputComponentHandle_t k_ulInvalidInputComponentHandle = 0;
+
+	enum EVRScalarType
+	{
+		VRScalarType_Absolute = 0,
+		VRScalarType_Relative = 1,
+	};
+
+
+	enum EVRScalarUnits
+	{
+		VRScalarUnits_NormalizedOneSided = 0, // Value ranges from 0 to 1
+		VRScalarUnits_NormalizedTwoSided = 1, // Value ranges from -1 to 1
+	};
+
+	class IVRDriverInput
+	{
+	public:
+
+		/** Creates a boolean input component for the device */
+		virtual EVRInputError CreateBooleanComponent( PropertyContainerHandle_t ulContainer, const char *pchName, VRInputComponentHandle_t *pHandle ) = 0;
+
+		/** Updates a boolean component */
+		virtual EVRInputError UpdateBooleanComponent( VRInputComponentHandle_t ulComponent, bool bNewValue, double fTimeOffset ) = 0;
+
+		/** Creates a scalar input component for the device */
+		virtual EVRInputError CreateScalarComponent( PropertyContainerHandle_t ulContainer, const char *pchName, VRInputComponentHandle_t *pHandle, EVRScalarType eType, EVRScalarUnits eUnits ) = 0;
+
+		/** Updates a boolean component */
+		virtual EVRInputError UpdateScalarComponent( VRInputComponentHandle_t ulComponent, float fNewValue, double fTimeOffset ) = 0;
+
+		/** Creates a haptic component for the device */
+		virtual EVRInputError CreateHapticComponent( PropertyContainerHandle_t ulContainer, const char *pchName, VRInputComponentHandle_t *pHandle ) = 0;
+
+		/** Creates a skeleton component. */
+		virtual EVRInputError CreateSkeletonComponent( PropertyContainerHandle_t ulContainer, const char *pchName, const char *pchSkeletonPath, const char *pchBasePosePath, EVRSkeletalTrackingLevel eSkeletalTrackingLevel, const VRBoneTransform_t *pGripLimitTransforms, uint32_t unGripLimitTransformCount, VRInputComponentHandle_t *pHandle ) = 0;
+
+		/** Updates a skeleton component. */
+		virtual EVRInputError UpdateSkeletonComponent( VRInputComponentHandle_t ulComponent, EVRSkeletalMotionRange eMotionRange, const VRBoneTransform_t *pTransforms, uint32_t unTransformCount ) = 0;
+
+	};
+
+	static const char * const IVRDriverInput_Version = "IVRDriverInput_003";
+
+} // namespace vr
+
+// ivrdriverlog.h
+namespace vr
+{
+
+class IVRDriverLog
+{
+public:
+	/** Writes a log message to the log file prefixed with the driver name */
+	virtual void Log( const char *pchLogMessage ) = 0;
+};
+
+
+static const char *IVRDriverLog_Version = "IVRDriverLog_001";
+
+}
+// ivrserverdriverhost.h
+namespace vr
+{
+
+class ITrackedDeviceServerDriver;
+struct TrackedDeviceDriverInfo_t;
+struct DriverPose_t;
+
+/** This interface is provided by vrserver to allow the driver to notify 
+* the system when something changes about a device. These changes must
+* not change the serial number or class of the device because those values
+* are permanently associated with the device's index. */
+class IVRServerDriverHost
+{
+public:
+	/** Notifies the server that a tracked device has been added. If this function returns true
+	* the server will call Activate on the device. If it returns false some kind of error
+	* has occurred and the device will not be activated. */
+	virtual bool TrackedDeviceAdded( const char *pchDeviceSerialNumber, ETrackedDeviceClass eDeviceClass, ITrackedDeviceServerDriver *pDriver ) = 0;
+
+	/** Notifies the server that a tracked device's pose has been updated */
+	virtual void TrackedDevicePoseUpdated( uint32_t unWhichDevice, const DriverPose_t & newPose, uint32_t unPoseStructSize ) = 0;
+
+	/** Notifies the server that vsync has occurred on the the display attached to the device. This is
+	* only permitted on devices of the HMD class. */
+	virtual void VsyncEvent( double vsyncTimeOffsetSeconds ) = 0;
+
+	/** Sends a vendor specific event (VREvent_VendorSpecific_Reserved_Start..VREvent_VendorSpecific_Reserved_End */
+	virtual void VendorSpecificEvent( uint32_t unWhichDevice, vr::EVREventType eventType, const VREvent_Data_t & eventData, double eventTimeOffset ) = 0;
+
+	/** Returns true if SteamVR is exiting */
+	virtual bool IsExiting() = 0;
+
+	/** Returns true and fills the event with the next event on the queue if there is one. If there are no events
+	* this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct */
+	virtual bool PollNextEvent( VREvent_t *pEvent, uint32_t uncbVREvent ) = 0;
+
+	/** Provides access to device poses for drivers.  Poses are in their "raw" tracking space which is uniquely
+	* defined by each driver providing poses for its devices.  It is up to clients of this function to correlate
+	* poses across different drivers.  Poses are indexed by their device id, and their associated driver and
+	* other properties can be looked up via IVRProperties. */
+	virtual void GetRawTrackedDevicePoses( float fPredictedSecondsFromNow, TrackedDevicePose_t *pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount ) = 0;
+
+	/** Notifies the server that a tracked device's display component transforms have been updated. */
+	virtual void TrackedDeviceDisplayTransformUpdated( uint32_t unWhichDevice, HmdMatrix34_t eyeToHeadLeft, HmdMatrix34_t eyeToHeadRight ) = 0;
+
+	/** Requests that SteamVR be restarted. The provided reason will be displayed to the user and should be in the current locale. */
+	virtual void RequestRestart( const char *pchLocalizedReason, const char *pchExecutableToStart, const char *pchArguments, const char *pchWorkingDirectory ) = 0;
+
+	/** Interface for copying a range of timing data.  Frames are returned in ascending order (oldest to newest) with the last being the most recent frame.
+	* Only the first entry's m_nSize needs to be set, as the rest will be inferred from that.  Returns total number of entries filled out. */
+	virtual uint32_t GetFrameTimings( Compositor_FrameTiming *pTiming, uint32_t nFrames ) = 0;
+};
+
+static const char *IVRServerDriverHost_Version = "IVRServerDriverHost_005";
+
+}
+
+// ivrcompositordriverhost.h
+namespace vr
+{
+
+class IVRCompositorDriverHost
+{
+public:
+	/** Returns true and fills the event with the next event on the queue if there is one. If there are no events
+	* this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct */
+	virtual bool PollNextEvent( VREvent_t *pEvent, uint32_t uncbVREvent ) = 0;
+};
+
+static const char *IVRCompositorDriverHost_Version = "IVRCompositorDriverHost_001";
+
+}
+
+// ivrhiddenarea.h
+namespace vr
+{
+
+class CVRHiddenAreaHelpers
+{
+public:
+	CVRHiddenAreaHelpers( IVRProperties *pProperties ) : m_pProperties( pProperties ) {}
+
+	/** Stores a hidden area mesh in a property */
+	ETrackedPropertyError SetHiddenArea( EVREye eEye, EHiddenAreaMeshType type, HmdVector2_t *pVerts, uint32_t unVertCount );
+
+	/** retrieves a hidden area mesh from a property. Returns the vert count read out of the property.  */
+	uint32_t GetHiddenArea( EVREye eEye, EHiddenAreaMeshType type, HmdVector2_t *pVerts, uint32_t unVertCount, ETrackedPropertyError *peError );
+
+private:
+	ETrackedDeviceProperty GetPropertyEnum( EVREye eEye, EHiddenAreaMeshType type )
+	{
+		return (ETrackedDeviceProperty)(Prop_DisplayHiddenArea_Binary_Start + ((int)type * 2) + (int)eEye);
+	}
+
+	IVRProperties *m_pProperties;
+};
+
+
+inline ETrackedPropertyError CVRHiddenAreaHelpers::SetHiddenArea( EVREye eEye, EHiddenAreaMeshType type, HmdVector2_t *pVerts, uint32_t unVertCount )
+{
+	ETrackedDeviceProperty prop = GetPropertyEnum( eEye, type );
+	CVRPropertyHelpers propHelpers( m_pProperties );
+	return propHelpers.SetProperty( propHelpers.TrackedDeviceToPropertyContainer( k_unTrackedDeviceIndex_Hmd ), prop, pVerts, sizeof( HmdVector2_t ) * unVertCount, k_unHiddenAreaPropertyTag );
+}
+
+
+inline uint32_t CVRHiddenAreaHelpers::GetHiddenArea( EVREye eEye, EHiddenAreaMeshType type, HmdVector2_t *pVerts, uint32_t unVertCount, ETrackedPropertyError *peError )
+{
+	ETrackedDeviceProperty prop = GetPropertyEnum( eEye, type );
+	CVRPropertyHelpers propHelpers( m_pProperties );
+	ETrackedPropertyError propError;
+	PropertyTypeTag_t unTag;
+	uint32_t unBytesNeeded = propHelpers.GetProperty( propHelpers.TrackedDeviceToPropertyContainer( k_unTrackedDeviceIndex_Hmd ), prop, pVerts, sizeof( HmdVector2_t )*unVertCount, &unTag, &propError );
+	if ( propError == TrackedProp_Success && unTag != k_unHiddenAreaPropertyTag )
+	{
+		propError = TrackedProp_WrongDataType;
+		unBytesNeeded = 0;
+	}
+
+	if ( peError )
+	{
+		*peError = propError;
+	}
+
+	return unBytesNeeded / sizeof( HmdVector2_t );
+}
+
+}
+// ivrwatchdoghost.h
+namespace vr
+{
+
+/** This interface is provided by vrclient to allow the driver to make everything wake up */
+class IVRWatchdogHost
+{
+public:
+	/** Client drivers in watchdog mode should call this when they have received a signal from hardware that should
+	* cause SteamVR to start */
+	virtual void WatchdogWakeUp( vr::ETrackedDeviceClass eDeviceClass ) = 0;
+};
+
+static const char *IVRWatchdogHost_Version = "IVRWatchdogHost_002";
+
+};
+
+
+
+// ivrvirtualdisplay.h
+namespace vr
+{
+	struct PresentInfo_t
+	{
+		SharedTextureHandle_t backbufferTextureHandle;
+		EVSync vsync;
+		uint64_t nFrameId;
+		double flVSyncTimeInSeconds;
+	};
+
+	// ----------------------------------------------------------------------------------------------
+	// Purpose: This component is used for drivers that implement a virtual display (e.g. wireless).
+	// ----------------------------------------------------------------------------------------------
+	class IVRVirtualDisplay
+	{
+	public:
+
+		/** Submits final backbuffer for display. */
+		virtual void Present( const PresentInfo_t *pPresentInfo, uint32_t unPresentInfoSize ) = 0;
+
+		/** Block until the last presented buffer start scanning out. */
+		virtual void WaitForPresent() = 0;
+
+		/** Provides timing data for synchronizing with display. */
+		virtual bool GetTimeSinceLastVsync( float *pfSecondsSinceLastVsync, uint64_t *pulFrameCounter ) = 0;
+	};
+
+	static const char *IVRVirtualDisplay_Version = "IVRVirtualDisplay_002";
+}
+
+
+// ivrresources.h
+namespace vr
+{
+
+class IVRResources
+{
+public:
+
+	// ------------------------------------
+	// Shared Resource Methods
+	// ------------------------------------
+
+	/** Loads the specified resource into the provided buffer if large enough.
+	* Returns the size in bytes of the buffer required to hold the specified resource. */
+	virtual uint32_t LoadSharedResource( const char *pchResourceName, char *pchBuffer, uint32_t unBufferLen ) = 0;
+
+	/** Provides the full path to the specified resource. Resource names can include named directories for
+	* drivers and other things, and this resolves all of those and returns the actual physical path. 
+	* pchResourceTypeDirectory is the subdirectory of resources to look in. */
+	virtual uint32_t GetResourceFullPath( const char *pchResourceName, const char *pchResourceTypeDirectory, VR_OUT_STRING() char *pchPathBuffer, uint32_t unBufferLen ) = 0;
+};
+
+static const char * const IVRResources_Version = "IVRResources_001";
+
+
+}
+// ivriobuffer.h
+namespace vr
+{
+
+typedef uint64_t IOBufferHandle_t;
+static const uint64_t k_ulInvalidIOBufferHandle = 0;
+	
+	enum EIOBufferError
+	{
+		IOBuffer_Success                  = 0,
+		IOBuffer_OperationFailed          = 100,
+		IOBuffer_InvalidHandle            = 101,
+		IOBuffer_InvalidArgument          = 102,
+		IOBuffer_PathExists               = 103,
+		IOBuffer_PathDoesNotExist         = 104,
+		IOBuffer_Permission               = 105,
+	};
+
+	enum EIOBufferMode
+	{
+		IOBufferMode_Read                 = 0x0001,
+		IOBufferMode_Write                = 0x0002,
+		IOBufferMode_Create               = 0x0200,
+	};
+
+	// ----------------------------------------------------------------------------------------------
+	// Purpose:
+	// ----------------------------------------------------------------------------------------------
+	class IVRIOBuffer
+	{
+	public:
+		/** opens an existing or creates a new IOBuffer of unSize bytes */
+		virtual vr::EIOBufferError Open( const char *pchPath, vr::EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, vr::IOBufferHandle_t *pulBuffer ) = 0;
+		
+		/** closes a previously opened or created buffer */
+		virtual vr::EIOBufferError Close( vr::IOBufferHandle_t ulBuffer ) = 0;
+		
+		/** reads up to unBytes from buffer into *pDst, returning number of bytes read in *punRead */
+		virtual vr::EIOBufferError Read( vr::IOBufferHandle_t ulBuffer, void *pDst, uint32_t unBytes, uint32_t *punRead ) = 0;
+		
+		/** writes unBytes of data from *pSrc into a buffer. */
+		virtual vr::EIOBufferError Write( vr::IOBufferHandle_t ulBuffer, void *pSrc, uint32_t unBytes ) = 0;
+		
+		/** retrieves the property container of an buffer. */
+		virtual vr::PropertyContainerHandle_t PropertyContainer( vr::IOBufferHandle_t ulBuffer ) = 0;
+
+		/** inexpensively checks for readers to allow writers to fast-fail potentially expensive copies and writes. */
+		virtual bool HasReaders( vr::IOBufferHandle_t ulBuffer ) = 0;
+	};
+
+	static const char *IVRIOBuffer_Version = "IVRIOBuffer_002";
+}
+
+// ivrdrivermanager.h
+namespace vr
+{
+
+class IVRDriverManager
+{
+public:
+	virtual uint32_t GetDriverCount() const = 0;
+
+	/** Returns the length of the number of bytes necessary to hold this string including the trailing null. */
+	virtual uint32_t GetDriverName( vr::DriverId_t nDriver, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize ) = 0;
+
+	virtual DriverHandle_t GetDriverHandle( const char *pchDriverName ) = 0;
+
+	virtual bool IsEnabled( vr::DriverId_t nDriver ) const = 0;
+};
+
+static const char * const IVRDriverManager_Version = "IVRDriverManager_001";
+
+} // namespace vr
+
+
+
+// ivrdriverspatialanchors.h
+namespace vr
+{
+	struct SpatialAnchorDriverPose_t
+	{
+		/** This position is in the same "world" space (+Y up) as provided by DriverPose_t. */
+		vr::HmdQuaternion_t qWorldRotation;
+		vr::HmdVector3d_t vWorldTranslation;
+
+		/** The pose will automatically start returning VRSpatialAnchorError_NotAvailableInThisUniverse
+		* if this is nonzero and does not match the current universe ID. */
+		uint64_t ulRequiredUniverseId;
+
+		/** When this time expires, SteamVR will start generating
+		* VREvent_SpatialAnchors_RequestPoseUpdate when the pose is read by an application
+		* to let the driver know it is still worth updating.
+		* You can use this facility in several ways:
+		*   1. Set to -1 to never receive an update request for this pose.  The driver
+		*      may still update poses at any time.
+		*   2. Set to 0 to always receive an update request *after* each time the pose
+		*      is read.  The rate of requests could be very high if the application gets
+		*      the pose at framerate.
+		*   3. If the driver knows there is no reason to update the pose for some amount of
+		*      time, it can set that time here and receive the update request reminder later.
+		*   4. If the driver plans to automatically update this pose for some amount of time
+		*      (as it gets better information about the virtual location of this anchor) it can
+		*      set that duration here to indicate that no "update requested" reminders are needed.
+		*      When that automatic update period expires, any future interest in the pose will
+		*      be indicated by a pose update request.
+		* The driver may always update the pose, including during the valid duration. */
+		double fValidDuration;  // seconds
+	};
+
+	class IVRDriverSpatialAnchors
+	{
+	public:
+
+		/* NOTE: You must declare support for spatial anchors in your driver manifest.  Add
+		* "spatialAnchorsSupport": true to your manifest.  Without that setting, SteamVR
+		* will short-circuit anchor requests from applications and provide a generic descriptor
+		* that does not have any of the advantages of true spatial anchors. */
+
+		/* The driver should monitor for events VREvent_SpatialAnchors_RequestPoseUpdate (for new
+		* descriptors from applications that need UpdateSpatialAnchorPose()) and for
+		* VREvent_SpatialAnchors_RequestDescriptorUpdate (for new poses that need UpdateSpatialAnchorDescriptor()).
+		* For automatic pose updates over time, the driver should keep track of the handles it
+		* has seen and provide updates when conditions change.  If the driver uses fValidDuration,
+		* it may wait for VREvent_SpatialAnchors_RequestPoseUpdate instead of keeping track itself. */
+
+		/** Update a pose for a spatial anchor.  Should be called when an event notifies the driver that a
+		* new descriptor has been registered by an application.  May be called for any anchor whenever the
+		* driver has better information about the best virtual coordinate to represent the anchor.  Should
+		* be called on all active handles whenever driver state changes in a way that changes how physical
+		* world locations map to virtual coordinates (e.g. anything that would cause a universe ID change).
+		* This fires an event when it is called for the first time (to alert whoever submitted the descriptor). */
+		virtual EVRSpatialAnchorError UpdateSpatialAnchorPose( SpatialAnchorHandle_t unHandle, const SpatialAnchorDriverPose_t *pPose ) = 0;
+
+		/** Invalidate any pose associated with the handle and cause future calls to GetSpatialAnchorPose (on
+		* both the client and driver side) to return the specified error.  eError must be one of
+		* VRSpatialAnchorError_NotYetAvailable, VRSpatialAnchorError_NotAvailableInThisUniverse, or
+		* VRSpatialAnchorError_PermanentlyUnavailable */
+		virtual EVRSpatialAnchorError SetSpatialAnchorPoseError( SpatialAnchorHandle_t unHandle, EVRSpatialAnchorError eError, double fValidDuration ) = 0;
+
+		/** Update the descriptor for a spatial anchor.  Should be called when an event notifies the driver
+		* that a new pose has been registered by an application.  May be called for any anchor whenever the
+		* driver has better or additional information it wants to include in the anchor descriptor.  Note,
+		* however, that the application may never fetch the updated anchor descriptor and may request the
+		* original descriptor in a future session having ignored the update.
+		* The supplied descriptor should be only the driver's opaque internal data, not the decorated form that
+		* is used by clients (wrapped by runtime metadata).  The descriptor must not contain non-ASCII characters or
+		* the two special characters ~ or "
+		* This fires an event every time it is called. */
+		virtual EVRSpatialAnchorError UpdateSpatialAnchorDescriptor( SpatialAnchorHandle_t unHandle, const char *pchDescriptor ) = 0;
+
+		/** Get the pose for a given handle. */
+		virtual EVRSpatialAnchorError GetSpatialAnchorPose( SpatialAnchorHandle_t unHandle, SpatialAnchorDriverPose_t *pDriverPoseOut ) = 0;
+
+		/** Get the descriptor for a given handle.  This will be VRSpatialAnchorError_NotYetAvailable for handles
+		* where the driver has not yet built a descriptor.  It will be the application-supplied descriptor for previously
+		* saved anchors that the application is requesting poses for.  If the driver has called UpdateSpatialAnchorDescriptor()
+		* already in this session, it will be the descriptor provided by the driver.
+		* If bDecorated, returns the descriptor wrapped with runtime metadata suitable for a client to save.  Else returns only
+		* the driver's opaque internal data.
+		*/
+		virtual EVRSpatialAnchorError GetSpatialAnchorDescriptor( SpatialAnchorHandle_t unHandle, VR_OUT_STRING() char *pchDescriptorOut, uint32_t *punDescriptorBufferLenInOut, bool bDecorated ) = 0;
+
+	};
+
+	static const char * const IVRDriverSpatialAnchors_Version = "IVRDriverSpatialAnchors_001";
+
+} // namespace vr
+
+
+
+namespace vr
+{
+#if !defined( OPENVR_INTERFACE_INTERNAL )
+	static const char * const k_InterfaceVersions[] =
+	{
+		IVRSettings_Version,
+		ITrackedDeviceServerDriver_Version,
+		IVRDisplayComponent_Version,
+		IVRDriverDirectModeComponent_Version,
+		IVRCameraComponent_Version,
+		IServerTrackedDeviceProvider_Version,
+		IVRWatchdogProvider_Version,
+		IVRVirtualDisplay_Version,
+		IVRDriverManager_Version,
+		IVRResources_Version,
+		IVRCompositorPluginProvider_Version,
+		nullptr
+	};
+
+	inline IVRDriverContext *&VRDriverContext()
+	{
+		static IVRDriverContext *pHost;
+		return pHost;
+	}
+
+	class COpenVRDriverContext
+	{
+	public:
+		COpenVRDriverContext() : m_propertyHelpers(nullptr), m_hiddenAreaHelpers(nullptr) { Clear(); }
+		void Clear();
+
+		EVRInitError InitServer();
+		EVRInitError InitWatchdog();
+		EVRInitError InitCompositor();
+
+		IVRSettings *VRSettings()
+		{
+			if ( m_pVRSettings == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRSettings = (IVRSettings *)VRDriverContext()->GetGenericInterface( IVRSettings_Version, &eError );
+			}
+			return m_pVRSettings;
+		}
+
+		IVRProperties *VRPropertiesRaw()
+		{
+			if ( m_pVRProperties == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRProperties = (IVRProperties *)VRDriverContext()->GetGenericInterface( IVRProperties_Version, &eError );
+				m_propertyHelpers = CVRPropertyHelpers( m_pVRProperties );
+				m_hiddenAreaHelpers = CVRHiddenAreaHelpers( m_pVRProperties );
+			}
+			return m_pVRProperties;
+		}
+
+		CVRPropertyHelpers *VRProperties()
+		{
+			VRPropertiesRaw();
+			return &m_propertyHelpers;
+		}
+
+		CVRHiddenAreaHelpers *VRHiddenArea()
+		{
+			VRPropertiesRaw();
+			return &m_hiddenAreaHelpers;
+		}
+
+		IVRServerDriverHost *VRServerDriverHost()
+		{
+			if ( m_pVRServerDriverHost == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRServerDriverHost = (IVRServerDriverHost *)VRDriverContext()->GetGenericInterface( IVRServerDriverHost_Version, &eError );
+			}
+			return m_pVRServerDriverHost;
+		}
+
+		IVRWatchdogHost *VRWatchdogHost()
+		{
+			if ( m_pVRWatchdogHost == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRWatchdogHost = (IVRWatchdogHost *)VRDriverContext()->GetGenericInterface( IVRWatchdogHost_Version, &eError );
+			}
+			return m_pVRWatchdogHost;
+		}
+
+		IVRCompositorDriverHost *VRCompositorDriverHost()
+		{
+			if ( m_pVRCompositorDriverHost == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRCompositorDriverHost = ( IVRCompositorDriverHost * )VRDriverContext()->GetGenericInterface( IVRCompositorDriverHost_Version, &eError );
+			}
+			return m_pVRCompositorDriverHost;
+		}
+
+		IVRDriverLog *VRDriverLog()
+		{
+			if ( m_pVRDriverLog == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRDriverLog = (IVRDriverLog *)VRDriverContext()->GetGenericInterface( IVRDriverLog_Version, &eError );
+			}
+			return m_pVRDriverLog;
+		}
+
+		DriverHandle_t VR_CALLTYPE VRDriverHandle()
+		{
+			return VRDriverContext()->GetDriverHandle();
+		}
+
+		IVRDriverManager *VRDriverManager()
+		{
+			if ( !m_pVRDriverManager )
+			{
+				EVRInitError eError;
+				m_pVRDriverManager = (IVRDriverManager *)VRDriverContext()->GetGenericInterface( IVRDriverManager_Version, &eError );
+			}
+			return m_pVRDriverManager;
+		}
+
+		IVRResources *VRResources()
+		{
+			if ( !m_pVRResources )
+			{
+				EVRInitError eError;
+				m_pVRResources = (IVRResources *)VRDriverContext()->GetGenericInterface( IVRResources_Version, &eError );
+			}
+			return m_pVRResources;
+		}
+
+		IVRDriverInput *VRDriverInput()
+		{
+			if ( !m_pVRDriverInput )
+			{
+				EVRInitError eError;
+				m_pVRDriverInput = (IVRDriverInput *)VRDriverContext()->GetGenericInterface( IVRDriverInput_Version, &eError );
+			}
+			return m_pVRDriverInput;
+		}
+
+		IVRIOBuffer *VRIOBuffer()
+		{
+			if ( !m_pVRIOBuffer )
+			{
+				EVRInitError eError;
+				m_pVRIOBuffer = (IVRIOBuffer *)VRDriverContext()->GetGenericInterface( IVRIOBuffer_Version, &eError );
+			}
+			return m_pVRIOBuffer;
+		}
+		
+		IVRDriverSpatialAnchors *VRDriverSpatialAnchors()
+		{
+			if ( !m_pVRDriverSpatialAnchors )
+			{
+				EVRInitError eError;
+				m_pVRDriverSpatialAnchors = (IVRDriverSpatialAnchors *)VRDriverContext()->GetGenericInterface( IVRDriverSpatialAnchors_Version, &eError );
+			}
+			return m_pVRDriverSpatialAnchors;
+		}
+
+	private:
+		CVRPropertyHelpers		m_propertyHelpers;
+		CVRHiddenAreaHelpers	m_hiddenAreaHelpers;
+
+		IVRSettings				*m_pVRSettings;
+		IVRProperties			*m_pVRProperties;
+		IVRServerDriverHost		*m_pVRServerDriverHost;
+		IVRWatchdogHost			*m_pVRWatchdogHost;
+		IVRCompositorDriverHost	*m_pVRCompositorDriverHost;
+		IVRDriverLog			*m_pVRDriverLog;
+		IVRDriverManager		*m_pVRDriverManager;
+		IVRResources			*m_pVRResources;
+		IVRDriverInput			*m_pVRDriverInput;
+		IVRIOBuffer				*m_pVRIOBuffer;
+		IVRDriverSpatialAnchors *m_pVRDriverSpatialAnchors;
+	};
+
+	inline COpenVRDriverContext &OpenVRInternal_ModuleServerDriverContext()
+	{
+		static void *ctx[sizeof( COpenVRDriverContext ) / sizeof( void * )];
+		return *(COpenVRDriverContext *)ctx; // bypass zero-init constructor
+	}
+
+	inline IVRSettings *VR_CALLTYPE VRSettings() { return OpenVRInternal_ModuleServerDriverContext().VRSettings(); }
+	inline IVRProperties *VR_CALLTYPE VRPropertiesRaw() { return OpenVRInternal_ModuleServerDriverContext().VRPropertiesRaw(); }
+	inline CVRPropertyHelpers *VR_CALLTYPE VRProperties() { return OpenVRInternal_ModuleServerDriverContext().VRProperties(); }
+	inline CVRHiddenAreaHelpers *VR_CALLTYPE VRHiddenArea() { return OpenVRInternal_ModuleServerDriverContext().VRHiddenArea(); }
+	inline IVRDriverLog *VR_CALLTYPE VRDriverLog() { return OpenVRInternal_ModuleServerDriverContext().VRDriverLog(); }
+	inline IVRServerDriverHost *VR_CALLTYPE VRServerDriverHost() { return OpenVRInternal_ModuleServerDriverContext().VRServerDriverHost(); }
+	inline IVRWatchdogHost *VR_CALLTYPE VRWatchdogHost() { return OpenVRInternal_ModuleServerDriverContext().VRWatchdogHost(); }
+	inline IVRCompositorDriverHost *VR_CALLTYPE VRCompositorDriverHost() { return OpenVRInternal_ModuleServerDriverContext().VRCompositorDriverHost(); }
+	inline DriverHandle_t VR_CALLTYPE VRDriverHandle() { return OpenVRInternal_ModuleServerDriverContext().VRDriverHandle(); }
+	inline IVRDriverManager *VR_CALLTYPE VRDriverManager() { return OpenVRInternal_ModuleServerDriverContext().VRDriverManager(); }
+	inline IVRResources *VR_CALLTYPE VRResources() { return OpenVRInternal_ModuleServerDriverContext().VRResources(); }
+	inline IVRDriverInput *VR_CALLTYPE VRDriverInput() { return OpenVRInternal_ModuleServerDriverContext().VRDriverInput(); }
+	inline IVRIOBuffer *VR_CALLTYPE VRIOBuffer() { return OpenVRInternal_ModuleServerDriverContext().VRIOBuffer(); }
+	inline IVRDriverSpatialAnchors *VR_CALLTYPE VRDriverSpatialAnchors() { return OpenVRInternal_ModuleServerDriverContext().VRDriverSpatialAnchors(); }
+
+	inline void COpenVRDriverContext::Clear()
+	{
+		m_pVRSettings = nullptr;
+		m_pVRProperties = nullptr;
+		m_pVRServerDriverHost = nullptr;
+		m_pVRWatchdogHost = nullptr;
+		m_pVRCompositorDriverHost = nullptr;
+		m_pVRDriverLog = nullptr;
+		m_pVRDriverManager = nullptr;
+		m_pVRResources = nullptr;
+		m_pVRDriverInput = nullptr;
+		m_pVRIOBuffer = nullptr;
+		m_pVRDriverSpatialAnchors = nullptr;
+	}
+
+	inline EVRInitError COpenVRDriverContext::InitServer()
+	{
+		Clear();
+		if ( !VRServerDriverHost()
+			|| !VRSettings()
+			|| !VRProperties()
+			|| !VRDriverLog() 
+			|| !VRDriverManager()
+			|| !VRResources() )
+			return VRInitError_Init_InterfaceNotFound;
+		return VRInitError_None;
+	}
+
+	inline EVRInitError COpenVRDriverContext::InitWatchdog()
+	{
+		Clear();
+		if ( !VRWatchdogHost()
+			|| !VRSettings()
+			|| !VRDriverLog() )
+			return VRInitError_Init_InterfaceNotFound;
+		return VRInitError_None;
+	}
+
+	inline EVRInitError COpenVRDriverContext::InitCompositor()
+	{
+		Clear();
+		if ( !VRCompositorDriverHost()
+			|| !VRSettings()
+			|| !VRProperties()
+			|| !VRDriverLog()
+			|| !VRDriverManager()
+			|| !VRResources() )
+			return VRInitError_Init_InterfaceNotFound;
+		return VRInitError_None;
+	}
+
+	inline EVRInitError InitServerDriverContext( IVRDriverContext *pContext )
+	{
+		VRDriverContext() = pContext;
+		return OpenVRInternal_ModuleServerDriverContext().InitServer();
+	}
+
+	inline EVRInitError InitWatchdogDriverContext( IVRDriverContext *pContext )
+	{
+		VRDriverContext() = pContext;
+		return OpenVRInternal_ModuleServerDriverContext().InitWatchdog();
+	}
+
+	inline EVRInitError InitCompositorDriverContext( IVRDriverContext *pContext )
+	{
+		VRDriverContext() = pContext;
+		return OpenVRInternal_ModuleServerDriverContext().InitCompositor();
+	}
+
+	inline void CleanupDriverContext()
+	{
+		VRDriverContext() = nullptr;
+		OpenVRInternal_ModuleServerDriverContext().Clear();
+	}
+
+	#define VR_INIT_SERVER_DRIVER_CONTEXT( pContext ) \
+			{ \
+			vr::EVRInitError eError = vr::InitServerDriverContext( pContext ); \
+			if( eError != vr::VRInitError_None ) \
+				return eError; \
+			}
+
+	#define VR_CLEANUP_SERVER_DRIVER_CONTEXT() \
+		vr::CleanupDriverContext();
+
+	#define VR_INIT_WATCHDOG_DRIVER_CONTEXT( pContext ) \
+			{ \
+			vr::EVRInitError eError = vr::InitWatchdogDriverContext( pContext ); \
+			if( eError != vr::VRInitError_None ) \
+				return eError; \
+			}
+
+	#define VR_CLEANUP_WATCHDOG_DRIVER_CONTEXT() \
+		vr::CleanupDriverContext();
+
+#define VR_INIT_COMPOSITOR_DRIVER_CONTEXT( pContext ) \
+			{ \
+			vr::EVRInitError eError = vr::InitCompositorDriverContext( pContext ); \
+			if( eError != vr::VRInitError_None ) \
+				return eError; \
+			}
+
+#define VR_CLEANUP_COMPOSITOR_DRIVER_CONTEXT() \
+		vr::CleanupDriverContext();
+
+
+#endif // OPENVR_INTERFACE_INTERNAL
+
+}
+// End
+
+#endif // _OPENVR_DRIVER_API
+
+
diff --git a/engine/inc/openvr-x/openvr_mingw.h b/engine/inc/openvr-x/openvr_mingw.h
new file mode 100644
index 00000000..7d28a851
--- /dev/null
+++ b/engine/inc/openvr-x/openvr_mingw.h
@@ -0,0 +1,5967 @@
+#pragma once
+
+// openvr.h
+//========= Copyright Valve Corporation ============//
+// Dynamically generated file. Do not modify this file directly.
+
+#ifndef _OPENVR_API
+#define _OPENVR_API
+
+#include <stdint.h>
+
+
+
+// version.h
+namespace vr
+{
+	static const uint32_t k_nSteamVRVersionMajor = 1;
+	static const uint32_t k_nSteamVRVersionMinor = 11;
+	static const uint32_t k_nSteamVRVersionBuild = 11;
+} // namespace vr
+
+// vrtypes.h
+#ifndef _INCLUDE_VRTYPES_H
+#define _INCLUDE_VRTYPES_H
+
+// Forward declarations to avoid requiring vulkan.h
+struct VkDevice_T;
+struct VkPhysicalDevice_T;
+struct VkInstance_T;
+struct VkQueue_T;
+
+// Forward declarations to avoid requiring d3d12.h
+struct ID3D12Resource;
+struct ID3D12CommandQueue;
+
+namespace vr
+{
+#pragma pack( push, 8 )
+
+/** A handle for a spatial anchor.  This handle is only valid during the session it was created in.
+* Anchors that live beyond one session should be saved by their string descriptors. */
+typedef uint32_t SpatialAnchorHandle_t;
+
+typedef void* glSharedTextureHandle_t;
+typedef int32_t glInt_t;
+typedef uint32_t glUInt_t;
+
+// right-handed system
+// +y is up
+// +x is to the right
+// -z is forward
+// Distance unit is  meters
+struct HmdMatrix34_t
+{
+	float m[3][4];
+};
+
+struct HmdMatrix33_t
+{
+	float m[3][3];
+};
+
+struct HmdMatrix44_t
+{
+	float m[4][4];
+};
+
+struct HmdVector3_t
+{
+	float v[3];
+};
+
+struct HmdVector4_t
+{
+	float v[4];
+};
+
+struct HmdVector3d_t
+{
+	double v[3];
+};
+
+struct HmdVector2_t
+{
+	float v[2];
+};
+
+struct HmdQuaternion_t
+{
+	double w, x, y, z;
+};
+
+struct HmdQuaternionf_t
+{
+	float w, x, y, z;
+};
+
+struct HmdColor_t
+{
+	float r, g, b, a;
+};
+
+struct HmdQuad_t
+{
+	HmdVector3_t vCorners[ 4 ];
+};
+
+struct HmdRect2_t
+{
+	HmdVector2_t vTopLeft;
+	HmdVector2_t vBottomRight;
+};
+
+/** Used to return the post-distortion UVs for each color channel. 
+* UVs range from 0 to 1 with 0,0 in the upper left corner of the 
+* source render target. The 0,0 to 1,1 range covers a single eye. */
+struct DistortionCoordinates_t
+{
+	float rfRed[2];
+	float rfGreen[2];
+	float rfBlue[2];
+};
+
+enum EVREye
+{
+	Eye_Left = 0,
+	Eye_Right = 1
+};
+
+enum ETextureType
+{
+	TextureType_Invalid = -1, // Handle has been invalidated
+	TextureType_DirectX = 0, // Handle is an ID3D11Texture
+	TextureType_OpenGL = 1,  // Handle is an OpenGL texture name or an OpenGL render buffer name, depending on submit flags
+	TextureType_Vulkan = 2, // Handle is a pointer to a VRVulkanTextureData_t structure
+	TextureType_IOSurface = 3, // Handle is a macOS cross-process-sharable IOSurfaceRef, deprecated in favor of TextureType_Metal on supported platforms
+	TextureType_DirectX12 = 4, // Handle is a pointer to a D3D12TextureData_t structure
+	TextureType_DXGISharedHandle = 5, // Handle is a HANDLE DXGI share handle, only supported for Overlay render targets. 
+									  // this texture is used directly by our renderer, so only perform atomic (copyresource or resolve) on it
+	TextureType_Metal = 6, // Handle is a MTLTexture conforming to the MTLSharedTexture protocol. Textures submitted to IVRCompositor::Submit which
+						   // are of type MTLTextureType2DArray assume layer 0 is the left eye texture (vr::EVREye::Eye_left), layer 1 is the right
+						   // eye texture (vr::EVREye::Eye_Right)
+};
+
+enum EColorSpace
+{
+	ColorSpace_Auto = 0,	// Assumes 'gamma' for 8-bit per component formats, otherwise 'linear'.  This mirrors the DXGI formats which have _SRGB variants.
+	ColorSpace_Gamma = 1,	// Texture data can be displayed directly on the display without any conversion (a.k.a. display native format).
+	ColorSpace_Linear = 2,	// Same as gamma but has been converted to a linear representation using DXGI's sRGB conversion algorithm.
+};
+
+struct Texture_t
+{
+	void* handle; // See ETextureType definition above
+	ETextureType eType;
+	EColorSpace eColorSpace;
+};
+
+// Handle to a shared texture (HANDLE on Windows obtained using OpenSharedResource).
+typedef uint64_t SharedTextureHandle_t;
+#define INVALID_SHARED_TEXTURE_HANDLE	((vr::SharedTextureHandle_t)0)
+
+enum ETrackingResult
+{
+	TrackingResult_Uninitialized			= 1,
+
+	TrackingResult_Calibrating_InProgress	= 100,
+	TrackingResult_Calibrating_OutOfRange	= 101,
+
+	TrackingResult_Running_OK				= 200,
+	TrackingResult_Running_OutOfRange		= 201,
+
+	TrackingResult_Fallback_RotationOnly	= 300,
+};
+
+typedef uint32_t DriverId_t;
+static const uint32_t k_nDriverNone = 0xFFFFFFFF;
+
+static const uint32_t k_unMaxDriverDebugResponseSize = 32768;
+
+/** Used to pass device IDs to API calls */
+typedef uint32_t TrackedDeviceIndex_t;
+static const uint32_t k_unTrackedDeviceIndex_Hmd = 0;
+static const uint32_t k_unMaxTrackedDeviceCount = 64;
+static const uint32_t k_unTrackedDeviceIndexOther = 0xFFFFFFFE;
+static const uint32_t k_unTrackedDeviceIndexInvalid = 0xFFFFFFFF;
+
+/** Describes what kind of object is being tracked at a given ID */
+enum ETrackedDeviceClass
+{
+	TrackedDeviceClass_Invalid = 0,				// the ID was not valid.
+	TrackedDeviceClass_HMD = 1,					// Head-Mounted Displays
+	TrackedDeviceClass_Controller = 2,			// Tracked controllers
+	TrackedDeviceClass_GenericTracker = 3,		// Generic trackers, similar to controllers
+	TrackedDeviceClass_TrackingReference = 4,	// Camera and base stations that serve as tracking reference points
+	TrackedDeviceClass_DisplayRedirect = 5,		// Accessories that aren't necessarily tracked themselves, but may redirect video output from other tracked devices
+
+	TrackedDeviceClass_Max
+};
+
+
+/** Describes what specific role associated with a tracked device */
+enum ETrackedControllerRole
+{
+	TrackedControllerRole_Invalid = 0,					// Invalid value for controller type
+	TrackedControllerRole_LeftHand = 1,					// Tracked device associated with the left hand
+	TrackedControllerRole_RightHand = 2,				// Tracked device associated with the right hand
+	TrackedControllerRole_OptOut = 3,					// Tracked device is opting out of left/right hand selection
+	TrackedControllerRole_Treadmill = 4,				// Tracked device is a treadmill or other locomotion device
+	TrackedControllerRole_Stylus = 5,					// Tracked device is a stylus
+	TrackedControllerRole_Max = 5
+};
+
+
+/** Returns true if the tracked controller role is allowed to be a hand */
+inline bool IsRoleAllowedAsHand( ETrackedControllerRole eRole )
+{
+	switch ( eRole )
+	{
+	case TrackedControllerRole_Invalid:
+	case TrackedControllerRole_LeftHand:
+	case TrackedControllerRole_RightHand:
+		return true;
+	default:
+		return false;
+	}
+}
+
+
+/** describes a single pose for a tracked object */
+struct TrackedDevicePose_t
+{
+	HmdMatrix34_t mDeviceToAbsoluteTracking;
+	HmdVector3_t vVelocity;				// velocity in tracker space in m/s
+	HmdVector3_t vAngularVelocity;		// angular velocity in radians/s (?)
+	ETrackingResult eTrackingResult;
+	bool bPoseIsValid;
+
+	// This indicates that there is a device connected for this spot in the pose array.
+	// It could go from true to false if the user unplugs the device.
+	bool bDeviceIsConnected;
+};
+
+/** Identifies which style of tracking origin the application wants to use
+* for the poses it is requesting */
+enum ETrackingUniverseOrigin
+{
+	TrackingUniverseSeated = 0,		// Poses are provided relative to the seated zero pose
+	TrackingUniverseStanding = 1,	// Poses are provided relative to the safe bounds configured by the user
+	TrackingUniverseRawAndUncalibrated = 2,	// Poses are provided in the coordinate system defined by the driver.  It has Y up and is unified for devices of the same driver. You usually don't want this one.
+};
+
+enum EAdditionalRadioFeatures
+{
+	AdditionalRadioFeatures_None           = 0x00000000,
+	AdditionalRadioFeatures_HTCLinkBox     = 0x00000001,
+	AdditionalRadioFeatures_InternalDongle = 0x00000002,
+	AdditionalRadioFeatures_ExternalDongle = 0x00000004,
+};
+
+typedef uint64_t WebConsoleHandle_t;
+#define INVALID_WEB_CONSOLE_HANDLE	((vr::WebConsoleHandle_t)0)
+
+// Refers to a single container of properties
+typedef uint64_t PropertyContainerHandle_t;
+typedef uint32_t PropertyTypeTag_t;
+
+static const PropertyContainerHandle_t k_ulInvalidPropertyContainer = 0;
+static const PropertyTypeTag_t k_unInvalidPropertyTag = 0;
+
+typedef PropertyContainerHandle_t DriverHandle_t;
+static const PropertyContainerHandle_t k_ulInvalidDriverHandle = 0;
+
+// Use these tags to set/get common types as struct properties
+static const PropertyTypeTag_t k_unFloatPropertyTag = 1;
+static const PropertyTypeTag_t k_unInt32PropertyTag = 2;
+static const PropertyTypeTag_t k_unUint64PropertyTag = 3;
+static const PropertyTypeTag_t k_unBoolPropertyTag = 4;
+static const PropertyTypeTag_t k_unStringPropertyTag = 5;
+static const PropertyTypeTag_t k_unErrorPropertyTag = 6;
+static const PropertyTypeTag_t k_unDoublePropertyTag = 7;
+
+static const PropertyTypeTag_t k_unHmdMatrix34PropertyTag = 20;
+static const PropertyTypeTag_t k_unHmdMatrix44PropertyTag = 21;
+static const PropertyTypeTag_t k_unHmdVector3PropertyTag = 22;
+static const PropertyTypeTag_t k_unHmdVector4PropertyTag = 23;
+static const PropertyTypeTag_t k_unHmdVector2PropertyTag = 24;
+static const PropertyTypeTag_t k_unHmdQuadPropertyTag = 25;
+
+static const PropertyTypeTag_t k_unHiddenAreaPropertyTag = 30;
+static const PropertyTypeTag_t k_unPathHandleInfoTag = 31;
+static const PropertyTypeTag_t k_unActionPropertyTag = 32;
+static const PropertyTypeTag_t k_unInputValuePropertyTag = 33;
+static const PropertyTypeTag_t k_unWildcardPropertyTag = 34;
+static const PropertyTypeTag_t k_unHapticVibrationPropertyTag = 35;
+static const PropertyTypeTag_t k_unSkeletonPropertyTag = 36;
+
+static const PropertyTypeTag_t k_unSpatialAnchorPosePropertyTag = 40;
+static const PropertyTypeTag_t k_unJsonPropertyTag = 41;
+static const PropertyTypeTag_t k_unActiveActionSetPropertyTag = 42;
+
+static const PropertyTypeTag_t k_unOpenVRInternalReserved_Start = 1000;
+static const PropertyTypeTag_t k_unOpenVRInternalReserved_End = 10000;
+
+
+/** Each entry in this enum represents a property that can be retrieved about a
+* tracked device. Many fields are only valid for one ETrackedDeviceClass. */
+enum ETrackedDeviceProperty
+{
+	Prop_Invalid								= 0,
+
+	// general properties that apply to all device classes
+	Prop_TrackingSystemName_String				= 1000,
+	Prop_ModelNumber_String						= 1001,
+	Prop_SerialNumber_String					= 1002,
+	Prop_RenderModelName_String					= 1003,
+	Prop_WillDriftInYaw_Bool					= 1004,
+	Prop_ManufacturerName_String				= 1005,
+	Prop_TrackingFirmwareVersion_String			= 1006,
+	Prop_HardwareRevision_String				= 1007,
+	Prop_AllWirelessDongleDescriptions_String	= 1008,
+	Prop_ConnectedWirelessDongle_String			= 1009,
+	Prop_DeviceIsWireless_Bool					= 1010,
+	Prop_DeviceIsCharging_Bool					= 1011,
+	Prop_DeviceBatteryPercentage_Float			= 1012, // 0 is empty, 1 is full
+	Prop_StatusDisplayTransform_Matrix34		= 1013,
+	Prop_Firmware_UpdateAvailable_Bool			= 1014,
+	Prop_Firmware_ManualUpdate_Bool				= 1015,
+	Prop_Firmware_ManualUpdateURL_String		= 1016,
+	Prop_HardwareRevision_Uint64				= 1017,
+	Prop_FirmwareVersion_Uint64					= 1018,
+	Prop_FPGAVersion_Uint64						= 1019,
+	Prop_VRCVersion_Uint64						= 1020,
+	Prop_RadioVersion_Uint64					= 1021,
+	Prop_DongleVersion_Uint64					= 1022,
+	Prop_BlockServerShutdown_Bool				= 1023,
+	Prop_CanUnifyCoordinateSystemWithHmd_Bool	= 1024,
+	Prop_ContainsProximitySensor_Bool			= 1025,
+	Prop_DeviceProvidesBatteryStatus_Bool		= 1026,
+	Prop_DeviceCanPowerOff_Bool					= 1027,
+	Prop_Firmware_ProgrammingTarget_String		= 1028,
+	Prop_DeviceClass_Int32						= 1029,
+	Prop_HasCamera_Bool							= 1030,
+	Prop_DriverVersion_String                   = 1031,
+	Prop_Firmware_ForceUpdateRequired_Bool      = 1032,
+	Prop_ViveSystemButtonFixRequired_Bool		= 1033,
+	Prop_ParentDriver_Uint64					= 1034,
+	Prop_ResourceRoot_String					= 1035,
+	Prop_RegisteredDeviceType_String			= 1036,
+	Prop_InputProfilePath_String				= 1037, // input profile to use for this device in the input system. Will default to tracking system name if this isn't provided
+	Prop_NeverTracked_Bool						= 1038, // Used for devices that will never have a valid pose by design
+	Prop_NumCameras_Int32						= 1039,
+	Prop_CameraFrameLayout_Int32				= 1040, // EVRTrackedCameraFrameLayout value
+	Prop_CameraStreamFormat_Int32				= 1041, // ECameraVideoStreamFormat value
+	Prop_AdditionalDeviceSettingsPath_String	= 1042, // driver-relative path to additional device and global configuration settings
+	Prop_Identifiable_Bool						= 1043, // Whether device supports being identified from vrmonitor (e.g. blink LED, vibrate haptics, etc)
+	Prop_BootloaderVersion_Uint64			    = 1044,
+	Prop_AdditionalSystemReportData_String		= 1045, // additional string to include in system reports about a tracked device
+	Prop_CompositeFirmwareVersion_String        = 1046, // additional FW components from a device that gets propagated into reports
+	Prop_Firmware_RemindUpdate_Bool             = 1047,
+	Prop_PeripheralApplicationVersion_Uint64	= 1048,
+	Prop_ManufacturerSerialNumber_String		= 1049,
+	Prop_ComputedSerialNumber_String			= 1050,
+	Prop_EstimatedDeviceFirstUseTime_Int32		= 1051,
+
+	// Properties that are unique to TrackedDeviceClass_HMD
+	Prop_ReportsTimeSinceVSync_Bool				= 2000,
+	Prop_SecondsFromVsyncToPhotons_Float		= 2001,
+	Prop_DisplayFrequency_Float					= 2002,
+	Prop_UserIpdMeters_Float					= 2003,
+	Prop_CurrentUniverseId_Uint64				= 2004, 
+	Prop_PreviousUniverseId_Uint64				= 2005, 
+	Prop_DisplayFirmwareVersion_Uint64			= 2006,
+	Prop_IsOnDesktop_Bool						= 2007,
+	Prop_DisplayMCType_Int32					= 2008,
+	Prop_DisplayMCOffset_Float					= 2009,
+	Prop_DisplayMCScale_Float					= 2010,
+	Prop_EdidVendorID_Int32						= 2011,
+	Prop_DisplayMCImageLeft_String              = 2012,
+	Prop_DisplayMCImageRight_String             = 2013,
+	Prop_DisplayGCBlackClamp_Float				= 2014,
+	Prop_EdidProductID_Int32					= 2015,
+	Prop_CameraToHeadTransform_Matrix34			= 2016,
+	Prop_DisplayGCType_Int32					= 2017,
+	Prop_DisplayGCOffset_Float					= 2018,
+	Prop_DisplayGCScale_Float					= 2019,
+	Prop_DisplayGCPrescale_Float				= 2020,
+	Prop_DisplayGCImage_String					= 2021,
+	Prop_LensCenterLeftU_Float					= 2022,
+	Prop_LensCenterLeftV_Float					= 2023,
+	Prop_LensCenterRightU_Float					= 2024,
+	Prop_LensCenterRightV_Float					= 2025,
+	Prop_UserHeadToEyeDepthMeters_Float			= 2026,
+	Prop_CameraFirmwareVersion_Uint64			= 2027,
+	Prop_CameraFirmwareDescription_String		= 2028,
+	Prop_DisplayFPGAVersion_Uint64				= 2029,
+	Prop_DisplayBootloaderVersion_Uint64		= 2030,
+	Prop_DisplayHardwareVersion_Uint64			= 2031,
+	Prop_AudioFirmwareVersion_Uint64			= 2032,
+	Prop_CameraCompatibilityMode_Int32			= 2033,
+	Prop_ScreenshotHorizontalFieldOfViewDegrees_Float = 2034,
+	Prop_ScreenshotVerticalFieldOfViewDegrees_Float = 2035,
+	Prop_DisplaySuppressed_Bool					= 2036,
+	Prop_DisplayAllowNightMode_Bool				= 2037,
+	Prop_DisplayMCImageWidth_Int32				= 2038,
+	Prop_DisplayMCImageHeight_Int32				= 2039,
+	Prop_DisplayMCImageNumChannels_Int32		= 2040,
+	Prop_DisplayMCImageData_Binary				= 2041,
+	Prop_SecondsFromPhotonsToVblank_Float		= 2042,
+	Prop_DriverDirectModeSendsVsyncEvents_Bool	= 2043,
+	Prop_DisplayDebugMode_Bool					= 2044,
+	Prop_GraphicsAdapterLuid_Uint64				= 2045,
+	Prop_DriverProvidedChaperonePath_String		= 2048,
+	Prop_ExpectedTrackingReferenceCount_Int32	= 2049, // expected number of sensors or basestations to reserve UI space for
+	Prop_ExpectedControllerCount_Int32			= 2050, // expected number of tracked controllers to reserve UI space for
+	Prop_NamedIconPathControllerLeftDeviceOff_String	= 2051, // placeholder icon for "left" controller if not yet detected/loaded
+	Prop_NamedIconPathControllerRightDeviceOff_String	= 2052, // placeholder icon for "right" controller if not yet detected/loaded
+	Prop_NamedIconPathTrackingReferenceDeviceOff_String	= 2053, // placeholder icon for sensor/base if not yet detected/loaded
+	Prop_DoNotApplyPrediction_Bool				= 2054, // currently no effect. was used to disable HMD pose prediction on MR, which is now done by MR driver setting velocity=0
+	Prop_CameraToHeadTransforms_Matrix34_Array	= 2055,
+	Prop_DistortionMeshResolution_Int32			= 2056, // custom resolution of compositor calls to IVRSystem::ComputeDistortion
+	Prop_DriverIsDrawingControllers_Bool		= 2057,
+	Prop_DriverRequestsApplicationPause_Bool	= 2058,
+	Prop_DriverRequestsReducedRendering_Bool	= 2059,
+	Prop_MinimumIpdStepMeters_Float				= 2060,
+	Prop_AudioBridgeFirmwareVersion_Uint64		= 2061,
+	Prop_ImageBridgeFirmwareVersion_Uint64		= 2062,
+	Prop_ImuToHeadTransform_Matrix34			= 2063,
+	Prop_ImuFactoryGyroBias_Vector3				= 2064,
+	Prop_ImuFactoryGyroScale_Vector3			= 2065,
+	Prop_ImuFactoryAccelerometerBias_Vector3	= 2066,
+	Prop_ImuFactoryAccelerometerScale_Vector3	= 2067,
+	// reserved 2068
+	Prop_ConfigurationIncludesLighthouse20Features_Bool = 2069,
+	Prop_AdditionalRadioFeatures_Uint64         = 2070,
+	Prop_CameraWhiteBalance_Vector4_Array		= 2071, // Prop_NumCameras_Int32-sized array of float[4] RGBG white balance calibration data (max size is vr::k_unMaxCameras)
+	Prop_CameraDistortionFunction_Int32_Array	= 2072, // Prop_NumCameras_Int32-sized array of vr::EVRDistortionFunctionType values (max size is vr::k_unMaxCameras)
+	Prop_CameraDistortionCoefficients_Float_Array = 2073, // Prop_NumCameras_Int32-sized array of double[vr::k_unMaxDistortionFunctionParameters] (max size is vr::k_unMaxCameras)
+	Prop_ExpectedControllerType_String			= 2074,
+	Prop_HmdTrackingStyle_Int32					= 2075, // one of EHmdTrackingStyle
+	Prop_DriverProvidedChaperoneVisibility_Bool = 2076,
+	Prop_HmdColumnCorrectionSettingPrefix_String = 2077,
+	Prop_CameraSupportsCompatibilityModes_Bool	= 2078,
+
+	Prop_DisplayAvailableFrameRates_Float_Array = 2080, // populated by compositor from actual EDID list when available from GPU driver
+	Prop_DisplaySupportsMultipleFramerates_Bool = 2081, // if this is true but Prop_DisplayAvailableFrameRates_Float_Array is empty, explain to user
+	Prop_DisplayColorMultLeft_Vector3			= 2082,
+	Prop_DisplayColorMultRight_Vector3			= 2083,
+	Prop_DisplaySupportsRuntimeFramerateChange_Bool = 2084,
+	Prop_DisplaySupportsAnalogGain_Bool 		= 2085,
+	Prop_DisplayMinAnalogGain_Float 			= 2086,
+	Prop_DisplayMaxAnalogGain_Float 			= 2087,
+
+	// Prop_DashboardLayoutPathName_String 		= 2090, // DELETED
+	Prop_DashboardScale_Float 					= 2091,
+	Prop_IpdUIRangeMinMeters_Float 				= 2100,
+	Prop_IpdUIRangeMaxMeters_Float 				= 2101,
+
+	// Driver requested mura correction properties
+	Prop_DriverRequestedMuraCorrectionMode_Int32		= 2200,
+	Prop_DriverRequestedMuraFeather_InnerLeft_Int32		= 2201,
+	Prop_DriverRequestedMuraFeather_InnerRight_Int32	= 2202,
+	Prop_DriverRequestedMuraFeather_InnerTop_Int32		= 2203,
+	Prop_DriverRequestedMuraFeather_InnerBottom_Int32	= 2204,
+	Prop_DriverRequestedMuraFeather_OuterLeft_Int32		= 2205,
+	Prop_DriverRequestedMuraFeather_OuterRight_Int32	= 2206,
+	Prop_DriverRequestedMuraFeather_OuterTop_Int32		= 2207,
+	Prop_DriverRequestedMuraFeather_OuterBottom_Int32	= 2208,
+
+	Prop_Audio_DefaultPlaybackDeviceId_String		= 2300,
+	Prop_Audio_DefaultRecordingDeviceId_String		= 2301,
+	Prop_Audio_DefaultPlaybackDeviceVolume_Float	= 2302,
+
+	// Properties that are unique to TrackedDeviceClass_Controller
+	Prop_AttachedDeviceId_String				= 3000,
+	Prop_SupportedButtons_Uint64				= 3001,
+	Prop_Axis0Type_Int32						= 3002, // Return value is of type EVRControllerAxisType
+	Prop_Axis1Type_Int32						= 3003, // Return value is of type EVRControllerAxisType
+	Prop_Axis2Type_Int32						= 3004, // Return value is of type EVRControllerAxisType
+	Prop_Axis3Type_Int32						= 3005, // Return value is of type EVRControllerAxisType
+	Prop_Axis4Type_Int32						= 3006, // Return value is of type EVRControllerAxisType
+	Prop_ControllerRoleHint_Int32				= 3007, // Return value is of type ETrackedControllerRole
+
+	// Properties that are unique to TrackedDeviceClass_TrackingReference
+	Prop_FieldOfViewLeftDegrees_Float			= 4000,
+	Prop_FieldOfViewRightDegrees_Float			= 4001,
+	Prop_FieldOfViewTopDegrees_Float			= 4002,
+	Prop_FieldOfViewBottomDegrees_Float			= 4003,
+	Prop_TrackingRangeMinimumMeters_Float		= 4004,
+	Prop_TrackingRangeMaximumMeters_Float		= 4005,
+	Prop_ModeLabel_String						= 4006,
+	Prop_CanWirelessIdentify_Bool               = 4007, // volatile, based on radio presence and fw discovery
+	Prop_Nonce_Int32                            = 4008,
+
+	// Properties that are used for user interface like icons names
+	Prop_IconPathName_String						= 5000, // DEPRECATED. Value not referenced. Now expected to be part of icon path properties.
+	Prop_NamedIconPathDeviceOff_String				= 5001, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceSearching_String		= 5002, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceSearchingAlert_String	= 5003, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceReady_String			= 5004, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceReadyAlert_String		= 5005, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceNotReady_String			= 5006, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceStandby_String			= 5007, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceAlertLow_String			= 5008, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceStandbyAlert_String		= 5009, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+
+	// Properties that are used by helpers, but are opaque to applications
+	Prop_DisplayHiddenArea_Binary_Start				= 5100,
+	Prop_DisplayHiddenArea_Binary_End				= 5150,
+	Prop_ParentContainer							= 5151,
+	Prop_OverrideContainer_Uint64					= 5152,
+
+	// Properties that are unique to drivers
+	Prop_UserConfigPath_String					= 6000,
+	Prop_InstallPath_String						= 6001,
+	Prop_HasDisplayComponent_Bool				= 6002,
+	Prop_HasControllerComponent_Bool			= 6003,
+	Prop_HasCameraComponent_Bool				= 6004,
+	Prop_HasDriverDirectModeComponent_Bool		= 6005,
+	Prop_HasVirtualDisplayComponent_Bool		= 6006,
+	Prop_HasSpatialAnchorsSupport_Bool		    = 6007,
+
+	// Properties that are set internally based on other information provided by drivers
+	Prop_ControllerType_String					= 7000,
+	//Prop_LegacyInputProfile_String				= 7001, // This is no longer used. See "legacy_binding" in the input profile instead.
+	Prop_ControllerHandSelectionPriority_Int32	= 7002, // Allows hand assignments to prefer some controllers over others. High numbers are selected over low numbers
+
+	// Vendors are free to expose private debug data in this reserved region
+	Prop_VendorSpecific_Reserved_Start			= 10000,
+	Prop_VendorSpecific_Reserved_End			= 10999,
+	
+	Prop_TrackedDeviceProperty_Max				= 1000000,
+};
+
+/** No string property will ever be longer than this length */
+static const uint32_t k_unMaxPropertyStringSize = 32 * 1024;
+
+/** Used to return errors that occur when reading properties. */
+enum ETrackedPropertyError
+{
+	TrackedProp_Success						= 0,
+	TrackedProp_WrongDataType				= 1,
+	TrackedProp_WrongDeviceClass			= 2,
+	TrackedProp_BufferTooSmall				= 3,
+	TrackedProp_UnknownProperty				= 4, // Driver has not set the property (and may not ever).
+	TrackedProp_InvalidDevice				= 5,
+	TrackedProp_CouldNotContactServer		= 6,
+	TrackedProp_ValueNotProvidedByDevice	= 7,
+	TrackedProp_StringExceedsMaximumLength	= 8,
+	TrackedProp_NotYetAvailable				= 9, // The property value isn't known yet, but is expected soon. Call again later.
+	TrackedProp_PermissionDenied			= 10,
+	TrackedProp_InvalidOperation			= 11,
+	TrackedProp_CannotWriteToWildcards		= 12,
+	TrackedProp_IPCReadFailure				= 13,
+	TrackedProp_OutOfMemory					= 14,
+	TrackedProp_InvalidContainer			= 15,
+};
+
+/** Used to drive certain text in the UI when talking about the tracking system for the HMD */
+enum EHmdTrackingStyle
+{
+	HmdTrackingStyle_Unknown				= 0,
+
+	HmdTrackingStyle_Lighthouse				= 1, // base stations and lasers
+	HmdTrackingStyle_OutsideInCameras		= 2, // Cameras and LED, Rift 1 style
+	HmdTrackingStyle_InsideOutCameras		= 3, // Cameras on HMD looking at the world
+};
+
+typedef uint64_t VRActionHandle_t;
+typedef uint64_t VRActionSetHandle_t;
+typedef uint64_t VRInputValueHandle_t;
+
+static const VRActionHandle_t k_ulInvalidActionHandle = 0;
+static const VRActionSetHandle_t k_ulInvalidActionSetHandle = 0;
+static const VRInputValueHandle_t k_ulInvalidInputValueHandle = 0;
+
+
+/** Allows the application to control what part of the provided texture will be used in the
+* frame buffer. */
+struct VRTextureBounds_t
+{
+	float uMin, vMin;
+	float uMax, vMax;
+};
+
+/** Allows specifying pose used to render provided scene texture (if different from value returned by WaitGetPoses). */
+struct VRTextureWithPose_t : public Texture_t
+{
+	HmdMatrix34_t mDeviceToAbsoluteTracking; // Actual pose used to render scene textures.
+};
+
+struct VRTextureDepthInfo_t
+{
+	void* handle; // See ETextureType definition above
+	HmdMatrix44_t mProjection;
+	HmdVector2_t vRange; // 0..1
+};
+
+struct VRTextureWithDepth_t : public Texture_t
+{
+	VRTextureDepthInfo_t depth;
+};
+
+struct VRTextureWithPoseAndDepth_t : public VRTextureWithPose_t
+{
+	VRTextureDepthInfo_t depth;
+};
+
+/** Allows the application to control how scene textures are used by the compositor when calling Submit. */
+enum EVRSubmitFlags
+{
+	// Simple render path. App submits rendered left and right eye images with no lens distortion correction applied.
+	Submit_Default = 0x00,
+
+	// App submits final left and right eye images with lens distortion already applied (lens distortion makes the images appear
+	// barrel distorted with chromatic aberration correction applied). The app would have used the data returned by
+	// vr::IVRSystem::ComputeDistortion() to apply the correct distortion to the rendered images before calling Submit().
+	Submit_LensDistortionAlreadyApplied = 0x01,
+
+	// If the texture pointer passed in is actually a renderbuffer (e.g. for MSAA in OpenGL) then set this flag.
+	Submit_GlRenderBuffer = 0x02,
+
+	// Do not use
+	Submit_Reserved = 0x04,
+
+	// Set to indicate that pTexture is a pointer to a VRTextureWithPose_t.
+	// This flag can be combined with Submit_TextureWithDepth to pass a VRTextureWithPoseAndDepth_t.
+	Submit_TextureWithPose = 0x08,
+
+	// Set to indicate that pTexture is a pointer to a VRTextureWithDepth_t.
+	// This flag can be combined with Submit_TextureWithPose to pass a VRTextureWithPoseAndDepth_t.
+	Submit_TextureWithDepth = 0x10,
+
+	// Set to indicate a discontinuity between this and the last frame.
+	// This will prevent motion smoothing from attempting to extrapolate using the pair.
+	Submit_FrameDiscontinuty = 0x20,
+};
+
+/** Data required for passing Vulkan textures to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. 
+* Please see https://github.com/ValveSoftware/openvr/wiki/Vulkan for Vulkan-specific documentation */
+struct VRVulkanTextureData_t
+{
+	uint64_t m_nImage; // VkImage
+	VkDevice_T *m_pDevice;
+	VkPhysicalDevice_T *m_pPhysicalDevice;
+	VkInstance_T *m_pInstance;
+	VkQueue_T *m_pQueue;
+	uint32_t m_nQueueFamilyIndex;
+	uint32_t m_nWidth, m_nHeight, m_nFormat, m_nSampleCount;
+};
+
+/** Data required for passing D3D12 textures to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. */
+struct D3D12TextureData_t
+{
+	ID3D12Resource *m_pResource;
+	ID3D12CommandQueue *m_pCommandQueue;
+	uint32_t m_nNodeMask;
+};
+
+/** Status of the overall system or tracked objects */
+enum EVRState
+{
+	VRState_Undefined = -1,
+	VRState_Off = 0,
+	VRState_Searching = 1,
+	VRState_Searching_Alert = 2,
+	VRState_Ready = 3,
+	VRState_Ready_Alert = 4,
+	VRState_NotReady = 5,
+	VRState_Standby = 6,
+	VRState_Ready_Alert_Low = 7,
+};
+
+/** The types of events that could be posted (and what the parameters mean for each event type) */
+enum EVREventType
+{
+	VREvent_None = 0,
+
+	VREvent_TrackedDeviceActivated		= 100,
+	VREvent_TrackedDeviceDeactivated	= 101,
+	VREvent_TrackedDeviceUpdated		= 102,
+	VREvent_TrackedDeviceUserInteractionStarted	= 103,
+	VREvent_TrackedDeviceUserInteractionEnded	= 104,
+	VREvent_IpdChanged					= 105,
+	VREvent_EnterStandbyMode			= 106,
+	VREvent_LeaveStandbyMode			= 107,
+	VREvent_TrackedDeviceRoleChanged	= 108,
+	VREvent_WatchdogWakeUpRequested		= 109,
+	VREvent_LensDistortionChanged		= 110,
+	VREvent_PropertyChanged				= 111,
+	VREvent_WirelessDisconnect			= 112,
+	VREvent_WirelessReconnect			= 113,
+
+	VREvent_ButtonPress					= 200, // data is controller
+	VREvent_ButtonUnpress				= 201, // data is controller
+	VREvent_ButtonTouch					= 202, // data is controller
+	VREvent_ButtonUntouch				= 203, // data is controller
+
+	// VREvent_DualAnalog_Press			= 250, // No longer sent
+	// VREvent_DualAnalog_Unpress		= 251, // No longer sent
+	// VREvent_DualAnalog_Touch			= 252, // No longer sent
+	// VREvent_DualAnalog_Untouch		= 253, // No longer sent
+	// VREvent_DualAnalog_Move			= 254, // No longer sent
+	// VREvent_DualAnalog_ModeSwitch1	= 255, // No longer sent
+	// VREvent_DualAnalog_ModeSwitch2	= 256, // No longer sent
+	VREvent_Modal_Cancel				= 257, // Sent to overlays with the 
+
+	VREvent_MouseMove					= 300, // data is mouse
+	VREvent_MouseButtonDown				= 301, // data is mouse
+	VREvent_MouseButtonUp				= 302, // data is mouse
+	VREvent_FocusEnter					= 303, // data is overlay
+	VREvent_FocusLeave					= 304, // data is overlay
+	VREvent_ScrollDiscrete				= 305, // data is scroll
+	VREvent_TouchPadMove				= 306, // data is mouse
+	VREvent_OverlayFocusChanged			= 307, // data is overlay, global event
+	VREvent_ReloadOverlays				= 308, 
+	VREvent_ScrollSmooth				= 309, // data is scroll
+	VREvent_LockMousePosition			= 310,
+	VREvent_UnlockMousePosition			= 311,
+
+	VREvent_InputFocusCaptured			= 400, // data is process DEPRECATED
+	VREvent_InputFocusReleased			= 401, // data is process DEPRECATED
+	// VREvent_SceneFocusLost			= 402, // data is process
+	// VREvent_SceneFocusGained			= 403, // data is process
+	VREvent_SceneApplicationChanged		= 404, // data is process - The App actually drawing the scene changed (usually to or from the compositor)
+	VREvent_SceneFocusChanged			= 405, // data is process - New app got access to draw the scene
+	VREvent_InputFocusChanged			= 406, // data is process
+	// VREvent_SceneApplicationSecondaryRenderingStarted = 407,
+	VREvent_SceneApplicationUsingWrongGraphicsAdapter = 408, // data is process
+	VREvent_ActionBindingReloaded		 = 409, // data is process - The App that action binds reloaded for
+
+	VREvent_HideRenderModels			= 410, // Sent to the scene application to request hiding render models temporarily
+	VREvent_ShowRenderModels			= 411, // Sent to the scene application to request restoring render model visibility
+
+	VREvent_SceneApplicationStateChanged = 412, // No data; but query VRApplications()->GetSceneApplicationState();
+
+	VREvent_ConsoleOpened               = 420,
+	VREvent_ConsoleClosed               = 421,
+
+	VREvent_OverlayShown				= 500,
+	VREvent_OverlayHidden				= 501,
+	VREvent_DashboardActivated			= 502,
+	VREvent_DashboardDeactivated		= 503,
+	//VREvent_DashboardThumbSelected		= 504, // Sent to the overlay manager - data is overlay - No longer sent
+	VREvent_DashboardRequested			= 505, // Sent to the overlay manager - data is overlay
+	VREvent_ResetDashboard				= 506, // Send to the overlay manager
+	//VREvent_RenderToast					= 507, // Send to the dashboard to render a toast - data is the notification ID -- no longer sent
+	VREvent_ImageLoaded					= 508, // Sent to overlays when a SetOverlayRaw or SetOverlayFromFile call finishes loading
+	VREvent_ShowKeyboard				= 509, // Sent to keyboard renderer in the dashboard to invoke it
+	VREvent_HideKeyboard				= 510, // Sent to keyboard renderer in the dashboard to hide it
+	VREvent_OverlayGamepadFocusGained	= 511, // Sent to an overlay when IVROverlay::SetFocusOverlay is called on it
+	VREvent_OverlayGamepadFocusLost		= 512, // Send to an overlay when it previously had focus and IVROverlay::SetFocusOverlay is called on something else
+	VREvent_OverlaySharedTextureChanged = 513,
+	//VREvent_DashboardGuideButtonDown	= 514, // These are no longer sent
+	//VREvent_DashboardGuideButtonUp		= 515,
+	VREvent_ScreenshotTriggered			= 516, // Screenshot button combo was pressed, Dashboard should request a screenshot
+	VREvent_ImageFailed					= 517, // Sent to overlays when a SetOverlayRaw or SetOverlayfromFail fails to load
+	VREvent_DashboardOverlayCreated		= 518,
+	VREvent_SwitchGamepadFocus			= 519,
+
+	// Screenshot API
+	VREvent_RequestScreenshot				= 520, // Sent by vrclient application to compositor to take a screenshot
+	VREvent_ScreenshotTaken					= 521, // Sent by compositor to the application that the screenshot has been taken
+	VREvent_ScreenshotFailed				= 522, // Sent by compositor to the application that the screenshot failed to be taken
+	VREvent_SubmitScreenshotToDashboard		= 523, // Sent by compositor to the dashboard that a completed screenshot was submitted
+	VREvent_ScreenshotProgressToDashboard	= 524, // Sent by compositor to the dashboard that a completed screenshot was submitted
+
+	VREvent_PrimaryDashboardDeviceChanged	= 525,
+	VREvent_RoomViewShown					= 526, // Sent by compositor whenever room-view is enabled
+	VREvent_RoomViewHidden					= 527, // Sent by compositor whenever room-view is disabled
+	VREvent_ShowUI							= 528, // data is showUi
+	VREvent_ShowDevTools					= 529, // data is showDevTools
+
+	VREvent_Notification_Shown				= 600,
+	VREvent_Notification_Hidden				= 601,
+	VREvent_Notification_BeginInteraction	= 602,
+	VREvent_Notification_Destroyed			= 603,
+
+	VREvent_Quit							= 700, // data is process
+	VREvent_ProcessQuit						= 701, // data is process
+	//VREvent_QuitAborted_UserPrompt			= 702, // data is process
+	VREvent_QuitAcknowledged				= 703, // data is process
+	VREvent_DriverRequestedQuit				= 704, // The driver has requested that SteamVR shut down
+	VREvent_RestartRequested				= 705, // A driver or other component wants the user to restart SteamVR
+
+	VREvent_ChaperoneDataHasChanged			= 800, // this will never happen with the new chaperone system
+	VREvent_ChaperoneUniverseHasChanged		= 801,
+	VREvent_ChaperoneTempDataHasChanged		= 802, // this will never happen with the new chaperone system
+	VREvent_ChaperoneSettingsHaveChanged	= 803,
+	VREvent_SeatedZeroPoseReset				= 804,
+	VREvent_ChaperoneFlushCache				= 805, // Sent when the process needs to reload any cached data it retrieved from VRChaperone()
+	VREvent_ChaperoneRoomSetupStarting	    = 806, // Triggered by CVRChaperoneClient::RoomSetupStarting
+	VREvent_ChaperoneRoomSetupFinished	    = 807, // Triggered by CVRChaperoneClient::CommitWorkingCopy
+
+	VREvent_AudioSettingsHaveChanged		= 820,
+
+	VREvent_BackgroundSettingHasChanged				= 850,
+	VREvent_CameraSettingsHaveChanged				= 851,
+	VREvent_ReprojectionSettingHasChanged			= 852,
+	VREvent_ModelSkinSettingsHaveChanged			= 853,
+	VREvent_EnvironmentSettingsHaveChanged			= 854,
+	VREvent_PowerSettingsHaveChanged				= 855,
+	VREvent_EnableHomeAppSettingsHaveChanged		= 856,
+	VREvent_SteamVRSectionSettingChanged			= 857,
+	VREvent_LighthouseSectionSettingChanged			= 858,
+	VREvent_NullSectionSettingChanged				= 859,
+	VREvent_UserInterfaceSectionSettingChanged		= 860,
+	VREvent_NotificationsSectionSettingChanged		= 861,
+	VREvent_KeyboardSectionSettingChanged			= 862,
+	VREvent_PerfSectionSettingChanged				= 863,
+	VREvent_DashboardSectionSettingChanged			= 864,
+	VREvent_WebInterfaceSectionSettingChanged		= 865,
+	VREvent_TrackersSectionSettingChanged			= 866,
+	VREvent_LastKnownSectionSettingChanged			= 867,
+	VREvent_DismissedWarningsSectionSettingChanged	= 868,
+	VREvent_GpuSpeedSectionSettingChanged			= 869,
+	VREvent_WindowsMRSectionSettingChanged			= 870,
+	VREvent_OtherSectionSettingChanged				= 871,
+
+	VREvent_StatusUpdate					= 900,
+
+	VREvent_WebInterface_InstallDriverCompleted = 950,
+
+	VREvent_MCImageUpdated					= 1000,
+
+	VREvent_FirmwareUpdateStarted			= 1100,
+	VREvent_FirmwareUpdateFinished			= 1101,
+
+	VREvent_KeyboardClosed					= 1200,
+	VREvent_KeyboardCharInput				= 1201,
+	VREvent_KeyboardDone					= 1202, // Sent when DONE button clicked on keyboard
+
+	//VREvent_ApplicationTransitionStarted		= 1300,
+	//VREvent_ApplicationTransitionAborted		= 1301,
+	//VREvent_ApplicationTransitionNewAppStarted	= 1302,
+	VREvent_ApplicationListUpdated				= 1303,
+	VREvent_ApplicationMimeTypeLoad				= 1304,
+	// VREvent_ApplicationTransitionNewAppLaunchComplete = 1305,
+	VREvent_ProcessConnected					= 1306,
+	VREvent_ProcessDisconnected					= 1307,
+
+	//VREvent_Compositor_MirrorWindowShown		= 1400, // DEPRECATED
+	//VREvent_Compositor_MirrorWindowHidden		= 1401, // DEPRECATED
+	VREvent_Compositor_ChaperoneBoundsShown		= 1410,
+	VREvent_Compositor_ChaperoneBoundsHidden	= 1411,
+	VREvent_Compositor_DisplayDisconnected		= 1412,
+	VREvent_Compositor_DisplayReconnected		= 1413,
+	VREvent_Compositor_HDCPError				= 1414, // data is hdcpError
+	VREvent_Compositor_ApplicationNotResponding	= 1415,
+	VREvent_Compositor_ApplicationResumed		= 1416,
+	VREvent_Compositor_OutOfVideoMemory			= 1417,
+	VREvent_Compositor_DisplayModeNotSupported	= 1418, // k_pch_SteamVR_PreferredRefreshRate
+	VREvent_Compositor_StageOverrideReady		= 1419,
+
+	VREvent_TrackedCamera_StartVideoStream  = 1500,
+	VREvent_TrackedCamera_StopVideoStream   = 1501,
+	VREvent_TrackedCamera_PauseVideoStream  = 1502,
+	VREvent_TrackedCamera_ResumeVideoStream = 1503,
+	VREvent_TrackedCamera_EditingSurface    = 1550,
+
+	VREvent_PerformanceTest_EnableCapture	= 1600,
+	VREvent_PerformanceTest_DisableCapture	= 1601,
+	VREvent_PerformanceTest_FidelityLevel	= 1602,
+
+	VREvent_MessageOverlay_Closed			= 1650,
+	VREvent_MessageOverlayCloseRequested	= 1651,
+	
+	VREvent_Input_HapticVibration			= 1700, // data is hapticVibration
+	VREvent_Input_BindingLoadFailed			= 1701, // data is inputBinding
+	VREvent_Input_BindingLoadSuccessful		= 1702, // data is inputBinding
+	VREvent_Input_ActionManifestReloaded	= 1703, // no data
+	VREvent_Input_ActionManifestLoadFailed	= 1704, // data is actionManifest
+	VREvent_Input_ProgressUpdate			= 1705, // data is progressUpdate
+	VREvent_Input_TrackerActivated			= 1706,
+	VREvent_Input_BindingsUpdated			= 1707,
+	VREvent_Input_BindingSubscriptionChanged = 1708,
+
+	VREvent_SpatialAnchors_PoseUpdated		= 1800,        // data is spatialAnchor. broadcast
+	VREvent_SpatialAnchors_DescriptorUpdated = 1801,       // data is spatialAnchor. broadcast
+	VREvent_SpatialAnchors_RequestPoseUpdate = 1802,       // data is spatialAnchor. sent to specific driver
+	VREvent_SpatialAnchors_RequestDescriptorUpdate = 1803, // data is spatialAnchor. sent to specific driver
+
+	VREvent_SystemReport_Started			= 1900, // user or system initiated generation of a system report. broadcast
+
+	VREvent_Monitor_ShowHeadsetView			= 2000, // data is process
+	VREvent_Monitor_HideHeadsetView			= 2001, // data is process
+
+	// Vendors are free to expose private events in this reserved region
+	VREvent_VendorSpecific_Reserved_Start	= 10000,
+	VREvent_VendorSpecific_Reserved_End		= 19999,
+};
+
+
+/** Level of Hmd activity */
+// UserInteraction_Timeout means the device is in the process of timing out.
+// InUse = ( k_EDeviceActivityLevel_UserInteraction || k_EDeviceActivityLevel_UserInteraction_Timeout )
+// VREvent_TrackedDeviceUserInteractionStarted fires when the devices transitions from Standby -> UserInteraction or Idle -> UserInteraction.
+// VREvent_TrackedDeviceUserInteractionEnded fires when the devices transitions from UserInteraction_Timeout -> Idle
+enum EDeviceActivityLevel
+{	
+	k_EDeviceActivityLevel_Unknown = -1,									
+	k_EDeviceActivityLevel_Idle = 0,						// No activity for the last 10 seconds
+	k_EDeviceActivityLevel_UserInteraction = 1,				// Activity (movement or prox sensor) is happening now	
+	k_EDeviceActivityLevel_UserInteraction_Timeout = 2,		// No activity for the last 0.5 seconds
+	k_EDeviceActivityLevel_Standby = 3,						// Idle for at least 5 seconds (configurable in Settings -> Power Management)
+	k_EDeviceActivityLevel_Idle_Timeout = 4,
+};
+
+
+/** VR controller button and axis IDs */
+enum EVRButtonId
+{
+	k_EButton_System			= 0,
+	k_EButton_ApplicationMenu	= 1,
+	k_EButton_Grip				= 2,
+	k_EButton_DPad_Left			= 3,
+	k_EButton_DPad_Up			= 4,
+	k_EButton_DPad_Right		= 5,
+	k_EButton_DPad_Down			= 6,
+	k_EButton_A					= 7,
+	
+	k_EButton_ProximitySensor   = 31,
+
+	k_EButton_Axis0				= 32,
+	k_EButton_Axis1				= 33,
+	k_EButton_Axis2				= 34,
+	k_EButton_Axis3				= 35,
+	k_EButton_Axis4				= 36,
+
+	// aliases for well known controllers
+	k_EButton_SteamVR_Touchpad	= k_EButton_Axis0,
+	k_EButton_SteamVR_Trigger	= k_EButton_Axis1,
+
+	k_EButton_Dashboard_Back	= k_EButton_Grip,
+
+	k_EButton_IndexController_A		= k_EButton_Grip,
+	k_EButton_IndexController_B		= k_EButton_ApplicationMenu,
+	k_EButton_IndexController_JoyStick	= k_EButton_Axis3,
+
+	k_EButton_Max				= 64
+};
+
+inline uint64_t ButtonMaskFromId( EVRButtonId id ) { return 1ull << id; }
+
+/** used for controller button events */
+struct VREvent_Controller_t
+{
+	uint32_t button; // EVRButtonId enum
+};
+
+
+/** used for simulated mouse events in overlay space */
+enum EVRMouseButton
+{
+	VRMouseButton_Left					= 0x0001,
+	VRMouseButton_Right					= 0x0002,
+	VRMouseButton_Middle				= 0x0004,
+};
+
+
+/** used for simulated mouse events in overlay space */
+struct VREvent_Mouse_t
+{
+	float x, y; // co-ords are in GL space, bottom left of the texture is 0,0
+	uint32_t button; // EVRMouseButton enum
+};
+
+/** used for simulated mouse wheel scroll */
+struct VREvent_Scroll_t
+{
+	float xdelta, ydelta;
+	uint32_t unused;
+	float viewportscale; // For scrolling on an overlay with laser mouse, this is the overlay's vertical size relative to the overlay height. Range: [0,1]
+};
+
+/** when in mouse input mode you can receive data from the touchpad, these events are only sent if the users finger
+   is on the touchpad (or just released from it). These events are sent to overlays with the VROverlayFlags_SendVRTouchpadEvents
+   flag set.
+**/
+struct VREvent_TouchPadMove_t
+{
+	// true if the users finger is detected on the touch pad
+	bool bFingerDown;
+
+	// How long the finger has been down in seconds
+	float flSecondsFingerDown;
+
+	// These values indicate the starting finger position (so you can do some basic swipe stuff)
+	float fValueXFirst;
+	float fValueYFirst;
+
+	// This is the raw sampled coordinate without deadzoning
+	float fValueXRaw;
+	float fValueYRaw;
+};
+
+/** notification related events. Details will still change at this point */
+struct VREvent_Notification_t
+{
+	uint64_t ulUserValue;
+	uint32_t notificationId;
+};
+
+/** Used for events about processes */
+struct VREvent_Process_t
+{
+	uint32_t pid;
+	uint32_t oldPid;
+	bool bForced;
+	// If the associated event was triggered by a connection loss
+	bool bConnectionLost;
+};
+
+
+/** Used for a few events about overlays */
+struct VREvent_Overlay_t
+{
+	uint64_t overlayHandle;
+	uint64_t devicePath;
+};
+
+
+/** Used for a few events about overlays */
+struct VREvent_Status_t
+{
+	uint32_t statusState; // EVRState enum
+};
+
+/** Used for keyboard events **/
+struct VREvent_Keyboard_t
+{
+	char cNewInput[8];	// Up to 11 bytes of new input
+	uint64_t uUserValue;	// Possible flags about the new input
+};
+
+struct VREvent_Ipd_t
+{
+	float ipdMeters;
+};
+
+struct VREvent_Chaperone_t
+{
+	uint64_t m_nPreviousUniverse;
+	uint64_t m_nCurrentUniverse;
+};
+
+/** Not actually used for any events */
+struct VREvent_Reserved_t
+{
+	uint64_t reserved0;
+	uint64_t reserved1;
+	uint64_t reserved2;
+	uint64_t reserved3;
+	uint64_t reserved4;
+	uint64_t reserved5;
+};
+
+struct VREvent_PerformanceTest_t
+{
+	uint32_t m_nFidelityLevel;
+};
+
+struct VREvent_SeatedZeroPoseReset_t
+{
+	bool bResetBySystemMenu;
+};
+
+struct VREvent_Screenshot_t
+{
+	uint32_t handle;
+	uint32_t type;
+};
+
+struct VREvent_ScreenshotProgress_t
+{
+	float progress;
+};
+
+struct VREvent_ApplicationLaunch_t
+{
+	uint32_t pid;
+	uint32_t unArgsHandle;
+};
+
+struct VREvent_EditingCameraSurface_t
+{
+	uint64_t overlayHandle;
+	uint32_t nVisualMode;
+};
+
+struct VREvent_MessageOverlay_t
+{
+	uint32_t unVRMessageOverlayResponse; // vr::VRMessageOverlayResponse enum
+};
+
+struct VREvent_Property_t
+{
+	PropertyContainerHandle_t container;
+	ETrackedDeviceProperty prop;
+};
+
+struct VREvent_HapticVibration_t
+{
+	uint64_t containerHandle; // property container handle of the device with the haptic component
+	uint64_t componentHandle; // Which haptic component needs to vibrate
+	float fDurationSeconds;
+	float fFrequency;
+	float fAmplitude;
+};
+
+struct VREvent_WebConsole_t
+{
+	WebConsoleHandle_t webConsoleHandle;
+};
+
+struct VREvent_InputBindingLoad_t
+{
+	vr::PropertyContainerHandle_t ulAppContainer;
+	uint64_t pathMessage;
+	uint64_t pathUrl;
+	uint64_t pathControllerType;
+};
+
+struct VREvent_InputActionManifestLoad_t
+{
+	uint64_t pathAppKey;
+	uint64_t pathMessage;
+	uint64_t pathMessageParam;
+	uint64_t pathManifestPath;
+};
+
+struct VREvent_SpatialAnchor_t
+{
+	SpatialAnchorHandle_t unHandle;
+};
+
+struct VREvent_ProgressUpdate_t
+{
+	uint64_t ulApplicationPropertyContainer;
+	uint64_t pathDevice;
+	uint64_t pathInputSource;
+	uint64_t pathProgressAction;
+	uint64_t pathIcon;
+	float fProgress;
+};
+
+enum EShowUIType
+{
+	ShowUI_ControllerBinding = 0,
+	ShowUI_ManageTrackers = 1,
+	// ShowUI_QuickStart = 2, // Deprecated
+	ShowUI_Pairing = 3,
+	ShowUI_Settings = 4,
+	ShowUI_DebugCommands = 5,
+	ShowUI_FullControllerBinding = 6,
+	ShowUI_ManageDrivers = 7,
+};
+
+struct VREvent_ShowUI_t
+{
+	EShowUIType eType;
+};
+
+struct VREvent_ShowDevTools_t
+{
+	int32_t nBrowserIdentifier;
+};
+
+enum EHDCPError
+{
+	HDCPError_None = 0,
+	HDCPError_LinkLost = 1,
+	HDCPError_Tampered = 2,
+	HDCPError_DeviceRevoked = 3,
+	HDCPError_Unknown = 4
+};
+
+struct VREvent_HDCPError_t
+{
+	EHDCPError eCode;
+};
+
+typedef union
+{
+	VREvent_Reserved_t reserved;
+	VREvent_Controller_t controller;
+	VREvent_Mouse_t mouse;
+	VREvent_Scroll_t scroll;
+	VREvent_Process_t process;
+	VREvent_Notification_t notification;
+	VREvent_Overlay_t overlay;
+	VREvent_Status_t status;
+	VREvent_Keyboard_t keyboard;
+	VREvent_Ipd_t ipd;
+	VREvent_Chaperone_t chaperone;
+	VREvent_PerformanceTest_t performanceTest;
+	VREvent_TouchPadMove_t touchPadMove;
+	VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset;
+	VREvent_Screenshot_t screenshot;
+	VREvent_ScreenshotProgress_t screenshotProgress;
+	VREvent_ApplicationLaunch_t applicationLaunch;
+	VREvent_EditingCameraSurface_t cameraSurface;
+	VREvent_MessageOverlay_t messageOverlay;
+	VREvent_Property_t property;
+	VREvent_HapticVibration_t hapticVibration;
+	VREvent_WebConsole_t webConsole;
+	VREvent_InputBindingLoad_t inputBinding;
+	VREvent_InputActionManifestLoad_t actionManifest;
+	VREvent_SpatialAnchor_t spatialAnchor;
+	VREvent_ProgressUpdate_t progressUpdate;
+	VREvent_ShowUI_t showUi;
+	VREvent_ShowDevTools_t showDevTools;
+	VREvent_HDCPError_t hdcpError;
+    /** NOTE!!! If you change this you MUST manually update openvr_interop.cs.py */
+} VREvent_Data_t;
+
+
+#if defined(__linux__) || defined(__APPLE__) 
+// This structure was originally defined mis-packed on Linux, preserved for 
+// compatibility. 
+#pragma pack( push, 4 )
+#endif
+
+/** An event posted by the server to all running applications */
+struct VREvent_t
+{
+	uint32_t eventType; // EVREventType enum
+	TrackedDeviceIndex_t trackedDeviceIndex;
+	float eventAgeSeconds;
+	// event data must be the end of the struct as its size is variable
+	VREvent_Data_t data;
+};
+
+#if defined(__linux__) || defined(__APPLE__) 
+#pragma pack( pop )
+#endif
+
+typedef uint32_t VRComponentProperties;
+
+enum EVRComponentProperty
+{
+	VRComponentProperty_IsStatic = (1 << 0),
+	VRComponentProperty_IsVisible = (1 << 1),
+	VRComponentProperty_IsTouched = (1 << 2),
+	VRComponentProperty_IsPressed = (1 << 3),
+	VRComponentProperty_IsScrolled = (1 << 4),
+	VRComponentProperty_IsHighlighted = (1 << 5),
+};
+
+
+/** Describes state information about a render-model component, including transforms and other dynamic properties */
+struct RenderModel_ComponentState_t
+{
+	HmdMatrix34_t mTrackingToComponentRenderModel;  // Transform required when drawing the component render model
+	HmdMatrix34_t mTrackingToComponentLocal;        // Transform available for attaching to a local component coordinate system (-Z out from surface )
+	VRComponentProperties uProperties;
+};
+
+
+enum EVRInputError
+{
+	VRInputError_None = 0,
+	VRInputError_NameNotFound = 1,
+	VRInputError_WrongType = 2,
+	VRInputError_InvalidHandle = 3,
+	VRInputError_InvalidParam = 4,
+	VRInputError_NoSteam = 5,
+	VRInputError_MaxCapacityReached = 6,
+	VRInputError_IPCError = 7,
+	VRInputError_NoActiveActionSet = 8,
+	VRInputError_InvalidDevice = 9,
+	VRInputError_InvalidSkeleton = 10,
+	VRInputError_InvalidBoneCount = 11,
+	VRInputError_InvalidCompressedData = 12,
+	VRInputError_NoData = 13,
+	VRInputError_BufferTooSmall = 14,
+	VRInputError_MismatchedActionManifest = 15,
+	VRInputError_MissingSkeletonData = 16,
+	VRInputError_InvalidBoneIndex = 17,
+	VRInputError_InvalidPriority = 18,
+	VRInputError_PermissionDenied = 19,
+	VRInputError_InvalidRenderModel = 20,
+};
+
+enum EVRSpatialAnchorError
+{
+	VRSpatialAnchorError_Success = 0,
+	VRSpatialAnchorError_Internal = 1,
+	VRSpatialAnchorError_UnknownHandle = 2,
+	VRSpatialAnchorError_ArrayTooSmall = 3,
+	VRSpatialAnchorError_InvalidDescriptorChar = 4,
+	VRSpatialAnchorError_NotYetAvailable = 5,
+	VRSpatialAnchorError_NotAvailableInThisUniverse = 6,
+	VRSpatialAnchorError_PermanentlyUnavailable = 7,
+	VRSpatialAnchorError_WrongDriver = 8,
+	VRSpatialAnchorError_DescriptorTooLong = 9,
+	VRSpatialAnchorError_Unknown = 10,
+	VRSpatialAnchorError_NoRoomCalibration = 11,
+	VRSpatialAnchorError_InvalidArgument = 12,
+	VRSpatialAnchorError_UnknownDriver = 13,
+};
+
+/** The mesh to draw into the stencil (or depth) buffer to perform 
+* early stencil (or depth) kills of pixels that will never appear on the HMD.
+* This mesh draws on all the pixels that will be hidden after distortion. 
+*
+* If the HMD does not provide a visible area mesh pVertexData will be
+* NULL and unTriangleCount will be 0. */
+struct HiddenAreaMesh_t
+{
+	const HmdVector2_t *pVertexData;
+	uint32_t unTriangleCount;
+};
+
+
+enum EHiddenAreaMeshType
+{
+	k_eHiddenAreaMesh_Standard = 0,
+	k_eHiddenAreaMesh_Inverse = 1,
+	k_eHiddenAreaMesh_LineLoop = 2,
+
+	k_eHiddenAreaMesh_Max = 3,
+};
+
+
+/** Identifies what kind of axis is on the controller at index n. Read this type 
+* with pVRSystem->Get( nControllerDeviceIndex, Prop_Axis0Type_Int32 + n );
+*/
+enum EVRControllerAxisType
+{
+	k_eControllerAxis_None = 0,
+	k_eControllerAxis_TrackPad = 1,
+	k_eControllerAxis_Joystick = 2,
+	k_eControllerAxis_Trigger = 3, // Analog trigger data is in the X axis
+};
+
+
+/** contains information about one axis on the controller */
+struct VRControllerAxis_t
+{
+	float x; // Ranges from -1.0 to 1.0 for joysticks and track pads. Ranges from 0.0 to 1.0 for triggers were 0 is fully released.
+	float y; // Ranges from -1.0 to 1.0 for joysticks and track pads. Is always 0.0 for triggers.
+};
+
+
+/** the number of axes in the controller state */
+static const uint32_t k_unControllerStateAxisCount = 5;
+
+
+#if defined(__linux__) || defined(__APPLE__) 
+// This structure was originally defined mis-packed on Linux, preserved for 
+// compatibility. 
+#pragma pack( push, 4 )
+#endif
+
+/** Holds all the state of a controller at one moment in time. */
+struct VRControllerState001_t
+{
+	// If packet num matches that on your prior call, then the controller state hasn't been changed since 
+	// your last call and there is no need to process it
+	uint32_t unPacketNum;
+
+	// bit flags for each of the buttons. Use ButtonMaskFromId to turn an ID into a mask
+	uint64_t ulButtonPressed;
+	uint64_t ulButtonTouched;
+
+	// Axis data for the controller's analog inputs
+	VRControllerAxis_t rAxis[ k_unControllerStateAxisCount ];
+};
+#if defined(__linux__) || defined(__APPLE__) 
+#pragma pack( pop )
+#endif
+
+
+typedef VRControllerState001_t VRControllerState_t;
+
+
+/** determines how to provide output to the application of various event processing functions. */
+enum EVRControllerEventOutputType
+{
+	ControllerEventOutput_OSEvents = 0,
+	ControllerEventOutput_VREvents = 1,
+};
+
+
+
+/** Collision Bounds Style */
+enum ECollisionBoundsStyle
+{
+	COLLISION_BOUNDS_STYLE_BEGINNER = 0,
+	COLLISION_BOUNDS_STYLE_INTERMEDIATE,
+	COLLISION_BOUNDS_STYLE_SQUARES,
+	COLLISION_BOUNDS_STYLE_ADVANCED,
+	COLLISION_BOUNDS_STYLE_NONE,
+
+	COLLISION_BOUNDS_STYLE_COUNT
+};
+
+/** used to refer to a single VR overlay */
+typedef uint64_t VROverlayHandle_t;
+
+static const VROverlayHandle_t k_ulOverlayHandleInvalid = 0;
+
+/** Errors that can occur around VR overlays */
+enum EVROverlayError
+{
+	VROverlayError_None						= 0,
+
+	VROverlayError_UnknownOverlay			= 10,
+	VROverlayError_InvalidHandle			= 11,
+	VROverlayError_PermissionDenied			= 12,
+	VROverlayError_OverlayLimitExceeded		= 13, // No more overlays could be created because the maximum number already exist
+	VROverlayError_WrongVisibilityType		= 14,
+	VROverlayError_KeyTooLong				= 15,
+	VROverlayError_NameTooLong				= 16,
+	VROverlayError_KeyInUse					= 17,
+	VROverlayError_WrongTransformType		= 18,
+	VROverlayError_InvalidTrackedDevice		= 19,
+	VROverlayError_InvalidParameter			= 20,
+	VROverlayError_ThumbnailCantBeDestroyed	= 21,
+	VROverlayError_ArrayTooSmall			= 22,
+	VROverlayError_RequestFailed			= 23,
+	VROverlayError_InvalidTexture			= 24,
+	VROverlayError_UnableToLoadFile			= 25,
+	VROverlayError_KeyboardAlreadyInUse		= 26,
+	VROverlayError_NoNeighbor				= 27,
+	VROverlayError_TooManyMaskPrimitives	= 29,
+	VROverlayError_BadMaskPrimitive			= 30,
+	VROverlayError_TextureAlreadyLocked		= 31,
+	VROverlayError_TextureLockCapacityReached = 32,
+	VROverlayError_TextureNotLocked			= 33,
+};
+
+/** enum values to pass in to VR_Init to identify whether the application will 
+* draw a 3D scene. */
+enum EVRApplicationType
+{
+	VRApplication_Other = 0,		// Some other kind of application that isn't covered by the other entries 
+	VRApplication_Scene	= 1,		// Application will submit 3D frames 
+	VRApplication_Overlay = 2,		// Application only interacts with overlays
+	VRApplication_Background = 3,	// Application should not start SteamVR if it's not already running, and should not
+									// keep it running if everything else quits.
+	VRApplication_Utility = 4,		// Init should not try to load any drivers. The application needs access to utility
+									// interfaces (like IVRSettings and IVRApplications) but not hardware.
+	VRApplication_VRMonitor = 5,	// Reserved for vrmonitor
+	VRApplication_SteamWatchdog = 6,// Reserved for Steam
+	VRApplication_Bootstrapper = 7, // reserved for vrstartup
+	VRApplication_WebHelper = 8,	// reserved for vrwebhelper
+
+	VRApplication_Max
+};
+
+
+/** error codes for firmware */
+enum EVRFirmwareError
+{
+	VRFirmwareError_None = 0,
+	VRFirmwareError_Success = 1,
+	VRFirmwareError_Fail = 2,
+};
+
+
+/** error codes for notifications */
+enum EVRNotificationError
+{
+	VRNotificationError_OK = 0,
+	VRNotificationError_InvalidNotificationId = 100,
+	VRNotificationError_NotificationQueueFull = 101,
+	VRNotificationError_InvalidOverlayHandle = 102,
+	VRNotificationError_SystemWithUserValueAlreadyExists = 103,
+};
+
+
+enum EVRSkeletalMotionRange
+{
+	// The range of motion of the skeleton takes into account any physical limits imposed by
+	// the controller itself.  This will tend to be the most accurate pose compared to the user's
+	// actual hand pose, but might not allow a closed fist for example
+	VRSkeletalMotionRange_WithController = 0,
+
+	// Retarget the range of motion provided by the input device to make the hand appear to move
+	// as if it was not holding a controller.  eg: map "hand grasping controller" to "closed fist"
+	VRSkeletalMotionRange_WithoutController = 1,
+};
+
+enum EVRSkeletalTrackingLevel
+{
+	// body part location can't be directly determined by the device. Any skeletal pose provided by
+	// the device is estimated by assuming the position required to active buttons, triggers, joysticks, 
+	// or other input sensors. 
+	// E.g. Vive Controller, Gamepad
+	VRSkeletalTracking_Estimated = 0,
+
+	// body part location can be measured directly but with fewer degrees of freedom than the actual body 
+	// part. Certain body part positions may be unmeasured by the device and estimated from other input data. 
+	// E.g. Index Controllers, gloves that only measure finger curl
+	VRSkeletalTracking_Partial = 1,
+
+	// Body part location can be measured directly throughout the entire range of motion of the body part. 
+	// E.g. Mocap suit for the full body, gloves that measure rotation of each finger segment
+	VRSkeletalTracking_Full = 2,
+
+	VRSkeletalTrackingLevel_Count,
+	VRSkeletalTrackingLevel_Max = VRSkeletalTrackingLevel_Count - 1
+};
+
+
+
+/** Holds the transform for a single bone */
+struct VRBoneTransform_t
+{
+	HmdVector4_t position;
+	HmdQuaternionf_t orientation;
+};
+
+/** Type used for referring to bones by their index */
+typedef int32_t BoneIndex_t;
+const BoneIndex_t k_unInvalidBoneIndex = -1;
+
+
+/** error codes returned by Vr_Init */
+
+// Please add adequate error description to https://developer.valvesoftware.com/w/index.php?title=Category:SteamVRHelp
+enum EVRInitError
+{
+	VRInitError_None	= 0,
+	VRInitError_Unknown = 1,
+
+	VRInitError_Init_InstallationNotFound			= 100,
+	VRInitError_Init_InstallationCorrupt			= 101,
+	VRInitError_Init_VRClientDLLNotFound			= 102,
+	VRInitError_Init_FileNotFound					= 103,
+	VRInitError_Init_FactoryNotFound				= 104,
+	VRInitError_Init_InterfaceNotFound				= 105,
+	VRInitError_Init_InvalidInterface				= 106,
+	VRInitError_Init_UserConfigDirectoryInvalid		= 107,
+	VRInitError_Init_HmdNotFound					= 108,
+	VRInitError_Init_NotInitialized					= 109,
+	VRInitError_Init_PathRegistryNotFound			= 110,
+	VRInitError_Init_NoConfigPath					= 111,
+	VRInitError_Init_NoLogPath						= 112,
+	VRInitError_Init_PathRegistryNotWritable		= 113,
+	VRInitError_Init_AppInfoInitFailed				= 114,
+	VRInitError_Init_Retry							= 115, // Used internally to cause retries to vrserver
+	VRInitError_Init_InitCanceledByUser				= 116, // The calling application should silently exit. The user canceled app startup
+	VRInitError_Init_AnotherAppLaunching			= 117, 
+	VRInitError_Init_SettingsInitFailed				= 118, 
+	VRInitError_Init_ShuttingDown					= 119,
+	VRInitError_Init_TooManyObjects					= 120,
+	VRInitError_Init_NoServerForBackgroundApp		= 121,
+	VRInitError_Init_NotSupportedWithCompositor		= 122,
+	VRInitError_Init_NotAvailableToUtilityApps		= 123,
+	VRInitError_Init_Internal				 		= 124,
+	VRInitError_Init_HmdDriverIdIsNone		 		= 125,
+	VRInitError_Init_HmdNotFoundPresenceFailed 		= 126,
+	VRInitError_Init_VRMonitorNotFound				= 127,
+	VRInitError_Init_VRMonitorStartupFailed			= 128,
+	VRInitError_Init_LowPowerWatchdogNotSupported	= 129, 
+	VRInitError_Init_InvalidApplicationType			= 130,
+	VRInitError_Init_NotAvailableToWatchdogApps		= 131,
+	VRInitError_Init_WatchdogDisabledInSettings		= 132,
+	VRInitError_Init_VRDashboardNotFound			= 133,
+	VRInitError_Init_VRDashboardStartupFailed		= 134,
+	VRInitError_Init_VRHomeNotFound					= 135,
+	VRInitError_Init_VRHomeStartupFailed			= 136,
+	VRInitError_Init_RebootingBusy					= 137,
+	VRInitError_Init_FirmwareUpdateBusy				= 138,
+	VRInitError_Init_FirmwareRecoveryBusy			= 139,
+	VRInitError_Init_USBServiceBusy					= 140,
+	VRInitError_Init_VRWebHelperStartupFailed		= 141,
+	VRInitError_Init_TrackerManagerInitFailed		= 142,
+	VRInitError_Init_AlreadyRunning					= 143,
+	VRInitError_Init_FailedForVrMonitor				= 144,
+	VRInitError_Init_PropertyManagerInitFailed		= 145,
+	VRInitError_Init_WebServerFailed				= 146,
+
+	VRInitError_Driver_Failed						= 200,
+	VRInitError_Driver_Unknown						= 201,
+	VRInitError_Driver_HmdUnknown					= 202,
+	VRInitError_Driver_NotLoaded					= 203,
+	VRInitError_Driver_RuntimeOutOfDate				= 204,
+	VRInitError_Driver_HmdInUse						= 205,
+	VRInitError_Driver_NotCalibrated				= 206,
+	VRInitError_Driver_CalibrationInvalid			= 207,
+	VRInitError_Driver_HmdDisplayNotFound			= 208,
+	VRInitError_Driver_TrackedDeviceInterfaceUnknown = 209,
+	// VRInitError_Driver_HmdDisplayNotFoundAfterFix = 210, // not needed: here for historic reasons
+	VRInitError_Driver_HmdDriverIdOutOfBounds		= 211,
+	VRInitError_Driver_HmdDisplayMirrored			= 212,
+	VRInitError_Driver_HmdDisplayNotFoundLaptop		= 213,
+	// Never make error 259 because we return it from main and it would conflict with STILL_ACTIVE
+
+	VRInitError_IPC_ServerInitFailed				= 300,
+	VRInitError_IPC_ConnectFailed					= 301,
+	VRInitError_IPC_SharedStateInitFailed			= 302,
+	VRInitError_IPC_CompositorInitFailed			= 303,
+	VRInitError_IPC_MutexInitFailed					= 304,
+	VRInitError_IPC_Failed							= 305,
+	VRInitError_IPC_CompositorConnectFailed			= 306,
+	VRInitError_IPC_CompositorInvalidConnectResponse = 307,
+	VRInitError_IPC_ConnectFailedAfterMultipleAttempts = 308,
+	VRInitError_IPC_ConnectFailedAfterTargetExited = 309,
+	VRInitError_IPC_NamespaceUnavailable			 = 310,
+
+	VRInitError_Compositor_Failed												= 400,
+	VRInitError_Compositor_D3D11HardwareRequired								= 401,
+	VRInitError_Compositor_FirmwareRequiresUpdate								= 402,
+	VRInitError_Compositor_OverlayInitFailed									= 403,
+	VRInitError_Compositor_ScreenshotsInitFailed								= 404,
+	VRInitError_Compositor_UnableToCreateDevice									= 405,
+	VRInitError_Compositor_SharedStateIsNull									= 406,
+	VRInitError_Compositor_NotificationManagerIsNull							= 407,
+	VRInitError_Compositor_ResourceManagerClientIsNull							= 408,
+	VRInitError_Compositor_MessageOverlaySharedStateInitFailure					= 409,
+	VRInitError_Compositor_PropertiesInterfaceIsNull							= 410,
+	VRInitError_Compositor_CreateFullscreenWindowFailed							= 411,
+	VRInitError_Compositor_SettingsInterfaceIsNull								= 412,
+	VRInitError_Compositor_FailedToShowWindow									= 413,
+	VRInitError_Compositor_DistortInterfaceIsNull								= 414,
+	VRInitError_Compositor_DisplayFrequencyFailure								= 415,
+	VRInitError_Compositor_RendererInitializationFailed							= 416,
+	VRInitError_Compositor_DXGIFactoryInterfaceIsNull							= 417,
+	VRInitError_Compositor_DXGIFactoryCreateFailed								= 418,
+	VRInitError_Compositor_DXGIFactoryQueryFailed								= 419,
+	VRInitError_Compositor_InvalidAdapterDesktop								= 420,
+	VRInitError_Compositor_InvalidHmdAttachment									= 421,
+	VRInitError_Compositor_InvalidOutputDesktop									= 422,
+	VRInitError_Compositor_InvalidDeviceProvided								= 423,
+	VRInitError_Compositor_D3D11RendererInitializationFailed					= 424,
+	VRInitError_Compositor_FailedToFindDisplayMode								= 425,
+	VRInitError_Compositor_FailedToCreateSwapChain								= 426,
+	VRInitError_Compositor_FailedToGetBackBuffer								= 427,
+	VRInitError_Compositor_FailedToCreateRenderTarget							= 428,
+	VRInitError_Compositor_FailedToCreateDXGI2SwapChain							= 429,
+	VRInitError_Compositor_FailedtoGetDXGI2BackBuffer							= 430,
+	VRInitError_Compositor_FailedToCreateDXGI2RenderTarget						= 431,
+	VRInitError_Compositor_FailedToGetDXGIDeviceInterface						= 432,
+	VRInitError_Compositor_SelectDisplayMode									= 433,
+	VRInitError_Compositor_FailedToCreateNvAPIRenderTargets						= 434,
+	VRInitError_Compositor_NvAPISetDisplayMode									= 435,
+	VRInitError_Compositor_FailedToCreateDirectModeDisplay						= 436,
+	VRInitError_Compositor_InvalidHmdPropertyContainer							= 437,
+	VRInitError_Compositor_UpdateDisplayFrequency								= 438,
+	VRInitError_Compositor_CreateRasterizerState								= 439,
+	VRInitError_Compositor_CreateWireframeRasterizerState						= 440,
+	VRInitError_Compositor_CreateSamplerState									= 441,
+	VRInitError_Compositor_CreateClampToBorderSamplerState						= 442,
+	VRInitError_Compositor_CreateAnisoSamplerState								= 443,
+	VRInitError_Compositor_CreateOverlaySamplerState							= 444,
+	VRInitError_Compositor_CreatePanoramaSamplerState							= 445,
+	VRInitError_Compositor_CreateFontSamplerState								= 446,
+	VRInitError_Compositor_CreateNoBlendState									= 447,
+	VRInitError_Compositor_CreateBlendState										= 448,
+	VRInitError_Compositor_CreateAlphaBlendState								= 449,
+	VRInitError_Compositor_CreateBlendStateMaskR								= 450,
+	VRInitError_Compositor_CreateBlendStateMaskG								= 451,
+	VRInitError_Compositor_CreateBlendStateMaskB								= 452,
+	VRInitError_Compositor_CreateDepthStencilState								= 453,
+	VRInitError_Compositor_CreateDepthStencilStateNoWrite						= 454,
+	VRInitError_Compositor_CreateDepthStencilStateNoDepth						= 455,
+	VRInitError_Compositor_CreateFlushTexture									= 456,
+	VRInitError_Compositor_CreateDistortionSurfaces								= 457,
+	VRInitError_Compositor_CreateConstantBuffer									= 458,
+	VRInitError_Compositor_CreateHmdPoseConstantBuffer							= 459,
+	VRInitError_Compositor_CreateHmdPoseStagingConstantBuffer					= 460,
+	VRInitError_Compositor_CreateSharedFrameInfoConstantBuffer					= 461,
+	VRInitError_Compositor_CreateOverlayConstantBuffer							= 462,
+	VRInitError_Compositor_CreateSceneTextureIndexConstantBuffer				= 463,
+	VRInitError_Compositor_CreateReadableSceneTextureIndexConstantBuffer		= 464,
+	VRInitError_Compositor_CreateLayerGraphicsTextureIndexConstantBuffer		= 465,
+	VRInitError_Compositor_CreateLayerComputeTextureIndexConstantBuffer			= 466,
+	VRInitError_Compositor_CreateLayerComputeSceneTextureIndexConstantBuffer	= 467,
+	VRInitError_Compositor_CreateComputeHmdPoseConstantBuffer					= 468,
+	VRInitError_Compositor_CreateGeomConstantBuffer								= 469,
+	VRInitError_Compositor_CreatePanelMaskConstantBuffer						= 470,
+	VRInitError_Compositor_CreatePixelSimUBO									= 471,
+	VRInitError_Compositor_CreateMSAARenderTextures								= 472,
+	VRInitError_Compositor_CreateResolveRenderTextures							= 473,
+	VRInitError_Compositor_CreateComputeResolveRenderTextures					= 474,
+	VRInitError_Compositor_CreateDriverDirectModeResolveTextures				= 475,
+	VRInitError_Compositor_OpenDriverDirectModeResolveTextures					= 476,
+	VRInitError_Compositor_CreateFallbackSyncTexture							= 477,
+	VRInitError_Compositor_ShareFallbackSyncTexture								= 478,
+	VRInitError_Compositor_CreateOverlayIndexBuffer								= 479,
+	VRInitError_Compositor_CreateOverlayVertexBuffer							= 480,
+	VRInitError_Compositor_CreateTextVertexBuffer								= 481,
+	VRInitError_Compositor_CreateTextIndexBuffer								= 482,
+	VRInitError_Compositor_CreateMirrorTextures									= 483,
+	VRInitError_Compositor_CreateLastFrameRenderTexture							= 484,
+	VRInitError_Compositor_CreateMirrorOverlay									= 485,
+	VRInitError_Compositor_FailedToCreateVirtualDisplayBackbuffer				= 486,
+	VRInitError_Compositor_DisplayModeNotSupported								= 487,
+	VRInitError_Compositor_CreateOverlayInvalidCall								= 488,
+	VRInitError_Compositor_CreateOverlayAlreadyInitialized						= 489,
+	VRInitError_Compositor_FailedToCreateMailbox								= 490,
+	
+	VRInitError_VendorSpecific_UnableToConnectToOculusRuntime		= 1000,
+	VRInitError_VendorSpecific_WindowsNotInDevMode					= 1001,
+
+	VRInitError_VendorSpecific_HmdFound_CantOpenDevice 				= 1101,
+	VRInitError_VendorSpecific_HmdFound_UnableToRequestConfigStart	= 1102,
+	VRInitError_VendorSpecific_HmdFound_NoStoredConfig 				= 1103,
+	VRInitError_VendorSpecific_HmdFound_ConfigTooBig 				= 1104,
+	VRInitError_VendorSpecific_HmdFound_ConfigTooSmall 				= 1105,
+	VRInitError_VendorSpecific_HmdFound_UnableToInitZLib 			= 1106,
+	VRInitError_VendorSpecific_HmdFound_CantReadFirmwareVersion 	= 1107,
+	VRInitError_VendorSpecific_HmdFound_UnableToSendUserDataStart	= 1108,
+	VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataStart	= 1109,
+	VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataNext		= 1110,
+	VRInitError_VendorSpecific_HmdFound_UserDataAddressRange		= 1111,
+	VRInitError_VendorSpecific_HmdFound_UserDataError				= 1112,
+	VRInitError_VendorSpecific_HmdFound_ConfigFailedSanityCheck		= 1113,
+	VRInitError_VendorSpecific_OculusRuntimeBadInstall				= 1114,
+
+	VRInitError_Steam_SteamInstallationNotFound = 2000,
+
+	// Strictly a placeholder
+	VRInitError_LastError
+};
+
+enum EVRScreenshotType
+{
+	VRScreenshotType_None = 0,
+	VRScreenshotType_Mono = 1, // left eye only
+	VRScreenshotType_Stereo = 2,
+	VRScreenshotType_Cubemap = 3,
+	VRScreenshotType_MonoPanorama = 4,
+	VRScreenshotType_StereoPanorama = 5
+};
+
+enum EVRScreenshotPropertyFilenames
+{
+	VRScreenshotPropertyFilenames_Preview = 0,
+	VRScreenshotPropertyFilenames_VR = 1,
+};
+
+enum EVRTrackedCameraError
+{
+	VRTrackedCameraError_None                       = 0,
+	VRTrackedCameraError_OperationFailed            = 100,
+	VRTrackedCameraError_InvalidHandle              = 101,	
+	VRTrackedCameraError_InvalidFrameHeaderVersion  = 102,
+	VRTrackedCameraError_OutOfHandles               = 103,
+	VRTrackedCameraError_IPCFailure                 = 104,
+	VRTrackedCameraError_NotSupportedForThisDevice  = 105,
+	VRTrackedCameraError_SharedMemoryFailure        = 106,
+	VRTrackedCameraError_FrameBufferingFailure      = 107,
+	VRTrackedCameraError_StreamSetupFailure         = 108,
+	VRTrackedCameraError_InvalidGLTextureId         = 109,
+	VRTrackedCameraError_InvalidSharedTextureHandle = 110,
+	VRTrackedCameraError_FailedToGetGLTextureId     = 111,
+	VRTrackedCameraError_SharedTextureFailure       = 112,
+	VRTrackedCameraError_NoFrameAvailable           = 113,
+	VRTrackedCameraError_InvalidArgument            = 114,
+	VRTrackedCameraError_InvalidFrameBufferSize     = 115,
+};
+
+enum EVRTrackedCameraFrameLayout
+{
+	EVRTrackedCameraFrameLayout_Mono				= 0x0001,
+	EVRTrackedCameraFrameLayout_Stereo				= 0x0002,
+	EVRTrackedCameraFrameLayout_VerticalLayout		= 0x0010,	// Stereo frames are Top/Bottom (left/right)
+	EVRTrackedCameraFrameLayout_HorizontalLayout	= 0x0020,	// Stereo frames are Left/Right
+};
+	
+enum EVRTrackedCameraFrameType
+{
+	VRTrackedCameraFrameType_Distorted = 0,			// This is the camera video frame size in pixels, still distorted.
+	VRTrackedCameraFrameType_Undistorted,			// In pixels, an undistorted inscribed rectangle region without invalid regions. This size is subject to changes shortly.
+	VRTrackedCameraFrameType_MaximumUndistorted,	// In pixels, maximum undistorted with invalid regions. Non zero alpha component identifies valid regions.
+	MAX_CAMERA_FRAME_TYPES
+};
+
+enum EVRDistortionFunctionType
+{
+	VRDistortionFunctionType_None,
+	VRDistortionFunctionType_FTheta,
+	VRDistortionFunctionType_Extended_FTheta,
+	MAX_DISTORTION_FUNCTION_TYPES,
+};
+
+static const uint32_t k_unMaxDistortionFunctionParameters = 8;
+
+typedef uint64_t TrackedCameraHandle_t;
+#define INVALID_TRACKED_CAMERA_HANDLE	((vr::TrackedCameraHandle_t)0)
+
+struct CameraVideoStreamFrameHeader_t
+{
+	EVRTrackedCameraFrameType eFrameType;
+
+	uint32_t nWidth;
+	uint32_t nHeight;
+	uint32_t nBytesPerPixel;
+
+	uint32_t nFrameSequence;
+
+	TrackedDevicePose_t trackedDevicePose;
+	
+	uint64_t ulFrameExposureTime;						// mid-point of the exposure of the image in host system ticks
+};
+
+// Screenshot types
+typedef uint32_t ScreenshotHandle_t;
+
+static const uint32_t k_unScreenshotHandleInvalid = 0;
+
+/** Compositor frame timing reprojection flags. */
+const uint32_t VRCompositor_ReprojectionReason_Cpu = 0x01;
+const uint32_t VRCompositor_ReprojectionReason_Gpu = 0x02;
+const uint32_t VRCompositor_ReprojectionAsync = 0x04;	// This flag indicates the async reprojection mode is active,
+															// but does not indicate if reprojection actually happened or not.
+															// Use the ReprojectionReason flags above to check if reprojection
+															// was actually applied (i.e. scene texture was reused).
+															// NumFramePresents > 1 also indicates the scene texture was reused,
+															// and also the number of times that it was presented in total.
+
+const uint32_t VRCompositor_ReprojectionMotion = 0x08;	// This flag indicates whether or not motion smoothing was triggered for this frame
+
+const uint32_t VRCompositor_PredictionMask = 0x30;	// The runtime may predict more than one frame (up to four) ahead if
+															// it detects the application is taking too long to render. These two
+															// bits will contain the count of additional frames (normally zero).
+															// Use the VR_COMPOSITOR_ADDITIONAL_PREDICTED_FRAMES macro to read from
+															// the latest frame timing entry.
+
+const uint32_t VRCompositor_ThrottleMask = 0xC0;	// Number of frames the compositor is throttling the application.
+															// Use the VR_COMPOSITOR_NUMBER_OF_THROTTLED_FRAMES macro to read from
+															// the latest frame timing entry.
+
+#define VR_COMPOSITOR_ADDITIONAL_PREDICTED_FRAMES( timing ) ( ( ( timing ).m_nReprojectionFlags & vr::VRCompositor_PredictionMask ) >> 4 )
+#define VR_COMPOSITOR_NUMBER_OF_THROTTLED_FRAMES( timing ) ( ( ( timing ).m_nReprojectionFlags & vr::VRCompositor_ThrottleMask ) >> 6 )
+
+/** Provides a single frame's timing information to the app */
+struct Compositor_FrameTiming
+{
+	uint32_t m_nSize; // Set to sizeof( Compositor_FrameTiming )
+	uint32_t m_nFrameIndex;
+	uint32_t m_nNumFramePresents; // number of times this frame was presented
+	uint32_t m_nNumMisPresented; // number of times this frame was presented on a vsync other than it was originally predicted to
+	uint32_t m_nNumDroppedFrames; // number of additional times previous frame was scanned out
+	uint32_t m_nReprojectionFlags;
+
+	/** Absolute time reference for comparing frames.  This aligns with the vsync that running start is relative to. */
+	double m_flSystemTimeInSeconds;
+
+	/** These times may include work from other processes due to OS scheduling.
+	* The fewer packets of work these are broken up into, the less likely this will happen.
+	* GPU work can be broken up by calling Flush.  This can sometimes be useful to get the GPU started
+	* processing that work earlier in the frame. */
+	float m_flPreSubmitGpuMs; // time spent rendering the scene (gpu work submitted between WaitGetPoses and second Submit)
+	float m_flPostSubmitGpuMs; // additional time spent rendering by application (e.g. companion window)
+	float m_flTotalRenderGpuMs; // time between work submitted immediately after present (ideally vsync) until the end of compositor submitted work
+	float m_flCompositorRenderGpuMs; // time spend performing distortion correction, rendering chaperone, overlays, etc.
+	float m_flCompositorRenderCpuMs; // time spent on cpu submitting the above work for this frame
+	float m_flCompositorIdleCpuMs; // time spent waiting for running start (application could have used this much more time)
+
+	/** Miscellaneous measured intervals. */
+	float m_flClientFrameIntervalMs; // time between calls to WaitGetPoses
+	float m_flPresentCallCpuMs; // time blocked on call to present (usually 0.0, but can go long)
+	float m_flWaitForPresentCpuMs; // time spent spin-waiting for frame index to change (not near-zero indicates wait object failure)
+	float m_flSubmitFrameMs; // time spent in IVRCompositor::Submit (not near-zero indicates driver issue)
+
+	/** The following are all relative to this frame's SystemTimeInSeconds */
+	float m_flWaitGetPosesCalledMs;
+	float m_flNewPosesReadyMs;
+	float m_flNewFrameReadyMs; // second call to IVRCompositor::Submit
+	float m_flCompositorUpdateStartMs;
+	float m_flCompositorUpdateEndMs;
+	float m_flCompositorRenderStartMs;
+
+	vr::TrackedDevicePose_t m_HmdPose; // pose used by app to render this frame
+
+	uint32_t m_nNumVSyncsReadyForUse;
+	uint32_t m_nNumVSyncsToFirstView;
+};
+
+/** Provides compositor benchmark results to the app */
+struct Compositor_BenchmarkResults
+{
+	float m_flMegaPixelsPerSecond; // Measurement of GPU MP/s performed by compositor benchmark
+	float m_flHmdRecommendedMegaPixelsPerSecond; // Recommended default MP/s given the HMD resolution, refresh, and panel mask.
+};
+
+/** Frame timing data provided by direct mode drivers. */
+struct DriverDirectMode_FrameTiming
+{
+	uint32_t m_nSize; // Set to sizeof( DriverDirectMode_FrameTiming )
+	uint32_t m_nNumFramePresents; // number of times frame was presented
+	uint32_t m_nNumMisPresented; // number of times frame was presented on a vsync other than it was originally predicted to
+	uint32_t m_nNumDroppedFrames; // number of additional times previous frame was scanned out (i.e. compositor missed vsync)
+	uint32_t m_nReprojectionFlags;
+};
+
+/** These flags will be set on DriverDirectMode_FrameTiming::m_nReprojectionFlags when IVRDriverDirectModeComponent::GetFrameTiming is called for drivers to optionally respond to. */
+const uint32_t VRCompositor_ReprojectionMotion_Enabled = 0x100; // Motion Smoothing is enabled in the UI for the currently running application
+const uint32_t VRCompositor_ReprojectionMotion_ForcedOn = 0x200; // Motion Smoothing is forced on in the UI for the currently running application
+const uint32_t VRCompositor_ReprojectionMotion_AppThrottled = 0x400; // Application is requesting throttling via ForceInterleavedReprojectionOn
+
+
+enum EVSync
+{
+	VSync_None,
+	VSync_WaitRender,	// block following render work until vsync
+	VSync_NoWaitRender,	// do not block following render work (allow to get started early)
+};
+
+enum EVRMuraCorrectionMode
+{
+	EVRMuraCorrectionMode_Default = 0,
+	EVRMuraCorrectionMode_NoCorrection
+};
+
+/** raw IMU data provided by IVRIOBuffer from paths to tracked devices with IMUs */
+enum Imu_OffScaleFlags
+{
+	OffScale_AccelX	= 0x01,
+	OffScale_AccelY	= 0x02,
+	OffScale_AccelZ	= 0x04,
+	OffScale_GyroX	= 0x08,
+	OffScale_GyroY	= 0x10,
+	OffScale_GyroZ	= 0x20,
+};
+	
+struct ImuSample_t
+{
+	double fSampleTime;
+	HmdVector3d_t vAccel;
+	HmdVector3d_t vGyro;
+	uint32_t unOffScaleFlags;
+};
+
+#pragma pack( pop )
+
+// figure out how to import from the VR API dll
+#if defined(_WIN32)
+
+  #if !defined(OPENVR_BUILD_STATIC)
+    #ifdef VR_API_EXPORT
+      #define VR_INTERFACE extern "C" __declspec( dllexport )
+    #else
+      #define VR_INTERFACE extern "C" __declspec( dllimport )
+    #endif
+  #else
+    #define VR_INTERFACE extern "C"
+  #endif
+
+#elif defined(__GNUC__) || defined(COMPILER_GCC) || defined(__APPLE__)
+
+#ifdef VR_API_EXPORT
+  #define VR_INTERFACE extern "C" __attribute__((visibility("default")))
+#else
+  #define VR_INTERFACE extern "C" 
+#endif
+
+#else
+  #error "Unsupported Platform."
+#endif
+
+
+#if defined( _WIN32 )
+  #define VR_CALLTYPE __cdecl
+#else
+  #define VR_CALLTYPE 
+#endif
+
+} // namespace vr
+
+#endif // _INCLUDE_VRTYPES_H
+
+
+// vrannotation.h
+#ifdef API_GEN
+# define VR_CLANG_ATTR(ATTR) __attribute__((annotate( ATTR )))
+#else
+# define VR_CLANG_ATTR(ATTR)
+#endif
+
+#define VR_METHOD_DESC(DESC) VR_CLANG_ATTR( "desc:" #DESC ";" )
+#define VR_IGNOREATTR() VR_CLANG_ATTR( "ignore" )
+#define VR_OUT_STRUCT() VR_CLANG_ATTR( "out_struct: ;" )
+#define VR_OUT_STRING() VR_CLANG_ATTR( "out_string: ;" )
+#define VR_OUT_ARRAY_CALL(COUNTER,FUNCTION,PARAMS) VR_CLANG_ATTR( "out_array_call:" #COUNTER "," #FUNCTION "," #PARAMS ";" )
+#define VR_OUT_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR( "out_array_count:" #COUNTER ";" )
+#define VR_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR( "array_count:" #COUNTER ";" )
+#define VR_ARRAY_COUNT_D(COUNTER, DESC) VR_CLANG_ATTR( "array_count:" #COUNTER ";desc:" #DESC )
+#define VR_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR( "buffer_count:" #COUNTER ";" )
+#define VR_OUT_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR( "out_buffer_count:" #COUNTER ";" )
+#define VR_OUT_STRING_COUNT(COUNTER) VR_CLANG_ATTR( "out_string_count:" #COUNTER ";" )
+
+// ivrsystem.h
+namespace vr
+{
+
+struct VR_IVRSystem_FnTable
+{
+	void (__stdcall *GetRecommendedRenderTargetSize)( uint32_t *pnWidth, uint32_t *pnHeight );
+	HmdMatrix44_t (__stdcall *GetProjectionMatrix)( EVREye eEye, float fNearZ, float fFarZ );
+	void (__stdcall *GetProjectionRaw)( EVREye eEye, float *pfLeft, float *pfRight, float *pfTop, float *pfBottom );
+	bool (__stdcall *ComputeDistortion)( EVREye eEye, float fU, float fV, DistortionCoordinates_t *pDistortionCoordinates );
+	HmdMatrix34_t (__stdcall *GetEyeToHeadTransform)( EVREye eEye );
+	bool (__stdcall *GetTimeSinceLastVsync)( float *pfSecondsSinceLastVsync, uint64_t *pulFrameCounter );
+	int32_t (__stdcall *GetD3D9AdapterIndex)();
+	void (__stdcall *GetDXGIOutputInfo)( int32_t *pnAdapterIndex );
+	void (__stdcall *GetOutputDevice)( uint64_t *pnDevice, ETextureType textureType, VkInstance_T *pInstance);
+	bool (__stdcall *IsDisplayOnDesktop)();
+	bool (__stdcall *SetDisplayVisibility)( bool bIsVisibleOnDesktop );
+	void (__stdcall *GetDeviceToAbsoluteTrackingPose)( ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow,  TrackedDevicePose_t *pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount );
+	void (__stdcall *ResetSeatedZeroPose)();
+	HmdMatrix34_t (__stdcall *GetSeatedZeroPoseToStandingAbsoluteTrackingPose)();
+	HmdMatrix34_t (__stdcall *GetRawZeroPoseToStandingAbsoluteTrackingPose)();
+	uint32_t (__stdcall *GetSortedTrackedDeviceIndicesOfClass)( ETrackedDeviceClass eTrackedDeviceClass,  vr::TrackedDeviceIndex_t *punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, vr::TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex);
+	EDeviceActivityLevel (__stdcall *GetTrackedDeviceActivityLevel)( vr::TrackedDeviceIndex_t unDeviceId );
+	void (__stdcall *ApplyTransform)( TrackedDevicePose_t *pOutputPose, const TrackedDevicePose_t *pTrackedDevicePose, const HmdMatrix34_t *pTransform );
+	vr::TrackedDeviceIndex_t (__stdcall *GetTrackedDeviceIndexForControllerRole)( vr::ETrackedControllerRole unDeviceType );
+	vr::ETrackedControllerRole (__stdcall *GetControllerRoleForTrackedDeviceIndex)( vr::TrackedDeviceIndex_t unDeviceIndex );
+	ETrackedDeviceClass (__stdcall *GetTrackedDeviceClass)( vr::TrackedDeviceIndex_t unDeviceIndex );
+	bool (__stdcall *IsTrackedDeviceConnected)( vr::TrackedDeviceIndex_t unDeviceIndex );
+	bool (__stdcall *GetBoolTrackedDeviceProperty)( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError);
+	float (__stdcall *GetFloatTrackedDeviceProperty)( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError);
+	int32_t (__stdcall *GetInt32TrackedDeviceProperty)( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError);
+	uint64_t (__stdcall *GetUint64TrackedDeviceProperty)( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError);
+	HmdMatrix34_t (__stdcall *GetMatrix34TrackedDeviceProperty)( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError);
+	uint32_t (__stdcall *GetArrayTrackedDeviceProperty)( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void *pBuffer, uint32_t unBufferSize, ETrackedPropertyError *pError);
+	uint32_t (__stdcall *GetStringTrackedDeviceProperty)( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop,  char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError);
+	const char *(__stdcall *GetPropErrorNameFromEnum)( ETrackedPropertyError error );
+	bool (__stdcall *PollNextEvent)( VREvent_t *pEvent, uint32_t uncbVREvent );
+	bool (__stdcall *PollNextEventWithPose)( ETrackingUniverseOrigin eOrigin, VREvent_t *pEvent, uint32_t uncbVREvent, vr::TrackedDevicePose_t *pTrackedDevicePose );
+	const char *(__stdcall *GetEventTypeNameFromEnum)( EVREventType eType );
+	HiddenAreaMesh_t (__stdcall *GetHiddenAreaMesh)( EVREye eEye, EHiddenAreaMeshType type);
+	bool (__stdcall *GetControllerState)( vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize );
+	bool (__stdcall *GetControllerStateWithPose)( ETrackingUniverseOrigin eOrigin, vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose );
+	void (__stdcall *TriggerHapticPulse)( vr::TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec );
+	const char *(__stdcall *GetButtonIdNameFromEnum)( EVRButtonId eButtonId );
+	const char *(__stdcall *GetControllerAxisTypeNameFromEnum)( EVRControllerAxisType eAxisType );
+	bool (__stdcall *IsInputAvailable)();
+	bool (__stdcall *IsSteamVRDrawingControllers)();
+	bool (__stdcall *ShouldApplicationPause)();
+	bool (__stdcall *ShouldApplicationReduceRenderingWork)();
+	vr::EVRFirmwareError (__stdcall *PerformFirmwareUpdate)( vr::TrackedDeviceIndex_t unDeviceIndex );
+	void (__stdcall *AcknowledgeQuit_Exiting)();
+	uint32_t (__stdcall *GetAppContainerFilePaths)(  char *pchBuffer, uint32_t unBufferSize );
+	const char *(__stdcall *GetRuntimeVersion)();
+};
+
+class IVRSystem
+{
+	VR_IVRSystem_FnTable _table;
+public:
+
+
+	// ------------------------------------
+	// Display Methods
+	// ------------------------------------
+
+	/** Suggested size for the intermediate render target that the distortion pulls from. */
+	void GetRecommendedRenderTargetSize( uint32_t *pnWidth, uint32_t *pnHeight ) { _table.GetRecommendedRenderTargetSize(pnWidth, pnHeight); }
+
+	/** The projection matrix for the specified eye */
+	HmdMatrix44_t GetProjectionMatrix( EVREye eEye, float fNearZ, float fFarZ ) { return _table.GetProjectionMatrix(eEye, fNearZ, fFarZ); }
+
+	/** The components necessary to build your own projection matrix in case your
+	* application is doing something fancy like infinite Z */
+	void GetProjectionRaw( EVREye eEye, float *pfLeft, float *pfRight, float *pfTop, float *pfBottom ) { _table.GetProjectionRaw(eEye, pfLeft, pfRight, pfTop, pfBottom); }
+
+	/** Gets the result of the distortion function for the specified eye and input UVs. UVs go from 0,0 in 
+	* the upper left of that eye's viewport and 1,1 in the lower right of that eye's viewport.
+	* Returns true for success. Otherwise, returns false, and distortion coordinates are not suitable. */
+	bool ComputeDistortion( EVREye eEye, float fU, float fV, DistortionCoordinates_t *pDistortionCoordinates ) { return _table.ComputeDistortion(eEye, fU, fV, pDistortionCoordinates); }
+
+	/** Returns the transform from eye space to the head space. Eye space is the per-eye flavor of head
+	* space that provides stereo disparity. Instead of Model * View * Projection the sequence is Model * View * Eye^-1 * Projection. 
+	* Normally View and Eye^-1 will be multiplied together and treated as View in your application. 
+	*/
+	HmdMatrix34_t GetEyeToHeadTransform( EVREye eEye ) { return _table.GetEyeToHeadTransform(eEye); }
+
+	/** Returns the number of elapsed seconds since the last recorded vsync event. This 
+	*	will come from a vsync timer event in the timer if possible or from the application-reported
+	*   time if that is not available. If no vsync times are available the function will 
+	*   return zero for vsync time and frame counter and return false from the method. */
+	bool GetTimeSinceLastVsync( float *pfSecondsSinceLastVsync, uint64_t *pulFrameCounter ) { return _table.GetTimeSinceLastVsync(pfSecondsSinceLastVsync, pulFrameCounter); }
+
+	/** [D3D9 Only]
+	* Returns the adapter index that the user should pass into CreateDevice to set up D3D9 in such
+	* a way that it can go full screen exclusive on the HMD. Returns -1 if there was an error.
+	*/
+	int32_t GetD3D9AdapterIndex() { return _table.GetD3D9AdapterIndex(); }
+
+	/** [D3D10/11 Only]
+	* Returns the adapter index that the user should pass into EnumAdapters to create the device 
+	* and swap chain in DX10 and DX11. If an error occurs the index will be set to -1.
+	*/
+	void GetDXGIOutputInfo( int32_t *pnAdapterIndex ) { _table.GetDXGIOutputInfo(pnAdapterIndex); }
+	
+	/**
+	 * Returns platform- and texture-type specific adapter identification so that applications and the
+	 * compositor are creating textures and swap chains on the same GPU. If an error occurs the device
+	 * will be set to 0.
+	 * pInstance is an optional parameter that is required only when textureType is TextureType_Vulkan.
+	 * [D3D10/11/12 Only (D3D9 Not Supported)]
+	 *  Returns the adapter LUID that identifies the GPU attached to the HMD. The user should
+	 *  enumerate all adapters using IDXGIFactory::EnumAdapters and IDXGIAdapter::GetDesc to find
+	 *  the adapter with the matching LUID, or use IDXGIFactory4::EnumAdapterByLuid.
+	 *  The discovered IDXGIAdapter should be used to create the device and swap chain.
+	 * [Vulkan Only]
+	 *  Returns the VkPhysicalDevice that should be used by the application.
+	 *  pInstance must be the instance the application will use to query for the VkPhysicalDevice.  The application
+	 *  must create the VkInstance with extensions returned by IVRCompositor::GetVulkanInstanceExtensionsRequired enabled.
+	 * [macOS Only]
+	 *  For TextureType_IOSurface returns the id<MTLDevice> that should be used by the application.
+	 *  On 10.13+ for TextureType_OpenGL returns the 'registryId' of the renderer which should be used
+	 *   by the application. See Apple Technical Q&A QA1168 for information on enumerating GL Renderers, and the
+	 *   new kCGLRPRegistryIDLow and kCGLRPRegistryIDHigh CGLRendererProperty values in the 10.13 SDK.
+	 *  Pre 10.13 for TextureType_OpenGL returns 0, as there is no dependable way to correlate the HMDs MTLDevice
+	 *   with a GL Renderer.
+	 */
+	void GetOutputDevice( uint64_t *pnDevice, ETextureType textureType, VkInstance_T *pInstance = nullptr ) { _table.GetOutputDevice(pnDevice, textureType, pInstance); }
+
+	// ------------------------------------
+	// Display Mode methods
+	// ------------------------------------
+
+	/** Use to determine if the headset display is part of the desktop (i.e. extended) or hidden (i.e. direct mode). */
+	bool IsDisplayOnDesktop() { return _table.IsDisplayOnDesktop(); }
+
+	/** Set the display visibility (true = extended, false = direct mode).  Return value of true indicates that the change was successful. */
+	bool SetDisplayVisibility( bool bIsVisibleOnDesktop ) { return _table.SetDisplayVisibility(bIsVisibleOnDesktop); }
+
+	// ------------------------------------
+	// Tracking Methods
+	// ------------------------------------
+
+	/** The pose that the tracker thinks that the HMD will be in at the specified number of seconds into the 
+	* future. Pass 0 to get the state at the instant the method is called. Most of the time the application should
+	* calculate the time until the photons will be emitted from the display and pass that time into the method.
+	*
+	* This is roughly analogous to the inverse of the view matrix in most applications, though 
+	* many games will need to do some additional rotation or translation on top of the rotation
+	* and translation provided by the head pose.
+	*
+	* For devices where bPoseIsValid is true the application can use the pose to position the device
+	* in question. The provided array can be any size up to k_unMaxTrackedDeviceCount. 
+	*
+	* Seated experiences should call this method with TrackingUniverseSeated and receive poses relative
+	* to the seated zero pose. Standing experiences should call this method with TrackingUniverseStanding 
+	* and receive poses relative to the Chaperone Play Area. TrackingUniverseRawAndUncalibrated should 
+	* probably not be used unless the application is the Chaperone calibration tool itself, but will provide
+	* poses relative to the hardware-specific coordinate system in the driver.
+	*/
+	void GetDeviceToAbsoluteTrackingPose( ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, VR_ARRAY_COUNT(unTrackedDevicePoseArrayCount) TrackedDevicePose_t *pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount ) { _table.GetDeviceToAbsoluteTrackingPose(eOrigin, fPredictedSecondsToPhotonsFromNow, pTrackedDevicePoseArray, unTrackedDevicePoseArrayCount); }
+
+	/** Sets the zero pose for the seated tracker coordinate system to the current position and yaw of the HMD. After 
+	* ResetSeatedZeroPose all GetDeviceToAbsoluteTrackingPose calls that pass TrackingUniverseSeated as the origin 
+	* will be relative to this new zero pose. The new zero coordinate system will not change the fact that the Y axis 
+	* is up in the real world, so the next pose returned from GetDeviceToAbsoluteTrackingPose after a call to 
+	* ResetSeatedZeroPose may not be exactly an identity matrix.
+	*
+	* NOTE: This function overrides the user's previously saved seated zero pose and should only be called as the result of a user action. 
+	* Users are also able to set their seated zero pose via the OpenVR Dashboard.
+	**/
+	void ResetSeatedZeroPose() { _table.ResetSeatedZeroPose(); }
+
+	/** Returns the transform from the seated zero pose to the standing absolute tracking system. This allows 
+	* applications to represent the seated origin to used or transform object positions from one coordinate
+	* system to the other. 
+	*
+	* The seated origin may or may not be inside the Play Area or Collision Bounds returned by IVRChaperone. Its position 
+	* depends on what the user has set from the Dashboard settings and previous calls to ResetSeatedZeroPose. */
+	HmdMatrix34_t GetSeatedZeroPoseToStandingAbsoluteTrackingPose() { return _table.GetSeatedZeroPoseToStandingAbsoluteTrackingPose(); }
+
+	/** Returns the transform from the tracking origin to the standing absolute tracking system. This allows
+	* applications to convert from raw tracking space to the calibrated standing coordinate system. */
+	HmdMatrix34_t GetRawZeroPoseToStandingAbsoluteTrackingPose() { return _table.GetRawZeroPoseToStandingAbsoluteTrackingPose(); }
+
+	/** Get a sorted array of device indices of a given class of tracked devices (e.g. controllers).  Devices are sorted right to left
+	* relative to the specified tracked device (default: hmd -- pass in -1 for absolute tracking space).  Returns the number of devices
+	* in the list, or the size of the array needed if not large enough. */
+	uint32_t GetSortedTrackedDeviceIndicesOfClass( ETrackedDeviceClass eTrackedDeviceClass, VR_ARRAY_COUNT(unTrackedDeviceIndexArrayCount) vr::TrackedDeviceIndex_t *punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, vr::TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex = k_unTrackedDeviceIndex_Hmd ) { return _table.GetSortedTrackedDeviceIndicesOfClass(eTrackedDeviceClass, punTrackedDeviceIndexArray, unTrackedDeviceIndexArrayCount, unRelativeToTrackedDeviceIndex); }
+
+	/** Returns the level of activity on the device. */
+	EDeviceActivityLevel GetTrackedDeviceActivityLevel( vr::TrackedDeviceIndex_t unDeviceId ) { return _table.GetTrackedDeviceActivityLevel(unDeviceId); }
+
+	/** Convenience utility to apply the specified transform to the specified pose.
+	*   This properly transforms all pose components, including velocity and angular velocity
+	*/
+	void ApplyTransform( TrackedDevicePose_t *pOutputPose, const TrackedDevicePose_t *pTrackedDevicePose, const HmdMatrix34_t *pTransform ) { _table.ApplyTransform(pOutputPose, pTrackedDevicePose, pTransform); }
+
+	/** Returns the device index associated with a specific role, for example the left hand or the right hand. This function is deprecated in favor of the new IVRInput system. */
+	vr::TrackedDeviceIndex_t GetTrackedDeviceIndexForControllerRole( vr::ETrackedControllerRole unDeviceType ) { return _table.GetTrackedDeviceIndexForControllerRole(unDeviceType); }
+
+	/** Returns the controller type associated with a device index. This function is deprecated in favor of the new IVRInput system. */
+	vr::ETrackedControllerRole GetControllerRoleForTrackedDeviceIndex( vr::TrackedDeviceIndex_t unDeviceIndex ) { return _table.GetControllerRoleForTrackedDeviceIndex(unDeviceIndex); }
+
+	// ------------------------------------
+	// Property methods
+	// ------------------------------------
+
+	/** Returns the device class of a tracked device. If there has not been a device connected in this slot
+	* since the application started this function will return TrackedDevice_Invalid. For previous detected
+	* devices the function will return the previously observed device class. 
+	*
+	* To determine which devices exist on the system, just loop from 0 to k_unMaxTrackedDeviceCount and check
+	* the device class. Every device with something other than TrackedDevice_Invalid is associated with an 
+	* actual tracked device. */
+	ETrackedDeviceClass GetTrackedDeviceClass( vr::TrackedDeviceIndex_t unDeviceIndex ) { return _table.GetTrackedDeviceClass(unDeviceIndex); }
+
+	/** Returns true if there is a device connected in this slot. */
+	bool IsTrackedDeviceConnected( vr::TrackedDeviceIndex_t unDeviceIndex ) { return _table.IsTrackedDeviceConnected(unDeviceIndex); }
+
+	/** Returns a bool property. If the device index is not valid or the property is not a bool type this function will return false. */
+	bool GetBoolTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) { return _table.GetBoolTrackedDeviceProperty(unDeviceIndex, prop, pError); }
+
+	/** Returns a float property. If the device index is not valid or the property is not a float type this function will return 0. */
+	float GetFloatTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) { return _table.GetFloatTrackedDeviceProperty(unDeviceIndex, prop, pError); }
+
+	/** Returns an int property. If the device index is not valid or the property is not a int type this function will return 0. */
+	int32_t GetInt32TrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) { return _table.GetInt32TrackedDeviceProperty(unDeviceIndex, prop, pError); }
+
+	/** Returns a uint64 property. If the device index is not valid or the property is not a uint64 type this function will return 0. */
+	uint64_t GetUint64TrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) { return _table.GetUint64TrackedDeviceProperty(unDeviceIndex, prop, pError); }
+
+	/** Returns a matrix property. If the device index is not valid or the property is not a matrix type, this function will return identity. */
+	HmdMatrix34_t GetMatrix34TrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) { return _table.GetMatrix34TrackedDeviceProperty(unDeviceIndex, prop, pError); }
+	
+	/** Returns an array of one type of property. If the device index is not valid or the property is not a single value or an array of the specified type,
+	* this function will return 0. Otherwise it returns the number of bytes necessary to hold the array of properties. If unBufferSize is
+	* greater than the returned size and pBuffer is non-NULL, pBuffer is filled with the contents of array of properties. */
+	uint32_t GetArrayTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void *pBuffer, uint32_t unBufferSize, ETrackedPropertyError *pError = 0L ) { return _table.GetArrayTrackedDeviceProperty(unDeviceIndex, prop, propType, pBuffer, unBufferSize, pError); }
+
+	/** Returns a string property. If the device index is not valid or the property is not a string type this function will 
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters. */
+	uint32_t GetStringTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError = 0L ) { return _table.GetStringTrackedDeviceProperty(unDeviceIndex, prop, pchValue, unBufferSize, pError); }
+
+	/** returns a string that corresponds with the specified property error. The string will be the name 
+	* of the error enum value for all valid error codes */
+	const char *GetPropErrorNameFromEnum( ETrackedPropertyError error ) { return _table.GetPropErrorNameFromEnum(error); }
+
+	// ------------------------------------
+	// Event methods
+	// ------------------------------------
+
+	/** Returns true and fills the event with the next event on the queue if there is one. If there are no events
+	* this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct */
+	bool PollNextEvent( VREvent_t *pEvent, uint32_t uncbVREvent ) { return _table.PollNextEvent(pEvent, uncbVREvent); }
+
+	/** Returns true and fills the event with the next event on the queue if there is one. If there are no events
+	* this method returns false. Fills in the pose of the associated tracked device in the provided pose struct. 
+	* This pose will always be older than the call to this function and should not be used to render the device. 
+	uncbVREvent should be the size in bytes of the VREvent_t struct */
+	bool PollNextEventWithPose( ETrackingUniverseOrigin eOrigin, VREvent_t *pEvent, uint32_t uncbVREvent, vr::TrackedDevicePose_t *pTrackedDevicePose ) { return _table.PollNextEventWithPose(eOrigin, pEvent, uncbVREvent, pTrackedDevicePose); }
+
+	/** returns the name of an EVREvent enum value */
+	const char *GetEventTypeNameFromEnum( EVREventType eType ) { return _table.GetEventTypeNameFromEnum(eType); }
+
+	// ------------------------------------
+	// Rendering helper methods
+	// ------------------------------------
+
+	/** Returns the hidden area mesh for the current HMD. The pixels covered by this mesh will never be seen by the user after the lens distortion is
+	* applied based on visibility to the panels. If this HMD does not have a hidden area mesh, the vertex data and count will be NULL and 0 respectively.
+	* This mesh is meant to be rendered into the stencil buffer (or into the depth buffer setting nearz) before rendering each eye's view. 
+	* This will improve performance by letting the GPU early-reject pixels the user will never see before running the pixel shader.
+	* NOTE: Render this mesh with backface culling disabled since the winding order of the vertices can be different per-HMD or per-eye.
+	* Setting the bInverse argument to true will produce the visible area mesh that is commonly used in place of full-screen quads. The visible area mesh covers all of the pixels the hidden area mesh does not cover.
+	* Setting the bLineLoop argument will return a line loop of vertices in HiddenAreaMesh_t->pVertexData with HiddenAreaMesh_t->unTriangleCount set to the number of vertices.
+	*/
+	HiddenAreaMesh_t GetHiddenAreaMesh( EVREye eEye, EHiddenAreaMeshType type = k_eHiddenAreaMesh_Standard ) { return _table.GetHiddenAreaMesh(eEye, type); }
+
+	// ------------------------------------
+	// Controller methods
+	// ------------------------------------
+
+	/** Fills the supplied struct with the current state of the controller. Returns false if the controller index
+	* is invalid. This function is deprecated in favor of the new IVRInput system. */
+	bool GetControllerState( vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize ) { return _table.GetControllerState(unControllerDeviceIndex, pControllerState, unControllerStateSize); }
+
+	/** fills the supplied struct with the current state of the controller and the provided pose with the pose of 
+	* the controller when the controller state was updated most recently. Use this form if you need a precise controller
+	* pose as input to your application when the user presses or releases a button. This function is deprecated in favor of the new IVRInput system. */
+	bool GetControllerStateWithPose( ETrackingUniverseOrigin eOrigin, vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose ) { return _table.GetControllerStateWithPose(eOrigin, unControllerDeviceIndex, pControllerState, unControllerStateSize, pTrackedDevicePose); }
+
+	/** Trigger a single haptic pulse on a controller. After this call the application may not trigger another haptic pulse on this controller
+	* and axis combination for 5ms. This function is deprecated in favor of the new IVRInput system. */
+	void TriggerHapticPulse( vr::TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec ) { _table.TriggerHapticPulse(unControllerDeviceIndex, unAxisId, usDurationMicroSec); }
+
+	/** returns the name of an EVRButtonId enum value. This function is deprecated in favor of the new IVRInput system.  */
+	const char *GetButtonIdNameFromEnum( EVRButtonId eButtonId ) { return _table.GetButtonIdNameFromEnum(eButtonId); }
+
+	/** returns the name of an EVRControllerAxisType enum value. This function is deprecated in favor of the new IVRInput system. */
+	const char *GetControllerAxisTypeNameFromEnum( EVRControllerAxisType eAxisType ) { return _table.GetControllerAxisTypeNameFromEnum(eAxisType); }
+
+	/** Returns true if this application is receiving input from the system. This would return false if 
+	* system-related functionality is consuming the input stream. */
+	bool IsInputAvailable() { return _table.IsInputAvailable(); }
+
+	/** Returns true SteamVR is drawing controllers on top of the application. Applications should consider
+	* not drawing anything attached to the user's hands in this case. */
+	bool IsSteamVRDrawingControllers() { return _table.IsSteamVRDrawingControllers(); }
+
+	/** Returns true if the user has put SteamVR into a mode that is distracting them from the application.
+	* For applications where this is appropriate, the application should pause ongoing activity. */
+	bool ShouldApplicationPause() { return _table.ShouldApplicationPause(); }
+
+	/** Returns true if SteamVR is doing significant rendering work and the game should do what it can to reduce
+	* its own workload. One common way to do this is to reduce the size of the render target provided for each eye. */
+	bool ShouldApplicationReduceRenderingWork() { return _table.ShouldApplicationReduceRenderingWork(); }
+
+	// ------------------------------------
+	// Firmware methods
+	// ------------------------------------
+	
+	/** Performs the actual firmware update if applicable. 
+	 * The following events will be sent, if VRFirmwareError_None was returned: VREvent_FirmwareUpdateStarted, VREvent_FirmwareUpdateFinished 
+	 * Use the properties Prop_Firmware_UpdateAvailable_Bool, Prop_Firmware_ManualUpdate_Bool, and Prop_Firmware_ManualUpdateURL_String
+	 * to figure our whether a firmware update is available, and to figure out whether its a manual update 
+	 * Prop_Firmware_ManualUpdateURL_String should point to an URL describing the manual update process */
+	vr::EVRFirmwareError PerformFirmwareUpdate( vr::TrackedDeviceIndex_t unDeviceIndex ) { return _table.PerformFirmwareUpdate(unDeviceIndex); }
+
+	// ------------------------------------
+	// Application life cycle methods
+	// ------------------------------------
+
+	/** Call this to acknowledge to the system that VREvent_Quit has been received and that the process is exiting.
+	* This extends the timeout until the process is killed. */
+	void AcknowledgeQuit_Exiting() { _table.AcknowledgeQuit_Exiting(); }
+
+	// -------------------------------------
+	// App container sandbox methods
+	// -------------------------------------
+
+	/** Retrieves a null-terminated, semicolon-delimited list of UTF8 file paths that an application 
+	* must have read access to when running inside of an app container. Returns the number of bytes
+	* needed to hold the list. */
+	uint32_t GetAppContainerFilePaths( VR_OUT_STRING() char *pchBuffer, uint32_t unBufferSize ) { return _table.GetAppContainerFilePaths(pchBuffer, unBufferSize); }
+
+	// -------------------------------------
+	// System methods
+	// -------------------------------------
+
+	/** Returns the current version of the SteamVR runtime. The returned string will remain valid until VR_Shutdown is called.
+	*
+	* NOTE: Is it not appropriate to use this version to test for the presence of any SteamVR feature. Only use this version
+	* number for logging or showing to a user, and not to try to detect anything at runtime. When appropriate, feature-specific
+	* presence information is provided by other APIs. */
+	const char *GetRuntimeVersion() { return _table.GetRuntimeVersion(); }
+
+};
+
+static const char * const IVRSystem_Version = "FnTable:IVRSystem_021";
+
+}
+
+
+// ivrapplications.h
+namespace vr
+{
+
+	/** Used for all errors reported by the IVRApplications interface */
+	enum EVRApplicationError
+	{
+		VRApplicationError_None = 0,
+
+		VRApplicationError_AppKeyAlreadyExists = 100,	// Only one application can use any given key
+		VRApplicationError_NoManifest = 101,			// the running application does not have a manifest
+		VRApplicationError_NoApplication = 102,			// No application is running
+		VRApplicationError_InvalidIndex = 103,
+		VRApplicationError_UnknownApplication = 104,	// the application could not be found
+		VRApplicationError_IPCFailed = 105,				// An IPC failure caused the request to fail
+		VRApplicationError_ApplicationAlreadyRunning = 106, 
+		VRApplicationError_InvalidManifest = 107,
+		VRApplicationError_InvalidApplication = 108,
+		VRApplicationError_LaunchFailed = 109,			// the process didn't start
+		VRApplicationError_ApplicationAlreadyStarting = 110, // the system was already starting the same application
+		VRApplicationError_LaunchInProgress = 111,		// The system was already starting a different application
+		VRApplicationError_OldApplicationQuitting = 112, 
+		VRApplicationError_TransitionAborted = 113,
+		VRApplicationError_IsTemplate = 114, // error when you try to call LaunchApplication() on a template type app (use LaunchTemplateApplication)
+		VRApplicationError_SteamVRIsExiting = 115,
+
+		VRApplicationError_BufferTooSmall = 200,		// The provided buffer was too small to fit the requested data
+		VRApplicationError_PropertyNotSet = 201,		// The requested property was not set
+		VRApplicationError_UnknownProperty = 202,
+		VRApplicationError_InvalidParameter = 203,
+	};
+
+	/** The maximum length of an application key */
+	static const uint32_t k_unMaxApplicationKeyLength = 128;
+
+	/** these are the properties available on applications. */
+	enum EVRApplicationProperty
+	{
+		VRApplicationProperty_Name_String				= 0,
+
+		VRApplicationProperty_LaunchType_String			= 11,
+		VRApplicationProperty_WorkingDirectory_String	= 12,
+		VRApplicationProperty_BinaryPath_String			= 13,
+		VRApplicationProperty_Arguments_String			= 14,
+		VRApplicationProperty_URL_String				= 15,
+
+		VRApplicationProperty_Description_String		= 50,
+		VRApplicationProperty_NewsURL_String			= 51,
+		VRApplicationProperty_ImagePath_String			= 52,
+		VRApplicationProperty_Source_String				= 53,
+		VRApplicationProperty_ActionManifestURL_String	= 54,
+
+		VRApplicationProperty_IsDashboardOverlay_Bool	= 60,
+		VRApplicationProperty_IsTemplate_Bool			= 61,
+		VRApplicationProperty_IsInstanced_Bool			= 62,
+		VRApplicationProperty_IsInternal_Bool			= 63,
+		VRApplicationProperty_WantsCompositorPauseInStandby_Bool = 64,
+		VRApplicationProperty_IsHidden_Bool				= 65,
+
+		VRApplicationProperty_LastLaunchTime_Uint64		= 70,
+	};
+
+	enum EVRSceneApplicationState
+	{
+		EVRSceneApplicationState_None						      = 0, // Scene Application is not running
+		EVRSceneApplicationState_Starting					      = 1, // Scene Application is starting
+		EVRSceneApplicationState_Quitting					      = 2, // Scene Application is quitting
+		EVRSceneApplicationState_Running						  = 3, // Scene Application is running, and submitting frames, a custom skybox, or a visible overlay
+		EVRSceneApplicationState_Waiting						  = 4, // Scene Application is running, but not drawing anything
+	};
+
+	struct AppOverrideKeys_t
+	{
+		const char *pchKey;
+		const char *pchValue;
+	};
+
+	/** Currently recognized mime types */
+	static const char * const k_pch_MimeType_HomeApp		= "vr/home";
+	static const char * const k_pch_MimeType_GameTheater	= "vr/game_theater";
+
+	struct VR_IVRApplications_FnTable
+	{
+		EVRApplicationError (__stdcall *AddApplicationManifest)( const char *pchApplicationManifestFullPath, bool bTemporary);
+		EVRApplicationError (__stdcall *RemoveApplicationManifest)( const char *pchApplicationManifestFullPath );
+		bool (__stdcall *IsApplicationInstalled)( const char *pchAppKey );
+		uint32_t (__stdcall *GetApplicationCount)();
+		EVRApplicationError (__stdcall *GetApplicationKeyByIndex)( uint32_t unApplicationIndex,  char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen );
+		EVRApplicationError (__stdcall *GetApplicationKeyByProcessId)( uint32_t unProcessId,  char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen );
+		EVRApplicationError (__stdcall *LaunchApplication)( const char *pchAppKey );
+		EVRApplicationError (__stdcall *LaunchTemplateApplication)( const char *pchTemplateAppKey, const char *pchNewAppKey,  const AppOverrideKeys_t *pKeys, uint32_t unKeys );
+		vr::EVRApplicationError (__stdcall *LaunchApplicationFromMimeType)( const char *pchMimeType, const char *pchArgs );
+		EVRApplicationError (__stdcall *LaunchDashboardOverlay)( const char *pchAppKey );
+		bool (__stdcall *CancelApplicationLaunch)( const char *pchAppKey );
+		EVRApplicationError (__stdcall *IdentifyApplication)( uint32_t unProcessId, const char *pchAppKey );
+		uint32_t (__stdcall *GetApplicationProcessId)( const char *pchAppKey );
+		const char *(__stdcall *GetApplicationsErrorNameFromEnum)( EVRApplicationError error );
+		uint32_t (__stdcall *GetApplicationPropertyString)( const char *pchAppKey, EVRApplicationProperty eProperty,  char *pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError *peError);
+		bool (__stdcall *GetApplicationPropertyBool)( const char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError);
+		uint64_t (__stdcall *GetApplicationPropertyUint64)( const char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError);
+		EVRApplicationError (__stdcall *SetApplicationAutoLaunch)( const char *pchAppKey, bool bAutoLaunch );
+		bool (__stdcall *GetApplicationAutoLaunch)( const char *pchAppKey );
+		EVRApplicationError (__stdcall *SetDefaultApplicationForMimeType)( const char *pchAppKey, const char *pchMimeType );
+		bool (__stdcall *GetDefaultApplicationForMimeType)( const char *pchMimeType,  char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen );
+		bool (__stdcall *GetApplicationSupportedMimeTypes)( const char *pchAppKey,  char *pchMimeTypesBuffer, uint32_t unMimeTypesBuffer );
+		uint32_t (__stdcall *GetApplicationsThatSupportMimeType)( const char *pchMimeType,  char *pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer );
+		uint32_t (__stdcall *GetApplicationLaunchArguments)( uint32_t unHandle,  char *pchArgs, uint32_t unArgs );
+		EVRApplicationError (__stdcall *GetStartingApplication)(  char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen );
+		EVRSceneApplicationState (__stdcall *GetSceneApplicationState)();
+		EVRApplicationError (__stdcall *PerformApplicationPrelaunchCheck)( const char *pchAppKey );
+		const char *(__stdcall *GetSceneApplicationStateNameFromEnum)( EVRSceneApplicationState state );
+		EVRApplicationError (__stdcall *LaunchInternalProcess)( const char *pchBinaryPath, const char *pchArguments, const char *pchWorkingDirectory );
+		uint32_t (__stdcall *GetCurrentSceneProcessId)();
+	};
+
+	class IVRApplications
+	{
+		VR_IVRApplications_FnTable _table;
+	public:
+
+		// ---------------  Application management  --------------- //
+
+		/** Adds an application manifest to the list to load when building the list of installed applications. 
+		* Temporary manifests are not automatically loaded */
+		EVRApplicationError AddApplicationManifest( const char *pchApplicationManifestFullPath, bool bTemporary = false ) { return _table.AddApplicationManifest(pchApplicationManifestFullPath, bTemporary); }
+
+		/** Removes an application manifest from the list to load when building the list of installed applications. */
+		EVRApplicationError RemoveApplicationManifest( const char *pchApplicationManifestFullPath ) { return _table.RemoveApplicationManifest(pchApplicationManifestFullPath); }
+
+		/** Returns true if an application is installed */
+		bool IsApplicationInstalled( const char *pchAppKey ) { return _table.IsApplicationInstalled(pchAppKey); }
+
+		/** Returns the number of applications available in the list */
+		uint32_t GetApplicationCount() { return _table.GetApplicationCount(); }
+
+		/** Returns the key of the specified application. The index is at least 0 and is less than the return 
+		* value of GetApplicationCount(). The buffer should be at least k_unMaxApplicationKeyLength in order to 
+		* fit the key. */
+		EVRApplicationError GetApplicationKeyByIndex( uint32_t unApplicationIndex, VR_OUT_STRING() char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) { return _table.GetApplicationKeyByIndex(unApplicationIndex, pchAppKeyBuffer, unAppKeyBufferLen); }
+
+		/** Returns the key of the application for the specified Process Id. The buffer should be at least 
+		* k_unMaxApplicationKeyLength in order to fit the key. */
+		EVRApplicationError GetApplicationKeyByProcessId( uint32_t unProcessId, VR_OUT_STRING() char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) { return _table.GetApplicationKeyByProcessId(unProcessId, pchAppKeyBuffer, unAppKeyBufferLen); }
+
+		/** Launches the application. The existing scene application will exit and then the new application will start.
+		* This call is not valid for dashboard overlay applications. */
+		EVRApplicationError LaunchApplication( const char *pchAppKey ) { return _table.LaunchApplication(pchAppKey); }
+
+		/** Launches an instance of an application of type template, with its app key being pchNewAppKey (which must be unique) and optionally override sections
+		* from the manifest file via AppOverrideKeys_t
+		*/
+		EVRApplicationError LaunchTemplateApplication( const char *pchTemplateAppKey, const char *pchNewAppKey, VR_ARRAY_COUNT( unKeys ) const AppOverrideKeys_t *pKeys, uint32_t unKeys ) { return _table.LaunchTemplateApplication(pchTemplateAppKey, pchNewAppKey, pKeys, unKeys); }
+
+		/** launches the application currently associated with this mime type and passes it the option args, typically the filename or object name of the item being launched */
+		vr::EVRApplicationError LaunchApplicationFromMimeType( const char *pchMimeType, const char *pchArgs ) { return _table.LaunchApplicationFromMimeType(pchMimeType, pchArgs); }
+
+		/** Launches the dashboard overlay application if it is not already running. This call is only valid for 
+		* dashboard overlay applications. */
+		EVRApplicationError LaunchDashboardOverlay( const char *pchAppKey ) { return _table.LaunchDashboardOverlay(pchAppKey); }
+
+		/** Cancel a pending launch for an application */
+		bool CancelApplicationLaunch( const char *pchAppKey ) { return _table.CancelApplicationLaunch(pchAppKey); }
+
+		/** Identifies a running application. OpenVR can't always tell which process started in response
+		* to a URL. This function allows a URL handler (or the process itself) to identify the app key 
+		* for the now running application. Passing a process ID of 0 identifies the calling process. 
+		* The application must be one that's known to the system via a call to AddApplicationManifest. */
+		EVRApplicationError IdentifyApplication( uint32_t unProcessId, const char *pchAppKey ) { return _table.IdentifyApplication(unProcessId, pchAppKey); }
+
+		/** Returns the process ID for an application. Return 0 if the application was not found or is not running. */
+		uint32_t GetApplicationProcessId( const char *pchAppKey ) { return _table.GetApplicationProcessId(pchAppKey); }
+
+		/** Returns a string for an applications error */
+		const char *GetApplicationsErrorNameFromEnum( EVRApplicationError error ) { return _table.GetApplicationsErrorNameFromEnum(error); }
+
+		// ---------------  Application properties  --------------- //
+
+		/** Returns a value for an application property. The required buffer size to fit this value will be returned. */
+		uint32_t GetApplicationPropertyString( const char *pchAppKey, EVRApplicationProperty eProperty, VR_OUT_STRING() char *pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError *peError = nullptr ) { return _table.GetApplicationPropertyString(pchAppKey, eProperty, pchPropertyValueBuffer, unPropertyValueBufferLen, peError); }
+
+		/** Returns a bool value for an application property. Returns false in all error cases. */
+		bool GetApplicationPropertyBool( const char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError = nullptr ) { return _table.GetApplicationPropertyBool(pchAppKey, eProperty, peError); }
+
+		/** Returns a uint64 value for an application property. Returns 0 in all error cases. */
+		uint64_t GetApplicationPropertyUint64( const char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError = nullptr ) { return _table.GetApplicationPropertyUint64(pchAppKey, eProperty, peError); }
+
+		/** Sets the application auto-launch flag. This is only valid for applications which return true for VRApplicationProperty_IsDashboardOverlay_Bool. */
+		EVRApplicationError SetApplicationAutoLaunch( const char *pchAppKey, bool bAutoLaunch ) { return _table.SetApplicationAutoLaunch(pchAppKey, bAutoLaunch); }
+
+		/** Gets the application auto-launch flag. This is only valid for applications which return true for VRApplicationProperty_IsDashboardOverlay_Bool. */
+		bool GetApplicationAutoLaunch( const char *pchAppKey ) { return _table.GetApplicationAutoLaunch(pchAppKey); }
+
+		/** Adds this mime-type to the list of supported mime types for this application*/
+		EVRApplicationError SetDefaultApplicationForMimeType( const char *pchAppKey, const char *pchMimeType ) { return _table.SetDefaultApplicationForMimeType(pchAppKey, pchMimeType); }
+
+		/** return the app key that will open this mime type */
+		bool GetDefaultApplicationForMimeType( const char *pchMimeType, VR_OUT_STRING() char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) { return _table.GetDefaultApplicationForMimeType(pchMimeType, pchAppKeyBuffer, unAppKeyBufferLen); }
+
+		/** Get the list of supported mime types for this application, comma-delimited */
+		bool GetApplicationSupportedMimeTypes( const char *pchAppKey, VR_OUT_STRING() char *pchMimeTypesBuffer, uint32_t unMimeTypesBuffer ) { return _table.GetApplicationSupportedMimeTypes(pchAppKey, pchMimeTypesBuffer, unMimeTypesBuffer); }
+
+		/** Get the list of app-keys that support this mime type, comma-delimited, the return value is number of bytes you need to return the full string */
+		uint32_t GetApplicationsThatSupportMimeType( const char *pchMimeType, VR_OUT_STRING() char *pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer ) { return _table.GetApplicationsThatSupportMimeType(pchMimeType, pchAppKeysThatSupportBuffer, unAppKeysThatSupportBuffer); }
+
+		/** Get the args list from an app launch that had the process already running, you call this when you get a VREvent_ApplicationMimeTypeLoad */
+		uint32_t GetApplicationLaunchArguments( uint32_t unHandle, VR_OUT_STRING() char *pchArgs, uint32_t unArgs ) { return _table.GetApplicationLaunchArguments(unHandle, pchArgs, unArgs); }
+
+		// ---------------  Transition methods --------------- //
+
+		/** Returns the app key for the application that is starting up */
+		EVRApplicationError GetStartingApplication( VR_OUT_STRING() char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) { return _table.GetStartingApplication(pchAppKeyBuffer, unAppKeyBufferLen); }
+
+		/** Returns the application transition state */
+		EVRSceneApplicationState GetSceneApplicationState() { return _table.GetSceneApplicationState(); }
+
+		/** Returns errors that would prevent the specified application from launching immediately. Calling this function will
+		* cause the current scene application to quit, so only call it when you are actually about to launch something else.
+		* What the caller should do about these failures depends on the failure:
+		*   VRApplicationError_OldApplicationQuitting - An existing application has been told to quit. Wait for a VREvent_ProcessQuit
+		*                                               and try again.
+		*   VRApplicationError_ApplicationAlreadyStarting - This application is already starting. This is a permanent failure.
+		*   VRApplicationError_LaunchInProgress	      - A different application is already starting. This is a permanent failure.
+		*   VRApplicationError_None                   - Go ahead and launch. Everything is clear.
+		*/
+		EVRApplicationError PerformApplicationPrelaunchCheck( const char *pchAppKey ) { return _table.PerformApplicationPrelaunchCheck(pchAppKey); }
+
+		/** Returns a string for an application transition state */
+		const char *GetSceneApplicationStateNameFromEnum( EVRSceneApplicationState state ) { return _table.GetSceneApplicationStateNameFromEnum(state); }
+
+		/** Starts a subprocess within the calling application. This
+		* suppresses all application transition UI and automatically identifies the new executable 
+		* as part of the same application. On success the calling process should exit immediately. 
+		* If working directory is NULL or "" the directory portion of the binary path will be 
+		* the working directory. */
+		EVRApplicationError LaunchInternalProcess( const char *pchBinaryPath, const char *pchArguments, const char *pchWorkingDirectory ) { return _table.LaunchInternalProcess(pchBinaryPath, pchArguments, pchWorkingDirectory); }
+
+		/** Returns the current scene process ID according to the application system. A scene process will get scene
+		* focus once it starts rendering, but it will appear here once it calls VR_Init with the Scene application
+		* type. */
+		uint32_t GetCurrentSceneProcessId() { return _table.GetCurrentSceneProcessId(); }
+	};
+
+	static const char * const IVRApplications_Version = "FnTable:IVRApplications_007";
+
+} // namespace vr
+
+// ivrsettings.h
+#include <string>
+
+namespace vr
+{
+	enum EVRSettingsError
+	{
+		VRSettingsError_None = 0,
+		VRSettingsError_IPCFailed = 1,
+		VRSettingsError_WriteFailed = 2,
+		VRSettingsError_ReadFailed = 3,
+		VRSettingsError_JsonParseFailed = 4,
+		VRSettingsError_UnsetSettingHasNoDefault = 5, // This will be returned if the setting does not appear in the appropriate default file and has not been set
+	};
+
+	// The maximum length of a settings key
+	static const uint32_t k_unMaxSettingsKeyLength = 128;
+
+	struct VR_IVRSettings_FnTable
+	{
+		const char *(__stdcall *GetSettingsErrorNameFromEnum)( EVRSettingsError eError );
+		void (__stdcall *SetBool)( const char *pchSection, const char *pchSettingsKey, bool bValue, EVRSettingsError *peError);
+		void (__stdcall *SetInt32)( const char *pchSection, const char *pchSettingsKey, int32_t nValue, EVRSettingsError *peError);
+		void (__stdcall *SetFloat)( const char *pchSection, const char *pchSettingsKey, float flValue, EVRSettingsError *peError);
+		void (__stdcall *SetString)( const char *pchSection, const char *pchSettingsKey, const char *pchValue, EVRSettingsError *peError);
+		bool (__stdcall *GetBool)( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError);
+		int32_t (__stdcall *GetInt32)( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError);
+		float (__stdcall *GetFloat)( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError);
+		void (__stdcall *GetString)( const char *pchSection, const char *pchSettingsKey,  char *pchValue, uint32_t unValueLen, EVRSettingsError *peError);
+		void (__stdcall *RemoveSection)( const char *pchSection, EVRSettingsError *peError);
+		void (__stdcall *RemoveKeyInSection)( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError);
+	};
+
+	class IVRSettings
+	{
+		VR_IVRSettings_FnTable _table;
+	public:
+		const char *GetSettingsErrorNameFromEnum( EVRSettingsError eError ) { return _table.GetSettingsErrorNameFromEnum(eError); }
+
+		void SetBool( const char *pchSection, const char *pchSettingsKey, bool bValue, EVRSettingsError *peError = nullptr ) { _table.SetBool(pchSection, pchSettingsKey, bValue, peError); }
+		void SetInt32( const char *pchSection, const char *pchSettingsKey, int32_t nValue, EVRSettingsError *peError = nullptr ) { _table.SetInt32(pchSection, pchSettingsKey, nValue, peError); }
+		void SetFloat( const char *pchSection, const char *pchSettingsKey, float flValue, EVRSettingsError *peError = nullptr ) { _table.SetFloat(pchSection, pchSettingsKey, flValue, peError); }
+		void SetString( const char *pchSection, const char *pchSettingsKey, const char *pchValue, EVRSettingsError *peError = nullptr ) { _table.SetString(pchSection, pchSettingsKey, pchValue, peError); }
+
+		// Users of the system need to provide a proper default in default.vrsettings in the resources/settings/ directory
+		// of either the runtime or the driver_xxx directory. Otherwise the default will be false, 0, 0.0 or ""
+		bool GetBool( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) { return _table.GetBool(pchSection, pchSettingsKey, peError); }
+		int32_t GetInt32( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) { return _table.GetInt32(pchSection, pchSettingsKey, peError); }
+		float GetFloat( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) { return _table.GetFloat(pchSection, pchSettingsKey, peError); }
+		void GetString( const char *pchSection, const char *pchSettingsKey, VR_OUT_STRING() char *pchValue, uint32_t unValueLen, EVRSettingsError *peError = nullptr ) { _table.GetString(pchSection, pchSettingsKey, pchValue, unValueLen, peError); }
+
+		void RemoveSection( const char *pchSection, EVRSettingsError *peError = nullptr ) { _table.RemoveSection(pchSection, peError); }
+		void RemoveKeyInSection( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) { _table.RemoveKeyInSection(pchSection, pchSettingsKey, peError); }
+	};
+
+	//-----------------------------------------------------------------------------
+	static const char * const IVRSettings_Version = "FnTable:IVRSettings_003";
+
+	class CVRSettingHelper
+	{
+		IVRSettings *m_pSettings;
+	public:
+		CVRSettingHelper( IVRSettings *pSettings ) 
+		{ 
+			m_pSettings = pSettings; 
+		}
+
+		const char *GetSettingsErrorNameFromEnum( EVRSettingsError eError ) 
+		{ 
+			return m_pSettings->GetSettingsErrorNameFromEnum( eError ); 
+		}
+
+		void SetBool( const char *pchSection, const char *pchSettingsKey, bool bValue, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->SetBool( pchSection, pchSettingsKey, bValue, peError );
+		}
+
+		void SetInt32( const char *pchSection, const char *pchSettingsKey, int32_t nValue, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->SetInt32( pchSection, pchSettingsKey, nValue, peError );
+		}
+		void SetFloat( const char *pchSection, const char *pchSettingsKey, float flValue, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->SetFloat( pchSection, pchSettingsKey, flValue, peError );
+		}
+		void SetString( const char *pchSection, const char *pchSettingsKey, const char *pchValue, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->SetString( pchSection, pchSettingsKey, pchValue, peError );
+		}
+		void SetString( const std::string & sSection, const std::string &  sSettingsKey, const std::string & sValue, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->SetString( sSection.c_str(), sSettingsKey.c_str(), sValue.c_str(), peError );
+		}
+
+		bool GetBool( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr )
+		{
+			return m_pSettings->GetBool( pchSection, pchSettingsKey, peError );
+		}
+		int32_t GetInt32( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr )
+		{
+			return m_pSettings->GetInt32( pchSection, pchSettingsKey, peError );
+		}
+		float GetFloat( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr )
+		{
+			return m_pSettings->GetFloat( pchSection, pchSettingsKey, peError );
+		}
+		void GetString( const char *pchSection, const char *pchSettingsKey, VR_OUT_STRING() char *pchValue, uint32_t unValueLen, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->GetString( pchSection, pchSettingsKey, pchValue, unValueLen, peError );
+		}
+		std::string GetString( const std::string & sSection, const std::string & sSettingsKey, EVRSettingsError *peError = nullptr )
+		{
+			char buf[4096];
+			vr::EVRSettingsError eError;
+			m_pSettings->GetString( sSection.c_str(), sSettingsKey.c_str(), buf, sizeof( buf ), &eError );
+			if ( peError )
+				*peError = eError;
+			if ( eError == vr::VRSettingsError_None )
+				return buf;
+			else
+				return "";
+		}
+
+		void RemoveSection( const char *pchSection, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->RemoveSection( pchSection, peError );
+		}
+		void RemoveKeyInSection( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->RemoveKeyInSection( pchSection, pchSettingsKey, peError );
+		}
+	};
+
+
+	//-----------------------------------------------------------------------------
+	// steamvr keys
+	static const char * const k_pch_SteamVR_Section = "steamvr";
+	static const char * const k_pch_SteamVR_RequireHmd_String = "requireHmd";
+	static const char * const k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver";
+	static const char * const k_pch_SteamVR_ForcedHmdKey_String = "forcedHmd";
+	static const char * const k_pch_SteamVR_DisplayDebug_Bool = "displayDebug";
+	static const char * const k_pch_SteamVR_DebugProcessPipe_String = "debugProcessPipe";
+	static const char * const k_pch_SteamVR_DisplayDebugX_Int32 = "displayDebugX";
+	static const char * const k_pch_SteamVR_DisplayDebugY_Int32 = "displayDebugY";
+	static const char * const k_pch_SteamVR_SendSystemButtonToAllApps_Bool= "sendSystemButtonToAllApps";
+	static const char * const k_pch_SteamVR_LogLevel_Int32 = "loglevel";
+	static const char * const k_pch_SteamVR_IPD_Float = "ipd";
+	static const char * const k_pch_SteamVR_Background_String = "background";
+	static const char * const k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection";
+	static const char * const k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight";
+	static const char * const k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius";
+	static const char * const k_pch_SteamVR_GridColor_String = "gridColor";
+	static const char * const k_pch_SteamVR_PlayAreaColor_String = "playAreaColor";
+	static const char * const k_pch_SteamVR_TrackingLossColor_String = "trackingLossColor";
+	static const char * const k_pch_SteamVR_ShowStage_Bool = "showStage";
+	static const char * const k_pch_SteamVR_ActivateMultipleDrivers_Bool = "activateMultipleDrivers";
+	static const char * const k_pch_SteamVR_UsingSpeakers_Bool = "usingSpeakers";
+	static const char * const k_pch_SteamVR_SpeakersForwardYawOffsetDegrees_Float = "speakersForwardYawOffsetDegrees";
+	static const char * const k_pch_SteamVR_BaseStationPowerManagement_Int32 = "basestationPowerManagement";
+	static const char * const k_pch_SteamVR_ShowBaseStationPowerManagementTip_Int32 = "ShowBaseStationPowerManagementTip";
+	static const char * const k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses";
+	static const char * const k_pch_SteamVR_SupersampleScale_Float = "supersampleScale";
+	static const char * const k_pch_SteamVR_MaxRecommendedResolution_Int32 = "maxRecommendedResolution";
+	static const char * const k_pch_SteamVR_MotionSmoothing_Bool = "motionSmoothing";
+	static const char * const k_pch_SteamVR_MotionSmoothingOverride_Int32 = "motionSmoothingOverride";
+	static const char * const k_pch_SteamVR_DisableAsyncReprojection_Bool = "disableAsync";
+	static const char * const k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking";
+	static const char * const k_pch_SteamVR_DefaultMirrorView_Int32 = "mirrorView";
+	static const char * const k_pch_SteamVR_ShowLegacyMirrorView_Bool = "showLegacyMirrorView";
+	static const char * const k_pch_SteamVR_MirrorViewVisibility_Bool = "showMirrorView";
+	static const char * const k_pch_SteamVR_MirrorViewDisplayMode_Int32 = "mirrorViewDisplayMode";
+	static const char * const k_pch_SteamVR_MirrorViewEye_Int32 = "mirrorViewEye";
+	static const char * const k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry";
+	static const char * const k_pch_SteamVR_MirrorViewGeometryMaximized_String = "mirrorViewGeometryMaximized";
+	static const char * const k_pch_SteamVR_PerfGraphVisibility_Bool = "showPerfGraph";
+	static const char * const k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch";
+	static const char * const k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch";
+	static const char * const k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch";
+	static const char * const k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard";
+	static const char * const k_pch_SteamVR_EnableHomeApp = "enableHomeApp";
+	static const char * const k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec";
+	static const char * const k_pch_SteamVR_RetailDemo_Bool = "retailDemo";
+	static const char * const k_pch_SteamVR_IpdOffset_Float = "ipdOffset";
+	static const char * const k_pch_SteamVR_AllowSupersampleFiltering_Bool = "allowSupersampleFiltering";
+	static const char * const k_pch_SteamVR_SupersampleManualOverride_Bool = "supersampleManualOverride";
+	static const char * const k_pch_SteamVR_EnableLinuxVulkanAsync_Bool = "enableLinuxVulkanAsync";
+	static const char * const k_pch_SteamVR_AllowDisplayLockedMode_Bool = "allowDisplayLockedMode";
+	static const char * const k_pch_SteamVR_HaveStartedTutorialForNativeChaperoneDriver_Bool = "haveStartedTutorialForNativeChaperoneDriver";
+	static const char * const k_pch_SteamVR_ForceWindows32bitVRMonitor = "forceWindows32BitVRMonitor";
+	static const char * const k_pch_SteamVR_DebugInputBinding = "debugInputBinding";
+	static const char * const k_pch_SteamVR_DoNotFadeToGrid = "doNotFadeToGrid";
+	static const char * const k_pch_SteamVR_RenderCameraMode = "renderCameraMode";
+	static const char * const k_pch_SteamVR_EnableSharedResourceJournaling = "enableSharedResourceJournaling";
+	static const char * const k_pch_SteamVR_EnableSafeMode = "enableSafeMode";
+	static const char * const k_pch_SteamVR_PreferredRefreshRate = "preferredRefreshRate";
+	static const char * const k_pch_SteamVR_LastVersionNotice = "lastVersionNotice";
+	static const char * const k_pch_SteamVR_LastVersionNoticeDate = "lastVersionNoticeDate";
+	static const char * const k_pch_SteamVR_HmdDisplayColorGainR_Float = "hmdDisplayColorGainR";
+	static const char * const k_pch_SteamVR_HmdDisplayColorGainG_Float = "hmdDisplayColorGainG";
+	static const char * const k_pch_SteamVR_HmdDisplayColorGainB_Float = "hmdDisplayColorGainB";
+	static const char * const k_pch_SteamVR_CustomIconStyle_String = "customIconStyle";
+	static const char * const k_pch_SteamVR_CustomOffIconStyle_String = "customOffIconStyle";
+	static const char * const k_pch_SteamVR_CustomIconForceUpdate_String = "customIconForceUpdate";
+	static const char * const k_pch_SteamVR_AllowGlobalActionSetPriority = "globalActionSetPriority";
+	static const char * const k_pch_SteamVR_OverlayRenderQuality = "overlayRenderQuality_2";
+
+	//-----------------------------------------------------------------------------
+	// direct mode keys
+	static const char * const k_pch_DirectMode_Section = "direct_mode";
+	static const char * const k_pch_DirectMode_Enable_Bool = "enable";
+	static const char * const k_pch_DirectMode_Count_Int32 = "count";
+	static const char * const k_pch_DirectMode_EdidVid_Int32 = "edidVid";
+	static const char * const k_pch_DirectMode_EdidPid_Int32 = "edidPid";
+
+	//-----------------------------------------------------------------------------
+	// lighthouse keys
+	static const char * const k_pch_Lighthouse_Section = "driver_lighthouse";
+	static const char * const k_pch_Lighthouse_DisableIMU_Bool = "disableimu";
+	static const char * const k_pch_Lighthouse_DisableIMUExceptHMD_Bool = "disableimuexcepthmd";
+	static const char * const k_pch_Lighthouse_UseDisambiguation_String = "usedisambiguation";
+	static const char * const k_pch_Lighthouse_DisambiguationDebug_Int32 = "disambiguationdebug";
+	static const char * const k_pch_Lighthouse_PrimaryBasestation_Int32 = "primarybasestation";
+	static const char * const k_pch_Lighthouse_DBHistory_Bool = "dbhistory";
+	static const char * const k_pch_Lighthouse_EnableBluetooth_Bool = "enableBluetooth";
+	static const char * const k_pch_Lighthouse_PowerManagedBaseStations_String = "PowerManagedBaseStations";
+	static const char * const k_pch_Lighthouse_PowerManagedBaseStations2_String = "PowerManagedBaseStations2";
+	static const char * const k_pch_Lighthouse_InactivityTimeoutForBaseStations_Int32 = "InactivityTimeoutForBaseStations";
+	static const char * const k_pch_Lighthouse_EnableImuFallback_Bool = "enableImuFallback";
+
+	//-----------------------------------------------------------------------------
+	// null keys
+	static const char * const k_pch_Null_Section = "driver_null";
+	static const char * const k_pch_Null_SerialNumber_String = "serialNumber";
+	static const char * const k_pch_Null_ModelNumber_String = "modelNumber";
+	static const char * const k_pch_Null_WindowX_Int32 = "windowX";
+	static const char * const k_pch_Null_WindowY_Int32 = "windowY";
+	static const char * const k_pch_Null_WindowWidth_Int32 = "windowWidth";
+	static const char * const k_pch_Null_WindowHeight_Int32 = "windowHeight";
+	static const char * const k_pch_Null_RenderWidth_Int32 = "renderWidth";
+	static const char * const k_pch_Null_RenderHeight_Int32 = "renderHeight";
+	static const char * const k_pch_Null_SecondsFromVsyncToPhotons_Float = "secondsFromVsyncToPhotons";
+	static const char * const k_pch_Null_DisplayFrequency_Float = "displayFrequency";
+
+	//-----------------------------------------------------------------------------
+	// Windows MR keys
+	static const char * const k_pch_WindowsMR_Section = "driver_holographic";
+
+	//-----------------------------------------------------------------------------
+	// user interface keys
+	static const char * const k_pch_UserInterface_Section = "userinterface";
+	static const char * const k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop";
+	static const char * const k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray";
+	static const char * const k_pch_UserInterface_HidePopupsWhenStatusMinimized_Bool = "HidePopupsWhenStatusMinimized";
+	static const char * const k_pch_UserInterface_Screenshots_Bool = "screenshots";
+	static const char * const k_pch_UserInterface_ScreenshotType_Int = "screenshotType";
+
+	//-----------------------------------------------------------------------------
+	// notification keys
+	static const char * const k_pch_Notifications_Section = "notifications";
+	static const char * const k_pch_Notifications_DoNotDisturb_Bool = "DoNotDisturb";
+
+	//-----------------------------------------------------------------------------
+	// keyboard keys
+	static const char * const k_pch_Keyboard_Section = "keyboard";
+	static const char * const k_pch_Keyboard_TutorialCompletions = "TutorialCompletions";
+	static const char * const k_pch_Keyboard_ScaleX = "ScaleX";
+	static const char * const k_pch_Keyboard_ScaleY = "ScaleY";
+	static const char * const k_pch_Keyboard_OffsetLeftX = "OffsetLeftX";
+	static const char * const k_pch_Keyboard_OffsetRightX = "OffsetRightX";
+	static const char * const k_pch_Keyboard_OffsetY = "OffsetY";
+	static const char * const k_pch_Keyboard_Smoothing = "Smoothing";
+
+	//-----------------------------------------------------------------------------
+	// perf keys
+	static const char * const k_pch_Perf_Section = "perfcheck";
+	static const char * const k_pch_Perf_PerfGraphInHMD_Bool = "perfGraphInHMD";
+	static const char * const k_pch_Perf_AllowTimingStore_Bool = "allowTimingStore";
+	static const char * const k_pch_Perf_SaveTimingsOnExit_Bool = "saveTimingsOnExit";
+	static const char * const k_pch_Perf_TestData_Float = "perfTestData";
+	static const char * const k_pch_Perf_GPUProfiling_Bool = "GPUProfiling";
+
+	//-----------------------------------------------------------------------------
+	// collision bounds keys
+	static const char * const k_pch_CollisionBounds_Section = "collisionBounds";
+	static const char * const k_pch_CollisionBounds_Style_Int32 = "CollisionBoundsStyle";
+	static const char * const k_pch_CollisionBounds_GroundPerimeterOn_Bool = "CollisionBoundsGroundPerimeterOn";
+	static const char * const k_pch_CollisionBounds_CenterMarkerOn_Bool = "CollisionBoundsCenterMarkerOn";
+	static const char * const k_pch_CollisionBounds_PlaySpaceOn_Bool = "CollisionBoundsPlaySpaceOn";
+	static const char * const k_pch_CollisionBounds_FadeDistance_Float = "CollisionBoundsFadeDistance";
+	static const char * const k_pch_CollisionBounds_WallHeight_Float = "CollisionBoundsWallHeight";
+	static const char * const k_pch_CollisionBounds_ColorGammaR_Int32 = "CollisionBoundsColorGammaR";
+	static const char * const k_pch_CollisionBounds_ColorGammaG_Int32 = "CollisionBoundsColorGammaG";
+	static const char * const k_pch_CollisionBounds_ColorGammaB_Int32 = "CollisionBoundsColorGammaB";
+	static const char * const k_pch_CollisionBounds_ColorGammaA_Int32 = "CollisionBoundsColorGammaA";
+	static const char * const k_pch_CollisionBounds_EnableDriverImport = "enableDriverBoundsImport";
+
+	//-----------------------------------------------------------------------------
+	// camera keys
+	static const char * const k_pch_Camera_Section = "camera";
+	static const char * const k_pch_Camera_EnableCamera_Bool = "enableCamera";
+	static const char * const k_pch_Camera_EnableCameraInDashboard_Bool = "enableCameraInDashboard";
+	static const char * const k_pch_Camera_EnableCameraForCollisionBounds_Bool = "enableCameraForCollisionBounds";
+	static const char * const k_pch_Camera_EnableCameraForRoomView_Bool = "enableCameraForRoomView";
+	static const char * const k_pch_Camera_BoundsColorGammaR_Int32 = "cameraBoundsColorGammaR";
+	static const char * const k_pch_Camera_BoundsColorGammaG_Int32 = "cameraBoundsColorGammaG";
+	static const char * const k_pch_Camera_BoundsColorGammaB_Int32 = "cameraBoundsColorGammaB";
+	static const char * const k_pch_Camera_BoundsColorGammaA_Int32 = "cameraBoundsColorGammaA";
+	static const char * const k_pch_Camera_BoundsStrength_Int32 = "cameraBoundsStrength";
+	static const char * const k_pch_Camera_RoomViewMode_Int32 = "cameraRoomViewMode";
+
+	//-----------------------------------------------------------------------------
+	// audio keys
+	static const char * const k_pch_audio_Section = "audio";
+	static const char * const k_pch_audio_SetOsDefaultPlaybackDevice_Bool = "setOsDefaultPlaybackDevice";
+	static const char * const k_pch_audio_EnablePlaybackDeviceOverride_Bool = "enablePlaybackDeviceOverride";
+	static const char * const k_pch_audio_PlaybackDeviceOverride_String = "playbackDeviceOverride";
+	static const char * const k_pch_audio_PlaybackDeviceOverrideName_String = "playbackDeviceOverrideName";
+	static const char * const k_pch_audio_SetOsDefaultRecordingDevice_Bool = "setOsDefaultRecordingDevice";
+	static const char * const k_pch_audio_EnableRecordingDeviceOverride_Bool = "enableRecordingDeviceOverride";
+	static const char * const k_pch_audio_RecordingDeviceOverride_String = "recordingDeviceOverride";
+	static const char * const k_pch_audio_RecordingDeviceOverrideName_String = "recordingDeviceOverrideName";
+	static const char * const k_pch_audio_EnablePlaybackMirror_Bool = "enablePlaybackMirror";
+	static const char * const k_pch_audio_PlaybackMirrorDevice_String = "playbackMirrorDevice";
+	static const char * const k_pch_audio_PlaybackMirrorDeviceName_String = "playbackMirrorDeviceName";
+	static const char * const k_pch_audio_OldPlaybackMirrorDevice_String = "onPlaybackMirrorDevice";
+	static const char * const k_pch_audio_ActiveMirrorDevice_String = "activePlaybackMirrorDevice";
+	static const char * const k_pch_audio_EnablePlaybackMirrorIndependentVolume_Bool = "enablePlaybackMirrorIndependentVolume";
+	static const char * const k_pch_audio_LastHmdPlaybackDeviceId_String = "lastHmdPlaybackDeviceId";
+	static const char * const k_pch_audio_VIVEHDMIGain = "viveHDMIGain";
+
+	//-----------------------------------------------------------------------------
+	// power management keys
+	static const char * const k_pch_Power_Section = "power";
+	static const char * const k_pch_Power_PowerOffOnExit_Bool = "powerOffOnExit";
+	static const char * const k_pch_Power_TurnOffScreensTimeout_Float = "turnOffScreensTimeout";
+	static const char * const k_pch_Power_TurnOffControllersTimeout_Float = "turnOffControllersTimeout";
+	static const char * const k_pch_Power_ReturnToWatchdogTimeout_Float = "returnToWatchdogTimeout";
+	static const char * const k_pch_Power_AutoLaunchSteamVROnButtonPress = "autoLaunchSteamVROnButtonPress";
+	static const char * const k_pch_Power_PauseCompositorOnStandby_Bool = "pauseCompositorOnStandby";
+
+	//-----------------------------------------------------------------------------
+	// dashboard keys
+	static const char * const k_pch_Dashboard_Section = "dashboard";
+	static const char * const k_pch_Dashboard_EnableDashboard_Bool = "enableDashboard";
+	static const char * const k_pch_Dashboard_ArcadeMode_Bool = "arcadeMode";
+	static const char * const k_pch_Dashboard_Position = "position";
+	static const char * const k_pch_Dashboard_DesktopScale = "desktopScale";
+	static const char * const k_pch_Dashboard_DashboardScale = "dashboardScale";
+
+	//-----------------------------------------------------------------------------
+	// model skin keys
+	static const char * const k_pch_modelskin_Section = "modelskins";
+
+	//-----------------------------------------------------------------------------
+	// driver keys - These could be checked in any driver_<name> section
+	static const char * const k_pch_Driver_Enable_Bool = "enable";
+	static const char * const k_pch_Driver_BlockedBySafemode_Bool = "blocked_by_safe_mode";
+	static const char * const k_pch_Driver_LoadPriority_Int32 = "loadPriority";
+
+	//-----------------------------------------------------------------------------
+	// web interface keys
+	static const char* const k_pch_WebInterface_Section = "WebInterface";
+
+	//-----------------------------------------------------------------------------
+	// vrwebhelper keys
+	static const char* const k_pch_VRWebHelper_Section = "VRWebHelper";
+	static const char* const k_pch_VRWebHelper_DebuggerEnabled_Bool = "DebuggerEnabled";
+	static const char* const k_pch_VRWebHelper_DebuggerPort_Int32 = "DebuggerPort";
+
+	//-----------------------------------------------------------------------------
+	// tracking overrides - keys are device paths, values are the device paths their
+	//  tracking/pose information overrides
+	static const char* const k_pch_TrackingOverride_Section = "TrackingOverrides";
+
+	//-----------------------------------------------------------------------------
+	// per-app keys - the section name for these is the app key itself. Some of these are prefixed by the controller type
+	static const char* const k_pch_App_BindingAutosaveURLSuffix_String = "AutosaveURL";
+	static const char* const k_pch_App_BindingLegacyAPISuffix_String = "_legacy";
+	static const char* const k_pch_App_BindingSteamVRInputAPISuffix_String = "_steamvrinput";
+	static const char* const k_pch_App_BindingCurrentURLSuffix_String = "CurrentURL";
+	static const char* const k_pch_App_BindingPreviousURLSuffix_String = "PreviousURL";
+	static const char* const k_pch_App_NeedToUpdateAutosaveSuffix_Bool = "NeedToUpdateAutosave";
+	static const char* const k_pch_App_DominantHand_Int32 = "DominantHand";
+
+	//-----------------------------------------------------------------------------
+	// configuration for trackers
+	static const char * const k_pch_Trackers_Section = "trackers";
+
+	//-----------------------------------------------------------------------------
+	// configuration for desktop UI windows
+	static const char * const k_pch_DesktopUI_Section = "DesktopUI";
+
+	//-----------------------------------------------------------------------------
+	// Last known keys for righting recovery
+	static const char * const k_pch_LastKnown_Section = "LastKnown";
+	static const char* const k_pch_LastKnown_HMDManufacturer_String = "HMDManufacturer";
+	static const char* const k_pch_LastKnown_HMDModel_String = "HMDModel";
+
+	//-----------------------------------------------------------------------------
+	// Dismissed warnings
+	static const char * const k_pch_DismissedWarnings_Section = "DismissedWarnings";
+
+	//-----------------------------------------------------------------------------
+	// Input Settings
+	static const char * const k_pch_Input_Section = "input";
+	static const char* const k_pch_Input_LeftThumbstickRotation_Float = "leftThumbstickRotation";
+	static const char* const k_pch_Input_RightThumbstickRotation_Float = "rightThumbstickRotation";
+	static const char* const k_pch_Input_ThumbstickDeadzone_Float = "thumbstickDeadzone";
+
+	//-----------------------------------------------------------------------------
+	// Log of GPU performance
+	static const char * const k_pch_GpuSpeed_Section = "GpuSpeed";
+
+} // namespace vr
+
+// ivrchaperone.h
+namespace vr
+{
+
+#pragma pack( push, 8 )
+
+enum ChaperoneCalibrationState
+{
+	// OK!
+	ChaperoneCalibrationState_OK = 1,									// Chaperone is fully calibrated and working correctly
+
+	// Warnings
+	ChaperoneCalibrationState_Warning = 100,
+	ChaperoneCalibrationState_Warning_BaseStationMayHaveMoved = 101,	// A base station thinks that it might have moved
+	ChaperoneCalibrationState_Warning_BaseStationRemoved = 102,			// There are less base stations than when calibrated
+	ChaperoneCalibrationState_Warning_SeatedBoundsInvalid = 103,		// Seated bounds haven't been calibrated for the current tracking center
+
+	// Errors
+	ChaperoneCalibrationState_Error = 200,								// The UniverseID is invalid
+	ChaperoneCalibrationState_Error_BaseStationUninitialized = 201,		// Tracking center hasn't be calibrated for at least one of the base stations
+	ChaperoneCalibrationState_Error_BaseStationConflict = 202,			// Tracking center is calibrated, but base stations disagree on the tracking space
+	ChaperoneCalibrationState_Error_PlayAreaInvalid = 203,				// Play Area hasn't been calibrated for the current tracking center
+	ChaperoneCalibrationState_Error_CollisionBoundsInvalid = 204,		// Collision Bounds haven't been calibrated for the current tracking center
+};
+
+
+/** HIGH LEVEL TRACKING SPACE ASSUMPTIONS:
+* 0,0,0 is the preferred standing area center.
+* 0Y is the floor height.
+* -Z is the preferred forward facing direction. */
+struct VR_IVRChaperone_FnTable
+{
+	ChaperoneCalibrationState (__stdcall *GetCalibrationState)();
+	bool (__stdcall *GetPlayAreaSize)( float *pSizeX, float *pSizeZ );
+	bool (__stdcall *GetPlayAreaRect)( HmdQuad_t *rect );
+	void (__stdcall *ReloadInfo)( void );
+	void (__stdcall *SetSceneColor)( HmdColor_t color );
+	void (__stdcall *GetBoundsColor)( HmdColor_t *pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, HmdColor_t *pOutputCameraColor );
+	bool (__stdcall *AreBoundsVisible)();
+	void (__stdcall *ForceBoundsVisible)( bool bForce );
+};
+
+class IVRChaperone
+{
+	VR_IVRChaperone_FnTable _table;
+public:
+
+	/** Get the current state of Chaperone calibration. This state can change at any time during a session due to physical base station changes. **/
+	ChaperoneCalibrationState GetCalibrationState() { return _table.GetCalibrationState(); }
+
+	/** Returns the width and depth of the Play Area (formerly named Soft Bounds) in X and Z. 
+	* Tracking space center (0,0,0) is the center of the Play Area. **/
+	bool GetPlayAreaSize( float *pSizeX, float *pSizeZ ) { return _table.GetPlayAreaSize(pSizeX, pSizeZ); }
+
+	/** Returns the 4 corner positions of the Play Area (formerly named Soft Bounds).
+	* Corners are in counter-clockwise order.
+	* Standing center (0,0,0) is the center of the Play Area.
+	* It's a rectangle.
+	* 2 sides are parallel to the X axis and 2 sides are parallel to the Z axis.
+	* Height of every corner is 0Y (on the floor). **/
+	bool GetPlayAreaRect( HmdQuad_t *rect ) { return _table.GetPlayAreaRect(rect); }
+
+	/** Reload Chaperone data from the .vrchap file on disk. */
+	void ReloadInfo( void ) { _table.ReloadInfo(); }
+
+	/** Optionally give the chaperone system a hit about the color and brightness in the scene **/
+	void SetSceneColor( HmdColor_t color ) { _table.SetSceneColor(color); }
+
+	/** Get the current chaperone bounds draw color and brightness **/
+	void GetBoundsColor( HmdColor_t *pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, HmdColor_t *pOutputCameraColor ) { _table.GetBoundsColor(pOutputColorArray, nNumOutputColors, flCollisionBoundsFadeDistance, pOutputCameraColor); }
+
+	/** Determine whether the bounds are showing right now **/
+	bool AreBoundsVisible() { return _table.AreBoundsVisible(); }
+
+	/** Force the bounds to show, mostly for utilities **/
+	void ForceBoundsVisible( bool bForce ) { _table.ForceBoundsVisible(bForce); }
+};
+
+static const char * const IVRChaperone_Version = "FnTable:IVRChaperone_003";
+
+#pragma pack( pop )
+
+}
+
+// ivrchaperonesetup.h
+namespace vr
+{
+
+enum EChaperoneConfigFile
+{
+	EChaperoneConfigFile_Live = 1,		// The live chaperone config, used by most applications and games
+	EChaperoneConfigFile_Temp = 2,		// The temporary chaperone config, used to live-preview collision bounds in room setup
+};
+
+enum EChaperoneImportFlags
+{
+	EChaperoneImport_BoundsOnly = 0x0001,
+};
+
+/** Manages the working copy of the chaperone info. By default this will be the same as the 
+* live copy. Any changes made with this interface will stay in the working copy until 
+* CommitWorkingCopy() is called, at which point the working copy and the live copy will be 
+* the same again. */
+struct VR_IVRChaperoneSetup_FnTable
+{
+	bool (__stdcall *CommitWorkingCopy)( EChaperoneConfigFile configFile );
+	void (__stdcall *RevertWorkingCopy)();
+	bool (__stdcall *GetWorkingPlayAreaSize)( float *pSizeX, float *pSizeZ );
+	bool (__stdcall *GetWorkingPlayAreaRect)( HmdQuad_t *rect );
+	bool (__stdcall *GetWorkingCollisionBoundsInfo)(  HmdQuad_t *pQuadsBuffer, uint32_t* punQuadsCount );
+	bool (__stdcall *GetLiveCollisionBoundsInfo)(  HmdQuad_t *pQuadsBuffer, uint32_t* punQuadsCount );
+	bool (__stdcall *GetWorkingSeatedZeroPoseToRawTrackingPose)( HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose );
+	bool (__stdcall *GetWorkingStandingZeroPoseToRawTrackingPose)( HmdMatrix34_t *pmatStandingZeroPoseToRawTrackingPose );
+	void (__stdcall *SetWorkingPlayAreaSize)( float sizeX, float sizeZ );
+	void (__stdcall *SetWorkingCollisionBoundsInfo)(  HmdQuad_t *pQuadsBuffer, uint32_t unQuadsCount );
+	void (__stdcall *SetWorkingPerimeter)(  HmdVector2_t *pPointBuffer, uint32_t unPointCount );
+	void (__stdcall *SetWorkingSeatedZeroPoseToRawTrackingPose)( const HmdMatrix34_t *pMatSeatedZeroPoseToRawTrackingPose );
+	void (__stdcall *SetWorkingStandingZeroPoseToRawTrackingPose)( const HmdMatrix34_t *pMatStandingZeroPoseToRawTrackingPose );
+	void (__stdcall *ReloadFromDisk)( EChaperoneConfigFile configFile );
+	bool (__stdcall *GetLiveSeatedZeroPoseToRawTrackingPose)( HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose );
+	bool (__stdcall *ExportLiveToBuffer)(  char *pBuffer, uint32_t *pnBufferLength );
+	bool (__stdcall *ImportFromBufferToWorking)( const char *pBuffer, uint32_t nImportFlags );
+	void (__stdcall *ShowWorkingSetPreview)();
+	void (__stdcall *HideWorkingSetPreview)();
+	void (__stdcall *RoomSetupStarting)();
+};
+
+class IVRChaperoneSetup
+{
+	VR_IVRChaperoneSetup_FnTable _table;
+public:
+
+	/** Saves the current working copy to disk */
+	bool CommitWorkingCopy( EChaperoneConfigFile configFile ) { return _table.CommitWorkingCopy(configFile); }
+
+	/** Reverts the working copy to match the live chaperone calibration.
+	* To modify existing data this MUST be do WHILE getting a non-error ChaperoneCalibrationStatus.
+	* Only after this should you do gets and sets on the existing data. */
+	void RevertWorkingCopy() { _table.RevertWorkingCopy(); }
+
+	/** Returns the width and depth of the Play Area (formerly named Soft Bounds) in X and Z from the working copy.
+	* Tracking space center (0,0,0) is the center of the Play Area. */
+	bool GetWorkingPlayAreaSize( float *pSizeX, float *pSizeZ ) { return _table.GetWorkingPlayAreaSize(pSizeX, pSizeZ); }
+
+	/** Returns the 4 corner positions of the Play Area (formerly named Soft Bounds) from the working copy.
+	* Corners are in clockwise order.
+	* Tracking space center (0,0,0) is the center of the Play Area.
+	* It's a rectangle.
+	* 2 sides are parallel to the X axis and 2 sides are parallel to the Z axis.
+	* Height of every corner is 0Y (on the floor). **/
+	bool GetWorkingPlayAreaRect( HmdQuad_t *rect ) { return _table.GetWorkingPlayAreaRect(rect); }
+
+	/** Returns the number of Quads if the buffer points to null. Otherwise it returns Quads 
+	* into the buffer up to the max specified from the working copy. */
+	bool GetWorkingCollisionBoundsInfo( VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t* punQuadsCount ) { return _table.GetWorkingCollisionBoundsInfo(pQuadsBuffer, punQuadsCount); }
+
+	/** Returns the number of Quads if the buffer points to null. Otherwise it returns Quads 
+	* into the buffer up to the max specified. */
+	bool GetLiveCollisionBoundsInfo( VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t* punQuadsCount ) { return _table.GetLiveCollisionBoundsInfo(pQuadsBuffer, punQuadsCount); }
+
+	/** Returns the preferred seated position from the working copy. */
+	bool GetWorkingSeatedZeroPoseToRawTrackingPose( HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose ) { return _table.GetWorkingSeatedZeroPoseToRawTrackingPose(pmatSeatedZeroPoseToRawTrackingPose); }
+
+	/** Returns the standing origin from the working copy. */
+	bool GetWorkingStandingZeroPoseToRawTrackingPose( HmdMatrix34_t *pmatStandingZeroPoseToRawTrackingPose ) { return _table.GetWorkingStandingZeroPoseToRawTrackingPose(pmatStandingZeroPoseToRawTrackingPose); }
+
+	/** Sets the Play Area in the working copy. */
+	void SetWorkingPlayAreaSize( float sizeX, float sizeZ ) { _table.SetWorkingPlayAreaSize(sizeX, sizeZ); }
+
+	/** Sets the Collision Bounds in the working copy. Note: ceiling height is ignored. */
+	void SetWorkingCollisionBoundsInfo( VR_ARRAY_COUNT(unQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t unQuadsCount ) { _table.SetWorkingCollisionBoundsInfo(pQuadsBuffer, unQuadsCount); }
+
+	/** Sets the Collision Bounds in the working copy. */
+	void SetWorkingPerimeter( VR_ARRAY_COUNT( unPointCount ) HmdVector2_t *pPointBuffer, uint32_t unPointCount ) { _table.SetWorkingPerimeter(pPointBuffer, unPointCount); }
+
+	/** Sets the preferred seated position in the working copy. */
+	void SetWorkingSeatedZeroPoseToRawTrackingPose( const HmdMatrix34_t *pMatSeatedZeroPoseToRawTrackingPose ) { _table.SetWorkingSeatedZeroPoseToRawTrackingPose(pMatSeatedZeroPoseToRawTrackingPose); }
+
+	/** Sets the preferred standing position in the working copy. */
+	void SetWorkingStandingZeroPoseToRawTrackingPose( const HmdMatrix34_t *pMatStandingZeroPoseToRawTrackingPose ) { _table.SetWorkingStandingZeroPoseToRawTrackingPose(pMatStandingZeroPoseToRawTrackingPose); }
+
+	/** Tear everything down and reload it from the file on disk */
+	void ReloadFromDisk( EChaperoneConfigFile configFile ) { _table.ReloadFromDisk(configFile); }
+
+	/** Returns the preferred seated position. */
+	bool GetLiveSeatedZeroPoseToRawTrackingPose( HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose ) { return _table.GetLiveSeatedZeroPoseToRawTrackingPose(pmatSeatedZeroPoseToRawTrackingPose); }
+
+	bool ExportLiveToBuffer( VR_OUT_STRING() char *pBuffer, uint32_t *pnBufferLength ) { return _table.ExportLiveToBuffer(pBuffer, pnBufferLength); }
+	bool ImportFromBufferToWorking( const char *pBuffer, uint32_t nImportFlags ) { return _table.ImportFromBufferToWorking(pBuffer, nImportFlags); }
+
+	/** Shows the chaperone data in the working set to preview in the compositor.*/
+	void ShowWorkingSetPreview() { _table.ShowWorkingSetPreview(); }
+
+	/** Hides the chaperone data in the working set to preview in the compositor (if it was visible).*/
+	void HideWorkingSetPreview() { _table.HideWorkingSetPreview(); }
+
+	/** Fire an event that the tracking system can use to know room setup is about to begin. This lets the tracking
+	 * system make any last minute adjustments that should be incorporated into the new setup.  If the user is adjusting
+	 * live in HMD using a tweak tool, keep in mind that calling this might cause the user to see the room jump. */
+	void RoomSetupStarting() { _table.RoomSetupStarting(); }
+};
+
+static const char * const IVRChaperoneSetup_Version = "FnTable:IVRChaperoneSetup_006";
+
+
+}
+
+// ivrcompositor.h
+namespace vr
+{
+
+#pragma pack( push, 8 )
+
+/** Errors that can occur with the VR compositor */
+enum EVRCompositorError
+{
+	VRCompositorError_None						= 0,
+	VRCompositorError_RequestFailed				= 1,
+	VRCompositorError_IncompatibleVersion		= 100,
+	VRCompositorError_DoNotHaveFocus			= 101,
+	VRCompositorError_InvalidTexture			= 102,
+	VRCompositorError_IsNotSceneApplication		= 103,
+	VRCompositorError_TextureIsOnWrongDevice	= 104,
+	VRCompositorError_TextureUsesUnsupportedFormat = 105,
+	VRCompositorError_SharedTexturesNotSupported = 106,
+	VRCompositorError_IndexOutOfRange			= 107,
+	VRCompositorError_AlreadySubmitted			= 108,
+	VRCompositorError_InvalidBounds				= 109,
+	VRCompositorError_AlreadySet				= 110,
+};
+
+/** Timing mode passed to SetExplicitTimingMode(); see that function for documentation */
+enum EVRCompositorTimingMode
+{
+	VRCompositorTimingMode_Implicit											= 0,
+	VRCompositorTimingMode_Explicit_RuntimePerformsPostPresentHandoff		= 1,
+	VRCompositorTimingMode_Explicit_ApplicationPerformsPostPresentHandoff	= 2,
+};
+
+/** Cumulative stats for current application.  These are not cleared until a new app connects,
+* but they do stop accumulating once the associated app disconnects. */
+struct Compositor_CumulativeStats
+{
+	uint32_t m_nPid; // Process id associated with these stats (may no longer be running).
+	uint32_t m_nNumFramePresents; // total number of times we called present (includes reprojected frames)
+	uint32_t m_nNumDroppedFrames; // total number of times an old frame was re-scanned out (without reprojection)
+	uint32_t m_nNumReprojectedFrames; // total number of times a frame was scanned out a second time (with reprojection)
+
+	/** Values recorded at startup before application has fully faded in the first time. */
+	uint32_t m_nNumFramePresentsOnStartup;
+	uint32_t m_nNumDroppedFramesOnStartup;
+	uint32_t m_nNumReprojectedFramesOnStartup;
+
+	/** Applications may explicitly fade to the compositor.  This is usually to handle level transitions, and loading often causes
+	* system wide hitches.  The following stats are collected during this period.  Does not include values recorded during startup. */
+	uint32_t m_nNumLoading;
+	uint32_t m_nNumFramePresentsLoading;
+	uint32_t m_nNumDroppedFramesLoading;
+	uint32_t m_nNumReprojectedFramesLoading;
+
+	/** If we don't get a new frame from the app in less than 2.5 frames, then we assume the app has hung and start
+	* fading back to the compositor.  The following stats are a result of this, and are a subset of those recorded above.
+	* Does not include values recorded during start up or loading. */
+	uint32_t m_nNumTimedOut;
+	uint32_t m_nNumFramePresentsTimedOut;
+	uint32_t m_nNumDroppedFramesTimedOut;
+	uint32_t m_nNumReprojectedFramesTimedOut;
+};
+
+struct Compositor_StageRenderSettings
+{
+	/** Primary color is applied as a tint to (i.e. multiplied with) the model's texture */
+	HmdColor_t m_PrimaryColor;
+	HmdColor_t m_SecondaryColor;
+
+	/** Vignette radius is in meters and is used to fade to the specified secondary solid color over
+	* that 3D distance from the origin of the playspace. */
+	float m_flVignetteInnerRadius;
+	float m_flVignetteOuterRadius;
+
+	/** Fades to the secondary color based on view incidence.  This variable controls the linearity
+	* of the effect.  It is mutually exclusive with vignette.  Additionally, it treats the mesh as faceted. */
+	float m_flFresnelStrength;
+
+	/** Controls backface culling. */
+	bool m_bBackfaceCulling;
+
+	/** Converts the render model's texture to luma and applies to rgb equally.  This is useful to
+	* combat compression artifacts that can occur on desaturated source material. */
+	bool m_bGreyscale;
+
+	/** Renders mesh as a wireframe. */
+	bool m_bWireframe;
+};
+
+static inline Compositor_StageRenderSettings DefaultStageRenderSettings()
+{
+	Compositor_StageRenderSettings settings;
+	settings.m_PrimaryColor.r = 1.0f;
+	settings.m_PrimaryColor.g = 1.0f;
+	settings.m_PrimaryColor.b = 1.0f;
+	settings.m_PrimaryColor.a = 1.0f;
+	settings.m_SecondaryColor.r = 1.0f;
+	settings.m_SecondaryColor.g = 1.0f;
+	settings.m_SecondaryColor.b = 1.0f;
+	settings.m_SecondaryColor.a = 1.0f;
+	settings.m_flVignetteInnerRadius = 0.0f;
+	settings.m_flVignetteOuterRadius = 0.0f;
+	settings.m_flFresnelStrength = 0.0f;
+	settings.m_bBackfaceCulling = false;
+	settings.m_bGreyscale = false;
+	settings.m_bWireframe = false;
+	return settings;
+}
+
+#pragma pack( pop )
+
+/** Allows the application to interact with the compositor */
+struct VR_IVRCompositor_FnTable
+{
+	void (__stdcall *SetTrackingSpace)( ETrackingUniverseOrigin eOrigin );
+	ETrackingUniverseOrigin (__stdcall *GetTrackingSpace)();
+	EVRCompositorError (__stdcall *WaitGetPoses)(  TrackedDevicePose_t* pRenderPoseArray, uint32_t unRenderPoseArrayCount,
+		 TrackedDevicePose_t* pGamePoseArray, uint32_t unGamePoseArrayCount );
+	EVRCompositorError (__stdcall *GetLastPoses)(  TrackedDevicePose_t* pRenderPoseArray, uint32_t unRenderPoseArrayCount,
+		 TrackedDevicePose_t* pGamePoseArray, uint32_t unGamePoseArrayCount );
+	EVRCompositorError (__stdcall *GetLastPoseForTrackedDeviceIndex)( TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t *pOutputPose, TrackedDevicePose_t *pOutputGamePose );
+	EVRCompositorError (__stdcall *Submit)( EVREye eEye, const Texture_t *pTexture, const VRTextureBounds_t* pBounds, EVRSubmitFlags nSubmitFlags);
+	void (__stdcall *ClearLastSubmittedFrame)();
+	void (__stdcall *PostPresentHandoff)();
+	bool (__stdcall *GetFrameTiming)( Compositor_FrameTiming *pTiming, uint32_t unFramesAgo);
+	uint32_t (__stdcall *GetFrameTimings)(  Compositor_FrameTiming *pTiming, uint32_t nFrames );
+	float (__stdcall *GetFrameTimeRemaining)();
+	void (__stdcall *GetCumulativeStats)( Compositor_CumulativeStats *pStats, uint32_t nStatsSizeInBytes );
+	void (__stdcall *FadeToColor)( float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
+	HmdColor_t (__stdcall *GetCurrentFadeColor)( bool bBackground);
+	void (__stdcall *FadeGrid)( float fSeconds, bool bFadeIn );
+	float (__stdcall *GetCurrentGridAlpha)();
+	EVRCompositorError (__stdcall *SetSkyboxOverride)(  const Texture_t *pTextures, uint32_t unTextureCount );
+	void (__stdcall *ClearSkyboxOverride)();
+	void (__stdcall *CompositorBringToFront)();
+	void (__stdcall *CompositorGoToBack)();
+	void (__stdcall *CompositorQuit)();
+	bool (__stdcall *IsFullscreen)();
+	uint32_t (__stdcall *GetCurrentSceneFocusProcess)();
+	uint32_t (__stdcall *GetLastFrameRenderer)();
+	bool (__stdcall *CanRenderScene)();
+	void (__stdcall *ShowMirrorWindow)();
+	void (__stdcall *HideMirrorWindow)();
+	bool (__stdcall *IsMirrorWindowVisible)();
+	void (__stdcall *CompositorDumpImages)();
+	bool (__stdcall *ShouldAppRenderWithLowResources)();
+	void (__stdcall *ForceInterleavedReprojectionOn)( bool bOverride );
+	void (__stdcall *ForceReconnectProcess)();
+	void (__stdcall *SuspendRendering)( bool bSuspend );
+	vr::EVRCompositorError (__stdcall *GetMirrorTextureD3D11)( vr::EVREye eEye, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView );
+	void (__stdcall *ReleaseMirrorTextureD3D11)( void *pD3D11ShaderResourceView );
+	vr::EVRCompositorError (__stdcall *GetMirrorTextureGL)( vr::EVREye eEye, vr::glUInt_t *pglTextureId, vr::glSharedTextureHandle_t *pglSharedTextureHandle );
+	bool (__stdcall *ReleaseSharedGLTexture)( vr::glUInt_t glTextureId, vr::glSharedTextureHandle_t glSharedTextureHandle );
+	void (__stdcall *LockGLSharedTextureForAccess)( vr::glSharedTextureHandle_t glSharedTextureHandle );
+	void (__stdcall *UnlockGLSharedTextureForAccess)( vr::glSharedTextureHandle_t glSharedTextureHandle );
+	uint32_t (__stdcall *GetVulkanInstanceExtensionsRequired)(  char *pchValue, uint32_t unBufferSize );
+	uint32_t (__stdcall *GetVulkanDeviceExtensionsRequired)( VkPhysicalDevice_T *pPhysicalDevice,  char *pchValue, uint32_t unBufferSize );
+	void (__stdcall *SetExplicitTimingMode)( EVRCompositorTimingMode eTimingMode );
+	EVRCompositorError (__stdcall *SubmitExplicitTimingData)();
+	bool (__stdcall *IsMotionSmoothingEnabled)();
+	bool (__stdcall *IsMotionSmoothingSupported)();
+	bool (__stdcall *IsCurrentSceneFocusAppLoading)();
+	EVRCompositorError (__stdcall *SetStageOverride_Async)( const char *pchRenderModelPath, const HmdMatrix34_t *pTransform,
+		const Compositor_StageRenderSettings *pRenderSettings, uint32_t nSizeOfRenderSettings);
+	void (__stdcall *ClearStageOverride)();
+	bool (__stdcall *GetCompositorBenchmarkResults)( Compositor_BenchmarkResults *pBenchmarkResults, uint32_t nSizeOfBenchmarkResults );
+	EVRCompositorError (__stdcall *GetLastPosePredictionIDs)( uint32_t *pRenderPosePredictionID, uint32_t *pGamePosePredictionID );
+	EVRCompositorError (__stdcall *GetPosesForFrame)( uint32_t unPosePredictionID,  TrackedDevicePose_t* pPoseArray, uint32_t unPoseArrayCount );
+};
+
+class IVRCompositor
+{
+	VR_IVRCompositor_FnTable _table;
+public:
+	/** Sets tracking space returned by WaitGetPoses */
+	void SetTrackingSpace( ETrackingUniverseOrigin eOrigin ) { _table.SetTrackingSpace(eOrigin); }
+
+	/** Gets current tracking space returned by WaitGetPoses */
+	ETrackingUniverseOrigin GetTrackingSpace() { return _table.GetTrackingSpace(); }
+
+	/** Scene applications should call this function to get poses to render with (and optionally poses predicted an additional frame out to use for gameplay).
+	* This function will block until "running start" milliseconds before the start of the frame, and should be called at the last moment before needing to
+	* start rendering.
+	*
+	* Return codes:
+	*	- IsNotSceneApplication (make sure to call VR_Init with VRApplicaiton_Scene)
+	*	- DoNotHaveFocus (some other app has taken focus - this will throttle the call to 10hz to reduce the impact on that app)
+	*/
+	EVRCompositorError WaitGetPoses( VR_ARRAY_COUNT( unRenderPoseArrayCount ) TrackedDevicePose_t* pRenderPoseArray, uint32_t unRenderPoseArrayCount,
+		VR_ARRAY_COUNT( unGamePoseArrayCount ) TrackedDevicePose_t* pGamePoseArray, uint32_t unGamePoseArrayCount ) { return _table.WaitGetPoses(pRenderPoseArray, unRenderPoseArrayCount, pGamePoseArray, unGamePoseArrayCount); }
+
+	/** Get the last set of poses returned by WaitGetPoses. */
+	EVRCompositorError GetLastPoses( VR_ARRAY_COUNT( unRenderPoseArrayCount ) TrackedDevicePose_t* pRenderPoseArray, uint32_t unRenderPoseArrayCount,
+		VR_ARRAY_COUNT( unGamePoseArrayCount ) TrackedDevicePose_t* pGamePoseArray, uint32_t unGamePoseArrayCount ) { return _table.GetLastPoses(pRenderPoseArray, unRenderPoseArrayCount, pGamePoseArray, unGamePoseArrayCount); }
+
+	/** Interface for accessing last set of poses returned by WaitGetPoses one at a time.
+	* Returns VRCompositorError_IndexOutOfRange if unDeviceIndex not less than k_unMaxTrackedDeviceCount otherwise VRCompositorError_None.
+	* It is okay to pass NULL for either pose if you only want one of the values. */
+	EVRCompositorError GetLastPoseForTrackedDeviceIndex( TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t *pOutputPose, TrackedDevicePose_t *pOutputGamePose ) { return _table.GetLastPoseForTrackedDeviceIndex(unDeviceIndex, pOutputPose, pOutputGamePose); }
+
+	/** Updated scene texture to display. If pBounds is NULL the entire texture will be used.  If called from an OpenGL app, consider adding a glFlush after
+	* Submitting both frames to signal the driver to start processing, otherwise it may wait until the command buffer fills up, causing the app to miss frames.
+	*
+	* OpenGL dirty state:
+	*	glBindTexture
+	*
+	* Return codes:
+	*	- IsNotSceneApplication (make sure to call VR_Init with VRApplicaiton_Scene)
+	*	- DoNotHaveFocus (some other app has taken focus)
+	*	- TextureIsOnWrongDevice (application did not use proper AdapterIndex - see IVRSystem.GetDXGIOutputInfo)
+	*	- SharedTexturesNotSupported (application needs to call CreateDXGIFactory1 or later before creating DX device)
+	*	- TextureUsesUnsupportedFormat (scene textures must be compatible with DXGI sharing rules - e.g. uncompressed, no mips, etc.)
+	*	- InvalidTexture (usually means bad arguments passed in)
+	*	- AlreadySubmitted (app has submitted two left textures or two right textures in a single frame - i.e. before calling WaitGetPoses again)
+	*/
+	EVRCompositorError Submit( EVREye eEye, const Texture_t *pTexture, const VRTextureBounds_t* pBounds = 0, EVRSubmitFlags nSubmitFlags = Submit_Default ) { return _table.Submit(eEye, pTexture, pBounds, nSubmitFlags); }
+
+	/** Clears the frame that was sent with the last call to Submit. This will cause the 
+	* compositor to show the grid until Submit is called again. */
+	void ClearLastSubmittedFrame() { _table.ClearLastSubmittedFrame(); }
+
+	/** Call immediately after presenting your app's window (i.e. companion window) to unblock the compositor.
+	* This is an optional call, which only needs to be used if you can't instead call WaitGetPoses immediately after Present.
+	* For example, if your engine's render and game loop are not on separate threads, or blocking the render thread until 3ms before the next vsync would
+	* introduce a deadlock of some sort.  This function tells the compositor that you have finished all rendering after having Submitted buffers for both
+	* eyes, and it is free to start its rendering work.  This should only be called from the same thread you are rendering on. */
+	void PostPresentHandoff() { _table.PostPresentHandoff(); }
+
+	/** Returns true if timing data is filled it.  Sets oldest timing info if nFramesAgo is larger than the stored history.
+	* Be sure to set timing.size = sizeof(Compositor_FrameTiming) on struct passed in before calling this function. */
+	bool GetFrameTiming( Compositor_FrameTiming *pTiming, uint32_t unFramesAgo = 0 ) { return _table.GetFrameTiming(pTiming, unFramesAgo); }
+
+	/** Interface for copying a range of timing data.  Frames are returned in ascending order (oldest to newest) with the last being the most recent frame.
+	* Only the first entry's m_nSize needs to be set, as the rest will be inferred from that.  Returns total number of entries filled out. */
+	uint32_t GetFrameTimings( VR_ARRAY_COUNT( nFrames ) Compositor_FrameTiming *pTiming, uint32_t nFrames ) { return _table.GetFrameTimings(pTiming, nFrames); }
+
+	/** Returns the time in seconds left in the current (as identified by FrameTiming's frameIndex) frame.
+	* Due to "running start", this value may roll over to the next frame before ever reaching 0.0. */
+	float GetFrameTimeRemaining() { return _table.GetFrameTimeRemaining(); }
+
+	/** Fills out stats accumulated for the last connected application.  Pass in sizeof( Compositor_CumulativeStats ) as second parameter. */
+	void GetCumulativeStats( Compositor_CumulativeStats *pStats, uint32_t nStatsSizeInBytes ) { _table.GetCumulativeStats(pStats, nStatsSizeInBytes); }
+
+	/** Fades the view on the HMD to the specified color. The fade will take fSeconds, and the color values are between
+	* 0.0 and 1.0. This color is faded on top of the scene based on the alpha parameter. Removing the fade color instantly 
+	* would be FadeToColor( 0.0, 0.0, 0.0, 0.0, 0.0 ).  Values are in un-premultiplied alpha space. */
+	void FadeToColor( float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground = false ) { _table.FadeToColor(fSeconds, fRed, fGreen, fBlue, fAlpha, bBackground); }
+
+	/** Get current fade color value. */
+	HmdColor_t GetCurrentFadeColor( bool bBackground = false ) { return _table.GetCurrentFadeColor(bBackground); }
+
+	/** Fading the Grid in or out in fSeconds */
+	void FadeGrid( float fSeconds, bool bFadeIn ) { _table.FadeGrid(fSeconds, bFadeIn); }
+
+	/** Get current alpha value of grid. */
+	float GetCurrentGridAlpha() { return _table.GetCurrentGridAlpha(); }
+
+	/** Override the skybox used in the compositor (e.g. for during level loads when the app can't feed scene images fast enough)
+	* Order is Front, Back, Left, Right, Top, Bottom.  If only a single texture is passed, it is assumed in lat-long format.
+	* If two are passed, it is assumed a lat-long stereo pair. */
+	EVRCompositorError SetSkyboxOverride( VR_ARRAY_COUNT( unTextureCount ) const Texture_t *pTextures, uint32_t unTextureCount ) { return _table.SetSkyboxOverride(pTextures, unTextureCount); }
+
+	/** Resets compositor skybox back to defaults. */
+	void ClearSkyboxOverride() { _table.ClearSkyboxOverride(); }
+
+	/** Brings the compositor window to the front. This is useful for covering any other window that may be on the HMD
+	* and is obscuring the compositor window. */
+	void CompositorBringToFront() { _table.CompositorBringToFront(); }
+
+	/** Pushes the compositor window to the back. This is useful for allowing other applications to draw directly to the HMD. */
+	void CompositorGoToBack() { _table.CompositorGoToBack(); }
+
+	/** Tells the compositor process to clean up and exit. You do not need to call this function at shutdown. Under normal 
+	* circumstances the compositor will manage its own life cycle based on what applications are running. */
+	void CompositorQuit() { _table.CompositorQuit(); }
+	
+	/** Return whether the compositor is fullscreen */
+	bool IsFullscreen() { return _table.IsFullscreen(); }
+
+	/** Returns the process ID of the process that is currently rendering the scene */
+	uint32_t GetCurrentSceneFocusProcess() { return _table.GetCurrentSceneFocusProcess(); }
+
+	/** Returns the process ID of the process that rendered the last frame (or 0 if the compositor itself rendered the frame.)
+	* Returns 0 when fading out from an app and the app's process Id when fading into an app. */
+	uint32_t GetLastFrameRenderer() { return _table.GetLastFrameRenderer(); }
+
+	/** Returns true if the current process has the scene focus */
+	bool CanRenderScene() { return _table.CanRenderScene(); }
+
+	/** DEPRECATED: Opens the headset view (as either a window or docked widget depending on user's preferences) that displays what the user
+	* sees in the headset. */
+	void ShowMirrorWindow() { _table.ShowMirrorWindow(); }
+
+	/** DEPRECATED: Closes the headset view, either as a window or docked widget. */
+	void HideMirrorWindow() { _table.HideMirrorWindow(); }
+
+	/** DEPRECATED: Returns true if the headset view (either as a window or docked widget) is shown. */
+	bool IsMirrorWindowVisible() { return _table.IsMirrorWindowVisible(); }
+
+	/** Writes back buffer and stereo left/right pair from the application to a 'screenshots' folder in the SteamVR runtime root. */
+	void CompositorDumpImages() { _table.CompositorDumpImages(); }
+
+	/** Let an app know it should be rendering with low resources. */
+	bool ShouldAppRenderWithLowResources() { return _table.ShouldAppRenderWithLowResources(); }
+
+	/** Override interleaved reprojection logic to force on. */
+	void ForceInterleavedReprojectionOn( bool bOverride ) { _table.ForceInterleavedReprojectionOn(bOverride); }
+
+	/** Force reconnecting to the compositor process. */
+	void ForceReconnectProcess() { _table.ForceReconnectProcess(); }
+
+	/** Temporarily suspends rendering (useful for finer control over scene transitions). */
+	void SuspendRendering( bool bSuspend ) { _table.SuspendRendering(bSuspend); }
+
+	/** Opens a shared D3D11 texture with the undistorted composited image for each eye.  Use ReleaseMirrorTextureD3D11 when finished
+	* instead of calling Release on the resource itself. */
+	vr::EVRCompositorError GetMirrorTextureD3D11( vr::EVREye eEye, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView ) { return _table.GetMirrorTextureD3D11(eEye, pD3D11DeviceOrResource, ppD3D11ShaderResourceView); }
+	void ReleaseMirrorTextureD3D11( void *pD3D11ShaderResourceView ) { _table.ReleaseMirrorTextureD3D11(pD3D11ShaderResourceView); }
+
+	/** Access to mirror textures from OpenGL. */
+	vr::EVRCompositorError GetMirrorTextureGL( vr::EVREye eEye, vr::glUInt_t *pglTextureId, vr::glSharedTextureHandle_t *pglSharedTextureHandle ) { return _table.GetMirrorTextureGL(eEye, pglTextureId, pglSharedTextureHandle); }
+	bool ReleaseSharedGLTexture( vr::glUInt_t glTextureId, vr::glSharedTextureHandle_t glSharedTextureHandle ) { return _table.ReleaseSharedGLTexture(glTextureId, glSharedTextureHandle); }
+	void LockGLSharedTextureForAccess( vr::glSharedTextureHandle_t glSharedTextureHandle ) { _table.LockGLSharedTextureForAccess(glSharedTextureHandle); }
+	void UnlockGLSharedTextureForAccess( vr::glSharedTextureHandle_t glSharedTextureHandle ) { _table.UnlockGLSharedTextureForAccess(glSharedTextureHandle); }
+
+	/** [Vulkan Only]
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null.  The string will be a space separated list of-required instance extensions to enable in VkCreateInstance */
+	uint32_t GetVulkanInstanceExtensionsRequired( VR_OUT_STRING() char *pchValue, uint32_t unBufferSize ) { return _table.GetVulkanInstanceExtensionsRequired(pchValue, unBufferSize); }
+
+	/** [Vulkan only]
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null.  The string will be a space separated list of required device extensions to enable in VkCreateDevice */
+	uint32_t GetVulkanDeviceExtensionsRequired( VkPhysicalDevice_T *pPhysicalDevice, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize ) { return _table.GetVulkanDeviceExtensionsRequired(pPhysicalDevice, pchValue, unBufferSize); }
+
+	/** [ Vulkan/D3D12 Only ]
+	* There are two purposes for SetExplicitTimingMode:
+	*	1. To get a more accurate GPU timestamp for when the frame begins in Vulkan/D3D12 applications.
+	*	2. (Optional) To avoid having WaitGetPoses access the Vulkan queue so that the queue can be accessed from
+	*	another thread while WaitGetPoses is executing.
+	*
+	* More accurate GPU timestamp for the start of the frame is achieved by the application calling
+	* SubmitExplicitTimingData immediately before its first submission to the Vulkan/D3D12 queue.
+	* This is more accurate because normally this GPU timestamp is recorded during WaitGetPoses.  In D3D11, 
+	* WaitGetPoses queues a GPU timestamp write, but it does not actually get submitted to the GPU until the 
+	* application flushes.  By using SubmitExplicitTimingData, the timestamp is recorded at the same place for 
+	* Vulkan/D3D12 as it is for D3D11, resulting in a more accurate GPU time measurement for the frame.
+	*
+	* Avoiding WaitGetPoses accessing the Vulkan queue can be achieved using SetExplicitTimingMode as well.  If this is desired,
+	* the application should set the timing mode to Explicit_ApplicationPerformsPostPresentHandoff and *MUST* call PostPresentHandoff
+	* itself. If these conditions are met, then WaitGetPoses is guaranteed not to access the queue.  Note that PostPresentHandoff
+	* and SubmitExplicitTimingData will access the queue, so only WaitGetPoses becomes safe for accessing the queue from another
+	* thread. */
+	void SetExplicitTimingMode( EVRCompositorTimingMode eTimingMode ) { _table.SetExplicitTimingMode(eTimingMode); }
+
+	/** [ Vulkan/D3D12 Only ]
+	* Submit explicit timing data.  When SetExplicitTimingMode is true, this must be called immediately before
+	* the application's first vkQueueSubmit (Vulkan) or ID3D12CommandQueue::ExecuteCommandLists (D3D12) of each frame.
+	* This function will insert a GPU timestamp write just before the application starts its rendering.  This function
+	* will perform a vkQueueSubmit on Vulkan so must not be done simultaneously with VkQueue operations on another thread.
+	* Returns VRCompositorError_RequestFailed if SetExplicitTimingMode is not enabled. */
+	EVRCompositorError SubmitExplicitTimingData() { return _table.SubmitExplicitTimingData(); }
+
+	/** Indicates whether or not motion smoothing is enabled by the user settings.
+	* If you want to know if motion smoothing actually triggered due to a late frame, check Compositor_FrameTiming
+	* m_nReprojectionFlags & VRCompositor_ReprojectionMotion instead. */
+	bool IsMotionSmoothingEnabled() { return _table.IsMotionSmoothingEnabled(); }
+
+	/** Indicates whether or not motion smoothing is supported by the current hardware. */
+	bool IsMotionSmoothingSupported() { return _table.IsMotionSmoothingSupported(); }
+
+	/** Indicates whether or not the current scene focus app is currently loading.  This is inferred from its use of FadeGrid to
+	* explicitly fade to the compositor to cover up the fact that it cannot render at a sustained full framerate during this time. */
+	bool IsCurrentSceneFocusAppLoading() { return _table.IsCurrentSceneFocusAppLoading(); }
+
+	/** Override the stage model used in the compositor to replace the grid.  RenderModelPath is a full path the an OBJ file to load.
+	* This file will be loaded asynchronously from disk and uploaded to the gpu by the runtime.  Once ready for rendering, the
+	* VREvent StageOverrideReady will be sent.  Use FadeToGrid to reveal.  Call ClearStageOverride to free the associated resources when finished. */
+	EVRCompositorError SetStageOverride_Async( const char *pchRenderModelPath, const HmdMatrix34_t *pTransform = 0,
+		const Compositor_StageRenderSettings *pRenderSettings = 0, uint32_t nSizeOfRenderSettings = 0 ) { return _table.SetStageOverride_Async(pchRenderModelPath, pTransform, pRenderSettings, nSizeOfRenderSettings); }
+
+	/** Resets the stage to its default user specified setting. */
+	void ClearStageOverride() { _table.ClearStageOverride(); }
+
+	/** Returns true if pBenchmarkResults is filled it.  Sets pBenchmarkResults with the result of the compositor benchmark.
+	* nSizeOfBenchmarkResults should be set to sizeof(Compositor_BenchmarkResults) */
+	bool GetCompositorBenchmarkResults( Compositor_BenchmarkResults *pBenchmarkResults, uint32_t nSizeOfBenchmarkResults ) { return _table.GetCompositorBenchmarkResults(pBenchmarkResults, nSizeOfBenchmarkResults); }
+
+	/** Returns the frame id associated with the poses last returned by WaitGetPoses.  Deltas between IDs correspond to number of headset vsync intervals. */
+	EVRCompositorError GetLastPosePredictionIDs( uint32_t *pRenderPosePredictionID, uint32_t *pGamePosePredictionID ) { return _table.GetLastPosePredictionIDs(pRenderPosePredictionID, pGamePosePredictionID); }
+
+	/** Get the most up-to-date predicted (or recorded - up to 100ms old) set of poses for a given frame id. */
+	EVRCompositorError GetPosesForFrame( uint32_t unPosePredictionID, VR_ARRAY_COUNT( unPoseArrayCount ) TrackedDevicePose_t* pPoseArray, uint32_t unPoseArrayCount ) { return _table.GetPosesForFrame(unPosePredictionID, pPoseArray, unPoseArrayCount); }
+};
+
+static const char * const IVRCompositor_Version = "FnTable:IVRCompositor_026";
+
+} // namespace vr
+
+
+
+// ivrheadsetview.h
+namespace vr
+{
+	enum HeadsetViewMode_t
+	{
+		HeadsetViewMode_Left = 0,
+		HeadsetViewMode_Right,
+		HeadsetViewMode_Both
+	};
+
+	struct VR_IVRHeadsetView_FnTable
+	{
+		void (__stdcall *SetHeadsetViewSize)( uint32_t nWidth, uint32_t nHeight );
+		void (__stdcall *GetHeadsetViewSize)( uint32_t *pnWidth, uint32_t *pnHeight );
+		void (__stdcall *SetHeadsetViewMode)( HeadsetViewMode_t eHeadsetViewMode );
+		HeadsetViewMode_t (__stdcall *GetHeadsetViewMode)();
+		void (__stdcall *SetHeadsetViewCropped)( bool bCropped );
+		bool (__stdcall *GetHeadsetViewCropped)();
+		float (__stdcall *GetHeadsetViewAspectRatio)();
+		void (__stdcall *SetHeadsetViewBlendRange)( float flStartPct, float flEndPct );
+		void (__stdcall *GetHeadsetViewBlendRange)( float *pStartPct, float *pEndPct );
+	};
+
+	class IVRHeadsetView
+	{
+		VR_IVRHeadsetView_FnTable _table;
+	public:
+		/** Sets the resolution in pixels to render the headset view. These values are clamped to k_unHeadsetViewMaxWidth
+		* and k_unHeadsetViewMaxHeight respectively. For cropped views, the rendered output will be fit to aspect ratio
+		* defined by the the specified dimensions. For uncropped views, the caller should use GetHeadsetViewAspectRation
+		* to adjust the requested render size to avoid squashing or stretching, and then apply letterboxing to compensate
+		* when displaying the results. */
+		void SetHeadsetViewSize( uint32_t nWidth, uint32_t nHeight ) { _table.SetHeadsetViewSize(nWidth, nHeight); }
+
+		/** Gets the current resolution used to render the headset view. */
+		void GetHeadsetViewSize( uint32_t *pnWidth, uint32_t *pnHeight ) { _table.GetHeadsetViewSize(pnWidth, pnHeight); }
+
+		/** Set the mode used to render the headset view. */
+		void SetHeadsetViewMode( HeadsetViewMode_t eHeadsetViewMode ) { _table.SetHeadsetViewMode(eHeadsetViewMode); }
+
+		/** Get the current mode used to render the headset view. */
+		HeadsetViewMode_t GetHeadsetViewMode() { return _table.GetHeadsetViewMode(); }
+
+		/** Set whether or not the headset view should be rendered cropped to hide the hidden area mesh or not. */
+		void SetHeadsetViewCropped( bool bCropped ) { _table.SetHeadsetViewCropped(bCropped); }
+
+		/** Get the current cropping status of the headset view. */
+		bool GetHeadsetViewCropped() { return _table.GetHeadsetViewCropped(); }
+
+		/** Get the aspect ratio (width:height) of the uncropped headset view (accounting for the current set mode). */
+		float GetHeadsetViewAspectRatio() { return _table.GetHeadsetViewAspectRatio(); }
+
+		/** Set the range [0..1] that the headset view blends across the stereo overlapped area in cropped both mode. */
+		void SetHeadsetViewBlendRange( float flStartPct, float flEndPct ) { _table.SetHeadsetViewBlendRange(flStartPct, flEndPct); }
+
+		/** Get the current range [0..1] that the headset view blends across the stereo overlapped area in cropped both mode. */
+		void GetHeadsetViewBlendRange( float *pStartPct, float *pEndPct ) { _table.GetHeadsetViewBlendRange(pStartPct, pEndPct); }
+	};
+
+	static const uint32_t k_unHeadsetViewMaxWidth = 3840;
+	static const uint32_t k_unHeadsetViewMaxHeight = 2160;
+	static const char * const k_pchHeadsetViewOverlayKey = "system.HeadsetView";
+
+	static const char * const IVRHeadsetView_Version = "FnTable:IVRHeadsetView_001";
+
+	/** Returns the current IVRHeadsetView pointer or NULL the interface could not be found. */
+	VR_INTERFACE vr::IVRHeadsetView *VR_CALLTYPE VRHeadsetView();
+
+} // namespace vr
+
+
+// ivrnotifications.h
+namespace vr
+{
+
+#pragma pack( push, 8 )
+
+// Used for passing graphic data
+struct NotificationBitmap_t
+{
+	NotificationBitmap_t()
+		: m_pImageData( nullptr )
+		, m_nWidth( 0 )
+		, m_nHeight( 0 )
+		, m_nBytesPerPixel( 0 )
+	{
+	}
+
+	void *m_pImageData;
+	int32_t m_nWidth;
+	int32_t m_nHeight;
+	int32_t m_nBytesPerPixel;
+};
+
+
+/** Be aware that the notification type is used as 'priority' to pick the next notification */
+enum EVRNotificationType
+{
+	/** Transient notifications are automatically hidden after a period of time set by the user. 
+	* They are used for things like information and chat messages that do not require user interaction. */
+	EVRNotificationType_Transient = 0,
+
+	/** Persistent notifications are shown to the user until they are hidden by calling RemoveNotification().
+	* They are used for things like phone calls and alarms that require user interaction. */
+	EVRNotificationType_Persistent = 1,
+
+	/** System notifications are shown no matter what. It is expected, that the ulUserValue is used as ID.
+	 * If there is already a system notification in the queue with that ID it is not accepted into the queue
+	 * to prevent spamming with system notification */
+	EVRNotificationType_Transient_SystemWithUserValue = 2,
+};
+
+enum EVRNotificationStyle
+{
+	/** Creates a notification with minimal external styling. */
+	EVRNotificationStyle_None = 0,
+
+	/** Used for notifications about overlay-level status. In Steam this is used for events like downloads completing. */
+	EVRNotificationStyle_Application = 100,
+
+	/** Used for notifications about contacts that are unknown or not available. In Steam this is used for friend invitations and offline friends. */
+	EVRNotificationStyle_Contact_Disabled = 200,
+
+	/** Used for notifications about contacts that are available but inactive. In Steam this is used for friends that are online but not playing a game. */
+	EVRNotificationStyle_Contact_Enabled = 201,
+
+	/** Used for notifications about contacts that are available and active. In Steam this is used for friends that are online and currently running a game. */
+	EVRNotificationStyle_Contact_Active = 202,
+};
+
+static const uint32_t k_unNotificationTextMaxSize = 256;
+
+typedef uint32_t VRNotificationId;
+
+
+
+#pragma pack( pop )
+
+/** Allows notification sources to interact with the VR system
+	This current interface is not yet implemented. Do not use yet. */
+struct VR_IVRNotifications_FnTable
+{
+	EVRNotificationError (__stdcall *CreateNotification)( VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, EVRNotificationType type, const char *pchText, EVRNotificationStyle style, const NotificationBitmap_t *pImage, /* out */ VRNotificationId *pNotificationId );
+	EVRNotificationError (__stdcall *RemoveNotification)( VRNotificationId notificationId );
+};
+
+class IVRNotifications
+{
+	VR_IVRNotifications_FnTable _table;
+public:
+	/** Create a notification and enqueue it to be shown to the user.
+	* An overlay handle is required to create a notification, as otherwise it would be impossible for a user to act on it.
+	* To create a two-line notification, use a line break ('\n') to split the text into two lines.
+	* The pImage argument may be NULL, in which case the specified overlay's icon will be used instead. */
+	EVRNotificationError CreateNotification( VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, EVRNotificationType type, const char *pchText, EVRNotificationStyle style, const NotificationBitmap_t *pImage, /* out */ VRNotificationId *pNotificationId ) { return _table.CreateNotification(ulOverlayHandle, ulUserValue, type, pchText, style, pImage, pNotificationId); }
+
+	/** Destroy a notification, hiding it first if it currently shown to the user. */
+	EVRNotificationError RemoveNotification( VRNotificationId notificationId ) { return _table.RemoveNotification(notificationId); }
+
+};
+
+static const char * const IVRNotifications_Version = "FnTable:IVRNotifications_002";
+
+} // namespace vr
+
+
+
+// ivroverlay.h
+namespace vr
+{
+
+	/** The maximum length of an overlay key in bytes, counting the terminating null character. */
+	static const uint32_t k_unVROverlayMaxKeyLength = 128;
+
+	/** The maximum length of an overlay name in bytes, counting the terminating null character. */
+	static const uint32_t k_unVROverlayMaxNameLength = 128;
+
+	/** The maximum number of overlays that can exist in the system at one time. */
+	static const uint32_t k_unMaxOverlayCount = 128;
+
+	/** The maximum number of overlay intersection mask primitives per overlay */
+	static const uint32_t k_unMaxOverlayIntersectionMaskPrimitivesCount = 32;
+
+	/** Types of input supported by VR Overlays */
+	enum VROverlayInputMethod
+	{
+		VROverlayInputMethod_None		= 0, // No input events will be generated automatically for this overlay
+		VROverlayInputMethod_Mouse		= 1, // Tracked controllers will get mouse events automatically
+		// VROverlayInputMethod_DualAnalog = 2, // No longer supported
+	};
+
+	/** Allows the caller to figure out which overlay transform getter to call. */
+	enum VROverlayTransformType
+	{
+		VROverlayTransform_Invalid					= -1,
+		VROverlayTransform_Absolute					= 0,
+		VROverlayTransform_TrackedDeviceRelative	= 1,
+		VROverlayTransform_SystemOverlay			= 2,
+		VROverlayTransform_TrackedComponent 		= 3,
+		VROverlayTransform_Cursor					= 4,
+		VROverlayTransform_DashboardTab				= 5,
+		VROverlayTransform_DashboardThumb			= 6,
+		VROverlayTransform_Mountable				= 7,
+	};
+
+	/** Overlay control settings */
+	enum VROverlayFlags
+	{
+		// Set this flag on a dashboard overlay to prevent a tab from showing up for that overlay
+		VROverlayFlags_NoDashboardTab = 1 << 3,
+
+		// When this is set the overlay will receive VREvent_ScrollDiscrete events like a mouse wheel. 
+		// Requires mouse input mode.
+		VROverlayFlags_SendVRDiscreteScrollEvents = 1 << 6,
+
+		// Indicates that the overlay would like to receive
+		VROverlayFlags_SendVRTouchpadEvents = 1 << 7,
+
+		// If set this will render a vertical scroll wheel on the primary controller, 
+		//  only needed if not using VROverlayFlags_SendVRScrollEvents but you still want to represent a scroll wheel
+		VROverlayFlags_ShowTouchPadScrollWheel = 1 << 8,
+
+		// If this is set ownership and render access to the overlay are transferred 
+		// to the new scene process on a call to IVRApplications::LaunchInternalProcess
+		VROverlayFlags_TransferOwnershipToInternalProcess = 1 << 9,
+
+		// If set, renders 50% of the texture in each eye, side by side
+		VROverlayFlags_SideBySide_Parallel = 1 << 10, // Texture is left/right
+		VROverlayFlags_SideBySide_Crossed = 1 << 11, // Texture is crossed and right/left
+
+		VROverlayFlags_Panorama = 1 << 12, // Texture is a panorama
+		VROverlayFlags_StereoPanorama = 1 << 13, // Texture is a stereo panorama
+
+		// If this is set on an overlay owned by the scene application that overlay
+		// will be sorted with the "Other" overlays on top of all other scene overlays
+		VROverlayFlags_SortWithNonSceneOverlays = 1 << 14,
+
+		// If set, the overlay will be shown in the dashboard, otherwise it will be hidden.
+		VROverlayFlags_VisibleInDashboard = 1 << 15,
+
+		// If this is set and the overlay's input method is not none, the system-wide laser mouse
+		// mode will be activated whenever this overlay is visible.
+		VROverlayFlags_MakeOverlaysInteractiveIfVisible = 1 << 16,
+
+		// If this is set the overlay will receive smooth VREvent_ScrollSmooth that emulate trackpad scrolling.
+		// Requires mouse input mode.
+		VROverlayFlags_SendVRSmoothScrollEvents = 1 << 17,
+
+		// If this is set, the overlay texture will be protected content, preventing unauthorized reads.
+		VROverlayFlags_ProtectedContent = 1 << 18,
+
+		// If this is set, the laser mouse splat will not be drawn over this overlay. The overlay will
+		// be responsible for drawing its own "cursor".
+		VROverlayFlags_HideLaserIntersection = 1 << 19,
+
+		// If this is set, clicking away from the overlay will cause it to receive a VREvent_Modal_Cancel event.
+		// This is ignored for dashboard overlays.
+		VROverlayFlags_WantsModalBehavior = 1 << 20,
+
+		// If this is set, alpha composition assumes the texture is pre-multiplied
+		VROverlayFlags_IsPremultiplied = 1 << 21,
+	};
+
+	enum VRMessageOverlayResponse
+	{
+		VRMessageOverlayResponse_ButtonPress_0 = 0,
+		VRMessageOverlayResponse_ButtonPress_1 = 1,
+		VRMessageOverlayResponse_ButtonPress_2 = 2,
+		VRMessageOverlayResponse_ButtonPress_3 = 3,
+		VRMessageOverlayResponse_CouldntFindSystemOverlay = 4,
+		VRMessageOverlayResponse_CouldntFindOrCreateClientOverlay= 5,
+		VRMessageOverlayResponse_ApplicationQuit = 6
+	};
+
+	struct VROverlayIntersectionParams_t
+	{
+		HmdVector3_t vSource;
+		HmdVector3_t vDirection;
+		ETrackingUniverseOrigin eOrigin;
+	};
+
+	struct VROverlayIntersectionResults_t
+	{
+		HmdVector3_t vPoint;
+		HmdVector3_t vNormal;
+		HmdVector2_t vUVs;
+		float fDistance;
+	};
+
+	// Input modes for the Big Picture gamepad text entry
+	enum EGamepadTextInputMode
+	{
+		k_EGamepadTextInputModeNormal = 0,
+		k_EGamepadTextInputModePassword = 1,
+		k_EGamepadTextInputModeSubmit = 2,
+	};
+
+	// Controls number of allowed lines for the Big Picture gamepad text entry
+	enum EGamepadTextInputLineMode
+	{
+		k_EGamepadTextInputLineModeSingleLine = 0,
+		k_EGamepadTextInputLineModeMultipleLines = 1
+	};
+
+	enum EVROverlayIntersectionMaskPrimitiveType
+	{
+		OverlayIntersectionPrimitiveType_Rectangle,
+		OverlayIntersectionPrimitiveType_Circle,
+	};
+
+	struct IntersectionMaskRectangle_t
+	{
+		float m_flTopLeftX;
+		float m_flTopLeftY;
+		float m_flWidth;
+		float m_flHeight;
+	};
+
+	struct IntersectionMaskCircle_t
+	{
+		float m_flCenterX;
+		float m_flCenterY;
+		float m_flRadius;
+	};
+
+	/** NOTE!!! If you change this you MUST manually update openvr_interop.cs.py and openvr_api_flat.h.py */
+	typedef union
+	{
+		IntersectionMaskRectangle_t m_Rectangle;
+		IntersectionMaskCircle_t m_Circle;
+	} VROverlayIntersectionMaskPrimitive_Data_t;
+
+	struct VROverlayIntersectionMaskPrimitive_t
+	{
+		EVROverlayIntersectionMaskPrimitiveType m_nPrimitiveType;
+		VROverlayIntersectionMaskPrimitive_Data_t m_Primitive;
+	};
+
+	enum EKeyboardFlags
+	{
+		KeyboardFlag_Minimal		= 1 << 0, // makes the keyboard send key events immediately instead of accumulating a buffer
+		KeyboardFlag_Modal			= 2 << 0, // makes the keyboard take all focus and dismiss when clicking off the panel
+	};
+
+
+	struct VR_IVROverlay_FnTable
+	{
+		EVROverlayError (__stdcall *FindOverlay)( const char *pchOverlayKey, VROverlayHandle_t * pOverlayHandle );
+		EVROverlayError (__stdcall *CreateOverlay)( const char *pchOverlayKey, const char *pchOverlayName, VROverlayHandle_t * pOverlayHandle );
+		EVROverlayError (__stdcall *DestroyOverlay)( VROverlayHandle_t ulOverlayHandle );
+		uint32_t (__stdcall *GetOverlayKey)( VROverlayHandle_t ulOverlayHandle,  char *pchValue, uint32_t unBufferSize, EVROverlayError *pError);
+		uint32_t (__stdcall *GetOverlayName)( VROverlayHandle_t ulOverlayHandle,  char *pchValue, uint32_t unBufferSize, EVROverlayError *pError);
+		EVROverlayError (__stdcall *SetOverlayName)( VROverlayHandle_t ulOverlayHandle, const char *pchName );
+		EVROverlayError (__stdcall *GetOverlayImageData)( VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unBufferSize, uint32_t *punWidth, uint32_t *punHeight );
+		const char *(__stdcall *GetOverlayErrorNameFromEnum)( EVROverlayError error );
+		EVROverlayError (__stdcall *SetOverlayRenderingPid)( VROverlayHandle_t ulOverlayHandle, uint32_t unPID );
+		uint32_t (__stdcall *GetOverlayRenderingPid)( VROverlayHandle_t ulOverlayHandle );
+		EVROverlayError (__stdcall *SetOverlayFlag)( VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled );
+		EVROverlayError (__stdcall *GetOverlayFlag)( VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool *pbEnabled );
+		EVROverlayError (__stdcall *GetOverlayFlags)( VROverlayHandle_t ulOverlayHandle, uint32_t *pFlags );
+		EVROverlayError (__stdcall *SetOverlayColor)( VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue );
+		EVROverlayError (__stdcall *GetOverlayColor)( VROverlayHandle_t ulOverlayHandle, float *pfRed, float *pfGreen, float *pfBlue );
+		EVROverlayError (__stdcall *SetOverlayAlpha)( VROverlayHandle_t ulOverlayHandle, float fAlpha );
+		EVROverlayError (__stdcall *GetOverlayAlpha)( VROverlayHandle_t ulOverlayHandle, float *pfAlpha );
+		EVROverlayError (__stdcall *SetOverlayTexelAspect)( VROverlayHandle_t ulOverlayHandle, float fTexelAspect );
+		EVROverlayError (__stdcall *GetOverlayTexelAspect)( VROverlayHandle_t ulOverlayHandle, float *pfTexelAspect );
+		EVROverlayError (__stdcall *SetOverlaySortOrder)( VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder );
+		EVROverlayError (__stdcall *GetOverlaySortOrder)( VROverlayHandle_t ulOverlayHandle, uint32_t *punSortOrder );
+		EVROverlayError (__stdcall *SetOverlayWidthInMeters)( VROverlayHandle_t ulOverlayHandle, float fWidthInMeters );
+		EVROverlayError (__stdcall *GetOverlayWidthInMeters)( VROverlayHandle_t ulOverlayHandle, float *pfWidthInMeters );
+		EVROverlayError (__stdcall *SetOverlayCurvature)( VROverlayHandle_t ulOverlayHandle, float fCurvature );
+		EVROverlayError (__stdcall *GetOverlayCurvature)( VROverlayHandle_t ulOverlayHandle, float *pfCurvature );
+		EVROverlayError (__stdcall *SetOverlayTextureColorSpace)( VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace );
+		EVROverlayError (__stdcall *GetOverlayTextureColorSpace)( VROverlayHandle_t ulOverlayHandle, EColorSpace *peTextureColorSpace );
+		EVROverlayError (__stdcall *SetOverlayTextureBounds)( VROverlayHandle_t ulOverlayHandle, const VRTextureBounds_t *pOverlayTextureBounds );
+		EVROverlayError (__stdcall *GetOverlayTextureBounds)( VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t *pOverlayTextureBounds );
+		EVROverlayError (__stdcall *GetOverlayTransformType)( VROverlayHandle_t ulOverlayHandle, VROverlayTransformType *peTransformType );
+		EVROverlayError (__stdcall *SetOverlayTransformAbsolute)( VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, const HmdMatrix34_t *pmatTrackingOriginToOverlayTransform );
+		EVROverlayError (__stdcall *GetOverlayTransformAbsolute)( VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin *peTrackingOrigin, HmdMatrix34_t *pmatTrackingOriginToOverlayTransform );
+		EVROverlayError (__stdcall *SetOverlayTransformTrackedDeviceRelative)( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, const HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform );
+		EVROverlayError (__stdcall *GetOverlayTransformTrackedDeviceRelative)( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punTrackedDevice, HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform );
+		EVROverlayError (__stdcall *SetOverlayTransformTrackedDeviceComponent)( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char *pchComponentName );
+		EVROverlayError (__stdcall *GetOverlayTransformTrackedDeviceComponent)( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punDeviceIndex,  char *pchComponentName, uint32_t unComponentNameSize );
+		vr::EVROverlayError (__stdcall *GetOverlayTransformOverlayRelative)( VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t *ulOverlayHandleParent, HmdMatrix34_t *pmatParentOverlayToOverlayTransform );
+		vr::EVROverlayError (__stdcall *SetOverlayTransformOverlayRelative)( VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, const HmdMatrix34_t *pmatParentOverlayToOverlayTransform );
+		EVROverlayError (__stdcall *SetOverlayTransformCursor)( VROverlayHandle_t ulCursorOverlayHandle, const HmdVector2_t *pvHotspot );
+		vr::EVROverlayError (__stdcall *GetOverlayTransformCursor)( VROverlayHandle_t ulOverlayHandle, HmdVector2_t *pvHotspot );
+		EVROverlayError (__stdcall *ShowOverlay)( VROverlayHandle_t ulOverlayHandle );
+		EVROverlayError (__stdcall *HideOverlay)( VROverlayHandle_t ulOverlayHandle );
+		bool (__stdcall *IsOverlayVisible)( VROverlayHandle_t ulOverlayHandle );
+		EVROverlayError (__stdcall *GetTransformForOverlayCoordinates)( VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t *pmatTransform );
+		bool (__stdcall *PollNextOverlayEvent)( VROverlayHandle_t ulOverlayHandle, VREvent_t *pEvent, uint32_t uncbVREvent );
+		EVROverlayError (__stdcall *GetOverlayInputMethod)( VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod *peInputMethod );
+		EVROverlayError (__stdcall *SetOverlayInputMethod)( VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod );
+		EVROverlayError (__stdcall *GetOverlayMouseScale)( VROverlayHandle_t ulOverlayHandle, HmdVector2_t *pvecMouseScale );
+		EVROverlayError (__stdcall *SetOverlayMouseScale)( VROverlayHandle_t ulOverlayHandle, const HmdVector2_t *pvecMouseScale );
+		bool (__stdcall *ComputeOverlayIntersection)( VROverlayHandle_t ulOverlayHandle, const VROverlayIntersectionParams_t *pParams, VROverlayIntersectionResults_t *pResults );
+		bool (__stdcall *IsHoverTargetOverlay)( VROverlayHandle_t ulOverlayHandle );
+		EVROverlayError (__stdcall *SetOverlayIntersectionMask)( VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t *pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
+		EVROverlayError (__stdcall *TriggerLaserMouseHapticVibration)( VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude );
+		EVROverlayError (__stdcall *SetOverlayCursor)( VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle );
+		EVROverlayError (__stdcall *SetOverlayCursorPositionOverride)( VROverlayHandle_t ulOverlayHandle, const HmdVector2_t *pvCursor );
+		EVROverlayError (__stdcall *ClearOverlayCursorPositionOverride)( VROverlayHandle_t ulOverlayHandle );
+		EVROverlayError (__stdcall *SetOverlayTexture)( VROverlayHandle_t ulOverlayHandle, const Texture_t *pTexture );
+		EVROverlayError (__stdcall *ClearOverlayTexture)( VROverlayHandle_t ulOverlayHandle );
+		EVROverlayError (__stdcall *SetOverlayRaw)( VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel );
+		EVROverlayError (__stdcall *SetOverlayFromFile)( VROverlayHandle_t ulOverlayHandle, const char *pchFilePath );
+		EVROverlayError (__stdcall *GetOverlayTexture)( VROverlayHandle_t ulOverlayHandle, void **pNativeTextureHandle, void *pNativeTextureRef, uint32_t *pWidth, uint32_t *pHeight, uint32_t *pNativeFormat, ETextureType *pAPIType, EColorSpace *pColorSpace, VRTextureBounds_t *pTextureBounds );
+		EVROverlayError (__stdcall *ReleaseNativeOverlayHandle)( VROverlayHandle_t ulOverlayHandle, void *pNativeTextureHandle );
+		EVROverlayError (__stdcall *GetOverlayTextureSize)( VROverlayHandle_t ulOverlayHandle, uint32_t *pWidth, uint32_t *pHeight );
+		EVROverlayError (__stdcall *CreateDashboardOverlay)( const char *pchOverlayKey, const char *pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t *pThumbnailHandle );
+		bool (__stdcall *IsDashboardVisible)();
+		bool (__stdcall *IsActiveDashboardOverlay)( VROverlayHandle_t ulOverlayHandle );
+		EVROverlayError (__stdcall *SetDashboardOverlaySceneProcess)( VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId );
+		EVROverlayError (__stdcall *GetDashboardOverlaySceneProcess)( VROverlayHandle_t ulOverlayHandle, uint32_t *punProcessId );
+		void (__stdcall *ShowDashboard)( const char *pchOverlayToShow );
+		vr::TrackedDeviceIndex_t (__stdcall *GetPrimaryDashboardDevice)();
+		EVROverlayError (__stdcall *ShowKeyboard)( EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, 
+			const char *pchDescription, uint32_t unCharMax, const char *pchExistingText, uint64_t uUserValue );
+		EVROverlayError (__stdcall *ShowKeyboardForOverlay)( VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode,
+			EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char *pchDescription, uint32_t unCharMax, 
+			const char *pchExistingText, uint64_t uUserValue );
+		uint32_t (__stdcall *GetKeyboardText)(  char *pchText, uint32_t cchText );
+		void (__stdcall *HideKeyboard)();
+		void (__stdcall *SetKeyboardTransformAbsolute)( ETrackingUniverseOrigin eTrackingOrigin, const HmdMatrix34_t *pmatTrackingOriginToKeyboardTransform );
+		void (__stdcall *SetKeyboardPositionForOverlay)( VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect );
+		VRMessageOverlayResponse (__stdcall *ShowMessageOverlay)( const char* pchText, const char* pchCaption, const char* pchButton0Text, const char* pchButton1Text, const char* pchButton2Text, const char* pchButton3Text);
+		void (__stdcall *CloseMessageOverlay)();
+	};
+
+	class IVROverlay
+	{
+		VR_IVROverlay_FnTable _table;
+	public:
+
+		// ---------------------------------------------
+		// Overlay management methods
+		// ---------------------------------------------
+
+		/** Finds an existing overlay with the specified key. */
+		EVROverlayError FindOverlay( const char *pchOverlayKey, VROverlayHandle_t * pOverlayHandle ) { return _table.FindOverlay(pchOverlayKey, pOverlayHandle); }
+
+		/** Creates a new named overlay. All overlays start hidden and with default settings. */
+		EVROverlayError CreateOverlay( const char *pchOverlayKey, const char *pchOverlayName, VROverlayHandle_t * pOverlayHandle ) { return _table.CreateOverlay(pchOverlayKey, pchOverlayName, pOverlayHandle); }
+
+		/** Destroys the specified overlay. When an application calls VR_Shutdown all overlays created by that app are
+		* automatically destroyed. */
+		EVROverlayError DestroyOverlay( VROverlayHandle_t ulOverlayHandle ) { return _table.DestroyOverlay(ulOverlayHandle); }
+
+		/** Fills the provided buffer with the string key of the overlay. Returns the size of buffer required to store the key, including
+		* the terminating null character. k_unVROverlayMaxKeyLength will be enough bytes to fit the string. */
+		uint32_t GetOverlayKey( VROverlayHandle_t ulOverlayHandle, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, EVROverlayError *pError = 0L ) { return _table.GetOverlayKey(ulOverlayHandle, pchValue, unBufferSize, pError); }
+
+		/** Fills the provided buffer with the friendly name of the overlay. Returns the size of buffer required to store the key, including
+		* the terminating null character. k_unVROverlayMaxNameLength will be enough bytes to fit the string. */
+		uint32_t GetOverlayName( VROverlayHandle_t ulOverlayHandle, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, EVROverlayError *pError = 0L ) { return _table.GetOverlayName(ulOverlayHandle, pchValue, unBufferSize, pError); }
+
+		/** set the name to use for this overlay */
+		EVROverlayError SetOverlayName( VROverlayHandle_t ulOverlayHandle, const char *pchName ) { return _table.SetOverlayName(ulOverlayHandle, pchName); }
+
+		/** Gets the raw image data from an overlay. Overlay image data is always returned as RGBA data, 4 bytes per pixel. If the buffer is not large enough, width and height 
+		* will be set and VROverlayError_ArrayTooSmall is returned. */
+		EVROverlayError GetOverlayImageData( VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unBufferSize, uint32_t *punWidth, uint32_t *punHeight ) { return _table.GetOverlayImageData(ulOverlayHandle, pvBuffer, unBufferSize, punWidth, punHeight); }
+
+		/** returns a string that corresponds with the specified overlay error. The string will be the name 
+		* of the error enum value for all valid error codes */
+		const char *GetOverlayErrorNameFromEnum( EVROverlayError error ) { return _table.GetOverlayErrorNameFromEnum(error); }
+
+		// ---------------------------------------------
+		// Overlay rendering methods
+		// ---------------------------------------------
+
+		/** Sets the pid that is allowed to render to this overlay (the creator pid is always allow to render),
+		*	by default this is the pid of the process that made the overlay */
+		EVROverlayError SetOverlayRenderingPid( VROverlayHandle_t ulOverlayHandle, uint32_t unPID ) { return _table.SetOverlayRenderingPid(ulOverlayHandle, unPID); }
+
+		/** Gets the pid that is allowed to render to this overlay */
+		uint32_t GetOverlayRenderingPid( VROverlayHandle_t ulOverlayHandle ) { return _table.GetOverlayRenderingPid(ulOverlayHandle); }
+
+		/** Specify flag setting for a given overlay */
+		EVROverlayError SetOverlayFlag( VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled ) { return _table.SetOverlayFlag(ulOverlayHandle, eOverlayFlag, bEnabled); }
+
+		/** Sets flag setting for a given overlay */
+		EVROverlayError GetOverlayFlag( VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool *pbEnabled ) { return _table.GetOverlayFlag(ulOverlayHandle, eOverlayFlag, pbEnabled); }
+
+		/** Gets all the flags for a given overlay */
+		EVROverlayError GetOverlayFlags( VROverlayHandle_t ulOverlayHandle, uint32_t *pFlags ) { return _table.GetOverlayFlags(ulOverlayHandle, pFlags); }
+
+		/** Sets the color tint of the overlay quad. Use 0.0 to 1.0 per channel. */
+		EVROverlayError SetOverlayColor( VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue ) { return _table.SetOverlayColor(ulOverlayHandle, fRed, fGreen, fBlue); }
+
+		/** Gets the color tint of the overlay quad. */
+		EVROverlayError GetOverlayColor( VROverlayHandle_t ulOverlayHandle, float *pfRed, float *pfGreen, float *pfBlue ) { return _table.GetOverlayColor(ulOverlayHandle, pfRed, pfGreen, pfBlue); }
+
+		/** Sets the alpha of the overlay quad. Use 1.0 for 100 percent opacity to 0.0 for 0 percent opacity. */
+		EVROverlayError SetOverlayAlpha( VROverlayHandle_t ulOverlayHandle, float fAlpha ) { return _table.SetOverlayAlpha(ulOverlayHandle, fAlpha); }
+
+		/** Gets the alpha of the overlay quad. By default overlays are rendering at 100 percent alpha (1.0). */
+		EVROverlayError GetOverlayAlpha( VROverlayHandle_t ulOverlayHandle, float *pfAlpha ) { return _table.GetOverlayAlpha(ulOverlayHandle, pfAlpha); }
+
+		/** Sets the aspect ratio of the texels in the overlay. 1.0 means the texels are square. 2.0 means the texels
+		* are twice as wide as they are tall. Defaults to 1.0. */
+		EVROverlayError SetOverlayTexelAspect( VROverlayHandle_t ulOverlayHandle, float fTexelAspect ) { return _table.SetOverlayTexelAspect(ulOverlayHandle, fTexelAspect); }
+
+		/** Gets the aspect ratio of the texels in the overlay. Defaults to 1.0 */
+		EVROverlayError GetOverlayTexelAspect( VROverlayHandle_t ulOverlayHandle, float *pfTexelAspect ) { return _table.GetOverlayTexelAspect(ulOverlayHandle, pfTexelAspect); }
+
+		/** Sets the rendering sort order for the overlay. Overlays are rendered this order:
+		*      Overlays owned by the scene application
+		*      Overlays owned by some other application
+		*
+		*	Within a category overlays are rendered lowest sort order to highest sort order. Overlays with the same 
+		*	sort order are rendered back to front base on distance from the HMD.
+		*
+		*	Sort order defaults to 0. */
+		EVROverlayError SetOverlaySortOrder( VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder ) { return _table.SetOverlaySortOrder(ulOverlayHandle, unSortOrder); }
+
+		/** Gets the sort order of the overlay. See SetOverlaySortOrder for how this works. */
+		EVROverlayError GetOverlaySortOrder( VROverlayHandle_t ulOverlayHandle, uint32_t *punSortOrder ) { return _table.GetOverlaySortOrder(ulOverlayHandle, punSortOrder); }
+
+		/** Sets the width of the overlay quad in meters. By default overlays are rendered on a quad that is 1 meter across */
+		EVROverlayError SetOverlayWidthInMeters( VROverlayHandle_t ulOverlayHandle, float fWidthInMeters ) { return _table.SetOverlayWidthInMeters(ulOverlayHandle, fWidthInMeters); }
+
+		/** Returns the width of the overlay quad in meters. By default overlays are rendered on a quad that is 1 meter across */
+		EVROverlayError GetOverlayWidthInMeters( VROverlayHandle_t ulOverlayHandle, float *pfWidthInMeters ) { return _table.GetOverlayWidthInMeters(ulOverlayHandle, pfWidthInMeters); }
+
+		/** Use to draw overlay as a curved surface. Curvature is a percentage from (0..1] where 1 is a fully closed cylinder.
+		* For a specific radius, curvature can be computed as: overlay.width / (2 PI r). */
+		EVROverlayError SetOverlayCurvature( VROverlayHandle_t ulOverlayHandle, float fCurvature ) { return _table.SetOverlayCurvature(ulOverlayHandle, fCurvature); }
+
+		/** Returns the curvature of the overlay as a percentage from (0..1] where 1 is a fully closed cylinder. */
+		EVROverlayError GetOverlayCurvature( VROverlayHandle_t ulOverlayHandle, float *pfCurvature ) { return _table.GetOverlayCurvature(ulOverlayHandle, pfCurvature); }
+
+		/** Sets the colorspace the overlay texture's data is in.  Defaults to 'auto'.
+		* If the texture needs to be resolved, you should call SetOverlayTexture with the appropriate colorspace instead. */
+		EVROverlayError SetOverlayTextureColorSpace( VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace ) { return _table.SetOverlayTextureColorSpace(ulOverlayHandle, eTextureColorSpace); }
+
+		/** Gets the overlay's current colorspace setting. */
+		EVROverlayError GetOverlayTextureColorSpace( VROverlayHandle_t ulOverlayHandle, EColorSpace *peTextureColorSpace ) { return _table.GetOverlayTextureColorSpace(ulOverlayHandle, peTextureColorSpace); }
+
+		/** Sets the part of the texture to use for the overlay. UV Min is the upper left corner and UV Max is the lower right corner. */
+		EVROverlayError SetOverlayTextureBounds( VROverlayHandle_t ulOverlayHandle, const VRTextureBounds_t *pOverlayTextureBounds ) { return _table.SetOverlayTextureBounds(ulOverlayHandle, pOverlayTextureBounds); }
+
+		/** Gets the part of the texture to use for the overlay. UV Min is the upper left corner and UV Max is the lower right corner. */
+		EVROverlayError GetOverlayTextureBounds( VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t *pOverlayTextureBounds ) { return _table.GetOverlayTextureBounds(ulOverlayHandle, pOverlayTextureBounds); }
+
+		/** Returns the transform type of this overlay. */
+		EVROverlayError GetOverlayTransformType( VROverlayHandle_t ulOverlayHandle, VROverlayTransformType *peTransformType ) { return _table.GetOverlayTransformType(ulOverlayHandle, peTransformType); }
+
+		/** Sets the transform to absolute tracking origin. */
+		EVROverlayError SetOverlayTransformAbsolute( VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, const HmdMatrix34_t *pmatTrackingOriginToOverlayTransform ) { return _table.SetOverlayTransformAbsolute(ulOverlayHandle, eTrackingOrigin, pmatTrackingOriginToOverlayTransform); }
+
+		/** Gets the transform if it is absolute. Returns an error if the transform is some other type. */
+		EVROverlayError GetOverlayTransformAbsolute( VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin *peTrackingOrigin, HmdMatrix34_t *pmatTrackingOriginToOverlayTransform ) { return _table.GetOverlayTransformAbsolute(ulOverlayHandle, peTrackingOrigin, pmatTrackingOriginToOverlayTransform); }
+
+		/** Sets the transform to relative to the transform of the specified tracked device. */
+		EVROverlayError SetOverlayTransformTrackedDeviceRelative( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, const HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform ) { return _table.SetOverlayTransformTrackedDeviceRelative(ulOverlayHandle, unTrackedDevice, pmatTrackedDeviceToOverlayTransform); }
+
+		/** Gets the transform if it is relative to a tracked device. Returns an error if the transform is some other type. */
+		EVROverlayError GetOverlayTransformTrackedDeviceRelative( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punTrackedDevice, HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform ) { return _table.GetOverlayTransformTrackedDeviceRelative(ulOverlayHandle, punTrackedDevice, pmatTrackedDeviceToOverlayTransform); }
+
+		/** Sets the transform to draw the overlay on a rendermodel component mesh instead of a quad. This will only draw when the system is
+		* drawing the device. Overlays with this transform type cannot receive mouse events. */
+		EVROverlayError SetOverlayTransformTrackedDeviceComponent( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char *pchComponentName ) { return _table.SetOverlayTransformTrackedDeviceComponent(ulOverlayHandle, unDeviceIndex, pchComponentName); }
+
+		/** Gets the transform information when the overlay is rendering on a component. */
+		EVROverlayError GetOverlayTransformTrackedDeviceComponent( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punDeviceIndex, VR_OUT_STRING() char *pchComponentName, uint32_t unComponentNameSize ) { return _table.GetOverlayTransformTrackedDeviceComponent(ulOverlayHandle, punDeviceIndex, pchComponentName, unComponentNameSize); }
+
+		/** Gets the transform if it is relative to another overlay. Returns an error if the transform is some other type. */
+		vr::EVROverlayError GetOverlayTransformOverlayRelative( VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t *ulOverlayHandleParent, HmdMatrix34_t *pmatParentOverlayToOverlayTransform ) { return _table.GetOverlayTransformOverlayRelative(ulOverlayHandle, ulOverlayHandleParent, pmatParentOverlayToOverlayTransform); }
+		
+		/** Sets the transform to relative to the transform of the specified overlay. This overlays visibility will also track the parents visibility */
+		vr::EVROverlayError SetOverlayTransformOverlayRelative( VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, const HmdMatrix34_t *pmatParentOverlayToOverlayTransform ) { return _table.SetOverlayTransformOverlayRelative(ulOverlayHandle, ulOverlayHandleParent, pmatParentOverlayToOverlayTransform); }
+
+		/** Sets the hotspot for the specified overlay when that overlay is used as a cursor. These are in texture space with 0,0 in the upper left corner of
+		* the texture and 1,1 in the lower right corner of the texture. */
+		EVROverlayError SetOverlayTransformCursor( VROverlayHandle_t ulCursorOverlayHandle, const HmdVector2_t *pvHotspot ) { return _table.SetOverlayTransformCursor(ulCursorOverlayHandle, pvHotspot); }
+
+		/** Gets cursor hotspot/transform for the specified overlay */
+		vr::EVROverlayError GetOverlayTransformCursor( VROverlayHandle_t ulOverlayHandle, HmdVector2_t *pvHotspot ) { return _table.GetOverlayTransformCursor(ulOverlayHandle, pvHotspot); }
+
+		/** Shows the VR overlay.  For dashboard overlays, only the Dashboard Manager is allowed to call this. */
+		EVROverlayError ShowOverlay( VROverlayHandle_t ulOverlayHandle ) { return _table.ShowOverlay(ulOverlayHandle); }
+
+		/** Hides the VR overlay.  For dashboard overlays, only the Dashboard Manager is allowed to call this. */
+		EVROverlayError HideOverlay( VROverlayHandle_t ulOverlayHandle ) { return _table.HideOverlay(ulOverlayHandle); }
+
+		/** Returns true if the overlay is visible. */
+		bool IsOverlayVisible( VROverlayHandle_t ulOverlayHandle ) { return _table.IsOverlayVisible(ulOverlayHandle); }
+
+		/** Get the transform in 3d space associated with a specific 2d point in the overlay's coordinate space (where 0,0 is the lower left). -Z points out of the overlay */
+		EVROverlayError GetTransformForOverlayCoordinates( VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t *pmatTransform ) { return _table.GetTransformForOverlayCoordinates(ulOverlayHandle, eTrackingOrigin, coordinatesInOverlay, pmatTransform); }
+
+		// ---------------------------------------------
+		// Overlay input methods
+		// ---------------------------------------------
+
+		/** Returns true and fills the event with the next event on the overlay's event queue, if there is one. 
+		* If there are no events this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct */
+		bool PollNextOverlayEvent( VROverlayHandle_t ulOverlayHandle, VREvent_t *pEvent, uint32_t uncbVREvent ) { return _table.PollNextOverlayEvent(ulOverlayHandle, pEvent, uncbVREvent); }
+
+		/** Returns the current input settings for the specified overlay. */
+		EVROverlayError GetOverlayInputMethod( VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod *peInputMethod ) { return _table.GetOverlayInputMethod(ulOverlayHandle, peInputMethod); }
+
+		/** Sets the input settings for the specified overlay. */
+		EVROverlayError SetOverlayInputMethod( VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod ) { return _table.SetOverlayInputMethod(ulOverlayHandle, eInputMethod); }
+
+		/** Gets the mouse scaling factor that is used for mouse events. The actual texture may be a different size, but this is
+		* typically the size of the underlying UI in pixels. */
+		EVROverlayError GetOverlayMouseScale( VROverlayHandle_t ulOverlayHandle, HmdVector2_t *pvecMouseScale ) { return _table.GetOverlayMouseScale(ulOverlayHandle, pvecMouseScale); }
+
+		/** Sets the mouse scaling factor that is used for mouse events. The actual texture may be a different size, but this is
+		* typically the size of the underlying UI in pixels (not in world space). */
+		EVROverlayError SetOverlayMouseScale( VROverlayHandle_t ulOverlayHandle, const HmdVector2_t *pvecMouseScale ) { return _table.SetOverlayMouseScale(ulOverlayHandle, pvecMouseScale); }
+
+		/** Computes the overlay-space pixel coordinates of where the ray intersects the overlay with the
+		* specified settings. Returns false if there is no intersection. */
+		bool ComputeOverlayIntersection( VROverlayHandle_t ulOverlayHandle, const VROverlayIntersectionParams_t *pParams, VROverlayIntersectionResults_t *pResults ) { return _table.ComputeOverlayIntersection(ulOverlayHandle, pParams, pResults); }
+
+		/** Returns true if the specified overlay is the hover target. An overlay is the hover target when it is the last overlay "moused over" 
+		* by the virtual mouse pointer */
+		bool IsHoverTargetOverlay( VROverlayHandle_t ulOverlayHandle ) { return _table.IsHoverTargetOverlay(ulOverlayHandle); }
+
+		/** Sets a list of primitives to be used for controller ray intersection
+		* typically the size of the underlying UI in pixels (not in world space). */
+		EVROverlayError SetOverlayIntersectionMask( VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t *pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize = sizeof( VROverlayIntersectionMaskPrimitive_t ) ) { return _table.SetOverlayIntersectionMask(ulOverlayHandle, pMaskPrimitives, unNumMaskPrimitives, unPrimitiveSize); }
+
+		/** Triggers a haptic event on the laser mouse controller for the specified overlay */
+		EVROverlayError TriggerLaserMouseHapticVibration( VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude ) { return _table.TriggerLaserMouseHapticVibration(ulOverlayHandle, fDurationSeconds, fFrequency, fAmplitude); }
+
+		/** Sets the cursor to use for the specified overlay. This will be drawn instead of the generic blob when the laser mouse is pointed at the specified overlay */
+		EVROverlayError SetOverlayCursor( VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle ) { return _table.SetOverlayCursor(ulOverlayHandle, ulCursorHandle); }
+
+		/** Sets the override cursor position to use for this overlay in overlay mouse coordinates. This position will be used to draw the cursor
+		* instead of whatever the laser mouse cursor position is. */
+		EVROverlayError SetOverlayCursorPositionOverride( VROverlayHandle_t ulOverlayHandle, const HmdVector2_t *pvCursor ) { return _table.SetOverlayCursorPositionOverride(ulOverlayHandle, pvCursor); }
+
+		/** Clears the override cursor position for this overlay */
+		EVROverlayError ClearOverlayCursorPositionOverride( VROverlayHandle_t ulOverlayHandle ) { return _table.ClearOverlayCursorPositionOverride(ulOverlayHandle); }
+
+		// ---------------------------------------------
+		// Overlay texture methods
+		// ---------------------------------------------
+
+		/** Texture to draw for the overlay. This function can only be called by the overlay's creator or renderer process (see SetOverlayRenderingPid) .
+		*
+		* OpenGL dirty state:
+		*	glBindTexture
+		*/
+		EVROverlayError SetOverlayTexture( VROverlayHandle_t ulOverlayHandle, const Texture_t *pTexture ) { return _table.SetOverlayTexture(ulOverlayHandle, pTexture); }
+
+		/** Use this to tell the overlay system to release the texture set for this overlay. */
+		EVROverlayError ClearOverlayTexture( VROverlayHandle_t ulOverlayHandle ) { return _table.ClearOverlayTexture(ulOverlayHandle); }
+
+		/** Separate interface for providing the data as a stream of bytes, but there is an upper bound on data 
+		* that can be sent. This function can only be called by the overlay's renderer process. */
+		EVROverlayError SetOverlayRaw( VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel ) { return _table.SetOverlayRaw(ulOverlayHandle, pvBuffer, unWidth, unHeight, unBytesPerPixel); }
+
+		/** Separate interface for providing the image through a filename: can be png or jpg, and should not be bigger than 1920x1080.
+		* This function can only be called by the overlay's renderer process */
+		EVROverlayError SetOverlayFromFile( VROverlayHandle_t ulOverlayHandle, const char *pchFilePath ) { return _table.SetOverlayFromFile(ulOverlayHandle, pchFilePath); }
+
+		/** Get the native texture handle/device for an overlay you have created.
+		* On windows this handle will be a ID3D11ShaderResourceView with a ID3D11Texture2D bound.
+		*
+		* The texture will always be sized to match the backing texture you supplied in SetOverlayTexture above.
+		*
+		* You MUST call ReleaseNativeOverlayHandle() with pNativeTextureHandle once you are done with this texture.
+		*
+		* pNativeTextureHandle is an OUTPUT, it will be a pointer to a ID3D11ShaderResourceView *.
+		* pNativeTextureRef is an INPUT and should be a ID3D11Resource *. The device used by pNativeTextureRef will be used to bind pNativeTextureHandle.
+		*/
+		EVROverlayError GetOverlayTexture( VROverlayHandle_t ulOverlayHandle, void **pNativeTextureHandle, void *pNativeTextureRef, uint32_t *pWidth, uint32_t *pHeight, uint32_t *pNativeFormat, ETextureType *pAPIType, EColorSpace *pColorSpace, VRTextureBounds_t *pTextureBounds ) { return _table.GetOverlayTexture(ulOverlayHandle, pNativeTextureHandle, pNativeTextureRef, pWidth, pHeight, pNativeFormat, pAPIType, pColorSpace, pTextureBounds); }
+
+		/** Release the pNativeTextureHandle provided from the GetOverlayTexture call, this allows the system to free the underlying GPU resources for this object,
+		* so only do it once you stop rendering this texture.
+		*/
+		EVROverlayError ReleaseNativeOverlayHandle( VROverlayHandle_t ulOverlayHandle, void *pNativeTextureHandle ) { return _table.ReleaseNativeOverlayHandle(ulOverlayHandle, pNativeTextureHandle); }
+
+		/** Get the size of the overlay texture */
+		EVROverlayError GetOverlayTextureSize( VROverlayHandle_t ulOverlayHandle, uint32_t *pWidth, uint32_t *pHeight ) { return _table.GetOverlayTextureSize(ulOverlayHandle, pWidth, pHeight); }
+
+		// ----------------------------------------------
+		// Dashboard Overlay Methods
+		// ----------------------------------------------
+
+		/** Creates a dashboard overlay and returns its handle */
+		EVROverlayError CreateDashboardOverlay( const char *pchOverlayKey, const char *pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t *pThumbnailHandle ) { return _table.CreateDashboardOverlay(pchOverlayKey, pchOverlayFriendlyName, pMainHandle, pThumbnailHandle); }
+
+		/** Returns true if the dashboard is visible */
+		bool IsDashboardVisible() { return _table.IsDashboardVisible(); }
+
+		/** returns true if the dashboard is visible and the specified overlay is the active system Overlay */
+		bool IsActiveDashboardOverlay( VROverlayHandle_t ulOverlayHandle ) { return _table.IsActiveDashboardOverlay(ulOverlayHandle); }
+
+		/** Sets the dashboard overlay to only appear when the specified process ID has scene focus */
+		EVROverlayError SetDashboardOverlaySceneProcess( VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId ) { return _table.SetDashboardOverlaySceneProcess(ulOverlayHandle, unProcessId); }
+
+		/** Gets the process ID that this dashboard overlay requires to have scene focus */
+		EVROverlayError GetDashboardOverlaySceneProcess( VROverlayHandle_t ulOverlayHandle, uint32_t *punProcessId ) { return _table.GetDashboardOverlaySceneProcess(ulOverlayHandle, punProcessId); }
+
+		/** Shows the dashboard. */
+		void ShowDashboard( const char *pchOverlayToShow ) { _table.ShowDashboard(pchOverlayToShow); }
+
+		/** Returns the tracked device that has the laser pointer in the dashboard */
+		vr::TrackedDeviceIndex_t GetPrimaryDashboardDevice() { return _table.GetPrimaryDashboardDevice(); }
+
+		// ---------------------------------------------
+		// Keyboard methods
+		// ---------------------------------------------
+		
+		/** Show the virtual keyboard to accept input. In most cases, you should pass KeyboardFlag_Modal to enable modal overlay 
+		* behavior on the keyboard itself. See EKeyboardFlags for more. */
+		EVROverlayError ShowKeyboard( EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, 
+			const char *pchDescription, uint32_t unCharMax, const char *pchExistingText, uint64_t uUserValue ) { return _table.ShowKeyboard(eInputMode, eLineInputMode, unFlags, pchDescription, unCharMax, pchExistingText, uUserValue); }
+
+		/** Show the virtual keyboard to accept input for an overlay. In most cases, you should pass KeyboardFlag_Modal to enable modal 
+		* overlay behavior on the keyboard itself. See EKeyboardFlags for more. */
+		EVROverlayError ShowKeyboardForOverlay( VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode,
+			EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char *pchDescription, uint32_t unCharMax, 
+			const char *pchExistingText, uint64_t uUserValue ) { return _table.ShowKeyboardForOverlay(ulOverlayHandle, eInputMode, eLineInputMode, unFlags, pchDescription, unCharMax, pchExistingText, uUserValue); }
+
+		/** Get the text that was entered into the text input **/
+		uint32_t GetKeyboardText( VR_OUT_STRING() char *pchText, uint32_t cchText ) { return _table.GetKeyboardText(pchText, cchText); }
+
+		/** Hide the virtual keyboard **/
+		void HideKeyboard() { _table.HideKeyboard(); }
+
+		/** Set the position of the keyboard in world space **/
+		void SetKeyboardTransformAbsolute( ETrackingUniverseOrigin eTrackingOrigin, const HmdMatrix34_t *pmatTrackingOriginToKeyboardTransform ) { _table.SetKeyboardTransformAbsolute(eTrackingOrigin, pmatTrackingOriginToKeyboardTransform); }
+
+		/** Set the position of the keyboard in overlay space by telling it to avoid a rectangle in the overlay. Rectangle coords have (0,0) in the bottom left **/
+		void SetKeyboardPositionForOverlay( VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect ) { _table.SetKeyboardPositionForOverlay(ulOverlayHandle, avoidRect); }
+
+		// ---------------------------------------------
+		// Message box methods
+		// ---------------------------------------------
+
+		/** Show the message overlay. This will block and return you a result. **/
+		VRMessageOverlayResponse ShowMessageOverlay( const char* pchText, const char* pchCaption, const char* pchButton0Text, const char* pchButton1Text = nullptr, const char* pchButton2Text = nullptr, const char* pchButton3Text = nullptr ) { return _table.ShowMessageOverlay(pchText, pchCaption, pchButton0Text, pchButton1Text, pchButton2Text, pchButton3Text); }
+
+		/** If the calling process owns the overlay and it's open, this will close it. **/
+		void CloseMessageOverlay() { _table.CloseMessageOverlay(); }
+	};
+
+	static const char * const IVROverlay_Version = "FnTable:IVROverlay_024";
+
+} // namespace vr
+
+// ivroverlayview.h
+namespace vr
+{
+	struct VROverlayView_t
+	{
+		VROverlayHandle_t overlayHandle;
+		Texture_t texture;
+		VRTextureBounds_t textureBounds;
+	};
+
+	enum EDeviceType
+	{
+		DeviceType_Invalid           = -1, // Invalid handle
+		DeviceType_DirectX11         = 0, // Handle is an ID3D11Device
+		DeviceType_Vulkan            = 1, // Handle is a pointer to a VRVulkanDevice_t structure
+	};
+
+	struct VRVulkanDevice_t
+	{
+		VkInstance_T *m_pInstance;
+		VkDevice_T *m_pDevice;
+		VkPhysicalDevice_T *m_pPhysicalDevice;
+		VkQueue_T *m_pQueue;
+		uint32_t m_uQueueFamilyIndex;
+	};
+
+	struct VRNativeDevice_t
+	{
+		void *handle; // See EDeviceType definition above
+		EDeviceType eType;
+	};
+
+	struct VR_IVROverlayView_FnTable
+	{
+		EVROverlayError (__stdcall *AcquireOverlayView)(VROverlayHandle_t ulOverlayHandle, VRNativeDevice_t *pNativeDevice, VROverlayView_t *pOverlayView, uint32_t unOverlayViewSize );
+		EVROverlayError (__stdcall *ReleaseOverlayView)(VROverlayView_t *pOverlayView);
+		void (__stdcall *PostOverlayEvent)(VROverlayHandle_t ulOverlayHandle, const VREvent_t *pvrEvent);
+		bool (__stdcall *IsViewingPermitted)( VROverlayHandle_t ulOverlayHandle );
+	};
+
+	class IVROverlayView
+	{
+		VR_IVROverlayView_FnTable _table;
+	public:
+		/** Acquire an OverlayView_t from an overlay handle
+		*
+		* The overlay view can be used to sample the contents directly by a native API. The
+		* contents of the OverlayView_t will remain unchanged through the lifetime of the
+		* OverlayView_t.
+		*
+		* The caller acquires read privileges over the OverlayView_t, but should not
+		* write to it.
+		*
+		* AcquireOverlayView() may be called on the same ulOverlayHandle multiple times to
+		* refresh the image contents. In this case the caller is strongly encouraged to re-use
+		* the same pOverlayView for all re-acquisition calls.
+		*
+		* If the producer has not yet queued an image, AcquireOverlayView will return success,
+		* and the Texture_t will have the expected ETextureType. However, the Texture_t->handle
+		* will be nullptr. Once the producer generates the first overlay frame, Texture_t->handle
+		* will become a valid handle.
+		*/
+		EVROverlayError AcquireOverlayView(VROverlayHandle_t ulOverlayHandle, VRNativeDevice_t *pNativeDevice, VROverlayView_t *pOverlayView, uint32_t unOverlayViewSize ) { return _table.AcquireOverlayView(ulOverlayHandle, pNativeDevice, pOverlayView, unOverlayViewSize); }
+
+		/** Release an acquired OverlayView_t
+		*
+		* Denotes that pOverlayView will no longer require access to the resources it acquired in
+		* all previous calls to AcquireOverlayView().
+		*
+		* All OverlayView_t*'s provided to AcquireOverlayView() as pOverlayViews must be
+		* passed into ReleaseOverlayView() in order for the underlying GPU resources to be freed.
+		*/
+		EVROverlayError ReleaseOverlayView(VROverlayView_t *pOverlayView) { return _table.ReleaseOverlayView(pOverlayView); }
+
+		/** Posts an overlay event */
+		void PostOverlayEvent(VROverlayHandle_t ulOverlayHandle, const VREvent_t *pvrEvent) { _table.PostOverlayEvent(ulOverlayHandle, pvrEvent); }
+
+		/** Determines whether this process is permitted to view an overlay's content. */
+		bool IsViewingPermitted( VROverlayHandle_t ulOverlayHandle ) { return _table.IsViewingPermitted(ulOverlayHandle); }
+
+	};
+
+	static const char * const IVROverlayView_Version = "FnTable:IVROverlayView_003";
+
+}
+
+// ivrrendermodels.h
+namespace vr
+{
+
+static const char * const k_pch_Controller_Component_GDC2015 = "gdc2015";   // Canonical coordinate system of the gdc 2015 wired controller, provided for backwards compatibility
+static const char * const k_pch_Controller_Component_Base = "base";         // For controllers with an unambiguous 'base'.
+static const char * const k_pch_Controller_Component_Tip = "tip";           // For controllers with an unambiguous 'tip' (used for 'laser-pointing')
+static const char * const k_pch_Controller_Component_HandGrip = "handgrip"; // Neutral, ambidextrous hand-pose when holding controller. On plane between neutrally posed index finger and thumb
+static const char * const k_pch_Controller_Component_Status = "status";		// 1:1 aspect ratio status area, with canonical [0,1] uv mapping
+
+#pragma pack( push, 8 )
+
+/** Errors that can occur with the VR compositor */
+enum EVRRenderModelError
+{
+	VRRenderModelError_None = 0,
+	VRRenderModelError_Loading = 100,
+	VRRenderModelError_NotSupported = 200,
+	VRRenderModelError_InvalidArg = 300,
+	VRRenderModelError_InvalidModel = 301,
+	VRRenderModelError_NoShapes = 302,
+	VRRenderModelError_MultipleShapes = 303,
+	VRRenderModelError_TooManyVertices = 304,
+	VRRenderModelError_MultipleTextures = 305,
+	VRRenderModelError_BufferTooSmall = 306,
+	VRRenderModelError_NotEnoughNormals = 307,
+	VRRenderModelError_NotEnoughTexCoords = 308,
+
+	VRRenderModelError_InvalidTexture = 400,
+};
+
+enum EVRRenderModelTextureFormat
+{
+	VRRenderModelTextureFormat_RGBA8_SRGB = 0, // RGBA with 8 bits per channel per pixel. Data size is width * height * 4ub
+	VRRenderModelTextureFormat_BC2,
+	VRRenderModelTextureFormat_BC4,
+	VRRenderModelTextureFormat_BC7,
+	VRRenderModelTextureFormat_BC7_SRGB
+};
+
+/** A single vertex in a render model */
+struct RenderModel_Vertex_t
+{
+	HmdVector3_t vPosition;		// position in meters in device space
+	HmdVector3_t vNormal;
+	float rfTextureCoord[2];
+};
+
+/** A texture map for use on a render model */
+#if defined(__linux__) || defined(__APPLE__) 
+// This structure was originally defined mis-packed on Linux, preserved for 
+// compatibility. 
+#pragma pack( push, 4 )
+#endif
+
+struct RenderModel_TextureMap_t
+{
+	uint16_t unWidth, unHeight; // width and height of the texture map in pixels
+	const uint8_t *rubTextureMapData;	// Map texture data.
+	EVRRenderModelTextureFormat format; // Refer to EVRRenderModelTextureFormat
+};
+#if defined(__linux__) || defined(__APPLE__) 
+#pragma pack( pop )
+#endif
+
+/**  Session unique texture identifier. Rendermodels which share the same texture will have the same id.
+IDs <0 denote the texture is not present */
+
+typedef int32_t TextureID_t;
+
+const TextureID_t INVALID_TEXTURE_ID = -1;
+
+#if defined(__linux__) || defined(__APPLE__) 
+// This structure was originally defined mis-packed on Linux, preserved for 
+// compatibility. 
+#pragma pack( push, 4 )
+#endif
+
+struct RenderModel_t
+{
+	const RenderModel_Vertex_t *rVertexData;	// Vertex data for the mesh
+	uint32_t unVertexCount;						// Number of vertices in the vertex data
+	const uint16_t *rIndexData;					// Indices into the vertex data for each triangle
+	uint32_t unTriangleCount;					// Number of triangles in the mesh. Index count is 3 * TriangleCount
+	TextureID_t diffuseTextureId;				// Session unique texture identifier. Rendermodels which share the same texture will have the same id. <0 == texture not present
+};
+#if defined(__linux__) || defined(__APPLE__) 
+#pragma pack( pop )
+#endif
+
+
+struct RenderModel_ControllerMode_State_t
+{
+	bool bScrollWheelVisible; // is this controller currently set to be in a scroll wheel mode
+};
+
+#pragma pack( pop )
+
+struct VR_IVRRenderModels_FnTable
+{
+	EVRRenderModelError (__stdcall *LoadRenderModel_Async)( const char *pchRenderModelName, RenderModel_t **ppRenderModel );
+	void (__stdcall *FreeRenderModel)( RenderModel_t *pRenderModel );
+	EVRRenderModelError (__stdcall *LoadTexture_Async)( TextureID_t textureId, RenderModel_TextureMap_t **ppTexture );
+	void (__stdcall *FreeTexture)( RenderModel_TextureMap_t *pTexture );
+	EVRRenderModelError (__stdcall *LoadTextureD3D11_Async)( TextureID_t textureId, void *pD3D11Device, void **ppD3D11Texture2D );
+	EVRRenderModelError (__stdcall *LoadIntoTextureD3D11_Async)( TextureID_t textureId, void *pDstTexture );
+	void (__stdcall *FreeTextureD3D11)( void *pD3D11Texture2D );
+	uint32_t (__stdcall *GetRenderModelName)( uint32_t unRenderModelIndex,  char *pchRenderModelName, uint32_t unRenderModelNameLen );
+	uint32_t (__stdcall *GetRenderModelCount)();
+	uint32_t (__stdcall *GetComponentCount)( const char *pchRenderModelName );
+	uint32_t (__stdcall *GetComponentName)( const char *pchRenderModelName, uint32_t unComponentIndex,  char *pchComponentName, uint32_t unComponentNameLen );
+	uint64_t (__stdcall *GetComponentButtonMask)( const char *pchRenderModelName, const char *pchComponentName );
+	uint32_t (__stdcall *GetComponentRenderModelName)( const char *pchRenderModelName, const char *pchComponentName,  char *pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen );
+	bool (__stdcall *GetComponentStateForDevicePath)( const char *pchRenderModelName, const char *pchComponentName, vr::VRInputValueHandle_t devicePath, const vr::RenderModel_ControllerMode_State_t *pState, vr::RenderModel_ComponentState_t *pComponentState );
+	bool (__stdcall *GetComponentState)( const char *pchRenderModelName, const char *pchComponentName, const vr::VRControllerState_t *pControllerState, const RenderModel_ControllerMode_State_t *pState, RenderModel_ComponentState_t *pComponentState );
+	bool (__stdcall *RenderModelHasComponent)( const char *pchRenderModelName, const char *pchComponentName );
+	uint32_t (__stdcall *GetRenderModelThumbnailURL)( const char *pchRenderModelName,  char *pchThumbnailURL, uint32_t unThumbnailURLLen, vr::EVRRenderModelError *peError );
+	uint32_t (__stdcall *GetRenderModelOriginalPath)( const char *pchRenderModelName,  char *pchOriginalPath, uint32_t unOriginalPathLen, vr::EVRRenderModelError *peError );
+	const char *(__stdcall *GetRenderModelErrorNameFromEnum)( vr::EVRRenderModelError error );
+};
+
+class IVRRenderModels
+{
+	VR_IVRRenderModels_FnTable _table;
+public:
+
+	/** Loads and returns a render model for use in the application. pchRenderModelName should be a render model name
+	* from the Prop_RenderModelName_String property or an absolute path name to a render model on disk. 
+	*
+	* The resulting render model is valid until VR_Shutdown() is called or until FreeRenderModel() is called. When the 
+	* application is finished with the render model it should call FreeRenderModel() to free the memory associated
+	* with the model.
+	*
+	* The method returns VRRenderModelError_Loading while the render model is still being loaded.
+	* The method returns VRRenderModelError_None once loaded successfully, otherwise will return an error. */
+	EVRRenderModelError LoadRenderModel_Async( const char *pchRenderModelName, RenderModel_t **ppRenderModel ) { return _table.LoadRenderModel_Async(pchRenderModelName, ppRenderModel); }
+
+	/** Frees a previously returned render model
+	*   It is safe to call this on a null ptr. */
+	void FreeRenderModel( RenderModel_t *pRenderModel ) { _table.FreeRenderModel(pRenderModel); }
+
+	/** Loads and returns a texture for use in the application. */
+	EVRRenderModelError LoadTexture_Async( TextureID_t textureId, RenderModel_TextureMap_t **ppTexture ) { return _table.LoadTexture_Async(textureId, ppTexture); }
+
+	/** Frees a previously returned texture
+	*   It is safe to call this on a null ptr. */
+	void FreeTexture( RenderModel_TextureMap_t *pTexture ) { _table.FreeTexture(pTexture); }
+
+	/** Creates a D3D11 texture and loads data into it. */
+	EVRRenderModelError LoadTextureD3D11_Async( TextureID_t textureId, void *pD3D11Device, void **ppD3D11Texture2D ) { return _table.LoadTextureD3D11_Async(textureId, pD3D11Device, ppD3D11Texture2D); }
+
+	/** Helper function to copy the bits into an existing texture. */
+	EVRRenderModelError LoadIntoTextureD3D11_Async( TextureID_t textureId, void *pDstTexture ) { return _table.LoadIntoTextureD3D11_Async(textureId, pDstTexture); }
+
+	/** Use this to free textures created with LoadTextureD3D11_Async instead of calling Release on them. */
+	void FreeTextureD3D11( void *pD3D11Texture2D ) { _table.FreeTextureD3D11(pD3D11Texture2D); }
+
+	/** Use this to get the names of available render models.  Index does not correlate to a tracked device index, but
+	* is only used for iterating over all available render models.  If the index is out of range, this function will return 0.
+	* Otherwise, it will return the size of the buffer required for the name. */
+	uint32_t GetRenderModelName( uint32_t unRenderModelIndex, VR_OUT_STRING() char *pchRenderModelName, uint32_t unRenderModelNameLen ) { return _table.GetRenderModelName(unRenderModelIndex, pchRenderModelName, unRenderModelNameLen); }
+
+	/** Returns the number of available render models. */
+	uint32_t GetRenderModelCount() { return _table.GetRenderModelCount(); }
+
+
+	/** Returns the number of components of the specified render model.
+	*  Components are useful when client application wish to draw, label, or otherwise interact with components of tracked objects.
+	*  Examples controller components:
+	*   renderable things such as triggers, buttons
+	*   non-renderable things which include coordinate systems such as 'tip', 'base', a neutral controller agnostic hand-pose
+	*   If all controller components are enumerated and rendered, it will be equivalent to drawing the traditional render model
+	*   Returns 0 if components not supported, >0 otherwise */
+	uint32_t GetComponentCount( const char *pchRenderModelName ) { return _table.GetComponentCount(pchRenderModelName); }
+
+	/** Use this to get the names of available components.  Index does not correlate to a tracked device index, but
+	* is only used for iterating over all available components.  If the index is out of range, this function will return 0.
+	* Otherwise, it will return the size of the buffer required for the name. */
+	uint32_t GetComponentName( const char *pchRenderModelName, uint32_t unComponentIndex, VR_OUT_STRING( ) char *pchComponentName, uint32_t unComponentNameLen ) { return _table.GetComponentName(pchRenderModelName, unComponentIndex, pchComponentName, unComponentNameLen); }
+
+	/** Get the button mask for all buttons associated with this component
+	*   If no buttons (or axes) are associated with this component, return 0
+	*   Note: multiple components may be associated with the same button. Ex: two grip buttons on a single controller.
+	*   Note: A single component may be associated with multiple buttons. Ex: A trackpad which also provides "D-pad" functionality */
+	uint64_t GetComponentButtonMask( const char *pchRenderModelName, const char *pchComponentName ) { return _table.GetComponentButtonMask(pchRenderModelName, pchComponentName); }
+
+	/** Use this to get the render model name for the specified rendermode/component combination, to be passed to LoadRenderModel.
+	* If the component name is out of range, this function will return 0.
+	* Otherwise, it will return the size of the buffer required for the name. */
+	uint32_t GetComponentRenderModelName( const char *pchRenderModelName, const char *pchComponentName, VR_OUT_STRING( ) char *pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen ) { return _table.GetComponentRenderModelName(pchRenderModelName, pchComponentName, pchComponentRenderModelName, unComponentRenderModelNameLen); }
+
+	/** Use this to query information about the component, as a function of the controller state.
+	*
+	* For dynamic controller components (ex: trigger) values will reflect component motions
+	* For static components this will return a consistent value independent of the VRControllerState_t
+	*
+	* If the pchRenderModelName or pchComponentName is invalid, this will return false (and transforms will be set to identity).
+	* Otherwise, return true
+	* Note: For dynamic objects, visibility may be dynamic. (I.e., true/false will be returned based on controller state and controller mode state ) */
+	bool GetComponentStateForDevicePath( const char *pchRenderModelName, const char *pchComponentName, vr::VRInputValueHandle_t devicePath, const vr::RenderModel_ControllerMode_State_t *pState, vr::RenderModel_ComponentState_t *pComponentState ) { return _table.GetComponentStateForDevicePath(pchRenderModelName, pchComponentName, devicePath, pState, pComponentState); }
+
+	/** This version of GetComponentState takes a controller state block instead of an action origin. This function is deprecated. You should use the new input system and GetComponentStateForDevicePath instead. */
+	bool GetComponentState( const char *pchRenderModelName, const char *pchComponentName, const vr::VRControllerState_t *pControllerState, const RenderModel_ControllerMode_State_t *pState, RenderModel_ComponentState_t *pComponentState ) { return _table.GetComponentState(pchRenderModelName, pchComponentName, pControllerState, pState, pComponentState); }
+
+	/** Returns true if the render model has a component with the specified name */
+	bool RenderModelHasComponent( const char *pchRenderModelName, const char *pchComponentName ) { return _table.RenderModelHasComponent(pchRenderModelName, pchComponentName); }
+
+	/** Returns the URL of the thumbnail image for this rendermodel */
+	uint32_t GetRenderModelThumbnailURL( const char *pchRenderModelName, VR_OUT_STRING() char *pchThumbnailURL, uint32_t unThumbnailURLLen, vr::EVRRenderModelError *peError ) { return _table.GetRenderModelThumbnailURL(pchRenderModelName, pchThumbnailURL, unThumbnailURLLen, peError); }
+
+	/** Provides a render model path that will load the unskinned model if the model name provided has been replace by the user. If the model
+	* hasn't been replaced the path value will still be a valid path to load the model. Pass this to LoadRenderModel_Async, etc. to load the
+	* model. */
+	uint32_t GetRenderModelOriginalPath( const char *pchRenderModelName, VR_OUT_STRING() char *pchOriginalPath, uint32_t unOriginalPathLen, vr::EVRRenderModelError *peError ) { return _table.GetRenderModelOriginalPath(pchRenderModelName, pchOriginalPath, unOriginalPathLen, peError); }
+
+	/** Returns a string for a render model error */
+	const char *GetRenderModelErrorNameFromEnum( vr::EVRRenderModelError error ) { return _table.GetRenderModelErrorNameFromEnum(error); }
+};
+
+static const char * const IVRRenderModels_Version = "FnTable:IVRRenderModels_006";
+
+}
+
+
+// ivrextendeddisplay.h
+namespace vr
+{
+
+	/** NOTE: Use of this interface is not recommended in production applications. It will not work for displays which use
+	* direct-to-display mode. Creating our own window is also incompatible with the VR compositor and is not available when the compositor is running. */
+	struct VR_IVRExtendedDisplay_FnTable
+	{
+		void (__stdcall *GetWindowBounds)( int32_t *pnX, int32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight );
+		void (__stdcall *GetEyeOutputViewport)( EVREye eEye, uint32_t *pnX, uint32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight );
+		void (__stdcall *GetDXGIOutputInfo)( int32_t *pnAdapterIndex, int32_t *pnAdapterOutputIndex );
+	};
+
+	class IVRExtendedDisplay
+	{
+		VR_IVRExtendedDisplay_FnTable _table;
+	public:
+
+		/** Size and position that the window needs to be on the VR display. */
+		void GetWindowBounds( int32_t *pnX, int32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight ) { _table.GetWindowBounds(pnX, pnY, pnWidth, pnHeight); }
+
+		/** Gets the viewport in the frame buffer to draw the output of the distortion into */
+		void GetEyeOutputViewport( EVREye eEye, uint32_t *pnX, uint32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight ) { _table.GetEyeOutputViewport(eEye, pnX, pnY, pnWidth, pnHeight); }
+
+		/** [D3D10/11 Only]
+		* Returns the adapter index and output index that the user should pass into EnumAdapters and EnumOutputs
+		* to create the device and swap chain in DX10 and DX11. If an error occurs both indices will be set to -1.
+		*/
+		void GetDXGIOutputInfo( int32_t *pnAdapterIndex, int32_t *pnAdapterOutputIndex ) { _table.GetDXGIOutputInfo(pnAdapterIndex, pnAdapterOutputIndex); }
+
+	};
+
+	static const char * const IVRExtendedDisplay_Version = "FnTable:IVRExtendedDisplay_001";
+
+}
+
+
+// ivrtrackedcamera.h
+namespace vr
+{
+
+struct VR_IVRTrackedCamera_FnTable
+{
+	const char *(__stdcall *GetCameraErrorNameFromEnum)( vr::EVRTrackedCameraError eCameraError );
+	vr::EVRTrackedCameraError (__stdcall *HasCamera)( vr::TrackedDeviceIndex_t nDeviceIndex, bool *pHasCamera );
+	vr::EVRTrackedCameraError (__stdcall *GetCameraFrameSize)( vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, uint32_t *pnWidth, uint32_t *pnHeight, uint32_t *pnFrameBufferSize );
+	vr::EVRTrackedCameraError (__stdcall *GetCameraIntrinsics)( vr::TrackedDeviceIndex_t nDeviceIndex, uint32_t nCameraIndex, vr::EVRTrackedCameraFrameType eFrameType, vr::HmdVector2_t *pFocalLength, vr::HmdVector2_t *pCenter );
+	vr::EVRTrackedCameraError (__stdcall *GetCameraProjection)( vr::TrackedDeviceIndex_t nDeviceIndex, uint32_t nCameraIndex, vr::EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, vr::HmdMatrix44_t *pProjection );
+	vr::EVRTrackedCameraError (__stdcall *AcquireVideoStreamingService)( vr::TrackedDeviceIndex_t nDeviceIndex, vr::TrackedCameraHandle_t *pHandle );
+	vr::EVRTrackedCameraError (__stdcall *ReleaseVideoStreamingService)( vr::TrackedCameraHandle_t hTrackedCamera );
+	vr::EVRTrackedCameraError (__stdcall *GetVideoStreamFrameBuffer)( vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, void *pFrameBuffer, uint32_t nFrameBufferSize, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize );
+	vr::EVRTrackedCameraError (__stdcall *GetVideoStreamTextureSize)( vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, vr::VRTextureBounds_t *pTextureBounds, uint32_t *pnWidth, uint32_t *pnHeight );
+	vr::EVRTrackedCameraError (__stdcall *GetVideoStreamTextureD3D11)( vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize );
+	vr::EVRTrackedCameraError (__stdcall *GetVideoStreamTextureGL)( vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, vr::glUInt_t *pglTextureId, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize );
+	vr::EVRTrackedCameraError (__stdcall *ReleaseVideoStreamTextureGL)( vr::TrackedCameraHandle_t hTrackedCamera, vr::glUInt_t glTextureId );
+	void (__stdcall *SetCameraTrackingSpace)( vr::ETrackingUniverseOrigin eUniverse );
+	vr::ETrackingUniverseOrigin (__stdcall *GetCameraTrackingSpace)( );
+};
+
+class IVRTrackedCamera
+{
+	VR_IVRTrackedCamera_FnTable _table;
+public:
+	/** Returns a string for an error */
+	const char *GetCameraErrorNameFromEnum( vr::EVRTrackedCameraError eCameraError ) { return _table.GetCameraErrorNameFromEnum(eCameraError); }
+
+	/** For convenience, same as tracked property request Prop_HasCamera_Bool */
+	vr::EVRTrackedCameraError HasCamera( vr::TrackedDeviceIndex_t nDeviceIndex, bool *pHasCamera ) { return _table.HasCamera(nDeviceIndex, pHasCamera); }
+
+	/** Gets size of the image frame. */
+	vr::EVRTrackedCameraError GetCameraFrameSize( vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, uint32_t *pnWidth, uint32_t *pnHeight, uint32_t *pnFrameBufferSize ) { return _table.GetCameraFrameSize(nDeviceIndex, eFrameType, pnWidth, pnHeight, pnFrameBufferSize); }
+
+	vr::EVRTrackedCameraError GetCameraIntrinsics( vr::TrackedDeviceIndex_t nDeviceIndex, uint32_t nCameraIndex, vr::EVRTrackedCameraFrameType eFrameType, vr::HmdVector2_t *pFocalLength, vr::HmdVector2_t *pCenter ) { return _table.GetCameraIntrinsics(nDeviceIndex, nCameraIndex, eFrameType, pFocalLength, pCenter); }
+
+	vr::EVRTrackedCameraError GetCameraProjection( vr::TrackedDeviceIndex_t nDeviceIndex, uint32_t nCameraIndex, vr::EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, vr::HmdMatrix44_t *pProjection ) { return _table.GetCameraProjection(nDeviceIndex, nCameraIndex, eFrameType, flZNear, flZFar, pProjection); }
+
+	/** Acquiring streaming service permits video streaming for the caller. Releasing hints the system that video services do not need to be maintained for this client.
+	* If the camera has not already been activated, a one time spin up may incur some auto exposure as well as initial streaming frame delays.
+	* The camera should be considered a global resource accessible for shared consumption but not exclusive to any caller.
+	* The camera may go inactive due to lack of active consumers or headset idleness. */
+	vr::EVRTrackedCameraError AcquireVideoStreamingService( vr::TrackedDeviceIndex_t nDeviceIndex, vr::TrackedCameraHandle_t *pHandle ) { return _table.AcquireVideoStreamingService(nDeviceIndex, pHandle); }
+	vr::EVRTrackedCameraError ReleaseVideoStreamingService( vr::TrackedCameraHandle_t hTrackedCamera ) { return _table.ReleaseVideoStreamingService(hTrackedCamera); }
+
+	/** Copies the image frame into a caller's provided buffer. The image data is currently provided as RGBA data, 4 bytes per pixel.
+	* A caller can provide null for the framebuffer or frameheader if not desired. Requesting the frame header first, followed by the frame buffer allows
+	* the caller to determine if the frame as advanced per the frame header sequence. 
+	* If there is no frame available yet, due to initial camera spinup or re-activation, the error will be VRTrackedCameraError_NoFrameAvailable.
+	* Ideally a caller should be polling at ~16ms intervals */
+	vr::EVRTrackedCameraError GetVideoStreamFrameBuffer( vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, void *pFrameBuffer, uint32_t nFrameBufferSize, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize ) { return _table.GetVideoStreamFrameBuffer(hTrackedCamera, eFrameType, pFrameBuffer, nFrameBufferSize, pFrameHeader, nFrameHeaderSize); }
+
+	/** Gets size of the image frame. */
+	vr::EVRTrackedCameraError GetVideoStreamTextureSize( vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, vr::VRTextureBounds_t *pTextureBounds, uint32_t *pnWidth, uint32_t *pnHeight ) { return _table.GetVideoStreamTextureSize(nDeviceIndex, eFrameType, pTextureBounds, pnWidth, pnHeight); }
+
+	/** Access a shared D3D11 texture for the specified tracked camera stream.
+	* The camera frame type VRTrackedCameraFrameType_Undistorted is not supported directly as a shared texture. It is an interior subregion of the shared texture VRTrackedCameraFrameType_MaximumUndistorted.
+	* Instead, use GetVideoStreamTextureSize() with VRTrackedCameraFrameType_Undistorted to determine the proper interior subregion bounds along with GetVideoStreamTextureD3D11() with
+	* VRTrackedCameraFrameType_MaximumUndistorted to provide the texture. The VRTrackedCameraFrameType_MaximumUndistorted will yield an image where the invalid regions are decoded
+	* by the alpha channel having a zero component. The valid regions all have a non-zero alpha component. The subregion as described by VRTrackedCameraFrameType_Undistorted 
+	* guarantees a rectangle where all pixels are valid. */
+	vr::EVRTrackedCameraError GetVideoStreamTextureD3D11( vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize ) { return _table.GetVideoStreamTextureD3D11(hTrackedCamera, eFrameType, pD3D11DeviceOrResource, ppD3D11ShaderResourceView, pFrameHeader, nFrameHeaderSize); }
+
+	/** Access a shared GL texture for the specified tracked camera stream */
+	vr::EVRTrackedCameraError GetVideoStreamTextureGL( vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, vr::glUInt_t *pglTextureId, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize ) { return _table.GetVideoStreamTextureGL(hTrackedCamera, eFrameType, pglTextureId, pFrameHeader, nFrameHeaderSize); }
+	vr::EVRTrackedCameraError ReleaseVideoStreamTextureGL( vr::TrackedCameraHandle_t hTrackedCamera, vr::glUInt_t glTextureId ) { return _table.ReleaseVideoStreamTextureGL(hTrackedCamera, glTextureId); }
+	void SetCameraTrackingSpace( vr::ETrackingUniverseOrigin eUniverse ) { _table.SetCameraTrackingSpace(eUniverse); }
+	vr::ETrackingUniverseOrigin GetCameraTrackingSpace( ) { return _table.GetCameraTrackingSpace(); }
+};
+
+static const char * const IVRTrackedCamera_Version = "FnTable:IVRTrackedCamera_006";
+
+} // namespace vr
+
+
+// ivrscreenshots.h
+namespace vr
+{
+
+/** Errors that can occur with the VR compositor */
+enum EVRScreenshotError
+{
+	VRScreenshotError_None							= 0,
+	VRScreenshotError_RequestFailed					= 1,
+	VRScreenshotError_IncompatibleVersion			= 100,
+	VRScreenshotError_NotFound						= 101,
+	VRScreenshotError_BufferTooSmall				= 102,
+	VRScreenshotError_ScreenshotAlreadyInProgress	= 108,
+};
+
+/** Allows the application to generate screenshots */
+struct VR_IVRScreenshots_FnTable
+{
+	vr::EVRScreenshotError (__stdcall *RequestScreenshot)( vr::ScreenshotHandle_t *pOutScreenshotHandle, vr::EVRScreenshotType type, const char *pchPreviewFilename, const char *pchVRFilename );
+	vr::EVRScreenshotError (__stdcall *HookScreenshot)(  const vr::EVRScreenshotType *pSupportedTypes, int numTypes );
+	vr::EVRScreenshotType (__stdcall *GetScreenshotPropertyType)( vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotError *pError );
+	uint32_t (__stdcall *GetScreenshotPropertyFilename)( vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotPropertyFilenames filenameType,  char *pchFilename, uint32_t cchFilename, vr::EVRScreenshotError *pError );
+	vr::EVRScreenshotError (__stdcall *UpdateScreenshotProgress)( vr::ScreenshotHandle_t screenshotHandle, float flProgress );
+	vr::EVRScreenshotError (__stdcall *TakeStereoScreenshot)( vr::ScreenshotHandle_t *pOutScreenshotHandle, const char *pchPreviewFilename, const char *pchVRFilename );
+	vr::EVRScreenshotError (__stdcall *SubmitScreenshot)( vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotType type, const char *pchSourcePreviewFilename, const char *pchSourceVRFilename );
+};
+
+class IVRScreenshots
+{
+	VR_IVRScreenshots_FnTable _table;
+public:
+	/** Request a screenshot of the requested type.
+	 *  A request of the VRScreenshotType_Stereo type will always
+	 *  work. Other types will depend on the underlying application
+	 *  support.
+	 *  The first file name is for the preview image and should be a
+	 *  regular screenshot (ideally from the left eye). The second
+	 *  is the VR screenshot in the correct format. They should be
+	 *  in the same aspect ratio.  Formats per type:
+	 *  VRScreenshotType_Mono: the VR filename is ignored (can be
+	 *  nullptr), this is a normal flat single shot.
+	 *  VRScreenshotType_Stereo:  The VR image should be a
+	 *  side-by-side with the left eye image on the left.
+	 *  VRScreenshotType_Cubemap: The VR image should be six square
+	 *  images composited horizontally.
+	 *  VRScreenshotType_StereoPanorama: above/below with left eye
+	 *  panorama being the above image.  Image is typically square
+	 *  with the panorama being 2x horizontal.
+	 *  
+	 *  Note that the VR dashboard will call this function when
+	 *  the user presses the screenshot binding (currently System
+	 *  Button + Trigger).  If Steam is running, the destination
+	 *  file names will be in %TEMP% and will be copied into
+	 *  Steam's screenshot library for the running application
+	 *  once SubmitScreenshot() is called.
+	 *  If Steam is not running, the paths will be in the user's
+	 *  documents folder under Documents\SteamVR\Screenshots.
+	 *  Other VR applications can call this to initiate a
+	 *  screenshot outside of user control.
+	 *  The destination file names do not need an extension,
+	 *  will be replaced with the correct one for the format
+	 *  which is currently .png. */
+	vr::EVRScreenshotError RequestScreenshot( vr::ScreenshotHandle_t *pOutScreenshotHandle, vr::EVRScreenshotType type, const char *pchPreviewFilename, const char *pchVRFilename ) { return _table.RequestScreenshot(pOutScreenshotHandle, type, pchPreviewFilename, pchVRFilename); }
+
+	/** Called by the running VR application to indicate that it
+	 *  wishes to be in charge of screenshots.  If the
+	 *  application does not call this, the Compositor will only
+	 *  support VRScreenshotType_Stereo screenshots that will be
+	 *  captured without notification to the running app.
+	 *  Once hooked your application will receive a
+	 *  VREvent_RequestScreenshot event when the user presses the
+	 *  buttons to take a screenshot. */
+	vr::EVRScreenshotError HookScreenshot( VR_ARRAY_COUNT( numTypes ) const vr::EVRScreenshotType *pSupportedTypes, int numTypes ) { return _table.HookScreenshot(pSupportedTypes, numTypes); }
+
+	/** When your application receives a
+	 *  VREvent_RequestScreenshot event, call these functions to get
+	 *  the details of the screenshot request. */
+	vr::EVRScreenshotType GetScreenshotPropertyType( vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotError *pError ) { return _table.GetScreenshotPropertyType(screenshotHandle, pError); }
+
+	/** Get the filename for the preview or vr image (see
+	 *  vr::EScreenshotPropertyFilenames).  The return value is
+	 *  the size of the string.   */
+	uint32_t GetScreenshotPropertyFilename( vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotPropertyFilenames filenameType, VR_OUT_STRING() char *pchFilename, uint32_t cchFilename, vr::EVRScreenshotError *pError ) { return _table.GetScreenshotPropertyFilename(screenshotHandle, filenameType, pchFilename, cchFilename, pError); }
+
+	/** Call this if the application is taking the screen shot
+	 *  will take more than a few ms processing. This will result
+	 *  in an overlay being presented that shows a completion
+	 *  bar. */
+	vr::EVRScreenshotError UpdateScreenshotProgress( vr::ScreenshotHandle_t screenshotHandle, float flProgress ) { return _table.UpdateScreenshotProgress(screenshotHandle, flProgress); }
+
+	/** Tells the compositor to take an internal screenshot of
+	 *  type VRScreenshotType_Stereo. It will take the current
+	 *  submitted scene textures of the running application and
+	 *  write them into the preview image and a side-by-side file
+	 *  for the VR image.
+	 *  This is similar to request screenshot, but doesn't ever
+	 *  talk to the application, just takes the shot and submits. */
+	vr::EVRScreenshotError TakeStereoScreenshot( vr::ScreenshotHandle_t *pOutScreenshotHandle, const char *pchPreviewFilename, const char *pchVRFilename ) { return _table.TakeStereoScreenshot(pOutScreenshotHandle, pchPreviewFilename, pchVRFilename); }
+
+	/** Submit the completed screenshot.  If Steam is running
+	 *  this will call into the Steam client and upload the
+	 *  screenshot to the screenshots section of the library for
+	 *  the running application.  If Steam is not running, this
+	 *  function will display a notification to the user that the
+	 *  screenshot was taken. The paths should be full paths with
+	 *  extensions.
+	 *  File paths should be absolute including extensions.
+	 *  screenshotHandle can be k_unScreenshotHandleInvalid if this
+	 *  was a new shot taking by the app to be saved and not
+	 *  initiated by a user (achievement earned or something) */
+	vr::EVRScreenshotError SubmitScreenshot( vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotType type, const char *pchSourcePreviewFilename, const char *pchSourceVRFilename ) { return _table.SubmitScreenshot(screenshotHandle, type, pchSourcePreviewFilename, pchSourceVRFilename); }
+};
+
+static const char * const IVRScreenshots_Version = "FnTable:IVRScreenshots_001";
+
+} // namespace vr
+
+
+
+// ivrresources.h
+namespace vr
+{
+
+struct VR_IVRResources_FnTable
+{
+	uint32_t (__stdcall *LoadSharedResource)( const char *pchResourceName, char *pchBuffer, uint32_t unBufferLen );
+	uint32_t (__stdcall *GetResourceFullPath)( const char *pchResourceName, const char *pchResourceTypeDirectory,  char *pchPathBuffer, uint32_t unBufferLen );
+};
+
+class IVRResources
+{
+	VR_IVRResources_FnTable _table;
+public:
+
+	// ------------------------------------
+	// Shared Resource Methods
+	// ------------------------------------
+
+	/** Loads the specified resource into the provided buffer if large enough.
+	* Returns the size in bytes of the buffer required to hold the specified resource. */
+	uint32_t LoadSharedResource( const char *pchResourceName, char *pchBuffer, uint32_t unBufferLen ) { return _table.LoadSharedResource(pchResourceName, pchBuffer, unBufferLen); }
+
+	/** Provides the full path to the specified resource. Resource names can include named directories for
+	* drivers and other things, and this resolves all of those and returns the actual physical path. 
+	* pchResourceTypeDirectory is the subdirectory of resources to look in. */
+	uint32_t GetResourceFullPath( const char *pchResourceName, const char *pchResourceTypeDirectory, VR_OUT_STRING() char *pchPathBuffer, uint32_t unBufferLen ) { return _table.GetResourceFullPath(pchResourceName, pchResourceTypeDirectory, pchPathBuffer, unBufferLen); }
+};
+
+static const char * const IVRResources_Version = "FnTable:IVRResources_001";
+
+
+}
+// ivrdrivermanager.h
+namespace vr
+{
+
+struct VR_IVRDriverManager_FnTable
+{
+	uint32_t (__stdcall *GetDriverName)( vr::DriverId_t nDriver,  char *pchValue, uint32_t unBufferSize );
+	DriverHandle_t (__stdcall *GetDriverHandle)( const char *pchDriverName );
+};
+
+class IVRDriverManager
+{
+	VR_IVRDriverManager_FnTable _table;
+public:
+	virtual uint32_t GetDriverCount() const = 0;
+
+	/** Returns the length of the number of bytes necessary to hold this string including the trailing null. */
+	uint32_t GetDriverName( vr::DriverId_t nDriver, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize ) { return _table.GetDriverName(nDriver, pchValue, unBufferSize); }
+
+	DriverHandle_t GetDriverHandle( const char *pchDriverName ) { return _table.GetDriverHandle(pchDriverName); }
+
+	virtual bool IsEnabled( vr::DriverId_t nDriver ) const = 0;
+};
+
+static const char * const IVRDriverManager_Version = "FnTable:IVRDriverManager_001";
+
+} // namespace vr
+
+
+
+// ivrinput.h
+namespace vr
+{
+	// Maximum number of characters in an action name, including the trailing null
+	static const uint32_t k_unMaxActionNameLength = 64; 
+
+	// Maximum number of characters in an action set name, including the trailing null
+	static const uint32_t k_unMaxActionSetNameLength = 64;
+
+	// Maximum number of origins for an action
+	static const uint32_t k_unMaxActionOriginCount = 16; 
+
+	// Maximum number of characters in a bone name, including the trailing null
+	static const uint32_t k_unMaxBoneNameLength = 32; 
+
+	enum EVRSkeletalTransformSpace
+	{
+		VRSkeletalTransformSpace_Model = 0, 
+		VRSkeletalTransformSpace_Parent = 1
+	};
+
+	enum EVRSkeletalReferencePose
+	{
+		VRSkeletalReferencePose_BindPose = 0,
+		VRSkeletalReferencePose_OpenHand,
+		VRSkeletalReferencePose_Fist,
+		VRSkeletalReferencePose_GripLimit
+	};
+
+	enum EVRFinger
+	{
+		VRFinger_Thumb = 0,
+		VRFinger_Index,
+		VRFinger_Middle,
+		VRFinger_Ring,
+		VRFinger_Pinky,
+		VRFinger_Count
+	};
+
+	enum EVRFingerSplay
+	{
+		VRFingerSplay_Thumb_Index = 0,
+		VRFingerSplay_Index_Middle,
+		VRFingerSplay_Middle_Ring,
+		VRFingerSplay_Ring_Pinky,
+		VRFingerSplay_Count
+	};
+
+	enum EVRSummaryType
+	{
+		// The skeletal summary data will match the animated bone transforms for the action.
+		VRSummaryType_FromAnimation = 0,	
+		
+		// The skeletal summary data will include unprocessed data directly from the device when available. 
+		// This data is generally less latent than the data that is computed from the animations.
+		VRSummaryType_FromDevice = 1,		
+	};
+
+	enum EVRInputFilterCancelType
+	{
+		VRInputFilterCancel_Timers = 0,
+		VRInputFilterCancel_Momentum = 1,
+	};
+
+	enum EVRInputStringBits
+	{
+		VRInputString_Hand = 0x01,
+		VRInputString_ControllerType = 0x02,
+		VRInputString_InputSource = 0x04,
+
+		VRInputString_All = 0xFFFFFFFF
+	};
+
+	struct InputAnalogActionData_t
+	{
+		/** Whether or not this action is currently available to be bound in the active action set */
+		bool bActive;
+
+		/** The origin that caused this action's current state */
+		VRInputValueHandle_t activeOrigin;
+
+		/** The current state of this action; will be delta updates for mouse actions */
+		float x, y, z;
+
+		/** Deltas since the previous call to UpdateActionState() */
+		float deltaX, deltaY, deltaZ;
+	
+		/** Time relative to now when this event happened. Will be negative to indicate a past time. */
+		float fUpdateTime;
+	};
+
+	struct InputDigitalActionData_t
+	{
+		/** Whether or not this action is currently available to be bound in the active action set */
+		bool bActive;
+
+		/** The origin that caused this action's current state */
+		VRInputValueHandle_t activeOrigin;
+
+		/** The current state of this action; will be true if currently pressed */
+		bool bState;
+
+		/** This is true if the state has changed since the last frame */
+		bool bChanged;
+
+		/** Time relative to now when this event happened. Will be negative to indicate a past time. */
+		float fUpdateTime;
+	};
+
+	struct InputPoseActionData_t
+	{
+		/** Whether or not this action is currently available to be bound in the active action set */
+		bool bActive;
+
+		/** The origin that caused this action's current state */
+		VRInputValueHandle_t activeOrigin;
+
+		/** The current state of this action */
+		TrackedDevicePose_t pose;
+	};
+
+	struct InputSkeletalActionData_t
+	{
+		/** Whether or not this action is currently available to be bound in the active action set */
+		bool bActive;
+
+		/** The origin that caused this action's current state */
+		VRInputValueHandle_t activeOrigin;
+	};
+
+	struct InputOriginInfo_t
+	{
+		VRInputValueHandle_t devicePath;
+		TrackedDeviceIndex_t trackedDeviceIndex;
+		char rchRenderModelComponentName[128];
+	};
+
+	struct InputBindingInfo_t
+	{
+		char rchDevicePathName[128];
+		char rchInputPathName[128];
+		char rchModeName[128];
+		char rchSlotName[128];
+		char rchInputSourceType[ 32 ];
+	};
+
+	// * Experimental global action set priority *
+	// These constants are part of the experimental support in SteamVR for overlay
+	// apps selectively overriding input in the base scene application. This may be
+	// useful for overlay applications that need to use part or all of a controller
+	// without taking away all input to the game. This system must be enabled by the 
+	// "Experimental overlay input overrides" setting in the developer section of 
+	// SteamVR settings.
+	//
+	// To use this system, set the nPriority field of an action set to any number in
+	// this range. 
+	static const int32_t k_nActionSetOverlayGlobalPriorityMin	= 0x01000000;
+	static const int32_t k_nActionSetOverlayGlobalPriorityMax	= 0x01FFFFFF;
+
+	static const int32_t k_nActionSetPriorityReservedMin		= 0x02000000;
+
+	struct VRActiveActionSet_t
+	{
+		/** This is the handle of the action set to activate for this frame. */
+		VRActionSetHandle_t ulActionSet;
+
+		/** This is the handle of a device path that this action set should be active for. To
+		* activate for all devices, set this to k_ulInvalidInputValueHandle. */
+		VRInputValueHandle_t ulRestrictedToDevice;
+
+		/** The action set to activate for all devices other than ulRestrictedDevice. If 
+		* ulRestrictedToDevice is set to k_ulInvalidInputValueHandle, this parameter is 
+		* ignored. */
+		VRActionSetHandle_t ulSecondaryActionSet;
+
+		// This field is ignored
+		uint32_t unPadding;
+
+		/** The priority of this action set relative to other action sets. Any inputs
+		* bound to a source (e.g. trackpad, joystick, trigger) will disable bindings in
+		* other active action sets with a smaller priority. 
+		*
+		* Overlay applications (i.e. ApplicationType_Overlay) may set their action set priority 
+		* to a value between k_nActionSetOverlayGlobalPriorityMin and k_nActionSetOverlayGlobalPriorityMax
+		* to cause any inputs bound to a source used by that action set to be disabled in scene applications.
+		*
+		* No action set priority may value may be larger than k_nActionSetPriorityReservedMin
+		*/
+		int32_t nPriority;
+	};
+
+	/** Contains summary information about the current skeletal pose */
+	struct VRSkeletalSummaryData_t
+	{
+		/** The amount that each finger is 'curled' inwards towards the palm.  In the case of the thumb,
+		* this represents how much the thumb is wrapped around the fist.  
+		* 0 means straight, 1 means fully curled */
+		float	flFingerCurl[ VRFinger_Count ];
+
+		/** The amount that each pair of adjacent fingers are separated.  
+		* 0 means the digits are touching, 1 means they are fully separated.
+		*/
+		float	flFingerSplay[ VRFingerSplay_Count ];
+	};
+
+
+	struct VR_IVRInput_FnTable
+	{
+		EVRInputError (__stdcall *SetActionManifestPath)( const char *pchActionManifestPath );
+		EVRInputError (__stdcall *GetActionSetHandle)( const char *pchActionSetName, VRActionSetHandle_t *pHandle );
+		EVRInputError (__stdcall *GetActionHandle)( const char *pchActionName, VRActionHandle_t *pHandle );
+		EVRInputError (__stdcall *GetInputSourceHandle)( const char *pchInputSourcePath, VRInputValueHandle_t *pHandle );
+		EVRInputError (__stdcall *UpdateActionState)(  VRActiveActionSet_t *pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount );
+		EVRInputError (__stdcall *GetDigitalActionData)( VRActionHandle_t action, InputDigitalActionData_t *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice );
+		EVRInputError (__stdcall *GetAnalogActionData)( VRActionHandle_t action, InputAnalogActionData_t *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice );
+		EVRInputError (__stdcall *GetPoseActionDataRelativeToNow)( VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice );
+		EVRInputError (__stdcall *GetPoseActionDataForNextFrame)( VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, InputPoseActionData_t *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice );
+		EVRInputError (__stdcall *GetSkeletalActionData)( VRActionHandle_t action, InputSkeletalActionData_t *pActionData, uint32_t unActionDataSize );
+		EVRInputError (__stdcall *GetDominantHand)( ETrackedControllerRole *peDominantHand );
+		EVRInputError (__stdcall *SetDominantHand)( ETrackedControllerRole eDominantHand );
+		EVRInputError (__stdcall *GetBoneCount)( VRActionHandle_t action, uint32_t* pBoneCount );
+		EVRInputError (__stdcall *GetBoneHierarchy)( VRActionHandle_t action,  BoneIndex_t* pParentIndices, uint32_t unIndexArayCount );
+		EVRInputError (__stdcall *GetBoneName)( VRActionHandle_t action, BoneIndex_t nBoneIndex,  char* pchBoneName, uint32_t unNameBufferSize );
+		EVRInputError (__stdcall *GetSkeletalReferenceTransforms)( VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalReferencePose eReferencePose,  VRBoneTransform_t *pTransformArray, uint32_t unTransformArrayCount );
+		EVRInputError (__stdcall *GetSkeletalTrackingLevel)( VRActionHandle_t action, EVRSkeletalTrackingLevel* pSkeletalTrackingLevel );
+		EVRInputError (__stdcall *GetSkeletalBoneData)( VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange,  VRBoneTransform_t *pTransformArray, uint32_t unTransformArrayCount );
+		EVRInputError (__stdcall *GetSkeletalSummaryData)( VRActionHandle_t action, EVRSummaryType eSummaryType, VRSkeletalSummaryData_t * pSkeletalSummaryData );
+		EVRInputError (__stdcall *GetSkeletalBoneDataCompressed)( VRActionHandle_t action, EVRSkeletalMotionRange eMotionRange,  void *pvCompressedData, uint32_t unCompressedSize, uint32_t *punRequiredCompressedSize );
+		EVRInputError (__stdcall *DecompressSkeletalBoneData)( const void *pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace eTransformSpace,  VRBoneTransform_t *pTransformArray, uint32_t unTransformArrayCount );
+		EVRInputError (__stdcall *TriggerHapticVibrationAction)( VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, VRInputValueHandle_t ulRestrictToDevice );
+		EVRInputError (__stdcall *GetActionOrigins)( VRActionSetHandle_t actionSetHandle, VRActionHandle_t digitalActionHandle,  VRInputValueHandle_t *originsOut, uint32_t originOutCount );
+		EVRInputError (__stdcall *GetOriginLocalizedName)( VRInputValueHandle_t origin,  char *pchNameArray, uint32_t unNameArraySize, int32_t unStringSectionsToInclude );
+		EVRInputError (__stdcall *GetOriginTrackedDeviceInfo)( VRInputValueHandle_t origin, InputOriginInfo_t *pOriginInfo, uint32_t unOriginInfoSize );
+		EVRInputError (__stdcall *GetActionBindingInfo)( VRActionHandle_t action, InputBindingInfo_t *pOriginInfo, uint32_t unBindingInfoSize, uint32_t unBindingInfoCount, uint32_t *punReturnedBindingInfoCount );
+		EVRInputError (__stdcall *ShowActionOrigins)( VRActionSetHandle_t actionSetHandle, VRActionHandle_t ulActionHandle );
+		EVRInputError (__stdcall *ShowBindingsForActionSet)(  VRActiveActionSet_t *pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight );
+		EVRInputError (__stdcall *GetComponentStateForBinding)( const char *pchRenderModelName, const char *pchComponentName,
+			const InputBindingInfo_t *pOriginInfo, uint32_t unBindingInfoSize, uint32_t unBindingInfoCount,
+			vr::RenderModel_ComponentState_t *pComponentState );
+		bool (__stdcall *IsUsingLegacyInput)();
+		EVRInputError (__stdcall *OpenBindingUI)( const char* pchAppKey, VRActionSetHandle_t ulActionSetHandle, VRInputValueHandle_t ulDeviceHandle, bool bShowOnDesktop );
+		EVRInputError (__stdcall *GetBindingVariant)( vr::VRInputValueHandle_t ulDevicePath,
+			 char *pchVariantArray, uint32_t unVariantArraySize );
+	};
+
+	class IVRInput
+	{
+		VR_IVRInput_FnTable _table;
+	public:
+
+		// ---------------  Handle management   --------------- //
+
+		/** Sets the path to the action manifest JSON file that is used by this application. If this information
+		* was set on the Steam partner site, calls to this function are ignored. If the Steam partner site
+		* setting and the path provided by this call are different, VRInputError_MismatchedActionManifest is returned. 
+		* This call must be made before the first call to UpdateActionState or IVRSystem::PollNextEvent. */
+		EVRInputError SetActionManifestPath( const char *pchActionManifestPath ) { return _table.SetActionManifestPath(pchActionManifestPath); }
+
+		/** Returns a handle for an action set. This handle is used for all performance-sensitive calls. */
+		EVRInputError GetActionSetHandle( const char *pchActionSetName, VRActionSetHandle_t *pHandle ) { return _table.GetActionSetHandle(pchActionSetName, pHandle); }
+
+		/** Returns a handle for an action. This handle is used for all performance-sensitive calls. */
+		EVRInputError GetActionHandle( const char *pchActionName, VRActionHandle_t *pHandle ) { return _table.GetActionHandle(pchActionName, pHandle); }
+
+		/** Returns a handle for any path in the input system. E.g. /user/hand/right */
+		EVRInputError GetInputSourceHandle( const char *pchInputSourcePath, VRInputValueHandle_t *pHandle ) { return _table.GetInputSourceHandle(pchInputSourcePath, pHandle); }
+
+
+
+		// --------------- Reading action state ------------------- //
+
+		/** Reads the current state into all actions. After this call, the results of Get*Action calls 
+		* will be the same until the next call to UpdateActionState. */
+		EVRInputError UpdateActionState( VR_ARRAY_COUNT( unSetCount ) VRActiveActionSet_t *pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount ) { return _table.UpdateActionState(pSets, unSizeOfVRSelectedActionSet_t, unSetCount); }
+
+		/** Reads the state of a digital action given its handle. This will return VRInputError_WrongType if the type of
+		* action is something other than digital */
+		EVRInputError GetDigitalActionData( VRActionHandle_t action, InputDigitalActionData_t *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice ) { return _table.GetDigitalActionData(action, pActionData, unActionDataSize, ulRestrictToDevice); }
+
+		/** Reads the state of an analog action given its handle. This will return VRInputError_WrongType if the type of
+		* action is something other than analog */
+		EVRInputError GetAnalogActionData( VRActionHandle_t action, InputAnalogActionData_t *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice ) { return _table.GetAnalogActionData(action, pActionData, unActionDataSize, ulRestrictToDevice); }
+
+		/** Reads the state of a pose action given its handle for the number of seconds relative to now. This
+		* will generally be called with negative times from the fUpdateTime fields in other actions. */
+		EVRInputError GetPoseActionDataRelativeToNow( VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice ) { return _table.GetPoseActionDataRelativeToNow(action, eOrigin, fPredictedSecondsFromNow, pActionData, unActionDataSize, ulRestrictToDevice); }
+
+		/** Reads the state of a pose action given its handle. The returned values will match the values returned
+		* by the last call to IVRCompositor::WaitGetPoses(). */
+		EVRInputError GetPoseActionDataForNextFrame( VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, InputPoseActionData_t *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice ) { return _table.GetPoseActionDataForNextFrame(action, eOrigin, pActionData, unActionDataSize, ulRestrictToDevice); }
+
+		/** Reads the state of a skeletal action given its handle. */
+		EVRInputError GetSkeletalActionData( VRActionHandle_t action, InputSkeletalActionData_t *pActionData, uint32_t unActionDataSize ) { return _table.GetSkeletalActionData(action, pActionData, unActionDataSize); }
+
+		/** Returns the current dominant hand for the user for this application. This function will only return success for applications
+		* which include "supports_dominant_hand_setting": true in their action manifests. The dominant hand will only change after
+		* a call to UpdateActionState, and the action data returned after that point will use the new dominant hand. */
+		EVRInputError GetDominantHand( ETrackedControllerRole *peDominantHand ) { return _table.GetDominantHand(peDominantHand); }
+
+		/** Sets the dominant hand for the user for this application. */
+		EVRInputError SetDominantHand( ETrackedControllerRole eDominantHand ) { return _table.SetDominantHand(eDominantHand); }
+
+		// ---------------  Static Skeletal Data ------------------- //
+
+		/** Reads the number of bones in skeleton associated with the given action */
+		EVRInputError GetBoneCount( VRActionHandle_t action, uint32_t* pBoneCount ) { return _table.GetBoneCount(action, pBoneCount); }
+
+		/** Fills the given array with the index of each bone's parent in the skeleton associated with the given action */
+		EVRInputError GetBoneHierarchy( VRActionHandle_t action, VR_ARRAY_COUNT( unIndexArayCount ) BoneIndex_t* pParentIndices, uint32_t unIndexArayCount ) { return _table.GetBoneHierarchy(action, pParentIndices, unIndexArayCount); }
+
+		/** Fills the given buffer with the name of the bone at the given index in the skeleton associated with the given action */
+		EVRInputError GetBoneName( VRActionHandle_t action, BoneIndex_t nBoneIndex, VR_OUT_STRING() char* pchBoneName, uint32_t unNameBufferSize ) { return _table.GetBoneName(action, nBoneIndex, pchBoneName, unNameBufferSize); }
+
+		/** Fills the given buffer with the transforms for a specific static skeletal reference pose */
+		EVRInputError GetSkeletalReferenceTransforms( VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalReferencePose eReferencePose, VR_ARRAY_COUNT( unTransformArrayCount ) VRBoneTransform_t *pTransformArray, uint32_t unTransformArrayCount ) { return _table.GetSkeletalReferenceTransforms(action, eTransformSpace, eReferencePose, pTransformArray, unTransformArrayCount); }
+
+		/** Reads the level of accuracy to which the controller is able to track the user to recreate a skeletal pose */
+		EVRInputError GetSkeletalTrackingLevel( VRActionHandle_t action, EVRSkeletalTrackingLevel* pSkeletalTrackingLevel ) { return _table.GetSkeletalTrackingLevel(action, pSkeletalTrackingLevel); }
+
+		// ---------------  Dynamic Skeletal Data ------------------- //
+
+		/** Reads the state of the skeletal bone data associated with this action and copies it into the given buffer. */
+		EVRInputError GetSkeletalBoneData( VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, VR_ARRAY_COUNT( unTransformArrayCount ) VRBoneTransform_t *pTransformArray, uint32_t unTransformArrayCount ) { return _table.GetSkeletalBoneData(action, eTransformSpace, eMotionRange, pTransformArray, unTransformArrayCount); }
+
+		/** Reads summary information about the current pose of the skeleton associated with the given action.   */
+		EVRInputError GetSkeletalSummaryData( VRActionHandle_t action, EVRSummaryType eSummaryType, VRSkeletalSummaryData_t * pSkeletalSummaryData ) { return _table.GetSkeletalSummaryData(action, eSummaryType, pSkeletalSummaryData); }
+
+		/** Reads the state of the skeletal bone data in a compressed form that is suitable for
+		* sending over the network. The required buffer size will never exceed ( sizeof(VR_BoneTransform_t)*boneCount + 2).
+		* Usually the size will be much smaller. */
+		EVRInputError GetSkeletalBoneDataCompressed( VRActionHandle_t action, EVRSkeletalMotionRange eMotionRange, VR_OUT_BUFFER_COUNT( unCompressedSize ) void *pvCompressedData, uint32_t unCompressedSize, uint32_t *punRequiredCompressedSize ) { return _table.GetSkeletalBoneDataCompressed(action, eMotionRange, pvCompressedData, unCompressedSize, punRequiredCompressedSize); }
+
+		/** Turns a compressed buffer from GetSkeletalBoneDataCompressed and turns it back into a bone transform array. */
+		EVRInputError DecompressSkeletalBoneData( const void *pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace eTransformSpace, VR_ARRAY_COUNT( unTransformArrayCount ) VRBoneTransform_t *pTransformArray, uint32_t unTransformArrayCount ) { return _table.DecompressSkeletalBoneData(pvCompressedBuffer, unCompressedBufferSize, eTransformSpace, pTransformArray, unTransformArrayCount); }
+
+		// --------------- Haptics ------------------- //
+
+		/** Triggers a haptic event as described by the specified action */
+		EVRInputError TriggerHapticVibrationAction( VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, VRInputValueHandle_t ulRestrictToDevice ) { return _table.TriggerHapticVibrationAction(action, fStartSecondsFromNow, fDurationSeconds, fFrequency, fAmplitude, ulRestrictToDevice); }
+
+		// --------------- Action Origins ---------------- //
+
+		/** Retrieve origin handles for an action */
+		EVRInputError GetActionOrigins( VRActionSetHandle_t actionSetHandle, VRActionHandle_t digitalActionHandle, VR_ARRAY_COUNT( originOutCount ) VRInputValueHandle_t *originsOut, uint32_t originOutCount ) { return _table.GetActionOrigins(actionSetHandle, digitalActionHandle, originsOut, originOutCount); }
+
+		/** Retrieves the name of the origin in the current language. unStringSectionsToInclude is a bitfield of values in EVRInputStringBits that allows the 
+			application to specify which parts of the origin's information it wants a string for. */
+		EVRInputError GetOriginLocalizedName( VRInputValueHandle_t origin, VR_OUT_STRING() char *pchNameArray, uint32_t unNameArraySize, int32_t unStringSectionsToInclude ) { return _table.GetOriginLocalizedName(origin, pchNameArray, unNameArraySize, unStringSectionsToInclude); }
+
+		/** Retrieves useful information for the origin of this action */
+		EVRInputError GetOriginTrackedDeviceInfo( VRInputValueHandle_t origin, InputOriginInfo_t *pOriginInfo, uint32_t unOriginInfoSize ) { return _table.GetOriginTrackedDeviceInfo(origin, pOriginInfo, unOriginInfoSize); }
+
+		/** Retrieves useful information about the bindings for an action */
+		EVRInputError GetActionBindingInfo( VRActionHandle_t action, InputBindingInfo_t *pOriginInfo, uint32_t unBindingInfoSize, uint32_t unBindingInfoCount, uint32_t *punReturnedBindingInfoCount ) { return _table.GetActionBindingInfo(action, pOriginInfo, unBindingInfoSize, unBindingInfoCount, punReturnedBindingInfoCount); }
+
+		/** Shows the current binding for the action in-headset */
+		EVRInputError ShowActionOrigins( VRActionSetHandle_t actionSetHandle, VRActionHandle_t ulActionHandle ) { return _table.ShowActionOrigins(actionSetHandle, ulActionHandle); }
+
+		/** Shows the current binding all the actions in the specified action sets */
+		EVRInputError ShowBindingsForActionSet( VR_ARRAY_COUNT( unSetCount ) VRActiveActionSet_t *pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight ) { return _table.ShowBindingsForActionSet(pSets, unSizeOfVRSelectedActionSet_t, unSetCount, originToHighlight); }
+
+		/** Use this to query what action on the component returned by GetOriginTrackedDeviceInfo would trigger this binding. */
+		EVRInputError GetComponentStateForBinding( const char *pchRenderModelName, const char *pchComponentName,
+			const InputBindingInfo_t *pOriginInfo, uint32_t unBindingInfoSize, uint32_t unBindingInfoCount,
+			vr::RenderModel_ComponentState_t *pComponentState ) { return _table.GetComponentStateForBinding(pchRenderModelName, pchComponentName, pOriginInfo, unBindingInfoSize, unBindingInfoCount, pComponentState); }
+
+
+		// --------------- Legacy Input ------------------- //
+		bool IsUsingLegacyInput() { return _table.IsUsingLegacyInput(); }
+
+
+		// --------------- Utilities ------------------- //
+
+		/** Opens the binding user interface. If no app key is provided it will use the key from the calling process.
+		* If no set is provided it will open to the root of the app binding page. */
+		EVRInputError OpenBindingUI( const char* pchAppKey, VRActionSetHandle_t ulActionSetHandle, VRInputValueHandle_t ulDeviceHandle, bool bShowOnDesktop ) { return _table.OpenBindingUI(pchAppKey, ulActionSetHandle, ulDeviceHandle, bShowOnDesktop); }
+
+		/** Returns the variant set in the current bindings. If the binding doesn't include a variant setting, this function 
+		* will return an empty string */
+		EVRInputError GetBindingVariant( vr::VRInputValueHandle_t ulDevicePath,
+			VR_OUT_STRING() char *pchVariantArray, uint32_t unVariantArraySize ) { return _table.GetBindingVariant(ulDevicePath, pchVariantArray, unVariantArraySize); }
+
+	};
+
+	static const char * const IVRInput_Version = "FnTable:IVRInput_010";
+
+} // namespace vr
+
+// ivriobuffer.h
+namespace vr
+{
+
+typedef uint64_t IOBufferHandle_t;
+static const uint64_t k_ulInvalidIOBufferHandle = 0;
+	
+	enum EIOBufferError
+	{
+		IOBuffer_Success                  = 0,
+		IOBuffer_OperationFailed          = 100,
+		IOBuffer_InvalidHandle            = 101,
+		IOBuffer_InvalidArgument          = 102,
+		IOBuffer_PathExists               = 103,
+		IOBuffer_PathDoesNotExist         = 104,
+		IOBuffer_Permission               = 105,
+	};
+
+	enum EIOBufferMode
+	{
+		IOBufferMode_Read                 = 0x0001,
+		IOBufferMode_Write                = 0x0002,
+		IOBufferMode_Create               = 0x0200,
+	};
+
+	// ----------------------------------------------------------------------------------------------
+	// Purpose:
+	// ----------------------------------------------------------------------------------------------
+	struct VR_IVRIOBuffer_FnTable
+	{
+		vr::EIOBufferError (__stdcall *Open)( const char *pchPath, vr::EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, vr::IOBufferHandle_t *pulBuffer );
+		vr::EIOBufferError (__stdcall *Close)( vr::IOBufferHandle_t ulBuffer );
+		vr::EIOBufferError (__stdcall *Read)( vr::IOBufferHandle_t ulBuffer, void *pDst, uint32_t unBytes, uint32_t *punRead );
+		vr::EIOBufferError (__stdcall *Write)( vr::IOBufferHandle_t ulBuffer, void *pSrc, uint32_t unBytes );
+		vr::PropertyContainerHandle_t (__stdcall *PropertyContainer)( vr::IOBufferHandle_t ulBuffer );
+		bool (__stdcall *HasReaders)( vr::IOBufferHandle_t ulBuffer );
+	};
+
+	class IVRIOBuffer
+	{
+		VR_IVRIOBuffer_FnTable _table;
+	public:
+		/** opens an existing or creates a new IOBuffer of unSize bytes */
+		vr::EIOBufferError Open( const char *pchPath, vr::EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, vr::IOBufferHandle_t *pulBuffer ) { return _table.Open(pchPath, mode, unElementSize, unElements, pulBuffer); }
+		
+		/** closes a previously opened or created buffer */
+		vr::EIOBufferError Close( vr::IOBufferHandle_t ulBuffer ) { return _table.Close(ulBuffer); }
+		
+		/** reads up to unBytes from buffer into *pDst, returning number of bytes read in *punRead */
+		vr::EIOBufferError Read( vr::IOBufferHandle_t ulBuffer, void *pDst, uint32_t unBytes, uint32_t *punRead ) { return _table.Read(ulBuffer, pDst, unBytes, punRead); }
+		
+		/** writes unBytes of data from *pSrc into a buffer. */
+		vr::EIOBufferError Write( vr::IOBufferHandle_t ulBuffer, void *pSrc, uint32_t unBytes ) { return _table.Write(ulBuffer, pSrc, unBytes); }
+		
+		/** retrieves the property container of an buffer. */
+		vr::PropertyContainerHandle_t PropertyContainer( vr::IOBufferHandle_t ulBuffer ) { return _table.PropertyContainer(ulBuffer); }
+
+		/** inexpensively checks for readers to allow writers to fast-fail potentially expensive copies and writes. */
+		bool HasReaders( vr::IOBufferHandle_t ulBuffer ) { return _table.HasReaders(ulBuffer); }
+	};
+
+	static const char *IVRIOBuffer_Version = "IVRIOBuffer_002";
+}
+
+// ivrspatialanchors.h
+namespace vr
+{
+	static const SpatialAnchorHandle_t k_ulInvalidSpatialAnchorHandle = 0;
+
+	struct SpatialAnchorPose_t
+	{
+		HmdMatrix34_t mAnchorToAbsoluteTracking;
+	};
+
+	struct VR_IVRSpatialAnchors_FnTable
+	{
+		EVRSpatialAnchorError (__stdcall *CreateSpatialAnchorFromDescriptor)( const char *pchDescriptor, SpatialAnchorHandle_t *pHandleOut );
+		EVRSpatialAnchorError (__stdcall *CreateSpatialAnchorFromPose)( TrackedDeviceIndex_t unDeviceIndex, ETrackingUniverseOrigin eOrigin, SpatialAnchorPose_t *pPose, SpatialAnchorHandle_t *pHandleOut );
+		EVRSpatialAnchorError (__stdcall *GetSpatialAnchorPose)( SpatialAnchorHandle_t unHandle, ETrackingUniverseOrigin eOrigin, SpatialAnchorPose_t *pPoseOut );
+		EVRSpatialAnchorError (__stdcall *GetSpatialAnchorDescriptor)( SpatialAnchorHandle_t unHandle,  char *pchDescriptorOut, uint32_t *punDescriptorBufferLenInOut );
+	};
+
+	class IVRSpatialAnchors
+	{
+		VR_IVRSpatialAnchors_FnTable _table;
+	public:
+
+		/** Returns a handle for an spatial anchor described by "descriptor".  On success, pHandle
+		* will contain a handle valid for this session.  Caller can wait for an event or occasionally
+		* poll GetSpatialAnchorPose() to find the virtual coordinate associated with this anchor. */
+		EVRSpatialAnchorError CreateSpatialAnchorFromDescriptor( const char *pchDescriptor, SpatialAnchorHandle_t *pHandleOut ) { return _table.CreateSpatialAnchorFromDescriptor(pchDescriptor, pHandleOut); }
+
+		/** Returns a handle for an new spatial anchor at pPose.  On success, pHandle
+		* will contain a handle valid for this session.  Caller can wait for an event or occasionally
+		* poll GetSpatialAnchorDescriptor() to find the permanent descriptor for this pose.
+		* The result of GetSpatialAnchorPose() may evolve from this initial position if the driver chooses
+		* to update it.
+		* The anchor will be associated with the driver that provides unDeviceIndex, and the driver may use that specific
+		* device as a hint for how to best create the anchor.
+		* The eOrigin must match whatever tracking origin you are working in (seated/standing/raw).
+		* This should be called when the user is close to (and ideally looking at/interacting with) the target physical
+		* location.  At that moment, the driver will have the most information about how to recover that physical point
+		* in the future, and the quality of the anchor (when the descriptor is re-used) will be highest.
+		* The caller may decide to apply offsets from this initial pose, but is advised to stay relatively close to the 
+		* original pose location for highest fidelity. */
+		EVRSpatialAnchorError CreateSpatialAnchorFromPose( TrackedDeviceIndex_t unDeviceIndex, ETrackingUniverseOrigin eOrigin, SpatialAnchorPose_t *pPose, SpatialAnchorHandle_t *pHandleOut ) { return _table.CreateSpatialAnchorFromPose(unDeviceIndex, eOrigin, pPose, pHandleOut); }
+
+		/** Get the pose for a given handle.  This is intended to be cheap enough to call every frame (or fairly often)
+		* so that the driver can refine this position when it has more information available. */
+		EVRSpatialAnchorError GetSpatialAnchorPose( SpatialAnchorHandle_t unHandle, ETrackingUniverseOrigin eOrigin, SpatialAnchorPose_t *pPoseOut ) { return _table.GetSpatialAnchorPose(unHandle, eOrigin, pPoseOut); }
+
+		/** Get the descriptor for a given handle.  This will be empty for handles where the driver has not
+		* yet built a descriptor.  It will be the application-supplied descriptor for previously saved anchors
+		* that the application is requesting poses for.  If the driver has called UpdateSpatialAnchorDescriptor()
+		* already in this session, it will be the descriptor provided by the driver.
+		* Returns true if the descriptor fits into the buffer, else false.  Buffer size should be at least
+		* k_unMaxSpatialAnchorDescriptorSize. */
+		EVRSpatialAnchorError GetSpatialAnchorDescriptor( SpatialAnchorHandle_t unHandle, VR_OUT_STRING() char *pchDescriptorOut, uint32_t *punDescriptorBufferLenInOut ) { return _table.GetSpatialAnchorDescriptor(unHandle, pchDescriptorOut, punDescriptorBufferLenInOut); }
+
+	};
+
+	static const char * const IVRSpatialAnchors_Version = "FnTable:IVRSpatialAnchors_001";
+
+} // namespace vr
+
+// ivrdebug.h
+namespace vr
+{
+	enum EVRDebugError
+	{
+		VRDebugError_Success = 0,
+		VRDebugError_BadParameter
+	};
+
+	/** Handle for vr profiler events */
+	typedef uint64_t VrProfilerEventHandle_t;
+
+	struct VR_IVRDebug_FnTable
+	{
+		EVRDebugError (__stdcall *EmitVrProfilerEvent)( const char *pchMessage );
+		EVRDebugError (__stdcall *BeginVrProfilerEvent)( VrProfilerEventHandle_t *pHandleOut );
+		EVRDebugError (__stdcall *FinishVrProfilerEvent)( VrProfilerEventHandle_t hHandle, const char *pchMessage );
+		uint32_t (__stdcall *DriverDebugRequest)( vr::TrackedDeviceIndex_t unDeviceIndex, const char *pchRequest,  char *pchResponseBuffer, uint32_t unResponseBufferSize );
+	};
+
+	class IVRDebug
+	{
+		VR_IVRDebug_FnTable _table;
+	public:
+
+		/** Create a vr profiler discrete event (point)
+		* The event will be associated with the message provided in pchMessage, and the current
+		* time will be used as the event timestamp. */
+		EVRDebugError EmitVrProfilerEvent( const char *pchMessage ) { return _table.EmitVrProfilerEvent(pchMessage); }
+
+		/** Create an vr profiler duration event (line)
+		* The current time will be used as the timestamp for the start of the line.
+		* On success, pHandleOut will contain a handle valid for terminating this event. */
+		EVRDebugError BeginVrProfilerEvent( VrProfilerEventHandle_t *pHandleOut ) { return _table.BeginVrProfilerEvent(pHandleOut); }
+
+		/** Terminate a vr profiler event
+		* The event associated with hHandle will be considered completed when this method is called.
+		* The current time will be used assocaited to the termination time of the event, and
+		* pchMessage will be used as the event title. */
+		EVRDebugError FinishVrProfilerEvent( VrProfilerEventHandle_t hHandle, const char *pchMessage ) { return _table.FinishVrProfilerEvent(hHandle, pchMessage); }
+
+		/** Sends a request to the driver for the specified device and returns the response. The maximum response size is 32k,
+		* but this method can be called with a smaller buffer. If the response exceeds the size of the buffer, it is truncated.
+		* The size of the response including its terminating null is returned. */
+		uint32_t DriverDebugRequest( vr::TrackedDeviceIndex_t unDeviceIndex, const char *pchRequest, VR_OUT_STRING() char *pchResponseBuffer, uint32_t unResponseBufferSize ) { return _table.DriverDebugRequest(unDeviceIndex, pchRequest, pchResponseBuffer, unResponseBufferSize); }
+
+	};
+
+	static const char * const IVRDebug_Version = "FnTable:IVRDebug_001";
+
+} // namespace vr
+// End
+
+#endif // _OPENVR_API
+
+
+
+namespace vr
+{
+#if !defined( OPENVR_INTERFACE_INTERNAL )
+
+	/** Finds the active installation of the VR API and initializes it. The provided path must be absolute
+	* or relative to the current working directory. These are the local install versions of the equivalent
+	* functions in steamvr.h and will work without a local Steam install.
+	*
+	* This path is to the "root" of the VR API install. That's the directory with
+	* the "drivers" directory and a platform (i.e. "win32") directory in it, not the directory with the DLL itself.
+	*
+	* pStartupInfo is reserved for future use.
+	*/
+	inline IVRSystem *VR_Init( EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo = nullptr );
+
+	/** unloads vrclient.dll. Any interface pointers from the interface are
+	* invalid after this point */
+	inline void VR_Shutdown();
+
+	/** Returns true if there is an HMD attached. This check is as lightweight as possible and
+	* can be called outside of VR_Init/VR_Shutdown. It should be used when an application wants
+	* to know if initializing VR is a possibility but isn't ready to take that step yet.
+	*/
+	VR_INTERFACE bool VR_CALLTYPE VR_IsHmdPresent();
+
+	/** Returns true if the OpenVR runtime is installed. */
+	VR_INTERFACE bool VR_CALLTYPE VR_IsRuntimeInstalled();
+
+	/** Returns where the OpenVR runtime is installed. */
+	VR_INTERFACE bool VR_GetRuntimePath( VR_OUT_STRING() char *pchPathBuffer, uint32_t unBufferSize, uint32_t *punRequiredBufferSize );
+	
+	/** Returns the name of the enum value for an EVRInitError. This function may be called outside of VR_Init()/VR_Shutdown(). */
+	VR_INTERFACE const char *VR_CALLTYPE VR_GetVRInitErrorAsSymbol( EVRInitError error );
+
+	/** Returns an English string for an EVRInitError. Applications should call VR_GetVRInitErrorAsSymbol instead and
+	* use that as a key to look up their own localized error message. This function may be called outside of VR_Init()/VR_Shutdown(). */
+	VR_INTERFACE const char *VR_CALLTYPE VR_GetVRInitErrorAsEnglishDescription( EVRInitError error );
+
+	/** Returns the interface of the specified version. This method must be called after VR_Init. The
+	* pointer returned is valid until VR_Shutdown is called.
+	*/
+	VR_INTERFACE void *VR_CALLTYPE VR_GetGenericInterface( const char *pchInterfaceVersion, EVRInitError *peError );
+
+	/** Returns whether the interface of the specified version exists.
+	*/
+	VR_INTERFACE bool VR_CALLTYPE VR_IsInterfaceVersionValid( const char *pchInterfaceVersion );
+
+	/** Returns a token that represents whether the VR interface handles need to be reloaded */
+	VR_INTERFACE uint32_t VR_CALLTYPE VR_GetInitToken();
+
+	// These typedefs allow old enum names from SDK 0.9.11 to be used in applications.
+	// They will go away in the future.
+	typedef EVRInitError HmdError;
+	typedef EVREye Hmd_Eye;
+	typedef EColorSpace ColorSpace;
+	typedef ETrackingResult HmdTrackingResult;
+	typedef ETrackedDeviceClass TrackedDeviceClass;
+	typedef ETrackingUniverseOrigin TrackingUniverseOrigin;
+	typedef ETrackedDeviceProperty TrackedDeviceProperty;
+	typedef ETrackedPropertyError TrackedPropertyError;
+	typedef EVRSubmitFlags VRSubmitFlags_t;
+	typedef EVRState VRState_t;
+	typedef ECollisionBoundsStyle CollisionBoundsStyle_t;
+	typedef EVROverlayError VROverlayError;
+	typedef EVRFirmwareError VRFirmwareError;
+	typedef EVRCompositorError VRCompositorError;
+	typedef EVRScreenshotError VRScreenshotsError;
+
+	inline uint32_t &VRToken()
+	{
+		static uint32_t token;
+		return token;
+	}
+
+	class COpenVRContext
+	{
+	public:
+		COpenVRContext() { Clear(); }
+		void Clear();
+
+		inline void CheckClear()
+		{
+			if ( VRToken() != VR_GetInitToken() )
+			{
+				Clear();
+				VRToken() = VR_GetInitToken();
+			}
+		}
+
+		IVRSystem *VRSystem()
+		{
+			CheckClear();
+			if ( m_pVRSystem == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRSystem = ( IVRSystem * )VR_GetGenericInterface( IVRSystem_Version, &eError );
+			}
+			return m_pVRSystem;
+		}
+		IVRChaperone *VRChaperone()
+		{
+			CheckClear();
+			if ( m_pVRChaperone == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRChaperone = ( IVRChaperone * )VR_GetGenericInterface( IVRChaperone_Version, &eError );
+			}
+			return m_pVRChaperone;
+		}
+
+		IVRChaperoneSetup *VRChaperoneSetup()
+		{
+			CheckClear();
+			if ( m_pVRChaperoneSetup == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRChaperoneSetup = ( IVRChaperoneSetup * )VR_GetGenericInterface( IVRChaperoneSetup_Version, &eError );
+			}
+			return m_pVRChaperoneSetup;
+		}
+
+		IVRCompositor *VRCompositor()
+		{
+			CheckClear();
+			if ( m_pVRCompositor == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRCompositor = ( IVRCompositor * )VR_GetGenericInterface( IVRCompositor_Version, &eError );
+			}
+			return m_pVRCompositor;
+		}
+
+		IVROverlay *VROverlay()
+		{
+			CheckClear();
+			if ( m_pVROverlay == nullptr )
+			{
+				EVRInitError eError;
+				m_pVROverlay = ( IVROverlay * )VR_GetGenericInterface( IVROverlay_Version, &eError );
+			}
+			return m_pVROverlay;
+		}
+
+		IVROverlayView *VROverlayView()
+		{
+			CheckClear();
+			if ( m_pVROverlayView == nullptr )
+			{
+				EVRInitError eError;
+				m_pVROverlayView = ( IVROverlayView * ) VR_GetGenericInterface( IVROverlayView_Version, &eError );
+			}
+			return m_pVROverlayView;
+		}
+
+		IVRHeadsetView *VRHeadsetView()
+		{
+			CheckClear();
+			if ( m_pVRHeadsetView == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRHeadsetView = ( IVRHeadsetView * ) VR_GetGenericInterface( IVRHeadsetView_Version, &eError );
+			}
+			return m_pVRHeadsetView;
+		}
+
+		IVRResources *VRResources()
+		{
+			CheckClear();
+			if ( m_pVRResources == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRResources = (IVRResources *)VR_GetGenericInterface( IVRResources_Version, &eError );
+			}
+			return m_pVRResources;
+		}
+
+		IVRScreenshots *VRScreenshots()
+		{
+			CheckClear();
+			if ( m_pVRScreenshots == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRScreenshots = ( IVRScreenshots * )VR_GetGenericInterface( IVRScreenshots_Version, &eError );
+			}
+			return m_pVRScreenshots;
+		}
+
+		IVRRenderModels *VRRenderModels()
+		{
+			CheckClear();
+			if ( m_pVRRenderModels == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRRenderModels = ( IVRRenderModels * )VR_GetGenericInterface( IVRRenderModels_Version, &eError );
+			}
+			return m_pVRRenderModels;
+		}
+
+		IVRExtendedDisplay *VRExtendedDisplay()
+		{
+			CheckClear();
+			if ( m_pVRExtendedDisplay == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRExtendedDisplay = ( IVRExtendedDisplay * )VR_GetGenericInterface( IVRExtendedDisplay_Version, &eError );
+			}
+			return m_pVRExtendedDisplay;
+		}
+
+		IVRSettings *VRSettings()
+		{
+			CheckClear();
+			if ( m_pVRSettings == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRSettings = ( IVRSettings * )VR_GetGenericInterface( IVRSettings_Version, &eError );
+			}
+			return m_pVRSettings;
+		}
+
+		IVRApplications *VRApplications()
+		{
+			CheckClear();
+			if ( m_pVRApplications == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRApplications = ( IVRApplications * )VR_GetGenericInterface( IVRApplications_Version, &eError );
+			}
+			return m_pVRApplications;
+		}
+
+		IVRTrackedCamera *VRTrackedCamera()
+		{
+			CheckClear();
+			if ( m_pVRTrackedCamera == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRTrackedCamera = ( IVRTrackedCamera * )VR_GetGenericInterface( IVRTrackedCamera_Version, &eError );
+			}
+			return m_pVRTrackedCamera;
+		}
+
+		IVRDriverManager *VRDriverManager()
+		{
+			CheckClear();
+			if ( !m_pVRDriverManager )
+			{
+				EVRInitError eError;
+				m_pVRDriverManager = ( IVRDriverManager * )VR_GetGenericInterface( IVRDriverManager_Version, &eError );
+			}
+			return m_pVRDriverManager;
+		}
+
+		IVRInput *VRInput()
+		{
+			CheckClear();
+			if ( !m_pVRInput )
+			{
+				EVRInitError eError;
+				m_pVRInput = (IVRInput *)VR_GetGenericInterface( IVRInput_Version, &eError );
+			}
+			return m_pVRInput;
+		}
+
+		IVRIOBuffer *VRIOBuffer()
+		{
+			if ( !m_pVRIOBuffer )
+			{
+				EVRInitError eError;
+				m_pVRIOBuffer = ( IVRIOBuffer * )VR_GetGenericInterface( IVRIOBuffer_Version, &eError );
+			}
+			return m_pVRIOBuffer;
+		}
+
+		IVRSpatialAnchors *VRSpatialAnchors()
+		{
+			CheckClear();
+			if ( !m_pVRSpatialAnchors )
+			{
+				EVRInitError eError;
+				m_pVRSpatialAnchors = (IVRSpatialAnchors *)VR_GetGenericInterface( IVRSpatialAnchors_Version, &eError );
+			}
+			return m_pVRSpatialAnchors;
+		}
+
+		IVRDebug *VRDebug()
+		{
+			CheckClear();
+			if ( !m_pVRDebug )
+			{
+				EVRInitError eError;
+				m_pVRDebug = (IVRDebug *)VR_GetGenericInterface( IVRDebug_Version, &eError );
+			}
+			return m_pVRDebug;
+		}
+
+		IVRNotifications *VRNotifications()
+		{
+			CheckClear();
+			if ( !m_pVRNotifications )
+			{
+				EVRInitError eError;
+				m_pVRNotifications = ( IVRNotifications * )VR_GetGenericInterface( IVRNotifications_Version, &eError );
+			}
+			return m_pVRNotifications;
+		}
+		
+	private:
+		IVRSystem			*m_pVRSystem;
+		IVRChaperone		*m_pVRChaperone;
+		IVRChaperoneSetup	*m_pVRChaperoneSetup;
+		IVRCompositor		*m_pVRCompositor;
+		IVRHeadsetView		*m_pVRHeadsetView;
+		IVROverlay			*m_pVROverlay;
+		IVROverlayView		*m_pVROverlayView;
+		IVRResources		*m_pVRResources;
+		IVRRenderModels		*m_pVRRenderModels;
+		IVRExtendedDisplay	*m_pVRExtendedDisplay;
+		IVRSettings			*m_pVRSettings;
+		IVRApplications		*m_pVRApplications;
+		IVRTrackedCamera	*m_pVRTrackedCamera;
+		IVRScreenshots		*m_pVRScreenshots;
+		IVRDriverManager	*m_pVRDriverManager;
+		IVRInput			*m_pVRInput;
+		IVRIOBuffer			*m_pVRIOBuffer;
+		IVRSpatialAnchors   *m_pVRSpatialAnchors;
+		IVRDebug			*m_pVRDebug;
+		IVRNotifications	*m_pVRNotifications;
+	};
+
+	inline COpenVRContext &OpenVRInternal_ModuleContext()
+	{
+		static void *ctx[ sizeof( COpenVRContext ) / sizeof( void * ) ];
+		return *( COpenVRContext * )ctx; // bypass zero-init constructor
+	}
+
+	inline IVRSystem *VR_CALLTYPE VRSystem() { return OpenVRInternal_ModuleContext().VRSystem(); }
+	inline IVRChaperone *VR_CALLTYPE VRChaperone() { return OpenVRInternal_ModuleContext().VRChaperone(); }
+	inline IVRChaperoneSetup *VR_CALLTYPE VRChaperoneSetup() { return OpenVRInternal_ModuleContext().VRChaperoneSetup(); }
+	inline IVRCompositor *VR_CALLTYPE VRCompositor() { return OpenVRInternal_ModuleContext().VRCompositor(); }
+	inline IVROverlay *VR_CALLTYPE VROverlay() { return OpenVRInternal_ModuleContext().VROverlay(); }
+	inline IVROverlayView *VR_CALLTYPE VROverlayView() { return OpenVRInternal_ModuleContext().VROverlayView(); }
+	inline IVRHeadsetView *VR_CALLTYPE VRHeadsetView() { return OpenVRInternal_ModuleContext().VRHeadsetView(); }
+	inline IVRScreenshots *VR_CALLTYPE VRScreenshots() { return OpenVRInternal_ModuleContext().VRScreenshots(); }
+	inline IVRRenderModels *VR_CALLTYPE VRRenderModels() { return OpenVRInternal_ModuleContext().VRRenderModels(); }
+	inline IVRApplications *VR_CALLTYPE VRApplications() { return OpenVRInternal_ModuleContext().VRApplications(); }
+	inline IVRSettings *VR_CALLTYPE VRSettings() { return OpenVRInternal_ModuleContext().VRSettings(); }
+	inline IVRResources *VR_CALLTYPE VRResources() { return OpenVRInternal_ModuleContext().VRResources(); }
+	inline IVRExtendedDisplay *VR_CALLTYPE VRExtendedDisplay() { return OpenVRInternal_ModuleContext().VRExtendedDisplay(); }
+	inline IVRTrackedCamera *VR_CALLTYPE VRTrackedCamera() { return OpenVRInternal_ModuleContext().VRTrackedCamera(); }
+	inline IVRDriverManager *VR_CALLTYPE VRDriverManager() { return OpenVRInternal_ModuleContext().VRDriverManager(); }
+	inline IVRInput *VR_CALLTYPE VRInput() { return OpenVRInternal_ModuleContext().VRInput(); }
+	inline IVRIOBuffer *VR_CALLTYPE VRIOBuffer() { return OpenVRInternal_ModuleContext().VRIOBuffer(); }
+	inline IVRSpatialAnchors *VR_CALLTYPE VRSpatialAnchors() { return OpenVRInternal_ModuleContext().VRSpatialAnchors(); }
+	inline IVRNotifications *VR_CALLTYPE VRNotifications() { return OpenVRInternal_ModuleContext().VRNotifications(); }
+	inline IVRDebug *VR_CALLTYPE VRDebug() { return OpenVRInternal_ModuleContext().VRDebug(); }
+
+	inline void COpenVRContext::Clear()
+	{
+		m_pVRSystem = nullptr;
+		m_pVRChaperone = nullptr;
+		m_pVRChaperoneSetup = nullptr;
+		m_pVRCompositor = nullptr;
+		m_pVROverlay = nullptr;
+		m_pVROverlayView = nullptr;
+		m_pVRHeadsetView = nullptr;
+		m_pVRRenderModels = nullptr;
+		m_pVRExtendedDisplay = nullptr;
+		m_pVRSettings = nullptr;
+		m_pVRApplications = nullptr;
+		m_pVRTrackedCamera = nullptr;
+		m_pVRResources = nullptr;
+		m_pVRScreenshots = nullptr;
+		m_pVRDriverManager = nullptr;
+		m_pVRInput = nullptr;
+		m_pVRIOBuffer = nullptr;
+		m_pVRSpatialAnchors = nullptr;
+		m_pVRNotifications = nullptr;
+		m_pVRDebug = nullptr;
+	}
+	
+	VR_INTERFACE uint32_t VR_CALLTYPE VR_InitInternal2( EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo );
+	VR_INTERFACE void VR_CALLTYPE VR_ShutdownInternal();
+
+	/** Finds the active installation of vrclient.dll and initializes it */
+	inline IVRSystem *VR_Init( EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo )
+	{
+		IVRSystem *pVRSystem = nullptr;
+
+		EVRInitError eError;
+		VRToken() = VR_InitInternal2( &eError, eApplicationType, pStartupInfo );
+		COpenVRContext &ctx = OpenVRInternal_ModuleContext();
+		ctx.Clear();
+
+		if ( eError == VRInitError_None )
+		{
+			if ( VR_IsInterfaceVersionValid( IVRSystem_Version ) )
+			{
+				pVRSystem = VRSystem();
+			}
+			else
+			{
+				VR_ShutdownInternal();
+				eError = VRInitError_Init_InterfaceNotFound;
+			}
+		}
+
+		if ( peError )
+			*peError = eError;
+		return pVRSystem;
+	}
+
+	/** unloads vrclient.dll. Any interface pointers from the interface are
+	* invalid after this point */
+	inline void VR_Shutdown()
+	{
+		VR_ShutdownInternal();
+	}
+
+#endif // OPENVR_INTERFACE_INTERNAL
+}
diff --git a/engine/inc/picosha2.h b/engine/inc/picosha2.h
new file mode 100644
index 00000000..879c7418
--- /dev/null
+++ b/engine/inc/picosha2.h
@@ -0,0 +1,377 @@
+/*
+The MIT License (MIT)
+
+Copyright (C) 2017 okdshin
+
+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.
+*/
+#ifndef PICOSHA2_H
+#define PICOSHA2_H
+// picosha2:20140213
+
+#ifndef PICOSHA2_BUFFER_SIZE_FOR_INPUT_ITERATOR
+#define PICOSHA2_BUFFER_SIZE_FOR_INPUT_ITERATOR \
+    1048576  //=1024*1024: default is 1MB memory
+#endif
+
+#include <algorithm>
+#include <cassert>
+#include <iterator>
+#include <sstream>
+#include <vector>
+#include <fstream>
+namespace picosha2 {
+typedef unsigned long word_t;
+typedef unsigned char byte_t;
+
+static const size_t k_digest_size = 32;
+
+namespace detail {
+inline byte_t mask_8bit(byte_t x) { return x & 0xff; }
+
+inline word_t mask_32bit(word_t x) { return x & 0xffffffff; }
+
+const word_t add_constant[64] = {
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
+    0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+    0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
+    0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
+    0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+    0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
+    0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
+    0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+    0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2};
+
+const word_t initial_message_digest[8] = {0x6a09e667, 0xbb67ae85, 0x3c6ef372,
+                                          0xa54ff53a, 0x510e527f, 0x9b05688c,
+                                          0x1f83d9ab, 0x5be0cd19};
+
+inline word_t ch(word_t x, word_t y, word_t z) { return (x & y) ^ ((~x) & z); }
+
+inline word_t maj(word_t x, word_t y, word_t z) {
+    return (x & y) ^ (x & z) ^ (y & z);
+}
+
+inline word_t rotr(word_t x, std::size_t n) {
+    assert(n < 32);
+    return mask_32bit((x >> n) | (x << (32 - n)));
+}
+
+inline word_t bsig0(word_t x) { return rotr(x, 2) ^ rotr(x, 13) ^ rotr(x, 22); }
+
+inline word_t bsig1(word_t x) { return rotr(x, 6) ^ rotr(x, 11) ^ rotr(x, 25); }
+
+inline word_t shr(word_t x, std::size_t n) {
+    assert(n < 32);
+    return x >> n;
+}
+
+inline word_t ssig0(word_t x) { return rotr(x, 7) ^ rotr(x, 18) ^ shr(x, 3); }
+
+inline word_t ssig1(word_t x) { return rotr(x, 17) ^ rotr(x, 19) ^ shr(x, 10); }
+
+template <typename RaIter1, typename RaIter2>
+void hash256_block(RaIter1 message_digest, RaIter2 first, RaIter2 last) {
+    assert(first + 64 == last);
+    static_cast<void>(last);  // for avoiding unused-variable warning
+    word_t w[64];
+    std::fill(w, w + 64, 0);
+    for (std::size_t i = 0; i < 16; ++i) {
+        w[i] = (static_cast<word_t>(mask_8bit(*(first + i * 4))) << 24) |
+               (static_cast<word_t>(mask_8bit(*(first + i * 4 + 1))) << 16) |
+               (static_cast<word_t>(mask_8bit(*(first + i * 4 + 2))) << 8) |
+               (static_cast<word_t>(mask_8bit(*(first + i * 4 + 3))));
+    }
+    for (std::size_t i = 16; i < 64; ++i) {
+        w[i] = mask_32bit(ssig1(w[i - 2]) + w[i - 7] + ssig0(w[i - 15]) +
+                          w[i - 16]);
+    }
+
+    word_t a = *message_digest;
+    word_t b = *(message_digest + 1);
+    word_t c = *(message_digest + 2);
+    word_t d = *(message_digest + 3);
+    word_t e = *(message_digest + 4);
+    word_t f = *(message_digest + 5);
+    word_t g = *(message_digest + 6);
+    word_t h = *(message_digest + 7);
+
+    for (std::size_t i = 0; i < 64; ++i) {
+        word_t temp1 = h + bsig1(e) + ch(e, f, g) + add_constant[i] + w[i];
+        word_t temp2 = bsig0(a) + maj(a, b, c);
+        h = g;
+        g = f;
+        f = e;
+        e = mask_32bit(d + temp1);
+        d = c;
+        c = b;
+        b = a;
+        a = mask_32bit(temp1 + temp2);
+    }
+    *message_digest += a;
+    *(message_digest + 1) += b;
+    *(message_digest + 2) += c;
+    *(message_digest + 3) += d;
+    *(message_digest + 4) += e;
+    *(message_digest + 5) += f;
+    *(message_digest + 6) += g;
+    *(message_digest + 7) += h;
+    for (std::size_t i = 0; i < 8; ++i) {
+        *(message_digest + i) = mask_32bit(*(message_digest + i));
+    }
+}
+
+}  // namespace detail
+
+template <typename InIter>
+void output_hex(InIter first, InIter last, std::ostream& os) {
+    os.setf(std::ios::hex, std::ios::basefield);
+    while (first != last) {
+        os.width(2);
+        os.fill('0');
+        os << static_cast<unsigned int>(*first);
+        ++first;
+    }
+    os.setf(std::ios::dec, std::ios::basefield);
+}
+
+template <typename InIter>
+void bytes_to_hex_string(InIter first, InIter last, std::string& hex_str) {
+    std::ostringstream oss;
+    output_hex(first, last, oss);
+    hex_str.assign(oss.str());
+}
+
+template <typename InContainer>
+void bytes_to_hex_string(const InContainer& bytes, std::string& hex_str) {
+    bytes_to_hex_string(bytes.begin(), bytes.end(), hex_str);
+}
+
+template <typename InIter>
+std::string bytes_to_hex_string(InIter first, InIter last) {
+    std::string hex_str;
+    bytes_to_hex_string(first, last, hex_str);
+    return hex_str;
+}
+
+template <typename InContainer>
+std::string bytes_to_hex_string(const InContainer& bytes) {
+    std::string hex_str;
+    bytes_to_hex_string(bytes, hex_str);
+    return hex_str;
+}
+
+class hash256_one_by_one {
+   public:
+    hash256_one_by_one() { init(); }
+
+    void init() {
+        buffer_.clear();
+        std::fill(data_length_digits_, data_length_digits_ + 4, 0);
+        std::copy(detail::initial_message_digest,
+                  detail::initial_message_digest + 8, h_);
+    }
+
+    template <typename RaIter>
+    void process(RaIter first, RaIter last) {
+        add_to_data_length(static_cast<word_t>(std::distance(first, last)));
+        std::copy(first, last, std::back_inserter(buffer_));
+        std::size_t i = 0;
+        for (; i + 64 <= buffer_.size(); i += 64) {
+            detail::hash256_block(h_, buffer_.begin() + i,
+                                  buffer_.begin() + i + 64);
+        }
+        buffer_.erase(buffer_.begin(), buffer_.begin() + i);
+    }
+
+    void finish() {
+        byte_t temp[64];
+        std::fill(temp, temp + 64, 0);
+        std::size_t remains = buffer_.size();
+        std::copy(buffer_.begin(), buffer_.end(), temp);
+        temp[remains] = 0x80;
+
+        if (remains > 55) {
+            std::fill(temp + remains + 1, temp + 64, 0);
+            detail::hash256_block(h_, temp, temp + 64);
+            std::fill(temp, temp + 64 - 4, 0);
+        } else {
+            std::fill(temp + remains + 1, temp + 64 - 4, 0);
+        }
+
+        write_data_bit_length(&(temp[56]));
+        detail::hash256_block(h_, temp, temp + 64);
+    }
+
+    template <typename OutIter>
+    void get_hash_bytes(OutIter first, OutIter last) const {
+        for (const word_t* iter = h_; iter != h_ + 8; ++iter) {
+            for (std::size_t i = 0; i < 4 && first != last; ++i) {
+                *(first++) = detail::mask_8bit(
+                    static_cast<byte_t>((*iter >> (24 - 8 * i))));
+            }
+        }
+    }
+
+   private:
+    void add_to_data_length(word_t n) {
+        word_t carry = 0;
+        data_length_digits_[0] += n;
+        for (std::size_t i = 0; i < 4; ++i) {
+            data_length_digits_[i] += carry;
+            if (data_length_digits_[i] >= 65536u) {
+                carry = data_length_digits_[i] >> 16;
+                data_length_digits_[i] &= 65535u;
+            } else {
+                break;
+            }
+        }
+    }
+    void write_data_bit_length(byte_t* begin) {
+        word_t data_bit_length_digits[4];
+        std::copy(data_length_digits_, data_length_digits_ + 4,
+                  data_bit_length_digits);
+
+        // convert byte length to bit length (multiply 8 or shift 3 times left)
+        word_t carry = 0;
+        for (std::size_t i = 0; i < 4; ++i) {
+            word_t before_val = data_bit_length_digits[i];
+            data_bit_length_digits[i] <<= 3;
+            data_bit_length_digits[i] |= carry;
+            data_bit_length_digits[i] &= 65535u;
+            carry = (before_val >> (16 - 3)) & 65535u;
+        }
+
+        // write data_bit_length
+        for (int i = 3; i >= 0; --i) {
+            (*begin++) = static_cast<byte_t>(data_bit_length_digits[i] >> 8);
+            (*begin++) = static_cast<byte_t>(data_bit_length_digits[i]);
+        }
+    }
+    std::vector<byte_t> buffer_;
+    word_t data_length_digits_[4];  // as 64bit integer (16bit x 4 integer)
+    word_t h_[8];
+};
+
+inline void get_hash_hex_string(const hash256_one_by_one& hasher,
+                                std::string& hex_str) {
+    byte_t hash[k_digest_size];
+    hasher.get_hash_bytes(hash, hash + k_digest_size);
+    return bytes_to_hex_string(hash, hash + k_digest_size, hex_str);
+}
+
+inline std::string get_hash_hex_string(const hash256_one_by_one& hasher) {
+    std::string hex_str;
+    get_hash_hex_string(hasher, hex_str);
+    return hex_str;
+}
+
+namespace impl {
+template <typename RaIter, typename OutIter>
+void hash256_impl(RaIter first, RaIter last, OutIter first2, OutIter last2, int,
+                  std::random_access_iterator_tag) {
+    hash256_one_by_one hasher;
+    // hasher.init();
+    hasher.process(first, last);
+    hasher.finish();
+    hasher.get_hash_bytes(first2, last2);
+}
+
+template <typename InputIter, typename OutIter>
+void hash256_impl(InputIter first, InputIter last, OutIter first2,
+                  OutIter last2, int buffer_size, std::input_iterator_tag) {
+    std::vector<byte_t> buffer(buffer_size);
+    hash256_one_by_one hasher;
+    // hasher.init();
+    while (first != last) {
+        int size = buffer_size;
+        for (int i = 0; i != buffer_size; ++i, ++first) {
+            if (first == last) {
+                size = i;
+                break;
+            }
+            buffer[i] = *first;
+        }
+        hasher.process(buffer.begin(), buffer.begin() + size);
+    }
+    hasher.finish();
+    hasher.get_hash_bytes(first2, last2);
+}
+}
+
+template <typename InIter, typename OutIter>
+void hash256(InIter first, InIter last, OutIter first2, OutIter last2,
+             int buffer_size = PICOSHA2_BUFFER_SIZE_FOR_INPUT_ITERATOR) {
+    picosha2::impl::hash256_impl(
+        first, last, first2, last2, buffer_size,
+        typename std::iterator_traits<InIter>::iterator_category());
+}
+
+template <typename InIter, typename OutContainer>
+void hash256(InIter first, InIter last, OutContainer& dst) {
+    hash256(first, last, dst.begin(), dst.end());
+}
+
+template <typename InContainer, typename OutIter>
+void hash256(const InContainer& src, OutIter first, OutIter last) {
+    hash256(src.begin(), src.end(), first, last);
+}
+
+template <typename InContainer, typename OutContainer>
+void hash256(const InContainer& src, OutContainer& dst) {
+    hash256(src.begin(), src.end(), dst.begin(), dst.end());
+}
+
+template <typename InIter>
+void hash256_hex_string(InIter first, InIter last, std::string& hex_str) {
+    byte_t hashed[k_digest_size];
+    hash256(first, last, hashed, hashed + k_digest_size);
+    std::ostringstream oss;
+    output_hex(hashed, hashed + k_digest_size, oss);
+    hex_str.assign(oss.str());
+}
+
+template <typename InIter>
+std::string hash256_hex_string(InIter first, InIter last) {
+    std::string hex_str;
+    hash256_hex_string(first, last, hex_str);
+    return hex_str;
+}
+
+inline void hash256_hex_string(const std::string& src, std::string& hex_str) {
+    hash256_hex_string(src.begin(), src.end(), hex_str);
+}
+
+template <typename InContainer>
+void hash256_hex_string(const InContainer& src, std::string& hex_str) {
+    hash256_hex_string(src.begin(), src.end(), hex_str);
+}
+
+template <typename InContainer>
+std::string hash256_hex_string(const InContainer& src) {
+    return hash256_hex_string(src.begin(), src.end());
+}
+template<typename OutIter>void hash256(std::ifstream& f, OutIter first, OutIter last){
+    hash256(std::istreambuf_iterator<char>(f), std::istreambuf_iterator<char>(), first,last);
+
+}
+}// namespace picosha2
+#endif  // PICOSHA2_H
\ No newline at end of file
diff --git a/engine/inc/png/png.h b/engine/inc/png/png.h
new file mode 100644
index 00000000..4c873f5c
--- /dev/null
+++ b/engine/inc/png/png.h
@@ -0,0 +1,3278 @@
+
+/* png.h - header file for PNG reference library
+ *
+ * libpng version 1.6.34, September 29, 2017
+ *
+ * Copyright (c) 1998-2002,2004,2006-2017 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ *
+ * This code is released under the libpng license (See LICENSE, below)
+ *
+ * Authors and maintainers:
+ *   libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat
+ *   libpng versions 0.89, June 1996, through 0.96, May 1997: Andreas Dilger
+ *   libpng versions 0.97, January 1998, through 1.6.34, September 29, 2017:
+ *     Glenn Randers-Pehrson.
+ *   See also "Contributing Authors", below.
+ */
+
+/*
+ * COPYRIGHT NOTICE, DISCLAIMER, and LICENSE:
+ *
+ * If you modify libpng you may insert additional notices immediately following
+ * this sentence.
+ *
+ * This code is released under the libpng license.
+ *
+ * libpng versions 1.0.7, July 1, 2000 through 1.6.34, September 29, 2017 are
+ * Copyright (c) 2000-2002, 2004, 2006-2017 Glenn Randers-Pehrson, are
+ * derived from libpng-1.0.6, and are distributed according to the same
+ * disclaimer and license as libpng-1.0.6 with the following individuals
+ * added to the list of Contributing Authors:
+ *
+ *    Simon-Pierre Cadieux
+ *    Eric S. Raymond
+ *    Mans Rullgard
+ *    Cosmin Truta
+ *    Gilles Vollant
+ *    James Yu
+ *    Mandar Sahastrabuddhe
+ *    Google Inc.
+ *    Vadim Barkov
+ *
+ * and with the following additions to the disclaimer:
+ *
+ *    There is no warranty against interference with your enjoyment of the
+ *    library or against infringement.  There is no warranty that our
+ *    efforts or the library will fulfill any of your particular purposes
+ *    or needs.  This library is provided with all faults, and the entire
+ *    risk of satisfactory quality, performance, accuracy, and effort is with
+ *    the user.
+ *
+ * Some files in the "contrib" directory and some configure-generated
+ * files that are distributed with libpng have other copyright owners and
+ * are released under other open source licenses.
+ *
+ * libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are
+ * Copyright (c) 1998-2000 Glenn Randers-Pehrson, are derived from
+ * libpng-0.96, and are distributed according to the same disclaimer and
+ * license as libpng-0.96, with the following individuals added to the list
+ * of Contributing Authors:
+ *
+ *    Tom Lane
+ *    Glenn Randers-Pehrson
+ *    Willem van Schaik
+ *
+ * libpng versions 0.89, June 1996, through 0.96, May 1997, are
+ * Copyright (c) 1996-1997 Andreas Dilger, are derived from libpng-0.88,
+ * and are distributed according to the same disclaimer and license as
+ * libpng-0.88, with the following individuals added to the list of
+ * Contributing Authors:
+ *
+ *    John Bowler
+ *    Kevin Bracey
+ *    Sam Bushell
+ *    Magnus Holmgren
+ *    Greg Roelofs
+ *    Tom Tanner
+ *
+ * Some files in the "scripts" directory have other copyright owners
+ * but are released under this license.
+ *
+ * libpng versions 0.5, May 1995, through 0.88, January 1996, are
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * For the purposes of this copyright and license, "Contributing Authors"
+ * is defined as the following set of individuals:
+ *
+ *    Andreas Dilger
+ *    Dave Martindale
+ *    Guy Eric Schalnat
+ *    Paul Schmidt
+ *    Tim Wegner
+ *
+ * The PNG Reference Library is supplied "AS IS".  The Contributing Authors
+ * and Group 42, Inc. disclaim all warranties, expressed or implied,
+ * including, without limitation, the warranties of merchantability and of
+ * fitness for any purpose.  The Contributing Authors and Group 42, Inc.
+ * assume no liability for direct, indirect, incidental, special, exemplary,
+ * or consequential damages, which may result from the use of the PNG
+ * Reference Library, even if advised of the possibility of such damage.
+ *
+ * Permission is hereby granted to use, copy, modify, and distribute this
+ * source code, or portions hereof, for any purpose, without fee, subject
+ * to the following restrictions:
+ *
+ *   1. The origin of this source code must not be misrepresented.
+ *
+ *   2. Altered versions must be plainly marked as such and must not
+ *      be misrepresented as being the original source.
+ *
+ *   3. This Copyright notice may not be removed or altered from any
+ *      source or altered source distribution.
+ *
+ * The Contributing Authors and Group 42, Inc. specifically permit, without
+ * fee, and encourage the use of this source code as a component to
+ * supporting the PNG file format in commercial products.  If you use this
+ * source code in a product, acknowledgment is not required but would be
+ * appreciated.
+ *
+ * END OF COPYRIGHT NOTICE, DISCLAIMER, and LICENSE.
+ *
+ * TRADEMARK:
+ *
+ * The name "libpng" has not been registered by the Copyright owner
+ * as a trademark in any jurisdiction.  However, because libpng has
+ * been distributed and maintained world-wide, continually since 1995,
+ * the Copyright owner claims "common-law trademark protection" in any
+ * jurisdiction where common-law trademark is recognized.
+ *
+ * OSI CERTIFICATION:
+ *
+ * Libpng is OSI Certified Open Source Software.  OSI Certified Open Source is
+ * a certification mark of the Open Source Initiative. OSI has not addressed
+ * the additional disclaimers inserted at version 1.0.7.
+ *
+ * EXPORT CONTROL:
+ *
+ * The Copyright owner believes that the Export Control Classification
+ * Number (ECCN) for libpng is EAR99, which means not subject to export
+ * controls or International Traffic in Arms Regulations (ITAR) because
+ * it is open source, publicly available software, that does not contain
+ * any encryption software.  See the EAR, paragraphs 734.3(b)(3) and
+ * 734.7(b).
+ */
+
+/*
+ * A "png_get_copyright" function is available, for convenient use in "about"
+ * boxes and the like:
+ *
+ *    printf("%s", png_get_copyright(NULL));
+ *
+ * Also, the PNG logo (in PNG format, of course) is supplied in the
+ * files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31).
+ */
+
+/*
+ * The contributing authors would like to thank all those who helped
+ * with testing, bug fixes, and patience.  This wouldn't have been
+ * possible without all of you.
+ *
+ * Thanks to Frank J. T. Wojcik for helping with the documentation.
+ */
+
+/* Note about libpng version numbers:
+ *
+ *    Due to various miscommunications, unforeseen code incompatibilities
+ *    and occasional factors outside the authors' control, version numbering
+ *    on the library has not always been consistent and straightforward.
+ *    The following table summarizes matters since version 0.89c, which was
+ *    the first widely used release:
+ *
+ *    source                 png.h  png.h  shared-lib
+ *    version                string   int  version
+ *    -------                ------ -----  ----------
+ *    0.89c "1.0 beta 3"     0.89      89  1.0.89
+ *    0.90  "1.0 beta 4"     0.90      90  0.90  [should have been 2.0.90]
+ *    0.95  "1.0 beta 5"     0.95      95  0.95  [should have been 2.0.95]
+ *    0.96  "1.0 beta 6"     0.96      96  0.96  [should have been 2.0.96]
+ *    0.97b "1.00.97 beta 7" 1.00.97   97  1.0.1 [should have been 2.0.97]
+ *    0.97c                  0.97      97  2.0.97
+ *    0.98                   0.98      98  2.0.98
+ *    0.99                   0.99      98  2.0.99
+ *    0.99a-m                0.99      99  2.0.99
+ *    1.00                   1.00     100  2.1.0 [100 should be 10000]
+ *    1.0.0      (from here on, the   100  2.1.0 [100 should be 10000]
+ *    1.0.1       png.h string is   10001  2.1.0
+ *    1.0.1a-e    identical to the  10002  from here on, the shared library
+ *    1.0.2       source version)   10002  is 2.V where V is the source code
+ *    1.0.2a-b                      10003  version, except as noted.
+ *    1.0.3                         10003
+ *    1.0.3a-d                      10004
+ *    1.0.4                         10004
+ *    1.0.4a-f                      10005
+ *    1.0.5 (+ 2 patches)           10005
+ *    1.0.5a-d                      10006
+ *    1.0.5e-r                      10100 (not source compatible)
+ *    1.0.5s-v                      10006 (not binary compatible)
+ *    1.0.6 (+ 3 patches)           10006 (still binary incompatible)
+ *    1.0.6d-f                      10007 (still binary incompatible)
+ *    1.0.6g                        10007
+ *    1.0.6h                        10007  10.6h (testing xy.z so-numbering)
+ *    1.0.6i                        10007  10.6i
+ *    1.0.6j                        10007  2.1.0.6j (incompatible with 1.0.0)
+ *    1.0.7beta11-14        DLLNUM  10007  2.1.0.7beta11-14 (binary compatible)
+ *    1.0.7beta15-18           1    10007  2.1.0.7beta15-18 (binary compatible)
+ *    1.0.7rc1-2               1    10007  2.1.0.7rc1-2 (binary compatible)
+ *    1.0.7                    1    10007  (still compatible)
+ *    ...
+ *    1.0.19                  10    10019  10.so.0.19[.0]
+ *    ...
+ *    1.2.59                  13    10257  12.so.0.59[.0]
+ *    ...
+ *    1.5.30                  15    10527  15.so.15.30[.0]
+ *    ...
+ *    1.6.34                  16    10633  16.so.16.34[.0]
+ *
+ *    Henceforth the source version will match the shared-library major
+ *    and minor numbers; the shared-library major version number will be
+ *    used for changes in backward compatibility, as it is intended.  The
+ *    PNG_LIBPNG_VER macro, which is not used within libpng but is available
+ *    for applications, is an unsigned integer of the form xyyzz corresponding
+ *    to the source version x.y.z (leading zeros in y and z).  Beta versions
+ *    were given the previous public release number plus a letter, until
+ *    version 1.0.6j; from then on they were given the upcoming public
+ *    release number plus "betaNN" or "rcNN".
+ *
+ *    Binary incompatibility exists only when applications make direct access
+ *    to the info_ptr or png_ptr members through png.h, and the compiled
+ *    application is loaded with a different version of the library.
+ *
+ *    DLLNUM will change each time there are forward or backward changes
+ *    in binary compatibility (e.g., when a new feature is added).
+ *
+ * See libpng.txt or libpng.3 for more information.  The PNG specification
+ * is available as a W3C Recommendation and as an ISO Specification,
+ * <https://www.w3.org/TR/2003/REC-PNG-20031110/
+ */
+
+/*
+ * Y2K compliance in libpng:
+ * =========================
+ *
+ *    September 29, 2017
+ *
+ *    Since the PNG Development group is an ad-hoc body, we can't make
+ *    an official declaration.
+ *
+ *    This is your unofficial assurance that libpng from version 0.71 and
+ *    upward through 1.6.34 are Y2K compliant.  It is my belief that
+ *    earlier versions were also Y2K compliant.
+ *
+ *    Libpng only has two year fields.  One is a 2-byte unsigned integer
+ *    that will hold years up to 65535.  The other, which is deprecated,
+ *    holds the date in text format, and will hold years up to 9999.
+ *
+ *    The integer is
+ *        "png_uint_16 year" in png_time_struct.
+ *
+ *    The string is
+ *        "char time_buffer[29]" in png_struct.  This is no longer used
+ *    in libpng-1.6.x and will be removed from libpng-1.7.0.
+ *
+ *    There are seven time-related functions:
+ *        png.c: png_convert_to_rfc_1123_buffer() in png.c
+ *          (formerly png_convert_to_rfc_1123() prior to libpng-1.5.x and
+ *          png_convert_to_rfc_1152() in error prior to libpng-0.98)
+ *        png_convert_from_struct_tm() in pngwrite.c, called in pngwrite.c
+ *        png_convert_from_time_t() in pngwrite.c
+ *        png_get_tIME() in pngget.c
+ *        png_handle_tIME() in pngrutil.c, called in pngread.c
+ *        png_set_tIME() in pngset.c
+ *        png_write_tIME() in pngwutil.c, called in pngwrite.c
+ *
+ *    All handle dates properly in a Y2K environment.  The
+ *    png_convert_from_time_t() function calls gmtime() to convert from system
+ *    clock time, which returns (year - 1900), which we properly convert to
+ *    the full 4-digit year.  There is a possibility that libpng applications
+ *    are not passing 4-digit years into the png_convert_to_rfc_1123_buffer()
+ *    function, or that they are incorrectly passing only a 2-digit year
+ *    instead of "year - 1900" into the png_convert_from_struct_tm() function,
+ *    but this is not under our control.  The libpng documentation has always
+ *    stated that it works with 4-digit years, and the APIs have been
+ *    documented as such.
+ *
+ *    The tIME chunk itself is also Y2K compliant.  It uses a 2-byte unsigned
+ *    integer to hold the year, and can hold years as large as 65535.
+ *
+ *    zlib, upon which libpng depends, is also Y2K compliant.  It contains
+ *    no date-related code.
+ *
+ *       Glenn Randers-Pehrson
+ *       libpng maintainer
+ *       PNG Development Group
+ */
+
+#ifndef PNG_H
+#define PNG_H
+
+/* This is not the place to learn how to use libpng. The file libpng-manual.txt
+ * describes how to use libpng, and the file example.c summarizes it
+ * with some code on which to build.  This file is useful for looking
+ * at the actual function definitions and structure components.  If that
+ * file has been stripped from your copy of libpng, you can find it at
+ * <http://www.libpng.org/pub/png/libpng-manual.txt>
+ *
+ * If you just need to read a PNG file and don't want to read the documentation
+ * skip to the end of this file and read the section entitled 'simplified API'.
+ */
+
+/* Version information for png.h - this should match the version in png.c */
+#define PNG_LIBPNG_VER_STRING "1.6.34"
+#define PNG_HEADER_VERSION_STRING " libpng version 1.6.34 - September 29, 2017\n"
+
+#define PNG_LIBPNG_VER_SONUM   16
+#define PNG_LIBPNG_VER_DLLNUM  16
+
+/* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */
+#define PNG_LIBPNG_VER_MAJOR   1
+#define PNG_LIBPNG_VER_MINOR   6
+#define PNG_LIBPNG_VER_RELEASE 34
+
+/* This should match the numeric part of the final component of
+ * PNG_LIBPNG_VER_STRING, omitting any leading zero:
+ */
+
+#define PNG_LIBPNG_VER_BUILD  0
+
+/* Release Status */
+#define PNG_LIBPNG_BUILD_ALPHA    1
+#define PNG_LIBPNG_BUILD_BETA     2
+#define PNG_LIBPNG_BUILD_RC       3
+#define PNG_LIBPNG_BUILD_STABLE   4
+#define PNG_LIBPNG_BUILD_RELEASE_STATUS_MASK 7
+
+/* Release-Specific Flags */
+#define PNG_LIBPNG_BUILD_PATCH    8 /* Can be OR'ed with
+                                       PNG_LIBPNG_BUILD_STABLE only */
+#define PNG_LIBPNG_BUILD_PRIVATE 16 /* Cannot be OR'ed with
+                                       PNG_LIBPNG_BUILD_SPECIAL */
+#define PNG_LIBPNG_BUILD_SPECIAL 32 /* Cannot be OR'ed with
+                                       PNG_LIBPNG_BUILD_PRIVATE */
+
+#define PNG_LIBPNG_BUILD_BASE_TYPE PNG_LIBPNG_BUILD_STABLE
+
+/* Careful here.  At one time, Guy wanted to use 082, but that would be octal.
+ * We must not include leading zeros.
+ * Versions 0.7 through 1.0.0 were in the range 0 to 100 here (only
+ * version 1.0.0 was mis-numbered 100 instead of 10000).  From
+ * version 1.0.1 it's    xxyyzz, where x=major, y=minor, z=release
+ */
+#define PNG_LIBPNG_VER 10634 /* 1.6.34 */
+
+/* Library configuration: these options cannot be changed after
+ * the library has been built.
+ */
+#ifndef PNGLCONF_H
+/* If pnglibconf.h is missing, you can
+ * copy scripts/pnglibconf.h.prebuilt to pnglibconf.h
+ */
+#   include "pnglibconf.h"
+#endif
+
+#ifndef PNG_VERSION_INFO_ONLY
+/* Machine specific configuration. */
+#  include "pngconf.h"
+#endif
+
+/*
+ * Added at libpng-1.2.8
+ *
+ * Ref MSDN: Private as priority over Special
+ * VS_FF_PRIVATEBUILD File *was not* built using standard release
+ * procedures. If this value is given, the StringFileInfo block must
+ * contain a PrivateBuild string.
+ *
+ * VS_FF_SPECIALBUILD File *was* built by the original company using
+ * standard release procedures but is a variation of the standard
+ * file of the same version number. If this value is given, the
+ * StringFileInfo block must contain a SpecialBuild string.
+ */
+
+#ifdef PNG_USER_PRIVATEBUILD /* From pnglibconf.h */
+#  define PNG_LIBPNG_BUILD_TYPE \
+       (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_PRIVATE)
+#else
+#  ifdef PNG_LIBPNG_SPECIALBUILD
+#    define PNG_LIBPNG_BUILD_TYPE \
+         (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_SPECIAL)
+#  else
+#    define PNG_LIBPNG_BUILD_TYPE (PNG_LIBPNG_BUILD_BASE_TYPE)
+#  endif
+#endif
+
+#ifndef PNG_VERSION_INFO_ONLY
+
+/* Inhibit C++ name-mangling for libpng functions but not for system calls. */
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/* Version information for C files, stored in png.c.  This had better match
+ * the version above.
+ */
+#define png_libpng_ver png_get_header_ver(NULL)
+
+/* This file is arranged in several sections:
+ *
+ * 1. [omitted]
+ * 2. Any configuration options that can be specified by for the application
+ *    code when it is built.  (Build time configuration is in pnglibconf.h)
+ * 3. Type definitions (base types are defined in pngconf.h), structure
+ *    definitions.
+ * 4. Exported library functions.
+ * 5. Simplified API.
+ * 6. Implementation options.
+ *
+ * The library source code has additional files (principally pngpriv.h) that
+ * allow configuration of the library.
+ */
+
+/* Section 1: [omitted] */
+
+/* Section 2: run time configuration
+ * See pnglibconf.h for build time configuration
+ *
+ * Run time configuration allows the application to choose between
+ * implementations of certain arithmetic APIs.  The default is set
+ * at build time and recorded in pnglibconf.h, but it is safe to
+ * override these (and only these) settings.  Note that this won't
+ * change what the library does, only application code, and the
+ * settings can (and probably should) be made on a per-file basis
+ * by setting the #defines before including png.h
+ *
+ * Use macros to read integers from PNG data or use the exported
+ * functions?
+ *   PNG_USE_READ_MACROS: use the macros (see below)  Note that
+ *     the macros evaluate their argument multiple times.
+ *   PNG_NO_USE_READ_MACROS: call the relevant library function.
+ *
+ * Use the alternative algorithm for compositing alpha samples that
+ * does not use division?
+ *   PNG_READ_COMPOSITE_NODIV_SUPPORTED: use the 'no division'
+ *      algorithm.
+ *   PNG_NO_READ_COMPOSITE_NODIV: use the 'division' algorithm.
+ *
+ * How to handle benign errors if PNG_ALLOW_BENIGN_ERRORS is
+ * false?
+ *   PNG_ALLOW_BENIGN_ERRORS: map calls to the benign error
+ *      APIs to png_warning.
+ * Otherwise the calls are mapped to png_error.
+ */
+
+/* Section 3: type definitions, including structures and compile time
+ * constants.
+ * See pngconf.h for base types that vary by machine/system
+ */
+
+/* This triggers a compiler error in png.c, if png.c and png.h
+ * do not agree upon the version number.
+ */
+typedef char* png_libpng_version_1_6_34;
+
+/* Basic control structions.  Read libpng-manual.txt or libpng.3 for more info.
+ *
+ * png_struct is the cache of information used while reading or writing a single
+ * PNG file.  One of these is always required, although the simplified API
+ * (below) hides the creation and destruction of it.
+ */
+typedef struct png_struct_def png_struct;
+typedef const png_struct * png_const_structp;
+typedef png_struct * png_structp;
+typedef png_struct * * png_structpp;
+
+/* png_info contains information read from or to be written to a PNG file.  One
+ * or more of these must exist while reading or creating a PNG file.  The
+ * information is not used by libpng during read but is used to control what
+ * gets written when a PNG file is created.  "png_get_" function calls read
+ * information during read and "png_set_" functions calls write information
+ * when creating a PNG.
+ * been moved into a separate header file that is not accessible to
+ * applications.  Read libpng-manual.txt or libpng.3 for more info.
+ */
+typedef struct png_info_def png_info;
+typedef png_info * png_infop;
+typedef const png_info * png_const_infop;
+typedef png_info * * png_infopp;
+
+/* Types with names ending 'p' are pointer types.  The corresponding types with
+ * names ending 'rp' are identical pointer types except that the pointer is
+ * marked 'restrict', which means that it is the only pointer to the object
+ * passed to the function.  Applications should not use the 'restrict' types;
+ * it is always valid to pass 'p' to a pointer with a function argument of the
+ * corresponding 'rp' type.  Different compilers have different rules with
+ * regard to type matching in the presence of 'restrict'.  For backward
+ * compatibility libpng callbacks never have 'restrict' in their parameters and,
+ * consequentially, writing portable application code is extremely difficult if
+ * an attempt is made to use 'restrict'.
+ */
+typedef png_struct * PNG_RESTRICT png_structrp;
+typedef const png_struct * PNG_RESTRICT png_const_structrp;
+typedef png_info * PNG_RESTRICT png_inforp;
+typedef const png_info * PNG_RESTRICT png_const_inforp;
+
+/* Three color definitions.  The order of the red, green, and blue, (and the
+ * exact size) is not important, although the size of the fields need to
+ * be png_byte or png_uint_16 (as defined below).
+ */
+typedef struct png_color_struct
+{
+   png_byte red;
+   png_byte green;
+   png_byte blue;
+} png_color;
+typedef png_color * png_colorp;
+typedef const png_color * png_const_colorp;
+typedef png_color * * png_colorpp;
+
+typedef struct png_color_16_struct
+{
+   png_byte index;    /* used for palette files */
+   png_uint_16 red;   /* for use in red green blue files */
+   png_uint_16 green;
+   png_uint_16 blue;
+   png_uint_16 gray;  /* for use in grayscale files */
+} png_color_16;
+typedef png_color_16 * png_color_16p;
+typedef const png_color_16 * png_const_color_16p;
+typedef png_color_16 * * png_color_16pp;
+
+typedef struct png_color_8_struct
+{
+   png_byte red;   /* for use in red green blue files */
+   png_byte green;
+   png_byte blue;
+   png_byte gray;  /* for use in grayscale files */
+   png_byte alpha; /* for alpha channel files */
+} png_color_8;
+typedef png_color_8 * png_color_8p;
+typedef const png_color_8 * png_const_color_8p;
+typedef png_color_8 * * png_color_8pp;
+
+/*
+ * The following two structures are used for the in-core representation
+ * of sPLT chunks.
+ */
+typedef struct png_sPLT_entry_struct
+{
+   png_uint_16 red;
+   png_uint_16 green;
+   png_uint_16 blue;
+   png_uint_16 alpha;
+   png_uint_16 frequency;
+} png_sPLT_entry;
+typedef png_sPLT_entry * png_sPLT_entryp;
+typedef const png_sPLT_entry * png_const_sPLT_entryp;
+typedef png_sPLT_entry * * png_sPLT_entrypp;
+
+/*  When the depth of the sPLT palette is 8 bits, the color and alpha samples
+ *  occupy the LSB of their respective members, and the MSB of each member
+ *  is zero-filled.  The frequency member always occupies the full 16 bits.
+ */
+
+typedef struct png_sPLT_struct
+{
+   png_charp name;           /* palette name */
+   png_byte depth;           /* depth of palette samples */
+   png_sPLT_entryp entries;  /* palette entries */
+   png_int_32 nentries;      /* number of palette entries */
+} png_sPLT_t;
+typedef png_sPLT_t * png_sPLT_tp;
+typedef const png_sPLT_t * png_const_sPLT_tp;
+typedef png_sPLT_t * * png_sPLT_tpp;
+
+#ifdef PNG_TEXT_SUPPORTED
+/* png_text holds the contents of a text/ztxt/itxt chunk in a PNG file,
+ * and whether that contents is compressed or not.  The "key" field
+ * points to a regular zero-terminated C string.  The "text" fields can be a
+ * regular C string, an empty string, or a NULL pointer.
+ * However, the structure returned by png_get_text() will always contain
+ * the "text" field as a regular zero-terminated C string (possibly
+ * empty), never a NULL pointer, so it can be safely used in printf() and
+ * other string-handling functions.  Note that the "itxt_length", "lang", and
+ * "lang_key" members of the structure only exist when the library is built
+ * with iTXt chunk support.  Prior to libpng-1.4.0 the library was built by
+ * default without iTXt support. Also note that when iTXt *is* supported,
+ * the "lang" and "lang_key" fields contain NULL pointers when the
+ * "compression" field contains * PNG_TEXT_COMPRESSION_NONE or
+ * PNG_TEXT_COMPRESSION_zTXt. Note that the "compression value" is not the
+ * same as what appears in the PNG tEXt/zTXt/iTXt chunk's "compression flag"
+ * which is always 0 or 1, or its "compression method" which is always 0.
+ */
+typedef struct png_text_struct
+{
+   int  compression;       /* compression value:
+                             -1: tEXt, none
+                              0: zTXt, deflate
+                              1: iTXt, none
+                              2: iTXt, deflate  */
+   png_charp key;          /* keyword, 1-79 character description of "text" */
+   png_charp text;         /* comment, may be an empty string (ie "")
+                              or a NULL pointer */
+   png_size_t text_length; /* length of the text string */
+   png_size_t itxt_length; /* length of the itxt string */
+   png_charp lang;         /* language code, 0-79 characters
+                              or a NULL pointer */
+   png_charp lang_key;     /* keyword translated UTF-8 string, 0 or more
+                              chars or a NULL pointer */
+} png_text;
+typedef png_text * png_textp;
+typedef const png_text * png_const_textp;
+typedef png_text * * png_textpp;
+#endif
+
+/* Supported compression types for text in PNG files (tEXt, and zTXt).
+ * The values of the PNG_TEXT_COMPRESSION_ defines should NOT be changed. */
+#define PNG_TEXT_COMPRESSION_NONE_WR -3
+#define PNG_TEXT_COMPRESSION_zTXt_WR -2
+#define PNG_TEXT_COMPRESSION_NONE    -1
+#define PNG_TEXT_COMPRESSION_zTXt     0
+#define PNG_ITXT_COMPRESSION_NONE     1
+#define PNG_ITXT_COMPRESSION_zTXt     2
+#define PNG_TEXT_COMPRESSION_LAST     3  /* Not a valid value */
+
+/* png_time is a way to hold the time in an machine independent way.
+ * Two conversions are provided, both from time_t and struct tm.  There
+ * is no portable way to convert to either of these structures, as far
+ * as I know.  If you know of a portable way, send it to me.  As a side
+ * note - PNG has always been Year 2000 compliant!
+ */
+typedef struct png_time_struct
+{
+   png_uint_16 year; /* full year, as in, 1995 */
+   png_byte month;   /* month of year, 1 - 12 */
+   png_byte day;     /* day of month, 1 - 31 */
+   png_byte hour;    /* hour of day, 0 - 23 */
+   png_byte minute;  /* minute of hour, 0 - 59 */
+   png_byte second;  /* second of minute, 0 - 60 (for leap seconds) */
+} png_time;
+typedef png_time * png_timep;
+typedef const png_time * png_const_timep;
+typedef png_time * * png_timepp;
+
+#if defined(PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED) ||\
+   defined(PNG_USER_CHUNKS_SUPPORTED)
+/* png_unknown_chunk is a structure to hold queued chunks for which there is
+ * no specific support.  The idea is that we can use this to queue
+ * up private chunks for output even though the library doesn't actually
+ * know about their semantics.
+ *
+ * The data in the structure is set by libpng on read and used on write.
+ */
+typedef struct png_unknown_chunk_t
+{
+   png_byte name[5]; /* Textual chunk name with '\0' terminator */
+   png_byte *data;   /* Data, should not be modified on read! */
+   png_size_t size;
+
+   /* On write 'location' must be set using the flag values listed below.
+    * Notice that on read it is set by libpng however the values stored have
+    * more bits set than are listed below.  Always treat the value as a
+    * bitmask.  On write set only one bit - setting multiple bits may cause the
+    * chunk to be written in multiple places.
+    */
+   png_byte location; /* mode of operation at read time */
+}
+png_unknown_chunk;
+
+typedef png_unknown_chunk * png_unknown_chunkp;
+typedef const png_unknown_chunk * png_const_unknown_chunkp;
+typedef png_unknown_chunk * * png_unknown_chunkpp;
+#endif
+
+/* Flag values for the unknown chunk location byte. */
+#define PNG_HAVE_IHDR  0x01
+#define PNG_HAVE_PLTE  0x02
+#define PNG_AFTER_IDAT 0x08
+
+/* Maximum positive integer used in PNG is (2^31)-1 */
+#define PNG_UINT_31_MAX ((png_uint_32)0x7fffffffL)
+#define PNG_UINT_32_MAX ((png_uint_32)(-1))
+#define PNG_SIZE_MAX ((png_size_t)(-1))
+
+/* These are constants for fixed point values encoded in the
+ * PNG specification manner (x100000)
+ */
+#define PNG_FP_1    100000
+#define PNG_FP_HALF  50000
+#define PNG_FP_MAX  ((png_fixed_point)0x7fffffffL)
+#define PNG_FP_MIN  (-PNG_FP_MAX)
+
+/* These describe the color_type field in png_info. */
+/* color type masks */
+#define PNG_COLOR_MASK_PALETTE    1
+#define PNG_COLOR_MASK_COLOR      2
+#define PNG_COLOR_MASK_ALPHA      4
+
+/* color types.  Note that not all combinations are legal */
+#define PNG_COLOR_TYPE_GRAY 0
+#define PNG_COLOR_TYPE_PALETTE  (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE)
+#define PNG_COLOR_TYPE_RGB        (PNG_COLOR_MASK_COLOR)
+#define PNG_COLOR_TYPE_RGB_ALPHA  (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA)
+#define PNG_COLOR_TYPE_GRAY_ALPHA (PNG_COLOR_MASK_ALPHA)
+/* aliases */
+#define PNG_COLOR_TYPE_RGBA  PNG_COLOR_TYPE_RGB_ALPHA
+#define PNG_COLOR_TYPE_GA  PNG_COLOR_TYPE_GRAY_ALPHA
+
+/* This is for compression type. PNG 1.0-1.2 only define the single type. */
+#define PNG_COMPRESSION_TYPE_BASE 0 /* Deflate method 8, 32K window */
+#define PNG_COMPRESSION_TYPE_DEFAULT PNG_COMPRESSION_TYPE_BASE
+
+/* This is for filter type. PNG 1.0-1.2 only define the single type. */
+#define PNG_FILTER_TYPE_BASE      0 /* Single row per-byte filtering */
+#define PNG_INTRAPIXEL_DIFFERENCING 64 /* Used only in MNG datastreams */
+#define PNG_FILTER_TYPE_DEFAULT   PNG_FILTER_TYPE_BASE
+
+/* These are for the interlacing type.  These values should NOT be changed. */
+#define PNG_INTERLACE_NONE        0 /* Non-interlaced image */
+#define PNG_INTERLACE_ADAM7       1 /* Adam7 interlacing */
+#define PNG_INTERLACE_LAST        2 /* Not a valid value */
+
+/* These are for the oFFs chunk.  These values should NOT be changed. */
+#define PNG_OFFSET_PIXEL          0 /* Offset in pixels */
+#define PNG_OFFSET_MICROMETER     1 /* Offset in micrometers (1/10^6 meter) */
+#define PNG_OFFSET_LAST           2 /* Not a valid value */
+
+/* These are for the pCAL chunk.  These values should NOT be changed. */
+#define PNG_EQUATION_LINEAR       0 /* Linear transformation */
+#define PNG_EQUATION_BASE_E       1 /* Exponential base e transform */
+#define PNG_EQUATION_ARBITRARY    2 /* Arbitrary base exponential transform */
+#define PNG_EQUATION_HYPERBOLIC   3 /* Hyperbolic sine transformation */
+#define PNG_EQUATION_LAST         4 /* Not a valid value */
+
+/* These are for the sCAL chunk.  These values should NOT be changed. */
+#define PNG_SCALE_UNKNOWN         0 /* unknown unit (image scale) */
+#define PNG_SCALE_METER           1 /* meters per pixel */
+#define PNG_SCALE_RADIAN          2 /* radians per pixel */
+#define PNG_SCALE_LAST            3 /* Not a valid value */
+
+/* These are for the pHYs chunk.  These values should NOT be changed. */
+#define PNG_RESOLUTION_UNKNOWN    0 /* pixels/unknown unit (aspect ratio) */
+#define PNG_RESOLUTION_METER      1 /* pixels/meter */
+#define PNG_RESOLUTION_LAST       2 /* Not a valid value */
+
+/* These are for the sRGB chunk.  These values should NOT be changed. */
+#define PNG_sRGB_INTENT_PERCEPTUAL 0
+#define PNG_sRGB_INTENT_RELATIVE   1
+#define PNG_sRGB_INTENT_SATURATION 2
+#define PNG_sRGB_INTENT_ABSOLUTE   3
+#define PNG_sRGB_INTENT_LAST       4 /* Not a valid value */
+
+/* This is for text chunks */
+#define PNG_KEYWORD_MAX_LENGTH     79
+
+/* Maximum number of entries in PLTE/sPLT/tRNS arrays */
+#define PNG_MAX_PALETTE_LENGTH    256
+
+/* These determine if an ancillary chunk's data has been successfully read
+ * from the PNG header, or if the application has filled in the corresponding
+ * data in the info_struct to be written into the output file.  The values
+ * of the PNG_INFO_<chunk> defines should NOT be changed.
+ */
+#define PNG_INFO_gAMA 0x0001U
+#define PNG_INFO_sBIT 0x0002U
+#define PNG_INFO_cHRM 0x0004U
+#define PNG_INFO_PLTE 0x0008U
+#define PNG_INFO_tRNS 0x0010U
+#define PNG_INFO_bKGD 0x0020U
+#define PNG_INFO_hIST 0x0040U
+#define PNG_INFO_pHYs 0x0080U
+#define PNG_INFO_oFFs 0x0100U
+#define PNG_INFO_tIME 0x0200U
+#define PNG_INFO_pCAL 0x0400U
+#define PNG_INFO_sRGB 0x0800U  /* GR-P, 0.96a */
+#define PNG_INFO_iCCP 0x1000U  /* ESR, 1.0.6 */
+#define PNG_INFO_sPLT 0x2000U  /* ESR, 1.0.6 */
+#define PNG_INFO_sCAL 0x4000U  /* ESR, 1.0.6 */
+#define PNG_INFO_IDAT 0x8000U  /* ESR, 1.0.6 */
+#define PNG_INFO_eXIf 0x10000U /* GR-P, 1.6.31 */
+
+/* This is used for the transformation routines, as some of them
+ * change these values for the row.  It also should enable using
+ * the routines for other purposes.
+ */
+typedef struct png_row_info_struct
+{
+   png_uint_32 width;    /* width of row */
+   png_size_t rowbytes;  /* number of bytes in row */
+   png_byte color_type;  /* color type of row */
+   png_byte bit_depth;   /* bit depth of row */
+   png_byte channels;    /* number of channels (1, 2, 3, or 4) */
+   png_byte pixel_depth; /* bits per pixel (depth * channels) */
+} png_row_info;
+
+typedef png_row_info * png_row_infop;
+typedef png_row_info * * png_row_infopp;
+
+/* These are the function types for the I/O functions and for the functions
+ * that allow the user to override the default I/O functions with his or her
+ * own.  The png_error_ptr type should match that of user-supplied warning
+ * and error functions, while the png_rw_ptr type should match that of the
+ * user read/write data functions.  Note that the 'write' function must not
+ * modify the buffer it is passed. The 'read' function, on the other hand, is
+ * expected to return the read data in the buffer.
+ */
+typedef PNG_CALLBACK(void, *png_error_ptr, (png_structp, png_const_charp));
+typedef PNG_CALLBACK(void, *png_rw_ptr, (png_structp, png_bytep, png_size_t));
+typedef PNG_CALLBACK(void, *png_flush_ptr, (png_structp));
+typedef PNG_CALLBACK(void, *png_read_status_ptr, (png_structp, png_uint_32,
+    int));
+typedef PNG_CALLBACK(void, *png_write_status_ptr, (png_structp, png_uint_32,
+    int));
+
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
+typedef PNG_CALLBACK(void, *png_progressive_info_ptr, (png_structp, png_infop));
+typedef PNG_CALLBACK(void, *png_progressive_end_ptr, (png_structp, png_infop));
+
+/* The following callback receives png_uint_32 row_number, int pass for the
+ * png_bytep data of the row.  When transforming an interlaced image the
+ * row number is the row number within the sub-image of the interlace pass, so
+ * the value will increase to the height of the sub-image (not the full image)
+ * then reset to 0 for the next pass.
+ *
+ * Use PNG_ROW_FROM_PASS_ROW(row, pass) and PNG_COL_FROM_PASS_COL(col, pass) to
+ * find the output pixel (x,y) given an interlaced sub-image pixel
+ * (row,col,pass).  (See below for these macros.)
+ */
+typedef PNG_CALLBACK(void, *png_progressive_row_ptr, (png_structp, png_bytep,
+    png_uint_32, int));
+#endif
+
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
+    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
+typedef PNG_CALLBACK(void, *png_user_transform_ptr, (png_structp, png_row_infop,
+    png_bytep));
+#endif
+
+#ifdef PNG_USER_CHUNKS_SUPPORTED
+typedef PNG_CALLBACK(int, *png_user_chunk_ptr, (png_structp,
+    png_unknown_chunkp));
+#endif
+#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
+/* not used anywhere */
+/* typedef PNG_CALLBACK(void, *png_unknown_chunk_ptr, (png_structp)); */
+#endif
+
+#ifdef PNG_SETJMP_SUPPORTED
+/* This must match the function definition in <setjmp.h>, and the application
+ * must include this before png.h to obtain the definition of jmp_buf.  The
+ * function is required to be PNG_NORETURN, but this is not checked.  If the
+ * function does return the application will crash via an abort() or similar
+ * system level call.
+ *
+ * If you get a warning here while building the library you may need to make
+ * changes to ensure that pnglibconf.h records the calling convention used by
+ * your compiler.  This may be very difficult - try using a different compiler
+ * to build the library!
+ */
+PNG_FUNCTION(void, (PNGCAPI *png_longjmp_ptr), PNGARG((jmp_buf, int)), typedef);
+#endif
+
+/* Transform masks for the high-level interface */
+#define PNG_TRANSFORM_IDENTITY       0x0000    /* read and write */
+#define PNG_TRANSFORM_STRIP_16       0x0001    /* read only */
+#define PNG_TRANSFORM_STRIP_ALPHA    0x0002    /* read only */
+#define PNG_TRANSFORM_PACKING        0x0004    /* read and write */
+#define PNG_TRANSFORM_PACKSWAP       0x0008    /* read and write */
+#define PNG_TRANSFORM_EXPAND         0x0010    /* read only */
+#define PNG_TRANSFORM_INVERT_MONO    0x0020    /* read and write */
+#define PNG_TRANSFORM_SHIFT          0x0040    /* read and write */
+#define PNG_TRANSFORM_BGR            0x0080    /* read and write */
+#define PNG_TRANSFORM_SWAP_ALPHA     0x0100    /* read and write */
+#define PNG_TRANSFORM_SWAP_ENDIAN    0x0200    /* read and write */
+#define PNG_TRANSFORM_INVERT_ALPHA   0x0400    /* read and write */
+#define PNG_TRANSFORM_STRIP_FILLER   0x0800    /* write only */
+/* Added to libpng-1.2.34 */
+#define PNG_TRANSFORM_STRIP_FILLER_BEFORE PNG_TRANSFORM_STRIP_FILLER
+#define PNG_TRANSFORM_STRIP_FILLER_AFTER 0x1000 /* write only */
+/* Added to libpng-1.4.0 */
+#define PNG_TRANSFORM_GRAY_TO_RGB   0x2000      /* read only */
+/* Added to libpng-1.5.4 */
+#define PNG_TRANSFORM_EXPAND_16     0x4000      /* read only */
+#if INT_MAX >= 0x8000 /* else this might break */
+#define PNG_TRANSFORM_SCALE_16      0x8000      /* read only */
+#endif
+
+/* Flags for MNG supported features */
+#define PNG_FLAG_MNG_EMPTY_PLTE     0x01
+#define PNG_FLAG_MNG_FILTER_64      0x04
+#define PNG_ALL_MNG_FEATURES        0x05
+
+/* NOTE: prior to 1.5 these functions had no 'API' style declaration,
+ * this allowed the zlib default functions to be used on Windows
+ * platforms.  In 1.5 the zlib default malloc (which just calls malloc and
+ * ignores the first argument) should be completely compatible with the
+ * following.
+ */
+typedef PNG_CALLBACK(png_voidp, *png_malloc_ptr, (png_structp,
+    png_alloc_size_t));
+typedef PNG_CALLBACK(void, *png_free_ptr, (png_structp, png_voidp));
+
+/* Section 4: exported functions
+ * Here are the function definitions most commonly used.  This is not
+ * the place to find out how to use libpng.  See libpng-manual.txt for the
+ * full explanation, see example.c for the summary.  This just provides
+ * a simple one line description of the use of each function.
+ *
+ * The PNG_EXPORT() and PNG_EXPORTA() macros used below are defined in
+ * pngconf.h and in the *.dfn files in the scripts directory.
+ *
+ *   PNG_EXPORT(ordinal, type, name, (args));
+ *
+ *       ordinal:    ordinal that is used while building
+ *                   *.def files. The ordinal value is only
+ *                   relevant when preprocessing png.h with
+ *                   the *.dfn files for building symbol table
+ *                   entries, and are removed by pngconf.h.
+ *       type:       return type of the function
+ *       name:       function name
+ *       args:       function arguments, with types
+ *
+ * When we wish to append attributes to a function prototype we use
+ * the PNG_EXPORTA() macro instead.
+ *
+ *   PNG_EXPORTA(ordinal, type, name, (args), attributes);
+ *
+ *       ordinal, type, name, and args: same as in PNG_EXPORT().
+ *       attributes: function attributes
+ */
+
+/* Returns the version number of the library */
+PNG_EXPORT(1, png_uint_32, png_access_version_number, (void));
+
+/* Tell lib we have already handled the first <num_bytes> magic bytes.
+ * Handling more than 8 bytes from the beginning of the file is an error.
+ */
+PNG_EXPORT(2, void, png_set_sig_bytes, (png_structrp png_ptr, int num_bytes));
+
+/* Check sig[start] through sig[start + num_to_check - 1] to see if it's a
+ * PNG file.  Returns zero if the supplied bytes match the 8-byte PNG
+ * signature, and non-zero otherwise.  Having num_to_check == 0 or
+ * start > 7 will always fail (ie return non-zero).
+ */
+PNG_EXPORT(3, int, png_sig_cmp, (png_const_bytep sig, png_size_t start,
+    png_size_t num_to_check));
+
+/* Simple signature checking function.  This is the same as calling
+ * png_check_sig(sig, n) := !png_sig_cmp(sig, 0, n).
+ */
+#define png_check_sig(sig, n) !png_sig_cmp((sig), 0, (n))
+
+/* Allocate and initialize png_ptr struct for reading, and any other memory. */
+PNG_EXPORTA(4, png_structp, png_create_read_struct,
+    (png_const_charp user_png_ver, png_voidp error_ptr,
+    png_error_ptr error_fn, png_error_ptr warn_fn),
+    PNG_ALLOCATED);
+
+/* Allocate and initialize png_ptr struct for writing, and any other memory */
+PNG_EXPORTA(5, png_structp, png_create_write_struct,
+    (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn,
+    png_error_ptr warn_fn),
+    PNG_ALLOCATED);
+
+PNG_EXPORT(6, png_size_t, png_get_compression_buffer_size,
+    (png_const_structrp png_ptr));
+
+PNG_EXPORT(7, void, png_set_compression_buffer_size, (png_structrp png_ptr,
+    png_size_t size));
+
+/* Moved from pngconf.h in 1.4.0 and modified to ensure setjmp/longjmp
+ * match up.
+ */
+#ifdef PNG_SETJMP_SUPPORTED
+/* This function returns the jmp_buf built in to *png_ptr.  It must be
+ * supplied with an appropriate 'longjmp' function to use on that jmp_buf
+ * unless the default error function is overridden in which case NULL is
+ * acceptable.  The size of the jmp_buf is checked against the actual size
+ * allocated by the library - the call will return NULL on a mismatch
+ * indicating an ABI mismatch.
+ */
+PNG_EXPORT(8, jmp_buf*, png_set_longjmp_fn, (png_structrp png_ptr,
+    png_longjmp_ptr longjmp_fn, size_t jmp_buf_size));
+#  define png_jmpbuf(png_ptr) \
+      (*png_set_longjmp_fn((png_ptr), longjmp, (sizeof (jmp_buf))))
+#else
+#  define png_jmpbuf(png_ptr) \
+      (LIBPNG_WAS_COMPILED_WITH__PNG_NO_SETJMP)
+#endif
+/* This function should be used by libpng applications in place of
+ * longjmp(png_ptr->jmpbuf, val).  If longjmp_fn() has been set, it
+ * will use it; otherwise it will call PNG_ABORT().  This function was
+ * added in libpng-1.5.0.
+ */
+PNG_EXPORTA(9, void, png_longjmp, (png_const_structrp png_ptr, int val),
+    PNG_NORETURN);
+
+#ifdef PNG_READ_SUPPORTED
+/* Reset the compression stream */
+PNG_EXPORTA(10, int, png_reset_zstream, (png_structrp png_ptr), PNG_DEPRECATED);
+#endif
+
+/* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */
+#ifdef PNG_USER_MEM_SUPPORTED
+PNG_EXPORTA(11, png_structp, png_create_read_struct_2,
+    (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn,
+    png_error_ptr warn_fn,
+    png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn),
+    PNG_ALLOCATED);
+PNG_EXPORTA(12, png_structp, png_create_write_struct_2,
+    (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn,
+    png_error_ptr warn_fn,
+    png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn),
+    PNG_ALLOCATED);
+#endif
+
+/* Write the PNG file signature. */
+PNG_EXPORT(13, void, png_write_sig, (png_structrp png_ptr));
+
+/* Write a PNG chunk - size, type, (optional) data, CRC. */
+PNG_EXPORT(14, void, png_write_chunk, (png_structrp png_ptr, png_const_bytep
+    chunk_name, png_const_bytep data, png_size_t length));
+
+/* Write the start of a PNG chunk - length and chunk name. */
+PNG_EXPORT(15, void, png_write_chunk_start, (png_structrp png_ptr,
+    png_const_bytep chunk_name, png_uint_32 length));
+
+/* Write the data of a PNG chunk started with png_write_chunk_start(). */
+PNG_EXPORT(16, void, png_write_chunk_data, (png_structrp png_ptr,
+    png_const_bytep data, png_size_t length));
+
+/* Finish a chunk started with png_write_chunk_start() (includes CRC). */
+PNG_EXPORT(17, void, png_write_chunk_end, (png_structrp png_ptr));
+
+/* Allocate and initialize the info structure */
+PNG_EXPORTA(18, png_infop, png_create_info_struct, (png_const_structrp png_ptr),
+    PNG_ALLOCATED);
+
+/* DEPRECATED: this function allowed init structures to be created using the
+ * default allocation method (typically malloc).  Use is deprecated in 1.6.0 and
+ * the API will be removed in the future.
+ */
+PNG_EXPORTA(19, void, png_info_init_3, (png_infopp info_ptr,
+    png_size_t png_info_struct_size), PNG_DEPRECATED);
+
+/* Writes all the PNG information before the image. */
+PNG_EXPORT(20, void, png_write_info_before_PLTE,
+    (png_structrp png_ptr, png_const_inforp info_ptr));
+PNG_EXPORT(21, void, png_write_info,
+    (png_structrp png_ptr, png_const_inforp info_ptr));
+
+#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+/* Read the information before the actual image data. */
+PNG_EXPORT(22, void, png_read_info,
+    (png_structrp png_ptr, png_inforp info_ptr));
+#endif
+
+#ifdef PNG_TIME_RFC1123_SUPPORTED
+   /* Convert to a US string format: there is no localization support in this
+    * routine.  The original implementation used a 29 character buffer in
+    * png_struct, this will be removed in future versions.
+    */
+#if PNG_LIBPNG_VER < 10700
+/* To do: remove this from libpng17 (and from libpng17/png.c and pngstruct.h) */
+PNG_EXPORTA(23, png_const_charp, png_convert_to_rfc1123, (png_structrp png_ptr,
+    png_const_timep ptime),PNG_DEPRECATED);
+#endif
+PNG_EXPORT(241, int, png_convert_to_rfc1123_buffer, (char out[29],
+    png_const_timep ptime));
+#endif
+
+#ifdef PNG_CONVERT_tIME_SUPPORTED
+/* Convert from a struct tm to png_time */
+PNG_EXPORT(24, void, png_convert_from_struct_tm, (png_timep ptime,
+    const struct tm * ttime));
+
+/* Convert from time_t to png_time.  Uses gmtime() */
+PNG_EXPORT(25, void, png_convert_from_time_t, (png_timep ptime, time_t ttime));
+#endif /* CONVERT_tIME */
+
+#ifdef PNG_READ_EXPAND_SUPPORTED
+/* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */
+PNG_EXPORT(26, void, png_set_expand, (png_structrp png_ptr));
+PNG_EXPORT(27, void, png_set_expand_gray_1_2_4_to_8, (png_structrp png_ptr));
+PNG_EXPORT(28, void, png_set_palette_to_rgb, (png_structrp png_ptr));
+PNG_EXPORT(29, void, png_set_tRNS_to_alpha, (png_structrp png_ptr));
+#endif
+
+#ifdef PNG_READ_EXPAND_16_SUPPORTED
+/* Expand to 16-bit channels, forces conversion of palette to RGB and expansion
+ * of a tRNS chunk if present.
+ */
+PNG_EXPORT(221, void, png_set_expand_16, (png_structrp png_ptr));
+#endif
+
+#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
+/* Use blue, green, red order for pixels. */
+PNG_EXPORT(30, void, png_set_bgr, (png_structrp png_ptr));
+#endif
+
+#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
+/* Expand the grayscale to 24-bit RGB if necessary. */
+PNG_EXPORT(31, void, png_set_gray_to_rgb, (png_structrp png_ptr));
+#endif
+
+#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
+/* Reduce RGB to grayscale. */
+#define PNG_ERROR_ACTION_NONE  1
+#define PNG_ERROR_ACTION_WARN  2
+#define PNG_ERROR_ACTION_ERROR 3
+#define PNG_RGB_TO_GRAY_DEFAULT (-1)/*for red/green coefficients*/
+
+PNG_FP_EXPORT(32, void, png_set_rgb_to_gray, (png_structrp png_ptr,
+    int error_action, double red, double green))
+PNG_FIXED_EXPORT(33, void, png_set_rgb_to_gray_fixed, (png_structrp png_ptr,
+    int error_action, png_fixed_point red, png_fixed_point green))
+
+PNG_EXPORT(34, png_byte, png_get_rgb_to_gray_status, (png_const_structrp
+    png_ptr));
+#endif
+
+#ifdef PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED
+PNG_EXPORT(35, void, png_build_grayscale_palette, (int bit_depth,
+    png_colorp palette));
+#endif
+
+#ifdef PNG_READ_ALPHA_MODE_SUPPORTED
+/* How the alpha channel is interpreted - this affects how the color channels
+ * of a PNG file are returned to the calling application when an alpha channel,
+ * or a tRNS chunk in a palette file, is present.
+ *
+ * This has no effect on the way pixels are written into a PNG output
+ * datastream. The color samples in a PNG datastream are never premultiplied
+ * with the alpha samples.
+ *
+ * The default is to return data according to the PNG specification: the alpha
+ * channel is a linear measure of the contribution of the pixel to the
+ * corresponding composited pixel, and the color channels are unassociated
+ * (not premultiplied).  The gamma encoded color channels must be scaled
+ * according to the contribution and to do this it is necessary to undo
+ * the encoding, scale the color values, perform the composition and reencode
+ * the values.  This is the 'PNG' mode.
+ *
+ * The alternative is to 'associate' the alpha with the color information by
+ * storing color channel values that have been scaled by the alpha.
+ * image.  These are the 'STANDARD', 'ASSOCIATED' or 'PREMULTIPLIED' modes
+ * (the latter being the two common names for associated alpha color channels).
+ *
+ * For the 'OPTIMIZED' mode, a pixel is treated as opaque only if the alpha
+ * value is equal to the maximum value.
+ *
+ * The final choice is to gamma encode the alpha channel as well.  This is
+ * broken because, in practice, no implementation that uses this choice
+ * correctly undoes the encoding before handling alpha composition.  Use this
+ * choice only if other serious errors in the software or hardware you use
+ * mandate it; the typical serious error is for dark halos to appear around
+ * opaque areas of the composited PNG image because of arithmetic overflow.
+ *
+ * The API function png_set_alpha_mode specifies which of these choices to use
+ * with an enumerated 'mode' value and the gamma of the required output:
+ */
+#define PNG_ALPHA_PNG           0 /* according to the PNG standard */
+#define PNG_ALPHA_STANDARD      1 /* according to Porter/Duff */
+#define PNG_ALPHA_ASSOCIATED    1 /* as above; this is the normal practice */
+#define PNG_ALPHA_PREMULTIPLIED 1 /* as above */
+#define PNG_ALPHA_OPTIMIZED     2 /* 'PNG' for opaque pixels, else 'STANDARD' */
+#define PNG_ALPHA_BROKEN        3 /* the alpha channel is gamma encoded */
+
+PNG_FP_EXPORT(227, void, png_set_alpha_mode, (png_structrp png_ptr, int mode,
+    double output_gamma))
+PNG_FIXED_EXPORT(228, void, png_set_alpha_mode_fixed, (png_structrp png_ptr,
+    int mode, png_fixed_point output_gamma))
+#endif
+
+#if defined(PNG_GAMMA_SUPPORTED) || defined(PNG_READ_ALPHA_MODE_SUPPORTED)
+/* The output_gamma value is a screen gamma in libpng terminology: it expresses
+ * how to decode the output values, not how they are encoded.
+ */
+#define PNG_DEFAULT_sRGB -1       /* sRGB gamma and color space */
+#define PNG_GAMMA_MAC_18 -2       /* Old Mac '1.8' gamma and color space */
+#define PNG_GAMMA_sRGB   220000   /* Television standards--matches sRGB gamma */
+#define PNG_GAMMA_LINEAR PNG_FP_1 /* Linear */
+#endif
+
+/* The following are examples of calls to png_set_alpha_mode to achieve the
+ * required overall gamma correction and, where necessary, alpha
+ * premultiplication.
+ *
+ * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB);
+ *    This is the default libpng handling of the alpha channel - it is not
+ *    pre-multiplied into the color components.  In addition the call states
+ *    that the output is for a sRGB system and causes all PNG files without gAMA
+ *    chunks to be assumed to be encoded using sRGB.
+ *
+ * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC);
+ *    In this case the output is assumed to be something like an sRGB conformant
+ *    display preceeded by a power-law lookup table of power 1.45.  This is how
+ *    early Mac systems behaved.
+ *
+ * png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_GAMMA_LINEAR);
+ *    This is the classic Jim Blinn approach and will work in academic
+ *    environments where everything is done by the book.  It has the shortcoming
+ *    of assuming that input PNG data with no gamma information is linear - this
+ *    is unlikely to be correct unless the PNG files where generated locally.
+ *    Most of the time the output precision will be so low as to show
+ *    significant banding in dark areas of the image.
+ *
+ * png_set_expand_16(pp);
+ * png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_DEFAULT_sRGB);
+ *    This is a somewhat more realistic Jim Blinn inspired approach.  PNG files
+ *    are assumed to have the sRGB encoding if not marked with a gamma value and
+ *    the output is always 16 bits per component.  This permits accurate scaling
+ *    and processing of the data.  If you know that your input PNG files were
+ *    generated locally you might need to replace PNG_DEFAULT_sRGB with the
+ *    correct value for your system.
+ *
+ * png_set_alpha_mode(pp, PNG_ALPHA_OPTIMIZED, PNG_DEFAULT_sRGB);
+ *    If you just need to composite the PNG image onto an existing background
+ *    and if you control the code that does this you can use the optimization
+ *    setting.  In this case you just copy completely opaque pixels to the
+ *    output.  For pixels that are not completely transparent (you just skip
+ *    those) you do the composition math using png_composite or png_composite_16
+ *    below then encode the resultant 8-bit or 16-bit values to match the output
+ *    encoding.
+ *
+ * Other cases
+ *    If neither the PNG nor the standard linear encoding work for you because
+ *    of the software or hardware you use then you have a big problem.  The PNG
+ *    case will probably result in halos around the image.  The linear encoding
+ *    will probably result in a washed out, too bright, image (it's actually too
+ *    contrasty.)  Try the ALPHA_OPTIMIZED mode above - this will probably
+ *    substantially reduce the halos.  Alternatively try:
+ *
+ * png_set_alpha_mode(pp, PNG_ALPHA_BROKEN, PNG_DEFAULT_sRGB);
+ *    This option will also reduce the halos, but there will be slight dark
+ *    halos round the opaque parts of the image where the background is light.
+ *    In the OPTIMIZED mode the halos will be light halos where the background
+ *    is dark.  Take your pick - the halos are unavoidable unless you can get
+ *    your hardware/software fixed!  (The OPTIMIZED approach is slightly
+ *    faster.)
+ *
+ * When the default gamma of PNG files doesn't match the output gamma.
+ *    If you have PNG files with no gamma information png_set_alpha_mode allows
+ *    you to provide a default gamma, but it also sets the ouput gamma to the
+ *    matching value.  If you know your PNG files have a gamma that doesn't
+ *    match the output you can take advantage of the fact that
+ *    png_set_alpha_mode always sets the output gamma but only sets the PNG
+ *    default if it is not already set:
+ *
+ * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB);
+ * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC);
+ *    The first call sets both the default and the output gamma values, the
+ *    second call overrides the output gamma without changing the default.  This
+ *    is easier than achieving the same effect with png_set_gamma.  You must use
+ *    PNG_ALPHA_PNG for the first call - internal checking in png_set_alpha will
+ *    fire if more than one call to png_set_alpha_mode and png_set_background is
+ *    made in the same read operation, however multiple calls with PNG_ALPHA_PNG
+ *    are ignored.
+ */
+
+#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
+PNG_EXPORT(36, void, png_set_strip_alpha, (png_structrp png_ptr));
+#endif
+
+#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \
+    defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
+PNG_EXPORT(37, void, png_set_swap_alpha, (png_structrp png_ptr));
+#endif
+
+#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \
+    defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
+PNG_EXPORT(38, void, png_set_invert_alpha, (png_structrp png_ptr));
+#endif
+
+#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
+/* Add a filler byte to 8-bit or 16-bit Gray or 24-bit or 48-bit RGB images. */
+PNG_EXPORT(39, void, png_set_filler, (png_structrp png_ptr, png_uint_32 filler,
+    int flags));
+/* The values of the PNG_FILLER_ defines should NOT be changed */
+#  define PNG_FILLER_BEFORE 0
+#  define PNG_FILLER_AFTER 1
+/* Add an alpha byte to 8-bit or 16-bit Gray or 24-bit or 48-bit RGB images. */
+PNG_EXPORT(40, void, png_set_add_alpha, (png_structrp png_ptr,
+    png_uint_32 filler, int flags));
+#endif /* READ_FILLER || WRITE_FILLER */
+
+#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
+/* Swap bytes in 16-bit depth files. */
+PNG_EXPORT(41, void, png_set_swap, (png_structrp png_ptr));
+#endif
+
+#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
+/* Use 1 byte per pixel in 1, 2, or 4-bit depth files. */
+PNG_EXPORT(42, void, png_set_packing, (png_structrp png_ptr));
+#endif
+
+#if defined(PNG_READ_PACKSWAP_SUPPORTED) || \
+    defined(PNG_WRITE_PACKSWAP_SUPPORTED)
+/* Swap packing order of pixels in bytes. */
+PNG_EXPORT(43, void, png_set_packswap, (png_structrp png_ptr));
+#endif
+
+#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
+/* Converts files to legal bit depths. */
+PNG_EXPORT(44, void, png_set_shift, (png_structrp png_ptr, png_const_color_8p
+    true_bits));
+#endif
+
+#if defined(PNG_READ_INTERLACING_SUPPORTED) || \
+    defined(PNG_WRITE_INTERLACING_SUPPORTED)
+/* Have the code handle the interlacing.  Returns the number of passes.
+ * MUST be called before png_read_update_info or png_start_read_image,
+ * otherwise it will not have the desired effect.  Note that it is still
+ * necessary to call png_read_row or png_read_rows png_get_image_height
+ * times for each pass.
+*/
+PNG_EXPORT(45, int, png_set_interlace_handling, (png_structrp png_ptr));
+#endif
+
+#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
+/* Invert monochrome files */
+PNG_EXPORT(46, void, png_set_invert_mono, (png_structrp png_ptr));
+#endif
+
+#ifdef PNG_READ_BACKGROUND_SUPPORTED
+/* Handle alpha and tRNS by replacing with a background color.  Prior to
+ * libpng-1.5.4 this API must not be called before the PNG file header has been
+ * read.  Doing so will result in unexpected behavior and possible warnings or
+ * errors if the PNG file contains a bKGD chunk.
+ */
+PNG_FP_EXPORT(47, void, png_set_background, (png_structrp png_ptr,
+    png_const_color_16p background_color, int background_gamma_code,
+    int need_expand, double background_gamma))
+PNG_FIXED_EXPORT(215, void, png_set_background_fixed, (png_structrp png_ptr,
+    png_const_color_16p background_color, int background_gamma_code,
+    int need_expand, png_fixed_point background_gamma))
+#endif
+#ifdef PNG_READ_BACKGROUND_SUPPORTED
+#  define PNG_BACKGROUND_GAMMA_UNKNOWN 0
+#  define PNG_BACKGROUND_GAMMA_SCREEN  1
+#  define PNG_BACKGROUND_GAMMA_FILE    2
+#  define PNG_BACKGROUND_GAMMA_UNIQUE  3
+#endif
+
+#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
+/* Scale a 16-bit depth file down to 8-bit, accurately. */
+PNG_EXPORT(229, void, png_set_scale_16, (png_structrp png_ptr));
+#endif
+
+#ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED
+#define PNG_READ_16_TO_8_SUPPORTED /* Name prior to 1.5.4 */
+/* Strip the second byte of information from a 16-bit depth file. */
+PNG_EXPORT(48, void, png_set_strip_16, (png_structrp png_ptr));
+#endif
+
+#ifdef PNG_READ_QUANTIZE_SUPPORTED
+/* Turn on quantizing, and reduce the palette to the number of colors
+ * available.
+ */
+PNG_EXPORT(49, void, png_set_quantize, (png_structrp png_ptr,
+    png_colorp palette, int num_palette, int maximum_colors,
+    png_const_uint_16p histogram, int full_quantize));
+#endif
+
+#ifdef PNG_READ_GAMMA_SUPPORTED
+/* The threshold on gamma processing is configurable but hard-wired into the
+ * library.  The following is the floating point variant.
+ */
+#define PNG_GAMMA_THRESHOLD (PNG_GAMMA_THRESHOLD_FIXED*.00001)
+
+/* Handle gamma correction. Screen_gamma=(display_exponent).
+ * NOTE: this API simply sets the screen and file gamma values. It will
+ * therefore override the value for gamma in a PNG file if it is called after
+ * the file header has been read - use with care  - call before reading the PNG
+ * file for best results!
+ *
+ * These routines accept the same gamma values as png_set_alpha_mode (described
+ * above).  The PNG_GAMMA_ defines and PNG_DEFAULT_sRGB can be passed to either
+ * API (floating point or fixed.)  Notice, however, that the 'file_gamma' value
+ * is the inverse of a 'screen gamma' value.
+ */
+PNG_FP_EXPORT(50, void, png_set_gamma, (png_structrp png_ptr,
+    double screen_gamma, double override_file_gamma))
+PNG_FIXED_EXPORT(208, void, png_set_gamma_fixed, (png_structrp png_ptr,
+    png_fixed_point screen_gamma, png_fixed_point override_file_gamma))
+#endif
+
+#ifdef PNG_WRITE_FLUSH_SUPPORTED
+/* Set how many lines between output flushes - 0 for no flushing */
+PNG_EXPORT(51, void, png_set_flush, (png_structrp png_ptr, int nrows));
+/* Flush the current PNG output buffer */
+PNG_EXPORT(52, void, png_write_flush, (png_structrp png_ptr));
+#endif
+
+/* Optional update palette with requested transformations */
+PNG_EXPORT(53, void, png_start_read_image, (png_structrp png_ptr));
+
+/* Optional call to update the users info structure */
+PNG_EXPORT(54, void, png_read_update_info, (png_structrp png_ptr,
+    png_inforp info_ptr));
+
+#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+/* Read one or more rows of image data. */
+PNG_EXPORT(55, void, png_read_rows, (png_structrp png_ptr, png_bytepp row,
+    png_bytepp display_row, png_uint_32 num_rows));
+#endif
+
+#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+/* Read a row of data. */
+PNG_EXPORT(56, void, png_read_row, (png_structrp png_ptr, png_bytep row,
+    png_bytep display_row));
+#endif
+
+#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+/* Read the whole image into memory at once. */
+PNG_EXPORT(57, void, png_read_image, (png_structrp png_ptr, png_bytepp image));
+#endif
+
+/* Write a row of image data */
+PNG_EXPORT(58, void, png_write_row, (png_structrp png_ptr,
+    png_const_bytep row));
+
+/* Write a few rows of image data: (*row) is not written; however, the type
+ * is declared as writeable to maintain compatibility with previous versions
+ * of libpng and to allow the 'display_row' array from read_rows to be passed
+ * unchanged to write_rows.
+ */
+PNG_EXPORT(59, void, png_write_rows, (png_structrp png_ptr, png_bytepp row,
+    png_uint_32 num_rows));
+
+/* Write the image data */
+PNG_EXPORT(60, void, png_write_image, (png_structrp png_ptr, png_bytepp image));
+
+/* Write the end of the PNG file. */
+PNG_EXPORT(61, void, png_write_end, (png_structrp png_ptr,
+    png_inforp info_ptr));
+
+#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+/* Read the end of the PNG file. */
+PNG_EXPORT(62, void, png_read_end, (png_structrp png_ptr, png_inforp info_ptr));
+#endif
+
+/* Free any memory associated with the png_info_struct */
+PNG_EXPORT(63, void, png_destroy_info_struct, (png_const_structrp png_ptr,
+    png_infopp info_ptr_ptr));
+
+/* Free any memory associated with the png_struct and the png_info_structs */
+PNG_EXPORT(64, void, png_destroy_read_struct, (png_structpp png_ptr_ptr,
+    png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr));
+
+/* Free any memory associated with the png_struct and the png_info_structs */
+PNG_EXPORT(65, void, png_destroy_write_struct, (png_structpp png_ptr_ptr,
+    png_infopp info_ptr_ptr));
+
+/* Set the libpng method of handling chunk CRC errors */
+PNG_EXPORT(66, void, png_set_crc_action, (png_structrp png_ptr, int crit_action,
+    int ancil_action));
+
+/* Values for png_set_crc_action() say how to handle CRC errors in
+ * ancillary and critical chunks, and whether to use the data contained
+ * therein.  Note that it is impossible to "discard" data in a critical
+ * chunk.  For versions prior to 0.90, the action was always error/quit,
+ * whereas in version 0.90 and later, the action for CRC errors in ancillary
+ * chunks is warn/discard.  These values should NOT be changed.
+ *
+ *      value                       action:critical     action:ancillary
+ */
+#define PNG_CRC_DEFAULT       0  /* error/quit          warn/discard data */
+#define PNG_CRC_ERROR_QUIT    1  /* error/quit          error/quit        */
+#define PNG_CRC_WARN_DISCARD  2  /* (INVALID)           warn/discard data */
+#define PNG_CRC_WARN_USE      3  /* warn/use data       warn/use data     */
+#define PNG_CRC_QUIET_USE     4  /* quiet/use data      quiet/use data    */
+#define PNG_CRC_NO_CHANGE     5  /* use current value   use current value */
+
+#ifdef PNG_WRITE_SUPPORTED
+/* These functions give the user control over the scan-line filtering in
+ * libpng and the compression methods used by zlib.  These functions are
+ * mainly useful for testing, as the defaults should work with most users.
+ * Those users who are tight on memory or want faster performance at the
+ * expense of compression can modify them.  See the compression library
+ * header file (zlib.h) for an explination of the compression functions.
+ */
+
+/* Set the filtering method(s) used by libpng.  Currently, the only valid
+ * value for "method" is 0.
+ */
+PNG_EXPORT(67, void, png_set_filter, (png_structrp png_ptr, int method,
+    int filters));
+#endif /* WRITE */
+
+/* Flags for png_set_filter() to say which filters to use.  The flags
+ * are chosen so that they don't conflict with real filter types
+ * below, in case they are supplied instead of the #defined constants.
+ * These values should NOT be changed.
+ */
+#define PNG_NO_FILTERS     0x00
+#define PNG_FILTER_NONE    0x08
+#define PNG_FILTER_SUB     0x10
+#define PNG_FILTER_UP      0x20
+#define PNG_FILTER_AVG     0x40
+#define PNG_FILTER_PAETH   0x80
+#define PNG_FAST_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP)
+#define PNG_ALL_FILTERS (PNG_FAST_FILTERS | PNG_FILTER_AVG | PNG_FILTER_PAETH)
+
+/* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now.
+ * These defines should NOT be changed.
+ */
+#define PNG_FILTER_VALUE_NONE  0
+#define PNG_FILTER_VALUE_SUB   1
+#define PNG_FILTER_VALUE_UP    2
+#define PNG_FILTER_VALUE_AVG   3
+#define PNG_FILTER_VALUE_PAETH 4
+#define PNG_FILTER_VALUE_LAST  5
+
+#ifdef PNG_WRITE_SUPPORTED
+#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED /* DEPRECATED */
+PNG_FP_EXPORT(68, void, png_set_filter_heuristics, (png_structrp png_ptr,
+    int heuristic_method, int num_weights, png_const_doublep filter_weights,
+    png_const_doublep filter_costs))
+PNG_FIXED_EXPORT(209, void, png_set_filter_heuristics_fixed,
+    (png_structrp png_ptr, int heuristic_method, int num_weights,
+    png_const_fixed_point_p filter_weights,
+    png_const_fixed_point_p filter_costs))
+#endif /* WRITE_WEIGHTED_FILTER */
+
+/* The following are no longer used and will be removed from libpng-1.7: */
+#define PNG_FILTER_HEURISTIC_DEFAULT    0  /* Currently "UNWEIGHTED" */
+#define PNG_FILTER_HEURISTIC_UNWEIGHTED 1  /* Used by libpng < 0.95 */
+#define PNG_FILTER_HEURISTIC_WEIGHTED   2  /* Experimental feature */
+#define PNG_FILTER_HEURISTIC_LAST       3  /* Not a valid value */
+
+/* Set the library compression level.  Currently, valid values range from
+ * 0 - 9, corresponding directly to the zlib compression levels 0 - 9
+ * (0 - no compression, 9 - "maximal" compression).  Note that tests have
+ * shown that zlib compression levels 3-6 usually perform as well as level 9
+ * for PNG images, and do considerably fewer caclulations.  In the future,
+ * these values may not correspond directly to the zlib compression levels.
+ */
+#ifdef PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED
+PNG_EXPORT(69, void, png_set_compression_level, (png_structrp png_ptr,
+    int level));
+
+PNG_EXPORT(70, void, png_set_compression_mem_level, (png_structrp png_ptr,
+    int mem_level));
+
+PNG_EXPORT(71, void, png_set_compression_strategy, (png_structrp png_ptr,
+    int strategy));
+
+/* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a
+ * smaller value of window_bits if it can do so safely.
+ */
+PNG_EXPORT(72, void, png_set_compression_window_bits, (png_structrp png_ptr,
+    int window_bits));
+
+PNG_EXPORT(73, void, png_set_compression_method, (png_structrp png_ptr,
+    int method));
+#endif /* WRITE_CUSTOMIZE_COMPRESSION */
+
+#ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
+/* Also set zlib parameters for compressing non-IDAT chunks */
+PNG_EXPORT(222, void, png_set_text_compression_level, (png_structrp png_ptr,
+    int level));
+
+PNG_EXPORT(223, void, png_set_text_compression_mem_level, (png_structrp png_ptr,
+    int mem_level));
+
+PNG_EXPORT(224, void, png_set_text_compression_strategy, (png_structrp png_ptr,
+    int strategy));
+
+/* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a
+ * smaller value of window_bits if it can do so safely.
+ */
+PNG_EXPORT(225, void, png_set_text_compression_window_bits,
+    (png_structrp png_ptr, int window_bits));
+
+PNG_EXPORT(226, void, png_set_text_compression_method, (png_structrp png_ptr,
+    int method));
+#endif /* WRITE_CUSTOMIZE_ZTXT_COMPRESSION */
+#endif /* WRITE */
+
+/* These next functions are called for input/output, memory, and error
+ * handling.  They are in the file pngrio.c, pngwio.c, and pngerror.c,
+ * and call standard C I/O routines such as fread(), fwrite(), and
+ * fprintf().  These functions can be made to use other I/O routines
+ * at run time for those applications that need to handle I/O in a
+ * different manner by calling png_set_???_fn().  See libpng-manual.txt for
+ * more information.
+ */
+
+#ifdef PNG_STDIO_SUPPORTED
+/* Initialize the input/output for the PNG file to the default functions. */
+PNG_EXPORT(74, void, png_init_io, (png_structrp png_ptr, png_FILE_p fp));
+#endif
+
+/* Replace the (error and abort), and warning functions with user
+ * supplied functions.  If no messages are to be printed you must still
+ * write and use replacement functions. The replacement error_fn should
+ * still do a longjmp to the last setjmp location if you are using this
+ * method of error handling.  If error_fn or warning_fn is NULL, the
+ * default function will be used.
+ */
+
+PNG_EXPORT(75, void, png_set_error_fn, (png_structrp png_ptr,
+    png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn));
+
+/* Return the user pointer associated with the error functions */
+PNG_EXPORT(76, png_voidp, png_get_error_ptr, (png_const_structrp png_ptr));
+
+/* Replace the default data output functions with a user supplied one(s).
+ * If buffered output is not used, then output_flush_fn can be set to NULL.
+ * If PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile time
+ * output_flush_fn will be ignored (and thus can be NULL).
+ * It is probably a mistake to use NULL for output_flush_fn if
+ * write_data_fn is not also NULL unless you have built libpng with
+ * PNG_WRITE_FLUSH_SUPPORTED undefined, because in this case libpng's
+ * default flush function, which uses the standard *FILE structure, will
+ * be used.
+ */
+PNG_EXPORT(77, void, png_set_write_fn, (png_structrp png_ptr, png_voidp io_ptr,
+    png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn));
+
+/* Replace the default data input function with a user supplied one. */
+PNG_EXPORT(78, void, png_set_read_fn, (png_structrp png_ptr, png_voidp io_ptr,
+    png_rw_ptr read_data_fn));
+
+/* Return the user pointer associated with the I/O functions */
+PNG_EXPORT(79, png_voidp, png_get_io_ptr, (png_const_structrp png_ptr));
+
+PNG_EXPORT(80, void, png_set_read_status_fn, (png_structrp png_ptr,
+    png_read_status_ptr read_row_fn));
+
+PNG_EXPORT(81, void, png_set_write_status_fn, (png_structrp png_ptr,
+    png_write_status_ptr write_row_fn));
+
+#ifdef PNG_USER_MEM_SUPPORTED
+/* Replace the default memory allocation functions with user supplied one(s). */
+PNG_EXPORT(82, void, png_set_mem_fn, (png_structrp png_ptr, png_voidp mem_ptr,
+    png_malloc_ptr malloc_fn, png_free_ptr free_fn));
+/* Return the user pointer associated with the memory functions */
+PNG_EXPORT(83, png_voidp, png_get_mem_ptr, (png_const_structrp png_ptr));
+#endif
+
+#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
+PNG_EXPORT(84, void, png_set_read_user_transform_fn, (png_structrp png_ptr,
+    png_user_transform_ptr read_user_transform_fn));
+#endif
+
+#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
+PNG_EXPORT(85, void, png_set_write_user_transform_fn, (png_structrp png_ptr,
+    png_user_transform_ptr write_user_transform_fn));
+#endif
+
+#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
+PNG_EXPORT(86, void, png_set_user_transform_info, (png_structrp png_ptr,
+    png_voidp user_transform_ptr, int user_transform_depth,
+    int user_transform_channels));
+/* Return the user pointer associated with the user transform functions */
+PNG_EXPORT(87, png_voidp, png_get_user_transform_ptr,
+    (png_const_structrp png_ptr));
+#endif
+
+#ifdef PNG_USER_TRANSFORM_INFO_SUPPORTED
+/* Return information about the row currently being processed.  Note that these
+ * APIs do not fail but will return unexpected results if called outside a user
+ * transform callback.  Also note that when transforming an interlaced image the
+ * row number is the row number within the sub-image of the interlace pass, so
+ * the value will increase to the height of the sub-image (not the full image)
+ * then reset to 0 for the next pass.
+ *
+ * Use PNG_ROW_FROM_PASS_ROW(row, pass) and PNG_COL_FROM_PASS_COL(col, pass) to
+ * find the output pixel (x,y) given an interlaced sub-image pixel
+ * (row,col,pass).  (See below for these macros.)
+ */
+PNG_EXPORT(217, png_uint_32, png_get_current_row_number, (png_const_structrp));
+PNG_EXPORT(218, png_byte, png_get_current_pass_number, (png_const_structrp));
+#endif
+
+#ifdef PNG_READ_USER_CHUNKS_SUPPORTED
+/* This callback is called only for *unknown* chunks.  If
+ * PNG_HANDLE_AS_UNKNOWN_SUPPORTED is set then it is possible to set known
+ * chunks to be treated as unknown, however in this case the callback must do
+ * any processing required by the chunk (e.g. by calling the appropriate
+ * png_set_ APIs.)
+ *
+ * There is no write support - on write, by default, all the chunks in the
+ * 'unknown' list are written in the specified position.
+ *
+ * The integer return from the callback function is interpreted thus:
+ *
+ * negative: An error occurred; png_chunk_error will be called.
+ *     zero: The chunk was not handled, the chunk will be saved. A critical
+ *           chunk will cause an error at this point unless it is to be saved.
+ * positive: The chunk was handled, libpng will ignore/discard it.
+ *
+ * See "INTERACTION WTIH USER CHUNK CALLBACKS" below for important notes about
+ * how this behavior will change in libpng 1.7
+ */
+PNG_EXPORT(88, void, png_set_read_user_chunk_fn, (png_structrp png_ptr,
+    png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn));
+#endif
+
+#ifdef PNG_USER_CHUNKS_SUPPORTED
+PNG_EXPORT(89, png_voidp, png_get_user_chunk_ptr, (png_const_structrp png_ptr));
+#endif
+
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
+/* Sets the function callbacks for the push reader, and a pointer to a
+ * user-defined structure available to the callback functions.
+ */
+PNG_EXPORT(90, void, png_set_progressive_read_fn, (png_structrp png_ptr,
+    png_voidp progressive_ptr, png_progressive_info_ptr info_fn,
+    png_progressive_row_ptr row_fn, png_progressive_end_ptr end_fn));
+
+/* Returns the user pointer associated with the push read functions */
+PNG_EXPORT(91, png_voidp, png_get_progressive_ptr,
+    (png_const_structrp png_ptr));
+
+/* Function to be called when data becomes available */
+PNG_EXPORT(92, void, png_process_data, (png_structrp png_ptr,
+    png_inforp info_ptr, png_bytep buffer, png_size_t buffer_size));
+
+/* A function which may be called *only* within png_process_data to stop the
+ * processing of any more data.  The function returns the number of bytes
+ * remaining, excluding any that libpng has cached internally.  A subsequent
+ * call to png_process_data must supply these bytes again.  If the argument
+ * 'save' is set to true the routine will first save all the pending data and
+ * will always return 0.
+ */
+PNG_EXPORT(219, png_size_t, png_process_data_pause, (png_structrp, int save));
+
+/* A function which may be called *only* outside (after) a call to
+ * png_process_data.  It returns the number of bytes of data to skip in the
+ * input.  Normally it will return 0, but if it returns a non-zero value the
+ * application must skip than number of bytes of input data and pass the
+ * following data to the next call to png_process_data.
+ */
+PNG_EXPORT(220, png_uint_32, png_process_data_skip, (png_structrp));
+
+/* Function that combines rows.  'new_row' is a flag that should come from
+ * the callback and be non-NULL if anything needs to be done; the library
+ * stores its own version of the new data internally and ignores the passed
+ * in value.
+ */
+PNG_EXPORT(93, void, png_progressive_combine_row, (png_const_structrp png_ptr,
+    png_bytep old_row, png_const_bytep new_row));
+#endif /* PROGRESSIVE_READ */
+
+PNG_EXPORTA(94, png_voidp, png_malloc, (png_const_structrp png_ptr,
+    png_alloc_size_t size), PNG_ALLOCATED);
+/* Added at libpng version 1.4.0 */
+PNG_EXPORTA(95, png_voidp, png_calloc, (png_const_structrp png_ptr,
+    png_alloc_size_t size), PNG_ALLOCATED);
+
+/* Added at libpng version 1.2.4 */
+PNG_EXPORTA(96, png_voidp, png_malloc_warn, (png_const_structrp png_ptr,
+    png_alloc_size_t size), PNG_ALLOCATED);
+
+/* Frees a pointer allocated by png_malloc() */
+PNG_EXPORT(97, void, png_free, (png_const_structrp png_ptr, png_voidp ptr));
+
+/* Free data that was allocated internally */
+PNG_EXPORT(98, void, png_free_data, (png_const_structrp png_ptr,
+    png_inforp info_ptr, png_uint_32 free_me, int num));
+
+/* Reassign responsibility for freeing existing data, whether allocated
+ * by libpng or by the application; this works on the png_info structure passed
+ * in, it does not change the state for other png_info structures.
+ *
+ * It is unlikely that this function works correctly as of 1.6.0 and using it
+ * may result either in memory leaks or double free of allocated data.
+ */
+PNG_EXPORT(99, void, png_data_freer, (png_const_structrp png_ptr,
+    png_inforp info_ptr, int freer, png_uint_32 mask));
+
+/* Assignments for png_data_freer */
+#define PNG_DESTROY_WILL_FREE_DATA 1
+#define PNG_SET_WILL_FREE_DATA 1
+#define PNG_USER_WILL_FREE_DATA 2
+/* Flags for png_ptr->free_me and info_ptr->free_me */
+#define PNG_FREE_HIST 0x0008U
+#define PNG_FREE_ICCP 0x0010U
+#define PNG_FREE_SPLT 0x0020U
+#define PNG_FREE_ROWS 0x0040U
+#define PNG_FREE_PCAL 0x0080U
+#define PNG_FREE_SCAL 0x0100U
+#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
+#  define PNG_FREE_UNKN 0x0200U
+#endif
+/*      PNG_FREE_LIST 0x0400U   removed in 1.6.0 because it is ignored */
+#define PNG_FREE_PLTE 0x1000U
+#define PNG_FREE_TRNS 0x2000U
+#define PNG_FREE_TEXT 0x4000U
+#define PNG_FREE_EXIF 0x8000U /* Added at libpng-1.6.31 */
+#define PNG_FREE_ALL  0xffffU
+#define PNG_FREE_MUL  0x4220U /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */
+
+#ifdef PNG_USER_MEM_SUPPORTED
+PNG_EXPORTA(100, png_voidp, png_malloc_default, (png_const_structrp png_ptr,
+    png_alloc_size_t size), PNG_ALLOCATED PNG_DEPRECATED);
+PNG_EXPORTA(101, void, png_free_default, (png_const_structrp png_ptr,
+    png_voidp ptr), PNG_DEPRECATED);
+#endif
+
+#ifdef PNG_ERROR_TEXT_SUPPORTED
+/* Fatal error in PNG image of libpng - can't continue */
+PNG_EXPORTA(102, void, png_error, (png_const_structrp png_ptr,
+    png_const_charp error_message), PNG_NORETURN);
+
+/* The same, but the chunk name is prepended to the error string. */
+PNG_EXPORTA(103, void, png_chunk_error, (png_const_structrp png_ptr,
+    png_const_charp error_message), PNG_NORETURN);
+
+#else
+/* Fatal error in PNG image of libpng - can't continue */
+PNG_EXPORTA(104, void, png_err, (png_const_structrp png_ptr), PNG_NORETURN);
+#  define png_error(s1,s2) png_err(s1)
+#  define png_chunk_error(s1,s2) png_err(s1)
+#endif
+
+#ifdef PNG_WARNINGS_SUPPORTED
+/* Non-fatal error in libpng.  Can continue, but may have a problem. */
+PNG_EXPORT(105, void, png_warning, (png_const_structrp png_ptr,
+    png_const_charp warning_message));
+
+/* Non-fatal error in libpng, chunk name is prepended to message. */
+PNG_EXPORT(106, void, png_chunk_warning, (png_const_structrp png_ptr,
+    png_const_charp warning_message));
+#else
+#  define png_warning(s1,s2) ((void)(s1))
+#  define png_chunk_warning(s1,s2) ((void)(s1))
+#endif
+
+#ifdef PNG_BENIGN_ERRORS_SUPPORTED
+/* Benign error in libpng.  Can continue, but may have a problem.
+ * User can choose whether to handle as a fatal error or as a warning. */
+PNG_EXPORT(107, void, png_benign_error, (png_const_structrp png_ptr,
+    png_const_charp warning_message));
+
+#ifdef PNG_READ_SUPPORTED
+/* Same, chunk name is prepended to message (only during read) */
+PNG_EXPORT(108, void, png_chunk_benign_error, (png_const_structrp png_ptr,
+    png_const_charp warning_message));
+#endif
+
+PNG_EXPORT(109, void, png_set_benign_errors,
+    (png_structrp png_ptr, int allowed));
+#else
+#  ifdef PNG_ALLOW_BENIGN_ERRORS
+#    define png_benign_error png_warning
+#    define png_chunk_benign_error png_chunk_warning
+#  else
+#    define png_benign_error png_error
+#    define png_chunk_benign_error png_chunk_error
+#  endif
+#endif
+
+/* The png_set_<chunk> functions are for storing values in the png_info_struct.
+ * Similarly, the png_get_<chunk> calls are used to read values from the
+ * png_info_struct, either storing the parameters in the passed variables, or
+ * setting pointers into the png_info_struct where the data is stored.  The
+ * png_get_<chunk> functions return a non-zero value if the data was available
+ * in info_ptr, or return zero and do not change any of the parameters if the
+ * data was not available.
+ *
+ * These functions should be used instead of directly accessing png_info
+ * to avoid problems with future changes in the size and internal layout of
+ * png_info_struct.
+ */
+/* Returns "flag" if chunk data is valid in info_ptr. */
+PNG_EXPORT(110, png_uint_32, png_get_valid, (png_const_structrp png_ptr,
+    png_const_inforp info_ptr, png_uint_32 flag));
+
+/* Returns number of bytes needed to hold a transformed row. */
+PNG_EXPORT(111, png_size_t, png_get_rowbytes, (png_const_structrp png_ptr,
+    png_const_inforp info_ptr));
+
+#ifdef PNG_INFO_IMAGE_SUPPORTED
+/* Returns row_pointers, which is an array of pointers to scanlines that was
+ * returned from png_read_png().
+ */
+PNG_EXPORT(112, png_bytepp, png_get_rows, (png_const_structrp png_ptr,
+    png_const_inforp info_ptr));
+
+/* Set row_pointers, which is an array of pointers to scanlines for use
+ * by png_write_png().
+ */
+PNG_EXPORT(113, void, png_set_rows, (png_const_structrp png_ptr,
+    png_inforp info_ptr, png_bytepp row_pointers));
+#endif
+
+/* Returns number of color channels in image. */
+PNG_EXPORT(114, png_byte, png_get_channels, (png_const_structrp png_ptr,
+    png_const_inforp info_ptr));
+
+#ifdef PNG_EASY_ACCESS_SUPPORTED
+/* Returns image width in pixels. */
+PNG_EXPORT(115, png_uint_32, png_get_image_width, (png_const_structrp png_ptr,
+    png_const_inforp info_ptr));
+
+/* Returns image height in pixels. */
+PNG_EXPORT(116, png_uint_32, png_get_image_height, (png_const_structrp png_ptr,
+    png_const_inforp info_ptr));
+
+/* Returns image bit_depth. */
+PNG_EXPORT(117, png_byte, png_get_bit_depth, (png_const_structrp png_ptr,
+    png_const_inforp info_ptr));
+
+/* Returns image color_type. */
+PNG_EXPORT(118, png_byte, png_get_color_type, (png_const_structrp png_ptr,
+    png_const_inforp info_ptr));
+
+/* Returns image filter_type. */
+PNG_EXPORT(119, png_byte, png_get_filter_type, (png_const_structrp png_ptr,
+    png_const_inforp info_ptr));
+
+/* Returns image interlace_type. */
+PNG_EXPORT(120, png_byte, png_get_interlace_type, (png_const_structrp png_ptr,
+    png_const_inforp info_ptr));
+
+/* Returns image compression_type. */
+PNG_EXPORT(121, png_byte, png_get_compression_type, (png_const_structrp png_ptr,
+    png_const_inforp info_ptr));
+
+/* Returns image resolution in pixels per meter, from pHYs chunk data. */
+PNG_EXPORT(122, png_uint_32, png_get_pixels_per_meter,
+    (png_const_structrp png_ptr, png_const_inforp info_ptr));
+PNG_EXPORT(123, png_uint_32, png_get_x_pixels_per_meter,
+    (png_const_structrp png_ptr, png_const_inforp info_ptr));
+PNG_EXPORT(124, png_uint_32, png_get_y_pixels_per_meter,
+    (png_const_structrp png_ptr, png_const_inforp info_ptr));
+
+/* Returns pixel aspect ratio, computed from pHYs chunk data.  */
+PNG_FP_EXPORT(125, float, png_get_pixel_aspect_ratio,
+    (png_const_structrp png_ptr, png_const_inforp info_ptr))
+PNG_FIXED_EXPORT(210, png_fixed_point, png_get_pixel_aspect_ratio_fixed,
+    (png_const_structrp png_ptr, png_const_inforp info_ptr))
+
+/* Returns image x, y offset in pixels or microns, from oFFs chunk data. */
+PNG_EXPORT(126, png_int_32, png_get_x_offset_pixels,
+    (png_const_structrp png_ptr, png_const_inforp info_ptr));
+PNG_EXPORT(127, png_int_32, png_get_y_offset_pixels,
+    (png_const_structrp png_ptr, png_const_inforp info_ptr));
+PNG_EXPORT(128, png_int_32, png_get_x_offset_microns,
+    (png_const_structrp png_ptr, png_const_inforp info_ptr));
+PNG_EXPORT(129, png_int_32, png_get_y_offset_microns,
+    (png_const_structrp png_ptr, png_const_inforp info_ptr));
+
+#endif /* EASY_ACCESS */
+
+#ifdef PNG_READ_SUPPORTED
+/* Returns pointer to signature string read from PNG header */
+PNG_EXPORT(130, png_const_bytep, png_get_signature, (png_const_structrp png_ptr,
+    png_const_inforp info_ptr));
+#endif
+
+#ifdef PNG_bKGD_SUPPORTED
+PNG_EXPORT(131, png_uint_32, png_get_bKGD, (png_const_structrp png_ptr,
+    png_inforp info_ptr, png_color_16p *background));
+#endif
+
+#ifdef PNG_bKGD_SUPPORTED
+PNG_EXPORT(132, void, png_set_bKGD, (png_const_structrp png_ptr,
+    png_inforp info_ptr, png_const_color_16p background));
+#endif
+
+#ifdef PNG_cHRM_SUPPORTED
+PNG_FP_EXPORT(133, png_uint_32, png_get_cHRM, (png_const_structrp png_ptr,
+    png_const_inforp info_ptr, double *white_x, double *white_y, double *red_x,
+    double *red_y, double *green_x, double *green_y, double *blue_x,
+    double *blue_y))
+PNG_FP_EXPORT(230, png_uint_32, png_get_cHRM_XYZ, (png_const_structrp png_ptr,
+    png_const_inforp info_ptr, double *red_X, double *red_Y, double *red_Z,
+    double *green_X, double *green_Y, double *green_Z, double *blue_X,
+    double *blue_Y, double *blue_Z))
+PNG_FIXED_EXPORT(134, png_uint_32, png_get_cHRM_fixed,
+    (png_const_structrp png_ptr, png_const_inforp info_ptr,
+    png_fixed_point *int_white_x, png_fixed_point *int_white_y,
+    png_fixed_point *int_red_x, png_fixed_point *int_red_y,
+    png_fixed_point *int_green_x, png_fixed_point *int_green_y,
+    png_fixed_point *int_blue_x, png_fixed_point *int_blue_y))
+PNG_FIXED_EXPORT(231, png_uint_32, png_get_cHRM_XYZ_fixed,
+    (png_const_structrp png_ptr, png_const_inforp info_ptr,
+    png_fixed_point *int_red_X, png_fixed_point *int_red_Y,
+    png_fixed_point *int_red_Z, png_fixed_point *int_green_X,
+    png_fixed_point *int_green_Y, png_fixed_point *int_green_Z,
+    png_fixed_point *int_blue_X, png_fixed_point *int_blue_Y,
+    png_fixed_point *int_blue_Z))
+#endif
+
+#ifdef PNG_cHRM_SUPPORTED
+PNG_FP_EXPORT(135, void, png_set_cHRM, (png_const_structrp png_ptr,
+    png_inforp info_ptr,
+    double white_x, double white_y, double red_x, double red_y, double green_x,
+    double green_y, double blue_x, double blue_y))
+PNG_FP_EXPORT(232, void, png_set_cHRM_XYZ, (png_const_structrp png_ptr,
+    png_inforp info_ptr, double red_X, double red_Y, double red_Z,
+    double green_X, double green_Y, double green_Z, double blue_X,
+    double blue_Y, double blue_Z))
+PNG_FIXED_EXPORT(136, void, png_set_cHRM_fixed, (png_const_structrp png_ptr,
+    png_inforp info_ptr, png_fixed_point int_white_x,
+    png_fixed_point int_white_y, png_fixed_point int_red_x,
+    png_fixed_point int_red_y, png_fixed_point int_green_x,
+    png_fixed_point int_green_y, png_fixed_point int_blue_x,
+    png_fixed_point int_blue_y))
+PNG_FIXED_EXPORT(233, void, png_set_cHRM_XYZ_fixed, (png_const_structrp png_ptr,
+    png_inforp info_ptr, png_fixed_point int_red_X, png_fixed_point int_red_Y,
+    png_fixed_point int_red_Z, png_fixed_point int_green_X,
+    png_fixed_point int_green_Y, png_fixed_point int_green_Z,
+    png_fixed_point int_blue_X, png_fixed_point int_blue_Y,
+    png_fixed_point int_blue_Z))
+#endif
+
+#ifdef PNG_eXIf_SUPPORTED
+PNG_EXPORT(246, png_uint_32, png_get_eXIf, (png_const_structrp png_ptr,
+    png_inforp info_ptr, png_bytep *exif));
+PNG_EXPORT(247, void, png_set_eXIf, (png_const_structrp png_ptr,
+    png_inforp info_ptr, const png_bytep exif));
+
+PNG_EXPORT(248, png_uint_32, png_get_eXIf_1, (png_const_structrp png_ptr,
+    png_const_inforp info_ptr, png_uint_32 *num_exif, png_bytep *exif));
+PNG_EXPORT(249, void, png_set_eXIf_1, (png_const_structrp png_ptr,
+    png_inforp info_ptr, const png_uint_32 num_exif, const png_bytep exif));
+#endif
+
+#ifdef PNG_gAMA_SUPPORTED
+PNG_FP_EXPORT(137, png_uint_32, png_get_gAMA, (png_const_structrp png_ptr,
+    png_const_inforp info_ptr, double *file_gamma))
+PNG_FIXED_EXPORT(138, png_uint_32, png_get_gAMA_fixed,
+    (png_const_structrp png_ptr, png_const_inforp info_ptr,
+    png_fixed_point *int_file_gamma))
+#endif
+
+#ifdef PNG_gAMA_SUPPORTED
+PNG_FP_EXPORT(139, void, png_set_gAMA, (png_const_structrp png_ptr,
+    png_inforp info_ptr, double file_gamma))
+PNG_FIXED_EXPORT(140, void, png_set_gAMA_fixed, (png_const_structrp png_ptr,
+    png_inforp info_ptr, png_fixed_point int_file_gamma))
+#endif
+
+#ifdef PNG_hIST_SUPPORTED
+PNG_EXPORT(141, png_uint_32, png_get_hIST, (png_const_structrp png_ptr,
+    png_inforp info_ptr, png_uint_16p *hist));
+PNG_EXPORT(142, void, png_set_hIST, (png_const_structrp png_ptr,
+    png_inforp info_ptr, png_const_uint_16p hist));
+#endif
+
+PNG_EXPORT(143, png_uint_32, png_get_IHDR, (png_const_structrp png_ptr,
+    png_const_inforp info_ptr, png_uint_32 *width, png_uint_32 *height,
+    int *bit_depth, int *color_type, int *interlace_method,
+    int *compression_method, int *filter_method));
+
+PNG_EXPORT(144, void, png_set_IHDR, (png_const_structrp png_ptr,
+    png_inforp info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth,
+    int color_type, int interlace_method, int compression_method,
+    int filter_method));
+
+#ifdef PNG_oFFs_SUPPORTED
+PNG_EXPORT(145, png_uint_32, png_get_oFFs, (png_const_structrp png_ptr,
+   png_const_inforp info_ptr, png_int_32 *offset_x, png_int_32 *offset_y,
+   int *unit_type));
+#endif
+
+#ifdef PNG_oFFs_SUPPORTED
+PNG_EXPORT(146, void, png_set_oFFs, (png_const_structrp png_ptr,
+    png_inforp info_ptr, png_int_32 offset_x, png_int_32 offset_y,
+    int unit_type));
+#endif
+
+#ifdef PNG_pCAL_SUPPORTED
+PNG_EXPORT(147, png_uint_32, png_get_pCAL, (png_const_structrp png_ptr,
+    png_inforp info_ptr, png_charp *purpose, png_int_32 *X0,
+    png_int_32 *X1, int *type, int *nparams, png_charp *units,
+    png_charpp *params));
+#endif
+
+#ifdef PNG_pCAL_SUPPORTED
+PNG_EXPORT(148, void, png_set_pCAL, (png_const_structrp png_ptr,
+    png_inforp info_ptr, png_const_charp purpose, png_int_32 X0, png_int_32 X1,
+    int type, int nparams, png_const_charp units, png_charpp params));
+#endif
+
+#ifdef PNG_pHYs_SUPPORTED
+PNG_EXPORT(149, png_uint_32, png_get_pHYs, (png_const_structrp png_ptr,
+    png_const_inforp info_ptr, png_uint_32 *res_x, png_uint_32 *res_y,
+    int *unit_type));
+#endif
+
+#ifdef PNG_pHYs_SUPPORTED
+PNG_EXPORT(150, void, png_set_pHYs, (png_const_structrp png_ptr,
+    png_inforp info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type));
+#endif
+
+PNG_EXPORT(151, png_uint_32, png_get_PLTE, (png_const_structrp png_ptr,
+   png_inforp info_ptr, png_colorp *palette, int *num_palette));
+
+PNG_EXPORT(152, void, png_set_PLTE, (png_structrp png_ptr,
+    png_inforp info_ptr, png_const_colorp palette, int num_palette));
+
+#ifdef PNG_sBIT_SUPPORTED
+PNG_EXPORT(153, png_uint_32, png_get_sBIT, (png_const_structrp png_ptr,
+    png_inforp info_ptr, png_color_8p *sig_bit));
+#endif
+
+#ifdef PNG_sBIT_SUPPORTED
+PNG_EXPORT(154, void, png_set_sBIT, (png_const_structrp png_ptr,
+    png_inforp info_ptr, png_const_color_8p sig_bit));
+#endif
+
+#ifdef PNG_sRGB_SUPPORTED
+PNG_EXPORT(155, png_uint_32, png_get_sRGB, (png_const_structrp png_ptr,
+    png_const_inforp info_ptr, int *file_srgb_intent));
+#endif
+
+#ifdef PNG_sRGB_SUPPORTED
+PNG_EXPORT(156, void, png_set_sRGB, (png_const_structrp png_ptr,
+    png_inforp info_ptr, int srgb_intent));
+PNG_EXPORT(157, void, png_set_sRGB_gAMA_and_cHRM, (png_const_structrp png_ptr,
+    png_inforp info_ptr, int srgb_intent));
+#endif
+
+#ifdef PNG_iCCP_SUPPORTED
+PNG_EXPORT(158, png_uint_32, png_get_iCCP, (png_const_structrp png_ptr,
+    png_inforp info_ptr, png_charpp name, int *compression_type,
+    png_bytepp profile, png_uint_32 *proflen));
+#endif
+
+#ifdef PNG_iCCP_SUPPORTED
+PNG_EXPORT(159, void, png_set_iCCP, (png_const_structrp png_ptr,
+    png_inforp info_ptr, png_const_charp name, int compression_type,
+    png_const_bytep profile, png_uint_32 proflen));
+#endif
+
+#ifdef PNG_sPLT_SUPPORTED
+PNG_EXPORT(160, int, png_get_sPLT, (png_const_structrp png_ptr,
+    png_inforp info_ptr, png_sPLT_tpp entries));
+#endif
+
+#ifdef PNG_sPLT_SUPPORTED
+PNG_EXPORT(161, void, png_set_sPLT, (png_const_structrp png_ptr,
+    png_inforp info_ptr, png_const_sPLT_tp entries, int nentries));
+#endif
+
+#ifdef PNG_TEXT_SUPPORTED
+/* png_get_text also returns the number of text chunks in *num_text */
+PNG_EXPORT(162, int, png_get_text, (png_const_structrp png_ptr,
+    png_inforp info_ptr, png_textp *text_ptr, int *num_text));
+#endif
+
+/* Note while png_set_text() will accept a structure whose text,
+ * language, and  translated keywords are NULL pointers, the structure
+ * returned by png_get_text will always contain regular
+ * zero-terminated C strings.  They might be empty strings but
+ * they will never be NULL pointers.
+ */
+
+#ifdef PNG_TEXT_SUPPORTED
+PNG_EXPORT(163, void, png_set_text, (png_const_structrp png_ptr,
+    png_inforp info_ptr, png_const_textp text_ptr, int num_text));
+#endif
+
+#ifdef PNG_tIME_SUPPORTED
+PNG_EXPORT(164, png_uint_32, png_get_tIME, (png_const_structrp png_ptr,
+    png_inforp info_ptr, png_timep *mod_time));
+#endif
+
+#ifdef PNG_tIME_SUPPORTED
+PNG_EXPORT(165, void, png_set_tIME, (png_const_structrp png_ptr,
+    png_inforp info_ptr, png_const_timep mod_time));
+#endif
+
+#ifdef PNG_tRNS_SUPPORTED
+PNG_EXPORT(166, png_uint_32, png_get_tRNS, (png_const_structrp png_ptr,
+    png_inforp info_ptr, png_bytep *trans_alpha, int *num_trans,
+    png_color_16p *trans_color));
+#endif
+
+#ifdef PNG_tRNS_SUPPORTED
+PNG_EXPORT(167, void, png_set_tRNS, (png_structrp png_ptr,
+    png_inforp info_ptr, png_const_bytep trans_alpha, int num_trans,
+    png_const_color_16p trans_color));
+#endif
+
+#ifdef PNG_sCAL_SUPPORTED
+PNG_FP_EXPORT(168, png_uint_32, png_get_sCAL, (png_const_structrp png_ptr,
+    png_const_inforp info_ptr, int *unit, double *width, double *height))
+#if defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) || \
+   defined(PNG_FLOATING_POINT_SUPPORTED)
+/* NOTE: this API is currently implemented using floating point arithmetic,
+ * consequently it can only be used on systems with floating point support.
+ * In any case the range of values supported by png_fixed_point is small and it
+ * is highly recommended that png_get_sCAL_s be used instead.
+ */
+PNG_FIXED_EXPORT(214, png_uint_32, png_get_sCAL_fixed,
+    (png_const_structrp png_ptr, png_const_inforp info_ptr, int *unit,
+    png_fixed_point *width, png_fixed_point *height))
+#endif
+PNG_EXPORT(169, png_uint_32, png_get_sCAL_s,
+    (png_const_structrp png_ptr, png_const_inforp info_ptr, int *unit,
+    png_charpp swidth, png_charpp sheight));
+
+PNG_FP_EXPORT(170, void, png_set_sCAL, (png_const_structrp png_ptr,
+    png_inforp info_ptr, int unit, double width, double height))
+PNG_FIXED_EXPORT(213, void, png_set_sCAL_fixed, (png_const_structrp png_ptr,
+   png_inforp info_ptr, int unit, png_fixed_point width,
+   png_fixed_point height))
+PNG_EXPORT(171, void, png_set_sCAL_s, (png_const_structrp png_ptr,
+    png_inforp info_ptr, int unit,
+    png_const_charp swidth, png_const_charp sheight));
+#endif /* sCAL */
+
+#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
+/* Provide the default handling for all unknown chunks or, optionally, for
+ * specific unknown chunks.
+ *
+ * NOTE: prior to 1.6.0 the handling specified for particular chunks on read was
+ * ignored and the default was used, the per-chunk setting only had an effect on
+ * write.  If you wish to have chunk-specific handling on read in code that must
+ * work on earlier versions you must use a user chunk callback to specify the
+ * desired handling (keep or discard.)
+ *
+ * The 'keep' parameter is a PNG_HANDLE_CHUNK_ value as listed below.  The
+ * parameter is interpreted as follows:
+ *
+ * READ:
+ *    PNG_HANDLE_CHUNK_AS_DEFAULT:
+ *       Known chunks: do normal libpng processing, do not keep the chunk (but
+ *          see the comments below about PNG_HANDLE_AS_UNKNOWN_SUPPORTED)
+ *       Unknown chunks: for a specific chunk use the global default, when used
+ *          as the default discard the chunk data.
+ *    PNG_HANDLE_CHUNK_NEVER:
+ *       Discard the chunk data.
+ *    PNG_HANDLE_CHUNK_IF_SAFE:
+ *       Keep the chunk data if the chunk is not critical else raise a chunk
+ *       error.
+ *    PNG_HANDLE_CHUNK_ALWAYS:
+ *       Keep the chunk data.
+ *
+ * If the chunk data is saved it can be retrieved using png_get_unknown_chunks,
+ * below.  Notice that specifying "AS_DEFAULT" as a global default is equivalent
+ * to specifying "NEVER", however when "AS_DEFAULT" is used for specific chunks
+ * it simply resets the behavior to the libpng default.
+ *
+ * INTERACTION WTIH USER CHUNK CALLBACKS:
+ * The per-chunk handling is always used when there is a png_user_chunk_ptr
+ * callback and the callback returns 0; the chunk is then always stored *unless*
+ * it is critical and the per-chunk setting is other than ALWAYS.  Notice that
+ * the global default is *not* used in this case.  (In effect the per-chunk
+ * value is incremented to at least IF_SAFE.)
+ *
+ * IMPORTANT NOTE: this behavior will change in libpng 1.7 - the global and
+ * per-chunk defaults will be honored.  If you want to preserve the current
+ * behavior when your callback returns 0 you must set PNG_HANDLE_CHUNK_IF_SAFE
+ * as the default - if you don't do this libpng 1.6 will issue a warning.
+ *
+ * If you want unhandled unknown chunks to be discarded in libpng 1.6 and
+ * earlier simply return '1' (handled).
+ *
+ * PNG_HANDLE_AS_UNKNOWN_SUPPORTED:
+ *    If this is *not* set known chunks will always be handled by libpng and
+ *    will never be stored in the unknown chunk list.  Known chunks listed to
+ *    png_set_keep_unknown_chunks will have no effect.  If it is set then known
+ *    chunks listed with a keep other than AS_DEFAULT will *never* be processed
+ *    by libpng, in addition critical chunks must either be processed by the
+ *    callback or saved.
+ *
+ *    The IHDR and IEND chunks must not be listed.  Because this turns off the
+ *    default handling for chunks that would otherwise be recognized the
+ *    behavior of libpng transformations may well become incorrect!
+ *
+ * WRITE:
+ *    When writing chunks the options only apply to the chunks specified by
+ *    png_set_unknown_chunks (below), libpng will *always* write known chunks
+ *    required by png_set_ calls and will always write the core critical chunks
+ *    (as required for PLTE).
+ *
+ *    Each chunk in the png_set_unknown_chunks list is looked up in the
+ *    png_set_keep_unknown_chunks list to find the keep setting, this is then
+ *    interpreted as follows:
+ *
+ *    PNG_HANDLE_CHUNK_AS_DEFAULT:
+ *       Write safe-to-copy chunks and write other chunks if the global
+ *       default is set to _ALWAYS, otherwise don't write this chunk.
+ *    PNG_HANDLE_CHUNK_NEVER:
+ *       Do not write the chunk.
+ *    PNG_HANDLE_CHUNK_IF_SAFE:
+ *       Write the chunk if it is safe-to-copy, otherwise do not write it.
+ *    PNG_HANDLE_CHUNK_ALWAYS:
+ *       Write the chunk.
+ *
+ * Note that the default behavior is effectively the opposite of the read case -
+ * in read unknown chunks are not stored by default, in write they are written
+ * by default.  Also the behavior of PNG_HANDLE_CHUNK_IF_SAFE is very different
+ * - on write the safe-to-copy bit is checked, on read the critical bit is
+ * checked and on read if the chunk is critical an error will be raised.
+ *
+ * num_chunks:
+ * ===========
+ *    If num_chunks is positive, then the "keep" parameter specifies the manner
+ *    for handling only those chunks appearing in the chunk_list array,
+ *    otherwise the chunk list array is ignored.
+ *
+ *    If num_chunks is 0 the "keep" parameter specifies the default behavior for
+ *    unknown chunks, as described above.
+ *
+ *    If num_chunks is negative, then the "keep" parameter specifies the manner
+ *    for handling all unknown chunks plus all chunks recognized by libpng
+ *    except for the IHDR, PLTE, tRNS, IDAT, and IEND chunks (which continue to
+ *    be processed by libpng.
+ */
+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+PNG_EXPORT(172, void, png_set_keep_unknown_chunks, (png_structrp png_ptr,
+    int keep, png_const_bytep chunk_list, int num_chunks));
+#endif /* HANDLE_AS_UNKNOWN */
+
+/* The "keep" PNG_HANDLE_CHUNK_ parameter for the specified chunk is returned;
+ * the result is therefore true (non-zero) if special handling is required,
+ * false for the default handling.
+ */
+PNG_EXPORT(173, int, png_handle_as_unknown, (png_const_structrp png_ptr,
+    png_const_bytep chunk_name));
+#endif /* SET_UNKNOWN_CHUNKS */
+
+#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
+PNG_EXPORT(174, void, png_set_unknown_chunks, (png_const_structrp png_ptr,
+    png_inforp info_ptr, png_const_unknown_chunkp unknowns,
+    int num_unknowns));
+   /* NOTE: prior to 1.6.0 this routine set the 'location' field of the added
+    * unknowns to the location currently stored in the png_struct.  This is
+    * invariably the wrong value on write.  To fix this call the following API
+    * for each chunk in the list with the correct location.  If you know your
+    * code won't be compiled on earlier versions you can rely on
+    * png_set_unknown_chunks(write-ptr, png_get_unknown_chunks(read-ptr)) doing
+    * the correct thing.
+    */
+
+PNG_EXPORT(175, void, png_set_unknown_chunk_location,
+    (png_const_structrp png_ptr, png_inforp info_ptr, int chunk, int location));
+
+PNG_EXPORT(176, int, png_get_unknown_chunks, (png_const_structrp png_ptr,
+    png_inforp info_ptr, png_unknown_chunkpp entries));
+#endif
+
+/* Png_free_data() will turn off the "valid" flag for anything it frees.
+ * If you need to turn it off for a chunk that your application has freed,
+ * you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK);
+ */
+PNG_EXPORT(177, void, png_set_invalid, (png_const_structrp png_ptr,
+    png_inforp info_ptr, int mask));
+
+#ifdef PNG_INFO_IMAGE_SUPPORTED
+/* The "params" pointer is currently not used and is for future expansion. */
+#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+PNG_EXPORT(178, void, png_read_png, (png_structrp png_ptr, png_inforp info_ptr,
+    int transforms, png_voidp params));
+#endif
+#ifdef PNG_WRITE_SUPPORTED
+PNG_EXPORT(179, void, png_write_png, (png_structrp png_ptr, png_inforp info_ptr,
+    int transforms, png_voidp params));
+#endif
+#endif
+
+PNG_EXPORT(180, png_const_charp, png_get_copyright,
+    (png_const_structrp png_ptr));
+PNG_EXPORT(181, png_const_charp, png_get_header_ver,
+    (png_const_structrp png_ptr));
+PNG_EXPORT(182, png_const_charp, png_get_header_version,
+    (png_const_structrp png_ptr));
+PNG_EXPORT(183, png_const_charp, png_get_libpng_ver,
+    (png_const_structrp png_ptr));
+
+#ifdef PNG_MNG_FEATURES_SUPPORTED
+PNG_EXPORT(184, png_uint_32, png_permit_mng_features, (png_structrp png_ptr,
+    png_uint_32 mng_features_permitted));
+#endif
+
+/* For use in png_set_keep_unknown, added to version 1.2.6 */
+#define PNG_HANDLE_CHUNK_AS_DEFAULT   0
+#define PNG_HANDLE_CHUNK_NEVER        1
+#define PNG_HANDLE_CHUNK_IF_SAFE      2
+#define PNG_HANDLE_CHUNK_ALWAYS       3
+#define PNG_HANDLE_CHUNK_LAST         4
+
+/* Strip the prepended error numbers ("#nnn ") from error and warning
+ * messages before passing them to the error or warning handler.
+ */
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED
+PNG_EXPORT(185, void, png_set_strip_error_numbers, (png_structrp png_ptr,
+    png_uint_32 strip_mode));
+#endif
+
+/* Added in libpng-1.2.6 */
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED
+PNG_EXPORT(186, void, png_set_user_limits, (png_structrp png_ptr,
+    png_uint_32 user_width_max, png_uint_32 user_height_max));
+PNG_EXPORT(187, png_uint_32, png_get_user_width_max,
+    (png_const_structrp png_ptr));
+PNG_EXPORT(188, png_uint_32, png_get_user_height_max,
+    (png_const_structrp png_ptr));
+/* Added in libpng-1.4.0 */
+PNG_EXPORT(189, void, png_set_chunk_cache_max, (png_structrp png_ptr,
+    png_uint_32 user_chunk_cache_max));
+PNG_EXPORT(190, png_uint_32, png_get_chunk_cache_max,
+    (png_const_structrp png_ptr));
+/* Added in libpng-1.4.1 */
+PNG_EXPORT(191, void, png_set_chunk_malloc_max, (png_structrp png_ptr,
+    png_alloc_size_t user_chunk_cache_max));
+PNG_EXPORT(192, png_alloc_size_t, png_get_chunk_malloc_max,
+    (png_const_structrp png_ptr));
+#endif
+
+#if defined(PNG_INCH_CONVERSIONS_SUPPORTED)
+PNG_EXPORT(193, png_uint_32, png_get_pixels_per_inch,
+    (png_const_structrp png_ptr, png_const_inforp info_ptr));
+
+PNG_EXPORT(194, png_uint_32, png_get_x_pixels_per_inch,
+    (png_const_structrp png_ptr, png_const_inforp info_ptr));
+
+PNG_EXPORT(195, png_uint_32, png_get_y_pixels_per_inch,
+    (png_const_structrp png_ptr, png_const_inforp info_ptr));
+
+PNG_FP_EXPORT(196, float, png_get_x_offset_inches,
+    (png_const_structrp png_ptr, png_const_inforp info_ptr))
+#ifdef PNG_FIXED_POINT_SUPPORTED /* otherwise not implemented. */
+PNG_FIXED_EXPORT(211, png_fixed_point, png_get_x_offset_inches_fixed,
+    (png_const_structrp png_ptr, png_const_inforp info_ptr))
+#endif
+
+PNG_FP_EXPORT(197, float, png_get_y_offset_inches, (png_const_structrp png_ptr,
+    png_const_inforp info_ptr))
+#ifdef PNG_FIXED_POINT_SUPPORTED /* otherwise not implemented. */
+PNG_FIXED_EXPORT(212, png_fixed_point, png_get_y_offset_inches_fixed,
+    (png_const_structrp png_ptr, png_const_inforp info_ptr))
+#endif
+
+#  ifdef PNG_pHYs_SUPPORTED
+PNG_EXPORT(198, png_uint_32, png_get_pHYs_dpi, (png_const_structrp png_ptr,
+    png_const_inforp info_ptr, png_uint_32 *res_x, png_uint_32 *res_y,
+    int *unit_type));
+#  endif /* pHYs */
+#endif  /* INCH_CONVERSIONS */
+
+/* Added in libpng-1.4.0 */
+#ifdef PNG_IO_STATE_SUPPORTED
+PNG_EXPORT(199, png_uint_32, png_get_io_state, (png_const_structrp png_ptr));
+
+/* Removed from libpng 1.6; use png_get_io_chunk_type. */
+PNG_REMOVED(200, png_const_bytep, png_get_io_chunk_name, (png_structrp png_ptr),
+    PNG_DEPRECATED)
+
+PNG_EXPORT(216, png_uint_32, png_get_io_chunk_type,
+    (png_const_structrp png_ptr));
+
+/* The flags returned by png_get_io_state() are the following: */
+#  define PNG_IO_NONE        0x0000   /* no I/O at this moment */
+#  define PNG_IO_READING     0x0001   /* currently reading */
+#  define PNG_IO_WRITING     0x0002   /* currently writing */
+#  define PNG_IO_SIGNATURE   0x0010   /* currently at the file signature */
+#  define PNG_IO_CHUNK_HDR   0x0020   /* currently at the chunk header */
+#  define PNG_IO_CHUNK_DATA  0x0040   /* currently at the chunk data */
+#  define PNG_IO_CHUNK_CRC   0x0080   /* currently at the chunk crc */
+#  define PNG_IO_MASK_OP     0x000f   /* current operation: reading/writing */
+#  define PNG_IO_MASK_LOC    0x00f0   /* current location: sig/hdr/data/crc */
+#endif /* IO_STATE */
+
+/* Interlace support.  The following macros are always defined so that if
+ * libpng interlace handling is turned off the macros may be used to handle
+ * interlaced images within the application.
+ */
+#define PNG_INTERLACE_ADAM7_PASSES 7
+
+/* Two macros to return the first row and first column of the original,
+ * full, image which appears in a given pass.  'pass' is in the range 0
+ * to 6 and the result is in the range 0 to 7.
+ */
+#define PNG_PASS_START_ROW(pass) (((1&~(pass))<<(3-((pass)>>1)))&7)
+#define PNG_PASS_START_COL(pass) (((1& (pass))<<(3-(((pass)+1)>>1)))&7)
+
+/* A macro to return the offset between pixels in the output row for a pair of
+ * pixels in the input - effectively the inverse of the 'COL_SHIFT' macro that
+ * follows.  Note that ROW_OFFSET is the offset from one row to the next whereas
+ * COL_OFFSET is from one column to the next, within a row.
+ */
+#define PNG_PASS_ROW_OFFSET(pass) ((pass)>2?(8>>(((pass)-1)>>1)):8)
+#define PNG_PASS_COL_OFFSET(pass) (1<<((7-(pass))>>1))
+
+/* Two macros to help evaluate the number of rows or columns in each
+ * pass.  This is expressed as a shift - effectively log2 of the number or
+ * rows or columns in each 8x8 tile of the original image.
+ */
+#define PNG_PASS_ROW_SHIFT(pass) ((pass)>2?(8-(pass))>>1:3)
+#define PNG_PASS_COL_SHIFT(pass) ((pass)>1?(7-(pass))>>1:3)
+
+/* Hence two macros to determine the number of rows or columns in a given
+ * pass of an image given its height or width.  In fact these macros may
+ * return non-zero even though the sub-image is empty, because the other
+ * dimension may be empty for a small image.
+ */
+#define PNG_PASS_ROWS(height, pass) (((height)+(((1<<PNG_PASS_ROW_SHIFT(pass))\
+   -1)-PNG_PASS_START_ROW(pass)))>>PNG_PASS_ROW_SHIFT(pass))
+#define PNG_PASS_COLS(width, pass) (((width)+(((1<<PNG_PASS_COL_SHIFT(pass))\
+   -1)-PNG_PASS_START_COL(pass)))>>PNG_PASS_COL_SHIFT(pass))
+
+/* For the reader row callbacks (both progressive and sequential) it is
+ * necessary to find the row in the output image given a row in an interlaced
+ * image, so two more macros:
+ */
+#define PNG_ROW_FROM_PASS_ROW(y_in, pass) \
+   (((y_in)<<PNG_PASS_ROW_SHIFT(pass))+PNG_PASS_START_ROW(pass))
+#define PNG_COL_FROM_PASS_COL(x_in, pass) \
+   (((x_in)<<PNG_PASS_COL_SHIFT(pass))+PNG_PASS_START_COL(pass))
+
+/* Two macros which return a boolean (0 or 1) saying whether the given row
+ * or column is in a particular pass.  These use a common utility macro that
+ * returns a mask for a given pass - the offset 'off' selects the row or
+ * column version.  The mask has the appropriate bit set for each column in
+ * the tile.
+ */
+#define PNG_PASS_MASK(pass,off) ( \
+   ((0x110145AF>>(((7-(off))-(pass))<<2)) & 0xF) | \
+   ((0x01145AF0>>(((7-(off))-(pass))<<2)) & 0xF0))
+
+#define PNG_ROW_IN_INTERLACE_PASS(y, pass) \
+   ((PNG_PASS_MASK(pass,0) >> ((y)&7)) & 1)
+#define PNG_COL_IN_INTERLACE_PASS(x, pass) \
+   ((PNG_PASS_MASK(pass,1) >> ((x)&7)) & 1)
+
+#ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED
+/* With these routines we avoid an integer divide, which will be slower on
+ * most machines.  However, it does take more operations than the corresponding
+ * divide method, so it may be slower on a few RISC systems.  There are two
+ * shifts (by 8 or 16 bits) and an addition, versus a single integer divide.
+ *
+ * Note that the rounding factors are NOT supposed to be the same!  128 and
+ * 32768 are correct for the NODIV code; 127 and 32767 are correct for the
+ * standard method.
+ *
+ * [Optimized code by Greg Roelofs and Mark Adler...blame us for bugs. :-) ]
+ */
+
+ /* fg and bg should be in `gamma 1.0' space; alpha is the opacity */
+
+#  define png_composite(composite, fg, alpha, bg)        \
+   {                                                     \
+      png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) \
+          * (png_uint_16)(alpha)                         \
+          + (png_uint_16)(bg)*(png_uint_16)(255          \
+          - (png_uint_16)(alpha)) + 128);                \
+      (composite) = (png_byte)(((temp + (temp >> 8)) >> 8) & 0xff); \
+   }
+
+#  define png_composite_16(composite, fg, alpha, bg)     \
+   {                                                     \
+      png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) \
+          * (png_uint_32)(alpha)                         \
+          + (png_uint_32)(bg)*(65535                     \
+          - (png_uint_32)(alpha)) + 32768);              \
+      (composite) = (png_uint_16)(0xffff & ((temp + (temp >> 16)) >> 16)); \
+   }
+
+#else  /* Standard method using integer division */
+
+#  define png_composite(composite, fg, alpha, bg)                      \
+   (composite) =                                                       \
+       (png_byte)(0xff & (((png_uint_16)(fg) * (png_uint_16)(alpha) +  \
+       (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \
+       127) / 255))
+
+#  define png_composite_16(composite, fg, alpha, bg)                       \
+   (composite) =                                                           \
+       (png_uint_16)(0xffff & (((png_uint_32)(fg) * (png_uint_32)(alpha) + \
+       (png_uint_32)(bg)*(png_uint_32)(65535 - (png_uint_32)(alpha)) +     \
+       32767) / 65535))
+#endif /* READ_COMPOSITE_NODIV */
+
+#ifdef PNG_READ_INT_FUNCTIONS_SUPPORTED
+PNG_EXPORT(201, png_uint_32, png_get_uint_32, (png_const_bytep buf));
+PNG_EXPORT(202, png_uint_16, png_get_uint_16, (png_const_bytep buf));
+PNG_EXPORT(203, png_int_32, png_get_int_32, (png_const_bytep buf));
+#endif
+
+PNG_EXPORT(204, png_uint_32, png_get_uint_31, (png_const_structrp png_ptr,
+    png_const_bytep buf));
+/* No png_get_int_16 -- may be added if there's a real need for it. */
+
+/* Place a 32-bit number into a buffer in PNG byte order (big-endian). */
+#ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED
+PNG_EXPORT(205, void, png_save_uint_32, (png_bytep buf, png_uint_32 i));
+#endif
+#ifdef PNG_SAVE_INT_32_SUPPORTED
+PNG_EXPORT(206, void, png_save_int_32, (png_bytep buf, png_int_32 i));
+#endif
+
+/* Place a 16-bit number into a buffer in PNG byte order.
+ * The parameter is declared unsigned int, not png_uint_16,
+ * just to avoid potential problems on pre-ANSI C compilers.
+ */
+#ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED
+PNG_EXPORT(207, void, png_save_uint_16, (png_bytep buf, unsigned int i));
+/* No png_save_int_16 -- may be added if there's a real need for it. */
+#endif
+
+#ifdef PNG_USE_READ_MACROS
+/* Inline macros to do direct reads of bytes from the input buffer.
+ * The png_get_int_32() routine assumes we are using two's complement
+ * format for negative values, which is almost certainly true.
+ */
+#  define PNG_get_uint_32(buf) \
+   (((png_uint_32)(*(buf)) << 24) + \
+    ((png_uint_32)(*((buf) + 1)) << 16) + \
+    ((png_uint_32)(*((buf) + 2)) << 8) + \
+    ((png_uint_32)(*((buf) + 3))))
+
+   /* From libpng-1.4.0 until 1.4.4, the png_get_uint_16 macro (but not the
+    * function) incorrectly returned a value of type png_uint_32.
+    */
+#  define PNG_get_uint_16(buf) \
+   ((png_uint_16) \
+    (((unsigned int)(*(buf)) << 8) + \
+    ((unsigned int)(*((buf) + 1)))))
+
+#  define PNG_get_int_32(buf) \
+   ((png_int_32)((*(buf) & 0x80) \
+    ? -((png_int_32)(((png_get_uint_32(buf)^0xffffffffU)+1U)&0x7fffffffU)) \
+    : (png_int_32)png_get_uint_32(buf)))
+
+/* If PNG_PREFIX is defined the same thing as below happens in pnglibconf.h,
+ * but defining a macro name prefixed with PNG_PREFIX.
+ */
+#  ifndef PNG_PREFIX
+#    define png_get_uint_32(buf) PNG_get_uint_32(buf)
+#    define png_get_uint_16(buf) PNG_get_uint_16(buf)
+#    define png_get_int_32(buf)  PNG_get_int_32(buf)
+#  endif
+#else
+#  ifdef PNG_PREFIX
+   /* No macros; revert to the (redefined) function */
+#    define PNG_get_uint_32 (png_get_uint_32)
+#    define PNG_get_uint_16 (png_get_uint_16)
+#    define PNG_get_int_32  (png_get_int_32)
+#  endif
+#endif
+
+#ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
+PNG_EXPORT(242, void, png_set_check_for_invalid_index,
+    (png_structrp png_ptr, int allowed));
+#  ifdef PNG_GET_PALETTE_MAX_SUPPORTED
+PNG_EXPORT(243, int, png_get_palette_max, (png_const_structp png_ptr,
+    png_const_infop info_ptr));
+#  endif
+#endif /* CHECK_FOR_INVALID_INDEX */
+
+/*******************************************************************************
+ * Section 5: SIMPLIFIED API
+ *******************************************************************************
+ *
+ * Please read the documentation in libpng-manual.txt (TODO: write said
+ * documentation) if you don't understand what follows.
+ *
+ * The simplified API hides the details of both libpng and the PNG file format
+ * itself.  It allows PNG files to be read into a very limited number of
+ * in-memory bitmap formats or to be written from the same formats.  If these
+ * formats do not accomodate your needs then you can, and should, use the more
+ * sophisticated APIs above - these support a wide variety of in-memory formats
+ * and a wide variety of sophisticated transformations to those formats as well
+ * as a wide variety of APIs to manipulate ancillary information.
+ *
+ * To read a PNG file using the simplified API:
+ *
+ * 1) Declare a 'png_image' structure (see below) on the stack, set the
+ *    version field to PNG_IMAGE_VERSION and the 'opaque' pointer to NULL
+ *    (this is REQUIRED, your program may crash if you don't do it.)
+ * 2) Call the appropriate png_image_begin_read... function.
+ * 3) Set the png_image 'format' member to the required sample format.
+ * 4) Allocate a buffer for the image and, if required, the color-map.
+ * 5) Call png_image_finish_read to read the image and, if required, the
+ *    color-map into your buffers.
+ *
+ * There are no restrictions on the format of the PNG input itself; all valid
+ * color types, bit depths, and interlace methods are acceptable, and the
+ * input image is transformed as necessary to the requested in-memory format
+ * during the png_image_finish_read() step.  The only caveat is that if you
+ * request a color-mapped image from a PNG that is full-color or makes
+ * complex use of an alpha channel the transformation is extremely lossy and the
+ * result may look terrible.
+ *
+ * To write a PNG file using the simplified API:
+ *
+ * 1) Declare a 'png_image' structure on the stack and memset() it to all zero.
+ * 2) Initialize the members of the structure that describe the image, setting
+ *    the 'format' member to the format of the image samples.
+ * 3) Call the appropriate png_image_write... function with a pointer to the
+ *    image and, if necessary, the color-map to write the PNG data.
+ *
+ * png_image is a structure that describes the in-memory format of an image
+ * when it is being read or defines the in-memory format of an image that you
+ * need to write:
+ */
+#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) || \
+    defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
+
+#define PNG_IMAGE_VERSION 1
+
+typedef struct png_control *png_controlp;
+typedef struct
+{
+   png_controlp opaque;    /* Initialize to NULL, free with png_image_free */
+   png_uint_32  version;   /* Set to PNG_IMAGE_VERSION */
+   png_uint_32  width;     /* Image width in pixels (columns) */
+   png_uint_32  height;    /* Image height in pixels (rows) */
+   png_uint_32  format;    /* Image format as defined below */
+   png_uint_32  flags;     /* A bit mask containing informational flags */
+   png_uint_32  colormap_entries;
+                           /* Number of entries in the color-map */
+
+   /* In the event of an error or warning the following field will be set to a
+    * non-zero value and the 'message' field will contain a '\0' terminated
+    * string with the libpng error or warning message.  If both warnings and
+    * an error were encountered, only the error is recorded.  If there
+    * are multiple warnings, only the first one is recorded.
+    *
+    * The upper 30 bits of this value are reserved, the low two bits contain
+    * a value as follows:
+    */
+#  define PNG_IMAGE_WARNING 1
+#  define PNG_IMAGE_ERROR 2
+   /*
+    * The result is a two-bit code such that a value more than 1 indicates
+    * a failure in the API just called:
+    *
+    *    0 - no warning or error
+    *    1 - warning
+    *    2 - error
+    *    3 - error preceded by warning
+    */
+#  define PNG_IMAGE_FAILED(png_cntrl) ((((png_cntrl).warning_or_error)&0x03)>1)
+
+   png_uint_32  warning_or_error;
+
+   char         message[64];
+} png_image, *png_imagep;
+
+/* The samples of the image have one to four channels whose components have
+ * original values in the range 0 to 1.0:
+ *
+ * 1: A single gray or luminance channel (G).
+ * 2: A gray/luminance channel and an alpha channel (GA).
+ * 3: Three red, green, blue color channels (RGB).
+ * 4: Three color channels and an alpha channel (RGBA).
+ *
+ * The components are encoded in one of two ways:
+ *
+ * a) As a small integer, value 0..255, contained in a single byte.  For the
+ * alpha channel the original value is simply value/255.  For the color or
+ * luminance channels the value is encoded according to the sRGB specification
+ * and matches the 8-bit format expected by typical display devices.
+ *
+ * The color/gray channels are not scaled (pre-multiplied) by the alpha
+ * channel and are suitable for passing to color management software.
+ *
+ * b) As a value in the range 0..65535, contained in a 2-byte integer.  All
+ * channels can be converted to the original value by dividing by 65535; all
+ * channels are linear.  Color channels use the RGB encoding (RGB end-points) of
+ * the sRGB specification.  This encoding is identified by the
+ * PNG_FORMAT_FLAG_LINEAR flag below.
+ *
+ * When the simplified API needs to convert between sRGB and linear colorspaces,
+ * the actual sRGB transfer curve defined in the sRGB specification (see the
+ * article at https://en.wikipedia.org/wiki/SRGB) is used, not the gamma=1/2.2
+ * approximation used elsewhere in libpng.
+ *
+ * When an alpha channel is present it is expected to denote pixel coverage
+ * of the color or luminance channels and is returned as an associated alpha
+ * channel: the color/gray channels are scaled (pre-multiplied) by the alpha
+ * value.
+ *
+ * The samples are either contained directly in the image data, between 1 and 8
+ * bytes per pixel according to the encoding, or are held in a color-map indexed
+ * by bytes in the image data.  In the case of a color-map the color-map entries
+ * are individual samples, encoded as above, and the image data has one byte per
+ * pixel to select the relevant sample from the color-map.
+ */
+
+/* PNG_FORMAT_*
+ *
+ * #defines to be used in png_image::format.  Each #define identifies a
+ * particular layout of sample data and, if present, alpha values.  There are
+ * separate defines for each of the two component encodings.
+ *
+ * A format is built up using single bit flag values.  All combinations are
+ * valid.  Formats can be built up from the flag values or you can use one of
+ * the predefined values below.  When testing formats always use the FORMAT_FLAG
+ * macros to test for individual features - future versions of the library may
+ * add new flags.
+ *
+ * When reading or writing color-mapped images the format should be set to the
+ * format of the entries in the color-map then png_image_{read,write}_colormap
+ * called to read or write the color-map and set the format correctly for the
+ * image data.  Do not set the PNG_FORMAT_FLAG_COLORMAP bit directly!
+ *
+ * NOTE: libpng can be built with particular features disabled. If you see
+ * compiler errors because the definition of one of the following flags has been
+ * compiled out it is because libpng does not have the required support.  It is
+ * possible, however, for the libpng configuration to enable the format on just
+ * read or just write; in that case you may see an error at run time.  You can
+ * guard against this by checking for the definition of the appropriate
+ * "_SUPPORTED" macro, one of:
+ *
+ *    PNG_SIMPLIFIED_{READ,WRITE}_{BGR,AFIRST}_SUPPORTED
+ */
+#define PNG_FORMAT_FLAG_ALPHA    0x01U /* format with an alpha channel */
+#define PNG_FORMAT_FLAG_COLOR    0x02U /* color format: otherwise grayscale */
+#define PNG_FORMAT_FLAG_LINEAR   0x04U /* 2-byte channels else 1-byte */
+#define PNG_FORMAT_FLAG_COLORMAP 0x08U /* image data is color-mapped */
+
+#ifdef PNG_FORMAT_BGR_SUPPORTED
+#  define PNG_FORMAT_FLAG_BGR    0x10U /* BGR colors, else order is RGB */
+#endif
+
+#ifdef PNG_FORMAT_AFIRST_SUPPORTED
+#  define PNG_FORMAT_FLAG_AFIRST 0x20U /* alpha channel comes first */
+#endif
+
+#define PNG_FORMAT_FLAG_ASSOCIATED_ALPHA 0x40U /* alpha channel is associated */
+
+/* Commonly used formats have predefined macros.
+ *
+ * First the single byte (sRGB) formats:
+ */
+#define PNG_FORMAT_GRAY 0
+#define PNG_FORMAT_GA   PNG_FORMAT_FLAG_ALPHA
+#define PNG_FORMAT_AG   (PNG_FORMAT_GA|PNG_FORMAT_FLAG_AFIRST)
+#define PNG_FORMAT_RGB  PNG_FORMAT_FLAG_COLOR
+#define PNG_FORMAT_BGR  (PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_BGR)
+#define PNG_FORMAT_RGBA (PNG_FORMAT_RGB|PNG_FORMAT_FLAG_ALPHA)
+#define PNG_FORMAT_ARGB (PNG_FORMAT_RGBA|PNG_FORMAT_FLAG_AFIRST)
+#define PNG_FORMAT_BGRA (PNG_FORMAT_BGR|PNG_FORMAT_FLAG_ALPHA)
+#define PNG_FORMAT_ABGR (PNG_FORMAT_BGRA|PNG_FORMAT_FLAG_AFIRST)
+
+/* Then the linear 2-byte formats.  When naming these "Y" is used to
+ * indicate a luminance (gray) channel.
+ */
+#define PNG_FORMAT_LINEAR_Y PNG_FORMAT_FLAG_LINEAR
+#define PNG_FORMAT_LINEAR_Y_ALPHA (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_ALPHA)
+#define PNG_FORMAT_LINEAR_RGB (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_COLOR)
+#define PNG_FORMAT_LINEAR_RGB_ALPHA \
+   (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_ALPHA)
+
+/* With color-mapped formats the image data is one byte for each pixel, the byte
+ * is an index into the color-map which is formatted as above.  To obtain a
+ * color-mapped format it is sufficient just to add the PNG_FOMAT_FLAG_COLORMAP
+ * to one of the above definitions, or you can use one of the definitions below.
+ */
+#define PNG_FORMAT_RGB_COLORMAP  (PNG_FORMAT_RGB|PNG_FORMAT_FLAG_COLORMAP)
+#define PNG_FORMAT_BGR_COLORMAP  (PNG_FORMAT_BGR|PNG_FORMAT_FLAG_COLORMAP)
+#define PNG_FORMAT_RGBA_COLORMAP (PNG_FORMAT_RGBA|PNG_FORMAT_FLAG_COLORMAP)
+#define PNG_FORMAT_ARGB_COLORMAP (PNG_FORMAT_ARGB|PNG_FORMAT_FLAG_COLORMAP)
+#define PNG_FORMAT_BGRA_COLORMAP (PNG_FORMAT_BGRA|PNG_FORMAT_FLAG_COLORMAP)
+#define PNG_FORMAT_ABGR_COLORMAP (PNG_FORMAT_ABGR|PNG_FORMAT_FLAG_COLORMAP)
+
+/* PNG_IMAGE macros
+ *
+ * These are convenience macros to derive information from a png_image
+ * structure.  The PNG_IMAGE_SAMPLE_ macros return values appropriate to the
+ * actual image sample values - either the entries in the color-map or the
+ * pixels in the image.  The PNG_IMAGE_PIXEL_ macros return corresponding values
+ * for the pixels and will always return 1 for color-mapped formats.  The
+ * remaining macros return information about the rows in the image and the
+ * complete image.
+ *
+ * NOTE: All the macros that take a png_image::format parameter are compile time
+ * constants if the format parameter is, itself, a constant.  Therefore these
+ * macros can be used in array declarations and case labels where required.
+ * Similarly the macros are also pre-processor constants (sizeof is not used) so
+ * they can be used in #if tests.
+ *
+ * First the information about the samples.
+ */
+#define PNG_IMAGE_SAMPLE_CHANNELS(fmt)\
+   (((fmt)&(PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_ALPHA))+1)
+   /* Return the total number of channels in a given format: 1..4 */
+
+#define PNG_IMAGE_SAMPLE_COMPONENT_SIZE(fmt)\
+   ((((fmt) & PNG_FORMAT_FLAG_LINEAR) >> 2)+1)
+   /* Return the size in bytes of a single component of a pixel or color-map
+    * entry (as appropriate) in the image: 1 or 2.
+    */
+
+#define PNG_IMAGE_SAMPLE_SIZE(fmt)\
+   (PNG_IMAGE_SAMPLE_CHANNELS(fmt) * PNG_IMAGE_SAMPLE_COMPONENT_SIZE(fmt))
+   /* This is the size of the sample data for one sample.  If the image is
+    * color-mapped it is the size of one color-map entry (and image pixels are
+    * one byte in size), otherwise it is the size of one image pixel.
+    */
+
+#define PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(fmt)\
+   (PNG_IMAGE_SAMPLE_CHANNELS(fmt) * 256)
+   /* The maximum size of the color-map required by the format expressed in a
+    * count of components.  This can be used to compile-time allocate a
+    * color-map:
+    *
+    * png_uint_16 colormap[PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(linear_fmt)];
+    *
+    * png_byte colormap[PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(sRGB_fmt)];
+    *
+    * Alternatively use the PNG_IMAGE_COLORMAP_SIZE macro below to use the
+    * information from one of the png_image_begin_read_ APIs and dynamically
+    * allocate the required memory.
+    */
+
+/* Corresponding information about the pixels */
+#define PNG_IMAGE_PIXEL_(test,fmt)\
+   (((fmt)&PNG_FORMAT_FLAG_COLORMAP)?1:test(fmt))
+
+#define PNG_IMAGE_PIXEL_CHANNELS(fmt)\
+   PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_CHANNELS,fmt)
+   /* The number of separate channels (components) in a pixel; 1 for a
+    * color-mapped image.
+    */
+
+#define PNG_IMAGE_PIXEL_COMPONENT_SIZE(fmt)\
+   PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_COMPONENT_SIZE,fmt)
+   /* The size, in bytes, of each component in a pixel; 1 for a color-mapped
+    * image.
+    */
+
+#define PNG_IMAGE_PIXEL_SIZE(fmt) PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_SIZE,fmt)
+   /* The size, in bytes, of a complete pixel; 1 for a color-mapped image. */
+
+/* Information about the whole row, or whole image */
+#define PNG_IMAGE_ROW_STRIDE(image)\
+   (PNG_IMAGE_PIXEL_CHANNELS((image).format) * (image).width)
+   /* Return the total number of components in a single row of the image; this
+    * is the minimum 'row stride', the minimum count of components between each
+    * row.  For a color-mapped image this is the minimum number of bytes in a
+    * row.
+    *
+    * WARNING: this macro overflows for some images with more than one component
+    * and very large image widths.  libpng will refuse to process an image where
+    * this macro would overflow.
+    */
+
+#define PNG_IMAGE_BUFFER_SIZE(image, row_stride)\
+   (PNG_IMAGE_PIXEL_COMPONENT_SIZE((image).format)*(image).height*(row_stride))
+   /* Return the size, in bytes, of an image buffer given a png_image and a row
+    * stride - the number of components to leave space for in each row.
+    *
+    * WARNING: this macro overflows a 32-bit integer for some large PNG images,
+    * libpng will refuse to process an image where such an overflow would occur.
+    */
+
+#define PNG_IMAGE_SIZE(image)\
+   PNG_IMAGE_BUFFER_SIZE(image, PNG_IMAGE_ROW_STRIDE(image))
+   /* Return the size, in bytes, of the image in memory given just a png_image;
+    * the row stride is the minimum stride required for the image.
+    */
+
+#define PNG_IMAGE_COLORMAP_SIZE(image)\
+   (PNG_IMAGE_SAMPLE_SIZE((image).format) * (image).colormap_entries)
+   /* Return the size, in bytes, of the color-map of this image.  If the image
+    * format is not a color-map format this will return a size sufficient for
+    * 256 entries in the given format; check PNG_FORMAT_FLAG_COLORMAP if
+    * you don't want to allocate a color-map in this case.
+    */
+
+/* PNG_IMAGE_FLAG_*
+ *
+ * Flags containing additional information about the image are held in the
+ * 'flags' field of png_image.
+ */
+#define PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB 0x01
+   /* This indicates the the RGB values of the in-memory bitmap do not
+    * correspond to the red, green and blue end-points defined by sRGB.
+    */
+
+#define PNG_IMAGE_FLAG_FAST 0x02
+   /* On write emphasise speed over compression; the resultant PNG file will be
+    * larger but will be produced significantly faster, particular for large
+    * images.  Do not use this option for images which will be distributed, only
+    * used it when producing intermediate files that will be read back in
+    * repeatedly.  For a typical 24-bit image the option will double the read
+    * speed at the cost of increasing the image size by 25%, however for many
+    * more compressible images the PNG file can be 10 times larger with only a
+    * slight speed gain.
+    */
+
+#define PNG_IMAGE_FLAG_16BIT_sRGB 0x04
+   /* On read if the image is a 16-bit per component image and there is no gAMA
+    * or sRGB chunk assume that the components are sRGB encoded.  Notice that
+    * images output by the simplified API always have gamma information; setting
+    * this flag only affects the interpretation of 16-bit images from an
+    * external source.  It is recommended that the application expose this flag
+    * to the user; the user can normally easily recognize the difference between
+    * linear and sRGB encoding.  This flag has no effect on write - the data
+    * passed to the write APIs must have the correct encoding (as defined
+    * above.)
+    *
+    * If the flag is not set (the default) input 16-bit per component data is
+    * assumed to be linear.
+    *
+    * NOTE: the flag can only be set after the png_image_begin_read_ call,
+    * because that call initializes the 'flags' field.
+    */
+
+#ifdef PNG_SIMPLIFIED_READ_SUPPORTED
+/* READ APIs
+ * ---------
+ *
+ * The png_image passed to the read APIs must have been initialized by setting
+ * the png_controlp field 'opaque' to NULL (or, safer, memset the whole thing.)
+ */
+#ifdef PNG_STDIO_SUPPORTED
+PNG_EXPORT(234, int, png_image_begin_read_from_file, (png_imagep image,
+   const char *file_name));
+   /* The named file is opened for read and the image header is filled in
+    * from the PNG header in the file.
+    */
+
+PNG_EXPORT(235, int, png_image_begin_read_from_stdio, (png_imagep image,
+   FILE* file));
+   /* The PNG header is read from the stdio FILE object. */
+#endif /* STDIO */
+
+PNG_EXPORT(236, int, png_image_begin_read_from_memory, (png_imagep image,
+   png_const_voidp memory, png_size_t size));
+   /* The PNG header is read from the given memory buffer. */
+
+PNG_EXPORT(237, int, png_image_finish_read, (png_imagep image,
+   png_const_colorp background, void *buffer, png_int_32 row_stride,
+   void *colormap));
+   /* Finish reading the image into the supplied buffer and clean up the
+    * png_image structure.
+    *
+    * row_stride is the step, in byte or 2-byte units as appropriate,
+    * between adjacent rows.  A positive stride indicates that the top-most row
+    * is first in the buffer - the normal top-down arrangement.  A negative
+    * stride indicates that the bottom-most row is first in the buffer.
+    *
+    * background need only be supplied if an alpha channel must be removed from
+    * a png_byte format and the removal is to be done by compositing on a solid
+    * color; otherwise it may be NULL and any composition will be done directly
+    * onto the buffer.  The value is an sRGB color to use for the background,
+    * for grayscale output the green channel is used.
+    *
+    * background must be supplied when an alpha channel must be removed from a
+    * single byte color-mapped output format, in other words if:
+    *
+    * 1) The original format from png_image_begin_read_from_* had
+    *    PNG_FORMAT_FLAG_ALPHA set.
+    * 2) The format set by the application does not.
+    * 3) The format set by the application has PNG_FORMAT_FLAG_COLORMAP set and
+    *    PNG_FORMAT_FLAG_LINEAR *not* set.
+    *
+    * For linear output removing the alpha channel is always done by compositing
+    * on black and background is ignored.
+    *
+    * colormap must be supplied when PNG_FORMAT_FLAG_COLORMAP is set.  It must
+    * be at least the size (in bytes) returned by PNG_IMAGE_COLORMAP_SIZE.
+    * image->colormap_entries will be updated to the actual number of entries
+    * written to the colormap; this may be less than the original value.
+    */
+
+PNG_EXPORT(238, void, png_image_free, (png_imagep image));
+   /* Free any data allocated by libpng in image->opaque, setting the pointer to
+    * NULL.  May be called at any time after the structure is initialized.
+    */
+#endif /* SIMPLIFIED_READ */
+
+#ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED
+/* WRITE APIS
+ * ----------
+ * For write you must initialize a png_image structure to describe the image to
+ * be written.  To do this use memset to set the whole structure to 0 then
+ * initialize fields describing your image.
+ *
+ * version: must be set to PNG_IMAGE_VERSION
+ * opaque: must be initialized to NULL
+ * width: image width in pixels
+ * height: image height in rows
+ * format: the format of the data (image and color-map) you wish to write
+ * flags: set to 0 unless one of the defined flags applies; set
+ *    PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB for color format images where the RGB
+ *    values do not correspond to the colors in sRGB.
+ * colormap_entries: set to the number of entries in the color-map (0 to 256)
+ */
+#ifdef PNG_SIMPLIFIED_WRITE_STDIO_SUPPORTED
+PNG_EXPORT(239, int, png_image_write_to_file, (png_imagep image,
+   const char *file, int convert_to_8bit, const void *buffer,
+   png_int_32 row_stride, const void *colormap));
+   /* Write the image to the named file. */
+
+PNG_EXPORT(240, int, png_image_write_to_stdio, (png_imagep image, FILE *file,
+   int convert_to_8_bit, const void *buffer, png_int_32 row_stride,
+   const void *colormap));
+   /* Write the image to the given (FILE*). */
+#endif /* SIMPLIFIED_WRITE_STDIO */
+
+/* With all write APIs if image is in one of the linear formats with 16-bit
+ * data then setting convert_to_8_bit will cause the output to be an 8-bit PNG
+ * gamma encoded according to the sRGB specification, otherwise a 16-bit linear
+ * encoded PNG file is written.
+ *
+ * With color-mapped data formats the colormap parameter point to a color-map
+ * with at least image->colormap_entries encoded in the specified format.  If
+ * the format is linear the written PNG color-map will be converted to sRGB
+ * regardless of the convert_to_8_bit flag.
+ *
+ * With all APIs row_stride is handled as in the read APIs - it is the spacing
+ * from one row to the next in component sized units (1 or 2 bytes) and if
+ * negative indicates a bottom-up row layout in the buffer.  If row_stride is
+ * zero, libpng will calculate it for you from the image width and number of
+ * channels.
+ *
+ * Note that the write API does not support interlacing, sub-8-bit pixels or
+ * most ancillary chunks.  If you need to write text chunks (e.g. for copyright
+ * notices) you need to use one of the other APIs.
+ */
+
+PNG_EXPORT(245, int, png_image_write_to_memory, (png_imagep image, void *memory,
+   png_alloc_size_t * PNG_RESTRICT memory_bytes, int convert_to_8_bit,
+   const void *buffer, png_int_32 row_stride, const void *colormap));
+   /* Write the image to the given memory buffer.  The function both writes the
+    * whole PNG data stream to *memory and updates *memory_bytes with the count
+    * of bytes written.
+    *
+    * 'memory' may be NULL.  In this case *memory_bytes is not read however on
+    * success the number of bytes which would have been written will still be
+    * stored in *memory_bytes.  On failure *memory_bytes will contain 0.
+    *
+    * If 'memory' is not NULL it must point to memory[*memory_bytes] of
+    * writeable memory.
+    *
+    * If the function returns success memory[*memory_bytes] (if 'memory' is not
+    * NULL) contains the written PNG data.  *memory_bytes will always be less
+    * than or equal to the original value.
+    *
+    * If the function returns false and *memory_bytes was not changed an error
+    * occured during write.  If *memory_bytes was changed, or is not 0 if
+    * 'memory' was NULL, the write would have succeeded but for the memory
+    * buffer being too small.  *memory_bytes contains the required number of
+    * bytes and will be bigger that the original value.
+    */
+
+#define png_image_write_get_memory_size(image, size, convert_to_8_bit, buffer,\
+   row_stride, colormap)\
+   png_image_write_to_memory(&(image), 0, &(size), convert_to_8_bit, buffer,\
+         row_stride, colormap)
+   /* Return the amount of memory in 'size' required to compress this image.
+    * The png_image structure 'image' must be filled in as in the above
+    * function and must not be changed before the actual write call, the buffer
+    * and all other parameters must also be identical to that in the final
+    * write call.  The 'size' variable need not be initialized.
+    *
+    * NOTE: the macro returns true/false, if false is returned 'size' will be
+    * set to zero and the write failed and probably will fail if tried again.
+    */
+
+/* You can pre-allocate the buffer by making sure it is of sufficient size
+ * regardless of the amount of compression achieved.  The buffer size will
+ * always be bigger than the original image and it will never be filled.  The
+ * following macros are provided to assist in allocating the buffer.
+ */
+#define PNG_IMAGE_DATA_SIZE(image) (PNG_IMAGE_SIZE(image)+(image).height)
+   /* The number of uncompressed bytes in the PNG byte encoding of the image;
+    * uncompressing the PNG IDAT data will give this number of bytes.
+    *
+    * NOTE: while PNG_IMAGE_SIZE cannot overflow for an image in memory this
+    * macro can because of the extra bytes used in the PNG byte encoding.  You
+    * need to avoid this macro if your image size approaches 2^30 in width or
+    * height.  The same goes for the remainder of these macros; they all produce
+    * bigger numbers than the actual in-memory image size.
+    */
+#ifndef PNG_ZLIB_MAX_SIZE
+#  define PNG_ZLIB_MAX_SIZE(b) ((b)+(((b)+7U)>>3)+(((b)+63U)>>6)+11U)
+   /* An upper bound on the number of compressed bytes given 'b' uncompressed
+    * bytes.  This is based on deflateBounds() in zlib; different
+    * implementations of zlib compression may conceivably produce more data so
+    * if your zlib implementation is not zlib itself redefine this macro
+    * appropriately.
+    */
+#endif
+
+#define PNG_IMAGE_COMPRESSED_SIZE_MAX(image)\
+   PNG_ZLIB_MAX_SIZE((png_alloc_size_t)PNG_IMAGE_DATA_SIZE(image))
+   /* An upper bound on the size of the data in the PNG IDAT chunks. */
+
+#define PNG_IMAGE_PNG_SIZE_MAX_(image, image_size)\
+   ((8U/*sig*/+25U/*IHDR*/+16U/*gAMA*/+44U/*cHRM*/+12U/*IEND*/+\
+    (((image).format&PNG_FORMAT_FLAG_COLORMAP)?/*colormap: PLTE, tRNS*/\
+    12U+3U*(image).colormap_entries/*PLTE data*/+\
+    (((image).format&PNG_FORMAT_FLAG_ALPHA)?\
+    12U/*tRNS*/+(image).colormap_entries:0U):0U)+\
+    12U)+(12U*((image_size)/PNG_ZBUF_SIZE))/*IDAT*/+(image_size))
+   /* A helper for the following macro; if your compiler cannot handle the
+    * following macro use this one with the result of
+    * PNG_IMAGE_COMPRESSED_SIZE_MAX(image) as the second argument (most
+    * compilers should handle this just fine.)
+    */
+
+#define PNG_IMAGE_PNG_SIZE_MAX(image)\
+   PNG_IMAGE_PNG_SIZE_MAX_(image, PNG_IMAGE_COMPRESSED_SIZE_MAX(image))
+   /* An upper bound on the total length of the PNG data stream for 'image'.
+    * The result is of type png_alloc_size_t, on 32-bit systems this may
+    * overflow even though PNG_IMAGE_DATA_SIZE does not overflow; the write will
+    * run out of buffer space but return a corrected size which should work.
+    */
+#endif /* SIMPLIFIED_WRITE */
+/*******************************************************************************
+ *  END OF SIMPLIFIED API
+ ******************************************************************************/
+#endif /* SIMPLIFIED_{READ|WRITE} */
+
+/*******************************************************************************
+ * Section 6: IMPLEMENTATION OPTIONS
+ *******************************************************************************
+ *
+ * Support for arbitrary implementation-specific optimizations.  The API allows
+ * particular options to be turned on or off.  'Option' is the number of the
+ * option and 'onoff' is 0 (off) or non-0 (on).  The value returned is given
+ * by the PNG_OPTION_ defines below.
+ *
+ * HARDWARE: normally hardware capabilites, such as the Intel SSE instructions,
+ *           are detected at run time, however sometimes it may be impossible
+ *           to do this in user mode, in which case it is necessary to discover
+ *           the capabilities in an OS specific way.  Such capabilities are
+ *           listed here when libpng has support for them and must be turned
+ *           ON by the application if present.
+ *
+ * SOFTWARE: sometimes software optimizations actually result in performance
+ *           decrease on some architectures or systems, or with some sets of
+ *           PNG images.  'Software' options allow such optimizations to be
+ *           selected at run time.
+ */
+#ifdef PNG_SET_OPTION_SUPPORTED
+#ifdef PNG_ARM_NEON_API_SUPPORTED
+#  define PNG_ARM_NEON   0 /* HARDWARE: ARM Neon SIMD instructions supported */
+#endif
+#define PNG_MAXIMUM_INFLATE_WINDOW 2 /* SOFTWARE: force maximum window */
+#define PNG_SKIP_sRGB_CHECK_PROFILE 4 /* SOFTWARE: Check ICC profile for sRGB */
+#ifdef PNG_MIPS_MSA_API_SUPPORTED
+#  define PNG_MIPS_MSA   6 /* HARDWARE: MIPS Msa SIMD instructions supported */
+#endif
+#define PNG_IGNORE_ADLER32 8
+#ifdef PNG_POWERPC_VSX_API_SUPPORTED
+#  define PNG_POWERPC_VSX   10 /* HARDWARE: PowerPC VSX SIMD instructions supported */
+#endif
+#define PNG_OPTION_NEXT  12 /* Next option - numbers must be even */
+
+/* Return values: NOTE: there are four values and 'off' is *not* zero */
+#define PNG_OPTION_UNSET   0 /* Unset - defaults to off */
+#define PNG_OPTION_INVALID 1 /* Option number out of range */
+#define PNG_OPTION_OFF     2
+#define PNG_OPTION_ON      3
+
+PNG_EXPORT(244, int, png_set_option, (png_structrp png_ptr, int option,
+   int onoff));
+#endif /* SET_OPTION */
+
+/*******************************************************************************
+ *  END OF HARDWARE AND SOFTWARE OPTIONS
+ ******************************************************************************/
+
+/* Maintainer: Put new public prototypes here ^, in libpng.3, in project
+ * defs, and in scripts/symbols.def.
+ */
+
+/* The last ordinal number (this is the *last* one already used; the next
+ * one to use is one more than this.)
+ */
+#ifdef PNG_EXPORT_LAST_ORDINAL
+  PNG_EXPORT_LAST_ORDINAL(249);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* PNG_VERSION_INFO_ONLY */
+/* Do not put anything past this line */
+#endif /* PNG_H */
diff --git a/engine/inc/png/pngconf.h b/engine/inc/png/pngconf.h
new file mode 100644
index 00000000..d13b13e5
--- /dev/null
+++ b/engine/inc/png/pngconf.h
@@ -0,0 +1,622 @@
+
+/* pngconf.h - machine configurable file for libpng
+ *
+ * libpng version 1.6.34, September 29, 2017
+ *
+ * Copyright (c) 1998-2002,2004,2006-2016 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * Any machine specific code is near the front of this file, so if you
+ * are configuring libpng for a machine, you may want to read the section
+ * starting here down to where it starts to typedef png_color, png_text,
+ * and png_info.
+ */
+
+#ifndef PNGCONF_H
+#define PNGCONF_H
+
+#ifndef PNG_BUILDING_SYMBOL_TABLE /* else includes may cause problems */
+
+/* From libpng 1.6.0 libpng requires an ANSI X3.159-1989 ("ISOC90") compliant C
+ * compiler for correct compilation.  The following header files are required by
+ * the standard.  If your compiler doesn't provide these header files, or they
+ * do not match the standard, you will need to provide/improve them.
+ */
+#include <limits.h>
+#include <stddef.h>
+
+/* Library header files.  These header files are all defined by ISOC90; libpng
+ * expects conformant implementations, however, an ISOC90 conformant system need
+ * not provide these header files if the functionality cannot be implemented.
+ * In this case it will be necessary to disable the relevant parts of libpng in
+ * the build of pnglibconf.h.
+ *
+ * Prior to 1.6.0 string.h was included here; the API changes in 1.6.0 to not
+ * include this unnecessary header file.
+ */
+
+#ifdef PNG_STDIO_SUPPORTED
+   /* Required for the definition of FILE: */
+#  include <stdio.h>
+#endif
+
+#ifdef PNG_SETJMP_SUPPORTED
+   /* Required for the definition of jmp_buf and the declaration of longjmp: */
+#  include <setjmp.h>
+#endif
+
+#ifdef PNG_CONVERT_tIME_SUPPORTED
+   /* Required for struct tm: */
+#  include <time.h>
+#endif
+
+#endif /* PNG_BUILDING_SYMBOL_TABLE */
+
+/* Prior to 1.6.0 it was possible to turn off 'const' in declarations using
+ * PNG_NO_CONST; this is no longer supported except for data declarations which
+ * apparently still cause problems in 2011 on some compilers.
+ */
+#define PNG_CONST const /* backward compatibility only */
+
+/* This controls optimization of the reading of 16-bit and 32-bit values
+ * from PNG files.  It can be set on a per-app-file basis - it
+ * just changes whether a macro is used when the function is called.
+ * The library builder sets the default; if read functions are not
+ * built into the library the macro implementation is forced on.
+ */
+#ifndef PNG_READ_INT_FUNCTIONS_SUPPORTED
+#  define PNG_USE_READ_MACROS
+#endif
+#if !defined(PNG_NO_USE_READ_MACROS) && !defined(PNG_USE_READ_MACROS)
+#  if PNG_DEFAULT_READ_MACROS
+#    define PNG_USE_READ_MACROS
+#  endif
+#endif
+
+/* COMPILER SPECIFIC OPTIONS.
+ *
+ * These options are provided so that a variety of difficult compilers
+ * can be used.  Some are fixed at build time (e.g. PNG_API_RULE
+ * below) but still have compiler specific implementations, others
+ * may be changed on a per-file basis when compiling against libpng.
+ */
+
+/* The PNGARG macro was used in versions of libpng prior to 1.6.0 to protect
+ * against legacy (pre ISOC90) compilers that did not understand function
+ * prototypes.  It is not required for modern C compilers.
+ */
+#ifndef PNGARG
+#  define PNGARG(arglist) arglist
+#endif
+
+/* Function calling conventions.
+ * =============================
+ * Normally it is not necessary to specify to the compiler how to call
+ * a function - it just does it - however on x86 systems derived from
+ * Microsoft and Borland C compilers ('IBM PC', 'DOS', 'Windows' systems
+ * and some others) there are multiple ways to call a function and the
+ * default can be changed on the compiler command line.  For this reason
+ * libpng specifies the calling convention of every exported function and
+ * every function called via a user supplied function pointer.  This is
+ * done in this file by defining the following macros:
+ *
+ * PNGAPI    Calling convention for exported functions.
+ * PNGCBAPI  Calling convention for user provided (callback) functions.
+ * PNGCAPI   Calling convention used by the ANSI-C library (required
+ *           for longjmp callbacks and sometimes used internally to
+ *           specify the calling convention for zlib).
+ *
+ * These macros should never be overridden.  If it is necessary to
+ * change calling convention in a private build this can be done
+ * by setting PNG_API_RULE (which defaults to 0) to one of the values
+ * below to select the correct 'API' variants.
+ *
+ * PNG_API_RULE=0 Use PNGCAPI - the 'C' calling convention - throughout.
+ *                This is correct in every known environment.
+ * PNG_API_RULE=1 Use the operating system convention for PNGAPI and
+ *                the 'C' calling convention (from PNGCAPI) for
+ *                callbacks (PNGCBAPI).  This is no longer required
+ *                in any known environment - if it has to be used
+ *                please post an explanation of the problem to the
+ *                libpng mailing list.
+ *
+ * These cases only differ if the operating system does not use the C
+ * calling convention, at present this just means the above cases
+ * (x86 DOS/Windows sytems) and, even then, this does not apply to
+ * Cygwin running on those systems.
+ *
+ * Note that the value must be defined in pnglibconf.h so that what
+ * the application uses to call the library matches the conventions
+ * set when building the library.
+ */
+
+/* Symbol export
+ * =============
+ * When building a shared library it is almost always necessary to tell
+ * the compiler which symbols to export.  The png.h macro 'PNG_EXPORT'
+ * is used to mark the symbols.  On some systems these symbols can be
+ * extracted at link time and need no special processing by the compiler,
+ * on other systems the symbols are flagged by the compiler and just
+ * the declaration requires a special tag applied (unfortunately) in a
+ * compiler dependent way.  Some systems can do either.
+ *
+ * A small number of older systems also require a symbol from a DLL to
+ * be flagged to the program that calls it.  This is a problem because
+ * we do not know in the header file included by application code that
+ * the symbol will come from a shared library, as opposed to a statically
+ * linked one.  For this reason the application must tell us by setting
+ * the magic flag PNG_USE_DLL to turn on the special processing before
+ * it includes png.h.
+ *
+ * Four additional macros are used to make this happen:
+ *
+ * PNG_IMPEXP The magic (if any) to cause a symbol to be exported from
+ *            the build or imported if PNG_USE_DLL is set - compiler
+ *            and system specific.
+ *
+ * PNG_EXPORT_TYPE(type) A macro that pre or appends PNG_IMPEXP to
+ *                       'type', compiler specific.
+ *
+ * PNG_DLL_EXPORT Set to the magic to use during a libpng build to
+ *                make a symbol exported from the DLL.  Not used in the
+ *                public header files; see pngpriv.h for how it is used
+ *                in the libpng build.
+ *
+ * PNG_DLL_IMPORT Set to the magic to force the libpng symbols to come
+ *                from a DLL - used to define PNG_IMPEXP when
+ *                PNG_USE_DLL is set.
+ */
+
+/* System specific discovery.
+ * ==========================
+ * This code is used at build time to find PNG_IMPEXP, the API settings
+ * and PNG_EXPORT_TYPE(), it may also set a macro to indicate the DLL
+ * import processing is possible.  On Windows systems it also sets
+ * compiler-specific macros to the values required to change the calling
+ * conventions of the various functions.
+ */
+#if defined(_Windows) || defined(_WINDOWS) || defined(WIN32) ||\
+    defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+  /* Windows system (DOS doesn't support DLLs).  Includes builds under Cygwin or
+   * MinGW on any architecture currently supported by Windows.  Also includes
+   * Watcom builds but these need special treatment because they are not
+   * compatible with GCC or Visual C because of different calling conventions.
+   */
+#  if PNG_API_RULE == 2
+   /* If this line results in an error, either because __watcall is not
+    * understood or because of a redefine just below you cannot use *this*
+    * build of the library with the compiler you are using.  *This* build was
+    * build using Watcom and applications must also be built using Watcom!
+    */
+#    define PNGCAPI __watcall
+#  endif
+
+#  if defined(__GNUC__) || (defined(_MSC_VER) && (_MSC_VER >= 800))
+#    define PNGCAPI __cdecl
+#    if PNG_API_RULE == 1
+   /* If this line results in an error __stdcall is not understood and
+    * PNG_API_RULE should not have been set to '1'.
+    */
+#      define PNGAPI __stdcall
+#    endif
+#  else
+   /* An older compiler, or one not detected (erroneously) above,
+    * if necessary override on the command line to get the correct
+    * variants for the compiler.
+    */
+#    ifndef PNGCAPI
+#      define PNGCAPI _cdecl
+#    endif
+#    if PNG_API_RULE == 1 && !defined(PNGAPI)
+#      define PNGAPI _stdcall
+#    endif
+#  endif /* compiler/api */
+
+  /* NOTE: PNGCBAPI always defaults to PNGCAPI. */
+
+#  if defined(PNGAPI) && !defined(PNG_USER_PRIVATEBUILD)
+#     error "PNG_USER_PRIVATEBUILD must be defined if PNGAPI is changed"
+#  endif
+
+#  if (defined(_MSC_VER) && _MSC_VER < 800) ||\
+      (defined(__BORLANDC__) && __BORLANDC__ < 0x500)
+   /* older Borland and MSC
+    * compilers used '__export' and required this to be after
+    * the type.
+    */
+#    ifndef PNG_EXPORT_TYPE
+#      define PNG_EXPORT_TYPE(type) type PNG_IMPEXP
+#    endif
+#    define PNG_DLL_EXPORT __export
+#  else /* newer compiler */
+#    define PNG_DLL_EXPORT __declspec(dllexport)
+#    ifndef PNG_DLL_IMPORT
+#      define PNG_DLL_IMPORT __declspec(dllimport)
+#    endif
+#  endif /* compiler */
+
+#else /* !Windows */
+#  if (defined(__IBMC__) || defined(__IBMCPP__)) && defined(__OS2__)
+#    define PNGAPI _System
+#  else /* !Windows/x86 && !OS/2 */
+   /* Use the defaults, or define PNG*API on the command line (but
+    * this will have to be done for every compile!)
+    */
+#  endif /* other system, !OS/2 */
+#endif /* !Windows/x86 */
+
+/* Now do all the defaulting . */
+#ifndef PNGCAPI
+#  define PNGCAPI
+#endif
+#ifndef PNGCBAPI
+#  define PNGCBAPI PNGCAPI
+#endif
+#ifndef PNGAPI
+#  define PNGAPI PNGCAPI
+#endif
+
+/* PNG_IMPEXP may be set on the compilation system command line or (if not set)
+ * then in an internal header file when building the library, otherwise (when
+ * using the library) it is set here.
+ */
+#ifndef PNG_IMPEXP
+#  if defined(PNG_USE_DLL) && defined(PNG_DLL_IMPORT)
+   /* This forces use of a DLL, disallowing static linking */
+#    define PNG_IMPEXP PNG_DLL_IMPORT
+#  endif
+
+#  ifndef PNG_IMPEXP
+#    define PNG_IMPEXP
+#  endif
+#endif
+
+/* In 1.5.2 the definition of PNG_FUNCTION has been changed to always treat
+ * 'attributes' as a storage class - the attributes go at the start of the
+ * function definition, and attributes are always appended regardless of the
+ * compiler.  This considerably simplifies these macros but may cause problems
+ * if any compilers both need function attributes and fail to handle them as
+ * a storage class (this is unlikely.)
+ */
+#ifndef PNG_FUNCTION
+#  define PNG_FUNCTION(type, name, args, attributes) attributes type name args
+#endif
+
+#ifndef PNG_EXPORT_TYPE
+#  define PNG_EXPORT_TYPE(type) PNG_IMPEXP type
+#endif
+
+   /* The ordinal value is only relevant when preprocessing png.h for symbol
+    * table entries, so we discard it here.  See the .dfn files in the
+    * scripts directory.
+    */
+
+#ifndef PNG_EXPORTA
+#  define PNG_EXPORTA(ordinal, type, name, args, attributes) \
+      PNG_FUNCTION(PNG_EXPORT_TYPE(type), (PNGAPI name), PNGARG(args), \
+      PNG_LINKAGE_API attributes)
+#endif
+
+/* ANSI-C (C90) does not permit a macro to be invoked with an empty argument,
+ * so make something non-empty to satisfy the requirement:
+ */
+#define PNG_EMPTY /*empty list*/
+
+#define PNG_EXPORT(ordinal, type, name, args) \
+   PNG_EXPORTA(ordinal, type, name, args, PNG_EMPTY)
+
+/* Use PNG_REMOVED to comment out a removed interface. */
+#ifndef PNG_REMOVED
+#  define PNG_REMOVED(ordinal, type, name, args, attributes)
+#endif
+
+#ifndef PNG_CALLBACK
+#  define PNG_CALLBACK(type, name, args) type (PNGCBAPI name) PNGARG(args)
+#endif
+
+/* Support for compiler specific function attributes.  These are used
+ * so that where compiler support is available incorrect use of API
+ * functions in png.h will generate compiler warnings.
+ *
+ * Added at libpng-1.2.41.
+ */
+
+#ifndef PNG_NO_PEDANTIC_WARNINGS
+#  ifndef PNG_PEDANTIC_WARNINGS_SUPPORTED
+#    define PNG_PEDANTIC_WARNINGS_SUPPORTED
+#  endif
+#endif
+
+#ifdef PNG_PEDANTIC_WARNINGS_SUPPORTED
+  /* Support for compiler specific function attributes.  These are used
+   * so that where compiler support is available, incorrect use of API
+   * functions in png.h will generate compiler warnings.  Added at libpng
+   * version 1.2.41.  Disabling these removes the warnings but may also produce
+   * less efficient code.
+   */
+#  if defined(__clang__) && defined(__has_attribute)
+   /* Clang defines both __clang__ and __GNUC__. Check __clang__ first. */
+#    if !defined(PNG_USE_RESULT) && __has_attribute(__warn_unused_result__)
+#      define PNG_USE_RESULT __attribute__((__warn_unused_result__))
+#    endif
+#    if !defined(PNG_NORETURN) && __has_attribute(__noreturn__)
+#      define PNG_NORETURN __attribute__((__noreturn__))
+#    endif
+#    if !defined(PNG_ALLOCATED) && __has_attribute(__malloc__)
+#      define PNG_ALLOCATED __attribute__((__malloc__))
+#    endif
+#    if !defined(PNG_DEPRECATED) && __has_attribute(__deprecated__)
+#      define PNG_DEPRECATED __attribute__((__deprecated__))
+#    endif
+#    if !defined(PNG_PRIVATE)
+#      ifdef __has_extension
+#        if __has_extension(attribute_unavailable_with_message)
+#          define PNG_PRIVATE __attribute__((__unavailable__(\
+             "This function is not exported by libpng.")))
+#        endif
+#      endif
+#    endif
+#    ifndef PNG_RESTRICT
+#      define PNG_RESTRICT __restrict
+#    endif
+
+#  elif defined(__GNUC__)
+#    ifndef PNG_USE_RESULT
+#      define PNG_USE_RESULT __attribute__((__warn_unused_result__))
+#    endif
+#    ifndef PNG_NORETURN
+#      define PNG_NORETURN   __attribute__((__noreturn__))
+#    endif
+#    if __GNUC__ >= 3
+#      ifndef PNG_ALLOCATED
+#        define PNG_ALLOCATED  __attribute__((__malloc__))
+#      endif
+#      ifndef PNG_DEPRECATED
+#        define PNG_DEPRECATED __attribute__((__deprecated__))
+#      endif
+#      ifndef PNG_PRIVATE
+#        if 0 /* Doesn't work so we use deprecated instead*/
+#          define PNG_PRIVATE \
+            __attribute__((warning("This function is not exported by libpng.")))
+#        else
+#          define PNG_PRIVATE \
+            __attribute__((__deprecated__))
+#        endif
+#      endif
+#      if ((__GNUC__ > 3) || !defined(__GNUC_MINOR__) || (__GNUC_MINOR__ >= 1))
+#        ifndef PNG_RESTRICT
+#          define PNG_RESTRICT __restrict
+#        endif
+#      endif /* __GNUC__.__GNUC_MINOR__ > 3.0 */
+#    endif /* __GNUC__ >= 3 */
+
+#  elif defined(_MSC_VER)  && (_MSC_VER >= 1300)
+#    ifndef PNG_USE_RESULT
+#      define PNG_USE_RESULT /* not supported */
+#    endif
+#    ifndef PNG_NORETURN
+#      define PNG_NORETURN   __declspec(noreturn)
+#    endif
+#    ifndef PNG_ALLOCATED
+#      if (_MSC_VER >= 1400)
+#        define PNG_ALLOCATED __declspec(restrict)
+#      endif
+#    endif
+#    ifndef PNG_DEPRECATED
+#      define PNG_DEPRECATED __declspec(deprecated)
+#    endif
+#    ifndef PNG_PRIVATE
+#      define PNG_PRIVATE __declspec(deprecated)
+#    endif
+#    ifndef PNG_RESTRICT
+#      if (_MSC_VER >= 1400)
+#        define PNG_RESTRICT __restrict
+#      endif
+#    endif
+
+#  elif defined(__WATCOMC__)
+#    ifndef PNG_RESTRICT
+#      define PNG_RESTRICT __restrict
+#    endif
+#  endif
+#endif /* PNG_PEDANTIC_WARNINGS */
+
+#ifndef PNG_DEPRECATED
+#  define PNG_DEPRECATED  /* Use of this function is deprecated */
+#endif
+#ifndef PNG_USE_RESULT
+#  define PNG_USE_RESULT  /* The result of this function must be checked */
+#endif
+#ifndef PNG_NORETURN
+#  define PNG_NORETURN    /* This function does not return */
+#endif
+#ifndef PNG_ALLOCATED
+#  define PNG_ALLOCATED   /* The result of the function is new memory */
+#endif
+#ifndef PNG_PRIVATE
+#  define PNG_PRIVATE     /* This is a private libpng function */
+#endif
+#ifndef PNG_RESTRICT
+#  define PNG_RESTRICT    /* The C99 "restrict" feature */
+#endif
+
+#ifndef PNG_FP_EXPORT     /* A floating point API. */
+#  ifdef PNG_FLOATING_POINT_SUPPORTED
+#     define PNG_FP_EXPORT(ordinal, type, name, args)\
+         PNG_EXPORT(ordinal, type, name, args);
+#  else                   /* No floating point APIs */
+#     define PNG_FP_EXPORT(ordinal, type, name, args)
+#  endif
+#endif
+#ifndef PNG_FIXED_EXPORT  /* A fixed point API. */
+#  ifdef PNG_FIXED_POINT_SUPPORTED
+#     define PNG_FIXED_EXPORT(ordinal, type, name, args)\
+         PNG_EXPORT(ordinal, type, name, args);
+#  else                   /* No fixed point APIs */
+#     define PNG_FIXED_EXPORT(ordinal, type, name, args)
+#  endif
+#endif
+
+#ifndef PNG_BUILDING_SYMBOL_TABLE
+/* Some typedefs to get us started.  These should be safe on most of the common
+ * platforms.
+ *
+ * png_uint_32 and png_int_32 may, currently, be larger than required to hold a
+ * 32-bit value however this is not normally advisable.
+ *
+ * png_uint_16 and png_int_16 should always be two bytes in size - this is
+ * verified at library build time.
+ *
+ * png_byte must always be one byte in size.
+ *
+ * The checks below use constants from limits.h, as defined by the ISOC90
+ * standard.
+ */
+#if CHAR_BIT == 8 && UCHAR_MAX == 255
+   typedef unsigned char png_byte;
+#else
+#  error "libpng requires 8-bit bytes"
+#endif
+
+#if INT_MIN == -32768 && INT_MAX == 32767
+   typedef int png_int_16;
+#elif SHRT_MIN == -32768 && SHRT_MAX == 32767
+   typedef short png_int_16;
+#else
+#  error "libpng requires a signed 16-bit type"
+#endif
+
+#if UINT_MAX == 65535
+   typedef unsigned int png_uint_16;
+#elif USHRT_MAX == 65535
+   typedef unsigned short png_uint_16;
+#else
+#  error "libpng requires an unsigned 16-bit type"
+#endif
+
+#if INT_MIN < -2147483646 && INT_MAX > 2147483646
+   typedef int png_int_32;
+#elif LONG_MIN < -2147483646 && LONG_MAX > 2147483646
+   typedef long int png_int_32;
+#else
+#  error "libpng requires a signed 32-bit (or more) type"
+#endif
+
+#if UINT_MAX > 4294967294U
+   typedef unsigned int png_uint_32;
+#elif ULONG_MAX > 4294967294U
+   typedef unsigned long int png_uint_32;
+#else
+#  error "libpng requires an unsigned 32-bit (or more) type"
+#endif
+
+/* Prior to 1.6.0 it was possible to disable the use of size_t, 1.6.0, however,
+ * requires an ISOC90 compiler and relies on consistent behavior of sizeof.
+ */
+typedef size_t png_size_t;
+typedef ptrdiff_t png_ptrdiff_t;
+
+/* libpng needs to know the maximum value of 'size_t' and this controls the
+ * definition of png_alloc_size_t, below.  This maximum value of size_t limits
+ * but does not control the maximum allocations the library makes - there is
+ * direct application control of this through png_set_user_limits().
+ */
+#ifndef PNG_SMALL_SIZE_T
+   /* Compiler specific tests for systems where size_t is known to be less than
+    * 32 bits (some of these systems may no longer work because of the lack of
+    * 'far' support; see above.)
+    */
+#  if (defined(__TURBOC__) && !defined(__FLAT__)) ||\
+   (defined(_MSC_VER) && defined(MAXSEG_64K))
+#     define PNG_SMALL_SIZE_T
+#  endif
+#endif
+
+/* png_alloc_size_t is guaranteed to be no smaller than png_size_t, and no
+ * smaller than png_uint_32.  Casts from png_size_t or png_uint_32 to
+ * png_alloc_size_t are not necessary; in fact, it is recommended not to use
+ * them at all so that the compiler can complain when something turns out to be
+ * problematic.
+ *
+ * Casts in the other direction (from png_alloc_size_t to png_size_t or
+ * png_uint_32) should be explicitly applied; however, we do not expect to
+ * encounter practical situations that require such conversions.
+ *
+ * PNG_SMALL_SIZE_T must be defined if the maximum value of size_t is less than
+ * 4294967295 - i.e. less than the maximum value of png_uint_32.
+ */
+#ifdef PNG_SMALL_SIZE_T
+   typedef png_uint_32 png_alloc_size_t;
+#else
+   typedef png_size_t png_alloc_size_t;
+#endif
+
+/* Prior to 1.6.0 libpng offered limited support for Microsoft C compiler
+ * implementations of Intel CPU specific support of user-mode segmented address
+ * spaces, where 16-bit pointers address more than 65536 bytes of memory using
+ * separate 'segment' registers.  The implementation requires two different
+ * types of pointer (only one of which includes the segment value.)
+ *
+ * If required this support is available in version 1.2 of libpng and may be
+ * available in versions through 1.5, although the correctness of the code has
+ * not been verified recently.
+ */
+
+/* Typedef for floating-point numbers that are converted to fixed-point with a
+ * multiple of 100,000, e.g., gamma
+ */
+typedef png_int_32 png_fixed_point;
+
+/* Add typedefs for pointers */
+typedef void                  * png_voidp;
+typedef const void            * png_const_voidp;
+typedef png_byte              * png_bytep;
+typedef const png_byte        * png_const_bytep;
+typedef png_uint_32           * png_uint_32p;
+typedef const png_uint_32     * png_const_uint_32p;
+typedef png_int_32            * png_int_32p;
+typedef const png_int_32      * png_const_int_32p;
+typedef png_uint_16           * png_uint_16p;
+typedef const png_uint_16     * png_const_uint_16p;
+typedef png_int_16            * png_int_16p;
+typedef const png_int_16      * png_const_int_16p;
+typedef char                  * png_charp;
+typedef const char            * png_const_charp;
+typedef png_fixed_point       * png_fixed_point_p;
+typedef const png_fixed_point * png_const_fixed_point_p;
+typedef png_size_t            * png_size_tp;
+typedef const png_size_t      * png_const_size_tp;
+
+#ifdef PNG_STDIO_SUPPORTED
+typedef FILE            * png_FILE_p;
+#endif
+
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+typedef double       * png_doublep;
+typedef const double * png_const_doublep;
+#endif
+
+/* Pointers to pointers; i.e. arrays */
+typedef png_byte        * * png_bytepp;
+typedef png_uint_32     * * png_uint_32pp;
+typedef png_int_32      * * png_int_32pp;
+typedef png_uint_16     * * png_uint_16pp;
+typedef png_int_16      * * png_int_16pp;
+typedef const char      * * png_const_charpp;
+typedef char            * * png_charpp;
+typedef png_fixed_point * * png_fixed_point_pp;
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+typedef double          * * png_doublepp;
+#endif
+
+/* Pointers to pointers to pointers; i.e., pointer to array */
+typedef char            * * * png_charppp;
+
+#endif /* PNG_BUILDING_SYMBOL_TABLE */
+
+#endif /* PNGCONF_H */
diff --git a/engine/inc/png/pnglibconf.h b/engine/inc/png/pnglibconf.h
new file mode 100644
index 00000000..cb4ea9e2
--- /dev/null
+++ b/engine/inc/png/pnglibconf.h
@@ -0,0 +1,218 @@
+/* pnglibconf.h - library build configuration */
+
+/* libpng version 1.6.34, September 29, 2017 */
+
+/* Copyright (c) 1998-2017 Glenn Randers-Pehrson */
+
+/* This code is released under the libpng license. */
+/* For conditions of distribution and use, see the disclaimer */
+/* and license in png.h */
+
+/* pnglibconf.h */
+/* Machine generated file: DO NOT EDIT */
+/* Derived from: scripts/pnglibconf.dfa */
+#ifndef PNGLCONF_H
+#define PNGLCONF_H
+/* options */
+#define PNG_16BIT_SUPPORTED
+#define PNG_ALIGNED_MEMORY_SUPPORTED
+/*#undef PNG_ARM_NEON_API_SUPPORTED*/
+/*#undef PNG_ARM_NEON_CHECK_SUPPORTED*/
+#define PNG_BENIGN_ERRORS_SUPPORTED
+#define PNG_BENIGN_READ_ERRORS_SUPPORTED
+/*#undef PNG_BENIGN_WRITE_ERRORS_SUPPORTED*/
+#define PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED
+#define PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
+#define PNG_COLORSPACE_SUPPORTED
+#define PNG_CONSOLE_IO_SUPPORTED
+#define PNG_CONVERT_tIME_SUPPORTED
+#define PNG_EASY_ACCESS_SUPPORTED
+/*#undef PNG_ERROR_NUMBERS_SUPPORTED*/
+#define PNG_ERROR_TEXT_SUPPORTED
+#define PNG_FIXED_POINT_SUPPORTED
+#define PNG_FLOATING_ARITHMETIC_SUPPORTED
+#define PNG_FLOATING_POINT_SUPPORTED
+#define PNG_FORMAT_AFIRST_SUPPORTED
+#define PNG_FORMAT_BGR_SUPPORTED
+#define PNG_GAMMA_SUPPORTED
+#define PNG_GET_PALETTE_MAX_SUPPORTED
+#define PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+#define PNG_INCH_CONVERSIONS_SUPPORTED
+#define PNG_INFO_IMAGE_SUPPORTED
+#define PNG_IO_STATE_SUPPORTED
+#define PNG_MNG_FEATURES_SUPPORTED
+#define PNG_POINTER_INDEXING_SUPPORTED
+/*#undef PNG_POWERPC_VSX_API_SUPPORTED*/
+/*#undef PNG_POWERPC_VSX_CHECK_SUPPORTED*/
+#define PNG_PROGRESSIVE_READ_SUPPORTED
+#define PNG_READ_16BIT_SUPPORTED
+#define PNG_READ_ALPHA_MODE_SUPPORTED
+#define PNG_READ_ANCILLARY_CHUNKS_SUPPORTED
+#define PNG_READ_BACKGROUND_SUPPORTED
+#define PNG_READ_BGR_SUPPORTED
+#define PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED
+#define PNG_READ_COMPOSITE_NODIV_SUPPORTED
+#define PNG_READ_COMPRESSED_TEXT_SUPPORTED
+#define PNG_READ_EXPAND_16_SUPPORTED
+#define PNG_READ_EXPAND_SUPPORTED
+#define PNG_READ_FILLER_SUPPORTED
+#define PNG_READ_GAMMA_SUPPORTED
+#define PNG_READ_GET_PALETTE_MAX_SUPPORTED
+#define PNG_READ_GRAY_TO_RGB_SUPPORTED
+#define PNG_READ_INTERLACING_SUPPORTED
+#define PNG_READ_INT_FUNCTIONS_SUPPORTED
+#define PNG_READ_INVERT_ALPHA_SUPPORTED
+#define PNG_READ_INVERT_SUPPORTED
+#define PNG_READ_OPT_PLTE_SUPPORTED
+#define PNG_READ_PACKSWAP_SUPPORTED
+#define PNG_READ_PACK_SUPPORTED
+#define PNG_READ_QUANTIZE_SUPPORTED
+#define PNG_READ_RGB_TO_GRAY_SUPPORTED
+#define PNG_READ_SCALE_16_TO_8_SUPPORTED
+#define PNG_READ_SHIFT_SUPPORTED
+#define PNG_READ_STRIP_16_TO_8_SUPPORTED
+#define PNG_READ_STRIP_ALPHA_SUPPORTED
+#define PNG_READ_SUPPORTED
+#define PNG_READ_SWAP_ALPHA_SUPPORTED
+#define PNG_READ_SWAP_SUPPORTED
+#define PNG_READ_TEXT_SUPPORTED
+#define PNG_READ_TRANSFORMS_SUPPORTED
+#define PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
+#define PNG_READ_USER_CHUNKS_SUPPORTED
+#define PNG_READ_USER_TRANSFORM_SUPPORTED
+#define PNG_READ_bKGD_SUPPORTED
+#define PNG_READ_cHRM_SUPPORTED
+#define PNG_READ_eXIf_SUPPORTED
+#define PNG_READ_gAMA_SUPPORTED
+#define PNG_READ_hIST_SUPPORTED
+#define PNG_READ_iCCP_SUPPORTED
+#define PNG_READ_iTXt_SUPPORTED
+#define PNG_READ_oFFs_SUPPORTED
+#define PNG_READ_pCAL_SUPPORTED
+#define PNG_READ_pHYs_SUPPORTED
+#define PNG_READ_sBIT_SUPPORTED
+#define PNG_READ_sCAL_SUPPORTED
+#define PNG_READ_sPLT_SUPPORTED
+#define PNG_READ_sRGB_SUPPORTED
+#define PNG_READ_tEXt_SUPPORTED
+#define PNG_READ_tIME_SUPPORTED
+#define PNG_READ_tRNS_SUPPORTED
+#define PNG_READ_zTXt_SUPPORTED
+#define PNG_SAVE_INT_32_SUPPORTED
+#define PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
+#define PNG_SEQUENTIAL_READ_SUPPORTED
+#define PNG_SETJMP_SUPPORTED
+#define PNG_SET_OPTION_SUPPORTED
+#define PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
+#define PNG_SET_USER_LIMITS_SUPPORTED
+#define PNG_SIMPLIFIED_READ_AFIRST_SUPPORTED
+#define PNG_SIMPLIFIED_READ_BGR_SUPPORTED
+#define PNG_SIMPLIFIED_READ_SUPPORTED
+#define PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED
+#define PNG_SIMPLIFIED_WRITE_BGR_SUPPORTED
+#define PNG_SIMPLIFIED_WRITE_STDIO_SUPPORTED
+#define PNG_SIMPLIFIED_WRITE_SUPPORTED
+#define PNG_STDIO_SUPPORTED
+#define PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
+#define PNG_TEXT_SUPPORTED
+#define PNG_TIME_RFC1123_SUPPORTED
+#define PNG_UNKNOWN_CHUNKS_SUPPORTED
+#define PNG_USER_CHUNKS_SUPPORTED
+#define PNG_USER_LIMITS_SUPPORTED
+#define PNG_USER_MEM_SUPPORTED
+#define PNG_USER_TRANSFORM_INFO_SUPPORTED
+#define PNG_USER_TRANSFORM_PTR_SUPPORTED
+#define PNG_WARNINGS_SUPPORTED
+#define PNG_WRITE_16BIT_SUPPORTED
+#define PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED
+#define PNG_WRITE_BGR_SUPPORTED
+#define PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED
+#define PNG_WRITE_COMPRESSED_TEXT_SUPPORTED
+#define PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED
+#define PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
+#define PNG_WRITE_FILLER_SUPPORTED
+#define PNG_WRITE_FILTER_SUPPORTED
+#define PNG_WRITE_FLUSH_SUPPORTED
+#define PNG_WRITE_GET_PALETTE_MAX_SUPPORTED
+#define PNG_WRITE_INTERLACING_SUPPORTED
+#define PNG_WRITE_INT_FUNCTIONS_SUPPORTED
+#define PNG_WRITE_INVERT_ALPHA_SUPPORTED
+#define PNG_WRITE_INVERT_SUPPORTED
+#define PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
+#define PNG_WRITE_PACKSWAP_SUPPORTED
+#define PNG_WRITE_PACK_SUPPORTED
+#define PNG_WRITE_SHIFT_SUPPORTED
+#define PNG_WRITE_SUPPORTED
+#define PNG_WRITE_SWAP_ALPHA_SUPPORTED
+#define PNG_WRITE_SWAP_SUPPORTED
+#define PNG_WRITE_TEXT_SUPPORTED
+#define PNG_WRITE_TRANSFORMS_SUPPORTED
+#define PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
+#define PNG_WRITE_USER_TRANSFORM_SUPPORTED
+#define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
+#define PNG_WRITE_bKGD_SUPPORTED
+#define PNG_WRITE_cHRM_SUPPORTED
+#define PNG_WRITE_eXIf_SUPPORTED
+#define PNG_WRITE_gAMA_SUPPORTED
+#define PNG_WRITE_hIST_SUPPORTED
+#define PNG_WRITE_iCCP_SUPPORTED
+#define PNG_WRITE_iTXt_SUPPORTED
+#define PNG_WRITE_oFFs_SUPPORTED
+#define PNG_WRITE_pCAL_SUPPORTED
+#define PNG_WRITE_pHYs_SUPPORTED
+#define PNG_WRITE_sBIT_SUPPORTED
+#define PNG_WRITE_sCAL_SUPPORTED
+#define PNG_WRITE_sPLT_SUPPORTED
+#define PNG_WRITE_sRGB_SUPPORTED
+#define PNG_WRITE_tEXt_SUPPORTED
+#define PNG_WRITE_tIME_SUPPORTED
+#define PNG_WRITE_tRNS_SUPPORTED
+#define PNG_WRITE_zTXt_SUPPORTED
+#define PNG_bKGD_SUPPORTED
+#define PNG_cHRM_SUPPORTED
+#define PNG_eXIf_SUPPORTED
+#define PNG_gAMA_SUPPORTED
+#define PNG_hIST_SUPPORTED
+#define PNG_iCCP_SUPPORTED
+#define PNG_iTXt_SUPPORTED
+#define PNG_oFFs_SUPPORTED
+#define PNG_pCAL_SUPPORTED
+#define PNG_pHYs_SUPPORTED
+#define PNG_sBIT_SUPPORTED
+#define PNG_sCAL_SUPPORTED
+#define PNG_sPLT_SUPPORTED
+#define PNG_sRGB_SUPPORTED
+#define PNG_tEXt_SUPPORTED
+#define PNG_tIME_SUPPORTED
+#define PNG_tRNS_SUPPORTED
+#define PNG_zTXt_SUPPORTED
+/* end of options */
+/* settings */
+#define PNG_API_RULE 0
+#define PNG_DEFAULT_READ_MACROS 1
+#define PNG_GAMMA_THRESHOLD_FIXED 5000
+#define PNG_IDAT_READ_SIZE PNG_ZBUF_SIZE
+#define PNG_INFLATE_BUF_SIZE 1024
+#define PNG_LINKAGE_API extern
+#define PNG_LINKAGE_CALLBACK extern
+#define PNG_LINKAGE_DATA extern
+#define PNG_LINKAGE_FUNCTION extern
+#define PNG_MAX_GAMMA_8 11
+#define PNG_QUANTIZE_BLUE_BITS 5
+#define PNG_QUANTIZE_GREEN_BITS 5
+#define PNG_QUANTIZE_RED_BITS 5
+#define PNG_TEXT_Z_DEFAULT_COMPRESSION (-1)
+#define PNG_TEXT_Z_DEFAULT_STRATEGY 0
+#define PNG_USER_CHUNK_CACHE_MAX 1000
+#define PNG_USER_CHUNK_MALLOC_MAX 8000000
+#define PNG_USER_HEIGHT_MAX 1000000
+#define PNG_USER_WIDTH_MAX 1000000
+#define PNG_ZBUF_SIZE 8192
+#define PNG_ZLIB_VERNUM 0x12b0
+#define PNG_Z_DEFAULT_COMPRESSION (-1)
+#define PNG_Z_DEFAULT_NOFILTER_STRATEGY 0
+#define PNG_Z_DEFAULT_STRATEGY 1
+#define PNG_sCAL_PRECISION 5
+#define PNG_sRGB_PROFILE_CHECKS 2
+/* end of settings */
+#endif /* PNGLCONF_H */
diff --git a/engine/inc/rapidjson/allocators.h b/engine/inc/rapidjson/allocators.h
new file mode 100644
index 00000000..98affe03
--- /dev/null
+++ b/engine/inc/rapidjson/allocators.h
@@ -0,0 +1,271 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_ALLOCATORS_H_
+#define RAPIDJSON_ALLOCATORS_H_
+
+#include "rapidjson.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+// Allocator
+
+/*! \class rapidjson::Allocator
+    \brief Concept for allocating, resizing and freeing memory block.
+    
+    Note that Malloc() and Realloc() are non-static but Free() is static.
+    
+    So if an allocator need to support Free(), it needs to put its pointer in 
+    the header of memory block.
+
+\code
+concept Allocator {
+    static const bool kNeedFree;    //!< Whether this allocator needs to call Free().
+
+    // Allocate a memory block.
+    // \param size of the memory block in bytes.
+    // \returns pointer to the memory block.
+    void* Malloc(size_t size);
+
+    // Resize a memory block.
+    // \param originalPtr The pointer to current memory block. Null pointer is permitted.
+    // \param originalSize The current size in bytes. (Design issue: since some allocator may not book-keep this, explicitly pass to it can save memory.)
+    // \param newSize the new size in bytes.
+    void* Realloc(void* originalPtr, size_t originalSize, size_t newSize);
+
+    // Free a memory block.
+    // \param pointer to the memory block. Null pointer is permitted.
+    static void Free(void *ptr);
+};
+\endcode
+*/
+
+///////////////////////////////////////////////////////////////////////////////
+// CrtAllocator
+
+//! C-runtime library allocator.
+/*! This class is just wrapper for standard C library memory routines.
+    \note implements Allocator concept
+*/
+class CrtAllocator {
+public:
+    static const bool kNeedFree = true;
+    void* Malloc(size_t size) { 
+        if (size) //  behavior of malloc(0) is implementation defined.
+            return std::malloc(size);
+        else
+            return NULL; // standardize to returning NULL.
+    }
+    void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) {
+        (void)originalSize;
+        if (newSize == 0) {
+            std::free(originalPtr);
+            return NULL;
+        }
+        return std::realloc(originalPtr, newSize);
+    }
+    static void Free(void *ptr) { std::free(ptr); }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// MemoryPoolAllocator
+
+//! Default memory allocator used by the parser and DOM.
+/*! This allocator allocate memory blocks from pre-allocated memory chunks. 
+
+    It does not free memory blocks. And Realloc() only allocate new memory.
+
+    The memory chunks are allocated by BaseAllocator, which is CrtAllocator by default.
+
+    User may also supply a buffer as the first chunk.
+
+    If the user-buffer is full then additional chunks are allocated by BaseAllocator.
+
+    The user-buffer is not deallocated by this allocator.
+
+    \tparam BaseAllocator the allocator type for allocating memory chunks. Default is CrtAllocator.
+    \note implements Allocator concept
+*/
+template <typename BaseAllocator = CrtAllocator>
+class MemoryPoolAllocator {
+public:
+    static const bool kNeedFree = false;    //!< Tell users that no need to call Free() with this allocator. (concept Allocator)
+
+    //! Constructor with chunkSize.
+    /*! \param chunkSize The size of memory chunk. The default is kDefaultChunkSize.
+        \param baseAllocator The allocator for allocating memory chunks.
+    */
+    MemoryPoolAllocator(size_t chunkSize = kDefaultChunkCapacity, BaseAllocator* baseAllocator = 0) : 
+        chunkHead_(0), chunk_capacity_(chunkSize), userBuffer_(0), baseAllocator_(baseAllocator), ownBaseAllocator_(0)
+    {
+    }
+
+    //! Constructor with user-supplied buffer.
+    /*! The user buffer will be used firstly. When it is full, memory pool allocates new chunk with chunk size.
+
+        The user buffer will not be deallocated when this allocator is destructed.
+
+        \param buffer User supplied buffer.
+        \param size Size of the buffer in bytes. It must at least larger than sizeof(ChunkHeader).
+        \param chunkSize The size of memory chunk. The default is kDefaultChunkSize.
+        \param baseAllocator The allocator for allocating memory chunks.
+    */
+    MemoryPoolAllocator(void *buffer, size_t size, size_t chunkSize = kDefaultChunkCapacity, BaseAllocator* baseAllocator = 0) :
+        chunkHead_(0), chunk_capacity_(chunkSize), userBuffer_(buffer), baseAllocator_(baseAllocator), ownBaseAllocator_(0)
+    {
+        RAPIDJSON_ASSERT(buffer != 0);
+        RAPIDJSON_ASSERT(size > sizeof(ChunkHeader));
+        chunkHead_ = reinterpret_cast<ChunkHeader*>(buffer);
+        chunkHead_->capacity = size - sizeof(ChunkHeader);
+        chunkHead_->size = 0;
+        chunkHead_->next = 0;
+    }
+
+    //! Destructor.
+    /*! This deallocates all memory chunks, excluding the user-supplied buffer.
+    */
+    ~MemoryPoolAllocator() {
+        Clear();
+        RAPIDJSON_DELETE(ownBaseAllocator_);
+    }
+
+    //! Deallocates all memory chunks, excluding the user-supplied buffer.
+    void Clear() {
+        while (chunkHead_ && chunkHead_ != userBuffer_) {
+            ChunkHeader* next = chunkHead_->next;
+            baseAllocator_->Free(chunkHead_);
+            chunkHead_ = next;
+        }
+        if (chunkHead_ && chunkHead_ == userBuffer_)
+            chunkHead_->size = 0; // Clear user buffer
+    }
+
+    //! Computes the total capacity of allocated memory chunks.
+    /*! \return total capacity in bytes.
+    */
+    size_t Capacity() const {
+        size_t capacity = 0;
+        for (ChunkHeader* c = chunkHead_; c != 0; c = c->next)
+            capacity += c->capacity;
+        return capacity;
+    }
+
+    //! Computes the memory blocks allocated.
+    /*! \return total used bytes.
+    */
+    size_t Size() const {
+        size_t size = 0;
+        for (ChunkHeader* c = chunkHead_; c != 0; c = c->next)
+            size += c->size;
+        return size;
+    }
+
+    //! Allocates a memory block. (concept Allocator)
+    void* Malloc(size_t size) {
+        if (!size)
+            return NULL;
+
+        size = RAPIDJSON_ALIGN(size);
+        if (chunkHead_ == 0 || chunkHead_->size + size > chunkHead_->capacity)
+            if (!AddChunk(chunk_capacity_ > size ? chunk_capacity_ : size))
+                return NULL;
+
+        void *buffer = reinterpret_cast<char *>(chunkHead_) + RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + chunkHead_->size;
+        chunkHead_->size += size;
+        return buffer;
+    }
+
+    //! Resizes a memory block (concept Allocator)
+    void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) {
+        if (originalPtr == 0)
+            return Malloc(newSize);
+
+        if (newSize == 0)
+            return NULL;
+
+        originalSize = RAPIDJSON_ALIGN(originalSize);
+        newSize = RAPIDJSON_ALIGN(newSize);
+
+        // Do not shrink if new size is smaller than original
+        if (originalSize >= newSize)
+            return originalPtr;
+
+        // Simply expand it if it is the last allocation and there is sufficient space
+        if (originalPtr == reinterpret_cast<char *>(chunkHead_) + RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + chunkHead_->size - originalSize) {
+            size_t increment = static_cast<size_t>(newSize - originalSize);
+            if (chunkHead_->size + increment <= chunkHead_->capacity) {
+                chunkHead_->size += increment;
+                return originalPtr;
+            }
+        }
+
+        // Realloc process: allocate and copy memory, do not free original buffer.
+        if (void* newBuffer = Malloc(newSize)) {
+            if (originalSize)
+                std::memcpy(newBuffer, originalPtr, originalSize);
+            return newBuffer;
+        }
+        else
+            return NULL;
+    }
+
+    //! Frees a memory block (concept Allocator)
+    static void Free(void *ptr) { (void)ptr; } // Do nothing
+
+private:
+    //! Copy constructor is not permitted.
+    MemoryPoolAllocator(const MemoryPoolAllocator& rhs) /* = delete */;
+    //! Copy assignment operator is not permitted.
+    MemoryPoolAllocator& operator=(const MemoryPoolAllocator& rhs) /* = delete */;
+
+    //! Creates a new chunk.
+    /*! \param capacity Capacity of the chunk in bytes.
+        \return true if success.
+    */
+    bool AddChunk(size_t capacity) {
+        if (!baseAllocator_)
+            ownBaseAllocator_ = baseAllocator_ = RAPIDJSON_NEW(BaseAllocator());
+        if (ChunkHeader* chunk = reinterpret_cast<ChunkHeader*>(baseAllocator_->Malloc(RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + capacity))) {
+            chunk->capacity = capacity;
+            chunk->size = 0;
+            chunk->next = chunkHead_;
+            chunkHead_ =  chunk;
+            return true;
+        }
+        else
+            return false;
+    }
+
+    static const int kDefaultChunkCapacity = 64 * 1024; //!< Default chunk capacity.
+
+    //! Chunk header for perpending to each chunk.
+    /*! Chunks are stored as a singly linked list.
+    */
+    struct ChunkHeader {
+        size_t capacity;    //!< Capacity of the chunk in bytes (excluding the header itself).
+        size_t size;        //!< Current size of allocated memory in bytes.
+        ChunkHeader *next;  //!< Next chunk in the linked list.
+    };
+
+    ChunkHeader *chunkHead_;    //!< Head of the chunk linked-list. Only the head chunk serves allocation.
+    size_t chunk_capacity_;     //!< The minimum capacity of chunk when they are allocated.
+    void *userBuffer_;          //!< User supplied buffer.
+    BaseAllocator* baseAllocator_;  //!< base allocator for allocating memory chunks.
+    BaseAllocator* ownBaseAllocator_;   //!< base allocator created by this object.
+};
+
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_ENCODINGS_H_
diff --git a/engine/inc/rapidjson/document.h b/engine/inc/rapidjson/document.h
new file mode 100644
index 00000000..cacd425f
--- /dev/null
+++ b/engine/inc/rapidjson/document.h
@@ -0,0 +1,2575 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_DOCUMENT_H_
+#define RAPIDJSON_DOCUMENT_H_
+
+/*! \file document.h */
+
+#include "reader.h"
+#include "internal/meta.h"
+#include "internal/strfunc.h"
+#include "memorystream.h"
+#include "encodedstream.h"
+#include <new>      // placement new
+#include <limits>
+
+RAPIDJSON_DIAG_PUSH
+#ifdef _MSC_VER
+RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
+RAPIDJSON_DIAG_OFF(4244) // conversion from kXxxFlags to 'uint16_t', possible loss of data
+#endif
+
+#ifdef __clang__
+RAPIDJSON_DIAG_OFF(padded)
+RAPIDJSON_DIAG_OFF(switch-enum)
+RAPIDJSON_DIAG_OFF(c++98-compat)
+#endif
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_OFF(effc++)
+#if __GNUC__ >= 6
+RAPIDJSON_DIAG_OFF(terminate) // ignore throwing RAPIDJSON_ASSERT in RAPIDJSON_NOEXCEPT functions
+#endif
+#endif // __GNUC__
+
+#ifndef RAPIDJSON_NOMEMBERITERATORCLASS
+#include <iterator> // std::iterator, std::random_access_iterator_tag
+#endif
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+#include <utility> // std::move
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+// Forward declaration.
+template <typename Encoding, typename Allocator>
+class GenericValue;
+
+template <typename Encoding, typename Allocator, typename StackAllocator>
+class GenericDocument;
+
+//! Name-value pair in a JSON object value.
+/*!
+    This class was internal to GenericValue. It used to be a inner struct.
+    But a compiler (IBM XL C/C++ for AIX) have reported to have problem with that so it moved as a namespace scope struct.
+    https://code.google.com/p/rapidjson/issues/detail?id=64
+*/
+template <typename Encoding, typename Allocator> 
+struct GenericMember { 
+    GenericValue<Encoding, Allocator> name;     //!< name of member (must be a string)
+    GenericValue<Encoding, Allocator> value;    //!< value of member.
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// GenericMemberIterator
+
+#ifndef RAPIDJSON_NOMEMBERITERATORCLASS
+
+//! (Constant) member iterator for a JSON object value
+/*!
+    \tparam Const Is this a constant iterator?
+    \tparam Encoding    Encoding of the value. (Even non-string values need to have the same encoding in a document)
+    \tparam Allocator   Allocator type for allocating memory of object, array and string.
+
+    This class implements a Random Access Iterator for GenericMember elements
+    of a GenericValue, see ISO/IEC 14882:2003(E) C++ standard, 24.1 [lib.iterator.requirements].
+
+    \note This iterator implementation is mainly intended to avoid implicit
+        conversions from iterator values to \c NULL,
+        e.g. from GenericValue::FindMember.
+
+    \note Define \c RAPIDJSON_NOMEMBERITERATORCLASS to fall back to a
+        pointer-based implementation, if your platform doesn't provide
+        the C++ <iterator> header.
+
+    \see GenericMember, GenericValue::MemberIterator, GenericValue::ConstMemberIterator
+ */
+template <bool Const, typename Encoding, typename Allocator>
+class GenericMemberIterator
+    : public std::iterator<std::random_access_iterator_tag
+        , typename internal::MaybeAddConst<Const,GenericMember<Encoding,Allocator> >::Type> {
+
+    friend class GenericValue<Encoding,Allocator>;
+    template <bool, typename, typename> friend class GenericMemberIterator;
+
+    typedef GenericMember<Encoding,Allocator> PlainType;
+    typedef typename internal::MaybeAddConst<Const,PlainType>::Type ValueType;
+    typedef std::iterator<std::random_access_iterator_tag,ValueType> BaseType;
+
+public:
+    //! Iterator type itself
+    typedef GenericMemberIterator Iterator;
+    //! Constant iterator type
+    typedef GenericMemberIterator<true,Encoding,Allocator>  ConstIterator;
+    //! Non-constant iterator type
+    typedef GenericMemberIterator<false,Encoding,Allocator> NonConstIterator;
+
+    //! Pointer to (const) GenericMember
+    typedef typename BaseType::pointer         Pointer;
+    //! Reference to (const) GenericMember
+    typedef typename BaseType::reference       Reference;
+    //! Signed integer type (e.g. \c ptrdiff_t)
+    typedef typename BaseType::difference_type DifferenceType;
+
+    //! Default constructor (singular value)
+    /*! Creates an iterator pointing to no element.
+        \note All operations, except for comparisons, are undefined on such values.
+     */
+    GenericMemberIterator() : ptr_() {}
+
+    //! Iterator conversions to more const
+    /*!
+        \param it (Non-const) iterator to copy from
+
+        Allows the creation of an iterator from another GenericMemberIterator
+        that is "less const".  Especially, creating a non-constant iterator
+        from a constant iterator are disabled:
+        \li const -> non-const (not ok)
+        \li const -> const (ok)
+        \li non-const -> const (ok)
+        \li non-const -> non-const (ok)
+
+        \note If the \c Const template parameter is already \c false, this
+            constructor effectively defines a regular copy-constructor.
+            Otherwise, the copy constructor is implicitly defined.
+    */
+    GenericMemberIterator(const NonConstIterator & it) : ptr_(it.ptr_) {}
+    Iterator& operator=(const NonConstIterator & it) { ptr_ = it.ptr_; return *this; }
+
+    //! @name stepping
+    //@{
+    Iterator& operator++(){ ++ptr_; return *this; }
+    Iterator& operator--(){ --ptr_; return *this; }
+    Iterator  operator++(int){ Iterator old(*this); ++ptr_; return old; }
+    Iterator  operator--(int){ Iterator old(*this); --ptr_; return old; }
+    //@}
+
+    //! @name increment/decrement
+    //@{
+    Iterator operator+(DifferenceType n) const { return Iterator(ptr_+n); }
+    Iterator operator-(DifferenceType n) const { return Iterator(ptr_-n); }
+
+    Iterator& operator+=(DifferenceType n) { ptr_+=n; return *this; }
+    Iterator& operator-=(DifferenceType n) { ptr_-=n; return *this; }
+    //@}
+
+    //! @name relations
+    //@{
+    bool operator==(ConstIterator that) const { return ptr_ == that.ptr_; }
+    bool operator!=(ConstIterator that) const { return ptr_ != that.ptr_; }
+    bool operator<=(ConstIterator that) const { return ptr_ <= that.ptr_; }
+    bool operator>=(ConstIterator that) const { return ptr_ >= that.ptr_; }
+    bool operator< (ConstIterator that) const { return ptr_ < that.ptr_; }
+    bool operator> (ConstIterator that) const { return ptr_ > that.ptr_; }
+    //@}
+
+    //! @name dereference
+    //@{
+    Reference operator*() const { return *ptr_; }
+    Pointer   operator->() const { return ptr_; }
+    Reference operator[](DifferenceType n) const { return ptr_[n]; }
+    //@}
+
+    //! Distance
+    DifferenceType operator-(ConstIterator that) const { return ptr_-that.ptr_; }
+
+private:
+    //! Internal constructor from plain pointer
+    explicit GenericMemberIterator(Pointer p) : ptr_(p) {}
+
+    Pointer ptr_; //!< raw pointer
+};
+
+#else // RAPIDJSON_NOMEMBERITERATORCLASS
+
+// class-based member iterator implementation disabled, use plain pointers
+
+template <bool Const, typename Encoding, typename Allocator>
+struct GenericMemberIterator;
+
+//! non-const GenericMemberIterator
+template <typename Encoding, typename Allocator>
+struct GenericMemberIterator<false,Encoding,Allocator> {
+    //! use plain pointer as iterator type
+    typedef GenericMember<Encoding,Allocator>* Iterator;
+};
+//! const GenericMemberIterator
+template <typename Encoding, typename Allocator>
+struct GenericMemberIterator<true,Encoding,Allocator> {
+    //! use plain const pointer as iterator type
+    typedef const GenericMember<Encoding,Allocator>* Iterator;
+};
+
+#endif // RAPIDJSON_NOMEMBERITERATORCLASS
+
+///////////////////////////////////////////////////////////////////////////////
+// GenericStringRef
+
+//! Reference to a constant string (not taking a copy)
+/*!
+    \tparam CharType character type of the string
+
+    This helper class is used to automatically infer constant string
+    references for string literals, especially from \c const \b (!)
+    character arrays.
+
+    The main use is for creating JSON string values without copying the
+    source string via an \ref Allocator.  This requires that the referenced
+    string pointers have a sufficient lifetime, which exceeds the lifetime
+    of the associated GenericValue.
+
+    \b Example
+    \code
+    Value v("foo");   // ok, no need to copy & calculate length
+    const char foo[] = "foo";
+    v.SetString(foo); // ok
+
+    const char* bar = foo;
+    // Value x(bar); // not ok, can't rely on bar's lifetime
+    Value x(StringRef(bar)); // lifetime explicitly guaranteed by user
+    Value y(StringRef(bar, 3));  // ok, explicitly pass length
+    \endcode
+
+    \see StringRef, GenericValue::SetString
+*/
+template<typename CharType>
+struct GenericStringRef {
+    typedef CharType Ch; //!< character type of the string
+
+    //! Create string reference from \c const character array
+#ifndef __clang__ // -Wdocumentation
+    /*!
+        This constructor implicitly creates a constant string reference from
+        a \c const character array.  It has better performance than
+        \ref StringRef(const CharType*) by inferring the string \ref length
+        from the array length, and also supports strings containing null
+        characters.
+
+        \tparam N length of the string, automatically inferred
+
+        \param str Constant character array, lifetime assumed to be longer
+            than the use of the string in e.g. a GenericValue
+
+        \post \ref s == str
+
+        \note Constant complexity.
+        \note There is a hidden, private overload to disallow references to
+            non-const character arrays to be created via this constructor.
+            By this, e.g. function-scope arrays used to be filled via
+            \c snprintf are excluded from consideration.
+            In such cases, the referenced string should be \b copied to the
+            GenericValue instead.
+     */
+#endif
+    template<SizeType N>
+    GenericStringRef(const CharType (&str)[N]) RAPIDJSON_NOEXCEPT
+        : s(str), length(N-1) {}
+
+    //! Explicitly create string reference from \c const character pointer
+#ifndef __clang__ // -Wdocumentation
+    /*!
+        This constructor can be used to \b explicitly  create a reference to
+        a constant string pointer.
+
+        \see StringRef(const CharType*)
+
+        \param str Constant character pointer, lifetime assumed to be longer
+            than the use of the string in e.g. a GenericValue
+
+        \post \ref s == str
+
+        \note There is a hidden, private overload to disallow references to
+            non-const character arrays to be created via this constructor.
+            By this, e.g. function-scope arrays used to be filled via
+            \c snprintf are excluded from consideration.
+            In such cases, the referenced string should be \b copied to the
+            GenericValue instead.
+     */
+#endif
+    explicit GenericStringRef(const CharType* str)
+        : s(str), length(internal::StrLen(str)){ RAPIDJSON_ASSERT(s != 0); }
+
+    //! Create constant string reference from pointer and length
+#ifndef __clang__ // -Wdocumentation
+    /*! \param str constant string, lifetime assumed to be longer than the use of the string in e.g. a GenericValue
+        \param len length of the string, excluding the trailing NULL terminator
+
+        \post \ref s == str && \ref length == len
+        \note Constant complexity.
+     */
+#endif
+    GenericStringRef(const CharType* str, SizeType len)
+        : s(str), length(len) { RAPIDJSON_ASSERT(s != 0); }
+
+    GenericStringRef(const GenericStringRef& rhs) : s(rhs.s), length(rhs.length) {}
+
+    GenericStringRef& operator=(const GenericStringRef& rhs) { s = rhs.s; length = rhs.length; }
+
+    //! implicit conversion to plain CharType pointer
+    operator const Ch *() const { return s; }
+
+    const Ch* const s; //!< plain CharType pointer
+    const SizeType length; //!< length of the string (excluding the trailing NULL terminator)
+
+private:
+    //! Disallow construction from non-const array
+    template<SizeType N>
+    GenericStringRef(CharType (&str)[N]) /* = delete */;
+};
+
+//! Mark a character pointer as constant string
+/*! Mark a plain character pointer as a "string literal".  This function
+    can be used to avoid copying a character string to be referenced as a
+    value in a JSON GenericValue object, if the string's lifetime is known
+    to be valid long enough.
+    \tparam CharType Character type of the string
+    \param str Constant string, lifetime assumed to be longer than the use of the string in e.g. a GenericValue
+    \return GenericStringRef string reference object
+    \relatesalso GenericStringRef
+
+    \see GenericValue::GenericValue(StringRefType), GenericValue::operator=(StringRefType), GenericValue::SetString(StringRefType), GenericValue::PushBack(StringRefType, Allocator&), GenericValue::AddMember
+*/
+template<typename CharType>
+inline GenericStringRef<CharType> StringRef(const CharType* str) {
+    return GenericStringRef<CharType>(str, internal::StrLen(str));
+}
+
+//! Mark a character pointer as constant string
+/*! Mark a plain character pointer as a "string literal".  This function
+    can be used to avoid copying a character string to be referenced as a
+    value in a JSON GenericValue object, if the string's lifetime is known
+    to be valid long enough.
+
+    This version has better performance with supplied length, and also
+    supports string containing null characters.
+
+    \tparam CharType character type of the string
+    \param str Constant string, lifetime assumed to be longer than the use of the string in e.g. a GenericValue
+    \param length The length of source string.
+    \return GenericStringRef string reference object
+    \relatesalso GenericStringRef
+*/
+template<typename CharType>
+inline GenericStringRef<CharType> StringRef(const CharType* str, size_t length) {
+    return GenericStringRef<CharType>(str, SizeType(length));
+}
+
+#if RAPIDJSON_HAS_STDSTRING
+//! Mark a string object as constant string
+/*! Mark a string object (e.g. \c std::string) as a "string literal".
+    This function can be used to avoid copying a string to be referenced as a
+    value in a JSON GenericValue object, if the string's lifetime is known
+    to be valid long enough.
+
+    \tparam CharType character type of the string
+    \param str Constant string, lifetime assumed to be longer than the use of the string in e.g. a GenericValue
+    \return GenericStringRef string reference object
+    \relatesalso GenericStringRef
+    \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING.
+*/
+template<typename CharType>
+inline GenericStringRef<CharType> StringRef(const std::basic_string<CharType>& str) {
+    return GenericStringRef<CharType>(str.data(), SizeType(str.size()));
+}
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// GenericValue type traits
+namespace internal {
+
+template <typename T, typename Encoding = void, typename Allocator = void>
+struct IsGenericValueImpl : FalseType {};
+
+// select candidates according to nested encoding and allocator types
+template <typename T> struct IsGenericValueImpl<T, typename Void<typename T::EncodingType>::Type, typename Void<typename T::AllocatorType>::Type>
+    : IsBaseOf<GenericValue<typename T::EncodingType, typename T::AllocatorType>, T>::Type {};
+
+// helper to match arbitrary GenericValue instantiations, including derived classes
+template <typename T> struct IsGenericValue : IsGenericValueImpl<T>::Type {};
+
+} // namespace internal
+
+///////////////////////////////////////////////////////////////////////////////
+// TypeHelper
+
+namespace internal {
+
+template <typename ValueType, typename T>
+struct TypeHelper {};
+
+template<typename ValueType> 
+struct TypeHelper<ValueType, bool> {
+    static bool Is(const ValueType& v) { return v.IsBool(); }
+    static bool Get(const ValueType& v) { return v.GetBool(); }
+    static ValueType& Set(ValueType& v, bool data) { return v.SetBool(data); }
+    static ValueType& Set(ValueType& v, bool data, typename ValueType::AllocatorType&) { return v.SetBool(data); }
+};
+
+template<typename ValueType> 
+struct TypeHelper<ValueType, int> {
+    static bool Is(const ValueType& v) { return v.IsInt(); }
+    static int Get(const ValueType& v) { return v.GetInt(); }
+    static ValueType& Set(ValueType& v, int data) { return v.SetInt(data); }
+    static ValueType& Set(ValueType& v, int data, typename ValueType::AllocatorType&) { return v.SetInt(data); }
+};
+
+template<typename ValueType> 
+struct TypeHelper<ValueType, unsigned> {
+    static bool Is(const ValueType& v) { return v.IsUint(); }
+    static unsigned Get(const ValueType& v) { return v.GetUint(); }
+    static ValueType& Set(ValueType& v, unsigned data) { return v.SetUint(data); }
+    static ValueType& Set(ValueType& v, unsigned data, typename ValueType::AllocatorType&) { return v.SetUint(data); }
+};
+
+template<typename ValueType> 
+struct TypeHelper<ValueType, int64_t> {
+    static bool Is(const ValueType& v) { return v.IsInt64(); }
+    static int64_t Get(const ValueType& v) { return v.GetInt64(); }
+    static ValueType& Set(ValueType& v, int64_t data) { return v.SetInt64(data); }
+    static ValueType& Set(ValueType& v, int64_t data, typename ValueType::AllocatorType&) { return v.SetInt64(data); }
+};
+
+template<typename ValueType> 
+struct TypeHelper<ValueType, uint64_t> {
+    static bool Is(const ValueType& v) { return v.IsUint64(); }
+    static uint64_t Get(const ValueType& v) { return v.GetUint64(); }
+    static ValueType& Set(ValueType& v, uint64_t data) { return v.SetUint64(data); }
+    static ValueType& Set(ValueType& v, uint64_t data, typename ValueType::AllocatorType&) { return v.SetUint64(data); }
+};
+
+template<typename ValueType> 
+struct TypeHelper<ValueType, double> {
+    static bool Is(const ValueType& v) { return v.IsDouble(); }
+    static double Get(const ValueType& v) { return v.GetDouble(); }
+    static ValueType& Set(ValueType& v, double data) { return v.SetDouble(data); }
+    static ValueType& Set(ValueType& v, double data, typename ValueType::AllocatorType&) { return v.SetDouble(data); }
+};
+
+template<typename ValueType> 
+struct TypeHelper<ValueType, float> {
+    static bool Is(const ValueType& v) { return v.IsFloat(); }
+    static float Get(const ValueType& v) { return v.GetFloat(); }
+    static ValueType& Set(ValueType& v, float data) { return v.SetFloat(data); }
+    static ValueType& Set(ValueType& v, float data, typename ValueType::AllocatorType&) { return v.SetFloat(data); }
+};
+
+template<typename ValueType> 
+struct TypeHelper<ValueType, const typename ValueType::Ch*> {
+    typedef const typename ValueType::Ch* StringType;
+    static bool Is(const ValueType& v) { return v.IsString(); }
+    static StringType Get(const ValueType& v) { return v.GetString(); }
+    static ValueType& Set(ValueType& v, const StringType data) { return v.SetString(typename ValueType::StringRefType(data)); }
+    static ValueType& Set(ValueType& v, const StringType data, typename ValueType::AllocatorType& a) { return v.SetString(data, a); }
+};
+
+#if RAPIDJSON_HAS_STDSTRING
+template<typename ValueType> 
+struct TypeHelper<ValueType, std::basic_string<typename ValueType::Ch> > {
+    typedef std::basic_string<typename ValueType::Ch> StringType;
+    static bool Is(const ValueType& v) { return v.IsString(); }
+    static StringType Get(const ValueType& v) { return StringType(v.GetString(), v.GetStringLength()); }
+    static ValueType& Set(ValueType& v, const StringType& data, typename ValueType::AllocatorType& a) { return v.SetString(data, a); }
+};
+#endif
+
+template<typename ValueType> 
+struct TypeHelper<ValueType, typename ValueType::Array> {
+    typedef typename ValueType::Array ArrayType;
+    static bool Is(const ValueType& v) { return v.IsArray(); }
+    static ArrayType Get(ValueType& v) { return v.GetArray(); }
+    static ValueType& Set(ValueType& v, ArrayType data) { return v = data; }
+    static ValueType& Set(ValueType& v, ArrayType data, typename ValueType::AllocatorType&) { return v = data; }
+};
+
+template<typename ValueType> 
+struct TypeHelper<ValueType, typename ValueType::ConstArray> {
+    typedef typename ValueType::ConstArray ArrayType;
+    static bool Is(const ValueType& v) { return v.IsArray(); }
+    static ArrayType Get(const ValueType& v) { return v.GetArray(); }
+};
+
+template<typename ValueType> 
+struct TypeHelper<ValueType, typename ValueType::Object> {
+    typedef typename ValueType::Object ObjectType;
+    static bool Is(const ValueType& v) { return v.IsObject(); }
+    static ObjectType Get(ValueType& v) { return v.GetObject(); }
+    static ValueType& Set(ValueType& v, ObjectType data) { return v = data; }
+    static ValueType& Set(ValueType& v, ObjectType data, typename ValueType::AllocatorType&) { v = data; }
+};
+
+template<typename ValueType> 
+struct TypeHelper<ValueType, typename ValueType::ConstObject> {
+    typedef typename ValueType::ConstObject ObjectType;
+    static bool Is(const ValueType& v) { return v.IsObject(); }
+    static ObjectType Get(const ValueType& v) { return v.GetObject(); }
+};
+
+} // namespace internal
+
+// Forward declarations
+template <bool, typename> class GenericArray;
+template <bool, typename> class GenericObject;
+
+///////////////////////////////////////////////////////////////////////////////
+// GenericValue
+
+//! Represents a JSON value. Use Value for UTF8 encoding and default allocator.
+/*!
+    A JSON value can be one of 7 types. This class is a variant type supporting
+    these types.
+
+    Use the Value if UTF8 and default allocator
+
+    \tparam Encoding    Encoding of the value. (Even non-string values need to have the same encoding in a document)
+    \tparam Allocator   Allocator type for allocating memory of object, array and string.
+*/
+template <typename Encoding, typename Allocator = MemoryPoolAllocator<> > 
+class GenericValue {
+public:
+    //! Name-value pair in an object.
+    typedef GenericMember<Encoding, Allocator> Member;
+    typedef Encoding EncodingType;                  //!< Encoding type from template parameter.
+    typedef Allocator AllocatorType;                //!< Allocator type from template parameter.
+    typedef typename Encoding::Ch Ch;               //!< Character type derived from Encoding.
+    typedef GenericStringRef<Ch> StringRefType;     //!< Reference to a constant string
+    typedef typename GenericMemberIterator<false,Encoding,Allocator>::Iterator MemberIterator;  //!< Member iterator for iterating in object.
+    typedef typename GenericMemberIterator<true,Encoding,Allocator>::Iterator ConstMemberIterator;  //!< Constant member iterator for iterating in object.
+    typedef GenericValue* ValueIterator;            //!< Value iterator for iterating in array.
+    typedef const GenericValue* ConstValueIterator; //!< Constant value iterator for iterating in array.
+    typedef GenericValue<Encoding, Allocator> ValueType;    //!< Value type of itself.
+    typedef GenericArray<false, ValueType> Array;
+    typedef GenericArray<true, ValueType> ConstArray;
+    typedef GenericObject<false, ValueType> Object;
+    typedef GenericObject<true, ValueType> ConstObject;
+
+    //!@name Constructors and destructor.
+    //@{
+
+    //! Default constructor creates a null value.
+    GenericValue() RAPIDJSON_NOEXCEPT : data_() { data_.f.flags = kNullFlag; }
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+    //! Move constructor in C++11
+    GenericValue(GenericValue&& rhs) RAPIDJSON_NOEXCEPT : data_(rhs.data_) {
+        rhs.data_.f.flags = kNullFlag; // give up contents
+    }
+#endif
+
+private:
+    //! Copy constructor is not permitted.
+    GenericValue(const GenericValue& rhs);
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+    //! Moving from a GenericDocument is not permitted.
+    template <typename StackAllocator>
+    GenericValue(GenericDocument<Encoding,Allocator,StackAllocator>&& rhs);
+
+    //! Move assignment from a GenericDocument is not permitted.
+    template <typename StackAllocator>
+    GenericValue& operator=(GenericDocument<Encoding,Allocator,StackAllocator>&& rhs);
+#endif
+
+public:
+
+    //! Constructor with JSON value type.
+    /*! This creates a Value of specified type with default content.
+        \param type Type of the value.
+        \note Default content for number is zero.
+    */
+    explicit GenericValue(Type type) RAPIDJSON_NOEXCEPT : data_() {
+        static const uint16_t defaultFlags[7] = {
+            kNullFlag, kFalseFlag, kTrueFlag, kObjectFlag, kArrayFlag, kShortStringFlag,
+            kNumberAnyFlag
+        };
+        RAPIDJSON_ASSERT(type <= kNumberType);
+        data_.f.flags = defaultFlags[type];
+
+        // Use ShortString to store empty string.
+        if (type == kStringType)
+            data_.ss.SetLength(0);
+    }
+
+    //! Explicit copy constructor (with allocator)
+    /*! Creates a copy of a Value by using the given Allocator
+        \tparam SourceAllocator allocator of \c rhs
+        \param rhs Value to copy from (read-only)
+        \param allocator Allocator for allocating copied elements and buffers. Commonly use GenericDocument::GetAllocator().
+        \see CopyFrom()
+    */
+    template< typename SourceAllocator >
+    GenericValue(const GenericValue<Encoding, SourceAllocator>& rhs, Allocator & allocator);
+
+    //! Constructor for boolean value.
+    /*! \param b Boolean value
+        \note This constructor is limited to \em real boolean values and rejects
+            implicitly converted types like arbitrary pointers.  Use an explicit cast
+            to \c bool, if you want to construct a boolean JSON value in such cases.
+     */
+#ifndef RAPIDJSON_DOXYGEN_RUNNING // hide SFINAE from Doxygen
+    template <typename T>
+    explicit GenericValue(T b, RAPIDJSON_ENABLEIF((internal::IsSame<bool, T>))) RAPIDJSON_NOEXCEPT  // See #472
+#else
+    explicit GenericValue(bool b) RAPIDJSON_NOEXCEPT
+#endif
+        : data_() {
+            // safe-guard against failing SFINAE
+            RAPIDJSON_STATIC_ASSERT((internal::IsSame<bool,T>::Value));
+            data_.f.flags = b ? kTrueFlag : kFalseFlag;
+    }
+
+    //! Constructor for int value.
+    explicit GenericValue(int i) RAPIDJSON_NOEXCEPT : data_() {
+        data_.n.i64 = i;
+        data_.f.flags = (i >= 0) ? (kNumberIntFlag | kUintFlag | kUint64Flag) : kNumberIntFlag;
+    }
+
+    //! Constructor for unsigned value.
+    explicit GenericValue(unsigned u) RAPIDJSON_NOEXCEPT : data_() {
+        data_.n.u64 = u; 
+        data_.f.flags = (u & 0x80000000) ? kNumberUintFlag : (kNumberUintFlag | kIntFlag | kInt64Flag);
+    }
+
+    //! Constructor for int64_t value.
+    explicit GenericValue(int64_t i64) RAPIDJSON_NOEXCEPT : data_() {
+        data_.n.i64 = i64;
+        data_.f.flags = kNumberInt64Flag;
+        if (i64 >= 0) {
+            data_.f.flags |= kNumberUint64Flag;
+            if (!(static_cast<uint64_t>(i64) & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x00000000)))
+                data_.f.flags |= kUintFlag;
+            if (!(static_cast<uint64_t>(i64) & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000)))
+                data_.f.flags |= kIntFlag;
+        }
+        else if (i64 >= static_cast<int64_t>(RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000)))
+            data_.f.flags |= kIntFlag;
+    }
+
+    //! Constructor for uint64_t value.
+    explicit GenericValue(uint64_t u64) RAPIDJSON_NOEXCEPT : data_() {
+        data_.n.u64 = u64;
+        data_.f.flags = kNumberUint64Flag;
+        if (!(u64 & RAPIDJSON_UINT64_C2(0x80000000, 0x00000000)))
+            data_.f.flags |= kInt64Flag;
+        if (!(u64 & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x00000000)))
+            data_.f.flags |= kUintFlag;
+        if (!(u64 & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000)))
+            data_.f.flags |= kIntFlag;
+    }
+
+    //! Constructor for double value.
+    explicit GenericValue(double d) RAPIDJSON_NOEXCEPT : data_() { data_.n.d = d; data_.f.flags = kNumberDoubleFlag; }
+
+    //! Constructor for constant string (i.e. do not make a copy of string)
+    GenericValue(const Ch* s, SizeType length) RAPIDJSON_NOEXCEPT : data_() { SetStringRaw(StringRef(s, length)); }
+
+    //! Constructor for constant string (i.e. do not make a copy of string)
+    explicit GenericValue(StringRefType s) RAPIDJSON_NOEXCEPT : data_() { SetStringRaw(s); }
+
+    //! Constructor for copy-string (i.e. do make a copy of string)
+    GenericValue(const Ch* s, SizeType length, Allocator& allocator) : data_() { SetStringRaw(StringRef(s, length), allocator); }
+
+    //! Constructor for copy-string (i.e. do make a copy of string)
+    GenericValue(const Ch*s, Allocator& allocator) : data_() { SetStringRaw(StringRef(s), allocator); }
+
+#if RAPIDJSON_HAS_STDSTRING
+    //! Constructor for copy-string from a string object (i.e. do make a copy of string)
+    /*! \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING.
+     */
+    GenericValue(const std::basic_string<Ch>& s, Allocator& allocator) : data_() { SetStringRaw(StringRef(s), allocator); }
+#endif
+
+    //! Constructor for Array.
+    /*!
+        \param a An array obtained by \c GetArray().
+        \note \c Array is always pass-by-value.
+        \note the source array is moved into this value and the sourec array becomes empty.
+    */
+    GenericValue(Array a) RAPIDJSON_NOEXCEPT : data_(a.value_.data_) {
+        a.value_.data_ = Data();
+        a.value_.data_.f.flags = kArrayFlag;
+    }
+
+    //! Constructor for Object.
+    /*!
+        \param o An object obtained by \c GetObject().
+        \note \c Object is always pass-by-value.
+        \note the source object is moved into this value and the sourec object becomes empty.
+    */
+    GenericValue(Object o) RAPIDJSON_NOEXCEPT : data_(o.value_.data_) {
+        o.value_.data_ = Data();
+        o.value_.data_.f.flags = kObjectFlag;
+    }
+
+    //! Destructor.
+    /*! Need to destruct elements of array, members of object, or copy-string.
+    */
+    ~GenericValue() {
+        if (Allocator::kNeedFree) { // Shortcut by Allocator's trait
+            switch(data_.f.flags) {
+            case kArrayFlag:
+                {
+                    GenericValue* e = GetElementsPointer();
+                    for (GenericValue* v = e; v != e + data_.a.size; ++v)
+                        v->~GenericValue();
+                    Allocator::Free(e);
+                }
+                break;
+
+            case kObjectFlag:
+                for (MemberIterator m = MemberBegin(); m != MemberEnd(); ++m)
+                    m->~Member();
+                Allocator::Free(GetMembersPointer());
+                break;
+
+            case kCopyStringFlag:
+                Allocator::Free(const_cast<Ch*>(GetStringPointer()));
+                break;
+
+            default:
+                break;  // Do nothing for other types.
+            }
+        }
+    }
+
+    //@}
+
+    //!@name Assignment operators
+    //@{
+
+    //! Assignment with move semantics.
+    /*! \param rhs Source of the assignment. It will become a null value after assignment.
+    */
+    GenericValue& operator=(GenericValue& rhs) RAPIDJSON_NOEXCEPT {
+        RAPIDJSON_ASSERT(this != &rhs);
+        this->~GenericValue();
+        RawAssign(rhs);
+        return *this;
+    }
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+    //! Move assignment in C++11
+    GenericValue& operator=(GenericValue&& rhs) RAPIDJSON_NOEXCEPT {
+        return *this = rhs.Move();
+    }
+#endif
+
+    //! Assignment of constant string reference (no copy)
+    /*! \param str Constant string reference to be assigned
+        \note This overload is needed to avoid clashes with the generic primitive type assignment overload below.
+        \see GenericStringRef, operator=(T)
+    */
+    GenericValue& operator=(StringRefType str) RAPIDJSON_NOEXCEPT {
+        GenericValue s(str);
+        return *this = s;
+    }
+
+    //! Assignment with primitive types.
+    /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t
+        \param value The value to be assigned.
+
+        \note The source type \c T explicitly disallows all pointer types,
+            especially (\c const) \ref Ch*.  This helps avoiding implicitly
+            referencing character strings with insufficient lifetime, use
+            \ref SetString(const Ch*, Allocator&) (for copying) or
+            \ref StringRef() (to explicitly mark the pointer as constant) instead.
+            All other pointer types would implicitly convert to \c bool,
+            use \ref SetBool() instead.
+    */
+    template <typename T>
+    RAPIDJSON_DISABLEIF_RETURN((internal::IsPointer<T>), (GenericValue&))
+    operator=(T value) {
+        GenericValue v(value);
+        return *this = v;
+    }
+
+    //! Deep-copy assignment from Value
+    /*! Assigns a \b copy of the Value to the current Value object
+        \tparam SourceAllocator Allocator type of \c rhs
+        \param rhs Value to copy from (read-only)
+        \param allocator Allocator to use for copying
+     */
+    template <typename SourceAllocator>
+    GenericValue& CopyFrom(const GenericValue<Encoding, SourceAllocator>& rhs, Allocator& allocator) {
+        RAPIDJSON_ASSERT(static_cast<void*>(this) != static_cast<void const*>(&rhs));
+        this->~GenericValue();
+        new (this) GenericValue(rhs, allocator);
+        return *this;
+    }
+
+    //! Exchange the contents of this value with those of other.
+    /*!
+        \param other Another value.
+        \note Constant complexity.
+    */
+    GenericValue& Swap(GenericValue& other) RAPIDJSON_NOEXCEPT {
+        GenericValue temp;
+        temp.RawAssign(*this);
+        RawAssign(other);
+        other.RawAssign(temp);
+        return *this;
+    }
+
+    //! free-standing swap function helper
+    /*!
+        Helper function to enable support for common swap implementation pattern based on \c std::swap:
+        \code
+        void swap(MyClass& a, MyClass& b) {
+            using std::swap;
+            swap(a.value, b.value);
+            // ...
+        }
+        \endcode
+        \see Swap()
+     */
+    friend inline void swap(GenericValue& a, GenericValue& b) RAPIDJSON_NOEXCEPT { a.Swap(b); }
+
+    //! Prepare Value for move semantics
+    /*! \return *this */
+    GenericValue& Move() RAPIDJSON_NOEXCEPT { return *this; }
+    //@}
+
+    //!@name Equal-to and not-equal-to operators
+    //@{
+    //! Equal-to operator
+    /*!
+        \note If an object contains duplicated named member, comparing equality with any object is always \c false.
+        \note Linear time complexity (number of all values in the subtree and total lengths of all strings).
+    */
+    template <typename SourceAllocator>
+    bool operator==(const GenericValue<Encoding, SourceAllocator>& rhs) const {
+        typedef GenericValue<Encoding, SourceAllocator> RhsType;
+        if (GetType() != rhs.GetType())
+            return false;
+
+        switch (GetType()) {
+        case kObjectType: // Warning: O(n^2) inner-loop
+            if (data_.o.size != rhs.data_.o.size)
+                return false;           
+            for (ConstMemberIterator lhsMemberItr = MemberBegin(); lhsMemberItr != MemberEnd(); ++lhsMemberItr) {
+                typename RhsType::ConstMemberIterator rhsMemberItr = rhs.FindMember(lhsMemberItr->name);
+                if (rhsMemberItr == rhs.MemberEnd() || lhsMemberItr->value != rhsMemberItr->value)
+                    return false;
+            }
+            return true;
+            
+        case kArrayType:
+            if (data_.a.size != rhs.data_.a.size)
+                return false;
+            for (SizeType i = 0; i < data_.a.size; i++)
+                if ((*this)[i] != rhs[i])
+                    return false;
+            return true;
+
+        case kStringType:
+            return StringEqual(rhs);
+
+        case kNumberType:
+            if (IsDouble() || rhs.IsDouble()) {
+                double a = GetDouble();     // May convert from integer to double.
+                double b = rhs.GetDouble(); // Ditto
+                return a >= b && a <= b;    // Prevent -Wfloat-equal
+            }
+            else
+                return data_.n.u64 == rhs.data_.n.u64;
+
+        default:
+            return true;
+        }
+    }
+
+    //! Equal-to operator with const C-string pointer
+    bool operator==(const Ch* rhs) const { return *this == GenericValue(StringRef(rhs)); }
+
+#if RAPIDJSON_HAS_STDSTRING
+    //! Equal-to operator with string object
+    /*! \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING.
+     */
+    bool operator==(const std::basic_string<Ch>& rhs) const { return *this == GenericValue(StringRef(rhs)); }
+#endif
+
+    //! Equal-to operator with primitive types
+    /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c double, \c true, \c false
+    */
+    template <typename T> RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>,internal::IsGenericValue<T> >), (bool)) operator==(const T& rhs) const { return *this == GenericValue(rhs); }
+
+    //! Not-equal-to operator
+    /*! \return !(*this == rhs)
+     */
+    template <typename SourceAllocator>
+    bool operator!=(const GenericValue<Encoding, SourceAllocator>& rhs) const { return !(*this == rhs); }
+
+    //! Not-equal-to operator with const C-string pointer
+    bool operator!=(const Ch* rhs) const { return !(*this == rhs); }
+
+    //! Not-equal-to operator with arbitrary types
+    /*! \return !(*this == rhs)
+     */
+    template <typename T> RAPIDJSON_DISABLEIF_RETURN((internal::IsGenericValue<T>), (bool)) operator!=(const T& rhs) const { return !(*this == rhs); }
+
+    //! Equal-to operator with arbitrary types (symmetric version)
+    /*! \return (rhs == lhs)
+     */
+    template <typename T> friend RAPIDJSON_DISABLEIF_RETURN((internal::IsGenericValue<T>), (bool)) operator==(const T& lhs, const GenericValue& rhs) { return rhs == lhs; }
+
+    //! Not-Equal-to operator with arbitrary types (symmetric version)
+    /*! \return !(rhs == lhs)
+     */
+    template <typename T> friend RAPIDJSON_DISABLEIF_RETURN((internal::IsGenericValue<T>), (bool)) operator!=(const T& lhs, const GenericValue& rhs) { return !(rhs == lhs); }
+    //@}
+
+    //!@name Type
+    //@{
+
+    Type GetType()  const { return static_cast<Type>(data_.f.flags & kTypeMask); }
+    bool IsNull()   const { return data_.f.flags == kNullFlag; }
+    bool IsFalse()  const { return data_.f.flags == kFalseFlag; }
+    bool IsTrue()   const { return data_.f.flags == kTrueFlag; }
+    bool IsBool()   const { return (data_.f.flags & kBoolFlag) != 0; }
+    bool IsObject() const { return data_.f.flags == kObjectFlag; }
+    bool IsArray()  const { return data_.f.flags == kArrayFlag; }
+    bool IsNumber() const { return (data_.f.flags & kNumberFlag) != 0; }
+    bool IsInt()    const { return (data_.f.flags & kIntFlag) != 0; }
+    bool IsUint()   const { return (data_.f.flags & kUintFlag) != 0; }
+    bool IsInt64()  const { return (data_.f.flags & kInt64Flag) != 0; }
+    bool IsUint64() const { return (data_.f.flags & kUint64Flag) != 0; }
+    bool IsDouble() const { return (data_.f.flags & kDoubleFlag) != 0; }
+    bool IsString() const { return (data_.f.flags & kStringFlag) != 0; }
+
+    // Checks whether a number can be losslessly converted to a double.
+    bool IsLosslessDouble() const {
+        if (!IsNumber()) return false;
+        if (IsUint64()) {
+            uint64_t u = GetUint64();
+            volatile double d = static_cast<double>(u);
+            return (d >= 0.0)
+                && (d < static_cast<double>(std::numeric_limits<uint64_t>::max()))
+                && (u == static_cast<uint64_t>(d));
+        }
+        if (IsInt64()) {
+            int64_t i = GetInt64();
+            volatile double d = static_cast<double>(i);
+            return (d >= static_cast<double>(std::numeric_limits<int64_t>::min()))
+                && (d < static_cast<double>(std::numeric_limits<int64_t>::max()))
+                && (i == static_cast<int64_t>(d));
+        }
+        return true; // double, int, uint are always lossless
+    }
+
+    // Checks whether a number is a float (possible lossy).
+    bool IsFloat() const  {
+        if ((data_.f.flags & kDoubleFlag) == 0)
+            return false;
+        double d = GetDouble();
+        return d >= -3.4028234e38 && d <= 3.4028234e38;
+    }
+    // Checks whether a number can be losslessly converted to a float.
+    bool IsLosslessFloat() const {
+        if (!IsNumber()) return false;
+        double a = GetDouble();
+        if (a < static_cast<double>(-std::numeric_limits<float>::max())
+                || a > static_cast<double>(std::numeric_limits<float>::max()))
+            return false;
+        double b = static_cast<double>(static_cast<float>(a));
+        return a >= b && a <= b;    // Prevent -Wfloat-equal
+    }
+
+    //@}
+
+    //!@name Null
+    //@{
+
+    GenericValue& SetNull() { this->~GenericValue(); new (this) GenericValue(); return *this; }
+
+    //@}
+
+    //!@name Bool
+    //@{
+
+    bool GetBool() const { RAPIDJSON_ASSERT(IsBool()); return data_.f.flags == kTrueFlag; }
+    //!< Set boolean value
+    /*! \post IsBool() == true */
+    GenericValue& SetBool(bool b) { this->~GenericValue(); new (this) GenericValue(b); return *this; }
+
+    //@}
+
+    //!@name Object
+    //@{
+
+    //! Set this value as an empty object.
+    /*! \post IsObject() == true */
+    GenericValue& SetObject() { this->~GenericValue(); new (this) GenericValue(kObjectType); return *this; }
+
+    //! Get the number of members in the object.
+    SizeType MemberCount() const { RAPIDJSON_ASSERT(IsObject()); return data_.o.size; }
+
+    //! Check whether the object is empty.
+    bool ObjectEmpty() const { RAPIDJSON_ASSERT(IsObject()); return data_.o.size == 0; }
+
+    //! Get a value from an object associated with the name.
+    /*! \pre IsObject() == true
+        \tparam T Either \c Ch or \c const \c Ch (template used for disambiguation with \ref operator[](SizeType))
+        \note In version 0.1x, if the member is not found, this function returns a null value. This makes issue 7.
+        Since 0.2, if the name is not correct, it will assert.
+        If user is unsure whether a member exists, user should use HasMember() first.
+        A better approach is to use FindMember().
+        \note Linear time complexity.
+    */
+    template <typename T>
+    RAPIDJSON_DISABLEIF_RETURN((internal::NotExpr<internal::IsSame<typename internal::RemoveConst<T>::Type, Ch> >),(GenericValue&)) operator[](T* name) {
+        GenericValue n(StringRef(name));
+        return (*this)[n];
+    }
+    template <typename T>
+    RAPIDJSON_DISABLEIF_RETURN((internal::NotExpr<internal::IsSame<typename internal::RemoveConst<T>::Type, Ch> >),(const GenericValue&)) operator[](T* name) const { return const_cast<GenericValue&>(*this)[name]; }
+
+    //! Get a value from an object associated with the name.
+    /*! \pre IsObject() == true
+        \tparam SourceAllocator Allocator of the \c name value
+
+        \note Compared to \ref operator[](T*), this version is faster because it does not need a StrLen().
+        And it can also handle strings with embedded null characters.
+
+        \note Linear time complexity.
+    */
+    template <typename SourceAllocator>
+    GenericValue& operator[](const GenericValue<Encoding, SourceAllocator>& name) {
+        MemberIterator member = FindMember(name);
+        if (member != MemberEnd())
+            return member->value;
+        else {
+            RAPIDJSON_ASSERT(false);    // see above note
+
+            // This will generate -Wexit-time-destructors in clang
+            // static GenericValue NullValue;
+            // return NullValue;
+
+            // Use static buffer and placement-new to prevent destruction
+            static char buffer[sizeof(GenericValue)];
+            return *new (buffer) GenericValue();
+        }
+    }
+    template <typename SourceAllocator>
+    const GenericValue& operator[](const GenericValue<Encoding, SourceAllocator>& name) const { return const_cast<GenericValue&>(*this)[name]; }
+
+#if RAPIDJSON_HAS_STDSTRING
+    //! Get a value from an object associated with name (string object).
+    GenericValue& operator[](const std::basic_string<Ch>& name) { return (*this)[GenericValue(StringRef(name))]; }
+    const GenericValue& operator[](const std::basic_string<Ch>& name) const { return (*this)[GenericValue(StringRef(name))]; }
+#endif
+
+    //! Const member iterator
+    /*! \pre IsObject() == true */
+    ConstMemberIterator MemberBegin() const { RAPIDJSON_ASSERT(IsObject()); return ConstMemberIterator(GetMembersPointer()); }
+    //! Const \em past-the-end member iterator
+    /*! \pre IsObject() == true */
+    ConstMemberIterator MemberEnd() const   { RAPIDJSON_ASSERT(IsObject()); return ConstMemberIterator(GetMembersPointer() + data_.o.size); }
+    //! Member iterator
+    /*! \pre IsObject() == true */
+    MemberIterator MemberBegin()            { RAPIDJSON_ASSERT(IsObject()); return MemberIterator(GetMembersPointer()); }
+    //! \em Past-the-end member iterator
+    /*! \pre IsObject() == true */
+    MemberIterator MemberEnd()              { RAPIDJSON_ASSERT(IsObject()); return MemberIterator(GetMembersPointer() + data_.o.size); }
+
+    //! Check whether a member exists in the object.
+    /*!
+        \param name Member name to be searched.
+        \pre IsObject() == true
+        \return Whether a member with that name exists.
+        \note It is better to use FindMember() directly if you need the obtain the value as well.
+        \note Linear time complexity.
+    */
+    bool HasMember(const Ch* name) const { return FindMember(name) != MemberEnd(); }
+
+#if RAPIDJSON_HAS_STDSTRING
+    //! Check whether a member exists in the object with string object.
+    /*!
+        \param name Member name to be searched.
+        \pre IsObject() == true
+        \return Whether a member with that name exists.
+        \note It is better to use FindMember() directly if you need the obtain the value as well.
+        \note Linear time complexity.
+    */
+    bool HasMember(const std::basic_string<Ch>& name) const { return FindMember(name) != MemberEnd(); }
+#endif
+
+    //! Check whether a member exists in the object with GenericValue name.
+    /*!
+        This version is faster because it does not need a StrLen(). It can also handle string with null character.
+        \param name Member name to be searched.
+        \pre IsObject() == true
+        \return Whether a member with that name exists.
+        \note It is better to use FindMember() directly if you need the obtain the value as well.
+        \note Linear time complexity.
+    */
+    template <typename SourceAllocator>
+    bool HasMember(const GenericValue<Encoding, SourceAllocator>& name) const { return FindMember(name) != MemberEnd(); }
+
+    //! Find member by name.
+    /*!
+        \param name Member name to be searched.
+        \pre IsObject() == true
+        \return Iterator to member, if it exists.
+            Otherwise returns \ref MemberEnd().
+
+        \note Earlier versions of Rapidjson returned a \c NULL pointer, in case
+            the requested member doesn't exist. For consistency with e.g.
+            \c std::map, this has been changed to MemberEnd() now.
+        \note Linear time complexity.
+    */
+    MemberIterator FindMember(const Ch* name) {
+        GenericValue n(StringRef(name));
+        return FindMember(n);
+    }
+
+    ConstMemberIterator FindMember(const Ch* name) const { return const_cast<GenericValue&>(*this).FindMember(name); }
+
+    //! Find member by name.
+    /*!
+        This version is faster because it does not need a StrLen(). It can also handle string with null character.
+        \param name Member name to be searched.
+        \pre IsObject() == true
+        \return Iterator to member, if it exists.
+            Otherwise returns \ref MemberEnd().
+
+        \note Earlier versions of Rapidjson returned a \c NULL pointer, in case
+            the requested member doesn't exist. For consistency with e.g.
+            \c std::map, this has been changed to MemberEnd() now.
+        \note Linear time complexity.
+    */
+    template <typename SourceAllocator>
+    MemberIterator FindMember(const GenericValue<Encoding, SourceAllocator>& name) {
+        RAPIDJSON_ASSERT(IsObject());
+        RAPIDJSON_ASSERT(name.IsString());
+        MemberIterator member = MemberBegin();
+        for ( ; member != MemberEnd(); ++member)
+            if (name.StringEqual(member->name))
+                break;
+        return member;
+    }
+    template <typename SourceAllocator> ConstMemberIterator FindMember(const GenericValue<Encoding, SourceAllocator>& name) const { return const_cast<GenericValue&>(*this).FindMember(name); }
+
+#if RAPIDJSON_HAS_STDSTRING
+    //! Find member by string object name.
+    /*!
+        \param name Member name to be searched.
+        \pre IsObject() == true
+        \return Iterator to member, if it exists.
+            Otherwise returns \ref MemberEnd().
+    */
+    MemberIterator FindMember(const std::basic_string<Ch>& name) { return FindMember(GenericValue(StringRef(name))); }
+    ConstMemberIterator FindMember(const std::basic_string<Ch>& name) const { return FindMember(GenericValue(StringRef(name))); }
+#endif
+
+    //! Add a member (name-value pair) to the object.
+    /*! \param name A string value as name of member.
+        \param value Value of any type.
+        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
+        \return The value itself for fluent API.
+        \note The ownership of \c name and \c value will be transferred to this object on success.
+        \pre  IsObject() && name.IsString()
+        \post name.IsNull() && value.IsNull()
+        \note Amortized Constant time complexity.
+    */
+    GenericValue& AddMember(GenericValue& name, GenericValue& value, Allocator& allocator) {
+        RAPIDJSON_ASSERT(IsObject());
+        RAPIDJSON_ASSERT(name.IsString());
+
+        ObjectData& o = data_.o;
+        if (o.size >= o.capacity) {
+            if (o.capacity == 0) {
+                o.capacity = kDefaultObjectCapacity;
+                SetMembersPointer(reinterpret_cast<Member*>(allocator.Malloc(o.capacity * sizeof(Member))));
+            }
+            else {
+                SizeType oldCapacity = o.capacity;
+                o.capacity += (oldCapacity + 1) / 2; // grow by factor 1.5
+                SetMembersPointer(reinterpret_cast<Member*>(allocator.Realloc(GetMembersPointer(), oldCapacity * sizeof(Member), o.capacity * sizeof(Member))));
+            }
+        }
+        Member* members = GetMembersPointer();
+        members[o.size].name.RawAssign(name);
+        members[o.size].value.RawAssign(value);
+        o.size++;
+        return *this;
+    }
+
+    //! Add a constant string value as member (name-value pair) to the object.
+    /*! \param name A string value as name of member.
+        \param value constant string reference as value of member.
+        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
+        \return The value itself for fluent API.
+        \pre  IsObject()
+        \note This overload is needed to avoid clashes with the generic primitive type AddMember(GenericValue&,T,Allocator&) overload below.
+        \note Amortized Constant time complexity.
+    */
+    GenericValue& AddMember(GenericValue& name, StringRefType value, Allocator& allocator) {
+        GenericValue v(value);
+        return AddMember(name, v, allocator);
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    //! Add a string object as member (name-value pair) to the object.
+    /*! \param name A string value as name of member.
+        \param value constant string reference as value of member.
+        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
+        \return The value itself for fluent API.
+        \pre  IsObject()
+        \note This overload is needed to avoid clashes with the generic primitive type AddMember(GenericValue&,T,Allocator&) overload below.
+        \note Amortized Constant time complexity.
+    */
+    GenericValue& AddMember(GenericValue& name, std::basic_string<Ch>& value, Allocator& allocator) {
+        GenericValue v(value, allocator);
+        return AddMember(name, v, allocator);
+    }
+#endif
+
+    //! Add any primitive value as member (name-value pair) to the object.
+    /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t
+        \param name A string value as name of member.
+        \param value Value of primitive type \c T as value of member
+        \param allocator Allocator for reallocating memory. Commonly use GenericDocument::GetAllocator().
+        \return The value itself for fluent API.
+        \pre  IsObject()
+
+        \note The source type \c T explicitly disallows all pointer types,
+            especially (\c const) \ref Ch*.  This helps avoiding implicitly
+            referencing character strings with insufficient lifetime, use
+            \ref AddMember(StringRefType, GenericValue&, Allocator&) or \ref
+            AddMember(StringRefType, StringRefType, Allocator&).
+            All other pointer types would implicitly convert to \c bool,
+            use an explicit cast instead, if needed.
+        \note Amortized Constant time complexity.
+    */
+    template <typename T>
+    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (GenericValue&))
+    AddMember(GenericValue& name, T value, Allocator& allocator) {
+        GenericValue v(value);
+        return AddMember(name, v, allocator);
+    }
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+    GenericValue& AddMember(GenericValue&& name, GenericValue&& value, Allocator& allocator) {
+        return AddMember(name, value, allocator);
+    }
+    GenericValue& AddMember(GenericValue&& name, GenericValue& value, Allocator& allocator) {
+        return AddMember(name, value, allocator);
+    }
+    GenericValue& AddMember(GenericValue& name, GenericValue&& value, Allocator& allocator) {
+        return AddMember(name, value, allocator);
+    }
+    GenericValue& AddMember(StringRefType name, GenericValue&& value, Allocator& allocator) {
+        GenericValue n(name);
+        return AddMember(n, value, allocator);
+    }
+#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
+
+
+    //! Add a member (name-value pair) to the object.
+    /*! \param name A constant string reference as name of member.
+        \param value Value of any type.
+        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
+        \return The value itself for fluent API.
+        \note The ownership of \c value will be transferred to this object on success.
+        \pre  IsObject()
+        \post value.IsNull()
+        \note Amortized Constant time complexity.
+    */
+    GenericValue& AddMember(StringRefType name, GenericValue& value, Allocator& allocator) {
+        GenericValue n(name);
+        return AddMember(n, value, allocator);
+    }
+
+    //! Add a constant string value as member (name-value pair) to the object.
+    /*! \param name A constant string reference as name of member.
+        \param value constant string reference as value of member.
+        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
+        \return The value itself for fluent API.
+        \pre  IsObject()
+        \note This overload is needed to avoid clashes with the generic primitive type AddMember(StringRefType,T,Allocator&) overload below.
+        \note Amortized Constant time complexity.
+    */
+    GenericValue& AddMember(StringRefType name, StringRefType value, Allocator& allocator) {
+        GenericValue v(value);
+        return AddMember(name, v, allocator);
+    }
+
+    //! Add any primitive value as member (name-value pair) to the object.
+    /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t
+        \param name A constant string reference as name of member.
+        \param value Value of primitive type \c T as value of member
+        \param allocator Allocator for reallocating memory. Commonly use GenericDocument::GetAllocator().
+        \return The value itself for fluent API.
+        \pre  IsObject()
+
+        \note The source type \c T explicitly disallows all pointer types,
+            especially (\c const) \ref Ch*.  This helps avoiding implicitly
+            referencing character strings with insufficient lifetime, use
+            \ref AddMember(StringRefType, GenericValue&, Allocator&) or \ref
+            AddMember(StringRefType, StringRefType, Allocator&).
+            All other pointer types would implicitly convert to \c bool,
+            use an explicit cast instead, if needed.
+        \note Amortized Constant time complexity.
+    */
+    template <typename T>
+    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (GenericValue&))
+    AddMember(StringRefType name, T value, Allocator& allocator) {
+        GenericValue n(name);
+        return AddMember(n, value, allocator);
+    }
+
+    //! Remove all members in the object.
+    /*! This function do not deallocate memory in the object, i.e. the capacity is unchanged.
+        \note Linear time complexity.
+    */
+    void RemoveAllMembers() {
+        RAPIDJSON_ASSERT(IsObject()); 
+        for (MemberIterator m = MemberBegin(); m != MemberEnd(); ++m)
+            m->~Member();
+        data_.o.size = 0;
+    }
+
+    //! Remove a member in object by its name.
+    /*! \param name Name of member to be removed.
+        \return Whether the member existed.
+        \note This function may reorder the object members. Use \ref
+            EraseMember(ConstMemberIterator) if you need to preserve the
+            relative order of the remaining members.
+        \note Linear time complexity.
+    */
+    bool RemoveMember(const Ch* name) {
+        GenericValue n(StringRef(name));
+        return RemoveMember(n);
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    bool RemoveMember(const std::basic_string<Ch>& name) { return RemoveMember(GenericValue(StringRef(name))); }
+#endif
+
+    template <typename SourceAllocator>
+    bool RemoveMember(const GenericValue<Encoding, SourceAllocator>& name) {
+        MemberIterator m = FindMember(name);
+        if (m != MemberEnd()) {
+            RemoveMember(m);
+            return true;
+        }
+        else
+            return false;
+    }
+
+    //! Remove a member in object by iterator.
+    /*! \param m member iterator (obtained by FindMember() or MemberBegin()).
+        \return the new iterator after removal.
+        \note This function may reorder the object members. Use \ref
+            EraseMember(ConstMemberIterator) if you need to preserve the
+            relative order of the remaining members.
+        \note Constant time complexity.
+    */
+    MemberIterator RemoveMember(MemberIterator m) {
+        RAPIDJSON_ASSERT(IsObject());
+        RAPIDJSON_ASSERT(data_.o.size > 0);
+        RAPIDJSON_ASSERT(GetMembersPointer() != 0);
+        RAPIDJSON_ASSERT(m >= MemberBegin() && m < MemberEnd());
+
+        MemberIterator last(GetMembersPointer() + (data_.o.size - 1));
+        if (data_.o.size > 1 && m != last)
+            *m = *last; // Move the last one to this place
+        else
+            m->~Member(); // Only one left, just destroy
+        --data_.o.size;
+        return m;
+    }
+
+    //! Remove a member from an object by iterator.
+    /*! \param pos iterator to the member to remove
+        \pre IsObject() == true && \ref MemberBegin() <= \c pos < \ref MemberEnd()
+        \return Iterator following the removed element.
+            If the iterator \c pos refers to the last element, the \ref MemberEnd() iterator is returned.
+        \note This function preserves the relative order of the remaining object
+            members. If you do not need this, use the more efficient \ref RemoveMember(MemberIterator).
+        \note Linear time complexity.
+    */
+    MemberIterator EraseMember(ConstMemberIterator pos) {
+        return EraseMember(pos, pos +1);
+    }
+
+    //! Remove members in the range [first, last) from an object.
+    /*! \param first iterator to the first member to remove
+        \param last  iterator following the last member to remove
+        \pre IsObject() == true && \ref MemberBegin() <= \c first <= \c last <= \ref MemberEnd()
+        \return Iterator following the last removed element.
+        \note This function preserves the relative order of the remaining object
+            members.
+        \note Linear time complexity.
+    */
+    MemberIterator EraseMember(ConstMemberIterator first, ConstMemberIterator last) {
+        RAPIDJSON_ASSERT(IsObject());
+        RAPIDJSON_ASSERT(data_.o.size > 0);
+        RAPIDJSON_ASSERT(GetMembersPointer() != 0);
+        RAPIDJSON_ASSERT(first >= MemberBegin());
+        RAPIDJSON_ASSERT(first <= last);
+        RAPIDJSON_ASSERT(last <= MemberEnd());
+
+        MemberIterator pos = MemberBegin() + (first - MemberBegin());
+        for (MemberIterator itr = pos; itr != last; ++itr)
+            itr->~Member();
+        std::memmove(&*pos, &*last, static_cast<size_t>(MemberEnd() - last) * sizeof(Member));
+        data_.o.size -= static_cast<SizeType>(last - first);
+        return pos;
+    }
+
+    //! Erase a member in object by its name.
+    /*! \param name Name of member to be removed.
+        \return Whether the member existed.
+        \note Linear time complexity.
+    */
+    bool EraseMember(const Ch* name) {
+        GenericValue n(StringRef(name));
+        return EraseMember(n);
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    bool EraseMember(const std::basic_string<Ch>& name) { return EraseMember(GenericValue(StringRef(name))); }
+#endif
+
+    template <typename SourceAllocator>
+    bool EraseMember(const GenericValue<Encoding, SourceAllocator>& name) {
+        MemberIterator m = FindMember(name);
+        if (m != MemberEnd()) {
+            EraseMember(m);
+            return true;
+        }
+        else
+            return false;
+    }
+
+    Object GetObject() { RAPIDJSON_ASSERT(IsObject()); return Object(*this); }
+    ConstObject GetObject() const { RAPIDJSON_ASSERT(IsObject()); return ConstObject(*this); }
+
+    //@}
+
+    //!@name Array
+    //@{
+
+    //! Set this value as an empty array.
+    /*! \post IsArray == true */
+    GenericValue& SetArray() { this->~GenericValue(); new (this) GenericValue(kArrayType); return *this; }
+
+    //! Get the number of elements in array.
+    SizeType Size() const { RAPIDJSON_ASSERT(IsArray()); return data_.a.size; }
+
+    //! Get the capacity of array.
+    SizeType Capacity() const { RAPIDJSON_ASSERT(IsArray()); return data_.a.capacity; }
+
+    //! Check whether the array is empty.
+    bool Empty() const { RAPIDJSON_ASSERT(IsArray()); return data_.a.size == 0; }
+
+    //! Remove all elements in the array.
+    /*! This function do not deallocate memory in the array, i.e. the capacity is unchanged.
+        \note Linear time complexity.
+    */
+    void Clear() {
+        RAPIDJSON_ASSERT(IsArray()); 
+        GenericValue* e = GetElementsPointer();
+        for (GenericValue* v = e; v != e + data_.a.size; ++v)
+            v->~GenericValue();
+        data_.a.size = 0;
+    }
+
+    //! Get an element from array by index.
+    /*! \pre IsArray() == true
+        \param index Zero-based index of element.
+        \see operator[](T*)
+    */
+    GenericValue& operator[](SizeType index) {
+        RAPIDJSON_ASSERT(IsArray());
+        RAPIDJSON_ASSERT(index < data_.a.size);
+        return GetElementsPointer()[index];
+    }
+    const GenericValue& operator[](SizeType index) const { return const_cast<GenericValue&>(*this)[index]; }
+
+    //! Element iterator
+    /*! \pre IsArray() == true */
+    ValueIterator Begin() { RAPIDJSON_ASSERT(IsArray()); return GetElementsPointer(); }
+    //! \em Past-the-end element iterator
+    /*! \pre IsArray() == true */
+    ValueIterator End() { RAPIDJSON_ASSERT(IsArray()); return GetElementsPointer() + data_.a.size; }
+    //! Constant element iterator
+    /*! \pre IsArray() == true */
+    ConstValueIterator Begin() const { return const_cast<GenericValue&>(*this).Begin(); }
+    //! Constant \em past-the-end element iterator
+    /*! \pre IsArray() == true */
+    ConstValueIterator End() const { return const_cast<GenericValue&>(*this).End(); }
+
+    //! Request the array to have enough capacity to store elements.
+    /*! \param newCapacity  The capacity that the array at least need to have.
+        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
+        \return The value itself for fluent API.
+        \note Linear time complexity.
+    */
+    GenericValue& Reserve(SizeType newCapacity, Allocator &allocator) {
+        RAPIDJSON_ASSERT(IsArray());
+        if (newCapacity > data_.a.capacity) {
+            SetElementsPointer(reinterpret_cast<GenericValue*>(allocator.Realloc(GetElementsPointer(), data_.a.capacity * sizeof(GenericValue), newCapacity * sizeof(GenericValue))));
+            data_.a.capacity = newCapacity;
+        }
+        return *this;
+    }
+
+    //! Append a GenericValue at the end of the array.
+    /*! \param value        Value to be appended.
+        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
+        \pre IsArray() == true
+        \post value.IsNull() == true
+        \return The value itself for fluent API.
+        \note The ownership of \c value will be transferred to this array on success.
+        \note If the number of elements to be appended is known, calls Reserve() once first may be more efficient.
+        \note Amortized constant time complexity.
+    */
+    GenericValue& PushBack(GenericValue& value, Allocator& allocator) {
+        RAPIDJSON_ASSERT(IsArray());
+        if (data_.a.size >= data_.a.capacity)
+            Reserve(data_.a.capacity == 0 ? kDefaultArrayCapacity : (data_.a.capacity + (data_.a.capacity + 1) / 2), allocator);
+        GetElementsPointer()[data_.a.size++].RawAssign(value);
+        return *this;
+    }
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+    GenericValue& PushBack(GenericValue&& value, Allocator& allocator) {
+        return PushBack(value, allocator);
+    }
+#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
+
+    //! Append a constant string reference at the end of the array.
+    /*! \param value        Constant string reference to be appended.
+        \param allocator    Allocator for reallocating memory. It must be the same one used previously. Commonly use GenericDocument::GetAllocator().
+        \pre IsArray() == true
+        \return The value itself for fluent API.
+        \note If the number of elements to be appended is known, calls Reserve() once first may be more efficient.
+        \note Amortized constant time complexity.
+        \see GenericStringRef
+    */
+    GenericValue& PushBack(StringRefType value, Allocator& allocator) {
+        return (*this).template PushBack<StringRefType>(value, allocator);
+    }
+
+    //! Append a primitive value at the end of the array.
+    /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t
+        \param value Value of primitive type T to be appended.
+        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
+        \pre IsArray() == true
+        \return The value itself for fluent API.
+        \note If the number of elements to be appended is known, calls Reserve() once first may be more efficient.
+
+        \note The source type \c T explicitly disallows all pointer types,
+            especially (\c const) \ref Ch*.  This helps avoiding implicitly
+            referencing character strings with insufficient lifetime, use
+            \ref PushBack(GenericValue&, Allocator&) or \ref
+            PushBack(StringRefType, Allocator&).
+            All other pointer types would implicitly convert to \c bool,
+            use an explicit cast instead, if needed.
+        \note Amortized constant time complexity.
+    */
+    template <typename T>
+    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (GenericValue&))
+    PushBack(T value, Allocator& allocator) {
+        GenericValue v(value);
+        return PushBack(v, allocator);
+    }
+
+    //! Remove the last element in the array.
+    /*!
+        \note Constant time complexity.
+    */
+    GenericValue& PopBack() {
+        RAPIDJSON_ASSERT(IsArray());
+        RAPIDJSON_ASSERT(!Empty());
+        GetElementsPointer()[--data_.a.size].~GenericValue();
+        return *this;
+    }
+
+    //! Remove an element of array by iterator.
+    /*!
+        \param pos iterator to the element to remove
+        \pre IsArray() == true && \ref Begin() <= \c pos < \ref End()
+        \return Iterator following the removed element. If the iterator pos refers to the last element, the End() iterator is returned.
+        \note Linear time complexity.
+    */
+    ValueIterator Erase(ConstValueIterator pos) {
+        return Erase(pos, pos + 1);
+    }
+
+    //! Remove elements in the range [first, last) of the array.
+    /*!
+        \param first iterator to the first element to remove
+        \param last  iterator following the last element to remove
+        \pre IsArray() == true && \ref Begin() <= \c first <= \c last <= \ref End()
+        \return Iterator following the last removed element.
+        \note Linear time complexity.
+    */
+    ValueIterator Erase(ConstValueIterator first, ConstValueIterator last) {
+        RAPIDJSON_ASSERT(IsArray());
+        RAPIDJSON_ASSERT(data_.a.size > 0);
+        RAPIDJSON_ASSERT(GetElementsPointer() != 0);
+        RAPIDJSON_ASSERT(first >= Begin());
+        RAPIDJSON_ASSERT(first <= last);
+        RAPIDJSON_ASSERT(last <= End());
+        ValueIterator pos = Begin() + (first - Begin());
+        for (ValueIterator itr = pos; itr != last; ++itr)
+            itr->~GenericValue();       
+        std::memmove(pos, last, static_cast<size_t>(End() - last) * sizeof(GenericValue));
+        data_.a.size -= static_cast<SizeType>(last - first);
+        return pos;
+    }
+
+    Array GetArray() { RAPIDJSON_ASSERT(IsArray()); return Array(*this); }
+    ConstArray GetArray() const { RAPIDJSON_ASSERT(IsArray()); return ConstArray(*this); }
+
+    //@}
+
+    //!@name Number
+    //@{
+
+    int GetInt() const          { RAPIDJSON_ASSERT(data_.f.flags & kIntFlag);   return data_.n.i.i;   }
+    unsigned GetUint() const    { RAPIDJSON_ASSERT(data_.f.flags & kUintFlag);  return data_.n.u.u;   }
+    int64_t GetInt64() const    { RAPIDJSON_ASSERT(data_.f.flags & kInt64Flag); return data_.n.i64; }
+    uint64_t GetUint64() const  { RAPIDJSON_ASSERT(data_.f.flags & kUint64Flag); return data_.n.u64; }
+
+    //! Get the value as double type.
+    /*! \note If the value is 64-bit integer type, it may lose precision. Use \c IsLosslessDouble() to check whether the converison is lossless.
+    */
+    double GetDouble() const {
+        RAPIDJSON_ASSERT(IsNumber());
+        if ((data_.f.flags & kDoubleFlag) != 0)                return data_.n.d;   // exact type, no conversion.
+        if ((data_.f.flags & kIntFlag) != 0)                   return data_.n.i.i; // int -> double
+        if ((data_.f.flags & kUintFlag) != 0)                  return data_.n.u.u; // unsigned -> double
+        if ((data_.f.flags & kInt64Flag) != 0)                 return static_cast<double>(data_.n.i64); // int64_t -> double (may lose precision)
+        RAPIDJSON_ASSERT((data_.f.flags & kUint64Flag) != 0);  return static_cast<double>(data_.n.u64); // uint64_t -> double (may lose precision)
+    }
+
+    //! Get the value as float type.
+    /*! \note If the value is 64-bit integer type, it may lose precision. Use \c IsLosslessFloat() to check whether the converison is lossless.
+    */
+    float GetFloat() const {
+        return static_cast<float>(GetDouble());
+    }
+
+    GenericValue& SetInt(int i)             { this->~GenericValue(); new (this) GenericValue(i);    return *this; }
+    GenericValue& SetUint(unsigned u)       { this->~GenericValue(); new (this) GenericValue(u);    return *this; }
+    GenericValue& SetInt64(int64_t i64)     { this->~GenericValue(); new (this) GenericValue(i64);  return *this; }
+    GenericValue& SetUint64(uint64_t u64)   { this->~GenericValue(); new (this) GenericValue(u64);  return *this; }
+    GenericValue& SetDouble(double d)       { this->~GenericValue(); new (this) GenericValue(d);    return *this; }
+    GenericValue& SetFloat(float f)         { this->~GenericValue(); new (this) GenericValue(f);    return *this; }
+
+    //@}
+
+    //!@name String
+    //@{
+
+    const Ch* GetString() const { RAPIDJSON_ASSERT(IsString()); return (data_.f.flags & kInlineStrFlag) ? data_.ss.str : GetStringPointer(); }
+
+    //! Get the length of string.
+    /*! Since rapidjson permits "\\u0000" in the json string, strlen(v.GetString()) may not equal to v.GetStringLength().
+    */
+    SizeType GetStringLength() const { RAPIDJSON_ASSERT(IsString()); return ((data_.f.flags & kInlineStrFlag) ? (data_.ss.GetLength()) : data_.s.length); }
+
+    //! Set this value as a string without copying source string.
+    /*! This version has better performance with supplied length, and also support string containing null character.
+        \param s source string pointer. 
+        \param length The length of source string, excluding the trailing null terminator.
+        \return The value itself for fluent API.
+        \post IsString() == true && GetString() == s && GetStringLength() == length
+        \see SetString(StringRefType)
+    */
+    GenericValue& SetString(const Ch* s, SizeType length) { return SetString(StringRef(s, length)); }
+
+    //! Set this value as a string without copying source string.
+    /*! \param s source string reference
+        \return The value itself for fluent API.
+        \post IsString() == true && GetString() == s && GetStringLength() == s.length
+    */
+    GenericValue& SetString(StringRefType s) { this->~GenericValue(); SetStringRaw(s); return *this; }
+
+    //! Set this value as a string by copying from source string.
+    /*! This version has better performance with supplied length, and also support string containing null character.
+        \param s source string. 
+        \param length The length of source string, excluding the trailing null terminator.
+        \param allocator Allocator for allocating copied buffer. Commonly use GenericDocument::GetAllocator().
+        \return The value itself for fluent API.
+        \post IsString() == true && GetString() != s && strcmp(GetString(),s) == 0 && GetStringLength() == length
+    */
+    GenericValue& SetString(const Ch* s, SizeType length, Allocator& allocator) { this->~GenericValue(); SetStringRaw(StringRef(s, length), allocator); return *this; }
+
+    //! Set this value as a string by copying from source string.
+    /*! \param s source string. 
+        \param allocator Allocator for allocating copied buffer. Commonly use GenericDocument::GetAllocator().
+        \return The value itself for fluent API.
+        \post IsString() == true && GetString() != s && strcmp(GetString(),s) == 0 && GetStringLength() == length
+    */
+    GenericValue& SetString(const Ch* s, Allocator& allocator) { return SetString(s, internal::StrLen(s), allocator); }
+
+#if RAPIDJSON_HAS_STDSTRING
+    //! Set this value as a string by copying from source string.
+    /*! \param s source string.
+        \param allocator Allocator for allocating copied buffer. Commonly use GenericDocument::GetAllocator().
+        \return The value itself for fluent API.
+        \post IsString() == true && GetString() != s.data() && strcmp(GetString(),s.data() == 0 && GetStringLength() == s.size()
+        \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING.
+    */
+    GenericValue& SetString(const std::basic_string<Ch>& s, Allocator& allocator) { return SetString(s.data(), SizeType(s.size()), allocator); }
+#endif
+
+    //@}
+
+    //!@name Array
+    //@{
+
+    //! Templated version for checking whether this value is type T.
+    /*!
+        \tparam T Either \c bool, \c int, \c unsigned, \c int64_t, \c uint64_t, \c double, \c float, \c const \c char*, \c std::basic_string<Ch>
+    */
+    template <typename T>
+    bool Is() const { return internal::TypeHelper<ValueType, T>::Is(*this); }
+
+    template <typename T>
+    T Get() const { return internal::TypeHelper<ValueType, T>::Get(*this); }
+
+    template <typename T>
+    T Get() { return internal::TypeHelper<ValueType, T>::Get(*this); }
+
+    template<typename T>
+    ValueType& Set(const T& data) { return internal::TypeHelper<ValueType, T>::Set(*this, data); }
+
+    template<typename T>
+    ValueType& Set(const T& data, AllocatorType& allocator) { return internal::TypeHelper<ValueType, T>::Set(*this, data, allocator); }
+
+    //@}
+
+    //! Generate events of this value to a Handler.
+    /*! This function adopts the GoF visitor pattern.
+        Typical usage is to output this JSON value as JSON text via Writer, which is a Handler.
+        It can also be used to deep clone this value via GenericDocument, which is also a Handler.
+        \tparam Handler type of handler.
+        \param handler An object implementing concept Handler.
+    */
+    template <typename Handler>
+    bool Accept(Handler& handler) const {
+        switch(GetType()) {
+        case kNullType:     return handler.Null();
+        case kFalseType:    return handler.Bool(false);
+        case kTrueType:     return handler.Bool(true);
+
+        case kObjectType:
+            if (RAPIDJSON_UNLIKELY(!handler.StartObject()))
+                return false;
+            for (ConstMemberIterator m = MemberBegin(); m != MemberEnd(); ++m) {
+                RAPIDJSON_ASSERT(m->name.IsString()); // User may change the type of name by MemberIterator.
+                if (RAPIDJSON_UNLIKELY(!handler.Key(m->name.GetString(), m->name.GetStringLength(), (m->name.data_.f.flags & kCopyFlag) != 0)))
+                    return false;
+                if (RAPIDJSON_UNLIKELY(!m->value.Accept(handler)))
+                    return false;
+            }
+            return handler.EndObject(data_.o.size);
+
+        case kArrayType:
+            if (RAPIDJSON_UNLIKELY(!handler.StartArray()))
+                return false;
+            for (const GenericValue* v = Begin(); v != End(); ++v)
+                if (RAPIDJSON_UNLIKELY(!v->Accept(handler)))
+                    return false;
+            return handler.EndArray(data_.a.size);
+    
+        case kStringType:
+            return handler.String(GetString(), GetStringLength(), (data_.f.flags & kCopyFlag) != 0);
+    
+        default:
+            RAPIDJSON_ASSERT(GetType() == kNumberType);
+            if (IsDouble())         return handler.Double(data_.n.d);
+            else if (IsInt())       return handler.Int(data_.n.i.i);
+            else if (IsUint())      return handler.Uint(data_.n.u.u);
+            else if (IsInt64())     return handler.Int64(data_.n.i64);
+            else                    return handler.Uint64(data_.n.u64);
+        }
+    }
+
+private:
+    template <typename, typename> friend class GenericValue;
+    template <typename, typename, typename> friend class GenericDocument;
+
+    enum {
+        kBoolFlag       = 0x0008,
+        kNumberFlag     = 0x0010,
+        kIntFlag        = 0x0020,
+        kUintFlag       = 0x0040,
+        kInt64Flag      = 0x0080,
+        kUint64Flag     = 0x0100,
+        kDoubleFlag     = 0x0200,
+        kStringFlag     = 0x0400,
+        kCopyFlag       = 0x0800,
+        kInlineStrFlag  = 0x1000,
+
+        // Initial flags of different types.
+        kNullFlag = kNullType,
+        kTrueFlag = kTrueType | kBoolFlag,
+        kFalseFlag = kFalseType | kBoolFlag,
+        kNumberIntFlag = kNumberType | kNumberFlag | kIntFlag | kInt64Flag,
+        kNumberUintFlag = kNumberType | kNumberFlag | kUintFlag | kUint64Flag | kInt64Flag,
+        kNumberInt64Flag = kNumberType | kNumberFlag | kInt64Flag,
+        kNumberUint64Flag = kNumberType | kNumberFlag | kUint64Flag,
+        kNumberDoubleFlag = kNumberType | kNumberFlag | kDoubleFlag,
+        kNumberAnyFlag = kNumberType | kNumberFlag | kIntFlag | kInt64Flag | kUintFlag | kUint64Flag | kDoubleFlag,
+        kConstStringFlag = kStringType | kStringFlag,
+        kCopyStringFlag = kStringType | kStringFlag | kCopyFlag,
+        kShortStringFlag = kStringType | kStringFlag | kCopyFlag | kInlineStrFlag,
+        kObjectFlag = kObjectType,
+        kArrayFlag = kArrayType,
+
+        kTypeMask = 0x07
+    };
+
+    static const SizeType kDefaultArrayCapacity = 16;
+    static const SizeType kDefaultObjectCapacity = 16;
+
+    struct Flag {
+#if RAPIDJSON_48BITPOINTER_OPTIMIZATION
+        char payload[sizeof(SizeType) * 2 + 6];     // 2 x SizeType + lower 48-bit pointer
+#elif RAPIDJSON_64BIT
+        char payload[sizeof(SizeType) * 2 + sizeof(void*) + 6]; // 6 padding bytes
+#else
+        char payload[sizeof(SizeType) * 2 + sizeof(void*) + 2]; // 2 padding bytes
+#endif
+        uint16_t flags;
+    };
+
+    struct String {
+        SizeType length;
+        SizeType hashcode;  //!< reserved
+        const Ch* str;
+    };  // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode
+
+    // implementation detail: ShortString can represent zero-terminated strings up to MaxSize chars
+    // (excluding the terminating zero) and store a value to determine the length of the contained
+    // string in the last character str[LenPos] by storing "MaxSize - length" there. If the string
+    // to store has the maximal length of MaxSize then str[LenPos] will be 0 and therefore act as
+    // the string terminator as well. For getting the string length back from that value just use
+    // "MaxSize - str[LenPos]".
+    // This allows to store 13-chars strings in 32-bit mode, 21-chars strings in 64-bit mode,
+    // 13-chars strings for RAPIDJSON_48BITPOINTER_OPTIMIZATION=1 inline (for `UTF8`-encoded strings).
+    struct ShortString {
+        enum { MaxChars = sizeof(static_cast<Flag*>(0)->payload) / sizeof(Ch), MaxSize = MaxChars - 1, LenPos = MaxSize };
+        Ch str[MaxChars];
+
+        inline static bool Usable(SizeType len) { return                       (MaxSize >= len); }
+        inline void     SetLength(SizeType len) { str[LenPos] = static_cast<Ch>(MaxSize -  len); }
+        inline SizeType GetLength() const       { return  static_cast<SizeType>(MaxSize -  str[LenPos]); }
+    };  // at most as many bytes as "String" above => 12 bytes in 32-bit mode, 16 bytes in 64-bit mode
+
+    // By using proper binary layout, retrieval of different integer types do not need conversions.
+    union Number {
+#if RAPIDJSON_ENDIAN == RAPIDJSON_LITTLEENDIAN
+        struct I {
+            int i;
+            char padding[4];
+        }i;
+        struct U {
+            unsigned u;
+            char padding2[4];
+        }u;
+#else
+        struct I {
+            char padding[4];
+            int i;
+        }i;
+        struct U {
+            char padding2[4];
+            unsigned u;
+        }u;
+#endif
+        int64_t i64;
+        uint64_t u64;
+        double d;
+    };  // 8 bytes
+
+    struct ObjectData {
+        SizeType size;
+        SizeType capacity;
+        Member* members;
+    };  // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode
+
+    struct ArrayData {
+        SizeType size;
+        SizeType capacity;
+        GenericValue* elements;
+    };  // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode
+
+    union Data {
+        String s;
+        ShortString ss;
+        Number n;
+        ObjectData o;
+        ArrayData a;
+        Flag f;
+    };  // 16 bytes in 32-bit mode, 24 bytes in 64-bit mode, 16 bytes in 64-bit with RAPIDJSON_48BITPOINTER_OPTIMIZATION
+
+    RAPIDJSON_FORCEINLINE const Ch* GetStringPointer() const { return RAPIDJSON_GETPOINTER(Ch, data_.s.str); }
+    RAPIDJSON_FORCEINLINE const Ch* SetStringPointer(const Ch* str) { return RAPIDJSON_SETPOINTER(Ch, data_.s.str, str); }
+    RAPIDJSON_FORCEINLINE GenericValue* GetElementsPointer() const { return RAPIDJSON_GETPOINTER(GenericValue, data_.a.elements); }
+    RAPIDJSON_FORCEINLINE GenericValue* SetElementsPointer(GenericValue* elements) { return RAPIDJSON_SETPOINTER(GenericValue, data_.a.elements, elements); }
+    RAPIDJSON_FORCEINLINE Member* GetMembersPointer() const { return RAPIDJSON_GETPOINTER(Member, data_.o.members); }
+    RAPIDJSON_FORCEINLINE Member* SetMembersPointer(Member* members) { return RAPIDJSON_SETPOINTER(Member, data_.o.members, members); }
+
+    // Initialize this value as array with initial data, without calling destructor.
+    void SetArrayRaw(GenericValue* values, SizeType count, Allocator& allocator) {
+        data_.f.flags = kArrayFlag;
+        if (count) {
+            GenericValue* e = static_cast<GenericValue*>(allocator.Malloc(count * sizeof(GenericValue)));
+            SetElementsPointer(e);
+            std::memcpy(e, values, count * sizeof(GenericValue));
+        }
+        else
+            SetElementsPointer(0);
+        data_.a.size = data_.a.capacity = count;
+    }
+
+    //! Initialize this value as object with initial data, without calling destructor.
+    void SetObjectRaw(Member* members, SizeType count, Allocator& allocator) {
+        data_.f.flags = kObjectFlag;
+        if (count) {
+            Member* m = static_cast<Member*>(allocator.Malloc(count * sizeof(Member)));
+            SetMembersPointer(m);
+            std::memcpy(m, members, count * sizeof(Member));
+        }
+        else
+            SetMembersPointer(0);
+        data_.o.size = data_.o.capacity = count;
+    }
+
+    //! Initialize this value as constant string, without calling destructor.
+    void SetStringRaw(StringRefType s) RAPIDJSON_NOEXCEPT {
+        data_.f.flags = kConstStringFlag;
+        SetStringPointer(s);
+        data_.s.length = s.length;
+    }
+
+    //! Initialize this value as copy string with initial data, without calling destructor.
+    void SetStringRaw(StringRefType s, Allocator& allocator) {
+        Ch* str = 0;
+        if (ShortString::Usable(s.length)) {
+            data_.f.flags = kShortStringFlag;
+            data_.ss.SetLength(s.length);
+            str = data_.ss.str;
+        } else {
+            data_.f.flags = kCopyStringFlag;
+            data_.s.length = s.length;
+            str = static_cast<Ch *>(allocator.Malloc((s.length + 1) * sizeof(Ch)));
+            SetStringPointer(str);
+        }
+        std::memcpy(str, s, s.length * sizeof(Ch));
+        str[s.length] = '\0';
+    }
+
+    //! Assignment without calling destructor
+    void RawAssign(GenericValue& rhs) RAPIDJSON_NOEXCEPT {
+        data_ = rhs.data_;
+        // data_.f.flags = rhs.data_.f.flags;
+        rhs.data_.f.flags = kNullFlag;
+    }
+
+    template <typename SourceAllocator>
+    bool StringEqual(const GenericValue<Encoding, SourceAllocator>& rhs) const {
+        RAPIDJSON_ASSERT(IsString());
+        RAPIDJSON_ASSERT(rhs.IsString());
+
+        const SizeType len1 = GetStringLength();
+        const SizeType len2 = rhs.GetStringLength();
+        if(len1 != len2) { return false; }
+
+        const Ch* const str1 = GetString();
+        const Ch* const str2 = rhs.GetString();
+        if(str1 == str2) { return true; } // fast path for constant string
+
+        return (std::memcmp(str1, str2, sizeof(Ch) * len1) == 0);
+    }
+
+    Data data_;
+};
+
+//! GenericValue with UTF8 encoding
+typedef GenericValue<UTF8<> > Value;
+
+///////////////////////////////////////////////////////////////////////////////
+// GenericDocument 
+
+//! A document for parsing JSON text as DOM.
+/*!
+    \note implements Handler concept
+    \tparam Encoding Encoding for both parsing and string storage.
+    \tparam Allocator Allocator for allocating memory for the DOM
+    \tparam StackAllocator Allocator for allocating memory for stack during parsing.
+    \warning Although GenericDocument inherits from GenericValue, the API does \b not provide any virtual functions, especially no virtual destructor.  To avoid memory leaks, do not \c delete a GenericDocument object via a pointer to a GenericValue.
+*/
+template <typename Encoding, typename Allocator = MemoryPoolAllocator<>, typename StackAllocator = CrtAllocator>
+class GenericDocument : public GenericValue<Encoding, Allocator> {
+public:
+    typedef typename Encoding::Ch Ch;                       //!< Character type derived from Encoding.
+    typedef GenericValue<Encoding, Allocator> ValueType;    //!< Value type of the document.
+    typedef Allocator AllocatorType;                        //!< Allocator type from template parameter.
+
+    //! Constructor
+    /*! Creates an empty document of specified type.
+        \param type             Mandatory type of object to create.
+        \param allocator        Optional allocator for allocating memory.
+        \param stackCapacity    Optional initial capacity of stack in bytes.
+        \param stackAllocator   Optional allocator for allocating memory for stack.
+    */
+    explicit GenericDocument(Type type, Allocator* allocator = 0, size_t stackCapacity = kDefaultStackCapacity, StackAllocator* stackAllocator = 0) :
+        GenericValue<Encoding, Allocator>(type),  allocator_(allocator), ownAllocator_(0), stack_(stackAllocator, stackCapacity), parseResult_()
+    {
+        if (!allocator_)
+            ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator());
+    }
+
+    //! Constructor
+    /*! Creates an empty document which type is Null. 
+        \param allocator        Optional allocator for allocating memory.
+        \param stackCapacity    Optional initial capacity of stack in bytes.
+        \param stackAllocator   Optional allocator for allocating memory for stack.
+    */
+    GenericDocument(Allocator* allocator = 0, size_t stackCapacity = kDefaultStackCapacity, StackAllocator* stackAllocator = 0) : 
+        allocator_(allocator), ownAllocator_(0), stack_(stackAllocator, stackCapacity), parseResult_()
+    {
+        if (!allocator_)
+            ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator());
+    }
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+    //! Move constructor in C++11
+    GenericDocument(GenericDocument&& rhs) RAPIDJSON_NOEXCEPT
+        : ValueType(std::forward<ValueType>(rhs)), // explicit cast to avoid prohibited move from Document
+          allocator_(rhs.allocator_),
+          ownAllocator_(rhs.ownAllocator_),
+          stack_(std::move(rhs.stack_)),
+          parseResult_(rhs.parseResult_)
+    {
+        rhs.allocator_ = 0;
+        rhs.ownAllocator_ = 0;
+        rhs.parseResult_ = ParseResult();
+    }
+#endif
+
+    ~GenericDocument() {
+        Destroy();
+    }
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+    //! Move assignment in C++11
+    GenericDocument& operator=(GenericDocument&& rhs) RAPIDJSON_NOEXCEPT
+    {
+        // The cast to ValueType is necessary here, because otherwise it would
+        // attempt to call GenericValue's templated assignment operator.
+        ValueType::operator=(std::forward<ValueType>(rhs));
+
+        // Calling the destructor here would prematurely call stack_'s destructor
+        Destroy();
+
+        allocator_ = rhs.allocator_;
+        ownAllocator_ = rhs.ownAllocator_;
+        stack_ = std::move(rhs.stack_);
+        parseResult_ = rhs.parseResult_;
+
+        rhs.allocator_ = 0;
+        rhs.ownAllocator_ = 0;
+        rhs.parseResult_ = ParseResult();
+
+        return *this;
+    }
+#endif
+
+    //! Exchange the contents of this document with those of another.
+    /*!
+        \param rhs Another document.
+        \note Constant complexity.
+        \see GenericValue::Swap
+    */
+    GenericDocument& Swap(GenericDocument& rhs) RAPIDJSON_NOEXCEPT {
+        ValueType::Swap(rhs);
+        stack_.Swap(rhs.stack_);
+        internal::Swap(allocator_, rhs.allocator_);
+        internal::Swap(ownAllocator_, rhs.ownAllocator_);
+        internal::Swap(parseResult_, rhs.parseResult_);
+        return *this;
+    }
+
+    //! free-standing swap function helper
+    /*!
+        Helper function to enable support for common swap implementation pattern based on \c std::swap:
+        \code
+        void swap(MyClass& a, MyClass& b) {
+            using std::swap;
+            swap(a.doc, b.doc);
+            // ...
+        }
+        \endcode
+        \see Swap()
+     */
+    friend inline void swap(GenericDocument& a, GenericDocument& b) RAPIDJSON_NOEXCEPT { a.Swap(b); }
+
+    //! Populate this document by a generator which produces SAX events.
+    /*! \tparam Generator A functor with <tt>bool f(Handler)</tt> prototype.
+        \param g Generator functor which sends SAX events to the parameter.
+        \return The document itself for fluent API.
+    */
+    template <typename Generator>
+    GenericDocument& Populate(Generator& g) {
+        ClearStackOnExit scope(*this);
+        if (g(*this)) {
+            RAPIDJSON_ASSERT(stack_.GetSize() == sizeof(ValueType)); // Got one and only one root object
+            ValueType::operator=(*stack_.template Pop<ValueType>(1));// Move value from stack to document
+        }
+        return *this;
+    }
+
+    //!@name Parse from stream
+    //!@{
+
+    //! Parse JSON text from an input stream (with Encoding conversion)
+    /*! \tparam parseFlags Combination of \ref ParseFlag.
+        \tparam SourceEncoding Encoding of input stream
+        \tparam InputStream Type of input stream, implementing Stream concept
+        \param is Input stream to be parsed.
+        \return The document itself for fluent API.
+    */
+    template <unsigned parseFlags, typename SourceEncoding, typename InputStream>
+    GenericDocument& ParseStream(InputStream& is) {
+        GenericReader<SourceEncoding, Encoding, StackAllocator> reader(
+            stack_.HasAllocator() ? &stack_.GetAllocator() : 0);
+        ClearStackOnExit scope(*this);
+        parseResult_ = reader.template Parse<parseFlags>(is, *this);
+        if (parseResult_) {
+            RAPIDJSON_ASSERT(stack_.GetSize() == sizeof(ValueType)); // Got one and only one root object
+            ValueType::operator=(*stack_.template Pop<ValueType>(1));// Move value from stack to document
+        }
+        return *this;
+    }
+
+    //! Parse JSON text from an input stream
+    /*! \tparam parseFlags Combination of \ref ParseFlag.
+        \tparam InputStream Type of input stream, implementing Stream concept
+        \param is Input stream to be parsed.
+        \return The document itself for fluent API.
+    */
+    template <unsigned parseFlags, typename InputStream>
+    GenericDocument& ParseStream(InputStream& is) {
+        return ParseStream<parseFlags, Encoding, InputStream>(is);
+    }
+
+    //! Parse JSON text from an input stream (with \ref kParseDefaultFlags)
+    /*! \tparam InputStream Type of input stream, implementing Stream concept
+        \param is Input stream to be parsed.
+        \return The document itself for fluent API.
+    */
+    template <typename InputStream>
+    GenericDocument& ParseStream(InputStream& is) {
+        return ParseStream<kParseDefaultFlags, Encoding, InputStream>(is);
+    }
+    //!@}
+
+    //!@name Parse in-place from mutable string
+    //!@{
+
+    //! Parse JSON text from a mutable string
+    /*! \tparam parseFlags Combination of \ref ParseFlag.
+        \param str Mutable zero-terminated string to be parsed.
+        \return The document itself for fluent API.
+    */
+    template <unsigned parseFlags>
+    GenericDocument& ParseInsitu(Ch* str) {
+        GenericInsituStringStream<Encoding> s(str);
+        return ParseStream<parseFlags | kParseInsituFlag>(s);
+    }
+
+    //! Parse JSON text from a mutable string (with \ref kParseDefaultFlags)
+    /*! \param str Mutable zero-terminated string to be parsed.
+        \return The document itself for fluent API.
+    */
+    GenericDocument& ParseInsitu(Ch* str) {
+        return ParseInsitu<kParseDefaultFlags>(str);
+    }
+    //!@}
+
+    //!@name Parse from read-only string
+    //!@{
+
+    //! Parse JSON text from a read-only string (with Encoding conversion)
+    /*! \tparam parseFlags Combination of \ref ParseFlag (must not contain \ref kParseInsituFlag).
+        \tparam SourceEncoding Transcoding from input Encoding
+        \param str Read-only zero-terminated string to be parsed.
+    */
+    template <unsigned parseFlags, typename SourceEncoding>
+    GenericDocument& Parse(const typename SourceEncoding::Ch* str) {
+        RAPIDJSON_ASSERT(!(parseFlags & kParseInsituFlag));
+        GenericStringStream<SourceEncoding> s(str);
+        return ParseStream<parseFlags, SourceEncoding>(s);
+    }
+
+    //! Parse JSON text from a read-only string
+    /*! \tparam parseFlags Combination of \ref ParseFlag (must not contain \ref kParseInsituFlag).
+        \param str Read-only zero-terminated string to be parsed.
+    */
+    template <unsigned parseFlags>
+    GenericDocument& Parse(const Ch* str) {
+        return Parse<parseFlags, Encoding>(str);
+    }
+
+    //! Parse JSON text from a read-only string (with \ref kParseDefaultFlags)
+    /*! \param str Read-only zero-terminated string to be parsed.
+    */
+    GenericDocument& Parse(const Ch* str) {
+        return Parse<kParseDefaultFlags>(str);
+    }
+
+    template <unsigned parseFlags, typename SourceEncoding>
+    GenericDocument& Parse(const typename SourceEncoding::Ch* str, size_t length) {
+        RAPIDJSON_ASSERT(!(parseFlags & kParseInsituFlag));
+        MemoryStream ms(static_cast<const char*>(str), length * sizeof(typename SourceEncoding::Ch));
+        EncodedInputStream<SourceEncoding, MemoryStream> is(ms);
+        ParseStream<parseFlags, SourceEncoding>(is);
+        return *this;
+    }
+
+    template <unsigned parseFlags>
+    GenericDocument& Parse(const Ch* str, size_t length) {
+        return Parse<parseFlags, Encoding>(str, length);
+    }
+    
+    GenericDocument& Parse(const Ch* str, size_t length) {
+        return Parse<kParseDefaultFlags>(str, length);
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    template <unsigned parseFlags, typename SourceEncoding>
+    GenericDocument& Parse(const std::basic_string<typename SourceEncoding::Ch>& str) {
+        // c_str() is constant complexity according to standard. Should be faster than Parse(const char*, size_t)
+        return Parse<parseFlags, SourceEncoding>(str.c_str());
+    }
+
+    template <unsigned parseFlags>
+    GenericDocument& Parse(const std::basic_string<Ch>& str) {
+        return Parse<parseFlags, Encoding>(str.c_str());
+    }
+
+    GenericDocument& Parse(const std::basic_string<Ch>& str) {
+        return Parse<kParseDefaultFlags>(str);
+    }
+#endif // RAPIDJSON_HAS_STDSTRING    
+
+    //!@}
+
+    //!@name Handling parse errors
+    //!@{
+
+    //! Whether a parse error has occured in the last parsing.
+    bool HasParseError() const { return parseResult_.IsError(); }
+
+    //! Get the \ref ParseErrorCode of last parsing.
+    ParseErrorCode GetParseError() const { return parseResult_.Code(); }
+
+    //! Get the position of last parsing error in input, 0 otherwise.
+    size_t GetErrorOffset() const { return parseResult_.Offset(); }
+
+    //! Implicit conversion to get the last parse result
+#ifndef __clang // -Wdocumentation
+    /*! \return \ref ParseResult of the last parse operation
+
+        \code
+          Document doc;
+          ParseResult ok = doc.Parse(json);
+          if (!ok)
+            printf( "JSON parse error: %s (%u)\n", GetParseError_En(ok.Code()), ok.Offset());
+        \endcode
+     */
+#endif
+    operator ParseResult() const { return parseResult_; }
+    //!@}
+
+    //! Get the allocator of this document.
+    Allocator& GetAllocator() {
+        RAPIDJSON_ASSERT(allocator_);
+        return *allocator_;
+    }
+
+    //! Get the capacity of stack in bytes.
+    size_t GetStackCapacity() const { return stack_.GetCapacity(); }
+
+private:
+    // clear stack on any exit from ParseStream, e.g. due to exception
+    struct ClearStackOnExit {
+        explicit ClearStackOnExit(GenericDocument& d) : d_(d) {}
+        ~ClearStackOnExit() { d_.ClearStack(); }
+    private:
+        ClearStackOnExit(const ClearStackOnExit&);
+        ClearStackOnExit& operator=(const ClearStackOnExit&);
+        GenericDocument& d_;
+    };
+
+    // callers of the following private Handler functions
+    // template <typename,typename,typename> friend class GenericReader; // for parsing
+    template <typename, typename> friend class GenericValue; // for deep copying
+
+public:
+    // Implementation of Handler
+    bool Null() { new (stack_.template Push<ValueType>()) ValueType(); return true; }
+    bool Bool(bool b) { new (stack_.template Push<ValueType>()) ValueType(b); return true; }
+    bool Int(int i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; }
+    bool Uint(unsigned i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; }
+    bool Int64(int64_t i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; }
+    bool Uint64(uint64_t i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; }
+    bool Double(double d) { new (stack_.template Push<ValueType>()) ValueType(d); return true; }
+
+    bool RawNumber(const Ch* str, SizeType length, bool copy) { 
+        if (copy) 
+            new (stack_.template Push<ValueType>()) ValueType(str, length, GetAllocator());
+        else
+            new (stack_.template Push<ValueType>()) ValueType(str, length);
+        return true;
+    }
+
+    bool String(const Ch* str, SizeType length, bool copy) { 
+        if (copy) 
+            new (stack_.template Push<ValueType>()) ValueType(str, length, GetAllocator());
+        else
+            new (stack_.template Push<ValueType>()) ValueType(str, length);
+        return true;
+    }
+
+    bool StartObject() { new (stack_.template Push<ValueType>()) ValueType(kObjectType); return true; }
+    
+    bool Key(const Ch* str, SizeType length, bool copy) { return String(str, length, copy); }
+
+    bool EndObject(SizeType memberCount) {
+        typename ValueType::Member* members = stack_.template Pop<typename ValueType::Member>(memberCount);
+        stack_.template Top<ValueType>()->SetObjectRaw(members, memberCount, GetAllocator());
+        return true;
+    }
+
+    bool StartArray() { new (stack_.template Push<ValueType>()) ValueType(kArrayType); return true; }
+    
+    bool EndArray(SizeType elementCount) {
+        ValueType* elements = stack_.template Pop<ValueType>(elementCount);
+        stack_.template Top<ValueType>()->SetArrayRaw(elements, elementCount, GetAllocator());
+        return true;
+    }
+
+    //! Prohibit copying
+    GenericDocument(const GenericDocument&);
+private:
+    //! Prohibit assignment
+    GenericDocument& operator=(const GenericDocument&);
+
+    void ClearStack() {
+        if (Allocator::kNeedFree)
+            while (stack_.GetSize() > 0)    // Here assumes all elements in stack array are GenericValue (Member is actually 2 GenericValue objects)
+                (stack_.template Pop<ValueType>(1))->~ValueType();
+        else
+            stack_.Clear();
+        stack_.ShrinkToFit();
+    }
+
+    void Destroy() {
+        RAPIDJSON_DELETE(ownAllocator_);
+    }
+
+    static const size_t kDefaultStackCapacity = 1024;
+    Allocator* allocator_;
+    Allocator* ownAllocator_;
+    internal::Stack<StackAllocator> stack_;
+    ParseResult parseResult_;
+};
+
+//! GenericDocument with UTF8 encoding
+typedef GenericDocument<UTF8<> > Document;
+
+// defined here due to the dependency on GenericDocument
+template <typename Encoding, typename Allocator>
+template <typename SourceAllocator>
+inline
+GenericValue<Encoding,Allocator>::GenericValue(const GenericValue<Encoding,SourceAllocator>& rhs, Allocator& allocator)
+{
+    switch (rhs.GetType()) {
+    case kObjectType:
+    case kArrayType: { // perform deep copy via SAX Handler
+            GenericDocument<Encoding,Allocator> d(&allocator);
+            rhs.Accept(d);
+            RawAssign(*d.stack_.template Pop<GenericValue>(1));
+        }
+        break;
+    case kStringType:
+        if (rhs.data_.f.flags == kConstStringFlag) {
+            data_.f.flags = rhs.data_.f.flags;
+            data_  = *reinterpret_cast<const Data*>(&rhs.data_);
+        } else {
+            SetStringRaw(StringRef(rhs.GetString(), rhs.GetStringLength()), allocator);
+        }
+        break;
+    default:
+        data_.f.flags = rhs.data_.f.flags;
+        data_  = *reinterpret_cast<const Data*>(&rhs.data_);
+        break;
+    }
+}
+
+//! Helper class for accessing Value of array type.
+/*!
+    Instance of this helper class is obtained by \c GenericValue::GetArray().
+    In addition to all APIs for array type, it provides range-based for loop if \c RAPIDJSON_HAS_CXX11_RANGE_FOR=1.
+*/
+template <bool Const, typename ValueT>
+class GenericArray {
+public:
+    typedef GenericArray<true, ValueT> ConstArray;
+    typedef GenericArray<false, ValueT> Array;
+    typedef ValueT PlainType;
+    typedef typename internal::MaybeAddConst<Const,PlainType>::Type ValueType;
+    typedef ValueType* ValueIterator;  // This may be const or non-const iterator
+    typedef const ValueT* ConstValueIterator;
+    typedef typename ValueType::AllocatorType AllocatorType;
+    typedef typename ValueType::StringRefType StringRefType;
+
+    template <typename, typename>
+    friend class GenericValue;
+
+    GenericArray(const GenericArray& rhs) : value_(rhs.value_) {}
+    GenericArray& operator=(const GenericArray& rhs) { value_ = rhs.value_; return *this; }
+    ~GenericArray() {}
+
+    SizeType Size() const { return value_.Size(); }
+    SizeType Capacity() const { return value_.Capacity(); }
+    bool Empty() const { return value_.Empty(); }
+    void Clear() const { value_.Clear(); }
+    ValueType& operator[](SizeType index) const {  return value_[index]; }
+    ValueIterator Begin() const { return value_.Begin(); }
+    ValueIterator End() const { return value_.End(); }
+    GenericArray Reserve(SizeType newCapacity, AllocatorType &allocator) const { value_.Reserve(newCapacity, allocator); return *this; }
+    GenericArray PushBack(ValueType& value, AllocatorType& allocator) const { value_.PushBack(value, allocator); return *this; }
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+    GenericArray PushBack(ValueType&& value, AllocatorType& allocator) const { value_.PushBack(value, allocator); return *this; }
+#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
+    GenericArray PushBack(StringRefType value, AllocatorType& allocator) const { value_.PushBack(value, allocator); return *this; }
+    template <typename T> RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (const GenericArray&)) PushBack(T value, AllocatorType& allocator) const { value_.PushBack(value, allocator); return *this; }
+    GenericArray PopBack() const { value_.PopBack(); return *this; }
+    ValueIterator Erase(ConstValueIterator pos) const { return value_.Erase(pos); }
+    ValueIterator Erase(ConstValueIterator first, ConstValueIterator last) const { return value_.Erase(first, last); }
+
+#if RAPIDJSON_HAS_CXX11_RANGE_FOR
+    ValueIterator begin() const { return value_.Begin(); }
+    ValueIterator end() const { return value_.End(); }
+#endif
+
+private:
+    GenericArray();
+    GenericArray(ValueType& value) : value_(value) {}
+    ValueType& value_;
+};
+
+//! Helper class for accessing Value of object type.
+/*!
+    Instance of this helper class is obtained by \c GenericValue::GetObject().
+    In addition to all APIs for array type, it provides range-based for loop if \c RAPIDJSON_HAS_CXX11_RANGE_FOR=1.
+*/
+template <bool Const, typename ValueT>
+class GenericObject {
+public:
+    typedef GenericObject<true, ValueT> ConstObject;
+    typedef GenericObject<false, ValueT> Object;
+    typedef ValueT PlainType;
+    typedef typename internal::MaybeAddConst<Const,PlainType>::Type ValueType;
+    typedef GenericMemberIterator<Const, typename ValueT::EncodingType, typename ValueT::AllocatorType> MemberIterator;  // This may be const or non-const iterator
+    typedef GenericMemberIterator<true, typename ValueT::EncodingType, typename ValueT::AllocatorType> ConstMemberIterator;
+    typedef typename ValueType::AllocatorType AllocatorType;
+    typedef typename ValueType::StringRefType StringRefType;
+    typedef typename ValueType::EncodingType EncodingType;
+    typedef typename ValueType::Ch Ch;
+
+    template <typename, typename>
+    friend class GenericValue;
+
+    GenericObject(const GenericObject& rhs) : value_(rhs.value_) {}
+    GenericObject& operator=(const GenericObject& rhs) { value_ = rhs.value_; return *this; }
+    ~GenericObject() {}
+
+    SizeType MemberCount() const { return value_.MemberCount(); }
+    bool ObjectEmpty() const { return value_.ObjectEmpty(); }
+    template <typename T> ValueType& operator[](T* name) const { return value_[name]; }
+    template <typename SourceAllocator> ValueType& operator[](const GenericValue<EncodingType, SourceAllocator>& name) const { return value_[name]; }
+#if RAPIDJSON_HAS_STDSTRING
+    ValueType& operator[](const std::basic_string<Ch>& name) const { return value_[name]; }
+#endif
+    MemberIterator MemberBegin() const { return value_.MemberBegin(); }
+    MemberIterator MemberEnd() const { return value_.MemberEnd(); }
+    bool HasMember(const Ch* name) const { return value_.HasMember(name); }
+#if RAPIDJSON_HAS_STDSTRING
+    bool HasMember(const std::basic_string<Ch>& name) const { return value_.HasMember(name); }
+#endif
+    template <typename SourceAllocator> bool HasMember(const GenericValue<EncodingType, SourceAllocator>& name) const { return value_.HasMember(name); }
+    MemberIterator FindMember(const Ch* name) const { return value_.FindMember(name); }
+    template <typename SourceAllocator> MemberIterator FindMember(const GenericValue<EncodingType, SourceAllocator>& name) const { return value_.FindMember(name); }
+#if RAPIDJSON_HAS_STDSTRING
+    MemberIterator FindMember(const std::basic_string<Ch>& name) const { return value_.FindMember(name); }
+#endif
+    GenericObject AddMember(ValueType& name, ValueType& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
+    GenericObject AddMember(ValueType& name, StringRefType value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
+#if RAPIDJSON_HAS_STDSTRING
+    GenericObject AddMember(ValueType& name, std::basic_string<Ch>& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
+#endif
+    template <typename T> RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType&)) AddMember(ValueType& name, T value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+    GenericObject AddMember(ValueType&& name, ValueType&& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
+    GenericObject AddMember(ValueType&& name, ValueType& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
+    GenericObject AddMember(ValueType& name, ValueType&& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
+    GenericObject AddMember(StringRefType name, ValueType&& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
+#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
+    GenericObject AddMember(StringRefType name, ValueType& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
+    GenericObject AddMember(StringRefType name, StringRefType value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
+    template <typename T> RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (GenericObject)) AddMember(StringRefType name, T value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
+    void RemoveAllMembers() { return value_.RemoveAllMembers(); }
+    bool RemoveMember(const Ch* name) const { return value_.RemoveMember(name); }
+#if RAPIDJSON_HAS_STDSTRING
+    bool RemoveMember(const std::basic_string<Ch>& name) const { return value_.RemoveMember(name); }
+#endif
+    template <typename SourceAllocator> bool RemoveMember(const GenericValue<EncodingType, SourceAllocator>& name) const { return value_.RemoveMember(name); }
+    MemberIterator RemoveMember(MemberIterator m) const { return value_.RemoveMember(m); }
+    MemberIterator EraseMember(ConstMemberIterator pos) const { return value_.EraseMember(pos); }
+    MemberIterator EraseMember(ConstMemberIterator first, ConstMemberIterator last) const { return value_.EraseMember(first, last); }
+    bool EraseMember(const Ch* name) const { return value_.EraseMember(name); }
+#if RAPIDJSON_HAS_STDSTRING
+    bool EraseMember(const std::basic_string<Ch>& name) const { return EraseMember(ValueType(StringRef(name))); }
+#endif
+    template <typename SourceAllocator> bool EraseMember(const GenericValue<EncodingType, SourceAllocator>& name) const { return value_.EraseMember(name); }
+
+#if RAPIDJSON_HAS_CXX11_RANGE_FOR
+    MemberIterator begin() const { return value_.MemberBegin(); }
+    MemberIterator end() const { return value_.MemberEnd(); }
+#endif
+
+private:
+    GenericObject();
+    GenericObject(ValueType& value) : value_(value) {}
+    ValueType& value_;
+};
+
+RAPIDJSON_NAMESPACE_END
+RAPIDJSON_DIAG_POP
+
+#endif // RAPIDJSON_DOCUMENT_H_
diff --git a/engine/inc/rapidjson/encodedstream.h b/engine/inc/rapidjson/encodedstream.h
new file mode 100644
index 00000000..14506838
--- /dev/null
+++ b/engine/inc/rapidjson/encodedstream.h
@@ -0,0 +1,299 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_ENCODEDSTREAM_H_
+#define RAPIDJSON_ENCODEDSTREAM_H_
+
+#include "stream.h"
+#include "memorystream.h"
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(effc++)
+#endif
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(padded)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Input byte stream wrapper with a statically bound encoding.
+/*!
+    \tparam Encoding The interpretation of encoding of the stream. Either UTF8, UTF16LE, UTF16BE, UTF32LE, UTF32BE.
+    \tparam InputByteStream Type of input byte stream. For example, FileReadStream.
+*/
+template <typename Encoding, typename InputByteStream>
+class EncodedInputStream {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+public:
+    typedef typename Encoding::Ch Ch;
+
+    EncodedInputStream(InputByteStream& is) : is_(is) { 
+        current_ = Encoding::TakeBOM(is_);
+    }
+
+    Ch Peek() const { return current_; }
+    Ch Take() { Ch c = current_; current_ = Encoding::Take(is_); return c; }
+    size_t Tell() const { return is_.Tell(); }
+
+    // Not implemented
+    void Put(Ch) { RAPIDJSON_ASSERT(false); }
+    void Flush() { RAPIDJSON_ASSERT(false); } 
+    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
+    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
+
+private:
+    EncodedInputStream(const EncodedInputStream&);
+    EncodedInputStream& operator=(const EncodedInputStream&);
+
+    InputByteStream& is_;
+    Ch current_;
+};
+
+//! Specialized for UTF8 MemoryStream.
+template <>
+class EncodedInputStream<UTF8<>, MemoryStream> {
+public:
+    typedef UTF8<>::Ch Ch;
+
+    EncodedInputStream(MemoryStream& is) : is_(is) {
+        if (static_cast<unsigned char>(is_.Peek()) == 0xEFu) is_.Take();
+        if (static_cast<unsigned char>(is_.Peek()) == 0xBBu) is_.Take();
+        if (static_cast<unsigned char>(is_.Peek()) == 0xBFu) is_.Take();
+    }
+    Ch Peek() const { return is_.Peek(); }
+    Ch Take() { return is_.Take(); }
+    size_t Tell() const { return is_.Tell(); }
+
+    // Not implemented
+    void Put(Ch) {}
+    void Flush() {} 
+    Ch* PutBegin() { return 0; }
+    size_t PutEnd(Ch*) { return 0; }
+
+    MemoryStream& is_;
+
+private:
+    EncodedInputStream(const EncodedInputStream&);
+    EncodedInputStream& operator=(const EncodedInputStream&);
+};
+
+//! Output byte stream wrapper with statically bound encoding.
+/*!
+    \tparam Encoding The interpretation of encoding of the stream. Either UTF8, UTF16LE, UTF16BE, UTF32LE, UTF32BE.
+    \tparam OutputByteStream Type of input byte stream. For example, FileWriteStream.
+*/
+template <typename Encoding, typename OutputByteStream>
+class EncodedOutputStream {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+public:
+    typedef typename Encoding::Ch Ch;
+
+    EncodedOutputStream(OutputByteStream& os, bool putBOM = true) : os_(os) { 
+        if (putBOM)
+            Encoding::PutBOM(os_);
+    }
+
+    void Put(Ch c) { Encoding::Put(os_, c);  }
+    void Flush() { os_.Flush(); }
+
+    // Not implemented
+    Ch Peek() const { RAPIDJSON_ASSERT(false); return 0;}
+    Ch Take() { RAPIDJSON_ASSERT(false); return 0;}
+    size_t Tell() const { RAPIDJSON_ASSERT(false);  return 0; }
+    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
+    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
+
+private:
+    EncodedOutputStream(const EncodedOutputStream&);
+    EncodedOutputStream& operator=(const EncodedOutputStream&);
+
+    OutputByteStream& os_;
+};
+
+#define RAPIDJSON_ENCODINGS_FUNC(x) UTF8<Ch>::x, UTF16LE<Ch>::x, UTF16BE<Ch>::x, UTF32LE<Ch>::x, UTF32BE<Ch>::x
+
+//! Input stream wrapper with dynamically bound encoding and automatic encoding detection.
+/*!
+    \tparam CharType Type of character for reading.
+    \tparam InputByteStream type of input byte stream to be wrapped.
+*/
+template <typename CharType, typename InputByteStream>
+class AutoUTFInputStream {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+public:
+    typedef CharType Ch;
+
+    //! Constructor.
+    /*!
+        \param is input stream to be wrapped.
+        \param type UTF encoding type if it is not detected from the stream.
+    */
+    AutoUTFInputStream(InputByteStream& is, UTFType type = kUTF8) : is_(&is), type_(type), hasBOM_(false) {
+        RAPIDJSON_ASSERT(type >= kUTF8 && type <= kUTF32BE);        
+        DetectType();
+        static const TakeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Take) };
+        takeFunc_ = f[type_];
+        current_ = takeFunc_(*is_);
+    }
+
+    UTFType GetType() const { return type_; }
+    bool HasBOM() const { return hasBOM_; }
+
+    Ch Peek() const { return current_; }
+    Ch Take() { Ch c = current_; current_ = takeFunc_(*is_); return c; }
+    size_t Tell() const { return is_->Tell(); }
+
+    // Not implemented
+    void Put(Ch) { RAPIDJSON_ASSERT(false); }
+    void Flush() { RAPIDJSON_ASSERT(false); } 
+    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
+    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
+
+private:
+    AutoUTFInputStream(const AutoUTFInputStream&);
+    AutoUTFInputStream& operator=(const AutoUTFInputStream&);
+
+    // Detect encoding type with BOM or RFC 4627
+    void DetectType() {
+        // BOM (Byte Order Mark):
+        // 00 00 FE FF  UTF-32BE
+        // FF FE 00 00  UTF-32LE
+        // FE FF        UTF-16BE
+        // FF FE        UTF-16LE
+        // EF BB BF     UTF-8
+
+        const unsigned char* c = reinterpret_cast<const unsigned char *>(is_->Peek4());
+        if (!c)
+            return;
+
+        unsigned bom = static_cast<unsigned>(c[0] | (c[1] << 8) | (c[2] << 16) | (c[3] << 24));
+        hasBOM_ = false;
+        if (bom == 0xFFFE0000)                  { type_ = kUTF32BE; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); is_->Take(); }
+        else if (bom == 0x0000FEFF)             { type_ = kUTF32LE; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); is_->Take(); }
+        else if ((bom & 0xFFFF) == 0xFFFE)      { type_ = kUTF16BE; hasBOM_ = true; is_->Take(); is_->Take();                           }
+        else if ((bom & 0xFFFF) == 0xFEFF)      { type_ = kUTF16LE; hasBOM_ = true; is_->Take(); is_->Take();                           }
+        else if ((bom & 0xFFFFFF) == 0xBFBBEF)  { type_ = kUTF8;    hasBOM_ = true; is_->Take(); is_->Take(); is_->Take();              }
+
+        // RFC 4627: Section 3
+        // "Since the first two characters of a JSON text will always be ASCII
+        // characters [RFC0020], it is possible to determine whether an octet
+        // stream is UTF-8, UTF-16 (BE or LE), or UTF-32 (BE or LE) by looking
+        // at the pattern of nulls in the first four octets."
+        // 00 00 00 xx  UTF-32BE
+        // 00 xx 00 xx  UTF-16BE
+        // xx 00 00 00  UTF-32LE
+        // xx 00 xx 00  UTF-16LE
+        // xx xx xx xx  UTF-8
+
+        if (!hasBOM_) {
+            unsigned pattern = (c[0] ? 1 : 0) | (c[1] ? 2 : 0) | (c[2] ? 4 : 0) | (c[3] ? 8 : 0);
+            switch (pattern) {
+            case 0x08: type_ = kUTF32BE; break;
+            case 0x0A: type_ = kUTF16BE; break;
+            case 0x01: type_ = kUTF32LE; break;
+            case 0x05: type_ = kUTF16LE; break;
+            case 0x0F: type_ = kUTF8;    break;
+            default: break; // Use type defined by user.
+            }
+        }
+
+        // Runtime check whether the size of character type is sufficient. It only perform checks with assertion.
+        if (type_ == kUTF16LE || type_ == kUTF16BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 2);
+        if (type_ == kUTF32LE || type_ == kUTF32BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 4);
+    }
+
+    typedef Ch (*TakeFunc)(InputByteStream& is);
+    InputByteStream* is_;
+    UTFType type_;
+    Ch current_;
+    TakeFunc takeFunc_;
+    bool hasBOM_;
+};
+
+//! Output stream wrapper with dynamically bound encoding and automatic encoding detection.
+/*!
+    \tparam CharType Type of character for writing.
+    \tparam OutputByteStream type of output byte stream to be wrapped.
+*/
+template <typename CharType, typename OutputByteStream>
+class AutoUTFOutputStream {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+public:
+    typedef CharType Ch;
+
+    //! Constructor.
+    /*!
+        \param os output stream to be wrapped.
+        \param type UTF encoding type.
+        \param putBOM Whether to write BOM at the beginning of the stream.
+    */
+    AutoUTFOutputStream(OutputByteStream& os, UTFType type, bool putBOM) : os_(&os), type_(type) {
+        RAPIDJSON_ASSERT(type >= kUTF8 && type <= kUTF32BE);
+
+        // Runtime check whether the size of character type is sufficient. It only perform checks with assertion.
+        if (type_ == kUTF16LE || type_ == kUTF16BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 2);
+        if (type_ == kUTF32LE || type_ == kUTF32BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 4);
+
+        static const PutFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Put) };
+        putFunc_ = f[type_];
+
+        if (putBOM)
+            PutBOM();
+    }
+
+    UTFType GetType() const { return type_; }
+
+    void Put(Ch c) { putFunc_(*os_, c); }
+    void Flush() { os_->Flush(); } 
+
+    // Not implemented
+    Ch Peek() const { RAPIDJSON_ASSERT(false); return 0;}
+    Ch Take() { RAPIDJSON_ASSERT(false); return 0;}
+    size_t Tell() const { RAPIDJSON_ASSERT(false); return 0; }
+    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
+    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
+
+private:
+    AutoUTFOutputStream(const AutoUTFOutputStream&);
+    AutoUTFOutputStream& operator=(const AutoUTFOutputStream&);
+
+    void PutBOM() { 
+        typedef void (*PutBOMFunc)(OutputByteStream&);
+        static const PutBOMFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(PutBOM) };
+        f[type_](*os_);
+    }
+
+    typedef void (*PutFunc)(OutputByteStream&, Ch);
+
+    OutputByteStream* os_;
+    UTFType type_;
+    PutFunc putFunc_;
+};
+
+#undef RAPIDJSON_ENCODINGS_FUNC
+
+RAPIDJSON_NAMESPACE_END
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_FILESTREAM_H_
diff --git a/engine/inc/rapidjson/encodings.h b/engine/inc/rapidjson/encodings.h
new file mode 100644
index 00000000..baa7c2b1
--- /dev/null
+++ b/engine/inc/rapidjson/encodings.h
@@ -0,0 +1,716 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_ENCODINGS_H_
+#define RAPIDJSON_ENCODINGS_H_
+
+#include "rapidjson.h"
+
+#ifdef _MSC_VER
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(4244) // conversion from 'type1' to 'type2', possible loss of data
+RAPIDJSON_DIAG_OFF(4702)  // unreachable code
+#elif defined(__GNUC__)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(effc++)
+RAPIDJSON_DIAG_OFF(overflow)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+// Encoding
+
+/*! \class rapidjson::Encoding
+    \brief Concept for encoding of Unicode characters.
+
+\code
+concept Encoding {
+    typename Ch;    //! Type of character. A "character" is actually a code unit in unicode's definition.
+
+    enum { supportUnicode = 1 }; // or 0 if not supporting unicode
+
+    //! \brief Encode a Unicode codepoint to an output stream.
+    //! \param os Output stream.
+    //! \param codepoint An unicode codepoint, ranging from 0x0 to 0x10FFFF inclusively.
+    template<typename OutputStream>
+    static void Encode(OutputStream& os, unsigned codepoint);
+
+    //! \brief Decode a Unicode codepoint from an input stream.
+    //! \param is Input stream.
+    //! \param codepoint Output of the unicode codepoint.
+    //! \return true if a valid codepoint can be decoded from the stream.
+    template <typename InputStream>
+    static bool Decode(InputStream& is, unsigned* codepoint);
+
+    //! \brief Validate one Unicode codepoint from an encoded stream.
+    //! \param is Input stream to obtain codepoint.
+    //! \param os Output for copying one codepoint.
+    //! \return true if it is valid.
+    //! \note This function just validating and copying the codepoint without actually decode it.
+    template <typename InputStream, typename OutputStream>
+    static bool Validate(InputStream& is, OutputStream& os);
+
+    // The following functions are deal with byte streams.
+
+    //! Take a character from input byte stream, skip BOM if exist.
+    template <typename InputByteStream>
+    static CharType TakeBOM(InputByteStream& is);
+
+    //! Take a character from input byte stream.
+    template <typename InputByteStream>
+    static Ch Take(InputByteStream& is);
+
+    //! Put BOM to output byte stream.
+    template <typename OutputByteStream>
+    static void PutBOM(OutputByteStream& os);
+
+    //! Put a character to output byte stream.
+    template <typename OutputByteStream>
+    static void Put(OutputByteStream& os, Ch c);
+};
+\endcode
+*/
+
+///////////////////////////////////////////////////////////////////////////////
+// UTF8
+
+//! UTF-8 encoding.
+/*! http://en.wikipedia.org/wiki/UTF-8
+    http://tools.ietf.org/html/rfc3629
+    \tparam CharType Code unit for storing 8-bit UTF-8 data. Default is char.
+    \note implements Encoding concept
+*/
+template<typename CharType = char>
+struct UTF8 {
+    typedef CharType Ch;
+
+    enum { supportUnicode = 1 };
+
+    template<typename OutputStream>
+    static void Encode(OutputStream& os, unsigned codepoint) {
+        if (codepoint <= 0x7F) 
+            os.Put(static_cast<Ch>(codepoint & 0xFF));
+        else if (codepoint <= 0x7FF) {
+            os.Put(static_cast<Ch>(0xC0 | ((codepoint >> 6) & 0xFF)));
+            os.Put(static_cast<Ch>(0x80 | ((codepoint & 0x3F))));
+        }
+        else if (codepoint <= 0xFFFF) {
+            os.Put(static_cast<Ch>(0xE0 | ((codepoint >> 12) & 0xFF)));
+            os.Put(static_cast<Ch>(0x80 | ((codepoint >> 6) & 0x3F)));
+            os.Put(static_cast<Ch>(0x80 | (codepoint & 0x3F)));
+        }
+        else {
+            RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
+            os.Put(static_cast<Ch>(0xF0 | ((codepoint >> 18) & 0xFF)));
+            os.Put(static_cast<Ch>(0x80 | ((codepoint >> 12) & 0x3F)));
+            os.Put(static_cast<Ch>(0x80 | ((codepoint >> 6) & 0x3F)));
+            os.Put(static_cast<Ch>(0x80 | (codepoint & 0x3F)));
+        }
+    }
+
+    template<typename OutputStream>
+    static void EncodeUnsafe(OutputStream& os, unsigned codepoint) {
+        if (codepoint <= 0x7F) 
+            PutUnsafe(os, static_cast<Ch>(codepoint & 0xFF));
+        else if (codepoint <= 0x7FF) {
+            PutUnsafe(os, static_cast<Ch>(0xC0 | ((codepoint >> 6) & 0xFF)));
+            PutUnsafe(os, static_cast<Ch>(0x80 | ((codepoint & 0x3F))));
+        }
+        else if (codepoint <= 0xFFFF) {
+            PutUnsafe(os, static_cast<Ch>(0xE0 | ((codepoint >> 12) & 0xFF)));
+            PutUnsafe(os, static_cast<Ch>(0x80 | ((codepoint >> 6) & 0x3F)));
+            PutUnsafe(os, static_cast<Ch>(0x80 | (codepoint & 0x3F)));
+        }
+        else {
+            RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
+            PutUnsafe(os, static_cast<Ch>(0xF0 | ((codepoint >> 18) & 0xFF)));
+            PutUnsafe(os, static_cast<Ch>(0x80 | ((codepoint >> 12) & 0x3F)));
+            PutUnsafe(os, static_cast<Ch>(0x80 | ((codepoint >> 6) & 0x3F)));
+            PutUnsafe(os, static_cast<Ch>(0x80 | (codepoint & 0x3F)));
+        }
+    }
+
+    template <typename InputStream>
+    static bool Decode(InputStream& is, unsigned* codepoint) {
+#define COPY() c = is.Take(); *codepoint = (*codepoint << 6) | (static_cast<unsigned char>(c) & 0x3Fu)
+#define TRANS(mask) result &= ((GetRange(static_cast<unsigned char>(c)) & mask) != 0)
+#define TAIL() COPY(); TRANS(0x70)
+        typename InputStream::Ch c = is.Take();
+        if (!(c & 0x80)) {
+            *codepoint = static_cast<unsigned char>(c);
+            return true;
+        }
+
+        unsigned char type = GetRange(static_cast<unsigned char>(c));
+        if (type >= 32) {
+            *codepoint = 0;
+        } else {
+            *codepoint = (0xFF >> type) & static_cast<unsigned char>(c);
+        }
+        bool result = true;
+        switch (type) {
+        case 2: TAIL(); return result;
+        case 3: TAIL(); TAIL(); return result;
+        case 4: COPY(); TRANS(0x50); TAIL(); return result;
+        case 5: COPY(); TRANS(0x10); TAIL(); TAIL(); return result;
+        case 6: TAIL(); TAIL(); TAIL(); return result;
+        case 10: COPY(); TRANS(0x20); TAIL(); return result;
+        case 11: COPY(); TRANS(0x60); TAIL(); TAIL(); return result;
+        default: return false;
+        }
+#undef COPY
+#undef TRANS
+#undef TAIL
+    }
+
+    template <typename InputStream, typename OutputStream>
+    static bool Validate(InputStream& is, OutputStream& os) {
+#define COPY() os.Put(c = is.Take())
+#define TRANS(mask) result &= ((GetRange(static_cast<unsigned char>(c)) & mask) != 0)
+#define TAIL() COPY(); TRANS(0x70)
+        Ch c;
+        COPY();
+        if (!(c & 0x80))
+            return true;
+
+        bool result = true;
+        switch (GetRange(static_cast<unsigned char>(c))) {
+        case 2: TAIL(); return result;
+        case 3: TAIL(); TAIL(); return result;
+        case 4: COPY(); TRANS(0x50); TAIL(); return result;
+        case 5: COPY(); TRANS(0x10); TAIL(); TAIL(); return result;
+        case 6: TAIL(); TAIL(); TAIL(); return result;
+        case 10: COPY(); TRANS(0x20); TAIL(); return result;
+        case 11: COPY(); TRANS(0x60); TAIL(); TAIL(); return result;
+        default: return false;
+        }
+#undef COPY
+#undef TRANS
+#undef TAIL
+    }
+
+    static unsigned char GetRange(unsigned char c) {
+        // Referring to DFA of http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
+        // With new mapping 1 -> 0x10, 7 -> 0x20, 9 -> 0x40, such that AND operation can test multiple types.
+        static const unsigned char type[] = {
+            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+            0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,
+            0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,
+            0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
+            0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
+            8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,  2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+            10,3,3,3,3,3,3,3,3,3,3,3,3,4,3,3, 11,6,6,6,5,8,8,8,8,8,8,8,8,8,8,8,
+        };
+        return type[c];
+    }
+
+    template <typename InputByteStream>
+    static CharType TakeBOM(InputByteStream& is) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+        typename InputByteStream::Ch c = Take(is);
+        if (static_cast<unsigned char>(c) != 0xEFu) return c;
+        c = is.Take();
+        if (static_cast<unsigned char>(c) != 0xBBu) return c;
+        c = is.Take();
+        if (static_cast<unsigned char>(c) != 0xBFu) return c;
+        c = is.Take();
+        return c;
+    }
+
+    template <typename InputByteStream>
+    static Ch Take(InputByteStream& is) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+        return static_cast<Ch>(is.Take());
+    }
+
+    template <typename OutputByteStream>
+    static void PutBOM(OutputByteStream& os) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+        os.Put(static_cast<typename OutputByteStream::Ch>(0xEFu));
+        os.Put(static_cast<typename OutputByteStream::Ch>(0xBBu));
+        os.Put(static_cast<typename OutputByteStream::Ch>(0xBFu));
+    }
+
+    template <typename OutputByteStream>
+    static void Put(OutputByteStream& os, Ch c) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+        os.Put(static_cast<typename OutputByteStream::Ch>(c));
+    }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// UTF16
+
+//! UTF-16 encoding.
+/*! http://en.wikipedia.org/wiki/UTF-16
+    http://tools.ietf.org/html/rfc2781
+    \tparam CharType Type for storing 16-bit UTF-16 data. Default is wchar_t. C++11 may use char16_t instead.
+    \note implements Encoding concept
+
+    \note For in-memory access, no need to concern endianness. The code units and code points are represented by CPU's endianness.
+    For streaming, use UTF16LE and UTF16BE, which handle endianness.
+*/
+template<typename CharType = wchar_t>
+struct UTF16 {
+    typedef CharType Ch;
+    RAPIDJSON_STATIC_ASSERT(sizeof(Ch) >= 2);
+
+    enum { supportUnicode = 1 };
+
+    template<typename OutputStream>
+    static void Encode(OutputStream& os, unsigned codepoint) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 2);
+        if (codepoint <= 0xFFFF) {
+            RAPIDJSON_ASSERT(codepoint < 0xD800 || codepoint > 0xDFFF); // Code point itself cannot be surrogate pair 
+            os.Put(static_cast<typename OutputStream::Ch>(codepoint));
+        }
+        else {
+            RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
+            unsigned v = codepoint - 0x10000;
+            os.Put(static_cast<typename OutputStream::Ch>((v >> 10) | 0xD800));
+            os.Put((v & 0x3FF) | 0xDC00);
+        }
+    }
+
+
+    template<typename OutputStream>
+    static void EncodeUnsafe(OutputStream& os, unsigned codepoint) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 2);
+        if (codepoint <= 0xFFFF) {
+            RAPIDJSON_ASSERT(codepoint < 0xD800 || codepoint > 0xDFFF); // Code point itself cannot be surrogate pair 
+            PutUnsafe(os, static_cast<typename OutputStream::Ch>(codepoint));
+        }
+        else {
+            RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
+            unsigned v = codepoint - 0x10000;
+            PutUnsafe(os, static_cast<typename OutputStream::Ch>((v >> 10) | 0xD800));
+            PutUnsafe(os, (v & 0x3FF) | 0xDC00);
+        }
+    }
+
+    template <typename InputStream>
+    static bool Decode(InputStream& is, unsigned* codepoint) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 2);
+        typename InputStream::Ch c = is.Take();
+        if (c < 0xD800 || c > 0xDFFF) {
+            *codepoint = static_cast<unsigned>(c);
+            return true;
+        }
+        else if (c <= 0xDBFF) {
+            *codepoint = (static_cast<unsigned>(c) & 0x3FF) << 10;
+            c = is.Take();
+            *codepoint |= (static_cast<unsigned>(c) & 0x3FF);
+            *codepoint += 0x10000;
+            return c >= 0xDC00 && c <= 0xDFFF;
+        }
+        return false;
+    }
+
+    template <typename InputStream, typename OutputStream>
+    static bool Validate(InputStream& is, OutputStream& os) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 2);
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 2);
+        typename InputStream::Ch c;
+        os.Put(static_cast<typename OutputStream::Ch>(c = is.Take()));
+        if (c < 0xD800 || c > 0xDFFF)
+            return true;
+        else if (c <= 0xDBFF) {
+            os.Put(c = is.Take());
+            return c >= 0xDC00 && c <= 0xDFFF;
+        }
+        return false;
+    }
+};
+
+//! UTF-16 little endian encoding.
+template<typename CharType = wchar_t>
+struct UTF16LE : UTF16<CharType> {
+    template <typename InputByteStream>
+    static CharType TakeBOM(InputByteStream& is) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+        CharType c = Take(is);
+        return static_cast<uint16_t>(c) == 0xFEFFu ? Take(is) : c;
+    }
+
+    template <typename InputByteStream>
+    static CharType Take(InputByteStream& is) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+        unsigned c = static_cast<uint8_t>(is.Take());
+        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 8;
+        return static_cast<CharType>(c);
+    }
+
+    template <typename OutputByteStream>
+    static void PutBOM(OutputByteStream& os) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+        os.Put(static_cast<typename OutputByteStream::Ch>(0xFFu));
+        os.Put(static_cast<typename OutputByteStream::Ch>(0xFEu));
+    }
+
+    template <typename OutputByteStream>
+    static void Put(OutputByteStream& os, CharType c) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+        os.Put(static_cast<typename OutputByteStream::Ch>(static_cast<unsigned>(c) & 0xFFu));
+        os.Put(static_cast<typename OutputByteStream::Ch>((static_cast<unsigned>(c) >> 8) & 0xFFu));
+    }
+};
+
+//! UTF-16 big endian encoding.
+template<typename CharType = wchar_t>
+struct UTF16BE : UTF16<CharType> {
+    template <typename InputByteStream>
+    static CharType TakeBOM(InputByteStream& is) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+        CharType c = Take(is);
+        return static_cast<uint16_t>(c) == 0xFEFFu ? Take(is) : c;
+    }
+
+    template <typename InputByteStream>
+    static CharType Take(InputByteStream& is) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+        unsigned c = static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 8;
+        c |= static_cast<uint8_t>(is.Take());
+        return static_cast<CharType>(c);
+    }
+
+    template <typename OutputByteStream>
+    static void PutBOM(OutputByteStream& os) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+        os.Put(static_cast<typename OutputByteStream::Ch>(0xFEu));
+        os.Put(static_cast<typename OutputByteStream::Ch>(0xFFu));
+    }
+
+    template <typename OutputByteStream>
+    static void Put(OutputByteStream& os, CharType c) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+        os.Put(static_cast<typename OutputByteStream::Ch>((static_cast<unsigned>(c) >> 8) & 0xFFu));
+        os.Put(static_cast<typename OutputByteStream::Ch>(static_cast<unsigned>(c) & 0xFFu));
+    }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// UTF32
+
+//! UTF-32 encoding. 
+/*! http://en.wikipedia.org/wiki/UTF-32
+    \tparam CharType Type for storing 32-bit UTF-32 data. Default is unsigned. C++11 may use char32_t instead.
+    \note implements Encoding concept
+
+    \note For in-memory access, no need to concern endianness. The code units and code points are represented by CPU's endianness.
+    For streaming, use UTF32LE and UTF32BE, which handle endianness.
+*/
+template<typename CharType = unsigned>
+struct UTF32 {
+    typedef CharType Ch;
+    RAPIDJSON_STATIC_ASSERT(sizeof(Ch) >= 4);
+
+    enum { supportUnicode = 1 };
+
+    template<typename OutputStream>
+    static void Encode(OutputStream& os, unsigned codepoint) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 4);
+        RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
+        os.Put(codepoint);
+    }
+
+    template<typename OutputStream>
+    static void EncodeUnsafe(OutputStream& os, unsigned codepoint) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 4);
+        RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
+        PutUnsafe(os, codepoint);
+    }
+
+    template <typename InputStream>
+    static bool Decode(InputStream& is, unsigned* codepoint) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 4);
+        Ch c = is.Take();
+        *codepoint = c;
+        return c <= 0x10FFFF;
+    }
+
+    template <typename InputStream, typename OutputStream>
+    static bool Validate(InputStream& is, OutputStream& os) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 4);
+        Ch c;
+        os.Put(c = is.Take());
+        return c <= 0x10FFFF;
+    }
+};
+
+//! UTF-32 little endian enocoding.
+template<typename CharType = unsigned>
+struct UTF32LE : UTF32<CharType> {
+    template <typename InputByteStream>
+    static CharType TakeBOM(InputByteStream& is) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+        CharType c = Take(is);
+        return static_cast<uint32_t>(c) == 0x0000FEFFu ? Take(is) : c;
+    }
+
+    template <typename InputByteStream>
+    static CharType Take(InputByteStream& is) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+        unsigned c = static_cast<uint8_t>(is.Take());
+        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 8;
+        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 16;
+        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 24;
+        return static_cast<CharType>(c);
+    }
+
+    template <typename OutputByteStream>
+    static void PutBOM(OutputByteStream& os) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+        os.Put(static_cast<typename OutputByteStream::Ch>(0xFFu));
+        os.Put(static_cast<typename OutputByteStream::Ch>(0xFEu));
+        os.Put(static_cast<typename OutputByteStream::Ch>(0x00u));
+        os.Put(static_cast<typename OutputByteStream::Ch>(0x00u));
+    }
+
+    template <typename OutputByteStream>
+    static void Put(OutputByteStream& os, CharType c) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+        os.Put(static_cast<typename OutputByteStream::Ch>(c & 0xFFu));
+        os.Put(static_cast<typename OutputByteStream::Ch>((c >> 8) & 0xFFu));
+        os.Put(static_cast<typename OutputByteStream::Ch>((c >> 16) & 0xFFu));
+        os.Put(static_cast<typename OutputByteStream::Ch>((c >> 24) & 0xFFu));
+    }
+};
+
+//! UTF-32 big endian encoding.
+template<typename CharType = unsigned>
+struct UTF32BE : UTF32<CharType> {
+    template <typename InputByteStream>
+    static CharType TakeBOM(InputByteStream& is) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+        CharType c = Take(is);
+        return static_cast<uint32_t>(c) == 0x0000FEFFu ? Take(is) : c; 
+    }
+
+    template <typename InputByteStream>
+    static CharType Take(InputByteStream& is) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+        unsigned c = static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 24;
+        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 16;
+        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 8;
+        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take()));
+        return static_cast<CharType>(c);
+    }
+
+    template <typename OutputByteStream>
+    static void PutBOM(OutputByteStream& os) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+        os.Put(static_cast<typename OutputByteStream::Ch>(0x00u));
+        os.Put(static_cast<typename OutputByteStream::Ch>(0x00u));
+        os.Put(static_cast<typename OutputByteStream::Ch>(0xFEu));
+        os.Put(static_cast<typename OutputByteStream::Ch>(0xFFu));
+    }
+
+    template <typename OutputByteStream>
+    static void Put(OutputByteStream& os, CharType c) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+        os.Put(static_cast<typename OutputByteStream::Ch>((c >> 24) & 0xFFu));
+        os.Put(static_cast<typename OutputByteStream::Ch>((c >> 16) & 0xFFu));
+        os.Put(static_cast<typename OutputByteStream::Ch>((c >> 8) & 0xFFu));
+        os.Put(static_cast<typename OutputByteStream::Ch>(c & 0xFFu));
+    }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// ASCII
+
+//! ASCII encoding.
+/*! http://en.wikipedia.org/wiki/ASCII
+    \tparam CharType Code unit for storing 7-bit ASCII data. Default is char.
+    \note implements Encoding concept
+*/
+template<typename CharType = char>
+struct ASCII {
+    typedef CharType Ch;
+
+    enum { supportUnicode = 0 };
+
+    template<typename OutputStream>
+    static void Encode(OutputStream& os, unsigned codepoint) {
+        RAPIDJSON_ASSERT(codepoint <= 0x7F);
+        os.Put(static_cast<Ch>(codepoint & 0xFF));
+    }
+
+    template<typename OutputStream>
+    static void EncodeUnsafe(OutputStream& os, unsigned codepoint) {
+        RAPIDJSON_ASSERT(codepoint <= 0x7F);
+        PutUnsafe(os, static_cast<Ch>(codepoint & 0xFF));
+    }
+
+    template <typename InputStream>
+    static bool Decode(InputStream& is, unsigned* codepoint) {
+        uint8_t c = static_cast<uint8_t>(is.Take());
+        *codepoint = c;
+        return c <= 0X7F;
+    }
+
+    template <typename InputStream, typename OutputStream>
+    static bool Validate(InputStream& is, OutputStream& os) {
+        uint8_t c = static_cast<uint8_t>(is.Take());
+        os.Put(static_cast<typename OutputStream::Ch>(c));
+        return c <= 0x7F;
+    }
+
+    template <typename InputByteStream>
+    static CharType TakeBOM(InputByteStream& is) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+        uint8_t c = static_cast<uint8_t>(Take(is));
+        return static_cast<Ch>(c);
+    }
+
+    template <typename InputByteStream>
+    static Ch Take(InputByteStream& is) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+        return static_cast<Ch>(is.Take());
+    }
+
+    template <typename OutputByteStream>
+    static void PutBOM(OutputByteStream& os) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+        (void)os;
+    }
+
+    template <typename OutputByteStream>
+    static void Put(OutputByteStream& os, Ch c) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+        os.Put(static_cast<typename OutputByteStream::Ch>(c));
+    }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// AutoUTF
+
+//! Runtime-specified UTF encoding type of a stream.
+enum UTFType {
+    kUTF8 = 0,      //!< UTF-8.
+    kUTF16LE = 1,   //!< UTF-16 little endian.
+    kUTF16BE = 2,   //!< UTF-16 big endian.
+    kUTF32LE = 3,   //!< UTF-32 little endian.
+    kUTF32BE = 4    //!< UTF-32 big endian.
+};
+
+//! Dynamically select encoding according to stream's runtime-specified UTF encoding type.
+/*! \note This class can be used with AutoUTFInputtStream and AutoUTFOutputStream, which provides GetType().
+*/
+template<typename CharType>
+struct AutoUTF {
+    typedef CharType Ch;
+
+    enum { supportUnicode = 1 };
+
+#define RAPIDJSON_ENCODINGS_FUNC(x) UTF8<Ch>::x, UTF16LE<Ch>::x, UTF16BE<Ch>::x, UTF32LE<Ch>::x, UTF32BE<Ch>::x
+
+    template<typename OutputStream>
+    RAPIDJSON_FORCEINLINE static void Encode(OutputStream& os, unsigned codepoint) {
+        typedef void (*EncodeFunc)(OutputStream&, unsigned);
+        static const EncodeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Encode) };
+        (*f[os.GetType()])(os, codepoint);
+    }
+
+    template<typename OutputStream>
+    RAPIDJSON_FORCEINLINE static void EncodeUnsafe(OutputStream& os, unsigned codepoint) {
+        typedef void (*EncodeFunc)(OutputStream&, unsigned);
+        static const EncodeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(EncodeUnsafe) };
+        (*f[os.GetType()])(os, codepoint);
+    }
+
+    template <typename InputStream>
+    RAPIDJSON_FORCEINLINE static bool Decode(InputStream& is, unsigned* codepoint) {
+        typedef bool (*DecodeFunc)(InputStream&, unsigned*);
+        static const DecodeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Decode) };
+        return (*f[is.GetType()])(is, codepoint);
+    }
+
+    template <typename InputStream, typename OutputStream>
+    RAPIDJSON_FORCEINLINE static bool Validate(InputStream& is, OutputStream& os) {
+        typedef bool (*ValidateFunc)(InputStream&, OutputStream&);
+        static const ValidateFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Validate) };
+        return (*f[is.GetType()])(is, os);
+    }
+
+#undef RAPIDJSON_ENCODINGS_FUNC
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// Transcoder
+
+//! Encoding conversion.
+template<typename SourceEncoding, typename TargetEncoding>
+struct Transcoder {
+    //! Take one Unicode codepoint from source encoding, convert it to target encoding and put it to the output stream.
+    template<typename InputStream, typename OutputStream>
+    RAPIDJSON_FORCEINLINE static bool Transcode(InputStream& is, OutputStream& os) {
+        unsigned codepoint;
+        if (!SourceEncoding::Decode(is, &codepoint))
+            return false;
+        TargetEncoding::Encode(os, codepoint);
+        return true;
+    }
+
+    template<typename InputStream, typename OutputStream>
+    RAPIDJSON_FORCEINLINE static bool TranscodeUnsafe(InputStream& is, OutputStream& os) {
+        unsigned codepoint;
+        if (!SourceEncoding::Decode(is, &codepoint))
+            return false;
+        TargetEncoding::EncodeUnsafe(os, codepoint);
+        return true;
+    }
+
+    //! Validate one Unicode codepoint from an encoded stream.
+    template<typename InputStream, typename OutputStream>
+    RAPIDJSON_FORCEINLINE static bool Validate(InputStream& is, OutputStream& os) {
+        return Transcode(is, os);   // Since source/target encoding is different, must transcode.
+    }
+};
+
+// Forward declaration.
+template<typename Stream>
+inline void PutUnsafe(Stream& stream, typename Stream::Ch c);
+
+//! Specialization of Transcoder with same source and target encoding.
+template<typename Encoding>
+struct Transcoder<Encoding, Encoding> {
+    template<typename InputStream, typename OutputStream>
+    RAPIDJSON_FORCEINLINE static bool Transcode(InputStream& is, OutputStream& os) {
+        os.Put(is.Take());  // Just copy one code unit. This semantic is different from primary template class.
+        return true;
+    }
+    
+    template<typename InputStream, typename OutputStream>
+    RAPIDJSON_FORCEINLINE static bool TranscodeUnsafe(InputStream& is, OutputStream& os) {
+        PutUnsafe(os, is.Take());  // Just copy one code unit. This semantic is different from primary template class.
+        return true;
+    }
+    
+    template<typename InputStream, typename OutputStream>
+    RAPIDJSON_FORCEINLINE static bool Validate(InputStream& is, OutputStream& os) {
+        return Encoding::Validate(is, os);  // source/target encoding are the same
+    }
+};
+
+RAPIDJSON_NAMESPACE_END
+
+#if defined(__GNUC__) || defined(_MSC_VER)
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_ENCODINGS_H_
diff --git a/engine/inc/rapidjson/error/en.h b/engine/inc/rapidjson/error/en.h
new file mode 100644
index 00000000..2db838bf
--- /dev/null
+++ b/engine/inc/rapidjson/error/en.h
@@ -0,0 +1,74 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_ERROR_EN_H_
+#define RAPIDJSON_ERROR_EN_H_
+
+#include "error.h"
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(switch-enum)
+RAPIDJSON_DIAG_OFF(covered-switch-default)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Maps error code of parsing into error message.
+/*!
+    \ingroup RAPIDJSON_ERRORS
+    \param parseErrorCode Error code obtained in parsing.
+    \return the error message.
+    \note User can make a copy of this function for localization.
+        Using switch-case is safer for future modification of error codes.
+*/
+inline const RAPIDJSON_ERROR_CHARTYPE* GetParseError_En(ParseErrorCode parseErrorCode) {
+    switch (parseErrorCode) {
+        case kParseErrorNone:                           return RAPIDJSON_ERROR_STRING("No error.");
+
+        case kParseErrorDocumentEmpty:                  return RAPIDJSON_ERROR_STRING("The document is empty.");
+        case kParseErrorDocumentRootNotSingular:        return RAPIDJSON_ERROR_STRING("The document root must not be followed by other values.");
+    
+        case kParseErrorValueInvalid:                   return RAPIDJSON_ERROR_STRING("Invalid value.");
+    
+        case kParseErrorObjectMissName:                 return RAPIDJSON_ERROR_STRING("Missing a name for object member.");
+        case kParseErrorObjectMissColon:                return RAPIDJSON_ERROR_STRING("Missing a colon after a name of object member.");
+        case kParseErrorObjectMissCommaOrCurlyBracket:  return RAPIDJSON_ERROR_STRING("Missing a comma or '}' after an object member.");
+    
+        case kParseErrorArrayMissCommaOrSquareBracket:  return RAPIDJSON_ERROR_STRING("Missing a comma or ']' after an array element.");
+
+        case kParseErrorStringUnicodeEscapeInvalidHex:  return RAPIDJSON_ERROR_STRING("Incorrect hex digit after \\u escape in string.");
+        case kParseErrorStringUnicodeSurrogateInvalid:  return RAPIDJSON_ERROR_STRING("The surrogate pair in string is invalid.");
+        case kParseErrorStringEscapeInvalid:            return RAPIDJSON_ERROR_STRING("Invalid escape character in string.");
+        case kParseErrorStringMissQuotationMark:        return RAPIDJSON_ERROR_STRING("Missing a closing quotation mark in string.");
+        case kParseErrorStringInvalidEncoding:          return RAPIDJSON_ERROR_STRING("Invalid encoding in string.");
+
+        case kParseErrorNumberTooBig:                   return RAPIDJSON_ERROR_STRING("Number too big to be stored in double.");
+        case kParseErrorNumberMissFraction:             return RAPIDJSON_ERROR_STRING("Miss fraction part in number.");
+        case kParseErrorNumberMissExponent:             return RAPIDJSON_ERROR_STRING("Miss exponent in number.");
+
+        case kParseErrorTermination:                    return RAPIDJSON_ERROR_STRING("Terminate parsing due to Handler error.");
+        case kParseErrorUnspecificSyntaxError:          return RAPIDJSON_ERROR_STRING("Unspecific syntax error.");
+
+        default:                                        return RAPIDJSON_ERROR_STRING("Unknown error.");
+    }
+}
+
+RAPIDJSON_NAMESPACE_END
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_ERROR_EN_H_
diff --git a/engine/inc/rapidjson/error/error.h b/engine/inc/rapidjson/error/error.h
new file mode 100644
index 00000000..95cb31a7
--- /dev/null
+++ b/engine/inc/rapidjson/error/error.h
@@ -0,0 +1,155 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_ERROR_ERROR_H_
+#define RAPIDJSON_ERROR_ERROR_H_
+
+#include "../rapidjson.h"
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(padded)
+#endif
+
+/*! \file error.h */
+
+/*! \defgroup RAPIDJSON_ERRORS RapidJSON error handling */
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_ERROR_CHARTYPE
+
+//! Character type of error messages.
+/*! \ingroup RAPIDJSON_ERRORS
+    The default character type is \c char.
+    On Windows, user can define this macro as \c TCHAR for supporting both
+    unicode/non-unicode settings.
+*/
+#ifndef RAPIDJSON_ERROR_CHARTYPE
+#define RAPIDJSON_ERROR_CHARTYPE char
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_ERROR_STRING
+
+//! Macro for converting string literial to \ref RAPIDJSON_ERROR_CHARTYPE[].
+/*! \ingroup RAPIDJSON_ERRORS
+    By default this conversion macro does nothing.
+    On Windows, user can define this macro as \c _T(x) for supporting both
+    unicode/non-unicode settings.
+*/
+#ifndef RAPIDJSON_ERROR_STRING
+#define RAPIDJSON_ERROR_STRING(x) x
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+// ParseErrorCode
+
+//! Error code of parsing.
+/*! \ingroup RAPIDJSON_ERRORS
+    \see GenericReader::Parse, GenericReader::GetParseErrorCode
+*/
+enum ParseErrorCode {
+    kParseErrorNone = 0,                        //!< No error.
+
+    kParseErrorDocumentEmpty,                   //!< The document is empty.
+    kParseErrorDocumentRootNotSingular,         //!< The document root must not follow by other values.
+
+    kParseErrorValueInvalid,                    //!< Invalid value.
+
+    kParseErrorObjectMissName,                  //!< Missing a name for object member.
+    kParseErrorObjectMissColon,                 //!< Missing a colon after a name of object member.
+    kParseErrorObjectMissCommaOrCurlyBracket,   //!< Missing a comma or '}' after an object member.
+
+    kParseErrorArrayMissCommaOrSquareBracket,   //!< Missing a comma or ']' after an array element.
+
+    kParseErrorStringUnicodeEscapeInvalidHex,   //!< Incorrect hex digit after \\u escape in string.
+    kParseErrorStringUnicodeSurrogateInvalid,   //!< The surrogate pair in string is invalid.
+    kParseErrorStringEscapeInvalid,             //!< Invalid escape character in string.
+    kParseErrorStringMissQuotationMark,         //!< Missing a closing quotation mark in string.
+    kParseErrorStringInvalidEncoding,           //!< Invalid encoding in string.
+
+    kParseErrorNumberTooBig,                    //!< Number too big to be stored in double.
+    kParseErrorNumberMissFraction,              //!< Miss fraction part in number.
+    kParseErrorNumberMissExponent,              //!< Miss exponent in number.
+
+    kParseErrorTermination,                     //!< Parsing was terminated.
+    kParseErrorUnspecificSyntaxError            //!< Unspecific syntax error.
+};
+
+//! Result of parsing (wraps ParseErrorCode)
+/*!
+    \ingroup RAPIDJSON_ERRORS
+    \code
+        Document doc;
+        ParseResult ok = doc.Parse("[42]");
+        if (!ok) {
+            fprintf(stderr, "JSON parse error: %s (%u)",
+                    GetParseError_En(ok.Code()), ok.Offset());
+            exit(EXIT_FAILURE);
+        }
+    \endcode
+    \see GenericReader::Parse, GenericDocument::Parse
+*/
+struct ParseResult {
+public:
+    //! Default constructor, no error.
+    ParseResult() : code_(kParseErrorNone), offset_(0) {}
+    //! Constructor to set an error.
+    ParseResult(ParseErrorCode code, size_t offset) : code_(code), offset_(offset) {}
+
+    //! Get the error code.
+    ParseErrorCode Code() const { return code_; }
+    //! Get the error offset, if \ref IsError(), 0 otherwise.
+    size_t Offset() const { return offset_; }
+
+    //! Conversion to \c bool, returns \c true, iff !\ref IsError().
+    operator bool() const { return !IsError(); }
+    //! Whether the result is an error.
+    bool IsError() const { return code_ != kParseErrorNone; }
+
+    bool operator==(const ParseResult& that) const { return code_ == that.code_; }
+    bool operator==(ParseErrorCode code) const { return code_ == code; }
+    friend bool operator==(ParseErrorCode code, const ParseResult & err) { return code == err.code_; }
+
+    //! Reset error code.
+    void Clear() { Set(kParseErrorNone); }
+    //! Update error code and offset.
+    void Set(ParseErrorCode code, size_t offset = 0) { code_ = code; offset_ = offset; }
+
+private:
+    ParseErrorCode code_;
+    size_t offset_;
+};
+
+//! Function pointer type of GetParseError().
+/*! \ingroup RAPIDJSON_ERRORS
+
+    This is the prototype for \c GetParseError_X(), where \c X is a locale.
+    User can dynamically change locale in runtime, e.g.:
+\code
+    GetParseErrorFunc GetParseError = GetParseError_En; // or whatever
+    const RAPIDJSON_ERROR_CHARTYPE* s = GetParseError(document.GetParseErrorCode());
+\endcode
+*/
+typedef const RAPIDJSON_ERROR_CHARTYPE* (*GetParseErrorFunc)(ParseErrorCode);
+
+RAPIDJSON_NAMESPACE_END
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_ERROR_ERROR_H_
diff --git a/engine/inc/rapidjson/filereadstream.h b/engine/inc/rapidjson/filereadstream.h
new file mode 100644
index 00000000..b56ea13b
--- /dev/null
+++ b/engine/inc/rapidjson/filereadstream.h
@@ -0,0 +1,99 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_FILEREADSTREAM_H_
+#define RAPIDJSON_FILEREADSTREAM_H_
+
+#include "stream.h"
+#include <cstdio>
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(padded)
+RAPIDJSON_DIAG_OFF(unreachable-code)
+RAPIDJSON_DIAG_OFF(missing-noreturn)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! File byte stream for input using fread().
+/*!
+    \note implements Stream concept
+*/
+class FileReadStream {
+public:
+    typedef char Ch;    //!< Character type (byte).
+
+    //! Constructor.
+    /*!
+        \param fp File pointer opened for read.
+        \param buffer user-supplied buffer.
+        \param bufferSize size of buffer in bytes. Must >=4 bytes.
+    */
+    FileReadStream(std::FILE* fp, char* buffer, size_t bufferSize) : fp_(fp), buffer_(buffer), bufferSize_(bufferSize), bufferLast_(0), current_(buffer_), readCount_(0), count_(0), eof_(false) { 
+        RAPIDJSON_ASSERT(fp_ != 0);
+        RAPIDJSON_ASSERT(bufferSize >= 4);
+        Read();
+    }
+
+    Ch Peek() const { return *current_; }
+    Ch Take() { Ch c = *current_; Read(); return c; }
+    size_t Tell() const { return count_ + static_cast<size_t>(current_ - buffer_); }
+
+    // Not implemented
+    void Put(Ch) { RAPIDJSON_ASSERT(false); }
+    void Flush() { RAPIDJSON_ASSERT(false); } 
+    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
+    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
+
+    // For encoding detection only.
+    const Ch* Peek4() const {
+        return (current_ + 4 <= bufferLast_) ? current_ : 0;
+    }
+
+private:
+    void Read() {
+        if (current_ < bufferLast_)
+            ++current_;
+        else if (!eof_) {
+            count_ += readCount_;
+            readCount_ = fread(buffer_, 1, bufferSize_, fp_);
+            bufferLast_ = buffer_ + readCount_ - 1;
+            current_ = buffer_;
+
+            if (readCount_ < bufferSize_) {
+                buffer_[readCount_] = '\0';
+                ++bufferLast_;
+                eof_ = true;
+            }
+        }
+    }
+
+    std::FILE* fp_;
+    Ch *buffer_;
+    size_t bufferSize_;
+    Ch *bufferLast_;
+    Ch *current_;
+    size_t readCount_;
+    size_t count_;  //!< Number of characters read
+    bool eof_;
+};
+
+RAPIDJSON_NAMESPACE_END
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_FILESTREAM_H_
diff --git a/engine/inc/rapidjson/filewritestream.h b/engine/inc/rapidjson/filewritestream.h
new file mode 100644
index 00000000..6378dd60
--- /dev/null
+++ b/engine/inc/rapidjson/filewritestream.h
@@ -0,0 +1,104 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_FILEWRITESTREAM_H_
+#define RAPIDJSON_FILEWRITESTREAM_H_
+
+#include "stream.h"
+#include <cstdio>
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(unreachable-code)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Wrapper of C file stream for input using fread().
+/*!
+    \note implements Stream concept
+*/
+class FileWriteStream {
+public:
+    typedef char Ch;    //!< Character type. Only support char.
+
+    FileWriteStream(std::FILE* fp, char* buffer, size_t bufferSize) : fp_(fp), buffer_(buffer), bufferEnd_(buffer + bufferSize), current_(buffer_) { 
+        RAPIDJSON_ASSERT(fp_ != 0);
+    }
+
+    void Put(char c) { 
+        if (current_ >= bufferEnd_)
+            Flush();
+
+        *current_++ = c;
+    }
+
+    void PutN(char c, size_t n) {
+        size_t avail = static_cast<size_t>(bufferEnd_ - current_);
+        while (n > avail) {
+            std::memset(current_, c, avail);
+            current_ += avail;
+            Flush();
+            n -= avail;
+            avail = static_cast<size_t>(bufferEnd_ - current_);
+        }
+
+        if (n > 0) {
+            std::memset(current_, c, n);
+            current_ += n;
+        }
+    }
+
+    void Flush() {
+        if (current_ != buffer_) {
+            size_t result = fwrite(buffer_, 1, static_cast<size_t>(current_ - buffer_), fp_);
+            if (result < static_cast<size_t>(current_ - buffer_)) {
+                // failure deliberately ignored at this time
+                // added to avoid warn_unused_result build errors
+            }
+            current_ = buffer_;
+        }
+    }
+
+    // Not implemented
+    char Peek() const { RAPIDJSON_ASSERT(false); return 0; }
+    char Take() { RAPIDJSON_ASSERT(false); return 0; }
+    size_t Tell() const { RAPIDJSON_ASSERT(false); return 0; }
+    char* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
+    size_t PutEnd(char*) { RAPIDJSON_ASSERT(false); return 0; }
+
+private:
+    // Prohibit copy constructor & assignment operator.
+    FileWriteStream(const FileWriteStream&);
+    FileWriteStream& operator=(const FileWriteStream&);
+
+    std::FILE* fp_;
+    char *buffer_;
+    char *bufferEnd_;
+    char *current_;
+};
+
+//! Implement specialized version of PutN() with memset() for better performance.
+template<>
+inline void PutN(FileWriteStream& stream, char c, size_t n) {
+    stream.PutN(c, n);
+}
+
+RAPIDJSON_NAMESPACE_END
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_FILESTREAM_H_
diff --git a/engine/inc/rapidjson/fwd.h b/engine/inc/rapidjson/fwd.h
new file mode 100644
index 00000000..e8104e84
--- /dev/null
+++ b/engine/inc/rapidjson/fwd.h
@@ -0,0 +1,151 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_FWD_H_
+#define RAPIDJSON_FWD_H_
+
+#include "rapidjson.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+// encodings.h
+
+template<typename CharType> struct UTF8;
+template<typename CharType> struct UTF16;
+template<typename CharType> struct UTF16BE;
+template<typename CharType> struct UTF16LE;
+template<typename CharType> struct UTF32;
+template<typename CharType> struct UTF32BE;
+template<typename CharType> struct UTF32LE;
+template<typename CharType> struct ASCII;
+template<typename CharType> struct AutoUTF;
+
+template<typename SourceEncoding, typename TargetEncoding>
+struct Transcoder;
+
+// allocators.h
+
+class CrtAllocator;
+
+template <typename BaseAllocator>
+class MemoryPoolAllocator;
+
+// stream.h
+
+template <typename Encoding>
+struct GenericStringStream;
+
+typedef GenericStringStream<UTF8<char> > StringStream;
+
+template <typename Encoding>
+struct GenericInsituStringStream;
+
+typedef GenericInsituStringStream<UTF8<char> > InsituStringStream;
+
+// stringbuffer.h
+
+template <typename Encoding, typename Allocator>
+class GenericStringBuffer;
+
+typedef GenericStringBuffer<UTF8<char>, CrtAllocator> StringBuffer;
+
+// filereadstream.h
+
+class FileReadStream;
+
+// filewritestream.h
+
+class FileWriteStream;
+
+// memorybuffer.h
+
+template <typename Allocator>
+struct GenericMemoryBuffer;
+
+typedef GenericMemoryBuffer<CrtAllocator> MemoryBuffer;
+
+// memorystream.h
+
+struct MemoryStream;
+
+// reader.h
+
+template<typename Encoding, typename Derived>
+struct BaseReaderHandler;
+
+template <typename SourceEncoding, typename TargetEncoding, typename StackAllocator>
+class GenericReader;
+
+typedef GenericReader<UTF8<char>, UTF8<char>, CrtAllocator> Reader;
+
+// writer.h
+
+template<typename OutputStream, typename SourceEncoding, typename TargetEncoding, typename StackAllocator, unsigned writeFlags>
+class Writer;
+
+// prettywriter.h
+
+template<typename OutputStream, typename SourceEncoding, typename TargetEncoding, typename StackAllocator, unsigned writeFlags>
+class PrettyWriter;
+
+// document.h
+
+template <typename Encoding, typename Allocator> 
+struct GenericMember;
+
+template <bool Const, typename Encoding, typename Allocator>
+class GenericMemberIterator;
+
+template<typename CharType>
+struct GenericStringRef;
+
+template <typename Encoding, typename Allocator> 
+class GenericValue;
+
+typedef GenericValue<UTF8<char>, MemoryPoolAllocator<CrtAllocator> > Value;
+
+template <typename Encoding, typename Allocator, typename StackAllocator>
+class GenericDocument;
+
+typedef GenericDocument<UTF8<char>, MemoryPoolAllocator<CrtAllocator>, CrtAllocator> Document;
+
+// pointer.h
+
+template <typename ValueType, typename Allocator>
+class GenericPointer;
+
+typedef GenericPointer<Value, CrtAllocator> Pointer;
+
+// schema.h
+
+template <typename SchemaDocumentType>
+class IGenericRemoteSchemaDocumentProvider;
+
+template <typename ValueT, typename Allocator>
+class GenericSchemaDocument;
+
+typedef GenericSchemaDocument<Value, CrtAllocator> SchemaDocument;
+typedef IGenericRemoteSchemaDocumentProvider<SchemaDocument> IRemoteSchemaDocumentProvider;
+
+template <
+    typename SchemaDocumentType,
+    typename OutputHandler,
+    typename StateAllocator>
+class GenericSchemaValidator;
+
+typedef GenericSchemaValidator<SchemaDocument, BaseReaderHandler<UTF8<char>, void>, CrtAllocator> SchemaValidator;
+
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_RAPIDJSONFWD_H_
diff --git a/engine/inc/rapidjson/internal/biginteger.h b/engine/inc/rapidjson/internal/biginteger.h
new file mode 100644
index 00000000..9d3e88c9
--- /dev/null
+++ b/engine/inc/rapidjson/internal/biginteger.h
@@ -0,0 +1,290 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_BIGINTEGER_H_
+#define RAPIDJSON_BIGINTEGER_H_
+
+#include "../rapidjson.h"
+
+#if defined(_MSC_VER) && defined(_M_AMD64)
+#include <intrin.h> // for _umul128
+#pragma intrinsic(_umul128)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal {
+
+class BigInteger {
+public:
+    typedef uint64_t Type;
+
+    BigInteger(const BigInteger& rhs) : count_(rhs.count_) {
+        std::memcpy(digits_, rhs.digits_, count_ * sizeof(Type));
+    }
+
+    explicit BigInteger(uint64_t u) : count_(1) {
+        digits_[0] = u;
+    }
+
+    BigInteger(const char* decimals, size_t length) : count_(1) {
+        RAPIDJSON_ASSERT(length > 0);
+        digits_[0] = 0;
+        size_t i = 0;
+        const size_t kMaxDigitPerIteration = 19;  // 2^64 = 18446744073709551616 > 10^19
+        while (length >= kMaxDigitPerIteration) {
+            AppendDecimal64(decimals + i, decimals + i + kMaxDigitPerIteration);
+            length -= kMaxDigitPerIteration;
+            i += kMaxDigitPerIteration;
+        }
+
+        if (length > 0)
+            AppendDecimal64(decimals + i, decimals + i + length);
+    }
+    
+    BigInteger& operator=(const BigInteger &rhs)
+    {
+        if (this != &rhs) {
+            count_ = rhs.count_;
+            std::memcpy(digits_, rhs.digits_, count_ * sizeof(Type));
+        }
+        return *this;
+    }
+    
+    BigInteger& operator=(uint64_t u) {
+        digits_[0] = u;            
+        count_ = 1;
+        return *this;
+    }
+
+    BigInteger& operator+=(uint64_t u) {
+        Type backup = digits_[0];
+        digits_[0] += u;
+        for (size_t i = 0; i < count_ - 1; i++) {
+            if (digits_[i] >= backup)
+                return *this; // no carry
+            backup = digits_[i + 1];
+            digits_[i + 1] += 1;
+        }
+
+        // Last carry
+        if (digits_[count_ - 1] < backup)
+            PushBack(1);
+
+        return *this;
+    }
+
+    BigInteger& operator*=(uint64_t u) {
+        if (u == 0) return *this = 0;
+        if (u == 1) return *this;
+        if (*this == 1) return *this = u;
+
+        uint64_t k = 0;
+        for (size_t i = 0; i < count_; i++) {
+            uint64_t hi;
+            digits_[i] = MulAdd64(digits_[i], u, k, &hi);
+            k = hi;
+        }
+        
+        if (k > 0)
+            PushBack(k);
+
+        return *this;
+    }
+
+    BigInteger& operator*=(uint32_t u) {
+        if (u == 0) return *this = 0;
+        if (u == 1) return *this;
+        if (*this == 1) return *this = u;
+
+        uint64_t k = 0;
+        for (size_t i = 0; i < count_; i++) {
+            const uint64_t c = digits_[i] >> 32;
+            const uint64_t d = digits_[i] & 0xFFFFFFFF;
+            const uint64_t uc = u * c;
+            const uint64_t ud = u * d;
+            const uint64_t p0 = ud + k;
+            const uint64_t p1 = uc + (p0 >> 32);
+            digits_[i] = (p0 & 0xFFFFFFFF) | (p1 << 32);
+            k = p1 >> 32;
+        }
+        
+        if (k > 0)
+            PushBack(k);
+
+        return *this;
+    }
+
+    BigInteger& operator<<=(size_t shift) {
+        if (IsZero() || shift == 0) return *this;
+
+        size_t offset = shift / kTypeBit;
+        size_t interShift = shift % kTypeBit;
+        RAPIDJSON_ASSERT(count_ + offset <= kCapacity);
+
+        if (interShift == 0) {
+            std::memmove(&digits_[count_ - 1 + offset], &digits_[count_ - 1], count_ * sizeof(Type));
+            count_ += offset;
+        }
+        else {
+            digits_[count_] = 0;
+            for (size_t i = count_; i > 0; i--)
+                digits_[i + offset] = (digits_[i] << interShift) | (digits_[i - 1] >> (kTypeBit - interShift));
+            digits_[offset] = digits_[0] << interShift;
+            count_ += offset;
+            if (digits_[count_])
+                count_++;
+        }
+
+        std::memset(digits_, 0, offset * sizeof(Type));
+
+        return *this;
+    }
+
+    bool operator==(const BigInteger& rhs) const {
+        return count_ == rhs.count_ && std::memcmp(digits_, rhs.digits_, count_ * sizeof(Type)) == 0;
+    }
+
+    bool operator==(const Type rhs) const {
+        return count_ == 1 && digits_[0] == rhs;
+    }
+
+    BigInteger& MultiplyPow5(unsigned exp) {
+        static const uint32_t kPow5[12] = {
+            5,
+            5 * 5,
+            5 * 5 * 5,
+            5 * 5 * 5 * 5,
+            5 * 5 * 5 * 5 * 5,
+            5 * 5 * 5 * 5 * 5 * 5,
+            5 * 5 * 5 * 5 * 5 * 5 * 5,
+            5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
+            5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
+            5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
+            5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
+            5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5
+        };
+        if (exp == 0) return *this;
+        for (; exp >= 27; exp -= 27) *this *= RAPIDJSON_UINT64_C2(0X6765C793, 0XFA10079D); // 5^27
+        for (; exp >= 13; exp -= 13) *this *= static_cast<uint32_t>(1220703125u); // 5^13
+        if (exp > 0)                 *this *= kPow5[exp - 1];
+        return *this;
+    }
+
+    // Compute absolute difference of this and rhs.
+    // Assume this != rhs
+    bool Difference(const BigInteger& rhs, BigInteger* out) const {
+        int cmp = Compare(rhs);
+        RAPIDJSON_ASSERT(cmp != 0);
+        const BigInteger *a, *b;  // Makes a > b
+        bool ret;
+        if (cmp < 0) { a = &rhs; b = this; ret = true; }
+        else         { a = this; b = &rhs; ret = false; }
+
+        Type borrow = 0;
+        for (size_t i = 0; i < a->count_; i++) {
+            Type d = a->digits_[i] - borrow;
+            if (i < b->count_)
+                d -= b->digits_[i];
+            borrow = (d > a->digits_[i]) ? 1 : 0;
+            out->digits_[i] = d;
+            if (d != 0)
+                out->count_ = i + 1;
+        }
+
+        return ret;
+    }
+
+    int Compare(const BigInteger& rhs) const {
+        if (count_ != rhs.count_)
+            return count_ < rhs.count_ ? -1 : 1;
+
+        for (size_t i = count_; i-- > 0;)
+            if (digits_[i] != rhs.digits_[i])
+                return digits_[i] < rhs.digits_[i] ? -1 : 1;
+
+        return 0;
+    }
+
+    size_t GetCount() const { return count_; }
+    Type GetDigit(size_t index) const { RAPIDJSON_ASSERT(index < count_); return digits_[index]; }
+    bool IsZero() const { return count_ == 1 && digits_[0] == 0; }
+
+private:
+    void AppendDecimal64(const char* begin, const char* end) {
+        uint64_t u = ParseUint64(begin, end);
+        if (IsZero())
+            *this = u;
+        else {
+            unsigned exp = static_cast<unsigned>(end - begin);
+            (MultiplyPow5(exp) <<= exp) += u;   // *this = *this * 10^exp + u
+        }
+    }
+
+    void PushBack(Type digit) {
+        RAPIDJSON_ASSERT(count_ < kCapacity);
+        digits_[count_++] = digit;
+    }
+
+    static uint64_t ParseUint64(const char* begin, const char* end) {
+        uint64_t r = 0;
+        for (const char* p = begin; p != end; ++p) {
+            RAPIDJSON_ASSERT(*p >= '0' && *p <= '9');
+            r = r * 10u + static_cast<unsigned>(*p - '0');
+        }
+        return r;
+    }
+
+    // Assume a * b + k < 2^128
+    static uint64_t MulAdd64(uint64_t a, uint64_t b, uint64_t k, uint64_t* outHigh) {
+#if defined(_MSC_VER) && defined(_M_AMD64)
+        uint64_t low = _umul128(a, b, outHigh) + k;
+        if (low < k)
+            (*outHigh)++;
+        return low;
+#elif (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__x86_64__)
+        __extension__ typedef unsigned __int128 uint128;
+        uint128 p = static_cast<uint128>(a) * static_cast<uint128>(b);
+        p += k;
+        *outHigh = static_cast<uint64_t>(p >> 64);
+        return static_cast<uint64_t>(p);
+#else
+        const uint64_t a0 = a & 0xFFFFFFFF, a1 = a >> 32, b0 = b & 0xFFFFFFFF, b1 = b >> 32;
+        uint64_t x0 = a0 * b0, x1 = a0 * b1, x2 = a1 * b0, x3 = a1 * b1;
+        x1 += (x0 >> 32); // can't give carry
+        x1 += x2;
+        if (x1 < x2)
+            x3 += (static_cast<uint64_t>(1) << 32);
+        uint64_t lo = (x1 << 32) + (x0 & 0xFFFFFFFF);
+        uint64_t hi = x3 + (x1 >> 32);
+
+        lo += k;
+        if (lo < k)
+            hi++;
+        *outHigh = hi;
+        return lo;
+#endif
+    }
+
+    static const size_t kBitCount = 3328;  // 64bit * 54 > 10^1000
+    static const size_t kCapacity = kBitCount / sizeof(Type);
+    static const size_t kTypeBit = sizeof(Type) * 8;
+
+    Type digits_[kCapacity];
+    size_t count_;
+};
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_BIGINTEGER_H_
diff --git a/engine/inc/rapidjson/internal/diyfp.h b/engine/inc/rapidjson/internal/diyfp.h
new file mode 100644
index 00000000..c9fefdc6
--- /dev/null
+++ b/engine/inc/rapidjson/internal/diyfp.h
@@ -0,0 +1,258 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+// This is a C++ header-only implementation of Grisu2 algorithm from the publication:
+// Loitsch, Florian. "Printing floating-point numbers quickly and accurately with
+// integers." ACM Sigplan Notices 45.6 (2010): 233-243.
+
+#ifndef RAPIDJSON_DIYFP_H_
+#define RAPIDJSON_DIYFP_H_
+
+#include "../rapidjson.h"
+
+#if defined(_MSC_VER) && defined(_M_AMD64)
+#include <intrin.h>
+#pragma intrinsic(_BitScanReverse64)
+#pragma intrinsic(_umul128)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal {
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(effc++)
+#endif
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(padded)
+#endif
+
+struct DiyFp {
+    DiyFp() : f(), e() {}
+
+    DiyFp(uint64_t fp, int exp) : f(fp), e(exp) {}
+
+    explicit DiyFp(double d) {
+        union {
+            double d;
+            uint64_t u64;
+        } u = { d };
+
+        int biased_e = static_cast<int>((u.u64 & kDpExponentMask) >> kDpSignificandSize);
+        uint64_t significand = (u.u64 & kDpSignificandMask);
+        if (biased_e != 0) {
+            f = significand + kDpHiddenBit;
+            e = biased_e - kDpExponentBias;
+        } 
+        else {
+            f = significand;
+            e = kDpMinExponent + 1;
+        }
+    }
+
+    DiyFp operator-(const DiyFp& rhs) const {
+        return DiyFp(f - rhs.f, e);
+    }
+
+    DiyFp operator*(const DiyFp& rhs) const {
+#if defined(_MSC_VER) && defined(_M_AMD64)
+        uint64_t h;
+        uint64_t l = _umul128(f, rhs.f, &h);
+        if (l & (uint64_t(1) << 63)) // rounding
+            h++;
+        return DiyFp(h, e + rhs.e + 64);
+#elif (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__x86_64__)
+        __extension__ typedef unsigned __int128 uint128;
+        uint128 p = static_cast<uint128>(f) * static_cast<uint128>(rhs.f);
+        uint64_t h = static_cast<uint64_t>(p >> 64);
+        uint64_t l = static_cast<uint64_t>(p);
+        if (l & (uint64_t(1) << 63)) // rounding
+            h++;
+        return DiyFp(h, e + rhs.e + 64);
+#else
+        const uint64_t M32 = 0xFFFFFFFF;
+        const uint64_t a = f >> 32;
+        const uint64_t b = f & M32;
+        const uint64_t c = rhs.f >> 32;
+        const uint64_t d = rhs.f & M32;
+        const uint64_t ac = a * c;
+        const uint64_t bc = b * c;
+        const uint64_t ad = a * d;
+        const uint64_t bd = b * d;
+        uint64_t tmp = (bd >> 32) + (ad & M32) + (bc & M32);
+        tmp += 1U << 31;  /// mult_round
+        return DiyFp(ac + (ad >> 32) + (bc >> 32) + (tmp >> 32), e + rhs.e + 64);
+#endif
+    }
+
+    DiyFp Normalize() const {
+#if defined(_MSC_VER) && defined(_M_AMD64)
+        unsigned long index;
+        _BitScanReverse64(&index, f);
+        return DiyFp(f << (63 - index), e - (63 - index));
+#elif defined(__GNUC__) && __GNUC__ >= 4
+        int s = __builtin_clzll(f);
+        return DiyFp(f << s, e - s);
+#else
+        DiyFp res = *this;
+        while (!(res.f & (static_cast<uint64_t>(1) << 63))) {
+            res.f <<= 1;
+            res.e--;
+        }
+        return res;
+#endif
+    }
+
+    DiyFp NormalizeBoundary() const {
+        DiyFp res = *this;
+        while (!(res.f & (kDpHiddenBit << 1))) {
+            res.f <<= 1;
+            res.e--;
+        }
+        res.f <<= (kDiySignificandSize - kDpSignificandSize - 2);
+        res.e = res.e - (kDiySignificandSize - kDpSignificandSize - 2);
+        return res;
+    }
+
+    void NormalizedBoundaries(DiyFp* minus, DiyFp* plus) const {
+        DiyFp pl = DiyFp((f << 1) + 1, e - 1).NormalizeBoundary();
+        DiyFp mi = (f == kDpHiddenBit) ? DiyFp((f << 2) - 1, e - 2) : DiyFp((f << 1) - 1, e - 1);
+        mi.f <<= mi.e - pl.e;
+        mi.e = pl.e;
+        *plus = pl;
+        *minus = mi;
+    }
+
+    double ToDouble() const {
+        union {
+            double d;
+            uint64_t u64;
+        }u;
+        const uint64_t be = (e == kDpDenormalExponent && (f & kDpHiddenBit) == 0) ? 0 : 
+            static_cast<uint64_t>(e + kDpExponentBias);
+        u.u64 = (f & kDpSignificandMask) | (be << kDpSignificandSize);
+        return u.d;
+    }
+
+    static const int kDiySignificandSize = 64;
+    static const int kDpSignificandSize = 52;
+    static const int kDpExponentBias = 0x3FF + kDpSignificandSize;
+    static const int kDpMaxExponent = 0x7FF - kDpExponentBias;
+    static const int kDpMinExponent = -kDpExponentBias;
+    static const int kDpDenormalExponent = -kDpExponentBias + 1;
+    static const uint64_t kDpExponentMask = RAPIDJSON_UINT64_C2(0x7FF00000, 0x00000000);
+    static const uint64_t kDpSignificandMask = RAPIDJSON_UINT64_C2(0x000FFFFF, 0xFFFFFFFF);
+    static const uint64_t kDpHiddenBit = RAPIDJSON_UINT64_C2(0x00100000, 0x00000000);
+
+    uint64_t f;
+    int e;
+};
+
+inline DiyFp GetCachedPowerByIndex(size_t index) {
+    // 10^-348, 10^-340, ..., 10^340
+    static const uint64_t kCachedPowers_F[] = {
+        RAPIDJSON_UINT64_C2(0xfa8fd5a0, 0x081c0288), RAPIDJSON_UINT64_C2(0xbaaee17f, 0xa23ebf76),
+        RAPIDJSON_UINT64_C2(0x8b16fb20, 0x3055ac76), RAPIDJSON_UINT64_C2(0xcf42894a, 0x5dce35ea),
+        RAPIDJSON_UINT64_C2(0x9a6bb0aa, 0x55653b2d), RAPIDJSON_UINT64_C2(0xe61acf03, 0x3d1a45df),
+        RAPIDJSON_UINT64_C2(0xab70fe17, 0xc79ac6ca), RAPIDJSON_UINT64_C2(0xff77b1fc, 0xbebcdc4f),
+        RAPIDJSON_UINT64_C2(0xbe5691ef, 0x416bd60c), RAPIDJSON_UINT64_C2(0x8dd01fad, 0x907ffc3c),
+        RAPIDJSON_UINT64_C2(0xd3515c28, 0x31559a83), RAPIDJSON_UINT64_C2(0x9d71ac8f, 0xada6c9b5),
+        RAPIDJSON_UINT64_C2(0xea9c2277, 0x23ee8bcb), RAPIDJSON_UINT64_C2(0xaecc4991, 0x4078536d),
+        RAPIDJSON_UINT64_C2(0x823c1279, 0x5db6ce57), RAPIDJSON_UINT64_C2(0xc2109436, 0x4dfb5637),
+        RAPIDJSON_UINT64_C2(0x9096ea6f, 0x3848984f), RAPIDJSON_UINT64_C2(0xd77485cb, 0x25823ac7),
+        RAPIDJSON_UINT64_C2(0xa086cfcd, 0x97bf97f4), RAPIDJSON_UINT64_C2(0xef340a98, 0x172aace5),
+        RAPIDJSON_UINT64_C2(0xb23867fb, 0x2a35b28e), RAPIDJSON_UINT64_C2(0x84c8d4df, 0xd2c63f3b),
+        RAPIDJSON_UINT64_C2(0xc5dd4427, 0x1ad3cdba), RAPIDJSON_UINT64_C2(0x936b9fce, 0xbb25c996),
+        RAPIDJSON_UINT64_C2(0xdbac6c24, 0x7d62a584), RAPIDJSON_UINT64_C2(0xa3ab6658, 0x0d5fdaf6),
+        RAPIDJSON_UINT64_C2(0xf3e2f893, 0xdec3f126), RAPIDJSON_UINT64_C2(0xb5b5ada8, 0xaaff80b8),
+        RAPIDJSON_UINT64_C2(0x87625f05, 0x6c7c4a8b), RAPIDJSON_UINT64_C2(0xc9bcff60, 0x34c13053),
+        RAPIDJSON_UINT64_C2(0x964e858c, 0x91ba2655), RAPIDJSON_UINT64_C2(0xdff97724, 0x70297ebd),
+        RAPIDJSON_UINT64_C2(0xa6dfbd9f, 0xb8e5b88f), RAPIDJSON_UINT64_C2(0xf8a95fcf, 0x88747d94),
+        RAPIDJSON_UINT64_C2(0xb9447093, 0x8fa89bcf), RAPIDJSON_UINT64_C2(0x8a08f0f8, 0xbf0f156b),
+        RAPIDJSON_UINT64_C2(0xcdb02555, 0x653131b6), RAPIDJSON_UINT64_C2(0x993fe2c6, 0xd07b7fac),
+        RAPIDJSON_UINT64_C2(0xe45c10c4, 0x2a2b3b06), RAPIDJSON_UINT64_C2(0xaa242499, 0x697392d3),
+        RAPIDJSON_UINT64_C2(0xfd87b5f2, 0x8300ca0e), RAPIDJSON_UINT64_C2(0xbce50864, 0x92111aeb),
+        RAPIDJSON_UINT64_C2(0x8cbccc09, 0x6f5088cc), RAPIDJSON_UINT64_C2(0xd1b71758, 0xe219652c),
+        RAPIDJSON_UINT64_C2(0x9c400000, 0x00000000), RAPIDJSON_UINT64_C2(0xe8d4a510, 0x00000000),
+        RAPIDJSON_UINT64_C2(0xad78ebc5, 0xac620000), RAPIDJSON_UINT64_C2(0x813f3978, 0xf8940984),
+        RAPIDJSON_UINT64_C2(0xc097ce7b, 0xc90715b3), RAPIDJSON_UINT64_C2(0x8f7e32ce, 0x7bea5c70),
+        RAPIDJSON_UINT64_C2(0xd5d238a4, 0xabe98068), RAPIDJSON_UINT64_C2(0x9f4f2726, 0x179a2245),
+        RAPIDJSON_UINT64_C2(0xed63a231, 0xd4c4fb27), RAPIDJSON_UINT64_C2(0xb0de6538, 0x8cc8ada8),
+        RAPIDJSON_UINT64_C2(0x83c7088e, 0x1aab65db), RAPIDJSON_UINT64_C2(0xc45d1df9, 0x42711d9a),
+        RAPIDJSON_UINT64_C2(0x924d692c, 0xa61be758), RAPIDJSON_UINT64_C2(0xda01ee64, 0x1a708dea),
+        RAPIDJSON_UINT64_C2(0xa26da399, 0x9aef774a), RAPIDJSON_UINT64_C2(0xf209787b, 0xb47d6b85),
+        RAPIDJSON_UINT64_C2(0xb454e4a1, 0x79dd1877), RAPIDJSON_UINT64_C2(0x865b8692, 0x5b9bc5c2),
+        RAPIDJSON_UINT64_C2(0xc83553c5, 0xc8965d3d), RAPIDJSON_UINT64_C2(0x952ab45c, 0xfa97a0b3),
+        RAPIDJSON_UINT64_C2(0xde469fbd, 0x99a05fe3), RAPIDJSON_UINT64_C2(0xa59bc234, 0xdb398c25),
+        RAPIDJSON_UINT64_C2(0xf6c69a72, 0xa3989f5c), RAPIDJSON_UINT64_C2(0xb7dcbf53, 0x54e9bece),
+        RAPIDJSON_UINT64_C2(0x88fcf317, 0xf22241e2), RAPIDJSON_UINT64_C2(0xcc20ce9b, 0xd35c78a5),
+        RAPIDJSON_UINT64_C2(0x98165af3, 0x7b2153df), RAPIDJSON_UINT64_C2(0xe2a0b5dc, 0x971f303a),
+        RAPIDJSON_UINT64_C2(0xa8d9d153, 0x5ce3b396), RAPIDJSON_UINT64_C2(0xfb9b7cd9, 0xa4a7443c),
+        RAPIDJSON_UINT64_C2(0xbb764c4c, 0xa7a44410), RAPIDJSON_UINT64_C2(0x8bab8eef, 0xb6409c1a),
+        RAPIDJSON_UINT64_C2(0xd01fef10, 0xa657842c), RAPIDJSON_UINT64_C2(0x9b10a4e5, 0xe9913129),
+        RAPIDJSON_UINT64_C2(0xe7109bfb, 0xa19c0c9d), RAPIDJSON_UINT64_C2(0xac2820d9, 0x623bf429),
+        RAPIDJSON_UINT64_C2(0x80444b5e, 0x7aa7cf85), RAPIDJSON_UINT64_C2(0xbf21e440, 0x03acdd2d),
+        RAPIDJSON_UINT64_C2(0x8e679c2f, 0x5e44ff8f), RAPIDJSON_UINT64_C2(0xd433179d, 0x9c8cb841),
+        RAPIDJSON_UINT64_C2(0x9e19db92, 0xb4e31ba9), RAPIDJSON_UINT64_C2(0xeb96bf6e, 0xbadf77d9),
+        RAPIDJSON_UINT64_C2(0xaf87023b, 0x9bf0ee6b)
+    };
+    static const int16_t kCachedPowers_E[] = {
+        -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007,  -980,
+        -954,  -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,
+        -688,  -661,  -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,
+        -422,  -396,  -369,  -343,  -316,  -289,  -263,  -236,  -210,  -183,
+        -157,  -130,  -103,   -77,   -50,   -24,     3,    30,    56,    83,
+        109,   136,   162,   189,   216,   242,   269,   295,   322,   348,
+        375,   402,   428,   455,   481,   508,   534,   561,   588,   614,
+        641,   667,   694,   720,   747,   774,   800,   827,   853,   880,
+        907,   933,   960,   986,  1013,  1039,  1066
+    };
+    return DiyFp(kCachedPowers_F[index], kCachedPowers_E[index]);
+}
+    
+inline DiyFp GetCachedPower(int e, int* K) {
+
+    //int k = static_cast<int>(ceil((-61 - e) * 0.30102999566398114)) + 374;
+    double dk = (-61 - e) * 0.30102999566398114 + 347;  // dk must be positive, so can do ceiling in positive
+    int k = static_cast<int>(dk);
+    if (dk - k > 0.0)
+        k++;
+
+    unsigned index = static_cast<unsigned>((k >> 3) + 1);
+    *K = -(-348 + static_cast<int>(index << 3));    // decimal exponent no need lookup table
+
+    return GetCachedPowerByIndex(index);
+}
+
+inline DiyFp GetCachedPower10(int exp, int *outExp) {
+     unsigned index = (static_cast<unsigned>(exp) + 348u) / 8u;
+     *outExp = -348 + static_cast<int>(index) * 8;
+     return GetCachedPowerByIndex(index);
+ }
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_POP
+#endif
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+RAPIDJSON_DIAG_OFF(padded)
+#endif
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_DIYFP_H_
diff --git a/engine/inc/rapidjson/internal/dtoa.h b/engine/inc/rapidjson/internal/dtoa.h
new file mode 100644
index 00000000..8d6350e6
--- /dev/null
+++ b/engine/inc/rapidjson/internal/dtoa.h
@@ -0,0 +1,245 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+// This is a C++ header-only implementation of Grisu2 algorithm from the publication:
+// Loitsch, Florian. "Printing floating-point numbers quickly and accurately with
+// integers." ACM Sigplan Notices 45.6 (2010): 233-243.
+
+#ifndef RAPIDJSON_DTOA_
+#define RAPIDJSON_DTOA_
+
+#include "itoa.h" // GetDigitsLut()
+#include "diyfp.h"
+#include "ieee754.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal {
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(effc++)
+RAPIDJSON_DIAG_OFF(array-bounds) // some gcc versions generate wrong warnings https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59124
+#endif
+
+inline void GrisuRound(char* buffer, int len, uint64_t delta, uint64_t rest, uint64_t ten_kappa, uint64_t wp_w) {
+    while (rest < wp_w && delta - rest >= ten_kappa &&
+           (rest + ten_kappa < wp_w ||  /// closer
+            wp_w - rest > rest + ten_kappa - wp_w)) {
+        buffer[len - 1]--;
+        rest += ten_kappa;
+    }
+}
+
+inline unsigned CountDecimalDigit32(uint32_t n) {
+    // Simple pure C++ implementation was faster than __builtin_clz version in this situation.
+    if (n < 10) return 1;
+    if (n < 100) return 2;
+    if (n < 1000) return 3;
+    if (n < 10000) return 4;
+    if (n < 100000) return 5;
+    if (n < 1000000) return 6;
+    if (n < 10000000) return 7;
+    if (n < 100000000) return 8;
+    // Will not reach 10 digits in DigitGen()
+    //if (n < 1000000000) return 9;
+    //return 10;
+    return 9;
+}
+
+inline void DigitGen(const DiyFp& W, const DiyFp& Mp, uint64_t delta, char* buffer, int* len, int* K) {
+    static const uint32_t kPow10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 };
+    const DiyFp one(uint64_t(1) << -Mp.e, Mp.e);
+    const DiyFp wp_w = Mp - W;
+    uint32_t p1 = static_cast<uint32_t>(Mp.f >> -one.e);
+    uint64_t p2 = Mp.f & (one.f - 1);
+    unsigned kappa = CountDecimalDigit32(p1); // kappa in [0, 9]
+    *len = 0;
+
+    while (kappa > 0) {
+        uint32_t d = 0;
+        switch (kappa) {
+            case  9: d = p1 /  100000000; p1 %=  100000000; break;
+            case  8: d = p1 /   10000000; p1 %=   10000000; break;
+            case  7: d = p1 /    1000000; p1 %=    1000000; break;
+            case  6: d = p1 /     100000; p1 %=     100000; break;
+            case  5: d = p1 /      10000; p1 %=      10000; break;
+            case  4: d = p1 /       1000; p1 %=       1000; break;
+            case  3: d = p1 /        100; p1 %=        100; break;
+            case  2: d = p1 /         10; p1 %=         10; break;
+            case  1: d = p1;              p1 =           0; break;
+            default:;
+        }
+        if (d || *len)
+            buffer[(*len)++] = static_cast<char>('0' + static_cast<char>(d));
+        kappa--;
+        uint64_t tmp = (static_cast<uint64_t>(p1) << -one.e) + p2;
+        if (tmp <= delta) {
+            *K += kappa;
+            GrisuRound(buffer, *len, delta, tmp, static_cast<uint64_t>(kPow10[kappa]) << -one.e, wp_w.f);
+            return;
+        }
+    }
+
+    // kappa = 0
+    for (;;) {
+        p2 *= 10;
+        delta *= 10;
+        char d = static_cast<char>(p2 >> -one.e);
+        if (d || *len)
+            buffer[(*len)++] = static_cast<char>('0' + d);
+        p2 &= one.f - 1;
+        kappa--;
+        if (p2 < delta) {
+            *K += kappa;
+            int index = -static_cast<int>(kappa);
+            GrisuRound(buffer, *len, delta, p2, one.f, wp_w.f * (index < 9 ? kPow10[-static_cast<int>(kappa)] : 0));
+            return;
+        }
+    }
+}
+
+inline void Grisu2(double value, char* buffer, int* length, int* K) {
+    const DiyFp v(value);
+    DiyFp w_m, w_p;
+    v.NormalizedBoundaries(&w_m, &w_p);
+
+    const DiyFp c_mk = GetCachedPower(w_p.e, K);
+    const DiyFp W = v.Normalize() * c_mk;
+    DiyFp Wp = w_p * c_mk;
+    DiyFp Wm = w_m * c_mk;
+    Wm.f++;
+    Wp.f--;
+    DigitGen(W, Wp, Wp.f - Wm.f, buffer, length, K);
+}
+
+inline char* WriteExponent(int K, char* buffer) {
+    if (K < 0) {
+        *buffer++ = '-';
+        K = -K;
+    }
+
+    if (K >= 100) {
+        *buffer++ = static_cast<char>('0' + static_cast<char>(K / 100));
+        K %= 100;
+        const char* d = GetDigitsLut() + K * 2;
+        *buffer++ = d[0];
+        *buffer++ = d[1];
+    }
+    else if (K >= 10) {
+        const char* d = GetDigitsLut() + K * 2;
+        *buffer++ = d[0];
+        *buffer++ = d[1];
+    }
+    else
+        *buffer++ = static_cast<char>('0' + static_cast<char>(K));
+
+    return buffer;
+}
+
+inline char* Prettify(char* buffer, int length, int k, int maxDecimalPlaces) {
+    const int kk = length + k;  // 10^(kk-1) <= v < 10^kk
+
+    if (0 <= k && kk <= 21) {
+        // 1234e7 -> 12340000000
+        for (int i = length; i < kk; i++)
+            buffer[i] = '0';
+        buffer[kk] = '.';
+        buffer[kk + 1] = '0';
+        return &buffer[kk + 2];
+    }
+    else if (0 < kk && kk <= 21) {
+        // 1234e-2 -> 12.34
+        std::memmove(&buffer[kk + 1], &buffer[kk], static_cast<size_t>(length - kk));
+        buffer[kk] = '.';
+        if (0 > k + maxDecimalPlaces) {
+            // When maxDecimalPlaces = 2, 1.2345 -> 1.23, 1.102 -> 1.1
+            // Remove extra trailing zeros (at least one) after truncation.
+            for (int i = kk + maxDecimalPlaces; i > kk + 1; i--)
+                if (buffer[i] != '0')
+                    return &buffer[i + 1];
+            return &buffer[kk + 2]; // Reserve one zero
+        }
+        else
+            return &buffer[length + 1];
+    }
+    else if (-6 < kk && kk <= 0) {
+        // 1234e-6 -> 0.001234
+        const int offset = 2 - kk;
+        std::memmove(&buffer[offset], &buffer[0], static_cast<size_t>(length));
+        buffer[0] = '0';
+        buffer[1] = '.';
+        for (int i = 2; i < offset; i++)
+            buffer[i] = '0';
+        if (length - kk > maxDecimalPlaces) {
+            // When maxDecimalPlaces = 2, 0.123 -> 0.12, 0.102 -> 0.1
+            // Remove extra trailing zeros (at least one) after truncation.
+            for (int i = maxDecimalPlaces + 1; i > 2; i--)
+                if (buffer[i] != '0')
+                    return &buffer[i + 1];
+            return &buffer[3]; // Reserve one zero
+        }
+        else
+            return &buffer[length + offset];
+    }
+    else if (kk < -maxDecimalPlaces) {
+        // Truncate to zero
+        buffer[0] = '0';
+        buffer[1] = '.';
+        buffer[2] = '0';
+        return &buffer[3];
+    }
+    else if (length == 1) {
+        // 1e30
+        buffer[1] = 'e';
+        return WriteExponent(kk - 1, &buffer[2]);
+    }
+    else {
+        // 1234e30 -> 1.234e33
+        std::memmove(&buffer[2], &buffer[1], static_cast<size_t>(length - 1));
+        buffer[1] = '.';
+        buffer[length + 1] = 'e';
+        return WriteExponent(kk - 1, &buffer[0 + length + 2]);
+    }
+}
+
+inline char* dtoa(double value, char* buffer, int maxDecimalPlaces = 324) {
+    RAPIDJSON_ASSERT(maxDecimalPlaces >= 1);
+    Double d(value);
+    if (d.IsZero()) {
+        if (d.Sign())
+            *buffer++ = '-';     // -0.0, Issue #289
+        buffer[0] = '0';
+        buffer[1] = '.';
+        buffer[2] = '0';
+        return &buffer[3];
+    }
+    else {
+        if (value < 0) {
+            *buffer++ = '-';
+            value = -value;
+        }
+        int length, K;
+        Grisu2(value, buffer, &length, &K);
+        return Prettify(buffer, length, K, maxDecimalPlaces);
+    }
+}
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_POP
+#endif
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_DTOA_
diff --git a/engine/inc/rapidjson/internal/ieee754.h b/engine/inc/rapidjson/internal/ieee754.h
new file mode 100644
index 00000000..82bb0b99
--- /dev/null
+++ b/engine/inc/rapidjson/internal/ieee754.h
@@ -0,0 +1,78 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_IEEE754_
+#define RAPIDJSON_IEEE754_
+
+#include "../rapidjson.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal {
+
+class Double {
+public:
+    Double() {}
+    Double(double d) : d_(d) {}
+    Double(uint64_t u) : u_(u) {}
+
+    double Value() const { return d_; }
+    uint64_t Uint64Value() const { return u_; }
+
+    double NextPositiveDouble() const {
+        RAPIDJSON_ASSERT(!Sign());
+        return Double(u_ + 1).Value();
+    }
+
+    bool Sign() const { return (u_ & kSignMask) != 0; }
+    uint64_t Significand() const { return u_ & kSignificandMask; }
+    int Exponent() const { return static_cast<int>(((u_ & kExponentMask) >> kSignificandSize) - kExponentBias); }
+
+    bool IsNan() const { return (u_ & kExponentMask) == kExponentMask && Significand() != 0; }
+    bool IsInf() const { return (u_ & kExponentMask) == kExponentMask && Significand() == 0; }
+    bool IsNanOrInf() const { return (u_ & kExponentMask) == kExponentMask; }
+    bool IsNormal() const { return (u_ & kExponentMask) != 0 || Significand() == 0; }
+    bool IsZero() const { return (u_ & (kExponentMask | kSignificandMask)) == 0; }
+
+    uint64_t IntegerSignificand() const { return IsNormal() ? Significand() | kHiddenBit : Significand(); }
+    int IntegerExponent() const { return (IsNormal() ? Exponent() : kDenormalExponent) - kSignificandSize; }
+    uint64_t ToBias() const { return (u_ & kSignMask) ? ~u_ + 1 : u_ | kSignMask; }
+
+    static unsigned EffectiveSignificandSize(int order) {
+        if (order >= -1021)
+            return 53;
+        else if (order <= -1074)
+            return 0;
+        else
+            return static_cast<unsigned>(order) + 1074;
+    }
+
+private:
+    static const int kSignificandSize = 52;
+    static const int kExponentBias = 0x3FF;
+    static const int kDenormalExponent = 1 - kExponentBias;
+    static const uint64_t kSignMask = RAPIDJSON_UINT64_C2(0x80000000, 0x00000000);
+    static const uint64_t kExponentMask = RAPIDJSON_UINT64_C2(0x7FF00000, 0x00000000);
+    static const uint64_t kSignificandMask = RAPIDJSON_UINT64_C2(0x000FFFFF, 0xFFFFFFFF);
+    static const uint64_t kHiddenBit = RAPIDJSON_UINT64_C2(0x00100000, 0x00000000);
+
+    union {
+        double d_;
+        uint64_t u_;
+    };
+};
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_IEEE754_
diff --git a/engine/inc/rapidjson/internal/itoa.h b/engine/inc/rapidjson/internal/itoa.h
new file mode 100644
index 00000000..01a4e7e7
--- /dev/null
+++ b/engine/inc/rapidjson/internal/itoa.h
@@ -0,0 +1,304 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_ITOA_
+#define RAPIDJSON_ITOA_
+
+#include "../rapidjson.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal {
+
+inline const char* GetDigitsLut() {
+    static const char cDigitsLut[200] = {
+        '0','0','0','1','0','2','0','3','0','4','0','5','0','6','0','7','0','8','0','9',
+        '1','0','1','1','1','2','1','3','1','4','1','5','1','6','1','7','1','8','1','9',
+        '2','0','2','1','2','2','2','3','2','4','2','5','2','6','2','7','2','8','2','9',
+        '3','0','3','1','3','2','3','3','3','4','3','5','3','6','3','7','3','8','3','9',
+        '4','0','4','1','4','2','4','3','4','4','4','5','4','6','4','7','4','8','4','9',
+        '5','0','5','1','5','2','5','3','5','4','5','5','5','6','5','7','5','8','5','9',
+        '6','0','6','1','6','2','6','3','6','4','6','5','6','6','6','7','6','8','6','9',
+        '7','0','7','1','7','2','7','3','7','4','7','5','7','6','7','7','7','8','7','9',
+        '8','0','8','1','8','2','8','3','8','4','8','5','8','6','8','7','8','8','8','9',
+        '9','0','9','1','9','2','9','3','9','4','9','5','9','6','9','7','9','8','9','9'
+    };
+    return cDigitsLut;
+}
+
+inline char* u32toa(uint32_t value, char* buffer) {
+    const char* cDigitsLut = GetDigitsLut();
+
+    if (value < 10000) {
+        const uint32_t d1 = (value / 100) << 1;
+        const uint32_t d2 = (value % 100) << 1;
+        
+        if (value >= 1000)
+            *buffer++ = cDigitsLut[d1];
+        if (value >= 100)
+            *buffer++ = cDigitsLut[d1 + 1];
+        if (value >= 10)
+            *buffer++ = cDigitsLut[d2];
+        *buffer++ = cDigitsLut[d2 + 1];
+    }
+    else if (value < 100000000) {
+        // value = bbbbcccc
+        const uint32_t b = value / 10000;
+        const uint32_t c = value % 10000;
+        
+        const uint32_t d1 = (b / 100) << 1;
+        const uint32_t d2 = (b % 100) << 1;
+        
+        const uint32_t d3 = (c / 100) << 1;
+        const uint32_t d4 = (c % 100) << 1;
+        
+        if (value >= 10000000)
+            *buffer++ = cDigitsLut[d1];
+        if (value >= 1000000)
+            *buffer++ = cDigitsLut[d1 + 1];
+        if (value >= 100000)
+            *buffer++ = cDigitsLut[d2];
+        *buffer++ = cDigitsLut[d2 + 1];
+        
+        *buffer++ = cDigitsLut[d3];
+        *buffer++ = cDigitsLut[d3 + 1];
+        *buffer++ = cDigitsLut[d4];
+        *buffer++ = cDigitsLut[d4 + 1];
+    }
+    else {
+        // value = aabbbbcccc in decimal
+        
+        const uint32_t a = value / 100000000; // 1 to 42
+        value %= 100000000;
+        
+        if (a >= 10) {
+            const unsigned i = a << 1;
+            *buffer++ = cDigitsLut[i];
+            *buffer++ = cDigitsLut[i + 1];
+        }
+        else
+            *buffer++ = static_cast<char>('0' + static_cast<char>(a));
+
+        const uint32_t b = value / 10000; // 0 to 9999
+        const uint32_t c = value % 10000; // 0 to 9999
+        
+        const uint32_t d1 = (b / 100) << 1;
+        const uint32_t d2 = (b % 100) << 1;
+        
+        const uint32_t d3 = (c / 100) << 1;
+        const uint32_t d4 = (c % 100) << 1;
+        
+        *buffer++ = cDigitsLut[d1];
+        *buffer++ = cDigitsLut[d1 + 1];
+        *buffer++ = cDigitsLut[d2];
+        *buffer++ = cDigitsLut[d2 + 1];
+        *buffer++ = cDigitsLut[d3];
+        *buffer++ = cDigitsLut[d3 + 1];
+        *buffer++ = cDigitsLut[d4];
+        *buffer++ = cDigitsLut[d4 + 1];
+    }
+    return buffer;
+}
+
+inline char* i32toa(int32_t value, char* buffer) {
+    uint32_t u = static_cast<uint32_t>(value);
+    if (value < 0) {
+        *buffer++ = '-';
+        u = ~u + 1;
+    }
+
+    return u32toa(u, buffer);
+}
+
+inline char* u64toa(uint64_t value, char* buffer) {
+    const char* cDigitsLut = GetDigitsLut();
+    const uint64_t  kTen8 = 100000000;
+    const uint64_t  kTen9 = kTen8 * 10;
+    const uint64_t kTen10 = kTen8 * 100;
+    const uint64_t kTen11 = kTen8 * 1000;
+    const uint64_t kTen12 = kTen8 * 10000;
+    const uint64_t kTen13 = kTen8 * 100000;
+    const uint64_t kTen14 = kTen8 * 1000000;
+    const uint64_t kTen15 = kTen8 * 10000000;
+    const uint64_t kTen16 = kTen8 * kTen8;
+    
+    if (value < kTen8) {
+        uint32_t v = static_cast<uint32_t>(value);
+        if (v < 10000) {
+            const uint32_t d1 = (v / 100) << 1;
+            const uint32_t d2 = (v % 100) << 1;
+            
+            if (v >= 1000)
+                *buffer++ = cDigitsLut[d1];
+            if (v >= 100)
+                *buffer++ = cDigitsLut[d1 + 1];
+            if (v >= 10)
+                *buffer++ = cDigitsLut[d2];
+            *buffer++ = cDigitsLut[d2 + 1];
+        }
+        else {
+            // value = bbbbcccc
+            const uint32_t b = v / 10000;
+            const uint32_t c = v % 10000;
+            
+            const uint32_t d1 = (b / 100) << 1;
+            const uint32_t d2 = (b % 100) << 1;
+            
+            const uint32_t d3 = (c / 100) << 1;
+            const uint32_t d4 = (c % 100) << 1;
+            
+            if (value >= 10000000)
+                *buffer++ = cDigitsLut[d1];
+            if (value >= 1000000)
+                *buffer++ = cDigitsLut[d1 + 1];
+            if (value >= 100000)
+                *buffer++ = cDigitsLut[d2];
+            *buffer++ = cDigitsLut[d2 + 1];
+            
+            *buffer++ = cDigitsLut[d3];
+            *buffer++ = cDigitsLut[d3 + 1];
+            *buffer++ = cDigitsLut[d4];
+            *buffer++ = cDigitsLut[d4 + 1];
+        }
+    }
+    else if (value < kTen16) {
+        const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
+        const uint32_t v1 = static_cast<uint32_t>(value % kTen8);
+        
+        const uint32_t b0 = v0 / 10000;
+        const uint32_t c0 = v0 % 10000;
+        
+        const uint32_t d1 = (b0 / 100) << 1;
+        const uint32_t d2 = (b0 % 100) << 1;
+        
+        const uint32_t d3 = (c0 / 100) << 1;
+        const uint32_t d4 = (c0 % 100) << 1;
+
+        const uint32_t b1 = v1 / 10000;
+        const uint32_t c1 = v1 % 10000;
+        
+        const uint32_t d5 = (b1 / 100) << 1;
+        const uint32_t d6 = (b1 % 100) << 1;
+        
+        const uint32_t d7 = (c1 / 100) << 1;
+        const uint32_t d8 = (c1 % 100) << 1;
+
+        if (value >= kTen15)
+            *buffer++ = cDigitsLut[d1];
+        if (value >= kTen14)
+            *buffer++ = cDigitsLut[d1 + 1];
+        if (value >= kTen13)
+            *buffer++ = cDigitsLut[d2];
+        if (value >= kTen12)
+            *buffer++ = cDigitsLut[d2 + 1];
+        if (value >= kTen11)
+            *buffer++ = cDigitsLut[d3];
+        if (value >= kTen10)
+            *buffer++ = cDigitsLut[d3 + 1];
+        if (value >= kTen9)
+            *buffer++ = cDigitsLut[d4];
+        if (value >= kTen8)
+            *buffer++ = cDigitsLut[d4 + 1];
+        
+        *buffer++ = cDigitsLut[d5];
+        *buffer++ = cDigitsLut[d5 + 1];
+        *buffer++ = cDigitsLut[d6];
+        *buffer++ = cDigitsLut[d6 + 1];
+        *buffer++ = cDigitsLut[d7];
+        *buffer++ = cDigitsLut[d7 + 1];
+        *buffer++ = cDigitsLut[d8];
+        *buffer++ = cDigitsLut[d8 + 1];
+    }
+    else {
+        const uint32_t a = static_cast<uint32_t>(value / kTen16); // 1 to 1844
+        value %= kTen16;
+        
+        if (a < 10)
+            *buffer++ = static_cast<char>('0' + static_cast<char>(a));
+        else if (a < 100) {
+            const uint32_t i = a << 1;
+            *buffer++ = cDigitsLut[i];
+            *buffer++ = cDigitsLut[i + 1];
+        }
+        else if (a < 1000) {
+            *buffer++ = static_cast<char>('0' + static_cast<char>(a / 100));
+            
+            const uint32_t i = (a % 100) << 1;
+            *buffer++ = cDigitsLut[i];
+            *buffer++ = cDigitsLut[i + 1];
+        }
+        else {
+            const uint32_t i = (a / 100) << 1;
+            const uint32_t j = (a % 100) << 1;
+            *buffer++ = cDigitsLut[i];
+            *buffer++ = cDigitsLut[i + 1];
+            *buffer++ = cDigitsLut[j];
+            *buffer++ = cDigitsLut[j + 1];
+        }
+        
+        const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
+        const uint32_t v1 = static_cast<uint32_t>(value % kTen8);
+        
+        const uint32_t b0 = v0 / 10000;
+        const uint32_t c0 = v0 % 10000;
+        
+        const uint32_t d1 = (b0 / 100) << 1;
+        const uint32_t d2 = (b0 % 100) << 1;
+        
+        const uint32_t d3 = (c0 / 100) << 1;
+        const uint32_t d4 = (c0 % 100) << 1;
+        
+        const uint32_t b1 = v1 / 10000;
+        const uint32_t c1 = v1 % 10000;
+        
+        const uint32_t d5 = (b1 / 100) << 1;
+        const uint32_t d6 = (b1 % 100) << 1;
+        
+        const uint32_t d7 = (c1 / 100) << 1;
+        const uint32_t d8 = (c1 % 100) << 1;
+        
+        *buffer++ = cDigitsLut[d1];
+        *buffer++ = cDigitsLut[d1 + 1];
+        *buffer++ = cDigitsLut[d2];
+        *buffer++ = cDigitsLut[d2 + 1];
+        *buffer++ = cDigitsLut[d3];
+        *buffer++ = cDigitsLut[d3 + 1];
+        *buffer++ = cDigitsLut[d4];
+        *buffer++ = cDigitsLut[d4 + 1];
+        *buffer++ = cDigitsLut[d5];
+        *buffer++ = cDigitsLut[d5 + 1];
+        *buffer++ = cDigitsLut[d6];
+        *buffer++ = cDigitsLut[d6 + 1];
+        *buffer++ = cDigitsLut[d7];
+        *buffer++ = cDigitsLut[d7 + 1];
+        *buffer++ = cDigitsLut[d8];
+        *buffer++ = cDigitsLut[d8 + 1];
+    }
+    
+    return buffer;
+}
+
+inline char* i64toa(int64_t value, char* buffer) {
+    uint64_t u = static_cast<uint64_t>(value);
+    if (value < 0) {
+        *buffer++ = '-';
+        u = ~u + 1;
+    }
+
+    return u64toa(u, buffer);
+}
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_ITOA_
diff --git a/engine/inc/rapidjson/internal/meta.h b/engine/inc/rapidjson/internal/meta.h
new file mode 100644
index 00000000..5a9aaa42
--- /dev/null
+++ b/engine/inc/rapidjson/internal/meta.h
@@ -0,0 +1,181 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_INTERNAL_META_H_
+#define RAPIDJSON_INTERNAL_META_H_
+
+#include "../rapidjson.h"
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(effc++)
+#endif
+#if defined(_MSC_VER)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(6334)
+#endif
+
+#if RAPIDJSON_HAS_CXX11_TYPETRAITS
+#include <type_traits>
+#endif
+
+//@cond RAPIDJSON_INTERNAL
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal {
+
+// Helper to wrap/convert arbitrary types to void, useful for arbitrary type matching
+template <typename T> struct Void { typedef void Type; };
+
+///////////////////////////////////////////////////////////////////////////////
+// BoolType, TrueType, FalseType
+//
+template <bool Cond> struct BoolType {
+    static const bool Value = Cond;
+    typedef BoolType Type;
+};
+typedef BoolType<true> TrueType;
+typedef BoolType<false> FalseType;
+
+
+///////////////////////////////////////////////////////////////////////////////
+// SelectIf, BoolExpr, NotExpr, AndExpr, OrExpr
+//
+
+template <bool C> struct SelectIfImpl { template <typename T1, typename T2> struct Apply { typedef T1 Type; }; };
+template <> struct SelectIfImpl<false> { template <typename T1, typename T2> struct Apply { typedef T2 Type; }; };
+template <bool C, typename T1, typename T2> struct SelectIfCond : SelectIfImpl<C>::template Apply<T1,T2> {};
+template <typename C, typename T1, typename T2> struct SelectIf : SelectIfCond<C::Value, T1, T2> {};
+
+template <bool Cond1, bool Cond2> struct AndExprCond : FalseType {};
+template <> struct AndExprCond<true, true> : TrueType {};
+template <bool Cond1, bool Cond2> struct OrExprCond : TrueType {};
+template <> struct OrExprCond<false, false> : FalseType {};
+
+template <typename C> struct BoolExpr : SelectIf<C,TrueType,FalseType>::Type {};
+template <typename C> struct NotExpr  : SelectIf<C,FalseType,TrueType>::Type {};
+template <typename C1, typename C2> struct AndExpr : AndExprCond<C1::Value, C2::Value>::Type {};
+template <typename C1, typename C2> struct OrExpr  : OrExprCond<C1::Value, C2::Value>::Type {};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// AddConst, MaybeAddConst, RemoveConst
+template <typename T> struct AddConst { typedef const T Type; };
+template <bool Constify, typename T> struct MaybeAddConst : SelectIfCond<Constify, const T, T> {};
+template <typename T> struct RemoveConst { typedef T Type; };
+template <typename T> struct RemoveConst<const T> { typedef T Type; };
+
+
+///////////////////////////////////////////////////////////////////////////////
+// IsSame, IsConst, IsMoreConst, IsPointer
+//
+template <typename T, typename U> struct IsSame : FalseType {};
+template <typename T> struct IsSame<T, T> : TrueType {};
+
+template <typename T> struct IsConst : FalseType {};
+template <typename T> struct IsConst<const T> : TrueType {};
+
+template <typename CT, typename T>
+struct IsMoreConst
+    : AndExpr<IsSame<typename RemoveConst<CT>::Type, typename RemoveConst<T>::Type>,
+              BoolType<IsConst<CT>::Value >= IsConst<T>::Value> >::Type {};
+
+template <typename T> struct IsPointer : FalseType {};
+template <typename T> struct IsPointer<T*> : TrueType {};
+
+///////////////////////////////////////////////////////////////////////////////
+// IsBaseOf
+//
+#if RAPIDJSON_HAS_CXX11_TYPETRAITS
+
+template <typename B, typename D> struct IsBaseOf
+    : BoolType< ::std::is_base_of<B,D>::value> {};
+
+#else // simplified version adopted from Boost
+
+template<typename B, typename D> struct IsBaseOfImpl {
+    RAPIDJSON_STATIC_ASSERT(sizeof(B) != 0);
+    RAPIDJSON_STATIC_ASSERT(sizeof(D) != 0);
+
+    typedef char (&Yes)[1];
+    typedef char (&No) [2];
+
+    template <typename T>
+    static Yes Check(const D*, T);
+    static No  Check(const B*, int);
+
+    struct Host {
+        operator const B*() const;
+        operator const D*();
+    };
+
+    enum { Value = (sizeof(Check(Host(), 0)) == sizeof(Yes)) };
+};
+
+template <typename B, typename D> struct IsBaseOf
+    : OrExpr<IsSame<B, D>, BoolExpr<IsBaseOfImpl<B, D> > >::Type {};
+
+#endif // RAPIDJSON_HAS_CXX11_TYPETRAITS
+
+
+//////////////////////////////////////////////////////////////////////////
+// EnableIf / DisableIf
+//
+template <bool Condition, typename T = void> struct EnableIfCond  { typedef T Type; };
+template <typename T> struct EnableIfCond<false, T> { /* empty */ };
+
+template <bool Condition, typename T = void> struct DisableIfCond { typedef T Type; };
+template <typename T> struct DisableIfCond<true, T> { /* empty */ };
+
+template <typename Condition, typename T = void>
+struct EnableIf : EnableIfCond<Condition::Value, T> {};
+
+template <typename Condition, typename T = void>
+struct DisableIf : DisableIfCond<Condition::Value, T> {};
+
+// SFINAE helpers
+struct SfinaeTag {};
+template <typename T> struct RemoveSfinaeTag;
+template <typename T> struct RemoveSfinaeTag<SfinaeTag&(*)(T)> { typedef T Type; };
+
+#define RAPIDJSON_REMOVEFPTR_(type) \
+    typename ::RAPIDJSON_NAMESPACE::internal::RemoveSfinaeTag \
+        < ::RAPIDJSON_NAMESPACE::internal::SfinaeTag&(*) type>::Type
+
+#define RAPIDJSON_ENABLEIF(cond) \
+    typename ::RAPIDJSON_NAMESPACE::internal::EnableIf \
+        <RAPIDJSON_REMOVEFPTR_(cond)>::Type * = NULL
+
+#define RAPIDJSON_DISABLEIF(cond) \
+    typename ::RAPIDJSON_NAMESPACE::internal::DisableIf \
+        <RAPIDJSON_REMOVEFPTR_(cond)>::Type * = NULL
+
+#define RAPIDJSON_ENABLEIF_RETURN(cond,returntype) \
+    typename ::RAPIDJSON_NAMESPACE::internal::EnableIf \
+        <RAPIDJSON_REMOVEFPTR_(cond), \
+         RAPIDJSON_REMOVEFPTR_(returntype)>::Type
+
+#define RAPIDJSON_DISABLEIF_RETURN(cond,returntype) \
+    typename ::RAPIDJSON_NAMESPACE::internal::DisableIf \
+        <RAPIDJSON_REMOVEFPTR_(cond), \
+         RAPIDJSON_REMOVEFPTR_(returntype)>::Type
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+//@endcond
+
+#if defined(__GNUC__) || defined(_MSC_VER)
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_INTERNAL_META_H_
diff --git a/engine/inc/rapidjson/internal/pow10.h b/engine/inc/rapidjson/internal/pow10.h
new file mode 100644
index 00000000..02f475d7
--- /dev/null
+++ b/engine/inc/rapidjson/internal/pow10.h
@@ -0,0 +1,55 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_POW10_
+#define RAPIDJSON_POW10_
+
+#include "../rapidjson.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal {
+
+//! Computes integer powers of 10 in double (10.0^n).
+/*! This function uses lookup table for fast and accurate results.
+    \param n non-negative exponent. Must <= 308.
+    \return 10.0^n
+*/
+inline double Pow10(int n) {
+    static const double e[] = { // 1e-0...1e308: 309 * 8 bytes = 2472 bytes
+        1e+0,  
+        1e+1,  1e+2,  1e+3,  1e+4,  1e+5,  1e+6,  1e+7,  1e+8,  1e+9,  1e+10, 1e+11, 1e+12, 1e+13, 1e+14, 1e+15, 1e+16, 1e+17, 1e+18, 1e+19, 1e+20, 
+        1e+21, 1e+22, 1e+23, 1e+24, 1e+25, 1e+26, 1e+27, 1e+28, 1e+29, 1e+30, 1e+31, 1e+32, 1e+33, 1e+34, 1e+35, 1e+36, 1e+37, 1e+38, 1e+39, 1e+40,
+        1e+41, 1e+42, 1e+43, 1e+44, 1e+45, 1e+46, 1e+47, 1e+48, 1e+49, 1e+50, 1e+51, 1e+52, 1e+53, 1e+54, 1e+55, 1e+56, 1e+57, 1e+58, 1e+59, 1e+60,
+        1e+61, 1e+62, 1e+63, 1e+64, 1e+65, 1e+66, 1e+67, 1e+68, 1e+69, 1e+70, 1e+71, 1e+72, 1e+73, 1e+74, 1e+75, 1e+76, 1e+77, 1e+78, 1e+79, 1e+80,
+        1e+81, 1e+82, 1e+83, 1e+84, 1e+85, 1e+86, 1e+87, 1e+88, 1e+89, 1e+90, 1e+91, 1e+92, 1e+93, 1e+94, 1e+95, 1e+96, 1e+97, 1e+98, 1e+99, 1e+100,
+        1e+101,1e+102,1e+103,1e+104,1e+105,1e+106,1e+107,1e+108,1e+109,1e+110,1e+111,1e+112,1e+113,1e+114,1e+115,1e+116,1e+117,1e+118,1e+119,1e+120,
+        1e+121,1e+122,1e+123,1e+124,1e+125,1e+126,1e+127,1e+128,1e+129,1e+130,1e+131,1e+132,1e+133,1e+134,1e+135,1e+136,1e+137,1e+138,1e+139,1e+140,
+        1e+141,1e+142,1e+143,1e+144,1e+145,1e+146,1e+147,1e+148,1e+149,1e+150,1e+151,1e+152,1e+153,1e+154,1e+155,1e+156,1e+157,1e+158,1e+159,1e+160,
+        1e+161,1e+162,1e+163,1e+164,1e+165,1e+166,1e+167,1e+168,1e+169,1e+170,1e+171,1e+172,1e+173,1e+174,1e+175,1e+176,1e+177,1e+178,1e+179,1e+180,
+        1e+181,1e+182,1e+183,1e+184,1e+185,1e+186,1e+187,1e+188,1e+189,1e+190,1e+191,1e+192,1e+193,1e+194,1e+195,1e+196,1e+197,1e+198,1e+199,1e+200,
+        1e+201,1e+202,1e+203,1e+204,1e+205,1e+206,1e+207,1e+208,1e+209,1e+210,1e+211,1e+212,1e+213,1e+214,1e+215,1e+216,1e+217,1e+218,1e+219,1e+220,
+        1e+221,1e+222,1e+223,1e+224,1e+225,1e+226,1e+227,1e+228,1e+229,1e+230,1e+231,1e+232,1e+233,1e+234,1e+235,1e+236,1e+237,1e+238,1e+239,1e+240,
+        1e+241,1e+242,1e+243,1e+244,1e+245,1e+246,1e+247,1e+248,1e+249,1e+250,1e+251,1e+252,1e+253,1e+254,1e+255,1e+256,1e+257,1e+258,1e+259,1e+260,
+        1e+261,1e+262,1e+263,1e+264,1e+265,1e+266,1e+267,1e+268,1e+269,1e+270,1e+271,1e+272,1e+273,1e+274,1e+275,1e+276,1e+277,1e+278,1e+279,1e+280,
+        1e+281,1e+282,1e+283,1e+284,1e+285,1e+286,1e+287,1e+288,1e+289,1e+290,1e+291,1e+292,1e+293,1e+294,1e+295,1e+296,1e+297,1e+298,1e+299,1e+300,
+        1e+301,1e+302,1e+303,1e+304,1e+305,1e+306,1e+307,1e+308
+    };
+    RAPIDJSON_ASSERT(n >= 0 && n <= 308);
+    return e[n];
+}
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_POW10_
diff --git a/engine/inc/rapidjson/internal/regex.h b/engine/inc/rapidjson/internal/regex.h
new file mode 100644
index 00000000..422a5240
--- /dev/null
+++ b/engine/inc/rapidjson/internal/regex.h
@@ -0,0 +1,701 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_INTERNAL_REGEX_H_
+#define RAPIDJSON_INTERNAL_REGEX_H_
+
+#include "../allocators.h"
+#include "../stream.h"
+#include "stack.h"
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(padded)
+RAPIDJSON_DIAG_OFF(switch-enum)
+RAPIDJSON_DIAG_OFF(implicit-fallthrough)
+#endif
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(effc++)
+#endif
+
+#ifdef _MSC_VER
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
+#endif
+
+#ifndef RAPIDJSON_REGEX_VERBOSE
+#define RAPIDJSON_REGEX_VERBOSE 0
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal {
+
+///////////////////////////////////////////////////////////////////////////////
+// GenericRegex
+
+static const SizeType kRegexInvalidState = ~SizeType(0);  //!< Represents an invalid index in GenericRegex::State::out, out1
+static const SizeType kRegexInvalidRange = ~SizeType(0);
+
+//! Regular expression engine with subset of ECMAscript grammar.
+/*!
+    Supported regular expression syntax:
+    - \c ab     Concatenation
+    - \c a|b    Alternation
+    - \c a?     Zero or one
+    - \c a*     Zero or more
+    - \c a+     One or more
+    - \c a{3}   Exactly 3 times
+    - \c a{3,}  At least 3 times
+    - \c a{3,5} 3 to 5 times
+    - \c (ab)   Grouping
+    - \c ^a     At the beginning
+    - \c a$     At the end
+    - \c .      Any character
+    - \c [abc]  Character classes
+    - \c [a-c]  Character class range
+    - \c [a-z0-9_] Character class combination
+    - \c [^abc] Negated character classes
+    - \c [^a-c] Negated character class range
+    - \c [\b]   Backspace (U+0008)
+    - \c \\| \\\\ ...  Escape characters
+    - \c \\f Form feed (U+000C)
+    - \c \\n Line feed (U+000A)
+    - \c \\r Carriage return (U+000D)
+    - \c \\t Tab (U+0009)
+    - \c \\v Vertical tab (U+000B)
+
+    \note This is a Thompson NFA engine, implemented with reference to 
+        Cox, Russ. "Regular Expression Matching Can Be Simple And Fast (but is slow in Java, Perl, PHP, Python, Ruby,...).", 
+        https://swtch.com/~rsc/regexp/regexp1.html 
+*/
+template <typename Encoding, typename Allocator = CrtAllocator>
+class GenericRegex {
+public:
+    typedef typename Encoding::Ch Ch;
+
+    GenericRegex(const Ch* source, Allocator* allocator = 0) : 
+        states_(allocator, 256), ranges_(allocator, 256), root_(kRegexInvalidState), stateCount_(), rangeCount_(), 
+        stateSet_(), state0_(allocator, 0), state1_(allocator, 0), anchorBegin_(), anchorEnd_()
+    {
+        GenericStringStream<Encoding> ss(source);
+        DecodedStream<GenericStringStream<Encoding> > ds(ss);
+        Parse(ds);
+    }
+
+    ~GenericRegex() {
+        Allocator::Free(stateSet_);
+    }
+
+    bool IsValid() const {
+        return root_ != kRegexInvalidState;
+    }
+
+    template <typename InputStream>
+    bool Match(InputStream& is) const {
+        return SearchWithAnchoring(is, true, true);
+    }
+
+    bool Match(const Ch* s) const {
+        GenericStringStream<Encoding> is(s);
+        return Match(is);
+    }
+
+    template <typename InputStream>
+    bool Search(InputStream& is) const {
+        return SearchWithAnchoring(is, anchorBegin_, anchorEnd_);
+    }
+
+    bool Search(const Ch* s) const {
+        GenericStringStream<Encoding> is(s);
+        return Search(is);
+    }
+
+private:
+    enum Operator {
+        kZeroOrOne,
+        kZeroOrMore,
+        kOneOrMore,
+        kConcatenation,
+        kAlternation,
+        kLeftParenthesis
+    };
+
+    static const unsigned kAnyCharacterClass = 0xFFFFFFFF;   //!< For '.'
+    static const unsigned kRangeCharacterClass = 0xFFFFFFFE;
+    static const unsigned kRangeNegationFlag = 0x80000000;
+
+    struct Range {
+        unsigned start; // 
+        unsigned end;
+        SizeType next;
+    };
+
+    struct State {
+        SizeType out;     //!< Equals to kInvalid for matching state
+        SizeType out1;    //!< Equals to non-kInvalid for split
+        SizeType rangeStart;
+        unsigned codepoint;
+    };
+
+    struct Frag {
+        Frag(SizeType s, SizeType o, SizeType m) : start(s), out(o), minIndex(m) {}
+        SizeType start;
+        SizeType out; //!< link-list of all output states
+        SizeType minIndex;
+    };
+
+    template <typename SourceStream>
+    class DecodedStream {
+    public:
+        DecodedStream(SourceStream& ss) : ss_(ss), codepoint_() { Decode(); }
+        unsigned Peek() { return codepoint_; }
+        unsigned Take() {
+            unsigned c = codepoint_;
+            if (c) // No further decoding when '\0'
+                Decode();
+            return c;
+        }
+
+    private:
+        void Decode() {
+            if (!Encoding::Decode(ss_, &codepoint_))
+                codepoint_ = 0;
+        }
+
+        SourceStream& ss_;
+        unsigned codepoint_;
+    };
+
+    State& GetState(SizeType index) {
+        RAPIDJSON_ASSERT(index < stateCount_);
+        return states_.template Bottom<State>()[index];
+    }
+
+    const State& GetState(SizeType index) const {
+        RAPIDJSON_ASSERT(index < stateCount_);
+        return states_.template Bottom<State>()[index];
+    }
+
+    Range& GetRange(SizeType index) {
+        RAPIDJSON_ASSERT(index < rangeCount_);
+        return ranges_.template Bottom<Range>()[index];
+    }
+
+    const Range& GetRange(SizeType index) const {
+        RAPIDJSON_ASSERT(index < rangeCount_);
+        return ranges_.template Bottom<Range>()[index];
+    }
+
+    template <typename InputStream>
+    void Parse(DecodedStream<InputStream>& ds) {
+        Allocator allocator;
+        Stack<Allocator> operandStack(&allocator, 256);     // Frag
+        Stack<Allocator> operatorStack(&allocator, 256);    // Operator
+        Stack<Allocator> atomCountStack(&allocator, 256);   // unsigned (Atom per parenthesis)
+
+        *atomCountStack.template Push<unsigned>() = 0;
+
+        unsigned codepoint;
+        while (ds.Peek() != 0) {
+            switch (codepoint = ds.Take()) {
+                case '^':
+                    anchorBegin_ = true;
+                    break;
+
+                case '$':
+                    anchorEnd_ = true;
+                    break;
+
+                case '|':
+                    while (!operatorStack.Empty() && *operatorStack.template Top<Operator>() < kAlternation)
+                        if (!Eval(operandStack, *operatorStack.template Pop<Operator>(1)))
+                            return;
+                    *operatorStack.template Push<Operator>() = kAlternation;
+                    *atomCountStack.template Top<unsigned>() = 0;
+                    break;
+
+                case '(':
+                    *operatorStack.template Push<Operator>() = kLeftParenthesis;
+                    *atomCountStack.template Push<unsigned>() = 0;
+                    break;
+
+                case ')':
+                    while (!operatorStack.Empty() && *operatorStack.template Top<Operator>() != kLeftParenthesis)
+                        if (!Eval(operandStack, *operatorStack.template Pop<Operator>(1)))
+                            return;
+                    if (operatorStack.Empty())
+                        return;
+                    operatorStack.template Pop<Operator>(1);
+                    atomCountStack.template Pop<unsigned>(1);
+                    ImplicitConcatenation(atomCountStack, operatorStack);
+                    break;
+
+                case '?':
+                    if (!Eval(operandStack, kZeroOrOne))
+                        return;
+                    break;
+
+                case '*':
+                    if (!Eval(operandStack, kZeroOrMore))
+                        return;
+                    break;
+
+                case '+':
+                    if (!Eval(operandStack, kOneOrMore))
+                        return;
+                    break;
+
+                case '{':
+                    {
+                        unsigned n, m;
+                        if (!ParseUnsigned(ds, &n))
+                            return;
+
+                        if (ds.Peek() == ',') {
+                            ds.Take();
+                            if (ds.Peek() == '}')
+                                m = kInfinityQuantifier;
+                            else if (!ParseUnsigned(ds, &m) || m < n)
+                                return;
+                        }
+                        else
+                            m = n;
+
+                        if (!EvalQuantifier(operandStack, n, m) || ds.Peek() != '}')
+                            return;
+                        ds.Take();
+                    }
+                    break;
+
+                case '.':
+                    PushOperand(operandStack, kAnyCharacterClass);
+                    ImplicitConcatenation(atomCountStack, operatorStack);
+                    break;
+
+                case '[':
+                    {
+                        SizeType range;
+                        if (!ParseRange(ds, &range))
+                            return;
+                        SizeType s = NewState(kRegexInvalidState, kRegexInvalidState, kRangeCharacterClass);
+                        GetState(s).rangeStart = range;
+                        *operandStack.template Push<Frag>() = Frag(s, s, s);
+                    }
+                    ImplicitConcatenation(atomCountStack, operatorStack);
+                    break;
+
+                case '\\': // Escape character
+                    if (!CharacterEscape(ds, &codepoint))
+                        return; // Unsupported escape character
+                    // fall through to default
+
+                default: // Pattern character
+                    PushOperand(operandStack, codepoint);
+                    ImplicitConcatenation(atomCountStack, operatorStack);
+            }
+        }
+
+        while (!operatorStack.Empty())
+            if (!Eval(operandStack, *operatorStack.template Pop<Operator>(1)))
+                return;
+
+        // Link the operand to matching state.
+        if (operandStack.GetSize() == sizeof(Frag)) {
+            Frag* e = operandStack.template Pop<Frag>(1);
+            Patch(e->out, NewState(kRegexInvalidState, kRegexInvalidState, 0));
+            root_ = e->start;
+
+#if RAPIDJSON_REGEX_VERBOSE
+            printf("root: %d\n", root_);
+            for (SizeType i = 0; i < stateCount_ ; i++) {
+                State& s = GetState(i);
+                printf("[%2d] out: %2d out1: %2d c: '%c'\n", i, s.out, s.out1, (char)s.codepoint);
+            }
+            printf("\n");
+#endif
+        }
+
+        // Preallocate buffer for SearchWithAnchoring()
+        RAPIDJSON_ASSERT(stateSet_ == 0);
+        if (stateCount_ > 0) {
+            stateSet_ = static_cast<unsigned*>(states_.GetAllocator().Malloc(GetStateSetSize()));
+            state0_.template Reserve<SizeType>(stateCount_);
+            state1_.template Reserve<SizeType>(stateCount_);
+        }
+    }
+
+    SizeType NewState(SizeType out, SizeType out1, unsigned codepoint) {
+        State* s = states_.template Push<State>();
+        s->out = out;
+        s->out1 = out1;
+        s->codepoint = codepoint;
+        s->rangeStart = kRegexInvalidRange;
+        return stateCount_++;
+    }
+
+    void PushOperand(Stack<Allocator>& operandStack, unsigned codepoint) {
+        SizeType s = NewState(kRegexInvalidState, kRegexInvalidState, codepoint);
+        *operandStack.template Push<Frag>() = Frag(s, s, s);
+    }
+
+    void ImplicitConcatenation(Stack<Allocator>& atomCountStack, Stack<Allocator>& operatorStack) {
+        if (*atomCountStack.template Top<unsigned>())
+            *operatorStack.template Push<Operator>() = kConcatenation;
+        (*atomCountStack.template Top<unsigned>())++;
+    }
+
+    SizeType Append(SizeType l1, SizeType l2) {
+        SizeType old = l1;
+        while (GetState(l1).out != kRegexInvalidState)
+            l1 = GetState(l1).out;
+        GetState(l1).out = l2;
+        return old;
+    }
+
+    void Patch(SizeType l, SizeType s) {
+        for (SizeType next; l != kRegexInvalidState; l = next) {
+            next = GetState(l).out;
+            GetState(l).out = s;
+        }
+    }
+
+    bool Eval(Stack<Allocator>& operandStack, Operator op) {
+        switch (op) {
+            case kConcatenation:
+                RAPIDJSON_ASSERT(operandStack.GetSize() >= sizeof(Frag) * 2);
+                {
+                    Frag e2 = *operandStack.template Pop<Frag>(1);
+                    Frag e1 = *operandStack.template Pop<Frag>(1);
+                    Patch(e1.out, e2.start);
+                    *operandStack.template Push<Frag>() = Frag(e1.start, e2.out, Min(e1.minIndex, e2.minIndex));
+                }
+                return true;
+
+            case kAlternation:
+                if (operandStack.GetSize() >= sizeof(Frag) * 2) {
+                    Frag e2 = *operandStack.template Pop<Frag>(1);
+                    Frag e1 = *operandStack.template Pop<Frag>(1);
+                    SizeType s = NewState(e1.start, e2.start, 0);
+                    *operandStack.template Push<Frag>() = Frag(s, Append(e1.out, e2.out), Min(e1.minIndex, e2.minIndex));
+                    return true;
+                }
+                return false;
+
+            case kZeroOrOne:
+                if (operandStack.GetSize() >= sizeof(Frag)) {
+                    Frag e = *operandStack.template Pop<Frag>(1);
+                    SizeType s = NewState(kRegexInvalidState, e.start, 0);
+                    *operandStack.template Push<Frag>() = Frag(s, Append(e.out, s), e.minIndex);
+                    return true;
+                }
+                return false;
+
+            case kZeroOrMore:
+                if (operandStack.GetSize() >= sizeof(Frag)) {
+                    Frag e = *operandStack.template Pop<Frag>(1);
+                    SizeType s = NewState(kRegexInvalidState, e.start, 0);
+                    Patch(e.out, s);
+                    *operandStack.template Push<Frag>() = Frag(s, s, e.minIndex);
+                    return true;
+                }
+                return false;
+
+            default: 
+                RAPIDJSON_ASSERT(op == kOneOrMore);
+                if (operandStack.GetSize() >= sizeof(Frag)) {
+                    Frag e = *operandStack.template Pop<Frag>(1);
+                    SizeType s = NewState(kRegexInvalidState, e.start, 0);
+                    Patch(e.out, s);
+                    *operandStack.template Push<Frag>() = Frag(e.start, s, e.minIndex);
+                    return true;
+                }
+                return false;
+        }
+    }
+
+    bool EvalQuantifier(Stack<Allocator>& operandStack, unsigned n, unsigned m) {
+        RAPIDJSON_ASSERT(n <= m);
+        RAPIDJSON_ASSERT(operandStack.GetSize() >= sizeof(Frag));
+
+        if (n == 0) {
+            if (m == 0)                             // a{0} not support
+                return false;
+            else if (m == kInfinityQuantifier)
+                Eval(operandStack, kZeroOrMore);    // a{0,} -> a*
+            else {
+                Eval(operandStack, kZeroOrOne);         // a{0,5} -> a?
+                for (unsigned i = 0; i < m - 1; i++)
+                    CloneTopOperand(operandStack);      // a{0,5} -> a? a? a? a? a?
+                for (unsigned i = 0; i < m - 1; i++)
+                    Eval(operandStack, kConcatenation); // a{0,5} -> a?a?a?a?a?
+            }
+            return true;
+        }
+
+        for (unsigned i = 0; i < n - 1; i++)        // a{3} -> a a a
+            CloneTopOperand(operandStack);
+
+        if (m == kInfinityQuantifier)
+            Eval(operandStack, kOneOrMore);         // a{3,} -> a a a+
+        else if (m > n) {
+            CloneTopOperand(operandStack);          // a{3,5} -> a a a a
+            Eval(operandStack, kZeroOrOne);         // a{3,5} -> a a a a?
+            for (unsigned i = n; i < m - 1; i++)
+                CloneTopOperand(operandStack);      // a{3,5} -> a a a a? a?
+            for (unsigned i = n; i < m; i++)
+                Eval(operandStack, kConcatenation); // a{3,5} -> a a aa?a?
+        }
+
+        for (unsigned i = 0; i < n - 1; i++)
+            Eval(operandStack, kConcatenation);     // a{3} -> aaa, a{3,} -> aaa+, a{3.5} -> aaaa?a?
+
+        return true;
+    }
+
+    static SizeType Min(SizeType a, SizeType b) { return a < b ? a : b; }
+
+    void CloneTopOperand(Stack<Allocator>& operandStack) {
+        const Frag src = *operandStack.template Top<Frag>(); // Copy constructor to prevent invalidation
+        SizeType count = stateCount_ - src.minIndex; // Assumes top operand contains states in [src->minIndex, stateCount_)
+        State* s = states_.template Push<State>(count);
+        memcpy(s, &GetState(src.minIndex), count * sizeof(State));
+        for (SizeType j = 0; j < count; j++) {
+            if (s[j].out != kRegexInvalidState)
+                s[j].out += count;
+            if (s[j].out1 != kRegexInvalidState)
+                s[j].out1 += count;
+        }
+        *operandStack.template Push<Frag>() = Frag(src.start + count, src.out + count, src.minIndex + count);
+        stateCount_ += count;
+    }
+
+    template <typename InputStream>
+    bool ParseUnsigned(DecodedStream<InputStream>& ds, unsigned* u) {
+        unsigned r = 0;
+        if (ds.Peek() < '0' || ds.Peek() > '9')
+            return false;
+        while (ds.Peek() >= '0' && ds.Peek() <= '9') {
+            if (r >= 429496729 && ds.Peek() > '5') // 2^32 - 1 = 4294967295
+                return false; // overflow
+            r = r * 10 + (ds.Take() - '0');
+        }
+        *u = r;
+        return true;
+    }
+
+    template <typename InputStream>
+    bool ParseRange(DecodedStream<InputStream>& ds, SizeType* range) {
+        bool isBegin = true;
+        bool negate = false;
+        int step = 0;
+        SizeType start = kRegexInvalidRange;
+        SizeType current = kRegexInvalidRange;
+        unsigned codepoint;
+        while ((codepoint = ds.Take()) != 0) {
+            if (isBegin) {
+                isBegin = false;
+                if (codepoint == '^') {
+                    negate = true;
+                    continue;
+                }
+            }
+
+            switch (codepoint) {
+            case ']':
+                if (start == kRegexInvalidRange)
+                    return false;   // Error: nothing inside []
+                if (step == 2) { // Add trailing '-'
+                    SizeType r = NewRange('-');
+                    RAPIDJSON_ASSERT(current != kRegexInvalidRange);
+                    GetRange(current).next = r;
+                }
+                if (negate)
+                    GetRange(start).start |= kRangeNegationFlag;
+                *range = start;
+                return true;
+
+            case '\\':
+                if (ds.Peek() == 'b') {
+                    ds.Take();
+                    codepoint = 0x0008; // Escape backspace character
+                }
+                else if (!CharacterEscape(ds, &codepoint))
+                    return false;
+                // fall through to default
+
+            default:
+                switch (step) {
+                case 1:
+                    if (codepoint == '-') {
+                        step++;
+                        break;
+                    }
+                    // fall through to step 0 for other characters
+
+                case 0:
+                    {
+                        SizeType r = NewRange(codepoint);
+                        if (current != kRegexInvalidRange)
+                            GetRange(current).next = r;
+                        if (start == kRegexInvalidRange)
+                            start = r;
+                        current = r;
+                    }
+                    step = 1;
+                    break;
+
+                default:
+                    RAPIDJSON_ASSERT(step == 2);
+                    GetRange(current).end = codepoint;
+                    step = 0;
+                }
+            }
+        }
+        return false;
+    }
+    
+    SizeType NewRange(unsigned codepoint) {
+        Range* r = ranges_.template Push<Range>();
+        r->start = r->end = codepoint;
+        r->next = kRegexInvalidRange;
+        return rangeCount_++;
+    }
+
+    template <typename InputStream>
+    bool CharacterEscape(DecodedStream<InputStream>& ds, unsigned* escapedCodepoint) {
+        unsigned codepoint;
+        switch (codepoint = ds.Take()) {
+            case '^':
+            case '$':
+            case '|':
+            case '(':
+            case ')':
+            case '?':
+            case '*':
+            case '+':
+            case '.':
+            case '[':
+            case ']':
+            case '{':
+            case '}':
+            case '\\':
+                *escapedCodepoint = codepoint; return true;
+            case 'f': *escapedCodepoint = 0x000C; return true;
+            case 'n': *escapedCodepoint = 0x000A; return true;
+            case 'r': *escapedCodepoint = 0x000D; return true;
+            case 't': *escapedCodepoint = 0x0009; return true;
+            case 'v': *escapedCodepoint = 0x000B; return true;
+            default:
+                return false; // Unsupported escape character
+        }
+    }
+
+    template <typename InputStream>
+    bool SearchWithAnchoring(InputStream& is, bool anchorBegin, bool anchorEnd) const {
+        RAPIDJSON_ASSERT(IsValid());
+        DecodedStream<InputStream> ds(is);
+
+        state0_.Clear();
+        Stack<Allocator> *current = &state0_, *next = &state1_;
+        const size_t stateSetSize = GetStateSetSize();
+        std::memset(stateSet_, 0, stateSetSize);
+
+        bool matched = AddState(*current, root_);
+        unsigned codepoint;
+        while (!current->Empty() && (codepoint = ds.Take()) != 0) {
+            std::memset(stateSet_, 0, stateSetSize);
+            next->Clear();
+            matched = false;
+            for (const SizeType* s = current->template Bottom<SizeType>(); s != current->template End<SizeType>(); ++s) {
+                const State& sr = GetState(*s);
+                if (sr.codepoint == codepoint ||
+                    sr.codepoint == kAnyCharacterClass || 
+                    (sr.codepoint == kRangeCharacterClass && MatchRange(sr.rangeStart, codepoint)))
+                {
+                    matched = AddState(*next, sr.out) || matched;
+                    if (!anchorEnd && matched)
+                        return true;
+                }
+                if (!anchorBegin)
+                    AddState(*next, root_);
+            }
+            internal::Swap(current, next);
+        }
+
+        return matched;
+    }
+
+    size_t GetStateSetSize() const {
+        return (stateCount_ + 31) / 32 * 4;
+    }
+
+    // Return whether the added states is a match state
+    bool AddState(Stack<Allocator>& l, SizeType index) const {
+        RAPIDJSON_ASSERT(index != kRegexInvalidState);
+
+        const State& s = GetState(index);
+        if (s.out1 != kRegexInvalidState) { // Split
+            bool matched = AddState(l, s.out);
+            return AddState(l, s.out1) || matched;
+        }
+        else if (!(stateSet_[index >> 5] & (1 << (index & 31)))) {
+            stateSet_[index >> 5] |= (1 << (index & 31));
+            *l.template PushUnsafe<SizeType>() = index;
+        }
+        return s.out == kRegexInvalidState; // by using PushUnsafe() above, we can ensure s is not validated due to reallocation.
+    }
+
+    bool MatchRange(SizeType rangeIndex, unsigned codepoint) const {
+        bool yes = (GetRange(rangeIndex).start & kRangeNegationFlag) == 0;
+        while (rangeIndex != kRegexInvalidRange) {
+            const Range& r = GetRange(rangeIndex);
+            if (codepoint >= (r.start & ~kRangeNegationFlag) && codepoint <= r.end)
+                return yes;
+            rangeIndex = r.next;
+        }
+        return !yes;
+    }
+
+    Stack<Allocator> states_;
+    Stack<Allocator> ranges_;
+    SizeType root_;
+    SizeType stateCount_;
+    SizeType rangeCount_;
+
+    static const unsigned kInfinityQuantifier = ~0u;
+
+    // For SearchWithAnchoring()
+    uint32_t* stateSet_;        // allocated by states_.GetAllocator()
+    mutable Stack<Allocator> state0_;
+    mutable Stack<Allocator> state1_;
+    bool anchorBegin_;
+    bool anchorEnd_;
+};
+
+typedef GenericRegex<UTF8<> > Regex;
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
+
+#ifdef _MSC_VER
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_INTERNAL_REGEX_H_
diff --git a/engine/inc/rapidjson/internal/stack.h b/engine/inc/rapidjson/internal/stack.h
new file mode 100644
index 00000000..022c9aab
--- /dev/null
+++ b/engine/inc/rapidjson/internal/stack.h
@@ -0,0 +1,230 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_INTERNAL_STACK_H_
+#define RAPIDJSON_INTERNAL_STACK_H_
+
+#include "../allocators.h"
+#include "swap.h"
+
+#if defined(__clang__)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(c++98-compat)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal {
+
+///////////////////////////////////////////////////////////////////////////////
+// Stack
+
+//! A type-unsafe stack for storing different types of data.
+/*! \tparam Allocator Allocator for allocating stack memory.
+*/
+template <typename Allocator>
+class Stack {
+public:
+    // Optimization note: Do not allocate memory for stack_ in constructor.
+    // Do it lazily when first Push() -> Expand() -> Resize().
+    Stack(Allocator* allocator, size_t stackCapacity) : allocator_(allocator), ownAllocator_(0), stack_(0), stackTop_(0), stackEnd_(0), initialCapacity_(stackCapacity) {
+    }
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+    Stack(Stack&& rhs)
+        : allocator_(rhs.allocator_),
+          ownAllocator_(rhs.ownAllocator_),
+          stack_(rhs.stack_),
+          stackTop_(rhs.stackTop_),
+          stackEnd_(rhs.stackEnd_),
+          initialCapacity_(rhs.initialCapacity_)
+    {
+        rhs.allocator_ = 0;
+        rhs.ownAllocator_ = 0;
+        rhs.stack_ = 0;
+        rhs.stackTop_ = 0;
+        rhs.stackEnd_ = 0;
+        rhs.initialCapacity_ = 0;
+    }
+#endif
+
+    ~Stack() {
+        Destroy();
+    }
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+    Stack& operator=(Stack&& rhs) {
+        if (&rhs != this)
+        {
+            Destroy();
+
+            allocator_ = rhs.allocator_;
+            ownAllocator_ = rhs.ownAllocator_;
+            stack_ = rhs.stack_;
+            stackTop_ = rhs.stackTop_;
+            stackEnd_ = rhs.stackEnd_;
+            initialCapacity_ = rhs.initialCapacity_;
+
+            rhs.allocator_ = 0;
+            rhs.ownAllocator_ = 0;
+            rhs.stack_ = 0;
+            rhs.stackTop_ = 0;
+            rhs.stackEnd_ = 0;
+            rhs.initialCapacity_ = 0;
+        }
+        return *this;
+    }
+#endif
+
+    void Swap(Stack& rhs) RAPIDJSON_NOEXCEPT {
+        internal::Swap(allocator_, rhs.allocator_);
+        internal::Swap(ownAllocator_, rhs.ownAllocator_);
+        internal::Swap(stack_, rhs.stack_);
+        internal::Swap(stackTop_, rhs.stackTop_);
+        internal::Swap(stackEnd_, rhs.stackEnd_);
+        internal::Swap(initialCapacity_, rhs.initialCapacity_);
+    }
+
+    void Clear() { stackTop_ = stack_; }
+
+    void ShrinkToFit() { 
+        if (Empty()) {
+            // If the stack is empty, completely deallocate the memory.
+            Allocator::Free(stack_);
+            stack_ = 0;
+            stackTop_ = 0;
+            stackEnd_ = 0;
+        }
+        else
+            Resize(GetSize());
+    }
+
+    // Optimization note: try to minimize the size of this function for force inline.
+    // Expansion is run very infrequently, so it is moved to another (probably non-inline) function.
+    template<typename T>
+    RAPIDJSON_FORCEINLINE void Reserve(size_t count = 1) {
+         // Expand the stack if needed
+        if (RAPIDJSON_UNLIKELY(stackTop_ + sizeof(T) * count > stackEnd_))
+            Expand<T>(count);
+    }
+
+    template<typename T>
+    RAPIDJSON_FORCEINLINE T* Push(size_t count = 1) {
+        Reserve<T>(count);
+        return PushUnsafe<T>(count);
+    }
+
+    template<typename T>
+    RAPIDJSON_FORCEINLINE T* PushUnsafe(size_t count = 1) {
+        RAPIDJSON_ASSERT(stackTop_ + sizeof(T) * count <= stackEnd_);
+        T* ret = reinterpret_cast<T*>(stackTop_);
+        stackTop_ += sizeof(T) * count;
+        return ret;
+    }
+
+    template<typename T>
+    T* Pop(size_t count) {
+        RAPIDJSON_ASSERT(GetSize() >= count * sizeof(T));
+        stackTop_ -= count * sizeof(T);
+        return reinterpret_cast<T*>(stackTop_);
+    }
+
+    template<typename T>
+    T* Top() { 
+        RAPIDJSON_ASSERT(GetSize() >= sizeof(T));
+        return reinterpret_cast<T*>(stackTop_ - sizeof(T));
+    }
+
+    template<typename T>
+    const T* Top() const {
+        RAPIDJSON_ASSERT(GetSize() >= sizeof(T));
+        return reinterpret_cast<T*>(stackTop_ - sizeof(T));
+    }
+
+    template<typename T>
+    T* End() { return reinterpret_cast<T*>(stackTop_); }
+
+    template<typename T>
+    const T* End() const { return reinterpret_cast<T*>(stackTop_); }
+
+    template<typename T>
+    T* Bottom() { return reinterpret_cast<T*>(stack_); }
+
+    template<typename T>
+    const T* Bottom() const { return reinterpret_cast<T*>(stack_); }
+
+    bool HasAllocator() const {
+        return allocator_ != 0;
+    }
+
+    Allocator& GetAllocator() {
+        RAPIDJSON_ASSERT(allocator_);
+        return *allocator_;
+    }
+
+    bool Empty() const { return stackTop_ == stack_; }
+    size_t GetSize() const { return static_cast<size_t>(stackTop_ - stack_); }
+    size_t GetCapacity() const { return static_cast<size_t>(stackEnd_ - stack_); }
+
+private:
+    template<typename T>
+    void Expand(size_t count) {
+        // Only expand the capacity if the current stack exists. Otherwise just create a stack with initial capacity.
+        size_t newCapacity;
+        if (stack_ == 0) {
+            if (!allocator_)
+                ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator());
+            newCapacity = initialCapacity_;
+        } else {
+            newCapacity = GetCapacity();
+            newCapacity += (newCapacity + 1) / 2;
+        }
+        size_t newSize = GetSize() + sizeof(T) * count;
+        if (newCapacity < newSize)
+            newCapacity = newSize;
+
+        Resize(newCapacity);
+    }
+
+    void Resize(size_t newCapacity) {
+        const size_t size = GetSize();  // Backup the current size
+        stack_ = static_cast<char*>(allocator_->Realloc(stack_, GetCapacity(), newCapacity));
+        stackTop_ = stack_ + size;
+        stackEnd_ = stack_ + newCapacity;
+    }
+
+    void Destroy() {
+        Allocator::Free(stack_);
+        RAPIDJSON_DELETE(ownAllocator_); // Only delete if it is owned by the stack
+    }
+
+    // Prohibit copy constructor & assignment operator.
+    Stack(const Stack&);
+    Stack& operator=(const Stack&);
+
+    Allocator* allocator_;
+    Allocator* ownAllocator_;
+    char *stack_;
+    char *stackTop_;
+    char *stackEnd_;
+    size_t initialCapacity_;
+};
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#if defined(__clang__)
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_STACK_H_
diff --git a/engine/inc/rapidjson/internal/strfunc.h b/engine/inc/rapidjson/internal/strfunc.h
new file mode 100644
index 00000000..2edfae52
--- /dev/null
+++ b/engine/inc/rapidjson/internal/strfunc.h
@@ -0,0 +1,55 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_INTERNAL_STRFUNC_H_
+#define RAPIDJSON_INTERNAL_STRFUNC_H_
+
+#include "../stream.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal {
+
+//! Custom strlen() which works on different character types.
+/*! \tparam Ch Character type (e.g. char, wchar_t, short)
+    \param s Null-terminated input string.
+    \return Number of characters in the string. 
+    \note This has the same semantics as strlen(), the return value is not number of Unicode codepoints.
+*/
+template <typename Ch>
+inline SizeType StrLen(const Ch* s) {
+    const Ch* p = s;
+    while (*p) ++p;
+    return SizeType(p - s);
+}
+
+//! Returns number of code points in a encoded string.
+template<typename Encoding>
+bool CountStringCodePoint(const typename Encoding::Ch* s, SizeType length, SizeType* outCount) {
+    GenericStringStream<Encoding> is(s);
+    const typename Encoding::Ch* end = s + length;
+    SizeType count = 0;
+    while (is.src_ < end) {
+        unsigned codepoint;
+        if (!Encoding::Decode(is, &codepoint))
+            return false;
+        count++;
+    }
+    *outCount = count;
+    return true;
+}
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_INTERNAL_STRFUNC_H_
diff --git a/engine/inc/rapidjson/internal/strtod.h b/engine/inc/rapidjson/internal/strtod.h
new file mode 100644
index 00000000..289c413b
--- /dev/null
+++ b/engine/inc/rapidjson/internal/strtod.h
@@ -0,0 +1,269 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_STRTOD_
+#define RAPIDJSON_STRTOD_
+
+#include "ieee754.h"
+#include "biginteger.h"
+#include "diyfp.h"
+#include "pow10.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal {
+
+inline double FastPath(double significand, int exp) {
+    if (exp < -308)
+        return 0.0;
+    else if (exp >= 0)
+        return significand * internal::Pow10(exp);
+    else
+        return significand / internal::Pow10(-exp);
+}
+
+inline double StrtodNormalPrecision(double d, int p) {
+    if (p < -308) {
+        // Prevent expSum < -308, making Pow10(p) = 0
+        d = FastPath(d, -308);
+        d = FastPath(d, p + 308);
+    }
+    else
+        d = FastPath(d, p);
+    return d;
+}
+
+template <typename T>
+inline T Min3(T a, T b, T c) {
+    T m = a;
+    if (m > b) m = b;
+    if (m > c) m = c;
+    return m;
+}
+
+inline int CheckWithinHalfULP(double b, const BigInteger& d, int dExp) {
+    const Double db(b);
+    const uint64_t bInt = db.IntegerSignificand();
+    const int bExp = db.IntegerExponent();
+    const int hExp = bExp - 1;
+
+    int dS_Exp2 = 0, dS_Exp5 = 0, bS_Exp2 = 0, bS_Exp5 = 0, hS_Exp2 = 0, hS_Exp5 = 0;
+
+    // Adjust for decimal exponent
+    if (dExp >= 0) {
+        dS_Exp2 += dExp;
+        dS_Exp5 += dExp;
+    }
+    else {
+        bS_Exp2 -= dExp;
+        bS_Exp5 -= dExp;
+        hS_Exp2 -= dExp;
+        hS_Exp5 -= dExp;
+    }
+
+    // Adjust for binary exponent
+    if (bExp >= 0)
+        bS_Exp2 += bExp;
+    else {
+        dS_Exp2 -= bExp;
+        hS_Exp2 -= bExp;
+    }
+
+    // Adjust for half ulp exponent
+    if (hExp >= 0)
+        hS_Exp2 += hExp;
+    else {
+        dS_Exp2 -= hExp;
+        bS_Exp2 -= hExp;
+    }
+
+    // Remove common power of two factor from all three scaled values
+    int common_Exp2 = Min3(dS_Exp2, bS_Exp2, hS_Exp2);
+    dS_Exp2 -= common_Exp2;
+    bS_Exp2 -= common_Exp2;
+    hS_Exp2 -= common_Exp2;
+
+    BigInteger dS = d;
+    dS.MultiplyPow5(static_cast<unsigned>(dS_Exp5)) <<= static_cast<unsigned>(dS_Exp2);
+
+    BigInteger bS(bInt);
+    bS.MultiplyPow5(static_cast<unsigned>(bS_Exp5)) <<= static_cast<unsigned>(bS_Exp2);
+
+    BigInteger hS(1);
+    hS.MultiplyPow5(static_cast<unsigned>(hS_Exp5)) <<= static_cast<unsigned>(hS_Exp2);
+
+    BigInteger delta(0);
+    dS.Difference(bS, &delta);
+
+    return delta.Compare(hS);
+}
+
+inline bool StrtodFast(double d, int p, double* result) {
+    // Use fast path for string-to-double conversion if possible
+    // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion/
+    if (p > 22  && p < 22 + 16) {
+        // Fast Path Cases In Disguise
+        d *= internal::Pow10(p - 22);
+        p = 22;
+    }
+
+    if (p >= -22 && p <= 22 && d <= 9007199254740991.0) { // 2^53 - 1
+        *result = FastPath(d, p);
+        return true;
+    }
+    else
+        return false;
+}
+
+// Compute an approximation and see if it is within 1/2 ULP
+inline bool StrtodDiyFp(const char* decimals, size_t length, size_t decimalPosition, int exp, double* result) {
+    uint64_t significand = 0;
+    size_t i = 0;   // 2^64 - 1 = 18446744073709551615, 1844674407370955161 = 0x1999999999999999    
+    for (; i < length; i++) {
+        if (significand  >  RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) ||
+            (significand == RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) && decimals[i] > '5'))
+            break;
+        significand = significand * 10u + static_cast<unsigned>(decimals[i] - '0');
+    }
+    
+    if (i < length && decimals[i] >= '5') // Rounding
+        significand++;
+
+    size_t remaining = length - i;
+    const unsigned kUlpShift = 3;
+    const unsigned kUlp = 1 << kUlpShift;
+    int64_t error = (remaining == 0) ? 0 : kUlp / 2;
+
+    DiyFp v(significand, 0);
+    v = v.Normalize();
+    error <<= -v.e;
+
+    const int dExp = static_cast<int>(decimalPosition) - static_cast<int>(i) + exp;
+
+    int actualExp;
+    DiyFp cachedPower = GetCachedPower10(dExp, &actualExp);
+    if (actualExp != dExp) {
+        static const DiyFp kPow10[] = {
+            DiyFp(RAPIDJSON_UINT64_C2(0xa0000000, 00000000), -60),  // 10^1
+            DiyFp(RAPIDJSON_UINT64_C2(0xc8000000, 00000000), -57),  // 10^2
+            DiyFp(RAPIDJSON_UINT64_C2(0xfa000000, 00000000), -54),  // 10^3
+            DiyFp(RAPIDJSON_UINT64_C2(0x9c400000, 00000000), -50),  // 10^4
+            DiyFp(RAPIDJSON_UINT64_C2(0xc3500000, 00000000), -47),  // 10^5
+            DiyFp(RAPIDJSON_UINT64_C2(0xf4240000, 00000000), -44),  // 10^6
+            DiyFp(RAPIDJSON_UINT64_C2(0x98968000, 00000000), -40)   // 10^7
+        };
+        int  adjustment = dExp - actualExp - 1;
+        RAPIDJSON_ASSERT(adjustment >= 0 && adjustment < 7);
+        v = v * kPow10[adjustment];
+        if (length + static_cast<unsigned>(adjustment)> 19u) // has more digits than decimal digits in 64-bit
+            error += kUlp / 2;
+    }
+
+    v = v * cachedPower;
+
+    error += kUlp + (error == 0 ? 0 : 1);
+
+    const int oldExp = v.e;
+    v = v.Normalize();
+    error <<= oldExp - v.e;
+
+    const unsigned effectiveSignificandSize = Double::EffectiveSignificandSize(64 + v.e);
+    unsigned precisionSize = 64 - effectiveSignificandSize;
+    if (precisionSize + kUlpShift >= 64) {
+        unsigned scaleExp = (precisionSize + kUlpShift) - 63;
+        v.f >>= scaleExp;
+        v.e += scaleExp; 
+        error = (error >> scaleExp) + 1 + static_cast<int>(kUlp);
+        precisionSize -= scaleExp;
+    }
+
+    DiyFp rounded(v.f >> precisionSize, v.e + static_cast<int>(precisionSize));
+    const uint64_t precisionBits = (v.f & ((uint64_t(1) << precisionSize) - 1)) * kUlp;
+    const uint64_t halfWay = (uint64_t(1) << (precisionSize - 1)) * kUlp;
+    if (precisionBits >= halfWay + static_cast<unsigned>(error)) {
+        rounded.f++;
+        if (rounded.f & (DiyFp::kDpHiddenBit << 1)) { // rounding overflows mantissa (issue #340)
+            rounded.f >>= 1;
+            rounded.e++;
+        }
+    }
+
+    *result = rounded.ToDouble();
+
+    return halfWay - static_cast<unsigned>(error) >= precisionBits || precisionBits >= halfWay + static_cast<unsigned>(error);
+}
+
+inline double StrtodBigInteger(double approx, const char* decimals, size_t length, size_t decimalPosition, int exp) {
+    const BigInteger dInt(decimals, length);
+    const int dExp = static_cast<int>(decimalPosition) - static_cast<int>(length) + exp;
+    Double a(approx);
+    int cmp = CheckWithinHalfULP(a.Value(), dInt, dExp);
+    if (cmp < 0)
+        return a.Value();  // within half ULP
+    else if (cmp == 0) {
+        // Round towards even
+        if (a.Significand() & 1)
+            return a.NextPositiveDouble();
+        else
+            return a.Value();
+    }
+    else // adjustment
+        return a.NextPositiveDouble();
+}
+
+inline double StrtodFullPrecision(double d, int p, const char* decimals, size_t length, size_t decimalPosition, int exp) {
+    RAPIDJSON_ASSERT(d >= 0.0);
+    RAPIDJSON_ASSERT(length >= 1);
+
+    double result;
+    if (StrtodFast(d, p, &result))
+        return result;
+
+    // Trim leading zeros
+    while (*decimals == '0' && length > 1) {
+        length--;
+        decimals++;
+        decimalPosition--;
+    }
+
+    // Trim trailing zeros
+    while (decimals[length - 1] == '0' && length > 1) {
+        length--;
+        decimalPosition--;
+        exp++;
+    }
+
+    // Trim right-most digits
+    const int kMaxDecimalDigit = 780;
+    if (static_cast<int>(length) > kMaxDecimalDigit) {
+        int delta = (static_cast<int>(length) - kMaxDecimalDigit);
+        exp += delta;
+        decimalPosition -= static_cast<unsigned>(delta);
+        length = kMaxDecimalDigit;
+    }
+
+    // If too small, underflow to zero
+    if (int(length) + exp < -324)
+        return 0.0;
+
+    if (StrtodDiyFp(decimals, length, decimalPosition, exp, &result))
+        return result;
+
+    // Use approximation from StrtodDiyFp and make adjustment with BigInteger comparison
+    return StrtodBigInteger(result, decimals, length, decimalPosition, exp);
+}
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_STRTOD_
diff --git a/engine/inc/rapidjson/internal/swap.h b/engine/inc/rapidjson/internal/swap.h
new file mode 100644
index 00000000..666e49f9
--- /dev/null
+++ b/engine/inc/rapidjson/internal/swap.h
@@ -0,0 +1,46 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_INTERNAL_SWAP_H_
+#define RAPIDJSON_INTERNAL_SWAP_H_
+
+#include "../rapidjson.h"
+
+#if defined(__clang__)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(c++98-compat)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal {
+
+//! Custom swap() to avoid dependency on C++ <algorithm> header
+/*! \tparam T Type of the arguments to swap, should be instantiated with primitive C++ types only.
+    \note This has the same semantics as std::swap().
+*/
+template <typename T>
+inline void Swap(T& a, T& b) RAPIDJSON_NOEXCEPT {
+    T tmp = a;
+        a = b;
+        b = tmp;
+}
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#if defined(__clang__)
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_INTERNAL_SWAP_H_
diff --git a/engine/inc/rapidjson/istreamwrapper.h b/engine/inc/rapidjson/istreamwrapper.h
new file mode 100644
index 00000000..f5fe2897
--- /dev/null
+++ b/engine/inc/rapidjson/istreamwrapper.h
@@ -0,0 +1,115 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_ISTREAMWRAPPER_H_
+#define RAPIDJSON_ISTREAMWRAPPER_H_
+
+#include "stream.h"
+#include <iosfwd>
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(padded)
+#endif
+
+#ifdef _MSC_VER
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(4351) // new behavior: elements of array 'array' will be default initialized
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Wrapper of \c std::basic_istream into RapidJSON's Stream concept.
+/*!
+    The classes can be wrapped including but not limited to:
+
+    - \c std::istringstream
+    - \c std::stringstream
+    - \c std::wistringstream
+    - \c std::wstringstream
+    - \c std::ifstream
+    - \c std::fstream
+    - \c std::wifstream
+    - \c std::wfstream
+
+    \tparam StreamType Class derived from \c std::basic_istream.
+*/
+   
+template <typename StreamType>
+class BasicIStreamWrapper {
+public:
+    typedef typename StreamType::char_type Ch;
+    BasicIStreamWrapper(StreamType& stream) : stream_(stream), count_(), peekBuffer_() {}
+
+    Ch Peek() const { 
+        typename StreamType::int_type c = stream_.peek();
+        return RAPIDJSON_LIKELY(c != StreamType::traits_type::eof()) ? static_cast<Ch>(c) : '\0';
+    }
+
+    Ch Take() { 
+        typename StreamType::int_type c = stream_.get();
+        if (RAPIDJSON_LIKELY(c != StreamType::traits_type::eof())) {
+            count_++;
+            return static_cast<Ch>(c);
+        }
+        else
+            return '\0';
+    }
+
+    // tellg() may return -1 when failed. So we count by ourself.
+    size_t Tell() const { return count_; }
+
+    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
+    void Put(Ch) { RAPIDJSON_ASSERT(false); }
+    void Flush() { RAPIDJSON_ASSERT(false); }
+    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
+
+    // For encoding detection only.
+    const Ch* Peek4() const {
+        RAPIDJSON_ASSERT(sizeof(Ch) == 1); // Only usable for byte stream.
+        int i;
+        bool hasError = false;
+        for (i = 0; i < 4; ++i) {
+            typename StreamType::int_type c = stream_.get();
+            if (c == StreamType::traits_type::eof()) {
+                hasError = true;
+                stream_.clear();
+                break;
+            }
+            peekBuffer_[i] = static_cast<Ch>(c);
+        }
+        for (--i; i >= 0; --i)
+            stream_.putback(peekBuffer_[i]);
+        return !hasError ? peekBuffer_ : 0;
+    }
+
+private:
+    BasicIStreamWrapper(const BasicIStreamWrapper&);
+    BasicIStreamWrapper& operator=(const BasicIStreamWrapper&);
+
+    StreamType& stream_;
+    size_t count_;  //!< Number of characters read. Note:
+    mutable Ch peekBuffer_[4];
+};
+
+typedef BasicIStreamWrapper<std::istream> IStreamWrapper;
+typedef BasicIStreamWrapper<std::wistream> WIStreamWrapper;
+
+#if defined(__clang__) || defined(_MSC_VER)
+RAPIDJSON_DIAG_POP
+#endif
+
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_ISTREAMWRAPPER_H_
diff --git a/engine/inc/rapidjson/memorybuffer.h b/engine/inc/rapidjson/memorybuffer.h
new file mode 100644
index 00000000..39bee1de
--- /dev/null
+++ b/engine/inc/rapidjson/memorybuffer.h
@@ -0,0 +1,70 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_MEMORYBUFFER_H_
+#define RAPIDJSON_MEMORYBUFFER_H_
+
+#include "stream.h"
+#include "internal/stack.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Represents an in-memory output byte stream.
+/*!
+    This class is mainly for being wrapped by EncodedOutputStream or AutoUTFOutputStream.
+
+    It is similar to FileWriteBuffer but the destination is an in-memory buffer instead of a file.
+
+    Differences between MemoryBuffer and StringBuffer:
+    1. StringBuffer has Encoding but MemoryBuffer is only a byte buffer. 
+    2. StringBuffer::GetString() returns a null-terminated string. MemoryBuffer::GetBuffer() returns a buffer without terminator.
+
+    \tparam Allocator type for allocating memory buffer.
+    \note implements Stream concept
+*/
+template <typename Allocator = CrtAllocator>
+struct GenericMemoryBuffer {
+    typedef char Ch; // byte
+
+    GenericMemoryBuffer(Allocator* allocator = 0, size_t capacity = kDefaultCapacity) : stack_(allocator, capacity) {}
+
+    void Put(Ch c) { *stack_.template Push<Ch>() = c; }
+    void Flush() {}
+
+    void Clear() { stack_.Clear(); }
+    void ShrinkToFit() { stack_.ShrinkToFit(); }
+    Ch* Push(size_t count) { return stack_.template Push<Ch>(count); }
+    void Pop(size_t count) { stack_.template Pop<Ch>(count); }
+
+    const Ch* GetBuffer() const {
+        return stack_.template Bottom<Ch>();
+    }
+
+    size_t GetSize() const { return stack_.GetSize(); }
+
+    static const size_t kDefaultCapacity = 256;
+    mutable internal::Stack<Allocator> stack_;
+};
+
+typedef GenericMemoryBuffer<> MemoryBuffer;
+
+//! Implement specialized version of PutN() with memset() for better performance.
+template<>
+inline void PutN(MemoryBuffer& memoryBuffer, char c, size_t n) {
+    std::memset(memoryBuffer.stack_.Push<char>(n), c, n * sizeof(c));
+}
+
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_MEMORYBUFFER_H_
diff --git a/engine/inc/rapidjson/memorystream.h b/engine/inc/rapidjson/memorystream.h
new file mode 100644
index 00000000..1d71d8a4
--- /dev/null
+++ b/engine/inc/rapidjson/memorystream.h
@@ -0,0 +1,71 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_MEMORYSTREAM_H_
+#define RAPIDJSON_MEMORYSTREAM_H_
+
+#include "stream.h"
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(unreachable-code)
+RAPIDJSON_DIAG_OFF(missing-noreturn)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Represents an in-memory input byte stream.
+/*!
+    This class is mainly for being wrapped by EncodedInputStream or AutoUTFInputStream.
+
+    It is similar to FileReadBuffer but the source is an in-memory buffer instead of a file.
+
+    Differences between MemoryStream and StringStream:
+    1. StringStream has encoding but MemoryStream is a byte stream.
+    2. MemoryStream needs size of the source buffer and the buffer don't need to be null terminated. StringStream assume null-terminated string as source.
+    3. MemoryStream supports Peek4() for encoding detection. StringStream is specified with an encoding so it should not have Peek4().
+    \note implements Stream concept
+*/
+struct MemoryStream {
+    typedef char Ch; // byte
+
+    MemoryStream(const Ch *src, size_t size) : src_(src), begin_(src), end_(src + size), size_(size) {}
+
+    Ch Peek() const { return RAPIDJSON_UNLIKELY(src_ == end_) ? '\0' : *src_; }
+    Ch Take() { return RAPIDJSON_UNLIKELY(src_ == end_) ? '\0' : *src_++; }
+    size_t Tell() const { return static_cast<size_t>(src_ - begin_); }
+
+    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
+    void Put(Ch) { RAPIDJSON_ASSERT(false); }
+    void Flush() { RAPIDJSON_ASSERT(false); }
+    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
+
+    // For encoding detection only.
+    const Ch* Peek4() const {
+        return Tell() + 4 <= size_ ? src_ : 0;
+    }
+
+    const Ch* src_;     //!< Current read position.
+    const Ch* begin_;   //!< Original head of the string.
+    const Ch* end_;     //!< End of stream.
+    size_t size_;       //!< Size of the stream.
+};
+
+RAPIDJSON_NAMESPACE_END
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_MEMORYBUFFER_H_
diff --git a/engine/inc/rapidjson/msinttypes/inttypes.h b/engine/inc/rapidjson/msinttypes/inttypes.h
new file mode 100644
index 00000000..18111286
--- /dev/null
+++ b/engine/inc/rapidjson/msinttypes/inttypes.h
@@ -0,0 +1,316 @@
+// ISO C9x  compliant inttypes.h for Microsoft Visual Studio
+// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 
+// 
+//  Copyright (c) 2006-2013 Alexander Chemeris
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// 
+//   1. Redistributions of source code must retain the above copyright notice,
+//      this list of conditions and the following disclaimer.
+// 
+//   2. Redistributions in binary form must reproduce the above copyright
+//      notice, this list of conditions and the following disclaimer in the
+//      documentation and/or other materials provided with the distribution.
+// 
+//   3. Neither the name of the product nor the names of its contributors may
+//      be used to endorse or promote products derived from this software
+//      without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+///////////////////////////////////////////////////////////////////////////////
+
+// The above software in this distribution may have been modified by 
+// THL A29 Limited ("Tencent Modifications"). 
+// All Tencent Modifications are Copyright (C) 2015 THL A29 Limited.
+
+#ifndef _MSC_VER // [
+#error "Use this header only with Microsoft Visual C++ compilers!"
+#endif // _MSC_VER ]
+
+#ifndef _MSC_INTTYPES_H_ // [
+#define _MSC_INTTYPES_H_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif
+
+#include "stdint.h"
+
+// miloyip: VC supports inttypes.h since VC2013
+#if _MSC_VER >= 1800
+#include <inttypes.h>
+#else
+
+// 7.8 Format conversion of integer types
+
+typedef struct {
+   intmax_t quot;
+   intmax_t rem;
+} imaxdiv_t;
+
+// 7.8.1 Macros for format specifiers
+
+#if !defined(__cplusplus) || defined(__STDC_FORMAT_MACROS) // [   See footnote 185 at page 198
+
+// The fprintf macros for signed integers are:
+#define PRId8       "d"
+#define PRIi8       "i"
+#define PRIdLEAST8  "d"
+#define PRIiLEAST8  "i"
+#define PRIdFAST8   "d"
+#define PRIiFAST8   "i"
+
+#define PRId16       "hd"
+#define PRIi16       "hi"
+#define PRIdLEAST16  "hd"
+#define PRIiLEAST16  "hi"
+#define PRIdFAST16   "hd"
+#define PRIiFAST16   "hi"
+
+#define PRId32       "I32d"
+#define PRIi32       "I32i"
+#define PRIdLEAST32  "I32d"
+#define PRIiLEAST32  "I32i"
+#define PRIdFAST32   "I32d"
+#define PRIiFAST32   "I32i"
+
+#define PRId64       "I64d"
+#define PRIi64       "I64i"
+#define PRIdLEAST64  "I64d"
+#define PRIiLEAST64  "I64i"
+#define PRIdFAST64   "I64d"
+#define PRIiFAST64   "I64i"
+
+#define PRIdMAX     "I64d"
+#define PRIiMAX     "I64i"
+
+#define PRIdPTR     "Id"
+#define PRIiPTR     "Ii"
+
+// The fprintf macros for unsigned integers are:
+#define PRIo8       "o"
+#define PRIu8       "u"
+#define PRIx8       "x"
+#define PRIX8       "X"
+#define PRIoLEAST8  "o"
+#define PRIuLEAST8  "u"
+#define PRIxLEAST8  "x"
+#define PRIXLEAST8  "X"
+#define PRIoFAST8   "o"
+#define PRIuFAST8   "u"
+#define PRIxFAST8   "x"
+#define PRIXFAST8   "X"
+
+#define PRIo16       "ho"
+#define PRIu16       "hu"
+#define PRIx16       "hx"
+#define PRIX16       "hX"
+#define PRIoLEAST16  "ho"
+#define PRIuLEAST16  "hu"
+#define PRIxLEAST16  "hx"
+#define PRIXLEAST16  "hX"
+#define PRIoFAST16   "ho"
+#define PRIuFAST16   "hu"
+#define PRIxFAST16   "hx"
+#define PRIXFAST16   "hX"
+
+#define PRIo32       "I32o"
+#define PRIu32       "I32u"
+#define PRIx32       "I32x"
+#define PRIX32       "I32X"
+#define PRIoLEAST32  "I32o"
+#define PRIuLEAST32  "I32u"
+#define PRIxLEAST32  "I32x"
+#define PRIXLEAST32  "I32X"
+#define PRIoFAST32   "I32o"
+#define PRIuFAST32   "I32u"
+#define PRIxFAST32   "I32x"
+#define PRIXFAST32   "I32X"
+
+#define PRIo64       "I64o"
+#define PRIu64       "I64u"
+#define PRIx64       "I64x"
+#define PRIX64       "I64X"
+#define PRIoLEAST64  "I64o"
+#define PRIuLEAST64  "I64u"
+#define PRIxLEAST64  "I64x"
+#define PRIXLEAST64  "I64X"
+#define PRIoFAST64   "I64o"
+#define PRIuFAST64   "I64u"
+#define PRIxFAST64   "I64x"
+#define PRIXFAST64   "I64X"
+
+#define PRIoMAX     "I64o"
+#define PRIuMAX     "I64u"
+#define PRIxMAX     "I64x"
+#define PRIXMAX     "I64X"
+
+#define PRIoPTR     "Io"
+#define PRIuPTR     "Iu"
+#define PRIxPTR     "Ix"
+#define PRIXPTR     "IX"
+
+// The fscanf macros for signed integers are:
+#define SCNd8       "d"
+#define SCNi8       "i"
+#define SCNdLEAST8  "d"
+#define SCNiLEAST8  "i"
+#define SCNdFAST8   "d"
+#define SCNiFAST8   "i"
+
+#define SCNd16       "hd"
+#define SCNi16       "hi"
+#define SCNdLEAST16  "hd"
+#define SCNiLEAST16  "hi"
+#define SCNdFAST16   "hd"
+#define SCNiFAST16   "hi"
+
+#define SCNd32       "ld"
+#define SCNi32       "li"
+#define SCNdLEAST32  "ld"
+#define SCNiLEAST32  "li"
+#define SCNdFAST32   "ld"
+#define SCNiFAST32   "li"
+
+#define SCNd64       "I64d"
+#define SCNi64       "I64i"
+#define SCNdLEAST64  "I64d"
+#define SCNiLEAST64  "I64i"
+#define SCNdFAST64   "I64d"
+#define SCNiFAST64   "I64i"
+
+#define SCNdMAX     "I64d"
+#define SCNiMAX     "I64i"
+
+#ifdef _WIN64 // [
+#  define SCNdPTR     "I64d"
+#  define SCNiPTR     "I64i"
+#else  // _WIN64 ][
+#  define SCNdPTR     "ld"
+#  define SCNiPTR     "li"
+#endif  // _WIN64 ]
+
+// The fscanf macros for unsigned integers are:
+#define SCNo8       "o"
+#define SCNu8       "u"
+#define SCNx8       "x"
+#define SCNX8       "X"
+#define SCNoLEAST8  "o"
+#define SCNuLEAST8  "u"
+#define SCNxLEAST8  "x"
+#define SCNXLEAST8  "X"
+#define SCNoFAST8   "o"
+#define SCNuFAST8   "u"
+#define SCNxFAST8   "x"
+#define SCNXFAST8   "X"
+
+#define SCNo16       "ho"
+#define SCNu16       "hu"
+#define SCNx16       "hx"
+#define SCNX16       "hX"
+#define SCNoLEAST16  "ho"
+#define SCNuLEAST16  "hu"
+#define SCNxLEAST16  "hx"
+#define SCNXLEAST16  "hX"
+#define SCNoFAST16   "ho"
+#define SCNuFAST16   "hu"
+#define SCNxFAST16   "hx"
+#define SCNXFAST16   "hX"
+
+#define SCNo32       "lo"
+#define SCNu32       "lu"
+#define SCNx32       "lx"
+#define SCNX32       "lX"
+#define SCNoLEAST32  "lo"
+#define SCNuLEAST32  "lu"
+#define SCNxLEAST32  "lx"
+#define SCNXLEAST32  "lX"
+#define SCNoFAST32   "lo"
+#define SCNuFAST32   "lu"
+#define SCNxFAST32   "lx"
+#define SCNXFAST32   "lX"
+
+#define SCNo64       "I64o"
+#define SCNu64       "I64u"
+#define SCNx64       "I64x"
+#define SCNX64       "I64X"
+#define SCNoLEAST64  "I64o"
+#define SCNuLEAST64  "I64u"
+#define SCNxLEAST64  "I64x"
+#define SCNXLEAST64  "I64X"
+#define SCNoFAST64   "I64o"
+#define SCNuFAST64   "I64u"
+#define SCNxFAST64   "I64x"
+#define SCNXFAST64   "I64X"
+
+#define SCNoMAX     "I64o"
+#define SCNuMAX     "I64u"
+#define SCNxMAX     "I64x"
+#define SCNXMAX     "I64X"
+
+#ifdef _WIN64 // [
+#  define SCNoPTR     "I64o"
+#  define SCNuPTR     "I64u"
+#  define SCNxPTR     "I64x"
+#  define SCNXPTR     "I64X"
+#else  // _WIN64 ][
+#  define SCNoPTR     "lo"
+#  define SCNuPTR     "lu"
+#  define SCNxPTR     "lx"
+#  define SCNXPTR     "lX"
+#endif  // _WIN64 ]
+
+#endif // __STDC_FORMAT_MACROS ]
+
+// 7.8.2 Functions for greatest-width integer types
+
+// 7.8.2.1 The imaxabs function
+#define imaxabs _abs64
+
+// 7.8.2.2 The imaxdiv function
+
+// This is modified version of div() function from Microsoft's div.c found
+// in %MSVC.NET%\crt\src\div.c
+#ifdef STATIC_IMAXDIV // [
+static
+#else // STATIC_IMAXDIV ][
+_inline
+#endif // STATIC_IMAXDIV ]
+imaxdiv_t __cdecl imaxdiv(intmax_t numer, intmax_t denom)
+{
+   imaxdiv_t result;
+
+   result.quot = numer / denom;
+   result.rem = numer % denom;
+
+   if (numer < 0 && result.rem > 0) {
+      // did division wrong; must fix up
+      ++result.quot;
+      result.rem -= denom;
+   }
+
+   return result;
+}
+
+// 7.8.2.3 The strtoimax and strtoumax functions
+#define strtoimax _strtoi64
+#define strtoumax _strtoui64
+
+// 7.8.2.4 The wcstoimax and wcstoumax functions
+#define wcstoimax _wcstoi64
+#define wcstoumax _wcstoui64
+
+#endif // _MSC_VER >= 1800
+
+#endif // _MSC_INTTYPES_H_ ]
diff --git a/engine/inc/rapidjson/msinttypes/stdint.h b/engine/inc/rapidjson/msinttypes/stdint.h
new file mode 100644
index 00000000..3d4477b9
--- /dev/null
+++ b/engine/inc/rapidjson/msinttypes/stdint.h
@@ -0,0 +1,300 @@
+// ISO C9x  compliant stdint.h for Microsoft Visual Studio
+// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 
+// 
+//  Copyright (c) 2006-2013 Alexander Chemeris
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// 
+//   1. Redistributions of source code must retain the above copyright notice,
+//      this list of conditions and the following disclaimer.
+// 
+//   2. Redistributions in binary form must reproduce the above copyright
+//      notice, this list of conditions and the following disclaimer in the
+//      documentation and/or other materials provided with the distribution.
+// 
+//   3. Neither the name of the product nor the names of its contributors may
+//      be used to endorse or promote products derived from this software
+//      without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+///////////////////////////////////////////////////////////////////////////////
+
+// The above software in this distribution may have been modified by 
+// THL A29 Limited ("Tencent Modifications"). 
+// All Tencent Modifications are Copyright (C) 2015 THL A29 Limited.
+
+#ifndef _MSC_VER // [
+#error "Use this header only with Microsoft Visual C++ compilers!"
+#endif // _MSC_VER ]
+
+#ifndef _MSC_STDINT_H_ // [
+#define _MSC_STDINT_H_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif
+
+// miloyip: Originally Visual Studio 2010 uses its own stdint.h. However it generates warning with INT64_C(), so change to use this file for vs2010.
+#if _MSC_VER >= 1600 // [
+#include <stdint.h>
+
+#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [   See footnote 224 at page 260
+
+#undef INT8_C
+#undef INT16_C
+#undef INT32_C
+#undef INT64_C
+#undef UINT8_C
+#undef UINT16_C
+#undef UINT32_C
+#undef UINT64_C
+
+// 7.18.4.1 Macros for minimum-width integer constants
+
+#define INT8_C(val)  val##i8
+#define INT16_C(val) val##i16
+#define INT32_C(val) val##i32
+#define INT64_C(val) val##i64
+
+#define UINT8_C(val)  val##ui8
+#define UINT16_C(val) val##ui16
+#define UINT32_C(val) val##ui32
+#define UINT64_C(val) val##ui64
+
+// 7.18.4.2 Macros for greatest-width integer constants
+// These #ifndef's are needed to prevent collisions with <boost/cstdint.hpp>.
+// Check out Issue 9 for the details.
+#ifndef INTMAX_C //   [
+#  define INTMAX_C   INT64_C
+#endif // INTMAX_C    ]
+#ifndef UINTMAX_C //  [
+#  define UINTMAX_C  UINT64_C
+#endif // UINTMAX_C   ]
+
+#endif // __STDC_CONSTANT_MACROS ]
+
+#else // ] _MSC_VER >= 1700 [
+
+#include <limits.h>
+
+// For Visual Studio 6 in C++ mode and for many Visual Studio versions when
+// compiling for ARM we have to wrap <wchar.h> include with 'extern "C++" {}'
+// or compiler would give many errors like this:
+//   error C2733: second C linkage of overloaded function 'wmemchr' not allowed
+#if defined(__cplusplus) && !defined(_M_ARM)
+extern "C" {
+#endif
+#  include <wchar.h>
+#if defined(__cplusplus) && !defined(_M_ARM)
+}
+#endif
+
+// Define _W64 macros to mark types changing their size, like intptr_t.
+#ifndef _W64
+#  if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300
+#     define _W64 __w64
+#  else
+#     define _W64
+#  endif
+#endif
+
+
+// 7.18.1 Integer types
+
+// 7.18.1.1 Exact-width integer types
+
+// Visual Studio 6 and Embedded Visual C++ 4 doesn't
+// realize that, e.g. char has the same size as __int8
+// so we give up on __intX for them.
+#if (_MSC_VER < 1300)
+   typedef signed char       int8_t;
+   typedef signed short      int16_t;
+   typedef signed int        int32_t;
+   typedef unsigned char     uint8_t;
+   typedef unsigned short    uint16_t;
+   typedef unsigned int      uint32_t;
+#else
+   typedef signed __int8     int8_t;
+   typedef signed __int16    int16_t;
+   typedef signed __int32    int32_t;
+   typedef unsigned __int8   uint8_t;
+   typedef unsigned __int16  uint16_t;
+   typedef unsigned __int32  uint32_t;
+#endif
+typedef signed __int64       int64_t;
+typedef unsigned __int64     uint64_t;
+
+
+// 7.18.1.2 Minimum-width integer types
+typedef int8_t    int_least8_t;
+typedef int16_t   int_least16_t;
+typedef int32_t   int_least32_t;
+typedef int64_t   int_least64_t;
+typedef uint8_t   uint_least8_t;
+typedef uint16_t  uint_least16_t;
+typedef uint32_t  uint_least32_t;
+typedef uint64_t  uint_least64_t;
+
+// 7.18.1.3 Fastest minimum-width integer types
+typedef int8_t    int_fast8_t;
+typedef int16_t   int_fast16_t;
+typedef int32_t   int_fast32_t;
+typedef int64_t   int_fast64_t;
+typedef uint8_t   uint_fast8_t;
+typedef uint16_t  uint_fast16_t;
+typedef uint32_t  uint_fast32_t;
+typedef uint64_t  uint_fast64_t;
+
+// 7.18.1.4 Integer types capable of holding object pointers
+#ifdef _WIN64 // [
+   typedef signed __int64    intptr_t;
+   typedef unsigned __int64  uintptr_t;
+#else // _WIN64 ][
+   typedef _W64 signed int   intptr_t;
+   typedef _W64 unsigned int uintptr_t;
+#endif // _WIN64 ]
+
+// 7.18.1.5 Greatest-width integer types
+typedef int64_t   intmax_t;
+typedef uint64_t  uintmax_t;
+
+
+// 7.18.2 Limits of specified-width integer types
+
+#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [   See footnote 220 at page 257 and footnote 221 at page 259
+
+// 7.18.2.1 Limits of exact-width integer types
+#define INT8_MIN     ((int8_t)_I8_MIN)
+#define INT8_MAX     _I8_MAX
+#define INT16_MIN    ((int16_t)_I16_MIN)
+#define INT16_MAX    _I16_MAX
+#define INT32_MIN    ((int32_t)_I32_MIN)
+#define INT32_MAX    _I32_MAX
+#define INT64_MIN    ((int64_t)_I64_MIN)
+#define INT64_MAX    _I64_MAX
+#define UINT8_MAX    _UI8_MAX
+#define UINT16_MAX   _UI16_MAX
+#define UINT32_MAX   _UI32_MAX
+#define UINT64_MAX   _UI64_MAX
+
+// 7.18.2.2 Limits of minimum-width integer types
+#define INT_LEAST8_MIN    INT8_MIN
+#define INT_LEAST8_MAX    INT8_MAX
+#define INT_LEAST16_MIN   INT16_MIN
+#define INT_LEAST16_MAX   INT16_MAX
+#define INT_LEAST32_MIN   INT32_MIN
+#define INT_LEAST32_MAX   INT32_MAX
+#define INT_LEAST64_MIN   INT64_MIN
+#define INT_LEAST64_MAX   INT64_MAX
+#define UINT_LEAST8_MAX   UINT8_MAX
+#define UINT_LEAST16_MAX  UINT16_MAX
+#define UINT_LEAST32_MAX  UINT32_MAX
+#define UINT_LEAST64_MAX  UINT64_MAX
+
+// 7.18.2.3 Limits of fastest minimum-width integer types
+#define INT_FAST8_MIN    INT8_MIN
+#define INT_FAST8_MAX    INT8_MAX
+#define INT_FAST16_MIN   INT16_MIN
+#define INT_FAST16_MAX   INT16_MAX
+#define INT_FAST32_MIN   INT32_MIN
+#define INT_FAST32_MAX   INT32_MAX
+#define INT_FAST64_MIN   INT64_MIN
+#define INT_FAST64_MAX   INT64_MAX
+#define UINT_FAST8_MAX   UINT8_MAX
+#define UINT_FAST16_MAX  UINT16_MAX
+#define UINT_FAST32_MAX  UINT32_MAX
+#define UINT_FAST64_MAX  UINT64_MAX
+
+// 7.18.2.4 Limits of integer types capable of holding object pointers
+#ifdef _WIN64 // [
+#  define INTPTR_MIN   INT64_MIN
+#  define INTPTR_MAX   INT64_MAX
+#  define UINTPTR_MAX  UINT64_MAX
+#else // _WIN64 ][
+#  define INTPTR_MIN   INT32_MIN
+#  define INTPTR_MAX   INT32_MAX
+#  define UINTPTR_MAX  UINT32_MAX
+#endif // _WIN64 ]
+
+// 7.18.2.5 Limits of greatest-width integer types
+#define INTMAX_MIN   INT64_MIN
+#define INTMAX_MAX   INT64_MAX
+#define UINTMAX_MAX  UINT64_MAX
+
+// 7.18.3 Limits of other integer types
+
+#ifdef _WIN64 // [
+#  define PTRDIFF_MIN  _I64_MIN
+#  define PTRDIFF_MAX  _I64_MAX
+#else  // _WIN64 ][
+#  define PTRDIFF_MIN  _I32_MIN
+#  define PTRDIFF_MAX  _I32_MAX
+#endif  // _WIN64 ]
+
+#define SIG_ATOMIC_MIN  INT_MIN
+#define SIG_ATOMIC_MAX  INT_MAX
+
+#ifndef SIZE_MAX // [
+#  ifdef _WIN64 // [
+#     define SIZE_MAX  _UI64_MAX
+#  else // _WIN64 ][
+#     define SIZE_MAX  _UI32_MAX
+#  endif // _WIN64 ]
+#endif // SIZE_MAX ]
+
+// WCHAR_MIN and WCHAR_MAX are also defined in <wchar.h>
+#ifndef WCHAR_MIN // [
+#  define WCHAR_MIN  0
+#endif  // WCHAR_MIN ]
+#ifndef WCHAR_MAX // [
+#  define WCHAR_MAX  _UI16_MAX
+#endif  // WCHAR_MAX ]
+
+#define WINT_MIN  0
+#define WINT_MAX  _UI16_MAX
+
+#endif // __STDC_LIMIT_MACROS ]
+
+
+// 7.18.4 Limits of other integer types
+
+#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [   See footnote 224 at page 260
+
+// 7.18.4.1 Macros for minimum-width integer constants
+
+#define INT8_C(val)  val##i8
+#define INT16_C(val) val##i16
+#define INT32_C(val) val##i32
+#define INT64_C(val) val##i64
+
+#define UINT8_C(val)  val##ui8
+#define UINT16_C(val) val##ui16
+#define UINT32_C(val) val##ui32
+#define UINT64_C(val) val##ui64
+
+// 7.18.4.2 Macros for greatest-width integer constants
+// These #ifndef's are needed to prevent collisions with <boost/cstdint.hpp>.
+// Check out Issue 9 for the details.
+#ifndef INTMAX_C //   [
+#  define INTMAX_C   INT64_C
+#endif // INTMAX_C    ]
+#ifndef UINTMAX_C //  [
+#  define UINTMAX_C  UINT64_C
+#endif // UINTMAX_C   ]
+
+#endif // __STDC_CONSTANT_MACROS ]
+
+#endif // _MSC_VER >= 1600 ]
+
+#endif // _MSC_STDINT_H_ ]
diff --git a/engine/inc/rapidjson/ostreamwrapper.h b/engine/inc/rapidjson/ostreamwrapper.h
new file mode 100644
index 00000000..6f4667c0
--- /dev/null
+++ b/engine/inc/rapidjson/ostreamwrapper.h
@@ -0,0 +1,81 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_OSTREAMWRAPPER_H_
+#define RAPIDJSON_OSTREAMWRAPPER_H_
+
+#include "stream.h"
+#include <iosfwd>
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(padded)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Wrapper of \c std::basic_ostream into RapidJSON's Stream concept.
+/*!
+    The classes can be wrapped including but not limited to:
+
+    - \c std::ostringstream
+    - \c std::stringstream
+    - \c std::wpstringstream
+    - \c std::wstringstream
+    - \c std::ifstream
+    - \c std::fstream
+    - \c std::wofstream
+    - \c std::wfstream
+
+    \tparam StreamType Class derived from \c std::basic_ostream.
+*/
+   
+template <typename StreamType>
+class BasicOStreamWrapper {
+public:
+    typedef typename StreamType::char_type Ch;
+    BasicOStreamWrapper(StreamType& stream) : stream_(stream) {}
+
+    void Put(Ch c) {
+        stream_.put(c);
+    }
+
+    void Flush() {
+        stream_.flush();
+    }
+
+    // Not implemented
+    char Peek() const { RAPIDJSON_ASSERT(false); return 0; }
+    char Take() { RAPIDJSON_ASSERT(false); return 0; }
+    size_t Tell() const { RAPIDJSON_ASSERT(false); return 0; }
+    char* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
+    size_t PutEnd(char*) { RAPIDJSON_ASSERT(false); return 0; }
+
+private:
+    BasicOStreamWrapper(const BasicOStreamWrapper&);
+    BasicOStreamWrapper& operator=(const BasicOStreamWrapper&);
+
+    StreamType& stream_;
+};
+
+typedef BasicOStreamWrapper<std::ostream> OStreamWrapper;
+typedef BasicOStreamWrapper<std::wostream> WOStreamWrapper;
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
+
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_OSTREAMWRAPPER_H_
diff --git a/engine/inc/rapidjson/pointer.h b/engine/inc/rapidjson/pointer.h
new file mode 100644
index 00000000..0206ac1c
--- /dev/null
+++ b/engine/inc/rapidjson/pointer.h
@@ -0,0 +1,1358 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_POINTER_H_
+#define RAPIDJSON_POINTER_H_
+
+#include "document.h"
+#include "internal/itoa.h"
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(switch-enum)
+#endif
+
+#ifdef _MSC_VER
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+static const SizeType kPointerInvalidIndex = ~SizeType(0);  //!< Represents an invalid index in GenericPointer::Token
+
+//! Error code of parsing.
+/*! \ingroup RAPIDJSON_ERRORS
+    \see GenericPointer::GenericPointer, GenericPointer::GetParseErrorCode
+*/
+enum PointerParseErrorCode {
+    kPointerParseErrorNone = 0,                     //!< The parse is successful
+
+    kPointerParseErrorTokenMustBeginWithSolidus,    //!< A token must begin with a '/'
+    kPointerParseErrorInvalidEscape,                //!< Invalid escape
+    kPointerParseErrorInvalidPercentEncoding,       //!< Invalid percent encoding in URI fragment
+    kPointerParseErrorCharacterMustPercentEncode    //!< A character must percent encoded in URI fragment
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// GenericPointer
+
+//! Represents a JSON Pointer. Use Pointer for UTF8 encoding and default allocator.
+/*!
+    This class implements RFC 6901 "JavaScript Object Notation (JSON) Pointer" 
+    (https://tools.ietf.org/html/rfc6901).
+
+    A JSON pointer is for identifying a specific value in a JSON document
+    (GenericDocument). It can simplify coding of DOM tree manipulation, because it
+    can access multiple-level depth of DOM tree with single API call.
+
+    After it parses a string representation (e.g. "/foo/0" or URI fragment 
+    representation (e.g. "#/foo/0") into its internal representation (tokens),
+    it can be used to resolve a specific value in multiple documents, or sub-tree 
+    of documents.
+
+    Contrary to GenericValue, Pointer can be copy constructed and copy assigned.
+    Apart from assignment, a Pointer cannot be modified after construction.
+
+    Although Pointer is very convenient, please aware that constructing Pointer
+    involves parsing and dynamic memory allocation. A special constructor with user-
+    supplied tokens eliminates these.
+
+    GenericPointer depends on GenericDocument and GenericValue.
+    
+    \tparam ValueType The value type of the DOM tree. E.g. GenericValue<UTF8<> >
+    \tparam Allocator The allocator type for allocating memory for internal representation.
+    
+    \note GenericPointer uses same encoding of ValueType.
+    However, Allocator of GenericPointer is independent of Allocator of Value.
+*/
+template <typename ValueType, typename Allocator = CrtAllocator>
+class GenericPointer {
+public:
+    typedef typename ValueType::EncodingType EncodingType;  //!< Encoding type from Value
+    typedef typename ValueType::Ch Ch;                      //!< Character type from Value
+
+    //! A token is the basic units of internal representation.
+    /*!
+        A JSON pointer string representation "/foo/123" is parsed to two tokens: 
+        "foo" and 123. 123 will be represented in both numeric form and string form.
+        They are resolved according to the actual value type (object or array).
+
+        For token that are not numbers, or the numeric value is out of bound
+        (greater than limits of SizeType), they are only treated as string form
+        (i.e. the token's index will be equal to kPointerInvalidIndex).
+
+        This struct is public so that user can create a Pointer without parsing and 
+        allocation, using a special constructor.
+    */
+    struct Token {
+        const Ch* name;             //!< Name of the token. It has null character at the end but it can contain null character.
+        SizeType length;            //!< Length of the name.
+        SizeType index;             //!< A valid array index, if it is not equal to kPointerInvalidIndex.
+    };
+
+    //!@name Constructors and destructor.
+    //@{
+
+    //! Default constructor.
+    GenericPointer(Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {}
+
+    //! Constructor that parses a string or URI fragment representation.
+    /*!
+        \param source A null-terminated, string or URI fragment representation of JSON pointer.
+        \param allocator User supplied allocator for this pointer. If no allocator is provided, it creates a self-owned one.
+    */
+    explicit GenericPointer(const Ch* source, Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
+        Parse(source, internal::StrLen(source));
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    //! Constructor that parses a string or URI fragment representation.
+    /*!
+        \param source A string or URI fragment representation of JSON pointer.
+        \param allocator User supplied allocator for this pointer. If no allocator is provided, it creates a self-owned one.
+        \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING.
+    */
+    explicit GenericPointer(const std::basic_string<Ch>& source, Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
+        Parse(source.c_str(), source.size());
+    }
+#endif
+
+    //! Constructor that parses a string or URI fragment representation, with length of the source string.
+    /*!
+        \param source A string or URI fragment representation of JSON pointer.
+        \param length Length of source.
+        \param allocator User supplied allocator for this pointer. If no allocator is provided, it creates a self-owned one.
+        \note Slightly faster than the overload without length.
+    */
+    GenericPointer(const Ch* source, size_t length, Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
+        Parse(source, length);
+    }
+
+    //! Constructor with user-supplied tokens.
+    /*!
+        This constructor let user supplies const array of tokens.
+        This prevents the parsing process and eliminates allocation.
+        This is preferred for memory constrained environments.
+
+        \param tokens An constant array of tokens representing the JSON pointer.
+        \param tokenCount Number of tokens.
+
+        \b Example
+        \code
+        #define NAME(s) { s, sizeof(s) / sizeof(s[0]) - 1, kPointerInvalidIndex }
+        #define INDEX(i) { #i, sizeof(#i) - 1, i }
+
+        static const Pointer::Token kTokens[] = { NAME("foo"), INDEX(123) };
+        static const Pointer p(kTokens, sizeof(kTokens) / sizeof(kTokens[0]));
+        // Equivalent to static const Pointer p("/foo/123");
+
+        #undef NAME
+        #undef INDEX
+        \endcode
+    */
+    GenericPointer(const Token* tokens, size_t tokenCount) : allocator_(), ownAllocator_(), nameBuffer_(), tokens_(const_cast<Token*>(tokens)), tokenCount_(tokenCount), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {}
+
+    //! Copy constructor.
+    GenericPointer(const GenericPointer& rhs, Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
+        *this = rhs;
+    }
+
+    //! Destructor.
+    ~GenericPointer() {
+        if (nameBuffer_)    // If user-supplied tokens constructor is used, nameBuffer_ is nullptr and tokens_ are not deallocated.
+            Allocator::Free(tokens_);
+        RAPIDJSON_DELETE(ownAllocator_);
+    }
+
+    //! Assignment operator.
+    GenericPointer& operator=(const GenericPointer& rhs) {
+        if (this != &rhs) {
+            // Do not delete ownAllcator
+            if (nameBuffer_)
+                Allocator::Free(tokens_);
+
+            tokenCount_ = rhs.tokenCount_;
+            parseErrorOffset_ = rhs.parseErrorOffset_;
+            parseErrorCode_ = rhs.parseErrorCode_;
+
+            if (rhs.nameBuffer_)
+                CopyFromRaw(rhs); // Normally parsed tokens.
+            else {
+                tokens_ = rhs.tokens_; // User supplied const tokens.
+                nameBuffer_ = 0;
+            }
+        }
+        return *this;
+    }
+
+    //@}
+
+    //!@name Append token
+    //@{
+
+    //! Append a token and return a new Pointer
+    /*!
+        \param token Token to be appended.
+        \param allocator Allocator for the newly return Pointer.
+        \return A new Pointer with appended token.
+    */
+    GenericPointer Append(const Token& token, Allocator* allocator = 0) const {
+        GenericPointer r;
+        r.allocator_ = allocator;
+        Ch *p = r.CopyFromRaw(*this, 1, token.length + 1);
+        std::memcpy(p, token.name, (token.length + 1) * sizeof(Ch));
+        r.tokens_[tokenCount_].name = p;
+        r.tokens_[tokenCount_].length = token.length;
+        r.tokens_[tokenCount_].index = token.index;
+        return r;
+    }
+
+    //! Append a name token with length, and return a new Pointer
+    /*!
+        \param name Name to be appended.
+        \param length Length of name.
+        \param allocator Allocator for the newly return Pointer.
+        \return A new Pointer with appended token.
+    */
+    GenericPointer Append(const Ch* name, SizeType length, Allocator* allocator = 0) const {
+        Token token = { name, length, kPointerInvalidIndex };
+        return Append(token, allocator);
+    }
+
+    //! Append a name token without length, and return a new Pointer
+    /*!
+        \param name Name (const Ch*) to be appended.
+        \param allocator Allocator for the newly return Pointer.
+        \return A new Pointer with appended token.
+    */
+    template <typename T>
+    RAPIDJSON_DISABLEIF_RETURN((internal::NotExpr<internal::IsSame<typename internal::RemoveConst<T>::Type, Ch> >), (GenericPointer))
+    Append(T* name, Allocator* allocator = 0) const {
+        return Append(name, StrLen(name), allocator);
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    //! Append a name token, and return a new Pointer
+    /*!
+        \param name Name to be appended.
+        \param allocator Allocator for the newly return Pointer.
+        \return A new Pointer with appended token.
+    */
+    GenericPointer Append(const std::basic_string<Ch>& name, Allocator* allocator = 0) const {
+        return Append(name.c_str(), static_cast<SizeType>(name.size()), allocator);
+    }
+#endif
+
+    //! Append a index token, and return a new Pointer
+    /*!
+        \param index Index to be appended.
+        \param allocator Allocator for the newly return Pointer.
+        \return A new Pointer with appended token.
+    */
+    GenericPointer Append(SizeType index, Allocator* allocator = 0) const {
+        char buffer[21];
+        char* end = sizeof(SizeType) == 4 ? internal::u32toa(index, buffer) : internal::u64toa(index, buffer);
+        SizeType length = static_cast<SizeType>(end - buffer);
+        buffer[length] = '\0';
+
+        if (sizeof(Ch) == 1) {
+            Token token = { reinterpret_cast<Ch*>(buffer), length, index };
+            return Append(token, allocator);
+        }
+        else {
+            Ch name[21];
+            for (size_t i = 0; i <= length; i++)
+                name[i] = buffer[i];
+            Token token = { name, length, index };
+            return Append(token, allocator);
+        }
+    }
+
+    //! Append a token by value, and return a new Pointer
+    /*!
+        \param token token to be appended.
+        \param allocator Allocator for the newly return Pointer.
+        \return A new Pointer with appended token.
+    */
+    GenericPointer Append(const ValueType& token, Allocator* allocator = 0) const {
+        if (token.IsString())
+            return Append(token.GetString(), token.GetStringLength(), allocator);
+        else {
+            RAPIDJSON_ASSERT(token.IsUint64());
+            RAPIDJSON_ASSERT(token.GetUint64() <= SizeType(~0));
+            return Append(static_cast<SizeType>(token.GetUint64()), allocator);
+        }
+    }
+
+    //!@name Handling Parse Error
+    //@{
+
+    //! Check whether this is a valid pointer.
+    bool IsValid() const { return parseErrorCode_ == kPointerParseErrorNone; }
+
+    //! Get the parsing error offset in code unit.
+    size_t GetParseErrorOffset() const { return parseErrorOffset_; }
+
+    //! Get the parsing error code.
+    PointerParseErrorCode GetParseErrorCode() const { return parseErrorCode_; }
+
+    //@}
+
+    //! Get the allocator of this pointer.
+    Allocator& GetAllocator() { return *allocator_; }
+
+    //!@name Tokens
+    //@{
+
+    //! Get the token array (const version only).
+    const Token* GetTokens() const { return tokens_; }
+
+    //! Get the number of tokens.
+    size_t GetTokenCount() const { return tokenCount_; }
+
+    //@}
+
+    //!@name Equality/inequality operators
+    //@{
+
+    //! Equality operator.
+    /*!
+        \note When any pointers are invalid, always returns false.
+    */
+    bool operator==(const GenericPointer& rhs) const {
+        if (!IsValid() || !rhs.IsValid() || tokenCount_ != rhs.tokenCount_)
+            return false;
+
+        for (size_t i = 0; i < tokenCount_; i++) {
+            if (tokens_[i].index != rhs.tokens_[i].index ||
+                tokens_[i].length != rhs.tokens_[i].length || 
+                (tokens_[i].length != 0 && std::memcmp(tokens_[i].name, rhs.tokens_[i].name, sizeof(Ch)* tokens_[i].length) != 0))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    //! Inequality operator.
+    /*!
+        \note When any pointers are invalid, always returns true.
+    */
+    bool operator!=(const GenericPointer& rhs) const { return !(*this == rhs); }
+
+    //@}
+
+    //!@name Stringify
+    //@{
+
+    //! Stringify the pointer into string representation.
+    /*!
+        \tparam OutputStream Type of output stream.
+        \param os The output stream.
+    */
+    template<typename OutputStream>
+    bool Stringify(OutputStream& os) const {
+        return Stringify<false, OutputStream>(os);
+    }
+
+    //! Stringify the pointer into URI fragment representation.
+    /*!
+        \tparam OutputStream Type of output stream.
+        \param os The output stream.
+    */
+    template<typename OutputStream>
+    bool StringifyUriFragment(OutputStream& os) const {
+        return Stringify<true, OutputStream>(os);
+    }
+
+    //@}
+
+    //!@name Create value
+    //@{
+
+    //! Create a value in a subtree.
+    /*!
+        If the value is not exist, it creates all parent values and a JSON Null value.
+        So it always succeed and return the newly created or existing value.
+
+        Remind that it may change types of parents according to tokens, so it 
+        potentially removes previously stored values. For example, if a document 
+        was an array, and "/foo" is used to create a value, then the document 
+        will be changed to an object, and all existing array elements are lost.
+
+        \param root Root value of a DOM subtree to be resolved. It can be any value other than document root.
+        \param allocator Allocator for creating the values if the specified value or its parents are not exist.
+        \param alreadyExist If non-null, it stores whether the resolved value is already exist.
+        \return The resolved newly created (a JSON Null value), or already exists value.
+    */
+    ValueType& Create(ValueType& root, typename ValueType::AllocatorType& allocator, bool* alreadyExist = 0) const {
+        RAPIDJSON_ASSERT(IsValid());
+        ValueType* v = &root;
+        bool exist = true;
+        for (const Token *t = tokens_; t != tokens_ + tokenCount_; ++t) {
+            if (v->IsArray() && t->name[0] == '-' && t->length == 1) {
+                v->PushBack(ValueType().Move(), allocator);
+                v = &((*v)[v->Size() - 1]);
+                exist = false;
+            }
+            else {
+                if (t->index == kPointerInvalidIndex) { // must be object name
+                    if (!v->IsObject())
+                        v->SetObject(); // Change to Object
+                }
+                else { // object name or array index
+                    if (!v->IsArray() && !v->IsObject())
+                        v->SetArray(); // Change to Array
+                }
+
+                if (v->IsArray()) {
+                    if (t->index >= v->Size()) {
+                        v->Reserve(t->index + 1, allocator);
+                        while (t->index >= v->Size())
+                            v->PushBack(ValueType().Move(), allocator);
+                        exist = false;
+                    }
+                    v = &((*v)[t->index]);
+                }
+                else {
+                    typename ValueType::MemberIterator m = v->FindMember(GenericStringRef<Ch>(t->name, t->length));
+                    if (m == v->MemberEnd()) {
+                        v->AddMember(ValueType(t->name, t->length, allocator).Move(), ValueType().Move(), allocator);
+                        v = &(--v->MemberEnd())->value; // Assumes AddMember() appends at the end
+                        exist = false;
+                    }
+                    else
+                        v = &m->value;
+                }
+            }
+        }
+
+        if (alreadyExist)
+            *alreadyExist = exist;
+
+        return *v;
+    }
+
+    //! Creates a value in a document.
+    /*!
+        \param document A document to be resolved.
+        \param alreadyExist If non-null, it stores whether the resolved value is already exist.
+        \return The resolved newly created, or already exists value.
+    */
+    template <typename stackAllocator>
+    ValueType& Create(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, bool* alreadyExist = 0) const {
+        return Create(document, document.GetAllocator(), alreadyExist);
+    }
+
+    //@}
+
+    //!@name Query value
+    //@{
+
+    //! Query a value in a subtree.
+    /*!
+        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
+        \param unresolvedTokenIndex If the pointer cannot resolve a token in the pointer, this parameter can obtain the index of unresolved token.
+        \return Pointer to the value if it can be resolved. Otherwise null.
+
+        \note
+        There are only 3 situations when a value cannot be resolved:
+        1. A value in the path is not an array nor object.
+        2. An object value does not contain the token.
+        3. A token is out of range of an array value.
+
+        Use unresolvedTokenIndex to retrieve the token index.
+    */
+    ValueType* Get(ValueType& root, size_t* unresolvedTokenIndex = 0) const {
+        RAPIDJSON_ASSERT(IsValid());
+        ValueType* v = &root;
+        for (const Token *t = tokens_; t != tokens_ + tokenCount_; ++t) {
+            switch (v->GetType()) {
+            case kObjectType:
+                {
+                    typename ValueType::MemberIterator m = v->FindMember(GenericStringRef<Ch>(t->name, t->length));
+                    if (m == v->MemberEnd())
+                        break;
+                    v = &m->value;
+                }
+                continue;
+            case kArrayType:
+                if (t->index == kPointerInvalidIndex || t->index >= v->Size())
+                    break;
+                v = &((*v)[t->index]);
+                continue;
+            default:
+                break;
+            }
+
+            // Error: unresolved token
+            if (unresolvedTokenIndex)
+                *unresolvedTokenIndex = static_cast<size_t>(t - tokens_);
+            return 0;
+        }
+        return v;
+    }
+
+    //! Query a const value in a const subtree.
+    /*!
+        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
+        \return Pointer to the value if it can be resolved. Otherwise null.
+    */
+    const ValueType* Get(const ValueType& root, size_t* unresolvedTokenIndex = 0) const { 
+        return Get(const_cast<ValueType&>(root), unresolvedTokenIndex);
+    }
+
+    //@}
+
+    //!@name Query a value with default
+    //@{
+
+    //! Query a value in a subtree with default value.
+    /*!
+        Similar to Get(), but if the specified value do not exists, it creates all parents and clone the default value.
+        So that this function always succeed.
+
+        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
+        \param defaultValue Default value to be cloned if the value was not exists.
+        \param allocator Allocator for creating the values if the specified value or its parents are not exist.
+        \see Create()
+    */
+    ValueType& GetWithDefault(ValueType& root, const ValueType& defaultValue, typename ValueType::AllocatorType& allocator) const {
+        bool alreadyExist;
+        Value& v = Create(root, allocator, &alreadyExist);
+        return alreadyExist ? v : v.CopyFrom(defaultValue, allocator);
+    }
+
+    //! Query a value in a subtree with default null-terminated string.
+    ValueType& GetWithDefault(ValueType& root, const Ch* defaultValue, typename ValueType::AllocatorType& allocator) const {
+        bool alreadyExist;
+        Value& v = Create(root, allocator, &alreadyExist);
+        return alreadyExist ? v : v.SetString(defaultValue, allocator);
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    //! Query a value in a subtree with default std::basic_string.
+    ValueType& GetWithDefault(ValueType& root, const std::basic_string<Ch>& defaultValue, typename ValueType::AllocatorType& allocator) const {
+        bool alreadyExist;
+        Value& v = Create(root, allocator, &alreadyExist);
+        return alreadyExist ? v : v.SetString(defaultValue, allocator);
+    }
+#endif
+
+    //! Query a value in a subtree with default primitive value.
+    /*!
+        \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool
+    */
+    template <typename T>
+    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType&))
+    GetWithDefault(ValueType& root, T defaultValue, typename ValueType::AllocatorType& allocator) const {
+        return GetWithDefault(root, ValueType(defaultValue).Move(), allocator);
+    }
+
+    //! Query a value in a document with default value.
+    template <typename stackAllocator>
+    ValueType& GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, const ValueType& defaultValue) const {
+        return GetWithDefault(document, defaultValue, document.GetAllocator());
+    }
+
+    //! Query a value in a document with default null-terminated string.
+    template <typename stackAllocator>
+    ValueType& GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, const Ch* defaultValue) const {
+        return GetWithDefault(document, defaultValue, document.GetAllocator());
+    }
+    
+#if RAPIDJSON_HAS_STDSTRING
+    //! Query a value in a document with default std::basic_string.
+    template <typename stackAllocator>
+    ValueType& GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, const std::basic_string<Ch>& defaultValue) const {
+        return GetWithDefault(document, defaultValue, document.GetAllocator());
+    }
+#endif
+
+    //! Query a value in a document with default primitive value.
+    /*!
+        \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool
+    */
+    template <typename T, typename stackAllocator>
+    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType&))
+    GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, T defaultValue) const {
+        return GetWithDefault(document, defaultValue, document.GetAllocator());
+    }
+
+    //@}
+
+    //!@name Set a value
+    //@{
+
+    //! Set a value in a subtree, with move semantics.
+    /*!
+        It creates all parents if they are not exist or types are different to the tokens.
+        So this function always succeeds but potentially remove existing values.
+
+        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
+        \param value Value to be set.
+        \param allocator Allocator for creating the values if the specified value or its parents are not exist.
+        \see Create()
+    */
+    ValueType& Set(ValueType& root, ValueType& value, typename ValueType::AllocatorType& allocator) const {
+        return Create(root, allocator) = value;
+    }
+
+    //! Set a value in a subtree, with copy semantics.
+    ValueType& Set(ValueType& root, const ValueType& value, typename ValueType::AllocatorType& allocator) const {
+        return Create(root, allocator).CopyFrom(value, allocator);
+    }
+
+    //! Set a null-terminated string in a subtree.
+    ValueType& Set(ValueType& root, const Ch* value, typename ValueType::AllocatorType& allocator) const {
+        return Create(root, allocator) = ValueType(value, allocator).Move();
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    //! Set a std::basic_string in a subtree.
+    ValueType& Set(ValueType& root, const std::basic_string<Ch>& value, typename ValueType::AllocatorType& allocator) const {
+        return Create(root, allocator) = ValueType(value, allocator).Move();
+    }
+#endif
+
+    //! Set a primitive value in a subtree.
+    /*!
+        \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool
+    */
+    template <typename T>
+    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType&))
+    Set(ValueType& root, T value, typename ValueType::AllocatorType& allocator) const {
+        return Create(root, allocator) = ValueType(value).Move();
+    }
+
+    //! Set a value in a document, with move semantics.
+    template <typename stackAllocator>
+    ValueType& Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, ValueType& value) const {
+        return Create(document) = value;
+    }
+
+    //! Set a value in a document, with copy semantics.
+    template <typename stackAllocator>
+    ValueType& Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, const ValueType& value) const {
+        return Create(document).CopyFrom(value, document.GetAllocator());
+    }
+
+    //! Set a null-terminated string in a document.
+    template <typename stackAllocator>
+    ValueType& Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, const Ch* value) const {
+        return Create(document) = ValueType(value, document.GetAllocator()).Move();
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    //! Sets a std::basic_string in a document.
+    template <typename stackAllocator>
+    ValueType& Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, const std::basic_string<Ch>& value) const {
+        return Create(document) = ValueType(value, document.GetAllocator()).Move();
+    }
+#endif
+
+    //! Set a primitive value in a document.
+    /*!
+    \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool
+    */
+    template <typename T, typename stackAllocator>
+    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType&))
+        Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, T value) const {
+            return Create(document) = value;
+    }
+
+    //@}
+
+    //!@name Swap a value
+    //@{
+
+    //! Swap a value with a value in a subtree.
+    /*!
+        It creates all parents if they are not exist or types are different to the tokens.
+        So this function always succeeds but potentially remove existing values.
+
+        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
+        \param value Value to be swapped.
+        \param allocator Allocator for creating the values if the specified value or its parents are not exist.
+        \see Create()
+    */
+    ValueType& Swap(ValueType& root, ValueType& value, typename ValueType::AllocatorType& allocator) const {
+        return Create(root, allocator).Swap(value);
+    }
+
+    //! Swap a value with a value in a document.
+    template <typename stackAllocator>
+    ValueType& Swap(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, ValueType& value) const {
+        return Create(document).Swap(value);
+    }
+
+    //@}
+
+    //! Erase a value in a subtree.
+    /*!
+        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
+        \return Whether the resolved value is found and erased.
+
+        \note Erasing with an empty pointer \c Pointer(""), i.e. the root, always fail and return false.
+    */
+    bool Erase(ValueType& root) const {
+        RAPIDJSON_ASSERT(IsValid());
+        if (tokenCount_ == 0) // Cannot erase the root
+            return false;
+
+        ValueType* v = &root;
+        const Token* last = tokens_ + (tokenCount_ - 1);
+        for (const Token *t = tokens_; t != last; ++t) {
+            switch (v->GetType()) {
+            case kObjectType:
+                {
+                    typename ValueType::MemberIterator m = v->FindMember(GenericStringRef<Ch>(t->name, t->length));
+                    if (m == v->MemberEnd())
+                        return false;
+                    v = &m->value;
+                }
+                break;
+            case kArrayType:
+                if (t->index == kPointerInvalidIndex || t->index >= v->Size())
+                    return false;
+                v = &((*v)[t->index]);
+                break;
+            default:
+                return false;
+            }
+        }
+
+        switch (v->GetType()) {
+        case kObjectType:
+            return v->EraseMember(GenericStringRef<Ch>(last->name, last->length));
+        case kArrayType:
+            if (last->index == kPointerInvalidIndex || last->index >= v->Size())
+                return false;
+            v->Erase(v->Begin() + last->index);
+            return true;
+        default:
+            return false;
+        }
+    }
+
+private:
+    //! Clone the content from rhs to this.
+    /*!
+        \param rhs Source pointer.
+        \param extraToken Extra tokens to be allocated.
+        \param extraNameBufferSize Extra name buffer size (in number of Ch) to be allocated.
+        \return Start of non-occupied name buffer, for storing extra names.
+    */
+    Ch* CopyFromRaw(const GenericPointer& rhs, size_t extraToken = 0, size_t extraNameBufferSize = 0) {
+        if (!allocator_) // allocator is independently owned.
+            ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator());
+
+        size_t nameBufferSize = rhs.tokenCount_; // null terminators for tokens
+        for (Token *t = rhs.tokens_; t != rhs.tokens_ + rhs.tokenCount_; ++t)
+            nameBufferSize += t->length;
+
+        tokenCount_ = rhs.tokenCount_ + extraToken;
+        tokens_ = static_cast<Token *>(allocator_->Malloc(tokenCount_ * sizeof(Token) + (nameBufferSize + extraNameBufferSize) * sizeof(Ch)));
+        nameBuffer_ = reinterpret_cast<Ch *>(tokens_ + tokenCount_);
+        if (rhs.tokenCount_ > 0) {
+            std::memcpy(tokens_, rhs.tokens_, rhs.tokenCount_ * sizeof(Token));
+        }
+        if (nameBufferSize > 0) {
+            std::memcpy(nameBuffer_, rhs.nameBuffer_, nameBufferSize * sizeof(Ch));
+        }
+
+        // Adjust pointers to name buffer
+        std::ptrdiff_t diff = nameBuffer_ - rhs.nameBuffer_;
+        for (Token *t = tokens_; t != tokens_ + rhs.tokenCount_; ++t)
+            t->name += diff;
+
+        return nameBuffer_ + nameBufferSize;
+    }
+
+    //! Check whether a character should be percent-encoded.
+    /*!
+        According to RFC 3986 2.3 Unreserved Characters.
+        \param c The character (code unit) to be tested.
+    */
+    bool NeedPercentEncode(Ch c) const {
+        return !((c >= '0' && c <= '9') || (c >= 'A' && c <='Z') || (c >= 'a' && c <= 'z') || c == '-' || c == '.' || c == '_' || c =='~');
+    }
+
+    //! Parse a JSON String or its URI fragment representation into tokens.
+#ifndef __clang__ // -Wdocumentation
+    /*!
+        \param source Either a JSON Pointer string, or its URI fragment representation. Not need to be null terminated.
+        \param length Length of the source string.
+        \note Source cannot be JSON String Representation of JSON Pointer, e.g. In "/\u0000", \u0000 will not be unescaped.
+    */
+#endif
+    void Parse(const Ch* source, size_t length) {
+        RAPIDJSON_ASSERT(source != NULL);
+        RAPIDJSON_ASSERT(nameBuffer_ == 0);
+        RAPIDJSON_ASSERT(tokens_ == 0);
+
+        // Create own allocator if user did not supply.
+        if (!allocator_)
+            ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator());
+
+        // Count number of '/' as tokenCount
+        tokenCount_ = 0;
+        for (const Ch* s = source; s != source + length; s++) 
+            if (*s == '/')
+                tokenCount_++;
+
+        Token* token = tokens_ = static_cast<Token *>(allocator_->Malloc(tokenCount_ * sizeof(Token) + length * sizeof(Ch)));
+        Ch* name = nameBuffer_ = reinterpret_cast<Ch *>(tokens_ + tokenCount_);
+        size_t i = 0;
+
+        // Detect if it is a URI fragment
+        bool uriFragment = false;
+        if (source[i] == '#') {
+            uriFragment = true;
+            i++;
+        }
+
+        if (i != length && source[i] != '/') {
+            parseErrorCode_ = kPointerParseErrorTokenMustBeginWithSolidus;
+            goto error;
+        }
+
+        while (i < length) {
+            RAPIDJSON_ASSERT(source[i] == '/');
+            i++; // consumes '/'
+
+            token->name = name;
+            bool isNumber = true;
+
+            while (i < length && source[i] != '/') {
+                Ch c = source[i];
+                if (uriFragment) {
+                    // Decoding percent-encoding for URI fragment
+                    if (c == '%') {
+                        PercentDecodeStream is(&source[i], source + length);
+                        GenericInsituStringStream<EncodingType> os(name);
+                        Ch* begin = os.PutBegin();
+                        if (!Transcoder<UTF8<>, EncodingType>().Validate(is, os) || !is.IsValid()) {
+                            parseErrorCode_ = kPointerParseErrorInvalidPercentEncoding;
+                            goto error;
+                        }
+                        size_t len = os.PutEnd(begin);
+                        i += is.Tell() - 1;
+                        if (len == 1)
+                            c = *name;
+                        else {
+                            name += len;
+                            isNumber = false;
+                            i++;
+                            continue;
+                        }
+                    }
+                    else if (NeedPercentEncode(c)) {
+                        parseErrorCode_ = kPointerParseErrorCharacterMustPercentEncode;
+                        goto error;
+                    }
+                }
+
+                i++;
+                
+                // Escaping "~0" -> '~', "~1" -> '/'
+                if (c == '~') {
+                    if (i < length) {
+                        c = source[i];
+                        if (c == '0')       c = '~';
+                        else if (c == '1')  c = '/';
+                        else {
+                            parseErrorCode_ = kPointerParseErrorInvalidEscape;
+                            goto error;
+                        }
+                        i++;
+                    }
+                    else {
+                        parseErrorCode_ = kPointerParseErrorInvalidEscape;
+                        goto error;
+                    }
+                }
+
+                // First check for index: all of characters are digit
+                if (c < '0' || c > '9')
+                    isNumber = false;
+
+                *name++ = c;
+            }
+            token->length = static_cast<SizeType>(name - token->name);
+            if (token->length == 0)
+                isNumber = false;
+            *name++ = '\0'; // Null terminator
+
+            // Second check for index: more than one digit cannot have leading zero
+            if (isNumber && token->length > 1 && token->name[0] == '0')
+                isNumber = false;
+
+            // String to SizeType conversion
+            SizeType n = 0;
+            if (isNumber) {
+                for (size_t j = 0; j < token->length; j++) {
+                    SizeType m = n * 10 + static_cast<SizeType>(token->name[j] - '0');
+                    if (m < n) {   // overflow detection
+                        isNumber = false;
+                        break;
+                    }
+                    n = m;
+                }
+            }
+
+            token->index = isNumber ? n : kPointerInvalidIndex;
+            token++;
+        }
+
+        RAPIDJSON_ASSERT(name <= nameBuffer_ + length); // Should not overflow buffer
+        parseErrorCode_ = kPointerParseErrorNone;
+        return;
+
+    error:
+        Allocator::Free(tokens_);
+        nameBuffer_ = 0;
+        tokens_ = 0;
+        tokenCount_ = 0;
+        parseErrorOffset_ = i;
+        return;
+    }
+
+    //! Stringify to string or URI fragment representation.
+    /*!
+        \tparam uriFragment True for stringifying to URI fragment representation. False for string representation.
+        \tparam OutputStream type of output stream.
+        \param os The output stream.
+    */
+    template<bool uriFragment, typename OutputStream>
+    bool Stringify(OutputStream& os) const {
+        RAPIDJSON_ASSERT(IsValid());
+
+        if (uriFragment)
+            os.Put('#');
+
+        for (Token *t = tokens_; t != tokens_ + tokenCount_; ++t) {
+            os.Put('/');
+            for (size_t j = 0; j < t->length; j++) {
+                Ch c = t->name[j];
+                if (c == '~') {
+                    os.Put('~');
+                    os.Put('0');
+                }
+                else if (c == '/') {
+                    os.Put('~');
+                    os.Put('1');
+                }
+                else if (uriFragment && NeedPercentEncode(c)) { 
+                    // Transcode to UTF8 sequence
+                    GenericStringStream<typename ValueType::EncodingType> source(&t->name[j]);
+                    PercentEncodeStream<OutputStream> target(os);
+                    if (!Transcoder<EncodingType, UTF8<> >().Validate(source, target))
+                        return false;
+                    j += source.Tell() - 1;
+                }
+                else
+                    os.Put(c);
+            }
+        }
+        return true;
+    }
+
+    //! A helper stream for decoding a percent-encoded sequence into code unit.
+    /*!
+        This stream decodes %XY triplet into code unit (0-255).
+        If it encounters invalid characters, it sets output code unit as 0 and 
+        mark invalid, and to be checked by IsValid().
+    */
+    class PercentDecodeStream {
+    public:
+        typedef typename ValueType::Ch Ch;
+
+        //! Constructor
+        /*!
+            \param source Start of the stream
+            \param end Past-the-end of the stream.
+        */
+        PercentDecodeStream(const Ch* source, const Ch* end) : src_(source), head_(source), end_(end), valid_(true) {}
+
+        Ch Take() {
+            if (*src_ != '%' || src_ + 3 > end_) { // %XY triplet
+                valid_ = false;
+                return 0;
+            }
+            src_++;
+            Ch c = 0;
+            for (int j = 0; j < 2; j++) {
+                c = static_cast<Ch>(c << 4);
+                Ch h = *src_;
+                if      (h >= '0' && h <= '9') c = static_cast<Ch>(c + h - '0');
+                else if (h >= 'A' && h <= 'F') c = static_cast<Ch>(c + h - 'A' + 10);
+                else if (h >= 'a' && h <= 'f') c = static_cast<Ch>(c + h - 'a' + 10);
+                else {
+                    valid_ = false;
+                    return 0;
+                }
+                src_++;
+            }
+            return c;
+        }
+
+        size_t Tell() const { return static_cast<size_t>(src_ - head_); }
+        bool IsValid() const { return valid_; }
+
+    private:
+        const Ch* src_;     //!< Current read position.
+        const Ch* head_;    //!< Original head of the string.
+        const Ch* end_;     //!< Past-the-end position.
+        bool valid_;        //!< Whether the parsing is valid.
+    };
+
+    //! A helper stream to encode character (UTF-8 code unit) into percent-encoded sequence.
+    template <typename OutputStream>
+    class PercentEncodeStream {
+    public:
+        PercentEncodeStream(OutputStream& os) : os_(os) {}
+        void Put(char c) { // UTF-8 must be byte
+            unsigned char u = static_cast<unsigned char>(c);
+            static const char hexDigits[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
+            os_.Put('%');
+            os_.Put(hexDigits[u >> 4]);
+            os_.Put(hexDigits[u & 15]);
+        }
+    private:
+        OutputStream& os_;
+    };
+
+    Allocator* allocator_;                  //!< The current allocator. It is either user-supplied or equal to ownAllocator_.
+    Allocator* ownAllocator_;               //!< Allocator owned by this Pointer.
+    Ch* nameBuffer_;                        //!< A buffer containing all names in tokens.
+    Token* tokens_;                         //!< A list of tokens.
+    size_t tokenCount_;                     //!< Number of tokens in tokens_.
+    size_t parseErrorOffset_;               //!< Offset in code unit when parsing fail.
+    PointerParseErrorCode parseErrorCode_;  //!< Parsing error code.
+};
+
+//! GenericPointer for Value (UTF-8, default allocator).
+typedef GenericPointer<Value> Pointer;
+
+//!@name Helper functions for GenericPointer
+//@{
+
+//////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+typename T::ValueType& CreateValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, typename T::AllocatorType& a) {
+    return pointer.Create(root, a);
+}
+
+template <typename T, typename CharType, size_t N>
+typename T::ValueType& CreateValueByPointer(T& root, const CharType(&source)[N], typename T::AllocatorType& a) {
+    return GenericPointer<typename T::ValueType>(source, N - 1).Create(root, a);
+}
+
+// No allocator parameter
+
+template <typename DocumentType>
+typename DocumentType::ValueType& CreateValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer) {
+    return pointer.Create(document);
+}
+
+template <typename DocumentType, typename CharType, size_t N>
+typename DocumentType::ValueType& CreateValueByPointer(DocumentType& document, const CharType(&source)[N]) {
+    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Create(document);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+typename T::ValueType* GetValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, size_t* unresolvedTokenIndex = 0) {
+    return pointer.Get(root, unresolvedTokenIndex);
+}
+
+template <typename T>
+const typename T::ValueType* GetValueByPointer(const T& root, const GenericPointer<typename T::ValueType>& pointer, size_t* unresolvedTokenIndex = 0) {
+    return pointer.Get(root, unresolvedTokenIndex);
+}
+
+template <typename T, typename CharType, size_t N>
+typename T::ValueType* GetValueByPointer(T& root, const CharType (&source)[N], size_t* unresolvedTokenIndex = 0) {
+    return GenericPointer<typename T::ValueType>(source, N - 1).Get(root, unresolvedTokenIndex);
+}
+
+template <typename T, typename CharType, size_t N>
+const typename T::ValueType* GetValueByPointer(const T& root, const CharType(&source)[N], size_t* unresolvedTokenIndex = 0) {
+    return GenericPointer<typename T::ValueType>(source, N - 1).Get(root, unresolvedTokenIndex);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+typename T::ValueType& GetValueByPointerWithDefault(T& root, const GenericPointer<typename T::ValueType>& pointer, const typename T::ValueType& defaultValue, typename T::AllocatorType& a) {
+    return pointer.GetWithDefault(root, defaultValue, a);
+}
+
+template <typename T>
+typename T::ValueType& GetValueByPointerWithDefault(T& root, const GenericPointer<typename T::ValueType>& pointer, const typename T::Ch* defaultValue, typename T::AllocatorType& a) {
+    return pointer.GetWithDefault(root, defaultValue, a);
+}
+
+#if RAPIDJSON_HAS_STDSTRING
+template <typename T>
+typename T::ValueType& GetValueByPointerWithDefault(T& root, const GenericPointer<typename T::ValueType>& pointer, const std::basic_string<typename T::Ch>& defaultValue, typename T::AllocatorType& a) {
+    return pointer.GetWithDefault(root, defaultValue, a);
+}
+#endif
+
+template <typename T, typename T2>
+RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename T::ValueType&))
+GetValueByPointerWithDefault(T& root, const GenericPointer<typename T::ValueType>& pointer, T2 defaultValue, typename T::AllocatorType& a) {
+    return pointer.GetWithDefault(root, defaultValue, a);
+}
+
+template <typename T, typename CharType, size_t N>
+typename T::ValueType& GetValueByPointerWithDefault(T& root, const CharType(&source)[N], const typename T::ValueType& defaultValue, typename T::AllocatorType& a) {
+    return GenericPointer<typename T::ValueType>(source, N - 1).GetWithDefault(root, defaultValue, a);
+}
+
+template <typename T, typename CharType, size_t N>
+typename T::ValueType& GetValueByPointerWithDefault(T& root, const CharType(&source)[N], const typename T::Ch* defaultValue, typename T::AllocatorType& a) {
+    return GenericPointer<typename T::ValueType>(source, N - 1).GetWithDefault(root, defaultValue, a);
+}
+
+#if RAPIDJSON_HAS_STDSTRING
+template <typename T, typename CharType, size_t N>
+typename T::ValueType& GetValueByPointerWithDefault(T& root, const CharType(&source)[N], const std::basic_string<typename T::Ch>& defaultValue, typename T::AllocatorType& a) {
+    return GenericPointer<typename T::ValueType>(source, N - 1).GetWithDefault(root, defaultValue, a);
+}
+#endif
+
+template <typename T, typename CharType, size_t N, typename T2>
+RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename T::ValueType&))
+GetValueByPointerWithDefault(T& root, const CharType(&source)[N], T2 defaultValue, typename T::AllocatorType& a) {
+    return GenericPointer<typename T::ValueType>(source, N - 1).GetWithDefault(root, defaultValue, a);
+}
+
+// No allocator parameter
+
+template <typename DocumentType>
+typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, const typename DocumentType::ValueType& defaultValue) {
+    return pointer.GetWithDefault(document, defaultValue);
+}
+
+template <typename DocumentType>
+typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, const typename DocumentType::Ch* defaultValue) {
+    return pointer.GetWithDefault(document, defaultValue);
+}
+
+#if RAPIDJSON_HAS_STDSTRING
+template <typename DocumentType>
+typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, const std::basic_string<typename DocumentType::Ch>& defaultValue) {
+    return pointer.GetWithDefault(document, defaultValue);
+}
+#endif
+
+template <typename DocumentType, typename T2>
+RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename DocumentType::ValueType&))
+GetValueByPointerWithDefault(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, T2 defaultValue) {
+    return pointer.GetWithDefault(document, defaultValue);
+}
+
+template <typename DocumentType, typename CharType, size_t N>
+typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const CharType(&source)[N], const typename DocumentType::ValueType& defaultValue) {
+    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).GetWithDefault(document, defaultValue);
+}
+
+template <typename DocumentType, typename CharType, size_t N>
+typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const CharType(&source)[N], const typename DocumentType::Ch* defaultValue) {
+    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).GetWithDefault(document, defaultValue);
+}
+
+#if RAPIDJSON_HAS_STDSTRING
+template <typename DocumentType, typename CharType, size_t N>
+typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const CharType(&source)[N], const std::basic_string<typename DocumentType::Ch>& defaultValue) {
+    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).GetWithDefault(document, defaultValue);
+}
+#endif
+
+template <typename DocumentType, typename CharType, size_t N, typename T2>
+RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename DocumentType::ValueType&))
+GetValueByPointerWithDefault(DocumentType& document, const CharType(&source)[N], T2 defaultValue) {
+    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).GetWithDefault(document, defaultValue);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+typename T::ValueType& SetValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, typename T::ValueType& value, typename T::AllocatorType& a) {
+    return pointer.Set(root, value, a);
+}
+
+template <typename T>
+typename T::ValueType& SetValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, const typename T::ValueType& value, typename T::AllocatorType& a) {
+    return pointer.Set(root, value, a);
+}
+
+template <typename T>
+typename T::ValueType& SetValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, const typename T::Ch* value, typename T::AllocatorType& a) {
+    return pointer.Set(root, value, a);
+}
+
+#if RAPIDJSON_HAS_STDSTRING
+template <typename T>
+typename T::ValueType& SetValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, const std::basic_string<typename T::Ch>& value, typename T::AllocatorType& a) {
+    return pointer.Set(root, value, a);
+}
+#endif
+
+template <typename T, typename T2>
+RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename T::ValueType&))
+SetValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, T2 value, typename T::AllocatorType& a) {
+    return pointer.Set(root, value, a);
+}
+
+template <typename T, typename CharType, size_t N>
+typename T::ValueType& SetValueByPointer(T& root, const CharType(&source)[N], typename T::ValueType& value, typename T::AllocatorType& a) {
+    return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
+}
+
+template <typename T, typename CharType, size_t N>
+typename T::ValueType& SetValueByPointer(T& root, const CharType(&source)[N], const typename T::ValueType& value, typename T::AllocatorType& a) {
+    return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
+}
+
+template <typename T, typename CharType, size_t N>
+typename T::ValueType& SetValueByPointer(T& root, const CharType(&source)[N], const typename T::Ch* value, typename T::AllocatorType& a) {
+    return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
+}
+
+#if RAPIDJSON_HAS_STDSTRING
+template <typename T, typename CharType, size_t N>
+typename T::ValueType& SetValueByPointer(T& root, const CharType(&source)[N], const std::basic_string<typename T::Ch>& value, typename T::AllocatorType& a) {
+    return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
+}
+#endif
+
+template <typename T, typename CharType, size_t N, typename T2>
+RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename T::ValueType&))
+SetValueByPointer(T& root, const CharType(&source)[N], T2 value, typename T::AllocatorType& a) {
+    return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
+}
+
+// No allocator parameter
+
+template <typename DocumentType>
+typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, typename DocumentType::ValueType& value) {
+    return pointer.Set(document, value);
+}
+
+template <typename DocumentType>
+typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, const typename DocumentType::ValueType& value) {
+    return pointer.Set(document, value);
+}
+
+template <typename DocumentType>
+typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, const typename DocumentType::Ch* value) {
+    return pointer.Set(document, value);
+}
+
+#if RAPIDJSON_HAS_STDSTRING
+template <typename DocumentType>
+typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, const std::basic_string<typename DocumentType::Ch>& value) {
+    return pointer.Set(document, value);
+}
+#endif
+
+template <typename DocumentType, typename T2>
+RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename DocumentType::ValueType&))
+SetValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, T2 value) {
+    return pointer.Set(document, value);
+}
+
+template <typename DocumentType, typename CharType, size_t N>
+typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const CharType(&source)[N], typename DocumentType::ValueType& value) {
+    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
+}
+
+template <typename DocumentType, typename CharType, size_t N>
+typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const CharType(&source)[N], const typename DocumentType::ValueType& value) {
+    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
+}
+
+template <typename DocumentType, typename CharType, size_t N>
+typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const CharType(&source)[N], const typename DocumentType::Ch* value) {
+    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
+}
+
+#if RAPIDJSON_HAS_STDSTRING
+template <typename DocumentType, typename CharType, size_t N>
+typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const CharType(&source)[N], const std::basic_string<typename DocumentType::Ch>& value) {
+    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
+}
+#endif
+
+template <typename DocumentType, typename CharType, size_t N, typename T2>
+RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename DocumentType::ValueType&))
+SetValueByPointer(DocumentType& document, const CharType(&source)[N], T2 value) {
+    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+typename T::ValueType& SwapValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, typename T::ValueType& value, typename T::AllocatorType& a) {
+    return pointer.Swap(root, value, a);
+}
+
+template <typename T, typename CharType, size_t N>
+typename T::ValueType& SwapValueByPointer(T& root, const CharType(&source)[N], typename T::ValueType& value, typename T::AllocatorType& a) {
+    return GenericPointer<typename T::ValueType>(source, N - 1).Swap(root, value, a);
+}
+
+template <typename DocumentType>
+typename DocumentType::ValueType& SwapValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, typename DocumentType::ValueType& value) {
+    return pointer.Swap(document, value);
+}
+
+template <typename DocumentType, typename CharType, size_t N>
+typename DocumentType::ValueType& SwapValueByPointer(DocumentType& document, const CharType(&source)[N], typename DocumentType::ValueType& value) {
+    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Swap(document, value);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+bool EraseValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer) {
+    return pointer.Erase(root);
+}
+
+template <typename T, typename CharType, size_t N>
+bool EraseValueByPointer(T& root, const CharType(&source)[N]) {
+    return GenericPointer<typename T::ValueType>(source, N - 1).Erase(root);
+}
+
+//@}
+
+RAPIDJSON_NAMESPACE_END
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
+
+#ifdef _MSC_VER
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_POINTER_H_
diff --git a/engine/inc/rapidjson/prettywriter.h b/engine/inc/rapidjson/prettywriter.h
new file mode 100644
index 00000000..0dcb0fee
--- /dev/null
+++ b/engine/inc/rapidjson/prettywriter.h
@@ -0,0 +1,255 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_PRETTYWRITER_H_
+#define RAPIDJSON_PRETTYWRITER_H_
+
+#include "writer.h"
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(effc++)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Combination of PrettyWriter format flags.
+/*! \see PrettyWriter::SetFormatOptions
+ */
+enum PrettyFormatOptions {
+    kFormatDefault = 0,         //!< Default pretty formatting.
+    kFormatSingleLineArray = 1  //!< Format arrays on a single line.
+};
+
+//! Writer with indentation and spacing.
+/*!
+    \tparam OutputStream Type of ouptut os.
+    \tparam SourceEncoding Encoding of source string.
+    \tparam TargetEncoding Encoding of output stream.
+    \tparam StackAllocator Type of allocator for allocating memory of stack.
+*/
+template<typename OutputStream, typename SourceEncoding = UTF8<>, typename TargetEncoding = UTF8<>, typename StackAllocator = CrtAllocator, unsigned writeFlags = kWriteDefaultFlags>
+class PrettyWriter : public Writer<OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags> {
+public:
+    typedef Writer<OutputStream, SourceEncoding, TargetEncoding, StackAllocator> Base;
+    typedef typename Base::Ch Ch;
+
+    //! Constructor
+    /*! \param os Output stream.
+        \param allocator User supplied allocator. If it is null, it will create a private one.
+        \param levelDepth Initial capacity of stack.
+    */
+    explicit PrettyWriter(OutputStream& os, StackAllocator* allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) : 
+        Base(os, allocator, levelDepth), indentChar_(' '), indentCharCount_(4), formatOptions_(kFormatDefault) {}
+
+
+    explicit PrettyWriter(StackAllocator* allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) : 
+        Base(allocator, levelDepth), indentChar_(' '), indentCharCount_(4) {}
+
+    //! Set custom indentation.
+    /*! \param indentChar       Character for indentation. Must be whitespace character (' ', '\\t', '\\n', '\\r').
+        \param indentCharCount  Number of indent characters for each indentation level.
+        \note The default indentation is 4 spaces.
+    */
+    PrettyWriter& SetIndent(Ch indentChar, unsigned indentCharCount) {
+        RAPIDJSON_ASSERT(indentChar == ' ' || indentChar == '\t' || indentChar == '\n' || indentChar == '\r');
+        indentChar_ = indentChar;
+        indentCharCount_ = indentCharCount;
+        return *this;
+    }
+
+    //! Set pretty writer formatting options.
+    /*! \param options Formatting options.
+    */
+    PrettyWriter& SetFormatOptions(PrettyFormatOptions options) {
+        formatOptions_ = options;
+        return *this;
+    }
+
+    /*! @name Implementation of Handler
+        \see Handler
+    */
+    //@{
+
+    bool Null()                 { PrettyPrefix(kNullType);   return Base::WriteNull(); }
+    bool Bool(bool b)           { PrettyPrefix(b ? kTrueType : kFalseType); return Base::WriteBool(b); }
+    bool Int(int i)             { PrettyPrefix(kNumberType); return Base::WriteInt(i); }
+    bool Uint(unsigned u)       { PrettyPrefix(kNumberType); return Base::WriteUint(u); }
+    bool Int64(int64_t i64)     { PrettyPrefix(kNumberType); return Base::WriteInt64(i64); }
+    bool Uint64(uint64_t u64)   { PrettyPrefix(kNumberType); return Base::WriteUint64(u64);  }
+    bool Double(double d)       { PrettyPrefix(kNumberType); return Base::WriteDouble(d); }
+
+    bool RawNumber(const Ch* str, SizeType length, bool copy = false) {
+        (void)copy;
+        PrettyPrefix(kNumberType);
+        return Base::WriteString(str, length);
+    }
+
+    bool String(const Ch* str, SizeType length, bool copy = false) {
+        (void)copy;
+        PrettyPrefix(kStringType);
+        return Base::WriteString(str, length);
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    bool String(const std::basic_string<Ch>& str) {
+        return String(str.data(), SizeType(str.size()));
+    }
+#endif
+
+    bool StartObject() {
+        PrettyPrefix(kObjectType);
+        new (Base::level_stack_.template Push<typename Base::Level>()) typename Base::Level(false);
+        return Base::WriteStartObject();
+    }
+
+    bool Key(const Ch* str, SizeType length, bool copy = false) { return String(str, length, copy); }
+
+#if RAPIDJSON_HAS_STDSTRING
+    bool Key(const std::basic_string<Ch>& str) {
+        return Key(str.data(), SizeType(str.size()));
+    }
+#endif
+	
+    bool EndObject(SizeType memberCount = 0) {
+        (void)memberCount;
+        RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level));
+        RAPIDJSON_ASSERT(!Base::level_stack_.template Top<typename Base::Level>()->inArray);
+        bool empty = Base::level_stack_.template Pop<typename Base::Level>(1)->valueCount == 0;
+
+        if (!empty) {
+            Base::os_->Put('\n');
+            WriteIndent();
+        }
+        bool ret = Base::WriteEndObject();
+        (void)ret;
+        RAPIDJSON_ASSERT(ret == true);
+        if (Base::level_stack_.Empty()) // end of json text
+            Base::os_->Flush();
+        return true;
+    }
+
+    bool StartArray() {
+        PrettyPrefix(kArrayType);
+        new (Base::level_stack_.template Push<typename Base::Level>()) typename Base::Level(true);
+        return Base::WriteStartArray();
+    }
+
+    bool EndArray(SizeType memberCount = 0) {
+        (void)memberCount;
+        RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level));
+        RAPIDJSON_ASSERT(Base::level_stack_.template Top<typename Base::Level>()->inArray);
+        bool empty = Base::level_stack_.template Pop<typename Base::Level>(1)->valueCount == 0;
+
+        if (!empty && !(formatOptions_ & kFormatSingleLineArray)) {
+            Base::os_->Put('\n');
+            WriteIndent();
+        }
+        bool ret = Base::WriteEndArray();
+        (void)ret;
+        RAPIDJSON_ASSERT(ret == true);
+        if (Base::level_stack_.Empty()) // end of json text
+            Base::os_->Flush();
+        return true;
+    }
+
+    //@}
+
+    /*! @name Convenience extensions */
+    //@{
+
+    //! Simpler but slower overload.
+    bool String(const Ch* str) { return String(str, internal::StrLen(str)); }
+    bool Key(const Ch* str) { return Key(str, internal::StrLen(str)); }
+
+    //@}
+
+    //! Write a raw JSON value.
+    /*!
+        For user to write a stringified JSON as a value.
+
+        \param json A well-formed JSON value. It should not contain null character within [0, length - 1] range.
+        \param length Length of the json.
+        \param type Type of the root of json.
+        \note When using PrettyWriter::RawValue(), the result json may not be indented correctly.
+    */
+    bool RawValue(const Ch* json, size_t length, Type type) { PrettyPrefix(type); return Base::WriteRawValue(json, length); }
+
+protected:
+    void PrettyPrefix(Type type) {
+        (void)type;
+        if (Base::level_stack_.GetSize() != 0) { // this value is not at root
+            typename Base::Level* level = Base::level_stack_.template Top<typename Base::Level>();
+
+            if (level->inArray) {
+                if (level->valueCount > 0) {
+                    Base::os_->Put(','); // add comma if it is not the first element in array
+                    if (formatOptions_ & kFormatSingleLineArray)
+                        Base::os_->Put(' ');
+                }
+
+                if (!(formatOptions_ & kFormatSingleLineArray)) {
+                    Base::os_->Put('\n');
+                    WriteIndent();
+                }
+            }
+            else {  // in object
+                if (level->valueCount > 0) {
+                    if (level->valueCount % 2 == 0) {
+                        Base::os_->Put(',');
+                        Base::os_->Put('\n');
+                    }
+                    else {
+                        Base::os_->Put(':');
+                        Base::os_->Put(' ');
+                    }
+                }
+                else
+                    Base::os_->Put('\n');
+
+                if (level->valueCount % 2 == 0)
+                    WriteIndent();
+            }
+            if (!level->inArray && level->valueCount % 2 == 0)
+                RAPIDJSON_ASSERT(type == kStringType);  // if it's in object, then even number should be a name
+            level->valueCount++;
+        }
+        else {
+            RAPIDJSON_ASSERT(!Base::hasRoot_);  // Should only has one and only one root.
+            Base::hasRoot_ = true;
+        }
+    }
+
+    void WriteIndent()  {
+        size_t count = (Base::level_stack_.GetSize() / sizeof(typename Base::Level)) * indentCharCount_;
+        PutN(*Base::os_, static_cast<typename TargetEncoding::Ch>(indentChar_), count);
+    }
+
+    Ch indentChar_;
+    unsigned indentCharCount_;
+    PrettyFormatOptions formatOptions_;
+
+private:
+    // Prohibit copy constructor & assignment operator.
+    PrettyWriter(const PrettyWriter&);
+    PrettyWriter& operator=(const PrettyWriter&);
+};
+
+RAPIDJSON_NAMESPACE_END
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_RAPIDJSON_H_
diff --git a/engine/inc/rapidjson/rapidjson.h b/engine/inc/rapidjson/rapidjson.h
new file mode 100644
index 00000000..053b2ce4
--- /dev/null
+++ b/engine/inc/rapidjson/rapidjson.h
@@ -0,0 +1,615 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_RAPIDJSON_H_
+#define RAPIDJSON_RAPIDJSON_H_
+
+/*!\file rapidjson.h
+    \brief common definitions and configuration
+    
+    \see RAPIDJSON_CONFIG
+ */
+
+/*! \defgroup RAPIDJSON_CONFIG RapidJSON configuration
+    \brief Configuration macros for library features
+
+    Some RapidJSON features are configurable to adapt the library to a wide
+    variety of platforms, environments and usage scenarios.  Most of the
+    features can be configured in terms of overriden or predefined
+    preprocessor macros at compile-time.
+
+    Some additional customization is available in the \ref RAPIDJSON_ERRORS APIs.
+
+    \note These macros should be given on the compiler command-line
+          (where applicable)  to avoid inconsistent values when compiling
+          different translation units of a single application.
+ */
+
+#include <cstdlib>  // malloc(), realloc(), free(), size_t
+#include <cstring>  // memset(), memcpy(), memmove(), memcmp()
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_VERSION_STRING
+//
+// ALWAYS synchronize the following 3 macros with corresponding variables in /CMakeLists.txt.
+//
+
+//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
+// token stringification
+#define RAPIDJSON_STRINGIFY(x) RAPIDJSON_DO_STRINGIFY(x)
+#define RAPIDJSON_DO_STRINGIFY(x) #x
+//!@endcond
+
+/*! \def RAPIDJSON_MAJOR_VERSION
+    \ingroup RAPIDJSON_CONFIG
+    \brief Major version of RapidJSON in integer.
+*/
+/*! \def RAPIDJSON_MINOR_VERSION
+    \ingroup RAPIDJSON_CONFIG
+    \brief Minor version of RapidJSON in integer.
+*/
+/*! \def RAPIDJSON_PATCH_VERSION
+    \ingroup RAPIDJSON_CONFIG
+    \brief Patch version of RapidJSON in integer.
+*/
+/*! \def RAPIDJSON_VERSION_STRING
+    \ingroup RAPIDJSON_CONFIG
+    \brief Version of RapidJSON in "<major>.<minor>.<patch>" string format.
+*/
+#define RAPIDJSON_MAJOR_VERSION 1
+#define RAPIDJSON_MINOR_VERSION 1
+#define RAPIDJSON_PATCH_VERSION 0
+#define RAPIDJSON_VERSION_STRING \
+    RAPIDJSON_STRINGIFY(RAPIDJSON_MAJOR_VERSION.RAPIDJSON_MINOR_VERSION.RAPIDJSON_PATCH_VERSION)
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_NAMESPACE_(BEGIN|END)
+/*! \def RAPIDJSON_NAMESPACE
+    \ingroup RAPIDJSON_CONFIG
+    \brief   provide custom rapidjson namespace
+
+    In order to avoid symbol clashes and/or "One Definition Rule" errors
+    between multiple inclusions of (different versions of) RapidJSON in
+    a single binary, users can customize the name of the main RapidJSON
+    namespace.
+
+    In case of a single nesting level, defining \c RAPIDJSON_NAMESPACE
+    to a custom name (e.g. \c MyRapidJSON) is sufficient.  If multiple
+    levels are needed, both \ref RAPIDJSON_NAMESPACE_BEGIN and \ref
+    RAPIDJSON_NAMESPACE_END need to be defined as well:
+
+    \code
+    // in some .cpp file
+    #define RAPIDJSON_NAMESPACE my::rapidjson
+    #define RAPIDJSON_NAMESPACE_BEGIN namespace my { namespace rapidjson {
+    #define RAPIDJSON_NAMESPACE_END   } }
+    #include "rapidjson/..."
+    \endcode
+
+    \see rapidjson
+ */
+/*! \def RAPIDJSON_NAMESPACE_BEGIN
+    \ingroup RAPIDJSON_CONFIG
+    \brief   provide custom rapidjson namespace (opening expression)
+    \see RAPIDJSON_NAMESPACE
+*/
+/*! \def RAPIDJSON_NAMESPACE_END
+    \ingroup RAPIDJSON_CONFIG
+    \brief   provide custom rapidjson namespace (closing expression)
+    \see RAPIDJSON_NAMESPACE
+*/
+#ifndef RAPIDJSON_NAMESPACE
+#define RAPIDJSON_NAMESPACE rapidjson
+#endif
+#ifndef RAPIDJSON_NAMESPACE_BEGIN
+#define RAPIDJSON_NAMESPACE_BEGIN namespace RAPIDJSON_NAMESPACE {
+#endif
+#ifndef RAPIDJSON_NAMESPACE_END
+#define RAPIDJSON_NAMESPACE_END }
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_HAS_STDSTRING
+
+#ifndef RAPIDJSON_HAS_STDSTRING
+#ifdef RAPIDJSON_DOXYGEN_RUNNING
+#define RAPIDJSON_HAS_STDSTRING 1 // force generation of documentation
+#else
+#define RAPIDJSON_HAS_STDSTRING 0 // no std::string support by default
+#endif
+/*! \def RAPIDJSON_HAS_STDSTRING
+    \ingroup RAPIDJSON_CONFIG
+    \brief Enable RapidJSON support for \c std::string
+
+    By defining this preprocessor symbol to \c 1, several convenience functions for using
+    \ref rapidjson::GenericValue with \c std::string are enabled, especially
+    for construction and comparison.
+
+    \hideinitializer
+*/
+#endif // !defined(RAPIDJSON_HAS_STDSTRING)
+
+#if RAPIDJSON_HAS_STDSTRING
+#include <string>
+#endif // RAPIDJSON_HAS_STDSTRING
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_NO_INT64DEFINE
+
+/*! \def RAPIDJSON_NO_INT64DEFINE
+    \ingroup RAPIDJSON_CONFIG
+    \brief Use external 64-bit integer types.
+
+    RapidJSON requires the 64-bit integer types \c int64_t and  \c uint64_t types
+    to be available at global scope.
+
+    If users have their own definition, define RAPIDJSON_NO_INT64DEFINE to
+    prevent RapidJSON from defining its own types.
+*/
+#ifndef RAPIDJSON_NO_INT64DEFINE
+//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
+#if defined(_MSC_VER) && (_MSC_VER < 1800)	// Visual Studio 2013
+#include "msinttypes/stdint.h"
+#include "msinttypes/inttypes.h"
+#else
+// Other compilers should have this.
+#include <stdint.h>
+#include <inttypes.h>
+#endif
+//!@endcond
+#ifdef RAPIDJSON_DOXYGEN_RUNNING
+#define RAPIDJSON_NO_INT64DEFINE
+#endif
+#endif // RAPIDJSON_NO_INT64TYPEDEF
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_FORCEINLINE
+
+#ifndef RAPIDJSON_FORCEINLINE
+//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
+#if defined(_MSC_VER) && defined(NDEBUG)
+#define RAPIDJSON_FORCEINLINE __forceinline
+#elif defined(__GNUC__) && __GNUC__ >= 4 && defined(NDEBUG)
+#define RAPIDJSON_FORCEINLINE __attribute__((always_inline))
+#else
+#define RAPIDJSON_FORCEINLINE
+#endif
+//!@endcond
+#endif // RAPIDJSON_FORCEINLINE
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_ENDIAN
+#define RAPIDJSON_LITTLEENDIAN  0   //!< Little endian machine
+#define RAPIDJSON_BIGENDIAN     1   //!< Big endian machine
+
+//! Endianness of the machine.
+/*!
+    \def RAPIDJSON_ENDIAN
+    \ingroup RAPIDJSON_CONFIG
+
+    GCC 4.6 provided macro for detecting endianness of the target machine. But other
+    compilers may not have this. User can define RAPIDJSON_ENDIAN to either
+    \ref RAPIDJSON_LITTLEENDIAN or \ref RAPIDJSON_BIGENDIAN.
+
+    Default detection implemented with reference to
+    \li https://gcc.gnu.org/onlinedocs/gcc-4.6.0/cpp/Common-Predefined-Macros.html
+    \li http://www.boost.org/doc/libs/1_42_0/boost/detail/endian.hpp
+*/
+#ifndef RAPIDJSON_ENDIAN
+// Detect with GCC 4.6's macro
+#  ifdef __BYTE_ORDER__
+#    if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#      define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
+#    elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#      define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
+#    else
+#      error Unknown machine endianess detected. User needs to define RAPIDJSON_ENDIAN.
+#    endif // __BYTE_ORDER__
+// Detect with GLIBC's endian.h
+#  elif defined(__GLIBC__)
+#    include <endian.h>
+#    if (__BYTE_ORDER == __LITTLE_ENDIAN)
+#      define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
+#    elif (__BYTE_ORDER == __BIG_ENDIAN)
+#      define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
+#    else
+#      error Unknown machine endianess detected. User needs to define RAPIDJSON_ENDIAN.
+#   endif // __GLIBC__
+// Detect with _LITTLE_ENDIAN and _BIG_ENDIAN macro
+#  elif defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN)
+#    define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
+#  elif defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN)
+#    define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
+// Detect with architecture macros
+#  elif defined(__sparc) || defined(__sparc__) || defined(_POWER) || defined(__powerpc__) || defined(__ppc__) || defined(__hpux) || defined(__hppa) || defined(_MIPSEB) || defined(_POWER) || defined(__s390__)
+#    define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
+#  elif defined(__i386__) || defined(__alpha__) || defined(__ia64) || defined(__ia64__) || defined(_M_IX86) || defined(_M_IA64) || defined(_M_ALPHA) || defined(__amd64) || defined(__amd64__) || defined(_M_AMD64) || defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || defined(__bfin__)
+#    define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
+#  elif defined(_MSC_VER) && defined(_M_ARM)
+#    define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
+#  elif defined(RAPIDJSON_DOXYGEN_RUNNING)
+#    define RAPIDJSON_ENDIAN
+#  else
+#    error Unknown machine endianess detected. User needs to define RAPIDJSON_ENDIAN.   
+#  endif
+#endif // RAPIDJSON_ENDIAN
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_64BIT
+
+//! Whether using 64-bit architecture
+#ifndef RAPIDJSON_64BIT
+#if defined(__LP64__) || (defined(__x86_64__) && defined(__ILP32__)) || defined(_WIN64) || defined(__EMSCRIPTEN__)
+#define RAPIDJSON_64BIT 1
+#else
+#define RAPIDJSON_64BIT 0
+#endif
+#endif // RAPIDJSON_64BIT
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_ALIGN
+
+//! Data alignment of the machine.
+/*! \ingroup RAPIDJSON_CONFIG
+    \param x pointer to align
+
+    Some machines require strict data alignment. Currently the default uses 4 bytes
+    alignment on 32-bit platforms and 8 bytes alignment for 64-bit platforms.
+    User can customize by defining the RAPIDJSON_ALIGN function macro.
+*/
+#ifndef RAPIDJSON_ALIGN
+#if RAPIDJSON_64BIT == 1
+#define RAPIDJSON_ALIGN(x) (((x) + static_cast<uint64_t>(7u)) & ~static_cast<uint64_t>(7u))
+#else
+#define RAPIDJSON_ALIGN(x) (((x) + 3u) & ~3u)
+#endif
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_UINT64_C2
+
+//! Construct a 64-bit literal by a pair of 32-bit integer.
+/*!
+    64-bit literal with or without ULL suffix is prone to compiler warnings.
+    UINT64_C() is C macro which cause compilation problems.
+    Use this macro to define 64-bit constants by a pair of 32-bit integer.
+*/
+#ifndef RAPIDJSON_UINT64_C2
+#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_48BITPOINTER_OPTIMIZATION
+
+//! Use only lower 48-bit address for some pointers.
+/*!
+    \ingroup RAPIDJSON_CONFIG
+
+    This optimization uses the fact that current X86-64 architecture only implement lower 48-bit virtual address.
+    The higher 16-bit can be used for storing other data.
+    \c GenericValue uses this optimization to reduce its size form 24 bytes to 16 bytes in 64-bit architecture.
+*/
+#ifndef RAPIDJSON_48BITPOINTER_OPTIMIZATION
+#if defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64) || defined(_M_X64) || defined(_M_AMD64)
+#define RAPIDJSON_48BITPOINTER_OPTIMIZATION 1
+#else
+#define RAPIDJSON_48BITPOINTER_OPTIMIZATION 0
+#endif
+#endif // RAPIDJSON_48BITPOINTER_OPTIMIZATION
+
+#if RAPIDJSON_48BITPOINTER_OPTIMIZATION == 1
+#if RAPIDJSON_64BIT != 1
+#error RAPIDJSON_48BITPOINTER_OPTIMIZATION can only be set to 1 when RAPIDJSON_64BIT=1
+#endif
+#define RAPIDJSON_SETPOINTER(type, p, x) (p = reinterpret_cast<type *>((reinterpret_cast<uintptr_t>(p) & static_cast<uintptr_t>(RAPIDJSON_UINT64_C2(0xFFFF0000, 0x00000000))) | reinterpret_cast<uintptr_t>(reinterpret_cast<const void*>(x))))
+#define RAPIDJSON_GETPOINTER(type, p) (reinterpret_cast<type *>(reinterpret_cast<uintptr_t>(p) & static_cast<uintptr_t>(RAPIDJSON_UINT64_C2(0x0000FFFF, 0xFFFFFFFF))))
+#else
+#define RAPIDJSON_SETPOINTER(type, p, x) (p = (x))
+#define RAPIDJSON_GETPOINTER(type, p) (p)
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_SSE2/RAPIDJSON_SSE42/RAPIDJSON_SIMD
+
+/*! \def RAPIDJSON_SIMD
+    \ingroup RAPIDJSON_CONFIG
+    \brief Enable SSE2/SSE4.2 optimization.
+
+    RapidJSON supports optimized implementations for some parsing operations
+    based on the SSE2 or SSE4.2 SIMD extensions on modern Intel-compatible
+    processors.
+
+    To enable these optimizations, two different symbols can be defined;
+    \code
+    // Enable SSE2 optimization.
+    #define RAPIDJSON_SSE2
+
+    // Enable SSE4.2 optimization.
+    #define RAPIDJSON_SSE42
+    \endcode
+
+    \c RAPIDJSON_SSE42 takes precedence, if both are defined.
+
+    If any of these symbols is defined, RapidJSON defines the macro
+    \c RAPIDJSON_SIMD to indicate the availability of the optimized code.
+*/
+#if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42) \
+    || defined(RAPIDJSON_DOXYGEN_RUNNING)
+#define RAPIDJSON_SIMD
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_NO_SIZETYPEDEFINE
+
+#ifndef RAPIDJSON_NO_SIZETYPEDEFINE
+/*! \def RAPIDJSON_NO_SIZETYPEDEFINE
+    \ingroup RAPIDJSON_CONFIG
+    \brief User-provided \c SizeType definition.
+
+    In order to avoid using 32-bit size types for indexing strings and arrays,
+    define this preprocessor symbol and provide the type rapidjson::SizeType
+    before including RapidJSON:
+    \code
+    #define RAPIDJSON_NO_SIZETYPEDEFINE
+    namespace rapidjson { typedef ::std::size_t SizeType; }
+    #include "rapidjson/..."
+    \endcode
+
+    \see rapidjson::SizeType
+*/
+#ifdef RAPIDJSON_DOXYGEN_RUNNING
+#define RAPIDJSON_NO_SIZETYPEDEFINE
+#endif
+RAPIDJSON_NAMESPACE_BEGIN
+//! Size type (for string lengths, array sizes, etc.)
+/*! RapidJSON uses 32-bit array/string indices even on 64-bit platforms,
+    instead of using \c size_t. Users may override the SizeType by defining
+    \ref RAPIDJSON_NO_SIZETYPEDEFINE.
+*/
+typedef unsigned SizeType;
+RAPIDJSON_NAMESPACE_END
+#endif
+
+// always import std::size_t to rapidjson namespace
+RAPIDJSON_NAMESPACE_BEGIN
+using std::size_t;
+RAPIDJSON_NAMESPACE_END
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_ASSERT
+
+//! Assertion.
+/*! \ingroup RAPIDJSON_CONFIG
+    By default, rapidjson uses C \c assert() for internal assertions.
+    User can override it by defining RAPIDJSON_ASSERT(x) macro.
+
+    \note Parsing errors are handled and can be customized by the
+          \ref RAPIDJSON_ERRORS APIs.
+*/
+#ifndef RAPIDJSON_ASSERT
+#include <cassert>
+#define RAPIDJSON_ASSERT(x) assert(x)
+#endif // RAPIDJSON_ASSERT
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_STATIC_ASSERT
+
+// Adopt from boost
+#ifndef RAPIDJSON_STATIC_ASSERT
+#ifndef __clang__
+//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
+#endif
+RAPIDJSON_NAMESPACE_BEGIN
+template <bool x> struct STATIC_ASSERTION_FAILURE;
+template <> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; };
+template<int x> struct StaticAssertTest {};
+RAPIDJSON_NAMESPACE_END
+
+#define RAPIDJSON_JOIN(X, Y) RAPIDJSON_DO_JOIN(X, Y)
+#define RAPIDJSON_DO_JOIN(X, Y) RAPIDJSON_DO_JOIN2(X, Y)
+#define RAPIDJSON_DO_JOIN2(X, Y) X##Y
+
+#if defined(__GNUC__)
+#define RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE __attribute__((unused))
+#else
+#define RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE 
+#endif
+#ifndef __clang__
+//!@endcond
+#endif
+
+/*! \def RAPIDJSON_STATIC_ASSERT
+    \brief (Internal) macro to check for conditions at compile-time
+    \param x compile-time condition
+    \hideinitializer
+ */
+#define RAPIDJSON_STATIC_ASSERT(x) \
+    typedef ::RAPIDJSON_NAMESPACE::StaticAssertTest< \
+      sizeof(::RAPIDJSON_NAMESPACE::STATIC_ASSERTION_FAILURE<bool(x) >)> \
+    RAPIDJSON_JOIN(StaticAssertTypedef, __LINE__) RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_LIKELY, RAPIDJSON_UNLIKELY
+
+//! Compiler branching hint for expression with high probability to be true.
+/*!
+    \ingroup RAPIDJSON_CONFIG
+    \param x Boolean expression likely to be true.
+*/
+#ifndef RAPIDJSON_LIKELY
+#if defined(__GNUC__) || defined(__clang__)
+#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
+#else
+#define RAPIDJSON_LIKELY(x) (x)
+#endif
+#endif
+
+//! Compiler branching hint for expression with low probability to be true.
+/*!
+    \ingroup RAPIDJSON_CONFIG
+    \param x Boolean expression unlikely to be true.
+*/
+#ifndef RAPIDJSON_UNLIKELY
+#if defined(__GNUC__) || defined(__clang__)
+#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
+#else
+#define RAPIDJSON_UNLIKELY(x) (x)
+#endif
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// Helpers
+
+//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
+
+#define RAPIDJSON_MULTILINEMACRO_BEGIN do {  
+#define RAPIDJSON_MULTILINEMACRO_END \
+} while((void)0, 0)
+
+// adopted from Boost
+#define RAPIDJSON_VERSION_CODE(x,y,z) \
+  (((x)*100000) + ((y)*100) + (z))
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_DIAG_PUSH/POP, RAPIDJSON_DIAG_OFF
+
+#if defined(__GNUC__)
+#define RAPIDJSON_GNUC \
+    RAPIDJSON_VERSION_CODE(__GNUC__,__GNUC_MINOR__,__GNUC_PATCHLEVEL__)
+#endif
+
+#if defined(__clang__) || (defined(RAPIDJSON_GNUC) && RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,2,0))
+
+#define RAPIDJSON_PRAGMA(x) _Pragma(RAPIDJSON_STRINGIFY(x))
+#define RAPIDJSON_DIAG_PRAGMA(x) RAPIDJSON_PRAGMA(GCC diagnostic x)
+#define RAPIDJSON_DIAG_OFF(x) \
+    RAPIDJSON_DIAG_PRAGMA(ignored RAPIDJSON_STRINGIFY(RAPIDJSON_JOIN(-W,x)))
+
+// push/pop support in Clang and GCC>=4.6
+#if defined(__clang__) || (defined(RAPIDJSON_GNUC) && RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0))
+#define RAPIDJSON_DIAG_PUSH RAPIDJSON_DIAG_PRAGMA(push)
+#define RAPIDJSON_DIAG_POP  RAPIDJSON_DIAG_PRAGMA(pop)
+#else // GCC >= 4.2, < 4.6
+#define RAPIDJSON_DIAG_PUSH /* ignored */
+#define RAPIDJSON_DIAG_POP /* ignored */
+#endif
+
+#elif defined(_MSC_VER)
+
+// pragma (MSVC specific)
+#define RAPIDJSON_PRAGMA(x) __pragma(x)
+#define RAPIDJSON_DIAG_PRAGMA(x) RAPIDJSON_PRAGMA(warning(x))
+
+#define RAPIDJSON_DIAG_OFF(x) RAPIDJSON_DIAG_PRAGMA(disable: x)
+#define RAPIDJSON_DIAG_PUSH RAPIDJSON_DIAG_PRAGMA(push)
+#define RAPIDJSON_DIAG_POP  RAPIDJSON_DIAG_PRAGMA(pop)
+
+#else
+
+#define RAPIDJSON_DIAG_OFF(x) /* ignored */
+#define RAPIDJSON_DIAG_PUSH   /* ignored */
+#define RAPIDJSON_DIAG_POP    /* ignored */
+
+#endif // RAPIDJSON_DIAG_*
+
+///////////////////////////////////////////////////////////////////////////////
+// C++11 features
+
+#ifndef RAPIDJSON_HAS_CXX11_RVALUE_REFS
+#if defined(__clang__)
+#if __has_feature(cxx_rvalue_references) && \
+    (defined(_LIBCPP_VERSION) || defined(__GLIBCXX__) && __GLIBCXX__ >= 20080306)
+#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 1
+#else
+#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 0
+#endif
+#elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,3,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
+      (defined(_MSC_VER) && _MSC_VER >= 1600)
+
+#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 1
+#else
+#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 0
+#endif
+#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
+
+#ifndef RAPIDJSON_HAS_CXX11_NOEXCEPT
+#if defined(__clang__)
+#define RAPIDJSON_HAS_CXX11_NOEXCEPT __has_feature(cxx_noexcept)
+#elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__))
+//    (defined(_MSC_VER) && _MSC_VER >= ????) // not yet supported
+#define RAPIDJSON_HAS_CXX11_NOEXCEPT 1
+#else
+#define RAPIDJSON_HAS_CXX11_NOEXCEPT 0
+#endif
+#endif
+#if RAPIDJSON_HAS_CXX11_NOEXCEPT
+#define RAPIDJSON_NOEXCEPT noexcept
+#else
+#define RAPIDJSON_NOEXCEPT /* noexcept */
+#endif // RAPIDJSON_HAS_CXX11_NOEXCEPT
+
+// no automatic detection, yet
+#ifndef RAPIDJSON_HAS_CXX11_TYPETRAITS
+#define RAPIDJSON_HAS_CXX11_TYPETRAITS 0
+#endif
+
+#ifndef RAPIDJSON_HAS_CXX11_RANGE_FOR
+#if defined(__clang__)
+#define RAPIDJSON_HAS_CXX11_RANGE_FOR __has_feature(cxx_range_for)
+#elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,3,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
+      (defined(_MSC_VER) && _MSC_VER >= 1700)
+#define RAPIDJSON_HAS_CXX11_RANGE_FOR 1
+#else
+#define RAPIDJSON_HAS_CXX11_RANGE_FOR 0
+#endif
+#endif // RAPIDJSON_HAS_CXX11_RANGE_FOR
+
+//!@endcond
+
+///////////////////////////////////////////////////////////////////////////////
+// new/delete
+
+#ifndef RAPIDJSON_NEW
+///! customization point for global \c new
+#define RAPIDJSON_NEW(x) new x
+#endif
+#ifndef RAPIDJSON_DELETE
+///! customization point for global \c delete
+#define RAPIDJSON_DELETE(x) delete x
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// Type
+
+/*! \namespace rapidjson
+    \brief main RapidJSON namespace
+    \see RAPIDJSON_NAMESPACE
+*/
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Type of JSON value
+enum Type {
+    kNullType = 0,      //!< null
+    kFalseType = 1,     //!< false
+    kTrueType = 2,      //!< true
+    kObjectType = 3,    //!< object
+    kArrayType = 4,     //!< array 
+    kStringType = 5,    //!< string
+    kNumberType = 6     //!< number
+};
+
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_RAPIDJSON_H_
diff --git a/engine/inc/rapidjson/reader.h b/engine/inc/rapidjson/reader.h
new file mode 100644
index 00000000..19f8849b
--- /dev/null
+++ b/engine/inc/rapidjson/reader.h
@@ -0,0 +1,1879 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_READER_H_
+#define RAPIDJSON_READER_H_
+
+/*! \file reader.h */
+
+#include "allocators.h"
+#include "stream.h"
+#include "encodedstream.h"
+#include "internal/meta.h"
+#include "internal/stack.h"
+#include "internal/strtod.h"
+#include <limits>
+
+#if defined(RAPIDJSON_SIMD) && defined(_MSC_VER)
+#include <intrin.h>
+#pragma intrinsic(_BitScanForward)
+#endif
+#ifdef RAPIDJSON_SSE42
+#include <nmmintrin.h>
+#elif defined(RAPIDJSON_SSE2)
+#include <emmintrin.h>
+#endif
+
+#ifdef _MSC_VER
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(4127)  // conditional expression is constant
+RAPIDJSON_DIAG_OFF(4702)  // unreachable code
+#endif
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(old-style-cast)
+RAPIDJSON_DIAG_OFF(padded)
+RAPIDJSON_DIAG_OFF(switch-enum)
+#endif
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(effc++)
+#endif
+
+//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
+#define RAPIDJSON_NOTHING /* deliberately empty */
+#ifndef RAPIDJSON_PARSE_ERROR_EARLY_RETURN
+#define RAPIDJSON_PARSE_ERROR_EARLY_RETURN(value) \
+    RAPIDJSON_MULTILINEMACRO_BEGIN \
+    if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
+    RAPIDJSON_MULTILINEMACRO_END
+#endif
+#define RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID \
+    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
+//!@endcond
+
+/*! \def RAPIDJSON_PARSE_ERROR_NORETURN
+    \ingroup RAPIDJSON_ERRORS
+    \brief Macro to indicate a parse error.
+    \param parseErrorCode \ref rapidjson::ParseErrorCode of the error
+    \param offset  position of the error in JSON input (\c size_t)
+
+    This macros can be used as a customization point for the internal
+    error handling mechanism of RapidJSON.
+
+    A common usage model is to throw an exception instead of requiring the
+    caller to explicitly check the \ref rapidjson::GenericReader::Parse's
+    return value:
+
+    \code
+    #define RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode,offset) \
+       throw ParseException(parseErrorCode, #parseErrorCode, offset)
+
+    #include <stdexcept>               // std::runtime_error
+    #include "rapidjson/error/error.h" // rapidjson::ParseResult
+
+    struct ParseException : std::runtime_error, rapidjson::ParseResult {
+      ParseException(rapidjson::ParseErrorCode code, const char* msg, size_t offset)
+        : std::runtime_error(msg), ParseResult(code, offset) {}
+    };
+
+    #include "rapidjson/reader.h"
+    \endcode
+
+    \see RAPIDJSON_PARSE_ERROR, rapidjson::GenericReader::Parse
+ */
+#ifndef RAPIDJSON_PARSE_ERROR_NORETURN
+#define RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset) \
+    RAPIDJSON_MULTILINEMACRO_BEGIN \
+    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
+    SetParseError(parseErrorCode, offset); \
+    RAPIDJSON_MULTILINEMACRO_END
+#endif
+
+/*! \def RAPIDJSON_PARSE_ERROR
+    \ingroup RAPIDJSON_ERRORS
+    \brief (Internal) macro to indicate and handle a parse error.
+    \param parseErrorCode \ref rapidjson::ParseErrorCode of the error
+    \param offset  position of the error in JSON input (\c size_t)
+
+    Invokes RAPIDJSON_PARSE_ERROR_NORETURN and stops the parsing.
+
+    \see RAPIDJSON_PARSE_ERROR_NORETURN
+    \hideinitializer
+ */
+#ifndef RAPIDJSON_PARSE_ERROR
+#define RAPIDJSON_PARSE_ERROR(parseErrorCode, offset) \
+    RAPIDJSON_MULTILINEMACRO_BEGIN \
+    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
+    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
+    RAPIDJSON_MULTILINEMACRO_END
+#endif
+
+#include "error/error.h" // ParseErrorCode, ParseResult
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+// ParseFlag
+
+/*! \def RAPIDJSON_PARSE_DEFAULT_FLAGS
+    \ingroup RAPIDJSON_CONFIG
+    \brief User-defined kParseDefaultFlags definition.
+
+    User can define this as any \c ParseFlag combinations.
+*/
+#ifndef RAPIDJSON_PARSE_DEFAULT_FLAGS
+#define RAPIDJSON_PARSE_DEFAULT_FLAGS kParseNoFlags
+#endif
+
+//! Combination of parseFlags
+/*! \see Reader::Parse, Document::Parse, Document::ParseInsitu, Document::ParseStream
+ */
+enum ParseFlag {
+    kParseNoFlags = 0,              //!< No flags are set.
+    kParseInsituFlag = 1,           //!< In-situ(destructive) parsing.
+    kParseValidateEncodingFlag = 2, //!< Validate encoding of JSON strings.
+    kParseIterativeFlag = 4,        //!< Iterative(constant complexity in terms of function call stack size) parsing.
+    kParseStopWhenDoneFlag = 8,     //!< After parsing a complete JSON root from stream, stop further processing the rest of stream. When this flag is used, parser will not generate kParseErrorDocumentRootNotSingular error.
+    kParseFullPrecisionFlag = 16,   //!< Parse number in full precision (but slower).
+    kParseCommentsFlag = 32,        //!< Allow one-line (//) and multi-line (/**/) comments.
+    kParseNumbersAsStringsFlag = 64,    //!< Parse all numbers (ints/doubles) as strings.
+    kParseTrailingCommasFlag = 128, //!< Allow trailing commas at the end of objects and arrays.
+    kParseNanAndInfFlag = 256,      //!< Allow parsing NaN, Inf, Infinity, -Inf and -Infinity as doubles.
+    kParseDefaultFlags = RAPIDJSON_PARSE_DEFAULT_FLAGS  //!< Default parse flags. Can be customized by defining RAPIDJSON_PARSE_DEFAULT_FLAGS
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// Handler
+
+/*! \class rapidjson::Handler
+    \brief Concept for receiving events from GenericReader upon parsing.
+    The functions return true if no error occurs. If they return false,
+    the event publisher should terminate the process.
+\code
+concept Handler {
+    typename Ch;
+
+    bool Null();
+    bool Bool(bool b);
+    bool Int(int i);
+    bool Uint(unsigned i);
+    bool Int64(int64_t i);
+    bool Uint64(uint64_t i);
+    bool Double(double d);
+    /// enabled via kParseNumbersAsStringsFlag, string is not null-terminated (use length)
+    bool RawNumber(const Ch* str, SizeType length, bool copy);
+    bool String(const Ch* str, SizeType length, bool copy);
+    bool StartObject();
+    bool Key(const Ch* str, SizeType length, bool copy);
+    bool EndObject(SizeType memberCount);
+    bool StartArray();
+    bool EndArray(SizeType elementCount);
+};
+\endcode
+*/
+///////////////////////////////////////////////////////////////////////////////
+// BaseReaderHandler
+
+//! Default implementation of Handler.
+/*! This can be used as base class of any reader handler.
+    \note implements Handler concept
+*/
+template<typename Encoding = UTF8<>, typename Derived = void>
+struct BaseReaderHandler {
+    typedef typename Encoding::Ch Ch;
+
+    typedef typename internal::SelectIf<internal::IsSame<Derived, void>, BaseReaderHandler, Derived>::Type Override;
+
+    bool Default() { return true; }
+    bool Null() { return static_cast<Override&>(*this).Default(); }
+    bool Bool(bool) { return static_cast<Override&>(*this).Default(); }
+    bool Int(int) { return static_cast<Override&>(*this).Default(); }
+    bool Uint(unsigned) { return static_cast<Override&>(*this).Default(); }
+    bool Int64(int64_t) { return static_cast<Override&>(*this).Default(); }
+    bool Uint64(uint64_t) { return static_cast<Override&>(*this).Default(); }
+    bool Double(double) { return static_cast<Override&>(*this).Default(); }
+    /// enabled via kParseNumbersAsStringsFlag, string is not null-terminated (use length)
+    bool RawNumber(const Ch* str, SizeType len, bool copy) { return static_cast<Override&>(*this).String(str, len, copy); }
+    bool String(const Ch*, SizeType, bool) { return static_cast<Override&>(*this).Default(); }
+    bool StartObject() { return static_cast<Override&>(*this).Default(); }
+    bool Key(const Ch* str, SizeType len, bool copy) { return static_cast<Override&>(*this).String(str, len, copy); }
+    bool EndObject(SizeType) { return static_cast<Override&>(*this).Default(); }
+    bool StartArray() { return static_cast<Override&>(*this).Default(); }
+    bool EndArray(SizeType) { return static_cast<Override&>(*this).Default(); }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// StreamLocalCopy
+
+namespace internal {
+
+template<typename Stream, int = StreamTraits<Stream>::copyOptimization>
+class StreamLocalCopy;
+
+//! Do copy optimization.
+template<typename Stream>
+class StreamLocalCopy<Stream, 1> {
+public:
+    StreamLocalCopy(Stream& original) : s(original), original_(original) {}
+    ~StreamLocalCopy() { original_ = s; }
+
+    Stream s;
+
+private:
+    StreamLocalCopy& operator=(const StreamLocalCopy&) /* = delete */;
+
+    Stream& original_;
+};
+
+//! Keep reference.
+template<typename Stream>
+class StreamLocalCopy<Stream, 0> {
+public:
+    StreamLocalCopy(Stream& original) : s(original) {}
+
+    Stream& s;
+
+private:
+    StreamLocalCopy& operator=(const StreamLocalCopy&) /* = delete */;
+};
+
+} // namespace internal
+
+///////////////////////////////////////////////////////////////////////////////
+// SkipWhitespace
+
+//! Skip the JSON white spaces in a stream.
+/*! \param is A input stream for skipping white spaces.
+    \note This function has SSE2/SSE4.2 specialization.
+*/
+template<typename InputStream>
+void SkipWhitespace(InputStream& is) {
+    internal::StreamLocalCopy<InputStream> copy(is);
+    InputStream& s(copy.s);
+
+    typename InputStream::Ch c;
+    while ((c = s.Peek()) == ' ' || c == '\n' || c == '\r' || c == '\t')
+        s.Take();
+}
+
+inline const char* SkipWhitespace(const char* p, const char* end) {
+    while (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t'))
+        ++p;
+    return p;
+}
+
+#ifdef RAPIDJSON_SSE42
+//! Skip whitespace with SSE 4.2 pcmpistrm instruction, testing 16 8-byte characters at once.
+inline const char *SkipWhitespace_SIMD(const char* p) {
+    // Fast return for single non-whitespace
+    if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
+        ++p;
+    else
+        return p;
+
+    // 16-byte align to the next boundary
+    const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
+    while (p != nextAligned)
+        if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
+            ++p;
+        else
+            return p;
+
+    // The rest of string using SIMD
+    static const char whitespace[16] = " \n\r\t";
+    const __m128i w = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespace[0]));
+
+    for (;; p += 16) {
+        const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
+        const int r = _mm_cvtsi128_si32(_mm_cmpistrm(w, s, _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_BIT_MASK | _SIDD_NEGATIVE_POLARITY));
+        if (r != 0) {   // some of characters is non-whitespace
+#ifdef _MSC_VER         // Find the index of first non-whitespace
+            unsigned long offset;
+            _BitScanForward(&offset, r);
+            return p + offset;
+#else
+            return p + __builtin_ffs(r) - 1;
+#endif
+        }
+    }
+}
+
+inline const char *SkipWhitespace_SIMD(const char* p, const char* end) {
+    // Fast return for single non-whitespace
+    if (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t'))
+        ++p;
+    else
+        return p;
+
+    // The middle of string using SIMD
+    static const char whitespace[16] = " \n\r\t";
+    const __m128i w = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespace[0]));
+
+    for (; p <= end - 16; p += 16) {
+        const __m128i s = _mm_loadu_si128(reinterpret_cast<const __m128i *>(p));
+        const int r = _mm_cvtsi128_si32(_mm_cmpistrm(w, s, _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_BIT_MASK | _SIDD_NEGATIVE_POLARITY));
+        if (r != 0) {   // some of characters is non-whitespace
+#ifdef _MSC_VER         // Find the index of first non-whitespace
+            unsigned long offset;
+            _BitScanForward(&offset, r);
+            return p + offset;
+#else
+            return p + __builtin_ffs(r) - 1;
+#endif
+        }
+    }
+
+    return SkipWhitespace(p, end);
+}
+
+#elif defined(RAPIDJSON_SSE2)
+
+//! Skip whitespace with SSE2 instructions, testing 16 8-byte characters at once.
+inline const char *SkipWhitespace_SIMD(const char* p) {
+    // Fast return for single non-whitespace
+    if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
+        ++p;
+    else
+        return p;
+
+    // 16-byte align to the next boundary
+    const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
+    while (p != nextAligned)
+        if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
+            ++p;
+        else
+            return p;
+
+    // The rest of string
+    #define C16(c) { c, c, c, c, c, c, c, c, c, c, c, c, c, c, c, c }
+    static const char whitespaces[4][16] = { C16(' '), C16('\n'), C16('\r'), C16('\t') };
+    #undef C16
+
+    const __m128i w0 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[0][0]));
+    const __m128i w1 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[1][0]));
+    const __m128i w2 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[2][0]));
+    const __m128i w3 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[3][0]));
+
+    for (;; p += 16) {
+        const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
+        __m128i x = _mm_cmpeq_epi8(s, w0);
+        x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w1));
+        x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w2));
+        x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w3));
+        unsigned short r = static_cast<unsigned short>(~_mm_movemask_epi8(x));
+        if (r != 0) {   // some of characters may be non-whitespace
+#ifdef _MSC_VER         // Find the index of first non-whitespace
+            unsigned long offset;
+            _BitScanForward(&offset, r);
+            return p + offset;
+#else
+            return p + __builtin_ffs(r) - 1;
+#endif
+        }
+    }
+}
+
+inline const char *SkipWhitespace_SIMD(const char* p, const char* end) {
+    // Fast return for single non-whitespace
+    if (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t'))
+        ++p;
+    else
+        return p;
+
+    // The rest of string
+    #define C16(c) { c, c, c, c, c, c, c, c, c, c, c, c, c, c, c, c }
+    static const char whitespaces[4][16] = { C16(' '), C16('\n'), C16('\r'), C16('\t') };
+    #undef C16
+
+    const __m128i w0 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[0][0]));
+    const __m128i w1 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[1][0]));
+    const __m128i w2 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[2][0]));
+    const __m128i w3 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[3][0]));
+
+    for (; p <= end - 16; p += 16) {
+        const __m128i s = _mm_loadu_si128(reinterpret_cast<const __m128i *>(p));
+        __m128i x = _mm_cmpeq_epi8(s, w0);
+        x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w1));
+        x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w2));
+        x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w3));
+        unsigned short r = static_cast<unsigned short>(~_mm_movemask_epi8(x));
+        if (r != 0) {   // some of characters may be non-whitespace
+#ifdef _MSC_VER         // Find the index of first non-whitespace
+            unsigned long offset;
+            _BitScanForward(&offset, r);
+            return p + offset;
+#else
+            return p + __builtin_ffs(r) - 1;
+#endif
+        }
+    }
+
+    return SkipWhitespace(p, end);
+}
+
+#endif // RAPIDJSON_SSE2
+
+#ifdef RAPIDJSON_SIMD
+//! Template function specialization for InsituStringStream
+template<> inline void SkipWhitespace(InsituStringStream& is) {
+    is.src_ = const_cast<char*>(SkipWhitespace_SIMD(is.src_));
+}
+
+//! Template function specialization for StringStream
+template<> inline void SkipWhitespace(StringStream& is) {
+    is.src_ = SkipWhitespace_SIMD(is.src_);
+}
+
+template<> inline void SkipWhitespace(EncodedInputStream<UTF8<>, MemoryStream>& is) {
+    is.is_.src_ = SkipWhitespace_SIMD(is.is_.src_, is.is_.end_);
+}
+#endif // RAPIDJSON_SIMD
+
+///////////////////////////////////////////////////////////////////////////////
+// GenericReader
+
+//! SAX-style JSON parser. Use \ref Reader for UTF8 encoding and default allocator.
+/*! GenericReader parses JSON text from a stream, and send events synchronously to an
+    object implementing Handler concept.
+
+    It needs to allocate a stack for storing a single decoded string during
+    non-destructive parsing.
+
+    For in-situ parsing, the decoded string is directly written to the source
+    text string, no temporary buffer is required.
+
+    A GenericReader object can be reused for parsing multiple JSON text.
+
+    \tparam SourceEncoding Encoding of the input stream.
+    \tparam TargetEncoding Encoding of the parse output.
+    \tparam StackAllocator Allocator type for stack.
+*/
+template <typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>
+class GenericReader {
+public:
+    typedef typename SourceEncoding::Ch Ch; //!< SourceEncoding character type
+
+    //! Constructor.
+    /*! \param stackAllocator Optional allocator for allocating stack memory. (Only use for non-destructive parsing)
+        \param stackCapacity stack capacity in bytes for storing a single decoded string.  (Only use for non-destructive parsing)
+    */
+    GenericReader(StackAllocator* stackAllocator = 0, size_t stackCapacity = kDefaultStackCapacity) : stack_(stackAllocator, stackCapacity), parseResult_() {}
+
+    //! Parse JSON text.
+    /*! \tparam parseFlags Combination of \ref ParseFlag.
+        \tparam InputStream Type of input stream, implementing Stream concept.
+        \tparam Handler Type of handler, implementing Handler concept.
+        \param is Input stream to be parsed.
+        \param handler The handler to receive events.
+        \return Whether the parsing is successful.
+    */
+    template <unsigned parseFlags, typename InputStream, typename Handler>
+    ParseResult Parse(InputStream& is, Handler& handler) {
+        if (parseFlags & kParseIterativeFlag)
+            return IterativeParse<parseFlags>(is, handler);
+
+        parseResult_.Clear();
+
+        ClearStackOnExit scope(*this);
+
+        SkipWhitespaceAndComments<parseFlags>(is);
+        RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
+
+        if (RAPIDJSON_UNLIKELY(is.Peek() == '\0')) {
+            RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentEmpty, is.Tell());
+            RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
+        }
+        else {
+            ParseValue<parseFlags>(is, handler);
+            RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
+
+            if (!(parseFlags & kParseStopWhenDoneFlag)) {
+                SkipWhitespaceAndComments<parseFlags>(is);
+                RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
+
+                if (RAPIDJSON_UNLIKELY(is.Peek() != '\0')) {
+                    RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentRootNotSingular, is.Tell());
+                    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
+                }
+            }
+        }
+
+        return parseResult_;
+    }
+
+    //! Parse JSON text (with \ref kParseDefaultFlags)
+    /*! \tparam InputStream Type of input stream, implementing Stream concept
+        \tparam Handler Type of handler, implementing Handler concept.
+        \param is Input stream to be parsed.
+        \param handler The handler to receive events.
+        \return Whether the parsing is successful.
+    */
+    template <typename InputStream, typename Handler>
+    ParseResult Parse(InputStream& is, Handler& handler) {
+        return Parse<kParseDefaultFlags>(is, handler);
+    }
+
+    //! Whether a parse error has occured in the last parsing.
+    bool HasParseError() const { return parseResult_.IsError(); }
+
+    //! Get the \ref ParseErrorCode of last parsing.
+    ParseErrorCode GetParseErrorCode() const { return parseResult_.Code(); }
+
+    //! Get the position of last parsing error in input, 0 otherwise.
+    size_t GetErrorOffset() const { return parseResult_.Offset(); }
+
+protected:
+    void SetParseError(ParseErrorCode code, size_t offset) { parseResult_.Set(code, offset); }
+
+private:
+    // Prohibit copy constructor & assignment operator.
+    GenericReader(const GenericReader&);
+    GenericReader& operator=(const GenericReader&);
+
+    void ClearStack() { stack_.Clear(); }
+
+    // clear stack on any exit from ParseStream, e.g. due to exception
+    struct ClearStackOnExit {
+        explicit ClearStackOnExit(GenericReader& r) : r_(r) {}
+        ~ClearStackOnExit() { r_.ClearStack(); }
+    private:
+        GenericReader& r_;
+        ClearStackOnExit(const ClearStackOnExit&);
+        ClearStackOnExit& operator=(const ClearStackOnExit&);
+    };
+
+    template<unsigned parseFlags, typename InputStream>
+    void SkipWhitespaceAndComments(InputStream& is) {
+        SkipWhitespace(is);
+
+        if (parseFlags & kParseCommentsFlag) {
+            while (RAPIDJSON_UNLIKELY(Consume(is, '/'))) {
+                if (Consume(is, '*')) {
+                    while (true) {
+                        if (RAPIDJSON_UNLIKELY(is.Peek() == '\0'))
+                            RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell());
+                        else if (Consume(is, '*')) {
+                            if (Consume(is, '/'))
+                                break;
+                        }
+                        else
+                            is.Take();
+                    }
+                }
+                else if (RAPIDJSON_LIKELY(Consume(is, '/')))
+                    while (is.Peek() != '\0' && is.Take() != '\n');
+                else
+                    RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell());
+
+                SkipWhitespace(is);
+            }
+        }
+    }
+
+    // Parse object: { string : value, ... }
+    template<unsigned parseFlags, typename InputStream, typename Handler>
+    void ParseObject(InputStream& is, Handler& handler) {
+        RAPIDJSON_ASSERT(is.Peek() == '{');
+        is.Take();  // Skip '{'
+
+        if (RAPIDJSON_UNLIKELY(!handler.StartObject()))
+            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
+
+        SkipWhitespaceAndComments<parseFlags>(is);
+        RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+
+        if (Consume(is, '}')) {
+            if (RAPIDJSON_UNLIKELY(!handler.EndObject(0)))  // empty object
+                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
+            return;
+        }
+
+        for (SizeType memberCount = 0;;) {
+            if (RAPIDJSON_UNLIKELY(is.Peek() != '"'))
+                RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissName, is.Tell());
+
+            ParseString<parseFlags>(is, handler, true);
+            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+
+            SkipWhitespaceAndComments<parseFlags>(is);
+            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+
+            if (RAPIDJSON_UNLIKELY(!Consume(is, ':')))
+                RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissColon, is.Tell());
+
+            SkipWhitespaceAndComments<parseFlags>(is);
+            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+
+            ParseValue<parseFlags>(is, handler);
+            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+
+            SkipWhitespaceAndComments<parseFlags>(is);
+            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+
+            ++memberCount;
+
+            switch (is.Peek()) {
+                case ',':
+                    is.Take();
+                    SkipWhitespaceAndComments<parseFlags>(is);
+                    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+                    break;
+                case '}':
+                    is.Take();
+                    if (RAPIDJSON_UNLIKELY(!handler.EndObject(memberCount)))
+                        RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
+                    return;
+                default:
+                    RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, is.Tell()); break; // This useless break is only for making warning and coverage happy
+            }
+
+            if (parseFlags & kParseTrailingCommasFlag) {
+                if (is.Peek() == '}') {
+                    if (RAPIDJSON_UNLIKELY(!handler.EndObject(memberCount)))
+                        RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
+                    is.Take();
+                    return;
+                }
+            }
+        }
+    }
+
+    // Parse array: [ value, ... ]
+    template<unsigned parseFlags, typename InputStream, typename Handler>
+    void ParseArray(InputStream& is, Handler& handler) {
+        RAPIDJSON_ASSERT(is.Peek() == '[');
+        is.Take();  // Skip '['
+
+        if (RAPIDJSON_UNLIKELY(!handler.StartArray()))
+            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
+
+        SkipWhitespaceAndComments<parseFlags>(is);
+        RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+
+        if (Consume(is, ']')) {
+            if (RAPIDJSON_UNLIKELY(!handler.EndArray(0))) // empty array
+                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
+            return;
+        }
+
+        for (SizeType elementCount = 0;;) {
+            ParseValue<parseFlags>(is, handler);
+            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+
+            ++elementCount;
+            SkipWhitespaceAndComments<parseFlags>(is);
+            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+
+            if (Consume(is, ',')) {
+                SkipWhitespaceAndComments<parseFlags>(is);
+                RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+            }
+            else if (Consume(is, ']')) {
+                if (RAPIDJSON_UNLIKELY(!handler.EndArray(elementCount)))
+                    RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
+                return;
+            }
+            else
+                RAPIDJSON_PARSE_ERROR(kParseErrorArrayMissCommaOrSquareBracket, is.Tell());
+
+            if (parseFlags & kParseTrailingCommasFlag) {
+                if (is.Peek() == ']') {
+                    if (RAPIDJSON_UNLIKELY(!handler.EndArray(elementCount)))
+                        RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
+                    is.Take();
+                    return;
+                }
+            }
+        }
+    }
+
+    template<unsigned parseFlags, typename InputStream, typename Handler>
+    void ParseNull(InputStream& is, Handler& handler) {
+        RAPIDJSON_ASSERT(is.Peek() == 'n');
+        is.Take();
+
+        if (RAPIDJSON_LIKELY(Consume(is, 'u') && Consume(is, 'l') && Consume(is, 'l'))) {
+            if (RAPIDJSON_UNLIKELY(!handler.Null()))
+                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
+        }
+        else
+            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
+    }
+
+    template<unsigned parseFlags, typename InputStream, typename Handler>
+    void ParseTrue(InputStream& is, Handler& handler) {
+        RAPIDJSON_ASSERT(is.Peek() == 't');
+        is.Take();
+
+        if (RAPIDJSON_LIKELY(Consume(is, 'r') && Consume(is, 'u') && Consume(is, 'e'))) {
+            if (RAPIDJSON_UNLIKELY(!handler.Bool(true)))
+                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
+        }
+        else
+            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
+    }
+
+    template<unsigned parseFlags, typename InputStream, typename Handler>
+    void ParseFalse(InputStream& is, Handler& handler) {
+        RAPIDJSON_ASSERT(is.Peek() == 'f');
+        is.Take();
+
+        if (RAPIDJSON_LIKELY(Consume(is, 'a') && Consume(is, 'l') && Consume(is, 's') && Consume(is, 'e'))) {
+            if (RAPIDJSON_UNLIKELY(!handler.Bool(false)))
+                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
+        }
+        else
+            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
+    }
+
+    template<typename InputStream>
+    RAPIDJSON_FORCEINLINE static bool Consume(InputStream& is, typename InputStream::Ch expect) {
+        if (RAPIDJSON_LIKELY(is.Peek() == expect)) {
+            is.Take();
+            return true;
+        }
+        else
+            return false;
+    }
+
+    // Helper function to parse four hexidecimal digits in \uXXXX in ParseString().
+    template<typename InputStream>
+    unsigned ParseHex4(InputStream& is, size_t escapeOffset) {
+        unsigned codepoint = 0;
+        for (int i = 0; i < 4; i++) {
+            Ch c = is.Peek();
+            codepoint <<= 4;
+            codepoint += static_cast<unsigned>(c);
+            if (c >= '0' && c <= '9')
+                codepoint -= '0';
+            else if (c >= 'A' && c <= 'F')
+                codepoint -= 'A' - 10;
+            else if (c >= 'a' && c <= 'f')
+                codepoint -= 'a' - 10;
+            else {
+                RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorStringUnicodeEscapeInvalidHex, escapeOffset);
+                RAPIDJSON_PARSE_ERROR_EARLY_RETURN(0);
+            }
+            is.Take();
+        }
+        return codepoint;
+    }
+
+    template <typename CharType>
+    class StackStream {
+    public:
+        typedef CharType Ch;
+
+        StackStream(internal::Stack<StackAllocator>& stack) : stack_(stack), length_(0) {}
+        RAPIDJSON_FORCEINLINE void Put(Ch c) {
+            *stack_.template Push<Ch>() = c;
+            ++length_;
+        }
+
+        RAPIDJSON_FORCEINLINE void* Push(SizeType count) {
+            length_ += count;
+            return stack_.template Push<Ch>(count);
+        }
+
+        size_t Length() const { return length_; }
+
+        Ch* Pop() {
+            return stack_.template Pop<Ch>(length_);
+        }
+
+    private:
+        StackStream(const StackStream&);
+        StackStream& operator=(const StackStream&);
+
+        internal::Stack<StackAllocator>& stack_;
+        SizeType length_;
+    };
+
+    // Parse string and generate String event. Different code paths for kParseInsituFlag.
+    template<unsigned parseFlags, typename InputStream, typename Handler>
+    void ParseString(InputStream& is, Handler& handler, bool isKey = false) {
+        internal::StreamLocalCopy<InputStream> copy(is);
+        InputStream& s(copy.s);
+
+        RAPIDJSON_ASSERT(s.Peek() == '\"');
+        s.Take();  // Skip '\"'
+
+        bool success = false;
+        if (parseFlags & kParseInsituFlag) {
+            typename InputStream::Ch *head = s.PutBegin();
+            ParseStringToStream<parseFlags, SourceEncoding, SourceEncoding>(s, s);
+            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+            size_t length = s.PutEnd(head) - 1;
+            RAPIDJSON_ASSERT(length <= 0xFFFFFFFF);
+            const typename TargetEncoding::Ch* const str = reinterpret_cast<typename TargetEncoding::Ch*>(head);
+            success = (isKey ? handler.Key(str, SizeType(length), false) : handler.String(str, SizeType(length), false));
+        }
+        else {
+            StackStream<typename TargetEncoding::Ch> stackStream(stack_);
+            ParseStringToStream<parseFlags, SourceEncoding, TargetEncoding>(s, stackStream);
+            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+            SizeType length = static_cast<SizeType>(stackStream.Length()) - 1;
+            const typename TargetEncoding::Ch* const str = stackStream.Pop();
+            success = (isKey ? handler.Key(str, length, true) : handler.String(str, length, true));
+        }
+        if (RAPIDJSON_UNLIKELY(!success))
+            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, s.Tell());
+    }
+
+    // Parse string to an output is
+    // This function handles the prefix/suffix double quotes, escaping, and optional encoding validation.
+    template<unsigned parseFlags, typename SEncoding, typename TEncoding, typename InputStream, typename OutputStream>
+    RAPIDJSON_FORCEINLINE void ParseStringToStream(InputStream& is, OutputStream& os) {
+//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
+#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+        static const char escape[256] = {
+            Z16, Z16, 0, 0,'\"', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'/',
+            Z16, Z16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'\\', 0, 0, 0,
+            0, 0,'\b', 0, 0, 0,'\f', 0, 0, 0, 0, 0, 0, 0,'\n', 0,
+            0, 0,'\r', 0,'\t', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
+        };
+#undef Z16
+//!@endcond
+
+        for (;;) {
+            // Scan and copy string before "\\\"" or < 0x20. This is an optional optimzation.
+            if (!(parseFlags & kParseValidateEncodingFlag))
+                ScanCopyUnescapedString(is, os);
+
+            Ch c = is.Peek();
+            if (RAPIDJSON_UNLIKELY(c == '\\')) {    // Escape
+                size_t escapeOffset = is.Tell();    // For invalid escaping, report the inital '\\' as error offset
+                is.Take();
+                Ch e = is.Peek();
+                if ((sizeof(Ch) == 1 || unsigned(e) < 256) && RAPIDJSON_LIKELY(escape[static_cast<unsigned char>(e)])) {
+                    is.Take();
+                    os.Put(static_cast<typename TEncoding::Ch>(escape[static_cast<unsigned char>(e)]));
+                }
+                else if (RAPIDJSON_LIKELY(e == 'u')) {    // Unicode
+                    is.Take();
+                    unsigned codepoint = ParseHex4(is, escapeOffset);
+                    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+                    if (RAPIDJSON_UNLIKELY(codepoint >= 0xD800 && codepoint <= 0xDBFF)) {
+                        // Handle UTF-16 surrogate pair
+                        if (RAPIDJSON_UNLIKELY(!Consume(is, '\\') || !Consume(is, 'u')))
+                            RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset);
+                        unsigned codepoint2 = ParseHex4(is, escapeOffset);
+                        RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+                        if (RAPIDJSON_UNLIKELY(codepoint2 < 0xDC00 || codepoint2 > 0xDFFF))
+                            RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset);
+                        codepoint = (((codepoint - 0xD800) << 10) | (codepoint2 - 0xDC00)) + 0x10000;
+                    }
+                    TEncoding::Encode(os, codepoint);
+                }
+                else
+                    RAPIDJSON_PARSE_ERROR(kParseErrorStringEscapeInvalid, escapeOffset);
+            }
+            else if (RAPIDJSON_UNLIKELY(c == '"')) {    // Closing double quote
+                is.Take();
+                os.Put('\0');   // null-terminate the string
+                return;
+            }
+            else if (RAPIDJSON_UNLIKELY(static_cast<unsigned>(c) < 0x20)) { // RFC 4627: unescaped = %x20-21 / %x23-5B / %x5D-10FFFF
+                if (c == '\0')
+                    RAPIDJSON_PARSE_ERROR(kParseErrorStringMissQuotationMark, is.Tell());
+                else
+                    RAPIDJSON_PARSE_ERROR(kParseErrorStringEscapeInvalid, is.Tell());
+            }
+            else {
+                size_t offset = is.Tell();
+                if (RAPIDJSON_UNLIKELY((parseFlags & kParseValidateEncodingFlag ?
+                    !Transcoder<SEncoding, TEncoding>::Validate(is, os) :
+                    !Transcoder<SEncoding, TEncoding>::Transcode(is, os))))
+                    RAPIDJSON_PARSE_ERROR(kParseErrorStringInvalidEncoding, offset);
+            }
+        }
+    }
+
+    template<typename InputStream, typename OutputStream>
+    static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(InputStream&, OutputStream&) {
+            // Do nothing for generic version
+    }
+
+#if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42)
+    // StringStream -> StackStream<char>
+    static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(StringStream& is, StackStream<char>& os) {
+        const char* p = is.src_;
+
+        // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
+        const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
+        while (p != nextAligned)
+            if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20)) {
+                is.src_ = p;
+                return;
+            }
+            else
+                os.Put(*p++);
+
+        // The rest of string using SIMD
+        static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' };
+        static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' };
+        static const char space[16]  = { 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19 };
+        const __m128i dq = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&dquote[0]));
+        const __m128i bs = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&bslash[0]));
+        const __m128i sp = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&space[0]));
+
+        for (;; p += 16) {
+            const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
+            const __m128i t1 = _mm_cmpeq_epi8(s, dq);
+            const __m128i t2 = _mm_cmpeq_epi8(s, bs);
+            const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x19) == 0x19
+            const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
+            unsigned short r = static_cast<unsigned short>(_mm_movemask_epi8(x));
+            if (RAPIDJSON_UNLIKELY(r != 0)) {   // some of characters is escaped
+                SizeType length;
+    #ifdef _MSC_VER         // Find the index of first escaped
+                unsigned long offset;
+                _BitScanForward(&offset, r);
+                length = offset;
+    #else
+                length = static_cast<SizeType>(__builtin_ffs(r) - 1);
+    #endif
+                char* q = reinterpret_cast<char*>(os.Push(length));
+                for (size_t i = 0; i < length; i++)
+                    q[i] = p[i];
+
+                p += length;
+                break;
+            }
+            _mm_storeu_si128(reinterpret_cast<__m128i *>(os.Push(16)), s);
+        }
+
+        is.src_ = p;
+    }
+
+    // InsituStringStream -> InsituStringStream
+    static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(InsituStringStream& is, InsituStringStream& os) {
+        RAPIDJSON_ASSERT(&is == &os);
+        (void)os;
+
+        if (is.src_ == is.dst_) {
+            SkipUnescapedString(is);
+            return;
+        }
+
+        char* p = is.src_;
+        char *q = is.dst_;
+
+        // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
+        const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
+        while (p != nextAligned)
+            if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20)) {
+                is.src_ = p;
+                is.dst_ = q;
+                return;
+            }
+            else
+                *q++ = *p++;
+
+        // The rest of string using SIMD
+        static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' };
+        static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' };
+        static const char space[16] = { 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19 };
+        const __m128i dq = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&dquote[0]));
+        const __m128i bs = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&bslash[0]));
+        const __m128i sp = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&space[0]));
+
+        for (;; p += 16, q += 16) {
+            const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
+            const __m128i t1 = _mm_cmpeq_epi8(s, dq);
+            const __m128i t2 = _mm_cmpeq_epi8(s, bs);
+            const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x19) == 0x19
+            const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
+            unsigned short r = static_cast<unsigned short>(_mm_movemask_epi8(x));
+            if (RAPIDJSON_UNLIKELY(r != 0)) {   // some of characters is escaped
+                size_t length;
+#ifdef _MSC_VER         // Find the index of first escaped
+                unsigned long offset;
+                _BitScanForward(&offset, r);
+                length = offset;
+#else
+                length = static_cast<size_t>(__builtin_ffs(r) - 1);
+#endif
+                for (const char* pend = p + length; p != pend; )
+                    *q++ = *p++;
+                break;
+            }
+            _mm_storeu_si128(reinterpret_cast<__m128i *>(q), s);
+        }
+
+        is.src_ = p;
+        is.dst_ = q;
+    }
+
+    // When read/write pointers are the same for insitu stream, just skip unescaped characters
+    static RAPIDJSON_FORCEINLINE void SkipUnescapedString(InsituStringStream& is) {
+        RAPIDJSON_ASSERT(is.src_ == is.dst_);
+        char* p = is.src_;
+
+        // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
+        const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
+        for (; p != nextAligned; p++)
+            if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20)) {
+                is.src_ = is.dst_ = p;
+                return;
+            }
+
+        // The rest of string using SIMD
+        static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' };
+        static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' };
+        static const char space[16] = { 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19 };
+        const __m128i dq = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&dquote[0]));
+        const __m128i bs = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&bslash[0]));
+        const __m128i sp = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&space[0]));
+
+        for (;; p += 16) {
+            const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
+            const __m128i t1 = _mm_cmpeq_epi8(s, dq);
+            const __m128i t2 = _mm_cmpeq_epi8(s, bs);
+            const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x19) == 0x19
+            const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
+            unsigned short r = static_cast<unsigned short>(_mm_movemask_epi8(x));
+            if (RAPIDJSON_UNLIKELY(r != 0)) {   // some of characters is escaped
+                size_t length;
+#ifdef _MSC_VER         // Find the index of first escaped
+                unsigned long offset;
+                _BitScanForward(&offset, r);
+                length = offset;
+#else
+                length = static_cast<size_t>(__builtin_ffs(r) - 1);
+#endif
+                p += length;
+                break;
+            }
+        }
+
+        is.src_ = is.dst_ = p;
+    }
+#endif
+
+    template<typename InputStream, bool backup, bool pushOnTake>
+    class NumberStream;
+
+    template<typename InputStream>
+    class NumberStream<InputStream, false, false> {
+    public:
+        typedef typename InputStream::Ch Ch;
+
+        NumberStream(GenericReader& reader, InputStream& s) : is(s) { (void)reader;  }
+        ~NumberStream() {}
+
+        RAPIDJSON_FORCEINLINE Ch Peek() const { return is.Peek(); }
+        RAPIDJSON_FORCEINLINE Ch TakePush() { return is.Take(); }
+        RAPIDJSON_FORCEINLINE Ch Take() { return is.Take(); }
+		  RAPIDJSON_FORCEINLINE void Push(char) {}
+
+        size_t Tell() { return is.Tell(); }
+        size_t Length() { return 0; }
+        const char* Pop() { return 0; }
+
+    protected:
+        NumberStream& operator=(const NumberStream&);
+
+        InputStream& is;
+    };
+
+    template<typename InputStream>
+    class NumberStream<InputStream, true, false> : public NumberStream<InputStream, false, false> {
+        typedef NumberStream<InputStream, false, false> Base;
+    public:
+        NumberStream(GenericReader& reader, InputStream& is) : Base(reader, is), stackStream(reader.stack_) {}
+        ~NumberStream() {}
+
+        RAPIDJSON_FORCEINLINE Ch TakePush() {
+            stackStream.Put(static_cast<char>(Base::is.Peek()));
+            return Base::is.Take();
+        }
+
+        RAPIDJSON_FORCEINLINE void Push(char c) {
+            stackStream.Put(c);
+        }
+
+        size_t Length() { return stackStream.Length(); }
+
+        const char* Pop() {
+            stackStream.Put('\0');
+            return stackStream.Pop();
+        }
+
+    private:
+        StackStream<char> stackStream;
+    };
+
+    template<typename InputStream>
+    class NumberStream<InputStream, true, true> : public NumberStream<InputStream, true, false> {
+        typedef NumberStream<InputStream, true, false> Base;
+    public:
+        NumberStream(GenericReader& reader, InputStream& is) : Base(reader, is) {}
+        ~NumberStream() {}
+
+        RAPIDJSON_FORCEINLINE Ch Take() { return Base::TakePush(); }
+    };
+
+    template<unsigned parseFlags, typename InputStream, typename Handler>
+    void ParseNumber(InputStream& is, Handler& handler) {
+        internal::StreamLocalCopy<InputStream> copy(is);
+        NumberStream<InputStream,
+            ((parseFlags & kParseNumbersAsStringsFlag) != 0) ?
+                ((parseFlags & kParseInsituFlag) == 0) :
+                ((parseFlags & kParseFullPrecisionFlag) != 0),
+            (parseFlags & kParseNumbersAsStringsFlag) != 0 &&
+                (parseFlags & kParseInsituFlag) == 0> s(*this, copy.s);
+
+        size_t startOffset = s.Tell();
+        double d = 0.0;
+        bool useNanOrInf = false;
+
+        // Parse minus
+        bool minus = Consume(s, '-');
+
+        // Parse int: zero / ( digit1-9 *DIGIT )
+        unsigned i = 0;
+        uint64_t i64 = 0;
+        bool use64bit = false;
+        int significandDigit = 0;
+        if (RAPIDJSON_UNLIKELY(s.Peek() == '0')) {
+            i = 0;
+            s.TakePush();
+        }
+        else if (RAPIDJSON_LIKELY(s.Peek() >= '1' && s.Peek() <= '9')) {
+            i = static_cast<unsigned>(s.TakePush() - '0');
+
+            if (minus)
+                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
+                    if (RAPIDJSON_UNLIKELY(i >= 214748364)) { // 2^31 = 2147483648
+                        if (RAPIDJSON_LIKELY(i != 214748364 || s.Peek() > '8')) {
+                            i64 = i;
+                            use64bit = true;
+                            break;
+                        }
+                    }
+                    i = i * 10 + static_cast<unsigned>(s.TakePush() - '0');
+                    significandDigit++;
+                }
+            else
+                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
+                    if (RAPIDJSON_UNLIKELY(i >= 429496729)) { // 2^32 - 1 = 4294967295
+                        if (RAPIDJSON_LIKELY(i != 429496729 || s.Peek() > '5')) {
+                            i64 = i;
+                            use64bit = true;
+                            break;
+                        }
+                    }
+                    i = i * 10 + static_cast<unsigned>(s.TakePush() - '0');
+                    significandDigit++;
+                }
+        }
+        // Parse NaN or Infinity here
+        else if ((parseFlags & kParseNanAndInfFlag) && RAPIDJSON_LIKELY((s.Peek() == 'I' || s.Peek() == 'N'))) {
+            useNanOrInf = true;
+            if (RAPIDJSON_LIKELY(Consume(s, 'N') && Consume(s, 'a') && Consume(s, 'N'))) {
+                d = std::numeric_limits<double>::quiet_NaN();
+            }
+            else if (RAPIDJSON_LIKELY(Consume(s, 'I') && Consume(s, 'n') && Consume(s, 'f'))) {
+                d = (minus ? -std::numeric_limits<double>::infinity() : std::numeric_limits<double>::infinity());
+                if (RAPIDJSON_UNLIKELY(s.Peek() == 'i' && !(Consume(s, 'i') && Consume(s, 'n')
+                                                            && Consume(s, 'i') && Consume(s, 't') && Consume(s, 'y'))))
+                    RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
+            }
+            else
+                RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
+        }
+        else
+            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
+
+        // Parse 64bit int
+        bool useDouble = false;
+        if (use64bit) {
+            if (minus)
+                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
+                     if (RAPIDJSON_UNLIKELY(i64 >= RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC))) // 2^63 = 9223372036854775808
+                        if (RAPIDJSON_LIKELY(i64 != RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC) || s.Peek() > '8')) {
+                            d = static_cast<double>(i64);
+                            useDouble = true;
+                            break;
+                        }
+                    i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
+                    significandDigit++;
+                }
+            else
+                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
+                    if (RAPIDJSON_UNLIKELY(i64 >= RAPIDJSON_UINT64_C2(0x19999999, 0x99999999))) // 2^64 - 1 = 18446744073709551615
+                        if (RAPIDJSON_LIKELY(i64 != RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) || s.Peek() > '5')) {
+                            d = static_cast<double>(i64);
+                            useDouble = true;
+                            break;
+                        }
+                    i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
+                    significandDigit++;
+                }
+        }
+
+        // Force double for big integer
+        if (useDouble) {
+            while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
+                if (RAPIDJSON_UNLIKELY(d >= 1.7976931348623157e307)) // DBL_MAX / 10.0
+                    RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset);
+                d = d * 10 + (s.TakePush() - '0');
+            }
+        }
+
+        // Parse frac = decimal-point 1*DIGIT
+        int expFrac = 0;
+        size_t decimalPosition;
+        if (Consume(s, '.')) {
+            decimalPosition = s.Length();
+
+            if (RAPIDJSON_UNLIKELY(!(s.Peek() >= '0' && s.Peek() <= '9')))
+                RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissFraction, s.Tell());
+
+            if (!useDouble) {
+#if RAPIDJSON_64BIT
+                // Use i64 to store significand in 64-bit architecture
+                if (!use64bit)
+                    i64 = i;
+
+                while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
+                    if (i64 > RAPIDJSON_UINT64_C2(0x1FFFFF, 0xFFFFFFFF)) // 2^53 - 1 for fast path
+                        break;
+                    else {
+                        i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
+                        --expFrac;
+                        if (i64 != 0)
+                            significandDigit++;
+                    }
+                }
+
+                d = static_cast<double>(i64);
+#else
+                // Use double to store significand in 32-bit architecture
+                d = static_cast<double>(use64bit ? i64 : i);
+#endif
+                useDouble = true;
+            }
+
+            while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
+                if (significandDigit < 17) {
+                    d = d * 10.0 + (s.TakePush() - '0');
+                    --expFrac;
+                    if (RAPIDJSON_LIKELY(d > 0.0))
+                        significandDigit++;
+                }
+                else
+                    s.TakePush();
+            }
+        }
+        else
+            decimalPosition = s.Length(); // decimal position at the end of integer.
+
+        // Parse exp = e [ minus / plus ] 1*DIGIT
+        int exp = 0;
+        if (Consume(s, 'e') || Consume(s, 'E')) {
+            if (!useDouble) {
+                d = static_cast<double>(use64bit ? i64 : i);
+                useDouble = true;
+            }
+
+            bool expMinus = false;
+            if (Consume(s, '+'))
+                ;
+            else if (Consume(s, '-'))
+                expMinus = true;
+
+            if (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
+                exp = static_cast<int>(s.Take() - '0');
+                if (expMinus) {
+                    while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
+                        exp = exp * 10 + static_cast<int>(s.Take() - '0');
+                        if (exp >= 214748364) {                         // Issue #313: prevent overflow exponent
+                            while (RAPIDJSON_UNLIKELY(s.Peek() >= '0' && s.Peek() <= '9'))  // Consume the rest of exponent
+                                s.Take();
+                        }
+                    }
+                }
+                else {  // positive exp
+                    int maxExp = 308 - expFrac;
+                    while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
+                        exp = exp * 10 + static_cast<int>(s.Take() - '0');
+                        if (RAPIDJSON_UNLIKELY(exp > maxExp))
+                            RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset);
+                    }
+                }
+            }
+            else
+                RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissExponent, s.Tell());
+
+            if (expMinus)
+                exp = -exp;
+        }
+
+        // Finish parsing, call event according to the type of number.
+        bool cont = true;
+
+        if (parseFlags & kParseNumbersAsStringsFlag) {
+            if (parseFlags & kParseInsituFlag) {
+                s.Pop();  // Pop stack no matter if it will be used or not.
+                typename InputStream::Ch* head = is.PutBegin();
+                const size_t length = s.Tell() - startOffset;
+                RAPIDJSON_ASSERT(length <= 0xFFFFFFFF);
+                // unable to insert the \0 character here, it will erase the comma after this number
+                const typename TargetEncoding::Ch* const str = reinterpret_cast<typename TargetEncoding::Ch*>(head);
+                cont = handler.RawNumber(str, SizeType(length), false);
+            }
+            else {
+                SizeType numCharsToCopy = static_cast<SizeType>(s.Length());
+                StringStream srcStream(s.Pop());
+                StackStream<typename TargetEncoding::Ch> dstStream(stack_);
+                while (numCharsToCopy--) {
+                    Transcoder<UTF8<>, TargetEncoding>::Transcode(srcStream, dstStream);
+                }
+                dstStream.Put('\0');
+                const typename TargetEncoding::Ch* str = dstStream.Pop();
+                const SizeType length = static_cast<SizeType>(dstStream.Length()) - 1;
+                cont = handler.RawNumber(str, SizeType(length), true);
+            }
+        }
+        else {
+           size_t length = s.Length();
+           const char* decimal = s.Pop();  // Pop stack no matter if it will be used or not.
+
+           if (useDouble) {
+               int p = exp + expFrac;
+               if (parseFlags & kParseFullPrecisionFlag)
+                   d = internal::StrtodFullPrecision(d, p, decimal, length, decimalPosition, exp);
+               else
+                   d = internal::StrtodNormalPrecision(d, p);
+
+               cont = handler.Double(minus ? -d : d);
+           }
+           else if (useNanOrInf) {
+               cont = handler.Double(d);
+           }
+           else {
+               if (use64bit) {
+                   if (minus)
+                       cont = handler.Int64(static_cast<int64_t>(~i64 + 1));
+                   else
+                       cont = handler.Uint64(i64);
+               }
+               else {
+                   if (minus)
+                       cont = handler.Int(static_cast<int32_t>(~i + 1));
+                   else
+                       cont = handler.Uint(i);
+               }
+           }
+        }
+        if (RAPIDJSON_UNLIKELY(!cont))
+            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, startOffset);
+    }
+
+    // Parse any JSON value
+    template<unsigned parseFlags, typename InputStream, typename Handler>
+    void ParseValue(InputStream& is, Handler& handler) {
+        switch (is.Peek()) {
+            case 'n': ParseNull  <parseFlags>(is, handler); break;
+            case 't': ParseTrue  <parseFlags>(is, handler); break;
+            case 'f': ParseFalse <parseFlags>(is, handler); break;
+            case '"': ParseString<parseFlags>(is, handler); break;
+            case '{': ParseObject<parseFlags>(is, handler); break;
+            case '[': ParseArray <parseFlags>(is, handler); break;
+            default :
+                      ParseNumber<parseFlags>(is, handler);
+                      break;
+
+        }
+    }
+
+    // Iterative Parsing
+
+    // States
+    enum IterativeParsingState {
+        IterativeParsingStartState = 0,
+        IterativeParsingFinishState,
+        IterativeParsingErrorState,
+
+        // Object states
+        IterativeParsingObjectInitialState,
+        IterativeParsingMemberKeyState,
+        IterativeParsingKeyValueDelimiterState,
+        IterativeParsingMemberValueState,
+        IterativeParsingMemberDelimiterState,
+        IterativeParsingObjectFinishState,
+
+        // Array states
+        IterativeParsingArrayInitialState,
+        IterativeParsingElementState,
+        IterativeParsingElementDelimiterState,
+        IterativeParsingArrayFinishState,
+
+        // Single value state
+        IterativeParsingValueState
+    };
+
+    enum { cIterativeParsingStateCount = IterativeParsingValueState + 1 };
+
+    // Tokens
+    enum Token {
+        LeftBracketToken = 0,
+        RightBracketToken,
+
+        LeftCurlyBracketToken,
+        RightCurlyBracketToken,
+
+        CommaToken,
+        ColonToken,
+
+        StringToken,
+        FalseToken,
+        TrueToken,
+        NullToken,
+        NumberToken,
+
+        kTokenCount
+    };
+
+    RAPIDJSON_FORCEINLINE Token Tokenize(Ch c) {
+
+//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
+#define N NumberToken
+#define N16 N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N
+        // Maps from ASCII to Token
+        static const unsigned char tokenMap[256] = {
+            N16, // 00~0F
+            N16, // 10~1F
+            N, N, StringToken, N, N, N, N, N, N, N, N, N, CommaToken, N, N, N, // 20~2F
+            N, N, N, N, N, N, N, N, N, N, ColonToken, N, N, N, N, N, // 30~3F
+            N16, // 40~4F
+            N, N, N, N, N, N, N, N, N, N, N, LeftBracketToken, N, RightBracketToken, N, N, // 50~5F
+            N, N, N, N, N, N, FalseToken, N, N, N, N, N, N, N, NullToken, N, // 60~6F
+            N, N, N, N, TrueToken, N, N, N, N, N, N, LeftCurlyBracketToken, N, RightCurlyBracketToken, N, N, // 70~7F
+            N16, N16, N16, N16, N16, N16, N16, N16 // 80~FF
+        };
+#undef N
+#undef N16
+//!@endcond
+
+        if (sizeof(Ch) == 1 || static_cast<unsigned>(c) < 256)
+            return static_cast<Token>(tokenMap[static_cast<unsigned char>(c)]);
+        else
+            return NumberToken;
+    }
+
+    RAPIDJSON_FORCEINLINE IterativeParsingState Predict(IterativeParsingState state, Token token) {
+        // current state x one lookahead token -> new state
+        static const char G[cIterativeParsingStateCount][kTokenCount] = {
+            // Start
+            {
+                IterativeParsingArrayInitialState,  // Left bracket
+                IterativeParsingErrorState,         // Right bracket
+                IterativeParsingObjectInitialState, // Left curly bracket
+                IterativeParsingErrorState,         // Right curly bracket
+                IterativeParsingErrorState,         // Comma
+                IterativeParsingErrorState,         // Colon
+                IterativeParsingValueState,         // String
+                IterativeParsingValueState,         // False
+                IterativeParsingValueState,         // True
+                IterativeParsingValueState,         // Null
+                IterativeParsingValueState          // Number
+            },
+            // Finish(sink state)
+            {
+                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
+                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
+                IterativeParsingErrorState
+            },
+            // Error(sink state)
+            {
+                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
+                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
+                IterativeParsingErrorState
+            },
+            // ObjectInitial
+            {
+                IterativeParsingErrorState,         // Left bracket
+                IterativeParsingErrorState,         // Right bracket
+                IterativeParsingErrorState,         // Left curly bracket
+                IterativeParsingObjectFinishState,  // Right curly bracket
+                IterativeParsingErrorState,         // Comma
+                IterativeParsingErrorState,         // Colon
+                IterativeParsingMemberKeyState,     // String
+                IterativeParsingErrorState,         // False
+                IterativeParsingErrorState,         // True
+                IterativeParsingErrorState,         // Null
+                IterativeParsingErrorState          // Number
+            },
+            // MemberKey
+            {
+                IterativeParsingErrorState,             // Left bracket
+                IterativeParsingErrorState,             // Right bracket
+                IterativeParsingErrorState,             // Left curly bracket
+                IterativeParsingErrorState,             // Right curly bracket
+                IterativeParsingErrorState,             // Comma
+                IterativeParsingKeyValueDelimiterState, // Colon
+                IterativeParsingErrorState,             // String
+                IterativeParsingErrorState,             // False
+                IterativeParsingErrorState,             // True
+                IterativeParsingErrorState,             // Null
+                IterativeParsingErrorState              // Number
+            },
+            // KeyValueDelimiter
+            {
+                IterativeParsingArrayInitialState,      // Left bracket(push MemberValue state)
+                IterativeParsingErrorState,             // Right bracket
+                IterativeParsingObjectInitialState,     // Left curly bracket(push MemberValue state)
+                IterativeParsingErrorState,             // Right curly bracket
+                IterativeParsingErrorState,             // Comma
+                IterativeParsingErrorState,             // Colon
+                IterativeParsingMemberValueState,       // String
+                IterativeParsingMemberValueState,       // False
+                IterativeParsingMemberValueState,       // True
+                IterativeParsingMemberValueState,       // Null
+                IterativeParsingMemberValueState        // Number
+            },
+            // MemberValue
+            {
+                IterativeParsingErrorState,             // Left bracket
+                IterativeParsingErrorState,             // Right bracket
+                IterativeParsingErrorState,             // Left curly bracket
+                IterativeParsingObjectFinishState,      // Right curly bracket
+                IterativeParsingMemberDelimiterState,   // Comma
+                IterativeParsingErrorState,             // Colon
+                IterativeParsingErrorState,             // String
+                IterativeParsingErrorState,             // False
+                IterativeParsingErrorState,             // True
+                IterativeParsingErrorState,             // Null
+                IterativeParsingErrorState              // Number
+            },
+            // MemberDelimiter
+            {
+                IterativeParsingErrorState,         // Left bracket
+                IterativeParsingErrorState,         // Right bracket
+                IterativeParsingErrorState,         // Left curly bracket
+                IterativeParsingObjectFinishState,  // Right curly bracket
+                IterativeParsingErrorState,         // Comma
+                IterativeParsingErrorState,         // Colon
+                IterativeParsingMemberKeyState,     // String
+                IterativeParsingErrorState,         // False
+                IterativeParsingErrorState,         // True
+                IterativeParsingErrorState,         // Null
+                IterativeParsingErrorState          // Number
+            },
+            // ObjectFinish(sink state)
+            {
+                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
+                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
+                IterativeParsingErrorState
+            },
+            // ArrayInitial
+            {
+                IterativeParsingArrayInitialState,      // Left bracket(push Element state)
+                IterativeParsingArrayFinishState,       // Right bracket
+                IterativeParsingObjectInitialState,     // Left curly bracket(push Element state)
+                IterativeParsingErrorState,             // Right curly bracket
+                IterativeParsingErrorState,             // Comma
+                IterativeParsingErrorState,             // Colon
+                IterativeParsingElementState,           // String
+                IterativeParsingElementState,           // False
+                IterativeParsingElementState,           // True
+                IterativeParsingElementState,           // Null
+                IterativeParsingElementState            // Number
+            },
+            // Element
+            {
+                IterativeParsingErrorState,             // Left bracket
+                IterativeParsingArrayFinishState,       // Right bracket
+                IterativeParsingErrorState,             // Left curly bracket
+                IterativeParsingErrorState,             // Right curly bracket
+                IterativeParsingElementDelimiterState,  // Comma
+                IterativeParsingErrorState,             // Colon
+                IterativeParsingErrorState,             // String
+                IterativeParsingErrorState,             // False
+                IterativeParsingErrorState,             // True
+                IterativeParsingErrorState,             // Null
+                IterativeParsingErrorState              // Number
+            },
+            // ElementDelimiter
+            {
+                IterativeParsingArrayInitialState,      // Left bracket(push Element state)
+                IterativeParsingArrayFinishState,       // Right bracket
+                IterativeParsingObjectInitialState,     // Left curly bracket(push Element state)
+                IterativeParsingErrorState,             // Right curly bracket
+                IterativeParsingErrorState,             // Comma
+                IterativeParsingErrorState,             // Colon
+                IterativeParsingElementState,           // String
+                IterativeParsingElementState,           // False
+                IterativeParsingElementState,           // True
+                IterativeParsingElementState,           // Null
+                IterativeParsingElementState            // Number
+            },
+            // ArrayFinish(sink state)
+            {
+                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
+                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
+                IterativeParsingErrorState
+            },
+            // Single Value (sink state)
+            {
+                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
+                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
+                IterativeParsingErrorState
+            }
+        }; // End of G
+
+        return static_cast<IterativeParsingState>(G[state][token]);
+    }
+
+    // Make an advance in the token stream and state based on the candidate destination state which was returned by Transit().
+    // May return a new state on state pop.
+    template <unsigned parseFlags, typename InputStream, typename Handler>
+    RAPIDJSON_FORCEINLINE IterativeParsingState Transit(IterativeParsingState src, Token token, IterativeParsingState dst, InputStream& is, Handler& handler) {
+        (void)token;
+
+        switch (dst) {
+        case IterativeParsingErrorState:
+            return dst;
+
+        case IterativeParsingObjectInitialState:
+        case IterativeParsingArrayInitialState:
+        {
+            // Push the state(Element or MemeberValue) if we are nested in another array or value of member.
+            // In this way we can get the correct state on ObjectFinish or ArrayFinish by frame pop.
+            IterativeParsingState n = src;
+            if (src == IterativeParsingArrayInitialState || src == IterativeParsingElementDelimiterState)
+                n = IterativeParsingElementState;
+            else if (src == IterativeParsingKeyValueDelimiterState)
+                n = IterativeParsingMemberValueState;
+            // Push current state.
+            *stack_.template Push<SizeType>(1) = n;
+            // Initialize and push the member/element count.
+            *stack_.template Push<SizeType>(1) = 0;
+            // Call handler
+            bool hr = (dst == IterativeParsingObjectInitialState) ? handler.StartObject() : handler.StartArray();
+            // On handler short circuits the parsing.
+            if (!hr) {
+                RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorTermination, is.Tell());
+                return IterativeParsingErrorState;
+            }
+            else {
+                is.Take();
+                return dst;
+            }
+        }
+
+        case IterativeParsingMemberKeyState:
+            ParseString<parseFlags>(is, handler, true);
+            if (HasParseError())
+                return IterativeParsingErrorState;
+            else
+                return dst;
+
+        case IterativeParsingKeyValueDelimiterState:
+            RAPIDJSON_ASSERT(token == ColonToken);
+            is.Take();
+            return dst;
+
+        case IterativeParsingMemberValueState:
+            // Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state.
+            ParseValue<parseFlags>(is, handler);
+            if (HasParseError()) {
+                return IterativeParsingErrorState;
+            }
+            return dst;
+
+        case IterativeParsingElementState:
+            // Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state.
+            ParseValue<parseFlags>(is, handler);
+            if (HasParseError()) {
+                return IterativeParsingErrorState;
+            }
+            return dst;
+
+        case IterativeParsingMemberDelimiterState:
+        case IterativeParsingElementDelimiterState:
+            is.Take();
+            // Update member/element count.
+            *stack_.template Top<SizeType>() = *stack_.template Top<SizeType>() + 1;
+            return dst;
+
+        case IterativeParsingObjectFinishState:
+        {
+            // Transit from delimiter is only allowed when trailing commas are enabled
+            if (!(parseFlags & kParseTrailingCommasFlag) && src == IterativeParsingMemberDelimiterState) {
+                RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorObjectMissName, is.Tell());
+                return IterativeParsingErrorState;
+            }
+            // Get member count.
+            SizeType c = *stack_.template Pop<SizeType>(1);
+            // If the object is not empty, count the last member.
+            if (src == IterativeParsingMemberValueState)
+                ++c;
+            // Restore the state.
+            IterativeParsingState n = static_cast<IterativeParsingState>(*stack_.template Pop<SizeType>(1));
+            // Transit to Finish state if this is the topmost scope.
+            if (n == IterativeParsingStartState)
+                n = IterativeParsingFinishState;
+            // Call handler
+            bool hr = handler.EndObject(c);
+            // On handler short circuits the parsing.
+            if (!hr) {
+                RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorTermination, is.Tell());
+                return IterativeParsingErrorState;
+            }
+            else {
+                is.Take();
+                return n;
+            }
+        }
+
+        case IterativeParsingArrayFinishState:
+        {
+            // Transit from delimiter is only allowed when trailing commas are enabled
+            if (!(parseFlags & kParseTrailingCommasFlag) && src == IterativeParsingElementDelimiterState) {
+                RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorValueInvalid, is.Tell());
+                return IterativeParsingErrorState;
+            }
+            // Get element count.
+            SizeType c = *stack_.template Pop<SizeType>(1);
+            // If the array is not empty, count the last element.
+            if (src == IterativeParsingElementState)
+                ++c;
+            // Restore the state.
+            IterativeParsingState n = static_cast<IterativeParsingState>(*stack_.template Pop<SizeType>(1));
+            // Transit to Finish state if this is the topmost scope.
+            if (n == IterativeParsingStartState)
+                n = IterativeParsingFinishState;
+            // Call handler
+            bool hr = handler.EndArray(c);
+            // On handler short circuits the parsing.
+            if (!hr) {
+                RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorTermination, is.Tell());
+                return IterativeParsingErrorState;
+            }
+            else {
+                is.Take();
+                return n;
+            }
+        }
+
+        default:
+            // This branch is for IterativeParsingValueState actually.
+            // Use `default:` rather than
+            // `case IterativeParsingValueState:` is for code coverage.
+
+            // The IterativeParsingStartState is not enumerated in this switch-case.
+            // It is impossible for that case. And it can be caught by following assertion.
+
+            // The IterativeParsingFinishState is not enumerated in this switch-case either.
+            // It is a "derivative" state which cannot triggered from Predict() directly.
+            // Therefore it cannot happen here. And it can be caught by following assertion.
+            RAPIDJSON_ASSERT(dst == IterativeParsingValueState);
+
+            // Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state.
+            ParseValue<parseFlags>(is, handler);
+            if (HasParseError()) {
+                return IterativeParsingErrorState;
+            }
+            return IterativeParsingFinishState;
+        }
+    }
+
+    template <typename InputStream>
+    void HandleError(IterativeParsingState src, InputStream& is) {
+        if (HasParseError()) {
+            // Error flag has been set.
+            return;
+        }
+
+        switch (src) {
+        case IterativeParsingStartState:            RAPIDJSON_PARSE_ERROR(kParseErrorDocumentEmpty, is.Tell()); return;
+        case IterativeParsingFinishState:           RAPIDJSON_PARSE_ERROR(kParseErrorDocumentRootNotSingular, is.Tell()); return;
+        case IterativeParsingObjectInitialState:
+        case IterativeParsingMemberDelimiterState:  RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissName, is.Tell()); return;
+        case IterativeParsingMemberKeyState:        RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissColon, is.Tell()); return;
+        case IterativeParsingMemberValueState:      RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, is.Tell()); return;
+        case IterativeParsingKeyValueDelimiterState:
+        case IterativeParsingArrayInitialState:
+        case IterativeParsingElementDelimiterState: RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell()); return;
+        default: RAPIDJSON_ASSERT(src == IterativeParsingElementState); RAPIDJSON_PARSE_ERROR(kParseErrorArrayMissCommaOrSquareBracket, is.Tell()); return;
+        }
+    }
+
+    template <unsigned parseFlags, typename InputStream, typename Handler>
+    ParseResult IterativeParse(InputStream& is, Handler& handler) {
+        parseResult_.Clear();
+        ClearStackOnExit scope(*this);
+        IterativeParsingState state = IterativeParsingStartState;
+
+        SkipWhitespaceAndComments<parseFlags>(is);
+        RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
+        while (is.Peek() != '\0') {
+            Token t = Tokenize(is.Peek());
+            IterativeParsingState n = Predict(state, t);
+            IterativeParsingState d = Transit<parseFlags>(state, t, n, is, handler);
+
+            if (d == IterativeParsingErrorState) {
+                HandleError(state, is);
+                break;
+            }
+
+            state = d;
+
+            // Do not further consume streams if a root JSON has been parsed.
+            if ((parseFlags & kParseStopWhenDoneFlag) && state == IterativeParsingFinishState)
+                break;
+
+            SkipWhitespaceAndComments<parseFlags>(is);
+            RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
+        }
+
+        // Handle the end of file.
+        if (state != IterativeParsingFinishState)
+            HandleError(state, is);
+
+        return parseResult_;
+    }
+
+    static const size_t kDefaultStackCapacity = 256;    //!< Default stack capacity in bytes for storing a single decoded string.
+    internal::Stack<StackAllocator> stack_;  //!< A stack for storing decoded string temporarily during non-destructive parsing.
+    ParseResult parseResult_;
+}; // class GenericReader
+
+//! Reader with UTF8 encoding and default allocator.
+typedef GenericReader<UTF8<>, UTF8<> > Reader;
+
+RAPIDJSON_NAMESPACE_END
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
+
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_POP
+#endif
+
+#ifdef _MSC_VER
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_READER_H_
diff --git a/engine/inc/rapidjson/schema.h b/engine/inc/rapidjson/schema.h
new file mode 100644
index 00000000..b182aa27
--- /dev/null
+++ b/engine/inc/rapidjson/schema.h
@@ -0,0 +1,2006 @@
+// Tencent is pleased to support the open source community by making RapidJSON available->
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip-> All rights reserved->
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License-> You may obtain a copy of the License at
+//
+// http://opensource->org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied-> See the License for the 
+// specific language governing permissions and limitations under the License->
+
+#ifndef RAPIDJSON_SCHEMA_H_
+#define RAPIDJSON_SCHEMA_H_
+
+#include "document.h"
+#include "pointer.h"
+#include <cmath> // abs, floor
+
+#if !defined(RAPIDJSON_SCHEMA_USE_INTERNALREGEX)
+#define RAPIDJSON_SCHEMA_USE_INTERNALREGEX 1
+#else
+#define RAPIDJSON_SCHEMA_USE_INTERNALREGEX 0
+#endif
+
+#if !RAPIDJSON_SCHEMA_USE_INTERNALREGEX && !defined(RAPIDJSON_SCHEMA_USE_STDREGEX) && (__cplusplus >=201103L || (defined(_MSC_VER) && _MSC_VER >= 1800))
+#define RAPIDJSON_SCHEMA_USE_STDREGEX 1
+#else
+#define RAPIDJSON_SCHEMA_USE_STDREGEX 0
+#endif
+
+#if RAPIDJSON_SCHEMA_USE_INTERNALREGEX
+#include "internal/regex.h"
+#elif RAPIDJSON_SCHEMA_USE_STDREGEX
+#include <regex>
+#endif
+
+#if RAPIDJSON_SCHEMA_USE_INTERNALREGEX || RAPIDJSON_SCHEMA_USE_STDREGEX
+#define RAPIDJSON_SCHEMA_HAS_REGEX 1
+#else
+#define RAPIDJSON_SCHEMA_HAS_REGEX 0
+#endif
+
+#ifndef RAPIDJSON_SCHEMA_VERBOSE
+#define RAPIDJSON_SCHEMA_VERBOSE 0
+#endif
+
+#if RAPIDJSON_SCHEMA_VERBOSE
+#include "stringbuffer.h"
+#endif
+
+RAPIDJSON_DIAG_PUSH
+
+#if defined(__GNUC__)
+RAPIDJSON_DIAG_OFF(effc++)
+#endif
+
+#ifdef __clang__
+RAPIDJSON_DIAG_OFF(weak-vtables)
+RAPIDJSON_DIAG_OFF(exit-time-destructors)
+RAPIDJSON_DIAG_OFF(c++98-compat-pedantic)
+RAPIDJSON_DIAG_OFF(variadic-macros)
+#endif
+
+#ifdef _MSC_VER
+RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+// Verbose Utilities
+
+#if RAPIDJSON_SCHEMA_VERBOSE
+
+namespace internal {
+
+inline void PrintInvalidKeyword(const char* keyword) {
+    printf("Fail keyword: %s\n", keyword);
+}
+
+inline void PrintInvalidKeyword(const wchar_t* keyword) {
+    wprintf(L"Fail keyword: %ls\n", keyword);
+}
+
+inline void PrintInvalidDocument(const char* document) {
+    printf("Fail document: %s\n\n", document);
+}
+
+inline void PrintInvalidDocument(const wchar_t* document) {
+    wprintf(L"Fail document: %ls\n\n", document);
+}
+
+inline void PrintValidatorPointers(unsigned depth, const char* s, const char* d) {
+    printf("S: %*s%s\nD: %*s%s\n\n", depth * 4, " ", s, depth * 4, " ", d);
+}
+
+inline void PrintValidatorPointers(unsigned depth, const wchar_t* s, const wchar_t* d) {
+    wprintf(L"S: %*ls%ls\nD: %*ls%ls\n\n", depth * 4, L" ", s, depth * 4, L" ", d);
+}
+
+} // namespace internal
+
+#endif // RAPIDJSON_SCHEMA_VERBOSE
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_INVALID_KEYWORD_RETURN
+
+#if RAPIDJSON_SCHEMA_VERBOSE
+#define RAPIDJSON_INVALID_KEYWORD_VERBOSE(keyword) internal::PrintInvalidKeyword(keyword)
+#else
+#define RAPIDJSON_INVALID_KEYWORD_VERBOSE(keyword)
+#endif
+
+#define RAPIDJSON_INVALID_KEYWORD_RETURN(keyword)\
+RAPIDJSON_MULTILINEMACRO_BEGIN\
+    context.invalidKeyword = keyword.GetString();\
+    RAPIDJSON_INVALID_KEYWORD_VERBOSE(keyword.GetString());\
+    return false;\
+RAPIDJSON_MULTILINEMACRO_END
+
+///////////////////////////////////////////////////////////////////////////////
+// Forward declarations
+
+template <typename ValueType, typename Allocator>
+class GenericSchemaDocument;
+
+namespace internal {
+
+template <typename SchemaDocumentType>
+class Schema;
+
+///////////////////////////////////////////////////////////////////////////////
+// ISchemaValidator
+
+class ISchemaValidator {
+public:
+    virtual ~ISchemaValidator() {}
+    virtual bool IsValid() const = 0;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// ISchemaStateFactory
+
+template <typename SchemaType>
+class ISchemaStateFactory {
+public:
+    virtual ~ISchemaStateFactory() {}
+    virtual ISchemaValidator* CreateSchemaValidator(const SchemaType&) = 0;
+    virtual void DestroySchemaValidator(ISchemaValidator* validator) = 0;
+    virtual void* CreateHasher() = 0;
+    virtual uint64_t GetHashCode(void* hasher) = 0;
+    virtual void DestroryHasher(void* hasher) = 0;
+    virtual void* MallocState(size_t size) = 0;
+    virtual void FreeState(void* p) = 0;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// Hasher
+
+// For comparison of compound value
+template<typename Encoding, typename Allocator>
+class Hasher {
+public:
+    typedef typename Encoding::Ch Ch;
+
+    Hasher(Allocator* allocator = 0, size_t stackCapacity = kDefaultSize) : stack_(allocator, stackCapacity) {}
+
+    bool Null() { return WriteType(kNullType); }
+    bool Bool(bool b) { return WriteType(b ? kTrueType : kFalseType); }
+    bool Int(int i) { Number n; n.u.i = i; n.d = static_cast<double>(i); return WriteNumber(n); }
+    bool Uint(unsigned u) { Number n; n.u.u = u; n.d = static_cast<double>(u); return WriteNumber(n); }
+    bool Int64(int64_t i) { Number n; n.u.i = i; n.d = static_cast<double>(i); return WriteNumber(n); }
+    bool Uint64(uint64_t u) { Number n; n.u.u = u; n.d = static_cast<double>(u); return WriteNumber(n); }
+    bool Double(double d) { 
+        Number n; 
+        if (d < 0) n.u.i = static_cast<int64_t>(d);
+        else       n.u.u = static_cast<uint64_t>(d); 
+        n.d = d;
+        return WriteNumber(n);
+    }
+
+    bool RawNumber(const Ch* str, SizeType len, bool) {
+        WriteBuffer(kNumberType, str, len * sizeof(Ch));
+        return true;
+    }
+
+    bool String(const Ch* str, SizeType len, bool) {
+        WriteBuffer(kStringType, str, len * sizeof(Ch));
+        return true;
+    }
+
+    bool StartObject() { return true; }
+    bool Key(const Ch* str, SizeType len, bool copy) { return String(str, len, copy); }
+    bool EndObject(SizeType memberCount) { 
+        uint64_t h = Hash(0, kObjectType);
+        uint64_t* kv = stack_.template Pop<uint64_t>(memberCount * 2);
+        for (SizeType i = 0; i < memberCount; i++)
+            h ^= Hash(kv[i * 2], kv[i * 2 + 1]);  // Use xor to achieve member order insensitive
+        *stack_.template Push<uint64_t>() = h;
+        return true;
+    }
+    
+    bool StartArray() { return true; }
+    bool EndArray(SizeType elementCount) { 
+        uint64_t h = Hash(0, kArrayType);
+        uint64_t* e = stack_.template Pop<uint64_t>(elementCount);
+        for (SizeType i = 0; i < elementCount; i++)
+            h = Hash(h, e[i]); // Use hash to achieve element order sensitive
+        *stack_.template Push<uint64_t>() = h;
+        return true;
+    }
+
+    bool IsValid() const { return stack_.GetSize() == sizeof(uint64_t); }
+
+    uint64_t GetHashCode() const {
+        RAPIDJSON_ASSERT(IsValid());
+        return *stack_.template Top<uint64_t>();
+    }
+
+private:
+    static const size_t kDefaultSize = 256;
+    struct Number {
+        union U {
+            uint64_t u;
+            int64_t i;
+        }u;
+        double d;
+    };
+
+    bool WriteType(Type type) { return WriteBuffer(type, 0, 0); }
+    
+    bool WriteNumber(const Number& n) { return WriteBuffer(kNumberType, &n, sizeof(n)); }
+    
+    bool WriteBuffer(Type type, const void* data, size_t len) {
+        // FNV-1a from http://isthe.com/chongo/tech/comp/fnv/
+        uint64_t h = Hash(RAPIDJSON_UINT64_C2(0x84222325, 0xcbf29ce4), type);
+        const unsigned char* d = static_cast<const unsigned char*>(data);
+        for (size_t i = 0; i < len; i++)
+            h = Hash(h, d[i]);
+        *stack_.template Push<uint64_t>() = h;
+        return true;
+    }
+
+    static uint64_t Hash(uint64_t h, uint64_t d) {
+        static const uint64_t kPrime = RAPIDJSON_UINT64_C2(0x00000100, 0x000001b3);
+        h ^= d;
+        h *= kPrime;
+        return h;
+    }
+
+    Stack<Allocator> stack_;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// SchemaValidationContext
+
+template <typename SchemaDocumentType>
+struct SchemaValidationContext {
+    typedef Schema<SchemaDocumentType> SchemaType;
+    typedef ISchemaStateFactory<SchemaType> SchemaValidatorFactoryType;
+    typedef typename SchemaType::ValueType ValueType;
+    typedef typename ValueType::Ch Ch;
+
+    enum PatternValidatorType {
+        kPatternValidatorOnly,
+        kPatternValidatorWithProperty,
+        kPatternValidatorWithAdditionalProperty
+    };
+
+    SchemaValidationContext(SchemaValidatorFactoryType& f, const SchemaType* s) :
+        factory(f),
+        schema(s),
+        valueSchema(),
+        invalidKeyword(),
+        hasher(),
+        arrayElementHashCodes(),
+        validators(),
+        validatorCount(),
+        patternPropertiesValidators(),
+        patternPropertiesValidatorCount(),
+        patternPropertiesSchemas(),
+        patternPropertiesSchemaCount(),
+        valuePatternValidatorType(kPatternValidatorOnly),
+        propertyExist(),
+        inArray(false),
+        valueUniqueness(false),
+        arrayUniqueness(false)
+    {
+    }
+
+    ~SchemaValidationContext() {
+        if (hasher)
+            factory.DestroryHasher(hasher);
+        if (validators) {
+            for (SizeType i = 0; i < validatorCount; i++)
+                factory.DestroySchemaValidator(validators[i]);
+            factory.FreeState(validators);
+        }
+        if (patternPropertiesValidators) {
+            for (SizeType i = 0; i < patternPropertiesValidatorCount; i++)
+                factory.DestroySchemaValidator(patternPropertiesValidators[i]);
+            factory.FreeState(patternPropertiesValidators);
+        }
+        if (patternPropertiesSchemas)
+            factory.FreeState(patternPropertiesSchemas);
+        if (propertyExist)
+            factory.FreeState(propertyExist);
+    }
+
+    SchemaValidatorFactoryType& factory;
+    const SchemaType* schema;
+    const SchemaType* valueSchema;
+    const Ch* invalidKeyword;
+    void* hasher; // Only validator access
+    void* arrayElementHashCodes; // Only validator access this
+    ISchemaValidator** validators;
+    SizeType validatorCount;
+    ISchemaValidator** patternPropertiesValidators;
+    SizeType patternPropertiesValidatorCount;
+    const SchemaType** patternPropertiesSchemas;
+    SizeType patternPropertiesSchemaCount;
+    PatternValidatorType valuePatternValidatorType;
+    PatternValidatorType objectPatternValidatorType;
+    SizeType arrayElementIndex;
+    bool* propertyExist;
+    bool inArray;
+    bool valueUniqueness;
+    bool arrayUniqueness;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// Schema
+
+template <typename SchemaDocumentType>
+class Schema {
+public:
+    typedef typename SchemaDocumentType::ValueType ValueType;
+    typedef typename SchemaDocumentType::AllocatorType AllocatorType;
+    typedef typename SchemaDocumentType::PointerType PointerType;
+    typedef typename ValueType::EncodingType EncodingType;
+    typedef typename EncodingType::Ch Ch;
+    typedef SchemaValidationContext<SchemaDocumentType> Context;
+    typedef Schema<SchemaDocumentType> SchemaType;
+    typedef GenericValue<EncodingType, AllocatorType> SValue;
+    friend class GenericSchemaDocument<ValueType, AllocatorType>;
+
+    Schema(SchemaDocumentType* schemaDocument, const PointerType& p, const ValueType& value, const ValueType& document, AllocatorType* allocator) :
+        allocator_(allocator),
+        enum_(),
+        enumCount_(),
+        not_(),
+        type_((1 << kTotalSchemaType) - 1), // typeless
+        validatorCount_(),
+        properties_(),
+        additionalPropertiesSchema_(),
+        patternProperties_(),
+        patternPropertyCount_(),
+        propertyCount_(),
+        minProperties_(),
+        maxProperties_(SizeType(~0)),
+        additionalProperties_(true),
+        hasDependencies_(),
+        hasRequired_(),
+        hasSchemaDependencies_(),
+        additionalItemsSchema_(),
+        itemsList_(),
+        itemsTuple_(),
+        itemsTupleCount_(),
+        minItems_(),
+        maxItems_(SizeType(~0)),
+        additionalItems_(true),
+        uniqueItems_(false),
+        pattern_(),
+        minLength_(0),
+        maxLength_(~SizeType(0)),
+        exclusiveMinimum_(false),
+        exclusiveMaximum_(false)
+    {
+        typedef typename SchemaDocumentType::ValueType ValueType;
+        typedef typename ValueType::ConstValueIterator ConstValueIterator;
+        typedef typename ValueType::ConstMemberIterator ConstMemberIterator;
+
+        if (!value.IsObject())
+            return;
+
+        if (const ValueType* v = GetMember(value, GetTypeString())) {
+            type_ = 0;
+            if (v->IsString())
+                AddType(*v);
+            else if (v->IsArray())
+                for (ConstValueIterator itr = v->Begin(); itr != v->End(); ++itr)
+                    AddType(*itr);
+        }
+
+        if (const ValueType* v = GetMember(value, GetEnumString()))
+            if (v->IsArray() && v->Size() > 0) {
+                enum_ = static_cast<uint64_t*>(allocator_->Malloc(sizeof(uint64_t) * v->Size()));
+                for (ConstValueIterator itr = v->Begin(); itr != v->End(); ++itr) {
+                    typedef Hasher<EncodingType, MemoryPoolAllocator<> > EnumHasherType;
+                    char buffer[256 + 24];
+                    MemoryPoolAllocator<> hasherAllocator(buffer, sizeof(buffer));
+                    EnumHasherType h(&hasherAllocator, 256);
+                    itr->Accept(h);
+                    enum_[enumCount_++] = h.GetHashCode();
+                }
+            }
+
+        if (schemaDocument) {
+            AssignIfExist(allOf_, *schemaDocument, p, value, GetAllOfString(), document);
+            AssignIfExist(anyOf_, *schemaDocument, p, value, GetAnyOfString(), document);
+            AssignIfExist(oneOf_, *schemaDocument, p, value, GetOneOfString(), document);
+        }
+
+        if (const ValueType* v = GetMember(value, GetNotString())) {
+            schemaDocument->CreateSchema(&not_, p.Append(GetNotString(), allocator_), *v, document);
+            notValidatorIndex_ = validatorCount_;
+            validatorCount_++;
+        }
+
+        // Object
+
+        const ValueType* properties = GetMember(value, GetPropertiesString());
+        const ValueType* required = GetMember(value, GetRequiredString());
+        const ValueType* dependencies = GetMember(value, GetDependenciesString());
+        {
+            // Gather properties from properties/required/dependencies
+            SValue allProperties(kArrayType);
+
+            if (properties && properties->IsObject())
+                for (ConstMemberIterator itr = properties->MemberBegin(); itr != properties->MemberEnd(); ++itr)
+                    AddUniqueElement(allProperties, itr->name);
+            
+            if (required && required->IsArray())
+                for (ConstValueIterator itr = required->Begin(); itr != required->End(); ++itr)
+                    if (itr->IsString())
+                        AddUniqueElement(allProperties, *itr);
+
+            if (dependencies && dependencies->IsObject())
+                for (ConstMemberIterator itr = dependencies->MemberBegin(); itr != dependencies->MemberEnd(); ++itr) {
+                    AddUniqueElement(allProperties, itr->name);
+                    if (itr->value.IsArray())
+                        for (ConstValueIterator i = itr->value.Begin(); i != itr->value.End(); ++i)
+                            if (i->IsString())
+                                AddUniqueElement(allProperties, *i);
+                }
+
+            if (allProperties.Size() > 0) {
+                propertyCount_ = allProperties.Size();
+                properties_ = static_cast<Property*>(allocator_->Malloc(sizeof(Property) * propertyCount_));
+                for (SizeType i = 0; i < propertyCount_; i++) {
+                    new (&properties_[i]) Property();
+                    properties_[i].name = allProperties[i];
+                    properties_[i].schema = GetTypeless();
+                }
+            }
+        }
+
+        if (properties && properties->IsObject()) {
+            PointerType q = p.Append(GetPropertiesString(), allocator_);
+            for (ConstMemberIterator itr = properties->MemberBegin(); itr != properties->MemberEnd(); ++itr) {
+                SizeType index;
+                if (FindPropertyIndex(itr->name, &index))
+                    schemaDocument->CreateSchema(&properties_[index].schema, q.Append(itr->name, allocator_), itr->value, document);
+            }
+        }
+
+        if (const ValueType* v = GetMember(value, GetPatternPropertiesString())) {
+            PointerType q = p.Append(GetPatternPropertiesString(), allocator_);
+            patternProperties_ = static_cast<PatternProperty*>(allocator_->Malloc(sizeof(PatternProperty) * v->MemberCount()));
+            patternPropertyCount_ = 0;
+
+            for (ConstMemberIterator itr = v->MemberBegin(); itr != v->MemberEnd(); ++itr) {
+                new (&patternProperties_[patternPropertyCount_]) PatternProperty();
+                patternProperties_[patternPropertyCount_].pattern = CreatePattern(itr->name);
+                schemaDocument->CreateSchema(&patternProperties_[patternPropertyCount_].schema, q.Append(itr->name, allocator_), itr->value, document);
+                patternPropertyCount_++;
+            }
+        }
+
+        if (required && required->IsArray())
+            for (ConstValueIterator itr = required->Begin(); itr != required->End(); ++itr)
+                if (itr->IsString()) {
+                    SizeType index;
+                    if (FindPropertyIndex(*itr, &index)) {
+                        properties_[index].required = true;
+                        hasRequired_ = true;
+                    }
+                }
+
+        if (dependencies && dependencies->IsObject()) {
+            PointerType q = p.Append(GetDependenciesString(), allocator_);
+            hasDependencies_ = true;
+            for (ConstMemberIterator itr = dependencies->MemberBegin(); itr != dependencies->MemberEnd(); ++itr) {
+                SizeType sourceIndex;
+                if (FindPropertyIndex(itr->name, &sourceIndex)) {
+                    if (itr->value.IsArray()) {
+                        properties_[sourceIndex].dependencies = static_cast<bool*>(allocator_->Malloc(sizeof(bool) * propertyCount_));
+                        std::memset(properties_[sourceIndex].dependencies, 0, sizeof(bool)* propertyCount_);
+                        for (ConstValueIterator targetItr = itr->value.Begin(); targetItr != itr->value.End(); ++targetItr) {
+                            SizeType targetIndex;
+                            if (FindPropertyIndex(*targetItr, &targetIndex))
+                                properties_[sourceIndex].dependencies[targetIndex] = true;
+                        }
+                    }
+                    else if (itr->value.IsObject()) {
+                        hasSchemaDependencies_ = true;
+                        schemaDocument->CreateSchema(&properties_[sourceIndex].dependenciesSchema, q.Append(itr->name, allocator_), itr->value, document);
+                        properties_[sourceIndex].dependenciesValidatorIndex = validatorCount_;
+                        validatorCount_++;
+                    }
+                }
+            }
+        }
+
+        if (const ValueType* v = GetMember(value, GetAdditionalPropertiesString())) {
+            if (v->IsBool())
+                additionalProperties_ = v->GetBool();
+            else if (v->IsObject())
+                schemaDocument->CreateSchema(&additionalPropertiesSchema_, p.Append(GetAdditionalPropertiesString(), allocator_), *v, document);
+        }
+
+        AssignIfExist(minProperties_, value, GetMinPropertiesString());
+        AssignIfExist(maxProperties_, value, GetMaxPropertiesString());
+
+        // Array
+        if (const ValueType* v = GetMember(value, GetItemsString())) {
+            PointerType q = p.Append(GetItemsString(), allocator_);
+            if (v->IsObject()) // List validation
+                schemaDocument->CreateSchema(&itemsList_, q, *v, document);
+            else if (v->IsArray()) { // Tuple validation
+                itemsTuple_ = static_cast<const Schema**>(allocator_->Malloc(sizeof(const Schema*) * v->Size()));
+                SizeType index = 0;
+                for (ConstValueIterator itr = v->Begin(); itr != v->End(); ++itr, index++)
+                    schemaDocument->CreateSchema(&itemsTuple_[itemsTupleCount_++], q.Append(index, allocator_), *itr, document);
+            }
+        }
+
+        AssignIfExist(minItems_, value, GetMinItemsString());
+        AssignIfExist(maxItems_, value, GetMaxItemsString());
+
+        if (const ValueType* v = GetMember(value, GetAdditionalItemsString())) {
+            if (v->IsBool())
+                additionalItems_ = v->GetBool();
+            else if (v->IsObject())
+                schemaDocument->CreateSchema(&additionalItemsSchema_, p.Append(GetAdditionalItemsString(), allocator_), *v, document);
+        }
+
+        AssignIfExist(uniqueItems_, value, GetUniqueItemsString());
+
+        // String
+        AssignIfExist(minLength_, value, GetMinLengthString());
+        AssignIfExist(maxLength_, value, GetMaxLengthString());
+
+        if (const ValueType* v = GetMember(value, GetPatternString()))
+            pattern_ = CreatePattern(*v);
+
+        // Number
+        if (const ValueType* v = GetMember(value, GetMinimumString()))
+            if (v->IsNumber())
+                minimum_.CopyFrom(*v, *allocator_);
+
+        if (const ValueType* v = GetMember(value, GetMaximumString()))
+            if (v->IsNumber())
+                maximum_.CopyFrom(*v, *allocator_);
+
+        AssignIfExist(exclusiveMinimum_, value, GetExclusiveMinimumString());
+        AssignIfExist(exclusiveMaximum_, value, GetExclusiveMaximumString());
+
+        if (const ValueType* v = GetMember(value, GetMultipleOfString()))
+            if (v->IsNumber() && v->GetDouble() > 0.0)
+                multipleOf_.CopyFrom(*v, *allocator_);
+    }
+
+    ~Schema() {
+        if (allocator_) {
+            allocator_->Free(enum_);
+        }
+        if (properties_) {
+            for (SizeType i = 0; i < propertyCount_; i++)
+                properties_[i].~Property();
+            AllocatorType::Free(properties_);
+        }
+        if (patternProperties_) {
+            for (SizeType i = 0; i < patternPropertyCount_; i++)
+                patternProperties_[i].~PatternProperty();
+            AllocatorType::Free(patternProperties_);
+        }
+        AllocatorType::Free(itemsTuple_);
+#if RAPIDJSON_SCHEMA_HAS_REGEX
+        if (pattern_) {
+            pattern_->~RegexType();
+            allocator_->Free(pattern_);
+        }
+#endif
+    }
+
+    bool BeginValue(Context& context) const {
+        if (context.inArray) {
+            if (uniqueItems_)
+                context.valueUniqueness = true;
+
+            if (itemsList_)
+                context.valueSchema = itemsList_;
+            else if (itemsTuple_) {
+                if (context.arrayElementIndex < itemsTupleCount_)
+                    context.valueSchema = itemsTuple_[context.arrayElementIndex];
+                else if (additionalItemsSchema_)
+                    context.valueSchema = additionalItemsSchema_;
+                else if (additionalItems_)
+                    context.valueSchema = GetTypeless();
+                else
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetItemsString());
+            }
+            else
+                context.valueSchema = GetTypeless();
+
+            context.arrayElementIndex++;
+        }
+        return true;
+    }
+
+    RAPIDJSON_FORCEINLINE bool EndValue(Context& context) const {
+        if (context.patternPropertiesValidatorCount > 0) {
+            bool otherValid = false;
+            SizeType count = context.patternPropertiesValidatorCount;
+            if (context.objectPatternValidatorType != Context::kPatternValidatorOnly)
+                otherValid = context.patternPropertiesValidators[--count]->IsValid();
+
+            bool patternValid = true;
+            for (SizeType i = 0; i < count; i++)
+                if (!context.patternPropertiesValidators[i]->IsValid()) {
+                    patternValid = false;
+                    break;
+                }
+
+            if (context.objectPatternValidatorType == Context::kPatternValidatorOnly) {
+                if (!patternValid)
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternPropertiesString());
+            }
+            else if (context.objectPatternValidatorType == Context::kPatternValidatorWithProperty) {
+                if (!patternValid || !otherValid)
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternPropertiesString());
+            }
+            else if (!patternValid && !otherValid) // kPatternValidatorWithAdditionalProperty)
+                RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternPropertiesString());
+        }
+
+        if (enum_) {
+            const uint64_t h = context.factory.GetHashCode(context.hasher);
+            for (SizeType i = 0; i < enumCount_; i++)
+                if (enum_[i] == h)
+                    goto foundEnum;
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetEnumString());
+            foundEnum:;
+        }
+
+        if (allOf_.schemas)
+            for (SizeType i = allOf_.begin; i < allOf_.begin + allOf_.count; i++)
+                if (!context.validators[i]->IsValid())
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetAllOfString());
+        
+        if (anyOf_.schemas) {
+            for (SizeType i = anyOf_.begin; i < anyOf_.begin + anyOf_.count; i++)
+                if (context.validators[i]->IsValid())
+                    goto foundAny;
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetAnyOfString());
+            foundAny:;
+        }
+
+        if (oneOf_.schemas) {
+            bool oneValid = false;
+            for (SizeType i = oneOf_.begin; i < oneOf_.begin + oneOf_.count; i++)
+                if (context.validators[i]->IsValid()) {
+                    if (oneValid)
+                        RAPIDJSON_INVALID_KEYWORD_RETURN(GetOneOfString());
+                    else
+                        oneValid = true;
+                }
+            if (!oneValid)
+                RAPIDJSON_INVALID_KEYWORD_RETURN(GetOneOfString());
+        }
+
+        if (not_ && context.validators[notValidatorIndex_]->IsValid())
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetNotString());
+
+        return true;
+    }
+
+    bool Null(Context& context) const { 
+        if (!(type_ & (1 << kNullSchemaType)))
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+        return CreateParallelValidator(context);
+    }
+    
+    bool Bool(Context& context, bool) const { 
+        if (!(type_ & (1 << kBooleanSchemaType)))
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+        return CreateParallelValidator(context);
+    }
+
+    bool Int(Context& context, int i) const {
+        if (!CheckInt(context, i))
+            return false;
+        return CreateParallelValidator(context);
+    }
+
+    bool Uint(Context& context, unsigned u) const {
+        if (!CheckUint(context, u))
+            return false;
+        return CreateParallelValidator(context);
+    }
+
+    bool Int64(Context& context, int64_t i) const {
+        if (!CheckInt(context, i))
+            return false;
+        return CreateParallelValidator(context);
+    }
+
+    bool Uint64(Context& context, uint64_t u) const {
+        if (!CheckUint(context, u))
+            return false;
+        return CreateParallelValidator(context);
+    }
+
+    bool Double(Context& context, double d) const {
+        if (!(type_ & (1 << kNumberSchemaType)))
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+
+        if (!minimum_.IsNull() && !CheckDoubleMinimum(context, d))
+            return false;
+
+        if (!maximum_.IsNull() && !CheckDoubleMaximum(context, d))
+            return false;
+        
+        if (!multipleOf_.IsNull() && !CheckDoubleMultipleOf(context, d))
+            return false;
+        
+        return CreateParallelValidator(context);
+    }
+    
+    bool String(Context& context, const Ch* str, SizeType length, bool) const {
+        if (!(type_ & (1 << kStringSchemaType)))
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+
+        if (minLength_ != 0 || maxLength_ != SizeType(~0)) {
+            SizeType count;
+            if (internal::CountStringCodePoint<EncodingType>(str, length, &count)) {
+                if (count < minLength_)
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinLengthString());
+                if (count > maxLength_)
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaxLengthString());
+            }
+        }
+
+        if (pattern_ && !IsPatternMatch(pattern_, str, length))
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternString());
+
+        return CreateParallelValidator(context);
+    }
+
+    bool StartObject(Context& context) const { 
+        if (!(type_ & (1 << kObjectSchemaType)))
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+
+        if (hasDependencies_ || hasRequired_) {
+            context.propertyExist = static_cast<bool*>(context.factory.MallocState(sizeof(bool) * propertyCount_));
+            std::memset(context.propertyExist, 0, sizeof(bool) * propertyCount_);
+        }
+
+        if (patternProperties_) { // pre-allocate schema array
+            SizeType count = patternPropertyCount_ + 1; // extra for valuePatternValidatorType
+            context.patternPropertiesSchemas = static_cast<const SchemaType**>(context.factory.MallocState(sizeof(const SchemaType*) * count));
+            context.patternPropertiesSchemaCount = 0;
+            std::memset(context.patternPropertiesSchemas, 0, sizeof(SchemaType*) * count);
+        }
+
+        return CreateParallelValidator(context);
+    }
+    
+    bool Key(Context& context, const Ch* str, SizeType len, bool) const {
+        if (patternProperties_) {
+            context.patternPropertiesSchemaCount = 0;
+            for (SizeType i = 0; i < patternPropertyCount_; i++)
+                if (patternProperties_[i].pattern && IsPatternMatch(patternProperties_[i].pattern, str, len))
+                    context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = patternProperties_[i].schema;
+        }
+
+        SizeType index;
+        if (FindPropertyIndex(ValueType(str, len).Move(), &index)) {
+            if (context.patternPropertiesSchemaCount > 0) {
+                context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = properties_[index].schema;
+                context.valueSchema = GetTypeless();
+                context.valuePatternValidatorType = Context::kPatternValidatorWithProperty;
+            }
+            else
+                context.valueSchema = properties_[index].schema;
+
+            if (context.propertyExist)
+                context.propertyExist[index] = true;
+
+            return true;
+        }
+
+        if (additionalPropertiesSchema_) {
+            if (additionalPropertiesSchema_ && context.patternPropertiesSchemaCount > 0) {
+                context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = additionalPropertiesSchema_;
+                context.valueSchema = GetTypeless();
+                context.valuePatternValidatorType = Context::kPatternValidatorWithAdditionalProperty;
+            }
+            else
+                context.valueSchema = additionalPropertiesSchema_;
+            return true;
+        }
+        else if (additionalProperties_) {
+            context.valueSchema = GetTypeless();
+            return true;
+        }
+
+        if (context.patternPropertiesSchemaCount == 0) // patternProperties are not additional properties
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetAdditionalPropertiesString());
+
+        return true;
+    }
+
+    bool EndObject(Context& context, SizeType memberCount) const {
+        if (hasRequired_)
+            for (SizeType index = 0; index < propertyCount_; index++)
+                if (properties_[index].required)
+                    if (!context.propertyExist[index])
+                        RAPIDJSON_INVALID_KEYWORD_RETURN(GetRequiredString());
+
+        if (memberCount < minProperties_)
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinPropertiesString());
+
+        if (memberCount > maxProperties_)
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaxPropertiesString());
+
+        if (hasDependencies_) {
+            for (SizeType sourceIndex = 0; sourceIndex < propertyCount_; sourceIndex++)
+                if (context.propertyExist[sourceIndex]) {
+                    if (properties_[sourceIndex].dependencies) {
+                        for (SizeType targetIndex = 0; targetIndex < propertyCount_; targetIndex++)
+                            if (properties_[sourceIndex].dependencies[targetIndex] && !context.propertyExist[targetIndex])
+                                RAPIDJSON_INVALID_KEYWORD_RETURN(GetDependenciesString());
+                    }
+                    else if (properties_[sourceIndex].dependenciesSchema)
+                        if (!context.validators[properties_[sourceIndex].dependenciesValidatorIndex]->IsValid())
+                            RAPIDJSON_INVALID_KEYWORD_RETURN(GetDependenciesString());
+                }
+        }
+
+        return true;
+    }
+
+    bool StartArray(Context& context) const { 
+        if (!(type_ & (1 << kArraySchemaType)))
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+
+        context.arrayElementIndex = 0;
+        context.inArray = true;
+
+        return CreateParallelValidator(context);
+    }
+
+    bool EndArray(Context& context, SizeType elementCount) const { 
+        context.inArray = false;
+        
+        if (elementCount < minItems_)
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinItemsString());
+        
+        if (elementCount > maxItems_)
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaxItemsString());
+
+        return true;
+    }
+
+    // Generate functions for string literal according to Ch
+#define RAPIDJSON_STRING_(name, ...) \
+    static const ValueType& Get##name##String() {\
+        static const Ch s[] = { __VA_ARGS__, '\0' };\
+        static const ValueType v(s, sizeof(s) / sizeof(Ch) - 1);\
+        return v;\
+    }
+
+    RAPIDJSON_STRING_(Null, 'n', 'u', 'l', 'l')
+    RAPIDJSON_STRING_(Boolean, 'b', 'o', 'o', 'l', 'e', 'a', 'n')
+    RAPIDJSON_STRING_(Object, 'o', 'b', 'j', 'e', 'c', 't')
+    RAPIDJSON_STRING_(Array, 'a', 'r', 'r', 'a', 'y')
+    RAPIDJSON_STRING_(String, 's', 't', 'r', 'i', 'n', 'g')
+    RAPIDJSON_STRING_(Number, 'n', 'u', 'm', 'b', 'e', 'r')
+    RAPIDJSON_STRING_(Integer, 'i', 'n', 't', 'e', 'g', 'e', 'r')
+    RAPIDJSON_STRING_(Type, 't', 'y', 'p', 'e')
+    RAPIDJSON_STRING_(Enum, 'e', 'n', 'u', 'm')
+    RAPIDJSON_STRING_(AllOf, 'a', 'l', 'l', 'O', 'f')
+    RAPIDJSON_STRING_(AnyOf, 'a', 'n', 'y', 'O', 'f')
+    RAPIDJSON_STRING_(OneOf, 'o', 'n', 'e', 'O', 'f')
+    RAPIDJSON_STRING_(Not, 'n', 'o', 't')
+    RAPIDJSON_STRING_(Properties, 'p', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's')
+    RAPIDJSON_STRING_(Required, 'r', 'e', 'q', 'u', 'i', 'r', 'e', 'd')
+    RAPIDJSON_STRING_(Dependencies, 'd', 'e', 'p', 'e', 'n', 'd', 'e', 'n', 'c', 'i', 'e', 's')
+    RAPIDJSON_STRING_(PatternProperties, 'p', 'a', 't', 't', 'e', 'r', 'n', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's')
+    RAPIDJSON_STRING_(AdditionalProperties, 'a', 'd', 'd', 'i', 't', 'i', 'o', 'n', 'a', 'l', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's')
+    RAPIDJSON_STRING_(MinProperties, 'm', 'i', 'n', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's')
+    RAPIDJSON_STRING_(MaxProperties, 'm', 'a', 'x', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's')
+    RAPIDJSON_STRING_(Items, 'i', 't', 'e', 'm', 's')
+    RAPIDJSON_STRING_(MinItems, 'm', 'i', 'n', 'I', 't', 'e', 'm', 's')
+    RAPIDJSON_STRING_(MaxItems, 'm', 'a', 'x', 'I', 't', 'e', 'm', 's')
+    RAPIDJSON_STRING_(AdditionalItems, 'a', 'd', 'd', 'i', 't', 'i', 'o', 'n', 'a', 'l', 'I', 't', 'e', 'm', 's')
+    RAPIDJSON_STRING_(UniqueItems, 'u', 'n', 'i', 'q', 'u', 'e', 'I', 't', 'e', 'm', 's')
+    RAPIDJSON_STRING_(MinLength, 'm', 'i', 'n', 'L', 'e', 'n', 'g', 't', 'h')
+    RAPIDJSON_STRING_(MaxLength, 'm', 'a', 'x', 'L', 'e', 'n', 'g', 't', 'h')
+    RAPIDJSON_STRING_(Pattern, 'p', 'a', 't', 't', 'e', 'r', 'n')
+    RAPIDJSON_STRING_(Minimum, 'm', 'i', 'n', 'i', 'm', 'u', 'm')
+    RAPIDJSON_STRING_(Maximum, 'm', 'a', 'x', 'i', 'm', 'u', 'm')
+    RAPIDJSON_STRING_(ExclusiveMinimum, 'e', 'x', 'c', 'l', 'u', 's', 'i', 'v', 'e', 'M', 'i', 'n', 'i', 'm', 'u', 'm')
+    RAPIDJSON_STRING_(ExclusiveMaximum, 'e', 'x', 'c', 'l', 'u', 's', 'i', 'v', 'e', 'M', 'a', 'x', 'i', 'm', 'u', 'm')
+    RAPIDJSON_STRING_(MultipleOf, 'm', 'u', 'l', 't', 'i', 'p', 'l', 'e', 'O', 'f')
+
+#undef RAPIDJSON_STRING_
+
+private:
+    enum SchemaValueType {
+        kNullSchemaType,
+        kBooleanSchemaType,
+        kObjectSchemaType,
+        kArraySchemaType,
+        kStringSchemaType,
+        kNumberSchemaType,
+        kIntegerSchemaType,
+        kTotalSchemaType
+    };
+
+#if RAPIDJSON_SCHEMA_USE_INTERNALREGEX
+        typedef internal::GenericRegex<EncodingType> RegexType;
+#elif RAPIDJSON_SCHEMA_USE_STDREGEX
+        typedef std::basic_regex<Ch> RegexType;
+#else
+        typedef char RegexType;
+#endif
+
+    struct SchemaArray {
+        SchemaArray() : schemas(), count() {}
+        ~SchemaArray() { AllocatorType::Free(schemas); }
+        const SchemaType** schemas;
+        SizeType begin; // begin index of context.validators
+        SizeType count;
+    };
+
+    static const SchemaType* GetTypeless() {
+        static SchemaType typeless(0, PointerType(), ValueType(kObjectType).Move(), ValueType(kObjectType).Move(), 0);
+        return &typeless;
+    }
+
+    template <typename V1, typename V2>
+    void AddUniqueElement(V1& a, const V2& v) {
+        for (typename V1::ConstValueIterator itr = a.Begin(); itr != a.End(); ++itr)
+            if (*itr == v)
+                return;
+        V1 c(v, *allocator_);
+        a.PushBack(c, *allocator_);
+    }
+
+    static const ValueType* GetMember(const ValueType& value, const ValueType& name) {
+        typename ValueType::ConstMemberIterator itr = value.FindMember(name);
+        return itr != value.MemberEnd() ? &(itr->value) : 0;
+    }
+
+    static void AssignIfExist(bool& out, const ValueType& value, const ValueType& name) {
+        if (const ValueType* v = GetMember(value, name))
+            if (v->IsBool())
+                out = v->GetBool();
+    }
+
+    static void AssignIfExist(SizeType& out, const ValueType& value, const ValueType& name) {
+        if (const ValueType* v = GetMember(value, name))
+            if (v->IsUint64() && v->GetUint64() <= SizeType(~0))
+                out = static_cast<SizeType>(v->GetUint64());
+    }
+
+    void AssignIfExist(SchemaArray& out, SchemaDocumentType& schemaDocument, const PointerType& p, const ValueType& value, const ValueType& name, const ValueType& document) {
+        if (const ValueType* v = GetMember(value, name)) {
+            if (v->IsArray() && v->Size() > 0) {
+                PointerType q = p.Append(name, allocator_);
+                out.count = v->Size();
+                out.schemas = static_cast<const Schema**>(allocator_->Malloc(out.count * sizeof(const Schema*)));
+                memset(out.schemas, 0, sizeof(Schema*)* out.count);
+                for (SizeType i = 0; i < out.count; i++)
+                    schemaDocument.CreateSchema(&out.schemas[i], q.Append(i, allocator_), (*v)[i], document);
+                out.begin = validatorCount_;
+                validatorCount_ += out.count;
+            }
+        }
+    }
+
+#if RAPIDJSON_SCHEMA_USE_INTERNALREGEX
+    template <typename ValueType>
+    RegexType* CreatePattern(const ValueType& value) {
+        if (value.IsString()) {
+            RegexType* r = new (allocator_->Malloc(sizeof(RegexType))) RegexType(value.GetString());
+            if (!r->IsValid()) {
+                r->~RegexType();
+                AllocatorType::Free(r);
+                r = 0;
+            }
+            return r;
+        }
+        return 0;
+    }
+
+    static bool IsPatternMatch(const RegexType* pattern, const Ch *str, SizeType) {
+        return pattern->Search(str);
+    }
+#elif RAPIDJSON_SCHEMA_USE_STDREGEX
+    template <typename ValueType>
+    RegexType* CreatePattern(const ValueType& value) {
+        if (value.IsString())
+            try {
+                return new (allocator_->Malloc(sizeof(RegexType))) RegexType(value.GetString(), std::size_t(value.GetStringLength()), std::regex_constants::ECMAScript);
+            }
+            catch (const std::regex_error&) {
+            }
+        return 0;
+    }
+
+    static bool IsPatternMatch(const RegexType* pattern, const Ch *str, SizeType length) {
+        std::match_results<const Ch*> r;
+        return std::regex_search(str, str + length, r, *pattern);
+    }
+#else
+    template <typename ValueType>
+    RegexType* CreatePattern(const ValueType&) { return 0; }
+
+    static bool IsPatternMatch(const RegexType*, const Ch *, SizeType) { return true; }
+#endif // RAPIDJSON_SCHEMA_USE_STDREGEX
+
+    void AddType(const ValueType& type) {
+        if      (type == GetNullString()   ) type_ |= 1 << kNullSchemaType;
+        else if (type == GetBooleanString()) type_ |= 1 << kBooleanSchemaType;
+        else if (type == GetObjectString() ) type_ |= 1 << kObjectSchemaType;
+        else if (type == GetArrayString()  ) type_ |= 1 << kArraySchemaType;
+        else if (type == GetStringString() ) type_ |= 1 << kStringSchemaType;
+        else if (type == GetIntegerString()) type_ |= 1 << kIntegerSchemaType;
+        else if (type == GetNumberString() ) type_ |= (1 << kNumberSchemaType) | (1 << kIntegerSchemaType);
+    }
+
+    bool CreateParallelValidator(Context& context) const {
+        if (enum_ || context.arrayUniqueness)
+            context.hasher = context.factory.CreateHasher();
+
+        if (validatorCount_) {
+            RAPIDJSON_ASSERT(context.validators == 0);
+            context.validators = static_cast<ISchemaValidator**>(context.factory.MallocState(sizeof(ISchemaValidator*) * validatorCount_));
+            context.validatorCount = validatorCount_;
+
+            if (allOf_.schemas)
+                CreateSchemaValidators(context, allOf_);
+
+            if (anyOf_.schemas)
+                CreateSchemaValidators(context, anyOf_);
+            
+            if (oneOf_.schemas)
+                CreateSchemaValidators(context, oneOf_);
+            
+            if (not_)
+                context.validators[notValidatorIndex_] = context.factory.CreateSchemaValidator(*not_);
+            
+            if (hasSchemaDependencies_) {
+                for (SizeType i = 0; i < propertyCount_; i++)
+                    if (properties_[i].dependenciesSchema)
+                        context.validators[properties_[i].dependenciesValidatorIndex] = context.factory.CreateSchemaValidator(*properties_[i].dependenciesSchema);
+            }
+        }
+
+        return true;
+    }
+
+    void CreateSchemaValidators(Context& context, const SchemaArray& schemas) const {
+        for (SizeType i = 0; i < schemas.count; i++)
+            context.validators[schemas.begin + i] = context.factory.CreateSchemaValidator(*schemas.schemas[i]);
+    }
+
+    // O(n)
+    bool FindPropertyIndex(const ValueType& name, SizeType* outIndex) const {
+        SizeType len = name.GetStringLength();
+        const Ch* str = name.GetString();
+        for (SizeType index = 0; index < propertyCount_; index++)
+            if (properties_[index].name.GetStringLength() == len && 
+                (std::memcmp(properties_[index].name.GetString(), str, sizeof(Ch) * len) == 0))
+            {
+                *outIndex = index;
+                return true;
+            }
+        return false;
+    }
+
+    bool CheckInt(Context& context, int64_t i) const {
+        if (!(type_ & ((1 << kIntegerSchemaType) | (1 << kNumberSchemaType))))
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+
+        if (!minimum_.IsNull()) {
+            if (minimum_.IsInt64()) {
+                if (exclusiveMinimum_ ? i <= minimum_.GetInt64() : i < minimum_.GetInt64())
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString());
+            }
+            else if (minimum_.IsUint64()) {
+                RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString()); // i <= max(int64_t) < minimum.GetUint64()
+            }
+            else if (!CheckDoubleMinimum(context, static_cast<double>(i)))
+                return false;
+        }
+
+        if (!maximum_.IsNull()) {
+            if (maximum_.IsInt64()) {
+                if (exclusiveMaximum_ ? i >= maximum_.GetInt64() : i > maximum_.GetInt64())
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString());
+            }
+            else if (maximum_.IsUint64())
+                /* do nothing */; // i <= max(int64_t) < maximum_.GetUint64()
+            else if (!CheckDoubleMaximum(context, static_cast<double>(i)))
+                return false;
+        }
+
+        if (!multipleOf_.IsNull()) {
+            if (multipleOf_.IsUint64()) {
+                if (static_cast<uint64_t>(i >= 0 ? i : -i) % multipleOf_.GetUint64() != 0)
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMultipleOfString());
+            }
+            else if (!CheckDoubleMultipleOf(context, static_cast<double>(i)))
+                return false;
+        }
+
+        return true;
+    }
+
+    bool CheckUint(Context& context, uint64_t i) const {
+        if (!(type_ & ((1 << kIntegerSchemaType) | (1 << kNumberSchemaType))))
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+
+        if (!minimum_.IsNull()) {
+            if (minimum_.IsUint64()) {
+                if (exclusiveMinimum_ ? i <= minimum_.GetUint64() : i < minimum_.GetUint64())
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString());
+            }
+            else if (minimum_.IsInt64())
+                /* do nothing */; // i >= 0 > minimum.Getint64()
+            else if (!CheckDoubleMinimum(context, static_cast<double>(i)))
+                return false;
+        }
+
+        if (!maximum_.IsNull()) {
+            if (maximum_.IsUint64()) {
+                if (exclusiveMaximum_ ? i >= maximum_.GetUint64() : i > maximum_.GetUint64())
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString());
+            }
+            else if (maximum_.IsInt64())
+                RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString()); // i >= 0 > maximum_
+            else if (!CheckDoubleMaximum(context, static_cast<double>(i)))
+                return false;
+        }
+
+        if (!multipleOf_.IsNull()) {
+            if (multipleOf_.IsUint64()) {
+                if (i % multipleOf_.GetUint64() != 0)
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMultipleOfString());
+            }
+            else if (!CheckDoubleMultipleOf(context, static_cast<double>(i)))
+                return false;
+        }
+
+        return true;
+    }
+
+    bool CheckDoubleMinimum(Context& context, double d) const {
+        if (exclusiveMinimum_ ? d <= minimum_.GetDouble() : d < minimum_.GetDouble())
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString());
+        return true;
+    }
+
+    bool CheckDoubleMaximum(Context& context, double d) const {
+        if (exclusiveMaximum_ ? d >= maximum_.GetDouble() : d > maximum_.GetDouble())
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString());
+        return true;
+    }
+
+    bool CheckDoubleMultipleOf(Context& context, double d) const {
+        double a = std::abs(d), b = std::abs(multipleOf_.GetDouble());
+        double q = std::floor(a / b);
+        double r = a - q * b;
+        if (r > 0.0)
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetMultipleOfString());
+        return true;
+    }
+
+    struct Property {
+        Property() : schema(), dependenciesSchema(), dependenciesValidatorIndex(), dependencies(), required(false) {}
+        ~Property() { AllocatorType::Free(dependencies); }
+        SValue name;
+        const SchemaType* schema;
+        const SchemaType* dependenciesSchema;
+        SizeType dependenciesValidatorIndex;
+        bool* dependencies;
+        bool required;
+    };
+
+    struct PatternProperty {
+        PatternProperty() : schema(), pattern() {}
+        ~PatternProperty() { 
+            if (pattern) {
+                pattern->~RegexType();
+                AllocatorType::Free(pattern);
+            }
+        }
+        const SchemaType* schema;
+        RegexType* pattern;
+    };
+
+    AllocatorType* allocator_;
+    uint64_t* enum_;
+    SizeType enumCount_;
+    SchemaArray allOf_;
+    SchemaArray anyOf_;
+    SchemaArray oneOf_;
+    const SchemaType* not_;
+    unsigned type_; // bitmask of kSchemaType
+    SizeType validatorCount_;
+    SizeType notValidatorIndex_;
+
+    Property* properties_;
+    const SchemaType* additionalPropertiesSchema_;
+    PatternProperty* patternProperties_;
+    SizeType patternPropertyCount_;
+    SizeType propertyCount_;
+    SizeType minProperties_;
+    SizeType maxProperties_;
+    bool additionalProperties_;
+    bool hasDependencies_;
+    bool hasRequired_;
+    bool hasSchemaDependencies_;
+
+    const SchemaType* additionalItemsSchema_;
+    const SchemaType* itemsList_;
+    const SchemaType** itemsTuple_;
+    SizeType itemsTupleCount_;
+    SizeType minItems_;
+    SizeType maxItems_;
+    bool additionalItems_;
+    bool uniqueItems_;
+
+    RegexType* pattern_;
+    SizeType minLength_;
+    SizeType maxLength_;
+
+    SValue minimum_;
+    SValue maximum_;
+    SValue multipleOf_;
+    bool exclusiveMinimum_;
+    bool exclusiveMaximum_;
+};
+
+template<typename Stack, typename Ch>
+struct TokenHelper {
+    RAPIDJSON_FORCEINLINE static void AppendIndexToken(Stack& documentStack, SizeType index) {
+        *documentStack.template Push<Ch>() = '/';
+        char buffer[21];
+        size_t length = static_cast<size_t>((sizeof(SizeType) == 4 ? u32toa(index, buffer) : u64toa(index, buffer)) - buffer);
+        for (size_t i = 0; i < length; i++)
+            *documentStack.template Push<Ch>() = buffer[i];
+    }
+};
+
+// Partial specialized version for char to prevent buffer copying.
+template <typename Stack>
+struct TokenHelper<Stack, char> {
+    RAPIDJSON_FORCEINLINE static void AppendIndexToken(Stack& documentStack, SizeType index) {
+        if (sizeof(SizeType) == 4) {
+            char *buffer = documentStack.template Push<char>(1 + 10); // '/' + uint
+            *buffer++ = '/';
+            const char* end = internal::u32toa(index, buffer);
+             documentStack.template Pop<char>(static_cast<size_t>(10 - (end - buffer)));
+        }
+        else {
+            char *buffer = documentStack.template Push<char>(1 + 20); // '/' + uint64
+            *buffer++ = '/';
+            const char* end = internal::u64toa(index, buffer);
+            documentStack.template Pop<char>(static_cast<size_t>(20 - (end - buffer)));
+        }
+    }
+};
+
+} // namespace internal
+
+///////////////////////////////////////////////////////////////////////////////
+// IGenericRemoteSchemaDocumentProvider
+
+template <typename SchemaDocumentType>
+class IGenericRemoteSchemaDocumentProvider {
+public:
+    typedef typename SchemaDocumentType::Ch Ch;
+
+    virtual ~IGenericRemoteSchemaDocumentProvider() {}
+    virtual const SchemaDocumentType* GetRemoteDocument(const Ch* uri, SizeType length) = 0;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// GenericSchemaDocument
+
+//! JSON schema document.
+/*!
+    A JSON schema document is a compiled version of a JSON schema.
+    It is basically a tree of internal::Schema.
+
+    \note This is an immutable class (i.e. its instance cannot be modified after construction).
+    \tparam ValueT Type of JSON value (e.g. \c Value ), which also determine the encoding.
+    \tparam Allocator Allocator type for allocating memory of this document.
+*/
+template <typename ValueT, typename Allocator = CrtAllocator>
+class GenericSchemaDocument {
+public:
+    typedef ValueT ValueType;
+    typedef IGenericRemoteSchemaDocumentProvider<GenericSchemaDocument> IRemoteSchemaDocumentProviderType;
+    typedef Allocator AllocatorType;
+    typedef typename ValueType::EncodingType EncodingType;
+    typedef typename EncodingType::Ch Ch;
+    typedef internal::Schema<GenericSchemaDocument> SchemaType;
+    typedef GenericPointer<ValueType, Allocator> PointerType;
+    friend class internal::Schema<GenericSchemaDocument>;
+    template <typename, typename, typename>
+    friend class GenericSchemaValidator;
+
+    //! Constructor.
+    /*!
+        Compile a JSON document into schema document.
+
+        \param document A JSON document as source.
+        \param remoteProvider An optional remote schema document provider for resolving remote reference. Can be null.
+        \param allocator An optional allocator instance for allocating memory. Can be null.
+    */
+    explicit GenericSchemaDocument(const ValueType& document, IRemoteSchemaDocumentProviderType* remoteProvider = 0, Allocator* allocator = 0) :
+        remoteProvider_(remoteProvider),
+        allocator_(allocator),
+        ownAllocator_(),
+        root_(),
+        schemaMap_(allocator, kInitialSchemaMapSize),
+        schemaRef_(allocator, kInitialSchemaRefSize)
+    {
+        if (!allocator_)
+            ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator());
+
+        // Generate root schema, it will call CreateSchema() to create sub-schemas,
+        // And call AddRefSchema() if there are $ref.
+        CreateSchemaRecursive(&root_, PointerType(), document, document);
+
+        // Resolve $ref
+        while (!schemaRef_.Empty()) {
+            SchemaRefEntry* refEntry = schemaRef_.template Pop<SchemaRefEntry>(1);
+            if (const SchemaType* s = GetSchema(refEntry->target)) {
+                if (refEntry->schema)
+                    *refEntry->schema = s;
+
+                // Create entry in map if not exist
+                if (!GetSchema(refEntry->source)) {
+                    new (schemaMap_.template Push<SchemaEntry>()) SchemaEntry(refEntry->source, const_cast<SchemaType*>(s), false, allocator_);
+                }
+            }
+            refEntry->~SchemaRefEntry();
+        }
+
+        RAPIDJSON_ASSERT(root_ != 0);
+
+        schemaRef_.ShrinkToFit(); // Deallocate all memory for ref
+    }
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+    //! Move constructor in C++11
+    GenericSchemaDocument(GenericSchemaDocument&& rhs) RAPIDJSON_NOEXCEPT :
+        remoteProvider_(rhs.remoteProvider_),
+        allocator_(rhs.allocator_),
+        ownAllocator_(rhs.ownAllocator_),
+        root_(rhs.root_),
+        schemaMap_(std::move(rhs.schemaMap_)),
+        schemaRef_(std::move(rhs.schemaRef_))
+    {
+        rhs.remoteProvider_ = 0;
+        rhs.allocator_ = 0;
+        rhs.ownAllocator_ = 0;
+    }
+#endif
+
+    //! Destructor
+    ~GenericSchemaDocument() {
+        while (!schemaMap_.Empty())
+            schemaMap_.template Pop<SchemaEntry>(1)->~SchemaEntry();
+
+        RAPIDJSON_DELETE(ownAllocator_);
+    }
+
+    //! Get the root schema.
+    const SchemaType& GetRoot() const { return *root_; }
+
+private:
+    //! Prohibit copying
+    GenericSchemaDocument(const GenericSchemaDocument&);
+    //! Prohibit assignment
+    GenericSchemaDocument& operator=(const GenericSchemaDocument&);
+
+    struct SchemaRefEntry {
+        SchemaRefEntry(const PointerType& s, const PointerType& t, const SchemaType** outSchema, Allocator *allocator) : source(s, allocator), target(t, allocator), schema(outSchema) {}
+        PointerType source;
+        PointerType target;
+        const SchemaType** schema;
+    };
+
+    struct SchemaEntry {
+        SchemaEntry(const PointerType& p, SchemaType* s, bool o, Allocator* allocator) : pointer(p, allocator), schema(s), owned(o) {}
+        ~SchemaEntry() {
+            if (owned) {
+                schema->~SchemaType();
+                Allocator::Free(schema);
+            }
+        }
+        PointerType pointer;
+        SchemaType* schema;
+        bool owned;
+    };
+
+    void CreateSchemaRecursive(const SchemaType** schema, const PointerType& pointer, const ValueType& v, const ValueType& document) {
+        if (schema)
+            *schema = SchemaType::GetTypeless();
+
+        if (v.GetType() == kObjectType) {
+            const SchemaType* s = GetSchema(pointer);
+            if (!s)
+                CreateSchema(schema, pointer, v, document);
+
+            for (typename ValueType::ConstMemberIterator itr = v.MemberBegin(); itr != v.MemberEnd(); ++itr)
+                CreateSchemaRecursive(0, pointer.Append(itr->name, allocator_), itr->value, document);
+        }
+        else if (v.GetType() == kArrayType)
+            for (SizeType i = 0; i < v.Size(); i++)
+                CreateSchemaRecursive(0, pointer.Append(i, allocator_), v[i], document);
+    }
+
+    void CreateSchema(const SchemaType** schema, const PointerType& pointer, const ValueType& v, const ValueType& document) {
+        RAPIDJSON_ASSERT(pointer.IsValid());
+        if (v.IsObject()) {
+            if (!HandleRefSchema(pointer, schema, v, document)) {
+                SchemaType* s = new (allocator_->Malloc(sizeof(SchemaType))) SchemaType(this, pointer, v, document, allocator_);
+                new (schemaMap_.template Push<SchemaEntry>()) SchemaEntry(pointer, s, true, allocator_);
+                if (schema)
+                    *schema = s;
+            }
+        }
+    }
+
+    bool HandleRefSchema(const PointerType& source, const SchemaType** schema, const ValueType& v, const ValueType& document) {
+        static const Ch kRefString[] = { '$', 'r', 'e', 'f', '\0' };
+        static const ValueType kRefValue(kRefString, 4);
+
+        typename ValueType::ConstMemberIterator itr = v.FindMember(kRefValue);
+        if (itr == v.MemberEnd())
+            return false;
+
+        if (itr->value.IsString()) {
+            SizeType len = itr->value.GetStringLength();
+            if (len > 0) {
+                const Ch* s = itr->value.GetString();
+                SizeType i = 0;
+                while (i < len && s[i] != '#') // Find the first #
+                    i++;
+
+                if (i > 0) { // Remote reference, resolve immediately
+                    if (remoteProvider_) {
+                        if (const GenericSchemaDocument* remoteDocument = remoteProvider_->GetRemoteDocument(s, i - 1)) {
+                            PointerType pointer(&s[i], len - i, allocator_);
+                            if (pointer.IsValid()) {
+                                if (const SchemaType* sc = remoteDocument->GetSchema(pointer)) {
+                                    if (schema)
+                                        *schema = sc;
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+                }
+                else if (s[i] == '#') { // Local reference, defer resolution
+                    PointerType pointer(&s[i], len - i, allocator_);
+                    if (pointer.IsValid()) {
+                        if (const ValueType* nv = pointer.Get(document))
+                            if (HandleRefSchema(source, schema, *nv, document))
+                                return true;
+
+                        new (schemaRef_.template Push<SchemaRefEntry>()) SchemaRefEntry(source, pointer, schema, allocator_);
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+
+    const SchemaType* GetSchema(const PointerType& pointer) const {
+        for (const SchemaEntry* target = schemaMap_.template Bottom<SchemaEntry>(); target != schemaMap_.template End<SchemaEntry>(); ++target)
+            if (pointer == target->pointer)
+                return target->schema;
+        return 0;
+    }
+
+    PointerType GetPointer(const SchemaType* schema) const {
+        for (const SchemaEntry* target = schemaMap_.template Bottom<SchemaEntry>(); target != schemaMap_.template End<SchemaEntry>(); ++target)
+            if (schema == target->schema)
+                return target->pointer;
+        return PointerType();
+    }
+
+    static const size_t kInitialSchemaMapSize = 64;
+    static const size_t kInitialSchemaRefSize = 64;
+
+    IRemoteSchemaDocumentProviderType* remoteProvider_;
+    Allocator *allocator_;
+    Allocator *ownAllocator_;
+    const SchemaType* root_;                //!< Root schema.
+    internal::Stack<Allocator> schemaMap_;  // Stores created Pointer -> Schemas
+    internal::Stack<Allocator> schemaRef_;  // Stores Pointer from $ref and schema which holds the $ref
+};
+
+//! GenericSchemaDocument using Value type.
+typedef GenericSchemaDocument<Value> SchemaDocument;
+//! IGenericRemoteSchemaDocumentProvider using SchemaDocument.
+typedef IGenericRemoteSchemaDocumentProvider<SchemaDocument> IRemoteSchemaDocumentProvider;
+
+///////////////////////////////////////////////////////////////////////////////
+// GenericSchemaValidator
+
+//! JSON Schema Validator.
+/*!
+    A SAX style JSON schema validator.
+    It uses a \c GenericSchemaDocument to validate SAX events.
+    It delegates the incoming SAX events to an output handler.
+    The default output handler does nothing.
+    It can be reused multiple times by calling \c Reset().
+
+    \tparam SchemaDocumentType Type of schema document.
+    \tparam OutputHandler Type of output handler. Default handler does nothing.
+    \tparam StateAllocator Allocator for storing the internal validation states.
+*/
+template <
+    typename SchemaDocumentType,
+    typename OutputHandler = BaseReaderHandler<typename SchemaDocumentType::SchemaType::EncodingType>,
+    typename StateAllocator = CrtAllocator>
+class GenericSchemaValidator :
+    public internal::ISchemaStateFactory<typename SchemaDocumentType::SchemaType>, 
+    public internal::ISchemaValidator
+{
+public:
+    typedef typename SchemaDocumentType::SchemaType SchemaType;
+    typedef typename SchemaDocumentType::PointerType PointerType;
+    typedef typename SchemaType::EncodingType EncodingType;
+    typedef typename EncodingType::Ch Ch;
+
+    //! Constructor without output handler.
+    /*!
+        \param schemaDocument The schema document to conform to.
+        \param allocator Optional allocator for storing internal validation states.
+        \param schemaStackCapacity Optional initial capacity of schema path stack.
+        \param documentStackCapacity Optional initial capacity of document path stack.
+    */
+    GenericSchemaValidator(
+        const SchemaDocumentType& schemaDocument,
+        StateAllocator* allocator = 0, 
+        size_t schemaStackCapacity = kDefaultSchemaStackCapacity,
+        size_t documentStackCapacity = kDefaultDocumentStackCapacity)
+        :
+        schemaDocument_(&schemaDocument),
+        root_(schemaDocument.GetRoot()),
+        outputHandler_(GetNullHandler()),
+        stateAllocator_(allocator),
+        ownStateAllocator_(0),
+        schemaStack_(allocator, schemaStackCapacity),
+        documentStack_(allocator, documentStackCapacity),
+        valid_(true)
+#if RAPIDJSON_SCHEMA_VERBOSE
+        , depth_(0)
+#endif
+    {
+    }
+
+    //! Constructor with output handler.
+    /*!
+        \param schemaDocument The schema document to conform to.
+        \param allocator Optional allocator for storing internal validation states.
+        \param schemaStackCapacity Optional initial capacity of schema path stack.
+        \param documentStackCapacity Optional initial capacity of document path stack.
+    */
+    GenericSchemaValidator(
+        const SchemaDocumentType& schemaDocument,
+        OutputHandler& outputHandler,
+        StateAllocator* allocator = 0, 
+        size_t schemaStackCapacity = kDefaultSchemaStackCapacity,
+        size_t documentStackCapacity = kDefaultDocumentStackCapacity)
+        :
+        schemaDocument_(&schemaDocument),
+        root_(schemaDocument.GetRoot()),
+        outputHandler_(outputHandler),
+        stateAllocator_(allocator),
+        ownStateAllocator_(0),
+        schemaStack_(allocator, schemaStackCapacity),
+        documentStack_(allocator, documentStackCapacity),
+        valid_(true)
+#if RAPIDJSON_SCHEMA_VERBOSE
+        , depth_(0)
+#endif
+    {
+    }
+
+    //! Destructor.
+    ~GenericSchemaValidator() {
+        Reset();
+        RAPIDJSON_DELETE(ownStateAllocator_);
+    }
+
+    //! Reset the internal states.
+    void Reset() {
+        while (!schemaStack_.Empty())
+            PopSchema();
+        documentStack_.Clear();
+        valid_ = true;
+    }
+
+    //! Checks whether the current state is valid.
+    // Implementation of ISchemaValidator
+    virtual bool IsValid() const { return valid_; }
+
+    //! Gets the JSON pointer pointed to the invalid schema.
+    PointerType GetInvalidSchemaPointer() const {
+        return schemaStack_.Empty() ? PointerType() : schemaDocument_->GetPointer(&CurrentSchema());
+    }
+
+    //! Gets the keyword of invalid schema.
+    const Ch* GetInvalidSchemaKeyword() const {
+        return schemaStack_.Empty() ? 0 : CurrentContext().invalidKeyword;
+    }
+
+    //! Gets the JSON pointer pointed to the invalid value.
+    PointerType GetInvalidDocumentPointer() const {
+        return documentStack_.Empty() ? PointerType() : PointerType(documentStack_.template Bottom<Ch>(), documentStack_.GetSize() / sizeof(Ch));
+    }
+
+#if RAPIDJSON_SCHEMA_VERBOSE
+#define RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_() \
+RAPIDJSON_MULTILINEMACRO_BEGIN\
+    *documentStack_.template Push<Ch>() = '\0';\
+    documentStack_.template Pop<Ch>(1);\
+    internal::PrintInvalidDocument(documentStack_.template Bottom<Ch>());\
+RAPIDJSON_MULTILINEMACRO_END
+#else
+#define RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_()
+#endif
+
+#define RAPIDJSON_SCHEMA_HANDLE_BEGIN_(method, arg1)\
+    if (!valid_) return false; \
+    if (!BeginValue() || !CurrentSchema().method arg1) {\
+        RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_();\
+        return valid_ = false;\
+    }
+
+#define RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(method, arg2)\
+    for (Context* context = schemaStack_.template Bottom<Context>(); context != schemaStack_.template End<Context>(); context++) {\
+        if (context->hasher)\
+            static_cast<HasherType*>(context->hasher)->method arg2;\
+        if (context->validators)\
+            for (SizeType i_ = 0; i_ < context->validatorCount; i_++)\
+                static_cast<GenericSchemaValidator*>(context->validators[i_])->method arg2;\
+        if (context->patternPropertiesValidators)\
+            for (SizeType i_ = 0; i_ < context->patternPropertiesValidatorCount; i_++)\
+                static_cast<GenericSchemaValidator*>(context->patternPropertiesValidators[i_])->method arg2;\
+    }
+
+#define RAPIDJSON_SCHEMA_HANDLE_END_(method, arg2)\
+    return valid_ = EndValue() && outputHandler_.method arg2
+
+#define RAPIDJSON_SCHEMA_HANDLE_VALUE_(method, arg1, arg2) \
+    RAPIDJSON_SCHEMA_HANDLE_BEGIN_   (method, arg1);\
+    RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(method, arg2);\
+    RAPIDJSON_SCHEMA_HANDLE_END_     (method, arg2)
+
+    bool Null()             { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Null,   (CurrentContext()   ), ( )); }
+    bool Bool(bool b)       { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Bool,   (CurrentContext(), b), (b)); }
+    bool Int(int i)         { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Int,    (CurrentContext(), i), (i)); }
+    bool Uint(unsigned u)   { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Uint,   (CurrentContext(), u), (u)); }
+    bool Int64(int64_t i)   { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Int64,  (CurrentContext(), i), (i)); }
+    bool Uint64(uint64_t u) { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Uint64, (CurrentContext(), u), (u)); }
+    bool Double(double d)   { RAPIDJSON_SCHEMA_HANDLE_VALUE_(Double, (CurrentContext(), d), (d)); }
+    bool RawNumber(const Ch* str, SizeType length, bool copy)
+                                    { RAPIDJSON_SCHEMA_HANDLE_VALUE_(String, (CurrentContext(), str, length, copy), (str, length, copy)); }
+    bool String(const Ch* str, SizeType length, bool copy)
+                                    { RAPIDJSON_SCHEMA_HANDLE_VALUE_(String, (CurrentContext(), str, length, copy), (str, length, copy)); }
+
+    bool StartObject() {
+        RAPIDJSON_SCHEMA_HANDLE_BEGIN_(StartObject, (CurrentContext()));
+        RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(StartObject, ());
+        return valid_ = outputHandler_.StartObject();
+    }
+    
+    bool Key(const Ch* str, SizeType len, bool copy) {
+        if (!valid_) return false;
+        AppendToken(str, len);
+        if (!CurrentSchema().Key(CurrentContext(), str, len, copy)) return valid_ = false;
+        RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(Key, (str, len, copy));
+        return valid_ = outputHandler_.Key(str, len, copy);
+    }
+    
+    bool EndObject(SizeType memberCount) { 
+        if (!valid_) return false;
+        RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(EndObject, (memberCount));
+        if (!CurrentSchema().EndObject(CurrentContext(), memberCount)) return valid_ = false;
+        RAPIDJSON_SCHEMA_HANDLE_END_(EndObject, (memberCount));
+    }
+
+    bool StartArray() {
+        RAPIDJSON_SCHEMA_HANDLE_BEGIN_(StartArray, (CurrentContext()));
+        RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(StartArray, ());
+        return valid_ = outputHandler_.StartArray();
+    }
+    
+    bool EndArray(SizeType elementCount) {
+        if (!valid_) return false;
+        RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(EndArray, (elementCount));
+        if (!CurrentSchema().EndArray(CurrentContext(), elementCount)) return valid_ = false;
+        RAPIDJSON_SCHEMA_HANDLE_END_(EndArray, (elementCount));
+    }
+
+#undef RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_
+#undef RAPIDJSON_SCHEMA_HANDLE_BEGIN_
+#undef RAPIDJSON_SCHEMA_HANDLE_PARALLEL_
+#undef RAPIDJSON_SCHEMA_HANDLE_VALUE_
+
+    // Implementation of ISchemaStateFactory<SchemaType>
+    virtual ISchemaValidator* CreateSchemaValidator(const SchemaType& root) {
+        return new (GetStateAllocator().Malloc(sizeof(GenericSchemaValidator))) GenericSchemaValidator(*schemaDocument_, root,
+#if RAPIDJSON_SCHEMA_VERBOSE
+        depth_ + 1,
+#endif
+        &GetStateAllocator());
+    }
+
+    virtual void DestroySchemaValidator(ISchemaValidator* validator) {
+        GenericSchemaValidator* v = static_cast<GenericSchemaValidator*>(validator);
+        v->~GenericSchemaValidator();
+        StateAllocator::Free(v);
+    }
+
+    virtual void* CreateHasher() {
+        return new (GetStateAllocator().Malloc(sizeof(HasherType))) HasherType(&GetStateAllocator());
+    }
+
+    virtual uint64_t GetHashCode(void* hasher) {
+        return static_cast<HasherType*>(hasher)->GetHashCode();
+    }
+
+    virtual void DestroryHasher(void* hasher) {
+        HasherType* h = static_cast<HasherType*>(hasher);
+        h->~HasherType();
+        StateAllocator::Free(h);
+    }
+
+    virtual void* MallocState(size_t size) {
+        return GetStateAllocator().Malloc(size);
+    }
+
+    virtual void FreeState(void* p) {
+        return StateAllocator::Free(p);
+    }
+
+private:
+    typedef typename SchemaType::Context Context;
+    typedef GenericValue<UTF8<>, StateAllocator> HashCodeArray;
+    typedef internal::Hasher<EncodingType, StateAllocator> HasherType;
+
+    GenericSchemaValidator( 
+        const SchemaDocumentType& schemaDocument,
+        const SchemaType& root,
+#if RAPIDJSON_SCHEMA_VERBOSE
+        unsigned depth,
+#endif
+        StateAllocator* allocator = 0,
+        size_t schemaStackCapacity = kDefaultSchemaStackCapacity,
+        size_t documentStackCapacity = kDefaultDocumentStackCapacity)
+        :
+        schemaDocument_(&schemaDocument),
+        root_(root),
+        outputHandler_(GetNullHandler()),
+        stateAllocator_(allocator),
+        ownStateAllocator_(0),
+        schemaStack_(allocator, schemaStackCapacity),
+        documentStack_(allocator, documentStackCapacity),
+        valid_(true)
+#if RAPIDJSON_SCHEMA_VERBOSE
+        , depth_(depth)
+#endif
+    {
+    }
+
+    StateAllocator& GetStateAllocator() {
+        if (!stateAllocator_)
+            stateAllocator_ = ownStateAllocator_ = RAPIDJSON_NEW(StateAllocator());
+        return *stateAllocator_;
+    }
+
+    bool BeginValue() {
+        if (schemaStack_.Empty())
+            PushSchema(root_);
+        else {
+            if (CurrentContext().inArray)
+                internal::TokenHelper<internal::Stack<StateAllocator>, Ch>::AppendIndexToken(documentStack_, CurrentContext().arrayElementIndex);
+
+            if (!CurrentSchema().BeginValue(CurrentContext()))
+                return false;
+
+            SizeType count = CurrentContext().patternPropertiesSchemaCount;
+            const SchemaType** sa = CurrentContext().patternPropertiesSchemas;
+            typename Context::PatternValidatorType patternValidatorType = CurrentContext().valuePatternValidatorType;
+            bool valueUniqueness = CurrentContext().valueUniqueness;
+            if (CurrentContext().valueSchema)
+                PushSchema(*CurrentContext().valueSchema);
+
+            if (count > 0) {
+                CurrentContext().objectPatternValidatorType = patternValidatorType;
+                ISchemaValidator**& va = CurrentContext().patternPropertiesValidators;
+                SizeType& validatorCount = CurrentContext().patternPropertiesValidatorCount;
+                va = static_cast<ISchemaValidator**>(MallocState(sizeof(ISchemaValidator*) * count));
+                for (SizeType i = 0; i < count; i++)
+                    va[validatorCount++] = CreateSchemaValidator(*sa[i]);
+            }
+
+            CurrentContext().arrayUniqueness = valueUniqueness;
+        }
+        return true;
+    }
+
+    bool EndValue() {
+        if (!CurrentSchema().EndValue(CurrentContext()))
+            return false;
+
+#if RAPIDJSON_SCHEMA_VERBOSE
+        GenericStringBuffer<EncodingType> sb;
+        schemaDocument_->GetPointer(&CurrentSchema()).Stringify(sb);
+
+        *documentStack_.template Push<Ch>() = '\0';
+        documentStack_.template Pop<Ch>(1);
+        internal::PrintValidatorPointers(depth_, sb.GetString(), documentStack_.template Bottom<Ch>());
+#endif
+
+        uint64_t h = CurrentContext().arrayUniqueness ? static_cast<HasherType*>(CurrentContext().hasher)->GetHashCode() : 0;
+        
+        PopSchema();
+
+        if (!schemaStack_.Empty()) {
+            Context& context = CurrentContext();
+            if (context.valueUniqueness) {
+                HashCodeArray* a = static_cast<HashCodeArray*>(context.arrayElementHashCodes);
+                if (!a)
+                    CurrentContext().arrayElementHashCodes = a = new (GetStateAllocator().Malloc(sizeof(HashCodeArray))) HashCodeArray(kArrayType);
+                for (typename HashCodeArray::ConstValueIterator itr = a->Begin(); itr != a->End(); ++itr)
+                    if (itr->GetUint64() == h)
+                        RAPIDJSON_INVALID_KEYWORD_RETURN(SchemaType::GetUniqueItemsString());
+                a->PushBack(h, GetStateAllocator());
+            }
+        }
+
+        // Remove the last token of document pointer
+        while (!documentStack_.Empty() && *documentStack_.template Pop<Ch>(1) != '/')
+            ;
+
+        return true;
+    }
+
+    void AppendToken(const Ch* str, SizeType len) {
+        documentStack_.template Reserve<Ch>(1 + len * 2); // worst case all characters are escaped as two characters
+        *documentStack_.template PushUnsafe<Ch>() = '/';
+        for (SizeType i = 0; i < len; i++) {
+            if (str[i] == '~') {
+                *documentStack_.template PushUnsafe<Ch>() = '~';
+                *documentStack_.template PushUnsafe<Ch>() = '0';
+            }
+            else if (str[i] == '/') {
+                *documentStack_.template PushUnsafe<Ch>() = '~';
+                *documentStack_.template PushUnsafe<Ch>() = '1';
+            }
+            else
+                *documentStack_.template PushUnsafe<Ch>() = str[i];
+        }
+    }
+
+    RAPIDJSON_FORCEINLINE void PushSchema(const SchemaType& schema) { new (schemaStack_.template Push<Context>()) Context(*this, &schema); }
+    
+    RAPIDJSON_FORCEINLINE void PopSchema() {
+        Context* c = schemaStack_.template Pop<Context>(1);
+        if (HashCodeArray* a = static_cast<HashCodeArray*>(c->arrayElementHashCodes)) {
+            a->~HashCodeArray();
+            StateAllocator::Free(a);
+        }
+        c->~Context();
+    }
+
+    const SchemaType& CurrentSchema() const { return *schemaStack_.template Top<Context>()->schema; }
+    Context& CurrentContext() { return *schemaStack_.template Top<Context>(); }
+    const Context& CurrentContext() const { return *schemaStack_.template Top<Context>(); }
+
+    static OutputHandler& GetNullHandler() {
+        static OutputHandler nullHandler;
+        return nullHandler;
+    }
+
+    static const size_t kDefaultSchemaStackCapacity = 1024;
+    static const size_t kDefaultDocumentStackCapacity = 256;
+    const SchemaDocumentType* schemaDocument_;
+    const SchemaType& root_;
+    OutputHandler& outputHandler_;
+    StateAllocator* stateAllocator_;
+    StateAllocator* ownStateAllocator_;
+    internal::Stack<StateAllocator> schemaStack_;    //!< stack to store the current path of schema (BaseSchemaType *)
+    internal::Stack<StateAllocator> documentStack_;  //!< stack to store the current path of validating document (Ch)
+    bool valid_;
+#if RAPIDJSON_SCHEMA_VERBOSE
+    unsigned depth_;
+#endif
+};
+
+typedef GenericSchemaValidator<SchemaDocument> SchemaValidator;
+
+///////////////////////////////////////////////////////////////////////////////
+// SchemaValidatingReader
+
+//! A helper class for parsing with validation.
+/*!
+    This helper class is a functor, designed as a parameter of \ref GenericDocument::Populate().
+
+    \tparam parseFlags Combination of \ref ParseFlag.
+    \tparam InputStream Type of input stream, implementing Stream concept.
+    \tparam SourceEncoding Encoding of the input stream.
+    \tparam SchemaDocumentType Type of schema document.
+    \tparam StackAllocator Allocator type for stack.
+*/
+template <
+    unsigned parseFlags,
+    typename InputStream,
+    typename SourceEncoding,
+    typename SchemaDocumentType = SchemaDocument,
+    typename StackAllocator = CrtAllocator>
+class SchemaValidatingReader {
+public:
+    typedef typename SchemaDocumentType::PointerType PointerType;
+    typedef typename InputStream::Ch Ch;
+
+    //! Constructor
+    /*!
+        \param is Input stream.
+        \param sd Schema document.
+    */
+    SchemaValidatingReader(InputStream& is, const SchemaDocumentType& sd) : is_(is), sd_(sd), invalidSchemaKeyword_(), isValid_(true) {}
+
+    template <typename Handler>
+    bool operator()(Handler& handler) {
+        GenericReader<SourceEncoding, typename SchemaDocumentType::EncodingType, StackAllocator> reader;
+        GenericSchemaValidator<SchemaDocumentType, Handler> validator(sd_, handler);
+        parseResult_ = reader.template Parse<parseFlags>(is_, validator);
+
+        isValid_ = validator.IsValid();
+        if (isValid_) {
+            invalidSchemaPointer_ = PointerType();
+            invalidSchemaKeyword_ = 0;
+            invalidDocumentPointer_ = PointerType();
+        }
+        else {
+            invalidSchemaPointer_ = validator.GetInvalidSchemaPointer();
+            invalidSchemaKeyword_ = validator.GetInvalidSchemaKeyword();
+            invalidDocumentPointer_ = validator.GetInvalidDocumentPointer();
+        }
+
+        return parseResult_;
+    }
+
+    const ParseResult& GetParseResult() const { return parseResult_; }
+    bool IsValid() const { return isValid_; }
+    const PointerType& GetInvalidSchemaPointer() const { return invalidSchemaPointer_; }
+    const Ch* GetInvalidSchemaKeyword() const { return invalidSchemaKeyword_; }
+    const PointerType& GetInvalidDocumentPointer() const { return invalidDocumentPointer_; }
+
+private:
+    InputStream& is_;
+    const SchemaDocumentType& sd_;
+
+    ParseResult parseResult_;
+    PointerType invalidSchemaPointer_;
+    const Ch* invalidSchemaKeyword_;
+    PointerType invalidDocumentPointer_;
+    bool isValid_;
+};
+
+RAPIDJSON_NAMESPACE_END
+RAPIDJSON_DIAG_POP
+
+#endif // RAPIDJSON_SCHEMA_H_
diff --git a/engine/inc/rapidjson/stream.h b/engine/inc/rapidjson/stream.h
new file mode 100644
index 00000000..fef82c25
--- /dev/null
+++ b/engine/inc/rapidjson/stream.h
@@ -0,0 +1,179 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#include "rapidjson.h"
+
+#ifndef RAPIDJSON_STREAM_H_
+#define RAPIDJSON_STREAM_H_
+
+#include "encodings.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+//  Stream
+
+/*! \class rapidjson::Stream
+    \brief Concept for reading and writing characters.
+
+    For read-only stream, no need to implement PutBegin(), Put(), Flush() and PutEnd().
+
+    For write-only stream, only need to implement Put() and Flush().
+
+\code
+concept Stream {
+    typename Ch;    //!< Character type of the stream.
+
+    //! Read the current character from stream without moving the read cursor.
+    Ch Peek() const;
+
+    //! Read the current character from stream and moving the read cursor to next character.
+    Ch Take();
+
+    //! Get the current read cursor.
+    //! \return Number of characters read from start.
+    size_t Tell();
+
+    //! Begin writing operation at the current read pointer.
+    //! \return The begin writer pointer.
+    Ch* PutBegin();
+
+    //! Write a character.
+    void Put(Ch c);
+
+    //! Flush the buffer.
+    void Flush();
+
+    //! End the writing operation.
+    //! \param begin The begin write pointer returned by PutBegin().
+    //! \return Number of characters written.
+    size_t PutEnd(Ch* begin);
+}
+\endcode
+*/
+
+//! Provides additional information for stream.
+/*!
+    By using traits pattern, this type provides a default configuration for stream.
+    For custom stream, this type can be specialized for other configuration.
+    See TEST(Reader, CustomStringStream) in readertest.cpp for example.
+*/
+template<typename Stream>
+struct StreamTraits {
+    //! Whether to make local copy of stream for optimization during parsing.
+    /*!
+        By default, for safety, streams do not use local copy optimization.
+        Stream that can be copied fast should specialize this, like StreamTraits<StringStream>.
+    */
+    enum { copyOptimization = 0 };
+};
+
+//! Reserve n characters for writing to a stream.
+template<typename Stream>
+inline void PutReserve(Stream& stream, size_t count) {
+    (void)stream;
+    (void)count;
+}
+
+//! Write character to a stream, presuming buffer is reserved.
+template<typename Stream>
+inline void PutUnsafe(Stream& stream, typename Stream::Ch c) {
+    stream.Put(c);
+}
+
+//! Put N copies of a character to a stream.
+template<typename Stream, typename Ch>
+inline void PutN(Stream& stream, Ch c, size_t n) {
+    PutReserve(stream, n);
+    for (size_t i = 0; i < n; i++)
+        PutUnsafe(stream, c);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// StringStream
+
+//! Read-only string stream.
+/*! \note implements Stream concept
+*/
+template <typename Encoding>
+struct GenericStringStream {
+    typedef typename Encoding::Ch Ch;
+
+    GenericStringStream(const Ch *src) : src_(src), head_(src) {}
+
+    Ch Peek() const { return *src_; }
+    Ch Take() { return *src_++; }
+    size_t Tell() const { return static_cast<size_t>(src_ - head_); }
+
+    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
+    void Put(Ch) { RAPIDJSON_ASSERT(false); }
+    void Flush() { RAPIDJSON_ASSERT(false); }
+    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
+
+    const Ch* src_;     //!< Current read position.
+    const Ch* head_;    //!< Original head of the string.
+};
+
+template <typename Encoding>
+struct StreamTraits<GenericStringStream<Encoding> > {
+    enum { copyOptimization = 1 };
+};
+
+//! String stream with UTF8 encoding.
+typedef GenericStringStream<UTF8<> > StringStream;
+
+///////////////////////////////////////////////////////////////////////////////
+// InsituStringStream
+
+//! A read-write string stream.
+/*! This string stream is particularly designed for in-situ parsing.
+    \note implements Stream concept
+*/
+template <typename Encoding>
+struct GenericInsituStringStream {
+    typedef typename Encoding::Ch Ch;
+
+    GenericInsituStringStream(Ch *src) : src_(src), dst_(0), head_(src) {}
+
+    // Read
+    Ch Peek() { return *src_; }
+    Ch Take() { return *src_++; }
+    size_t Tell() { return static_cast<size_t>(src_ - head_); }
+
+    // Write
+    void Put(Ch c) { RAPIDJSON_ASSERT(dst_ != 0); *dst_++ = c; }
+
+    Ch* PutBegin() { return dst_ = src_; }
+    size_t PutEnd(Ch* begin) { return static_cast<size_t>(dst_ - begin); }
+    void Flush() {}
+
+    Ch* Push(size_t count) { Ch* begin = dst_; dst_ += count; return begin; }
+    void Pop(size_t count) { dst_ -= count; }
+
+    Ch* src_;
+    Ch* dst_;
+    Ch* head_;
+};
+
+template <typename Encoding>
+struct StreamTraits<GenericInsituStringStream<Encoding> > {
+    enum { copyOptimization = 1 };
+};
+
+//! Insitu string stream with UTF8 encoding.
+typedef GenericInsituStringStream<UTF8<> > InsituStringStream;
+
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_STREAM_H_
diff --git a/engine/inc/rapidjson/stringbuffer.h b/engine/inc/rapidjson/stringbuffer.h
new file mode 100644
index 00000000..78f34d20
--- /dev/null
+++ b/engine/inc/rapidjson/stringbuffer.h
@@ -0,0 +1,117 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_STRINGBUFFER_H_
+#define RAPIDJSON_STRINGBUFFER_H_
+
+#include "stream.h"
+#include "internal/stack.h"
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+#include <utility> // std::move
+#endif
+
+#include "internal/stack.h"
+
+#if defined(__clang__)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(c++98-compat)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Represents an in-memory output stream.
+/*!
+    \tparam Encoding Encoding of the stream.
+    \tparam Allocator type for allocating memory buffer.
+    \note implements Stream concept
+*/
+template <typename Encoding, typename Allocator = CrtAllocator>
+class GenericStringBuffer {
+public:
+    typedef typename Encoding::Ch Ch;
+
+    GenericStringBuffer(Allocator* allocator = 0, size_t capacity = kDefaultCapacity) : stack_(allocator, capacity) {}
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+    GenericStringBuffer(GenericStringBuffer&& rhs) : stack_(std::move(rhs.stack_)) {}
+    GenericStringBuffer& operator=(GenericStringBuffer&& rhs) {
+        if (&rhs != this)
+            stack_ = std::move(rhs.stack_);
+        return *this;
+    }
+#endif
+
+    void Put(Ch c) { *stack_.template Push<Ch>() = c; }
+    void PutUnsafe(Ch c) { *stack_.template PushUnsafe<Ch>() = c; }
+    void Flush() {}
+
+    void Clear() { stack_.Clear(); }
+    void ShrinkToFit() {
+        // Push and pop a null terminator. This is safe.
+        *stack_.template Push<Ch>() = '\0';
+        stack_.ShrinkToFit();
+        stack_.template Pop<Ch>(1);
+    }
+
+    void Reserve(size_t count) { stack_.template Reserve<Ch>(count); }
+    Ch* Push(size_t count) { return stack_.template Push<Ch>(count); }
+    Ch* PushUnsafe(size_t count) { return stack_.template PushUnsafe<Ch>(count); }
+    void Pop(size_t count) { stack_.template Pop<Ch>(count); }
+
+    const Ch* GetString() const {
+        // Push and pop a null terminator. This is safe.
+        *stack_.template Push<Ch>() = '\0';
+        stack_.template Pop<Ch>(1);
+
+        return stack_.template Bottom<Ch>();
+    }
+
+    size_t GetSize() const { return stack_.GetSize(); }
+
+    static const size_t kDefaultCapacity = 256;
+    mutable internal::Stack<Allocator> stack_;
+
+private:
+    // Prohibit copy constructor & assignment operator.
+    GenericStringBuffer(const GenericStringBuffer&);
+    GenericStringBuffer& operator=(const GenericStringBuffer&);
+};
+
+//! String buffer with UTF8 encoding
+typedef GenericStringBuffer<UTF8<> > StringBuffer;
+
+template<typename Encoding, typename Allocator>
+inline void PutReserve(GenericStringBuffer<Encoding, Allocator>& stream, size_t count) {
+    stream.Reserve(count);
+}
+
+template<typename Encoding, typename Allocator>
+inline void PutUnsafe(GenericStringBuffer<Encoding, Allocator>& stream, typename Encoding::Ch c) {
+    stream.PutUnsafe(c);
+}
+
+//! Implement specialized version of PutN() with memset() for better performance.
+template<>
+inline void PutN(GenericStringBuffer<UTF8<> >& stream, char c, size_t n) {
+    std::memset(stream.stack_.Push<char>(n), c, n * sizeof(c));
+}
+
+RAPIDJSON_NAMESPACE_END
+
+#if defined(__clang__)
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_STRINGBUFFER_H_
diff --git a/engine/inc/rapidjson/writer.h b/engine/inc/rapidjson/writer.h
new file mode 100644
index 00000000..94f22dd5
--- /dev/null
+++ b/engine/inc/rapidjson/writer.h
@@ -0,0 +1,610 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_WRITER_H_
+#define RAPIDJSON_WRITER_H_
+
+#include "stream.h"
+#include "internal/stack.h"
+#include "internal/strfunc.h"
+#include "internal/dtoa.h"
+#include "internal/itoa.h"
+#include "stringbuffer.h"
+#include <new>      // placement new
+
+#if defined(RAPIDJSON_SIMD) && defined(_MSC_VER)
+#include <intrin.h>
+#pragma intrinsic(_BitScanForward)
+#endif
+#ifdef RAPIDJSON_SSE42
+#include <nmmintrin.h>
+#elif defined(RAPIDJSON_SSE2)
+#include <emmintrin.h>
+#endif
+
+#ifdef _MSC_VER
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
+#endif
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(padded)
+RAPIDJSON_DIAG_OFF(unreachable-code)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+// WriteFlag
+
+/*! \def RAPIDJSON_WRITE_DEFAULT_FLAGS 
+    \ingroup RAPIDJSON_CONFIG
+    \brief User-defined kWriteDefaultFlags definition.
+
+    User can define this as any \c WriteFlag combinations.
+*/
+#ifndef RAPIDJSON_WRITE_DEFAULT_FLAGS
+#define RAPIDJSON_WRITE_DEFAULT_FLAGS kWriteNoFlags
+#endif
+
+//! Combination of writeFlags
+enum WriteFlag {
+    kWriteNoFlags = 0,              //!< No flags are set.
+    kWriteValidateEncodingFlag = 1, //!< Validate encoding of JSON strings.
+    kWriteNanAndInfFlag = 2,        //!< Allow writing of Infinity, -Infinity and NaN.
+    kWriteDefaultFlags = RAPIDJSON_WRITE_DEFAULT_FLAGS  //!< Default write flags. Can be customized by defining RAPIDJSON_WRITE_DEFAULT_FLAGS
+};
+
+//! JSON writer
+/*! Writer implements the concept Handler.
+    It generates JSON text by events to an output os.
+
+    User may programmatically calls the functions of a writer to generate JSON text.
+
+    On the other side, a writer can also be passed to objects that generates events, 
+
+    for example Reader::Parse() and Document::Accept().
+
+    \tparam OutputStream Type of output stream.
+    \tparam SourceEncoding Encoding of source string.
+    \tparam TargetEncoding Encoding of output stream.
+    \tparam StackAllocator Type of allocator for allocating memory of stack.
+    \note implements Handler concept
+*/
+template<typename OutputStream, typename SourceEncoding = UTF8<>, typename TargetEncoding = UTF8<>, typename StackAllocator = CrtAllocator, unsigned writeFlags = kWriteDefaultFlags>
+class Writer {
+public:
+    typedef typename SourceEncoding::Ch Ch;
+
+    static const int kDefaultMaxDecimalPlaces = 324;
+
+    //! Constructor
+    /*! \param os Output stream.
+        \param stackAllocator User supplied allocator. If it is null, it will create a private one.
+        \param levelDepth Initial capacity of stack.
+    */
+    explicit
+    Writer(OutputStream& os, StackAllocator* stackAllocator = 0, size_t levelDepth = kDefaultLevelDepth) : 
+        os_(&os), level_stack_(stackAllocator, levelDepth * sizeof(Level)), maxDecimalPlaces_(kDefaultMaxDecimalPlaces), hasRoot_(false) {}
+
+    explicit
+    Writer(StackAllocator* allocator = 0, size_t levelDepth = kDefaultLevelDepth) :
+        os_(0), level_stack_(allocator, levelDepth * sizeof(Level)), maxDecimalPlaces_(kDefaultMaxDecimalPlaces), hasRoot_(false) {}
+
+    //! Reset the writer with a new stream.
+    /*!
+        This function reset the writer with a new stream and default settings,
+        in order to make a Writer object reusable for output multiple JSONs.
+
+        \param os New output stream.
+        \code
+        Writer<OutputStream> writer(os1);
+        writer.StartObject();
+        // ...
+        writer.EndObject();
+
+        writer.Reset(os2);
+        writer.StartObject();
+        // ...
+        writer.EndObject();
+        \endcode
+    */
+    void Reset(OutputStream& os) {
+        os_ = &os;
+        hasRoot_ = false;
+        level_stack_.Clear();
+    }
+
+    //! Checks whether the output is a complete JSON.
+    /*!
+        A complete JSON has a complete root object or array.
+    */
+    bool IsComplete() const {
+        return hasRoot_ && level_stack_.Empty();
+    }
+
+    int GetMaxDecimalPlaces() const {
+        return maxDecimalPlaces_;
+    }
+
+    //! Sets the maximum number of decimal places for double output.
+    /*!
+        This setting truncates the output with specified number of decimal places.
+
+        For example, 
+
+        \code
+        writer.SetMaxDecimalPlaces(3);
+        writer.StartArray();
+        writer.Double(0.12345);                 // "0.123"
+        writer.Double(0.0001);                  // "0.0"
+        writer.Double(1.234567890123456e30);    // "1.234567890123456e30" (do not truncate significand for positive exponent)
+        writer.Double(1.23e-4);                 // "0.0"                  (do truncate significand for negative exponent)
+        writer.EndArray();
+        \endcode
+
+        The default setting does not truncate any decimal places. You can restore to this setting by calling
+        \code
+        writer.SetMaxDecimalPlaces(Writer::kDefaultMaxDecimalPlaces);
+        \endcode
+    */
+    void SetMaxDecimalPlaces(int maxDecimalPlaces) {
+        maxDecimalPlaces_ = maxDecimalPlaces;
+    }
+
+    /*!@name Implementation of Handler
+        \see Handler
+    */
+    //@{
+
+    bool Null()                 { Prefix(kNullType);   return EndValue(WriteNull()); }
+    bool Bool(bool b)           { Prefix(b ? kTrueType : kFalseType); return EndValue(WriteBool(b)); }
+    bool Int(int i)             { Prefix(kNumberType); return EndValue(WriteInt(i)); }
+    bool Uint(unsigned u)       { Prefix(kNumberType); return EndValue(WriteUint(u)); }
+    bool Int64(int64_t i64)     { Prefix(kNumberType); return EndValue(WriteInt64(i64)); }
+    bool Uint64(uint64_t u64)   { Prefix(kNumberType); return EndValue(WriteUint64(u64)); }
+
+    //! Writes the given \c double value to the stream
+    /*!
+        \param d The value to be written.
+        \return Whether it is succeed.
+    */
+    bool Double(double d)       { Prefix(kNumberType); return EndValue(WriteDouble(d)); }
+
+    bool RawNumber(const Ch* str, SizeType length, bool copy = false) {
+        (void)copy;
+        Prefix(kNumberType);
+        return EndValue(WriteString(str, length));
+    }
+
+    bool String(const Ch* str, SizeType length, bool copy = false) {
+        (void)copy;
+        Prefix(kStringType);
+        return EndValue(WriteString(str, length));
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    bool String(const std::basic_string<Ch>& str) {
+        return String(str.data(), SizeType(str.size()));
+    }
+#endif
+
+    bool StartObject() {
+        Prefix(kObjectType);
+        new (level_stack_.template Push<Level>()) Level(false);
+        return WriteStartObject();
+    }
+
+    bool Key(const Ch* str, SizeType length, bool copy = false) { return String(str, length, copy); }
+
+    bool EndObject(SizeType memberCount = 0) {
+        (void)memberCount;
+        RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level));
+        RAPIDJSON_ASSERT(!level_stack_.template Top<Level>()->inArray);
+        level_stack_.template Pop<Level>(1);
+        return EndValue(WriteEndObject());
+    }
+
+    bool StartArray() {
+        Prefix(kArrayType);
+        new (level_stack_.template Push<Level>()) Level(true);
+        return WriteStartArray();
+    }
+
+    bool EndArray(SizeType elementCount = 0) {
+        (void)elementCount;
+        RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level));
+        RAPIDJSON_ASSERT(level_stack_.template Top<Level>()->inArray);
+        level_stack_.template Pop<Level>(1);
+        return EndValue(WriteEndArray());
+    }
+    //@}
+
+    /*! @name Convenience extensions */
+    //@{
+
+    //! Simpler but slower overload.
+    bool String(const Ch* str) { return String(str, internal::StrLen(str)); }
+    bool Key(const Ch* str) { return Key(str, internal::StrLen(str)); }
+
+    //@}
+
+    //! Write a raw JSON value.
+    /*!
+        For user to write a stringified JSON as a value.
+
+        \param json A well-formed JSON value. It should not contain null character within [0, length - 1] range.
+        \param length Length of the json.
+        \param type Type of the root of json.
+    */
+    bool RawValue(const Ch* json, size_t length, Type type) { Prefix(type); return EndValue(WriteRawValue(json, length)); }
+
+protected:
+    //! Information for each nested level
+    struct Level {
+        Level(bool inArray_) : valueCount(0), inArray(inArray_) {}
+        size_t valueCount;  //!< number of values in this level
+        bool inArray;       //!< true if in array, otherwise in object
+    };
+
+    static const size_t kDefaultLevelDepth = 32;
+
+    bool WriteNull()  {
+        PutReserve(*os_, 4);
+        PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'u'); PutUnsafe(*os_, 'l'); PutUnsafe(*os_, 'l'); return true;
+    }
+
+    bool WriteBool(bool b)  {
+        if (b) {
+            PutReserve(*os_, 4);
+            PutUnsafe(*os_, 't'); PutUnsafe(*os_, 'r'); PutUnsafe(*os_, 'u'); PutUnsafe(*os_, 'e');
+        }
+        else {
+            PutReserve(*os_, 5);
+            PutUnsafe(*os_, 'f'); PutUnsafe(*os_, 'a'); PutUnsafe(*os_, 'l'); PutUnsafe(*os_, 's'); PutUnsafe(*os_, 'e');
+        }
+        return true;
+    }
+
+    bool WriteInt(int i) {
+        char buffer[11];
+        const char* end = internal::i32toa(i, buffer);
+        PutReserve(*os_, static_cast<size_t>(end - buffer));
+        for (const char* p = buffer; p != end; ++p)
+            PutUnsafe(*os_, static_cast<typename TargetEncoding::Ch>(*p));
+        return true;
+    }
+
+    bool WriteUint(unsigned u) {
+        char buffer[10];
+        const char* end = internal::u32toa(u, buffer);
+        PutReserve(*os_, static_cast<size_t>(end - buffer));
+        for (const char* p = buffer; p != end; ++p)
+            PutUnsafe(*os_, static_cast<typename TargetEncoding::Ch>(*p));
+        return true;
+    }
+
+    bool WriteInt64(int64_t i64) {
+        char buffer[21];
+        const char* end = internal::i64toa(i64, buffer);
+        PutReserve(*os_, static_cast<size_t>(end - buffer));
+        for (const char* p = buffer; p != end; ++p)
+            PutUnsafe(*os_, static_cast<typename TargetEncoding::Ch>(*p));
+        return true;
+    }
+
+    bool WriteUint64(uint64_t u64) {
+        char buffer[20];
+        char* end = internal::u64toa(u64, buffer);
+        PutReserve(*os_, static_cast<size_t>(end - buffer));
+        for (char* p = buffer; p != end; ++p)
+            PutUnsafe(*os_, static_cast<typename TargetEncoding::Ch>(*p));
+        return true;
+    }
+
+    bool WriteDouble(double d) {
+        if (internal::Double(d).IsNanOrInf()) {
+            if (!(writeFlags & kWriteNanAndInfFlag))
+                return false;
+            if (internal::Double(d).IsNan()) {
+                PutReserve(*os_, 3);
+                PutUnsafe(*os_, 'N'); PutUnsafe(*os_, 'a'); PutUnsafe(*os_, 'N');
+                return true;
+            }
+            if (internal::Double(d).Sign()) {
+                PutReserve(*os_, 9);
+                PutUnsafe(*os_, '-');
+            }
+            else
+                PutReserve(*os_, 8);
+            PutUnsafe(*os_, 'I'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'f');
+            PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 't'); PutUnsafe(*os_, 'y');
+            return true;
+        }
+
+        char buffer[25];
+        char* end = internal::dtoa(d, buffer, maxDecimalPlaces_);
+        PutReserve(*os_, static_cast<size_t>(end - buffer));
+        for (char* p = buffer; p != end; ++p)
+            PutUnsafe(*os_, static_cast<typename TargetEncoding::Ch>(*p));
+        return true;
+    }
+
+    bool WriteString(const Ch* str, SizeType length)  {
+        static const typename TargetEncoding::Ch hexDigits[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
+        static const char escape[256] = {
+#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+            //0    1    2    3    4    5    6    7    8    9    A    B    C    D    E    F
+            'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'b', 't', 'n', 'u', 'f', 'r', 'u', 'u', // 00
+            'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', // 10
+              0,   0, '"',   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, // 20
+            Z16, Z16,                                                                       // 30~4F
+              0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,'\\',   0,   0,   0, // 50
+            Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16                                // 60~FF
+#undef Z16
+        };
+
+        if (TargetEncoding::supportUnicode)
+            PutReserve(*os_, 2 + length * 6); // "\uxxxx..."
+        else
+            PutReserve(*os_, 2 + length * 12);  // "\uxxxx\uyyyy..."
+
+        PutUnsafe(*os_, '\"');
+        GenericStringStream<SourceEncoding> is(str);
+        while (ScanWriteUnescapedString(is, length)) {
+            const Ch c = is.Peek();
+            if (!TargetEncoding::supportUnicode && static_cast<unsigned>(c) >= 0x80) {
+                // Unicode escaping
+                unsigned codepoint;
+                if (RAPIDJSON_UNLIKELY(!SourceEncoding::Decode(is, &codepoint)))
+                    return false;
+                PutUnsafe(*os_, '\\');
+                PutUnsafe(*os_, 'u');
+                if (codepoint <= 0xD7FF || (codepoint >= 0xE000 && codepoint <= 0xFFFF)) {
+                    PutUnsafe(*os_, hexDigits[(codepoint >> 12) & 15]);
+                    PutUnsafe(*os_, hexDigits[(codepoint >>  8) & 15]);
+                    PutUnsafe(*os_, hexDigits[(codepoint >>  4) & 15]);
+                    PutUnsafe(*os_, hexDigits[(codepoint      ) & 15]);
+                }
+                else {
+                    RAPIDJSON_ASSERT(codepoint >= 0x010000 && codepoint <= 0x10FFFF);
+                    // Surrogate pair
+                    unsigned s = codepoint - 0x010000;
+                    unsigned lead = (s >> 10) + 0xD800;
+                    unsigned trail = (s & 0x3FF) + 0xDC00;
+                    PutUnsafe(*os_, hexDigits[(lead >> 12) & 15]);
+                    PutUnsafe(*os_, hexDigits[(lead >>  8) & 15]);
+                    PutUnsafe(*os_, hexDigits[(lead >>  4) & 15]);
+                    PutUnsafe(*os_, hexDigits[(lead      ) & 15]);
+                    PutUnsafe(*os_, '\\');
+                    PutUnsafe(*os_, 'u');
+                    PutUnsafe(*os_, hexDigits[(trail >> 12) & 15]);
+                    PutUnsafe(*os_, hexDigits[(trail >>  8) & 15]);
+                    PutUnsafe(*os_, hexDigits[(trail >>  4) & 15]);
+                    PutUnsafe(*os_, hexDigits[(trail      ) & 15]);                    
+                }
+            }
+            else if ((sizeof(Ch) == 1 || static_cast<unsigned>(c) < 256) && RAPIDJSON_UNLIKELY(escape[static_cast<unsigned char>(c)]))  {
+                is.Take();
+                PutUnsafe(*os_, '\\');
+                PutUnsafe(*os_, static_cast<typename TargetEncoding::Ch>(escape[static_cast<unsigned char>(c)]));
+                if (escape[static_cast<unsigned char>(c)] == 'u') {
+                    PutUnsafe(*os_, '0');
+                    PutUnsafe(*os_, '0');
+                    PutUnsafe(*os_, hexDigits[static_cast<unsigned char>(c) >> 4]);
+                    PutUnsafe(*os_, hexDigits[static_cast<unsigned char>(c) & 0xF]);
+                }
+            }
+            else if (RAPIDJSON_UNLIKELY(!(writeFlags & kWriteValidateEncodingFlag ? 
+                Transcoder<SourceEncoding, TargetEncoding>::Validate(is, *os_) :
+                Transcoder<SourceEncoding, TargetEncoding>::TranscodeUnsafe(is, *os_))))
+                return false;
+        }
+        PutUnsafe(*os_, '\"');
+        return true;
+    }
+
+    bool ScanWriteUnescapedString(GenericStringStream<SourceEncoding>& is, size_t length) {
+        return RAPIDJSON_LIKELY(is.Tell() < length);
+    }
+
+    bool WriteStartObject() { os_->Put('{'); return true; }
+    bool WriteEndObject()   { os_->Put('}'); return true; }
+    bool WriteStartArray()  { os_->Put('['); return true; }
+    bool WriteEndArray()    { os_->Put(']'); return true; }
+
+    bool WriteRawValue(const Ch* json, size_t length) {
+        PutReserve(*os_, length);
+        for (size_t i = 0; i < length; i++) {
+            RAPIDJSON_ASSERT(json[i] != '\0');
+            PutUnsafe(*os_, json[i]);
+        }
+        return true;
+    }
+
+    void Prefix(Type type) {
+        (void)type;
+        if (RAPIDJSON_LIKELY(level_stack_.GetSize() != 0)) { // this value is not at root
+            Level* level = level_stack_.template Top<Level>();
+            if (level->valueCount > 0) {
+                if (level->inArray) 
+                    os_->Put(','); // add comma if it is not the first element in array
+                else  // in object
+                    os_->Put((level->valueCount % 2 == 0) ? ',' : ':');
+            }
+            if (!level->inArray && level->valueCount % 2 == 0)
+                RAPIDJSON_ASSERT(type == kStringType);  // if it's in object, then even number should be a name
+            level->valueCount++;
+        }
+        else {
+            RAPIDJSON_ASSERT(!hasRoot_);    // Should only has one and only one root.
+            hasRoot_ = true;
+        }
+    }
+
+    // Flush the value if it is the top level one.
+    bool EndValue(bool ret) {
+        if (RAPIDJSON_UNLIKELY(level_stack_.Empty()))   // end of json text
+            os_->Flush();
+        return ret;
+    }
+
+    OutputStream* os_;
+    internal::Stack<StackAllocator> level_stack_;
+    int maxDecimalPlaces_;
+    bool hasRoot_;
+
+private:
+    // Prohibit copy constructor & assignment operator.
+    Writer(const Writer&);
+    Writer& operator=(const Writer&);
+};
+
+// Full specialization for StringStream to prevent memory copying
+
+template<>
+inline bool Writer<StringBuffer>::WriteInt(int i) {
+    char *buffer = os_->Push(11);
+    const char* end = internal::i32toa(i, buffer);
+    os_->Pop(static_cast<size_t>(11 - (end - buffer)));
+    return true;
+}
+
+template<>
+inline bool Writer<StringBuffer>::WriteUint(unsigned u) {
+    char *buffer = os_->Push(10);
+    const char* end = internal::u32toa(u, buffer);
+    os_->Pop(static_cast<size_t>(10 - (end - buffer)));
+    return true;
+}
+
+template<>
+inline bool Writer<StringBuffer>::WriteInt64(int64_t i64) {
+    char *buffer = os_->Push(21);
+    const char* end = internal::i64toa(i64, buffer);
+    os_->Pop(static_cast<size_t>(21 - (end - buffer)));
+    return true;
+}
+
+template<>
+inline bool Writer<StringBuffer>::WriteUint64(uint64_t u) {
+    char *buffer = os_->Push(20);
+    const char* end = internal::u64toa(u, buffer);
+    os_->Pop(static_cast<size_t>(20 - (end - buffer)));
+    return true;
+}
+
+template<>
+inline bool Writer<StringBuffer>::WriteDouble(double d) {
+    if (internal::Double(d).IsNanOrInf()) {
+        // Note: This code path can only be reached if (RAPIDJSON_WRITE_DEFAULT_FLAGS & kWriteNanAndInfFlag).
+        if (!(kWriteDefaultFlags & kWriteNanAndInfFlag))
+            return false;
+        if (internal::Double(d).IsNan()) {
+            PutReserve(*os_, 3);
+            PutUnsafe(*os_, 'N'); PutUnsafe(*os_, 'a'); PutUnsafe(*os_, 'N');
+            return true;
+        }
+        if (internal::Double(d).Sign()) {
+            PutReserve(*os_, 9);
+            PutUnsafe(*os_, '-');
+        }
+        else
+            PutReserve(*os_, 8);
+        PutUnsafe(*os_, 'I'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'f');
+        PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 't'); PutUnsafe(*os_, 'y');
+        return true;
+    }
+    
+    char *buffer = os_->Push(25);
+    char* end = internal::dtoa(d, buffer, maxDecimalPlaces_);
+    os_->Pop(static_cast<size_t>(25 - (end - buffer)));
+    return true;
+}
+
+#if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42)
+template<>
+inline bool Writer<StringBuffer>::ScanWriteUnescapedString(StringStream& is, size_t length) {
+    if (length < 16)
+        return RAPIDJSON_LIKELY(is.Tell() < length);
+
+    if (!RAPIDJSON_LIKELY(is.Tell() < length))
+        return false;
+
+    const char* p = is.src_;
+    const char* end = is.head_ + length;
+    const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
+    const char* endAligned = reinterpret_cast<const char*>(reinterpret_cast<size_t>(end) & static_cast<size_t>(~15));
+    if (nextAligned > end)
+        return true;
+
+    while (p != nextAligned)
+        if (*p < 0x20 || *p == '\"' || *p == '\\') {
+            is.src_ = p;
+            return RAPIDJSON_LIKELY(is.Tell() < length);
+        }
+        else
+            os_->PutUnsafe(*p++);
+
+    // The rest of string using SIMD
+    static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' };
+    static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' };
+    static const char space[16]  = { 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19 };
+    const __m128i dq = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&dquote[0]));
+    const __m128i bs = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&bslash[0]));
+    const __m128i sp = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&space[0]));
+
+    for (; p != endAligned; p += 16) {
+        const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
+        const __m128i t1 = _mm_cmpeq_epi8(s, dq);
+        const __m128i t2 = _mm_cmpeq_epi8(s, bs);
+        const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x19) == 0x19
+        const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
+        unsigned short r = static_cast<unsigned short>(_mm_movemask_epi8(x));
+        if (RAPIDJSON_UNLIKELY(r != 0)) {   // some of characters is escaped
+            SizeType len;
+#ifdef _MSC_VER         // Find the index of first escaped
+            unsigned long offset;
+            _BitScanForward(&offset, r);
+            len = offset;
+#else
+            len = static_cast<SizeType>(__builtin_ffs(r) - 1);
+#endif
+            char* q = reinterpret_cast<char*>(os_->PushUnsafe(len));
+            for (size_t i = 0; i < len; i++)
+                q[i] = p[i];
+
+            p += len;
+            break;
+        }
+        _mm_storeu_si128(reinterpret_cast<__m128i *>(os_->PushUnsafe(16)), s);
+    }
+
+    is.src_ = p;
+    return RAPIDJSON_LIKELY(is.Tell() < length);
+}
+#endif // defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42)
+
+RAPIDJSON_NAMESPACE_END
+
+#ifdef _MSC_VER
+RAPIDJSON_DIAG_POP
+#endif
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_RAPIDJSON_H_
diff --git a/engine/inc/sol/config.hpp b/engine/inc/sol/config.hpp
new file mode 100644
index 00000000..90ec711b
--- /dev/null
+++ b/engine/inc/sol/config.hpp
@@ -0,0 +1,53 @@
+// The MIT License (MIT)
+
+// Copyright (c) 2013-2020 Rapptz, ThePhD and contributors
+
+// 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.
+
+// This file was generated with a script.
+// Generated 2020-10-03 21:34:25.034794 UTC
+// This header was generated with sol v3.2.1 (revision 48eea7b5)
+// https://github.com/ThePhD/sol2
+
+#ifndef SOL_SINGLE_CONFIG_HPP
+#define SOL_SINGLE_CONFIG_HPP
+
+// beginning of sol/config.hpp
+
+/* Base, empty configuration file!
+
+     To override, place a file in your include paths of the form:
+
+. (your include path here)
+| sol (directory, or equivalent)
+  | config.hpp (your config.hpp file)
+
+     So that when sol2 includes the file
+
+#include <sol/config.hpp>
+
+     it gives you the configuration values you desire. Configuration values can be
+seen in the safety.rst of the doc/src, or at
+https://sol2.readthedocs.io/en/latest/safety.html ! You can also pass them through
+the build system, or the command line options of your compiler.
+
+*/
+
+// end of sol/config.hpp
+
+#endif // SOL_SINGLE_CONFIG_HPP
diff --git a/engine/inc/sol/forward.hpp b/engine/inc/sol/forward.hpp
new file mode 100644
index 00000000..51fae7dd
--- /dev/null
+++ b/engine/inc/sol/forward.hpp
@@ -0,0 +1,828 @@
+// The MIT License (MIT)
+
+// Copyright (c) 2013-2020 Rapptz, ThePhD and contributors
+
+// 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.
+
+// This file was generated with a script.
+// Generated 2020-10-03 21:34:25.022965 UTC
+// This header was generated with sol v3.2.1 (revision 48eea7b5)
+// https://github.com/ThePhD/sol2
+
+#ifndef SOL_SINGLE_INCLUDE_FORWARD_HPP
+#define SOL_SINGLE_INCLUDE_FORWARD_HPP
+
+// beginning of sol/forward.hpp
+
+#ifndef SOL_FORWARD_HPP
+#define SOL_FORWARD_HPP
+
+// beginning of sol/version.hpp
+
+#include <sol/config.hpp>
+
+#include <cstdint>
+
+#define SOL_VERSION_MAJOR 3
+#define SOL_VERSION_MINOR 5
+#define SOL_VERSION_PATCH 0
+#define SOL_VERSION_STRING "3.5.0"
+#define SOL_VERSION ((SOL_VERSION_MAJOR * 100000) + (SOL_VERSION_MINOR * 100) + (SOL_VERSION_PATCH))
+
+#define SOL_IS_ON(OP_SYMBOL) ((3 OP_SYMBOL 3) != 0)
+#define SOL_IS_OFF(OP_SYMBOL) ((3 OP_SYMBOL 3) == 0)
+#define SOL_IS_DEFAULT_ON(OP_SYMBOL) ((3 OP_SYMBOL 3) > 3)
+#define SOL_IS_DEFAULT_OFF(OP_SYMBOL) ((3 OP_SYMBOL 3 OP_SYMBOL 3) < 0)
+
+#define SOL_ON          |
+#define SOL_OFF         ^
+#define SOL_DEFAULT_ON  +
+#define SOL_DEFAULT_OFF -
+
+#if defined(_MSC_VER)
+	#define SOL_COMPILER_CLANG_I_ SOL_OFF
+	#define SOL_COMPILER_GCC_I_   SOL_OFF
+	#define SOL_COMPILER_EDG_I_   SOL_OFF
+	#define SOL_COMPILER_VCXX_I_  SOL_ON
+#elif defined(__clang__)
+	#define SOL_COMPILER_CLANG_I_ SOL_ON
+	#define SOL_COMPILER_GCC_I_   SOL_OFF
+	#define SOL_COMPILER_EDG_I_   SOL_OFF
+	#define SOL_COMPILER_VCXX_I_  SOL_OFF
+#elif defined(__GNUC__)
+	#define SOL_COMPILER_CLANG_I_ SOL_OFF
+	#define SOL_COMPILER_GCC_I_   SOL_ON
+	#define SOL_COMPILER_EDG_I_   SOL_OFF
+	#define SOL_COMPILER_VCXX_I_  SOL_OFF
+#else
+	#define SOL_COMPILER_CLANG_I_ SOL_OFF
+	#define SOL_COMPILER_GCC_I_   SOL_OFF
+	#define SOL_COMPILER_EDG_I_   SOL_OFF
+	#define SOL_COMPILER_VCXX_I_  SOL_OFF
+#endif
+
+#if defined(__MINGW32__)
+	#define SOL_COMPILER_FRONTEND_MINGW_I_ SOL_ON
+#else
+	#define SOL_COMPILER_FRONTEND_MINGW_I_ SOL_OFF
+#endif
+
+#if SIZE_MAX <= 0xFFFFULL
+	#define SOL_PLATFORM_X16_I_ SOL_ON
+	#define SOL_PLATFORM_X86_I_ SOL_OFF
+	#define SOL_PLATFORM_X64_I_ SOL_OFF
+#elif SIZE_MAX <= 0xFFFFFFFFULL
+	#define SOL_PLATFORM_X16_I_ SOL_OFF
+	#define SOL_PLATFORM_X86_I_ SOL_ON
+	#define SOL_PLATFORM_X64_I_ SOL_OFF
+#else
+	#define SOL_PLATFORM_X16_I_ SOL_OFF
+	#define SOL_PLATFORM_X86_I_ SOL_OFF
+	#define SOL_PLATFORM_X64_I_ SOL_ON
+#endif
+
+#define SOL_PLATFORM_ARM32_I_ SOL_OFF
+#define SOL_PLATFORM_ARM64_I_ SOL_OFF
+
+#if defined(_WIN32)
+	#define SOL_PLATFORM_WINDOWS_I_ SOL_ON
+#else
+	#define SOL_PLATFORM_WINDOWS_I_ SOL_OFF
+#endif
+#if defined(__APPLE__)
+	#define SOL_PLATFORM_APPLE_I_ SOL_ON
+#else
+	#define SOL_PLATFORM_APPLE_I_ SOL_OFF
+#endif
+#if defined(__unix__)
+	#define SOL_PLATFORM_UNIXLIKE_I_ SOL_ON
+#else
+	#define SOL_PLATFORM_UNIXLIKE_I_ SOL_OFF
+#endif
+#if defined(__linux__)
+	#define SOL_PLATFORM_LINUXLIKE_I_ SOL_ON
+#else
+	#define SOL_PLATFORM_LINUXLIKE_I_ SOL_OFF
+#endif
+
+#define SOL_PLATFORM_APPLE_IPHONE_I_ SOL_OFF
+#define SOL_PLATFORM_BSDLIKE_I_      SOL_OFF
+
+#if defined(SOL_IN_DEBUG_DETECTED)
+	#if SOL_IN_DEBUG_DETECTED != 0
+		#define SOL_DEBUG_BUILD_I_ SOL_ON
+	#else
+		#define SOL_DEBUG_BUILD_I_ SOL_OFF
+	#endif
+#elif !defined(NDEBUG)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX_I_) && defined(_DEBUG)
+		#define SOL_DEBUG_BUILD_I_ SOL_ON
+	#elif (SOL_IS_ON(SOL_COMPILER_CLANG_I_) || SOL_IS_ON(SOL_COMPILER_GCC_I_)) && !defined(__OPTIMIZE__)
+		#define SOL_DEBUG_BUILD_I_ SOL_ON
+	#else
+		#define SOL_DEBUG_BUILD_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_DEBUG_BUILD_I_ SOL_DEFAULT_OFF
+#endif // We are in a debug mode of some sort
+
+#if defined(SOL_NO_EXCEPTIONS)
+	#if (SOL_NO_EXCEPTIONS != 0)
+		#define SOL_EXCEPTIONS_I_ SOL_OFF
+	#else
+		#define SOL_EXCEPTIONS_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+	#if !defined(_CPPUNWIND)
+		#define SOL_EXCEPTIONS_I_ SOL_OFF
+	#else
+		#define SOL_EXCEPTIONS_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_CLANG_I_) || SOL_IS_ON(SOL_COMPILER_GCC_I_)
+	#if !defined(__EXCEPTIONS)
+		#define SOL_EXCEPTIONS_I_ SOL_OFF
+	#else
+		#define SOL_EXCEPTIONS_I_ SOL_ON
+	#endif
+#else
+	#define SOL_EXCEPTIONS_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_NO_RTTI)
+	#if (SOL_NO_RTTI != 0)
+		#define SOL_RTTI_I_ SOL_OFF
+	#else
+		#define SOL_RTTI_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+	#if !defined(_CPPRTTI)
+		#define SOL_RTTI_I_ SOL_OFF
+	#else
+		#define SOL_RTTI_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_CLANG_I_) || SOL_IS_ON(SOL_COMPILER_GCC_I_)
+	#if !defined(__GXX_RTTI)
+		#define SOL_RTTI_I_ SOL_OFF
+	#else
+		#define SOL_RTTI_I_ SOL_ON
+	#endif
+#else
+	#define SOL_RTTI_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_NO_THREAD_LOCAL) && (SOL_NO_THREAD_LOCAL != 0)
+	#define SOL_USE_THREAD_LOCAL_I_ SOL_OFF
+#else
+	#define SOL_USE_THREAD_LOCAL_I_ SOL_DEFAULT_ON
+#endif // thread_local keyword is bjorked on some platforms
+
+#if defined(SOL_ALL_SAFETIES_ON) && (SOL_ALL_SAFETIES_ON != 0)
+	#define SOL_ALL_SAFETIES_ON_I_ SOL_ON
+#else
+	#define SOL_ALL_SAFETIES_ON_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_SAFE_GETTER) && (SOL_SAFE_GETTER != 0)
+	#define SOL_SAFE_GETTER_I_ SOL_ON
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+		#define SOL_SAFE_GETTER_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+		#define SOL_SAFE_GETTER_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_GETTER_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_USERTYPE) && (SOL_SAFE_USERTYPE != 0)
+	#define SOL_SAFE_USERTYPE_I_ SOL_ON
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+		#define SOL_SAFE_USERTYPE_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+		#define SOL_SAFE_USERTYPE_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_USERTYPE_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_REFERENCES) && (SOL_SAFE_REFERENCES != 0)
+	#define SOL_SAFE_REFERENCES_I_ SOL_ON
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+		#define SOL_SAFE_REFERENCES_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+		#define SOL_SAFE_REFERENCES_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_REFERENCES_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if (defined(SOL_SAFE_FUNCTIONS) && (SOL_SAFE_FUNCTIONS != 0)) \
+    || (defined(SOL_SAFE_FUNCTION_OBJECTS) && (SOL_SAFE_FUNCTION_OBJECTS != 0))
+	#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_ON
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_FUNCTION_CALLS) && (SOL_SAFE_FUNCTION_CALLS != 0)
+	#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_ON
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_PROXIES) && (SOL_SAFE_PROXIES != 0)
+	#define SOL_SAFE_PROXIES_I_ SOL_ON
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+		#define SOL_SAFE_PROXIES_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+		#define SOL_SAFE_PROXIES_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_PROXIES_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_NUMERICS) && (SOL_SAFE_NUMERICS != 0)
+	#define SOL_SAFE_NUMERICS_I_ SOL_ON
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+		#define SOL_SAFE_NUMERICS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+		#define SOL_SAFE_NUMERICS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_NUMERICS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_STACK_CHECK) && (SOL_SAFE_STACK_CHECK != 0)
+	#define SOL_SAFE_STACK_CHECK_I_ SOL_ON
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if (defined(SOL_NO_CHECK_NUMBER_PRECISION) && (SOL_NO_CHECK_NUMBER_PRECISION != 0)) \
+    || (defined(SOL_NO_CHECKING_NUMBER_PRECISION) && (SOL_NO_CHECKING_NUMBER_PRECISION != 0))
+	#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_OFF
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_SAFE_NUMERICS_I_)
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_STRINGS_ARE_NUMBERS)
+	#if (SOL_STRINGS_ARE_NUMBERS != 0)
+		#define SOL_STRINGS_ARE_NUMBERS_I_ SOL_ON
+	#else
+		#define SOL_STRINGS_ARE_NUMBERS_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_STRINGS_ARE_NUMBERS_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_ENABLE_INTEROP) && (SOL_ENABLE_INTEROP != 0) \
+    || defined(SOL_USE_INTEROP) && (SOL_USE_INTEROP != 0)
+	#define SOL_USE_INTEROP_I_ SOL_ON
+#else
+	#define SOL_USE_INTEROP_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_NO_NIL)
+	#if (SOL_NO_NIL != 0)
+		#define SOL_NIL_I_ SOL_OFF
+	#else
+		#define SOL_NIL_I_ SOL_ON
+	#endif
+#elif defined(__MAC_OS_X_VERSION_MAX_ALLOWED) || defined(__OBJC__) || defined(nil)
+	#define SOL_NIL_I_ SOL_DEFAULT_OFF
+#else
+	#define SOL_NIL_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_USERTYPE_TYPE_BINDING_INFO)
+	#if (SOL_USERTYPE_TYPE_BINDING_INFO != 0)
+		#define SOL_USERTYPE_TYPE_BINDING_INFO_I_ SOL_ON
+	#else
+		#define SOL_USERTYPE_TYPE_BINDING_INFO_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USERTYPE_TYPE_BINDING_INFO_I_ SOL_DEFAULT_ON
+#endif // We should generate a my_type.__type table with lots of class information for usertypes
+
+#if defined(SOL_AUTOMAGICAL_TYPES_BY_DEFAULT)
+	#if (SOL_AUTOMAGICAL_TYPES_BY_DEFAULT != 0)
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_ON
+	#else
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_OFF
+	#endif
+#elif defined(SOL_DEFAULT_AUTOMAGICAL_USERTYPES)
+	#if (SOL_DEFAULT_AUTOMAGICAL_USERTYPES != 0)
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_ON
+	#else
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_DEFAULT_ON
+#endif // make is_automagical on/off by default
+
+#if defined(SOL_STD_VARIANT)
+	#if (SOL_STD_VARIANT != 0)
+		#define SOL_STD_VARIANT_I_ SOL_ON
+	#else
+		#define SOL_STD_VARIANT_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_COMPILER_CLANG_I_) && SOL_IS_ON(SOL_PLATFORM_APPLE_I_)
+		#if defined(__has_include)
+			#if __has_include(<variant>)
+				#define SOL_STD_VARIANT_I_ SOL_ON
+			#else
+				#define SOL_STD_VARIANT_I_ SOL_OFF
+			#endif
+		#else
+			#define SOL_STD_VARIANT_I_ SOL_OFF
+		#endif
+	#else
+		#define SOL_STD_VARIANT_I_ SOL_DEFAULT_ON
+	#endif
+#endif // make is_automagical on/off by default
+
+#if defined(SOL_NOEXCEPT_FUNCTION_TYPE)
+	#if (SOL_NOEXCEPT_FUNCTION_TYPE != 0)
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_ON
+	#else
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_OFF
+	#endif
+#else
+	#if defined(__cpp_noexcept_function_type)
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_COMPILER_VCXX_I_) && (defined(_MSVC_LANG) && (_MSVC_LANG < 201403L))
+		// There is a bug in the VC++ compiler??
+		// on /std:c++latest under x86 conditions (VS 15.5.2),
+		// compiler errors are tossed for noexcept markings being on function types
+		// that are identical in every other way to their non-noexcept marked types function types...
+		// VS 2019: There is absolutely a bug.
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_OFF
+	#else
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_DEFAULT_ON
+	#endif
+#endif // noexcept is part of a function's type
+
+#if defined(SOL_STACK_STRING_OPTIMIZATION_SIZE) && SOL_STACK_STRING_OPTIMIZATION_SIZE > 0
+	#define SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_ SOL_STACK_STRING_OPTIMIZATION_SIZE
+#else
+	#define SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_ 1024
+#endif
+
+#if defined(SOL_ID_SIZE) && SOL_ID_SIZE > 0
+	#define SOL_ID_SIZE_I_ SOL_ID_SIZE
+#else
+	#define SOL_ID_SIZE_I_ 512
+#endif
+
+#if defined(LUA_IDSIZE) && LUA_IDSIZE > 0
+	#define SOL_FILE_ID_SIZE_I_ LUA_IDSIZE
+#elif defined(SOL_ID_SIZE) && SOL_ID_SIZE > 0
+	#define SOL_FILE_ID_SIZE_I_ SOL_FILE_ID_SIZE
+#else
+	#define SOL_FILE_ID_SIZE_I_ 2048
+#endif
+
+#if defined(SOL_PRINT_ERRORS)
+	#if (SOL_PRINT_ERRORS != 0)
+		#define SOL_PRINT_ERRORS_I_ SOL_ON
+	#else
+		#define SOL_PRINT_ERRORS_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+		#define SOL_PRINT_ERRORS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+		#define SOL_PRINT_ERRORS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_PRINT_ERRORS_I_ SOL_OFF
+	#endif
+#endif
+
+#if defined(SOL_DEFAULT_PASS_ON_ERROR) && (SOL_DEFAULT_PASS_ON_ERROR != 0)
+	#define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_ON
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+		#define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+		#define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_OFF
+	#endif
+#endif
+
+#if defined(SOL_USING_CXX_LUA)
+	#if (SOL_USING_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUA_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUA_I_ SOL_OFF
+	#endif
+#elif defined(SOL_USE_CXX_LUA)
+	#if (SOL_USE_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUA_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUA_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_CXX_LUA_I_ SOL_OFF
+#endif
+
+#if defined(SOL_USING_CXX_LUAJIT)
+	#if (SOL_USING_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_OFF
+	#endif
+#elif defined(SOL_USE_CXX_LUAJIT)
+	#if (SOL_USE_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_CXX_LUAJIT_I_ SOL_OFF
+#endif
+
+#if defined(SOL_NO_LUA_HPP)
+	#if (SOL_NO_LUA_HPP != 0)
+		#define SOL_USE_LUA_HPP_I_ SOL_OFF
+	#else
+		#define SOL_USE_LUA_HPP_I_ SOL_ON
+	#endif
+#elif defined(SOL_USING_CXX_LUA)
+	#define SOL_USE_LUA_HPP_I_ SOL_OFF
+#elif defined(__has_include)
+	#if __has_include(<lua.hpp>)
+		#define SOL_USE_LUA_HPP_I_ SOL_ON
+	#else
+		#define SOL_USE_LUA_HPP_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_LUA_HPP_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_CONTAINERS_START)
+	#define SOL_CONTAINER_START_INDEX_I_ SOL_CONTAINERS_START
+#elif defined(SOL_CONTAINERS_START_INDEX)
+	#define SOL_CONTAINER_START_INDEX_I_ SOL_CONTAINERS_START_INDEX
+#elif defined(SOL_CONTAINER_START_INDEX)
+	#define SOL_CONTAINER_START_INDEX_I_ SOL_CONTAINER_START_INDEX
+#else
+	#define SOL_CONTAINER_START_INDEX_I_ 1
+#endif
+
+#if defined (SOL_NO_MEMORY_ALIGNMENT)
+	#if (SOL_NO_MEMORY_ALIGNMENT != 0)
+		#define SOL_ALIGN_MEMORY_I_ SOL_OFF
+	#else
+		#define SOL_ALIGN_MEMORY_I_ SOL_ON
+	#endif
+#else
+	#define SOL_ALIGN_MEMORY_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_USE_BOOST)
+	#if (SOL_USE_BOOST != 0)
+		#define SOL_USE_BOOST_I_ SOL_ON
+	#else
+		#define SOL_USE_BOOST_I_ SOL_OFF
+	#endif
+#else
+		#define SOL_USE_BOOST_I_ SOL_OFF
+#endif
+
+#if defined(SOL_USE_UNSAFE_BASE_LOOKUP)
+	#if (SOL_USE_UNSAFE_BASE_LOOKUP != 0)
+		#define SOL_USE_UNSAFE_BASE_LOOKUP_I_ SOL_ON
+	#else
+		#define SOL_USE_UNSAFE_BASE_LOOKUP_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_UNSAFE_BASE_LOOKUP_I_ SOL_OFF
+#endif
+
+#if defined(SOL_INSIDE_UNREAL)
+	#if (SOL_INSIDE_UNREAL != 0)
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_ON
+	#else
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_OFF
+	#endif
+#else
+	#if defined(UE_BUILD_DEBUG) || defined(UE_BUILD_DEVELOPMENT) || defined(UE_BUILD_TEST) || defined(UE_BUILD_SHIPPING) || defined(UE_SERVER)
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_ON
+	#else
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_NO_COMPAT)
+	#if (SOL_NO_COMPAT != 0)
+		#define SOL_USE_COMPATIBILITY_LAYER_I_ SOL_OFF
+	#else
+		#define SOL_USE_COMPATIBILITY_LAYER_I_ SOL_ON
+	#endif
+#else
+	#define SOL_USE_COMPATIBILITY_LAYER_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_GET_FUNCTION_POINTER_UNSAFE)
+	#if (SOL_GET_FUNCTION_POINTER_UNSAFE != 0)
+		#define SOL_GET_FUNCTION_POINTER_UNSAFE_I_ SOL_ON
+	#else
+		#define SOL_GET_FUNCTION_POINTER_UNSAFE_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_GET_FUNCTION_POINTER_UNSAFE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if SOL_IS_ON(SOL_COMPILER_FRONTEND_MINGW_I_) && defined(__GNUC__) && (__GNUC__ < 6)
+	// MinGW is off its rocker in some places...
+	#define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_ON
+#else
+	#define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_DEFAULT_OFF
+#endif
+
+// end of sol/version.hpp
+
+#include <utility>
+#include <type_traits>
+#include <string_view>
+
+#if SOL_IS_ON(SOL_USE_CXX_LUA_I_) || SOL_IS_ON(SOL_USE_CXX_LUAJIT_I_)
+struct lua_State;
+#else
+extern "C" {
+struct lua_State;
+}
+#endif // C++ Mangling for Lua vs. Not
+
+namespace sol {
+
+	enum class type;
+
+	class stateless_reference;
+	template <bool b>
+	class basic_reference;
+	using reference = basic_reference<false>;
+	using main_reference = basic_reference<true>;
+	class stateless_stack_reference;
+	class stack_reference;
+
+	template <typename A>
+	class basic_bytecode;
+
+	struct lua_value;
+
+	struct proxy_base_tag;
+	template <typename>
+	struct proxy_base;
+	template <typename, typename>
+	struct table_proxy;
+
+	template <bool, typename>
+	class basic_table_core;
+	template <bool b>
+	using table_core = basic_table_core<b, reference>;
+	template <bool b>
+	using main_table_core = basic_table_core<b, main_reference>;
+	template <bool b>
+	using stack_table_core = basic_table_core<b, stack_reference>;
+	template <typename base_type>
+	using basic_table = basic_table_core<false, base_type>;
+	using table = table_core<false>;
+	using global_table = table_core<true>;
+	using main_table = main_table_core<false>;
+	using main_global_table = main_table_core<true>;
+	using stack_table = stack_table_core<false>;
+	using stack_global_table = stack_table_core<true>;
+
+	template <typename>
+	struct basic_lua_table;
+	using lua_table = basic_lua_table<reference>;
+	using stack_lua_table = basic_lua_table<stack_reference>;
+
+	template <typename T, typename base_type>
+	class basic_usertype;
+	template <typename T>
+	using usertype = basic_usertype<T, reference>;
+	template <typename T>
+	using stack_usertype = basic_usertype<T, stack_reference>;
+
+	template <typename base_type>
+	class basic_metatable;
+	using metatable = basic_metatable<reference>;
+	using stack_metatable = basic_metatable<stack_reference>;
+
+	template <typename base_t>
+	struct basic_environment;
+	using environment = basic_environment<reference>;
+	using main_environment = basic_environment<main_reference>;
+	using stack_environment = basic_environment<stack_reference>;
+
+	template <typename T, bool>
+	class basic_function;
+	template <typename T, bool, typename H>
+	class basic_protected_function;
+	using unsafe_function = basic_function<reference, false>;
+	using safe_function = basic_protected_function<reference, false, reference>;
+	using main_unsafe_function = basic_function<main_reference, false>;
+	using main_safe_function = basic_protected_function<main_reference, false, reference>;
+	using stack_unsafe_function = basic_function<stack_reference, false>;
+	using stack_safe_function = basic_protected_function<stack_reference, false, reference>;
+	using stack_aligned_unsafe_function = basic_function<stack_reference, true>;
+	using stack_aligned_safe_function = basic_protected_function<stack_reference, true, reference>;
+	using protected_function = safe_function;
+	using main_protected_function = main_safe_function;
+	using stack_protected_function = stack_safe_function;
+	using stack_aligned_protected_function = stack_aligned_safe_function;
+#if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS_I_)
+	using function = protected_function;
+	using main_function = main_protected_function;
+	using stack_function = stack_protected_function;
+	using stack_aligned_function = stack_aligned_safe_function;
+#else
+	using function = unsafe_function;
+	using main_function = main_unsafe_function;
+	using stack_function = stack_unsafe_function;
+	using stack_aligned_function = stack_aligned_unsafe_function;
+#endif
+	using stack_aligned_stack_handler_function = basic_protected_function<stack_reference, true, stack_reference>;
+
+	struct unsafe_function_result;
+	struct protected_function_result;
+	using safe_function_result = protected_function_result;
+#if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS_I_)
+	using function_result = safe_function_result;
+#else
+	using function_result = unsafe_function_result;
+#endif
+
+	template <typename base_t>
+	class basic_object_base;
+	template <typename base_t>
+	class basic_object;
+	template <typename base_t>
+	class basic_userdata;
+	template <typename base_t>
+	class basic_lightuserdata;
+	template <typename base_t>
+	class basic_coroutine;
+	template <typename base_t>
+	class basic_thread;
+
+	using object = basic_object<reference>;
+	using userdata = basic_userdata<reference>;
+	using lightuserdata = basic_lightuserdata<reference>;
+	using thread = basic_thread<reference>;
+	using coroutine = basic_coroutine<reference>;
+	using main_object = basic_object<main_reference>;
+	using main_userdata = basic_userdata<main_reference>;
+	using main_lightuserdata = basic_lightuserdata<main_reference>;
+	using main_coroutine = basic_coroutine<main_reference>;
+	using stack_object = basic_object<stack_reference>;
+	using stack_userdata = basic_userdata<stack_reference>;
+	using stack_lightuserdata = basic_lightuserdata<stack_reference>;
+	using stack_thread = basic_thread<stack_reference>;
+	using stack_coroutine = basic_coroutine<stack_reference>;
+
+	struct stack_proxy_base;
+	struct stack_proxy;
+	struct variadic_args;
+	struct variadic_results;
+	struct stack_count;
+	struct this_state;
+	struct this_main_state;
+	struct this_environment;
+
+	class state_view;
+	class state;
+
+	template <typename T>
+	struct as_table_t;
+	template <typename T>
+	struct as_container_t;
+	template <typename T>
+	struct nested;
+	template <typename T>
+	struct light;
+	template <typename T>
+	struct user;
+	template <typename T>
+	struct as_args_t;
+	template <typename T>
+	struct protect_t;
+	template <typename F, typename... Policies>
+	struct policy_wrapper;
+
+	template <typename T>
+	struct usertype_traits;
+	template <typename T>
+	struct unique_usertype_traits;
+
+	template <typename... Args>
+	struct types {
+		typedef std::make_index_sequence<sizeof...(Args)> indices;
+		static constexpr std::size_t size() {
+			return sizeof...(Args);
+		}
+	};
+
+	template <typename T>
+	struct derive : std::false_type {
+		typedef types<> type;
+	};
+
+	template <typename T>
+	struct base : std::false_type {
+		typedef types<> type;
+	};
+
+	template <typename T>
+	struct weak_derive {
+		static bool value;
+	};
+
+	template <typename T>
+	bool weak_derive<T>::value = false;
+
+	namespace stack {
+		struct record;
+	}
+
+#if SOL_IS_OFF(SOL_USE_BOOST_I_)
+	template <class T>
+	class optional;
+
+	template <class T>
+	class optional<T&>;
+#endif
+
+	using check_handler_type = int(lua_State*, int, type, type, const char*);
+
+} // namespace sol
+
+#define SOL_BASE_CLASSES(T, ...)                       \
+	namespace sol {                                   \
+		template <>                                  \
+		struct base<T> : std::true_type {            \
+			typedef ::sol::types<__VA_ARGS__> type; \
+		};                                           \
+	}                                                 \
+	void a_sol3_detail_function_decl_please_no_collide()
+#define SOL_DERIVED_CLASSES(T, ...)                    \
+	namespace sol {                                   \
+		template <>                                  \
+		struct derive<T> : std::true_type {          \
+			typedef ::sol::types<__VA_ARGS__> type; \
+		};                                           \
+	}                                                 \
+	void a_sol3_detail_function_decl_please_no_collide()
+
+#endif // SOL_FORWARD_HPP
+// end of sol/forward.hpp
+
+#endif // SOL_SINGLE_INCLUDE_FORWARD_HPP
diff --git a/engine/inc/sol/sol.hpp b/engine/inc/sol/sol.hpp
new file mode 100644
index 00000000..047c1389
--- /dev/null
+++ b/engine/inc/sol/sol.hpp
@@ -0,0 +1,26699 @@
+// The MIT License (MIT)
+
+// Copyright (c) 2013-2020 Rapptz, ThePhD and contributors
+
+// 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.
+
+// This file was generated with a script.
+// Generated 2020-10-03 21:34:24.496436 UTC
+// This header was generated with sol v3.2.1 (revision 48eea7b5)
+// https://github.com/ThePhD/sol2
+
+#ifndef SOL_SINGLE_INCLUDE_HPP
+#define SOL_SINGLE_INCLUDE_HPP
+
+// beginning of sol/sol.hpp
+
+#ifndef SOL_HPP
+#define SOL_HPP
+
+// beginning of sol/version.hpp
+
+#include <sol/config.hpp>
+
+#include <cstdint>
+
+#define SOL_VERSION_MAJOR 3
+#define SOL_VERSION_MINOR 5
+#define SOL_VERSION_PATCH 0
+#define SOL_VERSION_STRING "3.5.0"
+#define SOL_VERSION ((SOL_VERSION_MAJOR * 100000) + (SOL_VERSION_MINOR * 100) + (SOL_VERSION_PATCH))
+
+#define SOL_IS_ON(OP_SYMBOL) ((3 OP_SYMBOL 3) != 0)
+#define SOL_IS_OFF(OP_SYMBOL) ((3 OP_SYMBOL 3) == 0)
+#define SOL_IS_DEFAULT_ON(OP_SYMBOL) ((3 OP_SYMBOL 3) > 3)
+#define SOL_IS_DEFAULT_OFF(OP_SYMBOL) ((3 OP_SYMBOL 3 OP_SYMBOL 3) < 0)
+
+#define SOL_ON          |
+#define SOL_OFF         ^
+#define SOL_DEFAULT_ON  +
+#define SOL_DEFAULT_OFF -
+
+#if defined(_MSC_VER)
+	#define SOL_COMPILER_CLANG_I_ SOL_OFF
+	#define SOL_COMPILER_GCC_I_   SOL_OFF
+	#define SOL_COMPILER_EDG_I_   SOL_OFF
+	#define SOL_COMPILER_VCXX_I_  SOL_ON
+#elif defined(__clang__)
+	#define SOL_COMPILER_CLANG_I_ SOL_ON
+	#define SOL_COMPILER_GCC_I_   SOL_OFF
+	#define SOL_COMPILER_EDG_I_   SOL_OFF
+	#define SOL_COMPILER_VCXX_I_  SOL_OFF
+#elif defined(__GNUC__)
+	#define SOL_COMPILER_CLANG_I_ SOL_OFF
+	#define SOL_COMPILER_GCC_I_   SOL_ON
+	#define SOL_COMPILER_EDG_I_   SOL_OFF
+	#define SOL_COMPILER_VCXX_I_  SOL_OFF
+#else
+	#define SOL_COMPILER_CLANG_I_ SOL_OFF
+	#define SOL_COMPILER_GCC_I_   SOL_OFF
+	#define SOL_COMPILER_EDG_I_   SOL_OFF
+	#define SOL_COMPILER_VCXX_I_  SOL_OFF
+#endif
+
+#if defined(__MINGW32__)
+	#define SOL_COMPILER_FRONTEND_MINGW_I_ SOL_ON
+#else
+	#define SOL_COMPILER_FRONTEND_MINGW_I_ SOL_OFF
+#endif
+
+#if SIZE_MAX <= 0xFFFFULL
+	#define SOL_PLATFORM_X16_I_ SOL_ON
+	#define SOL_PLATFORM_X86_I_ SOL_OFF
+	#define SOL_PLATFORM_X64_I_ SOL_OFF
+#elif SIZE_MAX <= 0xFFFFFFFFULL
+	#define SOL_PLATFORM_X16_I_ SOL_OFF
+	#define SOL_PLATFORM_X86_I_ SOL_ON
+	#define SOL_PLATFORM_X64_I_ SOL_OFF
+#else
+	#define SOL_PLATFORM_X16_I_ SOL_OFF
+	#define SOL_PLATFORM_X86_I_ SOL_OFF
+	#define SOL_PLATFORM_X64_I_ SOL_ON
+#endif
+
+#define SOL_PLATFORM_ARM32_I_ SOL_OFF
+#define SOL_PLATFORM_ARM64_I_ SOL_OFF
+
+#if defined(_WIN32)
+	#define SOL_PLATFORM_WINDOWS_I_ SOL_ON
+#else
+	#define SOL_PLATFORM_WINDOWS_I_ SOL_OFF
+#endif
+#if defined(__APPLE__)
+	#define SOL_PLATFORM_APPLE_I_ SOL_ON
+#else
+	#define SOL_PLATFORM_APPLE_I_ SOL_OFF
+#endif
+#if defined(__unix__)
+	#define SOL_PLATFORM_UNIXLIKE_I_ SOL_ON
+#else
+	#define SOL_PLATFORM_UNIXLIKE_I_ SOL_OFF
+#endif
+#if defined(__linux__)
+	#define SOL_PLATFORM_LINUXLIKE_I_ SOL_ON
+#else
+	#define SOL_PLATFORM_LINUXLIKE_I_ SOL_OFF
+#endif
+
+#define SOL_PLATFORM_APPLE_IPHONE_I_ SOL_OFF
+#define SOL_PLATFORM_BSDLIKE_I_      SOL_OFF
+
+#if defined(SOL_IN_DEBUG_DETECTED)
+	#if SOL_IN_DEBUG_DETECTED != 0
+		#define SOL_DEBUG_BUILD_I_ SOL_ON
+	#else
+		#define SOL_DEBUG_BUILD_I_ SOL_OFF
+	#endif
+#elif !defined(NDEBUG)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX_I_) && defined(_DEBUG)
+		#define SOL_DEBUG_BUILD_I_ SOL_ON
+	#elif (SOL_IS_ON(SOL_COMPILER_CLANG_I_) || SOL_IS_ON(SOL_COMPILER_GCC_I_)) && !defined(__OPTIMIZE__)
+		#define SOL_DEBUG_BUILD_I_ SOL_ON
+	#else
+		#define SOL_DEBUG_BUILD_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_DEBUG_BUILD_I_ SOL_DEFAULT_OFF
+#endif // We are in a debug mode of some sort
+
+#if defined(SOL_NO_EXCEPTIONS)
+	#if (SOL_NO_EXCEPTIONS != 0)
+		#define SOL_EXCEPTIONS_I_ SOL_OFF
+	#else
+		#define SOL_EXCEPTIONS_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+	#if !defined(_CPPUNWIND)
+		#define SOL_EXCEPTIONS_I_ SOL_OFF
+	#else
+		#define SOL_EXCEPTIONS_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_CLANG_I_) || SOL_IS_ON(SOL_COMPILER_GCC_I_)
+	#if !defined(__EXCEPTIONS)
+		#define SOL_EXCEPTIONS_I_ SOL_OFF
+	#else
+		#define SOL_EXCEPTIONS_I_ SOL_ON
+	#endif
+#else
+	#define SOL_EXCEPTIONS_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_NO_RTTI)
+	#if (SOL_NO_RTTI != 0)
+		#define SOL_RTTI_I_ SOL_OFF
+	#else
+		#define SOL_RTTI_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+	#if !defined(_CPPRTTI)
+		#define SOL_RTTI_I_ SOL_OFF
+	#else
+		#define SOL_RTTI_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_CLANG_I_) || SOL_IS_ON(SOL_COMPILER_GCC_I_)
+	#if !defined(__GXX_RTTI)
+		#define SOL_RTTI_I_ SOL_OFF
+	#else
+		#define SOL_RTTI_I_ SOL_ON
+	#endif
+#else
+	#define SOL_RTTI_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_NO_THREAD_LOCAL) && (SOL_NO_THREAD_LOCAL != 0)
+	#define SOL_USE_THREAD_LOCAL_I_ SOL_OFF
+#else
+	#define SOL_USE_THREAD_LOCAL_I_ SOL_DEFAULT_ON
+#endif // thread_local keyword is bjorked on some platforms
+
+#if defined(SOL_ALL_SAFETIES_ON) && (SOL_ALL_SAFETIES_ON != 0)
+	#define SOL_ALL_SAFETIES_ON_I_ SOL_ON
+#else
+	#define SOL_ALL_SAFETIES_ON_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_SAFE_GETTER) && (SOL_SAFE_GETTER != 0)
+	#define SOL_SAFE_GETTER_I_ SOL_ON
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+		#define SOL_SAFE_GETTER_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+		#define SOL_SAFE_GETTER_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_GETTER_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_USERTYPE) && (SOL_SAFE_USERTYPE != 0)
+	#define SOL_SAFE_USERTYPE_I_ SOL_ON
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+		#define SOL_SAFE_USERTYPE_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+		#define SOL_SAFE_USERTYPE_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_USERTYPE_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_REFERENCES) && (SOL_SAFE_REFERENCES != 0)
+	#define SOL_SAFE_REFERENCES_I_ SOL_ON
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+		#define SOL_SAFE_REFERENCES_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+		#define SOL_SAFE_REFERENCES_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_REFERENCES_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if (defined(SOL_SAFE_FUNCTIONS) && (SOL_SAFE_FUNCTIONS != 0)) \
+    || (defined(SOL_SAFE_FUNCTION_OBJECTS) && (SOL_SAFE_FUNCTION_OBJECTS != 0))
+	#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_ON
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_FUNCTION_CALLS) && (SOL_SAFE_FUNCTION_CALLS != 0)
+	#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_ON
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_PROXIES) && (SOL_SAFE_PROXIES != 0)
+	#define SOL_SAFE_PROXIES_I_ SOL_ON
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+		#define SOL_SAFE_PROXIES_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+		#define SOL_SAFE_PROXIES_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_PROXIES_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_NUMERICS) && (SOL_SAFE_NUMERICS != 0)
+	#define SOL_SAFE_NUMERICS_I_ SOL_ON
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+		#define SOL_SAFE_NUMERICS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+		#define SOL_SAFE_NUMERICS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_NUMERICS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_STACK_CHECK) && (SOL_SAFE_STACK_CHECK != 0)
+	#define SOL_SAFE_STACK_CHECK_I_ SOL_ON
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if (defined(SOL_NO_CHECK_NUMBER_PRECISION) && (SOL_NO_CHECK_NUMBER_PRECISION != 0)) \
+    || (defined(SOL_NO_CHECKING_NUMBER_PRECISION) && (SOL_NO_CHECKING_NUMBER_PRECISION != 0))
+	#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_OFF
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_SAFE_NUMERICS_I_)
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_STRINGS_ARE_NUMBERS)
+	#if (SOL_STRINGS_ARE_NUMBERS != 0)
+		#define SOL_STRINGS_ARE_NUMBERS_I_ SOL_ON
+	#else
+		#define SOL_STRINGS_ARE_NUMBERS_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_STRINGS_ARE_NUMBERS_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_ENABLE_INTEROP) && (SOL_ENABLE_INTEROP != 0) \
+    || defined(SOL_USE_INTEROP) && (SOL_USE_INTEROP != 0)
+	#define SOL_USE_INTEROP_I_ SOL_ON
+#else
+	#define SOL_USE_INTEROP_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_NO_NIL)
+	#if (SOL_NO_NIL != 0)
+		#define SOL_NIL_I_ SOL_OFF
+	#else
+		#define SOL_NIL_I_ SOL_ON
+	#endif
+#elif defined(__MAC_OS_X_VERSION_MAX_ALLOWED) || defined(__OBJC__) || defined(nil)
+	#define SOL_NIL_I_ SOL_DEFAULT_OFF
+#else
+	#define SOL_NIL_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_USERTYPE_TYPE_BINDING_INFO)
+	#if (SOL_USERTYPE_TYPE_BINDING_INFO != 0)
+		#define SOL_USERTYPE_TYPE_BINDING_INFO_I_ SOL_ON
+	#else
+		#define SOL_USERTYPE_TYPE_BINDING_INFO_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USERTYPE_TYPE_BINDING_INFO_I_ SOL_DEFAULT_ON
+#endif // We should generate a my_type.__type table with lots of class information for usertypes
+
+#if defined(SOL_AUTOMAGICAL_TYPES_BY_DEFAULT)
+	#if (SOL_AUTOMAGICAL_TYPES_BY_DEFAULT != 0)
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_ON
+	#else
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_OFF
+	#endif
+#elif defined(SOL_DEFAULT_AUTOMAGICAL_USERTYPES)
+	#if (SOL_DEFAULT_AUTOMAGICAL_USERTYPES != 0)
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_ON
+	#else
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_DEFAULT_ON
+#endif // make is_automagical on/off by default
+
+#if defined(SOL_STD_VARIANT)
+	#if (SOL_STD_VARIANT != 0)
+		#define SOL_STD_VARIANT_I_ SOL_ON
+	#else
+		#define SOL_STD_VARIANT_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_COMPILER_CLANG_I_) && SOL_IS_ON(SOL_PLATFORM_APPLE_I_)
+		#if defined(__has_include)
+			#if __has_include(<variant>)
+				#define SOL_STD_VARIANT_I_ SOL_ON
+			#else
+				#define SOL_STD_VARIANT_I_ SOL_OFF
+			#endif
+		#else
+			#define SOL_STD_VARIANT_I_ SOL_OFF
+		#endif
+	#else
+		#define SOL_STD_VARIANT_I_ SOL_DEFAULT_ON
+	#endif
+#endif // make is_automagical on/off by default
+
+#if defined(SOL_NOEXCEPT_FUNCTION_TYPE)
+	#if (SOL_NOEXCEPT_FUNCTION_TYPE != 0)
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_ON
+	#else
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_OFF
+	#endif
+#else
+	#if defined(__cpp_noexcept_function_type)
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_COMPILER_VCXX_I_) && (defined(_MSVC_LANG) && (_MSVC_LANG < 201403L))
+		// There is a bug in the VC++ compiler??
+		// on /std:c++latest under x86 conditions (VS 15.5.2),
+		// compiler errors are tossed for noexcept markings being on function types
+		// that are identical in every other way to their non-noexcept marked types function types...
+		// VS 2019: There is absolutely a bug.
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_OFF
+	#else
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_DEFAULT_ON
+	#endif
+#endif // noexcept is part of a function's type
+
+#if defined(SOL_STACK_STRING_OPTIMIZATION_SIZE) && SOL_STACK_STRING_OPTIMIZATION_SIZE > 0
+	#define SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_ SOL_STACK_STRING_OPTIMIZATION_SIZE
+#else
+	#define SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_ 1024
+#endif
+
+#if defined(SOL_ID_SIZE) && SOL_ID_SIZE > 0
+	#define SOL_ID_SIZE_I_ SOL_ID_SIZE
+#else
+	#define SOL_ID_SIZE_I_ 512
+#endif
+
+#if defined(LUA_IDSIZE) && LUA_IDSIZE > 0
+	#define SOL_FILE_ID_SIZE_I_ LUA_IDSIZE
+#elif defined(SOL_ID_SIZE) && SOL_ID_SIZE > 0
+	#define SOL_FILE_ID_SIZE_I_ SOL_FILE_ID_SIZE
+#else
+	#define SOL_FILE_ID_SIZE_I_ 2048
+#endif
+
+#if defined(SOL_PRINT_ERRORS)
+	#if (SOL_PRINT_ERRORS != 0)
+		#define SOL_PRINT_ERRORS_I_ SOL_ON
+	#else
+		#define SOL_PRINT_ERRORS_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+		#define SOL_PRINT_ERRORS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+		#define SOL_PRINT_ERRORS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_PRINT_ERRORS_I_ SOL_OFF
+	#endif
+#endif
+
+#if defined(SOL_DEFAULT_PASS_ON_ERROR) && (SOL_DEFAULT_PASS_ON_ERROR != 0)
+	#define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_ON
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+		#define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+		#define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_OFF
+	#endif
+#endif
+
+#if defined(SOL_USING_CXX_LUA)
+	#if (SOL_USING_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUA_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUA_I_ SOL_OFF
+	#endif
+#elif defined(SOL_USE_CXX_LUA)
+	#if (SOL_USE_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUA_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUA_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_CXX_LUA_I_ SOL_OFF
+#endif
+
+#if defined(SOL_USING_CXX_LUAJIT)
+	#if (SOL_USING_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_OFF
+	#endif
+#elif defined(SOL_USE_CXX_LUAJIT)
+	#if (SOL_USE_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_CXX_LUAJIT_I_ SOL_OFF
+#endif
+
+#if defined(SOL_NO_LUA_HPP)
+	#if (SOL_NO_LUA_HPP != 0)
+		#define SOL_USE_LUA_HPP_I_ SOL_OFF
+	#else
+		#define SOL_USE_LUA_HPP_I_ SOL_ON
+	#endif
+#elif defined(SOL_USING_CXX_LUA)
+	#define SOL_USE_LUA_HPP_I_ SOL_OFF
+#elif defined(__has_include)
+	#if __has_include(<lua.hpp>)
+		#define SOL_USE_LUA_HPP_I_ SOL_ON
+	#else
+		#define SOL_USE_LUA_HPP_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_LUA_HPP_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_CONTAINERS_START)
+	#define SOL_CONTAINER_START_INDEX_I_ SOL_CONTAINERS_START
+#elif defined(SOL_CONTAINERS_START_INDEX)
+	#define SOL_CONTAINER_START_INDEX_I_ SOL_CONTAINERS_START_INDEX
+#elif defined(SOL_CONTAINER_START_INDEX)
+	#define SOL_CONTAINER_START_INDEX_I_ SOL_CONTAINER_START_INDEX
+#else
+	#define SOL_CONTAINER_START_INDEX_I_ 1
+#endif
+
+#if defined (SOL_NO_MEMORY_ALIGNMENT)
+	#if (SOL_NO_MEMORY_ALIGNMENT != 0)
+		#define SOL_ALIGN_MEMORY_I_ SOL_OFF
+	#else
+		#define SOL_ALIGN_MEMORY_I_ SOL_ON
+	#endif
+#else
+	#define SOL_ALIGN_MEMORY_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_USE_BOOST)
+	#if (SOL_USE_BOOST != 0)
+		#define SOL_USE_BOOST_I_ SOL_ON
+	#else
+		#define SOL_USE_BOOST_I_ SOL_OFF
+	#endif
+#else
+		#define SOL_USE_BOOST_I_ SOL_OFF
+#endif
+
+#if defined(SOL_USE_UNSAFE_BASE_LOOKUP)
+	#if (SOL_USE_UNSAFE_BASE_LOOKUP != 0)
+		#define SOL_USE_UNSAFE_BASE_LOOKUP_I_ SOL_ON
+	#else
+		#define SOL_USE_UNSAFE_BASE_LOOKUP_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_UNSAFE_BASE_LOOKUP_I_ SOL_OFF
+#endif
+
+#if defined(SOL_INSIDE_UNREAL)
+	#if (SOL_INSIDE_UNREAL != 0)
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_ON
+	#else
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_OFF
+	#endif
+#else
+	#if defined(UE_BUILD_DEBUG) || defined(UE_BUILD_DEVELOPMENT) || defined(UE_BUILD_TEST) || defined(UE_BUILD_SHIPPING) || defined(UE_SERVER)
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_ON
+	#else
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_NO_COMPAT)
+	#if (SOL_NO_COMPAT != 0)
+		#define SOL_USE_COMPATIBILITY_LAYER_I_ SOL_OFF
+	#else
+		#define SOL_USE_COMPATIBILITY_LAYER_I_ SOL_ON
+	#endif
+#else
+	#define SOL_USE_COMPATIBILITY_LAYER_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_GET_FUNCTION_POINTER_UNSAFE)
+	#if (SOL_GET_FUNCTION_POINTER_UNSAFE != 0)
+		#define SOL_GET_FUNCTION_POINTER_UNSAFE_I_ SOL_ON
+	#else
+		#define SOL_GET_FUNCTION_POINTER_UNSAFE_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_GET_FUNCTION_POINTER_UNSAFE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if SOL_IS_ON(SOL_COMPILER_FRONTEND_MINGW_I_) && defined(__GNUC__) && (__GNUC__ < 6)
+	// MinGW is off its rocker in some places...
+	#define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_ON
+#else
+	#define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_DEFAULT_OFF
+#endif
+
+// end of sol/version.hpp
+
+#if SOL_IS_ON(SOL_INSIDE_UNREAL_ENGINE_I_)
+#ifdef check
+#pragma push_macro("check")
+#undef check
+#endif
+#endif // Unreal Engine 4 Bullshit
+
+#if SOL_IS_ON(SOL_COMPILER_GCC_I_)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+#pragma GCC diagnostic ignored "-Wconversion"
+#if __GNUC__ > 6
+#pragma GCC diagnostic ignored "-Wnoexcept-type"
+#endif
+#elif SOL_IS_ON(SOL_COMPILER_CLANG_I_)
+#elif SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+#pragma warning(push)
+#pragma warning(disable : 4505) // unreferenced local function has been removed GEE THANKS
+#endif                          // clang++ vs. g++ vs. VC++
+
+// beginning of sol/forward.hpp
+
+#ifndef SOL_FORWARD_HPP
+#define SOL_FORWARD_HPP
+
+#include <utility>
+#include <type_traits>
+#include <string_view>
+
+#if SOL_IS_ON(SOL_USE_CXX_LUA_I_) || SOL_IS_ON(SOL_USE_CXX_LUAJIT_I_)
+struct lua_State;
+#else
+extern "C" {
+struct lua_State;
+}
+#endif // C++ Mangling for Lua vs. Not
+
+namespace sol {
+
+	enum class type;
+
+	class stateless_reference;
+	template <bool b>
+	class basic_reference;
+	using reference = basic_reference<false>;
+	using main_reference = basic_reference<true>;
+	class stateless_stack_reference;
+	class stack_reference;
+
+	template <typename A>
+	class basic_bytecode;
+
+	struct lua_value;
+
+	struct proxy_base_tag;
+	template <typename>
+	struct proxy_base;
+	template <typename, typename>
+	struct table_proxy;
+
+	template <bool, typename>
+	class basic_table_core;
+	template <bool b>
+	using table_core = basic_table_core<b, reference>;
+	template <bool b>
+	using main_table_core = basic_table_core<b, main_reference>;
+	template <bool b>
+	using stack_table_core = basic_table_core<b, stack_reference>;
+	template <typename base_type>
+	using basic_table = basic_table_core<false, base_type>;
+	using table = table_core<false>;
+	using global_table = table_core<true>;
+	using main_table = main_table_core<false>;
+	using main_global_table = main_table_core<true>;
+	using stack_table = stack_table_core<false>;
+	using stack_global_table = stack_table_core<true>;
+
+	template <typename>
+	struct basic_lua_table;
+	using lua_table = basic_lua_table<reference>;
+	using stack_lua_table = basic_lua_table<stack_reference>;
+
+	template <typename T, typename base_type>
+	class basic_usertype;
+	template <typename T>
+	using usertype = basic_usertype<T, reference>;
+	template <typename T>
+	using stack_usertype = basic_usertype<T, stack_reference>;
+
+	template <typename base_type>
+	class basic_metatable;
+	using metatable = basic_metatable<reference>;
+	using stack_metatable = basic_metatable<stack_reference>;
+
+	template <typename base_t>
+	struct basic_environment;
+	using environment = basic_environment<reference>;
+	using main_environment = basic_environment<main_reference>;
+	using stack_environment = basic_environment<stack_reference>;
+
+	template <typename T, bool>
+	class basic_function;
+	template <typename T, bool, typename H>
+	class basic_protected_function;
+	using unsafe_function = basic_function<reference, false>;
+	using safe_function = basic_protected_function<reference, false, reference>;
+	using main_unsafe_function = basic_function<main_reference, false>;
+	using main_safe_function = basic_protected_function<main_reference, false, reference>;
+	using stack_unsafe_function = basic_function<stack_reference, false>;
+	using stack_safe_function = basic_protected_function<stack_reference, false, reference>;
+	using stack_aligned_unsafe_function = basic_function<stack_reference, true>;
+	using stack_aligned_safe_function = basic_protected_function<stack_reference, true, reference>;
+	using protected_function = safe_function;
+	using main_protected_function = main_safe_function;
+	using stack_protected_function = stack_safe_function;
+	using stack_aligned_protected_function = stack_aligned_safe_function;
+#if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS_I_)
+	using function = protected_function;
+	using main_function = main_protected_function;
+	using stack_function = stack_protected_function;
+	using stack_aligned_function = stack_aligned_safe_function;
+#else
+	using function = unsafe_function;
+	using main_function = main_unsafe_function;
+	using stack_function = stack_unsafe_function;
+	using stack_aligned_function = stack_aligned_unsafe_function;
+#endif
+	using stack_aligned_stack_handler_function = basic_protected_function<stack_reference, true, stack_reference>;
+
+	struct unsafe_function_result;
+	struct protected_function_result;
+	using safe_function_result = protected_function_result;
+#if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS_I_)
+	using function_result = safe_function_result;
+#else
+	using function_result = unsafe_function_result;
+#endif
+
+	template <typename base_t>
+	class basic_object_base;
+	template <typename base_t>
+	class basic_object;
+	template <typename base_t>
+	class basic_userdata;
+	template <typename base_t>
+	class basic_lightuserdata;
+	template <typename base_t>
+	class basic_coroutine;
+	template <typename base_t>
+	class basic_thread;
+
+	using object = basic_object<reference>;
+	using userdata = basic_userdata<reference>;
+	using lightuserdata = basic_lightuserdata<reference>;
+	using thread = basic_thread<reference>;
+	using coroutine = basic_coroutine<reference>;
+	using main_object = basic_object<main_reference>;
+	using main_userdata = basic_userdata<main_reference>;
+	using main_lightuserdata = basic_lightuserdata<main_reference>;
+	using main_coroutine = basic_coroutine<main_reference>;
+	using stack_object = basic_object<stack_reference>;
+	using stack_userdata = basic_userdata<stack_reference>;
+	using stack_lightuserdata = basic_lightuserdata<stack_reference>;
+	using stack_thread = basic_thread<stack_reference>;
+	using stack_coroutine = basic_coroutine<stack_reference>;
+
+	struct stack_proxy_base;
+	struct stack_proxy;
+	struct variadic_args;
+	struct variadic_results;
+	struct stack_count;
+	struct this_state;
+	struct this_main_state;
+	struct this_environment;
+
+	class state_view;
+	class state;
+
+	template <typename T>
+	struct as_table_t;
+	template <typename T>
+	struct as_container_t;
+	template <typename T>
+	struct nested;
+	template <typename T>
+	struct light;
+	template <typename T>
+	struct user;
+	template <typename T>
+	struct as_args_t;
+	template <typename T>
+	struct protect_t;
+	template <typename F, typename... Policies>
+	struct policy_wrapper;
+
+	template <typename T>
+	struct usertype_traits;
+	template <typename T>
+	struct unique_usertype_traits;
+
+	template <typename... Args>
+	struct types {
+		typedef std::make_index_sequence<sizeof...(Args)> indices;
+		static constexpr std::size_t size() {
+			return sizeof...(Args);
+		}
+	};
+
+	template <typename T>
+	struct derive : std::false_type {
+		typedef types<> type;
+	};
+
+	template <typename T>
+	struct base : std::false_type {
+		typedef types<> type;
+	};
+
+	template <typename T>
+	struct weak_derive {
+		static bool value;
+	};
+
+	template <typename T>
+	bool weak_derive<T>::value = false;
+
+	namespace stack {
+		struct record;
+	}
+
+#if SOL_IS_OFF(SOL_USE_BOOST_I_)
+	template <class T>
+	class optional;
+
+	template <class T>
+	class optional<T&>;
+#endif
+
+	using check_handler_type = int(lua_State*, int, type, type, const char*);
+
+} // namespace sol
+
+#define SOL_BASE_CLASSES(T, ...)                       \
+	namespace sol {                                   \
+		template <>                                  \
+		struct base<T> : std::true_type {            \
+			typedef ::sol::types<__VA_ARGS__> type; \
+		};                                           \
+	}                                                 \
+	void a_sol3_detail_function_decl_please_no_collide()
+#define SOL_DERIVED_CLASSES(T, ...)                    \
+	namespace sol {                                   \
+		template <>                                  \
+		struct derive<T> : std::true_type {          \
+			typedef ::sol::types<__VA_ARGS__> type; \
+		};                                           \
+	}                                                 \
+	void a_sol3_detail_function_decl_please_no_collide()
+
+#endif // SOL_FORWARD_HPP
+// end of sol/forward.hpp
+
+// beginning of sol/forward_detail.hpp
+
+#ifndef SOL_FORWARD_DETAIL_HPP
+#define SOL_FORWARD_DETAIL_HPP
+
+// beginning of sol/traits.hpp
+
+// beginning of sol/tuple.hpp
+
+// beginning of sol/base_traits.hpp
+
+#include <type_traits>
+
+namespace sol {
+	namespace detail {
+		struct unchecked_t {};
+		const unchecked_t unchecked = unchecked_t{};
+	} // namespace detail
+
+	namespace meta {
+		using sfinae_yes_t = std::true_type;
+		using sfinae_no_t = std::false_type;
+
+		template <typename T>
+		using void_t = void;
+
+		template <typename T>
+		using unqualified = std::remove_cv<std::remove_reference_t<T>>;
+
+		template <typename T>
+		using unqualified_t = typename unqualified<T>::type;
+
+		namespace meta_detail {
+			template <typename T>
+			struct unqualified_non_alias : unqualified<T> {};
+
+			template <template <class...> class Test, class, class... Args>
+			struct is_detected : std::false_type {};
+
+			template <template <class...> class Test, class... Args>
+			struct is_detected<Test, void_t<Test<Args...>>, Args...> : std::true_type {};
+		} // namespace meta_detail
+
+		template <template <class...> class Trait, class... Args>
+		using is_detected = typename meta_detail::is_detected<Trait, void, Args...>::type;
+
+		template <template <class...> class Trait, class... Args>
+		constexpr inline bool is_detected_v = is_detected<Trait, Args...>::value;
+
+		template <std::size_t I>
+		using index_value = std::integral_constant<std::size_t, I>;
+
+		template <bool>
+		struct conditional {
+			template <typename T, typename U>
+			using type = T;
+		};
+
+		template <>
+		struct conditional<false> {
+			template <typename T, typename U>
+			using type = U;
+		};
+
+		template <bool B, typename T, typename U>
+		using conditional_t = typename conditional<B>::template type<T, U>;
+
+		namespace meta_detail {
+			template <typename T, template <typename...> class Templ>
+			struct is_specialization_of : std::false_type {};
+			template <typename... T, template <typename...> class Templ>
+			struct is_specialization_of<Templ<T...>, Templ> : std::true_type {};
+		} // namespace meta_detail
+
+		template <typename T, template <typename...> class Templ>
+		using is_specialization_of = meta_detail::is_specialization_of<std::remove_cv_t<T>, Templ>;
+
+		template <typename T, template <typename...> class Templ>
+		inline constexpr bool is_specialization_of_v = is_specialization_of<std::remove_cv_t<T>, Templ>::value;
+
+		template <typename T>
+		struct identity {
+			typedef T type;
+		};
+
+		template <typename T>
+		using identity_t = typename identity<T>::type;
+
+		template <typename T>
+		using is_builtin_type = std::integral_constant<bool, std::is_arithmetic<T>::value || std::is_pointer<T>::value || std::is_array<T>::value>;
+
+	} // namespace meta
+} // namespace sol
+
+// end of sol/base_traits.hpp
+
+#include <tuple>
+#include <cstddef>
+
+namespace sol {
+	namespace detail {
+		using swallow = std::initializer_list<int>;
+	} // namespace detail
+
+	namespace meta {
+		template <typename T>
+		using is_tuple = is_specialization_of<T, std::tuple>;
+
+		template <typename T>
+		constexpr inline bool is_tuple_v = is_tuple<T>::value;
+
+		namespace detail {
+			template <typename... Args>
+			struct tuple_types_ { typedef types<Args...> type; };
+
+			template <typename... Args>
+			struct tuple_types_<std::tuple<Args...>> { typedef types<Args...> type; };
+		} // namespace detail
+
+		template <typename... Args>
+		using tuple_types = typename detail::tuple_types_<Args...>::type;
+
+		template <typename Arg>
+		struct pop_front_type;
+
+		template <typename Arg>
+		using pop_front_type_t = typename pop_front_type<Arg>::type;
+
+		template <typename... Args>
+		struct pop_front_type<types<Args...>> {
+			typedef void front_type;
+			typedef types<Args...> type;
+		};
+
+		template <typename Arg, typename... Args>
+		struct pop_front_type<types<Arg, Args...>> {
+			typedef Arg front_type;
+			typedef types<Args...> type;
+		};
+
+		template <std::size_t N, typename Tuple>
+		using tuple_element = std::tuple_element<N, std::remove_reference_t<Tuple>>;
+
+		template <std::size_t N, typename Tuple>
+		using tuple_element_t = std::tuple_element_t<N, std::remove_reference_t<Tuple>>;
+
+		template <std::size_t N, typename Tuple>
+		using unqualified_tuple_element = unqualified<tuple_element_t<N, Tuple>>;
+
+		template <std::size_t N, typename Tuple>
+		using unqualified_tuple_element_t = unqualified_t<tuple_element_t<N, Tuple>>;
+
+	} // namespace meta
+} // namespace sol
+
+// end of sol/tuple.hpp
+
+// beginning of sol/bind_traits.hpp
+
+namespace sol { namespace meta {
+	namespace meta_detail {
+
+		template <class F>
+		struct check_deducible_signature {
+			struct nat {};
+			template <class G>
+			static auto test(int) -> decltype(&G::operator(), void());
+			template <class>
+			static auto test(...) -> nat;
+
+			using type = std::is_void<decltype(test<F>(0))>;
+		};
+	} // namespace meta_detail
+
+	template <class F>
+	struct has_deducible_signature : meta_detail::check_deducible_signature<F>::type {};
+
+	namespace meta_detail {
+
+		template <std::size_t I, typename T>
+		struct void_tuple_element : meta::tuple_element<I, T> {};
+
+		template <std::size_t I>
+		struct void_tuple_element<I, std::tuple<>> {
+			typedef void type;
+		};
+
+		template <std::size_t I, typename T>
+		using void_tuple_element_t = typename void_tuple_element<I, T>::type;
+
+		template <bool it_is_noexcept, bool has_c_variadic, typename T, typename R, typename... Args>
+		struct basic_traits {
+		private:
+			using first_type = meta::conditional_t<std::is_void<T>::value, int, T>&;
+
+		public:
+			inline static constexpr const bool is_noexcept = it_is_noexcept;
+			inline static constexpr bool is_member_function = std::is_void<T>::value;
+			inline static constexpr bool has_c_var_arg = has_c_variadic;
+			inline static constexpr std::size_t arity = sizeof...(Args);
+			inline static constexpr std::size_t free_arity = sizeof...(Args) + static_cast<std::size_t>(!std::is_void<T>::value);
+			typedef types<Args...> args_list;
+			typedef std::tuple<Args...> args_tuple;
+			typedef T object_type;
+			typedef R return_type;
+			typedef tuple_types<R> returns_list;
+			typedef R(function_type)(Args...);
+			typedef meta::conditional_t<std::is_void<T>::value, args_list, types<first_type, Args...>> free_args_list;
+			typedef meta::conditional_t<std::is_void<T>::value, R(Args...), R(first_type, Args...)> free_function_type;
+			typedef meta::conditional_t<std::is_void<T>::value, R (*)(Args...), R (*)(first_type, Args...)> free_function_pointer_type;
+			typedef std::remove_pointer_t<free_function_pointer_type> signature_type;
+			template <std::size_t i>
+			using arg_at = void_tuple_element_t<i, args_tuple>;
+		};
+
+		template <typename Signature, bool b = has_deducible_signature<Signature>::value>
+		struct fx_traits : basic_traits<false, false, void, void> {};
+
+		// Free Functions
+		template <typename R, typename... Args>
+		struct fx_traits<R(Args...), false> : basic_traits<false, false, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args...);
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R (*)(Args...), false> : basic_traits<false, false, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args...);
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R(Args..., ...), false> : basic_traits<false, true, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args..., ...);
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R (*)(Args..., ...), false> : basic_traits<false, true, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args..., ...);
+		};
+
+		// Member Functions
+		/* C-Style Variadics */
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...), false> : basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...);
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...), false> : basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...);
+		};
+
+		/* Const Volatile */
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const, false> : basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const, false> : basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const volatile, false> : basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const volatile;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const volatile, false> : basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const volatile;
+		};
+
+		/* Member Function Qualifiers */
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...)&, false> : basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) &;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...)&, false> : basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) &;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const&, false> : basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const&, false> : basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const volatile&, false> : basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const volatile&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const volatile&, false> : basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const volatile&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...)&&, false> : basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) &&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...)&&, false> : basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) &&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const&&, false> : basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const&&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const&&, false> : basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const&&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const volatile&&, false> : basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const volatile&&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const volatile&&, false> : basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const volatile&&;
+		};
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_)
+
+		template <typename R, typename... Args>
+		struct fx_traits<R(Args...) noexcept, false> : basic_traits<true, false, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args...) noexcept;
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R (*)(Args...) noexcept, false> : basic_traits<true, false, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args...) noexcept;
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R(Args..., ...) noexcept, false> : basic_traits<true, true, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args..., ...) noexcept;
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R (*)(Args..., ...) noexcept, false> : basic_traits<true, true, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args..., ...) noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) noexcept, false> : basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) noexcept, false> : basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) noexcept;
+		};
+
+		/* Const Volatile */
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const noexcept, false> : basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const noexcept, false> : basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const volatile noexcept, false> : basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const volatile noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const volatile noexcept, false> : basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const volatile noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) & noexcept, false> : basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) & noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) & noexcept, false> : basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) & noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const& noexcept, false> : basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const& noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const& noexcept, false> : basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const& noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const volatile& noexcept, false> : basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const volatile& noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const volatile& noexcept, false> : basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const volatile& noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) && noexcept, false> : basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) && noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) && noexcept, false> : basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) && noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const&& noexcept, false> : basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const&& noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const&& noexcept, false> : basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const&& noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const volatile&& noexcept, false> : basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const volatile&& noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const volatile&& noexcept, false> : basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const volatile&& noexcept;
+		};
+
+#endif // noexcept is part of a function's type
+
+#if SOL_IS_ON(SOL_COMPILER_VCXX_I_) && SOL_IS_ON(SOL_PLATFORM_X86_I_)
+		template <typename R, typename... Args>
+		struct fx_traits<R __stdcall(Args...), false> : basic_traits<false, false, void, R, Args...> {
+			typedef R(__stdcall* function_pointer_type)(Args...);
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R(__stdcall*)(Args...), false> : basic_traits<false, false, void, R, Args...> {
+			typedef R(__stdcall* function_pointer_type)(Args...);
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...), false> : basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...);
+		};
+
+		/* Const Volatile */
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const, false> : basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const volatile, false> : basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile;
+		};
+
+		/* Member Function Qualifiers */
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...)&, false> : basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) &;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const&, false> : basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const volatile&, false> : basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...)&&, false> : basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) &&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const&&, false> : basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const&&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const volatile&&, false> : basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile&&;
+		};
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_)
+
+		template <typename R, typename... Args>
+		struct fx_traits<R __stdcall(Args...) noexcept, false> : basic_traits<true, false, void, R, Args...> {
+			typedef R(__stdcall* function_pointer_type)(Args...) noexcept;
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R(__stdcall*)(Args...) noexcept, false> : basic_traits<true, false, void, R, Args...> {
+			typedef R(__stdcall* function_pointer_type)(Args...) noexcept;
+		};
+
+		/* __stdcall cannot be applied to functions with varargs*/
+		/*template <typename R, typename... Args>
+		struct fx_traits<__stdcall R(Args..., ...) noexcept, false> : basic_traits<true, true, void, R, Args...> {
+			typedef R(__stdcall* function_pointer_type)(Args..., ...) noexcept;
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R (__stdcall *)(Args..., ...) noexcept, false> : basic_traits<true, true, void, R, Args...> {
+			typedef R(__stdcall* function_pointer_type)(Args..., ...) noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) noexcept, false> : basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) noexcept, false> : basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) noexcept;
+		};*/
+
+		/* Const Volatile */
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const noexcept, false> : basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) const noexcept, false> : basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const volatile noexcept, false> : basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) const volatile noexcept, false> : basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const volatile noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) & noexcept, false> : basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) & noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) & noexcept, false> : basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) & noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const& noexcept, false> : basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const& noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) const& noexcept, false> : basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const& noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const volatile& noexcept, false> : basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile& noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) const volatile& noexcept, false> : basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const volatile& noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) && noexcept, false> : basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) && noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) && noexcept, false> : basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) && noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const&& noexcept, false> : basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const&& noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) const&& noexcept, false> : basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const&& noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const volatile&& noexcept, false> : basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile&& noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) const volatile&& noexcept, false> : basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const volatile&& noexcept;
+		};*/
+#endif // noexcept is part of a function's type
+#endif // __stdcall x86 VC++ bug
+
+		template <typename Signature>
+		struct fx_traits<Signature, true>
+		: public fx_traits<typename fx_traits<decltype(&Signature::operator())>::function_type, false> {};
+
+		template <typename Signature, bool b = std::is_member_object_pointer<Signature>::value>
+		struct callable_traits
+		: public fx_traits<std::decay_t<Signature>> {};
+
+		template <typename R, typename T>
+		struct callable_traits<R(T::*), true> {
+			typedef meta::conditional_t<std::is_array_v<R>, std::add_lvalue_reference_t<R>, R> return_type;
+			typedef return_type Arg;
+			typedef T object_type;
+			using signature_type = R(T::*);
+			inline static constexpr bool is_noexcept = false;
+			inline static constexpr bool is_member_function = false;
+			inline static constexpr std::size_t arity = 1;
+			inline static constexpr std::size_t free_arity = 2;
+			typedef std::tuple<Arg> args_tuple;
+			typedef types<Arg> args_list;
+			typedef types<T, Arg> free_args_list;
+			typedef meta::tuple_types<return_type> returns_list;
+			typedef return_type(function_type)(T&, return_type);
+			typedef return_type (*function_pointer_type)(T&, Arg);
+			typedef return_type (*free_function_pointer_type)(T&, Arg);
+			template <std::size_t i>
+			using arg_at = void_tuple_element_t<i, args_tuple>;
+		};
+
+	} // namespace meta_detail
+
+	template <typename Signature>
+	struct bind_traits : meta_detail::callable_traits<Signature> {};
+
+	template <typename Signature>
+	using function_args_t = typename bind_traits<Signature>::args_list;
+
+	template <typename Signature>
+	using function_signature_t = typename bind_traits<Signature>::signature_type;
+
+	template <typename Signature>
+	using function_return_t = typename bind_traits<Signature>::return_type;
+}} // namespace sol::meta
+
+// end of sol/bind_traits.hpp
+
+// beginning of sol/pointer_like.hpp
+
+#include <utility>
+#include <type_traits>
+
+namespace sol {
+
+	namespace meta {
+		namespace meta_detail {
+			template <typename T>
+			using is_dereferenceable_test = decltype(*std::declval<T>());
+
+			template <typename T>
+			using is_explicitly_dereferenceable_test = decltype(std::declval<T>().operator*());
+		}
+
+		template <typename T>
+		using is_pointer_like = std::integral_constant<bool, !std::is_array_v<T> && (std::is_pointer_v<T> || is_detected_v<meta_detail::is_explicitly_dereferenceable_test, T>)>;
+
+		template <typename T>
+		constexpr inline bool is_pointer_like_v = is_pointer_like<T>::value;
+	} // namespace meta
+
+	namespace detail {
+
+		template <typename T>
+		auto unwrap(T&& item) -> decltype(std::forward<T>(item)) {
+			return std::forward<T>(item);
+		}
+
+		template <typename T>
+		T& unwrap(std::reference_wrapper<T> arg) {
+			return arg.get();
+		}
+
+		template <typename T>
+		inline decltype(auto) deref(T&& item) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (meta::is_pointer_like_v<Tu>) {
+				return *std::forward<T>(item);
+			}
+			else {
+				return std::forward<T>(item);
+			}
+		}
+
+		template <typename T>
+		inline decltype(auto) deref_move_only(T&& item) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (meta::is_pointer_like_v<Tu> && !std::is_pointer_v<Tu> && !std::is_copy_constructible_v<Tu>) {
+				return *std::forward<T>(item);
+			}
+			else {
+				return std::forward<T>(item);
+			}
+		}
+
+		template <typename T>
+		inline T* ptr(T& val) {
+			return std::addressof(val);
+		}
+
+		template <typename T>
+		inline T* ptr(std::reference_wrapper<T> val) {
+			return std::addressof(val.get());
+		}
+
+		template <typename T>
+		inline T* ptr(T* val) {
+			return val;
+		}
+	} // namespace detail
+} // namespace sol
+
+// end of sol/pointer_like.hpp
+
+// beginning of sol/string_view.hpp
+
+#include <cstddef>
+#include <string>
+#include <string_view>
+#include <functional>
+
+namespace sol {
+	template <typename C, typename T = std::char_traits<C>>
+	using basic_string_view = std::basic_string_view<C, T>;
+
+	typedef std::string_view string_view;
+	typedef std::wstring_view wstring_view;
+	typedef std::u16string_view u16string_view;
+	typedef std::u32string_view u32string_view;
+	typedef std::hash<std::string_view> string_view_hash;
+} // namespace sol
+
+// end of sol/string_view.hpp
+
+#include <type_traits>
+#include <cstdint>
+#include <memory>
+#include <functional>
+#include <array>
+#include <iterator>
+#include <iosfwd>
+#if SOL_IS_ON(SOL_STD_VARIANT_I_)
+#include <variant>
+#endif // variant is weird on XCode, thanks XCode
+
+namespace sol { namespace meta {
+	template <typename T>
+	struct unwrapped {
+		typedef T type;
+	};
+
+	template <typename T>
+	struct unwrapped<std::reference_wrapper<T>> {
+		typedef T type;
+	};
+
+	template <typename T>
+	using unwrapped_t = typename unwrapped<T>::type;
+
+	template <typename T>
+	struct unwrap_unqualified : unwrapped<unqualified_t<T>> {};
+
+	template <typename T>
+	using unwrap_unqualified_t = typename unwrap_unqualified<T>::type;
+
+	template <typename T>
+	struct remove_member_pointer;
+
+	template <typename R, typename T>
+	struct remove_member_pointer<R T::*> {
+		typedef R type;
+	};
+
+	template <typename R, typename T>
+	struct remove_member_pointer<R T::*const> {
+		typedef R type;
+	};
+
+	template <typename T>
+	using remove_member_pointer_t = remove_member_pointer<T>;
+
+	template <typename T, typename...>
+	struct all_same : std::true_type {};
+
+	template <typename T, typename U, typename... Args>
+	struct all_same<T, U, Args...> : std::integral_constant<bool, std::is_same<T, U>::value && all_same<T, Args...>::value> {};
+
+	template <typename T, typename...>
+	struct any_same : std::false_type {};
+
+	template <typename T, typename U, typename... Args>
+	struct any_same<T, U, Args...> : std::integral_constant<bool, std::is_same<T, U>::value || any_same<T, Args...>::value> {};
+
+	template <typename T, typename... Args>
+	constexpr inline bool any_same_v = any_same<T, Args...>::value;
+
+	template <bool B>
+	using boolean = std::integral_constant<bool, B>;
+
+	template <bool B>
+	constexpr inline bool boolean_v = boolean<B>::value;
+
+	template <typename T>
+	using neg = boolean<!T::value>;
+
+	template <typename T>
+	constexpr inline bool neg_v = neg<T>::value;
+
+	template <typename... Args>
+	struct all : boolean<true> {};
+
+	template <typename T, typename... Args>
+	struct all<T, Args...> : std::conditional_t<T::value, all<Args...>, boolean<false>> {};
+
+	template <typename... Args>
+	struct any : boolean<false> {};
+
+	template <typename T, typename... Args>
+	struct any<T, Args...> : std::conditional_t<T::value, boolean<true>, any<Args...>> {};
+
+	template <typename T, typename... Args>
+	constexpr inline bool all_v = all<T, Args...>::value;
+
+	template <typename T, typename... Args>
+	constexpr inline bool any_v = any<T, Args...>::value;
+
+	enum class enable_t { _ };
+
+	constexpr const auto enabler = enable_t::_;
+
+	template <bool value, typename T = void>
+	using disable_if_t = std::enable_if_t<!value, T>;
+
+	template <typename... Args>
+	using enable = std::enable_if_t<all<Args...>::value, enable_t>;
+
+	template <typename... Args>
+	using disable = std::enable_if_t<neg<all<Args...>>::value, enable_t>;
+
+	template <typename... Args>
+	using enable_any = std::enable_if_t<any<Args...>::value, enable_t>;
+
+	template <typename... Args>
+	using disable_any = std::enable_if_t<neg<any<Args...>>::value, enable_t>;
+
+	template <typename V, typename... Vs>
+	struct find_in_pack_v : boolean<false> {};
+
+	template <typename V, typename Vs1, typename... Vs>
+	struct find_in_pack_v<V, Vs1, Vs...> : any<boolean<(V::value == Vs1::value)>, find_in_pack_v<V, Vs...>> {};
+
+	namespace meta_detail {
+		template <std::size_t I, typename T, typename... Args>
+		struct index_in_pack : std::integral_constant<std::size_t, SIZE_MAX> {};
+
+		template <std::size_t I, typename T, typename T1, typename... Args>
+		struct index_in_pack<I, T, T1, Args...>
+		: conditional_t<std::is_same<T, T1>::value, std::integral_constant<std::ptrdiff_t, I>, index_in_pack<I + 1, T, Args...>> {};
+	} // namespace meta_detail
+
+	template <typename T, typename... Args>
+	struct index_in_pack : meta_detail::index_in_pack<0, T, Args...> {};
+
+	template <typename T, typename List>
+	struct index_in : meta_detail::index_in_pack<0, T, List> {};
+
+	template <typename T, typename... Args>
+	struct index_in<T, types<Args...>> : meta_detail::index_in_pack<0, T, Args...> {};
+
+	template <std::size_t I, typename... Args>
+	struct at_in_pack {};
+
+	template <std::size_t I, typename... Args>
+	using at_in_pack_t = typename at_in_pack<I, Args...>::type;
+
+	template <std::size_t I, typename Arg, typename... Args>
+	struct at_in_pack<I, Arg, Args...> : std::conditional<I == 0, Arg, at_in_pack_t<I - 1, Args...>> {};
+
+	template <typename Arg, typename... Args>
+	struct at_in_pack<0, Arg, Args...> {
+		typedef Arg type;
+	};
+
+	namespace meta_detail {
+		template <typename, typename TI>
+		using on_even = meta::boolean<(TI::value % 2) == 0>;
+
+		template <typename, typename TI>
+		using on_odd = meta::boolean<(TI::value % 2) == 1>;
+
+		template <typename, typename>
+		using on_always = std::true_type;
+
+		template <template <typename...> class When, std::size_t Limit, std::size_t I, template <typename...> class Pred, typename... Ts>
+		struct count_when_for_pack : std::integral_constant<std::size_t, 0> {};
+		template <template <typename...> class When, std::size_t Limit, std::size_t I, template <typename...> class Pred, typename T, typename... Ts>
+			          struct count_when_for_pack<When, Limit, I, Pred, T, Ts...> : conditional_t < sizeof...(Ts)
+			     == 0
+			|| Limit<2, std::integral_constant<std::size_t, I + static_cast<std::size_t>(Limit != 0 && Pred<T>::value)>,
+			     count_when_for_pack<When, Limit - static_cast<std::size_t>(When<T, std::integral_constant<std::size_t, I>>::value),
+			          I + static_cast<std::size_t>(When<T, std::integral_constant<std::size_t, I>>::value&& Pred<T>::value), Pred, Ts...>> {};
+	} // namespace meta_detail
+
+	template <template <typename...> class Pred, typename... Ts>
+	struct count_for_pack : meta_detail::count_when_for_pack<meta_detail::on_always, sizeof...(Ts), 0, Pred, Ts...> {};
+
+	template <template <typename...> class Pred, typename... Ts>
+	inline constexpr std::size_t count_for_pack_v = count_for_pack<Pred, Ts...>::value;
+
+	template <template <typename...> class Pred, typename List>
+	struct count_for;
+
+	template <template <typename...> class Pred, typename... Args>
+	struct count_for<Pred, types<Args...>> : count_for_pack<Pred, Args...> {};
+
+	template <std::size_t Limit, template <typename...> class Pred, typename... Ts>
+	struct count_for_to_pack : meta_detail::count_when_for_pack<meta_detail::on_always, Limit, 0, Pred, Ts...> {};
+
+	template <std::size_t Limit, template <typename...> class Pred, typename... Ts>
+	inline constexpr std::size_t count_for_to_pack_v = count_for_to_pack<Limit, Pred, Ts...>::value;
+
+	template <template <typename...> class When, std::size_t Limit, template <typename...> class Pred, typename... Ts>
+	struct count_when_for_to_pack : meta_detail::count_when_for_pack<When, Limit, 0, Pred, Ts...> {};
+
+	template <template <typename...> class When, std::size_t Limit, template <typename...> class Pred, typename... Ts>
+	inline constexpr std::size_t count_when_for_to_pack_v = count_when_for_to_pack<When, Limit, Pred, Ts...>::value;
+
+	template <template <typename...> class Pred, typename... Ts>
+	using count_even_for_pack = count_when_for_to_pack<meta_detail::on_even, sizeof...(Ts), Pred, Ts...>;
+
+	template <template <typename...> class Pred, typename... Ts>
+	inline constexpr std::size_t count_even_for_pack_v = count_even_for_pack<Pred, Ts...>::value;
+
+	template <template <typename...> class Pred, typename... Ts>
+	using count_odd_for_pack = count_when_for_to_pack<meta_detail::on_odd, sizeof...(Ts), Pred, Ts...>;
+
+	template <template <typename...> class Pred, typename... Ts>
+	inline constexpr std::size_t count_odd_for_pack_v = count_odd_for_pack<Pred, Ts...>::value;
+
+	template <typename... Args>
+	struct return_type {
+		typedef std::tuple<Args...> type;
+	};
+
+	template <typename T>
+	struct return_type<T> {
+		typedef T type;
+	};
+
+	template <>
+	struct return_type<> {
+		typedef void type;
+	};
+
+	template <typename... Args>
+	using return_type_t = typename return_type<Args...>::type;
+
+	namespace meta_detail {
+		template <typename>
+		struct always_true : std::true_type {};
+		struct is_invokable_tester {
+			template <typename Fun, typename... Args>
+			static always_true<decltype(std::declval<Fun>()(std::declval<Args>()...))> test(int);
+			template <typename...>
+			static std::false_type test(...);
+		};
+	} // namespace meta_detail
+
+	template <typename T>
+	struct is_invokable;
+	template <typename Fun, typename... Args>
+	struct is_invokable<Fun(Args...)> : decltype(meta_detail::is_invokable_tester::test<Fun, Args...>(0)) {};
+
+	namespace meta_detail {
+
+		template <typename T, typename = void>
+		struct is_callable : std::is_function<std::remove_pointer_t<T>> {};
+
+		template <typename T>
+		struct is_callable<T,
+			std::enable_if_t<std::is_final<unqualified_t<T>>::value && std::is_class<unqualified_t<T>>::value
+			     && std::is_same<decltype(void(&T::operator())), void>::value>> {};
+
+		template <typename T>
+		struct is_callable<T,
+			std::enable_if_t<!std::is_final<unqualified_t<T>>::value && std::is_class<unqualified_t<T>>::value
+			     && std::is_destructible<unqualified_t<T>>::value>> {
+			struct F {
+				void operator()() {};
+			};
+			struct Derived : T, F {};
+			template <typename U, U>
+			struct Check;
+
+			template <typename V>
+			static sfinae_no_t test(Check<void (F::*)(), &V::operator()>*);
+
+			template <typename>
+			static sfinae_yes_t test(...);
+
+			static constexpr bool value = std::is_same_v<decltype(test<Derived>(0)), sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct is_callable<T,
+			std::enable_if_t<!std::is_final<unqualified_t<T>>::value && std::is_class<unqualified_t<T>>::value
+			     && !std::is_destructible<unqualified_t<T>>::value>> {
+			struct F {
+				void operator()() {};
+			};
+			struct Derived : T, F {
+				~Derived() = delete;
+			};
+			template <typename U, U>
+			struct Check;
+
+			template <typename V>
+			static sfinae_no_t test(Check<void (F::*)(), &V::operator()>*);
+
+			template <typename>
+			static sfinae_yes_t test(...);
+
+			static constexpr bool value = std::is_same_v<decltype(test<Derived>(0)), sfinae_yes_t>;
+		};
+
+		struct has_begin_end_impl {
+			template <typename T, typename U = unqualified_t<T>, typename B = decltype(std::declval<U&>().begin()),
+				typename E = decltype(std::declval<U&>().end())>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		struct has_key_type_impl {
+			template <typename T, typename U = unqualified_t<T>, typename V = typename U::key_type>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		struct has_key_comp_impl {
+			template <typename T, typename V = decltype(std::declval<unqualified_t<T>>().key_comp())>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		struct has_load_factor_impl {
+			template <typename T, typename V = decltype(std::declval<unqualified_t<T>>().load_factor())>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		struct has_mapped_type_impl {
+			template <typename T, typename V = typename unqualified_t<T>::mapped_type>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		struct has_value_type_impl {
+			template <typename T, typename V = typename unqualified_t<T>::value_type>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		struct has_iterator_impl {
+			template <typename T, typename V = typename unqualified_t<T>::iterator>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		struct has_key_value_pair_impl {
+			template <typename T, typename U = unqualified_t<T>, typename V = typename U::value_type, typename F = decltype(std::declval<V&>().first),
+				typename S = decltype(std::declval<V&>().second)>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		template <typename T>
+		struct has_push_back_test {
+		private:
+			template <typename C>
+			static sfinae_yes_t test(decltype(std::declval<C>().push_back(std::declval<std::add_rvalue_reference_t<typename C::value_type>>()))*);
+			template <typename C>
+			static sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_insert_test {
+		private:
+			template <typename C>
+			static sfinae_yes_t test(decltype(std::declval<C>().insert(std::declval<std::add_rvalue_reference_t<typename C::const_iterator>>(),
+				std::declval<std::add_rvalue_reference_t<typename C::value_type>>()))*);
+			template <typename C>
+			static sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_insert_after_test {
+		private:
+			template <typename C>
+			static sfinae_yes_t test(decltype(std::declval<C>().insert_after(std::declval<std::add_rvalue_reference_t<typename C::const_iterator>>(),
+				std::declval<std::add_rvalue_reference_t<typename C::value_type>>()))*);
+			template <typename C>
+			static sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_size_test {
+		private:
+			template <typename C>
+			static sfinae_yes_t test(decltype(std::declval<C>().size())*);
+			template <typename C>
+			static sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_max_size_test {
+		private:
+			template <typename C>
+			static sfinae_yes_t test(decltype(std::declval<C>().max_size())*);
+			template <typename C>
+			static sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_to_string_test {
+		private:
+			template <typename C>
+			static sfinae_yes_t test(decltype(std::declval<C>().to_string())*);
+			template <typename C>
+			static sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), sfinae_yes_t>;
+		};
+
+		template <typename T, typename U, typename = void>
+		class supports_op_less_test : public std::false_type {};
+		template <typename T, typename U>
+		class supports_op_less_test<T, U, void_t<decltype(std::declval<T&>() < std::declval<U&>())>>
+		: public std::integral_constant<bool,
+			  !is_specialization_of_v<unqualified_t<T>, std::variant> && !is_specialization_of_v<unqualified_t<U>, std::variant>> {};
+
+		template <typename T, typename U, typename = void>
+		class supports_op_equal_test : public std::false_type {};
+		template <typename T, typename U>
+		class supports_op_equal_test<T, U, void_t<decltype(std::declval<T&>() == std::declval<U&>())>>
+		: public std::integral_constant<bool,
+			  !is_specialization_of_v<unqualified_t<T>, std::variant> && !is_specialization_of_v<unqualified_t<U>, std::variant>> {};
+
+		template <typename T, typename U, typename = void>
+		class supports_op_less_equal_test : public std::false_type {};
+		template <typename T, typename U>
+		class supports_op_less_equal_test<T, U, void_t<decltype(std::declval<T&>() <= std::declval<U&>())>>
+		: public std::integral_constant<bool,
+			  !is_specialization_of_v<unqualified_t<T>, std::variant> && !is_specialization_of_v<unqualified_t<U>, std::variant>> {};
+
+		template <typename T, typename U, typename = void>
+		class supports_op_left_shift_test : public std::false_type {};
+		template <typename T, typename U>
+		class supports_op_left_shift_test<T, U, void_t<decltype(std::declval<T&>() << std::declval<U&>())>> : public std::true_type {};
+
+		template <typename T, typename = void>
+		class supports_adl_to_string_test : public std::false_type {};
+		template <typename T>
+		class supports_adl_to_string_test<T, void_t<decltype(to_string(std::declval<const T&>()))>> : public std::true_type {};
+
+		template <typename T, bool b>
+		struct is_matched_lookup_impl : std::false_type {};
+		template <typename T>
+		struct is_matched_lookup_impl<T, true> : std::is_same<typename T::key_type, typename T::value_type> {};
+
+		template <typename T>
+		using non_void_t = meta::conditional_t<std::is_void_v<T>, ::sol::detail::unchecked_t, T>;
+	} // namespace meta_detail
+
+	template <typename T, typename U = T>
+	class supports_op_less : public meta_detail::supports_op_less_test<T, U> {};
+
+	template <typename T, typename U = T>
+	class supports_op_equal : public meta_detail::supports_op_equal_test<T, U> {};
+
+	template <typename T, typename U = T>
+	class supports_op_less_equal : public meta_detail::supports_op_less_equal_test<T, U> {};
+
+	template <typename T, typename U = T>
+	class supports_op_left_shift : public meta_detail::supports_op_left_shift_test<T, U> {};
+
+	template <typename T>
+	class supports_adl_to_string : public meta_detail::supports_adl_to_string_test<T> {};
+
+	template <typename T>
+	class supports_to_string_member : public meta::boolean<meta_detail::has_to_string_test<meta_detail::non_void_t<T>>::value> {};
+
+	template <typename T>
+	using is_callable = boolean<meta_detail::is_callable<T>::value>;
+
+	template <typename T>
+	constexpr inline bool is_callable_v = is_callable<T>::value;
+
+	template <typename T>
+	struct has_begin_end : decltype(meta_detail::has_begin_end_impl::test<T>(0)) {};
+
+	template <typename T>
+	constexpr inline bool has_begin_end_v = has_begin_end<T>::value;
+
+	template <typename T>
+	struct has_key_value_pair : decltype(meta_detail::has_key_value_pair_impl::test<T>(0)) {};
+
+	template <typename T>
+	struct has_key_type : decltype(meta_detail::has_key_type_impl::test<T>(0)) {};
+
+	template <typename T>
+	struct has_key_comp : decltype(meta_detail::has_key_comp_impl::test<T>(0)) {};
+
+	template <typename T>
+	struct has_load_factor : decltype(meta_detail::has_load_factor_impl::test<T>(0)) {};
+
+	template <typename T>
+	struct has_mapped_type : decltype(meta_detail::has_mapped_type_impl::test<T>(0)) {};
+
+	template <typename T>
+	struct has_iterator : decltype(meta_detail::has_iterator_impl::test<T>(0)) {};
+
+	template <typename T>
+	struct has_value_type : decltype(meta_detail::has_value_type_impl::test<T>(0)) {};
+
+	template <typename T>
+	using has_push_back = meta::boolean<meta_detail::has_push_back_test<T>::value>;
+
+	template <typename T>
+	using has_max_size = meta::boolean<meta_detail::has_max_size_test<T>::value>;
+
+	template <typename T>
+	using has_insert = meta::boolean<meta_detail::has_insert_test<T>::value>;
+
+	template <typename T>
+	using has_insert_after = meta::boolean<meta_detail::has_insert_after_test<T>::value>;
+
+	template <typename T>
+	using has_size = meta::boolean<meta_detail::has_size_test<T>::value>;
+
+	template <typename T>
+	using is_associative = meta::all<has_key_type<T>, has_key_value_pair<T>, has_mapped_type<T>>;
+
+	template <typename T>
+	using is_lookup = meta::all<has_key_type<T>, has_value_type<T>>;
+
+	template <typename T>
+	using is_ordered = meta::all<has_key_comp<T>, meta::neg<has_load_factor<T>>>;
+
+	template <typename T>
+	using is_matched_lookup = meta_detail::is_matched_lookup_impl<T, is_lookup<T>::value>;
+
+	template <typename T>
+	using is_initializer_list = meta::is_specialization_of<T, std::initializer_list>;
+
+	template <typename T>
+	constexpr inline bool is_initializer_list_v = is_initializer_list<T>::value;
+
+	template <typename T, typename CharT = char>
+	using is_string_literal_array_of = boolean<std::is_array_v<T> && std::is_same_v<std::remove_all_extents_t<T>, CharT>>;
+
+	template <typename T, typename CharT = char>
+	constexpr inline bool is_string_literal_array_of_v = is_string_literal_array_of<T, CharT>::value;
+
+	template <typename T>
+	using is_string_literal_array = boolean<std::is_array_v<T> && any_same_v<std::remove_all_extents_t<T>, char, char16_t, char32_t, wchar_t>>;
+
+	template <typename T>
+	constexpr inline bool is_string_literal_array_v = is_string_literal_array<T>::value;
+
+	template <typename T, typename CharT>
+	struct is_string_of : std::false_type {};
+
+	template <typename CharT, typename CharTargetT, typename TraitsT, typename AllocT>
+	struct is_string_of<std::basic_string<CharT, TraitsT, AllocT>, CharTargetT> : std::is_same<CharT, CharTargetT> {};
+
+	template <typename T, typename CharT>
+	constexpr inline bool is_string_of_v = is_string_of<T, CharT>::value;
+
+	template <typename T, typename CharT>
+	struct is_string_view_of : std::false_type {};
+
+	template <typename CharT, typename CharTargetT, typename TraitsT>
+	struct is_string_view_of<std::basic_string_view<CharT, TraitsT>, CharTargetT> : std::is_same<CharT, CharTargetT> {};
+
+	template <typename T, typename CharT>
+	constexpr inline bool is_string_view_of_v = is_string_view_of<T, CharT>::value;
+
+	template <typename T>
+	using is_string_like
+		= meta::boolean<is_specialization_of_v<T, std::basic_string> || is_specialization_of_v<T, std::basic_string_view> || is_string_literal_array_v<T>>;
+
+	template <typename T>
+	constexpr inline bool is_string_like_v = is_string_like<T>::value;
+
+	template <typename T, typename CharT = char>
+	using is_string_constructible = meta::boolean<
+		is_string_literal_array_of_v<T,
+		     CharT> || std::is_same_v<T, const CharT*> || std::is_same_v<T, CharT> || is_string_of_v<T, CharT> || std::is_same_v<T, std::initializer_list<CharT>> || is_string_view_of_v<T, CharT>>;
+
+	template <typename T, typename CharT = char>
+	constexpr inline bool is_string_constructible_v = is_string_constructible<T, CharT>::value;
+
+	template <typename T>
+	using is_string_like_or_constructible = meta::boolean<is_string_like_v<T> || is_string_constructible_v<T>>;
+
+	template <typename T>
+	struct is_pair : std::false_type {};
+
+	template <typename T1, typename T2>
+	struct is_pair<std::pair<T1, T2>> : std::true_type {};
+
+	template <typename T, typename Char>
+	using is_c_str_of = any<std::is_same<T, const Char*>, std::is_same<T, Char const* const>, std::is_same<T, Char*>, is_string_of<T, Char>,
+		is_string_literal_array_of<T, Char>>;
+
+	template <typename T, typename Char>
+	constexpr inline bool is_c_str_of_v = is_c_str_of<T, Char>::value;
+
+	template <typename T>
+	using is_c_str = is_c_str_of<T, char>;
+
+	template <typename T>
+	constexpr inline bool is_c_str_v = is_c_str<T>::value;
+
+	template <typename T>
+	struct is_move_only : all<neg<std::is_reference<T>>, neg<std::is_copy_constructible<unqualified_t<T>>>, std::is_move_constructible<unqualified_t<T>>> {};
+
+	template <typename T>
+	using is_not_move_only = neg<is_move_only<T>>;
+
+	namespace meta_detail {
+		template <typename T>
+		decltype(auto) force_tuple(T&& x) {
+			if constexpr (meta::is_specialization_of_v<meta::unqualified_t<T>, std::tuple>) {
+				return std::forward<T>(x);
+			}
+			else {
+				return std::tuple<T>(std::forward<T>(x));
+			}
+		}
+	} // namespace meta_detail
+
+	template <typename... X>
+	decltype(auto) tuplefy(X&&... x) {
+		return std::tuple_cat(meta_detail::force_tuple(std::forward<X>(x))...);
+	}
+
+	template <typename T, typename = void>
+	struct iterator_tag {
+		using type = std::input_iterator_tag;
+	};
+
+	template <typename T>
+	struct iterator_tag<T, conditional_t<false, typename std::iterator_traits<T>::iterator_category, void>> {
+		using type = typename std::iterator_traits<T>::iterator_category;
+	};
+
+}} // namespace sol::meta
+
+// end of sol/traits.hpp
+
+namespace sol {
+	namespace detail {
+		const bool default_safe_function_calls =
+#if SOL_IS_ON(SOL_SAFE_FUNCTION_CALLS_I_)
+		     true;
+#else
+		     false;
+#endif
+	} // namespace detail
+
+	namespace meta { namespace meta_detail {
+	}} // namespace meta::meta_detail
+
+	namespace stack { namespace stack_detail {
+		using undefined_method_func = void (*)(stack_reference);
+
+		template <typename T>
+		void set_undefined_methods_on(stack_reference);
+
+		struct undefined_metatable;
+	}} // namespace stack::stack_detail
+} // namespace sol
+
+#endif // SOL_FORWARD_DETAIL_HPP
+// end of sol/forward_detail.hpp
+
+// beginning of sol/bytecode.hpp
+
+// beginning of sol/compatibility.hpp
+
+// beginning of sol/compatibility/lua_version.hpp
+
+#if SOL_IS_ON(SOL_USE_CXX_LUA_I_)
+	#include <lua.h>
+	#include <lualib.h>
+	#include <lauxlib.h>
+#elif SOL_IS_ON(SOL_USE_LUA_HPP_I_)
+	#include <lua.hpp>
+#else
+	extern "C" {
+		#include <lua.h>
+		#include <lauxlib.h>
+		#include <lualib.h>
+	}
+#endif // C++ Mangling for Lua vs. Not
+
+#if defined(SOL_LUAJIT)
+	#if (SOL_LUAJIT != 0)
+		#define SOL_USE_LUAJIT_I_ SOL_ON
+	#else
+		#define SOL_USE_LUAJIT_I_ SOL_OFF
+	#endif
+#elif defined(LUAJIT_VERSION)
+	#define SOL_USE_LUAJIT_I_ SOL_OFF
+#else
+	#define SOL_USE_LUAJIT_I_ SOL_DEFAULT_OFF
+#endif // luajit
+
+#if SOL_IS_ON(SOL_USE_CXX_LUAJIT_I_)
+	#include <luajit.h>
+#elif SOL_IS_ON(SOL_USE_LUAJIT_I_)
+	extern "C" {
+		#include <luajit.h>
+	}
+#endif // C++ LuaJIT ... whatever that means
+
+#if defined(SOL_LUAJIT_VERSION)
+	#define SOL_LUAJIT_VERSION_I_ SOL_LUAJIT_VERSION
+#elif SOL_IS_ON(SOL_USE_LUAJIT_I_)
+	#define SOL_LUAJIT_VERSION_I_ LUAJIT_VERSION_NUM
+#else
+	#define SOL_LUAJIT_VERSION_I_ 0
+#endif
+
+#if defined(MOONJIT_VERSION)
+	#define SOL_USE_MOONJIT_I_ SOL_ON
+#else
+	#define SOL_USE_MOONJIT_I_ SOL_OFF
+#endif
+
+#if !defined(SOL_LUA_VERSION)
+	#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 502
+		#define SOL_LUA_VERSION LUA_VERSION_NUM
+	#elif defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 501
+		#define SOL_LUA_VERSION LUA_VERSION_NUM
+	#elif !defined(LUA_VERSION_NUM) || !(LUA_VERSION_NUM)
+		// Definitely 5.0
+		#define SOL_LUA_VERSION 500
+	#else
+		// ??? Not sure, assume latest?
+		#define SOL_LUA_VERSION 504
+	#endif // Lua Version 503, 502, 501 || luajit, 500
+#endif // SOL_LUA_VERSION
+
+#if defined(SOL_LUA_VERSION)
+	#define SOL_LUA_VESION_I_ SOL_LUA_VERSION
+#else
+	#define SOL_LUA_VESION_I_ 504
+#endif
+
+#if defined(SOL_EXCEPTIONS_ALWAYS_UNSAFE)
+	#if (SOL_EXCEPTIONS_ALWAYS_UNSAFE != 0)
+		#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_OFF
+	#else
+		#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_ON
+	#endif
+#elif defined(SOL_EXCEPTIONS_SAFE_PROPAGATION)
+	#if (SOL_EXCEPTIONS_SAFE_PROPAGATION != 0)
+		#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_ON
+	#else
+		#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_OFF
+	#endif
+#elif SOL_LUAJIT_VERSION_I_ >= 20100
+	// LuaJIT 2.1.0-beta3 and better have exception support locked in for all platforms (mostly)
+	#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_DEFAULT_ON
+#elif SOL_LUAJIT_VERSION_I_ >= 20000
+	// LuaJIT 2.0.x have exception support only on x64 builds
+	#if SOL_IS_ON(SOL_PLATFORM_X64_I_)
+		#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_OFF
+	#endif
+#else
+	// otherwise, there is no exception safety for
+	// shoving exceptions through Lua and errors should
+	// always be serialized
+	#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_DEFAULT_OFF
+#endif // LuaJIT beta 02.01.00 have better exception handling on all platforms since beta3
+
+#if defined(SOL_LUAJIT_USE_EXCEPTION_TRAMPOLINE)
+	#if (SOL_LUAJIT_USE_EXCEPTION_TRAMPOLINE != 0)
+		#define SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_ SOL_ON
+	#else
+		#define SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_OFF(SOL_PROPAGATE_EXCEPTIONS_I_) && SOL_IS_ON(SOL_USE_LUAJIT_I_)
+		#define SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_ SOL_ON
+	#else
+		#define SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_LUAL_STREAM_HAS_CLOSE_FUNCTION)
+	#if (SOL_LUAL_STREAM_HAS_CLOSE_FUNCTION != 0)
+		#define SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_ SOL_ON
+	#else
+		#define SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_OFF(SOL_USE_LUAJIT_I_) && (SOL_LUA_VERSION > 501)
+		#define SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_ SOL_ON
+	#else
+		#define SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+// end of sol/compatibility/lua_version.hpp
+
+#if SOL_IS_ON(SOL_USE_COMPATIBILITY_LAYER_I_)
+
+#if SOL_IS_ON(SOL_USE_CXX_LUA_I_) || SOL_IS_ON(SOL_USE_CXX_LUAJIT_I_)
+#ifndef COMPAT53_LUA_CPP
+#define COMPAT53_LUA_CPP 1
+#endif // Build Lua Compat layer as C++
+#endif
+#ifndef COMPAT53_INCLUDE_SOURCE
+#define COMPAT53_INCLUDE_SOURCE 1
+#endif // Build Compat Layer Inline
+
+// beginning of sol/compatibility/compat-5.3.h
+
+#ifndef KEPLER_PROJECT_COMPAT53_H_
+#define KEPLER_PROJECT_COMPAT53_H_
+
+#include <stddef.h>
+#include <limits.h>
+#include <string.h>
+#if defined(__cplusplus) && !defined(COMPAT53_LUA_CPP)
+extern "C" {
+#endif
+#include <lua.h>
+#include <lauxlib.h>
+#include <lualib.h>
+#if defined(__cplusplus) && !defined(COMPAT53_LUA_CPP)
+}
+#endif
+
+#ifndef COMPAT53_PREFIX
+/* we chose this name because many other lua bindings / libs have
+* their own compatibility layer, and that use the compat53 declaration
+* frequently, causing all kinds of linker / compiler issues
+*/
+#  define COMPAT53_PREFIX kp_compat53
+#endif // COMPAT53_PREFIX
+
+#ifndef COMPAT53_API
+#  if defined(COMPAT53_INCLUDE_SOURCE) && COMPAT53_INCLUDE_SOURCE
+#    if defined(__GNUC__) || defined(__clang__)
+#      define COMPAT53_API __attribute__((__unused__)) static inline 
+#    else
+#      define COMPAT53_API static inline 
+#    endif /* Clang/GCC */
+#  else /* COMPAT53_INCLUDE_SOURCE */
+/* we are not including source, so everything is extern */
+#      define COMPAT53_API extern
+#  endif /* COMPAT53_INCLUDE_SOURCE */
+#endif /* COMPAT53_PREFIX */
+
+#define COMPAT53_CONCAT_HELPER(a, b) a##b
+#define COMPAT53_CONCAT(a, b) COMPAT53_CONCAT_HELPER(a, b)
+
+/* declarations for Lua 5.1 */
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 501
+
+/* XXX not implemented:
+* lua_arith (new operators)
+* lua_upvalueid
+* lua_upvaluejoin
+* lua_version
+* lua_yieldk
+*/
+
+#ifndef LUA_OK
+#  define LUA_OK 0
+#endif
+#ifndef LUA_OPADD
+#  define LUA_OPADD 0
+#endif
+#ifndef LUA_OPSUB
+#  define LUA_OPSUB 1
+#endif
+#ifndef LUA_OPMUL
+#  define LUA_OPMUL 2
+#endif
+#ifndef LUA_OPDIV
+#  define LUA_OPDIV 3
+#endif
+#ifndef LUA_OPMOD
+#  define LUA_OPMOD 4
+#endif
+#ifndef LUA_OPPOW
+#  define LUA_OPPOW 5
+#endif
+#ifndef LUA_OPUNM
+#  define LUA_OPUNM 6
+#endif
+#ifndef LUA_OPEQ
+#  define LUA_OPEQ 0
+#endif
+#ifndef LUA_OPLT
+#  define LUA_OPLT 1
+#endif
+#ifndef LUA_OPLE
+#  define LUA_OPLE 2
+#endif
+
+/* LuaJIT/Lua 5.1 does not have the updated
+* error codes for thread status/function returns (but some patched versions do)
+* define it only if it's not found
+*/
+#if !defined(LUA_ERRGCMM)
+/* Use + 2 because in some versions of Lua (Lua 5.1)
+* LUA_ERRFILE is defined as (LUA_ERRERR+1)
+* so we need to avoid it (LuaJIT might have something at this
+* integer value too)
+*/
+#  define LUA_ERRGCMM (LUA_ERRERR + 2)
+#endif /* LUA_ERRGCMM define */
+
+#if !defined(MOONJIT_VERSION)
+typedef size_t lua_Unsigned;
+#endif
+
+typedef struct luaL_Buffer_53 {
+	luaL_Buffer b; /* make incorrect code crash! */
+	char *ptr;
+	size_t nelems;
+	size_t capacity;
+	lua_State *L2;
+} luaL_Buffer_53;
+#define luaL_Buffer luaL_Buffer_53
+
+/* In PUC-Rio 5.1, userdata is a simple FILE*
+* In LuaJIT, it's a struct where the first member is a FILE*
+* We can't support the `closef` member
+*/
+typedef struct luaL_Stream {
+	FILE *f;
+} luaL_Stream;
+
+#define lua_absindex COMPAT53_CONCAT(COMPAT53_PREFIX, _absindex)
+COMPAT53_API int lua_absindex(lua_State *L, int i);
+
+#define lua_arith COMPAT53_CONCAT(COMPAT53_PREFIX, _arith)
+COMPAT53_API void lua_arith(lua_State *L, int op);
+
+#define lua_compare COMPAT53_CONCAT(COMPAT53_PREFIX, _compare)
+COMPAT53_API int lua_compare(lua_State *L, int idx1, int idx2, int op);
+
+#define lua_copy COMPAT53_CONCAT(COMPAT53_PREFIX, _copy)
+COMPAT53_API void lua_copy(lua_State *L, int from, int to);
+
+#define lua_getuservalue(L, i) \
+  (lua_getfenv((L), (i)), lua_type((L), -1))
+#define lua_setuservalue(L, i) \
+  (luaL_checktype((L), -1, LUA_TTABLE), lua_setfenv((L), (i)))
+
+#define lua_len COMPAT53_CONCAT(COMPAT53_PREFIX, _len)
+COMPAT53_API void lua_len(lua_State *L, int i);
+
+#define lua_pushstring(L, s) \
+  (lua_pushstring((L), (s)), lua_tostring((L), -1))
+
+#define lua_pushlstring(L, s, len) \
+  ((((len) == 0) ? lua_pushlstring((L), "", 0) : lua_pushlstring((L), (s), (len))), lua_tostring((L), -1))
+
+#ifndef luaL_newlibtable
+#  define luaL_newlibtable(L, l) \
+  (lua_createtable((L), 0, sizeof((l))/sizeof(*(l))-1))
+#endif
+#ifndef luaL_newlib
+#  define luaL_newlib(L, l) \
+  (luaL_newlibtable((L), (l)), luaL_register((L), NULL, (l)))
+#endif
+
+#ifndef lua_pushglobaltable
+#  define lua_pushglobaltable(L) \
+  lua_pushvalue((L), LUA_GLOBALSINDEX)
+#endif
+#define lua_rawgetp COMPAT53_CONCAT(COMPAT53_PREFIX, _rawgetp)
+COMPAT53_API int lua_rawgetp(lua_State *L, int i, const void *p);
+
+#define lua_rawsetp COMPAT53_CONCAT(COMPAT53_PREFIX, _rawsetp)
+COMPAT53_API void lua_rawsetp(lua_State *L, int i, const void *p);
+
+#define lua_rawlen(L, i) lua_objlen((L), (i))
+
+#define lua_tointeger(L, i) lua_tointegerx((L), (i), NULL)
+
+#define lua_tonumberx COMPAT53_CONCAT(COMPAT53_PREFIX, _tonumberx)
+COMPAT53_API lua_Number lua_tonumberx(lua_State *L, int i, int *isnum);
+
+#define luaL_checkversion COMPAT53_CONCAT(COMPAT53_PREFIX, L_checkversion)
+COMPAT53_API void luaL_checkversion(lua_State *L);
+
+#define lua_load COMPAT53_CONCAT(COMPAT53_PREFIX, _load_53)
+COMPAT53_API int lua_load(lua_State *L, lua_Reader reader, void *data, const char* source, const char* mode);
+
+#define luaL_loadfilex COMPAT53_CONCAT(COMPAT53_PREFIX, L_loadfilex)
+COMPAT53_API int luaL_loadfilex(lua_State *L, const char *filename, const char *mode);
+
+#define luaL_loadbufferx COMPAT53_CONCAT(COMPAT53_PREFIX, L_loadbufferx)
+COMPAT53_API int luaL_loadbufferx(lua_State *L, const char *buff, size_t sz, const char *name, const char *mode);
+
+#define luaL_checkstack COMPAT53_CONCAT(COMPAT53_PREFIX, L_checkstack_53)
+COMPAT53_API void luaL_checkstack(lua_State *L, int sp, const char *msg);
+
+#define luaL_getsubtable COMPAT53_CONCAT(COMPAT53_PREFIX, L_getsubtable)
+COMPAT53_API int luaL_getsubtable(lua_State* L, int i, const char *name);
+
+#define luaL_len COMPAT53_CONCAT(COMPAT53_PREFIX, L_len)
+COMPAT53_API lua_Integer luaL_len(lua_State *L, int i);
+
+#define luaL_setfuncs COMPAT53_CONCAT(COMPAT53_PREFIX, L_setfuncs)
+COMPAT53_API void luaL_setfuncs(lua_State *L, const luaL_Reg *l, int nup);
+
+#define luaL_setmetatable COMPAT53_CONCAT(COMPAT53_PREFIX, L_setmetatable)
+COMPAT53_API void luaL_setmetatable(lua_State *L, const char *tname);
+
+#define luaL_testudata COMPAT53_CONCAT(COMPAT53_PREFIX, L_testudata)
+COMPAT53_API void *luaL_testudata(lua_State *L, int i, const char *tname);
+
+#define luaL_traceback COMPAT53_CONCAT(COMPAT53_PREFIX, L_traceback)
+COMPAT53_API void luaL_traceback(lua_State *L, lua_State *L1, const char *msg, int level);
+
+#define luaL_fileresult COMPAT53_CONCAT(COMPAT53_PREFIX, L_fileresult)
+COMPAT53_API int luaL_fileresult(lua_State *L, int stat, const char *fname);
+
+#define luaL_execresult COMPAT53_CONCAT(COMPAT53_PREFIX, L_execresult)
+COMPAT53_API int luaL_execresult(lua_State *L, int stat);
+
+#define lua_callk(L, na, nr, ctx, cont) \
+  ((void)(ctx), (void)(cont), lua_call((L), (na), (nr)))
+#define lua_pcallk(L, na, nr, err, ctx, cont) \
+  ((void)(ctx), (void)(cont), lua_pcall((L), (na), (nr), (err)))
+
+#define lua_resume(L, from, nargs) \
+  ((void)(from), lua_resume((L), (nargs)))
+
+#define luaL_buffinit COMPAT53_CONCAT(COMPAT53_PREFIX, _buffinit_53)
+COMPAT53_API void luaL_buffinit(lua_State *L, luaL_Buffer_53 *B);
+
+#define luaL_prepbuffsize COMPAT53_CONCAT(COMPAT53_PREFIX, _prepbufsize_53)
+COMPAT53_API char *luaL_prepbuffsize(luaL_Buffer_53 *B, size_t s);
+
+#define luaL_addlstring COMPAT53_CONCAT(COMPAT53_PREFIX, _addlstring_53)
+COMPAT53_API void luaL_addlstring(luaL_Buffer_53 *B, const char *s, size_t l);
+
+#define luaL_addvalue COMPAT53_CONCAT(COMPAT53_PREFIX, _addvalue_53)
+COMPAT53_API void luaL_addvalue(luaL_Buffer_53 *B);
+
+#define luaL_pushresult COMPAT53_CONCAT(COMPAT53_PREFIX, _pushresult_53)
+COMPAT53_API void luaL_pushresult(luaL_Buffer_53 *B);
+
+#undef luaL_buffinitsize
+#define luaL_buffinitsize(L, B, s) \
+  (luaL_buffinit((L), (B)), luaL_prepbuffsize((B), (s)))
+
+#undef luaL_prepbuffer
+#define luaL_prepbuffer(B) \
+  luaL_prepbuffsize((B), LUAL_BUFFERSIZE)
+
+#undef luaL_addchar
+#define luaL_addchar(B, c) \
+  ((void)((B)->nelems < (B)->capacity || luaL_prepbuffsize((B), 1)), \
+   ((B)->ptr[(B)->nelems++] = (c)))
+
+#undef luaL_addsize
+#define luaL_addsize(B, s) \
+  ((B)->nelems += (s))
+
+#undef luaL_addstring
+#define luaL_addstring(B, s) \
+  luaL_addlstring((B), (s), strlen((s)))
+
+#undef luaL_pushresultsize
+#define luaL_pushresultsize(B, s) \
+  (luaL_addsize((B), (s)), luaL_pushresult((B)))
+
+#if defined(LUA_COMPAT_APIINTCASTS)
+#define lua_pushunsigned(L, n) \
+  lua_pushinteger((L), (lua_Integer)(n))
+#define lua_tounsignedx(L, i, is) \
+  ((lua_Unsigned)lua_tointegerx((L), (i), (is)))
+#define lua_tounsigned(L, i) \
+  lua_tounsignedx((L), (i), NULL)
+#define luaL_checkunsigned(L, a) \
+  ((lua_Unsigned)luaL_checkinteger((L), (a)))
+#define luaL_optunsigned(L, a, d) \
+  ((lua_Unsigned)luaL_optinteger((L), (a), (lua_Integer)(d)))
+#endif
+
+#endif /* Lua 5.1 only */
+
+/* declarations for Lua 5.1 and 5.2 */
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM <= 502
+
+typedef int lua_KContext;
+
+typedef int(*lua_KFunction)(lua_State *L, int status, lua_KContext ctx);
+
+#define lua_dump(L, w, d, s) \
+  ((void)(s), lua_dump((L), (w), (d)))
+
+#define lua_getfield(L, i, k) \
+  (lua_getfield((L), (i), (k)), lua_type((L), -1))
+
+#define lua_gettable(L, i) \
+  (lua_gettable((L), (i)), lua_type((L), -1))
+
+#define lua_geti COMPAT53_CONCAT(COMPAT53_PREFIX, _geti)
+COMPAT53_API int lua_geti(lua_State *L, int index, lua_Integer i);
+
+#define lua_isinteger COMPAT53_CONCAT(COMPAT53_PREFIX, _isinteger)
+COMPAT53_API int lua_isinteger(lua_State *L, int index);
+
+#define lua_tointegerx COMPAT53_CONCAT(COMPAT53_PREFIX, _tointegerx_53)
+COMPAT53_API lua_Integer lua_tointegerx(lua_State *L, int i, int *isnum);
+
+#define lua_numbertointeger(n, p) \
+  ((*(p) = (lua_Integer)(n)), 1)
+
+#define lua_rawget(L, i) \
+  (lua_rawget((L), (i)), lua_type((L), -1))
+
+#define lua_rawgeti(L, i, n) \
+  (lua_rawgeti((L), (i), (n)), lua_type((L), -1))
+
+#define lua_rotate COMPAT53_CONCAT(COMPAT53_PREFIX, _rotate)
+COMPAT53_API void lua_rotate(lua_State *L, int idx, int n);
+
+#define lua_seti COMPAT53_CONCAT(COMPAT53_PREFIX, _seti)
+COMPAT53_API void lua_seti(lua_State *L, int index, lua_Integer i);
+
+#define lua_stringtonumber COMPAT53_CONCAT(COMPAT53_PREFIX, _stringtonumber)
+COMPAT53_API size_t lua_stringtonumber(lua_State *L, const char *s);
+
+#define luaL_tolstring COMPAT53_CONCAT(COMPAT53_PREFIX, L_tolstring)
+COMPAT53_API const char *luaL_tolstring(lua_State *L, int idx, size_t *len);
+
+#define luaL_getmetafield(L, o, e) \
+  (luaL_getmetafield((L), (o), (e)) ? lua_type((L), -1) : LUA_TNIL)
+
+#define luaL_newmetatable(L, tn) \
+  (luaL_newmetatable((L), (tn)) ? (lua_pushstring((L), (tn)), lua_setfield((L), -2, "__name"), 1) : 0)
+
+#define luaL_requiref COMPAT53_CONCAT(COMPAT53_PREFIX, L_requiref_53)
+COMPAT53_API void luaL_requiref(lua_State *L, const char *modname,
+	lua_CFunction openf, int glb);
+
+#endif /* Lua 5.1 and Lua 5.2 */
+
+/* declarations for Lua 5.2 */
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 502
+
+/* XXX not implemented:
+* lua_isyieldable
+* lua_getextraspace
+* lua_arith (new operators)
+* lua_pushfstring (new formats)
+*/
+
+#define lua_getglobal(L, n) \
+  (lua_getglobal((L), (n)), lua_type((L), -1))
+
+#define lua_getuservalue(L, i) \
+  (lua_getuservalue((L), (i)), lua_type((L), -1))
+
+#define lua_pushlstring(L, s, len) \
+  (((len) == 0) ? lua_pushlstring((L), "", 0) : lua_pushlstring((L), (s), (len)))
+
+#define lua_rawgetp(L, i, p) \
+  (lua_rawgetp((L), (i), (p)), lua_type((L), -1))
+
+#define LUA_KFUNCTION(_name) \
+  static int (_name)(lua_State *L, int status, lua_KContext ctx); \
+  static int (_name ## _52)(lua_State *L) { \
+    lua_KContext ctx; \
+    int status = lua_getctx(L, &ctx); \
+    return (_name)(L, status, ctx); \
+  } \
+  static int (_name)(lua_State *L, int status, lua_KContext ctx)
+
+#define lua_pcallk(L, na, nr, err, ctx, cont) \
+  lua_pcallk((L), (na), (nr), (err), (ctx), cont ## _52)
+
+#define lua_callk(L, na, nr, ctx, cont) \
+  lua_callk((L), (na), (nr), (ctx), cont ## _52)
+
+#define lua_yieldk(L, nr, ctx, cont) \
+  lua_yieldk((L), (nr), (ctx), cont ## _52)
+
+#ifdef lua_call
+#  undef lua_call
+#  define lua_call(L, na, nr) \
+  (lua_callk)((L), (na), (nr), 0, NULL)
+#endif
+
+#ifdef lua_pcall
+#  undef lua_pcall
+#  define lua_pcall(L, na, nr, err) \
+  (lua_pcallk)((L), (na), (nr), (err), 0, NULL)
+#endif
+
+#ifdef lua_yield
+#  undef lua_yield
+#  define lua_yield(L, nr) \
+  (lua_yieldk)((L), (nr), 0, NULL)
+#endif
+
+#endif /* Lua 5.2 only */
+
+/* other Lua versions */
+#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 501 || LUA_VERSION_NUM > 504
+
+#  error "unsupported Lua version (i.e. not Lua 5.1, 5.2, 5.3, or 5.4)"
+
+#endif /* other Lua versions except 5.1, 5.2, 5.3, and 5.4 */
+
+/* helper macro for defining continuation functions (for every version
+* *except* Lua 5.2) */
+#ifndef LUA_KFUNCTION
+#define LUA_KFUNCTION(_name) \
+  static int (_name)(lua_State *L, int status, lua_KContext ctx)
+#endif
+
+#if defined(COMPAT53_INCLUDE_SOURCE) && COMPAT53_INCLUDE_SOURCE == 1
+// beginning of sol/compatibility/compat-5.3.c.h
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+#include <stdio.h>
+
+/* don't compile it again if it already is included via compat53.h */
+#ifndef KEPLER_PROJECT_COMPAT53_C_
+#define KEPLER_PROJECT_COMPAT53_C_
+
+/* definitions for Lua 5.1 only */
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 501
+
+#ifndef COMPAT53_FOPEN_NO_LOCK
+#if defined(_MSC_VER)
+#define COMPAT53_FOPEN_NO_LOCK 1
+#else /* otherwise */
+#define COMPAT53_FOPEN_NO_LOCK 0
+#endif /* VC++ only so far */
+#endif /* No-lock fopen_s usage if possible */
+
+#if defined(_MSC_VER) && COMPAT53_FOPEN_NO_LOCK
+#include <share.h>
+#endif /* VC++ _fsopen for share-allowed file read */
+
+#ifndef COMPAT53_HAVE_STRERROR_R
+#if defined(__GLIBC__) || defined(_POSIX_VERSION) || defined(__APPLE__) || (!defined(__MINGW32__) && defined(__GNUC__) && (__GNUC__ < 6))
+#define COMPAT53_HAVE_STRERROR_R 1
+#else /* none of the defines matched: define to 0 */
+#define COMPAT53_HAVE_STRERROR_R 0
+#endif /* have strerror_r of some form */
+#endif /* strerror_r */
+
+#ifndef COMPAT53_HAVE_STRERROR_S
+#if defined(_MSC_VER) || (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || (defined(__STDC_LIB_EXT1__) && __STDC_LIB_EXT1__)
+#define COMPAT53_HAVE_STRERROR_S 1
+#else /* not VC++ or C11 */
+#define COMPAT53_HAVE_STRERROR_S 0
+#endif /* strerror_s from VC++ or C11 */
+#endif /* strerror_s */
+
+#ifndef COMPAT53_LUA_FILE_BUFFER_SIZE
+#define COMPAT53_LUA_FILE_BUFFER_SIZE 4096
+#endif /* Lua File Buffer Size */
+
+static char* compat53_strerror(int en, char* buff, size_t sz) {
+#if COMPAT53_HAVE_STRERROR_R
+	/* use strerror_r here, because it's available on these specific platforms */
+	if (sz > 0) {
+		buff[0] = '\0';
+		/* we don't care whether the GNU version or the XSI version is used: */
+		if (strerror_r(en, buff, sz)) {
+			/* Yes, we really DO want to ignore the return value!
+			 * GCC makes that extra hard, not even a (void) cast will do. */
+		}
+		if (buff[0] == '\0') {
+			/* Buffer is unchanged, so we probably have called GNU strerror_r which
+			 * returned a static constant string. Chances are that strerror will
+			 * return the same static constant string and therefore be thread-safe. */
+			return strerror(en);
+		}
+	}
+	return buff; /* sz is 0 *or* strerror_r wrote into the buffer */
+#elif COMPAT53_HAVE_STRERROR_S
+	/* for MSVC and other C11 implementations, use strerror_s since it's
+	 * provided by default by the libraries */
+	strerror_s(buff, sz, en);
+	return buff;
+#else
+	/* fallback, but strerror is not guaranteed to be threadsafe due to modifying
+	 * errno itself and some impls not locking a static buffer for it ... but most
+	 * known systems have threadsafe errno: this might only change if the locale
+	 * is changed out from under someone while this function is being called */
+	(void)buff;
+	(void)sz;
+	return strerror(en);
+#endif
+}
+
+COMPAT53_API int lua_absindex(lua_State* L, int i) {
+	if (i < 0 && i > LUA_REGISTRYINDEX)
+		i += lua_gettop(L) + 1;
+	return i;
+}
+
+static void compat53_call_lua(lua_State* L, char const code[], size_t len, int nargs, int nret) {
+	lua_rawgetp(L, LUA_REGISTRYINDEX, (void*)code);
+	if (lua_type(L, -1) != LUA_TFUNCTION) {
+		lua_pop(L, 1);
+		if (luaL_loadbuffer(L, code, len, "=none"))
+			lua_error(L);
+		lua_pushvalue(L, -1);
+		lua_rawsetp(L, LUA_REGISTRYINDEX, (void*)code);
+	}
+	lua_insert(L, -nargs - 1);
+	lua_call(L, nargs, nret);
+}
+
+static const char compat53_arith_code[]
+     = "local op,a,b=...\n"
+       "if op==0 then return a+b\n"
+       "elseif op==1 then return a-b\n"
+       "elseif op==2 then return a*b\n"
+       "elseif op==3 then return a/b\n"
+       "elseif op==4 then return a%b\n"
+       "elseif op==5 then return a^b\n"
+       "elseif op==6 then return -a\n"
+       "end\n";
+
+COMPAT53_API void lua_arith(lua_State* L, int op) {
+	if (op < LUA_OPADD || op > LUA_OPUNM)
+		luaL_error(L, "invalid 'op' argument for lua_arith");
+	luaL_checkstack(L, 5, "not enough stack slots");
+	if (op == LUA_OPUNM)
+		lua_pushvalue(L, -1);
+	lua_pushnumber(L, op);
+	lua_insert(L, -3);
+	compat53_call_lua(L, compat53_arith_code, sizeof(compat53_arith_code) - 1, 3, 1);
+}
+
+static const char compat53_compare_code[]
+     = "local a,b=...\n"
+       "return a<=b\n";
+
+COMPAT53_API int lua_compare(lua_State* L, int idx1, int idx2, int op) {
+	int result = 0;
+	switch (op) {
+	case LUA_OPEQ:
+		return lua_equal(L, idx1, idx2);
+	case LUA_OPLT:
+		return lua_lessthan(L, idx1, idx2);
+	case LUA_OPLE:
+		luaL_checkstack(L, 5, "not enough stack slots");
+		idx1 = lua_absindex(L, idx1);
+		idx2 = lua_absindex(L, idx2);
+		lua_pushvalue(L, idx1);
+		lua_pushvalue(L, idx2);
+		compat53_call_lua(L, compat53_compare_code, sizeof(compat53_compare_code) - 1, 2, 1);
+		result = lua_toboolean(L, -1);
+		lua_pop(L, 1);
+		return result;
+	default:
+		luaL_error(L, "invalid 'op' argument for lua_compare");
+	}
+	return 0;
+}
+
+COMPAT53_API void lua_copy(lua_State* L, int from, int to) {
+	int abs_to = lua_absindex(L, to);
+	luaL_checkstack(L, 1, "not enough stack slots");
+	lua_pushvalue(L, from);
+	lua_replace(L, abs_to);
+}
+
+COMPAT53_API void lua_len(lua_State* L, int i) {
+	switch (lua_type(L, i)) {
+	case LUA_TSTRING:
+		lua_pushnumber(L, (lua_Number)lua_objlen(L, i));
+		break;
+	case LUA_TTABLE:
+		if (!luaL_callmeta(L, i, "__len"))
+			lua_pushnumber(L, (lua_Number)lua_objlen(L, i));
+		break;
+	case LUA_TUSERDATA:
+		if (luaL_callmeta(L, i, "__len"))
+			break;
+		/* FALLTHROUGH */
+	default:
+		luaL_error(L, "attempt to get length of a %s value", lua_typename(L, lua_type(L, i)));
+	}
+}
+
+COMPAT53_API int lua_rawgetp(lua_State* L, int i, const void* p) {
+	int abs_i = lua_absindex(L, i);
+	lua_pushlightuserdata(L, (void*)p);
+	lua_rawget(L, abs_i);
+	return lua_type(L, -1);
+}
+
+COMPAT53_API void lua_rawsetp(lua_State* L, int i, const void* p) {
+	int abs_i = lua_absindex(L, i);
+	luaL_checkstack(L, 1, "not enough stack slots");
+	lua_pushlightuserdata(L, (void*)p);
+	lua_insert(L, -2);
+	lua_rawset(L, abs_i);
+}
+
+COMPAT53_API lua_Number lua_tonumberx(lua_State* L, int i, int* isnum) {
+	lua_Number n = lua_tonumber(L, i);
+	if (isnum != NULL) {
+		*isnum = (n != 0 || lua_isnumber(L, i));
+	}
+	return n;
+}
+
+COMPAT53_API void luaL_checkversion(lua_State* L) {
+	(void)L;
+}
+
+COMPAT53_API void luaL_checkstack(lua_State* L, int sp, const char* msg) {
+	if (!lua_checkstack(L, sp + LUA_MINSTACK)) {
+		if (msg != NULL)
+			luaL_error(L, "stack overflow (%s)", msg);
+		else {
+			lua_pushliteral(L, "stack overflow");
+			lua_error(L);
+		}
+	}
+}
+
+COMPAT53_API int luaL_getsubtable(lua_State* L, int i, const char* name) {
+	int abs_i = lua_absindex(L, i);
+	luaL_checkstack(L, 3, "not enough stack slots");
+	lua_pushstring(L, name);
+	lua_gettable(L, abs_i);
+	if (lua_istable(L, -1))
+		return 1;
+	lua_pop(L, 1);
+	lua_newtable(L);
+	lua_pushstring(L, name);
+	lua_pushvalue(L, -2);
+	lua_settable(L, abs_i);
+	return 0;
+}
+
+COMPAT53_API lua_Integer luaL_len(lua_State* L, int i) {
+	lua_Integer res = 0;
+	int isnum = 0;
+	luaL_checkstack(L, 1, "not enough stack slots");
+	lua_len(L, i);
+	res = lua_tointegerx(L, -1, &isnum);
+	lua_pop(L, 1);
+	if (!isnum)
+		luaL_error(L, "object length is not an integer");
+	return res;
+}
+
+COMPAT53_API void luaL_setfuncs(lua_State* L, const luaL_Reg* l, int nup) {
+	luaL_checkstack(L, nup + 1, "too many upvalues");
+	for (; l->name != NULL; l++) { /* fill the table with given functions */
+		int i;
+		lua_pushstring(L, l->name);
+		for (i = 0; i < nup; i++) /* copy upvalues to the top */
+			lua_pushvalue(L, -(nup + 1));
+		lua_pushcclosure(L, l->func, nup); /* closure with those upvalues */
+		lua_settable(L, -(nup + 3));       /* table must be below the upvalues, the name and the closure */
+	}
+	lua_pop(L, nup); /* remove upvalues */
+}
+
+COMPAT53_API void luaL_setmetatable(lua_State* L, const char* tname) {
+	luaL_checkstack(L, 1, "not enough stack slots");
+	luaL_getmetatable(L, tname);
+	lua_setmetatable(L, -2);
+}
+
+COMPAT53_API void* luaL_testudata(lua_State* L, int i, const char* tname) {
+	void* p = lua_touserdata(L, i);
+	luaL_checkstack(L, 2, "not enough stack slots");
+	if (p == NULL || !lua_getmetatable(L, i))
+		return NULL;
+	else {
+		int res = 0;
+		luaL_getmetatable(L, tname);
+		res = lua_rawequal(L, -1, -2);
+		lua_pop(L, 2);
+		if (!res)
+			p = NULL;
+	}
+	return p;
+}
+
+static int compat53_countlevels(lua_State* L) {
+	lua_Debug ar;
+	int li = 1, le = 1;
+	/* find an upper bound */
+	while (lua_getstack(L, le, &ar)) {
+		li = le;
+		le *= 2;
+	}
+	/* do a binary search */
+	while (li < le) {
+		int m = (li + le) / 2;
+		if (lua_getstack(L, m, &ar))
+			li = m + 1;
+		else
+			le = m;
+	}
+	return le - 1;
+}
+
+static int compat53_findfield(lua_State* L, int objidx, int level) {
+	if (level == 0 || !lua_istable(L, -1))
+		return 0;                               /* not found */
+	lua_pushnil(L);                              /* start 'next' loop */
+	while (lua_next(L, -2)) {                    /* for each pair in table */
+		if (lua_type(L, -2) == LUA_TSTRING) {   /* ignore non-string keys */
+			if (lua_rawequal(L, objidx, -1)) { /* found object? */
+				lua_pop(L, 1);                /* remove value (but keep name) */
+				return 1;
+			}
+			else if (compat53_findfield(L, objidx, level - 1)) { /* try recursively */
+				lua_remove(L, -2);                              /* remove table (but keep name) */
+				lua_pushliteral(L, ".");
+				lua_insert(L, -2); /* place '.' between the two names */
+				lua_concat(L, 3);
+				return 1;
+			}
+		}
+		lua_pop(L, 1); /* remove value */
+	}
+	return 0; /* not found */
+}
+
+static int compat53_pushglobalfuncname(lua_State* L, lua_Debug* ar) {
+	int top = lua_gettop(L);
+	lua_getinfo(L, "f", ar); /* push function */
+	lua_pushvalue(L, LUA_GLOBALSINDEX);
+	if (compat53_findfield(L, top + 1, 2)) {
+		lua_copy(L, -1, top + 1); /* move name to proper place */
+		lua_pop(L, 2);            /* remove pushed values */
+		return 1;
+	}
+	else {
+		lua_settop(L, top); /* remove function and global table */
+		return 0;
+	}
+}
+
+static void compat53_pushfuncname(lua_State* L, lua_Debug* ar) {
+	if (*ar->namewhat != '\0') /* is there a name? */
+		lua_pushfstring(L, "function " LUA_QS, ar->name);
+	else if (*ar->what == 'm') /* main? */
+		lua_pushliteral(L, "main chunk");
+	else if (*ar->what == 'C') {
+		if (compat53_pushglobalfuncname(L, ar)) {
+			lua_pushfstring(L, "function " LUA_QS, lua_tostring(L, -1));
+			lua_remove(L, -2); /* remove name */
+		}
+		else
+			lua_pushliteral(L, "?");
+	}
+	else
+		lua_pushfstring(L, "function <%s:%d>", ar->short_src, ar->linedefined);
+}
+
+#define COMPAT53_LEVELS1 12 /* size of the first part of the stack */
+#define COMPAT53_LEVELS2 10 /* size of the second part of the stack */
+
+COMPAT53_API void luaL_traceback(lua_State* L, lua_State* L1, const char* msg, int level) {
+	lua_Debug ar;
+	int top = lua_gettop(L);
+	int numlevels = compat53_countlevels(L1);
+	int mark = (numlevels > COMPAT53_LEVELS1 + COMPAT53_LEVELS2) ? COMPAT53_LEVELS1 : 0;
+	if (msg)
+		lua_pushfstring(L, "%s\n", msg);
+	lua_pushliteral(L, "stack traceback:");
+	while (lua_getstack(L1, level++, &ar)) {
+		if (level == mark) {                       /* too many levels? */
+			lua_pushliteral(L, "\n\t...");        /* add a '...' */
+			level = numlevels - COMPAT53_LEVELS2; /* and skip to last ones */
+		}
+		else {
+			lua_getinfo(L1, "Slnt", &ar);
+			lua_pushfstring(L, "\n\t%s:", ar.short_src);
+			if (ar.currentline > 0)
+				lua_pushfstring(L, "%d:", ar.currentline);
+			lua_pushliteral(L, " in ");
+			compat53_pushfuncname(L, &ar);
+			lua_concat(L, lua_gettop(L) - top);
+		}
+	}
+	lua_concat(L, lua_gettop(L) - top);
+}
+
+COMPAT53_API int luaL_fileresult(lua_State* L, int stat, const char* fname) {
+	const char* serr = NULL;
+	int en = errno; /* calls to Lua API may change this value */
+	char buf[512] = { 0 };
+	if (stat) {
+		lua_pushboolean(L, 1);
+		return 1;
+	}
+	else {
+		lua_pushnil(L);
+		serr = compat53_strerror(en, buf, sizeof(buf));
+		if (fname)
+			lua_pushfstring(L, "%s: %s", fname, serr);
+		else
+			lua_pushstring(L, serr);
+		lua_pushnumber(L, (lua_Number)en);
+		return 3;
+	}
+}
+
+static int compat53_checkmode(lua_State* L, const char* mode, const char* modename, int err) {
+	if (mode && strchr(mode, modename[0]) == NULL) {
+		lua_pushfstring(L, "attempt to load a %s chunk (mode is '%s')", modename, mode);
+		return err;
+	}
+	return LUA_OK;
+}
+
+typedef struct {
+	lua_Reader reader;
+	void* ud;
+	int has_peeked_data;
+	const char* peeked_data;
+	size_t peeked_data_size;
+} compat53_reader_data;
+
+static const char* compat53_reader(lua_State* L, void* ud, size_t* size) {
+	compat53_reader_data* data = (compat53_reader_data*)ud;
+	if (data->has_peeked_data) {
+		data->has_peeked_data = 0;
+		*size = data->peeked_data_size;
+		return data->peeked_data;
+	}
+	else
+		return data->reader(L, data->ud, size);
+}
+
+COMPAT53_API int lua_load(lua_State* L, lua_Reader reader, void* data, const char* source, const char* mode) {
+	int status = LUA_OK;
+	compat53_reader_data compat53_data = { reader, data, 1, 0, 0 };
+	compat53_data.peeked_data = reader(L, data, &(compat53_data.peeked_data_size));
+	if (compat53_data.peeked_data && compat53_data.peeked_data_size && compat53_data.peeked_data[0] == LUA_SIGNATURE[0]) /* binary file? */
+		status = compat53_checkmode(L, mode, "binary", LUA_ERRSYNTAX);
+	else
+		status = compat53_checkmode(L, mode, "text", LUA_ERRSYNTAX);
+	if (status != LUA_OK)
+		return status;
+		/* we need to call the original 5.1 version of lua_load! */
+#undef lua_load
+	return lua_load(L, compat53_reader, &compat53_data, source);
+#define lua_load COMPAT53_CONCAT(COMPAT53_PREFIX, _load_53)
+}
+
+typedef struct {
+	int n;                                    /* number of pre-read characters */
+	FILE* f;                                  /* file being read */
+	char buff[COMPAT53_LUA_FILE_BUFFER_SIZE]; /* area for reading file */
+} compat53_LoadF;
+
+static const char* compat53_getF(lua_State* L, void* ud, size_t* size) {
+	compat53_LoadF* lf = (compat53_LoadF*)ud;
+	(void)L;            /* not used */
+	if (lf->n > 0) {    /* are there pre-read characters to be read? */
+		*size = lf->n; /* return them (chars already in buffer) */
+		lf->n = 0;     /* no more pre-read characters */
+	}
+	else { /* read a block from file */
+		  /* 'fread' can return > 0 *and* set the EOF flag. If next call to
+		  'compat53_getF' called 'fread', it might still wait for user input.
+		  The next check avoids this problem. */
+		if (feof(lf->f))
+			return NULL;
+		*size = fread(lf->buff, 1, sizeof(lf->buff), lf->f); /* read block */
+	}
+	return lf->buff;
+}
+
+static int compat53_errfile(lua_State* L, const char* what, int fnameindex) {
+	char buf[512] = { 0 };
+	const char* serr = compat53_strerror(errno, buf, sizeof(buf));
+	const char* filename = lua_tostring(L, fnameindex) + 1;
+	lua_pushfstring(L, "cannot %s %s: %s", what, filename, serr);
+	lua_remove(L, fnameindex);
+	return LUA_ERRFILE;
+}
+
+static int compat53_skipBOM(compat53_LoadF* lf) {
+	const char* p = "\xEF\xBB\xBF"; /* UTF-8 BOM mark */
+	int c;
+	lf->n = 0;
+	do {
+		c = getc(lf->f);
+		if (c == EOF || c != *(const unsigned char*)p++)
+			return c;
+		lf->buff[lf->n++] = (char)c; /* to be read by the parser */
+	} while (*p != '\0');
+	lf->n = 0;          /* prefix matched; discard it */
+	return getc(lf->f); /* return next character */
+}
+
+/*
+** reads the first character of file 'f' and skips an optional BOM mark
+** in its beginning plus its first line if it starts with '#'. Returns
+** true if it skipped the first line.  In any case, '*cp' has the
+** first "valid" character of the file (after the optional BOM and
+** a first-line comment).
+*/
+static int compat53_skipcomment(compat53_LoadF* lf, int* cp) {
+	int c = *cp = compat53_skipBOM(lf);
+	if (c == '#') { /* first line is a comment (Unix exec. file)? */
+		do {       /* skip first line */
+			c = getc(lf->f);
+		} while (c != EOF && c != '\n');
+		*cp = getc(lf->f); /* skip end-of-line, if present */
+		return 1;          /* there was a comment */
+	}
+	else
+		return 0; /* no comment */
+}
+
+COMPAT53_API int luaL_loadfilex(lua_State* L, const char* filename, const char* mode) {
+	compat53_LoadF lf;
+	int status, readstatus;
+	int c;
+	int fnameindex = lua_gettop(L) + 1; /* index of filename on the stack */
+	if (filename == NULL) {
+		lua_pushliteral(L, "=stdin");
+		lf.f = stdin;
+	}
+	else {
+		lua_pushfstring(L, "@%s", filename);
+#if defined(_MSC_VER)
+		/* This code is here to stop a deprecation error that stops builds
+		 * if a certain macro is defined. While normally not caring would
+		 * be best, some header-only libraries and builds can't afford to
+		 * dictate this to the user. A quick check shows that fopen_s this
+		 * goes back to VS 2005, and _fsopen goes back to VS 2003 .NET,
+		 * possibly even before that so we don't need to do any version
+		 * number checks, since this has been there since forever.  */
+
+		/* TO USER: if you want the behavior of typical fopen_s/fopen,
+		 * which does lock the file on VC++, define the macro used below to 0 */
+#if COMPAT53_FOPEN_NO_LOCK
+		lf.f = _fsopen(filename, "r", _SH_DENYNO); /* do not lock the file in any way */
+		if (lf.f == NULL)
+			return compat53_errfile(L, "open", fnameindex);
+#else  /* use default locking version */
+		if (fopen_s(&lf.f, filename, "r") != 0)
+			return compat53_errfile(L, "open", fnameindex);
+#endif /* Locking vs. No-locking fopen variants */
+#else
+		lf.f = fopen(filename, "r"); /* default stdlib doesn't forcefully lock files here */
+		if (lf.f == NULL)
+			return compat53_errfile(L, "open", fnameindex);
+#endif
+	}
+	if (compat53_skipcomment(&lf, &c))       /* read initial portion */
+		lf.buff[lf.n++] = '\n';             /* add line to correct line numbers */
+	if (c == LUA_SIGNATURE[0] && filename) { /* binary file? */
+#if defined(_MSC_VER)
+		if (freopen_s(&lf.f, filename, "rb", lf.f) != 0)
+			return compat53_errfile(L, "reopen", fnameindex);
+#else
+		lf.f = freopen(filename, "rb", lf.f); /* reopen in binary mode */
+		if (lf.f == NULL)
+			return compat53_errfile(L, "reopen", fnameindex);
+#endif
+		compat53_skipcomment(&lf, &c); /* re-read initial portion */
+	}
+	if (c != EOF)
+		lf.buff[lf.n++] = (char)c; /* 'c' is the first character of the stream */
+	status = lua_load(L, &compat53_getF, &lf, lua_tostring(L, -1), mode);
+	readstatus = ferror(lf.f);
+	if (filename)
+		fclose(lf.f); /* close file (even in case of errors) */
+	if (readstatus) {
+		lua_settop(L, fnameindex); /* ignore results from 'lua_load' */
+		return compat53_errfile(L, "read", fnameindex);
+	}
+	lua_remove(L, fnameindex);
+	return status;
+}
+
+COMPAT53_API int luaL_loadbufferx(lua_State* L, const char* buff, size_t sz, const char* name, const char* mode) {
+	int status = LUA_OK;
+	if (sz > 0 && buff[0] == LUA_SIGNATURE[0]) {
+		status = compat53_checkmode(L, mode, "binary", LUA_ERRSYNTAX);
+	}
+	else {
+		status = compat53_checkmode(L, mode, "text", LUA_ERRSYNTAX);
+	}
+	if (status != LUA_OK)
+		return status;
+	return luaL_loadbuffer(L, buff, sz, name);
+}
+
+#if !defined(l_inspectstat) \
+     && (defined(unix) || defined(__unix) || defined(__unix__) || defined(__TOS_AIX__) || defined(_SYSTYPE_BSD) || (defined(__APPLE__) && defined(__MACH__)))
+/* some form of unix; check feature macros in unistd.h for details */
+#include <unistd.h>
+/* check posix version; the relevant include files and macros probably
+ * were available before 2001, but I'm not sure */
+#if defined(_POSIX_VERSION) && _POSIX_VERSION >= 200112L
+#include <sys/wait.h>
+#define l_inspectstat(stat, what)   \
+	if (WIFEXITED(stat)) {         \
+		stat = WEXITSTATUS(stat); \
+	}                              \
+	else if (WIFSIGNALED(stat)) {  \
+		stat = WTERMSIG(stat);    \
+		what = "signal";          \
+	}
+#endif
+#endif
+
+/* provide default (no-op) version */
+#if !defined(l_inspectstat)
+#define l_inspectstat(stat, what) ((void)0)
+#endif
+
+COMPAT53_API int luaL_execresult(lua_State* L, int stat) {
+	const char* what = "exit";
+	if (stat == -1)
+		return luaL_fileresult(L, 0, NULL);
+	else {
+		l_inspectstat(stat, what);
+		if (*what == 'e' && stat == 0)
+			lua_pushboolean(L, 1);
+		else
+			lua_pushnil(L);
+		lua_pushstring(L, what);
+		lua_pushinteger(L, stat);
+		return 3;
+	}
+}
+
+COMPAT53_API void luaL_buffinit(lua_State* L, luaL_Buffer_53* B) {
+	/* make it crash if used via pointer to a 5.1-style luaL_Buffer */
+	B->b.p = NULL;
+	B->b.L = NULL;
+	B->b.lvl = 0;
+	/* reuse the buffer from the 5.1-style luaL_Buffer though! */
+	B->ptr = B->b.buffer;
+	B->capacity = LUAL_BUFFERSIZE;
+	B->nelems = 0;
+	B->L2 = L;
+}
+
+COMPAT53_API char* luaL_prepbuffsize(luaL_Buffer_53* B, size_t s) {
+	if (B->capacity - B->nelems < s) { /* needs to grow */
+		char* newptr = NULL;
+		size_t newcap = B->capacity * 2;
+		if (newcap - B->nelems < s)
+			newcap = B->nelems + s;
+		if (newcap < B->capacity) /* overflow */
+			luaL_error(B->L2, "buffer too large");
+		newptr = (char*)lua_newuserdata(B->L2, newcap);
+		memcpy(newptr, B->ptr, B->nelems);
+		if (B->ptr != B->b.buffer)
+			lua_replace(B->L2, -2); /* remove old buffer */
+		B->ptr = newptr;
+		B->capacity = newcap;
+	}
+	return B->ptr + B->nelems;
+}
+
+COMPAT53_API void luaL_addlstring(luaL_Buffer_53* B, const char* s, size_t l) {
+	memcpy(luaL_prepbuffsize(B, l), s, l);
+	luaL_addsize(B, l);
+}
+
+COMPAT53_API void luaL_addvalue(luaL_Buffer_53* B) {
+	size_t len = 0;
+	const char* s = lua_tolstring(B->L2, -1, &len);
+	if (!s)
+		luaL_error(B->L2, "cannot convert value to string");
+	if (B->ptr != B->b.buffer)
+		lua_insert(B->L2, -2); /* userdata buffer must be at stack top */
+	luaL_addlstring(B, s, len);
+	lua_remove(B->L2, B->ptr != B->b.buffer ? -2 : -1);
+}
+
+void luaL_pushresult(luaL_Buffer_53* B) {
+	lua_pushlstring(B->L2, B->ptr, B->nelems);
+	if (B->ptr != B->b.buffer)
+		lua_replace(B->L2, -2); /* remove userdata buffer */
+}
+
+#endif /* Lua 5.1 */
+
+/* definitions for Lua 5.1 and Lua 5.2 */
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM <= 502
+
+COMPAT53_API int lua_geti(lua_State* L, int index, lua_Integer i) {
+	index = lua_absindex(L, index);
+	lua_pushinteger(L, i);
+	lua_gettable(L, index);
+	return lua_type(L, -1);
+}
+
+COMPAT53_API int lua_isinteger(lua_State* L, int index) {
+	if (lua_type(L, index) == LUA_TNUMBER) {
+		lua_Number n = lua_tonumber(L, index);
+		lua_Integer i = lua_tointeger(L, index);
+		if (i == n)
+			return 1;
+	}
+	return 0;
+}
+
+COMPAT53_API lua_Integer lua_tointegerx(lua_State* L, int i, int* isnum) {
+	int ok = 0;
+	lua_Number n = lua_tonumberx(L, i, &ok);
+	if (ok) {
+		if (n == (lua_Integer)n) {
+			if (isnum)
+				*isnum = 1;
+			return (lua_Integer)n;
+		}
+	}
+	if (isnum)
+		*isnum = 0;
+	return 0;
+}
+
+static void compat53_reverse(lua_State* L, int a, int b) {
+	for (; a < b; ++a, --b) {
+		lua_pushvalue(L, a);
+		lua_pushvalue(L, b);
+		lua_replace(L, a);
+		lua_replace(L, b);
+	}
+}
+
+COMPAT53_API void lua_rotate(lua_State* L, int idx, int n) {
+	int n_elems = 0;
+	idx = lua_absindex(L, idx);
+	n_elems = lua_gettop(L) - idx + 1;
+	if (n < 0)
+		n += n_elems;
+	if (n > 0 && n < n_elems) {
+		luaL_checkstack(L, 2, "not enough stack slots available");
+		n = n_elems - n;
+		compat53_reverse(L, idx, idx + n - 1);
+		compat53_reverse(L, idx + n, idx + n_elems - 1);
+		compat53_reverse(L, idx, idx + n_elems - 1);
+	}
+}
+
+COMPAT53_API void lua_seti(lua_State* L, int index, lua_Integer i) {
+	luaL_checkstack(L, 1, "not enough stack slots available");
+	index = lua_absindex(L, index);
+	lua_pushinteger(L, i);
+	lua_insert(L, -2);
+	lua_settable(L, index);
+}
+
+#if !defined(lua_str2number)
+#define lua_str2number(s, p) strtod((s), (p))
+#endif
+
+COMPAT53_API size_t lua_stringtonumber(lua_State* L, const char* s) {
+	char* endptr;
+	lua_Number n = lua_str2number(s, &endptr);
+	if (endptr != s) {
+		while (*endptr != '\0' && isspace((unsigned char)*endptr))
+			++endptr;
+		if (*endptr == '\0') {
+			lua_pushnumber(L, n);
+			return endptr - s + 1;
+		}
+	}
+	return 0;
+}
+
+COMPAT53_API const char* luaL_tolstring(lua_State* L, int idx, size_t* len) {
+	if (!luaL_callmeta(L, idx, "__tostring")) {
+		int t = lua_type(L, idx), tt = 0;
+		char const* name = NULL;
+		switch (t) {
+		case LUA_TNIL:
+			lua_pushliteral(L, "nil");
+			break;
+		case LUA_TSTRING:
+		case LUA_TNUMBER:
+			lua_pushvalue(L, idx);
+			break;
+		case LUA_TBOOLEAN:
+			if (lua_toboolean(L, idx))
+				lua_pushliteral(L, "true");
+			else
+				lua_pushliteral(L, "false");
+			break;
+		default:
+			tt = luaL_getmetafield(L, idx, "__name");
+			name = (tt == LUA_TSTRING) ? lua_tostring(L, -1) : lua_typename(L, t);
+			lua_pushfstring(L, "%s: %p", name, lua_topointer(L, idx));
+			if (tt != LUA_TNIL)
+				lua_replace(L, -2);
+			break;
+		}
+	}
+	else {
+		if (!lua_isstring(L, -1))
+			luaL_error(L, "'__tostring' must return a string");
+	}
+	return lua_tolstring(L, -1, len);
+}
+
+COMPAT53_API void luaL_requiref(lua_State* L, const char* modname, lua_CFunction openf, int glb) {
+	luaL_checkstack(L, 3, "not enough stack slots available");
+	luaL_getsubtable(L, LUA_REGISTRYINDEX, "_LOADED");
+	if (lua_getfield(L, -1, modname) == LUA_TNIL) {
+		lua_pop(L, 1);
+		lua_pushcfunction(L, openf);
+		lua_pushstring(L, modname);
+		lua_call(L, 1, 1);
+		lua_pushvalue(L, -1);
+		lua_setfield(L, -3, modname);
+	}
+	if (glb) {
+		lua_pushvalue(L, -1);
+		lua_setglobal(L, modname);
+	}
+	lua_replace(L, -2);
+}
+
+#endif /* Lua 5.1 and 5.2 */
+
+#endif /* KEPLER_PROJECT_COMPAT53_C_ */
+
+/*********************************************************************
+ * This file contains parts of Lua 5.2's and Lua 5.3's source code:
+ *
+ * Copyright (C) 1994-2014 Lua.org, PUC-Rio.
+ *
+ * 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.
+ *********************************************************************/
+// end of sol/compatibility/compat-5.3.c.h
+
+#endif
+
+#endif /* KEPLER_PROJECT_COMPAT53_H_ */
+
+// end of sol/compatibility/compat-5.3.h
+
+// beginning of sol/compatibility/compat-5.4.h
+
+#ifndef NOT_KEPLER_PROJECT_COMPAT54_H_
+#define NOT_KEPLER_PROJECT_COMPAT54_H_
+
+#if defined(__cplusplus) && !defined(COMPAT53_LUA_CPP)
+extern "C" {
+#endif
+#include <lua.h>
+#include <lauxlib.h>
+#include <lualib.h>
+#if defined(__cplusplus) && !defined(COMPAT53_LUA_CPP)
+}
+#endif
+
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 504
+
+#if !defined(LUA_ERRGCMM)
+/* So Lua 5.4 actually removes this, which breaks sol2...
+ man, this API is quite unstable...!
+*/
+#  define LUA_ERRGCMM (LUA_ERRERR + 2)
+#endif /* LUA_ERRGCMM define */
+
+#endif // Lua 5.4 only
+
+#endif // NOT_KEPLER_PROJECT_COMPAT54_H_// end of sol/compatibility/compat-5.4.h
+
+#endif
+
+// end of sol/compatibility.hpp
+
+#include <vector>
+#include <cstdint>
+#include <cstddef>
+
+namespace sol {
+
+	template <typename Allocator = std::allocator<std::byte>>
+	class basic_bytecode : private std::vector<std::byte, Allocator> {
+	private:
+		using base_t = std::vector<std::byte, Allocator>;
+
+	public:
+		using typename base_t::allocator_type;
+		using typename base_t::const_iterator;
+		using typename base_t::const_pointer;
+		using typename base_t::const_reference;
+		using typename base_t::const_reverse_iterator;
+		using typename base_t::difference_type;
+		using typename base_t::iterator;
+		using typename base_t::pointer;
+		using typename base_t::reference;
+		using typename base_t::reverse_iterator;
+		using typename base_t::size_type;
+		using typename base_t::value_type;
+
+		using base_t::base_t;
+		using base_t::operator=;
+
+		using base_t::data;
+		using base_t::empty;
+		using base_t::max_size;
+		using base_t::size;
+
+		using base_t::at;
+		using base_t::operator[];
+		using base_t::back;
+		using base_t::front;
+
+		using base_t::begin;
+		using base_t::cbegin;
+		using base_t::cend;
+		using base_t::end;
+
+		using base_t::crbegin;
+		using base_t::crend;
+		using base_t::rbegin;
+		using base_t::rend;
+
+		using base_t::get_allocator;
+		using base_t::swap;
+
+		using base_t::clear;
+		using base_t::emplace;
+		using base_t::emplace_back;
+		using base_t::erase;
+		using base_t::insert;
+		using base_t::pop_back;
+		using base_t::push_back;
+		using base_t::reserve;
+		using base_t::resize;
+		using base_t::shrink_to_fit;
+
+		string_view as_string_view() const {
+			return string_view(reinterpret_cast<const char*>(this->data()), this->size());
+		}
+	};
+
+	template <typename Container>
+	inline int basic_insert_dump_writer(lua_State*, const void* memory, size_t memory_size, void* userdata) {
+		using storage_t = Container;
+		const std::byte* p_code = static_cast<const std::byte*>(memory);
+		storage_t& bc = *static_cast<storage_t*>(userdata);
+#if SOL_IS_OFF(SOL_EXCEPTIONS_I_)
+		bc.insert(bc.cend(), p_code, p_code + memory_size);
+#else
+		try {
+			bc.insert(bc.cend(), p_code, p_code + memory_size);
+		}
+		catch (...) {
+			return -1;
+		}
+#endif
+		return 0;
+	}
+
+	using bytecode = basic_bytecode<>;
+
+	constexpr inline auto bytecode_dump_writer = &basic_insert_dump_writer<bytecode>;
+
+} // namespace sol
+
+// end of sol/bytecode.hpp
+
+// beginning of sol/stack.hpp
+
+// beginning of sol/trampoline.hpp
+
+// beginning of sol/types.hpp
+
+// beginning of sol/error.hpp
+
+#include <stdexcept>
+#include <string>
+#include <array>
+
+namespace sol {
+	namespace detail {
+		struct direct_error_tag {};
+		const auto direct_error = direct_error_tag{};
+
+		struct error_result {
+			int results;
+			const char* format_string;
+			std::array<const char*, 4> args_strings;
+
+			error_result() : results(0), format_string(nullptr) {
+			}
+
+			error_result(int results) : results(results), format_string(nullptr) {
+			}
+
+			error_result(const char* fmt, const char* msg) : results(0), format_string(fmt) {
+				args_strings[0] = msg;
+			}
+		};
+
+		inline int handle_errors(lua_State* L, const error_result& er) {
+			if (er.format_string == nullptr) {
+				return er.results;
+			}
+			return luaL_error(L, er.format_string, er.args_strings[0], er.args_strings[1], er.args_strings[2], er.args_strings[3]);
+		}
+	} // namespace detail
+
+	class error : public std::runtime_error {
+	private:
+		// Because VC++ is upsetting, most of the time!
+		std::string what_reason;
+
+	public:
+		error(const std::string& str) : error(detail::direct_error, "lua: error: " + str) {
+		}
+		error(std::string&& str) : error(detail::direct_error, "lua: error: " + std::move(str)) {
+		}
+		error(detail::direct_error_tag, const std::string& str) : std::runtime_error(""), what_reason(str) {
+		}
+		error(detail::direct_error_tag, std::string&& str) : std::runtime_error(""), what_reason(std::move(str)) {
+		}
+
+		error(const error& e) = default;
+		error(error&& e) = default;
+		error& operator=(const error& e) = default;
+		error& operator=(error&& e) = default;
+
+		virtual const char* what() const noexcept override {
+			return what_reason.c_str();
+		}
+	};
+
+} // namespace sol
+
+// end of sol/error.hpp
+
+// beginning of sol/optional.hpp
+
+// beginning of sol/in_place.hpp
+
+#include <cstddef>
+#include <utility>
+
+namespace sol {
+
+	using in_place_t = std::in_place_t;
+	constexpr std::in_place_t in_place {};
+	constexpr std::in_place_t in_place_of {};
+
+	template <typename T>
+	using in_place_type_t = std::in_place_type_t<T>;
+	template <typename T>
+	constexpr std::in_place_type_t<T> in_place_type {};
+
+	template <size_t I>
+	using in_place_index_t = std::in_place_index_t<I>;
+	template <size_t I>
+	constexpr in_place_index_t<I> in_place_index {};
+
+} // namespace sol
+
+// end of sol/in_place.hpp
+
+#if SOL_IS_ON(SOL_USE_BOOST_I_)
+#include <boost/optional.hpp>
+#else
+// beginning of sol/optional_implementation.hpp
+
+#define SOL_TL_OPTIONAL_VERSION_MAJOR 0
+#define SOL_TL_OPTIONAL_VERSION_MINOR 5
+
+#include <exception>
+#include <functional>
+#include <new>
+#include <type_traits>
+#include <utility>
+#include <cstdlib>
+#include <optional>
+
+#if (defined(_MSC_VER) && _MSC_VER == 1900)
+#define SOL_TL_OPTIONAL_MSVC2015
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 && !defined(__clang__))
+#define SOL_TL_OPTIONAL_GCC49
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 4 && !defined(__clang__))
+#define SOL_TL_OPTIONAL_GCC54
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 5 && !defined(__clang__))
+#define SOL_TL_OPTIONAL_GCC55
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 && !defined(__clang__))
+#define SOL_TL_OPTIONAL_NO_CONSTRR
+
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) std::has_trivial_copy_constructor<T>::value
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) std::has_trivial_copy_assign<T>::value
+
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible<T>::value
+
+#elif (defined(__GNUC__) && __GNUC__ < 8 && !defined(__clang__))
+#ifndef SOL_TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX
+#define SOL_TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX
+namespace sol { namespace detail {
+	template <class T>
+	struct is_trivially_copy_constructible : std::is_trivially_copy_constructible<T> {};
+#ifdef _GLIBCXX_VECTOR
+	template <class T, class A>
+	struct is_trivially_copy_constructible<std::vector<T, A>> : std::is_trivially_copy_constructible<T> {};
+#endif
+}} // namespace sol::detail
+#endif
+
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) sol::detail::is_trivially_copy_constructible<T>::value
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) std::is_trivially_copy_assignable<T>::value
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible<T>::value
+#else
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) std::is_trivially_copy_constructible<T>::value
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) std::is_trivially_copy_assignable<T>::value
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible<T>::value
+#endif
+
+#if __cplusplus > 201103L
+#define SOL_TL_OPTIONAL_CXX14
+#endif
+
+#if (__cplusplus == 201103L || defined(SOL_TL_OPTIONAL_MSVC2015) || defined(SOL_TL_OPTIONAL_GCC49))
+#define SOL_TL_OPTIONAL_11_CONSTEXPR
+#else
+   /// \exclude
+#define SOL_TL_OPTIONAL_11_CONSTEXPR constexpr
+#endif
+
+namespace sol {
+#ifndef SOL_TL_MONOSTATE_INPLACE_MUTEX
+#define SOL_TL_MONOSTATE_INPLACE_MUTEX
+	/// \brief Used to represent an optional with no data; essentially a bool
+	class monostate {};
+#endif
+
+	template <class T>
+	class optional;
+
+	/// \exclude
+	namespace detail {
+#ifndef SOL_TL_TRAITS_MUTEX
+#define SOL_TL_TRAITS_MUTEX
+		// C++14-style aliases for brevity
+		template <class T>
+		using remove_const_t = typename std::remove_const<T>::type;
+		template <class T>
+		using remove_reference_t = typename std::remove_reference<T>::type;
+		template <class T>
+		using decay_t = typename std::decay<T>::type;
+		template <bool E, class T = void>
+		using enable_if_t = typename std::enable_if<E, T>::type;
+		template <bool B, class T, class F>
+		using conditional_t = typename std::conditional<B, T, F>::type;
+
+		// std::conjunction from C++17
+		template <class...>
+		struct conjunction : std::true_type {};
+		template <class B>
+		struct conjunction<B> : B {};
+		template <class B, class... Bs>
+		struct conjunction<B, Bs...> : std::conditional<bool(B::value), conjunction<Bs...>, B>::type {};
+
+#if defined(_LIBCPP_VERSION) && __cplusplus == 201103L
+#define SOL_TL_OPTIONAL_LIBCXX_MEM_FN_WORKAROUND
+#endif
+
+#ifdef SOL_TL_OPTIONAL_LIBCXX_MEM_FN_WORKAROUND
+		template <class T>
+		struct is_pointer_to_non_const_member_func : std::false_type {};
+		template <class T, class Ret, class... Args>
+		struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...)> : std::true_type {};
+		template <class T, class Ret, class... Args>
+		struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...)&> : std::true_type {};
+		template <class T, class Ret, class... Args>
+		struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) &&> : std::true_type {};
+		template <class T, class Ret, class... Args>
+		struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile> : std::true_type {};
+		template <class T, class Ret, class... Args>
+		struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile&> : std::true_type {};
+		template <class T, class Ret, class... Args>
+		struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile&&> : std::true_type {};
+
+		template <class T>
+		struct is_const_or_const_ref : std::false_type {};
+		template <class T>
+		struct is_const_or_const_ref<T const&> : std::true_type {};
+		template <class T>
+		struct is_const_or_const_ref<T const> : std::true_type {};
+#endif
+
+		// std::invoke from C++17
+		// https://stackoverflow.com/questions/38288042/c11-14-invoke-workaround
+		template <typename Fn, typename... Args,
+#ifdef SOL_TL_OPTIONAL_LIBCXX_MEM_FN_WORKAROUND
+		     typename = enable_if_t<!(is_pointer_to_non_const_member_func<Fn>::value && is_const_or_const_ref<Args...>::value)>,
+#endif
+		     typename = enable_if_t<std::is_member_pointer<decay_t<Fn>>::value>, int = 0>
+		constexpr auto invoke(Fn&& f, Args&&... args) noexcept(noexcept(std::mem_fn(f)(std::forward<Args>(args)...)))
+		     -> decltype(std::mem_fn(f)(std::forward<Args>(args)...)) {
+			return std::mem_fn(f)(std::forward<Args>(args)...);
+		}
+
+		template <typename Fn, typename... Args, typename = enable_if_t<!std::is_member_pointer<decay_t<Fn>>::value>>
+		constexpr auto invoke(Fn&& f, Args&&... args) noexcept(noexcept(std::forward<Fn>(f)(std::forward<Args>(args)...)))
+		     -> decltype(std::forward<Fn>(f)(std::forward<Args>(args)...)) {
+			return std::forward<Fn>(f)(std::forward<Args>(args)...);
+		}
+
+		// std::invoke_result from C++17
+		template <class F, class, class... Us>
+		struct invoke_result_impl;
+
+		template <class F, class... Us>
+		struct invoke_result_impl<F, decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...), void()), Us...> {
+			using type = decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...));
+		};
+
+		template <class F, class... Us>
+		using invoke_result = invoke_result_impl<F, void, Us...>;
+
+		template <class F, class... Us>
+		using invoke_result_t = typename invoke_result<F, Us...>::type;
+#endif
+
+		// std::void_t from C++17
+		template <class...>
+		struct voider {
+			using type = void;
+		};
+		template <class... Ts>
+		using void_t = typename voider<Ts...>::type;
+
+		// Trait for checking if a type is a sol::optional
+		template <class T>
+		struct is_optional_impl : std::false_type {};
+		template <class T>
+		struct is_optional_impl<optional<T>> : std::true_type {};
+		template <class T>
+		using is_optional = is_optional_impl<decay_t<T>>;
+
+		// Change void to sol::monostate
+		template <class U>
+		using fixup_void = conditional_t<std::is_void<U>::value, monostate, U>;
+
+		template <class F, class U, class = invoke_result_t<F, U>>
+		using get_map_return = optional<fixup_void<invoke_result_t<F, U>>>;
+
+		// Check if invoking F for some Us returns void
+		template <class F, class = void, class... U>
+		struct returns_void_impl;
+		template <class F, class... U>
+		struct returns_void_impl<F, void_t<invoke_result_t<F, U...>>, U...> : std::is_void<invoke_result_t<F, U...>> {};
+		template <class F, class... U>
+		using returns_void = returns_void_impl<F, void, U...>;
+
+		template <class T, class... U>
+		using enable_if_ret_void = enable_if_t<returns_void<T&&, U...>::value>;
+
+		template <class T, class... U>
+		using disable_if_ret_void = enable_if_t<!returns_void<T&&, U...>::value>;
+
+		template <class T, class U>
+		using enable_forward_value = detail::enable_if_t<std::is_constructible<T, U&&>::value && !std::is_same<detail::decay_t<U>, in_place_t>::value
+		     && !std::is_same<optional<T>, detail::decay_t<U>>::value>;
+
+		template <class T, class U, class Other>
+		using enable_from_other = detail::enable_if_t<std::is_constructible<T, Other>::value && !std::is_constructible<T, optional<U>&>::value
+		     && !std::is_constructible<T, optional<U>&&>::value && !std::is_constructible<T, const optional<U>&>::value
+		     && !std::is_constructible<T, const optional<U>&&>::value && !std::is_convertible<optional<U>&, T>::value
+		     && !std::is_convertible<optional<U>&&, T>::value && !std::is_convertible<const optional<U>&, T>::value
+		     && !std::is_convertible<const optional<U>&&, T>::value>;
+
+		template <class T, class U>
+		using enable_assign_forward = detail::enable_if_t<!std::is_same<optional<T>, detail::decay_t<U>>::value
+		     && !detail::conjunction<std::is_scalar<T>, std::is_same<T, detail::decay_t<U>>>::value && std::is_constructible<T, U>::value
+		     && std::is_assignable<T&, U>::value>;
+
+		template <class T, class U, class Other>
+		using enable_assign_from_other = detail::enable_if_t<std::is_constructible<T, Other>::value && std::is_assignable<T&, Other>::value
+		     && !std::is_constructible<T, optional<U>&>::value && !std::is_constructible<T, optional<U>&&>::value
+		     && !std::is_constructible<T, const optional<U>&>::value && !std::is_constructible<T, const optional<U>&&>::value
+		     && !std::is_convertible<optional<U>&, T>::value && !std::is_convertible<optional<U>&&, T>::value
+		     && !std::is_convertible<const optional<U>&, T>::value && !std::is_convertible<const optional<U>&&, T>::value
+		     && !std::is_assignable<T&, optional<U>&>::value && !std::is_assignable<T&, optional<U>&&>::value
+		     && !std::is_assignable<T&, const optional<U>&>::value && !std::is_assignable<T&, const optional<U>&&>::value>;
+
+#ifdef _MSC_VER
+		// TODO make a version which works with MSVC
+		template <class T, class U = T>
+		struct is_swappable : std::true_type {};
+
+		template <class T, class U = T>
+		struct is_nothrow_swappable : std::true_type {};
+#else
+		// https://stackoverflow.com/questions/26744589/what-is-a-proper-way-to-implement-is-swappable-to-test-for-the-swappable-concept
+		namespace swap_adl_tests {
+			// if swap ADL finds this then it would call std::swap otherwise (same
+			// signature)
+			struct tag {};
+
+			template <class T>
+			tag swap(T&, T&);
+			template <class T, std::size_t N>
+			tag swap(T (&a)[N], T (&b)[N]);
+
+			// helper functions to test if an unqualified swap is possible, and if it
+			// becomes std::swap
+			template <class, class>
+			std::false_type can_swap(...) noexcept(false);
+			template <class T, class U, class = decltype(swap(std::declval<T&>(), std::declval<U&>()))>
+			std::true_type can_swap(int) noexcept(noexcept(swap(std::declval<T&>(), std::declval<U&>())));
+
+			template <class, class>
+			std::false_type uses_std(...);
+			template <class T, class U>
+			std::is_same<decltype(swap(std::declval<T&>(), std::declval<U&>())), tag> uses_std(int);
+
+			template <class T>
+			struct is_std_swap_noexcept
+			: std::integral_constant<bool, std::is_nothrow_move_constructible<T>::value && std::is_nothrow_move_assignable<T>::value> {};
+
+			template <class T, std::size_t N>
+			struct is_std_swap_noexcept<T[N]> : is_std_swap_noexcept<T> {};
+
+			template <class T, class U>
+			struct is_adl_swap_noexcept : std::integral_constant<bool, noexcept(can_swap<T, U>(0))> {};
+		} // namespace swap_adl_tests
+
+		template <class T, class U = T>
+		struct is_swappable : std::integral_constant<bool,
+		                           decltype(detail::swap_adl_tests::can_swap<T, U>(0))::value
+		                                && (!decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value
+		                                     || (std::is_move_assignable<T>::value && std::is_move_constructible<T>::value))> {};
+
+		template <class T, std::size_t N>
+		struct is_swappable<T[N], T[N]> : std::integral_constant<bool,
+		                                       decltype(detail::swap_adl_tests::can_swap<T[N], T[N]>(0))::value
+		                                            && (!decltype(detail::swap_adl_tests::uses_std<T[N], T[N]>(0))::value || is_swappable<T, T>::value)> {};
+
+		template <class T, class U = T>
+		struct is_nothrow_swappable
+		: std::integral_constant<bool,
+		       is_swappable<T, U>::value
+		            && ((decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value&& detail::swap_adl_tests::is_std_swap_noexcept<T>::value)
+		                 || (!decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value&& detail::swap_adl_tests::is_adl_swap_noexcept<T, U>::value))> {};
+#endif
+
+		// The storage base manages the actual storage, and correctly propagates
+		// trivial destruction from T. This case is for when T is not trivially
+		// destructible.
+		template <class T, bool = ::std::is_trivially_destructible<T>::value>
+		struct optional_storage_base {
+			SOL_TL_OPTIONAL_11_CONSTEXPR optional_storage_base() noexcept : m_dummy(), m_has_value(false) {
+			}
+
+			template <class... U>
+			SOL_TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t, U&&... u) : m_value(std::forward<U>(u)...), m_has_value(true) {
+			}
+
+			~optional_storage_base() {
+				if (m_has_value) {
+					m_value.~T();
+					m_has_value = false;
+				}
+			}
+
+			struct dummy {};
+			union {
+				dummy m_dummy;
+				T m_value;
+			};
+
+			bool m_has_value;
+		};
+
+		// This case is for when T is trivially destructible.
+		template <class T>
+		struct optional_storage_base<T, true> {
+			SOL_TL_OPTIONAL_11_CONSTEXPR optional_storage_base() noexcept : m_dummy(), m_has_value(false) {
+			}
+
+			template <class... U>
+			SOL_TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t, U&&... u) : m_value(std::forward<U>(u)...), m_has_value(true) {
+			}
+
+			// No destructor, so this class is trivially destructible
+
+			struct dummy {};
+			union {
+				dummy m_dummy;
+				T m_value;
+			};
+
+			bool m_has_value = false;
+		};
+
+		// This base class provides some handy member functions which can be used in
+		// further derived classes
+		template <class T>
+		struct optional_operations_base : optional_storage_base<T> {
+			using optional_storage_base<T>::optional_storage_base;
+
+			void hard_reset() noexcept {
+				get().~T();
+				this->m_has_value = false;
+			}
+
+			template <class... Args>
+			void construct(Args&&... args) noexcept {
+				new (std::addressof(this->m_value)) T(std::forward<Args>(args)...);
+				this->m_has_value = true;
+			}
+
+			template <class Opt>
+			void assign(Opt&& rhs) {
+				if (this->has_value()) {
+					if (rhs.has_value()) {
+						this->m_value = std::forward<Opt>(rhs).get();
+					}
+					else {
+						this->m_value.~T();
+						this->m_has_value = false;
+					}
+				}
+
+				else if (rhs.has_value()) {
+					construct(std::forward<Opt>(rhs).get());
+				}
+			}
+
+			bool has_value() const {
+				return this->m_has_value;
+			}
+
+			SOL_TL_OPTIONAL_11_CONSTEXPR T& get() & {
+				return this->m_value;
+			}
+			SOL_TL_OPTIONAL_11_CONSTEXPR const T& get() const& {
+				return this->m_value;
+			}
+			SOL_TL_OPTIONAL_11_CONSTEXPR T&& get() && {
+				return std::move(this->m_value);
+			}
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+			constexpr const T&& get() const&& {
+				return std::move(this->m_value);
+			}
+#endif
+		};
+
+		// This class manages conditionally having a trivial copy constructor
+		// This specialization is for when T is trivially copy constructible
+		template <class T, bool = SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)>
+		struct optional_copy_base : optional_operations_base<T> {
+			using optional_operations_base<T>::optional_operations_base;
+		};
+
+		// This specialization is for when T is not trivially copy constructible
+		template <class T>
+		struct optional_copy_base<T, false> : optional_operations_base<T> {
+			using base_t = optional_operations_base<T>;
+
+			using base_t::base_t;
+
+			optional_copy_base() = default;
+			optional_copy_base(const optional_copy_base& rhs) : base_t() {
+				if (rhs.has_value()) {
+					this->construct(rhs.get());
+				}
+				else {
+					this->m_has_value = false;
+				}
+			}
+
+			optional_copy_base(optional_copy_base&& rhs) = default;
+			optional_copy_base& operator=(const optional_copy_base& rhs) = default;
+			optional_copy_base& operator=(optional_copy_base&& rhs) = default;
+		};
+
+#ifndef SOL_TL_OPTIONAL_GCC49
+		template <class T, bool = std::is_trivially_move_constructible<T>::value>
+		struct optional_move_base : optional_copy_base<T> {
+			using optional_copy_base<T>::optional_copy_base;
+		};
+#else
+		template <class T, bool = false>
+		struct optional_move_base;
+#endif
+		template <class T>
+		struct optional_move_base<T, false> : optional_copy_base<T> {
+			using optional_copy_base<T>::optional_copy_base;
+
+			optional_move_base() = default;
+			optional_move_base(const optional_move_base& rhs) = default;
+
+			optional_move_base(optional_move_base&& rhs) noexcept(std::is_nothrow_move_constructible<T>::value) {
+				if (rhs.has_value()) {
+					this->construct(std::move(rhs.get()));
+				}
+				else {
+					this->m_has_value = false;
+				}
+			}
+			optional_move_base& operator=(const optional_move_base& rhs) = default;
+			optional_move_base& operator=(optional_move_base&& rhs) = default;
+		};
+
+		// This class manages conditionally having a trivial copy assignment operator
+		template <class T,
+		     bool = SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) && SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)
+		          && SOL_TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T)>
+		struct optional_copy_assign_base : optional_move_base<T> {
+			using optional_move_base<T>::optional_move_base;
+		};
+
+		template <class T>
+		struct optional_copy_assign_base<T, false> : optional_move_base<T> {
+			using optional_move_base<T>::optional_move_base;
+
+			optional_copy_assign_base() = default;
+			optional_copy_assign_base(const optional_copy_assign_base& rhs) = default;
+
+			optional_copy_assign_base(optional_copy_assign_base&& rhs) = default;
+			optional_copy_assign_base& operator=(const optional_copy_assign_base& rhs) {
+				this->assign(rhs);
+				return *this;
+			}
+			optional_copy_assign_base& operator=(optional_copy_assign_base&& rhs) = default;
+		};
+
+#ifndef SOL_TL_OPTIONAL_GCC49
+		template <class T,
+		     bool = std::is_trivially_destructible<T>::value&& std::is_trivially_move_constructible<T>::value&& std::is_trivially_move_assignable<T>::value>
+		struct optional_move_assign_base : optional_copy_assign_base<T> {
+			using optional_copy_assign_base<T>::optional_copy_assign_base;
+		};
+#else
+		template <class T, bool = false>
+		struct optional_move_assign_base;
+#endif
+
+		template <class T>
+		struct optional_move_assign_base<T, false> : optional_copy_assign_base<T> {
+			using optional_copy_assign_base<T>::optional_copy_assign_base;
+
+			optional_move_assign_base() = default;
+			optional_move_assign_base(const optional_move_assign_base& rhs) = default;
+
+			optional_move_assign_base(optional_move_assign_base&& rhs) = default;
+
+			optional_move_assign_base& operator=(const optional_move_assign_base& rhs) = default;
+
+			optional_move_assign_base& operator=(optional_move_assign_base&& rhs) noexcept(
+			     std::is_nothrow_move_constructible<T>::value&& std::is_nothrow_move_assignable<T>::value) {
+				this->assign(std::move(rhs));
+				return *this;
+			}
+		};
+
+		// optional_delete_ctor_base will conditionally delete copy and move
+		// constructors depending on whether T is copy/move constructible
+		template <class T, bool EnableCopy = std::is_copy_constructible<T>::value, bool EnableMove = std::is_move_constructible<T>::value>
+		struct optional_delete_ctor_base {
+			optional_delete_ctor_base() = default;
+			optional_delete_ctor_base(const optional_delete_ctor_base&) = default;
+			optional_delete_ctor_base(optional_delete_ctor_base&&) noexcept = default;
+			optional_delete_ctor_base& operator=(const optional_delete_ctor_base&) = default;
+			optional_delete_ctor_base& operator=(optional_delete_ctor_base&&) noexcept = default;
+		};
+
+		template <class T>
+		struct optional_delete_ctor_base<T, true, false> {
+			optional_delete_ctor_base() = default;
+			optional_delete_ctor_base(const optional_delete_ctor_base&) = default;
+			optional_delete_ctor_base(optional_delete_ctor_base&&) noexcept = delete;
+			optional_delete_ctor_base& operator=(const optional_delete_ctor_base&) = default;
+			optional_delete_ctor_base& operator=(optional_delete_ctor_base&&) noexcept = default;
+		};
+
+		template <class T>
+		struct optional_delete_ctor_base<T, false, true> {
+			optional_delete_ctor_base() = default;
+			optional_delete_ctor_base(const optional_delete_ctor_base&) = delete;
+			optional_delete_ctor_base(optional_delete_ctor_base&&) noexcept = default;
+			optional_delete_ctor_base& operator=(const optional_delete_ctor_base&) = default;
+			optional_delete_ctor_base& operator=(optional_delete_ctor_base&&) noexcept = default;
+		};
+
+		template <class T>
+		struct optional_delete_ctor_base<T, false, false> {
+			optional_delete_ctor_base() = default;
+			optional_delete_ctor_base(const optional_delete_ctor_base&) = delete;
+			optional_delete_ctor_base(optional_delete_ctor_base&&) noexcept = delete;
+			optional_delete_ctor_base& operator=(const optional_delete_ctor_base&) = default;
+			optional_delete_ctor_base& operator=(optional_delete_ctor_base&&) noexcept = default;
+		};
+
+		// optional_delete_assign_base will conditionally delete copy and move
+		// constructors depending on whether T is copy/move constructible + assignable
+		template <class T, bool EnableCopy = (std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value),
+		     bool EnableMove = (std::is_move_constructible<T>::value && std::is_move_assignable<T>::value)>
+		struct optional_delete_assign_base {
+			optional_delete_assign_base() = default;
+			optional_delete_assign_base(const optional_delete_assign_base&) = default;
+			optional_delete_assign_base(optional_delete_assign_base&&) noexcept = default;
+			optional_delete_assign_base& operator=(const optional_delete_assign_base&) = default;
+			optional_delete_assign_base& operator=(optional_delete_assign_base&&) noexcept = default;
+		};
+
+		template <class T>
+		struct optional_delete_assign_base<T, true, false> {
+			optional_delete_assign_base() = default;
+			optional_delete_assign_base(const optional_delete_assign_base&) = default;
+			optional_delete_assign_base(optional_delete_assign_base&&) noexcept = default;
+			optional_delete_assign_base& operator=(const optional_delete_assign_base&) = default;
+			optional_delete_assign_base& operator=(optional_delete_assign_base&&) noexcept = delete;
+		};
+
+		template <class T>
+		struct optional_delete_assign_base<T, false, true> {
+			optional_delete_assign_base() = default;
+			optional_delete_assign_base(const optional_delete_assign_base&) = default;
+			optional_delete_assign_base(optional_delete_assign_base&&) noexcept = default;
+			optional_delete_assign_base& operator=(const optional_delete_assign_base&) = delete;
+			optional_delete_assign_base& operator=(optional_delete_assign_base&&) noexcept = default;
+		};
+
+		template <class T>
+		struct optional_delete_assign_base<T, false, false> {
+			optional_delete_assign_base() = default;
+			optional_delete_assign_base(const optional_delete_assign_base&) = default;
+			optional_delete_assign_base(optional_delete_assign_base&&) noexcept = default;
+			optional_delete_assign_base& operator=(const optional_delete_assign_base&) = delete;
+			optional_delete_assign_base& operator=(optional_delete_assign_base&&) noexcept = delete;
+		};
+
+	} // namespace detail
+
+	/// \brief A tag type to represent an empty optional
+	using nullopt_t = std::nullopt_t;
+
+	/// \brief Represents an empty optional
+	/// \synopsis static constexpr nullopt_t nullopt;
+	///
+	/// *Examples*:
+	/// ```
+	/// sol::optional<int> a = sol::nullopt;
+	/// void foo (sol::optional<int>);
+	/// foo(sol::nullopt); //pass an empty optional
+	/// ```
+	using std::nullopt;
+
+	class bad_optional_access : public std::exception {
+	public:
+		bad_optional_access() = default;
+		const char* what() const noexcept {
+			return "Optional has no value";
+		}
+	};
+
+	/// An optional object is an object that contains the storage for another
+	/// object and manages the lifetime of this contained object, if any. The
+	/// contained object may be initialized after the optional object has been
+	/// initialized, and may be destroyed before the optional object has been
+	/// destroyed. The initialization state of the contained object is tracked by
+	/// the optional object.
+	template <class T>
+	class optional : private detail::optional_move_assign_base<T>,
+	                 private detail::optional_delete_ctor_base<T>,
+	                 private detail::optional_delete_assign_base<T> {
+		using base = detail::optional_move_assign_base<T>;
+
+		static_assert(!std::is_same<T, in_place_t>::value, "instantiation of optional with in_place_t is ill-formed");
+		static_assert(!std::is_same<detail::decay_t<T>, nullopt_t>::value, "instantiation of optional with nullopt_t is ill-formed");
+
+	public:
+#if defined(SOL_TL_OPTIONAL_CXX14) && !defined(SOL_TL_OPTIONAL_GCC49) && !defined(SOL_TL_OPTIONAL_GCC54) && !defined(SOL_TL_OPTIONAL_GCC55)
+		/// \group and_then
+		/// Carries out some operation which returns an optional on the stored
+		/// object if there is one. \requires `std::invoke(std::forward<F>(f),
+		/// value())` returns a `std::optional<U>` for some `U`. \returns Let `U` be
+		/// the result of `std::invoke(std::forward<F>(f), value())`. Returns a
+		/// `std::optional<U>`. The return value is empty if `*this` is empty,
+		/// otherwise the return value of `std::invoke(std::forward<F>(f), value())`
+		/// is returned.
+		/// \group and_then
+		/// \synopsis template <class F>\nconstexpr auto and_then(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto and_then(F&& f) & {
+			using result = detail::invoke_result_t<F, T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F>\nconstexpr auto and_then(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto and_then(F&& f) && {
+			using result = detail::invoke_result_t<F, T&&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F>\nconstexpr auto and_then(F &&f) const &;
+		template <class F>
+		constexpr auto and_then(F&& f) const& {
+			using result = detail::invoke_result_t<F, const T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group and_then
+		/// \synopsis template <class F>\nconstexpr auto and_then(F &&f) const &&;
+		template <class F>
+		constexpr auto and_then(F&& f) const&& {
+			using result = detail::invoke_result_t<F, const T&&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : result(nullopt);
+		}
+#endif
+#else
+		/// \group and_then
+		/// Carries out some operation which returns an optional on the stored
+		/// object if there is one. \requires `std::invoke(std::forward<F>(f),
+		/// value())` returns a `std::optional<U>` for some `U`.
+		/// \returns Let `U` be the result of `std::invoke(std::forward<F>(f),
+		/// value())`. Returns a `std::optional<U>`. The return value is empty if
+		/// `*this` is empty, otherwise the return value of
+		/// `std::invoke(std::forward<F>(f), value())` is returned.
+		/// \group and_then
+		/// \synopsis template <class F>\nconstexpr auto and_then(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T&> and_then(F&& f) & {
+			using result = detail::invoke_result_t<F, T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F>\nconstexpr auto and_then(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T&&> and_then(F&& f) && {
+			using result = detail::invoke_result_t<F, T&&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F>\nconstexpr auto and_then(F &&f) const &;
+		template <class F>
+		constexpr detail::invoke_result_t<F, const T&> and_then(F&& f) const& {
+			using result = detail::invoke_result_t<F, const T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group and_then
+		/// \synopsis template <class F>\nconstexpr auto and_then(F &&f) const &&;
+		template <class F>
+		constexpr detail::invoke_result_t<F, const T&&> and_then(F&& f) const&& {
+			using result = detail::invoke_result_t<F, const T&&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : result(nullopt);
+		}
+#endif
+#endif
+
+#if defined(SOL_TL_OPTIONAL_CXX14) && !defined(SOL_TL_OPTIONAL_GCC49) && !defined(SOL_TL_OPTIONAL_GCC54) && !defined(SOL_TL_OPTIONAL_GCC55)
+		/// \brief Carries out some operation on the stored object if there is one.
+		/// \returns Let `U` be the result of `std::invoke(std::forward<F>(f),
+		/// value())`. Returns a `std::optional<U>`. The return value is empty if
+		/// `*this` is empty, otherwise an `optional<U>` is constructed from the
+		/// return value of `std::invoke(std::forward<F>(f), value())` and is
+		/// returned.
+		///
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto map(F&& f) & {
+			return optional_map_impl(*this, std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto map(F&& f) && {
+			return optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) const&;
+		template <class F>
+		constexpr auto map(F&& f) const& {
+			return optional_map_impl(*this, std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) const&&;
+		template <class F>
+		constexpr auto map(F&& f) const&& {
+			return optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+#else
+		/// \brief Carries out some operation on the stored object if there is one.
+		/// \returns Let `U` be the result of `std::invoke(std::forward<F>(f),
+		/// value())`. Returns a `std::optional<U>`. The return value is empty if
+		/// `*this` is empty, otherwise an `optional<U>` is constructed from the
+		/// return value of `std::invoke(std::forward<F>(f), value())` and is
+		/// returned.
+		///
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<optional&>(), std::declval<F&&>())) map(F&& f) & {
+			return optional_map_impl(*this, std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<optional&&>(), std::declval<F&&>())) map(F&& f) && {
+			return optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) const&;
+		template <class F>
+		constexpr decltype(optional_map_impl(std::declval<const optional&>(), std::declval<F&&>())) map(F&& f) const& {
+			return optional_map_impl(*this, std::forward<F>(f));
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) const&&;
+		template <class F>
+		constexpr decltype(optional_map_impl(std::declval<const optional&&>(), std::declval<F&&>())) map(F&& f) const&& {
+			return optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+#endif
+#endif
+
+		/// \brief Calls `f` if the optional is empty
+		/// \requires `std::invoke_result_t<F>` must be void or convertible to
+		/// `optional<T>`.
+		/// \effects If `*this` has a value, returns `*this`.
+		/// Otherwise, if `f` returns `void`, calls `std::forward<F>(f)` and returns
+		/// `std::nullopt`. Otherwise, returns `std::forward<F>(f)()`.
+		///
+		/// \group or_else
+		/// \synopsis template <class F> optional<T> or_else (F &&f) &;
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) & {
+			if (has_value())
+				return *this;
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) & {
+			return has_value() ? *this : std::forward<F>(f)();
+		}
+
+		/// \group or_else
+		/// \synopsis template <class F> optional<T> or_else (F &&f) &&;
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) && {
+			if (has_value())
+				return std::move(*this);
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) && {
+			return has_value() ? std::move(*this) : std::forward<F>(f)();
+		}
+
+		/// \group or_else
+		/// \synopsis template <class F> optional<T> or_else (F &&f) const &;
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) const& {
+			if (has_value())
+				return *this;
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) const& {
+			return has_value() ? *this : std::forward<F>(f)();
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \exclude
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) const&& {
+			if (has_value())
+				return std::move(*this);
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) const&& {
+			return has_value() ? std::move(*this) : std::forward<F>(f)();
+		}
+#endif
+
+		/// \brief Maps the stored value with `f` if there is one, otherwise returns
+		/// `u`.
+		///
+		/// \details If there is a value stored, then `f` is called with `**this`
+		/// and the value is returned. Otherwise `u` is returned.
+		///
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) & {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u);
+		}
+
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) && {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u);
+		}
+
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) const& {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) const&& {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u);
+		}
+#endif
+
+		/// \brief Maps the stored value with `f` if there is one, otherwise calls
+		/// `u` and returns the result.
+		///
+		/// \details If there is a value stored, then `f` is
+		/// called with `**this` and the value is returned. Otherwise
+		/// `std::forward<U>(u)()` is returned.
+		///
+		/// \group map_or_else
+		/// \synopsis template <class F, class U>\nauto map_or_else(F &&f, U &&u) &;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) & {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u)();
+		}
+
+		/// \group map_or_else
+		/// \synopsis template <class F, class U>\nauto map_or_else(F &&f, U &&u)
+		/// &&;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) && {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u)();
+		}
+
+		/// \group map_or_else
+		/// \synopsis template <class F, class U>\nauto map_or_else(F &&f, U &&u)
+		/// const &;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) const& {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u)();
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group map_or_else
+		/// \synopsis template <class F, class U>\nauto map_or_else(F &&f, U &&u)
+		/// const &&;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) const&& {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u)();
+		}
+#endif
+
+		/// \returns `u` if `*this` has a value, otherwise an empty optional.
+		template <class U>
+		constexpr optional<typename std::decay<U>::type> conjunction(U&& u) const {
+			using result = optional<detail::decay_t<U>>;
+			return has_value() ? result { u } : result { nullopt };
+		}
+
+		/// \returns `rhs` if `*this` is empty, otherwise the current value.
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional& rhs) & {
+			return has_value() ? *this : rhs;
+		}
+
+		/// \group disjunction
+		constexpr optional disjunction(const optional& rhs) const& {
+			return has_value() ? *this : rhs;
+		}
+
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional& rhs) && {
+			return has_value() ? std::move(*this) : rhs;
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group disjunction
+		constexpr optional disjunction(const optional& rhs) const&& {
+			return has_value() ? std::move(*this) : rhs;
+		}
+#endif
+
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional&& rhs) & {
+			return has_value() ? *this : std::move(rhs);
+		}
+
+		/// \group disjunction
+		constexpr optional disjunction(optional&& rhs) const& {
+			return has_value() ? *this : std::move(rhs);
+		}
+
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional&& rhs) && {
+			return has_value() ? std::move(*this) : std::move(rhs);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group disjunction
+		constexpr optional disjunction(optional&& rhs) const&& {
+			return has_value() ? std::move(*this) : std::move(rhs);
+		}
+#endif
+
+		/// Takes the value out of the optional, leaving it empty
+		/// \group take
+		optional take() & {
+			optional ret = *this;
+			reset();
+			return ret;
+		}
+
+		/// \group take
+		optional take() const& {
+			optional ret = *this;
+			reset();
+			return ret;
+		}
+
+		/// \group take
+		optional take() && {
+			optional ret = std::move(*this);
+			reset();
+			return ret;
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group take
+		optional take() const&& {
+			optional ret = std::move(*this);
+			reset();
+			return ret;
+		}
+#endif
+
+		using value_type = T;
+
+		/// Constructs an optional that does not contain a value.
+		/// \group ctor_empty
+		constexpr optional() noexcept = default;
+
+		/// \group ctor_empty
+		constexpr optional(nullopt_t) noexcept {
+		}
+
+		/// Copy constructor
+		///
+		/// If `rhs` contains a value, the stored value is direct-initialized with
+		/// it. Otherwise, the constructed optional is empty.
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional(const optional& rhs) = default;
+
+		/// Move constructor
+		///
+		/// If `rhs` contains a value, the stored value is direct-initialized with
+		/// it. Otherwise, the constructed optional is empty.
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional(optional&& rhs) = default;
+
+		/// Constructs the stored value in-place using the given arguments.
+		/// \group in_place
+		/// \synopsis template <class... Args> constexpr explicit optional(in_place_t, Args&&... args);
+		template <class... Args>
+		constexpr explicit optional(detail::enable_if_t<std::is_constructible<T, Args...>::value, in_place_t>, Args&&... args)
+		: base(in_place, std::forward<Args>(args)...) {
+		}
+
+		/// \group in_place
+		/// \synopsis template <class U, class... Args>\nconstexpr explicit optional(in_place_t, std::initializer_list<U>&, Args&&... args);
+		template <class U, class... Args>
+		SOL_TL_OPTIONAL_11_CONSTEXPR explicit optional(detail::enable_if_t<std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value, in_place_t>,
+		     std::initializer_list<U> il, Args&&... args) {
+			this->construct(il, std::forward<Args>(args)...);
+		}
+
+#if 0 // SOL_MODIFICATION
+      /// Constructs the stored value with `u`.
+      /// \synopsis template <class U=T> constexpr optional(U &&u);
+		template <class U = T, detail::enable_if_t<std::is_convertible<U&&, T>::value>* = nullptr, detail::enable_forward_value<T, U>* = nullptr>
+		constexpr optional(U&& u) : base(in_place, std::forward<U>(u)) {
+		}
+
+		/// \exclude
+		template <class U = T, detail::enable_if_t<!std::is_convertible<U&&, T>::value>* = nullptr, detail::enable_forward_value<T, U>* = nullptr>
+		constexpr explicit optional(U&& u) : base(in_place, std::forward<U>(u)) {
+		}
+#else
+		/// Constructs the stored value with `u`.
+		/// \synopsis template <class U=T> constexpr optional(U &&u);
+		constexpr optional(T&& u) : base(in_place, std::move(u)) {
+		}
+
+		/// \exclude
+		constexpr optional(const T& u) : base(in_place, u) {
+		}
+#endif // sol3 modification
+
+		/// Converting copy constructor.
+		/// \synopsis template <class U> optional(const optional<U> &rhs);
+		template <class U, detail::enable_from_other<T, U, const U&>* = nullptr, detail::enable_if_t<std::is_convertible<const U&, T>::value>* = nullptr>
+		optional(const optional<U>& rhs) {
+			if (rhs.has_value()) {
+				this->construct(*rhs);
+			}
+		}
+
+		/// \exclude
+		template <class U, detail::enable_from_other<T, U, const U&>* = nullptr, detail::enable_if_t<!std::is_convertible<const U&, T>::value>* = nullptr>
+		explicit optional(const optional<U>& rhs) {
+			if (rhs.has_value()) {
+				this->construct(*rhs);
+			}
+		}
+
+		/// Converting move constructor.
+		/// \synopsis template <class U> optional(optional<U> &&rhs);
+		template <class U, detail::enable_from_other<T, U, U&&>* = nullptr, detail::enable_if_t<std::is_convertible<U&&, T>::value>* = nullptr>
+		optional(optional<U>&& rhs) {
+			if (rhs.has_value()) {
+				this->construct(std::move(*rhs));
+			}
+		}
+
+		/// \exclude
+		template <class U, detail::enable_from_other<T, U, U&&>* = nullptr, detail::enable_if_t<!std::is_convertible<U&&, T>::value>* = nullptr>
+		explicit optional(optional<U>&& rhs) {
+			this->construct(std::move(*rhs));
+		}
+
+		/// Destroys the stored value if there is one.
+		~optional() = default;
+
+		/// Assignment to empty.
+		///
+		/// Destroys the current value if there is one.
+		optional& operator=(nullopt_t) noexcept {
+			if (has_value()) {
+				this->m_value.~T();
+				this->m_has_value = false;
+			}
+
+			return *this;
+		}
+
+		/// Copy assignment.
+		///
+		/// Copies the value from `rhs` if there is one. Otherwise resets the stored
+		/// value in `*this`.
+		optional& operator=(const optional& rhs) = default;
+
+		/// Move assignment.
+		///
+		/// Moves the value from `rhs` if there is one. Otherwise resets the stored
+		/// value in `*this`.
+		optional& operator=(optional&& rhs) = default;
+
+		/// Assigns the stored value from `u`, destroying the old value if there was
+		/// one.
+		/// \synopsis optional &operator=(U &&u);
+		template <class U = T, detail::enable_assign_forward<T, U>* = nullptr>
+		optional& operator=(U&& u) {
+			if (has_value()) {
+				this->m_value = std::forward<U>(u);
+			}
+			else {
+				this->construct(std::forward<U>(u));
+			}
+
+			return *this;
+		}
+
+		/// Converting copy assignment operator.
+		///
+		/// Copies the value from `rhs` if there is one. Otherwise resets the stored
+		/// value in `*this`.
+		/// \synopsis optional &operator=(const optional<U> & rhs);
+		template <class U, detail::enable_assign_from_other<T, U, const U&>* = nullptr>
+		optional& operator=(const optional<U>& rhs) {
+			if (has_value()) {
+				if (rhs.has_value()) {
+					this->m_value = *rhs;
+				}
+				else {
+					this->hard_reset();
+				}
+			}
+
+			if (rhs.has_value()) {
+				this->construct(*rhs);
+			}
+
+			return *this;
+		}
+
+		// TODO check exception guarantee
+		/// Converting move assignment operator.
+		///
+		/// Moves the value from `rhs` if there is one. Otherwise resets the stored
+		/// value in `*this`.
+		/// \synopsis optional &operator=(optional<U> && rhs);
+		template <class U, detail::enable_assign_from_other<T, U, U>* = nullptr>
+		optional& operator=(optional<U>&& rhs) {
+			if (has_value()) {
+				if (rhs.has_value()) {
+					this->m_value = std::move(*rhs);
+				}
+				else {
+					this->hard_reset();
+				}
+			}
+
+			if (rhs.has_value()) {
+				this->construct(std::move(*rhs));
+			}
+
+			return *this;
+		}
+
+		/// Constructs the value in-place, destroying the current one if there is
+		/// one.
+		/// \group emplace
+		template <class... Args>
+		T& emplace(Args&&... args) {
+			static_assert(std::is_constructible<T, Args&&...>::value, "T must be constructible with Args");
+
+			*this = nullopt;
+			this->construct(std::forward<Args>(args)...);
+			return value();
+		}
+
+		/// \group emplace
+		/// \synopsis template <class U, class... Args>\nT& emplace(std::initializer_list<U> il, Args &&... args);
+		template <class U, class... Args>
+		detail::enable_if_t<std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value, T&> emplace(std::initializer_list<U> il, Args&&... args) {
+			*this = nullopt;
+			this->construct(il, std::forward<Args>(args)...);
+			return value();
+		}
+
+		/// Swaps this optional with the other.
+		///
+		/// If neither optionals have a value, nothing happens.
+		/// If both have a value, the values are swapped.
+		/// If one has a value, it is moved to the other and the movee is left
+		/// valueless.
+		void swap(optional& rhs) noexcept(std::is_nothrow_move_constructible<T>::value&& detail::is_nothrow_swappable<T>::value) {
+			if (has_value()) {
+				if (rhs.has_value()) {
+					using std::swap;
+					swap(**this, *rhs);
+				}
+				else {
+					new (std::addressof(rhs.m_value)) T(std::move(this->m_value));
+					this->m_value.T::~T();
+				}
+			}
+			else if (rhs.has_value()) {
+				new (std::addressof(this->m_value)) T(std::move(rhs.m_value));
+				rhs.m_value.T::~T();
+			}
+		}
+
+		/// \returns a pointer to the stored value
+		/// \requires a value is stored
+		/// \group pointer
+		/// \synopsis constexpr const T *operator->() const;
+		constexpr const T* operator->() const {
+			return std::addressof(this->m_value);
+		}
+
+		/// \group pointer
+		/// \synopsis constexpr T *operator->();
+		SOL_TL_OPTIONAL_11_CONSTEXPR T* operator->() {
+			return std::addressof(this->m_value);
+		}
+
+		/// \returns the stored value
+		/// \requires a value is stored
+		/// \group deref
+		/// \synopsis constexpr T &operator*();
+		SOL_TL_OPTIONAL_11_CONSTEXPR T& operator*() & {
+			return this->m_value;
+		}
+
+		/// \group deref
+		/// \synopsis constexpr const T &operator*() const;
+		constexpr const T& operator*() const& {
+			return this->m_value;
+		}
+
+		/// \exclude
+		SOL_TL_OPTIONAL_11_CONSTEXPR T&& operator*() && {
+			return std::move(this->m_value);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \exclude
+		constexpr const T&& operator*() const&& {
+			return std::move(this->m_value);
+		}
+#endif
+
+		/// \returns whether or not the optional has a value
+		/// \group has_value
+		constexpr bool has_value() const noexcept {
+			return this->m_has_value;
+		}
+
+		/// \group has_value
+		constexpr explicit operator bool() const noexcept {
+			return this->m_has_value;
+		}
+
+		/// \returns the contained value if there is one, otherwise throws
+		/// [bad_optional_access]
+		/// \group value
+		/// \synopsis constexpr T &value();
+		SOL_TL_OPTIONAL_11_CONSTEXPR T& value() & {
+			if (has_value())
+				return this->m_value;
+#if SOL_IS_OFF(SOL_EXCEPTIONS_I_)
+			std::abort();
+#else
+			throw bad_optional_access();
+#endif // No exceptions allowed
+		}
+		/// \group value
+		/// \synopsis constexpr const T &value() const;
+		SOL_TL_OPTIONAL_11_CONSTEXPR const T& value() const& {
+			if (has_value())
+				return this->m_value;
+#if SOL_IS_OFF(SOL_EXCEPTIONS_I_)
+			std::abort();
+#else
+			throw bad_optional_access();
+#endif // No exceptions allowed
+		}
+		/// \exclude
+		SOL_TL_OPTIONAL_11_CONSTEXPR T&& value() && {
+			if (has_value())
+				return std::move(this->m_value);
+#if SOL_IS_OFF(SOL_EXCEPTIONS_I_)
+			std::abort();
+#else
+			throw bad_optional_access();
+#endif // No exceptions allowed
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \exclude
+		SOL_TL_OPTIONAL_11_CONSTEXPR const T&& value() const&& {
+			if (has_value())
+				return std::move(this->m_value);
+#if SOL_IS_OFF(SOL_EXCEPTIONS_I_)
+			std::abort();
+#else
+			throw bad_optional_access();
+#endif // No exceptions allowed
+		}
+#endif
+
+		/// \returns the stored value if there is one, otherwise returns `u`
+		/// \group value_or
+		template <class U>
+		constexpr T value_or(U&& u) const& {
+			static_assert(std::is_copy_constructible<T>::value && std::is_convertible<U&&, T>::value, "T must be copy constructible and convertible from U");
+			return has_value() ? **this : static_cast<T>(std::forward<U>(u));
+		}
+
+		/// \group value_or
+		template <class U>
+		SOL_TL_OPTIONAL_11_CONSTEXPR T value_or(U&& u) && {
+			static_assert(std::is_move_constructible<T>::value && std::is_convertible<U&&, T>::value, "T must be move constructible and convertible from U");
+			return has_value() ? **this : static_cast<T>(std::forward<U>(u));
+		}
+
+		/// Destroys the stored value if one exists, making the optional empty
+		void reset() noexcept {
+			if (has_value()) {
+				this->m_value.~T();
+				this->m_has_value = false;
+			}
+		}
+	}; // namespace sol
+
+	/// \group relop
+	/// \brief Compares two optional objects
+	/// \details If both optionals contain a value, they are compared with `T`s
+	/// relational operators. Otherwise `lhs` and `rhs` are equal only if they are
+	/// both empty, and `lhs` is less than `rhs` only if `rhs` is empty and `lhs`
+	/// is not.
+	template <class T, class U>
+	inline constexpr bool operator==(const optional<T>& lhs, const optional<U>& rhs) {
+		return lhs.has_value() == rhs.has_value() && (!lhs.has_value() || *lhs == *rhs);
+	}
+	/// \group relop
+	template <class T, class U>
+	inline constexpr bool operator!=(const optional<T>& lhs, const optional<U>& rhs) {
+		return lhs.has_value() != rhs.has_value() || (lhs.has_value() && *lhs != *rhs);
+	}
+	/// \group relop
+	template <class T, class U>
+	inline constexpr bool operator<(const optional<T>& lhs, const optional<U>& rhs) {
+		return rhs.has_value() && (!lhs.has_value() || *lhs < *rhs);
+	}
+	/// \group relop
+	template <class T, class U>
+	inline constexpr bool operator>(const optional<T>& lhs, const optional<U>& rhs) {
+		return lhs.has_value() && (!rhs.has_value() || *lhs > *rhs);
+	}
+	/// \group relop
+	template <class T, class U>
+	inline constexpr bool operator<=(const optional<T>& lhs, const optional<U>& rhs) {
+		return !lhs.has_value() || (rhs.has_value() && *lhs <= *rhs);
+	}
+	/// \group relop
+	template <class T, class U>
+	inline constexpr bool operator>=(const optional<T>& lhs, const optional<U>& rhs) {
+		return !rhs.has_value() || (lhs.has_value() && *lhs >= *rhs);
+	}
+
+	/// \group relop_nullopt
+	/// \brief Compares an optional to a `nullopt`
+	/// \details Equivalent to comparing the optional to an empty optional
+	template <class T>
+	inline constexpr bool operator==(const optional<T>& lhs, nullopt_t) noexcept {
+		return !lhs.has_value();
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator==(nullopt_t, const optional<T>& rhs) noexcept {
+		return !rhs.has_value();
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator!=(const optional<T>& lhs, nullopt_t) noexcept {
+		return lhs.has_value();
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator!=(nullopt_t, const optional<T>& rhs) noexcept {
+		return rhs.has_value();
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator<(const optional<T>&, nullopt_t) noexcept {
+		return false;
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator<(nullopt_t, const optional<T>& rhs) noexcept {
+		return rhs.has_value();
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator<=(const optional<T>& lhs, nullopt_t) noexcept {
+		return !lhs.has_value();
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept {
+		return true;
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator>(const optional<T>& lhs, nullopt_t) noexcept {
+		return lhs.has_value();
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator>(nullopt_t, const optional<T>&) noexcept {
+		return false;
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept {
+		return true;
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator>=(nullopt_t, const optional<T>& rhs) noexcept {
+		return !rhs.has_value();
+	}
+
+	/// \group relop_t
+	/// \brief Compares the optional with a value.
+	/// \details If the optional has a value, it is compared with the other value
+	/// using `T`s relational operators. Otherwise, the optional is considered
+	/// less than the value.
+	template <class T, class U>
+	inline constexpr bool operator==(const optional<T>& lhs, const U& rhs) {
+		return lhs.has_value() ? *lhs == rhs : false;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator==(const U& lhs, const optional<T>& rhs) {
+		return rhs.has_value() ? lhs == *rhs : false;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator!=(const optional<T>& lhs, const U& rhs) {
+		return lhs.has_value() ? *lhs != rhs : true;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator!=(const U& lhs, const optional<T>& rhs) {
+		return rhs.has_value() ? lhs != *rhs : true;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator<(const optional<T>& lhs, const U& rhs) {
+		return lhs.has_value() ? *lhs < rhs : true;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator<(const U& lhs, const optional<T>& rhs) {
+		return rhs.has_value() ? lhs < *rhs : false;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator<=(const optional<T>& lhs, const U& rhs) {
+		return lhs.has_value() ? *lhs <= rhs : true;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator<=(const U& lhs, const optional<T>& rhs) {
+		return rhs.has_value() ? lhs <= *rhs : false;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator>(const optional<T>& lhs, const U& rhs) {
+		return lhs.has_value() ? *lhs > rhs : false;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator>(const U& lhs, const optional<T>& rhs) {
+		return rhs.has_value() ? lhs > *rhs : true;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator>=(const optional<T>& lhs, const U& rhs) {
+		return lhs.has_value() ? *lhs >= rhs : false;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator>=(const U& lhs, const optional<T>& rhs) {
+		return rhs.has_value() ? lhs >= *rhs : true;
+	}
+
+	/// \synopsis template <class T>\nvoid swap(optional<T> &lhs, optional<T> &rhs);
+	template <class T, detail::enable_if_t<std::is_move_constructible<T>::value>* = nullptr, detail::enable_if_t<detail::is_swappable<T>::value>* = nullptr>
+	void swap(optional<T>& lhs, optional<T>& rhs) noexcept(noexcept(lhs.swap(rhs))) {
+		return lhs.swap(rhs);
+	}
+
+	namespace detail {
+		struct i_am_secret {};
+	} // namespace detail
+
+	template <class T = detail::i_am_secret, class U, class Ret = detail::conditional_t<std::is_same<T, detail::i_am_secret>::value, detail::decay_t<U>, T>>
+	inline constexpr optional<Ret> make_optional(U&& v) {
+		return optional<Ret>(std::forward<U>(v));
+	}
+
+	template <class T, class... Args>
+	inline constexpr optional<T> make_optional(Args&&... args) {
+		return optional<T>(in_place, std::forward<Args>(args)...);
+	}
+	template <class T, class U, class... Args>
+	inline constexpr optional<T> make_optional(std::initializer_list<U> il, Args&&... args) {
+		return optional<T>(in_place, il, std::forward<Args>(args)...);
+	}
+
+#if __cplusplus >= 201703L
+	template <class T>
+	optional(T)->optional<T>;
+#endif
+
+	/// \exclude
+	namespace detail {
+#ifdef SOL_TL_OPTIONAL_CXX14
+		template <class Opt, class F, class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Opt>())),
+		     detail::enable_if_t<!std::is_void<Ret>::value>* = nullptr>
+		constexpr auto optional_map_impl(Opt&& opt, F&& f) {
+			return opt.has_value() ? detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt)) : optional<Ret>(nullopt);
+		}
+
+		template <class Opt, class F, class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Opt>())),
+		     detail::enable_if_t<std::is_void<Ret>::value>* = nullptr>
+		auto optional_map_impl(Opt&& opt, F&& f) {
+			if (opt.has_value()) {
+				detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt));
+				return make_optional(monostate {});
+			}
+
+			return optional<monostate>(nullopt);
+		}
+#else
+		template <class Opt, class F, class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Opt>())),
+		     detail::enable_if_t<!std::is_void<Ret>::value>* = nullptr>
+
+		constexpr auto optional_map_impl(Opt&& opt, F&& f) -> optional<Ret> {
+			return opt.has_value() ? detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt)) : optional<Ret>(nullopt);
+		}
+
+		template <class Opt, class F, class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Opt>())),
+		     detail::enable_if_t<std::is_void<Ret>::value>* = nullptr>
+
+		auto optional_map_impl(Opt&& opt, F&& f) -> optional<monostate> {
+			if (opt.has_value()) {
+				detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt));
+				return monostate {};
+			}
+
+			return nullopt;
+		}
+#endif
+	} // namespace detail
+
+	/// Specialization for when `T` is a reference. `optional<T&>` acts similarly
+	/// to a `T*`, but provides more operations and shows intent more clearly.
+	///
+	/// *Examples*:
+	///
+	/// ```
+	/// int i = 42;
+	/// sol::optional<int&> o = i;
+	/// *o == 42; //true
+	/// i = 12;
+	/// *o = 12; //true
+	/// &*o == &i; //true
+	/// ```
+	///
+	/// Assignment has rebind semantics rather than assign-through semantics:
+	///
+	/// ```
+	/// int j = 8;
+	/// o = j;
+	///
+	/// &*o == &j; //true
+	/// ```
+	template <class T>
+	class optional<T&> {
+	public:
+#if defined(SOL_TL_OPTIONAL_CXX14) && !defined(SOL_TL_OPTIONAL_GCC49) && !defined(SOL_TL_OPTIONAL_GCC54) && !defined(SOL_TL_OPTIONAL_GCC55)
+		/// \group and_then
+		/// Carries out some operation which returns an optional on the stored
+		/// object if there is one. \requires `std::invoke(std::forward<F>(f),
+		/// value())` returns a `std::optional<U>` for some `U`. \returns Let `U` be
+		/// the result of `std::invoke(std::forward<F>(f), value())`. Returns a
+		/// `std::optional<U>`. The return value is empty if `*this` is empty,
+		/// otherwise the return value of `std::invoke(std::forward<F>(f), value())`
+		/// is returned.
+		/// \group and_then
+		/// \synopsis template <class F>\nconstexpr auto and_then(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto and_then(F&& f) & {
+			using result = detail::invoke_result_t<F, T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F>\nconstexpr auto and_then(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto and_then(F&& f) && {
+			using result = detail::invoke_result_t<F, T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F>\nconstexpr auto and_then(F &&f) const &;
+		template <class F>
+		constexpr auto and_then(F&& f) const& {
+			using result = detail::invoke_result_t<F, const T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group and_then
+		/// \synopsis template <class F>\nconstexpr auto and_then(F &&f) const &&;
+		template <class F>
+		constexpr auto and_then(F&& f) const&& {
+			using result = detail::invoke_result_t<F, const T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+#endif
+#else
+		/// \group and_then
+		/// Carries out some operation which returns an optional on the stored
+		/// object if there is one. \requires `std::invoke(std::forward<F>(f),
+		/// value())` returns a `std::optional<U>` for some `U`. \returns Let `U` be
+		/// the result of `std::invoke(std::forward<F>(f), value())`. Returns a
+		/// `std::optional<U>`. The return value is empty if `*this` is empty,
+		/// otherwise the return value of `std::invoke(std::forward<F>(f), value())`
+		/// is returned.
+		/// \group and_then
+		/// \synopsis template <class F>\nconstexpr auto and_then(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T&> and_then(F&& f) & {
+			using result = detail::invoke_result_t<F, T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F>\nconstexpr auto and_then(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T&> and_then(F&& f) && {
+			using result = detail::invoke_result_t<F, T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F>\nconstexpr auto and_then(F &&f) const &;
+		template <class F>
+		constexpr detail::invoke_result_t<F, const T&> and_then(F&& f) const& {
+			using result = detail::invoke_result_t<F, const T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group and_then
+		/// \synopsis template <class F>\nconstexpr auto and_then(F &&f) const &&;
+		template <class F>
+		constexpr detail::invoke_result_t<F, const T&> and_then(F&& f) const&& {
+			using result = detail::invoke_result_t<F, const T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+#endif
+#endif
+
+#if defined(SOL_TL_OPTIONAL_CXX14) && !defined(SOL_TL_OPTIONAL_GCC49) && !defined(SOL_TL_OPTIONAL_GCC54) && !defined(SOL_TL_OPTIONAL_GCC55)
+		/// \brief Carries out some operation on the stored object if there is one.
+		/// \returns Let `U` be the result of `std::invoke(std::forward<F>(f),
+		/// value())`. Returns a `std::optional<U>`. The return value is empty if
+		/// `*this` is empty, otherwise an `optional<U>` is constructed from the
+		/// return value of `std::invoke(std::forward<F>(f), value())` and is
+		/// returned.
+		///
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto map(F&& f) & {
+			return detail::optional_map_impl(*this, std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto map(F&& f) && {
+			return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) const&;
+		template <class F>
+		constexpr auto map(F&& f) const& {
+			return detail::optional_map_impl(*this, std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) const&&;
+		template <class F>
+		constexpr auto map(F&& f) const&& {
+			return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+#else
+		/// \brief Carries out some operation on the stored object if there is one.
+		/// \returns Let `U` be the result of `std::invoke(std::forward<F>(f),
+		/// value())`. Returns a `std::optional<U>`. The return value is empty if
+		/// `*this` is empty, otherwise an `optional<U>` is constructed from the
+		/// return value of `std::invoke(std::forward<F>(f), value())` and is
+		/// returned.
+		///
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(std::declval<optional&>(), std::declval<F&&>())) map(F&& f) & {
+			return detail::optional_map_impl(*this, std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(std::declval<optional&&>(), std::declval<F&&>())) map(F&& f) && {
+			return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) const&;
+		template <class F>
+		constexpr decltype(detail::optional_map_impl(std::declval<const optional&>(), std::declval<F&&>())) map(F&& f) const& {
+			return detail::optional_map_impl(*this, std::forward<F>(f));
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) const&&;
+		template <class F>
+		constexpr decltype(detail::optional_map_impl(std::declval<const optional&&>(), std::declval<F&&>())) map(F&& f) const&& {
+			return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+#endif
+#endif
+
+		/// \brief Calls `f` if the optional is empty
+		/// \requires `std::invoke_result_t<F>` must be void or convertible to
+		/// `optional<T>`. \effects If `*this` has a value, returns `*this`.
+		/// Otherwise, if `f` returns `void`, calls `std::forward<F>(f)` and returns
+		/// `std::nullopt`. Otherwise, returns `std::forward<F>(f)()`.
+		///
+		/// \group or_else
+		/// \synopsis template <class F> optional<T> or_else (F &&f) &;
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) & {
+			if (has_value())
+				return *this;
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) & {
+			return has_value() ? *this : std::forward<F>(f)();
+		}
+
+		/// \group or_else
+		/// \synopsis template <class F> optional<T> or_else (F &&f) &&;
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) && {
+			if (has_value())
+				return std::move(*this);
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) && {
+			return has_value() ? std::move(*this) : std::forward<F>(f)();
+		}
+
+		/// \group or_else
+		/// \synopsis template <class F> optional<T> or_else (F &&f) const &;
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) const& {
+			if (has_value())
+				return *this;
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) const& {
+			return has_value() ? *this : std::forward<F>(f)();
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \exclude
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) const&& {
+			if (has_value())
+				return std::move(*this);
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) const&& {
+			return has_value() ? std::move(*this) : std::forward<F>(f)();
+		}
+#endif
+
+		/// \brief Maps the stored value with `f` if there is one, otherwise returns
+		/// `u`.
+		///
+		/// \details If there is a value stored, then `f` is called with `**this`
+		/// and the value is returned. Otherwise `u` is returned.
+		///
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) & {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u);
+		}
+
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) && {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u);
+		}
+
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) const& {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) const&& {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u);
+		}
+#endif
+
+		/// \brief Maps the stored value with `f` if there is one, otherwise calls
+		/// `u` and returns the result.
+		///
+		/// \details If there is a value stored, then `f` is
+		/// called with `**this` and the value is returned. Otherwise
+		/// `std::forward<U>(u)()` is returned.
+		///
+		/// \group map_or_else
+		/// \synopsis template <class F, class U>\nauto map_or_else(F &&f, U &&u) &;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) & {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u)();
+		}
+
+		/// \group map_or_else
+		/// \synopsis template <class F, class U>\nauto map_or_else(F &&f, U &&u)
+		/// &&;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) && {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u)();
+		}
+
+		/// \group map_or_else
+		/// \synopsis template <class F, class U>\nauto map_or_else(F &&f, U &&u)
+		/// const &;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) const& {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u)();
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group map_or_else
+		/// \synopsis template <class F, class U>\nauto map_or_else(F &&f, U &&u)
+		/// const &&;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) const&& {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u)();
+		}
+#endif
+
+		/// \returns `u` if `*this` has a value, otherwise an empty optional.
+		template <class U>
+		constexpr optional<typename std::decay<U>::type> conjunction(U&& u) const {
+			using result = optional<detail::decay_t<U>>;
+			return has_value() ? result { u } : result { nullopt };
+		}
+
+		/// \returns `rhs` if `*this` is empty, otherwise the current value.
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional& rhs) & {
+			return has_value() ? *this : rhs;
+		}
+
+		/// \group disjunction
+		constexpr optional disjunction(const optional& rhs) const& {
+			return has_value() ? *this : rhs;
+		}
+
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional& rhs) && {
+			return has_value() ? std::move(*this) : rhs;
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group disjunction
+		constexpr optional disjunction(const optional& rhs) const&& {
+			return has_value() ? std::move(*this) : rhs;
+		}
+#endif
+
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional&& rhs) & {
+			return has_value() ? *this : std::move(rhs);
+		}
+
+		/// \group disjunction
+		constexpr optional disjunction(optional&& rhs) const& {
+			return has_value() ? *this : std::move(rhs);
+		}
+
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional&& rhs) && {
+			return has_value() ? std::move(*this) : std::move(rhs);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group disjunction
+		constexpr optional disjunction(optional&& rhs) const&& {
+			return has_value() ? std::move(*this) : std::move(rhs);
+		}
+#endif
+
+		/// Takes the value out of the optional, leaving it empty
+		/// \group take
+		optional take() & {
+			optional ret = *this;
+			reset();
+			return ret;
+		}
+
+		/// \group take
+		optional take() const& {
+			optional ret = *this;
+			reset();
+			return ret;
+		}
+
+		/// \group take
+		optional take() && {
+			optional ret = std::move(*this);
+			reset();
+			return ret;
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group take
+		optional take() const&& {
+			optional ret = std::move(*this);
+			reset();
+			return ret;
+		}
+#endif
+
+		using value_type = T&;
+
+		/// Constructs an optional that does not contain a value.
+		/// \group ctor_empty
+		constexpr optional() noexcept : m_value(nullptr) {
+		}
+
+		/// \group ctor_empty
+		constexpr optional(nullopt_t) noexcept : m_value(nullptr) {
+		}
+
+		/// Copy constructor
+		///
+		/// If `rhs` contains a value, the stored value is direct-initialized with
+		/// it. Otherwise, the constructed optional is empty.
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional(const optional& rhs) noexcept = default;
+
+		/// Move constructor
+		///
+		/// If `rhs` contains a value, the stored value is direct-initialized with
+		/// it. Otherwise, the constructed optional is empty.
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional(optional&& rhs) = default;
+
+		/// Constructs the stored value with `u`.
+		/// \synopsis template <class U=T> constexpr optional(U &&u);
+		template <class U = T, detail::enable_if_t<!detail::is_optional<detail::decay_t<U>>::value>* = nullptr>
+		constexpr optional(U&& u) : m_value(std::addressof(u)) {
+			static_assert(std::is_lvalue_reference<U>::value, "U must be an lvalue");
+		}
+
+		/// \exclude
+		template <class U>
+		constexpr explicit optional(const optional<U>& rhs) : optional(*rhs) {
+		}
+
+		/// No-op
+		~optional() = default;
+
+		/// Assignment to empty.
+		///
+		/// Destroys the current value if there is one.
+		optional& operator=(nullopt_t) noexcept {
+			m_value = nullptr;
+			return *this;
+		}
+
+		/// Copy assignment.
+		///
+		/// Rebinds this optional to the referee of `rhs` if there is one. Otherwise
+		/// resets the stored value in `*this`.
+		optional& operator=(const optional& rhs) = default;
+
+		/// Rebinds this optional to `u`.
+		///
+		/// \requires `U` must be an lvalue reference.
+		/// \synopsis optional &operator=(U &&u);
+		template <class U = T, detail::enable_if_t<!detail::is_optional<detail::decay_t<U>>::value>* = nullptr>
+		optional& operator=(U&& u) {
+			static_assert(std::is_lvalue_reference<U>::value, "U must be an lvalue");
+			m_value = std::addressof(u);
+			return *this;
+		}
+
+		/// Converting copy assignment operator.
+		///
+		/// Rebinds this optional to the referee of `rhs` if there is one. Otherwise
+		/// resets the stored value in `*this`.
+		template <class U>
+		optional& operator=(const optional<U>& rhs) {
+			m_value = std::addressof(rhs.value());
+			return *this;
+		}
+
+		/// Constructs the value in-place, destroying the current one if there is
+		/// one.
+		///
+		/// \group emplace
+		template <class... Args>
+		T& emplace(Args&&... args) noexcept {
+			static_assert(std::is_constructible<T, Args&&...>::value, "T must be constructible with Args");
+
+			*this = nullopt;
+			this->construct(std::forward<Args>(args)...);
+		}
+
+		/// Swaps this optional with the other.
+		///
+		/// If neither optionals have a value, nothing happens.
+		/// If both have a value, the values are swapped.
+		/// If one has a value, it is moved to the other and the movee is left
+		/// valueless.
+		void swap(optional& rhs) noexcept {
+			std::swap(m_value, rhs.m_value);
+		}
+
+		/// \returns a pointer to the stored value
+		/// \requires a value is stored
+		/// \group pointer
+		/// \synopsis constexpr const T *operator->() const;
+		constexpr const T* operator->() const {
+			return m_value;
+		}
+
+		/// \group pointer
+		/// \synopsis constexpr T *operator->();
+		SOL_TL_OPTIONAL_11_CONSTEXPR T* operator->() {
+			return m_value;
+		}
+
+		/// \returns the stored value
+		/// \requires a value is stored
+		/// \group deref
+		/// \synopsis constexpr T &operator*();
+		SOL_TL_OPTIONAL_11_CONSTEXPR T& operator*() {
+			return *m_value;
+		}
+
+		/// \group deref
+		/// \synopsis constexpr const T &operator*() const;
+		constexpr const T& operator*() const {
+			return *m_value;
+		}
+
+		/// \returns whether or not the optional has a value
+		/// \group has_value
+		constexpr bool has_value() const noexcept {
+			return m_value != nullptr;
+		}
+
+		/// \group has_value
+		constexpr explicit operator bool() const noexcept {
+			return m_value != nullptr;
+		}
+
+		/// \returns the contained value if there is one, otherwise throws
+		/// [bad_optional_access]
+		/// \group value
+		/// synopsis constexpr T &value();
+		SOL_TL_OPTIONAL_11_CONSTEXPR T& value() {
+			if (has_value())
+				return *m_value;
+#if SOL_IS_OFF(SOL_EXCEPTIONS_I_)
+			std::abort();
+#else
+			throw bad_optional_access();
+#endif // No exceptions allowed
+		}
+		/// \group value
+		/// \synopsis constexpr const T &value() const;
+		SOL_TL_OPTIONAL_11_CONSTEXPR const T& value() const {
+			if (has_value())
+				return *m_value;
+#if SOL_IS_OFF(SOL_EXCEPTIONS_I_)
+			std::abort();
+#else
+			throw bad_optional_access();
+#endif // No exceptions allowed
+		}
+
+		/// \returns the stored value if there is one, otherwise returns `u`
+		/// \group value_or
+		template <class U>
+		constexpr T& value_or(U&& u) const {
+			static_assert(std::is_convertible<U&&, T&>::value, "T must be convertible from U");
+			return has_value() ? const_cast<T&>(**this) : static_cast<T&>(std::forward<U>(u));
+		}
+
+		/// Destroys the stored value if one exists, making the optional empty
+		void reset() noexcept {
+			m_value = nullptr;
+		}
+
+	private:
+		T* m_value;
+	};
+
+} // namespace sol
+
+namespace std {
+	// TODO SFINAE
+	template <class T>
+	struct hash<::sol::optional<T>> {
+		::std::size_t operator()(const ::sol::optional<T>& o) const {
+			if (!o.has_value())
+				return 0;
+
+			return ::std::hash<::sol::detail::remove_const_t<T>>()(*o);
+		}
+	};
+} // namespace std
+
+// end of sol/optional_implementation.hpp
+
+#endif // Boost vs. Better optional
+
+#include <optional>
+
+namespace sol {
+
+#if SOL_IS_ON(SOL_USE_BOOST_I_)
+	template <typename T>
+	using optional = boost::optional<T>;
+	using nullopt_t = boost::none_t;
+	const nullopt_t nullopt = boost::none;
+#endif // Boost vs. Better optional
+
+	namespace meta {
+		template <typename T>
+		using is_optional = any<is_specialization_of<T, optional>, is_specialization_of<T, std::optional>>;
+
+		template <typename T>
+		constexpr inline bool is_optional_v = is_optional<T>::value;
+	} // namespace meta
+
+	namespace detail {
+		template <typename T>
+		struct associated_nullopt {
+			inline static constexpr std::nullopt_t value = std::nullopt;
+		};
+
+#if SOL_IS_ON(SOL_USE_BOOST_I_)
+		template <typename T>
+		struct associated_nullopt<boost::optional<T>> {
+			inline static constexpr std::nullopt_t value = boost::nullopt;
+		};
+#endif // Boost nullopt
+
+		template <typename T>
+		inline constexpr auto associated_nullopt_v = associated_nullopt<T>::value;
+	} // namespace detail
+} // namespace sol
+
+// end of sol/optional.hpp
+
+// beginning of sol/raii.hpp
+
+#include <memory>
+
+namespace sol {
+	namespace detail {
+		struct default_construct {
+			template <typename T, typename... Args>
+			static void construct(T&& obj, Args&&... args) {
+				typedef meta::unqualified_t<T> Tu;
+				std::allocator<Tu> alloc{};
+				std::allocator_traits<std::allocator<Tu>>::construct(alloc, std::forward<T>(obj), std::forward<Args>(args)...);
+			}
+
+			template <typename T, typename... Args>
+			void operator()(T&& obj, Args&&... args) const {
+				construct(std::forward<T>(obj), std::forward<Args>(args)...);
+			}
+		};
+
+		struct default_destruct {
+			template <typename T>
+			static void destroy(T&& obj) {
+				std::allocator<meta::unqualified_t<T>> alloc{};
+				alloc.destroy(obj);
+			}
+
+			template <typename T>
+			void operator()(T&& obj) const {
+				destroy(std::forward<T>(obj));
+			}
+		};
+
+		struct deleter {
+			template <typename T>
+			void operator()(T* p) const {
+				delete p;
+			}
+		};
+
+		struct state_deleter {
+			void operator()(lua_State* L) const {
+				lua_close(L);
+			}
+		};
+
+		template <typename T, typename Dx, typename... Args>
+		inline std::unique_ptr<T, Dx> make_unique_deleter(Args&&... args) {
+			return std::unique_ptr<T, Dx>(new T(std::forward<Args>(args)...));
+		}
+
+		template <typename Tag, typename T>
+		struct tagged {
+		private:
+			T value_;
+		
+		public:
+			template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, tagged>> = meta::enabler>
+			tagged(Arg&& arg, Args&&... args)
+			: value_(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+			}
+
+			T& value() & {
+				return value_;
+			}
+
+			T const& value() const& {
+				return value_;
+			}
+
+			T&& value() && {
+				return std::move(value_);
+			}
+		};
+	} // namespace detail
+
+	template <typename... Args>
+	struct constructor_list {};
+
+	template <typename... Args>
+	using constructors = constructor_list<Args...>;
+
+	const auto default_constructor = constructors<types<>>{};
+
+	struct no_construction {};
+	const auto no_constructor = no_construction{};
+
+	struct call_construction {};
+	const auto call_constructor = call_construction{};
+
+	template <typename... Functions>
+	struct constructor_wrapper {
+		std::tuple<Functions...> functions;
+		template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, constructor_wrapper>> = meta::enabler>
+		constructor_wrapper(Arg&& arg, Args&&... args)
+		: functions(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+	};
+
+	template <typename... Functions>
+	inline auto initializers(Functions&&... functions) {
+		return constructor_wrapper<std::decay_t<Functions>...>(std::forward<Functions>(functions)...);
+	}
+
+	template <typename... Functions>
+	struct factory_wrapper {
+		std::tuple<Functions...> functions;
+		template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, factory_wrapper>> = meta::enabler>
+		factory_wrapper(Arg&& arg, Args&&... args)
+		: functions(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+	};
+
+	template <typename... Functions>
+	inline auto factories(Functions&&... functions) {
+		return factory_wrapper<std::decay_t<Functions>...>(std::forward<Functions>(functions)...);
+	}
+
+	template <typename Function>
+	struct destructor_wrapper {
+		Function fx;
+		destructor_wrapper(Function f)
+		: fx(std::move(f)) {
+		}
+	};
+
+	template <>
+	struct destructor_wrapper<void> {};
+
+	const destructor_wrapper<void> default_destructor{};
+
+	template <typename Fx>
+	inline auto destructor(Fx&& fx) {
+		return destructor_wrapper<std::decay_t<Fx>>(std::forward<Fx>(fx));
+	}
+
+} // namespace sol
+
+// end of sol/raii.hpp
+
+// beginning of sol/policies.hpp
+
+#include <array>
+
+namespace sol {
+	namespace detail {
+		struct policy_base_tag {};
+	} // namespace detail
+
+	template <int Target, int... In>
+	struct static_stack_dependencies : detail::policy_base_tag {};
+	typedef static_stack_dependencies<-1, 1> self_dependency;
+	template <int... In>
+	struct returns_self_with : detail::policy_base_tag {};
+	typedef returns_self_with<> returns_self;
+
+	struct stack_dependencies : detail::policy_base_tag {
+		int target;
+		std::array<int, 64> stack_indices;
+		std::size_t len;
+
+		template <typename... Args>
+		stack_dependencies(int stack_target, Args&&... args) : target(stack_target), stack_indices(), len(sizeof...(Args)) {
+			std::size_t i = 0;
+			(void)detail::swallow{ int(), (stack_indices[i++] = static_cast<int>(std::forward<Args>(args)), int())... };
+		}
+
+		int& operator[](std::size_t i) {
+			return stack_indices[i];
+		}
+
+		const int& operator[](std::size_t i) const {
+			return stack_indices[i];
+		}
+
+		std::size_t size() const {
+			return len;
+		}
+	};
+
+	template <typename F, typename... Policies>
+	struct policy_wrapper {
+		typedef std::index_sequence_for<Policies...> indices;
+
+		F value;
+		std::tuple<Policies...> policies;
+
+		template <typename Fx, typename... Args, meta::enable<meta::neg<std::is_same<meta::unqualified_t<Fx>, policy_wrapper>>> = meta::enabler>
+		policy_wrapper(Fx&& fx, Args&&... args) : value(std::forward<Fx>(fx)), policies(std::forward<Args>(args)...) {
+		}
+
+		policy_wrapper(const policy_wrapper&) = default;
+		policy_wrapper& operator=(const policy_wrapper&) = default;
+		policy_wrapper(policy_wrapper&&) = default;
+		policy_wrapper& operator=(policy_wrapper&&) = default;
+	};
+
+	template <typename F, typename... Args>
+	auto policies(F&& f, Args&&... args) {
+		return policy_wrapper<std::decay_t<F>, std::decay_t<Args>...>(std::forward<F>(f), std::forward<Args>(args)...);
+	}
+
+	namespace detail {
+		template <typename T>
+		using is_policy = meta::is_specialization_of<T, policy_wrapper>;
+
+		template <typename T>
+		inline constexpr bool is_policy_v = is_policy<T>::value;
+	} // namespace detail
+} // namespace sol
+
+// end of sol/policies.hpp
+
+// beginning of sol/ebco.hpp
+
+#include <type_traits>
+#include <utility>
+
+namespace sol { namespace detail {
+
+	template <typename T, std::size_t tag = 0, typename = void>
+	struct ebco {
+		T value_;
+
+		ebco() = default;
+		ebco(const ebco&) = default;
+		ebco(ebco&&) = default;
+		ebco& operator=(const ebco&) = default;
+		ebco& operator=(ebco&&) = default;
+		ebco(const T& v) : value_(v){};
+		ebco(T&& v) : value_(std::move(v)){};
+		ebco& operator=(const T& v) {
+			value_ = v;
+			return *this;
+		}
+		ebco& operator=(T&& v) {
+			value_ = std::move(v);
+			return *this;
+		};
+		template <typename Arg, typename... Args,
+		     typename = std::enable_if_t<!std::is_same_v<std::remove_reference_t<std::remove_cv_t<Arg>>,
+		                                      ebco> && !std::is_same_v<std::remove_reference_t<std::remove_cv_t<Arg>>, T>>>
+		ebco(Arg&& arg, Args&&... args) : T(std::forward<Arg>(arg), std::forward<Args>(args)...){}
+
+		T& value() & {
+			return value_;
+		}
+
+		T const& value() const & {
+			return value_;
+		}
+
+		T&& value() && {
+			return std::move(value_);
+		}
+	};
+
+	template <typename T, std::size_t tag>
+	struct ebco<T, tag, std::enable_if_t<!std::is_reference_v<T> && std::is_class_v<T> && !std::is_final_v<T>>> : T {
+		ebco() = default;
+		ebco(const ebco&) = default;
+		ebco(ebco&&) = default;
+		ebco(const T& v) : T(v){};
+		ebco(T&& v) : T(std::move(v)){};
+		template <typename Arg, typename... Args,
+			typename = std::enable_if_t<!std::is_same_v<std::remove_reference_t<std::remove_cv_t<Arg>>,
+			                                 ebco> && !std::is_same_v<std::remove_reference_t<std::remove_cv_t<Arg>>, T>>>
+		ebco(Arg&& arg, Args&&... args) : T(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+
+		ebco& operator=(const ebco&) = default;
+		ebco& operator=(ebco&&) = default;
+		ebco& operator=(const T& v) {
+			static_cast<T&>(*this) = v;
+			return *this;
+		}
+		ebco& operator=(T&& v) {
+			static_cast<T&>(*this) = std::move(v);
+			return *this;
+		};
+
+		T& value() & {
+			return static_cast<T&>(*this);
+		}
+
+		T const& value() const & {
+			return static_cast<T const&>(*this);
+		}
+
+		T&& value() && {
+			return std::move(static_cast<T&>(*this));
+		}
+	};
+
+	template <typename T, std::size_t tag>
+	struct ebco<T&, tag> {
+		T& ref;
+
+		ebco() = default;
+		ebco(const ebco&) = default;
+		ebco(ebco&&) = default;
+		ebco(T& v) : ref(v){};
+
+		ebco& operator=(const ebco&) = default;
+		ebco& operator=(ebco&&) = default;
+		ebco& operator=(T& v) {
+			ref = v;
+			return *this;
+		}
+
+		T& value() const {
+			return const_cast<ebco<T&, tag>&>(*this).ref;
+		}
+	};
+
+	template <typename T, std::size_t tag>
+	struct ebco<T&&, tag> {
+		T&& ref;
+
+		ebco() = default;
+		ebco(const ebco&) = default;
+		ebco(ebco&&) = default;
+		ebco(T&& v) : ref(v){};
+
+		ebco& operator=(const ebco&) = default;
+		ebco& operator=(ebco&&) = default;
+		ebco& operator=(T&& v) {
+			ref = std::move(v);
+			return *this;
+		}
+
+		T& value() & {
+			return ref;
+		}
+
+		const T& value() const & {
+			return ref;
+		}
+
+		T&& value() && {
+			return std::move(ref);
+		}
+	};
+
+}} // namespace sol::detail
+
+// end of sol/ebco.hpp
+
+#include <array>
+#include <initializer_list>
+#include <string>
+#include <string_view>
+#include <optional>
+#if SOL_IS_ON(SOL_STD_VARIANT_I_)
+#include <variant>
+#endif // variant shenanigans (thanks, Mac OSX)
+
+namespace sol {
+	namespace detail {
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_)
+		typedef int (*lua_CFunction_noexcept)(lua_State* L) noexcept;
+#else
+		typedef int (*lua_CFunction_noexcept)(lua_State* L);
+#endif // noexcept function type for lua_CFunction
+
+		template <typename T>
+		struct unique_usertype { };
+
+		template <typename T>
+		struct implicit_wrapper {
+			T& item;
+			implicit_wrapper(T* item) : item(*item) {
+			}
+			implicit_wrapper(T& item) : item(item) {
+			}
+			operator T&() {
+				return item;
+			}
+			operator T*() {
+				return std::addressof(item);
+			}
+		};
+
+		struct yield_tag_t { };
+		const yield_tag_t yield_tag = yield_tag_t {};
+	} // namespace detail
+
+	struct lua_nil_t { };
+	inline constexpr lua_nil_t lua_nil {};
+	inline bool operator==(lua_nil_t, lua_nil_t) {
+		return true;
+	}
+	inline bool operator!=(lua_nil_t, lua_nil_t) {
+		return false;
+	}
+#if SOL_IS_ON(SOL_NIL_I_)
+	using nil_t = lua_nil_t;
+	inline constexpr const nil_t& nil = lua_nil;
+#endif
+
+	namespace detail {
+		struct non_lua_nil_t { };
+	} // namespace detail
+
+	struct metatable_key_t { };
+	const metatable_key_t metatable_key = {};
+
+	struct env_key_t { };
+	const env_key_t env_key = {};
+
+	struct no_metatable_t { };
+	const no_metatable_t no_metatable = {};
+
+	template <typename T>
+	struct yielding_t {
+		T func;
+
+		yielding_t() = default;
+		yielding_t(const yielding_t&) = default;
+		yielding_t(yielding_t&&) = default;
+		yielding_t& operator=(const yielding_t&) = default;
+		yielding_t& operator=(yielding_t&&) = default;
+		template <typename Arg,
+		     meta::enable<meta::neg<std::is_same<meta::unqualified_t<Arg>, yielding_t>>,
+		          meta::neg<std::is_base_of<proxy_base_tag, meta::unqualified_t<Arg>>>> = meta::enabler>
+		yielding_t(Arg&& arg) : func(std::forward<Arg>(arg)) {
+		}
+		template <typename Arg0, typename Arg1, typename... Args>
+		yielding_t(Arg0&& arg0, Arg1&& arg1, Args&&... args) : func(std::forward<Arg0>(arg0), std::forward<Arg1>(arg1), std::forward<Args>(args)...) {
+		}
+	};
+
+	template <typename F>
+	inline yielding_t<std::decay_t<F>> yielding(F&& f) {
+		return yielding_t<std::decay_t<F>>(std::forward<F>(f));
+	}
+
+	typedef std::remove_pointer_t<lua_CFunction> lua_CFunction_ref;
+
+	template <typename T>
+	struct non_null { };
+
+	template <typename... Args>
+	struct function_sig { };
+
+	struct upvalue_index {
+		int index;
+		upvalue_index(int idx) : index(lua_upvalueindex(idx)) {
+		}
+
+		operator int() const {
+			return index;
+		}
+	};
+
+	struct raw_index {
+		int index;
+		raw_index(int i) : index(i) {
+		}
+
+		operator int() const {
+			return index;
+		}
+	};
+
+	struct absolute_index {
+		int index;
+		absolute_index(lua_State* L, int idx) : index(lua_absindex(L, idx)) {
+		}
+
+		operator int() const {
+			return index;
+		}
+	};
+
+	struct ref_index {
+		int index;
+		ref_index(int idx) : index(idx) {
+		}
+
+		operator int() const {
+			return index;
+		}
+	};
+
+	struct stack_count {
+		int count;
+
+		stack_count(int cnt) : count(cnt) {
+		}
+	};
+
+	struct lightuserdata_value {
+		void* value;
+		lightuserdata_value(void* data) : value(data) {
+		}
+		operator void*() const {
+			return value;
+		}
+	};
+
+	struct userdata_value {
+		void* value;
+		userdata_value(void* data) : value(data) {
+		}
+		operator void*() const {
+			return value;
+		}
+	};
+
+	template <typename L>
+	struct light {
+		L* value;
+
+		light(L& x) : value(std::addressof(x)) {
+		}
+		light(L* x) : value(x) {
+		}
+		light(void* x) : value(static_cast<L*>(x)) {
+		}
+		operator L*() const {
+			return value;
+		}
+		operator L&() const {
+			return *value;
+		}
+	};
+
+	template <typename T>
+	auto make_light(T& l) {
+		typedef meta::unwrapped_t<std::remove_pointer_t<std::remove_pointer_t<T>>> L;
+		return light<L>(l);
+	}
+
+	template <typename U>
+	struct user {
+		U value;
+
+		user(U&& x) : value(std::forward<U>(x)) {
+		}
+		operator std::add_pointer_t<std::remove_reference_t<U>>() {
+			return std::addressof(value);
+		}
+		operator std::add_lvalue_reference_t<U>() {
+			return value;
+		}
+		operator std::add_const_t<std::add_lvalue_reference_t<U>> &() const {
+			return value;
+		}
+	};
+
+	template <typename T>
+	auto make_user(T&& u) {
+		typedef meta::unwrapped_t<meta::unqualified_t<T>> U;
+		return user<U>(std::forward<T>(u));
+	}
+
+	template <typename T>
+	struct metatable_registry_key {
+		T key;
+
+		metatable_registry_key(T key) : key(std::forward<T>(key)) {
+		}
+	};
+
+	template <typename T>
+	auto meta_registry_key(T&& key) {
+		typedef meta::unqualified_t<T> K;
+		return metatable_registry_key<K>(std::forward<T>(key));
+	}
+
+	template <typename... Upvalues>
+	struct closure {
+		lua_CFunction c_function;
+		std::tuple<Upvalues...> upvalues;
+		closure(lua_CFunction f, Upvalues... targetupvalues) : c_function(f), upvalues(std::forward<Upvalues>(targetupvalues)...) {
+		}
+	};
+
+	template <>
+	struct closure<> {
+		lua_CFunction c_function;
+		int upvalues;
+		closure(lua_CFunction f, int upvalue_count = 0) : c_function(f), upvalues(upvalue_count) {
+		}
+	};
+
+	typedef closure<> c_closure;
+
+	template <typename... Args>
+	closure<Args...> make_closure(lua_CFunction f, Args&&... args) {
+		return closure<Args...>(f, std::forward<Args>(args)...);
+	}
+
+	template <typename Sig, typename... Ps>
+	struct function_arguments {
+		std::tuple<Ps...> arguments;
+		template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, function_arguments>> = meta::enabler>
+		function_arguments(Arg&& arg, Args&&... args) : arguments(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+	};
+
+	template <typename Sig = function_sig<>, typename... Args>
+	auto as_function(Args&&... args) {
+		return function_arguments<Sig, std::decay_t<Args>...>(std::forward<Args>(args)...);
+	}
+
+	template <typename Sig = function_sig<>, typename... Args>
+	auto as_function_reference(Args&&... args) {
+		return function_arguments<Sig, Args...>(std::forward<Args>(args)...);
+	}
+
+	template <typename T>
+	struct as_table_t {
+	private:
+		T value_;
+
+	public:
+		as_table_t() = default;
+		as_table_t(const as_table_t&) = default;
+		as_table_t(as_table_t&&) = default;
+		as_table_t& operator=(const as_table_t&) = default;
+		as_table_t& operator=(as_table_t&&) = default;
+		template <typename Arg,
+		     meta::enable<meta::neg<std::is_same<meta::unqualified_t<Arg>, as_table_t>>,
+		          meta::neg<std::is_base_of<proxy_base_tag, meta::unqualified_t<Arg>>>> = meta::enabler>
+		as_table_t(Arg&& arg) : value_(std::forward<Arg>(arg)) {
+		}
+		template <typename Arg0, typename Arg1, typename... Args>
+		as_table_t(Arg0&& arg0, Arg1&& arg1, Args&&... args) : value_(std::forward<Arg0>(arg0), std::forward<Arg1>(arg1), std::forward<Args>(args)...) {
+		}
+
+		T& value() & {
+			return value_;
+		}
+
+		T&& value() && {
+			return std::move(value_);
+		}
+
+		const T& value() const& {
+			return value_;
+		}
+
+		operator std::add_lvalue_reference_t<T>() {
+			return value_;
+		}
+	};
+
+	template <typename T>
+	struct nested {
+	private:
+		T value_;
+
+	public:
+		using nested_type = T;
+
+		nested() = default;
+		nested(const nested&) = default;
+		nested(nested&&) = default;
+		nested& operator=(const nested&) = default;
+		nested& operator=(nested&&) = default;
+		template <typename Arg,
+		     meta::enable<meta::neg<std::is_same<meta::unqualified_t<Arg>, nested>>,
+		          meta::neg<std::is_base_of<proxy_base_tag, meta::unqualified_t<Arg>>>> = meta::enabler>
+		nested(Arg&& arg) : value_(std::forward<Arg>(arg)) {
+		}
+		template <typename Arg0, typename Arg1, typename... Args>
+		nested(Arg0&& arg0, Arg1&& arg1, Args&&... args) : value_(std::forward<Arg0>(arg0), std::forward<Arg1>(arg1), std::forward<Args>(args)...) {
+		}
+
+		T& value() & {
+			return value_;
+		}
+
+		T&& value() && {
+			return std::move(value_);
+		}
+
+		const T& value() const& {
+			return value_;
+		}
+
+		operator std::add_lvalue_reference_t<T>() {
+			return value_;
+		}
+	};
+
+	struct nested_tag_t { };
+	constexpr inline nested_tag_t nested_tag {};
+
+	template <typename T>
+	as_table_t<T> as_table_ref(T&& container) {
+		return as_table_t<T>(std::forward<T>(container));
+	}
+
+	template <typename T>
+	as_table_t<meta::unqualified_t<T>> as_table(T&& container) {
+		return as_table_t<meta::unqualified_t<T>>(std::forward<T>(container));
+	}
+
+	template <typename T>
+	nested<T> as_nested_ref(T&& container) {
+		return nested<T>(std::forward<T>(container));
+	}
+
+	template <typename T>
+	nested<meta::unqualified_t<T>> as_nested(T&& container) {
+		return nested<meta::unqualified_t<T>>(std::forward<T>(container));
+	}
+
+	template <typename T>
+	struct as_container_t {
+	private:
+		T value_;
+
+	public:
+		using type = T;
+
+		as_container_t() = default;
+		as_container_t(const as_container_t&) = default;
+		as_container_t(as_container_t&&) = default;
+		as_container_t& operator=(const as_container_t&) = default;
+		as_container_t& operator=(as_container_t&&) = default;
+		template <typename Arg,
+		     meta::enable<meta::neg<std::is_same<meta::unqualified_t<Arg>, as_container_t>>,
+		          meta::neg<std::is_base_of<proxy_base_tag, meta::unqualified_t<Arg>>>> = meta::enabler>
+		as_container_t(Arg&& arg) : value_(std::forward<Arg>(arg)) {
+		}
+		template <typename Arg0, typename Arg1, typename... Args>
+		as_container_t(Arg0&& arg0, Arg1&& arg1, Args&&... args) : value_(std::forward<Arg0>(arg0), std::forward<Arg1>(arg1), std::forward<Args>(args)...) {
+		}
+
+		T& value() & {
+			return value_;
+		}
+
+		T&& value() && {
+			return std::move(value_);
+		}
+
+		const T& value() const& {
+			return value_;
+		}
+	};
+
+	template <typename T>
+	struct as_container_t<T&> {
+	private:
+		std::reference_wrapper<T> value_;
+
+	public:
+		as_container_t(T& value) : value_(value) {
+		}
+
+		T& value() {
+			return value_;
+		}
+
+		operator T&() {
+			return value();
+		}
+	};
+
+	template <typename T>
+	auto as_container(T&& value) {
+		return as_container_t<T>(std::forward<T>(value));
+	}
+
+	template <typename T>
+	struct push_invoke_t {
+	private:
+		T value_;
+
+	public:
+		push_invoke_t() = default;
+		push_invoke_t(const push_invoke_t&) = default;
+		push_invoke_t(push_invoke_t&&) = default;
+		push_invoke_t& operator=(const push_invoke_t&) = default;
+		push_invoke_t& operator=(push_invoke_t&&) = default;
+		template <typename Arg,
+		     meta::enable<meta::neg<std::is_same<meta::unqualified_t<Arg>, push_invoke_t>>,
+		          meta::neg<std::is_base_of<proxy_base_tag, meta::unqualified_t<Arg>>>> = meta::enabler>
+		push_invoke_t(Arg&& arg) : value_(std::forward<Arg>(arg)) {
+		}
+		template <typename Arg0, typename Arg1, typename... Args>
+		push_invoke_t(Arg0&& arg0, Arg1&& arg1, Args&&... args) : value_(std::forward<Arg0>(arg0), std::forward<Arg1>(arg1), std::forward<Args>(args)...) {
+		}
+
+		T& value() & {
+			return value_;
+		}
+
+		T&& value() && {
+			return std::move(value_);
+		}
+
+		const T& value() const& {
+			return value_;
+		}
+	};
+
+	template <typename T>
+	struct push_invoke_t<T&> {
+		std::reference_wrapper<T> value_;
+
+		push_invoke_t(T& value) : value_(value) {
+		}
+
+		T& value() {
+			return value_;
+		}
+	};
+
+	template <typename Fx>
+	auto push_invoke(Fx&& fx) {
+		return push_invoke_t<Fx>(std::forward<Fx>(fx));
+	}
+
+	struct override_value_t { };
+	constexpr inline override_value_t override_value = override_value_t();
+	struct update_if_empty_t { };
+	constexpr inline update_if_empty_t update_if_empty = update_if_empty_t();
+	struct create_if_nil_t { };
+	constexpr inline create_if_nil_t create_if_nil = create_if_nil_t();
+
+	namespace detail {
+		enum insert_mode { none = 0x0, update_if_empty = 0x01, override_value = 0x02, create_if_nil = 0x04 };
+
+		template <typename T, typename...>
+		using is_insert_mode = std::integral_constant<bool,
+		     std::is_same_v<T, override_value_t> || std::is_same_v<T, update_if_empty_t> || std::is_same_v<T, create_if_nil_t>>;
+
+		template <typename T, typename...>
+		using is_not_insert_mode = meta::neg<is_insert_mode<T>>;
+	} // namespace detail
+
+	struct this_state {
+		lua_State* L;
+
+		this_state(lua_State* Ls) : L(Ls) {
+		}
+
+		operator lua_State*() const noexcept {
+			return lua_state();
+		}
+
+		lua_State* operator->() const noexcept {
+			return lua_state();
+		}
+
+		lua_State* lua_state() const noexcept {
+			return L;
+		}
+	};
+
+	struct this_main_state {
+		lua_State* L;
+
+		this_main_state(lua_State* Ls) : L(Ls) {
+		}
+
+		operator lua_State*() const noexcept {
+			return lua_state();
+		}
+
+		lua_State* operator->() const noexcept {
+			return lua_state();
+		}
+
+		lua_State* lua_state() const noexcept {
+			return L;
+		}
+	};
+
+	struct new_table {
+		int sequence_hint = 0;
+		int map_hint = 0;
+
+		new_table() = default;
+		new_table(const new_table&) = default;
+		new_table(new_table&&) = default;
+		new_table& operator=(const new_table&) = default;
+		new_table& operator=(new_table&&) = default;
+
+		new_table(int sequence_hint, int map_hint = 0) : sequence_hint(sequence_hint), map_hint(map_hint) {
+		}
+	};
+
+	const new_table create = {};
+
+	enum class lib : char {
+		// print, assert, and other base functions
+		base,
+		// require and other package functions
+		package,
+		// coroutine functions and utilities
+		coroutine,
+		// string library
+		string,
+		// functionality from the OS
+		os,
+		// all things math
+		math,
+		// the table manipulator and observer functions
+		table,
+		// the debug library
+		debug,
+		// the bit library: different based on which you're using
+		bit32,
+		// input/output library
+		io,
+		// LuaJIT only
+		ffi,
+		// LuaJIT only
+		jit,
+		// library for handling utf8: new to Lua
+		utf8,
+		// do not use
+		count
+	};
+
+	enum class call_syntax { dot = 0, colon = 1 };
+
+	enum class load_mode {
+		any = 0,
+		text = 1,
+		binary = 2,
+	};
+
+	enum class call_status : int {
+		ok = LUA_OK,
+		yielded = LUA_YIELD,
+		runtime = LUA_ERRRUN,
+		memory = LUA_ERRMEM,
+		handler = LUA_ERRERR,
+		gc = LUA_ERRGCMM,
+		syntax = LUA_ERRSYNTAX,
+		file = LUA_ERRFILE,
+	};
+
+	enum class thread_status : int {
+		ok = LUA_OK,
+		yielded = LUA_YIELD,
+		runtime = LUA_ERRRUN,
+		memory = LUA_ERRMEM,
+		gc = LUA_ERRGCMM,
+		handler = LUA_ERRERR,
+		dead = -1,
+	};
+
+	enum class load_status : int {
+		ok = LUA_OK,
+		syntax = LUA_ERRSYNTAX,
+		memory = LUA_ERRMEM,
+		gc = LUA_ERRGCMM,
+		file = LUA_ERRFILE,
+	};
+
+	enum class gc_mode : int {
+		incremental = 0,
+		generational = 1,
+		default_value = incremental,
+	};
+
+	enum class type : int {
+		none = LUA_TNONE,
+		lua_nil = LUA_TNIL,
+#if SOL_IS_ON(SOL_NIL_I_)
+		nil = lua_nil,
+#endif // Objective C/C++ Keyword that's found in OSX SDK and OBJC -- check for all forms to protect
+		string = LUA_TSTRING,
+		number = LUA_TNUMBER,
+		thread = LUA_TTHREAD,
+		boolean = LUA_TBOOLEAN,
+		function = LUA_TFUNCTION,
+		userdata = LUA_TUSERDATA,
+		lightuserdata = LUA_TLIGHTUSERDATA,
+		table = LUA_TTABLE,
+		poly = -0xFFFF
+	};
+
+	inline const std::string& to_string(call_status c) {
+		static const std::array<std::string, 10> names { { "ok",
+			"yielded",
+			"runtime",
+			"memory",
+			"handler",
+			"gc",
+			"syntax",
+			"file",
+			"CRITICAL_EXCEPTION_FAILURE",
+			"CRITICAL_INDETERMINATE_STATE_FAILURE" } };
+		switch (c) {
+		case call_status::ok:
+			return names[0];
+		case call_status::yielded:
+			return names[1];
+		case call_status::runtime:
+			return names[2];
+		case call_status::memory:
+			return names[3];
+		case call_status::handler:
+			return names[4];
+		case call_status::gc:
+			return names[5];
+		case call_status::syntax:
+			return names[6];
+		case call_status::file:
+			return names[7];
+		}
+		if (static_cast<std::ptrdiff_t>(c) == -1) {
+			// One of the many cases where a critical exception error has occurred
+			return names[8];
+		}
+		return names[9];
+	}
+
+	inline bool is_indeterminate_call_failure(call_status c) {
+		switch (c) {
+		case call_status::ok:
+		case call_status::yielded:
+		case call_status::runtime:
+		case call_status::memory:
+		case call_status::handler:
+		case call_status::gc:
+		case call_status::syntax:
+		case call_status::file:
+			return false;
+		}
+		return true;
+	}
+
+	inline const std::string& to_string(load_status c) {
+		static const std::array<std::string, 7> names {
+			{ "ok", "memory", "gc", "syntax", "file", "CRITICAL_EXCEPTION_FAILURE", "CRITICAL_INDETERMINATE_STATE_FAILURE" }
+		};
+		switch (c) {
+		case load_status::ok:
+			return names[0];
+		case load_status::memory:
+			return names[1];
+		case load_status::gc:
+			return names[2];
+		case load_status::syntax:
+			return names[3];
+		case load_status::file:
+			return names[4];
+		}
+		if (static_cast<int>(c) == -1) {
+			// One of the many cases where a critical exception error has occurred
+			return names[5];
+		}
+		return names[6];
+	}
+
+	inline const std::string& to_string(load_mode c) {
+		static const std::array<std::string, 3> names { {
+			"bt",
+			"t",
+			"b",
+		} };
+		return names[static_cast<std::size_t>(c)];
+	}
+
+	enum class meta_function {
+		construct,
+		index,
+		new_index,
+		mode,
+		call,
+		call_function = call,
+		metatable,
+		to_string,
+		length,
+		unary_minus,
+		addition,
+		subtraction,
+		multiplication,
+		division,
+		modulus,
+		power_of,
+		involution = power_of,
+		concatenation,
+		equal_to,
+		less_than,
+		less_than_or_equal_to,
+		garbage_collect,
+		floor_division,
+		bitwise_left_shift,
+		bitwise_right_shift,
+		bitwise_not,
+		bitwise_and,
+		bitwise_or,
+		bitwise_xor,
+		pairs,
+		ipairs,
+		next,
+		type,
+		type_info,
+		call_construct,
+		storage,
+		gc_names,
+		static_index,
+		static_new_index,
+	};
+
+	typedef meta_function meta_method;
+
+	inline const std::array<std::string, 37>& meta_function_names() {
+		static const std::array<std::string, 37> names = { { "new",
+			"__index",
+			"__newindex",
+			"__mode",
+			"__call",
+			"__metatable",
+			"__tostring",
+			"__len",
+			"__unm",
+			"__add",
+			"__sub",
+			"__mul",
+			"__div",
+			"__mod",
+			"__pow",
+			"__concat",
+			"__eq",
+			"__lt",
+			"__le",
+			"__gc",
+
+			"__idiv",
+			"__shl",
+			"__shr",
+			"__bnot",
+			"__band",
+			"__bor",
+			"__bxor",
+
+			"__pairs",
+			"__ipairs",
+			"next",
+
+			"__type",
+			"__typeinfo",
+			"__sol.call_new",
+			"__sol.storage",
+			"__sol.gc_names",
+			"__sol.static_index",
+			"__sol.static_new_index" } };
+		return names;
+	}
+
+	inline const std::string& to_string(meta_function mf) {
+		return meta_function_names()[static_cast<int>(mf)];
+	}
+
+	inline type type_of(lua_State* L, int index) {
+		return static_cast<type>(lua_type(L, index));
+	}
+
+	inline std::string type_name(lua_State* L, type t) {
+		return lua_typename(L, static_cast<int>(t));
+	}
+
+	template <typename T>
+	struct is_lua_reference
+	: std::integral_constant<bool, std::is_base_of_v<reference, T> || std::is_base_of_v<main_reference, T> || std::is_base_of_v<stack_reference, T>> { };
+
+	template <typename T>
+	inline constexpr bool is_lua_reference_v = is_lua_reference<T>::value;
+
+	template <typename T>
+	struct is_lua_reference_or_proxy : std::integral_constant<bool, is_lua_reference_v<T> || meta::is_specialization_of_v<T, table_proxy>> { };
+
+	template <typename T>
+	inline constexpr bool is_lua_reference_or_proxy_v = is_lua_reference_or_proxy<T>::value;
+
+	template <typename T>
+	struct is_transparent_argument : std::false_type { };
+
+	template <typename T>
+	constexpr inline bool is_transparent_argument_v = is_transparent_argument<T>::value;
+
+	template <>
+	struct is_transparent_argument<this_state> : std::true_type { };
+	template <>
+	struct is_transparent_argument<this_main_state> : std::true_type { };
+	template <>
+	struct is_transparent_argument<this_environment> : std::true_type { };
+	template <>
+	struct is_transparent_argument<variadic_args> : std::true_type { };
+	template <typename T>
+	struct is_variadic_arguments : std::is_same<T, variadic_args> { };
+
+	template <typename T>
+	struct is_container
+	: std::integral_constant<bool,
+	       !std::is_same_v<state_view,
+	            T> && !std::is_same_v<state, T> && !meta::is_initializer_list_v<T> && !meta::is_string_like_v<T> && !meta::is_string_literal_array_v<T> && !is_transparent_argument_v<T> && !is_lua_reference_v<T> && (meta::has_begin_end_v<T> || std::is_array_v<T>)> {
+	};
+
+	template <typename T>
+	constexpr inline bool is_container_v = is_container<T>::value;
+
+	template <typename T>
+	struct is_to_stringable : meta::any<meta::supports_to_string_member<meta::unqualified_t<T>>, meta::supports_adl_to_string<meta::unqualified_t<T>>,
+	                               meta::supports_op_left_shift<std::ostream, meta::unqualified_t<T>>> { };
+
+	namespace detail {
+		template <typename T, typename = void>
+		struct lua_type_of : std::integral_constant<type, type::userdata> { };
+
+		template <typename C, typename T, typename A>
+		struct lua_type_of<std::basic_string<C, T, A>> : std::integral_constant<type, type::string> { };
+
+		template <typename C, typename T>
+		struct lua_type_of<basic_string_view<C, T>> : std::integral_constant<type, type::string> { };
+
+		template <std::size_t N>
+		struct lua_type_of<char[N]> : std::integral_constant<type, type::string> { };
+
+		template <std::size_t N>
+		struct lua_type_of<wchar_t[N]> : std::integral_constant<type, type::string> { };
+
+		template <std::size_t N>
+		struct lua_type_of<char16_t[N]> : std::integral_constant<type, type::string> { };
+
+		template <std::size_t N>
+		struct lua_type_of<char32_t[N]> : std::integral_constant<type, type::string> { };
+
+		template <>
+		struct lua_type_of<char> : std::integral_constant<type, type::string> { };
+
+		template <>
+		struct lua_type_of<wchar_t> : std::integral_constant<type, type::string> { };
+
+		template <>
+		struct lua_type_of<char16_t> : std::integral_constant<type, type::string> { };
+
+		template <>
+		struct lua_type_of<char32_t> : std::integral_constant<type, type::string> { };
+
+		template <>
+		struct lua_type_of<const char*> : std::integral_constant<type, type::string> { };
+
+		template <>
+		struct lua_type_of<const char16_t*> : std::integral_constant<type, type::string> { };
+
+		template <>
+		struct lua_type_of<const char32_t*> : std::integral_constant<type, type::string> { };
+
+		template <>
+		struct lua_type_of<bool> : std::integral_constant<type, type::boolean> { };
+
+		template <>
+		struct lua_type_of<lua_nil_t> : std::integral_constant<type, type::lua_nil> { };
+
+		template <>
+		struct lua_type_of<nullopt_t> : std::integral_constant<type, type::lua_nil> { };
+
+		template <>
+		struct lua_type_of<lua_value> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<detail::non_lua_nil_t> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<std::nullptr_t> : std::integral_constant<type, type::lua_nil> { };
+
+		template <>
+		struct lua_type_of<error> : std::integral_constant<type, type::string> { };
+
+		template <bool b, typename Base>
+		struct lua_type_of<basic_table_core<b, Base>> : std::integral_constant<type, type::table> { };
+
+		template <typename Base>
+		struct lua_type_of<basic_lua_table<Base>> : std::integral_constant<type, type::table> { };
+
+		template <typename Base>
+		struct lua_type_of<basic_metatable<Base>> : std::integral_constant<type, type::table> { };
+
+		template <typename T, typename Base>
+		struct lua_type_of<basic_usertype<T, Base>> : std::integral_constant<type, type::table> { };
+
+		template <>
+		struct lua_type_of<metatable_key_t> : std::integral_constant<type, type::table> { };
+
+		template <typename B>
+		struct lua_type_of<basic_environment<B>> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<env_key_t> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<new_table> : std::integral_constant<type, type::table> { };
+
+		template <typename T>
+		struct lua_type_of<as_table_t<T>> : std::integral_constant<type, type::table> { };
+
+		template <typename T>
+		struct lua_type_of<std::initializer_list<T>> : std::integral_constant<type, type::table> { };
+
+		template <bool b>
+		struct lua_type_of<basic_reference<b>> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<stack_reference> : std::integral_constant<type, type::poly> { };
+
+		template <typename Base>
+		struct lua_type_of<basic_object<Base>> : std::integral_constant<type, type::poly> { };
+
+		template <typename... Args>
+		struct lua_type_of<std::tuple<Args...>> : std::integral_constant<type, type::poly> { };
+
+		template <typename A, typename B>
+		struct lua_type_of<std::pair<A, B>> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<void*> : std::integral_constant<type, type::lightuserdata> { };
+
+		template <>
+		struct lua_type_of<const void*> : std::integral_constant<type, type::lightuserdata> { };
+
+		template <>
+		struct lua_type_of<lightuserdata_value> : std::integral_constant<type, type::lightuserdata> { };
+
+		template <>
+		struct lua_type_of<userdata_value> : std::integral_constant<type, type::userdata> { };
+
+		template <typename T>
+		struct lua_type_of<light<T>> : std::integral_constant<type, type::lightuserdata> { };
+
+		template <typename T>
+		struct lua_type_of<user<T>> : std::integral_constant<type, type::userdata> { };
+
+		template <typename Base>
+		struct lua_type_of<basic_lightuserdata<Base>> : std::integral_constant<type, type::lightuserdata> { };
+
+		template <typename Base>
+		struct lua_type_of<basic_userdata<Base>> : std::integral_constant<type, type::userdata> { };
+
+		template <>
+		struct lua_type_of<lua_CFunction> : std::integral_constant<type, type::function> { };
+
+		template <>
+		struct lua_type_of<std::remove_pointer_t<lua_CFunction>> : std::integral_constant<type, type::function> { };
+
+		template <typename Base, bool aligned>
+		struct lua_type_of<basic_function<Base, aligned>> : std::integral_constant<type, type::function> { };
+
+		template <typename Base, bool aligned, typename Handler>
+		struct lua_type_of<basic_protected_function<Base, aligned, Handler>> : std::integral_constant<type, type::function> { };
+
+		template <typename Base>
+		struct lua_type_of<basic_coroutine<Base>> : std::integral_constant<type, type::function> { };
+
+		template <typename Base>
+		struct lua_type_of<basic_thread<Base>> : std::integral_constant<type, type::thread> { };
+
+		template <typename Signature>
+		struct lua_type_of<std::function<Signature>> : std::integral_constant<type, type::function> { };
+
+		template <typename T>
+		struct lua_type_of<optional<T>> : std::integral_constant<type, type::poly> { };
+
+		template <typename T>
+		struct lua_type_of<std::optional<T>> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<variadic_args> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<variadic_results> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<stack_count> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<this_state> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<this_main_state> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<this_environment> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<type> : std::integral_constant<type, type::poly> { };
+
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE_I_)
+		template <typename T>
+		struct lua_type_of<T*> : std::integral_constant<type, std::is_function_v<T> ? type::function : type::userdata> { };
+#else
+		template <typename T>
+		struct lua_type_of<T*> : std::integral_constant<type, type::userdata> { };
+#endif
+
+		template <typename T>
+		struct lua_type_of<T, std::enable_if_t<std::is_arithmetic_v<T> || std::is_same_v<T, lua_Number> || std::is_same_v<T, lua_Integer>>>
+		: std::integral_constant<type, type::number> { };
+
+		template <typename T>
+		struct lua_type_of<T, std::enable_if_t<std::is_function_v<T>>> : std::integral_constant<type, type::function> { };
+
+		template <typename T>
+		struct lua_type_of<T, std::enable_if_t<std::is_enum_v<T>>> : std::integral_constant<type, type::number> { };
+
+		template <>
+		struct lua_type_of<meta_function> : std::integral_constant<type, type::string> { };
+
+#if SOL_IS_ON(SOL_STD_VARIANT_I_)
+		template <typename... Tn>
+		struct lua_type_of<std::variant<Tn...>> : std::integral_constant<type, type::poly> { };
+#endif // std::variant deployment sucks on Clang
+
+		template <typename T>
+		struct lua_type_of<nested<T>> : meta::conditional_t<::sol::is_container_v<T>, std::integral_constant<type, type::table>, lua_type_of<T>> { };
+
+		template <typename C, C v, template <typename...> class V, typename... Args>
+		struct accumulate : std::integral_constant<C, v> { };
+
+		template <typename C, C v, template <typename...> class V, typename T, typename... Args>
+		struct accumulate<C, v, V, T, Args...> : accumulate<C, v + V<T>::value, V, Args...> { };
+
+		template <typename C, C v, template <typename...> class V, typename List>
+		struct accumulate_list;
+
+		template <typename C, C v, template <typename...> class V, typename... Args>
+		struct accumulate_list<C, v, V, types<Args...>> : accumulate<C, v, V, Args...> { };
+	} // namespace detail
+
+	template <typename T>
+	struct lua_type_of : detail::lua_type_of<T> {
+		typedef int SOL_INTERNAL_UNSPECIALIZED_MARKER_;
+	};
+
+	template <typename T>
+	inline constexpr type lua_type_of_v = lua_type_of<T>::value;
+
+	template <typename T>
+	struct lua_size : std::integral_constant<int, 1> {
+		typedef int SOL_INTERNAL_UNSPECIALIZED_MARKER_;
+	};
+
+	template <typename A, typename B>
+	struct lua_size<std::pair<A, B>> : std::integral_constant<int, lua_size<A>::value + lua_size<B>::value> { };
+
+	template <typename... Args>
+	struct lua_size<std::tuple<Args...>> : std::integral_constant<int, detail::accumulate<int, 0, lua_size, Args...>::value> { };
+
+	template <typename T>
+	inline constexpr int lua_size_v = lua_size<T>::value;
+
+	namespace detail {
+		template <typename...>
+		struct void_ {
+			typedef void type;
+		};
+		template <typename T, typename = void>
+		struct has_internal_marker_impl : std::false_type { };
+		template <typename T>
+		struct has_internal_marker_impl<T, typename void_<typename T::SOL_INTERNAL_UNSPECIALIZED_MARKER_>::type> : std::true_type { };
+
+		template <typename T>
+		using has_internal_marker = has_internal_marker_impl<T>;
+
+		template <typename T>
+		constexpr inline bool has_internal_marker_v = has_internal_marker<T>::value;
+	} // namespace detail
+
+	template <typename T>
+	struct is_lua_primitive
+	: std::integral_constant<bool,
+	       type::userdata
+	                 != lua_type_of_v<
+	                      T> || ((type::userdata == lua_type_of_v<T>)&&detail::has_internal_marker_v<lua_type_of<T>> && !detail::has_internal_marker_v<lua_size<T>>)
+	            || is_lua_reference_or_proxy_v<T> || meta::is_specialization_of_v<T, std::tuple> || meta::is_specialization_of_v<T, std::pair>> { };
+
+	template <typename T>
+	constexpr inline bool is_lua_primitive_v = is_lua_primitive<T>::value;
+
+	template <typename T>
+	struct is_main_threaded : std::is_base_of<main_reference, T> { };
+
+	template <typename T>
+	struct is_stack_based : std::is_base_of<stack_reference, T> { };
+	template <>
+	struct is_stack_based<variadic_args> : std::true_type { };
+	template <>
+	struct is_stack_based<unsafe_function_result> : std::true_type { };
+	template <>
+	struct is_stack_based<protected_function_result> : std::true_type { };
+	template <>
+	struct is_stack_based<stack_proxy> : std::true_type { };
+	template <>
+	struct is_stack_based<stack_proxy_base> : std::true_type { };
+	template <>
+	struct is_stack_based<stack_count> : std::true_type { };
+
+	template <typename T>
+	constexpr inline bool is_stack_based_v = is_stack_based<T>::value;
+
+	template <typename T>
+	struct is_lua_primitive<T*> : std::true_type { };
+	template <>
+	struct is_lua_primitive<unsafe_function_result> : std::true_type { };
+	template <>
+	struct is_lua_primitive<protected_function_result> : std::true_type { };
+	template <typename T>
+	struct is_lua_primitive<std::reference_wrapper<T>> : std::true_type { };
+	template <typename T>
+	struct is_lua_primitive<user<T>> : std::true_type { };
+	template <typename T>
+	struct is_lua_primitive<light<T>> : is_lua_primitive<T*> { };
+	template <typename T>
+	struct is_lua_primitive<optional<T>> : std::true_type { };
+	template <typename T>
+	struct is_lua_primitive<std::optional<T>> : std::true_type { };
+	template <typename T>
+	struct is_lua_primitive<as_table_t<T>> : std::true_type { };
+	template <typename T>
+	struct is_lua_primitive<nested<T>> : std::true_type { };
+	template <>
+	struct is_lua_primitive<userdata_value> : std::true_type { };
+	template <>
+	struct is_lua_primitive<lightuserdata_value> : std::true_type { };
+	template <>
+	struct is_lua_primitive<stack_proxy> : std::true_type { };
+	template <>
+	struct is_lua_primitive<stack_proxy_base> : std::true_type { };
+	template <typename T>
+	struct is_lua_primitive<non_null<T>> : is_lua_primitive<T*> { };
+
+	template <typename T>
+	struct is_lua_index : std::is_integral<T> { };
+	template <>
+	struct is_lua_index<raw_index> : std::true_type { };
+	template <>
+	struct is_lua_index<absolute_index> : std::true_type { };
+	template <>
+	struct is_lua_index<ref_index> : std::true_type { };
+	template <>
+	struct is_lua_index<upvalue_index> : std::true_type { };
+
+	template <typename Signature>
+	struct lua_bind_traits : meta::bind_traits<Signature> {
+	private:
+		typedef meta::bind_traits<Signature> base_t;
+
+	public:
+		typedef std::integral_constant<bool, meta::count_for<is_variadic_arguments, typename base_t::args_list>::value != 0> runtime_variadics_t;
+		static const std::size_t true_arity = base_t::arity;
+		static const std::size_t arity = detail::accumulate_list<std::size_t, 0, lua_size, typename base_t::args_list>::value
+		     - meta::count_for<is_transparent_argument, typename base_t::args_list>::value;
+		static const std::size_t true_free_arity = base_t::free_arity;
+		static const std::size_t free_arity = detail::accumulate_list<std::size_t, 0, lua_size, typename base_t::free_args_list>::value
+		     - meta::count_for<is_transparent_argument, typename base_t::args_list>::value;
+	};
+
+	template <typename T>
+	struct is_table : std::false_type { };
+	template <bool x, typename T>
+	struct is_table<basic_table_core<x, T>> : std::true_type { };
+	template <typename T>
+	struct is_table<basic_lua_table<T>> : std::true_type { };
+
+	template <typename T>
+	inline constexpr bool is_table_v = is_table<T>::value;
+
+	template <typename T>
+	struct is_stack_table : std::false_type { };
+	template <bool x, typename T>
+	struct is_stack_table<basic_table_core<x, T>> : std::integral_constant<bool, std::is_base_of_v<stack_reference, T>> { };
+	template <typename T>
+	struct is_stack_table<basic_lua_table<T>> : std::integral_constant<bool, std::is_base_of_v<stack_reference, T>> { };
+
+	template <typename T>
+	inline constexpr bool is_stack_table_v = is_stack_table<T>::value;
+
+	template <typename T>
+	struct is_function : std::false_type { };
+	template <typename T, bool aligned>
+	struct is_function<basic_function<T, aligned>> : std::true_type { };
+	template <typename T, bool aligned, typename Handler>
+	struct is_function<basic_protected_function<T, aligned, Handler>> : std::true_type { };
+
+	template <typename T>
+	using is_lightuserdata = meta::is_specialization_of<T, basic_lightuserdata>;
+
+	template <typename T>
+	inline constexpr bool is_lightuserdata_v = is_lightuserdata<T>::value;
+
+	template <typename T>
+	using is_userdata = meta::is_specialization_of<T, basic_userdata>;
+
+	template <typename T>
+	inline constexpr bool is_userdata_v = is_userdata<T>::value;
+
+	template <typename T>
+	using is_environment = std::integral_constant<bool, is_userdata_v<T> || is_table_v<T> || meta::is_specialization_of_v<T, basic_environment>>;
+
+	template <typename T>
+	inline constexpr bool is_environment_v = is_environment<T>::value;
+
+	template <typename T>
+	using is_table_like = std::integral_constant<bool, is_table_v<T> || is_environment_v<T> || is_userdata_v<T>>;
+
+	template <typename T>
+	inline constexpr bool is_table_like_v = is_table_like<T>::value;
+
+	template <typename T>
+	struct is_automagical
+	: std::integral_constant<bool,
+	       (SOL_IS_ON(SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_))
+	            || (std::is_array_v<
+	                     meta::unqualified_t<T>> || (!std::is_same_v<meta::unqualified_t<T>, state> && !std::is_same_v<meta::unqualified_t<T>, state_view>))> {
+	};
+
+	template <typename T>
+	inline type type_of() {
+		return lua_type_of<meta::unqualified_t<T>>::value;
+	}
+
+	namespace detail {
+		template <typename T>
+		struct is_non_factory_constructor : std::false_type { };
+
+		template <typename... Args>
+		struct is_non_factory_constructor<constructors<Args...>> : std::true_type { };
+
+		template <typename... Args>
+		struct is_non_factory_constructor<constructor_wrapper<Args...>> : std::true_type { };
+
+		template <>
+		struct is_non_factory_constructor<no_construction> : std::true_type { };
+
+		template <typename T>
+		inline constexpr bool is_non_factory_constructor_v = is_non_factory_constructor<T>::value;
+
+		template <typename T>
+		struct is_constructor : is_non_factory_constructor<T> { };
+
+		template <typename... Args>
+		struct is_constructor<factory_wrapper<Args...>> : std::true_type { };
+
+		template <typename T>
+		struct is_constructor<protect_t<T>> : is_constructor<meta::unqualified_t<T>> { };
+
+		template <typename F, typename... Policies>
+		struct is_constructor<policy_wrapper<F, Policies...>> : is_constructor<meta::unqualified_t<F>> { };
+
+		template <typename T>
+		inline constexpr bool is_constructor_v = is_constructor<T>::value;
+
+		template <typename... Args>
+		using any_is_constructor = meta::any<is_constructor<meta::unqualified_t<Args>>...>;
+
+		template <typename... Args>
+		inline constexpr bool any_is_constructor_v = any_is_constructor<Args...>::value;
+
+		template <typename T>
+		struct is_destructor : std::false_type { };
+
+		template <typename Fx>
+		struct is_destructor<destructor_wrapper<Fx>> : std::true_type { };
+
+		template <typename... Args>
+		using any_is_destructor = meta::any<is_destructor<meta::unqualified_t<Args>>...>;
+
+		template <typename... Args>
+		inline constexpr bool any_is_destructor_v = any_is_destructor<Args...>::value;
+	} // namespace detail
+
+	template <typename T>
+	using is_lua_c_function = meta::any<std::is_same<lua_CFunction, T>, std::is_same<detail::lua_CFunction_noexcept, T>, std::is_same<lua_CFunction_ref, T>>;
+
+	template <typename T>
+	inline constexpr bool is_lua_c_function_v = is_lua_c_function<T>::value;
+
+	struct automagic_enrollments {
+		bool default_constructor = true;
+		bool destructor = true;
+		bool pairs_operator = true;
+		bool to_string_operator = true;
+		bool call_operator = true;
+		bool less_than_operator = true;
+		bool less_than_or_equal_to_operator = true;
+		bool length_operator = true;
+		bool equal_to_operator = true;
+	};
+
+} // namespace sol
+
+// end of sol/types.hpp
+
+#include <exception>
+#include <cstring>
+
+#if SOL_IS_ON(SOL_PRINT_ERRORS_I_)
+#include <iostream>
+#endif
+
+namespace sol {
+	// must push a single object to be the error object
+	// NOTE: the VAST MAJORITY of all Lua libraries -- C or otherwise -- expect a string for the type of error
+	// break this convention at your own risk
+	using exception_handler_function = int (*)(lua_State*, optional<const std::exception&>, string_view);
+
+	namespace detail {
+		inline const char (&default_exception_handler_name())[11] {
+			static const char name[11] = "sol.\xE2\x98\xA2\xE2\x98\xA2";
+			return name;
+		}
+
+		// must push at least 1 object on the stack
+		inline int default_exception_handler(lua_State* L, optional<const std::exception&>, string_view what) {
+#if SOL_IS_ON(SOL_PRINT_ERRORS_I_)
+			std::cerr << "[sol3] An exception occurred: ";
+			std::cerr.write(what.data(), what.size());
+			std::cerr << std::endl;
+#endif
+			lua_pushlstring(L, what.data(), what.size());
+			return 1;
+		}
+
+		inline int call_exception_handler(lua_State* L, optional<const std::exception&> maybe_ex, string_view what) {
+			lua_getglobal(L, default_exception_handler_name());
+			type t = static_cast<type>(lua_type(L, -1));
+			if (t != type::lightuserdata) {
+				lua_pop(L, 1);
+				return default_exception_handler(L, std::move(maybe_ex), std::move(what));
+			}
+			void* vfunc = lua_touserdata(L, -1);
+			lua_pop(L, 1);
+			if (vfunc == nullptr) {
+				return default_exception_handler(L, std::move(maybe_ex), std::move(what));
+			}
+			exception_handler_function exfunc = reinterpret_cast<exception_handler_function>(vfunc);
+			return exfunc(L, std::move(maybe_ex), std::move(what));
+		}
+
+#if SOL_IS_OFF(SOL_EXCEPTIONS_I_)
+		template <lua_CFunction f>
+		int static_trampoline(lua_State* L) noexcept {
+			return f(L);
+		}
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_)
+		template <lua_CFunction_noexcept f>
+		int static_trampoline_noexcept(lua_State* L) noexcept {
+			return f(L);
+		}
+#else
+		template <lua_CFunction f>
+		int static_trampoline_noexcept(lua_State* L) noexcept {
+			return f(L);
+		}
+#endif
+
+		template <typename Fx, typename... Args>
+		int trampoline(lua_State* L, Fx&& f, Args&&... args) noexcept {
+			return f(L, std::forward<Args>(args)...);
+		}
+
+		inline int c_trampoline(lua_State* L, lua_CFunction f) noexcept {
+			return trampoline(L, f);
+		}
+#else
+
+		inline int lua_cfunction_trampoline(lua_State* L, lua_CFunction f) {
+#if SOL_IS_ON(SOL_PROPAGATE_EXCEPTIONS_I_)
+			return f(L);
+
+#else
+			try {
+				return f(L);
+			}
+			catch (const char* cs) {
+				call_exception_handler(L, optional<const std::exception&>(nullopt), string_view(cs));
+			}
+			catch (const std::string& s) {
+				call_exception_handler(L, optional<const std::exception&>(nullopt), string_view(s.c_str(), s.size()));
+			}
+			catch (const std::exception& e) {
+				call_exception_handler(L, optional<const std::exception&>(e), e.what());
+			}
+#if SOL_IS_OFF(SOL_USE_LUAJIT_I_)
+			// LuaJIT cannot have the catchall when the safe propagation is on
+			// but LuaJIT will swallow all C++ errors
+			// if we don't at least catch std::exception ones
+			catch (...) {
+				call_exception_handler(L, optional<const std::exception&>(nullopt), "caught (...) exception");
+			}
+#endif // LuaJIT cannot have the catchall, but we must catch std::exceps for it
+			return lua_error(L);
+#endif // Safe exceptions
+		}
+
+		template <lua_CFunction f>
+		int static_trampoline(lua_State* L) {
+			return lua_cfunction_trampoline(L, f);
+		}
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_)
+		template <lua_CFunction_noexcept f>
+		int static_trampoline_noexcept(lua_State* L) noexcept {
+			return f(L);
+		}
+#else
+		template <lua_CFunction f>
+		int static_trampoline_noexcept(lua_State* L) noexcept {
+			return f(L);
+		}
+#endif
+
+		template <typename Fx, typename... Args>
+		int trampoline(lua_State* L, Fx&& f, Args&&... args) {
+			if constexpr (meta::bind_traits<meta::unqualified_t<Fx>>::is_noexcept) {
+				return f(L, std::forward<Args>(args)...);
+			}
+			else {
+#if SOL_IS_ON(SOL_PROPAGATE_EXCEPTIONS_I_)
+				return f(L, std::forward<Args>(args)...);
+#else
+				try {
+					return f(L, std::forward<Args>(args)...);
+				}
+				catch (const char* cs) {
+					call_exception_handler(L, optional<const std::exception&>(nullopt), string_view(cs));
+				}
+				catch (const std::string& s) {
+					call_exception_handler(L, optional<const std::exception&>(nullopt), string_view(s.c_str(), s.size()));
+				}
+				catch (const std::exception& e) {
+					call_exception_handler(L, optional<const std::exception&>(e), e.what());
+				}
+#if SOL_IS_OFF(SOL_USE_LUAJIT_I_)
+				// LuaJIT cannot have the catchall when the safe propagation is on
+				// but LuaJIT will swallow all C++ errors
+				// if we don't at least catch std::exception ones
+				catch (...) {
+					call_exception_handler(L, optional<const std::exception&>(nullopt), "caught (...) exception");
+				}
+#endif
+				return lua_error(L);
+#endif
+			}
+		}
+
+		inline int c_trampoline(lua_State* L, lua_CFunction f) {
+			return trampoline(L, f);
+		}
+#endif // Exceptions vs. No Exceptions
+
+		template <typename F, F fx>
+		inline int typed_static_trampoline(lua_State* L) {
+			if constexpr (meta::bind_traits<F>::is_noexcept) {
+				return static_trampoline_noexcept<fx>(L);
+			}
+			else {
+				return static_trampoline<fx>(L);
+			}
+		}
+	} // namespace detail
+
+	inline void set_default_exception_handler(lua_State* L, exception_handler_function exf = &detail::default_exception_handler) {
+		static_assert(sizeof(void*) >= sizeof(exception_handler_function),
+		     "void* storage is too small to transport the exception handler: please file a bug on the sol2 issue tracker to get this looked at!");
+		void* storage;
+		std::memcpy(&storage, &exf, sizeof(exception_handler_function));
+		lua_pushlightuserdata(L, storage);
+		lua_setglobal(L, detail::default_exception_handler_name());
+	}
+} // namespace sol
+
+// end of sol/trampoline.hpp
+
+// beginning of sol/stack_core.hpp
+
+// beginning of sol/inheritance.hpp
+
+// beginning of sol/usertype_traits.hpp
+
+// beginning of sol/demangle.hpp
+
+#include <string>
+#include <array>
+#include <cctype>
+#if SOL_IS_ON(SOL_MINGW_CCTYPE_IS_POISONED_I_)
+extern "C" {
+#include <ctype.h>
+}
+#endif // MinGW is on some stuff
+#include <locale>
+
+namespace sol { namespace detail {
+	inline std::array<string_view, 9> removals { { "{anonymous}",
+		"(anonymous namespace)",
+		"public:",
+		"private:",
+		"protected:",
+		"struct ",
+		"class ",
+		"`anonymous-namespace'",
+		"`anonymous namespace'" } };
+
+#if SOL_IS_ON(SOL_COMPILER_GCC_I_) || SOL_IS_ON(SOL_COMPILER_CLANG_I_)
+	inline std::string ctti_get_type_name_from_sig(std::string name) {
+		// cardinal sins from MINGW
+		using namespace std;
+		std::size_t start = name.find_first_of('[');
+		start = name.find_first_of('=', start);
+		std::size_t end = name.find_last_of(']');
+		if (end == std::string::npos)
+			end = name.size();
+		if (start == std::string::npos)
+			start = 0;
+		if (start < name.size() - 1)
+			start += 1;
+		name = name.substr(start, end - start);
+		start = name.rfind("seperator_mark");
+		if (start != std::string::npos) {
+			name.erase(start - 2, name.length());
+		}
+		while (!name.empty() && isblank(name.front()))
+			name.erase(name.begin());
+		while (!name.empty() && isblank(name.back()))
+			name.pop_back();
+
+		for (std::size_t r = 0; r < removals.size(); ++r) {
+			auto found = name.find(removals[r]);
+			while (found != std::string::npos) {
+				name.erase(found, removals[r].size());
+				found = name.find(removals[r]);
+			}
+		}
+
+		return name;
+	}
+
+	template <typename T, class seperator_mark = int>
+	inline std::string ctti_get_type_name() {
+		return ctti_get_type_name_from_sig(__PRETTY_FUNCTION__);
+	}
+#elif SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+	inline std::string ctti_get_type_name_from_sig(std::string name) {
+		std::size_t start = name.find("get_type_name");
+		if (start == std::string::npos)
+			start = 0;
+		else
+			start += 13;
+		if (start < name.size() - 1)
+			start += 1;
+		std::size_t end = name.find_last_of('>');
+		if (end == std::string::npos)
+			end = name.size();
+		name = name.substr(start, end - start);
+		if (name.find("struct", 0) == 0)
+			name.replace(0, 6, "", 0);
+		if (name.find("class", 0) == 0)
+			name.replace(0, 5, "", 0);
+		while (!name.empty() && isblank(name.front()))
+			name.erase(name.begin());
+		while (!name.empty() && isblank(name.back()))
+			name.pop_back();
+
+		for (std::size_t r = 0; r < removals.size(); ++r) {
+			auto found = name.find(removals[r]);
+			while (found != std::string::npos) {
+				name.erase(found, removals[r].size());
+				found = name.find(removals[r]);
+			}
+		}
+
+		return name;
+	}
+
+	template <typename T>
+	std::string ctti_get_type_name() {
+		return ctti_get_type_name_from_sig(__FUNCSIG__);
+	}
+#else
+#error Compiler not supported for demangling
+#endif // compilers
+
+	template <typename T>
+	std::string demangle_once() {
+		std::string realname = ctti_get_type_name<T>();
+		return realname;
+	}
+
+	inline std::string short_demangle_from_type_name(std::string realname) {
+		// This isn't the most complete but it'll do for now...?
+		static const std::array<std::string, 10> ops = {
+			{ "operator<", "operator<<", "operator<<=", "operator<=", "operator>", "operator>>", "operator>>=", "operator>=", "operator->", "operator->*" }
+		};
+		int level = 0;
+		std::ptrdiff_t idx = 0;
+		for (idx = static_cast<std::ptrdiff_t>(realname.empty() ? 0 : realname.size() - 1); idx > 0; --idx) {
+			if (level == 0 && realname[idx] == ':') {
+				break;
+			}
+			bool isleft = realname[idx] == '<';
+			bool isright = realname[idx] == '>';
+			if (!isleft && !isright)
+				continue;
+			bool earlybreak = false;
+			for (const auto& op : ops) {
+				std::size_t nisop = realname.rfind(op, idx);
+				if (nisop == std::string::npos)
+					continue;
+				std::size_t nisopidx = idx - op.size() + 1;
+				if (nisop == nisopidx) {
+					idx = static_cast<std::ptrdiff_t>(nisopidx);
+					earlybreak = true;
+				}
+				break;
+			}
+			if (earlybreak) {
+				continue;
+			}
+			level += isleft ? -1 : 1;
+		}
+		if (idx > 0) {
+			realname.erase(0, realname.length() < static_cast<std::size_t>(idx) ? realname.length() : idx + 1);
+		}
+		return realname;
+	}
+
+	template <typename T>
+	std::string short_demangle_once() {
+		std::string realname = ctti_get_type_name<T>();
+		return short_demangle_from_type_name(realname);
+	}
+
+	template <typename T>
+	const std::string& demangle() {
+		static const std::string d = demangle_once<T>();
+		return d;
+	}
+
+	template <typename T>
+	const std::string& short_demangle() {
+		static const std::string d = short_demangle_once<T>();
+		return d;
+	}
+}} // namespace sol::detail
+
+// end of sol/demangle.hpp
+
+namespace sol {
+
+	template <typename T>
+	struct usertype_traits {
+		static const std::string& name() {
+			static const std::string& n = detail::short_demangle<T>();
+			return n;
+		}
+		static const std::string& qualified_name() {
+			static const std::string& q_n = detail::demangle<T>();
+			return q_n;
+		}
+		static const std::string& metatable() {
+			static const std::string m = std::string("sol.").append(detail::demangle<T>());
+			return m;
+		}
+		static const std::string& user_metatable() {
+			static const std::string u_m = std::string("sol.").append(detail::demangle<T>()).append(".user");
+			return u_m;
+		}
+		static const std::string& user_gc_metatable() {
+			static const std::string u_g_m = std::string("sol.").append(detail::demangle<T>()).append(".user\xE2\x99\xBB");
+			return u_g_m;
+		}
+		static const std::string& gc_table() {
+			static const std::string g_t = std::string("sol.").append(detail::demangle<T>()).append(".\xE2\x99\xBB");
+			return g_t;
+		}
+	};
+
+} // namespace sol
+
+// end of sol/usertype_traits.hpp
+
+// beginning of sol/unique_usertype_traits.hpp
+
+#include <memory>
+
+namespace sol {
+
+	template <typename T>
+	struct unique_usertype_traits {
+		typedef T type;
+		typedef T actual_type;
+		template <typename X>
+		using rebind_base = void;
+
+		static const bool value = false;
+
+		template <typename U>
+		static bool is_null(U&&) {
+			return false;
+		}
+
+		template <typename U>
+		static auto get(U&& value) {
+			return std::addressof(detail::deref(value));
+		}
+	};
+
+	template <typename T>
+	struct unique_usertype_traits<std::shared_ptr<T>> {
+		typedef T type;
+		typedef std::shared_ptr<T> actual_type;
+		// rebind is non-void
+		// if and only if unique usertype
+		// is cast-capable
+		template <typename X>
+		using rebind_base = std::shared_ptr<X>;
+
+		static const bool value = true;
+
+		static bool is_null(const actual_type& p) {
+			return p == nullptr;
+		}
+
+		static type* get(const actual_type& p) {
+			return p.get();
+		}
+	};
+
+	template <typename T, typename D>
+	struct unique_usertype_traits<std::unique_ptr<T, D>> {
+		using type = T;
+		using actual_type = std::unique_ptr<T, D>;
+
+		static const bool value = true;
+
+		static bool is_null(const actual_type& p) {
+			return p == nullptr;
+		}
+
+		static type* get(const actual_type& p) {
+			return p.get();
+		}
+	};
+
+	template <typename T>
+	struct is_unique_usertype : std::integral_constant<bool, unique_usertype_traits<T>::value> {};
+
+	template <typename T>
+	inline constexpr bool is_unique_usertype_v = is_unique_usertype<T>::value;
+
+	namespace detail {
+		template <typename T, typename Rebind = void>
+		using is_base_rebindable_test = typename T::template rebind_base<Rebind>;
+	}
+
+	template <typename T>
+	using is_base_rebindable = meta::is_detected<detail::is_base_rebindable_test, T>;
+
+	template <typename T>
+	inline constexpr bool is_base_rebindable_v = is_base_rebindable<T>::value;
+
+	namespace detail {
+		template <typename T, typename = void>
+		struct is_base_rebindable_non_void_sfinae : std::false_type {};
+
+		template <typename T>
+		struct is_base_rebindable_non_void_sfinae<T, std::enable_if_t<is_base_rebindable_v<T>>>
+		: std::integral_constant<bool, !std::is_void_v<typename T::template rebind_base<void>>> {};
+	} // namespace detail
+
+	template <typename T>
+	using is_base_rebindable_non_void = meta::is_detected<detail::is_base_rebindable_test, T>;
+
+	template <typename T>
+	inline constexpr bool is_base_rebindable_non_void_v = is_base_rebindable_non_void<T>::value;
+
+} // namespace sol
+
+// end of sol/unique_usertype_traits.hpp
+
+namespace sol {
+	template <typename... Args>
+	struct base_list {};
+	template <typename... Args>
+	using bases = base_list<Args...>;
+
+	typedef bases<> base_classes_tag;
+	const auto base_classes = base_classes_tag();
+
+	template <typename... Args>
+	struct is_to_stringable<base_list<Args...>> : std::false_type {};
+
+	namespace detail {
+
+		inline decltype(auto) base_class_check_key() {
+			static const auto& key = "class_check";
+			return key;
+		}
+
+		inline decltype(auto) base_class_cast_key() {
+			static const auto& key = "class_cast";
+			return key;
+		}
+
+		inline decltype(auto) base_class_index_propogation_key() {
+			static const auto& key = u8"\xF0\x9F\x8C\xB2.index";
+			return key;
+		}
+
+		inline decltype(auto) base_class_new_index_propogation_key() {
+			static const auto& key = u8"\xF0\x9F\x8C\xB2.new_index";
+			return key;
+		}
+
+		template <typename T>
+		struct inheritance {
+			typedef typename base<T>::type bases_t;
+
+			static bool type_check_bases(types<>, const string_view&) {
+				return false;
+			}
+
+			template <typename Base, typename... Args>
+			static bool type_check_bases(types<Base, Args...>, const string_view& ti) {
+				return ti == usertype_traits<Base>::qualified_name() || type_check_bases(types<Args...>(), ti);
+			}
+
+			static bool type_check(const string_view& ti) {
+				return ti == usertype_traits<T>::qualified_name() || type_check_bases(bases_t(), ti);
+			}
+
+			template <typename ...Bases>
+			static bool type_check_with(const string_view& ti) {
+				return ti == usertype_traits<T>::qualified_name() || type_check_bases(types<Bases...>(), ti);
+			}
+
+			static void* type_cast_bases(types<>, T*, const string_view&) {
+				return nullptr;
+			}
+
+			template <typename Base, typename... Args>
+			static void* type_cast_bases(types<Base, Args...>, T* data, const string_view& ti) {
+				// Make sure to convert to T first, and then dynamic cast to the proper type
+				return ti != usertype_traits<Base>::qualified_name() ? type_cast_bases(types<Args...>(), data, ti) : static_cast<void*>(static_cast<Base*>(data));
+			}
+
+			static void* type_cast(void* voiddata, const string_view& ti) {
+				T* data = static_cast<T*>(voiddata);
+				return static_cast<void*>(ti != usertype_traits<T>::qualified_name() ? type_cast_bases(bases_t(), data, ti) : data);
+			}
+
+			template <typename... Bases>
+			static void* type_cast_with(void* voiddata, const string_view& ti) {
+				T* data = static_cast<T*>(voiddata);
+				return static_cast<void*>(ti != usertype_traits<T>::qualified_name() ? type_cast_bases(types<Bases...>(), data, ti) : data);
+			}
+
+			template <typename U>
+			static bool type_unique_cast_bases(types<>, void*, void*, const string_view&) {
+				return 0;
+			}
+
+			template <typename U, typename Base, typename... Args>
+			static int type_unique_cast_bases(types<Base, Args...>, void* source_data, void* target_data, const string_view& ti) {
+				using uu_traits = unique_usertype_traits<U>;
+				using base_ptr = typename uu_traits::template rebind_base<Base>;
+				string_view base_ti = usertype_traits<Base>::qualified_name();
+				if (base_ti == ti) {
+					if (target_data != nullptr) {
+						U* source = static_cast<U*>(source_data);
+						base_ptr* target = static_cast<base_ptr*>(target_data);
+						// perform proper derived -> base conversion
+						*target = *source;
+					}
+					return 2;
+				}
+				return type_unique_cast_bases<U>(types<Args...>(), source_data, target_data, ti);
+			}
+
+			template <typename U>
+			static int type_unique_cast(void* source_data, void* target_data, const string_view& ti, const string_view& rebind_ti) {
+				typedef unique_usertype_traits<U> uu_traits;
+				if constexpr (is_base_rebindable_v<uu_traits>) {
+					typedef typename uu_traits::template rebind_base<void> rebind_t;
+					typedef meta::conditional_t<std::is_void<rebind_t>::value, types<>, bases_t> cond_bases_t;
+					string_view this_rebind_ti = usertype_traits<rebind_t>::qualified_name();
+					if (rebind_ti != this_rebind_ti) {
+						// this is not even of the same unique type
+						return 0;
+					}
+					string_view this_ti = usertype_traits<T>::qualified_name();
+					if (ti == this_ti) {
+						// direct match, return 1
+						return 1;
+					}
+					return type_unique_cast_bases<U>(cond_bases_t(), source_data, target_data, ti);
+				}
+				else {
+					(void)rebind_ti;
+					string_view this_ti = usertype_traits<T>::qualified_name();
+					if (ti == this_ti) {
+						// direct match, return 1
+						return 1;
+					}
+					return type_unique_cast_bases<U>(types<>(), source_data, target_data, ti);
+				}
+			}
+
+			template <typename U, typename... Bases>
+			static int type_unique_cast_with(void* source_data, void* target_data, const string_view& ti, const string_view& rebind_ti) {
+				using uc_bases_t = types<Bases...>;
+				typedef unique_usertype_traits<U> uu_traits;
+				if constexpr (is_base_rebindable_v<uu_traits>) {
+					using rebind_t = typename uu_traits::template rebind_base<void>;
+					using cond_bases_t = meta::conditional_t<std::is_void<rebind_t>::value, types<>, uc_bases_t>;
+					string_view this_rebind_ti = usertype_traits<rebind_t>::qualified_name();
+					if (rebind_ti != this_rebind_ti) {
+						// this is not even of the same unique type
+						return 0;
+					}
+					string_view this_ti = usertype_traits<T>::qualified_name();
+					if (ti == this_ti) {
+						// direct match, return 1
+						return 1;
+					}
+					return type_unique_cast_bases<U>(cond_bases_t(), source_data, target_data, ti);
+				}
+				else {
+					(void)rebind_ti;
+					string_view this_ti = usertype_traits<T>::qualified_name();
+					if (ti == this_ti) {
+						// direct match, return 1
+						return 1;
+					}
+					return type_unique_cast_bases<U>(types<>(), source_data, target_data, ti);
+				}
+			}
+		};
+
+		using inheritance_check_function = decltype(&inheritance<void>::type_check);
+		using inheritance_cast_function = decltype(&inheritance<void>::type_cast);
+		using inheritance_unique_cast_function = decltype(&inheritance<void>::type_unique_cast<void>);
+	} // namespace detail
+} // namespace sol
+
+// end of sol/inheritance.hpp
+
+// beginning of sol/error_handler.hpp
+
+#include <cstdio>
+
+namespace sol {
+
+	namespace detail {
+		constexpr const char* not_a_number = "not a numeric type";
+		constexpr const char* not_a_number_or_number_string = "not a numeric type or numeric string";
+		constexpr const char* not_a_number_integral = "not a numeric type that fits exactly an integer (number maybe has significant decimals)";
+		constexpr const char* not_a_number_or_number_string_integral
+		     = "not a numeric type or a numeric string that fits exactly an integer (e.g. number maybe has significant decimals)";
+
+		constexpr const char* not_enough_stack_space = "not enough space left on Lua stack";
+		constexpr const char* not_enough_stack_space_floating = "not enough space left on Lua stack for a floating point number";
+		constexpr const char* not_enough_stack_space_integral = "not enough space left on Lua stack for an integral number";
+		constexpr const char* not_enough_stack_space_string = "not enough space left on Lua stack for a string";
+		constexpr const char* not_enough_stack_space_meta_function_name = "not enough space left on Lua stack for the name of a meta_function";
+		constexpr const char* not_enough_stack_space_userdata = "not enough space left on Lua stack to create a sol3 userdata";
+		constexpr const char* not_enough_stack_space_generic = "not enough space left on Lua stack to push valuees";
+		constexpr const char* not_enough_stack_space_environment = "not enough space left on Lua stack to retrieve environment";
+		constexpr const char* protected_function_error = "caught (...) unknown error during protected_function call";
+
+		inline void accumulate_and_mark(const std::string& n, std::string& aux_message, int& marker) {
+			if (marker > 0) {
+				aux_message += ", ";
+			}
+			aux_message += n;
+			++marker;
+		}
+	} // namespace detail
+
+	inline std::string associated_type_name(lua_State* L, int index, type t) {
+		switch (t) {
+		case type::poly:
+			return "anything";
+		case type::userdata: {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 2, "not enough space to push get the type name");
+#endif // make sure stack doesn't overflow
+			if (lua_getmetatable(L, index) == 0) {
+				break;
+			}
+			lua_pushlstring(L, "__name", 6);
+			lua_rawget(L, -2);
+			size_t sz;
+			const char* name = lua_tolstring(L, -1, &sz);
+			std::string tn(name, static_cast<std::string::size_type>(sz));
+			lua_pop(L, 2);
+			return tn;
+		}
+		default:
+			break;
+		}
+		return lua_typename(L, static_cast<int>(t));
+	}
+
+	inline int push_type_panic_string(lua_State* L, int index, type expected, type actual, string_view message, string_view aux_message) noexcept {
+		const char* err = message.size() == 0
+		     ? (aux_message.size() == 0 ? "stack index %d, expected %s, received %s" : "stack index %d, expected %s, received %s: %s")
+		     : "stack index %d, expected %s, received %s: %s %s";
+		const char* type_name = expected == type::poly ? "anything" : lua_typename(L, static_cast<int>(expected));
+		{
+			std::string actual_name = associated_type_name(L, index, actual);
+			lua_pushfstring(L, err, index, type_name, actual_name.c_str(), message.data(), aux_message.data());
+		}
+		return 1;
+	}
+
+	inline int type_panic_string(lua_State* L, int index, type expected, type actual, string_view message = "") noexcept(false) {
+		push_type_panic_string(L, index, expected, actual, message, "");
+		return lua_error(L);
+	}
+
+	inline int type_panic_c_str(lua_State* L, int index, type expected, type actual, const char* message = nullptr) noexcept(false) {
+		push_type_panic_string(L, index, expected, actual, message == nullptr ? "" : message, "");
+		return lua_error(L);
+	}
+
+	struct type_panic_t {
+		int operator()(lua_State* L, int index, type expected, type actual) const noexcept(false) {
+			return type_panic_c_str(L, index, expected, actual, nullptr);
+		}
+		int operator()(lua_State* L, int index, type expected, type actual, string_view message) const noexcept(false) {
+			return type_panic_c_str(L, index, expected, actual, message.data());
+		}
+	};
+
+	const type_panic_t type_panic = {};
+
+	struct constructor_handler {
+		int operator()(lua_State* L, int index, type expected, type actual, string_view message) const noexcept(false) {
+			push_type_panic_string(L, index, expected, actual, message, "(type check failed in constructor)");
+			return lua_error(L);
+		}
+	};
+
+	template <typename F = void>
+	struct argument_handler {
+		int operator()(lua_State* L, int index, type expected, type actual, string_view message) const noexcept(false) {
+			push_type_panic_string(L, index, expected, actual, message, "(bad argument to variable or function call)");
+			return lua_error(L);
+		}
+	};
+
+	template <typename R, typename... Args>
+	struct argument_handler<types<R, Args...>> {
+		int operator()(lua_State* L, int index, type expected, type actual, string_view message) const noexcept(false) {
+			{
+				std::string aux_message = "(bad argument into '";
+				aux_message += detail::demangle<R>();
+				aux_message += "(";
+				int marker = 0;
+				(void)detail::swallow { int(), (detail::accumulate_and_mark(detail::demangle<Args>(), aux_message, marker), int())... };
+				aux_message += ")')";
+				push_type_panic_string(L, index, expected, actual, message, aux_message);
+			}
+			return lua_error(L);
+		}
+	};
+
+	// Specify this function as the handler for lua::check if you know there's nothing wrong
+	inline int no_panic(lua_State*, int, type, type, const char* = nullptr) noexcept {
+		return 0;
+	}
+
+	inline void type_error(lua_State* L, int expected, int actual) noexcept(false) {
+		luaL_error(L, "expected %s, received %s", lua_typename(L, expected), lua_typename(L, actual));
+	}
+
+	inline void type_error(lua_State* L, type expected, type actual) noexcept(false) {
+		type_error(L, static_cast<int>(expected), static_cast<int>(actual));
+	}
+
+	inline void type_assert(lua_State* L, int index, type expected, type actual) noexcept(false) {
+		if (expected != type::poly && expected != actual) {
+			type_panic_c_str(L, index, expected, actual, nullptr);
+		}
+	}
+
+	inline void type_assert(lua_State* L, int index, type expected) {
+		type actual = type_of(L, index);
+		type_assert(L, index, expected, actual);
+	}
+
+} // namespace sol
+
+// end of sol/error_handler.hpp
+
+// beginning of sol/reference.hpp
+
+// beginning of sol/stack_reference.hpp
+
+namespace sol {
+	namespace detail {
+		inline bool xmovable(lua_State* leftL, lua_State* rightL) {
+			if (rightL == nullptr || leftL == nullptr || leftL == rightL) {
+				return false;
+			}
+			const void* leftregistry = lua_topointer(leftL, LUA_REGISTRYINDEX);
+			const void* rightregistry = lua_topointer(rightL, LUA_REGISTRYINDEX);
+			return leftregistry == rightregistry;
+		}
+	} // namespace detail
+
+	class stateless_stack_reference {
+	private:
+		friend class stack_reference;
+		
+		int index = 0;
+
+		int registry_index() const noexcept {
+			return LUA_NOREF;
+		}
+
+	public:
+		stateless_stack_reference() noexcept = default;
+		stateless_stack_reference(lua_nil_t) noexcept : stateless_stack_reference(){};
+		stateless_stack_reference(lua_State* L, int i) noexcept : stateless_stack_reference(absolute_index(L, i)) {
+		}
+		stateless_stack_reference(lua_State*, absolute_index i) noexcept : stateless_stack_reference(i) {
+		}
+		stateless_stack_reference(lua_State*, raw_index i) noexcept : stateless_stack_reference(i) {
+		}
+		stateless_stack_reference(absolute_index i) noexcept : index(i) {
+		}
+		stateless_stack_reference(raw_index i) noexcept : index(i) {
+		}
+		stateless_stack_reference(lua_State*, ref_index) noexcept = delete;
+		stateless_stack_reference(ref_index) noexcept = delete;
+		stateless_stack_reference(const reference&) noexcept = delete;
+		stateless_stack_reference(const stateless_stack_reference&) noexcept = default;
+		stateless_stack_reference(stateless_stack_reference&& o) noexcept = default;
+		stateless_stack_reference& operator=(stateless_stack_reference&&) noexcept = default;
+		stateless_stack_reference& operator=(const stateless_stack_reference&) noexcept = default;
+
+		int push(lua_State* L) const noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 1, "not enough Lua stack space to push a single reference value");
+#endif // make sure stack doesn't overflow
+			lua_pushvalue(L, index);
+			return 1;
+		}
+
+		void pop(lua_State* L, int n = 1) const noexcept {
+			lua_pop(L, n);
+		}
+
+		int stack_index() const noexcept {
+			return index;
+		}
+
+		const void* pointer(lua_State* L) const noexcept {
+			const void* vp = lua_topointer(L, stack_index());
+			return vp;
+		}
+
+		type get_type(lua_State* L) const noexcept {
+			int result = lua_type(L, index);
+			return static_cast<type>(result);
+		}
+
+		bool valid(lua_State* L) const noexcept {
+			type t = get_type(L);
+			return t != type::lua_nil && t != type::none;
+		}
+
+		void abandon(lua_State* = nullptr) {
+			index = 0;
+		}
+	};
+
+	class stack_reference : public stateless_stack_reference {
+	private:
+		lua_State* luastate = nullptr;
+
+	public:
+		stack_reference() noexcept = default;
+		stack_reference(lua_nil_t) noexcept
+		: stack_reference() {};
+		stack_reference(lua_State* L, lua_nil_t) noexcept : stateless_stack_reference(L, 0), luastate(L) {
+		}
+		stack_reference(lua_State* L, int i) noexcept : stateless_stack_reference(L, i), luastate(L) {
+		}
+		stack_reference(lua_State* L, absolute_index i) noexcept : stateless_stack_reference(L, i), luastate(L) {
+		}
+		stack_reference(lua_State* L, raw_index i) noexcept : stateless_stack_reference(L, i), luastate(L) {
+		}
+		stack_reference(lua_State* L, ref_index i) noexcept = delete;
+		stack_reference(lua_State* L, const reference& r) noexcept = delete;
+		stack_reference(lua_State* L, const stack_reference& r) noexcept
+		: luastate(L) {
+			if (!r.valid()) {
+				index = 0;
+				return;
+			}
+			int i = r.stack_index();
+			if (detail::xmovable(lua_state(), r.lua_state())) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+				luaL_checkstack(L, 1, "not enough Lua stack space to push a single reference value");
+#endif // make sure stack doesn't overflow
+				lua_pushvalue(r.lua_state(), r.index);
+				lua_xmove(r.lua_state(), luastate, 1);
+				i = absolute_index(luastate, -1);
+			}
+			index = i;
+		}
+		stack_reference(stack_reference&& o) noexcept = default;
+		stack_reference& operator=(stack_reference&&) noexcept = default;
+		stack_reference(const stack_reference&) noexcept = default;
+		stack_reference& operator=(const stack_reference&) noexcept = default;
+
+		int push() const noexcept {
+			return push(lua_state());
+		}
+
+		int push(lua_State* Ls) const noexcept {
+			return stateless_stack_reference::push(Ls);
+		}
+
+		void pop() const noexcept {
+			pop(lua_state());
+		}
+
+		void pop(lua_State* Ls, int n = 1) const noexcept {
+			stateless_stack_reference::pop(Ls, n);
+		}
+
+		const void* pointer() const noexcept {
+			return stateless_stack_reference::pointer(lua_state());
+		}
+
+		type get_type() const noexcept {
+			return stateless_stack_reference::get_type(lua_state());
+		}
+
+		lua_State* lua_state() const noexcept {
+			return luastate;
+		}
+
+		bool valid() const noexcept {
+			return stateless_stack_reference::valid(lua_state());
+		}
+
+		void abandon () {
+			stateless_stack_reference::abandon(lua_state());
+		}
+	};
+
+	inline bool operator==(const stack_reference& l, const stack_reference& r) {
+		return lua_compare(l.lua_state(), l.stack_index(), r.stack_index(), LUA_OPEQ) == 0;
+	}
+
+	inline bool operator!=(const stack_reference& l, const stack_reference& r) {
+		return !operator==(l, r);
+	}
+
+	inline bool operator==(const stack_reference& lhs, const lua_nil_t&) {
+		return !lhs.valid();
+	}
+
+	inline bool operator==(const lua_nil_t&, const stack_reference& rhs) {
+		return !rhs.valid();
+	}
+
+	inline bool operator!=(const stack_reference& lhs, const lua_nil_t&) {
+		return lhs.valid();
+	}
+
+	inline bool operator!=(const lua_nil_t&, const stack_reference& rhs) {
+		return rhs.valid();
+	}
+
+	struct stack_reference_equals {
+		bool operator()(const lua_nil_t& lhs, const stack_reference& rhs) const {
+			return lhs == rhs;
+		}
+
+		bool operator()(const stack_reference& lhs, const lua_nil_t& rhs) const {
+			return lhs == rhs;
+		}
+
+		bool operator()(const stack_reference& lhs, const stack_reference& rhs) const {
+			return lhs == rhs;
+		}
+	};
+
+	struct stack_reference_hash {
+		typedef stack_reference argument_type;
+		typedef std::size_t result_type;
+
+		result_type operator()(const argument_type& lhs) const {
+			std::hash<const void*> h;
+			return h(lhs.pointer());
+		}
+	};
+} // namespace sol
+
+// end of sol/stack_reference.hpp
+
+#include <functional>
+
+namespace sol {
+	namespace detail {
+		inline const char (&default_main_thread_name())[9] {
+			static const char name[9] = "sol.\xF0\x9F\x93\x8C";
+			return name;
+		}
+	} // namespace detail
+
+	namespace stack {
+		inline void remove(lua_State* L, int rawindex, int count) {
+			if (count < 1)
+				return;
+			int top = lua_gettop(L);
+			if (top < 1) {
+				return;
+			}
+			if (rawindex == -count || top == rawindex) {
+				// Slice them right off the top
+				lua_pop(L, static_cast<int>(count));
+				return;
+			}
+
+			// Remove each item one at a time using stack operations
+			// Probably slower, maybe, haven't benchmarked,
+			// but necessary
+			int index = lua_absindex(L, rawindex);
+			if (index < 0) {
+				index = lua_gettop(L) + (index + 1);
+			}
+			int last = index + count;
+			for (int i = index; i < last; ++i) {
+				lua_remove(L, index);
+			}
+		}
+
+		struct push_popper_at {
+			lua_State* L;
+			int index;
+			int count;
+			push_popper_at(lua_State* luastate, int index = -1, int count = 1) : L(luastate), index(index), count(count) {
+			}
+			~push_popper_at() {
+				remove(L, index, count);
+			}
+		};
+
+		template <bool top_level>
+		struct push_popper_n {
+			lua_State* L;
+			int t;
+			push_popper_n(lua_State* luastate, int x) : L(luastate), t(x) {
+			}
+			push_popper_n(const push_popper_n&) = delete;
+			push_popper_n(push_popper_n&&) = default;
+			push_popper_n& operator=(const push_popper_n&) = delete;
+			push_popper_n& operator=(push_popper_n&&) = default;
+			~push_popper_n() {
+				lua_pop(L, t);
+			}
+		};
+
+		template <>
+		struct push_popper_n<true> {
+			push_popper_n(lua_State*, int) {
+			}
+		};
+
+		template <bool, typename T, typename = void>
+		struct push_popper {
+			using Tu = meta::unqualified_t<T>;
+			T t;
+			int idx;
+
+			push_popper(T x) : t(x), idx(lua_absindex(t.lua_state(), -t.push())) {
+			}
+
+			int index_of(const Tu&) {
+				return idx;
+			}
+
+			~push_popper() {
+				t.pop();
+			}
+		};
+
+		template <typename T, typename C>
+		struct push_popper<true, T, C> {
+			using Tu = meta::unqualified_t<T>;
+
+			push_popper(T) {
+			}
+
+			int index_of(const Tu&) {
+				return -1;
+			}
+
+			~push_popper() {
+			}
+		};
+
+		template <typename T>
+		struct push_popper<false, T, std::enable_if_t<is_stack_based_v<meta::unqualified_t<T>>>> {
+			using Tu = meta::unqualified_t<T>;
+
+			push_popper(T) {
+			}
+
+			int index_of(const Tu& r) {
+				return r.stack_index();
+			}
+
+			~push_popper() {
+			}
+		};
+
+		template <bool top_level = false, typename T>
+		push_popper<top_level, T> push_pop(T&& x) {
+			return push_popper<top_level, T>(std::forward<T>(x));
+		}
+
+		template <typename T>
+		push_popper_at push_pop_at(T&& x) {
+			int c = x.push();
+			lua_State* L = x.lua_state();
+			return push_popper_at(L, lua_absindex(L, -c), c);
+		}
+
+		template <bool top_level = false>
+		push_popper_n<top_level> pop_n(lua_State* L, int x) {
+			return push_popper_n<top_level>(L, x);
+		}
+	} // namespace stack
+
+	inline lua_State* main_thread(lua_State* L, lua_State* backup_if_unsupported = nullptr) {
+#if SOL_LUA_VESION_I_ < 502
+		if (L == nullptr)
+			return backup_if_unsupported;
+		lua_getglobal(L, detail::default_main_thread_name());
+		auto pp = stack::pop_n(L, 1);
+		if (type_of(L, -1) == type::thread) {
+			return lua_tothread(L, -1);
+		}
+		return backup_if_unsupported;
+#else
+		if (L == nullptr)
+			return backup_if_unsupported;
+		lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_MAINTHREAD);
+		lua_State* Lmain = lua_tothread(L, -1);
+		lua_pop(L, 1);
+		return Lmain;
+#endif // Lua 5.2+ has the main thread unqualified_getter
+	}
+
+	namespace detail {
+		struct global_tag {
+		} const global_ {};
+		struct no_safety_tag {
+		} const no_safety {};
+
+		template <bool b>
+		inline lua_State* pick_main_thread(lua_State* L, lua_State* backup_if_unsupported = nullptr) {
+			(void)L;
+			(void)backup_if_unsupported;
+			if (b) {
+				return main_thread(L, backup_if_unsupported);
+			}
+			return L;
+		}
+	} // namespace detail
+
+	class stateless_reference {
+	private:
+		template <bool o_main_only>
+		friend class basic_reference;
+
+		int ref = LUA_NOREF;
+
+		int copy(lua_State* L) const noexcept {
+			if (ref == LUA_NOREF)
+				return LUA_NOREF;
+			push(L);
+			return luaL_ref(L, LUA_REGISTRYINDEX);
+		}
+
+		lua_State* copy_assign(lua_State* L, lua_State* rL, const stateless_reference& r) {
+			if (valid(L)) {
+				deref(L);
+			}
+			ref = r.copy(L);
+			return rL;
+		}
+
+		lua_State* move_assign(lua_State* L, lua_State* rL, stateless_reference&& r) {
+			if (valid(L)) {
+				deref(L);
+			}
+			ref = r.ref;
+			r.ref = LUA_NOREF;
+			return rL;
+		}
+
+	protected:
+		int stack_index() const noexcept {
+			return -1;
+		}
+
+		stateless_reference(lua_State* L, detail::global_tag) noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 1, "not enough Lua stack space to push this reference value");
+#endif // make sure stack doesn't overflow
+			lua_pushglobaltable(L);
+			ref = luaL_ref(L, LUA_REGISTRYINDEX);
+		}
+
+		stateless_reference(int raw_ref_index) noexcept : ref(raw_ref_index) {
+		}
+
+	public:
+		stateless_reference() noexcept = default;
+		stateless_reference(lua_nil_t) noexcept : stateless_reference() {
+		}
+		stateless_reference(const stack_reference& r) noexcept : stateless_reference(r.lua_state(), r.stack_index()) {
+		}
+		stateless_reference(stack_reference&& r) noexcept : stateless_reference(r.lua_state(), r.stack_index()) {
+		}
+		stateless_reference(lua_State* L, const stateless_reference& r) noexcept {
+			if (r.ref == LUA_REFNIL) {
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (r.ref == LUA_NOREF || L == nullptr) {
+				ref = LUA_NOREF;
+				return;
+			}
+			ref = r.copy(L);
+		}
+
+		stateless_reference(lua_State* L, stateless_reference&& r) noexcept {
+			if (r.ref == LUA_REFNIL) {
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (r.ref == LUA_NOREF || L == nullptr) {
+				ref = LUA_NOREF;
+				return;
+			}
+			ref = r.ref;
+			r.ref = LUA_NOREF;
+		}
+
+		stateless_reference(lua_State* L, const stack_reference& r) noexcept {
+			if (L == nullptr || r.lua_state() == nullptr || r.get_type() == type::none) {
+				ref = LUA_NOREF;
+				return;
+			}
+			if (r.get_type() == type::lua_nil) {
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (L != r.lua_state() && !detail::xmovable(L, r.lua_state())) {
+				return;
+			}
+			r.push(L);
+			ref = luaL_ref(L, LUA_REGISTRYINDEX);
+		}
+
+		stateless_reference(lua_State* L, int index = -1) noexcept {
+			// use L to stick with that state's execution stack
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 1, "not enough Lua stack space to push this reference value");
+#endif // make sure stack doesn't overflow
+			lua_pushvalue(L, index);
+			ref = luaL_ref(L, LUA_REGISTRYINDEX);
+		}
+		stateless_reference(lua_State* L, ref_index index) noexcept {
+			lua_rawgeti(L, LUA_REGISTRYINDEX, index.index);
+			ref = luaL_ref(L, LUA_REGISTRYINDEX);
+		}
+		stateless_reference(lua_State*, lua_nil_t) noexcept {
+		}
+
+		~stateless_reference() noexcept = default;
+
+		stateless_reference(const stateless_reference& o) noexcept = delete;
+		stateless_reference& operator=(const stateless_reference& r) noexcept = delete;
+
+		stateless_reference(stateless_reference&& o) noexcept : ref(o.ref) {
+			o.ref = LUA_NOREF;
+		}
+
+		stateless_reference& operator=(stateless_reference&& o) noexcept {
+			ref = o.ref;
+			o.ref = LUA_NOREF;
+			return *this;
+		}
+
+		int push(lua_State* L) const noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 1, "not enough Lua stack space to push this reference value");
+#endif // make sure stack doesn't overflow
+			lua_rawgeti(L, LUA_REGISTRYINDEX, ref);
+			return 1;
+		}
+
+		void pop(lua_State* L, int n = 1) const noexcept {
+			lua_pop(L, n);
+		}
+
+		int registry_index() const noexcept {
+			return ref;
+		}
+
+		bool valid(lua_State*) const noexcept {
+			return !(ref == LUA_NOREF || ref == LUA_REFNIL);
+		}
+
+		const void* pointer(lua_State* L) const noexcept {
+			int si = push(L);
+			const void* vp = lua_topointer(L, -si);
+			lua_pop(L, si);
+			return vp;
+		}
+
+		type get_type(lua_State* L) const noexcept {
+			int p = push(L);
+			int result = lua_type(L, -1);
+			pop(L, p);
+			return static_cast<type>(result);
+		}
+
+		void abandon(lua_State* = nullptr) {
+			ref = LUA_NOREF;
+		}
+
+		void deref(lua_State* L) const noexcept {
+			luaL_unref(L, LUA_REGISTRYINDEX, ref);
+		}
+	};
+
+	template <bool main_only = false>
+	class basic_reference : public stateless_reference {
+	private:
+		template <bool o_main_only>
+		friend class basic_reference;
+		lua_State* luastate = nullptr; // non-owning
+
+		template <bool r_main_only>
+		void copy_assign(const basic_reference<r_main_only>& r) {
+			if (valid()) {
+				deref();
+			}
+			if (r.ref == LUA_REFNIL) {
+				luastate = detail::pick_main_thread < main_only && !r_main_only > (r.lua_state(), r.lua_state());
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (r.ref == LUA_NOREF) {
+				luastate = r.luastate;
+				ref = LUA_NOREF;
+				return;
+			}
+			if (detail::xmovable(lua_state(), r.lua_state())) {
+				r.push(lua_state());
+				ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
+				return;
+			}
+			luastate = detail::pick_main_thread < main_only && !r_main_only > (r.lua_state(), r.lua_state());
+			ref = r.copy();
+		}
+
+		template <bool r_main_only>
+		void move_assign(basic_reference<r_main_only>&& r) {
+			if (valid()) {
+				deref();
+			}
+			if (r.ref == LUA_REFNIL) {
+				luastate = detail::pick_main_thread < main_only && !r_main_only > (r.lua_state(), r.lua_state());
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (r.ref == LUA_NOREF) {
+				luastate = r.luastate;
+				ref = LUA_NOREF;
+				return;
+			}
+			if (detail::xmovable(lua_state(), r.lua_state())) {
+				r.push(lua_state());
+				ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
+				return;
+			}
+
+			luastate = detail::pick_main_thread < main_only && !r_main_only > (r.lua_state(), r.lua_state());
+			ref = r.ref;
+			r.ref = LUA_NOREF;
+			r.luastate = nullptr;
+		}
+
+	protected:
+		basic_reference(lua_State* L, detail::global_tag) noexcept
+		: basic_reference(detail::pick_main_thread<main_only>(L, L), detail::global_, detail::global_) {
+		}
+
+		basic_reference(lua_State* L, detail::global_tag, detail::global_tag) noexcept : stateless_reference(L, detail::global_), luastate(L) {
+		}
+
+		basic_reference(lua_State* oL, const basic_reference<!main_only>& o) noexcept : stateless_reference(oL, o), luastate(oL) {
+		}
+
+		void deref() const noexcept {
+			return stateless_reference::deref(lua_state());
+		}
+
+		int copy() const noexcept {
+			return copy(lua_state());
+		}
+
+		int copy(lua_State* L) const noexcept {
+			return stateless_reference::copy(L);
+		}
+
+	public:
+		basic_reference() noexcept = default;
+		basic_reference(lua_nil_t) noexcept : basic_reference() {
+		}
+		basic_reference(const stack_reference& r) noexcept : basic_reference(r.lua_state(), r.stack_index()) {
+		}
+		basic_reference(stack_reference&& r) noexcept : basic_reference(r.lua_state(), r.stack_index()) {
+		}
+		template <bool r_main_only>
+		basic_reference(lua_State* L, const basic_reference<r_main_only>& r) noexcept : luastate(detail::pick_main_thread<main_only>(L, L)) {
+			if (r.ref == LUA_REFNIL) {
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (r.ref == LUA_NOREF || lua_state() == nullptr) {
+				ref = LUA_NOREF;
+				return;
+			}
+			if (detail::xmovable(lua_state(), r.lua_state())) {
+				r.push(lua_state());
+				ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
+				return;
+			}
+			ref = r.copy();
+		}
+
+		template <bool r_main_only>
+		basic_reference(lua_State* L, basic_reference<r_main_only>&& r) noexcept : luastate(detail::pick_main_thread<main_only>(L, L)) {
+			if (r.ref == LUA_REFNIL) {
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (r.ref == LUA_NOREF || lua_state() == nullptr) {
+				ref = LUA_NOREF;
+				return;
+			}
+			if (detail::xmovable(lua_state(), r.lua_state())) {
+				r.push(lua_state());
+				ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
+				return;
+			}
+			ref = r.ref;
+			r.ref = LUA_NOREF;
+			r.luastate = nullptr;
+		}
+
+		basic_reference(lua_State* L, const stack_reference& r) noexcept : luastate(detail::pick_main_thread<main_only>(L, L)) {
+			if (lua_state() == nullptr || r.lua_state() == nullptr || r.get_type() == type::none) {
+				ref = LUA_NOREF;
+				return;
+			}
+			if (r.get_type() == type::lua_nil) {
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (lua_state() != r.lua_state() && !detail::xmovable(lua_state(), r.lua_state())) {
+				return;
+			}
+			r.push(lua_state());
+			ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
+		}
+		basic_reference(lua_State* L, int index = -1) noexcept : luastate(detail::pick_main_thread<main_only>(L, L)) {
+			// use L to stick with that state's execution stack
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 1, "not enough Lua stack space to push this reference value");
+#endif // make sure stack doesn't overflow
+			lua_pushvalue(L, index);
+			ref = luaL_ref(L, LUA_REGISTRYINDEX);
+		}
+		basic_reference(lua_State* L, ref_index index) noexcept : luastate(detail::pick_main_thread<main_only>(L, L)) {
+			lua_rawgeti(lua_state(), LUA_REGISTRYINDEX, index.index);
+			ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
+		}
+		basic_reference(lua_State* L, lua_nil_t) noexcept : luastate(detail::pick_main_thread<main_only>(L, L)) {
+		}
+
+		~basic_reference() noexcept {
+			if (lua_state() == nullptr || ref == LUA_NOREF)
+				return;
+			deref();
+		}
+
+		basic_reference(const basic_reference& o) noexcept : stateless_reference(o.copy()), luastate(o.lua_state()) {
+		}
+
+		basic_reference(basic_reference&& o) noexcept : stateless_reference(std::move(o)), luastate(o.lua_state()) {
+			o.luastate = nullptr;
+		}
+
+		basic_reference(const basic_reference<!main_only>& o) noexcept
+		: basic_reference(detail::pick_main_thread<main_only>(o.lua_state(), o.lua_state()), o) {
+		}
+
+		basic_reference(basic_reference<!main_only>&& o) noexcept
+		: stateless_reference(std::move(o)), luastate(detail::pick_main_thread<main_only>(o.lua_state(), o.lua_state())) {
+			o.luastate = nullptr;
+			o.ref = LUA_NOREF;
+		}
+
+		basic_reference& operator=(basic_reference&& r) noexcept {
+			move_assign(std::move(r));
+			return *this;
+		}
+
+		basic_reference& operator=(const basic_reference& r) noexcept {
+			copy_assign(r);
+			return *this;
+		}
+
+		basic_reference& operator=(basic_reference<!main_only>&& r) noexcept {
+			move_assign(std::move(r));
+			return *this;
+		}
+
+		basic_reference& operator=(const basic_reference<!main_only>& r) noexcept {
+			copy_assign(r);
+			return *this;
+		}
+
+		basic_reference& operator=(const lua_nil_t&) noexcept {
+			if (valid()) {
+				deref();
+			}
+			luastate = nullptr;
+			ref = LUA_NOREF;
+			return *this;
+		}
+
+		template <typename Super>
+		basic_reference& operator=(proxy_base<Super>&& r);
+
+		template <typename Super>
+		basic_reference& operator=(const proxy_base<Super>& r);
+
+		int push() const noexcept {
+			return push(lua_state());
+		}
+
+		int push(lua_State* L) const noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 1, "not enough Lua stack space to push this reference value");
+#endif // make sure stack doesn't overflow
+			if (lua_state() == nullptr) {
+				lua_pushnil(L);
+				return 1;
+			}
+			lua_rawgeti(lua_state(), LUA_REGISTRYINDEX, ref);
+			if (L != lua_state()) {
+				lua_xmove(lua_state(), L, 1);
+			}
+			return 1;
+		}
+
+		void pop() const noexcept {
+			pop(lua_state());
+		}
+
+		void pop(lua_State* L, int n = 1) const noexcept {
+			stateless_reference::pop(L, n);
+		}
+
+		int registry_index() const noexcept {
+			return stateless_reference::registry_index();
+		}
+
+		bool valid() const noexcept {
+			return stateless_reference::valid(lua_state());
+		}
+
+		const void* pointer() const noexcept {
+			return stateless_reference::pointer(lua_state());
+		}
+
+		explicit operator bool() const noexcept {
+			return valid();
+		}
+
+		type get_type() const noexcept {
+			return stateless_reference::get_type(lua_state());
+		}
+
+		lua_State* lua_state() const noexcept {
+			return luastate;
+		}
+	};
+
+	template <bool lb, bool rb>
+	inline bool operator==(const basic_reference<lb>& l, const basic_reference<rb>& r) {
+		auto ppl = stack::push_pop(l);
+		auto ppr = stack::push_pop(r);
+		return lua_compare(l.lua_state(), -1, -2, LUA_OPEQ) == 1;
+	}
+
+	template <bool lb, bool rb>
+	inline bool operator!=(const basic_reference<lb>& l, const basic_reference<rb>& r) {
+		return !operator==(l, r);
+	}
+
+	template <bool lb>
+	inline bool operator==(const basic_reference<lb>& l, const stack_reference& r) {
+		auto ppl = stack::push_pop(l);
+		return lua_compare(l.lua_state(), -1, r.stack_index(), LUA_OPEQ) == 1;
+	}
+
+	template <bool lb>
+	inline bool operator!=(const basic_reference<lb>& l, const stack_reference& r) {
+		return !operator==(l, r);
+	}
+
+	template <bool rb>
+	inline bool operator==(const stack_reference& l, const basic_reference<rb>& r) {
+		auto ppr = stack::push_pop(r);
+		return lua_compare(l.lua_state(), -1, r.stack_index(), LUA_OPEQ) == 1;
+	}
+
+	template <bool rb>
+	inline bool operator!=(const stack_reference& l, const basic_reference<rb>& r) {
+		return !operator==(l, r);
+	}
+
+	template <bool lb>
+	inline bool operator==(const basic_reference<lb>& lhs, const lua_nil_t&) {
+		return !lhs.valid();
+	}
+
+	template <bool rb>
+	inline bool operator==(const lua_nil_t&, const basic_reference<rb>& rhs) {
+		return !rhs.valid();
+	}
+
+	template <bool lb>
+	inline bool operator!=(const basic_reference<lb>& lhs, const lua_nil_t&) {
+		return lhs.valid();
+	}
+
+	template <bool rb>
+	inline bool operator!=(const lua_nil_t&, const basic_reference<rb>& rhs) {
+		return rhs.valid();
+	}
+
+	struct reference_equals : public stack_reference_equals {
+		template <bool rb>
+		bool operator()(const lua_nil_t& lhs, const basic_reference<rb>& rhs) const {
+			return lhs == rhs;
+		}
+
+		template <bool lb>
+		bool operator()(const basic_reference<lb>& lhs, const lua_nil_t& rhs) const {
+			return lhs == rhs;
+		}
+
+		template <bool lb, bool rb>
+		bool operator()(const basic_reference<lb>& lhs, const basic_reference<rb>& rhs) const {
+			return lhs == rhs;
+		}
+
+		template <bool lb>
+		bool operator()(const basic_reference<lb>& lhs, const stack_reference& rhs) const {
+			return lhs == rhs;
+		}
+
+		template <bool rb>
+		bool operator()(const stack_reference& lhs, const basic_reference<rb>& rhs) const {
+			return lhs == rhs;
+		}
+	};
+
+	struct reference_hash : public stack_reference_hash {
+		typedef reference argument_type;
+		typedef std::size_t result_type;
+
+		template <bool lb>
+		result_type operator()(const basic_reference<lb>& lhs) const {
+			std::hash<const void*> h;
+			return h(lhs.pointer());
+		}
+	};
+} // namespace sol
+
+// end of sol/reference.hpp
+
+// beginning of sol/tie.hpp
+
+namespace sol {
+
+	namespace detail {
+		template <typename T>
+		struct is_speshul : std::false_type {};
+	} // namespace detail
+
+	template <typename T>
+	struct tie_size : std::tuple_size<T> {};
+
+	template <typename T>
+	struct is_tieable : std::integral_constant<bool, (::sol::tie_size<T>::value > 0)> {};
+
+	template <typename... Tn>
+	struct tie_t : public std::tuple<std::add_lvalue_reference_t<Tn>...> {
+	private:
+		typedef std::tuple<std::add_lvalue_reference_t<Tn>...> base_t;
+
+		template <typename T>
+		void set(std::false_type, T&& target) {
+			std::get<0>(*this) = std::forward<T>(target);
+		}
+
+		template <typename T>
+		void set(std::true_type, T&& target) {
+			typedef tie_size<meta::unqualified_t<T>> value_size;
+			typedef tie_size<std::tuple<Tn...>> tie_size;
+			typedef meta::conditional_t<(value_size::value < tie_size::value), value_size, tie_size> indices_size;
+			typedef std::make_index_sequence<indices_size::value> indices;
+			set_extra(detail::is_speshul<meta::unqualified_t<T>>(), indices(), std::forward<T>(target));
+		}
+
+		template <std::size_t... I, typename T>
+		void set_extra(std::true_type, std::index_sequence<I...>, T&& target) {
+			using std::get;
+			(void)detail::swallow{0,
+				(get<I>(static_cast<base_t&>(*this)) = get<I>(types<Tn...>(), target), 0)..., 0};
+		}
+
+		template <std::size_t... I, typename T>
+		void set_extra(std::false_type, std::index_sequence<I...>, T&& target) {
+			using std::get;
+			(void)detail::swallow{0,
+				(get<I>(static_cast<base_t&>(*this)) = get<I>(target), 0)..., 0};
+		}
+
+	public:
+		using base_t::base_t;
+
+		template <typename T>
+		tie_t& operator=(T&& value) {
+			typedef is_tieable<meta::unqualified_t<T>> tieable;
+			set(tieable(), std::forward<T>(value));
+			return *this;
+		}
+	};
+
+	template <typename... Tn>
+	struct tie_size<tie_t<Tn...>> : std::tuple_size<std::tuple<Tn...>> {};
+
+	namespace adl_barrier_detail {
+		template <typename... Tn>
+		inline tie_t<std::remove_reference_t<Tn>...> tie(Tn&&... argn) {
+			return tie_t<std::remove_reference_t<Tn>...>(std::forward<Tn>(argn)...);
+		}
+	} // namespace adl_barrier_detail
+
+	using namespace adl_barrier_detail;
+
+} // namespace sol
+
+// end of sol/tie.hpp
+
+// beginning of sol/stack_guard.hpp
+
+#include <functional>
+
+namespace sol {
+	namespace detail {
+		inline void stack_fail(int, int) {
+#if !(defined(SOL_NO_EXCEPTIONS) && SOL_NO_EXCEPTIONS)
+			throw error(detail::direct_error, "imbalanced stack after operation finish");
+#else
+			// Lol, what do you want, an error printout? :3c
+			// There's no sane default here. The right way would be C-style abort(), and that's not acceptable, so
+			// hopefully someone will register their own stack_fail thing for the `fx` parameter of stack_guard.
+#endif // No Exceptions
+		}
+	} // namespace detail
+
+	struct stack_guard {
+		lua_State* L;
+		int top;
+		std::function<void(int, int)> on_mismatch;
+
+		stack_guard(lua_State* L) : stack_guard(L, lua_gettop(L)) {
+		}
+		stack_guard(lua_State* L, int top, std::function<void(int, int)> fx = detail::stack_fail) : L(L), top(top), on_mismatch(std::move(fx)) {
+		}
+		bool check_stack(int modification = 0) const {
+			int bottom = lua_gettop(L) + modification;
+			if (top == bottom) {
+				return true;
+			}
+			on_mismatch(top, bottom);
+			return false;
+		}
+		~stack_guard() {
+			check_stack();
+		}
+	};
+} // namespace sol
+
+// end of sol/stack_guard.hpp
+
+#include <vector>
+#include <bitset>
+#include <forward_list>
+#include <string>
+#include <algorithm>
+#include <sstream>
+#include <optional>
+
+namespace sol {
+	namespace detail {
+		struct with_function_tag { };
+		struct as_reference_tag { };
+		template <typename T>
+		struct as_pointer_tag { };
+		template <typename T>
+		struct as_value_tag { };
+		template <typename T>
+		struct as_unique_tag { };
+		template <typename T>
+		struct as_table_tag { };
+
+		using lua_reg_table = luaL_Reg[64];
+
+		using unique_destructor = void (*)(void*);
+		using unique_tag = detail::inheritance_unique_cast_function;
+
+		inline void* align(std::size_t alignment, std::size_t size, void*& ptr, std::size_t& space, std::size_t& required_space) {
+			// this handels arbitrary alignments...
+			// make this into a power-of-2-only?
+			// actually can't: this is a C++14-compatible framework,
+			// power of 2 alignment is C++17
+			std::uintptr_t initial = reinterpret_cast<std::uintptr_t>(ptr);
+			std::uintptr_t offby = static_cast<std::uintptr_t>(initial % alignment);
+			std::uintptr_t padding = (alignment - offby) % alignment;
+			required_space += size + padding;
+			if (space < required_space) {
+				return nullptr;
+			}
+			ptr = static_cast<void*>(static_cast<char*>(ptr) + padding);
+			space -= padding;
+			return ptr;
+		}
+
+		inline void* align(std::size_t alignment, std::size_t size, void*& ptr, std::size_t& space) {
+			std::size_t required_space = 0;
+			return align(alignment, size, ptr, space, required_space);
+		}
+
+		inline void align_one(std::size_t a, std::size_t s, void*& target_alignment) {
+			std::size_t space = (std::numeric_limits<std::size_t>::max)();
+			target_alignment = align(a, s, target_alignment, space);
+			target_alignment = static_cast<void*>(static_cast<char*>(target_alignment) + s);
+		}
+
+		template <typename... Args>
+		std::size_t aligned_space_for(void* alignment = nullptr) {
+			// use temporary storage to prevent strict UB shenanigans
+			char alignment_shim[(std::max)({ sizeof(Args)... }) + (std::max)({ alignof(Args)... })] {};
+			char* start = alignment == nullptr ? static_cast<char*>(alignment) : alignment_shim;
+			(void)detail::swallow { int {}, (align_one(std::alignment_of_v<Args>, sizeof(Args), alignment), int {})... };
+			return static_cast<char*>(alignment) - start;
+		}
+
+		inline void* align_usertype_pointer(void* ptr) {
+			using use_align = std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY_I_)
+			     false
+#else
+			     (std::alignment_of<void*>::value > 1)
+#endif
+			     >;
+			if (!use_align::value) {
+				return ptr;
+			}
+			std::size_t space = (std::numeric_limits<std::size_t>::max)();
+			return align(std::alignment_of<void*>::value, sizeof(void*), ptr, space);
+		}
+
+		template <bool pre_aligned = false, bool pre_shifted = false>
+		void* align_usertype_unique_destructor(void* ptr) {
+			using use_align = std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY_I_)
+			     false
+#else
+			     (std::alignment_of<unique_destructor>::value > 1)
+#endif
+			     >;
+			if (!pre_aligned) {
+				ptr = align_usertype_pointer(ptr);
+			}
+			if (!pre_shifted) {
+				ptr = static_cast<void*>(static_cast<char*>(ptr) + sizeof(void*));
+			}
+			if (!use_align::value) {
+				return static_cast<void*>(static_cast<void**>(ptr) + 1);
+			}
+			std::size_t space = (std::numeric_limits<std::size_t>::max)();
+			return align(std::alignment_of<unique_destructor>::value, sizeof(unique_destructor), ptr, space);
+		}
+
+		template <bool pre_aligned = false, bool pre_shifted = false>
+		void* align_usertype_unique_tag(void* ptr) {
+			using use_align = std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY_I_)
+			     false
+#else
+			     (std::alignment_of<unique_tag>::value > 1)
+#endif
+			     >;
+			if (!pre_aligned) {
+				ptr = align_usertype_unique_destructor(ptr);
+			}
+			if (!pre_shifted) {
+				ptr = static_cast<void*>(static_cast<char*>(ptr) + sizeof(unique_destructor));
+			}
+			if (!use_align::value) {
+				return ptr;
+			}
+			std::size_t space = (std::numeric_limits<std::size_t>::max)();
+			return align(std::alignment_of<unique_tag>::value, sizeof(unique_tag), ptr, space);
+		}
+
+		template <typename T, bool pre_aligned = false, bool pre_shifted = false>
+		void* align_usertype_unique(void* ptr) {
+			typedef std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY_I_)
+			     false
+#else
+			     (std::alignment_of_v<T> > 1)
+#endif
+			     >
+			     use_align;
+			if (!pre_aligned) {
+				ptr = align_usertype_unique_tag(ptr);
+			}
+			if (!pre_shifted) {
+				ptr = static_cast<void*>(static_cast<char*>(ptr) + sizeof(unique_tag));
+			}
+			if (!use_align::value) {
+				return ptr;
+			}
+			std::size_t space = (std::numeric_limits<std::size_t>::max)();
+			return align(std::alignment_of_v<T>, sizeof(T), ptr, space);
+		}
+
+		template <typename T>
+		void* align_user(void* ptr) {
+			typedef std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY_I_)
+			     false
+#else
+			     (std::alignment_of_v<T> > 1)
+#endif
+			     >
+			     use_align;
+			if (!use_align::value) {
+				return ptr;
+			}
+			std::size_t space = (std::numeric_limits<std::size_t>::max)();
+			return align(std::alignment_of_v<T>, sizeof(T), ptr, space);
+		}
+
+		template <typename T>
+		T** usertype_allocate_pointer(lua_State* L) {
+			typedef std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY_I_)
+			     false
+#else
+			     (std::alignment_of<T*>::value > 1)
+#endif
+			     >
+			     use_align;
+			if (!use_align::value) {
+				T** pointerpointer = static_cast<T**>(lua_newuserdata(L, sizeof(T*)));
+				return pointerpointer;
+			}
+			static const std::size_t initial_size = aligned_space_for<T*>(nullptr);
+			static const std::size_t misaligned_size = aligned_space_for<T*>(reinterpret_cast<void*>(0x1));
+
+			std::size_t allocated_size = initial_size;
+			void* unadjusted = lua_newuserdata(L, initial_size);
+			void* adjusted = align(std::alignment_of<T*>::value, sizeof(T*), unadjusted, allocated_size);
+			if (adjusted == nullptr) {
+				lua_pop(L, 1);
+				// what kind of absolute garbage trash allocator are we dealing with?
+				// whatever, add some padding in the case of MAXIMAL alignment waste...
+				allocated_size = misaligned_size;
+				unadjusted = lua_newuserdata(L, allocated_size);
+				adjusted = align(std::alignment_of<T*>::value, sizeof(T*), unadjusted, allocated_size);
+				if (adjusted == nullptr) {
+					// trash allocator can burn in hell
+					lua_pop(L, 1);
+					// luaL_error(L, "if you are the one that wrote this allocator you should feel bad for doing a
+					// worse job than malloc/realloc and should go read some books, yeah?");
+					luaL_error(L, "cannot properly align memory for '%s'", detail::demangle<T*>().data());
+				}
+			}
+			return static_cast<T**>(adjusted);
+		}
+
+		inline bool attempt_alloc(lua_State* L, std::size_t ptr_align, std::size_t ptr_size, std::size_t value_align, std::size_t value_size,
+		     std::size_t allocated_size, void*& pointer_adjusted, void*& data_adjusted) {
+			void* adjusted = lua_newuserdata(L, allocated_size);
+			pointer_adjusted = align(ptr_align, ptr_size, adjusted, allocated_size);
+			if (pointer_adjusted == nullptr) {
+				lua_pop(L, 1);
+				return false;
+			}
+			// subtract size of what we're going to allocate there
+			allocated_size -= ptr_size;
+			adjusted = static_cast<void*>(static_cast<char*>(pointer_adjusted) + ptr_size);
+			data_adjusted = align(value_align, value_size, adjusted, allocated_size);
+			if (data_adjusted == nullptr) {
+				lua_pop(L, 1);
+				return false;
+			}
+			return true;
+		}
+
+		inline bool attempt_alloc_unique(lua_State* L, std::size_t ptr_align, std::size_t ptr_size, std::size_t real_align, std::size_t real_size,
+		     std::size_t allocated_size, void*& pointer_adjusted, void*& dx_adjusted, void*& id_adjusted, void*& data_adjusted) {
+			void* adjusted = lua_newuserdata(L, allocated_size);
+			pointer_adjusted = align(ptr_align, ptr_size, adjusted, allocated_size);
+			if (pointer_adjusted == nullptr) {
+				lua_pop(L, 1);
+				return false;
+			}
+			allocated_size -= ptr_size;
+
+			adjusted = static_cast<void*>(static_cast<char*>(pointer_adjusted) + ptr_size);
+			dx_adjusted = align(std::alignment_of_v<unique_destructor>, sizeof(unique_destructor), adjusted, allocated_size);
+			if (dx_adjusted == nullptr) {
+				lua_pop(L, 1);
+				return false;
+			}
+			allocated_size -= sizeof(unique_destructor);
+
+			adjusted = static_cast<void*>(static_cast<char*>(dx_adjusted) + sizeof(unique_destructor));
+
+			id_adjusted = align(std::alignment_of_v<unique_tag>, sizeof(unique_tag), adjusted, allocated_size);
+			if (id_adjusted == nullptr) {
+				lua_pop(L, 1);
+				return false;
+			}
+			allocated_size -= sizeof(unique_tag);
+
+			adjusted = static_cast<void*>(static_cast<char*>(id_adjusted) + sizeof(unique_tag));
+			data_adjusted = align(real_align, real_size, adjusted, allocated_size);
+			if (data_adjusted == nullptr) {
+				lua_pop(L, 1);
+				return false;
+			}
+			return true;
+		}
+
+		template <typename T>
+		T* usertype_allocate(lua_State* L) {
+			typedef std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY_I_)
+			     false
+#else
+			     (std::alignment_of<T*>::value > 1 || std::alignment_of_v<T> > 1)
+#endif
+			     >
+			     use_align;
+			if (!use_align::value) {
+				T** pointerpointer = static_cast<T**>(lua_newuserdata(L, sizeof(T*) + sizeof(T)));
+				T*& pointerreference = *pointerpointer;
+				T* allocationtarget = reinterpret_cast<T*>(pointerpointer + 1);
+				pointerreference = allocationtarget;
+				return allocationtarget;
+			}
+
+			/* the assumption is that `lua_newuserdata` -- unless someone
+			passes a specific lua_Alloc that gives us bogus, un-aligned pointers
+			-- uses malloc, which tends to hand out more or less aligned pointers to memory
+			(most of the time, anyhow)
+
+			but it's not guaranteed, so we have to do a post-adjustment check and increase padding
+
+			we do this preliminarily with compile-time stuff, to see
+			if we strike lucky with the allocator and alignment values
+
+			otherwise, we have to re-allocate the userdata and
+			over-allocate some space for additional padding because
+			compilers are optimized for aligned reads/writes
+			(and clang will barf UBsan errors on us for not being aligned)
+			*/
+			static const std::size_t initial_size = aligned_space_for<T*, T>(nullptr);
+			static const std::size_t misaligned_size = aligned_space_for<T*, T>(reinterpret_cast<void*>(0x1));
+
+			void* pointer_adjusted;
+			void* data_adjusted;
+			bool result
+			     = attempt_alloc(L, std::alignment_of_v<T*>, sizeof(T*), std::alignment_of_v<T>, sizeof(T), initial_size, pointer_adjusted, data_adjusted);
+			if (!result) {
+				// we're likely to get something that fails to perform the proper allocation a second time,
+				// so we use the suggested_new_size bump to help us out here
+				pointer_adjusted = nullptr;
+				data_adjusted = nullptr;
+				result = attempt_alloc(
+				     L, std::alignment_of_v<T*>, sizeof(T*), std::alignment_of_v<T>, sizeof(T), misaligned_size, pointer_adjusted, data_adjusted);
+				if (!result) {
+					if (pointer_adjusted == nullptr) {
+						luaL_error(L, "aligned allocation of userdata block (pointer section) for '%s' failed", detail::demangle<T>().c_str());
+					}
+					else {
+						luaL_error(L, "aligned allocation of userdata block (data section) for '%s' failed", detail::demangle<T>().c_str());
+					}
+					return nullptr;
+				}
+			}
+
+			T** pointerpointer = reinterpret_cast<T**>(pointer_adjusted);
+			T*& pointerreference = *pointerpointer;
+			T* allocationtarget = reinterpret_cast<T*>(data_adjusted);
+			pointerreference = allocationtarget;
+			return allocationtarget;
+		}
+
+		template <typename T, typename Real>
+		Real* usertype_unique_allocate(lua_State* L, T**& pref, unique_destructor*& dx, unique_tag*& id) {
+			typedef std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY_I_)
+			     false
+#else
+			     (std::alignment_of<T*>::value > 1 || std::alignment_of<unique_tag>::value > 1 || std::alignment_of<unique_destructor>::value > 1
+			          || std::alignment_of<Real>::value > 1)
+#endif
+			     >
+			     use_align;
+			if (!use_align::value) {
+				pref = static_cast<T**>(lua_newuserdata(L, sizeof(T*) + sizeof(detail::unique_destructor) + sizeof(unique_tag) + sizeof(Real)));
+				dx = static_cast<detail::unique_destructor*>(static_cast<void*>(pref + 1));
+				id = static_cast<unique_tag*>(static_cast<void*>(dx + 1));
+				Real* mem = static_cast<Real*>(static_cast<void*>(id + 1));
+				return mem;
+			}
+
+			static const std::size_t initial_size = aligned_space_for<T*, unique_destructor, unique_tag, Real>(nullptr);
+			static const std::size_t misaligned_size = aligned_space_for<T*, unique_destructor, unique_tag, Real>(reinterpret_cast<void*>(0x1));
+
+			void* pointer_adjusted;
+			void* dx_adjusted;
+			void* id_adjusted;
+			void* data_adjusted;
+			bool result = attempt_alloc_unique(L,
+			     std::alignment_of_v<T*>,
+			     sizeof(T*),
+			     std::alignment_of_v<Real>,
+			     sizeof(Real),
+			     initial_size,
+			     pointer_adjusted,
+			     dx_adjusted,
+			     id_adjusted,
+			     data_adjusted);
+			if (!result) {
+				// we're likely to get something that fails to perform the proper allocation a second time,
+				// so we use the suggested_new_size bump to help us out here
+				pointer_adjusted = nullptr;
+				dx_adjusted = nullptr;
+				id_adjusted = nullptr;
+				data_adjusted = nullptr;
+				result = attempt_alloc_unique(L,
+				     std::alignment_of_v<T*>,
+				     sizeof(T*),
+				     std::alignment_of_v<Real>,
+				     sizeof(Real),
+				     misaligned_size,
+				     pointer_adjusted,
+				     dx_adjusted,
+				     id_adjusted,
+				     data_adjusted);
+				if (!result) {
+					if (pointer_adjusted == nullptr) {
+						luaL_error(L, "aligned allocation of userdata block (pointer section) for '%s' failed", detail::demangle<T>().c_str());
+					}
+					else if (dx_adjusted == nullptr) {
+						luaL_error(L, "aligned allocation of userdata block (deleter section) for '%s' failed", detail::demangle<T>().c_str());
+					}
+					else {
+						luaL_error(L, "aligned allocation of userdata block (data section) for '%s' failed", detail::demangle<T>().c_str());
+					}
+					return nullptr;
+				}
+			}
+
+			pref = static_cast<T**>(pointer_adjusted);
+			dx = static_cast<detail::unique_destructor*>(dx_adjusted);
+			id = static_cast<unique_tag*>(id_adjusted);
+			Real* mem = static_cast<Real*>(data_adjusted);
+			return mem;
+		}
+
+		template <typename T>
+		T* user_allocate(lua_State* L) {
+			typedef std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY_I_)
+			     false
+#else
+			     (std::alignment_of_v<T> > 1)
+#endif
+			     >
+			     use_align;
+			if (!use_align::value) {
+				T* pointer = static_cast<T*>(lua_newuserdata(L, sizeof(T)));
+				return pointer;
+			}
+
+			static const std::size_t initial_size = aligned_space_for<T>(nullptr);
+			static const std::size_t misaligned_size = aligned_space_for<T>(reinterpret_cast<void*>(0x1));
+
+			std::size_t allocated_size = initial_size;
+			void* unadjusted = lua_newuserdata(L, allocated_size);
+			void* adjusted = align(std::alignment_of_v<T>, sizeof(T), unadjusted, allocated_size);
+			if (adjusted == nullptr) {
+				lua_pop(L, 1);
+				// try again, add extra space for alignment padding
+				allocated_size = misaligned_size;
+				unadjusted = lua_newuserdata(L, allocated_size);
+				adjusted = align(std::alignment_of_v<T>, sizeof(T), unadjusted, allocated_size);
+				if (adjusted == nullptr) {
+					lua_pop(L, 1);
+					luaL_error(L, "cannot properly align memory for '%s'", detail::demangle<T>().data());
+				}
+			}
+			return static_cast<T*>(adjusted);
+		}
+
+		template <typename T>
+		int usertype_alloc_destruct(lua_State* L) {
+			void* memory = lua_touserdata(L, 1);
+			memory = align_usertype_pointer(memory);
+			T** pdata = static_cast<T**>(memory);
+			T* data = *pdata;
+			std::allocator<T> alloc {};
+			std::allocator_traits<std::allocator<T>>::destroy(alloc, data);
+			return 0;
+		}
+
+		template <typename T>
+		int unique_destruct(lua_State* L) {
+			void* memory = lua_touserdata(L, 1);
+			memory = align_usertype_unique_destructor(memory);
+			unique_destructor& dx = *static_cast<unique_destructor*>(memory);
+			memory = align_usertype_unique_tag<true>(memory);
+			(dx)(memory);
+			return 0;
+		}
+
+		template <typename T>
+		int user_alloc_destruct(lua_State* L) {
+			void* memory = lua_touserdata(L, 1);
+			memory = align_user<T>(memory);
+			T* data = static_cast<T*>(memory);
+			std::allocator<T> alloc;
+			std::allocator_traits<std::allocator<T>>::destroy(alloc, data);
+			return 0;
+		}
+
+		template <typename T, typename Real>
+		void usertype_unique_alloc_destroy(void* memory) {
+			memory = align_usertype_unique<Real, true>(memory);
+			Real* target = static_cast<Real*>(memory);
+			std::allocator<Real> alloc;
+			std::allocator_traits<std::allocator<Real>>::destroy(alloc, target);
+		}
+
+		template <typename T>
+		int cannot_destruct(lua_State* L) {
+			return luaL_error(L,
+			     "cannot call the destructor for '%s': it is either hidden (protected/private) or removed with '= "
+			     "delete' and thusly this type is being destroyed without properly destructing, invoking undefined "
+			     "behavior: please bind a usertype and specify a custom destructor to define the behavior properly",
+			     detail::demangle<T>().data());
+		}
+
+		template <typename T>
+		void reserve(T&, std::size_t) {
+		}
+
+		template <typename T, typename Al>
+		void reserve(std::vector<T, Al>& vec, std::size_t hint) {
+			vec.reserve(hint);
+		}
+
+		template <typename T, typename Tr, typename Al>
+		void reserve(std::basic_string<T, Tr, Al>& str, std::size_t hint) {
+			str.reserve(hint);
+		}
+
+		inline bool property_always_true(meta_function) {
+			return true;
+		}
+
+		struct properties_enrollment_allowed {
+			int& times_through;
+			std::bitset<64>& properties;
+			automagic_enrollments& enrollments;
+
+			properties_enrollment_allowed(int& times, std::bitset<64>& props, automagic_enrollments& enroll)
+			: times_through(times), properties(props), enrollments(enroll) {
+			}
+
+			bool operator()(meta_function mf) const {
+				bool p = properties[static_cast<int>(mf)];
+				if (times_through > 0) {
+					return p;
+				}
+				switch (mf) {
+				case meta_function::length:
+					return enrollments.length_operator && !p;
+				case meta_function::pairs:
+					return enrollments.pairs_operator && !p;
+				case meta_function::call:
+					return enrollments.call_operator && !p;
+				case meta_function::less_than:
+					return enrollments.less_than_operator && !p;
+				case meta_function::less_than_or_equal_to:
+					return enrollments.less_than_or_equal_to_operator && !p;
+				case meta_function::equal_to:
+					return enrollments.equal_to_operator && !p;
+				default:
+					break;
+				}
+				return !p;
+			}
+		};
+
+		struct indexed_insert {
+			lua_reg_table& l;
+			int& index;
+
+			indexed_insert(lua_reg_table& cont, int& idx) : l(cont), index(idx) {
+			}
+			void operator()(meta_function mf, lua_CFunction f) {
+				l[index] = luaL_Reg { to_string(mf).c_str(), f };
+				++index;
+			}
+		};
+	} // namespace detail
+
+	namespace stack {
+
+		template <typename T, bool global = false, bool raw = false, typename = void>
+		struct field_getter;
+		template <typename T, typename P, bool global = false, bool raw = false, typename = void>
+		struct probe_field_getter;
+
+		template <typename T, bool global = false, bool raw = false, typename = void>
+		struct field_setter;
+
+		template <typename T, typename = void>
+		struct unqualified_getter;
+		template <typename T, typename = void>
+		struct qualified_getter;
+
+		template <typename T, typename = void>
+		struct qualified_interop_getter;
+		template <typename T, typename = void>
+		struct unqualified_interop_getter;
+
+		template <typename T, typename = void>
+		struct popper;
+
+		template <typename T, typename = void>
+		struct unqualified_pusher;
+
+		template <typename T, type t, typename = void>
+		struct unqualified_checker;
+		template <typename T, type t, typename = void>
+		struct qualified_checker;
+
+		template <typename T, typename = void>
+		struct unqualified_check_getter;
+		template <typename T, typename = void>
+		struct qualified_check_getter;
+
+		struct probe {
+			bool success;
+			int levels;
+
+			probe(bool s, int l) : success(s), levels(l) {
+			}
+
+			operator bool() const {
+				return success;
+			};
+		};
+
+		struct record {
+			int last;
+			int used;
+
+			record() noexcept : last(), used() {
+			}
+			void use(int count) noexcept {
+				last = count;
+				used += count;
+			}
+		};
+
+		namespace stack_detail {
+			template <typename Function>
+			Function* get_function_pointer(lua_State*, int, record&) noexcept;
+			template <typename Function, typename Handler>
+			bool check_function_pointer(lua_State* L, int index, Handler&& handler, record& tracking) noexcept;
+		} // namespace stack_detail
+
+	} // namespace stack
+
+	namespace meta { namespace meta_detail {
+
+		template <typename T>
+		using adl_sol_lua_get_test_t = decltype(sol_lua_get(types<T>(), static_cast<lua_State*>(nullptr), -1, std::declval<stack::record&>()));
+
+		template <typename T>
+		using adl_sol_lua_interop_get_test_t
+			= decltype(sol_lua_interop_get(types<T>(), static_cast<lua_State*>(nullptr), -1, static_cast<void*>(nullptr), std::declval<stack::record&>()));
+
+		template <typename T>
+		using adl_sol_lua_check_test_t = decltype(sol_lua_check(types<T>(), static_cast<lua_State*>(nullptr), -1, no_panic, std::declval<stack::record&>()));
+
+		template <typename T>
+		using adl_sol_lua_interop_check_test_t
+			= decltype(sol_lua_interop_check(types<T>(), static_cast<lua_State*>(nullptr), -1, type::none, no_panic, std::declval<stack::record&>()));
+
+		template <typename T>
+		using adl_sol_lua_check_get_test_t
+			= decltype(sol_lua_check_get(types<T>(), static_cast<lua_State*>(nullptr), -1, no_panic, std::declval<stack::record&>()));
+
+		template <typename... Args>
+		using adl_sol_lua_push_test_t = decltype(sol_lua_push(static_cast<lua_State*>(nullptr), std::declval<Args>()...));
+
+		template <typename T, typename... Args>
+		using adl_sol_lua_push_exact_test_t = decltype(sol_lua_push(types<T>(), static_cast<lua_State*>(nullptr), std::declval<Args>()...));
+
+		template <typename T>
+		inline constexpr bool is_adl_sol_lua_get_v = meta::is_detected_v<adl_sol_lua_get_test_t, T>;
+
+		template <typename T>
+		inline constexpr bool is_adl_sol_lua_interop_get_v = meta::is_detected_v<adl_sol_lua_interop_get_test_t, T>;
+
+		template <typename T>
+		inline constexpr bool is_adl_sol_lua_check_v = meta::is_detected_v<adl_sol_lua_check_test_t, T>;
+
+		template <typename T>
+		inline constexpr bool is_adl_sol_lua_interop_check_v = meta::is_detected_v<adl_sol_lua_interop_check_test_t, T>;
+
+		template <typename T>
+		inline constexpr bool is_adl_sol_lua_check_get_v = meta::is_detected_v<adl_sol_lua_check_get_test_t, T>;
+
+		template <typename... Args>
+		inline constexpr bool is_adl_sol_lua_push_v = meta::is_detected_v<adl_sol_lua_push_test_t, Args...>;
+
+		template <typename T, typename... Args>
+		inline constexpr bool is_adl_sol_lua_push_exact_v = meta::is_detected_v<adl_sol_lua_push_exact_test_t, T, Args...>;
+	}} // namespace meta::meta_detail
+
+	namespace stack {
+		namespace stack_detail {
+			constexpr const char* not_enough_stack_space = "not enough space left on Lua stack";
+			constexpr const char* not_enough_stack_space_floating = "not enough space left on Lua stack for a floating point number";
+			constexpr const char* not_enough_stack_space_integral = "not enough space left on Lua stack for an integral number";
+			constexpr const char* not_enough_stack_space_string = "not enough space left on Lua stack for a string";
+			constexpr const char* not_enough_stack_space_meta_function_name = "not enough space left on Lua stack for the name of a meta_function";
+			constexpr const char* not_enough_stack_space_userdata = "not enough space left on Lua stack to create a sol3 userdata";
+			constexpr const char* not_enough_stack_space_generic = "not enough space left on Lua stack to push valuees";
+			constexpr const char* not_enough_stack_space_environment = "not enough space left on Lua stack to retrieve environment";
+
+			template <typename T>
+			struct strip {
+				typedef T type;
+			};
+			template <typename T>
+			struct strip<std::reference_wrapper<T>> {
+				typedef T& type;
+			};
+			template <typename T>
+			struct strip<user<T>> {
+				typedef T& type;
+			};
+			template <typename T>
+			struct strip<non_null<T>> {
+				typedef T type;
+			};
+			template <typename T>
+			using strip_t = typename strip<T>::type;
+
+			template <typename C>
+			static int get_size_hint(C& c) {
+				return static_cast<int>(c.size());
+			}
+
+			template <typename V, typename Al>
+			static int get_size_hint(const std::forward_list<V, Al>&) {
+				// forward_list makes me sad
+				return static_cast<int>(32);
+			}
+
+			template <typename T>
+			decltype(auto) unchecked_unqualified_get(lua_State* L, int index, record& tracking) {
+				using Tu = meta::unqualified_t<T>;
+				if constexpr (meta::meta_detail::is_adl_sol_lua_get_v<Tu>) {
+					return sol_lua_get(types<Tu>(), L, index, tracking);
+				}
+				else {
+					unqualified_getter<Tu> g {};
+					(void)g;
+					return g.get(L, index, tracking);
+				}
+			}
+
+			template <typename T>
+			decltype(auto) unchecked_get(lua_State* L, int index, record& tracking) {
+				if constexpr (meta::meta_detail::is_adl_sol_lua_get_v<T>) {
+					return sol_lua_get(types<T>(), L, index, tracking);
+				}
+				else {
+					qualified_getter<T> g {};
+					(void)g;
+					return g.get(L, index, tracking);
+				}
+			}
+
+			template <typename T>
+			decltype(auto) unqualified_interop_get(lua_State* L, int index, void* unadjusted_pointer, record& tracking) {
+				using Tu = meta::unqualified_t<T>;
+				if constexpr (meta::meta_detail::is_adl_sol_lua_interop_get_v<Tu>) {
+					return sol_lua_interop_get(types<Tu>(), L, index, unadjusted_pointer, tracking);
+				}
+				else {
+					(void)L;
+					(void)index;
+					(void)unadjusted_pointer;
+					(void)tracking;
+					using Ti = stack_detail::strip_t<Tu>;
+					return std::pair<bool, Ti*> { false, nullptr };
+				}
+			}
+
+			template <typename T>
+			decltype(auto) interop_get(lua_State* L, int index, void* unadjusted_pointer, record& tracking) {
+				if constexpr (meta::meta_detail::is_adl_sol_lua_interop_get_v<T>) {
+					return sol_lua_interop_get(types<T>(), L, index, unadjusted_pointer, tracking);
+				}
+				else {
+					return unqualified_interop_get<T>(L, index, unadjusted_pointer, tracking);
+				}
+			}
+
+			template <typename T, typename Handler>
+			bool unqualified_interop_check(lua_State* L, int index, type index_type, Handler&& handler, record& tracking) {
+				using Tu = meta::unqualified_t<T>;
+				if constexpr (meta::meta_detail::is_adl_sol_lua_interop_check_v<Tu>) {
+					return sol_lua_interop_check(types<Tu>(), L, index, index_type, std::forward<Handler>(handler), tracking);
+				}
+				else {
+					(void)L;
+					(void)index;
+					(void)index_type;
+					(void)handler;
+					(void)tracking;
+					return false;
+				}
+			}
+
+			template <typename T, typename Handler>
+			bool interop_check(lua_State* L, int index, type index_type, Handler&& handler, record& tracking) {
+				if constexpr (meta::meta_detail::is_adl_sol_lua_interop_check_v<T>) {
+					return sol_lua_interop_check(types<T>(), L, index, index_type, std::forward<Handler>(handler), tracking);
+				}
+				else {
+					return unqualified_interop_check<T>(L, index, index_type, std::forward<Handler>(handler), tracking);
+				}
+			}
+
+			using undefined_method_func = void (*)(stack_reference);
+
+			struct undefined_metatable {
+				lua_State* L;
+				const char* key;
+				undefined_method_func on_new_table;
+
+				undefined_metatable(lua_State* l, const char* k, undefined_method_func umf) : L(l), key(k), on_new_table(umf) {
+				}
+
+				void operator()() const {
+					if (luaL_newmetatable(L, key) == 1) {
+						on_new_table(stack_reference(L, -1));
+					}
+					lua_setmetatable(L, -2);
+				}
+			};
+		} // namespace stack_detail
+
+		inline bool maybe_indexable(lua_State* L, int index = -1) {
+			type t = type_of(L, index);
+			return t == type::userdata || t == type::table;
+		}
+
+		inline int top(lua_State* L) {
+			return lua_gettop(L);
+		}
+
+		inline bool is_main_thread(lua_State* L) {
+			int ismainthread = lua_pushthread(L);
+			lua_pop(L, 1);
+			return ismainthread == 1;
+		}
+
+		inline void coroutine_create_guard(lua_State* L) {
+			if (is_main_thread(L)) {
+				return;
+			}
+			int stacksize = lua_gettop(L);
+			if (stacksize < 1) {
+				return;
+			}
+			if (type_of(L, 1) != type::function) {
+				return;
+			}
+			// well now we're screwed...
+			// we can clean the stack and pray it doesn't destroy anything?
+			lua_pop(L, stacksize);
+		}
+
+		inline void clear(lua_State* L, int table_index) {
+			lua_pushnil(L);
+			while (lua_next(L, table_index) != 0) {
+				// remove value
+				lua_pop(L, 1);
+				// duplicate key to protect form rawset
+				lua_pushvalue(L, -1);
+				// push new value
+				lua_pushnil(L);
+				// table_index%[key] = nil
+				lua_rawset(L, table_index);
+			}
+		}
+
+		inline void clear(reference& r) {
+			auto pp = push_pop<false>(r);
+			int stack_index = pp.index_of(r);
+			clear(r.lua_state(), stack_index);
+		}
+
+		inline void clear(stack_reference& r) {
+			clear(r.lua_state(), r.stack_index());
+		}
+
+		template <typename T, typename... Args>
+		int push(lua_State* L, T&& t, Args&&... args) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (meta::meta_detail::is_adl_sol_lua_push_exact_v<T, T, Args...>) {
+				return sol_lua_push(types<T>(), L, std::forward<T>(t), std::forward<Args>(args)...);
+			}
+			else if constexpr (meta::meta_detail::is_adl_sol_lua_push_exact_v<Tu, T, Args...>) {
+				return sol_lua_push(types<Tu>(), L, std::forward<T>(t), std::forward<Args>(args)...);
+			}
+			else if constexpr (meta::meta_detail::is_adl_sol_lua_push_v<T, Args...>) {
+				return sol_lua_push(L, std::forward<T>(t), std::forward<Args>(args)...);
+			}
+			else {
+				unqualified_pusher<Tu> p {};
+				(void)p;
+				return p.push(L, std::forward<T>(t), std::forward<Args>(args)...);
+			}
+		}
+
+		// overload allows to use a pusher of a specific type, but pass in any kind of args
+		template <typename T, typename Arg, typename... Args, typename = std::enable_if_t<!std::is_same<T, Arg>::value>>
+		int push(lua_State* L, Arg&& arg, Args&&... args) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (meta::meta_detail::is_adl_sol_lua_push_exact_v<T, Arg, Args...>) {
+				return sol_lua_push(types<T>(), L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+			else if constexpr (meta::meta_detail::is_adl_sol_lua_push_exact_v<Tu, Arg, Args...>) {
+				return sol_lua_push(types<Tu>(), L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+			else if constexpr (meta::meta_detail::is_adl_sol_lua_push_v<Arg, Args...>) {
+				return sol_lua_push(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+			else {
+				unqualified_pusher<Tu> p {};
+				(void)p;
+				return p.push(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+		}
+
+		template <typename T, typename... Args>
+		int push_userdata(lua_State* L, T&& t, Args&&... args) {
+			using U = meta::unqualified_t<T>;
+			using Tr = meta::conditional_t<std::is_pointer_v<U>,
+			     detail::as_pointer_tag<std::remove_pointer_t<U>>,
+			     meta::conditional_t<is_unique_usertype_v<U>, detail::as_unique_tag<U>, detail::as_value_tag<U>>>;
+			return stack::push<Tr>(L, std::forward<T>(t), std::forward<Args>(args)...);
+		}
+
+		template <typename T, typename Arg, typename... Args>
+		int push_userdata(lua_State* L, Arg&& arg, Args&&... args) {
+			using U = meta::unqualified_t<T>;
+			using Tr = meta::conditional_t<std::is_pointer_v<U>,
+			     detail::as_pointer_tag<std::remove_pointer_t<U>>,
+			     meta::conditional_t<is_unique_usertype_v<U>, detail::as_unique_tag<U>, detail::as_value_tag<U>>>;
+			return stack::push<Tr>(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+		}
+
+		namespace stack_detail {
+
+			template <typename T, typename Arg, typename... Args>
+			int push_reference(lua_State* L, Arg&& arg, Args&&... args) {
+				using use_reference_tag = meta::all<std::is_lvalue_reference<T>,
+				     meta::neg<std::is_const<std::remove_reference_t<T>>>,
+				     meta::neg<is_lua_primitive<meta::unqualified_t<T>>>,
+				     meta::neg<is_unique_usertype<meta::unqualified_t<T>>>>;
+				using Tr = meta::conditional_t<use_reference_tag::value, detail::as_reference_tag, meta::unqualified_t<T>>;
+				return stack::push<Tr>(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+
+		} // namespace stack_detail
+
+		template <typename T, typename... Args>
+		int push_reference(lua_State* L, T&& t, Args&&... args) {
+			return stack_detail::push_reference<T>(L, std::forward<T>(t), std::forward<Args>(args)...);
+		}
+
+		template <typename T, typename Arg, typename... Args>
+		int push_reference(lua_State* L, Arg&& arg, Args&&... args) {
+			return stack_detail::push_reference<T>(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+		}
+
+		inline int multi_push(lua_State*) {
+			// do nothing
+			return 0;
+		}
+
+		template <typename T, typename... Args>
+		int multi_push(lua_State* L, T&& t, Args&&... args) {
+			int pushcount = push(L, std::forward<T>(t));
+			void(detail::swallow { (pushcount += stack::push(L, std::forward<Args>(args)), 0)... });
+			return pushcount;
+		}
+
+		inline int multi_push_reference(lua_State*) {
+			// do nothing
+			return 0;
+		}
+
+		template <typename T, typename... Args>
+		int multi_push_reference(lua_State* L, T&& t, Args&&... args) {
+			int pushcount = push_reference(L, std::forward<T>(t));
+			void(detail::swallow { (pushcount += stack::push_reference(L, std::forward<Args>(args)), 0)... });
+			return pushcount;
+		}
+
+		template <typename T, typename Handler>
+		bool unqualified_check(lua_State* L, int index, Handler&& handler, record& tracking) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (meta::meta_detail::is_adl_sol_lua_check_v<Tu>) {
+				return sol_lua_check(types<Tu>(), L, index, std::forward<Handler>(handler), tracking);
+			}
+			else {
+				unqualified_checker<Tu, lua_type_of_v<Tu>> c;
+				// VC++ has a bad warning here: shut it up
+				(void)c;
+				return c.check(L, index, std::forward<Handler>(handler), tracking);
+			}
+		}
+
+		template <typename T, typename Handler>
+		bool unqualified_check(lua_State* L, int index, Handler&& handler) {
+			record tracking {};
+			return unqualified_check<T>(L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename T>
+		bool unqualified_check(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+			auto handler = no_panic;
+			return unqualified_check<T>(L, index, handler);
+		}
+
+		template <typename T, typename Handler>
+		bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
+			if constexpr (meta::meta_detail::is_adl_sol_lua_check_v<T>) {
+				return sol_lua_check(types<T>(), L, index, std::forward<Handler>(handler), tracking);
+			}
+			else {
+				using Tu = meta::unqualified_t<T>;
+				qualified_checker<T, lua_type_of_v<Tu>> c;
+				// VC++ has a bad warning here: shut it up
+				(void)c;
+				return c.check(L, index, std::forward<Handler>(handler), tracking);
+			}
+		}
+
+		template <typename T, typename Handler>
+		bool check(lua_State* L, int index, Handler&& handler) {
+			record tracking {};
+			return check<T>(L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename T>
+		bool check(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+			auto handler = no_panic;
+			return check<T>(L, index, handler);
+		}
+
+		template <typename T, typename Handler>
+		bool check_usertype(lua_State* L, int index, type, Handler&& handler, record& tracking) {
+			using Tu = meta::unqualified_t<T>;
+			using detail_t = meta::conditional_t<std::is_pointer_v<T>, detail::as_pointer_tag<Tu>, detail::as_value_tag<Tu>>;
+			return check<detail_t>(L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename T, typename Handler>
+		bool check_usertype(lua_State* L, int index, Handler&& handler, record& tracking) {
+			using Tu = meta::unqualified_t<T>;
+			using detail_t = meta::conditional_t<std::is_pointer_v<T>, detail::as_pointer_tag<Tu>, detail::as_value_tag<Tu>>;
+			return check<detail_t>(L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename T, typename Handler>
+		bool check_usertype(lua_State* L, int index, Handler&& handler) {
+			record tracking {};
+			return check_usertype<T>(L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename T>
+		bool check_usertype(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+			auto handler = no_panic;
+			return check_usertype<T>(L, index, handler);
+		}
+
+		template <typename T, typename Handler>
+		decltype(auto) unqualified_check_get(lua_State* L, int index, Handler&& handler, record& tracking) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (meta::meta_detail::is_adl_sol_lua_check_get_v<T>) {
+				return sol_lua_check_get(types<T>(), L, index, std::forward<Handler>(handler), tracking);
+			}
+			else if constexpr (meta::meta_detail::is_adl_sol_lua_check_get_v<Tu>) {
+				return sol_lua_check_get(types<Tu>(), L, index, std::forward<Handler>(handler), tracking);
+			}
+			else {
+				unqualified_check_getter<Tu> cg {};
+				(void)cg;
+				return cg.get(L, index, std::forward<Handler>(handler), tracking);
+			}
+		}
+
+		template <typename T, typename Handler>
+		decltype(auto) unqualified_check_get(lua_State* L, int index, Handler&& handler) {
+			record tracking {};
+			return unqualified_check_get<T>(L, index, handler, tracking);
+		}
+
+		template <typename T>
+		decltype(auto) unqualified_check_get(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+			auto handler = no_panic;
+			return unqualified_check_get<T>(L, index, handler);
+		}
+
+		template <typename T, typename Handler>
+		decltype(auto) check_get(lua_State* L, int index, Handler&& handler, record& tracking) {
+			if constexpr (meta::meta_detail::is_adl_sol_lua_check_get_v<T>) {
+				return sol_lua_check_get(types<T>(), L, index, std::forward<Handler>(handler), tracking);
+			}
+			else {
+				qualified_check_getter<T> cg {};
+				(void)cg;
+				return cg.get(L, index, std::forward<Handler>(handler), tracking);
+			}
+		}
+
+		template <typename T, typename Handler>
+		decltype(auto) check_get(lua_State* L, int index, Handler&& handler) {
+			record tracking {};
+			return check_get<T>(L, index, handler, tracking);
+		}
+
+		template <typename T>
+		decltype(auto) check_get(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+			auto handler = no_panic;
+			return check_get<T>(L, index, handler);
+		}
+
+		namespace stack_detail {
+
+			template <typename Handler>
+			bool check_types(lua_State*, int, Handler&&, record&) {
+				return true;
+			}
+
+			template <typename T, typename... Args, typename Handler>
+			bool check_types(lua_State* L, int firstargument, Handler&& handler, record& tracking) {
+				if (!stack::check<T>(L, firstargument + tracking.used, handler, tracking))
+					return false;
+				return check_types<Args...>(L, firstargument, std::forward<Handler>(handler), tracking);
+			}
+
+			template <typename... Args, typename Handler>
+			bool check_types(types<Args...>, lua_State* L, int index, Handler&& handler, record& tracking) {
+				return check_types<Args...>(L, index, std::forward<Handler>(handler), tracking);
+			}
+
+		} // namespace stack_detail
+
+		template <typename... Args, typename Handler>
+		bool multi_check(lua_State* L, int index, Handler&& handler, record& tracking) {
+			return stack_detail::check_types<Args...>(L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename... Args, typename Handler>
+		bool multi_check(lua_State* L, int index, Handler&& handler) {
+			record tracking {};
+			return multi_check<Args...>(L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename... Args>
+		bool multi_check(lua_State* L, int index) {
+			return multi_check<Args...>(L, index);
+		}
+
+		template <typename T>
+		auto unqualified_get(lua_State* L, int index, record& tracking) -> decltype(stack_detail::unchecked_unqualified_get<T>(L, index, tracking)) {
+#if SOL_IS_ON(SOL_SAFE_GETTER_I_)
+			static constexpr bool is_op = meta::is_optional_v<T>;
+			if constexpr (is_op) {
+				return stack_detail::unchecked_unqualified_get<T>(L, index, tracking);
+			}
+			else {
+				if (is_lua_reference<T>::value) {
+					return stack_detail::unchecked_unqualified_get<T>(L, index, tracking);
+				}
+				auto op = unqualified_check_get<T>(L, index, type_panic_c_str, tracking);
+				return *std::move(op);
+			}
+#else
+			return stack_detail::unchecked_unqualified_get<T>(L, index, tracking);
+#endif
+		}
+
+		template <typename T>
+		decltype(auto) unqualified_get(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+			record tracking {};
+			return unqualified_get<T>(L, index, tracking);
+		}
+
+		template <typename T>
+		auto get(lua_State* L, int index, record& tracking) -> decltype(stack_detail::unchecked_get<T>(L, index, tracking)) {
+#if SOL_IS_ON(SOL_SAFE_GETTER_I_)
+			static constexpr bool is_op = meta::is_optional_v<T>;
+			if constexpr (is_op) {
+				return stack_detail::unchecked_get<T>(L, index, tracking);
+			}
+			else {
+				if (is_lua_reference<T>::value) {
+					return stack_detail::unchecked_get<T>(L, index, tracking);
+				}
+				auto op = check_get<T>(L, index, type_panic_c_str, tracking);
+				return *std::move(op);
+			}
+#else
+			return stack_detail::unchecked_get<T>(L, index, tracking);
+#endif
+		}
+
+		template <typename T>
+		decltype(auto) get(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+			record tracking {};
+			return get<T>(L, index, tracking);
+		}
+
+		template <typename T>
+		decltype(auto) get_usertype(lua_State* L, int index, record& tracking) {
+			using UT = meta::conditional_t<std::is_pointer<T>::value, detail::as_pointer_tag<std::remove_pointer_t<T>>, detail::as_value_tag<T>>;
+			return get<UT>(L, index, tracking);
+		}
+
+		template <typename T>
+		decltype(auto) get_usertype(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+			record tracking {};
+			return get_usertype<T>(L, index, tracking);
+		}
+
+		template <typename T>
+		decltype(auto) pop(lua_State* L) {
+			return popper<meta::unqualified_t<T>> {}.pop(L);
+		}
+
+		template <bool global = false, bool raw = false, typename Key>
+		void get_field(lua_State* L, Key&& key) {
+			field_getter<meta::unqualified_t<Key>, global, raw> {}.get(L, std::forward<Key>(key));
+		}
+
+		template <bool global = false, bool raw = false, typename Key>
+		void get_field(lua_State* L, Key&& key, int tableindex) {
+			field_getter<meta::unqualified_t<Key>, global, raw> {}.get(L, std::forward<Key>(key), tableindex);
+		}
+
+		template <bool global = false, typename Key>
+		void raw_get_field(lua_State* L, Key&& key) {
+			get_field<global, true>(L, std::forward<Key>(key));
+		}
+
+		template <bool global = false, typename Key>
+		void raw_get_field(lua_State* L, Key&& key, int tableindex) {
+			get_field<global, true>(L, std::forward<Key>(key), tableindex);
+		}
+
+		template <bool global = false, bool raw = false, typename C = detail::non_lua_nil_t, typename Key>
+		probe probe_get_field(lua_State* L, Key&& key) {
+			return probe_field_getter<meta::unqualified_t<Key>, C, global, raw> {}.get(L, std::forward<Key>(key));
+		}
+
+		template <bool global = false, bool raw = false, typename C = detail::non_lua_nil_t, typename Key>
+		probe probe_get_field(lua_State* L, Key&& key, int tableindex) {
+			return probe_field_getter<meta::unqualified_t<Key>, C, global, raw> {}.get(L, std::forward<Key>(key), tableindex);
+		}
+
+		template <bool global = false, typename C = detail::non_lua_nil_t, typename Key>
+		probe probe_raw_get_field(lua_State* L, Key&& key) {
+			return probe_get_field<global, true, C>(L, std::forward<Key>(key));
+		}
+
+		template <bool global = false, typename C = detail::non_lua_nil_t, typename Key>
+		probe probe_raw_get_field(lua_State* L, Key&& key, int tableindex) {
+			return probe_get_field<global, true, C>(L, std::forward<Key>(key), tableindex);
+		}
+
+		template <bool global = false, bool raw = false, typename Key, typename Value>
+		void set_field(lua_State* L, Key&& key, Value&& value) {
+			field_setter<meta::unqualified_t<Key>, global, raw> {}.set(L, std::forward<Key>(key), std::forward<Value>(value));
+		}
+
+		template <bool global = false, bool raw = false, typename Key, typename Value>
+		void set_field(lua_State* L, Key&& key, Value&& value, int tableindex) {
+			field_setter<meta::unqualified_t<Key>, global, raw> {}.set(L, std::forward<Key>(key), std::forward<Value>(value), tableindex);
+		}
+
+		template <bool global = false, typename Key, typename Value>
+		void raw_set_field(lua_State* L, Key&& key, Value&& value) {
+			set_field<global, true>(L, std::forward<Key>(key), std::forward<Value>(value));
+		}
+
+		template <bool global = false, typename Key, typename Value>
+		void raw_set_field(lua_State* L, Key&& key, Value&& value, int tableindex) {
+			set_field<global, true>(L, std::forward<Key>(key), std::forward<Value>(value), tableindex);
+		}
+
+		template <typename T, typename F>
+		void modify_unique_usertype_as(const stack_reference& obj, F&& f) {
+			using u_traits = unique_usertype_traits<T>;
+			void* raw = lua_touserdata(obj.lua_state(), obj.stack_index());
+			void* ptr_memory = detail::align_usertype_pointer(raw);
+			void* uu_memory = detail::align_usertype_unique<T>(raw);
+			T& uu = *static_cast<T*>(uu_memory);
+			f(uu);
+			*static_cast<void**>(ptr_memory) = static_cast<void*>(u_traits::get(uu));
+		}
+
+		template <typename F>
+		void modify_unique_usertype(const stack_reference& obj, F&& f) {
+			using bt = meta::bind_traits<meta::unqualified_t<F>>;
+			using T = typename bt::template arg_at<0>;
+			using Tu = meta::unqualified_t<T>;
+			modify_unique_usertype_as<Tu>(obj, std::forward<F>(f));
+		}
+
+	} // namespace stack
+
+	namespace detail {
+
+		template <typename T>
+		lua_CFunction make_destructor(std::true_type) {
+			if constexpr (is_unique_usertype_v<T>) {
+				return &unique_destruct<T>;
+			}
+			else if constexpr (!std::is_pointer_v<T>) {
+				return &usertype_alloc_destruct<T>;
+			}
+			else {
+				return &cannot_destruct<T>;
+			}
+		}
+
+		template <typename T>
+		lua_CFunction make_destructor(std::false_type) {
+			return &cannot_destruct<T>;
+		}
+
+		template <typename T>
+		lua_CFunction make_destructor() {
+			return make_destructor<T>(std::is_destructible<T>());
+		}
+
+		struct no_comp {
+			template <typename A, typename B>
+			bool operator()(A&&, B&&) const {
+				return false;
+			}
+		};
+
+		template <typename T>
+		int is_check(lua_State* L) {
+			return stack::push(L, stack::check<T>(L, 1, &no_panic));
+		}
+
+		template <typename T>
+		int member_default_to_string(std::true_type, lua_State* L) {
+			decltype(auto) ts = stack::get<T>(L, 1).to_string();
+			return stack::push(L, std::forward<decltype(ts)>(ts));
+		}
+
+		template <typename T>
+		int member_default_to_string(std::false_type, lua_State* L) {
+			return luaL_error(L,
+			     "cannot perform to_string on '%s': no 'to_string' overload in namespace, 'to_string' member "
+			     "function, or operator<<(ostream&, ...) present",
+			     detail::demangle<T>().data());
+		}
+
+		template <typename T>
+		int adl_default_to_string(std::true_type, lua_State* L) {
+			using namespace std;
+			decltype(auto) ts = to_string(stack::get<T>(L, 1));
+			return stack::push(L, std::forward<decltype(ts)>(ts));
+		}
+
+		template <typename T>
+		int adl_default_to_string(std::false_type, lua_State* L) {
+			return member_default_to_string<T>(meta::supports_to_string_member<T>(), L);
+		}
+
+		template <typename T>
+		int oss_default_to_string(std::true_type, lua_State* L) {
+			std::ostringstream oss;
+			oss << stack::unqualified_get<T>(L, 1);
+			return stack::push(L, oss.str());
+		}
+
+		template <typename T>
+		int oss_default_to_string(std::false_type, lua_State* L) {
+			return adl_default_to_string<T>(meta::supports_adl_to_string<T>(), L);
+		}
+
+		template <typename T>
+		int default_to_string(lua_State* L) {
+			return oss_default_to_string<T>(meta::supports_op_left_shift<std::ostream, T>(), L);
+		}
+
+		template <typename T>
+		int default_size(lua_State* L) {
+			decltype(auto) self = stack::unqualified_get<T>(L, 1);
+			return stack::push(L, self.size());
+		}
+
+		template <typename T, typename Op>
+		int comparsion_operator_wrap(lua_State* L) {
+			if constexpr (std::is_void_v<T>) {
+				return stack::push(L, false);
+			}
+			else {
+				auto maybel = stack::unqualified_check_get<T>(L, 1);
+				if (!maybel) {
+					return stack::push(L, false);
+				}
+				auto mayber = stack::unqualified_check_get<T>(L, 2);
+				if (!mayber) {
+					return stack::push(L, false);
+				}
+				decltype(auto) l = *maybel;
+				decltype(auto) r = *mayber;
+				if constexpr (std::is_same_v<no_comp, Op>) {
+					std::equal_to<> op;
+					return stack::push(L, op(detail::ptr(l), detail::ptr(r)));
+				}
+				else {
+					if constexpr (std::is_same_v<std::equal_to<>, Op> // clang-format hack
+					     || std::is_same_v<std::less_equal<>, Op>     //
+					     || std::is_same_v<std::less_equal<>, Op>) {  //
+						if (detail::ptr(l) == detail::ptr(r)) {
+							return stack::push(L, true);
+						}
+					}
+					Op op;
+					return stack::push(L, op(detail::deref(l), detail::deref(r)));
+				}
+			}
+		}
+
+		template <typename T, typename IFx, typename Fx>
+		void insert_default_registrations(IFx&& ifx, Fx&& fx);
+
+		template <typename T, bool, bool>
+		struct get_is_primitive : is_lua_primitive<T> { };
+
+		template <typename T>
+		struct get_is_primitive<T, true, false>
+		: meta::neg<std::is_reference<decltype(sol_lua_get(types<T>(), nullptr, -1, std::declval<stack::record&>()))>> { };
+
+		template <typename T>
+		struct get_is_primitive<T, false, true>
+		: meta::neg<std::is_reference<decltype(sol_lua_get(types<meta::unqualified_t<T>>(), nullptr, -1, std::declval<stack::record&>()))>> { };
+
+		template <typename T>
+		struct get_is_primitive<T, true, true> : get_is_primitive<T, true, false> { };
+
+	} // namespace detail
+
+	template <typename T>
+	struct is_proxy_primitive
+	: detail::get_is_primitive<T, meta::meta_detail::is_adl_sol_lua_get_v<T>, meta::meta_detail::is_adl_sol_lua_get_v<meta::unqualified_t<T>>> { };
+
+} // namespace sol
+
+// end of sol/stack_core.hpp
+
+// beginning of sol/stack_check.hpp
+
+// beginning of sol/stack_check_unqualified.hpp
+
+#include <memory>
+#include <functional>
+#include <utility>
+#include <cmath>
+#include <optional>
+#if SOL_IS_ON(SOL_STD_VARIANT_I_)
+#include <variant>
+#endif // variant shenanigans
+
+namespace sol { namespace stack {
+	namespace stack_detail {
+		inline bool impl_check_metatable(lua_State* L, int index, const std::string& metakey, bool poptable) {
+			luaL_getmetatable(L, &metakey[0]);
+			const type expectedmetatabletype = static_cast<type>(lua_type(L, -1));
+			if (expectedmetatabletype != type::lua_nil) {
+				if (lua_rawequal(L, -1, index) == 1) {
+					lua_pop(L, 1 + static_cast<int>(poptable));
+					return true;
+				}
+			}
+			lua_pop(L, 1);
+			return false;
+		}
+
+		template <typename T, bool poptable = true>
+		inline bool check_metatable(lua_State* L, int index = -2) {
+			return impl_check_metatable(L, index, usertype_traits<T>::metatable(), poptable);
+		}
+
+		template <type expected, int (*check_func)(lua_State*, int)>
+		struct basic_check {
+			template <typename Handler>
+			static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
+				tracking.use(1);
+				bool success = check_func(L, index) == 1;
+				if (!success) {
+					// expected type, actual type
+					handler(L, index, expected, type_of(L, index), "");
+				}
+				return success;
+			}
+		};
+	} // namespace stack_detail
+
+	template <typename T, typename>
+	struct unqualified_interop_checker {
+		template <typename Handler>
+		static bool check(lua_State*, int, type, Handler&&, record&) {
+			return false;
+		}
+	};
+
+	template <typename T, typename>
+	struct qualified_interop_checker {
+		template <typename Handler>
+		static bool check(lua_State* L, int index, type index_type, Handler&& handler, record& tracking) {
+			return stack_detail::unqualified_interop_check<T>(L, index, index_type, std::forward<Handler>(handler), tracking);
+		}
+	};
+
+	template <typename T, type expected, typename>
+	struct unqualified_checker {
+		template <typename Handler>
+		static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
+			if constexpr (std::is_same_v<T, bool>) {
+				tracking.use(1);
+				bool success = lua_isboolean(L, index) == 1;
+				if (!success) {
+					// expected type, actual type
+					handler(L, index, expected, type_of(L, index), "");
+				}
+				return success;
+			}
+			else if constexpr (meta::any_same_v<T, char /* , char8_t*/, char16_t, char32_t>) {
+				return stack::check<std::basic_string<T>>(L, index, std::forward<Handler>(handler), tracking);
+			}
+			else if constexpr (std::is_integral_v<T> || std::is_same_v<T, lua_Integer>) {
+				tracking.use(1);
+#if SOL_LUA_VESION_I_ >= 503
+				// Lua 5.3 and greater checks for numeric precision
+#if SOL_IS_ON(SOL_STRINGS_ARE_NUMBERS_I_)
+				// imprecise, sloppy conversions
+				int isnum = 0;
+				lua_tointegerx(L, index, &isnum);
+				const bool success = isnum != 0;
+				if (!success) {
+					// expected type, actual type
+					handler(L, index, type::number, type_of(L, index), detail::not_a_number_or_number_string_integral);
+				}
+#elif SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS_I_)
+				// this check is precise, do not convert
+				if (lua_isinteger(L, index) == 1) {
+					return true;
+				}
+				const bool success = false;
+				if (!success) {
+					// expected type, actual type
+					handler(L, index, type::number, type_of(L, index), detail::not_a_number_integral);
+				}
+#else
+				// Numerics are neither safe nor string-convertible
+				type t = type_of(L, index);
+				const bool success = t == type::number;
+#endif
+				if (!success) {
+					// expected type, actual type
+					handler(L, index, type::number, type_of(L, index), detail::not_a_number);
+				}
+				return success;
+#else
+				// Lua 5.2 and below checks
+#if SOL_IS_OFF(SOL_STRINGS_ARE_NUMBERS_I_)
+				// must pre-check, because it will convert
+				type t = type_of(L, index);
+				if (t != type::number) {
+					// expected type, actual type
+					handler(L, index, type::number, t, detail::not_a_number);
+					return false;
+				}
+#endif // Do not allow strings to be numbers
+
+#if SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS_I_)
+				int isnum = 0;
+				const lua_Number v = lua_tonumberx(L, index, &isnum);
+				const bool success = isnum != 0 && static_cast<lua_Number>(llround(v)) == v;
+#else
+				const bool success = true;
+#endif // Safe numerics and number precision checking
+				if (!success) {
+					// Use defines to provide a better error message!
+#if SOL_IS_ON(SOL_STRINGS_ARE_NUMBERS_I_)
+					handler(L, index, type::number, type_of(L, index), detail::not_a_number_or_number_string);
+#elif SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS_I_)
+					handler(L, index, type::number, t, detail::not_a_number_or_number_string);
+#else
+					handler(L, index, type::number, t, detail::not_a_number);
+#endif
+				}
+				return success;
+#endif
+			}
+			else if constexpr (std::is_floating_point_v<T> || std::is_same_v<T, lua_Number>) {
+				tracking.use(1);
+#if SOL_IS_ON(SOL_STRINGS_ARE_NUMBERS_I_)
+				bool success = lua_isnumber(L, index) == 1;
+				if (!success) {
+					// expected type, actual type
+					handler(L, index, type::number, type_of(L, index), detail::not_a_number_or_number_string);
+				}
+				return success;
+#else
+				type t = type_of(L, index);
+				bool success = t == type::number;
+				if (!success) {
+					// expected type, actual type
+					handler(L, index, type::number, t, detail::not_a_number);
+				}
+				return success;
+#endif // Strings are Numbers
+			}
+			else if constexpr (meta::any_same_v<T, type, this_state, this_main_state, this_environment, variadic_args>) {
+				(void)L;
+				(void)index;
+				(void)handler;
+				tracking.use(0);
+				return true;
+			}
+			else if constexpr (is_unique_usertype_v<T>) {
+				using proper_T = typename unique_usertype_traits<T>::type;
+				const type indextype = type_of(L, index);
+				tracking.use(1);
+				if (indextype != type::userdata) {
+					handler(L, index, type::userdata, indextype, "value is not a userdata");
+					return false;
+				}
+				if (lua_getmetatable(L, index) == 0) {
+					return true;
+				}
+				int metatableindex = lua_gettop(L);
+				if (stack_detail::check_metatable<detail::unique_usertype<proper_T>>(L, metatableindex)) {
+					void* memory = lua_touserdata(L, index);
+					memory = detail::align_usertype_unique_destructor(memory);
+					detail::unique_destructor& pdx = *static_cast<detail::unique_destructor*>(memory);
+					bool success = &detail::usertype_unique_alloc_destroy<proper_T, T> == pdx;
+					if (!success) {
+						memory = detail::align_usertype_unique_tag<true>(memory);
+#if 0
+						// New version
+#else
+						const char*& name_tag = *static_cast<const char**>(memory);
+						success = usertype_traits<T>::qualified_name() == name_tag;
+#endif
+						if (!success) {
+							handler(L, index, type::userdata, indextype, "value is a userdata but is not the correct unique usertype");
+						}
+					}
+					return success;
+				}
+				lua_pop(L, 1);
+				handler(L, index, type::userdata, indextype, "unrecognized userdata (not pushed by sol?)");
+				return false;
+			}
+			else if constexpr (meta::any_same_v<T, lua_nil_t, std::nullopt_t, nullopt_t>) {
+				bool success = lua_isnil(L, index);
+				if (success) {
+					tracking.use(1);
+					return success;
+				}
+				tracking.use(0);
+				success = lua_isnone(L, index);
+				if (!success) {
+					// expected type, actual type
+					handler(L, index, expected, type_of(L, index), "");
+				}
+				return success;
+			}
+			else if constexpr (std::is_same_v<T, env_key_t>) {
+				tracking.use(1);
+				type t = type_of(L, index);
+				if (t == type::table || t == type::none || t == type::lua_nil || t == type::userdata) {
+					return true;
+				}
+				handler(L, index, type::table, t, "value cannot not have a valid environment");
+				return true;
+			}
+			else if constexpr (std::is_same_v<T, detail::non_lua_nil_t>) {
+				return !stack::unqualified_check<lua_nil_t>(L, index, std::forward<Handler>(handler), tracking);
+			}
+			else if constexpr (meta::is_specialization_of_v<T, basic_lua_table>) {
+				tracking.use(1);
+				type t = type_of(L, index);
+				if (t != type::table) {
+					handler(L, index, type::table, t, "value is not a table");
+					return false;
+				}
+				return true;
+			}
+			else if constexpr (meta::is_specialization_of_v<T, basic_bytecode>) {
+				tracking.use(1);
+				type t = type_of(L, index);
+				if (t != type::function) {
+					handler(L, index, type::function, t, "value is not a function that can be dumped");
+					return false;
+				}
+				return true;
+			}
+			else if constexpr (meta::is_specialization_of_v<T, basic_environment>) {
+				tracking.use(1);
+				if (lua_getmetatable(L, index) == 0) {
+					return true;
+				}
+				type t = type_of(L, -1);
+				if (t == type::table || t == type::none || t == type::lua_nil) {
+					lua_pop(L, 1);
+					return true;
+				}
+				if (t != type::userdata) {
+					lua_pop(L, 1);
+					handler(L, index, type::table, t, "value does not have a valid metatable");
+					return false;
+				}
+				return true;
+			}
+			else if constexpr (std::is_same_v<T, metatable_key_t>) {
+				tracking.use(1);
+				if (lua_getmetatable(L, index) == 0) {
+					return true;
+				}
+				type t = type_of(L, -1);
+				if (t == type::table || t == type::none || t == type::lua_nil) {
+					lua_pop(L, 1);
+					return true;
+				}
+				if (t != type::userdata) {
+					lua_pop(L, 1);
+					handler(L, index, expected, t, "value does not have a valid metatable");
+					return false;
+				}
+				return true;
+			}
+			else if constexpr (std::is_same_v<T, luaL_Stream*> || std::is_same_v<T, luaL_Stream>) {
+				if (lua_getmetatable(L, index) == 0) {
+					type t = type_of(L, index);
+					handler(L, index, expected, t, "value is not a valid luaL_Stream (has no metatable/is not a valid value)");
+					return false;
+				}
+				luaL_getmetatable(L, LUA_FILEHANDLE);
+				if (type_of(L, index) != type::table) {
+					type t = type_of(L, index);
+					lua_pop(L, 1);
+					handler(L,
+						index,
+						expected,
+						t,
+						"value is not a valid luaL_Stream (there is no metatable for luaL_Stream -- did you forget to "
+						"my_lua_state.open_libraries(sol::lib::state) or equivalent?)");
+					return false;
+				}
+				int is_stream_table = lua_compare(L, -1, -2, LUA_OPEQ);
+				lua_pop(L, 2);
+				if (is_stream_table == 0) {
+					type t = type_of(L, index);
+					handler(L, index, expected, t, "value is not a valid luaL_Stream (incorrect metatable)");
+					return false;
+				}
+				return true;
+			}
+			else if constexpr (meta::is_optional_v<T>) {
+				using ValueType = typename T::value_type;
+				(void)handler;
+				type t = type_of(L, index);
+				if (t == type::none) {
+					tracking.use(0);
+					return true;
+				}
+				if (t == type::lua_nil) {
+					tracking.use(1);
+					return true;
+				}
+				return stack::unqualified_check<ValueType>(L, index, no_panic, tracking);
+			}
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE_I_)
+			else if constexpr (std::is_function_v<T> || (std::is_pointer_v<T> && std::is_function_v<std::remove_pointer_t<T>>)) {
+				return stack_detail::check_function_pointer<std::remove_pointer_t<T>>(L, index, std::forward<Handler>(handler), tracking);
+			}
+#endif
+			else if constexpr (expected == type::userdata) {
+				if constexpr (meta::any_same_v<T, userdata_value> || meta::is_specialization_of_v<T, basic_userdata>) {
+					tracking.use(1);
+					type t = type_of(L, index);
+					bool success = t == type::userdata;
+					if (!success) {
+						// expected type, actual type
+						handler(L, index, type::userdata, t, "");
+					}
+					return success;
+				}
+				else if constexpr (meta::is_specialization_of_v<T, user>) {
+					unqualified_checker<lightuserdata_value, type::userdata> c;
+					(void)c;
+					return c.check(L, index, std::forward<Handler>(handler), tracking);
+				}
+				else {
+					if constexpr (std::is_pointer_v<T>) {
+						return check_usertype<T>(L, index, std::forward<Handler>(handler), tracking);
+					}
+					else if constexpr (meta::is_specialization_of_v<T, std::reference_wrapper>) {
+						using T_internal = typename T::type;
+						return stack::check<T_internal>(L, index, std::forward<Handler>(handler), tracking);
+					}
+					else {
+						return check_usertype<T>(L, index, std::forward<Handler>(handler), tracking);
+					}
+				}
+			}
+			else if constexpr (expected == type::poly) {
+				tracking.use(1);
+				bool success = is_lua_reference_v<T> || !lua_isnone(L, index);
+				if (!success) {
+					// expected type, actual type
+					handler(L, index, type::poly, type_of(L, index), "");
+				}
+				return success;
+			}
+			else if constexpr (expected == type::lightuserdata) {
+				tracking.use(1);
+				type t = type_of(L, index);
+				bool success = t == type::userdata || t == type::lightuserdata;
+				if (!success) {
+					// expected type, actual type
+					handler(L, index, type::lightuserdata, t, "");
+				}
+				return success;
+			}
+			else if constexpr (expected == type::function) {
+				if constexpr (meta::any_same_v<T, lua_CFunction, std::remove_pointer_t<lua_CFunction>, c_closure>) {
+					tracking.use(1);
+					bool success = lua_iscfunction(L, index) == 1;
+					if (!success) {
+						// expected type, actual type
+						handler(L, index, expected, type_of(L, index), "");
+					}
+					return success;
+				}
+				else {
+					tracking.use(1);
+					type t = type_of(L, index);
+					if (t == type::lua_nil || t == type::none || t == type::function) {
+						// allow for lua_nil to be returned
+						return true;
+					}
+					if (t != type::userdata && t != type::table) {
+						handler(L, index, type::function, t, "must be a function or table or a userdata");
+						return false;
+					}
+					// Do advanced check for call-style userdata?
+					static const auto& callkey = to_string(meta_function::call);
+					if (lua_getmetatable(L, index) == 0) {
+						// No metatable, no __call key possible
+						handler(L, index, type::function, t, "value is not a function and does not have overriden metatable");
+						return false;
+					}
+					if (lua_isnoneornil(L, -1)) {
+						lua_pop(L, 1);
+						handler(L, index, type::function, t, "value is not a function and does not have valid metatable");
+						return false;
+					}
+					lua_getfield(L, -1, &callkey[0]);
+					if (lua_isnoneornil(L, -1)) {
+						lua_pop(L, 2);
+						handler(L, index, type::function, t, "value's metatable does not have __call overridden in metatable, cannot call this type");
+						return false;
+					}
+					// has call, is definitely a function
+					lua_pop(L, 2);
+					return true;
+				}
+			}
+			else if constexpr (expected == type::table) {
+				tracking.use(1);
+				type t = type_of(L, index);
+				if (t == type::table) {
+					return true;
+				}
+				if (t != type::userdata) {
+					handler(L, index, type::table, t, "value is not a table or a userdata that can behave like one");
+					return false;
+				}
+				return true;
+			}
+			else {
+				tracking.use(1);
+				const type indextype = type_of(L, index);
+				bool success = expected == indextype;
+				if (!success) {
+					// expected type, actual type, message
+					handler(L, index, expected, indextype, "");
+				}
+				return success;
+			}
+		}
+	};
+
+	template <typename T>
+	struct unqualified_checker<non_null<T>, type::userdata> : unqualified_checker<T, lua_type_of_v<T>> { };
+
+	template <typename T>
+	struct unqualified_checker<detail::as_value_tag<T>, type::userdata> {
+		template <typename Handler>
+		static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
+			const type indextype = type_of(L, index);
+			return check(types<T>(), L, index, indextype, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename U, typename Handler>
+		static bool check(types<U>, lua_State* L, int index, type indextype, Handler&& handler, record& tracking) {
+			if constexpr (
+				std::is_same_v<T,
+				     lightuserdata_value> || std::is_same_v<T, userdata_value> || std::is_same_v<T, userdata> || std::is_same_v<T, lightuserdata>) {
+				tracking.use(1);
+				if (indextype != type::userdata) {
+					handler(L, index, type::userdata, indextype, "value is not a valid userdata");
+					return false;
+				}
+				return true;
+			}
+			else {
+#if SOL_IS_ON(SOL_USE_INTEROP_I_)
+				if (stack_detail::interop_check<U>(L, index, indextype, handler, tracking)) {
+					return true;
+				}
+#endif // interop extensibility
+				tracking.use(1);
+				if (indextype != type::userdata) {
+					handler(L, index, type::userdata, indextype, "value is not a valid userdata");
+					return false;
+				}
+				if (lua_getmetatable(L, index) == 0) {
+					return true;
+				}
+				int metatableindex = lua_gettop(L);
+				if (stack_detail::check_metatable<U>(L, metatableindex))
+					return true;
+				if (stack_detail::check_metatable<U*>(L, metatableindex))
+					return true;
+				if (stack_detail::check_metatable<detail::unique_usertype<U>>(L, metatableindex))
+					return true;
+				if (stack_detail::check_metatable<as_container_t<U>>(L, metatableindex))
+					return true;
+				bool success = false;
+				bool has_derived = derive<T>::value || weak_derive<T>::value;
+				if (has_derived) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+					luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+					auto pn = stack::pop_n(L, 1);
+					lua_pushstring(L, &detail::base_class_check_key()[0]);
+					lua_rawget(L, metatableindex);
+					if (type_of(L, -1) != type::lua_nil) {
+						void* basecastdata = lua_touserdata(L, -1);
+						detail::inheritance_check_function ic = reinterpret_cast<detail::inheritance_check_function>(basecastdata);
+						success = ic(usertype_traits<T>::qualified_name());
+					}
+				}
+				lua_pop(L, 1);
+				if (!success) {
+					handler(L, index, type::userdata, indextype, "value at this index does not properly reflect the desired type");
+					return false;
+				}
+				return true;
+			}
+		}
+	};
+
+	template <typename T>
+	struct unqualified_checker<detail::as_pointer_tag<T>, type::userdata> {
+		template <typename Handler>
+		static bool check(lua_State* L, int index, type indextype, Handler&& handler, record& tracking) {
+			if (indextype == type::lua_nil) {
+				tracking.use(1);
+				return true;
+			}
+			return check_usertype<std::remove_pointer_t<T>>(L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename Handler>
+		static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
+			const type indextype = type_of(L, index);
+			return check(L, index, indextype, std::forward<Handler>(handler), tracking);
+		}
+	};
+
+	template <typename... Args>
+	struct unqualified_checker<std::tuple<Args...>, type::poly> {
+		template <typename Handler>
+		static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
+			return stack::multi_check<Args...>(L, index, std::forward<Handler>(handler), tracking);
+		}
+	};
+
+	template <typename A, typename B>
+	struct unqualified_checker<std::pair<A, B>, type::poly> {
+		template <typename Handler>
+		static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
+			return stack::multi_check<A, B>(L, index, std::forward<Handler>(handler), tracking);
+		}
+	};
+
+#if SOL_IS_ON(SOL_STD_VARIANT_I_)
+
+	template <typename... Tn>
+	struct unqualified_checker<std::variant<Tn...>, type::poly> {
+		typedef std::variant<Tn...> V;
+		typedef std::variant_size<V> V_size;
+		typedef std::integral_constant<bool, V_size::value == 0> V_is_empty;
+
+		template <typename Handler>
+		static bool is_one(std::integral_constant<std::size_t, 0>, lua_State* L, int index, Handler&& handler, record& tracking) {
+			if constexpr (V_is_empty::value) {
+				if (lua_isnone(L, index)) {
+					return true;
+				}
+			}
+			tracking.use(1);
+			handler(L, index, type::poly, type_of(L, index), "value does not fit any type present in the variant");
+			return false;
+		}
+
+		template <std::size_t I, typename Handler>
+		static bool is_one(std::integral_constant<std::size_t, I>, lua_State* L, int index, Handler&& handler, record& tracking) {
+			typedef std::variant_alternative_t<I - 1, V> T;
+			record temp_tracking = tracking;
+			if (stack::check<T>(L, index, no_panic, temp_tracking)) {
+				tracking = temp_tracking;
+				return true;
+			}
+			return is_one(std::integral_constant<std::size_t, I - 1>(), L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename Handler>
+		static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
+			return is_one(std::integral_constant<std::size_t, V_size::value>(), L, index, std::forward<Handler>(handler), tracking);
+		}
+	};
+
+#endif // variant shenanigans
+
+}} // namespace sol::stack
+
+// end of sol/stack_check_unqualified.hpp
+
+// beginning of sol/stack_check_qualified.hpp
+
+namespace sol {
+namespace stack {
+
+	template <typename X, type expected, typename>
+	struct qualified_checker {
+		template <typename Handler>
+		static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
+			if constexpr (!std::is_reference_v<X> && is_unique_usertype_v<X>) {
+				using u_traits = unique_usertype_traits<meta::unqualified_t<X>>;
+				using T = typename u_traits::type;
+				if constexpr (is_base_rebindable_non_void_v<u_traits>) {
+					using rebind_t = typename u_traits::template rebind_base<void>;
+					// we have a unique pointer type that can be
+					// rebound to a base/derived type
+					const type indextype = type_of(L, index);
+					tracking.use(1);
+					if (indextype != type::userdata) {
+						handler(L, index, type::userdata, indextype, "value is not a userdata");
+						return false;
+					}
+					void* memory = lua_touserdata(L, index);
+					memory = detail::align_usertype_unique_destructor(memory);
+					detail::unique_destructor& pdx = *static_cast<detail::unique_destructor*>(memory);
+					if (&detail::usertype_unique_alloc_destroy<T, X> == pdx) {
+						return true;
+					}
+					if constexpr (derive<T>::value) {
+						memory = detail::align_usertype_unique_tag<true, false>(memory);
+						detail::unique_tag& ic = *reinterpret_cast<detail::unique_tag*>(memory);
+						string_view ti = usertype_traits<T>::qualified_name();
+						string_view rebind_ti = usertype_traits<rebind_t>::qualified_name();
+						if (ic(nullptr, nullptr, ti, rebind_ti) != 0) {
+							return true;
+						}
+					}
+					handler(L, index, type::userdata, indextype, "value is a userdata but is not the correct unique usertype");
+					return false;
+				}
+				else {
+					return stack::unqualified_check<X>(L, index, std::forward<Handler>(handler), tracking);
+				}
+			}
+			else if constexpr (!std::is_reference_v<X> && is_container_v<X>) {
+				if (type_of(L, index) == type::userdata) {
+					return stack::unqualified_check<X>(L, index, std::forward<Handler>(handler), tracking);
+				}
+				else {
+					return stack::unqualified_check<nested<X>>(L, index, std::forward<Handler>(handler), tracking);
+				}
+			}
+			else if constexpr (!std::is_reference_v<X> && meta::is_specialization_of_v<X, nested>) {
+				using NestedX = typename meta::unqualified_t<X>::nested_type;
+				return stack::check<NestedX>(L, index, ::std::forward<Handler>(handler), tracking);
+			}
+			else {
+				return stack::unqualified_check<X>(L, index, std::forward<Handler>(handler), tracking);
+			}
+		}
+	};
+}
+} // namespace sol::stack
+
+// end of sol/stack_check_qualified.hpp
+
+// end of sol/stack_check.hpp
+
+// beginning of sol/stack_get.hpp
+
+// beginning of sol/stack_get_unqualified.hpp
+
+// beginning of sol/overload.hpp
+
+#include <utility>
+
+namespace sol {
+	template <typename... Functions>
+	struct overload_set {
+		std::tuple<Functions...> functions;
+		template <typename Arg, typename... Args, meta::disable<std::is_same<overload_set, meta::unqualified_t<Arg>>> = meta::enabler>
+		overload_set(Arg&& arg, Args&&... args)
+		: functions(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+		overload_set(const overload_set&) = default;
+		overload_set(overload_set&&) = default;
+		overload_set& operator=(const overload_set&) = default;
+		overload_set& operator=(overload_set&&) = default;
+	};
+
+	template <typename... Args>
+	decltype(auto) overload(Args&&... args) {
+		return overload_set<std::decay_t<Args>...>(std::forward<Args>(args)...);
+	}
+} // namespace sol
+
+// end of sol/overload.hpp
+
+// beginning of sol/unicode.hpp
+
+#include <array>
+#include <cstring>
+
+namespace sol {
+	// Everything here was lifted pretty much straight out of
+	// ogonek, because fuck figuring it out=
+	namespace unicode {
+		enum class error_code {
+			ok = 0,
+			invalid_code_point,
+			invalid_code_unit,
+			invalid_leading_surrogate,
+			invalid_trailing_surrogate,
+			sequence_too_short,
+			overlong_sequence,
+		};
+
+		inline const string_view& to_string(error_code ec) {
+			static const string_view storage[7] = {
+				"ok",
+				"invalid code points",
+				"invalid code unit",
+				"invalid leading surrogate",
+				"invalid trailing surrogate",
+				"sequence too short",
+				"overlong sequence"
+			};
+			return storage[static_cast<std::size_t>(ec)];
+		}
+
+		template <typename It>
+		struct decoded_result {
+			error_code error;
+			char32_t codepoint;
+			It next;
+		};
+
+		template <typename C>
+		struct encoded_result {
+			error_code error;
+			std::size_t code_units_size;
+			std::array<C, 4> code_units;
+		};
+
+		struct unicode_detail {
+			// codepoint related
+			static constexpr char32_t last_code_point = 0x10FFFF;
+
+			static constexpr char32_t first_lead_surrogate = 0xD800;
+			static constexpr char32_t last_lead_surrogate = 0xDBFF;
+
+			static constexpr char32_t first_trail_surrogate = 0xDC00;
+			static constexpr char32_t last_trail_surrogate = 0xDFFF;
+
+			static constexpr char32_t first_surrogate = first_lead_surrogate;
+			static constexpr char32_t last_surrogate = last_trail_surrogate;
+
+			static constexpr bool is_lead_surrogate(char32_t u) {
+				return u >= first_lead_surrogate && u <= last_lead_surrogate;
+			}
+			static constexpr bool is_trail_surrogate(char32_t u) {
+				return u >= first_trail_surrogate && u <= last_trail_surrogate;
+			}
+			static constexpr bool is_surrogate(char32_t u) {
+				return u >= first_surrogate && u <= last_surrogate;
+			}
+
+			// utf8 related
+			static constexpr auto last_1byte_value = 0x7Fu;
+			static constexpr auto last_2byte_value = 0x7FFu;
+			static constexpr auto last_3byte_value = 0xFFFFu;
+
+			static constexpr auto start_2byte_mask = 0x80u;
+			static constexpr auto start_3byte_mask = 0xE0u;
+			static constexpr auto start_4byte_mask = 0xF0u;
+
+			static constexpr auto continuation_mask = 0xC0u;
+			static constexpr auto continuation_signature = 0x80u;
+
+			static constexpr bool is_invalid(unsigned char b) {
+				return b == 0xC0 || b == 0xC1 || b > 0xF4;
+			}
+
+			static constexpr bool is_continuation(unsigned char b) {
+				return (b & unicode_detail::continuation_mask) == unicode_detail::continuation_signature;
+			}
+
+			static constexpr bool is_overlong(char32_t u, std::size_t bytes) {
+				return u <= unicode_detail::last_1byte_value || (u <= unicode_detail::last_2byte_value && bytes > 2)
+				     || (u <= unicode_detail::last_3byte_value && bytes > 3);
+			}
+
+			static constexpr int sequence_length(unsigned char b) {
+				return (b & start_2byte_mask) == 0 ? 1
+					: (b & start_3byte_mask) != start_3byte_mask ? 2
+					: (b & start_4byte_mask) != start_4byte_mask ? 3
+					: 4;
+			}
+
+			static constexpr char32_t decode(unsigned char b0, unsigned char b1) {
+				return ((b0 & 0x1F) << 6) | (b1 & 0x3F);
+			}
+			static constexpr char32_t decode(unsigned char b0, unsigned char b1, unsigned char b2) {
+				return ((b0 & 0x0F) << 12) | ((b1 & 0x3F) << 6) | (b2 & 0x3F);
+			}
+			static constexpr char32_t decode(unsigned char b0, unsigned char b1, unsigned char b2, unsigned char b3) {
+				return ((b0 & 0x07) << 18) | ((b1 & 0x3F) << 12) | ((b2 & 0x3F) << 6) | (b3 & 0x3F);
+			}
+
+			// utf16 related
+			static constexpr char32_t last_bmp_value = 0xFFFF;
+			static constexpr char32_t normalizing_value = 0x10000;
+			static constexpr int lead_surrogate_bitmask = 0xFFC00;
+			static constexpr int trail_surrogate_bitmask = 0x3FF;
+			static constexpr int lead_shifted_bits = 10;
+			static constexpr char32_t replacement = 0xFFFD;
+
+			static char32_t combine_surrogates(char16_t lead, char16_t trail) {
+				auto hi = lead - first_lead_surrogate;
+				auto lo = trail - first_trail_surrogate;
+				return normalizing_value + ((hi << lead_shifted_bits) | lo);
+			}
+		};
+
+		inline encoded_result<char> code_point_to_utf8(char32_t codepoint) {
+			encoded_result<char> er;
+			er.error = error_code::ok;
+			if (codepoint <= unicode_detail::last_1byte_value) {
+				er.code_units_size = 1;
+				er.code_units = std::array<char, 4>{ { static_cast<char>(codepoint) } };
+			}
+			else if (codepoint <= unicode_detail::last_2byte_value) {
+				er.code_units_size = 2;
+				er.code_units = std::array<char, 4>{{
+					static_cast<char>(0xC0 | ((codepoint & 0x7C0) >> 6)),
+					static_cast<char>(0x80 | (codepoint & 0x3F)),
+				}};
+			}
+			else if (codepoint <= unicode_detail::last_3byte_value) {
+				er.code_units_size = 3;
+				er.code_units = std::array<char, 4>{{
+					static_cast<char>(0xE0 | ((codepoint & 0xF000) >> 12)),
+					static_cast<char>(0x80 | ((codepoint & 0xFC0) >> 6)),
+					static_cast<char>(0x80 | (codepoint & 0x3F)),
+				}};
+			}
+			else {
+				er.code_units_size = 4;
+				er.code_units = std::array<char, 4>{ {
+					static_cast<char>(0xF0 | ((codepoint & 0x1C0000) >> 18)),
+						static_cast<char>(0x80 | ((codepoint & 0x3F000) >> 12)),
+						static_cast<char>(0x80 | ((codepoint & 0xFC0) >> 6)),
+						static_cast<char>(0x80 | (codepoint & 0x3F)),
+				} };
+			}
+			return er;
+		}
+
+		inline encoded_result<char16_t> code_point_to_utf16(char32_t codepoint) {
+			encoded_result<char16_t> er;
+
+			if (codepoint <= unicode_detail::last_bmp_value) {
+				er.code_units_size = 1;
+				er.code_units = std::array<char16_t, 4>{ { static_cast<char16_t>(codepoint) } };
+				er.error = error_code::ok;
+			}
+			else {
+				auto normal = codepoint - unicode_detail::normalizing_value;
+				auto lead = unicode_detail::first_lead_surrogate + ((normal & unicode_detail::lead_surrogate_bitmask) >> unicode_detail::lead_shifted_bits);
+				auto trail = unicode_detail::first_trail_surrogate + (normal & unicode_detail::trail_surrogate_bitmask);
+				er.code_units = std::array<char16_t, 4>{ {
+					static_cast<char16_t>(lead),
+					static_cast<char16_t>(trail)
+				} };
+				er.code_units_size = 2;
+				er.error = error_code::ok;
+			}
+			return er;
+		}
+
+		inline encoded_result<char32_t> code_point_to_utf32(char32_t codepoint) {
+			encoded_result<char32_t> er;
+			er.code_units_size = 1;
+			er.code_units[0] = codepoint;
+			er.error = error_code::ok;
+			return er;
+		}
+
+		template <typename It>
+		inline decoded_result<It> utf8_to_code_point(It it, It last) {
+			decoded_result<It> dr;
+			if (it == last) {
+				dr.next = it;
+				dr.error = error_code::sequence_too_short;
+				return dr;
+			}
+
+			unsigned char b0 = *it;
+			std::size_t length = unicode_detail::sequence_length(b0);
+
+			if (length == 1) {
+				dr.codepoint = static_cast<char32_t>(b0);
+				dr.error = error_code::ok;
+				++it;
+				dr.next = it;
+				return dr;
+			}
+
+			if (unicode_detail::is_invalid(b0) || unicode_detail::is_continuation(b0)) {
+				dr.error = error_code::invalid_code_unit;
+				dr.next = it;
+				return dr;
+			}
+
+			++it;
+			std::array<unsigned char, 4> b;
+			b[0] = b0;
+			for (std::size_t i = 1; i < length; ++i) {
+				b[i] = *it;
+				if (!unicode_detail::is_continuation(b[i])) {
+					dr.error = error_code::invalid_code_unit;
+					dr.next = it;
+					return dr;
+				}
+				++it;
+			}
+
+			char32_t decoded;
+			switch (length) {
+			case 2:
+				decoded = unicode_detail::decode(b[0], b[1]);
+				break;
+			case 3:
+				decoded = unicode_detail::decode(b[0], b[1], b[2]);
+				break;
+			default:
+				decoded = unicode_detail::decode(b[0], b[1], b[2], b[3]);
+				break;
+			}
+
+			if (unicode_detail::is_overlong(decoded, length)) {
+				dr.error = error_code::overlong_sequence;
+				return dr;
+			}
+			if (unicode_detail::is_surrogate(decoded) || decoded > unicode_detail::last_code_point) {
+				dr.error = error_code::invalid_code_point;
+				return dr;
+			}
+			
+			// then everything is fine
+			dr.codepoint = decoded;
+			dr.error = error_code::ok;
+			dr.next = it;
+			return dr;
+		}
+
+		template <typename It>
+		inline decoded_result<It> utf16_to_code_point(It it, It last) {
+			decoded_result<It> dr;
+			if (it == last) {
+				dr.next = it;
+				dr.error = error_code::sequence_too_short;
+				return dr;
+			}
+
+			char16_t lead = static_cast<char16_t>(*it);
+			
+			if (!unicode_detail::is_surrogate(lead)) {
+				++it;
+				dr.codepoint = static_cast<char32_t>(lead);
+				dr.next = it;
+				dr.error = error_code::ok;
+				return dr;
+			}
+			if (!unicode_detail::is_lead_surrogate(lead)) {
+				dr.error = error_code::invalid_leading_surrogate;
+				dr.next = it;
+				return dr;
+			}
+
+			++it;
+			auto trail = *it;
+			if (!unicode_detail::is_trail_surrogate(trail)) {
+				dr.error = error_code::invalid_trailing_surrogate;
+				dr.next = it;
+				return dr;
+			}
+			
+			dr.codepoint = unicode_detail::combine_surrogates(lead, trail);
+			dr.next = ++it;
+			dr.error = error_code::ok;
+			return dr;
+		}
+
+		template <typename It>
+		inline decoded_result<It> utf32_to_code_point(It it, It last) {
+			decoded_result<It> dr;
+			if (it == last) {
+				dr.next = it;
+				dr.error = error_code::sequence_too_short;
+				return dr;
+			}
+			dr.codepoint = static_cast<char32_t>(*it);
+			dr.next = ++it;
+			dr.error = error_code::ok;
+			return dr;
+		}
+	}
+}
+// end of sol/unicode.hpp
+
+#include <memory>
+#include <functional>
+#include <utility>
+#include <cstdlib>
+#include <cmath>
+#include <string_view>
+#if SOL_IS_ON(SOL_STD_VARIANT_I_)
+#include <variant>
+#endif // Apple clang screwed up
+
+namespace sol { namespace stack {
+
+	namespace stack_detail {
+		template <typename Ch>
+		struct count_code_units_utf {
+			std::size_t needed_size;
+
+			count_code_units_utf() : needed_size(0) {
+			}
+
+			void operator()(const unicode::encoded_result<Ch> er) {
+				needed_size += er.code_units_size;
+			}
+		};
+
+		template <typename Ch, typename ErCh>
+		struct copy_code_units_utf {
+			Ch* target_;
+
+			copy_code_units_utf(Ch* target) : target_(target) {
+			}
+
+			void operator()(const unicode::encoded_result<ErCh> er) {
+				std::memcpy(target_, er.code_units.data(), er.code_units_size * sizeof(ErCh));
+				target_ += er.code_units_size;
+			}
+		};
+
+		template <typename Ch, typename F>
+		inline void convert(const char* strb, const char* stre, F&& f) {
+			char32_t cp = 0;
+			for (const char* strtarget = strb; strtarget < stre;) {
+				auto dr = unicode::utf8_to_code_point(strtarget, stre);
+				if (dr.error != unicode::error_code::ok) {
+					cp = unicode::unicode_detail::replacement;
+					++strtarget;
+				}
+				else {
+					cp = dr.codepoint;
+					strtarget = dr.next;
+				}
+				if constexpr (std::is_same_v<Ch, char32_t>) {
+					auto er = unicode::code_point_to_utf32(cp);
+					f(er);
+				}
+				else {
+					auto er = unicode::code_point_to_utf16(cp);
+					f(er);
+				}
+			}
+		}
+
+		template <typename BaseCh, typename S>
+		inline S get_into(lua_State* L, int index, record& tracking) {
+			using Ch = typename S::value_type;
+			tracking.use(1);
+			size_t len;
+			auto utf8p = lua_tolstring(L, index, &len);
+			if (len < 1)
+				return S();
+			const char* strb = utf8p;
+			const char* stre = utf8p + len;
+			stack_detail::count_code_units_utf<BaseCh> count_units;
+			convert<BaseCh>(strb, stre, count_units);
+			S r(count_units.needed_size, static_cast<Ch>(0));
+			r.resize(count_units.needed_size);
+			Ch* target = &r[0];
+			stack_detail::copy_code_units_utf<Ch, BaseCh> copy_units(target);
+			convert<BaseCh>(strb, stre, copy_units);
+			return r;
+		}
+	} // namespace stack_detail
+
+	template <typename T, typename>
+	struct unqualified_getter {
+		static decltype(auto) get(lua_State* L, int index, record& tracking) {
+			if constexpr (std::is_same_v<T, bool>) {
+				tracking.use(1);
+				return lua_toboolean(L, index) != 0;
+			}
+			else if constexpr (std::is_enum_v<T>) {
+				tracking.use(1);
+				return static_cast<T>(lua_tointegerx(L, index, nullptr));
+			}
+			else if constexpr (std::is_integral_v<T> || std::is_same_v<T, lua_Integer>) {
+				tracking.use(1);
+#if SOL_LUA_VESION_I_ >= 503
+				if (lua_isinteger(L, index) != 0) {
+					return static_cast<T>(lua_tointeger(L, index));
+				}
+#endif
+				return static_cast<T>(llround(lua_tonumber(L, index)));
+			}
+			else if constexpr (std::is_floating_point_v<T> || std::is_same_v<T, lua_Number>) {
+				tracking.use(1);
+				return static_cast<T>(lua_tonumber(L, index));
+			}
+			else if constexpr (is_lua_reference_v<T>) {
+				tracking.use(1);
+				return T(L, index);
+			}
+			else if constexpr (is_unique_usertype_v<T>) {
+				using Real = typename unique_usertype_traits<T>::actual_type;
+
+				tracking.use(1);
+				void* memory = lua_touserdata(L, index);
+				memory = detail::align_usertype_unique<Real>(memory);
+				Real* mem = static_cast<Real*>(memory);
+				return *mem;
+			}
+			else if constexpr (meta::is_optional_v<T>) {
+				using ValueType = typename T::value_type;
+				return unqualified_check_getter<ValueType>::template get_using<T>(L, index, no_panic, tracking);
+			}
+			else if constexpr (std::is_same_v<T, luaL_Stream*>) {
+				luaL_Stream* pstream = static_cast<luaL_Stream*>(lua_touserdata(L, index));
+				return pstream;
+			}
+			else if constexpr (std::is_same_v<T, luaL_Stream>) {
+				luaL_Stream* pstream = static_cast<luaL_Stream*>(lua_touserdata(L, index));
+				return *pstream;
+			}
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE_I_)
+			else if constexpr (std::is_function_v<T> || (std::is_pointer_v<T> && std::is_function_v<std::remove_pointer_t<T>>)) {
+				return stack_detail::get_function_pointer<std::remove_pointer_t<T>>(L, index, tracking);
+			}
+#endif
+			else {
+				return stack_detail::unchecked_unqualified_get<detail::as_value_tag<T>>(L, index, tracking);
+			}
+		}
+	};
+
+	template <typename X, typename>
+	struct qualified_getter {
+		static decltype(auto) get(lua_State* L, int index, record& tracking) {
+			using Tu = meta::unqualified_t<X>;
+			static constexpr bool is_userdata_of_some_kind
+				= !std::is_reference_v<
+				       X> && is_container_v<Tu> && std::is_default_constructible_v<Tu> && !is_lua_primitive_v<Tu> && !is_transparent_argument_v<Tu>;
+			if constexpr (is_userdata_of_some_kind) {
+				if (type_of(L, index) == type::userdata) {
+					return static_cast<Tu>(stack_detail::unchecked_unqualified_get<Tu>(L, index, tracking));
+				}
+				else {
+					return stack_detail::unchecked_unqualified_get<sol::nested<Tu>>(L, index, tracking);
+				}
+			}
+			else if constexpr (!std::is_reference_v<X> && is_unique_usertype_v<Tu> && !is_base_rebindable_non_void_v<unique_usertype_traits<Tu>>) {
+				using u_traits = unique_usertype_traits<Tu>;
+				using T = typename u_traits::type;
+				using Real = typename u_traits::actual_type;
+				tracking.use(1);
+				void* memory = lua_touserdata(L, index);
+				memory = detail::align_usertype_unique_destructor(memory);
+				detail::unique_destructor& pdx = *static_cast<detail::unique_destructor*>(memory);
+				if (&detail::usertype_unique_alloc_destroy<T, X> == pdx) {
+					memory = detail::align_usertype_unique_tag<true, false>(memory);
+					memory = detail::align_usertype_unique<Real, true, false>(memory);
+					Real* mem = static_cast<Real*>(memory);
+					return static_cast<Real>(*mem);
+				}
+				Real r(nullptr);
+				if constexpr (!derive<T>::value) {
+					// TODO: abort / terminate, maybe only in debug modes?
+					return static_cast<Real>(std::move(r));
+				}
+				else {
+					memory = detail::align_usertype_unique_tag<true, false>(memory);
+					detail::unique_tag& ic = *reinterpret_cast<detail::unique_tag*>(memory);
+					memory = detail::align_usertype_unique<Real, true, false>(memory);
+					string_view ti = usertype_traits<T>::qualified_name();
+					int cast_operation;
+					if constexpr (is_base_rebindable_v<u_traits>) {
+						using rebind_t = typename u_traits::template rebind_base<void>;
+						string_view rebind_ti = usertype_traits<rebind_t>::qualified_name();
+						cast_operation = ic(memory, &r, ti, rebind_ti);
+					}
+					else {
+						string_view rebind_ti("");
+						cast_operation = ic(memory, &r, ti, rebind_ti);
+					}
+					switch (cast_operation) {
+					case 1: {
+						// it's a perfect match,
+						// alias memory directly
+						Real* mem = static_cast<Real*>(memory);
+						return static_cast<Real>(*mem);
+					}
+					case 2:
+						// it's a base match, return the
+						// aliased creation
+						return static_cast<Real>(std::move(r));
+					default:
+						// uh oh..
+						break;
+					}
+					// TODO: abort / terminate, maybe only in debug modes?
+					return static_cast<Real>(r);
+				}
+			}
+			else {
+				return stack_detail::unchecked_unqualified_get<Tu>(L, index, tracking);
+			}
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<as_table_t<T>> {
+		using Tu = meta::unqualified_t<T>;
+
+		template <typename V>
+		static void push_back_at_end(std::true_type, types<V>, lua_State* L, T& cont, std::size_t) {
+			cont.push_back(stack::get<V>(L, -lua_size<V>::value));
+		}
+
+		template <typename V>
+		static void push_back_at_end(std::false_type, types<V> t, lua_State* L, T& cont, std::size_t idx) {
+			insert_at_end(meta::has_insert<Tu>(), t, L, cont, idx);
+		}
+
+		template <typename V>
+		static void insert_at_end(std::true_type, types<V>, lua_State* L, T& cont, std::size_t) {
+			using std::cend;
+			cont.insert(cend(cont), stack::get<V>(L, -lua_size<V>::value));
+		}
+
+		template <typename V>
+		static void insert_at_end(std::false_type, types<V>, lua_State* L, T& cont, std::size_t idx) {
+			cont[idx] = stack::get<V>(L, -lua_size<V>::value);
+		}
+
+		static bool max_size_check(std::false_type, T&, std::size_t) {
+			return false;
+		}
+
+		static bool max_size_check(std::true_type, T& cont, std::size_t idx) {
+			return idx >= cont.max_size();
+		}
+
+		static T get(lua_State* L, int relindex, record& tracking) {
+			return get(meta::is_associative<Tu>(), L, relindex, tracking);
+		}
+
+		static T get(std::false_type, lua_State* L, int relindex, record& tracking) {
+			typedef typename Tu::value_type V;
+			return get(types<V>(), L, relindex, tracking);
+		}
+
+		template <typename V>
+		static T get(types<V> t, lua_State* L, int relindex, record& tracking) {
+			tracking.use(1);
+
+			// the W4 flag is really great,
+			// so great that it can tell my for loops (twice nested)
+			// below never actually terminate
+			// without hitting where the gotos have infested
+
+			// so now I would get the error W4XXX unreachable
+			// me that the return cont at the end of this function
+			// which is fair until other compilers complain
+			// that there isn't a return and that based on
+			// SOME MAGICAL FORCE
+			// control flow falls off the end of a non-void function
+			// so it needs to be there for the compilers that are
+			// too flimsy to analyze the basic blocks...
+			// (I'm sure I should file a bug but those compilers are already
+			// in the wild; it doesn't matter if I fix them,
+			// someone else is still going to get some old-ass compiler
+			// and then bother me about the unclean build for the 30th
+			// time)
+
+			// "Why not an IIFE?"
+			// Because additional lambdas / functions which serve as
+			// capture-all-and-then-invoke bloat binary sizes
+			// by an actually detectable amount
+			// (one user uses sol2 pretty heavily and 22 MB of binary size
+			// was saved by reducing reliance on lambdas in templates)
+
+			// This would really be solved by having break N;
+			// be a real, proper thing...
+			// but instead, we have to use labels and gotos
+			// and earn the universal vitriol of the dogmatic
+			// programming community
+
+			// all in all: W4 is great!~
+
+			int index = lua_absindex(L, relindex);
+			T cont;
+			std::size_t idx = 0;
+#if SOL_LUA_VESION_I_ >= 503
+			// This method is HIGHLY performant over regular table iteration
+			// thanks to the Lua API changes in 5.3
+			// Questionable in 5.4
+			for (lua_Integer i = 0;; i += lua_size<V>::value) {
+				if (max_size_check(meta::has_max_size<Tu>(), cont, idx)) {
+					// see above comment
+					goto done;
+				}
+				bool isnil = false;
+				for (int vi = 0; vi < lua_size<V>::value; ++vi) {
+#if defined(LUA_NILINTABLE) && LUA_NILINTABLE && SOL_LUA_VESION_I_ >= 600
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+					luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+					lua_pushinteger(L, static_cast<lua_Integer>(i + vi));
+					if (lua_keyin(L, index) == 0) {
+						// it's time to stop
+						isnil = true;
+					}
+					else {
+						// we have a key, have to get the value
+						lua_geti(L, index, i + vi);
+					}
+#else
+					type vt = static_cast<type>(lua_geti(L, index, i + vi));
+					isnil = vt == type::none || vt == type::lua_nil;
+#endif
+					if (isnil) {
+						if (i == 0) {
+							break;
+						}
+#if defined(LUA_NILINTABLE) && LUA_NILINTABLE && SOL_LUA_VESION_I_ >= 600
+						lua_pop(L, vi);
+#else
+						lua_pop(L, (vi + 1));
+#endif
+						// see above comment
+						goto done;
+					}
+				}
+				if (isnil) {
+#if defined(LUA_NILINTABLE) && LUA_NILINTABLE && SOL_LUA_VESION_I_ >= 600
+#else
+					lua_pop(L, lua_size<V>::value);
+#endif
+					continue;
+				}
+
+				push_back_at_end(meta::has_push_back<Tu>(), t, L, cont, idx);
+				++idx;
+				lua_pop(L, lua_size<V>::value);
+			}
+#else
+			// Zzzz slower but necessary thanks to the lower version API and missing functions qq
+			for (lua_Integer i = 0;; i += lua_size<V>::value, lua_pop(L, lua_size<V>::value)) {
+				if (idx >= cont.max_size()) {
+					// see above comment
+					goto done;
+				}
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+				luaL_checkstack(L, 2, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+				bool isnil = false;
+				for (int vi = 0; vi < lua_size<V>::value; ++vi) {
+					lua_pushinteger(L, i);
+					lua_gettable(L, index);
+					type vt = type_of(L, -1);
+					isnil = vt == type::lua_nil;
+					if (isnil) {
+						if (i == 0) {
+							break;
+						}
+						lua_pop(L, (vi + 1));
+						// see above comment
+						goto done;
+					}
+				}
+				if (isnil)
+					continue;
+				push_back_at_end(meta::has_push_back<Tu>(), t, L, cont, idx);
+				++idx;
+			}
+#endif
+		done:
+			return cont;
+		}
+
+		static T get(std::true_type, lua_State* L, int index, record& tracking) {
+			typedef typename Tu::value_type P;
+			typedef typename P::first_type K;
+			typedef typename P::second_type V;
+			return get(types<K, V>(), L, index, tracking);
+		}
+
+		template <typename K, typename V>
+		static T get(types<K, V>, lua_State* L, int relindex, record& tracking) {
+			tracking.use(1);
+
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 3, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+
+			T associative;
+			int index = lua_absindex(L, relindex);
+			lua_pushnil(L);
+			while (lua_next(L, index) != 0) {
+				decltype(auto) key = stack::check_get<K>(L, -2);
+				if (!key) {
+					lua_pop(L, 1);
+					continue;
+				}
+				associative.emplace(std::forward<decltype(*key)>(*key), stack::get<V>(L, -1));
+				lua_pop(L, 1);
+			}
+			return associative;
+		}
+	};
+
+	template <typename T, typename Al>
+	struct unqualified_getter<as_table_t<std::forward_list<T, Al>>> {
+		typedef std::forward_list<T, Al> C;
+
+		static C get(lua_State* L, int relindex, record& tracking) {
+			return get(meta::has_key_value_pair<C>(), L, relindex, tracking);
+		}
+
+		static C get(std::true_type, lua_State* L, int index, record& tracking) {
+			typedef typename T::value_type P;
+			typedef typename P::first_type K;
+			typedef typename P::second_type V;
+			return get(types<K, V>(), L, index, tracking);
+		}
+
+		static C get(std::false_type, lua_State* L, int relindex, record& tracking) {
+			typedef typename C::value_type V;
+			return get(types<V>(), L, relindex, tracking);
+		}
+
+		template <typename V>
+		static C get(types<V>, lua_State* L, int relindex, record& tracking) {
+			tracking.use(1);
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 3, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+
+			int index = lua_absindex(L, relindex);
+			C cont;
+			auto at = cont.cbefore_begin();
+			std::size_t idx = 0;
+#if SOL_LUA_VESION_I_ >= 503
+			// This method is HIGHLY performant over regular table iteration thanks to the Lua API changes in 5.3
+			for (lua_Integer i = 0;; i += lua_size<V>::value, lua_pop(L, lua_size<V>::value)) {
+				if (idx >= cont.max_size()) {
+					goto done;
+				}
+				bool isnil = false;
+				for (int vi = 0; vi < lua_size<V>::value; ++vi) {
+					type t = static_cast<type>(lua_geti(L, index, i + vi));
+					isnil = t == type::lua_nil;
+					if (isnil) {
+						if (i == 0) {
+							break;
+						}
+						lua_pop(L, (vi + 1));
+						goto done;
+					}
+				}
+				if (isnil)
+					continue;
+				at = cont.insert_after(at, stack::get<V>(L, -lua_size<V>::value));
+				++idx;
+			}
+#else
+			// Zzzz slower but necessary thanks to the lower version API and missing functions qq
+			for (lua_Integer i = 0;; i += lua_size<V>::value, lua_pop(L, lua_size<V>::value)) {
+				if (idx >= cont.max_size()) {
+					goto done;
+				}
+				bool isnil = false;
+				for (int vi = 0; vi < lua_size<V>::value; ++vi) {
+					lua_pushinteger(L, i);
+					lua_gettable(L, index);
+					type t = type_of(L, -1);
+					isnil = t == type::lua_nil;
+					if (isnil) {
+						if (i == 0) {
+							break;
+						}
+						lua_pop(L, (vi + 1));
+						goto done;
+					}
+				}
+				if (isnil)
+					continue;
+				at = cont.insert_after(at, stack::get<V>(L, -lua_size<V>::value));
+				++idx;
+			}
+#endif
+		done:
+			return cont;
+		}
+
+		template <typename K, typename V>
+		static C get(types<K, V>, lua_State* L, int relindex, record& tracking) {
+			tracking.use(1);
+
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 3, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+
+			C associative;
+			auto at = associative.cbefore_begin();
+			int index = lua_absindex(L, relindex);
+			lua_pushnil(L);
+			while (lua_next(L, index) != 0) {
+				decltype(auto) key = stack::check_get<K>(L, -2);
+				if (!key) {
+					lua_pop(L, 1);
+					continue;
+				}
+				at = associative.emplace_after(at, std::forward<decltype(*key)>(*key), stack::get<V>(L, -1));
+				lua_pop(L, 1);
+			}
+			return associative;
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<nested<T>> {
+		static T get(lua_State* L, int index, record& tracking) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (is_container_v<Tu>) {
+				if constexpr (meta::is_associative<Tu>::value) {
+					typedef typename T::value_type P;
+					typedef typename P::first_type K;
+					typedef typename P::second_type V;
+					unqualified_getter<as_table_t<T>> g;
+					// VC++ has a bad warning here: shut it up
+					(void)g;
+					return g.get(types<K, nested<V>>(), L, index, tracking);
+				}
+				else {
+					typedef typename T::value_type V;
+					unqualified_getter<as_table_t<T>> g;
+					// VC++ has a bad warning here: shut it up
+					(void)g;
+					return g.get(types<nested<V>>(), L, index, tracking);
+				}
+			}
+			else {
+				unqualified_getter<Tu> g;
+				// VC++ has a bad warning here: shut it up
+				(void)g;
+				return g.get(L, index, tracking);
+			}
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<as_container_t<T>> {
+		static decltype(auto) get(lua_State* L, int index, record& tracking) {
+			return stack::unqualified_get<T>(L, index, tracking);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<as_container_t<T>*> {
+		static decltype(auto) get(lua_State* L, int index, record& tracking) {
+			return stack::unqualified_get<T*>(L, index, tracking);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<userdata_value> {
+		static userdata_value get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			return userdata_value(lua_touserdata(L, index));
+		}
+	};
+
+	template <>
+	struct unqualified_getter<lightuserdata_value> {
+		static lightuserdata_value get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			return lightuserdata_value(lua_touserdata(L, index));
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<light<T>> {
+		static light<T> get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			void* memory = lua_touserdata(L, index);
+			return light<T>(static_cast<T*>(memory));
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<user<T>> {
+		static std::add_lvalue_reference_t<T> get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			void* memory = lua_touserdata(L, index);
+			memory = detail::align_user<T>(memory);
+			return *static_cast<std::remove_reference_t<T>*>(memory);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<user<T*>> {
+		static T* get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			void* memory = lua_touserdata(L, index);
+			memory = detail::align_user<T*>(memory);
+			return static_cast<T*>(memory);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<type> {
+		static type get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			return static_cast<type>(lua_type(L, index));
+		}
+	};
+
+	template <>
+	struct unqualified_getter<std::string> {
+		static std::string get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			std::size_t len;
+			auto str = lua_tolstring(L, index, &len);
+			return std::string(str, len);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<const char*> {
+		static const char* get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			size_t sz;
+			return lua_tolstring(L, index, &sz);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<char> {
+		static char get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			size_t len;
+			auto str = lua_tolstring(L, index, &len);
+			return len > 0 ? str[0] : '\0';
+		}
+	};
+
+	template <typename Traits>
+	struct unqualified_getter<basic_string_view<char, Traits>> {
+		static string_view get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			size_t sz;
+			const char* str = lua_tolstring(L, index, &sz);
+			return basic_string_view<char, Traits>(str, sz);
+		}
+	};
+
+	template <typename Traits, typename Al>
+	struct unqualified_getter<std::basic_string<wchar_t, Traits, Al>> {
+		using S = std::basic_string<wchar_t, Traits, Al>;
+		static S get(lua_State* L, int index, record& tracking) {
+			using Ch = meta::conditional_t<sizeof(wchar_t) == 2, char16_t, char32_t>;
+			return stack_detail::get_into<Ch, S>(L, index, tracking);
+		}
+	};
+
+	template <typename Traits, typename Al>
+	struct unqualified_getter<std::basic_string<char16_t, Traits, Al>> {
+		static std::basic_string<char16_t, Traits, Al> get(lua_State* L, int index, record& tracking) {
+			return stack_detail::get_into<char16_t, std::basic_string<char16_t, Traits, Al>>(L, index, tracking);
+		}
+	};
+
+	template <typename Traits, typename Al>
+	struct unqualified_getter<std::basic_string<char32_t, Traits, Al>> {
+		static std::basic_string<char32_t, Traits, Al> get(lua_State* L, int index, record& tracking) {
+			return stack_detail::get_into<char32_t, std::basic_string<char32_t, Traits, Al>>(L, index, tracking);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<char16_t> {
+		static char16_t get(lua_State* L, int index, record& tracking) {
+			string_view utf8 = stack::get<string_view>(L, index, tracking);
+			const char* strb = utf8.data();
+			const char* stre = utf8.data() + utf8.size();
+			char32_t cp = 0;
+			auto dr = unicode::utf8_to_code_point(strb, stre);
+			if (dr.error != unicode::error_code::ok) {
+				cp = unicode::unicode_detail::replacement;
+			}
+			else {
+				cp = dr.codepoint;
+			}
+			auto er = unicode::code_point_to_utf16(cp);
+			return er.code_units[0];
+		}
+	};
+
+	template <>
+	struct unqualified_getter<char32_t> {
+		static char32_t get(lua_State* L, int index, record& tracking) {
+			string_view utf8 = stack::get<string_view>(L, index, tracking);
+			const char* strb = utf8.data();
+			const char* stre = utf8.data() + utf8.size();
+			char32_t cp = 0;
+			auto dr = unicode::utf8_to_code_point(strb, stre);
+			if (dr.error != unicode::error_code::ok) {
+				cp = unicode::unicode_detail::replacement;
+			}
+			else {
+				cp = dr.codepoint;
+			}
+			auto er = unicode::code_point_to_utf32(cp);
+			return er.code_units[0];
+		}
+	};
+
+	template <>
+	struct unqualified_getter<wchar_t> {
+		static wchar_t get(lua_State* L, int index, record& tracking) {
+			typedef meta::conditional_t<sizeof(wchar_t) == 2, char16_t, char32_t> Ch;
+			unqualified_getter<Ch> g;
+			(void)g;
+			auto c = g.get(L, index, tracking);
+			return static_cast<wchar_t>(c);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<meta_function> {
+		static meta_function get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			const char* name = unqualified_getter<const char*> {}.get(L, index, tracking);
+			const auto& mfnames = meta_function_names();
+			for (std::size_t i = 0; i < mfnames.size(); ++i)
+				if (mfnames[i] == name)
+					return static_cast<meta_function>(i);
+			return meta_function::construct;
+		}
+	};
+
+	template <>
+	struct unqualified_getter<lua_nil_t> {
+		static lua_nil_t get(lua_State*, int, record& tracking) {
+			tracking.use(1);
+			return lua_nil;
+		}
+	};
+
+	template <>
+	struct unqualified_getter<std::nullptr_t> {
+		static std::nullptr_t get(lua_State*, int, record& tracking) {
+			tracking.use(1);
+			return nullptr;
+		}
+	};
+
+	template <>
+	struct unqualified_getter<nullopt_t> {
+		static nullopt_t get(lua_State*, int, record& tracking) {
+			tracking.use(1);
+			return nullopt;
+		}
+	};
+
+	template <>
+	struct unqualified_getter<this_state> {
+		static this_state get(lua_State* L, int, record& tracking) {
+			tracking.use(0);
+			return this_state(L);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<this_main_state> {
+		static this_main_state get(lua_State* L, int, record& tracking) {
+			tracking.use(0);
+			return this_main_state(main_thread(L, L));
+		}
+	};
+
+	template <>
+	struct unqualified_getter<lua_CFunction> {
+		static lua_CFunction get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			return lua_tocfunction(L, index);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<c_closure> {
+		static c_closure get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			return c_closure(lua_tocfunction(L, index), -1);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<error> {
+		static error get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			size_t sz = 0;
+			const char* err = lua_tolstring(L, index, &sz);
+			if (err == nullptr) {
+				return error(detail::direct_error, "");
+			}
+			return error(detail::direct_error, std::string(err, sz));
+		}
+	};
+
+	template <>
+	struct unqualified_getter<void*> {
+		static void* get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			return lua_touserdata(L, index);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<const void*> {
+		static const void* get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			return lua_touserdata(L, index);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<detail::as_value_tag<T>> {
+		static T* get_no_lua_nil(lua_State* L, int index, record& tracking) {
+			void* memory = lua_touserdata(L, index);
+#if SOL_IS_ON(SOL_USE_INTEROP_I_)
+			auto ugr = stack_detail::interop_get<T>(L, index, memory, tracking);
+			if (ugr.first) {
+				return ugr.second;
+			}
+#endif // interop extensibility
+			tracking.use(1);
+			void* rawdata = detail::align_usertype_pointer(memory);
+			void** pudata = static_cast<void**>(rawdata);
+			void* udata = *pudata;
+			return get_no_lua_nil_from(L, udata, index, tracking);
+		}
+
+		static T* get_no_lua_nil_from(lua_State* L, void* udata, int index, record&) {
+			bool has_derived = derive<T>::value || weak_derive<T>::value;
+			if (has_derived) {
+				if (lua_getmetatable(L, index) == 1) {
+					lua_getfield(L, -1, &detail::base_class_cast_key()[0]);
+					if (type_of(L, -1) != type::lua_nil) {
+						void* basecastdata = lua_touserdata(L, -1);
+						detail::inheritance_cast_function ic = reinterpret_cast<detail::inheritance_cast_function>(basecastdata);
+						// use the casting function to properly adjust the pointer for the desired T
+						udata = ic(udata, usertype_traits<T>::qualified_name());
+					}
+					lua_pop(L, 2);
+				}
+			}
+			T* obj = static_cast<T*>(udata);
+			return obj;
+		}
+
+		static T& get(lua_State* L, int index, record& tracking) {
+			return *get_no_lua_nil(L, index, tracking);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<detail::as_pointer_tag<T>> {
+		static T* get(lua_State* L, int index, record& tracking) {
+			type t = type_of(L, index);
+			if (t == type::lua_nil) {
+				tracking.use(1);
+				return nullptr;
+			}
+			unqualified_getter<detail::as_value_tag<T>> g;
+			// Avoid VC++ warning
+			(void)g;
+			return g.get_no_lua_nil(L, index, tracking);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<non_null<T*>> {
+		static T* get(lua_State* L, int index, record& tracking) {
+			unqualified_getter<detail::as_value_tag<T>> g;
+			// Avoid VC++ warning
+			(void)g;
+			return g.get_no_lua_nil(L, index, tracking);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<T&> {
+		static T& get(lua_State* L, int index, record& tracking) {
+			unqualified_getter<detail::as_value_tag<T>> g;
+			// Avoid VC++ warning
+			(void)g;
+			return g.get(L, index, tracking);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<std::reference_wrapper<T>> {
+		static T& get(lua_State* L, int index, record& tracking) {
+			unqualified_getter<T&> g;
+			// Avoid VC++ warning
+			(void)g;
+			return g.get(L, index, tracking);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<T*> {
+		static T* get(lua_State* L, int index, record& tracking) {
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE_I_)
+			if constexpr (std::is_function_v<T>) {
+				return stack_detail::get_function_pointer<T>(L, index, tracking);
+			}
+			else {
+				unqualified_getter<detail::as_pointer_tag<T>> g;
+				// Avoid VC++ warning
+				(void)g;
+				return g.get(L, index, tracking);
+			}
+#else
+			unqualified_getter<detail::as_pointer_tag<T>> g;
+			// Avoid VC++ warning
+			(void)g;
+			return g.get(L, index, tracking);
+#endif
+		}
+	};
+
+	template <typename... Tn>
+	struct unqualified_getter<std::tuple<Tn...>> {
+		typedef std::tuple<decltype(stack::get<Tn>(nullptr, 0))...> R;
+
+		template <typename... Args>
+		static R apply(std::index_sequence<>, lua_State*, int, record&, Args&&... args) {
+			// Fuck you too, VC++
+			return R { std::forward<Args>(args)... };
+		}
+
+		template <std::size_t I, std::size_t... Ix, typename... Args>
+		static R apply(std::index_sequence<I, Ix...>, lua_State* L, int index, record& tracking, Args&&... args) {
+			// Fuck you too, VC++
+			typedef std::tuple_element_t<I, std::tuple<Tn...>> T;
+			return apply(std::index_sequence<Ix...>(), L, index, tracking, std::forward<Args>(args)..., stack::get<T>(L, index + tracking.used, tracking));
+		}
+
+		static R get(lua_State* L, int index, record& tracking) {
+			return apply(std::make_index_sequence<sizeof...(Tn)>(), L, index, tracking);
+		}
+	};
+
+	template <typename A, typename B>
+	struct unqualified_getter<std::pair<A, B>> {
+		static decltype(auto) get(lua_State* L, int index, record& tracking) {
+			return std::pair<decltype(stack::get<A>(L, index)), decltype(stack::get<B>(L, index))> { stack::get<A>(L, index, tracking),
+				stack::get<B>(L, index + tracking.used, tracking) };
+		}
+	};
+
+#if SOL_IS_ON(SOL_STD_VARIANT_I_)
+
+	template <typename... Tn>
+	struct unqualified_getter<std::variant<Tn...>> {
+		using V = std::variant<Tn...>;
+
+		static V get_one(std::integral_constant<std::size_t, std::variant_size_v<V>>, lua_State* L, int index, record& tracking) {
+			(void)L;
+			(void)index;
+			(void)tracking;
+			if constexpr (std::variant_size_v<V> == 0) {
+				return V();
+			}
+			else {
+				// using T = std::variant_alternative_t<0, V>;
+				std::abort();
+				// return V(std::in_place_index<0>, stack::get<T>(L, index, tracking));
+			}
+		}
+
+		template <std::size_t I>
+		static V get_one(std::integral_constant<std::size_t, I>, lua_State* L, int index, record& tracking) {
+			typedef std::variant_alternative_t<I, V> T;
+			record temp_tracking = tracking;
+			if (stack::check<T>(L, index, no_panic, temp_tracking)) {
+				tracking = temp_tracking;
+				return V(std::in_place_index<I>, stack::get<T>(L, index));
+			}
+			return get_one(std::integral_constant<std::size_t, I + 1>(), L, index, tracking);
+		}
+
+		static V get(lua_State* L, int index, record& tracking) {
+			return get_one(std::integral_constant<std::size_t, 0>(), L, index, tracking);
+		}
+	};
+#endif // variant
+
+}} // namespace sol::stack
+
+// end of sol/stack_get_unqualified.hpp
+
+// beginning of sol/stack_get_qualified.hpp
+
+namespace sol {
+namespace stack {
+
+	// There are no more enable_ifs that can be used here,
+	// so this is just for posterity, I guess?
+	// maybe I'll fill this file in later.
+
+}
+} // namespace sol::stack
+
+// end of sol/stack_get_qualified.hpp
+
+// end of sol/stack_get.hpp
+
+// beginning of sol/stack_check_get.hpp
+
+// beginning of sol/stack_check_get_unqualified.hpp
+
+#include <cstdlib>
+#include <cmath>
+#include <optional>
+#if SOL_IS_ON(SOL_STD_VARIANT_I_)
+#include <variant>
+#endif // variant shenanigans (thanks, Mac OSX)
+
+namespace sol { namespace stack {
+	template <typename T, typename>
+	struct unqualified_check_getter {
+		typedef decltype(stack_detail::unchecked_unqualified_get<T>(nullptr, -1, std::declval<record&>())) R;
+
+		template <typename Optional, typename Handler>
+		static Optional get_using(lua_State* L, int index, Handler&& handler, record& tracking) {
+			if constexpr (!meta::meta_detail::is_adl_sol_lua_check_v<T> && !meta::meta_detail::is_adl_sol_lua_get_v<T>) {
+				if constexpr (is_lua_reference_v<T>) {
+					// actually check if it's none here, otherwise
+					// we'll have a none object inside an optional!
+					bool success = lua_isnoneornil(L, index) == 0 && stack::check<T>(L, index, no_panic);
+					if (!success) {
+						// expected type, actual type
+						tracking.use(static_cast<int>(success));
+						handler(L, index, type::poly, type_of(L, index), "");
+						return detail::associated_nullopt_v<Optional>;
+					}
+					return stack_detail::unchecked_get<T>(L, index, tracking);
+				}
+				else if constexpr ((std::is_integral_v<T> || std::is_same_v<T, lua_Integer>)&&!std::is_same_v<T, bool>) {
+#if SOL_LUA_VESION_I_ >= 503
+					if (lua_isinteger(L, index) != 0) {
+						tracking.use(1);
+						return static_cast<T>(lua_tointeger(L, index));
+					}
+#endif
+					int isnum = 0;
+					const lua_Number value = lua_tonumberx(L, index, &isnum);
+					if (isnum != 0) {
+#if SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS_I_)
+						const auto integer_value = llround(value);
+						if (static_cast<lua_Number>(integer_value) == value) {
+							tracking.use(1);
+							return static_cast<T>(integer_value);
+						}
+#else
+						tracking.use(1);
+						return static_cast<T>(value);
+#endif
+					}
+					const type t = type_of(L, index);
+					tracking.use(static_cast<int>(t != type::none));
+					handler(L, index, type::number, t, "not an integer");
+					return detail::associated_nullopt_v<Optional>;
+				}
+				else if constexpr (std::is_floating_point_v<T> || std::is_same_v<T, lua_Number>) {
+					int isnum = 0;
+					lua_Number value = lua_tonumberx(L, index, &isnum);
+					if (isnum == 0) {
+						type t = type_of(L, index);
+						tracking.use(static_cast<int>(t != type::none));
+						handler(L, index, type::number, t, "not a valid floating point number");
+						return detail::associated_nullopt_v<Optional>;
+					}
+					tracking.use(1);
+					return static_cast<T>(value);
+				}
+				else if constexpr (std::is_enum_v<T> && !meta::any_same_v<T, meta_function, type>) {
+					int isnum = 0;
+					lua_Integer value = lua_tointegerx(L, index, &isnum);
+					if (isnum == 0) {
+						type t = type_of(L, index);
+						tracking.use(static_cast<int>(t != type::none));
+						handler(L, index, type::number, t, "not a valid enumeration value");
+						return detail::associated_nullopt_v<Optional>;
+					}
+					tracking.use(1);
+					return static_cast<T>(value);
+				}
+				else {
+					if (!unqualified_check<T>(L, index, std::forward<Handler>(handler))) {
+						tracking.use(static_cast<int>(!lua_isnone(L, index)));
+						return detail::associated_nullopt_v<Optional>;
+					}
+					return stack_detail::unchecked_unqualified_get<T>(L, index, tracking);
+				}
+			}
+			else {
+				if (!unqualified_check<T>(L, index, std::forward<Handler>(handler))) {
+					tracking.use(static_cast<int>(!lua_isnone(L, index)));
+					return detail::associated_nullopt_v<Optional>;
+				}
+				return stack_detail::unchecked_unqualified_get<T>(L, index, tracking);
+			}
+		}
+
+		template <typename Handler>
+		static optional<R> get(lua_State* L, int index, Handler&& handler, record& tracking) {
+			return get_using<optional<R>>(L, index, std::forward<Handler>(handler), tracking);
+		}
+	};
+
+#if SOL_IS_ON(SOL_STD_VARIANT_I_)
+	template <typename... Tn, typename C>
+	struct unqualified_check_getter<std::variant<Tn...>, C> {
+		typedef std::variant<Tn...> V;
+		typedef std::variant_size<V> V_size;
+		typedef std::integral_constant<bool, V_size::value == 0> V_is_empty;
+
+		template <typename Handler>
+		static optional<V> get_empty(std::true_type, lua_State*, int, Handler&&, record&) {
+			return nullopt;
+		}
+
+		template <typename Handler>
+		static optional<V> get_empty(std::false_type, lua_State* L, int index, Handler&& handler, record&) {
+			// This should never be reached...
+			// please check your code and understand what you did to bring yourself here
+			// maybe file a bug report, or 5
+			handler(
+				L, index, type::poly, type_of(L, index), "this variant code should never be reached: if it has, you have done something so terribly wrong");
+			return nullopt;
+		}
+
+		template <typename Handler>
+		static optional<V> get_one(std::integral_constant<std::size_t, 0>, lua_State* L, int index, Handler&& handler, record& tracking) {
+			return get_empty(V_is_empty(), L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <std::size_t I, typename Handler>
+		static optional<V> get_one(std::integral_constant<std::size_t, I>, lua_State* L, int index, Handler&& handler, record& tracking) {
+			typedef std::variant_alternative_t<I - 1, V> T;
+			if (stack::check<T>(L, index, no_panic, tracking)) {
+				return V(std::in_place_index<I - 1>, stack::get<T>(L, index));
+			}
+			return get_one(std::integral_constant<std::size_t, I - 1>(), L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename Handler>
+		static optional<V> get(lua_State* L, int index, Handler&& handler, record& tracking) {
+			return get_one(std::integral_constant<std::size_t, V_size::value>(), L, index, std::forward<Handler>(handler), tracking);
+		}
+	};
+#endif // standard variant
+}}     // namespace sol::stack
+
+// end of sol/stack_check_get_unqualified.hpp
+
+// beginning of sol/stack_check_get_qualified.hpp
+
+namespace sol { namespace stack {
+	template <typename T, typename C>
+	struct qualified_check_getter {
+		typedef decltype(stack_detail::unchecked_get<T>(nullptr, -1, std::declval<record&>())) R;
+
+		template <typename Handler>
+		static optional<R> get(lua_State* L, int index, Handler&& handler, record& tracking) {
+			if constexpr (is_lua_reference_v<T>) {
+				// actually check if it's none here, otherwise
+				// we'll have a none object inside an optional!
+				bool success = lua_isnoneornil(L, index) == 0 && stack::check<T>(L, index, no_panic);
+				if (!success) {
+					// expected type, actual type
+					tracking.use(static_cast<int>(success));
+					handler(L, index, type::poly, type_of(L, index), "");
+					return nullopt;
+				}
+				return stack_detail::unchecked_get<T>(L, index, tracking);
+			}
+			else {
+				if (!check<T>(L, index, std::forward<Handler>(handler))) {
+					tracking.use(static_cast<int>(!lua_isnone(L, index)));
+					return nullopt;
+				}
+				return stack_detail::unchecked_get<T>(L, index, tracking);
+			}
+		}
+	};
+
+	template <typename T>
+	struct qualified_getter<T, std::enable_if_t<meta::is_optional_v<T>>> {
+		static T get(lua_State* L, int index, record& tracking) {
+			using ValueType = typename meta::unqualified_t<T>::value_type;
+			if constexpr (is_lua_reference_v<ValueType>) {
+				// actually check if it's none here, otherwise
+				// we'll have a none object inside an optional!
+				bool success = lua_isnoneornil(L, index) == 0 && stack::check<ValueType>(L, index, no_panic);
+				if (!success) {
+					// expected type, actual type
+					tracking.use(static_cast<int>(success));
+					return {};
+				}
+				return stack_detail::unchecked_get<ValueType>(L, index, tracking);
+			}
+			else {
+				if (!check<ValueType>(L, index, &no_panic)) {
+					tracking.use(static_cast<int>(!lua_isnone(L, index)));
+					return {};
+				}
+				return stack_detail::unchecked_get<ValueType>(L, index, tracking);
+			}
+		}
+	};
+
+}} // namespace sol::stack
+
+// end of sol/stack_check_get_qualified.hpp
+
+// end of sol/stack_check_get.hpp
+
+// beginning of sol/stack_push.hpp
+
+#include <memory>
+#include <type_traits>
+#include <cassert>
+#include <limits>
+#include <cmath>
+#include <string_view>
+#if SOL_IS_ON(SOL_STD_VARIANT_I_)
+#include <variant>
+#endif // Can use variant
+
+namespace sol { namespace stack {
+	namespace stack_detail {
+		template <typename T>
+		inline bool integer_value_fits(const T& value) {
+			if constexpr (sizeof(T) < sizeof(lua_Integer) || (std::is_signed_v<T> && sizeof(T) == sizeof(lua_Integer))) {
+				(void)value;
+				return true;
+			}
+			else {
+				auto u_min = static_cast<std::intmax_t>((std::numeric_limits<lua_Integer>::min)());
+				auto u_max = static_cast<std::uintmax_t>((std::numeric_limits<lua_Integer>::max)());
+				auto t_min = static_cast<std::intmax_t>((std::numeric_limits<T>::min)());
+				auto t_max = static_cast<std::uintmax_t>((std::numeric_limits<T>::max)());
+				return (u_min <= t_min || value >= static_cast<T>(u_min)) && (u_max >= t_max || value <= static_cast<T>(u_max));
+			}
+		}
+
+		template <typename T>
+		int msvc_is_ass_with_if_constexpr_push_enum(std::true_type, lua_State* L, const T& value) {
+			if constexpr (meta::any_same_v<std::underlying_type_t<T>, char /*, char8_t*/, char16_t, char32_t>) {
+				if constexpr (std::is_signed_v<T>) {
+					return stack::push(L, static_cast<std::int_least32_t>(value));
+				}
+				else {
+					return stack::push(L, static_cast<std::uint_least32_t>(value));
+				}
+			}
+			else {
+				return stack::push(L, static_cast<std::underlying_type_t<T>>(value));
+			}
+		}
+
+		template <typename T>
+		int msvc_is_ass_with_if_constexpr_push_enum(std::false_type, lua_State*, const T&) {
+			return 0;
+		}
+	} // namespace stack_detail
+
+	inline int push_environment_of(lua_State* L, int index = -1) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+		luaL_checkstack(L, 1, detail::not_enough_stack_space_environment);
+#endif // make sure stack doesn't overflow
+#if SOL_LUA_VESION_I_ < 502
+		// Use lua_getfenv
+		lua_getfenv(L, index);
+#else
+		// Use upvalues as explained in Lua 5.2 and beyond's manual
+		if (lua_getupvalue(L, index, 1) == nullptr) {
+			push(L, lua_nil);
+			return 1;
+		}
+#endif
+		return 1;
+	}
+
+	template <typename T>
+	int push_environment_of(const T& target) {
+		target.push();
+		return push_environment_of(target.lua_state(), -1) + 1;
+	}
+
+	template <typename T>
+	struct unqualified_pusher<detail::as_value_tag<T>> {
+		template <typename F, typename... Args>
+		static int push_fx(lua_State* L, F&& f, Args&&... args) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
+#endif // make sure stack doesn't overflow
+       // Basically, we store all user-data like this:
+       // If it's a movable/copyable value (no std::ref(x)), then we store the pointer to the new
+       // data in the first sizeof(T*) bytes, and then however many bytes it takes to
+       // do the actual object. Things that are std::ref or plain T* are stored as
+       // just the sizeof(T*), and nothing else.
+			T* obj = detail::usertype_allocate<T>(L);
+			f();
+			std::allocator<T> alloc {};
+			std::allocator_traits<std::allocator<T>>::construct(alloc, obj, std::forward<Args>(args)...);
+			return 1;
+		}
+
+		template <typename K, typename... Args>
+		static int push_keyed(lua_State* L, K&& k, Args&&... args) {
+			stack_detail::undefined_metatable fx(L, &k[0], &stack::stack_detail::set_undefined_methods_on<T>);
+			return push_fx(L, fx, std::forward<Args>(args)...);
+		}
+
+		template <typename Arg, typename... Args>
+		static int push(lua_State* L, Arg&& arg, Args&&... args) {
+			if constexpr (std::is_same_v<meta::unqualified_t<Arg>, detail::with_function_tag>) {
+				(void)arg;
+				return push_fx(L, std::forward<Args>(args)...);
+			}
+			else {
+				return push_keyed(L, usertype_traits<T>::metatable(), std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+		}
+
+		static int push(lua_State* L) {
+			return push_keyed(L, usertype_traits<T>::metatable());
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<detail::as_pointer_tag<T>> {
+		typedef meta::unqualified_t<T> U;
+
+		template <typename F>
+		static int push_fx(lua_State* L, F&& f, T* obj) {
+			if (obj == nullptr)
+				return stack::push(L, lua_nil);
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
+#endif // make sure stack doesn't overflow
+			T** pref = detail::usertype_allocate_pointer<T>(L);
+			f();
+			*pref = obj;
+			return 1;
+		}
+
+		template <typename K>
+		static int push_keyed(lua_State* L, K&& k, T* obj) {
+			stack_detail::undefined_metatable fx(L, &k[0], &stack::stack_detail::set_undefined_methods_on<U*>);
+			return push_fx(L, fx, obj);
+		}
+
+		template <typename Arg, typename... Args>
+		static int push(lua_State* L, Arg&& arg, Args&&... args) {
+			if constexpr (std::is_same_v<meta::unqualified_t<Arg>, detail::with_function_tag>) {
+				(void)arg;
+				return push_fx(L, std::forward<Args>(args)...);
+			}
+			else {
+				return push_keyed(L, usertype_traits<U*>::metatable(), std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<detail::as_reference_tag> {
+		template <typename T>
+		static int push(lua_State* L, T&& obj) {
+			return stack::push(L, detail::ptr(obj));
+		}
+	};
+
+	namespace stack_detail {
+		template <typename T>
+		struct uu_pusher {
+			using u_traits = unique_usertype_traits<T>;
+			using P = typename u_traits::type;
+			using Real = typename u_traits::actual_type;
+
+			template <typename Arg, typename... Args>
+			static int push(lua_State* L, Arg&& arg, Args&&... args) {
+				if constexpr (std::is_base_of_v<Real, meta::unqualified_t<Arg>>) {
+					if (u_traits::is_null(arg)) {
+						return stack::push(L, lua_nil);
+					}
+					return push_deep(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+				}
+				else {
+					return push_deep(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+				}
+			}
+
+			template <typename... Args>
+			static int push_deep(lua_State* L, Args&&... args) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
+#endif // make sure stack doesn't overflow
+				P** pref = nullptr;
+				detail::unique_destructor* fx = nullptr;
+				detail::unique_tag* id = nullptr;
+				Real* mem = detail::usertype_unique_allocate<P, Real>(L, pref, fx, id);
+				if (luaL_newmetatable(L, &usertype_traits<detail::unique_usertype<std::remove_cv_t<P>>>::metatable()[0]) == 1) {
+					detail::lua_reg_table l {};
+					int index = 0;
+					detail::indexed_insert insert_fx(l, index);
+					detail::insert_default_registrations<P>(insert_fx, detail::property_always_true);
+					l[index] = { to_string(meta_function::garbage_collect).c_str(), detail::make_destructor<T>() };
+					luaL_setfuncs(L, l, 0);
+				}
+				lua_setmetatable(L, -2);
+				*fx = detail::usertype_unique_alloc_destroy<P, Real>;
+				*id = &detail::inheritance<P>::template type_unique_cast<Real>;
+				detail::default_construct::construct(mem, std::forward<Args>(args)...);
+				*pref = unique_usertype_traits<T>::get(*mem);
+				return 1;
+			}
+		};
+	} // namespace stack_detail
+
+	template <typename T>
+	struct unqualified_pusher<detail::as_unique_tag<T>> {
+		template <typename... Args>
+		static int push(lua_State* L, Args&&... args) {
+			stack_detail::uu_pusher<T> p;
+			(void)p;
+			return p.push(L, std::forward<Args>(args)...);
+		}
+	};
+
+	template <typename T, typename>
+	struct unqualified_pusher {
+		template <typename... Args>
+		static int push(lua_State* L, Args&&... args) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (is_lua_reference_v<Tu>) {
+				using int_arr = int[];
+				int_arr p { (std::forward<Args>(args).push(L))... };
+				return p[0];
+			}
+			else if constexpr (std::is_same_v<Tu, bool>) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+				lua_pushboolean(L, std::forward<Args>(args)...);
+				return 1;
+			}
+			else if constexpr (std::is_integral_v<Tu> || std::is_same_v<Tu, lua_Integer>) {
+				const Tu& value(std::forward<Args>(args)...);
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_integral);
+#endif // make sure stack doesn't overflow
+#if SOL_LUA_VESION_I_ >= 503
+				if (stack_detail::integer_value_fits<Tu>(value)) {
+					lua_pushinteger(L, static_cast<lua_Integer>(value));
+					return 1;
+				}
+#endif // Lua 5.3 and above
+#if SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS_I_)
+				if (static_cast<T>(llround(static_cast<lua_Number>(value))) != value) {
+#if SOL_IS_OFF(SOL_EXCEPTIONS_I_)
+					// Is this really worth it?
+					assert(false && "integer value will be misrepresented in lua");
+					lua_pushinteger(L, static_cast<lua_Integer>(value));
+					return 1;
+#else
+					throw error(detail::direct_error, "integer value will be misrepresented in lua");
+#endif // No Exceptions
+				}
+#endif // Safe Numerics and Number Precision Check
+				lua_pushnumber(L, static_cast<lua_Number>(value));
+				return 1;
+			}
+			else if constexpr (std::is_floating_point_v<Tu> || std::is_same_v<Tu, lua_Number>) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_floating);
+#endif // make sure stack doesn't overflow
+				lua_pushnumber(L, std::forward<Args>(args)...);
+				return 1;
+			}
+			else if constexpr (std::is_same_v<Tu, luaL_Stream*>) {
+				luaL_Stream* source { std::forward<Args>(args)... };
+				luaL_Stream* stream = static_cast<luaL_Stream*>(lua_newuserdata(L, sizeof(luaL_Stream)));
+				stream->f = source->f;
+#if SOL_IS_ON(SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_)
+				stream->closef = source->closef;
+#endif // LuaJIT and Lua 5.1 and below do not have
+				return 1;
+			}
+			else if constexpr (std::is_same_v<Tu, luaL_Stream>) {
+				luaL_Stream& source(std::forward<Args>(args)...);
+				luaL_Stream* stream = static_cast<luaL_Stream*>(lua_newuserdata(L, sizeof(luaL_Stream)));
+				stream->f = source.f;
+#if SOL_IS_ON(SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_)
+				stream->closef = source.closef;
+#endif // LuaJIT and Lua 5.1 and below do not have
+				return 1;
+			}
+			else if constexpr (std::is_enum_v<Tu>) {
+				return stack_detail::msvc_is_ass_with_if_constexpr_push_enum(std::true_type(), L, std::forward<Args>(args)...);
+			}
+			else if constexpr (std::is_pointer_v<Tu>) {
+				return stack::push<detail::as_pointer_tag<std::remove_pointer_t<T>>>(L, std::forward<Args>(args)...);
+			}
+			else if constexpr (is_unique_usertype_v<Tu>) {
+				return stack::push<detail::as_unique_tag<T>>(L, std::forward<Args>(args)...);
+			}
+			else {
+				return stack::push<detail::as_value_tag<T>>(L, std::forward<Args>(args)...);
+			}
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<std::reference_wrapper<T>> {
+		static int push(lua_State* L, const std::reference_wrapper<T>& t) {
+			return stack::push(L, std::addressof(detail::deref(t.get())));
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<detail::as_table_tag<T>> {
+		using has_kvp = meta::has_key_value_pair<meta::unqualified_t<std::remove_pointer_t<T>>>;
+
+		static int push(lua_State* L, const T& tablecont) {
+			return push(has_kvp(), std::false_type(), L, tablecont);
+		}
+
+		static int push(lua_State* L, const T& tablecont, nested_tag_t) {
+			return push(has_kvp(), std::true_type(), L, tablecont);
+		}
+
+		static int push(std::true_type, lua_State* L, const T& tablecont) {
+			return push(has_kvp(), std::true_type(), L, tablecont);
+		}
+
+		static int push(std::false_type, lua_State* L, const T& tablecont) {
+			return push(has_kvp(), std::false_type(), L, tablecont);
+		}
+
+		template <bool is_nested>
+		static int push(std::true_type, std::integral_constant<bool, is_nested>, lua_State* L, const T& tablecont) {
+			auto& cont = detail::deref(detail::unwrap(tablecont));
+			lua_createtable(L, static_cast<int>(cont.size()), 0);
+			int tableindex = lua_gettop(L);
+			for (const auto& pair : cont) {
+				if (is_nested) {
+					set_field(L, pair.first, as_nested_ref(pair.second), tableindex);
+				}
+				else {
+					set_field(L, pair.first, pair.second, tableindex);
+				}
+			}
+			return 1;
+		}
+
+		template <bool is_nested>
+		static int push(std::false_type, std::integral_constant<bool, is_nested>, lua_State* L, const T& tablecont) {
+			auto& cont = detail::deref(detail::unwrap(tablecont));
+			lua_createtable(L, stack_detail::get_size_hint(cont), 0);
+			int tableindex = lua_gettop(L);
+			std::size_t index = 1;
+			for (const auto& i : cont) {
+#if SOL_LUA_VESION_I_ >= 503
+				int p = is_nested ? stack::push(L, as_nested_ref(i)) : stack::push(L, i);
+				for (int pi = 0; pi < p; ++pi) {
+					lua_seti(L, tableindex, static_cast<lua_Integer>(index++));
+				}
+#else
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+				lua_pushinteger(L, static_cast<lua_Integer>(index));
+				int p = is_nested ? stack::push(L, as_nested_ref(i)) : stack::push(L, i);
+				if (p == 1) {
+					++index;
+					lua_settable(L, tableindex);
+				}
+				else {
+					int firstindex = tableindex + 1 + 1;
+					for (int pi = 0; pi < p; ++pi) {
+						stack::push(L, index);
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+						luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+						lua_pushvalue(L, firstindex);
+						lua_settable(L, tableindex);
+						++index;
+						++firstindex;
+					}
+					lua_pop(L, 1 + p);
+				}
+#endif // Lua Version 5.3 and others
+			}
+			// TODO: figure out a better way to do this...?
+			// set_field(L, -1, cont.size());
+			return 1;
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<as_table_t<T>> {
+		static int push(lua_State* L, const T& v) {
+			using inner_t = std::remove_pointer_t<meta::unwrap_unqualified_t<T>>;
+			if constexpr (is_container_v<inner_t>) {
+				return stack::push<detail::as_table_tag<T>>(L, v);
+			}
+			else {
+				return stack::push(L, v);
+			}
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<nested<T>> {
+		static int push(lua_State* L, const T& tablecont) {
+			using Tu = meta::unwrap_unqualified_t<T>;
+			using inner_t = std::remove_pointer_t<Tu>;
+			if constexpr (is_container_v<inner_t>) {
+				return stack::push<detail::as_table_tag<T>>(L, tablecont, nested_tag);
+			}
+			else {
+				return stack::push<Tu>(L, tablecont);
+			}
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<std::initializer_list<T>> {
+		static int push(lua_State* L, const std::initializer_list<T>& il) {
+			unqualified_pusher<detail::as_table_tag<std::initializer_list<T>>> p {};
+			// silence annoying VC++ warning
+			(void)p;
+			return p.push(L, il);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<lua_nil_t> {
+		static int push(lua_State* L, lua_nil_t) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushnil(L);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<stack_count> {
+		static int push(lua_State*, stack_count st) {
+			return st.count;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<metatable_key_t> {
+		static int push(lua_State* L, metatable_key_t) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushlstring(L, to_string(meta_function::metatable).c_str(), 4);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<std::remove_pointer_t<lua_CFunction>> {
+		static int push(lua_State* L, lua_CFunction func, int n = 0) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushcclosure(L, func, n);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<lua_CFunction> {
+		static int push(lua_State* L, lua_CFunction func, int n = 0) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushcclosure(L, func, n);
+			return 1;
+		}
+	};
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_)
+	template <>
+	struct unqualified_pusher<std::remove_pointer_t<detail::lua_CFunction_noexcept>> {
+		static int push(lua_State* L, detail::lua_CFunction_noexcept func, int n = 0) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushcclosure(L, func, n);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<detail::lua_CFunction_noexcept> {
+		static int push(lua_State* L, detail::lua_CFunction_noexcept func, int n = 0) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushcclosure(L, func, n);
+			return 1;
+		}
+	};
+#endif // noexcept function type
+
+	template <>
+	struct unqualified_pusher<c_closure> {
+		static int push(lua_State* L, c_closure cc) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushcclosure(L, cc.c_function, cc.upvalues);
+			return 1;
+		}
+	};
+
+	template <typename Arg, typename... Args>
+	struct unqualified_pusher<closure<Arg, Args...>> {
+		template <std::size_t... I, typename T>
+		static int push(std::index_sequence<I...>, lua_State* L, T&& c) {
+			using f_tuple = decltype(std::forward<T>(c).upvalues);
+			int pushcount = multi_push(L, std::get<I>(std::forward<f_tuple>(std::forward<T>(c).upvalues))...);
+			return stack::push(L, c_closure(c.c_function, pushcount));
+		}
+
+		template <typename T>
+		static int push(lua_State* L, T&& c) {
+			return push(std::make_index_sequence<1 + sizeof...(Args)>(), L, std::forward<T>(c));
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<void*> {
+		static int push(lua_State* L, void* userdata) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushlightuserdata(L, userdata);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<const void*> {
+		static int push(lua_State* L, const void* userdata) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushlightuserdata(L, const_cast<void*>(userdata));
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<lightuserdata_value> {
+		static int push(lua_State* L, lightuserdata_value userdata) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushlightuserdata(L, userdata);
+			return 1;
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<light<T>> {
+		static int push(lua_State* L, light<T> l) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushlightuserdata(L, static_cast<void*>(l.value));
+			return 1;
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<user<T>> {
+		template <bool with_meta = true, typename Key, typename... Args>
+		static int push_with(lua_State* L, Key&& name, Args&&... args) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
+#endif // make sure stack doesn't overflow
+       // A dumb pusher
+			T* data = detail::user_allocate<T>(L);
+			if (with_meta) {
+				// Make sure we have a plain GC set for this data
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+				if (luaL_newmetatable(L, name) != 0) {
+					lua_CFunction cdel = detail::user_alloc_destruct<T>;
+					lua_pushcclosure(L, cdel, 0);
+					lua_setfield(L, -2, "__gc");
+				}
+				lua_setmetatable(L, -2);
+			}
+			std::allocator<T> alloc {};
+			std::allocator_traits<std::allocator<T>>::construct(alloc, data, std::forward<Args>(args)...);
+			return 1;
+		}
+
+		template <typename Arg, typename... Args>
+		static int push(lua_State* L, Arg&& arg, Args&&... args) {
+			if constexpr (std::is_same_v<meta::unqualified_t<Arg>, metatable_key_t>) {
+				const auto name = &arg[0];
+				return push_with<true>(L, name, std::forward<Args>(args)...);
+			}
+			else if constexpr (std::is_same_v<meta::unqualified_t<Arg>, no_metatable_t>) {
+				(void)arg;
+				const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
+				return push_with<false>(L, name, std::forward<Args>(args)...);
+			}
+			else {
+				const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
+				return push_with(L, name, std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+		}
+
+		static int push(lua_State* L, const user<T>& u) {
+			const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
+			return push_with(L, name, u.value);
+		}
+
+		static int push(lua_State* L, user<T>&& u) {
+			const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
+			return push_with(L, name, std::move(u.value));
+		}
+
+		static int push(lua_State* L, no_metatable_t, const user<T>& u) {
+			const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
+			return push_with<false>(L, name, u.value);
+		}
+
+		static int push(lua_State* L, no_metatable_t, user<T>&& u) {
+			const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
+			return push_with<false>(L, name, std::move(u.value));
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<userdata_value> {
+		static int push(lua_State* L, userdata_value data) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
+#endif // make sure stack doesn't overflow
+			void** ud = detail::usertype_allocate_pointer<void>(L);
+			*ud = data.value;
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<const char*> {
+		static int push_sized(lua_State* L, const char* str, std::size_t len) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+			lua_pushlstring(L, str, len);
+			return 1;
+		}
+
+		static int push(lua_State* L, const char* str) {
+			if (str == nullptr)
+				return stack::push(L, lua_nil);
+			return push_sized(L, str, std::char_traits<char>::length(str));
+		}
+
+		static int push(lua_State* L, const char* strb, const char* stre) {
+			return push_sized(L, strb, stre - strb);
+		}
+
+		static int push(lua_State* L, const char* str, std::size_t len) {
+			return push_sized(L, str, len);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<char*> {
+		static int push_sized(lua_State* L, const char* str, std::size_t len) {
+			unqualified_pusher<const char*> p {};
+			(void)p;
+			return p.push_sized(L, str, len);
+		}
+
+		static int push(lua_State* L, const char* str) {
+			unqualified_pusher<const char*> p {};
+			(void)p;
+			return p.push(L, str);
+		}
+
+		static int push(lua_State* L, const char* strb, const char* stre) {
+			unqualified_pusher<const char*> p {};
+			(void)p;
+			return p.push(L, strb, stre);
+		}
+
+		static int push(lua_State* L, const char* str, std::size_t len) {
+			unqualified_pusher<const char*> p {};
+			(void)p;
+			return p.push(L, str, len);
+		}
+	};
+
+	template <size_t N>
+	struct unqualified_pusher<char[N]> {
+		static int push(lua_State* L, const char (&str)[N]) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+			lua_pushlstring(L, str, std::char_traits<char>::length(str));
+			return 1;
+		}
+
+		static int push(lua_State* L, const char (&str)[N], std::size_t sz) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+			lua_pushlstring(L, str, sz);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<char> {
+		static int push(lua_State* L, char c) {
+			const char str[2] = { c, '\0' };
+			return stack::push(L, static_cast<const char*>(str), 1);
+		}
+	};
+
+	template <typename Ch, typename Traits, typename Al>
+	struct unqualified_pusher<std::basic_string<Ch, Traits, Al>> {
+		static int push(lua_State* L, const std::basic_string<Ch, Traits, Al>& str) {
+			if constexpr (!std::is_same_v<Ch, char>) {
+				return stack::push(L, str.data(), str.size());
+			}
+			else {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+				lua_pushlstring(L, str.c_str(), str.size());
+				return 1;
+			}
+		}
+
+		static int push(lua_State* L, const std::basic_string<Ch, Traits, Al>& str, std::size_t sz) {
+			if constexpr (!std::is_same_v<Ch, char>) {
+				return stack::push(L, str.data(), sz);
+			}
+			else {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+				lua_pushlstring(L, str.c_str(), sz);
+				return 1;
+			}
+		}
+	};
+
+	template <typename Ch, typename Traits>
+	struct unqualified_pusher<basic_string_view<Ch, Traits>> {
+		static int push(lua_State* L, const basic_string_view<Ch, Traits>& sv) {
+			return stack::push(L, sv.data(), sv.length());
+		}
+
+		static int push(lua_State* L, const basic_string_view<Ch, Traits>& sv, std::size_t n) {
+			return stack::push(L, sv.data(), n);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<meta_function> {
+		static int push(lua_State* L, meta_function m) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_meta_function_name);
+#endif // make sure stack doesn't overflow
+			const std::string& str = to_string(m);
+			lua_pushlstring(L, str.c_str(), str.size());
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<absolute_index> {
+		static int push(lua_State* L, absolute_index ai) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushvalue(L, ai);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<raw_index> {
+		static int push(lua_State* L, raw_index ri) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushvalue(L, ri);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<ref_index> {
+		static int push(lua_State* L, ref_index ri) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_rawgeti(L, LUA_REGISTRYINDEX, ri);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<const wchar_t*> {
+		static int push(lua_State* L, const wchar_t* wstr) {
+			return push(L, wstr, std::char_traits<wchar_t>::length(wstr));
+		}
+
+		static int push(lua_State* L, const wchar_t* wstr, std::size_t sz) {
+			return push(L, wstr, wstr + sz);
+		}
+
+		static int push(lua_State* L, const wchar_t* strb, const wchar_t* stre) {
+			if constexpr (sizeof(wchar_t) == 2) {
+				const char16_t* sb = reinterpret_cast<const char16_t*>(strb);
+				const char16_t* se = reinterpret_cast<const char16_t*>(stre);
+				return stack::push(L, sb, se);
+			}
+			else {
+				const char32_t* sb = reinterpret_cast<const char32_t*>(strb);
+				const char32_t* se = reinterpret_cast<const char32_t*>(stre);
+				return stack::push(L, sb, se);
+			}
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<wchar_t*> {
+		static int push(lua_State* L, const wchar_t* str) {
+			unqualified_pusher<const wchar_t*> p {};
+			(void)p;
+			return p.push(L, str);
+		}
+
+		static int push(lua_State* L, const wchar_t* strb, const wchar_t* stre) {
+			unqualified_pusher<const wchar_t*> p {};
+			(void)p;
+			return p.push(L, strb, stre);
+		}
+
+		static int push(lua_State* L, const wchar_t* str, std::size_t len) {
+			unqualified_pusher<const wchar_t*> p {};
+			(void)p;
+			return p.push(L, str, len);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<const char16_t*> {
+		static int convert_into(lua_State* L, char* start, std::size_t, const char16_t* strb, const char16_t* stre) {
+			char* target = start;
+			char32_t cp = 0;
+			for (const char16_t* strtarget = strb; strtarget < stre;) {
+				auto dr = unicode::utf16_to_code_point(strtarget, stre);
+				if (dr.error != unicode::error_code::ok) {
+					cp = unicode::unicode_detail::replacement;
+				}
+				else {
+					cp = dr.codepoint;
+				}
+				auto er = unicode::code_point_to_utf8(cp);
+				const char* utf8data = er.code_units.data();
+				std::memcpy(target, utf8data, er.code_units_size);
+				target += er.code_units_size;
+				strtarget = dr.next;
+			}
+
+			return stack::push(L, start, target);
+		}
+
+		static int push(lua_State* L, const char16_t* u16str) {
+			return push(L, u16str, std::char_traits<char16_t>::length(u16str));
+		}
+
+		static int push(lua_State* L, const char16_t* u16str, std::size_t sz) {
+			return push(L, u16str, u16str + sz);
+		}
+
+		static int push(lua_State* L, const char16_t* strb, const char16_t* stre) {
+			char sbo[SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_];
+			// if our max string space is small enough, use SBO
+			// right off the bat
+			std::size_t max_possible_code_units = (stre - strb) * 4;
+			if (max_possible_code_units <= SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_) {
+				return convert_into(L, sbo, max_possible_code_units, strb, stre);
+			}
+			// otherwise, we must manually count/check size
+			std::size_t needed_size = 0;
+			for (const char16_t* strtarget = strb; strtarget < stre;) {
+				auto dr = unicode::utf16_to_code_point(strtarget, stre);
+				auto er = unicode::code_point_to_utf8(dr.codepoint);
+				needed_size += er.code_units_size;
+				strtarget = dr.next;
+			}
+			if (needed_size < SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_) {
+				return convert_into(L, sbo, needed_size, strb, stre);
+			}
+			std::string u8str("", 0);
+			u8str.resize(needed_size);
+			char* target = const_cast<char*>(u8str.data());
+			return convert_into(L, target, needed_size, strb, stre);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<char16_t*> {
+		static int push(lua_State* L, const char16_t* str) {
+			unqualified_pusher<const char16_t*> p {};
+			(void)p;
+			return p.push(L, str);
+		}
+
+		static int push(lua_State* L, const char16_t* strb, const char16_t* stre) {
+			unqualified_pusher<const char16_t*> p {};
+			(void)p;
+			return p.push(L, strb, stre);
+		}
+
+		static int push(lua_State* L, const char16_t* str, std::size_t len) {
+			unqualified_pusher<const char16_t*> p {};
+			(void)p;
+			return p.push(L, str, len);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<const char32_t*> {
+		static int convert_into(lua_State* L, char* start, std::size_t, const char32_t* strb, const char32_t* stre) {
+			char* target = start;
+			char32_t cp = 0;
+			for (const char32_t* strtarget = strb; strtarget < stre;) {
+				auto dr = unicode::utf32_to_code_point(strtarget, stre);
+				if (dr.error != unicode::error_code::ok) {
+					cp = unicode::unicode_detail::replacement;
+				}
+				else {
+					cp = dr.codepoint;
+				}
+				auto er = unicode::code_point_to_utf8(cp);
+				const char* data = er.code_units.data();
+				std::memcpy(target, data, er.code_units_size);
+				target += er.code_units_size;
+				strtarget = dr.next;
+			}
+			return stack::push(L, start, target);
+		}
+
+		static int push(lua_State* L, const char32_t* u32str) {
+			return push(L, u32str, u32str + std::char_traits<char32_t>::length(u32str));
+		}
+
+		static int push(lua_State* L, const char32_t* u32str, std::size_t sz) {
+			return push(L, u32str, u32str + sz);
+		}
+
+		static int push(lua_State* L, const char32_t* strb, const char32_t* stre) {
+			char sbo[SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_];
+			// if our max string space is small enough, use SBO
+			// right off the bat
+			std::size_t max_possible_code_units = (stre - strb) * 4;
+			if (max_possible_code_units <= SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_) {
+				return convert_into(L, sbo, max_possible_code_units, strb, stre);
+			}
+			// otherwise, we must manually count/check size
+			std::size_t needed_size = 0;
+			for (const char32_t* strtarget = strb; strtarget < stre;) {
+				auto dr = unicode::utf32_to_code_point(strtarget, stre);
+				auto er = unicode::code_point_to_utf8(dr.codepoint);
+				needed_size += er.code_units_size;
+				strtarget = dr.next;
+			}
+			if (needed_size < SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_) {
+				return convert_into(L, sbo, needed_size, strb, stre);
+			}
+			std::string u8str("", 0);
+			u8str.resize(needed_size);
+			char* target = const_cast<char*>(u8str.data());
+			return convert_into(L, target, needed_size, strb, stre);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<char32_t*> {
+		static int push(lua_State* L, const char32_t* str) {
+			unqualified_pusher<const char32_t*> p {};
+			(void)p;
+			return p.push(L, str);
+		}
+
+		static int push(lua_State* L, const char32_t* strb, const char32_t* stre) {
+			unqualified_pusher<const char32_t*> p {};
+			(void)p;
+			return p.push(L, strb, stre);
+		}
+
+		static int push(lua_State* L, const char32_t* str, std::size_t len) {
+			unqualified_pusher<const char32_t*> p {};
+			(void)p;
+			return p.push(L, str, len);
+		}
+	};
+
+	template <size_t N>
+	struct unqualified_pusher<wchar_t[N]> {
+		static int push(lua_State* L, const wchar_t (&str)[N]) {
+			return push(L, str, std::char_traits<wchar_t>::length(str));
+		}
+
+		static int push(lua_State* L, const wchar_t (&str)[N], std::size_t sz) {
+			const wchar_t* str_ptr = static_cast<const wchar_t*>(str);
+			return stack::push<const wchar_t*>(L, str_ptr, str_ptr + sz);
+		}
+	};
+
+	template <size_t N>
+	struct unqualified_pusher<char16_t[N]> {
+		static int push(lua_State* L, const char16_t (&str)[N]) {
+			return push(L, str, std::char_traits<char16_t>::length(str));
+		}
+
+		static int push(lua_State* L, const char16_t (&str)[N], std::size_t sz) {
+			const char16_t* str_ptr = static_cast<const char16_t*>(str);
+			return stack::push<const char16_t*>(L, str_ptr, str_ptr + sz);
+		}
+	};
+
+	template <size_t N>
+	struct unqualified_pusher<char32_t[N]> {
+		static int push(lua_State* L, const char32_t (&str)[N]) {
+			return push(L, str, std::char_traits<char32_t>::length(str));
+		}
+
+		static int push(lua_State* L, const char32_t (&str)[N], std::size_t sz) {
+			const char32_t* str_ptr = static_cast<const char32_t*>(str);
+			return stack::push<const char32_t*>(L, str_ptr, str_ptr + sz);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<wchar_t> {
+		static int push(lua_State* L, wchar_t c) {
+			const wchar_t str[2] = { c, '\0' };
+			return stack::push(L, static_cast<const wchar_t*>(str), 1);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<char16_t> {
+		static int push(lua_State* L, char16_t c) {
+			const char16_t str[2] = { c, '\0' };
+			return stack::push(L, static_cast<const char16_t*>(str), 1);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<char32_t> {
+		static int push(lua_State* L, char32_t c) {
+			const char32_t str[2] = { c, '\0' };
+			return stack::push(L, static_cast<const char32_t*>(str), 1);
+		}
+	};
+
+	template <typename... Args>
+	struct unqualified_pusher<std::tuple<Args...>> {
+		template <std::size_t... I, typename T>
+		static int push(std::index_sequence<I...>, lua_State* L, T&& t) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, static_cast<int>(sizeof...(I)), detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			int pushcount = 0;
+			(void)detail::swallow { 0, (pushcount += stack::push(L, std::get<I>(std::forward<T>(t))), 0)... };
+			return pushcount;
+		}
+
+		template <typename T>
+		static int push(lua_State* L, T&& t) {
+			return push(std::index_sequence_for<Args...>(), L, std::forward<T>(t));
+		}
+	};
+
+	template <typename A, typename B>
+	struct unqualified_pusher<std::pair<A, B>> {
+		template <typename T>
+		static int push(lua_State* L, T&& t) {
+			int pushcount = stack::push(L, std::get<0>(std::forward<T>(t)));
+			pushcount += stack::push(L, std::get<1>(std::forward<T>(t)));
+			return pushcount;
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<T, std::enable_if_t<meta::is_optional_v<T>>> {
+		using ValueType = typename meta::unqualified_t<T>::value_type;
+
+		template <typename Optional>
+		static int push(lua_State* L, Optional&& op) {
+			using QualifiedValueType = meta::conditional_t<std::is_lvalue_reference_v<Optional>, ValueType&, ValueType&&>;
+			if (!op) {
+				return stack::push(L, nullopt);
+			}
+			return stack::push(L, static_cast<QualifiedValueType>(op.value()));
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<nullopt_t> {
+		static int push(lua_State* L, nullopt_t) {
+			return stack::push(L, lua_nil);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<std::nullptr_t> {
+		static int push(lua_State* L, std::nullptr_t) {
+			return stack::push(L, lua_nil);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<this_state> {
+		static int push(lua_State*, const this_state&) {
+			return 0;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<this_main_state> {
+		static int push(lua_State*, const this_main_state&) {
+			return 0;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<new_table> {
+		static int push(lua_State* L, const new_table& nt) {
+			lua_createtable(L, nt.sequence_hint, nt.map_hint);
+			return 1;
+		}
+	};
+
+	template <typename Allocator>
+	struct unqualified_pusher<basic_bytecode<Allocator>> {
+		template <typename T>
+		static int push(lua_State* L, T&& bc, const char* bytecode_name) {
+			const auto first = bc.data();
+			const auto bcsize = bc.size();
+			// pushes either the function, or an error
+			// if it errors, shit goes south, and people can test that upstream
+			(void)luaL_loadbuffer(
+				L, reinterpret_cast<const char*>(first), static_cast<std::size_t>(bcsize * (sizeof(*first) / sizeof(const char))), bytecode_name);
+			return 1;
+		}
+
+		template <typename T>
+		static int push(lua_State* L, T&& bc) {
+			return push(L, std::forward<bc>(bc), "bytecode");
+		}
+	};
+
+#if SOL_IS_ON(SOL_STD_VARIANT_I_)
+	namespace stack_detail {
+
+		struct push_function {
+			lua_State* L;
+
+			push_function(lua_State* L) : L(L) {
+			}
+
+			template <typename T>
+			int operator()(T&& value) const {
+				return stack::push<T>(L, std::forward<T>(value));
+			}
+		};
+
+	} // namespace stack_detail
+
+	template <typename... Tn>
+	struct unqualified_pusher<std::variant<Tn...>> {
+		static int push(lua_State* L, const std::variant<Tn...>& v) {
+			return std::visit(stack_detail::push_function(L), v);
+		}
+
+		static int push(lua_State* L, std::variant<Tn...>&& v) {
+			return std::visit(stack_detail::push_function(L), std::move(v));
+		}
+	};
+#endif // Variant because Clang is terrible
+
+}} // namespace sol::stack
+
+// end of sol/stack_push.hpp
+
+// beginning of sol/stack_pop.hpp
+
+#include <utility>
+#include <tuple>
+
+namespace sol {
+namespace stack {
+	template <typename T, typename>
+	struct popper {
+		inline static decltype(auto) pop(lua_State* L) {
+			if constexpr (is_stack_based_v<meta::unqualified_t<T>>) {
+				static_assert(!is_stack_based_v<meta::unqualified_t<T>>,
+					"You cannot pop something that lives solely on the stack: it will not remain on the stack when popped and thusly will go out of "
+					"scope!");
+			}
+			else {
+				record tracking{};
+				decltype(auto) r = get<T>(L, -lua_size<T>::value, tracking);
+				lua_pop(L, tracking.used);
+				return r;
+			}
+		}
+	};
+}
+} // namespace sol::stack
+
+// end of sol/stack_pop.hpp
+
+// beginning of sol/stack_field.hpp
+
+namespace sol { namespace stack {
+	template <typename T, bool global, bool raw, typename>
+	struct field_getter {
+		static constexpr int default_table_index = meta::conditional_t < meta::is_c_str_v<T>
+#if SOL_LUA_VESION_I_ >= 503
+			|| (std::is_integral_v<T> && !std::is_same_v<T, bool>)
+#endif // integer  global keys 5.3 or better
+			|| (raw && std::is_void_v<std::remove_pointer_t<T>>),
+			                std::integral_constant<int, -1>, std::integral_constant<int, -2> > ::value;
+
+		template <typename Key>
+		void get(lua_State* L, Key&& key, int tableindex = default_table_index) {
+			if constexpr (std::is_same_v<T, update_if_empty_t> || std::is_same_v<T, override_value_t> || std::is_same_v<T, create_if_nil_t>) {
+				(void)L;
+				(void)key;
+				(void)tableindex;
+			}
+			else if constexpr (std::is_same_v<T, env_key_t>) {
+				(void)key;
+#if SOL_LUA_VESION_I_ < 502
+				// Use lua_setfenv
+				lua_getfenv(L, tableindex);
+#else
+				// Use upvalues as explained in Lua 5.2 and beyond's manual
+				if (lua_getupvalue(L, tableindex, 1) == nullptr) {
+					push(L, lua_nil);
+				}
+#endif
+			}
+			else if constexpr (std::is_same_v<T, metatable_key_t>) {
+				(void)key;
+				if (lua_getmetatable(L, tableindex) == 0)
+					push(L, lua_nil);
+			}
+			else if constexpr (raw) {
+				if constexpr (std::is_integral_v<T> && !std::is_same_v<bool, T>) {
+					lua_rawgeti(L, tableindex, static_cast<lua_Integer>(key));
+				}
+#if SOL_LUA_VESION_I_ >= 502
+				else if constexpr (std::is_void_v<std::remove_pointer_t<T>>) {
+					lua_rawgetp(L, tableindex, key);
+				}
+#endif // Lua 5.2.x+
+				else {
+					push(L, std::forward<Key>(key));
+					lua_rawget(L, tableindex);
+				}
+			}
+			else {
+				if constexpr (meta::is_c_str_v<T>) {
+					if constexpr (global) {
+						(void)tableindex;
+						lua_getglobal(L, &key[0]);
+					}
+					else {
+						lua_getfield(L, tableindex, &key[0]);
+					}
+				}
+#if SOL_LUA_VESION_I_ >= 503
+				else if constexpr (std::is_integral_v<T> && !std::is_same_v<bool, T>) {
+					lua_geti(L, tableindex, static_cast<lua_Integer>(key));
+				}
+#endif // Lua 5.3.x+
+				else {
+					push(L, std::forward<Key>(key));
+					lua_gettable(L, tableindex);
+				}
+			}
+		}
+	};
+
+	template <typename... Args, bool b, bool raw, typename C>
+	struct field_getter<std::tuple<Args...>, b, raw, C> {
+		template <std::size_t... I, typename Keys>
+		void apply(std::index_sequence<0, I...>, lua_State* L, Keys&& keys, int tableindex) {
+			get_field<b, raw>(L, std::get<0>(std::forward<Keys>(keys)), tableindex);
+			void(detail::swallow { (get_field<false, raw>(L, std::get<I>(std::forward<Keys>(keys))), 0)... });
+			reference saved(L, -1);
+			lua_pop(L, static_cast<int>(sizeof...(I)));
+			saved.push();
+		}
+
+		template <typename Keys>
+		void get(lua_State* L, Keys&& keys) {
+			apply(std::make_index_sequence<sizeof...(Args)>(), L, std::forward<Keys>(keys), lua_absindex(L, -1));
+		}
+
+		template <typename Keys>
+		void get(lua_State* L, Keys&& keys, int tableindex) {
+			apply(std::make_index_sequence<sizeof...(Args)>(), L, std::forward<Keys>(keys), tableindex);
+		}
+	};
+
+	template <typename A, typename B, bool b, bool raw, typename C>
+	struct field_getter<std::pair<A, B>, b, raw, C> {
+		template <typename Keys>
+		void get(lua_State* L, Keys&& keys, int tableindex) {
+			get_field<b, raw>(L, std::get<0>(std::forward<Keys>(keys)), tableindex);
+			get_field<false, raw>(L, std::get<1>(std::forward<Keys>(keys)));
+			reference saved(L, -1);
+			lua_pop(L, static_cast<int>(2));
+			saved.push();
+		}
+
+		template <typename Keys>
+		void get(lua_State* L, Keys&& keys) {
+			get_field<b, raw>(L, std::get<0>(std::forward<Keys>(keys)));
+			get_field<false, raw>(L, std::get<1>(std::forward<Keys>(keys)));
+			reference saved(L, -1);
+			lua_pop(L, static_cast<int>(2));
+			saved.push();
+		}
+	};
+
+	template <typename T, bool global, bool raw, typename>
+	struct field_setter {
+		static constexpr int default_table_index
+			= meta::conditional_t < (meta::is_c_str_v<T> || meta::is_string_of_v<T, char>) || (std::is_integral_v<T> && !std::is_same_v<T, bool>)
+			|| (std::is_integral_v<T> && !std::is_same_v<T, bool>) || (raw && std::is_void_v<std::remove_pointer_t<T>>),
+			std::integral_constant<int, -2>, std::integral_constant<int, -3> > ::value;
+
+		template <typename Key, typename Value>
+		void set(lua_State* L, Key&& key, Value&& value, int tableindex = default_table_index) {
+			if constexpr (std::is_same_v<T, update_if_empty_t> || std::is_same_v<T, override_value_t>) {
+				(void)L;
+				(void)key;
+				(void)value;
+				(void)tableindex;
+			}
+			else if constexpr (std::is_same_v<T, metatable_key_t>) {
+				(void)key;
+				push(L, std::forward<Value>(value));
+				lua_setmetatable(L, tableindex);
+			}
+			else if constexpr (raw) {
+				if constexpr (std::is_integral_v<T> && !std::is_same_v<bool, T>) {
+					push(L, std::forward<Value>(value));
+					lua_rawseti(L, tableindex, static_cast<lua_Integer>(key));
+				}
+#if SOL_LUA_VESION_I_ >= 502
+				else if constexpr (std::is_void_v<std::remove_pointer_t<T>>) {
+					push(L, std::forward<Value>(value));
+					lua_rawsetp(L, tableindex, std::forward<Key>(key));
+				}
+#endif // Lua 5.2.x
+				else {
+					push(L, std::forward<Key>(key));
+					push(L, std::forward<Value>(value));
+					lua_rawset(L, tableindex);
+				}
+			}
+			else {
+				if constexpr (meta::is_c_str_v<T> || meta::is_string_of_v<T, char>) {
+					if constexpr (global) {
+						push(L, std::forward<Value>(value));
+						lua_setglobal(L, &key[0]);
+						(void)tableindex;
+					}
+					else {
+						push(L, std::forward<Value>(value));
+						lua_setfield(L, tableindex, &key[0]);
+					}
+				}
+#if SOL_LUA_VESION_I_ >= 503
+				else if constexpr (std::is_integral_v<T> && !std::is_same_v<bool, T>) {
+					push(L, std::forward<Value>(value));
+					lua_seti(L, tableindex, static_cast<lua_Integer>(key));
+				}
+#endif // Lua 5.3.x
+				else {
+					push(L, std::forward<Key>(key));
+					push(L, std::forward<Value>(value));
+					lua_settable(L, tableindex);
+				}
+			}
+		}
+	};
+
+	template <typename... Args, bool b, bool raw, typename C>
+	struct field_setter<std::tuple<Args...>, b, raw, C> {
+		template <bool g, std::size_t I, typename Keys, typename Value>
+		void apply(std::index_sequence<I>, lua_State* L, Keys&& keys, Value&& value, int tableindex) {
+			I < 1 ? set_field<g, raw>(L, std::get<I>(std::forward<Keys>(keys)), std::forward<Value>(value), tableindex)
+				 : set_field<g, raw>(L, std::get<I>(std::forward<Keys>(keys)), std::forward<Value>(value));
+		}
+
+		template <bool g, std::size_t I0, std::size_t I1, std::size_t... I, typename Keys, typename Value>
+		void apply(std::index_sequence<I0, I1, I...>, lua_State* L, Keys&& keys, Value&& value, int tableindex) {
+			I0 < 1 ? get_field<g, raw>(L, std::get<I0>(std::forward<Keys>(keys)), tableindex)
+				  : get_field<g, raw>(L, std::get<I0>(std::forward<Keys>(keys)), -1);
+			apply<false>(std::index_sequence<I1, I...>(), L, std::forward<Keys>(keys), std::forward<Value>(value), -1);
+		}
+
+		template <bool g, std::size_t I0, std::size_t... I, typename Keys, typename Value>
+		void top_apply(std::index_sequence<I0, I...>, lua_State* L, Keys&& keys, Value&& value, int tableindex) {
+			apply<g>(std::index_sequence<I0, I...>(), L, std::forward<Keys>(keys), std::forward<Value>(value), tableindex);
+			lua_pop(L, static_cast<int>(sizeof...(I)));
+		}
+
+		template <typename Keys, typename Value>
+		void set(lua_State* L, Keys&& keys, Value&& value, int tableindex = -3) {
+			top_apply<b>(std::make_index_sequence<sizeof...(Args)>(), L, std::forward<Keys>(keys), std::forward<Value>(value), tableindex);
+		}
+	};
+
+	template <typename A, typename B, bool b, bool raw, typename C>
+	struct field_setter<std::pair<A, B>, b, raw, C> {
+		template <typename Keys, typename Value>
+		void set(lua_State* L, Keys&& keys, Value&& value, int tableindex = -1) {
+			get_field<b, raw>(L, std::get<0>(std::forward<Keys>(keys)), tableindex);
+			set_field<false, raw>(L, std::get<1>(std::forward<Keys>(keys)), std::forward<Value>(value), lua_gettop(L));
+			lua_pop(L, 1);
+		}
+	};
+}} // namespace sol::stack
+
+// end of sol/stack_field.hpp
+
+// beginning of sol/stack_probe.hpp
+
+namespace sol {
+namespace stack {
+	template <typename T, typename P, bool b, bool raw, typename>
+	struct probe_field_getter {
+		template <typename Key>
+		probe get(lua_State* L, Key&& key, int tableindex = -2) {
+			if constexpr(!b) {
+				if (!maybe_indexable(L, tableindex)) {
+					return probe(false, 0);
+				}
+			}
+			get_field<b, raw>(L, std::forward<Key>(key), tableindex);
+			return probe(check<P>(L), 1);
+		}
+	};
+
+	template <typename A, typename B, typename P, bool b, bool raw, typename C>
+	struct probe_field_getter<std::pair<A, B>, P, b, raw, C> {
+		template <typename Keys>
+		probe get(lua_State* L, Keys&& keys, int tableindex = -2) {
+			if (!b && !maybe_indexable(L, tableindex)) {
+				return probe(false, 0);
+			}
+			get_field<b, raw>(L, std::get<0>(keys), tableindex);
+			if (!maybe_indexable(L)) {
+				return probe(false, 1);
+			}
+			get_field<false, raw>(L, std::get<1>(keys), tableindex);
+			return probe(check<P>(L), 2);
+		}
+	};
+
+	template <typename... Args, typename P, bool b, bool raw, typename C>
+	struct probe_field_getter<std::tuple<Args...>, P, b, raw, C> {
+		template <std::size_t I, typename Keys>
+		probe apply(std::index_sequence<I>, int sofar, lua_State* L, Keys&& keys, int tableindex) {
+			get_field<(I<1) && b, raw>(L, std::get<I>(keys), tableindex);
+			return probe(check<P>(L), sofar);
+		}
+
+		template <std::size_t I, std::size_t I1, std::size_t... In, typename Keys>
+		probe apply(std::index_sequence<I, I1, In...>, int sofar, lua_State* L, Keys&& keys, int tableindex) {
+			get_field < I<1 && b, raw>(L, std::get<I>(keys), tableindex);
+			if (!maybe_indexable(L)) {
+				return probe(false, sofar);
+			}
+			return apply(std::index_sequence<I1, In...>(), sofar + 1, L, std::forward<Keys>(keys), -1);
+		}
+
+		template <typename Keys>
+		probe get(lua_State* L, Keys&& keys, int tableindex = -2) {
+			if constexpr (!b) {
+				if (!maybe_indexable(L, tableindex)) {
+					return probe(false, 0);
+				}
+				return apply(std::index_sequence_for<Args...>(), 1, L, std::forward<Keys>(keys), tableindex);
+			}
+			else {
+				return apply(std::index_sequence_for<Args...>(), 1, L, std::forward<Keys>(keys), tableindex);
+			}
+		}
+	};
+}
+} // namespace sol::stack
+
+// end of sol/stack_probe.hpp
+
+#include <cstring>
+#include <array>
+
+namespace sol {
+	namespace detail {
+		using typical_chunk_name_t = char[SOL_ID_SIZE_I_];
+		using typical_file_chunk_name_t = char[SOL_FILE_ID_SIZE_I_];
+
+		inline const std::string& default_chunk_name() {
+			static const std::string name = "";
+			return name;
+		}
+
+		template <std::size_t N>
+		const char* make_chunk_name(const string_view& code, const std::string& chunkname, char (&basechunkname)[N]) {
+			if (chunkname.empty()) {
+				auto it = code.cbegin();
+				auto e = code.cend();
+				std::size_t i = 0;
+				static const std::size_t n = N - 4;
+				for (i = 0; i < n && it != e; ++i, ++it) {
+					basechunkname[i] = *it;
+				}
+				if (it != e) {
+					for (std::size_t c = 0; c < 3; ++i, ++c) {
+						basechunkname[i] = '.';
+					}
+				}
+				basechunkname[i] = '\0';
+				return &basechunkname[0];
+			}
+			else {
+				return chunkname.c_str();
+			}
+		}
+
+		inline void clear_entries(stack_reference r) {
+			stack::push(r.lua_state(), lua_nil);
+			while (lua_next(r.lua_state(), -2)) {
+				absolute_index key(r.lua_state(), -2);
+				auto pn = stack::pop_n(r.lua_state(), 1);
+				stack::set_field<false, true>(r.lua_state(), key, lua_nil, r.stack_index());
+			}
+		}
+
+		inline void clear_entries(const reference& registry_reference) {
+			auto pp = stack::push_pop(registry_reference);
+			stack_reference ref(registry_reference.lua_state(), -1);
+			clear_entries(ref);
+		}
+	} // namespace detail
+
+	namespace stack {
+		namespace stack_detail {
+			template <typename T>
+			inline int push_as_upvalues(lua_State* L, T& item) {
+				typedef std::decay_t<T> TValue;
+				static const std::size_t itemsize = sizeof(TValue);
+				static const std::size_t voidsize = sizeof(void*);
+				static const std::size_t voidsizem1 = voidsize - 1;
+				static const std::size_t data_t_count = (sizeof(TValue) + voidsizem1) / voidsize;
+				typedef std::array<void*, data_t_count> data_t;
+
+				data_t data { {} };
+				std::memcpy(&data[0], std::addressof(item), itemsize);
+				int pushcount = 0;
+				for (const auto& v : data) {
+					lua_pushlightuserdata(L, v);
+					pushcount += 1;
+				}
+				return pushcount;
+			}
+
+			template <typename T>
+			inline std::pair<T, int> get_as_upvalues(lua_State* L, int index = 2) {
+				static const std::size_t data_t_count = (sizeof(T) + (sizeof(void*) - 1)) / sizeof(void*);
+				typedef std::array<void*, data_t_count> data_t;
+				data_t voiddata { {} };
+				for (std::size_t i = 0, d = 0; d < sizeof(T); ++i, d += sizeof(void*)) {
+					voiddata[i] = lua_touserdata(L, upvalue_index(index++));
+				}
+				return std::pair<T, int>(*reinterpret_cast<T*>(static_cast<void*>(voiddata.data())), index);
+			}
+
+			template <typename T>
+			inline std::pair<T, int> get_as_upvalues_using_function(lua_State* L, int function_index = -1) {
+				static const std::size_t data_t_count = (sizeof(T) + (sizeof(void*) - 1)) / sizeof(void*);
+				typedef std::array<void*, data_t_count> data_t;
+				function_index = lua_absindex(L, function_index);
+				int index = 0;
+				data_t voiddata { {} };
+				for (std::size_t d = 0; d < sizeof(T); d += sizeof(void*)) {
+					// first upvalue is nullptr to respect environment shenanigans
+					// So +2 instead of +1
+					const char* upvalue_name = lua_getupvalue(L, function_index, index + 2);
+					if (upvalue_name == nullptr) {
+						// We should freak out here...
+						break;
+					}
+					voiddata[index] = lua_touserdata(L, -1);
+					++index;
+				}
+				lua_pop(L, index);
+				return std::pair<T, int>(*reinterpret_cast<T*>(static_cast<void*>(voiddata.data())), index);
+			}
+
+			template <typename Fx, typename... Args>
+			static decltype(auto) eval(types<>, std::index_sequence<>, lua_State*, int, record&, Fx&& fx, Args&&... args) {
+				return std::forward<Fx>(fx)(std::forward<Args>(args)...);
+			}
+
+			template <typename Fx, typename Arg, typename... Args, std::size_t I, std::size_t... Is, typename... FxArgs>
+			static decltype(auto) eval(
+			     types<Arg, Args...>, std::index_sequence<I, Is...>, lua_State* L, int start, record& tracking, Fx&& fx, FxArgs&&... fxargs) {
+				return eval(types<Args...>(),
+				     std::index_sequence<Is...>(),
+				     L,
+				     start,
+				     tracking,
+				     std::forward<Fx>(fx),
+				     std::forward<FxArgs>(fxargs)...,
+				     stack_detail::unchecked_get<Arg>(L, start + tracking.used, tracking));
+			}
+
+			template <bool checkargs = detail::default_safe_function_calls, std::size_t... I, typename R, typename... Args, typename Fx, typename... FxArgs>
+			inline decltype(auto) call(types<R>, types<Args...> ta, std::index_sequence<I...> tai, lua_State* L, int start, Fx&& fx, FxArgs&&... args) {
+				static_assert(meta::all<meta::is_not_move_only<Args>...>::value,
+				     "One of the arguments being bound is a move-only type, and it is not being taken by reference: this will break your code. Please take "
+				     "a reference and std::move it manually if this was your intention.");
+				if constexpr (checkargs) {
+					argument_handler<types<R, Args...>> handler {};
+					multi_check<Args...>(L, start, handler);
+				}
+				record tracking {};
+				if constexpr (std::is_void_v<R>) {
+					eval(ta, tai, L, start, tracking, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
+				}
+				else {
+					return eval(ta, tai, L, start, tracking, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
+				}
+			}
+		} // namespace stack_detail
+
+		template <typename T>
+		int set_ref(lua_State* L, T&& arg, int tableindex = -2) {
+			push(L, std::forward<T>(arg));
+			return luaL_ref(L, tableindex);
+		}
+
+		template <bool check_args = detail::default_safe_function_calls, typename R, typename... Args, typename Fx, typename... FxArgs>
+		inline decltype(auto) call(types<R> tr, types<Args...> ta, lua_State* L, int start, Fx&& fx, FxArgs&&... args) {
+			using args_indices = std::make_index_sequence<sizeof...(Args)>;
+			if constexpr (std::is_void_v<R>) {
+				stack_detail::call<check_args>(tr, ta, args_indices(), L, start, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
+			}
+			else {
+				return stack_detail::call<check_args>(tr, ta, args_indices(), L, start, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
+			}
+		}
+
+		template <bool check_args = detail::default_safe_function_calls, typename R, typename... Args, typename Fx, typename... FxArgs>
+		inline decltype(auto) call(types<R> tr, types<Args...> ta, lua_State* L, Fx&& fx, FxArgs&&... args) {
+			if constexpr (std::is_void_v<R>) {
+				call<check_args>(tr, ta, L, 1, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
+			}
+			else {
+				return call<check_args>(tr, ta, L, 1, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
+			}
+		}
+
+		template <bool check_args = detail::default_safe_function_calls, typename R, typename... Args, typename Fx, typename... FxArgs>
+		inline decltype(auto) call_from_top(types<R> tr, types<Args...> ta, lua_State* L, Fx&& fx, FxArgs&&... args) {
+			using expected_count_t = meta::count_for_pack<lua_size, Args...>;
+			if constexpr (std::is_void_v<R>) {
+				call<check_args>(tr,
+				     ta,
+				     L,
+				     (std::max)(static_cast<int>(lua_gettop(L) - expected_count_t::value), static_cast<int>(0)),
+				     std::forward<Fx>(fx),
+				     std::forward<FxArgs>(args)...);
+			}
+			else {
+				return call<check_args>(tr,
+				     ta,
+				     L,
+				     (std::max)(static_cast<int>(lua_gettop(L) - expected_count_t::value), static_cast<int>(0)),
+				     std::forward<Fx>(fx),
+				     std::forward<FxArgs>(args)...);
+			}
+		}
+
+		template <bool check_args = detail::default_safe_function_calls, bool clean_stack = true, typename Ret0, typename... Ret, typename... Args,
+		     typename Fx, typename... FxArgs>
+		inline int call_into_lua(types<Ret0, Ret...> tr, types<Args...> ta, lua_State* L, int start, Fx&& fx, FxArgs&&... fxargs) {
+			if constexpr (std::is_void_v<Ret0>) {
+				call<check_args>(tr, ta, L, start, std::forward<Fx>(fx), std::forward<FxArgs>(fxargs)...);
+				if constexpr (clean_stack) {
+					lua_settop(L, 0);
+				}
+				return 0;
+			}
+			else {
+				(void)tr;
+				decltype(auto) r
+				     = call<check_args>(types<meta::return_type_t<Ret0, Ret...>>(), ta, L, start, std::forward<Fx>(fx), std::forward<FxArgs>(fxargs)...);
+				using R = meta::unqualified_t<decltype(r)>;
+				using is_stack = meta::any<is_stack_based<R>, std::is_same<R, absolute_index>, std::is_same<R, ref_index>, std::is_same<R, raw_index>>;
+				if constexpr (clean_stack && !is_stack::value) {
+					lua_settop(L, 0);
+				}
+				return push_reference(L, std::forward<decltype(r)>(r));
+			}
+		}
+
+		template <bool check_args = detail::default_safe_function_calls, bool clean_stack = true, typename Fx, typename... FxArgs>
+		inline int call_lua(lua_State* L, int start, Fx&& fx, FxArgs&&... fxargs) {
+			using traits_type = lua_bind_traits<meta::unqualified_t<Fx>>;
+			using args_list = typename traits_type::args_list;
+			using returns_list = typename traits_type::returns_list;
+			return call_into_lua<check_args, clean_stack>(returns_list(), args_list(), L, start, std::forward<Fx>(fx), std::forward<FxArgs>(fxargs)...);
+		}
+
+		inline call_syntax get_call_syntax(lua_State* L, const string_view& key, int index) {
+			if (lua_gettop(L) < 1) {
+				return call_syntax::dot;
+			}
+			luaL_getmetatable(L, key.data());
+			auto pn = pop_n(L, 1);
+			if (lua_compare(L, -1, index, LUA_OPEQ) != 1) {
+				return call_syntax::dot;
+			}
+			return call_syntax::colon;
+		}
+
+		inline void script(
+		     lua_State* L, lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name("lua_Reader", chunkname, basechunkname);
+			if (lua_load(L, reader, data, chunknametarget, to_string(mode).c_str()) || lua_pcall(L, 0, LUA_MULTRET, 0)) {
+				lua_error(L);
+			}
+		}
+
+		inline void script(
+		     lua_State* L, const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name(code, chunkname, basechunkname);
+			if (luaL_loadbufferx(L, code.data(), code.size(), chunknametarget, to_string(mode).c_str()) || lua_pcall(L, 0, LUA_MULTRET, 0)) {
+				lua_error(L);
+			}
+		}
+
+		inline void script_file(lua_State* L, const std::string& filename, load_mode mode = load_mode::any) {
+			if (luaL_loadfilex(L, filename.c_str(), to_string(mode).c_str()) || lua_pcall(L, 0, LUA_MULTRET, 0)) {
+				lua_error(L);
+			}
+		}
+
+		inline void luajit_exception_handler(lua_State* L, int (*handler)(lua_State*, lua_CFunction) = detail::c_trampoline) {
+#if SOL_IS_ON(SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_)
+			if (L == nullptr) {
+				return;
+			}
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushlightuserdata(L, (void*)handler);
+			auto pn = pop_n(L, 1);
+			luaJIT_setmode(L, -1, LUAJIT_MODE_WRAPCFUNC | LUAJIT_MODE_ON);
+#else
+			(void)L;
+			(void)handler;
+#endif
+		}
+
+		inline void luajit_exception_off(lua_State* L) {
+#if SOL_IS_ON(SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_)
+			if (L == nullptr) {
+				return;
+			}
+			luaJIT_setmode(L, -1, LUAJIT_MODE_WRAPCFUNC | LUAJIT_MODE_OFF);
+#else
+			(void)L;
+#endif
+		}
+	} // namespace stack
+} // namespace sol
+
+// end of sol/stack.hpp
+
+// beginning of sol/object.hpp
+
+// beginning of sol/make_reference.hpp
+
+namespace sol {
+
+	template <typename R = reference, bool should_pop = !is_stack_based_v<R>, typename T>
+	R make_reference(lua_State* L, T&& value) {
+		int backpedal = stack::push(L, std::forward<T>(value));
+		R r = stack::get<R>(L, -backpedal);
+		if (should_pop) {
+			lua_pop(L, backpedal);
+		}
+		return r;
+	}
+
+	template <typename T, typename R = reference, bool should_pop = !is_stack_based_v<R>, typename... Args>
+	R make_reference(lua_State* L, Args&&... args) {
+		int backpedal = stack::push<T>(L, std::forward<Args>(args)...);
+		R r = stack::get<R>(L, -backpedal);
+		if (should_pop) {
+			lua_pop(L, backpedal);
+		}
+		return r;
+	}
+
+	template <typename R = reference, bool should_pop = !is_stack_based_v<R>, typename T>
+	R make_reference_userdata(lua_State* L, T&& value) {
+		int backpedal = stack::push_userdata(L, std::forward<T>(value));
+		R r = stack::get<R>(L, -backpedal);
+		if (should_pop) {
+			lua_pop(L, backpedal);
+		}
+		return r;
+	}
+
+	template <typename T, typename R = reference, bool should_pop = !is_stack_based_v<R>, typename... Args>
+	R make_reference_userdata(lua_State* L, Args&&... args) {
+		int backpedal = stack::push_userdata<T>(L, std::forward<Args>(args)...);
+		R r = stack::get<R>(L, -backpedal);
+		if (should_pop) {
+			lua_pop(L, backpedal);
+		}
+		return r;
+	}
+
+} // namespace sol
+
+// end of sol/make_reference.hpp
+
+// beginning of sol/object_base.hpp
+
+namespace sol {
+
+	template <typename ref_t>
+	class basic_object_base : public ref_t {
+	private:
+		using base_t = ref_t;
+		
+		template <typename T>
+		decltype(auto) as_stack(std::true_type) const {
+			return stack::get<T>(base_t::lua_state(), base_t::stack_index());
+		}
+
+		template <typename T>
+		decltype(auto) as_stack(std::false_type) const {
+			base_t::push();
+			return stack::pop<T>(base_t::lua_state());
+		}
+
+		template <typename T>
+		bool is_stack(std::true_type) const {
+			return stack::check<T>(base_t::lua_state(), base_t::stack_index(), no_panic);
+		}
+
+		template <typename T>
+		bool is_stack(std::false_type) const {
+			int r = base_t::registry_index();
+			if (r == LUA_REFNIL)
+				return meta::any_same<meta::unqualified_t<T>, lua_nil_t, nullopt_t, std::nullptr_t>::value ? true : false;
+			if (r == LUA_NOREF)
+				return false;
+			auto pp = stack::push_pop(*this);
+			return stack::check<T>(base_t::lua_state(), -1, no_panic);
+		}
+
+	public:
+		basic_object_base() noexcept = default;
+		basic_object_base(const basic_object_base&) = default;
+		basic_object_base(basic_object_base&&) = default;
+		basic_object_base& operator=(const basic_object_base&) = default;
+		basic_object_base& operator=(basic_object_base&&) = default;
+		template <typename T, typename... Args, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_object_base>>> = meta::enabler>
+		basic_object_base(T&& arg, Args&&... args)
+		: base_t(std::forward<T>(arg), std::forward<Args>(args)...) {
+		}
+
+		template <typename T>
+		decltype(auto) as() const {
+			return as_stack<T>(is_stack_based<base_t>());
+		}
+
+		template <typename T>
+		bool is() const {
+			return is_stack<T>(is_stack_based<base_t>());
+		}
+	};
+} // namespace sol
+
+// end of sol/object_base.hpp
+
+namespace sol {
+
+	template <typename base_type>
+	class basic_object : public basic_object_base<base_type> {
+	private:
+		typedef basic_object_base<base_type> base_t;
+
+		template <bool invert_and_pop = false>
+		basic_object(std::integral_constant<bool, invert_and_pop>, lua_State* L, int index = -1) noexcept
+		: base_t(L, index) {
+			if (invert_and_pop) {
+				lua_pop(L, -index);
+			}
+		}
+
+	protected:
+		basic_object(detail::no_safety_tag, lua_nil_t n) : base_t(n) {
+		}
+		basic_object(detail::no_safety_tag, lua_State* L, int index) : base_t(L, index) {
+		}
+		basic_object(lua_State* L, detail::global_tag t) : base_t(L, t) {
+		}
+		basic_object(detail::no_safety_tag, lua_State* L, ref_index index) : base_t(L, index) {
+		}
+		template <typename T,
+		     meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_object>>, meta::neg<std::is_same<base_type, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_object(detail::no_safety_tag, T&& r) noexcept : base_t(std::forward<T>(r)) {
+		}
+
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_object(detail::no_safety_tag, lua_State* L, T&& r) noexcept : base_t(L, std::forward<T>(r)) {
+		}
+
+	public:
+		basic_object() noexcept = default;
+		template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_object>>, meta::neg<std::is_same<base_type, stack_reference>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_object(T&& r)
+		: base_t(std::forward<T>(r)) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_object(lua_State* L, T&& r)
+		: base_t(L, std::forward<T>(r)) {
+		}
+		basic_object(lua_nil_t r)
+		: base_t(r) {
+		}
+		basic_object(const basic_object&) = default;
+		basic_object(basic_object&&) = default;
+		basic_object(const stack_reference& r) noexcept
+		: basic_object(r.lua_state(), r.stack_index()) {
+		}
+		basic_object(stack_reference&& r) noexcept
+		: basic_object(r.lua_state(), r.stack_index()) {
+		}
+		template <typename Super>
+		basic_object(const proxy_base<Super>& r) noexcept
+		: basic_object(r.operator basic_object()) {
+		}
+		template <typename Super>
+		basic_object(proxy_base<Super>&& r) noexcept
+		: basic_object(r.operator basic_object()) {
+		}
+		basic_object(lua_State* L, lua_nil_t r) noexcept
+		: base_t(L, r) {
+		}
+		basic_object(lua_State* L, int index = -1) noexcept
+		: base_t(L, index) {
+		}
+		basic_object(lua_State* L, absolute_index index) noexcept
+		: base_t(L, index) {
+		}
+		basic_object(lua_State* L, raw_index index) noexcept
+		: base_t(L, index) {
+		}
+		basic_object(lua_State* L, ref_index index) noexcept
+		: base_t(L, index) {
+		}
+		template <typename T, typename... Args>
+		basic_object(lua_State* L, in_place_type_t<T>, Args&&... args) noexcept
+		: basic_object(std::integral_constant<bool, !is_stack_based<base_t>::value>(), L, -stack::push<T>(L, std::forward<Args>(args)...)) {
+		}
+		template <typename T, typename... Args>
+		basic_object(lua_State* L, in_place_t, T&& arg, Args&&... args) noexcept
+		: basic_object(L, in_place_type<T>, std::forward<T>(arg), std::forward<Args>(args)...) {
+		}
+		basic_object& operator=(const basic_object&) = default;
+		basic_object& operator=(basic_object&&) = default;
+		basic_object& operator=(const base_type& b) {
+			base_t::operator=(b);
+			return *this;
+		}
+		basic_object& operator=(base_type&& b) {
+			base_t::operator=(std::move(b));
+			return *this;
+		}
+		template <typename Super>
+		basic_object& operator=(const proxy_base<Super>& r) {
+			this->operator=(r.operator basic_object());
+			return *this;
+		}
+		template <typename Super>
+		basic_object& operator=(proxy_base<Super>&& r) {
+			this->operator=(r.operator basic_object());
+			return *this;
+		}
+	};
+
+	template <typename T>
+	object make_object(lua_State* L, T&& value) {
+		return make_reference<object, true>(L, std::forward<T>(value));
+	}
+
+	template <typename T, typename... Args>
+	object make_object(lua_State* L, Args&&... args) {
+		return make_reference<T, object, true>(L, std::forward<Args>(args)...);
+	}
+
+	template <typename T>
+	object make_object_userdata(lua_State* L, T&& value) {
+		return make_reference_userdata<object, true>(L, std::forward<T>(value));
+	}
+
+	template <typename T, typename... Args>
+	object make_object_userdata(lua_State* L, Args&&... args) {
+		return make_reference_userdata<T, object, true>(L, std::forward<Args>(args)...);
+	}
+} // namespace sol
+
+// end of sol/object.hpp
+
+// beginning of sol/function.hpp
+
+// beginning of sol/unsafe_function.hpp
+
+// beginning of sol/function_result.hpp
+
+// beginning of sol/protected_function_result.hpp
+
+// beginning of sol/proxy_base.hpp
+
+namespace sol {
+	struct proxy_base_tag {};
+
+	namespace detail {
+		template <typename T>
+		using proxy_key_t = meta::conditional_t<meta::is_specialization_of_v<meta::unqualified_t<T>, std::tuple>, T,
+		     std::tuple<meta::conditional_t<std::is_array_v<meta::unqualified_t<T>>, std::remove_reference_t<T>&, meta::unqualified_t<T>>>>;
+	}
+
+	template <typename Super>
+	struct proxy_base : proxy_base_tag {
+		operator std::string() const {
+			const Super& super = *static_cast<const Super*>(static_cast<const void*>(this));
+			return super.template get<std::string>();
+		}
+
+		template <typename T, meta::enable<meta::neg<meta::is_string_constructible<T>>, is_proxy_primitive<meta::unqualified_t<T>>> = meta::enabler>
+		operator T() const {
+			const Super& super = *static_cast<const Super*>(static_cast<const void*>(this));
+			return super.template get<T>();
+		}
+
+		template <typename T, meta::enable<meta::neg<meta::is_string_constructible<T>>, meta::neg<is_proxy_primitive<meta::unqualified_t<T>>>> = meta::enabler>
+		operator T&() const {
+			const Super& super = *static_cast<const Super*>(static_cast<const void*>(this));
+			return super.template get<T&>();
+		}
+
+		lua_State* lua_state() const {
+			const Super& super = *static_cast<const Super*>(static_cast<const void*>(this));
+			return super.lua_state();
+		}
+	};
+} // namespace sol
+
+// end of sol/proxy_base.hpp
+
+// beginning of sol/stack_iterator.hpp
+
+#include <limits>
+#include <iterator>
+
+namespace sol {
+	template <typename proxy_t, bool is_const>
+	struct stack_iterator {
+		typedef meta::conditional_t<is_const, const proxy_t, proxy_t> reference;
+		typedef meta::conditional_t<is_const, const proxy_t*, proxy_t*> pointer;
+		typedef proxy_t value_type;
+		typedef std::ptrdiff_t difference_type;
+		typedef std::random_access_iterator_tag iterator_category;
+		lua_State* L;
+		int index;
+		int stacktop;
+		proxy_t sp;
+
+		stack_iterator()
+			: L(nullptr), index((std::numeric_limits<int>::max)()), stacktop((std::numeric_limits<int>::max)()), sp() {
+		}
+		stack_iterator(const stack_iterator<proxy_t, true>& r)
+			: L(r.L), index(r.index), stacktop(r.stacktop), sp(r.sp) {
+		}
+		stack_iterator(lua_State* luastate, int idx, int topidx)
+			: L(luastate), index(idx), stacktop(topidx), sp(luastate, idx) {
+		}
+
+		reference operator*() {
+			return proxy_t(L, index);
+		}
+
+		reference operator*() const {
+			return proxy_t(L, index);
+		}
+
+		pointer operator->() {
+			sp = proxy_t(L, index);
+			return &sp;
+		}
+
+		pointer operator->() const {
+			const_cast<proxy_t&>(sp) = proxy_t(L, index);
+			return &sp;
+		}
+
+		stack_iterator& operator++() {
+			++index;
+			return *this;
+		}
+
+		stack_iterator operator++(int) {
+			auto r = *this;
+			this->operator++();
+			return r;
+		}
+
+		stack_iterator& operator--() {
+			--index;
+			return *this;
+		}
+
+		stack_iterator operator--(int) {
+			auto r = *this;
+			this->operator--();
+			return r;
+		}
+
+		stack_iterator& operator+=(difference_type idx) {
+			index += static_cast<int>(idx);
+			return *this;
+		}
+
+		stack_iterator& operator-=(difference_type idx) {
+			index -= static_cast<int>(idx);
+			return *this;
+		}
+
+		difference_type operator-(const stack_iterator& r) const {
+			return index - r.index;
+		}
+
+		stack_iterator operator+(difference_type idx) const {
+			stack_iterator r = *this;
+			r += idx;
+			return r;
+		}
+
+		reference operator[](difference_type idx) const {
+			return proxy_t(L, index + static_cast<int>(idx));
+		}
+
+		bool operator==(const stack_iterator& r) const {
+			if (stacktop == (std::numeric_limits<int>::max)()) {
+				return r.index == r.stacktop;
+			}
+			else if (r.stacktop == (std::numeric_limits<int>::max)()) {
+				return index == stacktop;
+			}
+			return index == r.index;
+		}
+
+		bool operator!=(const stack_iterator& r) const {
+			return !(this->operator==(r));
+		}
+
+		bool operator<(const stack_iterator& r) const {
+			return index < r.index;
+		}
+
+		bool operator>(const stack_iterator& r) const {
+			return index > r.index;
+		}
+
+		bool operator<=(const stack_iterator& r) const {
+			return index <= r.index;
+		}
+
+		bool operator>=(const stack_iterator& r) const {
+			return index >= r.index;
+		}
+	};
+
+	template <typename proxy_t, bool is_const>
+	inline stack_iterator<proxy_t, is_const> operator+(typename stack_iterator<proxy_t, is_const>::difference_type n, const stack_iterator<proxy_t, is_const>& r) {
+		return r + n;
+	}
+} // namespace sol
+
+// end of sol/stack_iterator.hpp
+
+// beginning of sol/stack_proxy.hpp
+
+// beginning of sol/stack_proxy_base.hpp
+
+namespace sol {
+	struct stack_proxy_base : public proxy_base<stack_proxy_base> {
+	private:
+		lua_State* L;
+		int index;
+
+	public:
+		stack_proxy_base()
+			: L(nullptr), index(0) {
+		}
+		stack_proxy_base(lua_State* L, int index)
+			: L(L), index(index) {
+		}
+
+		template <typename T>
+		decltype(auto) get() const {
+			return stack::get<T>(L, stack_index());
+		}
+
+		template <typename T>
+		bool is() const {
+			return stack::check<T>(L, stack_index());
+		}
+
+		template <typename T>
+		decltype(auto) as() const {
+			return get<T>();
+		}
+
+		type get_type() const noexcept {
+			return type_of(lua_state(), stack_index());
+		}
+
+		int push() const {
+			return push(L);
+		}
+
+		int push(lua_State* Ls) const {
+			lua_pushvalue(Ls, index);
+			return 1;
+		}
+
+		lua_State* lua_state() const {
+			return L;
+		}
+		int stack_index() const {
+			return index;
+		}
+	};
+
+	namespace stack {
+		template <>
+		struct unqualified_getter<stack_proxy_base> {
+			static stack_proxy_base get(lua_State* L, int index = -1) {
+				return stack_proxy_base(L, index);
+			}
+		};
+
+		template <>
+		struct unqualified_pusher<stack_proxy_base> {
+			static int push(lua_State*, const stack_proxy_base& ref) {
+				return ref.push();
+			}
+		};
+	} // namespace stack
+
+} // namespace sol
+
+// end of sol/stack_proxy_base.hpp
+
+namespace sol {
+	struct stack_proxy : public stack_proxy_base {
+	public:
+		stack_proxy() : stack_proxy_base() {
+		}
+		stack_proxy(lua_State* L, int index) : stack_proxy_base(L, index) {
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) call(Args&&... args);
+
+		template <typename... Args>
+		decltype(auto) operator()(Args&&... args) {
+			return call<>(std::forward<Args>(args)...);
+		}
+	};
+
+	namespace stack {
+		template <>
+		struct unqualified_getter<stack_proxy> {
+			static stack_proxy get(lua_State* L, int index, record& tracking) {
+				tracking.use(0);
+				return stack_proxy(L, index);
+			}
+		};
+
+		template <>
+		struct unqualified_pusher<stack_proxy> {
+			static int push(lua_State*, const stack_proxy& ref) {
+				return ref.push();
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/stack_proxy.hpp
+
+#include <cstdint>
+
+namespace sol {
+	struct protected_function_result : public proxy_base<protected_function_result> {
+	private:
+		lua_State* L;
+		int index;
+		int returncount;
+		int popcount;
+		call_status err;
+
+	public:
+		typedef stack_proxy reference_type;
+		typedef stack_proxy value_type;
+		typedef stack_proxy* pointer;
+		typedef std::ptrdiff_t difference_type;
+		typedef std::size_t size_type;
+		typedef stack_iterator<stack_proxy, false> iterator;
+		typedef stack_iterator<stack_proxy, true> const_iterator;
+		typedef std::reverse_iterator<iterator> reverse_iterator;
+		typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+		protected_function_result() noexcept = default;
+		protected_function_result(lua_State* Ls, int idx = -1, int retnum = 0, int popped = 0, call_status pferr = call_status::ok) noexcept
+		: L(Ls), index(idx), returncount(retnum), popcount(popped), err(pferr) {
+		}
+
+		// We do not want anyone to copy these around willy-nilly
+		// Will likely break people, but also will probably get rid of quiet bugs that have
+		// been lurking. (E.g., Vanilla Lua will just quietly discard over-pops and under-pops:
+		// LuaJIT and other Lua engines will implode and segfault at random later times.)
+		protected_function_result(const protected_function_result&) = delete;
+		protected_function_result& operator=(const protected_function_result&) = delete;
+
+		protected_function_result(protected_function_result&& o) noexcept
+		: L(o.L), index(o.index), returncount(o.returncount), popcount(o.popcount), err(o.err) {
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but we will be thorough
+			o.abandon();
+		}
+		protected_function_result& operator=(protected_function_result&& o) noexcept {
+			L = o.L;
+			index = o.index;
+			returncount = o.returncount;
+			popcount = o.popcount;
+			err = o.err;
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but we will be thorough
+			o.abandon();
+			return *this;
+		}
+
+		protected_function_result(const unsafe_function_result& o) = delete;
+		protected_function_result& operator=(const unsafe_function_result& o) = delete;
+		protected_function_result(unsafe_function_result&& o) noexcept;
+		protected_function_result& operator=(unsafe_function_result&& o) noexcept;
+
+		call_status status() const noexcept {
+			return err;
+		}
+
+		bool valid() const noexcept {
+			return status() == call_status::ok || status() == call_status::yielded;
+		}
+
+		template <typename T>
+		decltype(auto) get(int index_offset = 0) const {
+			using UT = meta::unqualified_t<T>;
+			int target = index + index_offset;
+			if constexpr (meta::is_optional_v<UT>) {
+				using ValueType = typename UT::value_type;
+				if constexpr (std::is_same_v<ValueType, error>) {
+					if (valid()) {
+						return UT();
+					}
+					return UT(error(detail::direct_error, stack::get<std::string>(L, target)));
+				}
+				else {
+					if (!valid()) {
+						return UT();
+					}
+					return stack::get<UT>(L, target);
+				}
+			}
+			else {
+				if constexpr (std::is_same_v<T, error>) {
+#if SOL_IS_ON(SOL_SAFE_PROXIES_I_)
+					if (valid()) {
+						type t = type_of(L, target);
+						type_panic_c_str(L, target, t, type::none, "bad get from protected_function_result (is an error)");
+					}
+#endif // Check Argument Safety
+					return error(detail::direct_error, stack::get<std::string>(L, target));
+				}
+				else {
+#if SOL_IS_ON(SOL_SAFE_PROXIES_I_)
+					if (!valid()) {
+						type t = type_of(L, target);
+						type_panic_c_str(L, target, t, type::none, "bad get from protected_function_result (is not an error)");
+					}
+#endif // Check Argument Safety
+					return stack::get<T>(L, target);
+				}
+			}
+		}
+
+		type get_type(int index_offset = 0) const noexcept {
+			return type_of(L, index + static_cast<int>(index_offset));
+		}
+
+		stack_proxy operator[](difference_type index_offset) const {
+			return stack_proxy(L, index + static_cast<int>(index_offset));
+		}
+
+		iterator begin() {
+			return iterator(L, index, stack_index() + return_count());
+		}
+		iterator end() {
+			return iterator(L, stack_index() + return_count(), stack_index() + return_count());
+		}
+		const_iterator begin() const {
+			return const_iterator(L, index, stack_index() + return_count());
+		}
+		const_iterator end() const {
+			return const_iterator(L, stack_index() + return_count(), stack_index() + return_count());
+		}
+		const_iterator cbegin() const {
+			return begin();
+		}
+		const_iterator cend() const {
+			return end();
+		}
+
+		reverse_iterator rbegin() {
+			return std::reverse_iterator<iterator>(begin());
+		}
+		reverse_iterator rend() {
+			return std::reverse_iterator<iterator>(end());
+		}
+		const_reverse_iterator rbegin() const {
+			return std::reverse_iterator<const_iterator>(begin());
+		}
+		const_reverse_iterator rend() const {
+			return std::reverse_iterator<const_iterator>(end());
+		}
+		const_reverse_iterator crbegin() const {
+			return std::reverse_iterator<const_iterator>(cbegin());
+		}
+		const_reverse_iterator crend() const {
+			return std::reverse_iterator<const_iterator>(cend());
+		}
+
+		lua_State* lua_state() const noexcept {
+			return L;
+		};
+		int stack_index() const noexcept {
+			return index;
+		};
+		int return_count() const noexcept {
+			return returncount;
+		};
+		int pop_count() const noexcept {
+			return popcount;
+		};
+		void abandon() noexcept {
+			// L = nullptr;
+			index = 0;
+			returncount = 0;
+			popcount = 0;
+			err = call_status::runtime;
+		}
+		~protected_function_result() {
+			stack::remove(L, index, popcount);
+		}
+	};
+
+	namespace stack {
+		template <>
+		struct unqualified_pusher<protected_function_result> {
+			static int push(lua_State* L, const protected_function_result& pfr) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+				luaL_checkstack(L, static_cast<int>(pfr.pop_count()), detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+				int p = 0;
+				for (int i = 0; i < pfr.pop_count(); ++i) {
+					lua_pushvalue(L, i + pfr.stack_index());
+					++p;
+				}
+				return p;
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/protected_function_result.hpp
+
+// beginning of sol/unsafe_function_result.hpp
+
+#include <cstdint>
+
+namespace sol {
+	struct unsafe_function_result : public proxy_base<unsafe_function_result> {
+	private:
+		lua_State* L;
+		int index;
+		int returncount;
+
+	public:
+		typedef stack_proxy reference_type;
+		typedef stack_proxy value_type;
+		typedef stack_proxy* pointer;
+		typedef std::ptrdiff_t difference_type;
+		typedef std::size_t size_type;
+		typedef stack_iterator<stack_proxy, false> iterator;
+		typedef stack_iterator<stack_proxy, true> const_iterator;
+		typedef std::reverse_iterator<iterator> reverse_iterator;
+		typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+		unsafe_function_result() noexcept = default;
+		unsafe_function_result(lua_State* Ls, int idx = -1, int retnum = 0) noexcept : L(Ls), index(idx), returncount(retnum) {
+		}
+
+		// We do not want anyone to copy these around willy-nilly
+		// Will likely break people, but also will probably get rid of quiet bugs that have
+		// been lurking. (E.g., Vanilla Lua will just quietly discard over-pops and under-pops:
+		// LuaJIT and other Lua engines will implode and segfault at random later times.)
+		unsafe_function_result(const unsafe_function_result&) = delete;
+		unsafe_function_result& operator=(const unsafe_function_result&) = delete;
+
+		unsafe_function_result(unsafe_function_result&& o) noexcept : L(o.L), index(o.index), returncount(o.returncount) {
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but will be thorough
+			o.abandon();
+		}
+		unsafe_function_result& operator=(unsafe_function_result&& o) noexcept {
+			L = o.L;
+			index = o.index;
+			returncount = o.returncount;
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but will be thorough
+			o.abandon();
+			return *this;
+		}
+
+		unsafe_function_result(const protected_function_result& o) = delete;
+		unsafe_function_result& operator=(const protected_function_result& o) = delete;
+		unsafe_function_result(protected_function_result&& o) noexcept;
+		unsafe_function_result& operator=(protected_function_result&& o) noexcept;
+
+		template <typename T>
+		decltype(auto) get(difference_type index_offset = 0) const {
+			return stack::get<T>(L, index + static_cast<int>(index_offset));
+		}
+
+		type get_type(difference_type index_offset = 0) const noexcept {
+			return type_of(L, index + static_cast<int>(index_offset));
+		}
+
+		stack_proxy operator[](difference_type index_offset) const {
+			return stack_proxy(L, index + static_cast<int>(index_offset));
+		}
+
+		iterator begin() {
+			return iterator(L, index, stack_index() + return_count());
+		}
+		iterator end() {
+			return iterator(L, stack_index() + return_count(), stack_index() + return_count());
+		}
+		const_iterator begin() const {
+			return const_iterator(L, index, stack_index() + return_count());
+		}
+		const_iterator end() const {
+			return const_iterator(L, stack_index() + return_count(), stack_index() + return_count());
+		}
+		const_iterator cbegin() const {
+			return begin();
+		}
+		const_iterator cend() const {
+			return end();
+		}
+
+		reverse_iterator rbegin() {
+			return std::reverse_iterator<iterator>(begin());
+		}
+		reverse_iterator rend() {
+			return std::reverse_iterator<iterator>(end());
+		}
+		const_reverse_iterator rbegin() const {
+			return std::reverse_iterator<const_iterator>(begin());
+		}
+		const_reverse_iterator rend() const {
+			return std::reverse_iterator<const_iterator>(end());
+		}
+		const_reverse_iterator crbegin() const {
+			return std::reverse_iterator<const_iterator>(cbegin());
+		}
+		const_reverse_iterator crend() const {
+			return std::reverse_iterator<const_iterator>(cend());
+		}
+
+		call_status status() const noexcept {
+			return call_status::ok;
+		}
+
+		bool valid() const noexcept {
+			return status() == call_status::ok || status() == call_status::yielded;
+		}
+
+		lua_State* lua_state() const {
+			return L;
+		};
+		int stack_index() const {
+			return index;
+		};
+		int return_count() const {
+			return returncount;
+		};
+		void abandon() noexcept {
+			// L = nullptr;
+			index = 0;
+			returncount = 0;
+		}
+		~unsafe_function_result() {
+			lua_pop(L, returncount);
+		}
+	};
+
+	namespace stack {
+		template <>
+		struct unqualified_pusher<unsafe_function_result> {
+			static int push(lua_State* L, const unsafe_function_result& fr) {
+				int p = 0;
+				for (int i = 0; i < fr.return_count(); ++i) {
+					lua_pushvalue(L, i + fr.stack_index());
+					++p;
+				}
+				return p;
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/unsafe_function_result.hpp
+
+#include <cstdint>
+
+namespace sol {
+
+	namespace detail {
+		template <>
+		struct is_speshul<unsafe_function_result> : std::true_type {};
+		template <>
+		struct is_speshul<protected_function_result> : std::true_type {};
+
+		template <std::size_t I, typename... Args, typename T>
+		stack_proxy get(types<Args...>, meta::index_value<0>, meta::index_value<I>, const T& fr) {
+			return stack_proxy(fr.lua_state(), static_cast<int>(fr.stack_index() + I));
+		}
+
+		template <std::size_t I, std::size_t N, typename Arg, typename... Args, typename T, meta::enable<meta::boolean<(N > 0)>> = meta::enabler>
+		stack_proxy get(types<Arg, Args...>, meta::index_value<N>, meta::index_value<I>, const T& fr) {
+			return get(types<Args...>(), meta::index_value<N - 1>(), meta::index_value<I + lua_size<Arg>::value>(), fr);
+		}
+	} // namespace detail
+
+	template <>
+	struct tie_size<unsafe_function_result> : std::integral_constant<std::size_t, SIZE_MAX> {};
+
+	template <>
+	struct tie_size<protected_function_result> : std::integral_constant<std::size_t, SIZE_MAX> {};
+
+	template <std::size_t I>
+	stack_proxy get(const unsafe_function_result& fr) {
+		return stack_proxy(fr.lua_state(), static_cast<int>(fr.stack_index() + I));
+	}
+
+	template <std::size_t I, typename... Args>
+	stack_proxy get(types<Args...> t, const unsafe_function_result& fr) {
+		return detail::get(t, meta::index_value<I>(), meta::index_value<0>(), fr);
+	}
+
+	template <std::size_t I>
+	stack_proxy get(const protected_function_result& fr) {
+		return stack_proxy(fr.lua_state(), static_cast<int>(fr.stack_index() + I));
+	}
+
+	template <std::size_t I, typename... Args>
+	stack_proxy get(types<Args...> t, const protected_function_result& fr) {
+		return detail::get(t, meta::index_value<I>(), meta::index_value<0>(), fr);
+	}
+} // namespace sol
+
+// end of sol/function_result.hpp
+
+// beginning of sol/function_types.hpp
+
+// beginning of sol/function_types_core.hpp
+
+// beginning of sol/wrapper.hpp
+
+namespace sol {
+
+	namespace detail {
+		template <typename T>
+		using array_return_type = meta::conditional_t<std::is_array<T>::value, std::add_lvalue_reference_t<T>, T>;
+	}
+
+	template <typename F, typename = void>
+	struct wrapper {
+		typedef lua_bind_traits<meta::unqualified_t<F>> traits_type;
+		typedef typename traits_type::args_list args_list;
+		typedef typename traits_type::args_list free_args_list;
+		typedef typename traits_type::returns_list returns_list;
+
+		template <typename... Args>
+		static decltype(auto) call(F& f, Args&&... args) {
+			return f(std::forward<Args>(args)...);
+		}
+
+		struct caller {
+			template <typename... Args>
+			decltype(auto) operator()(F& fx, Args&&... args) const {
+				return call(fx, std::forward<Args>(args)...);
+			}
+		};
+	};
+
+	template <typename F>
+	struct wrapper<F, std::enable_if_t<std::is_function<std::remove_pointer_t<meta::unqualified_t<F>>>::value>> {
+		typedef lua_bind_traits<std::remove_pointer_t<meta::unqualified_t<F>>> traits_type;
+		typedef typename traits_type::args_list args_list;
+		typedef typename traits_type::args_list free_args_list;
+		typedef typename traits_type::returns_list returns_list;
+
+		template <F fx, typename... Args>
+		static decltype(auto) invoke(Args&&... args) {
+			return fx(std::forward<Args>(args)...);
+		}
+
+		template <typename... Args>
+		static decltype(auto) call(F& fx, Args&&... args) {
+			return fx(std::forward<Args>(args)...);
+		}
+
+		struct caller {
+			template <typename... Args>
+			decltype(auto) operator()(F& fx, Args&&... args) const {
+				return call(fx, std::forward<Args>(args)...);
+			}
+		};
+
+		template <F fx>
+		struct invoker {
+			template <typename... Args>
+			decltype(auto) operator()(Args&&... args) const {
+				return invoke<fx>(std::forward<Args>(args)...);
+			}
+		};
+	};
+
+	template <typename F>
+	struct wrapper<F, std::enable_if_t<std::is_member_object_pointer<meta::unqualified_t<F>>::value>> {
+		typedef lua_bind_traits<meta::unqualified_t<F>> traits_type;
+		typedef typename traits_type::object_type object_type;
+		typedef typename traits_type::return_type return_type;
+		typedef typename traits_type::args_list args_list;
+		typedef types<object_type&, return_type> free_args_list;
+		typedef typename traits_type::returns_list returns_list;
+
+		template <F fx>
+		static auto call(object_type& mem) -> detail::array_return_type<decltype(mem.*fx)> {
+			return mem.*fx;
+		}
+
+		template <F fx, typename Arg, typename... Args>
+		static decltype(auto) invoke(object_type& mem, Arg&& arg, Args&&...) {
+			return mem.*fx = std::forward<Arg>(arg);
+		}
+
+		template <typename Fx>
+		static auto call(Fx&& fx, object_type& mem) -> detail::array_return_type<decltype(mem.*fx)> {
+			return mem.*fx;
+		}
+
+		template <typename Fx, typename Arg, typename... Args>
+		static void call(Fx&& fx, object_type& mem, Arg&& arg, Args&&...) {
+			using actual_type = meta::unqualified_t<detail::array_return_type<decltype(mem.*fx)>>;
+			if constexpr (std::is_array_v<actual_type>) {
+				using std::cbegin;
+				using std::cend;
+				auto first = cbegin(arg);
+				auto last = cend(arg);
+				for (std::size_t i = 0; first != last; ++i, ++first) {
+					(mem.*fx)[i] = *first;
+				}
+			}
+			else {
+				(mem.*fx) = std::forward<Arg>(arg);
+			}
+		}
+
+		struct caller {
+			template <typename Fx, typename... Args>
+			decltype(auto) operator()(Fx&& fx, object_type& mem, Args&&... args) const {
+				return call(std::forward<Fx>(fx), mem, std::forward<Args>(args)...);
+			}
+		};
+
+		template <F fx>
+		struct invoker {
+			template <typename... Args>
+			decltype(auto) operator()(Args&&... args) const {
+				return invoke<fx>(std::forward<Args>(args)...);
+			}
+		};
+	};
+
+	template <typename F, typename R, typename O, typename... FArgs>
+	struct member_function_wrapper {
+		typedef O object_type;
+		typedef lua_bind_traits<F> traits_type;
+		typedef typename traits_type::args_list args_list;
+		typedef types<object_type&, FArgs...> free_args_list;
+		typedef meta::tuple_types<R> returns_list;
+
+		template <F fx, typename... Args>
+		static R invoke(O& mem, Args&&... args) {
+			return (mem.*fx)(std::forward<Args>(args)...);
+		}
+
+		template <typename Fx, typename... Args>
+		static R call(Fx&& fx, O& mem, Args&&... args) {
+			return (mem.*fx)(std::forward<Args>(args)...);
+		}
+
+		struct caller {
+			template <typename Fx, typename... Args>
+			decltype(auto) operator()(Fx&& fx, O& mem, Args&&... args) const {
+				return call(std::forward<Fx>(fx), mem, std::forward<Args>(args)...);
+			}
+		};
+
+		template <F fx>
+		struct invoker {
+			template <typename... Args>
+			decltype(auto) operator()(O& mem, Args&&... args) const {
+				return invoke<fx>(mem, std::forward<Args>(args)...);
+			}
+		};
+	};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...)> : public member_function_wrapper<R (O::*)(Args...), R, O, Args...> {};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const> : public member_function_wrapper<R (O::*)(Args...) const, R, O, Args...> {};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const volatile> : public member_function_wrapper<R (O::*)(Args...) const volatile, R, O, Args...> {};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...)&> : public member_function_wrapper<R (O::*)(Args...)&, R, O, Args...> {};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const&> : public member_function_wrapper<R (O::*)(Args...) const&, R, O, Args...> {};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const volatile&> : public member_function_wrapper<R (O::*)(Args...) const volatile&, R, O, Args...> {};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...)&> : public member_function_wrapper<R (O::*)(Args..., ...)&, R, O, Args...> {};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const&> : public member_function_wrapper<R (O::*)(Args..., ...) const&, R, O, Args...> {};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const volatile&> : public member_function_wrapper<R (O::*)(Args..., ...) const volatile&, R, O, Args...> {};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) &&> : public member_function_wrapper<R (O::*)(Args...)&, R, O, Args...> {};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const&&> : public member_function_wrapper<R (O::*)(Args...) const&, R, O, Args...> {};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const volatile&&> : public member_function_wrapper<R (O::*)(Args...) const volatile&, R, O, Args...> {};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) &&> : public member_function_wrapper<R (O::*)(Args..., ...)&, R, O, Args...> {};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const&&> : public member_function_wrapper<R (O::*)(Args..., ...) const&, R, O, Args...> {};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const volatile&&> : public member_function_wrapper<R (O::*)(Args..., ...) const volatile&, R, O, Args...> {};
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_)
+	// noexcept has become a part of a function's type
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) noexcept> : public member_function_wrapper<R (O::*)(Args...) noexcept, R, O, Args...> {};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const noexcept> : public member_function_wrapper<R (O::*)(Args...) const noexcept, R, O, Args...> {};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const volatile noexcept> : public member_function_wrapper<R (O::*)(Args...) const volatile noexcept, R, O, Args...> {};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) & noexcept> : public member_function_wrapper<R (O::*)(Args...) & noexcept, R, O, Args...> {};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const& noexcept> : public member_function_wrapper<R (O::*)(Args...) const& noexcept, R, O, Args...> {};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const volatile& noexcept> : public member_function_wrapper<R (O::*)(Args...) const volatile& noexcept, R, O, Args...> {};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) & noexcept> : public member_function_wrapper<R (O::*)(Args..., ...) & noexcept, R, O, Args...> {};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const& noexcept> : public member_function_wrapper<R (O::*)(Args..., ...) const& noexcept, R, O, Args...> {};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const volatile& noexcept>
+	: public member_function_wrapper<R (O::*)(Args..., ...) const volatile& noexcept, R, O, Args...> {};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) && noexcept> : public member_function_wrapper<R (O::*)(Args...) & noexcept, R, O, Args...> {};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const&& noexcept> : public member_function_wrapper<R (O::*)(Args...) const& noexcept, R, O, Args...> {};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const volatile&& noexcept> : public member_function_wrapper<R (O::*)(Args...) const volatile& noexcept, R, O, Args...> {};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) && noexcept> : public member_function_wrapper<R (O::*)(Args..., ...) & noexcept, R, O, Args...> {};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const&& noexcept> : public member_function_wrapper<R (O::*)(Args..., ...) const& noexcept, R, O, Args...> {};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const volatile&& noexcept>
+	: public member_function_wrapper<R (O::*)(Args..., ...) const volatile& noexcept, R, O, Args...> {};
+
+#endif // noexcept is part of a function's type
+
+} // namespace sol
+
+// end of sol/wrapper.hpp
+
+#include <memory>
+
+namespace sol {
+namespace function_detail {
+	template <typename Fx, int start = 1, bool is_yielding = false>
+	int call(lua_State* L) {
+		Fx& fx = stack::get<user<Fx>>(L, upvalue_index(start));
+		int nr = fx(L);
+		if (is_yielding) {
+			return lua_yield(L, nr);
+		}
+		else {
+			return nr;
+		}
+	}
+}
+} // namespace sol::function_detail
+
+// end of sol/function_types_core.hpp
+
+// beginning of sol/function_types_templated.hpp
+
+// beginning of sol/call.hpp
+
+// beginning of sol/property.hpp
+
+#include <type_traits>
+#include <utility>
+
+namespace sol {
+	namespace detail {
+		struct no_prop {};
+	}
+
+	template <typename R, typename W>
+	struct property_wrapper : detail::ebco<R, 0>, detail::ebco<W, 1> {
+	private:
+		using read_base_t = detail::ebco<R, 0>;
+		using write_base_t = detail::ebco<W, 1>;
+
+	public:
+		template <typename Rx, typename Wx>
+		property_wrapper(Rx&& r, Wx&& w)
+		: read_base_t(std::forward<Rx>(r)), write_base_t(std::forward<Wx>(w)) {
+		}
+
+		W& write() {
+			return write_base_t::value();
+		}
+
+		const W& write() const {
+			return write_base_t::value();
+		}
+
+		R& read() {
+			return read_base_t::value();
+		}
+
+		const R& read() const {
+			return read_base_t::value();
+		}
+	};
+
+	template <typename F, typename G>
+	inline decltype(auto) property(F&& f, G&& g) {
+		typedef lua_bind_traits<meta::unqualified_t<F>> left_traits;
+		typedef lua_bind_traits<meta::unqualified_t<G>> right_traits;
+		if constexpr (left_traits::free_arity < right_traits::free_arity) {
+			return property_wrapper<std::decay_t<F>, std::decay_t<G>>(std::forward<F>(f), std::forward<G>(g));
+		}
+		else {
+			return property_wrapper<std::decay_t<G>, std::decay_t<F>>(std::forward<G>(g), std::forward<F>(f));
+		}
+	}
+
+	template <typename F>
+	inline decltype(auto) property(F&& f) {
+		typedef lua_bind_traits<meta::unqualified_t<F>> left_traits;
+		if constexpr (left_traits::free_arity < 2) {
+			return property_wrapper<std::decay_t<F>, detail::no_prop>(std::forward<F>(f), detail::no_prop());
+		}
+		else {
+			return property_wrapper<detail::no_prop, std::decay_t<F>>(detail::no_prop(), std::forward<F>(f));
+		}
+	}
+
+	template <typename F>
+	inline decltype(auto) readonly_property(F&& f) {
+		return property_wrapper<std::decay_t<F>, detail::no_prop>(std::forward<F>(f), detail::no_prop());
+	}
+
+	template <typename F>
+	inline decltype(auto) writeonly_property(F&& f) {
+		return property_wrapper<detail::no_prop, std::decay_t<F>>(detail::no_prop(), std::forward<F>(f));
+	}
+
+	template <typename T>
+	struct readonly_wrapper : detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		using base_t::base_t;
+
+		operator T&() {
+			return base_t::value();
+		}
+		operator const T&() const {
+			return base_t::value();
+		}
+	};
+
+	// Allow someone to make a member variable readonly (const)
+	template <typename R, typename T>
+	inline auto readonly(R T::*v) {
+		return readonly_wrapper<meta::unqualified_t<decltype(v)>>(v);
+	}
+
+	template <typename T>
+	struct var_wrapper : detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		using base_t::base_t;
+	};
+
+	template <typename V>
+	inline auto var(V&& v) {
+		typedef std::decay_t<V> T;
+		return var_wrapper<T>(std::forward<V>(v));
+	}
+
+	namespace meta {
+		template <typename T>
+		struct is_member_object : std::is_member_object_pointer<T> {};
+
+		template <typename T>
+		struct is_member_object<readonly_wrapper<T>> : std::true_type {};
+
+		template <typename T>
+		inline constexpr bool is_member_object_v = is_member_object<T>::value;
+	} // namespace meta
+
+} // namespace sol
+
+// end of sol/property.hpp
+
+// beginning of sol/protect.hpp
+
+#include <utility>
+
+namespace sol {
+
+	template <typename T>
+	struct protect_t {
+		T value;
+
+		template <typename Arg, typename... Args, meta::disable<std::is_same<protect_t, meta::unqualified_t<Arg>>> = meta::enabler>
+		protect_t(Arg&& arg, Args&&... args)
+		: value(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+
+		protect_t(const protect_t&) = default;
+		protect_t(protect_t&&) = default;
+		protect_t& operator=(const protect_t&) = default;
+		protect_t& operator=(protect_t&&) = default;
+	};
+
+	template <typename T>
+	auto protect(T&& value) {
+		return protect_t<std::decay_t<T>>(std::forward<T>(value));
+	}
+
+} // namespace sol
+
+// end of sol/protect.hpp
+
+namespace sol {
+	namespace u_detail {
+
+	} // namespace u_detail
+
+	namespace policy_detail {
+		template <int I, int... In>
+		inline void handle_policy(static_stack_dependencies<I, In...>, lua_State* L, int&) {
+			if constexpr (sizeof...(In) == 0) {
+				(void)L;
+				return;
+			}
+			else {
+				absolute_index ai(L, I);
+				if (type_of(L, ai) != type::userdata) {
+					return;
+				}
+				lua_createtable(L, static_cast<int>(sizeof...(In)), 0);
+				stack_reference deps(L, -1);
+				auto per_dep = [&L, &deps](int i) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+					luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+					lua_pushvalue(L, i);
+					luaL_ref(L, deps.stack_index());
+				};
+				(void)per_dep;
+				(void)detail::swallow{ int(), (per_dep(In), int())... };
+				lua_setuservalue(L, ai);
+			}
+		}
+
+		template <int... In>
+		inline void handle_policy(returns_self_with<In...>, lua_State* L, int& pushed) {
+			pushed = stack::push(L, raw_index(1));
+			handle_policy(static_stack_dependencies<-1, In...>(), L, pushed);
+		}
+
+		inline void handle_policy(const stack_dependencies& sdeps, lua_State* L, int&) {
+			absolute_index ai(L, sdeps.target);
+			if (type_of(L, ai) != type::userdata) {
+				return;
+			}
+			lua_createtable(L, static_cast<int>(sdeps.size()), 0);
+			stack_reference deps(L, -1);
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+			luaL_checkstack(L, static_cast<int>(sdeps.size()), detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			for (std::size_t i = 0; i < sdeps.size(); ++i) {
+				lua_pushvalue(L, sdeps.stack_indices[i]);
+				luaL_ref(L, deps.stack_index());
+			}
+			lua_setuservalue(L, ai);
+		}
+
+		template <typename P, meta::disable<std::is_base_of<detail::policy_base_tag, meta::unqualified_t<P>>> = meta::enabler>
+		inline void handle_policy(P&& p, lua_State* L, int& pushed) {
+			pushed = std::forward<P>(p)(L, pushed);
+		}
+	} // namespace policy_detail
+
+	namespace function_detail {
+		inline int no_construction_error(lua_State* L) {
+			return luaL_error(L, "sol: cannot call this constructor (tagged as non-constructible)");
+		}
+	} // namespace function_detail
+
+	namespace call_detail {
+
+		template <typename R, typename W>
+		inline auto& pick(std::true_type, property_wrapper<R, W>& f) {
+			return f.read();
+		}
+
+		template <typename R, typename W>
+		inline auto& pick(std::false_type, property_wrapper<R, W>& f) {
+			return f.write();
+		}
+
+		template <typename T, typename List>
+		struct void_call : void_call<T, meta::function_args_t<List>> {};
+
+		template <typename T, typename... Args>
+		struct void_call<T, types<Args...>> {
+			static void call(Args...) {
+			}
+		};
+
+		template <typename T, bool checked, bool clean_stack>
+		struct constructor_match {
+			T* obj_;
+
+			constructor_match(T* o) : obj_(o) {
+			}
+
+			template <typename Fx, std::size_t I, typename... R, typename... Args>
+			int operator()(types<Fx>, meta::index_value<I>, types<R...> r, types<Args...> a, lua_State* L, int, int start) const {
+				detail::default_construct func{};
+				return stack::call_into_lua<checked, clean_stack>(r, a, L, start, func, obj_);
+			}
+		};
+
+		namespace overload_detail {
+			template <std::size_t... M, typename Match, typename... Args>
+			inline int overload_match_arity(types<>, std::index_sequence<>, std::index_sequence<M...>, Match&&, lua_State* L, int, int, Args&&...) {
+				return luaL_error(L, "sol: no matching function call takes this number of arguments and the specified types");
+			}
+
+			template <typename Fx, typename... Fxs, std::size_t I, std::size_t... In, std::size_t... M, typename Match, typename... Args>
+			inline int overload_match_arity(types<Fx, Fxs...>, std::index_sequence<I, In...>, std::index_sequence<M...>, Match&& matchfx, lua_State* L,
+			     int fxarity, int start, Args&&... args) {
+				typedef lua_bind_traits<meta::unwrap_unqualified_t<Fx>> traits;
+				typedef meta::tuple_types<typename traits::return_type> return_types;
+				typedef typename traits::free_args_list args_list;
+				// compile-time eliminate any functions that we know ahead of time are of improper arity
+				if constexpr (!traits::runtime_variadics_t::value
+				     && meta::find_in_pack_v<meta::index_value<traits::free_arity>, meta::index_value<M>...>::value) {
+					return overload_match_arity(types<Fxs...>(),
+					     std::index_sequence<In...>(),
+					     std::index_sequence<M...>(),
+					     std::forward<Match>(matchfx),
+					     L,
+					     fxarity,
+					     start,
+					     std::forward<Args>(args)...);
+				}
+				else {
+					if constexpr (!traits::runtime_variadics_t::value) {
+						if (traits::free_arity != fxarity) {
+							return overload_match_arity(types<Fxs...>(),
+							     std::index_sequence<In...>(),
+							     std::index_sequence<traits::free_arity, M...>(),
+							     std::forward<Match>(matchfx),
+							     L,
+							     fxarity,
+							     start,
+							     std::forward<Args>(args)...);
+						}
+					}
+					stack::record tracking{};
+					if (!stack::stack_detail::check_types(args_list(), L, start, no_panic, tracking)) {
+						return overload_match_arity(types<Fxs...>(),
+						     std::index_sequence<In...>(),
+						     std::index_sequence<M...>(),
+						     std::forward<Match>(matchfx),
+						     L,
+						     fxarity,
+						     start,
+						     std::forward<Args>(args)...);
+					}
+					return matchfx(types<Fx>(), meta::index_value<I>(), return_types(), args_list(), L, fxarity, start, std::forward<Args>(args)...);
+				}
+			}
+
+			template <std::size_t... M, typename Match, typename... Args>
+			inline int overload_match_arity_single(
+			     types<>, std::index_sequence<>, std::index_sequence<M...>, Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
+				return overload_match_arity(types<>(),
+				     std::index_sequence<>(),
+				     std::index_sequence<M...>(),
+				     std::forward<Match>(matchfx),
+				     L,
+				     fxarity,
+				     start,
+				     std::forward<Args>(args)...);
+			}
+
+			template <typename Fx, std::size_t I, std::size_t... M, typename Match, typename... Args>
+			inline int overload_match_arity_single(
+			     types<Fx>, std::index_sequence<I>, std::index_sequence<M...>, Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
+				typedef lua_bind_traits<meta::unwrap_unqualified_t<Fx>> traits;
+				typedef meta::tuple_types<typename traits::return_type> return_types;
+				typedef typename traits::free_args_list args_list;
+				// compile-time eliminate any functions that we know ahead of time are of improper arity
+				if constexpr (!traits::runtime_variadics_t::value
+				     && meta::find_in_pack_v<meta::index_value<traits::free_arity>, meta::index_value<M>...>::value) {
+					return overload_match_arity(types<>(),
+					     std::index_sequence<>(),
+					     std::index_sequence<M...>(),
+					     std::forward<Match>(matchfx),
+					     L,
+					     fxarity,
+					     start,
+					     std::forward<Args>(args)...);
+				}
+				if constexpr (!traits::runtime_variadics_t::value) {
+					if (traits::free_arity != fxarity) {
+						return overload_match_arity(types<>(),
+						     std::index_sequence<>(),
+						     std::index_sequence<traits::free_arity, M...>(),
+						     std::forward<Match>(matchfx),
+						     L,
+						     fxarity,
+						     start,
+						     std::forward<Args>(args)...);
+					}
+				}
+				return matchfx(types<Fx>(), meta::index_value<I>(), return_types(), args_list(), L, fxarity, start, std::forward<Args>(args)...);
+			}
+
+			template <typename Fx, typename Fx1, typename... Fxs, std::size_t I, std::size_t I1, std::size_t... In, std::size_t... M, typename Match,
+			     typename... Args>
+			inline int overload_match_arity_single(types<Fx, Fx1, Fxs...>, std::index_sequence<I, I1, In...>, std::index_sequence<M...>, Match&& matchfx,
+			     lua_State* L, int fxarity, int start, Args&&... args) {
+				typedef lua_bind_traits<meta::unwrap_unqualified_t<Fx>> traits;
+				typedef meta::tuple_types<typename traits::return_type> return_types;
+				typedef typename traits::free_args_list args_list;
+				// compile-time eliminate any functions that we know ahead of time are of improper arity
+				if constexpr (!traits::runtime_variadics_t::value
+				     && meta::find_in_pack_v<meta::index_value<traits::free_arity>, meta::index_value<M>...>::value) {
+					return overload_match_arity(types<Fx1, Fxs...>(),
+					     std::index_sequence<I1, In...>(),
+					     std::index_sequence<M...>(),
+					     std::forward<Match>(matchfx),
+					     L,
+					     fxarity,
+					     start,
+					     std::forward<Args>(args)...);
+				}
+				else {
+					if constexpr (!traits::runtime_variadics_t::value) {
+						if (traits::free_arity != fxarity) {
+							return overload_match_arity(types<Fx1, Fxs...>(),
+							     std::index_sequence<I1, In...>(),
+							     std::index_sequence<traits::free_arity, M...>(),
+							     std::forward<Match>(matchfx),
+							     L,
+							     fxarity,
+							     start,
+							     std::forward<Args>(args)...);
+						}
+					}
+					stack::record tracking{};
+					if (!stack::stack_detail::check_types(args_list(), L, start, no_panic, tracking)) {
+						return overload_match_arity(types<Fx1, Fxs...>(),
+						     std::index_sequence<I1, In...>(),
+						     std::index_sequence<M...>(),
+						     std::forward<Match>(matchfx),
+						     L,
+						     fxarity,
+						     start,
+						     std::forward<Args>(args)...);
+					}
+					return matchfx(types<Fx>(), meta::index_value<I>(), return_types(), args_list(), L, fxarity, start, std::forward<Args>(args)...);
+				}
+			}
+		} // namespace overload_detail
+
+		template <typename... Functions, typename Match, typename... Args>
+		inline int overload_match_arity(Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
+			return overload_detail::overload_match_arity_single(types<Functions...>(),
+			     std::make_index_sequence<sizeof...(Functions)>(),
+			     std::index_sequence<>(),
+			     std::forward<Match>(matchfx),
+			     L,
+			     fxarity,
+			     start,
+			     std::forward<Args>(args)...);
+		}
+
+		template <typename... Functions, typename Match, typename... Args>
+		inline int overload_match(Match&& matchfx, lua_State* L, int start, Args&&... args) {
+			int fxarity = lua_gettop(L) - (start - 1);
+			return overload_match_arity<Functions...>(std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
+		}
+
+		template <typename T, typename... TypeLists, typename Match, typename... Args>
+		inline int construct_match(Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
+			// use same overload resolution matching as all other parts of the framework
+			return overload_match_arity<decltype(void_call<T, TypeLists>::call)...>(
+			     std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
+		}
+
+		template <typename T, bool checked, bool clean_stack, typename... TypeLists>
+		inline int construct_trampolined(lua_State* L) {
+			static const auto& meta = usertype_traits<T>::metatable();
+			int argcount = lua_gettop(L);
+			call_syntax syntax = argcount > 0 ? stack::get_call_syntax(L, usertype_traits<T>::user_metatable(), 1) : call_syntax::dot;
+			argcount -= static_cast<int>(syntax);
+
+			T* obj = detail::usertype_allocate<T>(L);
+			reference userdataref(L, -1);
+			stack::stack_detail::undefined_metatable umf(L, &meta[0], &stack::stack_detail::set_undefined_methods_on<T>);
+			umf();
+
+			// put userdata at the first index
+			lua_insert(L, 1);
+			construct_match<T, TypeLists...>(constructor_match<T, checked, clean_stack>(obj), L, argcount, 1 + static_cast<int>(syntax));
+
+			userdataref.push();
+			return 1;
+		}
+
+		template <typename T, bool checked, bool clean_stack, typename... TypeLists>
+		inline int construct(lua_State* L) {
+			return detail::static_trampoline<&construct_trampolined<T, checked, clean_stack, TypeLists...>>(L);
+		}
+
+		template <typename F, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename = void>
+		struct agnostic_lua_call_wrapper {
+			template <typename Fx, typename... Args>
+			static int call(lua_State* L, Fx&& f, Args&&... args) {
+				using uFx = meta::unqualified_t<Fx>;
+				static constexpr bool is_ref = is_lua_reference_v<uFx>;
+				if constexpr (is_ref) {
+					if constexpr (is_index) {
+						return stack::push(L, std::forward<Fx>(f), std::forward<Args>(args)...);
+					}
+					else {
+						std::forward<Fx>(f) = stack::unqualified_get<F>(L, boost + (is_variable ? 3 : 1));
+						return 0;
+					}
+				}
+				else {
+					using wrap = wrapper<uFx>;
+					using traits_type = typename wrap::traits_type;
+					using fp_t = typename traits_type::function_pointer_type;
+					constexpr bool is_function_pointer_convertible
+					     = std::is_class_v<uFx> && std::is_convertible_v<std::decay_t<Fx>, fp_t>;
+					if constexpr (is_function_pointer_convertible) {
+						fp_t fx = f;
+						return agnostic_lua_call_wrapper<fp_t, is_index, is_variable, checked, boost, clean_stack>{}.call(
+						     L, fx, std::forward<Args>(args)...);
+					}
+					else {
+						using returns_list = typename wrap::returns_list;
+						using args_list = typename wrap::free_args_list;
+						using caller = typename wrap::caller;
+						return stack::call_into_lua<checked, clean_stack>(
+						     returns_list(), args_list(), L, boost + 1, caller(), std::forward<Fx>(f), std::forward<Args>(args)...);
+					}
+				}
+			}
+		};
+
+		template <typename T, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<var_wrapper<T>, is_index, is_variable, checked, boost, clean_stack, C> {
+			template <typename F>
+			static int call(lua_State* L, F&& f) {
+				if constexpr (is_index) {
+					constexpr bool is_stack = is_stack_based_v<meta::unqualified_t<decltype(detail::unwrap(f.value()))>>;
+					if constexpr (clean_stack && !is_stack) {
+						lua_settop(L, 0);
+					}
+					return stack::push_reference(L, detail::unwrap(f.value()));
+				}
+				else {
+					if constexpr (std::is_const_v<meta::unwrapped_t<T>>) {
+						(void)f;
+						return luaL_error(L, "sol: cannot write to a readonly (const) variable");
+					}
+					else {
+						using R = meta::unwrapped_t<T>;
+						if constexpr (std::is_assignable_v<std::add_lvalue_reference_t<meta::unqualified_t<R>>, R>) {
+							detail::unwrap(f.value()) = stack::unqualified_get<meta::unwrapped_t<T>>(L, boost + (is_variable ? 3 : 1));
+							if (clean_stack) {
+								lua_settop(L, 0);
+							}
+							return 0;
+						}
+						else {
+							return luaL_error(L, "sol: cannot write to this variable: copy assignment/constructor not available");
+						}
+					}
+				}
+			}
+		};
+
+		template <bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<lua_CFunction_ref, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State* L, lua_CFunction_ref f) {
+				return f(L);
+			}
+		};
+
+		template <bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<lua_CFunction, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State* L, lua_CFunction f) {
+				return f(L);
+			}
+		};
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_)
+		template <bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<detail::lua_CFunction_noexcept, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State* L, detail::lua_CFunction_noexcept f) {
+				return f(L);
+			}
+		};
+#endif // noexcept function types
+
+		template <bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<detail::no_prop, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State* L, const detail::no_prop&) {
+				return luaL_error(L, is_index ? "sol: cannot read from a writeonly property" : "sol: cannot write to a readonly property");
+			}
+		};
+
+		template <bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<no_construction, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State* L, const no_construction&) {
+				return function_detail::no_construction_error(L);
+			}
+		};
+
+		template <typename... Args, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<bases<Args...>, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State*, const bases<Args...>&) {
+				// Uh. How did you even call this, lul
+				return 0;
+			}
+		};
+
+		template <typename T, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<std::reference_wrapper<T>, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State* L, std::reference_wrapper<T> f) {
+				agnostic_lua_call_wrapper<T, is_index, is_variable, checked, boost, clean_stack> alcw{};
+				return alcw.call(L, f.get());
+			}
+		};
+
+		template <typename T, typename F, bool is_index, bool is_variable, bool checked = detail::default_safe_function_calls, int boost = 0,
+		     bool clean_stack = true, typename = void>
+		struct lua_call_wrapper {
+			template <typename Fx, typename... Args>
+			static int call(lua_State* L, Fx&& fx, Args&&... args) {
+				if constexpr (std::is_member_function_pointer_v<F>) {
+					using wrap = wrapper<F>;
+					using object_type = typename wrap::object_type;
+					if constexpr (sizeof...(Args) < 1) {
+						using Ta = meta::conditional_t<std::is_void_v<T>, object_type, T>;
+						static_assert(std::is_base_of_v<object_type, Ta>, "It seems like you might have accidentally bound a class type with a member function method that does not correspond to the class. For example, there could be a small type in your new_usertype<T>(...) binding, where you specify one class \"T\" but then bind member methods from a complete unrelated class. Check things over!");
+#if SOL_IS_ON(SOL_SAFE_USERTYPE_I_)
+						auto maybeo = stack::check_get<Ta*>(L, 1);
+						if (!maybeo || maybeo.value() == nullptr) {
+							return luaL_error(L,
+							     "sol: received nil for 'self' argument (use ':' for accessing member functions, make sure member variables are "
+							     "preceeded by the "
+							     "actual object with '.' syntax)");
+						}
+						object_type* o = static_cast<object_type*>(maybeo.value());
+						return call(L, std::forward<Fx>(fx), *o);
+#else
+						object_type& o = static_cast<object_type&>(*stack::unqualified_get<non_null<Ta*>>(L, 1));
+						return call(L, std::forward<Fx>(fx), o);
+#endif // Safety
+					}
+					else {
+						using returns_list = typename wrap::returns_list;
+						using args_list = typename wrap::args_list;
+						using caller = typename wrap::caller;
+						return stack::call_into_lua<checked, clean_stack>(
+						     returns_list(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), std::forward<Fx>(fx), std::forward<Args>(args)...);
+					}
+				}
+				else if constexpr (std::is_member_object_pointer_v<F>) {
+					using wrap = wrapper<F>;
+					using object_type = typename wrap::object_type;
+					if constexpr (is_index) {
+						if constexpr (sizeof...(Args) < 1) {
+							using Ta = meta::conditional_t<std::is_void_v<T>, object_type, T>;
+							static_assert(std::is_base_of_v<object_type, Ta>, "It seems like you might have accidentally bound a class type with a member function method that does not correspond to the class. For example, there could be a small type in your new_usertype<T>(...) binding, where you specify one class \"T\" but then bind member methods from a complete unrelated class. Check things over!");
+#if SOL_IS_ON(SOL_SAFE_USERTYPE_I_)
+							auto maybeo = stack::check_get<Ta*>(L, 1);
+							if (!maybeo || maybeo.value() == nullptr) {
+								if (is_variable) {
+									return luaL_error(L, "sol: 'self' argument is lua_nil (bad '.' access?)");
+								}
+								return luaL_error(L, "sol: 'self' argument is lua_nil (pass 'self' as first argument)");
+							}
+							object_type* o = static_cast<object_type*>(maybeo.value());
+							return call(L, std::forward<Fx>(fx), *o);
+#else
+							object_type& o = static_cast<object_type&>(*stack::get<non_null<Ta*>>(L, 1));
+							return call(L, std::forward<Fx>(fx), o);
+#endif // Safety
+						}
+						else {
+							using returns_list = typename wrap::returns_list;
+							using caller = typename wrap::caller;
+							return stack::call_into_lua<checked, clean_stack>(returns_list(),
+							     types<>(),
+							     L,
+							     boost + (is_variable ? 3 : 2),
+							     caller(),
+							     std::forward<Fx>(fx),
+							     std::forward<Args>(args)...);
+						}
+					}
+					else {
+						using traits_type = lua_bind_traits<F>;
+						using return_type = typename traits_type::return_type;
+						constexpr bool ret_is_const = std::is_const_v<std::remove_reference_t<return_type>>;
+						if constexpr (ret_is_const) {
+							(void)fx;
+							(void)detail::swallow{ 0, (static_cast<void>(args), 0)... };
+							return luaL_error(L, "sol: cannot write to a readonly (const) variable");
+						}
+						else {
+							using u_return_type = meta::unqualified_t<return_type>;
+							constexpr bool is_assignable = std::is_copy_assignable_v<u_return_type> || std::is_array_v<u_return_type>;
+							if constexpr (!is_assignable) {
+								(void)fx;
+								(void)detail::swallow{ 0, ((void)args, 0)... };
+								return luaL_error(L, "sol: cannot write to this variable: copy assignment/constructor not available");
+							}
+							else {
+								using args_list = typename wrap::args_list;
+								using caller = typename wrap::caller;
+								if constexpr (sizeof...(Args) > 0) {
+									return stack::call_into_lua<checked, clean_stack>(types<void>(),
+									     args_list(),
+									     L,
+									     boost + (is_variable ? 3 : 2),
+									     caller(),
+									     std::forward<Fx>(fx),
+									     std::forward<Args>(args)...);
+								}
+								else {
+									using Ta = meta::conditional_t<std::is_void_v<T>, object_type, T>;
+#if SOL_IS_ON(SOL_SAFE_USERTYPE_I_)
+									auto maybeo = stack::check_get<Ta*>(L, 1);
+									if (!maybeo || maybeo.value() == nullptr) {
+										if (is_variable) {
+											return luaL_error(L, "sol: received nil for 'self' argument (bad '.' access?)");
+										}
+										return luaL_error(L, "sol: received nil for 'self' argument (pass 'self' as first argument)");
+									}
+									object_type* po = static_cast<object_type*>(maybeo.value());
+									object_type& o = *po;
+#else
+									object_type& o = static_cast<object_type&>(*stack::get<non_null<Ta*>>(L, 1));
+#endif // Safety
+
+									return stack::call_into_lua<checked, clean_stack>(
+									     types<void>(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), std::forward<Fx>(fx), o);
+								}
+							}
+						}
+					}
+				}
+				else {
+					agnostic_lua_call_wrapper<F, is_index, is_variable, checked, boost, clean_stack> alcw{};
+					return alcw.call(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+				}
+			}
+		};
+
+		template <typename T, typename F, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, readonly_wrapper<F>, is_index, is_variable, checked, boost, clean_stack, C> {
+			using traits_type = lua_bind_traits<F>;
+			using wrap = wrapper<F>;
+			using object_type = typename wrap::object_type;
+
+			static int call(lua_State* L, readonly_wrapper<F>&& rw) {
+				if constexpr (!is_index) {
+					(void)rw;
+					return luaL_error(L, "sol: cannot write to a sol::readonly variable");
+				}
+				else {
+					lua_call_wrapper<T, F, true, is_variable, checked, boost, clean_stack, C> lcw;
+					return lcw.call(L, std::move(rw.value()));
+				}
+			}
+
+			static int call(lua_State* L, readonly_wrapper<F>&& rw, object_type& o) {
+				if constexpr (!is_index) {
+					(void)o;
+					return call(L, std::move(rw));
+				}
+				else {
+					lua_call_wrapper<T, F, true, is_variable, checked, boost, clean_stack, C> lcw;
+					return lcw.call(L, rw.value(), o);
+				}
+			}
+
+			static int call(lua_State* L, const readonly_wrapper<F>& rw) {
+				if constexpr (!is_index) {
+					(void)rw;
+					return luaL_error(L, "sol: cannot write to a sol::readonly variable");
+				}
+				else {
+					lua_call_wrapper<T, F, true, is_variable, checked, boost, clean_stack, C> lcw;
+					return lcw.call(L, rw.value());
+				}
+			}
+
+			static int call(lua_State* L, const readonly_wrapper<F>& rw, object_type& o) {
+				if constexpr (!is_index) {
+					(void)o;
+					return call(L, rw);
+				}
+				else {
+					lua_call_wrapper<T, F, true, is_variable, checked, boost, clean_stack, C> lcw;
+					return lcw.call(L, rw.value(), o);
+				}
+			}
+		};
+
+		template <typename T, typename... Args, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, constructor_list<Args...>, is_index, is_variable, checked, boost, clean_stack, C> {
+			typedef constructor_list<Args...> F;
+
+			static int call(lua_State* L, F&) {
+				const auto& meta = usertype_traits<T>::metatable();
+				int argcount = lua_gettop(L);
+				call_syntax syntax = argcount > 0 ? stack::get_call_syntax(L, usertype_traits<T>::user_metatable(), 1) : call_syntax::dot;
+				argcount -= static_cast<int>(syntax);
+
+				T* obj = detail::usertype_allocate<T>(L);
+				reference userdataref(L, -1);
+				stack::stack_detail::undefined_metatable umf(L, &meta[0], &stack::stack_detail::set_undefined_methods_on<T>);
+				umf();
+
+				// put userdata at the first index
+				lua_insert(L, 1);
+				construct_match<T, Args...>(constructor_match<T, checked, clean_stack>(obj), L, argcount, boost + 1 + 1 + static_cast<int>(syntax));
+
+				userdataref.push();
+				return 1;
+			}
+		};
+
+		template <typename T, typename... Cxs, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, constructor_wrapper<Cxs...>, is_index, is_variable, checked, boost, clean_stack, C> {
+			typedef constructor_wrapper<Cxs...> F;
+
+			struct onmatch {
+				template <typename Fx, std::size_t I, typename... R, typename... Args>
+				int operator()(types<Fx>, meta::index_value<I>, types<R...> r, types<Args...> a, lua_State* L, int, int start, F& f) {
+					const auto& meta = usertype_traits<T>::metatable();
+					T* obj = detail::usertype_allocate<T>(L);
+					reference userdataref(L, -1);
+					stack::stack_detail::undefined_metatable umf(L, &meta[0], &stack::stack_detail::set_undefined_methods_on<T>);
+					umf();
+
+					auto& func = std::get<I>(f.functions);
+					// put userdata at the first index
+					lua_insert(L, 1);
+					stack::call_into_lua<checked, clean_stack>(r, a, L, boost + 1 + start, func, detail::implicit_wrapper<T>(obj));
+
+					userdataref.push();
+					return 1;
+				}
+			};
+
+			static int call(lua_State* L, F& f) {
+				call_syntax syntax = stack::get_call_syntax(L, usertype_traits<T>::user_metatable(), 1);
+				int syntaxval = static_cast<int>(syntax);
+				int argcount = lua_gettop(L) - syntaxval;
+				return construct_match<T, meta::pop_front_type_t<meta::function_args_t<Cxs>>...>(onmatch(), L, argcount, 1 + syntaxval, f);
+			}
+		};
+
+		template <typename T, typename Fx, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, destructor_wrapper<Fx>, is_index, is_variable, checked, boost, clean_stack, C> {
+
+			template <typename F>
+			static int call(lua_State* L, F&& f) {
+				if constexpr (std::is_void_v<Fx>) {
+					return detail::usertype_alloc_destruct<T>(L);
+				}
+				else {
+					using uFx = meta::unqualified_t<Fx>;
+					lua_call_wrapper<T, uFx, is_index, is_variable, checked, boost, clean_stack> lcw{};
+					return lcw.call(L, std::forward<F>(f).fx);
+				}
+			}
+		};
+
+		template <typename T, typename... Fs, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, overload_set<Fs...>, is_index, is_variable, checked, boost, clean_stack, C> {
+			typedef overload_set<Fs...> F;
+
+			struct on_match {
+				template <typename Fx, std::size_t I, typename... R, typename... Args>
+				int operator()(types<Fx>, meta::index_value<I>, types<R...>, types<Args...>, lua_State* L, int, int, F& fx) {
+					auto& f = std::get<I>(fx.functions);
+					return lua_call_wrapper<T, Fx, is_index, is_variable, checked, boost>{}.call(L, f);
+				}
+			};
+
+			static int call(lua_State* L, F& fx) {
+				return overload_match_arity<Fs...>(on_match(), L, lua_gettop(L), 1, fx);
+			}
+		};
+
+		template <typename T, typename... Fs, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, factory_wrapper<Fs...>, is_index, is_variable, checked, boost, clean_stack, C> {
+			typedef factory_wrapper<Fs...> F;
+
+			struct on_match {
+				template <typename Fx, std::size_t I, typename... R, typename... Args>
+				int operator()(types<Fx>, meta::index_value<I>, types<R...>, types<Args...>, lua_State* L, int, int, F& fx) {
+					auto& f = std::get<I>(fx.functions);
+					return lua_call_wrapper<T, Fx, is_index, is_variable, checked, boost, clean_stack>{}.call(L, f);
+				}
+			};
+
+			static int call(lua_State* L, F& fx) {
+				return overload_match_arity<Fs...>(on_match(), L, lua_gettop(L) - boost, 1 + boost, fx);
+			}
+		};
+
+		template <typename T, typename R, typename W, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, property_wrapper<R, W>, is_index, is_variable, checked, boost, clean_stack, C> {
+			typedef meta::conditional_t<is_index, R, W> P;
+			typedef meta::unqualified_t<P> U;
+			typedef wrapper<U> wrap;
+			typedef lua_bind_traits<U> traits_type;
+			typedef meta::unqualified_t<typename traits_type::template arg_at<0>> object_type;
+
+			template <typename F, typename... Args>
+			static int call(lua_State* L, F&& f, Args&&... args) {
+				constexpr bool is_specialized = meta::any<std::is_same<U, detail::no_prop>,
+				     meta::is_specialization_of<U, var_wrapper>,
+				     meta::is_specialization_of<U, constructor_wrapper>,
+				     meta::is_specialization_of<U, constructor_list>,
+				     std::is_member_pointer<U>>::value;
+				if constexpr (is_specialized) {
+					if constexpr (is_index) {
+						decltype(auto) p = f.read();
+						lua_call_wrapper<T, meta::unqualified_t<decltype(p)>, is_index, is_variable, checked, boost, clean_stack> lcw{};
+						return lcw.call(L, p, std::forward<Args>(args)...);
+					}
+					else {
+						decltype(auto) p = f.write();
+						lua_call_wrapper<T, meta::unqualified_t<decltype(p)>, is_index, is_variable, checked, boost, clean_stack> lcw{};
+						return lcw.call(L, p, std::forward<Args>(args)...);
+					}
+				}
+				else {
+					constexpr bool non_class_object_type = meta::any<std::is_void<object_type>,
+					     meta::boolean<lua_type_of<meta::unwrap_unqualified_t<object_type>>::value != type::userdata>>::value;
+					if constexpr (non_class_object_type) {
+						// The type being void means we don't have any arguments, so it might be a free functions?
+						using args_list = typename traits_type::free_args_list;
+						using returns_list = typename wrap::returns_list;
+						using caller = typename wrap::caller;
+						if constexpr (is_index) {
+							decltype(auto) pf = f.read();
+							return stack::call_into_lua<checked, clean_stack>(
+							     returns_list(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), pf);
+						}
+						else {
+							decltype(auto) pf = f.write();
+							return stack::call_into_lua<checked, clean_stack>(
+							     returns_list(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), pf);
+						}
+					}
+					else {
+						using args_list = meta::pop_front_type_t<typename traits_type::free_args_list>;
+						using Ta = T;
+						using Oa = std::remove_pointer_t<object_type>;
+#if SOL_IS_ON(SOL_SAFE_USERTYPE_I_)
+						auto maybeo = stack::check_get<Ta*>(L, 1);
+						if (!maybeo || maybeo.value() == nullptr) {
+							if (is_variable) {
+								return luaL_error(L, "sol: 'self' argument is lua_nil (bad '.' access?)");
+							}
+							return luaL_error(L, "sol: 'self' argument is lua_nil (pass 'self' as first argument)");
+						}
+						Oa* o = static_cast<Oa*>(maybeo.value());
+#else
+						Oa* o = static_cast<Oa*>(stack::get<non_null<Ta*>>(L, 1));
+#endif // Safety
+						using returns_list = typename wrap::returns_list;
+						using caller = typename wrap::caller;
+						if constexpr (is_index) {
+							decltype(auto) pf = f.read();
+							return stack::call_into_lua<checked, clean_stack>(
+							     returns_list(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), pf, detail::implicit_wrapper<Oa>(*o));
+						}
+						else {
+							decltype(auto) pf = f.write();
+							return stack::call_into_lua<checked, clean_stack>(
+							     returns_list(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), pf, detail::implicit_wrapper<Oa>(*o));
+						}
+					}
+				}
+			}
+		};
+
+		template <typename T, typename V, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, protect_t<V>, is_index, is_variable, checked, boost, clean_stack, C> {
+			typedef protect_t<V> F;
+
+			template <typename... Args>
+			static int call(lua_State* L, F& fx, Args&&... args) {
+				return lua_call_wrapper<T, V, is_index, is_variable, true, boost, clean_stack>{}.call(L, fx.value, std::forward<Args>(args)...);
+			}
+		};
+
+		template <typename T, typename F, typename... Policies, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, policy_wrapper<F, Policies...>, is_index, is_variable, checked, boost, clean_stack, C> {
+			typedef policy_wrapper<F, Policies...> P;
+
+			template <std::size_t... In>
+			static int call(std::index_sequence<In...>, lua_State* L, P& fx) {
+				int pushed = lua_call_wrapper<T, F, is_index, is_variable, checked, boost, false, C>{}.call(L, fx.value);
+				(void)detail::swallow{ int(), (policy_detail::handle_policy(std::get<In>(fx.policies), L, pushed), int())... };
+				return pushed;
+			}
+
+			static int call(lua_State* L, P& fx) {
+				typedef typename P::indices indices;
+				return call(indices(), L, fx);
+			}
+		};
+
+		template <typename T, typename Y, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, yielding_t<Y>, is_index, is_variable, checked, boost, clean_stack, C> {
+			template <typename F>
+			static int call(lua_State* L, F&& f) {
+				return lua_call_wrapper<T, meta::unqualified_t<Y>, is_index, is_variable, checked, boost, clean_stack>{}.call(L, f.func);
+			}
+		};
+
+		template <typename T, typename Sig, typename P, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, function_arguments<Sig, P>, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State* L, const function_arguments<Sig, P>& f) {
+				lua_call_wrapper<T, meta::unqualified_t<P>, is_index, is_variable, checked, boost, clean_stack> lcw{};
+				return lcw.call(L, std::get<0>(f.arguments));
+			}
+
+			static int call(lua_State* L, function_arguments<Sig, P>&& f) {
+				lua_call_wrapper<T, meta::unqualified_t<P>, is_index, is_variable, checked, boost, clean_stack> lcw{};
+				return lcw.call(L, std::get<0>(std::move(f.arguments)));
+			}
+		};
+
+		template <typename T, bool is_index, bool is_variable, int boost = 0, bool checked = detail::default_safe_function_calls, bool clean_stack = true,
+		     typename Fx, typename... Args>
+		inline int call_wrapped(lua_State* L, Fx&& fx, Args&&... args) {
+			using uFx = meta::unqualified_t<Fx>;
+			if constexpr (meta::is_specialization_of_v<uFx, yielding_t>) {
+				using real_fx = meta::unqualified_t<decltype(std::forward<Fx>(fx).func)>;
+				lua_call_wrapper<T, real_fx, is_index, is_variable, checked, boost, clean_stack> lcw{};
+				return lcw.call(L, std::forward<Fx>(fx).func, std::forward<Args>(args)...);
+			}
+			else {
+				lua_call_wrapper<T, uFx, is_index, is_variable, checked, boost, clean_stack> lcw{};
+				return lcw.call(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+		}
+
+		template <typename T, bool is_index, bool is_variable, typename F, int start = 1, bool checked = detail::default_safe_function_calls,
+		     bool clean_stack = true>
+		inline int call_user(lua_State* L) {
+			auto& fx = stack::unqualified_get<user<F>>(L, upvalue_index(start));
+			using uFx = meta::unqualified_t<F>;
+			int nr = call_wrapped<T, is_index, is_variable, 0, checked, clean_stack>(L, fx);
+			if constexpr (meta::is_specialization_of_v<uFx, yielding_t>) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		template <typename T, typename = void>
+		struct is_var_bind : std::false_type {};
+
+		template <typename T>
+		struct is_var_bind<T, std::enable_if_t<std::is_member_object_pointer<T>::value>> : std::true_type {};
+
+		template <typename T>
+		struct is_var_bind<T, std::enable_if_t<is_lua_reference_or_proxy<T>::value>> : std::true_type {};
+
+		template <>
+		struct is_var_bind<detail::no_prop> : std::true_type {};
+
+		template <typename R, typename W>
+		struct is_var_bind<property_wrapper<R, W>> : std::true_type {};
+
+		template <typename T>
+		struct is_var_bind<var_wrapper<T>> : std::true_type {};
+
+		template <typename T>
+		struct is_var_bind<readonly_wrapper<T>> : is_var_bind<meta::unqualified_t<T>> {};
+
+		template <typename F, typename... Policies>
+		struct is_var_bind<policy_wrapper<F, Policies...>> : is_var_bind<meta::unqualified_t<F>> {};
+	} // namespace call_detail
+
+	template <typename T>
+	struct is_variable_binding : call_detail::is_var_bind<meta::unqualified_t<T>> {};
+
+	template <typename T>
+	using is_var_wrapper = meta::is_specialization_of<T, var_wrapper>;
+
+	template <typename T>
+	struct is_function_binding : meta::neg<is_variable_binding<T>> {};
+
+} // namespace sol
+
+// end of sol/call.hpp
+
+namespace sol {
+	namespace function_detail {
+		template <typename F, F fx>
+		inline int call_wrapper_variable(std::false_type, lua_State* L) {
+			typedef meta::bind_traits<meta::unqualified_t<F>> traits_type;
+			typedef typename traits_type::args_list args_list;
+			typedef meta::tuple_types<typename traits_type::return_type> return_type;
+			return stack::call_into_lua(return_type(), args_list(), L, 1, fx);
+		}
+
+		template <typename R, typename V, V, typename T>
+		inline int call_set_assignable(std::false_type, T&&, lua_State* L) {
+			return luaL_error(L, "cannot write to this type: copy assignment/constructor not available");
+		}
+
+		template <typename R, typename V, V variable, typename T>
+		inline int call_set_assignable(std::true_type, lua_State* L, T&& mem) {
+			(mem.*variable) = stack::get<R>(L, 2);
+			return 0;
+		}
+
+		template <typename R, typename V, V, typename T>
+		inline int call_set_variable(std::false_type, lua_State* L, T&&) {
+			return luaL_error(L, "cannot write to a const variable");
+		}
+
+		template <typename R, typename V, V variable, typename T>
+		inline int call_set_variable(std::true_type, lua_State* L, T&& mem) {
+			return call_set_assignable<R, V, variable>(std::is_assignable<std::add_lvalue_reference_t<R>, R>(), L, std::forward<T>(mem));
+		}
+
+		template <typename V, V variable>
+		inline int call_wrapper_variable(std::true_type, lua_State* L) {
+			typedef meta::bind_traits<meta::unqualified_t<V>> traits_type;
+			typedef typename traits_type::object_type T;
+			typedef typename traits_type::return_type R;
+			auto& mem = stack::get<T>(L, 1);
+			switch (lua_gettop(L)) {
+			case 1: {
+				decltype(auto) r = (mem.*variable);
+				stack::push_reference(L, std::forward<decltype(r)>(r));
+				return 1;
+			}
+			case 2:
+				return call_set_variable<R, V, variable>(meta::neg<std::is_const<R>>(), L, mem);
+			default:
+				return luaL_error(L, "incorrect number of arguments to member variable function call");
+			}
+		}
+
+		template <typename F, F fx>
+		inline int call_wrapper_function(std::false_type, lua_State* L) {
+			return call_wrapper_variable<F, fx>(std::is_member_object_pointer<F>(), L);
+		}
+
+		template <typename F, F fx>
+		inline int call_wrapper_function(std::true_type, lua_State* L) {
+			return call_detail::call_wrapped<void, false, false>(L, fx);
+		}
+
+		template <typename F, F fx>
+		int call_wrapper_entry(lua_State* L) noexcept(meta::bind_traits<F>::is_noexcept) {
+			return call_wrapper_function<F, fx>(std::is_member_function_pointer<meta::unqualified_t<F>>(), L);
+		}
+
+		template <typename... Fxs>
+		struct c_call_matcher {
+			template <typename Fx, std::size_t I, typename R, typename... Args>
+			int operator()(types<Fx>, meta::index_value<I>, types<R>, types<Args...>, lua_State* L, int, int) const {
+				typedef meta::at_in_pack_t<I, Fxs...> target;
+				return target::call(L);
+			}
+		};
+
+		template <typename F, F fx>
+		inline int c_call_raw(std::true_type, lua_State* L) {
+			return fx(L);
+		}
+
+		template <typename F, F fx>
+		inline int c_call_raw(std::false_type, lua_State* L) {
+#ifdef __clang__
+			return detail::trampoline(L, function_detail::call_wrapper_entry<F, fx>);
+#else
+			return detail::typed_static_trampoline<decltype(&function_detail::call_wrapper_entry<F, fx>), (&function_detail::call_wrapper_entry<F, fx>)>(L);
+#endif // fuck you clang :c
+		}
+
+	} // namespace function_detail
+
+	template <typename F, F fx>
+	inline int c_call(lua_State* L) {
+		typedef meta::unqualified_t<F> Fu;
+		typedef std::integral_constant<bool,
+		     std::is_same<Fu, lua_CFunction>::value
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_)
+		          || std::is_same<Fu, detail::lua_CFunction_noexcept>::value
+#endif
+		     >
+		     is_raw;
+		return function_detail::c_call_raw<F, fx>(is_raw(), L);
+	}
+
+	template <typename F, F f>
+	struct wrap {
+		typedef F type;
+
+		static int call(lua_State* L) {
+			return c_call<type, f>(L);
+		}
+	};
+
+	template <typename... Fxs>
+	inline int c_call(lua_State* L) {
+		if constexpr (sizeof...(Fxs) < 2) {
+			using target = meta::at_in_pack_t<0, Fxs...>;
+			return target::call(L);
+		}
+		else {
+			return call_detail::overload_match_arity<typename Fxs::type...>(function_detail::c_call_matcher<Fxs...>(), L, lua_gettop(L), 1);
+		}
+	}
+
+} // namespace sol
+
+// end of sol/function_types_templated.hpp
+
+// beginning of sol/function_types_stateless.hpp
+
+namespace sol { namespace function_detail {
+	template <typename Function, bool is_yielding>
+	struct upvalue_free_function {
+		using function_type = std::remove_pointer_t<std::decay_t<Function>>;
+		using traits_type = meta::bind_traits<function_type>;
+
+		static int real_call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			auto udata = stack::stack_detail::get_as_upvalues<function_type*>(L);
+			function_type* fx = udata.first;
+			return call_detail::call_wrapped<void, true, false>(L, fx);
+		}
+
+		static int call(lua_State* L) {
+			int nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L) {
+			return call(L);
+		}
+	};
+
+	template <typename T, typename Function, bool is_yielding>
+	struct upvalue_member_function {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+		typedef lua_bind_traits<function_type> traits_type;
+
+		static int real_call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			// Layout:
+			// idx 1...n: verbatim data of member function pointer
+			// idx n + 1: is the object's void pointer
+			// We don't need to store the size, because the other side is templated
+			// with the same member function pointer type
+			function_type& memfx = stack::get<user<function_type>>(L, upvalue_index(2));
+			auto& item = *static_cast<T*>(stack::get<void*>(L, upvalue_index(3)));
+			return call_detail::call_wrapped<T, true, false, -1>(L, memfx, item);
+		}
+
+		static int call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			int nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L) {
+			return call(L);
+		}
+	};
+
+	template <typename T, typename Function, bool is_yielding>
+	struct upvalue_member_variable {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+		typedef lua_bind_traits<function_type> traits_type;
+
+		static int real_call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			// Layout:
+			// idx 1...n: verbatim data of member variable pointer
+			// idx n + 1: is the object's void pointer
+			// We don't need to store the size, because the other side is templated
+			// with the same member function pointer type
+			auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L);
+			auto objdata = stack::stack_detail::get_as_upvalues<T*>(L, memberdata.second);
+			auto& mem = *objdata.first;
+			function_type& var = memberdata.first;
+			switch (lua_gettop(L)) {
+			case 0:
+				return call_detail::call_wrapped<T, true, false, -1>(L, var, mem);
+			case 1:
+				return call_detail::call_wrapped<T, false, false, -1>(L, var, mem);
+			default:
+				return luaL_error(L, "sol: incorrect number of arguments to member variable function");
+			}
+		}
+
+		static int call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			int nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L) {
+			return call(L);
+		}
+	};
+
+	template <typename T, typename Function, bool is_yielding>
+	struct upvalue_member_variable<T, readonly_wrapper<Function>, is_yielding> {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+		typedef lua_bind_traits<function_type> traits_type;
+
+		static int real_call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			// Layout:
+			// idx 1...n: verbatim data of member variable pointer
+			// idx n + 1: is the object's void pointer
+			// We don't need to store the size, because the other side is templated
+			// with the same member function pointer type
+			auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L);
+			auto objdata = stack::stack_detail::get_as_upvalues<T*>(L, memberdata.second);
+			auto& mem = *objdata.first;
+			function_type& var = memberdata.first;
+			switch (lua_gettop(L)) {
+			case 0:
+				return call_detail::call_wrapped<T, true, false, -1>(L, var, mem);
+			default:
+				return luaL_error(L, "sol: incorrect number of arguments to member variable function");
+			}
+		}
+
+		static int call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			int nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L) {
+			return call(L);
+		}
+	};
+
+	template <typename T, typename Function, bool is_yielding>
+	struct upvalue_this_member_function {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+		typedef lua_bind_traits<function_type> traits_type;
+
+		static int real_call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			// Layout:
+			// idx 1...n: verbatim data of member variable pointer
+			function_type& memfx = stack::get<user<function_type>>(L, upvalue_index(2));
+			return call_detail::call_wrapped<T, false, false>(L, memfx);
+		}
+
+		static int call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			int nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L) {
+			return call(L);
+		}
+	};
+
+	template <typename T, typename Function, bool is_yielding>
+	struct upvalue_this_member_variable {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+
+		static int real_call(lua_State* L) noexcept(false) {
+			// Layout:
+			// idx 1...n: verbatim data of member variable pointer
+			auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L);
+			function_type& var = memberdata.first;
+			switch (lua_gettop(L)) {
+			case 1:
+				return call_detail::call_wrapped<T, true, false>(L, var);
+			case 2:
+				return call_detail::call_wrapped<T, false, false>(L, var);
+			default:
+				return luaL_error(L, "sol: incorrect number of arguments to member variable function");
+			}
+		}
+
+		static int call(lua_State* L) {
+			int nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L) {
+			return call(L);
+		}
+	};
+
+	template <typename T, typename Function, bool is_yielding>
+	struct upvalue_this_member_variable<T, readonly_wrapper<Function>, is_yielding> {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+		typedef lua_bind_traits<function_type> traits_type;
+
+		static int real_call(lua_State* L) noexcept(false) {
+			// Layout:
+			// idx 1...n: verbatim data of member variable pointer
+			auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L);
+			function_type& var = memberdata.first;
+			switch (lua_gettop(L)) {
+			case 1:
+				return call_detail::call_wrapped<T, true, false>(L, var);
+			default:
+				return luaL_error(L, "sol: incorrect number of arguments to member variable function");
+			}
+		}
+
+		static int call(lua_State* L) {
+			int nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L) {
+			return call(L);
+		}
+	};
+}} // namespace sol::function_detail
+
+// end of sol/function_types_stateless.hpp
+
+// beginning of sol/function_types_stateful.hpp
+
+namespace sol {
+namespace function_detail {
+	template <typename Func, bool is_yielding, bool no_trampoline>
+	struct functor_function {
+		typedef std::decay_t<meta::unwrap_unqualified_t<Func>> function_type;
+		function_type fx;
+
+		template <typename... Args>
+		functor_function(function_type f, Args&&... args)
+		: fx(std::move(f), std::forward<Args>(args)...) {
+		}
+
+		int call(lua_State* L) {
+			int nr = call_detail::call_wrapped<void, true, false>(L, fx);
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L) {
+			if (!no_trampoline) {
+				auto f = [&](lua_State*) -> int { return this->call(L); };
+				return detail::trampoline(L, f);
+			}
+			else {
+				return call(L);
+			}
+		}
+	};
+
+	template <typename T, typename Function, bool is_yielding>
+	struct member_function {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+		typedef meta::function_return_t<function_type> return_type;
+		typedef meta::function_args_t<function_type> args_lists;
+		function_type invocation;
+		T member;
+
+		template <typename... Args>
+		member_function(function_type f, Args&&... args)
+		: invocation(std::move(f)), member(std::forward<Args>(args)...) {
+		}
+
+		int call(lua_State* L) {
+			int nr = call_detail::call_wrapped<T, true, false, -1>(L, invocation, detail::unwrap(detail::deref(member)));
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L) {
+			auto f = [&](lua_State*) -> int { return this->call(L); };
+			return detail::trampoline(L, f);
+		}
+	};
+
+	template <typename T, typename Function, bool is_yielding>
+	struct member_variable {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+		typedef typename meta::bind_traits<function_type>::return_type return_type;
+		typedef typename meta::bind_traits<function_type>::args_list args_lists;
+		function_type var;
+		T member;
+		typedef std::add_lvalue_reference_t<meta::unwrapped_t<std::remove_reference_t<decltype(detail::deref(member))>>> M;
+
+		template <typename... Args>
+		member_variable(function_type v, Args&&... args)
+		: var(std::move(v)), member(std::forward<Args>(args)...) {
+		}
+
+		int call(lua_State* L) {
+			int nr;
+			{
+				M mem = detail::unwrap(detail::deref(member));
+				switch (lua_gettop(L)) {
+				case 0:
+					nr = call_detail::call_wrapped<T, true, false, -1>(L, var, mem);
+					break;
+				case 1:
+					nr = call_detail::call_wrapped<T, false, false, -1>(L, var, mem);
+					break;
+				default:
+					nr = luaL_error(L, "sol: incorrect number of arguments to member variable function");
+					break;
+				}
+			}
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L) {
+			auto f = [&](lua_State*) -> int { return this->call(L); };
+			return detail::trampoline(L, f);
+		}
+	};
+}
+} // namespace sol::function_detail
+
+// end of sol/function_types_stateful.hpp
+
+// beginning of sol/function_types_overloaded.hpp
+
+namespace sol {
+namespace function_detail {
+	template <int start_skew, typename... Functions>
+	struct overloaded_function {
+		typedef std::tuple<Functions...> overload_list;
+		typedef std::make_index_sequence<sizeof...(Functions)> indices;
+		overload_list overloads;
+
+		overloaded_function(overload_list set)
+		: overloads(std::move(set)) {
+		}
+
+		overloaded_function(Functions... fxs)
+		: overloads(fxs...) {
+		}
+
+		template <typename Fx, std::size_t I, typename... R, typename... Args>
+		static int call(types<Fx>, meta::index_value<I>, types<R...>, types<Args...>, lua_State* L, int, int, overload_list& ol) {
+			auto& func = std::get<I>(ol);
+			int nr = call_detail::call_wrapped<void, true, false, start_skew>(L, func);
+			return nr;
+		}
+
+		int operator()(lua_State* L) {
+			auto mfx = [](auto&&... args) { return call(std::forward<decltype(args)>(args)...); };
+			return call_detail::overload_match<Functions...>(mfx, L, 1 + start_skew, overloads);
+		}
+	};
+}
+} // namespace sol::function_detail
+
+// end of sol/function_types_overloaded.hpp
+
+// beginning of sol/resolve.hpp
+
+namespace sol {
+
+#ifndef __clang__
+	// constexpr is fine for not-clang
+
+	namespace detail {
+		template <typename R, typename... Args, typename F, typename = std::invoke_result_t<meta::unqualified_t<F>, Args...>>
+		inline constexpr auto resolve_i(types<R(Args...)>, F &&) -> R (meta::unqualified_t<F>::*)(Args...) {
+			using Sig = R(Args...);
+			typedef meta::unqualified_t<F> Fu;
+			return static_cast<Sig Fu::*>(&Fu::operator());
+		}
+
+		template <typename F, typename U = meta::unqualified_t<F>>
+		inline constexpr auto resolve_f(std::true_type, F&& f)
+		     -> decltype(resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(), std::forward<F>(f))) {
+			return resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(), std::forward<F>(f));
+		}
+
+		template <typename F>
+		inline constexpr void resolve_f(std::false_type, F&&) {
+			static_assert(
+			     meta::has_deducible_signature<F>::value, "Cannot use no-template-parameter call with an overloaded functor: specify the signature");
+		}
+
+		template <typename F, typename U = meta::unqualified_t<F>>
+		inline constexpr auto resolve_i(types<>, F&& f) -> decltype(resolve_f(meta::has_deducible_signature<U>(), std::forward<F>(f))) {
+			return resolve_f(meta::has_deducible_signature<U> {}, std::forward<F>(f));
+		}
+
+		template <typename... Args, typename F, typename R = std::invoke_result_t<F&, Args...>>
+		inline constexpr auto resolve_i(types<Args...>, F&& f) -> decltype(resolve_i(types<R(Args...)>(), std::forward<F>(f))) {
+			return resolve_i(types<R(Args...)>(), std::forward<F>(f));
+		}
+
+		template <typename Sig, typename C>
+		inline constexpr Sig C::*resolve_v(std::false_type, Sig C::*mem_func_ptr) {
+			return mem_func_ptr;
+		}
+
+		template <typename Sig, typename C>
+		inline constexpr Sig C::*resolve_v(std::true_type, Sig C::*mem_variable_ptr) {
+			return mem_variable_ptr;
+		}
+	} // namespace detail
+
+	template <typename... Args, typename R>
+	inline constexpr auto resolve(R fun_ptr(Args...)) -> R (*)(Args...) {
+		return fun_ptr;
+	}
+
+	template <typename Sig>
+	inline constexpr Sig* resolve(Sig* fun_ptr) {
+		return fun_ptr;
+	}
+
+	template <typename... Args, typename R, typename C>
+	inline constexpr auto resolve(R (C::*mem_ptr)(Args...)) -> R (C::*)(Args...) {
+		return mem_ptr;
+	}
+
+	template <typename Sig, typename C>
+	inline constexpr Sig C::*resolve(Sig C::*mem_ptr) {
+		return detail::resolve_v(std::is_member_object_pointer<Sig C::*>(), mem_ptr);
+	}
+
+	template <typename... Sig, typename F, meta::disable<std::is_function<meta::unqualified_t<F>>> = meta::enabler>
+	inline constexpr auto resolve(F&& f) -> decltype(detail::resolve_i(types<Sig...>(), std::forward<F>(f))) {
+		return detail::resolve_i(types<Sig...>(), std::forward<F>(f));
+	}
+#else
+
+	// Clang has distinct problems with constexpr arguments,
+	// so don't use the constexpr versions inside of clang.
+
+	namespace detail {
+		template <typename R, typename... Args, typename F, typename = std::invoke_result_t<meta::unqualified_t<F>, Args...>>
+		inline auto resolve_i(types<R(Args...)>, F &&) -> R (meta::unqualified_t<F>::*)(Args...) {
+			using Sig = R(Args...);
+			typedef meta::unqualified_t<F> Fu;
+			return static_cast<Sig Fu::*>(&Fu::operator());
+		}
+
+		template <typename F, typename U = meta::unqualified_t<F>>
+		inline auto resolve_f(std::true_type, F&& f)
+		     -> decltype(resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(), std::forward<F>(f))) {
+			return resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(), std::forward<F>(f));
+		}
+
+		template <typename F>
+		inline void resolve_f(std::false_type, F&&) {
+			static_assert(
+			     meta::has_deducible_signature<F>::value, "Cannot use no-template-parameter call with an overloaded functor: specify the signature");
+		}
+
+		template <typename F, typename U = meta::unqualified_t<F>>
+		inline auto resolve_i(types<>, F&& f) -> decltype(resolve_f(meta::has_deducible_signature<U>(), std::forward<F>(f))) {
+			return resolve_f(meta::has_deducible_signature<U> {}, std::forward<F>(f));
+		}
+
+		template <typename... Args, typename F, typename R = std::invoke_result_t<F&, Args...>>
+		inline auto resolve_i(types<Args...>, F&& f) -> decltype(resolve_i(types<R(Args...)>(), std::forward<F>(f))) {
+			return resolve_i(types<R(Args...)>(), std::forward<F>(f));
+		}
+
+		template <typename Sig, typename C>
+		inline Sig C::*resolve_v(std::false_type, Sig C::*mem_func_ptr) {
+			return mem_func_ptr;
+		}
+
+		template <typename Sig, typename C>
+		inline Sig C::*resolve_v(std::true_type, Sig C::*mem_variable_ptr) {
+			return mem_variable_ptr;
+		}
+	} // namespace detail
+
+	template <typename... Args, typename R>
+	inline auto resolve(R fun_ptr(Args...)) -> R (*)(Args...) {
+		return fun_ptr;
+	}
+
+	template <typename Sig>
+	inline Sig* resolve(Sig* fun_ptr) {
+		return fun_ptr;
+	}
+
+	template <typename... Args, typename R, typename C>
+	inline auto resolve(R (C::*mem_ptr)(Args...)) -> R (C::*)(Args...) {
+		return mem_ptr;
+	}
+
+	template <typename Sig, typename C>
+	inline Sig C::*resolve(Sig C::*mem_ptr) {
+		return detail::resolve_v(std::is_member_object_pointer<Sig C::*>(), mem_ptr);
+	}
+
+	template <typename... Sig, typename F>
+	inline auto resolve(F&& f) -> decltype(detail::resolve_i(types<Sig...>(), std::forward<F>(f))) {
+		return detail::resolve_i(types<Sig...>(), std::forward<F>(f));
+	}
+
+#endif
+
+} // namespace sol
+
+// end of sol/resolve.hpp
+
+namespace sol {
+	namespace function_detail {
+		template <typename T>
+		struct class_indicator {
+			using type = T;
+		};
+
+		struct call_indicator { };
+
+		template <bool yielding>
+		int lua_c_wrapper(lua_State* L) {
+			lua_CFunction cf = lua_tocfunction(L, lua_upvalueindex(2));
+			int nr = cf(L);
+			if constexpr (yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		template <bool yielding>
+		int lua_c_noexcept_wrapper(lua_State* L) noexcept {
+			detail::lua_CFunction_noexcept cf = reinterpret_cast<detail::lua_CFunction_noexcept>(lua_tocfunction(L, lua_upvalueindex(2)));
+			int nr = cf(L);
+			if constexpr (yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		struct c_function_invocation { };
+
+		template <bool is_yielding, typename Fx, typename... Args>
+		void select(lua_State* L, Fx&& fx, Args&&... args);
+
+		template <bool is_yielding, bool no_trampoline, typename Fx, typename... Args>
+		void select_set_fx(lua_State* L, Args&&... args) {
+			lua_CFunction freefunc = no_trampoline ? detail::static_trampoline<function_detail::call<meta::unqualified_t<Fx>, 2, is_yielding>>
+			                                       : function_detail::call<meta::unqualified_t<Fx>, 2, is_yielding>;
+
+			int upvalues = 0;
+			upvalues += stack::push(L, nullptr);
+			upvalues += stack::push<user<Fx>>(L, std::forward<Args>(args)...);
+			stack::push(L, c_closure(freefunc, upvalues));
+		}
+
+		template <bool is_yielding, typename R, typename... A, typename Fx, typename... Args>
+		void select_convertible(types<R(A...)>, lua_State* L, Fx&& fx, Args&&... args) {
+			using dFx = std::decay_t<meta::unwrap_unqualified_t<Fx>>;
+			using fx_ptr_t = R (*)(A...);
+			constexpr bool is_convertible = std::is_convertible_v<dFx, fx_ptr_t>;
+			if constexpr (is_convertible) {
+				fx_ptr_t fxptr = detail::unwrap(std::forward<Fx>(fx));
+				select<is_yielding>(L, std::move(fxptr), std::forward<Args>(args)...);
+			}
+			else {
+				using F = function_detail::functor_function<dFx, false, true>;
+				select_set_fx<is_yielding, false, F>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+		}
+
+		template <bool is_yielding, typename Fx, typename... Args>
+		void select_convertible(types<>, lua_State* L, Fx&& fx, Args&&... args) {
+			typedef meta::function_signature_t<meta::unwrap_unqualified_t<Fx>> Sig;
+			select_convertible<is_yielding>(types<Sig>(), L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+		}
+
+		template <bool is_yielding, typename Fx, typename... Args>
+		void select_member_variable(lua_State* L, Fx&& fx, Args&&... args) {
+			using uFx = meta::unqualified_t<Fx>;
+			if constexpr (sizeof...(Args) < 1) {
+				using C = typename meta::bind_traits<uFx>::object_type;
+				lua_CFunction freefunc = &function_detail::upvalue_this_member_variable<C, Fx, is_yielding>::call;
+
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::stack_detail::push_as_upvalues(L, fx);
+				stack::push(L, c_closure(freefunc, upvalues));
+			}
+			else if constexpr (sizeof...(Args) < 2) {
+				using Tu = typename meta::meta_detail::unqualified_non_alias<Args...>::type;
+				constexpr bool is_reference = meta::is_specialization_of_v<Tu, std::reference_wrapper> || std::is_pointer_v<Tu>;
+				if constexpr (meta::is_specialization_of_v<Tu, function_detail::class_indicator>) {
+					lua_CFunction freefunc = &function_detail::upvalue_this_member_variable<typename Tu::type, Fx, is_yielding>::call;
+
+					int upvalues = 0;
+					upvalues += stack::push(L, nullptr);
+					upvalues += stack::stack_detail::push_as_upvalues(L, fx);
+					stack::push(L, c_closure(freefunc, upvalues));
+				}
+				else if constexpr (is_reference) {
+					typedef std::decay_t<Fx> dFx;
+					dFx memfxptr(std::forward<Fx>(fx));
+					auto userptr = detail::ptr(std::forward<Args>(args)...);
+					lua_CFunction freefunc
+					     = &function_detail::upvalue_member_variable<std::decay_t<decltype(*userptr)>, meta::unqualified_t<Fx>, is_yielding>::call;
+
+					int upvalues = 0;
+					upvalues += stack::push(L, nullptr);
+					upvalues += stack::stack_detail::push_as_upvalues(L, memfxptr);
+					upvalues += stack::push(L, static_cast<void const*>(userptr));
+					stack::push(L, c_closure(freefunc, upvalues));
+				}
+				else {
+					using clean_fx = std::remove_pointer_t<std::decay_t<Fx>>;
+					using F = function_detail::member_variable<Tu, clean_fx, is_yielding>;
+					select_set_fx<false, false, F>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+				}
+			}
+			else {
+				using C = typename meta::bind_traits<uFx>::object_type;
+				using clean_fx = std::remove_pointer_t<std::decay_t<Fx>>;
+				using F = function_detail::member_variable<C, clean_fx, is_yielding>;
+				select_set_fx<false, false, F>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+		}
+
+		template <bool is_yielding, typename Fx, typename T, typename... Args>
+		void select_member_function_with(lua_State* L, Fx&& fx, T&& obj, Args&&... args) {
+			using dFx = std::decay_t<Fx>;
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (meta::is_specialization_of_v<Tu, function_detail::class_indicator>) {
+				(void)obj;
+				using C = typename Tu::type;
+				lua_CFunction freefunc = &function_detail::upvalue_this_member_function<C, dFx, is_yielding>::call;
+
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<dFx>>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+				stack::push(L, c_closure(freefunc, upvalues));
+			}
+			else {
+				constexpr bool is_reference = meta::is_specialization_of_v<Tu, std::reference_wrapper> || std::is_pointer_v<Tu>;
+				if constexpr (is_reference) {
+					auto userptr = detail::ptr(std::forward<T>(obj));
+					lua_CFunction freefunc = &function_detail::upvalue_member_function<std::decay_t<decltype(*userptr)>, dFx, is_yielding>::call;
+
+					int upvalues = 0;
+					upvalues += stack::push(L, nullptr);
+					upvalues += stack::push<user<dFx>>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+					upvalues += stack::push(L, lightuserdata_value(static_cast<void*>(userptr)));
+					stack::push(L, c_closure(freefunc, upvalues));
+				}
+				else {
+					using F = function_detail::member_function<Tu, dFx, is_yielding>;
+					select_set_fx<false, false, F>(L, std::forward<Fx>(fx), std::forward<T>(obj), std::forward<Args>(args)...);
+				}
+			}
+		}
+
+		template <bool is_yielding, typename Fx, typename... Args>
+		void select_member_function(lua_State* L, Fx&& fx, Args&&... args) {
+			using dFx = std::decay_t<Fx>;
+			if constexpr (sizeof...(Args) < 1) {
+				using C = typename meta::bind_traits<meta::unqualified_t<Fx>>::object_type;
+				lua_CFunction freefunc = &function_detail::upvalue_this_member_function<C, dFx, is_yielding>::call;
+
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<dFx>>(L, std::forward<Fx>(fx));
+				stack::push(L, c_closure(freefunc, upvalues));
+			}
+			else {
+				select_member_function_with<is_yielding>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+		}
+
+		template <bool is_yielding, typename Fx, typename... Args>
+		void select(lua_State* L, Fx&& fx, Args&&... args) {
+			using uFx = meta::unqualified_t<Fx>;
+			if constexpr (is_lua_reference_v<uFx>) {
+				// TODO: hoist into lambda in this case for yielding???
+				stack::push(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+			else if constexpr (is_lua_c_function_v<uFx>) {
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push(L, std::forward<Fx>(fx));
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_)
+				if constexpr (std::is_nothrow_invocable_r_v<int, uFx, lua_State*>) {
+					detail::lua_CFunction_noexcept cf = &lua_c_noexcept_wrapper<is_yielding>;
+					lua_pushcclosure(L, reinterpret_cast<lua_CFunction>(cf), 2);
+				}
+				else {
+					lua_CFunction cf = &lua_c_wrapper<is_yielding>;
+					lua_pushcclosure(L, cf, 2);
+				}
+#else
+				lua_CFunction cf = &function_detail::lua_c_wrapper<is_yielding>;
+				lua_pushcclosure(L, cf, 2);
+#endif
+			}
+			else if constexpr (std::is_function_v<std::remove_pointer_t<uFx>>) {
+				std::decay_t<Fx> target(std::forward<Fx>(fx), std::forward<Args>(args)...);
+				lua_CFunction freefunc = &function_detail::upvalue_free_function<Fx, is_yielding>::call;
+
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::stack_detail::push_as_upvalues(L, target);
+				stack::push(L, c_closure(freefunc, upvalues));
+			}
+			else if constexpr (std::is_member_function_pointer_v<uFx>) {
+				select_member_function<is_yielding>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+			else if constexpr (meta::is_member_object_v<uFx>) {
+				select_member_variable<is_yielding>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+			else {
+				select_convertible<is_yielding>(types<>(), L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+		}
+	} // namespace function_detail
+
+	namespace stack {
+		template <typename... Sigs>
+		struct unqualified_pusher<function_sig<Sigs...>> {
+			template <bool is_yielding, typename Arg0, typename... Args>
+			static int push(lua_State* L, Arg0&& arg0, Args&&... args) {
+				if constexpr (meta::is_specialization_of_v<meta::unqualified_t<Arg0>, std::function>) {
+					if constexpr (is_yielding) {
+						return stack::push<meta::unqualified_t<Arg0>>(L, detail::yield_tag, std::forward<Arg0>(arg0), std::forward<Args>(args)...);
+					}
+					else {
+						return stack::push(L, std::forward<Arg0>(arg0), std::forward<Args>(args)...);
+					}
+				}
+				else {
+					function_detail::select<is_yielding>(L, std::forward<Arg0>(arg0), std::forward<Args>(args)...);
+					return 1;
+				}
+			}
+
+			template <typename Arg0, typename... Args>
+			static int push(lua_State* L, Arg0&& arg0, Args&&... args) {
+				if constexpr (std::is_same_v<meta::unqualified_t<Arg0>, detail::yield_tag_t>) {
+					push<true>(L, std::forward<Args>(args)...);
+				}
+				else if constexpr (meta::is_specialization_of_v<meta::unqualified_t<Arg0>, yielding_t>) {
+					push<true>(L, std::forward<Arg0>(arg0).func, std::forward<Args>(args)...);
+				}
+				else {
+					push<false>(L, std::forward<Arg0>(arg0), std::forward<Args>(args)...);
+				}
+				return 1;
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<yielding_t<T>> {
+			template <typename... Args>
+			static int push(lua_State* L, const yielding_t<T>& f, Args&&... args) {
+				if constexpr (meta::is_specialization_of_v<meta::unqualified_t<T>, std::function>) {
+					return stack::push<T>(L, detail::yield_tag, f.func, std::forward<Args>(args)...);
+				}
+				else {
+					function_detail::select<true>(L, f.func, std::forward<Args>(args)...);
+					return 1;
+				}
+			}
+
+			template <typename... Args>
+			static int push(lua_State* L, yielding_t<T>&& f, Args&&... args) {
+				if constexpr (meta::is_specialization_of_v<meta::unqualified_t<T>, std::function>) {
+					return stack::push<T>(L, detail::yield_tag, std::move(f.func), std::forward<Args>(args)...);
+				}
+				else {
+					function_detail::select<true>(L, std::move(f.func), std::forward<Args>(args)...);
+					return 1;
+				}
+			}
+		};
+
+		template <typename T, typename... Args>
+		struct unqualified_pusher<function_arguments<T, Args...>> {
+			template <std::size_t... I, typename FP>
+			static int push_func(std::index_sequence<I...>, lua_State* L, FP&& fp) {
+				return stack::push<T>(L, std::get<I>(std::forward<FP>(fp).arguments)...);
+			}
+
+			static int push(lua_State* L, const function_arguments<T, Args...>& fp) {
+				return push_func(std::make_index_sequence<sizeof...(Args)>(), L, fp);
+			}
+
+			static int push(lua_State* L, function_arguments<T, Args...>&& fp) {
+				return push_func(std::make_index_sequence<sizeof...(Args)>(), L, std::move(fp));
+			}
+		};
+
+		template <typename Signature>
+		struct unqualified_pusher<std::function<Signature>> {
+			static int push(lua_State* L, detail::yield_tag_t, const std::function<Signature>& fx) {
+				if (fx) {
+					function_detail::select<true>(L, fx);
+					return 1;
+				}
+				return stack::push(L, lua_nil);
+			}
+
+			static int push(lua_State* L, detail::yield_tag_t, std::function<Signature>&& fx) {
+				if (fx) {
+					function_detail::select<true>(L, std::move(fx));
+					return 1;
+				}
+				return stack::push(L, lua_nil);
+			}
+
+			static int push(lua_State* L, const std::function<Signature>& fx) {
+				if (fx) {
+					function_detail::select<false>(L, fx);
+					return 1;
+				}
+				return stack::push(L, lua_nil);
+			}
+
+			static int push(lua_State* L, std::function<Signature>&& fx) {
+				if (fx) {
+					function_detail::select<false>(L, std::move(fx));
+					return 1;
+				}
+				return stack::push(L, lua_nil);
+			}
+		};
+
+		template <typename Signature>
+		struct unqualified_pusher<Signature, std::enable_if_t<std::is_member_pointer<Signature>::value>> {
+			template <typename... Args>
+			static int push(lua_State* L, Args&&... args) {
+				function_detail::select<false>(L, std::forward<Args>(args)...);
+				return 1;
+			}
+		};
+
+		template <typename Signature>
+		struct unqualified_pusher<Signature,
+		     std::enable_if_t<meta::all<std::is_function<std::remove_pointer_t<Signature>>, meta::neg<std::is_same<Signature, lua_CFunction>>,
+		          meta::neg<std::is_same<Signature, std::remove_pointer_t<lua_CFunction>>>
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_)
+		          ,
+		          meta::neg<std::is_same<Signature, detail::lua_CFunction_noexcept>>,
+		          meta::neg<std::is_same<Signature, std::remove_pointer_t<detail::lua_CFunction_noexcept>>>
+#endif // noexcept function types
+		          >::value>> {
+			template <typename F>
+			static int push(lua_State* L, F&& f) {
+				function_detail::select<false>(L, std::forward<F>(f));
+				return 1;
+			}
+		};
+
+		template <typename... Functions>
+		struct unqualified_pusher<overload_set<Functions...>> {
+			static int push(lua_State* L, overload_set<Functions...>&& set) {
+				using F = function_detail::overloaded_function<0, Functions...>;
+				function_detail::select_set_fx<false, false, F>(L, std::move(set.functions));
+				return 1;
+			}
+
+			static int push(lua_State* L, const overload_set<Functions...>& set) {
+				using F = function_detail::overloaded_function<0, Functions...>;
+				function_detail::select_set_fx<false, false, F>(L, set.functions);
+				return 1;
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<protect_t<T>> {
+			static int push(lua_State* L, protect_t<T>&& pw) {
+				lua_CFunction cf = call_detail::call_user<void, false, false, protect_t<T>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<protect_t<T>>>(L, std::move(pw.value));
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+
+			static int push(lua_State* L, const protect_t<T>& pw) {
+				lua_CFunction cf = call_detail::call_user<void, false, false, protect_t<T>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<protect_t<T>>>(L, pw.value);
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+		};
+
+		template <typename F, typename G>
+		struct unqualified_pusher<property_wrapper<F, G>> {
+			static int push(lua_State* L, property_wrapper<F, G>&& pw) {
+				if constexpr (std::is_void_v<F>) {
+					return stack::push(L, std::move(pw.write()));
+				}
+				else if constexpr (std::is_void_v<G>) {
+					return stack::push(L, std::move(pw.read()));
+				}
+				else {
+					return stack::push(L, overload(std::move(pw.read()), std::move(pw.write())));
+				}
+			}
+
+			static int push(lua_State* L, const property_wrapper<F, G>& pw) {
+				if constexpr (std::is_void_v<F>) {
+					return stack::push(L, pw.write);
+				}
+				else if constexpr (std::is_void_v<G>) {
+					return stack::push(L, pw.read);
+				}
+				else {
+					return stack::push(L, overload(pw.read, pw.write));
+				}
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<var_wrapper<T>> {
+			static int push(lua_State* L, var_wrapper<T>&& vw) {
+				return stack::push(L, std::move(vw.value()));
+			}
+			static int push(lua_State* L, const var_wrapper<T>& vw) {
+				return stack::push(L, vw.value());
+			}
+		};
+
+		template <typename... Functions>
+		struct unqualified_pusher<factory_wrapper<Functions...>> {
+			static int push(lua_State* L, const factory_wrapper<Functions...>& fw) {
+				using F = function_detail::overloaded_function<0, Functions...>;
+				function_detail::select_set_fx<false, false, F>(L, fw.functions);
+				return 1;
+			}
+
+			static int push(lua_State* L, factory_wrapper<Functions...>&& fw) {
+				using F = function_detail::overloaded_function<0, Functions...>;
+				function_detail::select_set_fx<false, false, F>(L, std::move(fw.functions));
+				return 1;
+			}
+
+			static int push(lua_State* L, const factory_wrapper<Functions...>& fw, function_detail::call_indicator) {
+				using F = function_detail::overloaded_function<1, Functions...>;
+				function_detail::select_set_fx<false, false, F>(L, fw.functions);
+				return 1;
+			}
+
+			static int push(lua_State* L, factory_wrapper<Functions...>&& fw, function_detail::call_indicator) {
+				using F = function_detail::overloaded_function<1, Functions...>;
+				function_detail::select_set_fx<false, false, F>(L, std::move(fw.functions));
+				return 1;
+			}
+		};
+
+		template <>
+		struct unqualified_pusher<no_construction> {
+			static int push(lua_State* L, no_construction) {
+				lua_CFunction cf = &function_detail::no_construction_error;
+				return stack::push(L, cf);
+			}
+
+			static int push(lua_State* L, no_construction c, function_detail::call_indicator) {
+				return push(L, c);
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<detail::tagged<T, no_construction>> {
+			static int push(lua_State* L, detail::tagged<T, no_construction>) {
+				lua_CFunction cf = &function_detail::no_construction_error;
+				return stack::push(L, cf);
+			}
+
+			static int push(lua_State* L, no_construction c, function_detail::call_indicator) {
+				return push(L, c);
+			}
+		};
+
+		template <typename T, typename... Lists>
+		struct unqualified_pusher<detail::tagged<T, constructor_list<Lists...>>> {
+			static int push(lua_State* L, detail::tagged<T, constructor_list<Lists...>>) {
+				lua_CFunction cf = call_detail::construct<T, detail::default_safe_function_calls, true, Lists...>;
+				return stack::push(L, cf);
+			}
+
+			static int push(lua_State* L, constructor_list<Lists...>) {
+				lua_CFunction cf = call_detail::construct<T, detail::default_safe_function_calls, true, Lists...>;
+				return stack::push(L, cf);
+			}
+		};
+
+		template <typename L0, typename... Lists>
+		struct unqualified_pusher<constructor_list<L0, Lists...>> {
+			typedef constructor_list<L0, Lists...> cl_t;
+			static int push(lua_State* L, cl_t cl) {
+				typedef typename meta::bind_traits<L0>::return_type T;
+				return stack::push<detail::tagged<T, cl_t>>(L, cl);
+			}
+		};
+
+		template <typename T, typename... Fxs>
+		struct unqualified_pusher<detail::tagged<T, constructor_wrapper<Fxs...>>> {
+			static int push(lua_State* L, detail::tagged<T, constructor_wrapper<Fxs...>>&& c) {
+				return push(L, std::move(c.value()));
+			}
+
+			static int push(lua_State* L, const detail::tagged<T, const constructor_wrapper<Fxs...>>& c) {
+				return push(L, c.value());
+			}
+
+			static int push(lua_State* L, constructor_wrapper<Fxs...>&& c) {
+				lua_CFunction cf = call_detail::call_user<T, false, false, constructor_wrapper<Fxs...>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<constructor_wrapper<Fxs...>>>(L, std::move(c));
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+
+			static int push(lua_State* L, const constructor_wrapper<Fxs...>& c) {
+				lua_CFunction cf = call_detail::call_user<T, false, false, constructor_wrapper<Fxs...>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<constructor_wrapper<Fxs...>>>(L, c);
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+		};
+
+		template <typename F, typename... Fxs>
+		struct unqualified_pusher<constructor_wrapper<F, Fxs...>> {
+			static int push(lua_State* L, const constructor_wrapper<F, Fxs...>& c) {
+				typedef typename meta::bind_traits<F>::template arg_at<0> arg0;
+				typedef meta::unqualified_t<std::remove_pointer_t<arg0>> T;
+				return stack::push<detail::tagged<T, constructor_wrapper<F, Fxs...>>>(L, c);
+			}
+
+			static int push(lua_State* L, constructor_wrapper<F, Fxs...>&& c) {
+				typedef typename meta::bind_traits<F>::template arg_at<0> arg0;
+				typedef meta::unqualified_t<std::remove_pointer_t<arg0>> T;
+				return stack::push<detail::tagged<T, constructor_wrapper<F, Fxs...>>>(L, std::move(c));
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<detail::tagged<T, destructor_wrapper<void>>> {
+			static int push(lua_State* L, destructor_wrapper<void>) {
+				lua_CFunction cf = detail::usertype_alloc_destruct<T>;
+				return stack::push(L, cf);
+			}
+		};
+
+		template <typename T, typename Fx>
+		struct unqualified_pusher<detail::tagged<T, destructor_wrapper<Fx>>> {
+			static int push(lua_State* L, destructor_wrapper<Fx>&& c) {
+				lua_CFunction cf = call_detail::call_user<T, false, false, destructor_wrapper<Fx>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<destructor_wrapper<Fx>>>(L, std::move(c));
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+
+			static int push(lua_State* L, const destructor_wrapper<Fx>& c) {
+				lua_CFunction cf = call_detail::call_user<T, false, false, destructor_wrapper<Fx>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<destructor_wrapper<Fx>>>(L, c);
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+		};
+
+		template <typename Fx>
+		struct unqualified_pusher<destructor_wrapper<Fx>> {
+			static int push(lua_State* L, destructor_wrapper<Fx>&& c) {
+				lua_CFunction cf = call_detail::call_user<void, false, false, destructor_wrapper<Fx>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<destructor_wrapper<Fx>>>(L, std::move(c));
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+
+			static int push(lua_State* L, const destructor_wrapper<Fx>& c) {
+				lua_CFunction cf = call_detail::call_user<void, false, false, destructor_wrapper<Fx>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<destructor_wrapper<Fx>>>(L, c);
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+		};
+
+		template <typename F, typename... Policies>
+		struct unqualified_pusher<policy_wrapper<F, Policies...>> {
+			using P = policy_wrapper<F, Policies...>;
+
+			static int push(lua_State* L, const P& p) {
+				lua_CFunction cf = call_detail::call_user<void, false, false, P, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<P>>(L, p);
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+
+			static int push(lua_State* L, P&& p) {
+				lua_CFunction cf = call_detail::call_user<void, false, false, P, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<P>>(L, std::move(p));
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+		};
+
+		template <typename T, typename F, typename... Policies>
+		struct unqualified_pusher<detail::tagged<T, policy_wrapper<F, Policies...>>> {
+			using P = policy_wrapper<F, Policies...>;
+			using Tagged = detail::tagged<T, P>;
+
+			static int push(lua_State* L, const Tagged& p) {
+				lua_CFunction cf = call_detail::call_user<T, false, false, P, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<P>>(L, p.value());
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+
+			static int push(lua_State* L, Tagged&& p) {
+				lua_CFunction cf = call_detail::call_user<T, false, false, P, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<P>>(L, std::move(p.value()));
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<push_invoke_t<T>> {
+			static int push(lua_State* L, push_invoke_t<T>&& pi) {
+				if constexpr (std::is_invocable_v<std::add_rvalue_reference_t<T>, lua_State*>) {
+					return stack::push(L, std::move(pi.value())(L));
+				}
+				else {
+					return stack::push(L, std::move(pi.value())());
+				}
+			}
+
+			static int push(lua_State* L, const push_invoke_t<T>& pi) {
+				if constexpr (std::is_invocable_v<const T, lua_State*>) {
+					return stack::push(L, pi.value()(L));
+				}
+				else {
+					return stack::push(L, pi.value()());
+				}
+			}
+		};
+
+		namespace stack_detail {
+			template <typename Function, typename Handler>
+			bool check_function_pointer(lua_State* L, int index, Handler&& handler, record& tracking) noexcept {
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE_I_)
+				tracking.use(1);
+				bool success = lua_iscfunction(L, index) == 1;
+				if (success) {
+					// there must be at LEAST 2 upvalues; otherwise, we didn't serialize it.
+					const char* upvalue_name = lua_getupvalue(L, index, 2);
+					lua_pop(L, 1);
+					success = upvalue_name != nullptr;
+				}
+				if (!success) {
+					// expected type, actual type
+					handler(
+					     L, index, type::function, type_of(L, index), "type must be a Lua C Function gotten from a function pointer serialized by sol2");
+				}
+				return success;
+#else
+				return false;
+#endif
+			}
+
+			template <typename Function>
+			Function* get_function_pointer(lua_State* L, int index, record& tracking) noexcept {
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE_I_)
+				tracking.use(1);
+				auto udata = stack::stack_detail::get_as_upvalues_using_function<Function*>(L, index);
+				Function* fx = udata.first;
+				return fx;
+#else
+				static_assert(meta::meta_detail::always_true<Function>::value,
+#if SOL_IS_DEFAULT_OFF(SOL_GET_FUNCTION_POINTER_UNSAFE_I_)
+				     "You are attempting to retrieve a function pointer type. "
+				     "This is inherently unsafe in sol2. In order to do this, you must turn on the "
+				     "SOL_GET_FUNCTION_POINTER_UNSAFE configuration macro, as detailed in the documentation. "
+				     "Please be careful!"
+#else
+				     "You are attempting to retrieve a function pointer type. "
+				     "You explicitly turned off the ability to do this by defining "
+				     "SOL_GET_FUNCTION_POINTER_UNSAFE or similar to be off. "
+				     "Please reconsider this!"
+#endif
+				);
+				return nullptr;
+#endif
+			}
+		} // namespace stack_detail
+	}      // namespace stack
+} // namespace sol
+
+// end of sol/function_types.hpp
+
+// beginning of sol/dump_handler.hpp
+
+#include <cstdint>
+#include <exception>
+
+namespace sol {
+
+	class dump_error : public error {
+	private:
+		int ec_;
+
+	public:
+		dump_error(int error_code_) : error("dump returned non-zero error of " + std::to_string(error_code_)), ec_(error_code_) {
+		}
+
+		int error_code() const {
+			return ec_;
+		}
+	};
+
+	inline int dump_pass_on_error(lua_State* L, int result_code, lua_Writer writer_function, void* userdata, bool strip) {
+		(void)L;
+		(void)writer_function;
+		(void)userdata;
+		(void)strip;
+		return result_code;
+	}
+
+	inline int dump_panic_on_error(lua_State* L, int result_code, lua_Writer writer_function, void* userdata, bool strip) {
+		(void)L;
+		(void)writer_function;
+		(void)userdata;
+		(void)strip;
+		return luaL_error(L, "a non-zero error code (%d) was returned by the lua_Writer for the dump function", result_code);
+	}
+
+	inline int dump_throw_on_error(lua_State* L, int result_code, lua_Writer writer_function, void* userdata, bool strip) {
+#if SOL_IS_OFF(SOL_EXCEPTIONS_I_)
+		return dump_panic_on_error(L, result_code, writer_function, userdata, strip);
+#else
+		(void)L;
+		(void)writer_function;
+		(void)userdata;
+		(void)strip;
+		throw dump_error(result_code);
+#endif // no exceptions stuff
+	}
+
+} // namespace sol
+
+// end of sol/dump_handler.hpp
+
+#include <cstdint>
+
+namespace sol {
+	template <typename ref_t, bool aligned = false>
+	class basic_function : public basic_object<ref_t> {
+	private:
+		using base_t = basic_object<ref_t>;
+
+		void luacall(std::ptrdiff_t argcount, std::ptrdiff_t resultcount) const {
+			lua_call(lua_state(), static_cast<int>(argcount), static_cast<int>(resultcount));
+		}
+
+		template <std::size_t... I, typename... Ret>
+		auto invoke(types<Ret...>, std::index_sequence<I...>, std::ptrdiff_t n) const {
+			luacall(n, lua_size<std::tuple<Ret...>>::value);
+			return stack::pop<std::tuple<Ret...>>(lua_state());
+		}
+
+		template <std::size_t I, typename Ret, meta::enable<meta::neg<std::is_void<Ret>>> = meta::enabler>
+		Ret invoke(types<Ret>, std::index_sequence<I>, std::ptrdiff_t n) const {
+			luacall(n, lua_size<Ret>::value);
+			return stack::pop<Ret>(lua_state());
+		}
+
+		template <std::size_t I>
+		void invoke(types<void>, std::index_sequence<I>, std::ptrdiff_t n) const {
+			luacall(n, 0);
+		}
+
+		unsafe_function_result invoke(types<>, std::index_sequence<>, std::ptrdiff_t n) const {
+			int stacksize = lua_gettop(lua_state());
+			int firstreturn = (std::max)(1, stacksize - static_cast<int>(n));
+			luacall(n, LUA_MULTRET);
+			int poststacksize = lua_gettop(lua_state());
+			int returncount = poststacksize - (firstreturn - 1);
+			return unsafe_function_result(lua_state(), firstreturn, returncount);
+		}
+
+	public:
+		using base_t::lua_state;
+
+		basic_function() = default;
+		template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_function>>, meta::neg<std::is_same<base_t, stack_reference>>, meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_function(T&& r) noexcept
+		: base_t(std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			if (!is_function<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				constructor_handler handler{};
+				stack::check<basic_function>(lua_state(), -1, handler);
+			}
+#endif // Safety
+		}
+		basic_function(const basic_function&) = default;
+		basic_function& operator=(const basic_function&) = default;
+		basic_function(basic_function&&) = default;
+		basic_function& operator=(basic_function&&) = default;
+		basic_function(const stack_reference& r)
+		: basic_function(r.lua_state(), r.stack_index()) {
+		}
+		basic_function(stack_reference&& r)
+		: basic_function(r.lua_state(), r.stack_index()) {
+		}
+		basic_function(lua_nil_t n)
+		: base_t(n) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_function(lua_State* L, T&& r)
+		: base_t(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler{};
+			stack::check<basic_function>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		basic_function(lua_State* L, int index = -1)
+		: base_t(L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			constructor_handler handler{};
+			stack::check<basic_function>(L, index, handler);
+#endif // Safety
+		}
+		basic_function(lua_State* L, ref_index index)
+		: base_t(L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler{};
+			stack::check<basic_function>(lua_state(), -1, handler);
+#endif // Safety
+		}
+
+		template <typename Fx>
+		int dump(lua_Writer writer, void* userdata, bool strip, Fx&& on_error) const {
+			this->push();
+			auto ppn = stack::push_popper_n<false>(this->lua_state(), 1);
+			int r = lua_dump(this->lua_state(), writer, userdata, strip ? 1 : 0);
+			if (r != 0) {
+				return on_error(this->lua_state(), r, writer, userdata, strip);
+			}
+			return r;
+		}
+
+		int dump(lua_Writer writer, void* userdata, bool strip = false) const {
+			return dump(writer, userdata, strip, &dump_throw_on_error);
+		}
+
+		template <typename Container = bytecode>
+		Container dump() const {
+			Container bc;
+			(void)dump(static_cast<lua_Writer>(&basic_insert_dump_writer<Container>), static_cast<void*>(&bc), false, &dump_panic_on_error);
+			return bc;
+		}
+
+		template <typename Container = bytecode, typename Fx>
+		Container dump(Fx&& on_error) const {
+			Container bc;
+			(void)dump(static_cast<lua_Writer>(&basic_insert_dump_writer<Container>), static_cast<void*>(&bc), false, std::forward<Fx>(on_error));
+			return bc;
+		}
+
+		template <typename... Args>
+		unsafe_function_result operator()(Args&&... args) const {
+			return call<>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) operator()(types<Ret...>, Args&&... args) const {
+			return call<Ret...>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) call(Args&&... args) const {
+			if (!aligned) {
+				base_t::push();
+			}
+			int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
+			return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), static_cast<std::ptrdiff_t>(pushcount));
+		}
+	};
+} // namespace sol
+
+// end of sol/unsafe_function.hpp
+
+// beginning of sol/protected_function.hpp
+
+// beginning of sol/protected_handler.hpp
+
+#include <cstdint>
+
+namespace sol {
+	namespace detail {
+		inline const char(&default_handler_name())[9]{
+			static const char name[9] = "sol.\xF0\x9F\x94\xA9";
+			return name;
+		}
+
+		template <bool b, typename target_t = reference>
+		struct protected_handler {
+			typedef is_stack_based<target_t> is_stack;
+			const target_t& target;
+			int stackindex;
+
+			protected_handler(std::false_type, const target_t& target)
+				: target(target), stackindex(0) {
+				if (b) {
+					stackindex = lua_gettop(target.lua_state()) + 1;
+					target.push();
+				}
+			}
+
+			protected_handler(std::true_type, const target_t& target)
+				: target(target), stackindex(0) {
+				if (b) {
+					stackindex = target.stack_index();
+				}
+			}
+
+			protected_handler(const target_t& target)
+				: protected_handler(is_stack(), target) {
+			}
+
+			bool valid() const noexcept {
+				return b;
+			}
+
+			~protected_handler() {
+				if constexpr (!is_stack::value) {
+					if (stackindex != 0) {
+						lua_remove(target.lua_state(), stackindex);
+					}
+				}
+			}
+		};
+
+		template <typename base_t, typename T>
+		basic_function<base_t> force_cast(T& p) {
+			return p;
+		}
+
+		template <typename Reference, bool is_main_ref = false>
+		static Reference get_default_handler(lua_State* L) {
+			if (is_stack_based<Reference>::value || L == nullptr)
+				return Reference(L, lua_nil);
+			L = is_main_ref ? main_thread(L, L) : L;
+			lua_getglobal(L, default_handler_name());
+			auto pp = stack::pop_n(L, 1);
+			return Reference(L, -1);
+		}
+
+		template <typename T>
+		static void set_default_handler(lua_State* L, const T& ref) {
+			if (L == nullptr) {
+				return;
+			}
+			if (!ref.valid()) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+				lua_pushnil(L);
+				lua_setglobal(L, default_handler_name());
+			}
+			else {
+				ref.push(L);
+				lua_setglobal(L, default_handler_name());
+			}
+		}
+	} // namespace detail
+} // namespace sol
+
+// end of sol/protected_handler.hpp
+
+#include <cstdint>
+#include <algorithm>
+
+namespace sol {
+	
+	namespace detail {
+		template <bool b, typename handler_t>
+		inline void handle_protected_exception(lua_State* L, optional<const std::exception&> maybe_ex, const char* error, detail::protected_handler<b, handler_t>& h) {
+			h.stackindex = 0;
+			if (b) {
+				h.target.push();
+				detail::call_exception_handler(L, maybe_ex, error);
+				lua_call(L, 1, 1);
+			}
+			else {
+				detail::call_exception_handler(L, maybe_ex, error);
+			}
+		}
+	}
+
+	template <typename ref_t, bool aligned = false, typename handler_t = reference>
+	class basic_protected_function : public basic_object<ref_t> {
+	private:
+		using base_t = basic_object<ref_t>;
+
+	public:
+		using is_stack_handler = is_stack_based<handler_t>;
+
+		static handler_t get_default_handler(lua_State* L) {
+			return detail::get_default_handler<handler_t, is_main_threaded<base_t>::value>(L);
+		}
+
+		template <typename T>
+		static void set_default_handler(const T& ref) {
+			detail::set_default_handler(ref.lua_state(), ref);
+		}
+
+	private:
+		template <bool b>
+		call_status luacall(std::ptrdiff_t argcount, std::ptrdiff_t resultcount, detail::protected_handler<b, handler_t>& h) const {
+			return static_cast<call_status>(lua_pcall(lua_state(), static_cast<int>(argcount), static_cast<int>(resultcount), h.stackindex));
+		}
+
+		template <std::size_t... I, bool b, typename... Ret>
+		auto invoke(types<Ret...>, std::index_sequence<I...>, std::ptrdiff_t n, detail::protected_handler<b, handler_t>& h) const {
+			luacall(n, sizeof...(Ret), h);
+			return stack::pop<std::tuple<Ret...>>(lua_state());
+		}
+
+		template <std::size_t I, bool b, typename Ret>
+		Ret invoke(types<Ret>, std::index_sequence<I>, std::ptrdiff_t n, detail::protected_handler<b, handler_t>& h) const {
+			luacall(n, 1, h);
+			return stack::pop<Ret>(lua_state());
+		}
+
+		template <std::size_t I, bool b>
+		void invoke(types<void>, std::index_sequence<I>, std::ptrdiff_t n, detail::protected_handler<b, handler_t>& h) const {
+			luacall(n, 0, h);
+		}
+
+		template <bool b>
+		protected_function_result invoke(types<>, std::index_sequence<>, std::ptrdiff_t n, detail::protected_handler<b, handler_t>& h) const {
+			int stacksize = lua_gettop(lua_state());
+			int poststacksize = stacksize;
+			int firstreturn = 1;
+			int returncount = 0;
+			call_status code = call_status::ok;
+#if !defined(SOL_NO_EXCEPTIONS) || !SOL_NO_EXCEPTIONS
+#if (!defined(SOL_EXCEPTIONS_SAFE_PROPAGATION) || !SOL_NO_EXCEPTIONS_SAFE_PROPAGATION) || (defined(SOL_LUAJIT) && SOL_LUAJIT)
+			try {
+#endif // Safe Exception Propagation
+#endif // No Exceptions
+				firstreturn = (std::max)(1, static_cast<int>(stacksize - n - static_cast<int>(h.valid() && !is_stack_handler::value)));
+				code = luacall(n, LUA_MULTRET, h);
+				poststacksize = lua_gettop(lua_state()) - static_cast<int>(h.valid() && !is_stack_handler::value);
+				returncount = poststacksize - (firstreturn - 1);
+#ifndef SOL_NO_EXCEPTIONS
+#if (!defined(SOL_EXCEPTIONS_SAFE_PROPAGATION) || !SOL_NO_EXCEPTIONS_SAFE_PROPAGATION) || (defined(SOL_LUAJIT) && SOL_LUAJIT)
+			}
+			// Handle C++ errors thrown from C++ functions bound inside of lua
+			catch (const char* error) {
+				detail::handle_protected_exception(lua_state(), optional<const std::exception&>(nullopt), error, h);
+				firstreturn = lua_gettop(lua_state());
+				return protected_function_result(lua_state(), firstreturn, 0, 1, call_status::runtime);
+			}
+			catch (const std::string& error) {
+				detail::handle_protected_exception(lua_state(), optional<const std::exception&>(nullopt), error.c_str(), h);
+				firstreturn = lua_gettop(lua_state());
+				return protected_function_result(lua_state(), firstreturn, 0, 1, call_status::runtime);
+			}
+			catch (const std::exception& error) {
+				detail::handle_protected_exception(lua_state(), optional<const std::exception&>(error), error.what(), h);
+				firstreturn = lua_gettop(lua_state());
+				return protected_function_result(lua_state(), firstreturn, 0, 1, call_status::runtime);
+			}
+#if (!defined(SOL_EXCEPTIONS_SAFE_PROPAGATION) || !SOL_NO_EXCEPTIONS_SAFE_PROPAGATION)
+			// LuaJIT cannot have the catchall when the safe propagation is on
+			// but LuaJIT will swallow all C++ errors 
+			// if we don't at least catch std::exception ones
+			catch (...) {
+				detail::handle_protected_exception(lua_state(), optional<const std::exception&>(nullopt), detail::protected_function_error, h);
+				firstreturn = lua_gettop(lua_state());
+				return protected_function_result(lua_state(), firstreturn, 0, 1, call_status::runtime);
+			}
+#endif // LuaJIT
+#else
+			// do not handle exceptions: they can be propogated into C++ and keep all type information / rich information
+#endif // Safe Exception Propagation
+#endif // Exceptions vs. No Exceptions
+			return protected_function_result(lua_state(), firstreturn, returncount, returncount, code);
+		}
+
+	public:
+		using base_t::lua_state;
+
+		handler_t error_handler;
+
+		basic_protected_function() = default;
+		template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_protected_function>>, meta::neg<std::is_base_of<proxy_base_tag, meta::unqualified_t<T>>>, meta::neg<std::is_same<base_t, stack_reference>>, meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_protected_function(T&& r) noexcept
+		: base_t(std::forward<T>(r)), error_handler(get_default_handler(r.lua_state())) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			if (!is_function<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				constructor_handler handler{};
+				stack::check<basic_protected_function>(lua_state(), -1, handler);
+			}
+#endif // Safety
+		}
+		basic_protected_function(const basic_protected_function&) = default;
+		basic_protected_function& operator=(const basic_protected_function&) = default;
+		basic_protected_function(basic_protected_function&&) = default;
+		basic_protected_function& operator=(basic_protected_function&&) = default;
+		basic_protected_function(const basic_function<base_t>& b)
+		: basic_protected_function(b, get_default_handler(b.lua_state())) {
+		}
+		basic_protected_function(basic_function<base_t>&& b)
+		: basic_protected_function(std::move(b), get_default_handler(b.lua_state())) {
+		}
+		basic_protected_function(const basic_function<base_t>& b, handler_t eh)
+		: base_t(b), error_handler(std::move(eh)) {
+		}
+		basic_protected_function(basic_function<base_t>&& b, handler_t eh)
+		: base_t(std::move(b)), error_handler(std::move(eh)) {
+		}
+		basic_protected_function(const stack_reference& r)
+		: basic_protected_function(r.lua_state(), r.stack_index(), get_default_handler(r.lua_state())) {
+		}
+		basic_protected_function(stack_reference&& r)
+		: basic_protected_function(r.lua_state(), r.stack_index(), get_default_handler(r.lua_state())) {
+		}
+		basic_protected_function(const stack_reference& r, handler_t eh)
+		: basic_protected_function(r.lua_state(), r.stack_index(), std::move(eh)) {
+		}
+		basic_protected_function(stack_reference&& r, handler_t eh)
+		: basic_protected_function(r.lua_state(), r.stack_index(), std::move(eh)) {
+		}
+
+		template <typename Super>
+		basic_protected_function(const proxy_base<Super>& p)
+		: basic_protected_function(p, get_default_handler(p.lua_state())) {
+		}
+		template <typename Super>
+		basic_protected_function(proxy_base<Super>&& p)
+		: basic_protected_function(std::move(p), get_default_handler(p.lua_state())) {
+		}
+		template <typename Proxy, typename Handler, meta::enable<std::is_base_of<proxy_base_tag, meta::unqualified_t<Proxy>>, meta::neg<is_lua_index<meta::unqualified_t<Handler>>>> = meta::enabler>
+		basic_protected_function(Proxy&& p, Handler&& eh)
+		: basic_protected_function(detail::force_cast<base_t>(p), std::forward<Handler>(eh)) {
+		}
+
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_protected_function(lua_State* L, T&& r)
+		: basic_protected_function(L, std::forward<T>(r), get_default_handler(L)) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_protected_function(lua_State* L, T&& r, handler_t eh)
+		: base_t(L, std::forward<T>(r)), error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler{};
+			stack::check<basic_protected_function>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		
+		basic_protected_function(lua_nil_t n)
+			: base_t(n), error_handler(n) {
+		}
+
+		basic_protected_function(lua_State* L, int index = -1)
+		: basic_protected_function(L, index, get_default_handler(L)) {
+		}
+		basic_protected_function(lua_State* L, int index, handler_t eh)
+		: base_t(L, index), error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			constructor_handler handler{};
+			stack::check<basic_protected_function>(L, index, handler);
+#endif // Safety
+		}
+		basic_protected_function(lua_State* L, absolute_index index)
+		: basic_protected_function(L, index, get_default_handler(L)) {
+		}
+		basic_protected_function(lua_State* L, absolute_index index, handler_t eh)
+		: base_t(L, index), error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			constructor_handler handler{};
+			stack::check<basic_protected_function>(L, index, handler);
+#endif // Safety
+		}
+		basic_protected_function(lua_State* L, raw_index index)
+		: basic_protected_function(L, index, get_default_handler(L)) {
+		}
+		basic_protected_function(lua_State* L, raw_index index, handler_t eh)
+		: base_t(L, index), error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			constructor_handler handler{};
+			stack::check<basic_protected_function>(L, index, handler);
+#endif // Safety
+		}
+		basic_protected_function(lua_State* L, ref_index index)
+		: basic_protected_function(L, index, get_default_handler(L)) {
+		}
+		basic_protected_function(lua_State* L, ref_index index, handler_t eh)
+		: base_t(L, index), error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler{};
+			stack::check<basic_protected_function>(lua_state(), -1, handler);
+#endif // Safety
+		}
+
+		template <typename Fx>
+		int dump(lua_Writer writer, void* userdata, bool strip, Fx&& on_error) const {
+			this->push();
+			auto ppn = stack::push_popper_n<false>(this->lua_state(), 1);
+			int r = lua_dump(this->lua_state(), writer, userdata, strip ? 1 : 0);
+			if (r != 0) {
+				return on_error(this->lua_state(), r, writer, userdata, strip);
+			}
+			return r;
+		}
+
+		int dump(lua_Writer writer, void* userdata, bool strip = false) const {
+			return dump(writer, userdata, strip, &dump_pass_on_error);
+		}
+
+		template <typename Container = bytecode>
+		Container dump() const {
+			Container bc;
+			(void)dump(static_cast<lua_Writer>(&basic_insert_dump_writer<Container>), static_cast<void*>(&bc), false, &dump_throw_on_error);
+			return bc;
+		}
+
+		template <typename Container = bytecode, typename Fx>
+		Container dump(Fx&& on_error) const {
+			Container bc;
+			(void)dump(static_cast<lua_Writer>(&basic_insert_dump_writer<Container>), static_cast<void*>(&bc), false, std::forward<Fx>(on_error));
+			return bc;
+		}
+
+		template <typename... Args>
+		protected_function_result operator()(Args&&... args) const {
+			return call<>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) operator()(types<Ret...>, Args&&... args) const {
+			return call<Ret...>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) call(Args&&... args) const {
+			if constexpr (!aligned) {
+				// we do not expect the function to already be on the stack: push it
+				if (error_handler.valid()) {
+					detail::protected_handler<true, handler_t> h(error_handler);
+					base_t::push();
+					int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
+					return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount, h);
+				}
+				else {
+					detail::protected_handler<false, handler_t> h(error_handler);
+					base_t::push();
+					int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
+					return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount, h);
+				}
+			}
+			else {
+				// the function is already on the stack at the right location
+				if (error_handler.valid()) {
+					// the handler will be pushed onto the stack manually,
+					// since it's not already on the stack this means we need to push our own
+					// function on the stack too and swap things to be in-place
+					if constexpr (!is_stack_handler::value) {
+						// so, we need to remove the function at the top and then dump the handler out ourselves
+						base_t::push();
+					}
+					detail::protected_handler<true, handler_t> h(error_handler);
+					if constexpr (!is_stack_handler::value) {
+						lua_replace(lua_state(), -3);
+						h.stackindex = lua_absindex(lua_state(), -2);
+					}
+					int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
+					return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount, h);
+				}
+				else {
+					detail::protected_handler<false, handler_t> h(error_handler);
+					int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
+					return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount, h);
+				}
+			}
+		}
+	};
+} // namespace sol
+
+// end of sol/protected_function.hpp
+
+#include <functional>
+
+namespace sol {
+	template <typename... Ret, typename... Args>
+	decltype(auto) stack_proxy::call(Args&&... args) {
+		stack_function sf(this->lua_state(), this->stack_index());
+		return sf.template call<Ret...>(std::forward<Args>(args)...);
+	}
+
+	inline protected_function_result::protected_function_result(unsafe_function_result&& o) noexcept
+	: L(o.lua_state()), index(o.stack_index()), returncount(o.return_count()), popcount(o.return_count()), err(o.status()) {
+		// Must be manual, otherwise destructor will screw us
+		// return count being 0 is enough to keep things clean
+		// but we will be thorough
+		o.abandon();
+	}
+
+	inline protected_function_result& protected_function_result::operator=(unsafe_function_result&& o) noexcept {
+		L = o.lua_state();
+		index = o.stack_index();
+		returncount = o.return_count();
+		popcount = o.return_count();
+		err = o.status();
+		// Must be manual, otherwise destructor will screw us
+		// return count being 0 is enough to keep things clean
+		// but we will be thorough
+		o.abandon();
+		return *this;
+	}
+
+	inline unsafe_function_result::unsafe_function_result(protected_function_result&& o) noexcept
+	: L(o.lua_state()), index(o.stack_index()), returncount(o.return_count()) {
+		// Must be manual, otherwise destructor will screw us
+		// return count being 0 is enough to keep things clean
+		// but we will be thorough
+		o.abandon();
+	}
+	inline unsafe_function_result& unsafe_function_result::operator=(protected_function_result&& o) noexcept {
+		L = o.lua_state();
+		index = o.stack_index();
+		returncount = o.return_count();
+		// Must be manual, otherwise destructor will screw us
+		// return count being 0 is enough to keep things clean
+		// but we will be thorough
+		o.abandon();
+		return *this;
+	}
+
+	namespace detail {
+		template <typename... R>
+		struct std_shim {
+			unsafe_function lua_func_;
+
+			std_shim(unsafe_function lua_func) : lua_func_(std::move(lua_func)) {
+			}
+
+			template <typename... Args>
+			meta::return_type_t<R...> operator()(Args&&... args) {
+				return lua_func_.call<R...>(std::forward<Args>(args)...);
+			}
+		};
+
+		template <>
+		struct std_shim<void> {
+			unsafe_function lua_func_;
+
+			std_shim(unsafe_function lua_func) : lua_func_(std::move(lua_func)) {
+			}
+
+			template <typename... Args>
+			void operator()(Args&&... args) {
+				lua_func_.call<void>(std::forward<Args>(args)...);
+			}
+		};
+	} // namespace detail
+
+	namespace stack {
+		template <typename Signature>
+		struct unqualified_getter<std::function<Signature>> {
+			typedef meta::bind_traits<Signature> fx_t;
+			typedef typename fx_t::args_list args_lists;
+			typedef meta::tuple_types<typename fx_t::return_type> return_types;
+
+			template <typename... R>
+			static std::function<Signature> get_std_func(types<R...>, lua_State* L, int index) {
+				detail::std_shim<R...> fx(unsafe_function(L, index));
+				return fx;
+			}
+
+			static std::function<Signature> get(lua_State* L, int index, record& tracking) {
+				tracking.use(1);
+				type t = type_of(L, index);
+				if (t == type::none || t == type::lua_nil) {
+					return nullptr;
+				}
+				return get_std_func(return_types(), L, index);
+			}
+		};
+
+		template <typename Allocator>
+		struct unqualified_getter<basic_bytecode<Allocator>> {
+			static basic_bytecode<Allocator> get(lua_State* L, int index, record& tracking) {
+				tracking.use(1);
+				stack_function sf(L, index);
+				return sf.dump(&dump_panic_on_error);
+			}
+		};
+	} // namespace stack
+
+} // namespace sol
+
+// end of sol/function.hpp
+
+// beginning of sol/usertype.hpp
+
+// beginning of sol/usertype_core.hpp
+
+// beginning of sol/deprecate.hpp
+
+#ifndef SOL_DEPRECATED
+#ifdef _MSC_VER
+#define SOL_DEPRECATED __declspec(deprecated)
+#elif __GNUC__
+#define SOL_DEPRECATED __attribute__((deprecated))
+#else
+#define SOL_DEPRECATED [[deprecated]]
+#endif // compilers
+#endif // SOL_DEPRECATED
+
+namespace sol {
+namespace detail {
+	template <typename T>
+	struct SOL_DEPRECATED deprecate_type {
+		using type = T;
+	};
+}
+} // namespace sol::detail
+
+// end of sol/deprecate.hpp
+
+// beginning of sol/usertype_container_launch.hpp
+
+// beginning of sol/usertype_container.hpp
+
+namespace sol {
+
+	template <typename T>
+	struct usertype_container;
+
+	namespace container_detail {
+
+		template <typename T>
+		struct has_clear_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::clear));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_empty_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::empty));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_erase_after_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(
+			     decltype(std::declval<C>().erase_after(std::declval<std::add_rvalue_reference_t<typename C::const_iterator>>()))*);
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T, typename = void>
+		struct has_find_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(std::declval<C>().find(std::declval<std::add_rvalue_reference_t<typename C::value_type>>()))*);
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_find_test<T, std::enable_if_t<meta::is_lookup<T>::value>> {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(std::declval<C>().find(std::declval<std::add_rvalue_reference_t<typename C::key_type>>()))*);
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_erase_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(std::declval<C>().erase(std::declval<typename C::iterator>()))*);
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_erase_key_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(std::declval<C>().erase(std::declval<typename C::key_type>()))*);
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_find_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::find));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_index_of_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::index_of));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_insert_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::insert));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_erase_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::erase));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_index_set_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::index_set));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_index_get_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::index_get));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_set_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::set));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_get_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::get));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_at_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::at));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_pairs_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::pairs));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_ipairs_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::ipairs));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_next_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::next));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_add_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::add));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_size_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::size));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		using has_clear = meta::boolean<has_clear_test<T>::value>;
+
+		template <typename T>
+		using has_empty = meta::boolean<has_empty_test<T>::value>;
+
+		template <typename T>
+		using has_find = meta::boolean<has_find_test<T>::value>;
+
+		template <typename T>
+		using has_erase = meta::boolean<has_erase_test<T>::value>;
+
+		template <typename T>
+		using has_erase_key = meta::boolean<has_erase_key_test<T>::value>;
+
+		template <typename T>
+		using has_erase_after = meta::boolean<has_erase_after_test<T>::value>;
+
+		template <typename T>
+		using has_traits_get = meta::boolean<has_traits_get_test<T>::value>;
+
+		template <typename T>
+		using has_traits_at = meta::boolean<has_traits_at_test<T>::value>;
+
+		template <typename T>
+		using has_traits_set = meta::boolean<has_traits_set_test<T>::value>;
+
+		template <typename T>
+		using has_traits_index_get = meta::boolean<has_traits_index_get_test<T>::value>;
+
+		template <typename T>
+		using has_traits_index_set = meta::boolean<has_traits_index_set_test<T>::value>;
+
+		template <typename T>
+		using has_traits_pairs = meta::boolean<has_traits_pairs_test<T>::value>;
+
+		template <typename T>
+		using has_traits_ipairs = meta::boolean<has_traits_ipairs_test<T>::value>;
+
+		template <typename T>
+		using has_traits_next = meta::boolean<has_traits_next_test<T>::value>;
+
+		template <typename T>
+		using has_traits_add = meta::boolean<has_traits_add_test<T>::value>;
+
+		template <typename T>
+		using has_traits_size = meta::boolean<has_traits_size_test<T>::value>;
+
+		template <typename T>
+		using has_traits_clear = has_clear<T>;
+
+		template <typename T>
+		using has_traits_empty = has_empty<T>;
+
+		template <typename T>
+		using has_traits_find = meta::boolean<has_traits_find_test<T>::value>;
+
+		template <typename T>
+		using has_traits_index_of = meta::boolean<has_traits_index_of_test<T>::value>;
+
+		template <typename T>
+		using has_traits_insert = meta::boolean<has_traits_insert_test<T>::value>;
+
+		template <typename T>
+		using has_traits_erase = meta::boolean<has_traits_erase_test<T>::value>;
+
+		template <typename T>
+		struct is_forced_container : is_container<T> {};
+
+		template <typename T>
+		struct is_forced_container<as_container_t<T>> : std::true_type {};
+
+		template <typename T>
+		struct container_decay {
+			typedef T type;
+		};
+
+		template <typename T>
+		struct container_decay<as_container_t<T>> {
+			typedef T type;
+		};
+
+		template <typename T>
+		using container_decay_t = typename container_decay<meta::unqualified_t<T>>::type;
+
+		template <typename T>
+		decltype(auto) get_key(std::false_type, T&& t) {
+			return std::forward<T>(t);
+		}
+
+		template <typename T>
+		decltype(auto) get_key(std::true_type, T&& t) {
+			return t.first;
+		}
+
+		template <typename T>
+		decltype(auto) get_value(std::false_type, T&& t) {
+			return std::forward<T>(t);
+		}
+
+		template <typename T>
+		decltype(auto) get_value(std::true_type, T&& t) {
+			return t.second;
+		}
+
+		template <typename X, typename = void>
+		struct usertype_container_default {
+		private:
+			typedef std::remove_pointer_t<meta::unwrap_unqualified_t<X>> T;
+
+		public:
+			typedef lua_nil_t iterator;
+			typedef lua_nil_t value_type;
+
+			static int at(lua_State* L) {
+				return luaL_error(L, "sol: cannot call 'at(index)' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int get(lua_State* L) {
+				return luaL_error(L, "sol: cannot call 'get(key)' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int index_get(lua_State* L) {
+				return luaL_error(L, "sol: cannot call 'container[key]' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int set(lua_State* L) {
+				return luaL_error(L, "sol: cannot call 'set(key, value)' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int index_set(lua_State* L) {
+				return luaL_error(
+				     L, "sol: cannot call 'container[key] = value' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int add(lua_State* L) {
+				return luaL_error(L, "sol: cannot call 'add' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int insert(lua_State* L) {
+				return luaL_error(L, "sol: cannot call 'insert' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int find(lua_State* L) {
+				return luaL_error(L, "sol: cannot call 'find' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int index_of(lua_State* L) {
+				return luaL_error(L, "sol: cannot call 'index_of' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int size(lua_State* L) {
+				return luaL_error(L, "sol: cannot call 'end' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int clear(lua_State* L) {
+				return luaL_error(L, "sol: cannot call 'clear' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int empty(lua_State* L) {
+				return luaL_error(L, "sol: cannot call 'empty' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int erase(lua_State* L) {
+				return luaL_error(L, "sol: cannot call 'erase' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int next(lua_State* L) {
+				return luaL_error(L, "sol: cannot call 'next' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int pairs(lua_State* L) {
+				return luaL_error(L, "sol: cannot call '__pairs/pairs' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int ipairs(lua_State* L) {
+				return luaL_error(L, "sol: cannot call '__ipairs' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static iterator begin(lua_State* L, T&) {
+				luaL_error(L, "sol: cannot call 'being' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+				return lua_nil;
+			}
+
+			static iterator end(lua_State* L, T&) {
+				luaL_error(L, "sol: cannot call 'end' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+				return lua_nil;
+			}
+		};
+
+		template <typename X>
+		struct usertype_container_default<X,
+		     std::enable_if_t<meta::all<is_forced_container<meta::unqualified_t<X>>, meta::has_value_type<meta::unqualified_t<container_decay_t<X>>>,
+		          meta::has_iterator<meta::unqualified_t<container_decay_t<X>>>>::value>> {
+		private:
+			using T = std::remove_pointer_t<meta::unwrap_unqualified_t<container_decay_t<X>>>;
+
+		private:
+			using deferred_uc = usertype_container<X>;
+			using is_associative = meta::is_associative<T>;
+			using is_lookup = meta::is_lookup<T>;
+			using is_ordered = meta::is_ordered<T>;
+			using is_matched_lookup = meta::is_matched_lookup<T>;
+			using iterator = typename T::iterator;
+			using value_type = typename T::value_type;
+			typedef meta::conditional_t<is_matched_lookup::value, std::pair<value_type, value_type>,
+			     meta::conditional_t<is_associative::value || is_lookup::value, value_type, std::pair<std::ptrdiff_t, value_type>>>
+			     KV;
+			typedef typename KV::first_type K;
+			typedef typename KV::second_type V;
+			typedef meta::conditional_t<is_matched_lookup::value, std::ptrdiff_t, K> next_K;
+			typedef decltype(*std::declval<iterator&>()) iterator_return;
+			typedef meta::conditional_t<is_associative::value || is_matched_lookup::value, std::add_lvalue_reference_t<V>,
+			     meta::conditional_t<is_lookup::value, V, iterator_return>>
+			     captured_type;
+			typedef typename meta::iterator_tag<iterator>::type iterator_category;
+			typedef std::is_same<iterator_category, std::input_iterator_tag> is_input_iterator;
+			typedef meta::conditional_t<is_input_iterator::value, V, decltype(detail::deref_move_only(std::declval<captured_type>()))> push_type;
+			typedef std::is_copy_assignable<V> is_copyable;
+			typedef meta::neg<meta::any<std::is_const<V>, std::is_const<std::remove_reference_t<iterator_return>>, meta::neg<is_copyable>>> is_writable;
+			typedef meta::unqualified_t<decltype(get_key(is_associative(), std::declval<std::add_lvalue_reference_t<value_type>>()))> key_type;
+			typedef meta::all<std::is_integral<K>, meta::neg<meta::any<is_associative, is_lookup>>> is_linear_integral;
+
+			struct iter {
+				T& source;
+				iterator it;
+				std::size_t i;
+
+				iter(T& source, iterator it) : source(source), it(std::move(it)), i(0) {
+				}
+
+				~iter() {
+				}
+			};
+
+			static auto& get_src(lua_State* L) {
+#if SOL_IS_ON(SOL_SAFE_USERTYPE_I_)
+				auto p = stack::unqualified_check_get<T*>(L, 1);
+				if (!p) {
+					luaL_error(L,
+					     "sol: 'self' is not of type '%s' (pass 'self' as first argument with ':' or call on proper type)",
+					     detail::demangle<T>().c_str());
+				}
+				if (p.value() == nullptr) {
+					luaL_error(
+					     L, "sol: 'self' argument is nil (pass 'self' as first argument with ':' or call on a '%s' type)", detail::demangle<T>().c_str());
+				}
+				return *p.value();
+#else
+				return stack::unqualified_get<T>(L, 1);
+#endif // Safe getting with error
+			}
+
+			static detail::error_result at_category(std::input_iterator_tag, lua_State* L, T& self, std::ptrdiff_t pos) {
+				pos += deferred_uc::index_adjustment(L, self);
+				if (pos < 0) {
+					return stack::push(L, lua_nil);
+				}
+				auto it = deferred_uc::begin(L, self);
+				auto e = deferred_uc::end(L, self);
+				if (it == e) {
+					return stack::push(L, lua_nil);
+				}
+				while (pos > 0) {
+					--pos;
+					++it;
+					if (it == e) {
+						return stack::push(L, lua_nil);
+					}
+				}
+				return get_associative(is_associative(), L, it);
+			}
+
+			static detail::error_result at_category(std::random_access_iterator_tag, lua_State* L, T& self, std::ptrdiff_t pos) {
+				std::ptrdiff_t len = static_cast<std::ptrdiff_t>(size_start(L, self));
+				pos += deferred_uc::index_adjustment(L, self);
+				if (pos < 0 || pos >= len) {
+					return stack::push(L, lua_nil);
+				}
+				auto it = std::next(deferred_uc::begin(L, self), pos);
+				return get_associative(is_associative(), L, it);
+			}
+
+			static detail::error_result at_start(lua_State* L, T& self, std::ptrdiff_t pos) {
+				return at_category(iterator_category(), L, self, pos);
+			}
+
+			template <typename Iter>
+			static detail::error_result get_associative(std::true_type, lua_State* L, Iter& it) {
+				decltype(auto) v = *it;
+				return stack::stack_detail::push_reference<push_type>(L, detail::deref_move_only(v.second));
+			}
+
+			template <typename Iter>
+			static detail::error_result get_associative(std::false_type, lua_State* L, Iter& it) {
+				return stack::stack_detail::push_reference<push_type>(L, detail::deref_move_only(*it));
+			}
+
+			static detail::error_result get_category(std::input_iterator_tag, lua_State* L, T& self, K& key) {
+				key += deferred_uc::index_adjustment(L, self);
+				if (key < 0) {
+					return stack::push(L, lua_nil);
+				}
+				auto it = deferred_uc::begin(L, self);
+				auto e = deferred_uc::end(L, self);
+				if (it == e) {
+					return stack::push(L, lua_nil);
+				}
+				while (key > 0) {
+					--key;
+					++it;
+					if (it == e) {
+						return stack::push(L, lua_nil);
+					}
+				}
+				return get_associative(is_associative(), L, it);
+			}
+
+			static detail::error_result get_category(std::random_access_iterator_tag, lua_State* L, T& self, K& key) {
+				std::ptrdiff_t len = static_cast<std::ptrdiff_t>(size_start(L, self));
+				key += deferred_uc::index_adjustment(L, self);
+				if (key < 0 || key >= len) {
+					return stack::push(L, lua_nil);
+				}
+				auto it = std::next(deferred_uc::begin(L, self), key);
+				return get_associative(is_associative(), L, it);
+			}
+
+			static detail::error_result get_it(std::true_type, lua_State* L, T& self, K& key) {
+				return get_category(iterator_category(), L, self, key);
+			}
+
+			static detail::error_result get_comparative(std::true_type, lua_State* L, T& self, K& key) {
+				auto fx = [&](const value_type& r) -> bool { return key == get_key(is_associative(), r); };
+				auto e = deferred_uc::end(L, self);
+				auto it = std::find_if(deferred_uc::begin(L, self), e, std::ref(fx));
+				if (it == e) {
+					return stack::push(L, lua_nil);
+				}
+				return get_associative(is_associative(), L, it);
+			}
+
+			static detail::error_result get_comparative(std::false_type, lua_State*, T&, K&) {
+				return detail::error_result("cannot get this key on '%s': no suitable way to increment iterator and compare to key value '%s'",
+				     detail::demangle<T>().data(),
+				     detail::demangle<K>().data());
+			}
+
+			static detail::error_result get_it(std::false_type, lua_State* L, T& self, K& key) {
+				return get_comparative(meta::supports_op_equal<K, key_type>(), L, self, key);
+			}
+
+			static detail::error_result set_associative(std::true_type, iterator& it, stack_object value) {
+				decltype(auto) v = *it;
+				v.second = value.as<V>();
+				return {};
+			}
+
+			static detail::error_result set_associative(std::false_type, iterator& it, stack_object value) {
+				decltype(auto) v = *it;
+				v = value.as<V>();
+				return {};
+			}
+
+			static detail::error_result set_writable(std::true_type, lua_State*, T&, iterator& it, stack_object value) {
+				return set_associative(is_associative(), it, std::move(value));
+			}
+
+			static detail::error_result set_writable(std::false_type, lua_State*, T&, iterator&, stack_object) {
+				return detail::error_result(
+				     "cannot perform a 'set': '%s's iterator reference is not writable (non-copy-assignable or const)", detail::demangle<T>().data());
+			}
+
+			static detail::error_result set_category(std::input_iterator_tag, lua_State* L, T& self, stack_object okey, stack_object value) {
+				decltype(auto) key = okey.as<K>();
+				key += deferred_uc::index_adjustment(L, self);
+				auto e = deferred_uc::end(L, self);
+				auto it = deferred_uc::begin(L, self);
+				auto backit = it;
+				for (; key > 0 && it != e; --key, ++it) {
+					backit = it;
+				}
+				if (it == e) {
+					if (key == 0) {
+						return add_copyable(is_copyable(), L, self, std::move(value), meta::has_insert_after<T>::value ? backit : it);
+					}
+					return detail::error_result("out of bounds (too big) for set on '%s'", detail::demangle<T>().c_str());
+				}
+				return set_writable(is_writable(), L, self, it, std::move(value));
+			}
+
+			static detail::error_result set_category(std::random_access_iterator_tag, lua_State* L, T& self, stack_object okey, stack_object value) {
+				decltype(auto) key = okey.as<K>();
+				key += deferred_uc::index_adjustment(L, self);
+				if (key < 0) {
+					return detail::error_result("sol: out of bounds (too small) for set on '%s'", detail::demangle<T>().c_str());
+				}
+				std::ptrdiff_t len = static_cast<std::ptrdiff_t>(size_start(L, self));
+				if (key == len) {
+					return add_copyable(is_copyable(), L, self, std::move(value));
+				}
+				else if (key >= len) {
+					return detail::error_result("sol: out of bounds (too big) for set on '%s'", detail::demangle<T>().c_str());
+				}
+				auto it = std::next(deferred_uc::begin(L, self), key);
+				return set_writable(is_writable(), L, self, it, std::move(value));
+			}
+
+			static detail::error_result set_comparative(std::true_type, lua_State* L, T& self, stack_object okey, stack_object value) {
+				decltype(auto) key = okey.as<K>();
+				if (!is_writable::value) {
+					return detail::error_result(
+					     "cannot perform a 'set': '%s's iterator reference is not writable (non-copy-assignable or const)", detail::demangle<T>().data());
+				}
+				auto fx = [&](const value_type& r) -> bool { return key == get_key(is_associative(), r); };
+				auto e = deferred_uc::end(L, self);
+				auto it = std::find_if(deferred_uc::begin(L, self), e, std::ref(fx));
+				if (it == e) {
+					return {};
+				}
+				return set_writable(is_writable(), L, self, it, std::move(value));
+			}
+
+			static detail::error_result set_comparative(std::false_type, lua_State*, T&, stack_object, stack_object) {
+				return detail::error_result("cannot set this value on '%s': no suitable way to increment iterator or compare to '%s' key",
+				     detail::demangle<T>().data(),
+				     detail::demangle<K>().data());
+			}
+
+			template <typename Iter>
+			static detail::error_result set_associative_insert(std::true_type, lua_State*, T& self, Iter& it, K& key, stack_object value) {
+				if constexpr (meta::has_insert<T>::value) {
+					self.insert(it, value_type(key, value.as<V>()));
+					return {};
+				}
+				else {
+					(void)self;
+					(void)it;
+					(void)key;
+					return detail::error_result(
+					     "cannot call 'set' on '%s': there is no 'insert' function on this associative type", detail::demangle<T>().c_str());
+				}
+			}
+
+			template <typename Iter>
+			static detail::error_result set_associative_insert(std::false_type, lua_State*, T& self, Iter& it, K& key, stack_object) {
+				if constexpr (meta::has_insert<T>::value) {
+					self.insert(it, key);
+					return {};
+				}
+				else {
+					(void)self;
+					(void)it;
+					(void)key;
+					return detail::error_result(
+					     "cannot call 'set' on '%s': there is no 'insert' function on this non-associative type", detail::demangle<T>().c_str());
+				}
+			}
+
+			static detail::error_result set_associative_find(std::true_type, lua_State* L, T& self, stack_object okey, stack_object value) {
+				decltype(auto) key = okey.as<K>();
+				auto it = self.find(key);
+				if (it == deferred_uc::end(L, self)) {
+					return set_associative_insert(is_associative(), L, self, it, key, std::move(value));
+				}
+				return set_writable(is_writable(), L, self, it, std::move(value));
+			}
+
+			static detail::error_result set_associative_find(std::false_type, lua_State* L, T& self, stack_object key, stack_object value) {
+				return set_comparative(meta::supports_op_equal<K, key_type>(), L, self, std::move(key), std::move(value));
+			}
+
+			static detail::error_result set_it(std::true_type, lua_State* L, T& self, stack_object key, stack_object value) {
+				return set_category(iterator_category(), L, self, std::move(key), std::move(value));
+			}
+
+			static detail::error_result set_it(std::false_type, lua_State* L, T& self, stack_object key, stack_object value) {
+				return set_associative_find(meta::all<has_find<T>, meta::any<is_associative, is_lookup>>(), L, self, std::move(key), std::move(value));
+			}
+
+			template <bool idx_of = false>
+			static detail::error_result find_has_associative_lookup(std::true_type, lua_State* L, T& self) {
+				if constexpr (!is_ordered::value && idx_of) {
+					(void)L;
+					(void)self;
+					return detail::error_result("cannot perform an 'index_of': '%s's is not an ordered container", detail::demangle<T>().data());
+				}
+				else {
+					decltype(auto) key = stack::unqualified_get<K>(L, 2);
+					auto it = self.find(key);
+					if (it == deferred_uc::end(L, self)) {
+						return stack::push(L, lua_nil);
+					}
+					if constexpr (idx_of) {
+						auto dist = std::distance(deferred_uc::begin(L, self), it);
+						dist -= deferred_uc::index_adjustment(L, self);
+						return stack::push(L, dist);
+					}
+					else {
+						return get_associative(is_associative(), L, it);
+					}
+				}
+			}
+
+			template <bool idx_of = false>
+			static detail::error_result find_has_associative_lookup(std::false_type, lua_State* L, T& self) {
+				if constexpr (!is_ordered::value && idx_of) {
+					(void)L;
+					(void)self;
+					return detail::error_result("cannot perform an 'index_of': '%s's is not an ordered container", detail::demangle<T>().data());
+				}
+				else {
+					decltype(auto) value = stack::unqualified_get<V>(L, 2);
+					auto it = self.find(value);
+					if (it == deferred_uc::end(L, self)) {
+						return stack::push(L, lua_nil);
+					}
+					if constexpr (idx_of) {
+						auto dist = std::distance(deferred_uc::begin(L, self), it);
+						dist -= deferred_uc::index_adjustment(L, self);
+						return stack::push(L, dist);
+					}
+					else {
+						return get_associative(is_associative(), L, it);
+					}
+				}
+			}
+
+			template <bool idx_of = false>
+			static detail::error_result find_has(std::true_type, lua_State* L, T& self) {
+				return find_has_associative_lookup<idx_of>(meta::any<is_lookup, is_associative>(), L, self);
+			}
+
+			template <typename Iter>
+			static detail::error_result find_associative_lookup(std::true_type, lua_State* L, T&, Iter& it, std::size_t) {
+				return get_associative(is_associative(), L, it);
+			}
+
+			template <typename Iter>
+			static detail::error_result find_associative_lookup(std::false_type, lua_State* L, T& self, Iter&, std::size_t idx) {
+				idx -= deferred_uc::index_adjustment(L, self);
+				return stack::push(L, idx);
+			}
+
+			template <bool = false>
+			static detail::error_result find_comparative(std::false_type, lua_State*, T&) {
+				return detail::error_result("cannot call 'find' on '%s': there is no 'find' function and the value_type is not equality comparable",
+				     detail::demangle<T>().c_str());
+			}
+
+			template <bool idx_of = false>
+			static detail::error_result find_comparative(std::true_type, lua_State* L, T& self) {
+				decltype(auto) value = stack::unqualified_get<V>(L, 2);
+				auto it = deferred_uc::begin(L, self);
+				auto e = deferred_uc::end(L, self);
+				std::size_t idx = 0;
+				for (;; ++it, ++idx) {
+					if (it == e) {
+						return stack::push(L, lua_nil);
+					}
+					if (value == get_value(is_associative(), *it)) {
+						break;
+					}
+				}
+				return find_associative_lookup(meta::all<meta::boolean<!idx_of>, meta::any<is_lookup, is_associative>>(), L, self, it, idx);
+			}
+
+			template <bool idx_of = false>
+			static detail::error_result find_has(std::false_type, lua_State* L, T& self) {
+				return find_comparative<idx_of>(meta::supports_op_equal<V>(), L, self);
+			}
+
+			template <typename Iter>
+			static detail::error_result add_insert_after(std::false_type, lua_State* L, T& self, stack_object value, Iter&) {
+				return add_insert_after(std::false_type(), L, self, value);
+			}
+
+			static detail::error_result add_insert_after(std::false_type, lua_State*, T&, stack_object) {
+				return detail::error_result("cannot call 'add' on type '%s': no suitable insert/push_back C++ functions", detail::demangle<T>().data());
+			}
+
+			template <typename Iter>
+			static detail::error_result add_insert_after(std::true_type, lua_State*, T& self, stack_object value, Iter& pos) {
+				self.insert_after(pos, value.as<V>());
+				return {};
+			}
+
+			static detail::error_result add_insert_after(std::true_type, lua_State* L, T& self, stack_object value) {
+				auto backit = self.before_begin();
+				{
+					auto e = deferred_uc::end(L, self);
+					for (auto it = deferred_uc::begin(L, self); it != e; ++backit, ++it) {
+					}
+				}
+				return add_insert_after(std::true_type(), L, self, value, backit);
+			}
+
+			template <typename Iter>
+			static detail::error_result add_insert(std::true_type, lua_State*, T& self, stack_object value, Iter& pos) {
+				self.insert(pos, value.as<V>());
+				return {};
+			}
+
+			static detail::error_result add_insert(std::true_type, lua_State* L, T& self, stack_object value) {
+				auto pos = deferred_uc::end(L, self);
+				return add_insert(std::true_type(), L, self, value, pos);
+			}
+
+			template <typename Iter>
+			static detail::error_result add_insert(std::false_type, lua_State* L, T& self, stack_object value, Iter& pos) {
+				return add_insert_after(meta::has_insert_after<T>(), L, self, std::move(value), pos);
+			}
+
+			static detail::error_result add_insert(std::false_type, lua_State* L, T& self, stack_object value) {
+				return add_insert_after(meta::has_insert_after<T>(), L, self, std::move(value));
+			}
+
+			template <typename Iter>
+			static detail::error_result add_push_back(std::true_type, lua_State*, T& self, stack_object value, Iter&) {
+				self.push_back(value.as<V>());
+				return {};
+			}
+
+			static detail::error_result add_push_back(std::true_type, lua_State*, T& self, stack_object value) {
+				self.push_back(value.as<V>());
+				return {};
+			}
+
+			template <typename Iter>
+			static detail::error_result add_push_back(std::false_type, lua_State* L, T& self, stack_object value, Iter& pos) {
+				return add_insert(meta::has_insert<T>(), L, self, value, pos);
+			}
+
+			static detail::error_result add_push_back(std::false_type, lua_State* L, T& self, stack_object value) {
+				return add_insert(meta::has_insert<T>(), L, self, value);
+			}
+
+			template <typename Iter>
+			static detail::error_result add_associative(std::true_type, lua_State* L, T& self, stack_object key, Iter& pos) {
+				if constexpr (meta::has_insert<T>::value) {
+					self.insert(pos, value_type(key.as<K>(), stack::unqualified_get<V>(L, 3)));
+					return {};
+				}
+				else {
+					(void)L;
+					(void)self;
+					(void)key;
+					(void)pos;
+					return detail::error_result(
+					     "cannot call 'insert' on '%s': there is no 'insert' function on this associative type", detail::demangle<T>().c_str());
+				}
+			}
+
+			static detail::error_result add_associative(std::true_type, lua_State* L, T& self, stack_object key) {
+				auto pos = deferred_uc::end(L, self);
+				return add_associative(std::true_type(), L, self, std::move(key), pos);
+			}
+
+			template <typename Iter>
+			static detail::error_result add_associative(std::false_type, lua_State* L, T& self, stack_object value, Iter& pos) {
+				return add_push_back(meta::has_push_back<T>(), L, self, value, pos);
+			}
+
+			static detail::error_result add_associative(std::false_type, lua_State* L, T& self, stack_object value) {
+				return add_push_back(meta::has_push_back<T>(), L, self, value);
+			}
+
+			template <typename Iter>
+			static detail::error_result add_copyable(std::true_type, lua_State* L, T& self, stack_object value, Iter& pos) {
+				return add_associative(is_associative(), L, self, std::move(value), pos);
+			}
+
+			static detail::error_result add_copyable(std::true_type, lua_State* L, T& self, stack_object value) {
+				return add_associative(is_associative(), L, self, value);
+			}
+
+			template <typename Iter>
+			static detail::error_result add_copyable(std::false_type, lua_State* L, T& self, stack_object value, Iter&) {
+				return add_copyable(std::false_type(), L, self, std::move(value));
+			}
+
+			static detail::error_result add_copyable(std::false_type, lua_State*, T&, stack_object) {
+				return detail::error_result("cannot call 'add' on '%s': value_type is non-copyable", detail::demangle<T>().data());
+			}
+
+			static detail::error_result insert_lookup(std::true_type, lua_State* L, T& self, stack_object, stack_object value) {
+				// TODO: should we warn or error about someone calling insert on an ordered / lookup container with no associativity?
+				return add_copyable(std::true_type(), L, self, std::move(value));
+			}
+
+			static detail::error_result insert_lookup(std::false_type, lua_State* L, T& self, stack_object where, stack_object value) {
+				auto it = deferred_uc::begin(L, self);
+				auto key = where.as<K>();
+				key += deferred_uc::index_adjustment(L, self);
+				std::advance(it, key);
+				self.insert(it, value.as<V>());
+				return {};
+			}
+
+			static detail::error_result insert_after_has(std::true_type, lua_State* L, T& self, stack_object where, stack_object value) {
+				auto key = where.as<K>();
+				auto backit = self.before_begin();
+				{
+					key += deferred_uc::index_adjustment(L, self);
+					auto e = deferred_uc::end(L, self);
+					for (auto it = deferred_uc::begin(L, self); key > 0; ++backit, ++it, --key) {
+						if (backit == e) {
+							return detail::error_result("sol: out of bounds (too big) for set on '%s'", detail::demangle<T>().c_str());
+						}
+					}
+				}
+				self.insert_after(backit, value.as<V>());
+				return {};
+			}
+
+			static detail::error_result insert_after_has(std::false_type, lua_State*, T&, stack_object, stack_object) {
+				return detail::error_result(
+				     "cannot call 'insert' on '%s': no suitable or similar functionality detected on this container", detail::demangle<T>().data());
+			}
+
+			static detail::error_result insert_has(std::true_type, lua_State* L, T& self, stack_object key, stack_object value) {
+				return insert_lookup(meta::any<is_associative, is_lookup>(), L, self, std::move(key), std::move(value));
+			}
+
+			static detail::error_result insert_has(std::false_type, lua_State* L, T& self, stack_object where, stack_object value) {
+				return insert_after_has(meta::has_insert_after<T>(), L, self, where, value);
+			}
+
+			static detail::error_result insert_copyable(std::true_type, lua_State* L, T& self, stack_object key, stack_object value) {
+				return insert_has(meta::has_insert<T>(), L, self, std::move(key), std::move(value));
+			}
+
+			static detail::error_result insert_copyable(std::false_type, lua_State*, T&, stack_object, stack_object) {
+				return detail::error_result("cannot call 'insert' on '%s': value_type is non-copyable", detail::demangle<T>().data());
+			}
+
+			static detail::error_result erase_integral(std::true_type, lua_State* L, T& self, K& key) {
+				auto it = deferred_uc::begin(L, self);
+				key += deferred_uc::index_adjustment(L, self);
+				std::advance(it, key);
+				self.erase(it);
+
+				return {};
+			}
+
+			static detail::error_result erase_integral(std::false_type, lua_State* L, T& self, const K& key) {
+				auto fx = [&](const value_type& r) -> bool { return key == r; };
+				auto e = deferred_uc::end(L, self);
+				auto it = std::find_if(deferred_uc::begin(L, self), e, std::ref(fx));
+				if (it == e) {
+					return {};
+				}
+				self.erase(it);
+
+				return {};
+			}
+
+			static detail::error_result erase_associative_lookup(std::true_type, lua_State*, T& self, const K& key) {
+				self.erase(key);
+				return {};
+			}
+
+			static detail::error_result erase_associative_lookup(std::false_type, lua_State* L, T& self, K& key) {
+				return erase_integral(std::is_integral<K>(), L, self, key);
+			}
+
+			static detail::error_result erase_after_has(std::true_type, lua_State* L, T& self, K& key) {
+				auto backit = self.before_begin();
+				{
+					key += deferred_uc::index_adjustment(L, self);
+					auto e = deferred_uc::end(L, self);
+					for (auto it = deferred_uc::begin(L, self); key > 0; ++backit, ++it, --key) {
+						if (backit == e) {
+							return detail::error_result("sol: out of bounds for erase on '%s'", detail::demangle<T>().c_str());
+						}
+					}
+				}
+				self.erase_after(backit);
+				return {};
+			}
+
+			static detail::error_result erase_after_has(std::false_type, lua_State*, T&, const K&) {
+				return detail::error_result("sol: cannot call erase on '%s'", detail::demangle<T>().c_str());
+			}
+
+			static detail::error_result erase_key_has(std::true_type, lua_State* L, T& self, K& key) {
+				return erase_associative_lookup(meta::any<is_associative, is_lookup>(), L, self, key);
+			}
+
+			static detail::error_result erase_key_has(std::false_type, lua_State* L, T& self, K& key) {
+				return erase_after_has(has_erase_after<T>(), L, self, key);
+			}
+
+			static detail::error_result erase_has(std::true_type, lua_State* L, T& self, K& key) {
+				return erase_associative_lookup(meta::any<is_associative, is_lookup>(), L, self, key);
+			}
+
+			static detail::error_result erase_has(std::false_type, lua_State* L, T& self, K& key) {
+				return erase_key_has(has_erase_key<T>(), L, self, key);
+			}
+
+			static auto size_has(std::false_type, lua_State* L, T& self) {
+				return std::distance(deferred_uc::begin(L, self), deferred_uc::end(L, self));
+			}
+
+			static auto size_has(std::true_type, lua_State*, T& self) {
+				return self.size();
+			}
+
+			static void clear_has(std::true_type, lua_State*, T& self) {
+				self.clear();
+			}
+
+			static void clear_has(std::false_type, lua_State* L, T&) {
+				luaL_error(L, "sol: cannot call clear on '%s'", detail::demangle<T>().c_str());
+			}
+
+			static bool empty_has(std::true_type, lua_State*, T& self) {
+				return self.empty();
+			}
+
+			static bool empty_has(std::false_type, lua_State* L, T& self) {
+				return deferred_uc::begin(L, self) == deferred_uc::end(L, self);
+			}
+
+			static detail::error_result get_associative_find(std::true_type, lua_State* L, T& self, K& key) {
+				auto it = self.find(key);
+				if (it == deferred_uc::end(L, self)) {
+					stack::push(L, lua_nil);
+					return {};
+				}
+				return get_associative(std::true_type(), L, it);
+			}
+
+			static detail::error_result get_associative_find(std::false_type, lua_State* L, T& self, K& key) {
+				return get_it(is_linear_integral(), L, self, key);
+			}
+
+			static detail::error_result get_start(lua_State* L, T& self, K& key) {
+				return get_associative_find(std::integral_constant < bool, is_associative::value&& has_find<T>::value > (), L, self, key);
+			}
+
+			static detail::error_result set_start(lua_State* L, T& self, stack_object key, stack_object value) {
+				return set_it(is_linear_integral(), L, self, std::move(key), std::move(value));
+			}
+
+			static std::size_t size_start(lua_State* L, T& self) {
+				return size_has(meta::has_size<T>(), L, self);
+			}
+
+			static void clear_start(lua_State* L, T& self) {
+				clear_has(has_clear<T>(), L, self);
+			}
+
+			static bool empty_start(lua_State* L, T& self) {
+				return empty_has(has_empty<T>(), L, self);
+			}
+
+			static detail::error_result erase_start(lua_State* L, T& self, K& key) {
+				return erase_has(has_erase<T>(), L, self, key);
+			}
+
+			template <bool ip>
+			static int next_associative(std::true_type, lua_State* L) {
+				iter& i = stack::unqualified_get<user<iter>>(L, 1);
+				auto& source = i.source;
+				auto& it = i.it;
+				if (it == deferred_uc::end(L, source)) {
+					return stack::push(L, lua_nil);
+				}
+				int p;
+				if constexpr (ip) {
+					++i.i;
+					p = stack::push_reference(L, i.i);
+				}
+				else {
+					p = stack::push_reference(L, it->first);
+				}
+				p += stack::stack_detail::push_reference<push_type>(L, detail::deref_move_only(it->second));
+				std::advance(it, 1);
+				return p;
+			}
+
+			template <bool>
+			static int next_associative(std::false_type, lua_State* L) {
+				iter& i = stack::unqualified_get<user<iter>>(L, 1);
+				auto& source = i.source;
+				auto& it = i.it;
+				next_K k = stack::unqualified_get<next_K>(L, 2);
+				if (it == deferred_uc::end(L, source)) {
+					return stack::push(L, lua_nil);
+				}
+				int p;
+				if constexpr (std::is_integral_v<next_K>) {
+					p = stack::push_reference(L, k + 1);
+				}
+				else {
+					p = stack::stack_detail::push_reference(L, k + 1);
+				}
+				p += stack::stack_detail::push_reference<push_type>(L, detail::deref_move_only(*it));
+				std::advance(it, 1);
+				return p;
+			}
+
+			template <bool ip>
+			static int next_iter(lua_State* L) {
+				typedef meta::any<is_associative, meta::all<is_lookup, meta::neg<is_matched_lookup>>> is_assoc;
+				return next_associative<ip>(is_assoc(), L);
+			}
+
+			template <bool ip>
+			static int pairs_associative(std::true_type, lua_State* L) {
+				auto& src = get_src(L);
+				stack::push(L, next_iter<ip>);
+				stack::push<user<iter>>(L, src, deferred_uc::begin(L, src));
+				stack::push(L, lua_nil);
+				return 3;
+			}
+
+			template <bool ip>
+			static int pairs_associative(std::false_type, lua_State* L) {
+				auto& src = get_src(L);
+				stack::push(L, next_iter<ip>);
+				stack::push<user<iter>>(L, src, deferred_uc::begin(L, src));
+				stack::push(L, 0);
+				return 3;
+			}
+
+		public:
+			static int at(lua_State* L) {
+				auto& self = get_src(L);
+				detail::error_result er;
+				{
+					std::ptrdiff_t pos = stack::unqualified_get<std::ptrdiff_t>(L, 2);
+					er = at_start(L, self, pos);
+				}
+				return handle_errors(L, er);
+			}
+
+			static int get(lua_State* L) {
+				auto& self = get_src(L);
+				detail::error_result er;
+				{
+					decltype(auto) key = stack::unqualified_get<K>(L);
+					er = get_start(L, self, key);
+				}
+				return handle_errors(L, er);
+			}
+
+			static int index_get(lua_State* L) {
+				return get(L);
+			}
+
+			static int set(lua_State* L) {
+				stack_object value = stack_object(L, raw_index(3));
+				if constexpr (is_linear_integral::value) {
+					// for non-associative containers,
+					// erasure only happens if it is the
+					// last index in the container
+					auto key = stack::get<K>(L, 2);
+					auto self_size = deferred_uc::size(L);
+					if (key == static_cast<K>(self_size)) {
+						if (type_of(L, 3) == type::lua_nil) {
+							return erase(L);
+						}
+					}
+				}
+				else {
+					if (type_of(L, 3) == type::lua_nil) {
+						return erase(L);
+					}
+				}
+				auto& self = get_src(L);
+				detail::error_result er = set_start(L, self, stack_object(L, raw_index(2)), std::move(value));
+				return handle_errors(L, er);
+			}
+
+			static int index_set(lua_State* L) {
+				return set(L);
+			}
+
+			static int add(lua_State* L) {
+				auto& self = get_src(L);
+				detail::error_result er = add_copyable(is_copyable(), L, self, stack_object(L, raw_index(2)));
+				return handle_errors(L, er);
+			}
+
+			static int insert(lua_State* L) {
+				auto& self = get_src(L);
+				detail::error_result er = insert_copyable(is_copyable(), L, self, stack_object(L, raw_index(2)), stack_object(L, raw_index(3)));
+				return handle_errors(L, er);
+			}
+
+			static int find(lua_State* L) {
+				auto& self = get_src(L);
+				detail::error_result er = find_has(has_find<T>(), L, self);
+				return handle_errors(L, er);
+			}
+
+			static int index_of(lua_State* L) {
+				auto& self = get_src(L);
+				detail::error_result er = find_has<true>(has_find<T>(), L, self);
+				return handle_errors(L, er);
+			}
+
+			static iterator begin(lua_State*, T& self) {
+				if constexpr (meta::has_begin_end_v<T>) {
+					return self.begin();
+				}
+				else {
+					using std::begin;
+					return begin(self);
+				}
+			}
+
+			static iterator end(lua_State*, T& self) {
+				if constexpr (meta::has_begin_end_v<T>) {
+					return self.end();
+				}
+				else {
+					using std::end;
+					return end(self);
+				}
+			}
+
+			static int size(lua_State* L) {
+				auto& self = get_src(L);
+				std::size_t r = size_start(L, self);
+				return stack::push(L, r);
+			}
+
+			static int clear(lua_State* L) {
+				auto& self = get_src(L);
+				clear_start(L, self);
+				return 0;
+			}
+
+			static int erase(lua_State* L) {
+				auto& self = get_src(L);
+				detail::error_result er;
+				{
+					decltype(auto) key = stack::unqualified_get<K>(L, 2);
+					er = erase_start(L, self, key);
+				}
+				return handle_errors(L, er);
+			}
+
+			static int empty(lua_State* L) {
+				auto& self = get_src(L);
+				return stack::push(L, empty_start(L, self));
+			}
+
+			static std::ptrdiff_t index_adjustment(lua_State*, T&) {
+				return static_cast<std::ptrdiff_t>((SOL_CONTAINER_START_INDEX_I_) == 0 ? 0 : -(SOL_CONTAINER_START_INDEX_I_));
+			}
+
+			static int pairs(lua_State* L) {
+				typedef meta::any<is_associative, meta::all<is_lookup, meta::neg<is_matched_lookup>>> is_assoc;
+				return pairs_associative<false>(is_assoc(), L);
+			}
+
+			static int ipairs(lua_State* L) {
+				typedef meta::any<is_associative, meta::all<is_lookup, meta::neg<is_matched_lookup>>> is_assoc;
+				return pairs_associative<true>(is_assoc(), L);
+			}
+
+			static int next(lua_State* L) {
+				return stack::push(L, next_iter<false>);
+			}
+		};
+
+		template <typename X>
+		struct usertype_container_default<X, std::enable_if_t<std::is_array<std::remove_pointer_t<meta::unwrap_unqualified_t<X>>>::value>> {
+		private:
+			typedef std::remove_pointer_t<meta::unwrap_unqualified_t<X>> T;
+			typedef usertype_container<X> deferred_uc;
+
+		public:
+			typedef std::remove_extent_t<T> value_type;
+			typedef value_type* iterator;
+
+		private:
+			struct iter {
+				T& source;
+				iterator it;
+
+				iter(T& source, iterator it) : source(source), it(std::move(it)) {
+				}
+			};
+
+			static auto& get_src(lua_State* L) {
+				auto p = stack::unqualified_check_get<T*>(L, 1);
+#if SOL_IS_ON(SOL_SAFE_USERTYPE_I_)
+				if (!p) {
+					luaL_error(L,
+					     "sol: 'self' is not of type '%s' (pass 'self' as first argument with ':' or call on proper type)",
+					     detail::demangle<T>().c_str());
+				}
+				if (p.value() == nullptr) {
+					luaL_error(
+					     L, "sol: 'self' argument is nil (pass 'self' as first argument with ':' or call on a '%s' type)", detail::demangle<T>().c_str());
+				}
+#endif // Safe getting with error
+				return *p.value();
+			}
+
+			static int find(std::true_type, lua_State* L) {
+				T& self = get_src(L);
+				decltype(auto) value = stack::unqualified_get<value_type>(L, 2);
+				std::size_t N = std::extent<T>::value;
+				for (std::size_t idx = 0; idx < N; ++idx) {
+					using v_t = std::add_const_t<decltype(self[idx])>;
+					v_t v = self[idx];
+					if (v == value) {
+						idx -= deferred_uc::index_adjustment(L, self);
+						return stack::push(L, idx);
+					}
+				}
+				return stack::push(L, lua_nil);
+			}
+
+			static int find(std::false_type, lua_State* L) {
+				return luaL_error(L, "sol: cannot call 'find' on '%s': no supported comparison operator for the value type", detail::demangle<T>().c_str());
+			}
+
+			static int next_iter(lua_State* L) {
+				iter& i = stack::unqualified_get<user<iter>>(L, 1);
+				auto& source = i.source;
+				auto& it = i.it;
+				std::size_t k = stack::unqualified_get<std::size_t>(L, 2);
+				if (it == deferred_uc::end(L, source)) {
+					return 0;
+				}
+				int p;
+				p = stack::push(L, k + 1);
+				p += stack::push_reference(L, detail::deref_move_only(*it));
+				std::advance(it, 1);
+				return p;
+			}
+
+		public:
+			static int clear(lua_State* L) {
+				return luaL_error(L, "sol: cannot call 'clear' on type '%s': cannot remove all items from a fixed array", detail::demangle<T>().c_str());
+			}
+
+			static int erase(lua_State* L) {
+				return luaL_error(L, "sol: cannot call 'erase' on type '%s': cannot remove an item from fixed arrays", detail::demangle<T>().c_str());
+			}
+
+			static int add(lua_State* L) {
+				return luaL_error(L, "sol: cannot call 'add' on type '%s': cannot add to fixed arrays", detail::demangle<T>().c_str());
+			}
+
+			static int insert(lua_State* L) {
+				return luaL_error(L, "sol: cannot call 'insert' on type '%s': cannot insert new entries into fixed arrays", detail::demangle<T>().c_str());
+			}
+
+			static int at(lua_State* L) {
+				return get(L);
+			}
+
+			static int get(lua_State* L) {
+				T& self = get_src(L);
+				std::ptrdiff_t idx = stack::unqualified_get<std::ptrdiff_t>(L, 2);
+				idx += deferred_uc::index_adjustment(L, self);
+				if (idx >= static_cast<std::ptrdiff_t>(std::extent<T>::value) || idx < 0) {
+					return stack::push(L, lua_nil);
+				}
+				return stack::push_reference(L, detail::deref_move_only(self[idx]));
+			}
+
+			static int index_get(lua_State* L) {
+				return get(L);
+			}
+
+			static int set(lua_State* L) {
+				T& self = get_src(L);
+				std::ptrdiff_t idx = stack::unqualified_get<std::ptrdiff_t>(L, 2);
+				idx += deferred_uc::index_adjustment(L, self);
+				if (idx >= static_cast<std::ptrdiff_t>(std::extent<T>::value)) {
+					return luaL_error(L, "sol: index out of bounds (too big) for set on '%s'", detail::demangle<T>().c_str());
+				}
+				if (idx < 0) {
+					return luaL_error(L, "sol: index out of bounds (too small) for set on '%s'", detail::demangle<T>().c_str());
+				}
+				self[idx] = stack::unqualified_get<value_type>(L, 3);
+				return 0;
+			}
+
+			static int index_set(lua_State* L) {
+				return set(L);
+			}
+
+			static int index_of(lua_State* L) {
+				return find(L);
+			}
+
+			static int find(lua_State* L) {
+				return find(meta::supports_op_equal<value_type, value_type>(), L);
+			}
+
+			static int size(lua_State* L) {
+				return stack::push(L, std::extent<T>::value);
+			}
+
+			static int empty(lua_State* L) {
+				return stack::push(L, std::extent<T>::value > 0);
+			}
+
+			static int pairs(lua_State* L) {
+				auto& src = get_src(L);
+				stack::push(L, next_iter);
+				stack::push<user<iter>>(L, src, deferred_uc::begin(L, src));
+				stack::push(L, 0);
+				return 3;
+			}
+
+			static int ipairs(lua_State* L) {
+				return pairs(L);
+			}
+
+			static int next(lua_State* L) {
+				return stack::push(L, next_iter);
+			}
+
+			static std::ptrdiff_t index_adjustment(lua_State*, T&) {
+				return (SOL_CONTAINER_START_INDEX_I_) == 0 ? 0 : -(SOL_CONTAINER_START_INDEX_I_);
+			}
+
+			static iterator begin(lua_State*, T& self) {
+				return std::addressof(self[0]);
+			}
+
+			static iterator end(lua_State*, T& self) {
+				return std::addressof(self[0]) + std::extent<T>::value;
+			}
+		};
+
+		template <typename X>
+		struct usertype_container_default<usertype_container<X>> : usertype_container_default<X> {};
+	} // namespace container_detail
+
+	template <typename T>
+	struct usertype_container : container_detail::usertype_container_default<T> {};
+
+} // namespace sol
+
+// end of sol/usertype_container.hpp
+
+#include <unordered_map>
+
+namespace sol {
+
+	namespace container_detail {
+		template <typename X>
+		struct u_c_launch {
+			using T = std::remove_pointer_t<meta::unqualified_t<X>>;
+			using uc = usertype_container<T>;
+			using default_uc = usertype_container_default<T>;
+
+			static inline int real_index_get_traits(std::true_type, lua_State* L) {
+				return uc::index_get(L);
+			}
+
+			static inline int real_index_get_traits(std::false_type, lua_State* L) {
+				return default_uc::index_get(L);
+			}
+
+			static inline int real_index_call(lua_State* L) {
+				static const std::unordered_map<string_view, lua_CFunction> calls {
+					{ "at", &real_at_call },
+					{ "get", &real_get_call },
+					{ "set", &real_set_call },
+					{ "size", &real_length_call },
+					{ "add", &real_add_call },
+					{ "empty", &real_empty_call },
+					{ "insert", &real_insert_call },
+					{ "clear", &real_clear_call },
+					{ "find", &real_find_call },
+					{ "index_of", &real_index_of_call },
+					{ "erase", &real_erase_call },
+					{ "pairs", &pairs_call },
+					{ "next", &next_call },
+				};
+				auto maybenameview = stack::unqualified_check_get<string_view>(L, 2);
+				if (maybenameview) {
+					const string_view& name = *maybenameview;
+					auto it = calls.find(name);
+					if (it != calls.cend()) {
+						return stack::push(L, it->second);
+					}
+				}
+				return real_index_get_traits(container_detail::has_traits_index_get<uc>(), L);
+			}
+
+			static inline int real_at_traits(std::true_type, lua_State* L) {
+				return uc::at(L);
+			}
+
+			static inline int real_at_traits(std::false_type, lua_State* L) {
+				return default_uc::at(L);
+			}
+
+			static inline int real_at_call(lua_State* L) {
+				return real_at_traits(container_detail::has_traits_at<uc>(), L);
+			}
+
+			static inline int real_get_traits(std::true_type, lua_State* L) {
+				return uc::get(L);
+			}
+
+			static inline int real_get_traits(std::false_type, lua_State* L) {
+				return default_uc::get(L);
+			}
+
+			static inline int real_get_call(lua_State* L) {
+				return real_get_traits(container_detail::has_traits_get<uc>(), L);
+			}
+
+			static inline int real_set_traits(std::true_type, lua_State* L) {
+				return uc::set(L);
+			}
+
+			static inline int real_set_traits(std::false_type, lua_State* L) {
+				return default_uc::set(L);
+			}
+
+			static inline int real_set_call(lua_State* L) {
+				return real_set_traits(container_detail::has_traits_set<uc>(), L);
+			}
+
+			static inline int real_index_set_traits(std::true_type, lua_State* L) {
+				return uc::index_set(L);
+			}
+
+			static inline int real_index_set_traits(std::false_type, lua_State* L) {
+				return default_uc::index_set(L);
+			}
+
+			static inline int real_new_index_call(lua_State* L) {
+				return real_index_set_traits(container_detail::has_traits_index_set<uc>(), L);
+			}
+
+			static inline int real_pairs_traits(std::true_type, lua_State* L) {
+				return uc::pairs(L);
+			}
+
+			static inline int real_pairs_traits(std::false_type, lua_State* L) {
+				return default_uc::pairs(L);
+			}
+
+			static inline int real_pairs_call(lua_State* L) {
+				return real_pairs_traits(container_detail::has_traits_pairs<uc>(), L);
+			}
+
+			static inline int real_ipairs_traits(std::true_type, lua_State* L) {
+				return uc::ipairs(L);
+			}
+
+			static inline int real_ipairs_traits(std::false_type, lua_State* L) {
+				return default_uc::ipairs(L);
+			}
+
+			static inline int real_ipairs_call(lua_State* L) {
+				return real_ipairs_traits(container_detail::has_traits_ipairs<uc>(), L);
+			}
+
+			static inline int real_next_traits(std::true_type, lua_State* L) {
+				return uc::next(L);
+			}
+
+			static inline int real_next_traits(std::false_type, lua_State* L) {
+				return default_uc::next(L);
+			}
+
+			static inline int real_next_call(lua_State* L) {
+				return real_next_traits(container_detail::has_traits_next<uc>(), L);
+			}
+
+			static inline int real_size_traits(std::true_type, lua_State* L) {
+				return uc::size(L);
+			}
+
+			static inline int real_size_traits(std::false_type, lua_State* L) {
+				return default_uc::size(L);
+			}
+
+			static inline int real_length_call(lua_State* L) {
+				return real_size_traits(container_detail::has_traits_size<uc>(), L);
+			}
+
+			static inline int real_add_traits(std::true_type, lua_State* L) {
+				return uc::add(L);
+			}
+
+			static inline int real_add_traits(std::false_type, lua_State* L) {
+				return default_uc::add(L);
+			}
+
+			static inline int real_add_call(lua_State* L) {
+				return real_add_traits(container_detail::has_traits_add<uc>(), L);
+			}
+
+			static inline int real_insert_traits(std::true_type, lua_State* L) {
+				return uc::insert(L);
+			}
+
+			static inline int real_insert_traits(std::false_type, lua_State* L) {
+				return default_uc::insert(L);
+			}
+
+			static inline int real_insert_call(lua_State* L) {
+				return real_insert_traits(container_detail::has_traits_insert<uc>(), L);
+			}
+
+			static inline int real_clear_traits(std::true_type, lua_State* L) {
+				return uc::clear(L);
+			}
+
+			static inline int real_clear_traits(std::false_type, lua_State* L) {
+				return default_uc::clear(L);
+			}
+
+			static inline int real_clear_call(lua_State* L) {
+				return real_clear_traits(container_detail::has_traits_clear<uc>(), L);
+			}
+
+			static inline int real_empty_traits(std::true_type, lua_State* L) {
+				return uc::empty(L);
+			}
+
+			static inline int real_empty_traits(std::false_type, lua_State* L) {
+				return default_uc::empty(L);
+			}
+
+			static inline int real_empty_call(lua_State* L) {
+				return real_empty_traits(container_detail::has_traits_empty<uc>(), L);
+			}
+
+			static inline int real_erase_traits(std::true_type, lua_State* L) {
+				return uc::erase(L);
+			}
+
+			static inline int real_erase_traits(std::false_type, lua_State* L) {
+				return default_uc::erase(L);
+			}
+
+			static inline int real_erase_call(lua_State* L) {
+				return real_erase_traits(container_detail::has_traits_erase<uc>(), L);
+			}
+
+			static inline int real_find_traits(std::true_type, lua_State* L) {
+				return uc::find(L);
+			}
+
+			static inline int real_find_traits(std::false_type, lua_State* L) {
+				return default_uc::find(L);
+			}
+
+			static inline int real_find_call(lua_State* L) {
+				return real_find_traits(container_detail::has_traits_find<uc>(), L);
+			}
+
+			static inline int real_index_of_call(lua_State* L) {
+				if constexpr (container_detail::has_traits_index_of<uc>()) {
+					return uc::index_of(L);
+				}
+				else {
+					return default_uc::index_of(L);
+				}
+			}
+
+			static inline int add_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_add_call), (&real_add_call)>(L);
+			}
+
+			static inline int erase_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_erase_call), (&real_erase_call)>(L);
+			}
+
+			static inline int insert_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_insert_call), (&real_insert_call)>(L);
+			}
+
+			static inline int clear_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_clear_call), (&real_clear_call)>(L);
+			}
+
+			static inline int empty_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_empty_call), (&real_empty_call)>(L);
+			}
+
+			static inline int find_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_find_call), (&real_find_call)>(L);
+			}
+
+			static inline int index_of_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_index_of_call), (&real_index_of_call)>(L);
+			}
+
+			static inline int length_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_length_call), (&real_length_call)>(L);
+			}
+
+			static inline int pairs_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_pairs_call), (&real_pairs_call)>(L);
+			}
+
+			static inline int ipairs_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_ipairs_call), (&real_ipairs_call)>(L);
+			}
+
+			static inline int next_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_next_call), (&real_next_call)>(L);
+			}
+
+			static inline int at_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_at_call), (&real_at_call)>(L);
+			}
+
+			static inline int get_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_get_call), (&real_get_call)>(L);
+			}
+
+			static inline int set_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_set_call), (&real_set_call)>(L);
+			}
+
+			static inline int index_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_index_call), (&real_index_call)>(L);
+			}
+
+			static inline int new_index_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_new_index_call), (&real_new_index_call)>(L);
+			}
+		};
+	} // namespace container_detail
+
+	namespace stack {
+		namespace stack_detail {
+			template <typename T, bool is_shim = false>
+			struct metatable_setup {
+				lua_State* L;
+
+				metatable_setup(lua_State* L) : L(L) {
+				}
+
+				void operator()() {
+					using meta_usertype_container
+					     = container_detail::u_c_launch<meta::conditional_t<is_shim, as_container_t<std::remove_pointer_t<T>>, std::remove_pointer_t<T>>>;
+					static const char* metakey
+					     = is_shim ? &usertype_traits<as_container_t<std::remove_pointer_t<T>>>::metatable()[0] : &usertype_traits<T>::metatable()[0];
+					static const std::array<luaL_Reg, 20> reg = { {
+						// clang-format off
+						{ "__pairs", &meta_usertype_container::pairs_call },
+						{ "__ipairs", &meta_usertype_container::ipairs_call },
+						{ "__len", &meta_usertype_container::length_call },
+						{ "__index", &meta_usertype_container::index_call },
+						{ "__newindex", &meta_usertype_container::new_index_call },
+						{ "pairs", &meta_usertype_container::pairs_call },
+						{ "next", &meta_usertype_container::next_call },
+						{ "at", &meta_usertype_container::at_call },
+						{ "get", &meta_usertype_container::get_call },
+						{ "set", &meta_usertype_container::set_call },
+						{ "size", &meta_usertype_container::length_call },
+						{ "empty", &meta_usertype_container::empty_call },
+						{ "clear", &meta_usertype_container::clear_call },
+						{ "insert", &meta_usertype_container::insert_call },
+						{ "add", &meta_usertype_container::add_call },
+						{ "find", &meta_usertype_container::find_call },
+						{ "index_of", &meta_usertype_container::index_of_call },
+						{ "erase", &meta_usertype_container::erase_call },
+						std::is_pointer<T>::value ? luaL_Reg{ nullptr, nullptr } : luaL_Reg{ "__gc", &detail::usertype_alloc_destruct<T> },
+						{ nullptr, nullptr }
+						// clang-format on 
+					} };
+
+					if (luaL_newmetatable(L, metakey) == 1) {
+						luaL_setfuncs(L, reg.data(), 0);
+					}
+					lua_setmetatable(L, -2);
+				}
+			};
+		} // namespace stack_detail
+
+		template <typename T>
+		struct unqualified_pusher<as_container_t<T>> {
+			using C = meta::unqualified_t<T>;
+
+			static int push_lvalue(std::true_type, lua_State* L, const C& cont) {
+				stack_detail::metatable_setup<C*, true> fx(L);
+				return stack::push<detail::as_pointer_tag<const C>>(L, detail::with_function_tag(), fx, detail::ptr(cont));
+			}
+
+			static int push_lvalue(std::false_type, lua_State* L, const C& cont) {
+				stack_detail::metatable_setup<C, true> fx(L);
+				return stack::push<detail::as_value_tag<C>>(L, detail::with_function_tag(), fx, cont);
+			}
+
+			static int push_rvalue(std::true_type, lua_State* L, C&& cont) {
+				stack_detail::metatable_setup<C, true> fx(L);
+				return stack::push<detail::as_value_tag<C>>(L, detail::with_function_tag(), fx, std::move(cont));
+			}
+
+			static int push_rvalue(std::false_type, lua_State* L, const C& cont) {
+				return push_lvalue(std::is_lvalue_reference<T>(), L, cont);
+			}
+
+			static int push(lua_State* L, const as_container_t<T>& as_cont) {
+				return push_lvalue(std::is_lvalue_reference<T>(), L, as_cont.value());
+			}
+
+			static int push(lua_State* L, as_container_t<T>&& as_cont) {
+				return push_rvalue(meta::all<std::is_rvalue_reference<T>, meta::neg<std::is_lvalue_reference<T>>>(), L, std::forward<T>(as_cont.value()));
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<as_container_t<T*>> {
+			using C = std::add_pointer_t<meta::unqualified_t<std::remove_pointer_t<T>>>;
+
+			static int push(lua_State* L, T* cont) {
+				stack_detail::metatable_setup<C> fx(L);
+				return stack::push<detail::as_pointer_tag<T>>(L, detail::with_function_tag(), fx, cont);
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<T, std::enable_if_t<is_container_v<T>>> {
+			using C = T;
+
+			template <typename... Args>
+			static int push(lua_State* L, Args&&... args) {
+				stack_detail::metatable_setup<C> fx(L);
+				return stack::push<detail::as_value_tag<T>>(L, detail::with_function_tag(), fx, std::forward<Args>(args)...);
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<T*, std::enable_if_t<is_container_v<T>>> {
+			using C = std::add_pointer_t<meta::unqualified_t<std::remove_pointer_t<T>>>;
+
+			static int push(lua_State* L, T* cont) {
+				stack_detail::metatable_setup<C> fx(L);
+				return stack::push<detail::as_pointer_tag<T>>(L, detail::with_function_tag(), fx, cont);
+			}
+		};
+	} // namespace stack
+
+} // namespace sol
+
+// end of sol/usertype_container_launch.hpp
+
+#include <sstream>
+#include <type_traits>
+
+namespace sol {
+	namespace u_detail {
+		constexpr const lua_Integer toplevel_magic = static_cast<lua_Integer>(0xCCC2CCC1);
+
+		constexpr const int environment_index = 1;
+		constexpr const int usertype_storage_index = 2;
+		constexpr const int usertype_storage_base_index = 3;
+		constexpr const int exact_function_index = 4;
+		constexpr const int magic_index = 5;
+
+		constexpr const int simple_usertype_storage_index = 2;
+		constexpr const int index_function_index = 3;
+		constexpr const int new_index_function_index = 4;
+
+		constexpr const int base_walking_failed_index = -32467;
+		constexpr const int lookup_failed_index = -42469;
+
+		enum class submetatable_type {
+			// must be sequential
+			value,
+			reference,
+			unique,
+			const_reference,
+			const_value,
+			// must be LAST!
+			named
+		};
+
+		inline auto make_string_view(string_view s) {
+			return s;
+		}
+
+		inline auto make_string_view(call_construction) {
+			return string_view(to_string(meta_function::call_function));
+		}
+
+		inline auto make_string_view(meta_function mf) {
+			return string_view(to_string(mf));
+		}
+
+		inline auto make_string_view(base_classes_tag) {
+			return string_view(detail::base_class_cast_key());
+		}
+
+		template <typename Arg>
+		inline std::string make_string(Arg&& arg) {
+			string_view s = make_string_view(arg);
+			return std::string(s.data(), s.size());
+		}
+
+		inline int is_indexer(string_view s) {
+			if (s == to_string(meta_function::index)) {
+				return 1;
+			}
+			else if (s == to_string(meta_function::new_index)) {
+				return 2;
+			}
+			return 0;
+		}
+
+		inline int is_indexer(meta_function mf) {
+			if (mf == meta_function::index) {
+				return 1;
+			}
+			else if (mf == meta_function::new_index) {
+				return 2;
+			}
+			return 0;
+		}
+
+		inline int is_indexer(call_construction) {
+			return 0;
+		}
+	} // namespace u_detail
+
+	namespace detail {
+
+		template <typename T, typename IFx, typename Fx>
+		inline void insert_default_registrations(IFx&& ifx, Fx&& fx) {
+			(void)ifx;
+			(void)fx;
+			if constexpr (is_automagical<T>::value) {
+				if (fx(meta_function::less_than)) {
+					if constexpr (meta::supports_op_less<T>::value) {
+						lua_CFunction f = &comparsion_operator_wrap<T, std::less<>>;
+						ifx(meta_function::less_than, f);
+					}
+				}
+				if (fx(meta_function::less_than_or_equal_to)) {
+					if constexpr (meta::supports_op_less_equal<T>::value) {
+						lua_CFunction f = &comparsion_operator_wrap<T, std::less_equal<>>;
+						ifx(meta_function::less_than_or_equal_to, f);
+					}
+				}
+				if (fx(meta_function::equal_to)) {
+					if constexpr (meta::supports_op_equal<T>::value) {
+						lua_CFunction f = &comparsion_operator_wrap<T, std::equal_to<>>;
+						ifx(meta_function::equal_to, f);
+					}
+					else {
+						lua_CFunction f = &comparsion_operator_wrap<T, no_comp>;
+						ifx(meta_function::equal_to, f);
+					}
+				}
+				if (fx(meta_function::pairs)) {
+					ifx(meta_function::pairs, &container_detail::u_c_launch<as_container_t<T>>::pairs_call);
+				}
+				if (fx(meta_function::length)) {
+					if constexpr (meta::has_size<const T>::value || meta::has_size<T>::value) {
+						auto f = &default_size<T>;
+						ifx(meta_function::length, f);
+					}
+				}
+				if (fx(meta_function::to_string)) {
+					if constexpr (is_to_stringable<T>::value) {
+						auto f = &detail::static_trampoline<&default_to_string<T>>;
+						ifx(meta_function::to_string, f);
+					}
+				}
+				if (fx(meta_function::call_function)) {
+					if constexpr (meta::has_deducible_signature<T>::value) {
+						auto f = &c_call<decltype(&T::operator()), &T::operator()>;
+						ifx(meta_function::call_function, f);
+					}
+				}
+			}
+		}
+	} // namespace detail
+
+	namespace stack { namespace stack_detail {
+		template <typename X>
+		void set_undefined_methods_on(stack_reference t) {
+			using T = std::remove_pointer_t<X>;
+
+			lua_State* L = t.lua_state();
+
+			t.push();
+
+			detail::lua_reg_table l{};
+			int index = 0;
+			detail::indexed_insert insert_fx(l, index);
+			detail::insert_default_registrations<T>(insert_fx, detail::property_always_true);
+			if constexpr (!std::is_pointer_v<X>) {
+				l[index] = luaL_Reg{ to_string(meta_function::garbage_collect).c_str(), detail::make_destructor<T>() };
+			}
+			luaL_setfuncs(L, l, 0);
+
+			// __type table
+			lua_createtable(L, 0, 2);
+			const std::string& name = detail::demangle<T>();
+			lua_pushlstring(L, name.c_str(), name.size());
+			lua_setfield(L, -2, "name");
+			lua_CFunction is_func = &detail::is_check<T>;
+			lua_pushcclosure(L, is_func, 0);
+			lua_setfield(L, -2, "is");
+			lua_setfield(L, t.stack_index(), to_string(meta_function::type).c_str());
+
+			t.pop();
+		}
+	}} // namespace stack::stack_detail
+} // namespace sol
+
+// end of sol/usertype_core.hpp
+
+// beginning of sol/usertype_storage.hpp
+
+#include <bitset>
+#include <unordered_map>
+
+namespace sol { namespace u_detail {
+
+	struct usertype_storage_base;
+	template <typename T>
+	struct usertype_storage;
+
+	optional<usertype_storage_base&> maybe_get_usertype_storage_base(lua_State* L, int index);
+	usertype_storage_base& get_usertype_storage_base(lua_State* L, const char* gcmetakey);
+	template <typename T>
+	optional<usertype_storage<T>&> maybe_get_usertype_storage(lua_State* L);
+	template <typename T>
+	usertype_storage<T>& get_usertype_storage(lua_State* L);
+
+	using index_call_function = int(lua_State*, void*);
+	using change_indexing_mem_func
+		= void (usertype_storage_base::*)(lua_State*, submetatable_type, void*, stack_reference&, lua_CFunction, lua_CFunction, lua_CFunction, lua_CFunction);
+
+	struct index_call_storage {
+		index_call_function* index;
+		index_call_function* new_index;
+		void* binding_data;
+	};
+
+	struct new_index_call_storage : index_call_storage {
+		void* new_binding_data;
+	};
+
+	struct binding_base {
+		virtual void* data() = 0;
+		virtual ~binding_base() {
+		}
+	};
+
+	template <typename K, typename Fq, typename T = void>
+	struct binding : binding_base {
+		using uF = meta::unqualified_t<Fq>;
+		using F = meta::conditional_t<meta::is_c_str_of_v<uF, char>
+#ifdef __cpp_char8_t
+			     || meta::is_c_str_of_v<uF, char8_t>
+#endif
+			     || meta::is_c_str_of_v<uF, char16_t> || meta::is_c_str_of_v<uF, char32_t> || meta::is_c_str_of_v<uF, wchar_t>,
+			std::add_pointer_t<std::add_const_t<std::remove_all_extents_t<Fq>>>, std::decay_t<Fq>>;
+		F data_;
+
+		template <typename... Args>
+		binding(Args&&... args) : data_(std::forward<Args>(args)...) {
+		}
+
+		virtual void* data() override {
+			return static_cast<void*>(std::addressof(data_));
+		}
+
+		template <bool is_index = true, bool is_variable = false>
+		static inline int call_with_(lua_State* L, void* target) {
+			constexpr int boost = !detail::is_non_factory_constructor<F>::value && std::is_same<K, call_construction>::value ? 1 : 0;
+			auto& f = *static_cast<F*>(target);
+			return call_detail::call_wrapped<T, is_index, is_variable, boost>(L, f);
+		}
+
+		template <bool is_index = true, bool is_variable = false>
+		static inline int call_(lua_State* L) {
+			void* f = stack::get<void*>(L, upvalue_index(usertype_storage_index));
+			return call_with_<is_index, is_variable>(L, f);
+		}
+
+		template <bool is_index = true, bool is_variable = false>
+		static inline int call(lua_State* L) {
+			int r = detail::typed_static_trampoline<decltype(&call_<is_index, is_variable>), (&call_<is_index, is_variable>)>(L);
+			if constexpr (meta::is_specialization_of_v<uF, yielding_t>) {
+				return lua_yield(L, r);
+			}
+			else {
+				return r;
+			}
+		}
+
+		template <bool is_index = true, bool is_variable = false>
+		static inline int index_call_with_(lua_State* L, void* target) {
+			if constexpr (!is_variable) {
+				if constexpr (is_lua_c_function_v<std::decay_t<F>>) {
+					auto& f = *static_cast<std::decay_t<F>*>(target);
+					return stack::push(L, f);
+				}
+				else {
+					// set up upvalues
+					// for a chained call
+					int upvalues = 0;
+					upvalues += stack::push(L, nullptr);
+					upvalues += stack::push(L, target);
+					auto cfunc = &call<is_index, is_variable>;
+					return stack::push(L, c_closure(cfunc, upvalues));
+				}
+			}
+			else {
+				constexpr int boost = !detail::is_non_factory_constructor<F>::value && std::is_same<K, call_construction>::value ? 1 : 0;
+				auto& f = *static_cast<F*>(target);
+				return call_detail::call_wrapped<T, is_index, is_variable, boost>(L, f);
+			}
+		}
+
+		template <bool is_index = true, bool is_variable = false>
+		static inline int index_call_(lua_State* L) {
+			void* f = stack::get<void*>(L, upvalue_index(usertype_storage_index));
+			return index_call_with_<is_index, is_variable>(L, f);
+		}
+
+		template <bool is_index = true, bool is_variable = false>
+		static inline int index_call(lua_State* L) {
+			int r = detail::typed_static_trampoline<decltype(&index_call_<is_index, is_variable>), (&index_call_<is_index, is_variable>)>(L);
+			if constexpr (meta::is_specialization_of_v<uF, yielding_t>) {
+				return lua_yield(L, r);
+			}
+			else {
+				return r;
+			}
+		}
+	};
+
+	inline int index_fail(lua_State* L) {
+		if (lua_getmetatable(L, 1) == 1) {
+			int metatarget = lua_gettop(L);
+			stack::get_field<false, true>(L, stack_reference(L, raw_index(2)), metatarget);
+			return 1;
+		}
+		// With runtime extensibility, we can't
+		// hard-error things. They have to
+		// return nil, like regular table types
+		return stack::push(L, lua_nil);
+	}
+
+	inline int index_target_fail(lua_State* L, void*) {
+		return index_fail(L);
+	}
+
+	inline int new_index_fail(lua_State* L) {
+		return luaL_error(L, "sol: cannot set (new_index) into this object: no defined new_index operation on usertype");
+	}
+
+	inline int new_index_target_fail(lua_State* L, void*) {
+		return new_index_fail(L);
+	}
+
+	struct string_for_each_metatable_func {
+		bool is_destruction = false;
+		bool is_index = false;
+		bool is_new_index = false;
+		bool is_static_index = false;
+		bool is_static_new_index = false;
+		bool poison_indexing = false;
+		bool is_unqualified_lua_CFunction = false;
+		bool is_unqualified_lua_reference = false;
+		std::string* p_key = nullptr;
+		reference* p_binding_ref = nullptr;
+		lua_CFunction call_func = nullptr;
+		index_call_storage* p_ics = nullptr;
+		usertype_storage_base* p_usb = nullptr;
+		void* p_derived_usb = nullptr;
+		lua_CFunction idx_call = nullptr, new_idx_call = nullptr, meta_idx_call = nullptr, meta_new_idx_call = nullptr;
+		change_indexing_mem_func change_indexing;
+
+		void operator()(lua_State* L, submetatable_type smt, reference& fast_index_table) {
+			std::string& key = *p_key;
+			usertype_storage_base& usb = *p_usb;
+			index_call_storage& ics = *p_ics;
+
+			if (smt == submetatable_type::named) {
+				// do not override __call or
+				// other specific meta functions on named metatable:
+				// we need that for call construction
+				// and other amenities
+				return;
+			}
+			int fast_index_table_push = fast_index_table.push();
+			stack_reference t(L, -fast_index_table_push);
+			if (poison_indexing) {
+				(usb.*change_indexing)(L, smt, p_derived_usb, t, idx_call, new_idx_call, meta_idx_call, meta_new_idx_call);
+			}
+			if (is_destruction
+				&& (smt == submetatable_type::reference || smt == submetatable_type::const_reference || smt == submetatable_type::named
+				     || smt == submetatable_type::unique)) {
+				// gc does not apply to us here
+				// for reference types (raw T*, std::ref)
+				// for the named metatable itself,
+				// or for unique_usertypes, which do their own custom destruction
+				t.pop();
+				return;
+			}
+			if (is_index || is_new_index || is_static_index || is_static_new_index) {
+				// do not serialize the new_index and index functions here directly
+				// we control those...
+				t.pop();
+				return;
+			}
+			if (is_unqualified_lua_CFunction) {
+				stack::set_field<false, true>(L, key, call_func, t.stack_index());
+			}
+			else if (is_unqualified_lua_reference) {
+				reference& binding_ref = *p_binding_ref;
+				stack::set_field<false, true>(L, key, binding_ref, t.stack_index());
+			}
+			else {
+				stack::set_field<false, true>(L, key, make_closure(call_func, nullptr, ics.binding_data), t.stack_index());
+			}
+			t.pop();
+		}
+	};
+
+	struct lua_reference_func {
+		reference key;
+		reference value;
+
+		void operator()(lua_State* L, submetatable_type smt, reference& fast_index_table) {
+			if (smt == submetatable_type::named) {
+				return;
+			}
+			int fast_index_table_push = fast_index_table.push();
+			stack_reference t(L, -fast_index_table_push);
+			stack::set_field<false, true>(L, key, value, t.stack_index());
+			t.pop();
+		}
+	};
+
+	struct update_bases_func {
+		detail::inheritance_check_function base_class_check_func;
+		detail::inheritance_cast_function base_class_cast_func;
+		lua_CFunction idx_call, new_idx_call, meta_idx_call, meta_new_idx_call;
+		usertype_storage_base* p_usb;
+		void* p_derived_usb;
+		change_indexing_mem_func change_indexing;
+
+		void operator()(lua_State* L, submetatable_type smt, reference& fast_index_table) {
+			int fast_index_table_push = fast_index_table.push();
+			stack_reference t(L, -fast_index_table_push);
+			stack::set_field(L, detail::base_class_check_key(), reinterpret_cast<void*>(base_class_check_func), t.stack_index());
+			stack::set_field(L, detail::base_class_cast_key(), reinterpret_cast<void*>(base_class_cast_func), t.stack_index());
+			// change indexing, forcefully
+			(p_usb->*change_indexing)(L, smt, p_derived_usb, t, idx_call, new_idx_call, meta_idx_call, meta_new_idx_call);
+			t.pop();
+		}
+	};
+
+	struct binding_data_equals {
+		void* binding_data;
+
+		binding_data_equals(void* b) : binding_data(b) {
+		}
+
+		bool operator()(const std::unique_ptr<binding_base>& ptr) const {
+			return binding_data == ptr->data();
+		}
+	};
+
+	struct usertype_storage_base {
+	public:
+		std::vector<std::unique_ptr<binding_base>> storage;
+		std::vector<std::unique_ptr<char[]>> string_keys_storage;
+		std::unordered_map<string_view, index_call_storage> string_keys;
+		std::unordered_map<reference, reference, reference_hash, reference_equals> auxiliary_keys;
+		reference value_index_table;
+		reference reference_index_table;
+		reference unique_index_table;
+		reference const_reference_index_table;
+		reference const_value_index_table;
+		reference named_index_table;
+		reference type_table;
+		reference gc_names_table;
+		reference named_metatable;
+		new_index_call_storage base_index;
+		new_index_call_storage static_base_index;
+		bool is_using_index;
+		bool is_using_new_index;
+		std::bitset<64> properties;
+
+		usertype_storage_base(lua_State* L)
+		: storage()
+		, string_keys()
+		, auxiliary_keys()
+		, value_index_table()
+		, reference_index_table()
+		, unique_index_table()
+		, const_reference_index_table()
+		, type_table(make_reference(L, create))
+		, gc_names_table(make_reference(L, create))
+		, named_metatable(make_reference(L, create))
+		, base_index()
+		, static_base_index()
+		, is_using_index(false)
+		, is_using_new_index(false)
+		, properties() {
+			base_index.binding_data = nullptr;
+			base_index.index = index_target_fail;
+			base_index.new_index = new_index_target_fail;
+			base_index.new_binding_data = nullptr;
+			static_base_index.binding_data = nullptr;
+			static_base_index.index = index_target_fail;
+			static_base_index.new_binding_data = this;
+			static_base_index.new_index = new_index_target_set;
+		}
+
+		template <typename Fx>
+		void for_each_table(lua_State* L, Fx&& fx) {
+			for (int i = 0; i < 6; ++i) {
+				submetatable_type smt = static_cast<submetatable_type>(i);
+				reference* p_fast_index_table = nullptr;
+				switch (smt) {
+				case submetatable_type::const_value:
+					p_fast_index_table = &this->const_value_index_table;
+					break;
+				case submetatable_type::reference:
+					p_fast_index_table = &this->reference_index_table;
+					break;
+				case submetatable_type::unique:
+					p_fast_index_table = &this->unique_index_table;
+					break;
+				case submetatable_type::const_reference:
+					p_fast_index_table = &this->const_reference_index_table;
+					break;
+				case submetatable_type::named:
+					p_fast_index_table = &this->named_index_table;
+					break;
+				case submetatable_type::value:
+				default:
+					p_fast_index_table = &this->value_index_table;
+					break;
+				}
+				fx(L, smt, *p_fast_index_table);
+			}
+		}
+
+		void add_entry(string_view sv, index_call_storage ics) {
+			string_keys_storage.emplace_back(new char[sv.size()]);
+			std::unique_ptr<char[]>& sv_storage = string_keys_storage.back();
+			std::memcpy(sv_storage.get(), sv.data(), sv.size());
+			string_view stored_sv(sv_storage.get(), sv.size());
+			string_keys.insert_or_assign(std::move(stored_sv), std::move(ics));
+		}
+
+		template <typename T, typename... Bases>
+		void update_bases(lua_State* L, bases<Bases...>) {
+			static_assert(sizeof(void*) <= sizeof(detail::inheritance_check_function),
+				"The size of this data pointer is too small to fit the inheritance checking function: Please file "
+				"a bug report.");
+			static_assert(sizeof(void*) <= sizeof(detail::inheritance_cast_function),
+				"The size of this data pointer is too small to fit the inheritance checking function: Please file "
+				"a bug report.");
+			static_assert(!meta::any_same<T, Bases...>::value, "base classes cannot list the original class as part of the bases");
+			if constexpr (sizeof...(Bases) < 1) {
+				return;
+			}
+
+			(void)detail::swallow { 0, ((weak_derive<Bases>::value = true), 0)... };
+
+			void* derived_this = static_cast<void*>(static_cast<usertype_storage<T>*>(this));
+
+			update_bases_func for_each_fx;
+			for_each_fx.base_class_check_func = &detail::inheritance<T>::template type_check_with<Bases...>;
+			for_each_fx.base_class_cast_func = &detail::inheritance<T>::template type_cast_with<Bases...>;
+			for_each_fx.idx_call = &usertype_storage<T>::template index_call_with_bases<false, Bases...>;
+			for_each_fx.new_idx_call = &usertype_storage<T>::template index_call_with_bases<true, Bases...>;
+			for_each_fx.meta_idx_call = &usertype_storage<T>::template meta_index_call_with_bases<false, Bases...>;
+			for_each_fx.meta_new_idx_call = &usertype_storage<T>::template meta_index_call_with_bases<true, Bases...>;
+			for_each_fx.p_usb = this;
+			for_each_fx.p_derived_usb = derived_this;
+			for_each_fx.change_indexing = &usertype_storage_base::change_indexing;
+			for_each_fx.p_derived_usb = derived_this;
+			this->for_each_table(L, for_each_fx);
+		}
+
+		void clear() {
+			if (value_index_table.valid()) {
+				stack::clear(value_index_table);
+			}
+			if (reference_index_table.valid()) {
+				stack::clear(reference_index_table);
+			}
+			if (unique_index_table.valid()) {
+				stack::clear(unique_index_table);
+			}
+			if (const_reference_index_table.valid()) {
+				stack::clear(const_reference_index_table);
+			}
+			if (const_value_index_table.valid()) {
+				stack::clear(const_value_index_table);
+			}
+			if (named_index_table.valid()) {
+				stack::clear(named_index_table);
+			}
+			if (type_table.valid()) {
+				stack::clear(type_table);
+			}
+			if (gc_names_table.valid()) {
+				stack::clear(gc_names_table);
+			}
+			if (named_metatable.valid()) {
+				lua_State* L = named_metatable.lua_state();
+				auto pp = stack::push_pop(named_metatable);
+				int named_metatable_index = pp.index_of(named_metatable);
+				if (lua_getmetatable(L, named_metatable_index) == 1) {
+					stack::clear(L, absolute_index(L, -1));
+				}
+				stack::clear(named_metatable);
+			}
+
+			value_index_table = lua_nil;
+			reference_index_table = lua_nil;
+			unique_index_table = lua_nil;
+			const_reference_index_table = lua_nil;
+			const_value_index_table = lua_nil;
+			named_index_table = lua_nil;
+			type_table = lua_nil;
+			gc_names_table = lua_nil;
+			named_metatable = lua_nil;
+
+			storage.clear();
+			string_keys.clear();
+			auxiliary_keys.clear();
+		}
+
+		template <bool is_new_index, typename Base>
+		static void base_walk_index(lua_State* L, usertype_storage_base& self, bool& keep_going, int& base_result) {
+			using bases = typename base<Base>::type;
+			if (!keep_going) {
+				return;
+			}
+			(void)L;
+			(void)self;
+#if SOL_IS_ON(SOL_USE_UNSAFE_BASE_LOOKUP_I_)
+			usertype_storage_base& base_storage = get_usertype_storage<Base>(L);
+			base_result = self_index_call<is_new_index, true>(bases(), L, base_storage);
+#else
+			optional<usertype_storage<Base>&> maybe_base_storage = maybe_get_usertype_storage<Base>(L);
+			if (static_cast<bool>(maybe_base_storage)) {
+				base_result = self_index_call<is_new_index, true>(bases(), L, *maybe_base_storage);
+				keep_going = base_result == base_walking_failed_index;
+			}
+#endif // Fast versus slow, safe base lookup
+		}
+
+		template <bool is_new_index = false, bool base_walking = false, bool from_named_metatable = false, typename... Bases>
+		static inline int self_index_call(types<Bases...>, lua_State* L, usertype_storage_base& self) {
+			type k_type = stack::get<type>(L, 2);
+			if (k_type == type::string) {
+				index_call_storage* target = nullptr;
+				{
+					string_view k = stack::get<string_view>(L, 2);
+					auto it = self.string_keys.find(k);
+					if (it != self.string_keys.cend()) {
+						target = &it->second;
+					}
+				}
+				if (target != nullptr) {
+					// let the target decide what to do
+					if constexpr (is_new_index) {
+						return (target->new_index)(L, target->binding_data);
+					}
+					else {
+						return (target->index)(L, target->binding_data);
+					}
+				}
+			}
+			else if (k_type != type::lua_nil && k_type != type::none) {
+				reference* target = nullptr;
+				{
+					stack_reference k = stack::get<stack_reference>(L, 2);
+					auto it = self.auxiliary_keys.find(k);
+					if (it != self.auxiliary_keys.cend()) {
+						target = &it->second;
+					}
+				}
+				if (target != nullptr) {
+					if constexpr (is_new_index) {
+						// set value and return
+						*target = reference(L, 3);
+						return 0;
+					}
+					else {
+						// push target to return
+						// what we found
+						return stack::push(L, *target);
+					}
+				}
+			}
+
+			// retrieve bases and walk through them.
+			bool keep_going = true;
+			int base_result;
+			(void)keep_going;
+			(void)base_result;
+			(void)detail::swallow { 1, (base_walk_index<is_new_index, Bases>(L, self, keep_going, base_result), 1)... };
+			if constexpr (sizeof...(Bases) > 0) {
+				if (!keep_going) {
+					return base_result;
+				}
+			}
+			if constexpr (base_walking) {
+				// if we're JUST base-walking then don't index-fail, just
+				// return the false bits
+				return base_walking_failed_index;
+			}
+			else if constexpr (from_named_metatable) {
+				if constexpr (is_new_index) {
+					return self.static_base_index.new_index(L, self.static_base_index.new_binding_data);
+				}
+				else {
+					return self.static_base_index.index(L, self.static_base_index.binding_data);
+				}
+			}
+			else {
+				if constexpr (is_new_index) {
+					return self.base_index.new_index(L, self.base_index.new_binding_data);
+				}
+				else {
+					return self.base_index.index(L, self.base_index.binding_data);
+				}
+			}
+		}
+
+		void change_indexing(lua_State* L, submetatable_type submetatable, void* derived_this, stack_reference& t, lua_CFunction index,
+			lua_CFunction new_index, lua_CFunction meta_index, lua_CFunction meta_new_index) {
+			usertype_storage_base& this_base = *this;
+			void* base_this = static_cast<void*>(&this_base);
+
+			this->is_using_index |= true;
+			this->is_using_new_index |= true;
+			if (submetatable == submetatable_type::named) {
+				stack::set_field(L, metatable_key, named_index_table, t.stack_index());
+				stack_reference stack_metametatable(L, -named_metatable.push());
+				stack::set_field<false, true>(L,
+					meta_function::index,
+					make_closure(meta_index, nullptr, derived_this, base_this, nullptr, toplevel_magic),
+					stack_metametatable.stack_index());
+				stack::set_field<false, true>(L,
+					meta_function::new_index,
+					make_closure(meta_new_index, nullptr, derived_this, base_this, nullptr, toplevel_magic),
+					stack_metametatable.stack_index());
+				stack_metametatable.pop();
+			}
+			else {
+				stack::set_field<false, true>(
+					L, meta_function::index, make_closure(index, nullptr, derived_this, base_this, nullptr, toplevel_magic), t.stack_index());
+				stack::set_field<false, true>(
+					L, meta_function::new_index, make_closure(new_index, nullptr, derived_this, base_this, nullptr, toplevel_magic), t.stack_index());
+			}
+		}
+
+		template <typename T = void, typename Key, typename Value>
+		void set(lua_State* L, Key&& key, Value&& value);
+
+		static int new_index_target_set(lua_State* L, void* target) {
+			usertype_storage_base& self = *static_cast<usertype_storage_base*>(target);
+			self.set(L, reference(L, raw_index(2)), reference(L, raw_index(3)));
+			return 0;
+		}
+	};
+
+	template <typename T>
+	struct usertype_storage : usertype_storage_base {
+
+		using usertype_storage_base::usertype_storage_base;
+
+		template <bool is_new_index, bool from_named_metatable>
+		static inline int index_call_(lua_State* L) {
+			using bases = typename base<T>::type;
+			usertype_storage_base& self = stack::get<light<usertype_storage_base>>(L, upvalue_index(usertype_storage_index));
+			return self_index_call<is_new_index, false, from_named_metatable>(bases(), L, self);
+		}
+
+		template <bool is_new_index, bool from_named_metatable, typename... Bases>
+		static inline int index_call_with_bases_(lua_State* L) {
+			using bases = types<Bases...>;
+			usertype_storage_base& self = stack::get<light<usertype_storage_base>>(L, upvalue_index(usertype_storage_index));
+			return self_index_call<is_new_index, false, from_named_metatable>(bases(), L, self);
+		}
+
+		template <bool is_new_index>
+		static inline int index_call(lua_State* L) {
+			return detail::static_trampoline<&index_call_<is_new_index, false>>(L);
+		}
+
+		template <bool is_new_index, typename... Bases>
+		static inline int index_call_with_bases(lua_State* L) {
+			return detail::static_trampoline<&index_call_with_bases_<is_new_index, false, Bases...>>(L);
+		}
+
+		template <bool is_new_index>
+		static inline int meta_index_call(lua_State* L) {
+			return detail::static_trampoline<&index_call_<is_new_index, true>>(L);
+		}
+
+		template <bool is_new_index, typename... Bases>
+		static inline int meta_index_call_with_bases(lua_State* L) {
+			return detail::static_trampoline<&index_call_with_bases_<is_new_index, true, Bases...>>(L);
+		}
+
+		template <typename Key, typename Value>
+		inline void set(lua_State* L, Key&& key, Value&& value);
+	};
+
+	template <typename T>
+	inline int destruct_usertype_storage(lua_State* L) {
+		return detail::user_alloc_destruct<usertype_storage<T>>(L);
+	}
+
+	template <typename T, typename Key, typename Value>
+	void usertype_storage_base::set(lua_State* L, Key&& key, Value&& value) {
+		using ValueU = meta::unwrap_unqualified_t<Value>;
+		using KeyU = meta::unwrap_unqualified_t<Key>;
+		using Binding = binding<KeyU, ValueU, T>;
+		using is_var_bind = is_variable_binding<ValueU>;
+		if constexpr (std::is_same_v<KeyU, call_construction>) {
+			(void)key;
+			std::unique_ptr<Binding> p_binding = std::make_unique<Binding>(std::forward<Value>(value));
+			Binding& b = *p_binding;
+			this->storage.push_back(std::move(p_binding));
+
+			this->named_index_table.push();
+			absolute_index metametatable_index(L, -1);
+			stack::push(L, nullptr);
+			stack::push(L, b.data());
+			lua_CFunction target_func = &b.template call<false, false>;
+			lua_pushcclosure(L, target_func, 2);
+			lua_setfield(L, metametatable_index, to_string(meta_function::call).c_str());
+			this->named_index_table.pop();
+		}
+		else if constexpr (std::is_same_v<KeyU, base_classes_tag>) {
+			(void)key;
+			this->update_bases<T>(L, std::forward<Value>(value));
+		}
+		else if constexpr ((meta::is_string_like_or_constructible<KeyU>::value || std::is_same_v<KeyU, meta_function>)) {
+			std::string s = u_detail::make_string(std::forward<Key>(key));
+			auto storage_it = this->storage.end();
+			auto string_it = this->string_keys.find(s);
+			if (string_it != this->string_keys.cend()) {
+				const auto& binding_data = string_it->second.binding_data;
+				storage_it = std::find_if(this->storage.begin(), this->storage.end(), binding_data_equals(binding_data));
+				this->string_keys.erase(string_it);
+			}
+
+			std::unique_ptr<Binding> p_binding = std::make_unique<Binding>(std::forward<Value>(value));
+			Binding& b = *p_binding;
+			if (storage_it != this->storage.cend()) {
+				*storage_it = std::move(p_binding);
+			}
+			else {
+				this->storage.push_back(std::move(p_binding));
+			}
+
+			bool is_index = (s == to_string(meta_function::index));
+			bool is_new_index = (s == to_string(meta_function::new_index));
+			bool is_static_index = (s == to_string(meta_function::static_index));
+			bool is_static_new_index = (s == to_string(meta_function::static_new_index));
+			bool is_destruction = s == to_string(meta_function::garbage_collect);
+			bool poison_indexing = (!is_using_index || !is_using_new_index) && (is_var_bind::value || is_index || is_new_index);
+			void* derived_this = static_cast<void*>(static_cast<usertype_storage<T>*>(this));
+			index_call_storage ics;
+			ics.binding_data = b.data();
+			ics.index = is_index || is_static_index ? &Binding::template call_with_<true, is_var_bind::value>
+				                                   : &Binding::template index_call_with_<true, is_var_bind::value>;
+			ics.new_index = is_new_index || is_static_new_index ? &Binding::template call_with_<false, is_var_bind::value>
+				                                               : &Binding::template index_call_with_<false, is_var_bind::value>;
+
+			string_for_each_metatable_func for_each_fx;
+			for_each_fx.is_destruction = is_destruction;
+			for_each_fx.is_index = is_index;
+			for_each_fx.is_new_index = is_new_index;
+			for_each_fx.is_static_index = is_static_index;
+			for_each_fx.is_static_new_index = is_static_new_index;
+			for_each_fx.poison_indexing = poison_indexing;
+			for_each_fx.p_key = &s;
+			for_each_fx.p_ics = &ics;
+			if constexpr (is_lua_c_function_v<ValueU>) {
+				for_each_fx.is_unqualified_lua_CFunction = true;
+				for_each_fx.call_func = *static_cast<lua_CFunction*>(ics.binding_data);
+			}
+			else if constexpr (is_lua_reference_or_proxy_v<ValueU>) {
+				for_each_fx.is_unqualified_lua_reference = true;
+				for_each_fx.p_binding_ref = static_cast<reference*>(ics.binding_data);
+			}
+			else {
+				for_each_fx.call_func = &b.template call<false, is_var_bind::value>;
+			}
+			for_each_fx.p_usb = this;
+			for_each_fx.p_derived_usb = derived_this;
+			for_each_fx.idx_call = &usertype_storage<T>::template index_call<false>;
+			for_each_fx.new_idx_call = &usertype_storage<T>::template index_call<true>;
+			for_each_fx.meta_idx_call = &usertype_storage<T>::template meta_index_call<false>;
+			for_each_fx.meta_new_idx_call = &usertype_storage<T>::template meta_index_call<true>;
+			for_each_fx.change_indexing = &usertype_storage_base::change_indexing;
+			// set base index and base new_index
+			// functions here
+			if (is_index) {
+				this->base_index.index = ics.index;
+				this->base_index.binding_data = ics.binding_data;
+			}
+			if (is_new_index) {
+				this->base_index.new_index = ics.new_index;
+				this->base_index.new_binding_data = ics.binding_data;
+			}
+			if (is_static_index) {
+				this->static_base_index.index = ics.index;
+				this->static_base_index.binding_data = ics.binding_data;
+			}
+			if (is_static_new_index) {
+				this->static_base_index.new_index = ics.new_index;
+				this->static_base_index.new_binding_data = ics.binding_data;
+			}
+			this->for_each_table(L, for_each_fx);
+			this->add_entry(s, std::move(ics));
+		}
+		else {
+			// the reference-based implementation might compare poorly and hash
+			// poorly in some cases...
+			if constexpr (is_lua_reference_v<KeyU> && is_lua_reference_v<ValueU>) {
+				if (key.get_type() == type::string) {
+					stack::push(L, key);
+					std::string string_key = stack::pop<std::string>(L);
+					this->set<T>(L, string_key, std::forward<Value>(value));
+				}
+				else {
+					lua_reference_func ref_additions_fx { key, value };
+
+					this->for_each_table(L, ref_additions_fx);
+					this->auxiliary_keys.insert_or_assign(std::forward<Key>(key), std::forward<Value>(value));
+				}
+			}
+			else {
+				reference ref_key = make_reference(L, std::forward<Key>(key));
+				reference ref_value = make_reference(L, std::forward<Value>(value));
+				lua_reference_func ref_additions_fx { key, value };
+
+				this->for_each_table(L, ref_additions_fx);
+				this->auxiliary_keys.insert_or_assign(std::move(ref_key), std::move(ref_value));
+			}
+		}
+	}
+
+	template <typename T>
+	template <typename Key, typename Value>
+	void usertype_storage<T>::set(lua_State* L, Key&& key, Value&& value) {
+		static_cast<usertype_storage_base&>(*this).set<T>(L, std::forward<Key>(key), std::forward<Value>(value));
+	}
+
+	template <typename T>
+	inline usertype_storage<T>& create_usertype_storage(lua_State* L) {
+		const char* gcmetakey = &usertype_traits<T>::gc_table()[0];
+
+		// Make sure userdata's memory is properly in lua first,
+		// otherwise all the light userdata we make later will become invalid
+		int usertype_storage_push_count = stack::push<user<usertype_storage<T>>>(L, no_metatable, L);
+		stack_reference usertype_storage_ref(L, -usertype_storage_push_count);
+
+		// create and push onto the stack a table to use as metatable for this GC
+		// we create a metatable to attach to the regular gc_table
+		// so that the destructor is called for the usertype storage
+		int usertype_storage_metatabe_count = stack::push(L, new_table(0, 1));
+		stack_reference usertype_storage_metatable(L, -usertype_storage_metatabe_count);
+		// set the destruction routine on the metatable
+		stack::set_field(L, meta_function::garbage_collect, &destruct_usertype_storage<T>, usertype_storage_metatable.stack_index());
+		// set the metatable on the usertype storage userdata
+		stack::set_field(L, metatable_key, usertype_storage_metatable, usertype_storage_ref.stack_index());
+		usertype_storage_metatable.pop();
+
+		// set the usertype storage and its metatable
+		// into the global table...
+		stack::set_field<true>(L, gcmetakey, usertype_storage_ref);
+		usertype_storage_ref.pop();
+
+		// then retrieve the lua-stored version so we have a well-pinned
+		// reference that does not die
+		stack::get_field<true>(L, gcmetakey);
+		usertype_storage<T>& target_umt = stack::pop<user<usertype_storage<T>>>(L);
+		return target_umt;
+	}
+
+	inline optional<usertype_storage_base&> maybe_get_usertype_storage_base(lua_State* L, int index) {
+		stack::record tracking;
+		if (!stack::check<user<usertype_storage_base>>(L, index)) {
+			return nullopt;
+		}
+		usertype_storage_base& target_umt = stack::stack_detail::unchecked_unqualified_get<user<usertype_storage_base>>(L, -1, tracking);
+		return target_umt;
+	}
+
+	inline optional<usertype_storage_base&> maybe_get_usertype_storage_base(lua_State* L, const char* gcmetakey) {
+		stack::get_field<true>(L, gcmetakey);
+		auto maybe_storage = maybe_get_usertype_storage_base(L, lua_gettop(L));
+		lua_pop(L, 1);
+		return maybe_storage;
+	}
+
+	inline usertype_storage_base& get_usertype_storage_base(lua_State* L, const char* gcmetakey) {
+		stack::get_field<true>(L, gcmetakey);
+		stack::record tracking;
+		usertype_storage_base& target_umt = stack::stack_detail::unchecked_unqualified_get<user<usertype_storage_base>>(L, -1, tracking);
+		lua_pop(L, 1);
+		return target_umt;
+	}
+
+	template <typename T>
+	inline optional<usertype_storage<T>&> maybe_get_usertype_storage(lua_State* L) {
+		const char* gcmetakey = &usertype_traits<T>::gc_table()[0];
+		stack::get_field<true>(L, gcmetakey);
+		int target = lua_gettop(L);
+		if (!stack::check<user<usertype_storage<T>>>(L, target)) {
+			return nullopt;
+		}
+		usertype_storage<T>& target_umt = stack::pop<user<usertype_storage<T>>>(L);
+		return target_umt;
+	}
+
+	template <typename T>
+	inline usertype_storage<T>& get_usertype_storage(lua_State* L) {
+		const char* gcmetakey = &usertype_traits<T>::gc_table()[0];
+		stack::get_field<true>(L, gcmetakey);
+		usertype_storage<T>& target_umt = stack::pop<user<usertype_storage<T>>>(L);
+		return target_umt;
+	}
+
+	template <typename T>
+	inline void delete_usertype_storage(lua_State* L) {
+		using u_traits = usertype_traits<T>;
+#if 0
+		using u_const_traits = usertype_traits<const T>;
+		using u_unique_traits = usertype_traits<detail::unique_usertype<T>>;
+		using u_ref_traits = usertype_traits<T*>;
+		using u_const_ref_traits = usertype_traits<T const*>;
+#endif
+		using uts = usertype_storage<T>;
+
+		const char* gcmetakey = &u_traits::gc_table()[0];
+		stack::get_field<true>(L, gcmetakey);
+		if (!stack::check<user<uts>>(L)) {
+			lua_pop(L, 1);
+			return;
+		}
+		usertype_storage<T>& target_umt = stack::pop<user<usertype_storage<T>>>(L);
+		target_umt.clear();
+
+		// get the registry
+#if 0
+		stack_reference registry(L, raw_index(LUA_REGISTRYINDEX));
+		registry.push();
+		// eliminate all named entries for this usertype
+		// in the registry (luaL_newmetatable does
+		// [name] = new table
+		// in registry upon creation
+		stack::set_field(L, &u_traits::metatable()[0], lua_nil, registry.stack_index());
+		stack::set_field(L, &u_const_traits::metatable()[0], lua_nil, registry.stack_index());
+		stack::set_field(L, &u_const_ref_traits::metatable()[0], lua_nil, registry.stack_index());
+		stack::set_field(L, &u_ref_traits::metatable()[0], lua_nil, registry.stack_index());
+		stack::set_field(L, &u_unique_traits::metatable()[0], lua_nil, registry.stack_index());
+		registry.pop();
+#endif // Registry Cleanout
+
+		stack::set_field<true>(L, gcmetakey, lua_nil);
+	}
+
+	template <typename T>
+	inline int register_usertype(lua_State* L, automagic_enrollments enrollments = {}) {
+		using u_traits = usertype_traits<T>;
+		using u_const_traits = usertype_traits<const T>;
+		using u_unique_traits = usertype_traits<detail::unique_usertype<T>>;
+		using u_ref_traits = usertype_traits<T*>;
+		using u_const_ref_traits = usertype_traits<T const*>;
+		using uts = usertype_storage<T>;
+
+		// always have __new_index point to usertype_storage method
+		// have __index always point to regular fast-lookup
+		// meta_method table
+		// if __new_index is invoked, runtime-swap
+		// to slow __index if necessary
+		// (no speed penalty because function calls
+		// are all read-only -- only depend on __index
+		// to retrieve function and then call happens VIA Lua)
+
+		// __type entry:
+		// table contains key -> value lookup,
+		// where key is entry in metatable
+		// and value is type information as a string as
+		// best as we can give it
+
+		// name entry:
+		// string that contains raw class name,
+		// as defined from C++
+
+		// is entry:
+		// checks if argument supplied is of type T
+
+		// __storage entry:
+		// a light userdata pointing to the storage
+		// mostly to enable this new abstraction
+		// to not require the type name `T`
+		// to get at the C++ usertype storage within
+
+		// we then let typical definitions potentially override these intrinsics
+		// it's the user's fault if they override things or screw them up:
+		// these names have been reserved and documented since sol3
+
+		// STEP 0: tell the old usertype (if it exists)
+		// to fuck off
+		delete_usertype_storage<T>(L);
+
+		// STEP 1: Create backing store for usertype storage
+		// Pretty much the most important step.
+		// STEP 2: Create Lua tables used for fast method indexing.
+		// This is done inside of the storage table's constructor
+		usertype_storage<T>& storage = create_usertype_storage<T>(L);
+		usertype_storage_base& base_storage = storage;
+		void* light_storage = static_cast<void*>(&storage);
+		void* light_base_storage = static_cast<void*>(&base_storage);
+
+		// STEP 3: set up GC escape hatch table entirely
+		storage.gc_names_table.push();
+		stack_reference gnt(L, -1);
+		stack::set_field(L, submetatable_type::named, &u_traits::gc_table()[0], gnt.stack_index());
+		stack::set_field(L, submetatable_type::const_value, &u_const_traits::metatable()[0], gnt.stack_index());
+		stack::set_field(L, submetatable_type::const_reference, &u_const_ref_traits::metatable()[0], gnt.stack_index());
+		stack::set_field(L, submetatable_type::reference, &u_ref_traits::metatable()[0], gnt.stack_index());
+		stack::set_field(L, submetatable_type::unique, &u_unique_traits::metatable()[0], gnt.stack_index());
+		stack::set_field(L, submetatable_type::value, &u_traits::metatable()[0], gnt.stack_index());
+		gnt.pop();
+
+		// STEP 4: add some useful information to the type table
+		stack_reference stacked_type_table(L, -storage.type_table.push());
+		stack::set_field(L, "name", detail::demangle<T>(), stacked_type_table.stack_index());
+		stack::set_field(L, "is", &detail::is_check<T>, stacked_type_table.stack_index());
+		stacked_type_table.pop();
+
+		// STEP 5: create and hook up metatable,
+		// add intrinsics
+		// this one is the actual meta-handling table,
+		// the next one will be the one for
+		int for_each_backing_metatable_calls = 0;
+		auto for_each_backing_metatable = [&](lua_State* L, submetatable_type smt, reference& fast_index_table) {
+			// Pointer types, AKA "references" from C++
+			const char* metakey = nullptr;
+			switch (smt) {
+			case submetatable_type::const_value:
+				metakey = &u_const_traits::metatable()[0];
+				break;
+			case submetatable_type::reference:
+				metakey = &u_ref_traits::metatable()[0];
+				break;
+			case submetatable_type::unique:
+				metakey = &u_unique_traits::metatable()[0];
+				break;
+			case submetatable_type::const_reference:
+				metakey = &u_const_ref_traits::metatable()[0];
+				break;
+			case submetatable_type::named:
+				metakey = &u_traits::user_metatable()[0];
+				break;
+			case submetatable_type::value:
+			default:
+				metakey = &u_traits::metatable()[0];
+				break;
+			}
+
+			luaL_newmetatable(L, metakey);
+			if (smt == submetatable_type::named) {
+				// the named table itself
+				// gets the associated name value
+				storage.named_metatable = reference(L, -1);
+				lua_pop(L, 1);
+				// but the thing we perform the methods on
+				// is still the metatable of the named
+				// table
+				lua_createtable(L, 0, 6);
+			}
+			stack_reference t(L, -1);
+			fast_index_table = reference(t);
+			stack::set_field<false, true>(L, meta_function::type, storage.type_table, t.stack_index());
+			if constexpr (std::is_destructible_v<T>) {
+				// destructible: serialize default
+				// destructor here
+				switch (smt) {
+				case submetatable_type::const_reference:
+				case submetatable_type::reference:
+				case submetatable_type::named:
+					break;
+				case submetatable_type::unique:
+					stack::set_field<false, true>(L, meta_function::garbage_collect, &detail::unique_destruct<T>, t.stack_index());
+					break;
+				case submetatable_type::value:
+				case submetatable_type::const_value:
+				default:
+					stack::set_field<false, true>(L, meta_function::garbage_collect, detail::make_destructor<T>(), t.stack_index());
+					break;
+				}
+			}
+			else {
+				// not destructible: serialize a
+				// "hey you messed up"
+				// destructor
+				switch (smt) {
+				case submetatable_type::const_reference:
+				case submetatable_type::reference:
+				case submetatable_type::named:
+					break;
+				case submetatable_type::unique:
+					stack::set_field<false, true>(L, meta_function::garbage_collect, &detail::cannot_destruct<T>, t.stack_index());
+					break;
+				case submetatable_type::value:
+				case submetatable_type::const_value:
+				default:
+					stack::set_field<false, true>(L, meta_function::garbage_collect, &detail::cannot_destruct<T>, t.stack_index());
+					break;
+				}
+			}
+
+			static_assert(sizeof(void*) <= sizeof(detail::inheritance_check_function),
+				"The size of this data pointer is too small to fit the inheritance checking function: file a bug "
+				"report.");
+			static_assert(sizeof(void*) <= sizeof(detail::inheritance_cast_function),
+				"The size of this data pointer is too small to fit the inheritance checking function: file a bug "
+				"report.");
+			stack::set_field<false, true>(L, detail::base_class_check_key(), reinterpret_cast<void*>(&detail::inheritance<T>::type_check), t.stack_index());
+			stack::set_field<false, true>(L, detail::base_class_cast_key(), reinterpret_cast<void*>(&detail::inheritance<T>::type_cast), t.stack_index());
+
+			auto prop_fx = detail::properties_enrollment_allowed(for_each_backing_metatable_calls, storage.properties, enrollments);
+			auto insert_fx = [&L, &t, &storage](meta_function mf, lua_CFunction reg) {
+				stack::set_field<false, true>(L, mf, reg, t.stack_index());
+				storage.properties[static_cast<int>(mf)] = true;
+			};
+			detail::insert_default_registrations<T>(insert_fx, prop_fx);
+
+			// There are no variables, so serialize the fast function stuff
+			// be sure to reset the index stuff to the non-fast version
+			// if the user ever adds something later!
+			if (smt == submetatable_type::named) {
+				// add escape hatch storage pointer and gc names
+				stack::set_field<false, true>(L, meta_function::storage, light_base_storage, t.stack_index());
+				stack::set_field<false, true>(L, meta_function::gc_names, storage.gc_names_table, t.stack_index());
+
+				// fancy new_indexing when using the named table
+				{
+					absolute_index named_metatable_index(L, -storage.named_metatable.push());
+					stack::set_field<false, true>(L, metatable_key, t, named_metatable_index);
+					storage.named_metatable.pop();
+				}
+				stack_reference stack_metametatable(L, -storage.named_index_table.push());
+				stack::set_field<false, true>(L,
+					meta_function::index,
+					make_closure(uts::template meta_index_call<false>, nullptr, light_storage, light_base_storage, nullptr, toplevel_magic),
+					stack_metametatable.stack_index());
+				stack::set_field<false, true>(L,
+					meta_function::new_index,
+					make_closure(uts::template meta_index_call<true>, nullptr, light_storage, light_base_storage, nullptr, toplevel_magic),
+					stack_metametatable.stack_index());
+				stack_metametatable.pop();
+			}
+			else {
+				// otherwise just plain for index,
+				// and elaborated for new_index
+				stack::set_field<false, true>(L, meta_function::index, t, t.stack_index());
+				stack::set_field<false, true>(L,
+					meta_function::new_index,
+					make_closure(uts::template index_call<true>, nullptr, light_storage, light_base_storage, nullptr, toplevel_magic),
+					t.stack_index());
+				storage.is_using_new_index = true;
+			}
+
+			++for_each_backing_metatable_calls;
+			fast_index_table = reference(L, t);
+			t.pop();
+		};
+
+		storage.for_each_table(L, for_each_backing_metatable);
+
+		// can only use set AFTER we initialize all the metatables
+		if constexpr (std::is_default_constructible_v<T>) {
+			if (enrollments.default_constructor) {
+				storage.set(L, meta_function::construct, constructors<T()>());
+			}
+		}
+
+		// return the named metatable we want names linked into
+		storage.named_metatable.push();
+		return 1;
+	}
+}} // namespace sol::u_detail
+
+// end of sol/usertype_storage.hpp
+
+// beginning of sol/usertype_proxy.hpp
+
+namespace sol {
+	template <typename Table, typename Key>
+	struct usertype_proxy : public proxy_base<usertype_proxy<Table, Key>> {
+	private:
+		using key_type = detail::proxy_key_t<Key>;
+
+		template <typename T, std::size_t... I>
+		decltype(auto) tuple_get(std::index_sequence<I...>) const & {
+			return tbl.template traverse_get<T>(std::get<I>(key)...);
+		}
+
+		template <typename T, std::size_t... I>
+		decltype(auto) tuple_get(std::index_sequence<I...>) && {
+			return tbl.template traverse_get<T>(std::get<I>(std::move(key))...);
+		}
+
+		template <std::size_t... I, typename T>
+		void tuple_set(std::index_sequence<I...>, T&& value) & {
+			if constexpr (sizeof...(I) > 1) {
+				tbl.traverse_set(std::get<I>(key)..., std::forward<T>(value));
+			}
+			else {
+				tbl.set(std::get<I>(key)..., std::forward<T>(value));
+			}
+		}
+
+		template <std::size_t... I, typename T>
+		void tuple_set(std::index_sequence<I...>, T&& value) && {
+			if constexpr (sizeof...(I) > 1) {
+				tbl.traverse_set(std::get<I>(std::move(key))..., std::forward<T>(value));
+			}
+			else {
+				tbl.set(std::get<I>(std::move(key))..., std::forward<T>(value));
+			}
+		}
+
+	public:
+		Table tbl;
+		key_type key;
+
+		template <typename T>
+		usertype_proxy(Table table, T&& k)
+		: tbl(table), key(std::forward<T>(k)) {
+		}
+
+		template <typename T>
+		usertype_proxy& set(T&& item) & {
+			using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;
+			tuple_set(idx_seq(), std::forward<T>(item));
+			return *this;
+		}
+
+		template <typename T>
+		usertype_proxy&& set(T&& item) && {
+			using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;
+			std::move(*this).tuple_set(idx_seq(), std::forward<T>(item));
+			return std::move(*this);
+		}
+
+		template <typename T>
+		usertype_proxy& operator=(T&& other) & {
+			return set(std::forward<T>(other));
+		}
+
+		template <typename T>
+		usertype_proxy&& operator=(T&& other) && {
+			return std::move(*this).set(std::forward<T>(other));
+		}
+
+		template <typename T>
+		usertype_proxy& operator=(std::initializer_list<T> other) & {
+			return set(std::move(other));
+		}
+
+		template <typename T>
+		usertype_proxy&& operator=(std::initializer_list<T> other) && {
+			return std::move(*this).set(std::move(other));
+		}
+
+		template <typename T>
+		decltype(auto) get() const& {
+			using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;
+			return tuple_get<T>(idx_seq());
+		}
+
+		template <typename T>
+		decltype(auto) get() && {
+			using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;
+			return std::move(*this).template tuple_get<T>(idx_seq());
+		}
+
+		template <typename K>
+		decltype(auto) operator[](K&& k) const& {
+			auto keys = meta::tuplefy(key, std::forward<K>(k));
+			return usertype_proxy<Table, decltype(keys)>(tbl, std::move(keys));
+		}
+
+		template <typename K>
+		decltype(auto) operator[](K&& k) & {
+			auto keys = meta::tuplefy(key, std::forward<K>(k));
+			return usertype_proxy<Table, decltype(keys)>(tbl, std::move(keys));
+		}
+
+		template <typename K>
+		decltype(auto) operator[](K&& k) && {
+			auto keys = meta::tuplefy(std::move(key), std::forward<K>(k));
+			return usertype_proxy<Table, decltype(keys)>(tbl, std::move(keys));
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) call(Args&&... args) {
+#if !defined(__clang__) && defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 191200000
+			// MSVC is ass sometimes
+			return get<function>().call<Ret...>(std::forward<Args>(args)...);
+#else
+			return get<function>().template call<Ret...>(std::forward<Args>(args)...);
+#endif
+		}
+
+		template <typename... Args>
+		decltype(auto) operator()(Args&&... args) {
+			return call<>(std::forward<Args>(args)...);
+		}
+
+		bool valid() const {
+			auto pp = stack::push_pop(tbl);
+			auto p = stack::probe_get_field<std::is_same<meta::unqualified_t<Table>, global_table>::value>(lua_state(), key, lua_gettop(lua_state()));
+			lua_pop(lua_state(), p.levels);
+			return p;
+		}
+
+		int push() const noexcept {
+			return push(this->lua_state());
+		}
+
+		int push(lua_State* L) const noexcept {
+			return get<reference>().push(L);
+		}
+
+		type get_type() const {
+			type t = type::none;
+			auto pp = stack::push_pop(tbl);
+			auto p = stack::probe_get_field<std::is_same<meta::unqualified_t<Table>, global_table>::value>(lua_state(), key, lua_gettop(lua_state()));
+			if (p) {
+				t = type_of(lua_state(), -1);
+			}
+			lua_pop(lua_state(), p.levels);
+			return t;
+		}
+
+		lua_State* lua_state() const {
+			return tbl.lua_state();
+		}
+	};
+} // namespace sol
+
+// end of sol/usertype_proxy.hpp
+
+// beginning of sol/metatable.hpp
+
+// beginning of sol/table_core.hpp
+
+// beginning of sol/table_proxy.hpp
+
+namespace sol {
+
+	template <typename Table, typename Key>
+	struct table_proxy : public proxy_base<table_proxy<Table, Key>> {
+	private:
+		using key_type = detail::proxy_key_t<Key>;
+
+		template <typename T, std::size_t... I>
+		decltype(auto) tuple_get(std::index_sequence<I...>) const& {
+			return tbl.template traverse_get<T>(std::get<I>(key)...);
+		}
+
+		template <typename T, std::size_t... I>
+		decltype(auto) tuple_get(std::index_sequence<I...>) && {
+			return tbl.template traverse_get<T>(std::get<I>(std::move(key))...);
+		}
+
+		template <std::size_t... I, typename T>
+		void tuple_set(std::index_sequence<I...>, T&& value) & {
+			tbl.traverse_set(std::get<I>(key)..., std::forward<T>(value));
+		}
+
+		template <std::size_t... I, typename T>
+		void tuple_set(std::index_sequence<I...>, T&& value) && {
+			tbl.traverse_set(std::get<I>(std::move(key))..., std::forward<T>(value));
+		}
+
+		auto setup_table(std::true_type) {
+			auto p = stack::probe_get_field<std::is_same_v<meta::unqualified_t<Table>, global_table>>(lua_state(), key, tbl.stack_index());
+			lua_pop(lua_state(), p.levels);
+			return p;
+		}
+
+		bool is_valid(std::false_type) {
+			auto pp = stack::push_pop(tbl);
+			auto p = stack::probe_get_field<std::is_same_v<meta::unqualified_t<Table>, global_table>>(lua_state(), key, lua_gettop(lua_state()));
+			lua_pop(lua_state(), p.levels);
+			return p;
+		}
+
+	public:
+		Table tbl;
+		key_type key;
+
+		template <typename T>
+		table_proxy(Table table, T&& k) : tbl(table), key(std::forward<T>(k)) {
+		}
+
+		template <typename T>
+		table_proxy& set(T&& item) & {
+			tuple_set(std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>(), std::forward<T>(item));
+			return *this;
+		}
+
+		template <typename T>
+		table_proxy&& set(T&& item) && {
+			tuple_set(std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>(), std::forward<T>(item));
+			return std::move(*this);
+		}
+
+		template <typename... Args>
+		table_proxy& set_function(Args&&... args) & {
+			tbl.set_function(key, std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename... Args>
+		table_proxy&& set_function(Args&&... args) && {
+			tbl.set_function(std::move(key), std::forward<Args>(args)...);
+			return std::move(*this);
+		}
+
+		template <typename T>
+		table_proxy& operator=(T&& other) & {
+			using Tu = meta::unwrap_unqualified_t<T>;
+			if constexpr (!is_lua_reference_or_proxy_v<Tu> && meta::is_callable_v<Tu>) {
+				return set_function(std::forward<T>(other));
+			}
+			else {
+				return set(std::forward<T>(other));
+			}
+		}
+
+		template <typename T>
+		table_proxy&& operator=(T&& other) && {
+			using Tu = meta::unwrap_unqualified_t<T>;
+			if constexpr (!is_lua_reference_or_proxy_v<Tu> && meta::is_callable_v<Tu>) {
+				return std::move(*this).set_function(std::forward<T>(other));
+			}
+			else {
+				return std::move(*this).set(std::forward<T>(other));
+			}
+		}
+
+		template <typename T>
+		table_proxy& operator=(std::initializer_list<T> other) & {
+			return set(std::move(other));
+		}
+
+		template <typename T>
+		table_proxy&& operator=(std::initializer_list<T> other) && {
+			return std::move(*this).set(std::move(other));
+		}
+
+		template <typename T>
+		decltype(auto) get() const& {
+			using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;
+			return tuple_get<T>(idx_seq());
+		}
+
+		template <typename T>
+		decltype(auto) get() && {
+			using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;
+			return std::move(*this).template tuple_get<T>(idx_seq());
+		}
+
+		template <typename T>
+		bool is() const {
+			typedef decltype(get<T>()) U;
+			optional<U> option = get<optional<U>>();
+			return option;
+		}
+
+		template <typename T>
+		decltype(auto) get_or(T&& otherwise) const {
+			typedef decltype(get<T>()) U;
+			optional<U> option = get<optional<U>>();
+			if (option) {
+				return static_cast<U>(option.value());
+			}
+			return static_cast<U>(std::forward<T>(otherwise));
+		}
+
+		template <typename T, typename D>
+		decltype(auto) get_or(D&& otherwise) const {
+			optional<T> option = get<optional<T>>();
+			if (option) {
+				return static_cast<T>(option.value());
+			}
+			return static_cast<T>(std::forward<D>(otherwise));
+		}
+
+		template <typename T>
+		decltype(auto) get_or_create() {
+			return get_or_create<T>(new_table());
+		}
+
+		template <typename T, typename Otherwise>
+		decltype(auto) get_or_create(Otherwise&& other) {
+			if (!this->valid()) {
+				this->set(std::forward<Otherwise>(other));
+			}
+			return get<T>();
+		}
+
+		template <typename K>
+		decltype(auto) operator[](K&& k) const& {
+			auto keys = meta::tuplefy(key, std::forward<K>(k));
+			return table_proxy<Table, decltype(keys)>(tbl, std::move(keys));
+		}
+
+		template <typename K>
+		decltype(auto) operator[](K&& k) & {
+			auto keys = meta::tuplefy(key, std::forward<K>(k));
+			return table_proxy<Table, decltype(keys)>(tbl, std::move(keys));
+		}
+
+		template <typename K>
+		decltype(auto) operator[](K&& k) && {
+			auto keys = meta::tuplefy(std::move(key), std::forward<K>(k));
+			return table_proxy<Table, decltype(keys)>(tbl, std::move(keys));
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) call(Args&&... args) {
+			lua_State* L = this->lua_state();
+			push(L);
+			int idx = lua_gettop(L);
+			stack_aligned_function func(L, idx);
+			return func.call<Ret...>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Args>
+		decltype(auto) operator()(Args&&... args) {
+			return call<>(std::forward<Args>(args)...);
+		}
+
+		bool valid() const {
+			auto pp = stack::push_pop(tbl);
+			auto p = stack::probe_get_field<std::is_same<meta::unqualified_t<Table>, global_table>::value>(lua_state(), key, lua_gettop(lua_state()));
+			lua_pop(lua_state(), p.levels);
+			return p;
+		}
+
+		int push() const noexcept {
+			return push(this->lua_state());
+		}
+
+		int push(lua_State* L) const noexcept {
+			if constexpr (std::is_same_v<meta::unqualified_t<Table>, global_table> || is_stack_table_v<meta::unqualified_t<Table>>) {
+				auto pp = stack::push_pop<true>(tbl);
+				int tableindex = pp.index_of(tbl);
+				int top_index = lua_gettop(L);
+				stack::get_field<true>(lua_state(), key, tableindex);
+				lua_replace(L, top_index + 1);
+				lua_settop(L, top_index + 1);
+			}
+			else {
+				auto pp = stack::push_pop<false>(tbl);
+				int tableindex = pp.index_of(tbl);
+				int aftertableindex = lua_gettop(L);
+				stack::get_field<false>(lua_state(), key, tableindex);
+				lua_replace(L, tableindex);
+				lua_settop(L, aftertableindex + 1);
+			}
+			return 1;
+		}
+
+		type get_type() const {
+			type t = type::none;
+			auto pp = stack::push_pop(tbl);
+			auto p = stack::probe_get_field<std::is_same<meta::unqualified_t<Table>, global_table>::value>(lua_state(), key, lua_gettop(lua_state()));
+			if (p) {
+				t = type_of(lua_state(), -1);
+			}
+			lua_pop(lua_state(), p.levels);
+			return t;
+		}
+
+		lua_State* lua_state() const {
+			return tbl.lua_state();
+		}
+
+		table_proxy& force() {
+			if (!this->valid()) {
+				this->set(new_table());
+			}
+			return *this;
+		}
+
+		// added by me
+		template<typename T>
+		inline decltype(auto) as() const& {
+			return get<T>();
+		}
+
+		template<typename T>
+		inline decltype(auto) as() && {
+			return get<T>();
+		}
+
+		inline decltype(auto) begin() {
+			return get<sol::table>().begin();
+		}
+		inline decltype(auto) end() {
+			return get<sol::table>().end();
+		}
+	};
+
+	template <typename Table, typename Key, typename T>
+	inline bool operator==(T&& left, const table_proxy<Table, Key>& right) {
+		using G = decltype(stack::get<T>(nullptr, 0));
+		return right.template get<optional<G>>() == left;
+	}
+
+	template <typename Table, typename Key, typename T>
+	inline bool operator==(const table_proxy<Table, Key>& right, T&& left) {
+		using G = decltype(stack::get<T>(nullptr, 0));
+		return right.template get<optional<G>>() == left;
+	}
+
+	template <typename Table, typename Key, typename T>
+	inline bool operator!=(T&& left, const table_proxy<Table, Key>& right) {
+		using G = decltype(stack::get<T>(nullptr, 0));
+		return right.template get<optional<G>>() != left;
+	}
+
+	template <typename Table, typename Key, typename T>
+	inline bool operator!=(const table_proxy<Table, Key>& right, T&& left) {
+		using G = decltype(stack::get<T>(nullptr, 0));
+		return right.template get<optional<G>>() != left;
+	}
+
+	template <typename Table, typename Key>
+	inline bool operator==(lua_nil_t, const table_proxy<Table, Key>& right) {
+		return !right.valid();
+	}
+
+	template <typename Table, typename Key>
+	inline bool operator==(const table_proxy<Table, Key>& right, lua_nil_t) {
+		return !right.valid();
+	}
+
+	template <typename Table, typename Key>
+	inline bool operator!=(lua_nil_t, const table_proxy<Table, Key>& right) {
+		return right.valid();
+	}
+
+	template <typename Table, typename Key>
+	inline bool operator!=(const table_proxy<Table, Key>& right, lua_nil_t) {
+		return right.valid();
+	}
+
+	template <bool b>
+	template <typename Super>
+	basic_reference<b>& basic_reference<b>::operator=(proxy_base<Super>&& r) {
+		basic_reference<b> v = r;
+		this->operator=(std::move(v));
+		return *this;
+	}
+
+	template <bool b>
+	template <typename Super>
+	basic_reference<b>& basic_reference<b>::operator=(const proxy_base<Super>& r) {
+		basic_reference<b> v = r;
+		this->operator=(std::move(v));
+		return *this;
+	}
+
+	namespace stack {
+		template <typename Table, typename Key>
+		struct unqualified_pusher<table_proxy<Table, Key>> {
+			static int push(lua_State* L, const table_proxy<Table, Key>& p) {
+				return p.push(L);
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/table_proxy.hpp
+
+// beginning of sol/table_iterator.hpp
+
+#include <iterator>
+
+namespace sol {
+
+	template <typename reference_type>
+	class basic_table_iterator {
+	public:
+		typedef object key_type;
+		typedef object mapped_type;
+		typedef std::pair<object, object> value_type;
+		typedef std::input_iterator_tag iterator_category;
+		typedef std::ptrdiff_t difference_type;
+		typedef value_type* pointer;
+		typedef value_type& reference;
+		typedef const value_type& const_reference;
+
+	private:
+		std::pair<object, object> kvp;
+		reference_type ref;
+		int tableidx = 0;
+		int keyidx = 0;
+		std::ptrdiff_t idx = 0;
+
+	public:
+		basic_table_iterator() : keyidx(-1), idx(-1) {
+		}
+
+		basic_table_iterator(reference_type x) : ref(std::move(x)) {
+			ref.push();
+			tableidx = lua_gettop(ref.lua_state());
+			stack::push(ref.lua_state(), lua_nil);
+			this->operator++();
+			if (idx == -1) {
+				return;
+			}
+			--idx;
+		}
+
+		basic_table_iterator& operator++() {
+			if (idx == -1)
+				return *this;
+
+			if (lua_next(ref.lua_state(), tableidx) == 0) {
+				idx = -1;
+				keyidx = -1;
+				return *this;
+			}
+			++idx;
+			kvp.first = object(ref.lua_state(), -2);
+			kvp.second = object(ref.lua_state(), -1);
+			lua_pop(ref.lua_state(), 1);
+			// leave key on the stack
+			keyidx = lua_gettop(ref.lua_state());
+			return *this;
+		}
+
+		basic_table_iterator operator++(int) {
+			auto saved = *this;
+			this->operator++();
+			return saved;
+		}
+
+		reference operator*() {
+			return kvp;
+		}
+
+		const_reference operator*() const {
+			return kvp;
+		}
+
+		bool operator==(const basic_table_iterator& right) const {
+			return idx == right.idx;
+		}
+
+		bool operator!=(const basic_table_iterator& right) const {
+			return idx != right.idx;
+		}
+
+		~basic_table_iterator() {
+			if (keyidx != -1) {
+				stack::remove(ref.lua_state(), keyidx, 1);
+			}
+			if (ref.lua_state() != nullptr && ref.valid()) {
+				stack::remove(ref.lua_state(), tableidx, 1);
+			}
+		}
+	};
+
+} // namespace sol
+
+// end of sol/table_iterator.hpp
+
+namespace sol {
+	namespace detail {
+		template <std::size_t n>
+		struct clean {
+			lua_State* L;
+			clean(lua_State* luastate) : L(luastate) {
+			}
+			~clean() {
+				lua_pop(L, static_cast<int>(n));
+			}
+		};
+
+		struct ref_clean {
+			lua_State* L;
+			int& n;
+			ref_clean(lua_State* luastate, int& n) : L(luastate), n(n) {
+			}
+			~ref_clean() {
+				lua_pop(L, static_cast<int>(n));
+			}
+		};
+
+		inline int fail_on_newindex(lua_State* L) {
+			return luaL_error(L, "sol: cannot modify the elements of an enumeration table");
+		}
+
+	} // namespace detail
+
+	template <bool top_level, typename ref_t>
+	class basic_table_core : public basic_object<ref_t> {
+	private:
+		using base_t = basic_object<ref_t>;
+
+		friend class state;
+		friend class state_view;
+		template <typename, typename>
+		friend class basic_usertype;
+		template <typename>
+		friend class basic_metatable;
+
+		template <bool raw, typename... Ret, typename... Keys>
+		decltype(auto) tuple_get(int table_index, Keys&&... keys) const {
+			if constexpr (sizeof...(Ret) < 2) {
+				return traverse_get_single_maybe_tuple<raw, Ret...>(table_index, std::forward<Keys>(keys)...);
+			}
+			else {
+				using multi_ret = decltype(stack::pop<std::tuple<Ret...>>(nullptr));
+				return multi_ret(traverse_get_single_maybe_tuple<raw, Ret>(table_index, std::forward<Keys>(keys))...);
+			}
+		}
+
+		template <bool raw, typename Ret, size_t... I, typename Key>
+		decltype(auto) traverse_get_single_tuple(int table_index, std::index_sequence<I...>, Key&& key) const {
+			return traverse_get_single<raw, Ret>(table_index, std::get<I>(std::forward<Key>(key))...);
+		}
+
+		template <bool raw, typename Ret, typename Key>
+		decltype(auto) traverse_get_single_maybe_tuple(int table_index, Key&& key) const {
+			if constexpr (meta::is_tuple_v<meta::unqualified_t<Key>>) {
+				return traverse_get_single_tuple<raw, Ret>(
+				     table_index, std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<Key>>>(), std::forward<Key>(key));
+			}
+			else {
+				return traverse_get_single<raw, Ret>(table_index, std::forward<Key>(key));
+			}
+		}
+
+		template <bool raw, typename Ret, typename... Keys>
+		decltype(auto) traverse_get_single(int table_index, Keys&&... keys) const {
+			constexpr static bool global = top_level && (meta::count_for_to_pack_v<1, meta::is_c_str, meta::unqualified_t<Keys>...> > 0);
+			if constexpr (meta::is_optional_v<meta::unqualified_t<Ret>>) {
+				int popcount = 0;
+				detail::ref_clean c(base_t::lua_state(), popcount);
+				return traverse_get_deep_optional<global, raw, detail::insert_mode::none, Ret>(popcount, table_index, std::forward<Keys>(keys)...);
+			}
+			else {
+				detail::clean<sizeof...(Keys) - meta::count_for_pack_v<detail::is_insert_mode, meta::unqualified_t<Keys>...>> c(base_t::lua_state());
+				return traverse_get_deep<global, raw, detail::insert_mode::none, Ret>(table_index, std::forward<Keys>(keys)...);
+			}
+		}
+
+		template <bool raw, typename Pairs, std::size_t... I>
+		void tuple_set(std::index_sequence<I...>, Pairs&& pairs) {
+			constexpr static bool global = top_level
+			     && (meta::count_even_for_pack_v<meta::is_c_str, meta::unqualified_t<decltype(std::get<I * 2>(std::forward<Pairs>(pairs)))>...> > 0);
+			auto pp = stack::push_pop<global>(*this);
+			int table_index = pp.index_of(*this);
+			lua_State* L = base_t::lua_state();
+			(void)table_index;
+			(void)L;
+			void(detail::swallow { (stack::set_field<(top_level), raw>(
+			                             L, std::get<I * 2>(std::forward<Pairs>(pairs)), std::get<I * 2 + 1>(std::forward<Pairs>(pairs)), table_index),
+			     0)... });
+		}
+
+		template <bool global, bool raw, detail::insert_mode mode, typename T, typename Key, typename... Keys>
+		decltype(auto) traverse_get_deep(int table_index, Key&& key, Keys&&... keys) const {
+			if constexpr (std::is_same_v<meta::unqualified_t<Key>, create_if_nil_t>) {
+				(void)key;
+				return traverse_get_deep<false, raw, static_cast<detail::insert_mode>(mode | detail::insert_mode::create_if_nil), T>(
+				     table_index, std::forward<Keys>(keys)...);
+			}
+			else {
+				lua_State* L = base_t::lua_state();
+				stack::get_field<global, raw>(L, std::forward<Key>(key), table_index);
+				if constexpr (sizeof...(Keys) > 0) {
+					if constexpr ((mode & detail::insert_mode::create_if_nil) == detail::insert_mode::create_if_nil) {
+						type t = type_of(L, -1);
+						if (t == type::lua_nil || t == type::none) {
+							lua_pop(L, 1);
+							stack::push(L, new_table(0, 0));
+						}
+					}
+					return traverse_get_deep<false, raw, mode, T>(lua_gettop(L), std::forward<Keys>(keys)...);
+				}
+				else {
+					if constexpr ((mode & detail::insert_mode::create_if_nil) == detail::insert_mode::create_if_nil) {
+						type t = type_of(L, -1);
+						if ((t == type::lua_nil || t == type::none) && (is_table_like_v<T>)) {
+							lua_pop(L, 1);
+							stack::push(L, new_table(0, 0));
+						}
+					}
+					return stack::get<T>(L);
+				}
+			}
+		}
+
+		template <bool global, bool raw, detail::insert_mode mode, typename T, typename Key, typename... Keys>
+		decltype(auto) traverse_get_deep_optional(int& popcount, int table_index, Key&& key, Keys&&... keys) const {
+			if constexpr (std::is_same_v<meta::unqualified_t<Key>, create_if_nil_t>) {
+				constexpr detail::insert_mode new_mode = static_cast<detail::insert_mode>(mode | detail::insert_mode::create_if_nil);
+				(void)key;
+				return traverse_get_deep_optional<global, raw, new_mode, T>(popcount, table_index, std::forward<Keys>(keys)...);
+			}
+			else if constexpr (std::is_same_v<meta::unqualified_t<Key>, update_if_empty_t>) {
+				constexpr detail::insert_mode new_mode = static_cast<detail::insert_mode>(mode | detail::insert_mode::update_if_empty);
+				(void)key;
+				return traverse_get_deep_optional<global, raw, new_mode, T>(popcount, table_index, std::forward<Keys>(keys)...);
+			}
+			else if constexpr (std::is_same_v<meta::unqualified_t<Key>, override_value_t>) {
+				constexpr detail::insert_mode new_mode = static_cast<detail::insert_mode>(mode | detail::insert_mode::override_value);
+				(void)key;
+				return traverse_get_deep_optional<global, raw, new_mode, T>(popcount, table_index, std::forward<Keys>(keys)...);
+			}
+			else {
+				if constexpr (sizeof...(Keys) > 0) {
+					lua_State* L = base_t::lua_state();
+					auto p = stack::probe_get_field<global, raw>(L, std::forward<Key>(key), table_index);
+					popcount += p.levels;
+					if (!p.success) {
+						if constexpr ((mode & detail::insert_mode::create_if_nil) == detail::insert_mode::create_if_nil) {
+							lua_pop(L, 1);
+							constexpr bool is_seq = meta::count_for_to_pack_v<1, std::is_integral, Keys...> > 0;
+							stack::push(L, new_table(static_cast<int>(is_seq), static_cast<int>(!is_seq)));
+							stack::set_field<global, raw>(L, std::forward<Key>(key), stack_reference(L, -1), table_index);
+						}
+						else {
+							return T(nullopt);
+						}
+					}
+					return traverse_get_deep_optional<false, raw, mode, T>(popcount, lua_gettop(L), std::forward<Keys>(keys)...);
+				}
+				else {
+					using R = decltype(stack::get<T>(nullptr));
+					using value_type = typename meta::unqualified_t<R>::value_type;
+					lua_State* L = base_t::lua_state();
+					auto p = stack::probe_get_field<global, raw, value_type>(L, key, table_index);
+					popcount += p.levels;
+					if (!p.success) {
+						if constexpr ((mode & detail::insert_mode::create_if_nil) == detail::insert_mode::create_if_nil) {
+							lua_pop(L, 1);
+							stack::push(L, new_table(0, 0));
+							stack::set_field<global, raw>(L, std::forward<Key>(key), stack_reference(L, -1), table_index);
+							if (stack::check<value_type>(L, lua_gettop(L), no_panic)) {
+								return stack::get<T>(L);
+							}
+						}
+						return R(nullopt);
+					}
+					return stack::get<T>(L);
+				}
+			}
+		}
+
+		template <bool global, bool raw, detail::insert_mode mode, typename Key, typename... Keys>
+		void traverse_set_deep(int table_index, Key&& key, Keys&&... keys) const {
+			using KeyU = meta::unqualified_t<Key>;
+			if constexpr (std::is_same_v<KeyU, update_if_empty_t>) {
+				(void)key;
+				traverse_set_deep<global, raw, static_cast<detail::insert_mode>(mode | detail::insert_mode::update_if_empty)>(
+				     table_index, std::forward<Keys>(keys)...);
+			}
+			else if constexpr (std::is_same_v<KeyU, create_if_nil_t>) {
+				(void)key;
+				traverse_set_deep<global, raw, static_cast<detail::insert_mode>(mode | detail::insert_mode::create_if_nil)>(
+				     table_index, std::forward<Keys>(keys)...);
+			}
+			else if constexpr (std::is_same_v<KeyU, override_value_t>) {
+				(void)key;
+				traverse_set_deep<global, raw, static_cast<detail::insert_mode>(mode | detail::insert_mode::override_value)>(
+				     table_index, std::forward<Keys>(keys)...);
+			}
+			else {
+				lua_State* L = base_t::lua_state();
+				if constexpr (sizeof...(Keys) == 1) {
+					if constexpr ((mode & detail::insert_mode::update_if_empty) == detail::insert_mode::update_if_empty) {
+						auto p = stack::probe_get_field<global, raw>(L, key, table_index);
+						lua_pop(L, p.levels);
+						if (!p.success) {
+							stack::set_field<global, raw>(L, std::forward<Key>(key), std::forward<Keys>(keys)..., table_index);
+						}
+					}
+					else {
+						stack::set_field<global, raw>(L, std::forward<Key>(key), std::forward<Keys>(keys)..., table_index);
+					}
+				}
+				else {
+					if constexpr (mode != detail::insert_mode::none) {
+						stack::get_field<global, raw>(L, key, table_index);
+						type vt = type_of(L, -1);
+						if constexpr ((mode & detail::insert_mode::update_if_empty) == detail::insert_mode::update_if_empty
+						     || (mode & detail::insert_mode::create_if_nil) == detail::insert_mode::create_if_nil) {
+							if (vt == type::lua_nil || vt == type::none) {
+								constexpr bool is_seq = meta::count_for_to_pack_v<1, std::is_integral, Keys...> > 0;
+								lua_pop(L, 1);
+								stack::push(L, new_table(static_cast<int>(is_seq), static_cast<int>(!is_seq)));
+								stack::set_field<global, raw>(L, std::forward<Key>(key), stack_reference(L, -1), table_index);
+							}
+						}
+						else {
+							if (vt != type::table) {
+								constexpr bool is_seq = meta::count_for_to_pack_v<1, std::is_integral, Keys...> > 0;
+								lua_pop(L, 1);
+								stack::push(L, new_table(static_cast<int>(is_seq), static_cast<int>(!is_seq)));
+								stack::set_field<global, raw>(L, std::forward<Key>(key), stack_reference(L, -1), table_index);
+							}
+						}
+					}
+					else {
+						stack::get_field<global, raw>(L, std::forward<Key>(key), table_index);
+					}
+					traverse_set_deep<false, raw, mode>(lua_gettop(L), std::forward<Keys>(keys)...);
+				}
+			}
+		}
+
+		basic_table_core(lua_State* L, detail::global_tag t) noexcept : base_t(L, t) {
+		}
+
+	protected:
+		basic_table_core(detail::no_safety_tag, lua_nil_t n) : base_t(n) {
+		}
+		basic_table_core(detail::no_safety_tag, lua_State* L, int index) : base_t(L, index) {
+		}
+		basic_table_core(detail::no_safety_tag, lua_State* L, ref_index index) : base_t(L, index) {
+		}
+		template <typename T,
+		     meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_table_core>>, meta::neg<std::is_same<ref_t, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_table_core(detail::no_safety_tag, T&& r) noexcept : base_t(std::forward<T>(r)) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_table_core(detail::no_safety_tag, lua_State* L, T&& r) noexcept : base_t(L, std::forward<T>(r)) {
+		}
+
+	public:
+		using iterator = basic_table_iterator<ref_t>;
+		using const_iterator = iterator;
+
+		using base_t::lua_state;
+
+		basic_table_core() noexcept = default;
+		basic_table_core(const basic_table_core&) = default;
+		basic_table_core(basic_table_core&&) = default;
+		basic_table_core& operator=(const basic_table_core&) = default;
+		basic_table_core& operator=(basic_table_core&&) = default;
+		basic_table_core(const stack_reference& r) : basic_table_core(r.lua_state(), r.stack_index()) {
+		}
+		basic_table_core(stack_reference&& r) : basic_table_core(r.lua_state(), r.stack_index()) {
+		}
+		template <typename T, meta::enable_any<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_table_core(lua_State* L, T&& r) : base_t(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			auto pp = stack::push_pop(*this);
+			int table_index = pp.index_of(*this);
+			constructor_handler handler {};
+			stack::check<basic_table_core>(lua_state(), table_index, handler);
+#endif // Safety
+		}
+		basic_table_core(lua_State* L, const new_table& nt) : base_t(L, -stack::push(L, nt)) {
+			if (!is_stack_based<meta::unqualified_t<ref_t>>::value) {
+				lua_pop(L, 1);
+			}
+		}
+		basic_table_core(lua_State* L, int index = -1) : basic_table_core(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			constructor_handler handler {};
+			stack::check<basic_table_core>(L, index, handler);
+#endif // Safety
+		}
+		basic_table_core(lua_State* L, ref_index index) : basic_table_core(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			auto pp = stack::push_pop(*this);
+			int table_index = pp.index_of(*this);
+			constructor_handler handler {};
+			stack::check<basic_table_core>(lua_state(), table_index, handler);
+#endif // Safety
+		}
+		template <typename T,
+		     meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_table_core>>, meta::neg<std::is_same<ref_t, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_table_core(T&& r) noexcept : basic_table_core(detail::no_safety, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			if (!is_table<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				int table_index = pp.index_of(*this);
+				constructor_handler handler {};
+				stack::check<basic_table_core>(lua_state(), table_index, handler);
+			}
+#endif // Safety
+		}
+		basic_table_core(lua_nil_t r) noexcept : basic_table_core(detail::no_safety, r) {
+		}
+
+		iterator begin() const {
+			if (this->get_type() == type::table) {
+				return iterator(*this);
+			}
+			return iterator();
+		}
+
+		iterator end() const {
+			return iterator();
+		}
+
+		const_iterator cbegin() const {
+			return begin();
+		}
+
+		const_iterator cend() const {
+			return end();
+		}
+
+		void clear() {
+			auto pp = stack::push_pop<false>(*this);
+			int table_index = pp.index_of(*this);
+			stack::clear(lua_state(), table_index);
+		}
+
+		template <typename... Ret, typename... Keys>
+		decltype(auto) get(Keys&&... keys) const {
+			static_assert(sizeof...(Keys) == sizeof...(Ret), "number of keys and number of return types do not match");
+			constexpr static bool global = meta::all<meta::boolean<top_level>, meta::is_c_str<meta::unqualified_t<Keys>>...>::value;
+			auto pp = stack::push_pop<global>(*this);
+			int table_index = pp.index_of(*this);
+			return tuple_get<false, Ret...>(table_index, std::forward<Keys>(keys)...);
+		}
+
+		template <typename T, typename Key>
+		decltype(auto) get_or(Key&& key, T&& otherwise) const {
+			typedef decltype(get<T>("")) U;
+			optional<U> option = get<optional<U>>(std::forward<Key>(key));
+			if (option) {
+				return static_cast<U>(option.value());
+			}
+			return static_cast<U>(std::forward<T>(otherwise));
+		}
+
+		template <typename T, typename Key, typename D>
+		decltype(auto) get_or(Key&& key, D&& otherwise) const {
+			optional<T> option = get<optional<T>>(std::forward<Key>(key));
+			if (option) {
+				return static_cast<T>(option.value());
+			}
+			return static_cast<T>(std::forward<D>(otherwise));
+		}
+
+		template <typename T, typename... Keys>
+		decltype(auto) traverse_get(Keys&&... keys) const {
+			static_assert(sizeof...(Keys) > 0, "must pass at least 1 key to get");
+			constexpr static bool global = top_level && (meta::count_for_to_pack_v<1, meta::is_c_str, meta::unqualified_t<Keys>...> > 0);
+			auto pp = stack::push_pop<global>(*this);
+			int table_index = pp.index_of(*this);
+			return traverse_get_single<false, T>(table_index, std::forward<Keys>(keys)...);
+		}
+
+		template <typename... Keys>
+		basic_table_core& traverse_set(Keys&&... keys) {
+			static_assert(sizeof...(Keys) > 1, "must pass at least 1 key and 1 value to set");
+			constexpr static bool global
+			     = top_level && (meta::count_when_for_to_pack_v<detail::is_not_insert_mode, 1, meta::is_c_str, meta::unqualified_t<Keys>...> > 0);
+			auto pp = stack::push_pop<global>(*this);
+			int table_index = pp.index_of(*this);
+			lua_State* L = base_t::lua_state();
+			auto pn = stack::pop_n(L, static_cast<int>(sizeof...(Keys) - 2 - meta::count_for_pack_v<detail::is_insert_mode, meta::unqualified_t<Keys>...>));
+			traverse_set_deep<top_level, false, detail::insert_mode::none>(table_index, std::forward<Keys>(keys)...);
+			return *this;
+		}
+
+		template <typename... Args>
+		basic_table_core& set(Args&&... args) {
+			if constexpr (sizeof...(Args) == 2) {
+				traverse_set(std::forward<Args>(args)...);
+			}
+			else {
+				tuple_set<false>(std::make_index_sequence<sizeof...(Args) / 2>(), std::forward_as_tuple(std::forward<Args>(args)...));
+			}
+			return *this;
+		}
+
+		template <typename... Ret, typename... Keys>
+		decltype(auto) raw_get(Keys&&... keys) const {
+			static_assert(sizeof...(Keys) == sizeof...(Ret), "number of keys and number of return types do not match");
+			constexpr static bool global = top_level && (meta::count_for_to_pack_v<1, meta::is_c_str, meta::unqualified_t<Keys>...> > 0);
+			auto pp = stack::push_pop<global>(*this);
+			int table_index = pp.index_of(*this);
+			return tuple_get<true, Ret...>(table_index, std::forward<Keys>(keys)...);
+		}
+
+		template <typename T, typename Key>
+		decltype(auto) raw_get_or(Key&& key, T&& otherwise) const {
+			typedef decltype(raw_get<T>("")) U;
+			optional<U> option = raw_get<optional<U>>(std::forward<Key>(key));
+			if (option) {
+				return static_cast<U>(option.value());
+			}
+			return static_cast<U>(std::forward<T>(otherwise));
+		}
+
+		template <typename T, typename Key, typename D>
+		decltype(auto) raw_get_or(Key&& key, D&& otherwise) const {
+			optional<T> option = raw_get<optional<T>>(std::forward<Key>(key));
+			if (option) {
+				return static_cast<T>(option.value());
+			}
+			return static_cast<T>(std::forward<D>(otherwise));
+		}
+
+		template <typename T, typename... Keys>
+		decltype(auto) traverse_raw_get(Keys&&... keys) const {
+			constexpr static bool global = top_level && (meta::count_for_to_pack_v<1, meta::is_c_str, meta::unqualified_t<Keys>...> > 0);
+			auto pp = stack::push_pop<global>(*this);
+			int table_index = pp.index_of(*this);
+			return traverse_get_single<true, T>(table_index, std::forward<Keys>(keys)...);
+		}
+
+		template <typename... Keys>
+		basic_table_core& traverse_raw_set(Keys&&... keys) {
+			constexpr static bool global = top_level && (meta::count_for_to_pack_v<1, meta::is_c_str, meta::unqualified_t<Keys>...> > 0);
+			auto pp = stack::push_pop<global>(*this);
+			lua_State* L = base_t::lua_state();
+			auto pn = stack::pop_n(L, static_cast<int>(sizeof...(Keys) - 2 - meta::count_for_pack_v<detail::is_insert_mode, meta::unqualified_t<Keys>...>));
+			traverse_set_deep<top_level, true, false>(std::forward<Keys>(keys)...);
+			return *this;
+		}
+
+		template <typename... Args>
+		basic_table_core& raw_set(Args&&... args) {
+			tuple_set<true>(std::make_index_sequence<sizeof...(Args) / 2>(), std::forward_as_tuple(std::forward<Args>(args)...));
+			return *this;
+		}
+
+		template <typename Class, typename Key>
+		usertype<Class> new_usertype(Key&& key);
+
+		template <typename Class, typename Key>
+		usertype<Class> new_usertype(Key&& key, automagic_enrollments enrollment);
+
+		template <typename Class, typename Key, typename Arg, typename... Args,
+		     typename = std::enable_if_t<!std::is_same_v<meta::unqualified_t<Arg>, automagic_enrollments>>>
+		usertype<Class> new_usertype(Key&& key, Arg&& arg, Args&&... args);
+
+		template <bool read_only = true, typename... Args>
+		table new_enum(const string_view& name, Args&&... args) {
+			table target = create_with(std::forward<Args>(args)...);
+			if (read_only) {
+				table x = create_with(meta_function::new_index, detail::fail_on_newindex, meta_function::index, target);
+				table shim = create_named(name, metatable_key, x);
+				return shim;
+			}
+			else {
+				set(name, target);
+				return target;
+			}
+		}
+
+		template <typename T, bool read_only = true>
+		table new_enum(const string_view& name, std::initializer_list<std::pair<string_view, T>> items) {
+			table target = create(static_cast<int>(items.size()), static_cast<int>(0));
+			for (const auto& kvp : items) {
+				target.set(kvp.first, kvp.second);
+			}
+			if constexpr (read_only) {
+				table x = create_with(meta_function::new_index, detail::fail_on_newindex, meta_function::index, target);
+				table shim = create_named(name, metatable_key, x);
+				return shim;
+			}
+			else {
+				set(name, target);
+				return target;
+			}
+		}
+
+		template <typename Key = object, typename Value = object, typename Fx>
+		void for_each(Fx&& fx) const {
+			lua_State* L = base_t::lua_state();
+			if constexpr (std::is_invocable_v<Fx, Key, Value>) {
+				auto pp = stack::push_pop(*this);
+				int table_index = pp.index_of(*this);
+				stack::push(L, lua_nil);
+				while (lua_next(L, table_index)) {
+					Key key(L, -2);
+					Value value(L, -1);
+					auto pn = stack::pop_n(L, 1);
+					fx(key, value);
+				}
+			}
+			else {
+				auto pp = stack::push_pop(*this);
+				int table_index = pp.index_of(*this);
+				stack::push(L, lua_nil);
+				while (lua_next(L, table_index)) {
+					Key key(L, -2);
+					Value value(L, -1);
+					auto pn = stack::pop_n(L, 1);
+					std::pair<Key&, Value&> keyvalue(key, value);
+					fx(keyvalue);
+				}
+			}
+		}
+
+		size_t size() const {
+			auto pp = stack::push_pop(*this);
+			int table_index = pp.index_of(*this);
+			lua_State* L = base_t::lua_state();
+			lua_len(L, table_index);
+			return stack::pop<size_t>(L);
+		}
+
+		bool empty() const {
+			return cbegin() == cend();
+		}
+
+		template <typename T>
+		auto operator[](T&& key) & {
+			return table_proxy<basic_table_core&, detail::proxy_key_t<T>>(*this, std::forward<T>(key));
+		}
+
+		template <typename T>
+		auto operator[](T&& key) const& {
+			return table_proxy<const basic_table_core&, detail::proxy_key_t<T>>(*this, std::forward<T>(key));
+		}
+
+		template <typename T>
+		auto operator[](T&& key) && {
+			return table_proxy<basic_table_core, detail::proxy_key_t<T>>(std::move(*this), std::forward<T>(key));
+		}
+
+		template <typename Sig, typename Key, typename... Args>
+		basic_table_core& set_function(Key&& key, Args&&... args) {
+			set_fx(types<Sig>(), std::forward<Key>(key), std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename Key, typename... Args>
+		basic_table_core& set_function(Key&& key, Args&&... args) {
+			set_fx(types<>(), std::forward<Key>(key), std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename... Args>
+		basic_table_core& add(Args&&... args) {
+			auto pp = stack::push_pop(*this);
+			int table_index = pp.index_of(*this);
+			lua_State* L = base_t::lua_state();
+			(void)detail::swallow { 0, (stack::set_ref(L, std::forward<Args>(args), table_index), 0)... };
+			return *this;
+		}
+
+	private:
+		template <typename R, typename... Args, typename Fx, typename Key, typename = std::invoke_result_t<Fx, Args...>>
+		void set_fx(types<R(Args...)>, Key&& key, Fx&& fx) {
+			set_resolved_function<R(Args...)>(std::forward<Key>(key), std::forward<Fx>(fx));
+		}
+
+		template <typename Fx, typename Key, meta::enable<meta::is_specialization_of<meta::unqualified_t<Fx>, overload_set>> = meta::enabler>
+		void set_fx(types<>, Key&& key, Fx&& fx) {
+			set(std::forward<Key>(key), std::forward<Fx>(fx));
+		}
+
+		template <typename Fx, typename Key, typename... Args,
+		     meta::disable<meta::is_specialization_of<meta::unqualified_t<Fx>, overload_set>> = meta::enabler>
+		void set_fx(types<>, Key&& key, Fx&& fx, Args&&... args) {
+			set(std::forward<Key>(key), as_function_reference(std::forward<Fx>(fx), std::forward<Args>(args)...));
+		}
+
+		template <typename... Sig, typename... Args, typename Key>
+		void set_resolved_function(Key&& key, Args&&... args) {
+			set(std::forward<Key>(key), as_function_reference<function_sig<Sig...>>(std::forward<Args>(args)...));
+		}
+
+	public:
+		static inline table create(lua_State* L, int narr = 0, int nrec = 0) {
+			lua_createtable(L, narr, nrec);
+			table result(L);
+			lua_pop(L, 1);
+			return result;
+		}
+
+		template <typename Key, typename Value, typename... Args>
+		static inline table create(lua_State* L, int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
+			lua_createtable(L, narr, nrec);
+			table result(L);
+			result.set(std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+			lua_pop(L, 1);
+			return result;
+		}
+
+		template <typename... Args>
+		static inline table create_with(lua_State* L, Args&&... args) {
+			static_assert(sizeof...(Args) % 2 == 0, "You must have an even number of arguments for a key, value ... list.");
+			constexpr int narr = static_cast<int>(meta::count_odd_for_pack_v<std::is_integral, Args...>);
+			return create(L, narr, static_cast<int>((sizeof...(Args) / 2) - narr), std::forward<Args>(args)...);
+		}
+
+		table create(int narr = 0, int nrec = 0) {
+			return create(base_t::lua_state(), narr, nrec);
+		}
+
+		template <typename Key, typename Value, typename... Args>
+		table create(int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
+			return create(base_t::lua_state(), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+		}
+
+		template <typename Name>
+		table create(Name&& name, int narr = 0, int nrec = 0) {
+			table x = create(base_t::lua_state(), narr, nrec);
+			this->set(std::forward<Name>(name), x);
+			return x;
+		}
+
+		template <typename Name, typename Key, typename Value, typename... Args>
+		table create(Name&& name, int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
+			table x = create(base_t::lua_state(), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+			this->set(std::forward<Name>(name), x);
+			return x;
+		}
+
+		template <typename... Args>
+		table create_with(Args&&... args) {
+			return create_with(base_t::lua_state(), std::forward<Args>(args)...);
+		}
+
+		template <typename Name, typename... Args>
+		table create_named(Name&& name, Args&&... args) {
+			static const int narr = static_cast<int>(meta::count_even_for_pack_v<std::is_integral, Args...>);
+			return create(std::forward<Name>(name), narr, (sizeof...(Args) / 2) - narr, std::forward<Args>(args)...);
+		}
+	};
+} // namespace sol
+
+// end of sol/table_core.hpp
+
+namespace sol {
+
+	template <typename base_type>
+	class basic_metatable : public basic_table<base_type> {
+		typedef basic_table<base_type> base_t;
+		friend class state;
+		friend class state_view;
+
+	protected:
+		basic_metatable(detail::no_safety_tag, lua_nil_t n) : base_t(n) {
+		}
+		basic_metatable(detail::no_safety_tag, lua_State* L, int index) : base_t(L, index) {
+		}
+		basic_metatable(detail::no_safety_tag, lua_State* L, ref_index index) : base_t(L, index) {
+		}
+		template <typename T,
+		     meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_metatable>>, meta::neg<std::is_same<base_type, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_metatable(detail::no_safety_tag, T&& r) noexcept : base_t(std::forward<T>(r)) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_metatable(detail::no_safety_tag, lua_State* L, T&& r) noexcept : base_t(L, std::forward<T>(r)) {
+		}
+
+	public:
+		using base_t::lua_state;
+
+		basic_metatable() noexcept = default;
+		basic_metatable(const basic_metatable&) = default;
+		basic_metatable(basic_metatable&&) = default;
+		basic_metatable& operator=(const basic_metatable&) = default;
+		basic_metatable& operator=(basic_metatable&&) = default;
+		basic_metatable(const stack_reference& r) : basic_metatable(r.lua_state(), r.stack_index()) {
+		}
+		basic_metatable(stack_reference&& r) : basic_metatable(r.lua_state(), r.stack_index()) {
+		}
+		template <typename T, meta::enable_any<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_metatable(lua_State* L, T&& r) : base_t(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler{};
+			stack::check<basic_metatable>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		basic_metatable(lua_State* L, int index = -1) : basic_metatable(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			constructor_handler handler{};
+			stack::check<basic_metatable>(L, index, handler);
+#endif // Safety
+		}
+		basic_metatable(lua_State* L, ref_index index) : basic_metatable(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler{};
+			stack::check<basic_metatable>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		template <typename T,
+		     meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_metatable>>, meta::neg<std::is_same<base_type, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_metatable(T&& r) noexcept : basic_metatable(detail::no_safety, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			if (!is_table<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				constructor_handler handler{};
+				stack::check<basic_metatable>(base_t::lua_state(), -1, handler);
+			}
+#endif // Safety
+		}
+		basic_metatable(lua_nil_t r) noexcept : basic_metatable(detail::no_safety, r) {
+		}
+
+		template <typename Key, typename Value>
+		void set(Key&& key, Value&& value);
+
+		void unregister() {
+			using ustorage_base = u_detail::usertype_storage_base;
+
+			lua_State* L = this->lua_state();
+
+			auto pp = stack::push_pop(*this);
+			int top = lua_gettop(L);
+
+			stack_reference mt(L, -1);
+			stack::get_field(L, meta_function::gc_names, mt.stack_index());
+			if (type_of(L, -1) != type::table) {
+				return;
+			}
+			stack_reference gc_names_table(L, -1);
+			stack::get_field(L, meta_function::storage, mt.stack_index());
+			if (type_of(L, -1) != type::lightuserdata) {
+				return;
+			}
+			ustorage_base& base_storage = *static_cast<ustorage_base*>(stack::get<void*>(L, -1));
+			std::array<string_view, 6> registry_traits;
+			for (std::size_t i = 0; i < registry_traits.size(); ++i) {
+				u_detail::submetatable_type smt = static_cast<u_detail::submetatable_type>(i);
+				stack::get_field<false, true>(L, smt, gc_names_table.stack_index());
+				registry_traits[i] = stack::get<string_view>(L, -1);
+			}
+
+			// get the registry
+			stack_reference registry(L, raw_index(LUA_REGISTRYINDEX));
+			registry.push();
+			// eliminate all named entries for this usertype
+			// in the registry (luaL_newmetatable does
+			// [name] = new table
+			// in registry upon creation)
+			for (std::size_t i = 0; i < registry_traits.size(); ++i) {
+				u_detail::submetatable_type smt = static_cast<u_detail::submetatable_type>(i);
+				const string_view& gcmetakey = registry_traits[i];
+				if (smt == u_detail::submetatable_type::named) {
+					// use .data() to make it treat it like a c string,
+					// which it is...
+					stack::set_field<true>(L, gcmetakey.data(), lua_nil);
+				}
+				else {
+					// do not change the values in the registry: they need to be present
+					// no matter what, for safety's sake
+					//stack::set_field(L, gcmetakey, lua_nil, registry.stack_index());
+				}
+			}
+
+			// destroy all storage and tables
+			base_storage.clear();
+
+			// 6 strings from gc_names table,
+			// + 1 registry,
+			// + 1 gc_names table
+			// + 1 light userdata of storage
+			// + 1 registry
+			// 10 total, 4 left since popping off 6 gc_names tables
+			lua_settop(L, top);
+		}
+	};
+
+} // namespace sol
+
+// end of sol/metatable.hpp
+
+namespace sol {
+
+	template <typename T, typename base_type>
+	class basic_usertype : private basic_metatable<base_type> {
+	private:
+		using base_t = basic_metatable<base_type>;
+		using table_base_t = basic_table<base_type>;
+
+		template <typename>
+		friend class basic_metatable;
+
+		template <bool, typename>
+		friend class basic_table_core;
+
+		template <std::size_t... I, typename... Args>
+		void tuple_set(std::index_sequence<I...>, std::tuple<Args...>&& args) {
+			(void)args;
+			(void)detail::swallow{ 0,
+				(this->set(std::get<I * 2>(std::move(args)), std::get<I * 2 + 1>(std::move(args))), 0)... };
+		}
+
+	public:
+		using base_t::base_t;
+
+		using base_t::pop;
+		using base_t::push;
+		using base_t::lua_state;
+		using base_t::get;
+		using base_t::set_function;
+		using base_t::traverse_set;
+		using base_t::traverse_get;
+		using base_t::unregister;
+
+		template <typename Key, typename Value>
+		void set(Key&& key, Value&& value) {
+			optional<u_detail::usertype_storage<T>&> maybe_uts = u_detail::maybe_get_usertype_storage<T>(this->lua_state());
+			if (maybe_uts) {
+				u_detail::usertype_storage<T>& uts = *maybe_uts;
+				uts.set(this->lua_state(), std::forward<Key>(key), std::forward<Value>(value));
+			}
+			else {
+				using ValueU = meta::unqualified_t<Value>;
+				// cannot get metatable: try regular table set?
+				if constexpr (detail::is_non_factory_constructor_v<ValueU> || detail::is_policy_v<ValueU>) {
+					// tag constructors so we don't get destroyed by lack of info
+					table_base_t::set(std::forward<Key>(key), detail::tagged<T, Value>(std::forward<Value>(value)));
+				}
+				else {
+					table_base_t::set(std::forward<Key>(key), std::forward<Value>(value));
+				}
+			}
+		}
+
+		template <typename Key>
+		usertype_proxy<basic_usertype&, std::decay_t<Key>> operator[](Key&& key) {
+			return usertype_proxy<basic_usertype&, std::decay_t<Key>>(*this, std::forward<Key>(key));
+		}
+
+		template <typename Key>
+		usertype_proxy<const basic_usertype&, std::decay_t<Key>> operator[](Key&& key) const {
+			return usertype_proxy<const basic_usertype&, std::decay_t<Key>>(*this, std::forward<Key>(key));
+		}
+	};
+
+} // namespace sol
+
+// end of sol/usertype.hpp
+
+// beginning of sol/table.hpp
+
+// beginning of sol/lua_table.hpp
+
+namespace sol {
+
+	template <typename ref_t>
+	struct basic_lua_table : basic_table_core<false, ref_t> {
+	private:
+		using base_t = basic_table_core<false, ref_t>;
+
+		friend class state;
+		friend class state_view;
+
+	public:
+		using base_t::lua_state;
+
+		basic_lua_table() noexcept = default;
+		basic_lua_table(const basic_lua_table&) = default;
+		basic_lua_table(basic_lua_table&&) = default;
+		basic_lua_table& operator=(const basic_lua_table&) = default;
+		basic_lua_table& operator=(basic_lua_table&&) = default;
+		basic_lua_table(const stack_reference& r) : basic_lua_table(r.lua_state(), r.stack_index()) {
+		}
+		basic_lua_table(stack_reference&& r) : basic_lua_table(r.lua_state(), r.stack_index()) {
+		}
+		template <typename T, meta::enable_any<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_lua_table(lua_State* L, T&& r) : base_t(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler{};
+			stack::check<basic_lua_table>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		basic_lua_table(lua_State* L, const new_table& nt) : base_t(L, nt) {
+			if (!is_stack_based<meta::unqualified_t<ref_t>>::value) {
+				lua_pop(L, 1);
+			}
+		}
+		basic_lua_table(lua_State* L, int index = -1) : base_t(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			constructor_handler handler{};
+			stack::check<basic_lua_table>(L, index, handler);
+#endif // Safety
+		}
+		basic_lua_table(lua_State* L, ref_index index) : base_t(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler{};
+			stack::check<basic_lua_table>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		template <typename T,
+		     meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_lua_table>>, meta::neg<std::is_same<ref_t, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_lua_table(T&& r) noexcept : basic_lua_table(detail::no_safety, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			if (!is_table<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				constructor_handler handler{};
+				stack::check<basic_lua_table>(lua_state(), -1, handler);
+			}
+#endif // Safety
+		}
+		basic_lua_table(lua_nil_t r) noexcept : basic_lua_table(detail::no_safety, r) {
+		}
+	};
+
+}
+
+// end of sol/lua_table.hpp
+
+namespace sol {
+	typedef table_core<false> table;
+
+	template <bool is_global, typename base_type>
+	template <typename Class, typename Key>
+	usertype<Class> basic_table_core<is_global, base_type>::new_usertype(Key&& key) {
+		automagic_enrollments enrollments;
+		return this->new_usertype<Class>(std::forward<Key>(key), std::move(enrollments));
+	}
+
+	template <bool is_global, typename base_type>
+	template <typename Class, typename Key>
+	usertype<Class> basic_table_core<is_global, base_type>::new_usertype(Key&& key, automagic_enrollments enrollments) {
+		int mt_index = u_detail::register_usertype<Class>(this->lua_state(), std::move(enrollments));
+		usertype<Class> mt(this->lua_state(), -mt_index);
+		lua_pop(this->lua_state(), 1);
+		set(std::forward<Key>(key), mt);
+		return mt;
+	}
+
+	template <bool is_global, typename base_type>
+	template <typename Class, typename Key, typename Arg, typename... Args, typename>
+	usertype<Class> basic_table_core<is_global, base_type>::new_usertype(Key&& key, Arg&& arg, Args&&... args) {
+		automagic_enrollments enrollments;
+		enrollments.default_constructor = !detail::any_is_constructor_v<Arg, Args...>;
+		enrollments.destructor = !detail::any_is_destructor_v<Arg, Args...>;
+		usertype<Class> ut = this->new_usertype<Class>(std::forward<Key>(key), std::move(enrollments));
+		static_assert(sizeof...(Args) % 2 == static_cast<std::size_t>(!detail::any_is_constructor_v<Arg>), 
+			"you must pass an even number of arguments to new_usertype after first passing a constructor");
+		if constexpr (detail::any_is_constructor_v<Arg>) {
+			ut.set(meta_function::construct, std::forward<Arg>(arg));
+			ut.tuple_set(std::make_index_sequence<(sizeof...(Args)) / 2>(), std::forward_as_tuple(std::forward<Args>(args)...));
+		}
+		else {
+			ut.tuple_set(std::make_index_sequence<(sizeof...(Args) + 1) / 2>(), std::forward_as_tuple(std::forward<Arg>(arg), std::forward<Args>(args)...));
+		}
+		return ut;
+	}
+
+	template <typename base_type>
+	template <typename Key, typename Value>
+	void basic_metatable<base_type>::set(Key&& key, Value&& value) {
+		this->push();
+		lua_State* L = this->lua_state();
+		int target = lua_gettop(L);
+		optional<u_detail::usertype_storage_base&> maybe_uts = u_detail::maybe_get_usertype_storage_base(L, target);
+		lua_pop(L, 1);
+		if (maybe_uts) {
+			u_detail::usertype_storage_base& uts = *maybe_uts;
+			uts.set(L, std::forward<Key>(key), std::forward<Value>(value));
+		}
+		else {
+			base_t::set(std::forward<Key>(key), std::forward<Value>(value));
+		}
+	}
+
+	namespace stack {
+		template <>
+		struct unqualified_getter<metatable_key_t> {
+			static table get(lua_State* L, int index = -1) {
+				if (lua_getmetatable(L, index) == 0) {
+					return table(L, ref_index(LUA_REFNIL));
+				}
+				return table(L, -1);
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/table.hpp
+
+// beginning of sol/state.hpp
+
+// beginning of sol/state_view.hpp
+
+// beginning of sol/environment.hpp
+
+namespace sol {
+
+	template <typename base_type>
+	struct basic_environment : basic_table<base_type> {
+	private:
+		typedef basic_table<base_type> base_t;
+
+	public:
+		using base_t::lua_state;
+
+		basic_environment() noexcept = default;
+		basic_environment(const basic_environment&) = default;
+		basic_environment(basic_environment&&) = default;
+		basic_environment& operator=(const basic_environment&) = default;
+		basic_environment& operator=(basic_environment&&) = default;
+		basic_environment(const stack_reference& r) : basic_environment(r.lua_state(), r.stack_index()) {
+		}
+		basic_environment(stack_reference&& r) : basic_environment(r.lua_state(), r.stack_index()) {
+		}
+
+		basic_environment(lua_State* L, new_table nt) : base_t(L, std::move(nt)) {
+		}
+		template <bool b>
+		basic_environment(lua_State* L, new_table t, const basic_reference<b>& fallback) : basic_environment(L, std::move(t)) {
+			stack_table mt(L, new_table(0, 1));
+			mt.set(meta_function::index, fallback);
+			this->set(metatable_key, mt);
+			mt.pop();
+		}
+
+		basic_environment(env_key_t, const stack_reference& extraction_target)
+		: base_t(detail::no_safety, extraction_target.lua_state(), (stack::push_environment_of(extraction_target), -1)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			constructor_handler handler {};
+			stack::check<env_key_t>(this->lua_state(), -1, handler);
+#endif // Safety
+			lua_pop(this->lua_state(), 2);
+		}
+		template <bool b>
+		basic_environment(env_key_t, const basic_reference<b>& extraction_target)
+		: base_t(detail::no_safety, extraction_target.lua_state(), (stack::push_environment_of(extraction_target), -1)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			constructor_handler handler {};
+			stack::check<env_key_t>(this->lua_state(), -1, handler);
+#endif // Safety
+			lua_pop(this->lua_state(), 2);
+		}
+		basic_environment(lua_State* L, int index = -1) : base_t(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			constructor_handler handler {};
+			stack::check<basic_environment>(L, index, handler);
+#endif // Safety
+		}
+		basic_environment(lua_State* L, ref_index index) : base_t(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_environment>(L, -1, handler);
+#endif // Safety
+		}
+		template <typename T,
+		     meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_environment>>, meta::neg<std::is_same<base_type, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_environment(T&& r) noexcept : base_t(detail::no_safety, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			if (!is_environment<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				constructor_handler handler {};
+				stack::check<basic_environment>(lua_state(), -1, handler);
+			}
+#endif // Safety
+		}
+		basic_environment(lua_nil_t r) noexcept : base_t(detail::no_safety, r) {
+		}
+
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_environment(lua_State* L, T&& r) noexcept : base_t(detail::no_safety, L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			if (!is_environment<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				constructor_handler handler {};
+				stack::check<basic_environment>(lua_state(), -1, handler);
+			}
+#endif // Safety
+		}
+
+		template <typename T>
+		void set_on(const T& target) const {
+			lua_State* L = target.lua_state();
+			auto pp = stack::push_pop(target);
+#if SOL_LUA_VESION_I_ < 502
+			// Use lua_setfenv
+			this->push();
+			lua_setfenv(L, -2);
+#else
+			// Use upvalues as explained in Lua 5.2 and beyond's manual
+			this->push();
+			const char* name = lua_setupvalue(L, -2, 1);
+			if (name == nullptr) {
+				this->pop();
+			}
+#endif
+		}
+	};
+
+	template <typename T, typename E>
+	void set_environment(const basic_environment<E>& env, const T& target) {
+		env.set_on(target);
+	}
+
+	template <typename E = reference, typename T>
+	basic_environment<E> get_environment(const T& target) {
+		lua_State* L = target.lua_state();
+		auto pp = stack::pop_n(L, stack::push_environment_of(target));
+		return basic_environment<E>(L, -1);
+	}
+
+	struct this_environment {
+		optional<environment> env;
+
+		this_environment() : env(nullopt) {
+		}
+		this_environment(environment e) : env(std::move(e)) {
+		}
+		this_environment(const this_environment&) = default;
+		this_environment(this_environment&&) = default;
+		this_environment& operator=(const this_environment&) = default;
+		this_environment& operator=(this_environment&&) = default;
+
+		explicit operator bool() const {
+			return static_cast<bool>(env);
+		}
+
+		operator optional<environment> &() {
+			return env;
+		}
+
+		operator const optional<environment> &() const {
+			return env;
+		}
+
+		operator environment&() {
+			return env.value();
+		}
+
+		operator const environment&() const {
+			return env.value();
+		}
+	};
+
+	namespace stack {
+		template <>
+		struct unqualified_getter<env_key_t> {
+			static environment get(lua_State* L, int index, record& tracking) {
+				tracking.use(1);
+				return get_environment(stack_reference(L, raw_index(index)));
+			}
+		};
+
+		template <>
+		struct unqualified_getter<this_environment> {
+			static this_environment get(lua_State* L, int, record& tracking) {
+				tracking.use(0);
+				lua_Debug info;
+				// Level 0 means current function (this C function, which may or may not be useful for us?)
+				// Level 1 means next call frame up the stack. (Can be nothing if function called directly from C++ with lua_p/call)
+				int pre_stack_size = lua_gettop(L);
+				if (lua_getstack(L, 1, &info) != 1) {
+					if (lua_getstack(L, 0, &info) != 1) {
+						lua_settop(L, pre_stack_size);
+						return this_environment();
+					}
+				}
+				if (lua_getinfo(L, "f", &info) == 0) {
+					lua_settop(L, pre_stack_size);
+					return this_environment();
+				}
+
+				stack_reference f(L, -1);
+				environment env(env_key, f);
+				if (!env.valid()) {
+					lua_settop(L, pre_stack_size);
+					return this_environment();
+				}
+				return this_environment(std::move(env));
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/environment.hpp
+
+// beginning of sol/load_result.hpp
+
+#include <cstdint>
+
+namespace sol {
+	struct load_result : public proxy_base<load_result> {
+	private:
+		lua_State* L;
+		int index;
+		int returncount;
+		int popcount;
+		load_status err;
+
+	public:
+		load_result() noexcept = default;
+		load_result(lua_State* Ls, int stackindex = -1, int retnum = 0, int popnum = 0, load_status lerr = load_status::ok) noexcept
+		: L(Ls), index(stackindex), returncount(retnum), popcount(popnum), err(lerr) {
+		}
+
+		// We do not want anyone to copy these around willy-nilly
+		// Will likely break people, but also will probably get rid of quiet bugs that have
+		// been lurking. (E.g., Vanilla Lua will just quietly discard over-pops and under-pops:
+		// LuaJIT and other Lua engines will implode and segfault at random later times.)
+		load_result(const load_result&) = delete;
+		load_result& operator=(const load_result&) = delete;
+
+		load_result(load_result&& o) noexcept : L(o.L), index(o.index), returncount(o.returncount), popcount(o.popcount), err(o.err) {
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but we will be thorough
+			o.L = nullptr;
+			o.index = 0;
+			o.returncount = 0;
+			o.popcount = 0;
+			o.err = load_status::syntax;
+		}
+		load_result& operator=(load_result&& o) noexcept {
+			L = o.L;
+			index = o.index;
+			returncount = o.returncount;
+			popcount = o.popcount;
+			err = o.err;
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but we will be thorough
+			o.L = nullptr;
+			o.index = 0;
+			o.returncount = 0;
+			o.popcount = 0;
+			o.err = load_status::syntax;
+			return *this;
+		}
+
+		load_status status() const noexcept {
+			return err;
+		}
+
+		bool valid() const noexcept {
+			return status() == load_status::ok;
+		}
+
+		template <typename T>
+		T get() const {
+			using UT = meta::unqualified_t<T>;
+			if constexpr (meta::is_optional_v<UT>) {
+				using ValueType = typename UT::value_type;
+				if constexpr (std::is_same_v<ValueType, error>) {
+					if (valid()) {
+						return UT(nullopt);
+					}
+					return error(detail::direct_error, stack::get<std::string>(L, index));
+				}
+				else {
+					if (!valid()) {
+						return UT(nullopt);
+					}
+					return stack::get<UT>(L, index);
+				}
+			}
+			else {
+				if constexpr (std::is_same_v<T, error>) {
+#if SOL_IS_ON(SOL_SAFE_PROXIES_I_)
+					if (valid()) {
+						type_panic_c_str(L, index, type_of(L, index), type::none, "expecting an error type (a string, from Lua)");
+					}
+#endif // Check proxy type's safety
+					return error(detail::direct_error, stack::get<std::string>(L, index));
+				}
+				else {
+#if SOL_IS_ON(SOL_SAFE_PROXIES_I_)
+					if (!valid()) {
+						type_panic_c_str(L, index, type_of(L, index), type::none);
+					}
+#endif // Check proxy type's safety
+					return stack::get<T>(L, index);
+				}
+			}
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) call(Args&&... args) {
+#if !defined(__clang__) && defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 191200000
+			// MSVC is ass sometimes
+			return get<protected_function>().call<Ret...>(std::forward<Args>(args)...);
+#else
+			return get<protected_function>().template call<Ret...>(std::forward<Args>(args)...);
+#endif
+		}
+
+		template <typename... Args>
+		decltype(auto) operator()(Args&&... args) {
+			return call<>(std::forward<Args>(args)...);
+		}
+
+		lua_State* lua_state() const noexcept {
+			return L;
+		};
+		int stack_index() const noexcept {
+			return index;
+		};
+
+		~load_result() {
+			stack::remove(L, index, popcount);
+		}
+	};
+} // namespace sol
+
+// end of sol/load_result.hpp
+
+// beginning of sol/state_handling.hpp
+
+// beginning of sol/lua_value.hpp
+
+namespace sol {
+	struct lua_value {
+	public:
+		struct arr : detail::ebco<std::initializer_list<lua_value>> {
+		private:
+			using base_t = detail::ebco<std::initializer_list<lua_value>>;
+
+		public:
+			using base_t::base_t;
+		};
+
+	private:
+		template <typename T>
+		using is_reference_or_lua_value_init_list
+		     = meta::any<meta::is_specialization_of<T, std::initializer_list>, std::is_same<T, reference>, std::is_same<T, arr>>;
+
+		template <typename T>
+		using is_lua_value_single_constructible = meta::any<std::is_same<T, lua_value>, is_reference_or_lua_value_init_list<T>>;
+
+		static lua_State*& thread_local_lua_state() {
+#if SOL_IS_ON(SOL_USE_THREAD_LOCAL_I_)
+			static thread_local lua_State* L = nullptr;
+#else
+			static lua_State* L = nullptr;
+#endif
+			return L;
+		}
+
+		reference ref_value;
+
+	public:
+		static void set_lua_state(lua_State* L) {
+			thread_local_lua_state() = L;
+		}
+
+		template <typename T, meta::disable<is_reference_or_lua_value_init_list<meta::unqualified_t<T>>> = meta::enabler>
+		lua_value(lua_State* L_, T&& value) : lua_value(((set_lua_state(L_)), std::forward<T>(value))) {
+		}
+
+		template <typename T, meta::disable<is_lua_value_single_constructible<meta::unqualified_t<T>>> = meta::enabler>
+		lua_value(T&& value) : ref_value(make_reference(thread_local_lua_state(), std::forward<T>(value))) {
+		}
+
+		lua_value(lua_State* L_, std::initializer_list<std::pair<lua_value, lua_value>> il)
+		: lua_value([&L_, &il]() {
+			set_lua_state(L_);
+			return std::move(il);
+		}()) {
+		}
+
+		lua_value(std::initializer_list<std::pair<lua_value, lua_value>> il) : ref_value(make_reference(thread_local_lua_state(), std::move(il))) {
+		}
+
+		lua_value(lua_State* L_, arr il)
+		: lua_value([&L_, &il]() {
+			set_lua_state(L_);
+			return std::move(il);
+		}()) {
+		}
+
+		lua_value(arr il) : ref_value(make_reference(thread_local_lua_state(), std::move(il.value()))) {
+		}
+
+		lua_value(lua_State* L_, reference r)
+		: lua_value([&L_, &r]() {
+			set_lua_state(L_);
+			return std::move(r);
+		}()) {
+		}
+
+		lua_value(reference r) : ref_value(std::move(r)) {
+		}
+
+		lua_value(const lua_value&) noexcept = default;
+		lua_value(lua_value&&) = default;
+		lua_value& operator=(const lua_value&) = default;
+		lua_value& operator=(lua_value&&) = default;
+
+		const reference& value() const& {
+			return ref_value;
+		}
+
+		reference& value() & {
+			return ref_value;
+		}
+
+		reference&& value() && {
+			return std::move(ref_value);
+		}
+
+		template <typename T>
+		decltype(auto) as() const {
+			ref_value.push();
+			return stack::pop<T>(ref_value.lua_state());
+		}
+
+		template <typename T>
+		bool is() const {
+			int r = ref_value.registry_index();
+			if (r == LUA_REFNIL)
+				return meta::any_same<meta::unqualified_t<T>, lua_nil_t, nullopt_t, std::nullptr_t>::value ? true : false;
+			if (r == LUA_NOREF)
+				return false;
+			auto pp = stack::push_pop(ref_value);
+			return stack::check<T>(ref_value.lua_state(), -1, no_panic);
+		}
+	};
+
+	using array_value = typename lua_value::arr;
+
+	namespace stack {
+		template <>
+		struct unqualified_pusher<lua_value> {
+			static int push(lua_State* L, const lua_value& lv) {
+				return stack::push(L, lv.value());
+			}
+
+			static int push(lua_State* L, lua_value&& lv) {
+				return stack::push(L, std::move(lv).value());
+			}
+		};
+
+		template <>
+		struct unqualified_getter<lua_value> {
+			static lua_value get(lua_State* L, int index, record& tracking) {
+				return lua_value(L, stack::get<reference>(L, index, tracking));
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/lua_value.hpp
+
+#if SOL_IS_ON(SOL_PRINT_ERRORS_I_)
+#include <iostream>
+#endif
+
+namespace sol {
+	inline void register_main_thread(lua_State* L) {
+#if SOL_LUA_VESION_I_ < 502
+		if (L == nullptr) {
+			lua_pushnil(L);
+			lua_setglobal(L, detail::default_main_thread_name());
+			return;
+		}
+		lua_pushthread(L);
+		lua_setglobal(L, detail::default_main_thread_name());
+#else
+		(void)L;
+#endif
+	}
+
+	inline int default_at_panic(lua_State* L) {
+#if SOL_IS_OFF(SOL_EXCEPTIONS_I_)
+		(void)L;
+		return -1;
+#else
+		size_t messagesize;
+		const char* message = lua_tolstring(L, -1, &messagesize);
+		if (message) {
+			std::string err(message, messagesize);
+			lua_settop(L, 0);
+#if SOL_IS_ON(SOL_PRINT_ERRORS_I_)
+			std::cerr << "[sol3] An error occurred and panic has been invoked: ";
+			std::cerr << err;
+			std::cerr << std::endl;
+#endif
+			throw error(err);
+		}
+		lua_settop(L, 0);
+		throw error(std::string("An unexpected error occurred and panic has been invoked"));
+#endif // Printing Errors
+	}
+
+	inline int default_traceback_error_handler(lua_State* L) {
+		std::string msg = "An unknown error has triggered the default error handler";
+		optional<string_view> maybetopmsg = stack::unqualified_check_get<string_view>(L, 1, no_panic);
+		if (maybetopmsg) {
+			const string_view& topmsg = maybetopmsg.value();
+			msg.assign(topmsg.data(), topmsg.size());
+		}
+		luaL_traceback(L, L, msg.c_str(), 1);
+		optional<string_view> maybetraceback = stack::unqualified_check_get<string_view>(L, -1, no_panic);
+		if (maybetraceback) {
+			const string_view& traceback = maybetraceback.value();
+			msg.assign(traceback.data(), traceback.size());
+		}
+#if SOL_IS_ON(SOL_PRINT_ERRORS_I_)
+		// std::cerr << "[sol3] An error occurred and was caught in traceback: ";
+		// std::cerr << msg;
+		// std::cerr << std::endl;
+#endif // Printing
+		return stack::push(L, msg);
+	}
+
+	inline void set_default_state(lua_State* L, lua_CFunction panic_function = &default_at_panic,
+	     lua_CFunction traceback_function = c_call<decltype(&default_traceback_error_handler), &default_traceback_error_handler>,
+	     exception_handler_function exf = detail::default_exception_handler) {
+		lua_atpanic(L, panic_function);
+		protected_function::set_default_handler(object(L, in_place, traceback_function));
+		set_default_exception_handler(L, exf);
+		register_main_thread(L);
+		stack::luajit_exception_handler(L);
+		lua_value::set_lua_state(L);
+	}
+
+	inline std::size_t total_memory_used(lua_State* L) {
+		std::size_t kb = lua_gc(L, LUA_GCCOUNT, 0);
+		kb *= 1024;
+		kb += lua_gc(L, LUA_GCCOUNTB, 0);
+		return kb;
+	}
+
+	inline protected_function_result script_pass_on_error(lua_State*, protected_function_result result) {
+		return result;
+	}
+
+	inline protected_function_result script_throw_on_error(lua_State* L, protected_function_result result) {
+		type t = type_of(L, result.stack_index());
+		std::string err = "sol: ";
+		err += to_string(result.status());
+		err += " error";
+#if SOL_IS_ON(SOL_EXCEPTIONS_I_)
+		std::exception_ptr eptr = std::current_exception();
+		if (eptr) {
+			err += " with a ";
+			try {
+				std::rethrow_exception(eptr);
+			}
+			catch (const std::exception& ex) {
+				err += "std::exception -- ";
+				err.append(ex.what());
+			}
+			catch (const std::string& message) {
+				err += "thrown message -- ";
+				err.append(message);
+			}
+			catch (const char* message) {
+				err += "thrown message -- ";
+				err.append(message);
+			}
+			catch (...) {
+				err.append("thrown but unknown type, cannot serialize into error message");
+			}
+		}
+#endif // serialize exception information if possible
+		if (t == type::string) {
+			err += ": ";
+			string_view serr = stack::unqualified_get<string_view>(L, result.stack_index());
+			err.append(serr.data(), serr.size());
+		}
+#if SOL_IS_ON(SOL_PRINT_ERRORS_I_)
+		std::cerr << "[sol3] An error occurred and has been passed to an error handler: ";
+		std::cerr << err;
+		std::cerr << std::endl;
+#endif
+		// replacing information of stack error into pfr
+		int target = result.stack_index();
+		if (result.pop_count() > 0) {
+			stack::remove(L, target, result.pop_count());
+		}
+		stack::push(L, err);
+		int top = lua_gettop(L);
+		int towards = top - target;
+		if (towards != 0) {
+			lua_rotate(L, top, towards);
+		}
+#if SOL_IS_OFF(SOL_EXCEPTIONS_I_)
+		return result;
+#else
+		// just throw our error
+		throw error(detail::direct_error, err);
+#endif // If exceptions are allowed
+	}
+
+	inline protected_function_result script_default_on_error(lua_State* L, protected_function_result pfr) {
+#if SOL_IS_ON(SOL_DEFAULT_PASS_ON_ERROR_I_)
+		return script_pass_on_error(L, std::move(pfr));
+#else
+		return script_throw_on_error(L, std::move(pfr));
+#endif
+	}
+
+	namespace stack {
+		inline error get_traceback_or_errors(lua_State* L) {
+			int p = default_traceback_error_handler(L);
+			sol::error err = stack::get<sol::error>(L, -p);
+			lua_pop(L, p);
+			return err;
+		}
+	} // namespace stack
+} // namespace sol
+
+// end of sol/state_handling.hpp
+
+#include <memory>
+#include <cstddef>
+
+namespace sol {
+
+	class state_view {
+	private:
+		lua_State* L;
+		table reg;
+		global_table global;
+
+		optional<object> is_loaded_package(const std::string& key) {
+			auto loaded = reg.traverse_get<optional<object>>("_LOADED", key);
+			bool is53mod = loaded && !(loaded->is<bool>() && !loaded->as<bool>());
+			if (is53mod)
+				return loaded;
+#if SOL_LUA_VESION_I_ <= 501
+			auto loaded51 = global.traverse_get<optional<object>>("package", "loaded", key);
+			bool is51mod = loaded51 && !(loaded51->is<bool>() && !loaded51->as<bool>());
+			if (is51mod)
+				return loaded51;
+#endif
+			return nullopt;
+		}
+
+		template <typename T>
+		void ensure_package(const std::string& key, T&& sr) {
+#if SOL_LUA_VESION_I_ <= 501
+			auto pkg = global["package"];
+			if (!pkg.valid()) {
+				pkg = create_table_with("loaded", create_table_with(key, sr));
+			}
+			else {
+				auto ld = pkg["loaded"];
+				if (!ld.valid()) {
+					ld = create_table_with(key, sr);
+				}
+				else {
+					ld[key] = sr;
+				}
+			}
+#endif
+			auto loaded = reg["_LOADED"];
+			if (!loaded.valid()) {
+				loaded = create_table_with(key, sr);
+			}
+			else {
+				loaded[key] = sr;
+			}
+		}
+
+		template <typename Fx>
+		object require_core(const std::string& key, Fx&& action, bool create_global = true) {
+			optional<object> loaded = is_loaded_package(key);
+			if (loaded && loaded->valid())
+				return std::move(*loaded);
+			action();
+			stack_reference sr(L, -1);
+			if (create_global)
+				set(key, sr);
+			ensure_package(key, sr);
+			return stack::pop<object>(L);
+		}
+
+	public:
+		using iterator = typename global_table::iterator;
+		using const_iterator = typename global_table::const_iterator;
+
+		state_view(lua_State* Ls) : L(Ls), reg(Ls, LUA_REGISTRYINDEX), global(Ls, detail::global_) {
+		}
+
+		state_view(this_state Ls) : state_view(Ls.L) {
+		}
+
+		lua_State* lua_state() const {
+			return L;
+		}
+
+		template <typename... Args>
+		void open_libraries(Args&&... args) {
+			static_assert(meta::all_same<lib, meta::unqualified_t<Args>...>::value, "all types must be libraries");
+			if constexpr (sizeof...(args) == 0) {
+				luaL_openlibs(L);
+				return;
+			}
+			else {
+				lib libraries[1 + sizeof...(args)] = { lib::count, std::forward<Args>(args)... };
+
+				for (auto&& library : libraries) {
+					switch (library) {
+#if SOL_LUA_VESION_I_ <= 501 && defined(SOL_LUAJIT)
+					case lib::coroutine:
+#endif // luajit opens coroutine base stuff
+					case lib::base:
+						luaL_requiref(L, "base", luaopen_base, 1);
+						lua_pop(L, 1);
+						break;
+					case lib::package:
+						luaL_requiref(L, "package", luaopen_package, 1);
+						lua_pop(L, 1);
+						break;
+#if !defined(SOL_LUAJIT)
+					case lib::coroutine:
+#if SOL_LUA_VESION_I_ > 501
+						luaL_requiref(L, "coroutine", luaopen_coroutine, 1);
+						lua_pop(L, 1);
+#endif // Lua 5.2+ only
+						break;
+#endif // Not LuaJIT - comes builtin
+					case lib::string:
+						luaL_requiref(L, "string", luaopen_string, 1);
+						lua_pop(L, 1);
+						break;
+					case lib::table:
+						luaL_requiref(L, "table", luaopen_table, 1);
+						lua_pop(L, 1);
+						break;
+					case lib::math:
+						luaL_requiref(L, "math", luaopen_math, 1);
+						lua_pop(L, 1);
+						break;
+					case lib::bit32:
+#ifdef SOL_LUAJIT
+						luaL_requiref(L, "bit32", luaopen_bit, 1);
+						lua_pop(L, 1);
+#elif (SOL_LUA_VESION_I_ == 502) || defined(LUA_COMPAT_BITLIB) || defined(LUA_COMPAT_5_2)
+						luaL_requiref(L, "bit32", luaopen_bit32, 1);
+						lua_pop(L, 1);
+#else
+#endif // Lua 5.2 only (deprecated in 5.3 (503)) (Can be turned on with Compat flags)
+						break;
+					case lib::io:
+						luaL_requiref(L, "io", luaopen_io, 1);
+						lua_pop(L, 1);
+						break;
+					case lib::os:
+						luaL_requiref(L, "os", luaopen_os, 1);
+						lua_pop(L, 1);
+						break;
+					case lib::debug:
+						luaL_requiref(L, "debug", luaopen_debug, 1);
+						lua_pop(L, 1);
+						break;
+					case lib::utf8:
+#if SOL_LUA_VESION_I_ > 502 && !defined(SOL_LUAJIT)
+						luaL_requiref(L, "utf8", luaopen_utf8, 1);
+						lua_pop(L, 1);
+#endif // Lua 5.3+ only
+						break;
+					case lib::ffi:
+#ifdef SOL_LUAJIT
+						luaL_requiref(L, "ffi", luaopen_ffi, 1);
+						lua_pop(L, 1);
+#endif // LuaJIT only
+						break;
+					case lib::jit:
+#ifdef SOL_LUAJIT
+						luaL_requiref(L, "jit", luaopen_jit, 0);
+						lua_pop(L, 1);
+#endif // LuaJIT Only
+						break;
+					case lib::count:
+					default:
+						break;
+					}
+				}
+			}
+		}
+
+		object require(const std::string& key, lua_CFunction open_function, bool create_global = true) {
+			luaL_requiref(L, key.c_str(), open_function, create_global ? 1 : 0);
+			return stack::pop<object>(L);
+		}
+
+		object require_script(const std::string& key, const string_view& code, bool create_global = true,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			auto action = [this, &code, &chunkname, &mode]() { stack::script(L, code, chunkname, mode); };
+			return require_core(key, action, create_global);
+		}
+
+		object require_file(const std::string& key, const std::string& filename, bool create_global = true, load_mode mode = load_mode::any) {
+			auto action = [this, &filename, &mode]() { stack::script_file(L, filename, mode); };
+			return require_core(key, action, create_global);
+		}
+
+		void clear_package_loaders() {
+			optional<table> maybe_package = this->global["package"];
+			if (!maybe_package) {
+				// package lib wasn't opened
+				// open package lib
+				return;
+			}
+			table& package = *maybe_package;
+			// yay for version differences...
+			// one day Lua 5.1 will die a peaceful death
+			// and its old bones will find blissful rest
+			auto loaders_proxy = package
+#if SOL_LUA_VESION_I_ < 502
+			     ["loaders"]
+#else
+			     ["searchers"]
+#endif
+			     ;
+			if (!loaders_proxy.valid()) {
+				// nothing to clear
+				return;
+			}
+			// we need to create the table for loaders
+			// table does not exist, so create and move forward
+			loaders_proxy = new_table(1, 0);
+		}
+
+		template <typename Fx>
+		void add_package_loader(Fx&& fx, bool clear_all_package_loaders = false) {
+			optional<table> maybe_package = this->global["package"];
+			if (!maybe_package) {
+				// package lib wasn't opened
+				// open package lib
+				return;
+			}
+			table& package = *maybe_package;
+			// yay for version differences...
+			// one day Lua 5.1 will die a peaceful death
+			// and its old bones will find blissful rest
+			auto loaders_proxy = package
+#if SOL_LUA_VESION_I_ < 502
+			     ["loaders"]
+#else
+			     ["searchers"]
+#endif
+			     ;
+			bool make_new_table = clear_all_package_loaders || !loaders_proxy.valid();
+			if (make_new_table) {
+				// we need to create the table for loaders
+				// table does not exist, so create and move forward
+				loaders_proxy = new_table(1, 0);
+			}
+			optional<table> maybe_loaders = loaders_proxy;
+			if (!maybe_loaders) {
+				// loaders/searches
+				// thing exists in package, but it
+				// ain't a table or a table-alike...!
+				return;
+			}
+			table loaders = loaders_proxy;
+			loaders.add(std::forward<Fx>(fx));
+		}
+
+		template <typename E>
+		protected_function_result do_reader(lua_Reader reader, void* data, const basic_environment<E>& env,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name("lua_Reader", chunkname, basechunkname);
+			load_status x = static_cast<load_status>(lua_load(L, reader, data, chunknametarget, to_string(mode).c_str()));
+			if (x != load_status::ok) {
+				return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
+			}
+			stack_aligned_protected_function pf(L, -1);
+			set_environment(env, pf);
+			return pf();
+		}
+
+		protected_function_result do_reader(
+		     lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name("lua_Reader", chunkname, basechunkname);
+			load_status x = static_cast<load_status>(lua_load(L, reader, data, chunknametarget, to_string(mode).c_str()));
+			if (x != load_status::ok) {
+				return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
+			}
+			stack_aligned_protected_function pf(L, -1);
+			return pf();
+		}
+
+		template <typename E>
+		protected_function_result do_string(const string_view& code, const basic_environment<E>& env,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name(code, chunkname, basechunkname);
+			load_status x = static_cast<load_status>(luaL_loadbufferx(L, code.data(), code.size(), chunknametarget, to_string(mode).c_str()));
+			if (x != load_status::ok) {
+				return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
+			}
+			stack_aligned_protected_function pf(L, -1);
+			set_environment(env, pf);
+			return pf();
+		}
+
+		protected_function_result do_string(
+		     const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name(code, chunkname, basechunkname);
+			load_status x = static_cast<load_status>(luaL_loadbufferx(L, code.data(), code.size(), chunknametarget, to_string(mode).c_str()));
+			if (x != load_status::ok) {
+				return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
+			}
+			stack_aligned_protected_function pf(L, -1);
+			return pf();
+		}
+
+		template <typename E>
+		protected_function_result do_file(const std::string& filename, const basic_environment<E>& env, load_mode mode = load_mode::any) {
+			load_status x = static_cast<load_status>(luaL_loadfilex(L, filename.c_str(), to_string(mode).c_str()));
+			if (x != load_status::ok) {
+				return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
+			}
+			stack_aligned_protected_function pf(L, -1);
+			set_environment(env, pf);
+			return pf();
+		}
+
+		protected_function_result do_file(const std::string& filename, load_mode mode = load_mode::any) {
+			load_status x = static_cast<load_status>(luaL_loadfilex(L, filename.c_str(), to_string(mode).c_str()));
+			if (x != load_status::ok) {
+				return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
+			}
+			stack_aligned_protected_function pf(L, -1);
+			return pf();
+		}
+
+		template <typename Fx,
+		     meta::disable_any<meta::is_string_constructible<meta::unqualified_t<Fx>>,
+		          meta::is_specialization_of<meta::unqualified_t<Fx>, basic_environment>> = meta::enabler>
+		protected_function_result safe_script(
+		     lua_Reader reader, void* data, Fx&& on_error, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			protected_function_result pfr = do_reader(reader, data, chunkname, mode);
+			if (!pfr.valid()) {
+				return on_error(L, std::move(pfr));
+			}
+			return pfr;
+		}
+
+		protected_function_result safe_script(
+		     lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(reader, data, script_default_on_error, chunkname, mode);
+		}
+
+		template <typename Fx,
+		     meta::disable_any<meta::is_string_constructible<meta::unqualified_t<Fx>>,
+		          meta::is_specialization_of<meta::unqualified_t<Fx>, basic_environment>> = meta::enabler>
+		protected_function_result safe_script(
+		     const string_view& code, Fx&& on_error, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			protected_function_result pfr = do_string(code, chunkname, mode);
+			if (!pfr.valid()) {
+				return on_error(L, std::move(pfr));
+			}
+			return pfr;
+		}
+
+		template <typename Fx, typename E>
+		protected_function_result safe_script(const string_view& code, const basic_environment<E>& env, Fx&& on_error,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			protected_function_result pfr = do_string(code, env, chunkname, mode);
+			if (!pfr.valid()) {
+				return on_error(L, std::move(pfr));
+			}
+			return pfr;
+		}
+
+		template <typename E>
+		protected_function_result safe_script(const string_view& code, const basic_environment<E>& env,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(code, env, script_default_on_error, chunkname, mode);
+		}
+
+		protected_function_result safe_script(
+		     const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(code, script_default_on_error, chunkname, mode);
+		}
+
+		template <typename Fx,
+		     meta::disable_any<meta::is_string_constructible<meta::unqualified_t<Fx>>,
+		          meta::is_specialization_of<meta::unqualified_t<Fx>, basic_environment>> = meta::enabler>
+		protected_function_result safe_script_file(const std::string& filename, Fx&& on_error, load_mode mode = load_mode::any) {
+			protected_function_result pfr = do_file(filename, mode);
+			if (!pfr.valid()) {
+				return on_error(L, std::move(pfr));
+			}
+			return pfr;
+		}
+
+		template <typename Fx, typename E>
+		protected_function_result safe_script_file(
+		     const std::string& filename, const basic_environment<E>& env, Fx&& on_error, load_mode mode = load_mode::any) {
+			protected_function_result pfr = do_file(filename, env, mode);
+			if (!pfr.valid()) {
+				return on_error(L, std::move(pfr));
+			}
+			return pfr;
+		}
+
+		template <typename E>
+		protected_function_result safe_script_file(const std::string& filename, const basic_environment<E>& env, load_mode mode = load_mode::any) {
+			return safe_script_file(filename, env, script_default_on_error, mode);
+		}
+
+		protected_function_result safe_script_file(const std::string& filename, load_mode mode = load_mode::any) {
+			return safe_script_file(filename, script_default_on_error, mode);
+		}
+
+		template <typename E>
+		unsafe_function_result unsafe_script(lua_Reader reader, void* data, const basic_environment<E>& env,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name("lua_Reader", chunkname, basechunkname);
+			int index = lua_gettop(L);
+			if (lua_load(L, reader, data, chunknametarget, to_string(mode).c_str())) {
+				lua_error(L);
+			}
+			set_environment(env, stack_reference(L, raw_index(index + 1)));
+			if (lua_pcall(L, 0, LUA_MULTRET, 0)) {
+				lua_error(L);
+			}
+			int postindex = lua_gettop(L);
+			int returns = postindex - index;
+			return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
+		}
+
+		unsafe_function_result unsafe_script(
+		     lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			int index = lua_gettop(L);
+			stack::script(L, reader, data, chunkname, mode);
+			int postindex = lua_gettop(L);
+			int returns = postindex - index;
+			return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
+		}
+
+		template <typename E>
+		unsafe_function_result unsafe_script(const string_view& code, const basic_environment<E>& env,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name(code, chunkname, basechunkname);
+			int index = lua_gettop(L);
+			if (luaL_loadbufferx(L, code.data(), code.size(), chunknametarget, to_string(mode).c_str())) {
+				lua_error(L);
+			}
+			set_environment(env, stack_reference(L, raw_index(index + 1)));
+			if (lua_pcall(L, 0, LUA_MULTRET, 0)) {
+				lua_error(L);
+			}
+			int postindex = lua_gettop(L);
+			int returns = postindex - index;
+			return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
+		}
+
+		unsafe_function_result unsafe_script(
+		     const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			int index = lua_gettop(L);
+			stack::script(L, code, chunkname, mode);
+			int postindex = lua_gettop(L);
+			int returns = postindex - index;
+			return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
+		}
+
+		template <typename E>
+		unsafe_function_result unsafe_script_file(const std::string& filename, const basic_environment<E>& env, load_mode mode = load_mode::any) {
+			int index = lua_gettop(L);
+			if (luaL_loadfilex(L, filename.c_str(), to_string(mode).c_str())) {
+				lua_error(L);
+			}
+			set_environment(env, stack_reference(L, raw_index(index + 1)));
+			if (lua_pcall(L, 0, LUA_MULTRET, 0)) {
+				lua_error(L);
+			}
+			int postindex = lua_gettop(L);
+			int returns = postindex - index;
+			return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
+		}
+
+		unsafe_function_result unsafe_script_file(const std::string& filename, load_mode mode = load_mode::any) {
+			int index = lua_gettop(L);
+			stack::script_file(L, filename, mode);
+			int postindex = lua_gettop(L);
+			int returns = postindex - index;
+			return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
+		}
+
+		template <typename Fx,
+		     meta::disable_any<meta::is_string_constructible<meta::unqualified_t<Fx>>,
+		          meta::is_specialization_of<meta::unqualified_t<Fx>, basic_environment>> = meta::enabler>
+		protected_function_result script(
+		     const string_view& code, Fx&& on_error, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(code, std::forward<Fx>(on_error), chunkname, mode);
+		}
+
+		template <typename Fx,
+		     meta::disable_any<meta::is_string_constructible<meta::unqualified_t<Fx>>,
+		          meta::is_specialization_of<meta::unqualified_t<Fx>, basic_environment>> = meta::enabler>
+		protected_function_result script_file(const std::string& filename, Fx&& on_error, load_mode mode = load_mode::any) {
+			return safe_script_file(filename, std::forward<Fx>(on_error), mode);
+		}
+
+		template <typename Fx, typename E>
+		protected_function_result script(const string_view& code, const basic_environment<E>& env, Fx&& on_error,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(code, env, std::forward<Fx>(on_error), chunkname, mode);
+		}
+
+		template <typename Fx, typename E>
+		protected_function_result script_file(const std::string& filename, const basic_environment<E>& env, Fx&& on_error, load_mode mode = load_mode::any) {
+			return safe_script_file(filename, env, std::forward<Fx>(on_error), mode);
+		}
+
+		protected_function_result script(
+		     const string_view& code, const environment& env, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(code, env, script_default_on_error, chunkname, mode);
+		}
+
+		protected_function_result script_file(const std::string& filename, const environment& env, load_mode mode = load_mode::any) {
+			return safe_script_file(filename, env, script_default_on_error, mode);
+		}
+
+#if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS_I_)
+		protected_function_result script(
+		     lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(reader, data, chunkname, mode);
+		}
+
+		protected_function_result script(
+		     const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(code, chunkname, mode);
+		}
+
+		protected_function_result script_file(const std::string& filename, load_mode mode = load_mode::any) {
+			return safe_script_file(filename, mode);
+		}
+#else
+		unsafe_function_result script(const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return unsafe_script(code, chunkname, mode);
+		}
+
+		unsafe_function_result script_file(const std::string& filename, load_mode mode = load_mode::any) {
+			return unsafe_script_file(filename, mode);
+		}
+#endif
+		load_result load(const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name(code, chunkname, basechunkname);
+			load_status x = static_cast<load_status>(luaL_loadbufferx(L, code.data(), code.size(), chunknametarget, to_string(mode).c_str()));
+			return load_result(L, absolute_index(L, -1), 1, 1, x);
+		}
+
+		load_result load_buffer(const char* buff, size_t size, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return load(string_view(buff, size), chunkname, mode);
+		}
+
+		load_result load_buffer(
+		     const std::byte* buff, size_t size, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return load(string_view(reinterpret_cast<const char*>(buff), size), chunkname, mode);
+		}
+
+		load_result load_file(const std::string& filename, load_mode mode = load_mode::any) {
+			load_status x = static_cast<load_status>(luaL_loadfilex(L, filename.c_str(), to_string(mode).c_str()));
+			return load_result(L, absolute_index(L, -1), 1, 1, x);
+		}
+
+		load_result load(lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name("lua_Reader", chunkname, basechunkname);
+			load_status x = static_cast<load_status>(lua_load(L, reader, data, chunknametarget, to_string(mode).c_str()));
+			return load_result(L, absolute_index(L, -1), 1, 1, x);
+		}
+
+		iterator begin() const {
+			return global.begin();
+		}
+
+		iterator end() const {
+			return global.end();
+		}
+
+		const_iterator cbegin() const {
+			return global.cbegin();
+		}
+
+		const_iterator cend() const {
+			return global.cend();
+		}
+
+		global_table globals() const {
+			// if we return a reference
+			// we'll be screwed a bit
+			return global;
+		}
+
+		global_table& globals() {
+			return global;
+		}
+
+		table registry() const {
+			return reg;
+		}
+
+		std::size_t memory_used() const {
+			return total_memory_used(lua_state());
+		}
+
+		int stack_top() const {
+			return stack::top(L);
+		}
+
+		int stack_clear() {
+			int s = stack_top();
+			lua_pop(L, s);
+			return s;
+		}
+
+		bool supports_gc_mode(gc_mode mode) const noexcept {
+#if SOL_LUA_VESION_I_ >= 504
+			// supports all modes
+			(void)mode;
+			return true;
+#endif
+			return mode == gc_mode::default_value;
+		}
+
+		bool is_gc_on() const {
+#if SOL_LUA_VESION_I_ >= 502
+			return lua_gc(lua_state(), LUA_GCISRUNNING, 0) == 1;
+#else
+			// You cannot turn it off in Lua 5.1
+			return true;
+#endif
+		}
+
+		void collect_garbage() {
+			lua_gc(lua_state(), LUA_GCCOLLECT, 0);
+		}
+
+		void collect_gc() {
+			collect_garbage();
+		}
+
+		bool step_gc(int step_size_kilobytes) {
+			// THOUGHT: std::chrono-alikes to map "kilobyte size" here...?
+			// Make it harder to give MB or KB to a B parameter...?
+			// Probably overkill for now.
+#if SOL_LUA_VESION_I_ >= 504
+			// The manual implies that this function is almost always successful...
+			// is it?? It could depend on the GC mode...
+			return lua_gc(lua_state(), LUA_GCSTEP, step_size_kilobytes) != 0;
+#else
+			return lua_gc(lua_state(), LUA_GCSTEP, step_size_kilobytes) == 1;
+#endif
+		}
+
+		void restart_gc() {
+			lua_gc(lua_state(), LUA_GCRESTART, 0);
+		}
+
+		void stop_gc() {
+			lua_gc(lua_state(), LUA_GCSTOP, 0);
+		}
+
+		// Returns the old GC mode. Check support using the supports_gc_mode function.
+		gc_mode change_gc_mode_incremental(int pause, int step_multiplier, int step_byte_size) {
+			// "What the fuck does any of this mean??"
+			// http://www.lua.org/manual/5.4/manual.html#2.5.1
+
+			// THOUGHT: std::chrono-alikes to map "byte size" here...?
+			// Make it harder to give MB or KB to a B parameter...?
+			// Probably overkill for now.
+#if SOL_LUA_VESION_I_ >= 504
+			int old_mode = lua_gc(lua_state(), LUA_GCINC, pause, step_multiplier, step_byte_size);
+			if (old_mode == LUA_GCGEN) {
+				return gc_mode::generational;
+			}
+			else if (old_mode == LUA_GCINC) {
+				return gc_mode::incremental;
+			}
+#else
+			lua_gc(lua_state(), LUA_GCSETPAUSE, pause);
+			lua_gc(lua_state(), LUA_GCSETSTEPMUL, step_multiplier);
+			(void)step_byte_size; // means nothing in older versions
+#endif
+			return gc_mode::default_value;
+		}
+
+		// Returns the old GC mode. Check support using the supports_gc_mode function.
+		gc_mode change_gc_mode_generational(int minor_multiplier, int major_multiplier) {
+#if SOL_LUA_VESION_I_ >= 504
+			// "What does this shit mean?"
+			// http://www.lua.org/manual/5.4/manual.html#2.5.2
+			int old_mode = lua_gc(lua_state(), LUA_GCGEN, minor_multiplier, major_multiplier);
+			if (old_mode == LUA_GCGEN) {
+				return gc_mode::generational;
+			}
+			else if (old_mode == LUA_GCINC) {
+				return gc_mode::incremental;
+			}
+#endif
+			return gc_mode::default_value;
+		}
+
+		operator lua_State*() const {
+			return lua_state();
+		}
+
+		void set_panic(lua_CFunction panic) {
+			lua_atpanic(lua_state(), panic);
+		}
+
+		void set_exception_handler(exception_handler_function handler) {
+			set_default_exception_handler(lua_state(), handler);
+		}
+
+		template <typename... Args, typename... Keys>
+		decltype(auto) get(Keys&&... keys) const {
+			return global.get<Args...>(std::forward<Keys>(keys)...);
+		}
+
+		template <typename T, typename Key>
+		decltype(auto) get_or(Key&& key, T&& otherwise) const {
+			return global.get_or(std::forward<Key>(key), std::forward<T>(otherwise));
+		}
+
+		template <typename T, typename Key, typename D>
+		decltype(auto) get_or(Key&& key, D&& otherwise) const {
+			return global.get_or<T>(std::forward<Key>(key), std::forward<D>(otherwise));
+		}
+
+		template <typename... Args>
+		state_view& set(Args&&... args) {
+			global.set(std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename T, typename... Keys>
+		decltype(auto) traverse_get(Keys&&... keys) const {
+			return global.traverse_get<T>(std::forward<Keys>(keys)...);
+		}
+
+		template <typename... Args>
+		state_view& traverse_set(Args&&... args) {
+			global.traverse_set(std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename Class, typename... Args>
+		usertype<Class> new_usertype(const std::string& name, Args&&... args) {
+			return global.new_usertype<Class>(name, std::forward<Args>(args)...);
+		}
+
+		template <bool read_only = true, typename... Args>
+		state_view& new_enum(const string_view& name, Args&&... args) {
+			global.new_enum<read_only>(name, std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename T, bool read_only = true>
+		state_view& new_enum(const string_view& name, std::initializer_list<std::pair<string_view, T>> items) {
+			global.new_enum<T, read_only>(name, std::move(items));
+			return *this;
+		}
+
+		template <typename Fx>
+		void for_each(Fx&& fx) {
+			global.for_each(std::forward<Fx>(fx));
+		}
+
+		template <typename T>
+		table_proxy<global_table&, detail::proxy_key_t<T>> operator[](T&& key) {
+			return global[std::forward<T>(key)];
+		}
+
+		template <typename T>
+		table_proxy<const global_table&, detail::proxy_key_t<T>> operator[](T&& key) const {
+			return global[std::forward<T>(key)];
+		}
+
+		template <typename Sig, typename... Args, typename Key>
+		state_view& set_function(Key&& key, Args&&... args) {
+			global.set_function<Sig>(std::forward<Key>(key), std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename... Args, typename Key>
+		state_view& set_function(Key&& key, Args&&... args) {
+			global.set_function(std::forward<Key>(key), std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename Name>
+		table create_table(Name&& name, int narr = 0, int nrec = 0) {
+			return global.create(std::forward<Name>(name), narr, nrec);
+		}
+
+		template <typename Name, typename Key, typename Value, typename... Args>
+		table create_table(Name&& name, int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
+			return global.create(std::forward<Name>(name), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+		}
+
+		template <typename Name, typename... Args>
+		table create_named_table(Name&& name, Args&&... args) {
+			table x = global.create_with(std::forward<Args>(args)...);
+			global.set(std::forward<Name>(name), x);
+			return x;
+		}
+
+		table create_table(int narr = 0, int nrec = 0) {
+			return create_table(lua_state(), narr, nrec);
+		}
+
+		template <typename Key, typename Value, typename... Args>
+		table create_table(int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
+			return create_table(lua_state(), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+		}
+
+		template <typename... Args>
+		table create_table_with(Args&&... args) {
+			return create_table_with(lua_state(), std::forward<Args>(args)...);
+		}
+
+		static inline table create_table(lua_State* L, int narr = 0, int nrec = 0) {
+			return global_table::create(L, narr, nrec);
+		}
+
+		template <typename Key, typename Value, typename... Args>
+		static inline table create_table(lua_State* L, int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
+			return global_table::create(L, narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+		}
+
+		template <typename... Args>
+		static inline table create_table_with(lua_State* L, Args&&... args) {
+			return global_table::create_with(L, std::forward<Args>(args)...);
+		}
+	};
+} // namespace sol
+
+// end of sol/state_view.hpp
+
+// beginning of sol/thread.hpp
+
+namespace sol {
+	struct lua_thread_state {
+		lua_State* L;
+
+		lua_thread_state(lua_State* Ls)
+		: L(Ls) {
+		}
+
+		lua_State* lua_state() const noexcept {
+			return L;
+		}
+		operator lua_State*() const noexcept {
+			return lua_state();
+		}
+		lua_State* operator->() const noexcept {
+			return lua_state();
+		}
+	};
+
+	namespace stack {
+		template <>
+		struct unqualified_pusher<lua_thread_state> {
+			int push(lua_State*, lua_thread_state lts) {
+				lua_pushthread(lts.L);
+				return 1;
+			}
+		};
+
+		template <>
+		struct unqualified_getter<lua_thread_state> {
+			lua_thread_state get(lua_State* L, int index, record& tracking) {
+				tracking.use(1);
+				lua_thread_state lts( lua_tothread(L, index) );
+				return lts;
+			}
+		};
+
+		template <>
+		struct unqualified_check_getter<lua_thread_state> {
+			template <typename Handler>
+			optional<lua_thread_state> get(lua_State* L, int index, Handler&& handler, record& tracking) {
+				lua_thread_state lts( lua_tothread(L, index) );
+				if (lts.lua_state() == nullptr) {
+					handler(L, index, type::thread, type_of(L, index), "value is not a valid thread type");
+					return nullopt;
+				}
+				tracking.use(1);
+				return lts;
+			}
+		};
+	} // namespace stack
+
+	template <typename ref_t>
+	class basic_thread : public basic_object<ref_t> {
+	private:
+		using base_t = basic_object<ref_t>;
+
+	public:
+		using base_t::lua_state;
+
+		basic_thread() noexcept = default;
+		basic_thread(const basic_thread&) = default;
+		basic_thread(basic_thread&&) = default;
+		template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_thread>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_thread(T&& r)
+		: base_t(std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler{};
+			stack::check<basic_thread>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		basic_thread(const stack_reference& r)
+		: basic_thread(r.lua_state(), r.stack_index()){};
+		basic_thread(stack_reference&& r)
+		: basic_thread(r.lua_state(), r.stack_index()){};
+		basic_thread& operator=(const basic_thread&) = default;
+		basic_thread& operator=(basic_thread&&) = default;
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_thread(lua_State* L, T&& r)
+		: base_t(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler{};
+			stack::check<basic_thread>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		basic_thread(lua_State* L, int index = -1)
+		: base_t(L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			constructor_handler handler{};
+			stack::check<basic_thread>(L, index, handler);
+#endif // Safety
+		}
+		basic_thread(lua_State* L, ref_index index)
+		: base_t(L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler{};
+			stack::check<basic_thread>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		basic_thread(lua_State* L, lua_State* actualthread)
+		: basic_thread(L, lua_thread_state{ actualthread }) {
+		}
+		basic_thread(lua_State* L, this_state actualthread)
+		: basic_thread(L, lua_thread_state{ actualthread.L }) {
+		}
+		basic_thread(lua_State* L, lua_thread_state actualthread)
+		: base_t(L, -stack::push(L, actualthread)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			constructor_handler handler{};
+			stack::check<basic_thread>(lua_state(), -1, handler);
+#endif // Safety
+			if (!is_stack_based<base_t>::value) {
+				lua_pop(lua_state(), 1);
+			}
+		}
+
+		state_view state() const {
+			return state_view(this->thread_state());
+		}
+
+		bool is_main_thread() const {
+			return stack::is_main_thread(this->thread_state());
+		}
+
+		lua_State* thread_state() const {
+			auto pp = stack::push_pop(*this);
+			lua_State* lthread = lua_tothread(lua_state(), -1);
+			return lthread;
+		}
+
+		thread_status status() const {
+			lua_State* lthread = thread_state();
+			auto lstat = static_cast<thread_status>(lua_status(lthread));
+			if (lstat == thread_status::ok) {
+				lua_Debug ar;
+				if (lua_getstack(lthread, 0, &ar) > 0)
+					return thread_status::ok;
+				else if (lua_gettop(lthread) == 0)
+					return thread_status::dead;
+				else
+					return thread_status::yielded;
+			}
+			return lstat;
+		}
+
+		basic_thread create() {
+			return create(lua_state());
+		}
+
+		static basic_thread create(lua_State* L) {
+			lua_newthread(L);
+			basic_thread result(L);
+			if (!is_stack_based<base_t>::value) {
+				lua_pop(L, 1);
+			}
+			return result;
+		}
+	};
+
+	typedef basic_thread<reference> thread;
+	typedef basic_thread<stack_reference> stack_thread;
+} // namespace sol
+
+// end of sol/thread.hpp
+
+namespace sol {
+
+	class state : private std::unique_ptr<lua_State, detail::state_deleter>, public state_view {
+	private:
+		typedef std::unique_ptr<lua_State, detail::state_deleter> unique_base;
+
+	public:
+		state(lua_CFunction panic = default_at_panic)
+		: unique_base(luaL_newstate()), state_view(unique_base::get()) {
+			set_default_state(unique_base::get(), panic);
+		}
+
+		state(lua_CFunction panic, lua_Alloc alfunc, void* alpointer = nullptr)
+		: unique_base(lua_newstate(alfunc, alpointer)), state_view(unique_base::get()) {
+			set_default_state(unique_base::get(), panic);
+		}
+
+		state(const state&) = delete;
+		state(state&&) = default;
+		state& operator=(const state&) = delete;
+		state& operator=(state&& that) {
+			state_view::operator=(std::move(that));
+			unique_base::operator=(std::move(that));
+			return *this;
+		}
+
+		using state_view::get;
+
+		~state() {
+		}
+	};
+} // namespace sol
+
+// end of sol/state.hpp
+
+// beginning of sol/coroutine.hpp
+
+namespace sol {
+	template <typename ref_t>
+	class basic_coroutine : public basic_object<ref_t> {
+	private:
+		using base_t = basic_object<ref_t>;
+
+	public:
+		typedef reference handler_t;
+		handler_t error_handler;
+
+	private:
+		call_status stats = call_status::yielded;
+
+		void luacall(std::ptrdiff_t argcount, std::ptrdiff_t) {
+#if SOL_LUA_VESION_I_ >= 504
+			int nresults;
+			stats = static_cast<call_status>(lua_resume(lua_state(), nullptr, static_cast<int>(argcount), &nresults));
+#else
+			stats = static_cast<call_status>(lua_resume(lua_state(), nullptr, static_cast<int>(argcount)));
+#endif
+		}
+
+		template <std::size_t... I, typename... Ret>
+		auto invoke(types<Ret...>, std::index_sequence<I...>, std::ptrdiff_t n) {
+			luacall(n, sizeof...(Ret));
+			return stack::pop<std::tuple<Ret...>>(lua_state());
+		}
+
+		template <std::size_t I, typename Ret>
+		Ret invoke(types<Ret>, std::index_sequence<I>, std::ptrdiff_t n) {
+			luacall(n, 1);
+			return stack::pop<Ret>(lua_state());
+		}
+
+		template <std::size_t I>
+		void invoke(types<void>, std::index_sequence<I>, std::ptrdiff_t n) {
+			luacall(n, 0);
+		}
+
+		protected_function_result invoke(types<>, std::index_sequence<>, std::ptrdiff_t n) {
+			int firstreturn = 1;
+			luacall(n, LUA_MULTRET);
+			int poststacksize = lua_gettop(this->lua_state());
+			int returncount = poststacksize - (firstreturn - 1);
+			if (error()) {
+				if (error_handler.valid()) {
+					string_view err = stack::get<string_view>(this->lua_state(), poststacksize);
+					error_handler.push();
+					stack::push(this->lua_state(), err);
+					lua_call(lua_state(), 1, 1);
+				}
+				return protected_function_result(this->lua_state(), lua_absindex(this->lua_state(), -1), 1, returncount, status());
+			}
+			return protected_function_result(this->lua_state(), firstreturn, returncount, returncount, status());
+		}
+
+	public:
+		using base_t::lua_state;
+
+		basic_coroutine() = default;
+		template <typename T,
+		     meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_coroutine>>,
+		          meta::neg<std::is_base_of<proxy_base_tag, meta::unqualified_t<T>>>, meta::neg<std::is_same<base_t, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_coroutine(T&& r) noexcept
+		: base_t(std::forward<T>(r)), error_handler(detail::get_default_handler<reference, is_main_threaded<base_t>::value>(r.lua_state())) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			if (!is_function<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				constructor_handler handler {};
+				stack::check<basic_coroutine>(lua_state(), -1, handler);
+			}
+#endif // Safety
+		}
+		basic_coroutine(const basic_coroutine&) = default;
+		basic_coroutine& operator=(const basic_coroutine&) = default;
+		basic_coroutine(basic_coroutine&&) = default;
+		basic_coroutine& operator=(basic_coroutine&&) = default;
+		basic_coroutine(const basic_function<base_t>& b)
+		: basic_coroutine(b, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(b.lua_state())) {
+		}
+		basic_coroutine(basic_function<base_t>&& b)
+		: basic_coroutine(std::move(b), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(b.lua_state())) {
+		}
+		basic_coroutine(const basic_function<base_t>& b, handler_t eh) : base_t(b), error_handler(std::move(eh)) {
+		}
+		basic_coroutine(basic_function<base_t>&& b, handler_t eh) : base_t(std::move(b)), error_handler(std::move(eh)) {
+		}
+		basic_coroutine(const stack_reference& r)
+		: basic_coroutine(r.lua_state(), r.stack_index(), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(r.lua_state())) {
+		}
+		basic_coroutine(stack_reference&& r)
+		: basic_coroutine(r.lua_state(), r.stack_index(), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(r.lua_state())) {
+		}
+		basic_coroutine(const stack_reference& r, handler_t eh) : basic_coroutine(r.lua_state(), r.stack_index(), std::move(eh)) {
+		}
+		basic_coroutine(stack_reference&& r, handler_t eh) : basic_coroutine(r.lua_state(), r.stack_index(), std::move(eh)) {
+		}
+
+		template <typename Super>
+		basic_coroutine(const proxy_base<Super>& p)
+		: basic_coroutine(p, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(p.lua_state())) {
+		}
+		template <typename Super>
+		basic_coroutine(proxy_base<Super>&& p)
+		: basic_coroutine(std::move(p), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(p.lua_state())) {
+		}
+		template <typename Proxy, typename Handler,
+		     meta::enable<std::is_base_of<proxy_base_tag, meta::unqualified_t<Proxy>>, meta::neg<is_lua_index<meta::unqualified_t<Handler>>>> = meta::enabler>
+		basic_coroutine(Proxy&& p, Handler&& eh) : basic_coroutine(detail::force_cast<base_t>(p), std::forward<Handler>(eh)) {
+		}
+
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_coroutine(lua_State* L, T&& r)
+		: basic_coroutine(L, std::forward<T>(r), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_coroutine(lua_State* L, T&& r, handler_t eh) : base_t(L, std::forward<T>(r)), error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_coroutine>(lua_state(), -1, handler);
+#endif // Safety
+		}
+
+		basic_coroutine(lua_nil_t n) : base_t(n), error_handler(n) {
+		}
+
+		basic_coroutine(lua_State* L, int index = -1)
+		: basic_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
+		}
+		basic_coroutine(lua_State* L, int index, handler_t eh) : base_t(L, index), error_handler(std::move(eh)) {
+#ifdef SOL_SAFE_REFERENCES
+			constructor_handler handler {};
+			stack::check<basic_coroutine>(L, index, handler);
+#endif // Safety
+		}
+		basic_coroutine(lua_State* L, absolute_index index)
+		: basic_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
+		}
+		basic_coroutine(lua_State* L, absolute_index index, handler_t eh) : base_t(L, index), error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			constructor_handler handler {};
+			stack::check<basic_coroutine>(L, index, handler);
+#endif // Safety
+		}
+		basic_coroutine(lua_State* L, raw_index index)
+		: basic_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
+		}
+		basic_coroutine(lua_State* L, raw_index index, handler_t eh) : base_t(L, index), error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			constructor_handler handler {};
+			stack::check<basic_coroutine>(L, index, handler);
+#endif // Safety
+		}
+		basic_coroutine(lua_State* L, ref_index index)
+		: basic_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
+		}
+		basic_coroutine(lua_State* L, ref_index index, handler_t eh) : base_t(L, index), error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_coroutine>(lua_state(), -1, handler);
+#endif // Safety
+		}
+
+		call_status status() const noexcept {
+			return stats;
+		}
+
+		bool error() const noexcept {
+			call_status cs = status();
+			return cs != call_status::ok && cs != call_status::yielded;
+		}
+
+		bool runnable() const noexcept {
+			return base_t::valid() && (status() == call_status::yielded);
+		}
+
+		explicit operator bool() const noexcept {
+			return runnable();
+		}
+
+		template <typename... Args>
+		protected_function_result operator()(Args&&... args) {
+			return call<>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) operator()(types<Ret...>, Args&&... args) {
+			return call<Ret...>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) call(Args&&... args) {
+			// some users screw up coroutine.create
+			// and try to use it with sol::coroutine without ever calling the first resume in Lua
+			// this makes the stack incompatible with other kinds of stacks: protect against this
+			// make sure coroutines don't screw us over
+			base_t::push();
+			int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
+			return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount);
+		}
+	};
+} // namespace sol
+
+// end of sol/coroutine.hpp
+
+// beginning of sol/userdata.hpp
+
+namespace sol {
+	template <typename base_type>
+	class basic_userdata : public basic_table<base_type> {
+	private:
+		using base_t = basic_table<base_type>;
+
+	public:
+		using base_t::lua_state;
+
+		basic_userdata() noexcept = default;
+		template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_userdata>>, meta::neg<std::is_same<base_t, stack_reference>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_userdata(T&& r) noexcept
+		: base_t(std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			if (!is_userdata<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				type_assert(lua_state(), -1, type::userdata);
+			}
+#endif // Safety
+		}
+		basic_userdata(const basic_userdata&) = default;
+		basic_userdata(basic_userdata&&) = default;
+		basic_userdata& operator=(const basic_userdata&) = default;
+		basic_userdata& operator=(basic_userdata&&) = default;
+		basic_userdata(const stack_reference& r)
+		: basic_userdata(r.lua_state(), r.stack_index()) {
+		}
+		basic_userdata(stack_reference&& r)
+		: basic_userdata(r.lua_state(), r.stack_index()) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_userdata(lua_State* L, T&& r)
+		: base_t(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler{};
+			stack::check<basic_userdata>(L, -1, handler);
+#endif // Safety
+		}
+		basic_userdata(lua_State* L, int index = -1)
+		: base_t(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			constructor_handler handler{};
+			stack::check<basic_userdata>(L, index, handler);
+#endif // Safety
+		}
+		basic_userdata(lua_State* L, ref_index index)
+		: base_t(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler{};
+			stack::check<basic_userdata>(L, -1, handler);
+#endif // Safety
+		}
+	};
+
+	template <typename base_type>
+	class basic_lightuserdata : public basic_object_base<base_type> {
+		typedef basic_object_base<base_type> base_t;
+
+	public:
+		using base_t::lua_state;
+
+		basic_lightuserdata() noexcept = default;
+		template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_lightuserdata>>, meta::neg<std::is_same<base_t, stack_reference>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_lightuserdata(T&& r) noexcept
+		: base_t(std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			if (!is_lightuserdata<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				type_assert(lua_state(), -1, type::lightuserdata);
+			}
+#endif // Safety
+		}
+		basic_lightuserdata(const basic_lightuserdata&) = default;
+		basic_lightuserdata(basic_lightuserdata&&) = default;
+		basic_lightuserdata& operator=(const basic_lightuserdata&) = default;
+		basic_lightuserdata& operator=(basic_lightuserdata&&) = default;
+		basic_lightuserdata(const stack_reference& r)
+		: basic_lightuserdata(r.lua_state(), r.stack_index()) {
+		}
+		basic_lightuserdata(stack_reference&& r)
+		: basic_lightuserdata(r.lua_state(), r.stack_index()) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_lightuserdata(lua_State* L, T&& r)
+		: basic_lightuserdata(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler{};
+			stack::check<basic_lightuserdata>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		basic_lightuserdata(lua_State* L, int index = -1)
+		: base_t(L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			constructor_handler handler{};
+			stack::check<basic_lightuserdata>(L, index, handler);
+#endif // Safety
+		}
+		basic_lightuserdata(lua_State* L, ref_index index)
+		: base_t(L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler{};
+			stack::check<basic_lightuserdata>(lua_state(), index, handler);
+#endif // Safety
+		}
+	};
+
+} // namespace sol
+
+// end of sol/userdata.hpp
+
+// beginning of sol/as_args.hpp
+
+namespace sol {
+	template <typename T>
+	struct as_args_t {
+		T src;
+	};
+
+	template <typename Source>
+	auto as_args(Source&& source) {
+		return as_args_t<Source> { std::forward<Source>(source) };
+	}
+
+	namespace stack {
+		template <typename T>
+		struct unqualified_pusher<as_args_t<T>> {
+			int push(lua_State* L, const as_args_t<T>& e) {
+				int p = 0;
+				for (const auto& i : e.src) {
+					p += stack::push(L, i);
+				}
+				return p;
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/as_args.hpp
+
+// beginning of sol/variadic_args.hpp
+
+#include <limits>
+#include <iterator>
+
+namespace sol {
+	struct variadic_args {
+	private:
+		lua_State* L;
+		int index;
+		int stacktop;
+
+	public:
+		typedef stack_proxy reference_type;
+		typedef stack_proxy value_type;
+		typedef stack_proxy* pointer;
+		typedef std::ptrdiff_t difference_type;
+		typedef std::size_t size_type;
+		typedef stack_iterator<stack_proxy, false> iterator;
+		typedef stack_iterator<stack_proxy, true> const_iterator;
+		typedef std::reverse_iterator<iterator> reverse_iterator;
+		typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+		variadic_args() = default;
+		variadic_args(lua_State* luastate, int stackindex = -1)
+			: L(luastate), index(lua_absindex(luastate, stackindex)), stacktop(lua_gettop(luastate)) {
+		}
+		variadic_args(lua_State* luastate, int stackindex, int lastindex)
+			: L(luastate), index(lua_absindex(luastate, stackindex)), stacktop(lastindex) {
+		}
+		variadic_args(const variadic_args&) = default;
+		variadic_args& operator=(const variadic_args&) = default;
+		variadic_args(variadic_args&& o)
+			: L(o.L), index(o.index), stacktop(o.stacktop) {
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but will be thorough
+			o.L = nullptr;
+			o.index = 0;
+			o.stacktop = 0;
+		}
+		variadic_args& operator=(variadic_args&& o) {
+			L = o.L;
+			index = o.index;
+			stacktop = o.stacktop;
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but will be thorough
+			o.L = nullptr;
+			o.index = 0;
+			o.stacktop = 0;
+			return *this;
+		}
+
+		iterator begin() {
+			return iterator(L, index, stacktop + 1);
+		}
+		iterator end() {
+			return iterator(L, stacktop + 1, stacktop + 1);
+		}
+		const_iterator begin() const {
+			return const_iterator(L, index, stacktop + 1);
+		}
+		const_iterator end() const {
+			return const_iterator(L, stacktop + 1, stacktop + 1);
+		}
+		const_iterator cbegin() const {
+			return begin();
+		}
+		const_iterator cend() const {
+			return end();
+		}
+
+		reverse_iterator rbegin() {
+			return std::reverse_iterator<iterator>(begin());
+		}
+		reverse_iterator rend() {
+			return std::reverse_iterator<iterator>(end());
+		}
+		const_reverse_iterator rbegin() const {
+			return std::reverse_iterator<const_iterator>(begin());
+		}
+		const_reverse_iterator rend() const {
+			return std::reverse_iterator<const_iterator>(end());
+		}
+		const_reverse_iterator crbegin() const {
+			return std::reverse_iterator<const_iterator>(cbegin());
+		}
+		const_reverse_iterator crend() const {
+			return std::reverse_iterator<const_iterator>(cend());
+		}
+
+		int push() const {
+			return push(L);
+		}
+
+		int push(lua_State* target) const {
+			int pushcount = 0;
+			for (int i = index; i <= stacktop; ++i) {
+				lua_pushvalue(L, i);
+				pushcount += 1;
+			}
+			if (target != L) {
+				lua_xmove(L, target, pushcount);
+			}
+			return pushcount;
+		}
+
+		template <typename T>
+		decltype(auto) get(difference_type index_offset = 0) const {
+			return stack::get<T>(L, index + static_cast<int>(index_offset));
+		}
+
+		type get_type(difference_type index_offset = 0) const noexcept {
+			return type_of(L, index + static_cast<int>(index_offset));
+		}
+
+		stack_proxy operator[](difference_type index_offset) const {
+			return stack_proxy(L, index + static_cast<int>(index_offset));
+		}
+
+		lua_State* lua_state() const {
+			return L;
+		};
+		int stack_index() const {
+			return index;
+		};
+		int leftover_count() const {
+			return stacktop - (index - 1);
+		}
+		std::size_t size() const {
+			return static_cast<std::size_t>(leftover_count());
+		}
+		int top() const {
+			return stacktop;
+		}
+	};
+
+	namespace stack {
+		template <>
+		struct unqualified_getter<variadic_args> {
+			static variadic_args get(lua_State* L, int index, record& tracking) {
+				tracking.last = 0;
+				return variadic_args(L, index);
+			}
+		};
+
+		template <>
+		struct unqualified_pusher<variadic_args> {
+			static int push(lua_State* L, const variadic_args& ref) {
+				return ref.push(L);
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/variadic_args.hpp
+
+// beginning of sol/variadic_results.hpp
+
+// beginning of sol/as_returns.hpp
+
+namespace sol {
+	template <typename T>
+	struct as_returns_t {
+		T src;
+	};
+
+	template <typename Source>
+	auto as_returns(Source&& source) {
+		return as_returns_t<std::decay_t<Source>>{ std::forward<Source>(source) };
+	}
+
+	namespace stack {
+		template <typename T>
+		struct unqualified_pusher<as_returns_t<T>> {
+			int push(lua_State* L, const as_returns_t<T>& e) {
+				auto& src = detail::unwrap(e.src);
+				int p = 0;
+				for (const auto& i : src) {
+					p += stack::push(L, i);
+				}
+				return p;
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/as_returns.hpp
+
+#include <vector>
+
+namespace sol {
+
+	template <typename Al = typename std::allocator<object>>
+	struct basic_variadic_results : public std::vector<object, Al> {
+	private:
+		using base_t = std::vector<object, Al>;
+
+	public:
+		basic_variadic_results() : base_t() {
+		}
+
+		basic_variadic_results(unsafe_function_result fr) : base_t() {
+			this->reserve(fr.return_count());
+			this->insert(this->cend(), fr.begin(), fr.end());
+		}
+
+		basic_variadic_results(protected_function_result fr) : base_t() {
+			this->reserve(fr.return_count());
+			this->insert(this->cend(), fr.begin(), fr.end());
+		}
+
+		template <typename Arg0, typename... Args,
+		     meta::disable_any<std::is_same<meta::unqualified_t<Arg0>, basic_variadic_results>, std::is_same<meta::unqualified_t<Arg0>, function_result>,
+		          std::is_same<meta::unqualified_t<Arg0>, protected_function_result>> = meta::enabler>
+		basic_variadic_results(Arg0&& arg0, Args&&... args) : base_t(std::forward<Arg0>(arg0), std::forward<Args>(args)...) {
+		}
+
+		basic_variadic_results(const basic_variadic_results&) = default;
+		basic_variadic_results(basic_variadic_results&&) = default;
+	};
+
+	struct variadic_results : public basic_variadic_results<> {
+	private:
+		using base_t = basic_variadic_results<>;
+
+	public:
+		using base_t::base_t;
+	};
+
+	template <typename Al>
+	struct is_container<basic_variadic_results<Al>> : std::false_type { };
+
+	template <>
+	struct is_container<variadic_results> : std::false_type { };
+
+	namespace stack {
+		template <typename Al>
+		struct unqualified_pusher<basic_variadic_results<Al>> {
+			int push(lua_State* L, const basic_variadic_results<Al>& e) {
+				int p = 0;
+				for (const auto& i : e) {
+					p += stack::push(L, i);
+				}
+				return p;
+			}
+		};
+
+		template <>
+		struct unqualified_pusher<variadic_results> {
+			int push(lua_State* L, const variadic_results& r) {
+				using base_t = basic_variadic_results<>;
+				return stack::push(L, static_cast<const base_t&>(r));
+			}
+		};
+	} // namespace stack
+
+} // namespace sol
+
+// end of sol/variadic_results.hpp
+
+#if SOL_IS_ON(SOL_COMPILER_GCC_I_)
+#pragma GCC diagnostic pop
+#elif SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+#pragma warning(pop)
+#endif // g++
+
+#if SOL_IS_ON(SOL_INSIDE_UNREAL_ENGINE_I_)
+#undef check
+#pragma pop_macro("check")
+#endif // Unreal Engine 4 Bullshit
+
+#endif // SOL_HPP
+// end of sol/sol.hpp
+
+#endif // SOL_SINGLE_INCLUDE_HPP
diff --git a/engine/inc/spirv_cross/GLSL.std.450.h b/engine/inc/spirv_cross/GLSL.std.450.h
new file mode 100644
index 00000000..54cc00e9
--- /dev/null
+++ b/engine/inc/spirv_cross/GLSL.std.450.h
@@ -0,0 +1,131 @@
+/*
+** Copyright (c) 2014-2016 The Khronos Group Inc.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and/or associated documentation files (the "Materials"),
+** to deal in the Materials without restriction, including without limitation
+** the rights to use, copy, modify, merge, publish, distribute, sublicense,
+** and/or sell copies of the Materials, and to permit persons to whom the
+** Materials are 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 Materials.
+**
+** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
+**
+** THE MATERIALS ARE 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 MATERIALS OR THE USE OR OTHER DEALINGS
+** IN THE MATERIALS.
+*/
+
+#ifndef GLSLstd450_H
+#define GLSLstd450_H
+
+static const int GLSLstd450Version = 100;
+static const int GLSLstd450Revision = 3;
+
+enum GLSLstd450 {
+    GLSLstd450Bad = 0,              // Don't use
+
+    GLSLstd450Round = 1,
+    GLSLstd450RoundEven = 2,
+    GLSLstd450Trunc = 3,
+    GLSLstd450FAbs = 4,
+    GLSLstd450SAbs = 5,
+    GLSLstd450FSign = 6,
+    GLSLstd450SSign = 7,
+    GLSLstd450Floor = 8,
+    GLSLstd450Ceil = 9,
+    GLSLstd450Fract = 10,
+
+    GLSLstd450Radians = 11,
+    GLSLstd450Degrees = 12,
+    GLSLstd450Sin = 13,
+    GLSLstd450Cos = 14,
+    GLSLstd450Tan = 15,
+    GLSLstd450Asin = 16,
+    GLSLstd450Acos = 17,
+    GLSLstd450Atan = 18,
+    GLSLstd450Sinh = 19,
+    GLSLstd450Cosh = 20,
+    GLSLstd450Tanh = 21,
+    GLSLstd450Asinh = 22,
+    GLSLstd450Acosh = 23,
+    GLSLstd450Atanh = 24,
+    GLSLstd450Atan2 = 25,
+
+    GLSLstd450Pow = 26,
+    GLSLstd450Exp = 27,
+    GLSLstd450Log = 28,
+    GLSLstd450Exp2 = 29,
+    GLSLstd450Log2 = 30,
+    GLSLstd450Sqrt = 31,
+    GLSLstd450InverseSqrt = 32,
+
+    GLSLstd450Determinant = 33,
+    GLSLstd450MatrixInverse = 34,
+
+    GLSLstd450Modf = 35,            // second operand needs an OpVariable to write to
+    GLSLstd450ModfStruct = 36,      // no OpVariable operand
+    GLSLstd450FMin = 37,
+    GLSLstd450UMin = 38,
+    GLSLstd450SMin = 39,
+    GLSLstd450FMax = 40,
+    GLSLstd450UMax = 41,
+    GLSLstd450SMax = 42,
+    GLSLstd450FClamp = 43,
+    GLSLstd450UClamp = 44,
+    GLSLstd450SClamp = 45,
+    GLSLstd450FMix = 46,
+    GLSLstd450IMix = 47,            // Reserved
+    GLSLstd450Step = 48,
+    GLSLstd450SmoothStep = 49,
+
+    GLSLstd450Fma = 50,
+    GLSLstd450Frexp = 51,            // second operand needs an OpVariable to write to
+    GLSLstd450FrexpStruct = 52,      // no OpVariable operand
+    GLSLstd450Ldexp = 53,
+
+    GLSLstd450PackSnorm4x8 = 54,
+    GLSLstd450PackUnorm4x8 = 55,
+    GLSLstd450PackSnorm2x16 = 56,
+    GLSLstd450PackUnorm2x16 = 57,
+    GLSLstd450PackHalf2x16 = 58,
+    GLSLstd450PackDouble2x32 = 59,
+    GLSLstd450UnpackSnorm2x16 = 60,
+    GLSLstd450UnpackUnorm2x16 = 61,
+    GLSLstd450UnpackHalf2x16 = 62,
+    GLSLstd450UnpackSnorm4x8 = 63,
+    GLSLstd450UnpackUnorm4x8 = 64,
+    GLSLstd450UnpackDouble2x32 = 65,
+
+    GLSLstd450Length = 66,
+    GLSLstd450Distance = 67,
+    GLSLstd450Cross = 68,
+    GLSLstd450Normalize = 69,
+    GLSLstd450FaceForward = 70,
+    GLSLstd450Reflect = 71,
+    GLSLstd450Refract = 72,
+
+    GLSLstd450FindILsb = 73,
+    GLSLstd450FindSMsb = 74,
+    GLSLstd450FindUMsb = 75,
+
+    GLSLstd450InterpolateAtCentroid = 76,
+    GLSLstd450InterpolateAtSample = 77,
+    GLSLstd450InterpolateAtOffset = 78,
+
+    GLSLstd450NMin = 79,
+    GLSLstd450NMax = 80,
+    GLSLstd450NClamp = 81,
+
+    GLSLstd450Count
+};
+
+#endif  // #ifndef GLSLstd450_H
diff --git a/engine/inc/spirv_cross/barrier.hpp b/engine/inc/spirv_cross/barrier.hpp
new file mode 100644
index 00000000..bfcd2284
--- /dev/null
+++ b/engine/inc/spirv_cross/barrier.hpp
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2015-2017 ARM Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SPIRV_CROSS_BARRIER_HPP
+#define SPIRV_CROSS_BARRIER_HPP
+
+#include <atomic>
+#include <thread>
+
+namespace spirv_cross
+{
+class Barrier
+{
+public:
+	Barrier()
+	{
+		count.store(0);
+		iteration.store(0);
+	}
+
+	void set_release_divisor(unsigned divisor)
+	{
+		this->divisor = divisor;
+	}
+
+	static inline void memoryBarrier()
+	{
+		std::atomic_thread_fence(std::memory_order_seq_cst);
+	}
+
+	void reset_counter()
+	{
+		count.store(0);
+		iteration.store(0);
+	}
+
+	void wait()
+	{
+		unsigned target_iteration = iteration.load(std::memory_order_relaxed) + 1;
+		// Overflows cleanly.
+		unsigned target_count = divisor * target_iteration;
+
+		// Barriers don't enforce memory ordering.
+		// Be as relaxed about the barrier as we possibly can!
+		unsigned c = count.fetch_add(1u, std::memory_order_relaxed);
+
+		if (c + 1 == target_count)
+		{
+			iteration.store(target_iteration, std::memory_order_relaxed);
+		}
+		else
+		{
+			// If we have more threads than the CPU, don't hog the CPU for very long periods of time.
+			while (iteration.load(std::memory_order_relaxed) != target_iteration)
+				std::this_thread::yield();
+		}
+	}
+
+private:
+	unsigned divisor = 1;
+	std::atomic<unsigned> count;
+	std::atomic<unsigned> iteration;
+};
+}
+
+#endif
diff --git a/engine/inc/spirv_cross/external_interface.h b/engine/inc/spirv_cross/external_interface.h
new file mode 100644
index 00000000..1d26f1e1
--- /dev/null
+++ b/engine/inc/spirv_cross/external_interface.h
@@ -0,0 +1,126 @@
+/*
+ * Copyright 2015-2017 ARM Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SPIRV_CROSS_EXTERNAL_INTERFACE_H
+#define SPIRV_CROSS_EXTERNAL_INTERFACE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+
+typedef struct spirv_cross_shader spirv_cross_shader_t;
+
+struct spirv_cross_interface
+{
+	spirv_cross_shader_t *(*construct)(void);
+	void (*destruct)(spirv_cross_shader_t *thiz);
+	void (*invoke)(spirv_cross_shader_t *thiz);
+};
+
+void spirv_cross_set_stage_input(spirv_cross_shader_t *thiz, unsigned location, void *data, size_t size);
+
+void spirv_cross_set_stage_output(spirv_cross_shader_t *thiz, unsigned location, void *data, size_t size);
+
+void spirv_cross_set_push_constant(spirv_cross_shader_t *thiz, void *data, size_t size);
+
+void spirv_cross_set_uniform_constant(spirv_cross_shader_t *thiz, unsigned location, void *data, size_t size);
+
+void spirv_cross_set_resource(spirv_cross_shader_t *thiz, unsigned set, unsigned binding, void **data, size_t size);
+
+const struct spirv_cross_interface *spirv_cross_get_interface(void);
+
+typedef enum spirv_cross_builtin {
+	SPIRV_CROSS_BUILTIN_POSITION = 0,
+	SPIRV_CROSS_BUILTIN_FRAG_COORD = 1,
+	SPIRV_CROSS_BUILTIN_WORK_GROUP_ID = 2,
+	SPIRV_CROSS_BUILTIN_NUM_WORK_GROUPS = 3,
+	SPIRV_CROSS_NUM_BUILTINS
+} spirv_cross_builtin;
+
+void spirv_cross_set_builtin(spirv_cross_shader_t *thiz, spirv_cross_builtin builtin, void *data, size_t size);
+
+#define SPIRV_CROSS_NUM_DESCRIPTOR_SETS 4
+#define SPIRV_CROSS_NUM_DESCRIPTOR_BINDINGS 16
+#define SPIRV_CROSS_NUM_STAGE_INPUTS 16
+#define SPIRV_CROSS_NUM_STAGE_OUTPUTS 16
+#define SPIRV_CROSS_NUM_UNIFORM_CONSTANTS 32
+
+enum spirv_cross_format
+{
+	SPIRV_CROSS_FORMAT_R8_UNORM = 0,
+	SPIRV_CROSS_FORMAT_R8G8_UNORM = 1,
+	SPIRV_CROSS_FORMAT_R8G8B8_UNORM = 2,
+	SPIRV_CROSS_FORMAT_R8G8B8A8_UNORM = 3,
+
+	SPIRV_CROSS_NUM_FORMATS
+};
+
+enum spirv_cross_wrap
+{
+	SPIRV_CROSS_WRAP_CLAMP_TO_EDGE = 0,
+	SPIRV_CROSS_WRAP_REPEAT = 1,
+
+	SPIRV_CROSS_NUM_WRAP
+};
+
+enum spirv_cross_filter
+{
+	SPIRV_CROSS_FILTER_NEAREST = 0,
+	SPIRV_CROSS_FILTER_LINEAR = 1,
+
+	SPIRV_CROSS_NUM_FILTER
+};
+
+enum spirv_cross_mipfilter
+{
+	SPIRV_CROSS_MIPFILTER_BASE = 0,
+	SPIRV_CROSS_MIPFILTER_NEAREST = 1,
+	SPIRV_CROSS_MIPFILTER_LINEAR = 2,
+
+	SPIRV_CROSS_NUM_MIPFILTER
+};
+
+struct spirv_cross_miplevel
+{
+	const void *data;
+	unsigned width, height;
+	size_t stride;
+};
+
+struct spirv_cross_sampler_info
+{
+	const struct spirv_cross_miplevel *mipmaps;
+	unsigned num_mipmaps;
+
+	enum spirv_cross_format format;
+	enum spirv_cross_wrap wrap_s;
+	enum spirv_cross_wrap wrap_t;
+	enum spirv_cross_filter min_filter;
+	enum spirv_cross_filter mag_filter;
+	enum spirv_cross_mipfilter mip_filter;
+};
+
+typedef struct spirv_cross_sampler_2d spirv_cross_sampler_2d_t;
+spirv_cross_sampler_2d_t *spirv_cross_create_sampler_2d(const struct spirv_cross_sampler_info *info);
+void spirv_cross_destroy_sampler_2d(spirv_cross_sampler_2d_t *samp);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/engine/inc/spirv_cross/image.hpp b/engine/inc/spirv_cross/image.hpp
new file mode 100644
index 00000000..73de894f
--- /dev/null
+++ b/engine/inc/spirv_cross/image.hpp
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2015-2017 ARM Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SPIRV_CROSS_IMAGE_HPP
+#define SPIRV_CROSS_IMAGE_HPP
+
+#ifndef GLM_SWIZZLE
+#define GLM_SWIZZLE
+#endif
+
+#ifndef GLM_FORCE_RADIANS
+#define GLM_FORCE_RADIANS
+#endif
+
+#include <glm/glm.hpp>
+
+namespace spirv_cross
+{
+template <typename T>
+struct image2DBase
+{
+	virtual ~image2DBase() = default;
+	inline virtual T load(glm::ivec2 coord) const
+	{
+		return T(0, 0, 0, 1);
+	}
+	inline virtual void store(glm::ivec2 coord, const T &v)
+	{
+	}
+};
+
+typedef image2DBase<glm::vec4> image2D;
+typedef image2DBase<glm::ivec4> iimage2D;
+typedef image2DBase<glm::uvec4> uimage2D;
+
+template <typename T>
+inline T imageLoad(const image2DBase<T> &image, glm::ivec2 coord)
+{
+	return image.load(coord);
+}
+
+template <typename T>
+void imageStore(image2DBase<T> &image, glm::ivec2 coord, const T &value)
+{
+	image.store(coord, value);
+}
+}
+
+#endif
diff --git a/engine/inc/spirv_cross/internal_interface.hpp b/engine/inc/spirv_cross/internal_interface.hpp
new file mode 100644
index 00000000..e56223df
--- /dev/null
+++ b/engine/inc/spirv_cross/internal_interface.hpp
@@ -0,0 +1,603 @@
+/*
+ * Copyright 2015-2017 ARM Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SPIRV_CROSS_INTERNAL_INTERFACE_HPP
+#define SPIRV_CROSS_INTERNAL_INTERFACE_HPP
+
+// This file must only be included by the shader generated by spirv-cross!
+
+#ifndef GLM_FORCE_SWIZZLE
+#define GLM_FORCE_SWIZZLE
+#endif
+
+#ifndef GLM_FORCE_RADIANS
+#define GLM_FORCE_RADIANS
+#endif
+
+#include <glm/glm.hpp>
+
+#include "barrier.hpp"
+#include "external_interface.h"
+#include "image.hpp"
+#include "sampler.hpp"
+#include "thread_group.hpp"
+#include <assert.h>
+#include <stdint.h>
+
+namespace internal
+{
+// Adaptor helpers to adapt GLSL access chain syntax to C++.
+// Don't bother with arrays of arrays on uniforms ...
+// Would likely need horribly complex variadic template munging.
+
+template <typename T>
+struct Interface
+{
+	enum
+	{
+		ArraySize = 1,
+		Size = sizeof(T)
+	};
+
+	Interface()
+	    : ptr(0)
+	{
+	}
+	T &get()
+	{
+		assert(ptr);
+		return *ptr;
+	}
+
+	T *ptr;
+};
+
+// For array types, return a pointer instead.
+template <typename T, unsigned U>
+struct Interface<T[U]>
+{
+	enum
+	{
+		ArraySize = U,
+		Size = U * sizeof(T)
+	};
+
+	Interface()
+	    : ptr(0)
+	{
+	}
+	T *get()
+	{
+		assert(ptr);
+		return ptr;
+	}
+
+	T *ptr;
+};
+
+// For case when array size is 1, avoid double dereference.
+template <typename T>
+struct PointerInterface
+{
+	enum
+	{
+		ArraySize = 1,
+		Size = sizeof(T *)
+	};
+	enum
+	{
+		PreDereference = true
+	};
+
+	PointerInterface()
+	    : ptr(0)
+	{
+	}
+
+	T &get()
+	{
+		assert(ptr);
+		return *ptr;
+	}
+
+	T *ptr;
+};
+
+// Automatically converts a pointer down to reference to match GLSL syntax.
+template <typename T>
+struct DereferenceAdaptor
+{
+	DereferenceAdaptor(T **ptr)
+	    : ptr(ptr)
+	{
+	}
+	T &operator[](unsigned index) const
+	{
+		return *(ptr[index]);
+	}
+	T **ptr;
+};
+
+// We can't have a linear array of T* since T* can be an abstract type in case of samplers.
+// We also need a list of pointers since we can have run-time length SSBOs.
+template <typename T, unsigned U>
+struct PointerInterface<T[U]>
+{
+	enum
+	{
+		ArraySize = U,
+		Size = sizeof(T *) * U
+	};
+	enum
+	{
+		PreDereference = false
+	};
+	PointerInterface()
+	    : ptr(0)
+	{
+	}
+
+	DereferenceAdaptor<T> get()
+	{
+		assert(ptr);
+		return DereferenceAdaptor<T>(ptr);
+	}
+
+	T **ptr;
+};
+
+// Resources can be more abstract and be unsized,
+// so we need to have an array of pointers for those cases.
+template <typename T>
+struct Resource : PointerInterface<T>
+{
+};
+
+// POD with no unknown sizes, so we can express these as flat arrays.
+template <typename T>
+struct UniformConstant : Interface<T>
+{
+};
+template <typename T>
+struct StageInput : Interface<T>
+{
+};
+template <typename T>
+struct StageOutput : Interface<T>
+{
+};
+template <typename T>
+struct PushConstant : Interface<T>
+{
+};
+}
+
+struct spirv_cross_shader
+{
+	struct PPSize
+	{
+		PPSize()
+		    : ptr(0)
+		    , size(0)
+		{
+		}
+		void **ptr;
+		size_t size;
+	};
+
+	struct PPSizeResource
+	{
+		PPSizeResource()
+		    : ptr(0)
+		    , size(0)
+		    , pre_dereference(false)
+		{
+		}
+		void **ptr;
+		size_t size;
+		bool pre_dereference;
+	};
+
+	PPSizeResource resources[SPIRV_CROSS_NUM_DESCRIPTOR_SETS][SPIRV_CROSS_NUM_DESCRIPTOR_BINDINGS];
+	PPSize stage_inputs[SPIRV_CROSS_NUM_STAGE_INPUTS];
+	PPSize stage_outputs[SPIRV_CROSS_NUM_STAGE_OUTPUTS];
+	PPSize uniform_constants[SPIRV_CROSS_NUM_UNIFORM_CONSTANTS];
+	PPSize push_constant;
+	PPSize builtins[SPIRV_CROSS_NUM_BUILTINS];
+
+	template <typename U>
+	void register_builtin(spirv_cross_builtin builtin, const U &value)
+	{
+		assert(!builtins[builtin].ptr);
+
+		builtins[builtin].ptr = (void **)&value.ptr;
+		builtins[builtin].size = sizeof(*value.ptr) * U::ArraySize;
+	}
+
+	void set_builtin(spirv_cross_builtin builtin, void *data, size_t size)
+	{
+		assert(builtins[builtin].ptr);
+		assert(size >= builtins[builtin].size);
+
+		*builtins[builtin].ptr = data;
+	}
+
+	template <typename U>
+	void register_resource(const internal::Resource<U> &value, unsigned set, unsigned binding)
+	{
+		assert(set < SPIRV_CROSS_NUM_DESCRIPTOR_SETS);
+		assert(binding < SPIRV_CROSS_NUM_DESCRIPTOR_BINDINGS);
+		assert(!resources[set][binding].ptr);
+
+		resources[set][binding].ptr = (void **)&value.ptr;
+		resources[set][binding].size = internal::Resource<U>::Size;
+		resources[set][binding].pre_dereference = internal::Resource<U>::PreDereference;
+	}
+
+	template <typename U>
+	void register_stage_input(const internal::StageInput<U> &value, unsigned location)
+	{
+		assert(location < SPIRV_CROSS_NUM_STAGE_INPUTS);
+		assert(!stage_inputs[location].ptr);
+
+		stage_inputs[location].ptr = (void **)&value.ptr;
+		stage_inputs[location].size = internal::StageInput<U>::Size;
+	}
+
+	template <typename U>
+	void register_stage_output(const internal::StageOutput<U> &value, unsigned location)
+	{
+		assert(location < SPIRV_CROSS_NUM_STAGE_OUTPUTS);
+		assert(!stage_outputs[location].ptr);
+
+		stage_outputs[location].ptr = (void **)&value.ptr;
+		stage_outputs[location].size = internal::StageOutput<U>::Size;
+	}
+
+	template <typename U>
+	void register_uniform_constant(const internal::UniformConstant<U> &value, unsigned location)
+	{
+		assert(location < SPIRV_CROSS_NUM_UNIFORM_CONSTANTS);
+		assert(!uniform_constants[location].ptr);
+
+		uniform_constants[location].ptr = (void **)&value.ptr;
+		uniform_constants[location].size = internal::UniformConstant<U>::Size;
+	}
+
+	template <typename U>
+	void register_push_constant(const internal::PushConstant<U> &value)
+	{
+		assert(!push_constant.ptr);
+
+		push_constant.ptr = (void **)&value.ptr;
+		push_constant.size = internal::PushConstant<U>::Size;
+	}
+
+	void set_stage_input(unsigned location, void *data, size_t size)
+	{
+		assert(location < SPIRV_CROSS_NUM_STAGE_INPUTS);
+		assert(stage_inputs[location].ptr);
+		assert(size >= stage_inputs[location].size);
+
+		*stage_inputs[location].ptr = data;
+	}
+
+	void set_stage_output(unsigned location, void *data, size_t size)
+	{
+		assert(location < SPIRV_CROSS_NUM_STAGE_OUTPUTS);
+		assert(stage_outputs[location].ptr);
+		assert(size >= stage_outputs[location].size);
+
+		*stage_outputs[location].ptr = data;
+	}
+
+	void set_uniform_constant(unsigned location, void *data, size_t size)
+	{
+		assert(location < SPIRV_CROSS_NUM_UNIFORM_CONSTANTS);
+		assert(uniform_constants[location].ptr);
+		assert(size >= uniform_constants[location].size);
+
+		*uniform_constants[location].ptr = data;
+	}
+
+	void set_push_constant(void *data, size_t size)
+	{
+		assert(push_constant.ptr);
+		assert(size >= push_constant.size);
+
+		*push_constant.ptr = data;
+	}
+
+	void set_resource(unsigned set, unsigned binding, void **data, size_t size)
+	{
+		assert(set < SPIRV_CROSS_NUM_DESCRIPTOR_SETS);
+		assert(binding < SPIRV_CROSS_NUM_DESCRIPTOR_BINDINGS);
+		assert(resources[set][binding].ptr);
+		assert(size >= resources[set][binding].size);
+
+		// We're using the regular PointerInterface, dereference ahead of time.
+		if (resources[set][binding].pre_dereference)
+			*resources[set][binding].ptr = *data;
+		else
+			*resources[set][binding].ptr = data;
+	}
+};
+
+namespace spirv_cross
+{
+template <typename T>
+struct BaseShader : spirv_cross_shader
+{
+	void invoke()
+	{
+		static_cast<T *>(this)->main();
+	}
+};
+
+struct FragmentResources
+{
+	internal::StageOutput<glm::vec4> gl_FragCoord;
+	void init(spirv_cross_shader &s)
+	{
+		s.register_builtin(SPIRV_CROSS_BUILTIN_FRAG_COORD, gl_FragCoord);
+	}
+#define gl_FragCoord __res->gl_FragCoord.get()
+};
+
+template <typename T, typename Res>
+struct FragmentShader : BaseShader<FragmentShader<T, Res>>
+{
+	inline void main()
+	{
+		impl.main();
+	}
+
+	FragmentShader()
+	{
+		resources.init(*this);
+		impl.__res = &resources;
+	}
+
+	T impl;
+	Res resources;
+};
+
+struct VertexResources
+{
+	internal::StageOutput<glm::vec4> gl_Position;
+	void init(spirv_cross_shader &s)
+	{
+		s.register_builtin(SPIRV_CROSS_BUILTIN_POSITION, gl_Position);
+	}
+#define gl_Position __res->gl_Position.get()
+};
+
+template <typename T, typename Res>
+struct VertexShader : BaseShader<VertexShader<T, Res>>
+{
+	inline void main()
+	{
+		impl.main();
+	}
+
+	VertexShader()
+	{
+		resources.init(*this);
+		impl.__res = &resources;
+	}
+
+	T impl;
+	Res resources;
+};
+
+struct TessEvaluationResources
+{
+	inline void init(spirv_cross_shader &)
+	{
+	}
+};
+
+template <typename T, typename Res>
+struct TessEvaluationShader : BaseShader<TessEvaluationShader<T, Res>>
+{
+	inline void main()
+	{
+		impl.main();
+	}
+
+	TessEvaluationShader()
+	{
+		resources.init(*this);
+		impl.__res = &resources;
+	}
+
+	T impl;
+	Res resources;
+};
+
+struct TessControlResources
+{
+	inline void init(spirv_cross_shader &)
+	{
+	}
+};
+
+template <typename T, typename Res>
+struct TessControlShader : BaseShader<TessControlShader<T, Res>>
+{
+	inline void main()
+	{
+		impl.main();
+	}
+
+	TessControlShader()
+	{
+		resources.init(*this);
+		impl.__res = &resources;
+	}
+
+	T impl;
+	Res resources;
+};
+
+struct GeometryResources
+{
+	inline void init(spirv_cross_shader &)
+	{
+	}
+};
+
+template <typename T, typename Res>
+struct GeometryShader : BaseShader<GeometryShader<T, Res>>
+{
+	inline void main()
+	{
+		impl.main();
+	}
+
+	GeometryShader()
+	{
+		resources.init(*this);
+		impl.__res = &resources;
+	}
+
+	T impl;
+	Res resources;
+};
+
+struct ComputeResources
+{
+	internal::StageInput<glm::uvec3> gl_WorkGroupID__;
+	internal::StageInput<glm::uvec3> gl_NumWorkGroups__;
+	void init(spirv_cross_shader &s)
+	{
+		s.register_builtin(SPIRV_CROSS_BUILTIN_WORK_GROUP_ID, gl_WorkGroupID__);
+		s.register_builtin(SPIRV_CROSS_BUILTIN_NUM_WORK_GROUPS, gl_NumWorkGroups__);
+	}
+#define gl_WorkGroupID __res->gl_WorkGroupID__.get()
+#define gl_NumWorkGroups __res->gl_NumWorkGroups__.get()
+
+	Barrier barrier__;
+#define barrier() __res->barrier__.wait()
+};
+
+struct ComputePrivateResources
+{
+	uint32_t gl_LocalInvocationIndex__;
+#define gl_LocalInvocationIndex __priv_res.gl_LocalInvocationIndex__
+	glm::uvec3 gl_LocalInvocationID__;
+#define gl_LocalInvocationID __priv_res.gl_LocalInvocationID__
+	glm::uvec3 gl_GlobalInvocationID__;
+#define gl_GlobalInvocationID __priv_res.gl_GlobalInvocationID__
+};
+
+template <typename T, typename Res, unsigned WorkGroupX, unsigned WorkGroupY, unsigned WorkGroupZ>
+struct ComputeShader : BaseShader<ComputeShader<T, Res, WorkGroupX, WorkGroupY, WorkGroupZ>>
+{
+	inline void main()
+	{
+		resources.barrier__.reset_counter();
+
+		for (unsigned z = 0; z < WorkGroupZ; z++)
+			for (unsigned y = 0; y < WorkGroupY; y++)
+				for (unsigned x = 0; x < WorkGroupX; x++)
+					impl[z][y][x].__priv_res.gl_GlobalInvocationID__ =
+					    glm::uvec3(WorkGroupX, WorkGroupY, WorkGroupZ) * resources.gl_WorkGroupID__.get() +
+					    glm::uvec3(x, y, z);
+
+		group.run();
+		group.wait();
+	}
+
+	ComputeShader()
+	    : group(&impl[0][0][0])
+	{
+		resources.init(*this);
+		resources.barrier__.set_release_divisor(WorkGroupX * WorkGroupY * WorkGroupZ);
+
+		unsigned i = 0;
+		for (unsigned z = 0; z < WorkGroupZ; z++)
+		{
+			for (unsigned y = 0; y < WorkGroupY; y++)
+			{
+				for (unsigned x = 0; x < WorkGroupX; x++)
+				{
+					impl[z][y][x].__priv_res.gl_LocalInvocationID__ = glm::uvec3(x, y, z);
+					impl[z][y][x].__priv_res.gl_LocalInvocationIndex__ = i++;
+					impl[z][y][x].__res = &resources;
+				}
+			}
+		}
+	}
+
+	T impl[WorkGroupZ][WorkGroupY][WorkGroupX];
+	ThreadGroup<T, WorkGroupX * WorkGroupY * WorkGroupZ> group;
+	Res resources;
+};
+
+inline void memoryBarrierShared()
+{
+	Barrier::memoryBarrier();
+}
+inline void memoryBarrier()
+{
+	Barrier::memoryBarrier();
+}
+// TODO: Rest of the barriers.
+
+// Atomics
+template <typename T>
+inline T atomicAdd(T &v, T a)
+{
+	static_assert(sizeof(std::atomic<T>) == sizeof(T), "Cannot cast properly to std::atomic<T>.");
+
+	// We need explicit memory barriers in GLSL to enfore any ordering.
+	// FIXME: Can we really cast this? There is no other way I think ...
+	return std::atomic_fetch_add_explicit(reinterpret_cast<std::atomic<T> *>(&v), a, std::memory_order_relaxed);
+}
+}
+
+void spirv_cross_set_stage_input(spirv_cross_shader_t *shader, unsigned location, void *data, size_t size)
+{
+	shader->set_stage_input(location, data, size);
+}
+
+void spirv_cross_set_stage_output(spirv_cross_shader_t *shader, unsigned location, void *data, size_t size)
+{
+	shader->set_stage_output(location, data, size);
+}
+
+void spirv_cross_set_uniform_constant(spirv_cross_shader_t *shader, unsigned location, void *data, size_t size)
+{
+	shader->set_uniform_constant(location, data, size);
+}
+
+void spirv_cross_set_resource(spirv_cross_shader_t *shader, unsigned set, unsigned binding, void **data, size_t size)
+{
+	shader->set_resource(set, binding, data, size);
+}
+
+void spirv_cross_set_push_constant(spirv_cross_shader_t *shader, void *data, size_t size)
+{
+	shader->set_push_constant(data, size);
+}
+
+void spirv_cross_set_builtin(spirv_cross_shader_t *shader, spirv_cross_builtin builtin, void *data, size_t size)
+{
+	shader->set_builtin(builtin, data, size);
+}
+
+#endif
diff --git a/engine/inc/spirv_cross/sampler.hpp b/engine/inc/spirv_cross/sampler.hpp
new file mode 100644
index 00000000..542e11b4
--- /dev/null
+++ b/engine/inc/spirv_cross/sampler.hpp
@@ -0,0 +1,105 @@
+/*
+ * Copyright 2015-2017 ARM Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SPIRV_CROSS_SAMPLER_HPP
+#define SPIRV_CROSS_SAMPLER_HPP
+
+#include <vector>
+
+namespace spirv_cross
+{
+struct spirv_cross_sampler_2d
+{
+	inline virtual ~spirv_cross_sampler_2d()
+	{
+	}
+};
+
+template <typename T>
+struct sampler2DBase : spirv_cross_sampler_2d
+{
+	sampler2DBase(const spirv_cross_sampler_info *info)
+	{
+		mips.insert(mips.end(), info->mipmaps, info->mipmaps + info->num_mipmaps);
+		format = info->format;
+		wrap_s = info->wrap_s;
+		wrap_t = info->wrap_t;
+		min_filter = info->min_filter;
+		mag_filter = info->mag_filter;
+		mip_filter = info->mip_filter;
+	}
+
+	inline virtual T sample(glm::vec2 uv, float bias)
+	{
+		return sampleLod(uv, bias);
+	}
+
+	inline virtual T sampleLod(glm::vec2 uv, float lod)
+	{
+		if (mag_filter == SPIRV_CROSS_FILTER_NEAREST)
+		{
+			uv.x = wrap(uv.x, wrap_s, mips[0].width);
+			uv.y = wrap(uv.y, wrap_t, mips[0].height);
+			glm::vec2 uv_full = uv * glm::vec2(mips[0].width, mips[0].height);
+
+			int x = int(uv_full.x);
+			int y = int(uv_full.y);
+			return sample(x, y, 0);
+		}
+		else
+		{
+			return T(0, 0, 0, 1);
+		}
+	}
+
+	inline float wrap(float v, spirv_cross_wrap wrap, unsigned size)
+	{
+		switch (wrap)
+		{
+		case SPIRV_CROSS_WRAP_REPEAT:
+			return v - glm::floor(v);
+		case SPIRV_CROSS_WRAP_CLAMP_TO_EDGE:
+		{
+			float half = 0.5f / size;
+			return glm::clamp(v, half, 1.0f - half);
+		}
+
+		default:
+			return 0.0f;
+		}
+	}
+
+	std::vector<spirv_cross_miplevel> mips;
+	spirv_cross_format format;
+	spirv_cross_wrap wrap_s;
+	spirv_cross_wrap wrap_t;
+	spirv_cross_filter min_filter;
+	spirv_cross_filter mag_filter;
+	spirv_cross_mipfilter mip_filter;
+};
+
+typedef sampler2DBase<glm::vec4> sampler2D;
+typedef sampler2DBase<glm::ivec4> isampler2D;
+typedef sampler2DBase<glm::uvec4> usampler2D;
+
+template <typename T>
+inline T texture(const sampler2DBase<T> &samp, const glm::vec2 &uv, float bias = 0.0f)
+{
+	return samp.sample(uv, bias);
+}
+}
+
+#endif
diff --git a/engine/inc/spirv_cross/spirv.h b/engine/inc/spirv_cross/spirv.h
new file mode 100644
index 00000000..dd9850db
--- /dev/null
+++ b/engine/inc/spirv_cross/spirv.h
@@ -0,0 +1,2104 @@
+/*
+** Copyright (c) 2014-2020 The Khronos Group Inc.
+** 
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and/or associated documentation files (the "Materials"),
+** to deal in the Materials without restriction, including without limitation
+** the rights to use, copy, modify, merge, publish, distribute, sublicense,
+** and/or sell copies of the Materials, and to permit persons to whom the
+** Materials are 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 Materials.
+** 
+** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
+** 
+** THE MATERIALS ARE 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 MATERIALS OR THE USE OR OTHER DEALINGS
+** IN THE MATERIALS.
+*/
+
+/*
+** This header is automatically generated by the same tool that creates
+** the Binary Section of the SPIR-V specification.
+*/
+
+/*
+** Enumeration tokens for SPIR-V, in various styles:
+**   C, C++, C++11, JSON, Lua, Python, C#, D
+** 
+** - C will have tokens with a "Spv" prefix, e.g.: SpvSourceLanguageGLSL
+** - C++ will have tokens in the "spv" name space, e.g.: spv::SourceLanguageGLSL
+** - C++11 will use enum classes in the spv namespace, e.g.: spv::SourceLanguage::GLSL
+** - Lua will use tables, e.g.: spv.SourceLanguage.GLSL
+** - Python will use dictionaries, e.g.: spv['SourceLanguage']['GLSL']
+** - C# will use enum classes in the Specification class located in the "Spv" namespace,
+**     e.g.: Spv.Specification.SourceLanguage.GLSL
+** - D will have tokens under the "spv" module, e.g: spv.SourceLanguage.GLSL
+** 
+** Some tokens act like mask values, which can be OR'd together,
+** while others are mutually exclusive.  The mask-like ones have
+** "Mask" in their name, and a parallel enum that has the shift
+** amount (1 << x) for each corresponding enumerant.
+*/
+
+#ifndef spirv_H
+#define spirv_H
+
+typedef unsigned int SpvId;
+
+#define SPV_VERSION 0x10500
+#define SPV_REVISION 3
+
+static const unsigned int SpvMagicNumber = 0x07230203;
+static const unsigned int SpvVersion = 0x00010500;
+static const unsigned int SpvRevision = 3;
+static const unsigned int SpvOpCodeMask = 0xffff;
+static const unsigned int SpvWordCountShift = 16;
+
+typedef enum SpvSourceLanguage_ {
+    SpvSourceLanguageUnknown = 0,
+    SpvSourceLanguageESSL = 1,
+    SpvSourceLanguageGLSL = 2,
+    SpvSourceLanguageOpenCL_C = 3,
+    SpvSourceLanguageOpenCL_CPP = 4,
+    SpvSourceLanguageHLSL = 5,
+    SpvSourceLanguageMax = 0x7fffffff,
+} SpvSourceLanguage;
+
+typedef enum SpvExecutionModel_ {
+    SpvExecutionModelVertex = 0,
+    SpvExecutionModelTessellationControl = 1,
+    SpvExecutionModelTessellationEvaluation = 2,
+    SpvExecutionModelGeometry = 3,
+    SpvExecutionModelFragment = 4,
+    SpvExecutionModelGLCompute = 5,
+    SpvExecutionModelKernel = 6,
+    SpvExecutionModelTaskNV = 5267,
+    SpvExecutionModelMeshNV = 5268,
+    SpvExecutionModelRayGenerationKHR = 5313,
+    SpvExecutionModelRayGenerationNV = 5313,
+    SpvExecutionModelIntersectionKHR = 5314,
+    SpvExecutionModelIntersectionNV = 5314,
+    SpvExecutionModelAnyHitKHR = 5315,
+    SpvExecutionModelAnyHitNV = 5315,
+    SpvExecutionModelClosestHitKHR = 5316,
+    SpvExecutionModelClosestHitNV = 5316,
+    SpvExecutionModelMissKHR = 5317,
+    SpvExecutionModelMissNV = 5317,
+    SpvExecutionModelCallableKHR = 5318,
+    SpvExecutionModelCallableNV = 5318,
+    SpvExecutionModelMax = 0x7fffffff,
+} SpvExecutionModel;
+
+typedef enum SpvAddressingModel_ {
+    SpvAddressingModelLogical = 0,
+    SpvAddressingModelPhysical32 = 1,
+    SpvAddressingModelPhysical64 = 2,
+    SpvAddressingModelPhysicalStorageBuffer64 = 5348,
+    SpvAddressingModelPhysicalStorageBuffer64EXT = 5348,
+    SpvAddressingModelMax = 0x7fffffff,
+} SpvAddressingModel;
+
+typedef enum SpvMemoryModel_ {
+    SpvMemoryModelSimple = 0,
+    SpvMemoryModelGLSL450 = 1,
+    SpvMemoryModelOpenCL = 2,
+    SpvMemoryModelVulkan = 3,
+    SpvMemoryModelVulkanKHR = 3,
+    SpvMemoryModelMax = 0x7fffffff,
+} SpvMemoryModel;
+
+typedef enum SpvExecutionMode_ {
+    SpvExecutionModeInvocations = 0,
+    SpvExecutionModeSpacingEqual = 1,
+    SpvExecutionModeSpacingFractionalEven = 2,
+    SpvExecutionModeSpacingFractionalOdd = 3,
+    SpvExecutionModeVertexOrderCw = 4,
+    SpvExecutionModeVertexOrderCcw = 5,
+    SpvExecutionModePixelCenterInteger = 6,
+    SpvExecutionModeOriginUpperLeft = 7,
+    SpvExecutionModeOriginLowerLeft = 8,
+    SpvExecutionModeEarlyFragmentTests = 9,
+    SpvExecutionModePointMode = 10,
+    SpvExecutionModeXfb = 11,
+    SpvExecutionModeDepthReplacing = 12,
+    SpvExecutionModeDepthGreater = 14,
+    SpvExecutionModeDepthLess = 15,
+    SpvExecutionModeDepthUnchanged = 16,
+    SpvExecutionModeLocalSize = 17,
+    SpvExecutionModeLocalSizeHint = 18,
+    SpvExecutionModeInputPoints = 19,
+    SpvExecutionModeInputLines = 20,
+    SpvExecutionModeInputLinesAdjacency = 21,
+    SpvExecutionModeTriangles = 22,
+    SpvExecutionModeInputTrianglesAdjacency = 23,
+    SpvExecutionModeQuads = 24,
+    SpvExecutionModeIsolines = 25,
+    SpvExecutionModeOutputVertices = 26,
+    SpvExecutionModeOutputPoints = 27,
+    SpvExecutionModeOutputLineStrip = 28,
+    SpvExecutionModeOutputTriangleStrip = 29,
+    SpvExecutionModeVecTypeHint = 30,
+    SpvExecutionModeContractionOff = 31,
+    SpvExecutionModeInitializer = 33,
+    SpvExecutionModeFinalizer = 34,
+    SpvExecutionModeSubgroupSize = 35,
+    SpvExecutionModeSubgroupsPerWorkgroup = 36,
+    SpvExecutionModeSubgroupsPerWorkgroupId = 37,
+    SpvExecutionModeLocalSizeId = 38,
+    SpvExecutionModeLocalSizeHintId = 39,
+    SpvExecutionModePostDepthCoverage = 4446,
+    SpvExecutionModeDenormPreserve = 4459,
+    SpvExecutionModeDenormFlushToZero = 4460,
+    SpvExecutionModeSignedZeroInfNanPreserve = 4461,
+    SpvExecutionModeRoundingModeRTE = 4462,
+    SpvExecutionModeRoundingModeRTZ = 4463,
+    SpvExecutionModeStencilRefReplacingEXT = 5027,
+    SpvExecutionModeOutputLinesNV = 5269,
+    SpvExecutionModeOutputPrimitivesNV = 5270,
+    SpvExecutionModeDerivativeGroupQuadsNV = 5289,
+    SpvExecutionModeDerivativeGroupLinearNV = 5290,
+    SpvExecutionModeOutputTrianglesNV = 5298,
+    SpvExecutionModePixelInterlockOrderedEXT = 5366,
+    SpvExecutionModePixelInterlockUnorderedEXT = 5367,
+    SpvExecutionModeSampleInterlockOrderedEXT = 5368,
+    SpvExecutionModeSampleInterlockUnorderedEXT = 5369,
+    SpvExecutionModeShadingRateInterlockOrderedEXT = 5370,
+    SpvExecutionModeShadingRateInterlockUnorderedEXT = 5371,
+    SpvExecutionModeMax = 0x7fffffff,
+} SpvExecutionMode;
+
+typedef enum SpvStorageClass_ {
+    SpvStorageClassUniformConstant = 0,
+    SpvStorageClassInput = 1,
+    SpvStorageClassUniform = 2,
+    SpvStorageClassOutput = 3,
+    SpvStorageClassWorkgroup = 4,
+    SpvStorageClassCrossWorkgroup = 5,
+    SpvStorageClassPrivate = 6,
+    SpvStorageClassFunction = 7,
+    SpvStorageClassGeneric = 8,
+    SpvStorageClassPushConstant = 9,
+    SpvStorageClassAtomicCounter = 10,
+    SpvStorageClassImage = 11,
+    SpvStorageClassStorageBuffer = 12,
+    SpvStorageClassCallableDataKHR = 5328,
+    SpvStorageClassCallableDataNV = 5328,
+    SpvStorageClassIncomingCallableDataKHR = 5329,
+    SpvStorageClassIncomingCallableDataNV = 5329,
+    SpvStorageClassRayPayloadKHR = 5338,
+    SpvStorageClassRayPayloadNV = 5338,
+    SpvStorageClassHitAttributeKHR = 5339,
+    SpvStorageClassHitAttributeNV = 5339,
+    SpvStorageClassIncomingRayPayloadKHR = 5342,
+    SpvStorageClassIncomingRayPayloadNV = 5342,
+    SpvStorageClassShaderRecordBufferKHR = 5343,
+    SpvStorageClassShaderRecordBufferNV = 5343,
+    SpvStorageClassPhysicalStorageBuffer = 5349,
+    SpvStorageClassPhysicalStorageBufferEXT = 5349,
+    SpvStorageClassMax = 0x7fffffff,
+} SpvStorageClass;
+
+typedef enum SpvDim_ {
+    SpvDim1D = 0,
+    SpvDim2D = 1,
+    SpvDim3D = 2,
+    SpvDimCube = 3,
+    SpvDimRect = 4,
+    SpvDimBuffer = 5,
+    SpvDimSubpassData = 6,
+    SpvDimMax = 0x7fffffff,
+} SpvDim;
+
+typedef enum SpvSamplerAddressingMode_ {
+    SpvSamplerAddressingModeNone = 0,
+    SpvSamplerAddressingModeClampToEdge = 1,
+    SpvSamplerAddressingModeClamp = 2,
+    SpvSamplerAddressingModeRepeat = 3,
+    SpvSamplerAddressingModeRepeatMirrored = 4,
+    SpvSamplerAddressingModeMax = 0x7fffffff,
+} SpvSamplerAddressingMode;
+
+typedef enum SpvSamplerFilterMode_ {
+    SpvSamplerFilterModeNearest = 0,
+    SpvSamplerFilterModeLinear = 1,
+    SpvSamplerFilterModeMax = 0x7fffffff,
+} SpvSamplerFilterMode;
+
+typedef enum SpvImageFormat_ {
+    SpvImageFormatUnknown = 0,
+    SpvImageFormatRgba32f = 1,
+    SpvImageFormatRgba16f = 2,
+    SpvImageFormatR32f = 3,
+    SpvImageFormatRgba8 = 4,
+    SpvImageFormatRgba8Snorm = 5,
+    SpvImageFormatRg32f = 6,
+    SpvImageFormatRg16f = 7,
+    SpvImageFormatR11fG11fB10f = 8,
+    SpvImageFormatR16f = 9,
+    SpvImageFormatRgba16 = 10,
+    SpvImageFormatRgb10A2 = 11,
+    SpvImageFormatRg16 = 12,
+    SpvImageFormatRg8 = 13,
+    SpvImageFormatR16 = 14,
+    SpvImageFormatR8 = 15,
+    SpvImageFormatRgba16Snorm = 16,
+    SpvImageFormatRg16Snorm = 17,
+    SpvImageFormatRg8Snorm = 18,
+    SpvImageFormatR16Snorm = 19,
+    SpvImageFormatR8Snorm = 20,
+    SpvImageFormatRgba32i = 21,
+    SpvImageFormatRgba16i = 22,
+    SpvImageFormatRgba8i = 23,
+    SpvImageFormatR32i = 24,
+    SpvImageFormatRg32i = 25,
+    SpvImageFormatRg16i = 26,
+    SpvImageFormatRg8i = 27,
+    SpvImageFormatR16i = 28,
+    SpvImageFormatR8i = 29,
+    SpvImageFormatRgba32ui = 30,
+    SpvImageFormatRgba16ui = 31,
+    SpvImageFormatRgba8ui = 32,
+    SpvImageFormatR32ui = 33,
+    SpvImageFormatRgb10a2ui = 34,
+    SpvImageFormatRg32ui = 35,
+    SpvImageFormatRg16ui = 36,
+    SpvImageFormatRg8ui = 37,
+    SpvImageFormatR16ui = 38,
+    SpvImageFormatR8ui = 39,
+    SpvImageFormatMax = 0x7fffffff,
+} SpvImageFormat;
+
+typedef enum SpvImageChannelOrder_ {
+    SpvImageChannelOrderR = 0,
+    SpvImageChannelOrderA = 1,
+    SpvImageChannelOrderRG = 2,
+    SpvImageChannelOrderRA = 3,
+    SpvImageChannelOrderRGB = 4,
+    SpvImageChannelOrderRGBA = 5,
+    SpvImageChannelOrderBGRA = 6,
+    SpvImageChannelOrderARGB = 7,
+    SpvImageChannelOrderIntensity = 8,
+    SpvImageChannelOrderLuminance = 9,
+    SpvImageChannelOrderRx = 10,
+    SpvImageChannelOrderRGx = 11,
+    SpvImageChannelOrderRGBx = 12,
+    SpvImageChannelOrderDepth = 13,
+    SpvImageChannelOrderDepthStencil = 14,
+    SpvImageChannelOrdersRGB = 15,
+    SpvImageChannelOrdersRGBx = 16,
+    SpvImageChannelOrdersRGBA = 17,
+    SpvImageChannelOrdersBGRA = 18,
+    SpvImageChannelOrderABGR = 19,
+    SpvImageChannelOrderMax = 0x7fffffff,
+} SpvImageChannelOrder;
+
+typedef enum SpvImageChannelDataType_ {
+    SpvImageChannelDataTypeSnormInt8 = 0,
+    SpvImageChannelDataTypeSnormInt16 = 1,
+    SpvImageChannelDataTypeUnormInt8 = 2,
+    SpvImageChannelDataTypeUnormInt16 = 3,
+    SpvImageChannelDataTypeUnormShort565 = 4,
+    SpvImageChannelDataTypeUnormShort555 = 5,
+    SpvImageChannelDataTypeUnormInt101010 = 6,
+    SpvImageChannelDataTypeSignedInt8 = 7,
+    SpvImageChannelDataTypeSignedInt16 = 8,
+    SpvImageChannelDataTypeSignedInt32 = 9,
+    SpvImageChannelDataTypeUnsignedInt8 = 10,
+    SpvImageChannelDataTypeUnsignedInt16 = 11,
+    SpvImageChannelDataTypeUnsignedInt32 = 12,
+    SpvImageChannelDataTypeHalfFloat = 13,
+    SpvImageChannelDataTypeFloat = 14,
+    SpvImageChannelDataTypeUnormInt24 = 15,
+    SpvImageChannelDataTypeUnormInt101010_2 = 16,
+    SpvImageChannelDataTypeMax = 0x7fffffff,
+} SpvImageChannelDataType;
+
+typedef enum SpvImageOperandsShift_ {
+    SpvImageOperandsBiasShift = 0,
+    SpvImageOperandsLodShift = 1,
+    SpvImageOperandsGradShift = 2,
+    SpvImageOperandsConstOffsetShift = 3,
+    SpvImageOperandsOffsetShift = 4,
+    SpvImageOperandsConstOffsetsShift = 5,
+    SpvImageOperandsSampleShift = 6,
+    SpvImageOperandsMinLodShift = 7,
+    SpvImageOperandsMakeTexelAvailableShift = 8,
+    SpvImageOperandsMakeTexelAvailableKHRShift = 8,
+    SpvImageOperandsMakeTexelVisibleShift = 9,
+    SpvImageOperandsMakeTexelVisibleKHRShift = 9,
+    SpvImageOperandsNonPrivateTexelShift = 10,
+    SpvImageOperandsNonPrivateTexelKHRShift = 10,
+    SpvImageOperandsVolatileTexelShift = 11,
+    SpvImageOperandsVolatileTexelKHRShift = 11,
+    SpvImageOperandsSignExtendShift = 12,
+    SpvImageOperandsZeroExtendShift = 13,
+    SpvImageOperandsMax = 0x7fffffff,
+} SpvImageOperandsShift;
+
+typedef enum SpvImageOperandsMask_ {
+    SpvImageOperandsMaskNone = 0,
+    SpvImageOperandsBiasMask = 0x00000001,
+    SpvImageOperandsLodMask = 0x00000002,
+    SpvImageOperandsGradMask = 0x00000004,
+    SpvImageOperandsConstOffsetMask = 0x00000008,
+    SpvImageOperandsOffsetMask = 0x00000010,
+    SpvImageOperandsConstOffsetsMask = 0x00000020,
+    SpvImageOperandsSampleMask = 0x00000040,
+    SpvImageOperandsMinLodMask = 0x00000080,
+    SpvImageOperandsMakeTexelAvailableMask = 0x00000100,
+    SpvImageOperandsMakeTexelAvailableKHRMask = 0x00000100,
+    SpvImageOperandsMakeTexelVisibleMask = 0x00000200,
+    SpvImageOperandsMakeTexelVisibleKHRMask = 0x00000200,
+    SpvImageOperandsNonPrivateTexelMask = 0x00000400,
+    SpvImageOperandsNonPrivateTexelKHRMask = 0x00000400,
+    SpvImageOperandsVolatileTexelMask = 0x00000800,
+    SpvImageOperandsVolatileTexelKHRMask = 0x00000800,
+    SpvImageOperandsSignExtendMask = 0x00001000,
+    SpvImageOperandsZeroExtendMask = 0x00002000,
+} SpvImageOperandsMask;
+
+typedef enum SpvFPFastMathModeShift_ {
+    SpvFPFastMathModeNotNaNShift = 0,
+    SpvFPFastMathModeNotInfShift = 1,
+    SpvFPFastMathModeNSZShift = 2,
+    SpvFPFastMathModeAllowRecipShift = 3,
+    SpvFPFastMathModeFastShift = 4,
+    SpvFPFastMathModeMax = 0x7fffffff,
+} SpvFPFastMathModeShift;
+
+typedef enum SpvFPFastMathModeMask_ {
+    SpvFPFastMathModeMaskNone = 0,
+    SpvFPFastMathModeNotNaNMask = 0x00000001,
+    SpvFPFastMathModeNotInfMask = 0x00000002,
+    SpvFPFastMathModeNSZMask = 0x00000004,
+    SpvFPFastMathModeAllowRecipMask = 0x00000008,
+    SpvFPFastMathModeFastMask = 0x00000010,
+} SpvFPFastMathModeMask;
+
+typedef enum SpvFPRoundingMode_ {
+    SpvFPRoundingModeRTE = 0,
+    SpvFPRoundingModeRTZ = 1,
+    SpvFPRoundingModeRTP = 2,
+    SpvFPRoundingModeRTN = 3,
+    SpvFPRoundingModeMax = 0x7fffffff,
+} SpvFPRoundingMode;
+
+typedef enum SpvLinkageType_ {
+    SpvLinkageTypeExport = 0,
+    SpvLinkageTypeImport = 1,
+    SpvLinkageTypeMax = 0x7fffffff,
+} SpvLinkageType;
+
+typedef enum SpvAccessQualifier_ {
+    SpvAccessQualifierReadOnly = 0,
+    SpvAccessQualifierWriteOnly = 1,
+    SpvAccessQualifierReadWrite = 2,
+    SpvAccessQualifierMax = 0x7fffffff,
+} SpvAccessQualifier;
+
+typedef enum SpvFunctionParameterAttribute_ {
+    SpvFunctionParameterAttributeZext = 0,
+    SpvFunctionParameterAttributeSext = 1,
+    SpvFunctionParameterAttributeByVal = 2,
+    SpvFunctionParameterAttributeSret = 3,
+    SpvFunctionParameterAttributeNoAlias = 4,
+    SpvFunctionParameterAttributeNoCapture = 5,
+    SpvFunctionParameterAttributeNoWrite = 6,
+    SpvFunctionParameterAttributeNoReadWrite = 7,
+    SpvFunctionParameterAttributeMax = 0x7fffffff,
+} SpvFunctionParameterAttribute;
+
+typedef enum SpvDecoration_ {
+    SpvDecorationRelaxedPrecision = 0,
+    SpvDecorationSpecId = 1,
+    SpvDecorationBlock = 2,
+    SpvDecorationBufferBlock = 3,
+    SpvDecorationRowMajor = 4,
+    SpvDecorationColMajor = 5,
+    SpvDecorationArrayStride = 6,
+    SpvDecorationMatrixStride = 7,
+    SpvDecorationGLSLShared = 8,
+    SpvDecorationGLSLPacked = 9,
+    SpvDecorationCPacked = 10,
+    SpvDecorationBuiltIn = 11,
+    SpvDecorationNoPerspective = 13,
+    SpvDecorationFlat = 14,
+    SpvDecorationPatch = 15,
+    SpvDecorationCentroid = 16,
+    SpvDecorationSample = 17,
+    SpvDecorationInvariant = 18,
+    SpvDecorationRestrict = 19,
+    SpvDecorationAliased = 20,
+    SpvDecorationVolatile = 21,
+    SpvDecorationConstant = 22,
+    SpvDecorationCoherent = 23,
+    SpvDecorationNonWritable = 24,
+    SpvDecorationNonReadable = 25,
+    SpvDecorationUniform = 26,
+    SpvDecorationUniformId = 27,
+    SpvDecorationSaturatedConversion = 28,
+    SpvDecorationStream = 29,
+    SpvDecorationLocation = 30,
+    SpvDecorationComponent = 31,
+    SpvDecorationIndex = 32,
+    SpvDecorationBinding = 33,
+    SpvDecorationDescriptorSet = 34,
+    SpvDecorationOffset = 35,
+    SpvDecorationXfbBuffer = 36,
+    SpvDecorationXfbStride = 37,
+    SpvDecorationFuncParamAttr = 38,
+    SpvDecorationFPRoundingMode = 39,
+    SpvDecorationFPFastMathMode = 40,
+    SpvDecorationLinkageAttributes = 41,
+    SpvDecorationNoContraction = 42,
+    SpvDecorationInputAttachmentIndex = 43,
+    SpvDecorationAlignment = 44,
+    SpvDecorationMaxByteOffset = 45,
+    SpvDecorationAlignmentId = 46,
+    SpvDecorationMaxByteOffsetId = 47,
+    SpvDecorationNoSignedWrap = 4469,
+    SpvDecorationNoUnsignedWrap = 4470,
+    SpvDecorationExplicitInterpAMD = 4999,
+    SpvDecorationOverrideCoverageNV = 5248,
+    SpvDecorationPassthroughNV = 5250,
+    SpvDecorationViewportRelativeNV = 5252,
+    SpvDecorationSecondaryViewportRelativeNV = 5256,
+    SpvDecorationPerPrimitiveNV = 5271,
+    SpvDecorationPerViewNV = 5272,
+    SpvDecorationPerTaskNV = 5273,
+    SpvDecorationPerVertexNV = 5285,
+    SpvDecorationNonUniform = 5300,
+    SpvDecorationNonUniformEXT = 5300,
+    SpvDecorationRestrictPointer = 5355,
+    SpvDecorationRestrictPointerEXT = 5355,
+    SpvDecorationAliasedPointer = 5356,
+    SpvDecorationAliasedPointerEXT = 5356,
+    SpvDecorationCounterBuffer = 5634,
+    SpvDecorationHlslCounterBufferGOOGLE = 5634,
+    SpvDecorationHlslSemanticGOOGLE = 5635,
+    SpvDecorationUserSemantic = 5635,
+    SpvDecorationUserTypeGOOGLE = 5636,
+    SpvDecorationMax = 0x7fffffff,
+} SpvDecoration;
+
+typedef enum SpvBuiltIn_ {
+    SpvBuiltInPosition = 0,
+    SpvBuiltInPointSize = 1,
+    SpvBuiltInClipDistance = 3,
+    SpvBuiltInCullDistance = 4,
+    SpvBuiltInVertexId = 5,
+    SpvBuiltInInstanceId = 6,
+    SpvBuiltInPrimitiveId = 7,
+    SpvBuiltInInvocationId = 8,
+    SpvBuiltInLayer = 9,
+    SpvBuiltInViewportIndex = 10,
+    SpvBuiltInTessLevelOuter = 11,
+    SpvBuiltInTessLevelInner = 12,
+    SpvBuiltInTessCoord = 13,
+    SpvBuiltInPatchVertices = 14,
+    SpvBuiltInFragCoord = 15,
+    SpvBuiltInPointCoord = 16,
+    SpvBuiltInFrontFacing = 17,
+    SpvBuiltInSampleId = 18,
+    SpvBuiltInSamplePosition = 19,
+    SpvBuiltInSampleMask = 20,
+    SpvBuiltInFragDepth = 22,
+    SpvBuiltInHelperInvocation = 23,
+    SpvBuiltInNumWorkgroups = 24,
+    SpvBuiltInWorkgroupSize = 25,
+    SpvBuiltInWorkgroupId = 26,
+    SpvBuiltInLocalInvocationId = 27,
+    SpvBuiltInGlobalInvocationId = 28,
+    SpvBuiltInLocalInvocationIndex = 29,
+    SpvBuiltInWorkDim = 30,
+    SpvBuiltInGlobalSize = 31,
+    SpvBuiltInEnqueuedWorkgroupSize = 32,
+    SpvBuiltInGlobalOffset = 33,
+    SpvBuiltInGlobalLinearId = 34,
+    SpvBuiltInSubgroupSize = 36,
+    SpvBuiltInSubgroupMaxSize = 37,
+    SpvBuiltInNumSubgroups = 38,
+    SpvBuiltInNumEnqueuedSubgroups = 39,
+    SpvBuiltInSubgroupId = 40,
+    SpvBuiltInSubgroupLocalInvocationId = 41,
+    SpvBuiltInVertexIndex = 42,
+    SpvBuiltInInstanceIndex = 43,
+    SpvBuiltInSubgroupEqMask = 4416,
+    SpvBuiltInSubgroupEqMaskKHR = 4416,
+    SpvBuiltInSubgroupGeMask = 4417,
+    SpvBuiltInSubgroupGeMaskKHR = 4417,
+    SpvBuiltInSubgroupGtMask = 4418,
+    SpvBuiltInSubgroupGtMaskKHR = 4418,
+    SpvBuiltInSubgroupLeMask = 4419,
+    SpvBuiltInSubgroupLeMaskKHR = 4419,
+    SpvBuiltInSubgroupLtMask = 4420,
+    SpvBuiltInSubgroupLtMaskKHR = 4420,
+    SpvBuiltInBaseVertex = 4424,
+    SpvBuiltInBaseInstance = 4425,
+    SpvBuiltInDrawIndex = 4426,
+    SpvBuiltInDeviceIndex = 4438,
+    SpvBuiltInViewIndex = 4440,
+    SpvBuiltInBaryCoordNoPerspAMD = 4992,
+    SpvBuiltInBaryCoordNoPerspCentroidAMD = 4993,
+    SpvBuiltInBaryCoordNoPerspSampleAMD = 4994,
+    SpvBuiltInBaryCoordSmoothAMD = 4995,
+    SpvBuiltInBaryCoordSmoothCentroidAMD = 4996,
+    SpvBuiltInBaryCoordSmoothSampleAMD = 4997,
+    SpvBuiltInBaryCoordPullModelAMD = 4998,
+    SpvBuiltInFragStencilRefEXT = 5014,
+    SpvBuiltInViewportMaskNV = 5253,
+    SpvBuiltInSecondaryPositionNV = 5257,
+    SpvBuiltInSecondaryViewportMaskNV = 5258,
+    SpvBuiltInPositionPerViewNV = 5261,
+    SpvBuiltInViewportMaskPerViewNV = 5262,
+    SpvBuiltInFullyCoveredEXT = 5264,
+    SpvBuiltInTaskCountNV = 5274,
+    SpvBuiltInPrimitiveCountNV = 5275,
+    SpvBuiltInPrimitiveIndicesNV = 5276,
+    SpvBuiltInClipDistancePerViewNV = 5277,
+    SpvBuiltInCullDistancePerViewNV = 5278,
+    SpvBuiltInLayerPerViewNV = 5279,
+    SpvBuiltInMeshViewCountNV = 5280,
+    SpvBuiltInMeshViewIndicesNV = 5281,
+    SpvBuiltInBaryCoordNV = 5286,
+    SpvBuiltInBaryCoordNoPerspNV = 5287,
+    SpvBuiltInFragSizeEXT = 5292,
+    SpvBuiltInFragmentSizeNV = 5292,
+    SpvBuiltInFragInvocationCountEXT = 5293,
+    SpvBuiltInInvocationsPerPixelNV = 5293,
+    SpvBuiltInLaunchIdKHR = 5319,
+    SpvBuiltInLaunchIdNV = 5319,
+    SpvBuiltInLaunchSizeKHR = 5320,
+    SpvBuiltInLaunchSizeNV = 5320,
+    SpvBuiltInWorldRayOriginKHR = 5321,
+    SpvBuiltInWorldRayOriginNV = 5321,
+    SpvBuiltInWorldRayDirectionKHR = 5322,
+    SpvBuiltInWorldRayDirectionNV = 5322,
+    SpvBuiltInObjectRayOriginKHR = 5323,
+    SpvBuiltInObjectRayOriginNV = 5323,
+    SpvBuiltInObjectRayDirectionKHR = 5324,
+    SpvBuiltInObjectRayDirectionNV = 5324,
+    SpvBuiltInRayTminKHR = 5325,
+    SpvBuiltInRayTminNV = 5325,
+    SpvBuiltInRayTmaxKHR = 5326,
+    SpvBuiltInRayTmaxNV = 5326,
+    SpvBuiltInInstanceCustomIndexKHR = 5327,
+    SpvBuiltInInstanceCustomIndexNV = 5327,
+    SpvBuiltInObjectToWorldKHR = 5330,
+    SpvBuiltInObjectToWorldNV = 5330,
+    SpvBuiltInWorldToObjectKHR = 5331,
+    SpvBuiltInWorldToObjectNV = 5331,
+    SpvBuiltInHitTKHR = 5332,
+    SpvBuiltInHitTNV = 5332,
+    SpvBuiltInHitKindKHR = 5333,
+    SpvBuiltInHitKindNV = 5333,
+    SpvBuiltInIncomingRayFlagsKHR = 5351,
+    SpvBuiltInIncomingRayFlagsNV = 5351,
+    SpvBuiltInRayGeometryIndexKHR = 5352,
+    SpvBuiltInWarpsPerSMNV = 5374,
+    SpvBuiltInSMCountNV = 5375,
+    SpvBuiltInWarpIDNV = 5376,
+    SpvBuiltInSMIDNV = 5377,
+    SpvBuiltInMax = 0x7fffffff,
+} SpvBuiltIn;
+
+typedef enum SpvSelectionControlShift_ {
+    SpvSelectionControlFlattenShift = 0,
+    SpvSelectionControlDontFlattenShift = 1,
+    SpvSelectionControlMax = 0x7fffffff,
+} SpvSelectionControlShift;
+
+typedef enum SpvSelectionControlMask_ {
+    SpvSelectionControlMaskNone = 0,
+    SpvSelectionControlFlattenMask = 0x00000001,
+    SpvSelectionControlDontFlattenMask = 0x00000002,
+} SpvSelectionControlMask;
+
+typedef enum SpvLoopControlShift_ {
+    SpvLoopControlUnrollShift = 0,
+    SpvLoopControlDontUnrollShift = 1,
+    SpvLoopControlDependencyInfiniteShift = 2,
+    SpvLoopControlDependencyLengthShift = 3,
+    SpvLoopControlMinIterationsShift = 4,
+    SpvLoopControlMaxIterationsShift = 5,
+    SpvLoopControlIterationMultipleShift = 6,
+    SpvLoopControlPeelCountShift = 7,
+    SpvLoopControlPartialCountShift = 8,
+    SpvLoopControlMax = 0x7fffffff,
+} SpvLoopControlShift;
+
+typedef enum SpvLoopControlMask_ {
+    SpvLoopControlMaskNone = 0,
+    SpvLoopControlUnrollMask = 0x00000001,
+    SpvLoopControlDontUnrollMask = 0x00000002,
+    SpvLoopControlDependencyInfiniteMask = 0x00000004,
+    SpvLoopControlDependencyLengthMask = 0x00000008,
+    SpvLoopControlMinIterationsMask = 0x00000010,
+    SpvLoopControlMaxIterationsMask = 0x00000020,
+    SpvLoopControlIterationMultipleMask = 0x00000040,
+    SpvLoopControlPeelCountMask = 0x00000080,
+    SpvLoopControlPartialCountMask = 0x00000100,
+} SpvLoopControlMask;
+
+typedef enum SpvFunctionControlShift_ {
+    SpvFunctionControlInlineShift = 0,
+    SpvFunctionControlDontInlineShift = 1,
+    SpvFunctionControlPureShift = 2,
+    SpvFunctionControlConstShift = 3,
+    SpvFunctionControlMax = 0x7fffffff,
+} SpvFunctionControlShift;
+
+typedef enum SpvFunctionControlMask_ {
+    SpvFunctionControlMaskNone = 0,
+    SpvFunctionControlInlineMask = 0x00000001,
+    SpvFunctionControlDontInlineMask = 0x00000002,
+    SpvFunctionControlPureMask = 0x00000004,
+    SpvFunctionControlConstMask = 0x00000008,
+} SpvFunctionControlMask;
+
+typedef enum SpvMemorySemanticsShift_ {
+    SpvMemorySemanticsAcquireShift = 1,
+    SpvMemorySemanticsReleaseShift = 2,
+    SpvMemorySemanticsAcquireReleaseShift = 3,
+    SpvMemorySemanticsSequentiallyConsistentShift = 4,
+    SpvMemorySemanticsUniformMemoryShift = 6,
+    SpvMemorySemanticsSubgroupMemoryShift = 7,
+    SpvMemorySemanticsWorkgroupMemoryShift = 8,
+    SpvMemorySemanticsCrossWorkgroupMemoryShift = 9,
+    SpvMemorySemanticsAtomicCounterMemoryShift = 10,
+    SpvMemorySemanticsImageMemoryShift = 11,
+    SpvMemorySemanticsOutputMemoryShift = 12,
+    SpvMemorySemanticsOutputMemoryKHRShift = 12,
+    SpvMemorySemanticsMakeAvailableShift = 13,
+    SpvMemorySemanticsMakeAvailableKHRShift = 13,
+    SpvMemorySemanticsMakeVisibleShift = 14,
+    SpvMemorySemanticsMakeVisibleKHRShift = 14,
+    SpvMemorySemanticsVolatileShift = 15,
+    SpvMemorySemanticsMax = 0x7fffffff,
+} SpvMemorySemanticsShift;
+
+typedef enum SpvMemorySemanticsMask_ {
+    SpvMemorySemanticsMaskNone = 0,
+    SpvMemorySemanticsAcquireMask = 0x00000002,
+    SpvMemorySemanticsReleaseMask = 0x00000004,
+    SpvMemorySemanticsAcquireReleaseMask = 0x00000008,
+    SpvMemorySemanticsSequentiallyConsistentMask = 0x00000010,
+    SpvMemorySemanticsUniformMemoryMask = 0x00000040,
+    SpvMemorySemanticsSubgroupMemoryMask = 0x00000080,
+    SpvMemorySemanticsWorkgroupMemoryMask = 0x00000100,
+    SpvMemorySemanticsCrossWorkgroupMemoryMask = 0x00000200,
+    SpvMemorySemanticsAtomicCounterMemoryMask = 0x00000400,
+    SpvMemorySemanticsImageMemoryMask = 0x00000800,
+    SpvMemorySemanticsOutputMemoryMask = 0x00001000,
+    SpvMemorySemanticsOutputMemoryKHRMask = 0x00001000,
+    SpvMemorySemanticsMakeAvailableMask = 0x00002000,
+    SpvMemorySemanticsMakeAvailableKHRMask = 0x00002000,
+    SpvMemorySemanticsMakeVisibleMask = 0x00004000,
+    SpvMemorySemanticsMakeVisibleKHRMask = 0x00004000,
+    SpvMemorySemanticsVolatileMask = 0x00008000,
+} SpvMemorySemanticsMask;
+
+typedef enum SpvMemoryAccessShift_ {
+    SpvMemoryAccessVolatileShift = 0,
+    SpvMemoryAccessAlignedShift = 1,
+    SpvMemoryAccessNontemporalShift = 2,
+    SpvMemoryAccessMakePointerAvailableShift = 3,
+    SpvMemoryAccessMakePointerAvailableKHRShift = 3,
+    SpvMemoryAccessMakePointerVisibleShift = 4,
+    SpvMemoryAccessMakePointerVisibleKHRShift = 4,
+    SpvMemoryAccessNonPrivatePointerShift = 5,
+    SpvMemoryAccessNonPrivatePointerKHRShift = 5,
+    SpvMemoryAccessMax = 0x7fffffff,
+} SpvMemoryAccessShift;
+
+typedef enum SpvMemoryAccessMask_ {
+    SpvMemoryAccessMaskNone = 0,
+    SpvMemoryAccessVolatileMask = 0x00000001,
+    SpvMemoryAccessAlignedMask = 0x00000002,
+    SpvMemoryAccessNontemporalMask = 0x00000004,
+    SpvMemoryAccessMakePointerAvailableMask = 0x00000008,
+    SpvMemoryAccessMakePointerAvailableKHRMask = 0x00000008,
+    SpvMemoryAccessMakePointerVisibleMask = 0x00000010,
+    SpvMemoryAccessMakePointerVisibleKHRMask = 0x00000010,
+    SpvMemoryAccessNonPrivatePointerMask = 0x00000020,
+    SpvMemoryAccessNonPrivatePointerKHRMask = 0x00000020,
+} SpvMemoryAccessMask;
+
+typedef enum SpvScope_ {
+    SpvScopeCrossDevice = 0,
+    SpvScopeDevice = 1,
+    SpvScopeWorkgroup = 2,
+    SpvScopeSubgroup = 3,
+    SpvScopeInvocation = 4,
+    SpvScopeQueueFamily = 5,
+    SpvScopeQueueFamilyKHR = 5,
+    SpvScopeShaderCallKHR = 6,
+    SpvScopeMax = 0x7fffffff,
+} SpvScope;
+
+typedef enum SpvGroupOperation_ {
+    SpvGroupOperationReduce = 0,
+    SpvGroupOperationInclusiveScan = 1,
+    SpvGroupOperationExclusiveScan = 2,
+    SpvGroupOperationClusteredReduce = 3,
+    SpvGroupOperationPartitionedReduceNV = 6,
+    SpvGroupOperationPartitionedInclusiveScanNV = 7,
+    SpvGroupOperationPartitionedExclusiveScanNV = 8,
+    SpvGroupOperationMax = 0x7fffffff,
+} SpvGroupOperation;
+
+typedef enum SpvKernelEnqueueFlags_ {
+    SpvKernelEnqueueFlagsNoWait = 0,
+    SpvKernelEnqueueFlagsWaitKernel = 1,
+    SpvKernelEnqueueFlagsWaitWorkGroup = 2,
+    SpvKernelEnqueueFlagsMax = 0x7fffffff,
+} SpvKernelEnqueueFlags;
+
+typedef enum SpvKernelProfilingInfoShift_ {
+    SpvKernelProfilingInfoCmdExecTimeShift = 0,
+    SpvKernelProfilingInfoMax = 0x7fffffff,
+} SpvKernelProfilingInfoShift;
+
+typedef enum SpvKernelProfilingInfoMask_ {
+    SpvKernelProfilingInfoMaskNone = 0,
+    SpvKernelProfilingInfoCmdExecTimeMask = 0x00000001,
+} SpvKernelProfilingInfoMask;
+
+typedef enum SpvCapability_ {
+    SpvCapabilityMatrix = 0,
+    SpvCapabilityShader = 1,
+    SpvCapabilityGeometry = 2,
+    SpvCapabilityTessellation = 3,
+    SpvCapabilityAddresses = 4,
+    SpvCapabilityLinkage = 5,
+    SpvCapabilityKernel = 6,
+    SpvCapabilityVector16 = 7,
+    SpvCapabilityFloat16Buffer = 8,
+    SpvCapabilityFloat16 = 9,
+    SpvCapabilityFloat64 = 10,
+    SpvCapabilityInt64 = 11,
+    SpvCapabilityInt64Atomics = 12,
+    SpvCapabilityImageBasic = 13,
+    SpvCapabilityImageReadWrite = 14,
+    SpvCapabilityImageMipmap = 15,
+    SpvCapabilityPipes = 17,
+    SpvCapabilityGroups = 18,
+    SpvCapabilityDeviceEnqueue = 19,
+    SpvCapabilityLiteralSampler = 20,
+    SpvCapabilityAtomicStorage = 21,
+    SpvCapabilityInt16 = 22,
+    SpvCapabilityTessellationPointSize = 23,
+    SpvCapabilityGeometryPointSize = 24,
+    SpvCapabilityImageGatherExtended = 25,
+    SpvCapabilityStorageImageMultisample = 27,
+    SpvCapabilityUniformBufferArrayDynamicIndexing = 28,
+    SpvCapabilitySampledImageArrayDynamicIndexing = 29,
+    SpvCapabilityStorageBufferArrayDynamicIndexing = 30,
+    SpvCapabilityStorageImageArrayDynamicIndexing = 31,
+    SpvCapabilityClipDistance = 32,
+    SpvCapabilityCullDistance = 33,
+    SpvCapabilityImageCubeArray = 34,
+    SpvCapabilitySampleRateShading = 35,
+    SpvCapabilityImageRect = 36,
+    SpvCapabilitySampledRect = 37,
+    SpvCapabilityGenericPointer = 38,
+    SpvCapabilityInt8 = 39,
+    SpvCapabilityInputAttachment = 40,
+    SpvCapabilitySparseResidency = 41,
+    SpvCapabilityMinLod = 42,
+    SpvCapabilitySampled1D = 43,
+    SpvCapabilityImage1D = 44,
+    SpvCapabilitySampledCubeArray = 45,
+    SpvCapabilitySampledBuffer = 46,
+    SpvCapabilityImageBuffer = 47,
+    SpvCapabilityImageMSArray = 48,
+    SpvCapabilityStorageImageExtendedFormats = 49,
+    SpvCapabilityImageQuery = 50,
+    SpvCapabilityDerivativeControl = 51,
+    SpvCapabilityInterpolationFunction = 52,
+    SpvCapabilityTransformFeedback = 53,
+    SpvCapabilityGeometryStreams = 54,
+    SpvCapabilityStorageImageReadWithoutFormat = 55,
+    SpvCapabilityStorageImageWriteWithoutFormat = 56,
+    SpvCapabilityMultiViewport = 57,
+    SpvCapabilitySubgroupDispatch = 58,
+    SpvCapabilityNamedBarrier = 59,
+    SpvCapabilityPipeStorage = 60,
+    SpvCapabilityGroupNonUniform = 61,
+    SpvCapabilityGroupNonUniformVote = 62,
+    SpvCapabilityGroupNonUniformArithmetic = 63,
+    SpvCapabilityGroupNonUniformBallot = 64,
+    SpvCapabilityGroupNonUniformShuffle = 65,
+    SpvCapabilityGroupNonUniformShuffleRelative = 66,
+    SpvCapabilityGroupNonUniformClustered = 67,
+    SpvCapabilityGroupNonUniformQuad = 68,
+    SpvCapabilityShaderLayer = 69,
+    SpvCapabilityShaderViewportIndex = 70,
+    SpvCapabilitySubgroupBallotKHR = 4423,
+    SpvCapabilityDrawParameters = 4427,
+    SpvCapabilitySubgroupVoteKHR = 4431,
+    SpvCapabilityStorageBuffer16BitAccess = 4433,
+    SpvCapabilityStorageUniformBufferBlock16 = 4433,
+    SpvCapabilityStorageUniform16 = 4434,
+    SpvCapabilityUniformAndStorageBuffer16BitAccess = 4434,
+    SpvCapabilityStoragePushConstant16 = 4435,
+    SpvCapabilityStorageInputOutput16 = 4436,
+    SpvCapabilityDeviceGroup = 4437,
+    SpvCapabilityMultiView = 4439,
+    SpvCapabilityVariablePointersStorageBuffer = 4441,
+    SpvCapabilityVariablePointers = 4442,
+    SpvCapabilityAtomicStorageOps = 4445,
+    SpvCapabilitySampleMaskPostDepthCoverage = 4447,
+    SpvCapabilityStorageBuffer8BitAccess = 4448,
+    SpvCapabilityUniformAndStorageBuffer8BitAccess = 4449,
+    SpvCapabilityStoragePushConstant8 = 4450,
+    SpvCapabilityDenormPreserve = 4464,
+    SpvCapabilityDenormFlushToZero = 4465,
+    SpvCapabilitySignedZeroInfNanPreserve = 4466,
+    SpvCapabilityRoundingModeRTE = 4467,
+    SpvCapabilityRoundingModeRTZ = 4468,
+    SpvCapabilityRayQueryProvisionalKHR = 4471,
+    SpvCapabilityRayTraversalPrimitiveCullingProvisionalKHR = 4478,
+    SpvCapabilityFloat16ImageAMD = 5008,
+    SpvCapabilityImageGatherBiasLodAMD = 5009,
+    SpvCapabilityFragmentMaskAMD = 5010,
+    SpvCapabilityStencilExportEXT = 5013,
+    SpvCapabilityImageReadWriteLodAMD = 5015,
+    SpvCapabilityShaderClockKHR = 5055,
+    SpvCapabilitySampleMaskOverrideCoverageNV = 5249,
+    SpvCapabilityGeometryShaderPassthroughNV = 5251,
+    SpvCapabilityShaderViewportIndexLayerEXT = 5254,
+    SpvCapabilityShaderViewportIndexLayerNV = 5254,
+    SpvCapabilityShaderViewportMaskNV = 5255,
+    SpvCapabilityShaderStereoViewNV = 5259,
+    SpvCapabilityPerViewAttributesNV = 5260,
+    SpvCapabilityFragmentFullyCoveredEXT = 5265,
+    SpvCapabilityMeshShadingNV = 5266,
+    SpvCapabilityImageFootprintNV = 5282,
+    SpvCapabilityFragmentBarycentricNV = 5284,
+    SpvCapabilityComputeDerivativeGroupQuadsNV = 5288,
+    SpvCapabilityFragmentDensityEXT = 5291,
+    SpvCapabilityShadingRateNV = 5291,
+    SpvCapabilityGroupNonUniformPartitionedNV = 5297,
+    SpvCapabilityShaderNonUniform = 5301,
+    SpvCapabilityShaderNonUniformEXT = 5301,
+    SpvCapabilityRuntimeDescriptorArray = 5302,
+    SpvCapabilityRuntimeDescriptorArrayEXT = 5302,
+    SpvCapabilityInputAttachmentArrayDynamicIndexing = 5303,
+    SpvCapabilityInputAttachmentArrayDynamicIndexingEXT = 5303,
+    SpvCapabilityUniformTexelBufferArrayDynamicIndexing = 5304,
+    SpvCapabilityUniformTexelBufferArrayDynamicIndexingEXT = 5304,
+    SpvCapabilityStorageTexelBufferArrayDynamicIndexing = 5305,
+    SpvCapabilityStorageTexelBufferArrayDynamicIndexingEXT = 5305,
+    SpvCapabilityUniformBufferArrayNonUniformIndexing = 5306,
+    SpvCapabilityUniformBufferArrayNonUniformIndexingEXT = 5306,
+    SpvCapabilitySampledImageArrayNonUniformIndexing = 5307,
+    SpvCapabilitySampledImageArrayNonUniformIndexingEXT = 5307,
+    SpvCapabilityStorageBufferArrayNonUniformIndexing = 5308,
+    SpvCapabilityStorageBufferArrayNonUniformIndexingEXT = 5308,
+    SpvCapabilityStorageImageArrayNonUniformIndexing = 5309,
+    SpvCapabilityStorageImageArrayNonUniformIndexingEXT = 5309,
+    SpvCapabilityInputAttachmentArrayNonUniformIndexing = 5310,
+    SpvCapabilityInputAttachmentArrayNonUniformIndexingEXT = 5310,
+    SpvCapabilityUniformTexelBufferArrayNonUniformIndexing = 5311,
+    SpvCapabilityUniformTexelBufferArrayNonUniformIndexingEXT = 5311,
+    SpvCapabilityStorageTexelBufferArrayNonUniformIndexing = 5312,
+    SpvCapabilityStorageTexelBufferArrayNonUniformIndexingEXT = 5312,
+    SpvCapabilityRayTracingNV = 5340,
+    SpvCapabilityVulkanMemoryModel = 5345,
+    SpvCapabilityVulkanMemoryModelKHR = 5345,
+    SpvCapabilityVulkanMemoryModelDeviceScope = 5346,
+    SpvCapabilityVulkanMemoryModelDeviceScopeKHR = 5346,
+    SpvCapabilityPhysicalStorageBufferAddresses = 5347,
+    SpvCapabilityPhysicalStorageBufferAddressesEXT = 5347,
+    SpvCapabilityComputeDerivativeGroupLinearNV = 5350,
+    SpvCapabilityRayTracingProvisionalKHR = 5353,
+    SpvCapabilityCooperativeMatrixNV = 5357,
+    SpvCapabilityFragmentShaderSampleInterlockEXT = 5363,
+    SpvCapabilityFragmentShaderShadingRateInterlockEXT = 5372,
+    SpvCapabilityShaderSMBuiltinsNV = 5373,
+    SpvCapabilityFragmentShaderPixelInterlockEXT = 5378,
+    SpvCapabilityDemoteToHelperInvocationEXT = 5379,
+    SpvCapabilitySubgroupShuffleINTEL = 5568,
+    SpvCapabilitySubgroupBufferBlockIOINTEL = 5569,
+    SpvCapabilitySubgroupImageBlockIOINTEL = 5570,
+    SpvCapabilitySubgroupImageMediaBlockIOINTEL = 5579,
+    SpvCapabilityIntegerFunctions2INTEL = 5584,
+    SpvCapabilitySubgroupAvcMotionEstimationINTEL = 5696,
+    SpvCapabilitySubgroupAvcMotionEstimationIntraINTEL = 5697,
+    SpvCapabilitySubgroupAvcMotionEstimationChromaINTEL = 5698,
+    SpvCapabilityMax = 0x7fffffff,
+} SpvCapability;
+
+typedef enum SpvRayFlagsShift_ {
+    SpvRayFlagsOpaqueKHRShift = 0,
+    SpvRayFlagsNoOpaqueKHRShift = 1,
+    SpvRayFlagsTerminateOnFirstHitKHRShift = 2,
+    SpvRayFlagsSkipClosestHitShaderKHRShift = 3,
+    SpvRayFlagsCullBackFacingTrianglesKHRShift = 4,
+    SpvRayFlagsCullFrontFacingTrianglesKHRShift = 5,
+    SpvRayFlagsCullOpaqueKHRShift = 6,
+    SpvRayFlagsCullNoOpaqueKHRShift = 7,
+    SpvRayFlagsSkipTrianglesKHRShift = 8,
+    SpvRayFlagsSkipAABBsKHRShift = 9,
+    SpvRayFlagsMax = 0x7fffffff,
+} SpvRayFlagsShift;
+
+typedef enum SpvRayFlagsMask_ {
+    SpvRayFlagsMaskNone = 0,
+    SpvRayFlagsOpaqueKHRMask = 0x00000001,
+    SpvRayFlagsNoOpaqueKHRMask = 0x00000002,
+    SpvRayFlagsTerminateOnFirstHitKHRMask = 0x00000004,
+    SpvRayFlagsSkipClosestHitShaderKHRMask = 0x00000008,
+    SpvRayFlagsCullBackFacingTrianglesKHRMask = 0x00000010,
+    SpvRayFlagsCullFrontFacingTrianglesKHRMask = 0x00000020,
+    SpvRayFlagsCullOpaqueKHRMask = 0x00000040,
+    SpvRayFlagsCullNoOpaqueKHRMask = 0x00000080,
+    SpvRayFlagsSkipTrianglesKHRMask = 0x00000100,
+    SpvRayFlagsSkipAABBsKHRMask = 0x00000200,
+} SpvRayFlagsMask;
+
+typedef enum SpvRayQueryIntersection_ {
+    SpvRayQueryIntersectionRayQueryCandidateIntersectionKHR = 0,
+    SpvRayQueryIntersectionRayQueryCommittedIntersectionKHR = 1,
+    SpvRayQueryIntersectionMax = 0x7fffffff,
+} SpvRayQueryIntersection;
+
+typedef enum SpvRayQueryCommittedIntersectionType_ {
+    SpvRayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionNoneKHR = 0,
+    SpvRayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionTriangleKHR = 1,
+    SpvRayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionGeneratedKHR = 2,
+    SpvRayQueryCommittedIntersectionTypeMax = 0x7fffffff,
+} SpvRayQueryCommittedIntersectionType;
+
+typedef enum SpvRayQueryCandidateIntersectionType_ {
+    SpvRayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionTriangleKHR = 0,
+    SpvRayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionAABBKHR = 1,
+    SpvRayQueryCandidateIntersectionTypeMax = 0x7fffffff,
+} SpvRayQueryCandidateIntersectionType;
+
+typedef enum SpvOp_ {
+    SpvOpNop = 0,
+    SpvOpUndef = 1,
+    SpvOpSourceContinued = 2,
+    SpvOpSource = 3,
+    SpvOpSourceExtension = 4,
+    SpvOpName = 5,
+    SpvOpMemberName = 6,
+    SpvOpString = 7,
+    SpvOpLine = 8,
+    SpvOpExtension = 10,
+    SpvOpExtInstImport = 11,
+    SpvOpExtInst = 12,
+    SpvOpMemoryModel = 14,
+    SpvOpEntryPoint = 15,
+    SpvOpExecutionMode = 16,
+    SpvOpCapability = 17,
+    SpvOpTypeVoid = 19,
+    SpvOpTypeBool = 20,
+    SpvOpTypeInt = 21,
+    SpvOpTypeFloat = 22,
+    SpvOpTypeVector = 23,
+    SpvOpTypeMatrix = 24,
+    SpvOpTypeImage = 25,
+    SpvOpTypeSampler = 26,
+    SpvOpTypeSampledImage = 27,
+    SpvOpTypeArray = 28,
+    SpvOpTypeRuntimeArray = 29,
+    SpvOpTypeStruct = 30,
+    SpvOpTypeOpaque = 31,
+    SpvOpTypePointer = 32,
+    SpvOpTypeFunction = 33,
+    SpvOpTypeEvent = 34,
+    SpvOpTypeDeviceEvent = 35,
+    SpvOpTypeReserveId = 36,
+    SpvOpTypeQueue = 37,
+    SpvOpTypePipe = 38,
+    SpvOpTypeForwardPointer = 39,
+    SpvOpConstantTrue = 41,
+    SpvOpConstantFalse = 42,
+    SpvOpConstant = 43,
+    SpvOpConstantComposite = 44,
+    SpvOpConstantSampler = 45,
+    SpvOpConstantNull = 46,
+    SpvOpSpecConstantTrue = 48,
+    SpvOpSpecConstantFalse = 49,
+    SpvOpSpecConstant = 50,
+    SpvOpSpecConstantComposite = 51,
+    SpvOpSpecConstantOp = 52,
+    SpvOpFunction = 54,
+    SpvOpFunctionParameter = 55,
+    SpvOpFunctionEnd = 56,
+    SpvOpFunctionCall = 57,
+    SpvOpVariable = 59,
+    SpvOpImageTexelPointer = 60,
+    SpvOpLoad = 61,
+    SpvOpStore = 62,
+    SpvOpCopyMemory = 63,
+    SpvOpCopyMemorySized = 64,
+    SpvOpAccessChain = 65,
+    SpvOpInBoundsAccessChain = 66,
+    SpvOpPtrAccessChain = 67,
+    SpvOpArrayLength = 68,
+    SpvOpGenericPtrMemSemantics = 69,
+    SpvOpInBoundsPtrAccessChain = 70,
+    SpvOpDecorate = 71,
+    SpvOpMemberDecorate = 72,
+    SpvOpDecorationGroup = 73,
+    SpvOpGroupDecorate = 74,
+    SpvOpGroupMemberDecorate = 75,
+    SpvOpVectorExtractDynamic = 77,
+    SpvOpVectorInsertDynamic = 78,
+    SpvOpVectorShuffle = 79,
+    SpvOpCompositeConstruct = 80,
+    SpvOpCompositeExtract = 81,
+    SpvOpCompositeInsert = 82,
+    SpvOpCopyObject = 83,
+    SpvOpTranspose = 84,
+    SpvOpSampledImage = 86,
+    SpvOpImageSampleImplicitLod = 87,
+    SpvOpImageSampleExplicitLod = 88,
+    SpvOpImageSampleDrefImplicitLod = 89,
+    SpvOpImageSampleDrefExplicitLod = 90,
+    SpvOpImageSampleProjImplicitLod = 91,
+    SpvOpImageSampleProjExplicitLod = 92,
+    SpvOpImageSampleProjDrefImplicitLod = 93,
+    SpvOpImageSampleProjDrefExplicitLod = 94,
+    SpvOpImageFetch = 95,
+    SpvOpImageGather = 96,
+    SpvOpImageDrefGather = 97,
+    SpvOpImageRead = 98,
+    SpvOpImageWrite = 99,
+    SpvOpImage = 100,
+    SpvOpImageQueryFormat = 101,
+    SpvOpImageQueryOrder = 102,
+    SpvOpImageQuerySizeLod = 103,
+    SpvOpImageQuerySize = 104,
+    SpvOpImageQueryLod = 105,
+    SpvOpImageQueryLevels = 106,
+    SpvOpImageQuerySamples = 107,
+    SpvOpConvertFToU = 109,
+    SpvOpConvertFToS = 110,
+    SpvOpConvertSToF = 111,
+    SpvOpConvertUToF = 112,
+    SpvOpUConvert = 113,
+    SpvOpSConvert = 114,
+    SpvOpFConvert = 115,
+    SpvOpQuantizeToF16 = 116,
+    SpvOpConvertPtrToU = 117,
+    SpvOpSatConvertSToU = 118,
+    SpvOpSatConvertUToS = 119,
+    SpvOpConvertUToPtr = 120,
+    SpvOpPtrCastToGeneric = 121,
+    SpvOpGenericCastToPtr = 122,
+    SpvOpGenericCastToPtrExplicit = 123,
+    SpvOpBitcast = 124,
+    SpvOpSNegate = 126,
+    SpvOpFNegate = 127,
+    SpvOpIAdd = 128,
+    SpvOpFAdd = 129,
+    SpvOpISub = 130,
+    SpvOpFSub = 131,
+    SpvOpIMul = 132,
+    SpvOpFMul = 133,
+    SpvOpUDiv = 134,
+    SpvOpSDiv = 135,
+    SpvOpFDiv = 136,
+    SpvOpUMod = 137,
+    SpvOpSRem = 138,
+    SpvOpSMod = 139,
+    SpvOpFRem = 140,
+    SpvOpFMod = 141,
+    SpvOpVectorTimesScalar = 142,
+    SpvOpMatrixTimesScalar = 143,
+    SpvOpVectorTimesMatrix = 144,
+    SpvOpMatrixTimesVector = 145,
+    SpvOpMatrixTimesMatrix = 146,
+    SpvOpOuterProduct = 147,
+    SpvOpDot = 148,
+    SpvOpIAddCarry = 149,
+    SpvOpISubBorrow = 150,
+    SpvOpUMulExtended = 151,
+    SpvOpSMulExtended = 152,
+    SpvOpAny = 154,
+    SpvOpAll = 155,
+    SpvOpIsNan = 156,
+    SpvOpIsInf = 157,
+    SpvOpIsFinite = 158,
+    SpvOpIsNormal = 159,
+    SpvOpSignBitSet = 160,
+    SpvOpLessOrGreater = 161,
+    SpvOpOrdered = 162,
+    SpvOpUnordered = 163,
+    SpvOpLogicalEqual = 164,
+    SpvOpLogicalNotEqual = 165,
+    SpvOpLogicalOr = 166,
+    SpvOpLogicalAnd = 167,
+    SpvOpLogicalNot = 168,
+    SpvOpSelect = 169,
+    SpvOpIEqual = 170,
+    SpvOpINotEqual = 171,
+    SpvOpUGreaterThan = 172,
+    SpvOpSGreaterThan = 173,
+    SpvOpUGreaterThanEqual = 174,
+    SpvOpSGreaterThanEqual = 175,
+    SpvOpULessThan = 176,
+    SpvOpSLessThan = 177,
+    SpvOpULessThanEqual = 178,
+    SpvOpSLessThanEqual = 179,
+    SpvOpFOrdEqual = 180,
+    SpvOpFUnordEqual = 181,
+    SpvOpFOrdNotEqual = 182,
+    SpvOpFUnordNotEqual = 183,
+    SpvOpFOrdLessThan = 184,
+    SpvOpFUnordLessThan = 185,
+    SpvOpFOrdGreaterThan = 186,
+    SpvOpFUnordGreaterThan = 187,
+    SpvOpFOrdLessThanEqual = 188,
+    SpvOpFUnordLessThanEqual = 189,
+    SpvOpFOrdGreaterThanEqual = 190,
+    SpvOpFUnordGreaterThanEqual = 191,
+    SpvOpShiftRightLogical = 194,
+    SpvOpShiftRightArithmetic = 195,
+    SpvOpShiftLeftLogical = 196,
+    SpvOpBitwiseOr = 197,
+    SpvOpBitwiseXor = 198,
+    SpvOpBitwiseAnd = 199,
+    SpvOpNot = 200,
+    SpvOpBitFieldInsert = 201,
+    SpvOpBitFieldSExtract = 202,
+    SpvOpBitFieldUExtract = 203,
+    SpvOpBitReverse = 204,
+    SpvOpBitCount = 205,
+    SpvOpDPdx = 207,
+    SpvOpDPdy = 208,
+    SpvOpFwidth = 209,
+    SpvOpDPdxFine = 210,
+    SpvOpDPdyFine = 211,
+    SpvOpFwidthFine = 212,
+    SpvOpDPdxCoarse = 213,
+    SpvOpDPdyCoarse = 214,
+    SpvOpFwidthCoarse = 215,
+    SpvOpEmitVertex = 218,
+    SpvOpEndPrimitive = 219,
+    SpvOpEmitStreamVertex = 220,
+    SpvOpEndStreamPrimitive = 221,
+    SpvOpControlBarrier = 224,
+    SpvOpMemoryBarrier = 225,
+    SpvOpAtomicLoad = 227,
+    SpvOpAtomicStore = 228,
+    SpvOpAtomicExchange = 229,
+    SpvOpAtomicCompareExchange = 230,
+    SpvOpAtomicCompareExchangeWeak = 231,
+    SpvOpAtomicIIncrement = 232,
+    SpvOpAtomicIDecrement = 233,
+    SpvOpAtomicIAdd = 234,
+    SpvOpAtomicISub = 235,
+    SpvOpAtomicSMin = 236,
+    SpvOpAtomicUMin = 237,
+    SpvOpAtomicSMax = 238,
+    SpvOpAtomicUMax = 239,
+    SpvOpAtomicAnd = 240,
+    SpvOpAtomicOr = 241,
+    SpvOpAtomicXor = 242,
+    SpvOpPhi = 245,
+    SpvOpLoopMerge = 246,
+    SpvOpSelectionMerge = 247,
+    SpvOpLabel = 248,
+    SpvOpBranch = 249,
+    SpvOpBranchConditional = 250,
+    SpvOpSwitch = 251,
+    SpvOpKill = 252,
+    SpvOpReturn = 253,
+    SpvOpReturnValue = 254,
+    SpvOpUnreachable = 255,
+    SpvOpLifetimeStart = 256,
+    SpvOpLifetimeStop = 257,
+    SpvOpGroupAsyncCopy = 259,
+    SpvOpGroupWaitEvents = 260,
+    SpvOpGroupAll = 261,
+    SpvOpGroupAny = 262,
+    SpvOpGroupBroadcast = 263,
+    SpvOpGroupIAdd = 264,
+    SpvOpGroupFAdd = 265,
+    SpvOpGroupFMin = 266,
+    SpvOpGroupUMin = 267,
+    SpvOpGroupSMin = 268,
+    SpvOpGroupFMax = 269,
+    SpvOpGroupUMax = 270,
+    SpvOpGroupSMax = 271,
+    SpvOpReadPipe = 274,
+    SpvOpWritePipe = 275,
+    SpvOpReservedReadPipe = 276,
+    SpvOpReservedWritePipe = 277,
+    SpvOpReserveReadPipePackets = 278,
+    SpvOpReserveWritePipePackets = 279,
+    SpvOpCommitReadPipe = 280,
+    SpvOpCommitWritePipe = 281,
+    SpvOpIsValidReserveId = 282,
+    SpvOpGetNumPipePackets = 283,
+    SpvOpGetMaxPipePackets = 284,
+    SpvOpGroupReserveReadPipePackets = 285,
+    SpvOpGroupReserveWritePipePackets = 286,
+    SpvOpGroupCommitReadPipe = 287,
+    SpvOpGroupCommitWritePipe = 288,
+    SpvOpEnqueueMarker = 291,
+    SpvOpEnqueueKernel = 292,
+    SpvOpGetKernelNDrangeSubGroupCount = 293,
+    SpvOpGetKernelNDrangeMaxSubGroupSize = 294,
+    SpvOpGetKernelWorkGroupSize = 295,
+    SpvOpGetKernelPreferredWorkGroupSizeMultiple = 296,
+    SpvOpRetainEvent = 297,
+    SpvOpReleaseEvent = 298,
+    SpvOpCreateUserEvent = 299,
+    SpvOpIsValidEvent = 300,
+    SpvOpSetUserEventStatus = 301,
+    SpvOpCaptureEventProfilingInfo = 302,
+    SpvOpGetDefaultQueue = 303,
+    SpvOpBuildNDRange = 304,
+    SpvOpImageSparseSampleImplicitLod = 305,
+    SpvOpImageSparseSampleExplicitLod = 306,
+    SpvOpImageSparseSampleDrefImplicitLod = 307,
+    SpvOpImageSparseSampleDrefExplicitLod = 308,
+    SpvOpImageSparseSampleProjImplicitLod = 309,
+    SpvOpImageSparseSampleProjExplicitLod = 310,
+    SpvOpImageSparseSampleProjDrefImplicitLod = 311,
+    SpvOpImageSparseSampleProjDrefExplicitLod = 312,
+    SpvOpImageSparseFetch = 313,
+    SpvOpImageSparseGather = 314,
+    SpvOpImageSparseDrefGather = 315,
+    SpvOpImageSparseTexelsResident = 316,
+    SpvOpNoLine = 317,
+    SpvOpAtomicFlagTestAndSet = 318,
+    SpvOpAtomicFlagClear = 319,
+    SpvOpImageSparseRead = 320,
+    SpvOpSizeOf = 321,
+    SpvOpTypePipeStorage = 322,
+    SpvOpConstantPipeStorage = 323,
+    SpvOpCreatePipeFromPipeStorage = 324,
+    SpvOpGetKernelLocalSizeForSubgroupCount = 325,
+    SpvOpGetKernelMaxNumSubgroups = 326,
+    SpvOpTypeNamedBarrier = 327,
+    SpvOpNamedBarrierInitialize = 328,
+    SpvOpMemoryNamedBarrier = 329,
+    SpvOpModuleProcessed = 330,
+    SpvOpExecutionModeId = 331,
+    SpvOpDecorateId = 332,
+    SpvOpGroupNonUniformElect = 333,
+    SpvOpGroupNonUniformAll = 334,
+    SpvOpGroupNonUniformAny = 335,
+    SpvOpGroupNonUniformAllEqual = 336,
+    SpvOpGroupNonUniformBroadcast = 337,
+    SpvOpGroupNonUniformBroadcastFirst = 338,
+    SpvOpGroupNonUniformBallot = 339,
+    SpvOpGroupNonUniformInverseBallot = 340,
+    SpvOpGroupNonUniformBallotBitExtract = 341,
+    SpvOpGroupNonUniformBallotBitCount = 342,
+    SpvOpGroupNonUniformBallotFindLSB = 343,
+    SpvOpGroupNonUniformBallotFindMSB = 344,
+    SpvOpGroupNonUniformShuffle = 345,
+    SpvOpGroupNonUniformShuffleXor = 346,
+    SpvOpGroupNonUniformShuffleUp = 347,
+    SpvOpGroupNonUniformShuffleDown = 348,
+    SpvOpGroupNonUniformIAdd = 349,
+    SpvOpGroupNonUniformFAdd = 350,
+    SpvOpGroupNonUniformIMul = 351,
+    SpvOpGroupNonUniformFMul = 352,
+    SpvOpGroupNonUniformSMin = 353,
+    SpvOpGroupNonUniformUMin = 354,
+    SpvOpGroupNonUniformFMin = 355,
+    SpvOpGroupNonUniformSMax = 356,
+    SpvOpGroupNonUniformUMax = 357,
+    SpvOpGroupNonUniformFMax = 358,
+    SpvOpGroupNonUniformBitwiseAnd = 359,
+    SpvOpGroupNonUniformBitwiseOr = 360,
+    SpvOpGroupNonUniformBitwiseXor = 361,
+    SpvOpGroupNonUniformLogicalAnd = 362,
+    SpvOpGroupNonUniformLogicalOr = 363,
+    SpvOpGroupNonUniformLogicalXor = 364,
+    SpvOpGroupNonUniformQuadBroadcast = 365,
+    SpvOpGroupNonUniformQuadSwap = 366,
+    SpvOpCopyLogical = 400,
+    SpvOpPtrEqual = 401,
+    SpvOpPtrNotEqual = 402,
+    SpvOpPtrDiff = 403,
+    SpvOpSubgroupBallotKHR = 4421,
+    SpvOpSubgroupFirstInvocationKHR = 4422,
+    SpvOpSubgroupAllKHR = 4428,
+    SpvOpSubgroupAnyKHR = 4429,
+    SpvOpSubgroupAllEqualKHR = 4430,
+    SpvOpSubgroupReadInvocationKHR = 4432,
+    SpvOpTypeRayQueryProvisionalKHR = 4472,
+    SpvOpRayQueryInitializeKHR = 4473,
+    SpvOpRayQueryTerminateKHR = 4474,
+    SpvOpRayQueryGenerateIntersectionKHR = 4475,
+    SpvOpRayQueryConfirmIntersectionKHR = 4476,
+    SpvOpRayQueryProceedKHR = 4477,
+    SpvOpRayQueryGetIntersectionTypeKHR = 4479,
+    SpvOpGroupIAddNonUniformAMD = 5000,
+    SpvOpGroupFAddNonUniformAMD = 5001,
+    SpvOpGroupFMinNonUniformAMD = 5002,
+    SpvOpGroupUMinNonUniformAMD = 5003,
+    SpvOpGroupSMinNonUniformAMD = 5004,
+    SpvOpGroupFMaxNonUniformAMD = 5005,
+    SpvOpGroupUMaxNonUniformAMD = 5006,
+    SpvOpGroupSMaxNonUniformAMD = 5007,
+    SpvOpFragmentMaskFetchAMD = 5011,
+    SpvOpFragmentFetchAMD = 5012,
+    SpvOpReadClockKHR = 5056,
+    SpvOpImageSampleFootprintNV = 5283,
+    SpvOpGroupNonUniformPartitionNV = 5296,
+    SpvOpWritePackedPrimitiveIndices4x8NV = 5299,
+    SpvOpReportIntersectionKHR = 5334,
+    SpvOpReportIntersectionNV = 5334,
+    SpvOpIgnoreIntersectionKHR = 5335,
+    SpvOpIgnoreIntersectionNV = 5335,
+    SpvOpTerminateRayKHR = 5336,
+    SpvOpTerminateRayNV = 5336,
+    SpvOpTraceNV = 5337,
+    SpvOpTraceRayKHR = 5337,
+    SpvOpTypeAccelerationStructureKHR = 5341,
+    SpvOpTypeAccelerationStructureNV = 5341,
+    SpvOpExecuteCallableKHR = 5344,
+    SpvOpExecuteCallableNV = 5344,
+    SpvOpTypeCooperativeMatrixNV = 5358,
+    SpvOpCooperativeMatrixLoadNV = 5359,
+    SpvOpCooperativeMatrixStoreNV = 5360,
+    SpvOpCooperativeMatrixMulAddNV = 5361,
+    SpvOpCooperativeMatrixLengthNV = 5362,
+    SpvOpBeginInvocationInterlockEXT = 5364,
+    SpvOpEndInvocationInterlockEXT = 5365,
+    SpvOpDemoteToHelperInvocationEXT = 5380,
+    SpvOpIsHelperInvocationEXT = 5381,
+    SpvOpSubgroupShuffleINTEL = 5571,
+    SpvOpSubgroupShuffleDownINTEL = 5572,
+    SpvOpSubgroupShuffleUpINTEL = 5573,
+    SpvOpSubgroupShuffleXorINTEL = 5574,
+    SpvOpSubgroupBlockReadINTEL = 5575,
+    SpvOpSubgroupBlockWriteINTEL = 5576,
+    SpvOpSubgroupImageBlockReadINTEL = 5577,
+    SpvOpSubgroupImageBlockWriteINTEL = 5578,
+    SpvOpSubgroupImageMediaBlockReadINTEL = 5580,
+    SpvOpSubgroupImageMediaBlockWriteINTEL = 5581,
+    SpvOpUCountLeadingZerosINTEL = 5585,
+    SpvOpUCountTrailingZerosINTEL = 5586,
+    SpvOpAbsISubINTEL = 5587,
+    SpvOpAbsUSubINTEL = 5588,
+    SpvOpIAddSatINTEL = 5589,
+    SpvOpUAddSatINTEL = 5590,
+    SpvOpIAverageINTEL = 5591,
+    SpvOpUAverageINTEL = 5592,
+    SpvOpIAverageRoundedINTEL = 5593,
+    SpvOpUAverageRoundedINTEL = 5594,
+    SpvOpISubSatINTEL = 5595,
+    SpvOpUSubSatINTEL = 5596,
+    SpvOpIMul32x16INTEL = 5597,
+    SpvOpUMul32x16INTEL = 5598,
+    SpvOpDecorateString = 5632,
+    SpvOpDecorateStringGOOGLE = 5632,
+    SpvOpMemberDecorateString = 5633,
+    SpvOpMemberDecorateStringGOOGLE = 5633,
+    SpvOpVmeImageINTEL = 5699,
+    SpvOpTypeVmeImageINTEL = 5700,
+    SpvOpTypeAvcImePayloadINTEL = 5701,
+    SpvOpTypeAvcRefPayloadINTEL = 5702,
+    SpvOpTypeAvcSicPayloadINTEL = 5703,
+    SpvOpTypeAvcMcePayloadINTEL = 5704,
+    SpvOpTypeAvcMceResultINTEL = 5705,
+    SpvOpTypeAvcImeResultINTEL = 5706,
+    SpvOpTypeAvcImeResultSingleReferenceStreamoutINTEL = 5707,
+    SpvOpTypeAvcImeResultDualReferenceStreamoutINTEL = 5708,
+    SpvOpTypeAvcImeSingleReferenceStreaminINTEL = 5709,
+    SpvOpTypeAvcImeDualReferenceStreaminINTEL = 5710,
+    SpvOpTypeAvcRefResultINTEL = 5711,
+    SpvOpTypeAvcSicResultINTEL = 5712,
+    SpvOpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL = 5713,
+    SpvOpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL = 5714,
+    SpvOpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL = 5715,
+    SpvOpSubgroupAvcMceSetInterShapePenaltyINTEL = 5716,
+    SpvOpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL = 5717,
+    SpvOpSubgroupAvcMceSetInterDirectionPenaltyINTEL = 5718,
+    SpvOpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL = 5719,
+    SpvOpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL = 5720,
+    SpvOpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL = 5721,
+    SpvOpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL = 5722,
+    SpvOpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL = 5723,
+    SpvOpSubgroupAvcMceSetMotionVectorCostFunctionINTEL = 5724,
+    SpvOpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL = 5725,
+    SpvOpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL = 5726,
+    SpvOpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL = 5727,
+    SpvOpSubgroupAvcMceSetAcOnlyHaarINTEL = 5728,
+    SpvOpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL = 5729,
+    SpvOpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL = 5730,
+    SpvOpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL = 5731,
+    SpvOpSubgroupAvcMceConvertToImePayloadINTEL = 5732,
+    SpvOpSubgroupAvcMceConvertToImeResultINTEL = 5733,
+    SpvOpSubgroupAvcMceConvertToRefPayloadINTEL = 5734,
+    SpvOpSubgroupAvcMceConvertToRefResultINTEL = 5735,
+    SpvOpSubgroupAvcMceConvertToSicPayloadINTEL = 5736,
+    SpvOpSubgroupAvcMceConvertToSicResultINTEL = 5737,
+    SpvOpSubgroupAvcMceGetMotionVectorsINTEL = 5738,
+    SpvOpSubgroupAvcMceGetInterDistortionsINTEL = 5739,
+    SpvOpSubgroupAvcMceGetBestInterDistortionsINTEL = 5740,
+    SpvOpSubgroupAvcMceGetInterMajorShapeINTEL = 5741,
+    SpvOpSubgroupAvcMceGetInterMinorShapeINTEL = 5742,
+    SpvOpSubgroupAvcMceGetInterDirectionsINTEL = 5743,
+    SpvOpSubgroupAvcMceGetInterMotionVectorCountINTEL = 5744,
+    SpvOpSubgroupAvcMceGetInterReferenceIdsINTEL = 5745,
+    SpvOpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL = 5746,
+    SpvOpSubgroupAvcImeInitializeINTEL = 5747,
+    SpvOpSubgroupAvcImeSetSingleReferenceINTEL = 5748,
+    SpvOpSubgroupAvcImeSetDualReferenceINTEL = 5749,
+    SpvOpSubgroupAvcImeRefWindowSizeINTEL = 5750,
+    SpvOpSubgroupAvcImeAdjustRefOffsetINTEL = 5751,
+    SpvOpSubgroupAvcImeConvertToMcePayloadINTEL = 5752,
+    SpvOpSubgroupAvcImeSetMaxMotionVectorCountINTEL = 5753,
+    SpvOpSubgroupAvcImeSetUnidirectionalMixDisableINTEL = 5754,
+    SpvOpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL = 5755,
+    SpvOpSubgroupAvcImeSetWeightedSadINTEL = 5756,
+    SpvOpSubgroupAvcImeEvaluateWithSingleReferenceINTEL = 5757,
+    SpvOpSubgroupAvcImeEvaluateWithDualReferenceINTEL = 5758,
+    SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL = 5759,
+    SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL = 5760,
+    SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL = 5761,
+    SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL = 5762,
+    SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL = 5763,
+    SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL = 5764,
+    SpvOpSubgroupAvcImeConvertToMceResultINTEL = 5765,
+    SpvOpSubgroupAvcImeGetSingleReferenceStreaminINTEL = 5766,
+    SpvOpSubgroupAvcImeGetDualReferenceStreaminINTEL = 5767,
+    SpvOpSubgroupAvcImeStripSingleReferenceStreamoutINTEL = 5768,
+    SpvOpSubgroupAvcImeStripDualReferenceStreamoutINTEL = 5769,
+    SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL = 5770,
+    SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL = 5771,
+    SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL = 5772,
+    SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL = 5773,
+    SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL = 5774,
+    SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL = 5775,
+    SpvOpSubgroupAvcImeGetBorderReachedINTEL = 5776,
+    SpvOpSubgroupAvcImeGetTruncatedSearchIndicationINTEL = 5777,
+    SpvOpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL = 5778,
+    SpvOpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL = 5779,
+    SpvOpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL = 5780,
+    SpvOpSubgroupAvcFmeInitializeINTEL = 5781,
+    SpvOpSubgroupAvcBmeInitializeINTEL = 5782,
+    SpvOpSubgroupAvcRefConvertToMcePayloadINTEL = 5783,
+    SpvOpSubgroupAvcRefSetBidirectionalMixDisableINTEL = 5784,
+    SpvOpSubgroupAvcRefSetBilinearFilterEnableINTEL = 5785,
+    SpvOpSubgroupAvcRefEvaluateWithSingleReferenceINTEL = 5786,
+    SpvOpSubgroupAvcRefEvaluateWithDualReferenceINTEL = 5787,
+    SpvOpSubgroupAvcRefEvaluateWithMultiReferenceINTEL = 5788,
+    SpvOpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL = 5789,
+    SpvOpSubgroupAvcRefConvertToMceResultINTEL = 5790,
+    SpvOpSubgroupAvcSicInitializeINTEL = 5791,
+    SpvOpSubgroupAvcSicConfigureSkcINTEL = 5792,
+    SpvOpSubgroupAvcSicConfigureIpeLumaINTEL = 5793,
+    SpvOpSubgroupAvcSicConfigureIpeLumaChromaINTEL = 5794,
+    SpvOpSubgroupAvcSicGetMotionVectorMaskINTEL = 5795,
+    SpvOpSubgroupAvcSicConvertToMcePayloadINTEL = 5796,
+    SpvOpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL = 5797,
+    SpvOpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL = 5798,
+    SpvOpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL = 5799,
+    SpvOpSubgroupAvcSicSetBilinearFilterEnableINTEL = 5800,
+    SpvOpSubgroupAvcSicSetSkcForwardTransformEnableINTEL = 5801,
+    SpvOpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL = 5802,
+    SpvOpSubgroupAvcSicEvaluateIpeINTEL = 5803,
+    SpvOpSubgroupAvcSicEvaluateWithSingleReferenceINTEL = 5804,
+    SpvOpSubgroupAvcSicEvaluateWithDualReferenceINTEL = 5805,
+    SpvOpSubgroupAvcSicEvaluateWithMultiReferenceINTEL = 5806,
+    SpvOpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL = 5807,
+    SpvOpSubgroupAvcSicConvertToMceResultINTEL = 5808,
+    SpvOpSubgroupAvcSicGetIpeLumaShapeINTEL = 5809,
+    SpvOpSubgroupAvcSicGetBestIpeLumaDistortionINTEL = 5810,
+    SpvOpSubgroupAvcSicGetBestIpeChromaDistortionINTEL = 5811,
+    SpvOpSubgroupAvcSicGetPackedIpeLumaModesINTEL = 5812,
+    SpvOpSubgroupAvcSicGetIpeChromaModeINTEL = 5813,
+    SpvOpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL = 5814,
+    SpvOpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL = 5815,
+    SpvOpSubgroupAvcSicGetInterRawSadsINTEL = 5816,
+    SpvOpRayQueryGetRayTMinKHR = 6016,
+    SpvOpRayQueryGetRayFlagsKHR = 6017,
+    SpvOpRayQueryGetIntersectionTKHR = 6018,
+    SpvOpRayQueryGetIntersectionInstanceCustomIndexKHR = 6019,
+    SpvOpRayQueryGetIntersectionInstanceIdKHR = 6020,
+    SpvOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR = 6021,
+    SpvOpRayQueryGetIntersectionGeometryIndexKHR = 6022,
+    SpvOpRayQueryGetIntersectionPrimitiveIndexKHR = 6023,
+    SpvOpRayQueryGetIntersectionBarycentricsKHR = 6024,
+    SpvOpRayQueryGetIntersectionFrontFaceKHR = 6025,
+    SpvOpRayQueryGetIntersectionCandidateAABBOpaqueKHR = 6026,
+    SpvOpRayQueryGetIntersectionObjectRayDirectionKHR = 6027,
+    SpvOpRayQueryGetIntersectionObjectRayOriginKHR = 6028,
+    SpvOpRayQueryGetWorldRayDirectionKHR = 6029,
+    SpvOpRayQueryGetWorldRayOriginKHR = 6030,
+    SpvOpRayQueryGetIntersectionObjectToWorldKHR = 6031,
+    SpvOpRayQueryGetIntersectionWorldToObjectKHR = 6032,
+    SpvOpMax = 0x7fffffff,
+} SpvOp;
+
+#ifdef SPV_ENABLE_UTILITY_CODE
+inline void SpvHasResultAndType(SpvOp opcode, bool *hasResult, bool *hasResultType) {
+    *hasResult = *hasResultType = false;
+    switch (opcode) {
+    default: /* unknown opcode */ break;
+    case SpvOpNop: *hasResult = false; *hasResultType = false; break;
+    case SpvOpUndef: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSourceContinued: *hasResult = false; *hasResultType = false; break;
+    case SpvOpSource: *hasResult = false; *hasResultType = false; break;
+    case SpvOpSourceExtension: *hasResult = false; *hasResultType = false; break;
+    case SpvOpName: *hasResult = false; *hasResultType = false; break;
+    case SpvOpMemberName: *hasResult = false; *hasResultType = false; break;
+    case SpvOpString: *hasResult = true; *hasResultType = false; break;
+    case SpvOpLine: *hasResult = false; *hasResultType = false; break;
+    case SpvOpExtension: *hasResult = false; *hasResultType = false; break;
+    case SpvOpExtInstImport: *hasResult = true; *hasResultType = false; break;
+    case SpvOpExtInst: *hasResult = true; *hasResultType = true; break;
+    case SpvOpMemoryModel: *hasResult = false; *hasResultType = false; break;
+    case SpvOpEntryPoint: *hasResult = false; *hasResultType = false; break;
+    case SpvOpExecutionMode: *hasResult = false; *hasResultType = false; break;
+    case SpvOpCapability: *hasResult = false; *hasResultType = false; break;
+    case SpvOpTypeVoid: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeBool: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeInt: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeFloat: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeVector: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeMatrix: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeImage: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeSampler: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeSampledImage: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeArray: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeRuntimeArray: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeStruct: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeOpaque: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypePointer: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeFunction: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeEvent: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeDeviceEvent: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeReserveId: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeQueue: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypePipe: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeForwardPointer: *hasResult = false; *hasResultType = false; break;
+    case SpvOpConstantTrue: *hasResult = true; *hasResultType = true; break;
+    case SpvOpConstantFalse: *hasResult = true; *hasResultType = true; break;
+    case SpvOpConstant: *hasResult = true; *hasResultType = true; break;
+    case SpvOpConstantComposite: *hasResult = true; *hasResultType = true; break;
+    case SpvOpConstantSampler: *hasResult = true; *hasResultType = true; break;
+    case SpvOpConstantNull: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSpecConstantTrue: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSpecConstantFalse: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSpecConstant: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSpecConstantComposite: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSpecConstantOp: *hasResult = true; *hasResultType = true; break;
+    case SpvOpFunction: *hasResult = true; *hasResultType = true; break;
+    case SpvOpFunctionParameter: *hasResult = true; *hasResultType = true; break;
+    case SpvOpFunctionEnd: *hasResult = false; *hasResultType = false; break;
+    case SpvOpFunctionCall: *hasResult = true; *hasResultType = true; break;
+    case SpvOpVariable: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageTexelPointer: *hasResult = true; *hasResultType = true; break;
+    case SpvOpLoad: *hasResult = true; *hasResultType = true; break;
+    case SpvOpStore: *hasResult = false; *hasResultType = false; break;
+    case SpvOpCopyMemory: *hasResult = false; *hasResultType = false; break;
+    case SpvOpCopyMemorySized: *hasResult = false; *hasResultType = false; break;
+    case SpvOpAccessChain: *hasResult = true; *hasResultType = true; break;
+    case SpvOpInBoundsAccessChain: *hasResult = true; *hasResultType = true; break;
+    case SpvOpPtrAccessChain: *hasResult = true; *hasResultType = true; break;
+    case SpvOpArrayLength: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGenericPtrMemSemantics: *hasResult = true; *hasResultType = true; break;
+    case SpvOpInBoundsPtrAccessChain: *hasResult = true; *hasResultType = true; break;
+    case SpvOpDecorate: *hasResult = false; *hasResultType = false; break;
+    case SpvOpMemberDecorate: *hasResult = false; *hasResultType = false; break;
+    case SpvOpDecorationGroup: *hasResult = true; *hasResultType = false; break;
+    case SpvOpGroupDecorate: *hasResult = false; *hasResultType = false; break;
+    case SpvOpGroupMemberDecorate: *hasResult = false; *hasResultType = false; break;
+    case SpvOpVectorExtractDynamic: *hasResult = true; *hasResultType = true; break;
+    case SpvOpVectorInsertDynamic: *hasResult = true; *hasResultType = true; break;
+    case SpvOpVectorShuffle: *hasResult = true; *hasResultType = true; break;
+    case SpvOpCompositeConstruct: *hasResult = true; *hasResultType = true; break;
+    case SpvOpCompositeExtract: *hasResult = true; *hasResultType = true; break;
+    case SpvOpCompositeInsert: *hasResult = true; *hasResultType = true; break;
+    case SpvOpCopyObject: *hasResult = true; *hasResultType = true; break;
+    case SpvOpTranspose: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSampledImage: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageSampleImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageSampleExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageFetch: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageGather: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageDrefGather: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageRead: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageWrite: *hasResult = false; *hasResultType = false; break;
+    case SpvOpImage: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageQueryFormat: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageQueryOrder: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageQuerySizeLod: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageQuerySize: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageQueryLod: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageQueryLevels: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageQuerySamples: *hasResult = true; *hasResultType = true; break;
+    case SpvOpConvertFToU: *hasResult = true; *hasResultType = true; break;
+    case SpvOpConvertFToS: *hasResult = true; *hasResultType = true; break;
+    case SpvOpConvertSToF: *hasResult = true; *hasResultType = true; break;
+    case SpvOpConvertUToF: *hasResult = true; *hasResultType = true; break;
+    case SpvOpUConvert: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSConvert: *hasResult = true; *hasResultType = true; break;
+    case SpvOpFConvert: *hasResult = true; *hasResultType = true; break;
+    case SpvOpQuantizeToF16: *hasResult = true; *hasResultType = true; break;
+    case SpvOpConvertPtrToU: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSatConvertSToU: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSatConvertUToS: *hasResult = true; *hasResultType = true; break;
+    case SpvOpConvertUToPtr: *hasResult = true; *hasResultType = true; break;
+    case SpvOpPtrCastToGeneric: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGenericCastToPtr: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGenericCastToPtrExplicit: *hasResult = true; *hasResultType = true; break;
+    case SpvOpBitcast: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSNegate: *hasResult = true; *hasResultType = true; break;
+    case SpvOpFNegate: *hasResult = true; *hasResultType = true; break;
+    case SpvOpIAdd: *hasResult = true; *hasResultType = true; break;
+    case SpvOpFAdd: *hasResult = true; *hasResultType = true; break;
+    case SpvOpISub: *hasResult = true; *hasResultType = true; break;
+    case SpvOpFSub: *hasResult = true; *hasResultType = true; break;
+    case SpvOpIMul: *hasResult = true; *hasResultType = true; break;
+    case SpvOpFMul: *hasResult = true; *hasResultType = true; break;
+    case SpvOpUDiv: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSDiv: *hasResult = true; *hasResultType = true; break;
+    case SpvOpFDiv: *hasResult = true; *hasResultType = true; break;
+    case SpvOpUMod: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSRem: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSMod: *hasResult = true; *hasResultType = true; break;
+    case SpvOpFRem: *hasResult = true; *hasResultType = true; break;
+    case SpvOpFMod: *hasResult = true; *hasResultType = true; break;
+    case SpvOpVectorTimesScalar: *hasResult = true; *hasResultType = true; break;
+    case SpvOpMatrixTimesScalar: *hasResult = true; *hasResultType = true; break;
+    case SpvOpVectorTimesMatrix: *hasResult = true; *hasResultType = true; break;
+    case SpvOpMatrixTimesVector: *hasResult = true; *hasResultType = true; break;
+    case SpvOpMatrixTimesMatrix: *hasResult = true; *hasResultType = true; break;
+    case SpvOpOuterProduct: *hasResult = true; *hasResultType = true; break;
+    case SpvOpDot: *hasResult = true; *hasResultType = true; break;
+    case SpvOpIAddCarry: *hasResult = true; *hasResultType = true; break;
+    case SpvOpISubBorrow: *hasResult = true; *hasResultType = true; break;
+    case SpvOpUMulExtended: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSMulExtended: *hasResult = true; *hasResultType = true; break;
+    case SpvOpAny: *hasResult = true; *hasResultType = true; break;
+    case SpvOpAll: *hasResult = true; *hasResultType = true; break;
+    case SpvOpIsNan: *hasResult = true; *hasResultType = true; break;
+    case SpvOpIsInf: *hasResult = true; *hasResultType = true; break;
+    case SpvOpIsFinite: *hasResult = true; *hasResultType = true; break;
+    case SpvOpIsNormal: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSignBitSet: *hasResult = true; *hasResultType = true; break;
+    case SpvOpLessOrGreater: *hasResult = true; *hasResultType = true; break;
+    case SpvOpOrdered: *hasResult = true; *hasResultType = true; break;
+    case SpvOpUnordered: *hasResult = true; *hasResultType = true; break;
+    case SpvOpLogicalEqual: *hasResult = true; *hasResultType = true; break;
+    case SpvOpLogicalNotEqual: *hasResult = true; *hasResultType = true; break;
+    case SpvOpLogicalOr: *hasResult = true; *hasResultType = true; break;
+    case SpvOpLogicalAnd: *hasResult = true; *hasResultType = true; break;
+    case SpvOpLogicalNot: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSelect: *hasResult = true; *hasResultType = true; break;
+    case SpvOpIEqual: *hasResult = true; *hasResultType = true; break;
+    case SpvOpINotEqual: *hasResult = true; *hasResultType = true; break;
+    case SpvOpUGreaterThan: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSGreaterThan: *hasResult = true; *hasResultType = true; break;
+    case SpvOpUGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
+    case SpvOpULessThan: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSLessThan: *hasResult = true; *hasResultType = true; break;
+    case SpvOpULessThanEqual: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSLessThanEqual: *hasResult = true; *hasResultType = true; break;
+    case SpvOpFOrdEqual: *hasResult = true; *hasResultType = true; break;
+    case SpvOpFUnordEqual: *hasResult = true; *hasResultType = true; break;
+    case SpvOpFOrdNotEqual: *hasResult = true; *hasResultType = true; break;
+    case SpvOpFUnordNotEqual: *hasResult = true; *hasResultType = true; break;
+    case SpvOpFOrdLessThan: *hasResult = true; *hasResultType = true; break;
+    case SpvOpFUnordLessThan: *hasResult = true; *hasResultType = true; break;
+    case SpvOpFOrdGreaterThan: *hasResult = true; *hasResultType = true; break;
+    case SpvOpFUnordGreaterThan: *hasResult = true; *hasResultType = true; break;
+    case SpvOpFOrdLessThanEqual: *hasResult = true; *hasResultType = true; break;
+    case SpvOpFUnordLessThanEqual: *hasResult = true; *hasResultType = true; break;
+    case SpvOpFOrdGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
+    case SpvOpFUnordGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
+    case SpvOpShiftRightLogical: *hasResult = true; *hasResultType = true; break;
+    case SpvOpShiftRightArithmetic: *hasResult = true; *hasResultType = true; break;
+    case SpvOpShiftLeftLogical: *hasResult = true; *hasResultType = true; break;
+    case SpvOpBitwiseOr: *hasResult = true; *hasResultType = true; break;
+    case SpvOpBitwiseXor: *hasResult = true; *hasResultType = true; break;
+    case SpvOpBitwiseAnd: *hasResult = true; *hasResultType = true; break;
+    case SpvOpNot: *hasResult = true; *hasResultType = true; break;
+    case SpvOpBitFieldInsert: *hasResult = true; *hasResultType = true; break;
+    case SpvOpBitFieldSExtract: *hasResult = true; *hasResultType = true; break;
+    case SpvOpBitFieldUExtract: *hasResult = true; *hasResultType = true; break;
+    case SpvOpBitReverse: *hasResult = true; *hasResultType = true; break;
+    case SpvOpBitCount: *hasResult = true; *hasResultType = true; break;
+    case SpvOpDPdx: *hasResult = true; *hasResultType = true; break;
+    case SpvOpDPdy: *hasResult = true; *hasResultType = true; break;
+    case SpvOpFwidth: *hasResult = true; *hasResultType = true; break;
+    case SpvOpDPdxFine: *hasResult = true; *hasResultType = true; break;
+    case SpvOpDPdyFine: *hasResult = true; *hasResultType = true; break;
+    case SpvOpFwidthFine: *hasResult = true; *hasResultType = true; break;
+    case SpvOpDPdxCoarse: *hasResult = true; *hasResultType = true; break;
+    case SpvOpDPdyCoarse: *hasResult = true; *hasResultType = true; break;
+    case SpvOpFwidthCoarse: *hasResult = true; *hasResultType = true; break;
+    case SpvOpEmitVertex: *hasResult = false; *hasResultType = false; break;
+    case SpvOpEndPrimitive: *hasResult = false; *hasResultType = false; break;
+    case SpvOpEmitStreamVertex: *hasResult = false; *hasResultType = false; break;
+    case SpvOpEndStreamPrimitive: *hasResult = false; *hasResultType = false; break;
+    case SpvOpControlBarrier: *hasResult = false; *hasResultType = false; break;
+    case SpvOpMemoryBarrier: *hasResult = false; *hasResultType = false; break;
+    case SpvOpAtomicLoad: *hasResult = true; *hasResultType = true; break;
+    case SpvOpAtomicStore: *hasResult = false; *hasResultType = false; break;
+    case SpvOpAtomicExchange: *hasResult = true; *hasResultType = true; break;
+    case SpvOpAtomicCompareExchange: *hasResult = true; *hasResultType = true; break;
+    case SpvOpAtomicCompareExchangeWeak: *hasResult = true; *hasResultType = true; break;
+    case SpvOpAtomicIIncrement: *hasResult = true; *hasResultType = true; break;
+    case SpvOpAtomicIDecrement: *hasResult = true; *hasResultType = true; break;
+    case SpvOpAtomicIAdd: *hasResult = true; *hasResultType = true; break;
+    case SpvOpAtomicISub: *hasResult = true; *hasResultType = true; break;
+    case SpvOpAtomicSMin: *hasResult = true; *hasResultType = true; break;
+    case SpvOpAtomicUMin: *hasResult = true; *hasResultType = true; break;
+    case SpvOpAtomicSMax: *hasResult = true; *hasResultType = true; break;
+    case SpvOpAtomicUMax: *hasResult = true; *hasResultType = true; break;
+    case SpvOpAtomicAnd: *hasResult = true; *hasResultType = true; break;
+    case SpvOpAtomicOr: *hasResult = true; *hasResultType = true; break;
+    case SpvOpAtomicXor: *hasResult = true; *hasResultType = true; break;
+    case SpvOpPhi: *hasResult = true; *hasResultType = true; break;
+    case SpvOpLoopMerge: *hasResult = false; *hasResultType = false; break;
+    case SpvOpSelectionMerge: *hasResult = false; *hasResultType = false; break;
+    case SpvOpLabel: *hasResult = true; *hasResultType = false; break;
+    case SpvOpBranch: *hasResult = false; *hasResultType = false; break;
+    case SpvOpBranchConditional: *hasResult = false; *hasResultType = false; break;
+    case SpvOpSwitch: *hasResult = false; *hasResultType = false; break;
+    case SpvOpKill: *hasResult = false; *hasResultType = false; break;
+    case SpvOpReturn: *hasResult = false; *hasResultType = false; break;
+    case SpvOpReturnValue: *hasResult = false; *hasResultType = false; break;
+    case SpvOpUnreachable: *hasResult = false; *hasResultType = false; break;
+    case SpvOpLifetimeStart: *hasResult = false; *hasResultType = false; break;
+    case SpvOpLifetimeStop: *hasResult = false; *hasResultType = false; break;
+    case SpvOpGroupAsyncCopy: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupWaitEvents: *hasResult = false; *hasResultType = false; break;
+    case SpvOpGroupAll: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupAny: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupBroadcast: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupIAdd: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupFAdd: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupFMin: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupUMin: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupSMin: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupFMax: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupUMax: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupSMax: *hasResult = true; *hasResultType = true; break;
+    case SpvOpReadPipe: *hasResult = true; *hasResultType = true; break;
+    case SpvOpWritePipe: *hasResult = true; *hasResultType = true; break;
+    case SpvOpReservedReadPipe: *hasResult = true; *hasResultType = true; break;
+    case SpvOpReservedWritePipe: *hasResult = true; *hasResultType = true; break;
+    case SpvOpReserveReadPipePackets: *hasResult = true; *hasResultType = true; break;
+    case SpvOpReserveWritePipePackets: *hasResult = true; *hasResultType = true; break;
+    case SpvOpCommitReadPipe: *hasResult = false; *hasResultType = false; break;
+    case SpvOpCommitWritePipe: *hasResult = false; *hasResultType = false; break;
+    case SpvOpIsValidReserveId: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGetNumPipePackets: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGetMaxPipePackets: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupReserveReadPipePackets: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupReserveWritePipePackets: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupCommitReadPipe: *hasResult = false; *hasResultType = false; break;
+    case SpvOpGroupCommitWritePipe: *hasResult = false; *hasResultType = false; break;
+    case SpvOpEnqueueMarker: *hasResult = true; *hasResultType = true; break;
+    case SpvOpEnqueueKernel: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGetKernelNDrangeSubGroupCount: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGetKernelNDrangeMaxSubGroupSize: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGetKernelWorkGroupSize: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGetKernelPreferredWorkGroupSizeMultiple: *hasResult = true; *hasResultType = true; break;
+    case SpvOpRetainEvent: *hasResult = false; *hasResultType = false; break;
+    case SpvOpReleaseEvent: *hasResult = false; *hasResultType = false; break;
+    case SpvOpCreateUserEvent: *hasResult = true; *hasResultType = true; break;
+    case SpvOpIsValidEvent: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSetUserEventStatus: *hasResult = false; *hasResultType = false; break;
+    case SpvOpCaptureEventProfilingInfo: *hasResult = false; *hasResultType = false; break;
+    case SpvOpGetDefaultQueue: *hasResult = true; *hasResultType = true; break;
+    case SpvOpBuildNDRange: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageSparseSampleImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageSparseSampleExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageSparseSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageSparseSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageSparseSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageSparseSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageSparseSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageSparseSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageSparseFetch: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageSparseGather: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageSparseDrefGather: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageSparseTexelsResident: *hasResult = true; *hasResultType = true; break;
+    case SpvOpNoLine: *hasResult = false; *hasResultType = false; break;
+    case SpvOpAtomicFlagTestAndSet: *hasResult = true; *hasResultType = true; break;
+    case SpvOpAtomicFlagClear: *hasResult = false; *hasResultType = false; break;
+    case SpvOpImageSparseRead: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSizeOf: *hasResult = true; *hasResultType = true; break;
+    case SpvOpTypePipeStorage: *hasResult = true; *hasResultType = false; break;
+    case SpvOpConstantPipeStorage: *hasResult = true; *hasResultType = true; break;
+    case SpvOpCreatePipeFromPipeStorage: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGetKernelLocalSizeForSubgroupCount: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGetKernelMaxNumSubgroups: *hasResult = true; *hasResultType = true; break;
+    case SpvOpTypeNamedBarrier: *hasResult = true; *hasResultType = false; break;
+    case SpvOpNamedBarrierInitialize: *hasResult = true; *hasResultType = true; break;
+    case SpvOpMemoryNamedBarrier: *hasResult = false; *hasResultType = false; break;
+    case SpvOpModuleProcessed: *hasResult = false; *hasResultType = false; break;
+    case SpvOpExecutionModeId: *hasResult = false; *hasResultType = false; break;
+    case SpvOpDecorateId: *hasResult = false; *hasResultType = false; break;
+    case SpvOpGroupNonUniformElect: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformAll: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformAny: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformAllEqual: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformBroadcast: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformBroadcastFirst: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformBallot: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformInverseBallot: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformBallotBitExtract: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformBallotBitCount: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformBallotFindLSB: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformBallotFindMSB: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformShuffle: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformShuffleXor: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformShuffleUp: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformShuffleDown: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformIAdd: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformFAdd: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformIMul: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformFMul: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformSMin: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformUMin: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformFMin: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformSMax: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformUMax: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformFMax: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformBitwiseAnd: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformBitwiseOr: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformBitwiseXor: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformLogicalAnd: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformLogicalOr: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformLogicalXor: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformQuadBroadcast: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformQuadSwap: *hasResult = true; *hasResultType = true; break;
+    case SpvOpCopyLogical: *hasResult = true; *hasResultType = true; break;
+    case SpvOpPtrEqual: *hasResult = true; *hasResultType = true; break;
+    case SpvOpPtrNotEqual: *hasResult = true; *hasResultType = true; break;
+    case SpvOpPtrDiff: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupBallotKHR: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupFirstInvocationKHR: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAllKHR: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAnyKHR: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAllEqualKHR: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break;
+    case SpvOpTypeRayQueryProvisionalKHR: *hasResult = true; *hasResultType = false; break;
+    case SpvOpRayQueryInitializeKHR: *hasResult = false; *hasResultType = false; break;
+    case SpvOpRayQueryTerminateKHR: *hasResult = false; *hasResultType = false; break;
+    case SpvOpRayQueryGenerateIntersectionKHR: *hasResult = false; *hasResultType = false; break;
+    case SpvOpRayQueryConfirmIntersectionKHR: *hasResult = false; *hasResultType = false; break;
+    case SpvOpRayQueryProceedKHR: *hasResult = true; *hasResultType = true; break;
+    case SpvOpRayQueryGetIntersectionTypeKHR: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupIAddNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupFAddNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupFMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupUMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupSMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupFMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupUMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupSMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case SpvOpFragmentMaskFetchAMD: *hasResult = true; *hasResultType = true; break;
+    case SpvOpFragmentFetchAMD: *hasResult = true; *hasResultType = true; break;
+    case SpvOpReadClockKHR: *hasResult = true; *hasResultType = true; break;
+    case SpvOpImageSampleFootprintNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpGroupNonUniformPartitionNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpWritePackedPrimitiveIndices4x8NV: *hasResult = false; *hasResultType = false; break;
+    case SpvOpReportIntersectionNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpIgnoreIntersectionNV: *hasResult = false; *hasResultType = false; break;
+    case SpvOpTerminateRayNV: *hasResult = false; *hasResultType = false; break;
+    case SpvOpTraceNV: *hasResult = false; *hasResultType = false; break;
+    case SpvOpTypeAccelerationStructureNV: *hasResult = true; *hasResultType = false; break;
+    case SpvOpExecuteCallableNV: *hasResult = false; *hasResultType = false; break;
+    case SpvOpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break;
+    case SpvOpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpCooperativeMatrixStoreNV: *hasResult = false; *hasResultType = false; break;
+    case SpvOpCooperativeMatrixMulAddNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpCooperativeMatrixLengthNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpBeginInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break;
+    case SpvOpEndInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break;
+    case SpvOpDemoteToHelperInvocationEXT: *hasResult = false; *hasResultType = false; break;
+    case SpvOpIsHelperInvocationEXT: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupShuffleINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupShuffleDownINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupShuffleUpINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupShuffleXorINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupBlockReadINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupBlockWriteINTEL: *hasResult = false; *hasResultType = false; break;
+    case SpvOpSubgroupImageBlockReadINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupImageBlockWriteINTEL: *hasResult = false; *hasResultType = false; break;
+    case SpvOpSubgroupImageMediaBlockReadINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupImageMediaBlockWriteINTEL: *hasResult = false; *hasResultType = false; break;
+    case SpvOpUCountLeadingZerosINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpUCountTrailingZerosINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpAbsISubINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpAbsUSubINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpIAddSatINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpUAddSatINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpIAverageINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpUAverageINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpIAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpUAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpISubSatINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpUSubSatINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpIMul32x16INTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpUMul32x16INTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpDecorateString: *hasResult = false; *hasResultType = false; break;
+    case SpvOpMemberDecorateString: *hasResult = false; *hasResultType = false; break;
+    case SpvOpVmeImageINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpTypeVmeImageINTEL: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeAvcImePayloadINTEL: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeAvcRefPayloadINTEL: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeAvcSicPayloadINTEL: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeAvcMcePayloadINTEL: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeAvcMceResultINTEL: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeAvcImeResultINTEL: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeAvcImeResultSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeAvcImeResultDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeAvcImeSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeAvcImeDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeAvcRefResultINTEL: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeAvcSicResultINTEL: *hasResult = true; *hasResultType = false; break;
+    case SpvOpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceSetInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceSetInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceSetAcOnlyHaarINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceConvertToImePayloadINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceConvertToImeResultINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceConvertToRefPayloadINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceConvertToRefResultINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceConvertToSicPayloadINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceConvertToSicResultINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceGetMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceGetInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceGetBestInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceGetInterMajorShapeINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceGetInterMinorShapeINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceGetInterDirectionsINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceGetInterMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceGetInterReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeInitializeINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeSetSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeSetDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeRefWindowSizeINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeAdjustRefOffsetINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeSetMaxMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeSetWeightedSadINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeGetSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeGetDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeStripDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeGetBorderReachedINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcFmeInitializeINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcBmeInitializeINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcRefConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcRefSetBidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcRefSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcRefEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcRefConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcSicInitializeINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcSicConfigureSkcINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcSicConfigureIpeLumaINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcSicConfigureIpeLumaChromaINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcSicGetMotionVectorMaskINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcSicConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcSicSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcSicEvaluateIpeINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcSicEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcSicConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcSicGetIpeLumaShapeINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcSicGetPackedIpeLumaModesINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcSicGetIpeChromaModeINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpSubgroupAvcSicGetInterRawSadsINTEL: *hasResult = true; *hasResultType = true; break;
+    case SpvOpRayQueryGetRayTMinKHR: *hasResult = true; *hasResultType = true; break;
+    case SpvOpRayQueryGetRayFlagsKHR: *hasResult = true; *hasResultType = true; break;
+    case SpvOpRayQueryGetIntersectionTKHR: *hasResult = true; *hasResultType = true; break;
+    case SpvOpRayQueryGetIntersectionInstanceCustomIndexKHR: *hasResult = true; *hasResultType = true; break;
+    case SpvOpRayQueryGetIntersectionInstanceIdKHR: *hasResult = true; *hasResultType = true; break;
+    case SpvOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: *hasResult = true; *hasResultType = true; break;
+    case SpvOpRayQueryGetIntersectionGeometryIndexKHR: *hasResult = true; *hasResultType = true; break;
+    case SpvOpRayQueryGetIntersectionPrimitiveIndexKHR: *hasResult = true; *hasResultType = true; break;
+    case SpvOpRayQueryGetIntersectionBarycentricsKHR: *hasResult = true; *hasResultType = true; break;
+    case SpvOpRayQueryGetIntersectionFrontFaceKHR: *hasResult = true; *hasResultType = true; break;
+    case SpvOpRayQueryGetIntersectionCandidateAABBOpaqueKHR: *hasResult = true; *hasResultType = true; break;
+    case SpvOpRayQueryGetIntersectionObjectRayDirectionKHR: *hasResult = true; *hasResultType = true; break;
+    case SpvOpRayQueryGetIntersectionObjectRayOriginKHR: *hasResult = true; *hasResultType = true; break;
+    case SpvOpRayQueryGetWorldRayDirectionKHR: *hasResult = true; *hasResultType = true; break;
+    case SpvOpRayQueryGetWorldRayOriginKHR: *hasResult = true; *hasResultType = true; break;
+    case SpvOpRayQueryGetIntersectionObjectToWorldKHR: *hasResult = true; *hasResultType = true; break;
+    case SpvOpRayQueryGetIntersectionWorldToObjectKHR: *hasResult = true; *hasResultType = true; break;
+    }
+}
+#endif /* SPV_ENABLE_UTILITY_CODE */
+
+#endif
+
diff --git a/engine/inc/spirv_cross/spirv.hpp b/engine/inc/spirv_cross/spirv.hpp
new file mode 100644
index 00000000..dae36cf2
--- /dev/null
+++ b/engine/inc/spirv_cross/spirv.hpp
@@ -0,0 +1,2114 @@
+// Copyright (c) 2014-2020 The Khronos Group Inc.
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and/or associated documentation files (the "Materials"),
+// to deal in the Materials without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Materials, and to permit persons to whom the
+// Materials are 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 Materials.
+// 
+// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+// STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+// HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
+// 
+// THE MATERIALS ARE 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 MATERIALS OR THE USE OR OTHER DEALINGS
+// IN THE MATERIALS.
+
+// This header is automatically generated by the same tool that creates
+// the Binary Section of the SPIR-V specification.
+
+// Enumeration tokens for SPIR-V, in various styles:
+//   C, C++, C++11, JSON, Lua, Python, C#, D
+// 
+// - C will have tokens with a "Spv" prefix, e.g.: SpvSourceLanguageGLSL
+// - C++ will have tokens in the "spv" name space, e.g.: spv::SourceLanguageGLSL
+// - C++11 will use enum classes in the spv namespace, e.g.: spv::SourceLanguage::GLSL
+// - Lua will use tables, e.g.: spv.SourceLanguage.GLSL
+// - Python will use dictionaries, e.g.: spv['SourceLanguage']['GLSL']
+// - C# will use enum classes in the Specification class located in the "Spv" namespace,
+//     e.g.: Spv.Specification.SourceLanguage.GLSL
+// - D will have tokens under the "spv" module, e.g: spv.SourceLanguage.GLSL
+// 
+// Some tokens act like mask values, which can be OR'd together,
+// while others are mutually exclusive.  The mask-like ones have
+// "Mask" in their name, and a parallel enum that has the shift
+// amount (1 << x) for each corresponding enumerant.
+
+#ifndef spirv_HPP
+#define spirv_HPP
+
+namespace spv {
+
+typedef unsigned int Id;
+
+#define SPV_VERSION 0x10500
+#define SPV_REVISION 3
+
+static const unsigned int MagicNumber = 0x07230203;
+static const unsigned int Version = 0x00010500;
+static const unsigned int Revision = 3;
+static const unsigned int OpCodeMask = 0xffff;
+static const unsigned int WordCountShift = 16;
+
+enum SourceLanguage {
+    SourceLanguageUnknown = 0,
+    SourceLanguageESSL = 1,
+    SourceLanguageGLSL = 2,
+    SourceLanguageOpenCL_C = 3,
+    SourceLanguageOpenCL_CPP = 4,
+    SourceLanguageHLSL = 5,
+    SourceLanguageMax = 0x7fffffff,
+};
+
+enum ExecutionModel {
+    ExecutionModelVertex = 0,
+    ExecutionModelTessellationControl = 1,
+    ExecutionModelTessellationEvaluation = 2,
+    ExecutionModelGeometry = 3,
+    ExecutionModelFragment = 4,
+    ExecutionModelGLCompute = 5,
+    ExecutionModelKernel = 6,
+    ExecutionModelTaskNV = 5267,
+    ExecutionModelMeshNV = 5268,
+    ExecutionModelRayGenerationKHR = 5313,
+    ExecutionModelRayGenerationNV = 5313,
+    ExecutionModelIntersectionKHR = 5314,
+    ExecutionModelIntersectionNV = 5314,
+    ExecutionModelAnyHitKHR = 5315,
+    ExecutionModelAnyHitNV = 5315,
+    ExecutionModelClosestHitKHR = 5316,
+    ExecutionModelClosestHitNV = 5316,
+    ExecutionModelMissKHR = 5317,
+    ExecutionModelMissNV = 5317,
+    ExecutionModelCallableKHR = 5318,
+    ExecutionModelCallableNV = 5318,
+    ExecutionModelMax = 0x7fffffff,
+};
+
+enum AddressingModel {
+    AddressingModelLogical = 0,
+    AddressingModelPhysical32 = 1,
+    AddressingModelPhysical64 = 2,
+    AddressingModelPhysicalStorageBuffer64 = 5348,
+    AddressingModelPhysicalStorageBuffer64EXT = 5348,
+    AddressingModelMax = 0x7fffffff,
+};
+
+enum MemoryModel {
+    MemoryModelSimple = 0,
+    MemoryModelGLSL450 = 1,
+    MemoryModelOpenCL = 2,
+    MemoryModelVulkan = 3,
+    MemoryModelVulkanKHR = 3,
+    MemoryModelMax = 0x7fffffff,
+};
+
+enum ExecutionMode {
+    ExecutionModeInvocations = 0,
+    ExecutionModeSpacingEqual = 1,
+    ExecutionModeSpacingFractionalEven = 2,
+    ExecutionModeSpacingFractionalOdd = 3,
+    ExecutionModeVertexOrderCw = 4,
+    ExecutionModeVertexOrderCcw = 5,
+    ExecutionModePixelCenterInteger = 6,
+    ExecutionModeOriginUpperLeft = 7,
+    ExecutionModeOriginLowerLeft = 8,
+    ExecutionModeEarlyFragmentTests = 9,
+    ExecutionModePointMode = 10,
+    ExecutionModeXfb = 11,
+    ExecutionModeDepthReplacing = 12,
+    ExecutionModeDepthGreater = 14,
+    ExecutionModeDepthLess = 15,
+    ExecutionModeDepthUnchanged = 16,
+    ExecutionModeLocalSize = 17,
+    ExecutionModeLocalSizeHint = 18,
+    ExecutionModeInputPoints = 19,
+    ExecutionModeInputLines = 20,
+    ExecutionModeInputLinesAdjacency = 21,
+    ExecutionModeTriangles = 22,
+    ExecutionModeInputTrianglesAdjacency = 23,
+    ExecutionModeQuads = 24,
+    ExecutionModeIsolines = 25,
+    ExecutionModeOutputVertices = 26,
+    ExecutionModeOutputPoints = 27,
+    ExecutionModeOutputLineStrip = 28,
+    ExecutionModeOutputTriangleStrip = 29,
+    ExecutionModeVecTypeHint = 30,
+    ExecutionModeContractionOff = 31,
+    ExecutionModeInitializer = 33,
+    ExecutionModeFinalizer = 34,
+    ExecutionModeSubgroupSize = 35,
+    ExecutionModeSubgroupsPerWorkgroup = 36,
+    ExecutionModeSubgroupsPerWorkgroupId = 37,
+    ExecutionModeLocalSizeId = 38,
+    ExecutionModeLocalSizeHintId = 39,
+    ExecutionModePostDepthCoverage = 4446,
+    ExecutionModeDenormPreserve = 4459,
+    ExecutionModeDenormFlushToZero = 4460,
+    ExecutionModeSignedZeroInfNanPreserve = 4461,
+    ExecutionModeRoundingModeRTE = 4462,
+    ExecutionModeRoundingModeRTZ = 4463,
+    ExecutionModeStencilRefReplacingEXT = 5027,
+    ExecutionModeOutputLinesNV = 5269,
+    ExecutionModeOutputPrimitivesNV = 5270,
+    ExecutionModeDerivativeGroupQuadsNV = 5289,
+    ExecutionModeDerivativeGroupLinearNV = 5290,
+    ExecutionModeOutputTrianglesNV = 5298,
+    ExecutionModePixelInterlockOrderedEXT = 5366,
+    ExecutionModePixelInterlockUnorderedEXT = 5367,
+    ExecutionModeSampleInterlockOrderedEXT = 5368,
+    ExecutionModeSampleInterlockUnorderedEXT = 5369,
+    ExecutionModeShadingRateInterlockOrderedEXT = 5370,
+    ExecutionModeShadingRateInterlockUnorderedEXT = 5371,
+    ExecutionModeMax = 0x7fffffff,
+};
+
+enum StorageClass {
+    StorageClassUniformConstant = 0,
+    StorageClassInput = 1,
+    StorageClassUniform = 2,
+    StorageClassOutput = 3,
+    StorageClassWorkgroup = 4,
+    StorageClassCrossWorkgroup = 5,
+    StorageClassPrivate = 6,
+    StorageClassFunction = 7,
+    StorageClassGeneric = 8,
+    StorageClassPushConstant = 9,
+    StorageClassAtomicCounter = 10,
+    StorageClassImage = 11,
+    StorageClassStorageBuffer = 12,
+    StorageClassCallableDataKHR = 5328,
+    StorageClassCallableDataNV = 5328,
+    StorageClassIncomingCallableDataKHR = 5329,
+    StorageClassIncomingCallableDataNV = 5329,
+    StorageClassRayPayloadKHR = 5338,
+    StorageClassRayPayloadNV = 5338,
+    StorageClassHitAttributeKHR = 5339,
+    StorageClassHitAttributeNV = 5339,
+    StorageClassIncomingRayPayloadKHR = 5342,
+    StorageClassIncomingRayPayloadNV = 5342,
+    StorageClassShaderRecordBufferKHR = 5343,
+    StorageClassShaderRecordBufferNV = 5343,
+    StorageClassPhysicalStorageBuffer = 5349,
+    StorageClassPhysicalStorageBufferEXT = 5349,
+    StorageClassMax = 0x7fffffff,
+};
+
+enum Dim {
+    Dim1D = 0,
+    Dim2D = 1,
+    Dim3D = 2,
+    DimCube = 3,
+    DimRect = 4,
+    DimBuffer = 5,
+    DimSubpassData = 6,
+    DimMax = 0x7fffffff,
+};
+
+enum SamplerAddressingMode {
+    SamplerAddressingModeNone = 0,
+    SamplerAddressingModeClampToEdge = 1,
+    SamplerAddressingModeClamp = 2,
+    SamplerAddressingModeRepeat = 3,
+    SamplerAddressingModeRepeatMirrored = 4,
+    SamplerAddressingModeMax = 0x7fffffff,
+};
+
+enum SamplerFilterMode {
+    SamplerFilterModeNearest = 0,
+    SamplerFilterModeLinear = 1,
+    SamplerFilterModeMax = 0x7fffffff,
+};
+
+enum ImageFormat {
+    ImageFormatUnknown = 0,
+    ImageFormatRgba32f = 1,
+    ImageFormatRgba16f = 2,
+    ImageFormatR32f = 3,
+    ImageFormatRgba8 = 4,
+    ImageFormatRgba8Snorm = 5,
+    ImageFormatRg32f = 6,
+    ImageFormatRg16f = 7,
+    ImageFormatR11fG11fB10f = 8,
+    ImageFormatR16f = 9,
+    ImageFormatRgba16 = 10,
+    ImageFormatRgb10A2 = 11,
+    ImageFormatRg16 = 12,
+    ImageFormatRg8 = 13,
+    ImageFormatR16 = 14,
+    ImageFormatR8 = 15,
+    ImageFormatRgba16Snorm = 16,
+    ImageFormatRg16Snorm = 17,
+    ImageFormatRg8Snorm = 18,
+    ImageFormatR16Snorm = 19,
+    ImageFormatR8Snorm = 20,
+    ImageFormatRgba32i = 21,
+    ImageFormatRgba16i = 22,
+    ImageFormatRgba8i = 23,
+    ImageFormatR32i = 24,
+    ImageFormatRg32i = 25,
+    ImageFormatRg16i = 26,
+    ImageFormatRg8i = 27,
+    ImageFormatR16i = 28,
+    ImageFormatR8i = 29,
+    ImageFormatRgba32ui = 30,
+    ImageFormatRgba16ui = 31,
+    ImageFormatRgba8ui = 32,
+    ImageFormatR32ui = 33,
+    ImageFormatRgb10a2ui = 34,
+    ImageFormatRg32ui = 35,
+    ImageFormatRg16ui = 36,
+    ImageFormatRg8ui = 37,
+    ImageFormatR16ui = 38,
+    ImageFormatR8ui = 39,
+    ImageFormatMax = 0x7fffffff,
+};
+
+enum ImageChannelOrder {
+    ImageChannelOrderR = 0,
+    ImageChannelOrderA = 1,
+    ImageChannelOrderRG = 2,
+    ImageChannelOrderRA = 3,
+    ImageChannelOrderRGB = 4,
+    ImageChannelOrderRGBA = 5,
+    ImageChannelOrderBGRA = 6,
+    ImageChannelOrderARGB = 7,
+    ImageChannelOrderIntensity = 8,
+    ImageChannelOrderLuminance = 9,
+    ImageChannelOrderRx = 10,
+    ImageChannelOrderRGx = 11,
+    ImageChannelOrderRGBx = 12,
+    ImageChannelOrderDepth = 13,
+    ImageChannelOrderDepthStencil = 14,
+    ImageChannelOrdersRGB = 15,
+    ImageChannelOrdersRGBx = 16,
+    ImageChannelOrdersRGBA = 17,
+    ImageChannelOrdersBGRA = 18,
+    ImageChannelOrderABGR = 19,
+    ImageChannelOrderMax = 0x7fffffff,
+};
+
+enum ImageChannelDataType {
+    ImageChannelDataTypeSnormInt8 = 0,
+    ImageChannelDataTypeSnormInt16 = 1,
+    ImageChannelDataTypeUnormInt8 = 2,
+    ImageChannelDataTypeUnormInt16 = 3,
+    ImageChannelDataTypeUnormShort565 = 4,
+    ImageChannelDataTypeUnormShort555 = 5,
+    ImageChannelDataTypeUnormInt101010 = 6,
+    ImageChannelDataTypeSignedInt8 = 7,
+    ImageChannelDataTypeSignedInt16 = 8,
+    ImageChannelDataTypeSignedInt32 = 9,
+    ImageChannelDataTypeUnsignedInt8 = 10,
+    ImageChannelDataTypeUnsignedInt16 = 11,
+    ImageChannelDataTypeUnsignedInt32 = 12,
+    ImageChannelDataTypeHalfFloat = 13,
+    ImageChannelDataTypeFloat = 14,
+    ImageChannelDataTypeUnormInt24 = 15,
+    ImageChannelDataTypeUnormInt101010_2 = 16,
+    ImageChannelDataTypeMax = 0x7fffffff,
+};
+
+enum ImageOperandsShift {
+    ImageOperandsBiasShift = 0,
+    ImageOperandsLodShift = 1,
+    ImageOperandsGradShift = 2,
+    ImageOperandsConstOffsetShift = 3,
+    ImageOperandsOffsetShift = 4,
+    ImageOperandsConstOffsetsShift = 5,
+    ImageOperandsSampleShift = 6,
+    ImageOperandsMinLodShift = 7,
+    ImageOperandsMakeTexelAvailableShift = 8,
+    ImageOperandsMakeTexelAvailableKHRShift = 8,
+    ImageOperandsMakeTexelVisibleShift = 9,
+    ImageOperandsMakeTexelVisibleKHRShift = 9,
+    ImageOperandsNonPrivateTexelShift = 10,
+    ImageOperandsNonPrivateTexelKHRShift = 10,
+    ImageOperandsVolatileTexelShift = 11,
+    ImageOperandsVolatileTexelKHRShift = 11,
+    ImageOperandsSignExtendShift = 12,
+    ImageOperandsZeroExtendShift = 13,
+    ImageOperandsMax = 0x7fffffff,
+};
+
+enum ImageOperandsMask {
+    ImageOperandsMaskNone = 0,
+    ImageOperandsBiasMask = 0x00000001,
+    ImageOperandsLodMask = 0x00000002,
+    ImageOperandsGradMask = 0x00000004,
+    ImageOperandsConstOffsetMask = 0x00000008,
+    ImageOperandsOffsetMask = 0x00000010,
+    ImageOperandsConstOffsetsMask = 0x00000020,
+    ImageOperandsSampleMask = 0x00000040,
+    ImageOperandsMinLodMask = 0x00000080,
+    ImageOperandsMakeTexelAvailableMask = 0x00000100,
+    ImageOperandsMakeTexelAvailableKHRMask = 0x00000100,
+    ImageOperandsMakeTexelVisibleMask = 0x00000200,
+    ImageOperandsMakeTexelVisibleKHRMask = 0x00000200,
+    ImageOperandsNonPrivateTexelMask = 0x00000400,
+    ImageOperandsNonPrivateTexelKHRMask = 0x00000400,
+    ImageOperandsVolatileTexelMask = 0x00000800,
+    ImageOperandsVolatileTexelKHRMask = 0x00000800,
+    ImageOperandsSignExtendMask = 0x00001000,
+    ImageOperandsZeroExtendMask = 0x00002000,
+};
+
+enum FPFastMathModeShift {
+    FPFastMathModeNotNaNShift = 0,
+    FPFastMathModeNotInfShift = 1,
+    FPFastMathModeNSZShift = 2,
+    FPFastMathModeAllowRecipShift = 3,
+    FPFastMathModeFastShift = 4,
+    FPFastMathModeMax = 0x7fffffff,
+};
+
+enum FPFastMathModeMask {
+    FPFastMathModeMaskNone = 0,
+    FPFastMathModeNotNaNMask = 0x00000001,
+    FPFastMathModeNotInfMask = 0x00000002,
+    FPFastMathModeNSZMask = 0x00000004,
+    FPFastMathModeAllowRecipMask = 0x00000008,
+    FPFastMathModeFastMask = 0x00000010,
+};
+
+enum FPRoundingMode {
+    FPRoundingModeRTE = 0,
+    FPRoundingModeRTZ = 1,
+    FPRoundingModeRTP = 2,
+    FPRoundingModeRTN = 3,
+    FPRoundingModeMax = 0x7fffffff,
+};
+
+enum LinkageType {
+    LinkageTypeExport = 0,
+    LinkageTypeImport = 1,
+    LinkageTypeMax = 0x7fffffff,
+};
+
+enum AccessQualifier {
+    AccessQualifierReadOnly = 0,
+    AccessQualifierWriteOnly = 1,
+    AccessQualifierReadWrite = 2,
+    AccessQualifierMax = 0x7fffffff,
+};
+
+enum FunctionParameterAttribute {
+    FunctionParameterAttributeZext = 0,
+    FunctionParameterAttributeSext = 1,
+    FunctionParameterAttributeByVal = 2,
+    FunctionParameterAttributeSret = 3,
+    FunctionParameterAttributeNoAlias = 4,
+    FunctionParameterAttributeNoCapture = 5,
+    FunctionParameterAttributeNoWrite = 6,
+    FunctionParameterAttributeNoReadWrite = 7,
+    FunctionParameterAttributeMax = 0x7fffffff,
+};
+
+enum Decoration {
+    DecorationRelaxedPrecision = 0,
+    DecorationSpecId = 1,
+    DecorationBlock = 2,
+    DecorationBufferBlock = 3,
+    DecorationRowMajor = 4,
+    DecorationColMajor = 5,
+    DecorationArrayStride = 6,
+    DecorationMatrixStride = 7,
+    DecorationGLSLShared = 8,
+    DecorationGLSLPacked = 9,
+    DecorationCPacked = 10,
+    DecorationBuiltIn = 11,
+    DecorationNoPerspective = 13,
+    DecorationFlat = 14,
+    DecorationPatch = 15,
+    DecorationCentroid = 16,
+    DecorationSample = 17,
+    DecorationInvariant = 18,
+    DecorationRestrict = 19,
+    DecorationAliased = 20,
+    DecorationVolatile = 21,
+    DecorationConstant = 22,
+    DecorationCoherent = 23,
+    DecorationNonWritable = 24,
+    DecorationNonReadable = 25,
+    DecorationUniform = 26,
+    DecorationUniformId = 27,
+    DecorationSaturatedConversion = 28,
+    DecorationStream = 29,
+    DecorationLocation = 30,
+    DecorationComponent = 31,
+    DecorationIndex = 32,
+    DecorationBinding = 33,
+    DecorationDescriptorSet = 34,
+    DecorationOffset = 35,
+    DecorationXfbBuffer = 36,
+    DecorationXfbStride = 37,
+    DecorationFuncParamAttr = 38,
+    DecorationFPRoundingMode = 39,
+    DecorationFPFastMathMode = 40,
+    DecorationLinkageAttributes = 41,
+    DecorationNoContraction = 42,
+    DecorationInputAttachmentIndex = 43,
+    DecorationAlignment = 44,
+    DecorationMaxByteOffset = 45,
+    DecorationAlignmentId = 46,
+    DecorationMaxByteOffsetId = 47,
+    DecorationNoSignedWrap = 4469,
+    DecorationNoUnsignedWrap = 4470,
+    DecorationExplicitInterpAMD = 4999,
+    DecorationOverrideCoverageNV = 5248,
+    DecorationPassthroughNV = 5250,
+    DecorationViewportRelativeNV = 5252,
+    DecorationSecondaryViewportRelativeNV = 5256,
+    DecorationPerPrimitiveNV = 5271,
+    DecorationPerViewNV = 5272,
+    DecorationPerTaskNV = 5273,
+    DecorationPerVertexNV = 5285,
+    DecorationNonUniform = 5300,
+    DecorationNonUniformEXT = 5300,
+    DecorationRestrictPointer = 5355,
+    DecorationRestrictPointerEXT = 5355,
+    DecorationAliasedPointer = 5356,
+    DecorationAliasedPointerEXT = 5356,
+    DecorationCounterBuffer = 5634,
+    DecorationHlslCounterBufferGOOGLE = 5634,
+    DecorationHlslSemanticGOOGLE = 5635,
+    DecorationUserSemantic = 5635,
+    DecorationUserTypeGOOGLE = 5636,
+    DecorationMax = 0x7fffffff,
+};
+
+enum BuiltIn {
+    BuiltInPosition = 0,
+    BuiltInPointSize = 1,
+    BuiltInClipDistance = 3,
+    BuiltInCullDistance = 4,
+    BuiltInVertexId = 5,
+    BuiltInInstanceId = 6,
+    BuiltInPrimitiveId = 7,
+    BuiltInInvocationId = 8,
+    BuiltInLayer = 9,
+    BuiltInViewportIndex = 10,
+    BuiltInTessLevelOuter = 11,
+    BuiltInTessLevelInner = 12,
+    BuiltInTessCoord = 13,
+    BuiltInPatchVertices = 14,
+    BuiltInFragCoord = 15,
+    BuiltInPointCoord = 16,
+    BuiltInFrontFacing = 17,
+    BuiltInSampleId = 18,
+    BuiltInSamplePosition = 19,
+    BuiltInSampleMask = 20,
+    BuiltInFragDepth = 22,
+    BuiltInHelperInvocation = 23,
+    BuiltInNumWorkgroups = 24,
+    BuiltInWorkgroupSize = 25,
+    BuiltInWorkgroupId = 26,
+    BuiltInLocalInvocationId = 27,
+    BuiltInGlobalInvocationId = 28,
+    BuiltInLocalInvocationIndex = 29,
+    BuiltInWorkDim = 30,
+    BuiltInGlobalSize = 31,
+    BuiltInEnqueuedWorkgroupSize = 32,
+    BuiltInGlobalOffset = 33,
+    BuiltInGlobalLinearId = 34,
+    BuiltInSubgroupSize = 36,
+    BuiltInSubgroupMaxSize = 37,
+    BuiltInNumSubgroups = 38,
+    BuiltInNumEnqueuedSubgroups = 39,
+    BuiltInSubgroupId = 40,
+    BuiltInSubgroupLocalInvocationId = 41,
+    BuiltInVertexIndex = 42,
+    BuiltInInstanceIndex = 43,
+    BuiltInSubgroupEqMask = 4416,
+    BuiltInSubgroupEqMaskKHR = 4416,
+    BuiltInSubgroupGeMask = 4417,
+    BuiltInSubgroupGeMaskKHR = 4417,
+    BuiltInSubgroupGtMask = 4418,
+    BuiltInSubgroupGtMaskKHR = 4418,
+    BuiltInSubgroupLeMask = 4419,
+    BuiltInSubgroupLeMaskKHR = 4419,
+    BuiltInSubgroupLtMask = 4420,
+    BuiltInSubgroupLtMaskKHR = 4420,
+    BuiltInBaseVertex = 4424,
+    BuiltInBaseInstance = 4425,
+    BuiltInDrawIndex = 4426,
+    BuiltInDeviceIndex = 4438,
+    BuiltInViewIndex = 4440,
+    BuiltInBaryCoordNoPerspAMD = 4992,
+    BuiltInBaryCoordNoPerspCentroidAMD = 4993,
+    BuiltInBaryCoordNoPerspSampleAMD = 4994,
+    BuiltInBaryCoordSmoothAMD = 4995,
+    BuiltInBaryCoordSmoothCentroidAMD = 4996,
+    BuiltInBaryCoordSmoothSampleAMD = 4997,
+    BuiltInBaryCoordPullModelAMD = 4998,
+    BuiltInFragStencilRefEXT = 5014,
+    BuiltInViewportMaskNV = 5253,
+    BuiltInSecondaryPositionNV = 5257,
+    BuiltInSecondaryViewportMaskNV = 5258,
+    BuiltInPositionPerViewNV = 5261,
+    BuiltInViewportMaskPerViewNV = 5262,
+    BuiltInFullyCoveredEXT = 5264,
+    BuiltInTaskCountNV = 5274,
+    BuiltInPrimitiveCountNV = 5275,
+    BuiltInPrimitiveIndicesNV = 5276,
+    BuiltInClipDistancePerViewNV = 5277,
+    BuiltInCullDistancePerViewNV = 5278,
+    BuiltInLayerPerViewNV = 5279,
+    BuiltInMeshViewCountNV = 5280,
+    BuiltInMeshViewIndicesNV = 5281,
+    BuiltInBaryCoordNV = 5286,
+    BuiltInBaryCoordNoPerspNV = 5287,
+    BuiltInFragSizeEXT = 5292,
+    BuiltInFragmentSizeNV = 5292,
+    BuiltInFragInvocationCountEXT = 5293,
+    BuiltInInvocationsPerPixelNV = 5293,
+    BuiltInLaunchIdKHR = 5319,
+    BuiltInLaunchIdNV = 5319,
+    BuiltInLaunchSizeKHR = 5320,
+    BuiltInLaunchSizeNV = 5320,
+    BuiltInWorldRayOriginKHR = 5321,
+    BuiltInWorldRayOriginNV = 5321,
+    BuiltInWorldRayDirectionKHR = 5322,
+    BuiltInWorldRayDirectionNV = 5322,
+    BuiltInObjectRayOriginKHR = 5323,
+    BuiltInObjectRayOriginNV = 5323,
+    BuiltInObjectRayDirectionKHR = 5324,
+    BuiltInObjectRayDirectionNV = 5324,
+    BuiltInRayTminKHR = 5325,
+    BuiltInRayTminNV = 5325,
+    BuiltInRayTmaxKHR = 5326,
+    BuiltInRayTmaxNV = 5326,
+    BuiltInInstanceCustomIndexKHR = 5327,
+    BuiltInInstanceCustomIndexNV = 5327,
+    BuiltInObjectToWorldKHR = 5330,
+    BuiltInObjectToWorldNV = 5330,
+    BuiltInWorldToObjectKHR = 5331,
+    BuiltInWorldToObjectNV = 5331,
+    BuiltInHitTKHR = 5332,
+    BuiltInHitTNV = 5332,
+    BuiltInHitKindKHR = 5333,
+    BuiltInHitKindNV = 5333,
+    BuiltInIncomingRayFlagsKHR = 5351,
+    BuiltInIncomingRayFlagsNV = 5351,
+    BuiltInRayGeometryIndexKHR = 5352,
+    BuiltInWarpsPerSMNV = 5374,
+    BuiltInSMCountNV = 5375,
+    BuiltInWarpIDNV = 5376,
+    BuiltInSMIDNV = 5377,
+    BuiltInMax = 0x7fffffff,
+};
+
+enum SelectionControlShift {
+    SelectionControlFlattenShift = 0,
+    SelectionControlDontFlattenShift = 1,
+    SelectionControlMax = 0x7fffffff,
+};
+
+enum SelectionControlMask {
+    SelectionControlMaskNone = 0,
+    SelectionControlFlattenMask = 0x00000001,
+    SelectionControlDontFlattenMask = 0x00000002,
+};
+
+enum LoopControlShift {
+    LoopControlUnrollShift = 0,
+    LoopControlDontUnrollShift = 1,
+    LoopControlDependencyInfiniteShift = 2,
+    LoopControlDependencyLengthShift = 3,
+    LoopControlMinIterationsShift = 4,
+    LoopControlMaxIterationsShift = 5,
+    LoopControlIterationMultipleShift = 6,
+    LoopControlPeelCountShift = 7,
+    LoopControlPartialCountShift = 8,
+    LoopControlMax = 0x7fffffff,
+};
+
+enum LoopControlMask {
+    LoopControlMaskNone = 0,
+    LoopControlUnrollMask = 0x00000001,
+    LoopControlDontUnrollMask = 0x00000002,
+    LoopControlDependencyInfiniteMask = 0x00000004,
+    LoopControlDependencyLengthMask = 0x00000008,
+    LoopControlMinIterationsMask = 0x00000010,
+    LoopControlMaxIterationsMask = 0x00000020,
+    LoopControlIterationMultipleMask = 0x00000040,
+    LoopControlPeelCountMask = 0x00000080,
+    LoopControlPartialCountMask = 0x00000100,
+};
+
+enum FunctionControlShift {
+    FunctionControlInlineShift = 0,
+    FunctionControlDontInlineShift = 1,
+    FunctionControlPureShift = 2,
+    FunctionControlConstShift = 3,
+    FunctionControlMax = 0x7fffffff,
+};
+
+enum FunctionControlMask {
+    FunctionControlMaskNone = 0,
+    FunctionControlInlineMask = 0x00000001,
+    FunctionControlDontInlineMask = 0x00000002,
+    FunctionControlPureMask = 0x00000004,
+    FunctionControlConstMask = 0x00000008,
+};
+
+enum MemorySemanticsShift {
+    MemorySemanticsAcquireShift = 1,
+    MemorySemanticsReleaseShift = 2,
+    MemorySemanticsAcquireReleaseShift = 3,
+    MemorySemanticsSequentiallyConsistentShift = 4,
+    MemorySemanticsUniformMemoryShift = 6,
+    MemorySemanticsSubgroupMemoryShift = 7,
+    MemorySemanticsWorkgroupMemoryShift = 8,
+    MemorySemanticsCrossWorkgroupMemoryShift = 9,
+    MemorySemanticsAtomicCounterMemoryShift = 10,
+    MemorySemanticsImageMemoryShift = 11,
+    MemorySemanticsOutputMemoryShift = 12,
+    MemorySemanticsOutputMemoryKHRShift = 12,
+    MemorySemanticsMakeAvailableShift = 13,
+    MemorySemanticsMakeAvailableKHRShift = 13,
+    MemorySemanticsMakeVisibleShift = 14,
+    MemorySemanticsMakeVisibleKHRShift = 14,
+    MemorySemanticsVolatileShift = 15,
+    MemorySemanticsMax = 0x7fffffff,
+};
+
+enum MemorySemanticsMask {
+    MemorySemanticsMaskNone = 0,
+    MemorySemanticsAcquireMask = 0x00000002,
+    MemorySemanticsReleaseMask = 0x00000004,
+    MemorySemanticsAcquireReleaseMask = 0x00000008,
+    MemorySemanticsSequentiallyConsistentMask = 0x00000010,
+    MemorySemanticsUniformMemoryMask = 0x00000040,
+    MemorySemanticsSubgroupMemoryMask = 0x00000080,
+    MemorySemanticsWorkgroupMemoryMask = 0x00000100,
+    MemorySemanticsCrossWorkgroupMemoryMask = 0x00000200,
+    MemorySemanticsAtomicCounterMemoryMask = 0x00000400,
+    MemorySemanticsImageMemoryMask = 0x00000800,
+    MemorySemanticsOutputMemoryMask = 0x00001000,
+    MemorySemanticsOutputMemoryKHRMask = 0x00001000,
+    MemorySemanticsMakeAvailableMask = 0x00002000,
+    MemorySemanticsMakeAvailableKHRMask = 0x00002000,
+    MemorySemanticsMakeVisibleMask = 0x00004000,
+    MemorySemanticsMakeVisibleKHRMask = 0x00004000,
+    MemorySemanticsVolatileMask = 0x00008000,
+};
+
+enum MemoryAccessShift {
+    MemoryAccessVolatileShift = 0,
+    MemoryAccessAlignedShift = 1,
+    MemoryAccessNontemporalShift = 2,
+    MemoryAccessMakePointerAvailableShift = 3,
+    MemoryAccessMakePointerAvailableKHRShift = 3,
+    MemoryAccessMakePointerVisibleShift = 4,
+    MemoryAccessMakePointerVisibleKHRShift = 4,
+    MemoryAccessNonPrivatePointerShift = 5,
+    MemoryAccessNonPrivatePointerKHRShift = 5,
+    MemoryAccessMax = 0x7fffffff,
+};
+
+enum MemoryAccessMask {
+    MemoryAccessMaskNone = 0,
+    MemoryAccessVolatileMask = 0x00000001,
+    MemoryAccessAlignedMask = 0x00000002,
+    MemoryAccessNontemporalMask = 0x00000004,
+    MemoryAccessMakePointerAvailableMask = 0x00000008,
+    MemoryAccessMakePointerAvailableKHRMask = 0x00000008,
+    MemoryAccessMakePointerVisibleMask = 0x00000010,
+    MemoryAccessMakePointerVisibleKHRMask = 0x00000010,
+    MemoryAccessNonPrivatePointerMask = 0x00000020,
+    MemoryAccessNonPrivatePointerKHRMask = 0x00000020,
+};
+
+enum Scope {
+    ScopeCrossDevice = 0,
+    ScopeDevice = 1,
+    ScopeWorkgroup = 2,
+    ScopeSubgroup = 3,
+    ScopeInvocation = 4,
+    ScopeQueueFamily = 5,
+    ScopeQueueFamilyKHR = 5,
+    ScopeShaderCallKHR = 6,
+    ScopeMax = 0x7fffffff,
+};
+
+enum GroupOperation {
+    GroupOperationReduce = 0,
+    GroupOperationInclusiveScan = 1,
+    GroupOperationExclusiveScan = 2,
+    GroupOperationClusteredReduce = 3,
+    GroupOperationPartitionedReduceNV = 6,
+    GroupOperationPartitionedInclusiveScanNV = 7,
+    GroupOperationPartitionedExclusiveScanNV = 8,
+    GroupOperationMax = 0x7fffffff,
+};
+
+enum KernelEnqueueFlags {
+    KernelEnqueueFlagsNoWait = 0,
+    KernelEnqueueFlagsWaitKernel = 1,
+    KernelEnqueueFlagsWaitWorkGroup = 2,
+    KernelEnqueueFlagsMax = 0x7fffffff,
+};
+
+enum KernelProfilingInfoShift {
+    KernelProfilingInfoCmdExecTimeShift = 0,
+    KernelProfilingInfoMax = 0x7fffffff,
+};
+
+enum KernelProfilingInfoMask {
+    KernelProfilingInfoMaskNone = 0,
+    KernelProfilingInfoCmdExecTimeMask = 0x00000001,
+};
+
+enum Capability {
+    CapabilityMatrix = 0,
+    CapabilityShader = 1,
+    CapabilityGeometry = 2,
+    CapabilityTessellation = 3,
+    CapabilityAddresses = 4,
+    CapabilityLinkage = 5,
+    CapabilityKernel = 6,
+    CapabilityVector16 = 7,
+    CapabilityFloat16Buffer = 8,
+    CapabilityFloat16 = 9,
+    CapabilityFloat64 = 10,
+    CapabilityInt64 = 11,
+    CapabilityInt64Atomics = 12,
+    CapabilityImageBasic = 13,
+    CapabilityImageReadWrite = 14,
+    CapabilityImageMipmap = 15,
+    CapabilityPipes = 17,
+    CapabilityGroups = 18,
+    CapabilityDeviceEnqueue = 19,
+    CapabilityLiteralSampler = 20,
+    CapabilityAtomicStorage = 21,
+    CapabilityInt16 = 22,
+    CapabilityTessellationPointSize = 23,
+    CapabilityGeometryPointSize = 24,
+    CapabilityImageGatherExtended = 25,
+    CapabilityStorageImageMultisample = 27,
+    CapabilityUniformBufferArrayDynamicIndexing = 28,
+    CapabilitySampledImageArrayDynamicIndexing = 29,
+    CapabilityStorageBufferArrayDynamicIndexing = 30,
+    CapabilityStorageImageArrayDynamicIndexing = 31,
+    CapabilityClipDistance = 32,
+    CapabilityCullDistance = 33,
+    CapabilityImageCubeArray = 34,
+    CapabilitySampleRateShading = 35,
+    CapabilityImageRect = 36,
+    CapabilitySampledRect = 37,
+    CapabilityGenericPointer = 38,
+    CapabilityInt8 = 39,
+    CapabilityInputAttachment = 40,
+    CapabilitySparseResidency = 41,
+    CapabilityMinLod = 42,
+    CapabilitySampled1D = 43,
+    CapabilityImage1D = 44,
+    CapabilitySampledCubeArray = 45,
+    CapabilitySampledBuffer = 46,
+    CapabilityImageBuffer = 47,
+    CapabilityImageMSArray = 48,
+    CapabilityStorageImageExtendedFormats = 49,
+    CapabilityImageQuery = 50,
+    CapabilityDerivativeControl = 51,
+    CapabilityInterpolationFunction = 52,
+    CapabilityTransformFeedback = 53,
+    CapabilityGeometryStreams = 54,
+    CapabilityStorageImageReadWithoutFormat = 55,
+    CapabilityStorageImageWriteWithoutFormat = 56,
+    CapabilityMultiViewport = 57,
+    CapabilitySubgroupDispatch = 58,
+    CapabilityNamedBarrier = 59,
+    CapabilityPipeStorage = 60,
+    CapabilityGroupNonUniform = 61,
+    CapabilityGroupNonUniformVote = 62,
+    CapabilityGroupNonUniformArithmetic = 63,
+    CapabilityGroupNonUniformBallot = 64,
+    CapabilityGroupNonUniformShuffle = 65,
+    CapabilityGroupNonUniformShuffleRelative = 66,
+    CapabilityGroupNonUniformClustered = 67,
+    CapabilityGroupNonUniformQuad = 68,
+    CapabilityShaderLayer = 69,
+    CapabilityShaderViewportIndex = 70,
+    CapabilitySubgroupBallotKHR = 4423,
+    CapabilityDrawParameters = 4427,
+    CapabilitySubgroupVoteKHR = 4431,
+    CapabilityStorageBuffer16BitAccess = 4433,
+    CapabilityStorageUniformBufferBlock16 = 4433,
+    CapabilityStorageUniform16 = 4434,
+    CapabilityUniformAndStorageBuffer16BitAccess = 4434,
+    CapabilityStoragePushConstant16 = 4435,
+    CapabilityStorageInputOutput16 = 4436,
+    CapabilityDeviceGroup = 4437,
+    CapabilityMultiView = 4439,
+    CapabilityVariablePointersStorageBuffer = 4441,
+    CapabilityVariablePointers = 4442,
+    CapabilityAtomicStorageOps = 4445,
+    CapabilitySampleMaskPostDepthCoverage = 4447,
+    CapabilityStorageBuffer8BitAccess = 4448,
+    CapabilityUniformAndStorageBuffer8BitAccess = 4449,
+    CapabilityStoragePushConstant8 = 4450,
+    CapabilityDenormPreserve = 4464,
+    CapabilityDenormFlushToZero = 4465,
+    CapabilitySignedZeroInfNanPreserve = 4466,
+    CapabilityRoundingModeRTE = 4467,
+    CapabilityRoundingModeRTZ = 4468,
+    CapabilityRayQueryProvisionalKHR = 4471,
+    CapabilityRayTraversalPrimitiveCullingProvisionalKHR = 4478,
+    CapabilityFloat16ImageAMD = 5008,
+    CapabilityImageGatherBiasLodAMD = 5009,
+    CapabilityFragmentMaskAMD = 5010,
+    CapabilityStencilExportEXT = 5013,
+    CapabilityImageReadWriteLodAMD = 5015,
+    CapabilityShaderClockKHR = 5055,
+    CapabilitySampleMaskOverrideCoverageNV = 5249,
+    CapabilityGeometryShaderPassthroughNV = 5251,
+    CapabilityShaderViewportIndexLayerEXT = 5254,
+    CapabilityShaderViewportIndexLayerNV = 5254,
+    CapabilityShaderViewportMaskNV = 5255,
+    CapabilityShaderStereoViewNV = 5259,
+    CapabilityPerViewAttributesNV = 5260,
+    CapabilityFragmentFullyCoveredEXT = 5265,
+    CapabilityMeshShadingNV = 5266,
+    CapabilityImageFootprintNV = 5282,
+    CapabilityFragmentBarycentricNV = 5284,
+    CapabilityComputeDerivativeGroupQuadsNV = 5288,
+    CapabilityFragmentDensityEXT = 5291,
+    CapabilityShadingRateNV = 5291,
+    CapabilityGroupNonUniformPartitionedNV = 5297,
+    CapabilityShaderNonUniform = 5301,
+    CapabilityShaderNonUniformEXT = 5301,
+    CapabilityRuntimeDescriptorArray = 5302,
+    CapabilityRuntimeDescriptorArrayEXT = 5302,
+    CapabilityInputAttachmentArrayDynamicIndexing = 5303,
+    CapabilityInputAttachmentArrayDynamicIndexingEXT = 5303,
+    CapabilityUniformTexelBufferArrayDynamicIndexing = 5304,
+    CapabilityUniformTexelBufferArrayDynamicIndexingEXT = 5304,
+    CapabilityStorageTexelBufferArrayDynamicIndexing = 5305,
+    CapabilityStorageTexelBufferArrayDynamicIndexingEXT = 5305,
+    CapabilityUniformBufferArrayNonUniformIndexing = 5306,
+    CapabilityUniformBufferArrayNonUniformIndexingEXT = 5306,
+    CapabilitySampledImageArrayNonUniformIndexing = 5307,
+    CapabilitySampledImageArrayNonUniformIndexingEXT = 5307,
+    CapabilityStorageBufferArrayNonUniformIndexing = 5308,
+    CapabilityStorageBufferArrayNonUniformIndexingEXT = 5308,
+    CapabilityStorageImageArrayNonUniformIndexing = 5309,
+    CapabilityStorageImageArrayNonUniformIndexingEXT = 5309,
+    CapabilityInputAttachmentArrayNonUniformIndexing = 5310,
+    CapabilityInputAttachmentArrayNonUniformIndexingEXT = 5310,
+    CapabilityUniformTexelBufferArrayNonUniformIndexing = 5311,
+    CapabilityUniformTexelBufferArrayNonUniformIndexingEXT = 5311,
+    CapabilityStorageTexelBufferArrayNonUniformIndexing = 5312,
+    CapabilityStorageTexelBufferArrayNonUniformIndexingEXT = 5312,
+    CapabilityRayTracingNV = 5340,
+    CapabilityVulkanMemoryModel = 5345,
+    CapabilityVulkanMemoryModelKHR = 5345,
+    CapabilityVulkanMemoryModelDeviceScope = 5346,
+    CapabilityVulkanMemoryModelDeviceScopeKHR = 5346,
+    CapabilityPhysicalStorageBufferAddresses = 5347,
+    CapabilityPhysicalStorageBufferAddressesEXT = 5347,
+    CapabilityComputeDerivativeGroupLinearNV = 5350,
+    CapabilityRayTracingProvisionalKHR = 5353,
+    CapabilityCooperativeMatrixNV = 5357,
+    CapabilityFragmentShaderSampleInterlockEXT = 5363,
+    CapabilityFragmentShaderShadingRateInterlockEXT = 5372,
+    CapabilityShaderSMBuiltinsNV = 5373,
+    CapabilityFragmentShaderPixelInterlockEXT = 5378,
+    CapabilityDemoteToHelperInvocationEXT = 5379,
+    CapabilitySubgroupShuffleINTEL = 5568,
+    CapabilitySubgroupBufferBlockIOINTEL = 5569,
+    CapabilitySubgroupImageBlockIOINTEL = 5570,
+    CapabilitySubgroupImageMediaBlockIOINTEL = 5579,
+    CapabilityIntegerFunctions2INTEL = 5584,
+    CapabilitySubgroupAvcMotionEstimationINTEL = 5696,
+    CapabilitySubgroupAvcMotionEstimationIntraINTEL = 5697,
+    CapabilitySubgroupAvcMotionEstimationChromaINTEL = 5698,
+    CapabilityMax = 0x7fffffff,
+};
+
+enum RayFlagsShift {
+    RayFlagsOpaqueKHRShift = 0,
+    RayFlagsNoOpaqueKHRShift = 1,
+    RayFlagsTerminateOnFirstHitKHRShift = 2,
+    RayFlagsSkipClosestHitShaderKHRShift = 3,
+    RayFlagsCullBackFacingTrianglesKHRShift = 4,
+    RayFlagsCullFrontFacingTrianglesKHRShift = 5,
+    RayFlagsCullOpaqueKHRShift = 6,
+    RayFlagsCullNoOpaqueKHRShift = 7,
+    RayFlagsSkipTrianglesKHRShift = 8,
+    RayFlagsSkipAABBsKHRShift = 9,
+    RayFlagsMax = 0x7fffffff,
+};
+
+enum RayFlagsMask {
+    RayFlagsMaskNone = 0,
+    RayFlagsOpaqueKHRMask = 0x00000001,
+    RayFlagsNoOpaqueKHRMask = 0x00000002,
+    RayFlagsTerminateOnFirstHitKHRMask = 0x00000004,
+    RayFlagsSkipClosestHitShaderKHRMask = 0x00000008,
+    RayFlagsCullBackFacingTrianglesKHRMask = 0x00000010,
+    RayFlagsCullFrontFacingTrianglesKHRMask = 0x00000020,
+    RayFlagsCullOpaqueKHRMask = 0x00000040,
+    RayFlagsCullNoOpaqueKHRMask = 0x00000080,
+    RayFlagsSkipTrianglesKHRMask = 0x00000100,
+    RayFlagsSkipAABBsKHRMask = 0x00000200,
+};
+
+enum RayQueryIntersection {
+    RayQueryIntersectionRayQueryCandidateIntersectionKHR = 0,
+    RayQueryIntersectionRayQueryCommittedIntersectionKHR = 1,
+    RayQueryIntersectionMax = 0x7fffffff,
+};
+
+enum RayQueryCommittedIntersectionType {
+    RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionNoneKHR = 0,
+    RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionTriangleKHR = 1,
+    RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionGeneratedKHR = 2,
+    RayQueryCommittedIntersectionTypeMax = 0x7fffffff,
+};
+
+enum RayQueryCandidateIntersectionType {
+    RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionTriangleKHR = 0,
+    RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionAABBKHR = 1,
+    RayQueryCandidateIntersectionTypeMax = 0x7fffffff,
+};
+
+enum Op {
+    OpNop = 0,
+    OpUndef = 1,
+    OpSourceContinued = 2,
+    OpSource = 3,
+    OpSourceExtension = 4,
+    OpName = 5,
+    OpMemberName = 6,
+    OpString = 7,
+    OpLine = 8,
+    OpExtension = 10,
+    OpExtInstImport = 11,
+    OpExtInst = 12,
+    OpMemoryModel = 14,
+    OpEntryPoint = 15,
+    OpExecutionMode = 16,
+    OpCapability = 17,
+    OpTypeVoid = 19,
+    OpTypeBool = 20,
+    OpTypeInt = 21,
+    OpTypeFloat = 22,
+    OpTypeVector = 23,
+    OpTypeMatrix = 24,
+    OpTypeImage = 25,
+    OpTypeSampler = 26,
+    OpTypeSampledImage = 27,
+    OpTypeArray = 28,
+    OpTypeRuntimeArray = 29,
+    OpTypeStruct = 30,
+    OpTypeOpaque = 31,
+    OpTypePointer = 32,
+    OpTypeFunction = 33,
+    OpTypeEvent = 34,
+    OpTypeDeviceEvent = 35,
+    OpTypeReserveId = 36,
+    OpTypeQueue = 37,
+    OpTypePipe = 38,
+    OpTypeForwardPointer = 39,
+    OpConstantTrue = 41,
+    OpConstantFalse = 42,
+    OpConstant = 43,
+    OpConstantComposite = 44,
+    OpConstantSampler = 45,
+    OpConstantNull = 46,
+    OpSpecConstantTrue = 48,
+    OpSpecConstantFalse = 49,
+    OpSpecConstant = 50,
+    OpSpecConstantComposite = 51,
+    OpSpecConstantOp = 52,
+    OpFunction = 54,
+    OpFunctionParameter = 55,
+    OpFunctionEnd = 56,
+    OpFunctionCall = 57,
+    OpVariable = 59,
+    OpImageTexelPointer = 60,
+    OpLoad = 61,
+    OpStore = 62,
+    OpCopyMemory = 63,
+    OpCopyMemorySized = 64,
+    OpAccessChain = 65,
+    OpInBoundsAccessChain = 66,
+    OpPtrAccessChain = 67,
+    OpArrayLength = 68,
+    OpGenericPtrMemSemantics = 69,
+    OpInBoundsPtrAccessChain = 70,
+    OpDecorate = 71,
+    OpMemberDecorate = 72,
+    OpDecorationGroup = 73,
+    OpGroupDecorate = 74,
+    OpGroupMemberDecorate = 75,
+    OpVectorExtractDynamic = 77,
+    OpVectorInsertDynamic = 78,
+    OpVectorShuffle = 79,
+    OpCompositeConstruct = 80,
+    OpCompositeExtract = 81,
+    OpCompositeInsert = 82,
+    OpCopyObject = 83,
+    OpTranspose = 84,
+    OpSampledImage = 86,
+    OpImageSampleImplicitLod = 87,
+    OpImageSampleExplicitLod = 88,
+    OpImageSampleDrefImplicitLod = 89,
+    OpImageSampleDrefExplicitLod = 90,
+    OpImageSampleProjImplicitLod = 91,
+    OpImageSampleProjExplicitLod = 92,
+    OpImageSampleProjDrefImplicitLod = 93,
+    OpImageSampleProjDrefExplicitLod = 94,
+    OpImageFetch = 95,
+    OpImageGather = 96,
+    OpImageDrefGather = 97,
+    OpImageRead = 98,
+    OpImageWrite = 99,
+    OpImage = 100,
+    OpImageQueryFormat = 101,
+    OpImageQueryOrder = 102,
+    OpImageQuerySizeLod = 103,
+    OpImageQuerySize = 104,
+    OpImageQueryLod = 105,
+    OpImageQueryLevels = 106,
+    OpImageQuerySamples = 107,
+    OpConvertFToU = 109,
+    OpConvertFToS = 110,
+    OpConvertSToF = 111,
+    OpConvertUToF = 112,
+    OpUConvert = 113,
+    OpSConvert = 114,
+    OpFConvert = 115,
+    OpQuantizeToF16 = 116,
+    OpConvertPtrToU = 117,
+    OpSatConvertSToU = 118,
+    OpSatConvertUToS = 119,
+    OpConvertUToPtr = 120,
+    OpPtrCastToGeneric = 121,
+    OpGenericCastToPtr = 122,
+    OpGenericCastToPtrExplicit = 123,
+    OpBitcast = 124,
+    OpSNegate = 126,
+    OpFNegate = 127,
+    OpIAdd = 128,
+    OpFAdd = 129,
+    OpISub = 130,
+    OpFSub = 131,
+    OpIMul = 132,
+    OpFMul = 133,
+    OpUDiv = 134,
+    OpSDiv = 135,
+    OpFDiv = 136,
+    OpUMod = 137,
+    OpSRem = 138,
+    OpSMod = 139,
+    OpFRem = 140,
+    OpFMod = 141,
+    OpVectorTimesScalar = 142,
+    OpMatrixTimesScalar = 143,
+    OpVectorTimesMatrix = 144,
+    OpMatrixTimesVector = 145,
+    OpMatrixTimesMatrix = 146,
+    OpOuterProduct = 147,
+    OpDot = 148,
+    OpIAddCarry = 149,
+    OpISubBorrow = 150,
+    OpUMulExtended = 151,
+    OpSMulExtended = 152,
+    OpAny = 154,
+    OpAll = 155,
+    OpIsNan = 156,
+    OpIsInf = 157,
+    OpIsFinite = 158,
+    OpIsNormal = 159,
+    OpSignBitSet = 160,
+    OpLessOrGreater = 161,
+    OpOrdered = 162,
+    OpUnordered = 163,
+    OpLogicalEqual = 164,
+    OpLogicalNotEqual = 165,
+    OpLogicalOr = 166,
+    OpLogicalAnd = 167,
+    OpLogicalNot = 168,
+    OpSelect = 169,
+    OpIEqual = 170,
+    OpINotEqual = 171,
+    OpUGreaterThan = 172,
+    OpSGreaterThan = 173,
+    OpUGreaterThanEqual = 174,
+    OpSGreaterThanEqual = 175,
+    OpULessThan = 176,
+    OpSLessThan = 177,
+    OpULessThanEqual = 178,
+    OpSLessThanEqual = 179,
+    OpFOrdEqual = 180,
+    OpFUnordEqual = 181,
+    OpFOrdNotEqual = 182,
+    OpFUnordNotEqual = 183,
+    OpFOrdLessThan = 184,
+    OpFUnordLessThan = 185,
+    OpFOrdGreaterThan = 186,
+    OpFUnordGreaterThan = 187,
+    OpFOrdLessThanEqual = 188,
+    OpFUnordLessThanEqual = 189,
+    OpFOrdGreaterThanEqual = 190,
+    OpFUnordGreaterThanEqual = 191,
+    OpShiftRightLogical = 194,
+    OpShiftRightArithmetic = 195,
+    OpShiftLeftLogical = 196,
+    OpBitwiseOr = 197,
+    OpBitwiseXor = 198,
+    OpBitwiseAnd = 199,
+    OpNot = 200,
+    OpBitFieldInsert = 201,
+    OpBitFieldSExtract = 202,
+    OpBitFieldUExtract = 203,
+    OpBitReverse = 204,
+    OpBitCount = 205,
+    OpDPdx = 207,
+    OpDPdy = 208,
+    OpFwidth = 209,
+    OpDPdxFine = 210,
+    OpDPdyFine = 211,
+    OpFwidthFine = 212,
+    OpDPdxCoarse = 213,
+    OpDPdyCoarse = 214,
+    OpFwidthCoarse = 215,
+    OpEmitVertex = 218,
+    OpEndPrimitive = 219,
+    OpEmitStreamVertex = 220,
+    OpEndStreamPrimitive = 221,
+    OpControlBarrier = 224,
+    OpMemoryBarrier = 225,
+    OpAtomicLoad = 227,
+    OpAtomicStore = 228,
+    OpAtomicExchange = 229,
+    OpAtomicCompareExchange = 230,
+    OpAtomicCompareExchangeWeak = 231,
+    OpAtomicIIncrement = 232,
+    OpAtomicIDecrement = 233,
+    OpAtomicIAdd = 234,
+    OpAtomicISub = 235,
+    OpAtomicSMin = 236,
+    OpAtomicUMin = 237,
+    OpAtomicSMax = 238,
+    OpAtomicUMax = 239,
+    OpAtomicAnd = 240,
+    OpAtomicOr = 241,
+    OpAtomicXor = 242,
+    OpPhi = 245,
+    OpLoopMerge = 246,
+    OpSelectionMerge = 247,
+    OpLabel = 248,
+    OpBranch = 249,
+    OpBranchConditional = 250,
+    OpSwitch = 251,
+    OpKill = 252,
+    OpReturn = 253,
+    OpReturnValue = 254,
+    OpUnreachable = 255,
+    OpLifetimeStart = 256,
+    OpLifetimeStop = 257,
+    OpGroupAsyncCopy = 259,
+    OpGroupWaitEvents = 260,
+    OpGroupAll = 261,
+    OpGroupAny = 262,
+    OpGroupBroadcast = 263,
+    OpGroupIAdd = 264,
+    OpGroupFAdd = 265,
+    OpGroupFMin = 266,
+    OpGroupUMin = 267,
+    OpGroupSMin = 268,
+    OpGroupFMax = 269,
+    OpGroupUMax = 270,
+    OpGroupSMax = 271,
+    OpReadPipe = 274,
+    OpWritePipe = 275,
+    OpReservedReadPipe = 276,
+    OpReservedWritePipe = 277,
+    OpReserveReadPipePackets = 278,
+    OpReserveWritePipePackets = 279,
+    OpCommitReadPipe = 280,
+    OpCommitWritePipe = 281,
+    OpIsValidReserveId = 282,
+    OpGetNumPipePackets = 283,
+    OpGetMaxPipePackets = 284,
+    OpGroupReserveReadPipePackets = 285,
+    OpGroupReserveWritePipePackets = 286,
+    OpGroupCommitReadPipe = 287,
+    OpGroupCommitWritePipe = 288,
+    OpEnqueueMarker = 291,
+    OpEnqueueKernel = 292,
+    OpGetKernelNDrangeSubGroupCount = 293,
+    OpGetKernelNDrangeMaxSubGroupSize = 294,
+    OpGetKernelWorkGroupSize = 295,
+    OpGetKernelPreferredWorkGroupSizeMultiple = 296,
+    OpRetainEvent = 297,
+    OpReleaseEvent = 298,
+    OpCreateUserEvent = 299,
+    OpIsValidEvent = 300,
+    OpSetUserEventStatus = 301,
+    OpCaptureEventProfilingInfo = 302,
+    OpGetDefaultQueue = 303,
+    OpBuildNDRange = 304,
+    OpImageSparseSampleImplicitLod = 305,
+    OpImageSparseSampleExplicitLod = 306,
+    OpImageSparseSampleDrefImplicitLod = 307,
+    OpImageSparseSampleDrefExplicitLod = 308,
+    OpImageSparseSampleProjImplicitLod = 309,
+    OpImageSparseSampleProjExplicitLod = 310,
+    OpImageSparseSampleProjDrefImplicitLod = 311,
+    OpImageSparseSampleProjDrefExplicitLod = 312,
+    OpImageSparseFetch = 313,
+    OpImageSparseGather = 314,
+    OpImageSparseDrefGather = 315,
+    OpImageSparseTexelsResident = 316,
+    OpNoLine = 317,
+    OpAtomicFlagTestAndSet = 318,
+    OpAtomicFlagClear = 319,
+    OpImageSparseRead = 320,
+    OpSizeOf = 321,
+    OpTypePipeStorage = 322,
+    OpConstantPipeStorage = 323,
+    OpCreatePipeFromPipeStorage = 324,
+    OpGetKernelLocalSizeForSubgroupCount = 325,
+    OpGetKernelMaxNumSubgroups = 326,
+    OpTypeNamedBarrier = 327,
+    OpNamedBarrierInitialize = 328,
+    OpMemoryNamedBarrier = 329,
+    OpModuleProcessed = 330,
+    OpExecutionModeId = 331,
+    OpDecorateId = 332,
+    OpGroupNonUniformElect = 333,
+    OpGroupNonUniformAll = 334,
+    OpGroupNonUniformAny = 335,
+    OpGroupNonUniformAllEqual = 336,
+    OpGroupNonUniformBroadcast = 337,
+    OpGroupNonUniformBroadcastFirst = 338,
+    OpGroupNonUniformBallot = 339,
+    OpGroupNonUniformInverseBallot = 340,
+    OpGroupNonUniformBallotBitExtract = 341,
+    OpGroupNonUniformBallotBitCount = 342,
+    OpGroupNonUniformBallotFindLSB = 343,
+    OpGroupNonUniformBallotFindMSB = 344,
+    OpGroupNonUniformShuffle = 345,
+    OpGroupNonUniformShuffleXor = 346,
+    OpGroupNonUniformShuffleUp = 347,
+    OpGroupNonUniformShuffleDown = 348,
+    OpGroupNonUniformIAdd = 349,
+    OpGroupNonUniformFAdd = 350,
+    OpGroupNonUniformIMul = 351,
+    OpGroupNonUniformFMul = 352,
+    OpGroupNonUniformSMin = 353,
+    OpGroupNonUniformUMin = 354,
+    OpGroupNonUniformFMin = 355,
+    OpGroupNonUniformSMax = 356,
+    OpGroupNonUniformUMax = 357,
+    OpGroupNonUniformFMax = 358,
+    OpGroupNonUniformBitwiseAnd = 359,
+    OpGroupNonUniformBitwiseOr = 360,
+    OpGroupNonUniformBitwiseXor = 361,
+    OpGroupNonUniformLogicalAnd = 362,
+    OpGroupNonUniformLogicalOr = 363,
+    OpGroupNonUniformLogicalXor = 364,
+    OpGroupNonUniformQuadBroadcast = 365,
+    OpGroupNonUniformQuadSwap = 366,
+    OpCopyLogical = 400,
+    OpPtrEqual = 401,
+    OpPtrNotEqual = 402,
+    OpPtrDiff = 403,
+    OpSubgroupBallotKHR = 4421,
+    OpSubgroupFirstInvocationKHR = 4422,
+    OpSubgroupAllKHR = 4428,
+    OpSubgroupAnyKHR = 4429,
+    OpSubgroupAllEqualKHR = 4430,
+    OpSubgroupReadInvocationKHR = 4432,
+    OpTypeRayQueryProvisionalKHR = 4472,
+    OpRayQueryInitializeKHR = 4473,
+    OpRayQueryTerminateKHR = 4474,
+    OpRayQueryGenerateIntersectionKHR = 4475,
+    OpRayQueryConfirmIntersectionKHR = 4476,
+    OpRayQueryProceedKHR = 4477,
+    OpRayQueryGetIntersectionTypeKHR = 4479,
+    OpGroupIAddNonUniformAMD = 5000,
+    OpGroupFAddNonUniformAMD = 5001,
+    OpGroupFMinNonUniformAMD = 5002,
+    OpGroupUMinNonUniformAMD = 5003,
+    OpGroupSMinNonUniformAMD = 5004,
+    OpGroupFMaxNonUniformAMD = 5005,
+    OpGroupUMaxNonUniformAMD = 5006,
+    OpGroupSMaxNonUniformAMD = 5007,
+    OpFragmentMaskFetchAMD = 5011,
+    OpFragmentFetchAMD = 5012,
+    OpReadClockKHR = 5056,
+    OpImageSampleFootprintNV = 5283,
+    OpGroupNonUniformPartitionNV = 5296,
+    OpWritePackedPrimitiveIndices4x8NV = 5299,
+    OpReportIntersectionKHR = 5334,
+    OpReportIntersectionNV = 5334,
+    OpIgnoreIntersectionKHR = 5335,
+    OpIgnoreIntersectionNV = 5335,
+    OpTerminateRayKHR = 5336,
+    OpTerminateRayNV = 5336,
+    OpTraceNV = 5337,
+    OpTraceRayKHR = 5337,
+    OpTypeAccelerationStructureKHR = 5341,
+    OpTypeAccelerationStructureNV = 5341,
+    OpExecuteCallableKHR = 5344,
+    OpExecuteCallableNV = 5344,
+    OpTypeCooperativeMatrixNV = 5358,
+    OpCooperativeMatrixLoadNV = 5359,
+    OpCooperativeMatrixStoreNV = 5360,
+    OpCooperativeMatrixMulAddNV = 5361,
+    OpCooperativeMatrixLengthNV = 5362,
+    OpBeginInvocationInterlockEXT = 5364,
+    OpEndInvocationInterlockEXT = 5365,
+    OpDemoteToHelperInvocationEXT = 5380,
+    OpIsHelperInvocationEXT = 5381,
+    OpSubgroupShuffleINTEL = 5571,
+    OpSubgroupShuffleDownINTEL = 5572,
+    OpSubgroupShuffleUpINTEL = 5573,
+    OpSubgroupShuffleXorINTEL = 5574,
+    OpSubgroupBlockReadINTEL = 5575,
+    OpSubgroupBlockWriteINTEL = 5576,
+    OpSubgroupImageBlockReadINTEL = 5577,
+    OpSubgroupImageBlockWriteINTEL = 5578,
+    OpSubgroupImageMediaBlockReadINTEL = 5580,
+    OpSubgroupImageMediaBlockWriteINTEL = 5581,
+    OpUCountLeadingZerosINTEL = 5585,
+    OpUCountTrailingZerosINTEL = 5586,
+    OpAbsISubINTEL = 5587,
+    OpAbsUSubINTEL = 5588,
+    OpIAddSatINTEL = 5589,
+    OpUAddSatINTEL = 5590,
+    OpIAverageINTEL = 5591,
+    OpUAverageINTEL = 5592,
+    OpIAverageRoundedINTEL = 5593,
+    OpUAverageRoundedINTEL = 5594,
+    OpISubSatINTEL = 5595,
+    OpUSubSatINTEL = 5596,
+    OpIMul32x16INTEL = 5597,
+    OpUMul32x16INTEL = 5598,
+    OpDecorateString = 5632,
+    OpDecorateStringGOOGLE = 5632,
+    OpMemberDecorateString = 5633,
+    OpMemberDecorateStringGOOGLE = 5633,
+    OpVmeImageINTEL = 5699,
+    OpTypeVmeImageINTEL = 5700,
+    OpTypeAvcImePayloadINTEL = 5701,
+    OpTypeAvcRefPayloadINTEL = 5702,
+    OpTypeAvcSicPayloadINTEL = 5703,
+    OpTypeAvcMcePayloadINTEL = 5704,
+    OpTypeAvcMceResultINTEL = 5705,
+    OpTypeAvcImeResultINTEL = 5706,
+    OpTypeAvcImeResultSingleReferenceStreamoutINTEL = 5707,
+    OpTypeAvcImeResultDualReferenceStreamoutINTEL = 5708,
+    OpTypeAvcImeSingleReferenceStreaminINTEL = 5709,
+    OpTypeAvcImeDualReferenceStreaminINTEL = 5710,
+    OpTypeAvcRefResultINTEL = 5711,
+    OpTypeAvcSicResultINTEL = 5712,
+    OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL = 5713,
+    OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL = 5714,
+    OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL = 5715,
+    OpSubgroupAvcMceSetInterShapePenaltyINTEL = 5716,
+    OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL = 5717,
+    OpSubgroupAvcMceSetInterDirectionPenaltyINTEL = 5718,
+    OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL = 5719,
+    OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL = 5720,
+    OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL = 5721,
+    OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL = 5722,
+    OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL = 5723,
+    OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL = 5724,
+    OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL = 5725,
+    OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL = 5726,
+    OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL = 5727,
+    OpSubgroupAvcMceSetAcOnlyHaarINTEL = 5728,
+    OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL = 5729,
+    OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL = 5730,
+    OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL = 5731,
+    OpSubgroupAvcMceConvertToImePayloadINTEL = 5732,
+    OpSubgroupAvcMceConvertToImeResultINTEL = 5733,
+    OpSubgroupAvcMceConvertToRefPayloadINTEL = 5734,
+    OpSubgroupAvcMceConvertToRefResultINTEL = 5735,
+    OpSubgroupAvcMceConvertToSicPayloadINTEL = 5736,
+    OpSubgroupAvcMceConvertToSicResultINTEL = 5737,
+    OpSubgroupAvcMceGetMotionVectorsINTEL = 5738,
+    OpSubgroupAvcMceGetInterDistortionsINTEL = 5739,
+    OpSubgroupAvcMceGetBestInterDistortionsINTEL = 5740,
+    OpSubgroupAvcMceGetInterMajorShapeINTEL = 5741,
+    OpSubgroupAvcMceGetInterMinorShapeINTEL = 5742,
+    OpSubgroupAvcMceGetInterDirectionsINTEL = 5743,
+    OpSubgroupAvcMceGetInterMotionVectorCountINTEL = 5744,
+    OpSubgroupAvcMceGetInterReferenceIdsINTEL = 5745,
+    OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL = 5746,
+    OpSubgroupAvcImeInitializeINTEL = 5747,
+    OpSubgroupAvcImeSetSingleReferenceINTEL = 5748,
+    OpSubgroupAvcImeSetDualReferenceINTEL = 5749,
+    OpSubgroupAvcImeRefWindowSizeINTEL = 5750,
+    OpSubgroupAvcImeAdjustRefOffsetINTEL = 5751,
+    OpSubgroupAvcImeConvertToMcePayloadINTEL = 5752,
+    OpSubgroupAvcImeSetMaxMotionVectorCountINTEL = 5753,
+    OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL = 5754,
+    OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL = 5755,
+    OpSubgroupAvcImeSetWeightedSadINTEL = 5756,
+    OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL = 5757,
+    OpSubgroupAvcImeEvaluateWithDualReferenceINTEL = 5758,
+    OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL = 5759,
+    OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL = 5760,
+    OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL = 5761,
+    OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL = 5762,
+    OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL = 5763,
+    OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL = 5764,
+    OpSubgroupAvcImeConvertToMceResultINTEL = 5765,
+    OpSubgroupAvcImeGetSingleReferenceStreaminINTEL = 5766,
+    OpSubgroupAvcImeGetDualReferenceStreaminINTEL = 5767,
+    OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL = 5768,
+    OpSubgroupAvcImeStripDualReferenceStreamoutINTEL = 5769,
+    OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL = 5770,
+    OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL = 5771,
+    OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL = 5772,
+    OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL = 5773,
+    OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL = 5774,
+    OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL = 5775,
+    OpSubgroupAvcImeGetBorderReachedINTEL = 5776,
+    OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL = 5777,
+    OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL = 5778,
+    OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL = 5779,
+    OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL = 5780,
+    OpSubgroupAvcFmeInitializeINTEL = 5781,
+    OpSubgroupAvcBmeInitializeINTEL = 5782,
+    OpSubgroupAvcRefConvertToMcePayloadINTEL = 5783,
+    OpSubgroupAvcRefSetBidirectionalMixDisableINTEL = 5784,
+    OpSubgroupAvcRefSetBilinearFilterEnableINTEL = 5785,
+    OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL = 5786,
+    OpSubgroupAvcRefEvaluateWithDualReferenceINTEL = 5787,
+    OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL = 5788,
+    OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL = 5789,
+    OpSubgroupAvcRefConvertToMceResultINTEL = 5790,
+    OpSubgroupAvcSicInitializeINTEL = 5791,
+    OpSubgroupAvcSicConfigureSkcINTEL = 5792,
+    OpSubgroupAvcSicConfigureIpeLumaINTEL = 5793,
+    OpSubgroupAvcSicConfigureIpeLumaChromaINTEL = 5794,
+    OpSubgroupAvcSicGetMotionVectorMaskINTEL = 5795,
+    OpSubgroupAvcSicConvertToMcePayloadINTEL = 5796,
+    OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL = 5797,
+    OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL = 5798,
+    OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL = 5799,
+    OpSubgroupAvcSicSetBilinearFilterEnableINTEL = 5800,
+    OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL = 5801,
+    OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL = 5802,
+    OpSubgroupAvcSicEvaluateIpeINTEL = 5803,
+    OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL = 5804,
+    OpSubgroupAvcSicEvaluateWithDualReferenceINTEL = 5805,
+    OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL = 5806,
+    OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL = 5807,
+    OpSubgroupAvcSicConvertToMceResultINTEL = 5808,
+    OpSubgroupAvcSicGetIpeLumaShapeINTEL = 5809,
+    OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL = 5810,
+    OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL = 5811,
+    OpSubgroupAvcSicGetPackedIpeLumaModesINTEL = 5812,
+    OpSubgroupAvcSicGetIpeChromaModeINTEL = 5813,
+    OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL = 5814,
+    OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL = 5815,
+    OpSubgroupAvcSicGetInterRawSadsINTEL = 5816,
+    OpRayQueryGetRayTMinKHR = 6016,
+    OpRayQueryGetRayFlagsKHR = 6017,
+    OpRayQueryGetIntersectionTKHR = 6018,
+    OpRayQueryGetIntersectionInstanceCustomIndexKHR = 6019,
+    OpRayQueryGetIntersectionInstanceIdKHR = 6020,
+    OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR = 6021,
+    OpRayQueryGetIntersectionGeometryIndexKHR = 6022,
+    OpRayQueryGetIntersectionPrimitiveIndexKHR = 6023,
+    OpRayQueryGetIntersectionBarycentricsKHR = 6024,
+    OpRayQueryGetIntersectionFrontFaceKHR = 6025,
+    OpRayQueryGetIntersectionCandidateAABBOpaqueKHR = 6026,
+    OpRayQueryGetIntersectionObjectRayDirectionKHR = 6027,
+    OpRayQueryGetIntersectionObjectRayOriginKHR = 6028,
+    OpRayQueryGetWorldRayDirectionKHR = 6029,
+    OpRayQueryGetWorldRayOriginKHR = 6030,
+    OpRayQueryGetIntersectionObjectToWorldKHR = 6031,
+    OpRayQueryGetIntersectionWorldToObjectKHR = 6032,
+    OpMax = 0x7fffffff,
+};
+
+#ifdef SPV_ENABLE_UTILITY_CODE
+inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
+    *hasResult = *hasResultType = false;
+    switch (opcode) {
+    default: /* unknown opcode */ break;
+    case OpNop: *hasResult = false; *hasResultType = false; break;
+    case OpUndef: *hasResult = true; *hasResultType = true; break;
+    case OpSourceContinued: *hasResult = false; *hasResultType = false; break;
+    case OpSource: *hasResult = false; *hasResultType = false; break;
+    case OpSourceExtension: *hasResult = false; *hasResultType = false; break;
+    case OpName: *hasResult = false; *hasResultType = false; break;
+    case OpMemberName: *hasResult = false; *hasResultType = false; break;
+    case OpString: *hasResult = true; *hasResultType = false; break;
+    case OpLine: *hasResult = false; *hasResultType = false; break;
+    case OpExtension: *hasResult = false; *hasResultType = false; break;
+    case OpExtInstImport: *hasResult = true; *hasResultType = false; break;
+    case OpExtInst: *hasResult = true; *hasResultType = true; break;
+    case OpMemoryModel: *hasResult = false; *hasResultType = false; break;
+    case OpEntryPoint: *hasResult = false; *hasResultType = false; break;
+    case OpExecutionMode: *hasResult = false; *hasResultType = false; break;
+    case OpCapability: *hasResult = false; *hasResultType = false; break;
+    case OpTypeVoid: *hasResult = true; *hasResultType = false; break;
+    case OpTypeBool: *hasResult = true; *hasResultType = false; break;
+    case OpTypeInt: *hasResult = true; *hasResultType = false; break;
+    case OpTypeFloat: *hasResult = true; *hasResultType = false; break;
+    case OpTypeVector: *hasResult = true; *hasResultType = false; break;
+    case OpTypeMatrix: *hasResult = true; *hasResultType = false; break;
+    case OpTypeImage: *hasResult = true; *hasResultType = false; break;
+    case OpTypeSampler: *hasResult = true; *hasResultType = false; break;
+    case OpTypeSampledImage: *hasResult = true; *hasResultType = false; break;
+    case OpTypeArray: *hasResult = true; *hasResultType = false; break;
+    case OpTypeRuntimeArray: *hasResult = true; *hasResultType = false; break;
+    case OpTypeStruct: *hasResult = true; *hasResultType = false; break;
+    case OpTypeOpaque: *hasResult = true; *hasResultType = false; break;
+    case OpTypePointer: *hasResult = true; *hasResultType = false; break;
+    case OpTypeFunction: *hasResult = true; *hasResultType = false; break;
+    case OpTypeEvent: *hasResult = true; *hasResultType = false; break;
+    case OpTypeDeviceEvent: *hasResult = true; *hasResultType = false; break;
+    case OpTypeReserveId: *hasResult = true; *hasResultType = false; break;
+    case OpTypeQueue: *hasResult = true; *hasResultType = false; break;
+    case OpTypePipe: *hasResult = true; *hasResultType = false; break;
+    case OpTypeForwardPointer: *hasResult = false; *hasResultType = false; break;
+    case OpConstantTrue: *hasResult = true; *hasResultType = true; break;
+    case OpConstantFalse: *hasResult = true; *hasResultType = true; break;
+    case OpConstant: *hasResult = true; *hasResultType = true; break;
+    case OpConstantComposite: *hasResult = true; *hasResultType = true; break;
+    case OpConstantSampler: *hasResult = true; *hasResultType = true; break;
+    case OpConstantNull: *hasResult = true; *hasResultType = true; break;
+    case OpSpecConstantTrue: *hasResult = true; *hasResultType = true; break;
+    case OpSpecConstantFalse: *hasResult = true; *hasResultType = true; break;
+    case OpSpecConstant: *hasResult = true; *hasResultType = true; break;
+    case OpSpecConstantComposite: *hasResult = true; *hasResultType = true; break;
+    case OpSpecConstantOp: *hasResult = true; *hasResultType = true; break;
+    case OpFunction: *hasResult = true; *hasResultType = true; break;
+    case OpFunctionParameter: *hasResult = true; *hasResultType = true; break;
+    case OpFunctionEnd: *hasResult = false; *hasResultType = false; break;
+    case OpFunctionCall: *hasResult = true; *hasResultType = true; break;
+    case OpVariable: *hasResult = true; *hasResultType = true; break;
+    case OpImageTexelPointer: *hasResult = true; *hasResultType = true; break;
+    case OpLoad: *hasResult = true; *hasResultType = true; break;
+    case OpStore: *hasResult = false; *hasResultType = false; break;
+    case OpCopyMemory: *hasResult = false; *hasResultType = false; break;
+    case OpCopyMemorySized: *hasResult = false; *hasResultType = false; break;
+    case OpAccessChain: *hasResult = true; *hasResultType = true; break;
+    case OpInBoundsAccessChain: *hasResult = true; *hasResultType = true; break;
+    case OpPtrAccessChain: *hasResult = true; *hasResultType = true; break;
+    case OpArrayLength: *hasResult = true; *hasResultType = true; break;
+    case OpGenericPtrMemSemantics: *hasResult = true; *hasResultType = true; break;
+    case OpInBoundsPtrAccessChain: *hasResult = true; *hasResultType = true; break;
+    case OpDecorate: *hasResult = false; *hasResultType = false; break;
+    case OpMemberDecorate: *hasResult = false; *hasResultType = false; break;
+    case OpDecorationGroup: *hasResult = true; *hasResultType = false; break;
+    case OpGroupDecorate: *hasResult = false; *hasResultType = false; break;
+    case OpGroupMemberDecorate: *hasResult = false; *hasResultType = false; break;
+    case OpVectorExtractDynamic: *hasResult = true; *hasResultType = true; break;
+    case OpVectorInsertDynamic: *hasResult = true; *hasResultType = true; break;
+    case OpVectorShuffle: *hasResult = true; *hasResultType = true; break;
+    case OpCompositeConstruct: *hasResult = true; *hasResultType = true; break;
+    case OpCompositeExtract: *hasResult = true; *hasResultType = true; break;
+    case OpCompositeInsert: *hasResult = true; *hasResultType = true; break;
+    case OpCopyObject: *hasResult = true; *hasResultType = true; break;
+    case OpTranspose: *hasResult = true; *hasResultType = true; break;
+    case OpSampledImage: *hasResult = true; *hasResultType = true; break;
+    case OpImageSampleImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case OpImageSampleExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case OpImageSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case OpImageSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case OpImageSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case OpImageSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case OpImageSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case OpImageSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case OpImageFetch: *hasResult = true; *hasResultType = true; break;
+    case OpImageGather: *hasResult = true; *hasResultType = true; break;
+    case OpImageDrefGather: *hasResult = true; *hasResultType = true; break;
+    case OpImageRead: *hasResult = true; *hasResultType = true; break;
+    case OpImageWrite: *hasResult = false; *hasResultType = false; break;
+    case OpImage: *hasResult = true; *hasResultType = true; break;
+    case OpImageQueryFormat: *hasResult = true; *hasResultType = true; break;
+    case OpImageQueryOrder: *hasResult = true; *hasResultType = true; break;
+    case OpImageQuerySizeLod: *hasResult = true; *hasResultType = true; break;
+    case OpImageQuerySize: *hasResult = true; *hasResultType = true; break;
+    case OpImageQueryLod: *hasResult = true; *hasResultType = true; break;
+    case OpImageQueryLevels: *hasResult = true; *hasResultType = true; break;
+    case OpImageQuerySamples: *hasResult = true; *hasResultType = true; break;
+    case OpConvertFToU: *hasResult = true; *hasResultType = true; break;
+    case OpConvertFToS: *hasResult = true; *hasResultType = true; break;
+    case OpConvertSToF: *hasResult = true; *hasResultType = true; break;
+    case OpConvertUToF: *hasResult = true; *hasResultType = true; break;
+    case OpUConvert: *hasResult = true; *hasResultType = true; break;
+    case OpSConvert: *hasResult = true; *hasResultType = true; break;
+    case OpFConvert: *hasResult = true; *hasResultType = true; break;
+    case OpQuantizeToF16: *hasResult = true; *hasResultType = true; break;
+    case OpConvertPtrToU: *hasResult = true; *hasResultType = true; break;
+    case OpSatConvertSToU: *hasResult = true; *hasResultType = true; break;
+    case OpSatConvertUToS: *hasResult = true; *hasResultType = true; break;
+    case OpConvertUToPtr: *hasResult = true; *hasResultType = true; break;
+    case OpPtrCastToGeneric: *hasResult = true; *hasResultType = true; break;
+    case OpGenericCastToPtr: *hasResult = true; *hasResultType = true; break;
+    case OpGenericCastToPtrExplicit: *hasResult = true; *hasResultType = true; break;
+    case OpBitcast: *hasResult = true; *hasResultType = true; break;
+    case OpSNegate: *hasResult = true; *hasResultType = true; break;
+    case OpFNegate: *hasResult = true; *hasResultType = true; break;
+    case OpIAdd: *hasResult = true; *hasResultType = true; break;
+    case OpFAdd: *hasResult = true; *hasResultType = true; break;
+    case OpISub: *hasResult = true; *hasResultType = true; break;
+    case OpFSub: *hasResult = true; *hasResultType = true; break;
+    case OpIMul: *hasResult = true; *hasResultType = true; break;
+    case OpFMul: *hasResult = true; *hasResultType = true; break;
+    case OpUDiv: *hasResult = true; *hasResultType = true; break;
+    case OpSDiv: *hasResult = true; *hasResultType = true; break;
+    case OpFDiv: *hasResult = true; *hasResultType = true; break;
+    case OpUMod: *hasResult = true; *hasResultType = true; break;
+    case OpSRem: *hasResult = true; *hasResultType = true; break;
+    case OpSMod: *hasResult = true; *hasResultType = true; break;
+    case OpFRem: *hasResult = true; *hasResultType = true; break;
+    case OpFMod: *hasResult = true; *hasResultType = true; break;
+    case OpVectorTimesScalar: *hasResult = true; *hasResultType = true; break;
+    case OpMatrixTimesScalar: *hasResult = true; *hasResultType = true; break;
+    case OpVectorTimesMatrix: *hasResult = true; *hasResultType = true; break;
+    case OpMatrixTimesVector: *hasResult = true; *hasResultType = true; break;
+    case OpMatrixTimesMatrix: *hasResult = true; *hasResultType = true; break;
+    case OpOuterProduct: *hasResult = true; *hasResultType = true; break;
+    case OpDot: *hasResult = true; *hasResultType = true; break;
+    case OpIAddCarry: *hasResult = true; *hasResultType = true; break;
+    case OpISubBorrow: *hasResult = true; *hasResultType = true; break;
+    case OpUMulExtended: *hasResult = true; *hasResultType = true; break;
+    case OpSMulExtended: *hasResult = true; *hasResultType = true; break;
+    case OpAny: *hasResult = true; *hasResultType = true; break;
+    case OpAll: *hasResult = true; *hasResultType = true; break;
+    case OpIsNan: *hasResult = true; *hasResultType = true; break;
+    case OpIsInf: *hasResult = true; *hasResultType = true; break;
+    case OpIsFinite: *hasResult = true; *hasResultType = true; break;
+    case OpIsNormal: *hasResult = true; *hasResultType = true; break;
+    case OpSignBitSet: *hasResult = true; *hasResultType = true; break;
+    case OpLessOrGreater: *hasResult = true; *hasResultType = true; break;
+    case OpOrdered: *hasResult = true; *hasResultType = true; break;
+    case OpUnordered: *hasResult = true; *hasResultType = true; break;
+    case OpLogicalEqual: *hasResult = true; *hasResultType = true; break;
+    case OpLogicalNotEqual: *hasResult = true; *hasResultType = true; break;
+    case OpLogicalOr: *hasResult = true; *hasResultType = true; break;
+    case OpLogicalAnd: *hasResult = true; *hasResultType = true; break;
+    case OpLogicalNot: *hasResult = true; *hasResultType = true; break;
+    case OpSelect: *hasResult = true; *hasResultType = true; break;
+    case OpIEqual: *hasResult = true; *hasResultType = true; break;
+    case OpINotEqual: *hasResult = true; *hasResultType = true; break;
+    case OpUGreaterThan: *hasResult = true; *hasResultType = true; break;
+    case OpSGreaterThan: *hasResult = true; *hasResultType = true; break;
+    case OpUGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
+    case OpSGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
+    case OpULessThan: *hasResult = true; *hasResultType = true; break;
+    case OpSLessThan: *hasResult = true; *hasResultType = true; break;
+    case OpULessThanEqual: *hasResult = true; *hasResultType = true; break;
+    case OpSLessThanEqual: *hasResult = true; *hasResultType = true; break;
+    case OpFOrdEqual: *hasResult = true; *hasResultType = true; break;
+    case OpFUnordEqual: *hasResult = true; *hasResultType = true; break;
+    case OpFOrdNotEqual: *hasResult = true; *hasResultType = true; break;
+    case OpFUnordNotEqual: *hasResult = true; *hasResultType = true; break;
+    case OpFOrdLessThan: *hasResult = true; *hasResultType = true; break;
+    case OpFUnordLessThan: *hasResult = true; *hasResultType = true; break;
+    case OpFOrdGreaterThan: *hasResult = true; *hasResultType = true; break;
+    case OpFUnordGreaterThan: *hasResult = true; *hasResultType = true; break;
+    case OpFOrdLessThanEqual: *hasResult = true; *hasResultType = true; break;
+    case OpFUnordLessThanEqual: *hasResult = true; *hasResultType = true; break;
+    case OpFOrdGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
+    case OpFUnordGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
+    case OpShiftRightLogical: *hasResult = true; *hasResultType = true; break;
+    case OpShiftRightArithmetic: *hasResult = true; *hasResultType = true; break;
+    case OpShiftLeftLogical: *hasResult = true; *hasResultType = true; break;
+    case OpBitwiseOr: *hasResult = true; *hasResultType = true; break;
+    case OpBitwiseXor: *hasResult = true; *hasResultType = true; break;
+    case OpBitwiseAnd: *hasResult = true; *hasResultType = true; break;
+    case OpNot: *hasResult = true; *hasResultType = true; break;
+    case OpBitFieldInsert: *hasResult = true; *hasResultType = true; break;
+    case OpBitFieldSExtract: *hasResult = true; *hasResultType = true; break;
+    case OpBitFieldUExtract: *hasResult = true; *hasResultType = true; break;
+    case OpBitReverse: *hasResult = true; *hasResultType = true; break;
+    case OpBitCount: *hasResult = true; *hasResultType = true; break;
+    case OpDPdx: *hasResult = true; *hasResultType = true; break;
+    case OpDPdy: *hasResult = true; *hasResultType = true; break;
+    case OpFwidth: *hasResult = true; *hasResultType = true; break;
+    case OpDPdxFine: *hasResult = true; *hasResultType = true; break;
+    case OpDPdyFine: *hasResult = true; *hasResultType = true; break;
+    case OpFwidthFine: *hasResult = true; *hasResultType = true; break;
+    case OpDPdxCoarse: *hasResult = true; *hasResultType = true; break;
+    case OpDPdyCoarse: *hasResult = true; *hasResultType = true; break;
+    case OpFwidthCoarse: *hasResult = true; *hasResultType = true; break;
+    case OpEmitVertex: *hasResult = false; *hasResultType = false; break;
+    case OpEndPrimitive: *hasResult = false; *hasResultType = false; break;
+    case OpEmitStreamVertex: *hasResult = false; *hasResultType = false; break;
+    case OpEndStreamPrimitive: *hasResult = false; *hasResultType = false; break;
+    case OpControlBarrier: *hasResult = false; *hasResultType = false; break;
+    case OpMemoryBarrier: *hasResult = false; *hasResultType = false; break;
+    case OpAtomicLoad: *hasResult = true; *hasResultType = true; break;
+    case OpAtomicStore: *hasResult = false; *hasResultType = false; break;
+    case OpAtomicExchange: *hasResult = true; *hasResultType = true; break;
+    case OpAtomicCompareExchange: *hasResult = true; *hasResultType = true; break;
+    case OpAtomicCompareExchangeWeak: *hasResult = true; *hasResultType = true; break;
+    case OpAtomicIIncrement: *hasResult = true; *hasResultType = true; break;
+    case OpAtomicIDecrement: *hasResult = true; *hasResultType = true; break;
+    case OpAtomicIAdd: *hasResult = true; *hasResultType = true; break;
+    case OpAtomicISub: *hasResult = true; *hasResultType = true; break;
+    case OpAtomicSMin: *hasResult = true; *hasResultType = true; break;
+    case OpAtomicUMin: *hasResult = true; *hasResultType = true; break;
+    case OpAtomicSMax: *hasResult = true; *hasResultType = true; break;
+    case OpAtomicUMax: *hasResult = true; *hasResultType = true; break;
+    case OpAtomicAnd: *hasResult = true; *hasResultType = true; break;
+    case OpAtomicOr: *hasResult = true; *hasResultType = true; break;
+    case OpAtomicXor: *hasResult = true; *hasResultType = true; break;
+    case OpPhi: *hasResult = true; *hasResultType = true; break;
+    case OpLoopMerge: *hasResult = false; *hasResultType = false; break;
+    case OpSelectionMerge: *hasResult = false; *hasResultType = false; break;
+    case OpLabel: *hasResult = true; *hasResultType = false; break;
+    case OpBranch: *hasResult = false; *hasResultType = false; break;
+    case OpBranchConditional: *hasResult = false; *hasResultType = false; break;
+    case OpSwitch: *hasResult = false; *hasResultType = false; break;
+    case OpKill: *hasResult = false; *hasResultType = false; break;
+    case OpReturn: *hasResult = false; *hasResultType = false; break;
+    case OpReturnValue: *hasResult = false; *hasResultType = false; break;
+    case OpUnreachable: *hasResult = false; *hasResultType = false; break;
+    case OpLifetimeStart: *hasResult = false; *hasResultType = false; break;
+    case OpLifetimeStop: *hasResult = false; *hasResultType = false; break;
+    case OpGroupAsyncCopy: *hasResult = true; *hasResultType = true; break;
+    case OpGroupWaitEvents: *hasResult = false; *hasResultType = false; break;
+    case OpGroupAll: *hasResult = true; *hasResultType = true; break;
+    case OpGroupAny: *hasResult = true; *hasResultType = true; break;
+    case OpGroupBroadcast: *hasResult = true; *hasResultType = true; break;
+    case OpGroupIAdd: *hasResult = true; *hasResultType = true; break;
+    case OpGroupFAdd: *hasResult = true; *hasResultType = true; break;
+    case OpGroupFMin: *hasResult = true; *hasResultType = true; break;
+    case OpGroupUMin: *hasResult = true; *hasResultType = true; break;
+    case OpGroupSMin: *hasResult = true; *hasResultType = true; break;
+    case OpGroupFMax: *hasResult = true; *hasResultType = true; break;
+    case OpGroupUMax: *hasResult = true; *hasResultType = true; break;
+    case OpGroupSMax: *hasResult = true; *hasResultType = true; break;
+    case OpReadPipe: *hasResult = true; *hasResultType = true; break;
+    case OpWritePipe: *hasResult = true; *hasResultType = true; break;
+    case OpReservedReadPipe: *hasResult = true; *hasResultType = true; break;
+    case OpReservedWritePipe: *hasResult = true; *hasResultType = true; break;
+    case OpReserveReadPipePackets: *hasResult = true; *hasResultType = true; break;
+    case OpReserveWritePipePackets: *hasResult = true; *hasResultType = true; break;
+    case OpCommitReadPipe: *hasResult = false; *hasResultType = false; break;
+    case OpCommitWritePipe: *hasResult = false; *hasResultType = false; break;
+    case OpIsValidReserveId: *hasResult = true; *hasResultType = true; break;
+    case OpGetNumPipePackets: *hasResult = true; *hasResultType = true; break;
+    case OpGetMaxPipePackets: *hasResult = true; *hasResultType = true; break;
+    case OpGroupReserveReadPipePackets: *hasResult = true; *hasResultType = true; break;
+    case OpGroupReserveWritePipePackets: *hasResult = true; *hasResultType = true; break;
+    case OpGroupCommitReadPipe: *hasResult = false; *hasResultType = false; break;
+    case OpGroupCommitWritePipe: *hasResult = false; *hasResultType = false; break;
+    case OpEnqueueMarker: *hasResult = true; *hasResultType = true; break;
+    case OpEnqueueKernel: *hasResult = true; *hasResultType = true; break;
+    case OpGetKernelNDrangeSubGroupCount: *hasResult = true; *hasResultType = true; break;
+    case OpGetKernelNDrangeMaxSubGroupSize: *hasResult = true; *hasResultType = true; break;
+    case OpGetKernelWorkGroupSize: *hasResult = true; *hasResultType = true; break;
+    case OpGetKernelPreferredWorkGroupSizeMultiple: *hasResult = true; *hasResultType = true; break;
+    case OpRetainEvent: *hasResult = false; *hasResultType = false; break;
+    case OpReleaseEvent: *hasResult = false; *hasResultType = false; break;
+    case OpCreateUserEvent: *hasResult = true; *hasResultType = true; break;
+    case OpIsValidEvent: *hasResult = true; *hasResultType = true; break;
+    case OpSetUserEventStatus: *hasResult = false; *hasResultType = false; break;
+    case OpCaptureEventProfilingInfo: *hasResult = false; *hasResultType = false; break;
+    case OpGetDefaultQueue: *hasResult = true; *hasResultType = true; break;
+    case OpBuildNDRange: *hasResult = true; *hasResultType = true; break;
+    case OpImageSparseSampleImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case OpImageSparseSampleExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case OpImageSparseSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case OpImageSparseSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case OpImageSparseSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case OpImageSparseSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case OpImageSparseSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case OpImageSparseSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case OpImageSparseFetch: *hasResult = true; *hasResultType = true; break;
+    case OpImageSparseGather: *hasResult = true; *hasResultType = true; break;
+    case OpImageSparseDrefGather: *hasResult = true; *hasResultType = true; break;
+    case OpImageSparseTexelsResident: *hasResult = true; *hasResultType = true; break;
+    case OpNoLine: *hasResult = false; *hasResultType = false; break;
+    case OpAtomicFlagTestAndSet: *hasResult = true; *hasResultType = true; break;
+    case OpAtomicFlagClear: *hasResult = false; *hasResultType = false; break;
+    case OpImageSparseRead: *hasResult = true; *hasResultType = true; break;
+    case OpSizeOf: *hasResult = true; *hasResultType = true; break;
+    case OpTypePipeStorage: *hasResult = true; *hasResultType = false; break;
+    case OpConstantPipeStorage: *hasResult = true; *hasResultType = true; break;
+    case OpCreatePipeFromPipeStorage: *hasResult = true; *hasResultType = true; break;
+    case OpGetKernelLocalSizeForSubgroupCount: *hasResult = true; *hasResultType = true; break;
+    case OpGetKernelMaxNumSubgroups: *hasResult = true; *hasResultType = true; break;
+    case OpTypeNamedBarrier: *hasResult = true; *hasResultType = false; break;
+    case OpNamedBarrierInitialize: *hasResult = true; *hasResultType = true; break;
+    case OpMemoryNamedBarrier: *hasResult = false; *hasResultType = false; break;
+    case OpModuleProcessed: *hasResult = false; *hasResultType = false; break;
+    case OpExecutionModeId: *hasResult = false; *hasResultType = false; break;
+    case OpDecorateId: *hasResult = false; *hasResultType = false; break;
+    case OpGroupNonUniformElect: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformAll: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformAny: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformAllEqual: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformBroadcast: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformBroadcastFirst: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformBallot: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformInverseBallot: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformBallotBitExtract: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformBallotBitCount: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformBallotFindLSB: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformBallotFindMSB: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformShuffle: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformShuffleXor: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformShuffleUp: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformShuffleDown: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformIAdd: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformFAdd: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformIMul: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformFMul: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformSMin: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformUMin: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformFMin: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformSMax: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformUMax: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformFMax: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformBitwiseAnd: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformBitwiseOr: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformBitwiseXor: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformLogicalAnd: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformLogicalOr: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformLogicalXor: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformQuadBroadcast: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformQuadSwap: *hasResult = true; *hasResultType = true; break;
+    case OpCopyLogical: *hasResult = true; *hasResultType = true; break;
+    case OpPtrEqual: *hasResult = true; *hasResultType = true; break;
+    case OpPtrNotEqual: *hasResult = true; *hasResultType = true; break;
+    case OpPtrDiff: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupBallotKHR: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupFirstInvocationKHR: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAllKHR: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAnyKHR: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAllEqualKHR: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break;
+    case OpTypeRayQueryProvisionalKHR: *hasResult = true; *hasResultType = false; break;
+    case OpRayQueryInitializeKHR: *hasResult = false; *hasResultType = false; break;
+    case OpRayQueryTerminateKHR: *hasResult = false; *hasResultType = false; break;
+    case OpRayQueryGenerateIntersectionKHR: *hasResult = false; *hasResultType = false; break;
+    case OpRayQueryConfirmIntersectionKHR: *hasResult = false; *hasResultType = false; break;
+    case OpRayQueryProceedKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionTypeKHR: *hasResult = true; *hasResultType = true; break;
+    case OpGroupIAddNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case OpGroupFAddNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case OpGroupFMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case OpGroupUMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case OpGroupSMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case OpGroupFMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case OpGroupUMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case OpGroupSMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case OpFragmentMaskFetchAMD: *hasResult = true; *hasResultType = true; break;
+    case OpFragmentFetchAMD: *hasResult = true; *hasResultType = true; break;
+    case OpReadClockKHR: *hasResult = true; *hasResultType = true; break;
+    case OpImageSampleFootprintNV: *hasResult = true; *hasResultType = true; break;
+    case OpGroupNonUniformPartitionNV: *hasResult = true; *hasResultType = true; break;
+    case OpWritePackedPrimitiveIndices4x8NV: *hasResult = false; *hasResultType = false; break;
+    case OpReportIntersectionNV: *hasResult = true; *hasResultType = true; break;
+    case OpIgnoreIntersectionNV: *hasResult = false; *hasResultType = false; break;
+    case OpTerminateRayNV: *hasResult = false; *hasResultType = false; break;
+    case OpTraceNV: *hasResult = false; *hasResultType = false; break;
+    case OpTypeAccelerationStructureNV: *hasResult = true; *hasResultType = false; break;
+    case OpExecuteCallableNV: *hasResult = false; *hasResultType = false; break;
+    case OpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break;
+    case OpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break;
+    case OpCooperativeMatrixStoreNV: *hasResult = false; *hasResultType = false; break;
+    case OpCooperativeMatrixMulAddNV: *hasResult = true; *hasResultType = true; break;
+    case OpCooperativeMatrixLengthNV: *hasResult = true; *hasResultType = true; break;
+    case OpBeginInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break;
+    case OpEndInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break;
+    case OpDemoteToHelperInvocationEXT: *hasResult = false; *hasResultType = false; break;
+    case OpIsHelperInvocationEXT: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupShuffleINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupShuffleDownINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupShuffleUpINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupShuffleXorINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupBlockReadINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupBlockWriteINTEL: *hasResult = false; *hasResultType = false; break;
+    case OpSubgroupImageBlockReadINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupImageBlockWriteINTEL: *hasResult = false; *hasResultType = false; break;
+    case OpSubgroupImageMediaBlockReadINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupImageMediaBlockWriteINTEL: *hasResult = false; *hasResultType = false; break;
+    case OpUCountLeadingZerosINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpUCountTrailingZerosINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpAbsISubINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpAbsUSubINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpIAddSatINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpUAddSatINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpIAverageINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpUAverageINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpIAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpUAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpISubSatINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpUSubSatINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpIMul32x16INTEL: *hasResult = true; *hasResultType = true; break;
+    case OpUMul32x16INTEL: *hasResult = true; *hasResultType = true; break;
+    case OpDecorateString: *hasResult = false; *hasResultType = false; break;
+    case OpMemberDecorateString: *hasResult = false; *hasResultType = false; break;
+    case OpVmeImageINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpTypeVmeImageINTEL: *hasResult = true; *hasResultType = false; break;
+    case OpTypeAvcImePayloadINTEL: *hasResult = true; *hasResultType = false; break;
+    case OpTypeAvcRefPayloadINTEL: *hasResult = true; *hasResultType = false; break;
+    case OpTypeAvcSicPayloadINTEL: *hasResult = true; *hasResultType = false; break;
+    case OpTypeAvcMcePayloadINTEL: *hasResult = true; *hasResultType = false; break;
+    case OpTypeAvcMceResultINTEL: *hasResult = true; *hasResultType = false; break;
+    case OpTypeAvcImeResultINTEL: *hasResult = true; *hasResultType = false; break;
+    case OpTypeAvcImeResultSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break;
+    case OpTypeAvcImeResultDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break;
+    case OpTypeAvcImeSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break;
+    case OpTypeAvcImeDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break;
+    case OpTypeAvcRefResultINTEL: *hasResult = true; *hasResultType = false; break;
+    case OpTypeAvcSicResultINTEL: *hasResult = true; *hasResultType = false; break;
+    case OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceSetInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceSetInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceSetAcOnlyHaarINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceConvertToImePayloadINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceConvertToImeResultINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceConvertToRefPayloadINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceConvertToRefResultINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceConvertToSicPayloadINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceConvertToSicResultINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceGetMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceGetInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceGetBestInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceGetInterMajorShapeINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceGetInterMinorShapeINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceGetInterDirectionsINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceGetInterMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceGetInterReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeInitializeINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeSetSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeSetDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeRefWindowSizeINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeAdjustRefOffsetINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeSetMaxMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeSetWeightedSadINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeGetSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeGetDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeStripDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeGetBorderReachedINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcFmeInitializeINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcBmeInitializeINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcRefConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcRefSetBidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcRefSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcRefEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcRefConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcSicInitializeINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcSicConfigureSkcINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcSicConfigureIpeLumaINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcSicConfigureIpeLumaChromaINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcSicGetMotionVectorMaskINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcSicConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcSicSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcSicEvaluateIpeINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcSicEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcSicConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcSicGetIpeLumaShapeINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcSicGetPackedIpeLumaModesINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcSicGetIpeChromaModeINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSubgroupAvcSicGetInterRawSadsINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetRayTMinKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetRayFlagsKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionTKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionInstanceCustomIndexKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionInstanceIdKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionGeometryIndexKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionPrimitiveIndexKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionBarycentricsKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionFrontFaceKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionCandidateAABBOpaqueKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionObjectRayDirectionKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionObjectRayOriginKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetWorldRayDirectionKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetWorldRayOriginKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionObjectToWorldKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionWorldToObjectKHR: *hasResult = true; *hasResultType = true; break;
+    }
+}
+#endif /* SPV_ENABLE_UTILITY_CODE */
+
+// Overload operator| for mask bit combining
+
+inline ImageOperandsMask operator|(ImageOperandsMask a, ImageOperandsMask b) { return ImageOperandsMask(unsigned(a) | unsigned(b)); }
+inline FPFastMathModeMask operator|(FPFastMathModeMask a, FPFastMathModeMask b) { return FPFastMathModeMask(unsigned(a) | unsigned(b)); }
+inline SelectionControlMask operator|(SelectionControlMask a, SelectionControlMask b) { return SelectionControlMask(unsigned(a) | unsigned(b)); }
+inline LoopControlMask operator|(LoopControlMask a, LoopControlMask b) { return LoopControlMask(unsigned(a) | unsigned(b)); }
+inline FunctionControlMask operator|(FunctionControlMask a, FunctionControlMask b) { return FunctionControlMask(unsigned(a) | unsigned(b)); }
+inline MemorySemanticsMask operator|(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) | unsigned(b)); }
+inline MemoryAccessMask operator|(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) | unsigned(b)); }
+inline KernelProfilingInfoMask operator|(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) | unsigned(b)); }
+inline RayFlagsMask operator|(RayFlagsMask a, RayFlagsMask b) { return RayFlagsMask(unsigned(a) | unsigned(b)); }
+
+}  // end namespace spv
+
+#endif  // #ifndef spirv_HPP
+
diff --git a/engine/inc/spirv_cross/spirv_cfg.hpp b/engine/inc/spirv_cross/spirv_cfg.hpp
new file mode 100644
index 00000000..9f3e62a1
--- /dev/null
+++ b/engine/inc/spirv_cross/spirv_cfg.hpp
@@ -0,0 +1,156 @@
+/*
+ * Copyright 2016-2020 Arm Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SPIRV_CROSS_CFG_HPP
+#define SPIRV_CROSS_CFG_HPP
+
+#include "spirv_common.hpp"
+#include <assert.h>
+
+namespace SPIRV_CROSS_NAMESPACE
+{
+class Compiler;
+class CFG
+{
+public:
+	CFG(Compiler &compiler, const SPIRFunction &function);
+
+	Compiler &get_compiler()
+	{
+		return compiler;
+	}
+
+	const Compiler &get_compiler() const
+	{
+		return compiler;
+	}
+
+	const SPIRFunction &get_function() const
+	{
+		return func;
+	}
+
+	uint32_t get_immediate_dominator(uint32_t block) const
+	{
+		auto itr = immediate_dominators.find(block);
+		if (itr != std::end(immediate_dominators))
+			return itr->second;
+		else
+			return 0;
+	}
+
+	uint32_t get_visit_order(uint32_t block) const
+	{
+		auto itr = visit_order.find(block);
+		assert(itr != std::end(visit_order));
+		int v = itr->second.get();
+		assert(v > 0);
+		return uint32_t(v);
+	}
+
+	uint32_t find_common_dominator(uint32_t a, uint32_t b) const;
+
+	const SmallVector<uint32_t> &get_preceding_edges(uint32_t block) const
+	{
+		auto itr = preceding_edges.find(block);
+		if (itr != std::end(preceding_edges))
+			return itr->second;
+		else
+			return empty_vector;
+	}
+
+	const SmallVector<uint32_t> &get_succeeding_edges(uint32_t block) const
+	{
+		auto itr = succeeding_edges.find(block);
+		if (itr != std::end(succeeding_edges))
+			return itr->second;
+		else
+			return empty_vector;
+	}
+
+	template <typename Op>
+	void walk_from(std::unordered_set<uint32_t> &seen_blocks, uint32_t block, const Op &op) const
+	{
+		if (seen_blocks.count(block))
+			return;
+		seen_blocks.insert(block);
+
+		if (op(block))
+		{
+			for (auto b : get_succeeding_edges(block))
+				walk_from(seen_blocks, b, op);
+		}
+	}
+
+	uint32_t find_loop_dominator(uint32_t block) const;
+
+	bool node_terminates_control_flow_in_sub_graph(BlockID from, BlockID to) const;
+
+private:
+	struct VisitOrder
+	{
+		int &get()
+		{
+			return v;
+		}
+
+		const int &get() const
+		{
+			return v;
+		}
+
+		int v = -1;
+	};
+
+	Compiler &compiler;
+	const SPIRFunction &func;
+	std::unordered_map<uint32_t, SmallVector<uint32_t>> preceding_edges;
+	std::unordered_map<uint32_t, SmallVector<uint32_t>> succeeding_edges;
+	std::unordered_map<uint32_t, uint32_t> immediate_dominators;
+	std::unordered_map<uint32_t, VisitOrder> visit_order;
+	SmallVector<uint32_t> post_order;
+	SmallVector<uint32_t> empty_vector;
+
+	void add_branch(uint32_t from, uint32_t to);
+	void build_post_order_visit_order();
+	void build_immediate_dominators();
+	bool post_order_visit(uint32_t block);
+	uint32_t visit_count = 0;
+
+	bool is_back_edge(uint32_t to) const;
+	bool has_visited_forward_edge(uint32_t to) const;
+};
+
+class DominatorBuilder
+{
+public:
+	DominatorBuilder(const CFG &cfg);
+
+	void add_block(uint32_t block);
+	uint32_t get_dominator() const
+	{
+		return dominator;
+	}
+
+	void lift_continue_block_dominator();
+
+private:
+	const CFG &cfg;
+	uint32_t dominator = 0;
+};
+} // namespace SPIRV_CROSS_NAMESPACE
+
+#endif
diff --git a/engine/inc/spirv_cross/spirv_common.hpp b/engine/inc/spirv_cross/spirv_common.hpp
new file mode 100644
index 00000000..6ff6fa9a
--- /dev/null
+++ b/engine/inc/spirv_cross/spirv_common.hpp
@@ -0,0 +1,1831 @@
+/*
+ * Copyright 2015-2020 Arm Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SPIRV_CROSS_COMMON_HPP
+#define SPIRV_CROSS_COMMON_HPP
+
+#include "spirv.hpp"
+#include "spirv_cross_containers.hpp"
+#include "spirv_cross_error_handling.hpp"
+#include <functional>
+
+// A bit crude, but allows projects which embed SPIRV-Cross statically to
+// effectively hide all the symbols from other projects.
+// There is a case where we have:
+// - Project A links against SPIRV-Cross statically.
+// - Project A links against Project B statically.
+// - Project B links against SPIRV-Cross statically (might be a different version).
+// This leads to a conflict with extremely bizarre results.
+// By overriding the namespace in one of the project builds, we can work around this.
+// If SPIRV-Cross is embedded in dynamic libraries,
+// prefer using -fvisibility=hidden on GCC/Clang instead.
+#ifdef SPIRV_CROSS_NAMESPACE_OVERRIDE
+#define SPIRV_CROSS_NAMESPACE SPIRV_CROSS_NAMESPACE_OVERRIDE
+#else
+#define SPIRV_CROSS_NAMESPACE spirv_cross
+#endif
+
+namespace SPIRV_CROSS_NAMESPACE
+{
+namespace inner
+{
+template <typename T>
+void join_helper(StringStream<> &stream, T &&t)
+{
+	stream << std::forward<T>(t);
+}
+
+template <typename T, typename... Ts>
+void join_helper(StringStream<> &stream, T &&t, Ts &&... ts)
+{
+	stream << std::forward<T>(t);
+	join_helper(stream, std::forward<Ts>(ts)...);
+}
+} // namespace inner
+
+class Bitset
+{
+public:
+	Bitset() = default;
+	explicit inline Bitset(uint64_t lower_)
+	    : lower(lower_)
+	{
+	}
+
+	inline bool get(uint32_t bit) const
+	{
+		if (bit < 64)
+			return (lower & (1ull << bit)) != 0;
+		else
+			return higher.count(bit) != 0;
+	}
+
+	inline void set(uint32_t bit)
+	{
+		if (bit < 64)
+			lower |= 1ull << bit;
+		else
+			higher.insert(bit);
+	}
+
+	inline void clear(uint32_t bit)
+	{
+		if (bit < 64)
+			lower &= ~(1ull << bit);
+		else
+			higher.erase(bit);
+	}
+
+	inline uint64_t get_lower() const
+	{
+		return lower;
+	}
+
+	inline void reset()
+	{
+		lower = 0;
+		higher.clear();
+	}
+
+	inline void merge_and(const Bitset &other)
+	{
+		lower &= other.lower;
+		std::unordered_set<uint32_t> tmp_set;
+		for (auto &v : higher)
+			if (other.higher.count(v) != 0)
+				tmp_set.insert(v);
+		higher = std::move(tmp_set);
+	}
+
+	inline void merge_or(const Bitset &other)
+	{
+		lower |= other.lower;
+		for (auto &v : other.higher)
+			higher.insert(v);
+	}
+
+	inline bool operator==(const Bitset &other) const
+	{
+		if (lower != other.lower)
+			return false;
+
+		if (higher.size() != other.higher.size())
+			return false;
+
+		for (auto &v : higher)
+			if (other.higher.count(v) == 0)
+				return false;
+
+		return true;
+	}
+
+	inline bool operator!=(const Bitset &other) const
+	{
+		return !(*this == other);
+	}
+
+	template <typename Op>
+	void for_each_bit(const Op &op) const
+	{
+		// TODO: Add ctz-based iteration.
+		for (uint32_t i = 0; i < 64; i++)
+		{
+			if (lower & (1ull << i))
+				op(i);
+		}
+
+		if (higher.empty())
+			return;
+
+		// Need to enforce an order here for reproducible results,
+		// but hitting this path should happen extremely rarely, so having this slow path is fine.
+		SmallVector<uint32_t> bits;
+		bits.reserve(higher.size());
+		for (auto &v : higher)
+			bits.push_back(v);
+		std::sort(std::begin(bits), std::end(bits));
+
+		for (auto &v : bits)
+			op(v);
+	}
+
+	inline bool empty() const
+	{
+		return lower == 0 && higher.empty();
+	}
+
+private:
+	// The most common bits to set are all lower than 64,
+	// so optimize for this case. Bits spilling outside 64 go into a slower data structure.
+	// In almost all cases, higher data structure will not be used.
+	uint64_t lower = 0;
+	std::unordered_set<uint32_t> higher;
+};
+
+// Helper template to avoid lots of nasty string temporary munging.
+template <typename... Ts>
+std::string join(Ts &&... ts)
+{
+	StringStream<> stream;
+	inner::join_helper(stream, std::forward<Ts>(ts)...);
+	return stream.str();
+}
+
+inline std::string merge(const SmallVector<std::string> &list, const char *between = ", ")
+{
+	StringStream<> stream;
+	for (auto &elem : list)
+	{
+		stream << elem;
+		if (&elem != &list.back())
+			stream << between;
+	}
+	return stream.str();
+}
+
+// Make sure we don't accidentally call this with float or doubles with SFINAE.
+// Have to use the radix-aware overload.
+template <typename T, typename std::enable_if<!std::is_floating_point<T>::value, int>::type = 0>
+inline std::string convert_to_string(const T &t)
+{
+	return std::to_string(t);
+}
+
+// Allow implementations to set a convenient standard precision
+#ifndef SPIRV_CROSS_FLT_FMT
+#define SPIRV_CROSS_FLT_FMT "%.32g"
+#endif
+
+// Disable sprintf and strcat warnings.
+// We cannot rely on snprintf and family existing because, ..., MSVC.
+#if defined(__clang__) || defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#elif defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4996)
+#endif
+
+static inline void fixup_radix_point(char *str, char radix_point)
+{
+	// Setting locales is a very risky business in multi-threaded program,
+	// so just fixup locales instead. We only need to care about the radix point.
+	if (radix_point != '.')
+	{
+		while (*str != '\0')
+		{
+			if (*str == radix_point)
+				*str = '.';
+			str++;
+		}
+	}
+}
+
+inline std::string convert_to_string(float t, char locale_radix_point)
+{
+	// std::to_string for floating point values is broken.
+	// Fallback to something more sane.
+	char buf[64];
+	sprintf(buf, SPIRV_CROSS_FLT_FMT, t);
+	fixup_radix_point(buf, locale_radix_point);
+
+	// Ensure that the literal is float.
+	if (!strchr(buf, '.') && !strchr(buf, 'e'))
+		strcat(buf, ".0");
+	return buf;
+}
+
+inline std::string convert_to_string(double t, char locale_radix_point)
+{
+	// std::to_string for floating point values is broken.
+	// Fallback to something more sane.
+	char buf[64];
+	sprintf(buf, SPIRV_CROSS_FLT_FMT, t);
+	fixup_radix_point(buf, locale_radix_point);
+
+	// Ensure that the literal is float.
+	if (!strchr(buf, '.') && !strchr(buf, 'e'))
+		strcat(buf, ".0");
+	return buf;
+}
+
+template <typename T>
+struct ValueSaver
+{
+	explicit ValueSaver(T &current_)
+	    : current(current_)
+	    , saved(current_)
+	{
+	}
+
+	void release()
+	{
+		current = saved;
+	}
+
+	~ValueSaver()
+	{
+		release();
+	}
+
+	T &current;
+	T saved;
+};
+
+#if defined(__clang__) || defined(__GNUC__)
+#pragma GCC diagnostic pop
+#elif defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+struct Instruction
+{
+	uint16_t op = 0;
+	uint16_t count = 0;
+	uint32_t offset = 0;
+	uint32_t length = 0;
+};
+
+enum Types
+{
+	TypeNone,
+	TypeType,
+	TypeVariable,
+	TypeConstant,
+	TypeFunction,
+	TypeFunctionPrototype,
+	TypeBlock,
+	TypeExtension,
+	TypeExpression,
+	TypeConstantOp,
+	TypeCombinedImageSampler,
+	TypeAccessChain,
+	TypeUndef,
+	TypeString,
+	TypeCount
+};
+
+template <Types type>
+class TypedID;
+
+template <>
+class TypedID<TypeNone>
+{
+public:
+	TypedID() = default;
+	TypedID(uint32_t id_)
+	    : id(id_)
+	{
+	}
+
+	template <Types U>
+	TypedID(const TypedID<U> &other)
+	{
+		*this = other;
+	}
+
+	template <Types U>
+	TypedID &operator=(const TypedID<U> &other)
+	{
+		id = uint32_t(other);
+		return *this;
+	}
+
+	// Implicit conversion to u32 is desired here.
+	// As long as we block implicit conversion between TypedID<A> and TypedID<B> we're good.
+	operator uint32_t() const
+	{
+		return id;
+	}
+
+	template <Types U>
+	operator TypedID<U>() const
+	{
+		return TypedID<U>(*this);
+	}
+
+	bool operator==(const TypedID &other) const
+	{
+		return id == other.id;
+	}
+
+	bool operator!=(const TypedID &other) const
+	{
+		return id != other.id;
+	}
+
+	template <Types type>
+	bool operator==(const TypedID<type> &other) const
+	{
+		return id == uint32_t(other);
+	}
+
+	template <Types type>
+	bool operator!=(const TypedID<type> &other) const
+	{
+		return id != uint32_t(other);
+	}
+
+private:
+	uint32_t id = 0;
+};
+
+template <Types type>
+class TypedID
+{
+public:
+	TypedID() = default;
+	TypedID(uint32_t id_)
+	    : id(id_)
+	{
+	}
+
+	explicit TypedID(const TypedID<TypeNone> &other)
+	    : id(uint32_t(other))
+	{
+	}
+
+	operator uint32_t() const
+	{
+		return id;
+	}
+
+	bool operator==(const TypedID &other) const
+	{
+		return id == other.id;
+	}
+
+	bool operator!=(const TypedID &other) const
+	{
+		return id != other.id;
+	}
+
+	bool operator==(const TypedID<TypeNone> &other) const
+	{
+		return id == uint32_t(other);
+	}
+
+	bool operator!=(const TypedID<TypeNone> &other) const
+	{
+		return id != uint32_t(other);
+	}
+
+private:
+	uint32_t id = 0;
+};
+
+using VariableID = TypedID<TypeVariable>;
+using TypeID = TypedID<TypeType>;
+using ConstantID = TypedID<TypeConstant>;
+using FunctionID = TypedID<TypeFunction>;
+using BlockID = TypedID<TypeBlock>;
+using ID = TypedID<TypeNone>;
+
+// Helper for Variant interface.
+struct IVariant
+{
+	virtual ~IVariant() = default;
+	virtual IVariant *clone(ObjectPoolBase *pool) = 0;
+	ID self = 0;
+};
+
+#define SPIRV_CROSS_DECLARE_CLONE(T)                                \
+	IVariant *clone(ObjectPoolBase *pool) override                  \
+	{                                                               \
+		return static_cast<ObjectPool<T> *>(pool)->allocate(*this); \
+	}
+
+struct SPIRUndef : IVariant
+{
+	enum
+	{
+		type = TypeUndef
+	};
+
+	explicit SPIRUndef(TypeID basetype_)
+	    : basetype(basetype_)
+	{
+	}
+	TypeID basetype;
+
+	SPIRV_CROSS_DECLARE_CLONE(SPIRUndef)
+};
+
+struct SPIRString : IVariant
+{
+	enum
+	{
+		type = TypeString
+	};
+
+	explicit SPIRString(std::string str_)
+	    : str(std::move(str_))
+	{
+	}
+
+	std::string str;
+
+	SPIRV_CROSS_DECLARE_CLONE(SPIRString)
+};
+
+// This type is only used by backends which need to access the combined image and sampler IDs separately after
+// the OpSampledImage opcode.
+struct SPIRCombinedImageSampler : IVariant
+{
+	enum
+	{
+		type = TypeCombinedImageSampler
+	};
+	SPIRCombinedImageSampler(TypeID type_, VariableID image_, VariableID sampler_)
+	    : combined_type(type_)
+	    , image(image_)
+	    , sampler(sampler_)
+	{
+	}
+	TypeID combined_type;
+	VariableID image;
+	VariableID sampler;
+
+	SPIRV_CROSS_DECLARE_CLONE(SPIRCombinedImageSampler)
+};
+
+struct SPIRConstantOp : IVariant
+{
+	enum
+	{
+		type = TypeConstantOp
+	};
+
+	SPIRConstantOp(TypeID result_type, spv::Op op, const uint32_t *args, uint32_t length)
+	    : opcode(op)
+	    , basetype(result_type)
+	{
+		arguments.reserve(length);
+		for (uint32_t i = 0; i < length; i++)
+			arguments.push_back(args[i]);
+	}
+
+	spv::Op opcode;
+	SmallVector<uint32_t> arguments;
+	TypeID basetype;
+
+	SPIRV_CROSS_DECLARE_CLONE(SPIRConstantOp)
+};
+
+struct SPIRType : IVariant
+{
+	enum
+	{
+		type = TypeType
+	};
+
+	enum BaseType
+	{
+		Unknown,
+		Void,
+		Boolean,
+		SByte,
+		UByte,
+		Short,
+		UShort,
+		Int,
+		UInt,
+		Int64,
+		UInt64,
+		AtomicCounter,
+		Half,
+		Float,
+		Double,
+		Struct,
+		Image,
+		SampledImage,
+		Sampler,
+		AccelerationStructure,
+		RayQuery,
+
+		// Keep internal types at the end.
+		ControlPointArray,
+		Char
+	};
+
+	// Scalar/vector/matrix support.
+	BaseType basetype = Unknown;
+	uint32_t width = 0;
+	uint32_t vecsize = 1;
+	uint32_t columns = 1;
+
+	// Arrays, support array of arrays by having a vector of array sizes.
+	SmallVector<uint32_t> array;
+
+	// Array elements can be either specialization constants or specialization ops.
+	// This array determines how to interpret the array size.
+	// If an element is true, the element is a literal,
+	// otherwise, it's an expression, which must be resolved on demand.
+	// The actual size is not really known until runtime.
+	SmallVector<bool> array_size_literal;
+
+	// Pointers
+	// Keep track of how many pointer layers we have.
+	uint32_t pointer_depth = 0;
+	bool pointer = false;
+	bool forward_pointer = false;
+
+	spv::StorageClass storage = spv::StorageClassGeneric;
+
+	SmallVector<TypeID> member_types;
+
+	// If member order has been rewritten to handle certain scenarios with Offset,
+	// allow codegen to rewrite the index.
+	SmallVector<uint32_t> member_type_index_redirection;
+
+	struct ImageType
+	{
+		TypeID type;
+		spv::Dim dim;
+		bool depth;
+		bool arrayed;
+		bool ms;
+		uint32_t sampled;
+		spv::ImageFormat format;
+		spv::AccessQualifier access;
+	} image;
+
+	// Structs can be declared multiple times if they are used as part of interface blocks.
+	// We want to detect this so that we only emit the struct definition once.
+	// Since we cannot rely on OpName to be equal, we need to figure out aliases.
+	TypeID type_alias = 0;
+
+	// Denotes the type which this type is based on.
+	// Allows the backend to traverse how a complex type is built up during access chains.
+	TypeID parent_type = 0;
+
+	// Used in backends to avoid emitting members with conflicting names.
+	std::unordered_set<std::string> member_name_cache;
+
+	SPIRV_CROSS_DECLARE_CLONE(SPIRType)
+};
+
+struct SPIRExtension : IVariant
+{
+	enum
+	{
+		type = TypeExtension
+	};
+
+	enum Extension
+	{
+		Unsupported,
+		GLSL,
+		SPV_debug_info,
+		SPV_AMD_shader_ballot,
+		SPV_AMD_shader_explicit_vertex_parameter,
+		SPV_AMD_shader_trinary_minmax,
+		SPV_AMD_gcn_shader
+	};
+
+	explicit SPIRExtension(Extension ext_)
+	    : ext(ext_)
+	{
+	}
+
+	Extension ext;
+	SPIRV_CROSS_DECLARE_CLONE(SPIRExtension)
+};
+
+// SPIREntryPoint is not a variant since its IDs are used to decorate OpFunction,
+// so in order to avoid conflicts, we can't stick them in the ids array.
+struct SPIREntryPoint
+{
+	SPIREntryPoint(FunctionID self_, spv::ExecutionModel execution_model, const std::string &entry_name)
+	    : self(self_)
+	    , name(entry_name)
+	    , orig_name(entry_name)
+	    , model(execution_model)
+	{
+	}
+	SPIREntryPoint() = default;
+
+	FunctionID self = 0;
+	std::string name;
+	std::string orig_name;
+	SmallVector<VariableID> interface_variables;
+
+	Bitset flags;
+	struct WorkgroupSize
+	{
+		uint32_t x = 0, y = 0, z = 0;
+		uint32_t constant = 0; // Workgroup size can be expressed as a constant/spec-constant instead.
+	} workgroup_size;
+	uint32_t invocations = 0;
+	uint32_t output_vertices = 0;
+	spv::ExecutionModel model = spv::ExecutionModelMax;
+	bool geometry_passthrough = false;
+};
+
+struct SPIRExpression : IVariant
+{
+	enum
+	{
+		type = TypeExpression
+	};
+
+	// Only created by the backend target to avoid creating tons of temporaries.
+	SPIRExpression(std::string expr, TypeID expression_type_, bool immutable_)
+	    : expression(move(expr))
+	    , expression_type(expression_type_)
+	    , immutable(immutable_)
+	{
+	}
+
+	// If non-zero, prepend expression with to_expression(base_expression).
+	// Used in amortizing multiple calls to to_expression()
+	// where in certain cases that would quickly force a temporary when not needed.
+	ID base_expression = 0;
+
+	std::string expression;
+	TypeID expression_type = 0;
+
+	// If this expression is a forwarded load,
+	// allow us to reference the original variable.
+	ID loaded_from = 0;
+
+	// If this expression will never change, we can avoid lots of temporaries
+	// in high level source.
+	// An expression being immutable can be speculative,
+	// it is assumed that this is true almost always.
+	bool immutable = false;
+
+	// Before use, this expression must be transposed.
+	// This is needed for targets which don't support row_major layouts.
+	bool need_transpose = false;
+
+	// Whether or not this is an access chain expression.
+	bool access_chain = false;
+
+	// A list of expressions which this expression depends on.
+	SmallVector<ID> expression_dependencies;
+
+	// By reading this expression, we implicitly read these expressions as well.
+	// Used by access chain Store and Load since we read multiple expressions in this case.
+	SmallVector<ID> implied_read_expressions;
+
+	// The expression was emitted at a certain scope. Lets us track when an expression read means multiple reads.
+	uint32_t emitted_loop_level = 0;
+
+	SPIRV_CROSS_DECLARE_CLONE(SPIRExpression)
+};
+
+struct SPIRFunctionPrototype : IVariant
+{
+	enum
+	{
+		type = TypeFunctionPrototype
+	};
+
+	explicit SPIRFunctionPrototype(TypeID return_type_)
+	    : return_type(return_type_)
+	{
+	}
+
+	TypeID return_type;
+	SmallVector<uint32_t> parameter_types;
+
+	SPIRV_CROSS_DECLARE_CLONE(SPIRFunctionPrototype)
+};
+
+struct SPIRBlock : IVariant
+{
+	enum
+	{
+		type = TypeBlock
+	};
+
+	enum Terminator
+	{
+		Unknown,
+		Direct, // Emit next block directly without a particular condition.
+
+		Select, // Block ends with an if/else block.
+		MultiSelect, // Block ends with switch statement.
+
+		Return, // Block ends with return.
+		Unreachable, // Noop
+		Kill // Discard
+	};
+
+	enum Merge
+	{
+		MergeNone,
+		MergeLoop,
+		MergeSelection
+	};
+
+	enum Hints
+	{
+		HintNone,
+		HintUnroll,
+		HintDontUnroll,
+		HintFlatten,
+		HintDontFlatten
+	};
+
+	enum Method
+	{
+		MergeToSelectForLoop,
+		MergeToDirectForLoop,
+		MergeToSelectContinueForLoop
+	};
+
+	enum ContinueBlockType
+	{
+		ContinueNone,
+
+		// Continue block is branchless and has at least one instruction.
+		ForLoop,
+
+		// Noop continue block.
+		WhileLoop,
+
+		// Continue block is conditional.
+		DoWhileLoop,
+
+		// Highly unlikely that anything will use this,
+		// since it is really awkward/impossible to express in GLSL.
+		ComplexLoop
+	};
+
+	enum : uint32_t
+	{
+		NoDominator = 0xffffffffu
+	};
+
+	Terminator terminator = Unknown;
+	Merge merge = MergeNone;
+	Hints hint = HintNone;
+	BlockID next_block = 0;
+	BlockID merge_block = 0;
+	BlockID continue_block = 0;
+
+	ID return_value = 0; // If 0, return nothing (void).
+	ID condition = 0;
+	BlockID true_block = 0;
+	BlockID false_block = 0;
+	BlockID default_block = 0;
+
+	SmallVector<Instruction> ops;
+
+	struct Phi
+	{
+		ID local_variable; // flush local variable ...
+		BlockID parent; // If we're in from_block and want to branch into this block ...
+		VariableID function_variable; // to this function-global "phi" variable first.
+	};
+
+	// Before entering this block flush out local variables to magical "phi" variables.
+	SmallVector<Phi> phi_variables;
+
+	// Declare these temporaries before beginning the block.
+	// Used for handling complex continue blocks which have side effects.
+	SmallVector<std::pair<TypeID, ID>> declare_temporary;
+
+	// Declare these temporaries, but only conditionally if this block turns out to be
+	// a complex loop header.
+	SmallVector<std::pair<TypeID, ID>> potential_declare_temporary;
+
+	struct Case
+	{
+		uint32_t value;
+		BlockID block;
+	};
+	SmallVector<Case> cases;
+
+	// If we have tried to optimize code for this block but failed,
+	// keep track of this.
+	bool disable_block_optimization = false;
+
+	// If the continue block is complex, fallback to "dumb" for loops.
+	bool complex_continue = false;
+
+	// Do we need a ladder variable to defer breaking out of a loop construct after a switch block?
+	bool need_ladder_break = false;
+
+	// If marked, we have explicitly handled Phi from this block, so skip any flushes related to that on a branch.
+	// Used to handle an edge case with switch and case-label fallthrough where fall-through writes to Phi.
+	BlockID ignore_phi_from_block = 0;
+
+	// The dominating block which this block might be within.
+	// Used in continue; blocks to determine if we really need to write continue.
+	BlockID loop_dominator = 0;
+
+	// All access to these variables are dominated by this block,
+	// so before branching anywhere we need to make sure that we declare these variables.
+	SmallVector<VariableID> dominated_variables;
+
+	// These are variables which should be declared in a for loop header, if we
+	// fail to use a classic for-loop,
+	// we remove these variables, and fall back to regular variables outside the loop.
+	SmallVector<VariableID> loop_variables;
+
+	// Some expressions are control-flow dependent, i.e. any instruction which relies on derivatives or
+	// sub-group-like operations.
+	// Make sure that we only use these expressions in the original block.
+	SmallVector<ID> invalidate_expressions;
+
+	SPIRV_CROSS_DECLARE_CLONE(SPIRBlock)
+};
+
+struct SPIRFunction : IVariant
+{
+	enum
+	{
+		type = TypeFunction
+	};
+
+	SPIRFunction(TypeID return_type_, TypeID function_type_)
+	    : return_type(return_type_)
+	    , function_type(function_type_)
+	{
+	}
+
+	struct Parameter
+	{
+		TypeID type;
+		ID id;
+		uint32_t read_count;
+		uint32_t write_count;
+
+		// Set to true if this parameter aliases a global variable,
+		// used mostly in Metal where global variables
+		// have to be passed down to functions as regular arguments.
+		// However, for this kind of variable, we should not care about
+		// read and write counts as access to the function arguments
+		// is not local to the function in question.
+		bool alias_global_variable;
+	};
+
+	// When calling a function, and we're remapping separate image samplers,
+	// resolve these arguments into combined image samplers and pass them
+	// as additional arguments in this order.
+	// It gets more complicated as functions can pull in their own globals
+	// and combine them with parameters,
+	// so we need to distinguish if something is local parameter index
+	// or a global ID.
+	struct CombinedImageSamplerParameter
+	{
+		VariableID id;
+		VariableID image_id;
+		VariableID sampler_id;
+		bool global_image;
+		bool global_sampler;
+		bool depth;
+	};
+
+	TypeID return_type;
+	TypeID function_type;
+	SmallVector<Parameter> arguments;
+
+	// Can be used by backends to add magic arguments.
+	// Currently used by combined image/sampler implementation.
+
+	SmallVector<Parameter> shadow_arguments;
+	SmallVector<VariableID> local_variables;
+	BlockID entry_block = 0;
+	SmallVector<BlockID> blocks;
+	SmallVector<CombinedImageSamplerParameter> combined_parameters;
+
+	struct EntryLine
+	{
+		uint32_t file_id = 0;
+		uint32_t line_literal = 0;
+	};
+	EntryLine entry_line;
+
+	void add_local_variable(VariableID id)
+	{
+		local_variables.push_back(id);
+	}
+
+	void add_parameter(TypeID parameter_type, ID id, bool alias_global_variable = false)
+	{
+		// Arguments are read-only until proven otherwise.
+		arguments.push_back({ parameter_type, id, 0u, 0u, alias_global_variable });
+	}
+
+	// Hooks to be run when the function returns.
+	// Mostly used for lowering internal data structures onto flattened structures.
+	// Need to defer this, because they might rely on things which change during compilation.
+	// Intentionally not a small vector, this one is rare, and std::function can be large.
+	Vector<std::function<void()>> fixup_hooks_out;
+
+	// Hooks to be run when the function begins.
+	// Mostly used for populating internal data structures from flattened structures.
+	// Need to defer this, because they might rely on things which change during compilation.
+	// Intentionally not a small vector, this one is rare, and std::function can be large.
+	Vector<std::function<void()>> fixup_hooks_in;
+
+	// On function entry, make sure to copy a constant array into thread addr space to work around
+	// the case where we are passing a constant array by value to a function on backends which do not
+	// consider arrays value types.
+	SmallVector<ID> constant_arrays_needed_on_stack;
+
+	bool active = false;
+	bool flush_undeclared = true;
+	bool do_combined_parameters = true;
+
+	SPIRV_CROSS_DECLARE_CLONE(SPIRFunction)
+};
+
+struct SPIRAccessChain : IVariant
+{
+	enum
+	{
+		type = TypeAccessChain
+	};
+
+	SPIRAccessChain(TypeID basetype_, spv::StorageClass storage_, std::string base_, std::string dynamic_index_,
+	                int32_t static_index_)
+	    : basetype(basetype_)
+	    , storage(storage_)
+	    , base(std::move(base_))
+	    , dynamic_index(std::move(dynamic_index_))
+	    , static_index(static_index_)
+	{
+	}
+
+	// The access chain represents an offset into a buffer.
+	// Some backends need more complicated handling of access chains to be able to use buffers, like HLSL
+	// which has no usable buffer type ala GLSL SSBOs.
+	// StructuredBuffer is too limited, so our only option is to deal with ByteAddressBuffer which works with raw addresses.
+
+	TypeID basetype;
+	spv::StorageClass storage;
+	std::string base;
+	std::string dynamic_index;
+	int32_t static_index;
+
+	VariableID loaded_from = 0;
+	uint32_t matrix_stride = 0;
+	uint32_t array_stride = 0;
+	bool row_major_matrix = false;
+	bool immutable = false;
+
+	// By reading this expression, we implicitly read these expressions as well.
+	// Used by access chain Store and Load since we read multiple expressions in this case.
+	SmallVector<ID> implied_read_expressions;
+
+	SPIRV_CROSS_DECLARE_CLONE(SPIRAccessChain)
+};
+
+struct SPIRVariable : IVariant
+{
+	enum
+	{
+		type = TypeVariable
+	};
+
+	SPIRVariable() = default;
+	SPIRVariable(TypeID basetype_, spv::StorageClass storage_, ID initializer_ = 0, VariableID basevariable_ = 0)
+	    : basetype(basetype_)
+	    , storage(storage_)
+	    , initializer(initializer_)
+	    , basevariable(basevariable_)
+	{
+	}
+
+	TypeID basetype = 0;
+	spv::StorageClass storage = spv::StorageClassGeneric;
+	uint32_t decoration = 0;
+	ID initializer = 0;
+	VariableID basevariable = 0;
+
+	SmallVector<uint32_t> dereference_chain;
+	bool compat_builtin = false;
+
+	// If a variable is shadowed, we only statically assign to it
+	// and never actually emit a statement for it.
+	// When we read the variable as an expression, just forward
+	// shadowed_id as the expression.
+	bool statically_assigned = false;
+	ID static_expression = 0;
+
+	// Temporaries which can remain forwarded as long as this variable is not modified.
+	SmallVector<ID> dependees;
+	bool forwardable = true;
+
+	bool deferred_declaration = false;
+	bool phi_variable = false;
+
+	// Used to deal with Phi variable flushes. See flush_phi().
+	bool allocate_temporary_copy = false;
+
+	bool remapped_variable = false;
+	uint32_t remapped_components = 0;
+
+	// The block which dominates all access to this variable.
+	BlockID dominator = 0;
+	// If true, this variable is a loop variable, when accessing the variable
+	// outside a loop,
+	// we should statically forward it.
+	bool loop_variable = false;
+	// Set to true while we're inside the for loop.
+	bool loop_variable_enable = false;
+
+	SPIRFunction::Parameter *parameter = nullptr;
+
+	SPIRV_CROSS_DECLARE_CLONE(SPIRVariable)
+};
+
+struct SPIRConstant : IVariant
+{
+	enum
+	{
+		type = TypeConstant
+	};
+
+	union Constant
+	{
+		uint32_t u32;
+		int32_t i32;
+		float f32;
+
+		uint64_t u64;
+		int64_t i64;
+		double f64;
+	};
+
+	struct ConstantVector
+	{
+		Constant r[4];
+		// If != 0, this element is a specialization constant, and we should keep track of it as such.
+		ID id[4];
+		uint32_t vecsize = 1;
+
+		ConstantVector()
+		{
+			memset(r, 0, sizeof(r));
+		}
+	};
+
+	struct ConstantMatrix
+	{
+		ConstantVector c[4];
+		// If != 0, this column is a specialization constant, and we should keep track of it as such.
+		ID id[4];
+		uint32_t columns = 1;
+	};
+
+	static inline float f16_to_f32(uint16_t u16_value)
+	{
+		// Based on the GLM implementation.
+		int s = (u16_value >> 15) & 0x1;
+		int e = (u16_value >> 10) & 0x1f;
+		int m = (u16_value >> 0) & 0x3ff;
+
+		union
+		{
+			float f32;
+			uint32_t u32;
+		} u;
+
+		if (e == 0)
+		{
+			if (m == 0)
+			{
+				u.u32 = uint32_t(s) << 31;
+				return u.f32;
+			}
+			else
+			{
+				while ((m & 0x400) == 0)
+				{
+					m <<= 1;
+					e--;
+				}
+
+				e++;
+				m &= ~0x400;
+			}
+		}
+		else if (e == 31)
+		{
+			if (m == 0)
+			{
+				u.u32 = (uint32_t(s) << 31) | 0x7f800000u;
+				return u.f32;
+			}
+			else
+			{
+				u.u32 = (uint32_t(s) << 31) | 0x7f800000u | (m << 13);
+				return u.f32;
+			}
+		}
+
+		e += 127 - 15;
+		m <<= 13;
+		u.u32 = (uint32_t(s) << 31) | (e << 23) | m;
+		return u.f32;
+	}
+
+	inline uint32_t specialization_constant_id(uint32_t col, uint32_t row) const
+	{
+		return m.c[col].id[row];
+	}
+
+	inline uint32_t specialization_constant_id(uint32_t col) const
+	{
+		return m.id[col];
+	}
+
+	inline uint32_t scalar(uint32_t col = 0, uint32_t row = 0) const
+	{
+		return m.c[col].r[row].u32;
+	}
+
+	inline int16_t scalar_i16(uint32_t col = 0, uint32_t row = 0) const
+	{
+		return int16_t(m.c[col].r[row].u32 & 0xffffu);
+	}
+
+	inline uint16_t scalar_u16(uint32_t col = 0, uint32_t row = 0) const
+	{
+		return uint16_t(m.c[col].r[row].u32 & 0xffffu);
+	}
+
+	inline int8_t scalar_i8(uint32_t col = 0, uint32_t row = 0) const
+	{
+		return int8_t(m.c[col].r[row].u32 & 0xffu);
+	}
+
+	inline uint8_t scalar_u8(uint32_t col = 0, uint32_t row = 0) const
+	{
+		return uint8_t(m.c[col].r[row].u32 & 0xffu);
+	}
+
+	inline float scalar_f16(uint32_t col = 0, uint32_t row = 0) const
+	{
+		return f16_to_f32(scalar_u16(col, row));
+	}
+
+	inline float scalar_f32(uint32_t col = 0, uint32_t row = 0) const
+	{
+		return m.c[col].r[row].f32;
+	}
+
+	inline int32_t scalar_i32(uint32_t col = 0, uint32_t row = 0) const
+	{
+		return m.c[col].r[row].i32;
+	}
+
+	inline double scalar_f64(uint32_t col = 0, uint32_t row = 0) const
+	{
+		return m.c[col].r[row].f64;
+	}
+
+	inline int64_t scalar_i64(uint32_t col = 0, uint32_t row = 0) const
+	{
+		return m.c[col].r[row].i64;
+	}
+
+	inline uint64_t scalar_u64(uint32_t col = 0, uint32_t row = 0) const
+	{
+		return m.c[col].r[row].u64;
+	}
+
+	inline const ConstantVector &vector() const
+	{
+		return m.c[0];
+	}
+
+	inline uint32_t vector_size() const
+	{
+		return m.c[0].vecsize;
+	}
+
+	inline uint32_t columns() const
+	{
+		return m.columns;
+	}
+
+	inline void make_null(const SPIRType &constant_type_)
+	{
+		m = {};
+		m.columns = constant_type_.columns;
+		for (auto &c : m.c)
+			c.vecsize = constant_type_.vecsize;
+	}
+
+	inline bool constant_is_null() const
+	{
+		if (specialization)
+			return false;
+		if (!subconstants.empty())
+			return false;
+
+		for (uint32_t col = 0; col < columns(); col++)
+			for (uint32_t row = 0; row < vector_size(); row++)
+				if (scalar_u64(col, row) != 0)
+					return false;
+
+		return true;
+	}
+
+	explicit SPIRConstant(uint32_t constant_type_)
+	    : constant_type(constant_type_)
+	{
+	}
+
+	SPIRConstant() = default;
+
+	SPIRConstant(TypeID constant_type_, const uint32_t *elements, uint32_t num_elements, bool specialized)
+	    : constant_type(constant_type_)
+	    , specialization(specialized)
+	{
+		subconstants.reserve(num_elements);
+		for (uint32_t i = 0; i < num_elements; i++)
+			subconstants.push_back(elements[i]);
+		specialization = specialized;
+	}
+
+	// Construct scalar (32-bit).
+	SPIRConstant(TypeID constant_type_, uint32_t v0, bool specialized)
+	    : constant_type(constant_type_)
+	    , specialization(specialized)
+	{
+		m.c[0].r[0].u32 = v0;
+		m.c[0].vecsize = 1;
+		m.columns = 1;
+	}
+
+	// Construct scalar (64-bit).
+	SPIRConstant(TypeID constant_type_, uint64_t v0, bool specialized)
+	    : constant_type(constant_type_)
+	    , specialization(specialized)
+	{
+		m.c[0].r[0].u64 = v0;
+		m.c[0].vecsize = 1;
+		m.columns = 1;
+	}
+
+	// Construct vectors and matrices.
+	SPIRConstant(TypeID constant_type_, const SPIRConstant *const *vector_elements, uint32_t num_elements,
+	             bool specialized)
+	    : constant_type(constant_type_)
+	    , specialization(specialized)
+	{
+		bool matrix = vector_elements[0]->m.c[0].vecsize > 1;
+
+		if (matrix)
+		{
+			m.columns = num_elements;
+
+			for (uint32_t i = 0; i < num_elements; i++)
+			{
+				m.c[i] = vector_elements[i]->m.c[0];
+				if (vector_elements[i]->specialization)
+					m.id[i] = vector_elements[i]->self;
+			}
+		}
+		else
+		{
+			m.c[0].vecsize = num_elements;
+			m.columns = 1;
+
+			for (uint32_t i = 0; i < num_elements; i++)
+			{
+				m.c[0].r[i] = vector_elements[i]->m.c[0].r[0];
+				if (vector_elements[i]->specialization)
+					m.c[0].id[i] = vector_elements[i]->self;
+			}
+		}
+	}
+
+	TypeID constant_type = 0;
+	ConstantMatrix m;
+
+	// If this constant is a specialization constant (i.e. created with OpSpecConstant*).
+	bool specialization = false;
+	// If this constant is used as an array length which creates specialization restrictions on some backends.
+	bool is_used_as_array_length = false;
+
+	// If true, this is a LUT, and should always be declared in the outer scope.
+	bool is_used_as_lut = false;
+
+	// For composites which are constant arrays, etc.
+	SmallVector<ConstantID> subconstants;
+
+	// Non-Vulkan GLSL, HLSL and sometimes MSL emits defines for each specialization constant,
+	// and uses them to initialize the constant. This allows the user
+	// to still be able to specialize the value by supplying corresponding
+	// preprocessor directives before compiling the shader.
+	std::string specialization_constant_macro_name;
+
+	SPIRV_CROSS_DECLARE_CLONE(SPIRConstant)
+};
+
+// Variants have a very specific allocation scheme.
+struct ObjectPoolGroup
+{
+	std::unique_ptr<ObjectPoolBase> pools[TypeCount];
+};
+
+class Variant
+{
+public:
+	explicit Variant(ObjectPoolGroup *group_)
+	    : group(group_)
+	{
+	}
+
+	~Variant()
+	{
+		if (holder)
+			group->pools[type]->free_opaque(holder);
+	}
+
+	// Marking custom move constructor as noexcept is important.
+	Variant(Variant &&other) SPIRV_CROSS_NOEXCEPT
+	{
+		*this = std::move(other);
+	}
+
+	// We cannot copy from other variant without our own pool group.
+	// Have to explicitly copy.
+	Variant(const Variant &variant) = delete;
+
+	// Marking custom move constructor as noexcept is important.
+	Variant &operator=(Variant &&other) SPIRV_CROSS_NOEXCEPT
+	{
+		if (this != &other)
+		{
+			if (holder)
+				group->pools[type]->free_opaque(holder);
+			holder = other.holder;
+			group = other.group;
+			type = other.type;
+			allow_type_rewrite = other.allow_type_rewrite;
+
+			other.holder = nullptr;
+			other.type = TypeNone;
+		}
+		return *this;
+	}
+
+	// This copy/clone should only be called in the Compiler constructor.
+	// If this is called inside ::compile(), we invalidate any references we took higher in the stack.
+	// This should never happen.
+	Variant &operator=(const Variant &other)
+	{
+//#define SPIRV_CROSS_COPY_CONSTRUCTOR_SANITIZE
+#ifdef SPIRV_CROSS_COPY_CONSTRUCTOR_SANITIZE
+		abort();
+#endif
+		if (this != &other)
+		{
+			if (holder)
+				group->pools[type]->free_opaque(holder);
+
+			if (other.holder)
+				holder = other.holder->clone(group->pools[other.type].get());
+			else
+				holder = nullptr;
+
+			type = other.type;
+			allow_type_rewrite = other.allow_type_rewrite;
+		}
+		return *this;
+	}
+
+	void set(IVariant *val, Types new_type)
+	{
+		if (holder)
+			group->pools[type]->free_opaque(holder);
+		holder = nullptr;
+
+		if (!allow_type_rewrite && type != TypeNone && type != new_type)
+		{
+			if (val)
+				group->pools[new_type]->free_opaque(val);
+			SPIRV_CROSS_THROW("Overwriting a variant with new type.");
+		}
+
+		holder = val;
+		type = new_type;
+		allow_type_rewrite = false;
+	}
+
+	template <typename T, typename... Ts>
+	T *allocate_and_set(Types new_type, Ts &&... ts)
+	{
+		T *val = static_cast<ObjectPool<T> &>(*group->pools[new_type]).allocate(std::forward<Ts>(ts)...);
+		set(val, new_type);
+		return val;
+	}
+
+	template <typename T>
+	T &get()
+	{
+		if (!holder)
+			SPIRV_CROSS_THROW("nullptr");
+		if (static_cast<Types>(T::type) != type)
+			SPIRV_CROSS_THROW("Bad cast");
+		return *static_cast<T *>(holder);
+	}
+
+	template <typename T>
+	const T &get() const
+	{
+		if (!holder)
+			SPIRV_CROSS_THROW("nullptr");
+		if (static_cast<Types>(T::type) != type)
+			SPIRV_CROSS_THROW("Bad cast");
+		return *static_cast<const T *>(holder);
+	}
+
+	Types get_type() const
+	{
+		return type;
+	}
+
+	ID get_id() const
+	{
+		return holder ? holder->self : ID(0);
+	}
+
+	bool empty() const
+	{
+		return !holder;
+	}
+
+	void reset()
+	{
+		if (holder)
+			group->pools[type]->free_opaque(holder);
+		holder = nullptr;
+		type = TypeNone;
+	}
+
+	void set_allow_type_rewrite()
+	{
+		allow_type_rewrite = true;
+	}
+
+private:
+	ObjectPoolGroup *group = nullptr;
+	IVariant *holder = nullptr;
+	Types type = TypeNone;
+	bool allow_type_rewrite = false;
+};
+
+template <typename T>
+T &variant_get(Variant &var)
+{
+	return var.get<T>();
+}
+
+template <typename T>
+const T &variant_get(const Variant &var)
+{
+	return var.get<T>();
+}
+
+template <typename T, typename... P>
+T &variant_set(Variant &var, P &&... args)
+{
+	auto *ptr = var.allocate_and_set<T>(static_cast<Types>(T::type), std::forward<P>(args)...);
+	return *ptr;
+}
+
+struct AccessChainMeta
+{
+	uint32_t storage_physical_type = 0;
+	bool need_transpose = false;
+	bool storage_is_packed = false;
+	bool storage_is_invariant = false;
+	bool flattened_struct = false;
+};
+
+enum ExtendedDecorations
+{
+	// Marks if a buffer block is re-packed, i.e. member declaration might be subject to PhysicalTypeID remapping and padding.
+	SPIRVCrossDecorationBufferBlockRepacked = 0,
+
+	// A type in a buffer block might be declared with a different physical type than the logical type.
+	// If this is not set, PhysicalTypeID == the SPIR-V type as declared.
+	SPIRVCrossDecorationPhysicalTypeID,
+
+	// Marks if the physical type is to be declared with tight packing rules, i.e. packed_floatN on MSL and friends.
+	// If this is set, PhysicalTypeID might also be set. It can be set to same as logical type if all we're doing
+	// is converting float3 to packed_float3 for example.
+	// If this is marked on a struct, it means the struct itself must use only Packed types for all its members.
+	SPIRVCrossDecorationPhysicalTypePacked,
+
+	// The padding in bytes before declaring this struct member.
+	// If used on a struct type, marks the target size of a struct.
+	SPIRVCrossDecorationPaddingTarget,
+
+	SPIRVCrossDecorationInterfaceMemberIndex,
+	SPIRVCrossDecorationInterfaceOrigID,
+	SPIRVCrossDecorationResourceIndexPrimary,
+	// Used for decorations like resource indices for samplers when part of combined image samplers.
+	// A variable might need to hold two resource indices in this case.
+	SPIRVCrossDecorationResourceIndexSecondary,
+	// Used for resource indices for multiplanar images when part of combined image samplers.
+	SPIRVCrossDecorationResourceIndexTertiary,
+	SPIRVCrossDecorationResourceIndexQuaternary,
+
+	// Marks a buffer block for using explicit offsets (GLSL/HLSL).
+	SPIRVCrossDecorationExplicitOffset,
+
+	// Apply to a variable in the Input storage class; marks it as holding the base group passed to vkCmdDispatchBase(),
+	// or the base vertex and instance indices passed to vkCmdDrawIndexed().
+	// In MSL, this is used to adjust the WorkgroupId and GlobalInvocationId variables in compute shaders,
+	// and to hold the BaseVertex and BaseInstance variables in vertex shaders.
+	SPIRVCrossDecorationBuiltInDispatchBase,
+
+	// Apply to a variable that is a function parameter; marks it as being a "dynamic"
+	// combined image-sampler. In MSL, this is used when a function parameter might hold
+	// either a regular combined image-sampler or one that has an attached sampler
+	// Y'CbCr conversion.
+	SPIRVCrossDecorationDynamicImageSampler,
+
+	// Apply to a variable in the Input storage class; marks it as holding the size of the stage
+	// input grid.
+	// In MSL, this is used to hold the vertex and instance counts in a tessellation pipeline
+	// vertex shader.
+	SPIRVCrossDecorationBuiltInStageInputSize,
+
+	// Apply to any access chain of a tessellation I/O variable; stores the type of the sub-object
+	// that was chained to, as recorded in the input variable itself. This is used in case the pointer
+	// is itself used as the base of an access chain, to calculate the original type of the sub-object
+	// chained to, in case a swizzle needs to be applied. This should not happen normally with valid
+	// SPIR-V, but the MSL backend can change the type of input variables, necessitating the
+	// addition of swizzles to keep the generated code compiling.
+	SPIRVCrossDecorationTessIOOriginalInputTypeID,
+
+	SPIRVCrossDecorationCount
+};
+
+struct Meta
+{
+	struct Decoration
+	{
+		std::string alias;
+		std::string qualified_alias;
+		std::string hlsl_semantic;
+		Bitset decoration_flags;
+		spv::BuiltIn builtin_type = spv::BuiltInMax;
+		uint32_t location = 0;
+		uint32_t component = 0;
+		uint32_t set = 0;
+		uint32_t binding = 0;
+		uint32_t offset = 0;
+		uint32_t xfb_buffer = 0;
+		uint32_t xfb_stride = 0;
+		uint32_t array_stride = 0;
+		uint32_t matrix_stride = 0;
+		uint32_t input_attachment = 0;
+		uint32_t spec_id = 0;
+		uint32_t index = 0;
+		spv::FPRoundingMode fp_rounding_mode = spv::FPRoundingModeMax;
+		bool builtin = false;
+
+		struct Extended
+		{
+			Extended()
+			{
+				// MSVC 2013 workaround to init like this.
+				for (auto &v : values)
+					v = 0;
+			}
+
+			Bitset flags;
+			uint32_t values[SPIRVCrossDecorationCount];
+		} extended;
+	};
+
+	Decoration decoration;
+
+	// Intentionally not a SmallVector. Decoration is large and somewhat rare.
+	Vector<Decoration> members;
+
+	std::unordered_map<uint32_t, uint32_t> decoration_word_offset;
+
+	// For SPV_GOOGLE_hlsl_functionality1.
+	bool hlsl_is_magic_counter_buffer = false;
+	// ID for the sibling counter buffer.
+	uint32_t hlsl_magic_counter_buffer = 0;
+};
+
+// A user callback that remaps the type of any variable.
+// var_name is the declared name of the variable.
+// name_of_type is the textual name of the type which will be used in the code unless written to by the callback.
+using VariableTypeRemapCallback =
+    std::function<void(const SPIRType &type, const std::string &var_name, std::string &name_of_type)>;
+
+class Hasher
+{
+public:
+	inline void u32(uint32_t value)
+	{
+		h = (h * 0x100000001b3ull) ^ value;
+	}
+
+	inline uint64_t get() const
+	{
+		return h;
+	}
+
+private:
+	uint64_t h = 0xcbf29ce484222325ull;
+};
+
+static inline bool type_is_floating_point(const SPIRType &type)
+{
+	return type.basetype == SPIRType::Half || type.basetype == SPIRType::Float || type.basetype == SPIRType::Double;
+}
+
+static inline bool type_is_integral(const SPIRType &type)
+{
+	return type.basetype == SPIRType::SByte || type.basetype == SPIRType::UByte || type.basetype == SPIRType::Short ||
+	       type.basetype == SPIRType::UShort || type.basetype == SPIRType::Int || type.basetype == SPIRType::UInt ||
+	       type.basetype == SPIRType::Int64 || type.basetype == SPIRType::UInt64;
+}
+
+static inline SPIRType::BaseType to_signed_basetype(uint32_t width)
+{
+	switch (width)
+	{
+	case 8:
+		return SPIRType::SByte;
+	case 16:
+		return SPIRType::Short;
+	case 32:
+		return SPIRType::Int;
+	case 64:
+		return SPIRType::Int64;
+	default:
+		SPIRV_CROSS_THROW("Invalid bit width.");
+	}
+}
+
+static inline SPIRType::BaseType to_unsigned_basetype(uint32_t width)
+{
+	switch (width)
+	{
+	case 8:
+		return SPIRType::UByte;
+	case 16:
+		return SPIRType::UShort;
+	case 32:
+		return SPIRType::UInt;
+	case 64:
+		return SPIRType::UInt64;
+	default:
+		SPIRV_CROSS_THROW("Invalid bit width.");
+	}
+}
+
+// Returns true if an arithmetic operation does not change behavior depending on signedness.
+static inline bool opcode_is_sign_invariant(spv::Op opcode)
+{
+	switch (opcode)
+	{
+	case spv::OpIEqual:
+	case spv::OpINotEqual:
+	case spv::OpISub:
+	case spv::OpIAdd:
+	case spv::OpIMul:
+	case spv::OpShiftLeftLogical:
+	case spv::OpBitwiseOr:
+	case spv::OpBitwiseXor:
+	case spv::OpBitwiseAnd:
+		return true;
+
+	default:
+		return false;
+	}
+}
+
+struct SetBindingPair
+{
+	uint32_t desc_set;
+	uint32_t binding;
+
+	inline bool operator==(const SetBindingPair &other) const
+	{
+		return desc_set == other.desc_set && binding == other.binding;
+	}
+
+	inline bool operator<(const SetBindingPair &other) const
+	{
+		return desc_set < other.desc_set || (desc_set == other.desc_set && binding < other.binding);
+	}
+};
+
+struct StageSetBinding
+{
+	spv::ExecutionModel model;
+	uint32_t desc_set;
+	uint32_t binding;
+
+	inline bool operator==(const StageSetBinding &other) const
+	{
+		return model == other.model && desc_set == other.desc_set && binding == other.binding;
+	}
+};
+
+struct InternalHasher
+{
+	inline size_t operator()(const SetBindingPair &value) const
+	{
+		// Quality of hash doesn't really matter here.
+		auto hash_set = std::hash<uint32_t>()(value.desc_set);
+		auto hash_binding = std::hash<uint32_t>()(value.binding);
+		return (hash_set * 0x10001b31) ^ hash_binding;
+	}
+
+	inline size_t operator()(const StageSetBinding &value) const
+	{
+		// Quality of hash doesn't really matter here.
+		auto hash_model = std::hash<uint32_t>()(value.model);
+		auto hash_set = std::hash<uint32_t>()(value.desc_set);
+		auto tmp_hash = (hash_model * 0x10001b31) ^ hash_set;
+		return (tmp_hash * 0x10001b31) ^ value.binding;
+	}
+};
+
+// Special constant used in a {MSL,HLSL}ResourceBinding desc_set
+// element to indicate the bindings for the push constants.
+static const uint32_t ResourceBindingPushConstantDescriptorSet = ~(0u);
+
+// Special constant used in a {MSL,HLSL}ResourceBinding binding
+// element to indicate the bindings for the push constants.
+static const uint32_t ResourceBindingPushConstantBinding = 0;
+} // namespace SPIRV_CROSS_NAMESPACE
+
+namespace std
+{
+template <SPIRV_CROSS_NAMESPACE::Types type>
+struct hash<SPIRV_CROSS_NAMESPACE::TypedID<type>>
+{
+	size_t operator()(const SPIRV_CROSS_NAMESPACE::TypedID<type> &value) const
+	{
+		return std::hash<uint32_t>()(value);
+	}
+};
+} // namespace std
+
+#endif
diff --git a/engine/inc/spirv_cross/spirv_cpp.hpp b/engine/inc/spirv_cross/spirv_cpp.hpp
new file mode 100644
index 00000000..e78d0369
--- /dev/null
+++ b/engine/inc/spirv_cross/spirv_cpp.hpp
@@ -0,0 +1,86 @@
+/*
+ * Copyright 2015-2020 Arm Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SPIRV_CROSS_CPP_HPP
+#define SPIRV_CROSS_CPP_HPP
+
+#include "spirv_glsl.hpp"
+#include <utility>
+
+namespace SPIRV_CROSS_NAMESPACE
+{
+class CompilerCPP : public CompilerGLSL
+{
+public:
+	explicit CompilerCPP(std::vector<uint32_t> spirv_)
+	    : CompilerGLSL(std::move(spirv_))
+	{
+	}
+
+	CompilerCPP(const uint32_t *ir_, size_t word_count)
+	    : CompilerGLSL(ir_, word_count)
+	{
+	}
+
+	explicit CompilerCPP(const ParsedIR &ir_)
+	    : CompilerGLSL(ir_)
+	{
+	}
+
+	explicit CompilerCPP(ParsedIR &&ir_)
+	    : CompilerGLSL(std::move(ir_))
+	{
+	}
+
+	std::string compile() override;
+
+	// Sets a custom symbol name that can override
+	// spirv_cross_get_interface.
+	//
+	// Useful when several shader interfaces are linked
+	// statically into the same binary.
+	void set_interface_name(std::string name)
+	{
+		interface_name = std::move(name);
+	}
+
+private:
+	void emit_header() override;
+	void emit_c_linkage();
+	void emit_function_prototype(SPIRFunction &func, const Bitset &return_flags) override;
+
+	void emit_resources();
+	void emit_buffer_block(const SPIRVariable &type) override;
+	void emit_push_constant_block(const SPIRVariable &var) override;
+	void emit_interface_block(const SPIRVariable &type);
+	void emit_block_chain(SPIRBlock &block);
+	void emit_uniform(const SPIRVariable &var) override;
+	void emit_shared(const SPIRVariable &var);
+	void emit_block_struct(SPIRType &type);
+	std::string variable_decl(const SPIRType &type, const std::string &name, uint32_t id) override;
+
+	std::string argument_decl(const SPIRFunction::Parameter &arg);
+
+	SmallVector<std::string> resource_registrations;
+	std::string impl_type;
+	std::string resource_type;
+	uint32_t shared_counter = 0;
+
+	std::string interface_name;
+};
+} // namespace SPIRV_CROSS_NAMESPACE
+
+#endif
diff --git a/engine/inc/spirv_cross/spirv_cross.hpp b/engine/inc/spirv_cross/spirv_cross.hpp
new file mode 100644
index 00000000..17c08188
--- /dev/null
+++ b/engine/inc/spirv_cross/spirv_cross.hpp
@@ -0,0 +1,1070 @@
+/*
+ * Copyright 2015-2020 Arm Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SPIRV_CROSS_HPP
+#define SPIRV_CROSS_HPP
+
+#include "spirv.hpp"
+#include "spirv_cfg.hpp"
+#include "spirv_cross_parsed_ir.hpp"
+
+namespace SPIRV_CROSS_NAMESPACE
+{
+struct Resource
+{
+	// Resources are identified with their SPIR-V ID.
+	// This is the ID of the OpVariable.
+	ID id;
+
+	// The type ID of the variable which includes arrays and all type modifications.
+	// This type ID is not suitable for parsing OpMemberDecoration of a struct and other decorations in general
+	// since these modifications typically happen on the base_type_id.
+	TypeID type_id;
+
+	// The base type of the declared resource.
+	// This type is the base type which ignores pointers and arrays of the type_id.
+	// This is mostly useful to parse decorations of the underlying type.
+	// base_type_id can also be obtained with get_type(get_type(type_id).self).
+	TypeID base_type_id;
+
+	// The declared name (OpName) of the resource.
+	// For Buffer blocks, the name actually reflects the externally
+	// visible Block name.
+	//
+	// This name can be retrieved again by using either
+	// get_name(id) or get_name(base_type_id) depending if it's a buffer block or not.
+	//
+	// This name can be an empty string in which case get_fallback_name(id) can be
+	// used which obtains a suitable fallback identifier for an ID.
+	std::string name;
+};
+
+struct ShaderResources
+{
+	SmallVector<Resource> uniform_buffers;
+	SmallVector<Resource> storage_buffers;
+	SmallVector<Resource> stage_inputs;
+	SmallVector<Resource> stage_outputs;
+	SmallVector<Resource> subpass_inputs;
+	SmallVector<Resource> storage_images;
+	SmallVector<Resource> sampled_images;
+	SmallVector<Resource> atomic_counters;
+	SmallVector<Resource> acceleration_structures;
+
+	// There can only be one push constant block,
+	// but keep the vector in case this restriction is lifted in the future.
+	SmallVector<Resource> push_constant_buffers;
+
+	// For Vulkan GLSL and HLSL source,
+	// these correspond to separate texture2D and samplers respectively.
+	SmallVector<Resource> separate_images;
+	SmallVector<Resource> separate_samplers;
+};
+
+struct CombinedImageSampler
+{
+	// The ID of the sampler2D variable.
+	VariableID combined_id;
+	// The ID of the texture2D variable.
+	VariableID image_id;
+	// The ID of the sampler variable.
+	VariableID sampler_id;
+};
+
+struct SpecializationConstant
+{
+	// The ID of the specialization constant.
+	ConstantID id;
+	// The constant ID of the constant, used in Vulkan during pipeline creation.
+	uint32_t constant_id;
+};
+
+struct BufferRange
+{
+	unsigned index;
+	size_t offset;
+	size_t range;
+};
+
+enum BufferPackingStandard
+{
+	BufferPackingStd140,
+	BufferPackingStd430,
+	BufferPackingStd140EnhancedLayout,
+	BufferPackingStd430EnhancedLayout,
+	BufferPackingHLSLCbuffer,
+	BufferPackingHLSLCbufferPackOffset,
+	BufferPackingScalar,
+	BufferPackingScalarEnhancedLayout
+};
+
+struct EntryPoint
+{
+	std::string name;
+	spv::ExecutionModel execution_model;
+};
+
+class Compiler
+{
+public:
+	friend class CFG;
+	friend class DominatorBuilder;
+
+	// The constructor takes a buffer of SPIR-V words and parses it.
+	// It will create its own parser, parse the SPIR-V and move the parsed IR
+	// as if you had called the constructors taking ParsedIR directly.
+	explicit Compiler(std::vector<uint32_t> ir);
+	Compiler(const uint32_t *ir, size_t word_count);
+
+	// This is more modular. We can also consume a ParsedIR structure directly, either as a move, or copy.
+	// With copy, we can reuse the same parsed IR for multiple Compiler instances.
+	explicit Compiler(const ParsedIR &ir);
+	explicit Compiler(ParsedIR &&ir);
+
+	virtual ~Compiler() = default;
+
+	// After parsing, API users can modify the SPIR-V via reflection and call this
+	// to disassemble the SPIR-V into the desired langauage.
+	// Sub-classes actually implement this.
+	virtual std::string compile();
+
+	// Gets the identifier (OpName) of an ID. If not defined, an empty string will be returned.
+	const std::string &get_name(ID id) const;
+
+	// Applies a decoration to an ID. Effectively injects OpDecorate.
+	void set_decoration(ID id, spv::Decoration decoration, uint32_t argument = 0);
+	void set_decoration_string(ID id, spv::Decoration decoration, const std::string &argument);
+
+	// Overrides the identifier OpName of an ID.
+	// Identifiers beginning with underscores or identifiers which contain double underscores
+	// are reserved by the implementation.
+	void set_name(ID id, const std::string &name);
+
+	// Gets a bitmask for the decorations which are applied to ID.
+	// I.e. (1ull << spv::DecorationFoo) | (1ull << spv::DecorationBar)
+	const Bitset &get_decoration_bitset(ID id) const;
+
+	// Returns whether the decoration has been applied to the ID.
+	bool has_decoration(ID id, spv::Decoration decoration) const;
+
+	// Gets the value for decorations which take arguments.
+	// If the decoration is a boolean (i.e. spv::DecorationNonWritable),
+	// 1 will be returned.
+	// If decoration doesn't exist or decoration is not recognized,
+	// 0 will be returned.
+	uint32_t get_decoration(ID id, spv::Decoration decoration) const;
+	const std::string &get_decoration_string(ID id, spv::Decoration decoration) const;
+
+	// Removes the decoration for an ID.
+	void unset_decoration(ID id, spv::Decoration decoration);
+
+	// Gets the SPIR-V type associated with ID.
+	// Mostly used with Resource::type_id and Resource::base_type_id to parse the underlying type of a resource.
+	const SPIRType &get_type(TypeID id) const;
+
+	// Gets the SPIR-V type of a variable.
+	const SPIRType &get_type_from_variable(VariableID id) const;
+
+	// Gets the underlying storage class for an OpVariable.
+	spv::StorageClass get_storage_class(VariableID id) const;
+
+	// If get_name() is an empty string, get the fallback name which will be used
+	// instead in the disassembled source.
+	virtual const std::string get_fallback_name(ID id) const;
+
+	// If get_name() of a Block struct is an empty string, get the fallback name.
+	// This needs to be per-variable as multiple variables can use the same block type.
+	virtual const std::string get_block_fallback_name(VariableID id) const;
+
+	// Given an OpTypeStruct in ID, obtain the identifier for member number "index".
+	// This may be an empty string.
+	const std::string &get_member_name(TypeID id, uint32_t index) const;
+
+	// Given an OpTypeStruct in ID, obtain the OpMemberDecoration for member number "index".
+	uint32_t get_member_decoration(TypeID id, uint32_t index, spv::Decoration decoration) const;
+	const std::string &get_member_decoration_string(TypeID id, uint32_t index, spv::Decoration decoration) const;
+
+	// Sets the member identifier for OpTypeStruct ID, member number "index".
+	void set_member_name(TypeID id, uint32_t index, const std::string &name);
+
+	// Returns the qualified member identifier for OpTypeStruct ID, member number "index",
+	// or an empty string if no qualified alias exists
+	const std::string &get_member_qualified_name(TypeID type_id, uint32_t index) const;
+
+	// Gets the decoration mask for a member of a struct, similar to get_decoration_mask.
+	const Bitset &get_member_decoration_bitset(TypeID id, uint32_t index) const;
+
+	// Returns whether the decoration has been applied to a member of a struct.
+	bool has_member_decoration(TypeID id, uint32_t index, spv::Decoration decoration) const;
+
+	// Similar to set_decoration, but for struct members.
+	void set_member_decoration(TypeID id, uint32_t index, spv::Decoration decoration, uint32_t argument = 0);
+	void set_member_decoration_string(TypeID id, uint32_t index, spv::Decoration decoration,
+	                                  const std::string &argument);
+
+	// Unsets a member decoration, similar to unset_decoration.
+	void unset_member_decoration(TypeID id, uint32_t index, spv::Decoration decoration);
+
+	// Gets the fallback name for a member, similar to get_fallback_name.
+	virtual const std::string get_fallback_member_name(uint32_t index) const
+	{
+		return join("_", index);
+	}
+
+	// Returns a vector of which members of a struct are potentially in use by a
+	// SPIR-V shader. The granularity of this analysis is per-member of a struct.
+	// This can be used for Buffer (UBO), BufferBlock/StorageBuffer (SSBO) and PushConstant blocks.
+	// ID is the Resource::id obtained from get_shader_resources().
+	SmallVector<BufferRange> get_active_buffer_ranges(VariableID id) const;
+
+	// Returns the effective size of a buffer block.
+	size_t get_declared_struct_size(const SPIRType &struct_type) const;
+
+	// Returns the effective size of a buffer block, with a given array size
+	// for a runtime array.
+	// SSBOs are typically declared as runtime arrays. get_declared_struct_size() will return 0 for the size.
+	// This is not very helpful for applications which might need to know the array stride of its last member.
+	// This can be done through the API, but it is not very intuitive how to accomplish this, so here we provide a helper function
+	// to query the size of the buffer, assuming that the last member has a certain size.
+	// If the buffer does not contain a runtime array, array_size is ignored, and the function will behave as
+	// get_declared_struct_size().
+	// To get the array stride of the last member, something like:
+	// get_declared_struct_size_runtime_array(type, 1) - get_declared_struct_size_runtime_array(type, 0) will work.
+	size_t get_declared_struct_size_runtime_array(const SPIRType &struct_type, size_t array_size) const;
+
+	// Returns the effective size of a buffer block struct member.
+	size_t get_declared_struct_member_size(const SPIRType &struct_type, uint32_t index) const;
+
+	// Returns a set of all global variables which are statically accessed
+	// by the control flow graph from the current entry point.
+	// Only variables which change the interface for a shader are returned, that is,
+	// variables with storage class of Input, Output, Uniform, UniformConstant, PushConstant and AtomicCounter
+	// storage classes are returned.
+	//
+	// To use the returned set as the filter for which variables are used during compilation,
+	// this set can be moved to set_enabled_interface_variables().
+	std::unordered_set<VariableID> get_active_interface_variables() const;
+
+	// Sets the interface variables which are used during compilation.
+	// By default, all variables are used.
+	// Once set, compile() will only consider the set in active_variables.
+	void set_enabled_interface_variables(std::unordered_set<VariableID> active_variables);
+
+	// Query shader resources, use ids with reflection interface to modify or query binding points, etc.
+	ShaderResources get_shader_resources() const;
+
+	// Query shader resources, but only return the variables which are part of active_variables.
+	// E.g.: get_shader_resources(get_active_variables()) to only return the variables which are statically
+	// accessed.
+	ShaderResources get_shader_resources(const std::unordered_set<VariableID> &active_variables) const;
+
+	// Remapped variables are considered built-in variables and a backend will
+	// not emit a declaration for this variable.
+	// This is mostly useful for making use of builtins which are dependent on extensions.
+	void set_remapped_variable_state(VariableID id, bool remap_enable);
+	bool get_remapped_variable_state(VariableID id) const;
+
+	// For subpassInput variables which are remapped to plain variables,
+	// the number of components in the remapped
+	// variable must be specified as the backing type of subpass inputs are opaque.
+	void set_subpass_input_remapped_components(VariableID id, uint32_t components);
+	uint32_t get_subpass_input_remapped_components(VariableID id) const;
+
+	// All operations work on the current entry point.
+	// Entry points can be swapped out with set_entry_point().
+	// Entry points should be set right after the constructor completes as some reflection functions traverse the graph from the entry point.
+	// Resource reflection also depends on the entry point.
+	// By default, the current entry point is set to the first OpEntryPoint which appears in the SPIR-V module.
+
+	// Some shader languages restrict the names that can be given to entry points, and the
+	// corresponding backend will automatically rename an entry point name, during the call
+	// to compile() if it is illegal. For example, the common entry point name main() is
+	// illegal in MSL, and is renamed to an alternate name by the MSL backend.
+	// Given the original entry point name contained in the SPIR-V, this function returns
+	// the name, as updated by the backend during the call to compile(). If the name is not
+	// illegal, and has not been renamed, or if this function is called before compile(),
+	// this function will simply return the same name.
+
+	// New variants of entry point query and reflection.
+	// Names for entry points in the SPIR-V module may alias if they belong to different execution models.
+	// To disambiguate, we must pass along with the entry point names the execution model.
+	SmallVector<EntryPoint> get_entry_points_and_stages() const;
+	void set_entry_point(const std::string &entry, spv::ExecutionModel execution_model);
+
+	// Renames an entry point from old_name to new_name.
+	// If old_name is currently selected as the current entry point, it will continue to be the current entry point,
+	// albeit with a new name.
+	// get_entry_points() is essentially invalidated at this point.
+	void rename_entry_point(const std::string &old_name, const std::string &new_name,
+	                        spv::ExecutionModel execution_model);
+	const SPIREntryPoint &get_entry_point(const std::string &name, spv::ExecutionModel execution_model) const;
+	SPIREntryPoint &get_entry_point(const std::string &name, spv::ExecutionModel execution_model);
+	const std::string &get_cleansed_entry_point_name(const std::string &name,
+	                                                 spv::ExecutionModel execution_model) const;
+
+	// Traverses all reachable opcodes and sets active_builtins to a bitmask of all builtin variables which are accessed in the shader.
+	void update_active_builtins();
+	bool has_active_builtin(spv::BuiltIn builtin, spv::StorageClass storage);
+
+	// Query and modify OpExecutionMode.
+	const Bitset &get_execution_mode_bitset() const;
+
+	void unset_execution_mode(spv::ExecutionMode mode);
+	void set_execution_mode(spv::ExecutionMode mode, uint32_t arg0 = 0, uint32_t arg1 = 0, uint32_t arg2 = 0);
+
+	// Gets argument for an execution mode (LocalSize, Invocations, OutputVertices).
+	// For LocalSize, the index argument is used to select the dimension (X = 0, Y = 1, Z = 2).
+	// For execution modes which do not have arguments, 0 is returned.
+	uint32_t get_execution_mode_argument(spv::ExecutionMode mode, uint32_t index = 0) const;
+	spv::ExecutionModel get_execution_model() const;
+
+	bool is_tessellation_shader() const;
+
+	// In SPIR-V, the compute work group size can be represented by a constant vector, in which case
+	// the LocalSize execution mode is ignored.
+	//
+	// This constant vector can be a constant vector, specialization constant vector, or partly specialized constant vector.
+	// To modify and query work group dimensions which are specialization constants, SPIRConstant values must be modified
+	// directly via get_constant() rather than using LocalSize directly. This function will return which constants should be modified.
+	//
+	// To modify dimensions which are *not* specialization constants, set_execution_mode should be used directly.
+	// Arguments to set_execution_mode which are specialization constants are effectively ignored during compilation.
+	// NOTE: This is somewhat different from how SPIR-V works. In SPIR-V, the constant vector will completely replace LocalSize,
+	// while in this interface, LocalSize is only ignored for specialization constants.
+	//
+	// The specialization constant will be written to x, y and z arguments.
+	// If the component is not a specialization constant, a zeroed out struct will be written.
+	// The return value is the constant ID of the builtin WorkGroupSize, but this is not expected to be useful
+	// for most use cases.
+	uint32_t get_work_group_size_specialization_constants(SpecializationConstant &x, SpecializationConstant &y,
+	                                                      SpecializationConstant &z) const;
+
+	// Analyzes all OpImageFetch (texelFetch) opcodes and checks if there are instances where
+	// said instruction is used without a combined image sampler.
+	// GLSL targets do not support the use of texelFetch without a sampler.
+	// To workaround this, we must inject a dummy sampler which can be used to form a sampler2D at the call-site of
+	// texelFetch as necessary.
+	//
+	// This must be called before build_combined_image_samplers().
+	// build_combined_image_samplers() may refer to the ID returned by this method if the returned ID is non-zero.
+	// The return value will be the ID of a sampler object if a dummy sampler is necessary, or 0 if no sampler object
+	// is required.
+	//
+	// If the returned ID is non-zero, it can be decorated with set/bindings as desired before calling compile().
+	// Calling this function also invalidates get_active_interface_variables(), so this should be called
+	// before that function.
+	VariableID build_dummy_sampler_for_combined_images();
+
+	// Analyzes all separate image and samplers used from the currently selected entry point,
+	// and re-routes them all to a combined image sampler instead.
+	// This is required to "support" separate image samplers in targets which do not natively support
+	// this feature, like GLSL/ESSL.
+	//
+	// This must be called before compile() if such remapping is desired.
+	// This call will add new sampled images to the SPIR-V,
+	// so it will appear in reflection if get_shader_resources() is called after build_combined_image_samplers.
+	//
+	// If any image/sampler remapping was found, no separate image/samplers will appear in the decompiled output,
+	// but will still appear in reflection.
+	//
+	// The resulting samplers will be void of any decorations like name, descriptor sets and binding points,
+	// so this can be added before compile() if desired.
+	//
+	// Combined image samplers originating from this set are always considered active variables.
+	// Arrays of separate samplers are not supported, but arrays of separate images are supported.
+	// Array of images + sampler -> Array of combined image samplers.
+	void build_combined_image_samplers();
+
+	// Gets a remapping for the combined image samplers.
+	const SmallVector<CombinedImageSampler> &get_combined_image_samplers() const
+	{
+		return combined_image_samplers;
+	}
+
+	// Set a new variable type remap callback.
+	// The type remapping is designed to allow global interface variable to assume more special types.
+	// A typical example here is to remap sampler2D into samplerExternalOES, which currently isn't supported
+	// directly by SPIR-V.
+	//
+	// In compile() while emitting code,
+	// for every variable that is declared, including function parameters, the callback will be called
+	// and the API user has a chance to change the textual representation of the type used to declare the variable.
+	// The API user can detect special patterns in names to guide the remapping.
+	void set_variable_type_remap_callback(VariableTypeRemapCallback cb)
+	{
+		variable_remap_callback = std::move(cb);
+	}
+
+	// API for querying which specialization constants exist.
+	// To modify a specialization constant before compile(), use get_constant(constant.id),
+	// then update constants directly in the SPIRConstant data structure.
+	// For composite types, the subconstants can be iterated over and modified.
+	// constant_type is the SPIRType for the specialization constant,
+	// which can be queried to determine which fields in the unions should be poked at.
+	SmallVector<SpecializationConstant> get_specialization_constants() const;
+	SPIRConstant &get_constant(ConstantID id);
+	const SPIRConstant &get_constant(ConstantID id) const;
+
+	uint32_t get_current_id_bound() const
+	{
+		return uint32_t(ir.ids.size());
+	}
+
+	// API for querying buffer objects.
+	// The type passed in here should be the base type of a resource, i.e.
+	// get_type(resource.base_type_id)
+	// as decorations are set in the basic Block type.
+	// The type passed in here must have these decorations set, or an exception is raised.
+	// Only UBOs and SSBOs or sub-structs which are part of these buffer types will have these decorations set.
+	uint32_t type_struct_member_offset(const SPIRType &type, uint32_t index) const;
+	uint32_t type_struct_member_array_stride(const SPIRType &type, uint32_t index) const;
+	uint32_t type_struct_member_matrix_stride(const SPIRType &type, uint32_t index) const;
+
+	// Gets the offset in SPIR-V words (uint32_t) for a decoration which was originally declared in the SPIR-V binary.
+	// The offset will point to one or more uint32_t literals which can be modified in-place before using the SPIR-V binary.
+	// Note that adding or removing decorations using the reflection API will not change the behavior of this function.
+	// If the decoration was declared, sets the word_offset to an offset into the provided SPIR-V binary buffer and returns true,
+	// otherwise, returns false.
+	// If the decoration does not have any value attached to it (e.g. DecorationRelaxedPrecision), this function will also return false.
+	bool get_binary_offset_for_decoration(VariableID id, spv::Decoration decoration, uint32_t &word_offset) const;
+
+	// HLSL counter buffer reflection interface.
+	// Append/Consume/Increment/Decrement in HLSL is implemented as two "neighbor" buffer objects where
+	// one buffer implements the storage, and a single buffer containing just a lone "int" implements the counter.
+	// To SPIR-V these will be exposed as two separate buffers, but glslang HLSL frontend emits a special indentifier
+	// which lets us link the two buffers together.
+
+	// Queries if a variable ID is a counter buffer which "belongs" to a regular buffer object.
+
+	// If SPV_GOOGLE_hlsl_functionality1 is used, this can be used even with a stripped SPIR-V module.
+	// Otherwise, this query is purely based on OpName identifiers as found in the SPIR-V module, and will
+	// only return true if OpSource was reported HLSL.
+	// To rely on this functionality, ensure that the SPIR-V module is not stripped.
+
+	bool buffer_is_hlsl_counter_buffer(VariableID id) const;
+
+	// Queries if a buffer object has a neighbor "counter" buffer.
+	// If so, the ID of that counter buffer will be returned in counter_id.
+	// If SPV_GOOGLE_hlsl_functionality1 is used, this can be used even with a stripped SPIR-V module.
+	// Otherwise, this query is purely based on OpName identifiers as found in the SPIR-V module, and will
+	// only return true if OpSource was reported HLSL.
+	// To rely on this functionality, ensure that the SPIR-V module is not stripped.
+	bool buffer_get_hlsl_counter_buffer(VariableID id, uint32_t &counter_id) const;
+
+	// Gets the list of all SPIR-V Capabilities which were declared in the SPIR-V module.
+	const SmallVector<spv::Capability> &get_declared_capabilities() const;
+
+	// Gets the list of all SPIR-V extensions which were declared in the SPIR-V module.
+	const SmallVector<std::string> &get_declared_extensions() const;
+
+	// When declaring buffer blocks in GLSL, the name declared in the GLSL source
+	// might not be the same as the name declared in the SPIR-V module due to naming conflicts.
+	// In this case, SPIRV-Cross needs to find a fallback-name, and it might only
+	// be possible to know this name after compiling to GLSL.
+	// This is particularly important for HLSL input and UAVs which tends to reuse the same block type
+	// for multiple distinct blocks. For these cases it is not possible to modify the name of the type itself
+	// because it might be unique. Instead, you can use this interface to check after compilation which
+	// name was actually used if your input SPIR-V tends to have this problem.
+	// For other names like remapped names for variables, etc, it's generally enough to query the name of the variables
+	// after compiling, block names are an exception to this rule.
+	// ID is the name of a variable as returned by Resource::id, and must be a variable with a Block-like type.
+	//
+	// This also applies to HLSL cbuffers.
+	std::string get_remapped_declared_block_name(VariableID id) const;
+
+	// For buffer block variables, get the decorations for that variable.
+	// Sometimes, decorations for buffer blocks are found in member decorations instead
+	// of direct decorations on the variable itself.
+	// The most common use here is to check if a buffer is readonly or writeonly.
+	Bitset get_buffer_block_flags(VariableID id) const;
+
+protected:
+	const uint32_t *stream(const Instruction &instr) const
+	{
+		// If we're not going to use any arguments, just return nullptr.
+		// We want to avoid case where we return an out of range pointer
+		// that trips debug assertions on some platforms.
+		if (!instr.length)
+			return nullptr;
+
+		if (instr.offset + instr.length > ir.spirv.size())
+			SPIRV_CROSS_THROW("Compiler::stream() out of range.");
+		return &ir.spirv[instr.offset];
+	}
+
+	ParsedIR ir;
+	// Marks variables which have global scope and variables which can alias with other variables
+	// (SSBO, image load store, etc)
+	SmallVector<uint32_t> global_variables;
+	SmallVector<uint32_t> aliased_variables;
+
+	SPIRFunction *current_function = nullptr;
+	SPIRBlock *current_block = nullptr;
+	uint32_t current_loop_level = 0;
+	std::unordered_set<VariableID> active_interface_variables;
+	bool check_active_interface_variables = false;
+
+	void add_loop_level();
+
+	void set_initializers(SPIRExpression &e)
+	{
+		e.emitted_loop_level = current_loop_level;
+	}
+
+	template <typename T>
+	void set_initializers(const T &)
+	{
+	}
+
+	// If our IDs are out of range here as part of opcodes, throw instead of
+	// undefined behavior.
+	template <typename T, typename... P>
+	T &set(uint32_t id, P &&... args)
+	{
+		ir.add_typed_id(static_cast<Types>(T::type), id);
+		auto &var = variant_set<T>(ir.ids[id], std::forward<P>(args)...);
+		var.self = id;
+		set_initializers(var);
+		return var;
+	}
+
+	template <typename T>
+	T &get(uint32_t id)
+	{
+		return variant_get<T>(ir.ids[id]);
+	}
+
+	template <typename T>
+	T *maybe_get(uint32_t id)
+	{
+		if (id >= ir.ids.size())
+			return nullptr;
+		else if (ir.ids[id].get_type() == static_cast<Types>(T::type))
+			return &get<T>(id);
+		else
+			return nullptr;
+	}
+
+	template <typename T>
+	const T &get(uint32_t id) const
+	{
+		return variant_get<T>(ir.ids[id]);
+	}
+
+	template <typename T>
+	const T *maybe_get(uint32_t id) const
+	{
+		if (id >= ir.ids.size())
+			return nullptr;
+		else if (ir.ids[id].get_type() == static_cast<Types>(T::type))
+			return &get<T>(id);
+		else
+			return nullptr;
+	}
+
+	// Gets the id of SPIR-V type underlying the given type_id, which might be a pointer.
+	uint32_t get_pointee_type_id(uint32_t type_id) const;
+
+	// Gets the SPIR-V type underlying the given type, which might be a pointer.
+	const SPIRType &get_pointee_type(const SPIRType &type) const;
+
+	// Gets the SPIR-V type underlying the given type_id, which might be a pointer.
+	const SPIRType &get_pointee_type(uint32_t type_id) const;
+
+	// Gets the ID of the SPIR-V type underlying a variable.
+	uint32_t get_variable_data_type_id(const SPIRVariable &var) const;
+
+	// Gets the SPIR-V type underlying a variable.
+	SPIRType &get_variable_data_type(const SPIRVariable &var);
+
+	// Gets the SPIR-V type underlying a variable.
+	const SPIRType &get_variable_data_type(const SPIRVariable &var) const;
+
+	// Gets the SPIR-V element type underlying an array variable.
+	SPIRType &get_variable_element_type(const SPIRVariable &var);
+
+	// Gets the SPIR-V element type underlying an array variable.
+	const SPIRType &get_variable_element_type(const SPIRVariable &var) const;
+
+	// Sets the qualified member identifier for OpTypeStruct ID, member number "index".
+	void set_member_qualified_name(uint32_t type_id, uint32_t index, const std::string &name);
+	void set_qualified_name(uint32_t id, const std::string &name);
+
+	// Returns if the given type refers to a sampled image.
+	bool is_sampled_image_type(const SPIRType &type);
+
+	const SPIREntryPoint &get_entry_point() const;
+	SPIREntryPoint &get_entry_point();
+	static bool is_tessellation_shader(spv::ExecutionModel model);
+
+	virtual std::string to_name(uint32_t id, bool allow_alias = true) const;
+	bool is_builtin_variable(const SPIRVariable &var) const;
+	bool is_builtin_type(const SPIRType &type) const;
+	bool is_hidden_variable(const SPIRVariable &var, bool include_builtins = false) const;
+	bool is_immutable(uint32_t id) const;
+	bool is_member_builtin(const SPIRType &type, uint32_t index, spv::BuiltIn *builtin) const;
+	bool is_scalar(const SPIRType &type) const;
+	bool is_vector(const SPIRType &type) const;
+	bool is_matrix(const SPIRType &type) const;
+	bool is_array(const SPIRType &type) const;
+	uint32_t expression_type_id(uint32_t id) const;
+	const SPIRType &expression_type(uint32_t id) const;
+	bool expression_is_lvalue(uint32_t id) const;
+	bool variable_storage_is_aliased(const SPIRVariable &var);
+	SPIRVariable *maybe_get_backing_variable(uint32_t chain);
+	spv::StorageClass get_expression_effective_storage_class(uint32_t ptr);
+
+	void register_read(uint32_t expr, uint32_t chain, bool forwarded);
+	void register_write(uint32_t chain);
+
+	inline bool is_continue(uint32_t next) const
+	{
+		return (ir.block_meta[next] & ParsedIR::BLOCK_META_CONTINUE_BIT) != 0;
+	}
+
+	inline bool is_single_block_loop(uint32_t next) const
+	{
+		auto &block = get<SPIRBlock>(next);
+		return block.merge == SPIRBlock::MergeLoop && block.continue_block == ID(next);
+	}
+
+	inline bool is_break(uint32_t next) const
+	{
+		return (ir.block_meta[next] &
+		        (ParsedIR::BLOCK_META_LOOP_MERGE_BIT | ParsedIR::BLOCK_META_MULTISELECT_MERGE_BIT)) != 0;
+	}
+
+	inline bool is_loop_break(uint32_t next) const
+	{
+		return (ir.block_meta[next] & ParsedIR::BLOCK_META_LOOP_MERGE_BIT) != 0;
+	}
+
+	inline bool is_conditional(uint32_t next) const
+	{
+		return (ir.block_meta[next] &
+		        (ParsedIR::BLOCK_META_SELECTION_MERGE_BIT | ParsedIR::BLOCK_META_MULTISELECT_MERGE_BIT)) != 0;
+	}
+
+	// Dependency tracking for temporaries read from variables.
+	void flush_dependees(SPIRVariable &var);
+	void flush_all_active_variables();
+	void flush_control_dependent_expressions(uint32_t block);
+	void flush_all_atomic_capable_variables();
+	void flush_all_aliased_variables();
+	void register_global_read_dependencies(const SPIRBlock &func, uint32_t id);
+	void register_global_read_dependencies(const SPIRFunction &func, uint32_t id);
+	std::unordered_set<uint32_t> invalid_expressions;
+
+	void update_name_cache(std::unordered_set<std::string> &cache, std::string &name);
+
+	// A variant which takes two sets of names. The secondary is only used to verify there are no collisions,
+	// but the set is not updated when we have found a new name.
+	// Used primarily when adding block interface names.
+	void update_name_cache(std::unordered_set<std::string> &cache_primary,
+	                       const std::unordered_set<std::string> &cache_secondary, std::string &name);
+
+	bool function_is_pure(const SPIRFunction &func);
+	bool block_is_pure(const SPIRBlock &block);
+
+	bool execution_is_branchless(const SPIRBlock &from, const SPIRBlock &to) const;
+	bool execution_is_direct_branch(const SPIRBlock &from, const SPIRBlock &to) const;
+	bool execution_is_noop(const SPIRBlock &from, const SPIRBlock &to) const;
+	SPIRBlock::ContinueBlockType continue_block_type(const SPIRBlock &continue_block) const;
+
+	void force_recompile();
+	void clear_force_recompile();
+	bool is_forcing_recompilation() const;
+	bool is_force_recompile = false;
+
+	bool block_is_loop_candidate(const SPIRBlock &block, SPIRBlock::Method method) const;
+
+	bool types_are_logically_equivalent(const SPIRType &a, const SPIRType &b) const;
+	void inherit_expression_dependencies(uint32_t dst, uint32_t source);
+	void add_implied_read_expression(SPIRExpression &e, uint32_t source);
+	void add_implied_read_expression(SPIRAccessChain &e, uint32_t source);
+
+	// For proper multiple entry point support, allow querying if an Input or Output
+	// variable is part of that entry points interface.
+	bool interface_variable_exists_in_entry_point(uint32_t id) const;
+
+	SmallVector<CombinedImageSampler> combined_image_samplers;
+
+	void remap_variable_type_name(const SPIRType &type, const std::string &var_name, std::string &type_name) const
+	{
+		if (variable_remap_callback)
+			variable_remap_callback(type, var_name, type_name);
+	}
+
+	void set_ir(const ParsedIR &parsed);
+	void set_ir(ParsedIR &&parsed);
+	void parse_fixup();
+
+	// Used internally to implement various traversals for queries.
+	struct OpcodeHandler
+	{
+		virtual ~OpcodeHandler() = default;
+
+		// Return true if traversal should continue.
+		// If false, traversal will end immediately.
+		virtual bool handle(spv::Op opcode, const uint32_t *args, uint32_t length) = 0;
+
+		virtual bool follow_function_call(const SPIRFunction &)
+		{
+			return true;
+		}
+
+		virtual void set_current_block(const SPIRBlock &)
+		{
+		}
+
+		// Called after returning from a function or when entering a block,
+		// can be called multiple times per block,
+		// while set_current_block is only called on block entry.
+		virtual void rearm_current_block(const SPIRBlock &)
+		{
+		}
+
+		virtual bool begin_function_scope(const uint32_t *, uint32_t)
+		{
+			return true;
+		}
+
+		virtual bool end_function_scope(const uint32_t *, uint32_t)
+		{
+			return true;
+		}
+	};
+
+	struct BufferAccessHandler : OpcodeHandler
+	{
+		BufferAccessHandler(const Compiler &compiler_, SmallVector<BufferRange> &ranges_, uint32_t id_)
+		    : compiler(compiler_)
+		    , ranges(ranges_)
+		    , id(id_)
+		{
+		}
+
+		bool handle(spv::Op opcode, const uint32_t *args, uint32_t length) override;
+
+		const Compiler &compiler;
+		SmallVector<BufferRange> &ranges;
+		uint32_t id;
+
+		std::unordered_set<uint32_t> seen;
+	};
+
+	struct InterfaceVariableAccessHandler : OpcodeHandler
+	{
+		InterfaceVariableAccessHandler(const Compiler &compiler_, std::unordered_set<VariableID> &variables_)
+		    : compiler(compiler_)
+		    , variables(variables_)
+		{
+		}
+
+		bool handle(spv::Op opcode, const uint32_t *args, uint32_t length) override;
+
+		const Compiler &compiler;
+		std::unordered_set<VariableID> &variables;
+	};
+
+	struct CombinedImageSamplerHandler : OpcodeHandler
+	{
+		CombinedImageSamplerHandler(Compiler &compiler_)
+		    : compiler(compiler_)
+		{
+		}
+		bool handle(spv::Op opcode, const uint32_t *args, uint32_t length) override;
+		bool begin_function_scope(const uint32_t *args, uint32_t length) override;
+		bool end_function_scope(const uint32_t *args, uint32_t length) override;
+
+		Compiler &compiler;
+
+		// Each function in the call stack needs its own remapping for parameters so we can deduce which global variable each texture/sampler the parameter is statically bound to.
+		std::stack<std::unordered_map<uint32_t, uint32_t>> parameter_remapping;
+		std::stack<SPIRFunction *> functions;
+
+		uint32_t remap_parameter(uint32_t id);
+		void push_remap_parameters(const SPIRFunction &func, const uint32_t *args, uint32_t length);
+		void pop_remap_parameters();
+		void register_combined_image_sampler(SPIRFunction &caller, VariableID combined_id, VariableID texture_id,
+		                                     VariableID sampler_id, bool depth);
+	};
+
+	struct DummySamplerForCombinedImageHandler : OpcodeHandler
+	{
+		DummySamplerForCombinedImageHandler(Compiler &compiler_)
+		    : compiler(compiler_)
+		{
+		}
+		bool handle(spv::Op opcode, const uint32_t *args, uint32_t length) override;
+
+		Compiler &compiler;
+		bool need_dummy_sampler = false;
+	};
+
+	struct ActiveBuiltinHandler : OpcodeHandler
+	{
+		ActiveBuiltinHandler(Compiler &compiler_)
+		    : compiler(compiler_)
+		{
+		}
+
+		bool handle(spv::Op opcode, const uint32_t *args, uint32_t length) override;
+		Compiler &compiler;
+
+		void handle_builtin(const SPIRType &type, spv::BuiltIn builtin, const Bitset &decoration_flags);
+	};
+
+	bool traverse_all_reachable_opcodes(const SPIRBlock &block, OpcodeHandler &handler) const;
+	bool traverse_all_reachable_opcodes(const SPIRFunction &block, OpcodeHandler &handler) const;
+	// This must be an ordered data structure so we always pick the same type aliases.
+	SmallVector<uint32_t> global_struct_cache;
+
+	ShaderResources get_shader_resources(const std::unordered_set<VariableID> *active_variables) const;
+
+	VariableTypeRemapCallback variable_remap_callback;
+
+	bool get_common_basic_type(const SPIRType &type, SPIRType::BaseType &base_type);
+
+	std::unordered_set<uint32_t> forced_temporaries;
+	std::unordered_set<uint32_t> forwarded_temporaries;
+	std::unordered_set<uint32_t> suppressed_usage_tracking;
+	std::unordered_set<uint32_t> hoisted_temporaries;
+	std::unordered_set<uint32_t> forced_invariant_temporaries;
+
+	Bitset active_input_builtins;
+	Bitset active_output_builtins;
+	uint32_t clip_distance_count = 0;
+	uint32_t cull_distance_count = 0;
+	bool position_invariant = false;
+
+	void analyze_parameter_preservation(
+	    SPIRFunction &entry, const CFG &cfg,
+	    const std::unordered_map<uint32_t, std::unordered_set<uint32_t>> &variable_to_blocks,
+	    const std::unordered_map<uint32_t, std::unordered_set<uint32_t>> &complete_write_blocks);
+
+	// If a variable ID or parameter ID is found in this set, a sampler is actually a shadow/comparison sampler.
+	// SPIR-V does not support this distinction, so we must keep track of this information outside the type system.
+	// There might be unrelated IDs found in this set which do not correspond to actual variables.
+	// This set should only be queried for the existence of samplers which are already known to be variables or parameter IDs.
+	// Similar is implemented for images, as well as if subpass inputs are needed.
+	std::unordered_set<uint32_t> comparison_ids;
+	bool need_subpass_input = false;
+
+	// In certain backends, we will need to use a dummy sampler to be able to emit code.
+	// GLSL does not support texelFetch on texture2D objects, but SPIR-V does,
+	// so we need to workaround by having the application inject a dummy sampler.
+	uint32_t dummy_sampler_id = 0;
+
+	void analyze_image_and_sampler_usage();
+
+	struct CombinedImageSamplerDrefHandler : OpcodeHandler
+	{
+		CombinedImageSamplerDrefHandler(Compiler &compiler_)
+		    : compiler(compiler_)
+		{
+		}
+		bool handle(spv::Op opcode, const uint32_t *args, uint32_t length) override;
+
+		Compiler &compiler;
+		std::unordered_set<uint32_t> dref_combined_samplers;
+	};
+
+	struct CombinedImageSamplerUsageHandler : OpcodeHandler
+	{
+		CombinedImageSamplerUsageHandler(Compiler &compiler_,
+		                                 const std::unordered_set<uint32_t> &dref_combined_samplers_)
+		    : compiler(compiler_)
+		    , dref_combined_samplers(dref_combined_samplers_)
+		{
+		}
+
+		bool begin_function_scope(const uint32_t *args, uint32_t length) override;
+		bool handle(spv::Op opcode, const uint32_t *args, uint32_t length) override;
+		Compiler &compiler;
+		const std::unordered_set<uint32_t> &dref_combined_samplers;
+
+		std::unordered_map<uint32_t, std::unordered_set<uint32_t>> dependency_hierarchy;
+		std::unordered_set<uint32_t> comparison_ids;
+
+		void add_hierarchy_to_comparison_ids(uint32_t ids);
+		bool need_subpass_input = false;
+		void add_dependency(uint32_t dst, uint32_t src);
+	};
+
+	void build_function_control_flow_graphs_and_analyze();
+	std::unordered_map<uint32_t, std::unique_ptr<CFG>> function_cfgs;
+	const CFG &get_cfg_for_current_function() const;
+	const CFG &get_cfg_for_function(uint32_t id) const;
+
+	struct CFGBuilder : OpcodeHandler
+	{
+		explicit CFGBuilder(Compiler &compiler_);
+
+		bool follow_function_call(const SPIRFunction &func) override;
+		bool handle(spv::Op op, const uint32_t *args, uint32_t length) override;
+		Compiler &compiler;
+		std::unordered_map<uint32_t, std::unique_ptr<CFG>> function_cfgs;
+	};
+
+	struct AnalyzeVariableScopeAccessHandler : OpcodeHandler
+	{
+		AnalyzeVariableScopeAccessHandler(Compiler &compiler_, SPIRFunction &entry_);
+
+		bool follow_function_call(const SPIRFunction &) override;
+		void set_current_block(const SPIRBlock &block) override;
+
+		void notify_variable_access(uint32_t id, uint32_t block);
+		bool id_is_phi_variable(uint32_t id) const;
+		bool id_is_potential_temporary(uint32_t id) const;
+		bool handle(spv::Op op, const uint32_t *args, uint32_t length) override;
+
+		Compiler &compiler;
+		SPIRFunction &entry;
+		std::unordered_map<uint32_t, std::unordered_set<uint32_t>> accessed_variables_to_block;
+		std::unordered_map<uint32_t, std::unordered_set<uint32_t>> accessed_temporaries_to_block;
+		std::unordered_map<uint32_t, uint32_t> result_id_to_type;
+		std::unordered_map<uint32_t, std::unordered_set<uint32_t>> complete_write_variables_to_block;
+		std::unordered_map<uint32_t, std::unordered_set<uint32_t>> partial_write_variables_to_block;
+		std::unordered_set<uint32_t> access_chain_expressions;
+		// Access chains used in multiple blocks mean hoisting all the variables used to construct the access chain as not all backends can use pointers.
+		std::unordered_map<uint32_t, std::unordered_set<uint32_t>> access_chain_children;
+		const SPIRBlock *current_block = nullptr;
+	};
+
+	struct StaticExpressionAccessHandler : OpcodeHandler
+	{
+		StaticExpressionAccessHandler(Compiler &compiler_, uint32_t variable_id_);
+		bool follow_function_call(const SPIRFunction &) override;
+		bool handle(spv::Op op, const uint32_t *args, uint32_t length) override;
+
+		Compiler &compiler;
+		uint32_t variable_id;
+		uint32_t static_expression = 0;
+		uint32_t write_count = 0;
+	};
+
+	struct PhysicalStorageBufferPointerHandler : OpcodeHandler
+	{
+		explicit PhysicalStorageBufferPointerHandler(Compiler &compiler_);
+		bool handle(spv::Op op, const uint32_t *args, uint32_t length) override;
+		Compiler &compiler;
+		std::unordered_set<uint32_t> types;
+	};
+	void analyze_non_block_pointer_types();
+	SmallVector<uint32_t> physical_storage_non_block_pointer_types;
+
+	void analyze_variable_scope(SPIRFunction &function, AnalyzeVariableScopeAccessHandler &handler);
+	void find_function_local_luts(SPIRFunction &function, const AnalyzeVariableScopeAccessHandler &handler,
+	                              bool single_function);
+	bool may_read_undefined_variable_in_block(const SPIRBlock &block, uint32_t var);
+
+	// Finds all resources that are written to from inside the critical section, if present.
+	// The critical section is delimited by OpBeginInvocationInterlockEXT and
+	// OpEndInvocationInterlockEXT instructions. In MSL and HLSL, any resources written
+	// while inside the critical section must be placed in a raster order group.
+	struct InterlockedResourceAccessHandler : OpcodeHandler
+	{
+		InterlockedResourceAccessHandler(Compiler &compiler_, uint32_t entry_point_id)
+		    : compiler(compiler_)
+		{
+			call_stack.push_back(entry_point_id);
+		}
+
+		bool handle(spv::Op op, const uint32_t *args, uint32_t length) override;
+		bool begin_function_scope(const uint32_t *args, uint32_t length) override;
+		bool end_function_scope(const uint32_t *args, uint32_t length) override;
+
+		Compiler &compiler;
+		bool in_crit_sec = false;
+
+		uint32_t interlock_function_id = 0;
+		bool split_function_case = false;
+		bool control_flow_interlock = false;
+		bool use_critical_section = false;
+		bool call_stack_is_interlocked = false;
+		SmallVector<uint32_t> call_stack;
+
+		void access_potential_resource(uint32_t id);
+	};
+
+	struct InterlockedResourceAccessPrepassHandler : OpcodeHandler
+	{
+		InterlockedResourceAccessPrepassHandler(Compiler &compiler_, uint32_t entry_point_id)
+		    : compiler(compiler_)
+		{
+			call_stack.push_back(entry_point_id);
+		}
+
+		void rearm_current_block(const SPIRBlock &block) override;
+		bool handle(spv::Op op, const uint32_t *args, uint32_t length) override;
+		bool begin_function_scope(const uint32_t *args, uint32_t length) override;
+		bool end_function_scope(const uint32_t *args, uint32_t length) override;
+
+		Compiler &compiler;
+		uint32_t interlock_function_id = 0;
+		uint32_t current_block_id = 0;
+		bool split_function_case = false;
+		bool control_flow_interlock = false;
+		SmallVector<uint32_t> call_stack;
+	};
+
+	void analyze_interlocked_resource_usage();
+	// The set of all resources written while inside the critical section, if present.
+	std::unordered_set<uint32_t> interlocked_resources;
+	bool interlocked_is_complex = false;
+
+	void make_constant_null(uint32_t id, uint32_t type);
+
+	std::unordered_map<uint32_t, std::string> declared_block_names;
+
+	bool instruction_to_result_type(uint32_t &result_type, uint32_t &result_id, spv::Op op, const uint32_t *args,
+	                                uint32_t length);
+
+	Bitset combined_decoration_for_member(const SPIRType &type, uint32_t index) const;
+	static bool is_desktop_only_format(spv::ImageFormat format);
+
+	bool image_is_comparison(const SPIRType &type, uint32_t id) const;
+
+	void set_extended_decoration(uint32_t id, ExtendedDecorations decoration, uint32_t value = 0);
+	uint32_t get_extended_decoration(uint32_t id, ExtendedDecorations decoration) const;
+	bool has_extended_decoration(uint32_t id, ExtendedDecorations decoration) const;
+	void unset_extended_decoration(uint32_t id, ExtendedDecorations decoration);
+
+	void set_extended_member_decoration(uint32_t type, uint32_t index, ExtendedDecorations decoration,
+	                                    uint32_t value = 0);
+	uint32_t get_extended_member_decoration(uint32_t type, uint32_t index, ExtendedDecorations decoration) const;
+	bool has_extended_member_decoration(uint32_t type, uint32_t index, ExtendedDecorations decoration) const;
+	void unset_extended_member_decoration(uint32_t type, uint32_t index, ExtendedDecorations decoration);
+
+	bool type_is_array_of_pointers(const SPIRType &type) const;
+	bool type_is_top_level_physical_pointer(const SPIRType &type) const;
+	bool type_is_block_like(const SPIRType &type) const;
+	bool type_is_opaque_value(const SPIRType &type) const;
+
+	bool reflection_ssbo_instance_name_is_significant() const;
+	std::string get_remapped_declared_block_name(uint32_t id, bool fallback_prefer_instance_name) const;
+
+	bool flush_phi_required(BlockID from, BlockID to) const;
+
+private:
+	// Used only to implement the old deprecated get_entry_point() interface.
+	const SPIREntryPoint &get_first_entry_point(const std::string &name) const;
+	SPIREntryPoint &get_first_entry_point(const std::string &name);
+};
+} // namespace SPIRV_CROSS_NAMESPACE
+
+#endif
diff --git a/engine/inc/spirv_cross/spirv_cross_c.h b/engine/inc/spirv_cross/spirv_cross_c.h
new file mode 100644
index 00000000..e8d1397a
--- /dev/null
+++ b/engine/inc/spirv_cross/spirv_cross_c.h
@@ -0,0 +1,966 @@
+/*
+ * Copyright 2019-2020 Hans-Kristian Arntzen
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SPIRV_CROSS_C_API_H
+#define SPIRV_CROSS_C_API_H
+
+#include <stddef.h>
+#include "spirv.h"
+
+/*
+ * C89-compatible wrapper for SPIRV-Cross' API.
+ * Documentation here is sparse unless the behavior does not map 1:1 with C++ API.
+ * It is recommended to look at the canonical C++ API for more detailed information.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Bumped if ABI or API breaks backwards compatibility. */
+#define SPVC_C_API_VERSION_MAJOR 0
+/* Bumped if APIs or enumerations are added in a backwards compatible way. */
+#define SPVC_C_API_VERSION_MINOR 37
+/* Bumped if internal implementation details change. */
+#define SPVC_C_API_VERSION_PATCH 0
+
+#if !defined(SPVC_PUBLIC_API)
+#if defined(SPVC_EXPORT_SYMBOLS)
+/* Exports symbols. Standard C calling convention is used. */
+#if defined(__GNUC__)
+#define SPVC_PUBLIC_API __attribute__((visibility("default")))
+#elif defined(_MSC_VER)
+#define SPVC_PUBLIC_API __declspec(dllexport)
+#else
+#define SPVC_PUBLIC_API
+#endif
+#else
+#define SPVC_PUBLIC_API
+#endif
+#endif
+
+/*
+ * Gets the SPVC_C_API_VERSION_* used to build this library.
+ * Can be used to check for ABI mismatch if so-versioning did not catch it.
+ */
+SPVC_PUBLIC_API void spvc_get_version(unsigned *major, unsigned *minor, unsigned *patch);
+
+/* Gets a human readable version string to identify which commit a particular binary was created from. */
+SPVC_PUBLIC_API const char *spvc_get_commit_revision_and_timestamp(void);
+
+/* These types are opaque to the user. */
+typedef struct spvc_context_s *spvc_context;
+typedef struct spvc_parsed_ir_s *spvc_parsed_ir;
+typedef struct spvc_compiler_s *spvc_compiler;
+typedef struct spvc_compiler_options_s *spvc_compiler_options;
+typedef struct spvc_resources_s *spvc_resources;
+struct spvc_type_s;
+typedef const struct spvc_type_s *spvc_type;
+typedef struct spvc_constant_s *spvc_constant;
+struct spvc_set_s;
+typedef const struct spvc_set_s *spvc_set;
+
+/*
+ * Shallow typedefs. All SPIR-V IDs are plain 32-bit numbers, but this helps communicate which data is used.
+ * Maps to a SPIRType.
+ */
+typedef SpvId spvc_type_id;
+/* Maps to a SPIRVariable. */
+typedef SpvId spvc_variable_id;
+/* Maps to a SPIRConstant. */
+typedef SpvId spvc_constant_id;
+
+/* See C++ API. */
+typedef struct spvc_reflected_resource
+{
+	spvc_variable_id id;
+	spvc_type_id base_type_id;
+	spvc_type_id type_id;
+	const char *name;
+} spvc_reflected_resource;
+
+/* See C++ API. */
+typedef struct spvc_entry_point
+{
+	SpvExecutionModel execution_model;
+	const char *name;
+} spvc_entry_point;
+
+/* See C++ API. */
+typedef struct spvc_combined_image_sampler
+{
+	spvc_variable_id combined_id;
+	spvc_variable_id image_id;
+	spvc_variable_id sampler_id;
+} spvc_combined_image_sampler;
+
+/* See C++ API. */
+typedef struct spvc_specialization_constant
+{
+	spvc_constant_id id;
+	unsigned constant_id;
+} spvc_specialization_constant;
+
+/* See C++ API. */
+typedef struct spvc_buffer_range
+{
+	unsigned index;
+	size_t offset;
+	size_t range;
+} spvc_buffer_range;
+
+/* See C++ API. */
+typedef struct spvc_hlsl_root_constants
+{
+	unsigned start;
+	unsigned end;
+	unsigned binding;
+	unsigned space;
+} spvc_hlsl_root_constants;
+
+/* See C++ API. */
+typedef struct spvc_hlsl_vertex_attribute_remap
+{
+	unsigned location;
+	const char *semantic;
+} spvc_hlsl_vertex_attribute_remap;
+
+/*
+ * Be compatible with non-C99 compilers, which do not have stdbool.
+ * Only recent MSVC compilers supports this for example, and ideally SPIRV-Cross should be linkable
+ * from a wide range of compilers in its C wrapper.
+ */
+typedef unsigned char spvc_bool;
+#define SPVC_TRUE ((spvc_bool)1)
+#define SPVC_FALSE ((spvc_bool)0)
+
+typedef enum spvc_result
+{
+	/* Success. */
+	SPVC_SUCCESS = 0,
+
+	/* The SPIR-V is invalid. Should have been caught by validation ideally. */
+	SPVC_ERROR_INVALID_SPIRV = -1,
+
+	/* The SPIR-V might be valid or invalid, but SPIRV-Cross currently cannot correctly translate this to your target language. */
+	SPVC_ERROR_UNSUPPORTED_SPIRV = -2,
+
+	/* If for some reason we hit this, new or malloc failed. */
+	SPVC_ERROR_OUT_OF_MEMORY = -3,
+
+	/* Invalid API argument. */
+	SPVC_ERROR_INVALID_ARGUMENT = -4,
+
+	SPVC_ERROR_INT_MAX = 0x7fffffff
+} spvc_result;
+
+typedef enum spvc_capture_mode
+{
+	/* The Parsed IR payload will be copied, and the handle can be reused to create other compiler instances. */
+	SPVC_CAPTURE_MODE_COPY = 0,
+
+	/*
+	 * The payload will now be owned by the compiler.
+	 * parsed_ir should now be considered a dead blob and must not be used further.
+	 * This is optimal for performance and should be the go-to option.
+	 */
+	SPVC_CAPTURE_MODE_TAKE_OWNERSHIP = 1,
+
+	SPVC_CAPTURE_MODE_INT_MAX = 0x7fffffff
+} spvc_capture_mode;
+
+typedef enum spvc_backend
+{
+	/* This backend can only perform reflection, no compiler options are supported. Maps to spirv_cross::Compiler. */
+	SPVC_BACKEND_NONE = 0,
+	SPVC_BACKEND_GLSL = 1, /* spirv_cross::CompilerGLSL */
+	SPVC_BACKEND_HLSL = 2, /* CompilerHLSL */
+	SPVC_BACKEND_MSL = 3, /* CompilerMSL */
+	SPVC_BACKEND_CPP = 4, /* CompilerCPP */
+	SPVC_BACKEND_JSON = 5, /* CompilerReflection w/ JSON backend */
+	SPVC_BACKEND_INT_MAX = 0x7fffffff
+} spvc_backend;
+
+/* Maps to C++ API. */
+typedef enum spvc_resource_type
+{
+	SPVC_RESOURCE_TYPE_UNKNOWN = 0,
+	SPVC_RESOURCE_TYPE_UNIFORM_BUFFER = 1,
+	SPVC_RESOURCE_TYPE_STORAGE_BUFFER = 2,
+	SPVC_RESOURCE_TYPE_STAGE_INPUT = 3,
+	SPVC_RESOURCE_TYPE_STAGE_OUTPUT = 4,
+	SPVC_RESOURCE_TYPE_SUBPASS_INPUT = 5,
+	SPVC_RESOURCE_TYPE_STORAGE_IMAGE = 6,
+	SPVC_RESOURCE_TYPE_SAMPLED_IMAGE = 7,
+	SPVC_RESOURCE_TYPE_ATOMIC_COUNTER = 8,
+	SPVC_RESOURCE_TYPE_PUSH_CONSTANT = 9,
+	SPVC_RESOURCE_TYPE_SEPARATE_IMAGE = 10,
+	SPVC_RESOURCE_TYPE_SEPARATE_SAMPLERS = 11,
+	SPVC_RESOURCE_TYPE_ACCELERATION_STRUCTURE = 12,
+	SPVC_RESOURCE_TYPE_RAY_QUERY = 13,
+	SPVC_RESOURCE_TYPE_INT_MAX = 0x7fffffff
+} spvc_resource_type;
+
+/* Maps to spirv_cross::SPIRType::BaseType. */
+typedef enum spvc_basetype
+{
+	SPVC_BASETYPE_UNKNOWN = 0,
+	SPVC_BASETYPE_VOID = 1,
+	SPVC_BASETYPE_BOOLEAN = 2,
+	SPVC_BASETYPE_INT8 = 3,
+	SPVC_BASETYPE_UINT8 = 4,
+	SPVC_BASETYPE_INT16 = 5,
+	SPVC_BASETYPE_UINT16 = 6,
+	SPVC_BASETYPE_INT32 = 7,
+	SPVC_BASETYPE_UINT32 = 8,
+	SPVC_BASETYPE_INT64 = 9,
+	SPVC_BASETYPE_UINT64 = 10,
+	SPVC_BASETYPE_ATOMIC_COUNTER = 11,
+	SPVC_BASETYPE_FP16 = 12,
+	SPVC_BASETYPE_FP32 = 13,
+	SPVC_BASETYPE_FP64 = 14,
+	SPVC_BASETYPE_STRUCT = 15,
+	SPVC_BASETYPE_IMAGE = 16,
+	SPVC_BASETYPE_SAMPLED_IMAGE = 17,
+	SPVC_BASETYPE_SAMPLER = 18,
+	SPVC_BASETYPE_ACCELERATION_STRUCTURE = 19,
+
+	SPVC_BASETYPE_INT_MAX = 0x7fffffff
+} spvc_basetype;
+
+#define SPVC_COMPILER_OPTION_COMMON_BIT 0x1000000
+#define SPVC_COMPILER_OPTION_GLSL_BIT 0x2000000
+#define SPVC_COMPILER_OPTION_HLSL_BIT 0x4000000
+#define SPVC_COMPILER_OPTION_MSL_BIT 0x8000000
+#define SPVC_COMPILER_OPTION_LANG_BITS 0x0f000000
+#define SPVC_COMPILER_OPTION_ENUM_BITS 0xffffff
+
+#define SPVC_MAKE_MSL_VERSION(major, minor, patch) ((major) * 10000 + (minor) * 100 + (patch))
+
+/* Maps to C++ API. */
+typedef enum spvc_msl_platform
+{
+	SPVC_MSL_PLATFORM_IOS = 0,
+	SPVC_MSL_PLATFORM_MACOS = 1,
+	SPVC_MSL_PLATFORM_MAX_INT = 0x7fffffff
+} spvc_msl_platform;
+
+/* Maps to C++ API. */
+typedef enum spvc_msl_index_type
+{
+	SPVC_MSL_INDEX_TYPE_NONE = 0,
+	SPVC_MSL_INDEX_TYPE_UINT16 = 1,
+	SPVC_MSL_INDEX_TYPE_UINT32 = 2,
+	SPVC_MSL_INDEX_TYPE_MAX_INT = 0x7fffffff
+} spvc_msl_index_type;
+
+/* Maps to C++ API. */
+typedef enum spvc_msl_shader_input_format
+{
+	SPVC_MSL_SHADER_INPUT_FORMAT_OTHER = 0,
+	SPVC_MSL_SHADER_INPUT_FORMAT_UINT8 = 1,
+	SPVC_MSL_SHADER_INPUT_FORMAT_UINT16 = 2,
+	SPVC_MSL_SHADER_INPUT_FORMAT_ANY16 = 3,
+	SPVC_MSL_SHADER_INPUT_FORMAT_ANY32 = 4,
+
+	/* Deprecated names. */
+	SPVC_MSL_VERTEX_FORMAT_OTHER = SPVC_MSL_SHADER_INPUT_FORMAT_OTHER,
+	SPVC_MSL_VERTEX_FORMAT_UINT8 = SPVC_MSL_SHADER_INPUT_FORMAT_UINT8,
+	SPVC_MSL_VERTEX_FORMAT_UINT16 = SPVC_MSL_SHADER_INPUT_FORMAT_UINT16,
+
+	SPVC_MSL_SHADER_INPUT_FORMAT_INT_MAX = 0x7fffffff
+} spvc_msl_shader_input_format, spvc_msl_vertex_format;
+
+/* Maps to C++ API. Deprecated; use spvc_msl_shader_input. */
+typedef struct spvc_msl_vertex_attribute
+{
+	unsigned location;
+
+	/* Obsolete, do not use. Only lingers on for ABI compatibility. */
+	unsigned msl_buffer;
+	/* Obsolete, do not use. Only lingers on for ABI compatibility. */
+	unsigned msl_offset;
+	/* Obsolete, do not use. Only lingers on for ABI compatibility. */
+	unsigned msl_stride;
+	/* Obsolete, do not use. Only lingers on for ABI compatibility. */
+	spvc_bool per_instance;
+
+	spvc_msl_vertex_format format;
+	SpvBuiltIn builtin;
+} spvc_msl_vertex_attribute;
+
+/*
+ * Initializes the vertex attribute struct.
+ */
+SPVC_PUBLIC_API void spvc_msl_vertex_attribute_init(spvc_msl_vertex_attribute *attr);
+
+/* Maps to C++ API. */
+typedef struct spvc_msl_shader_input
+{
+	unsigned location;
+	spvc_msl_vertex_format format;
+	SpvBuiltIn builtin;
+	unsigned vecsize;
+} spvc_msl_shader_input;
+
+/*
+ * Initializes the shader input struct.
+ */
+SPVC_PUBLIC_API void spvc_msl_shader_input_init(spvc_msl_shader_input *input);
+
+/* Maps to C++ API. */
+typedef struct spvc_msl_resource_binding
+{
+	SpvExecutionModel stage;
+	unsigned desc_set;
+	unsigned binding;
+	unsigned msl_buffer;
+	unsigned msl_texture;
+	unsigned msl_sampler;
+} spvc_msl_resource_binding;
+
+/*
+ * Initializes the resource binding struct.
+ * The defaults are non-zero.
+ */
+SPVC_PUBLIC_API void spvc_msl_resource_binding_init(spvc_msl_resource_binding *binding);
+
+#define SPVC_MSL_PUSH_CONSTANT_DESC_SET (~(0u))
+#define SPVC_MSL_PUSH_CONSTANT_BINDING (0)
+#define SPVC_MSL_SWIZZLE_BUFFER_BINDING (~(1u))
+#define SPVC_MSL_BUFFER_SIZE_BUFFER_BINDING (~(2u))
+#define SPVC_MSL_ARGUMENT_BUFFER_BINDING (~(3u))
+
+/* Obsolete. Sticks around for backwards compatibility. */
+#define SPVC_MSL_AUX_BUFFER_STRUCT_VERSION 1
+
+/* Runtime check for incompatibility. Obsolete. */
+SPVC_PUBLIC_API unsigned spvc_msl_get_aux_buffer_struct_version(void);
+
+/* Maps to C++ API. */
+typedef enum spvc_msl_sampler_coord
+{
+	SPVC_MSL_SAMPLER_COORD_NORMALIZED = 0,
+	SPVC_MSL_SAMPLER_COORD_PIXEL = 1,
+	SPVC_MSL_SAMPLER_INT_MAX = 0x7fffffff
+} spvc_msl_sampler_coord;
+
+/* Maps to C++ API. */
+typedef enum spvc_msl_sampler_filter
+{
+	SPVC_MSL_SAMPLER_FILTER_NEAREST = 0,
+	SPVC_MSL_SAMPLER_FILTER_LINEAR = 1,
+	SPVC_MSL_SAMPLER_FILTER_INT_MAX = 0x7fffffff
+} spvc_msl_sampler_filter;
+
+/* Maps to C++ API. */
+typedef enum spvc_msl_sampler_mip_filter
+{
+	SPVC_MSL_SAMPLER_MIP_FILTER_NONE = 0,
+	SPVC_MSL_SAMPLER_MIP_FILTER_NEAREST = 1,
+	SPVC_MSL_SAMPLER_MIP_FILTER_LINEAR = 2,
+	SPVC_MSL_SAMPLER_MIP_FILTER_INT_MAX = 0x7fffffff
+} spvc_msl_sampler_mip_filter;
+
+/* Maps to C++ API. */
+typedef enum spvc_msl_sampler_address
+{
+	SPVC_MSL_SAMPLER_ADDRESS_CLAMP_TO_ZERO = 0,
+	SPVC_MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE = 1,
+	SPVC_MSL_SAMPLER_ADDRESS_CLAMP_TO_BORDER = 2,
+	SPVC_MSL_SAMPLER_ADDRESS_REPEAT = 3,
+	SPVC_MSL_SAMPLER_ADDRESS_MIRRORED_REPEAT = 4,
+	SPVC_MSL_SAMPLER_ADDRESS_INT_MAX = 0x7fffffff
+} spvc_msl_sampler_address;
+
+/* Maps to C++ API. */
+typedef enum spvc_msl_sampler_compare_func
+{
+	SPVC_MSL_SAMPLER_COMPARE_FUNC_NEVER = 0,
+	SPVC_MSL_SAMPLER_COMPARE_FUNC_LESS = 1,
+	SPVC_MSL_SAMPLER_COMPARE_FUNC_LESS_EQUAL = 2,
+	SPVC_MSL_SAMPLER_COMPARE_FUNC_GREATER = 3,
+	SPVC_MSL_SAMPLER_COMPARE_FUNC_GREATER_EQUAL = 4,
+	SPVC_MSL_SAMPLER_COMPARE_FUNC_EQUAL = 5,
+	SPVC_MSL_SAMPLER_COMPARE_FUNC_NOT_EQUAL = 6,
+	SPVC_MSL_SAMPLER_COMPARE_FUNC_ALWAYS = 7,
+	SPVC_MSL_SAMPLER_COMPARE_FUNC_INT_MAX = 0x7fffffff
+} spvc_msl_sampler_compare_func;
+
+/* Maps to C++ API. */
+typedef enum spvc_msl_sampler_border_color
+{
+	SPVC_MSL_SAMPLER_BORDER_COLOR_TRANSPARENT_BLACK = 0,
+	SPVC_MSL_SAMPLER_BORDER_COLOR_OPAQUE_BLACK = 1,
+	SPVC_MSL_SAMPLER_BORDER_COLOR_OPAQUE_WHITE = 2,
+	SPVC_MSL_SAMPLER_BORDER_COLOR_INT_MAX = 0x7fffffff
+} spvc_msl_sampler_border_color;
+
+/* Maps to C++ API. */
+typedef enum spvc_msl_format_resolution
+{
+	SPVC_MSL_FORMAT_RESOLUTION_444 = 0,
+	SPVC_MSL_FORMAT_RESOLUTION_422,
+	SPVC_MSL_FORMAT_RESOLUTION_420,
+	SPVC_MSL_FORMAT_RESOLUTION_INT_MAX = 0x7fffffff
+} spvc_msl_format_resolution;
+
+/* Maps to C++ API. */
+typedef enum spvc_msl_chroma_location
+{
+	SPVC_MSL_CHROMA_LOCATION_COSITED_EVEN = 0,
+	SPVC_MSL_CHROMA_LOCATION_MIDPOINT,
+	SPVC_MSL_CHROMA_LOCATION_INT_MAX = 0x7fffffff
+} spvc_msl_chroma_location;
+
+/* Maps to C++ API. */
+typedef enum spvc_msl_component_swizzle
+{
+	SPVC_MSL_COMPONENT_SWIZZLE_IDENTITY = 0,
+	SPVC_MSL_COMPONENT_SWIZZLE_ZERO,
+	SPVC_MSL_COMPONENT_SWIZZLE_ONE,
+	SPVC_MSL_COMPONENT_SWIZZLE_R,
+	SPVC_MSL_COMPONENT_SWIZZLE_G,
+	SPVC_MSL_COMPONENT_SWIZZLE_B,
+	SPVC_MSL_COMPONENT_SWIZZLE_A,
+	SPVC_MSL_COMPONENT_SWIZZLE_INT_MAX = 0x7fffffff
+} spvc_msl_component_swizzle;
+
+/* Maps to C++ API. */
+typedef enum spvc_msl_sampler_ycbcr_model_conversion
+{
+	SPVC_MSL_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0,
+	SPVC_MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY,
+	SPVC_MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_709,
+	SPVC_MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_601,
+	SPVC_MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_2020,
+	SPVC_MSL_SAMPLER_YCBCR_MODEL_CONVERSION_INT_MAX = 0x7fffffff
+} spvc_msl_sampler_ycbcr_model_conversion;
+
+/* Maps to C+ API. */
+typedef enum spvc_msl_sampler_ycbcr_range
+{
+	SPVC_MSL_SAMPLER_YCBCR_RANGE_ITU_FULL = 0,
+	SPVC_MSL_SAMPLER_YCBCR_RANGE_ITU_NARROW,
+	SPVC_MSL_SAMPLER_YCBCR_RANGE_INT_MAX = 0x7fffffff
+} spvc_msl_sampler_ycbcr_range;
+
+/* Maps to C++ API. */
+typedef struct spvc_msl_constexpr_sampler
+{
+	spvc_msl_sampler_coord coord;
+	spvc_msl_sampler_filter min_filter;
+	spvc_msl_sampler_filter mag_filter;
+	spvc_msl_sampler_mip_filter mip_filter;
+	spvc_msl_sampler_address s_address;
+	spvc_msl_sampler_address t_address;
+	spvc_msl_sampler_address r_address;
+	spvc_msl_sampler_compare_func compare_func;
+	spvc_msl_sampler_border_color border_color;
+	float lod_clamp_min;
+	float lod_clamp_max;
+	int max_anisotropy;
+
+	spvc_bool compare_enable;
+	spvc_bool lod_clamp_enable;
+	spvc_bool anisotropy_enable;
+} spvc_msl_constexpr_sampler;
+
+/*
+ * Initializes the constexpr sampler struct.
+ * The defaults are non-zero.
+ */
+SPVC_PUBLIC_API void spvc_msl_constexpr_sampler_init(spvc_msl_constexpr_sampler *sampler);
+
+/* Maps to the sampler Y'CbCr conversion-related portions of MSLConstexprSampler. See C++ API for defaults and details. */
+typedef struct spvc_msl_sampler_ycbcr_conversion
+{
+	unsigned planes;
+	spvc_msl_format_resolution resolution;
+	spvc_msl_sampler_filter chroma_filter;
+	spvc_msl_chroma_location x_chroma_offset;
+	spvc_msl_chroma_location y_chroma_offset;
+	spvc_msl_component_swizzle swizzle[4];
+	spvc_msl_sampler_ycbcr_model_conversion ycbcr_model;
+	spvc_msl_sampler_ycbcr_range ycbcr_range;
+	unsigned bpc;
+} spvc_msl_sampler_ycbcr_conversion;
+
+/*
+ * Initializes the constexpr sampler struct.
+ * The defaults are non-zero.
+ */
+SPVC_PUBLIC_API void spvc_msl_sampler_ycbcr_conversion_init(spvc_msl_sampler_ycbcr_conversion *conv);
+
+/* Maps to C++ API. */
+typedef enum spvc_hlsl_binding_flag_bits
+{
+	SPVC_HLSL_BINDING_AUTO_NONE_BIT = 0,
+	SPVC_HLSL_BINDING_AUTO_PUSH_CONSTANT_BIT = 1 << 0,
+	SPVC_HLSL_BINDING_AUTO_CBV_BIT = 1 << 1,
+	SPVC_HLSL_BINDING_AUTO_SRV_BIT = 1 << 2,
+	SPVC_HLSL_BINDING_AUTO_UAV_BIT = 1 << 3,
+	SPVC_HLSL_BINDING_AUTO_SAMPLER_BIT = 1 << 4,
+	SPVC_HLSL_BINDING_AUTO_ALL = 0x7fffffff
+} spvc_hlsl_binding_flag_bits;
+typedef unsigned spvc_hlsl_binding_flags;
+
+#define SPVC_HLSL_PUSH_CONSTANT_DESC_SET (~(0u))
+#define SPVC_HLSL_PUSH_CONSTANT_BINDING (0)
+
+/* Maps to C++ API. */
+typedef struct spvc_hlsl_resource_binding_mapping
+{
+	unsigned register_space;
+	unsigned register_binding;
+} spvc_hlsl_resource_binding_mapping;
+
+typedef struct spvc_hlsl_resource_binding
+{
+	SpvExecutionModel stage;
+	unsigned desc_set;
+	unsigned binding;
+
+	spvc_hlsl_resource_binding_mapping cbv, uav, srv, sampler;
+} spvc_hlsl_resource_binding;
+
+/*
+ * Initializes the resource binding struct.
+ * The defaults are non-zero.
+ */
+SPVC_PUBLIC_API void spvc_hlsl_resource_binding_init(spvc_hlsl_resource_binding *binding);
+
+/* Maps to the various spirv_cross::Compiler*::Option structures. See C++ API for defaults and details. */
+typedef enum spvc_compiler_option
+{
+	SPVC_COMPILER_OPTION_UNKNOWN = 0,
+
+	SPVC_COMPILER_OPTION_FORCE_TEMPORARY = 1 | SPVC_COMPILER_OPTION_COMMON_BIT,
+	SPVC_COMPILER_OPTION_FLATTEN_MULTIDIMENSIONAL_ARRAYS = 2 | SPVC_COMPILER_OPTION_COMMON_BIT,
+	SPVC_COMPILER_OPTION_FIXUP_DEPTH_CONVENTION = 3 | SPVC_COMPILER_OPTION_COMMON_BIT,
+	SPVC_COMPILER_OPTION_FLIP_VERTEX_Y = 4 | SPVC_COMPILER_OPTION_COMMON_BIT,
+
+	SPVC_COMPILER_OPTION_GLSL_SUPPORT_NONZERO_BASE_INSTANCE = 5 | SPVC_COMPILER_OPTION_GLSL_BIT,
+	SPVC_COMPILER_OPTION_GLSL_SEPARATE_SHADER_OBJECTS = 6 | SPVC_COMPILER_OPTION_GLSL_BIT,
+	SPVC_COMPILER_OPTION_GLSL_ENABLE_420PACK_EXTENSION = 7 | SPVC_COMPILER_OPTION_GLSL_BIT,
+	SPVC_COMPILER_OPTION_GLSL_VERSION = 8 | SPVC_COMPILER_OPTION_GLSL_BIT,
+	SPVC_COMPILER_OPTION_GLSL_ES = 9 | SPVC_COMPILER_OPTION_GLSL_BIT,
+	SPVC_COMPILER_OPTION_GLSL_VULKAN_SEMANTICS = 10 | SPVC_COMPILER_OPTION_GLSL_BIT,
+	SPVC_COMPILER_OPTION_GLSL_ES_DEFAULT_FLOAT_PRECISION_HIGHP = 11 | SPVC_COMPILER_OPTION_GLSL_BIT,
+	SPVC_COMPILER_OPTION_GLSL_ES_DEFAULT_INT_PRECISION_HIGHP = 12 | SPVC_COMPILER_OPTION_GLSL_BIT,
+
+	SPVC_COMPILER_OPTION_HLSL_SHADER_MODEL = 13 | SPVC_COMPILER_OPTION_HLSL_BIT,
+	SPVC_COMPILER_OPTION_HLSL_POINT_SIZE_COMPAT = 14 | SPVC_COMPILER_OPTION_HLSL_BIT,
+	SPVC_COMPILER_OPTION_HLSL_POINT_COORD_COMPAT = 15 | SPVC_COMPILER_OPTION_HLSL_BIT,
+	SPVC_COMPILER_OPTION_HLSL_SUPPORT_NONZERO_BASE_VERTEX_BASE_INSTANCE = 16 | SPVC_COMPILER_OPTION_HLSL_BIT,
+
+	SPVC_COMPILER_OPTION_MSL_VERSION = 17 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_TEXEL_BUFFER_TEXTURE_WIDTH = 18 | SPVC_COMPILER_OPTION_MSL_BIT,
+
+	/* Obsolete, use SWIZZLE_BUFFER_INDEX instead. */
+	SPVC_COMPILER_OPTION_MSL_AUX_BUFFER_INDEX = 19 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_SWIZZLE_BUFFER_INDEX = 19 | SPVC_COMPILER_OPTION_MSL_BIT,
+
+	SPVC_COMPILER_OPTION_MSL_INDIRECT_PARAMS_BUFFER_INDEX = 20 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_SHADER_OUTPUT_BUFFER_INDEX = 21 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_SHADER_PATCH_OUTPUT_BUFFER_INDEX = 22 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_SHADER_TESS_FACTOR_OUTPUT_BUFFER_INDEX = 23 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_SHADER_INPUT_WORKGROUP_INDEX = 24 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_ENABLE_POINT_SIZE_BUILTIN = 25 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_DISABLE_RASTERIZATION = 26 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_CAPTURE_OUTPUT_TO_BUFFER = 27 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_SWIZZLE_TEXTURE_SAMPLES = 28 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_PAD_FRAGMENT_OUTPUT_COMPONENTS = 29 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_TESS_DOMAIN_ORIGIN_LOWER_LEFT = 30 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_PLATFORM = 31 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_ARGUMENT_BUFFERS = 32 | SPVC_COMPILER_OPTION_MSL_BIT,
+
+	SPVC_COMPILER_OPTION_GLSL_EMIT_PUSH_CONSTANT_AS_UNIFORM_BUFFER = 33 | SPVC_COMPILER_OPTION_GLSL_BIT,
+
+	SPVC_COMPILER_OPTION_MSL_TEXTURE_BUFFER_NATIVE = 34 | SPVC_COMPILER_OPTION_MSL_BIT,
+
+	SPVC_COMPILER_OPTION_GLSL_EMIT_UNIFORM_BUFFER_AS_PLAIN_UNIFORMS = 35 | SPVC_COMPILER_OPTION_GLSL_BIT,
+
+	SPVC_COMPILER_OPTION_MSL_BUFFER_SIZE_BUFFER_INDEX = 36 | SPVC_COMPILER_OPTION_MSL_BIT,
+
+	SPVC_COMPILER_OPTION_EMIT_LINE_DIRECTIVES = 37 | SPVC_COMPILER_OPTION_COMMON_BIT,
+
+	SPVC_COMPILER_OPTION_MSL_MULTIVIEW = 38 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_VIEW_MASK_BUFFER_INDEX = 39 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_DEVICE_INDEX = 40 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_VIEW_INDEX_FROM_DEVICE_INDEX = 41 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_DISPATCH_BASE = 42 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_DYNAMIC_OFFSETS_BUFFER_INDEX = 43 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_TEXTURE_1D_AS_2D = 44 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_ENABLE_BASE_INDEX_ZERO = 45 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_IOS_FRAMEBUFFER_FETCH_SUBPASS = 46 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_INVARIANT_FP_MATH = 47 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_EMULATE_CUBEMAP_ARRAY = 48 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_ENABLE_DECORATION_BINDING = 49 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_FORCE_ACTIVE_ARGUMENT_BUFFER_RESOURCES = 50 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_FORCE_NATIVE_ARRAYS = 51 | SPVC_COMPILER_OPTION_MSL_BIT,
+
+	SPVC_COMPILER_OPTION_ENABLE_STORAGE_IMAGE_QUALIFIER_DEDUCTION = 52 | SPVC_COMPILER_OPTION_COMMON_BIT,
+
+	SPVC_COMPILER_OPTION_HLSL_FORCE_STORAGE_BUFFER_AS_UAV = 53 | SPVC_COMPILER_OPTION_HLSL_BIT,
+
+	SPVC_COMPILER_OPTION_FORCE_ZERO_INITIALIZED_VARIABLES = 54 | SPVC_COMPILER_OPTION_COMMON_BIT,
+
+	SPVC_COMPILER_OPTION_HLSL_NONWRITABLE_UAV_TEXTURE_AS_SRV = 55 | SPVC_COMPILER_OPTION_HLSL_BIT,
+
+	SPVC_COMPILER_OPTION_MSL_ENABLE_FRAG_OUTPUT_MASK = 56 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_ENABLE_FRAG_DEPTH_BUILTIN = 57 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_ENABLE_FRAG_STENCIL_REF_BUILTIN = 58 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_ENABLE_CLIP_DISTANCE_USER_VARYING = 59 | SPVC_COMPILER_OPTION_MSL_BIT,
+
+	SPVC_COMPILER_OPTION_HLSL_ENABLE_16BIT_TYPES = 60 | SPVC_COMPILER_OPTION_HLSL_BIT,
+
+	SPVC_COMPILER_OPTION_MSL_MULTI_PATCH_WORKGROUP = 61 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_SHADER_INPUT_BUFFER_INDEX = 62 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_SHADER_INDEX_BUFFER_INDEX = 63 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_VERTEX_FOR_TESSELLATION = 64 | SPVC_COMPILER_OPTION_MSL_BIT,
+	SPVC_COMPILER_OPTION_MSL_VERTEX_INDEX_TYPE = 65 | SPVC_COMPILER_OPTION_MSL_BIT,
+
+	SPVC_COMPILER_OPTION_GLSL_FORCE_FLATTENED_IO_BLOCKS = 66 | SPVC_COMPILER_OPTION_GLSL_BIT,
+
+	SPVC_COMPILER_OPTION_INT_MAX = 0x7fffffff
+} spvc_compiler_option;
+
+/*
+ * Context is the highest-level API construct.
+ * The context owns all memory allocations made by its child object hierarchy, including various non-opaque structs and strings.
+ * This means that the API user only has to care about one "destroy" call ever when using the C API.
+ * All pointers handed out by the APIs are only valid as long as the context
+ * is alive and spvc_context_release_allocations has not been called.
+ */
+SPVC_PUBLIC_API spvc_result spvc_context_create(spvc_context *context);
+
+/* Frees all memory allocations and objects associated with the context and its child objects. */
+SPVC_PUBLIC_API void spvc_context_destroy(spvc_context context);
+
+/* Frees all memory allocations and objects associated with the context and its child objects, but keeps the context alive. */
+SPVC_PUBLIC_API void spvc_context_release_allocations(spvc_context context);
+
+/* Get the string for the last error which was logged. */
+SPVC_PUBLIC_API const char *spvc_context_get_last_error_string(spvc_context context);
+
+/* Get notified in a callback when an error triggers. Useful for debugging. */
+typedef void (*spvc_error_callback)(void *userdata, const char *error);
+SPVC_PUBLIC_API void spvc_context_set_error_callback(spvc_context context, spvc_error_callback cb, void *userdata);
+
+/* SPIR-V parsing interface. Maps to Parser which then creates a ParsedIR, and that IR is extracted into the handle. */
+SPVC_PUBLIC_API spvc_result spvc_context_parse_spirv(spvc_context context, const SpvId *spirv, size_t word_count,
+                                                     spvc_parsed_ir *parsed_ir);
+
+/*
+ * Create a compiler backend. Capture mode controls if we construct by copy or move semantics.
+ * It is always recommended to use SPVC_CAPTURE_MODE_TAKE_OWNERSHIP if you only intend to cross-compile the IR once.
+ */
+SPVC_PUBLIC_API spvc_result spvc_context_create_compiler(spvc_context context, spvc_backend backend,
+                                                         spvc_parsed_ir parsed_ir, spvc_capture_mode mode,
+                                                         spvc_compiler *compiler);
+
+/* Maps directly to C++ API. */
+SPVC_PUBLIC_API unsigned spvc_compiler_get_current_id_bound(spvc_compiler compiler);
+
+/* Create compiler options, which will initialize defaults. */
+SPVC_PUBLIC_API spvc_result spvc_compiler_create_compiler_options(spvc_compiler compiler,
+                                                                  spvc_compiler_options *options);
+/* Override options. Will return error if e.g. MSL options are used for the HLSL backend, etc. */
+SPVC_PUBLIC_API spvc_result spvc_compiler_options_set_bool(spvc_compiler_options options,
+                                                           spvc_compiler_option option, spvc_bool value);
+SPVC_PUBLIC_API spvc_result spvc_compiler_options_set_uint(spvc_compiler_options options,
+                                                           spvc_compiler_option option, unsigned value);
+/* Set compiler options. */
+SPVC_PUBLIC_API spvc_result spvc_compiler_install_compiler_options(spvc_compiler compiler,
+                                                                   spvc_compiler_options options);
+
+/* Compile IR into a string. *source is owned by the context, and caller must not free it themselves. */
+SPVC_PUBLIC_API spvc_result spvc_compiler_compile(spvc_compiler compiler, const char **source);
+
+/* Maps to C++ API. */
+SPVC_PUBLIC_API spvc_result spvc_compiler_add_header_line(spvc_compiler compiler, const char *line);
+SPVC_PUBLIC_API spvc_result spvc_compiler_require_extension(spvc_compiler compiler, const char *ext);
+SPVC_PUBLIC_API spvc_result spvc_compiler_flatten_buffer_block(spvc_compiler compiler, spvc_variable_id id);
+
+SPVC_PUBLIC_API spvc_bool spvc_compiler_variable_is_depth_or_compare(spvc_compiler compiler, spvc_variable_id id);
+
+/*
+ * HLSL specifics.
+ * Maps to C++ API.
+ */
+SPVC_PUBLIC_API spvc_result spvc_compiler_hlsl_set_root_constants_layout(spvc_compiler compiler,
+                                                                         const spvc_hlsl_root_constants *constant_info,
+                                                                         size_t count);
+SPVC_PUBLIC_API spvc_result spvc_compiler_hlsl_add_vertex_attribute_remap(spvc_compiler compiler,
+                                                                          const spvc_hlsl_vertex_attribute_remap *remap,
+                                                                          size_t remaps);
+SPVC_PUBLIC_API spvc_variable_id spvc_compiler_hlsl_remap_num_workgroups_builtin(spvc_compiler compiler);
+
+SPVC_PUBLIC_API spvc_result spvc_compiler_hlsl_set_resource_binding_flags(spvc_compiler compiler,
+                                                                          spvc_hlsl_binding_flags flags);
+
+SPVC_PUBLIC_API spvc_result spvc_compiler_hlsl_add_resource_binding(spvc_compiler compiler,
+                                                                    const spvc_hlsl_resource_binding *binding);
+SPVC_PUBLIC_API spvc_bool spvc_compiler_hlsl_is_resource_used(spvc_compiler compiler,
+                                                              SpvExecutionModel model,
+                                                              unsigned set,
+                                                              unsigned binding);
+
+/*
+ * MSL specifics.
+ * Maps to C++ API.
+ */
+SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_is_rasterization_disabled(spvc_compiler compiler);
+
+/* Obsolete. Renamed to needs_swizzle_buffer. */
+SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_needs_aux_buffer(spvc_compiler compiler);
+SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_needs_swizzle_buffer(spvc_compiler compiler);
+SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_needs_buffer_size_buffer(spvc_compiler compiler);
+
+SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_needs_output_buffer(spvc_compiler compiler);
+SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_needs_patch_output_buffer(spvc_compiler compiler);
+SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_needs_input_threadgroup_mem(spvc_compiler compiler);
+SPVC_PUBLIC_API spvc_result spvc_compiler_msl_add_vertex_attribute(spvc_compiler compiler,
+                                                                   const spvc_msl_vertex_attribute *attrs);
+SPVC_PUBLIC_API spvc_result spvc_compiler_msl_add_resource_binding(spvc_compiler compiler,
+                                                                   const spvc_msl_resource_binding *binding);
+SPVC_PUBLIC_API spvc_result spvc_compiler_msl_add_shader_input(spvc_compiler compiler,
+                                                               const spvc_msl_shader_input *input);
+SPVC_PUBLIC_API spvc_result spvc_compiler_msl_add_discrete_descriptor_set(spvc_compiler compiler, unsigned desc_set);
+SPVC_PUBLIC_API spvc_result spvc_compiler_msl_set_argument_buffer_device_address_space(spvc_compiler compiler, unsigned desc_set, spvc_bool device_address);
+
+/* Obsolete, use is_shader_input_used. */
+SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_is_vertex_attribute_used(spvc_compiler compiler, unsigned location);
+SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_is_shader_input_used(spvc_compiler compiler, unsigned location);
+
+SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_is_resource_used(spvc_compiler compiler,
+                                                             SpvExecutionModel model,
+                                                             unsigned set,
+                                                             unsigned binding);
+SPVC_PUBLIC_API spvc_result spvc_compiler_msl_remap_constexpr_sampler(spvc_compiler compiler, spvc_variable_id id, const spvc_msl_constexpr_sampler *sampler);
+SPVC_PUBLIC_API spvc_result spvc_compiler_msl_remap_constexpr_sampler_by_binding(spvc_compiler compiler, unsigned desc_set, unsigned binding, const spvc_msl_constexpr_sampler *sampler);
+SPVC_PUBLIC_API spvc_result spvc_compiler_msl_remap_constexpr_sampler_ycbcr(spvc_compiler compiler, spvc_variable_id id, const spvc_msl_constexpr_sampler *sampler, const spvc_msl_sampler_ycbcr_conversion *conv);
+SPVC_PUBLIC_API spvc_result spvc_compiler_msl_remap_constexpr_sampler_by_binding_ycbcr(spvc_compiler compiler, unsigned desc_set, unsigned binding, const spvc_msl_constexpr_sampler *sampler, const spvc_msl_sampler_ycbcr_conversion *conv);
+SPVC_PUBLIC_API spvc_result spvc_compiler_msl_set_fragment_output_components(spvc_compiler compiler, unsigned location, unsigned components);
+
+SPVC_PUBLIC_API unsigned spvc_compiler_msl_get_automatic_resource_binding(spvc_compiler compiler, spvc_variable_id id);
+SPVC_PUBLIC_API unsigned spvc_compiler_msl_get_automatic_resource_binding_secondary(spvc_compiler compiler, spvc_variable_id id);
+
+SPVC_PUBLIC_API spvc_result spvc_compiler_msl_add_dynamic_buffer(spvc_compiler compiler, unsigned desc_set, unsigned binding, unsigned index);
+
+SPVC_PUBLIC_API spvc_result spvc_compiler_msl_add_inline_uniform_block(spvc_compiler compiler, unsigned desc_set, unsigned binding);
+
+/*
+ * Reflect resources.
+ * Maps almost 1:1 to C++ API.
+ */
+SPVC_PUBLIC_API spvc_result spvc_compiler_get_active_interface_variables(spvc_compiler compiler, spvc_set *set);
+SPVC_PUBLIC_API spvc_result spvc_compiler_set_enabled_interface_variables(spvc_compiler compiler, spvc_set set);
+SPVC_PUBLIC_API spvc_result spvc_compiler_create_shader_resources(spvc_compiler compiler, spvc_resources *resources);
+SPVC_PUBLIC_API spvc_result spvc_compiler_create_shader_resources_for_active_variables(spvc_compiler compiler,
+                                                                                       spvc_resources *resources,
+                                                                                       spvc_set active);
+SPVC_PUBLIC_API spvc_result spvc_resources_get_resource_list_for_type(spvc_resources resources, spvc_resource_type type,
+                                                                      const spvc_reflected_resource **resource_list,
+                                                                      size_t *resource_size);
+
+/*
+ * Decorations.
+ * Maps to C++ API.
+ */
+SPVC_PUBLIC_API void spvc_compiler_set_decoration(spvc_compiler compiler, SpvId id, SpvDecoration decoration,
+                                                  unsigned argument);
+SPVC_PUBLIC_API void spvc_compiler_set_decoration_string(spvc_compiler compiler, SpvId id, SpvDecoration decoration,
+                                                         const char *argument);
+SPVC_PUBLIC_API void spvc_compiler_set_name(spvc_compiler compiler, SpvId id, const char *argument);
+SPVC_PUBLIC_API void spvc_compiler_set_member_decoration(spvc_compiler compiler, spvc_type_id id, unsigned member_index,
+                                                         SpvDecoration decoration, unsigned argument);
+SPVC_PUBLIC_API void spvc_compiler_set_member_decoration_string(spvc_compiler compiler, spvc_type_id id,
+                                                                unsigned member_index, SpvDecoration decoration,
+                                                                const char *argument);
+SPVC_PUBLIC_API void spvc_compiler_set_member_name(spvc_compiler compiler, spvc_type_id id, unsigned member_index,
+                                                   const char *argument);
+SPVC_PUBLIC_API void spvc_compiler_unset_decoration(spvc_compiler compiler, SpvId id, SpvDecoration decoration);
+SPVC_PUBLIC_API void spvc_compiler_unset_member_decoration(spvc_compiler compiler, spvc_type_id id,
+                                                           unsigned member_index, SpvDecoration decoration);
+
+SPVC_PUBLIC_API spvc_bool spvc_compiler_has_decoration(spvc_compiler compiler, SpvId id, SpvDecoration decoration);
+SPVC_PUBLIC_API spvc_bool spvc_compiler_has_member_decoration(spvc_compiler compiler, spvc_type_id id,
+                                                              unsigned member_index, SpvDecoration decoration);
+SPVC_PUBLIC_API const char *spvc_compiler_get_name(spvc_compiler compiler, SpvId id);
+SPVC_PUBLIC_API unsigned spvc_compiler_get_decoration(spvc_compiler compiler, SpvId id, SpvDecoration decoration);
+SPVC_PUBLIC_API const char *spvc_compiler_get_decoration_string(spvc_compiler compiler, SpvId id,
+                                                                SpvDecoration decoration);
+SPVC_PUBLIC_API unsigned spvc_compiler_get_member_decoration(spvc_compiler compiler, spvc_type_id id,
+                                                             unsigned member_index, SpvDecoration decoration);
+SPVC_PUBLIC_API const char *spvc_compiler_get_member_decoration_string(spvc_compiler compiler, spvc_type_id id,
+                                                                       unsigned member_index, SpvDecoration decoration);
+SPVC_PUBLIC_API const char *spvc_compiler_get_member_name(spvc_compiler compiler, spvc_type_id id, unsigned member_index);
+
+/*
+ * Entry points.
+ * Maps to C++ API.
+ */
+SPVC_PUBLIC_API spvc_result spvc_compiler_get_entry_points(spvc_compiler compiler,
+                                                           const spvc_entry_point **entry_points,
+                                                           size_t *num_entry_points);
+SPVC_PUBLIC_API spvc_result spvc_compiler_set_entry_point(spvc_compiler compiler, const char *name,
+                                                          SpvExecutionModel model);
+SPVC_PUBLIC_API spvc_result spvc_compiler_rename_entry_point(spvc_compiler compiler, const char *old_name,
+                                                             const char *new_name, SpvExecutionModel model);
+SPVC_PUBLIC_API const char *spvc_compiler_get_cleansed_entry_point_name(spvc_compiler compiler, const char *name,
+                                                                        SpvExecutionModel model);
+SPVC_PUBLIC_API void spvc_compiler_set_execution_mode(spvc_compiler compiler, SpvExecutionMode mode);
+SPVC_PUBLIC_API void spvc_compiler_unset_execution_mode(spvc_compiler compiler, SpvExecutionMode mode);
+SPVC_PUBLIC_API void spvc_compiler_set_execution_mode_with_arguments(spvc_compiler compiler, SpvExecutionMode mode,
+                                                                     unsigned arg0, unsigned arg1, unsigned arg2);
+SPVC_PUBLIC_API spvc_result spvc_compiler_get_execution_modes(spvc_compiler compiler, const SpvExecutionMode **modes,
+                                                              size_t *num_modes);
+SPVC_PUBLIC_API unsigned spvc_compiler_get_execution_mode_argument(spvc_compiler compiler, SpvExecutionMode mode);
+SPVC_PUBLIC_API unsigned spvc_compiler_get_execution_mode_argument_by_index(spvc_compiler compiler,
+                                                                            SpvExecutionMode mode, unsigned index);
+SPVC_PUBLIC_API SpvExecutionModel spvc_compiler_get_execution_model(spvc_compiler compiler);
+
+/*
+ * Type query interface.
+ * Maps to C++ API, except it's read-only.
+ */
+SPVC_PUBLIC_API spvc_type spvc_compiler_get_type_handle(spvc_compiler compiler, spvc_type_id id);
+
+/* Pulls out SPIRType::self. This effectively gives the type ID without array or pointer qualifiers.
+ * This is necessary when reflecting decoration/name information on members of a struct,
+ * which are placed in the base type, not the qualified type.
+ * This is similar to spvc_reflected_resource::base_type_id. */
+SPVC_PUBLIC_API spvc_type_id spvc_type_get_base_type_id(spvc_type type);
+
+SPVC_PUBLIC_API spvc_basetype spvc_type_get_basetype(spvc_type type);
+SPVC_PUBLIC_API unsigned spvc_type_get_bit_width(spvc_type type);
+SPVC_PUBLIC_API unsigned spvc_type_get_vector_size(spvc_type type);
+SPVC_PUBLIC_API unsigned spvc_type_get_columns(spvc_type type);
+SPVC_PUBLIC_API unsigned spvc_type_get_num_array_dimensions(spvc_type type);
+SPVC_PUBLIC_API spvc_bool spvc_type_array_dimension_is_literal(spvc_type type, unsigned dimension);
+SPVC_PUBLIC_API SpvId spvc_type_get_array_dimension(spvc_type type, unsigned dimension);
+SPVC_PUBLIC_API unsigned spvc_type_get_num_member_types(spvc_type type);
+SPVC_PUBLIC_API spvc_type_id spvc_type_get_member_type(spvc_type type, unsigned index);
+SPVC_PUBLIC_API SpvStorageClass spvc_type_get_storage_class(spvc_type type);
+
+/* Image type query. */
+SPVC_PUBLIC_API spvc_type_id spvc_type_get_image_sampled_type(spvc_type type);
+SPVC_PUBLIC_API SpvDim spvc_type_get_image_dimension(spvc_type type);
+SPVC_PUBLIC_API spvc_bool spvc_type_get_image_is_depth(spvc_type type);
+SPVC_PUBLIC_API spvc_bool spvc_type_get_image_arrayed(spvc_type type);
+SPVC_PUBLIC_API spvc_bool spvc_type_get_image_multisampled(spvc_type type);
+SPVC_PUBLIC_API spvc_bool spvc_type_get_image_is_storage(spvc_type type);
+SPVC_PUBLIC_API SpvImageFormat spvc_type_get_image_storage_format(spvc_type type);
+SPVC_PUBLIC_API SpvAccessQualifier spvc_type_get_image_access_qualifier(spvc_type type);
+
+/*
+ * Buffer layout query.
+ * Maps to C++ API.
+ */
+SPVC_PUBLIC_API spvc_result spvc_compiler_get_declared_struct_size(spvc_compiler compiler, spvc_type struct_type, size_t *size);
+SPVC_PUBLIC_API spvc_result spvc_compiler_get_declared_struct_size_runtime_array(spvc_compiler compiler,
+                                                                                 spvc_type struct_type, size_t array_size, size_t *size);
+SPVC_PUBLIC_API spvc_result spvc_compiler_get_declared_struct_member_size(spvc_compiler compiler, spvc_type type, unsigned index, size_t *size);
+
+SPVC_PUBLIC_API spvc_result spvc_compiler_type_struct_member_offset(spvc_compiler compiler,
+                                                                    spvc_type type, unsigned index, unsigned *offset);
+SPVC_PUBLIC_API spvc_result spvc_compiler_type_struct_member_array_stride(spvc_compiler compiler,
+                                                                          spvc_type type, unsigned index, unsigned *stride);
+SPVC_PUBLIC_API spvc_result spvc_compiler_type_struct_member_matrix_stride(spvc_compiler compiler,
+                                                                           spvc_type type, unsigned index, unsigned *stride);
+
+/*
+ * Workaround helper functions.
+ * Maps to C++ API.
+ */
+SPVC_PUBLIC_API spvc_result spvc_compiler_build_dummy_sampler_for_combined_images(spvc_compiler compiler, spvc_variable_id *id);
+SPVC_PUBLIC_API spvc_result spvc_compiler_build_combined_image_samplers(spvc_compiler compiler);
+SPVC_PUBLIC_API spvc_result spvc_compiler_get_combined_image_samplers(spvc_compiler compiler,
+                                                                      const spvc_combined_image_sampler **samplers,
+                                                                      size_t *num_samplers);
+
+/*
+ * Constants
+ * Maps to C++ API.
+ */
+SPVC_PUBLIC_API spvc_result spvc_compiler_get_specialization_constants(spvc_compiler compiler,
+                                                                       const spvc_specialization_constant **constants,
+                                                                       size_t *num_constants);
+SPVC_PUBLIC_API spvc_constant spvc_compiler_get_constant_handle(spvc_compiler compiler,
+                                                                spvc_constant_id id);
+
+SPVC_PUBLIC_API spvc_constant_id spvc_compiler_get_work_group_size_specialization_constants(spvc_compiler compiler,
+                                                                                            spvc_specialization_constant *x,
+                                                                                            spvc_specialization_constant *y,
+                                                                                            spvc_specialization_constant *z);
+
+/*
+ * Buffer ranges
+ * Maps to C++ API.
+ */
+SPVC_PUBLIC_API spvc_result spvc_compiler_get_active_buffer_ranges(spvc_compiler compiler,
+                                                                   spvc_variable_id id,
+                                                                   const spvc_buffer_range **ranges,
+                                                                   size_t *num_ranges);
+
+/*
+ * No stdint.h until C99, sigh :(
+ * For smaller types, the result is sign or zero-extended as appropriate.
+ * Maps to C++ API.
+ * TODO: The SPIRConstant query interface and modification interface is not quite complete.
+ */
+SPVC_PUBLIC_API float spvc_constant_get_scalar_fp16(spvc_constant constant, unsigned column, unsigned row);
+SPVC_PUBLIC_API float spvc_constant_get_scalar_fp32(spvc_constant constant, unsigned column, unsigned row);
+SPVC_PUBLIC_API double spvc_constant_get_scalar_fp64(spvc_constant constant, unsigned column, unsigned row);
+SPVC_PUBLIC_API unsigned spvc_constant_get_scalar_u32(spvc_constant constant, unsigned column, unsigned row);
+SPVC_PUBLIC_API int spvc_constant_get_scalar_i32(spvc_constant constant, unsigned column, unsigned row);
+SPVC_PUBLIC_API unsigned spvc_constant_get_scalar_u16(spvc_constant constant, unsigned column, unsigned row);
+SPVC_PUBLIC_API int spvc_constant_get_scalar_i16(spvc_constant constant, unsigned column, unsigned row);
+SPVC_PUBLIC_API unsigned spvc_constant_get_scalar_u8(spvc_constant constant, unsigned column, unsigned row);
+SPVC_PUBLIC_API int spvc_constant_get_scalar_i8(spvc_constant constant, unsigned column, unsigned row);
+SPVC_PUBLIC_API void spvc_constant_get_subconstants(spvc_constant constant, const spvc_constant_id **constituents, size_t *count);
+SPVC_PUBLIC_API spvc_type_id spvc_constant_get_type(spvc_constant constant);
+
+/*
+ * Misc reflection
+ * Maps to C++ API.
+ */
+SPVC_PUBLIC_API spvc_bool spvc_compiler_get_binary_offset_for_decoration(spvc_compiler compiler,
+                                                                         spvc_variable_id id,
+                                                                         SpvDecoration decoration,
+                                                                         unsigned *word_offset);
+
+SPVC_PUBLIC_API spvc_bool spvc_compiler_buffer_is_hlsl_counter_buffer(spvc_compiler compiler, spvc_variable_id id);
+SPVC_PUBLIC_API spvc_bool spvc_compiler_buffer_get_hlsl_counter_buffer(spvc_compiler compiler, spvc_variable_id id,
+                                                                       spvc_variable_id *counter_id);
+
+SPVC_PUBLIC_API spvc_result spvc_compiler_get_declared_capabilities(spvc_compiler compiler,
+                                                                    const SpvCapability **capabilities,
+                                                                    size_t *num_capabilities);
+SPVC_PUBLIC_API spvc_result spvc_compiler_get_declared_extensions(spvc_compiler compiler, const char ***extensions,
+                                                                  size_t *num_extensions);
+
+SPVC_PUBLIC_API const char *spvc_compiler_get_remapped_declared_block_name(spvc_compiler compiler, spvc_variable_id id);
+SPVC_PUBLIC_API spvc_result spvc_compiler_get_buffer_block_decorations(spvc_compiler compiler, spvc_variable_id id,
+                                                                       const SpvDecoration **decorations,
+                                                                       size_t *num_decorations);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/engine/inc/spirv_cross/spirv_cross_containers.hpp b/engine/inc/spirv_cross/spirv_cross_containers.hpp
new file mode 100644
index 00000000..37238ec1
--- /dev/null
+++ b/engine/inc/spirv_cross/spirv_cross_containers.hpp
@@ -0,0 +1,735 @@
+/*
+ * Copyright 2019-2020 Hans-Kristian Arntzen
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SPIRV_CROSS_CONTAINERS_HPP
+#define SPIRV_CROSS_CONTAINERS_HPP
+
+#include "spirv_cross_error_handling.hpp"
+#include <algorithm>
+#include <functional>
+#include <iterator>
+#include <limits>
+#include <memory>
+#include <stack>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <type_traits>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#ifdef SPIRV_CROSS_NAMESPACE_OVERRIDE
+#define SPIRV_CROSS_NAMESPACE SPIRV_CROSS_NAMESPACE_OVERRIDE
+#else
+#define SPIRV_CROSS_NAMESPACE spirv_cross
+#endif
+
+namespace SPIRV_CROSS_NAMESPACE
+{
+#ifndef SPIRV_CROSS_FORCE_STL_TYPES
+// std::aligned_storage does not support size == 0, so roll our own.
+template <typename T, size_t N>
+class AlignedBuffer
+{
+public:
+	T *data()
+	{
+#if defined(_MSC_VER) && _MSC_VER < 1900
+		// MSVC 2013 workarounds, sigh ...
+		// Only use this workaround on MSVC 2013 due to some confusion around default initialized unions.
+		// Spec seems to suggest the memory will be zero-initialized, which is *not* what we want.
+		return reinterpret_cast<T *>(u.aligned_char);
+#else
+		return reinterpret_cast<T *>(aligned_char);
+#endif
+	}
+
+private:
+#if defined(_MSC_VER) && _MSC_VER < 1900
+	// MSVC 2013 workarounds, sigh ...
+	union
+	{
+		char aligned_char[sizeof(T) * N];
+		double dummy_aligner;
+	} u;
+#else
+	alignas(T) char aligned_char[sizeof(T) * N];
+#endif
+};
+
+template <typename T>
+class AlignedBuffer<T, 0>
+{
+public:
+	T *data()
+	{
+		return nullptr;
+	}
+};
+
+// An immutable version of SmallVector which erases type information about storage.
+template <typename T>
+class VectorView
+{
+public:
+	T &operator[](size_t i) SPIRV_CROSS_NOEXCEPT
+	{
+		return ptr[i];
+	}
+
+	const T &operator[](size_t i) const SPIRV_CROSS_NOEXCEPT
+	{
+		return ptr[i];
+	}
+
+	bool empty() const SPIRV_CROSS_NOEXCEPT
+	{
+		return buffer_size == 0;
+	}
+
+	size_t size() const SPIRV_CROSS_NOEXCEPT
+	{
+		return buffer_size;
+	}
+
+	T *data() SPIRV_CROSS_NOEXCEPT
+	{
+		return ptr;
+	}
+
+	const T *data() const SPIRV_CROSS_NOEXCEPT
+	{
+		return ptr;
+	}
+
+	T *begin() SPIRV_CROSS_NOEXCEPT
+	{
+		return ptr;
+	}
+
+	T *end() SPIRV_CROSS_NOEXCEPT
+	{
+		return ptr + buffer_size;
+	}
+
+	const T *begin() const SPIRV_CROSS_NOEXCEPT
+	{
+		return ptr;
+	}
+
+	const T *end() const SPIRV_CROSS_NOEXCEPT
+	{
+		return ptr + buffer_size;
+	}
+
+	T &front() SPIRV_CROSS_NOEXCEPT
+	{
+		return ptr[0];
+	}
+
+	const T &front() const SPIRV_CROSS_NOEXCEPT
+	{
+		return ptr[0];
+	}
+
+	T &back() SPIRV_CROSS_NOEXCEPT
+	{
+		return ptr[buffer_size - 1];
+	}
+
+	const T &back() const SPIRV_CROSS_NOEXCEPT
+	{
+		return ptr[buffer_size - 1];
+	}
+
+	// Makes it easier to consume SmallVector.
+#if defined(_MSC_VER) && _MSC_VER < 1900
+	explicit operator std::vector<T>() const
+	{
+		// Another MSVC 2013 workaround. It does not understand lvalue/rvalue qualified operations.
+		return std::vector<T>(ptr, ptr + buffer_size);
+	}
+#else
+	// Makes it easier to consume SmallVector.
+	explicit operator std::vector<T>() const &
+	{
+		return std::vector<T>(ptr, ptr + buffer_size);
+	}
+
+	// If we are converting as an r-value, we can pilfer our elements.
+	explicit operator std::vector<T>() &&
+	{
+		return std::vector<T>(std::make_move_iterator(ptr), std::make_move_iterator(ptr + buffer_size));
+	}
+#endif
+
+	// Avoid sliced copies. Base class should only be read as a reference.
+	VectorView(const VectorView &) = delete;
+	void operator=(const VectorView &) = delete;
+
+protected:
+	VectorView() = default;
+	T *ptr = nullptr;
+	size_t buffer_size = 0;
+};
+
+// Simple vector which supports up to N elements inline, without malloc/free.
+// We use a lot of throwaway vectors all over the place which triggers allocations.
+// This class only implements the subset of std::vector we need in SPIRV-Cross.
+// It is *NOT* a drop-in replacement in general projects.
+template <typename T, size_t N = 8>
+class SmallVector : public VectorView<T>
+{
+public:
+	SmallVector() SPIRV_CROSS_NOEXCEPT
+	{
+		this->ptr = stack_storage.data();
+		buffer_capacity = N;
+	}
+
+	SmallVector(const T *arg_list_begin, const T *arg_list_end) SPIRV_CROSS_NOEXCEPT : SmallVector()
+	{
+		auto count = size_t(arg_list_end - arg_list_begin);
+		reserve(count);
+		for (size_t i = 0; i < count; i++, arg_list_begin++)
+			new (&this->ptr[i]) T(*arg_list_begin);
+		this->buffer_size = count;
+	}
+
+	SmallVector(SmallVector &&other) SPIRV_CROSS_NOEXCEPT : SmallVector()
+	{
+		*this = std::move(other);
+	}
+
+	SmallVector &operator=(SmallVector &&other) SPIRV_CROSS_NOEXCEPT
+	{
+		clear();
+		if (other.ptr != other.stack_storage.data())
+		{
+			// Pilfer allocated pointer.
+			if (this->ptr != stack_storage.data())
+				free(this->ptr);
+			this->ptr = other.ptr;
+			this->buffer_size = other.buffer_size;
+			buffer_capacity = other.buffer_capacity;
+			other.ptr = nullptr;
+			other.buffer_size = 0;
+			other.buffer_capacity = 0;
+		}
+		else
+		{
+			// Need to move the stack contents individually.
+			reserve(other.buffer_size);
+			for (size_t i = 0; i < other.buffer_size; i++)
+			{
+				new (&this->ptr[i]) T(std::move(other.ptr[i]));
+				other.ptr[i].~T();
+			}
+			this->buffer_size = other.buffer_size;
+			other.buffer_size = 0;
+		}
+		return *this;
+	}
+
+	SmallVector(const SmallVector &other) SPIRV_CROSS_NOEXCEPT : SmallVector()
+	{
+		*this = other;
+	}
+
+	SmallVector &operator=(const SmallVector &other) SPIRV_CROSS_NOEXCEPT
+	{
+		if (this == &other)
+			return *this;
+
+		clear();
+		reserve(other.buffer_size);
+		for (size_t i = 0; i < other.buffer_size; i++)
+			new (&this->ptr[i]) T(other.ptr[i]);
+		this->buffer_size = other.buffer_size;
+		return *this;
+	}
+
+	explicit SmallVector(size_t count) SPIRV_CROSS_NOEXCEPT : SmallVector()
+	{
+		resize(count);
+	}
+
+	~SmallVector()
+	{
+		clear();
+		if (this->ptr != stack_storage.data())
+			free(this->ptr);
+	}
+
+	void clear() SPIRV_CROSS_NOEXCEPT
+	{
+		for (size_t i = 0; i < this->buffer_size; i++)
+			this->ptr[i].~T();
+		this->buffer_size = 0;
+	}
+
+	void push_back(const T &t) SPIRV_CROSS_NOEXCEPT
+	{
+		reserve(this->buffer_size + 1);
+		new (&this->ptr[this->buffer_size]) T(t);
+		this->buffer_size++;
+	}
+
+	void push_back(T &&t) SPIRV_CROSS_NOEXCEPT
+	{
+		reserve(this->buffer_size + 1);
+		new (&this->ptr[this->buffer_size]) T(std::move(t));
+		this->buffer_size++;
+	}
+
+	void pop_back() SPIRV_CROSS_NOEXCEPT
+	{
+		// Work around false positive warning on GCC 8.3.
+		// Calling pop_back on empty vector is undefined.
+		if (!this->empty())
+			resize(this->buffer_size - 1);
+	}
+
+	template <typename... Ts>
+	void emplace_back(Ts &&... ts) SPIRV_CROSS_NOEXCEPT
+	{
+		reserve(this->buffer_size + 1);
+		new (&this->ptr[this->buffer_size]) T(std::forward<Ts>(ts)...);
+		this->buffer_size++;
+	}
+
+	void reserve(size_t count) SPIRV_CROSS_NOEXCEPT
+	{
+		if ((count > std::numeric_limits<size_t>::max() / sizeof(T)) ||
+		    (count > std::numeric_limits<size_t>::max() / 2))
+		{
+			// Only way this should ever happen is with garbage input, terminate.
+			std::terminate();
+		}
+
+		if (count > buffer_capacity)
+		{
+			size_t target_capacity = buffer_capacity;
+			if (target_capacity == 0)
+				target_capacity = 1;
+			if (target_capacity < N)
+				target_capacity = N;
+
+			// Need to ensure there is a POT value of target capacity which is larger than count,
+			// otherwise this will overflow.
+			while (target_capacity < count)
+				target_capacity <<= 1u;
+
+			T *new_buffer =
+			    target_capacity > N ? static_cast<T *>(malloc(target_capacity * sizeof(T))) : stack_storage.data();
+
+			// If we actually fail this malloc, we are hosed anyways, there is no reason to attempt recovery.
+			if (!new_buffer)
+				std::terminate();
+
+			// In case for some reason two allocations both come from same stack.
+			if (new_buffer != this->ptr)
+			{
+				// We don't deal with types which can throw in move constructor.
+				for (size_t i = 0; i < this->buffer_size; i++)
+				{
+					new (&new_buffer[i]) T(std::move(this->ptr[i]));
+					this->ptr[i].~T();
+				}
+			}
+
+			if (this->ptr != stack_storage.data())
+				free(this->ptr);
+			this->ptr = new_buffer;
+			buffer_capacity = target_capacity;
+		}
+	}
+
+	void insert(T *itr, const T *insert_begin, const T *insert_end) SPIRV_CROSS_NOEXCEPT
+	{
+		auto count = size_t(insert_end - insert_begin);
+		if (itr == this->end())
+		{
+			reserve(this->buffer_size + count);
+			for (size_t i = 0; i < count; i++, insert_begin++)
+				new (&this->ptr[this->buffer_size + i]) T(*insert_begin);
+			this->buffer_size += count;
+		}
+		else
+		{
+			if (this->buffer_size + count > buffer_capacity)
+			{
+				auto target_capacity = this->buffer_size + count;
+				if (target_capacity == 0)
+					target_capacity = 1;
+				if (target_capacity < N)
+					target_capacity = N;
+
+				while (target_capacity < count)
+					target_capacity <<= 1u;
+
+				// Need to allocate new buffer. Move everything to a new buffer.
+				T *new_buffer =
+				    target_capacity > N ? static_cast<T *>(malloc(target_capacity * sizeof(T))) : stack_storage.data();
+
+				// If we actually fail this malloc, we are hosed anyways, there is no reason to attempt recovery.
+				if (!new_buffer)
+					std::terminate();
+
+				// First, move elements from source buffer to new buffer.
+				// We don't deal with types which can throw in move constructor.
+				auto *target_itr = new_buffer;
+				auto *original_source_itr = this->begin();
+
+				if (new_buffer != this->ptr)
+				{
+					while (original_source_itr != itr)
+					{
+						new (target_itr) T(std::move(*original_source_itr));
+						original_source_itr->~T();
+						++original_source_itr;
+						++target_itr;
+					}
+				}
+
+				// Copy-construct new elements.
+				for (auto *source_itr = insert_begin; source_itr != insert_end; ++source_itr, ++target_itr)
+					new (target_itr) T(*source_itr);
+
+				// Move over the other half.
+				if (new_buffer != this->ptr || insert_begin != insert_end)
+				{
+					while (original_source_itr != this->end())
+					{
+						new (target_itr) T(std::move(*original_source_itr));
+						original_source_itr->~T();
+						++original_source_itr;
+						++target_itr;
+					}
+				}
+
+				if (this->ptr != stack_storage.data())
+					free(this->ptr);
+				this->ptr = new_buffer;
+				buffer_capacity = target_capacity;
+			}
+			else
+			{
+				// Move in place, need to be a bit careful about which elements are constructed and which are not.
+				// Move the end and construct the new elements.
+				auto *target_itr = this->end() + count;
+				auto *source_itr = this->end();
+				while (target_itr != this->end() && source_itr != itr)
+				{
+					--target_itr;
+					--source_itr;
+					new (target_itr) T(std::move(*source_itr));
+				}
+
+				// For already constructed elements we can move-assign.
+				std::move_backward(itr, source_itr, target_itr);
+
+				// For the inserts which go to already constructed elements, we can do a plain copy.
+				while (itr != this->end() && insert_begin != insert_end)
+					*itr++ = *insert_begin++;
+
+				// For inserts into newly allocated memory, we must copy-construct instead.
+				while (insert_begin != insert_end)
+				{
+					new (itr) T(*insert_begin);
+					++itr;
+					++insert_begin;
+				}
+			}
+
+			this->buffer_size += count;
+		}
+	}
+
+	void insert(T *itr, const T &value) SPIRV_CROSS_NOEXCEPT
+	{
+		insert(itr, &value, &value + 1);
+	}
+
+	T *erase(T *itr) SPIRV_CROSS_NOEXCEPT
+	{
+		std::move(itr + 1, this->end(), itr);
+		this->ptr[--this->buffer_size].~T();
+		return itr;
+	}
+
+	void erase(T *start_erase, T *end_erase) SPIRV_CROSS_NOEXCEPT
+	{
+		if (end_erase == this->end())
+		{
+			resize(size_t(start_erase - this->begin()));
+		}
+		else
+		{
+			auto new_size = this->buffer_size - (end_erase - start_erase);
+			std::move(end_erase, this->end(), start_erase);
+			resize(new_size);
+		}
+	}
+
+	void resize(size_t new_size) SPIRV_CROSS_NOEXCEPT
+	{
+		if (new_size < this->buffer_size)
+		{
+			for (size_t i = new_size; i < this->buffer_size; i++)
+				this->ptr[i].~T();
+		}
+		else if (new_size > this->buffer_size)
+		{
+			reserve(new_size);
+			for (size_t i = this->buffer_size; i < new_size; i++)
+				new (&this->ptr[i]) T();
+		}
+
+		this->buffer_size = new_size;
+	}
+
+private:
+	size_t buffer_capacity = 0;
+	AlignedBuffer<T, N> stack_storage;
+};
+
+// A vector without stack storage.
+// Could also be a typedef-ed to std::vector,
+// but might as well use the one we have.
+template <typename T>
+using Vector = SmallVector<T, 0>;
+
+#else // SPIRV_CROSS_FORCE_STL_TYPES
+
+template <typename T, size_t N = 8>
+using SmallVector = std::vector<T>;
+template <typename T>
+using Vector = std::vector<T>;
+template <typename T>
+using VectorView = std::vector<T>;
+
+#endif // SPIRV_CROSS_FORCE_STL_TYPES
+
+// An object pool which we use for allocating IVariant-derived objects.
+// We know we are going to allocate a bunch of objects of each type,
+// so amortize the mallocs.
+class ObjectPoolBase
+{
+public:
+	virtual ~ObjectPoolBase() = default;
+	virtual void free_opaque(void *ptr) = 0;
+};
+
+template <typename T>
+class ObjectPool : public ObjectPoolBase
+{
+public:
+	explicit ObjectPool(unsigned start_object_count_ = 16)
+	    : start_object_count(start_object_count_)
+	{
+	}
+
+	template <typename... P>
+	T *allocate(P &&... p)
+	{
+		if (vacants.empty())
+		{
+			unsigned num_objects = start_object_count << memory.size();
+			T *ptr = static_cast<T *>(malloc(num_objects * sizeof(T)));
+			if (!ptr)
+				return nullptr;
+
+			for (unsigned i = 0; i < num_objects; i++)
+				vacants.push_back(&ptr[i]);
+
+			memory.emplace_back(ptr);
+		}
+
+		T *ptr = vacants.back();
+		vacants.pop_back();
+		new (ptr) T(std::forward<P>(p)...);
+		return ptr;
+	}
+
+	void free(T *ptr)
+	{
+		ptr->~T();
+		vacants.push_back(ptr);
+	}
+
+	void free_opaque(void *ptr) override
+	{
+		free(static_cast<T *>(ptr));
+	}
+
+	void clear()
+	{
+		vacants.clear();
+		memory.clear();
+	}
+
+protected:
+	Vector<T *> vacants;
+
+	struct MallocDeleter
+	{
+		void operator()(T *ptr)
+		{
+			::free(ptr);
+		}
+	};
+
+	SmallVector<std::unique_ptr<T, MallocDeleter>> memory;
+	unsigned start_object_count;
+};
+
+template <size_t StackSize = 4096, size_t BlockSize = 4096>
+class StringStream
+{
+public:
+	StringStream()
+	{
+		reset();
+	}
+
+	~StringStream()
+	{
+		reset();
+	}
+
+	// Disable copies and moves. Makes it easier to implement, and we don't need it.
+	StringStream(const StringStream &) = delete;
+	void operator=(const StringStream &) = delete;
+
+	template <typename T, typename std::enable_if<!std::is_floating_point<T>::value, int>::type = 0>
+	StringStream &operator<<(const T &t)
+	{
+		auto s = std::to_string(t);
+		append(s.data(), s.size());
+		return *this;
+	}
+
+	// Only overload this to make float/double conversions ambiguous.
+	StringStream &operator<<(uint32_t v)
+	{
+		auto s = std::to_string(v);
+		append(s.data(), s.size());
+		return *this;
+	}
+
+	StringStream &operator<<(char c)
+	{
+		append(&c, 1);
+		return *this;
+	}
+
+	StringStream &operator<<(const std::string &s)
+	{
+		append(s.data(), s.size());
+		return *this;
+	}
+
+	StringStream &operator<<(const char *s)
+	{
+		append(s, strlen(s));
+		return *this;
+	}
+
+	template <size_t N>
+	StringStream &operator<<(const char (&s)[N])
+	{
+		append(s, strlen(s));
+		return *this;
+	}
+
+	std::string str() const
+	{
+		std::string ret;
+		size_t target_size = 0;
+		for (auto &saved : saved_buffers)
+			target_size += saved.offset;
+		target_size += current_buffer.offset;
+		ret.reserve(target_size);
+
+		for (auto &saved : saved_buffers)
+			ret.insert(ret.end(), saved.buffer, saved.buffer + saved.offset);
+		ret.insert(ret.end(), current_buffer.buffer, current_buffer.buffer + current_buffer.offset);
+		return ret;
+	}
+
+	void reset()
+	{
+		for (auto &saved : saved_buffers)
+			if (saved.buffer != stack_buffer)
+				free(saved.buffer);
+		if (current_buffer.buffer != stack_buffer)
+			free(current_buffer.buffer);
+
+		saved_buffers.clear();
+		current_buffer.buffer = stack_buffer;
+		current_buffer.offset = 0;
+		current_buffer.size = sizeof(stack_buffer);
+	}
+
+private:
+	struct Buffer
+	{
+		char *buffer = nullptr;
+		size_t offset = 0;
+		size_t size = 0;
+	};
+	Buffer current_buffer;
+	char stack_buffer[StackSize];
+	SmallVector<Buffer> saved_buffers;
+
+	void append(const char *s, size_t len)
+	{
+		size_t avail = current_buffer.size - current_buffer.offset;
+		if (avail < len)
+		{
+			if (avail > 0)
+			{
+				memcpy(current_buffer.buffer + current_buffer.offset, s, avail);
+				s += avail;
+				len -= avail;
+				current_buffer.offset += avail;
+			}
+
+			saved_buffers.push_back(current_buffer);
+			size_t target_size = len > BlockSize ? len : BlockSize;
+			current_buffer.buffer = static_cast<char *>(malloc(target_size));
+			if (!current_buffer.buffer)
+				SPIRV_CROSS_THROW("Out of memory.");
+
+			memcpy(current_buffer.buffer, s, len);
+			current_buffer.offset = len;
+			current_buffer.size = target_size;
+		}
+		else
+		{
+			memcpy(current_buffer.buffer + current_buffer.offset, s, len);
+			current_buffer.offset += len;
+		}
+	}
+};
+
+} // namespace SPIRV_CROSS_NAMESPACE
+
+#endif
diff --git a/engine/inc/spirv_cross/spirv_cross_error_handling.hpp b/engine/inc/spirv_cross/spirv_cross_error_handling.hpp
new file mode 100644
index 00000000..fa90610b
--- /dev/null
+++ b/engine/inc/spirv_cross/spirv_cross_error_handling.hpp
@@ -0,0 +1,87 @@
+/*
+ * Copyright 2015-2020 Arm Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SPIRV_CROSS_ERROR_HANDLING
+#define SPIRV_CROSS_ERROR_HANDLING
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string>
+#ifndef SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS
+#include <stdexcept>
+#endif
+
+#ifdef SPIRV_CROSS_NAMESPACE_OVERRIDE
+#define SPIRV_CROSS_NAMESPACE SPIRV_CROSS_NAMESPACE_OVERRIDE
+#else
+#define SPIRV_CROSS_NAMESPACE spirv_cross
+#endif
+
+namespace SPIRV_CROSS_NAMESPACE
+{
+#ifdef SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS
+#if !defined(_MSC_VER) || defined(__clang__)
+[[noreturn]]
+#elif defined(_MSC_VER)
+__declspec(noreturn)
+#endif
+inline void
+report_and_abort(const std::string &msg)
+{
+#ifdef NDEBUG
+	(void)msg;
+#else
+	fprintf(stderr, "There was a compiler error: %s\n", msg.c_str());
+#endif
+	fflush(stderr);
+	abort();
+}
+
+#define SPIRV_CROSS_THROW(x) report_and_abort(x)
+#else
+class CompilerError : public std::runtime_error
+{
+public:
+	explicit CompilerError(const std::string &str)
+	    : std::runtime_error(str)
+	{
+	}
+};
+
+#define SPIRV_CROSS_THROW(x) throw CompilerError(x)
+#endif
+
+// MSVC 2013 does not have noexcept. We need this for Variant to get move constructor to work correctly
+// instead of copy constructor.
+// MSVC 2013 ignores that move constructors cannot throw in std::vector, so just don't define it.
+#if defined(_MSC_VER) && _MSC_VER < 1900
+#define SPIRV_CROSS_NOEXCEPT
+#else
+#define SPIRV_CROSS_NOEXCEPT noexcept
+#endif
+
+#if __cplusplus >= 201402l
+#define SPIRV_CROSS_DEPRECATED(reason) [[deprecated(reason)]]
+#elif defined(__GNUC__)
+#define SPIRV_CROSS_DEPRECATED(reason) __attribute__((deprecated))
+#elif defined(_MSC_VER)
+#define SPIRV_CROSS_DEPRECATED(reason) __declspec(deprecated(reason))
+#else
+#define SPIRV_CROSS_DEPRECATED(reason)
+#endif
+} // namespace SPIRV_CROSS_NAMESPACE
+
+#endif
diff --git a/engine/inc/spirv_cross/spirv_cross_parsed_ir.hpp b/engine/inc/spirv_cross/spirv_cross_parsed_ir.hpp
new file mode 100644
index 00000000..4880c841
--- /dev/null
+++ b/engine/inc/spirv_cross/spirv_cross_parsed_ir.hpp
@@ -0,0 +1,231 @@
+/*
+ * Copyright 2018-2020 Arm Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SPIRV_CROSS_PARSED_IR_HPP
+#define SPIRV_CROSS_PARSED_IR_HPP
+
+#include "spirv_common.hpp"
+#include <stdint.h>
+#include <unordered_map>
+
+namespace SPIRV_CROSS_NAMESPACE
+{
+
+// This data structure holds all information needed to perform cross-compilation and reflection.
+// It is the output of the Parser, but any implementation could create this structure.
+// It is intentionally very "open" and struct-like with some helper functions to deal with decorations.
+// Parser is the reference implementation of how this data structure should be filled in.
+
+class ParsedIR
+{
+private:
+	// This must be destroyed after the "ids" vector.
+	std::unique_ptr<ObjectPoolGroup> pool_group;
+
+public:
+	ParsedIR();
+
+	// Due to custom allocations from object pools, we cannot use a default copy constructor.
+	ParsedIR(const ParsedIR &other);
+	ParsedIR &operator=(const ParsedIR &other);
+
+	// Moves are unproblematic, but we need to implement it anyways, since MSVC 2013 does not understand
+	// how to default-implement these.
+	ParsedIR(ParsedIR &&other) SPIRV_CROSS_NOEXCEPT;
+	ParsedIR &operator=(ParsedIR &&other) SPIRV_CROSS_NOEXCEPT;
+
+	// Resizes ids, meta and block_meta.
+	void set_id_bounds(uint32_t bounds);
+
+	// The raw SPIR-V, instructions and opcodes refer to this by offset + count.
+	std::vector<uint32_t> spirv;
+
+	// Holds various data structures which inherit from IVariant.
+	SmallVector<Variant> ids;
+
+	// Various meta data for IDs, decorations, names, etc.
+	std::unordered_map<ID, Meta> meta;
+
+	// Holds all IDs which have a certain type.
+	// This is needed so we can iterate through a specific kind of resource quickly,
+	// and in-order of module declaration.
+	SmallVector<ID> ids_for_type[TypeCount];
+
+	// Special purpose lists which contain a union of types.
+	// This is needed so we can declare specialization constants and structs in an interleaved fashion,
+	// among other things.
+	// Constants can be of struct type, and struct array sizes can use specialization constants.
+	SmallVector<ID> ids_for_constant_or_type;
+	SmallVector<ID> ids_for_constant_or_variable;
+
+	// Declared capabilities and extensions in the SPIR-V module.
+	// Not really used except for reflection at the moment.
+	SmallVector<spv::Capability> declared_capabilities;
+	SmallVector<std::string> declared_extensions;
+
+	// Meta data about blocks. The cross-compiler needs to query if a block is either of these types.
+	// It is a bitset as there can be more than one tag per block.
+	enum BlockMetaFlagBits
+	{
+		BLOCK_META_LOOP_HEADER_BIT = 1 << 0,
+		BLOCK_META_CONTINUE_BIT = 1 << 1,
+		BLOCK_META_LOOP_MERGE_BIT = 1 << 2,
+		BLOCK_META_SELECTION_MERGE_BIT = 1 << 3,
+		BLOCK_META_MULTISELECT_MERGE_BIT = 1 << 4
+	};
+	using BlockMetaFlags = uint8_t;
+	SmallVector<BlockMetaFlags> block_meta;
+	std::unordered_map<BlockID, BlockID> continue_block_to_loop_header;
+
+	// Normally, we'd stick SPIREntryPoint in ids array, but it conflicts with SPIRFunction.
+	// Entry points can therefore be seen as some sort of meta structure.
+	std::unordered_map<FunctionID, SPIREntryPoint> entry_points;
+	FunctionID default_entry_point = 0;
+
+	struct Source
+	{
+		uint32_t version = 0;
+		bool es = false;
+		bool known = false;
+		bool hlsl = false;
+
+		Source() = default;
+	};
+
+	Source source;
+
+	spv::AddressingModel addressing_model = spv::AddressingModelMax;
+	spv::MemoryModel memory_model = spv::MemoryModelMax;
+
+	// Decoration handling methods.
+	// Can be useful for simple "raw" reflection.
+	// However, most members are here because the Parser needs most of these,
+	// and might as well just have the whole suite of decoration/name handling in one place.
+	void set_name(ID id, const std::string &name);
+	const std::string &get_name(ID id) const;
+	void set_decoration(ID id, spv::Decoration decoration, uint32_t argument = 0);
+	void set_decoration_string(ID id, spv::Decoration decoration, const std::string &argument);
+	bool has_decoration(ID id, spv::Decoration decoration) const;
+	uint32_t get_decoration(ID id, spv::Decoration decoration) const;
+	const std::string &get_decoration_string(ID id, spv::Decoration decoration) const;
+	const Bitset &get_decoration_bitset(ID id) const;
+	void unset_decoration(ID id, spv::Decoration decoration);
+
+	// Decoration handling methods (for members of a struct).
+	void set_member_name(TypeID id, uint32_t index, const std::string &name);
+	const std::string &get_member_name(TypeID id, uint32_t index) const;
+	void set_member_decoration(TypeID id, uint32_t index, spv::Decoration decoration, uint32_t argument = 0);
+	void set_member_decoration_string(TypeID id, uint32_t index, spv::Decoration decoration,
+	                                  const std::string &argument);
+	uint32_t get_member_decoration(TypeID id, uint32_t index, spv::Decoration decoration) const;
+	const std::string &get_member_decoration_string(TypeID id, uint32_t index, spv::Decoration decoration) const;
+	bool has_member_decoration(TypeID id, uint32_t index, spv::Decoration decoration) const;
+	const Bitset &get_member_decoration_bitset(TypeID id, uint32_t index) const;
+	void unset_member_decoration(TypeID id, uint32_t index, spv::Decoration decoration);
+
+	void mark_used_as_array_length(ID id);
+	uint32_t increase_bound_by(uint32_t count);
+	Bitset get_buffer_block_flags(const SPIRVariable &var) const;
+
+	void add_typed_id(Types type, ID id);
+	void remove_typed_id(Types type, ID id);
+
+	class LoopLock
+	{
+	public:
+		explicit LoopLock(uint32_t *counter);
+		LoopLock(const LoopLock &) = delete;
+		void operator=(const LoopLock &) = delete;
+		LoopLock(LoopLock &&other) SPIRV_CROSS_NOEXCEPT;
+		LoopLock &operator=(LoopLock &&other) SPIRV_CROSS_NOEXCEPT;
+		~LoopLock();
+
+	private:
+		uint32_t *lock;
+	};
+
+	// This must be held while iterating over a type ID array.
+	// It is undefined if someone calls set<>() while we're iterating over a data structure, so we must
+	// make sure that this case is avoided.
+
+	// If we have a hard lock, it is an error to call set<>(), and an exception is thrown.
+	// If we have a soft lock, we silently ignore any additions to the typed arrays.
+	// This should only be used for physical ID remapping where we need to create an ID, but we will never
+	// care about iterating over them.
+	LoopLock create_loop_hard_lock() const;
+	LoopLock create_loop_soft_lock() const;
+
+	template <typename T, typename Op>
+	void for_each_typed_id(const Op &op)
+	{
+		auto loop_lock = create_loop_hard_lock();
+		for (auto &id : ids_for_type[T::type])
+		{
+			if (ids[id].get_type() == static_cast<Types>(T::type))
+				op(id, get<T>(id));
+		}
+	}
+
+	template <typename T, typename Op>
+	void for_each_typed_id(const Op &op) const
+	{
+		auto loop_lock = create_loop_hard_lock();
+		for (auto &id : ids_for_type[T::type])
+		{
+			if (ids[id].get_type() == static_cast<Types>(T::type))
+				op(id, get<T>(id));
+		}
+	}
+
+	template <typename T>
+	void reset_all_of_type()
+	{
+		reset_all_of_type(static_cast<Types>(T::type));
+	}
+
+	void reset_all_of_type(Types type);
+
+	Meta *find_meta(ID id);
+	const Meta *find_meta(ID id) const;
+
+	const std::string &get_empty_string() const
+	{
+		return empty_string;
+	}
+
+	void make_constant_null(uint32_t id, uint32_t type, bool add_to_typed_id_set);
+
+private:
+	template <typename T>
+	T &get(uint32_t id)
+	{
+		return variant_get<T>(ids[id]);
+	}
+
+	template <typename T>
+	const T &get(uint32_t id) const
+	{
+		return variant_get<T>(ids[id]);
+	}
+
+	mutable uint32_t loop_iteration_depth_hard = 0;
+	mutable uint32_t loop_iteration_depth_soft = 0;
+	std::string empty_string;
+	Bitset cleared_bitset;
+};
+} // namespace SPIRV_CROSS_NAMESPACE
+
+#endif
diff --git a/engine/inc/spirv_cross/spirv_cross_util.hpp b/engine/inc/spirv_cross/spirv_cross_util.hpp
new file mode 100644
index 00000000..708b7cb5
--- /dev/null
+++ b/engine/inc/spirv_cross/spirv_cross_util.hpp
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2015-2020 Arm Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SPIRV_CROSS_UTIL_HPP
+#define SPIRV_CROSS_UTIL_HPP
+
+#include "spirv_cross.hpp"
+
+namespace spirv_cross_util
+{
+void rename_interface_variable(SPIRV_CROSS_NAMESPACE::Compiler &compiler,
+                               const SPIRV_CROSS_NAMESPACE::SmallVector<SPIRV_CROSS_NAMESPACE::Resource> &resources,
+                               uint32_t location, const std::string &name);
+void inherit_combined_sampler_bindings(SPIRV_CROSS_NAMESPACE::Compiler &compiler);
+} // namespace spirv_cross_util
+
+#endif
diff --git a/engine/inc/spirv_cross/spirv_glsl.hpp b/engine/inc/spirv_cross/spirv_glsl.hpp
new file mode 100644
index 00000000..c3837434
--- /dev/null
+++ b/engine/inc/spirv_cross/spirv_glsl.hpp
@@ -0,0 +1,806 @@
+/*
+ * Copyright 2015-2020 Arm Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SPIRV_CROSS_GLSL_HPP
+#define SPIRV_CROSS_GLSL_HPP
+
+#include "GLSL.std.450.h"
+#include "spirv_cross.hpp"
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+
+namespace SPIRV_CROSS_NAMESPACE
+{
+enum PlsFormat
+{
+	PlsNone = 0,
+
+	PlsR11FG11FB10F,
+	PlsR32F,
+	PlsRG16F,
+	PlsRGB10A2,
+	PlsRGBA8,
+	PlsRG16,
+
+	PlsRGBA8I,
+	PlsRG16I,
+
+	PlsRGB10A2UI,
+	PlsRGBA8UI,
+	PlsRG16UI,
+	PlsR32UI
+};
+
+struct PlsRemap
+{
+	uint32_t id;
+	PlsFormat format;
+};
+
+enum AccessChainFlagBits
+{
+	ACCESS_CHAIN_INDEX_IS_LITERAL_BIT = 1 << 0,
+	ACCESS_CHAIN_CHAIN_ONLY_BIT = 1 << 1,
+	ACCESS_CHAIN_PTR_CHAIN_BIT = 1 << 2,
+	ACCESS_CHAIN_SKIP_REGISTER_EXPRESSION_READ_BIT = 1 << 3,
+	ACCESS_CHAIN_LITERAL_MSB_FORCE_ID = 1 << 4,
+	ACCESS_CHAIN_FLATTEN_ALL_MEMBERS_BIT = 1 << 5
+};
+typedef uint32_t AccessChainFlags;
+
+class CompilerGLSL : public Compiler
+{
+public:
+	struct Options
+	{
+		// The shading language version. Corresponds to #version $VALUE.
+		uint32_t version = 450;
+
+		// Emit the OpenGL ES shading language instead of desktop OpenGL.
+		bool es = false;
+
+		// Debug option to always emit temporary variables for all expressions.
+		bool force_temporary = false;
+
+		// If true, Vulkan GLSL features are used instead of GL-compatible features.
+		// Mostly useful for debugging SPIR-V files.
+		bool vulkan_semantics = false;
+
+		// If true, gl_PerVertex is explicitly redeclared in vertex, geometry and tessellation shaders.
+		// The members of gl_PerVertex is determined by which built-ins are declared by the shader.
+		// This option is ignored in ES versions, as redeclaration in ES is not required, and it depends on a different extension
+		// (EXT_shader_io_blocks) which makes things a bit more fuzzy.
+		bool separate_shader_objects = false;
+
+		// Flattens multidimensional arrays, e.g. float foo[a][b][c] into single-dimensional arrays,
+		// e.g. float foo[a * b * c].
+		// This function does not change the actual SPIRType of any object.
+		// Only the generated code, including declarations of interface variables are changed to be single array dimension.
+		bool flatten_multidimensional_arrays = false;
+
+		// For older desktop GLSL targets than version 420, the
+		// GL_ARB_shading_language_420pack extensions is used to be able to support
+		// layout(binding) on UBOs and samplers.
+		// If disabled on older targets, binding decorations will be stripped.
+		bool enable_420pack_extension = true;
+
+		// In non-Vulkan GLSL, emit push constant blocks as UBOs rather than plain uniforms.
+		bool emit_push_constant_as_uniform_buffer = false;
+
+		// Always emit uniform blocks as plain uniforms, regardless of the GLSL version, even when UBOs are supported.
+		// Does not apply to shader storage or push constant blocks.
+		bool emit_uniform_buffer_as_plain_uniforms = false;
+
+		// Emit OpLine directives if present in the module.
+		// May not correspond exactly to original source, but should be a good approximation.
+		bool emit_line_directives = false;
+
+		// In cases where readonly/writeonly decoration are not used at all,
+		// we try to deduce which qualifier(s) we should actually used, since actually emitting
+		// read-write decoration is very rare, and older glslang/HLSL compilers tend to just emit readwrite as a matter of fact.
+		// The default (true) is to enable automatic deduction for these cases, but if you trust the decorations set
+		// by the SPIR-V, it's recommended to set this to false.
+		bool enable_storage_image_qualifier_deduction = true;
+
+		// On some targets (WebGPU), uninitialized variables are banned.
+		// If this is enabled, all variables (temporaries, Private, Function)
+		// which would otherwise be uninitialized will now be initialized to 0 instead.
+		bool force_zero_initialized_variables = false;
+
+		// In GLSL, force use of I/O block flattening, similar to
+		// what happens on legacy GLSL targets for blocks and structs.
+		bool force_flattened_io_blocks = false;
+
+		enum Precision
+		{
+			DontCare,
+			Lowp,
+			Mediump,
+			Highp
+		};
+
+		struct VertexOptions
+		{
+			// GLSL: In vertex shaders, rewrite [0, w] depth (Vulkan/D3D style) to [-w, w] depth (GL style).
+			// MSL: In vertex shaders, rewrite [-w, w] depth (GL style) to [0, w] depth.
+			// HLSL: In vertex shaders, rewrite [-w, w] depth (GL style) to [0, w] depth.
+			bool fixup_clipspace = false;
+
+			// Inverts gl_Position.y or equivalent.
+			bool flip_vert_y = false;
+
+			// GLSL only, for HLSL version of this option, see CompilerHLSL.
+			// If true, the backend will assume that InstanceIndex will need to apply
+			// a base instance offset. Set to false if you know you will never use base instance
+			// functionality as it might remove some internal uniforms.
+			bool support_nonzero_base_instance = true;
+		} vertex;
+
+		struct FragmentOptions
+		{
+			// Add precision mediump float in ES targets when emitting GLES source.
+			// Add precision highp int in ES targets when emitting GLES source.
+			Precision default_float_precision = Mediump;
+			Precision default_int_precision = Highp;
+		} fragment;
+	};
+
+	void remap_pixel_local_storage(std::vector<PlsRemap> inputs, std::vector<PlsRemap> outputs)
+	{
+		pls_inputs = std::move(inputs);
+		pls_outputs = std::move(outputs);
+		remap_pls_variables();
+	}
+
+	// Redirect a subpassInput reading from input_attachment_index to instead load its value from
+	// the color attachment at location = color_location. Requires ESSL.
+	void remap_ext_framebuffer_fetch(uint32_t input_attachment_index, uint32_t color_location);
+
+	explicit CompilerGLSL(std::vector<uint32_t> spirv_)
+	    : Compiler(std::move(spirv_))
+	{
+		init();
+	}
+
+	CompilerGLSL(const uint32_t *ir_, size_t word_count)
+	    : Compiler(ir_, word_count)
+	{
+		init();
+	}
+
+	explicit CompilerGLSL(const ParsedIR &ir_)
+	    : Compiler(ir_)
+	{
+		init();
+	}
+
+	explicit CompilerGLSL(ParsedIR &&ir_)
+	    : Compiler(std::move(ir_))
+	{
+		init();
+	}
+
+	const Options &get_common_options() const
+	{
+		return options;
+	}
+
+	void set_common_options(const Options &opts)
+	{
+		options = opts;
+	}
+
+	std::string compile() override;
+
+	// Returns the current string held in the conversion buffer. Useful for
+	// capturing what has been converted so far when compile() throws an error.
+	std::string get_partial_source();
+
+	// Adds a line to be added right after #version in GLSL backend.
+	// This is useful for enabling custom extensions which are outside the scope of SPIRV-Cross.
+	// This can be combined with variable remapping.
+	// A new-line will be added.
+	//
+	// While add_header_line() is a more generic way of adding arbitrary text to the header
+	// of a GLSL file, require_extension() should be used when adding extensions since it will
+	// avoid creating collisions with SPIRV-Cross generated extensions.
+	//
+	// Code added via add_header_line() is typically backend-specific.
+	void add_header_line(const std::string &str);
+
+	// Adds an extension which is required to run this shader, e.g.
+	// require_extension("GL_KHR_my_extension");
+	void require_extension(const std::string &ext);
+
+	// Legacy GLSL compatibility method.
+	// Takes a uniform or push constant variable and flattens it into a (i|u)vec4 array[N]; array instead.
+	// For this to work, all types in the block must be the same basic type, e.g. mixing vec2 and vec4 is fine, but
+	// mixing int and float is not.
+	// The name of the uniform array will be the same as the interface block name.
+	void flatten_buffer_block(VariableID id);
+
+	// After compilation, query if a variable ID was used as a depth resource.
+	// This is meaningful for MSL since descriptor types depend on this knowledge.
+	// Cases which return true:
+	// - Images which are declared with depth = 1 image type.
+	// - Samplers which are statically used at least once with Dref opcodes.
+	// - Images which are statically used at least once with Dref opcodes.
+	bool variable_is_depth_or_compare(VariableID id) const;
+
+protected:
+	void reset();
+	void emit_function(SPIRFunction &func, const Bitset &return_flags);
+
+	bool has_extension(const std::string &ext) const;
+	void require_extension_internal(const std::string &ext);
+
+	// Virtualize methods which need to be overridden by subclass targets like C++ and such.
+	virtual void emit_function_prototype(SPIRFunction &func, const Bitset &return_flags);
+
+	SPIRBlock *current_emitting_block = nullptr;
+	SPIRBlock *current_emitting_switch = nullptr;
+	bool current_emitting_switch_fallthrough = false;
+
+	virtual void emit_instruction(const Instruction &instr);
+	void emit_block_instructions(SPIRBlock &block);
+	virtual void emit_glsl_op(uint32_t result_type, uint32_t result_id, uint32_t op, const uint32_t *args,
+	                          uint32_t count);
+	virtual void emit_spv_amd_shader_ballot_op(uint32_t result_type, uint32_t result_id, uint32_t op,
+	                                           const uint32_t *args, uint32_t count);
+	virtual void emit_spv_amd_shader_explicit_vertex_parameter_op(uint32_t result_type, uint32_t result_id, uint32_t op,
+	                                                              const uint32_t *args, uint32_t count);
+	virtual void emit_spv_amd_shader_trinary_minmax_op(uint32_t result_type, uint32_t result_id, uint32_t op,
+	                                                   const uint32_t *args, uint32_t count);
+	virtual void emit_spv_amd_gcn_shader_op(uint32_t result_type, uint32_t result_id, uint32_t op, const uint32_t *args,
+	                                        uint32_t count);
+	virtual void emit_header();
+	void emit_line_directive(uint32_t file_id, uint32_t line_literal);
+	void build_workgroup_size(SmallVector<std::string> &arguments, const SpecializationConstant &x,
+	                          const SpecializationConstant &y, const SpecializationConstant &z);
+
+	virtual void emit_sampled_image_op(uint32_t result_type, uint32_t result_id, uint32_t image_id, uint32_t samp_id);
+	virtual void emit_texture_op(const Instruction &i, bool sparse);
+	virtual std::string to_texture_op(const Instruction &i, bool sparse, bool *forward,
+	                                  SmallVector<uint32_t> &inherited_expressions);
+	virtual void emit_subgroup_op(const Instruction &i);
+	virtual std::string type_to_glsl(const SPIRType &type, uint32_t id = 0);
+	virtual std::string builtin_to_glsl(spv::BuiltIn builtin, spv::StorageClass storage);
+	virtual void emit_struct_member(const SPIRType &type, uint32_t member_type_id, uint32_t index,
+	                                const std::string &qualifier = "", uint32_t base_offset = 0);
+	virtual void emit_struct_padding_target(const SPIRType &type);
+	virtual std::string image_type_glsl(const SPIRType &type, uint32_t id = 0);
+	std::string constant_expression(const SPIRConstant &c);
+	std::string constant_op_expression(const SPIRConstantOp &cop);
+	virtual std::string constant_expression_vector(const SPIRConstant &c, uint32_t vector);
+	virtual void emit_fixup();
+	virtual std::string variable_decl(const SPIRType &type, const std::string &name, uint32_t id = 0);
+	virtual std::string to_func_call_arg(const SPIRFunction::Parameter &arg, uint32_t id);
+
+	struct TextureFunctionBaseArguments
+	{
+		// GCC 4.8 workarounds, it doesn't understand '{}' constructor here, use explicit default constructor.
+		TextureFunctionBaseArguments() = default;
+		VariableID img = 0;
+		const SPIRType *imgtype = nullptr;
+		bool is_fetch = false, is_gather = false, is_proj = false;
+	};
+
+	struct TextureFunctionNameArguments
+	{
+		// GCC 4.8 workarounds, it doesn't understand '{}' constructor here, use explicit default constructor.
+		TextureFunctionNameArguments() = default;
+		TextureFunctionBaseArguments base;
+		bool has_array_offsets = false, has_offset = false, has_grad = false;
+		bool has_dref = false, is_sparse_feedback = false, has_min_lod = false;
+		uint32_t lod = 0;
+	};
+	virtual std::string to_function_name(const TextureFunctionNameArguments &args);
+
+	struct TextureFunctionArguments
+	{
+		// GCC 4.8 workarounds, it doesn't understand '{}' constructor here, use explicit default constructor.
+		TextureFunctionArguments() = default;
+		TextureFunctionBaseArguments base;
+		uint32_t coord = 0, coord_components = 0, dref = 0;
+		uint32_t grad_x = 0, grad_y = 0, lod = 0, coffset = 0, offset = 0;
+		uint32_t bias = 0, component = 0, sample = 0, sparse_texel = 0, min_lod = 0;
+	};
+	virtual std::string to_function_args(const TextureFunctionArguments &args, bool *p_forward);
+
+	void emit_sparse_feedback_temporaries(uint32_t result_type_id, uint32_t id, uint32_t &feedback_id,
+	                                      uint32_t &texel_id);
+	uint32_t get_sparse_feedback_texel_id(uint32_t id) const;
+	virtual void emit_buffer_block(const SPIRVariable &type);
+	virtual void emit_push_constant_block(const SPIRVariable &var);
+	virtual void emit_uniform(const SPIRVariable &var);
+	virtual std::string unpack_expression_type(std::string expr_str, const SPIRType &type, uint32_t physical_type_id,
+	                                           bool packed_type, bool row_major);
+
+	virtual bool builtin_translates_to_nonarray(spv::BuiltIn builtin) const;
+
+	void emit_copy_logical_type(uint32_t lhs_id, uint32_t lhs_type_id, uint32_t rhs_id, uint32_t rhs_type_id,
+	                            SmallVector<uint32_t> chain);
+
+	StringStream<> buffer;
+
+	template <typename T>
+	inline void statement_inner(T &&t)
+	{
+		buffer << std::forward<T>(t);
+		statement_count++;
+	}
+
+	template <typename T, typename... Ts>
+	inline void statement_inner(T &&t, Ts &&... ts)
+	{
+		buffer << std::forward<T>(t);
+		statement_count++;
+		statement_inner(std::forward<Ts>(ts)...);
+	}
+
+	template <typename... Ts>
+	inline void statement(Ts &&... ts)
+	{
+		if (is_forcing_recompilation())
+		{
+			// Do not bother emitting code while force_recompile is active.
+			// We will compile again.
+			statement_count++;
+			return;
+		}
+
+		if (redirect_statement)
+		{
+			redirect_statement->push_back(join(std::forward<Ts>(ts)...));
+			statement_count++;
+		}
+		else
+		{
+			for (uint32_t i = 0; i < indent; i++)
+				buffer << "    ";
+			statement_inner(std::forward<Ts>(ts)...);
+			buffer << '\n';
+		}
+	}
+
+	template <typename... Ts>
+	inline void statement_no_indent(Ts &&... ts)
+	{
+		auto old_indent = indent;
+		indent = 0;
+		statement(std::forward<Ts>(ts)...);
+		indent = old_indent;
+	}
+
+	// Used for implementing continue blocks where
+	// we want to obtain a list of statements we can merge
+	// on a single line separated by comma.
+	SmallVector<std::string> *redirect_statement = nullptr;
+	const SPIRBlock *current_continue_block = nullptr;
+
+	void begin_scope();
+	void end_scope();
+	void end_scope(const std::string &trailer);
+	void end_scope_decl();
+	void end_scope_decl(const std::string &decl);
+
+	Options options;
+
+	virtual std::string type_to_array_glsl(
+	    const SPIRType &type); // Allow Metal to use the array<T> template to make arrays a value type
+	std::string to_array_size(const SPIRType &type, uint32_t index);
+	uint32_t to_array_size_literal(const SPIRType &type, uint32_t index) const;
+	uint32_t to_array_size_literal(const SPIRType &type) const;
+	virtual std::string variable_decl(const SPIRVariable &variable); // Threadgroup arrays can't have a wrapper type
+	std::string variable_decl_function_local(SPIRVariable &variable);
+
+	void add_local_variable_name(uint32_t id);
+	void add_resource_name(uint32_t id);
+	void add_member_name(SPIRType &type, uint32_t name);
+	void add_function_overload(const SPIRFunction &func);
+
+	virtual bool is_non_native_row_major_matrix(uint32_t id);
+	virtual bool member_is_non_native_row_major_matrix(const SPIRType &type, uint32_t index);
+	bool member_is_remapped_physical_type(const SPIRType &type, uint32_t index) const;
+	bool member_is_packed_physical_type(const SPIRType &type, uint32_t index) const;
+	virtual std::string convert_row_major_matrix(std::string exp_str, const SPIRType &exp_type,
+	                                             uint32_t physical_type_id, bool is_packed);
+
+	std::unordered_set<std::string> local_variable_names;
+	std::unordered_set<std::string> resource_names;
+	std::unordered_set<std::string> block_input_names;
+	std::unordered_set<std::string> block_output_names;
+	std::unordered_set<std::string> block_ubo_names;
+	std::unordered_set<std::string> block_ssbo_names;
+	std::unordered_set<std::string> block_names; // A union of all block_*_names.
+	std::unordered_map<std::string, std::unordered_set<uint64_t>> function_overloads;
+	std::unordered_map<uint32_t, std::string> preserved_aliases;
+	void preserve_alias_on_reset(uint32_t id);
+	void reset_name_caches();
+
+	bool processing_entry_point = false;
+
+	// Can be overriden by subclass backends for trivial things which
+	// shouldn't need polymorphism.
+	struct BackendVariations
+	{
+		std::string discard_literal = "discard";
+		std::string demote_literal = "demote";
+		std::string null_pointer_literal = "";
+		bool float_literal_suffix = false;
+		bool double_literal_suffix = true;
+		bool uint32_t_literal_suffix = true;
+		bool long_long_literal_suffix = false;
+		const char *basic_int_type = "int";
+		const char *basic_uint_type = "uint";
+		const char *basic_int8_type = "int8_t";
+		const char *basic_uint8_type = "uint8_t";
+		const char *basic_int16_type = "int16_t";
+		const char *basic_uint16_type = "uint16_t";
+		const char *int16_t_literal_suffix = "s";
+		const char *uint16_t_literal_suffix = "us";
+		const char *nonuniform_qualifier = "nonuniformEXT";
+		const char *boolean_mix_function = "mix";
+		bool swizzle_is_function = false;
+		bool shared_is_implied = false;
+		bool unsized_array_supported = true;
+		bool explicit_struct_type = false;
+		bool use_initializer_list = false;
+		bool use_typed_initializer_list = false;
+		bool can_declare_struct_inline = true;
+		bool can_declare_arrays_inline = true;
+		bool native_row_major_matrix = true;
+		bool use_constructor_splatting = true;
+		bool allow_precision_qualifiers = false;
+		bool can_swizzle_scalar = false;
+		bool force_gl_in_out_block = false;
+		bool can_return_array = true;
+		bool allow_truncated_access_chain = false;
+		bool supports_extensions = false;
+		bool supports_empty_struct = false;
+		bool array_is_value_type = true;
+		bool buffer_offset_array_is_value_type = true;
+		bool comparison_image_samples_scalar = false;
+		bool native_pointers = false;
+		bool support_small_type_sampling_result = false;
+		bool support_case_fallthrough = true;
+		bool use_array_constructor = false;
+	} backend;
+
+	void emit_struct(SPIRType &type);
+	void emit_resources();
+	void emit_buffer_block_native(const SPIRVariable &var);
+	void emit_buffer_reference_block(SPIRType &type, bool forward_declaration);
+	void emit_buffer_block_legacy(const SPIRVariable &var);
+	void emit_buffer_block_flattened(const SPIRVariable &type);
+	void emit_declared_builtin_block(spv::StorageClass storage, spv::ExecutionModel model);
+	bool should_force_emit_builtin_block(spv::StorageClass storage);
+	void emit_push_constant_block_vulkan(const SPIRVariable &var);
+	void emit_push_constant_block_glsl(const SPIRVariable &var);
+	void emit_interface_block(const SPIRVariable &type);
+	void emit_flattened_io_block(const SPIRVariable &var, const char *qual);
+	void emit_flattened_io_block_struct(const std::string &basename, const SPIRType &type, const char *qual,
+	                                    const SmallVector<uint32_t> &indices);
+	void emit_flattened_io_block_member(const std::string &basename, const SPIRType &type, const char *qual,
+	                                    const SmallVector<uint32_t> &indices);
+	void emit_block_chain(SPIRBlock &block);
+	void emit_hoisted_temporaries(SmallVector<std::pair<TypeID, ID>> &temporaries);
+	std::string constant_value_macro_name(uint32_t id);
+	void emit_constant(const SPIRConstant &constant);
+	void emit_specialization_constant_op(const SPIRConstantOp &constant);
+	std::string emit_continue_block(uint32_t continue_block, bool follow_true_block, bool follow_false_block);
+	bool attempt_emit_loop_header(SPIRBlock &block, SPIRBlock::Method method);
+
+	void branch(BlockID from, BlockID to);
+	void branch_to_continue(BlockID from, BlockID to);
+	void branch(BlockID from, uint32_t cond, BlockID true_block, BlockID false_block);
+	void flush_phi(BlockID from, BlockID to);
+	void flush_variable_declaration(uint32_t id);
+	void flush_undeclared_variables(SPIRBlock &block);
+	void emit_variable_temporary_copies(const SPIRVariable &var);
+
+	bool should_dereference(uint32_t id);
+	bool should_forward(uint32_t id) const;
+	bool should_suppress_usage_tracking(uint32_t id) const;
+	void emit_mix_op(uint32_t result_type, uint32_t id, uint32_t left, uint32_t right, uint32_t lerp);
+	void emit_nminmax_op(uint32_t result_type, uint32_t id, uint32_t op0, uint32_t op1, GLSLstd450 op);
+	bool to_trivial_mix_op(const SPIRType &type, std::string &op, uint32_t left, uint32_t right, uint32_t lerp);
+	void emit_quaternary_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, uint32_t op2,
+	                             uint32_t op3, const char *op);
+	void emit_trinary_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, uint32_t op2,
+	                          const char *op);
+	void emit_binary_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op);
+
+	void emit_unary_func_op_cast(uint32_t result_type, uint32_t result_id, uint32_t op0, const char *op,
+	                             SPIRType::BaseType input_type, SPIRType::BaseType expected_result_type);
+	void emit_binary_func_op_cast(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op,
+	                              SPIRType::BaseType input_type, bool skip_cast_if_equal_type);
+	void emit_binary_func_op_cast_clustered(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1,
+	                                        const char *op, SPIRType::BaseType input_type);
+	void emit_trinary_func_op_cast(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, uint32_t op2,
+	                               const char *op, SPIRType::BaseType input_type);
+	void emit_trinary_func_op_bitextract(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1,
+	                                     uint32_t op2, const char *op, SPIRType::BaseType expected_result_type,
+	                                     SPIRType::BaseType input_type0, SPIRType::BaseType input_type1,
+	                                     SPIRType::BaseType input_type2);
+	void emit_bitfield_insert_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, uint32_t op2,
+	                             uint32_t op3, const char *op, SPIRType::BaseType offset_count_type);
+
+	void emit_unary_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, const char *op);
+	void emit_unrolled_unary_op(uint32_t result_type, uint32_t result_id, uint32_t operand, const char *op);
+	void emit_binary_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op);
+	void emit_unrolled_binary_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op,
+	                             bool negate, SPIRType::BaseType expected_type);
+	void emit_binary_op_cast(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op,
+	                         SPIRType::BaseType input_type, bool skip_cast_if_equal_type);
+
+	SPIRType binary_op_bitcast_helper(std::string &cast_op0, std::string &cast_op1, SPIRType::BaseType &input_type,
+	                                  uint32_t op0, uint32_t op1, bool skip_cast_if_equal_type);
+
+	virtual bool emit_complex_bitcast(uint32_t result_type, uint32_t id, uint32_t op0);
+
+	std::string to_ternary_expression(const SPIRType &result_type, uint32_t select, uint32_t true_value,
+	                                  uint32_t false_value);
+
+	void emit_unary_op(uint32_t result_type, uint32_t result_id, uint32_t op0, const char *op);
+	bool expression_is_forwarded(uint32_t id) const;
+	bool expression_suppresses_usage_tracking(uint32_t id) const;
+	bool expression_read_implies_multiple_reads(uint32_t id) const;
+	SPIRExpression &emit_op(uint32_t result_type, uint32_t result_id, const std::string &rhs, bool forward_rhs,
+	                        bool suppress_usage_tracking = false);
+
+	void access_chain_internal_append_index(std::string &expr, uint32_t base, const SPIRType *type,
+	                                        AccessChainFlags flags, bool &access_chain_is_arrayed, uint32_t index);
+
+	std::string access_chain_internal(uint32_t base, const uint32_t *indices, uint32_t count, AccessChainFlags flags,
+	                                  AccessChainMeta *meta);
+
+	virtual void prepare_access_chain_for_scalar_access(std::string &expr, const SPIRType &type,
+	                                                    spv::StorageClass storage, bool &is_packed);
+
+	std::string access_chain(uint32_t base, const uint32_t *indices, uint32_t count, const SPIRType &target_type,
+	                         AccessChainMeta *meta = nullptr, bool ptr_chain = false);
+
+	std::string flattened_access_chain(uint32_t base, const uint32_t *indices, uint32_t count,
+	                                   const SPIRType &target_type, uint32_t offset, uint32_t matrix_stride,
+	                                   uint32_t array_stride, bool need_transpose);
+	std::string flattened_access_chain_struct(uint32_t base, const uint32_t *indices, uint32_t count,
+	                                          const SPIRType &target_type, uint32_t offset);
+	std::string flattened_access_chain_matrix(uint32_t base, const uint32_t *indices, uint32_t count,
+	                                          const SPIRType &target_type, uint32_t offset, uint32_t matrix_stride,
+	                                          bool need_transpose);
+	std::string flattened_access_chain_vector(uint32_t base, const uint32_t *indices, uint32_t count,
+	                                          const SPIRType &target_type, uint32_t offset, uint32_t matrix_stride,
+	                                          bool need_transpose);
+	std::pair<std::string, uint32_t> flattened_access_chain_offset(const SPIRType &basetype, const uint32_t *indices,
+	                                                               uint32_t count, uint32_t offset,
+	                                                               uint32_t word_stride, bool *need_transpose = nullptr,
+	                                                               uint32_t *matrix_stride = nullptr,
+	                                                               uint32_t *array_stride = nullptr,
+	                                                               bool ptr_chain = false);
+
+	const char *index_to_swizzle(uint32_t index);
+	std::string remap_swizzle(const SPIRType &result_type, uint32_t input_components, const std::string &expr);
+	std::string declare_temporary(uint32_t type, uint32_t id);
+	void emit_uninitialized_temporary(uint32_t type, uint32_t id);
+	SPIRExpression &emit_uninitialized_temporary_expression(uint32_t type, uint32_t id);
+	void append_global_func_args(const SPIRFunction &func, uint32_t index, SmallVector<std::string> &arglist);
+	std::string to_expression(uint32_t id, bool register_expression_read = true);
+	std::string to_composite_constructor_expression(uint32_t id, bool uses_buffer_offset);
+	std::string to_rerolled_array_expression(const std::string &expr, const SPIRType &type);
+	std::string to_enclosed_expression(uint32_t id, bool register_expression_read = true);
+	std::string to_unpacked_expression(uint32_t id, bool register_expression_read = true);
+	std::string to_unpacked_row_major_matrix_expression(uint32_t id);
+	std::string to_enclosed_unpacked_expression(uint32_t id, bool register_expression_read = true);
+	std::string to_dereferenced_expression(uint32_t id, bool register_expression_read = true);
+	std::string to_pointer_expression(uint32_t id, bool register_expression_read = true);
+	std::string to_enclosed_pointer_expression(uint32_t id, bool register_expression_read = true);
+	std::string to_extract_component_expression(uint32_t id, uint32_t index);
+	std::string enclose_expression(const std::string &expr);
+	std::string dereference_expression(const SPIRType &expression_type, const std::string &expr);
+	std::string address_of_expression(const std::string &expr);
+	void strip_enclosed_expression(std::string &expr);
+	std::string to_member_name(const SPIRType &type, uint32_t index);
+	virtual std::string to_member_reference(uint32_t base, const SPIRType &type, uint32_t index, bool ptr_chain);
+	std::string to_multi_member_reference(const SPIRType &type, const SmallVector<uint32_t> &indices);
+	std::string type_to_glsl_constructor(const SPIRType &type);
+	std::string argument_decl(const SPIRFunction::Parameter &arg);
+	virtual std::string to_qualifiers_glsl(uint32_t id);
+	const char *to_precision_qualifiers_glsl(uint32_t id);
+	virtual const char *to_storage_qualifiers_glsl(const SPIRVariable &var);
+	const char *flags_to_qualifiers_glsl(const SPIRType &type, const Bitset &flags);
+	const char *format_to_glsl(spv::ImageFormat format);
+	virtual std::string layout_for_member(const SPIRType &type, uint32_t index);
+	virtual std::string to_interpolation_qualifiers(const Bitset &flags);
+	std::string layout_for_variable(const SPIRVariable &variable);
+	std::string to_combined_image_sampler(VariableID image_id, VariableID samp_id);
+	virtual bool skip_argument(uint32_t id) const;
+	virtual void emit_array_copy(const std::string &lhs, uint32_t rhs_id, spv::StorageClass lhs_storage,
+	                             spv::StorageClass rhs_storage);
+	virtual void emit_block_hints(const SPIRBlock &block);
+	virtual std::string to_initializer_expression(const SPIRVariable &var);
+	virtual std::string to_zero_initialized_expression(uint32_t type_id);
+	bool type_can_zero_initialize(const SPIRType &type) const;
+
+	bool buffer_is_packing_standard(const SPIRType &type, BufferPackingStandard packing,
+	                                uint32_t *failed_index = nullptr, uint32_t start_offset = 0,
+	                                uint32_t end_offset = ~(0u));
+	std::string buffer_to_packing_standard(const SPIRType &type, bool support_std430_without_scalar_layout);
+
+	uint32_t type_to_packed_base_size(const SPIRType &type, BufferPackingStandard packing);
+	uint32_t type_to_packed_alignment(const SPIRType &type, const Bitset &flags, BufferPackingStandard packing);
+	uint32_t type_to_packed_array_stride(const SPIRType &type, const Bitset &flags, BufferPackingStandard packing);
+	uint32_t type_to_packed_size(const SPIRType &type, const Bitset &flags, BufferPackingStandard packing);
+
+	std::string bitcast_glsl(const SPIRType &result_type, uint32_t arg);
+	virtual std::string bitcast_glsl_op(const SPIRType &result_type, const SPIRType &argument_type);
+
+	std::string bitcast_expression(SPIRType::BaseType target_type, uint32_t arg);
+	std::string bitcast_expression(const SPIRType &target_type, SPIRType::BaseType expr_type, const std::string &expr);
+
+	std::string build_composite_combiner(uint32_t result_type, const uint32_t *elems, uint32_t length);
+	bool remove_duplicate_swizzle(std::string &op);
+	bool remove_unity_swizzle(uint32_t base, std::string &op);
+
+	// Can modify flags to remote readonly/writeonly if image type
+	// and force recompile.
+	bool check_atomic_image(uint32_t id);
+
+	virtual void replace_illegal_names();
+	void replace_illegal_names(const std::unordered_set<std::string> &keywords);
+	virtual void emit_entry_point_declarations();
+
+	void replace_fragment_output(SPIRVariable &var);
+	void replace_fragment_outputs();
+	bool check_explicit_lod_allowed(uint32_t lod);
+	std::string legacy_tex_op(const std::string &op, const SPIRType &imgtype, uint32_t lod, uint32_t id);
+
+	uint32_t indent = 0;
+
+	std::unordered_set<uint32_t> emitted_functions;
+
+	// Ensure that we declare phi-variable copies even if the original declaration isn't deferred
+	std::unordered_set<uint32_t> flushed_phi_variables;
+
+	std::unordered_set<uint32_t> flattened_buffer_blocks;
+	std::unordered_map<uint32_t, bool> flattened_structs;
+
+	std::string load_flattened_struct(const std::string &basename, const SPIRType &type);
+	std::string to_flattened_struct_member(const std::string &basename, const SPIRType &type, uint32_t index);
+	void store_flattened_struct(uint32_t lhs_id, uint32_t value);
+	void store_flattened_struct(const std::string &basename, uint32_t rhs, const SPIRType &type,
+	                            const SmallVector<uint32_t> &indices);
+	std::string to_flattened_access_chain_expression(uint32_t id);
+
+	// Usage tracking. If a temporary is used more than once, use the temporary instead to
+	// avoid AST explosion when SPIRV is generated with pure SSA and doesn't write stuff to variables.
+	std::unordered_map<uint32_t, uint32_t> expression_usage_counts;
+	void track_expression_read(uint32_t id);
+
+	SmallVector<std::string> forced_extensions;
+	SmallVector<std::string> header_lines;
+
+	// Used when expressions emit extra opcodes with their own unique IDs,
+	// and we need to reuse the IDs across recompilation loops.
+	// Currently used by NMin/Max/Clamp implementations.
+	std::unordered_map<uint32_t, uint32_t> extra_sub_expressions;
+
+	uint32_t statement_count = 0;
+
+	inline bool is_legacy() const
+	{
+		return (options.es && options.version < 300) || (!options.es && options.version < 130);
+	}
+
+	inline bool is_legacy_es() const
+	{
+		return options.es && options.version < 300;
+	}
+
+	inline bool is_legacy_desktop() const
+	{
+		return !options.es && options.version < 130;
+	}
+
+	bool args_will_forward(uint32_t id, const uint32_t *args, uint32_t num_args, bool pure);
+	void register_call_out_argument(uint32_t id);
+	void register_impure_function_call();
+	void register_control_dependent_expression(uint32_t expr);
+
+	// GL_EXT_shader_pixel_local_storage support.
+	std::vector<PlsRemap> pls_inputs;
+	std::vector<PlsRemap> pls_outputs;
+	std::string pls_decl(const PlsRemap &variable);
+	const char *to_pls_qualifiers_glsl(const SPIRVariable &variable);
+	void emit_pls();
+	void remap_pls_variables();
+
+	// GL_EXT_shader_framebuffer_fetch support.
+	std::vector<std::pair<uint32_t, uint32_t>> subpass_to_framebuffer_fetch_attachment;
+	std::unordered_set<uint32_t> inout_color_attachments;
+	bool subpass_input_is_framebuffer_fetch(uint32_t id) const;
+	void emit_inout_fragment_outputs_copy_to_subpass_inputs();
+	const SPIRVariable *find_subpass_input_by_attachment_index(uint32_t index) const;
+	const SPIRVariable *find_color_output_by_location(uint32_t location) const;
+
+	// A variant which takes two sets of name. The secondary is only used to verify there are no collisions,
+	// but the set is not updated when we have found a new name.
+	// Used primarily when adding block interface names.
+	void add_variable(std::unordered_set<std::string> &variables_primary,
+	                  const std::unordered_set<std::string> &variables_secondary, std::string &name);
+
+	void check_function_call_constraints(const uint32_t *args, uint32_t length);
+	void handle_invalid_expression(uint32_t id);
+	void find_static_extensions();
+
+	std::string emit_for_loop_initializers(const SPIRBlock &block);
+	void emit_while_loop_initializers(const SPIRBlock &block);
+	bool for_loop_initializers_are_same_type(const SPIRBlock &block);
+	bool optimize_read_modify_write(const SPIRType &type, const std::string &lhs, const std::string &rhs);
+	void fixup_image_load_store_access();
+
+	bool type_is_empty(const SPIRType &type);
+
+	virtual void declare_undefined_values();
+
+	static std::string sanitize_underscores(const std::string &str);
+
+	bool can_use_io_location(spv::StorageClass storage, bool block);
+	const Instruction *get_next_instruction_in_block(const Instruction &instr);
+	static uint32_t mask_relevant_memory_semantics(uint32_t semantics);
+
+	std::string convert_half_to_string(const SPIRConstant &value, uint32_t col, uint32_t row);
+	std::string convert_float_to_string(const SPIRConstant &value, uint32_t col, uint32_t row);
+	std::string convert_double_to_string(const SPIRConstant &value, uint32_t col, uint32_t row);
+
+	std::string convert_separate_image_to_expression(uint32_t id);
+
+	// Builtins in GLSL are always specific signedness, but the SPIR-V can declare them
+	// as either unsigned or signed.
+	// Sometimes we will need to automatically perform bitcasts on load and store to make this work.
+	virtual void bitcast_to_builtin_store(uint32_t target_id, std::string &expr, const SPIRType &expr_type);
+	virtual void bitcast_from_builtin_load(uint32_t source_id, std::string &expr, const SPIRType &expr_type);
+	void unroll_array_from_complex_load(uint32_t target_id, uint32_t source_id, std::string &expr);
+	void convert_non_uniform_expression(const SPIRType &type, std::string &expr);
+
+	void handle_store_to_invariant_variable(uint32_t store_id, uint32_t value_id);
+	void disallow_forwarding_in_expression_chain(const SPIRExpression &expr);
+
+	bool expression_is_constant_null(uint32_t id) const;
+	bool expression_is_non_value_type_array(uint32_t ptr);
+	virtual void emit_store_statement(uint32_t lhs_expression, uint32_t rhs_expression);
+
+	uint32_t get_integer_width_for_instruction(const Instruction &instr) const;
+	uint32_t get_integer_width_for_glsl_instruction(GLSLstd450 op, const uint32_t *arguments, uint32_t length) const;
+
+	bool variable_is_lut(const SPIRVariable &var) const;
+
+	char current_locale_radix_character = '.';
+
+	void fixup_type_alias();
+	void reorder_type_alias();
+
+	void propagate_nonuniform_qualifier(uint32_t id);
+
+	static const char *vector_swizzle(int vecsize, int index);
+
+private:
+	void init();
+};
+} // namespace SPIRV_CROSS_NAMESPACE
+
+#endif
diff --git a/engine/inc/spirv_cross/spirv_hlsl.hpp b/engine/inc/spirv_cross/spirv_hlsl.hpp
new file mode 100644
index 00000000..11f7f263
--- /dev/null
+++ b/engine/inc/spirv_cross/spirv_hlsl.hpp
@@ -0,0 +1,361 @@
+/*
+ * Copyright 2016-2020 Robert Konrad
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SPIRV_HLSL_HPP
+#define SPIRV_HLSL_HPP
+
+#include "spirv_glsl.hpp"
+#include <utility>
+
+namespace SPIRV_CROSS_NAMESPACE
+{
+// Interface which remaps vertex inputs to a fixed semantic name to make linking easier.
+struct HLSLVertexAttributeRemap
+{
+	uint32_t location;
+	std::string semantic;
+};
+// Specifying a root constant (d3d12) or push constant range (vulkan).
+//
+// `start` and `end` denotes the range of the root constant in bytes.
+// Both values need to be multiple of 4.
+struct RootConstants
+{
+	uint32_t start;
+	uint32_t end;
+
+	uint32_t binding;
+	uint32_t space;
+};
+
+// For finer control, decorations may be removed from specific resources instead with unset_decoration().
+enum HLSLBindingFlagBits
+{
+	HLSL_BINDING_AUTO_NONE_BIT = 0,
+
+	// Push constant (root constant) resources will be declared as CBVs (b-space) without a register() declaration.
+	// A register will be automatically assigned by the D3D compiler, but must therefore be reflected in D3D-land.
+	// Push constants do not normally have a DecorationBinding set, but if they do, this can be used to ignore it.
+	HLSL_BINDING_AUTO_PUSH_CONSTANT_BIT = 1 << 0,
+
+	// cbuffer resources will be declared as CBVs (b-space) without a register() declaration.
+	// A register will be automatically assigned, but must be reflected in D3D-land.
+	HLSL_BINDING_AUTO_CBV_BIT = 1 << 1,
+
+	// All SRVs (t-space) will be declared without a register() declaration.
+	HLSL_BINDING_AUTO_SRV_BIT = 1 << 2,
+
+	// All UAVs (u-space) will be declared without a register() declaration.
+	HLSL_BINDING_AUTO_UAV_BIT = 1 << 3,
+
+	// All samplers (s-space) will be declared without a register() declaration.
+	HLSL_BINDING_AUTO_SAMPLER_BIT = 1 << 4,
+
+	// No resources will be declared with register().
+	HLSL_BINDING_AUTO_ALL = 0x7fffffff
+};
+using HLSLBindingFlags = uint32_t;
+
+// By matching stage, desc_set and binding for a SPIR-V resource,
+// register bindings are set based on whether the HLSL resource is a
+// CBV, UAV, SRV or Sampler. A single binding in SPIR-V might contain multiple
+// resource types, e.g. COMBINED_IMAGE_SAMPLER, and SRV/Sampler bindings will be used respectively.
+// On SM 5.0 and lower, register_space is ignored.
+//
+// To remap a push constant block which does not have any desc_set/binding associated with it,
+// use ResourceBindingPushConstant{DescriptorSet,Binding} as values for desc_set/binding.
+// For deeper control of push constants, set_root_constant_layouts() can be used instead.
+struct HLSLResourceBinding
+{
+	spv::ExecutionModel stage = spv::ExecutionModelMax;
+	uint32_t desc_set = 0;
+	uint32_t binding = 0;
+
+	struct Binding
+	{
+		uint32_t register_space = 0;
+		uint32_t register_binding = 0;
+	} cbv, uav, srv, sampler;
+};
+
+class CompilerHLSL : public CompilerGLSL
+{
+public:
+	struct Options
+	{
+		uint32_t shader_model = 30; // TODO: map ps_4_0_level_9_0,... somehow
+
+		// Allows the PointSize builtin, and ignores it, as PointSize is not supported in HLSL.
+		bool point_size_compat = false;
+
+		// Allows the PointCoord builtin, returns float2(0.5, 0.5), as PointCoord is not supported in HLSL.
+		bool point_coord_compat = false;
+
+		// If true, the backend will assume that VertexIndex and InstanceIndex will need to apply
+		// a base offset, and you will need to fill in a cbuffer with offsets.
+		// Set to false if you know you will never use base instance or base vertex
+		// functionality as it might remove an internal cbuffer.
+		bool support_nonzero_base_vertex_base_instance = false;
+
+		// Forces a storage buffer to always be declared as UAV, even if the readonly decoration is used.
+		// By default, a readonly storage buffer will be declared as ByteAddressBuffer (SRV) instead.
+		// Alternatively, use set_hlsl_force_storage_buffer_as_uav to specify individually.
+		bool force_storage_buffer_as_uav = false;
+
+		// Forces any storage image type marked as NonWritable to be considered an SRV instead.
+		// For this to work with function call parameters, NonWritable must be considered to be part of the type system
+		// so that NonWritable image arguments are also translated to Texture rather than RWTexture.
+		bool nonwritable_uav_texture_as_srv = false;
+
+		// Enables native 16-bit types. Needs SM 6.2.
+		// Uses half/int16_t/uint16_t instead of min16* types.
+		// Also adds support for 16-bit load-store from (RW)ByteAddressBuffer.
+		bool enable_16bit_types = false;
+	};
+
+	explicit CompilerHLSL(std::vector<uint32_t> spirv_)
+	    : CompilerGLSL(std::move(spirv_))
+	{
+	}
+
+	CompilerHLSL(const uint32_t *ir_, size_t size)
+	    : CompilerGLSL(ir_, size)
+	{
+	}
+
+	explicit CompilerHLSL(const ParsedIR &ir_)
+	    : CompilerGLSL(ir_)
+	{
+	}
+
+	explicit CompilerHLSL(ParsedIR &&ir_)
+	    : CompilerGLSL(std::move(ir_))
+	{
+	}
+
+	const Options &get_hlsl_options() const
+	{
+		return hlsl_options;
+	}
+
+	void set_hlsl_options(const Options &opts)
+	{
+		hlsl_options = opts;
+	}
+
+	// Optionally specify a custom root constant layout.
+	//
+	// Push constants ranges will be split up according to the
+	// layout specified.
+	void set_root_constant_layouts(std::vector<RootConstants> layout);
+
+	// Compiles and remaps vertex attributes at specific locations to a fixed semantic.
+	// The default is TEXCOORD# where # denotes location.
+	// Matrices are unrolled to vectors with notation ${SEMANTIC}_#, where # denotes row.
+	// $SEMANTIC is either TEXCOORD# or a semantic name specified here.
+	void add_vertex_attribute_remap(const HLSLVertexAttributeRemap &vertex_attributes);
+	std::string compile() override;
+
+	// This is a special HLSL workaround for the NumWorkGroups builtin.
+	// This does not exist in HLSL, so the calling application must create a dummy cbuffer in
+	// which the application will store this builtin.
+	// The cbuffer layout will be:
+	// cbuffer SPIRV_Cross_NumWorkgroups : register(b#, space#) { uint3 SPIRV_Cross_NumWorkgroups_count; };
+	// This must be called before compile().
+	// The function returns 0 if NumWorkGroups builtin is not statically used in the shader from the current entry point.
+	// If non-zero, this returns the variable ID of a cbuffer which corresponds to
+	// the cbuffer declared above. By default, no binding or descriptor set decoration is set,
+	// so the calling application should declare explicit bindings on this ID before calling compile().
+	VariableID remap_num_workgroups_builtin();
+
+	// Controls how resource bindings are declared in the output HLSL.
+	void set_resource_binding_flags(HLSLBindingFlags flags);
+
+	// resource is a resource binding to indicate the HLSL CBV, SRV, UAV or sampler binding
+	// to use for a particular SPIR-V description set
+	// and binding. If resource bindings are provided,
+	// is_hlsl_resource_binding_used() will return true after calling ::compile() if
+	// the set/binding combination was used by the HLSL code.
+	void add_hlsl_resource_binding(const HLSLResourceBinding &resource);
+	bool is_hlsl_resource_binding_used(spv::ExecutionModel model, uint32_t set, uint32_t binding) const;
+
+	// Controls which storage buffer bindings will be forced to be declared as UAVs.
+	void set_hlsl_force_storage_buffer_as_uav(uint32_t desc_set, uint32_t binding);
+
+private:
+	std::string type_to_glsl(const SPIRType &type, uint32_t id = 0) override;
+	std::string image_type_hlsl(const SPIRType &type, uint32_t id);
+	std::string image_type_hlsl_modern(const SPIRType &type, uint32_t id);
+	std::string image_type_hlsl_legacy(const SPIRType &type, uint32_t id);
+	void emit_function_prototype(SPIRFunction &func, const Bitset &return_flags) override;
+	void emit_hlsl_entry_point();
+	void emit_header() override;
+	void emit_resources();
+	void declare_undefined_values() override;
+	void emit_interface_block_globally(const SPIRVariable &type);
+	void emit_interface_block_in_struct(const SPIRVariable &type, std::unordered_set<uint32_t> &active_locations);
+	void emit_builtin_inputs_in_struct();
+	void emit_builtin_outputs_in_struct();
+	void emit_texture_op(const Instruction &i, bool sparse) override;
+	void emit_instruction(const Instruction &instruction) override;
+	void emit_glsl_op(uint32_t result_type, uint32_t result_id, uint32_t op, const uint32_t *args,
+	                  uint32_t count) override;
+	void emit_buffer_block(const SPIRVariable &type) override;
+	void emit_push_constant_block(const SPIRVariable &var) override;
+	void emit_uniform(const SPIRVariable &var) override;
+	void emit_modern_uniform(const SPIRVariable &var);
+	void emit_legacy_uniform(const SPIRVariable &var);
+	void emit_specialization_constants_and_structs();
+	void emit_composite_constants();
+	void emit_fixup() override;
+	std::string builtin_to_glsl(spv::BuiltIn builtin, spv::StorageClass storage) override;
+	std::string layout_for_member(const SPIRType &type, uint32_t index) override;
+	std::string to_interpolation_qualifiers(const Bitset &flags) override;
+	std::string bitcast_glsl_op(const SPIRType &result_type, const SPIRType &argument_type) override;
+	bool emit_complex_bitcast(uint32_t result_type, uint32_t id, uint32_t op0) override;
+	std::string to_func_call_arg(const SPIRFunction::Parameter &arg, uint32_t id) override;
+	std::string to_sampler_expression(uint32_t id);
+	std::string to_resource_binding(const SPIRVariable &var);
+	std::string to_resource_binding_sampler(const SPIRVariable &var);
+	std::string to_resource_register(HLSLBindingFlagBits flag, char space, uint32_t binding, uint32_t set);
+	void emit_sampled_image_op(uint32_t result_type, uint32_t result_id, uint32_t image_id, uint32_t samp_id) override;
+	void emit_access_chain(const Instruction &instruction);
+	void emit_load(const Instruction &instruction);
+	void read_access_chain(std::string *expr, const std::string &lhs, const SPIRAccessChain &chain);
+	void read_access_chain_struct(const std::string &lhs, const SPIRAccessChain &chain);
+	void read_access_chain_array(const std::string &lhs, const SPIRAccessChain &chain);
+	void write_access_chain(const SPIRAccessChain &chain, uint32_t value, const SmallVector<uint32_t> &composite_chain);
+	void write_access_chain_struct(const SPIRAccessChain &chain, uint32_t value,
+	                               const SmallVector<uint32_t> &composite_chain);
+	void write_access_chain_array(const SPIRAccessChain &chain, uint32_t value,
+	                              const SmallVector<uint32_t> &composite_chain);
+	std::string write_access_chain_value(uint32_t value, const SmallVector<uint32_t> &composite_chain, bool enclose);
+	void emit_store(const Instruction &instruction);
+	void emit_atomic(const uint32_t *ops, uint32_t length, spv::Op op);
+	void emit_subgroup_op(const Instruction &i) override;
+	void emit_block_hints(const SPIRBlock &block) override;
+
+	void emit_struct_member(const SPIRType &type, uint32_t member_type_id, uint32_t index, const std::string &qualifier,
+	                        uint32_t base_offset = 0) override;
+
+	const char *to_storage_qualifiers_glsl(const SPIRVariable &var) override;
+	void replace_illegal_names() override;
+
+	bool is_hlsl_force_storage_buffer_as_uav(ID id) const;
+
+	Options hlsl_options;
+
+	// TODO: Refactor this to be more similar to MSL, maybe have some common system in place?
+	bool requires_op_fmod = false;
+	bool requires_fp16_packing = false;
+	bool requires_uint2_packing = false;
+	bool requires_explicit_fp16_packing = false;
+	bool requires_unorm8_packing = false;
+	bool requires_snorm8_packing = false;
+	bool requires_unorm16_packing = false;
+	bool requires_snorm16_packing = false;
+	bool requires_bitfield_insert = false;
+	bool requires_bitfield_extract = false;
+	bool requires_inverse_2x2 = false;
+	bool requires_inverse_3x3 = false;
+	bool requires_inverse_4x4 = false;
+	bool requires_scalar_reflect = false;
+	bool requires_scalar_refract = false;
+	bool requires_scalar_faceforward = false;
+
+	struct TextureSizeVariants
+	{
+		// MSVC 2013 workaround.
+		TextureSizeVariants()
+		{
+			srv = 0;
+			for (auto &unorm : uav)
+				for (auto &u : unorm)
+					u = 0;
+		}
+		uint64_t srv;
+		uint64_t uav[3][4];
+	} required_texture_size_variants;
+
+	void require_texture_query_variant(uint32_t var_id);
+	void emit_texture_size_variants(uint64_t variant_mask, const char *vecsize_qualifier, bool uav,
+	                                const char *type_qualifier);
+
+	enum TextureQueryVariantDim
+	{
+		Query1D = 0,
+		Query1DArray,
+		Query2D,
+		Query2DArray,
+		Query3D,
+		QueryBuffer,
+		QueryCube,
+		QueryCubeArray,
+		Query2DMS,
+		Query2DMSArray,
+		QueryDimCount
+	};
+
+	enum TextureQueryVariantType
+	{
+		QueryTypeFloat = 0,
+		QueryTypeInt = 16,
+		QueryTypeUInt = 32,
+		QueryTypeCount = 3
+	};
+
+	enum BitcastType
+	{
+		TypeNormal,
+		TypePackUint2x32,
+		TypeUnpackUint64
+	};
+
+	BitcastType get_bitcast_type(uint32_t result_type, uint32_t op0);
+
+	void emit_builtin_variables();
+	bool require_output = false;
+	bool require_input = false;
+	SmallVector<HLSLVertexAttributeRemap> remap_vertex_attributes;
+
+	uint32_t type_to_consumed_locations(const SPIRType &type) const;
+
+	void emit_io_block(const SPIRVariable &var);
+	std::string to_semantic(uint32_t location, spv::ExecutionModel em, spv::StorageClass sc);
+
+	uint32_t num_workgroups_builtin = 0;
+	HLSLBindingFlags resource_binding_flags = 0;
+
+	// Custom root constant layout, which should be emitted
+	// when translating push constant ranges.
+	std::vector<RootConstants> root_constants_layout;
+
+	void validate_shader_model();
+
+	std::string get_unique_identifier();
+	uint32_t unique_identifier_count = 0;
+
+	std::unordered_map<StageSetBinding, std::pair<HLSLResourceBinding, bool>, InternalHasher> resource_bindings;
+	void remap_hlsl_resource_binding(HLSLBindingFlagBits type, uint32_t &desc_set, uint32_t &binding);
+
+	std::unordered_set<SetBindingPair, InternalHasher> force_uav_buffer_bindings;
+
+	// Returns true for BuiltInSampleMask because gl_SampleMask[] is an array in SPIR-V, but SV_Coverage is a scalar in HLSL.
+	bool builtin_translates_to_nonarray(spv::BuiltIn builtin) const override;
+};
+} // namespace SPIRV_CROSS_NAMESPACE
+
+#endif
diff --git a/engine/inc/spirv_cross/spirv_msl.hpp b/engine/inc/spirv_cross/spirv_msl.hpp
new file mode 100644
index 00000000..2d4b0be7
--- /dev/null
+++ b/engine/inc/spirv_cross/spirv_msl.hpp
@@ -0,0 +1,1014 @@
+/*
+ * Copyright 2016-2020 The Brenwill Workshop Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SPIRV_CROSS_MSL_HPP
+#define SPIRV_CROSS_MSL_HPP
+
+#include "spirv_glsl.hpp"
+#include <map>
+#include <set>
+#include <stddef.h>
+#include <unordered_map>
+#include <unordered_set>
+
+namespace SPIRV_CROSS_NAMESPACE
+{
+
+// Indicates the format of a shader input. Currently limited to specifying
+// if the input is an 8-bit unsigned integer, 16-bit unsigned integer, or
+// some other format.
+enum MSLShaderInputFormat
+{
+	MSL_SHADER_INPUT_FORMAT_OTHER = 0,
+	MSL_SHADER_INPUT_FORMAT_UINT8 = 1,
+	MSL_SHADER_INPUT_FORMAT_UINT16 = 2,
+	MSL_SHADER_INPUT_FORMAT_ANY16 = 3,
+	MSL_SHADER_INPUT_FORMAT_ANY32 = 4,
+
+	// Deprecated aliases.
+	MSL_VERTEX_FORMAT_OTHER = MSL_SHADER_INPUT_FORMAT_OTHER,
+	MSL_VERTEX_FORMAT_UINT8 = MSL_SHADER_INPUT_FORMAT_UINT8,
+	MSL_VERTEX_FORMAT_UINT16 = MSL_SHADER_INPUT_FORMAT_UINT16,
+
+	MSL_SHADER_INPUT_FORMAT_INT_MAX = 0x7fffffff
+};
+
+// Defines MSL characteristics of an input variable at a particular location.
+// After compilation, it is possible to query whether or not this location was used.
+// If vecsize is nonzero, it must be greater than or equal to the vecsize declared in the shader,
+// or behavior is undefined.
+struct MSLShaderInput
+{
+	uint32_t location = 0;
+	MSLShaderInputFormat format = MSL_SHADER_INPUT_FORMAT_OTHER;
+	spv::BuiltIn builtin = spv::BuiltInMax;
+	uint32_t vecsize = 0;
+};
+
+// Matches the binding index of a MSL resource for a binding within a descriptor set.
+// Taken together, the stage, desc_set and binding combine to form a reference to a resource
+// descriptor used in a particular shading stage.
+// If using MSL 2.0 argument buffers, the descriptor set is not marked as a discrete descriptor set,
+// and (for iOS only) the resource is not a storage image (sampled != 2), the binding reference we
+// remap to will become an [[id(N)]] attribute within the "descriptor set" argument buffer structure.
+// For resources which are bound in the "classic" MSL 1.0 way or discrete descriptors, the remap will become a
+// [[buffer(N)]], [[texture(N)]] or [[sampler(N)]] depending on the resource types used.
+struct MSLResourceBinding
+{
+	spv::ExecutionModel stage = spv::ExecutionModelMax;
+	uint32_t desc_set = 0;
+	uint32_t binding = 0;
+	uint32_t msl_buffer = 0;
+	uint32_t msl_texture = 0;
+	uint32_t msl_sampler = 0;
+};
+
+enum MSLSamplerCoord
+{
+	MSL_SAMPLER_COORD_NORMALIZED = 0,
+	MSL_SAMPLER_COORD_PIXEL = 1,
+	MSL_SAMPLER_INT_MAX = 0x7fffffff
+};
+
+enum MSLSamplerFilter
+{
+	MSL_SAMPLER_FILTER_NEAREST = 0,
+	MSL_SAMPLER_FILTER_LINEAR = 1,
+	MSL_SAMPLER_FILTER_INT_MAX = 0x7fffffff
+};
+
+enum MSLSamplerMipFilter
+{
+	MSL_SAMPLER_MIP_FILTER_NONE = 0,
+	MSL_SAMPLER_MIP_FILTER_NEAREST = 1,
+	MSL_SAMPLER_MIP_FILTER_LINEAR = 2,
+	MSL_SAMPLER_MIP_FILTER_INT_MAX = 0x7fffffff
+};
+
+enum MSLSamplerAddress
+{
+	MSL_SAMPLER_ADDRESS_CLAMP_TO_ZERO = 0,
+	MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE = 1,
+	MSL_SAMPLER_ADDRESS_CLAMP_TO_BORDER = 2,
+	MSL_SAMPLER_ADDRESS_REPEAT = 3,
+	MSL_SAMPLER_ADDRESS_MIRRORED_REPEAT = 4,
+	MSL_SAMPLER_ADDRESS_INT_MAX = 0x7fffffff
+};
+
+enum MSLSamplerCompareFunc
+{
+	MSL_SAMPLER_COMPARE_FUNC_NEVER = 0,
+	MSL_SAMPLER_COMPARE_FUNC_LESS = 1,
+	MSL_SAMPLER_COMPARE_FUNC_LESS_EQUAL = 2,
+	MSL_SAMPLER_COMPARE_FUNC_GREATER = 3,
+	MSL_SAMPLER_COMPARE_FUNC_GREATER_EQUAL = 4,
+	MSL_SAMPLER_COMPARE_FUNC_EQUAL = 5,
+	MSL_SAMPLER_COMPARE_FUNC_NOT_EQUAL = 6,
+	MSL_SAMPLER_COMPARE_FUNC_ALWAYS = 7,
+	MSL_SAMPLER_COMPARE_FUNC_INT_MAX = 0x7fffffff
+};
+
+enum MSLSamplerBorderColor
+{
+	MSL_SAMPLER_BORDER_COLOR_TRANSPARENT_BLACK = 0,
+	MSL_SAMPLER_BORDER_COLOR_OPAQUE_BLACK = 1,
+	MSL_SAMPLER_BORDER_COLOR_OPAQUE_WHITE = 2,
+	MSL_SAMPLER_BORDER_COLOR_INT_MAX = 0x7fffffff
+};
+
+enum MSLFormatResolution
+{
+	MSL_FORMAT_RESOLUTION_444 = 0,
+	MSL_FORMAT_RESOLUTION_422,
+	MSL_FORMAT_RESOLUTION_420,
+	MSL_FORMAT_RESOLUTION_INT_MAX = 0x7fffffff
+};
+
+enum MSLChromaLocation
+{
+	MSL_CHROMA_LOCATION_COSITED_EVEN = 0,
+	MSL_CHROMA_LOCATION_MIDPOINT,
+	MSL_CHROMA_LOCATION_INT_MAX = 0x7fffffff
+};
+
+enum MSLComponentSwizzle
+{
+	MSL_COMPONENT_SWIZZLE_IDENTITY = 0,
+	MSL_COMPONENT_SWIZZLE_ZERO,
+	MSL_COMPONENT_SWIZZLE_ONE,
+	MSL_COMPONENT_SWIZZLE_R,
+	MSL_COMPONENT_SWIZZLE_G,
+	MSL_COMPONENT_SWIZZLE_B,
+	MSL_COMPONENT_SWIZZLE_A,
+	MSL_COMPONENT_SWIZZLE_INT_MAX = 0x7fffffff
+};
+
+enum MSLSamplerYCbCrModelConversion
+{
+	MSL_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0,
+	MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY,
+	MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_709,
+	MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_601,
+	MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_2020,
+	MSL_SAMPLER_YCBCR_MODEL_CONVERSION_INT_MAX = 0x7fffffff
+};
+
+enum MSLSamplerYCbCrRange
+{
+	MSL_SAMPLER_YCBCR_RANGE_ITU_FULL = 0,
+	MSL_SAMPLER_YCBCR_RANGE_ITU_NARROW,
+	MSL_SAMPLER_YCBCR_RANGE_INT_MAX = 0x7fffffff
+};
+
+struct MSLConstexprSampler
+{
+	MSLSamplerCoord coord = MSL_SAMPLER_COORD_NORMALIZED;
+	MSLSamplerFilter min_filter = MSL_SAMPLER_FILTER_NEAREST;
+	MSLSamplerFilter mag_filter = MSL_SAMPLER_FILTER_NEAREST;
+	MSLSamplerMipFilter mip_filter = MSL_SAMPLER_MIP_FILTER_NONE;
+	MSLSamplerAddress s_address = MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE;
+	MSLSamplerAddress t_address = MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE;
+	MSLSamplerAddress r_address = MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE;
+	MSLSamplerCompareFunc compare_func = MSL_SAMPLER_COMPARE_FUNC_NEVER;
+	MSLSamplerBorderColor border_color = MSL_SAMPLER_BORDER_COLOR_TRANSPARENT_BLACK;
+	float lod_clamp_min = 0.0f;
+	float lod_clamp_max = 1000.0f;
+	int max_anisotropy = 1;
+
+	// Sampler Y'CbCr conversion parameters
+	uint32_t planes = 0;
+	MSLFormatResolution resolution = MSL_FORMAT_RESOLUTION_444;
+	MSLSamplerFilter chroma_filter = MSL_SAMPLER_FILTER_NEAREST;
+	MSLChromaLocation x_chroma_offset = MSL_CHROMA_LOCATION_COSITED_EVEN;
+	MSLChromaLocation y_chroma_offset = MSL_CHROMA_LOCATION_COSITED_EVEN;
+	MSLComponentSwizzle swizzle[4]; // IDENTITY, IDENTITY, IDENTITY, IDENTITY
+	MSLSamplerYCbCrModelConversion ycbcr_model = MSL_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY;
+	MSLSamplerYCbCrRange ycbcr_range = MSL_SAMPLER_YCBCR_RANGE_ITU_FULL;
+	uint32_t bpc = 8;
+
+	bool compare_enable = false;
+	bool lod_clamp_enable = false;
+	bool anisotropy_enable = false;
+	bool ycbcr_conversion_enable = false;
+
+	MSLConstexprSampler()
+	{
+		for (uint32_t i = 0; i < 4; i++)
+			swizzle[i] = MSL_COMPONENT_SWIZZLE_IDENTITY;
+	}
+	bool swizzle_is_identity() const
+	{
+		return (swizzle[0] == MSL_COMPONENT_SWIZZLE_IDENTITY && swizzle[1] == MSL_COMPONENT_SWIZZLE_IDENTITY &&
+		        swizzle[2] == MSL_COMPONENT_SWIZZLE_IDENTITY && swizzle[3] == MSL_COMPONENT_SWIZZLE_IDENTITY);
+	}
+	bool swizzle_has_one_or_zero() const
+	{
+		return (swizzle[0] == MSL_COMPONENT_SWIZZLE_ZERO || swizzle[0] == MSL_COMPONENT_SWIZZLE_ONE ||
+		        swizzle[1] == MSL_COMPONENT_SWIZZLE_ZERO || swizzle[1] == MSL_COMPONENT_SWIZZLE_ONE ||
+		        swizzle[2] == MSL_COMPONENT_SWIZZLE_ZERO || swizzle[2] == MSL_COMPONENT_SWIZZLE_ONE ||
+		        swizzle[3] == MSL_COMPONENT_SWIZZLE_ZERO || swizzle[3] == MSL_COMPONENT_SWIZZLE_ONE);
+	}
+};
+
+// Special constant used in a MSLResourceBinding desc_set
+// element to indicate the bindings for the push constants.
+// Kinda deprecated. Just use ResourceBindingPushConstant{DescriptorSet,Binding} directly.
+static const uint32_t kPushConstDescSet = ResourceBindingPushConstantDescriptorSet;
+
+// Special constant used in a MSLResourceBinding binding
+// element to indicate the bindings for the push constants.
+// Kinda deprecated. Just use ResourceBindingPushConstant{DescriptorSet,Binding} directly.
+static const uint32_t kPushConstBinding = ResourceBindingPushConstantBinding;
+
+// Special constant used in a MSLResourceBinding binding
+// element to indicate the buffer binding for swizzle buffers.
+static const uint32_t kSwizzleBufferBinding = ~(1u);
+
+// Special constant used in a MSLResourceBinding binding
+// element to indicate the buffer binding for buffer size buffers to support OpArrayLength.
+static const uint32_t kBufferSizeBufferBinding = ~(2u);
+
+// Special constant used in a MSLResourceBinding binding
+// element to indicate the buffer binding used for the argument buffer itself.
+// This buffer binding should be kept as small as possible as all automatic bindings for buffers
+// will start at max(kArgumentBufferBinding) + 1.
+static const uint32_t kArgumentBufferBinding = ~(3u);
+
+static const uint32_t kMaxArgumentBuffers = 8;
+
+// Decompiles SPIR-V to Metal Shading Language
+class CompilerMSL : public CompilerGLSL
+{
+public:
+	// Options for compiling to Metal Shading Language
+	struct Options
+	{
+		typedef enum
+		{
+			iOS = 0,
+			macOS = 1
+		} Platform;
+
+		Platform platform = macOS;
+		uint32_t msl_version = make_msl_version(1, 2);
+		uint32_t texel_buffer_texture_width = 4096; // Width of 2D Metal textures used as 1D texel buffers
+		uint32_t swizzle_buffer_index = 30;
+		uint32_t indirect_params_buffer_index = 29;
+		uint32_t shader_output_buffer_index = 28;
+		uint32_t shader_patch_output_buffer_index = 27;
+		uint32_t shader_tess_factor_buffer_index = 26;
+		uint32_t buffer_size_buffer_index = 25;
+		uint32_t view_mask_buffer_index = 24;
+		uint32_t dynamic_offsets_buffer_index = 23;
+		uint32_t shader_input_buffer_index = 22;
+		uint32_t shader_index_buffer_index = 21;
+		uint32_t shader_input_wg_index = 0;
+		uint32_t device_index = 0;
+		uint32_t enable_frag_output_mask = 0xffffffff;
+		// Metal doesn't allow setting a fixed sample mask directly in the pipeline.
+		// We can evade this restriction by ANDing the internal sample_mask output
+		// of the shader with the additional fixed sample mask.
+		uint32_t additional_fixed_sample_mask = 0xffffffff;
+		bool enable_point_size_builtin = true;
+		bool enable_frag_depth_builtin = true;
+		bool enable_frag_stencil_ref_builtin = true;
+		bool disable_rasterization = false;
+		bool capture_output_to_buffer = false;
+		bool swizzle_texture_samples = false;
+		bool tess_domain_origin_lower_left = false;
+		bool multiview = false;
+		bool view_index_from_device_index = false;
+		bool dispatch_base = false;
+		bool texture_1D_as_2D = false;
+
+		// Enable use of MSL 2.0 indirect argument buffers.
+		// MSL 2.0 must also be enabled.
+		bool argument_buffers = false;
+
+		// Ensures vertex and instance indices start at zero. This reflects the behavior of HLSL with SV_VertexID and SV_InstanceID.
+		bool enable_base_index_zero = false;
+
+		// Fragment output in MSL must have at least as many components as the render pass.
+		// Add support to explicit pad out components.
+		bool pad_fragment_output_components = false;
+
+		// Specifies whether the iOS target version supports the [[base_vertex]] and [[base_instance]] attributes.
+		bool ios_support_base_vertex_instance = false;
+
+		// Use Metal's native frame-buffer fetch API for subpass inputs.
+		bool ios_use_framebuffer_fetch_subpasses = false;
+
+		// Enables use of "fma" intrinsic for invariant float math
+		bool invariant_float_math = false;
+
+		// Emulate texturecube_array with texture2d_array for iOS where this type is not available
+		bool emulate_cube_array = false;
+
+		// Allow user to enable decoration binding
+		bool enable_decoration_binding = false;
+
+		// Requires MSL 2.1, use the native support for texel buffers.
+		bool texture_buffer_native = false;
+
+		// Forces all resources which are part of an argument buffer to be considered active.
+		// This ensures ABI compatibility between shaders where some resources might be unused,
+		// and would otherwise declare a different IAB.
+		bool force_active_argument_buffer_resources = false;
+
+		// Forces the use of plain arrays, which works around certain driver bugs on certain versions
+		// of Intel Macbooks. See https://github.com/KhronosGroup/SPIRV-Cross/issues/1210.
+		// May reduce performance in scenarios where arrays are copied around as value-types.
+		bool force_native_arrays = false;
+
+		// If a shader writes clip distance, also emit user varyings which
+		// can be read in subsequent stages.
+		bool enable_clip_distance_user_varying = true;
+
+		// In a tessellation control shader, assume that more than one patch can be processed in a
+		// single workgroup. This requires changes to the way the InvocationId and PrimitiveId
+		// builtins are processed, but should result in more efficient usage of the GPU.
+		bool multi_patch_workgroup = false;
+
+		// If set, a vertex shader will be compiled as part of a tessellation pipeline.
+		// It will be translated as a compute kernel, so it can use the global invocation ID
+		// to index the output buffer.
+		bool vertex_for_tessellation = false;
+
+		enum class IndexType
+		{
+			None = 0,
+			UInt16 = 1,
+			UInt32 = 2
+		};
+
+		// The type of index in the index buffer, if present. For a compute shader, Metal
+		// requires specifying the indexing at pipeline creation, rather than at draw time
+		// as with graphics pipelines. This means we must create three different pipelines,
+		// for no indexing, 16-bit indices, and 32-bit indices. Each requires different
+		// handling for the gl_VertexIndex builtin. We may as well, then, create three
+		// different shaders for these three scenarios.
+		IndexType vertex_index_type = IndexType::None;
+
+		bool is_ios() const
+		{
+			return platform == iOS;
+		}
+
+		bool is_macos() const
+		{
+			return platform == macOS;
+		}
+
+		void set_msl_version(uint32_t major, uint32_t minor = 0, uint32_t patch = 0)
+		{
+			msl_version = make_msl_version(major, minor, patch);
+		}
+
+		bool supports_msl_version(uint32_t major, uint32_t minor = 0, uint32_t patch = 0) const
+		{
+			return msl_version >= make_msl_version(major, minor, patch);
+		}
+
+		static uint32_t make_msl_version(uint32_t major, uint32_t minor = 0, uint32_t patch = 0)
+		{
+			return (major * 10000) + (minor * 100) + patch;
+		}
+	};
+
+	const Options &get_msl_options() const
+	{
+		return msl_options;
+	}
+
+	void set_msl_options(const Options &opts)
+	{
+		msl_options = opts;
+	}
+
+	// Provide feedback to calling API to allow runtime to disable pipeline
+	// rasterization if vertex shader requires rasterization to be disabled.
+	bool get_is_rasterization_disabled() const
+	{
+		return is_rasterization_disabled && (get_entry_point().model == spv::ExecutionModelVertex ||
+		                                     get_entry_point().model == spv::ExecutionModelTessellationControl ||
+		                                     get_entry_point().model == spv::ExecutionModelTessellationEvaluation);
+	}
+
+	// Provide feedback to calling API to allow it to pass an auxiliary
+	// swizzle buffer if the shader needs it.
+	bool needs_swizzle_buffer() const
+	{
+		return used_swizzle_buffer;
+	}
+
+	// Provide feedback to calling API to allow it to pass a buffer
+	// containing STORAGE_BUFFER buffer sizes to support OpArrayLength.
+	bool needs_buffer_size_buffer() const
+	{
+		return !buffers_requiring_array_length.empty();
+	}
+
+	// Provide feedback to calling API to allow it to pass a buffer
+	// containing the view mask for the current multiview subpass.
+	bool needs_view_mask_buffer() const
+	{
+		return msl_options.multiview && !msl_options.view_index_from_device_index;
+	}
+
+	// Provide feedback to calling API to allow it to pass a buffer
+	// containing the dispatch base workgroup ID.
+	bool needs_dispatch_base_buffer() const
+	{
+		return msl_options.dispatch_base && !msl_options.supports_msl_version(1, 2);
+	}
+
+	// Provide feedback to calling API to allow it to pass an output
+	// buffer if the shader needs it.
+	bool needs_output_buffer() const
+	{
+		return capture_output_to_buffer && stage_out_var_id != ID(0);
+	}
+
+	// Provide feedback to calling API to allow it to pass a patch output
+	// buffer if the shader needs it.
+	bool needs_patch_output_buffer() const
+	{
+		return capture_output_to_buffer && patch_stage_out_var_id != ID(0);
+	}
+
+	// Provide feedback to calling API to allow it to pass an input threadgroup
+	// buffer if the shader needs it.
+	bool needs_input_threadgroup_mem() const
+	{
+		return capture_output_to_buffer && stage_in_var_id != ID(0);
+	}
+
+	explicit CompilerMSL(std::vector<uint32_t> spirv);
+	CompilerMSL(const uint32_t *ir, size_t word_count);
+	explicit CompilerMSL(const ParsedIR &ir);
+	explicit CompilerMSL(ParsedIR &&ir);
+
+	// input is a shader input description used to fix up shader input variables.
+	// If shader inputs are provided, is_msl_shader_input_used() will return true after
+	// calling ::compile() if the location was used by the MSL code.
+	void add_msl_shader_input(const MSLShaderInput &input);
+
+	// resource is a resource binding to indicate the MSL buffer,
+	// texture or sampler index to use for a particular SPIR-V description set
+	// and binding. If resource bindings are provided,
+	// is_msl_resource_binding_used() will return true after calling ::compile() if
+	// the set/binding combination was used by the MSL code.
+	void add_msl_resource_binding(const MSLResourceBinding &resource);
+
+	// desc_set and binding are the SPIR-V descriptor set and binding of a buffer resource
+	// in this shader. index is the index within the dynamic offset buffer to use. This
+	// function marks that resource as using a dynamic offset (VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC
+	// or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC). This function only has any effect if argument buffers
+	// are enabled. If so, the buffer will have its address adjusted at the beginning of the shader with
+	// an offset taken from the dynamic offset buffer.
+	void add_dynamic_buffer(uint32_t desc_set, uint32_t binding, uint32_t index);
+
+	// desc_set and binding are the SPIR-V descriptor set and binding of a buffer resource
+	// in this shader. This function marks that resource as an inline uniform block
+	// (VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT). This function only has any effect if argument buffers
+	// are enabled. If so, the buffer block will be directly embedded into the argument
+	// buffer, instead of being referenced indirectly via pointer.
+	void add_inline_uniform_block(uint32_t desc_set, uint32_t binding);
+
+	// When using MSL argument buffers, we can force "classic" MSL 1.0 binding schemes for certain descriptor sets.
+	// This corresponds to VK_KHR_push_descriptor in Vulkan.
+	void add_discrete_descriptor_set(uint32_t desc_set);
+
+	// If an argument buffer is large enough, it may need to be in the device storage space rather than
+	// constant. Opt-in to this behavior here on a per set basis.
+	void set_argument_buffer_device_address_space(uint32_t desc_set, bool device_storage);
+
+	// Query after compilation is done. This allows you to check if an input location was used by the shader.
+	bool is_msl_shader_input_used(uint32_t location);
+
+	// NOTE: Only resources which are remapped using add_msl_resource_binding will be reported here.
+	// Constexpr samplers are always assumed to be emitted.
+	// No specific MSLResourceBinding remapping is required for constexpr samplers as long as they are remapped
+	// by remap_constexpr_sampler(_by_binding).
+	bool is_msl_resource_binding_used(spv::ExecutionModel model, uint32_t set, uint32_t binding) const;
+
+	// This must only be called after a successful call to CompilerMSL::compile().
+	// For a variable resource ID obtained through reflection API, report the automatically assigned resource index.
+	// If the descriptor set was part of an argument buffer, report the [[id(N)]],
+	// or [[buffer/texture/sampler]] binding for other resources.
+	// If the resource was a combined image sampler, report the image binding here,
+	// use the _secondary version of this call to query the sampler half of the resource.
+	// If no binding exists, uint32_t(-1) is returned.
+	uint32_t get_automatic_msl_resource_binding(uint32_t id) const;
+
+	// Same as get_automatic_msl_resource_binding, but should only be used for combined image samplers, in which case the
+	// sampler's binding is returned instead. For any other resource type, -1 is returned.
+	uint32_t get_automatic_msl_resource_binding_secondary(uint32_t id) const;
+
+	// Same as get_automatic_msl_resource_binding, but should only be used for combined image samplers for multiplanar images,
+	// in which case the second plane's binding is returned instead. For any other resource type, -1 is returned.
+	uint32_t get_automatic_msl_resource_binding_tertiary(uint32_t id) const;
+
+	// Same as get_automatic_msl_resource_binding, but should only be used for combined image samplers for triplanar images,
+	// in which case the third plane's binding is returned instead. For any other resource type, -1 is returned.
+	uint32_t get_automatic_msl_resource_binding_quaternary(uint32_t id) const;
+
+	// Compiles the SPIR-V code into Metal Shading Language.
+	std::string compile() override;
+
+	// Remap a sampler with ID to a constexpr sampler.
+	// Older iOS targets must use constexpr samplers in certain cases (PCF),
+	// so a static sampler must be used.
+	// The sampler will not consume a binding, but be declared in the entry point as a constexpr sampler.
+	// This can be used on both combined image/samplers (sampler2D) or standalone samplers.
+	// The remapped sampler must not be an array of samplers.
+	// Prefer remap_constexpr_sampler_by_binding unless you're also doing reflection anyways.
+	void remap_constexpr_sampler(VariableID id, const MSLConstexprSampler &sampler);
+
+	// Same as remap_constexpr_sampler, except you provide set/binding, rather than variable ID.
+	// Remaps based on ID take priority over set/binding remaps.
+	void remap_constexpr_sampler_by_binding(uint32_t desc_set, uint32_t binding, const MSLConstexprSampler &sampler);
+
+	// If using CompilerMSL::Options::pad_fragment_output_components, override the number of components we expect
+	// to use for a particular location. The default is 4 if number of components is not overridden.
+	void set_fragment_output_components(uint32_t location, uint32_t components);
+
+protected:
+	// An enum of SPIR-V functions that are implemented in additional
+	// source code that is added to the shader if necessary.
+	enum SPVFuncImpl
+	{
+		SPVFuncImplNone,
+		SPVFuncImplMod,
+		SPVFuncImplRadians,
+		SPVFuncImplDegrees,
+		SPVFuncImplFindILsb,
+		SPVFuncImplFindSMsb,
+		SPVFuncImplFindUMsb,
+		SPVFuncImplSSign,
+		SPVFuncImplArrayCopyMultidimBase,
+		// Unfortunately, we cannot use recursive templates in the MSL compiler properly,
+		// so stamp out variants up to some arbitrary maximum.
+		SPVFuncImplArrayCopy = SPVFuncImplArrayCopyMultidimBase + 1,
+		SPVFuncImplArrayOfArrayCopy2Dim = SPVFuncImplArrayCopyMultidimBase + 2,
+		SPVFuncImplArrayOfArrayCopy3Dim = SPVFuncImplArrayCopyMultidimBase + 3,
+		SPVFuncImplArrayOfArrayCopy4Dim = SPVFuncImplArrayCopyMultidimBase + 4,
+		SPVFuncImplArrayOfArrayCopy5Dim = SPVFuncImplArrayCopyMultidimBase + 5,
+		SPVFuncImplArrayOfArrayCopy6Dim = SPVFuncImplArrayCopyMultidimBase + 6,
+		SPVFuncImplTexelBufferCoords,
+		SPVFuncImplImage2DAtomicCoords, // Emulate texture2D atomic operations
+		SPVFuncImplFMul,
+		SPVFuncImplFAdd,
+		SPVFuncImplCubemapTo2DArrayFace,
+		SPVFuncImplUnsafeArray, // Allow Metal to use the array<T> template to make arrays a value type
+		SPVFuncImplInverse4x4,
+		SPVFuncImplInverse3x3,
+		SPVFuncImplInverse2x2,
+		// It is very important that this come before *Swizzle and ChromaReconstruct*, to ensure it's
+		// emitted before them.
+		SPVFuncImplForwardArgs,
+		// Likewise, this must come before *Swizzle.
+		SPVFuncImplGetSwizzle,
+		SPVFuncImplTextureSwizzle,
+		SPVFuncImplGatherSwizzle,
+		SPVFuncImplGatherCompareSwizzle,
+		SPVFuncImplSubgroupBallot,
+		SPVFuncImplSubgroupBallotBitExtract,
+		SPVFuncImplSubgroupBallotFindLSB,
+		SPVFuncImplSubgroupBallotFindMSB,
+		SPVFuncImplSubgroupBallotBitCount,
+		SPVFuncImplSubgroupAllEqual,
+		SPVFuncImplReflectScalar,
+		SPVFuncImplRefractScalar,
+		SPVFuncImplFaceForwardScalar,
+		SPVFuncImplChromaReconstructNearest2Plane,
+		SPVFuncImplChromaReconstructNearest3Plane,
+		SPVFuncImplChromaReconstructLinear422CositedEven2Plane,
+		SPVFuncImplChromaReconstructLinear422CositedEven3Plane,
+		SPVFuncImplChromaReconstructLinear422Midpoint2Plane,
+		SPVFuncImplChromaReconstructLinear422Midpoint3Plane,
+		SPVFuncImplChromaReconstructLinear420XCositedEvenYCositedEven2Plane,
+		SPVFuncImplChromaReconstructLinear420XCositedEvenYCositedEven3Plane,
+		SPVFuncImplChromaReconstructLinear420XMidpointYCositedEven2Plane,
+		SPVFuncImplChromaReconstructLinear420XMidpointYCositedEven3Plane,
+		SPVFuncImplChromaReconstructLinear420XCositedEvenYMidpoint2Plane,
+		SPVFuncImplChromaReconstructLinear420XCositedEvenYMidpoint3Plane,
+		SPVFuncImplChromaReconstructLinear420XMidpointYMidpoint2Plane,
+		SPVFuncImplChromaReconstructLinear420XMidpointYMidpoint3Plane,
+		SPVFuncImplExpandITUFullRange,
+		SPVFuncImplExpandITUNarrowRange,
+		SPVFuncImplConvertYCbCrBT709,
+		SPVFuncImplConvertYCbCrBT601,
+		SPVFuncImplConvertYCbCrBT2020,
+		SPVFuncImplDynamicImageSampler,
+
+		SPVFuncImplArrayCopyMultidimMax = 6
+	};
+
+	// If the underlying resource has been used for comparison then duplicate loads of that resource must be too
+	// Use Metal's native frame-buffer fetch API for subpass inputs.
+	void emit_texture_op(const Instruction &i, bool sparse) override;
+	void emit_binary_unord_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op);
+	void emit_instruction(const Instruction &instr) override;
+	void emit_glsl_op(uint32_t result_type, uint32_t result_id, uint32_t op, const uint32_t *args,
+	                  uint32_t count) override;
+	void emit_spv_amd_shader_trinary_minmax_op(uint32_t result_type, uint32_t result_id, uint32_t op,
+	                                           const uint32_t *args, uint32_t count) override;
+	void emit_header() override;
+	void emit_function_prototype(SPIRFunction &func, const Bitset &return_flags) override;
+	void emit_sampled_image_op(uint32_t result_type, uint32_t result_id, uint32_t image_id, uint32_t samp_id) override;
+	void emit_subgroup_op(const Instruction &i) override;
+	std::string to_texture_op(const Instruction &i, bool sparse, bool *forward,
+	                          SmallVector<uint32_t> &inherited_expressions) override;
+	void emit_fixup() override;
+	std::string to_struct_member(const SPIRType &type, uint32_t member_type_id, uint32_t index,
+	                             const std::string &qualifier = "");
+	void emit_struct_member(const SPIRType &type, uint32_t member_type_id, uint32_t index,
+	                        const std::string &qualifier = "", uint32_t base_offset = 0) override;
+	void emit_struct_padding_target(const SPIRType &type) override;
+	std::string type_to_glsl(const SPIRType &type, uint32_t id = 0) override;
+
+	// Allow Metal to use the array<T> template to make arrays a value type
+	std::string type_to_array_glsl(const SPIRType &type) override;
+
+	// Threadgroup arrays can't have a wrapper type
+	std::string variable_decl(const SPIRVariable &variable) override;
+
+	// GCC workaround of lambdas calling protected functions (for older GCC versions)
+	std::string variable_decl(const SPIRType &type, const std::string &name, uint32_t id = 0) override;
+
+	std::string image_type_glsl(const SPIRType &type, uint32_t id = 0) override;
+	std::string sampler_type(const SPIRType &type);
+	std::string builtin_to_glsl(spv::BuiltIn builtin, spv::StorageClass storage) override;
+	std::string to_func_call_arg(const SPIRFunction::Parameter &arg, uint32_t id) override;
+	std::string to_name(uint32_t id, bool allow_alias = true) const override;
+	std::string to_function_name(const TextureFunctionNameArguments &args) override;
+	std::string to_function_args(const TextureFunctionArguments &args, bool *p_forward) override;
+	std::string to_initializer_expression(const SPIRVariable &var) override;
+	std::string to_zero_initialized_expression(uint32_t type_id) override;
+
+	std::string unpack_expression_type(std::string expr_str, const SPIRType &type, uint32_t physical_type_id,
+	                                   bool is_packed, bool row_major) override;
+
+	// Returns true for BuiltInSampleMask because gl_SampleMask[] is an array in SPIR-V, but [[sample_mask]] is a scalar in Metal.
+	bool builtin_translates_to_nonarray(spv::BuiltIn builtin) const override;
+
+	std::string bitcast_glsl_op(const SPIRType &result_type, const SPIRType &argument_type) override;
+	bool emit_complex_bitcast(uint32_t result_id, uint32_t id, uint32_t op0) override;
+	bool skip_argument(uint32_t id) const override;
+	std::string to_member_reference(uint32_t base, const SPIRType &type, uint32_t index, bool ptr_chain) override;
+	std::string to_qualifiers_glsl(uint32_t id) override;
+	void replace_illegal_names() override;
+	void declare_undefined_values() override;
+	void declare_constant_arrays();
+
+	// Constant arrays of non-primitive types (i.e. matrices) won't link properly into Metal libraries
+	void declare_complex_constant_arrays();
+
+	bool is_patch_block(const SPIRType &type);
+	bool is_non_native_row_major_matrix(uint32_t id) override;
+	bool member_is_non_native_row_major_matrix(const SPIRType &type, uint32_t index) override;
+	std::string convert_row_major_matrix(std::string exp_str, const SPIRType &exp_type, uint32_t physical_type_id,
+	                                     bool is_packed) override;
+
+	void preprocess_op_codes();
+	void localize_global_variables();
+	void extract_global_variables_from_functions();
+	void mark_packable_structs();
+	void mark_as_packable(SPIRType &type);
+
+	std::unordered_map<uint32_t, std::set<uint32_t>> function_global_vars;
+	void extract_global_variables_from_function(uint32_t func_id, std::set<uint32_t> &added_arg_ids,
+	                                            std::unordered_set<uint32_t> &global_var_ids,
+	                                            std::unordered_set<uint32_t> &processed_func_ids);
+	uint32_t add_interface_block(spv::StorageClass storage, bool patch = false);
+	uint32_t add_interface_block_pointer(uint32_t ib_var_id, spv::StorageClass storage);
+
+	struct InterfaceBlockMeta
+	{
+		struct LocationMeta
+		{
+			uint32_t num_components = 0;
+			uint32_t ib_index = ~0u;
+		};
+		std::unordered_map<uint32_t, LocationMeta> location_meta;
+		bool strip_array = false;
+	};
+
+	void add_variable_to_interface_block(spv::StorageClass storage, const std::string &ib_var_ref, SPIRType &ib_type,
+	                                     SPIRVariable &var, InterfaceBlockMeta &meta);
+	void add_composite_variable_to_interface_block(spv::StorageClass storage, const std::string &ib_var_ref,
+	                                               SPIRType &ib_type, SPIRVariable &var, InterfaceBlockMeta &meta);
+	void add_plain_variable_to_interface_block(spv::StorageClass storage, const std::string &ib_var_ref,
+	                                           SPIRType &ib_type, SPIRVariable &var, InterfaceBlockMeta &meta);
+	void add_plain_member_variable_to_interface_block(spv::StorageClass storage, const std::string &ib_var_ref,
+	                                                  SPIRType &ib_type, SPIRVariable &var, uint32_t index,
+	                                                  InterfaceBlockMeta &meta);
+	void add_composite_member_variable_to_interface_block(spv::StorageClass storage, const std::string &ib_var_ref,
+	                                                      SPIRType &ib_type, SPIRVariable &var, uint32_t index,
+	                                                      InterfaceBlockMeta &meta);
+	uint32_t get_accumulated_member_location(const SPIRVariable &var, uint32_t mbr_idx, bool strip_array);
+	void add_tess_level_input_to_interface_block(const std::string &ib_var_ref, SPIRType &ib_type, SPIRVariable &var);
+
+	void fix_up_interface_member_indices(spv::StorageClass storage, uint32_t ib_type_id);
+
+	void mark_location_as_used_by_shader(uint32_t location, const SPIRType &type, spv::StorageClass storage);
+	uint32_t ensure_correct_builtin_type(uint32_t type_id, spv::BuiltIn builtin);
+	uint32_t ensure_correct_input_type(uint32_t type_id, uint32_t location, uint32_t num_components = 0);
+
+	void emit_custom_templates();
+	void emit_custom_functions();
+	void emit_resources();
+	void emit_specialization_constants_and_structs();
+	void emit_interface_block(uint32_t ib_var_id);
+	bool maybe_emit_array_assignment(uint32_t id_lhs, uint32_t id_rhs);
+
+	void fix_up_shader_inputs_outputs();
+
+	std::string func_type_decl(SPIRType &type);
+	std::string entry_point_args_classic(bool append_comma);
+	std::string entry_point_args_argument_buffer(bool append_comma);
+	std::string entry_point_arg_stage_in();
+	void entry_point_args_builtin(std::string &args);
+	void entry_point_args_discrete_descriptors(std::string &args);
+	std::string to_qualified_member_name(const SPIRType &type, uint32_t index);
+	std::string ensure_valid_name(std::string name, std::string pfx);
+	std::string to_sampler_expression(uint32_t id);
+	std::string to_swizzle_expression(uint32_t id);
+	std::string to_buffer_size_expression(uint32_t id);
+	bool is_direct_input_builtin(spv::BuiltIn builtin);
+	std::string builtin_qualifier(spv::BuiltIn builtin);
+	std::string builtin_type_decl(spv::BuiltIn builtin, uint32_t id = 0);
+	std::string built_in_func_arg(spv::BuiltIn builtin, bool prefix_comma);
+	std::string member_attribute_qualifier(const SPIRType &type, uint32_t index);
+	std::string argument_decl(const SPIRFunction::Parameter &arg);
+	std::string round_fp_tex_coords(std::string tex_coords, bool coord_is_fp);
+	uint32_t get_metal_resource_index(SPIRVariable &var, SPIRType::BaseType basetype, uint32_t plane = 0);
+	uint32_t get_ordered_member_location(uint32_t type_id, uint32_t index, uint32_t *comp = nullptr);
+
+	// MSL packing rules. These compute the effective packing rules as observed by the MSL compiler in the MSL output.
+	// These values can change depending on various extended decorations which control packing rules.
+	// We need to make these rules match up with SPIR-V declared rules.
+	uint32_t get_declared_type_size_msl(const SPIRType &type, bool packed, bool row_major) const;
+	uint32_t get_declared_type_array_stride_msl(const SPIRType &type, bool packed, bool row_major) const;
+	uint32_t get_declared_type_matrix_stride_msl(const SPIRType &type, bool packed, bool row_major) const;
+	uint32_t get_declared_type_alignment_msl(const SPIRType &type, bool packed, bool row_major) const;
+
+	uint32_t get_declared_struct_member_size_msl(const SPIRType &struct_type, uint32_t index) const;
+	uint32_t get_declared_struct_member_array_stride_msl(const SPIRType &struct_type, uint32_t index) const;
+	uint32_t get_declared_struct_member_matrix_stride_msl(const SPIRType &struct_type, uint32_t index) const;
+	uint32_t get_declared_struct_member_alignment_msl(const SPIRType &struct_type, uint32_t index) const;
+
+	uint32_t get_declared_input_size_msl(const SPIRType &struct_type, uint32_t index) const;
+	uint32_t get_declared_input_array_stride_msl(const SPIRType &struct_type, uint32_t index) const;
+	uint32_t get_declared_input_matrix_stride_msl(const SPIRType &struct_type, uint32_t index) const;
+	uint32_t get_declared_input_alignment_msl(const SPIRType &struct_type, uint32_t index) const;
+
+	const SPIRType &get_physical_member_type(const SPIRType &struct_type, uint32_t index) const;
+	SPIRType get_presumed_input_type(const SPIRType &struct_type, uint32_t index) const;
+
+	uint32_t get_declared_struct_size_msl(const SPIRType &struct_type, bool ignore_alignment = false,
+	                                      bool ignore_padding = false) const;
+
+	std::string to_component_argument(uint32_t id);
+	void align_struct(SPIRType &ib_type, std::unordered_set<uint32_t> &aligned_structs);
+	void mark_scalar_layout_structs(const SPIRType &ib_type);
+	void mark_struct_members_packed(const SPIRType &type);
+	void ensure_member_packing_rules_msl(SPIRType &ib_type, uint32_t index);
+	bool validate_member_packing_rules_msl(const SPIRType &type, uint32_t index) const;
+	std::string get_argument_address_space(const SPIRVariable &argument);
+	std::string get_type_address_space(const SPIRType &type, uint32_t id, bool argument = false);
+	const char *to_restrict(uint32_t id, bool space = true);
+	SPIRType &get_stage_in_struct_type();
+	SPIRType &get_stage_out_struct_type();
+	SPIRType &get_patch_stage_in_struct_type();
+	SPIRType &get_patch_stage_out_struct_type();
+	std::string get_tess_factor_struct_name();
+	SPIRType &get_uint_type();
+	uint32_t get_uint_type_id();
+	void emit_atomic_func_op(uint32_t result_type, uint32_t result_id, const char *op, uint32_t mem_order_1,
+	                         uint32_t mem_order_2, bool has_mem_order_2, uint32_t op0, uint32_t op1 = 0,
+	                         bool op1_is_pointer = false, bool op1_is_literal = false, uint32_t op2 = 0);
+	const char *get_memory_order(uint32_t spv_mem_sem);
+	void add_pragma_line(const std::string &line);
+	void add_typedef_line(const std::string &line);
+	void emit_barrier(uint32_t id_exe_scope, uint32_t id_mem_scope, uint32_t id_mem_sem);
+	void emit_array_copy(const std::string &lhs, uint32_t rhs_id, spv::StorageClass lhs_storage,
+	                     spv::StorageClass rhs_storage) override;
+	void build_implicit_builtins();
+	uint32_t build_constant_uint_array_pointer();
+	void emit_entry_point_declarations() override;
+	uint32_t builtin_frag_coord_id = 0;
+	uint32_t builtin_sample_id_id = 0;
+	uint32_t builtin_sample_mask_id = 0;
+	uint32_t builtin_vertex_idx_id = 0;
+	uint32_t builtin_base_vertex_id = 0;
+	uint32_t builtin_instance_idx_id = 0;
+	uint32_t builtin_base_instance_id = 0;
+	uint32_t builtin_view_idx_id = 0;
+	uint32_t builtin_layer_id = 0;
+	uint32_t builtin_invocation_id_id = 0;
+	uint32_t builtin_primitive_id_id = 0;
+	uint32_t builtin_subgroup_invocation_id_id = 0;
+	uint32_t builtin_subgroup_size_id = 0;
+	uint32_t builtin_dispatch_base_id = 0;
+	uint32_t builtin_stage_input_size_id = 0;
+	uint32_t swizzle_buffer_id = 0;
+	uint32_t buffer_size_buffer_id = 0;
+	uint32_t view_mask_buffer_id = 0;
+	uint32_t dynamic_offsets_buffer_id = 0;
+	uint32_t uint_type_id = 0;
+
+	bool does_shader_write_sample_mask = false;
+
+	void bitcast_to_builtin_store(uint32_t target_id, std::string &expr, const SPIRType &expr_type) override;
+	void bitcast_from_builtin_load(uint32_t source_id, std::string &expr, const SPIRType &expr_type) override;
+	void emit_store_statement(uint32_t lhs_expression, uint32_t rhs_expression) override;
+
+	void analyze_sampled_image_usage();
+
+	void prepare_access_chain_for_scalar_access(std::string &expr, const SPIRType &type, spv::StorageClass storage,
+	                                            bool &is_packed) override;
+	bool emit_tessellation_access_chain(const uint32_t *ops, uint32_t length);
+	bool emit_tessellation_io_load(uint32_t result_type, uint32_t id, uint32_t ptr);
+	bool is_out_of_bounds_tessellation_level(uint32_t id_lhs);
+
+	void ensure_builtin(spv::StorageClass storage, spv::BuiltIn builtin);
+
+	void mark_implicit_builtin(spv::StorageClass storage, spv::BuiltIn builtin, uint32_t id);
+
+	std::string convert_to_f32(const std::string &expr, uint32_t components);
+
+	Options msl_options;
+	std::set<SPVFuncImpl> spv_function_implementations;
+	// Must be ordered to ensure declarations are in a specific order.
+	std::map<uint32_t, MSLShaderInput> inputs_by_location;
+	std::unordered_map<uint32_t, MSLShaderInput> inputs_by_builtin;
+	std::unordered_set<uint32_t> inputs_in_use;
+	std::unordered_map<uint32_t, uint32_t> fragment_output_components;
+	std::set<std::string> pragma_lines;
+	std::set<std::string> typedef_lines;
+	SmallVector<uint32_t> vars_needing_early_declaration;
+
+	std::unordered_map<StageSetBinding, std::pair<MSLResourceBinding, bool>, InternalHasher> resource_bindings;
+
+	uint32_t next_metal_resource_index_buffer = 0;
+	uint32_t next_metal_resource_index_texture = 0;
+	uint32_t next_metal_resource_index_sampler = 0;
+	// Intentionally uninitialized, works around MSVC 2013 bug.
+	uint32_t next_metal_resource_ids[kMaxArgumentBuffers];
+
+	VariableID stage_in_var_id = 0;
+	VariableID stage_out_var_id = 0;
+	VariableID patch_stage_in_var_id = 0;
+	VariableID patch_stage_out_var_id = 0;
+	VariableID stage_in_ptr_var_id = 0;
+	VariableID stage_out_ptr_var_id = 0;
+
+	// Handle HLSL-style 0-based vertex/instance index.
+	enum class TriState
+	{
+		Neutral,
+		No,
+		Yes
+	};
+	TriState needs_base_vertex_arg = TriState::Neutral;
+	TriState needs_base_instance_arg = TriState::Neutral;
+
+	bool has_sampled_images = false;
+	bool builtin_declaration = false; // Handle HLSL-style 0-based vertex/instance index.
+
+	bool is_using_builtin_array = false; // Force the use of C style array declaration.
+	bool using_builtin_array() const;
+
+	bool is_rasterization_disabled = false;
+	bool capture_output_to_buffer = false;
+	bool needs_swizzle_buffer_def = false;
+	bool used_swizzle_buffer = false;
+	bool added_builtin_tess_level = false;
+	bool needs_subgroup_invocation_id = false;
+	std::string qual_pos_var_name;
+	std::string stage_in_var_name = "in";
+	std::string stage_out_var_name = "out";
+	std::string patch_stage_in_var_name = "patchIn";
+	std::string patch_stage_out_var_name = "patchOut";
+	std::string sampler_name_suffix = "Smplr";
+	std::string swizzle_name_suffix = "Swzl";
+	std::string buffer_size_name_suffix = "BufferSize";
+	std::string plane_name_suffix = "Plane";
+	std::string input_wg_var_name = "gl_in";
+	std::string input_buffer_var_name = "spvIn";
+	std::string output_buffer_var_name = "spvOut";
+	std::string patch_output_buffer_var_name = "spvPatchOut";
+	std::string tess_factor_buffer_var_name = "spvTessLevel";
+	std::string index_buffer_var_name = "spvIndices";
+	spv::Op previous_instruction_opcode = spv::OpNop;
+
+	// Must be ordered since declaration is in a specific order.
+	std::map<uint32_t, MSLConstexprSampler> constexpr_samplers_by_id;
+	std::unordered_map<SetBindingPair, MSLConstexprSampler, InternalHasher> constexpr_samplers_by_binding;
+	const MSLConstexprSampler *find_constexpr_sampler(uint32_t id) const;
+
+	std::unordered_set<uint32_t> buffers_requiring_array_length;
+	SmallVector<uint32_t> buffer_arrays;
+	std::unordered_set<uint32_t> atomic_image_vars; // Emulate texture2D atomic operations
+
+	// Must be ordered since array is in a specific order.
+	std::map<SetBindingPair, std::pair<uint32_t, uint32_t>> buffers_requiring_dynamic_offset;
+
+	SmallVector<uint32_t> disabled_frag_outputs;
+
+	std::unordered_set<SetBindingPair, InternalHasher> inline_uniform_blocks;
+
+	uint32_t argument_buffer_ids[kMaxArgumentBuffers];
+	uint32_t argument_buffer_discrete_mask = 0;
+	uint32_t argument_buffer_device_storage_mask = 0;
+
+	void analyze_argument_buffers();
+	bool descriptor_set_is_argument_buffer(uint32_t desc_set) const;
+
+	uint32_t get_target_components_for_fragment_location(uint32_t location) const;
+	uint32_t build_extended_vector_type(uint32_t type_id, uint32_t components,
+	                                    SPIRType::BaseType basetype = SPIRType::Unknown);
+
+	bool suppress_missing_prototypes = false;
+
+	void add_spv_func_and_recompile(SPVFuncImpl spv_func);
+
+	void activate_argument_buffer_resources();
+
+	bool type_is_msl_framebuffer_fetch(const SPIRType &type) const;
+
+	// OpcodeHandler that handles several MSL preprocessing operations.
+	struct OpCodePreprocessor : OpcodeHandler
+	{
+		OpCodePreprocessor(CompilerMSL &compiler_)
+		    : compiler(compiler_)
+		{
+		}
+
+		bool handle(spv::Op opcode, const uint32_t *args, uint32_t length) override;
+		CompilerMSL::SPVFuncImpl get_spv_func_impl(spv::Op opcode, const uint32_t *args);
+		void check_resource_write(uint32_t var_id);
+
+		CompilerMSL &compiler;
+		std::unordered_map<uint32_t, uint32_t> result_types;
+		std::unordered_map<uint32_t, uint32_t> image_pointers; // Emulate texture2D atomic operations
+		bool suppress_missing_prototypes = false;
+		bool uses_atomics = false;
+		bool uses_resource_write = false;
+		bool needs_subgroup_invocation_id = false;
+	};
+
+	// OpcodeHandler that scans for uses of sampled images
+	struct SampledImageScanner : OpcodeHandler
+	{
+		SampledImageScanner(CompilerMSL &compiler_)
+		    : compiler(compiler_)
+		{
+		}
+
+		bool handle(spv::Op opcode, const uint32_t *args, uint32_t) override;
+
+		CompilerMSL &compiler;
+	};
+
+	// Sorts the members of a SPIRType and associated Meta info based on a settable sorting
+	// aspect, which defines which aspect of the struct members will be used to sort them.
+	// Regardless of the sorting aspect, built-in members always appear at the end of the struct.
+	struct MemberSorter
+	{
+		enum SortAspect
+		{
+			Location,
+			LocationReverse,
+			Offset,
+			OffsetThenLocationReverse,
+			Alphabetical
+		};
+
+		void sort();
+		bool operator()(uint32_t mbr_idx1, uint32_t mbr_idx2);
+		MemberSorter(SPIRType &t, Meta &m, SortAspect sa);
+
+		SPIRType &type;
+		Meta &meta;
+		SortAspect sort_aspect;
+	};
+};
+} // namespace SPIRV_CROSS_NAMESPACE
+
+#endif
diff --git a/engine/inc/spirv_cross/spirv_parser.hpp b/engine/inc/spirv_cross/spirv_parser.hpp
new file mode 100644
index 00000000..7b3edded
--- /dev/null
+++ b/engine/inc/spirv_cross/spirv_parser.hpp
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2018-2020 Arm Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SPIRV_CROSS_PARSER_HPP
+#define SPIRV_CROSS_PARSER_HPP
+
+#include "spirv_cross_parsed_ir.hpp"
+#include <stdint.h>
+
+namespace SPIRV_CROSS_NAMESPACE
+{
+class Parser
+{
+public:
+	Parser(const uint32_t *spirv_data, size_t word_count);
+	Parser(std::vector<uint32_t> spirv);
+
+	void parse();
+
+	ParsedIR &get_parsed_ir()
+	{
+		return ir;
+	}
+
+private:
+	ParsedIR ir;
+	SPIRFunction *current_function = nullptr;
+	SPIRBlock *current_block = nullptr;
+
+	void parse(const Instruction &instr);
+	const uint32_t *stream(const Instruction &instr) const;
+
+	template <typename T, typename... P>
+	T &set(uint32_t id, P &&... args)
+	{
+		ir.add_typed_id(static_cast<Types>(T::type), id);
+		auto &var = variant_set<T>(ir.ids[id], std::forward<P>(args)...);
+		var.self = id;
+		return var;
+	}
+
+	template <typename T>
+	T &get(uint32_t id)
+	{
+		return variant_get<T>(ir.ids[id]);
+	}
+
+	template <typename T>
+	T *maybe_get(uint32_t id)
+	{
+		if (ir.ids[id].get_type() == static_cast<Types>(T::type))
+			return &get<T>(id);
+		else
+			return nullptr;
+	}
+
+	template <typename T>
+	const T &get(uint32_t id) const
+	{
+		return variant_get<T>(ir.ids[id]);
+	}
+
+	template <typename T>
+	const T *maybe_get(uint32_t id) const
+	{
+		if (ir.ids[id].get_type() == T::type)
+			return &get<T>(id);
+		else
+			return nullptr;
+	}
+
+	// This must be an ordered data structure so we always pick the same type aliases.
+	SmallVector<uint32_t> global_struct_cache;
+	SmallVector<std::pair<uint32_t, uint32_t>> forward_pointer_fixups;
+
+	bool types_are_logically_equivalent(const SPIRType &a, const SPIRType &b) const;
+	bool variable_storage_is_aliased(const SPIRVariable &v) const;
+};
+} // namespace SPIRV_CROSS_NAMESPACE
+
+#endif
diff --git a/engine/inc/spirv_cross/spirv_reflect.hpp b/engine/inc/spirv_cross/spirv_reflect.hpp
new file mode 100644
index 00000000..9f60e72e
--- /dev/null
+++ b/engine/inc/spirv_cross/spirv_reflect.hpp
@@ -0,0 +1,84 @@
+/*
+ * Copyright 2018-2020 Bradley Austin Davis
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SPIRV_CROSS_REFLECT_HPP
+#define SPIRV_CROSS_REFLECT_HPP
+
+#include "spirv_glsl.hpp"
+#include <utility>
+
+namespace simple_json
+{
+class Stream;
+}
+
+namespace SPIRV_CROSS_NAMESPACE
+{
+class CompilerReflection : public CompilerGLSL
+{
+	using Parent = CompilerGLSL;
+
+public:
+	explicit CompilerReflection(std::vector<uint32_t> spirv_)
+	    : Parent(std::move(spirv_))
+	{
+		options.vulkan_semantics = true;
+	}
+
+	CompilerReflection(const uint32_t *ir_, size_t word_count)
+	    : Parent(ir_, word_count)
+	{
+		options.vulkan_semantics = true;
+	}
+
+	explicit CompilerReflection(const ParsedIR &ir_)
+	    : CompilerGLSL(ir_)
+	{
+		options.vulkan_semantics = true;
+	}
+
+	explicit CompilerReflection(ParsedIR &&ir_)
+	    : CompilerGLSL(std::move(ir_))
+	{
+		options.vulkan_semantics = true;
+	}
+
+	void set_format(const std::string &format);
+	std::string compile() override;
+
+private:
+	static std::string execution_model_to_str(spv::ExecutionModel model);
+
+	void emit_entry_points();
+	void emit_types();
+	void emit_resources();
+	void emit_specialization_constants();
+
+	void emit_type(uint32_t type_id, bool &emitted_open_tag);
+	void emit_type_member(const SPIRType &type, uint32_t index);
+	void emit_type_member_qualifiers(const SPIRType &type, uint32_t index);
+	void emit_type_array(const SPIRType &type);
+	void emit_resources(const char *tag, const SmallVector<Resource> &resources);
+	bool type_is_reference(const SPIRType &type) const;
+
+	std::string to_member_name(const SPIRType &type, uint32_t index) const;
+
+	std::shared_ptr<simple_json::Stream> json_stream;
+};
+
+} // namespace SPIRV_CROSS_NAMESPACE
+
+#endif
diff --git a/engine/inc/spirv_cross/thread_group.hpp b/engine/inc/spirv_cross/thread_group.hpp
new file mode 100644
index 00000000..377f098b
--- /dev/null
+++ b/engine/inc/spirv_cross/thread_group.hpp
@@ -0,0 +1,113 @@
+/*
+ * Copyright 2015-2017 ARM Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SPIRV_CROSS_THREAD_GROUP_HPP
+#define SPIRV_CROSS_THREAD_GROUP_HPP
+
+#include <condition_variable>
+#include <mutex>
+#include <thread>
+
+namespace spirv_cross
+{
+template <typename T, unsigned Size>
+class ThreadGroup
+{
+public:
+	ThreadGroup(T *impl)
+	{
+		for (unsigned i = 0; i < Size; i++)
+			workers[i].start(&impl[i]);
+	}
+
+	void run()
+	{
+		for (auto &worker : workers)
+			worker.run();
+	}
+
+	void wait()
+	{
+		for (auto &worker : workers)
+			worker.wait();
+	}
+
+private:
+	struct Thread
+	{
+		enum State
+		{
+			Idle,
+			Running,
+			Dying
+		};
+		State state = Idle;
+
+		void start(T *impl)
+		{
+			worker = std::thread([impl, this] {
+				for (;;)
+				{
+					{
+						std::unique_lock<std::mutex> l{ lock };
+						cond.wait(l, [this] { return state != Idle; });
+						if (state == Dying)
+							break;
+					}
+
+					impl->main();
+
+					std::lock_guard<std::mutex> l{ lock };
+					state = Idle;
+					cond.notify_one();
+				}
+			});
+		}
+
+		void wait()
+		{
+			std::unique_lock<std::mutex> l{ lock };
+			cond.wait(l, [this] { return state == Idle; });
+		}
+
+		void run()
+		{
+			std::lock_guard<std::mutex> l{ lock };
+			state = Running;
+			cond.notify_one();
+		}
+
+		~Thread()
+		{
+			if (worker.joinable())
+			{
+				{
+					std::lock_guard<std::mutex> l{ lock };
+					state = Dying;
+					cond.notify_one();
+				}
+				worker.join();
+			}
+		}
+		std::thread worker;
+		std::condition_variable cond;
+		std::mutex lock;
+	};
+	Thread workers[Size];
+};
+}
+
+#endif
diff --git a/engine/inc/stb_image.h b/engine/inc/stb_image.h
new file mode 100644
index 00000000..a6202a31
--- /dev/null
+++ b/engine/inc/stb_image.h
@@ -0,0 +1,7547 @@
+/* stb_image - v2.22 - public domain image loader - http://nothings.org/stb
+                                  no warranty implied; use at your own risk
+
+   Do this:
+      #define STB_IMAGE_IMPLEMENTATION
+   before you include this file in *one* C or C++ file to create the implementation.
+
+   // i.e. it should look like this:
+   #include ...
+   #include ...
+   #include ...
+   #define STB_IMAGE_IMPLEMENTATION
+   #include "stb_image.h"
+
+   You can #define STBI_ASSERT(x) before the #include to avoid using assert.h.
+   And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free
+
+
+   QUICK NOTES:
+      Primarily of interest to game developers and other people who can
+          avoid problematic images and only need the trivial interface
+
+      JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib)
+      PNG 1/2/4/8/16-bit-per-channel
+
+      TGA (not sure what subset, if a subset)
+      BMP non-1bpp, non-RLE
+      PSD (composited view only, no extra channels, 8/16 bit-per-channel)
+
+      GIF (*comp always reports as 4-channel)
+      HDR (radiance rgbE format)
+      PIC (Softimage PIC)
+      PNM (PPM and PGM binary only)
+
+      Animated GIF still needs a proper API, but here's one way to do it:
+          http://gist.github.com/urraka/685d9a6340b26b830d49
+
+      - decode from memory or through FILE (define STBI_NO_STDIO to remove code)
+      - decode from arbitrary I/O callbacks
+      - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON)
+
+   Full documentation under "DOCUMENTATION" below.
+
+
+LICENSE
+
+  See end of file for license information.
+
+RECENT REVISION HISTORY:
+
+      2.22  (2019-03-04) gif fixes, fix warnings
+      2.21  (2019-02-25) fix typo in comment
+      2.20  (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs 
+      2.19  (2018-02-11) fix warning
+      2.18  (2018-01-30) fix warnings
+      2.17  (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings
+      2.16  (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes
+      2.15  (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC
+      2.14  (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs
+      2.13  (2016-12-04) experimental 16-bit API, only for PNG so far; fixes
+      2.12  (2016-04-02) fix typo in 2.11 PSD fix that caused crashes
+      2.11  (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64
+                         RGB-format JPEG; remove white matting in PSD;
+                         allocate large structures on the stack;
+                         correct channel count for PNG & BMP
+      2.10  (2016-01-22) avoid warning introduced in 2.09
+      2.09  (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED
+
+   See end of file for full revision history.
+
+
+ ============================    Contributors    =========================
+
+ Image formats                          Extensions, features
+    Sean Barrett (jpeg, png, bmp)          Jetro Lauha (stbi_info)
+    Nicolas Schulz (hdr, psd)              Martin "SpartanJ" Golini (stbi_info)
+    Jonathan Dummer (tga)                  James "moose2000" Brown (iPhone PNG)
+    Jean-Marc Lienher (gif)                Ben "Disch" Wenger (io callbacks)
+    Tom Seddon (pic)                       Omar Cornut (1/2/4-bit PNG)
+    Thatcher Ulrich (psd)                  Nicolas Guillemot (vertical flip)
+    Ken Miller (pgm, ppm)                  Richard Mitton (16-bit PSD)
+    github:urraka (animated gif)           Junggon Kim (PNM comments)
+    Christopher Forseth (animated gif)     Daniel Gibson (16-bit TGA)
+                                           socks-the-fox (16-bit PNG)
+                                           Jeremy Sawicki (handle all ImageNet JPGs)
+ Optimizations & bugfixes                  Mikhail Morozov (1-bit BMP)
+    Fabian "ryg" Giesen                    Anael Seghezzi (is-16-bit query)
+    Arseny Kapoulkine
+    John-Mark Allen
+    Carmelo J Fdez-Aguera
+
+ Bug & warning fixes
+    Marc LeBlanc            David Woo          Guillaume George   Martins Mozeiko
+    Christpher Lloyd        Jerry Jansson      Joseph Thomson     Phil Jordan
+    Dave Moore              Roy Eltham         Hayaki Saito       Nathan Reed
+    Won Chun                Luke Graham        Johan Duparc       Nick Verigakis
+    the Horde3D community   Thomas Ruf         Ronny Chevalier    github:rlyeh
+    Janez Zemva             John Bartholomew   Michal Cichon      github:romigrou
+    Jonathan Blow           Ken Hamada         Tero Hanninen      github:svdijk
+    Laurent Gomila          Cort Stratton      Sergio Gonzalez    github:snagar
+    Aruelien Pocheville     Thibault Reuille   Cass Everitt       github:Zelex
+    Ryamond Barbiero        Paul Du Bois       Engin Manap        github:grim210
+    Aldo Culquicondor       Philipp Wiesemann  Dale Weiler        github:sammyhw
+    Oriol Ferrer Mesia      Josh Tobin         Matthew Gregan     github:phprus
+    Julian Raschke          Gregory Mullen     Baldur Karlsson    github:poppolopoppo
+    Christian Floisand      Kevin Schmidt      JR Smith           github:darealshinji
+    Blazej Dariusz Roszkowski                                     github:Michaelangel007
+*/
+
+#ifndef STBI_INCLUDE_STB_IMAGE_H
+#define STBI_INCLUDE_STB_IMAGE_H
+
+// DOCUMENTATION
+//
+// Limitations:
+//    - no 12-bit-per-channel JPEG
+//    - no JPEGs with arithmetic coding
+//    - GIF always returns *comp=4
+//
+// Basic usage (see HDR discussion below for HDR usage):
+//    int x,y,n;
+//    unsigned char *data = stbi_load(filename, &x, &y, &n, 0);
+//    // ... process data if not NULL ...
+//    // ... x = width, y = height, n = # 8-bit components per pixel ...
+//    // ... replace '0' with '1'..'4' to force that many components per pixel
+//    // ... but 'n' will always be the number that it would have been if you said 0
+//    stbi_image_free(data)
+//
+// Standard parameters:
+//    int *x                 -- outputs image width in pixels
+//    int *y                 -- outputs image height in pixels
+//    int *channels_in_file  -- outputs # of image components in image file
+//    int desired_channels   -- if non-zero, # of image components requested in result
+//
+// The return value from an image loader is an 'unsigned char *' which points
+// to the pixel data, or NULL on an allocation failure or if the image is
+// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels,
+// with each pixel consisting of N interleaved 8-bit components; the first
+// pixel pointed to is top-left-most in the image. There is no padding between
+// image scanlines or between pixels, regardless of format. The number of
+// components N is 'desired_channels' if desired_channels is non-zero, or
+// *channels_in_file otherwise. If desired_channels is non-zero,
+// *channels_in_file has the number of components that _would_ have been
+// output otherwise. E.g. if you set desired_channels to 4, you will always
+// get RGBA output, but you can check *channels_in_file to see if it's trivially
+// opaque because e.g. there were only 3 channels in the source image.
+//
+// An output image with N components has the following components interleaved
+// in this order in each pixel:
+//
+//     N=#comp     components
+//       1           grey
+//       2           grey, alpha
+//       3           red, green, blue
+//       4           red, green, blue, alpha
+//
+// If image loading fails for any reason, the return value will be NULL,
+// and *x, *y, *channels_in_file will be unchanged. The function
+// stbi_failure_reason() can be queried for an extremely brief, end-user
+// unfriendly explanation of why the load failed. Define STBI_NO_FAILURE_STRINGS
+// to avoid compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly
+// more user-friendly ones.
+//
+// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized.
+//
+// ===========================================================================
+//
+// UNICODE:
+//
+//   If compiling for Windows and you wish to use Unicode filenames, compile
+//   with
+//       #define STBI_WINDOWS_UTF8
+//   and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert
+//   Windows wchar_t filenames to utf8.
+//
+// ===========================================================================
+//
+// Philosophy
+//
+// stb libraries are designed with the following priorities:
+//
+//    1. easy to use
+//    2. easy to maintain
+//    3. good performance
+//
+// Sometimes I let "good performance" creep up in priority over "easy to maintain",
+// and for best performance I may provide less-easy-to-use APIs that give higher
+// performance, in addition to the easy-to-use ones. Nevertheless, it's important
+// to keep in mind that from the standpoint of you, a client of this library,
+// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all.
+//
+// Some secondary priorities arise directly from the first two, some of which
+// provide more explicit reasons why performance can't be emphasized.
+//
+//    - Portable ("ease of use")
+//    - Small source code footprint ("easy to maintain")
+//    - No dependencies ("ease of use")
+//
+// ===========================================================================
+//
+// I/O callbacks
+//
+// I/O callbacks allow you to read from arbitrary sources, like packaged
+// files or some other source. Data read from callbacks are processed
+// through a small internal buffer (currently 128 bytes) to try to reduce
+// overhead.
+//
+// The three functions you must define are "read" (reads some bytes of data),
+// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end).
+//
+// ===========================================================================
+//
+// SIMD support
+//
+// The JPEG decoder will try to automatically use SIMD kernels on x86 when
+// supported by the compiler. For ARM Neon support, you must explicitly
+// request it.
+//
+// (The old do-it-yourself SIMD API is no longer supported in the current
+// code.)
+//
+// On x86, SSE2 will automatically be used when available based on a run-time
+// test; if not, the generic C versions are used as a fall-back. On ARM targets,
+// the typical path is to have separate builds for NEON and non-NEON devices
+// (at least this is true for iOS and Android). Therefore, the NEON support is
+// toggled by a build flag: define STBI_NEON to get NEON loops.
+//
+// If for some reason you do not want to use any of SIMD code, or if
+// you have issues compiling it, you can disable it entirely by
+// defining STBI_NO_SIMD.
+//
+// ===========================================================================
+//
+// HDR image support   (disable by defining STBI_NO_HDR)
+//
+// stb_image supports loading HDR images in general, and currently the Radiance
+// .HDR file format specifically. You can still load any file through the existing
+// interface; if you attempt to load an HDR file, it will be automatically remapped
+// to LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1;
+// both of these constants can be reconfigured through this interface:
+//
+//     stbi_hdr_to_ldr_gamma(2.2f);
+//     stbi_hdr_to_ldr_scale(1.0f);
+//
+// (note, do not use _inverse_ constants; stbi_image will invert them
+// appropriately).
+//
+// Additionally, there is a new, parallel interface for loading files as
+// (linear) floats to preserve the full dynamic range:
+//
+//    float *data = stbi_loadf(filename, &x, &y, &n, 0);
+//
+// If you load LDR images through this interface, those images will
+// be promoted to floating point values, run through the inverse of
+// constants corresponding to the above:
+//
+//     stbi_ldr_to_hdr_scale(1.0f);
+//     stbi_ldr_to_hdr_gamma(2.2f);
+//
+// Finally, given a filename (or an open file or memory block--see header
+// file for details) containing image data, you can query for the "most
+// appropriate" interface to use (that is, whether the image is HDR or
+// not), using:
+//
+//     stbi_is_hdr(char *filename);
+//
+// ===========================================================================
+//
+// iPhone PNG support:
+//
+// By default we convert iphone-formatted PNGs back to RGB, even though
+// they are internally encoded differently. You can disable this conversion
+// by calling stbi_convert_iphone_png_to_rgb(0), in which case
+// you will always just get the native iphone "format" through (which
+// is BGR stored in RGB).
+//
+// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per
+// pixel to remove any premultiplied alpha *only* if the image file explicitly
+// says there's premultiplied data (currently only happens in iPhone images,
+// and only if iPhone convert-to-rgb processing is on).
+//
+// ===========================================================================
+//
+// ADDITIONAL CONFIGURATION
+//
+//  - You can suppress implementation of any of the decoders to reduce
+//    your code footprint by #defining one or more of the following
+//    symbols before creating the implementation.
+//
+//        STBI_NO_JPEG
+//        STBI_NO_PNG
+//        STBI_NO_BMP
+//        STBI_NO_PSD
+//        STBI_NO_TGA
+//        STBI_NO_GIF
+//        STBI_NO_HDR
+//        STBI_NO_PIC
+//        STBI_NO_PNM   (.ppm and .pgm)
+//
+//  - You can request *only* certain decoders and suppress all other ones
+//    (this will be more forward-compatible, as addition of new decoders
+//    doesn't require you to disable them explicitly):
+//
+//        STBI_ONLY_JPEG
+//        STBI_ONLY_PNG
+//        STBI_ONLY_BMP
+//        STBI_ONLY_PSD
+//        STBI_ONLY_TGA
+//        STBI_ONLY_GIF
+//        STBI_ONLY_HDR
+//        STBI_ONLY_PIC
+//        STBI_ONLY_PNM   (.ppm and .pgm)
+//
+//   - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still
+//     want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB
+//
+
+
+#ifndef STBI_NO_STDIO
+#include <stdio.h>
+#endif // STBI_NO_STDIO
+
+#define STBI_VERSION 1
+
+enum
+{
+   STBI_default = 0, // only used for desired_channels
+
+   STBI_grey       = 1,
+   STBI_grey_alpha = 2,
+   STBI_rgb        = 3,
+   STBI_rgb_alpha  = 4
+};
+
+#include <stdlib.h>
+typedef unsigned char stbi_uc;
+typedef unsigned short stbi_us;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef STBIDEF
+#ifdef STB_IMAGE_STATIC
+#define STBIDEF static
+#else
+#define STBIDEF extern
+#endif
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// PRIMARY API - works on images of any type
+//
+
+//
+// load image by filename, open file, or memory buffer
+//
+
+typedef struct
+{
+   int      (*read)  (void *user,char *data,int size);   // fill 'data' with 'size' bytes.  return number of bytes actually read
+   void     (*skip)  (void *user,int n);                 // skip the next 'n' bytes, or 'unget' the last -n bytes if negative
+   int      (*eof)   (void *user);                       // returns nonzero if we are at end of file/data
+} stbi_io_callbacks;
+
+////////////////////////////////////
+//
+// 8-bits-per-channel interface
+//
+
+STBIDEF stbi_uc *stbi_load_from_memory   (stbi_uc           const *buffer, int len   , int *x, int *y, int *channels_in_file, int desired_channels);
+STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk  , void *user, int *x, int *y, int *channels_in_file, int desired_channels);
+
+#ifndef STBI_NO_STDIO
+STBIDEF stbi_uc *stbi_load            (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);
+STBIDEF stbi_uc *stbi_load_from_file  (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);
+// for stbi_load_from_file, file pointer is left pointing immediately after image
+#endif
+
+#ifndef STBI_NO_GIF
+STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp);
+#endif
+
+#ifdef STBI_WINDOWS_UTF8
+STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input);
+#endif
+
+////////////////////////////////////
+//
+// 16-bits-per-channel interface
+//
+
+STBIDEF stbi_us *stbi_load_16_from_memory   (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels);
+STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels);
+
+#ifndef STBI_NO_STDIO
+STBIDEF stbi_us *stbi_load_16          (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);
+STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);
+#endif
+
+////////////////////////////////////
+//
+// float-per-channel interface
+//
+#ifndef STBI_NO_LINEAR
+   STBIDEF float *stbi_loadf_from_memory     (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels);
+   STBIDEF float *stbi_loadf_from_callbacks  (stbi_io_callbacks const *clbk, void *user, int *x, int *y,  int *channels_in_file, int desired_channels);
+
+   #ifndef STBI_NO_STDIO
+   STBIDEF float *stbi_loadf            (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);
+   STBIDEF float *stbi_loadf_from_file  (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);
+   #endif
+#endif
+
+#ifndef STBI_NO_HDR
+   STBIDEF void   stbi_hdr_to_ldr_gamma(float gamma);
+   STBIDEF void   stbi_hdr_to_ldr_scale(float scale);
+#endif // STBI_NO_HDR
+
+#ifndef STBI_NO_LINEAR
+   STBIDEF void   stbi_ldr_to_hdr_gamma(float gamma);
+   STBIDEF void   stbi_ldr_to_hdr_scale(float scale);
+#endif // STBI_NO_LINEAR
+
+// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR
+STBIDEF int    stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user);
+STBIDEF int    stbi_is_hdr_from_memory(stbi_uc const *buffer, int len);
+#ifndef STBI_NO_STDIO
+STBIDEF int      stbi_is_hdr          (char const *filename);
+STBIDEF int      stbi_is_hdr_from_file(FILE *f);
+#endif // STBI_NO_STDIO
+
+
+// get a VERY brief reason for failure
+// NOT THREADSAFE
+STBIDEF const char *stbi_failure_reason  (void);
+
+// free the loaded image -- this is just free()
+STBIDEF void     stbi_image_free      (void *retval_from_stbi_load);
+
+// get image dimensions & components without fully decoding
+STBIDEF int      stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);
+STBIDEF int      stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp);
+STBIDEF int      stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len);
+STBIDEF int      stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user);
+
+#ifndef STBI_NO_STDIO
+STBIDEF int      stbi_info               (char const *filename,     int *x, int *y, int *comp);
+STBIDEF int      stbi_info_from_file     (FILE *f,                  int *x, int *y, int *comp);
+STBIDEF int      stbi_is_16_bit          (char const *filename);
+STBIDEF int      stbi_is_16_bit_from_file(FILE *f);
+#endif
+
+
+
+// for image formats that explicitly notate that they have premultiplied alpha,
+// we just return the colors as stored in the file. set this flag to force
+// unpremultiplication. results are undefined if the unpremultiply overflow.
+STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply);
+
+// indicate whether we should process iphone images back to canonical format,
+// or just pass them through "as-is"
+STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert);
+
+// flip the image vertically, so the first pixel in the output array is the bottom left
+STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip);
+
+// ZLIB client - used by PNG, available for other purposes
+
+STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen);
+STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header);
+STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen);
+STBIDEF int   stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
+
+STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen);
+STBIDEF int   stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+//
+//
+////   end header file   /////////////////////////////////////////////////////
+#endif // STBI_INCLUDE_STB_IMAGE_H
+
+#ifdef STB_IMAGE_IMPLEMENTATION
+
+#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \
+  || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \
+  || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \
+  || defined(STBI_ONLY_ZLIB)
+   #ifndef STBI_ONLY_JPEG
+   #define STBI_NO_JPEG
+   #endif
+   #ifndef STBI_ONLY_PNG
+   #define STBI_NO_PNG
+   #endif
+   #ifndef STBI_ONLY_BMP
+   #define STBI_NO_BMP
+   #endif
+   #ifndef STBI_ONLY_PSD
+   #define STBI_NO_PSD
+   #endif
+   #ifndef STBI_ONLY_TGA
+   #define STBI_NO_TGA
+   #endif
+   #ifndef STBI_ONLY_GIF
+   #define STBI_NO_GIF
+   #endif
+   #ifndef STBI_ONLY_HDR
+   #define STBI_NO_HDR
+   #endif
+   #ifndef STBI_ONLY_PIC
+   #define STBI_NO_PIC
+   #endif
+   #ifndef STBI_ONLY_PNM
+   #define STBI_NO_PNM
+   #endif
+#endif
+
+#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB)
+#define STBI_NO_ZLIB
+#endif
+
+
+#include <stdarg.h>
+#include <stddef.h> // ptrdiff_t on osx
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+
+#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)
+#include <math.h>  // ldexp, pow
+#endif
+
+#ifndef STBI_NO_STDIO
+#include <stdio.h>
+#endif
+
+#ifndef STBI_ASSERT
+#include <assert.h>
+#define STBI_ASSERT(x) assert(x)
+#endif
+
+#ifdef __cplusplus
+#define STBI_EXTERN extern "C"
+#else
+#define STBI_EXTERN extern
+#endif
+
+
+#ifndef _MSC_VER
+   #ifdef __cplusplus
+   #define stbi_inline inline
+   #else
+   #define stbi_inline
+   #endif
+#else
+   #define stbi_inline __forceinline
+#endif
+
+
+#ifdef _MSC_VER
+typedef unsigned short stbi__uint16;
+typedef   signed short stbi__int16;
+typedef unsigned int   stbi__uint32;
+typedef   signed int   stbi__int32;
+#else
+#include <stdint.h>
+typedef uint16_t stbi__uint16;
+typedef int16_t  stbi__int16;
+typedef uint32_t stbi__uint32;
+typedef int32_t  stbi__int32;
+#endif
+
+// should produce compiler error if size is wrong
+typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1];
+
+#ifdef _MSC_VER
+#define STBI_NOTUSED(v)  (void)(v)
+#else
+#define STBI_NOTUSED(v)  (void)sizeof(v)
+#endif
+
+#ifdef _MSC_VER
+#define STBI_HAS_LROTL
+#endif
+
+#ifdef STBI_HAS_LROTL
+   #define stbi_lrot(x,y)  _lrotl(x,y)
+#else
+   #define stbi_lrot(x,y)  (((x) << (y)) | ((x) >> (32 - (y))))
+#endif
+
+#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED))
+// ok
+#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED)
+// ok
+#else
+#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)."
+#endif
+
+#ifndef STBI_MALLOC
+#define STBI_MALLOC(sz)           malloc(sz)
+#define STBI_REALLOC(p,newsz)     realloc(p,newsz)
+#define STBI_FREE(p)              free(p)
+#endif
+
+#ifndef STBI_REALLOC_SIZED
+#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz)
+#endif
+
+// x86/x64 detection
+#if defined(__x86_64__) || defined(_M_X64)
+#define STBI__X64_TARGET
+#elif defined(__i386) || defined(_M_IX86)
+#define STBI__X86_TARGET
+#endif
+
+#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD)
+// gcc doesn't support sse2 intrinsics unless you compile with -msse2,
+// which in turn means it gets to use SSE2 everywhere. This is unfortunate,
+// but previous attempts to provide the SSE2 functions with runtime
+// detection caused numerous issues. The way architecture extensions are
+// exposed in GCC/Clang is, sadly, not really suited for one-file libs.
+// New behavior: if compiled with -msse2, we use SSE2 without any
+// detection; if not, we don't use it at all.
+#define STBI_NO_SIMD
+#endif
+
+#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD)
+// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET
+//
+// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the
+// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant.
+// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not
+// simultaneously enabling "-mstackrealign".
+//
+// See https://github.com/nothings/stb/issues/81 for more information.
+//
+// So default to no SSE2 on 32-bit MinGW. If you've read this far and added
+// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2.
+#define STBI_NO_SIMD
+#endif
+
+#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET))
+#define STBI_SSE2
+#include <emmintrin.h>
+
+#ifdef _MSC_VER
+
+#if _MSC_VER >= 1400  // not VC6
+#include <intrin.h> // __cpuid
+static int stbi__cpuid3(void)
+{
+   int info[4];
+   __cpuid(info,1);
+   return info[3];
+}
+#else
+static int stbi__cpuid3(void)
+{
+   int res;
+   __asm {
+      mov  eax,1
+      cpuid
+      mov  res,edx
+   }
+   return res;
+}
+#endif
+
+#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name
+
+#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
+static int stbi__sse2_available(void)
+{
+   int info3 = stbi__cpuid3();
+   return ((info3 >> 26) & 1) != 0;
+}
+#endif
+
+#else // assume GCC-style if not VC++
+#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
+
+#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
+static int stbi__sse2_available(void)
+{
+   // If we're even attempting to compile this on GCC/Clang, that means
+   // -msse2 is on, which means the compiler is allowed to use SSE2
+   // instructions at will, and so are we.
+   return 1;
+}
+#endif
+
+#endif
+#endif
+
+// ARM NEON
+#if defined(STBI_NO_SIMD) && defined(STBI_NEON)
+#undef STBI_NEON
+#endif
+
+#ifdef STBI_NEON
+#include <arm_neon.h>
+// assume GCC or Clang on ARM targets
+#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
+#endif
+
+#ifndef STBI_SIMD_ALIGN
+#define STBI_SIMD_ALIGN(type, name) type name
+#endif
+
+///////////////////////////////////////////////
+//
+//  stbi__context struct and start_xxx functions
+
+// stbi__context structure is our basic context used by all images, so it
+// contains all the IO context, plus some basic image information
+typedef struct
+{
+   stbi__uint32 img_x, img_y;
+   int img_n, img_out_n;
+
+   stbi_io_callbacks io;
+   void *io_user_data;
+
+   int read_from_callbacks;
+   int buflen;
+   stbi_uc buffer_start[128];
+
+   stbi_uc *img_buffer, *img_buffer_end;
+   stbi_uc *img_buffer_original, *img_buffer_original_end;
+} stbi__context;
+
+
+static void stbi__refill_buffer(stbi__context *s);
+
+// initialize a memory-decode context
+static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len)
+{
+   s->io.read = NULL;
+   s->read_from_callbacks = 0;
+   s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer;
+   s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len;
+}
+
+// initialize a callback-based context
+static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user)
+{
+   s->io = *c;
+   s->io_user_data = user;
+   s->buflen = sizeof(s->buffer_start);
+   s->read_from_callbacks = 1;
+   s->img_buffer_original = s->buffer_start;
+   stbi__refill_buffer(s);
+   s->img_buffer_original_end = s->img_buffer_end;
+}
+
+#ifndef STBI_NO_STDIO
+
+static int stbi__stdio_read(void *user, char *data, int size)
+{
+   return (int) fread(data,1,size,(FILE*) user);
+}
+
+static void stbi__stdio_skip(void *user, int n)
+{
+   fseek((FILE*) user, n, SEEK_CUR);
+}
+
+static int stbi__stdio_eof(void *user)
+{
+   return feof((FILE*) user);
+}
+
+static stbi_io_callbacks stbi__stdio_callbacks =
+{
+   stbi__stdio_read,
+   stbi__stdio_skip,
+   stbi__stdio_eof,
+};
+
+static void stbi__start_file(stbi__context *s, FILE *f)
+{
+   stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f);
+}
+
+//static void stop_file(stbi__context *s) { }
+
+#endif // !STBI_NO_STDIO
+
+static void stbi__rewind(stbi__context *s)
+{
+   // conceptually rewind SHOULD rewind to the beginning of the stream,
+   // but we just rewind to the beginning of the initial buffer, because
+   // we only use it after doing 'test', which only ever looks at at most 92 bytes
+   s->img_buffer = s->img_buffer_original;
+   s->img_buffer_end = s->img_buffer_original_end;
+}
+
+enum
+{
+   STBI_ORDER_RGB,
+   STBI_ORDER_BGR
+};
+
+typedef struct
+{
+   int bits_per_channel;
+   int num_channels;
+   int channel_order;
+} stbi__result_info;
+
+#ifndef STBI_NO_JPEG
+static int      stbi__jpeg_test(stbi__context *s);
+static void    *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_PNG
+static int      stbi__png_test(stbi__context *s);
+static void    *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__png_info(stbi__context *s, int *x, int *y, int *comp);
+static int      stbi__png_is16(stbi__context *s);
+#endif
+
+#ifndef STBI_NO_BMP
+static int      stbi__bmp_test(stbi__context *s);
+static void    *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_TGA
+static int      stbi__tga_test(stbi__context *s);
+static void    *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__tga_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_PSD
+static int      stbi__psd_test(stbi__context *s);
+static void    *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc);
+static int      stbi__psd_info(stbi__context *s, int *x, int *y, int *comp);
+static int      stbi__psd_is16(stbi__context *s);
+#endif
+
+#ifndef STBI_NO_HDR
+static int      stbi__hdr_test(stbi__context *s);
+static float   *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_PIC
+static int      stbi__pic_test(stbi__context *s);
+static void    *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__pic_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_GIF
+static int      stbi__gif_test(stbi__context *s);
+static void    *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static void    *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp);
+static int      stbi__gif_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_PNM
+static int      stbi__pnm_test(stbi__context *s);
+static void    *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+// this is not threadsafe
+static const char *stbi__g_failure_reason;
+
+STBIDEF const char *stbi_failure_reason(void)
+{
+   return stbi__g_failure_reason;
+}
+
+static int stbi__err(const char *str)
+{
+   stbi__g_failure_reason = str;
+   return 0;
+}
+
+static void *stbi__malloc(size_t size)
+{
+    return STBI_MALLOC(size);
+}
+
+// stb_image uses ints pervasively, including for offset calculations.
+// therefore the largest decoded image size we can support with the
+// current code, even on 64-bit targets, is INT_MAX. this is not a
+// significant limitation for the intended use case.
+//
+// we do, however, need to make sure our size calculations don't
+// overflow. hence a few helper functions for size calculations that
+// multiply integers together, making sure that they're non-negative
+// and no overflow occurs.
+
+// return 1 if the sum is valid, 0 on overflow.
+// negative terms are considered invalid.
+static int stbi__addsizes_valid(int a, int b)
+{
+   if (b < 0) return 0;
+   // now 0 <= b <= INT_MAX, hence also
+   // 0 <= INT_MAX - b <= INTMAX.
+   // And "a + b <= INT_MAX" (which might overflow) is the
+   // same as a <= INT_MAX - b (no overflow)
+   return a <= INT_MAX - b;
+}
+
+// returns 1 if the product is valid, 0 on overflow.
+// negative factors are considered invalid.
+static int stbi__mul2sizes_valid(int a, int b)
+{
+   if (a < 0 || b < 0) return 0;
+   if (b == 0) return 1; // mul-by-0 is always safe
+   // portable way to check for no overflows in a*b
+   return a <= INT_MAX/b;
+}
+
+// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow
+static int stbi__mad2sizes_valid(int a, int b, int add)
+{
+   return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add);
+}
+
+// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow
+static int stbi__mad3sizes_valid(int a, int b, int c, int add)
+{
+   return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
+      stbi__addsizes_valid(a*b*c, add);
+}
+
+// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow
+#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)
+static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add)
+{
+   return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
+      stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add);
+}
+#endif
+
+// mallocs with size overflow checking
+static void *stbi__malloc_mad2(int a, int b, int add)
+{
+   if (!stbi__mad2sizes_valid(a, b, add)) return NULL;
+   return stbi__malloc(a*b + add);
+}
+
+static void *stbi__malloc_mad3(int a, int b, int c, int add)
+{
+   if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL;
+   return stbi__malloc(a*b*c + add);
+}
+
+#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)
+static void *stbi__malloc_mad4(int a, int b, int c, int d, int add)
+{
+   if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL;
+   return stbi__malloc(a*b*c*d + add);
+}
+#endif
+
+// stbi__err - error
+// stbi__errpf - error returning pointer to float
+// stbi__errpuc - error returning pointer to unsigned char
+
+#ifdef STBI_NO_FAILURE_STRINGS
+   #define stbi__err(x,y)  0
+#elif defined(STBI_FAILURE_USERMSG)
+   #define stbi__err(x,y)  stbi__err(y)
+#else
+   #define stbi__err(x,y)  stbi__err(x)
+#endif
+
+#define stbi__errpf(x,y)   ((float *)(size_t) (stbi__err(x,y)?NULL:NULL))
+#define stbi__errpuc(x,y)  ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL))
+
+STBIDEF void stbi_image_free(void *retval_from_stbi_load)
+{
+   STBI_FREE(retval_from_stbi_load);
+}
+
+#ifndef STBI_NO_LINEAR
+static float   *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp);
+#endif
+
+#ifndef STBI_NO_HDR
+static stbi_uc *stbi__hdr_to_ldr(float   *data, int x, int y, int comp);
+#endif
+
+static int stbi__vertically_flip_on_load = 0;
+
+STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip)
+{
+    stbi__vertically_flip_on_load = flag_true_if_should_flip;
+}
+
+static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)
+{
+   memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields
+   ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed
+   ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order
+   ri->num_channels = 0;
+
+   #ifndef STBI_NO_JPEG
+   if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri);
+   #endif
+   #ifndef STBI_NO_PNG
+   if (stbi__png_test(s))  return stbi__png_load(s,x,y,comp,req_comp, ri);
+   #endif
+   #ifndef STBI_NO_BMP
+   if (stbi__bmp_test(s))  return stbi__bmp_load(s,x,y,comp,req_comp, ri);
+   #endif
+   #ifndef STBI_NO_GIF
+   if (stbi__gif_test(s))  return stbi__gif_load(s,x,y,comp,req_comp, ri);
+   #endif
+   #ifndef STBI_NO_PSD
+   if (stbi__psd_test(s))  return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc);
+   #endif
+   #ifndef STBI_NO_PIC
+   if (stbi__pic_test(s))  return stbi__pic_load(s,x,y,comp,req_comp, ri);
+   #endif
+   #ifndef STBI_NO_PNM
+   if (stbi__pnm_test(s))  return stbi__pnm_load(s,x,y,comp,req_comp, ri);
+   #endif
+
+   #ifndef STBI_NO_HDR
+   if (stbi__hdr_test(s)) {
+      float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri);
+      return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp);
+   }
+   #endif
+
+   #ifndef STBI_NO_TGA
+   // test tga last because it's a crappy test!
+   if (stbi__tga_test(s))
+      return stbi__tga_load(s,x,y,comp,req_comp, ri);
+   #endif
+
+   return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt");
+}
+
+static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels)
+{
+   int i;
+   int img_len = w * h * channels;
+   stbi_uc *reduced;
+
+   reduced = (stbi_uc *) stbi__malloc(img_len);
+   if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory");
+
+   for (i = 0; i < img_len; ++i)
+      reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling
+
+   STBI_FREE(orig);
+   return reduced;
+}
+
+static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels)
+{
+   int i;
+   int img_len = w * h * channels;
+   stbi__uint16 *enlarged;
+
+   enlarged = (stbi__uint16 *) stbi__malloc(img_len*2);
+   if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory");
+
+   for (i = 0; i < img_len; ++i)
+      enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff
+
+   STBI_FREE(orig);
+   return enlarged;
+}
+
+static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel)
+{
+   int row;
+   size_t bytes_per_row = (size_t)w * bytes_per_pixel;
+   stbi_uc temp[2048];
+   stbi_uc *bytes = (stbi_uc *)image;
+
+   for (row = 0; row < (h>>1); row++) {
+      stbi_uc *row0 = bytes + row*bytes_per_row;
+      stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row;
+      // swap row0 with row1
+      size_t bytes_left = bytes_per_row;
+      while (bytes_left) {
+         size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp);
+         memcpy(temp, row0, bytes_copy);
+         memcpy(row0, row1, bytes_copy);
+         memcpy(row1, temp, bytes_copy);
+         row0 += bytes_copy;
+         row1 += bytes_copy;
+         bytes_left -= bytes_copy;
+      }
+   }
+}
+
+#ifndef STBI_NO_GIF
+static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel)
+{
+   int slice;
+   int slice_size = w * h * bytes_per_pixel;
+
+   stbi_uc *bytes = (stbi_uc *)image;
+   for (slice = 0; slice < z; ++slice) {
+      stbi__vertical_flip(bytes, w, h, bytes_per_pixel); 
+      bytes += slice_size; 
+   }
+}
+#endif
+
+static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__result_info ri;
+   void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8);
+
+   if (result == NULL)
+      return NULL;
+
+   if (ri.bits_per_channel != 8) {
+      STBI_ASSERT(ri.bits_per_channel == 16);
+      result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp);
+      ri.bits_per_channel = 8;
+   }
+
+   // @TODO: move stbi__convert_format to here
+
+   if (stbi__vertically_flip_on_load) {
+      int channels = req_comp ? req_comp : *comp;
+      stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc));
+   }
+
+   return (unsigned char *) result;
+}
+
+static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__result_info ri;
+   void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16);
+
+   if (result == NULL)
+      return NULL;
+
+   if (ri.bits_per_channel != 16) {
+      STBI_ASSERT(ri.bits_per_channel == 8);
+      result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp);
+      ri.bits_per_channel = 16;
+   }
+
+   // @TODO: move stbi__convert_format16 to here
+   // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision
+
+   if (stbi__vertically_flip_on_load) {
+      int channels = req_comp ? req_comp : *comp;
+      stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16));
+   }
+
+   return (stbi__uint16 *) result;
+}
+
+#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR)
+static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp)
+{
+   if (stbi__vertically_flip_on_load && result != NULL) {
+      int channels = req_comp ? req_comp : *comp;
+      stbi__vertical_flip(result, *x, *y, channels * sizeof(float));
+   }
+}
+#endif
+
+#ifndef STBI_NO_STDIO
+
+#if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8)
+STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide);
+STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default);
+#endif
+
+#if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8)
+STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)
+{
+	return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL);
+}
+#endif
+
+static FILE *stbi__fopen(char const *filename, char const *mode)
+{
+   FILE *f;
+#if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8)
+   wchar_t wMode[64];
+   wchar_t wFilename[1024];
+	if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)))
+      return 0;
+	
+	if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)))
+      return 0;
+
+#if _MSC_VER >= 1400
+	if (0 != _wfopen_s(&f, wFilename, wMode))
+		f = 0;
+#else
+   f = _wfopen(wFilename, wMode);
+#endif
+
+#elif defined(_MSC_VER) && _MSC_VER >= 1400
+   if (0 != fopen_s(&f, filename, mode))
+      f=0;
+#else
+   f = fopen(filename, mode);
+#endif
+   return f;
+}
+
+
+STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)
+{
+   FILE *f = stbi__fopen(filename, "rb");
+   unsigned char *result;
+   if (!f) return stbi__errpuc("can't fopen", "Unable to open file");
+   result = stbi_load_from_file(f,x,y,comp,req_comp);
+   fclose(f);
+   return result;
+}
+
+STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
+{
+   unsigned char *result;
+   stbi__context s;
+   stbi__start_file(&s,f);
+   result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
+   if (result) {
+      // need to 'unget' all the characters in the IO buffer
+      fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
+   }
+   return result;
+}
+
+STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__uint16 *result;
+   stbi__context s;
+   stbi__start_file(&s,f);
+   result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp);
+   if (result) {
+      // need to 'unget' all the characters in the IO buffer
+      fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
+   }
+   return result;
+}
+
+STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp)
+{
+   FILE *f = stbi__fopen(filename, "rb");
+   stbi__uint16 *result;
+   if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file");
+   result = stbi_load_from_file_16(f,x,y,comp,req_comp);
+   fclose(f);
+   return result;
+}
+
+
+#endif //!STBI_NO_STDIO
+
+STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels)
+{
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
+}
+
+STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels)
+{
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user);
+   return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
+}
+
+STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
+}
+
+STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+   return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
+}
+
+#ifndef STBI_NO_GIF
+STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp)
+{
+   unsigned char *result;
+   stbi__context s; 
+   stbi__start_mem(&s,buffer,len); 
+   
+   result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp);
+   if (stbi__vertically_flip_on_load) {
+      stbi__vertical_flip_slices( result, *x, *y, *z, *comp ); 
+   }
+
+   return result; 
+}
+#endif
+
+#ifndef STBI_NO_LINEAR
+static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp)
+{
+   unsigned char *data;
+   #ifndef STBI_NO_HDR
+   if (stbi__hdr_test(s)) {
+      stbi__result_info ri;
+      float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri);
+      if (hdr_data)
+         stbi__float_postprocess(hdr_data,x,y,comp,req_comp);
+      return hdr_data;
+   }
+   #endif
+   data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp);
+   if (data)
+      return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);
+   return stbi__errpf("unknown image type", "Image not of any known type, or corrupt");
+}
+
+STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__loadf_main(&s,x,y,comp,req_comp);
+}
+
+STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+   return stbi__loadf_main(&s,x,y,comp,req_comp);
+}
+
+#ifndef STBI_NO_STDIO
+STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)
+{
+   float *result;
+   FILE *f = stbi__fopen(filename, "rb");
+   if (!f) return stbi__errpf("can't fopen", "Unable to open file");
+   result = stbi_loadf_from_file(f,x,y,comp,req_comp);
+   fclose(f);
+   return result;
+}
+
+STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__context s;
+   stbi__start_file(&s,f);
+   return stbi__loadf_main(&s,x,y,comp,req_comp);
+}
+#endif // !STBI_NO_STDIO
+
+#endif // !STBI_NO_LINEAR
+
+// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is
+// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always
+// reports false!
+
+STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)
+{
+   #ifndef STBI_NO_HDR
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__hdr_test(&s);
+   #else
+   STBI_NOTUSED(buffer);
+   STBI_NOTUSED(len);
+   return 0;
+   #endif
+}
+
+#ifndef STBI_NO_STDIO
+STBIDEF int      stbi_is_hdr          (char const *filename)
+{
+   FILE *f = stbi__fopen(filename, "rb");
+   int result=0;
+   if (f) {
+      result = stbi_is_hdr_from_file(f);
+      fclose(f);
+   }
+   return result;
+}
+
+STBIDEF int stbi_is_hdr_from_file(FILE *f)
+{
+   #ifndef STBI_NO_HDR
+   long pos = ftell(f);
+   int res;
+   stbi__context s;
+   stbi__start_file(&s,f);
+   res = stbi__hdr_test(&s);
+   fseek(f, pos, SEEK_SET);
+   return res;
+   #else
+   STBI_NOTUSED(f);
+   return 0;
+   #endif
+}
+#endif // !STBI_NO_STDIO
+
+STBIDEF int      stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user)
+{
+   #ifndef STBI_NO_HDR
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+   return stbi__hdr_test(&s);
+   #else
+   STBI_NOTUSED(clbk);
+   STBI_NOTUSED(user);
+   return 0;
+   #endif
+}
+
+#ifndef STBI_NO_LINEAR
+static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f;
+
+STBIDEF void   stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; }
+STBIDEF void   stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; }
+#endif
+
+static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f;
+
+STBIDEF void   stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; }
+STBIDEF void   stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; }
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Common code used by all image loaders
+//
+
+enum
+{
+   STBI__SCAN_load=0,
+   STBI__SCAN_type,
+   STBI__SCAN_header
+};
+
+static void stbi__refill_buffer(stbi__context *s)
+{
+   int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen);
+   if (n == 0) {
+      // at end of file, treat same as if from memory, but need to handle case
+      // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file
+      s->read_from_callbacks = 0;
+      s->img_buffer = s->buffer_start;
+      s->img_buffer_end = s->buffer_start+1;
+      *s->img_buffer = 0;
+   } else {
+      s->img_buffer = s->buffer_start;
+      s->img_buffer_end = s->buffer_start + n;
+   }
+}
+
+stbi_inline static stbi_uc stbi__get8(stbi__context *s)
+{
+   if (s->img_buffer < s->img_buffer_end)
+      return *s->img_buffer++;
+   if (s->read_from_callbacks) {
+      stbi__refill_buffer(s);
+      return *s->img_buffer++;
+   }
+   return 0;
+}
+
+stbi_inline static int stbi__at_eof(stbi__context *s)
+{
+   if (s->io.read) {
+      if (!(s->io.eof)(s->io_user_data)) return 0;
+      // if feof() is true, check if buffer = end
+      // special case: we've only got the special 0 character at the end
+      if (s->read_from_callbacks == 0) return 1;
+   }
+
+   return s->img_buffer >= s->img_buffer_end;
+}
+
+static void stbi__skip(stbi__context *s, int n)
+{
+   if (n < 0) {
+      s->img_buffer = s->img_buffer_end;
+      return;
+   }
+   if (s->io.read) {
+      int blen = (int) (s->img_buffer_end - s->img_buffer);
+      if (blen < n) {
+         s->img_buffer = s->img_buffer_end;
+         (s->io.skip)(s->io_user_data, n - blen);
+         return;
+      }
+   }
+   s->img_buffer += n;
+}
+
+static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)
+{
+   if (s->io.read) {
+      int blen = (int) (s->img_buffer_end - s->img_buffer);
+      if (blen < n) {
+         int res, count;
+
+         memcpy(buffer, s->img_buffer, blen);
+
+         count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen);
+         res = (count == (n-blen));
+         s->img_buffer = s->img_buffer_end;
+         return res;
+      }
+   }
+
+   if (s->img_buffer+n <= s->img_buffer_end) {
+      memcpy(buffer, s->img_buffer, n);
+      s->img_buffer += n;
+      return 1;
+   } else
+      return 0;
+}
+
+static int stbi__get16be(stbi__context *s)
+{
+   int z = stbi__get8(s);
+   return (z << 8) + stbi__get8(s);
+}
+
+static stbi__uint32 stbi__get32be(stbi__context *s)
+{
+   stbi__uint32 z = stbi__get16be(s);
+   return (z << 16) + stbi__get16be(s);
+}
+
+#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF)
+// nothing
+#else
+static int stbi__get16le(stbi__context *s)
+{
+   int z = stbi__get8(s);
+   return z + (stbi__get8(s) << 8);
+}
+#endif
+
+#ifndef STBI_NO_BMP
+static stbi__uint32 stbi__get32le(stbi__context *s)
+{
+   stbi__uint32 z = stbi__get16le(s);
+   return z + (stbi__get16le(s) << 16);
+}
+#endif
+
+#define STBI__BYTECAST(x)  ((stbi_uc) ((x) & 255))  // truncate int to byte without warnings
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  generic converter from built-in img_n to req_comp
+//    individual types do this automatically as much as possible (e.g. jpeg
+//    does all cases internally since it needs to colorspace convert anyway,
+//    and it never has alpha, so very few cases ). png can automatically
+//    interleave an alpha=255 channel, but falls back to this for other cases
+//
+//  assume data buffer is malloced, so malloc a new one and free that one
+//  only failure mode is malloc failing
+
+static stbi_uc stbi__compute_y(int r, int g, int b)
+{
+   return (stbi_uc) (((r*77) + (g*150) +  (29*b)) >> 8);
+}
+
+static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y)
+{
+   int i,j;
+   unsigned char *good;
+
+   if (req_comp == img_n) return data;
+   STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
+
+   good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0);
+   if (good == NULL) {
+      STBI_FREE(data);
+      return stbi__errpuc("outofmem", "Out of memory");
+   }
+
+   for (j=0; j < (int) y; ++j) {
+      unsigned char *src  = data + j * x * img_n   ;
+      unsigned char *dest = good + j * x * req_comp;
+
+      #define STBI__COMBO(a,b)  ((a)*8+(b))
+      #define STBI__CASE(a,b)   case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
+      // convert source image with img_n components to one with req_comp components;
+      // avoid switch per pixel, so use switch per scanline and massive macros
+      switch (STBI__COMBO(img_n, req_comp)) {
+         STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255;                                     } break;
+         STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0];                                  } break;
+         STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255;                     } break;
+         STBI__CASE(2,1) { dest[0]=src[0];                                                  } break;
+         STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0];                                  } break;
+         STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1];                  } break;
+         STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255;        } break;
+         STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]);                   } break;
+         STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255;    } break;
+         STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]);                   } break;
+         STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break;
+         STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];                    } break;
+         default: STBI_ASSERT(0);
+      }
+      #undef STBI__CASE
+   }
+
+   STBI_FREE(data);
+   return good;
+}
+
+static stbi__uint16 stbi__compute_y_16(int r, int g, int b)
+{
+   return (stbi__uint16) (((r*77) + (g*150) +  (29*b)) >> 8);
+}
+
+static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y)
+{
+   int i,j;
+   stbi__uint16 *good;
+
+   if (req_comp == img_n) return data;
+   STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
+
+   good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2);
+   if (good == NULL) {
+      STBI_FREE(data);
+      return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory");
+   }
+
+   for (j=0; j < (int) y; ++j) {
+      stbi__uint16 *src  = data + j * x * img_n   ;
+      stbi__uint16 *dest = good + j * x * req_comp;
+
+      #define STBI__COMBO(a,b)  ((a)*8+(b))
+      #define STBI__CASE(a,b)   case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
+      // convert source image with img_n components to one with req_comp components;
+      // avoid switch per pixel, so use switch per scanline and massive macros
+      switch (STBI__COMBO(img_n, req_comp)) {
+         STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff;                                     } break;
+         STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0];                                     } break;
+         STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff;                     } break;
+         STBI__CASE(2,1) { dest[0]=src[0];                                                     } break;
+         STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0];                                     } break;
+         STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1];                     } break;
+         STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff;        } break;
+         STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]);                   } break;
+         STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; } break;
+         STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]);                   } break;
+         STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; } break;
+         STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];                       } break;
+         default: STBI_ASSERT(0);
+      }
+      #undef STBI__CASE
+   }
+
+   STBI_FREE(data);
+   return good;
+}
+
+#ifndef STBI_NO_LINEAR
+static float   *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
+{
+   int i,k,n;
+   float *output;
+   if (!data) return NULL;
+   output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0);
+   if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); }
+   // compute number of non-alpha components
+   if (comp & 1) n = comp; else n = comp-1;
+   for (i=0; i < x*y; ++i) {
+      for (k=0; k < n; ++k) {
+         output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale);
+      }
+   }
+   if (n < comp) {
+      for (i=0; i < x*y; ++i) {
+         output[i*comp + n] = data[i*comp + n]/255.0f;
+      }
+   }
+   STBI_FREE(data);
+   return output;
+}
+#endif
+
+#ifndef STBI_NO_HDR
+#define stbi__float2int(x)   ((int) (x))
+static stbi_uc *stbi__hdr_to_ldr(float   *data, int x, int y, int comp)
+{
+   int i,k,n;
+   stbi_uc *output;
+   if (!data) return NULL;
+   output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0);
+   if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); }
+   // compute number of non-alpha components
+   if (comp & 1) n = comp; else n = comp-1;
+   for (i=0; i < x*y; ++i) {
+      for (k=0; k < n; ++k) {
+         float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f;
+         if (z < 0) z = 0;
+         if (z > 255) z = 255;
+         output[i*comp + k] = (stbi_uc) stbi__float2int(z);
+      }
+      if (k < comp) {
+         float z = data[i*comp+k] * 255 + 0.5f;
+         if (z < 0) z = 0;
+         if (z > 255) z = 255;
+         output[i*comp + k] = (stbi_uc) stbi__float2int(z);
+      }
+   }
+   STBI_FREE(data);
+   return output;
+}
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  "baseline" JPEG/JFIF decoder
+//
+//    simple implementation
+//      - doesn't support delayed output of y-dimension
+//      - simple interface (only one output format: 8-bit interleaved RGB)
+//      - doesn't try to recover corrupt jpegs
+//      - doesn't allow partial loading, loading multiple at once
+//      - still fast on x86 (copying globals into locals doesn't help x86)
+//      - allocates lots of intermediate memory (full size of all components)
+//        - non-interleaved case requires this anyway
+//        - allows good upsampling (see next)
+//    high-quality
+//      - upsampled channels are bilinearly interpolated, even across blocks
+//      - quality integer IDCT derived from IJG's 'slow'
+//    performance
+//      - fast huffman; reasonable integer IDCT
+//      - some SIMD kernels for common paths on targets with SSE2/NEON
+//      - uses a lot of intermediate memory, could cache poorly
+
+#ifndef STBI_NO_JPEG
+
+// huffman decoding acceleration
+#define FAST_BITS   9  // larger handles more cases; smaller stomps less cache
+
+typedef struct
+{
+   stbi_uc  fast[1 << FAST_BITS];
+   // weirdly, repacking this into AoS is a 10% speed loss, instead of a win
+   stbi__uint16 code[256];
+   stbi_uc  values[256];
+   stbi_uc  size[257];
+   unsigned int maxcode[18];
+   int    delta[17];   // old 'firstsymbol' - old 'firstcode'
+} stbi__huffman;
+
+typedef struct
+{
+   stbi__context *s;
+   stbi__huffman huff_dc[4];
+   stbi__huffman huff_ac[4];
+   stbi__uint16 dequant[4][64];
+   stbi__int16 fast_ac[4][1 << FAST_BITS];
+
+// sizes for components, interleaved MCUs
+   int img_h_max, img_v_max;
+   int img_mcu_x, img_mcu_y;
+   int img_mcu_w, img_mcu_h;
+
+// definition of jpeg image component
+   struct
+   {
+      int id;
+      int h,v;
+      int tq;
+      int hd,ha;
+      int dc_pred;
+
+      int x,y,w2,h2;
+      stbi_uc *data;
+      void *raw_data, *raw_coeff;
+      stbi_uc *linebuf;
+      short   *coeff;   // progressive only
+      int      coeff_w, coeff_h; // number of 8x8 coefficient blocks
+   } img_comp[4];
+
+   stbi__uint32   code_buffer; // jpeg entropy-coded buffer
+   int            code_bits;   // number of valid bits
+   unsigned char  marker;      // marker seen while filling entropy buffer
+   int            nomore;      // flag if we saw a marker so must stop
+
+   int            progressive;
+   int            spec_start;
+   int            spec_end;
+   int            succ_high;
+   int            succ_low;
+   int            eob_run;
+   int            jfif;
+   int            app14_color_transform; // Adobe APP14 tag
+   int            rgb;
+
+   int scan_n, order[4];
+   int restart_interval, todo;
+
+// kernels
+   void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]);
+   void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step);
+   stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs);
+} stbi__jpeg;
+
+static int stbi__build_huffman(stbi__huffman *h, int *count)
+{
+   int i,j,k=0;
+   unsigned int code;
+   // build size list for each symbol (from JPEG spec)
+   for (i=0; i < 16; ++i)
+      for (j=0; j < count[i]; ++j)
+         h->size[k++] = (stbi_uc) (i+1);
+   h->size[k] = 0;
+
+   // compute actual symbols (from jpeg spec)
+   code = 0;
+   k = 0;
+   for(j=1; j <= 16; ++j) {
+      // compute delta to add to code to compute symbol id
+      h->delta[j] = k - code;
+      if (h->size[k] == j) {
+         while (h->size[k] == j)
+            h->code[k++] = (stbi__uint16) (code++);
+         if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt JPEG");
+      }
+      // compute largest code + 1 for this size, preshifted as needed later
+      h->maxcode[j] = code << (16-j);
+      code <<= 1;
+   }
+   h->maxcode[j] = 0xffffffff;
+
+   // build non-spec acceleration table; 255 is flag for not-accelerated
+   memset(h->fast, 255, 1 << FAST_BITS);
+   for (i=0; i < k; ++i) {
+      int s = h->size[i];
+      if (s <= FAST_BITS) {
+         int c = h->code[i] << (FAST_BITS-s);
+         int m = 1 << (FAST_BITS-s);
+         for (j=0; j < m; ++j) {
+            h->fast[c+j] = (stbi_uc) i;
+         }
+      }
+   }
+   return 1;
+}
+
+// build a table that decodes both magnitude and value of small ACs in
+// one go.
+static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h)
+{
+   int i;
+   for (i=0; i < (1 << FAST_BITS); ++i) {
+      stbi_uc fast = h->fast[i];
+      fast_ac[i] = 0;
+      if (fast < 255) {
+         int rs = h->values[fast];
+         int run = (rs >> 4) & 15;
+         int magbits = rs & 15;
+         int len = h->size[fast];
+
+         if (magbits && len + magbits <= FAST_BITS) {
+            // magnitude code followed by receive_extend code
+            int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits);
+            int m = 1 << (magbits - 1);
+            if (k < m) k += (~0U << magbits) + 1;
+            // if the result is small enough, we can fit it in fast_ac table
+            if (k >= -128 && k <= 127)
+               fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits));
+         }
+      }
+   }
+}
+
+static void stbi__grow_buffer_unsafe(stbi__jpeg *j)
+{
+   do {
+      unsigned int b = j->nomore ? 0 : stbi__get8(j->s);
+      if (b == 0xff) {
+         int c = stbi__get8(j->s);
+         while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes
+         if (c != 0) {
+            j->marker = (unsigned char) c;
+            j->nomore = 1;
+            return;
+         }
+      }
+      j->code_buffer |= b << (24 - j->code_bits);
+      j->code_bits += 8;
+   } while (j->code_bits <= 24);
+}
+
+// (1 << n) - 1
+static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535};
+
+// decode a jpeg huffman value from the bitstream
+stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h)
+{
+   unsigned int temp;
+   int c,k;
+
+   if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+
+   // look at the top FAST_BITS and determine what symbol ID it is,
+   // if the code is <= FAST_BITS
+   c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
+   k = h->fast[c];
+   if (k < 255) {
+      int s = h->size[k];
+      if (s > j->code_bits)
+         return -1;
+      j->code_buffer <<= s;
+      j->code_bits -= s;
+      return h->values[k];
+   }
+
+   // naive test is to shift the code_buffer down so k bits are
+   // valid, then test against maxcode. To speed this up, we've
+   // preshifted maxcode left so that it has (16-k) 0s at the
+   // end; in other words, regardless of the number of bits, it
+   // wants to be compared against something shifted to have 16;
+   // that way we don't need to shift inside the loop.
+   temp = j->code_buffer >> 16;
+   for (k=FAST_BITS+1 ; ; ++k)
+      if (temp < h->maxcode[k])
+         break;
+   if (k == 17) {
+      // error! code not found
+      j->code_bits -= 16;
+      return -1;
+   }
+
+   if (k > j->code_bits)
+      return -1;
+
+   // convert the huffman code to the symbol id
+   c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k];
+   STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]);
+
+   // convert the id to a symbol
+   j->code_bits -= k;
+   j->code_buffer <<= k;
+   return h->values[c];
+}
+
+// bias[n] = (-1<<n) + 1
+static const int stbi__jbias[16] = {0,-1,-3,-7,-15,-31,-63,-127,-255,-511,-1023,-2047,-4095,-8191,-16383,-32767};
+
+// combined JPEG 'receive' and JPEG 'extend', since baseline
+// always extends everything it receives.
+stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)
+{
+   unsigned int k;
+   int sgn;
+   if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
+
+   sgn = (stbi__int32)j->code_buffer >> 31; // sign bit is always in MSB
+   k = stbi_lrot(j->code_buffer, n);
+   STBI_ASSERT(n >= 0 && n < (int) (sizeof(stbi__bmask)/sizeof(*stbi__bmask)));
+   j->code_buffer = k & ~stbi__bmask[n];
+   k &= stbi__bmask[n];
+   j->code_bits -= n;
+   return k + (stbi__jbias[n] & ~sgn);
+}
+
+// get some unsigned bits
+stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n)
+{
+   unsigned int k;
+   if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
+   k = stbi_lrot(j->code_buffer, n);
+   j->code_buffer = k & ~stbi__bmask[n];
+   k &= stbi__bmask[n];
+   j->code_bits -= n;
+   return k;
+}
+
+stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j)
+{
+   unsigned int k;
+   if (j->code_bits < 1) stbi__grow_buffer_unsafe(j);
+   k = j->code_buffer;
+   j->code_buffer <<= 1;
+   --j->code_bits;
+   return k & 0x80000000;
+}
+
+// given a value that's at position X in the zigzag stream,
+// where does it appear in the 8x8 matrix coded as row-major?
+static const stbi_uc stbi__jpeg_dezigzag[64+15] =
+{
+    0,  1,  8, 16,  9,  2,  3, 10,
+   17, 24, 32, 25, 18, 11,  4,  5,
+   12, 19, 26, 33, 40, 48, 41, 34,
+   27, 20, 13,  6,  7, 14, 21, 28,
+   35, 42, 49, 56, 57, 50, 43, 36,
+   29, 22, 15, 23, 30, 37, 44, 51,
+   58, 59, 52, 45, 38, 31, 39, 46,
+   53, 60, 61, 54, 47, 55, 62, 63,
+   // let corrupt input sample past end
+   63, 63, 63, 63, 63, 63, 63, 63,
+   63, 63, 63, 63, 63, 63, 63
+};
+
+// decode one 64-entry block--
+static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant)
+{
+   int diff,dc,k;
+   int t;
+
+   if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+   t = stbi__jpeg_huff_decode(j, hdc);
+   if (t < 0) return stbi__err("bad huffman code","Corrupt JPEG");
+
+   // 0 all the ac values now so we can do it 32-bits at a time
+   memset(data,0,64*sizeof(data[0]));
+
+   diff = t ? stbi__extend_receive(j, t) : 0;
+   dc = j->img_comp[b].dc_pred + diff;
+   j->img_comp[b].dc_pred = dc;
+   data[0] = (short) (dc * dequant[0]);
+
+   // decode AC components, see JPEG spec
+   k = 1;
+   do {
+      unsigned int zig;
+      int c,r,s;
+      if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+      c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
+      r = fac[c];
+      if (r) { // fast-AC path
+         k += (r >> 4) & 15; // run
+         s = r & 15; // combined length
+         j->code_buffer <<= s;
+         j->code_bits -= s;
+         // decode into unzigzag'd location
+         zig = stbi__jpeg_dezigzag[k++];
+         data[zig] = (short) ((r >> 8) * dequant[zig]);
+      } else {
+         int rs = stbi__jpeg_huff_decode(j, hac);
+         if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
+         s = rs & 15;
+         r = rs >> 4;
+         if (s == 0) {
+            if (rs != 0xf0) break; // end block
+            k += 16;
+         } else {
+            k += r;
+            // decode into unzigzag'd location
+            zig = stbi__jpeg_dezigzag[k++];
+            data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]);
+         }
+      }
+   } while (k < 64);
+   return 1;
+}
+
+static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b)
+{
+   int diff,dc;
+   int t;
+   if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
+
+   if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+
+   if (j->succ_high == 0) {
+      // first scan for DC coefficient, must be first
+      memset(data,0,64*sizeof(data[0])); // 0 all the ac values now
+      t = stbi__jpeg_huff_decode(j, hdc);
+      diff = t ? stbi__extend_receive(j, t) : 0;
+
+      dc = j->img_comp[b].dc_pred + diff;
+      j->img_comp[b].dc_pred = dc;
+      data[0] = (short) (dc << j->succ_low);
+   } else {
+      // refinement scan for DC coefficient
+      if (stbi__jpeg_get_bit(j))
+         data[0] += (short) (1 << j->succ_low);
+   }
+   return 1;
+}
+
+// @OPTIMIZE: store non-zigzagged during the decode passes,
+// and only de-zigzag when dequantizing
+static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac)
+{
+   int k;
+   if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
+
+   if (j->succ_high == 0) {
+      int shift = j->succ_low;
+
+      if (j->eob_run) {
+         --j->eob_run;
+         return 1;
+      }
+
+      k = j->spec_start;
+      do {
+         unsigned int zig;
+         int c,r,s;
+         if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+         c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
+         r = fac[c];
+         if (r) { // fast-AC path
+            k += (r >> 4) & 15; // run
+            s = r & 15; // combined length
+            j->code_buffer <<= s;
+            j->code_bits -= s;
+            zig = stbi__jpeg_dezigzag[k++];
+            data[zig] = (short) ((r >> 8) << shift);
+         } else {
+            int rs = stbi__jpeg_huff_decode(j, hac);
+            if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
+            s = rs & 15;
+            r = rs >> 4;
+            if (s == 0) {
+               if (r < 15) {
+                  j->eob_run = (1 << r);
+                  if (r)
+                     j->eob_run += stbi__jpeg_get_bits(j, r);
+                  --j->eob_run;
+                  break;
+               }
+               k += 16;
+            } else {
+               k += r;
+               zig = stbi__jpeg_dezigzag[k++];
+               data[zig] = (short) (stbi__extend_receive(j,s) << shift);
+            }
+         }
+      } while (k <= j->spec_end);
+   } else {
+      // refinement scan for these AC coefficients
+
+      short bit = (short) (1 << j->succ_low);
+
+      if (j->eob_run) {
+         --j->eob_run;
+         for (k = j->spec_start; k <= j->spec_end; ++k) {
+            short *p = &data[stbi__jpeg_dezigzag[k]];
+            if (*p != 0)
+               if (stbi__jpeg_get_bit(j))
+                  if ((*p & bit)==0) {
+                     if (*p > 0)
+                        *p += bit;
+                     else
+                        *p -= bit;
+                  }
+         }
+      } else {
+         k = j->spec_start;
+         do {
+            int r,s;
+            int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh
+            if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
+            s = rs & 15;
+            r = rs >> 4;
+            if (s == 0) {
+               if (r < 15) {
+                  j->eob_run = (1 << r) - 1;
+                  if (r)
+                     j->eob_run += stbi__jpeg_get_bits(j, r);
+                  r = 64; // force end of block
+               } else {
+                  // r=15 s=0 should write 16 0s, so we just do
+                  // a run of 15 0s and then write s (which is 0),
+                  // so we don't have to do anything special here
+               }
+            } else {
+               if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG");
+               // sign bit
+               if (stbi__jpeg_get_bit(j))
+                  s = bit;
+               else
+                  s = -bit;
+            }
+
+            // advance by r
+            while (k <= j->spec_end) {
+               short *p = &data[stbi__jpeg_dezigzag[k++]];
+               if (*p != 0) {
+                  if (stbi__jpeg_get_bit(j))
+                     if ((*p & bit)==0) {
+                        if (*p > 0)
+                           *p += bit;
+                        else
+                           *p -= bit;
+                     }
+               } else {
+                  if (r == 0) {
+                     *p = (short) s;
+                     break;
+                  }
+                  --r;
+               }
+            }
+         } while (k <= j->spec_end);
+      }
+   }
+   return 1;
+}
+
+// take a -128..127 value and stbi__clamp it and convert to 0..255
+stbi_inline static stbi_uc stbi__clamp(int x)
+{
+   // trick to use a single test to catch both cases
+   if ((unsigned int) x > 255) {
+      if (x < 0) return 0;
+      if (x > 255) return 255;
+   }
+   return (stbi_uc) x;
+}
+
+#define stbi__f2f(x)  ((int) (((x) * 4096 + 0.5)))
+#define stbi__fsh(x)  ((x) * 4096)
+
+// derived from jidctint -- DCT_ISLOW
+#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \
+   int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \
+   p2 = s2;                                    \
+   p3 = s6;                                    \
+   p1 = (p2+p3) * stbi__f2f(0.5411961f);       \
+   t2 = p1 + p3*stbi__f2f(-1.847759065f);      \
+   t3 = p1 + p2*stbi__f2f( 0.765366865f);      \
+   p2 = s0;                                    \
+   p3 = s4;                                    \
+   t0 = stbi__fsh(p2+p3);                      \
+   t1 = stbi__fsh(p2-p3);                      \
+   x0 = t0+t3;                                 \
+   x3 = t0-t3;                                 \
+   x1 = t1+t2;                                 \
+   x2 = t1-t2;                                 \
+   t0 = s7;                                    \
+   t1 = s5;                                    \
+   t2 = s3;                                    \
+   t3 = s1;                                    \
+   p3 = t0+t2;                                 \
+   p4 = t1+t3;                                 \
+   p1 = t0+t3;                                 \
+   p2 = t1+t2;                                 \
+   p5 = (p3+p4)*stbi__f2f( 1.175875602f);      \
+   t0 = t0*stbi__f2f( 0.298631336f);           \
+   t1 = t1*stbi__f2f( 2.053119869f);           \
+   t2 = t2*stbi__f2f( 3.072711026f);           \
+   t3 = t3*stbi__f2f( 1.501321110f);           \
+   p1 = p5 + p1*stbi__f2f(-0.899976223f);      \
+   p2 = p5 + p2*stbi__f2f(-2.562915447f);      \
+   p3 = p3*stbi__f2f(-1.961570560f);           \
+   p4 = p4*stbi__f2f(-0.390180644f);           \
+   t3 += p1+p4;                                \
+   t2 += p2+p3;                                \
+   t1 += p2+p4;                                \
+   t0 += p1+p3;
+
+static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64])
+{
+   int i,val[64],*v=val;
+   stbi_uc *o;
+   short *d = data;
+
+   // columns
+   for (i=0; i < 8; ++i,++d, ++v) {
+      // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing
+      if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0
+           && d[40]==0 && d[48]==0 && d[56]==0) {
+         //    no shortcut                 0     seconds
+         //    (1|2|3|4|5|6|7)==0          0     seconds
+         //    all separate               -0.047 seconds
+         //    1 && 2|3 && 4|5 && 6|7:    -0.047 seconds
+         int dcterm = d[0]*4;
+         v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm;
+      } else {
+         STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56])
+         // constants scaled things up by 1<<12; let's bring them back
+         // down, but keep 2 extra bits of precision
+         x0 += 512; x1 += 512; x2 += 512; x3 += 512;
+         v[ 0] = (x0+t3) >> 10;
+         v[56] = (x0-t3) >> 10;
+         v[ 8] = (x1+t2) >> 10;
+         v[48] = (x1-t2) >> 10;
+         v[16] = (x2+t1) >> 10;
+         v[40] = (x2-t1) >> 10;
+         v[24] = (x3+t0) >> 10;
+         v[32] = (x3-t0) >> 10;
+      }
+   }
+
+   for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) {
+      // no fast case since the first 1D IDCT spread components out
+      STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7])
+      // constants scaled things up by 1<<12, plus we had 1<<2 from first
+      // loop, plus horizontal and vertical each scale by sqrt(8) so together
+      // we've got an extra 1<<3, so 1<<17 total we need to remove.
+      // so we want to round that, which means adding 0.5 * 1<<17,
+      // aka 65536. Also, we'll end up with -128 to 127 that we want
+      // to encode as 0..255 by adding 128, so we'll add that before the shift
+      x0 += 65536 + (128<<17);
+      x1 += 65536 + (128<<17);
+      x2 += 65536 + (128<<17);
+      x3 += 65536 + (128<<17);
+      // tried computing the shifts into temps, or'ing the temps to see
+      // if any were out of range, but that was slower
+      o[0] = stbi__clamp((x0+t3) >> 17);
+      o[7] = stbi__clamp((x0-t3) >> 17);
+      o[1] = stbi__clamp((x1+t2) >> 17);
+      o[6] = stbi__clamp((x1-t2) >> 17);
+      o[2] = stbi__clamp((x2+t1) >> 17);
+      o[5] = stbi__clamp((x2-t1) >> 17);
+      o[3] = stbi__clamp((x3+t0) >> 17);
+      o[4] = stbi__clamp((x3-t0) >> 17);
+   }
+}
+
+#ifdef STBI_SSE2
+// sse2 integer IDCT. not the fastest possible implementation but it
+// produces bit-identical results to the generic C version so it's
+// fully "transparent".
+static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
+{
+   // This is constructed to match our regular (generic) integer IDCT exactly.
+   __m128i row0, row1, row2, row3, row4, row5, row6, row7;
+   __m128i tmp;
+
+   // dot product constant: even elems=x, odd elems=y
+   #define dct_const(x,y)  _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y))
+
+   // out(0) = c0[even]*x + c0[odd]*y   (c0, x, y 16-bit, out 32-bit)
+   // out(1) = c1[even]*x + c1[odd]*y
+   #define dct_rot(out0,out1, x,y,c0,c1) \
+      __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \
+      __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \
+      __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \
+      __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \
+      __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \
+      __m128i out1##_h = _mm_madd_epi16(c0##hi, c1)
+
+   // out = in << 12  (in 16-bit, out 32-bit)
+   #define dct_widen(out, in) \
+      __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \
+      __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4)
+
+   // wide add
+   #define dct_wadd(out, a, b) \
+      __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \
+      __m128i out##_h = _mm_add_epi32(a##_h, b##_h)
+
+   // wide sub
+   #define dct_wsub(out, a, b) \
+      __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \
+      __m128i out##_h = _mm_sub_epi32(a##_h, b##_h)
+
+   // butterfly a/b, add bias, then shift by "s" and pack
+   #define dct_bfly32o(out0, out1, a,b,bias,s) \
+      { \
+         __m128i abiased_l = _mm_add_epi32(a##_l, bias); \
+         __m128i abiased_h = _mm_add_epi32(a##_h, bias); \
+         dct_wadd(sum, abiased, b); \
+         dct_wsub(dif, abiased, b); \
+         out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \
+         out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \
+      }
+
+   // 8-bit interleave step (for transposes)
+   #define dct_interleave8(a, b) \
+      tmp = a; \
+      a = _mm_unpacklo_epi8(a, b); \
+      b = _mm_unpackhi_epi8(tmp, b)
+
+   // 16-bit interleave step (for transposes)
+   #define dct_interleave16(a, b) \
+      tmp = a; \
+      a = _mm_unpacklo_epi16(a, b); \
+      b = _mm_unpackhi_epi16(tmp, b)
+
+   #define dct_pass(bias,shift) \
+      { \
+         /* even part */ \
+         dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \
+         __m128i sum04 = _mm_add_epi16(row0, row4); \
+         __m128i dif04 = _mm_sub_epi16(row0, row4); \
+         dct_widen(t0e, sum04); \
+         dct_widen(t1e, dif04); \
+         dct_wadd(x0, t0e, t3e); \
+         dct_wsub(x3, t0e, t3e); \
+         dct_wadd(x1, t1e, t2e); \
+         dct_wsub(x2, t1e, t2e); \
+         /* odd part */ \
+         dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \
+         dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \
+         __m128i sum17 = _mm_add_epi16(row1, row7); \
+         __m128i sum35 = _mm_add_epi16(row3, row5); \
+         dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \
+         dct_wadd(x4, y0o, y4o); \
+         dct_wadd(x5, y1o, y5o); \
+         dct_wadd(x6, y2o, y5o); \
+         dct_wadd(x7, y3o, y4o); \
+         dct_bfly32o(row0,row7, x0,x7,bias,shift); \
+         dct_bfly32o(row1,row6, x1,x6,bias,shift); \
+         dct_bfly32o(row2,row5, x2,x5,bias,shift); \
+         dct_bfly32o(row3,row4, x3,x4,bias,shift); \
+      }
+
+   __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f));
+   __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f));
+   __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f));
+   __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f));
+   __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f));
+   __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f));
+   __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f));
+   __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f));
+
+   // rounding biases in column/row passes, see stbi__idct_block for explanation.
+   __m128i bias_0 = _mm_set1_epi32(512);
+   __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17));
+
+   // load
+   row0 = _mm_load_si128((const __m128i *) (data + 0*8));
+   row1 = _mm_load_si128((const __m128i *) (data + 1*8));
+   row2 = _mm_load_si128((const __m128i *) (data + 2*8));
+   row3 = _mm_load_si128((const __m128i *) (data + 3*8));
+   row4 = _mm_load_si128((const __m128i *) (data + 4*8));
+   row5 = _mm_load_si128((const __m128i *) (data + 5*8));
+   row6 = _mm_load_si128((const __m128i *) (data + 6*8));
+   row7 = _mm_load_si128((const __m128i *) (data + 7*8));
+
+   // column pass
+   dct_pass(bias_0, 10);
+
+   {
+      // 16bit 8x8 transpose pass 1
+      dct_interleave16(row0, row4);
+      dct_interleave16(row1, row5);
+      dct_interleave16(row2, row6);
+      dct_interleave16(row3, row7);
+
+      // transpose pass 2
+      dct_interleave16(row0, row2);
+      dct_interleave16(row1, row3);
+      dct_interleave16(row4, row6);
+      dct_interleave16(row5, row7);
+
+      // transpose pass 3
+      dct_interleave16(row0, row1);
+      dct_interleave16(row2, row3);
+      dct_interleave16(row4, row5);
+      dct_interleave16(row6, row7);
+   }
+
+   // row pass
+   dct_pass(bias_1, 17);
+
+   {
+      // pack
+      __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7
+      __m128i p1 = _mm_packus_epi16(row2, row3);
+      __m128i p2 = _mm_packus_epi16(row4, row5);
+      __m128i p3 = _mm_packus_epi16(row6, row7);
+
+      // 8bit 8x8 transpose pass 1
+      dct_interleave8(p0, p2); // a0e0a1e1...
+      dct_interleave8(p1, p3); // c0g0c1g1...
+
+      // transpose pass 2
+      dct_interleave8(p0, p1); // a0c0e0g0...
+      dct_interleave8(p2, p3); // b0d0f0h0...
+
+      // transpose pass 3
+      dct_interleave8(p0, p2); // a0b0c0d0...
+      dct_interleave8(p1, p3); // a4b4c4d4...
+
+      // store
+      _mm_storel_epi64((__m128i *) out, p0); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, p2); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, p1); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, p3); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e));
+   }
+
+#undef dct_const
+#undef dct_rot
+#undef dct_widen
+#undef dct_wadd
+#undef dct_wsub
+#undef dct_bfly32o
+#undef dct_interleave8
+#undef dct_interleave16
+#undef dct_pass
+}
+
+#endif // STBI_SSE2
+
+#ifdef STBI_NEON
+
+// NEON integer IDCT. should produce bit-identical
+// results to the generic C version.
+static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
+{
+   int16x8_t row0, row1, row2, row3, row4, row5, row6, row7;
+
+   int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f));
+   int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f));
+   int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f));
+   int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f));
+   int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f));
+   int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f));
+   int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f));
+   int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f));
+   int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f));
+   int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f));
+   int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f));
+   int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f));
+
+#define dct_long_mul(out, inq, coeff) \
+   int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \
+   int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff)
+
+#define dct_long_mac(out, acc, inq, coeff) \
+   int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \
+   int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff)
+
+#define dct_widen(out, inq) \
+   int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \
+   int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12)
+
+// wide add
+#define dct_wadd(out, a, b) \
+   int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \
+   int32x4_t out##_h = vaddq_s32(a##_h, b##_h)
+
+// wide sub
+#define dct_wsub(out, a, b) \
+   int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \
+   int32x4_t out##_h = vsubq_s32(a##_h, b##_h)
+
+// butterfly a/b, then shift using "shiftop" by "s" and pack
+#define dct_bfly32o(out0,out1, a,b,shiftop,s) \
+   { \
+      dct_wadd(sum, a, b); \
+      dct_wsub(dif, a, b); \
+      out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \
+      out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \
+   }
+
+#define dct_pass(shiftop, shift) \
+   { \
+      /* even part */ \
+      int16x8_t sum26 = vaddq_s16(row2, row6); \
+      dct_long_mul(p1e, sum26, rot0_0); \
+      dct_long_mac(t2e, p1e, row6, rot0_1); \
+      dct_long_mac(t3e, p1e, row2, rot0_2); \
+      int16x8_t sum04 = vaddq_s16(row0, row4); \
+      int16x8_t dif04 = vsubq_s16(row0, row4); \
+      dct_widen(t0e, sum04); \
+      dct_widen(t1e, dif04); \
+      dct_wadd(x0, t0e, t3e); \
+      dct_wsub(x3, t0e, t3e); \
+      dct_wadd(x1, t1e, t2e); \
+      dct_wsub(x2, t1e, t2e); \
+      /* odd part */ \
+      int16x8_t sum15 = vaddq_s16(row1, row5); \
+      int16x8_t sum17 = vaddq_s16(row1, row7); \
+      int16x8_t sum35 = vaddq_s16(row3, row5); \
+      int16x8_t sum37 = vaddq_s16(row3, row7); \
+      int16x8_t sumodd = vaddq_s16(sum17, sum35); \
+      dct_long_mul(p5o, sumodd, rot1_0); \
+      dct_long_mac(p1o, p5o, sum17, rot1_1); \
+      dct_long_mac(p2o, p5o, sum35, rot1_2); \
+      dct_long_mul(p3o, sum37, rot2_0); \
+      dct_long_mul(p4o, sum15, rot2_1); \
+      dct_wadd(sump13o, p1o, p3o); \
+      dct_wadd(sump24o, p2o, p4o); \
+      dct_wadd(sump23o, p2o, p3o); \
+      dct_wadd(sump14o, p1o, p4o); \
+      dct_long_mac(x4, sump13o, row7, rot3_0); \
+      dct_long_mac(x5, sump24o, row5, rot3_1); \
+      dct_long_mac(x6, sump23o, row3, rot3_2); \
+      dct_long_mac(x7, sump14o, row1, rot3_3); \
+      dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \
+      dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \
+      dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \
+      dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \
+   }
+
+   // load
+   row0 = vld1q_s16(data + 0*8);
+   row1 = vld1q_s16(data + 1*8);
+   row2 = vld1q_s16(data + 2*8);
+   row3 = vld1q_s16(data + 3*8);
+   row4 = vld1q_s16(data + 4*8);
+   row5 = vld1q_s16(data + 5*8);
+   row6 = vld1q_s16(data + 6*8);
+   row7 = vld1q_s16(data + 7*8);
+
+   // add DC bias
+   row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0));
+
+   // column pass
+   dct_pass(vrshrn_n_s32, 10);
+
+   // 16bit 8x8 transpose
+   {
+// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively.
+// whether compilers actually get this is another story, sadly.
+#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; }
+#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); }
+#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); }
+
+      // pass 1
+      dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6
+      dct_trn16(row2, row3);
+      dct_trn16(row4, row5);
+      dct_trn16(row6, row7);
+
+      // pass 2
+      dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4
+      dct_trn32(row1, row3);
+      dct_trn32(row4, row6);
+      dct_trn32(row5, row7);
+
+      // pass 3
+      dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0
+      dct_trn64(row1, row5);
+      dct_trn64(row2, row6);
+      dct_trn64(row3, row7);
+
+#undef dct_trn16
+#undef dct_trn32
+#undef dct_trn64
+   }
+
+   // row pass
+   // vrshrn_n_s32 only supports shifts up to 16, we need
+   // 17. so do a non-rounding shift of 16 first then follow
+   // up with a rounding shift by 1.
+   dct_pass(vshrn_n_s32, 16);
+
+   {
+      // pack and round
+      uint8x8_t p0 = vqrshrun_n_s16(row0, 1);
+      uint8x8_t p1 = vqrshrun_n_s16(row1, 1);
+      uint8x8_t p2 = vqrshrun_n_s16(row2, 1);
+      uint8x8_t p3 = vqrshrun_n_s16(row3, 1);
+      uint8x8_t p4 = vqrshrun_n_s16(row4, 1);
+      uint8x8_t p5 = vqrshrun_n_s16(row5, 1);
+      uint8x8_t p6 = vqrshrun_n_s16(row6, 1);
+      uint8x8_t p7 = vqrshrun_n_s16(row7, 1);
+
+      // again, these can translate into one instruction, but often don't.
+#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; }
+#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); }
+#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); }
+
+      // sadly can't use interleaved stores here since we only write
+      // 8 bytes to each scan line!
+
+      // 8x8 8-bit transpose pass 1
+      dct_trn8_8(p0, p1);
+      dct_trn8_8(p2, p3);
+      dct_trn8_8(p4, p5);
+      dct_trn8_8(p6, p7);
+
+      // pass 2
+      dct_trn8_16(p0, p2);
+      dct_trn8_16(p1, p3);
+      dct_trn8_16(p4, p6);
+      dct_trn8_16(p5, p7);
+
+      // pass 3
+      dct_trn8_32(p0, p4);
+      dct_trn8_32(p1, p5);
+      dct_trn8_32(p2, p6);
+      dct_trn8_32(p3, p7);
+
+      // store
+      vst1_u8(out, p0); out += out_stride;
+      vst1_u8(out, p1); out += out_stride;
+      vst1_u8(out, p2); out += out_stride;
+      vst1_u8(out, p3); out += out_stride;
+      vst1_u8(out, p4); out += out_stride;
+      vst1_u8(out, p5); out += out_stride;
+      vst1_u8(out, p6); out += out_stride;
+      vst1_u8(out, p7);
+
+#undef dct_trn8_8
+#undef dct_trn8_16
+#undef dct_trn8_32
+   }
+
+#undef dct_long_mul
+#undef dct_long_mac
+#undef dct_widen
+#undef dct_wadd
+#undef dct_wsub
+#undef dct_bfly32o
+#undef dct_pass
+}
+
+#endif // STBI_NEON
+
+#define STBI__MARKER_none  0xff
+// if there's a pending marker from the entropy stream, return that
+// otherwise, fetch from the stream and get a marker. if there's no
+// marker, return 0xff, which is never a valid marker value
+static stbi_uc stbi__get_marker(stbi__jpeg *j)
+{
+   stbi_uc x;
+   if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; }
+   x = stbi__get8(j->s);
+   if (x != 0xff) return STBI__MARKER_none;
+   while (x == 0xff)
+      x = stbi__get8(j->s); // consume repeated 0xff fill bytes
+   return x;
+}
+
+// in each scan, we'll have scan_n components, and the order
+// of the components is specified by order[]
+#define STBI__RESTART(x)     ((x) >= 0xd0 && (x) <= 0xd7)
+
+// after a restart interval, stbi__jpeg_reset the entropy decoder and
+// the dc prediction
+static void stbi__jpeg_reset(stbi__jpeg *j)
+{
+   j->code_bits = 0;
+   j->code_buffer = 0;
+   j->nomore = 0;
+   j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = j->img_comp[3].dc_pred = 0;
+   j->marker = STBI__MARKER_none;
+   j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff;
+   j->eob_run = 0;
+   // no more than 1<<31 MCUs if no restart_interal? that's plenty safe,
+   // since we don't even allow 1<<30 pixels
+}
+
+static int stbi__parse_entropy_coded_data(stbi__jpeg *z)
+{
+   stbi__jpeg_reset(z);
+   if (!z->progressive) {
+      if (z->scan_n == 1) {
+         int i,j;
+         STBI_SIMD_ALIGN(short, data[64]);
+         int n = z->order[0];
+         // non-interleaved data, we just need to process one block at a time,
+         // in trivial scanline order
+         // number of blocks to do just depends on how many actual "pixels" this
+         // component has, independent of interleaved MCU blocking and such
+         int w = (z->img_comp[n].x+7) >> 3;
+         int h = (z->img_comp[n].y+7) >> 3;
+         for (j=0; j < h; ++j) {
+            for (i=0; i < w; ++i) {
+               int ha = z->img_comp[n].ha;
+               if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0;
+               z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);
+               // every data block is an MCU, so countdown the restart interval
+               if (--z->todo <= 0) {
+                  if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
+                  // if it's NOT a restart, then just bail, so we get corrupt data
+                  // rather than no data
+                  if (!STBI__RESTART(z->marker)) return 1;
+                  stbi__jpeg_reset(z);
+               }
+            }
+         }
+         return 1;
+      } else { // interleaved
+         int i,j,k,x,y;
+         STBI_SIMD_ALIGN(short, data[64]);
+         for (j=0; j < z->img_mcu_y; ++j) {
+            for (i=0; i < z->img_mcu_x; ++i) {
+               // scan an interleaved mcu... process scan_n components in order
+               for (k=0; k < z->scan_n; ++k) {
+                  int n = z->order[k];
+                  // scan out an mcu's worth of this component; that's just determined
+                  // by the basic H and V specified for the component
+                  for (y=0; y < z->img_comp[n].v; ++y) {
+                     for (x=0; x < z->img_comp[n].h; ++x) {
+                        int x2 = (i*z->img_comp[n].h + x)*8;
+                        int y2 = (j*z->img_comp[n].v + y)*8;
+                        int ha = z->img_comp[n].ha;
+                        if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0;
+                        z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data);
+                     }
+                  }
+               }
+               // after all interleaved components, that's an interleaved MCU,
+               // so now count down the restart interval
+               if (--z->todo <= 0) {
+                  if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
+                  if (!STBI__RESTART(z->marker)) return 1;
+                  stbi__jpeg_reset(z);
+               }
+            }
+         }
+         return 1;
+      }
+   } else {
+      if (z->scan_n == 1) {
+         int i,j;
+         int n = z->order[0];
+         // non-interleaved data, we just need to process one block at a time,
+         // in trivial scanline order
+         // number of blocks to do just depends on how many actual "pixels" this
+         // component has, independent of interleaved MCU blocking and such
+         int w = (z->img_comp[n].x+7) >> 3;
+         int h = (z->img_comp[n].y+7) >> 3;
+         for (j=0; j < h; ++j) {
+            for (i=0; i < w; ++i) {
+               short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);
+               if (z->spec_start == 0) {
+                  if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))
+                     return 0;
+               } else {
+                  int ha = z->img_comp[n].ha;
+                  if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha]))
+                     return 0;
+               }
+               // every data block is an MCU, so countdown the restart interval
+               if (--z->todo <= 0) {
+                  if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
+                  if (!STBI__RESTART(z->marker)) return 1;
+                  stbi__jpeg_reset(z);
+               }
+            }
+         }
+         return 1;
+      } else { // interleaved
+         int i,j,k,x,y;
+         for (j=0; j < z->img_mcu_y; ++j) {
+            for (i=0; i < z->img_mcu_x; ++i) {
+               // scan an interleaved mcu... process scan_n components in order
+               for (k=0; k < z->scan_n; ++k) {
+                  int n = z->order[k];
+                  // scan out an mcu's worth of this component; that's just determined
+                  // by the basic H and V specified for the component
+                  for (y=0; y < z->img_comp[n].v; ++y) {
+                     for (x=0; x < z->img_comp[n].h; ++x) {
+                        int x2 = (i*z->img_comp[n].h + x);
+                        int y2 = (j*z->img_comp[n].v + y);
+                        short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w);
+                        if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))
+                           return 0;
+                     }
+                  }
+               }
+               // after all interleaved components, that's an interleaved MCU,
+               // so now count down the restart interval
+               if (--z->todo <= 0) {
+                  if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
+                  if (!STBI__RESTART(z->marker)) return 1;
+                  stbi__jpeg_reset(z);
+               }
+            }
+         }
+         return 1;
+      }
+   }
+}
+
+static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant)
+{
+   int i;
+   for (i=0; i < 64; ++i)
+      data[i] *= dequant[i];
+}
+
+static void stbi__jpeg_finish(stbi__jpeg *z)
+{
+   if (z->progressive) {
+      // dequantize and idct the data
+      int i,j,n;
+      for (n=0; n < z->s->img_n; ++n) {
+         int w = (z->img_comp[n].x+7) >> 3;
+         int h = (z->img_comp[n].y+7) >> 3;
+         for (j=0; j < h; ++j) {
+            for (i=0; i < w; ++i) {
+               short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);
+               stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]);
+               z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);
+            }
+         }
+      }
+   }
+}
+
+static int stbi__process_marker(stbi__jpeg *z, int m)
+{
+   int L;
+   switch (m) {
+      case STBI__MARKER_none: // no marker found
+         return stbi__err("expected marker","Corrupt JPEG");
+
+      case 0xDD: // DRI - specify restart interval
+         if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG");
+         z->restart_interval = stbi__get16be(z->s);
+         return 1;
+
+      case 0xDB: // DQT - define quantization table
+         L = stbi__get16be(z->s)-2;
+         while (L > 0) {
+            int q = stbi__get8(z->s);
+            int p = q >> 4, sixteen = (p != 0);
+            int t = q & 15,i;
+            if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG");
+            if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG");
+
+            for (i=0; i < 64; ++i)
+               z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s));
+            L -= (sixteen ? 129 : 65);
+         }
+         return L==0;
+
+      case 0xC4: // DHT - define huffman table
+         L = stbi__get16be(z->s)-2;
+         while (L > 0) {
+            stbi_uc *v;
+            int sizes[16],i,n=0;
+            int q = stbi__get8(z->s);
+            int tc = q >> 4;
+            int th = q & 15;
+            if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG");
+            for (i=0; i < 16; ++i) {
+               sizes[i] = stbi__get8(z->s);
+               n += sizes[i];
+            }
+            L -= 17;
+            if (tc == 0) {
+               if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0;
+               v = z->huff_dc[th].values;
+            } else {
+               if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0;
+               v = z->huff_ac[th].values;
+            }
+            for (i=0; i < n; ++i)
+               v[i] = stbi__get8(z->s);
+            if (tc != 0)
+               stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th);
+            L -= n;
+         }
+         return L==0;
+   }
+
+   // check for comment block or APP blocks
+   if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) {
+      L = stbi__get16be(z->s);
+      if (L < 2) {
+         if (m == 0xFE)
+            return stbi__err("bad COM len","Corrupt JPEG");
+         else
+            return stbi__err("bad APP len","Corrupt JPEG");
+      }
+      L -= 2;
+
+      if (m == 0xE0 && L >= 5) { // JFIF APP0 segment
+         static const unsigned char tag[5] = {'J','F','I','F','\0'};
+         int ok = 1;
+         int i;
+         for (i=0; i < 5; ++i)
+            if (stbi__get8(z->s) != tag[i])
+               ok = 0;
+         L -= 5;
+         if (ok)
+            z->jfif = 1;
+      } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment
+         static const unsigned char tag[6] = {'A','d','o','b','e','\0'};
+         int ok = 1;
+         int i;
+         for (i=0; i < 6; ++i)
+            if (stbi__get8(z->s) != tag[i])
+               ok = 0;
+         L -= 6;
+         if (ok) {
+            stbi__get8(z->s); // version
+            stbi__get16be(z->s); // flags0
+            stbi__get16be(z->s); // flags1
+            z->app14_color_transform = stbi__get8(z->s); // color transform
+            L -= 6;
+         }
+      }
+
+      stbi__skip(z->s, L);
+      return 1;
+   }
+
+   return stbi__err("unknown marker","Corrupt JPEG");
+}
+
+// after we see SOS
+static int stbi__process_scan_header(stbi__jpeg *z)
+{
+   int i;
+   int Ls = stbi__get16be(z->s);
+   z->scan_n = stbi__get8(z->s);
+   if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad SOS component count","Corrupt JPEG");
+   if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG");
+   for (i=0; i < z->scan_n; ++i) {
+      int id = stbi__get8(z->s), which;
+      int q = stbi__get8(z->s);
+      for (which = 0; which < z->s->img_n; ++which)
+         if (z->img_comp[which].id == id)
+            break;
+      if (which == z->s->img_n) return 0; // no match
+      z->img_comp[which].hd = q >> 4;   if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG");
+      z->img_comp[which].ha = q & 15;   if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG");
+      z->order[i] = which;
+   }
+
+   {
+      int aa;
+      z->spec_start = stbi__get8(z->s);
+      z->spec_end   = stbi__get8(z->s); // should be 63, but might be 0
+      aa = stbi__get8(z->s);
+      z->succ_high = (aa >> 4);
+      z->succ_low  = (aa & 15);
+      if (z->progressive) {
+         if (z->spec_start > 63 || z->spec_end > 63  || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13)
+            return stbi__err("bad SOS", "Corrupt JPEG");
+      } else {
+         if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG");
+         if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG");
+         z->spec_end = 63;
+      }
+   }
+
+   return 1;
+}
+
+static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why)
+{
+   int i;
+   for (i=0; i < ncomp; ++i) {
+      if (z->img_comp[i].raw_data) {
+         STBI_FREE(z->img_comp[i].raw_data);
+         z->img_comp[i].raw_data = NULL;
+         z->img_comp[i].data = NULL;
+      }
+      if (z->img_comp[i].raw_coeff) {
+         STBI_FREE(z->img_comp[i].raw_coeff);
+         z->img_comp[i].raw_coeff = 0;
+         z->img_comp[i].coeff = 0;
+      }
+      if (z->img_comp[i].linebuf) {
+         STBI_FREE(z->img_comp[i].linebuf);
+         z->img_comp[i].linebuf = NULL;
+      }
+   }
+   return why;
+}
+
+static int stbi__process_frame_header(stbi__jpeg *z, int scan)
+{
+   stbi__context *s = z->s;
+   int Lf,p,i,q, h_max=1,v_max=1,c;
+   Lf = stbi__get16be(s);         if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG
+   p  = stbi__get8(s);            if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline
+   s->img_y = stbi__get16be(s);   if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG
+   s->img_x = stbi__get16be(s);   if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires
+   c = stbi__get8(s);
+   if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG");
+   s->img_n = c;
+   for (i=0; i < c; ++i) {
+      z->img_comp[i].data = NULL;
+      z->img_comp[i].linebuf = NULL;
+   }
+
+   if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG");
+
+   z->rgb = 0;
+   for (i=0; i < s->img_n; ++i) {
+      static const unsigned char rgb[3] = { 'R', 'G', 'B' };
+      z->img_comp[i].id = stbi__get8(s);
+      if (s->img_n == 3 && z->img_comp[i].id == rgb[i])
+         ++z->rgb;
+      q = stbi__get8(s);
+      z->img_comp[i].h = (q >> 4);  if (!z->img_comp[i].h || z->img_comp[i].h > 4) return stbi__err("bad H","Corrupt JPEG");
+      z->img_comp[i].v = q & 15;    if (!z->img_comp[i].v || z->img_comp[i].v > 4) return stbi__err("bad V","Corrupt JPEG");
+      z->img_comp[i].tq = stbi__get8(s);  if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG");
+   }
+
+   if (scan != STBI__SCAN_load) return 1;
+
+   if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode");
+
+   for (i=0; i < s->img_n; ++i) {
+      if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h;
+      if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v;
+   }
+
+   // compute interleaved mcu info
+   z->img_h_max = h_max;
+   z->img_v_max = v_max;
+   z->img_mcu_w = h_max * 8;
+   z->img_mcu_h = v_max * 8;
+   // these sizes can't be more than 17 bits
+   z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w;
+   z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h;
+
+   for (i=0; i < s->img_n; ++i) {
+      // number of effective pixels (e.g. for non-interleaved MCU)
+      z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max;
+      z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max;
+      // to simplify generation, we'll allocate enough memory to decode
+      // the bogus oversized data from using interleaved MCUs and their
+      // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't
+      // discard the extra data until colorspace conversion
+      //
+      // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier)
+      // so these muls can't overflow with 32-bit ints (which we require)
+      z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8;
+      z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8;
+      z->img_comp[i].coeff = 0;
+      z->img_comp[i].raw_coeff = 0;
+      z->img_comp[i].linebuf = NULL;
+      z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15);
+      if (z->img_comp[i].raw_data == NULL)
+         return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory"));
+      // align blocks for idct using mmx/sse
+      z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15);
+      if (z->progressive) {
+         // w2, h2 are multiples of 8 (see above)
+         z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8;
+         z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8;
+         z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15);
+         if (z->img_comp[i].raw_coeff == NULL)
+            return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory"));
+         z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15);
+      }
+   }
+
+   return 1;
+}
+
+// use comparisons since in some cases we handle more than one case (e.g. SOF)
+#define stbi__DNL(x)         ((x) == 0xdc)
+#define stbi__SOI(x)         ((x) == 0xd8)
+#define stbi__EOI(x)         ((x) == 0xd9)
+#define stbi__SOF(x)         ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2)
+#define stbi__SOS(x)         ((x) == 0xda)
+
+#define stbi__SOF_progressive(x)   ((x) == 0xc2)
+
+static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan)
+{
+   int m;
+   z->jfif = 0;
+   z->app14_color_transform = -1; // valid values are 0,1,2
+   z->marker = STBI__MARKER_none; // initialize cached marker to empty
+   m = stbi__get_marker(z);
+   if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG");
+   if (scan == STBI__SCAN_type) return 1;
+   m = stbi__get_marker(z);
+   while (!stbi__SOF(m)) {
+      if (!stbi__process_marker(z,m)) return 0;
+      m = stbi__get_marker(z);
+      while (m == STBI__MARKER_none) {
+         // some files have extra padding after their blocks, so ok, we'll scan
+         if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG");
+         m = stbi__get_marker(z);
+      }
+   }
+   z->progressive = stbi__SOF_progressive(m);
+   if (!stbi__process_frame_header(z, scan)) return 0;
+   return 1;
+}
+
+// decode image to YCbCr format
+static int stbi__decode_jpeg_image(stbi__jpeg *j)
+{
+   int m;
+   for (m = 0; m < 4; m++) {
+      j->img_comp[m].raw_data = NULL;
+      j->img_comp[m].raw_coeff = NULL;
+   }
+   j->restart_interval = 0;
+   if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0;
+   m = stbi__get_marker(j);
+   while (!stbi__EOI(m)) {
+      if (stbi__SOS(m)) {
+         if (!stbi__process_scan_header(j)) return 0;
+         if (!stbi__parse_entropy_coded_data(j)) return 0;
+         if (j->marker == STBI__MARKER_none ) {
+            // handle 0s at the end of image data from IP Kamera 9060
+            while (!stbi__at_eof(j->s)) {
+               int x = stbi__get8(j->s);
+               if (x == 255) {
+                  j->marker = stbi__get8(j->s);
+                  break;
+               }
+            }
+            // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0
+         }
+      } else if (stbi__DNL(m)) {
+         int Ld = stbi__get16be(j->s);
+         stbi__uint32 NL = stbi__get16be(j->s);
+         if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG");
+         if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG");
+      } else {
+         if (!stbi__process_marker(j, m)) return 0;
+      }
+      m = stbi__get_marker(j);
+   }
+   if (j->progressive)
+      stbi__jpeg_finish(j);
+   return 1;
+}
+
+// static jfif-centered resampling (across block boundaries)
+
+typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1,
+                                    int w, int hs);
+
+#define stbi__div4(x) ((stbi_uc) ((x) >> 2))
+
+static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+   STBI_NOTUSED(out);
+   STBI_NOTUSED(in_far);
+   STBI_NOTUSED(w);
+   STBI_NOTUSED(hs);
+   return in_near;
+}
+
+static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+   // need to generate two samples vertically for every one in input
+   int i;
+   STBI_NOTUSED(hs);
+   for (i=0; i < w; ++i)
+      out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2);
+   return out;
+}
+
+static stbi_uc*  stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+   // need to generate two samples horizontally for every one in input
+   int i;
+   stbi_uc *input = in_near;
+
+   if (w == 1) {
+      // if only one sample, can't do any interpolation
+      out[0] = out[1] = input[0];
+      return out;
+   }
+
+   out[0] = input[0];
+   out[1] = stbi__div4(input[0]*3 + input[1] + 2);
+   for (i=1; i < w-1; ++i) {
+      int n = 3*input[i]+2;
+      out[i*2+0] = stbi__div4(n+input[i-1]);
+      out[i*2+1] = stbi__div4(n+input[i+1]);
+   }
+   out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2);
+   out[i*2+1] = input[w-1];
+
+   STBI_NOTUSED(in_far);
+   STBI_NOTUSED(hs);
+
+   return out;
+}
+
+#define stbi__div16(x) ((stbi_uc) ((x) >> 4))
+
+static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+   // need to generate 2x2 samples for every one in input
+   int i,t0,t1;
+   if (w == 1) {
+      out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
+      return out;
+   }
+
+   t1 = 3*in_near[0] + in_far[0];
+   out[0] = stbi__div4(t1+2);
+   for (i=1; i < w; ++i) {
+      t0 = t1;
+      t1 = 3*in_near[i]+in_far[i];
+      out[i*2-1] = stbi__div16(3*t0 + t1 + 8);
+      out[i*2  ] = stbi__div16(3*t1 + t0 + 8);
+   }
+   out[w*2-1] = stbi__div4(t1+2);
+
+   STBI_NOTUSED(hs);
+
+   return out;
+}
+
+#if defined(STBI_SSE2) || defined(STBI_NEON)
+static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+   // need to generate 2x2 samples for every one in input
+   int i=0,t0,t1;
+
+   if (w == 1) {
+      out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
+      return out;
+   }
+
+   t1 = 3*in_near[0] + in_far[0];
+   // process groups of 8 pixels for as long as we can.
+   // note we can't handle the last pixel in a row in this loop
+   // because we need to handle the filter boundary conditions.
+   for (; i < ((w-1) & ~7); i += 8) {
+#if defined(STBI_SSE2)
+      // load and perform the vertical filtering pass
+      // this uses 3*x + y = 4*x + (y - x)
+      __m128i zero  = _mm_setzero_si128();
+      __m128i farb  = _mm_loadl_epi64((__m128i *) (in_far + i));
+      __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i));
+      __m128i farw  = _mm_unpacklo_epi8(farb, zero);
+      __m128i nearw = _mm_unpacklo_epi8(nearb, zero);
+      __m128i diff  = _mm_sub_epi16(farw, nearw);
+      __m128i nears = _mm_slli_epi16(nearw, 2);
+      __m128i curr  = _mm_add_epi16(nears, diff); // current row
+
+      // horizontal filter works the same based on shifted vers of current
+      // row. "prev" is current row shifted right by 1 pixel; we need to
+      // insert the previous pixel value (from t1).
+      // "next" is current row shifted left by 1 pixel, with first pixel
+      // of next block of 8 pixels added in.
+      __m128i prv0 = _mm_slli_si128(curr, 2);
+      __m128i nxt0 = _mm_srli_si128(curr, 2);
+      __m128i prev = _mm_insert_epi16(prv0, t1, 0);
+      __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7);
+
+      // horizontal filter, polyphase implementation since it's convenient:
+      // even pixels = 3*cur + prev = cur*4 + (prev - cur)
+      // odd  pixels = 3*cur + next = cur*4 + (next - cur)
+      // note the shared term.
+      __m128i bias  = _mm_set1_epi16(8);
+      __m128i curs = _mm_slli_epi16(curr, 2);
+      __m128i prvd = _mm_sub_epi16(prev, curr);
+      __m128i nxtd = _mm_sub_epi16(next, curr);
+      __m128i curb = _mm_add_epi16(curs, bias);
+      __m128i even = _mm_add_epi16(prvd, curb);
+      __m128i odd  = _mm_add_epi16(nxtd, curb);
+
+      // interleave even and odd pixels, then undo scaling.
+      __m128i int0 = _mm_unpacklo_epi16(even, odd);
+      __m128i int1 = _mm_unpackhi_epi16(even, odd);
+      __m128i de0  = _mm_srli_epi16(int0, 4);
+      __m128i de1  = _mm_srli_epi16(int1, 4);
+
+      // pack and write output
+      __m128i outv = _mm_packus_epi16(de0, de1);
+      _mm_storeu_si128((__m128i *) (out + i*2), outv);
+#elif defined(STBI_NEON)
+      // load and perform the vertical filtering pass
+      // this uses 3*x + y = 4*x + (y - x)
+      uint8x8_t farb  = vld1_u8(in_far + i);
+      uint8x8_t nearb = vld1_u8(in_near + i);
+      int16x8_t diff  = vreinterpretq_s16_u16(vsubl_u8(farb, nearb));
+      int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2));
+      int16x8_t curr  = vaddq_s16(nears, diff); // current row
+
+      // horizontal filter works the same based on shifted vers of current
+      // row. "prev" is current row shifted right by 1 pixel; we need to
+      // insert the previous pixel value (from t1).
+      // "next" is current row shifted left by 1 pixel, with first pixel
+      // of next block of 8 pixels added in.
+      int16x8_t prv0 = vextq_s16(curr, curr, 7);
+      int16x8_t nxt0 = vextq_s16(curr, curr, 1);
+      int16x8_t prev = vsetq_lane_s16(t1, prv0, 0);
+      int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7);
+
+      // horizontal filter, polyphase implementation since it's convenient:
+      // even pixels = 3*cur + prev = cur*4 + (prev - cur)
+      // odd  pixels = 3*cur + next = cur*4 + (next - cur)
+      // note the shared term.
+      int16x8_t curs = vshlq_n_s16(curr, 2);
+      int16x8_t prvd = vsubq_s16(prev, curr);
+      int16x8_t nxtd = vsubq_s16(next, curr);
+      int16x8_t even = vaddq_s16(curs, prvd);
+      int16x8_t odd  = vaddq_s16(curs, nxtd);
+
+      // undo scaling and round, then store with even/odd phases interleaved
+      uint8x8x2_t o;
+      o.val[0] = vqrshrun_n_s16(even, 4);
+      o.val[1] = vqrshrun_n_s16(odd,  4);
+      vst2_u8(out + i*2, o);
+#endif
+
+      // "previous" value for next iter
+      t1 = 3*in_near[i+7] + in_far[i+7];
+   }
+
+   t0 = t1;
+   t1 = 3*in_near[i] + in_far[i];
+   out[i*2] = stbi__div16(3*t1 + t0 + 8);
+
+   for (++i; i < w; ++i) {
+      t0 = t1;
+      t1 = 3*in_near[i]+in_far[i];
+      out[i*2-1] = stbi__div16(3*t0 + t1 + 8);
+      out[i*2  ] = stbi__div16(3*t1 + t0 + 8);
+   }
+   out[w*2-1] = stbi__div4(t1+2);
+
+   STBI_NOTUSED(hs);
+
+   return out;
+}
+#endif
+
+static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+   // resample with nearest-neighbor
+   int i,j;
+   STBI_NOTUSED(in_far);
+   for (i=0; i < w; ++i)
+      for (j=0; j < hs; ++j)
+         out[i*hs+j] = in_near[i];
+   return out;
+}
+
+// this is a reduced-precision calculation of YCbCr-to-RGB introduced
+// to make sure the code produces the same results in both SIMD and scalar
+#define stbi__float2fixed(x)  (((int) ((x) * 4096.0f + 0.5f)) << 8)
+static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step)
+{
+   int i;
+   for (i=0; i < count; ++i) {
+      int y_fixed = (y[i] << 20) + (1<<19); // rounding
+      int r,g,b;
+      int cr = pcr[i] - 128;
+      int cb = pcb[i] - 128;
+      r = y_fixed +  cr* stbi__float2fixed(1.40200f);
+      g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);
+      b = y_fixed                                     +   cb* stbi__float2fixed(1.77200f);
+      r >>= 20;
+      g >>= 20;
+      b >>= 20;
+      if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }
+      if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }
+      if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }
+      out[0] = (stbi_uc)r;
+      out[1] = (stbi_uc)g;
+      out[2] = (stbi_uc)b;
+      out[3] = 255;
+      out += step;
+   }
+}
+
+#if defined(STBI_SSE2) || defined(STBI_NEON)
+static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step)
+{
+   int i = 0;
+
+#ifdef STBI_SSE2
+   // step == 3 is pretty ugly on the final interleave, and i'm not convinced
+   // it's useful in practice (you wouldn't use it for textures, for example).
+   // so just accelerate step == 4 case.
+   if (step == 4) {
+      // this is a fairly straightforward implementation and not super-optimized.
+      __m128i signflip  = _mm_set1_epi8(-0x80);
+      __m128i cr_const0 = _mm_set1_epi16(   (short) ( 1.40200f*4096.0f+0.5f));
+      __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f));
+      __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f));
+      __m128i cb_const1 = _mm_set1_epi16(   (short) ( 1.77200f*4096.0f+0.5f));
+      __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128);
+      __m128i xw = _mm_set1_epi16(255); // alpha channel
+
+      for (; i+7 < count; i += 8) {
+         // load
+         __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i));
+         __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i));
+         __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i));
+         __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128
+         __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128
+
+         // unpack to short (and left-shift cr, cb by 8)
+         __m128i yw  = _mm_unpacklo_epi8(y_bias, y_bytes);
+         __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased);
+         __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased);
+
+         // color transform
+         __m128i yws = _mm_srli_epi16(yw, 4);
+         __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw);
+         __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw);
+         __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1);
+         __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1);
+         __m128i rws = _mm_add_epi16(cr0, yws);
+         __m128i gwt = _mm_add_epi16(cb0, yws);
+         __m128i bws = _mm_add_epi16(yws, cb1);
+         __m128i gws = _mm_add_epi16(gwt, cr1);
+
+         // descale
+         __m128i rw = _mm_srai_epi16(rws, 4);
+         __m128i bw = _mm_srai_epi16(bws, 4);
+         __m128i gw = _mm_srai_epi16(gws, 4);
+
+         // back to byte, set up for transpose
+         __m128i brb = _mm_packus_epi16(rw, bw);
+         __m128i gxb = _mm_packus_epi16(gw, xw);
+
+         // transpose to interleave channels
+         __m128i t0 = _mm_unpacklo_epi8(brb, gxb);
+         __m128i t1 = _mm_unpackhi_epi8(brb, gxb);
+         __m128i o0 = _mm_unpacklo_epi16(t0, t1);
+         __m128i o1 = _mm_unpackhi_epi16(t0, t1);
+
+         // store
+         _mm_storeu_si128((__m128i *) (out + 0), o0);
+         _mm_storeu_si128((__m128i *) (out + 16), o1);
+         out += 32;
+      }
+   }
+#endif
+
+#ifdef STBI_NEON
+   // in this version, step=3 support would be easy to add. but is there demand?
+   if (step == 4) {
+      // this is a fairly straightforward implementation and not super-optimized.
+      uint8x8_t signflip = vdup_n_u8(0x80);
+      int16x8_t cr_const0 = vdupq_n_s16(   (short) ( 1.40200f*4096.0f+0.5f));
+      int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f));
+      int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f));
+      int16x8_t cb_const1 = vdupq_n_s16(   (short) ( 1.77200f*4096.0f+0.5f));
+
+      for (; i+7 < count; i += 8) {
+         // load
+         uint8x8_t y_bytes  = vld1_u8(y + i);
+         uint8x8_t cr_bytes = vld1_u8(pcr + i);
+         uint8x8_t cb_bytes = vld1_u8(pcb + i);
+         int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip));
+         int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip));
+
+         // expand to s16
+         int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4));
+         int16x8_t crw = vshll_n_s8(cr_biased, 7);
+         int16x8_t cbw = vshll_n_s8(cb_biased, 7);
+
+         // color transform
+         int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0);
+         int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0);
+         int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1);
+         int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1);
+         int16x8_t rws = vaddq_s16(yws, cr0);
+         int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1);
+         int16x8_t bws = vaddq_s16(yws, cb1);
+
+         // undo scaling, round, convert to byte
+         uint8x8x4_t o;
+         o.val[0] = vqrshrun_n_s16(rws, 4);
+         o.val[1] = vqrshrun_n_s16(gws, 4);
+         o.val[2] = vqrshrun_n_s16(bws, 4);
+         o.val[3] = vdup_n_u8(255);
+
+         // store, interleaving r/g/b/a
+         vst4_u8(out, o);
+         out += 8*4;
+      }
+   }
+#endif
+
+   for (; i < count; ++i) {
+      int y_fixed = (y[i] << 20) + (1<<19); // rounding
+      int r,g,b;
+      int cr = pcr[i] - 128;
+      int cb = pcb[i] - 128;
+      r = y_fixed + cr* stbi__float2fixed(1.40200f);
+      g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);
+      b = y_fixed                                   +   cb* stbi__float2fixed(1.77200f);
+      r >>= 20;
+      g >>= 20;
+      b >>= 20;
+      if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }
+      if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }
+      if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }
+      out[0] = (stbi_uc)r;
+      out[1] = (stbi_uc)g;
+      out[2] = (stbi_uc)b;
+      out[3] = 255;
+      out += step;
+   }
+}
+#endif
+
+// set up the kernels
+static void stbi__setup_jpeg(stbi__jpeg *j)
+{
+   j->idct_block_kernel = stbi__idct_block;
+   j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row;
+   j->resample_row_hv_2_kernel = stbi__resample_row_hv_2;
+
+#ifdef STBI_SSE2
+   if (stbi__sse2_available()) {
+      j->idct_block_kernel = stbi__idct_simd;
+      j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
+      j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
+   }
+#endif
+
+#ifdef STBI_NEON
+   j->idct_block_kernel = stbi__idct_simd;
+   j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
+   j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
+#endif
+}
+
+// clean up the temporary component buffers
+static void stbi__cleanup_jpeg(stbi__jpeg *j)
+{
+   stbi__free_jpeg_components(j, j->s->img_n, 0);
+}
+
+typedef struct
+{
+   resample_row_func resample;
+   stbi_uc *line0,*line1;
+   int hs,vs;   // expansion factor in each axis
+   int w_lores; // horizontal pixels pre-expansion
+   int ystep;   // how far through vertical expansion we are
+   int ypos;    // which pre-expansion row we're on
+} stbi__resample;
+
+// fast 0..255 * 0..255 => 0..255 rounded multiplication
+static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y)
+{
+   unsigned int t = x*y + 128;
+   return (stbi_uc) ((t + (t >>8)) >> 8);
+}
+
+static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp)
+{
+   int n, decode_n, is_rgb;
+   z->s->img_n = 0; // make stbi__cleanup_jpeg safe
+
+   // validate req_comp
+   if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");
+
+   // load a jpeg image from whichever source, but leave in YCbCr format
+   if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; }
+
+   // determine actual number of components to generate
+   n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1;
+
+   is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif));
+
+   if (z->s->img_n == 3 && n < 3 && !is_rgb)
+      decode_n = 1;
+   else
+      decode_n = z->s->img_n;
+
+   // resample and color-convert
+   {
+      int k;
+      unsigned int i,j;
+      stbi_uc *output;
+      stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL };
+
+      stbi__resample res_comp[4];
+
+      for (k=0; k < decode_n; ++k) {
+         stbi__resample *r = &res_comp[k];
+
+         // allocate line buffer big enough for upsampling off the edges
+         // with upsample factor of 4
+         z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3);
+         if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }
+
+         r->hs      = z->img_h_max / z->img_comp[k].h;
+         r->vs      = z->img_v_max / z->img_comp[k].v;
+         r->ystep   = r->vs >> 1;
+         r->w_lores = (z->s->img_x + r->hs-1) / r->hs;
+         r->ypos    = 0;
+         r->line0   = r->line1 = z->img_comp[k].data;
+
+         if      (r->hs == 1 && r->vs == 1) r->resample = resample_row_1;
+         else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2;
+         else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2;
+         else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel;
+         else                               r->resample = stbi__resample_row_generic;
+      }
+
+      // can't error after this so, this is safe
+      output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1);
+      if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }
+
+      // now go ahead and resample
+      for (j=0; j < z->s->img_y; ++j) {
+         stbi_uc *out = output + n * z->s->img_x * j;
+         for (k=0; k < decode_n; ++k) {
+            stbi__resample *r = &res_comp[k];
+            int y_bot = r->ystep >= (r->vs >> 1);
+            coutput[k] = r->resample(z->img_comp[k].linebuf,
+                                     y_bot ? r->line1 : r->line0,
+                                     y_bot ? r->line0 : r->line1,
+                                     r->w_lores, r->hs);
+            if (++r->ystep >= r->vs) {
+               r->ystep = 0;
+               r->line0 = r->line1;
+               if (++r->ypos < z->img_comp[k].y)
+                  r->line1 += z->img_comp[k].w2;
+            }
+         }
+         if (n >= 3) {
+            stbi_uc *y = coutput[0];
+            if (z->s->img_n == 3) {
+               if (is_rgb) {
+                  for (i=0; i < z->s->img_x; ++i) {
+                     out[0] = y[i];
+                     out[1] = coutput[1][i];
+                     out[2] = coutput[2][i];
+                     out[3] = 255;
+                     out += n;
+                  }
+               } else {
+                  z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
+               }
+            } else if (z->s->img_n == 4) {
+               if (z->app14_color_transform == 0) { // CMYK
+                  for (i=0; i < z->s->img_x; ++i) {
+                     stbi_uc m = coutput[3][i];
+                     out[0] = stbi__blinn_8x8(coutput[0][i], m);
+                     out[1] = stbi__blinn_8x8(coutput[1][i], m);
+                     out[2] = stbi__blinn_8x8(coutput[2][i], m);
+                     out[3] = 255;
+                     out += n;
+                  }
+               } else if (z->app14_color_transform == 2) { // YCCK
+                  z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
+                  for (i=0; i < z->s->img_x; ++i) {
+                     stbi_uc m = coutput[3][i];
+                     out[0] = stbi__blinn_8x8(255 - out[0], m);
+                     out[1] = stbi__blinn_8x8(255 - out[1], m);
+                     out[2] = stbi__blinn_8x8(255 - out[2], m);
+                     out += n;
+                  }
+               } else { // YCbCr + alpha?  Ignore the fourth channel for now
+                  z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
+               }
+            } else
+               for (i=0; i < z->s->img_x; ++i) {
+                  out[0] = out[1] = out[2] = y[i];
+                  out[3] = 255; // not used if n==3
+                  out += n;
+               }
+         } else {
+            if (is_rgb) {
+               if (n == 1)
+                  for (i=0; i < z->s->img_x; ++i)
+                     *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);
+               else {
+                  for (i=0; i < z->s->img_x; ++i, out += 2) {
+                     out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);
+                     out[1] = 255;
+                  }
+               }
+            } else if (z->s->img_n == 4 && z->app14_color_transform == 0) {
+               for (i=0; i < z->s->img_x; ++i) {
+                  stbi_uc m = coutput[3][i];
+                  stbi_uc r = stbi__blinn_8x8(coutput[0][i], m);
+                  stbi_uc g = stbi__blinn_8x8(coutput[1][i], m);
+                  stbi_uc b = stbi__blinn_8x8(coutput[2][i], m);
+                  out[0] = stbi__compute_y(r, g, b);
+                  out[1] = 255;
+                  out += n;
+               }
+            } else if (z->s->img_n == 4 && z->app14_color_transform == 2) {
+               for (i=0; i < z->s->img_x; ++i) {
+                  out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]);
+                  out[1] = 255;
+                  out += n;
+               }
+            } else {
+               stbi_uc *y = coutput[0];
+               if (n == 1)
+                  for (i=0; i < z->s->img_x; ++i) out[i] = y[i];
+               else
+                  for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; }
+            }
+         }
+      }
+      stbi__cleanup_jpeg(z);
+      *out_x = z->s->img_x;
+      *out_y = z->s->img_y;
+      if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output
+      return output;
+   }
+}
+
+static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   unsigned char* result;
+   stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg));
+   STBI_NOTUSED(ri);
+   j->s = s;
+   stbi__setup_jpeg(j);
+   result = load_jpeg_image(j, x,y,comp,req_comp);
+   STBI_FREE(j);
+   return result;
+}
+
+static int stbi__jpeg_test(stbi__context *s)
+{
+   int r;
+   stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg));
+   j->s = s;
+   stbi__setup_jpeg(j);
+   r = stbi__decode_jpeg_header(j, STBI__SCAN_type);
+   stbi__rewind(s);
+   STBI_FREE(j);
+   return r;
+}
+
+static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp)
+{
+   if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) {
+      stbi__rewind( j->s );
+      return 0;
+   }
+   if (x) *x = j->s->img_x;
+   if (y) *y = j->s->img_y;
+   if (comp) *comp = j->s->img_n >= 3 ? 3 : 1;
+   return 1;
+}
+
+static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   int result;
+   stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg)));
+   j->s = s;
+   result = stbi__jpeg_info_raw(j, x, y, comp);
+   STBI_FREE(j);
+   return result;
+}
+#endif
+
+// public domain zlib decode    v0.2  Sean Barrett 2006-11-18
+//    simple implementation
+//      - all input must be provided in an upfront buffer
+//      - all output is written to a single output buffer (can malloc/realloc)
+//    performance
+//      - fast huffman
+
+#ifndef STBI_NO_ZLIB
+
+// fast-way is faster to check than jpeg huffman, but slow way is slower
+#define STBI__ZFAST_BITS  9 // accelerate all cases in default tables
+#define STBI__ZFAST_MASK  ((1 << STBI__ZFAST_BITS) - 1)
+
+// zlib-style huffman encoding
+// (jpegs packs from left, zlib from right, so can't share code)
+typedef struct
+{
+   stbi__uint16 fast[1 << STBI__ZFAST_BITS];
+   stbi__uint16 firstcode[16];
+   int maxcode[17];
+   stbi__uint16 firstsymbol[16];
+   stbi_uc  size[288];
+   stbi__uint16 value[288];
+} stbi__zhuffman;
+
+stbi_inline static int stbi__bitreverse16(int n)
+{
+  n = ((n & 0xAAAA) >>  1) | ((n & 0x5555) << 1);
+  n = ((n & 0xCCCC) >>  2) | ((n & 0x3333) << 2);
+  n = ((n & 0xF0F0) >>  4) | ((n & 0x0F0F) << 4);
+  n = ((n & 0xFF00) >>  8) | ((n & 0x00FF) << 8);
+  return n;
+}
+
+stbi_inline static int stbi__bit_reverse(int v, int bits)
+{
+   STBI_ASSERT(bits <= 16);
+   // to bit reverse n bits, reverse 16 and shift
+   // e.g. 11 bits, bit reverse and shift away 5
+   return stbi__bitreverse16(v) >> (16-bits);
+}
+
+static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num)
+{
+   int i,k=0;
+   int code, next_code[16], sizes[17];
+
+   // DEFLATE spec for generating codes
+   memset(sizes, 0, sizeof(sizes));
+   memset(z->fast, 0, sizeof(z->fast));
+   for (i=0; i < num; ++i)
+      ++sizes[sizelist[i]];
+   sizes[0] = 0;
+   for (i=1; i < 16; ++i)
+      if (sizes[i] > (1 << i))
+         return stbi__err("bad sizes", "Corrupt PNG");
+   code = 0;
+   for (i=1; i < 16; ++i) {
+      next_code[i] = code;
+      z->firstcode[i] = (stbi__uint16) code;
+      z->firstsymbol[i] = (stbi__uint16) k;
+      code = (code + sizes[i]);
+      if (sizes[i])
+         if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG");
+      z->maxcode[i] = code << (16-i); // preshift for inner loop
+      code <<= 1;
+      k += sizes[i];
+   }
+   z->maxcode[16] = 0x10000; // sentinel
+   for (i=0; i < num; ++i) {
+      int s = sizelist[i];
+      if (s) {
+         int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s];
+         stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i);
+         z->size [c] = (stbi_uc     ) s;
+         z->value[c] = (stbi__uint16) i;
+         if (s <= STBI__ZFAST_BITS) {
+            int j = stbi__bit_reverse(next_code[s],s);
+            while (j < (1 << STBI__ZFAST_BITS)) {
+               z->fast[j] = fastv;
+               j += (1 << s);
+            }
+         }
+         ++next_code[s];
+      }
+   }
+   return 1;
+}
+
+// zlib-from-memory implementation for PNG reading
+//    because PNG allows splitting the zlib stream arbitrarily,
+//    and it's annoying structurally to have PNG call ZLIB call PNG,
+//    we require PNG read all the IDATs and combine them into a single
+//    memory buffer
+
+typedef struct
+{
+   stbi_uc *zbuffer, *zbuffer_end;
+   int num_bits;
+   stbi__uint32 code_buffer;
+
+   char *zout;
+   char *zout_start;
+   char *zout_end;
+   int   z_expandable;
+
+   stbi__zhuffman z_length, z_distance;
+} stbi__zbuf;
+
+stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z)
+{
+   if (z->zbuffer >= z->zbuffer_end) return 0;
+   return *z->zbuffer++;
+}
+
+static void stbi__fill_bits(stbi__zbuf *z)
+{
+   do {
+      STBI_ASSERT(z->code_buffer < (1U << z->num_bits));
+      z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits;
+      z->num_bits += 8;
+   } while (z->num_bits <= 24);
+}
+
+stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n)
+{
+   unsigned int k;
+   if (z->num_bits < n) stbi__fill_bits(z);
+   k = z->code_buffer & ((1 << n) - 1);
+   z->code_buffer >>= n;
+   z->num_bits -= n;
+   return k;
+}
+
+static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z)
+{
+   int b,s,k;
+   // not resolved by fast table, so compute it the slow way
+   // use jpeg approach, which requires MSbits at top
+   k = stbi__bit_reverse(a->code_buffer, 16);
+   for (s=STBI__ZFAST_BITS+1; ; ++s)
+      if (k < z->maxcode[s])
+         break;
+   if (s == 16) return -1; // invalid code!
+   // code size is s, so:
+   b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s];
+   STBI_ASSERT(z->size[b] == s);
+   a->code_buffer >>= s;
+   a->num_bits -= s;
+   return z->value[b];
+}
+
+stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z)
+{
+   int b,s;
+   if (a->num_bits < 16) stbi__fill_bits(a);
+   b = z->fast[a->code_buffer & STBI__ZFAST_MASK];
+   if (b) {
+      s = b >> 9;
+      a->code_buffer >>= s;
+      a->num_bits -= s;
+      return b & 511;
+   }
+   return stbi__zhuffman_decode_slowpath(a, z);
+}
+
+static int stbi__zexpand(stbi__zbuf *z, char *zout, int n)  // need to make room for n bytes
+{
+   char *q;
+   int cur, limit, old_limit;
+   z->zout = zout;
+   if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG");
+   cur   = (int) (z->zout     - z->zout_start);
+   limit = old_limit = (int) (z->zout_end - z->zout_start);
+   while (cur + n > limit)
+      limit *= 2;
+   q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit);
+   STBI_NOTUSED(old_limit);
+   if (q == NULL) return stbi__err("outofmem", "Out of memory");
+   z->zout_start = q;
+   z->zout       = q + cur;
+   z->zout_end   = q + limit;
+   return 1;
+}
+
+static const int stbi__zlength_base[31] = {
+   3,4,5,6,7,8,9,10,11,13,
+   15,17,19,23,27,31,35,43,51,59,
+   67,83,99,115,131,163,195,227,258,0,0 };
+
+static const int stbi__zlength_extra[31]=
+{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 };
+
+static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,
+257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0};
+
+static const int stbi__zdist_extra[32] =
+{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
+
+static int stbi__parse_huffman_block(stbi__zbuf *a)
+{
+   char *zout = a->zout;
+   for(;;) {
+      int z = stbi__zhuffman_decode(a, &a->z_length);
+      if (z < 256) {
+         if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes
+         if (zout >= a->zout_end) {
+            if (!stbi__zexpand(a, zout, 1)) return 0;
+            zout = a->zout;
+         }
+         *zout++ = (char) z;
+      } else {
+         stbi_uc *p;
+         int len,dist;
+         if (z == 256) {
+            a->zout = zout;
+            return 1;
+         }
+         z -= 257;
+         len = stbi__zlength_base[z];
+         if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]);
+         z = stbi__zhuffman_decode(a, &a->z_distance);
+         if (z < 0) return stbi__err("bad huffman code","Corrupt PNG");
+         dist = stbi__zdist_base[z];
+         if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]);
+         if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG");
+         if (zout + len > a->zout_end) {
+            if (!stbi__zexpand(a, zout, len)) return 0;
+            zout = a->zout;
+         }
+         p = (stbi_uc *) (zout - dist);
+         if (dist == 1) { // run of one byte; common in images.
+            stbi_uc v = *p;
+            if (len) { do *zout++ = v; while (--len); }
+         } else {
+            if (len) { do *zout++ = *p++; while (--len); }
+         }
+      }
+   }
+}
+
+static int stbi__compute_huffman_codes(stbi__zbuf *a)
+{
+   static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 };
+   stbi__zhuffman z_codelength;
+   stbi_uc lencodes[286+32+137];//padding for maximum single op
+   stbi_uc codelength_sizes[19];
+   int i,n;
+
+   int hlit  = stbi__zreceive(a,5) + 257;
+   int hdist = stbi__zreceive(a,5) + 1;
+   int hclen = stbi__zreceive(a,4) + 4;
+   int ntot  = hlit + hdist;
+
+   memset(codelength_sizes, 0, sizeof(codelength_sizes));
+   for (i=0; i < hclen; ++i) {
+      int s = stbi__zreceive(a,3);
+      codelength_sizes[length_dezigzag[i]] = (stbi_uc) s;
+   }
+   if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0;
+
+   n = 0;
+   while (n < ntot) {
+      int c = stbi__zhuffman_decode(a, &z_codelength);
+      if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG");
+      if (c < 16)
+         lencodes[n++] = (stbi_uc) c;
+      else {
+         stbi_uc fill = 0;
+         if (c == 16) {
+            c = stbi__zreceive(a,2)+3;
+            if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG");
+            fill = lencodes[n-1];
+         } else if (c == 17)
+            c = stbi__zreceive(a,3)+3;
+         else {
+            STBI_ASSERT(c == 18);
+            c = stbi__zreceive(a,7)+11;
+         }
+         if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG");
+         memset(lencodes+n, fill, c);
+         n += c;
+      }
+   }
+   if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG");
+   if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0;
+   if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0;
+   return 1;
+}
+
+static int stbi__parse_uncompressed_block(stbi__zbuf *a)
+{
+   stbi_uc header[4];
+   int len,nlen,k;
+   if (a->num_bits & 7)
+      stbi__zreceive(a, a->num_bits & 7); // discard
+   // drain the bit-packed data into header
+   k = 0;
+   while (a->num_bits > 0) {
+      header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check
+      a->code_buffer >>= 8;
+      a->num_bits -= 8;
+   }
+   STBI_ASSERT(a->num_bits == 0);
+   // now fill header the normal way
+   while (k < 4)
+      header[k++] = stbi__zget8(a);
+   len  = header[1] * 256 + header[0];
+   nlen = header[3] * 256 + header[2];
+   if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG");
+   if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG");
+   if (a->zout + len > a->zout_end)
+      if (!stbi__zexpand(a, a->zout, len)) return 0;
+   memcpy(a->zout, a->zbuffer, len);
+   a->zbuffer += len;
+   a->zout += len;
+   return 1;
+}
+
+static int stbi__parse_zlib_header(stbi__zbuf *a)
+{
+   int cmf   = stbi__zget8(a);
+   int cm    = cmf & 15;
+   /* int cinfo = cmf >> 4; */
+   int flg   = stbi__zget8(a);
+   if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec
+   if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png
+   if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png
+   // window = 1 << (8 + cinfo)... but who cares, we fully buffer output
+   return 1;
+}
+
+static const stbi_uc stbi__zdefault_length[288] =
+{
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+   9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+   9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+   9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8
+};
+static const stbi_uc stbi__zdefault_distance[32] =
+{
+   5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5
+};
+/*
+Init algorithm:
+{
+   int i;   // use <= to match clearly with spec
+   for (i=0; i <= 143; ++i)     stbi__zdefault_length[i]   = 8;
+   for (   ; i <= 255; ++i)     stbi__zdefault_length[i]   = 9;
+   for (   ; i <= 279; ++i)     stbi__zdefault_length[i]   = 7;
+   for (   ; i <= 287; ++i)     stbi__zdefault_length[i]   = 8;
+
+   for (i=0; i <=  31; ++i)     stbi__zdefault_distance[i] = 5;
+}
+*/
+
+static int stbi__parse_zlib(stbi__zbuf *a, int parse_header)
+{
+   int final, type;
+   if (parse_header)
+      if (!stbi__parse_zlib_header(a)) return 0;
+   a->num_bits = 0;
+   a->code_buffer = 0;
+   do {
+      final = stbi__zreceive(a,1);
+      type = stbi__zreceive(a,2);
+      if (type == 0) {
+         if (!stbi__parse_uncompressed_block(a)) return 0;
+      } else if (type == 3) {
+         return 0;
+      } else {
+         if (type == 1) {
+            // use fixed code lengths
+            if (!stbi__zbuild_huffman(&a->z_length  , stbi__zdefault_length  , 288)) return 0;
+            if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance,  32)) return 0;
+         } else {
+            if (!stbi__compute_huffman_codes(a)) return 0;
+         }
+         if (!stbi__parse_huffman_block(a)) return 0;
+      }
+   } while (!final);
+   return 1;
+}
+
+static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header)
+{
+   a->zout_start = obuf;
+   a->zout       = obuf;
+   a->zout_end   = obuf + olen;
+   a->z_expandable = exp;
+
+   return stbi__parse_zlib(a, parse_header);
+}
+
+STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)
+{
+   stbi__zbuf a;
+   char *p = (char *) stbi__malloc(initial_size);
+   if (p == NULL) return NULL;
+   a.zbuffer = (stbi_uc *) buffer;
+   a.zbuffer_end = (stbi_uc *) buffer + len;
+   if (stbi__do_zlib(&a, p, initial_size, 1, 1)) {
+      if (outlen) *outlen = (int) (a.zout - a.zout_start);
+      return a.zout_start;
+   } else {
+      STBI_FREE(a.zout_start);
+      return NULL;
+   }
+}
+
+STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen)
+{
+   return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen);
+}
+
+STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)
+{
+   stbi__zbuf a;
+   char *p = (char *) stbi__malloc(initial_size);
+   if (p == NULL) return NULL;
+   a.zbuffer = (stbi_uc *) buffer;
+   a.zbuffer_end = (stbi_uc *) buffer + len;
+   if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) {
+      if (outlen) *outlen = (int) (a.zout - a.zout_start);
+      return a.zout_start;
+   } else {
+      STBI_FREE(a.zout_start);
+      return NULL;
+   }
+}
+
+STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen)
+{
+   stbi__zbuf a;
+   a.zbuffer = (stbi_uc *) ibuffer;
+   a.zbuffer_end = (stbi_uc *) ibuffer + ilen;
+   if (stbi__do_zlib(&a, obuffer, olen, 0, 1))
+      return (int) (a.zout - a.zout_start);
+   else
+      return -1;
+}
+
+STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)
+{
+   stbi__zbuf a;
+   char *p = (char *) stbi__malloc(16384);
+   if (p == NULL) return NULL;
+   a.zbuffer = (stbi_uc *) buffer;
+   a.zbuffer_end = (stbi_uc *) buffer+len;
+   if (stbi__do_zlib(&a, p, 16384, 1, 0)) {
+      if (outlen) *outlen = (int) (a.zout - a.zout_start);
+      return a.zout_start;
+   } else {
+      STBI_FREE(a.zout_start);
+      return NULL;
+   }
+}
+
+STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen)
+{
+   stbi__zbuf a;
+   a.zbuffer = (stbi_uc *) ibuffer;
+   a.zbuffer_end = (stbi_uc *) ibuffer + ilen;
+   if (stbi__do_zlib(&a, obuffer, olen, 0, 0))
+      return (int) (a.zout - a.zout_start);
+   else
+      return -1;
+}
+#endif
+
+// public domain "baseline" PNG decoder   v0.10  Sean Barrett 2006-11-18
+//    simple implementation
+//      - only 8-bit samples
+//      - no CRC checking
+//      - allocates lots of intermediate memory
+//        - avoids problem of streaming data between subsystems
+//        - avoids explicit window management
+//    performance
+//      - uses stb_zlib, a PD zlib implementation with fast huffman decoding
+
+#ifndef STBI_NO_PNG
+typedef struct
+{
+   stbi__uint32 length;
+   stbi__uint32 type;
+} stbi__pngchunk;
+
+static stbi__pngchunk stbi__get_chunk_header(stbi__context *s)
+{
+   stbi__pngchunk c;
+   c.length = stbi__get32be(s);
+   c.type   = stbi__get32be(s);
+   return c;
+}
+
+static int stbi__check_png_header(stbi__context *s)
+{
+   static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 };
+   int i;
+   for (i=0; i < 8; ++i)
+      if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG");
+   return 1;
+}
+
+typedef struct
+{
+   stbi__context *s;
+   stbi_uc *idata, *expanded, *out;
+   int depth;
+} stbi__png;
+
+
+enum {
+   STBI__F_none=0,
+   STBI__F_sub=1,
+   STBI__F_up=2,
+   STBI__F_avg=3,
+   STBI__F_paeth=4,
+   // synthetic filters used for first scanline to avoid needing a dummy row of 0s
+   STBI__F_avg_first,
+   STBI__F_paeth_first
+};
+
+static stbi_uc first_row_filter[5] =
+{
+   STBI__F_none,
+   STBI__F_sub,
+   STBI__F_none,
+   STBI__F_avg_first,
+   STBI__F_paeth_first
+};
+
+static int stbi__paeth(int a, int b, int c)
+{
+   int p = a + b - c;
+   int pa = abs(p-a);
+   int pb = abs(p-b);
+   int pc = abs(p-c);
+   if (pa <= pb && pa <= pc) return a;
+   if (pb <= pc) return b;
+   return c;
+}
+
+static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 };
+
+// create the png data from post-deflated data
+static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color)
+{
+   int bytes = (depth == 16? 2 : 1);
+   stbi__context *s = a->s;
+   stbi__uint32 i,j,stride = x*out_n*bytes;
+   stbi__uint32 img_len, img_width_bytes;
+   int k;
+   int img_n = s->img_n; // copy it into a local for later
+
+   int output_bytes = out_n*bytes;
+   int filter_bytes = img_n*bytes;
+   int width = x;
+
+   STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1);
+   a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into
+   if (!a->out) return stbi__err("outofmem", "Out of memory");
+
+   if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG");
+   img_width_bytes = (((img_n * x * depth) + 7) >> 3);
+   img_len = (img_width_bytes + 1) * y;
+
+   // we used to check for exact match between raw_len and img_len on non-interlaced PNGs,
+   // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros),
+   // so just check for raw_len < img_len always.
+   if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG");
+
+   for (j=0; j < y; ++j) {
+      stbi_uc *cur = a->out + stride*j;
+      stbi_uc *prior;
+      int filter = *raw++;
+
+      if (filter > 4)
+         return stbi__err("invalid filter","Corrupt PNG");
+
+      if (depth < 8) {
+         STBI_ASSERT(img_width_bytes <= x);
+         cur += x*out_n - img_width_bytes; // store output to the rightmost img_len bytes, so we can decode in place
+         filter_bytes = 1;
+         width = img_width_bytes;
+      }
+      prior = cur - stride; // bugfix: need to compute this after 'cur +=' computation above
+
+      // if first row, use special filter that doesn't sample previous row
+      if (j == 0) filter = first_row_filter[filter];
+
+      // handle first byte explicitly
+      for (k=0; k < filter_bytes; ++k) {
+         switch (filter) {
+            case STBI__F_none       : cur[k] = raw[k]; break;
+            case STBI__F_sub        : cur[k] = raw[k]; break;
+            case STBI__F_up         : cur[k] = STBI__BYTECAST(raw[k] + prior[k]); break;
+            case STBI__F_avg        : cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); break;
+            case STBI__F_paeth      : cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(0,prior[k],0)); break;
+            case STBI__F_avg_first  : cur[k] = raw[k]; break;
+            case STBI__F_paeth_first: cur[k] = raw[k]; break;
+         }
+      }
+
+      if (depth == 8) {
+         if (img_n != out_n)
+            cur[img_n] = 255; // first pixel
+         raw += img_n;
+         cur += out_n;
+         prior += out_n;
+      } else if (depth == 16) {
+         if (img_n != out_n) {
+            cur[filter_bytes]   = 255; // first pixel top byte
+            cur[filter_bytes+1] = 255; // first pixel bottom byte
+         }
+         raw += filter_bytes;
+         cur += output_bytes;
+         prior += output_bytes;
+      } else {
+         raw += 1;
+         cur += 1;
+         prior += 1;
+      }
+
+      // this is a little gross, so that we don't switch per-pixel or per-component
+      if (depth < 8 || img_n == out_n) {
+         int nk = (width - 1)*filter_bytes;
+         #define STBI__CASE(f) \
+             case f:     \
+                for (k=0; k < nk; ++k)
+         switch (filter) {
+            // "none" filter turns into a memcpy here; make that explicit.
+            case STBI__F_none:         memcpy(cur, raw, nk); break;
+            STBI__CASE(STBI__F_sub)          { cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); } break;
+            STBI__CASE(STBI__F_up)           { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break;
+            STBI__CASE(STBI__F_avg)          { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); } break;
+            STBI__CASE(STBI__F_paeth)        { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],prior[k],prior[k-filter_bytes])); } break;
+            STBI__CASE(STBI__F_avg_first)    { cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); } break;
+            STBI__CASE(STBI__F_paeth_first)  { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],0,0)); } break;
+         }
+         #undef STBI__CASE
+         raw += nk;
+      } else {
+         STBI_ASSERT(img_n+1 == out_n);
+         #define STBI__CASE(f) \
+             case f:     \
+                for (i=x-1; i >= 1; --i, cur[filter_bytes]=255,raw+=filter_bytes,cur+=output_bytes,prior+=output_bytes) \
+                   for (k=0; k < filter_bytes; ++k)
+         switch (filter) {
+            STBI__CASE(STBI__F_none)         { cur[k] = raw[k]; } break;
+            STBI__CASE(STBI__F_sub)          { cur[k] = STBI__BYTECAST(raw[k] + cur[k- output_bytes]); } break;
+            STBI__CASE(STBI__F_up)           { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break;
+            STBI__CASE(STBI__F_avg)          { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k- output_bytes])>>1)); } break;
+            STBI__CASE(STBI__F_paeth)        { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],prior[k],prior[k- output_bytes])); } break;
+            STBI__CASE(STBI__F_avg_first)    { cur[k] = STBI__BYTECAST(raw[k] + (cur[k- output_bytes] >> 1)); } break;
+            STBI__CASE(STBI__F_paeth_first)  { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],0,0)); } break;
+         }
+         #undef STBI__CASE
+
+         // the loop above sets the high byte of the pixels' alpha, but for
+         // 16 bit png files we also need the low byte set. we'll do that here.
+         if (depth == 16) {
+            cur = a->out + stride*j; // start at the beginning of the row again
+            for (i=0; i < x; ++i,cur+=output_bytes) {
+               cur[filter_bytes+1] = 255;
+            }
+         }
+      }
+   }
+
+   // we make a separate pass to expand bits to pixels; for performance,
+   // this could run two scanlines behind the above code, so it won't
+   // intefere with filtering but will still be in the cache.
+   if (depth < 8) {
+      for (j=0; j < y; ++j) {
+         stbi_uc *cur = a->out + stride*j;
+         stbi_uc *in  = a->out + stride*j + x*out_n - img_width_bytes;
+         // unpack 1/2/4-bit into a 8-bit buffer. allows us to keep the common 8-bit path optimal at minimal cost for 1/2/4-bit
+         // png guarante byte alignment, if width is not multiple of 8/4/2 we'll decode dummy trailing data that will be skipped in the later loop
+         stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range
+
+         // note that the final byte might overshoot and write more data than desired.
+         // we can allocate enough data that this never writes out of memory, but it
+         // could also overwrite the next scanline. can it overwrite non-empty data
+         // on the next scanline? yes, consider 1-pixel-wide scanlines with 1-bit-per-pixel.
+         // so we need to explicitly clamp the final ones
+
+         if (depth == 4) {
+            for (k=x*img_n; k >= 2; k-=2, ++in) {
+               *cur++ = scale * ((*in >> 4)       );
+               *cur++ = scale * ((*in     ) & 0x0f);
+            }
+            if (k > 0) *cur++ = scale * ((*in >> 4)       );
+         } else if (depth == 2) {
+            for (k=x*img_n; k >= 4; k-=4, ++in) {
+               *cur++ = scale * ((*in >> 6)       );
+               *cur++ = scale * ((*in >> 4) & 0x03);
+               *cur++ = scale * ((*in >> 2) & 0x03);
+               *cur++ = scale * ((*in     ) & 0x03);
+            }
+            if (k > 0) *cur++ = scale * ((*in >> 6)       );
+            if (k > 1) *cur++ = scale * ((*in >> 4) & 0x03);
+            if (k > 2) *cur++ = scale * ((*in >> 2) & 0x03);
+         } else if (depth == 1) {
+            for (k=x*img_n; k >= 8; k-=8, ++in) {
+               *cur++ = scale * ((*in >> 7)       );
+               *cur++ = scale * ((*in >> 6) & 0x01);
+               *cur++ = scale * ((*in >> 5) & 0x01);
+               *cur++ = scale * ((*in >> 4) & 0x01);
+               *cur++ = scale * ((*in >> 3) & 0x01);
+               *cur++ = scale * ((*in >> 2) & 0x01);
+               *cur++ = scale * ((*in >> 1) & 0x01);
+               *cur++ = scale * ((*in     ) & 0x01);
+            }
+            if (k > 0) *cur++ = scale * ((*in >> 7)       );
+            if (k > 1) *cur++ = scale * ((*in >> 6) & 0x01);
+            if (k > 2) *cur++ = scale * ((*in >> 5) & 0x01);
+            if (k > 3) *cur++ = scale * ((*in >> 4) & 0x01);
+            if (k > 4) *cur++ = scale * ((*in >> 3) & 0x01);
+            if (k > 5) *cur++ = scale * ((*in >> 2) & 0x01);
+            if (k > 6) *cur++ = scale * ((*in >> 1) & 0x01);
+         }
+         if (img_n != out_n) {
+            int q;
+            // insert alpha = 255
+            cur = a->out + stride*j;
+            if (img_n == 1) {
+               for (q=x-1; q >= 0; --q) {
+                  cur[q*2+1] = 255;
+                  cur[q*2+0] = cur[q];
+               }
+            } else {
+               STBI_ASSERT(img_n == 3);
+               for (q=x-1; q >= 0; --q) {
+                  cur[q*4+3] = 255;
+                  cur[q*4+2] = cur[q*3+2];
+                  cur[q*4+1] = cur[q*3+1];
+                  cur[q*4+0] = cur[q*3+0];
+               }
+            }
+         }
+      }
+   } else if (depth == 16) {
+      // force the image data from big-endian to platform-native.
+      // this is done in a separate pass due to the decoding relying
+      // on the data being untouched, but could probably be done
+      // per-line during decode if care is taken.
+      stbi_uc *cur = a->out;
+      stbi__uint16 *cur16 = (stbi__uint16*)cur;
+
+      for(i=0; i < x*y*out_n; ++i,cur16++,cur+=2) {
+         *cur16 = (cur[0] << 8) | cur[1];
+      }
+   }
+
+   return 1;
+}
+
+static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced)
+{
+   int bytes = (depth == 16 ? 2 : 1);
+   int out_bytes = out_n * bytes;
+   stbi_uc *final;
+   int p;
+   if (!interlaced)
+      return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color);
+
+   // de-interlacing
+   final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0);
+   for (p=0; p < 7; ++p) {
+      int xorig[] = { 0,4,0,2,0,1,0 };
+      int yorig[] = { 0,0,4,0,2,0,1 };
+      int xspc[]  = { 8,8,4,4,2,2,1 };
+      int yspc[]  = { 8,8,8,4,4,2,2 };
+      int i,j,x,y;
+      // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1
+      x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p];
+      y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p];
+      if (x && y) {
+         stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y;
+         if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) {
+            STBI_FREE(final);
+            return 0;
+         }
+         for (j=0; j < y; ++j) {
+            for (i=0; i < x; ++i) {
+               int out_y = j*yspc[p]+yorig[p];
+               int out_x = i*xspc[p]+xorig[p];
+               memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes,
+                      a->out + (j*x+i)*out_bytes, out_bytes);
+            }
+         }
+         STBI_FREE(a->out);
+         image_data += img_len;
+         image_data_len -= img_len;
+      }
+   }
+   a->out = final;
+
+   return 1;
+}
+
+static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n)
+{
+   stbi__context *s = z->s;
+   stbi__uint32 i, pixel_count = s->img_x * s->img_y;
+   stbi_uc *p = z->out;
+
+   // compute color-based transparency, assuming we've
+   // already got 255 as the alpha value in the output
+   STBI_ASSERT(out_n == 2 || out_n == 4);
+
+   if (out_n == 2) {
+      for (i=0; i < pixel_count; ++i) {
+         p[1] = (p[0] == tc[0] ? 0 : 255);
+         p += 2;
+      }
+   } else {
+      for (i=0; i < pixel_count; ++i) {
+         if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
+            p[3] = 0;
+         p += 4;
+      }
+   }
+   return 1;
+}
+
+static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n)
+{
+   stbi__context *s = z->s;
+   stbi__uint32 i, pixel_count = s->img_x * s->img_y;
+   stbi__uint16 *p = (stbi__uint16*) z->out;
+
+   // compute color-based transparency, assuming we've
+   // already got 65535 as the alpha value in the output
+   STBI_ASSERT(out_n == 2 || out_n == 4);
+
+   if (out_n == 2) {
+      for (i = 0; i < pixel_count; ++i) {
+         p[1] = (p[0] == tc[0] ? 0 : 65535);
+         p += 2;
+      }
+   } else {
+      for (i = 0; i < pixel_count; ++i) {
+         if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
+            p[3] = 0;
+         p += 4;
+      }
+   }
+   return 1;
+}
+
+static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n)
+{
+   stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y;
+   stbi_uc *p, *temp_out, *orig = a->out;
+
+   p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0);
+   if (p == NULL) return stbi__err("outofmem", "Out of memory");
+
+   // between here and free(out) below, exitting would leak
+   temp_out = p;
+
+   if (pal_img_n == 3) {
+      for (i=0; i < pixel_count; ++i) {
+         int n = orig[i]*4;
+         p[0] = palette[n  ];
+         p[1] = palette[n+1];
+         p[2] = palette[n+2];
+         p += 3;
+      }
+   } else {
+      for (i=0; i < pixel_count; ++i) {
+         int n = orig[i]*4;
+         p[0] = palette[n  ];
+         p[1] = palette[n+1];
+         p[2] = palette[n+2];
+         p[3] = palette[n+3];
+         p += 4;
+      }
+   }
+   STBI_FREE(a->out);
+   a->out = temp_out;
+
+   STBI_NOTUSED(len);
+
+   return 1;
+}
+
+static int stbi__unpremultiply_on_load = 0;
+static int stbi__de_iphone_flag = 0;
+
+STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply)
+{
+   stbi__unpremultiply_on_load = flag_true_if_should_unpremultiply;
+}
+
+STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)
+{
+   stbi__de_iphone_flag = flag_true_if_should_convert;
+}
+
+static void stbi__de_iphone(stbi__png *z)
+{
+   stbi__context *s = z->s;
+   stbi__uint32 i, pixel_count = s->img_x * s->img_y;
+   stbi_uc *p = z->out;
+
+   if (s->img_out_n == 3) {  // convert bgr to rgb
+      for (i=0; i < pixel_count; ++i) {
+         stbi_uc t = p[0];
+         p[0] = p[2];
+         p[2] = t;
+         p += 3;
+      }
+   } else {
+      STBI_ASSERT(s->img_out_n == 4);
+      if (stbi__unpremultiply_on_load) {
+         // convert bgr to rgb and unpremultiply
+         for (i=0; i < pixel_count; ++i) {
+            stbi_uc a = p[3];
+            stbi_uc t = p[0];
+            if (a) {
+               stbi_uc half = a / 2;
+               p[0] = (p[2] * 255 + half) / a;
+               p[1] = (p[1] * 255 + half) / a;
+               p[2] = ( t   * 255 + half) / a;
+            } else {
+               p[0] = p[2];
+               p[2] = t;
+            }
+            p += 4;
+         }
+      } else {
+         // convert bgr to rgb
+         for (i=0; i < pixel_count; ++i) {
+            stbi_uc t = p[0];
+            p[0] = p[2];
+            p[2] = t;
+            p += 4;
+         }
+      }
+   }
+}
+
+#define STBI__PNG_TYPE(a,b,c,d)  (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d))
+
+static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)
+{
+   stbi_uc palette[1024], pal_img_n=0;
+   stbi_uc has_trans=0, tc[3]={0};
+   stbi__uint16 tc16[3];
+   stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0;
+   int first=1,k,interlace=0, color=0, is_iphone=0;
+   stbi__context *s = z->s;
+
+   z->expanded = NULL;
+   z->idata = NULL;
+   z->out = NULL;
+
+   if (!stbi__check_png_header(s)) return 0;
+
+   if (scan == STBI__SCAN_type) return 1;
+
+   for (;;) {
+      stbi__pngchunk c = stbi__get_chunk_header(s);
+      switch (c.type) {
+         case STBI__PNG_TYPE('C','g','B','I'):
+            is_iphone = 1;
+            stbi__skip(s, c.length);
+            break;
+         case STBI__PNG_TYPE('I','H','D','R'): {
+            int comp,filter;
+            if (!first) return stbi__err("multiple IHDR","Corrupt PNG");
+            first = 0;
+            if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG");
+            s->img_x = stbi__get32be(s); if (s->img_x > (1 << 24)) return stbi__err("too large","Very large image (corrupt?)");
+            s->img_y = stbi__get32be(s); if (s->img_y > (1 << 24)) return stbi__err("too large","Very large image (corrupt?)");
+            z->depth = stbi__get8(s);  if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16)  return stbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only");
+            color = stbi__get8(s);  if (color > 6)         return stbi__err("bad ctype","Corrupt PNG");
+            if (color == 3 && z->depth == 16)                  return stbi__err("bad ctype","Corrupt PNG");
+            if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG");
+            comp  = stbi__get8(s);  if (comp) return stbi__err("bad comp method","Corrupt PNG");
+            filter= stbi__get8(s);  if (filter) return stbi__err("bad filter method","Corrupt PNG");
+            interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG");
+            if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG");
+            if (!pal_img_n) {
+               s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0);
+               if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode");
+               if (scan == STBI__SCAN_header) return 1;
+            } else {
+               // if paletted, then pal_n is our final components, and
+               // img_n is # components to decompress/filter.
+               s->img_n = 1;
+               if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG");
+               // if SCAN_header, have to scan to see if we have a tRNS
+            }
+            break;
+         }
+
+         case STBI__PNG_TYPE('P','L','T','E'):  {
+            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
+            if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG");
+            pal_len = c.length / 3;
+            if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG");
+            for (i=0; i < pal_len; ++i) {
+               palette[i*4+0] = stbi__get8(s);
+               palette[i*4+1] = stbi__get8(s);
+               palette[i*4+2] = stbi__get8(s);
+               palette[i*4+3] = 255;
+            }
+            break;
+         }
+
+         case STBI__PNG_TYPE('t','R','N','S'): {
+            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
+            if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG");
+            if (pal_img_n) {
+               if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; }
+               if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG");
+               if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG");
+               pal_img_n = 4;
+               for (i=0; i < c.length; ++i)
+                  palette[i*4+3] = stbi__get8(s);
+            } else {
+               if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG");
+               if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG");
+               has_trans = 1;
+               if (z->depth == 16) {
+                  for (k = 0; k < s->img_n; ++k) tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is
+               } else {
+                  for (k = 0; k < s->img_n; ++k) tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger
+               }
+            }
+            break;
+         }
+
+         case STBI__PNG_TYPE('I','D','A','T'): {
+            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
+            if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG");
+            if (scan == STBI__SCAN_header) { s->img_n = pal_img_n; return 1; }
+            if ((int)(ioff + c.length) < (int)ioff) return 0;
+            if (ioff + c.length > idata_limit) {
+               stbi__uint32 idata_limit_old = idata_limit;
+               stbi_uc *p;
+               if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096;
+               while (ioff + c.length > idata_limit)
+                  idata_limit *= 2;
+               STBI_NOTUSED(idata_limit_old);
+               p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory");
+               z->idata = p;
+            }
+            if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG");
+            ioff += c.length;
+            break;
+         }
+
+         case STBI__PNG_TYPE('I','E','N','D'): {
+            stbi__uint32 raw_len, bpl;
+            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
+            if (scan != STBI__SCAN_load) return 1;
+            if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG");
+            // initial guess for decoded data size to avoid unnecessary reallocs
+            bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component
+            raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */;
+            z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone);
+            if (z->expanded == NULL) return 0; // zlib should set error
+            STBI_FREE(z->idata); z->idata = NULL;
+            if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans)
+               s->img_out_n = s->img_n+1;
+            else
+               s->img_out_n = s->img_n;
+            if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0;
+            if (has_trans) {
+               if (z->depth == 16) {
+                  if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0;
+               } else {
+                  if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0;
+               }
+            }
+            if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2)
+               stbi__de_iphone(z);
+            if (pal_img_n) {
+               // pal_img_n == 3 or 4
+               s->img_n = pal_img_n; // record the actual colors we had
+               s->img_out_n = pal_img_n;
+               if (req_comp >= 3) s->img_out_n = req_comp;
+               if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n))
+                  return 0;
+            } else if (has_trans) {
+               // non-paletted image with tRNS -> source image has (constant) alpha
+               ++s->img_n;
+            }
+            STBI_FREE(z->expanded); z->expanded = NULL;
+            return 1;
+         }
+
+         default:
+            // if critical, fail
+            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
+            if ((c.type & (1 << 29)) == 0) {
+               #ifndef STBI_NO_FAILURE_STRINGS
+               // not threadsafe
+               static char invalid_chunk[] = "XXXX PNG chunk not known";
+               invalid_chunk[0] = STBI__BYTECAST(c.type >> 24);
+               invalid_chunk[1] = STBI__BYTECAST(c.type >> 16);
+               invalid_chunk[2] = STBI__BYTECAST(c.type >>  8);
+               invalid_chunk[3] = STBI__BYTECAST(c.type >>  0);
+               #endif
+               return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type");
+            }
+            stbi__skip(s, c.length);
+            break;
+      }
+      // end of PNG chunk, read and skip CRC
+      stbi__get32be(s);
+   }
+}
+
+static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri)
+{
+   void *result=NULL;
+   if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");
+   if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) {
+      if (p->depth < 8)
+         ri->bits_per_channel = 8;
+      else
+         ri->bits_per_channel = p->depth;
+      result = p->out;
+      p->out = NULL;
+      if (req_comp && req_comp != p->s->img_out_n) {
+         if (ri->bits_per_channel == 8)
+            result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
+         else
+            result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
+         p->s->img_out_n = req_comp;
+         if (result == NULL) return result;
+      }
+      *x = p->s->img_x;
+      *y = p->s->img_y;
+      if (n) *n = p->s->img_n;
+   }
+   STBI_FREE(p->out);      p->out      = NULL;
+   STBI_FREE(p->expanded); p->expanded = NULL;
+   STBI_FREE(p->idata);    p->idata    = NULL;
+
+   return result;
+}
+
+static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   stbi__png p;
+   p.s = s;
+   return stbi__do_png(&p, x,y,comp,req_comp, ri);
+}
+
+static int stbi__png_test(stbi__context *s)
+{
+   int r;
+   r = stbi__check_png_header(s);
+   stbi__rewind(s);
+   return r;
+}
+
+static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp)
+{
+   if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) {
+      stbi__rewind( p->s );
+      return 0;
+   }
+   if (x) *x = p->s->img_x;
+   if (y) *y = p->s->img_y;
+   if (comp) *comp = p->s->img_n;
+   return 1;
+}
+
+static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   stbi__png p;
+   p.s = s;
+   return stbi__png_info_raw(&p, x, y, comp);
+}
+
+static int stbi__png_is16(stbi__context *s)
+{
+   stbi__png p;
+   p.s = s;
+   if (!stbi__png_info_raw(&p, NULL, NULL, NULL))
+	   return 0;
+   if (p.depth != 16) {
+      stbi__rewind(p.s);
+      return 0;
+   }
+   return 1;
+}
+#endif
+
+// Microsoft/Windows BMP image
+
+#ifndef STBI_NO_BMP
+static int stbi__bmp_test_raw(stbi__context *s)
+{
+   int r;
+   int sz;
+   if (stbi__get8(s) != 'B') return 0;
+   if (stbi__get8(s) != 'M') return 0;
+   stbi__get32le(s); // discard filesize
+   stbi__get16le(s); // discard reserved
+   stbi__get16le(s); // discard reserved
+   stbi__get32le(s); // discard data offset
+   sz = stbi__get32le(s);
+   r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124);
+   return r;
+}
+
+static int stbi__bmp_test(stbi__context *s)
+{
+   int r = stbi__bmp_test_raw(s);
+   stbi__rewind(s);
+   return r;
+}
+
+
+// returns 0..31 for the highest set bit
+static int stbi__high_bit(unsigned int z)
+{
+   int n=0;
+   if (z == 0) return -1;
+   if (z >= 0x10000) { n += 16; z >>= 16; }
+   if (z >= 0x00100) { n +=  8; z >>=  8; }
+   if (z >= 0x00010) { n +=  4; z >>=  4; }
+   if (z >= 0x00004) { n +=  2; z >>=  2; }
+   if (z >= 0x00002) { n +=  1; z >>=  1; }
+   return n;
+}
+
+static int stbi__bitcount(unsigned int a)
+{
+   a = (a & 0x55555555) + ((a >>  1) & 0x55555555); // max 2
+   a = (a & 0x33333333) + ((a >>  2) & 0x33333333); // max 4
+   a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits
+   a = (a + (a >> 8)); // max 16 per 8 bits
+   a = (a + (a >> 16)); // max 32 per 8 bits
+   return a & 0xff;
+}
+
+// extract an arbitrarily-aligned N-bit value (N=bits)
+// from v, and then make it 8-bits long and fractionally
+// extend it to full full range.
+static int stbi__shiftsigned(unsigned int v, int shift, int bits)
+{
+   static unsigned int mul_table[9] = {
+      0,
+      0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/,
+      0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/,
+   };
+   static unsigned int shift_table[9] = {
+      0, 0,0,1,0,2,4,6,0,
+   };
+   if (shift < 0)
+      v <<= -shift;
+   else
+      v >>= shift;
+   STBI_ASSERT(v >= 0 && v < 256);
+   v >>= (8-bits);
+   STBI_ASSERT(bits >= 0 && bits <= 8);
+   return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits];
+}
+
+typedef struct
+{
+   int bpp, offset, hsz;
+   unsigned int mr,mg,mb,ma, all_a;
+} stbi__bmp_data;
+
+static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info)
+{
+   int hsz;
+   if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP");
+   stbi__get32le(s); // discard filesize
+   stbi__get16le(s); // discard reserved
+   stbi__get16le(s); // discard reserved
+   info->offset = stbi__get32le(s);
+   info->hsz = hsz = stbi__get32le(s);
+   info->mr = info->mg = info->mb = info->ma = 0;
+
+   if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown");
+   if (hsz == 12) {
+      s->img_x = stbi__get16le(s);
+      s->img_y = stbi__get16le(s);
+   } else {
+      s->img_x = stbi__get32le(s);
+      s->img_y = stbi__get32le(s);
+   }
+   if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP");
+   info->bpp = stbi__get16le(s);
+   if (hsz != 12) {
+      int compress = stbi__get32le(s);
+      if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE");
+      stbi__get32le(s); // discard sizeof
+      stbi__get32le(s); // discard hres
+      stbi__get32le(s); // discard vres
+      stbi__get32le(s); // discard colorsused
+      stbi__get32le(s); // discard max important
+      if (hsz == 40 || hsz == 56) {
+         if (hsz == 56) {
+            stbi__get32le(s);
+            stbi__get32le(s);
+            stbi__get32le(s);
+            stbi__get32le(s);
+         }
+         if (info->bpp == 16 || info->bpp == 32) {
+            if (compress == 0) {
+               if (info->bpp == 32) {
+                  info->mr = 0xffu << 16;
+                  info->mg = 0xffu <<  8;
+                  info->mb = 0xffu <<  0;
+                  info->ma = 0xffu << 24;
+                  info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0
+               } else {
+                  info->mr = 31u << 10;
+                  info->mg = 31u <<  5;
+                  info->mb = 31u <<  0;
+               }
+            } else if (compress == 3) {
+               info->mr = stbi__get32le(s);
+               info->mg = stbi__get32le(s);
+               info->mb = stbi__get32le(s);
+               // not documented, but generated by photoshop and handled by mspaint
+               if (info->mr == info->mg && info->mg == info->mb) {
+                  // ?!?!?
+                  return stbi__errpuc("bad BMP", "bad BMP");
+               }
+            } else
+               return stbi__errpuc("bad BMP", "bad BMP");
+         }
+      } else {
+         int i;
+         if (hsz != 108 && hsz != 124)
+            return stbi__errpuc("bad BMP", "bad BMP");
+         info->mr = stbi__get32le(s);
+         info->mg = stbi__get32le(s);
+         info->mb = stbi__get32le(s);
+         info->ma = stbi__get32le(s);
+         stbi__get32le(s); // discard color space
+         for (i=0; i < 12; ++i)
+            stbi__get32le(s); // discard color space parameters
+         if (hsz == 124) {
+            stbi__get32le(s); // discard rendering intent
+            stbi__get32le(s); // discard offset of profile data
+            stbi__get32le(s); // discard size of profile data
+            stbi__get32le(s); // discard reserved
+         }
+      }
+   }
+   return (void *) 1;
+}
+
+
+static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   stbi_uc *out;
+   unsigned int mr=0,mg=0,mb=0,ma=0, all_a;
+   stbi_uc pal[256][4];
+   int psize=0,i,j,width;
+   int flip_vertically, pad, target;
+   stbi__bmp_data info;
+   STBI_NOTUSED(ri);
+
+   info.all_a = 255;
+   if (stbi__bmp_parse_header(s, &info) == NULL)
+      return NULL; // error code already set
+
+   flip_vertically = ((int) s->img_y) > 0;
+   s->img_y = abs((int) s->img_y);
+
+   mr = info.mr;
+   mg = info.mg;
+   mb = info.mb;
+   ma = info.ma;
+   all_a = info.all_a;
+
+   if (info.hsz == 12) {
+      if (info.bpp < 24)
+         psize = (info.offset - 14 - 24) / 3;
+   } else {
+      if (info.bpp < 16)
+         psize = (info.offset - 14 - info.hsz) >> 2;
+   }
+
+   s->img_n = ma ? 4 : 3;
+   if (req_comp && req_comp >= 3) // we can directly decode 3 or 4
+      target = req_comp;
+   else
+      target = s->img_n; // if they want monochrome, we'll post-convert
+
+   // sanity-check size
+   if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0))
+      return stbi__errpuc("too large", "Corrupt BMP");
+
+   out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0);
+   if (!out) return stbi__errpuc("outofmem", "Out of memory");
+   if (info.bpp < 16) {
+      int z=0;
+      if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); }
+      for (i=0; i < psize; ++i) {
+         pal[i][2] = stbi__get8(s);
+         pal[i][1] = stbi__get8(s);
+         pal[i][0] = stbi__get8(s);
+         if (info.hsz != 12) stbi__get8(s);
+         pal[i][3] = 255;
+      }
+      stbi__skip(s, info.offset - 14 - info.hsz - psize * (info.hsz == 12 ? 3 : 4));
+      if (info.bpp == 1) width = (s->img_x + 7) >> 3;
+      else if (info.bpp == 4) width = (s->img_x + 1) >> 1;
+      else if (info.bpp == 8) width = s->img_x;
+      else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); }
+      pad = (-width)&3;
+      if (info.bpp == 1) {
+         for (j=0; j < (int) s->img_y; ++j) {
+            int bit_offset = 7, v = stbi__get8(s);
+            for (i=0; i < (int) s->img_x; ++i) {
+               int color = (v>>bit_offset)&0x1;
+               out[z++] = pal[color][0];
+               out[z++] = pal[color][1];
+               out[z++] = pal[color][2];
+               if (target == 4) out[z++] = 255;
+               if (i+1 == (int) s->img_x) break;
+               if((--bit_offset) < 0) {
+                  bit_offset = 7;
+                  v = stbi__get8(s);
+               }
+            }
+            stbi__skip(s, pad);
+         }
+      } else {
+         for (j=0; j < (int) s->img_y; ++j) {
+            for (i=0; i < (int) s->img_x; i += 2) {
+               int v=stbi__get8(s),v2=0;
+               if (info.bpp == 4) {
+                  v2 = v & 15;
+                  v >>= 4;
+               }
+               out[z++] = pal[v][0];
+               out[z++] = pal[v][1];
+               out[z++] = pal[v][2];
+               if (target == 4) out[z++] = 255;
+               if (i+1 == (int) s->img_x) break;
+               v = (info.bpp == 8) ? stbi__get8(s) : v2;
+               out[z++] = pal[v][0];
+               out[z++] = pal[v][1];
+               out[z++] = pal[v][2];
+               if (target == 4) out[z++] = 255;
+            }
+            stbi__skip(s, pad);
+         }
+      }
+   } else {
+      int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0;
+      int z = 0;
+      int easy=0;
+      stbi__skip(s, info.offset - 14 - info.hsz);
+      if (info.bpp == 24) width = 3 * s->img_x;
+      else if (info.bpp == 16) width = 2*s->img_x;
+      else /* bpp = 32 and pad = 0 */ width=0;
+      pad = (-width) & 3;
+      if (info.bpp == 24) {
+         easy = 1;
+      } else if (info.bpp == 32) {
+         if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000)
+            easy = 2;
+      }
+      if (!easy) {
+         if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); }
+         // right shift amt to put high bit in position #7
+         rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr);
+         gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg);
+         bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb);
+         ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma);
+      }
+      for (j=0; j < (int) s->img_y; ++j) {
+         if (easy) {
+            for (i=0; i < (int) s->img_x; ++i) {
+               unsigned char a;
+               out[z+2] = stbi__get8(s);
+               out[z+1] = stbi__get8(s);
+               out[z+0] = stbi__get8(s);
+               z += 3;
+               a = (easy == 2 ? stbi__get8(s) : 255);
+               all_a |= a;
+               if (target == 4) out[z++] = a;
+            }
+         } else {
+            int bpp = info.bpp;
+            for (i=0; i < (int) s->img_x; ++i) {
+               stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s));
+               unsigned int a;
+               out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount));
+               out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount));
+               out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount));
+               a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255);
+               all_a |= a;
+               if (target == 4) out[z++] = STBI__BYTECAST(a);
+            }
+         }
+         stbi__skip(s, pad);
+      }
+   }
+
+   // if alpha channel is all 0s, replace with all 255s
+   if (target == 4 && all_a == 0)
+      for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4)
+         out[i] = 255;
+
+   if (flip_vertically) {
+      stbi_uc t;
+      for (j=0; j < (int) s->img_y>>1; ++j) {
+         stbi_uc *p1 = out +      j     *s->img_x*target;
+         stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target;
+         for (i=0; i < (int) s->img_x*target; ++i) {
+            t = p1[i]; p1[i] = p2[i]; p2[i] = t;
+         }
+      }
+   }
+
+   if (req_comp && req_comp != target) {
+      out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y);
+      if (out == NULL) return out; // stbi__convert_format frees input on failure
+   }
+
+   *x = s->img_x;
+   *y = s->img_y;
+   if (comp) *comp = s->img_n;
+   return out;
+}
+#endif
+
+// Targa Truevision - TGA
+// by Jonathan Dummer
+#ifndef STBI_NO_TGA
+// returns STBI_rgb or whatever, 0 on error
+static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16)
+{
+   // only RGB or RGBA (incl. 16bit) or grey allowed
+   if (is_rgb16) *is_rgb16 = 0;
+   switch(bits_per_pixel) {
+      case 8:  return STBI_grey;
+      case 16: if(is_grey) return STBI_grey_alpha;
+               // fallthrough
+      case 15: if(is_rgb16) *is_rgb16 = 1;
+               return STBI_rgb;
+      case 24: // fallthrough
+      case 32: return bits_per_pixel/8;
+      default: return 0;
+   }
+}
+
+static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp)
+{
+    int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp;
+    int sz, tga_colormap_type;
+    stbi__get8(s);                   // discard Offset
+    tga_colormap_type = stbi__get8(s); // colormap type
+    if( tga_colormap_type > 1 ) {
+        stbi__rewind(s);
+        return 0;      // only RGB or indexed allowed
+    }
+    tga_image_type = stbi__get8(s); // image type
+    if ( tga_colormap_type == 1 ) { // colormapped (paletted) image
+        if (tga_image_type != 1 && tga_image_type != 9) {
+            stbi__rewind(s);
+            return 0;
+        }
+        stbi__skip(s,4);       // skip index of first colormap entry and number of entries
+        sz = stbi__get8(s);    //   check bits per palette color entry
+        if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) {
+            stbi__rewind(s);
+            return 0;
+        }
+        stbi__skip(s,4);       // skip image x and y origin
+        tga_colormap_bpp = sz;
+    } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE
+        if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) {
+            stbi__rewind(s);
+            return 0; // only RGB or grey allowed, +/- RLE
+        }
+        stbi__skip(s,9); // skip colormap specification and image x/y origin
+        tga_colormap_bpp = 0;
+    }
+    tga_w = stbi__get16le(s);
+    if( tga_w < 1 ) {
+        stbi__rewind(s);
+        return 0;   // test width
+    }
+    tga_h = stbi__get16le(s);
+    if( tga_h < 1 ) {
+        stbi__rewind(s);
+        return 0;   // test height
+    }
+    tga_bits_per_pixel = stbi__get8(s); // bits per pixel
+    stbi__get8(s); // ignore alpha bits
+    if (tga_colormap_bpp != 0) {
+        if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) {
+            // when using a colormap, tga_bits_per_pixel is the size of the indexes
+            // I don't think anything but 8 or 16bit indexes makes sense
+            stbi__rewind(s);
+            return 0;
+        }
+        tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL);
+    } else {
+        tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL);
+    }
+    if(!tga_comp) {
+      stbi__rewind(s);
+      return 0;
+    }
+    if (x) *x = tga_w;
+    if (y) *y = tga_h;
+    if (comp) *comp = tga_comp;
+    return 1;                   // seems to have passed everything
+}
+
+static int stbi__tga_test(stbi__context *s)
+{
+   int res = 0;
+   int sz, tga_color_type;
+   stbi__get8(s);      //   discard Offset
+   tga_color_type = stbi__get8(s);   //   color type
+   if ( tga_color_type > 1 ) goto errorEnd;   //   only RGB or indexed allowed
+   sz = stbi__get8(s);   //   image type
+   if ( tga_color_type == 1 ) { // colormapped (paletted) image
+      if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9
+      stbi__skip(s,4);       // skip index of first colormap entry and number of entries
+      sz = stbi__get8(s);    //   check bits per palette color entry
+      if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd;
+      stbi__skip(s,4);       // skip image x and y origin
+   } else { // "normal" image w/o colormap
+      if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE
+      stbi__skip(s,9); // skip colormap specification and image x/y origin
+   }
+   if ( stbi__get16le(s) < 1 ) goto errorEnd;      //   test width
+   if ( stbi__get16le(s) < 1 ) goto errorEnd;      //   test height
+   sz = stbi__get8(s);   //   bits per pixel
+   if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index
+   if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd;
+
+   res = 1; // if we got this far, everything's good and we can return 1 instead of 0
+
+errorEnd:
+   stbi__rewind(s);
+   return res;
+}
+
+// read 16bit value and convert to 24bit RGB
+static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out)
+{
+   stbi__uint16 px = (stbi__uint16)stbi__get16le(s);
+   stbi__uint16 fiveBitMask = 31;
+   // we have 3 channels with 5bits each
+   int r = (px >> 10) & fiveBitMask;
+   int g = (px >> 5) & fiveBitMask;
+   int b = px & fiveBitMask;
+   // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later
+   out[0] = (stbi_uc)((r * 255)/31);
+   out[1] = (stbi_uc)((g * 255)/31);
+   out[2] = (stbi_uc)((b * 255)/31);
+
+   // some people claim that the most significant bit might be used for alpha
+   // (possibly if an alpha-bit is set in the "image descriptor byte")
+   // but that only made 16bit test images completely translucent..
+   // so let's treat all 15 and 16bit TGAs as RGB with no alpha.
+}
+
+static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   //   read in the TGA header stuff
+   int tga_offset = stbi__get8(s);
+   int tga_indexed = stbi__get8(s);
+   int tga_image_type = stbi__get8(s);
+   int tga_is_RLE = 0;
+   int tga_palette_start = stbi__get16le(s);
+   int tga_palette_len = stbi__get16le(s);
+   int tga_palette_bits = stbi__get8(s);
+   int tga_x_origin = stbi__get16le(s);
+   int tga_y_origin = stbi__get16le(s);
+   int tga_width = stbi__get16le(s);
+   int tga_height = stbi__get16le(s);
+   int tga_bits_per_pixel = stbi__get8(s);
+   int tga_comp, tga_rgb16=0;
+   int tga_inverted = stbi__get8(s);
+   // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?)
+   //   image data
+   unsigned char *tga_data;
+   unsigned char *tga_palette = NULL;
+   int i, j;
+   unsigned char raw_data[4] = {0};
+   int RLE_count = 0;
+   int RLE_repeating = 0;
+   int read_next_pixel = 1;
+   STBI_NOTUSED(ri);
+
+   //   do a tiny bit of precessing
+   if ( tga_image_type >= 8 )
+   {
+      tga_image_type -= 8;
+      tga_is_RLE = 1;
+   }
+   tga_inverted = 1 - ((tga_inverted >> 5) & 1);
+
+   //   If I'm paletted, then I'll use the number of bits from the palette
+   if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16);
+   else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16);
+
+   if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency
+      return stbi__errpuc("bad format", "Can't find out TGA pixelformat");
+
+   //   tga info
+   *x = tga_width;
+   *y = tga_height;
+   if (comp) *comp = tga_comp;
+
+   if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0))
+      return stbi__errpuc("too large", "Corrupt TGA");
+
+   tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0);
+   if (!tga_data) return stbi__errpuc("outofmem", "Out of memory");
+
+   // skip to the data's starting position (offset usually = 0)
+   stbi__skip(s, tga_offset );
+
+   if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) {
+      for (i=0; i < tga_height; ++i) {
+         int row = tga_inverted ? tga_height -i - 1 : i;
+         stbi_uc *tga_row = tga_data + row*tga_width*tga_comp;
+         stbi__getn(s, tga_row, tga_width * tga_comp);
+      }
+   } else  {
+      //   do I need to load a palette?
+      if ( tga_indexed)
+      {
+         //   any data to skip? (offset usually = 0)
+         stbi__skip(s, tga_palette_start );
+         //   load the palette
+         tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0);
+         if (!tga_palette) {
+            STBI_FREE(tga_data);
+            return stbi__errpuc("outofmem", "Out of memory");
+         }
+         if (tga_rgb16) {
+            stbi_uc *pal_entry = tga_palette;
+            STBI_ASSERT(tga_comp == STBI_rgb);
+            for (i=0; i < tga_palette_len; ++i) {
+               stbi__tga_read_rgb16(s, pal_entry);
+               pal_entry += tga_comp;
+            }
+         } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) {
+               STBI_FREE(tga_data);
+               STBI_FREE(tga_palette);
+               return stbi__errpuc("bad palette", "Corrupt TGA");
+         }
+      }
+      //   load the data
+      for (i=0; i < tga_width * tga_height; ++i)
+      {
+         //   if I'm in RLE mode, do I need to get a RLE stbi__pngchunk?
+         if ( tga_is_RLE )
+         {
+            if ( RLE_count == 0 )
+            {
+               //   yep, get the next byte as a RLE command
+               int RLE_cmd = stbi__get8(s);
+               RLE_count = 1 + (RLE_cmd & 127);
+               RLE_repeating = RLE_cmd >> 7;
+               read_next_pixel = 1;
+            } else if ( !RLE_repeating )
+            {
+               read_next_pixel = 1;
+            }
+         } else
+         {
+            read_next_pixel = 1;
+         }
+         //   OK, if I need to read a pixel, do it now
+         if ( read_next_pixel )
+         {
+            //   load however much data we did have
+            if ( tga_indexed )
+            {
+               // read in index, then perform the lookup
+               int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s);
+               if ( pal_idx >= tga_palette_len ) {
+                  // invalid index
+                  pal_idx = 0;
+               }
+               pal_idx *= tga_comp;
+               for (j = 0; j < tga_comp; ++j) {
+                  raw_data[j] = tga_palette[pal_idx+j];
+               }
+            } else if(tga_rgb16) {
+               STBI_ASSERT(tga_comp == STBI_rgb);
+               stbi__tga_read_rgb16(s, raw_data);
+            } else {
+               //   read in the data raw
+               for (j = 0; j < tga_comp; ++j) {
+                  raw_data[j] = stbi__get8(s);
+               }
+            }
+            //   clear the reading flag for the next pixel
+            read_next_pixel = 0;
+         } // end of reading a pixel
+
+         // copy data
+         for (j = 0; j < tga_comp; ++j)
+           tga_data[i*tga_comp+j] = raw_data[j];
+
+         //   in case we're in RLE mode, keep counting down
+         --RLE_count;
+      }
+      //   do I need to invert the image?
+      if ( tga_inverted )
+      {
+         for (j = 0; j*2 < tga_height; ++j)
+         {
+            int index1 = j * tga_width * tga_comp;
+            int index2 = (tga_height - 1 - j) * tga_width * tga_comp;
+            for (i = tga_width * tga_comp; i > 0; --i)
+            {
+               unsigned char temp = tga_data[index1];
+               tga_data[index1] = tga_data[index2];
+               tga_data[index2] = temp;
+               ++index1;
+               ++index2;
+            }
+         }
+      }
+      //   clear my palette, if I had one
+      if ( tga_palette != NULL )
+      {
+         STBI_FREE( tga_palette );
+      }
+   }
+
+   // swap RGB - if the source data was RGB16, it already is in the right order
+   if (tga_comp >= 3 && !tga_rgb16)
+   {
+      unsigned char* tga_pixel = tga_data;
+      for (i=0; i < tga_width * tga_height; ++i)
+      {
+         unsigned char temp = tga_pixel[0];
+         tga_pixel[0] = tga_pixel[2];
+         tga_pixel[2] = temp;
+         tga_pixel += tga_comp;
+      }
+   }
+
+   // convert to target component count
+   if (req_comp && req_comp != tga_comp)
+      tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height);
+
+   //   the things I do to get rid of an error message, and yet keep
+   //   Microsoft's C compilers happy... [8^(
+   tga_palette_start = tga_palette_len = tga_palette_bits =
+         tga_x_origin = tga_y_origin = 0;
+   //   OK, done
+   return tga_data;
+}
+#endif
+
+// *************************************************************************************************
+// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB
+
+#ifndef STBI_NO_PSD
+static int stbi__psd_test(stbi__context *s)
+{
+   int r = (stbi__get32be(s) == 0x38425053);
+   stbi__rewind(s);
+   return r;
+}
+
+static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount)
+{
+   int count, nleft, len;
+
+   count = 0;
+   while ((nleft = pixelCount - count) > 0) {
+      len = stbi__get8(s);
+      if (len == 128) {
+         // No-op.
+      } else if (len < 128) {
+         // Copy next len+1 bytes literally.
+         len++;
+         if (len > nleft) return 0; // corrupt data
+         count += len;
+         while (len) {
+            *p = stbi__get8(s);
+            p += 4;
+            len--;
+         }
+      } else if (len > 128) {
+         stbi_uc   val;
+         // Next -len+1 bytes in the dest are replicated from next source byte.
+         // (Interpret len as a negative 8-bit int.)
+         len = 257 - len;
+         if (len > nleft) return 0; // corrupt data
+         val = stbi__get8(s);
+         count += len;
+         while (len) {
+            *p = val;
+            p += 4;
+            len--;
+         }
+      }
+   }
+
+   return 1;
+}
+
+static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)
+{
+   int pixelCount;
+   int channelCount, compression;
+   int channel, i;
+   int bitdepth;
+   int w,h;
+   stbi_uc *out;
+   STBI_NOTUSED(ri);
+
+   // Check identifier
+   if (stbi__get32be(s) != 0x38425053)   // "8BPS"
+      return stbi__errpuc("not PSD", "Corrupt PSD image");
+
+   // Check file type version.
+   if (stbi__get16be(s) != 1)
+      return stbi__errpuc("wrong version", "Unsupported version of PSD image");
+
+   // Skip 6 reserved bytes.
+   stbi__skip(s, 6 );
+
+   // Read the number of channels (R, G, B, A, etc).
+   channelCount = stbi__get16be(s);
+   if (channelCount < 0 || channelCount > 16)
+      return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image");
+
+   // Read the rows and columns of the image.
+   h = stbi__get32be(s);
+   w = stbi__get32be(s);
+
+   // Make sure the depth is 8 bits.
+   bitdepth = stbi__get16be(s);
+   if (bitdepth != 8 && bitdepth != 16)
+      return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit");
+
+   // Make sure the color mode is RGB.
+   // Valid options are:
+   //   0: Bitmap
+   //   1: Grayscale
+   //   2: Indexed color
+   //   3: RGB color
+   //   4: CMYK color
+   //   7: Multichannel
+   //   8: Duotone
+   //   9: Lab color
+   if (stbi__get16be(s) != 3)
+      return stbi__errpuc("wrong color format", "PSD is not in RGB color format");
+
+   // Skip the Mode Data.  (It's the palette for indexed color; other info for other modes.)
+   stbi__skip(s,stbi__get32be(s) );
+
+   // Skip the image resources.  (resolution, pen tool paths, etc)
+   stbi__skip(s, stbi__get32be(s) );
+
+   // Skip the reserved data.
+   stbi__skip(s, stbi__get32be(s) );
+
+   // Find out if the data is compressed.
+   // Known values:
+   //   0: no compression
+   //   1: RLE compressed
+   compression = stbi__get16be(s);
+   if (compression > 1)
+      return stbi__errpuc("bad compression", "PSD has an unknown compression format");
+
+   // Check size
+   if (!stbi__mad3sizes_valid(4, w, h, 0))
+      return stbi__errpuc("too large", "Corrupt PSD");
+
+   // Create the destination image.
+
+   if (!compression && bitdepth == 16 && bpc == 16) {
+      out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0);
+      ri->bits_per_channel = 16;
+   } else
+      out = (stbi_uc *) stbi__malloc(4 * w*h);
+
+   if (!out) return stbi__errpuc("outofmem", "Out of memory");
+   pixelCount = w*h;
+
+   // Initialize the data to zero.
+   //memset( out, 0, pixelCount * 4 );
+
+   // Finally, the image data.
+   if (compression) {
+      // RLE as used by .PSD and .TIFF
+      // Loop until you get the number of unpacked bytes you are expecting:
+      //     Read the next source byte into n.
+      //     If n is between 0 and 127 inclusive, copy the next n+1 bytes literally.
+      //     Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times.
+      //     Else if n is 128, noop.
+      // Endloop
+
+      // The RLE-compressed data is preceded by a 2-byte data count for each row in the data,
+      // which we're going to just skip.
+      stbi__skip(s, h * channelCount * 2 );
+
+      // Read the RLE data by channel.
+      for (channel = 0; channel < 4; channel++) {
+         stbi_uc *p;
+
+         p = out+channel;
+         if (channel >= channelCount) {
+            // Fill this channel with default data.
+            for (i = 0; i < pixelCount; i++, p += 4)
+               *p = (channel == 3 ? 255 : 0);
+         } else {
+            // Read the RLE data.
+            if (!stbi__psd_decode_rle(s, p, pixelCount)) {
+               STBI_FREE(out);
+               return stbi__errpuc("corrupt", "bad RLE data");
+            }
+         }
+      }
+
+   } else {
+      // We're at the raw image data.  It's each channel in order (Red, Green, Blue, Alpha, ...)
+      // where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image.
+
+      // Read the data by channel.
+      for (channel = 0; channel < 4; channel++) {
+         if (channel >= channelCount) {
+            // Fill this channel with default data.
+            if (bitdepth == 16 && bpc == 16) {
+               stbi__uint16 *q = ((stbi__uint16 *) out) + channel;
+               stbi__uint16 val = channel == 3 ? 65535 : 0;
+               for (i = 0; i < pixelCount; i++, q += 4)
+                  *q = val;
+            } else {
+               stbi_uc *p = out+channel;
+               stbi_uc val = channel == 3 ? 255 : 0;
+               for (i = 0; i < pixelCount; i++, p += 4)
+                  *p = val;
+            }
+         } else {
+            if (ri->bits_per_channel == 16) {    // output bpc
+               stbi__uint16 *q = ((stbi__uint16 *) out) + channel;
+               for (i = 0; i < pixelCount; i++, q += 4)
+                  *q = (stbi__uint16) stbi__get16be(s);
+            } else {
+               stbi_uc *p = out+channel;
+               if (bitdepth == 16) {  // input bpc
+                  for (i = 0; i < pixelCount; i++, p += 4)
+                     *p = (stbi_uc) (stbi__get16be(s) >> 8);
+               } else {
+                  for (i = 0; i < pixelCount; i++, p += 4)
+                     *p = stbi__get8(s);
+               }
+            }
+         }
+      }
+   }
+
+   // remove weird white matte from PSD
+   if (channelCount >= 4) {
+      if (ri->bits_per_channel == 16) {
+         for (i=0; i < w*h; ++i) {
+            stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i;
+            if (pixel[3] != 0 && pixel[3] != 65535) {
+               float a = pixel[3] / 65535.0f;
+               float ra = 1.0f / a;
+               float inv_a = 65535.0f * (1 - ra);
+               pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a);
+               pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a);
+               pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a);
+            }
+         }
+      } else {
+         for (i=0; i < w*h; ++i) {
+            unsigned char *pixel = out + 4*i;
+            if (pixel[3] != 0 && pixel[3] != 255) {
+               float a = pixel[3] / 255.0f;
+               float ra = 1.0f / a;
+               float inv_a = 255.0f * (1 - ra);
+               pixel[0] = (unsigned char) (pixel[0]*ra + inv_a);
+               pixel[1] = (unsigned char) (pixel[1]*ra + inv_a);
+               pixel[2] = (unsigned char) (pixel[2]*ra + inv_a);
+            }
+         }
+      }
+   }
+
+   // convert to desired output format
+   if (req_comp && req_comp != 4) {
+      if (ri->bits_per_channel == 16)
+         out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h);
+      else
+         out = stbi__convert_format(out, 4, req_comp, w, h);
+      if (out == NULL) return out; // stbi__convert_format frees input on failure
+   }
+
+   if (comp) *comp = 4;
+   *y = h;
+   *x = w;
+
+   return out;
+}
+#endif
+
+// *************************************************************************************************
+// Softimage PIC loader
+// by Tom Seddon
+//
+// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format
+// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/
+
+#ifndef STBI_NO_PIC
+static int stbi__pic_is4(stbi__context *s,const char *str)
+{
+   int i;
+   for (i=0; i<4; ++i)
+      if (stbi__get8(s) != (stbi_uc)str[i])
+         return 0;
+
+   return 1;
+}
+
+static int stbi__pic_test_core(stbi__context *s)
+{
+   int i;
+
+   if (!stbi__pic_is4(s,"\x53\x80\xF6\x34"))
+      return 0;
+
+   for(i=0;i<84;++i)
+      stbi__get8(s);
+
+   if (!stbi__pic_is4(s,"PICT"))
+      return 0;
+
+   return 1;
+}
+
+typedef struct
+{
+   stbi_uc size,type,channel;
+} stbi__pic_packet;
+
+static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest)
+{
+   int mask=0x80, i;
+
+   for (i=0; i<4; ++i, mask>>=1) {
+      if (channel & mask) {
+         if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short");
+         dest[i]=stbi__get8(s);
+      }
+   }
+
+   return dest;
+}
+
+static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src)
+{
+   int mask=0x80,i;
+
+   for (i=0;i<4; ++i, mask>>=1)
+      if (channel&mask)
+         dest[i]=src[i];
+}
+
+static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result)
+{
+   int act_comp=0,num_packets=0,y,chained;
+   stbi__pic_packet packets[10];
+
+   // this will (should...) cater for even some bizarre stuff like having data
+    // for the same channel in multiple packets.
+   do {
+      stbi__pic_packet *packet;
+
+      if (num_packets==sizeof(packets)/sizeof(packets[0]))
+         return stbi__errpuc("bad format","too many packets");
+
+      packet = &packets[num_packets++];
+
+      chained = stbi__get8(s);
+      packet->size    = stbi__get8(s);
+      packet->type    = stbi__get8(s);
+      packet->channel = stbi__get8(s);
+
+      act_comp |= packet->channel;
+
+      if (stbi__at_eof(s))          return stbi__errpuc("bad file","file too short (reading packets)");
+      if (packet->size != 8)  return stbi__errpuc("bad format","packet isn't 8bpp");
+   } while (chained);
+
+   *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel?
+
+   for(y=0; y<height; ++y) {
+      int packet_idx;
+
+      for(packet_idx=0; packet_idx < num_packets; ++packet_idx) {
+         stbi__pic_packet *packet = &packets[packet_idx];
+         stbi_uc *dest = result+y*width*4;
+
+         switch (packet->type) {
+            default:
+               return stbi__errpuc("bad format","packet has bad compression type");
+
+            case 0: {//uncompressed
+               int x;
+
+               for(x=0;x<width;++x, dest+=4)
+                  if (!stbi__readval(s,packet->channel,dest))
+                     return 0;
+               break;
+            }
+
+            case 1://Pure RLE
+               {
+                  int left=width, i;
+
+                  while (left>0) {
+                     stbi_uc count,value[4];
+
+                     count=stbi__get8(s);
+                     if (stbi__at_eof(s))   return stbi__errpuc("bad file","file too short (pure read count)");
+
+                     if (count > left)
+                        count = (stbi_uc) left;
+
+                     if (!stbi__readval(s,packet->channel,value))  return 0;
+
+                     for(i=0; i<count; ++i,dest+=4)
+                        stbi__copyval(packet->channel,dest,value);
+                     left -= count;
+                  }
+               }
+               break;
+
+            case 2: {//Mixed RLE
+               int left=width;
+               while (left>0) {
+                  int count = stbi__get8(s), i;
+                  if (stbi__at_eof(s))  return stbi__errpuc("bad file","file too short (mixed read count)");
+
+                  if (count >= 128) { // Repeated
+                     stbi_uc value[4];
+
+                     if (count==128)
+                        count = stbi__get16be(s);
+                     else
+                        count -= 127;
+                     if (count > left)
+                        return stbi__errpuc("bad file","scanline overrun");
+
+                     if (!stbi__readval(s,packet->channel,value))
+                        return 0;
+
+                     for(i=0;i<count;++i, dest += 4)
+                        stbi__copyval(packet->channel,dest,value);
+                  } else { // Raw
+                     ++count;
+                     if (count>left) return stbi__errpuc("bad file","scanline overrun");
+
+                     for(i=0;i<count;++i, dest+=4)
+                        if (!stbi__readval(s,packet->channel,dest))
+                           return 0;
+                  }
+                  left-=count;
+               }
+               break;
+            }
+         }
+      }
+   }
+
+   return result;
+}
+
+static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri)
+{
+   stbi_uc *result;
+   int i, x,y, internal_comp;
+   STBI_NOTUSED(ri);
+
+   if (!comp) comp = &internal_comp;
+
+   for (i=0; i<92; ++i)
+      stbi__get8(s);
+
+   x = stbi__get16be(s);
+   y = stbi__get16be(s);
+   if (stbi__at_eof(s))  return stbi__errpuc("bad file","file too short (pic header)");
+   if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode");
+
+   stbi__get32be(s); //skip `ratio'
+   stbi__get16be(s); //skip `fields'
+   stbi__get16be(s); //skip `pad'
+
+   // intermediate buffer is RGBA
+   result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0);
+   memset(result, 0xff, x*y*4);
+
+   if (!stbi__pic_load_core(s,x,y,comp, result)) {
+      STBI_FREE(result);
+      result=0;
+   }
+   *px = x;
+   *py = y;
+   if (req_comp == 0) req_comp = *comp;
+   result=stbi__convert_format(result,4,req_comp,x,y);
+
+   return result;
+}
+
+static int stbi__pic_test(stbi__context *s)
+{
+   int r = stbi__pic_test_core(s);
+   stbi__rewind(s);
+   return r;
+}
+#endif
+
+// *************************************************************************************************
+// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb
+
+#ifndef STBI_NO_GIF
+typedef struct
+{
+   stbi__int16 prefix;
+   stbi_uc first;
+   stbi_uc suffix;
+} stbi__gif_lzw;
+
+typedef struct
+{
+   int w,h;
+   stbi_uc *out;                 // output buffer (always 4 components)
+   stbi_uc *background;          // The current "background" as far as a gif is concerned
+   stbi_uc *history; 
+   int flags, bgindex, ratio, transparent, eflags;
+   stbi_uc  pal[256][4];
+   stbi_uc lpal[256][4];
+   stbi__gif_lzw codes[8192];
+   stbi_uc *color_table;
+   int parse, step;
+   int lflags;
+   int start_x, start_y;
+   int max_x, max_y;
+   int cur_x, cur_y;
+   int line_size;
+   int delay;
+} stbi__gif;
+
+static int stbi__gif_test_raw(stbi__context *s)
+{
+   int sz;
+   if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0;
+   sz = stbi__get8(s);
+   if (sz != '9' && sz != '7') return 0;
+   if (stbi__get8(s) != 'a') return 0;
+   return 1;
+}
+
+static int stbi__gif_test(stbi__context *s)
+{
+   int r = stbi__gif_test_raw(s);
+   stbi__rewind(s);
+   return r;
+}
+
+static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp)
+{
+   int i;
+   for (i=0; i < num_entries; ++i) {
+      pal[i][2] = stbi__get8(s);
+      pal[i][1] = stbi__get8(s);
+      pal[i][0] = stbi__get8(s);
+      pal[i][3] = transp == i ? 0 : 255;
+   }
+}
+
+static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info)
+{
+   stbi_uc version;
+   if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8')
+      return stbi__err("not GIF", "Corrupt GIF");
+
+   version = stbi__get8(s);
+   if (version != '7' && version != '9')    return stbi__err("not GIF", "Corrupt GIF");
+   if (stbi__get8(s) != 'a')                return stbi__err("not GIF", "Corrupt GIF");
+
+   stbi__g_failure_reason = "";
+   g->w = stbi__get16le(s);
+   g->h = stbi__get16le(s);
+   g->flags = stbi__get8(s);
+   g->bgindex = stbi__get8(s);
+   g->ratio = stbi__get8(s);
+   g->transparent = -1;
+
+   if (comp != 0) *comp = 4;  // can't actually tell whether it's 3 or 4 until we parse the comments
+
+   if (is_info) return 1;
+
+   if (g->flags & 0x80)
+      stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1);
+
+   return 1;
+}
+
+static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp)
+{
+   stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif));
+   if (!stbi__gif_header(s, g, comp, 1)) {
+      STBI_FREE(g);
+      stbi__rewind( s );
+      return 0;
+   }
+   if (x) *x = g->w;
+   if (y) *y = g->h;
+   STBI_FREE(g);
+   return 1;
+}
+
+static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)
+{
+   stbi_uc *p, *c;
+   int idx; 
+
+   // recurse to decode the prefixes, since the linked-list is backwards,
+   // and working backwards through an interleaved image would be nasty
+   if (g->codes[code].prefix >= 0)
+      stbi__out_gif_code(g, g->codes[code].prefix);
+
+   if (g->cur_y >= g->max_y) return;
+
+   idx = g->cur_x + g->cur_y; 
+   p = &g->out[idx];
+   g->history[idx / 4] = 1;  
+
+   c = &g->color_table[g->codes[code].suffix * 4];
+   if (c[3] > 128) { // don't render transparent pixels; 
+      p[0] = c[2];
+      p[1] = c[1];
+      p[2] = c[0];
+      p[3] = c[3];
+   }
+   g->cur_x += 4;
+
+   if (g->cur_x >= g->max_x) {
+      g->cur_x = g->start_x;
+      g->cur_y += g->step;
+
+      while (g->cur_y >= g->max_y && g->parse > 0) {
+         g->step = (1 << g->parse) * g->line_size;
+         g->cur_y = g->start_y + (g->step >> 1);
+         --g->parse;
+      }
+   }
+}
+
+static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g)
+{
+   stbi_uc lzw_cs;
+   stbi__int32 len, init_code;
+   stbi__uint32 first;
+   stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear;
+   stbi__gif_lzw *p;
+
+   lzw_cs = stbi__get8(s);
+   if (lzw_cs > 12) return NULL;
+   clear = 1 << lzw_cs;
+   first = 1;
+   codesize = lzw_cs + 1;
+   codemask = (1 << codesize) - 1;
+   bits = 0;
+   valid_bits = 0;
+   for (init_code = 0; init_code < clear; init_code++) {
+      g->codes[init_code].prefix = -1;
+      g->codes[init_code].first = (stbi_uc) init_code;
+      g->codes[init_code].suffix = (stbi_uc) init_code;
+   }
+
+   // support no starting clear code
+   avail = clear+2;
+   oldcode = -1;
+
+   len = 0;
+   for(;;) {
+      if (valid_bits < codesize) {
+         if (len == 0) {
+            len = stbi__get8(s); // start new block
+            if (len == 0)
+               return g->out;
+         }
+         --len;
+         bits |= (stbi__int32) stbi__get8(s) << valid_bits;
+         valid_bits += 8;
+      } else {
+         stbi__int32 code = bits & codemask;
+         bits >>= codesize;
+         valid_bits -= codesize;
+         // @OPTIMIZE: is there some way we can accelerate the non-clear path?
+         if (code == clear) {  // clear code
+            codesize = lzw_cs + 1;
+            codemask = (1 << codesize) - 1;
+            avail = clear + 2;
+            oldcode = -1;
+            first = 0;
+         } else if (code == clear + 1) { // end of stream code
+            stbi__skip(s, len);
+            while ((len = stbi__get8(s)) > 0)
+               stbi__skip(s,len);
+            return g->out;
+         } else if (code <= avail) {
+            if (first) {
+               return stbi__errpuc("no clear code", "Corrupt GIF");
+            }
+
+            if (oldcode >= 0) {
+               p = &g->codes[avail++];
+               if (avail > 8192) {
+                  return stbi__errpuc("too many codes", "Corrupt GIF");
+               }
+
+               p->prefix = (stbi__int16) oldcode;
+               p->first = g->codes[oldcode].first;
+               p->suffix = (code == avail) ? p->first : g->codes[code].first;
+            } else if (code == avail)
+               return stbi__errpuc("illegal code in raster", "Corrupt GIF");
+
+            stbi__out_gif_code(g, (stbi__uint16) code);
+
+            if ((avail & codemask) == 0 && avail <= 0x0FFF) {
+               codesize++;
+               codemask = (1 << codesize) - 1;
+            }
+
+            oldcode = code;
+         } else {
+            return stbi__errpuc("illegal code in raster", "Corrupt GIF");
+         }
+      }
+   }
+}
+
+// this function is designed to support animated gifs, although stb_image doesn't support it
+// two back is the image from two frames ago, used for a very specific disposal format
+static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back)
+{
+   int dispose; 
+   int first_frame; 
+   int pi; 
+   int pcount; 
+   STBI_NOTUSED(req_comp);
+
+   // on first frame, any non-written pixels get the background colour (non-transparent)
+   first_frame = 0; 
+   if (g->out == 0) {
+      if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header
+      if (!stbi__mad3sizes_valid(4, g->w, g->h, 0))
+         return stbi__errpuc("too large", "GIF image is too large");
+      pcount = g->w * g->h;
+      g->out = (stbi_uc *) stbi__malloc(4 * pcount);
+      g->background = (stbi_uc *) stbi__malloc(4 * pcount);
+      g->history = (stbi_uc *) stbi__malloc(pcount);
+      if (!g->out || !g->background || !g->history)
+         return stbi__errpuc("outofmem", "Out of memory");
+
+      // image is treated as "transparent" at the start - ie, nothing overwrites the current background; 
+      // background colour is only used for pixels that are not rendered first frame, after that "background"
+      // color refers to the color that was there the previous frame. 
+      memset(g->out, 0x00, 4 * pcount);
+      memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent)
+      memset(g->history, 0x00, pcount);        // pixels that were affected previous frame
+      first_frame = 1; 
+   } else {
+      // second frame - how do we dispoase of the previous one?
+      dispose = (g->eflags & 0x1C) >> 2; 
+      pcount = g->w * g->h; 
+
+      if ((dispose == 3) && (two_back == 0)) {
+         dispose = 2; // if I don't have an image to revert back to, default to the old background
+      }
+
+      if (dispose == 3) { // use previous graphic
+         for (pi = 0; pi < pcount; ++pi) {
+            if (g->history[pi]) {
+               memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 ); 
+            }
+         }
+      } else if (dispose == 2) { 
+         // restore what was changed last frame to background before that frame; 
+         for (pi = 0; pi < pcount; ++pi) {
+            if (g->history[pi]) {
+               memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 ); 
+            }
+         }
+      } else {
+         // This is a non-disposal case eithe way, so just 
+         // leave the pixels as is, and they will become the new background
+         // 1: do not dispose
+         // 0:  not specified.
+      }
+
+      // background is what out is after the undoing of the previou frame; 
+      memcpy( g->background, g->out, 4 * g->w * g->h ); 
+   }
+
+   // clear my history; 
+   memset( g->history, 0x00, g->w * g->h );        // pixels that were affected previous frame
+
+   for (;;) {
+      int tag = stbi__get8(s); 
+      switch (tag) {
+         case 0x2C: /* Image Descriptor */
+         {
+            stbi__int32 x, y, w, h;
+            stbi_uc *o;
+
+            x = stbi__get16le(s);
+            y = stbi__get16le(s);
+            w = stbi__get16le(s);
+            h = stbi__get16le(s);
+            if (((x + w) > (g->w)) || ((y + h) > (g->h)))
+               return stbi__errpuc("bad Image Descriptor", "Corrupt GIF");
+
+            g->line_size = g->w * 4;
+            g->start_x = x * 4;
+            g->start_y = y * g->line_size;
+            g->max_x   = g->start_x + w * 4;
+            g->max_y   = g->start_y + h * g->line_size;
+            g->cur_x   = g->start_x;
+            g->cur_y   = g->start_y;
+
+            // if the width of the specified rectangle is 0, that means
+            // we may not see *any* pixels or the image is malformed;
+            // to make sure this is caught, move the current y down to
+            // max_y (which is what out_gif_code checks).
+            if (w == 0)
+               g->cur_y = g->max_y;
+
+            g->lflags = stbi__get8(s);
+
+            if (g->lflags & 0x40) {
+               g->step = 8 * g->line_size; // first interlaced spacing
+               g->parse = 3;
+            } else {
+               g->step = g->line_size;
+               g->parse = 0;
+            }
+
+            if (g->lflags & 0x80) {
+               stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1);
+               g->color_table = (stbi_uc *) g->lpal;
+            } else if (g->flags & 0x80) {
+               g->color_table = (stbi_uc *) g->pal;
+            } else
+               return stbi__errpuc("missing color table", "Corrupt GIF");            
+            
+            o = stbi__process_gif_raster(s, g);
+            if (!o) return NULL;
+
+            // if this was the first frame, 
+            pcount = g->w * g->h; 
+            if (first_frame && (g->bgindex > 0)) {
+               // if first frame, any pixel not drawn to gets the background color
+               for (pi = 0; pi < pcount; ++pi) {
+                  if (g->history[pi] == 0) {
+                     g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be; 
+                     memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 ); 
+                  }
+               }
+            }
+
+            return o;
+         }
+
+         case 0x21: // Comment Extension.
+         {
+            int len;
+            int ext = stbi__get8(s); 
+            if (ext == 0xF9) { // Graphic Control Extension.
+               len = stbi__get8(s);
+               if (len == 4) {
+                  g->eflags = stbi__get8(s);
+                  g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths.
+
+                  // unset old transparent
+                  if (g->transparent >= 0) {
+                     g->pal[g->transparent][3] = 255; 
+                  } 
+                  if (g->eflags & 0x01) {
+                     g->transparent = stbi__get8(s);
+                     if (g->transparent >= 0) {
+                        g->pal[g->transparent][3] = 0; 
+                     }
+                  } else {
+                     // don't need transparent
+                     stbi__skip(s, 1); 
+                     g->transparent = -1; 
+                  }
+               } else {
+                  stbi__skip(s, len);
+                  break;
+               }
+            } 
+            while ((len = stbi__get8(s)) != 0) {
+               stbi__skip(s, len);
+            }
+            break;
+         }
+
+         case 0x3B: // gif stream termination code
+            return (stbi_uc *) s; // using '1' causes warning on some compilers
+
+         default:
+            return stbi__errpuc("unknown code", "Corrupt GIF");
+      }
+   }
+}
+
+static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp)
+{
+   if (stbi__gif_test(s)) {
+      int layers = 0; 
+      stbi_uc *u = 0;
+      stbi_uc *out = 0;
+      stbi_uc *two_back = 0; 
+      stbi__gif g;
+      int stride; 
+      memset(&g, 0, sizeof(g));
+      if (delays) {
+         *delays = 0; 
+      }
+
+      do {
+         u = stbi__gif_load_next(s, &g, comp, req_comp, two_back);
+         if (u == (stbi_uc *) s) u = 0;  // end of animated gif marker
+
+         if (u) {
+            *x = g.w;
+            *y = g.h;
+            ++layers; 
+            stride = g.w * g.h * 4; 
+         
+            if (out) {
+               out = (stbi_uc*) STBI_REALLOC( out, layers * stride ); 
+               if (delays) {
+                  *delays = (int*) STBI_REALLOC( *delays, sizeof(int) * layers ); 
+               }
+            } else {
+               out = (stbi_uc*)stbi__malloc( layers * stride ); 
+               if (delays) {
+                  *delays = (int*) stbi__malloc( layers * sizeof(int) ); 
+               }
+            }
+            memcpy( out + ((layers - 1) * stride), u, stride ); 
+            if (layers >= 2) {
+               two_back = out - 2 * stride; 
+            }
+
+            if (delays) {
+               (*delays)[layers - 1U] = g.delay; 
+            }
+         }
+      } while (u != 0); 
+
+      // free temp buffer; 
+      STBI_FREE(g.out); 
+      STBI_FREE(g.history); 
+      STBI_FREE(g.background); 
+
+      // do the final conversion after loading everything; 
+      if (req_comp && req_comp != 4)
+         out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h);
+
+      *z = layers; 
+      return out;
+   } else {
+      return stbi__errpuc("not GIF", "Image was not as a gif type."); 
+   }
+}
+
+static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   stbi_uc *u = 0;
+   stbi__gif g;
+   memset(&g, 0, sizeof(g));
+   STBI_NOTUSED(ri);
+
+   u = stbi__gif_load_next(s, &g, comp, req_comp, 0);
+   if (u == (stbi_uc *) s) u = 0;  // end of animated gif marker
+   if (u) {
+      *x = g.w;
+      *y = g.h;
+
+      // moved conversion to after successful load so that the same
+      // can be done for multiple frames. 
+      if (req_comp && req_comp != 4)
+         u = stbi__convert_format(u, 4, req_comp, g.w, g.h);
+   } else if (g.out) {
+      // if there was an error and we allocated an image buffer, free it!
+      STBI_FREE(g.out);
+   }
+
+   // free buffers needed for multiple frame loading; 
+   STBI_FREE(g.history);
+   STBI_FREE(g.background); 
+
+   return u;
+}
+
+static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   return stbi__gif_info_raw(s,x,y,comp);
+}
+#endif
+
+// *************************************************************************************************
+// Radiance RGBE HDR loader
+// originally by Nicolas Schulz
+#ifndef STBI_NO_HDR
+static int stbi__hdr_test_core(stbi__context *s, const char *signature)
+{
+   int i;
+   for (i=0; signature[i]; ++i)
+      if (stbi__get8(s) != signature[i])
+          return 0;
+   stbi__rewind(s);
+   return 1;
+}
+
+static int stbi__hdr_test(stbi__context* s)
+{
+   int r = stbi__hdr_test_core(s, "#?RADIANCE\n");
+   stbi__rewind(s);
+   if(!r) {
+       r = stbi__hdr_test_core(s, "#?RGBE\n");
+       stbi__rewind(s);
+   }
+   return r;
+}
+
+#define STBI__HDR_BUFLEN  1024
+static char *stbi__hdr_gettoken(stbi__context *z, char *buffer)
+{
+   int len=0;
+   char c = '\0';
+
+   c = (char) stbi__get8(z);
+
+   while (!stbi__at_eof(z) && c != '\n') {
+      buffer[len++] = c;
+      if (len == STBI__HDR_BUFLEN-1) {
+         // flush to end of line
+         while (!stbi__at_eof(z) && stbi__get8(z) != '\n')
+            ;
+         break;
+      }
+      c = (char) stbi__get8(z);
+   }
+
+   buffer[len] = 0;
+   return buffer;
+}
+
+static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp)
+{
+   if ( input[3] != 0 ) {
+      float f1;
+      // Exponent
+      f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8));
+      if (req_comp <= 2)
+         output[0] = (input[0] + input[1] + input[2]) * f1 / 3;
+      else {
+         output[0] = input[0] * f1;
+         output[1] = input[1] * f1;
+         output[2] = input[2] * f1;
+      }
+      if (req_comp == 2) output[1] = 1;
+      if (req_comp == 4) output[3] = 1;
+   } else {
+      switch (req_comp) {
+         case 4: output[3] = 1; /* fallthrough */
+         case 3: output[0] = output[1] = output[2] = 0;
+                 break;
+         case 2: output[1] = 1; /* fallthrough */
+         case 1: output[0] = 0;
+                 break;
+      }
+   }
+}
+
+static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   char buffer[STBI__HDR_BUFLEN];
+   char *token;
+   int valid = 0;
+   int width, height;
+   stbi_uc *scanline;
+   float *hdr_data;
+   int len;
+   unsigned char count, value;
+   int i, j, k, c1,c2, z;
+   const char *headerToken;
+   STBI_NOTUSED(ri);
+
+   // Check identifier
+   headerToken = stbi__hdr_gettoken(s,buffer);
+   if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0)
+      return stbi__errpf("not HDR", "Corrupt HDR image");
+
+   // Parse header
+   for(;;) {
+      token = stbi__hdr_gettoken(s,buffer);
+      if (token[0] == 0) break;
+      if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
+   }
+
+   if (!valid)    return stbi__errpf("unsupported format", "Unsupported HDR format");
+
+   // Parse width and height
+   // can't use sscanf() if we're not using stdio!
+   token = stbi__hdr_gettoken(s,buffer);
+   if (strncmp(token, "-Y ", 3))  return stbi__errpf("unsupported data layout", "Unsupported HDR format");
+   token += 3;
+   height = (int) strtol(token, &token, 10);
+   while (*token == ' ') ++token;
+   if (strncmp(token, "+X ", 3))  return stbi__errpf("unsupported data layout", "Unsupported HDR format");
+   token += 3;
+   width = (int) strtol(token, NULL, 10);
+
+   *x = width;
+   *y = height;
+
+   if (comp) *comp = 3;
+   if (req_comp == 0) req_comp = 3;
+
+   if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0))
+      return stbi__errpf("too large", "HDR image is too large");
+
+   // Read data
+   hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0);
+   if (!hdr_data)
+      return stbi__errpf("outofmem", "Out of memory");
+
+   // Load image data
+   // image data is stored as some number of sca
+   if ( width < 8 || width >= 32768) {
+      // Read flat data
+      for (j=0; j < height; ++j) {
+         for (i=0; i < width; ++i) {
+            stbi_uc rgbe[4];
+           main_decode_loop:
+            stbi__getn(s, rgbe, 4);
+            stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp);
+         }
+      }
+   } else {
+      // Read RLE-encoded data
+      scanline = NULL;
+
+      for (j = 0; j < height; ++j) {
+         c1 = stbi__get8(s);
+         c2 = stbi__get8(s);
+         len = stbi__get8(s);
+         if (c1 != 2 || c2 != 2 || (len & 0x80)) {
+            // not run-length encoded, so we have to actually use THIS data as a decoded
+            // pixel (note this can't be a valid pixel--one of RGB must be >= 128)
+            stbi_uc rgbe[4];
+            rgbe[0] = (stbi_uc) c1;
+            rgbe[1] = (stbi_uc) c2;
+            rgbe[2] = (stbi_uc) len;
+            rgbe[3] = (stbi_uc) stbi__get8(s);
+            stbi__hdr_convert(hdr_data, rgbe, req_comp);
+            i = 1;
+            j = 0;
+            STBI_FREE(scanline);
+            goto main_decode_loop; // yes, this makes no sense
+         }
+         len <<= 8;
+         len |= stbi__get8(s);
+         if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); }
+         if (scanline == NULL) {
+            scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0);
+            if (!scanline) {
+               STBI_FREE(hdr_data);
+               return stbi__errpf("outofmem", "Out of memory");
+            }
+         }
+
+         for (k = 0; k < 4; ++k) {
+            int nleft;
+            i = 0;
+            while ((nleft = width - i) > 0) {
+               count = stbi__get8(s);
+               if (count > 128) {
+                  // Run
+                  value = stbi__get8(s);
+                  count -= 128;
+                  if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); }
+                  for (z = 0; z < count; ++z)
+                     scanline[i++ * 4 + k] = value;
+               } else {
+                  // Dump
+                  if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); }
+                  for (z = 0; z < count; ++z)
+                     scanline[i++ * 4 + k] = stbi__get8(s);
+               }
+            }
+         }
+         for (i=0; i < width; ++i)
+            stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp);
+      }
+      if (scanline)
+         STBI_FREE(scanline);
+   }
+
+   return hdr_data;
+}
+
+static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   char buffer[STBI__HDR_BUFLEN];
+   char *token;
+   int valid = 0;
+   int dummy;
+
+   if (!x) x = &dummy;
+   if (!y) y = &dummy;
+   if (!comp) comp = &dummy;
+
+   if (stbi__hdr_test(s) == 0) {
+       stbi__rewind( s );
+       return 0;
+   }
+
+   for(;;) {
+      token = stbi__hdr_gettoken(s,buffer);
+      if (token[0] == 0) break;
+      if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
+   }
+
+   if (!valid) {
+       stbi__rewind( s );
+       return 0;
+   }
+   token = stbi__hdr_gettoken(s,buffer);
+   if (strncmp(token, "-Y ", 3)) {
+       stbi__rewind( s );
+       return 0;
+   }
+   token += 3;
+   *y = (int) strtol(token, &token, 10);
+   while (*token == ' ') ++token;
+   if (strncmp(token, "+X ", 3)) {
+       stbi__rewind( s );
+       return 0;
+   }
+   token += 3;
+   *x = (int) strtol(token, NULL, 10);
+   *comp = 3;
+   return 1;
+}
+#endif // STBI_NO_HDR
+
+#ifndef STBI_NO_BMP
+static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   void *p;
+   stbi__bmp_data info;
+
+   info.all_a = 255;
+   p = stbi__bmp_parse_header(s, &info);
+   stbi__rewind( s );
+   if (p == NULL)
+      return 0;
+   if (x) *x = s->img_x;
+   if (y) *y = s->img_y;
+   if (comp) *comp = info.ma ? 4 : 3;
+   return 1;
+}
+#endif
+
+#ifndef STBI_NO_PSD
+static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   int channelCount, dummy, depth;
+   if (!x) x = &dummy;
+   if (!y) y = &dummy;
+   if (!comp) comp = &dummy;
+   if (stbi__get32be(s) != 0x38425053) {
+       stbi__rewind( s );
+       return 0;
+   }
+   if (stbi__get16be(s) != 1) {
+       stbi__rewind( s );
+       return 0;
+   }
+   stbi__skip(s, 6);
+   channelCount = stbi__get16be(s);
+   if (channelCount < 0 || channelCount > 16) {
+       stbi__rewind( s );
+       return 0;
+   }
+   *y = stbi__get32be(s);
+   *x = stbi__get32be(s);
+   depth = stbi__get16be(s);
+   if (depth != 8 && depth != 16) {
+       stbi__rewind( s );
+       return 0;
+   }
+   if (stbi__get16be(s) != 3) {
+       stbi__rewind( s );
+       return 0;
+   }
+   *comp = 4;
+   return 1;
+}
+
+static int stbi__psd_is16(stbi__context *s)
+{
+   int channelCount, depth;
+   if (stbi__get32be(s) != 0x38425053) {
+       stbi__rewind( s );
+       return 0;
+   }
+   if (stbi__get16be(s) != 1) {
+       stbi__rewind( s );
+       return 0;
+   }
+   stbi__skip(s, 6);
+   channelCount = stbi__get16be(s);
+   if (channelCount < 0 || channelCount > 16) {
+       stbi__rewind( s );
+       return 0;
+   }
+   (void) stbi__get32be(s);
+   (void) stbi__get32be(s);
+   depth = stbi__get16be(s);
+   if (depth != 16) {
+       stbi__rewind( s );
+       return 0;
+   }
+   return 1;
+}
+#endif
+
+#ifndef STBI_NO_PIC
+static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   int act_comp=0,num_packets=0,chained,dummy;
+   stbi__pic_packet packets[10];
+
+   if (!x) x = &dummy;
+   if (!y) y = &dummy;
+   if (!comp) comp = &dummy;
+
+   if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) {
+      stbi__rewind(s);
+      return 0;
+   }
+
+   stbi__skip(s, 88);
+
+   *x = stbi__get16be(s);
+   *y = stbi__get16be(s);
+   if (stbi__at_eof(s)) {
+      stbi__rewind( s);
+      return 0;
+   }
+   if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) {
+      stbi__rewind( s );
+      return 0;
+   }
+
+   stbi__skip(s, 8);
+
+   do {
+      stbi__pic_packet *packet;
+
+      if (num_packets==sizeof(packets)/sizeof(packets[0]))
+         return 0;
+
+      packet = &packets[num_packets++];
+      chained = stbi__get8(s);
+      packet->size    = stbi__get8(s);
+      packet->type    = stbi__get8(s);
+      packet->channel = stbi__get8(s);
+      act_comp |= packet->channel;
+
+      if (stbi__at_eof(s)) {
+          stbi__rewind( s );
+          return 0;
+      }
+      if (packet->size != 8) {
+          stbi__rewind( s );
+          return 0;
+      }
+   } while (chained);
+
+   *comp = (act_comp & 0x10 ? 4 : 3);
+
+   return 1;
+}
+#endif
+
+// *************************************************************************************************
+// Portable Gray Map and Portable Pixel Map loader
+// by Ken Miller
+//
+// PGM: http://netpbm.sourceforge.net/doc/pgm.html
+// PPM: http://netpbm.sourceforge.net/doc/ppm.html
+//
+// Known limitations:
+//    Does not support comments in the header section
+//    Does not support ASCII image data (formats P2 and P3)
+//    Does not support 16-bit-per-channel
+
+#ifndef STBI_NO_PNM
+
+static int      stbi__pnm_test(stbi__context *s)
+{
+   char p, t;
+   p = (char) stbi__get8(s);
+   t = (char) stbi__get8(s);
+   if (p != 'P' || (t != '5' && t != '6')) {
+       stbi__rewind( s );
+       return 0;
+   }
+   return 1;
+}
+
+static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   stbi_uc *out;
+   STBI_NOTUSED(ri);
+
+   if (!stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n))
+      return 0;
+
+   *x = s->img_x;
+   *y = s->img_y;
+   if (comp) *comp = s->img_n;
+
+   if (!stbi__mad3sizes_valid(s->img_n, s->img_x, s->img_y, 0))
+      return stbi__errpuc("too large", "PNM too large");
+
+   out = (stbi_uc *) stbi__malloc_mad3(s->img_n, s->img_x, s->img_y, 0);
+   if (!out) return stbi__errpuc("outofmem", "Out of memory");
+   stbi__getn(s, out, s->img_n * s->img_x * s->img_y);
+
+   if (req_comp && req_comp != s->img_n) {
+      out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y);
+      if (out == NULL) return out; // stbi__convert_format frees input on failure
+   }
+   return out;
+}
+
+static int      stbi__pnm_isspace(char c)
+{
+   return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
+}
+
+static void     stbi__pnm_skip_whitespace(stbi__context *s, char *c)
+{
+   for (;;) {
+      while (!stbi__at_eof(s) && stbi__pnm_isspace(*c))
+         *c = (char) stbi__get8(s);
+
+      if (stbi__at_eof(s) || *c != '#')
+         break;
+
+      while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' )
+         *c = (char) stbi__get8(s);
+   }
+}
+
+static int      stbi__pnm_isdigit(char c)
+{
+   return c >= '0' && c <= '9';
+}
+
+static int      stbi__pnm_getinteger(stbi__context *s, char *c)
+{
+   int value = 0;
+
+   while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) {
+      value = value*10 + (*c - '0');
+      *c = (char) stbi__get8(s);
+   }
+
+   return value;
+}
+
+static int      stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   int maxv, dummy;
+   char c, p, t;
+
+   if (!x) x = &dummy;
+   if (!y) y = &dummy;
+   if (!comp) comp = &dummy;
+
+   stbi__rewind(s);
+
+   // Get identifier
+   p = (char) stbi__get8(s);
+   t = (char) stbi__get8(s);
+   if (p != 'P' || (t != '5' && t != '6')) {
+       stbi__rewind(s);
+       return 0;
+   }
+
+   *comp = (t == '6') ? 3 : 1;  // '5' is 1-component .pgm; '6' is 3-component .ppm
+
+   c = (char) stbi__get8(s);
+   stbi__pnm_skip_whitespace(s, &c);
+
+   *x = stbi__pnm_getinteger(s, &c); // read width
+   stbi__pnm_skip_whitespace(s, &c);
+
+   *y = stbi__pnm_getinteger(s, &c); // read height
+   stbi__pnm_skip_whitespace(s, &c);
+
+   maxv = stbi__pnm_getinteger(s, &c);  // read max value
+
+   if (maxv > 255)
+      return stbi__err("max value > 255", "PPM image not 8-bit");
+   else
+      return 1;
+}
+#endif
+
+static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp)
+{
+   #ifndef STBI_NO_JPEG
+   if (stbi__jpeg_info(s, x, y, comp)) return 1;
+   #endif
+
+   #ifndef STBI_NO_PNG
+   if (stbi__png_info(s, x, y, comp))  return 1;
+   #endif
+
+   #ifndef STBI_NO_GIF
+   if (stbi__gif_info(s, x, y, comp))  return 1;
+   #endif
+
+   #ifndef STBI_NO_BMP
+   if (stbi__bmp_info(s, x, y, comp))  return 1;
+   #endif
+
+   #ifndef STBI_NO_PSD
+   if (stbi__psd_info(s, x, y, comp))  return 1;
+   #endif
+
+   #ifndef STBI_NO_PIC
+   if (stbi__pic_info(s, x, y, comp))  return 1;
+   #endif
+
+   #ifndef STBI_NO_PNM
+   if (stbi__pnm_info(s, x, y, comp))  return 1;
+   #endif
+
+   #ifndef STBI_NO_HDR
+   if (stbi__hdr_info(s, x, y, comp))  return 1;
+   #endif
+
+   // test tga last because it's a crappy test!
+   #ifndef STBI_NO_TGA
+   if (stbi__tga_info(s, x, y, comp))
+       return 1;
+   #endif
+   return stbi__err("unknown image type", "Image not of any known type, or corrupt");
+}
+
+static int stbi__is_16_main(stbi__context *s)
+{
+   #ifndef STBI_NO_PNG
+   if (stbi__png_is16(s))  return 1;
+   #endif
+
+   #ifndef STBI_NO_PSD
+   if (stbi__psd_is16(s))  return 1;
+   #endif
+
+   return 0;
+}
+
+#ifndef STBI_NO_STDIO
+STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp)
+{
+    FILE *f = stbi__fopen(filename, "rb");
+    int result;
+    if (!f) return stbi__err("can't fopen", "Unable to open file");
+    result = stbi_info_from_file(f, x, y, comp);
+    fclose(f);
+    return result;
+}
+
+STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)
+{
+   int r;
+   stbi__context s;
+   long pos = ftell(f);
+   stbi__start_file(&s, f);
+   r = stbi__info_main(&s,x,y,comp);
+   fseek(f,pos,SEEK_SET);
+   return r;
+}
+
+STBIDEF int stbi_is_16_bit(char const *filename)
+{
+    FILE *f = stbi__fopen(filename, "rb");
+    int result;
+    if (!f) return stbi__err("can't fopen", "Unable to open file");
+    result = stbi_is_16_bit_from_file(f);
+    fclose(f);
+    return result;
+}
+
+STBIDEF int stbi_is_16_bit_from_file(FILE *f)
+{
+   int r;
+   stbi__context s;
+   long pos = ftell(f);
+   stbi__start_file(&s, f);
+   r = stbi__is_16_main(&s);
+   fseek(f,pos,SEEK_SET);
+   return r;
+}
+#endif // !STBI_NO_STDIO
+
+STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp)
+{
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__info_main(&s,x,y,comp);
+}
+
+STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp)
+{
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);
+   return stbi__info_main(&s,x,y,comp);
+}
+
+STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len)
+{
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__is_16_main(&s);
+}
+
+STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user)
+{
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);
+   return stbi__is_16_main(&s);
+}
+
+#endif // STB_IMAGE_IMPLEMENTATION
+
+/*
+   revision history:
+      2.20  (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs 
+      2.19  (2018-02-11) fix warning
+      2.18  (2018-01-30) fix warnings
+      2.17  (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug
+                         1-bit BMP
+                         *_is_16_bit api
+                         avoid warnings
+      2.16  (2017-07-23) all functions have 16-bit variants;
+                         STBI_NO_STDIO works again;
+                         compilation fixes;
+                         fix rounding in unpremultiply;
+                         optimize vertical flip;
+                         disable raw_len validation;
+                         documentation fixes
+      2.15  (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode;
+                         warning fixes; disable run-time SSE detection on gcc;
+                         uniform handling of optional "return" values;
+                         thread-safe initialization of zlib tables
+      2.14  (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs
+      2.13  (2016-11-29) add 16-bit API, only supported for PNG right now
+      2.12  (2016-04-02) fix typo in 2.11 PSD fix that caused crashes
+      2.11  (2016-04-02) allocate large structures on the stack
+                         remove white matting for transparent PSD
+                         fix reported channel count for PNG & BMP
+                         re-enable SSE2 in non-gcc 64-bit
+                         support RGB-formatted JPEG
+                         read 16-bit PNGs (only as 8-bit)
+      2.10  (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED
+      2.09  (2016-01-16) allow comments in PNM files
+                         16-bit-per-pixel TGA (not bit-per-component)
+                         info() for TGA could break due to .hdr handling
+                         info() for BMP to shares code instead of sloppy parse
+                         can use STBI_REALLOC_SIZED if allocator doesn't support realloc
+                         code cleanup
+      2.08  (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA
+      2.07  (2015-09-13) fix compiler warnings
+                         partial animated GIF support
+                         limited 16-bpc PSD support
+                         #ifdef unused functions
+                         bug with < 92 byte PIC,PNM,HDR,TGA
+      2.06  (2015-04-19) fix bug where PSD returns wrong '*comp' value
+      2.05  (2015-04-19) fix bug in progressive JPEG handling, fix warning
+      2.04  (2015-04-15) try to re-enable SIMD on MinGW 64-bit
+      2.03  (2015-04-12) extra corruption checking (mmozeiko)
+                         stbi_set_flip_vertically_on_load (nguillemot)
+                         fix NEON support; fix mingw support
+      2.02  (2015-01-19) fix incorrect assert, fix warning
+      2.01  (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2
+      2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG
+      2.00  (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg)
+                         progressive JPEG (stb)
+                         PGM/PPM support (Ken Miller)
+                         STBI_MALLOC,STBI_REALLOC,STBI_FREE
+                         GIF bugfix -- seemingly never worked
+                         STBI_NO_*, STBI_ONLY_*
+      1.48  (2014-12-14) fix incorrectly-named assert()
+      1.47  (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb)
+                         optimize PNG (ryg)
+                         fix bug in interlaced PNG with user-specified channel count (stb)
+      1.46  (2014-08-26)
+              fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG
+      1.45  (2014-08-16)
+              fix MSVC-ARM internal compiler error by wrapping malloc
+      1.44  (2014-08-07)
+              various warning fixes from Ronny Chevalier
+      1.43  (2014-07-15)
+              fix MSVC-only compiler problem in code changed in 1.42
+      1.42  (2014-07-09)
+              don't define _CRT_SECURE_NO_WARNINGS (affects user code)
+              fixes to stbi__cleanup_jpeg path
+              added STBI_ASSERT to avoid requiring assert.h
+      1.41  (2014-06-25)
+              fix search&replace from 1.36 that messed up comments/error messages
+      1.40  (2014-06-22)
+              fix gcc struct-initialization warning
+      1.39  (2014-06-15)
+              fix to TGA optimization when req_comp != number of components in TGA;
+              fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite)
+              add support for BMP version 5 (more ignored fields)
+      1.38  (2014-06-06)
+              suppress MSVC warnings on integer casts truncating values
+              fix accidental rename of 'skip' field of I/O
+      1.37  (2014-06-04)
+              remove duplicate typedef
+      1.36  (2014-06-03)
+              convert to header file single-file library
+              if de-iphone isn't set, load iphone images color-swapped instead of returning NULL
+      1.35  (2014-05-27)
+              various warnings
+              fix broken STBI_SIMD path
+              fix bug where stbi_load_from_file no longer left file pointer in correct place
+              fix broken non-easy path for 32-bit BMP (possibly never used)
+              TGA optimization by Arseny Kapoulkine
+      1.34  (unknown)
+              use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case
+      1.33  (2011-07-14)
+              make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements
+      1.32  (2011-07-13)
+              support for "info" function for all supported filetypes (SpartanJ)
+      1.31  (2011-06-20)
+              a few more leak fixes, bug in PNG handling (SpartanJ)
+      1.30  (2011-06-11)
+              added ability to load files via callbacks to accomidate custom input streams (Ben Wenger)
+              removed deprecated format-specific test/load functions
+              removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway
+              error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha)
+              fix inefficiency in decoding 32-bit BMP (David Woo)
+      1.29  (2010-08-16)
+              various warning fixes from Aurelien Pocheville
+      1.28  (2010-08-01)
+              fix bug in GIF palette transparency (SpartanJ)
+      1.27  (2010-08-01)
+              cast-to-stbi_uc to fix warnings
+      1.26  (2010-07-24)
+              fix bug in file buffering for PNG reported by SpartanJ
+      1.25  (2010-07-17)
+              refix trans_data warning (Won Chun)
+      1.24  (2010-07-12)
+              perf improvements reading from files on platforms with lock-heavy fgetc()
+              minor perf improvements for jpeg
+              deprecated type-specific functions so we'll get feedback if they're needed
+              attempt to fix trans_data warning (Won Chun)
+      1.23    fixed bug in iPhone support
+      1.22  (2010-07-10)
+              removed image *writing* support
+              stbi_info support from Jetro Lauha
+              GIF support from Jean-Marc Lienher
+              iPhone PNG-extensions from James Brown
+              warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva)
+      1.21    fix use of 'stbi_uc' in header (reported by jon blow)
+      1.20    added support for Softimage PIC, by Tom Seddon
+      1.19    bug in interlaced PNG corruption check (found by ryg)
+      1.18  (2008-08-02)
+              fix a threading bug (local mutable static)
+      1.17    support interlaced PNG
+      1.16    major bugfix - stbi__convert_format converted one too many pixels
+      1.15    initialize some fields for thread safety
+      1.14    fix threadsafe conversion bug
+              header-file-only version (#define STBI_HEADER_FILE_ONLY before including)
+      1.13    threadsafe
+      1.12    const qualifiers in the API
+      1.11    Support installable IDCT, colorspace conversion routines
+      1.10    Fixes for 64-bit (don't use "unsigned long")
+              optimized upsampling by Fabian "ryg" Giesen
+      1.09    Fix format-conversion for PSD code (bad global variables!)
+      1.08    Thatcher Ulrich's PSD code integrated by Nicolas Schulz
+      1.07    attempt to fix C++ warning/errors again
+      1.06    attempt to fix C++ warning/errors again
+      1.05    fix TGA loading to return correct *comp and use good luminance calc
+      1.04    default float alpha is 1, not 255; use 'void *' for stbi_image_free
+      1.03    bugfixes to STBI_NO_STDIO, STBI_NO_HDR
+      1.02    support for (subset of) HDR files, float interface for preferred access to them
+      1.01    fix bug: possible bug in handling right-side up bmps... not sure
+              fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all
+      1.00    interface to zlib that skips zlib header
+      0.99    correct handling of alpha in palette
+      0.98    TGA loader by lonesock; dynamically add loaders (untested)
+      0.97    jpeg errors on too large a file; also catch another malloc failure
+      0.96    fix detection of invalid v value - particleman@mollyrocket forum
+      0.95    during header scan, seek to markers in case of padding
+      0.94    STBI_NO_STDIO to disable stdio usage; rename all #defines the same
+      0.93    handle jpegtran output; verbose errors
+      0.92    read 4,8,16,24,32-bit BMP files of several formats
+      0.91    output 24-bit Windows 3.0 BMP files
+      0.90    fix a few more warnings; bump version number to approach 1.0
+      0.61    bugfixes due to Marc LeBlanc, Christopher Lloyd
+      0.60    fix compiling as c++
+      0.59    fix warnings: merge Dave Moore's -Wall fixes
+      0.58    fix bug: zlib uncompressed mode len/nlen was wrong endian
+      0.57    fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available
+      0.56    fix bug: zlib uncompressed mode len vs. nlen
+      0.55    fix bug: restart_interval not initialized to 0
+      0.54    allow NULL for 'int *comp'
+      0.53    fix bug in png 3->4; speedup png decoding
+      0.52    png handles req_comp=3,4 directly; minor cleanup; jpeg comments
+      0.51    obey req_comp requests, 1-component jpegs return as 1-component,
+              on 'test' only check type, not whether we support this variant
+      0.50  (2006-11-19)
+              first released version
+*/
+
+
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+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.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+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 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.
+------------------------------------------------------------------------------
+*/
diff --git a/engine/inc/uf/config.h b/engine/inc/uf/config.h
new file mode 100644
index 00000000..8b9d867f
--- /dev/null
+++ b/engine/inc/uf/config.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#if defined(UF_ENV)
+	#warning Specific variables already defined; undefining...
+
+	#undef UF_ENV
+	#undef UF_ENV_WINDOWS
+	#undef UF_ENV_LINUX
+	#undef UF_ENV_MACOS
+	#undef UF_ENV_FREEBSD
+	#undef UF_ENV_DREAMCAST
+	#undef UF_ENV_UNKNOWN
+#endif
+
+#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+	// Windows
+	#define UF_ENV "Windows"
+	#define UF_ENV_WINDOWS 1
+	#define UF_ENV_HEADER "windows.h"
+	#if defined(__CYGWIN__)
+		#define to_string(var) string(var)
+	#endif
+	#define _WIN32_WINNT 0x0600
+	#define WINVER 0x0600
+	
+	#define UF_IO_ROOT "./data/"
+#elif defined(linux) || defined(__linux)
+	// Linux
+	#define UF_ENV "Linux"
+	#define UF_ENV_LINUX 1
+	#define UF_ENV_HEADER "linux.h"
+	
+	#define UF_IO_ROOT "./data/"
+#elif defined(__APPLE__) || defined(MACOSX) || defined(macintosh) || defined(Macintosh)
+	// MacOS
+	#define UF_ENV "OSX"
+	#define UF_ENV_OSX 1
+	#define UF_ENV_HEADER "osx.h"
+	
+	#define UF_IO_ROOT "./data/"
+#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+	// FreeBSD
+	#define UF_ENV "FreeBSD"
+	#define UF_ENV_FREEBSD 1
+	#define UF_ENV_HEADER "freebsd.h"
+	
+	#define UF_IO_ROOT "./data/"
+#elif defined(__sh__)
+	// Dreamcast
+	#define UF_ENV "Dreamcast"
+	#define UF_ENV_DREAMCAST 1
+	#define UF_ENV_HEADER "dreamcast.h"
+	#include UF_ENV_HEADER
+
+	#define _arch_dreamcast
+
+	#define UF_IO_ROOT "/cd/"
+#else
+	// Unsupported system
+	#define UF_ENV "Unknown"
+	#define UF_ENV_UNKNOWN 1
+	#define UF_ENV_HEADER "unknown.h"
+	#warning Using "unknown"
+ 	#error No support
+#endif
+
+#if !defined(UF_STATIC)
+	#if defined(UF_ENV_WINDOWS)
+		// Windows compilers need specific (and different) keywords for export and import
+		#define UF_API_EXPORT __declspec(dllexport)
+		#define UF_API_IMPORT __declspec(dllimport)
+		// For Visual C++ compilers, we also need to turn off this annoying C4251 warning
+		#ifdef _MSC_VER
+			#pragma warning(disable : 4251)
+		#endif
+	#else // Linux, FreeBSD, Mac OS X
+		#if __GNUC__ >= 4
+			// GCC 4 has special keywords for showing/hidding symbols,
+			// the same keyword is used for both importing and exporting
+			#define UF_API_EXPORT __attribute__ ((__visibility__ ("default")))
+			#define UF_API_IMPORT __attribute__ ((__visibility__ ("default")))
+		#else
+			// GCC < 4 has no mechanism to explicitely hide symbols, everything's exported
+			#define UF_API_EXPORT
+			#define UF_API_IMPORT
+		#endif
+	#endif
+#else
+	// Static build doesn't need import/export macros
+	#define UF_API_EXPORT
+	#define UF_API_IMPORT
+#endif
+
+#ifdef UF_EXPORTS
+	#define UF_API UF_API_EXPORT
+#else
+	#define UF_API UF_API_IMPORT
+#endif
+
+// Legacy support
+#define UF_API_VAR UF_API
+#define UF_API_CALL //__cdecl
+
+#ifdef UF_DISABLE_ALIGNAS
+	#define alignas(X)
+#endif
+
+#include "macros.h"
+#include "simd.h"
\ No newline at end of file
diff --git a/engine/inc/uf/engine/asset/asset.h b/engine/inc/uf/engine/asset/asset.h
new file mode 100644
index 00000000..259c9245
--- /dev/null
+++ b/engine/inc/uf/engine/asset/asset.h
@@ -0,0 +1,83 @@
+#pragma once
+
+#include <uf/utils/http/http.h>
+#include <uf/engine/entity/entity.h>
+#include <uf/utils/string/ext.h>
+#include <uf/utils/hook/hook.h>
+#include <unordered_map>
+#include <functional>
+
+namespace uf {
+	class UF_API Asset : public uf::Component {
+	protected:
+		static uf::Asset masterAssetLoader;
+	public:
+		// URL or file path
+		void processQueue();
+
+		void cache( const std::string&, const std::string&, const std::string&, const std::string& );
+		void load( const std::string&, const std::string&, const std::string&, const std::string& );
+
+		std::string cache( const std::string&, const std::string& = "", const std::string& = "" );
+		std::string load( const std::string&, const std::string& = "", const std::string& = "" );
+
+		std::string getOriginal( const std::string& );
+
+		template<typename T>
+		std::vector<T>& getContainer() {
+			return this->getComponent<std::vector<T>>();
+		}
+
+		template<typename T>
+		bool has( std::size_t i = 0 ) {
+			auto& container = this->getContainer<T>();
+			return container.size() > i;
+		}
+		template<typename T>
+		bool has( const std::string& url ) {
+			auto& container = this->getContainer<T>();
+			if ( container.empty() ) return false;
+			std::string extension = uf::io::extension( url );
+			uf::Serializer& map = this->getComponent<uf::Serializer>();
+			if ( ext::json::isNull( map[extension] ) ) return false;
+			if ( ext::json::isNull( map[extension][url] ) ) return false;
+			return true;
+		}
+		template<typename T>
+		T& get( std::size_t i = 0 ) {
+			auto& container = this->getContainer<T>();
+			return container.at(i);
+		}
+		template<typename T>
+		T& get( const std::string& url ) {
+			std::string extension = uf::io::extension( url );
+			uf::Serializer& map = this->getComponent<uf::Serializer>();
+		
+			std::size_t index = map[extension][url].as<size_t>();
+		
+			return this->get<T>(index);
+		}
+
+		template<typename T>
+		T& add( const std::string& url, const T& copy ) {
+			std::string extension = uf::io::extension( url );
+			uf::Serializer& map = this->getComponent<uf::Serializer>();
+			auto& container = this->getContainer<T>();
+			if ( !ext::json::isNull( map[extension][url] ) ) return this->get<T>(url);
+			
+			container.push_back( copy );
+			return container.back();
+		}
+		template<typename T>
+		T& add( const std::string& url, T&& move ) {
+			std::string extension = uf::io::extension( url );
+			uf::Serializer& map = this->getComponent<uf::Serializer>();
+			auto& container = this->getContainer<T>();
+
+			if ( !ext::json::isNull( map[extension][url] ) ) return this->get<T>(url);
+		
+			container.push_back( move );
+			return container.back();
+		}
+	};
+}
\ No newline at end of file
diff --git a/engine/inc/uf/engine/asset/masterdata.h b/engine/inc/uf/engine/asset/masterdata.h
new file mode 100644
index 00000000..b84ad354
--- /dev/null
+++ b/engine/inc/uf/engine/asset/masterdata.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include <uf/engine/asset/asset.h>
+
+namespace uf {
+	class UF_API MasterData {
+	protected:
+		std::string m_table;
+		std::string m_key;
+		uf::Serializer m_data;
+
+		static uf::Asset assetLoader;
+		static std::string root;
+	public:
+		uf::Serializer load( const std::string&, size_t );
+		uf::Serializer load( const std::string&, const std::string& = "" );
+		uf::Serializer get( const std::string& k = "" ) const;
+		const std::string& tableName() const;
+		const std::string& keyName() const;
+	};
+}
\ No newline at end of file
diff --git a/engine/inc/uf/engine/behavior/behavior.h b/engine/inc/uf/engine/behavior/behavior.h
new file mode 100644
index 00000000..8ded8cd9
--- /dev/null
+++ b/engine/inc/uf/engine/behavior/behavior.h
@@ -0,0 +1,78 @@
+#pragma once
+
+#include <uf/utils/component/component.h>
+
+#include <functional>
+#include <vector>
+#include <typeindex>
+
+namespace uf {
+	class UF_API Entity;
+	class UF_API Object;
+}
+
+namespace pod {
+	struct UF_API Behavior {
+		typedef std::type_index type_t;
+		typedef std::function<void(uf::Object&)> function_t;
+
+		type_t type = std::type_index(typeid(pod::Behavior));
+		function_t initialize = function_t();
+		function_t tick = function_t();
+		function_t render = function_t();
+		function_t destroy = function_t();
+	};
+}
+
+namespace uf {
+	class UF_API Behaviors : public uf::Component {
+	protected:
+		typedef std::vector<pod::Behavior> container_t;
+		container_t m_behaviors;
+	public:
+		void initialize();
+		void tick();
+		void render();
+		void destroy();
+
+		container_t& getBehaviors() {
+			return this->m_behaviors;
+		}
+
+		bool hasBehavior( const pod::Behavior& );
+		template<typename T>
+		bool hasBehavior() {
+			for ( auto& behavior : this->m_behaviors ) {
+				if ( behavior.type == getType<T>() ) return true;
+			}
+			return false;
+		}
+
+		void addBehavior( const pod::Behavior& );
+		void removeBehavior( const pod::Behavior& );
+		
+		template<typename T>
+		static pod::Behavior::type_t getType() {
+			return std::type_index(typeid(T));
+		}
+		template<typename T>
+		void addBehavior() {
+			this->addBehavior(pod::Behavior{
+				.type = getType<T>(),
+				.initialize = T::initialize,
+				.tick = T::tick,
+				.render = T::render,
+				.destroy = T::destroy,
+			});
+		}
+		template<typename T>
+		void removeBehavior() {
+			this->removeBehavior(pod::Behavior{
+				.type = getType<T>()
+			});
+		}
+	};
+
+}
+
+#include "macros.inl"
\ No newline at end of file
diff --git a/engine/inc/uf/engine/behavior/macros.inl b/engine/inc/uf/engine/behavior/macros.inl
new file mode 100644
index 00000000..2629b023
--- /dev/null
+++ b/engine/inc/uf/engine/behavior/macros.inl
@@ -0,0 +1,84 @@
+#pragma once
+
+#define UF_BEHAVIOR_ENTITY_H( OBJ )\
+	class UF_API OBJ ## Behavior {\
+	public:\
+		static void attach( uf::Entity& );\
+		static void initialize( uf::Object& );\
+		static void tick( uf::Object& );\
+		static void render( uf::Object& );\
+		static void destroy( uf::Object& );\
+	};
+
+#define UF_BEHAVIOR_ENTITY_CPP_BEGIN( OBJ )\
+	void OBJ ## Behavior::attach( uf::Entity& self ) {\
+		self.addBehavior(pod::Behavior{\
+			.type = uf::Behaviors::getType<OBJ ## Behavior>(),\
+			.initialize = OBJ ## Behavior::initialize,\
+			.tick = OBJ ## Behavior::tick,\
+			.render = OBJ ## Behavior::render,\
+			.destroy = OBJ ## Behavior::destroy,\
+		});\
+	}
+#define UF_BEHAVIOR_ENTITY_CPP_ATTACH( OBJ ) {\
+	OBJ ## Behavior::attach( *this );\
+}
+
+#define UF_BEHAVIOR_ENTITY_CPP_END( OBJ )
+
+/*
+#define UF_BEHAVIOR_VIRTUAL 0
+
+#define UF_BEHAVIOR_ENTITY_H( OBJ )\
+	class UF_API OBJ ## Behavior {\
+	public:\
+		static void attach( uf::Entity& );\
+		static void initialize( uf::Object& );\
+		static void tick( uf::Object& );\
+		static void render( uf::Object& );\
+		static void destroy( uf::Object& );\
+	};
+#if UF_BEHAVIOR_VIRTUAL
+	#define UF_BEHAVIOR_VIRTUAL_H() \
+		virtual void initialize();\
+		virtual void destroy();\
+		virtual void tick();\
+		virtual void render();
+
+	#define UF_BEHAVIOR_ENTITY_CPP_VIRTUAL_DEFINITIONS( OBJ )\
+		void uf::OBJ::initialize(){ uf::Behaviors::initialize(); }\
+		void uf::OBJ::tick(){ uf::Behaviors::tick(); }\
+		void uf::OBJ::render(){ uf::Behaviors::render(); }\
+		void uf::OBJ::destroy(){ uf::Behaviors::destroy(); }
+#else
+	#define UF_BEHAVIOR_VIRTUAL_H()
+	#define UF_BEHAVIOR_ENTITY_CPP_VIRTUAL_DEFINITIONS( OBJ )
+#endif
+#define UF_BEHAVIOR_ENTITY_CPP_BEGIN( OBJ )\
+	uf::OBJ::OBJ() { \
+		uf::OBJ ## Behavior::attach( *this );\
+	}\
+	UF_BEHAVIOR_ENTITY_CPP_VIRTUAL_DEFINITIONS( OBJ )\
+	void uf::OBJ ## Behavior::attach( uf::Entity& self ) {\
+		self.addBehavior(pod::Behavior{\
+			.type = uf::Behaviors::getType<uf::OBJ ## Behavior>(),\
+			.initialize = uf::OBJ ## Behavior::initialize,\
+			.tick = uf::OBJ ## Behavior::tick,\
+			.render = uf::OBJ ## Behavior::render,\
+			.destroy = uf::OBJ ## Behavior::destroy,\
+		});\
+	}
+#define UF_BEHAVIOR_ENTITY_CPP_END( OBJ )
+
+#define EXT_BEHAVIOR_ENTITY_CPP_BEGIN( OBJ )\
+	void ext::OBJ ## Behavior::attach( uf::Entity& self ) {\
+		self.addBehavior(pod::Behavior{\
+			.type = uf::Behaviors::getType<ext::OBJ ## Behavior>(),\
+			.initialize = ext::OBJ ## Behavior::initialize,\
+			.tick = ext::OBJ ## Behavior::tick,\
+			.render = ext::OBJ ## Behavior::render,\
+			.destroy = ext::OBJ ## Behavior::destroy,\
+		});\
+	}
+#define EXT_BEHAVIOR_ENTITY_CPP_END( OBJ )
+*/
\ No newline at end of file
diff --git a/engine/inc/uf/engine/entity/behavior.h b/engine/inc/uf/engine/entity/behavior.h
new file mode 100644
index 00000000..b4ef84d2
--- /dev/null
+++ b/engine/inc/uf/engine/entity/behavior.h
@@ -0,0 +1,5 @@
+#pragma once
+
+namespace uf {
+	UF_BEHAVIOR_ENTITY_H(Entity)
+}
\ No newline at end of file
diff --git a/engine/inc/uf/engine/entity/entity.h b/engine/inc/uf/engine/entity/entity.h
new file mode 100644
index 00000000..850eb296
--- /dev/null
+++ b/engine/inc/uf/engine/entity/entity.h
@@ -0,0 +1,76 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/engine/behavior/behavior.h>
+#include <uf/utils/serialize/serializer.h>
+#include <vector>
+#include <functional>
+
+#include <uf/utils/mempool/mempool.h>
+
+namespace uf {
+	class UF_API Object;
+	class UF_API Entity : public uf::Behaviors {
+	friend class EntityBehavior;
+	public:
+		typedef std::vector<uf::Entity*> container_t;
+		static uf::Entity null;
+		static bool deleteChildrenOnDestroy;
+		static bool deleteComponentsOnDestroy;
+	protected:
+		static std::size_t uids;
+
+		uf::Entity* m_parent = NULL;
+		uf::Entity::container_t m_children;
+
+		std::size_t m_uid = 0;
+		std::string m_name = "Entity";
+
+	public:
+		static uf::MemoryPool memoryPool;
+		Entity();
+		~Entity();
+		// identifiers
+		bool isValid() const;
+		const std::string& getName() const;
+		std::size_t getUid() const;
+		void setName( const std::string& );
+		// cast to other Entity classes, avoid nasty shit like *((uf::Object*) &entity)
+		template<typename T=uf::Object> T& as();
+		template<typename T=uf::Object> const T& as() const;
+		// parent-child relationship
+		bool hasParent() const;
+		template<typename T=uf::Entity> T& getParent();
+		template<typename T=uf::Entity> T& getRootParent();
+		template<typename T=uf::Entity> const T& getParent() const;
+		template<typename T=uf::Entity> const T& getRootParent() const;
+
+		void setParent();
+		void setParent( uf::Entity& parent );
+		uf::Entity& addChild( uf::Entity& child );
+		void addChild( uf::Entity* child );
+		void moveChild( uf::Entity& child );
+		void removeChild( uf::Entity& child );
+
+		uf::Entity::container_t& getChildren();
+		const uf::Entity::container_t& getChildren() const;
+		// use instantiate to allocate
+		void* operator new(size_t, const std::string& = "");
+		void operator delete(void*);
+		// search
+		uf::Entity* findByName( const std::string& name );
+		uf::Entity* findByUid( std::size_t id );
+		const uf::Entity* findByName( const std::string& name ) const;
+		const uf::Entity* findByUid( std::size_t id ) const;
+		// filters
+		void process( std::function<void(uf::Entity*)> );
+		void process( std::function<void(uf::Entity*, int)>, int depth = 0 );
+		// globals
+		static uf::Entity* globalFindByUid( size_t id );
+		static uf::Entity* globalFindByName( const std::string& name );
+
+	};
+}
+
+#include "entity.inl"
+#include "behavior.h"
\ No newline at end of file
diff --git a/engine/inc/uf/engine/entity/entity.inl b/engine/inc/uf/engine/entity/entity.inl
new file mode 100644
index 00000000..8da02a4e
--- /dev/null
+++ b/engine/inc/uf/engine/entity/entity.inl
@@ -0,0 +1,56 @@
+template<typename T> T& uf::Entity::as() {
+	return *((T*) this);
+}
+template<typename T> const T& uf::Entity::as() const {
+	return *((T*) this);
+}
+template<typename T> T& uf::Entity::getParent() {
+//	static T null;
+//	return this->m_parent ? *(T*)this->m_parent : null;
+	if ( this->hasParent() ) return *(T*) this->m_parent;
+	return uf::Entity::null.as<T>();
+}
+template<typename T> T& uf::Entity::getRootParent() {
+//	static T null;
+	uf::Entity* last = this;
+	uf::Entity* pointer = this->m_parent;
+	while ( pointer != NULL ) {
+		last = pointer;
+		pointer = pointer->m_parent;
+	}
+	return *(T*) last;
+}
+template<typename T> const T& uf::Entity::getParent() const {
+//	static const T null;
+//	return this->m_parent ? *(T*)this->m_parent : null;
+	if ( this->hasParent() ) return *(const T*) this->m_parent;
+	return uf::Entity::null.as<T>();
+}
+template<typename T> const T& uf::Entity::getRootParent() const {
+//	static const T null;
+	const uf::Entity* last = this;
+	const uf::Entity* pointer = this->m_parent;
+	while ( pointer != NULL ) {
+		last = pointer;
+		pointer = pointer->m_parent;
+	}
+	return *(const T*) last;
+}
+/*
+template<typename T> void uf::Entity::initialize() {
+	static_cast<T*>(this)->initialize();
+	this->initialize();
+}
+template<typename T> void uf::Entity::destroy() {
+	static_cast<T*>(this)->destroy();
+	this->destroy();
+}
+template<typename T> void uf::Entity::tick() {
+	static_cast<T*>(this)->tick();
+	this->tick();
+}
+template<typename T> void uf::Entity::render() {
+	static_cast<T*>(this)->render();
+	this->render();
+}
+*/
\ No newline at end of file
diff --git a/engine/inc/uf/engine/instantiator/instantiator.h b/engine/inc/uf/engine/instantiator/instantiator.h
new file mode 100644
index 00000000..24751b9e
--- /dev/null
+++ b/engine/inc/uf/engine/instantiator/instantiator.h
@@ -0,0 +1,73 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/engine/entity/entity.h>
+#include <uf/utils/singletons/pre_main.h>
+#include <uf/utils/string/ext.h>
+#include <unordered_map>
+#include <typeindex>
+#include <functional>
+
+#define UF_INSTANTIATOR_ANNOUNCE 0
+
+namespace pod {
+	struct UF_API Instantiator {
+		typedef std::function<uf::Entity*()> function_t;
+		typedef std::vector<std::string> behaviors_t;
+		function_t function;
+		behaviors_t behaviors;
+	};
+
+	template<typename C>
+	struct UF_API NamedTypes {
+		typedef std::type_index type_t;
+		typedef std::unordered_map<type_t, std::string> container_t;
+		typedef std::unordered_map<std::string, C> map_t;
+		container_t names;
+		map_t map;
+
+		type_t getType( const std::string& name );
+		template<typename T> type_t getType();
+		template<typename T> std::string getName();
+
+		bool has( const std::string& name, bool = true );
+		template<typename T> bool has( bool = true );
+
+		template<typename T> void add( const std::string& name, const C& c );
+
+		C& get( const std::string& name );
+		template<typename T> C& get();
+	};
+}
+
+namespace uf {
+	namespace instantiator {
+		extern UF_API pod::NamedTypes<pod::Instantiator>* objects;
+		extern UF_API pod::NamedTypes<pod::Behavior>* behaviors;
+
+		uf::Entity* UF_API alloc( size_t );
+		template<typename T> T* alloc();
+		void UF_API free( uf::Entity* );
+		bool UF_API valid( uf::Entity* );
+
+		uf::Entity* UF_API reuse( size_t );
+		size_t UF_API collect( uint8_t = 0 );
+
+		template<typename T> void registerObject( const std::string& name );
+		template<typename T> void registerBehavior( const std::string& name );
+		template<typename T> void registerBinding( const std::string& name );
+		void UF_API registerBinding( const std::string& object, const std::string& behavior );
+
+		uf::Entity& UF_API instantiate( const std::string& );
+		template<typename T> T& instantiate();
+		template<typename T> T* _instantiate();
+
+		void UF_API bind( const std::string&, uf::Entity& );
+		template<typename T> void bind( uf::Entity& );
+		void UF_API unbind( const std::string&, uf::Entity& );
+		template<typename T> void unbind( uf::Entity& );
+	};
+}
+
+#include "instantiator.inl"
+#include "macros.inl"
\ No newline at end of file
diff --git a/engine/inc/uf/engine/instantiator/instantiator.inl b/engine/inc/uf/engine/instantiator/instantiator.inl
new file mode 100644
index 00000000..8d014cca
--- /dev/null
+++ b/engine/inc/uf/engine/instantiator/instantiator.inl
@@ -0,0 +1,186 @@
+#include <uf/utils/type/type.h>
+
+template<typename C>
+typename pod::NamedTypes<C>::type_t pod::NamedTypes<C>::getType( const std::string& name ) {
+	for ( auto pair : names ) if ( pair.second == name ) return pair.first;
+	return getType<void>();
+}
+template<typename C>
+template<typename T> typename pod::NamedTypes<C>::type_t pod::NamedTypes<C>::getType() {
+	return std::type_index(typeid(T));
+}
+template<typename C>
+template<typename T> std::string pod::NamedTypes<C>::getName() {
+	return names[getType<T>()];	
+}
+template<typename C>
+bool pod::NamedTypes<C>::has( const std::string& name, bool useNames ) {
+	return useNames ? names.count(getType(name)) > 0 : map.count(name) > 0;
+}template<typename C>
+template<typename T> bool pod::NamedTypes<C>::has( bool useNames ) {
+	return useNames ? names.count(getType<T>()) > 0 : map.count(getName<T>()) > 0;
+}
+template<typename C>
+template<typename T> void pod::NamedTypes<C>::add( const std::string& name, const C& c ) {
+	names[getType<T>()] = name;
+	map[name] = c;
+}
+template<typename C>
+C& pod::NamedTypes<C>::get( const std::string& name ) {
+	return map[name];
+}
+template<typename C>
+template<typename T>
+C& pod::NamedTypes<C>::get() {
+	return map[getName<T>()];
+}
+
+template<typename T>
+T* uf::instantiator::alloc() {
+	return (T*) alloc( sizeof(T) );
+}
+
+template<typename T> void uf::instantiator::registerObject( const std::string& name ) {
+	if ( !objects ) objects = new pod::NamedTypes<pod::Instantiator>;
+	auto& container = *uf::instantiator::objects;
+	container.add<T>(name, {
+		.function = _instantiate<T>,
+		.behaviors = {}
+	});
+
+	if ( UF_INSTANTIATOR_ANNOUNCE ) std::cout << "Registered instantiation for " << name << std::endl;
+}
+template<typename T> void uf::instantiator::registerBehavior( const std::string& name ) {
+	if ( !behaviors ) behaviors = new pod::NamedTypes<pod::Behavior>;
+	auto& container = *uf::instantiator::behaviors;
+	container.add<T>(name, pod::Behavior{
+		.type = uf::Behaviors::getType<T>(),
+		.initialize = T::initialize,
+		.tick = T::tick,
+		.render = T::render,
+		.destroy = T::destroy,
+	});
+
+	if ( UF_INSTANTIATOR_ANNOUNCE ) std::cout << "Registered behavior for " << name << std::endl;
+}
+
+template<typename T> void uf::instantiator::registerBinding( const std::string& name ) {
+	if ( !objects ) objects = new pod::NamedTypes<pod::Instantiator>;
+	auto& container = *uf::instantiator::objects;
+	auto& instantiator = container.get<T>();
+	instantiator.behaviors.emplace_back(name);
+	
+	if ( UF_INSTANTIATOR_ANNOUNCE ) std::cout << "Registered binding for " << name << std::endl;
+}
+
+template<typename T>
+T& uf::instantiator::instantiate() {
+	T* entity = alloc<T>();
+	::new (entity) T();
+	T& object = *entity;
+	uf::instantiator::bind<T>( object );
+	return object;
+}
+template<typename T>
+T* uf::instantiator::_instantiate() {
+	return &instantiate<T>();
+}
+
+template<typename T>
+void uf::instantiator::bind( uf::Entity& entity ) {
+	auto& instantiator = uf::instantiator::objects->get<T>();
+	for ( auto& name : instantiator.behaviors ) {
+		auto& behavior = uf::instantiator::behaviors->get( name );
+		entity.addBehavior(behavior);
+	}
+}
+
+template<typename T>
+void uf::instantiator::unbind( uf::Entity& entity ) {
+	auto& instantiator = uf::instantiator::objects->get<T>();
+	for ( auto& name : instantiator.behaviors ) {
+		auto& behavior = uf::instantiator::behaviors->get( name );
+		entity.removeBehavior(behavior);
+	}
+}
+/*
+template<typename T>
+T* uf::instantiator::alloc() {
+	return (T*) alloc( sizeof(T) );
+}
+
+template<typename T>
+std::string uf::instantiator::getName() {
+	auto type = getType<T>();
+	auto& names = *uf::instantiator::names;
+	return names[type];
+}
+
+template<typename T>
+uf::instantiator::type_t uf::instantiator::getType() {
+	return std::type_index(typeid(T));
+}
+
+template<typename T>
+T& uf::instantiator::instantiate() {
+	T* entity = alloc<T>();
+	::new (entity) T();
+	T& object = *entity;
+	uf::instantiator::bind<T>( object );
+	return object;
+}
+template<typename T>
+T* uf::instantiator::_instantiate() {
+	return &instantiate<T>();
+}
+
+template<typename T>
+void uf::instantiator::add( const std::string& name ) {
+	if ( !map ) map = new std::unordered_map<std::string, pod::Instantiator>;
+	if ( !names ) names = new std::unordered_map<uf::instantiator::type_t, std::string>;
+
+	auto& map = *uf::instantiator::map;
+	auto& names = *uf::instantiator::names;
+
+	auto type = getType<T>();
+	names[type] = name;
+	map[name] = {
+		.function = _instantiate<T>
+	};
+
+	std::cout << "Registered instantiation for " << name << std::endl;
+}
+template<typename T>
+void uf::instantiator::add( const pod::Behavior& behavior ) {
+	if ( !registered<T>() ) return;
+	auto type = getType<T>();
+	auto& map = *uf::instantiator::map;
+	auto& instantiator = map[getName<T>()];
+	instantiator.behaviors.emplace_back(behavior);
+}
+template<typename T, typename U>
+void uf::instantiator::add() {
+	return uf::instantiator::add<T>(pod::Behavior{
+		.type = uf::Behaviors::getType<U>(),
+		.initialize = U::initialize,
+		.tick = U::tick,
+		.render = U::render,
+		.destroy = U::destroy,
+	});
+}
+
+template<typename T>
+bool uf::instantiator::registered() {
+	return uf::instantiator::map->count(getName<T>()) > 0;
+}
+
+template<typename T>
+void uf::instantiator::bind( T& object ) {
+	if ( !registered<T>() ) return;
+	auto& map = *uf::instantiator::map;
+	auto& instantiator = map[getName<T>()];
+	for ( auto& behavior : instantiator.behaviors ) {
+		object.addBehavior(behavior);
+	}
+}
+*/
\ No newline at end of file
diff --git a/engine/inc/uf/engine/instantiator/macros.inl b/engine/inc/uf/engine/instantiator/macros.inl
new file mode 100644
index 00000000..345c904e
--- /dev/null
+++ b/engine/inc/uf/engine/instantiator/macros.inl
@@ -0,0 +1,106 @@
+#pragma once
+
+#define UF_OBJECT_REGISTER_CPP( OBJ ) \
+namespace {\
+	static uf::StaticInitialization TOKEN_PASTE(STATIC_INITIALIZATION_, __LINE__)( []{\
+		uf::instantiator::registerObject<OBJ>( UF_NS_GET_LAST(OBJ) );\
+	});\
+}
+
+#define UF_BEHAVIOR_REGISTER_CPP( BEHAVIOR ) \
+namespace {\
+	static uf::StaticInitialization TOKEN_PASTE(STATIC_INITIALIZATION_, __LINE__)( []{\
+		uf::instantiator::registerBehavior<BEHAVIOR>( UF_NS_GET_LAST(BEHAVIOR) );\
+	});\
+}
+
+#define UF_BEHAVIOR_REGISTER_AS_OBJECT( BEHAVIOR, OBJ )\
+namespace {\
+	static uf::StaticInitialization TOKEN_PASTE(STATIC_INITIALIZATION_, __LINE__)( []{\
+		uf::instantiator::registerBinding( UF_NS_GET_LAST(OBJ), UF_NS_GET_LAST(BEHAVIOR) );\
+	});\
+}
+
+#define UF_OBJECT_REGISTER_BEGIN( OBJ )\
+namespace {\
+	static uf::StaticInitialization TOKEN_PASTE(STATIC_INITIALIZATION_, __LINE__)( []{\
+		std::string name = UF_NS_GET_LAST(OBJ);\
+		uf::instantiator::registerObject<OBJ>( name );
+
+#define UF_OBJECT_BIND_BEHAVIOR( BEHAVIOR )\
+		uf::instantiator::registerBinding( name, UF_NS_GET_LAST(BEHAVIOR) );
+
+#define UF_OBJECT_REGISTER_BEHAVIOR( BEHAVIOR )\
+		uf::instantiator::registerBehavior<BEHAVIOR>( UF_NS_GET_LAST(BEHAVIOR) );\
+		UF_OBJECT_BIND_BEHAVIOR( BEHAVIOR )
+
+#define UF_OBJECT_REGISTER_END()\
+	});\
+}
+
+/*
+#define UF_OBJECT_REGISTER_CPP( OBJ ) \
+namespace {\
+	static uf::StaticInitialization REGISTER_UF_ ## OBJ( []{\
+		uf::instantiator::registerObject<uf::OBJ>( #OBJ );\
+	});\
+}
+#define EXT_OBJECT_REGISTER_CPP( OBJ ) \
+namespace {\
+	static uf::StaticInitialization REGISTER_EXT_ ## OBJ( []{\
+		uf::instantiator::registerObject<ext::OBJ>( #OBJ );\
+	});\
+}
+#define UF_BEHAVIOR_REGISTER_CPP( BEHAVIOR ) \
+namespace {\
+	static uf::StaticInitialization REGISTER_UF_ ## BEHAVIOR( []{\
+		uf::instantiator::registerBehavior<uf::BEHAVIOR>( #BEHAVIOR );\
+	});\
+}
+#define EXT_BEHAVIOR_REGISTER_CPP( BEHAVIOR ) \
+namespace {\
+	static uf::StaticInitialization REGISTER_EXT_ ## BEHAVIOR( []{\
+		uf::instantiator::registerBehavior<ext::BEHAVIOR>( #BEHAVIOR );\
+	});\
+}
+#define EXT_BEHAVIOR_REGISTER_AS_OBJECT( BEHAVIOR, OBJ )\
+namespace {\
+	static uf::StaticInitialization REGISTER_AS_OBJECT_EXT_ ## BEHAVIOR( []{\
+		uf::instantiator::registerBinding( #OBJ, #BEHAVIOR );\
+	});\
+}
+
+#define UF_OBJECT_REGISTER_BEGIN( OBJ )\
+namespace {\
+	static uf::StaticInitialization REGISTER_EXT_ ## OBJ( []{\
+		std::string name = #OBJ;\
+		uf::instantiator::registerObject<uf::OBJ>( name );
+
+#define UF_OBJECT_BIND_BEHAVIOR( BEHAVIOR )\
+		uf::instantiator::registerBinding( name, #BEHAVIOR );
+
+#define UF_OBJECT_REGISTER_BEHAVIOR( BEHAVIOR )\
+		uf::instantiator::registerBehavior<uf::BEHAVIOR>( #BEHAVIOR );\
+		UF_OBJECT_BIND_BEHAVIOR( BEHAVIOR )
+
+#define UF_OBJECT_REGISTER_END()\
+	});\
+}
+
+#define EXT_OBJECT_REGISTER_BEGIN( OBJ )\
+namespace {\
+	static uf::StaticInitialization REGISTER_EXT_ ## OBJ( []{\
+		std::string name = #OBJ;\
+		uf::instantiator::registerObject<ext::OBJ>( name );
+
+#define EXT_OBJECT_BIND_BEHAVIOR( BEHAVIOR )\
+		uf::instantiator::registerBinding( name, #BEHAVIOR );
+
+#define EXT_OBJECT_REGISTER_BEHAVIOR( BEHAVIOR )\
+		uf::instantiator::registerBehavior<ext::BEHAVIOR>( #BEHAVIOR );\
+		EXT_OBJECT_BIND_BEHAVIOR( BEHAVIOR )
+
+#define EXT_OBJECT_REGISTER_END()\
+	});\
+}
+*/
\ No newline at end of file
diff --git a/engine/inc/uf/engine/object/behavior.h b/engine/inc/uf/engine/object/behavior.h
new file mode 100644
index 00000000..aa402c1e
--- /dev/null
+++ b/engine/inc/uf/engine/object/behavior.h
@@ -0,0 +1,5 @@
+#pragma once
+
+namespace uf {
+	UF_BEHAVIOR_ENTITY_H(Object)
+}
\ No newline at end of file
diff --git a/engine/inc/uf/engine/object/behaviors/gltf.h b/engine/inc/uf/engine/object/behaviors/gltf.h
new file mode 100644
index 00000000..918f3183
--- /dev/null
+++ b/engine/inc/uf/engine/object/behaviors/gltf.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/engine/entity/entity.h>
+#include <uf/engine/scene/scene.h>
+
+namespace uf {
+	class UF_API GltfBehavior {
+	public:
+		static void attach( uf::Object& );
+		static void initialize( uf::Object& );
+		static void tick( uf::Object& );
+		static void render( uf::Object& );
+		static void destroy( uf::Object& );
+	};
+}
\ No newline at end of file
diff --git a/engine/inc/uf/engine/object/behaviors/loading.h b/engine/inc/uf/engine/object/behaviors/loading.h
new file mode 100644
index 00000000..df574268
--- /dev/null
+++ b/engine/inc/uf/engine/object/behaviors/loading.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/engine/entity/entity.h>
+#include <uf/engine/scene/scene.h>
+
+namespace uf {
+	class UF_API LoadingBehavior {
+	public:
+		static void attach( uf::Object& );
+		static void initialize( uf::Object& );
+		static void tick( uf::Object& );
+		static void render( uf::Object& );
+		static void destroy( uf::Object& );
+	};
+}
\ No newline at end of file
diff --git a/engine/inc/uf/engine/object/behaviors/lua.h b/engine/inc/uf/engine/object/behaviors/lua.h
new file mode 100644
index 00000000..3bb1c38f
--- /dev/null
+++ b/engine/inc/uf/engine/object/behaviors/lua.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/engine/entity/entity.h>
+#include <uf/engine/scene/scene.h>
+
+namespace uf {
+	class UF_API LuaBehavior {
+	public:
+		static void attach( uf::Object& );
+		static void initialize( uf::Object& );
+		static void tick( uf::Object& );
+		static void render( uf::Object& );
+		static void destroy( uf::Object& );
+	};
+}
\ No newline at end of file
diff --git a/engine/inc/uf/engine/object/behaviors/render.h b/engine/inc/uf/engine/object/behaviors/render.h
new file mode 100644
index 00000000..18e4ca8c
--- /dev/null
+++ b/engine/inc/uf/engine/object/behaviors/render.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/engine/entity/entity.h>
+#include <uf/engine/scene/scene.h>
+
+namespace uf {
+	class UF_API RenderBehavior {
+	public:
+		static void attach( uf::Object& );
+		static void initialize( uf::Object& );
+		static void tick( uf::Object& );
+		static void render( uf::Object& );
+		static void destroy( uf::Object& );
+	};
+}
\ No newline at end of file
diff --git a/engine/inc/uf/engine/object/object.h b/engine/inc/uf/engine/object/object.h
new file mode 100644
index 00000000..7bee03a0
--- /dev/null
+++ b/engine/inc/uf/engine/object/object.h
@@ -0,0 +1,61 @@
+#pragma once
+
+#include <uf/engine/entity/entity.h>
+#include <uf/engine/instantiator/instantiator.h>
+#include <uf/utils/hook/hook.h>
+#include <uf/utils/time/time.h>
+
+#include <typeindex>
+#include <functional>
+
+namespace uf {
+	class UF_API Object : public uf::Entity {
+	public:
+		static uf::Timer<long long> timer;
+		Object();
+
+		bool reload( bool = false );
+		bool load( const std::string&, bool = false );
+		bool load( const uf::Serializer& );
+
+		uf::Object& loadChild( const uf::Serializer&, bool = true );
+		uf::Object* loadChildPointer( const uf::Serializer&, bool = true );
+		std::size_t loadChildUid( const uf::Serializer&, bool = true );
+
+		uf::Object& loadChild( const std::string&, bool = true );
+		uf::Object* loadChildPointer( const std::string&, bool = true );
+		std::size_t loadChildUid( const std::string&, bool = true );
+		
+		template<typename T>
+		T loadChild( const uf::Serializer&, bool = true );
+		template<typename T>
+		T loadChild( const std::string&, bool = true );
+
+		std::string formatHookName( const std::string& name );
+		static std::string formatHookName( const std::string& name, size_t uid, bool fetch = true );
+	//	void queueHook( const std::string&, const std::string& = "", double = 0 );
+	//	std::vector<std::string> callHook( const std::string&, const std::string& = "" );
+	//	std::size_t addHook( const std::string&, const uf::HookHandler::Readable::function_t& );
+
+		void queueHook( const std::string&, const ext::json::Value& = ext::json::null(), double = 0 );
+	//	std::vector<ext::json::Value> callHook( const std::string&, const ext::json::Value& = ext::json::null() );
+		uf::Hooks::return_t callHook( const std::string& );
+		uf::Hooks::return_t callHook( const std::string&, const ext::json::Value& );
+		uf::Hooks::return_t callHook( const std::string&, const uf::Serializer& );
+		
+		template<typename T> size_t addHook( const std::string& name, T function );
+	//	template<typename T> uf::Hooks::return_t queueHook( const std::string& name, const T& payload, double = 0 );
+		template<typename T> uf::Hooks::return_t callHook( const std::string& name, const T& payload );
+
+		std::string grabURI( const std::string& filename, const std::string& root = "" );
+	};
+}
+
+namespace uf {
+	namespace string {
+		std::string UF_API toString( const uf::Object& object );
+	}
+}
+
+#include "object.inl"
+#include "behavior.h"
\ No newline at end of file
diff --git a/engine/inc/uf/engine/object/object.inl b/engine/inc/uf/engine/object/object.inl
new file mode 100644
index 00000000..d2c080bf
--- /dev/null
+++ b/engine/inc/uf/engine/object/object.inl
@@ -0,0 +1,32 @@
+template<typename T>
+T uf::Object::loadChild( const uf::Serializer& json, bool initialize ) {
+	// T is size_t
+	if ( typeid(T) == typeid(std::size_t) ) return this->loadChildUid(json, initialize);
+	// T is pointer
+	if ( std::is_pointer<T>::value ) return this->loadChildPointer(json, initialize);
+	// T is reference
+	return this->loadChild(json, initialize);
+}
+template<typename T>
+T uf::Object::loadChild( const std::string& filename, bool initialize ) {
+	// T is size_t
+	if ( typeid(T) == typeid(std::size_t) ) return this->loadChildUid(filename, initialize);
+	// T is pointer
+	if ( std::is_pointer<T>::value ) return this->loadChildPointer(filename, initialize);
+	// T is reference
+	return this->loadChild(filename, initialize);
+}
+template<typename T>
+size_t uf::Object::addHook( const std::string& name, T callback ) {
+	std::string parsed = this->formatHookName( name );
+	std::size_t id = uf::hooks.addHook( parsed, callback );
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	metadata["system"]["hooks"]["alloc"][parsed].emplace_back(id);
+	return id;
+}
+template<typename T>
+uf::Hooks::return_t uf::Object::callHook( const std::string& name, const T& p ) {
+	uf::Userdata payload;
+	payload.create<T>(p);
+	return uf::hooks.call( this->formatHookName( name ), payload );
+}
\ No newline at end of file
diff --git a/engine/inc/uf/engine/scene/behavior.h b/engine/inc/uf/engine/scene/behavior.h
new file mode 100644
index 00000000..39b2c346
--- /dev/null
+++ b/engine/inc/uf/engine/scene/behavior.h
@@ -0,0 +1,5 @@
+#pragma once
+
+namespace uf {
+	UF_BEHAVIOR_ENTITY_H(Scene)
+}
\ No newline at end of file
diff --git a/engine/inc/uf/engine/scene/scene.h b/engine/inc/uf/engine/scene/scene.h
new file mode 100644
index 00000000..6433cb58
--- /dev/null
+++ b/engine/inc/uf/engine/scene/scene.h
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <uf/engine/object/object.h>
+
+namespace uf {
+	class UF_API Scene : public uf::Object {
+	public:
+		Scene();
+		uf::Entity& getController();
+		const uf::Entity& getController() const;
+
+		template<typename T> T& getController() {
+			return *((T*) &this->getController());
+		}
+		template<typename T> const T& getController() const {
+			return *((const T*) &this->getController());
+		}
+	};
+
+	namespace scene {
+		extern UF_API std::vector<uf::Scene*> scenes;
+		Scene& UF_API getCurrentScene();
+		Scene& UF_API loadScene( const std::string& name, const std::string& filename = "" );
+		Scene& UF_API loadScene( const std::string& name, const uf::Serializer& );
+		void UF_API unloadScene();
+
+		void UF_API tick();
+		void UF_API render();
+		void UF_API destroy();
+	}
+}
+
+#include "behavior.h"
\ No newline at end of file
diff --git a/engine/inc/uf/ext/bullet/bullet.h b/engine/inc/uf/ext/bullet/bullet.h
new file mode 100644
index 00000000..0b10ff60
--- /dev/null
+++ b/engine/inc/uf/ext/bullet/bullet.h
@@ -0,0 +1,86 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/engine/object/object.h>
+#include <uf/utils/math/transform.h>
+#include <uf/utils/graphic/mesh.h>
+#include <uf/utils/math/collision.h>
+
+#if UF_USE_BULLET
+#include "btBulletDynamicsCommon.h"
+#endif
+namespace pod {
+	struct UF_API Bullet {
+		size_t uid = 0;
+		float mass = 0.0f;
+		pod::Vector3f inertia = {};
+		pod::Transform<>* transform = NULL;
+
+		bool shared = false; // share control of the transform both in-engine and bullet, set to true if you're directly modifying the transform
+	#if UF_USE_BULLET
+		btRigidBody* body = NULL;
+		btCollisionShape* shape = NULL;
+	#else
+		void* body = NULL;
+		void* shape = NULL;
+	#endif
+	};
+}
+#if UF_USE_BULLET
+namespace ext {
+	namespace bullet {
+		extern UF_API bool debugDrawEnabled;
+		extern UF_API float debugDrawRate;
+		extern UF_API size_t iterations;
+		extern UF_API size_t substeps;
+		extern UF_API float timescale;
+		
+		extern UF_API size_t defaultMaxCollisionAlgorithmPoolSize;
+		extern UF_API size_t defaultMaxPersistentManifoldPoolSize;
+
+		void UF_API initialize();
+		void UF_API tick( float = 0 );
+		void UF_API terminate();
+
+		// base collider creation
+		pod::Bullet& create( uf::Object& );
+		void destroy( uf::Object& );
+
+		void UF_API attach( pod::Bullet& );
+		void UF_API detach( pod::Bullet& );
+
+		// collider from mesh
+		template<typename T, typename U>
+		pod::Bullet& create( uf::Object&, const uf::BaseMesh<T, U>& mesh, bool = true, int = 0 );
+		// collider for boundingbox
+		pod::Bullet& UF_API create( uf::Object&, const pod::Vector3f&, float );
+		// collider for capsule
+		pod::Bullet& UF_API create( uf::Object&, float, float, float );
+
+		// synchronize engine transforms to bullet transforms
+		void UF_API syncToBullet();
+		// synchronize bullet transforms to engine transforms
+		void UF_API syncFromBullet();
+		// apply impulse
+		void UF_API applyImpulse( pod::Bullet&, const pod::Vector3f& );
+		// directly move a transform
+		void UF_API applyMovement( pod::Bullet&, const pod::Vector3f& );
+		// directly apply a velocity
+		void UF_API applyVelocity( pod::Bullet&, const pod::Vector3f& );
+		// directly rotate a transform
+		void UF_API applyRotation( pod::Bullet&, const pod::Quaternion<>& );
+		void UF_API applyRotation( pod::Bullet&, const pod::Vector3f&, float );
+
+		// picks an appropriate movement option
+		void UF_API move( pod::Bullet&, const pod::Vector3f&, bool = false );
+
+		// allows noclip
+		void UF_API activateCollision( pod::Bullet&, bool = true );
+
+		// allows showing collision models
+		void UF_API debugDraw( uf::Object& );
+	}
+}
+
+#include "bullet.inl"
+#endif
\ No newline at end of file
diff --git a/engine/inc/uf/ext/bullet/bullet.inl b/engine/inc/uf/ext/bullet/bullet.inl
new file mode 100644
index 00000000..4f482df2
--- /dev/null
+++ b/engine/inc/uf/ext/bullet/bullet.inl
@@ -0,0 +1,98 @@
+#include "BulletCollision/CollisionDispatch/btInternalEdgeUtility.h"
+
+template<typename T, typename U>
+pod::Bullet& ext::bullet::create( uf::Object& object, const uf::BaseMesh<T, U>& mesh, bool applyTransform, int windingOrder ) {
+	auto& collider = ext::bullet::create( object );
+	btTriangleMesh* bMesh = new btTriangleMesh();
+	auto& transform = object.getComponent<pod::Transform<>>();
+	auto model = uf::transform::model( transform );
+/*
+	if ( !mesh.indices.empty() ) {
+		std::cout << "INDEXED VERTICES" << std::endl;
+		for ( size_t i = 0; i < mesh.indices.size() / 3; ++i ) {			
+			size_t A = mesh.indices[i*3]+0;
+			size_t B = mesh.indices[i*3]+1;
+			size_t C = mesh.indices[i*3]+2;
+
+			if ( A >= mesh.vertices.size() ) continue;
+			if ( B >= mesh.vertices.size() ) continue;
+			if ( C >= mesh.vertices.size() ) continue;
+
+			auto a = mesh.vertices[A].position;
+			auto b = mesh.vertices[B].position;
+			auto c = mesh.vertices[C].position;
+			if ( applyTransform ) {
+				a = uf::matrix::multiply<float>( model, a );
+				b = uf::matrix::multiply<float>( model, b );
+				c = uf::matrix::multiply<float>( model, c );
+			}
+
+			if ( windingOrder == -1 ) {
+				bMesh->addTriangle(btVector3(a.x, a.y, a.z), btVector3(b.x, b.y, b.z), btVector3(c.x, c.y, c.z));
+			} else if ( windingOrder == 0 ) {
+				bMesh->addTriangle(btVector3(a.x, a.y, a.z), btVector3(b.x, b.y, b.z), btVector3(c.x, c.y, c.z));
+				bMesh->addTriangle(btVector3(a.x, a.y, a.z), btVector3(c.x, c.y, c.z), btVector3(b.x, b.y, b.z));
+			} else if ( windingOrder == 1 ) {
+				bMesh->addTriangle(btVector3(a.x, a.y, a.z), btVector3(c.x, c.y, c.z), btVector3(b.x, b.y, b.z));
+			} else {
+				std::cout << windingOrder << std::endl;
+			}
+		}
+	} else {
+		std::cout << "NON-INDEX VERTICES" << std::endl;
+		for ( size_t i = 0; i < mesh.vertices.size() / 3; ++i ) {
+			if ( i * 3 + 2 >= mesh.vertices.size() ) break;
+			auto a = mesh.vertices[i*3+0].position;
+			auto b = mesh.vertices[i*3+1].position;
+			auto c = mesh.vertices[i*3+2].position;
+			if ( applyTransform ) {
+				a = uf::matrix::multiply<float>( model, a );
+				b = uf::matrix::multiply<float>( model, b );
+				c = uf::matrix::multiply<float>( model, c );
+			}
+
+			if ( windingOrder == -1 ) {
+				bMesh->addTriangle(btVector3(a.x, a.y, a.z), btVector3(b.x, b.y, b.z), btVector3(c.x, c.y, c.z));
+			} else if ( windingOrder == 0 ) {
+				bMesh->addTriangle(btVector3(a.x, a.y, a.z), btVector3(b.x, b.y, b.z), btVector3(c.x, c.y, c.z));
+				bMesh->addTriangle(btVector3(a.x, a.y, a.z), btVector3(c.x, c.y, c.z), btVector3(b.x, b.y, b.z));
+			} else if ( windingOrder == 1 ) {
+				bMesh->addTriangle(btVector3(a.x, a.y, a.z), btVector3(c.x, c.y, c.z), btVector3(b.x, b.y, b.z));
+			} else {
+				std::cout << windingOrder << std::endl;
+			}
+		}
+	}
+*/
+	auto expanded = mesh;
+	expanded.expand();
+	for ( size_t i = 0; i < expanded.vertices.size() / 3; ++i ) {
+		if ( i * 3 + 2 >= expanded.vertices.size() ) break;
+		auto a = expanded.vertices[i*3+0].position;
+		auto b = expanded.vertices[i*3+1].position;
+		auto c = expanded.vertices[i*3+2].position;
+		if ( applyTransform ) {
+			a = uf::matrix::multiply<float>( model, a );
+			b = uf::matrix::multiply<float>( model, b );
+			c = uf::matrix::multiply<float>( model, c );
+		}
+
+		if ( windingOrder == -1 ) {
+			bMesh->addTriangle(btVector3(a.x, a.y, a.z), btVector3(b.x, b.y, b.z), btVector3(c.x, c.y, c.z));
+		} else if ( windingOrder == 0 ) {
+			bMesh->addTriangle(btVector3(a.x, a.y, a.z), btVector3(b.x, b.y, b.z), btVector3(c.x, c.y, c.z));
+			bMesh->addTriangle(btVector3(a.x, a.y, a.z), btVector3(c.x, c.y, c.z), btVector3(b.x, b.y, b.z));
+		} else if ( windingOrder == 1 ) {
+			bMesh->addTriangle(btVector3(a.x, a.y, a.z), btVector3(c.x, c.y, c.z), btVector3(b.x, b.y, b.z));
+		}
+	}
+	collider.shape = new btBvhTriangleMeshShape(bMesh, true);
+	ext::bullet::attach( collider );
+	{	
+		btTransform t = collider.body->getWorldTransform();
+		t.setFromOpenGLMatrix(&model[0]);
+		collider.body->setWorldTransform(t);
+		collider.body->setCenterOfMassTransform(t);
+	}
+	return collider;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/discord/discord.h b/engine/inc/uf/ext/discord/discord.h
new file mode 100644
index 00000000..ead47a7a
--- /dev/null
+++ b/engine/inc/uf/ext/discord/discord.h
@@ -0,0 +1,10 @@
+#pragma once
+
+#include <uf/config.h>
+
+namespace ext {
+	namespace discord {
+		void UF_API initialize();
+		void UF_API tick();
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/ext.h b/engine/inc/uf/ext/ext.h
new file mode 100644
index 00000000..1254667c
--- /dev/null
+++ b/engine/inc/uf/ext/ext.h
@@ -0,0 +1,52 @@
+#pragma once
+
+#include <uf/config.h>
+#include <vector>
+
+#if !defined(EXT_STATIC)
+	#if defined(UF_ENV_WINDOWS)
+		// Windows compilers need specific (and different) keywords for export and import
+		#define EXT_API_EXPORT __declspec(dllexport)
+		#define EXT_API_IMPORT __declspec(dllimport)
+		// For Visual C++ compilers, we also need to turn off this annoying C4251 warning
+		#ifdef _MSC_VER
+			#pragma warning(disable : 4251)
+		#endif
+	#else // Linux, FreeBSD, Mac OS X
+		#if __GNUC__ >= 4
+			// GCC 4 has special keywords for showing/hidding symbols,
+			// the same keyword is used for both importing and exporting
+			#define EXT_API_EXPORT __attribute__ ((__visibility__ ("default")))
+			#define EXT_API_IMPORT __attribute__ ((__visibility__ ("default")))
+		#else
+			// GCC < 4 has no mechanism to explicitely hide symbols, everything's exported
+			#define EXT_API_EXPORT
+			#define EXT_API_IMPORT
+		#endif
+	#endif
+#else
+	// Static build doesn't need import/export macros
+	#define EXT_API_EXPORT
+	#define EXT_API_IMPORT
+#endif
+
+#ifdef EXT_EXPORTS
+	#define EXT_API EXT_API_EXPORT
+#else
+	#define EXT_API EXT_API_IMPORT
+#endif
+
+#include <string>
+#include <uf/utils/serialize/serializer.h>
+namespace ext {
+	extern bool EXT_API ready;
+	extern std::vector<std::string> EXT_API arguments;
+	extern uf::Serializer EXT_API config;
+	
+	extern void EXT_API load();
+	extern void EXT_API initialize();
+	extern bool EXT_API running();
+	extern void EXT_API tick();
+	extern void EXT_API render();
+	extern void EXT_API terminate();
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/freetype/freetype.h b/engine/inc/uf/ext/freetype/freetype.h
new file mode 100644
index 00000000..cf69c954
--- /dev/null
+++ b/engine/inc/uf/ext/freetype/freetype.h
@@ -0,0 +1,46 @@
+#pragma once
+
+#include <uf/config.h>
+#if UF_USE_FREETYPE
+
+#if UF_ENV_DREAMCAST
+	#include <freetype/freetype2/ft2build.h>
+#else
+	#include <ft2build.h>
+#endif
+#include FT_FREETYPE_H 
+
+#include <uf/utils/string/string.h>
+
+namespace ext {
+	namespace freetype {
+		struct UF_API Library {
+			bool loaded;
+			FT_Library library;
+			Library();
+			~Library();
+		};
+		struct UF_API Glyph {
+			FT_Face face;
+			~Glyph();
+		};
+		extern UF_API ext::freetype::Library library;
+		UF_API bool initialize();
+		UF_API bool initialized();
+		UF_API void terminate();
+		
+		UF_API ext::freetype::Glyph initialize( const std::string& );
+		UF_API bool initialize( ext::freetype::Glyph&, const std::string& );
+		UF_API void destroy( ext::freetype::Glyph& );
+		
+		UF_API void setPixelSizes( ext::freetype::Glyph&, int ); 
+		UF_API void setPixelSizes( ext::freetype::Glyph&, int, int ); 
+		
+		UF_API bool load( ext::freetype::Glyph&, unsigned long );
+		UF_API bool load( ext::freetype::Glyph&, const uf::String& );
+
+		UF_API std::string getError( int );
+	}
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/inc/uf/ext/glfw/glfw.h b/engine/inc/uf/ext/glfw/glfw.h
new file mode 100644
index 00000000..018b2e2c
--- /dev/null
+++ b/engine/inc/uf/ext/glfw/glfw.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <uf/config.h>
+
+#define GLFW_INCLUDE_VULKAN
+#include <GLFW/glfw3.h>
+
+#include <vector>
+#include <string>
+
+namespace ext {
+	namespace glfw {
+		class UF_API Window {
+		protected:
+			size_t m_width;
+			size_t m_height;
+			std::string m_title;
+			GLFWwindow* m_window;
+		public:
+			void initialize( size_t width = 800, size_t height = 600, const std::string& title = "Window" );
+			void createSurface( VkInstance instance, VkSurfaceKHR& surface );
+			void destroy();
+			bool loop();
+			void poll();
+			bool minimized();
+			std::vector<const char*> getExtensions( bool );
+			operator GLFWwindow*();
+		};
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/gltf/gltf.h b/engine/inc/uf/ext/gltf/gltf.h
new file mode 100644
index 00000000..d3caa47d
--- /dev/null
+++ b/engine/inc/uf/ext/gltf/gltf.h
@@ -0,0 +1,12 @@
+#pragma once
+
+#include "mesh.h"
+#include "graph.h"
+#include <uf/engine/object/object.h>
+
+namespace ext {
+	namespace gltf {		
+		pod::Graph UF_API load( const std::string&, ext::gltf::load_mode_t, const uf::Serializer& );
+		void UF_API save( const std::string&, const pod::Graph& );
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/gltf/graph.h b/engine/inc/uf/ext/gltf/graph.h
new file mode 100644
index 00000000..cb3c6773
--- /dev/null
+++ b/engine/inc/uf/ext/gltf/graph.h
@@ -0,0 +1,129 @@
+#pragma once
+
+#include <uf/utils/image/atlas.h>
+#include <uf/engine/object/object.h>
+#include <uf/utils/math/transform.h>
+#include <uf/utils/graphic/mesh.h>
+#include <uf/utils/graphic/graphic.h>
+#include <uf/utils/renderer/renderer.h>
+#include <uf/utils/math/collision.h>
+
+#include "mesh.h"
+#include "pod.h"
+
+#include <queue>
+
+namespace pod {
+	struct UF_API Texture {
+		struct Storage {
+			alignas(4) int32_t index = -1;
+			alignas(4) int32_t sampler = -1;
+			alignas(4) int32_t remap = -1;
+			alignas(4) float blend = 0;
+
+			alignas(16) pod::Vector4f lerp = {0, 0, 1, 1};
+		} storage;
+		std::string name = "";
+		uf::renderer::Texture2D texture;
+	};
+	struct UF_API Node {
+		std::string name = "";
+		int32_t index = -1;
+		int32_t skin = -1;
+		int32_t parent = -1;
+		int32_t mesh = -1;
+		std::vector<int32_t> children;
+		
+		pod::Transform<> transform;
+
+		uf::Object* entity = NULL;
+		uf::Collider collider;
+		int32_t jointBufferIndex = -1;
+		int32_t materialBufferIndex = -1;
+		int32_t textureBufferIndex = -1;
+	};
+	struct UF_API Graph {
+		typedef ext::gltf::skinned_mesh_t Mesh;
+
+	//	Node* node = NULL;
+		pod::Node root;
+		std::vector<pod::Node> nodes;
+
+		uf::Object* entity = NULL;
+		size_t instanceBufferIndex = -1;
+
+		std::string name = "";
+		ext::gltf::load_mode_t mode;
+		uf::Serializer metadata;
+
+		uf::Atlas* atlas = NULL;
+		std::vector<uf::Image> images;
+		std::vector<uf::renderer::Sampler> samplers;
+		std::vector<pod::Texture> textures;
+		std::vector<pod::Material> materials;
+		std::vector<pod::Light> lights;
+		std::vector<pod::DrawCall> drawCalls;
+
+		std::vector<Skin> skins;
+		std::vector<Mesh> meshes;
+		std::unordered_map<std::string, Animation> animations;
+
+		std::queue<std::string> sequence;
+		struct {
+			struct {
+				bool loop = true;
+				float speed = 1;
+				struct {
+					float a = -std::numeric_limits<float>::max();
+					float speed = 1 / 0.125f;
+					std::unordered_map<int32_t, std::pair<pod::Transform<>, pod::Transform<>>> map;
+				} override;
+			} animations;
+		} settings;
+	};
+}
+
+namespace uf {
+	namespace graph {
+	/*
+		pod::Node& UF_API node();
+		pod::Node* UF_API find( const pod::Node& node, int32_t index );
+		pod::Node* UF_API find( pod::Node* node, int32_t index );
+		pod::Node* UF_API find( const pod::Graph& graph, int32_t index );
+
+		pod::Node* UF_API find( const pod::Node& node, const std::string& name );
+		pod::Node* UF_API find( pod::Node* node, const std::string& name );
+		pod::Node* UF_API find( const pod::Graph& graph, const std::string& name );
+
+		pod::Matrix4f UF_API local( const pod::Node& node );
+		pod::Matrix4f UF_API matrix( const pod::Node& node );
+	*/
+		pod::Node* UF_API find( pod::Graph& graph, int32_t index );
+		pod::Node* UF_API find( pod::Graph& graph, const std::string& name );
+
+	//	pod::Matrix4f UF_API local( const pod::Node& node );
+	//	pod::Matrix4f UF_API matrix( pod::Graph&, const pod::Node& node );
+		
+		pod::Matrix4f UF_API local( pod::Graph&, int32_t );
+		pod::Matrix4f UF_API matrix( pod::Graph&, int32_t );
+
+		void UF_API process( uf::Object& entity );
+		void UF_API process( pod::Graph& graph );
+		void UF_API process( pod::Graph& graph, int32_t, uf::Object& parent );
+		void UF_API cleanup( pod::Graph& graph );
+
+		void UF_API override( pod::Graph& );
+		void UF_API animate( pod::Graph&, const std::string&, float = 1, bool = true );
+		void UF_API update( pod::Graph& );
+		void UF_API update( pod::Graph&, float );
+		void UF_API update( pod::Graph&, pod::Node& );
+		
+		void UF_API destroy( pod::Graph& );
+
+		pod::Graph UF_API load( const std::string&, ext::gltf::load_mode_t, const uf::Serializer& );
+		void UF_API save( const std::string&, const pod::Graph& );
+
+		std::string UF_API print( const pod::Graph& graph );
+		uf::Serializer UF_API stats( const pod::Graph& graph );
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/gltf/mesh.h b/engine/inc/uf/ext/gltf/mesh.h
new file mode 100644
index 00000000..ddde25fe
--- /dev/null
+++ b/engine/inc/uf/ext/gltf/mesh.h
@@ -0,0 +1,45 @@
+#pragma once
+
+#include <uf/utils/graphic/mesh.h>
+
+namespace ext {
+	namespace gltf {
+		enum LoadMode {
+			RENDER 					= 0x1 << 0,
+			COLLISION 				= 0x1 << 1,
+			SEPARATE 				= 0x1 << 2,
+			NORMALS 				= 0x1 << 3,
+			LOAD 					= 0x1 << 4,
+			ATLAS 					= 0x1 << 5,
+			SKINNED 				= 0x1 << 6,
+			INVERT 					= 0x1 << 7,
+			TRANSFORM 				= 0x1 << 8,
+		};
+		typedef uint16_t load_mode_t;
+
+		namespace mesh {
+			struct ID {
+				/*alignas(16)*/ pod::Vector3f position;
+				/*alignas(8)*/ pod::Vector2f uv;
+				/*alignas(16)*/ pod::Vector3f normal;
+				/*alignas(16)*/ pod::Vector3f tangent;
+				/*alignas(8)*/ pod::Vector2ui id;
+
+				static UF_API std::vector<uf::renderer::VertexDescriptor> descriptor;
+			};
+			struct Skinned {
+				/*alignas(16)*/ pod::Vector3f position;
+				/*alignas(8)*/ pod::Vector2f uv;
+				/*alignas(16)*/ pod::Vector3f normal;
+				/*alignas(16)*/ pod::Vector3f tangent;
+				/*alignas(8)*/ pod::Vector2ui id;
+				/*alignas(16)*/ pod::Vector4ui joints;
+				/*alignas(16)*/ pod::Vector4f weights;
+
+				static UF_API std::vector<uf::renderer::VertexDescriptor> descriptor;
+			};
+		}
+		typedef uf::BaseMesh<ext::gltf::mesh::Skinned> mesh_t;
+		typedef uf::BaseMesh<ext::gltf::mesh::Skinned> skinned_mesh_t;
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/gltf/pod.h b/engine/inc/uf/ext/gltf/pod.h
new file mode 100644
index 00000000..08af28b9
--- /dev/null
+++ b/engine/inc/uf/ext/gltf/pod.h
@@ -0,0 +1,87 @@
+#pragma once
+
+#include <uf/config.h>
+#include <string>
+#include <uf/utils/math/vector.h>
+#include <uf/utils/math/transform.h>
+
+namespace pod {
+	struct UF_API DrawCall {
+		struct Storage {
+			alignas(4) int32_t materialIndex = -1;
+			alignas(4) uint32_t materials = 0;
+			alignas(4) int32_t textureIndex = -1;
+			alignas(4) uint32_t textures = 0;
+		} storage;
+		std::string name = "";
+		size_t verticesIndex = 0;
+		size_t vertices = 0;
+		size_t indicesIndex = 0;
+		size_t indices = 0;
+	};
+	struct UF_API Light {
+		struct UF_API Storage {
+			alignas(16) pod::Vector4f position;
+			alignas(16) pod::Vector4f color;
+
+			alignas(4) int32_t type = 0;
+			alignas(4) int32_t mapIndex = -1;
+			alignas(4) float depthBias = 0;
+			alignas(4) float padding = 0;
+			
+			alignas(16) pod::Matrix4f view;
+			alignas(16) pod::Matrix4f projection;
+		};
+		std::string name = "";
+		pod::Vector3f color = { 1, 1, 1 };
+		float intensity = 1.0f;
+		float range = 0.0f;
+	};
+	struct UF_API Material {
+		struct Storage {
+			alignas(16) pod::Vector4f colorBase = { 0, 0, 0, 0 };
+			alignas(16) pod::Vector4f colorEmissive = { 0, 0, 0, 0 };
+			
+			alignas(4) float factorMetallic = 0.0f;
+			alignas(4) float factorRoughness = 0.0f;
+			alignas(4) float factorOcclusion = 0.0f;
+			alignas(4) float factorAlphaCutoff = 1.0f;
+
+			alignas(4) int32_t indexAlbedo = -1;
+			alignas(4) int32_t indexNormal = -1;
+			alignas(4) int32_t indexEmissive = -1;
+			alignas(4) int32_t indexOcclusion = -1;
+
+			alignas(4) int32_t indexMetallicRoughness = -1;
+			alignas(4) int32_t modeAlpha = -1;
+			alignas(4) int32_t padding1 = -1;
+			alignas(4) int32_t padding2 = -1;
+		} storage;
+		std::string name = "";
+		std::string alphaMode = "";
+	};
+	struct UF_API Skin {
+		std::string name = "";
+		std::vector<int32_t> joints;
+		std::vector<pod::Matrix4f> inverseBindMatrices;
+	};
+	struct UF_API Animation {
+		struct Sampler {
+			std::string interpolator;
+			std::vector<float> inputs;
+			std::vector<pod::Vector4f> outputs;
+		};
+		struct Channel {
+			std::string path;
+			int32_t node;
+			uint32_t sampler;
+		};
+
+		std::string name = "";
+		std::vector<Sampler> samplers;
+		std::vector<Channel> channels;
+		float start = std::numeric_limits<float>::max();
+		float end = std::numeric_limits<float>::min();
+		float cur = 0;
+	};
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/json/json.h b/engine/inc/uf/ext/json/json.h
new file mode 100644
index 00000000..eeaa9e80
--- /dev/null
+++ b/engine/inc/uf/ext/json/json.h
@@ -0,0 +1,48 @@
+#pragma once
+
+#include <uf/config.h>
+
+#if defined(UF_JSON_USE_NLOHMANN) && UF_JSON_USE_NLOHMANN
+	#include "nlohmann.h"
+#elif defined(UF_JSON_USE_JSONCPP) && UF_JSON_USE_JSONCPP
+	#include "jsoncpp.h"
+#elif defined(UF_JSON_USE_RAPIDJSON) && UF_JSON_USE_RAPIDJSON
+	#include "rapidjson.h"
+#elif defined(UF_JSON_USE_LUA) && UF_JSON_USE_LUA
+	#include "lua.h"
+#else
+	#error "JSON implementation not defined"
+#endif
+
+#if UF_USE_LUA
+	#include <uf/ext/lua/lua.h>
+#endif
+
+namespace ext {
+	namespace json {
+		// cares not about breaking
+		void UF_API forEach( ext::json::Value& json, const std::function<void(ext::json::Value&)>& function );
+		void UF_API forEach( ext::json::Value& json, const std::function<void(size_t, ext::json::Value&)>& function );
+		void UF_API forEach( ext::json::Value& json, const std::function<void(const std::string&, ext::json::Value&)>& function );
+
+		// handles breaks
+		void UF_API forEach( ext::json::Value& json, const std::function<void(ext::json::Value&, bool&)>& function );
+		void UF_API forEach( ext::json::Value& json, const std::function<void(size_t, ext::json::Value&, bool&)>& function );
+		void UF_API forEach( ext::json::Value& json, const std::function<void(const std::string&, ext::json::Value&, bool&)>& function );
+
+		// const
+		void UF_API forEach( const ext::json::Value& json, const std::function<void(const ext::json::Value&)>& function );
+		void UF_API forEach( const ext::json::Value& json, const std::function<void(const ext::json::Value&, bool&)>& function );
+		void UF_API forEach( const ext::json::Value& json, const std::function<void(size_t, const ext::json::Value&)>& function );
+		void UF_API forEach( const ext::json::Value& json, const std::function<void(const std::string&, const ext::json::Value&)>& function );
+		void UF_API forEach( const ext::json::Value& json, const std::function<void(size_t, const ext::json::Value&, bool&)>& function );
+		void UF_API forEach( const ext::json::Value& json, const std::function<void(const std::string&, const ext::json::Value&, bool&)>& function );
+
+		std::string UF_API encode( const ext::json::Value& json, bool pretty = true );
+		std::string UF_API encode( const ext::json::Value& json, size_t precision, bool pretty = true );
+		void UF_API decode( ext::json::Value& json, const std::string& str );
+	#if UF_USE_LUA
+		std::string UF_API encode( const sol::table& table );
+	#endif
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/json/jsoncpp.h b/engine/inc/uf/ext/json/jsoncpp.h
new file mode 100644
index 00000000..1c526b1b
--- /dev/null
+++ b/engine/inc/uf/ext/json/jsoncpp.h
@@ -0,0 +1,54 @@
+#pragma once
+
+#include <uf/config.h>
+
+#include <json/json.h>
+
+namespace ext {
+	namespace json {
+		class UF_API Value;
+		typedef Json::Value base_value;
+		typedef Value Document;
+		
+		class UF_API Value : public base_value {
+		public:
+			Value( Json::ValueType type = Json::objectValue ) : base_value(type) {}
+			Value& operator=( const Value& );
+
+			template<typename... Args> Value& operator[]( Args... args );
+			template<typename... Args> const Value& operator[]( Args... args ) const;
+			template<typename... Args> Value& operator=( Args... args );
+
+			template<typename T>
+			Value& emplace_back( const T& );
+		};
+
+		inline bool isTable( const Value& v ) { return v.isArray() || v.isObject(); }
+		inline bool isObject( const Value& v ) { return v.isObject(); }
+		inline bool isArray( const Value& v ) { return v.isArray(); }
+		inline bool isNull( const Value& v ) { return v.isNull(); }
+
+		inline Value array() { return Value(Json::arrayValue); }
+		inline Value object() { return Value(Json::objectValue); }
+		inline Value null() { return Value(Json::nullValue); }
+		
+		inline std::vector<std::string> keys( const Value& v ) { return v.getMemberNames(); }
+	}
+}
+
+template<typename... Args> ext::json::Value& ext::json::Value::operator[]( Args... args ) {
+	return (ext::json::Value&) ext::json::base_value::operator[](args...);
+}
+template<typename... Args> const ext::json::Value& ext::json::Value::operator[]( Args... args ) const {
+	return (const ext::json::Value&) ext::json::base_value::operator[](args...);
+}
+template<typename... Args> ext::json::Value& ext::json::Value::operator=( Args... args ) {
+	ext::json::base_value::operator=(args...);
+	return *this;
+}
+
+template<typename T>
+ext::json::Value& ext::json::Value::emplace_back( const T& v ) {
+	ext::json::base_value::append( v );
+	return *this;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/json/lua.h b/engine/inc/uf/ext/json/lua.h
new file mode 100644
index 00000000..5117317a
--- /dev/null
+++ b/engine/inc/uf/ext/json/lua.h
@@ -0,0 +1,56 @@
+#pragma once
+
+#include <uf/config.h>
+
+#include <uf/ext/lua/lua.h>
+
+namespace ext {
+	namespace json {
+		class UF_API Value;
+		typedef sol::table base_value;
+		typedef Value Document;
+		
+		class UF_API Value : public base_value {
+		public:
+			Value& operator=( const Value& );
+
+			template<typename... Args> Value& operator[]( Args... args );
+			template<typename... Args> const Value& operator[]( Args... args ) const;
+			template<typename... Args> Value& operator=( Args... args );
+		};
+
+		inline bool isTable( sol::object v ) { return v.is<sol::table>(); }
+		inline bool isObject( sol::object v ) { return v.is<sol::table>(); }
+		inline bool isArray( sol::object v ) { return v.is<sol::table>(); }
+		inline bool isNull( sol::object v ) { return v == sol::lua_nil; }
+		
+		template<typename T> inline bool isTable( T v );
+		template<typename T> inline bool isObject( T v );
+		template<typename T> inline bool isArray( T v );
+		template<typename T> inline bool isNull( T v );
+	}
+}
+
+template<typename... Args> ext::json::Value& ext::json::Value::operator[]( Args... args ) {
+	return (ext::json::Value&) ext::json::base_value::operator[](args...);
+}
+template<typename... Args> const ext::json::Value& ext::json::Value::operator[]( Args... args ) const {
+	return (const ext::json::Value&) ext::json::base_value::operator[](args...);
+}
+template<typename... Args> ext::json::Value& ext::json::Value::operator=( Args... args ) {
+	ext::json::base_value::operator=(args...);
+	return *this;
+}
+
+
+template<typename T>
+inline bool ext::json::isTable( T v ) { return v.get_type() == sol::type::table; }
+
+template<typename T>
+inline bool ext::json::isObject( T v ) { return v.get_type() == sol::type::table; }
+
+template<typename T>
+inline bool ext::json::isArray( T v ) { return v.get_type() == sol::type::table; }
+
+template<typename T>
+inline bool ext::json::isNull( T v ) { return v.get_type() == sol::type::nil; }
\ No newline at end of file
diff --git a/engine/inc/uf/ext/json/nlohmann.h b/engine/inc/uf/ext/json/nlohmann.h
new file mode 100644
index 00000000..624e1f57
--- /dev/null
+++ b/engine/inc/uf/ext/json/nlohmann.h
@@ -0,0 +1,117 @@
+#pragma once
+
+#include <uf/config.h>
+
+#include <nlohmann/json.hpp>
+#include <nlohmann/fifo_map.hpp>
+
+#define UF_JSON_NLOHMANN_ORDERED 1
+
+namespace ext {
+	namespace json {
+		class UF_API Value;
+
+	#if UF_JSON_NLOHMANN_ORDERED
+		template<class K, class V, class dummy_compare, class A>
+		using fifo_map = nlohmann::fifo_map<K, V, nlohmann::fifo_map_compare<K>, A>;
+		typedef nlohmann::basic_json<fifo_map> base_value;
+	#else
+		typedef nlohmann::json base_value;
+	#endif
+
+		typedef Value Document;
+		class UF_API Value : public base_value {
+		public:
+			Value& operator=( const Value& );
+
+			template<typename... Args> Value& operator[]( Args... args );
+			template<typename... Args> const Value& operator[]( Args... args ) const;
+			template<typename... Args> Value& operator=( Args... args );
+
+			template<typename T> inline bool is( bool = false ) const = delete;
+			template<typename T> inline T as() const;
+			template<typename T> inline T as(const T& fallback) const;
+
+			Value& reserve( size_t );
+		};
+
+		inline bool isTable( const Value& v ) { return v.is_array() || v.is_object(); }
+		inline bool isObject( const Value& v ) { return v.is_object(); }
+		inline bool isArray( const Value& v ) { return v.is_array(); }
+		inline bool isNull( const Value& v ) { return v.is_null(); }
+
+		inline Value array() { return Value::array(); }
+		inline Value object() { return Value::object(); }
+		inline Value null() { return Value(); }
+		Value& UF_API reserve( Value& value, size_t size );
+		
+		std::vector<std::string> UF_API keys( const Value& v );
+	}
+}
+/*
+namespace pod {
+	template<typename T, size_t N> struct UF_API Vector;
+	template<typename T, size_t R, size_t C> struct UF_API Matrix;
+	template<typename T> struct UF_API Transform;
+}
+
+template<typename T, size_t N> ext::json::Value& ext::json::Value::operator=( const pod::Vector<T,N>& v ) {
+	ext::json::base_value::operator=( ext::json::encode(v) );
+	return *this;
+}
+template<typename T, size_t R, size_t C = R> ext::json::Value& ext::json::Value::operator=( const pod::Matrix<T,R,C>& m ) {
+	ext::json::base_value::operator=( ext::json::encode(m) );
+	return *this;
+}
+template<typename T> ext::json::Value& ext::json::Value::operator=( const pod::Vector<T,R,C>& t ) {
+	ext::json::base_value::operator=( ext::json::encode(t) );
+	return *this;
+}
+*/
+template<typename... Args> ext::json::Value& ext::json::Value::operator[]( Args... args ) {
+	return (ext::json::Value&) ext::json::base_value::operator[](args...);
+}
+template<typename... Args> const ext::json::Value& ext::json::Value::operator[]( Args... args ) const {
+	return (const ext::json::Value&) ext::json::base_value::operator[](args...);
+}
+template<typename... Args> ext::json::Value& ext::json::Value::operator=( Args... args ) {
+	ext::json::base_value::operator=(args...);
+	return *this;
+}
+
+template<> inline bool ext::json::Value::is<bool>(bool strict) const { return is_boolean(); }
+template<> inline bool ext::json::Value::is<int8_t>(bool strict) const { return strict ? is_number_integer() : is_number(); }
+template<> inline bool ext::json::Value::is<int16_t>(bool strict) const { return strict ? is_number_integer() : is_number(); }
+template<> inline bool ext::json::Value::is<int32_t>(bool strict) const { return strict ? is_number_integer() : is_number(); }
+template<> inline bool ext::json::Value::is<int64_t>(bool strict) const { return strict ? is_number_integer() : is_number(); }
+template<> inline bool ext::json::Value::is<uint8_t>(bool strict) const { return strict ? is_number_unsigned() : is_number(); }
+template<> inline bool ext::json::Value::is<uint16_t>(bool strict) const { return strict ? is_number_unsigned() : is_number(); }
+template<> inline bool ext::json::Value::is<uint32_t>(bool strict) const { return strict ? is_number_unsigned() : is_number(); }
+template<> inline bool ext::json::Value::is<uint64_t>(bool strict) const { return strict ? is_number_unsigned() : is_number(); }
+template<> inline bool ext::json::Value::is<float>(bool strict) const { return strict ? is_number_float() : is_number(); }
+template<> inline bool ext::json::Value::is<double>(bool strict) const { return strict ? is_number_float() : is_number(); }
+template<> inline bool ext::json::Value::is<std::string>(bool strict) const { return is_string(); }
+
+#if UF_ENV_DREAMCAST
+	template<> inline bool ext::json::Value::is<int>(bool strict) const { return strict ? is_number_integer() : is_number(); }
+	template<> inline bool ext::json::Value::is<unsigned int>(bool strict) const { return strict ? is_number_unsigned() : is_number(); }
+#endif
+template<typename T> inline T ext::json::Value::as() const {
+	if ( !is<T>() ) return T();
+	return get<T>();
+}
+template<typename T> inline T ext::json::Value::as( const T& fallback ) const {
+	if ( !is<T>() ) return fallback;
+	return get<T>();
+}
+template<> inline bool ext::json::Value::as<bool>() const {
+	// explicitly a bool
+	if ( is<bool>() ) return get<bool>();
+	// implicit conversion
+	if ( is_null() ) return false; // always return falce
+	if ( is_number() ) return get<int>(); // implicit conversion to bool
+	if ( is_string() ) return get<std::string>() != ""; // true if not empty
+	if ( is_object() ) return !ext::json::keys( *this ).empty(); // true if not empty
+	if ( is_array() ) return size() > 0; // true if not empty
+	return false;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/json/rapidjson.h b/engine/inc/uf/ext/json/rapidjson.h
new file mode 100644
index 00000000..0748de9d
--- /dev/null
+++ b/engine/inc/uf/ext/json/rapidjson.h
@@ -0,0 +1,147 @@
+#pragma once
+
+#include <uf/config.h>
+
+#include <rapidjson/document.h>
+
+namespace ext {
+	namespace json {
+		class UF_API Value;
+		typedef rapidjson::Value base_value;
+		struct UF_API Document;
+	//	typedef rapidjson::Document Document
+		class UF_API Value : public base_value {
+		public:
+			Value& operator=( const Value& );
+
+			template<typename... Args> Value& operator[]( Args... args );
+			template<typename... Args> const Value& operator[]( Args... args ) const;
+
+			inline size_t size() const { return Size(); }
+			
+			inline decltype(auto) begin() { return Begin(); }
+			inline decltype(auto) end() { return End(); }
+
+			template<typename T> inline T get() const = delete;
+			template<typename T> inline Value& operator=( T v ) = delete;
+		};
+
+		inline bool isTable( const Value& v ) { return v.IsArray() || v.IsObject(); }
+		inline bool isObject( const Value& v ) { return v.IsObject(); }
+		inline bool isArray( const Value& v ) { return v.IsArray(); }
+		inline bool isNull( const Value& v ) { return v.IsNull(); }
+
+		inline decltype(auto) array() {
+			return ext::json::base_value(rapidjson::kArrayType).Move();
+		}
+		inline decltype(auto) object() {
+			return ext::json::base_value(rapidjson::kObjectType).Move();
+		}
+		inline Value null() { return Value(); }
+		
+		std::vector<std::string> UF_API keys( const Value& v );
+		static rapidjson::Document::AllocatorType allocator;
+
+		struct Document : public rapidjson::Document {
+		public:
+			Document() : rapidjson::Document(&ext::json::allocator) {}
+
+			template<typename... Args> Value& operator[]( Args... args );
+			template<typename... Args> const Value& operator[]( Args... args ) const;
+		};
+	}
+}
+
+template<typename... Args> ext::json::Value& ext::json::Value::operator[]( Args... args ) {
+	const std::string k(args...); 
+	auto key = rapidjson::StringRef(k.c_str());
+	auto it = ext::json::base_value::FindMember(key);
+	if ( it != ext::json::base_value::MemberEnd() )
+		return (ext::json::Value&) it->value;
+
+	// member doesn't exist, make empty object
+	ext::json::base_value::AddMember(key, ext::json::object(), ext::json::allocator);
+	return this->operator[](args...);
+}
+template<typename... Args> const ext::json::Value& ext::json::Value::operator[]( Args... args ) const {
+	const std::string k(args...); 
+	auto key = rapidjson::StringRef(k.c_str());
+	auto it = ext::json::base_value::FindMember(key);
+	if ( it != ext::json::base_value::MemberEnd() )
+		return (const ext::json::Value&) it->value;
+
+	return ext::json::base_value();
+}
+template<> inline ext::json::Value& ext::json::Value::operator=<std::string>( std::string v ) {
+	ext::json::base_value::SetString( v.c_str(), ext::json::allocator );
+	return *this;
+}
+template<> inline ext::json::Value& ext::json::Value::operator=<bool>( bool v ) {
+	ext::json::base_value::SetBool(v);
+	return *this;
+}
+template<> inline ext::json::Value& ext::json::Value::operator=<int>( int v ) {
+	ext::json::base_value::SetInt(v);
+	return *this;
+}
+template<> inline ext::json::Value& ext::json::Value::operator=<size_t>( size_t v ) {
+	ext::json::base_value::SetUint64(v);
+	return *this;
+}
+template<> inline ext::json::Value& ext::json::Value::operator=<float>( float v ) {
+	ext::json::base_value::SetFloat(v);
+	return *this;
+}
+template<> inline ext::json::Value& ext::json::Value::operator=<double>( double v ) {
+	ext::json::base_value::SetDouble(v);
+	return *this;
+}
+
+template<typename... Args> ext::json::Value& ext::json::Document::operator[]( Args... args ) {
+	const std::string k(args...); 
+	auto key = rapidjson::StringRef(k.c_str());
+	auto it = rapidjson::Document::FindMember(key);
+	if ( it != rapidjson::Document::MemberEnd() )
+		return (ext::json::Value&) it->value;
+
+	// member doesn't exist, make empty object
+	rapidjson::Document::AddMember(key, ext::json::object(), ext::json::allocator);
+	return this->operator[](args...);
+}
+template<typename... Args> const ext::json::Value& ext::json::Document::operator[]( Args... args ) const {
+	const std::string k(args...); 
+	auto key = rapidjson::StringRef(k.c_str());
+	auto it = rapidjson::Document::FindMember(key);
+	if ( it != rapidjson::Document::MemberEnd() )
+		return (const ext::json::Value&) it->value;
+
+	return ext::json::base_value();
+}
+
+template<> inline bool ext::json::Value::is<bool>() const { return IsBool(); }
+template<> inline bool ext::json::Value::is<int>() const { return IsInt64(); }
+template<> inline bool ext::json::Value::is<size_t>() const { return IsUint64(); }
+template<> inline bool ext::json::Value::is<float>() const { return IsDouble(); }
+template<> inline bool ext::json::Value::is<double>() const { return IsDouble(); }
+template<> inline bool ext::json::Value::is<std::string>() const { return IsString(); }
+
+template<> inline bool ext::json::Value::get<bool>() const { return GetBool(); }
+template<> inline int ext::json::Value::get<int>() const { return GetInt(); }
+template<> inline size_t ext::json::Value::get<size_t>() const { return GetUint64(); }
+template<> inline float ext::json::Value::get<float>() const { return GetDouble(); }
+template<> inline double ext::json::Value::get<double>() const { return GetDouble(); }
+template<> inline std::string ext::json::Value::get<std::string>() const { return GetString(); }
+
+template<typename T> inline T ext::json::Value::as() const {
+	if ( !is<T>() ) return T();
+	return get<T>();
+}
+template<> inline bool ext::json::Value::as<bool>() const {
+	if ( is<bool>() ) return get<bool>();
+	if ( IsNull() ) return false;
+	if ( IsNumber() ) return get<int>() != 0;
+	if ( IsString() ) return get<std::string>() != "";
+	if ( IsObject() ) return !ext::json::keys( *this ).empty();
+	if ( IsArray() ) return size() > 0;
+	return false;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/lua/lua.h b/engine/inc/uf/ext/lua/lua.h
new file mode 100644
index 00000000..29694911
--- /dev/null
+++ b/engine/inc/uf/ext/lua/lua.h
@@ -0,0 +1,48 @@
+#pragma once
+
+#include <uf/config.h>
+#if UF_USE_LUA
+	#if UF_USE_LUAJIT
+		#define SOL_LUAJIT 1
+		#define SOL_USING_CXX_LUA_JIT 1
+	#endif
+#define SOL_NO_EXCEPTIONS 1
+#define SOL_ALL_SAFETIES_ON 1
+
+#include <sol/sol.hpp>
+#include <unordered_map>
+#include <uf/utils/singletons/pre_main.h>
+#include <uf/utils/string/ext.h>
+
+namespace pod {
+	struct UF_API LuaScript {
+		std::string file;
+		sol::environment env;
+	};
+}
+
+namespace ext {
+	namespace lua {
+		extern UF_API sol::state state;
+		extern UF_API std::string main;
+		extern UF_API std::unordered_map<std::string, std::string> modules;
+		extern UF_API std::vector<std::function<void()>>* onInitializationFunctions;
+
+		void UF_API initialize();
+		void UF_API terminate();
+		void UF_API onInitialization( const std::function<void()>& );
+		
+		bool UF_API run( const std::string&, bool = true );
+		
+		pod::LuaScript UF_API script( const std::string& );
+		bool UF_API run( const pod::LuaScript&, bool = true );
+
+		sol::table createTable();
+		std::string sanitize( const std::string& dirty, int index = -1 );
+		std::optional<std::string> encode( sol::table table );
+		std::optional<sol::table> decode( const std::string& string );
+	}
+}
+
+#include "lua.inl"
+#endif
\ No newline at end of file
diff --git a/engine/inc/uf/ext/lua/lua.inl b/engine/inc/uf/ext/lua/lua.inl
new file mode 100644
index 00000000..9d218dfb
--- /dev/null
+++ b/engine/inc/uf/ext/lua/lua.inl
@@ -0,0 +1,56 @@
+#define UF_NS_GET_LAST(name) uf::string::replace( uf::string::split( #name, "::" ).back(), "<>", "" )
+
+#define TOKEN__PASTE(x, y) x ## y
+#define TOKEN_PASTE(x, y) TOKEN__PASTE(x, y)
+
+#define UF_LUA_REGISTER_USERTYPE_BEGIN(type) \
+namespace {\
+	static uf::StaticInitialization TOKEN_PASTE(STATIC_INITIALIZATION_, __LINE__)( []{\
+		ext::lua::onInitialization( []{\
+			std::string name = UF_NS_GET_LAST(type);\
+			auto usertype = ext::lua::state.new_usertype<type>(name);
+
+#define UF_LUA_REGISTER_USERTYPE_DEFINE_RT(k, v) usertype[#k] = v;
+#define UF_LUA_REGISTER_USERTYPE_MEMBER_RT(member) usertype[UF_NS_GET_LAST(member)] = &member;
+
+#define UF_LUA_REGISTER_USERTYPE_END() \
+		});\
+	});\
+}
+
+
+#define UF_LUA_REGISTER_USERTYPE(type, ...) \
+namespace {\
+	static uf::StaticInitialization TOKEN_PASTE(STATIC_INITIALIZATION_, __LINE__)( []{\
+		ext::lua::onInitialization( []{\
+			ext::lua::state.new_usertype<type>(UF_NS_GET_LAST(type), __VA_ARGS__);\
+		});\
+	});\
+}
+
+#define UF_LUA_REGISTER_USERTYPE_DEFINE(k, v) #k, v
+#define UF_LUA_REGISTER_USERTYPE_MEMBER(member) UF_NS_GET_LAST(member), &member
+
+
+/*
+#define UF_NS_LUA_REGISTER_USERTYPE_BEGIN(k, v) {\
+	std::string name = #v;\
+	sol::usertype<k::v> usertype = state.new_usertype<k::v>(name);
+
+#define POD_LUA_REGISTER_USERTYPE_BEGIN(x) UF_NS_LUA_REGISTER_USERTYPE_BEGIN(pod, x)
+#define UF_LUA_REGISTER_USERTYPE_BEGIN(x) UF_NS_LUA_REGISTER_USERTYPE_BEGIN(uf, x)
+#define EXT_LUA_REGISTER_USERTYPE_BEGIN(x) UF_NS_LUA_REGISTER_USERTYPE_BEGIN(ext, x)
+
+#define UF_LUA_REGISTER_USERTYPE_DEFINE(k, v) usertype[#k] = v;
+#define POD_LUA_REGISTER_USERTYPE_DEFINE(k, v) UF_LUA_REGISTER_USERTYPE_DEFINE(k, v)
+#define EXT_LUA_REGISTER_USERTYPE_DEFINE(k, v) UF_LUA_REGISTER_USERTYPE_DEFINE(k, v)
+
+#define UF_NS_LUA_REGISTER_USERTYPE_MEMBER(ns, x, y) UF_LUA_REGISTER_USERTYPE_DEFINE(y, &ns::x::y)
+#define POD_LUA_REGISTER_USERTYPE_MEMBER(x, y) UF_NS_LUA_REGISTER_USERTYPE_MEMBER(pod, x, y)
+#define UF_LUA_REGISTER_USERTYPE_MEMBER(x, y) UF_NS_LUA_REGISTER_USERTYPE_MEMBER(uf, x, y)
+#define EXT_LUA_REGISTER_USERTYPE_MEMBER(x, y) UF_NS_LUA_REGISTER_USERTYPE_MEMBER(ext, x, y)
+
+#define UF_LUA_REGISTER_USERTYPE_END() }
+#define POD_LUA_REGISTER_USERTYPE_END() UF_LUA_REGISTER_USERTYPE_END()
+#define EXT_LUA_REGISTER_USERTYPE_END() UF_LUA_REGISTER_USERTYPE_END()
+*/
\ No newline at end of file
diff --git a/engine/inc/uf/ext/meshopt/meshopt.h b/engine/inc/uf/ext/meshopt/meshopt.h
new file mode 100644
index 00000000..a9efe256
--- /dev/null
+++ b/engine/inc/uf/ext/meshopt/meshopt.h
@@ -0,0 +1,10 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/utils/graphic/descriptor.h>
+
+namespace ext {
+	namespace meshopt {
+		void UF_API optimize( uf::BaseGeometry&, size_t = SIZE_MAX );
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/ncurses/ncurses.h b/engine/inc/uf/ext/ncurses/ncurses.h
new file mode 100644
index 00000000..1ee6d16e
--- /dev/null
+++ b/engine/inc/uf/ext/ncurses/ncurses.h
@@ -0,0 +1,54 @@
+#pragma once
+
+#include <uf/config.h>
+
+#include <string>
+
+namespace ext {
+	class UF_API Ncurses {
+	protected:
+		bool m_initialized;
+		bool m_initializeOnCtor = false;
+		void* m_window;
+		int m_timeout;
+	public:
+	// 	C-tor/D-tor
+		UF_API_CALL Ncurses();
+		~Ncurses();
+	// 	On-demand C-tor/D-tor
+		void UF_API_CALL initialize();
+		bool UF_API_CALL initialized();
+		void UF_API_CALL terminate();
+	// 	API (original named)
+		
+		void UF_API_CALL getYX(int& row, int& column);
+		void UF_API_CALL getMaxYX(int& row, int& column);
+		void UF_API_CALL move(int row, int column);
+		void UF_API_CALL move(int toRow, int toColumn, int& row, int& column);
+
+		void UF_API_CALL refresh();
+		void UF_API_CALL clrToEol();
+		void UF_API_CALL clrToBot();
+
+		 int UF_API_CALL getCh();
+		void UF_API_CALL delCh();
+		void UF_API_CALL addCh( char c );
+		void UF_API_CALL addStr(const char* c_str);
+		void UF_API_CALL addStr(const std::string str);
+
+		void UF_API_CALL attrOn(int att);
+		void UF_API_CALL attrOff(int att);
+		bool UF_API_CALL hasColors();
+		bool UF_API_CALL startColor();
+		void UF_API_CALL initPair( short id, short fore, short back );
+
+	// 	API (different named)
+		inline void UF_API_CALL clear(bool toBottom = true) { toBottom ? this->clrToBot() : this->clrToEol(); }
+		inline  int UF_API_CALL getChar() { return this->getCh(); }
+		inline void UF_API_CALL delChar() { this->delCh(); }
+		inline void UF_API_CALL addChar( char c ) { this->addCh( c ); }
+		inline void UF_API_CALL addString( const std::string& str ) { this->addStr( str.c_str() ); }
+		inline void UF_API_CALL attribute(int att, bool on = true) { on ? this->attrOn(att) : this->attrOff(att); }
+	};
+	extern UF_API ext::Ncurses ncurses;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/oal/oal.h b/engine/inc/uf/ext/oal/oal.h
new file mode 100644
index 00000000..28132d51
--- /dev/null
+++ b/engine/inc/uf/ext/oal/oal.h
@@ -0,0 +1,80 @@
+#pragma once
+
+#include <uf/config.h>
+#if UF_USE_OPENAL
+
+#include <AL/al.h>
+#include <AL/alc.h>
+#include <AL/alut.h>
+
+#include <string>
+#include <vector>
+
+#include <uf/utils/math/vector.h>
+
+#define AL_CHECK_ERROR(...) __VA_ARGS__; ext::oal.checkError(__FUNCTION__, __LINE__)
+
+namespace ext {
+	class UF_API AL {
+	protected:
+		bool m_initialized;
+		ALCdevice* m_device;
+		ALCcontext* m_context;
+	public:
+		AL();
+		~AL();
+
+		bool initialize();
+		bool terminate();
+
+		void listener( ALenum, std::vector<ALfloat> );
+		void listener( const std::string, std::vector<ALfloat> );
+
+		void checkError( const std::string& = "", int = 0, const std::string& = "" ) const;
+		std::string getError() const;
+	};
+	namespace al {
+		class UF_API Source {
+		protected:
+			ALuint m_index;
+		public:
+			Source();
+			~Source();
+
+			void generate();
+			void destroy();
+
+			ALuint& getIndex();
+			ALuint getIndex() const;
+			
+			void source( ALenum, std::vector<ALfloat> );
+			void source( const std::string, std::vector<ALfloat> );
+			
+			void source( ALenum, std::vector<ALint> );
+			void source( const std::string, std::vector<ALint> );
+
+			void play();
+			void stop();
+			bool playing();
+		};
+		class UF_API Buffer {
+		protected:
+			ALuint m_index;
+		public:
+			Buffer();
+			~Buffer();
+
+			ALuint& getIndex();
+			ALuint getIndex() const;
+
+			void buffer(ALenum, const ALvoid*, ALsizei, ALsizei);
+
+			void generate();
+			void destroy();
+		};
+	}
+
+	extern UF_API ext::AL oal;
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/inc/uf/ext/opengl/buffer.h b/engine/inc/uf/ext/opengl/buffer.h
new file mode 100644
index 00000000..d9e55396
--- /dev/null
+++ b/engine/inc/uf/ext/opengl/buffer.h
@@ -0,0 +1,87 @@
+#pragma once
+
+#include <vector>
+#include <uf/ext/opengl/ogl.h>
+#include <uf/ext/opengl/enums.h>
+
+#define GL_DEFAULT_STAGE_BUFFERS true
+
+typedef void* GLbuffer;
+
+namespace ext {
+	namespace opengl {
+		struct Device;
+
+		struct UF_API Buffer {
+			Device* device;
+			GLuint buffer = 0;
+			
+			struct Descriptor {
+				GLuint buffer = GL_NULL_HANDLE;
+				GLsizeiptr offset = 0;
+				GLsizeiptr range = GL_WHOLE_SIZE;
+			} descriptor;
+
+			struct CreateInfo {
+				GLenum flags = 0;
+				GLsizeiptr size = 0;
+				GLenum usage = 0;
+			};
+
+			GLsizeiptr size = 0;
+			GLsizeiptr alignment = 0;
+			enums::Buffer::type_t usage = 0;
+
+			GLhandle(VmaAllocation) allocation;
+			struct AllocationInfo {
+				uint32_t memoryType = 0;
+				GLhandle(VkDeviceMemory) deviceMemory = GL_NULL_HANDLE;
+				GLsizeiptr offset = 0;
+				GLsizeiptr size = 0;
+				void* pMappedData = NULL;
+				void* pUserData = NULL;
+			} allocationInfo;
+
+			bool map( GLsizeiptr size = GL_WHOLE_SIZE, GLsizeiptr offset = 0 );
+			void unmap();
+
+			bool bind( GLsizeiptr offset = 0 );
+
+			void setupDescriptor( GLsizeiptr size = GL_WHOLE_SIZE, GLsizeiptr offset = 0 );
+			void copyTo( void* data, GLsizeiptr size );
+			bool flush( GLsizeiptr size = GL_WHOLE_SIZE, GLsizeiptr offset = 0 );
+			bool invalidate( GLsizeiptr size = GL_WHOLE_SIZE, GLsizeiptr offset = 0 );
+			void allocate( const CreateInfo& );
+
+			// RAII
+			~Buffer();
+			void initialize( Device& device );
+			void destroy();
+		};
+		struct UF_API Buffers {
+			std::vector<Buffer> buffers;
+			Device* device;
+
+		//	~Buffers();
+			//
+			void initialize( Device& device );
+			void destroy();
+			//
+			size_t initializeBuffer( void* data, GLsizeiptr length, GLenum usage, bool stage = GL_DEFAULT_STAGE_BUFFERS );
+		/*
+			template<typename T> inline size_t initializeBuffer( T data, GLsizeiptr length, GLenum usage, bool stage = GL_DEFAULT_STAGE_BUFFERS ) {
+				return initializeBuffer( (void*) &data, length, usage, stage );
+			}
+			template<typename T> inline size_t initializeBuffer( T data, GLenum usage, bool stage = GL_DEFAULT_STAGE_BUFFERS ) {
+				return initializeBuffer( (void*) &data, static_cast<GLsizeiptr>(sizeof(T)), usage, stage );
+			}
+		*/
+
+			void updateBuffer( void* data, GLsizeiptr length, size_t index = 0, bool stage = GL_DEFAULT_STAGE_BUFFERS );
+			void updateBuffer( void* data, GLsizeiptr length, Buffer& buffer, bool stage = GL_DEFAULT_STAGE_BUFFERS );
+		//	template<typename T> inline void updateBuffer( T data, GLsizeiptr length, size_t index = 0, bool stage = GL_DEFAULT_STAGE_BUFFERS ) { return updateBuffer( (void*) &data, length, index, stage ); }
+		//	template<typename T> inline void updateBuffer( T data, size_t index = 0, bool stage = GL_DEFAULT_STAGE_BUFFERS ) { return updateBuffer( (void*) &data, static_cast<GLsizeiptr>(sizeof(T)), index, stage ); }
+		//	template<typename T> inline void updateBuffer( T data, GLsizeiptr length, Buffer& buffer, bool stage = GL_DEFAULT_STAGE_BUFFERS ) { return updateBuffer( (void*) &data, length, buffer, stage ); }
+		};
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/opengl/commands.h b/engine/inc/uf/ext/opengl/commands.h
new file mode 100644
index 00000000..3ae2c0bd
--- /dev/null
+++ b/engine/inc/uf/ext/opengl/commands.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include <mutex>
+
+#include <uf/ext/opengl/ogl.h>
+
+#include <uf/ext/opengl/uniform.h>
+#include <uf/ext/opengl/buffer.h>
+#include <uf/ext/opengl/texture.h>
+
+#include <uf/utils/thread/thread.h>
+#include <uf/utils/thread/perthread.h>
+#include <uf/utils/userdata/userdata.h>
+#include <uf/utils/graphic/descriptor.h>
+
+#define UF_COMMAND_BUFFER_POINTERED_USERDATA 1
+
+namespace ext {
+	namespace opengl {
+		struct Device;
+		struct Graphic;
+		
+		struct UF_API CommandBuffer {
+		public:
+			struct UF_API Info {
+				ext::opengl::enums::Command::type_t type = 0;
+				Info* next = NULL;
+			};
+			struct UF_API InfoClear : public Info {
+			//	ext::opengl::enums::Command::type_t type = 0;
+				pod::Vector4f color = {};
+				float depth = 0;
+				uint32_t bits = 0;
+			};
+			struct UF_API InfoViewport : public Info {
+			//	ext::opengl::enums::Command::type_t type = 0;
+				pod::Vector2ui corner = {};
+				pod::Vector2ui size = {};
+			};
+			struct UF_API InfoVariant : public Info {
+			//	ext::opengl::enums::Command::type_t type = 0;
+				typedef std::function<void()> function_t;
+				function_t lambda;
+			};
+			struct UF_API InfoBuffer : public Info {
+			//	ext::opengl::enums::Command::type_t type = 0;
+				ext::opengl::Buffer::Descriptor descriptor = { GL_NULL_HANDLE, 0, 0 };
+				enums::Buffer::type_t usage = 0;
+			};
+			struct UF_API InfoTexture : public Info {
+			//	ext::opengl::enums::Command::type_t type = 0;
+				ext::opengl::Texture::Descriptor descriptor = {};
+			};
+			struct UF_API InfoPipeline : public Info {
+			//	ext::opengl::enums::Command::type_t type = 0;
+				struct Descriptor {
+					GLuint pipeline = GL_NULL_HANDLE;
+					GLuint vertexArray = GL_NULL_HANDLE;
+				} descriptor = { GL_NULL_HANDLE, GL_NULL_HANDLE };
+			};
+			struct UF_API InfoGraphicBuffer : public Info {
+			//	ext::opengl::enums::Command::type_t type = 0;
+				ext::opengl::Graphic* graphic = NULL;
+				size_t bufferIndex = 0;
+			};
+			struct UF_API InfoDraw : public Info {
+			//	ext::opengl::enums::Command::type_t type = 0;
+				size_t length = 0;
+				GraphicDescriptor descriptor = {};
+			};
+			struct UF_API InfoGenerateTexture : public Info {
+			//	ext::opengl::enums::Command::type_t type = 0;
+				Texture::Descriptor descriptor;
+				void* data = NULL;
+				size_t size = 0;
+			};
+
+			#if UF_COMMAND_BUFFER_POINTERED_USERDATA
+				typedef uf::PointeredUserdata userdata_t;
+			#else
+				typedef uf::Userdata userdata_t;
+			#endif
+			typedef std::function<void()> function_t;
+			static size_t preallocate;
+
+			Device* device;
+			size_t state = 0;
+			std::vector<CommandBuffer::userdata_t> infos;
+			std::mutex* mutex;
+			
+			void initialize( Device& device );
+			void destroy();
+
+			void record( const CommandBuffer::Info& );
+			void record( const CommandBuffer::InfoVariant::function_t& );
+			void record( const CommandBuffer& );
+
+			void submit();
+			void flush();
+			void start();
+			void end();
+			size_t size() const;
+		protected:
+			void bindUniform( const Buffer::Descriptor& descriptor );
+			void draw( const InfoDraw&, const Info&, const std::vector<InfoTexture*>& = {} );
+			void drawIndexed( const InfoDraw&, const Info&, const Info&, const std::vector<InfoTexture*>& = {} );
+		};
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/opengl/device.h b/engine/inc/uf/ext/opengl/device.h
new file mode 100644
index 00000000..10ed3bba
--- /dev/null
+++ b/engine/inc/uf/ext/opengl/device.h
@@ -0,0 +1,55 @@
+#pragma once
+
+#include <uf/ext/opengl/ogl.h>
+#include <uf/ext/opengl/buffer.h>
+#include <uf/ext/opengl/commands.h>
+#include <uf/spec/context/context.h>
+#include <uf/utils/window/window.h>
+#include <uf/utils/thread/thread.h>
+#include <uf/utils/thread/perthread.h>
+
+#include <deque>
+
+namespace ext {
+	namespace opengl {
+		struct UF_API Device {
+		public:
+			uf::Window* window;
+			spec::Context::Settings contextSettings;
+			uf::ThreadUnique<spec::Context*> contexts;
+			
+			CommandBuffer commandBuffer;
+			struct HandlePool {
+				static size_t pageSize;
+				typedef GLuint handle_t;
+
+				enums::Command::type_t type;
+				std::deque<handle_t> available;
+				std::vector<handle_t> pool;
+
+				void allocate();
+				void allocate(size_t);
+				void clear();
+
+				bool used(handle_t);
+
+				size_t alloc( handle_t& );
+				void free( handle_t& );
+
+			} textures, buffers;
+
+			void initialize();
+			void destroy();
+
+			GLuint createBuffer( enums::Buffer::type_t usage, GLsizeiptr size, void* data = NULL );
+			void* getBuffer( GLuint );
+			void destroyBuffer( GLuint& );
+
+			size_t createTexture( GLuint& );
+			void destroyTexture( GLuint& );
+
+			spec::Context& activateContext();
+			spec::Context& activateContext(std::thread::id);
+		};
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/opengl/enums.h b/engine/inc/uf/ext/opengl/enums.h
new file mode 100644
index 00000000..bac09855
--- /dev/null
+++ b/engine/inc/uf/ext/opengl/enums.h
@@ -0,0 +1,209 @@
+#pragma once
+
+#include <uf/ext/opengl/ogl.h>
+
+namespace ext {
+	namespace opengl {
+		namespace enums {
+			namespace Compare {
+				typedef GLenum type_t;
+				static const type_t NEVER = GL_NEVER;
+				static const type_t LESS = GL_LESS;
+				static const type_t EQUAL = GL_EQUAL;
+				static const type_t LESS_OR_EQUAL = GL_LEQUAL;
+				static const type_t GREATER = GL_GREATER;
+				static const type_t NOT_EQUAL = GL_NOTEQUAL;
+				static const type_t GREATER_OR_EQUAL = GL_GEQUAL;
+				static const type_t ALWAYS = GL_ALWAYS;
+			}
+			namespace Format {
+				typedef GLenum type_t;
+				#include "enums/format.inl"
+			}
+			namespace Face {
+				typedef GLenum type_t;
+				static const type_t CW = GL_CW;
+				static const type_t CCW = GL_CCW;
+			}
+			namespace Layout {
+				typedef GLenum type_t;
+				static const type_t UNDEFINED = 0;
+				static const type_t GENERAL = 1;
+				static const type_t COLOR_ATTACHMENT_OPTIMAL = 2;
+				static const type_t DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3;
+				static const type_t DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4;
+				static const type_t SHADER_READ_ONLY_OPTIMAL = 5;
+				static const type_t TRANSFER_SRC_OPTIMAL = 6;
+				static const type_t TRANSFER_DST_OPTIMAL = 7;
+				static const type_t PREINITIALIZED = 8;
+			}
+			namespace Image {
+				typedef GLenum type_t;
+				typedef GLenum viewType_t;
+			#if UF_ENV_DREAMCAST
+				static const type_t TYPE_1D = 100;
+				static const type_t TYPE_2D = GL_TEXTURE_2D;
+				static const type_t TYPE_3D = 110;
+
+				static const viewType_t VIEW_TYPE_1D = 120;
+				static const viewType_t VIEW_TYPE_2D = GL_TEXTURE_2D;
+				static const viewType_t VIEW_TYPE_3D = 130;
+				static const viewType_t VIEW_TYPE_CUBE = 140;
+				static const viewType_t VIEW_TYPE_1D_ARRAY = 150;
+				static const viewType_t VIEW_TYPE_2D_ARRAY = 160;
+				static const viewType_t VIEW_TYPE_CUBE_ARRAY = 170;
+			#else
+				static const type_t TYPE_1D = GL_TEXTURE_1D;
+				static const type_t TYPE_2D = GL_TEXTURE_2D;
+				static const type_t TYPE_3D = GL_TEXTURE_3D;
+
+				static const viewType_t VIEW_TYPE_1D = GL_TEXTURE_1D;
+				static const viewType_t VIEW_TYPE_2D = GL_TEXTURE_2D;
+				static const viewType_t VIEW_TYPE_3D = GL_TEXTURE_3D;
+				static const viewType_t VIEW_TYPE_CUBE = GL_TEXTURE_CUBE_MAP;
+				static const viewType_t VIEW_TYPE_1D_ARRAY = GL_TEXTURE_1D_ARRAY;
+				static const viewType_t VIEW_TYPE_2D_ARRAY = GL_TEXTURE_2D_ARRAY;
+				static const viewType_t VIEW_TYPE_CUBE_ARRAY = GL_TEXTURE_CUBE_MAP_ARRAY;
+			#endif
+			}
+			namespace CullMode {
+				typedef GLenum type_t;
+				static const type_t NONE = 0;
+				static const type_t FRONT = GL_FRONT;
+				static const type_t BACK = GL_BACK;
+				static const type_t BOTH = GL_FRONT_AND_BACK;
+			}
+			namespace Shader {
+				typedef GLenum type_t;
+			#if UF_ENV_DREAMCAST
+				static const type_t VERTEX = 0x00000001;
+				static const type_t TESSELLATION_CONTROL = 0x00000002;
+				static const type_t TESSELLATION_EVALUATION = 0x00000003;
+				static const type_t GEOMETRY = 0x00000004;
+				static const type_t FRAGMENT = 0x00000005;
+				static const type_t COMPUTE = 0x00000006;
+				static const type_t ALL_GRAPHICS = 0x00000007;
+				static const type_t ALL = 0x00000008;
+			#else
+				static const type_t VERTEX = GL_VERTEX_SHADER;
+				static const type_t TESSELLATION_CONTROL = GL_TESS_CONTROL_SHADER;
+				static const type_t TESSELLATION_EVALUATION = GL_TESS_EVALUATION_SHADER;
+				static const type_t GEOMETRY = GL_GEOMETRY_SHADER;
+				static const type_t FRAGMENT = GL_FRAGMENT_SHADER;
+				static const type_t COMPUTE = GL_COMPUTE_SHADER;
+				static const type_t ALL_GRAPHICS = GLenumerator(VK_SHADER_STAGE_ALL_GRAPHICS);
+				static const type_t ALL = GLenumerator(VK_SHADER_STAGE_ALL);
+			#endif
+			}
+			namespace PrimitiveTopology {
+				typedef GLenum type_t;
+				static const type_t POINT_LIST = GLenumerator(VK_PRIMITIVE_TOPOLOGY_POINT_LIST);
+				static const type_t LINE_LIST = GLenumerator(VK_PRIMITIVE_TOPOLOGY_LINE_LIST);
+				static const type_t LINE_STRIP = GLenumerator(VK_PRIMITIVE_TOPOLOGY_LINE_STRIP);
+				static const type_t TRIANGLE_LIST = GLenumerator(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST);
+				static const type_t TRIANGLE_STRIP = GLenumerator(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP);
+				static const type_t TRIANGLE_FAN = GLenumerator(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN);
+				static const type_t LINE_LIST_WITH_ADJACENCY = GLenumerator(VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY);
+				static const type_t LINE_STRIP_WITH_ADJACENCY = GLenumerator(VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY);
+				static const type_t TRIANGLE_LIST_WITH_ADJACENCY = GLenumerator(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY);
+				static const type_t TRIANGLE_STRIP_WITH_ADJACENCY = GLenumerator(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY);
+				static const type_t PATCH_LIST = GLenumerator(VK_PRIMITIVE_TOPOLOGY_PATCH_LIST);
+			}
+			namespace PolygonMode {
+				typedef GLenum type_t;
+				static const type_t FILL = GLenumerator(VK_POLYGON_MODE_FILL);
+				static const type_t LINE = GLenumerator(VK_POLYGON_MODE_LINE);
+				static const type_t POINT = GLenumerator(VK_POLYGON_MODE_POINT);
+			}
+			namespace AddressMode {
+				typedef GLenum type_t;
+				static const type_t CLAMP_TO_EDGE = GLenumerator(VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE);
+				static const type_t CLAMP_TO_BORDER = GLenumerator(VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER);
+				static const type_t MIRRORED_REPEAT = GLenumerator(VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT);
+				static const type_t REPEAT = GLenumerator(VK_SAMPLER_ADDRESS_MODE_REPEAT);
+			}
+			namespace Filter {
+				typedef GLenum type_t;
+				static const type_t NEAREST = GL_NEAREST;
+				static const type_t LINEAR = GL_LINEAR;
+			}
+			namespace Type {
+				typedef GLenum type_t;
+			#if UF_ENV_DREAMCAST
+				static const type_t BYTE = GL_BYTE;
+				static const type_t UBYTE = GL_UNSIGNED_BYTE;
+
+				static const type_t SHORT = GL_SHORT;
+				static const type_t USHORT = GL_UNSIGNED_SHORT;
+				
+				static const type_t INT = GL_INT;
+				static const type_t UINT = GL_UNSIGNED_INT;
+
+				static const type_t HALF = GL_FLOAT;
+				static const type_t FLOAT = GL_FLOAT;
+				static const type_t DOUBLE = GL_DOUBLE;
+				static const type_t FIXED = 0;
+			#else
+				static const type_t BYTE = GL_BYTE;
+				static const type_t UBYTE = GL_UNSIGNED_BYTE;
+
+				static const type_t SHORT = GL_SHORT;
+				static const type_t USHORT = GL_UNSIGNED_SHORT;
+				
+				static const type_t INT = GL_INT;
+				static const type_t UINT = GL_UNSIGNED_INT;
+
+				static const type_t HALF = GL_HALF_FLOAT;
+				static const type_t FLOAT = GL_FLOAT;
+				static const type_t DOUBLE = GL_DOUBLE;
+				static const type_t FIXED = GL_FIXED;
+			#endif
+			}
+			namespace Buffer {
+				typedef GLenum type_t;
+				static const type_t TRANSFER_SRC 	= 0b0000000000000001; //0x00000001;
+				static const type_t TRANSFER_DST 	= 0b0000000000000010; //0x00000002;
+				static const type_t UNIFORM_TEXEL 	= 0b0000000000000100; //0x00000004;
+				static const type_t STORAGE_TEXEL 	= 0b0000000000001000; //0x00000008;
+				static const type_t UNIFORM 		= 0b0000000000010000; //0x00000010;
+				static const type_t STORAGE 		= 0b0000000000100000; //0x00000020;
+				static const type_t INDEX 			= 0b0000000001000000; //0x00000040;
+				static const type_t VERTEX 			= 0b0000000010000000; //0x00000080;
+				static const type_t INDIRECT 		= 0b0000000100000000; //0x00000100;
+				
+				static const type_t STREAM 			= 0b0000001000000000; //
+				static const type_t STATIC 			= 0b0000010000000000; //
+				static const type_t DYNAMIC 		= 0b0000100000000000; //
+				static const type_t DRAW 			= 0b0001000000000000; //
+				static const type_t READ 			= 0b0010000000000000; //
+				static const type_t COPY 			= 0b0100000000000000; //
+			}
+			namespace Command {
+				typedef size_t type_t;
+				static const type_t CLEAR 					= 1;
+				static const type_t VIEWPORT 				= 2;
+				static const type_t VARIANT 				= 3;
+				static const type_t BIND_BUFFER 			= 4;
+				static const type_t BIND_GRAPHIC_BUFFER 	= 5;
+				static const type_t BIND_TEXTURE 			= 6;
+				static const type_t BIND_PIPELINE 			= 7;
+				static const type_t DRAW 					= 8;
+				
+				static const type_t GENERATE_TEXTURE 		= 9;
+				static const type_t GENERATE_BUFFER 		= 10;
+			}
+		}
+		template<typename T>
+		ext::opengl::enums::Type::type_t typeToEnum() {
+			if ( typeid(T) == typeid(int8_t) ) return ext::opengl::enums::Type::BYTE;
+			if ( typeid(T) == typeid(uint8_t) ) return ext::opengl::enums::Type::UBYTE;
+			if ( typeid(T) == typeid(int16_t) ) return ext::opengl::enums::Type::SHORT;
+			if ( typeid(T) == typeid(uint16_t) ) return ext::opengl::enums::Type::USHORT;
+			if ( typeid(T) == typeid(int32_t) ) return ext::opengl::enums::Type::INT;
+			if ( typeid(T) == typeid(uint32_t) ) return ext::opengl::enums::Type::UINT;
+			if ( typeid(T) == typeid(float) ) return ext::opengl::enums::Type::FLOAT;
+			if ( typeid(T) == typeid(double) ) return ext::opengl::enums::Type::DOUBLE;
+			return 0;
+		}
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/opengl/enums/format.inl b/engine/inc/uf/ext/opengl/enums/format.inl
new file mode 100644
index 00000000..9e6d09b9
--- /dev/null
+++ b/engine/inc/uf/ext/opengl/enums/format.inl
@@ -0,0 +1,185 @@
+static const type_t UNDEFINED = 0;
+static const type_t R4G4_UNORM_PACK8 = 1;
+static const type_t R4G4B4A4_UNORM_PACK16 = 2;
+static const type_t B4G4R4A4_UNORM_PACK16 = 3;
+static const type_t R5G6B5_UNORM_PACK16 = 4;
+static const type_t B5G6R5_UNORM_PACK16 = 5;
+static const type_t R5G5B5A1_UNORM_PACK16 = 6;
+static const type_t B5G5R5A1_UNORM_PACK16 = 7;
+static const type_t A1R5G5B5_UNORM_PACK16 = 8;
+static const type_t R8_UNORM = 9;
+static const type_t R8_SNORM = 10;
+static const type_t R8_USCALED = 11;
+static const type_t R8_SSCALED = 12;
+static const type_t R8_UINT = 13;
+static const type_t R8_SINT = 14;
+static const type_t R8_SRGB = 15;
+static const type_t R8G8_UNORM = 16;
+static const type_t R8G8_SNORM = 17;
+static const type_t R8G8_USCALED = 18;
+static const type_t R8G8_SSCALED = 19;
+static const type_t R8G8_UINT = 20;
+static const type_t R8G8_SINT = 21;
+static const type_t R8G8_SRGB = 22;
+static const type_t R8G8B8_UNORM = 23;
+static const type_t R8G8B8_SNORM = 24;
+static const type_t R8G8B8_USCALED = 25;
+static const type_t R8G8B8_SSCALED = 26;
+static const type_t R8G8B8_UINT = 27;
+static const type_t R8G8B8_SINT = 28;
+static const type_t R8G8B8_SRGB = 29;
+static const type_t B8G8R8_UNORM = 30;
+static const type_t B8G8R8_SNORM = 31;
+static const type_t B8G8R8_USCALED = 32;
+static const type_t B8G8R8_SSCALED = 33;
+static const type_t B8G8R8_UINT = 34;
+static const type_t B8G8R8_SINT = 35;
+static const type_t B8G8R8_SRGB = 36;
+static const type_t R8G8B8A8_UNORM = 37;
+static const type_t R8G8B8A8_SNORM = 38;
+static const type_t R8G8B8A8_USCALED = 39;
+static const type_t R8G8B8A8_SSCALED = 40;
+static const type_t R8G8B8A8_UINT = 41;
+static const type_t R8G8B8A8_SINT = 42;
+static const type_t R8G8B8A8_SRGB = 43;
+static const type_t B8G8R8A8_UNORM = 44;
+static const type_t B8G8R8A8_SNORM = 45;
+static const type_t B8G8R8A8_USCALED = 46;
+static const type_t B8G8R8A8_SSCALED = 47;
+static const type_t B8G8R8A8_UINT = 48;
+static const type_t B8G8R8A8_SINT = 49;
+static const type_t B8G8R8A8_SRGB = 50;
+static const type_t A8B8G8R8_UNORM_PACK32 = 51;
+static const type_t A8B8G8R8_SNORM_PACK32 = 52;
+static const type_t A8B8G8R8_USCALED_PACK32 = 53;
+static const type_t A8B8G8R8_SSCALED_PACK32 = 54;
+static const type_t A8B8G8R8_UINT_PACK32 = 55;
+static const type_t A8B8G8R8_SINT_PACK32 = 56;
+static const type_t A8B8G8R8_SRGB_PACK32 = 57;
+static const type_t A2R10G10B10_UNORM_PACK32 = 58;
+static const type_t A2R10G10B10_SNORM_PACK32 = 59;
+static const type_t A2R10G10B10_USCALED_PACK32 = 60;
+static const type_t A2R10G10B10_SSCALED_PACK32 = 61;
+static const type_t A2R10G10B10_UINT_PACK32 = 62;
+static const type_t A2R10G10B10_SINT_PACK32 = 63;
+static const type_t A2B10G10R10_UNORM_PACK32 = 64;
+static const type_t A2B10G10R10_SNORM_PACK32 = 65;
+static const type_t A2B10G10R10_USCALED_PACK32 = 66;
+static const type_t A2B10G10R10_SSCALED_PACK32 = 67;
+static const type_t A2B10G10R10_UINT_PACK32 = 68;
+static const type_t A2B10G10R10_SINT_PACK32 = 69;
+static const type_t R16_UNORM = 70;
+static const type_t R16_SNORM = 71;
+static const type_t R16_USCALED = 72;
+static const type_t R16_SSCALED = 73;
+static const type_t R16_UINT = 74;
+static const type_t R16_SINT = 75;
+static const type_t R16_SFLOAT = 76;
+static const type_t R16G16_UNORM = 77;
+static const type_t R16G16_SNORM = 78;
+static const type_t R16G16_USCALED = 79;
+static const type_t R16G16_SSCALED = 80;
+static const type_t R16G16_UINT = 81;
+static const type_t R16G16_SINT = 82;
+static const type_t R16G16_SFLOAT = 83;
+static const type_t R16G16B16_UNORM = 84;
+static const type_t R16G16B16_SNORM = 85;
+static const type_t R16G16B16_USCALED = 86;
+static const type_t R16G16B16_SSCALED = 87;
+static const type_t R16G16B16_UINT = 88;
+static const type_t R16G16B16_SINT = 89;
+static const type_t R16G16B16_SFLOAT = 90;
+static const type_t R16G16B16A16_UNORM = 91;
+static const type_t R16G16B16A16_SNORM = 92;
+static const type_t R16G16B16A16_USCALED = 93;
+static const type_t R16G16B16A16_SSCALED = 94;
+static const type_t R16G16B16A16_UINT = 95;
+static const type_t R16G16B16A16_SINT = 96;
+static const type_t R16G16B16A16_SFLOAT = 97;
+static const type_t R32_UINT = 98;
+static const type_t R32_SINT = 99;
+static const type_t R32_SFLOAT = 100;
+static const type_t R32G32_UINT = 101;
+static const type_t R32G32_SINT = 102;
+static const type_t R32G32_SFLOAT = 103;
+static const type_t R32G32B32_UINT = 104;
+static const type_t R32G32B32_SINT = 105;
+static const type_t R32G32B32_SFLOAT = 106;
+static const type_t R32G32B32A32_UINT = 107;
+static const type_t R32G32B32A32_SINT = 108;
+static const type_t R32G32B32A32_SFLOAT = 109;
+static const type_t R64_UINT = 110;
+static const type_t R64_SINT = 111;
+static const type_t R64_SFLOAT = 112;
+static const type_t R64G64_UINT = 113;
+static const type_t R64G64_SINT = 114;
+static const type_t R64G64_SFLOAT = 115;
+static const type_t R64G64B64_UINT = 116;
+static const type_t R64G64B64_SINT = 117;
+static const type_t R64G64B64_SFLOAT = 118;
+static const type_t R64G64B64A64_UINT = 119;
+static const type_t R64G64B64A64_SINT = 120;
+static const type_t R64G64B64A64_SFLOAT = 121;
+static const type_t B10G11R11_UFLOAT_PACK32 = 122;
+static const type_t E5B9G9R9_UFLOAT_PACK32 = 123;
+static const type_t D16_UNORM = 124;
+static const type_t X8_D24_UNORM_PACK32 = 125;
+static const type_t D32_SFLOAT = 126;
+static const type_t S8_UINT = 127;
+static const type_t D16_UNORM_S8_UINT = 128;
+static const type_t D24_UNORM_S8_UINT = 129;
+static const type_t D32_SFLOAT_S8_UINT = 130;
+static const type_t BC1_RGB_UNORM_BLOCK = 131;
+static const type_t BC1_RGB_SRGB_BLOCK = 132;
+static const type_t BC1_RGBA_UNORM_BLOCK = 133;
+static const type_t BC1_RGBA_SRGB_BLOCK = 134;
+static const type_t BC2_UNORM_BLOCK = 135;
+static const type_t BC2_SRGB_BLOCK = 136;
+static const type_t BC3_UNORM_BLOCK = 137;
+static const type_t BC3_SRGB_BLOCK = 138;
+static const type_t BC4_UNORM_BLOCK = 139;
+static const type_t BC4_SNORM_BLOCK = 140;
+static const type_t BC5_UNORM_BLOCK = 141;
+static const type_t BC5_SNORM_BLOCK = 142;
+static const type_t BC6H_UFLOAT_BLOCK = 143;
+static const type_t BC6H_SFLOAT_BLOCK = 144;
+static const type_t BC7_UNORM_BLOCK = 145;
+static const type_t BC7_SRGB_BLOCK = 146;
+static const type_t ETC2_R8G8B8_UNORM_BLOCK = 147;
+static const type_t ETC2_R8G8B8_SRGB_BLOCK = 148;
+static const type_t ETC2_R8G8B8A1_UNORM_BLOCK = 149;
+static const type_t ETC2_R8G8B8A1_SRGB_BLOCK = 150;
+static const type_t ETC2_R8G8B8A8_UNORM_BLOCK = 151;
+static const type_t ETC2_R8G8B8A8_SRGB_BLOCK = 152;
+static const type_t EAC_R11_UNORM_BLOCK = 153;
+static const type_t EAC_R11_SNORM_BLOCK = 154;
+static const type_t EAC_R11G11_UNORM_BLOCK = 155;
+static const type_t EAC_R11G11_SNORM_BLOCK = 156;
+static const type_t ASTC_4x4_UNORM_BLOCK = 157;
+static const type_t ASTC_4x4_SRGB_BLOCK = 158;
+static const type_t ASTC_5x4_UNORM_BLOCK = 159;
+static const type_t ASTC_5x4_SRGB_BLOCK = 160;
+static const type_t ASTC_5x5_UNORM_BLOCK = 161;
+static const type_t ASTC_5x5_SRGB_BLOCK = 162;
+static const type_t ASTC_6x5_UNORM_BLOCK = 163;
+static const type_t ASTC_6x5_SRGB_BLOCK = 164;
+static const type_t ASTC_6x6_UNORM_BLOCK = 165;
+static const type_t ASTC_6x6_SRGB_BLOCK = 166;
+static const type_t ASTC_8x5_UNORM_BLOCK = 167;
+static const type_t ASTC_8x5_SRGB_BLOCK = 168;
+static const type_t ASTC_8x6_UNORM_BLOCK = 169;
+static const type_t ASTC_8x6_SRGB_BLOCK = 170;
+static const type_t ASTC_8x8_UNORM_BLOCK = 171;
+static const type_t ASTC_8x8_SRGB_BLOCK = 172;
+static const type_t ASTC_10x5_UNORM_BLOCK = 173;
+static const type_t ASTC_10x5_SRGB_BLOCK = 174;
+static const type_t ASTC_10x6_UNORM_BLOCK = 175;
+static const type_t ASTC_10x6_SRGB_BLOCK = 176;
+static const type_t ASTC_10x8_UNORM_BLOCK = 177;
+static const type_t ASTC_10x8_SRGB_BLOCK = 178;
+static const type_t ASTC_10x10_UNORM_BLOCK = 179;
+static const type_t ASTC_10x10_SRGB_BLOCK = 180;
+static const type_t ASTC_12x10_UNORM_BLOCK = 181;
+static const type_t ASTC_12x10_SRGB_BLOCK = 182;
+static const type_t ASTC_12x12_UNORM_BLOCK = 183;
+static const type_t ASTC_12x12_SRGB_BLOCK = 184;
\ No newline at end of file
diff --git a/engine/inc/uf/ext/opengl/graphic.h b/engine/inc/uf/ext/opengl/graphic.h
new file mode 100644
index 00000000..f1ab2e65
--- /dev/null
+++ b/engine/inc/uf/ext/opengl/graphic.h
@@ -0,0 +1,155 @@
+#pragma once
+
+#include <uf/ext/opengl/device.h>
+#include <uf/ext/opengl/swapchain.h>
+#include <uf/ext/opengl/initializers.h>
+#include <uf/ext/opengl/texture.h>
+#include <uf/utils/graphic/mesh.h>
+#include <uf/utils/graphic/descriptor.h>
+
+#define UF_GRAPHIC_POINTERED_USERDATA 1
+
+namespace ext {
+	namespace opengl {
+		#if UF_GRAPHIC_POINTERED_USERDATA
+			typedef uf::PointeredUserdata userdata_t;
+		#else
+			typedef uf::Userdata userdata_t;
+		#endif
+
+		ext::json::Value definitionToJson(/*const*/ ext::json::Value& definition );
+		ext::opengl::userdata_t jsonToUserdata( const ext::json::Value& payload, const ext::json::Value& definition );
+
+		struct Graphic;
+		struct CommandBuffer;
+
+		struct UF_API Shader : public Buffers {
+			bool aliased = false;
+
+			Device* device = NULL;
+			std::string filename = "";
+
+		#if !UF_USE_OPENGL_FIXED_FUNCTION
+			GLuint module = GL_NULL_HANDLE;
+		#else
+			typedef std::function<void(const Shader&, const Graphic&, void*)> module_t;
+			module_t module;
+		#endif
+			struct Descriptor {
+				GLuint module;
+				enums::Shader::type_t stage;
+			} descriptor;
+
+			uf::Serializer metadata;
+
+			ext::opengl::userdata_t specializationConstants;
+			std::vector<ext::opengl::userdata_t> pushConstants;
+			std::vector<ext::opengl::userdata_t> uniforms;
+		//	~Shader();
+			void initialize( Device& device, const std::string&, enums::Shader::type_t stage );
+			void destroy();
+			bool validate();
+
+			bool hasUniform( const std::string& name );
+
+			Buffer* getUniformBuffer( const std::string& name );
+			ext::opengl::userdata_t& getUniform( const std::string& name );
+			uf::Serializer getUniformJson( const std::string& name, bool cache = true );
+			ext::opengl::userdata_t getUniformUserdata( const std::string& name, const ext::json::Value& payload );
+			bool updateUniform( const std::string& name );
+			bool updateUniform( const std::string& name, const ext::opengl::userdata_t& );
+			bool updateUniform( const std::string& name, const ext::json::Value& payload );
+			
+			bool hasStorage( const std::string& name );
+			Buffer* getStorageBuffer( const std::string& name );
+			uf::Serializer getStorageJson( const std::string& name, bool cache = true );
+			ext::opengl::userdata_t getStorageUserdata( const std::string& name, const ext::json::Value& payload );
+
+		#if UF_USE_OPENGL_FIXED_FUNCTION
+			static void bind( const std::string& name, const module_t& module );
+			void execute( const Graphic& graphic, void* = NULL );
+		#endif
+		};
+		struct UF_API Pipeline {
+			bool aliased = false;
+
+			Device* device = NULL;
+		#if !UF_USE_OPENGL_FIXED_FUNCTION
+			GLuint pipeline;
+			GLuint vertexArray;
+			std::vector<Buffer::Descriptor> descriptorSet;
+		#endif
+			struct Descriptor {
+				GLuint pipeline;
+				GLuint vertexArray;
+			} descriptor;
+
+			void initialize( Graphic& graphic );
+			void initialize( Graphic& graphic, GraphicDescriptor& descriptor );
+			void update( Graphic& graphic );
+			void update( Graphic& graphic, GraphicDescriptor& descriptor );
+			void record( Graphic& graphic, CommandBuffer&, size_t = 0, size_t = 0 );
+			void destroy();
+		};
+		struct UF_API Material {
+			bool aliased = false;
+			Device* device;
+
+			std::vector<Sampler> samplers;
+			std::vector<Texture> textures;
+			std::vector<Shader> shaders;
+			uf::Serializer metadata;
+
+			void initialize( Device& device );
+			void destroy();
+
+			void attachShader( const std::string&, enums::Shader::type_t );
+			void initializeShaders( const std::vector<std::pair<std::string, enums::Shader::type_t>>& );
+
+			bool hasShader( const std::string& type );
+			Shader& getShader( const std::string& type );
+
+			bool validate();
+		};
+		struct UF_API Graphic : public Buffers {
+			GraphicDescriptor descriptor;
+
+			bool initialized = false;
+			bool process = true;
+			Material material;
+			std::unordered_map<std::string, Pipeline> pipelines;
+
+			~Graphic();
+			void initialize( const std::string& = "" );
+			void destroy();
+			
+			template<typename T, typename U>
+			void initializeMesh( uf::BaseMesh<T, U>& mesh, size_t = SIZE_MAX );
+			void initializeGeometry( const uf::BaseGeometry& mesh );
+
+			bool hasPipeline( GraphicDescriptor& descriptor );
+			void initializePipeline();
+			Pipeline& initializePipeline( GraphicDescriptor& descriptor, bool update = true );
+			Pipeline& getPipeline();
+			Pipeline& getPipeline( GraphicDescriptor& descriptor );
+			void updatePipelines();
+			
+			void record( CommandBuffer& commandBuffer, size_t pass = 0, size_t draw = 0 );
+			void record( CommandBuffer& commandBuffer, GraphicDescriptor& descriptor, size_t pass = 0, size_t draw = 0 );
+
+			bool hasStorage( const std::string& name );
+			Buffer* getStorageBuffer( const std::string& name );
+			uf::Serializer getStorageJson( const std::string& name, bool cache = true );
+			ext::opengl::userdata_t getStorageUserdata( const std::string& name, const ext::json::Value& payload );
+
+			Buffer::Descriptor getUniform( size_t = 0 ) const;
+			void updateUniform( void*, size_t, size_t = 0 );
+
+			Buffer::Descriptor getStorage( size_t = 0 ) const;
+			void updateStorage( void*, size_t, size_t = 0 );
+		};
+	}
+}
+
+
+#include "graphic.inl"
\ No newline at end of file
diff --git a/engine/inc/uf/ext/opengl/graphic.inl b/engine/inc/uf/ext/opengl/graphic.inl
new file mode 100644
index 00000000..8b148315
--- /dev/null
+++ b/engine/inc/uf/ext/opengl/graphic.inl
@@ -0,0 +1,6 @@
+template<typename T, typename U>
+void ext::opengl::Graphic::initializeMesh( uf::BaseMesh<T, U>& mesh, size_t o ) {
+	if ( mesh.indices.empty() ) mesh.initialize( o );
+	mesh.updateDescriptor();
+	initializeGeometry( mesh );
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/opengl/initializers.h b/engine/inc/uf/ext/opengl/initializers.h
new file mode 100644
index 00000000..7b9637ef
--- /dev/null
+++ b/engine/inc/uf/ext/opengl/initializers.h
@@ -0,0 +1 @@
+#pragma once
\ No newline at end of file
diff --git a/engine/inc/uf/ext/opengl/ogl.h b/engine/inc/uf/ext/opengl/ogl.h
new file mode 100644
index 00000000..10636ddc
--- /dev/null
+++ b/engine/inc/uf/ext/opengl/ogl.h
@@ -0,0 +1,56 @@
+#pragma once
+
+#include <uf/config.h>
+#if defined(UF_ENV_WINDOWS)
+	// The Visual C++ version of gl.h uses WINGDIAPI and APIENTRY but doesn't define them
+	#ifdef _MSC_VER
+		#include <windows.h>
+	#endif
+	#include <GL/glew.h>
+	#include <GL/gl.h>
+	#include <GL/glu.h>
+	#include <GL/wglext.h>
+	#include <GL/glext.h>
+#elif defined(UF_ENV_LINUX) || defined(UF_ENV_FREEBSD)
+	#include <GL/gl.h>
+	#include <GL/glu.h>
+#elif defined(UF_ENV_MACOS)
+	#include <OpenGL/gl.h>
+	#include <OpenGL/glu.h>
+#elif defined(UF_ENV_DREAMCAST)
+	#if UF_USE_OPENGL_GLDC
+		#include <GLdc/gl.h>
+		#include <GLdc/glu.h>
+		#include <GLdc/glkos.h>
+	#else
+		#include <GLkos/gl.h>
+		#include <GLkos/glu.h>
+		#include <GLkos/glut.h>
+
+		#define glIsTexture(x) ( x != 0 )
+	#endif
+
+	#define GL_NONE 0
+	#define GLsizeiptr GLsizei
+#endif
+
+#include <typeinfo>
+
+#define GL_NULL_HANDLE NULL
+#define GL_WHOLE_SIZE -1
+#define GLhandle(x) size_t
+#define GLenumerator(x) 0
+
+#define UF_USE_OPENGL_IMMEDIATE_MODE 0
+
+#define GL_DEBUG_MESSAGE(...) UF_DEBUG_MSG(__VA_ARGS__);
+#define GL_VALIDATION_MESSAGE(...) if ( ext::opengl::settings::validation ) GL_DEBUG_MESSAGE(__VA_ARGS__);
+
+#define GL_ERROR_CHECK(f) {														\
+	{f;}																		\
+	GLenum res = glGetError();													\
+	if (res != GL_NO_ERROR) {													\
+		std::string errorString = ext::opengl::errorString( res ); 				\
+		GL_VALIDATION_MESSAGE("[Validation Error] " << #f << ": " << errorString); 	\
+	}																			\
+}
diff --git a/engine/inc/uf/ext/opengl/opengl.h b/engine/inc/uf/ext/opengl/opengl.h
new file mode 100644
index 00000000..8434f8cf
--- /dev/null
+++ b/engine/inc/uf/ext/opengl/opengl.h
@@ -0,0 +1,82 @@
+#pragma once
+
+#include <uf/ext/opengl/ogl.h>
+#include <uf/ext/opengl/enums.h>
+#include <uf/ext/opengl/device.h>
+#include <uf/ext/opengl/swapchain.h>
+#include <uf/ext/opengl/rendermodes/base.h>
+
+#include <uf/engine/scene/scene.h>
+
+namespace ext {
+	namespace opengl {
+		namespace settings {
+			extern UF_API uint32_t width;
+			extern UF_API uint32_t height;
+			extern UF_API uint8_t msaa;
+			extern UF_API bool validation;
+			extern UF_API size_t viewCount;
+			constexpr size_t maxViews = 6;
+
+			extern UF_API std::vector<std::string> validationFilters;
+			extern UF_API std::vector<std::string> requestedDeviceFeatures;
+			extern UF_API std::vector<std::string> requestedDeviceExtensions;
+			extern UF_API std::vector<std::string> requestedInstanceExtensions;
+			
+			extern UF_API ext::opengl::enums::Filter::type_t swapchainUpscaleFilter;
+
+			namespace experimental {
+				extern UF_API bool rebuildOnTickBegin;
+				extern UF_API bool waitOnRenderEnd;
+				extern UF_API bool individualPipelines;
+				extern UF_API bool multithreadedCommandRecording;
+				extern UF_API std::string deferredMode;
+				extern UF_API bool deferredReconstructPosition;
+				extern UF_API bool deferredAliasOutputToSwapchain;
+				extern UF_API bool multiview;
+				extern UF_API bool vsync;
+				extern UF_API bool hdr;
+			}
+
+			namespace formats {
+				extern UF_API GLhandle(VkColorSpaceKHR) colorSpace;
+				extern UF_API ext::opengl::enums::Format::type_t color;
+				extern UF_API ext::opengl::enums::Format::type_t depth;
+				extern UF_API ext::opengl::enums::Format::type_t normal;
+				extern UF_API ext::opengl::enums::Format::type_t position;
+			}
+		}
+		namespace states {
+			extern UF_API bool rebuild;
+			extern UF_API bool resized;
+			extern UF_API uint32_t currentBuffer;
+		}
+
+		extern UF_API Device device;
+		extern UF_API std::mutex mutex;
+		extern UF_API std::mutex immediateModeMutex;
+
+		extern UF_API RenderMode* currentRenderMode;
+		extern UF_API std::vector<RenderMode*> renderModes;
+		extern UF_API std::vector<uf::Scene*> scenes;
+		
+		bool UF_API hasRenderMode( const std::string&, bool = true );
+		RenderMode& UF_API addRenderMode( RenderMode*, const std::string& = "" );
+		RenderMode& UF_API getRenderMode( const std::string&, bool = true );
+		std::vector<RenderMode*> UF_API getRenderModes( const std::string&, bool = true );
+		std::vector<RenderMode*> UF_API getRenderModes( const std::vector<std::string>&, bool = true );
+		void UF_API removeRenderMode( RenderMode*, bool = true );
+
+		void UF_API initialize( /*uint8_t = 0*/ );
+		void UF_API tick();
+		void UF_API render();
+		void UF_API destroy();
+		void UF_API synchronize( uint8_t = 0b11 );
+		std::string UF_API allocatorStats();
+		
+		ext::opengl::enums::Format::type_t UF_API formatFromString( const std::string& );
+
+		std::string UF_API errorString();
+		std::string UF_API errorString( GLenum );
+	};
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/opengl/rendermode.h b/engine/inc/uf/ext/opengl/rendermode.h
new file mode 100644
index 00000000..70e5b623
--- /dev/null
+++ b/engine/inc/uf/ext/opengl/rendermode.h
@@ -0,0 +1,56 @@
+#pragma once
+
+#include <uf/ext/opengl/device.h>
+#include <uf/ext/opengl/commands.h>
+#include <uf/utils/graphic/descriptor.h>
+
+namespace ext {
+	namespace opengl {
+		struct Graphic;
+		
+		struct UF_API RenderMode {
+			bool execute = false;
+			bool rebuild = false;
+			uint32_t width = 0;
+			uint32_t height = 0;
+			uf::Serializer metadata;
+			
+			Device* device = GL_NULL_HANDLE;
+			RenderTarget renderTarget;
+
+			GLhandle(VkSemaphore) renderCompleteSemaphore;
+			std::vector<GLhandle(VkFence)> fences;
+			
+			std::thread::id mostRecentCommandPoolId;
+			uf::ThreadUnique<CommandBuffer> commands;
+
+			virtual ~RenderMode();
+			// RAII
+			virtual const std::string getName() const;
+			virtual const std::string getType() const;
+			virtual RenderTarget& getRenderTarget(size_t = 0);
+			virtual const RenderTarget& getRenderTarget(size_t = 0) const;
+
+			virtual const size_t blitters() const;
+			virtual ext::opengl::Graphic* getBlitter(size_t = 0);
+			virtual std::vector<ext::opengl::Graphic*> getBlitters();
+
+			virtual CommandBuffer& getCommands();
+			virtual CommandBuffer& getCommands( std::thread::id );
+
+			virtual GraphicDescriptor bindGraphicDescriptor( const GraphicDescriptor&, size_t = 0 );
+			virtual void bindGraphicPushConstants( ext::opengl::Graphic*, size_t = 0 );
+			
+			virtual void initialize( Device& device );
+			virtual void createCommandBuffers();
+			virtual void createCommandBuffers( const std::vector<ext::opengl::Graphic*>& graphics );
+			virtual void bindPipelines();
+			virtual void bindPipelines( const std::vector<ext::opengl::Graphic*>& graphics );
+			virtual void tick();
+			virtual void render();
+			virtual void destroy();
+			virtual void synchronize( uint64_t = UINT64_MAX );
+			virtual void pipelineBarrier( GLhandle(VkCommandBuffer), uint8_t = -1 );
+		};
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/opengl/rendermodes/base.h b/engine/inc/uf/ext/opengl/rendermodes/base.h
new file mode 100644
index 00000000..014d35d0
--- /dev/null
+++ b/engine/inc/uf/ext/opengl/rendermodes/base.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <uf/ext/opengl/rendermode.h>
+
+namespace ext {
+	namespace opengl {
+		struct UF_API BaseRenderMode : public RenderMode {
+			// virtual ~RenderMode();
+			// RAII
+			virtual const std::string getType() const;
+			
+			virtual void initialize( Device& device );
+			virtual void createCommandBuffers( const std::vector<ext::opengl::Graphic*>& graphics );
+			virtual void tick();
+			virtual void render();
+			virtual void destroy();
+		};
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/opengl/rendermodes/compute.h b/engine/inc/uf/ext/opengl/rendermodes/compute.h
new file mode 100644
index 00000000..55f9a618
--- /dev/null
+++ b/engine/inc/uf/ext/opengl/rendermodes/compute.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <uf/ext/opengl/rendermode.h>
+#include <uf/ext/opengl/graphic.h>
+
+namespace ext {
+	namespace opengl {
+		struct UF_API ComputeRenderMode : public RenderMode {
+			ext::opengl::Graphic blitter, compute;
+			pod::Vector2ui dispatchSize = { 32, 32 };
+
+			// RAII
+			virtual const std::string getType() const;
+			virtual const size_t blitters() const;
+			virtual ext::opengl::Graphic* getBlitter(size_t = 0);
+			virtual std::vector<ext::opengl::Graphic*> getBlitters();
+			
+			virtual void createCommandBuffers();
+			virtual void initialize( Device& device );
+			virtual void tick();
+			virtual void render();
+			virtual void destroy();
+			virtual void bindPipelines();
+			virtual void pipelineBarrier( GLhandle(VkCommandBuffer), uint8_t = -1 );
+		};
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/opengl/rendermodes/deferred.h b/engine/inc/uf/ext/opengl/rendermodes/deferred.h
new file mode 100644
index 00000000..2f0e54f0
--- /dev/null
+++ b/engine/inc/uf/ext/opengl/rendermodes/deferred.h
@@ -0,0 +1,23 @@
+#pragma once
+
+#include <uf/ext/opengl/rendermode.h>
+#include <uf/ext/opengl/graphic.h>
+
+namespace ext {
+	namespace opengl {
+		struct UF_API DeferredRenderMode : public RenderMode {
+			ext::opengl::Graphic blitter;
+
+			// RAII
+			virtual const std::string getType() const;
+			virtual const size_t blitters() const;
+			virtual ext::opengl::Graphic* getBlitter(size_t = 0);
+			virtual std::vector<ext::opengl::Graphic*> getBlitters();
+			
+			virtual void createCommandBuffers( const std::vector<ext::opengl::Graphic*>& graphics );
+			virtual void initialize( Device& device );
+			virtual void tick();
+			virtual void destroy();
+		};
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/opengl/rendermodes/rendertarget.h b/engine/inc/uf/ext/opengl/rendermodes/rendertarget.h
new file mode 100644
index 00000000..a02bab97
--- /dev/null
+++ b/engine/inc/uf/ext/opengl/rendermodes/rendertarget.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <uf/ext/opengl/rendermode.h>
+#include <uf/ext/opengl/graphic.h>
+
+namespace ext {
+	namespace opengl {
+		struct UF_API RenderTargetRenderMode : public RenderMode {
+			ext::opengl::Graphic blitter;		
+			//
+			const std::string getTarget() const;
+			void setTarget( const std::string& );
+
+			// RAII
+			virtual const std::string getType() const;
+			virtual const size_t blitters() const;
+			virtual ext::opengl::Graphic* getBlitter(size_t = 0);
+			virtual std::vector<ext::opengl::Graphic*> getBlitters();
+
+			virtual GraphicDescriptor bindGraphicDescriptor( const GraphicDescriptor&, size_t = 0 );
+			
+			virtual void createCommandBuffers( const std::vector<ext::opengl::Graphic*>& graphics );
+			virtual void initialize( Device& device );
+			virtual void tick();
+			virtual void destroy();
+			virtual void render();
+			virtual void pipelineBarrier( GLhandle(VkCommandBuffer), uint8_t = -1 );
+		};
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/opengl/rendertarget.h b/engine/inc/uf/ext/opengl/rendertarget.h
new file mode 100644
index 00000000..70500594
--- /dev/null
+++ b/engine/inc/uf/ext/opengl/rendertarget.h
@@ -0,0 +1,59 @@
+#pragma once
+
+#include <uf/ext/opengl/ogl.h>
+#include <uf/ext/opengl/enums.h>
+#include <vector>
+
+namespace ext {
+	namespace opengl {
+		struct Device;
+
+		struct UF_API RenderTarget {
+			struct Attachment {
+				struct Descriptor {
+					GLhandle(VkFormat) format;
+					GLhandle(VkImageLayout) layout;
+					GLhandle(VkImageUsageFlags) usage;
+					bool blend = false;
+					uint8_t samples = 1;
+					bool aliased = false;
+				} descriptor;
+
+				GLhandle(VkImage) image;
+				GLhandle(VkDeviceMemory) mem;
+				GLhandle(VkImageView) view;
+			
+				GLhandle(VmaAllocation) allocation;
+				GLhandle(VmaAllocationInfo) allocationInfo;
+			
+				GLhandle(VkPipelineColorBlendAttachmentState) blendState;
+			};
+			std::vector<Attachment> attachments;
+
+			struct Subpass {
+				GLhandle(VkPipelineStageFlags) stage;
+				GLhandle(VkAccessFlags) access;
+				bool autoBuildPipeline;
+
+				std::vector<GLhandle(VkAttachmentReference)> colors;
+				std::vector<GLhandle(VkAttachmentReference)> inputs;
+				std::vector<GLhandle(VkAttachmentReference)> resolves;
+				GLhandle(VkAttachmentReference) depth;
+			};
+			std::vector<Subpass> passes;
+
+			bool initialized = false;
+			Device* device = GL_NULL_HANDLE;
+			GLhandle(VkRenderPass) renderPass = GL_NULL_HANDLE;
+			std::vector<GLhandle(VkFramebuffer)> framebuffers;
+			uint32_t width = 0;
+			uint32_t height = 0;
+			uint8_t views = 1;
+			// RAII
+			void initialize( Device& device );
+			void destroy();
+			void addPass( GLhandle(VkPipelineStageFlags), GLhandle(VkAccessFlags), const std::vector<size_t>&, const std::vector<size_t>&, const std::vector<size_t>&, size_t, bool = true  );
+			size_t attach( const Attachment::Descriptor& descriptor, Attachment* attachment = NULL );
+		};
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/opengl/swapchain.h b/engine/inc/uf/ext/opengl/swapchain.h
new file mode 100644
index 00000000..a78521cd
--- /dev/null
+++ b/engine/inc/uf/ext/opengl/swapchain.h
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <uf/ext/opengl/device.h>
+#include <uf/ext/opengl/rendertarget.h>
+
+namespace ext {
+	namespace opengl {
+		struct UF_API Swapchain {
+			Device* device = nullptr;
+			GLhandle(VkSurfaceKHR) surface;
+			GLhandle(VkSwapchainKHR) swapChain = GL_NULL_HANDLE;
+
+			bool initialized = false;
+			bool vsync = true;
+			uint32_t buffers;
+
+			GLhandle(VkSemaphore) presentCompleteSemaphore;
+			GLhandle(VkSemaphore) renderCompleteSemaphore;
+
+			// helpers
+			GLhandle(VkResult) acquireNextImage( uint32_t* imageIndex, GLhandle(VkSemaphore) );
+			GLhandle(VkResult) queuePresent( GLhandle(VkQueue) queue, uint32_t imageIndex, GLhandle(VkSemaphore) waitSemaphore = GL_NULL_HANDLE );
+			
+			// RAII
+			void initialize( Device& device );
+			void destroy();
+		};
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/opengl/texture.h b/engine/inc/uf/ext/opengl/texture.h
new file mode 100644
index 00000000..b26f8688
--- /dev/null
+++ b/engine/inc/uf/ext/opengl/texture.h
@@ -0,0 +1,124 @@
+#pragma once
+
+#pragma once
+
+#include <uf/ext/opengl/enums.h>
+#include <uf/ext/opengl/rendertarget.h>
+#include <uf/utils/image/image.h>
+
+namespace ext {
+	namespace opengl {
+		struct Device;
+
+		struct UF_API Sampler {
+			Device* device = NULL;
+
+			GLhandle(VkSampler) sampler;
+			struct {
+				struct {
+					enums::Filter::type_t min = enums::Filter::LINEAR;
+					enums::Filter::type_t mag = enums::Filter::LINEAR;
+					GLhandle(VkBorderColor) borderColor = GLenumerator(VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK);
+				} filter;
+				struct {
+					enums::AddressMode::type_t  u = enums::AddressMode::REPEAT,
+					 							v = enums::AddressMode::REPEAT,
+					 							w = enums::AddressMode::REPEAT;
+					bool unnormalizedCoordinates = false;
+				} addressMode;
+				struct {
+					bool compareEnable = false;
+					enums::Compare::type_t compareOp = enums::Compare::ALWAYS;
+					GLhandle(VkSamplerMipmapMode) mode = GLenumerator(VK_SAMPLER_MIPMAP_MODE_LINEAR);
+					float lodBias = 0.0f;
+					float min = 0.0f;
+					float max = 0.0f;
+				} mip;
+				struct {
+					bool enabled = true;
+					float max = 16.0f;
+				} anisotropy;
+				GLhandle(VkDescriptorImageInfo) info;
+			} descriptor;
+
+			void initialize( Device& device );
+			void destroy();
+		};
+		struct UF_API Texture {
+			Device* device = nullptr;
+
+			GLuint image = GL_NULL_HANDLE;
+			enums::Image::type_t type = enums::Image::TYPE_2D;
+			enums::Image::viewType_t viewType = enums::Image::VIEW_TYPE_2D;
+			enums::Format::type_t format = enums::Format::R8G8B8A8_UNORM;
+
+			struct Descriptor {
+				GLuint image = GL_NULL_HANDLE;
+				enums::Image::viewType_t viewType = 0;
+				enums::Format::type_t format = 0;
+				uint32_t width = 0, height = 0, depth = 0, layers = 0;
+			} descriptor;
+
+			Sampler sampler;
+
+			uint32_t width, height, depth, layers;
+			uint32_t mips = 1;
+			// RAII
+		#if UF_ENV_DREAMCAST
+			void initialize( Device& device, size_t width, size_t height, size_t depth, size_t layers );
+			void initialize( Device& device, enums::Image::viewType_t, size_t width, size_t height, size_t depth, size_t layers );
+		#else
+			void initialize( Device& device, size_t width, size_t height, size_t depth = 1, size_t layers = 1 );
+			void initialize( Device& device, enums::Image::viewType_t, size_t width, size_t height, size_t depth = 1, size_t layers = 1 );
+		#endif
+			void updateDescriptors();
+			void destroy();
+			bool generated() const;
+			void loadFromFile(
+				const std::string& filename, 
+				enums::Format::type_t format = enums::Format::R8G8B8A8_UNORM
+			);
+			void loadFromFile(
+				const std::string& filename, 
+				Device& device,
+				enums::Format::type_t format = enums::Format::R8G8B8A8_UNORM
+			);
+			void loadFromImage(
+				uf::Image& image,
+				enums::Format::type_t format = enums::Format::R8G8B8A8_UNORM
+			);
+			void loadFromImage(
+				uf::Image& image, 
+				Device& device,
+				enums::Format::type_t format = enums::Format::R8G8B8A8_UNORM
+			);
+			void fromBuffers( void* buffer, size_t bufferSize, enums::Format::type_t format, uint32_t texWidth, uint32_t texHeight, uint32_t texDepth, uint32_t layers, Device& device );
+			void asRenderTarget( Device& device, uint32_t texWidth, uint32_t texHeight, enums::Format::type_t format = enums::Format::R8G8B8A8_UNORM );
+			void aliasTexture( const Texture& );
+			void aliasAttachment( const RenderTarget::Attachment& attachment, bool = true );
+			
+			void update( uf::Image& image, uint32_t layer = 1 );
+			void update( void*, size_t, uint32_t layer = 1 );
+
+			inline void fromBuffers( void* buffer, size_t bufferSize, enums::Format::type_t format, uint32_t texWidth, uint32_t texHeight, Device& device ) { return this->fromBuffers(buffer, bufferSize, format, texWidth, texHeight, 1, 1, device); }
+			
+			void generateMipmaps( uint32_t layer = 1);
+
+			void fromBuffers( void* buffer, size_t bufferSize, enums::Format::type_t format, uint32_t texWidth, uint32_t texHeight, uint32_t texDepth, uint32_t layers );
+			inline void fromBuffers( void* buffer, size_t bufferSize, enums::Format::type_t format, uint32_t texWidth, uint32_t texHeight ) { return this->fromBuffers(buffer, bufferSize, format, texWidth, texHeight, 1, 1); }
+		};
+		class UF_API Texture2D : public Texture {
+		public:
+			Texture2D();
+			static Texture2D empty;
+		};
+		class UF_API Texture3D : public Texture {
+		public:
+			Texture3D();
+		};
+		class UF_API TextureCube : public Texture {
+		public:
+			TextureCube();
+		};
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/opengl/uniform.h b/engine/inc/uf/ext/opengl/uniform.h
new file mode 100644
index 00000000..da3816eb
--- /dev/null
+++ b/engine/inc/uf/ext/opengl/uniform.h
@@ -0,0 +1,10 @@
+#pragma once
+
+#include <uf/utils/math/matrix.h>
+
+namespace pod {
+	struct UF_API Uniform {
+		pod::Matrix4f projection = uf::matrix::identity();
+		pod::Matrix4f modelView = uf::matrix::identity();
+	};
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/openvr/openvr.h b/engine/inc/uf/ext/openvr/openvr.h
new file mode 100644
index 00000000..5f6bf9fa
--- /dev/null
+++ b/engine/inc/uf/ext/openvr/openvr.h
@@ -0,0 +1,84 @@
+#pragma once
+
+#include <uf/config.h>
+
+#if UF_USE_OPENVR
+#include <uf/utils/math/matrix.h>
+#include <uf/utils/math/quaternion.h>
+#include <uf/utils/graphic/graphic.h>
+#include <uf/utils/serialize/serializer.h>
+
+#ifdef USE_OPENVR_MINGW
+	#include <openvr/openvr_mingw.hpp>
+#else
+	#include <openvr/openvr.h>
+#endif
+
+namespace vr {
+	enum EVRHand {
+		Hand_Left = 0,
+		Hand_Right = 1
+	};
+	typedef EVRHand Controller_Hand;
+}
+
+namespace ext {
+	namespace openvr {
+		struct Driver {
+			std::string name;
+			std::string serial;
+			std::string manifest;
+			vr::TrackedDevicePose_t poses[vr::k_unMaxTrackedDeviceCount];
+			std::string types[vr::k_unMaxTrackedDeviceCount];
+			vr::IVRRenderModels* renderModels;
+		};
+		extern UF_API Driver driver;
+		extern UF_API vr::IVRSystem* context;
+		extern UF_API uint8_t renderPass;
+		extern UF_API float width, height;
+		extern UF_API bool enabled;
+		extern UF_API bool swapEyes;
+		extern UF_API uint8_t dominantEye;
+
+		bool UF_API initialize( int stage = 0 );
+		void UF_API tick();
+		void UF_API terminate();
+		void UF_API submit();
+		void UF_API synchronize( bool async = true );
+		float UF_API predictedTimeToDisplay( float additional = 1 );
+		float UF_API updateTracking( float additional = 1 );
+		void UF_API recommendedResolution( uint32_t& width, uint32_t& height );
+
+		pod::Matrix4t<> UF_API hmdHeadPositionMatrix();
+		pod::Matrix4t<> UF_API hmdEyePositionMatrix( vr::Hmd_Eye );
+
+		pod::Matrix4t<> UF_API hmdViewTranslationMatrix();
+		pod::Matrix4t<> UF_API hmdViewRotationMatrix();
+		pod::Vector3f UF_API hmdPosition();
+		pod::Vector3f UF_API hmdPosition( vr::Hmd_Eye eye );
+		pod::Vector3f UF_API hmdEyePosition( vr::Hmd_Eye eye );
+		pod::Quaternion<> UF_API hmdQuaternion();
+		pod::Matrix4t<> UF_API hmdViewMatrix( vr::Hmd_Eye eye, const pod::Matrix4f& = uf::matrix::identity() );
+		pod::Matrix4t<> UF_API hmdProjectionMatrix( vr::Hmd_Eye, float = 0.1f, float = 1024.0f );
+
+		uf::Serializer UF_API controllerState( vr::Controller_Hand, const std::string& = "" );
+		pod::Vector3f UF_API controllerPosition( vr::Controller_Hand, bool = false );
+		pod::Quaternion<> UF_API controllerQuaternion( vr::Controller_Hand, bool = false );
+		pod::Matrix4t<> UF_API controllerTranslationMatrix( vr::Controller_Hand, bool = false );
+		pod::Matrix4t<> UF_API controllerRotationMatrix( vr::Controller_Hand, bool = false );
+		pod::Matrix4t<> UF_API controllerModelMatrix( vr::Controller_Hand, bool = false );
+		pod::Matrix4t<> UF_API controllerMatrix( vr::Controller_Hand, bool = false );
+		bool UF_API controllerActive( vr::Controller_Hand );
+
+		bool UF_API requestRenderModel( const std::string& );
+		uf::Graphic& UF_API getRenderModel( const std::string& );
+		uf::Graphic& UF_API controllerRenderModel( vr::Controller_Hand );
+
+		void UF_API resetPosition();
+	/*
+		pod::Matrix4t<> UF_API positionMatrix();
+		pod::Matrix4t<> UF_API eyeMatrix( vr::Hmd_Eye );
+	*/
+	}
+}
+#endif
\ No newline at end of file
diff --git a/engine/inc/uf/ext/ultralight/ultralight.h b/engine/inc/uf/ext/ultralight/ultralight.h
new file mode 100644
index 00000000..d6d9e3da
--- /dev/null
+++ b/engine/inc/uf/ext/ultralight/ultralight.h
@@ -0,0 +1,47 @@
+#pragma once
+
+#include <uf/config.h>
+#if UF_USE_ULTRALIGHT
+
+#include <string>
+#include <vector>
+#include <uf/utils/math/vector.h>
+#include <uf/utils/image/image.h>
+#include <uf/utils/string/io.h>
+
+#include <Ultralight/CAPI.h>
+
+namespace pod {
+	struct HTML {
+		size_t uid = 0;
+		ULView view;
+		bool pending;
+		std::string html;
+		pod::Vector2ui size;
+		struct {
+			std::string load = "";
+		} callbacks;
+	};
+}
+
+namespace ext {
+	namespace ultralight {
+	//	extern UF_API std::string resourcesDir;
+		extern UF_API uint8_t log;
+		extern UF_API double scale;
+
+		void UF_API initialize();
+		void UF_API tick();
+		void UF_API render();
+		void UF_API terminate();
+
+		pod::HTML UF_API create( const std::string&, const pod::Vector2ui& );
+		pod::HTML& UF_API create( pod::HTML&, const std::string&, const pod::Vector2ui& );
+		void UF_API destroy( pod::HTML& );
+		void UF_API on( pod::HTML&, const std::string&, const std::string& );
+		void UF_API resize( pod::HTML&, const pod::Vector2ui& );
+		void UF_API input( pod::HTML&, const std::string& );
+		uf::Image UF_API capture( pod::HTML& );
+	}
+}
+#endif
\ No newline at end of file
diff --git a/engine/inc/uf/ext/vorbis/vorbis.h b/engine/inc/uf/ext/vorbis/vorbis.h
new file mode 100644
index 00000000..e1cbd1b5
--- /dev/null
+++ b/engine/inc/uf/ext/vorbis/vorbis.h
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <uf/config.h>
+#if UF_USE_VORBIS
+
+#include <vorbis/vorbisfile.h>
+
+#include <vector>
+#include <string>
+
+namespace ext {
+	class UF_API Vorbis {
+	public:
+		static int BUFFER;
+	protected:
+		std::vector<char> m_buffer;
+		int m_format;
+		int m_frequency;
+		float m_duration;
+	public:
+		void load( const std::string& );
+		
+		std::vector<char>& getBuffer();
+		const std::vector<char>& getBuffer() const;
+		int getFormat() const;
+		int getFrequency() const;
+		float getDuration() const;
+	};
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/inc/uf/ext/vulkan/buffer.h b/engine/inc/uf/ext/vulkan/buffer.h
new file mode 100644
index 00000000..bfcd8d58
--- /dev/null
+++ b/engine/inc/uf/ext/vulkan/buffer.h
@@ -0,0 +1,80 @@
+#pragma once
+
+#include <uf/ext/vulkan/vk.h>
+#include <vector>
+
+namespace ext {
+	namespace vulkan {
+		struct Device;
+
+		struct UF_API Buffer {
+			VkDevice device;
+			VkBuffer buffer = VK_NULL_HANDLE;
+			VkDeviceMemory memory = VK_NULL_HANDLE;
+			VkDescriptorBufferInfo descriptor = {
+				VK_NULL_HANDLE,
+				0,
+				0
+			};
+			VkDeviceSize size = 0;
+			VkDeviceSize alignment = 0;
+			void* mapped = nullptr;
+
+			VkBufferUsageFlags usage;
+			VkMemoryPropertyFlags memoryProperties;
+			
+			VkMemoryAllocateInfo memAlloc;
+			VkMemoryRequirements memReqs;
+
+			VmaAllocation allocation;
+			VmaAllocationInfo allocationInfo;
+
+			VkResult map( VkDeviceSize size = VK_WHOLE_SIZE, VkDeviceSize offset = 0 );
+
+			void unmap();
+
+			VkResult bind( VkDeviceSize offset = 0 );
+
+			void setupDescriptor( VkDeviceSize size = VK_WHOLE_SIZE, VkDeviceSize offset = 0 );
+			void copyTo( void* data, VkDeviceSize size );
+			VkResult flush( VkDeviceSize size = VK_WHOLE_SIZE, VkDeviceSize offset = 0 );
+			VkResult invalidate( VkDeviceSize size = VK_WHOLE_SIZE, VkDeviceSize offset = 0 );
+		/*
+			template<typename T>
+			std::size_t getAlignment( const T& t ) {
+				size_t min = device->properties.limits.minUniformBufferOffsetAlignment;
+				size_t dynamicAlignment = sizeof(T);
+				if (min > 0) {
+					dynamicAlignment = (dynamicAlignment + min - 1) & ~(min - 1);
+				}
+				return dynamicAlignment;
+			};
+		*/
+			void allocate( VkBufferCreateInfo );
+
+			// RAII
+			~Buffer();
+			void initialize( VkDevice device );
+			void destroy();
+		};
+		struct UF_API Buffers {
+			std::vector<Buffer> buffers;
+			Device* device;
+
+		//	~Buffers();
+			//
+			void initialize( Device& device );
+			void destroy();
+			//
+			size_t initializeBuffer( void* data, VkDeviceSize length, VkBufferUsageFlags usage, VkMemoryPropertyFlags memoryProperties = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, bool stage = VK_DEFAULT_STAGE_BUFFERS );
+			template<typename T> inline size_t initializeBuffer( T data, VkDeviceSize length, VkBufferUsageFlags usage, VkMemoryPropertyFlags memoryProperties = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, bool stage = VK_DEFAULT_STAGE_BUFFERS ) { return initializeBuffer( (void*) &data, length, usage, memoryProperties, stage ); }
+			template<typename T> inline size_t initializeBuffer( T data, VkBufferUsageFlags usage, VkMemoryPropertyFlags memoryProperties = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, bool stage = VK_DEFAULT_STAGE_BUFFERS ) { return initializeBuffer( (void*) &data, static_cast<VkDeviceSize>(sizeof(T)), usage, memoryProperties, stage ); }
+
+			void updateBuffer( void* data, VkDeviceSize length, size_t index = 0, bool stage = VK_DEFAULT_STAGE_BUFFERS );
+			void updateBuffer( void* data, VkDeviceSize length, Buffer& buffer, bool stage = VK_DEFAULT_STAGE_BUFFERS );
+			template<typename T> inline void updateBuffer( T data, VkDeviceSize length, size_t index = 0, bool stage = VK_DEFAULT_STAGE_BUFFERS ) { return updateBuffer( (void*) &data, length, index, stage ); }
+			template<typename T> inline void updateBuffer( T data, size_t index = 0, bool stage = VK_DEFAULT_STAGE_BUFFERS ) { return updateBuffer( (void*) &data, static_cast<VkDeviceSize>(sizeof(T)), index, stage ); }
+			template<typename T> inline void updateBuffer( T data, VkDeviceSize length, Buffer& buffer, bool stage = VK_DEFAULT_STAGE_BUFFERS ) { return updateBuffer( (void*) &data, length, buffer, stage ); }
+		};
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/vulkan/device.h b/engine/inc/uf/ext/vulkan/device.h
new file mode 100644
index 00000000..81bf2de7
--- /dev/null
+++ b/engine/inc/uf/ext/vulkan/device.h
@@ -0,0 +1,118 @@
+#pragma once
+
+#include <uf/ext/vulkan/vk.h>
+#include <uf/ext/vulkan/buffer.h>
+#include <uf/utils/window/window.h>
+#include <uf/utils/thread/thread.h>
+#include <uf/utils/thread/perthread.h>
+
+namespace ext {
+	namespace vulkan {
+		struct UF_API Device {
+			VkInstance instance;
+			VkDebugUtilsMessengerEXT debugMessenger;
+			VkSurfaceKHR surface;
+			VkPhysicalDevice physicalDevice;
+			VkDevice logicalDevice;
+			struct {
+			//	std::unordered_map<std::thread::id, VkCommandPool> graphics;
+			//	std::unordered_map<std::thread::id, VkCommandPool> compute;
+			//	std::unordered_map<std::thread::id, VkCommandPool> transfer;
+				uf::ThreadUnique<VkCommandPool> graphics;
+				uf::ThreadUnique<VkCommandPool> compute;
+				uf::ThreadUnique<VkCommandPool> transfer;
+			} commandPool;
+
+			VkPhysicalDeviceProperties properties;
+			VkPhysicalDeviceFeatures features;
+			VkPhysicalDeviceFeatures enabledFeatures;
+			VkPhysicalDeviceMemoryProperties memoryProperties;
+			
+			VkPhysicalDeviceProperties2 properties2;
+			VkPhysicalDeviceFeatures2 features2;
+			VkPhysicalDeviceFeatures2 enabledFeatures2;
+			VkPhysicalDeviceMemoryProperties2 memoryProperties2;
+
+			struct {
+				std::vector<VkExtensionProperties> instance;
+				std::vector<VkExtensionProperties> device;
+			} extensionProperties;
+			struct {
+				std::vector<std::string> instance;
+				std::vector<std::string> device;
+			} supportedExtensions;
+			
+			VkPipelineCache pipelineCache;
+
+			std::vector<VkQueueFamilyProperties> queueFamilyProperties;
+			
+			struct {
+			//	std::unordered_map<std::thread::id,VkQueue> graphics;
+			//	std::unordered_map<std::thread::id,VkQueue> present;
+			//	std::unordered_map<std::thread::id,VkQueue> compute;
+			//	std::unordered_map<std::thread::id,VkQueue> transfer;
+				uf::ThreadUnique<VkQueue> graphics;
+				uf::ThreadUnique<VkQueue> present;
+				uf::ThreadUnique<VkQueue> compute;
+				uf::ThreadUnique<VkQueue> transfer;
+			} queues;
+
+			uf::Window* window;
+
+		/*
+			struct {
+				VkFormat depth;
+				VkFormat color;
+				VkColorSpaceKHR space;
+			} formats;
+		*/
+
+			struct QueueFamilyIndices {
+				uint32_t graphics;
+				uint32_t present;
+				uint32_t compute;
+				uint32_t transfer;
+			} queueFamilyIndices;
+			operator VkDevice() { return this->logicalDevice; };
+			
+			// helpers
+			uint32_t getQueueFamilyIndex( VkQueueFlagBits queueFlags );
+			uint32_t getMemoryType( uint32_t typeBits, VkMemoryPropertyFlags properties, VkBool32 *memTypeFound = nullptr );
+			int rate( VkPhysicalDevice device );
+			
+			VkCommandBuffer createCommandBuffer( VkCommandBufferLevel level, bool begin = false );
+			void flushCommandBuffer( VkCommandBuffer commandBuffer, bool free = true );
+
+			VkResult createBuffer(
+				VkBufferUsageFlags usage,
+				VkMemoryPropertyFlags memoryProperties,
+				VkDeviceSize size,
+				VkBuffer* buffer, 
+				VkDeviceMemory *memory,
+				void *data = nullptr
+			);
+			VkResult createBuffer(
+				VkBufferUsageFlags usage,
+				VkMemoryPropertyFlags memoryProperties,
+				ext::vulkan::Buffer& buffer,
+				VkDeviceSize size,
+				void *data = nullptr
+			);
+
+			enum QueueEnum {
+				GRAPHICS,
+				PRESENT,
+				COMPUTE,
+				TRANSFER,
+			};
+			VkQueue& getQueue( QueueEnum );
+			VkCommandPool& getCommandPool( QueueEnum );
+			VkQueue& getQueue( QueueEnum, std::thread::id );
+			VkCommandPool& getCommandPool( QueueEnum, std::thread::id );
+
+			// RAII
+			void initialize();
+			void destroy();
+		};
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/vulkan/enums.h b/engine/inc/uf/ext/vulkan/enums.h
new file mode 100644
index 00000000..259c5abf
--- /dev/null
+++ b/engine/inc/uf/ext/vulkan/enums.h
@@ -0,0 +1,154 @@
+#pragma once
+
+#include <uf/ext/vulkan/vk.h>
+
+namespace ext {
+	namespace vulkan {
+		namespace enums {
+			namespace Compare {
+				typedef decltype(VK_COMPARE_OP_NEVER) type_t;
+				static const type_t NEVER = VK_COMPARE_OP_NEVER;
+				static const type_t LESS = VK_COMPARE_OP_LESS;
+				static const type_t EQUAL = VK_COMPARE_OP_EQUAL;
+				static const type_t LESS_OR_EQUAL = VK_COMPARE_OP_LESS_OR_EQUAL;
+				static const type_t GREATER = VK_COMPARE_OP_GREATER;
+				static const type_t NOT_EQUAL = VK_COMPARE_OP_NOT_EQUAL;
+				static const type_t GREATER_OR_EQUAL = VK_COMPARE_OP_GREATER_OR_EQUAL;
+				static const type_t ALWAYS = VK_COMPARE_OP_ALWAYS;
+			}
+			namespace Format {
+				typedef decltype(VK_FORMAT_R32G32_SFLOAT) type_t;
+				#include "enums/format.inl"
+			}
+			namespace Face {
+				typedef decltype(VK_FRONT_FACE_CLOCKWISE) type_t;
+				static const type_t CW = VK_FRONT_FACE_CLOCKWISE;
+				static const type_t CCW = VK_FRONT_FACE_COUNTER_CLOCKWISE;
+			}
+			namespace Layout {
+				typedef decltype(VK_IMAGE_LAYOUT_UNDEFINED) type_t;
+				static const type_t UNDEFINED = VK_IMAGE_LAYOUT_UNDEFINED;
+				static const type_t GENERAL = VK_IMAGE_LAYOUT_GENERAL;
+				static const type_t COLOR_ATTACHMENT_OPTIMAL = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+				static const type_t DEPTH_STENCIL_ATTACHMENT_OPTIMAL = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+				static const type_t DEPTH_STENCIL_READ_ONLY_OPTIMAL = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;
+				static const type_t SHADER_READ_ONLY_OPTIMAL = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+				static const type_t TRANSFER_SRC_OPTIMAL = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+				static const type_t TRANSFER_DST_OPTIMAL = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+				static const type_t PREINITIALIZED = VK_IMAGE_LAYOUT_PREINITIALIZED;
+			}
+			namespace Image {
+				typedef decltype(VK_IMAGE_TYPE_1D) type_t;
+				typedef decltype(VK_IMAGE_VIEW_TYPE_1D) viewType_t;
+				static const type_t TYPE_1D = VK_IMAGE_TYPE_1D;
+				static const type_t TYPE_2D = VK_IMAGE_TYPE_2D;
+				static const type_t TYPE_3D = VK_IMAGE_TYPE_3D;
+
+				static const viewType_t VIEW_TYPE_1D = VK_IMAGE_VIEW_TYPE_1D;
+				static const viewType_t VIEW_TYPE_2D = VK_IMAGE_VIEW_TYPE_2D;
+				static const viewType_t VIEW_TYPE_3D = VK_IMAGE_VIEW_TYPE_3D;
+				static const viewType_t VIEW_TYPE_CUBE = VK_IMAGE_VIEW_TYPE_CUBE;
+				static const viewType_t VIEW_TYPE_1D_ARRAY = VK_IMAGE_VIEW_TYPE_1D_ARRAY;
+				static const viewType_t VIEW_TYPE_2D_ARRAY = VK_IMAGE_VIEW_TYPE_2D_ARRAY;
+				static const viewType_t VIEW_TYPE_CUBE_ARRAY = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
+			}
+			namespace CullMode {
+				typedef decltype(VK_CULL_MODE_NONE) type_t;
+				static const type_t NONE = VK_CULL_MODE_NONE;
+				static const type_t FRONT = VK_CULL_MODE_FRONT_BIT;
+				static const type_t BACK = VK_CULL_MODE_BACK_BIT;
+				static const type_t BOTH = VK_CULL_MODE_FRONT_AND_BACK;
+			}
+			namespace Shader {
+				typedef decltype(VK_SHADER_STAGE_VERTEX_BIT) type_t;
+				static const type_t VERTEX = VK_SHADER_STAGE_VERTEX_BIT;
+				static const type_t TESSELLATION_CONTROL = VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT;
+				static const type_t TESSELLATION_EVALUATION = VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT;
+				static const type_t GEOMETRY = VK_SHADER_STAGE_GEOMETRY_BIT;
+				static const type_t FRAGMENT = VK_SHADER_STAGE_FRAGMENT_BIT;
+				static const type_t COMPUTE = VK_SHADER_STAGE_COMPUTE_BIT;
+				static const type_t ALL_GRAPHICS = VK_SHADER_STAGE_ALL_GRAPHICS;
+				static const type_t ALL = VK_SHADER_STAGE_ALL;
+			}
+			namespace PrimitiveTopology {
+				typedef decltype(VK_PRIMITIVE_TOPOLOGY_POINT_LIST) type_t;
+				static const type_t POINT_LIST = VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
+				static const type_t LINE_LIST = VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
+				static const type_t LINE_STRIP = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP;
+				static const type_t TRIANGLE_LIST = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+				static const type_t TRIANGLE_STRIP = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
+				static const type_t TRIANGLE_FAN = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN;
+				static const type_t LINE_LIST_WITH_ADJACENCY = VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY;
+				static const type_t LINE_STRIP_WITH_ADJACENCY = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY;
+				static const type_t TRIANGLE_LIST_WITH_ADJACENCY = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY;
+				static const type_t TRIANGLE_STRIP_WITH_ADJACENCY = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY;
+				static const type_t PATCH_LIST = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST;
+			}
+			namespace PolygonMode {
+				typedef decltype(VK_POLYGON_MODE_FILL) type_t;
+				static const type_t FILL = VK_POLYGON_MODE_FILL;
+				static const type_t LINE = VK_POLYGON_MODE_LINE;
+				static const type_t POINT = VK_POLYGON_MODE_POINT;
+			}
+			namespace AddressMode {
+				typedef decltype(VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE) type_t;
+				static const type_t CLAMP_TO_EDGE = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+				static const type_t CLAMP_TO_BORDER = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
+				static const type_t MIRRORED_REPEAT = VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT;
+				static const type_t REPEAT = VK_SAMPLER_ADDRESS_MODE_REPEAT;
+			}
+			namespace Filter {
+				typedef decltype(VK_FILTER_NEAREST) type_t;
+				static const type_t NEAREST = VK_FILTER_NEAREST;
+				static const type_t LINEAR = VK_FILTER_LINEAR;
+			}
+			namespace Type {
+				typedef size_t type_t;
+				static const type_t BYTE = 1;
+				static const type_t UBYTE = 2;
+
+				static const type_t SHORT = 3;
+				static const type_t USHORT = 4;
+				
+				static const type_t INT = 5;
+				static const type_t UINT = 6;
+
+				static const type_t HALF = 7;
+				static const type_t FLOAT = 8;
+				static const type_t DOUBLE = 9;
+				static const type_t FIXED = 10;
+			}
+			namespace Buffer {
+				typedef decltype(VK_BUFFER_USAGE_TRANSFER_SRC_BIT) type_t;
+				static const type_t TRANSFER_SRC = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
+				static const type_t TRANSFER_DST = VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+				static const type_t UNIFORM_TEXEL = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT;
+				static const type_t STORAGE_TEXEL = VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT;
+				static const type_t UNIFORM = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
+				static const type_t STORAGE = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
+				static const type_t INDEX = VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
+				static const type_t VERTEX = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
+				static const type_t INDIRECT = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
+
+				static const type_t STREAM = {};
+				static const type_t STATIC = {};
+				static const type_t DYNAMIC = {};
+				static const type_t DRAW = {};
+				static const type_t READ = {};
+				static const type_t COPY = {};
+			}
+		}
+		template<typename T>
+		ext::vulkan::enums::Type::type_t typeToEnum() {
+			if ( typeid(T) == typeid(int8_t) ) return ext::vulkan::enums::Type::BYTE;
+			if ( typeid(T) == typeid(uint8_t) ) return ext::vulkan::enums::Type::UBYTE;
+			if ( typeid(T) == typeid(int16_t) ) return ext::vulkan::enums::Type::SHORT;
+			if ( typeid(T) == typeid(uint16_t) ) return ext::vulkan::enums::Type::USHORT;
+			if ( typeid(T) == typeid(int32_t) ) return ext::vulkan::enums::Type::INT;
+			if ( typeid(T) == typeid(uint32_t) ) return ext::vulkan::enums::Type::UINT;
+			if ( typeid(T) == typeid(float) ) return ext::vulkan::enums::Type::FLOAT;
+			if ( typeid(T) == typeid(double) ) return ext::vulkan::enums::Type::DOUBLE;
+			return 0;
+		}
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/vulkan/enums/format.inl b/engine/inc/uf/ext/vulkan/enums/format.inl
new file mode 100644
index 00000000..e837e2c0
--- /dev/null
+++ b/engine/inc/uf/ext/vulkan/enums/format.inl
@@ -0,0 +1,185 @@
+static const type_t UNDEFINED = VK_FORMAT_UNDEFINED;
+static const type_t R4G4_UNORM_PACK8 = VK_FORMAT_R4G4_UNORM_PACK8;
+static const type_t R4G4B4A4_UNORM_PACK16 = VK_FORMAT_R4G4B4A4_UNORM_PACK16;
+static const type_t B4G4R4A4_UNORM_PACK16 = VK_FORMAT_B4G4R4A4_UNORM_PACK16;
+static const type_t R5G6B5_UNORM_PACK16 = VK_FORMAT_R5G6B5_UNORM_PACK16;
+static const type_t B5G6R5_UNORM_PACK16 = VK_FORMAT_B5G6R5_UNORM_PACK16;
+static const type_t R5G5B5A1_UNORM_PACK16 = VK_FORMAT_R5G5B5A1_UNORM_PACK16;
+static const type_t B5G5R5A1_UNORM_PACK16 = VK_FORMAT_B5G5R5A1_UNORM_PACK16;
+static const type_t A1R5G5B5_UNORM_PACK16 = VK_FORMAT_A1R5G5B5_UNORM_PACK16;
+static const type_t R8_UNORM = VK_FORMAT_R8_UNORM;
+static const type_t R8_SNORM = VK_FORMAT_R8_SNORM;
+static const type_t R8_USCALED = VK_FORMAT_R8_USCALED;
+static const type_t R8_SSCALED = VK_FORMAT_R8_SSCALED;
+static const type_t R8_UINT = VK_FORMAT_R8_UINT;
+static const type_t R8_SINT = VK_FORMAT_R8_SINT;
+static const type_t R8_SRGB = VK_FORMAT_R8_SRGB;
+static const type_t R8G8_UNORM = VK_FORMAT_R8G8_UNORM;
+static const type_t R8G8_SNORM = VK_FORMAT_R8G8_SNORM;
+static const type_t R8G8_USCALED = VK_FORMAT_R8G8_USCALED;
+static const type_t R8G8_SSCALED = VK_FORMAT_R8G8_SSCALED;
+static const type_t R8G8_UINT = VK_FORMAT_R8G8_UINT;
+static const type_t R8G8_SINT = VK_FORMAT_R8G8_SINT;
+static const type_t R8G8_SRGB = VK_FORMAT_R8G8_SRGB;
+static const type_t R8G8B8_UNORM = VK_FORMAT_R8G8B8_UNORM;
+static const type_t R8G8B8_SNORM = VK_FORMAT_R8G8B8_SNORM;
+static const type_t R8G8B8_USCALED = VK_FORMAT_R8G8B8_USCALED;
+static const type_t R8G8B8_SSCALED = VK_FORMAT_R8G8B8_SSCALED;
+static const type_t R8G8B8_UINT = VK_FORMAT_R8G8B8_UINT;
+static const type_t R8G8B8_SINT = VK_FORMAT_R8G8B8_SINT;
+static const type_t R8G8B8_SRGB = VK_FORMAT_R8G8B8_SRGB;
+static const type_t B8G8R8_UNORM = VK_FORMAT_B8G8R8_UNORM;
+static const type_t B8G8R8_SNORM = VK_FORMAT_B8G8R8_SNORM;
+static const type_t B8G8R8_USCALED = VK_FORMAT_B8G8R8_USCALED;
+static const type_t B8G8R8_SSCALED = VK_FORMAT_B8G8R8_SSCALED;
+static const type_t B8G8R8_UINT = VK_FORMAT_B8G8R8_UINT;
+static const type_t B8G8R8_SINT = VK_FORMAT_B8G8R8_SINT;
+static const type_t B8G8R8_SRGB = VK_FORMAT_B8G8R8_SRGB;
+static const type_t R8G8B8A8_UNORM = VK_FORMAT_R8G8B8A8_UNORM;
+static const type_t R8G8B8A8_SNORM = VK_FORMAT_R8G8B8A8_SNORM;
+static const type_t R8G8B8A8_USCALED = VK_FORMAT_R8G8B8A8_USCALED;
+static const type_t R8G8B8A8_SSCALED = VK_FORMAT_R8G8B8A8_SSCALED;
+static const type_t R8G8B8A8_UINT = VK_FORMAT_R8G8B8A8_UINT;
+static const type_t R8G8B8A8_SINT = VK_FORMAT_R8G8B8A8_SINT;
+static const type_t R8G8B8A8_SRGB = VK_FORMAT_R8G8B8A8_SRGB;
+static const type_t B8G8R8A8_UNORM = VK_FORMAT_B8G8R8A8_UNORM;
+static const type_t B8G8R8A8_SNORM = VK_FORMAT_B8G8R8A8_SNORM;
+static const type_t B8G8R8A8_USCALED = VK_FORMAT_B8G8R8A8_USCALED;
+static const type_t B8G8R8A8_SSCALED = VK_FORMAT_B8G8R8A8_SSCALED;
+static const type_t B8G8R8A8_UINT = VK_FORMAT_B8G8R8A8_UINT;
+static const type_t B8G8R8A8_SINT = VK_FORMAT_B8G8R8A8_SINT;
+static const type_t B8G8R8A8_SRGB = VK_FORMAT_B8G8R8A8_SRGB;
+static const type_t A8B8G8R8_UNORM_PACK32 = VK_FORMAT_A8B8G8R8_UNORM_PACK32;
+static const type_t A8B8G8R8_SNORM_PACK32 = VK_FORMAT_A8B8G8R8_SNORM_PACK32;
+static const type_t A8B8G8R8_USCALED_PACK32 = VK_FORMAT_A8B8G8R8_USCALED_PACK32;
+static const type_t A8B8G8R8_SSCALED_PACK32 = VK_FORMAT_A8B8G8R8_SSCALED_PACK32;
+static const type_t A8B8G8R8_UINT_PACK32 = VK_FORMAT_A8B8G8R8_UINT_PACK32;
+static const type_t A8B8G8R8_SINT_PACK32 = VK_FORMAT_A8B8G8R8_SINT_PACK32;
+static const type_t A8B8G8R8_SRGB_PACK32 = VK_FORMAT_A8B8G8R8_SRGB_PACK32;
+static const type_t A2R10G10B10_UNORM_PACK32 = VK_FORMAT_A2R10G10B10_UNORM_PACK32;
+static const type_t A2R10G10B10_SNORM_PACK32 = VK_FORMAT_A2R10G10B10_SNORM_PACK32;
+static const type_t A2R10G10B10_USCALED_PACK32 = VK_FORMAT_A2R10G10B10_USCALED_PACK32;
+static const type_t A2R10G10B10_SSCALED_PACK32 = VK_FORMAT_A2R10G10B10_SSCALED_PACK32;
+static const type_t A2R10G10B10_UINT_PACK32 = VK_FORMAT_A2R10G10B10_UINT_PACK32;
+static const type_t A2R10G10B10_SINT_PACK32 = VK_FORMAT_A2R10G10B10_SINT_PACK32;
+static const type_t A2B10G10R10_UNORM_PACK32 = VK_FORMAT_A2B10G10R10_UNORM_PACK32;
+static const type_t A2B10G10R10_SNORM_PACK32 = VK_FORMAT_A2B10G10R10_SNORM_PACK32;
+static const type_t A2B10G10R10_USCALED_PACK32 = VK_FORMAT_A2B10G10R10_USCALED_PACK32;
+static const type_t A2B10G10R10_SSCALED_PACK32 = VK_FORMAT_A2B10G10R10_SSCALED_PACK32;
+static const type_t A2B10G10R10_UINT_PACK32 = VK_FORMAT_A2B10G10R10_UINT_PACK32;
+static const type_t A2B10G10R10_SINT_PACK32 = VK_FORMAT_A2B10G10R10_SINT_PACK32;
+static const type_t R16_UNORM = VK_FORMAT_R16_UNORM;
+static const type_t R16_SNORM = VK_FORMAT_R16_SNORM;
+static const type_t R16_USCALED = VK_FORMAT_R16_USCALED;
+static const type_t R16_SSCALED = VK_FORMAT_R16_SSCALED;
+static const type_t R16_UINT = VK_FORMAT_R16_UINT;
+static const type_t R16_SINT = VK_FORMAT_R16_SINT;
+static const type_t R16_SFLOAT = VK_FORMAT_R16_SFLOAT;
+static const type_t R16G16_UNORM = VK_FORMAT_R16G16_UNORM;
+static const type_t R16G16_SNORM = VK_FORMAT_R16G16_SNORM;
+static const type_t R16G16_USCALED = VK_FORMAT_R16G16_USCALED;
+static const type_t R16G16_SSCALED = VK_FORMAT_R16G16_SSCALED;
+static const type_t R16G16_UINT = VK_FORMAT_R16G16_UINT;
+static const type_t R16G16_SINT = VK_FORMAT_R16G16_SINT;
+static const type_t R16G16_SFLOAT = VK_FORMAT_R16G16_SFLOAT;
+static const type_t R16G16B16_UNORM = VK_FORMAT_R16G16B16_UNORM;
+static const type_t R16G16B16_SNORM = VK_FORMAT_R16G16B16_SNORM;
+static const type_t R16G16B16_USCALED = VK_FORMAT_R16G16B16_USCALED;
+static const type_t R16G16B16_SSCALED = VK_FORMAT_R16G16B16_SSCALED;
+static const type_t R16G16B16_UINT = VK_FORMAT_R16G16B16_UINT;
+static const type_t R16G16B16_SINT = VK_FORMAT_R16G16B16_SINT;
+static const type_t R16G16B16_SFLOAT = VK_FORMAT_R16G16B16_SFLOAT;
+static const type_t R16G16B16A16_UNORM = VK_FORMAT_R16G16B16A16_UNORM;
+static const type_t R16G16B16A16_SNORM = VK_FORMAT_R16G16B16A16_SNORM;
+static const type_t R16G16B16A16_USCALED = VK_FORMAT_R16G16B16A16_USCALED;
+static const type_t R16G16B16A16_SSCALED = VK_FORMAT_R16G16B16A16_SSCALED;
+static const type_t R16G16B16A16_UINT = VK_FORMAT_R16G16B16A16_UINT;
+static const type_t R16G16B16A16_SINT = VK_FORMAT_R16G16B16A16_SINT;
+static const type_t R16G16B16A16_SFLOAT = VK_FORMAT_R16G16B16A16_SFLOAT;
+static const type_t R32_UINT = VK_FORMAT_R32_UINT;
+static const type_t R32_SINT = VK_FORMAT_R32_SINT;
+static const type_t R32_SFLOAT = VK_FORMAT_R32_SFLOAT;
+static const type_t R32G32_UINT = VK_FORMAT_R32G32_UINT;
+static const type_t R32G32_SINT = VK_FORMAT_R32G32_SINT;
+static const type_t R32G32_SFLOAT = VK_FORMAT_R32G32_SFLOAT;
+static const type_t R32G32B32_UINT = VK_FORMAT_R32G32B32_UINT;
+static const type_t R32G32B32_SINT = VK_FORMAT_R32G32B32_SINT;
+static const type_t R32G32B32_SFLOAT = VK_FORMAT_R32G32B32_SFLOAT;
+static const type_t R32G32B32A32_UINT = VK_FORMAT_R32G32B32A32_UINT;
+static const type_t R32G32B32A32_SINT = VK_FORMAT_R32G32B32A32_SINT;
+static const type_t R32G32B32A32_SFLOAT = VK_FORMAT_R32G32B32A32_SFLOAT;
+static const type_t R64_UINT = VK_FORMAT_R64_UINT;
+static const type_t R64_SINT = VK_FORMAT_R64_SINT;
+static const type_t R64_SFLOAT = VK_FORMAT_R64_SFLOAT;
+static const type_t R64G64_UINT = VK_FORMAT_R64G64_UINT;
+static const type_t R64G64_SINT = VK_FORMAT_R64G64_SINT;
+static const type_t R64G64_SFLOAT = VK_FORMAT_R64G64_SFLOAT;
+static const type_t R64G64B64_UINT = VK_FORMAT_R64G64B64_UINT;
+static const type_t R64G64B64_SINT = VK_FORMAT_R64G64B64_SINT;
+static const type_t R64G64B64_SFLOAT = VK_FORMAT_R64G64B64_SFLOAT;
+static const type_t R64G64B64A64_UINT = VK_FORMAT_R64G64B64A64_UINT;
+static const type_t R64G64B64A64_SINT = VK_FORMAT_R64G64B64A64_SINT;
+static const type_t R64G64B64A64_SFLOAT = VK_FORMAT_R64G64B64A64_SFLOAT;
+static const type_t B10G11R11_UFLOAT_PACK32 = VK_FORMAT_B10G11R11_UFLOAT_PACK32;
+static const type_t E5B9G9R9_UFLOAT_PACK32 = VK_FORMAT_E5B9G9R9_UFLOAT_PACK32;
+static const type_t D16_UNORM = VK_FORMAT_D16_UNORM;
+static const type_t X8_D24_UNORM_PACK32 = VK_FORMAT_X8_D24_UNORM_PACK32;
+static const type_t D32_SFLOAT = VK_FORMAT_D32_SFLOAT;
+static const type_t S8_UINT = VK_FORMAT_S8_UINT;
+static const type_t D16_UNORM_S8_UINT = VK_FORMAT_D16_UNORM_S8_UINT;
+static const type_t D24_UNORM_S8_UINT = VK_FORMAT_D24_UNORM_S8_UINT;
+static const type_t D32_SFLOAT_S8_UINT = VK_FORMAT_D32_SFLOAT_S8_UINT;
+static const type_t BC1_RGB_UNORM_BLOCK = VK_FORMAT_BC1_RGB_UNORM_BLOCK;
+static const type_t BC1_RGB_SRGB_BLOCK = VK_FORMAT_BC1_RGB_SRGB_BLOCK;
+static const type_t BC1_RGBA_UNORM_BLOCK = VK_FORMAT_BC1_RGBA_UNORM_BLOCK;
+static const type_t BC1_RGBA_SRGB_BLOCK = VK_FORMAT_BC1_RGBA_SRGB_BLOCK;
+static const type_t BC2_UNORM_BLOCK = VK_FORMAT_BC2_UNORM_BLOCK;
+static const type_t BC2_SRGB_BLOCK = VK_FORMAT_BC2_SRGB_BLOCK;
+static const type_t BC3_UNORM_BLOCK = VK_FORMAT_BC3_UNORM_BLOCK;
+static const type_t BC3_SRGB_BLOCK = VK_FORMAT_BC3_SRGB_BLOCK;
+static const type_t BC4_UNORM_BLOCK = VK_FORMAT_BC4_UNORM_BLOCK;
+static const type_t BC4_SNORM_BLOCK = VK_FORMAT_BC4_SNORM_BLOCK;
+static const type_t BC5_UNORM_BLOCK = VK_FORMAT_BC5_UNORM_BLOCK;
+static const type_t BC5_SNORM_BLOCK = VK_FORMAT_BC5_SNORM_BLOCK;
+static const type_t BC6H_UFLOAT_BLOCK = VK_FORMAT_BC6H_UFLOAT_BLOCK;
+static const type_t BC6H_SFLOAT_BLOCK = VK_FORMAT_BC6H_SFLOAT_BLOCK;
+static const type_t BC7_UNORM_BLOCK = VK_FORMAT_BC7_UNORM_BLOCK;
+static const type_t BC7_SRGB_BLOCK = VK_FORMAT_BC7_SRGB_BLOCK;
+static const type_t ETC2_R8G8B8_UNORM_BLOCK = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK;
+static const type_t ETC2_R8G8B8_SRGB_BLOCK = VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK;
+static const type_t ETC2_R8G8B8A1_UNORM_BLOCK = VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK;
+static const type_t ETC2_R8G8B8A1_SRGB_BLOCK = VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK;
+static const type_t ETC2_R8G8B8A8_UNORM_BLOCK = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK;
+static const type_t ETC2_R8G8B8A8_SRGB_BLOCK = VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK;
+static const type_t EAC_R11_UNORM_BLOCK = VK_FORMAT_EAC_R11_UNORM_BLOCK;
+static const type_t EAC_R11_SNORM_BLOCK = VK_FORMAT_EAC_R11_SNORM_BLOCK;
+static const type_t EAC_R11G11_UNORM_BLOCK = VK_FORMAT_EAC_R11G11_UNORM_BLOCK;
+static const type_t EAC_R11G11_SNORM_BLOCK = VK_FORMAT_EAC_R11G11_SNORM_BLOCK;
+static const type_t ASTC_4x4_UNORM_BLOCK = VK_FORMAT_ASTC_4x4_UNORM_BLOCK;
+static const type_t ASTC_4x4_SRGB_BLOCK = VK_FORMAT_ASTC_4x4_SRGB_BLOCK;
+static const type_t ASTC_5x4_UNORM_BLOCK = VK_FORMAT_ASTC_5x4_UNORM_BLOCK;
+static const type_t ASTC_5x4_SRGB_BLOCK = VK_FORMAT_ASTC_5x4_SRGB_BLOCK;
+static const type_t ASTC_5x5_UNORM_BLOCK = VK_FORMAT_ASTC_5x5_UNORM_BLOCK;
+static const type_t ASTC_5x5_SRGB_BLOCK = VK_FORMAT_ASTC_5x5_SRGB_BLOCK;
+static const type_t ASTC_6x5_UNORM_BLOCK = VK_FORMAT_ASTC_6x5_UNORM_BLOCK;
+static const type_t ASTC_6x5_SRGB_BLOCK = VK_FORMAT_ASTC_6x5_SRGB_BLOCK;
+static const type_t ASTC_6x6_UNORM_BLOCK = VK_FORMAT_ASTC_6x6_UNORM_BLOCK;
+static const type_t ASTC_6x6_SRGB_BLOCK = VK_FORMAT_ASTC_6x6_SRGB_BLOCK;
+static const type_t ASTC_8x5_UNORM_BLOCK = VK_FORMAT_ASTC_8x5_UNORM_BLOCK;
+static const type_t ASTC_8x5_SRGB_BLOCK = VK_FORMAT_ASTC_8x5_SRGB_BLOCK;
+static const type_t ASTC_8x6_UNORM_BLOCK = VK_FORMAT_ASTC_8x6_UNORM_BLOCK;
+static const type_t ASTC_8x6_SRGB_BLOCK = VK_FORMAT_ASTC_8x6_SRGB_BLOCK;
+static const type_t ASTC_8x8_UNORM_BLOCK = VK_FORMAT_ASTC_8x8_UNORM_BLOCK;
+static const type_t ASTC_8x8_SRGB_BLOCK = VK_FORMAT_ASTC_8x8_SRGB_BLOCK;
+static const type_t ASTC_10x5_UNORM_BLOCK = VK_FORMAT_ASTC_10x5_UNORM_BLOCK;
+static const type_t ASTC_10x5_SRGB_BLOCK = VK_FORMAT_ASTC_10x5_SRGB_BLOCK;
+static const type_t ASTC_10x6_UNORM_BLOCK = VK_FORMAT_ASTC_10x6_UNORM_BLOCK;
+static const type_t ASTC_10x6_SRGB_BLOCK = VK_FORMAT_ASTC_10x6_SRGB_BLOCK;
+static const type_t ASTC_10x8_UNORM_BLOCK = VK_FORMAT_ASTC_10x8_UNORM_BLOCK;
+static const type_t ASTC_10x8_SRGB_BLOCK = VK_FORMAT_ASTC_10x8_SRGB_BLOCK;
+static const type_t ASTC_10x10_UNORM_BLOCK = VK_FORMAT_ASTC_10x10_UNORM_BLOCK;
+static const type_t ASTC_10x10_SRGB_BLOCK = VK_FORMAT_ASTC_10x10_SRGB_BLOCK;
+static const type_t ASTC_12x10_UNORM_BLOCK = VK_FORMAT_ASTC_12x10_UNORM_BLOCK;
+static const type_t ASTC_12x10_SRGB_BLOCK = VK_FORMAT_ASTC_12x10_SRGB_BLOCK;
+static const type_t ASTC_12x12_UNORM_BLOCK = VK_FORMAT_ASTC_12x12_UNORM_BLOCK;
+static const type_t ASTC_12x12_SRGB_BLOCK = VK_FORMAT_ASTC_12x12_SRGB_BLOCK;
\ No newline at end of file
diff --git a/engine/inc/uf/ext/vulkan/graphic.h b/engine/inc/uf/ext/vulkan/graphic.h
new file mode 100644
index 00000000..d88ed040
--- /dev/null
+++ b/engine/inc/uf/ext/vulkan/graphic.h
@@ -0,0 +1,140 @@
+#pragma once 	
+
+#include <uf/ext/vulkan/device.h>
+#include <uf/ext/vulkan/swapchain.h>
+#include <uf/ext/vulkan/initializers.h>
+#include <uf/ext/vulkan/texture.h>
+#include <uf/utils/graphic/descriptor.h>
+#include <uf/utils/graphic/mesh.h>
+
+#define UF_GRAPHIC_POINTERED_USERDATA 1
+
+namespace ext {
+	namespace vulkan {
+		#if UF_GRAPHIC_POINTERED_USERDATA
+			typedef uf::PointeredUserdata userdata_t;
+		#else
+			typedef uf::Userdata userdata_t;
+		#endif
+
+		ext::json::Value definitionToJson(/*const*/ ext::json::Value& definition );
+		ext::vulkan::userdata_t jsonToUserdata( const ext::json::Value& payload, const ext::json::Value& definition );
+
+		struct Graphic;
+		struct UF_API Shader : public Buffers {
+			bool aliased = false;
+
+			Device* device = NULL;
+			std::string filename = "";
+
+			VkShaderModule module = VK_NULL_HANDLE;
+			VkPipelineShaderStageCreateInfo descriptor;
+			std::vector<VkDescriptorSetLayoutBinding> descriptorSetLayoutBindings;
+			std::vector<VkSpecializationMapEntry> specializationMapEntries;
+			VkSpecializationInfo specializationInfo;
+
+			uf::Serializer metadata;
+		/*
+			std::vector<uint8_t> specializationConstants;
+			std::vector<ext::vulkan::userdata_t> pushConstants;
+			std::vector<ext::vulkan::userdata_t> uniforms;
+		*/
+
+			ext::vulkan::userdata_t specializationConstants;
+			std::vector<ext::vulkan::userdata_t> pushConstants;
+			std::vector<ext::vulkan::userdata_t> uniforms;
+		//	~Shader();
+			void initialize( Device& device, const std::string&, VkShaderStageFlagBits );
+			void destroy();
+			bool validate();
+
+			bool hasUniform( const std::string& name );
+
+			Buffer* getUniformBuffer( const std::string& name );
+			ext::vulkan::userdata_t& getUniform( const std::string& name );
+			uf::Serializer getUniformJson( const std::string& name, bool cache = true );
+			ext::vulkan::userdata_t getUniformUserdata( const std::string& name, const ext::json::Value& payload );
+			bool updateUniform( const std::string& name );
+			bool updateUniform( const std::string& name, const ext::vulkan::userdata_t& );
+			bool updateUniform( const std::string& name, const ext::json::Value& payload );
+			
+			bool hasStorage( const std::string& name );
+			Buffer* getStorageBuffer( const std::string& name );
+			uf::Serializer getStorageJson( const std::string& name, bool cache = true );
+			ext::vulkan::userdata_t getStorageUserdata( const std::string& name, const ext::json::Value& payload );
+		};
+		struct UF_API Pipeline {
+			bool aliased = false;
+
+			Device* device = NULL;
+
+			VkPipeline pipeline;
+			VkPipelineLayout pipelineLayout;
+			VkDescriptorSetLayout descriptorSetLayout;
+			VkDescriptorPool descriptorPool;
+			VkDescriptorSet descriptorSet;
+			GraphicDescriptor descriptor;
+
+			void initialize( Graphic& graphic );
+			void initialize( Graphic& graphic, GraphicDescriptor& descriptor );
+			void update( Graphic& graphic );
+			void update( Graphic& graphic, GraphicDescriptor& descriptor );
+			void record( Graphic& graphic, VkCommandBuffer, size_t = 0, size_t = 0 );
+			void destroy();
+		};
+		struct UF_API Material {
+			bool aliased = false;
+			Device* device;
+
+			std::vector<Sampler> samplers;
+			std::vector<Texture2D> textures;
+			std::vector<Shader> shaders;
+			uf::Serializer metadata;
+
+			void initialize( Device& device );
+			void destroy();
+
+			void attachShader( const std::string&, VkShaderStageFlagBits );
+			void initializeShaders( const std::vector<std::pair<std::string, VkShaderStageFlagBits>>& );
+
+			bool hasShader( const std::string& type );
+			Shader& getShader( const std::string& type );
+
+			bool validate();
+		};
+		struct UF_API Graphic : public Buffers {
+			GraphicDescriptor descriptor;
+
+			bool initialized = false;
+			bool process = true;
+			Material material;
+			std::unordered_map<std::string, Pipeline> pipelines;
+
+			~Graphic();
+			void initialize( const std::string& = "" );
+			void destroy();
+			
+			template<typename T, typename U>
+			void initializeMesh( uf::BaseMesh<T, U>& mesh, size_t = SIZE_MAX );
+			void initializeGeometry( const uf::BaseGeometry& mesh );
+
+			bool hasPipeline( GraphicDescriptor& descriptor );
+			void initializePipeline();
+			Pipeline& initializePipeline( GraphicDescriptor& descriptor, bool update = true );
+			Pipeline& getPipeline();
+			Pipeline& getPipeline( GraphicDescriptor& descriptor );
+			void updatePipelines();
+			
+			void record( VkCommandBuffer commandBuffer, size_t pass = 0, size_t draw = 0 );
+			void record( VkCommandBuffer commandBuffer, GraphicDescriptor& descriptor, size_t pass = 0, size_t draw = 0 );
+
+			bool hasStorage( const std::string& name );
+			Buffer* getStorageBuffer( const std::string& name );
+			uf::Serializer getStorageJson( const std::string& name, bool cache = true );
+			ext::vulkan::userdata_t getStorageUserdata( const std::string& name, const ext::json::Value& payload );
+		};
+	}
+}
+
+
+#include "graphic.inl"
\ No newline at end of file
diff --git a/engine/inc/uf/ext/vulkan/graphic.inl b/engine/inc/uf/ext/vulkan/graphic.inl
new file mode 100644
index 00000000..bd305836
--- /dev/null
+++ b/engine/inc/uf/ext/vulkan/graphic.inl
@@ -0,0 +1,6 @@
+template<typename T, typename U>
+void ext::vulkan::Graphic::initializeMesh( uf::BaseMesh<T, U>& mesh, size_t o ) {
+	if ( mesh.indices.empty() ) mesh.initialize( o );
+	mesh.updateDescriptor();
+	initializeGeometry( mesh );
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/vulkan/initializers.h b/engine/inc/uf/ext/vulkan/initializers.h
new file mode 100644
index 00000000..74150c32
--- /dev/null
+++ b/engine/inc/uf/ext/vulkan/initializers.h
@@ -0,0 +1,558 @@
+#pragma once
+
+#include <uf/ext/vulkan/vk.h>
+#include <vector>
+
+namespace ext {
+	namespace vulkan {
+		namespace initializers {
+			inline VkMemoryAllocateInfo memoryAllocateInfo() {
+				VkMemoryAllocateInfo memAllocInfo {};
+				memAllocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
+				return memAllocInfo;
+			}
+
+			inline VkMappedMemoryRange mappedMemoryRange() {
+				VkMappedMemoryRange mappedMemoryRange {};
+				mappedMemoryRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
+				return mappedMemoryRange;
+			}
+
+			inline VkCommandBufferAllocateInfo commandBufferAllocateInfo(
+				VkCommandPool commandPool, 
+				VkCommandBufferLevel level, 
+				uint32_t bufferCount)
+			{
+				VkCommandBufferAllocateInfo commandBufferAllocateInfo {};
+				commandBufferAllocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
+				commandBufferAllocateInfo.commandPool = commandPool;
+				commandBufferAllocateInfo.level = level;
+				commandBufferAllocateInfo.commandBufferCount = bufferCount;
+				return commandBufferAllocateInfo;
+			}
+
+			inline VkCommandPoolCreateInfo commandPoolCreateInfo() {
+				VkCommandPoolCreateInfo cmdPoolCreateInfo {};
+				cmdPoolCreateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
+				return cmdPoolCreateInfo;
+			}
+
+			inline VkCommandBufferBeginInfo commandBufferBeginInfo() {
+				VkCommandBufferBeginInfo cmdBufferBeginInfo {};
+				cmdBufferBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+				return cmdBufferBeginInfo;
+			}
+
+			inline VkCommandBufferInheritanceInfo commandBufferInheritanceInfo() {
+				VkCommandBufferInheritanceInfo cmdBufferInheritanceInfo {};
+				cmdBufferInheritanceInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO;
+				return cmdBufferInheritanceInfo;
+			}
+
+			inline VkRenderPassBeginInfo renderPassBeginInfo() {
+				VkRenderPassBeginInfo renderPassBeginInfo {};
+				renderPassBeginInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
+				return renderPassBeginInfo;
+			}
+
+			inline VkRenderPassCreateInfo renderPassCreateInfo() {
+				VkRenderPassCreateInfo renderPassCreateInfo {};
+				renderPassCreateInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
+				return renderPassCreateInfo;
+			}
+
+			/** @brief Initialize an image memory barrier with no image transfer ownership */
+			inline VkImageMemoryBarrier imageMemoryBarrier() {
+				VkImageMemoryBarrier imageMemoryBarrier {};
+				imageMemoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+				imageMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+				imageMemoryBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+				return imageMemoryBarrier;
+			}
+
+			/** @brief Initialize a buffer memory barrier with no image transfer ownership */
+			inline VkBufferMemoryBarrier bufferMemoryBarrier() {
+				VkBufferMemoryBarrier bufferMemoryBarrier {};
+				bufferMemoryBarrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
+				bufferMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+				bufferMemoryBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+				return bufferMemoryBarrier;
+			}
+
+			inline VkMemoryBarrier memoryBarrier() {
+				VkMemoryBarrier memoryBarrier {};
+				memoryBarrier.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER;
+				return memoryBarrier;
+			}
+
+			inline VkImageCreateInfo imageCreateInfo() {
+				VkImageCreateInfo imageCreateInfo {};
+				imageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
+				return imageCreateInfo;
+			}
+
+			inline VkSamplerCreateInfo samplerCreateInfo() {
+				VkSamplerCreateInfo samplerCreateInfo {};
+				samplerCreateInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
+				samplerCreateInfo.maxAnisotropy = 1.0f;
+				return samplerCreateInfo;
+			}
+
+			inline VkImageViewCreateInfo imageViewCreateInfo() {
+				VkImageViewCreateInfo imageViewCreateInfo {};
+				imageViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+				return imageViewCreateInfo;
+			}
+
+			inline VkFramebufferCreateInfo framebufferCreateInfo() {
+				VkFramebufferCreateInfo framebufferCreateInfo {};
+				framebufferCreateInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
+				return framebufferCreateInfo;
+			}
+
+			inline VkSemaphoreCreateInfo semaphoreCreateInfo() {
+				VkSemaphoreCreateInfo semaphoreCreateInfo {};
+				semaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
+				return semaphoreCreateInfo;
+			}
+
+			inline VkFenceCreateInfo fenceCreateInfo( VkFenceCreateFlags flags = 0 ) {
+				VkFenceCreateInfo fenceCreateInfo {};
+				fenceCreateInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
+				fenceCreateInfo.flags = flags;
+				return fenceCreateInfo;
+			}
+
+			inline VkEventCreateInfo eventCreateInfo() {
+				VkEventCreateInfo eventCreateInfo {};
+				eventCreateInfo.sType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO;
+				return eventCreateInfo;
+			}
+
+			inline VkSubmitInfo submitInfo() {
+				VkSubmitInfo submitInfo {};
+				submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+				return submitInfo;
+			}
+
+			inline VkViewport viewport(
+				float width,
+				float height,
+				float minDepth,
+				float maxDepth)
+			{
+				VkViewport viewport {};
+				viewport.width = width;
+				viewport.height = height;
+				viewport.minDepth = minDepth;
+				viewport.maxDepth = maxDepth;
+				return viewport;
+			}
+
+			inline VkRect2D rect2D(
+				int32_t width,
+				int32_t height,
+				int32_t offsetX,
+				int32_t offsetY)
+			{
+				VkRect2D rect2D {};
+				rect2D.extent.width = width;
+				rect2D.extent.height = height;
+				rect2D.offset.x = offsetX;
+				rect2D.offset.y = offsetY;
+				return rect2D;
+			}
+
+			inline VkBufferCreateInfo bufferCreateInfo() {
+				VkBufferCreateInfo bufCreateInfo {};
+				bufCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+				return bufCreateInfo;
+			}
+
+			inline VkBufferCreateInfo bufferCreateInfo(
+				VkBufferUsageFlags usage,
+				VkDeviceSize size)
+			{
+				VkBufferCreateInfo bufCreateInfo {};
+				bufCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+				bufCreateInfo.usage = usage;
+				bufCreateInfo.size = size;
+				return bufCreateInfo;
+			}
+
+			inline VkDescriptorPoolCreateInfo descriptorPoolCreateInfo(
+				uint32_t poolSizeCount,
+				VkDescriptorPoolSize* pPoolSizes,
+				uint32_t maxSets)
+			{
+				VkDescriptorPoolCreateInfo descriptorPoolInfo {};
+				descriptorPoolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
+				descriptorPoolInfo.poolSizeCount = poolSizeCount;
+				descriptorPoolInfo.pPoolSizes = pPoolSizes;
+				descriptorPoolInfo.maxSets = maxSets;
+				return descriptorPoolInfo;
+			}
+
+			inline VkDescriptorPoolCreateInfo descriptorPoolCreateInfo(
+				const std::vector<VkDescriptorPoolSize>& poolSizes,
+				uint32_t maxSets)
+			{
+				VkDescriptorPoolCreateInfo descriptorPoolInfo{};
+				descriptorPoolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
+				descriptorPoolInfo.poolSizeCount = static_cast<uint32_t>(poolSizes.size());
+				descriptorPoolInfo.pPoolSizes = poolSizes.data();
+				descriptorPoolInfo.maxSets = maxSets;
+				return descriptorPoolInfo;
+			}
+
+			inline VkDescriptorPoolSize descriptorPoolSize(
+				VkDescriptorType type,
+				uint32_t descriptorCount)
+			{
+				VkDescriptorPoolSize descriptorPoolSize {};
+				descriptorPoolSize.type = type;
+				descriptorPoolSize.descriptorCount = descriptorCount;
+				return descriptorPoolSize;
+			}
+
+			inline VkDescriptorSetLayoutBinding descriptorSetLayoutBinding(
+				VkDescriptorType type,
+				VkShaderStageFlags stageFlags,
+				uint32_t binding,
+				uint32_t descriptorCount = 1)
+			{
+				VkDescriptorSetLayoutBinding setLayoutBinding {};
+				setLayoutBinding.descriptorType = type;
+				setLayoutBinding.stageFlags = stageFlags;
+				setLayoutBinding.binding = binding;
+				setLayoutBinding.descriptorCount = descriptorCount;
+				return setLayoutBinding;
+			}
+
+			inline VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCreateInfo(
+				const VkDescriptorSetLayoutBinding* pBindings,
+				uint32_t bindingCount)
+			{
+				VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCreateInfo {};
+				descriptorSetLayoutCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
+				descriptorSetLayoutCreateInfo.pBindings = pBindings;
+				descriptorSetLayoutCreateInfo.bindingCount = bindingCount;
+				return descriptorSetLayoutCreateInfo;
+			}
+
+			inline VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCreateInfo(
+				const std::vector<VkDescriptorSetLayoutBinding>& bindings)
+			{
+				VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCreateInfo{};
+				descriptorSetLayoutCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
+				descriptorSetLayoutCreateInfo.pBindings = bindings.data();
+				descriptorSetLayoutCreateInfo.bindingCount = static_cast<uint32_t>(bindings.size());
+				return descriptorSetLayoutCreateInfo;
+			}
+
+			inline VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo(
+				const VkDescriptorSetLayout* pSetLayouts,
+				uint32_t setLayoutCount = 1)
+			{
+				VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo {};
+				pipelineLayoutCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
+				pipelineLayoutCreateInfo.setLayoutCount = setLayoutCount;
+				pipelineLayoutCreateInfo.pSetLayouts = pSetLayouts;
+				return pipelineLayoutCreateInfo;
+			}
+
+			inline VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo(
+				uint32_t setLayoutCount = 1)
+			{
+				VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo{};
+				pipelineLayoutCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
+				pipelineLayoutCreateInfo.setLayoutCount = setLayoutCount;
+				return pipelineLayoutCreateInfo;
+			}
+
+			inline VkDescriptorSetAllocateInfo descriptorSetAllocateInfo(
+				VkDescriptorPool descriptorPool,
+				const VkDescriptorSetLayout* pSetLayouts,
+				uint32_t descriptorSetCount)
+			{
+				VkDescriptorSetAllocateInfo descriptorSetAllocateInfo {};
+				descriptorSetAllocateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
+				descriptorSetAllocateInfo.descriptorPool = descriptorPool;
+				descriptorSetAllocateInfo.pSetLayouts = pSetLayouts;
+				descriptorSetAllocateInfo.descriptorSetCount = descriptorSetCount;
+				return descriptorSetAllocateInfo;
+			}
+
+			inline VkDescriptorImageInfo descriptorImageInfo(VkImageView imageView, VkImageLayout imageLayout, VkSampler sampler = VK_NULL_HANDLE)
+			{
+				VkDescriptorImageInfo descriptorImageInfo {};
+				descriptorImageInfo.sampler = sampler;
+				descriptorImageInfo.imageView = imageView;
+				descriptorImageInfo.imageLayout = imageLayout;
+				return descriptorImageInfo;
+			}
+
+			inline VkWriteDescriptorSet writeDescriptorSet(
+				VkDescriptorSet dstSet,
+				VkDescriptorType type,
+				uint32_t binding,
+				VkDescriptorBufferInfo* bufferInfo,
+				uint32_t descriptorCount = 1)
+			{
+				VkWriteDescriptorSet writeDescriptorSet {};
+				writeDescriptorSet.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+				writeDescriptorSet.dstSet = dstSet;
+				writeDescriptorSet.descriptorType = type;
+				writeDescriptorSet.dstBinding = binding;
+				writeDescriptorSet.pBufferInfo = bufferInfo;
+				writeDescriptorSet.descriptorCount = descriptorCount;
+				return writeDescriptorSet;
+			}
+
+			inline VkWriteDescriptorSet writeDescriptorSet(
+				VkDescriptorSet dstSet,
+				VkDescriptorType type,
+				uint32_t binding,
+				VkDescriptorImageInfo *imageInfo,
+				uint32_t descriptorCount = 1)
+			{
+				VkWriteDescriptorSet writeDescriptorSet {};
+				writeDescriptorSet.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+				writeDescriptorSet.dstSet = dstSet;
+				writeDescriptorSet.descriptorType = type;
+				writeDescriptorSet.dstBinding = binding;
+				writeDescriptorSet.pImageInfo = imageInfo;
+				writeDescriptorSet.descriptorCount = descriptorCount;
+				return writeDescriptorSet;
+			}
+
+			inline VkVertexInputBindingDescription vertexInputBindingDescription(
+				uint32_t binding,
+				uint32_t stride,
+				VkVertexInputRate inputRate)
+			{
+				VkVertexInputBindingDescription vInputBindDescription {};
+				vInputBindDescription.binding = binding;
+				vInputBindDescription.stride = stride;
+				vInputBindDescription.inputRate = inputRate;
+				return vInputBindDescription;
+			}
+
+			inline VkVertexInputAttributeDescription vertexInputAttributeDescription(
+				uint32_t binding,
+				uint32_t location,
+				VkFormat format,
+				uint32_t offset)
+			{
+				VkVertexInputAttributeDescription vInputAttribDescription {};
+				vInputAttribDescription.location = location;
+				vInputAttribDescription.binding = binding;
+				vInputAttribDescription.format = format;
+				vInputAttribDescription.offset = offset;
+				return vInputAttribDescription;
+			}
+
+			inline VkPipelineVertexInputStateCreateInfo pipelineVertexInputStateCreateInfo() {
+				VkPipelineVertexInputStateCreateInfo pipelineVertexInputStateCreateInfo {};
+				pipelineVertexInputStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
+				return pipelineVertexInputStateCreateInfo;
+			}
+
+			inline VkPipelineInputAssemblyStateCreateInfo pipelineInputAssemblyStateCreateInfo(
+				VkPrimitiveTopology topology,
+				VkPipelineInputAssemblyStateCreateFlags flags,
+				VkBool32 primitiveRestartEnable)
+			{
+				VkPipelineInputAssemblyStateCreateInfo pipelineInputAssemblyStateCreateInfo {};
+				pipelineInputAssemblyStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
+				pipelineInputAssemblyStateCreateInfo.topology = topology;
+				pipelineInputAssemblyStateCreateInfo.flags = flags;
+				pipelineInputAssemblyStateCreateInfo.primitiveRestartEnable = primitiveRestartEnable;
+				return pipelineInputAssemblyStateCreateInfo;
+			}
+
+			inline VkPipelineRasterizationStateCreateInfo pipelineRasterizationStateCreateInfo(
+				VkPolygonMode polygonMode,
+				VkCullModeFlags cullMode,
+				VkFrontFace frontFace,
+				VkPipelineRasterizationStateCreateFlags flags = 0)
+			{
+				VkPipelineRasterizationStateCreateInfo pipelineRasterizationStateCreateInfo {};
+				pipelineRasterizationStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
+				pipelineRasterizationStateCreateInfo.polygonMode = polygonMode;
+				pipelineRasterizationStateCreateInfo.cullMode = cullMode;
+				pipelineRasterizationStateCreateInfo.frontFace = frontFace;
+				pipelineRasterizationStateCreateInfo.flags = flags;
+				pipelineRasterizationStateCreateInfo.depthClampEnable = VK_FALSE;
+				pipelineRasterizationStateCreateInfo.lineWidth = 1.0f;
+				return pipelineRasterizationStateCreateInfo;
+			}
+
+			inline VkPipelineColorBlendAttachmentState pipelineColorBlendAttachmentState(
+				VkColorComponentFlags colorWriteMask,
+				VkBool32 blendEnable)
+			{
+				VkPipelineColorBlendAttachmentState pipelineColorBlendAttachmentState {};
+				pipelineColorBlendAttachmentState.colorWriteMask = colorWriteMask;
+				pipelineColorBlendAttachmentState.blendEnable = blendEnable;
+				return pipelineColorBlendAttachmentState;
+			}
+
+			inline VkPipelineColorBlendStateCreateInfo pipelineColorBlendStateCreateInfo(
+				uint32_t attachmentCount,
+				const VkPipelineColorBlendAttachmentState * pAttachments)
+			{
+				VkPipelineColorBlendStateCreateInfo pipelineColorBlendStateCreateInfo {};
+				pipelineColorBlendStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
+				pipelineColorBlendStateCreateInfo.attachmentCount = attachmentCount;
+				pipelineColorBlendStateCreateInfo.pAttachments = pAttachments;
+				return pipelineColorBlendStateCreateInfo;
+			}
+
+			inline VkPipelineDepthStencilStateCreateInfo pipelineDepthStencilStateCreateInfo(
+				VkBool32 depthTestEnable,
+				VkBool32 depthWriteEnable,
+				VkCompareOp depthCompareOp)
+			{
+				VkPipelineDepthStencilStateCreateInfo pipelineDepthStencilStateCreateInfo {};
+				pipelineDepthStencilStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
+				pipelineDepthStencilStateCreateInfo.depthTestEnable = depthTestEnable;
+				pipelineDepthStencilStateCreateInfo.depthWriteEnable = depthWriteEnable;
+				pipelineDepthStencilStateCreateInfo.depthCompareOp = depthCompareOp;
+				pipelineDepthStencilStateCreateInfo.front = pipelineDepthStencilStateCreateInfo.back;
+				pipelineDepthStencilStateCreateInfo.back.compareOp = VK_COMPARE_OP_ALWAYS;
+				return pipelineDepthStencilStateCreateInfo;
+			}
+
+			inline VkPipelineViewportStateCreateInfo pipelineViewportStateCreateInfo(
+				uint32_t viewportCount,
+				uint32_t scissorCount,
+				VkPipelineViewportStateCreateFlags flags = 0)
+			{
+				VkPipelineViewportStateCreateInfo pipelineViewportStateCreateInfo {};
+				pipelineViewportStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
+				pipelineViewportStateCreateInfo.viewportCount = viewportCount;
+				pipelineViewportStateCreateInfo.scissorCount = scissorCount;
+				pipelineViewportStateCreateInfo.flags = flags;
+				return pipelineViewportStateCreateInfo;
+			}
+
+			inline VkPipelineMultisampleStateCreateInfo pipelineMultisampleStateCreateInfo(
+				VkSampleCountFlagBits rasterizationSamples,
+				VkPipelineMultisampleStateCreateFlags flags = 0)
+			{
+				VkPipelineMultisampleStateCreateInfo pipelineMultisampleStateCreateInfo {};
+				pipelineMultisampleStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
+				pipelineMultisampleStateCreateInfo.rasterizationSamples = rasterizationSamples;
+				pipelineMultisampleStateCreateInfo.flags = flags;
+				return pipelineMultisampleStateCreateInfo;
+			}
+
+			inline VkPipelineDynamicStateCreateInfo pipelineDynamicStateCreateInfo(
+				const VkDynamicState * pDynamicStates,
+				uint32_t dynamicStateCount,
+				VkPipelineDynamicStateCreateFlags flags = 0)
+			{
+				VkPipelineDynamicStateCreateInfo pipelineDynamicStateCreateInfo {};
+				pipelineDynamicStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
+				pipelineDynamicStateCreateInfo.pDynamicStates = pDynamicStates;
+				pipelineDynamicStateCreateInfo.dynamicStateCount = dynamicStateCount;
+				pipelineDynamicStateCreateInfo.flags = flags;
+				return pipelineDynamicStateCreateInfo;
+			}
+
+			inline VkPipelineDynamicStateCreateInfo pipelineDynamicStateCreateInfo(
+				const std::vector<VkDynamicState>& pDynamicStates,
+				VkPipelineDynamicStateCreateFlags flags = 0)
+			{
+				VkPipelineDynamicStateCreateInfo pipelineDynamicStateCreateInfo{};
+				pipelineDynamicStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
+				pipelineDynamicStateCreateInfo.pDynamicStates = pDynamicStates.data();
+				pipelineDynamicStateCreateInfo.dynamicStateCount = static_cast<uint32_t>(pDynamicStates.size());
+				pipelineDynamicStateCreateInfo.flags = flags;
+				return pipelineDynamicStateCreateInfo;
+			}
+
+			inline VkPipelineTessellationStateCreateInfo pipelineTessellationStateCreateInfo(uint32_t patchControlPoints)
+			{
+				VkPipelineTessellationStateCreateInfo pipelineTessellationStateCreateInfo {};
+				pipelineTessellationStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO;
+				pipelineTessellationStateCreateInfo.patchControlPoints = patchControlPoints;
+				return pipelineTessellationStateCreateInfo;
+			}
+
+			inline VkGraphicsPipelineCreateInfo pipelineCreateInfo(
+				VkPipelineLayout layout,
+				VkRenderPass renderPass,
+				VkPipelineCreateFlags flags = 0)
+			{
+				VkGraphicsPipelineCreateInfo pipelineCreateInfo {};
+				pipelineCreateInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
+				pipelineCreateInfo.layout = layout;
+				pipelineCreateInfo.renderPass = renderPass;
+				pipelineCreateInfo.flags = flags;
+				pipelineCreateInfo.basePipelineIndex = -1;
+				pipelineCreateInfo.basePipelineHandle = VK_NULL_HANDLE;
+				return pipelineCreateInfo;
+			}
+
+			inline VkGraphicsPipelineCreateInfo pipelineCreateInfo() {
+				VkGraphicsPipelineCreateInfo pipelineCreateInfo{};
+				pipelineCreateInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
+				pipelineCreateInfo.basePipelineIndex = -1;
+				pipelineCreateInfo.basePipelineHandle = VK_NULL_HANDLE;
+				return pipelineCreateInfo;
+			}
+
+			inline VkComputePipelineCreateInfo computePipelineCreateInfo(
+				VkPipelineLayout layout, 
+				VkPipelineCreateFlags flags = 0)
+			{
+				VkComputePipelineCreateInfo computePipelineCreateInfo {};
+				computePipelineCreateInfo.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO;
+				computePipelineCreateInfo.layout = layout;
+				computePipelineCreateInfo.flags = flags;
+				return computePipelineCreateInfo;
+			}
+
+			inline VkPushConstantRange pushConstantRange(
+				VkShaderStageFlags stageFlags,
+				uint32_t size,
+				uint32_t offset)
+			{
+				VkPushConstantRange pushConstantRange {};
+				pushConstantRange.stageFlags = stageFlags;
+				pushConstantRange.offset = offset;
+				pushConstantRange.size = size;
+				return pushConstantRange;
+			}
+
+			inline VkBindSparseInfo bindSparseInfo() {
+				VkBindSparseInfo bindSparseInfo{};
+				bindSparseInfo.sType = VK_STRUCTURE_TYPE_BIND_SPARSE_INFO;
+				return bindSparseInfo;
+			}
+
+			/** @brief Initialize a map entry for a shader specialization constant */
+			inline VkSpecializationMapEntry specializationMapEntry(uint32_t constantID, uint32_t offset, size_t size)
+			{
+				VkSpecializationMapEntry specializationMapEntry{};
+				specializationMapEntry.constantID = constantID;
+				specializationMapEntry.offset = offset;
+				specializationMapEntry.size = size;
+				return specializationMapEntry;
+			}
+
+			/** @brief Initialize a specialization constant info structure to pass to a shader stage */
+			inline VkSpecializationInfo specializationInfo(uint32_t mapEntryCount, const VkSpecializationMapEntry* mapEntries, size_t dataSize, const void* data)
+			{
+				VkSpecializationInfo specializationInfo{};
+				specializationInfo.mapEntryCount = mapEntryCount;
+				specializationInfo.pMapEntries = mapEntries;
+				specializationInfo.dataSize = dataSize;
+				specializationInfo.pData = data;
+				return specializationInfo;
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/vulkan/rendermode.h b/engine/inc/uf/ext/vulkan/rendermode.h
new file mode 100644
index 00000000..082ed589
--- /dev/null
+++ b/engine/inc/uf/ext/vulkan/rendermode.h
@@ -0,0 +1,56 @@
+#pragma once
+
+#include <uf/utils/graphic/descriptor.h>
+#include <uf/ext/vulkan/device.h>
+
+namespace ext {
+	namespace vulkan {
+		struct Graphic;
+		
+		struct UF_API RenderMode {
+			bool execute = false;
+			bool rebuild = false;
+			uint32_t width = 0;
+			uint32_t height = 0;
+			uf::Serializer metadata;
+			
+			Device* device = VK_NULL_HANDLE;
+			RenderTarget renderTarget;
+
+			VkSemaphore renderCompleteSemaphore;
+			std::vector<VkFence> fences;
+			
+			typedef std::vector<VkCommandBuffer> commands_container_t;
+			std::thread::id mostRecentCommandPoolId;
+			uf::ThreadUnique<commands_container_t> commands;
+
+			virtual ~RenderMode();
+			// RAII
+			virtual const std::string getName() const;
+			virtual const std::string getType() const;
+			virtual RenderTarget& getRenderTarget(size_t = 0);
+			virtual const RenderTarget& getRenderTarget(size_t = 0) const;
+
+			virtual const size_t blitters() const;
+			virtual ext::vulkan::Graphic* getBlitter(size_t = 0);
+			virtual std::vector<ext::vulkan::Graphic*> getBlitters();
+
+			virtual commands_container_t& getCommands();
+			virtual commands_container_t& getCommands( std::thread::id );
+
+			virtual GraphicDescriptor bindGraphicDescriptor( const GraphicDescriptor&, size_t = 0 );
+			virtual void bindGraphicPushConstants( ext::vulkan::Graphic*, size_t = 0 );
+			
+			virtual void initialize( Device& device );
+			virtual void createCommandBuffers();
+			virtual void createCommandBuffers( const std::vector<ext::vulkan::Graphic*>& graphics );
+			virtual void bindPipelines();
+			virtual void bindPipelines( const std::vector<ext::vulkan::Graphic*>& graphics );
+			virtual void tick();
+			virtual void render();
+			virtual void destroy();
+			virtual void synchronize( uint64_t = UINT64_MAX );
+			virtual void pipelineBarrier( VkCommandBuffer, uint8_t = -1 );
+		};
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/vulkan/rendermodes/base.h b/engine/inc/uf/ext/vulkan/rendermodes/base.h
new file mode 100644
index 00000000..f39c4978
--- /dev/null
+++ b/engine/inc/uf/ext/vulkan/rendermodes/base.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <uf/ext/vulkan/rendermode.h>
+
+namespace ext {
+	namespace vulkan {
+		struct UF_API BaseRenderMode : RenderMode {
+			// virtual ~RenderMode();
+			// RAII
+			virtual const std::string getType() const;
+			
+			virtual void initialize( Device& device );
+			virtual void createCommandBuffers( const std::vector<ext::vulkan::Graphic*>& graphics );
+			virtual void tick();
+			virtual void render();
+			virtual void destroy();
+		};
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/vulkan/rendermodes/compute.h b/engine/inc/uf/ext/vulkan/rendermodes/compute.h
new file mode 100644
index 00000000..6736116e
--- /dev/null
+++ b/engine/inc/uf/ext/vulkan/rendermodes/compute.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <uf/ext/vulkan/rendermode.h>
+#include <uf/ext/vulkan/graphic.h>
+
+namespace ext {
+	namespace vulkan {
+		struct UF_API ComputeRenderMode : public ext::vulkan::RenderMode {
+			ext::vulkan::Graphic blitter, compute;
+			pod::Vector2ui dispatchSize = { 32, 32 };
+
+			// RAII
+			virtual const std::string getType() const;
+			virtual const size_t blitters() const;
+			virtual ext::vulkan::Graphic* getBlitter(size_t = 0);
+			virtual std::vector<ext::vulkan::Graphic*> getBlitters();
+			
+			virtual void createCommandBuffers();
+			virtual void initialize( Device& device );
+			virtual void tick();
+			virtual void render();
+			virtual void destroy();
+			virtual void bindPipelines();
+			virtual void pipelineBarrier( VkCommandBuffer, uint8_t = -1 );
+		};
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/vulkan/rendermodes/deferred.h b/engine/inc/uf/ext/vulkan/rendermodes/deferred.h
new file mode 100644
index 00000000..52f15b2f
--- /dev/null
+++ b/engine/inc/uf/ext/vulkan/rendermodes/deferred.h
@@ -0,0 +1,23 @@
+#pragma once
+
+#include <uf/ext/vulkan/rendermode.h>
+#include <uf/ext/vulkan/graphic.h>
+
+namespace ext {
+	namespace vulkan {
+		struct UF_API DeferredRenderMode : public ext::vulkan::RenderMode {
+			ext::vulkan::Graphic blitter;
+
+			// RAII
+			virtual const std::string getType() const;
+			virtual const size_t blitters() const;
+			virtual ext::vulkan::Graphic* getBlitter(size_t = 0);
+			virtual std::vector<ext::vulkan::Graphic*> getBlitters();
+			
+			virtual void createCommandBuffers( const std::vector<ext::vulkan::Graphic*>& graphics );
+			virtual void initialize( Device& device );
+			virtual void tick();
+			virtual void destroy();
+		};
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/vulkan/rendermodes/rendertarget.h b/engine/inc/uf/ext/vulkan/rendermodes/rendertarget.h
new file mode 100644
index 00000000..7f6dbce5
--- /dev/null
+++ b/engine/inc/uf/ext/vulkan/rendermodes/rendertarget.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <uf/ext/vulkan/rendermode.h>
+#include <uf/ext/vulkan/graphic.h>
+
+namespace ext {
+	namespace vulkan {
+		struct UF_API RenderTargetRenderMode : public ext::vulkan::RenderMode {
+			ext::vulkan::Graphic blitter;		
+			//
+			const std::string getTarget() const;
+			void setTarget( const std::string& );
+
+			// RAII
+			virtual const std::string getType() const;
+			virtual const size_t blitters() const;
+			virtual ext::vulkan::Graphic* getBlitter(size_t = 0);
+			virtual std::vector<ext::vulkan::Graphic*> getBlitters();
+
+			virtual GraphicDescriptor bindGraphicDescriptor( const GraphicDescriptor&, size_t = 0 );
+			
+			virtual void createCommandBuffers( const std::vector<ext::vulkan::Graphic*>& graphics );
+			virtual void initialize( Device& device );
+			virtual void tick();
+			virtual void destroy();
+			virtual void render();
+			virtual void pipelineBarrier( VkCommandBuffer, uint8_t = -1 );
+		};
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/vulkan/rendertarget.h b/engine/inc/uf/ext/vulkan/rendertarget.h
new file mode 100644
index 00000000..6bdb29d9
--- /dev/null
+++ b/engine/inc/uf/ext/vulkan/rendertarget.h
@@ -0,0 +1,53 @@
+#pragma once
+
+#include <uf/ext/vulkan/device.h>
+
+namespace ext {
+	namespace vulkan {
+		struct UF_API RenderTarget {
+			struct Attachment {
+				struct Descriptor {
+					VkFormat format;
+					VkImageLayout layout;
+					VkImageUsageFlags usage;
+					bool blend = false;
+					uint8_t samples = 1;
+					bool aliased = false;
+				} descriptor;
+
+				VkImage image;
+				VkDeviceMemory mem;
+				VkImageView view;
+				VmaAllocation allocation;
+				VmaAllocationInfo allocationInfo;
+				VkPipelineColorBlendAttachmentState blendState;
+			};
+			std::vector<Attachment> attachments;
+
+			struct Subpass {
+				VkPipelineStageFlags stage;
+				VkAccessFlags access;
+				bool autoBuildPipeline;
+
+				std::vector<VkAttachmentReference> colors;
+				std::vector<VkAttachmentReference> inputs;
+				std::vector<VkAttachmentReference> resolves;
+				VkAttachmentReference depth;
+			};
+			std::vector<Subpass> passes;
+
+			bool initialized = false;
+			Device* device = VK_NULL_HANDLE;
+			VkRenderPass renderPass = VK_NULL_HANDLE;
+			std::vector<VkFramebuffer> framebuffers;
+			uint32_t width = 0;
+			uint32_t height = 0;
+			uint8_t views = 1;
+			// RAII
+			void initialize( Device& device );
+			void destroy();
+			void addPass( VkPipelineStageFlags, VkAccessFlags, const std::vector<size_t>&, const std::vector<size_t>&, const std::vector<size_t>&, size_t, bool = true  );
+			size_t attach( const Attachment::Descriptor& descriptor, Attachment* attachment = NULL );
+		};
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/vulkan/swapchain.h b/engine/inc/uf/ext/vulkan/swapchain.h
new file mode 100644
index 00000000..9e35b9cd
--- /dev/null
+++ b/engine/inc/uf/ext/vulkan/swapchain.h
@@ -0,0 +1,28 @@
+#pragma once
+
+#include <uf/ext/vulkan/device.h>
+#include <uf/ext/vulkan/rendertarget.h>
+
+namespace ext {
+	namespace vulkan {
+		struct UF_API Swapchain {
+			Device* device = nullptr;
+			VkSurfaceKHR surface;
+			VkSwapchainKHR swapChain = VK_NULL_HANDLE;
+
+			bool initialized = false;
+			uint32_t buffers;
+
+			VkSemaphore presentCompleteSemaphore;
+			VkSemaphore renderCompleteSemaphore;
+
+			// helpers
+			VkResult acquireNextImage( uint32_t* imageIndex, VkSemaphore );
+			VkResult queuePresent( VkQueue queue, uint32_t imageIndex, VkSemaphore waitSemaphore = VK_NULL_HANDLE );
+			
+			// RAII
+			void initialize( Device& device );
+			void destroy();
+		};
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/vulkan/texture.h b/engine/inc/uf/ext/vulkan/texture.h
new file mode 100644
index 00000000..df41ed06
--- /dev/null
+++ b/engine/inc/uf/ext/vulkan/texture.h
@@ -0,0 +1,141 @@
+#pragma once
+
+#include <uf/ext/vulkan/enums.h>
+#include <uf/ext/vulkan/device.h>
+#include <uf/ext/vulkan/rendertarget.h>
+#include <uf/utils/image/image.h>
+
+namespace ext {
+	namespace vulkan {
+		struct UF_API Sampler {
+			Device* device = NULL;
+
+			VkSampler sampler;
+			struct {
+				struct {
+					VkFilter min = VK_FILTER_LINEAR;
+					VkFilter mag = VK_FILTER_LINEAR;
+					VkBorderColor borderColor = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
+				} filter;
+				struct {
+					VkSamplerAddressMode u = VK_SAMPLER_ADDRESS_MODE_REPEAT, v = VK_SAMPLER_ADDRESS_MODE_REPEAT, w = VK_SAMPLER_ADDRESS_MODE_REPEAT;
+					VkBool32 unnormalizedCoordinates = VK_FALSE;
+				} addressMode;
+				struct {
+					VkBool32 compareEnable = VK_FALSE;
+					VkCompareOp compareOp = VK_COMPARE_OP_ALWAYS;
+					VkSamplerMipmapMode mode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
+					float lodBias = 0.0f;
+					float min = 0.0f;
+					float max = 0.0f;
+				} mip;
+				struct {
+					VkBool32 enabled = VK_TRUE;
+					float max = 16.0f;
+				} anisotropy;
+				VkDescriptorImageInfo info;
+			} descriptor;
+
+			void initialize( Device& device );
+			void destroy();
+		};
+		struct UF_API Texture {
+			Device* device = nullptr;
+
+			VkImage image;
+			VkImageView view;
+			VkImageType type = enums::Image::TYPE_2D;
+			VkImageViewType viewType = enums::Image::VIEW_TYPE_2D;
+			VkImageLayout imageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+			VkDeviceMemory deviceMemory;
+			VkDescriptorImageInfo descriptor;
+			VkFormat format = enums::Format::R8G8B8A8_UNORM;;
+			
+			Sampler sampler;
+
+			VmaAllocation allocation;
+			VmaAllocationInfo allocationInfo;
+
+			uint32_t width, height, depth, layers;
+			uint32_t mips = 1;
+			// RAII
+			void initialize( Device& device, size_t width, size_t height, size_t depth = 1, size_t layers = 1 );
+			void initialize( Device& device, VkImageViewType, size_t width, size_t height, size_t depth = 1, size_t layers = 1 );
+			void updateDescriptors();
+			void destroy();
+			bool generated() const;
+			static void setImageLayout(
+				VkCommandBuffer cmdbuffer,
+				VkImage image,
+				VkImageLayout oldImageLayout,
+				VkImageLayout newImageLayout,
+				VkImageSubresourceRange subresourceRange
+			);
+			static void setImageLayout(
+				VkCommandBuffer cmdbuffer,
+				VkImage image,
+				VkImageAspectFlags aspectMask,
+				VkImageLayout oldImageLayout,
+				VkImageLayout newImageLayout,
+				uint32_t mipLevels
+			);
+			void loadFromFile(
+				const std::string& filename, 
+				VkFormat format = VK_FORMAT_R8G8B8A8_UNORM,
+				VkImageUsageFlags imageUsageFlags = VK_IMAGE_USAGE_SAMPLED_BIT,
+				VkImageLayout imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
+			);
+			void loadFromFile(
+				const std::string& filename, 
+				Device& device,
+				VkFormat format = VK_FORMAT_R8G8B8A8_UNORM,
+				VkImageUsageFlags imageUsageFlags = VK_IMAGE_USAGE_SAMPLED_BIT,
+				VkImageLayout imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
+			);
+			void loadFromImage(
+				uf::Image& image, 
+				Device& device,
+				VkFormat format = VK_FORMAT_R8G8B8A8_UNORM,
+				VkImageUsageFlags imageUsageFlags = VK_IMAGE_USAGE_SAMPLED_BIT,
+				VkImageLayout imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
+			);
+			void loadFromImage(
+				uf::Image& image,
+				VkFormat format = VK_FORMAT_R8G8B8A8_UNORM,
+				VkImageUsageFlags imageUsageFlags = VK_IMAGE_USAGE_SAMPLED_BIT,
+				VkImageLayout imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
+			);
+			void fromBuffers( void* buffer, VkDeviceSize bufferSize, VkFormat format, uint32_t texWidth, uint32_t texHeight, uint32_t texDepth, uint32_t layers, Device& device, VkImageUsageFlags imageUsageFlags = VK_IMAGE_USAGE_SAMPLED_BIT, VkImageLayout imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL );
+			void asRenderTarget( Device& device, uint32_t texWidth, uint32_t texHeight, VkFormat format = VK_FORMAT_R8G8B8A8_UNORM );
+			void aliasTexture( const Texture& );
+			void aliasAttachment( const RenderTarget::Attachment& attachment, bool = true );
+			
+			void update( uf::Image& image, VkImageLayout, uint32_t layer = 1 );
+			void update( void*, VkDeviceSize, VkImageLayout, uint32_t layer = 1 );
+
+			inline void fromBuffers( void* buffer, VkDeviceSize bufferSize, VkFormat format, uint32_t texWidth, uint32_t texHeight, Device& device, VkImageUsageFlags imageUsageFlags = VK_IMAGE_USAGE_SAMPLED_BIT, VkImageLayout imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL ) { return this->fromBuffers(buffer, bufferSize, format, texWidth, texHeight, 1, 1, device, imageUsageFlags, imageLayout); }
+			inline void update( uf::Image& image, uint32_t layer = 1 ) { return this->update(image, this->imageLayout, layer); }
+			inline void update( void* data, VkDeviceSize size, uint32_t layer = 1 ) { return this->update(data, size, this->imageLayout, layer); }
+			
+			void generateMipmaps(VkCommandBuffer commandBuffer, uint32_t layer = 1);
+
+			void fromBuffers( void* buffer, VkDeviceSize bufferSize, VkFormat format, uint32_t texWidth, uint32_t texHeight, uint32_t texDepth, uint32_t layers, VkImageUsageFlags imageUsageFlags = VK_IMAGE_USAGE_SAMPLED_BIT, VkImageLayout imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL );
+			inline void fromBuffers( void* buffer, VkDeviceSize bufferSize, VkFormat format, uint32_t texWidth, uint32_t texHeight, VkImageUsageFlags imageUsageFlags = VK_IMAGE_USAGE_SAMPLED_BIT, VkImageLayout imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL ) { return this->fromBuffers(buffer, bufferSize, format, texWidth, texHeight, 1, 1, imageUsageFlags, imageLayout); }
+		};
+		class UF_API Texture2D : public Texture {
+		public:
+			static Texture2D empty;
+			Texture2D();
+		};
+		class UF_API Texture3D : public Texture {
+		public:
+			static Texture3D empty;
+			Texture3D();
+		};
+		class UF_API TextureCube : public Texture {
+		public:
+			static TextureCube empty;
+			TextureCube();
+		};
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/ext/vulkan/vk.h b/engine/inc/uf/ext/vulkan/vk.h
new file mode 100644
index 00000000..e10c05a7
--- /dev/null
+++ b/engine/inc/uf/ext/vulkan/vk.h
@@ -0,0 +1,26 @@
+#pragma once
+
+#include <uf/config.h>
+#include <vulkan/vulkan.h>
+#include <vk_mem_alloc.h>
+
+#include <typeinfo>
+#include <iostream>
+#include <cassert>
+#include <mutex>
+
+#define VK_DEBUG_MESSAGE(...) UF_DEBUG_MSG(__VA_ARGS__);
+#define VK_VALIDATION_MESSAGE(...) if ( ext::vulkan::settings::validation ) VK_DEBUG_MESSAGE(__VA_ARGS__);
+
+#define VK_CHECK_RESULT(f) {										\
+	VkResult res = (f);												\
+	if (res != VK_SUCCESS) {										\
+		std::string errorString = ext::vulkan::errorString( res ); 	\
+		VK_DEBUG_MESSAGE(errorString); 								\
+		UF_EXCEPTION(errorString);									\
+	}																\
+}
+
+#define VK_FLAGS_NONE 0
+#define DEFAULT_FENCE_TIMEOUT 100000000000
+#define VK_DEFAULT_STAGE_BUFFERS 1
\ No newline at end of file
diff --git a/engine/inc/uf/ext/vulkan/vulkan.h b/engine/inc/uf/ext/vulkan/vulkan.h
new file mode 100644
index 00000000..03d266a3
--- /dev/null
+++ b/engine/inc/uf/ext/vulkan/vulkan.h
@@ -0,0 +1,106 @@
+#pragma once
+
+#include <uf/ext/vulkan/vk.h>
+#include <uf/ext/vulkan/enums.h>
+#include <uf/ext/vulkan/device.h>
+#include <uf/ext/vulkan/swapchain.h>
+#include <uf/ext/vulkan/rendermodes/base.h>
+
+#include <uf/engine/scene/scene.h>
+
+namespace ext {
+	namespace vulkan {
+		VkResult CreateDebugUtilsMessengerEXT(
+			VkInstance instance,
+			const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
+			const VkAllocationCallbacks* pAllocator,
+			VkDebugUtilsMessengerEXT* pDebugMessenger
+		);
+
+		void DestroyDebugUtilsMessengerEXT(
+			VkInstance instance,
+			VkDebugUtilsMessengerEXT debugMessenger,
+			const VkAllocationCallbacks* pAllocator
+		);
+
+		VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback(
+			VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+			VkDebugUtilsMessageTypeFlagsEXT messageType,
+			const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
+			void* pUserData
+		);
+
+		std::string errorString( VkResult result );
+		VkSampleCountFlagBits sampleCount( uint8_t );
+		void* alignedAlloc( size_t size, size_t alignment );
+		void alignedFree(void* data);
+
+		typedef VmaAllocator Allocator;
+
+		namespace settings {
+			extern UF_API uint32_t width;
+			extern UF_API uint32_t height;
+			extern UF_API uint8_t msaa;
+			extern UF_API bool validation;
+			extern UF_API size_t viewCount;
+			constexpr size_t maxViews = 6;
+
+			extern UF_API std::vector<std::string> validationFilters;
+			extern UF_API std::vector<std::string> requestedDeviceFeatures;
+			extern UF_API std::vector<std::string> requestedDeviceExtensions;
+			extern UF_API std::vector<std::string> requestedInstanceExtensions;
+			
+			extern UF_API VkFilter swapchainUpscaleFilter;
+
+			namespace experimental {
+				extern UF_API bool rebuildOnTickBegin;
+				extern UF_API bool waitOnRenderEnd;
+				extern UF_API bool individualPipelines;
+				extern UF_API bool multithreadedCommandRecording;
+				extern UF_API std::string deferredMode;
+				extern UF_API bool deferredReconstructPosition;
+				extern UF_API bool deferredAliasOutputToSwapchain;
+				extern UF_API bool multiview;
+				extern UF_API bool vsync;
+				extern UF_API bool hdr;
+			}
+
+			namespace formats {
+				extern UF_API VkColorSpaceKHR colorSpace;
+				extern UF_API ext::vulkan::enums::Format::type_t color;
+				extern UF_API ext::vulkan::enums::Format::type_t depth;
+				extern UF_API ext::vulkan::enums::Format::type_t normal;
+				extern UF_API ext::vulkan::enums::Format::type_t position;
+			}
+		}
+		namespace states {
+			extern UF_API bool rebuild;
+			extern UF_API bool resized;
+			extern UF_API uint32_t currentBuffer;
+		}
+
+		extern UF_API Device device;
+		extern UF_API Allocator allocator;
+		extern UF_API Swapchain swapchain;
+		extern UF_API std::mutex mutex;
+
+		extern UF_API RenderMode* currentRenderMode;
+		extern UF_API std::vector<RenderMode*> renderModes;
+		extern UF_API std::vector<uf::Scene*> scenes;
+
+		bool UF_API hasRenderMode( const std::string&, bool = true );
+		RenderMode& UF_API addRenderMode( RenderMode*, const std::string& = "" );
+		RenderMode& UF_API getRenderMode( const std::string&, bool = true );
+		std::vector<RenderMode*> UF_API getRenderModes( const std::string&, bool = true );
+		std::vector<RenderMode*> UF_API getRenderModes( const std::vector<std::string>&, bool = true );
+		void UF_API removeRenderMode( RenderMode*, bool = true );
+
+		void UF_API initialize( /*uint8_t = 0*/ );
+		void UF_API tick();
+		void UF_API render();
+		void UF_API destroy();
+		void UF_API synchronize( uint8_t = 0b11 );
+		std::string UF_API allocatorStats();
+		ext::vulkan::enums::Format::type_t UF_API formatFromString( const std::string& );
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/macros.h b/engine/inc/uf/macros.h
new file mode 100644
index 00000000..3c1bb847
--- /dev/null
+++ b/engine/inc/uf/macros.h
@@ -0,0 +1,31 @@
+#define TOKEN__PASTE(x, y) x ## y
+#define TOKEN_PASTE(x, y) TOKEN__PASTE(x, y)
+
+#define UF_NS_GET_LAST(name) uf::string::replace( uf::string::split( #name, "::" ).back(), "<>", "" )
+
+#define TIMER(x, ...) auto TOKEN_PASTE(TIMER, __LINE__) = []( double every = 1 ) {\
+		static uf::Timer<long long> timer(false);\
+		if ( !timer.running() ) timer.start();\
+		double time = 0;\
+		if ( (time = timer.elapsed().asDouble()) >= every ) {\
+			timer.reset();\
+		}\
+		return time;\
+	};\
+	double time = 0;\
+	if ( __VA_ARGS__ (time = TOKEN_PASTE(TIMER, __LINE__)(x)) >= x )
+
+#define UF_DEBUG 1
+#if UF_DEBUG
+	#include <iostream>
+#endif
+#define UF_PRINT_MSG(X) std::cout << __FILE__ << ":" << __FUNCTION__ << "@" << __LINE__ << ": " << X << std::endl;
+#define UF_DEBUG_MSG(X) if ( UF_DEBUG ) UF_PRINT_MSG(X);
+#define UF_ERROR_MSG(X) UF_PRINT_MSG(X);
+#define UF_DEBUG_PRINT_MARKER() UF_DEBUG_MSG("")
+
+#if UF_NO_EXCEPTIONS
+	#define UF_EXCEPTION(X) UF_ERROR_MSG(X)
+#else
+	#define UF_EXCEPTION(X) throw std::runtime_error(X)
+#endif
\ No newline at end of file
diff --git a/engine/inc/uf/simd.h b/engine/inc/uf/simd.h
new file mode 100644
index 00000000..0839ae25
--- /dev/null
+++ b/engine/inc/uf/simd.h
@@ -0,0 +1,56 @@
+#pragma once
+
+#if (defined(_M_AMD64) || defined(_M_X64) || defined(__amd64)) && ! defined(__x86_64__)
+	#define __x86_64__ 1
+#endif
+
+// Find sse instruction set from compiler macros if SSE_INSTR_SET not defined
+// Note: Not all compilers define these macros automatically
+#ifndef SSE_INSTR_SET
+	#if defined ( __AVX2__ )
+		#define SSE_INSTR_SET 8
+	#elif defined ( __AVX__ )
+		#define SSE_INSTR_SET 7
+	#elif defined ( __SSE4_2__ )
+		#define SSE_INSTR_SET 6
+	#elif defined ( __SSE4_1__ )
+		#define SSE_INSTR_SET 5
+	#elif defined ( __SSSE3__ )
+		#define SSE_INSTR_SET 4
+	#elif defined ( __SSE3__ )
+		#define SSE_INSTR_SET 3
+	#elif defined ( __SSE2__ ) || defined ( __x86_64__ )
+		#define SSE_INSTR_SET 2
+	#elif defined ( __SSE__ )
+		#define SSE_INSTR_SET 1
+	#elif defined ( _M_IX86_FP )           // Defined in MS compiler on 32bits system. 1: SSE, 2: SSE2
+		#define SSE_INSTR_SET _M_IX86_FP
+	#else
+		#define SSE_INSTR
+	#endif
+#endif
+
+// Include the appropriate header file for intrinsic functions
+#if SSE_INSTR_SET > 7                  // AVX2 and later
+	#ifdef __GNUC__
+		#include <x86intrin.h>         // x86intrin.h includes header files for whatever instruction
+									   // sets are specified on the compiler command line, such as:
+									   // xopintrin.h, fma4intrin.h
+	#else
+		#include <immintrin.h>         // MS version of immintrin.h covers AVX, AVX2 and FMA3
+	#endif // __GNUC__
+#elif SSE_INSTR_SET == 7
+	#include <immintrin.h>             // AVX
+#elif SSE_INSTR_SET == 6
+	#include <nmmintrin.h>             // SSE4.2
+#elif SSE_INSTR_SET == 5
+	#include <smmintrin.h>             // SSE4.1
+#elif SSE_INSTR_SET == 4
+	#include <tmmintrin.h>             // SSSE3
+#elif SSE_INSTR_SET == 3
+	#include <pmmintrin.h>             // SSE3
+#elif SSE_INSTR_SET == 2
+	#include <emmintrin.h>             // SSE2
+#elif SSE_INSTR_SET == 1
+	#include <xmmintrin.h>             // SSE
+#endif
\ No newline at end of file
diff --git a/engine/inc/uf/spec/context/context.h b/engine/inc/uf/spec/context/context.h
new file mode 100644
index 00000000..89075d44
--- /dev/null
+++ b/engine/inc/uf/spec/context/context.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/spec/universal.h>
+
+// include universal
+#include "universal.h"
+// defines which implementation to use
+#include UF_ENV_HEADER
\ No newline at end of file
diff --git a/engine/inc/uf/spec/context/dreamcast.h b/engine/inc/uf/spec/context/dreamcast.h
new file mode 100644
index 00000000..c212e64b
--- /dev/null
+++ b/engine/inc/uf/spec/context/dreamcast.h
@@ -0,0 +1,8 @@
+#pragma once
+
+#include "universal.h"
+#include "unknown.h"
+
+namespace spec {
+	typedef spec::unknown::Context Context;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/spec/context/universal.h b/engine/inc/uf/spec/context/universal.h
new file mode 100644
index 00000000..116cd421
--- /dev/null
+++ b/engine/inc/uf/spec/context/universal.h
@@ -0,0 +1,63 @@
+#pragma once
+
+#include <uf/config.h>
+
+#if UF_USE_OPENGL
+	#include <uf/ext/opengl/ogl.h>
+#endif
+
+#if UF_USE_SFML
+	#include <uf/spec/window/universal.h>
+#else
+	#include <uf/spec/window/window.h>
+#endif
+
+namespace spec {
+	namespace uni {
+		class UF_API_VAR Context {
+		public:
+			#if UF_USE_SFML
+				typedef spec::uni::Window window_t;
+			#else
+				typedef spec::Window window_t;
+			#endif
+			struct Settings {
+				uint32_t depthBits = 24;
+				uint32_t stencilBits = 4;
+				uint32_t bitsPerPixel = 8;
+				uint32_t antialiasingLevel = 0;
+				uint32_t majorVersion = 2;
+				uint32_t minorVersion = 0;
+			};
+		protected:
+			Context::window_t::handle_t 	m_window;
+			bool							m_ownsWindow;
+			Context::Settings 				m_settings;
+		public:
+			UF_API_CALL Context();
+			UF_API_CALL Context( Context::window_t::handle_t window, bool ownsWindow, const Context::Settings& settings );
+			virtual ~Context();
+			virtual void UF_API_CALL create( uni::Context* shared ) = 0;
+			virtual void UF_API_CALL terminate() = 0;
+
+			virtual bool UF_API_CALL makeCurrent() = 0;
+			virtual void UF_API_CALL setVerticalSyncEnabled(bool enabled) = 0;
+			virtual void UF_API_CALL display() = 0;
+			virtual int UF_API_CALL evaluateFormat( const Context::Settings& settings, int colorBits, int depthBits, int stencilBits, int antialiasing );
+
+		// 
+			bool UF_API_CALL setActive(bool active);
+			const Context::Settings& UF_API_CALL getSettings() const;
+			void UF_API_CALL setSettings( const Context::Settings& );
+		//
+			void UF_API_CALL initialize();
+			static void UF_API_CALL globalInit();
+			static void UF_API_CALL globalCleanup();
+			static void UF_API_CALL ensureContext();
+			static Context* UF_API_CALL create();
+			static Context* UF_API_CALL create(const Context::Settings& settings, const Context::window_t& owner);
+			static Context* UF_API_CALL create(const Context::Settings& settings, unsigned int width, unsigned int height);
+		//
+		};
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/spec/context/unknown.h b/engine/inc/uf/spec/context/unknown.h
new file mode 100644
index 00000000..8e649a62
--- /dev/null
+++ b/engine/inc/uf/spec/context/unknown.h
@@ -0,0 +1,24 @@
+#pragma once
+
+#include "context.h"
+
+namespace spec {
+	namespace unknown {
+		class UF_API_VAR Context : public spec::uni::Context {
+		public:
+			UF_API_CALL Context( uni::Context* shared, const Context::Settings& settings = Settings() ) {}
+			UF_API_CALL Context( uni::Context* shared, const Context::Settings& settings, const Context::window_t& window ) {}
+			UF_API_CALL Context( uni::Context* shared, const Context::Settings& settings, unsigned int width, unsigned int height ) {}
+			~Context() {}
+
+			virtual void UF_API_CALL terminate() {}
+
+			virtual bool UF_API_CALL makeCurrent() { return false; }
+			virtual void UF_API_CALL setVerticalSyncEnabled(bool enabled) {}
+			virtual void UF_API_CALL display() {}
+		protected:
+			virtual void UF_API_CALL create( uni::Context* shared ){}
+		};
+	}
+	typedef spec::unknown::Context Context;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/spec/context/windows.h b/engine/inc/uf/spec/context/windows.h
new file mode 100644
index 00000000..e94e9d41
--- /dev/null
+++ b/engine/inc/uf/spec/context/windows.h
@@ -0,0 +1,32 @@
+#pragma once
+
+#include "universal.h"
+
+#if !UF_USE_SFML
+namespace spec {
+	namespace win32 {
+		class UF_API_VAR Context : public spec::uni::Context {
+		public:
+			typedef HDC 	dc_t;
+			typedef HGLRC 	context_t;
+		protected:
+			Context::dc_t		m_deviceContext;
+			Context::context_t 	m_context;
+		public:
+			UF_API_CALL Context( uni::Context* shared, const Context::Settings& settings = Settings() );
+			UF_API_CALL Context( uni::Context* shared, const Context::Settings& settings, const Context::window_t& window );
+			UF_API_CALL Context( uni::Context* shared, const Context::Settings& settings, unsigned int width, unsigned int height );
+			~Context();
+
+			virtual void UF_API_CALL terminate();
+
+			virtual bool UF_API_CALL makeCurrent();
+			virtual void UF_API_CALL setVerticalSyncEnabled(bool enabled);
+			virtual void UF_API_CALL display();
+		protected:
+			virtual void UF_API_CALL create( uni::Context* shared );
+		};
+	}
+	typedef spec::win32::Context Context;
+}
+#endif
\ No newline at end of file
diff --git a/engine/inc/uf/spec/dreamcast.h b/engine/inc/uf/spec/dreamcast.h
new file mode 100644
index 00000000..22e2ca8f
--- /dev/null
+++ b/engine/inc/uf/spec/dreamcast.h
@@ -0,0 +1,11 @@
+#pragma once
+
+#include <uf/config.h>
+// In the event some fool includes this file directly
+#include "universal.h"
+// Windows-specific stuffs
+#ifdef UF_ENV_DREAMCAST
+
+// Headers
+
+#endif
\ No newline at end of file
diff --git a/engine/inc/uf/spec/renderer/opengl.h b/engine/inc/uf/spec/renderer/opengl.h
new file mode 100644
index 00000000..e619fb18
--- /dev/null
+++ b/engine/inc/uf/spec/renderer/opengl.h
@@ -0,0 +1,12 @@
+#pragma once
+
+#include <uf/ext/opengl/opengl.h>
+#include <uf/ext/opengl/graphic.h>
+#include <uf/ext/opengl/rendermodes/rendertarget.h>
+#include <uf/ext/opengl/rendermodes/deferred.h>
+#include <uf/ext/opengl/rendermodes/compute.h>
+#include <uf/ext/opengl/rendertarget.h>
+
+namespace spec {
+	namespace renderer = ext::opengl;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/spec/renderer/universal.h b/engine/inc/uf/spec/renderer/universal.h
new file mode 100644
index 00000000..5b40eb00
--- /dev/null
+++ b/engine/inc/uf/spec/renderer/universal.h
@@ -0,0 +1,11 @@
+#pragma once
+
+#if defined(UF_USE_VULKAN) && UF_USE_VULKAN == 1
+	#include "vulkan.h"
+#elif defined(UF_USE_OPENGL) && UF_USE_OPENGL == 1
+	#include "opengl.h"
+#endif
+
+namespace uf {
+	namespace renderer = spec::renderer;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/spec/renderer/vulkan.h b/engine/inc/uf/spec/renderer/vulkan.h
new file mode 100644
index 00000000..770fb96d
--- /dev/null
+++ b/engine/inc/uf/spec/renderer/vulkan.h
@@ -0,0 +1,12 @@
+#pragma once
+
+#include <uf/ext/vulkan/vulkan.h>
+#include <uf/ext/vulkan/graphic.h>
+#include <uf/ext/vulkan/rendermodes/rendertarget.h>
+#include <uf/ext/vulkan/rendermodes/deferred.h>
+#include <uf/ext/vulkan/rendermodes/compute.h>
+#include <uf/ext/vulkan/rendertarget.h>
+
+namespace spec {
+	namespace renderer = ext::vulkan;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/spec/terminal/terminal.h b/engine/inc/uf/spec/terminal/terminal.h
new file mode 100644
index 00000000..f17275e7
--- /dev/null
+++ b/engine/inc/uf/spec/terminal/terminal.h
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/spec/universal.h>
+
+namespace spec {
+	namespace uni {
+		class UF_API Terminal {
+		protected:
+
+		public:
+			void UF_API_CALL clear();
+			void UF_API_CALL setLocale();
+			void UF_API_CALL hide();
+			void UF_API_CALL show();
+			inline void UF_API_CALL setVisible(bool visibility) { visibility ? this->show() : this->hide(); }
+		};
+	};
+
+	class UF_API Terminal : public spec::uni::Terminal {
+	protected:
+
+	public:
+		spec::uni::Terminal& UF_API_CALL getUniversal();
+
+		void UF_API_CALL clear();
+		void UF_API_CALL setLocale();
+		void UF_API_CALL hide();
+		void UF_API_CALL show();
+		inline void UF_API_CALL setVisible(bool visibility) { visibility ? this->show() : this->hide(); }
+	};
+	extern UF_API spec::Terminal terminal;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/spec/time/dreamcast.h b/engine/inc/uf/spec/time/dreamcast.h
new file mode 100644
index 00000000..5033fa7c
--- /dev/null
+++ b/engine/inc/uf/spec/time/dreamcast.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include <uf/config.h>
+#include "universal.h"
+
+#if UF_ENV_DREAMCAST
+
+namespace spec {
+	namespace dreamcast {
+		class UF_API Time : public spec::uni::Time {
+		public:
+			static Time::exp_t unit;
+			spec::uni::Time& UF_API_CALL getUniversal();
+
+			spec::uni::Time::time_t UF_API_CALL getTime();
+		};
+	}
+	typedef dreamcast::Time Time;
+	extern UF_API Time time;
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/inc/uf/spec/time/time.h b/engine/inc/uf/spec/time/time.h
new file mode 100644
index 00000000..89075d44
--- /dev/null
+++ b/engine/inc/uf/spec/time/time.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/spec/universal.h>
+
+// include universal
+#include "universal.h"
+// defines which implementation to use
+#include UF_ENV_HEADER
\ No newline at end of file
diff --git a/engine/inc/uf/spec/time/universal.h b/engine/inc/uf/spec/time/universal.h
new file mode 100644
index 00000000..e66014ac
--- /dev/null
+++ b/engine/inc/uf/spec/time/universal.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include <uf/config.h>
+
+namespace spec {
+	namespace uni {
+		class UF_API Time {
+		public:
+			typedef long long time_t;
+			typedef int exp_t;
+			static Time::exp_t unit;
+		protected:
+			
+		public:
+			spec::uni::Time::time_t UF_API_CALL getTime();
+		};
+	};
+}
\ No newline at end of file
diff --git a/engine/inc/uf/spec/time/unknown.h b/engine/inc/uf/spec/time/unknown.h
new file mode 100644
index 00000000..9ce214cf
--- /dev/null
+++ b/engine/inc/uf/spec/time/unknown.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include <uf/config.h>
+#include "universal.h"
+
+namespace spec {
+	typedef uni::Time Time;
+	extern UF_API Time time;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/spec/time/windows.h b/engine/inc/uf/spec/time/windows.h
new file mode 100644
index 00000000..bdccdeb7
--- /dev/null
+++ b/engine/inc/uf/spec/time/windows.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include <uf/config.h>
+#include "universal.h"
+
+#if defined(UF_ENV_WINDOWS)
+
+namespace spec {
+	namespace win32 {
+		class UF_API Time : public spec::uni::Time {
+		public:
+			static Time::exp_t unit;
+			spec::uni::Time& UF_API_CALL getUniversal();
+
+			spec::uni::Time::time_t UF_API_CALL getTime();
+		};
+	}
+	typedef win32::Time Time;
+	extern UF_API Time time;
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/inc/uf/spec/universal.h b/engine/inc/uf/spec/universal.h
new file mode 100644
index 00000000..dc2aa024
--- /dev/null
+++ b/engine/inc/uf/spec/universal.h
@@ -0,0 +1,34 @@
+#pragma once
+#include <uf/config.h>
+
+// Moved to uf/config.h
+/*
+
+#if defined(UF_ENV)
+	#warning Specific variables already defined; undefining...
+
+	#undef UF_ENV
+	#undef UF_ENV_WINDOWS
+	#undef UF_ENV_UNKNOWN
+#endif
+
+#if defined(_WIN32) || defined(__CYGWIN__)
+	#define UF_ENV "Windows"
+	#define UF_ENV_WINDOWS 1
+	#define UF_ENV_HEADER "windows.h"
+	#if defined(__CYGWIN__)
+		#define to_string(var) string(var)
+	#endif
+//	#warning Using "Windows"
+#else
+	#define UF_ENV "Unknown"
+	#define UF_ENV_UNKNOWN 1
+	#define UF_ENV_HEADER "unknown.h"
+//	#warning Using "unknown"
+#endif
+
+*/
+#include UF_ENV_HEADER
+
+// define some universal shit
+// #define UF_USE_SFML 1
\ No newline at end of file
diff --git a/engine/inc/uf/spec/unknown.h b/engine/inc/uf/spec/unknown.h
new file mode 100644
index 00000000..58e7f0f1
--- /dev/null
+++ b/engine/inc/uf/spec/unknown.h
@@ -0,0 +1,12 @@
+#pragma once
+
+#include <uf/config.h>
+// In the event some fool includes this file directly
+#include "universal.h"
+// Filler stuffs
+#ifdef UF_ENV_UNKNOWN
+
+
+
+
+#endif
\ No newline at end of file
diff --git a/engine/inc/uf/spec/window/dreamcast.h b/engine/inc/uf/spec/window/dreamcast.h
new file mode 100644
index 00000000..09035380
--- /dev/null
+++ b/engine/inc/uf/spec/window/dreamcast.h
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <uf/config.h>
+#include "universal.h"
+#include <kos.h>
+
+#if UF_ENV_DREAMCAST
+namespace spec {
+	namespace dreamcast {
+		class UF_API Window : public spec::uni::Window {
+		public:
+			typedef size_t 							handle_t;
+		protected:
+			spec::dreamcast::Window::handle_t 		m_handle;
+		//	size_t									m_cursor;
+		//	size_t 									m_icon;
+			
+			spec::dreamcast::Window::vector_t 		m_lastSize;
+			bool 									m_keyRepeatEnabled;
+			bool 									m_resizing;
+			bool 									m_mouseInside;
+			bool 									m_mouseGrabbed;
+			uint16_t 								m_surrogate;
+			bool 									m_syncParse;
+			bool 									m_asyncParse;
+		public:
+		// 	C-tors
+			UF_API Window();
+			UF_API Window( spec::dreamcast::Window::handle_t );
+			UF_API Window( const spec::dreamcast::Window::vector_t& size, const spec::dreamcast::Window::title_t& title = L"Window" );
+			/*virtual*/ void UF_API create( const spec::dreamcast::Window::vector_t& size, const spec::dreamcast::Window::title_t& title = L"Window" );
+		// 	D-tors
+			/*virtual*/ ~Window();
+			void UF_API terminate();
+		// 	Gets
+			spec::dreamcast::Window::handle_t UF_API getHandle() const;
+			/*virtual*/ spec::dreamcast::Window::vector_t UF_API getPosition() const;
+			/*virtual*/ spec::dreamcast::Window::vector_t UF_API getSize() const;
+			/*virtual*/ size_t UF_API getRefreshRate() const;
+		// 	Attribute modifiers
+			/*virtual*/ void UF_API setPosition( const spec::dreamcast::Window::vector_t& position );
+			/*virtual*/ void UF_API centerWindow();
+			/*virtual*/ void UF_API setMousePosition( const spec::dreamcast::Window::vector_t& position );
+			/*virtual*/ spec::dreamcast::Window::vector_t UF_API getMousePosition();
+			/*virtual*/ void UF_API setSize( const spec::dreamcast::Window::vector_t& size );
+			/*virtual*/ void UF_API setTitle( const spec::dreamcast::Window::title_t& title );
+			/*virtual*/ void UF_API setIcon( const spec::dreamcast::Window::vector_t& size, uint8_t* pixels );
+			/*virtual*/ void UF_API setVisible( bool visibility );
+			/*virtual*/ void UF_API setCursorVisible( bool visibility );
+			/*virtual*/ void UF_API setKeyRepeatEnabled( bool state );
+			/*virtual*/ void UF_API setMouseGrabbed(bool state);
+		
+			/*virtual*/ void UF_API requestFocus();
+			/*virtual*/ bool UF_API hasFocus() const;
+		// 	Update
+			/*virtual*/ void UF_API processEvents();
+			static /*virtual*/ bool UF_API isKeyPressed(const std::string&);
+			bool UF_API pollEvents( bool block = false );
+		// 	Win32 specific functions
+			void UF_API registerWindowClass();
+			void UF_API processEvent(/*UINT message, WPARAM wParam, LPARAM lParam*/);
+			void UF_API grabMouse(bool state);
+			
+			void UF_API setTracking(bool state);
+			static pod::Vector2ui UF_API getResolution();
+			void UF_API switchToFullscreen( bool borderless = false );
+			static std::string UF_API getKey(/*WPARAM key, LPARAM flags*/);
+		};
+	}
+	typedef spec::dreamcast::Window Window;
+}
+#endif
\ No newline at end of file
diff --git a/engine/inc/uf/spec/window/universal.h b/engine/inc/uf/spec/window/universal.h
new file mode 100644
index 00000000..2ea42ec7
--- /dev/null
+++ b/engine/inc/uf/spec/window/universal.h
@@ -0,0 +1,66 @@
+#pragma once
+
+#include <uf/config.h>
+
+#include <uf/utils/math/vector.h>
+#include <uf/utils/hook/hook.h>
+#include <uf/utils/string/string.h>
+#include <string>
+#include <queue>
+
+namespace spec {
+	namespace uni {
+		class UF_API Window {
+		public:
+			typedef void* 									handle_t;
+			typedef uf::String 								title_t;
+			typedef pod::Vector2i 							vector_t;
+
+			struct Event {
+				std::string name;
+				uf::Userdata payload;
+			};
+		protected:
+		//	Window::Events m_events;
+			std::queue<Event> m_events;
+		public:
+		// 	C-tors
+			/*virtual*/ void UF_API_CALL create( const spec::uni::Window::vector_t& size, const spec::uni::Window::title_t& title = L"Window" ) {} ;// = 0;
+		// 	D-tors
+			/*virtual*/ void UF_API_CALL terminate();/* = 0;*/
+		// 	Gets
+			/*virtual*/ spec::uni::Window::vector_t UF_API_CALL getPosition() const;/* = 0;*/
+			/*virtual*/ spec::uni::Window::vector_t UF_API_CALL getSize() const;/* = 0;*/
+			/*virtual*/ size_t UF_API_CALL getRefreshRate() const;/* = 0;*/
+		// 	Attribute modifiers
+			/*virtual*/ void UF_API_CALL setPosition( const spec::uni::Window::vector_t& position );/* = 0;*/
+			/*virtual*/ void UF_API_CALL centerWindow();/* = 0;*/
+			/*virtual*/ void UF_API_CALL setMousePosition( const spec::uni::Window::vector_t& position );/* = 0;*/
+			/*virtual*/ void UF_API_CALL setSize( const spec::uni::Window::vector_t& size );/* = 0;*/
+			/*virtual*/ void UF_API_CALL setTitle( const spec::uni::Window::title_t& title );/* = 0;*/
+			/*virtual*/ void UF_API_CALL setIcon( const spec::uni::Window::vector_t& size, uint8_t* pixels );/* = 0;*/
+			/*virtual*/ void UF_API_CALL setVisible( bool visibility );/* = 0;*/
+			/*virtual*/ void UF_API_CALL setCursorVisible( bool visibility );/* = 0;*/
+			/*virtual*/ void UF_API_CALL setKeyRepeatEnabled( bool state );/* = 0;*/
+			/*virtual*/ void UF_API_CALL setMouseGrabbed( bool state );/* = 0;*/
+		
+			/*virtual*/ void UF_API_CALL requestFocus();/* = 0;*/
+			/*virtual*/ bool UF_API_CALL hasFocus() const;/* = 0;*/
+		// 	Update
+			/*virtual*/ void UF_API_CALL processEvents();/* = 0;*/
+		/*
+			void UF_API_CALL pushEvent( const uf::ReadableHook::name_t& name, const uf::ReadableHook::argument_t& argument );
+			void UF_API_CALL pushEvent( const uf::OptimalHook::name_t& name, const uf::OptimalHook::argument_t& argument );
+			void UF_API_CALL pushEvent( const uf::ReadableHook::argument_t& serialized );
+			void UF_API_CALL pushEvent( const uf::OptimalHook::argument_t& userdata );
+		*/
+			void UF_API_CALL pushEvent( const uf::Hooks::name_t& name, const std::string& payload );
+			void UF_API_CALL pushEvent( const uf::Hooks::name_t& name, const ext::json::Value& payload );
+			void UF_API_CALL pushEvent( const uf::Hooks::name_t& name, const uf::Serializer& payload );
+			void UF_API_CALL pushEvent( const uf::Hooks::name_t& name, const uf::Hooks::argument_t& payload );
+			void UF_API_CALL pushEvent( const uf::Hooks::argument_t& payload );
+			bool UF_API_CALL pollEvents( bool block = false );
+			static bool UF_API_CALL isKeyPressed( const std::string& );
+		};
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/spec/window/unknown.h b/engine/inc/uf/spec/window/unknown.h
new file mode 100644
index 00000000..aa6ac7c8
--- /dev/null
+++ b/engine/inc/uf/spec/window/unknown.h
@@ -0,0 +1,49 @@
+#pragma once
+
+#include <uf/config.h>
+#include "universal.h"
+
+#ifdef UF_ENV_UNKNOWN
+namespace spec {
+	namespace unknown {
+		class UF_API Window : public spec::uni::Window {
+		public:
+			typedef void* 							handle_t;
+			typedef spec::uni::Window::title_t 		title_t;
+			typedef spec::uni::Window::vector_t 	vector_t;
+		
+		protected:
+
+		public:
+		// 	C-tors
+			UF_API_CALL Window( spec::unknown::Window::handle_t ) {}
+			UF_API_CALL Window( const spec::unknown::Window::vector_t& size, const spec::unknown::Window::title_t& title = L"Window" ) {}
+			/*virtual*/ void UF_API_CALL create( const spec::unknown::Window::vector_t& size, const spec::unknown::Window::title_t& title = L"Window" ) {}
+		// 	D-tors
+			/*virtual*/ ~Window() {}
+			void UF_API_CALL terminate() {}
+		// 	Gets
+			spec::unknown::Window::handle_t UF_API_CALL getHandle() const { return NULL; }
+			/*virtual*/ spec::unknown::Window::vector_t UF_API_CALL getPosition() const { return spec::unknown::Window::vector_t(0,0); }
+			/*virtual*/ spec::unknown::Window::vector_t UF_API_CALL getSize() const { return spec::unknown::Window::vector_t(0,0); }
+		// 	Attribute modifiers
+			/*virtual*/ void UF_API_CALL setPosition( const spec::unknown::Window::vector_t& position ) {}
+			/*virtual*/ void UF_API_CALL centerWindow() {}
+			/*virtual*/ void UF_API_CALL setMousePosition( const spec::unknown::Window::vector_t& position ) {}
+			/*virtual*/ void UF_API_CALL setSize( const spec::unknown::Window::vector_t& size ) {}
+			/*virtual*/ void UF_API_CALL setTitle( const spec::unknown::Window::title_t& title ) {}
+			/*virtual*/ void UF_API_CALL setIcon( const spec::unknown::Window::vector_t& size, uint8_t* pixels ) {}
+			/*virtual*/ void UF_API_CALL setVisible( bool visibility ) {}
+			/*virtual*/ void UF_API_CALL setCursorVisible( bool visibility ) {}
+			/*virtual*/ void UF_API_CALL setKeyRepeatEnabled( bool state ) {}
+			/*virtual*/ void UF_API_CALL setMouseGrabbed( bool state ) {}
+		
+			/*virtual*/ void UF_API_CALL requestFocus() {}
+			/*virtual*/ bool UF_API_CALL hasFocus() const { return false; }
+		// 	Update
+			/*virtual*/ void UF_API_CALL processEvents() {}
+		};
+	}
+	typedef spec::unknown::Window Window;
+}
+#endif
\ No newline at end of file
diff --git a/engine/inc/uf/spec/window/window.h b/engine/inc/uf/spec/window/window.h
new file mode 100644
index 00000000..89075d44
--- /dev/null
+++ b/engine/inc/uf/spec/window/window.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/spec/universal.h>
+
+// include universal
+#include "universal.h"
+// defines which implementation to use
+#include UF_ENV_HEADER
\ No newline at end of file
diff --git a/engine/inc/uf/spec/window/windows.h b/engine/inc/uf/spec/window/windows.h
new file mode 100644
index 00000000..5a812101
--- /dev/null
+++ b/engine/inc/uf/spec/window/windows.h
@@ -0,0 +1,88 @@
+#pragma once
+
+#include <uf/config.h>
+#include "universal.h"
+
+#if UF_ENV_WINDOWS && !UF_USE_SFML
+#if UF_USE_VULKAN
+	#include <uf/ext/vulkan/vk.h>
+#endif
+namespace spec {
+	namespace win32 {
+		class UF_API Window : public spec::uni::Window {
+		public:
+			typedef HWND 							handle_t;
+		/*
+			typedef spec::uni::Window::title_t 		title_t;
+			typedef spec::uni::Window::vector_t 	vector_t;
+		*/
+			LONG_PTR 								m_callback;
+		protected:
+			spec::win32::Window::handle_t 			m_handle;
+			HCURSOR									m_cursor;
+			HICON 									m_icon;
+			
+			spec::win32::Window::vector_t 			m_lastSize;
+			bool 									m_keyRepeatEnabled;
+			bool 									m_resizing;
+			bool 									m_mouseInside;
+			bool 									m_mouseGrabbed;
+			uint16_t 								m_surrogate;
+			bool 									m_syncParse;
+			bool 									m_asyncParse;
+		public:
+		// 	C-tors
+			UF_API_CALL Window();
+			UF_API_CALL Window( spec::win32::Window::handle_t );
+			UF_API_CALL Window( const spec::win32::Window::vector_t& size, const spec::win32::Window::title_t& title = L"Window" );
+			/*virtual*/ void UF_API_CALL create( const spec::win32::Window::vector_t& size, const spec::win32::Window::title_t& title = L"Window" );
+		// 	D-tors
+			/*virtual*/ ~Window();
+			void UF_API_CALL terminate();
+		// 	Gets
+			spec::win32::Window::handle_t UF_API_CALL getHandle() const;
+			/*virtual*/ spec::win32::Window::vector_t UF_API_CALL getPosition() const;
+			/*virtual*/ spec::win32::Window::vector_t UF_API_CALL getSize() const;
+			/*virtual*/ size_t UF_API_CALL getRefreshRate() const;
+		// 	Attribute modifiers
+			/*virtual*/ void UF_API_CALL setPosition( const spec::win32::Window::vector_t& position );
+			/*virtual*/ void UF_API_CALL centerWindow();
+			/*virtual*/ void UF_API_CALL setMousePosition( const spec::win32::Window::vector_t& position );
+			/*virtual*/ spec::win32::Window::vector_t UF_API_CALL getMousePosition();
+			/*virtual*/ void UF_API_CALL setSize( const spec::win32::Window::vector_t& size );
+			/*virtual*/ void UF_API_CALL setTitle( const spec::win32::Window::title_t& title );
+			/*virtual*/ void UF_API_CALL setIcon( const spec::win32::Window::vector_t& size, uint8_t* pixels );
+			/*virtual*/ void UF_API_CALL setVisible( bool visibility );
+			/*virtual*/ void UF_API_CALL setCursorVisible( bool visibility );
+			/*virtual*/ void UF_API_CALL setKeyRepeatEnabled( bool state );
+			/*virtual*/ void UF_API_CALL setMouseGrabbed(bool state);
+		
+			/*virtual*/ void UF_API_CALL requestFocus();
+			/*virtual*/ bool UF_API_CALL hasFocus() const;
+		// 	Update
+			/*virtual*/ void UF_API_CALL processEvents();
+			static /*virtual*/ bool UF_API_CALL isKeyPressed(const std::string&);
+			bool UF_API_CALL pollEvents( bool block = false );
+		// 	Win32 specific functions
+			void UF_API_CALL registerWindowClass();
+			void UF_API_CALL processEvent(UINT message, WPARAM wParam, LPARAM lParam);
+			void UF_API_CALL grabMouse(bool state);
+			
+			void UF_API_CALL setTracking(bool state);
+			static pod::Vector2ui UF_API_CALL getResolution();
+			void UF_API_CALL switchToFullscreen( bool borderless = false );
+		#if defined(UF_USE_VULKAN) && UF_USE_VULKAN == 1
+			std::vector<std::string> UF_API_CALL getExtensions( bool validationEnabled );
+			void UF_API_CALL createSurface( VkInstance instance, VkSurfaceKHR& surface );
+		#endif
+			static std::string UF_API_CALL getKey(WPARAM key, LPARAM flags);
+		};
+	}
+	typedef spec::win32::Window Window;
+}
+#elif UF_USE_SFML
+#include <uf/ext/sfml/window.h>
+namespace spec {
+	typedef ext::sfml::Window Window;
+}
+#endif
\ No newline at end of file
diff --git a/engine/inc/uf/spec/windows.h b/engine/inc/uf/spec/windows.h
new file mode 100644
index 00000000..5bf69538
--- /dev/null
+++ b/engine/inc/uf/spec/windows.h
@@ -0,0 +1,12 @@
+#pragma once
+
+#include <uf/config.h>
+// In the event some fool includes this file directly
+#include "universal.h"
+// Windows-specific stuffs
+#ifdef UF_ENV_WINDOWS
+
+// Headers
+#include <windows.h>
+
+#endif
\ No newline at end of file
diff --git a/engine/inc/uf/utils/audio/audio.h b/engine/inc/uf/utils/audio/audio.h
new file mode 100644
index 00000000..6f19e88d
--- /dev/null
+++ b/engine/inc/uf/utils/audio/audio.h
@@ -0,0 +1,110 @@
+#pragma once
+
+#include <uf/config.h>
+
+#if UF_USE_OPENAL
+#include <uf/ext/oal/oal.h>
+#else
+	namespace ext {
+		namespace al {
+			typedef size_t Source;
+			typedef size_t Buffer;
+		}
+	}
+	typedef float ALfloat;
+#endif
+
+#include <vector>
+#include <unordered_map>
+
+#include <uf/utils/math/vector.h>
+#include <uf/utils/math/quaternion.h>
+#include <uf/utils/serialize/serializer.h>
+
+namespace uf {
+	class UF_API Audio {
+	protected:
+		std::string m_filename;
+		ext::al::Source m_source;
+		ext::al::Buffer m_buffer;
+		float m_duration;
+	public:
+		static bool mute;
+		static uf::Audio null;
+		Audio( const std::string& = "" );
+		Audio( Audio&& );
+		Audio( const Audio& );
+		~Audio();
+
+		bool initialized();
+		bool playing();
+		void destroy();
+
+		void load( const std::string& = "" );
+		void play();
+		void stop();
+		ALfloat getTime();
+		void setTime( ALfloat );
+		float getDuration() const;
+
+		void setPosition( const pod::Vector3& );
+		void setOrientation( const pod::Quaternion<>& );
+		void setVolume( float );
+
+		ALfloat getPitch();
+		void setPitch( ALfloat );
+		ALfloat getGain();
+		void setGain( ALfloat );
+		ALfloat getRolloffFactor();
+		void setRolloffFactor( ALfloat );
+		ALfloat getMaxDistance();
+		void setMaxDistance( ALfloat );
+
+		float getVolume() const;
+		const std::string& getFilename() const;
+
+		Audio& operator=( const uf::Audio& );
+	};
+	class UF_API SoundEmitter {
+	public:
+		typedef std::vector<uf::Audio*> container_t;
+	protected:
+		uf::SoundEmitter::container_t m_container;
+	public:
+		~SoundEmitter();
+		
+		bool has( const std::string& ) const;
+
+		uf::Audio& add( const std::string&, bool unique = false );
+		uf::Audio& add( const uf::Audio&, bool unique = false );
+
+		uf::Audio& get( const std::string& );
+		const uf::Audio& get( const std::string& ) const;
+		
+		container_t& get();
+		const container_t& get() const;
+		
+		void cleanup( bool = false );
+	};
+	class UF_API MappedSoundEmitter {
+	public:
+		typedef std::unordered_map<std::string, uf::Audio*> container_t;
+	protected:
+		uf::MappedSoundEmitter::container_t m_container;
+	public:
+		~MappedSoundEmitter();
+		
+		bool has( const std::string& ) const;
+
+		uf::Audio& add( const std::string& );
+		uf::Audio& add( const uf::Audio& );
+
+		uf::Audio& get( const std::string& );
+		const uf::Audio& get( const std::string& ) const;
+		
+		container_t& get();
+		const container_t& get() const;
+
+		void cleanup( bool = false );
+	};
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/camera/camera.h b/engine/inc/uf/utils/camera/camera.h
new file mode 100644
index 00000000..06557a95
--- /dev/null
+++ b/engine/inc/uf/utils/camera/camera.h
@@ -0,0 +1,92 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/utils/math/vector.h>
+#include <uf/utils/math/matrix.h>
+#include <uf/utils/math/quaternion.h>
+#include <uf/utils/math/transform.h>
+
+namespace uf {
+	class UF_API Camera {
+	protected:
+		bool m_modified;
+		// ortho camera uses { size.x, size.y, tops.x, tops.y, bounds.x, bounds.y } => { left, right, bottom, top, near, far }
+		struct {
+			struct {
+				pod::Vector2 lr, bt, nf;
+			} ortho;
+			struct {
+				pod::Math::num_t fov;
+				pod::Vector2 size ;
+				pod::Vector2 bounds;
+			} perspective;
+			int mode;
+			pod::Vector3 offset;
+			bool stereoscopic = false;
+		} m_settings;
+		struct {
+		/*
+			struct {
+				pod::Matrix4 view, projection;
+			} left, right;
+			pod::Matrix4 model;
+		*/
+			std::vector<pod::Matrix4f> views;
+			std::vector<pod::Matrix4f> projections;
+		} m_matrices;
+		pod::Transform<> m_transform;
+	public:
+		static bool USE_REVERSE_INFINITE_PROJECTION;
+		
+		Camera();
+/*
+		Camera( const pod::Math::num_t& fov, const pod::Vector2& size, const pod::Vector2& bounds, const pod::Vector3& offset = {0, 0, 0}, const pod::Vector2& tops = {0, 0} );
+		Camera( Camera&& move );
+		Camera( const Camera& copy );
+*/
+		bool modified() const;
+		void setStereoscopic( bool );
+		pod::Transform<>& getTransform();
+		const pod::Transform<>& getTransform() const;
+
+		pod::Matrix4& getView( size_t = 0 );
+		const pod::Matrix4& getView( size_t = 0 ) const;
+
+		pod::Matrix4& getProjection( size_t = 0 );
+		const pod::Matrix4& getProjection( size_t = 0 ) const;
+
+	//	pod::Matrix4& getModel();
+	//	const pod::Matrix4& getModel() const;
+
+		pod::Math::num_t& getFov();
+		pod::Math::num_t getFov() const;
+
+		pod::Vector2& getSize();
+		const pod::Vector2& getSize() const;
+
+		pod::Vector2& getBounds();
+		const pod::Vector2& getBounds() const;
+
+		pod::Vector3& getOffset();
+		const pod::Vector3& getOffset() const;
+
+		void setTransform( const pod::Transform<>& transform );
+		
+		void setView( const pod::Matrix4& mat, size_t = SIZE_MAX );
+		void setProjection( const pod::Matrix4& mat, size_t = SIZE_MAX );
+	//	void setModel( const pod::Matrix4& mat );
+
+
+		void setFov( pod::Math::num_t fov );
+		void setSize( const pod::Vector2& );
+		void setBounds( const pod::Vector2& );
+
+		void ortho( const pod::Vector2&, const pod::Vector2&, const pod::Vector2& );
+		
+		void setOffset( const pod::Vector3& );
+
+		void update(bool override = false);
+		void updateView();
+		void updateProjection();
+	};
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/component/component.h b/engine/inc/uf/utils/component/component.h
new file mode 100644
index 00000000..5faefc43
--- /dev/null
+++ b/engine/inc/uf/utils/component/component.h
@@ -0,0 +1,63 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/utils/userdata/userdata.h>
+#include <uf/utils/io/iostream.h>
+
+#include <unordered_map>
+#include <typeinfo>
+
+#define UF_COMPONENT_POINTERED_USERDATA 0
+
+namespace pod {
+	struct UF_API Component {
+		typedef std::size_t id_t;
+		typedef std::unordered_map<pod::Component::id_t, pod::Component> container_t;
+	//	typedef std::unordered_map<pod::Component::id_t, pod::Component::id_t> alias_t;
+
+		pod::Component::id_t id;
+	#if UF_COMPONENT_POINTERED_USERDATA
+		pod::PointeredUserdata userdata;
+	#else
+		pod::Userdata* userdata;
+	#endif
+	};
+}
+namespace uf {
+	namespace component {
+		extern UF_API uf::MemoryPool memoryPool;
+		template<typename T> pod::Component::id_t type();
+		template<typename T> bool is( const pod::Component& );
+	}
+
+	class UF_API Component {
+	protected:
+		static const bool m_addOn404 = true;
+		pod::Component::container_t m_container;
+	//	pod::Component::alias_t m_aliases;
+	public:
+		~Component();
+	/*
+		template<typename T> bool hasAlias() const;
+		template<typename T, typename U> bool addAlias();
+	*/
+		template<typename T> pod::Component::id_t getType() const;
+		template<typename T> bool hasComponent() const;
+
+		template<typename T> pod::Component* getRawComponentPointer();
+		template<typename T> const pod::Component* getRawComponentPointer() const;
+
+		template<typename T> T* getComponentPointer();
+		template<typename T> const T* getComponentPointer() const;
+
+		template<typename T> T& getComponent();
+		template<typename T> const T& getComponent() const;
+
+		template<typename T> T& addComponent( const T& = T() );
+		template<typename T> void deleteComponent();
+
+		void destroyComponents();
+	};
+}
+
+#include "component.inl"
\ No newline at end of file
diff --git a/engine/inc/uf/utils/component/component.inl b/engine/inc/uf/utils/component/component.inl
new file mode 100644
index 00000000..389e6489
--- /dev/null
+++ b/engine/inc/uf/utils/component/component.inl
@@ -0,0 +1,110 @@
+template<typename T> pod::Component::id_t uf::component::type() {
+	return typeid(T).hash_code();
+}
+template<typename T> bool uf::component::is( const pod::Component& component ) {
+	return uf::component::type<T>() == component.id;
+}
+//
+//
+/*
+template<typename T>
+bool uf::Component::hasAlias() const {
+	return this->m_aliases.count(uf::component::type<T>()) != 0;
+}
+template<typename T, typename U>
+bool uf::Component::addAlias() {
+	if ( this->hasAlias<T>() ) return false;
+	this->m_aliases[uf::component::type<T>()] = this->getType<U>();
+	return true;
+}
+*/
+template<typename T>
+pod::Component::id_t uf::Component::getType() const {
+//	if ( this->hasAlias<T>() ) return this->m_aliases.at(uf::component::type<T>());
+	return uf::component::type<T>();
+}
+
+template<typename T>
+bool uf::Component::hasComponent() const {
+	return !this->m_container.empty() && this->m_container.count(this->getType<T>()) != 0;
+}
+template<typename T>
+pod::Component* uf::Component::getRawComponentPointer() {
+	if ( !this->hasComponent<T>() ) { if ( this->m_addOn404 ) this->addComponent<T>(); else return NULL; }
+	pod::Component::id_t id = this->getType<T>();
+	pod::Component& component = this->m_container[id];
+	return &component;
+}
+template<typename T>
+const pod::Component* uf::Component::getRawComponentPointer() const {
+	if ( !this->hasComponent<T>() ) return NULL;
+	pod::Component::id_t id = this->getType<T>();
+	const pod::Component& component = this->m_container.at(id);
+	return &component;
+}
+template<typename T>
+T* uf::Component::getComponentPointer() {
+	T* pointer = NULL;
+	if ( !this->hasComponent<T>() ) return ( this->m_addOn404 ) ? &this->addComponent<T>() : pointer;
+	pod::Component::id_t id = this->getType<T>();
+	pod::Component& component = this->m_container[id];
+
+#if UF_COMPONENT_POINTERED_USERDATA
+	pointer = &uf::pointeredUserdata::get<T>(component.userdata);
+#else
+	pointer = &uf::userdata::get<T>(component.userdata);
+#endif
+	return pointer;
+}
+template<typename T>
+const T* uf::Component::getComponentPointer() const {
+	const T* pointer = NULL;
+	if ( !this->hasComponent<T>() ) return pointer;
+	pod::Component::id_t id = this->getType<T>();
+	const pod::Component& component = this->m_container.at(id);
+
+#if UF_COMPONENT_POINTERED_USERDATA
+	pointer = &uf::pointeredUserdata::get<T>(component.userdata);
+#else
+	pointer = &uf::userdata::get<T>(component.userdata);
+#endif
+	return pointer;
+}
+template<typename T>
+T& uf::Component::getComponent() {
+	static T null;
+	T* pointer = this->getComponentPointer<T>();
+	return (pointer) ? *pointer : null;
+}
+template<typename T>
+const T& uf::Component::getComponent() const {
+	static T null;
+	const T* pointer = this->getComponentPointer<T>();
+	return (pointer) ? *pointer : null;
+}
+template<typename T> T& uf::Component::addComponent( const T& data ) {
+	if ( this->hasComponent<T>() ) return this->getComponent<T>();
+	
+	pod::Component::id_t id = this->getType<T>();
+	pod::Component& component = this->m_container[id];
+	component.id = id;
+#if UF_COMPONENT_POINTERED_USERDATA
+	component.userdata = uf::pointeredUserdata::create(uf::component::memoryPool, data);
+	T* pointer = &uf::pointeredUserdata::get<T>(component.userdata);
+#else
+	component.userdata = uf::userdata::create(uf::component::memoryPool, data);
+	T* pointer = &uf::userdata::get<T>(component.userdata);
+#endif
+	return *pointer;
+}
+template<typename T> void uf::Component::deleteComponent() {
+	if ( !this->hasComponent<T>() ) return;
+	pod::Component::id_t id = this->getType<T>();
+	pod::Component& component = this->m_container[id];
+
+#if UF_COMPONENT_POINTERED_USERDATA
+	uf::pointeredUserdata::destroy(uf::component::memoryPool, component.userdata);
+#else
+	uf::userdata::destroy(uf::component::memoryPool, component.userdata);
+#endif
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/graphic/descriptor.h b/engine/inc/uf/utils/graphic/descriptor.h
new file mode 100644
index 00000000..7ce090b7
--- /dev/null
+++ b/engine/inc/uf/utils/graphic/descriptor.h
@@ -0,0 +1,102 @@
+#pragma once 	
+
+#if UF_USE_VULKAN
+#include <uf/ext/vulkan/enums.h>
+#define RENDERER vulkan
+#elif UF_USE_OPENGL
+#include <uf/ext/opengl/enums.h>
+#define RENDERER opengl
+#endif
+
+namespace ext {
+	namespace RENDERER {
+	#if UF_ENV_DREAMCAST && !UF_USE_OPENGL_GLDC
+		typedef uint16_t index_t;
+	#else
+		typedef uint32_t index_t;
+	#endif
+		
+		struct /*UF_API*/ VertexDescriptor {
+			ext::RENDERER::enums::Format::type_t format = ext::RENDERER::enums::Format::UNDEFINED; // VK_FORMAT_R32G32B32_SFLOAT
+			size_t offset = 0; // offsetof(Vertex, position)
+			size_t size = 0; // sizeof(Vertex::position::type_t)
+			size_t components = 0; // Vertex::position::size
+			ext::RENDERER::enums::Type::type_t type = 0; // ext::RENDERER::typeToEnum<Vertex::position::type_t>()
+			std::string name = "";
+		};
+	}
+}
+
+namespace uf {
+	struct UF_API BaseGeometry {
+	public:
+		struct {
+			struct {
+				size_t size = 0;
+				void* pointer = NULL;
+				size_t length = 0;
+			} vertex, index;
+			std::vector<ext::RENDERER::VertexDescriptor> descriptor;
+		} attributes;
+
+		void generateIndices();
+		virtual ~BaseGeometry();
+		virtual void updateDescriptor();
+		virtual void resizeVertices( size_t );
+		virtual void resizeIndices( size_t );
+	};
+}
+
+namespace ext {
+	namespace RENDERER {
+		struct UF_API GraphicDescriptor {
+			std::string renderMode = "";
+			uint32_t renderTarget = 0;
+			uint32_t subpass = 0;
+
+			uf::BaseGeometry geometry;
+			size_t indices = 0;
+
+			struct {
+				size_t vertex = 0;
+				size_t index = 0;
+			} offsets;
+
+			ext::RENDERER::enums::PrimitiveTopology::type_t topology = ext::RENDERER::enums::PrimitiveTopology::TRIANGLE_LIST;
+			ext::RENDERER::enums::PolygonMode::type_t fill = ext::RENDERER::enums::PolygonMode::FILL;
+			ext::RENDERER::enums::CullMode::type_t cullMode = ext::RENDERER::enums::CullMode::BACK;
+			ext::RENDERER::enums::Face::type_t frontFace = ext::RENDERER::enums::Face::CW;
+			float lineWidth = 1.0f;
+
+			struct {
+				bool test = true;
+				bool write = true;
+				ext::RENDERER::enums::Compare::type_t operation = ext::RENDERER::enums::Compare::GREATER_OR_EQUAL;
+				struct {
+					bool enable = false;
+					float constant = 0;
+					float slope = 0;
+					float clamp = 0;
+				} bias;
+			} depth;
+
+			std::string hash() const;
+			void parse( ext::json::Value& );
+			bool operator==( const GraphicDescriptor& right ) const { return this->hash() == right.hash(); }
+		};
+	}
+}
+
+#undef UF_RENDERER
+#define UF_VERTEX_DESCRIPTION( TYPE, FORMAT, ATTRIBUTE ) {\
+		uf::renderer::enums::Format::FORMAT,\
+		offsetof(TYPE, ATTRIBUTE),\
+		sizeof(decltype(TYPE::ATTRIBUTE)::type_t),\
+		decltype(TYPE::ATTRIBUTE)::size,\
+		ext::RENDERER::typeToEnum<decltype(TYPE::ATTRIBUTE)::type_t>(),\
+		#ATTRIBUTE\
+	},
+
+#define UF_VERTEX_DESCRIPTOR( TYPE, ... )\
+	std::vector<uf::renderer::VertexDescriptor> TYPE::descriptor = { __VA_ARGS__ };
+	
\ No newline at end of file
diff --git a/engine/inc/uf/utils/graphic/graphic.h b/engine/inc/uf/utils/graphic/graphic.h
new file mode 100644
index 00000000..7ef78aca
--- /dev/null
+++ b/engine/inc/uf/utils/graphic/graphic.h
@@ -0,0 +1,7 @@
+#pragma once
+
+#include <uf/spec/renderer/universal.h>
+
+namespace uf {
+	typedef uf::renderer::Graphic Graphic;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/graphic/mesh.h b/engine/inc/uf/utils/graphic/mesh.h
new file mode 100644
index 00000000..f0f09158
--- /dev/null
+++ b/engine/inc/uf/utils/graphic/mesh.h
@@ -0,0 +1,78 @@
+#pragma once
+
+#include <uf/utils/mesh/mesh.h>
+
+namespace pod {
+	struct /*UF_API*/ Vertex_3F2F3F4F {
+		/*alignas(16)*/ pod::Vector3f position;
+		/*alignas(8)*/ pod::Vector2f uv;
+		/*alignas(16)*/ pod::Vector3f normal;
+		/*alignas(16)*/ pod::Vector4f color;
+
+		static UF_API std::vector<uf::renderer::VertexDescriptor> descriptor;
+	};
+	struct /*UF_API*/ Vertex_3F2F3F32B {
+		/*alignas(16)*/ pod::Vector3f position;
+		/*alignas(8)*/ pod::Vector2f uv;
+		/*alignas(16)*/ pod::Vector3f normal;
+		/*alignas(16)*/ pod::Vector4t<uint8_t> color;
+
+		static UF_API std::vector<uf::renderer::VertexDescriptor> descriptor;
+	};
+	struct /*UF_API*/ Vertex_3F3F3F {
+		/*alignas(16)*/ pod::Vector3f position;
+		/*alignas(16)*/ pod::Vector3f uv;
+		/*alignas(16)*/ pod::Vector3f normal;
+
+		static UF_API std::vector<uf::renderer::VertexDescriptor> descriptor;
+	};
+	struct /*UF_API*/ Vertex_3F2F3F1UI {
+		/*alignas(16)*/ pod::Vector3f position;
+		/*alignas(8)*/ pod::Vector2f uv;
+		/*alignas(16)*/ pod::Vector3f normal;
+		/*alignas(4)*/ pod::Vector1ui id;
+
+		static UF_API std::vector<uf::renderer::VertexDescriptor> descriptor;
+	};
+	struct /*UF_API*/ Vertex_3F2F3F {
+		/*alignas(16)*/ pod::Vector3f position;
+		/*alignas(8)*/ pod::Vector2f uv;
+		/*alignas(16)*/ pod::Vector3f normal;
+
+		static UF_API std::vector<uf::renderer::VertexDescriptor> descriptor;
+	};
+	struct /*UF_API*/ Vertex_3F2F {
+		/*alignas(16)*/ pod::Vector3f position;
+		/*alignas(8)*/ pod::Vector2f uv;
+
+		static UF_API std::vector<uf::renderer::VertexDescriptor> descriptor;
+	};
+	struct /*UF_API*/ Vertex_2F2F {
+		/*alignas(8)*/ pod::Vector2f position;
+		/*alignas(8)*/ pod::Vector2f uv;
+
+		static UF_API std::vector<uf::renderer::VertexDescriptor> descriptor;
+	};
+	struct /*UF_API*/ Vertex_3F {
+		/*alignas(16)*/ pod::Vector3f position;
+
+		static UF_API std::vector<uf::renderer::VertexDescriptor> descriptor;
+	};
+}
+
+namespace uf {
+	typedef BaseMesh<pod::Vertex_3F2F3F32B> ColoredMesh;
+	typedef BaseMesh<pod::Vertex_3F2F3F> Mesh;
+	typedef BaseMesh<pod::Vertex_3F2F> GuiMesh;
+	typedef BaseMesh<pod::Vertex_3F> LineMesh;
+
+	template<size_t N = 6>
+	struct MeshDescriptor {
+		struct {
+			alignas(16) pod::Matrix4f model;
+			alignas(16) pod::Matrix4f view[N];
+			alignas(16) pod::Matrix4f projection[N];
+		} matrices;
+		alignas(16) pod::Vector4f color = { 1, 1, 1, 0 };
+	};
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/hook/function_traits.inl b/engine/inc/uf/utils/hook/function_traits.inl
new file mode 100644
index 00000000..1a332f42
--- /dev/null
+++ b/engine/inc/uf/utils/hook/function_traits.inl
@@ -0,0 +1,51 @@
+#pragma once
+
+template <typename ... Args> constexpr bool return_void(void(Args ...)) { return true; }
+template <typename R, typename ... Args> constexpr bool return_void(R(Args ...)) { return false; }
+
+template <typename Signature> struct count_args;
+
+template <typename Ret, typename... Args> struct count_args<std::function<Ret(Args...)>> {
+    static constexpr size_t value = sizeof...(Args);
+};
+
+// For generic types that are functors, delegate to its 'operator()'
+template <typename T>
+struct function_traits : public function_traits<decltype(&T::operator())> {};
+
+// for pointers to member function
+template <typename ClassType, typename ReturnType, typename... Args>
+struct function_traits<ReturnType(ClassType::*)(Args...) const> {
+    //enum { arity = sizeof...(Args) };
+    static const size_t arguments = sizeof...(Args);
+    template <size_t i>
+	struct Arg {
+		typedef typename std::tuple_element<i, std::tuple<Args...>>::type type;
+	};
+    typedef ReturnType return_type;
+    typedef std::function<ReturnType (Args...)> type;
+};
+
+// for pointers to member function
+template <typename ClassType, typename ReturnType, typename... Args>
+struct function_traits<ReturnType(ClassType::*)(Args...) > {
+	static const size_t arguments = sizeof...(Args);
+	template <size_t i>
+	struct Arg {
+		typedef typename std::tuple_element<i, std::tuple<Args...>>::type type;
+	};
+    typedef ReturnType return_type;
+    typedef std::function<ReturnType (Args...)> type;
+};
+
+// for function pointers
+template <typename ReturnType, typename... Args>
+struct function_traits<ReturnType (*)(Args...)>  {
+	static const size_t arguments = sizeof...(Args);
+	template <size_t i>
+	struct Arg {
+		typedef typename std::tuple_element<i, std::tuple<Args...>>::type type;
+	};
+  typedef ReturnType return_type;
+  typedef std::function<ReturnType (Args...)> type;
+};
\ No newline at end of file
diff --git a/engine/inc/uf/utils/hook/hook.h b/engine/inc/uf/utils/hook/hook.h
new file mode 100644
index 00000000..332a41b7
--- /dev/null
+++ b/engine/inc/uf/utils/hook/hook.h
@@ -0,0 +1,73 @@
+#pragma once
+
+#include <uf/config.h>
+
+#include <uf/utils/userdata/userdata.h> 	// uf::Userdata
+
+#include <string> 							// std::string
+#include <functional> 						// std::function
+#include <vector> 							// std::vector
+#include <unordered_map> 					// std::unordered_map
+
+#include <uf/utils/userdata/userdata.h>
+#include <uf/utils/serialize/serializer.h>
+#include <type_traits>
+
+namespace pod {
+	struct UF_API Hook {
+		typedef std::function<uf::Userdata(const uf::Userdata&)> function_t;
+
+		size_t uid;
+		size_t type;
+		function_t callback;
+	};
+}
+
+namespace uf {
+	class UF_API Hooks {
+	public:
+		typedef std::vector<pod::Hook> hooks_t;
+		typedef std::unordered_map<std::string, hooks_t> container_t;
+
+		typedef std::string name_t;
+		typedef uf::Userdata argument_t;
+		typedef std::vector<uf::Userdata> return_t;
+	protected:
+		static size_t uids;
+		uf::Hooks::container_t m_container;
+	public:
+		bool exists( const name_t& name );
+		size_t addHook( const name_t& name, const pod::Hook::function_t& callback, size_t type = 0 );
+		void removeHook( const name_t& name, size_t uid );
+		return_t call( const name_t& name, const argument_t& payload );
+		
+		return_t call( const name_t& name, const std::string& = "" );
+		return_t call( const name_t& name, const ext::json::Value& );
+		return_t call( const name_t& name, const uf::Serializer& );
+
+		size_t addHook( const name_t& name, const std::function<void()>& callback );
+
+		template<typename Arg>
+		size_t addHook( const uf::Hooks::name_t& name, const std::function<void(Arg)>& callback );
+		template<typename R, typename Arg>
+		size_t addHook( const uf::Hooks::name_t& name, const std::function<R(Arg)>& callback );
+		template<typename Function>
+		size_t addHook( const uf::Hooks::name_t& name, const Function& lambda );
+
+		template<typename T>
+		return_t call( const name_t& name, const T& payload );
+	};
+	
+	extern UF_API uf::Hooks hooks;
+}
+/*
+namespace uf {
+	namespace HookHandler {
+		namespace Readable {
+			typedef std::function<std::string(const std::string&)> function_t;
+		}
+	}
+}
+*/
+#include "function_traits.inl"
+#include "hook.inl"
\ No newline at end of file
diff --git a/engine/inc/uf/utils/hook/hook.inl b/engine/inc/uf/utils/hook/hook.inl
new file mode 100644
index 00000000..10ec8a48
--- /dev/null
+++ b/engine/inc/uf/utils/hook/hook.inl
@@ -0,0 +1,38 @@
+template<typename Arg>
+size_t uf::Hooks::addHook( const uf::Hooks::name_t& name, const std::function<void(Arg)>& callback ) {
+	typedef typename std::remove_reference<Arg>::type Argument;
+	return addHook(name, [=]( const uf::Userdata& userdata ){
+		uf::Userdata ret;
+		
+		const Argument& payload = userdata.is<Argument>() ? userdata.get<Argument>() : Argument{};
+		Argument& unconst_payload = const_cast<Argument&>(payload);
+		callback( unconst_payload );
+		
+		return ret;
+	}, typeid(callback).hash_code());
+}
+template<typename R, typename Arg>
+size_t uf::Hooks::addHook( const uf::Hooks::name_t& name, const std::function<R(Arg)>& callback ) {
+	typedef typename std::remove_reference<Arg>::type Argument;
+	return addHook(name, [=]( const uf::Userdata& userdata ){
+		uf::Userdata ret;
+		const Argument& payload = userdata.is<Argument>() ? userdata.get<Argument>() : Argument{};
+		Argument& unconst_payload = const_cast<Argument&>(payload);
+		R res = callback( unconst_payload );
+		ret.create<R>(res);
+		return ret;
+	}, typeid(callback).hash_code());
+}
+
+template<typename Function>
+size_t uf::Hooks::addHook( const uf::Hooks::name_t& name, const Function& lambda ) {
+	typedef function_traits<Function> Traits;
+	typename Traits::type function = lambda;
+	return addHook(name, function);
+}
+template<typename T>
+uf::Hooks::return_t uf::Hooks::call( const uf::Hooks::name_t& name, const T& p ) {
+	uf::Userdata payload;
+	payload.create<T>(p);
+	return call( name, payload );
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/http/http.h b/engine/inc/uf/utils/http/http.h
new file mode 100644
index 00000000..e21388b1
--- /dev/null
+++ b/engine/inc/uf/utils/http/http.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <uf/config.h>
+#include <string>
+
+namespace uf {
+	struct UF_API Http {
+		std::string header;
+		std::string response;
+		char* effective;
+		long code;
+		double elapsed;
+	};
+	namespace http {
+		uf::Http UF_API get( const std::string& );
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/image/atlas.h b/engine/inc/uf/utils/image/atlas.h
new file mode 100644
index 00000000..0916d6ea
--- /dev/null
+++ b/engine/inc/uf/utils/image/atlas.h
@@ -0,0 +1,68 @@
+#pragma once
+
+#include <uf/utils/image/image.h>
+#include <binpack2d/binpack2d.hpp>
+#include <unordered_map>
+
+namespace uf {
+	class UF_API Atlas {
+	public:
+		struct Identifier {
+			size_t index;
+		};
+		typedef std::vector<uf::Image> images_t;
+		typedef Identifier identifier_t;
+		typedef BinPack2D::CanvasArray<identifier_t> atlas_t;
+	protected:
+		uf::Image m_image;
+		images_t m_images;
+		atlas_t m_atlas;
+	public:
+		void addImage( const uf::Image&, bool = false );
+		void addImage( uf::Image&&, bool = false );
+		void addImage( const uint8_t*, const pod::Vector2ui&, std::size_t, std::size_t, bool = false, bool = false );
+		
+		void generate(float padding = 1);
+		void generate( const images_t&, float padding = 1);
+		void clear();
+		
+		pod::Vector2f mapUv( const pod::Vector2f&, size_t );
+		pod::Vector3f mapUv( const pod::Vector3f& );
+		
+		uf::Image& getAtlas();
+	 	images_t& getImages();
+		const images_t& getImages() const;
+	};
+
+	class UF_API HashAtlas {
+	public:
+		typedef std::string hash_t;
+		typedef std::unordered_map<hash_t, uf::Image> images_t;
+		
+		struct Identifier {
+			hash_t hash;
+		};
+		typedef Identifier identifier_t;
+		typedef BinPack2D::CanvasArray<identifier_t> atlas_t;
+	protected:
+		uf::Image m_image;
+		images_t m_images;
+		atlas_t m_atlas;
+	public:
+		hash_t addImage( const uf::Image&, bool = false );
+		hash_t addImage( uf::Image&&, bool = false );
+		hash_t addImage( const uint8_t*, const pod::Vector2ui&, std::size_t, std::size_t, bool = false, bool = false );
+		
+		void generate(float padding = 1);
+		void generate( const images_t&, float padding = 1);
+		void clear();
+		bool has( const uf::Image& ) const;
+		bool has( const std::string& ) const;
+		
+		pod::Vector2f mapUv( const pod::Vector2f&, const hash_t& );
+		
+		uf::Image& getAtlas();
+	 	images_t& getImages();
+		const images_t& getImages() const;
+	};
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/image/image.h b/engine/inc/uf/utils/image/image.h
new file mode 100644
index 00000000..976a93f4
--- /dev/null
+++ b/engine/inc/uf/utils/image/image.h
@@ -0,0 +1,66 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/utils/math/vector.h>
+#include <vector>
+
+#include "pixel.h"
+
+namespace uf {
+	class UF_API Image {
+	public:
+		typedef pod::Vector2ui vec2_t;
+		typedef pod::PixelRgba8 pixel_t;
+		typedef std::vector<pixel_t::type_t> container_t;
+	protected:
+		std::string m_filename;
+		Image::container_t m_pixels;
+		Image::vec2_t m_dimensions;
+		std::size_t m_bpp;
+		std::size_t m_channels;
+	public:
+	// 	C-tor
+		Image(); 																				// Default
+		Image( const Image::vec2_t& size ); 													// Just Size
+		Image( Image&& move ); 																	// Move pixels
+		Image( const Image& copy ); 															// Copy pixels
+		Image( Image::container_t&& move, const Image::vec2_t& size ); 							// Move from vector of pixels
+		Image( const Image::container_t& copy, const Image::vec2_t& size ); 					// Copy from vector of pixels
+
+		bool open( const std::string& filename, bool = true ); 									// from file
+		void open( const std::istream& stream ); 												// from stream
+		void move( Image::container_t&& move,  const Image::vec2_t& size );						// move from vector of pixels
+		void copy( const Image::container_t& copy,  const Image::vec2_t& size );				// copy from vector of pixels
+		void copy( const uf::Image& );															// copy from image object
+	// 	D-tor
+		~Image();
+		void clear(); 																			// empties pixel container
+	// 	Getters
+		void loadFromBuffer( const Image::pixel_t::type_t* pointer, const pod::Vector2ui& size, std::size_t bpp, std::size_t channels, bool flip = false );
+		void loadFromBuffer( const Image::container_t& container, const pod::Vector2ui& size, std::size_t bpp, std::size_t channels, bool flip = false );
+		std::string getFilename() const;
+		Image::container_t& getPixels();
+		const Image::container_t& getPixels() const;
+		Image::pixel_t::type_t* getPixelsPtr();
+		const Image::pixel_t::type_t* getPixelsPtr() const;
+		Image::vec2_t& getDimensions();
+		const Image::vec2_t& getDimensions() const;
+		std::size_t& getBpp();
+		std::size_t getBpp() const;
+		std::size_t& getChannels();
+		std::size_t getChannels() const;
+		std::string getHash() const;
+		Image::pixel_t at( const Image::vec2_t& at );
+	// 	Modifiers
+		void flip();
+		void padToPowerOfTwo();
+		bool save( const std::string& filename, bool flip = false ) const; 				// to file
+		void save( std::ostream& stream ) const; 										// to stream
+		void convert( const std::string&, const std::string& = "rgba" );
+		Image overlay(const Image& top, const Image::vec2_t& corner = {} ) const; 		// Merges one image on top of another
+		Image replace(const Image::pixel_t& from, const Image::pixel_t& to ) const; 	// Changes all pixel from one color (from), to another (to)
+		Image subImage( const Image::vec2_t& start, const Image::vec2_t& end) const; 	// Crops an image
+	//	Operators
+		uf::Image& operator=(const uf::Image&);
+	};
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/image/pixel.h b/engine/inc/uf/utils/image/pixel.h
new file mode 100644
index 00000000..990ee6f2
--- /dev/null
+++ b/engine/inc/uf/utils/image/pixel.h
@@ -0,0 +1,123 @@
+#pragma once
+
+#include <uf/config.h>
+
+namespace pod {
+	// Simple Pixels (designed [to store in arrays] with minimal headaches)
+	template<typename T = pod::Math::num_t, std::size_t N = 4>
+	struct /*UF_API*/ Pixel {
+	// 	n-dimensional/unspecialized Pixel access
+		T components[N];
+	// 	POD information
+		typedef T type_t;
+		typedef T* container_t;
+		static const std::size_t size = N;
+	// 	Overload access
+		// Accessing Pia subscripts
+		T& operator[](std::size_t i);
+		const T& operator[](std::size_t i) const;
+		// Arithmetic
+		inline Pixel<T,N> operator-() const; 							// 	Negation
+		inline Pixel<T,N> operator*( const Pixel<T,N>& Pixel ) const; 	// 	Multiplication between two Pixels
+		inline Pixel<T,N> operator/( const Pixel<T,N>& Pixel ) const; 	// 	Divison between two Pixels
+		inline Pixel<T,N> operator*( T scalar ) const; 					// 	Multiplication with scalar
+		inline Pixel<T,N> operator/( T scalar ) const; 					// 	Divison with scalar
+		inline Pixel<T,N>& operator *=( const Pixel<T,N>& Pixel ); 		// 	Multiplication set between two Pixels
+		inline Pixel<T,N>& operator /=( const Pixel<T,N>& Pixel ); 		// 	Divison set between two Pixels
+		inline Pixel<T,N>& operator *=( T scalar ); 					// 	Multiplication set with scalar
+		inline Pixel<T,N>& operator /=( T scalar ); 					// 	Divison set with scalar
+		inline bool operator==( const Pixel<T,N>& Pixel ) const; 		// 	Equality check between two Pixels (equals)
+		inline bool operator!=( const Pixel<T,N>& Pixel ) const; 		// 	Equality check between two Pixels (not equals)
+	};
+	template<typename T>
+	struct /*UF_API*/ Pixel<T,3> {
+	// 	XYZ access
+		T r = 0;
+		T g = 0;
+		T b = 0;
+	// 	n-dimensional/unspecialized Pixel access
+		T* components = (T*) this;
+	// 	POD information
+		typedef T type_t;
+		typedef T* container_t;
+		static const std::size_t size = 3;
+	// 	Overload access
+		// Accessing Pia subscripts
+		T& operator[](std::size_t i);
+		const T& operator[](std::size_t i) const;
+		// Arithmetic
+		inline Pixel<T,3> operator-() const; 							// 	Negation
+		inline Pixel<T,3> operator*( const Pixel<T,3>& Pixel ) const; 	// 	Multiplication between two Pixels
+		inline Pixel<T,3> operator/( const Pixel<T,3>& Pixel ) const; 	// 	Divison between two Pixels
+		inline Pixel<T,3> operator*( T scalar ) const; 					// 	Multiplication with scalar
+		inline Pixel<T,3> operator/( T scalar ) const; 					// 	Divison with scalar
+		inline Pixel<T,3>& operator *=( const Pixel<T,3>& Pixel ); 		// 	Multiplication set between two Pixels
+		inline Pixel<T,3>& operator /=( const Pixel<T,3>& Pixel ); 		// 	Divison set between two Pixels
+		inline Pixel<T,3>& operator *=( T scalar ); 					// 	Multiplication set with scalar
+		inline Pixel<T,3>& operator /=( T scalar ); 					// 	Divison set with scalar
+		inline bool operator==( const Pixel<T,3>& Pixel ) const; 		// 	Equality check between two Pixels (equals)
+		inline bool operator!=( const Pixel<T,3>& Pixel ) const; 		// 	Equality check between two Pixels (not equals)
+	};
+	template<typename T>
+	struct /*UF_API*/ Pixel<T,4> {
+	// 	XYZW access
+		T r = 0;
+		T g = 0;
+		T b = 0;
+		T a = 0;
+	// 	n-dimensional/unspecialized Pixel access
+		T* components = (T*) this;
+	// 	POD information
+		typedef T type_t;
+		typedef T* container_t;
+		static const std::size_t size = 4;
+	// 	Overload access
+		// Accessing Pia subscripts
+		T& operator[](std::size_t i);
+		const T& operator[](std::size_t i) const;
+		// Arithmetic
+		inline Pixel<T,4> operator-() const; 							// 	Negation
+		inline Pixel<T,4> operator*( const Pixel<T,4>& Pixel ) const; 	// 	Multiplication between two Pixels
+		inline Pixel<T,4> operator/( const Pixel<T,4>& Pixel ) const; 	// 	Divison between two Pixels
+		inline Pixel<T,4> operator*( T scalar ) const; 					// 	Multiplication with scalar
+		inline Pixel<T,4> operator/( T scalar ) const; 					// 	Divison with scalar
+		inline Pixel<T,4>& operator *=( const Pixel<T,4>& Pixel ); 		// 	Multiplication set between two Pixels
+		inline Pixel<T,4>& operator /=( const Pixel<T,4>& Pixel ); 		// 	Divison set between two Pixels
+		inline Pixel<T,4>& operator *=( T scalar ); 					// 	Multiplication set with scalar
+		inline Pixel<T,4>& operator /=( T scalar ); 					// 	Divison set with scalar
+		inline bool operator==( const Pixel<T,4>& Pixel ) const; 		// 	Equality check between two Pixels (equals)
+		inline bool operator!=( const Pixel<T,4>& Pixel ) const; 		// 	Equality check between two Pixels (not equals)
+	};
+
+	template<typename T = pod::Math::num_t> using Pixel3t = Pixel<T,3>;
+	typedef Pixel<float> Pixel3f;
+	typedef Pixel<double> Pixel3d;
+	typedef Pixel<uint8_t> PixelRgb8;
+
+	template<typename T = pod::Math::num_t> using Pixel4t = Pixel<T,4>;
+	typedef Pixel<float> Pixel4f;
+	typedef Pixel<double> Pixel4d;
+	typedef Pixel<uint8_t> PixelRgba8;
+}
+
+// 	POD pixel accessing/manipulation
+namespace uf {
+	namespace pixel {
+	// 	Equality checking
+		template<typename T> std::size_t /*UF_API*/ compareTo( const T& left, const T& right ); 			// 	Equality check between two pixels (less than)
+		template<typename T> bool /*UF_API*/ equals( const T& left, const T& right ); 						// 	Equality check between two pixels (equals)
+	// 	Basic arithmetic
+		template<typename T> T /*UF_API*/ multiply( const T& left, const T& right );						// 	Multiplies two pixels of same type and size together
+		template<typename T> T /*UF_API*/ multiply( const T& pixel, const typename T::type_t& scalar );	// 	Multiplies this pixel by a scalar
+		template<typename T> T /*UF_API*/ divide( const T& left, const T& right );							// 	Divides two pixels of same type and size together
+		template<typename T> T /*UF_API*/ divide( const T& left, const typename T::type_t& scalar );		// 	Divides this pixel by a scalar
+		template<typename T> T /*UF_API*/ negate( const T& pixel );										// 	Flip sign of all components
+	// 	Writes to first value
+		template<typename T> T& /*UF_API*/ multiply( T& left, const T& right );								// 	Multiplies two pixels of same type and size together
+		template<typename T> T& /*UF_API*/ multiply( T& pixel, const typename T::type_t& scalar );			// 	Multiplies this pixel by a scalar
+		template<typename T> T& /*UF_API*/ divide( T& left, const T& right );								// 	Divides two pixels of same type and size together
+		template<typename T> T& /*UF_API*/ divide( T& left, const typename T::type_t& scalar );				// 	Divides this pixel by a scalar
+		template<typename T> T& /*UF_API*/ negate( T& pixel );												// 	Flip sign of all components
+	}
+}
+#include "pixel.inl"
\ No newline at end of file
diff --git a/engine/inc/uf/utils/image/pixel.inl b/engine/inc/uf/utils/image/pixel.inl
new file mode 100644
index 00000000..963c45bc
--- /dev/null
+++ b/engine/inc/uf/utils/image/pixel.inl
@@ -0,0 +1,128 @@
+#include <uf/config.h>
+#include <cstring> // memcmp
+
+// 	Equality checking
+template<typename T> 														// 	Equality check between two pixels (less than)
+std::size_t /*UF_API*/ uf::pixel::compareTo( const T& left, const T& right ) {
+	return memcmp( &left, &right, T::size );
+}
+template<typename T> 														// 	Equality check between two pixels (equals)
+bool /*UF_API*/ uf::pixel::equals( const T& left, const T& right ) {
+	return !compareTo(left, right);
+}
+// Basic arithmetic
+template<typename T> 														// Multiplies two pixels of same type and size together
+T /*UF_API*/ uf::pixel::multiply( const T& left, const T& right ) {
+	T res;
+	for ( std::size_t i = 0; i < T::size; ++i ) res[i] = left[i] * right[i];
+	return res;
+}
+template<typename T> 														// Multiplies this pixel by a scalar
+T /*UF_API*/ uf::pixel::multiply( const T& pixel, const typename T::type_t& scalar ) {
+	T res;
+	for ( std::size_t i = 0; i < T::size; ++i ) res[i] = pixel[i] * scalar;
+	return res;
+}
+template<typename T> 														// Divides two pixels of same type and size together
+T /*UF_API*/ uf::pixel::divide( const T& left, const T& right ) {
+	T res;
+	for ( std::size_t i = 0; i < T::size; ++i ) res[i] = left[i] / right[i];
+	return res;
+}
+template<typename T> 														// Divides this pixel by a scalar
+T /*UF_API*/ uf::pixel::divide( const T& pixel, const typename T::type_t& scalar ) {
+	T res;
+	for ( std::size_t i = 0; i < T::size; ++i ) res[i] = pixel[i] / scalar;
+	return res;
+}
+template<typename T> 														// Invert the color
+T /*UF_API*/ uf::pixel::negate( const T& pixel ) {
+	typename T::type_t max = 0;
+	max = ~0;
+	typename T::type_t res = 0;
+	for ( std::size_t i = 0; i < T::size; ++i ) res[i] = max - res[i];
+	return res;
+}
+// Writes to first value
+template<typename T> 														// Multiplies two pixels of same type and size together
+T& /*UF_API*/ uf::pixel::multiply( T& left, const T& right ) {
+	for ( std::size_t i = 0; i < T::size; ++i ) left[i] *= right[i];
+	return left;
+}
+template<typename T> 														// Multiplies this pixel by a scalar
+T& /*UF_API*/ uf::pixel::multiply( T& pixel, const typename T::type_t& scalar ) {
+	for ( std::size_t i = 0; i < T::size; ++i ) pixel[i] * scalar;
+	return pixel;
+}
+template<typename T> 														// Divides two pixels of same type and size together
+T& /*UF_API*/ uf::pixel::divide( T& left, const T& right ) {
+	for ( std::size_t i = 0; i < T::size; ++i ) left[i] /= right[i];
+	return left;
+}
+template<typename T> 														// Divides this pixel by a scalar
+T& /*UF_API*/ uf::pixel::divide( T& pixel, const typename T::type_t& scalar ) {
+	for ( std::size_t i = 0; i < T::size; ++i ) pixel[i] /= scalar;
+	return pixel;
+}
+template<typename T> 														// Flip sign of all components
+T& /*UF_API*/ uf::pixel::negate( T& pixel ) {
+	for ( std::size_t i = 0; i < T::size; ++i ) pixel[i] = -pixel[i];
+	return pixel;
+}
+
+
+//
+template<typename T, std::size_t N>
+T& pod::Pixel<T,N>::operator[](std::size_t i) {
+	return this->components[i];
+}
+template<typename T, std::size_t N>
+const T& pod::Pixel<T,N>::operator[](std::size_t i) const {
+	return this->components[i];
+}
+// Arithmetic
+template<typename T, std::size_t N> 												// 	Negation
+inline pod::Pixel<T,N> pod::Pixel<T,N>::operator-() const {
+	return uf::pixel::negate( *this );
+}
+template<typename T, std::size_t N> 												// 	Multiplication between two pixels
+inline pod::Pixel<T,N> pod::Pixel<T,N>::operator*( const pod::Pixel<T,N>& pixel ) const {
+	return uf::pixel::multiply( *this, pixel );
+}
+template<typename T, std::size_t N> 												// 	Division between two pixels
+inline pod::Pixel<T,N> pod::Pixel<T,N>::operator/( const pod::Pixel<T,N>& pixel ) const {
+	return uf::pixel::divide( *this, pixel );
+}
+template<typename T, std::size_t N> 												// 	Multiplication with scalar
+inline pod::Pixel<T,N> pod::Pixel<T,N>::operator*( T scalar ) const {
+	return uf::pixel::multiply( *this, scalar );
+}
+template<typename T, std::size_t N> 												// 	Division with scalar
+inline pod::Pixel<T,N> pod::Pixel<T,N>::operator/( T scalar ) const {
+	return uf::pixel::divide( *this, scalar );
+}
+template<typename T, std::size_t N> 												// 	Multiplication set between two pixels
+inline pod::Pixel<T,N>& pod::Pixel<T,N>::operator *=( const pod::Pixel<T,N>& pixel ) {
+	return uf::pixel::multiply( *this, pixel );
+}
+template<typename T, std::size_t N> 												// 	Division set between two pixels
+inline pod::Pixel<T,N>& pod::Pixel<T,N>::operator /=( const pod::Pixel<T,N>& pixel ) {
+	return uf::pixel::divide( *this, pixel );
+}
+template<typename T, std::size_t N> 												// 	Multiplication set with scalar
+inline pod::Pixel<T,N>& pod::Pixel<T,N>::operator *=( T scalar ) {
+	return uf::pixel::multiply( *this, scalar );
+}
+template<typename T, std::size_t N> 												// 	Division set with scalar
+inline pod::Pixel<T,N>& pod::Pixel<T,N>::operator /=( T scalar ) {
+	return uf::pixel::divide( *this, scalar );
+}
+template<typename T, std::size_t N> 												// 	Equality check between two pixels (equals)
+inline bool pod::Pixel<T,N>::operator==( const pod::Pixel<T,N>& pixel ) const {
+	return uf::pixel::equals(pixel);
+}
+template<typename T, std::size_t N> 												// 	Equality check between two pixels (not equals)
+inline bool pod::Pixel<T,N>::operator!=( const pod::Pixel<T,N>& pixel ) const {
+	return !uf::pixel::equals(pixel);
+}
+#include "redundancy.inl"
\ No newline at end of file
diff --git a/engine/inc/uf/utils/image/redundancy.inl b/engine/inc/uf/utils/image/redundancy.inl
new file mode 100644
index 00000000..7e4e6ebc
--- /dev/null
+++ b/engine/inc/uf/utils/image/redundancy.inl
@@ -0,0 +1,109 @@
+//
+template<typename T>
+T& pod::Pixel<T,3>::operator[](std::size_t i) {
+	return this->components[i];
+}
+template<typename T>
+const T& pod::Pixel<T,3>::operator[](std::size_t i) const {
+	return this->components[i];
+}
+// Arithmetic
+template<typename T>																		// 	Negation
+inline pod::Pixel<T,3> pod::Pixel<T,3>::operator-() const {
+	return uf::pixel::negate( *this );
+}
+template<typename T>																		// 	Multiplication between two pixels
+inline pod::Pixel<T,3> pod::Pixel<T,3>::operator*( const pod::Pixel<T,3>& pixel ) const {
+	return uf::pixel::multiply( *this, pixel );
+}
+template<typename T>																		// 	Division between two pixels
+inline pod::Pixel<T,3> pod::Pixel<T,3>::operator/( const pod::Pixel<T,3>& pixel ) const {
+	return uf::pixel::divide( *this, pixel );
+}
+template<typename T>																		// 	Multiplication with scalar
+inline pod::Pixel<T,3> pod::Pixel<T,3>::operator*( T scalar ) const {
+	return uf::pixel::multiply( *this, scalar );
+}
+template<typename T>																		// 	Division with scalar
+inline pod::Pixel<T,3> pod::Pixel<T,3>::operator/( T scalar ) const {
+	return uf::pixel::divide( *this, scalar );
+}
+template<typename T>																		// 	Multiplication set between two pixels
+inline pod::Pixel<T,3>& pod::Pixel<T,3>::operator *=( const pod::Pixel<T,3>& pixel ) {
+	return uf::pixel::multiply( *this, pixel );
+}
+template<typename T>																		// 	Division set between two pixels
+inline pod::Pixel<T,3>& pod::Pixel<T,3>::operator /=( const pod::Pixel<T,3>& pixel ) {
+	return uf::pixel::divide( *this, pixel );
+}
+template<typename T>																		// 	Multiplication set with scalar
+inline pod::Pixel<T,3>& pod::Pixel<T,3>::operator *=( T scalar ) {
+	return uf::pixel::multiply( *this, scalar );
+}
+template<typename T>																		// 	Division set with scalar
+inline pod::Pixel<T,3>& pod::Pixel<T,3>::operator /=( T scalar ) {
+	return uf::pixel::divide( *this, scalar );
+}
+template<typename T>																		// 	Equality check between two pixels (equals)
+inline bool pod::Pixel<T,3>::operator==( const pod::Pixel<T,3>& pixel ) const {
+	return uf::pixel::equals(pixel);
+}
+template<typename T>																		// 	Equality check between two pixels (not equals)
+inline bool pod::Pixel<T,3>::operator!=( const pod::Pixel<T,3>& pixel ) const {
+	return !uf::pixel::equals(pixel);
+}
+
+//
+template<typename T>
+T& pod::Pixel<T,4>::operator[](std::size_t i) {
+	return this->components[i];
+}
+template<typename T>
+const T& pod::Pixel<T,4>::operator[](std::size_t i) const {
+	return this->components[i];
+}
+// Arithmetic
+template<typename T>																		// 	Negation
+inline pod::Pixel<T,4> pod::Pixel<T,4>::operator-() const {
+	return uf::pixel::negate( *this );
+}
+template<typename T>																		// 	Multiplication between two pixels
+inline pod::Pixel<T,4> pod::Pixel<T,4>::operator*( const pod::Pixel<T,4>& pixel ) const {
+	return uf::pixel::multiply( *this, pixel );
+}
+template<typename T>																		// 	Division between two pixels
+inline pod::Pixel<T,4> pod::Pixel<T,4>::operator/( const pod::Pixel<T,4>& pixel ) const {
+	return uf::pixel::divide( *this, pixel );
+}
+template<typename T>																		// 	Multiplication with scalar
+inline pod::Pixel<T,4> pod::Pixel<T,4>::operator*( T scalar ) const {
+	return uf::pixel::multiply( *this, scalar );
+}
+template<typename T>																		// 	Division with scalar
+inline pod::Pixel<T,4> pod::Pixel<T,4>::operator/( T scalar ) const {
+	return uf::pixel::divide( *this, scalar );
+}
+template<typename T>																		// 	Multiplication set between two pixels
+inline pod::Pixel<T,4>& pod::Pixel<T,4>::operator *=( const pod::Pixel<T,4>& pixel ) {
+	return uf::pixel::multiply( *this, pixel );
+}
+template<typename T>																		// 	Division set between two pixels
+inline pod::Pixel<T,4>& pod::Pixel<T,4>::operator /=( const pod::Pixel<T,4>& pixel ) {
+	return uf::pixel::divide( *this, pixel );
+}
+template<typename T>																		// 	Multiplication set with scalar
+inline pod::Pixel<T,4>& pod::Pixel<T,4>::operator *=( T scalar ) {
+	return uf::pixel::multiply( *this, scalar );
+}
+template<typename T>																		// 	Division set with scalar
+inline pod::Pixel<T,4>& pod::Pixel<T,4>::operator /=( T scalar ) {
+	return uf::pixel::divide( *this, scalar );
+}
+template<typename T>																		// 	Equality check between two pixels (equals)
+inline bool pod::Pixel<T,4>::operator==( const pod::Pixel<T,4>& pixel ) const {
+	return uf::pixel::equals(pixel);
+}
+template<typename T>																		// 	Equality check between two pixels (not equals)
+inline bool pod::Pixel<T,4>::operator!=( const pod::Pixel<T,4>& pixel ) const {
+	return !uf::pixel::equals(pixel);
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/io/file.h b/engine/inc/uf/utils/io/file.h
new file mode 100644
index 00000000..a95a297b
--- /dev/null
+++ b/engine/inc/uf/utils/io/file.h
@@ -0,0 +1,26 @@
+#pragma once
+
+#include <uf/config.h>
+#include <string>
+#include <vector>
+
+namespace uf {
+	namespace io {
+		extern UF_API const std::string root;
+
+		std::string UF_API absolute( const std::string& );
+		std::string UF_API filename( const std::string& );
+		std::string UF_API basename( const std::string& );
+		std::string UF_API extension( const std::string& );
+		std::string UF_API extension( const std::string&, int32_t );
+		std::string UF_API directory( const std::string& );
+		std::string UF_API sanitize( const std::string&, const std::string& = "" );
+		std::string UF_API readAsString( const std::string&, const std::string& = "" );
+		std::vector<uint8_t> UF_API readAsBuffer( const std::string&, const std::string& = "" );
+		std::string UF_API hash( const std::string& );
+		bool UF_API exists( const std::string& );
+		size_t UF_API mtime( const std::string& );
+		bool UF_API mkdir( const std::string& );
+		std::string UF_API resolveURI( const std::string&, const std::string& = "" );
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/io/iostream.h b/engine/inc/uf/utils/io/iostream.h
new file mode 100644
index 00000000..57cf772e
--- /dev/null
+++ b/engine/inc/uf/utils/io/iostream.h
@@ -0,0 +1,116 @@
+#pragma once
+#include <uf/config.h>
+
+#include <string>
+
+#include <iostream>
+#include <sstream>
+#include <vector>
+#include <unordered_map>
+
+#include <uf/utils/serialize/serializer.h>
+#include <uf/utils/string/string.h>
+
+namespace uf {
+	class UF_API IoStream {
+	public:
+		struct UF_API color_t {
+			short id;
+			short foreground;
+			short background;
+			std::string name;
+		};
+	
+		class UF_API Color {
+		public:
+			class UF_API Manip1 {
+			friend class uf::IoStream;
+			friend class uf::IoStream::Color;
+			protected:
+				uf::IoStream& io;
+				UF_API_CALL Manip1( uf::IoStream& );
+			public:
+				uf::IoStream& UF_API_CALL operator<<( const std::string& name );
+			};
+			class UF_API Manip2 {
+			friend class uf::IoStream;
+			friend class uf::IoStream::Color;
+			protected:
+				std::string name;
+
+				UF_API_CALL Manip2( const std::string& = "" );
+			};
+
+			uf::IoStream::Color::Manip2 UF_API_CALL operator()( const std::string& = "" ) const;
+			uf::IoStream& UF_API_CALL operator()( uf::IoStream&, const std::string& = "" ) const;
+		};
+
+		typedef std::unordered_map<std::string, uf::IoStream::color_t> color_container_t;
+		static bool ncurses;
+	protected:
+		std::string m_currentColor;
+		uf::IoStream::color_container_t m_registeredColors;
+	public:
+		UF_API_CALL IoStream();
+		~IoStream();
+
+		void UF_API_CALL initialize();
+		void UF_API_CALL terminate();
+		void UF_API_CALL clear(bool = true);
+		void UF_API_CALL back();
+		std::string getBuffer();
+		std::vector<std::string> getHistory();
+		
+		char UF_API_CALL readChar(const bool& = true);
+		std::string UF_API_CALL readString(const bool& = true);
+		uf::String UF_API_CALL readUString(const bool& = true);
+		void UF_API_CALL operator>> (bool&);
+		void UF_API_CALL operator>> (short&);
+		void UF_API_CALL operator>> (unsigned short&);
+		void UF_API_CALL operator>> (char&);
+		void UF_API_CALL operator>> (int&);
+		void UF_API_CALL operator>> (unsigned int&);
+		void UF_API_CALL operator>> (long&);
+		void UF_API_CALL operator>> (unsigned long&);
+		void UF_API_CALL operator>> (long long&);
+		void UF_API_CALL operator>> (unsigned long long&);
+		void UF_API_CALL operator>> (float&);
+		void UF_API_CALL operator>> (double&);
+		void UF_API_CALL operator>> (long double&);
+		void UF_API_CALL operator>> (std::string&);
+		void UF_API_CALL operator>> (uf::String&);
+		std::istream& UF_API_CALL operator>> ( std::istream& );
+		friend std::istream& UF_API_CALL operator>> ( std::istream&, uf::IoStream& );
+
+		char UF_API_CALL writeChar(char);
+		const std::string& UF_API_CALL writeString(const std::string&);
+		const uf::String& UF_API_CALL writeUString(const uf::String&);
+		uf::IoStream& UF_API_CALL operator<< (const bool&);
+		uf::IoStream& UF_API_CALL operator<< (const short&);
+		uf::IoStream& UF_API_CALL operator<< (const unsigned short&);
+		uf::IoStream& UF_API_CALL operator<< (const char&);
+		uf::IoStream& UF_API_CALL operator<< (const int&);
+		uf::IoStream& UF_API_CALL operator<< (const unsigned int&);
+		uf::IoStream& UF_API_CALL operator<< (const long&);
+		uf::IoStream& UF_API_CALL operator<< (const unsigned long&);
+		uf::IoStream& UF_API_CALL operator<< (const long long&);
+		uf::IoStream& UF_API_CALL operator<< (const unsigned long long&);
+		uf::IoStream& UF_API_CALL operator<< (const float&);
+		uf::IoStream& UF_API_CALL operator<< (const double&);
+		uf::IoStream& UF_API_CALL operator<< (const long double&);
+		uf::IoStream& UF_API_CALL operator<< (const std::string&);
+		uf::IoStream& UF_API_CALL operator<< (const uf::String&);
+		uf::IoStream& UF_API_CALL operator<< (const char*);
+		uf::IoStream& UF_API_CALL operator<< (const uf::Serializer& val);
+		uf::IoStream& UF_API_CALL operator<< ( void* );
+		uf::IoStream& UF_API_CALL operator<< ( std::ostream& );
+		friend std::ostream& UF_API_CALL operator<< ( std::ostream&, uf::IoStream& );
+
+		uf::IoStream::Color::Manip1 UF_API_CALL operator<< ( const uf::IoStream::Color& );
+		uf::IoStream& UF_API_CALL operator<< ( const uf::IoStream::Color::Manip2& );
+		
+		std::string UF_API_CALL getColor();
+		void UF_API_CALL setColor( const std::string& );
+	};
+	extern UF_API uf::IoStream iostream;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/math/angle.h b/engine/inc/uf/utils/math/angle.h
new file mode 100644
index 00000000..ced677f1
--- /dev/null
+++ b/engine/inc/uf/utils/math/angle.h
@@ -0,0 +1,61 @@
+#pragma once
+
+#include <uf/config.h>
+
+#include <cmath>
+#include <stdint.h>
+
+namespace pod {
+	// 	Simple angle
+	struct UF_API Angle {
+		// 	Enums to store unit information
+		enum Unit {
+			RADIANS,
+			DEGREES,
+			GRADIANS,
+			UNKNOWN,
+			DEFAULT = RADIANS,
+		};
+		// 	Type to store angle measures in
+		typedef double type_t;
+
+		Angle::type_t angle; 	// Angle measure
+		Angle::Unit unit; 		// Unit angle is stored as
+	};
+}
+
+namespace uf {
+	// 	Provides operations for POD angle
+	class UF_API Angle {
+	public:
+	// 	Easily access POD's type
+		typedef pod::Angle pod_t;
+	// 	Replicate POD information
+		typedef Angle::pod_t::Unit Unit;
+		typedef Angle::pod_t::type_t type_t;
+	protected:
+	// 	POD storage
+		Angle::pod_t m_pod;
+	public:
+	// 	C-tor
+		Angle(const Angle::type_t& def = 0, Angle::Unit unit = Angle::Unit::DEFAULT); 					// initializes POD to 'def'
+		Angle(const Angle::pod_t& pod); 																// copies POD altogether
+	// 	D-tor
+		// Unneccesary
+	// 	POD access
+		Angle::pod_t& data(); 																			// 	Returns a reference of POD
+		const Angle::pod_t& data() const; 																// 	Returns a const-reference of POD
+	// 	Alternative POD access
+		Angle::type_t& get();																			// 	Returns a pointer to the angle measure
+		const Angle::type_t& get() const; 																// 	Returns a const-pointer to the angle measure
+	// 	POD manipulation
+		Angle::type_t& set(const Angle& angle);															// 	Sets the angle measure (from Angle object)
+		Angle::type_t& set(const Angle::type_t& val = 0);												// 	Sets the angle measure (from POD Angle)
+		Angle::type_t& set(const Angle::pod_t& pod);													// 	Sets the angle measure (from value) (performs no conversion)
+		Angle::type_t& set(const Angle::type_t& val = 0, Angle::Unit unit = Angle::Unit::DEFAULT);		// 	Sets the angle measure (from value and enum) (performs conversion (if necessary))
+	// 	POD manipulation
+		Angle& convert( Angle::Unit unit ); 															// 	Converts from current unit to desired unit (does nothing if current == desired)
+
+
+	};
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/math/collision.h b/engine/inc/uf/utils/math/collision.h
new file mode 100644
index 00000000..7db8db80
--- /dev/null
+++ b/engine/inc/uf/utils/math/collision.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <uf/config.h>
+
+#include "./collision/gjk.h"
+#include "./collision/boundingbox.h"
+#include "./collision/sphere.h"
+#include "./collision/mesh.h"
+#include <vector>
+
+namespace uf {
+	class UF_API Collider {
+	public:
+		typedef std::vector<pod::Collider*> container_t;
+	protected:
+		uf::Collider::container_t m_container;
+	public:
+		~Collider();
+		void clear();
+
+		void add( pod::Collider* );
+		uf::Collider::container_t& getContainer();
+		const uf::Collider::container_t& getContainer() const;
+		
+		std::size_t getSize() const;
+
+		std::vector<pod::Collider::Manifold> intersects( const uf::Collider&, bool = false ) const;
+		std::vector<pod::Collider::Manifold> intersects( const pod::Collider&, bool = false ) const;
+	};
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/math/collision/boundingbox.h b/engine/inc/uf/utils/math/collision/boundingbox.h
new file mode 100644
index 00000000..c4792322
--- /dev/null
+++ b/engine/inc/uf/utils/math/collision/boundingbox.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#include "gjk.h"
+
+namespace uf {
+	class UF_API BoundingBox : public pod::Collider {
+	protected:
+		pod::Vector3 m_origin;
+		pod::Vector3 m_corner;
+	public:
+		BoundingBox( const pod::Vector3& = {}, const pod::Vector3& = {} );
+		
+		const pod::Vector3& getOrigin() const;
+		const pod::Vector3& getCorner() const;
+		void setOrigin( const pod::Vector3& );
+		void setCorner( const pod::Vector3& );
+		
+		pod::Vector3 min() const;
+		pod::Vector3 max() const;
+		pod::Vector3 closest( const pod::Vector3f& ) const;
+
+		virtual std::string type() const;
+		virtual pod::Vector3* expand() const;
+		virtual pod::Vector3 support( const pod::Vector3& ) const;
+		pod::Collider::Manifold intersects( const uf::BoundingBox& ) const;
+	};
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/math/collision/gjk.h b/engine/inc/uf/utils/math/collision/gjk.h
new file mode 100644
index 00000000..de14c442
--- /dev/null
+++ b/engine/inc/uf/utils/math/collision/gjk.h
@@ -0,0 +1,88 @@
+#pragma once
+
+#include <uf/config.h>
+
+#include <uf/utils/math/vector.h>
+#include <uf/utils/math/transform.h>
+
+namespace pod {
+	struct UF_API Simplex {
+	public:
+		struct UF_API SupportPoint {
+			pod::Vector3 a, b, v;
+			bool operator==( const pod::Simplex::SupportPoint& r ) const {
+				return v == r.v;
+			}
+			pod::Vector3 operator-( const pod::Simplex::SupportPoint& r ) const {
+				return v - r.v;
+			}
+			pod::Vector3 operator*( float r ) const {
+				return v * r;
+			}
+			pod::Vector3 operator-( const pod::Vector3& r ) const {
+				return v - r;
+			}
+			pod::Math::num_t dot( const pod::Vector3& r ) const {
+				return uf::vector::dot(v, r);
+			}
+			pod::Vector3 cross( const pod::Simplex::SupportPoint& r ) const {
+				return uf::vector::cross(v, r.v);
+			}
+			pod::Vector3 cross( const pod::Vector3& r ) const {
+				return uf::vector::cross(v, r);
+			}
+		};
+		int size = 0;
+		pod::Simplex::SupportPoint b, c, d;
+	/*	
+		pod::Vector3 b, c, d;
+		Simplex( const pod::Vector3& = pod::Vector3(), const pod::Vector3& = pod::Vector3(), const pod::Vector3& = pod::Vector3() );
+		void add( const pod::Vector3& );
+		void set( const pod::Vector3& = pod::Vector3(), const pod::Vector3& = pod::Vector3(), const pod::Vector3& = pod::Vector3() );
+	*/
+	};
+}
+namespace pod {
+	class UF_API Collider {
+	protected:
+		pod::Transform<> m_transform;
+	public:
+		struct UF_API Manifold {
+			const pod::Collider* a;
+			const pod::Collider* b;
+			pod::Vector3 normal;
+			float depth;
+			bool colliding;
+
+			Manifold() {
+				this->normal = pod::Vector3{0.0f, 0.0f, 0.0f};
+				this->depth = -0.1f;
+				this->colliding = false;
+			}
+			Manifold( const pod::Collider& a, const pod::Collider& b ) {
+				this->a = &a;
+				this->b = &b;
+				this->normal = pod::Vector3{0.0f, 0.0f, 0.0f};
+				this->depth = -0.1f;
+				this->colliding = false;
+			}
+			Manifold( const pod::Collider& a, const pod::Collider& b, const pod::Vector3& normal, float depth, bool colliding ) {
+				this->a = &a;
+				this->b = &b;
+				this->normal = normal;
+				this->depth = depth;
+				this->colliding = colliding;
+			}
+		};
+		virtual ~Collider();
+		virtual std::string type() const;
+		virtual pod::Vector3* expand() const = 0;
+		virtual pod::Vector3 support( const pod::Vector3& ) const = 0;
+		pod::Collider::Manifold intersects( const pod::Collider& ) const;
+
+		pod::Vector3f getPosition() const;
+		pod::Transform<>& getTransform();
+		const pod::Transform<>& getTransform() const;
+		void setTransform( const pod::Transform<>& );
+	};
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/math/collision/mesh.h b/engine/inc/uf/utils/math/collision/mesh.h
new file mode 100644
index 00000000..0ebb50b5
--- /dev/null
+++ b/engine/inc/uf/utils/math/collision/mesh.h
@@ -0,0 +1,33 @@
+#pragma once
+
+#include "gjk.h"
+#include <uf/utils/graphic/mesh.h>
+
+namespace uf {
+	class UF_API MeshCollider : public pod::Collider {
+	protected:
+		std::vector<pod::Vector3> m_positions;
+	public:
+		MeshCollider( const pod::Transform<>& = {}, const std::vector<pod::Vector3>& = {} );
+
+	 	std::vector<pod::Vector3>& getPositions();
+	 	const std::vector<pod::Vector3>& getPositions() const;
+		
+		void setPositions( const std::vector<pod::Vector3>& );
+		
+		template<typename T, typename U>
+		void setPositions( const uf::BaseMesh<T, U>& mesh ) {
+			this->m_positions.clear();
+			this->m_positions.reserve( std::max( mesh.vertices.size(), mesh.indices.size() ) );
+			if ( !mesh.indices.empty() ) {
+				for ( auto& index : mesh.indices ) this->m_positions.push_back( mesh.vertices[index].position );
+			} else {
+				for ( auto& vertex : mesh.vertices ) this->m_positions.push_back( vertex.position );
+			}
+		}
+
+		virtual std::string type() const;
+		virtual pod::Vector3* expand() const;
+		virtual pod::Vector3 support( const pod::Vector3& ) const;
+	};
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/math/collision/modular.h b/engine/inc/uf/utils/math/collision/modular.h
new file mode 100644
index 00000000..c515716b
--- /dev/null
+++ b/engine/inc/uf/utils/math/collision/modular.h
@@ -0,0 +1,34 @@
+#pragma once
+
+#include "gjk.h"
+#include <functional>
+
+namespace uf {
+	class UF_API ModularCollider : public pod::Collider {
+	public:
+		typedef std::function<pod::Vector3*()> function_expand_t;
+		typedef std::function<pod::Vector3(const pod::Vector3&)> function_support_t;
+	protected:
+		uint m_len;
+		pod::Vector3* m_container;
+
+		bool m_should_free;
+
+		uf::ModularCollider::function_expand_t m_function_expand;
+		uf::ModularCollider::function_support_t m_function_support;
+	public:
+		ModularCollider( uint len = 0, pod::Vector3* = NULL, bool = false, const uf::ModularCollider::function_expand_t& = NULL, const uf::ModularCollider::function_support_t& = NULL );
+		~ModularCollider();
+		
+		void setExpand( const uf::ModularCollider::function_expand_t& = NULL );
+		void setSupport( const uf::ModularCollider::function_support_t& = NULL );
+		
+		pod::Vector3* getContainer();
+		uint getSize() const;
+		void setContainer( pod::Vector3*, uint );
+
+		virtual std::string type() const;
+		virtual pod::Vector3* expand() const;
+		virtual pod::Vector3 support( const pod::Vector3& ) const;
+	};
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/math/collision/sphere.h b/engine/inc/uf/utils/math/collision/sphere.h
new file mode 100644
index 00000000..4dc71ecc
--- /dev/null
+++ b/engine/inc/uf/utils/math/collision/sphere.h
@@ -0,0 +1,24 @@
+#pragma once
+
+#include "gjk.h"
+
+namespace uf {
+	class UF_API SphereCollider : public pod::Collider {
+	protected:
+		float m_radius;
+		pod::Vector3 m_origin;
+	public:
+		SphereCollider( float = 1.0f, const pod::Vector3& = pod::Vector3{} );
+
+		float getRadius() const;
+		const pod::Vector3& getOrigin() const;
+		
+		void setRadius( float = 1.0f );
+		void setOrigin( const pod::Vector3& );
+
+		virtual std::string type() const;
+		virtual pod::Vector3* expand() const;
+		virtual pod::Vector3 support( const pod::Vector3& ) const;
+		pod::Collider::Manifold intersects( const uf::SphereCollider& ) const;
+	};
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/math/glm.h b/engine/inc/uf/utils/math/glm.h
new file mode 100644
index 00000000..82a69fa1
--- /dev/null
+++ b/engine/inc/uf/utils/math/glm.h
@@ -0,0 +1,11 @@
+#pragma once
+
+#include <uf/config.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtx/transform.hpp>
+#include <glm/gtc/quaternion.hpp>
+#include <glm/gtx/quaternion.hpp>
+#include <glm/gtx/rotate_vector.hpp>
+#include <glm/matrix.hpp>
+#include <glm/gtc/matrix_transform.hpp>
\ No newline at end of file
diff --git a/engine/inc/uf/utils/math/math.h b/engine/inc/uf/utils/math/math.h
new file mode 100644
index 00000000..f0709b07
--- /dev/null
+++ b/engine/inc/uf/utils/math/math.h
@@ -0,0 +1,26 @@
+#pragma once
+
+#include <uf/config.h>
+#include <cstdint>
+
+namespace pod {
+	namespace Math {
+		typedef float num_t;
+	}
+}
+
+namespace {
+// Sometimes uint isn't declared
+	typedef unsigned int uint;
+}
+namespace uf {
+	namespace math {
+		uint16_t UF_API quantizeShort( float );
+		float UF_API unquantize( uint16_t );
+
+		template<typename T>
+		T lerp( const T& a, const T& b, double f ) {
+			return a + f * (b - a);
+		}
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/math/matrix.h b/engine/inc/uf/utils/math/matrix.h
new file mode 100644
index 00000000..1a718b8d
--- /dev/null
+++ b/engine/inc/uf/utils/math/matrix.h
@@ -0,0 +1,184 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/utils/math/vector.h>
+#ifdef UF_USE_GLM
+	#include "glm.h"
+#endif
+
+#include "math.h"
+namespace pod {
+	template<typename T = pod::Math::num_t, std::size_t R = 4, std::size_t C = R> 
+	struct /*UF_API*/ alignas(16) Matrix {
+	// 	n-dimensional/unspecialized matrix access
+		T components[R*C] = {};
+	//	T components[R][C] = {};
+	//	T* array = (T*) this;
+	// 	POD information
+		typedef T type_t;
+		typedef T* container_t;
+		static const std::size_t rows = R;
+		static const std::size_t columns = C;
+	// 	Overload access
+		// Accessing via subscripts
+		inline T& operator[](std::size_t i);
+		inline const T& operator[](std::size_t i) const;
+		
+		inline T& operator()(size_t r, size_t c);
+		inline const T& operator()(size_t r, size_t c) const;
+
+		// Arithmetic
+		Matrix<T,R,C> operator()() const; 								// 	Creation
+		Matrix<T,R,C> operator-() const; 								// 	Negation
+		Matrix<T,R,C> operator*( const Matrix<T,R,C>& matrix ) const; 	// 	Multiplication between two matrices
+		Matrix<T,R,C> operator*( T scalar ) const; 						// 	Multiplication between two matrices
+		Matrix<T,R,C> operator+( const Matrix<T,R,C>& matrix ) const; 	// 	Multiplication between two matrices
+		Matrix<T,R,C>& operator *=( const Matrix<T,R,C>& matrix ); 		// 	Multiplication set between two matrices
+		bool operator==( const Matrix<T,R,C>& matrix ) const; 			// 	Equality check between two matrices (equals)
+		bool operator!=( const Matrix<T,R,C>& matrix ) const; 			// 	Equality check between two matrices (not equals)
+	};
+	template<typename T = pod::Math::num_t> using Matrix3t = Matrix<T,3>;
+	typedef Matrix3t<> Matrix3;
+	typedef Matrix3t<float> Matrix3f;
+
+	template<typename T = pod::Math::num_t> using Matrix4t = Matrix<T,4>;
+	typedef Matrix4t<> Matrix4;
+	typedef Matrix4t<float> Matrix4f;
+}
+
+namespace uf {
+	namespace matrix {
+	// 	Equality checking
+		template<typename T=pod::Math::num_t> pod::Matrix4t<T> /*UF_API*/ identity();
+		template<typename T=pod::Math::num_t> pod::Matrix4t<T> /*UF_API*/ ortho( T, T, T, T );
+		template<typename T=pod::Math::num_t> pod::Matrix4t<T> /*UF_API*/ ortho( T, T, T, T, T, T );
+		template<typename T=pod::Math::num_t> pod::Matrix4t<T> /*UF_API*/ initialize( const T* );
+		template<typename T=pod::Math::num_t> pod::Matrix4t<T> /*UF_API*/ initialize( const std::vector<T>& );
+		template<typename T> pod::Matrix<typename T::type_t, T::columns, T::columns> /*UF_API*/ identityi();
+		template<typename T=pod::Matrix4> std::size_t /*UF_API*/ compareTo( const T& left, const T& right ); 			// 	Equality check between two matrices (less than)
+		template<typename T=pod::Matrix4> bool /*UF_API*/ equals( const T& left, const T& right ); 						// 	Equality check between two matrices (equals)
+	// 	Basic arithmetic
+	//	template<typename T=pod::Matrix4> pod::Matrix<typename T::type_t, C, C> /*UF_API*/ multiply( const T& left, const T& right );						// 	Multiplies two matrices of same type and size together
+		template<typename T, typename U> pod::Matrix<typename T::type_t, T::columns, T::columns> multiply( const T& left, const U& right );						// 	Multiplies two matrices of same type and size together
+		template<typename T> pod::Matrix<T,4,4> multiply( const pod::Matrix<T,4,4>& left, const pod::Matrix<T,4,4>& right );						// 	Multiplies two matrices of same type and size together
+		template<typename T=pod::Matrix4> T /*UF_API*/ transpose( const T& matrix );										// 	Flip sign of all components
+		template<typename T=pod::Matrix4> T /*UF_API*/ inverse( const T& matrix );										// 	Flip sign of all components
+		template<typename T=pod::Math::num_t> pod::Vector3t<T> multiply( const pod::Matrix4t<T>& mat, const pod::Vector3t<T>& vector );
+		template<typename T=pod::Math::num_t> pod::Vector4t<T> multiply( const pod::Matrix4t<T>& mat, const pod::Vector4t<T>& vector );
+		
+		template<typename T=pod::Matrix4> T /*UF_API*/ multiplyAll( const T& matrix, typename T::type_t scalar );
+		template<typename T=pod::Matrix4> T /*UF_API*/ add( const T& lhs, const T& rhs );
+	// 	Writes to first value
+	//	template<typename T=pod::Matrix4> pod::Matrix<typename T::type_t, C, C>& /*UF_API*/ multiply( T& left, const T& right );								// 	Multiplies two matrices of same type and size together
+		template<typename T, typename U> pod::Matrix<typename T::type_t, T::columns, T::columns> multiply( T& left, const U& right );								// 	Multiplies two matrices of same type and size together
+		template<typename T> pod::Matrix<typename T::type_t, T::columns, T::columns> multiply( T& left, const T& right );
+		template<typename T=pod::Matrix4> T& /*UF_API*/ invert( T& matrix );												// 	Flip sign of all components
+	// 	Complex arithmetic
+		template<typename T=pod::Matrix4> T /*UF_API*/ translate( const T& matrix, const pod::Vector3t<typename T::type_t>& vector );
+		template<typename T=pod::Matrix4> T /*UF_API*/ rotate( const T& matrix, const pod::Vector3t<typename T::type_t>& vector );
+		template<typename T=pod::Matrix4> T /*UF_API*/ scale( const T& matrix, const pod::Vector3t<typename T::type_t>& vector );
+		template<typename T=pod::Matrix4> T& /*UF_API*/ translate( T& matrix, const pod::Vector3t<typename T::type_t>& vector );
+		template<typename T=pod::Matrix4> T& /*UF_API*/ rotate( T& matrix, const pod::Vector3t<typename T::type_t>& vector );
+		template<typename T=pod::Matrix4> T& /*UF_API*/ scale( T& matrix, const pod::Vector3t<typename T::type_t>& vector );
+		template<typename T=pod::Matrix4> pod::Vector3t<typename T::type_t> /*UF_API*/ eulerAngles( const T& matrix );
+	// 	Setting
+		template<typename T=pod::Matrix4> T& /*UF_API*/ copy( T& destination, const T& source );
+		template<typename T=pod::Matrix4> T& /*UF_API*/ copy( T& destination, typename T::type_t* const source );
+
+		template<typename T, size_t R, size_t C = R> std::string /*UF_API*/ toString( const pod::Matrix<T,R,C>& v );
+		template<typename T, size_t R, size_t C> ext::json::Value /*UF_API*/ encode( const pod::Matrix<T,R,C>& v, bool compress = false );
+		template<typename T, size_t R, size_t C> pod::Matrix<T,R,C>& /*UF_API*/ decode( const ext::json::Value& v, pod::Matrix<T,R,C>& );
+		template<typename T, size_t R, size_t C> pod::Matrix<T,R,C> /*UF_API*/ decode( const ext::json::Value& v, const pod::Matrix<T,R,C>& = uf::matrix::identity() );
+	}
+}
+
+namespace uf {
+	template<typename T = pod::Math::num_t, std::size_t R = 4, std::size_t C = R>
+	class /*UF_API*/ Matrix {
+	public:
+	// 	Easily access POD's type
+		typedef pod::Matrix<T,R,C> pod_t;
+	// 	Replicate POD information
+		typedef T type_t;
+		typedef T* container_t;
+		static const std::size_t rows = R;
+		static const std::size_t columns = C;
+	protected:
+	// 	POD storage
+		Matrix<T,R,C>::pod_t m_pod;
+	public:
+	// 	C-tor
+		Matrix(); 																		// initializes POD to 'def'
+		Matrix(const Matrix<T,R,C>::pod_t& pod); 										// copies POD altogether
+		Matrix(const T components[R][C]); 												// copies data into POD from 'components' (typed as C array)
+		Matrix(const T components[R*C]); 												// copies data into POD from 'components' (typed as C array)
+		Matrix(const std::vector<T>& components); 										// copies data into POD from 'components' (typed as std::matrix<T>)
+	// 	D-tor
+		// Unneccesary
+	// 	POD access
+		Matrix<T,R,C>::pod_t& data(); 													// 	Returns a reference of POD
+		const Matrix<T,R,C>::pod_t& data() const; 										// 	Returns a const-reference of POD
+		
+		template<typename Q> typename Matrix<Q,R,C>::pod_t convert() const; 						// 	Returns a POD converted
+	// 	Alternative POD access
+		T* get();																		// 	Returns a pointer to the entire array
+		const T* get() const; 															// 	Returns a const-pointer to the entire array
+		T& getComponent( std::size_t i );												// 	Returns a reference to a single element
+		const T& getComponent( std::size_t i ) const; 									// 	Returns a const-reference to a single element
+	// 	POD manipulation
+		T* set(const T components[R][C]);												// 	Sets the entire array
+		T* set(const T components[R*C]);												// 	Sets the entire array
+		T& setComponent( std::size_t i, const T& value );								// 	Sets a single element
+	// 	Validation
+		bool isValid() const; 															// 	Checks if all components are valid (non NaN, inf, etc.)
+	// 	Basic arithmetic
+		inline uf::Matrix<T,C,C>  multiply( const Matrix<T,R,C>& matrix ) const;		// 	Multiplies two matrices of same type and size together
+		inline uf::Matrix<T,C,C>  multiply( const Matrix<T,R,C>& matrix );				// 	Multiplies two matrices of same type and size together
+		inline pod::Vector3t<T> multiply( const pod::Vector3t<T>& vector ) const;
+		inline pod::Vector4t<T> multiply( const pod::Vector4t<T>& vector ) const;
+		inline uf::Matrix<T,R,C>& negate();												// 	Flip sign of all components
+		inline uf::Matrix<T,R,C>& translate( const pod::Vector3t<T>& vector );
+		inline uf::Matrix<T,R,C>& rotate( const pod::Vector3t<T>& vector );
+		inline uf::Matrix<T,R,C>& scale( const pod::Vector3t<T>& vector );
+		inline uf::Matrix<T,R,C>& invert();
+		inline uf::Matrix<T,R,C>  inverse() const;
+		template<typename U>
+		inline uf::Matrix<T,C,C> multiply( const U& matrix ) const;					// 	Multiplies two matrices of same type and size together
+		template<typename U>
+		inline uf::Matrix<T,C,C> multiply( const U& matrix );							// 	Multiplies two matrices of same type and size together
+	// 	Overloaded ops
+		// Accessing via subscripts
+		T& operator[](std::size_t i);
+		const T& operator[](std::size_t i) const;
+		// Arithmetic
+		inline Matrix<T,R,C> operator-() const; 										// 	Negation
+		inline Matrix<T,C,C> operator*( const Matrix<T,R,C>& matrix ) const; 			// 	Multiplication between two matrices
+		inline Matrix<T,C,C>& operator *=( const Matrix<T,R,C>& matrix ); 				// 	Multiplication set between two matrices
+		template<typename U> inline Matrix<T,C,C> operator*( const U& matrix ) const; 	// 	Multiplication between two matrices
+		inline bool operator==( const Matrix<T,R,C>& matrix ) const; 					// 	Equality check between two matrices (equals)
+		inline bool operator!=( const Matrix<T,R,C>& matrix ) const; 					// 	Equality check between two matrices (not equals)
+		
+		inline operator pod_t&() { return this->m_pod; }
+		inline operator const pod_t&() const { return this->m_pod; } 
+	};
+	template<typename T = pod::Math::num_t> using Matrix4t = Matrix<T,4>;
+	typedef Matrix4t<> Matrix4;
+	typedef Matrix4t<float> Matrix4f;
+}
+
+#include <sstream>
+namespace uf {
+	namespace string {
+		template<typename T, size_t R, size_t C>
+		std::string /*UF_API*/ toString( const pod::Matrix<T,R,C>& v );
+	}
+}
+namespace ext {
+	namespace json {
+		template<typename T, size_t R, size_t C = R> ext::json::Value /*UF_API*/ encode( const pod::Matrix<T,R,C>& v );
+		template<typename T, size_t R, size_t C = R> pod::Matrix<T,R,C>& /*UF_API*/ decode( const ext::json::Value& v, pod::Matrix<T,R,C>& );
+		template<typename T, size_t R, size_t C = R> pod::Matrix<T,R,C> /*UF_API*/ decode( const ext::json::Value& v, const pod::Matrix<T,R,C>& = uf::matrix::identity() );
+	}
+}
+
+#include "matrix/matrix.inl"
\ No newline at end of file
diff --git a/engine/inc/uf/utils/math/matrix/class.inl b/engine/inc/uf/utils/math/matrix/class.inl
new file mode 100644
index 00000000..b0be270d
--- /dev/null
+++ b/engine/inc/uf/utils/math/matrix/class.inl
@@ -0,0 +1,212 @@
+// C-tor
+// initializes POD to 'def'
+template<typename T, std::size_t R, std::size_t C>
+uf::Matrix<T,R,C>::Matrix() {
+	for ( std::size_t r = 0; r < R; ++r ) 
+		for ( std::size_t c = 0; c < C; ++c ) 
+			this->m_pod.components[r+c*C] = (r == c ? 1 : 0);
+}
+// copies POD altogether
+template<typename T, std::size_t R, std::size_t C>
+uf::Matrix<T,R,C>::Matrix(const Matrix<T,R,C>::pod_t& pod ) :
+	m_pod(pod)
+{
+}
+// copies data into POD from 'components' (typed as C array)
+template<typename T, std::size_t R, std::size_t C>
+uf::Matrix<T,R,C>::Matrix(const T components[R][C] ) {
+	this->set(components);
+}
+template<typename T, std::size_t R, std::size_t C>
+uf::Matrix<T,R,C>::Matrix(const T components[R*C] ) {
+	this->set(components);
+}
+// copies data into POD from 'components' (typed as std::matrix<T>)
+template<typename T, std::size_t R, std::size_t C>
+uf::Matrix<T,R,C>::Matrix(const std::vector<T>& components ) {
+	auto it = components.begin();
+	if ( components.size() == R*C )
+		for ( std::size_t r = 0; r < R; ++r )
+			for ( std::size_t c = 0; c < C; ++c )
+				this->m_pod.components[r+c*C] = *it++;
+}
+// 	D-tor
+// Unneccesary
+// 	POD access
+// 	Returns a reference of POD
+template<typename T, std::size_t R, std::size_t C>
+typename uf::Matrix<T,R,C>::pod_t& uf::Matrix<T,R,C>::data() {
+	return this->m_pod;
+}
+// 	Returns a const-reference of POD
+template<typename T, std::size_t R, std::size_t C>
+const typename uf::Matrix<T,R,C>::pod_t& uf::Matrix<T,R,C>::data() const {
+	return this->m_pod;
+}
+// 	Returns a const-reference of POD
+template<typename T, std::size_t R, std::size_t C>
+template<typename Q>
+typename uf::Matrix<Q,R,C>::pod_t uf::Matrix<T,R,C>::convert() const {
+	typename uf::Matrix<Q,R,C>::pod_t converted;
+	for ( std::size_t i = 0; i < R*C; ++i )
+		converted.components[i] = (float) this->m_pod.components[i];
+	return converted;
+}
+// 	Alternative POD access
+// 	Returns a pointer to the entire array
+template<typename T, std::size_t R, std::size_t C>
+T* uf::Matrix<T,R,C>::get() {
+	return (T*) this->m_pod.components;
+}
+// 	Returns a const-pointer to the entire array
+template<typename T, std::size_t R, std::size_t C>
+const T* uf::Matrix<T,R,C>::get() const {
+	return (T*) this->m_pod.components;
+}
+// 	Returns a reference to a single element
+template<typename T, std::size_t R, std::size_t C>
+T& uf::Matrix<T,R,C>::getComponent( std::size_t i ) {
+	return this->m_pod.components[i];
+}
+// 	Returns a const-reference to a single element
+template<typename T, std::size_t R, std::size_t C>
+const T& uf::Matrix<T,R,C>::getComponent( std::size_t i ) const {
+	return this->m_pod.components[i];
+}
+// 	POD manipulation
+// 	Sets the entire array
+template<typename T, std::size_t R, std::size_t C>
+T* uf::Matrix<T,R,C>::set(const T components[R][C] ) {
+	for ( std::size_t r = 0; r < R; ++r )
+		for ( std::size_t c = 0; c < C; ++c )
+			this->m_pod.components[r+c*C] = components[r][c];
+	return (T*) this->m_pod.components;
+}
+template<typename T, std::size_t R, std::size_t C>
+T* uf::Matrix<T,R,C>::set(const T components[R*C] ) {
+//	memcpy( this->m_pod.components, components, R*C );
+	for ( std::size_t i = 0; i < R*C; ++i )
+		this->m_pod.components[i] = components[i];
+/*
+	for ( std::size_t r = 0; r < R; ++r )
+		for ( std::size_t c = 0; c < C; ++c )
+			this->m_pod.components[r+c*C] = components[r+c*C];
+*/
+
+	return (T*) this->m_pod.components;
+}
+// 	Sets a single element
+template<typename T, std::size_t R, std::size_t C>
+T& uf::Matrix<T,R,C>::setComponent( std::size_t i, const T& value ) {
+	this->m_pod.components[i] = value;
+}
+// 	Validation
+// 	Checks if all components are valid (non NaN, inf, etc.)
+template<typename T, std::size_t R, std::size_t C>
+bool uf::Matrix<T,R,C>::isValid() const {
+	T val;
+	for ( std::size_t i = 0; i < R * C; ++i )
+		if ( (val = this->m_pod.components[i]) != val ) return false;
+	return true;
+}
+// 	Basic arithmetic
+// 	Multiplies two matrices of same type and size together
+template<typename T, std::size_t R, std::size_t C>
+inline uf::Matrix<T,C,C> uf::Matrix<T,R,C>::multiply( const Matrix<T,R,C>& matrix ) {
+	return uf::matrix::multiply(this->m_pod, matrix.data());
+}
+template<typename T, std::size_t R, std::size_t C>
+inline uf::Matrix<T,C,C> uf::Matrix<T,R,C>::multiply( const Matrix<T,R,C>& matrix ) const {
+	return uf::matrix::multiply(this->m_pod, matrix.data());
+}
+// 	Flip sign of all components
+template<typename T, std::size_t R, std::size_t C>
+inline uf::Matrix<T,R,C>& uf::Matrix<T,R,C>::translate( const pod::Vector3t<T>& vector ) {
+	uf::matrix::translate(this->m_pod, vector);
+	return *this;
+}
+template<typename T, std::size_t R, std::size_t C>
+inline uf::Matrix<T,R,C>& uf::Matrix<T,R,C>::rotate( const pod::Vector3t<T>& vector ) {
+	uf::matrix::rotate(this->m_pod, vector);
+	return *this;
+}
+template<typename T, std::size_t R, std::size_t C>
+inline uf::Matrix<T,R,C>& uf::Matrix<T,R,C>::scale( const pod::Vector3t<T>& vector ) {
+	uf::matrix::scale(this->m_pod, vector);
+	return *this;
+}
+template<typename T, std::size_t R, std::size_t C>
+inline uf::Matrix<T,R,C>& uf::Matrix<T,R,C>::invert() {
+	return uf::matrix::invert(this->m_pod);
+}
+template<typename T, std::size_t R, std::size_t C>
+inline uf::Matrix<T,R,C>  uf::Matrix<T,R,C>::inverse() const {
+	return uf::matrix::inverse(this->m_pod);
+}
+
+template<typename T, std::size_t R, std::size_t C>
+template<typename U> inline uf::Matrix<T,C,C> uf::Matrix<T,R,C>::multiply( const U& matrix ) const {
+	return uf::matrix::multiply(this->m_pod, matrix.data());
+}
+template<typename T, std::size_t R, std::size_t C>
+template<typename U> inline uf::Matrix<T,C,C> uf::Matrix<T,R,C>::multiply( const U& matrix ) {
+	return uf::matrix::multiply(this->m_pod, matrix.data());
+}
+template<typename T, std::size_t R, std::size_t C>
+inline pod::Vector3t<T> uf::Matrix<T,R,C>::multiply( const pod::Vector3t<T>& vector ) const {
+	return uf::matrix::multiply(this->m_pod, vector);
+}
+template<typename T, std::size_t R, std::size_t C>
+inline pod::Vector4t<T> uf::Matrix<T,R,C>::multiply( const pod::Vector4t<T>& vector ) const {
+	return uf::matrix::multiply(this->m_pod, vector);
+}
+// 	Overloaded ops
+// Accessing via subscripts
+/*
+template<typename T, std::size_t R, std::size_t C>
+T* uf::Matrix<T,R,C>::operator[](std::size_t i) {
+	return this->m_pod[i];
+}
+template<typename T, std::size_t R, std::size_t C>
+const T* uf::Matrix<T,R,C>::operator[](std::size_t i) const {
+	return this->m_pod[i];
+}
+*/
+template<typename T, std::size_t R, std::size_t C>
+T& uf::Matrix<T,R,C>::operator[](std::size_t i) {
+	return this->m_pod[i];
+}
+template<typename T, std::size_t R, std::size_t C>
+const T& uf::Matrix<T,R,C>::operator[](std::size_t i) const {
+	return this->m_pod[i];
+}
+// Arithmetic
+// 	Negation
+template<typename T, std::size_t R, std::size_t C>
+inline uf::Matrix<T,R,C> uf::Matrix<T,R,C>::operator-() const {
+	return this->inverse();
+}
+// 	Multiplication between two matrices
+template<typename T, std::size_t R, std::size_t C>
+inline uf::Matrix<T,C,C> uf::Matrix<T,R,C>::operator*( const Matrix<T,R,C>& matrix ) const {
+	return this->multiply(matrix);
+}
+// 	Multiplication set between two matrices
+template<typename T, std::size_t R, std::size_t C>
+inline uf::Matrix<T,C,C>& uf::Matrix<T,R,C>::operator *=( const Matrix<T,R,C>& matrix ) {
+	return this->multiply(matrix);
+}
+template<typename T, std::size_t R, std::size_t C>
+template<typename U> inline uf::Matrix<T,C,C> uf::Matrix<T,R,C>::operator*( const U& matrix ) const {
+	return this->multiply(matrix);
+}
+// 	Equality check between two matrices (equals)
+template<typename T, std::size_t R, std::size_t C>
+inline bool uf::Matrix<T,R,C>::operator==( const Matrix<T,R,C>& matrix ) const {
+	return uf::matrix::equals( this->m_pod, matrix.m_pod );
+}
+// 	Equality check between two matrices (not equals)
+template<typename T, std::size_t R, std::size_t C>
+inline bool uf::Matrix<T,R,C>::operator!=( const Matrix<T,R,C>& matrix ) const {
+	return !uf::matrix::equals( this->m_pod, matrix.m_pod );
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/math/matrix/matrix.inl b/engine/inc/uf/utils/math/matrix/matrix.inl
new file mode 100644
index 00000000..af16e0ad
--- /dev/null
+++ b/engine/inc/uf/utils/math/matrix/matrix.inl
@@ -0,0 +1,21 @@
+#include "pod.inl"
+#include "class.inl"
+
+template<typename T, size_t R, size_t C>
+std::string /*UF_API*/ uf::string::toString( const pod::Matrix<T,R,C>& m ) {
+	return uf::matrix::toString(m);
+}
+
+template<typename T, size_t R, size_t C>
+ext::json::Value /*UF_API*/ ext::json::encode( const pod::Matrix<T,R,C>& v ) {
+	return uf::matrix::encode(v);
+}
+
+template<typename T, size_t R, size_t C>
+pod::Matrix<T,R,C>& /*UF_API*/ ext::json::decode( const ext::json::Value& json, pod::Matrix<T,R,C>& m ) {
+	return uf::matrix::decode<T,R,C>(json, m);
+}
+template<typename T, size_t R, size_t C>
+pod::Matrix<T,R,C> /*UF_API*/ ext::json::decode( const ext::json::Value& json, const pod::Matrix<T,R,C>& m ) {
+	return uf::matrix::decode<T,R,C>(json, m);
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/math/matrix/pod.inl b/engine/inc/uf/utils/math/matrix/pod.inl
new file mode 100644
index 00000000..7728fc1f
--- /dev/null
+++ b/engine/inc/uf/utils/math/matrix/pod.inl
@@ -0,0 +1,551 @@
+// 	Overloaded ops
+// Accessing via subscripts
+template<typename T, std::size_t R, std::size_t C>
+inline T& pod::Matrix<T,R,C>::operator[](std::size_t i) {
+//	static T null = 0.0/0.0;
+//	if ( i >= R*C ) return null;
+	return this->components[i];
+}
+template<typename T, std::size_t R, std::size_t C>
+inline const T& pod::Matrix<T,R,C>::operator[](std::size_t i) const {
+//	static T null = 0.0/0.0;
+//	if ( i >= R*C ) return null;
+	return this->components[i];
+}
+template<typename T, std::size_t R, std::size_t C>
+pod::Matrix<T,R,C> pod::Matrix<T,R,C>::operator()() const {
+	pod::Matrix<T,R,C> matrix;
+	for ( std::size_t r = 0; r < R; ++r ) 
+		for ( std::size_t c = 0; c < C; ++c ) 
+			matrix[r+c*C] = (r == c ? 1 : 0);
+	return matrix;
+}
+template<typename T, std::size_t R, std::size_t C>
+inline T& pod::Matrix<T,R,C>::operator()(size_t r, size_t c) {
+	return this->components[r+c*C];
+}
+template<typename T, std::size_t R, std::size_t C>
+inline const T& pod::Matrix<T,R,C>::operator()(size_t r, size_t c) const {
+	return this->components[r+c*C];
+}
+/*
+template<typename T, std::size_t R, std::size_t C>
+T* pod::Matrix<T,R,C>::operator[](std::size_t i) {
+	return this->components[i];
+}
+template<typename T, std::size_t R, std::size_t C>
+const T* pod::Matrix<T,R,C>::operator[](std::size_t i) const {
+	return this->components[i];
+}
+*/
+template<typename T>
+pod::Matrix4t<T> /*UF_API*/ uf::matrix::identity() {
+	pod::Matrix4t<T> matrix;
+	for ( std::size_t r = 0; r < 4; ++r ) 
+		for ( std::size_t c = 0; c < 4; ++c ) 
+			matrix[r+c*4] = (r == c ? 1 : 0);
+	return matrix;
+}
+template<typename T>
+pod::Matrix4t<T> /*UF_API*/ uf::matrix::ortho( T l, T r, T b, T t, T f, T n ) {
+	std::vector<T> m = {
+		2 / (r - l), 0, 0, 0,
+		0, 2 / (t - b), 0, 0,
+		0, 0, -2 / (f - n), 0,
+		-(r + l) / (r - l), -(t + b) / (t - b), -(f + n) / (f - n), 1,
+	};
+	return uf::matrix::initialize(m);
+}
+template<typename T>
+pod::Matrix4t<T> /*UF_API*/ uf::matrix::ortho( T l, T r, T b, T t ) {
+	std::vector<T> m = {
+		2 / (r - l), 0, 0, 0,
+		0, 2 / (t - b), 0, 0,
+		0, 0, 1, 0,
+		-(r + l) / (r - l), -(t+b)/(t-b), 0, 1
+	};
+	return uf::matrix::initialize(m);
+}
+template<typename T>
+pod::Matrix4t<T> /*UF_API*/ uf::matrix::initialize( const T* list ) {
+	pod::Matrix4t<T> matrix;
+//	memcpy(&matrix[0], list, 16);
+	for ( std::size_t i = 0; i < 16; ++i )
+		matrix.components[i] = list[i];
+/*
+	for ( std::size_t r = 0; r < 4; ++r ) 
+		for ( std::size_t c = 0; c < 4; ++c ) 
+			matrix[r+c*4] = list[r+c*4];
+*/
+	return matrix;
+}
+template<typename T>
+pod::Matrix4t<T> /*UF_API*/ uf::matrix::initialize( const std::vector<T>& list ) {
+	pod::Matrix4t<T> matrix;
+	if ( list.size() != 16 ) return matrix;
+//	memcpy(&matrix[0], &list[0], 16);
+	for ( std::size_t i = 0; i < 16; ++i )
+		matrix.components[i] = list[i];
+/*
+	for ( std::size_t r = 0; r < 4; ++r ) 
+		for ( std::size_t c = 0; c < 4; ++c ) 
+			matrix[r+c*4] = list[r+c*4];
+*/
+	return matrix;
+}
+template<typename T> pod::Matrix<typename T::type_t, T::columns, T::columns> uf::matrix::identityi(){
+	pod::Matrix<typename T::type_t, T::columns, T::columns> matrix;
+	for ( std::size_t r = 0; r < T::columns; ++r ) 
+		for ( std::size_t c = 0; c < T::columns; ++c ) 
+			matrix[r+c*T::columns] = (r == c ? 1 : 0);
+	return matrix;
+}
+// Arithmetic
+// 	Negation
+template<typename T, std::size_t R, std::size_t C>
+inline pod::Matrix<T,R,C> pod::Matrix<T,R,C>::operator-() const {
+	return uf::matrix::inverse(*this);
+}
+// 	Multiplication between two matrices
+template<typename T, std::size_t R, std::size_t C>
+inline pod::Matrix<T,R,C> pod::Matrix<T,R,C>::operator*( const Matrix<T,R,C>& matrix ) const {
+	return uf::matrix::multiply(*this, matrix);
+}
+// 	Multiplication between two matrices
+template<typename T, std::size_t R, std::size_t C>
+inline pod::Matrix<T,R,C> pod::Matrix<T,R,C>::operator*( T scalar ) const {
+	return uf::matrix::multiplyAll(*this, scalar);
+}
+// 	Multiplication between two matrices
+template<typename T, std::size_t R, std::size_t C>
+inline pod::Matrix<T,R,C> pod::Matrix<T,R,C>::operator+( const Matrix<T,R,C>& matrix ) const {
+	return uf::matrix::add(*this, matrix);
+}
+// 	Multiplication set between two matrices
+template<typename T, std::size_t R, std::size_t C>
+inline pod::Matrix<T,R,C>& pod::Matrix<T,R,C>::operator *=( const Matrix<T,R,C>& matrix ) {
+	return uf::matrix::multiply(*this, matrix);
+}
+// 	Equality check between two matrices (equals)
+template<typename T, std::size_t R, std::size_t C>
+inline bool pod::Matrix<T,R,C>::operator==( const Matrix<T,R,C>& matrix ) const {
+	return uf::matrix::equals( *this, matrix );
+}
+// 	Equality check between two matrices (not equals)
+template<typename T, std::size_t R, std::size_t C>
+inline bool pod::Matrix<T,R,C>::operator!=( const Matrix<T,R,C>& matrix ) const {
+	return !uf::matrix::equals( *this, matrix );
+}
+
+// 	Equality checking
+// 	Equality check between two matrices (less than)
+template<typename T> std::size_t uf::matrix::compareTo( const T& left, const T& right ) {
+	return 1;
+}
+// 	Equality check between two matrices (equals)
+template<typename T> bool uf::matrix::equals( const T& left, const T& right ) {
+	return uf::matrix::compareTo(left, right) == 0;
+}
+// 	Basic arithmetic
+// 	Multiplies two matrices of same type and size together
+template<typename T> pod::Matrix<T,4,4> uf::matrix::multiply( const pod::Matrix<T,4,4>& left, const pod::Matrix<T,4,4>& right ) {
+	pod::Matrix<T,4,4> res;
+#if UF_USE_SIMD
+	auto row1 = uf::simd::load(&left[0]);
+	auto row2 = uf::simd::load(&left[4]);
+	auto row3 = uf::simd::load(&left[8]);
+	auto row4 = uf::simd::load(&left[12]);
+	for(int i=0; i<4; i++) {
+		auto brod1 = uf::simd::set(right[4*i + 0]);
+		auto brod2 = uf::simd::set(right[4*i + 1]);
+		auto brod3 = uf::simd::set(right[4*i + 2]);
+		auto brod4 = uf::simd::set(right[4*i + 3]);
+		auto row = uf::simd::add(
+					uf::simd::add(
+						uf::simd::mul(brod1, row1),
+						uf::simd::mul(brod2, row2)),
+					uf::simd::add(
+						uf::simd::mul(brod3, row3),
+						uf::simd::mul(brod4, row4)));
+		uf::simd::store(row, &res[4*i]);
+	}
+	return res;
+#elif 1
+	// 
+	float* dstPtr = &res[0];
+	const float* leftPtr = &right[0];
+
+	for (size_t i = 0; i < 4; ++i) {
+		for (size_t j = 0; j < 4; ++j) {
+			const float* rightPtr = &left[0] + j;
+
+			float sum = leftPtr[0] * rightPtr[0];
+			for (size_t n = 1; n < 4; ++n) {
+				rightPtr += 4;
+				sum += leftPtr[n] * rightPtr[0];
+			}
+			*dstPtr++ = sum;
+		}
+		leftPtr += 4;
+	}
+	return res;
+#elif 1
+	// don't know if it's more performant than below
+	std::size_t i = 0;
+	for ( size_t col = 0; col < 4; col++ ) {
+		for ( size_t row = 0; row < 4; row++ ) {
+			res[i++] = uf::vector::dot( { right[0+col*4], right[1+col*4], right[2+col*4], right[3+col*4] }, { left[row+0*4], left[row+1*4], left[row+2*4], left[row+3*4] } );
+		}
+	}
+	return res;
+#else
+	// it works
+	const pod::Vector<T,4>& srcA0 = *((pod::Vector<T,4>*) &left[0]);
+	const pod::Vector<T,4>& srcA1 = *((pod::Vector<T,4>*) &left[4]);
+	const pod::Vector<T,4>& srcA2 = *((pod::Vector<T,4>*) &left[8]);
+	const pod::Vector<T,4>& srcA3 = *((pod::Vector<T,4>*) &left[12]);
+
+	const pod::Vector<T,4>& srcB0 = *((pod::Vector<T,4>*) &right[0]);
+	const pod::Vector<T,4>& srcB1 = *((pod::Vector<T,4>*) &right[4]);
+	const pod::Vector<T,4>& srcB2 = *((pod::Vector<T,4>*) &right[8]);
+	const pod::Vector<T,4>& srcB3 = *((pod::Vector<T,4>*) &right[12]);
+	
+	pod::Vector<T,4>& dst0 = *((pod::Vector<T,4>*) &res[0]);
+	pod::Vector<T,4>& dst1 = *((pod::Vector<T,4>*) &res[4]);
+	pod::Vector<T,4>& dst2 = *((pod::Vector<T,4>*) &res[8]);
+	pod::Vector<T,4>& dst3 = *((pod::Vector<T,4>*) &res[12]);
+
+	dst0 = srcA0 * srcB0[0] + srcA1 * srcB0[1] + srcA2 * srcB0[2] + srcA3 * srcB0[3];
+	dst1 = srcA0 * srcB1[0] + srcA1 * srcB1[1] + srcA2 * srcB1[2] + srcA3 * srcB1[3];
+	dst2 = srcA0 * srcB2[0] + srcA1 * srcB2[1] + srcA2 * srcB2[2] + srcA3 * srcB2[3];
+	dst3 = srcA0 * srcB3[0] + srcA1 * srcB3[1] + srcA2 * srcB3[2] + srcA3 * srcB3[3];
+	return res;
+#endif
+}
+template<typename T, typename U> pod::Matrix<typename T::type_t, T::columns, T::columns> uf::matrix::multiply( const T& left, const U& right ) {
+	static const std::size_t R = T::rows;
+	static const std::size_t C = T::columns;
+
+	pod::Matrix<typename T::type_t,R,C> res;
+#if 1
+	float* dstPtr = &res[0];
+	const float* leftPtr = &right[0];
+
+	for (size_t i = 0; i < R; ++i) {
+		for (size_t j = 0; j < C; ++j) {
+			const float* rightPtr = &left[0] + j;
+
+			float sum = leftPtr[0] * rightPtr[0];
+			for (size_t n = 1; n < C; ++n) {
+				rightPtr += C;
+				sum += leftPtr[n] * rightPtr[0];
+			}
+			*dstPtr++ = sum;
+		}
+		leftPtr += C;
+	}
+#else
+	std::size_t i = 0;
+	for ( size_t col = 0; col < R; col++ ) {
+		for ( size_t row = 0; row < C; row++ ) {
+			auto& sum = res[i++];
+			for ( size_t i = 0; i < C; i++ )
+				sum += right[i + col * C] * left[row + i * R];
+		}
+	}
+#endif
+	return res;
+}
+template<typename T=pod::Matrix4> T /*UF_API*/ uf::matrix::multiplyAll( const T& m, typename T::type_t scalar ) {
+	static const std::size_t R = T::rows;
+	static const std::size_t C = T::columns;
+	T matrix;
+	for ( size_t i = 0; i < R*C; ++i ) matrix[i] = m[i] * scalar;
+	return matrix;
+}
+template<typename T=pod::Matrix4> T /*UF_API*/ uf::matrix::add( const T& lhs, const T& rhs ) {
+	static const std::size_t R = T::rows;
+	static const std::size_t C = T::columns;
+	T matrix;
+	for ( size_t i = 0; i < R*C; ++i ) matrix[i] = lhs[i] + rhs[i];
+	return matrix;
+}
+// 	Transpose matrix
+template<typename T> T uf::matrix::transpose( const T& matrix ) {
+	static const std::size_t R = T::rows;
+	static const std::size_t C = T::columns;
+	T transpose;
+
+	for ( typename T::type_t col = 0; col < C; ++col )
+	for ( typename T::type_t row = 0; row < R; ++row )
+		transpose[col * R + row] = matrix[row * C + col];
+
+	return transpose;
+}
+// 	Flip sign of all components
+template<typename T> T uf::matrix::inverse( const T& matrix ) {
+	if ( T::rows != 4 ) return matrix;
+	if ( T::columns != 4 ) return matrix;
+
+	const typename T::type_t* m = &matrix[0];
+	typename T::type_t inv[16], det;
+	std::size_t i;
+
+	inv[0] = m[5]  * m[10] * m[15] - 
+			 m[5]  * m[11] * m[14] - 
+			 m[9]  * m[6]  * m[15] + 
+			 m[9]  * m[7]  * m[14] +
+			 m[13] * m[6]  * m[11] - 
+			 m[13] * m[7]  * m[10];
+	inv[4] = -m[4]  * m[10] * m[15] + 
+			  m[4]  * m[11] * m[14] + 
+			  m[8]  * m[6]  * m[15] - 
+			  m[8]  * m[7]  * m[14] - 
+			  m[12] * m[6]  * m[11] + 
+			  m[12] * m[7]  * m[10];
+	inv[8] = m[4]  * m[9] * m[15] - 
+			 m[4]  * m[11] * m[13] - 
+			 m[8]  * m[5] * m[15] + 
+			 m[8]  * m[7] * m[13] + 
+			 m[12] * m[5] * m[11] - 
+			 m[12] * m[7] * m[9];
+	inv[12] = -m[4]  * m[9] * m[14] + 
+			   m[4]  * m[10] * m[13] +
+			   m[8]  * m[5] * m[14] - 
+			   m[8]  * m[6] * m[13] - 
+			   m[12] * m[5] * m[10] + 
+			   m[12] * m[6] * m[9];
+	inv[1] = -m[1]  * m[10] * m[15] + 
+			  m[1]  * m[11] * m[14] + 
+			  m[9]  * m[2] * m[15] - 
+			  m[9]  * m[3] * m[14] - 
+			  m[13] * m[2] * m[11] + 
+			  m[13] * m[3] * m[10];
+	inv[5] = m[0]  * m[10] * m[15] - 
+			 m[0]  * m[11] * m[14] - 
+			 m[8]  * m[2] * m[15] + 
+			 m[8]  * m[3] * m[14] + 
+			 m[12] * m[2] * m[11] - 
+			 m[12] * m[3] * m[10];
+	inv[9] = -m[0]  * m[9] * m[15] + 
+			  m[0]  * m[11] * m[13] + 
+			  m[8]  * m[1] * m[15] - 
+			  m[8]  * m[3] * m[13] - 
+			  m[12] * m[1] * m[11] + 
+			  m[12] * m[3] * m[9];
+	inv[13] = m[0]  * m[9] * m[14] - 
+			  m[0]  * m[10] * m[13] - 
+			  m[8]  * m[1] * m[14] + 
+			  m[8]  * m[2] * m[13] + 
+			  m[12] * m[1] * m[10] - 
+			  m[12] * m[2] * m[9];
+	inv[2] = m[1]  * m[6] * m[15] - 
+			 m[1]  * m[7] * m[14] - 
+			 m[5]  * m[2] * m[15] + 
+			 m[5]  * m[3] * m[14] + 
+			 m[13] * m[2] * m[7] - 
+			 m[13] * m[3] * m[6];
+	inv[6] = -m[0]  * m[6] * m[15] + 
+			  m[0]  * m[7] * m[14] + 
+			  m[4]  * m[2] * m[15] - 
+			  m[4]  * m[3] * m[14] - 
+			  m[12] * m[2] * m[7] + 
+			  m[12] * m[3] * m[6];
+	inv[10] = m[0]  * m[5] * m[15] - 
+			  m[0]  * m[7] * m[13] - 
+			  m[4]  * m[1] * m[15] + 
+			  m[4]  * m[3] * m[13] + 
+			  m[12] * m[1] * m[7] - 
+			  m[12] * m[3] * m[5];
+	inv[14] = -m[0]  * m[5] * m[14] + 
+			   m[0]  * m[6] * m[13] + 
+			   m[4]  * m[1] * m[14] - 
+			   m[4]  * m[2] * m[13] - 
+			   m[12] * m[1] * m[6] + 
+			   m[12] * m[2] * m[5];
+	inv[3] = -m[1] * m[6] * m[11] + 
+			  m[1] * m[7] * m[10] + 
+			  m[5] * m[2] * m[11] - 
+			  m[5] * m[3] * m[10] - 
+			  m[9] * m[2] * m[7] + 
+			  m[9] * m[3] * m[6];
+	inv[7] = m[0] * m[6] * m[11] - 
+			 m[0] * m[7] * m[10] - 
+			 m[4] * m[2] * m[11] + 
+			 m[4] * m[3] * m[10] + 
+			 m[8] * m[2] * m[7] - 
+			 m[8] * m[3] * m[6];
+	inv[11] = -m[0] * m[5] * m[11] + 
+			   m[0] * m[7] * m[9] + 
+			   m[4] * m[1] * m[11] - 
+			   m[4] * m[3] * m[9] - 
+			   m[8] * m[1] * m[7] + 
+			   m[8] * m[3] * m[5];
+	inv[15] = m[0] * m[5] * m[10] - 
+			  m[0] * m[6] * m[9] - 
+			  m[4] * m[1] * m[10] + 
+			  m[4] * m[2] * m[9] + 
+			  m[8] * m[1] * m[6] - 
+			  m[8] * m[2] * m[5];
+
+	det = m[0] * inv[0] + m[1] * inv[4] + m[2] * inv[8] + m[3] * inv[12];
+	if (det == 0) return matrix;
+	det = 1.0 / det;
+	T inverted;
+	for (i = 0; i < 16; i++) inverted[i] = inv[i] * det;
+	return inverted;
+}
+// 	Writes to first value
+// 	Multiplies two matrices of same type and size together
+template<typename T> pod::Matrix<typename T::type_t, T::columns, T::columns> uf::matrix::multiply( T& left, const T& right ) {
+	return left = uf::matrix::multiply((const T&) left, right);
+}
+template<typename T> pod::Vector3t<T> uf::matrix::multiply( const pod::Matrix4t<T>& mat, const pod::Vector3t<T>& vector ) {
+	return {
+		vector[0] * mat[0] + vector[1] * mat[4] + vector[2] * mat[8] + vector[3] * mat[12],
+		vector[0] * mat[1] + vector[1] * mat[5] + vector[2] * mat[9] + vector[3] * mat[13],
+		vector[0] * mat[2] + vector[1] * mat[6] + vector[2] * mat[10] + vector[3] * mat[14]
+	//	vector[0] * mat[3] + vector[1] * mat[7] + vector[2] * mat[11] + vector[3] * mat[15]
+	};
+}
+template<typename T> pod::Vector4t<T> uf::matrix::multiply( const pod::Matrix4t<T>& mat, const pod::Vector4t<T>& vector ) {
+	return {
+		vector[0] * mat[0] + vector[1] * mat[4] + vector[2] * mat[8] + vector[3] * mat[12],
+		vector[0] * mat[1] + vector[1] * mat[5] + vector[2] * mat[9] + vector[3] * mat[13],
+		vector[0] * mat[2] + vector[1] * mat[6] + vector[2] * mat[10] + vector[3] * mat[14],
+		vector[0] * mat[3] + vector[1] * mat[7] + vector[2] * mat[11] + vector[3] * mat[15]
+	};
+}
+// 	Flip sign of all components
+template<typename T> T& uf::matrix::invert( T& matrix ) {
+	return matrix = uf::matrix::inverse((const T&) matrix);
+}
+// 	Complex arithmetic
+template<typename T> T uf::matrix::translate( const T& matrix, const pod::Vector3t<typename T::type_t>& vector ) {
+	T res = matrix;
+	res[12] = vector.x;
+	res[13] = vector.y;
+	res[14] = vector.z;
+	return res;
+}
+template<typename T> T uf::matrix::rotate( const T& matrix, const pod::Vector3t<typename T::type_t>& vector ) {
+	T res = matrix;
+	if ( vector.x != 0 ) {	
+		res[5] = cos( vector.x );
+		res[6] = sin( vector.x );
+		res[9] = -1 * sin( vector.x );
+		res[10] = cos( vector.x );
+	}
+	
+	if ( vector.y != 0 ) {	
+		res[0] = cos( vector.y );
+		res[2] = -1 * sin( vector.y );
+		res[8] = sin( vector.y );
+		res[10] = cos( vector.y );
+	}
+
+	if ( vector.z != 0 ) {	
+		res[0] = cos( vector.z );
+		res[1] = sin( vector.z );
+		res[4] = -1 * sin( vector.z );
+		res[5] = cos( vector.z );
+	}
+	return res;
+}
+template<typename T> T uf::matrix::scale( const T& matrix, const pod::Vector3t<typename T::type_t>& vector ) {
+	T res = matrix;
+	res[0] = vector.x;
+	res[5] = vector.y;
+	res[10] = vector.z;
+	return res;
+}
+template<typename T> T& uf::matrix::translate( T& matrix, const pod::Vector3t<typename T::type_t>& vector ) {
+	matrix[12] = vector.x;
+	matrix[13] = vector.y;
+	matrix[14] = vector.z;
+	return matrix;
+}
+template<typename T> T& uf::matrix::rotate( T& matrix, const pod::Vector3t<typename T::type_t>& vector ) {
+	if ( vector.x != 0 ) {	
+		matrix[5] = cos( vector.x );
+		matrix[6] = sin( vector.x );
+		matrix[9] = -1 * sin( vector.x );
+		matrix[10] = cos( vector.x );
+	}
+	
+	if ( vector.y != 0 ) {	
+		matrix[0] = cos( vector.y );
+		matrix[2] = -1 * sin( vector.y );
+		matrix[8] = sin( vector.y );
+		matrix[10] = cos( vector.y );
+	}
+
+	if ( vector.z != 0 ) {	
+		matrix[0] = cos( vector.z );
+		matrix[1] = sin( vector.z );
+		matrix[4] = -1 * sin( vector.z );
+		matrix[5] = cos( vector.z );
+	}
+	return matrix;
+}
+template<typename T> T& uf::matrix::scale( T& matrix, const pod::Vector3t<typename T::type_t>& vector ) {
+	matrix[0] = vector.x;
+	matrix[5] = vector.y;
+	matrix[10] = vector.z;
+	return matrix;
+}
+template<typename T> T& uf::matrix::copy( T& destination, const T& source ) {
+	for ( std::size_t i = 0; i < 16; ++i )
+		destination[i] = source[i];
+	return destination;
+}
+template<typename T> T& uf::matrix::copy( T& destination, typename T::type_t* const source ) {
+	for ( std::size_t i = 0; i < 16; ++i )
+		destination[i] = source[i];
+	return destination;
+}
+
+template<typename T> pod::Vector3t<typename T::type_t> /*UF_API*/ uf::matrix::eulerAngles( const T& M ) {
+	typename T::type_t T1 = atan2(M[2*4+1], M[2*4+2]);
+	typename T::type_t C2 = sqrt(M[0*4+0]*M[0*4+0] + M[1*4+0]*M[1*4+0]);
+	typename T::type_t T2 = atan2(-M[2*4+0], C2);
+	typename T::type_t S1 = sin(T1);
+	typename T::type_t C1 = cos(T1);
+	typename T::type_t T3 = atan2(S1*M[0*4+2] - C1*M[0*4+1], C1*M[1*4+1] - S1*M[1*4+2  ]);
+	return pod::Vector3t<typename T::type_t>{-T1, -T2, -T3};
+}
+
+
+template<typename T, size_t R, size_t C>
+ext::json::Value /*UF_API*/ uf::matrix::encode( const pod::Matrix<T,R,C>& m, bool compress ) {
+	ext::json::Value json;
+	if ( compress ) for ( size_t i = 0; i < R*C; ++i ) json[i] = uf::math::quantizeShort( m[i] );
+	else for ( size_t i = 0; i < R*C; ++i ) json[i] = m[i];
+	return json;
+}
+template<typename T, size_t R, size_t C>
+pod::Matrix<T,R,C>& /*UF_API*/ uf::matrix::decode( const ext::json::Value& json, pod::Matrix<T,R,C>& m ) {
+	for ( size_t i = 0; i < R*C; ++i ) m[i] = json[i].as<T>();
+	return m;
+}
+
+template<typename T, size_t R, size_t C>
+pod::Matrix<T,R,C> /*UF_API*/ uf::matrix::decode( const ext::json::Value& json, const pod::Matrix<T,R,C>& _m ) {
+	pod::Matrix<T,R,C> m = _m;
+	for ( size_t i = 0; i < R*C; ++i ) m[i] = json[i].as<T>();
+	return m;
+}
+
+template<typename T, size_t R, size_t C>
+std::string /*UF_API*/ uf::matrix::toString( const pod::Matrix<T,R,C>& m ) {
+	std::stringstream ss;
+	ss << "Matrix(\n\t";
+	for ( size_t c = 0; c < C; ++c ) {
+		for ( size_t r = 0; r < R; ++r ) {
+			ss << m[r+c*C] << ", ";
+		}
+		if ( c + 1 < C ) ss << "\n\t";
+	}
+	ss << "\n)";
+	return ss.str();
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/math/physics.h b/engine/inc/uf/utils/math/physics.h
new file mode 100644
index 00000000..e1ea1814
--- /dev/null
+++ b/engine/inc/uf/utils/math/physics.h
@@ -0,0 +1,36 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/utils/math/transform.h>
+#include <uf/utils/time/time.h>
+
+namespace pod {
+	struct UF_API Physics {
+		struct {
+			pod::Vector3 velocity;
+			pod::Vector3 acceleration;
+		} linear;
+		struct {
+			pod::Quaternion<> velocity;
+			pod::Quaternion<> acceleration;
+		} rotational;
+		pod::Transform<> previous;
+	};
+}
+
+namespace uf {
+	namespace physics {
+		namespace time {
+			extern UF_API uf::Timer<> timer;
+			extern UF_API double current;
+			extern UF_API double previous;
+			extern UF_API double delta;
+			extern UF_API double clamp;
+		}
+		void UF_API tick();
+		template<typename T> pod::Transform<T>& update( pod::Transform<T>& transform, pod::Physics& physics );
+		template<typename T> pod::Transform<T>& update( pod::Physics& physics, pod::Transform<T>& transform );
+	}
+}
+
+#include "physics/pod.inl"
\ No newline at end of file
diff --git a/engine/inc/uf/utils/math/physics/pod.inl b/engine/inc/uf/utils/math/physics/pod.inl
new file mode 100644
index 00000000..022a408f
--- /dev/null
+++ b/engine/inc/uf/utils/math/physics/pod.inl
@@ -0,0 +1,19 @@
+#include <iostream>
+template<typename T> pod::Transform<T>& uf::physics::update( pod::Transform<T>& transform, pod::Physics& physics ) {
+	physics.previous = transform;
+
+	if ( physics.linear.acceleration != pod::Vector3t<T>{0,0,0} ) 
+		physics.linear.velocity += (physics.linear.acceleration*uf::physics::time::delta);
+	if ( physics.rotational.acceleration != pod::Quaternion<T>{0,0,0,0} ) {
+		physics.rotational.velocity = uf::quaternion::multiply(physics.rotational.velocity, physics.rotational.acceleration*uf::physics::time::delta);
+	}
+
+	transform = uf::transform::move( transform, physics.linear.velocity*uf::physics::time::delta );
+	transform = uf::transform::rotate( transform, uf::vector::normalize(physics.rotational.velocity*uf::physics::time::delta));
+
+	return transform;
+}
+
+template<typename T> pod::Transform<T>& uf::physics::update( pod::Physics& physics, pod::Transform<T>& transform ) {
+	return uf::physics::update(transform, physics);
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/math/quaternion.h b/engine/inc/uf/utils/math/quaternion.h
new file mode 100644
index 00000000..37a44853
--- /dev/null
+++ b/engine/inc/uf/utils/math/quaternion.h
@@ -0,0 +1,172 @@
+#pragma once
+
+#include <uf/config.h>
+
+#include <sstream>
+#include <vector>
+#include <cmath>
+#include <stdint.h>
+
+#include <uf/utils/math/angle.h>
+#include <uf/utils/math/vector.h>
+#include <uf/utils/math/matrix.h>
+#ifdef UF_USE_GLM
+	#include "glm.h"
+#endif
+
+#include "math.h"
+namespace pod {
+	// Simple quaterions (designed [to store in arrays] with minimal headaches)
+	template<typename T = pod::Math::num_t> using Quaternion = Vector4t<T>;
+}
+
+namespace uf {
+	namespace quaternion {
+	// 	Equality checking
+		template<typename T> std::size_t /*UF_API*/ compareTo( const T& left, const T& right ); 			// 	Equality check between two vectors (less than)
+		template<typename T> bool /*UF_API*/ equals( const T& left, const T& right ); 						// 	Equality check between two vectors (equals)
+	// 	Basic arithmetic
+		template<typename T> T /*UF_API*/ multiply( const T& left, const T& right );						// 	Multiplies two vectors of same type and size together
+		template<typename T = pod::Math::num_t> pod::Quaternion<T> /*UF_API*/ identity();						// 	Multiplies two vectors of same type and size together
+		template<typename T> pod::Vector3t<T> /*UF_API*/ rotate( const pod::Quaternion<T>& left, const pod::Vector3t<T>& right );						// 	Multiplies two vectors of same type and size together
+		template<typename T> pod::Vector4t<T> /*UF_API*/ rotate( const pod::Quaternion<T>& left, const pod::Vector4t<T>& right );						// 	Multiplies two vectors of same type and size together
+		template<typename T> typename T::type_t /*UF_API*/ sum( const T& vector );							// 	Compute the sum of all components 
+		template<typename T> typename T::type_t /*UF_API*/ product( const T& vector );						// 	Compute the product of all components 
+		template<typename T> T /*UF_API*/ negate( const T& vector );										// 	Flip sign of all components
+	// 	Writes to first value
+		template<typename T> T& /*UF_API*/ multiply( T& left, const T& right );								// 	Multiplies two vectors of same type and size together
+		template<typename T> T& /*UF_API*/ negate( T& vector );												// 	Flip sign of all components
+		template<typename T> T& /*UF_API*/ normalize( T& vector ); 											// 	Normalizes a vector
+	// 	Complex arithmetic
+		template<typename T> typename T::type_t /*UF_API*/ dot( const T& left, const T& right ); 			// 	Compute the dot product between two vectors
+		template<typename T> pod::Angle /*UF_API*/ angle( const T& a, const T& b ); 						// 	Compute the angle between two vectors
+		
+		template<typename T> T /*UF_API*/ lerp( const T& from, const T& to, double delta ); 				// 	Linearly interpolate between two vectors
+		template<typename T> T /*UF_API*/ slerp( const T& from, const T& to, double delta ); 				// 	Spherically interpolate between two vectors
+		
+		template<typename T> typename T::type_t /*UF_API*/ distanceSquared( const T& a, const T& b ); 				// 	Gets the magnitude of the vector
+		template<typename T> typename T::type_t /*UF_API*/ distance( const T& a, const T& b ); 					// 	Gets the magnitude of the vector
+		template<typename T> typename T::type_t /*UF_API*/ magnitude( const T& vector ); 					// 	Gets the magnitude of the vector
+		template<typename T> typename T::type_t /*UF_API*/ norm( const T& vector ); 						// 	Compute the norm of the vector
+		template<typename T> T /*UF_API*/ normalize( const T& vector ); 									// 	Normalizes a vector
+	// 	Quaternion ops
+		template<typename T> pod::Matrix4t<typename T::type_t> matrix( const T& quaternion );
+		template<typename T> pod::Quaternion<T> axisAngle( const pod::Vector3t<T>& axis, T angle );
+		template<typename T> pod::Quaternion<T> unitVectors( const pod::Vector3t<T>& u, const pod::Vector3t<T>& v );
+		template<typename T> pod::Quaternion<T> lookAt( const pod::Vector3t<T>& source, const pod::Vector3t<T>& destination );
+		
+		template<typename T> T conjugate( const T& quaternion );
+		template<typename T> T inverse( const T& quaternion );
+		template<typename T> T& conjugate( T& quaternion );
+		template<typename T> T& inverse( T& quaternion );
+
+		template<typename T> pod::Vector3t<T> eulerAngles( const pod::Quaternion<T>& quaternion );
+		template<typename T> T pitch( const pod::Quaternion<T>& quaternion );
+		template<typename T> T yaw( const pod::Quaternion<T>& quaternion );
+		template<typename T> T roll( const pod::Quaternion<T>& quaternion );
+		
+		template<typename T> pod::Quaternion<T> fromMatrix( const pod::Matrix4t<T>& matrix );
+	}
+}
+
+namespace uf {
+	template<typename T = pod::Math::num_t>
+	class /*UF_API*/ Quaternion {
+public:
+	// 	Easily access POD's type
+		typedef pod::Quaternion<T> pod_t;
+	// 	Replicate POD information
+		typedef T type_t;
+		typedef T* container_t;
+		static const std::size_t size = 4;
+	protected:
+	// 	POD storage
+		Quaternion<T>::pod_t m_pod;
+	public:
+		T& x = m_pod.x;
+		T& y = m_pod.y;
+		T& z = m_pod.z;
+		T& w = m_pod.w;
+	public:
+	// 	C-tor
+		Quaternion(); 																	// initializes POD to 'def'
+		Quaternion(T def); 																// initializes POD to 'def'
+		Quaternion(T x, T y, T z, T w); 												// initializes POD to 'def'
+		Quaternion(const Quaternion<T>::pod_t& pod); 									// copies POD altogether
+		Quaternion(const T components[4]); 												// copies data into POD from 'components' (typed as C array)
+		Quaternion(const std::vector<T>& components); 									// copies data into POD from 'components' (typed as std::vector<T>)
+	// 	D-tor
+		// Unneccesary
+	// 	POD access
+		Quaternion<T>::pod_t& data(); 													// 	Returns a reference of POD
+		const Quaternion<T>::pod_t& data() const; 										// 	Returns a const-reference of POD
+	// 	Alternative POD access
+		T* get();																		// 	Returns a pointer to the entire array
+		const T* get() const; 															// 	Returns a const-pointer to the entire array
+		T& getComponent( std::size_t i );												// 	Returns a reference to a single element
+		const T& getComponent( std::size_t i ) const; 									// 	Returns a const-reference to a single element
+	// 	POD manipulation
+		T* set(const T components[4]);													// 	Sets the entire array
+		T& setComponent( std::size_t i, const T& value );								// 	Sets a single element
+	// 	Validation
+		bool isValid() const; 															// 	Checks if all components are valid (non NaN, inf, etc.)
+	// 	Basic arithmetic
+		inline uf::Quaternion<T>& multiply( const Quaternion<T>& quaternion );			// 	Multiplies two quaternions of same type and size together
+		inline uf::Quaternion<T>  multiply( const Quaternion<T>& quaternion ) const;	// 	Multiplies two quaternions of same type and size together
+		inline uf::Vector3t<T>    rotate( const Vector3t<T>& quaternion ) const;		// 	Multiplies a quaternion and a vector of same type and size together
+		inline uf::Vector4t<T>    rotate( const Vector4t<T>& quaternion ) const;		// 	Multiplies a quaternion and a vector of same type and size together
+		inline uf::Quaternion<T>& negate();												// 	Flip sign of all components
+	// 	Complex arithmetic
+		inline T dot( const Quaternion<T> right ) const; 								// 	Compute the dot product between two quaternions
+		inline pod::Angle angle( const Quaternion<T>& b ) const; 						// 	Compute the angle between two quaternions
+		
+		inline uf::Quaternion<T> lerp( const Quaternion<T> to, double delta ) const; 	// 	Linearly interpolate between two quaternions
+		inline uf::Quaternion<T> slerp( const Quaternion<T> to, double delta ) const; 	// 	Spherically interpolate between two quaternions
+		
+		inline T distanceSquared( const Quaternion<T> b ) const; 						// 	Compute the distance between two quaternions (doesn't sqrt)
+		inline T distance( const Quaternion<T> b ) const; 								// 	Compute the distance between two quaternions
+		inline T magnitude() const; 													// 	Gets the magnitude of the quaternion
+		inline T norm() const; 															// 	Compute the norm of the quaternion
+		
+		inline uf::Quaternion<T>& normalize(); 											// 	Normalizes a quaternion
+		uf::Quaternion<T> getNormalized() const; 										// 	Return a normalized quaternion
+	// 	Quaternion ops
+		inline uf::Matrix4t<T> matrix() const;
+		inline uf::Quaternion<T>& axisAngle( const Vector3t<T>& axis, T angle );
+		inline uf::Quaternion<T>& unitVectors( const Vector3t<T>& u, const Vector3t<T>& v );
+		
+		inline uf::Quaternion<T>& conjugate();
+		inline uf::Quaternion<T>& inverse();
+		
+		inline uf::Quaternion<T> getConjugate() const;
+		inline uf::Quaternion<T> getInverse() const;
+		inline std::string toString() const;
+	// 	Overloaded ops
+		// Accessing via subscripts
+		T& operator[](std::size_t i);
+		const T& operator[](std::size_t i) const;
+		// Arithmetic
+		inline Quaternion<T> operator-() const; 										// 	Negation
+		inline Quaternion<T> operator*( const Quaternion<T>& quaternion ) const; 		// 	Multiplication between two quaternions
+		inline Vector3t<T> operator*( const Vector3t<T>& vector ) const; 				// 	Multiplication between a quaternion and a vector (rotates vector)
+		inline Vector4t<T> operator*( const Vector4t<T>& vector ) const; 				// 	Multiplication between a quaternion and a vector (rotates vector)
+		inline Matrix4t<T> operator*( const Matrix4t<T>& matrix ) const; 				// 	Multiplication between a quaternion and a matrix
+		inline Quaternion<T>& operator *=( const Quaternion<T>& quaternion ); 			// 	Multiplication set between two quaternions
+		inline bool operator==( const Quaternion<T>& quaternion ) const; 				// 	Equality check between two quaternions (equals)
+		inline bool operator!=( const Quaternion<T>& quaternion ) const; 				// 	Equality check between two quaternions (not equals)
+		inline bool operator<( const Quaternion<T>& quaternion ) const; 				// 	Equality check between two quaternions (less than)
+		inline bool operator<=( const Quaternion<T>& quaternion ) const; 				// 	Equality check between two quaternions (less than or equals)
+		inline bool operator>( const Quaternion<T>& quaternion ) const; 				// 	Equality check between two quaternions (greater than)
+		inline bool operator>=( const Quaternion<T>& quaternion ) const; 				// 	Equality check between two quaternions (greater than or equals)
+		
+		inline operator pod_t&() { return this->m_pod; }
+		inline operator const pod_t&() const { return this->m_pod; }
+	};
+}
+
+
+#include "quaternion/quaternion.inl"
+#ifdef UF_USE_GLM_TMP
+	#undef UF_USE_GLM
+	#undef UF_USE_GLM_TMP
+#endif
\ No newline at end of file
diff --git a/engine/inc/uf/utils/math/quaternion/class.inl b/engine/inc/uf/utils/math/quaternion/class.inl
new file mode 100644
index 00000000..00dd3c9b
--- /dev/null
+++ b/engine/inc/uf/utils/math/quaternion/class.inl
@@ -0,0 +1,278 @@
+// 	C-tor
+// initializes POD to 'def'
+template<typename T>
+uf::Quaternion<T>::Quaternion() {
+
+}
+// initializes POD to 'def'
+template<typename T>
+uf::Quaternion<T>::Quaternion(T def) :
+	m_pod( {def, def, def, 1} )
+{
+
+}
+// initializes POD to 'def'
+template<typename T>
+uf::Quaternion<T>::Quaternion(T x, T y, T z, T w) :
+	m_pod( {x, y, z, w} )
+{
+
+}
+// copies POD altogether
+template<typename T>
+uf::Quaternion<T>::Quaternion(const Quaternion<T>::pod_t& pod) :
+	m_pod(pod)
+{
+
+}
+// copies data into POD from 'components' (typed as C array)
+template<typename T>
+uf::Quaternion<T>::Quaternion(const T components[4] ) : 
+	m_pod( { components[0], components[1], components[2], components[3] } )
+{
+
+}
+// copies data into POD from 'components' (typed as std::vector<T>)
+template<typename T>
+uf::Quaternion<T>::Quaternion(const std::vector<T>& components) {
+	memcpy( this->m_pod.components, &components[0], 4 );
+}
+// 	D-tor
+// Unneccesary
+// 	POD access
+// 	Returns a reference of POD
+template<typename T>
+typename uf::Quaternion<T>::pod_t& uf::Quaternion<T>::data() {
+	return this->m_pod;
+}
+// 	Returns a const-reference of POD
+template<typename T>
+const typename uf::Quaternion<T>::pod_t& uf::Quaternion<T>::data() const {
+	return this->m_pod;
+}
+// 	Alternative POD access
+// 	Returns a pointer to the entire array
+template<typename T>
+T* uf::Quaternion<T>::get() {
+	return this->m_pod.components;
+}
+// 	Returns a const-pointer to the entire array
+template<typename T>
+const T* uf::Quaternion<T>::get() const {
+	return this->m_pod.components;
+}
+// 	Returns a reference to a single element
+template<typename T>
+T& uf::Quaternion<T>::getComponent( std::size_t i ) {
+	return this->m_pod.components[i];
+}
+// 	Returns a const-reference to a single element
+template<typename T>
+const T& uf::Quaternion<T>::getComponent( std::size_t i ) const {
+	return this->m_pod.components[i];
+}
+// 	POD manipulation
+// 	Sets the entire array
+template<typename T>
+T* uf::Quaternion<T>::set(const T components[4]) {
+	for ( std::size_t i = 0; i < 4; ++i ) this->m_pod[i] = components[i];
+}
+// 	Sets a single element
+template<typename T>
+T& uf::Quaternion<T>::setComponent( std::size_t i, const T& value ) {
+	this->m_pod[i] = value;
+}
+// 	Validation
+// 	Checks if all components are valid (non NaN, inf, etc.)
+template<typename T>
+bool uf::Quaternion<T>::isValid() const {
+	for ( std::size_t i = 0; i < 4; ++i ) if ( this->m_pod[i] != this->m_pod[i] ) return false;
+	return true;
+}
+// 	Basic arithmetic
+// 	Multiplies two quaternions of same type and size together
+template<typename T>
+inline uf::Quaternion<T>& uf::Quaternion<T>::multiply( const Quaternion<T>& b ) {
+	uf::quaternion::multiply(this->m_pod, b.m_pod);
+	return *this;
+}
+template<typename T>
+inline uf::Quaternion<T>  uf::Quaternion<T>::multiply( const Quaternion<T>& b ) const {
+	return uf::quaternion::multiply(this->m_pod, b.m_pod);
+}
+template<typename T>
+inline uf::Vector3t<T>  uf::Quaternion<T>::rotate( const Vector3t<T>& b ) const {
+	return uf::quaternion::rotate(this->m_pod, b.data());
+}
+template<typename T>
+inline uf::Vector4t<T>  uf::Quaternion<T>::rotate( const Vector4t<T>& b ) const {
+	return uf::quaternion::rotate(this->m_pod, b.data());
+}
+// 	Flip sign of all components
+template<typename T>
+inline uf::Quaternion<T>& uf::Quaternion<T>::negate() {
+	uf::quaternion::negate(this->m_pod);
+	return *this;
+}
+// 	Complex arithmetic
+// 	Compute the dot product between two quaternions
+template<typename T>
+inline T uf::Quaternion<T>::dot( const Quaternion<T> right ) const {
+	return uf::quaternion::dot( this->m_pod, right.m_pod );
+}
+// 	Compute the angle between two quaternions
+template<typename T>
+inline pod::Angle uf::Quaternion<T>::angle( const Quaternion<T>& b ) const {
+	return uf::quaternion::angle( this->m_pod, b.m_pod );
+}
+
+// 	Linearly interpolate between two quaternions
+template<typename T>
+inline uf::Quaternion<T> uf::Quaternion<T>::lerp( const Quaternion<T> to, double delta ) const {
+	return uf::quaternion::lerp( this->m_pod, to.m_pod, delta );
+}
+// 	Spherically interpolate between two quaternions
+template<typename T>
+inline uf::Quaternion<T> uf::Quaternion<T>::slerp( const Quaternion<T> to, double delta ) const {
+	return uf::quaternion::slerp( this->m_pod, to.m_pod, delta );
+}
+
+// 	Compute the distance between two quaternions (doesn't sqrt)
+template<typename T>
+inline T uf::Quaternion<T>::distanceSquared( const Quaternion<T> b ) const {
+	return uf::quaternion::distanceSquared(this->m_pod, b.m_pod);
+}
+// 	Compute the distance between two quaternions
+template<typename T>
+inline T uf::Quaternion<T>::distance( const Quaternion<T> b ) const {
+	return uf::quaternion::distance(this->m_pod, b.m_pod);
+}
+// 	Gets the magnitude of the quaternion
+template<typename T>
+inline T uf::Quaternion<T>::magnitude() const {
+	return uf::quaternion::magnitude(this->m_pod);
+}
+// 	Compute the norm of the quaternion
+template<typename T>
+inline T uf::Quaternion<T>::norm() const {
+	return uf::quaternion::norm(this->m_pod);
+}
+
+// 	Normalizes a quaternion
+template<typename T>
+inline uf::Quaternion<T>& uf::Quaternion<T>::normalize() {
+	uf::quaternion::normalize(this->m_pod);
+	return *this;
+}
+// 	Return a normalized quaternion
+template<typename T>
+uf::Quaternion<T> uf::Quaternion<T>::getNormalized() const {
+	return uf::quaternion::normalize(this->m_pod);
+}
+// 	Quaternion ops
+template<typename T>
+inline uf::Matrix4t<T> uf::Quaternion<T>::matrix() const {
+	return uf::quaternion::matrix(this->m_pod);
+}
+template<typename T>
+inline uf::Quaternion<T>& uf::Quaternion<T>::axisAngle( const Vector3t<T>& axis, T angle ) {
+	this->m_pod = uf::quaternion::axisAngle(axis, angle);
+	return *this;
+}
+template<typename T>
+inline uf::Quaternion<T>& uf::Quaternion<T>::unitVectors( const Vector3t<T>& u, const Vector3t<T>& v ) {
+	this->m_pod = uf::quaternion::unitVectors(u, v);
+	return *this;
+}
+
+template<typename T>
+inline uf::Quaternion<T>& uf::Quaternion<T>::conjugate() {
+	return uf::quaternion::conjugate(this->m_pod);
+}
+template<typename T>
+inline uf::Quaternion<T>& uf::Quaternion<T>::inverse() {
+	return uf::quaternion::inverse(this->m_pod);
+}
+
+template<typename T>
+inline uf::Quaternion<T> uf::Quaternion<T>::getConjugate() const {
+	return uf::quaternion::conjugate(this->m_pod);
+}
+template<typename T>
+inline uf::Quaternion<T> uf::Quaternion<T>::getInverse() const {
+	return uf::quaternion::inverse(this->m_pod);
+}
+template<typename T>
+inline std::string uf::Quaternion<T>::toString() const {
+	return uf::vector::toString(this->m_pod);
+}
+// 	Overloaded ops
+// Accessing via subscripts
+template<typename T>
+T& uf::Quaternion<T>::operator[](std::size_t i) {
+	return this->m_pod[i];
+}
+template<typename T>
+const T& uf::Quaternion<T>::operator[](std::size_t i) const {
+	return this->m_pod[i];
+}
+// Arithmetic
+// 	Negation
+template<typename T>
+inline uf::Quaternion<T> uf::Quaternion<T>::operator-() const {
+	return this->negate();
+}
+// 	Multiplication between two quaternions
+template<typename T>
+inline uf::Quaternion<T> uf::Quaternion<T>::operator*( const Quaternion<T>& quaternion ) const {
+	return this->multiply(quaternion);
+}
+// 	Multiplication between a quaternion and a vector (rotates vector)
+template<typename T>
+inline uf::Vector3t<T> uf::Quaternion<T>::operator*( const Vector3t<T>& vector ) const {
+	return this->multiply(vector);
+}
+template<typename T>
+inline uf::Vector4t<T> uf::Quaternion<T>::operator*( const Vector4t<T>& vector ) const {
+	return this->multiply(vector);
+}
+// 	Multiplication between a quaternion and a matrix
+template<typename T>
+inline uf::Matrix4t<T> uf::Quaternion<T>::operator*( const Matrix4t<T>& matrix ) const {
+	return this->multiply(matrix);
+}
+// 	Multiplication set between two quaternions
+template<typename T>
+inline uf::Quaternion<T>& uf::Quaternion<T>::operator *=( const Quaternion<T>& quaternion ) {
+	return this->multiply(quaternion);
+}
+// 	Equality check between two quaternions (equals)
+template<typename T>
+inline bool uf::Quaternion<T>::operator==( const Quaternion<T>& quaternion ) const {
+	return uf::quaternion::equals(this->m_pod, quaternion.m_pod);
+}
+// 	Equality check between two quaternions (not equals)
+template<typename T>
+inline bool uf::Quaternion<T>::operator!=( const Quaternion<T>& quaternion ) const {
+	return !uf::quaternion::equals(this->m_pod, quaternion.m_pod);
+}
+// 	Equality check between two quaternions (less than)
+template<typename T>
+inline bool uf::Quaternion<T>::operator<( const Quaternion<T>& quaternion ) const {
+	return !(uf::quaternion::compareTo(this->m_pod, quaternion.m_pod) < 0);
+}
+// 	Equality check between two quaternions (less than or equals)
+template<typename T>
+inline bool uf::Quaternion<T>::operator<=( const Quaternion<T>& quaternion ) const {
+	return !(uf::quaternion::compareTo(this->m_pod, quaternion.m_pod) <= 0);
+}
+// 	Equality check between two quaternions (greater than)
+template<typename T>
+inline bool uf::Quaternion<T>::operator>( const Quaternion<T>& quaternion ) const {
+	return !(uf::quaternion::compareTo(this->m_pod, quaternion.m_pod) > 0);
+}
+// 	Equality check between two quaternions (greater than or equals)
+template<typename T>
+inline bool uf::Quaternion<T>::operator>=( const Quaternion<T>& quaternion ) const {
+	return !(uf::quaternion::compareTo(this->m_pod, quaternion.m_pod) >= 0);
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/math/quaternion/pod.inl b/engine/inc/uf/utils/math/quaternion/pod.inl
new file mode 100644
index 00000000..b7e4f460
--- /dev/null
+++ b/engine/inc/uf/utils/math/quaternion/pod.inl
@@ -0,0 +1,294 @@
+// 	Equality checking
+// 	Equality check between two quaternions (less than)
+template<typename T> std::size_t uf::quaternion::compareTo( const T& left, const T& right ) {
+	return uf::vector::compareTo(left, right);
+//	return uf::quaternion::angle(left) > uf::quaternion::angle(right);
+}
+// 	Equality check between two quaternions (equals)
+template<typename T> bool uf::quaternion::equals( const T& left, const T& right ) {
+	return uf::quaternion::compareTo( left, right ) == 0;
+}
+// 	Basic arithmetic
+// 	Multiplies two quaternions of same type and size together
+template<typename T> T uf::quaternion::multiply( const T& left, const T& right ) {
+	T q1 = uf::quaternion::normalize(left);
+	T q2 = uf::quaternion::normalize(right);
+	T q;
+	
+	q.x = q1.w * q2.x + q1.x * q2.w + q1.y * q2.z - q1.z * q2.y;
+	q.y = q1.w * q2.y + q1.y * q2.w + q1.z * q2.x - q1.x * q2.z;
+	q.z = q1.w * q2.z + q1.z * q2.w + q1.x * q2.y - q1.y * q2.x;
+	q.w = q1.w * q2.w - q1.x * q2.x - q1.y * q2.y - q1.z * q2.z;
+
+	return uf::quaternion::normalize( q );
+}
+// 	Multiplies this quaternion by a scalar
+/*
+template<typename T> T uf::quaternion::multiply( const T& quaternion, const typename T::type_t& scalar ) {
+	return uf::vector::multiply( quaternion, scalar );
+}
+*/
+// 	Flip sign of all components
+template<typename T> T uf::quaternion::negate( const T& quaternion ) {
+	return uf::quaternion::inverse(quaternion);
+}
+template<typename T> pod::Quaternion<T> uf::quaternion::identity() {
+	return pod::Quaternion<T>{ 0, 0, 0, 1 };
+}
+// 	Writes to first value
+// 	Multiplies two quaternions of same type and size together
+template<typename T> T& uf::quaternion::multiply( T& left, const T& right ) {
+	return left = uf::quaternion::multiply((const T&)  left, right );
+}
+// 	Multiplies a quaternion and a vector of same type and size together
+template<typename T> pod::Vector3t<T> uf::quaternion::rotate( const pod::Quaternion<T>& left, const pod::Vector3t<T>& right ) {
+	pod::Vector3t<T> qVec = { left.x, left.y, left.z };
+	T s = left.w;
+	return uf::vector::multiply( qVec, 2 * uf::vector::dot( qVec, right ) ) + uf::vector::multiply( right, s*s - uf::vector::dot( qVec, qVec )) +  ( uf::vector::cross( qVec, right ) * 2 * s );
+}
+template<typename T> pod::Vector4t<T> uf::quaternion::rotate( const pod::Quaternion<T>& left, const pod::Vector4t<T>& right ) {
+	pod::Vector3t<T> vector = uf::quaternion::rotate( left, {right.x, right.y, right.z} );
+	return {vector.x, vector.y, vector.z, left.w};
+}
+// 	Flip sign of all components
+template<typename T> T& uf::quaternion::negate( T& quaternion ) {
+	return quaternion = uf::quaternion::negate((const T&) quaternion);
+}
+// 	Normalizes a quaternion
+template<typename T> T& uf::quaternion::normalize( T& quaternion ) {
+	return quaternion = uf::quaternion::normalize((const T&) quaternion);
+}
+// 	Complex arithmetic
+// 	Compute the dot product between two quaternions
+template<typename T> typename T::type_t uf::quaternion::dot( const T& left, const T& right ) {
+	return uf::vector::dot(left, right);
+}
+// 	Compute the angle between two quaternions
+template<typename T> pod::Angle uf::quaternion::angle( const T& a, const T& b ) {
+	T tmp = b * uf::quaternion::inverse(a);
+	return acosf(tmp.w) * 2.0;
+}
+template<typename T> pod::Vector3t<T> uf::quaternion::eulerAngles( const pod::Quaternion<T>& quaternion ) {
+	return pod::Vector3t<T>{
+		uf::quaternion::pitch( quaternion ),
+		uf::quaternion::yaw( quaternion ),
+		uf::quaternion::roll( quaternion ),
+	};
+}
+template<typename T> T uf::quaternion::pitch( const pod::Quaternion<T>& q ) {
+	T const y = static_cast<T>(2) * (q.y * q.z + q.w * q.x);
+#if UF_USE_SIMD
+	uf::simd::value Q = q;
+	pod::Quaternion<T> s = uf::simd::mul( Q, Q );
+	T const x = s.w - s.x - s.y - s.z;
+#else
+	T const x = q.w * q.w - q.x * q.x - q.y * q.y + q.z * q.z;
+#endif
+
+	T epsilon = std::numeric_limits<T>::epsilon();
+	if ( fabs(x) < epsilon && fabs(y) < epsilon  ) //avoid atan2(0,0) - handle singularity - Matiis
+		return static_cast<T>(static_cast<T>(2) * atan2(q.x, q.w));
+
+	return static_cast<T>(atan2(y, x));
+}
+template<typename T> T uf::quaternion::yaw( const pod::Quaternion<T>& q ) {
+	return asin(std::clamp(static_cast<T>(-2) * (q.x * q.z - q.w * q.y), static_cast<T>(-1), static_cast<T>(1)));
+}
+template<typename T> T uf::quaternion::roll( const pod::Quaternion<T>& q ) {
+	T const y = static_cast<T>(2) * (q.x * q.y + q.w * q.z);
+#if UF_USE_SIMD
+	uf::simd::value Q = q;
+	pod::Quaternion<T> s = uf::simd::mul( Q, Q );
+	T const x = s.w - s.x - s.y - s.z;
+#else
+	T const x = q.w * q.w - q.x * q.x - q.y * q.y + q.z * q.z;
+#endif
+
+	T epsilon = std::numeric_limits<T>::epsilon();
+	if ( fabs(x) < epsilon && fabs(y) < epsilon  ) //avoid atan2(0,0) - handle singularity - Matiis
+		return static_cast<T>(0);
+
+	return static_cast<T>(atan2(y, x));
+}
+
+// 	Linearly interpolate between two quaternions
+template<typename T> T uf::quaternion::lerp( const T& from, const T& to, double delta ) {
+	return uf::vector::lerp( from, to, delta );
+}
+// 	Spherically interpolate between two quaternions
+template<typename T> T uf::quaternion::slerp( const T& x, const T& y, double a ) {
+//	return uf::vector::slerp( from, to, delta );
+	T z = y;
+
+	auto cosTheta = uf::quaternion::dot( x, y );
+
+	// If cosTheta < 0, the interpolation will take the long way around the sphere.
+	// To fix this, one quat must be negated.
+	if( cosTheta < 0 ) {
+		z = -y;
+		cosTheta = -cosTheta;
+	}
+
+	// Perform a linear interpolation when cosTheta is close to 1 to avoid side effect of sin(angle) becoming a zero denominator
+	if( cosTheta > 1 - std::numeric_limits<typename T::type_t>::epsilon() ) return uf::vector::mix( x, z, a );
+	// Essential Mathematics, page 467
+	typename T::type_t angle = acos(cosTheta);
+	return (x * sin((1 - a) * angle) + z * sin(a * angle)) / sin(angle);
+}
+
+// 	Compute the distance between two quaternions (doesn't sqrt)
+template<typename T> typename T::type_t uf::quaternion::distanceSquared( const T& a, const T& b ) {
+	return uf::vector::distanceSquared(a, b);
+}
+// 	Compute the distance between two quaternions
+template<typename T> typename T::type_t uf::quaternion::distance( const T& a, const T& b ) {
+	return uf::vector::distance(a, b);
+}
+// 	Gets the magnitude of the quaternion
+template<typename T> typename T::type_t uf::quaternion::magnitude( const T& quaternion ) {
+	return uf::vector::magnitude(quaternion);
+}
+// 	Compute the norm of the quaternion
+template<typename T> typename T::type_t uf::quaternion::norm( const T& quaternion ) {
+	return uf::vector::norm(quaternion);
+}
+// 	Normalizes a quaternion
+template<typename T> T uf::quaternion::normalize( const T& quaternion ) {
+	return uf::vector::normalize(quaternion);
+}
+
+// Quaternion ops
+template<typename T> pod::Matrix4t<typename T::type_t> uf::quaternion::matrix( const T& q ) {
+	T normal = uf::quaternion::normalize( q );
+	normal.w *= -1;
+
+	typename T::type_t x = normal.x;
+	typename T::type_t y = normal.y;
+	typename T::type_t z = normal.z;
+	typename T::type_t w = normal.w;
+
+	typename T::type_t x2 = x * x;
+	typename T::type_t y2 = y * y;
+	typename T::type_t z2 = z * z;
+//	typename T::type_t w2 = w * w;
+
+	return uf::matrix::initialize({
+		1 - 2 * y2 - 2 * z2, 		2 * x * y - 2 * w * z, 		2 * x * z + 2 * w * y, 	0,
+		2 * x * y + 2 * w * z, 		1 - 2 * x2 - 2 * z2, 		2 * y * z - 2 * w * x, 	0,
+		2 * x * z - 2 * w * y, 		2 * y * z + 2 * w * x, 		1 - 2 * x2 - 2 * y2, 	0,
+		0, 							0, 							0, 						1
+	});
+}
+template<typename T> pod::Quaternion<T> uf::quaternion::axisAngle( const pod::Vector3t<T>& axis, T angle ) { 
+	pod::Quaternion<T> q;
+
+	T sinAngle = sin( angle * 0.5 );
+	T cosAngle = cos( angle * 0.5 );
+#if UF_USE_SIMD
+	q = uf::simd::mul( uf::simd::value(axis.x, axis.y, axis.z, 1.0f ), uf::simd::value(sinAngle, sinAngle, sinAngle, cosAngle) );
+#else
+	q.x = axis.x * sinAngle;
+	q.y = axis.y * sinAngle;
+	q.z = axis.z * sinAngle;
+	q.w = cosAngle;
+#endif
+	uf::quaternion::normalize(q);
+	return q;
+}
+template<typename T> pod::Quaternion<T> uf::quaternion::unitVectors( const pod::Vector3t<T>& u, const pod::Vector3t<T>& v ) {
+	T dot = uf::vector::dot(u, v);
+	if ( dot + 1.0 < 0.00001 ) return uf::quaternion::axisAngle( uf::vector::normalize(u), (T) 3.1415926 );
+	T mag = sqrt( 2.0 + 2.0 * dot );
+	pod::Vector3t<T> w = uf::vector::multiply(uf::vector::cross(u, v), (1.0 / mag));
+	return {
+		.x = w.x,
+		.y = w.y,
+		.z = w.z,
+		.w = mag * 0.5
+	};
+}
+template<typename T> pod::Quaternion<T> uf::quaternion::lookAt( const pod::Vector3t<T>& at, const pod::Vector3t<T>& _up ) { 
+	pod::Vector3t<T> up = _up;
+	pod::Vector3t<T> forward = uf::vector::normalize( at ) ;
+	uf::vector::orthonormalize( up, forward );
+	pod::Vector3t<T> right = uf::vector::cross( up, forward );
+	pod::Quaternion<T> q;
+#if UF_USE_SIMD
+	T w = sqrtf(1.0f + right.x + up.y + forward.z) * 0.5f;
+	float w4_recip = 1.0f / (4.0f * w);
+	q = uf::simd::mul( uf::simd::sub( uf::simd::value( forward.y, right.z, up.x, 0.0f ), uf::simd::value( up.z, forward.x, right.y, 0.0f ) ), w4_recip );
+	q.w = w;
+#else
+	q.w = sqrtf(1.0f + right.x + up.y + forward.z) * 0.5f;
+	float w4_recip = 1.0f / (4.0f * q.w);
+	q.x = (forward.y - up.z) * w4_recip;
+	q.y = (right.z - forward.x) * w4_recip;
+	q.z = (up.x - right.y) * w4_recip;
+#endif
+	return uf::quaternion::inverse( uf::quaternion::normalize( q ) );
+//	return q;
+}
+
+template<typename T> T& uf::quaternion::conjugate( T& q ) {
+#if UF_USE_SIMD
+	return q = uf::simd::mul( q, -1.0f );
+#endif
+	return q = {
+		.x = -q.x,	
+		.y = -q.y,	
+		.z = -q.z,	
+		.w =  q.w	
+	};
+}
+template<typename T> T uf::quaternion::conjugate( const T& q ) {
+#if UF_USE_SIMD
+	return uf::simd::mul( q, -1.0f );
+#endif
+	return {
+		.x = -q.x,	
+		.y = -q.y,	
+		.z = -q.z,	
+		.w =  q.w	
+	};
+}
+template<typename T> T& uf::quaternion::inverse( T& q ) {
+#if UF_USE_SIMD
+	uf::simd::value Q = q;
+	return q = uf::simd::div( uf::simd::mul( Q, { -1.0f, -1.0f, -1.0f, 1.0f } ), uf::simd::dot( Q, Q ) );
+#endif
+	return q = uf::quaternion::conjugate( (const T&) q ) / uf::quaternion::dot( q, q );
+}
+template<typename T> T uf::quaternion::inverse( const T& q ) {
+#if UF_USE_SIMD
+	uf::simd::value Q = q;
+	return uf::simd::div( uf::simd::mul( Q, { -1.0f, -1.0f, -1.0f, 1.0f } ), uf::simd::dot( Q, Q ) );
+#endif
+	return uf::quaternion::conjugate( q ) / uf::quaternion::dot( q, q );
+}
+template<typename T> pod::Quaternion<T> uf::quaternion::fromMatrix( const pod::Matrix4t<T>& m ) {
+	pod::Quaternion<T> q;
+	T m0  = m[(4*0)+0];
+	T m5  = m[(4*1)+1];
+	T m10 = m[(4*2)+2];
+
+#if UF_USE_SIMD
+	q = uf::simd::div( uf::simd::sqrt( uf::simd::max( 0.0f, uf::simd::add( uf::simd::add( uf::simd::add( 1.0f, uf::simd::value( m0, m0, -m0, -m0 ) ), uf::simd::value( m5, -m5, -m5, -m5 ) ), { m10, -m10, -m10, m10 } ) ) ), 2.0f );
+	pod::Vector4f signs = uf::simd::sub( uf::simd::value( m[(4*1)+2], m[(4*2)+0], m[(4*0)+1], 0.0f ), uf::simd::value( m[(4*2)+1], m[(4*0)+2], m[(4*1)+0], 0.0f ) );
+	return {
+		copysign( q.x, signs.x ),
+		copysign( q.y, signs.y ),
+		copysign( q.z, signs.z ),
+		q.w
+	};
+#else
+	q.w = sqrt(fmax(0, 1 + m0 + m5 + m10)) / 2;
+	q.x = sqrt(fmax(0, 1 + m0 - m5 - m10)) / 2;
+	q.y = sqrt(fmax(0, 1 - m0 + m5 - m10)) / 2;
+	q.z = sqrt(fmax(0, 1 - m0 - m5 + m10)) / 2;
+
+	q.x = copysign(q.x, m[(4*1)+2] - m[(4*2)+1]);
+	q.y = copysign(q.y, m[(4*2)+0] - m[(4*0)+2]);
+	q.z = copysign(q.z, m[(4*0)+1] - m[(4*1)+0]);
+#endif
+	return q;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/math/quaternion/quaternion.inl b/engine/inc/uf/utils/math/quaternion/quaternion.inl
new file mode 100644
index 00000000..90735b93
--- /dev/null
+++ b/engine/inc/uf/utils/math/quaternion/quaternion.inl
@@ -0,0 +1,4 @@
+#pragma once
+
+#include "pod.inl"
+#include "class.inl"
\ No newline at end of file
diff --git a/engine/inc/uf/utils/math/rayt.h b/engine/inc/uf/utils/math/rayt.h
new file mode 100644
index 00000000..509fae85
--- /dev/null
+++ b/engine/inc/uf/utils/math/rayt.h
@@ -0,0 +1,35 @@
+#pragma once
+
+#include <uf/config.h>
+#include <cstdint>
+
+namespace pod {
+	struct UF_API Primitive {
+		static const uint32_t EMPTY = (uint32_t) -1; 
+		static const uint32_t CUBE = 1;
+		static const uint32_t LEAF = 2;
+		static const uint32_t TREE = 3;
+		static const uint32_t ROOT = 4;
+		alignas(16) pod::Vector4f position; 			// 4 * 4 = 16 bytes
+		alignas(4) uint32_t type; 						// 4 * 1 = 4 bytes
+	};
+	struct UF_API Light {
+		alignas(16) pod::Vector3f position;
+		alignas(16) pod::Vector3f color;
+	};
+	struct UF_API Tree {
+		static const size_t TREE_SIZE = 8;
+		alignas(16) pod::Vector4f position; 			// 4 * 4 = 16 bytes
+		alignas(4) uint32_t type; 						// 4 * 1 = 4 bytes
+		alignas(4) uint32_t children[Tree::TREE_SIZE]; 	// 4 * 8 = 32 bytes
+	};
+}
+
+namespace uf {
+	namespace primitive {
+		std::vector<pod::Tree> UF_API populate( const std::vector<pod::Primitive>& cubes );
+		std::vector<pod::Tree> UF_API populateEntirely( const std::vector<pod::Primitive>& cubes );
+		std::vector<pod::Tree> UF_API populateEntirely( const std::vector<pod::Tree>& trees, bool = false );
+		void UF_API test( const std::vector<pod::Primitive>& cubes, const std::vector<pod::Tree>& trees );
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/math/simd.h b/engine/inc/uf/utils/math/simd.h
new file mode 100644
index 00000000..e69de29b
diff --git a/engine/inc/uf/utils/math/transform.h b/engine/inc/uf/utils/math/transform.h
new file mode 100644
index 00000000..31f45932
--- /dev/null
+++ b/engine/inc/uf/utils/math/transform.h
@@ -0,0 +1,81 @@
+#pragma once
+
+#include <uf/config.h>
+
+#include <sstream>
+#include <vector>
+#include <cmath>
+#include <stdint.h>
+
+#include <uf/utils/math/angle.h>
+#include <uf/utils/math/vector.h>
+#include <uf/utils/math/quaternion.h>
+#include <uf/utils/math/matrix.h>
+#include <uf/utils/time/time.h>
+#include <uf/utils/io/iostream.h>
+#ifdef UF_USE_GLM
+	#include "glm.h"
+#endif
+#include "math.h"
+namespace pod {
+	// Simple transforms (designed [to store in arrays] with minimal headaches)
+	template<typename T = pod::Math::num_t>
+	struct /*UF_API*/ Transform {
+		typedef T type_t;
+
+		pod::Vector3t<T> position;
+		pod::Vector3t<T> scale = {1, 1, 1};
+
+		pod::Vector3t<T> up = {0, 1, 0};
+		pod::Vector3t<T> right = {1, 0, 0};
+		pod::Vector3t<T> forward = {0, 0, 1};
+		pod::Quaternion<T> orientation = {0, 0, 0, 1};
+
+		pod::Matrix4t<T> model = uf::matrix::identity();
+
+		pod::Transform<T>* reference = NULL;
+	};
+}
+
+namespace uf {
+	namespace transform {
+		template<typename T> pod::Transform<T>& /*UF_API*/ initialize( pod::Transform<T>& transform );
+		template<typename T> pod::Transform<T> /*UF_API*/ initialize();
+		template<typename T> pod::Transform<T>& /*UF_API*/ lookAt( pod::Transform<T>& transform, const pod::Vector3t<T>& at );
+		template<typename T> pod::Transform<T>& /*UF_API*/ move( pod::Transform<T>& transform, const pod::Vector3t<T>& axis, pod::Math::num_t delta );
+		template<typename T> pod::Transform<T>& /*UF_API*/ move( pod::Transform<T>& transform, const pod::Vector3t<T>& delta );
+		template<typename T> pod::Transform<T>& /*UF_API*/ reorient( pod::Transform<T>& transform );
+		template<typename T> pod::Transform<T> /*UF_API*/ reorient( const pod::Transform<T>& transform );
+		template<typename T> pod::Transform<T>& /*UF_API*/ rotate( pod::Transform<T>& transform, const pod::Vector3t<T>& axis, pod::Math::num_t delta );
+		template<typename T> pod::Transform<T>& /*UF_API*/ rotate( pod::Transform<T>& transform, const pod::Quaternion<T>& quat );
+		template<typename T> pod::Transform<T>& /*UF_API*/ scale( pod::Transform<T>& transform, const pod::Vector3t<T>& factor );
+		template<typename T> inline pod::Transform<T> /*UF_API*/ condense( const pod::Transform<T>& transform );
+		template<typename T> pod::Transform<T> /*UF_API*/ flatten( const pod::Transform<T>& transform, size_t depth = SIZE_MAX );
+		template<typename T> pod::Matrix4t<T> /*UF_API*/ model( const pod::Transform<T>& transform, bool flatten = false, size_t depth = SIZE_MAX );
+		template<typename T> pod::Transform<T> /*UF_API*/ fromMatrix( const pod::Matrix4t<T>& matrix );
+		template<typename T> pod::Transform<T>& /*UF_API*/ reference( pod::Transform<T>& transform, const pod::Transform<T>& parent, bool reorient = true );
+		
+		template<typename T> std::string /*UF_API*/ toString( const pod::Transform<T>&, bool flatten = true );
+		template<typename T> ext::json::Value /*UF_API*/ encode( const pod::Transform<T>&, bool flatten = true, bool compress = true );
+		template<typename T> pod::Transform<T>& /*UF_API*/ decode( const ext::json::Value&, pod::Transform<T>& );
+		template<typename T> pod::Transform<T> /*UF_API*/ decode( const ext::json::Value&, const pod::Transform<T>& = {} );
+	}
+}
+
+#include <sstream>
+namespace uf {
+	namespace string {
+		template<typename T>
+		std::string toString( const pod::Transform<T>& v, bool flatten = true );
+	}
+}
+namespace ext {
+	namespace json {
+		template<typename T>
+		ext::json::Value encode( const pod::Transform<T>& v, bool flatten = false );
+		template<typename T>
+		pod::Transform<T> decode( const ext::json::Value& v );
+	}
+}
+
+#include "transform/transform.inl"
\ No newline at end of file
diff --git a/engine/inc/uf/utils/math/transform/transform.inl b/engine/inc/uf/utils/math/transform/transform.inl
new file mode 100644
index 00000000..187dba39
--- /dev/null
+++ b/engine/inc/uf/utils/math/transform/transform.inl
@@ -0,0 +1,198 @@
+template<typename T> pod::Transform<T>& /*UF_API*/ uf::transform::initialize( pod::Transform<T>& transform ) {
+	transform.up = {0, 1, 0};
+	transform.right = {1, 0, 0};
+	transform.forward = {0, 0, 1};
+	transform.orientation = {0, 0, 0, 1};
+	transform.model = uf::matrix::identity();
+	transform.reference = NULL;
+	return transform;
+}
+template<typename T> pod::Transform<T> /*UF_API*/ uf::transform::initialize() {
+	pod::Transform<T> transform;
+	return transform = uf::transform::initialize(transform);
+}
+template<typename T> pod::Transform<T>& /*UF_API*/ uf::transform::lookAt( pod::Transform<T>& transform, const pod::Vector3t<T>& at ) {
+	pod::Vector3t<T> forward = uf::vector::normalize( at - transform.position );
+	pod::Vector3t<T> right = uf::vector::normalize(uf::vector::cross( forward, transform.up ));
+	pod::Vector3t<T> up = uf::vector::normalize(uf::vector::cross(at, right));
+
+	transform.up = up;
+	transform.right = right;
+	transform.forward = forward;
+
+	transform.orientation = uf::quaternion::lookAt( at, up );
+	return transform;
+}
+template<typename T> pod::Transform<T>& /*UF_API*/ uf::transform::move( pod::Transform<T>& transform, const pod::Vector3t<T>& axis, pod::Math::num_t delta ) {
+	transform.position += (axis * delta);
+	return transform;
+}
+template<typename T> pod::Transform<T>& /*UF_API*/ uf::transform::move( pod::Transform<T>& transform, const pod::Vector3t<T>& delta ) {
+	transform.position += delta;
+	return transform;
+}
+template<typename T> pod::Transform<T>& /*UF_API*/ uf::transform::reorient( pod::Transform<T>& transform ) {
+/*
+	transform.up = uf::vector::normalize(uf::quaternion::rotate(transform.orientation, pod::Vector3{0.0f, 1.0f, 0.0f}));
+	transform.right = uf::vector::normalize(uf::quaternion::rotate(transform.orientation, pod::Vector3{1.0f, 0.0f, 0.0f}));
+	transform.forward = uf::vector::normalize(uf::quaternion::rotate(transform.orientation, pod::Vector3{0.0f, 0.0f, 1.0f}));
+*/
+	pod::Quaternion<T> q = transform.orientation;
+	transform.forward = { 2 * (q.x * q.z + q.w * q.y),  2 * (q.y * q.x - q.w * q.x), 1 - 2 * (q.x * q.x + q.y * q.y) };
+	transform.up = { 2 * (q.x * q.y - q.w * q.z), 1 - 2 * (q.x * q.x + q.z * q.z), 2 * (q.y * q.z + q.w * q.x)};
+	transform.right = { 1 - 2 * (q.y * q.y + q.z * q.z), 2 * (q.x * q.y + q.w * q.z), 2 * (q.x * q.z - q.w * q.y)};
+	return transform;
+}
+template<typename T> pod::Transform<T> /*UF_API*/ uf::transform::reorient( const pod::Transform<T>& _transform ) {
+/*
+	transform.up = uf::vector::normalize(uf::quaternion::rotate(transform.orientation, pod::Vector3{0.0f, 1.0f, 0.0f}));
+	transform.right = uf::vector::normalize(uf::quaternion::rotate(transform.orientation, pod::Vector3{1.0f, 0.0f, 0.0f}));
+	transform.forward = uf::vector::normalize(uf::quaternion::rotate(transform.orientation, pod::Vector3{0.0f, 0.0f, 1.0f}));
+*/
+	pod::Transform<T> transform = _transform;
+	pod::Quaternion<T> q = transform.orientation;
+	transform.forward = { 2 * (q.x * q.z + q.w * q.y),  2 * (q.y * q.x - q.w * q.x), 1 - 2 * (q.x * q.x + q.y * q.y) };
+	transform.up = { 2 * (q.x * q.y - q.w * q.z), 1 - 2 * (q.x * q.x + q.z * q.z), 2 * (q.y * q.z + q.w * q.x)};
+	transform.right = { 1 - 2 * (q.y * q.y + q.z * q.z), 2 * (q.x * q.y + q.w * q.z), 2 * (q.x * q.z - q.w * q.y)};
+	return transform;
+}
+template<typename T> pod::Transform<T>& /*UF_API*/ uf::transform::rotate( pod::Transform<T>& transform, const pod::Vector3t<T>& axis, pod::Math::num_t delta ) {
+	pod::Quaternion<> quat = uf::quaternion::axisAngle( axis, delta );
+	
+	transform.orientation = uf::vector::normalize(uf::quaternion::multiply(transform.orientation, quat));
+	transform = uf::transform::reorient(transform);
+
+	return transform;
+}
+template<typename T> pod::Transform<T>& /*UF_API*/ uf::transform::rotate( pod::Transform<T>& transform, const pod::Quaternion<T>& quat ) {		
+	transform.orientation = uf::vector::normalize(uf::quaternion::multiply(transform.orientation, quat));
+	transform = uf::transform::reorient(transform);
+
+	return transform;
+}
+template<typename T> pod::Transform<T>& /*UF_API*/ uf::transform::scale( pod::Transform<T>& transform, const pod::Vector3t<T>& factor ) {
+	transform.scale = factor;
+	return transform;
+}
+template<typename T> inline pod::Transform<T> /*UF_API*/ uf::transform::condense( const pod::Transform<T>& transform ) {
+	return uf::transform::fromMatrix( uf::transform::model( transform, false ) );
+}
+template<typename T> pod::Transform<T> /*UF_API*/ uf::transform::flatten( const pod::Transform<T>& transform, size_t depth ) {
+	if ( !transform.reference ) return transform;
+//	if ( depth == SIZE_MAX ) return uf::transform::condense( transform );
+	pod::Transform<T> combined = transform;
+	combined.reference = NULL;
+	const pod::Transform<T>* pointer = transform.reference;
+	while ( pointer && depth-- > 0 ) {
+		// for some reason I can't just += for the camera
+		combined.position = {
+			combined.position.x + pointer->position.x,
+			combined.position.y + pointer->position.y,
+			combined.position.z + pointer->position.z,
+		};
+		pod::Quaternion<T> orientation = pointer->orientation;
+		combined.orientation = uf::quaternion::multiply( orientation, combined.orientation );
+		combined.scale = {
+			combined.scale.x * pointer->scale.x,
+			combined.scale.y * pointer->scale.y,
+			combined.scale.z * pointer->scale.z,
+		};
+		combined.model = pointer->model * combined.model;
+		pointer = pointer->reference;
+	}
+	return combined = uf::transform::reorient(combined);
+}
+template<typename T> pod::Matrix4t<T> /*UF_API*/ uf::transform::model( const pod::Transform<T>& transform, bool flatten, size_t depth ) {
+	if ( flatten ) {
+		pod::Transform<T> flatten = uf::transform::flatten(transform, depth);
+		return uf::matrix::translate( uf::matrix::identity(), flatten.position ) *
+			uf::quaternion::matrix( flatten.orientation ) *
+			uf::matrix::scale( uf::matrix::identity(), flatten.scale ) *
+			flatten.model;
+	}
+
+	pod::Matrix4t<T> matrix = uf::matrix::identity();
+	const pod::Transform<T>* pointer = &transform;
+	do {
+		pod::Matrix4t<T> model = uf::matrix::translate( uf::matrix::identity(), pointer->position ) *
+			uf::quaternion::matrix( pointer->orientation ) *
+			uf::matrix::scale( uf::matrix::identity(), pointer->scale ) *
+			pointer->model;
+		matrix = model * matrix;
+		pointer = pointer->reference;
+	} while ( pointer && --depth >= 0 );
+	return matrix;
+}
+template<typename T> pod::Transform<T> uf::transform::fromMatrix( const pod::Matrix4t<T>& matrix ) {
+	pod::Transform<T> transform;
+	transform.position = uf::matrix::multiply<float>( matrix, pod::Vector4f{ 0, 0, 0, 1 } );
+	transform.orientation = uf::quaternion::fromMatrix( matrix );
+	transform.model = matrix;
+	return transform = reorient( transform );
+}
+
+template<typename T> pod::Transform<T>& /*UF_API*/ uf::transform::reference( pod::Transform<T>& transform, const pod::Transform<T>& parent, bool reorient ) {
+	if ( !reorient ) {
+		transform.reference = const_cast<pod::Transform<T>*>(&parent);
+		return transform;
+	}
+
+	transform.position = parent.position - transform.position;
+	// reorient orientation here too
+	transform.reference = const_cast<pod::Transform<T>*>(&parent);
+	return transform;
+}
+
+template<typename T> 														// Normalizes a vector
+std::string /*UF_API*/ uf::transform::toString( const pod::Transform<T>& t, bool flatten ) {
+	pod::Transform<T> transform = flatten ? uf::transform::flatten(t) : t;
+	std::stringstream ss;
+	ss << "Transform(" << uf::string::toString(transform.position) << "; " << uf::string::toString(transform.orientation) << ")";
+	return ss.str();
+}
+
+template<typename T>
+ext::json::Value /*UF_API*/ uf::transform::encode( const pod::Transform<T>& t, bool flatten, bool compress ) {
+	pod::Transform<T> transform = flatten ? uf::transform::flatten(t) : t;
+	ext::json::Value json;
+	json["position"] = uf::vector::encode(transform.position, compress);
+	json["orientation"] = uf::vector::encode(transform.orientation, compress);
+	json["scale"] = uf::vector::encode(transform.scale, compress);
+	json["model"] = uf::matrix::encode(transform.model, compress);
+	return json;
+}
+template<typename T>
+pod::Transform<T>& /*UF_API*/ uf::transform::decode( const ext::json::Value& _json, pod::Transform<T>& transform ) {
+	ext::json::Value json = _json;
+//	transform.position = uf::vector::decode<T, 3>(json["position"], transform.position);
+//	transform.scale = uf::vector::decode<T, 3>(json["scale"], transform.scale);
+//	transform.orientation = uf::vector::decode<T, 4>(json["orientation"], transform.orientation);
+	if ( ext::json::isArray(json["position"]) || ext::json::isObject(json["position"]) ) transform.position = uf::vector::decode<T, 3>(json["position"], transform.position);
+	if ( ext::json::isArray(json["scale"]) || ext::json::isObject(json["scale"]) ) transform.scale = uf::vector::decode<T, 3>(json["scale"], transform.scale);
+	if ( ext::json::isArray(json["orientation"]) || ext::json::isObject(json["orientation"]) ) transform.orientation = uf::vector::decode<T, 4>(json["orientation"], transform.orientation);
+	if ( ext::json::isObject(json["rotation"]) && !ext::json::isNull(json["rotation"]["axis"]) && !ext::json::isNull(json["rotation"]["angle"]) ) {
+		pod::Vector3t<T> axis = uf::vector::decode<T, 3>(json["rotation"]["axis"]);
+		T angle = json["rotation"]["angle"].as<T>();
+		transform.orientation = uf::quaternion::axisAngle( axis, angle );
+	}
+	if ( ext::json::isArray(json["model"]) ) transform.model = uf::matrix::decode<T, 4, 4>(json["model"]);
+	return transform;
+}
+template<typename T>
+pod::Transform<T> /*UF_API*/ uf::transform::decode( const ext::json::Value& _json, const pod::Transform<T>& t ) {
+	ext::json::Value json = _json;
+	pod::Transform<T> transform = t;
+//	transform.position = uf::vector::decode<T, 3>(json["position"], transform.position);
+//	transform.scale = uf::vector::decode<T, 3>(json["scale"], transform.scale);
+//	transform.orientation = uf::vector::decode<T, 4>(json["orientation"], transform.orientation);
+	if ( ext::json::isArray(json["position"]) || ext::json::isObject(json["position"]) ) transform.position = uf::vector::decode<T, 3>(json["position"], transform.position);
+	if ( ext::json::isArray(json["scale"]) || ext::json::isObject(json["scale"]) ) transform.scale = uf::vector::decode<T, 3>(json["scale"], transform.scale);
+	if ( ext::json::isArray(json["orientation"]) || ext::json::isObject(json["orientation"]) ) transform.orientation = uf::vector::decode<T, 4>(json["orientation"], transform.orientation);
+	if ( ext::json::isObject(json["rotation"]) && !ext::json::isNull(json["rotation"]["axis"]) && !ext::json::isNull(json["rotation"]["angle"]) ) {
+		pod::Vector3t<T> axis = uf::vector::decode<T, 3>(json["rotation"]["axis"]);
+		T angle = json["rotation"]["angle"].as<T>();
+		transform.orientation = uf::quaternion::axisAngle( axis, angle );
+	}
+	if ( ext::json::isArray(json["model"]) ) transform.model = uf::matrix::decode<T, 4, 4>(json["model"]);
+	return transform;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/math/vector.h b/engine/inc/uf/utils/math/vector.h
new file mode 100644
index 00000000..b7813398
--- /dev/null
+++ b/engine/inc/uf/utils/math/vector.h
@@ -0,0 +1,490 @@
+#pragma once
+
+#include <uf/config.h>
+
+#include "math.h"
+
+#include <sstream>
+#include <vector>
+#include <cmath>
+#include <cstring>
+#include <stdint.h>
+
+#include <uf/ext/json/json.h>
+#include <uf/utils/math/angle.h>
+
+namespace pod {
+	// Simple vectors (designed [to store in arrays] with minimal headaches)
+	template<typename T = pod::Math::num_t, std::size_t N = 3>
+	struct /*UF_API*/ Vector {
+	// 	n-dimensional/unspecialized vector access
+		T components[N];
+	// 	POD information
+		typedef T type_t;
+		typedef T* container_t;
+		static const std::size_t size = N;
+	// 	Overload access
+		// Accessing via subscripts
+		T& operator[](std::size_t i);
+		const T& operator[](std::size_t i) const;
+		// Arithmetic
+		Vector<T,N> operator()() const; 								// 	Negation
+		Vector<T,N> operator-() const; 								// 	Negation
+		Vector<T,N> operator+( const Vector<T,N>& vector ) const; 	// 	Addition between two vectors
+		Vector<T,N> operator-( const Vector<T,N>& vector ) const; 	// 	Subtraction between two vectors
+		Vector<T,N> operator*( const Vector<T,N>& vector ) const; 	// 	Multiplication between two vectors
+		Vector<T,N> operator/( const Vector<T,N>& vector ) const; 	// 	Division between two vectors
+		Vector<T,N> operator*( T scalar ) const; 					// 	Multiplication with scalar
+		Vector<T,N> operator/( T scalar ) const; 					// 	Division with scalar
+		Vector<T,N>& operator +=( const Vector<T,N>& vector ); 		// 	Addition set between two vectors
+		Vector<T,N>& operator -=( const Vector<T,N>& vector ); 		// 	Subtraction set between two vectors
+		Vector<T,N>& operator *=( const Vector<T,N>& vector ); 		// 	Multiplication set between two vectors
+		Vector<T,N>& operator /=( const Vector<T,N>& vector ); 		// 	Division set between two vectors
+		Vector<T,N>& operator *=( T scalar ); 						// 	Multiplication set with scalar
+		Vector<T,N>& operator /=( T scalar ); 						// 	Division set with scalar
+		bool operator==( const Vector<T,N>& vector ) const; 		// 	Equality check between two vectors (equals)
+		bool operator!=( const Vector<T,N>& vector ) const; 		// 	Equality check between two vectors (not equals)
+		bool operator<( const Vector<T,N>& vector ) const; 			// 	Equality check between two vectors (less than)
+		bool operator<=( const Vector<T,N>& vector ) const; 		// 	Equality check between two vectors (less than or equals)
+		bool operator>( const Vector<T,N>& vector ) const; 			// 	Equality check between two vectors (greater than)
+		bool operator>=( const Vector<T,N>& vector ) const; 		// 	Equality check between two vectors (greater than or equals)
+
+		template<typename U, size_t M> Vector<T,N>& operator=( const Vector<U,M>& vector );
+		template<typename U, size_t M> operator Vector<U,M>();
+		inline operator bool() const;
+	};
+	template<typename T = float> using Vector1t = Vector<T,1>;
+	typedef Vector1t<pod::Math::num_t> Vector1;
+	typedef Vector1t<int32_t> Vector1i;
+	typedef Vector1t<uint32_t> Vector1ui;
+
+	typedef Vector1t<long> Vector1l;
+	typedef Vector1t<float> Vector1f;
+	typedef Vector1t<double> Vector1d;
+
+	template<typename T = float> using Vector2t = Vector<T,2>;
+	typedef Vector2t<pod::Math::num_t> Vector2;
+	typedef Vector2t<int32_t> Vector2i;
+	typedef Vector2t<uint32_t> Vector2ui;
+
+	typedef Vector2t<long> Vector2l;
+	typedef Vector2t<float> Vector2f;
+	typedef Vector2t<double> Vector2d;
+
+	template<typename T = float> using Vector3t = Vector<T,3>;
+	typedef Vector3t<pod::Math::num_t> Vector3;
+	typedef Vector3t<int32_t> Vector3i;
+	typedef Vector3t<uint32_t> Vector3ui;
+	typedef Vector3t<uint8_t> ColorRGB;
+
+	typedef Vector3t<long> Vector3l;
+	typedef Vector3t<float> Vector3f;
+	typedef Vector3t<double> Vector3d;
+
+	template<typename T = float> using Vector4t = Vector<T,4>;
+	typedef Vector4t<pod::Math::num_t> Vector4;
+	typedef Vector4t<int32_t> Vector4i;
+	typedef Vector4t<uint32_t> Vector4ui;
+	typedef Vector4t<uint8_t> ColorRgba;
+
+	typedef Vector4t<long> Vector4l;
+	typedef Vector4t<float> Vector4f;
+	typedef Vector4t<double> Vector4d;
+}
+
+// 	POD vector accessing/manipulation
+namespace uf {
+	namespace vector {
+		template<typename T> pod::Vector1t<T> /*UF_API*/ create( T x );
+		template<typename T> pod::Vector2t<T> /*UF_API*/ create( T x, T y );
+		template<typename T> pod::Vector3t<T> /*UF_API*/ create( T x, T y, T z );
+		template<typename T> pod::Vector4t<T> /*UF_API*/ create( T x, T y, T z, T w );
+		template<typename T, size_t N> pod::Vector<T, N> /*UF_API*/ copy( const pod::Vector<T, N>& = {});
+		template<typename T, size_t N, typename U> pod::Vector<T, N> /*UF_API*/ cast( const U& from );
+	// 	Equality checking
+		template<typename T> int /*UF_API*/ compareTo( const T& left, const T& right ); 					// 	Equality check between two vectors (less than)
+		template<typename T> bool /*UF_API*/ equals( const T& left, const T& right ); 						// 	Equality check between two vectors (equals)
+	// 	Basic arithmetic
+		template<typename T> T /*UF_API*/ add( const T& left, const T& right );								// 	Adds two vectors of same type and size together
+		template<typename T> T /*UF_API*/ subtract( const T& left, const T& right );						// 	Subtracts two vectors of same type and size together
+		template<typename T> T /*UF_API*/ multiply( const T& left, const T& right );						// 	Multiplies two vectors of same type and size together
+		template<typename T> T /*UF_API*/ multiply( const T& vector, const typename T::type_t& scalar );	// 	Multiplies this vector by a scalar
+		template<typename T> T /*UF_API*/ divide( const T& left, const T& right );							// 	Divides two vectors of same type and size together
+		template<typename T> T /*UF_API*/ divide( const T& left, const typename T::type_t& scalar );		// 	Divides this vector by a scalar
+		template<typename T> typename T::type_t /*UF_API*/ sum( const T& vector );							// 	Compute the sum of all components 
+		template<typename T> typename T::type_t /*UF_API*/ product( const T& vector );						// 	Compute the product of all components 
+		template<typename T> T /*UF_API*/ negate( const T& vector );										// 	Flip sign of all components
+	// 	Writes to first value
+		template<typename T> T& /*UF_API*/ add( T& left, const T& right );									// 	Adds two vectors of same type and size together
+		template<typename T> T& /*UF_API*/ subtract( T& left, const T& right );								// 	Subtracts two vectors of same type and size together
+		template<typename T> T& /*UF_API*/ multiply( T& left, const T& right );								// 	Multiplies two vectors of same type and size together
+		template<typename T> T& /*UF_API*/ multiply( T& vector, const typename T::type_t& scalar );			// 	Multiplies this vector by a scalar
+		template<typename T> T& /*UF_API*/ divide( T& left, const T& right );								// 	Divides two vectors of same type and size together
+		template<typename T> T& /*UF_API*/ divide( T& left, const typename T::type_t& scalar );				// 	Divides this vector by a scalar
+		template<typename T> T& /*UF_API*/ negate( T& vector );												// 	Flip sign of all components
+		template<typename T> T& /*UF_API*/ normalize( T& vector ); 											// 	Normalizes a vector
+	// 	Complex arithmetic
+		template<typename T> typename T::type_t /*UF_API*/ dot( const T& left, const T& right ); 			// 	Compute the dot product between two vectors
+		template<typename T> pod::Angle /*UF_API*/ angle( const T& a, const T& b ); 						// 	Compute the angle between two vectors
+		template<typename T> T /*UF_API*/ cross( const T& a, const T& b ); 									// 	Compute the angle between two vectors
+		
+		template<typename T> T /*UF_API*/ lerp( const T& from, const T& to, double, bool = true  ); 		// 	Linearly interpolate between two vectors
+		template<typename T> T /*UF_API*/ lerp( const T& from, const T& to, const T&, bool = true  ); 		// 	Linearly interpolate between two vectors
+
+		template<typename T> T /*UF_API*/ slerp( const T& from, const T& to, double, bool = false); 		// 	Spherically interpolate between two vectors
+		template<typename T> T /*UF_API*/ mix( const T& from, const T& to, double, bool = false ); 			// 	
+		
+		template<typename T> typename T::type_t /*UF_API*/ distanceSquared( const T& a, const T& b ); 		// 	Compute the distance between two vectors (doesn't sqrt)
+		template<typename T> typename T::type_t /*UF_API*/ distance( const T& a, const T& b ); 				// 	Compute the distance between two vectors
+		template<typename T> typename T::type_t /*UF_API*/ magnitude( const T& vector ); 					// 	Gets the magnitude of the vector
+		template<typename T> typename T::type_t /*UF_API*/ norm( const T& vector ); 						// 	Compute the norm of the vector
+		template<typename T> T /*UF_API*/ normalize( const T& vector ); 									// 	Normalizes a vector
+		template<typename T> void /*UF_API*/ orthonormalize( T& x, T& y ); 									// 	Normalizes a vector
+		template<typename T> T /*UF_API*/ orthonormalize( const T& x, const T& y ); 						// 	Normalizes a vector
+		
+		template<typename T> std::string /*UF_API*/ toString( const T& vector ); 							// 	Parses a vector as a string
+		template<typename T, size_t N> ext::json::Value encode( const pod::Vector<T,N>& v, bool = false ); 				// 	Parses a vector into a JSON value
+		
+		template<typename T, size_t N> pod::Vector<T,N>& decode( const ext::json::Value& v, pod::Vector<T,N>& ); 							// 	Parses a JSON value into a vector
+		template<typename T, size_t N> pod::Vector<T,N> decode( const ext::json::Value& v, const pod::Vector<T,N>& = {} ); 				// 	Parses a JSON value into a vector
+	}
+}
+
+
+namespace uf {
+	// Provides operations for POD vector
+	template<typename T = pod::Math::num_t, std::size_t N = 3> 
+	class /*UF_API*/ Vector {
+	public:
+	// 	Easily access POD's type
+		typedef pod::Vector<T,N> pod_t;
+	// 	Replicate POD information
+		typedef T type_t;
+		typedef T* container_t;
+		static const std::size_t size = N;
+	protected:
+	// 	POD storage
+		Vector<T,N>::pod_t m_pod;
+	public:
+	// 	C-tor
+		Vector(); 																		// initializes POD to 'def'
+		Vector(T def); 																	// initializes POD to 'def'
+		Vector(const Vector<T,N-1>& v, T w);
+		Vector(const Vector<T,N>::pod_t& pod); 											// copies POD altogether
+		Vector(const T components[N]); 													// copies data into POD from 'components' (typed as C array)
+		Vector(const std::vector<T>& components); 										// copies data into POD from 'components' (typed as std::vector<T>)
+	// 	D-tor
+		// Unneccesary
+	// 	POD access
+		Vector<T,N>::pod_t& data(); 													// 	Returns a reference of POD
+		const Vector<T,N>::pod_t& data() const; 										// 	Returns a const-reference of POD
+	// 	Alternative POD access
+		T* get();																		// 	Returns a pointer to the entire array
+		const T* get() const; 															// 	Returns a const-pointer to the entire array
+		T& getComponent( std::size_t i );												// 	Returns a reference to a single element
+		const T& getComponent( std::size_t i ) const; 									// 	Returns a const-reference to a single element
+	// 	POD manipulation
+		T* set(const T components[N]);													// 	Sets the entire array
+		T& setComponent( std::size_t i, const T& value );								// 	Sets a single element
+	// 	Validation
+		bool isValid() const; 															// 	Checks if all components are valid (non NaN, inf, etc.)
+	// 	Basic arithmetic
+		inline uf::Vector<T,N>& add( const Vector<T, N>& vector );						// 	Adds two vectors of same type and size together
+		inline uf::Vector<T,N>& subtract( const Vector<T, N>& vector );					// 	Subtracts two vectors of same type and size together
+		inline uf::Vector<T,N>& multiply( const Vector<T, N>& vector );					// 	Multiplies two vectors of same type and size together
+		inline uf::Vector<T,N>& multiply( T scalar );									// 	Multiplies this vector by a scalar
+		inline uf::Vector<T,N>& divide( const Vector<T, N>& vector );					// 	Divides two vectors of same type and size together
+		inline uf::Vector<T,N>& divide( T scalar );										// 	Divides this vector by a scalar
+		inline T sum() const;															// 	Compute the sum of all components 
+		inline T product() const;														// 	Compute the product of all components 
+		inline uf::Vector<T,N>& negate();												// 	Flip sign of all components
+	// 	Complex arithmetic
+		inline T dot( const Vector<T,N> right ) const; 									// 	Compute the dot product between two vectors
+		inline pod::Angle angle( const Vector<T,N>& b ) const; 							// 	Compute the angle between two vectors
+		
+		inline uf::Vector<T,N> lerp( const Vector<T,N> to, double delta ) const; 		// 	Linearly interpolate between two vectors
+		inline uf::Vector<T,N> slerp( const Vector<T,N> to, double delta ) const; 		// 	Spherically interpolate between two vectors
+		
+		inline T distanceSquared( const Vector<T,N> b ) const; 							// 	Compute the distance between two vectors (doesn't sqrt)
+		inline T distance( const Vector<T,N> b ) const; 								// 	Compute the distance between two vectors
+		inline T magnitude() const; 													// 	Gets the magnitude of the vector
+		inline T norm() const; 															// 	Compute the norm of the vector
+		
+		inline uf::Vector<T,N>& normalize(); 											// 	Normalizes a vector
+		uf::Vector<T,N> getNormalized() const; 											// 	Return a normalized vector
+		inline std::string toString() const;
+	// 	Overloaded ops
+		// Accessing via subscripts
+		T& operator[](std::size_t i);
+		const T& operator[](std::size_t i) const;
+		// Arithmetic
+		inline Vector<T,N> operator-() const; 								// 	Negation
+		inline Vector<T,N> operator+( const Vector<T,N>& vector ) const; 	// 	Addition between two vectors
+		inline Vector<T,N> operator-( const Vector<T,N>& vector ) const; 	// 	Subtraction between two vectors
+		inline Vector<T,N> operator*( const Vector<T,N>& vector ) const; 	// 	Multiplication between two vectors
+		inline Vector<T,N> operator/( const Vector<T,N>& vector ) const; 	// 	Division between two vectors
+		inline Vector<T,N> operator*( T scalar ) const; 					// 	Multiplication with scalar
+		inline Vector<T,N> operator/( T scalar ) const; 					// 	Division with scalar
+		inline Vector<T,N>& operator +=( const Vector<T,N>& vector ); 		// 	Addition set between two vectors
+		inline Vector<T,N>& operator -=( const Vector<T,N>& vector ); 		// 	Subtraction set between two vectors
+		inline Vector<T,N>& operator *=( const Vector<T,N>& vector ); 		// 	Multiplication set between two vectors
+		inline Vector<T,N>& operator /=( const Vector<T,N>& vector ); 		// 	Division set between two vectors
+		inline Vector<T,N>& operator *=( T scalar ); 						// 	Multiplication set with scalar
+		inline Vector<T,N>& operator /=( T scalar ); 						// 	Division set with scalar
+		inline bool operator==( const Vector<T,N>& vector ) const; 			// 	Equality check between two vectors (equals)
+		inline bool operator!=( const Vector<T,N>& vector ) const; 			// 	Equality check between two vectors (not equals)
+		inline bool operator<( const Vector<T,N>& vector ) const; 			// 	Equality check between two vectors (less than)
+		inline bool operator<=( const Vector<T,N>& vector ) const; 			// 	Equality check between two vectors (less than or equals)
+		inline bool operator>( const Vector<T,N>& vector ) const; 			// 	Equality check between two vectors (greater than)
+		inline bool operator>=( const Vector<T,N>& vector ) const; 			// 	Equality check between two vectors (greater than or equals)
+		
+		inline operator pod_t&() { return this->m_pod; }
+		inline operator const pod_t&() const { return this->m_pod; }
+	};
+	template<typename T = float> using Vector1t = Vector<T,1>;
+	typedef Vector1t<pod::Math::num_t> Vector1;
+	typedef Vector1t<int32_t> Vector1i;
+	typedef Vector1t<uint32_t> Vector1ui;
+
+	typedef Vector1t<long> Vector1l;
+	typedef Vector1t<float> Vector1f;
+	typedef Vector1t<double> Vector1d;
+	
+	template<typename T = float> using Vector2t = Vector<T,2>;
+	typedef Vector2t<pod::Math::num_t> Vector2;
+	typedef Vector2t<int32_t> Vector2i;
+	typedef Vector2t<uint32_t> Vector2ui;
+
+	typedef Vector2t<long> Vector2l;
+	typedef Vector2t<float> Vector2f;
+	typedef Vector2t<double> Vector2d;
+
+	template<typename T = float> using Vector3t = Vector<T,3>;
+	typedef Vector3t<pod::Math::num_t> Vector3;
+	typedef Vector3t<int32_t> Vector3i;
+	typedef Vector3t<uint32_t> Vector3ui;
+	typedef Vector3t<uint8_t> ColorRGB;
+
+	typedef Vector3t<long> Vector3l;
+	typedef Vector3t<float> Vector3f;
+	typedef Vector3t<double> Vector3d;
+
+	template<typename T = float> using Vector4t = Vector<T,4>;
+	typedef Vector4t<pod::Math::num_t> Vector4;
+	typedef Vector4t<int32_t> Vector4i;
+	typedef Vector4t<uint32_t> Vector4ui;
+	typedef Vector4t<uint8_t> ColorRgba;
+
+	typedef Vector4t<long> Vector4l;
+	typedef Vector4t<float> Vector4f;
+	typedef Vector4t<double> Vector4d;
+}
+
+//#include <uf/utils/string/ext.h>
+#include <sstream>
+namespace uf {
+	namespace string {
+		template<typename T, size_t N>
+		std::string toString( const pod::Vector<T,N>& v );
+	}
+}
+namespace ext {
+	namespace json {
+		template<typename T, size_t N> ext::json::Value encode( const pod::Vector<T,N>& v );
+		template<typename T, size_t N> pod::Vector<T,N>& decode( const ext::json::Value&, pod::Vector<T,N>& );
+		template<typename T, size_t N> pod::Vector<T,N> decode( const ext::json::Value&, const pod::Vector<T,N>& = {} );
+	}
+}
+
+namespace pod {
+	template<typename T>
+	struct /*UF_API*/ Vector<T,1> {			
+	// 	XY access
+		T x;
+	// 	n-dimensional/unspecialized vector access
+	//	T* components = (T*) this;
+	// 	POD information
+		typedef T type_t;
+		typedef T* container_t;
+		static const std::size_t size = 1;
+	// 	Overload access
+		// Accessing via subscripts
+		T& operator[](std::size_t i);
+		const T& operator[](std::size_t i) const;
+		// Arithmetic
+		inline Vector<T,1> operator()() const; 								// 	Creation
+		inline Vector<T,1> operator-() const; 								// 	Negation
+		inline Vector<T,1> operator+( const Vector<T,1>& vector ) const; 	// 	Addition between two vectors
+		inline Vector<T,1> operator-( const Vector<T,1>& vector ) const; 	// 	Subtraction between two vectors
+		inline Vector<T,1> operator*( const Vector<T,1>& vector ) const; 	// 	Multiplication between two vectors
+		inline Vector<T,1> operator/( const Vector<T,1>& vector ) const; 	// 	Division between two vectors
+		inline Vector<T,1> operator*( T scalar ) const; 					// 	Multiplication with scalar
+		inline Vector<T,1> operator/( T scalar ) const; 					// 	Division with scalar
+		inline Vector<T,1>& operator +=( const Vector<T,1>& vector ); 		// 	Addition set between two vectors
+		inline Vector<T,1>& operator -=( const Vector<T,1>& vector ); 		// 	Subtraction set between two vectors
+		inline Vector<T,1>& operator *=( const Vector<T,1>& vector ); 		// 	Multiplication set between two vectors
+		inline Vector<T,1>& operator /=( const Vector<T,1>& vector ); 		// 	Division set between two vectors
+		inline Vector<T,1>& operator *=( T scalar ); 						// 	Multiplication set with scalar
+		inline Vector<T,1>& operator /=( T scalar ); 						// 	Division set with scalar
+		inline bool operator==( const Vector<T,1>& vector ) const; 			// 	Equality check between two vectors (equals)
+		inline bool operator!=( const Vector<T,1>& vector ) const; 			// 	Equality check between two vectors (not equals)
+		inline bool operator<( const Vector<T,1>& vector ) const; 			// 	Equality check between two vectors (less than)
+		inline bool operator<=( const Vector<T,1>& vector ) const; 			// 	Equality check between two vectors (less than or equals)
+		inline bool operator>( const Vector<T,1>& vector ) const; 			// 	Equality check between two vectors (greater than)
+		inline bool operator>=( const Vector<T,1>& vector ) const; 			// 	Equality check between two vectors (greater than or equals)
+		template<typename U, size_t M> Vector<T,1>& operator=( const Vector<U,M>& vector );
+		template<typename U, size_t M> operator Vector<U,M>();
+		inline operator bool() const;
+	#if 0
+	#if UF_USE_SIMD
+		Vector<T,1>& operator=( const __m128 );
+		operator __m128() const;
+	#endif
+	#endif
+	};
+	template<typename T>
+	struct /*UF_API*/ Vector<T,2> {			
+	// 	XY access
+		T x;
+		T y;
+	// 	n-dimensional/unspecialized vector access
+	//	T* components = (T*) this;
+	// 	POD information
+		typedef T type_t;
+		typedef T* container_t;
+		static const std::size_t size = 2;
+	// 	Overload access
+		// Accessing via subscripts
+		T& operator[](std::size_t i);
+		const T& operator[](std::size_t i) const;
+		// Arithmetic
+		inline Vector<T,2> operator()() const; 								// 	Creation
+		inline Vector<T,2> operator-() const; 								// 	Negation
+		inline Vector<T,2> operator+( const Vector<T,2>& vector ) const; 	// 	Addition between two vectors
+		inline Vector<T,2> operator-( const Vector<T,2>& vector ) const; 	// 	Subtraction between two vectors
+		inline Vector<T,2> operator*( const Vector<T,2>& vector ) const; 	// 	Multiplication between two vectors
+		inline Vector<T,2> operator/( const Vector<T,2>& vector ) const; 	// 	Division between two vectors
+		inline Vector<T,2> operator*( T scalar ) const; 					// 	Multiplication with scalar
+		inline Vector<T,2> operator/( T scalar ) const; 					// 	Division with scalar
+		inline Vector<T,2>& operator +=( const Vector<T,2>& vector ); 		// 	Addition set between two vectors
+		inline Vector<T,2>& operator -=( const Vector<T,2>& vector ); 		// 	Subtraction set between two vectors
+		inline Vector<T,2>& operator *=( const Vector<T,2>& vector ); 		// 	Multiplication set between two vectors
+		inline Vector<T,2>& operator /=( const Vector<T,2>& vector ); 		// 	Division set between two vectors
+		inline Vector<T,2>& operator *=( T scalar ); 						// 	Multiplication set with scalar
+		inline Vector<T,2>& operator /=( T scalar ); 						// 	Division set with scalar
+		inline bool operator==( const Vector<T,2>& vector ) const; 			// 	Equality check between two vectors (equals)
+		inline bool operator!=( const Vector<T,2>& vector ) const; 			// 	Equality check between two vectors (not equals)
+		inline bool operator<( const Vector<T,2>& vector ) const; 			// 	Equality check between two vectors (less than)
+		inline bool operator<=( const Vector<T,2>& vector ) const; 			// 	Equality check between two vectors (less than or equals)
+		inline bool operator>( const Vector<T,2>& vector ) const; 			// 	Equality check between two vectors (greater than)
+		inline bool operator>=( const Vector<T,2>& vector ) const; 			// 	Equality check between two vectors (greater than or equals)
+		template<typename U, size_t M> Vector<T,2>& operator=( const Vector<U,M>& vector );
+		template<typename U, size_t M> operator Vector<U,M>();
+		inline operator bool() const;
+	#if 0
+	#if UF_USE_SIMD
+		Vector<T,2>& operator=( const __m128 );
+		operator __m128() const;
+	#endif
+	#endif
+	};
+	template<typename T>
+	struct /*UF_API*/ Vector<T,3> {
+	// 	XYZ access
+		T x;
+		T y;
+		T z;
+	// 	n-dimensional/unspecialized vector access
+	//	T* components = (T*) this;
+	// 	POD information
+		typedef T type_t;
+		typedef T* container_t;
+		static const std::size_t size = 3;
+	// 	Overload access
+		// Accessing via subscripts
+		T& operator[](std::size_t i);
+		const T& operator[](std::size_t i) const;
+		// Arithmetic
+		inline Vector<T,3> operator()() const; 								// 	Creation
+		inline Vector<T,3> operator-() const; 								// 	Negation
+		inline Vector<T,3> operator+( const Vector<T,3>& vector ) const; 	// 	Addition between two vectors
+		inline Vector<T,3> operator-( const Vector<T,3>& vector ) const; 	// 	Subtraction between two vectors
+		inline Vector<T,3> operator*( const Vector<T,3>& vector ) const; 	// 	Multiplication between two vectors
+		inline Vector<T,3> operator/( const Vector<T,3>& vector ) const; 	// 	Division between two vectors
+		inline Vector<T,3> operator*( T scalar ) const; 					// 	Multiplication with scalar
+		inline Vector<T,3> operator/( T scalar ) const; 					// 	Division with scalar
+		inline Vector<T,3>& operator +=( const Vector<T,3>& vector ); 		// 	Addition set between two vectors
+		inline Vector<T,3>& operator -=( const Vector<T,3>& vector ); 		// 	Subtraction set between two vectors
+		inline Vector<T,3>& operator *=( const Vector<T,3>& vector ); 		// 	Multiplication set between two vectors
+		inline Vector<T,3>& operator /=( const Vector<T,3>& vector ); 		// 	Division set between two vectors
+		inline Vector<T,3>& operator *=( T scalar ); 						// 	Multiplication set with scalar
+		inline Vector<T,3>& operator /=( T scalar ); 						// 	Division set with scalar
+		inline bool operator==( const Vector<T,3>& vector ) const; 			// 	Equality check between two vectors (equals)
+		inline bool operator!=( const Vector<T,3>& vector ) const; 			// 	Equality check between two vectors (not equals)
+		inline bool operator<( const Vector<T,3>& vector ) const; 			// 	Equality check between two vectors (less than)
+		inline bool operator<=( const Vector<T,3>& vector ) const; 			// 	Equality check between two vectors (less than or equals)
+		inline bool operator>( const Vector<T,3>& vector ) const; 			// 	Equality check between two vectors (greater than)
+		inline bool operator>=( const Vector<T,3>& vector ) const; 			// 	Equality check between two vectors (greater than or equals)
+		
+		template<typename U, size_t M> Vector<T,3>& operator=( const Vector<U,M>& vector );
+		template<typename U, size_t M> operator Vector<U,M>();
+		inline operator bool() const;
+	#if 0
+	#if UF_USE_SIMD
+		Vector<T,3>& operator=( const __m128 );
+		operator __m128() const;
+	#endif
+	#endif
+	};
+	template<typename T>
+	struct /*UF_API*/ alignas(16) Vector<T,4> {
+	// 	XYZW access
+		T x;
+		T y;
+		T z;
+		T w;
+	// 	n-dimensional/unspecialized vector access
+	//	T* components = (T*) this;
+	// 	POD information
+		typedef T type_t;
+		typedef T* container_t;
+		static const std::size_t size = 4;
+	// 	Overload access
+		// Accessing via subscripts
+		T& operator[](std::size_t i);
+		const T& operator[](std::size_t i) const;
+		// Arithmetic
+		inline Vector<T,4> operator()() const; 								// 	Creation
+		inline Vector<T,4> operator-() const; 								// 	Negation
+		inline Vector<T,4> operator+( const Vector<T,4>& vector ) const; 	// 	Addition between two vectors
+		inline Vector<T,4> operator-( const Vector<T,4>& vector ) const; 	// 	Subtraction between two vectors
+		inline Vector<T,4> operator*( const Vector<T,4>& vector ) const; 	// 	Multiplication between two vectors
+		inline Vector<T,4> operator/( const Vector<T,4>& vector ) const; 	// 	Division between two vectors
+		inline Vector<T,4> operator*( T scalar ) const; 					// 	Multiplication with scalar
+		inline Vector<T,4> operator/( T scalar ) const; 					// 	Division with scalar
+		inline Vector<T,4>& operator +=( const Vector<T,4>& vector ); 		// 	Addition set between two vectors
+		inline Vector<T,4>& operator -=( const Vector<T,4>& vector ); 		// 	Subtraction set between two vectors
+		inline Vector<T,4>& operator *=( const Vector<T,4>& vector ); 		// 	Multiplication set between two vectors
+		inline Vector<T,4>& operator /=( const Vector<T,4>& vector ); 		// 	Division set between two vectors
+		inline Vector<T,4>& operator *=( T scalar ); 						// 	Multiplication set with scalar
+		inline Vector<T,4>& operator /=( T scalar ); 						// 	Division set with scalar
+		inline bool operator==( const Vector<T,4>& vector ) const; 			// 	Equality check between two vectors (equals)
+		inline bool operator!=( const Vector<T,4>& vector ) const; 			// 	Equality check between two vectors (not equals)
+		inline bool operator<( const Vector<T,4>& vector ) const; 			// 	Equality check between two vectors (less than)
+		inline bool operator<=( const Vector<T,4>& vector ) const; 			// 	Equality check between two vectors (less than or equals)
+		inline bool operator>( const Vector<T,4>& vector ) const; 			// 	Equality check between two vectors (greater than)
+		inline bool operator>=( const Vector<T,4>& vector ) const; 			// 	Equality check between two vectors (greater than or equals)
+		
+		template<typename U, size_t M> Vector<T,4>& operator=( const Vector<U,M>& vector );
+		template<typename U, size_t M> operator Vector<U,M>();
+		inline operator bool() const;
+	#if 0
+	#if UF_USE_SIMD
+		Vector<T,4>& operator=( const __m128 );
+		operator __m128() const;
+	#endif
+	#endif
+	};
+}
+
+#include "vector/vector.inl"
\ No newline at end of file
diff --git a/engine/inc/uf/utils/math/vector/class.inl b/engine/inc/uf/utils/math/vector/class.inl
new file mode 100644
index 00000000..d13e1155
--- /dev/null
+++ b/engine/inc/uf/utils/math/vector/class.inl
@@ -0,0 +1,233 @@
+// 	C-tor
+template<typename T, std::size_t N> 											// initializes POD to 'def'
+uf::Vector<T,N>::Vector() {
+}
+template<typename T, std::size_t N> 											// initializes POD to 'def'
+uf::Vector<T,N>::Vector(T def) {
+	for ( std::size_t i = 0; i < N; ++i ) this->m_pod[i] = def;
+}
+template<typename T, std::size_t N> 											// copies POD altogether
+uf::Vector<T,N>::Vector(const typename uf::Vector<T,N>::pod_t& pod) : m_pod(pod) {
+}
+template<typename T, std::size_t N> 											// copies data into POD from 'components' (typed as C array)
+uf::Vector<T,N>::Vector(const T components[N]) {
+	this->set(&components[0]);
+}
+template<typename T, std::size_t N> 											// copies data into POD from 'components' (typed as std::vector<T>)
+uf::Vector<T,N>::Vector(const std::vector<T>& components) {
+	if ( components.size() >= N ) this->set(&components[0]);
+}
+// 	D-tor
+// Unneccesary
+// 	POD access
+template<typename T, std::size_t N> 											// 	Returns a reference of POD
+typename uf::Vector<T,N>::pod_t& uf::Vector<T,N>::data() {
+	return this->m_pod;
+}
+template<typename T, std::size_t N> 											// 	Returns a const-reference of POD
+const typename uf::Vector<T,N>::pod_t& uf::Vector<T,N>::data() const {
+	return this->m_pod;
+}
+// 	Alternative POD access
+template<typename T, std::size_t N> 											// 	Returns a pointer to the entire array
+T* uf::Vector<T,N>::get() {
+	return &this->m_pod[0];
+}
+template<typename T, std::size_t N> 											// 	Returns a const-pointer to the entire array
+const T* uf::Vector<T,N>::get() const {
+	return &this->m_pod[0];
+}
+template<typename T, std::size_t N> 											// 	Returns a reference to a single element
+T& uf::Vector<T,N>::getComponent( std::size_t i ) {
+	return this->m_pod[i];
+}
+template<typename T, std::size_t N> 											// 	Returns a const-reference to a single element
+const T& uf::Vector<T,N>::getComponent( std::size_t i ) const {
+	return this->m_pod[i];
+}
+// 	POD manipulation
+template<typename T, std::size_t N> 											// 	Sets the entire array
+T* uf::Vector<T,N>::set(const T components[N]) {
+	for ( std::size_t i = 0; i < N; ++i ) this->m_pod[i] = components[i];
+}
+template<typename T, std::size_t N> 											// 	Sets a single element
+T& uf::Vector<T,N>::setComponent( std::size_t i, const T& value ) {
+	this->m_pod[i] = value;
+}
+// 	Validation
+template<typename T, std::size_t N> 											// 	Checks if all components are valid (non NaN, inf, etc.)
+bool uf::Vector<T,N>::isValid() const {
+	for ( std::size_t i = 0; i < N; ++i ) if ( this->m_pod[i] != this->m_pod[i] ) return false;
+	return true;
+}
+// 	Basic arithmetic
+template<typename T, std::size_t N> 											// 	Adds two vectors of same type and size together
+inline uf::Vector<T,N>& uf::Vector<T,N>::add( const Vector<T, N>& vector ) {
+	return uf::vector::add( this->m_pod, vector.data() );
+}
+template<typename T, std::size_t N> 											// 	Subtracts two vectors of same type and size together
+inline uf::Vector<T,N>& uf::Vector<T,N>::subtract( const Vector<T, N>& vector ) {
+	return uf::vector::subtract( this->m_pod, vector.data() );
+}
+template<typename T, std::size_t N> 											// 	Multiplies two vectors of same type and size together
+inline uf::Vector<T,N>& uf::Vector<T,N>::multiply( const Vector<T, N>& vector ) {
+	return uf::vector::multiply( this->m_pod, vector.data() );
+}
+template<typename T, std::size_t N> 											// 	Multiplies this vector by a scalar
+inline uf::Vector<T,N>& uf::Vector<T,N>::multiply( T scalar ) {
+	return uf::vector::multiply( this->m_pod, scalar );
+}
+template<typename T, std::size_t N> 											// 	Divides two vectors of same type and size together
+inline uf::Vector<T,N>& uf::Vector<T,N>::divide( const Vector<T, N>& vector ) {
+	return uf::vector::divide( this->m_pod, vector.data() );
+}
+template<typename T, std::size_t N> 											// 	Divides this vector by a scalar
+inline uf::Vector<T,N>& uf::Vector<T,N>::divide( T scalar ) {
+	return uf::vector::divide( this->m_pod, scalar );
+}
+template<typename T, std::size_t N> 											// 	Compute the sum of all components 
+inline T uf::Vector<T,N>::sum() const {
+	return uf::vector::sum( this->m_pod );
+}
+template<typename T, std::size_t N> 											// 	Compute the product of all components 
+inline T uf::Vector<T,N>::product() const {
+	return uf::vector::product( this->m_pod );
+}
+template<typename T, std::size_t N> 											// 	Flip sign of all components
+inline uf::Vector<T,N>& uf::Vector<T,N>::negate() {
+	return uf::vector::negate( this->m_pod );
+}
+// 	Complex arithmetic
+template<typename T, std::size_t N> 											// 	Compute the dot product between two vectors
+inline T uf::Vector<T,N>::dot( const Vector<T,N> right ) const {
+	return uf::vector::dot( this->m_pod, right );
+}
+template<typename T, std::size_t N> 											// 	Compute the angle between two vectors
+inline pod::Angle uf::Vector<T,N>::angle( const Vector<T,N>& b ) const {
+	return uf::vector::angle( this->m_pod, b );
+}
+
+template<typename T, std::size_t N> 											// 	Linearly interpolate between two vectors
+inline uf::Vector<T,N> uf::Vector<T,N>::lerp( const Vector<T,N> to, double delta ) const {
+	return uf::vector::lerp( this->m_pod, to, delta );
+}
+template<typename T, std::size_t N> 											// 	Spherically interpolate between two vectors
+inline uf::Vector<T,N> uf::Vector<T,N>::slerp( const Vector<T,N> to, double delta ) const {
+	return uf::vector::slerp( this->m_pod, to, delta );
+}
+
+template<typename T, std::size_t N> 											// 	Compute the distance between two vectors (doesn't sqrt)
+inline T uf::Vector<T,N>::distanceSquared( const Vector<T,N> b ) const {
+	return uf::vector::distanceSquared( this->m_pod, b );
+}
+template<typename T, std::size_t N> 											// 	Compute the distance between two vectors
+inline T uf::Vector<T,N>::distance( const Vector<T,N> b ) const {
+	return uf::vector::distance( this->m_pod, b );
+}
+template<typename T, std::size_t N> 											// 	Gets the magnitude of the vector
+inline T uf::Vector<T,N>::magnitude() const {
+	return uf::vector::magnitude( this->m_pod );
+}
+template<typename T, std::size_t N> 											// 	Compute the norm of the vector
+inline T uf::Vector<T,N>::norm() const {
+	return uf::vector::norm( this->m_pod );
+}
+
+template<typename T, std::size_t N> 											// 	Normalizes a vector
+inline uf::Vector<T,N>& uf::Vector<T,N>::normalize() {
+	return uf::vector::normalize( this->m_pod );
+}
+template<typename T, std::size_t N> 											// 	Return a normalized vector
+uf::Vector<T,N> uf::Vector<T,N>::getNormalized() const {
+	return uf::vector::normalize( this->m_pod );
+}
+template<typename T, std::size_t N> 											// 	Return a string
+std::string uf::Vector<T,N>::toString() const {
+	return uf::vector::toString( this->m_pod );
+}
+// Overloaded ops
+template<typename T, std::size_t N> 
+T& uf::Vector<T,N>::operator[](std::size_t i) {
+	return this->m_pod[i];
+}
+template<typename T, std::size_t N> 
+const T& uf::Vector<T,N>::operator[](std::size_t i) const {
+	return this->m_pod[i];
+}
+// Arithmetic
+template<typename T, std::size_t N>  												// 	Negation
+inline uf::Vector<T,N> uf::Vector<T,N>::operator-() const {
+	return uf::vector::negate( this->m_pod );
+}			
+template<typename T, std::size_t N>  												// 	Addition between two vectors
+inline uf::Vector<T,N> uf::Vector<T,N>::operator+( const uf::Vector<T,N>& vector ) const {
+	return uf::vector::add( this->m_pod, vector.data() );
+}
+template<typename T, std::size_t N>  												// 	Subtraction between two vectors
+inline uf::Vector<T,N> uf::Vector<T,N>::operator-( const uf::Vector<T,N>& vector ) const {
+	return uf::vector::subtract( this->m_pod, vector.data() );
+}
+template<typename T, std::size_t N>  												// 	Multiplication between two vectors
+inline uf::Vector<T,N> uf::Vector<T,N>::operator*( const uf::Vector<T,N>& vector ) const {
+	return uf::vector::multiply( this->m_pod, vector.data() );
+}
+template<typename T, std::size_t N>  												// 	Division between two vectors
+inline uf::Vector<T,N> uf::Vector<T,N>::operator/( const uf::Vector<T,N>& vector ) const {
+	return uf::vector::divide( this->m_pod, vector.data() );
+}
+template<typename T, std::size_t N>  												// 	Multiplication with scalar
+inline uf::Vector<T,N> uf::Vector<T,N>::operator*( T scalar ) const {
+	return uf::vector::multiply( this->m_pod, scalar );
+}
+template<typename T, std::size_t N>  												// 	Division with scalar
+inline uf::Vector<T,N> uf::Vector<T,N>::operator/( T scalar ) const {
+	return uf::vector::divide( this->m_pod, scalar );
+}
+template<typename T, std::size_t N>  												// 	Addition set between two vectors
+inline uf::Vector<T,N>& uf::Vector<T,N>::operator +=( const uf::Vector<T,N>& vector ) {
+	return uf::vector::add( this->m_pod, vector.data() );
+}
+template<typename T, std::size_t N>  												// 	Subtraction set between two vectors
+inline uf::Vector<T,N>& uf::Vector<T,N>::operator -=( const uf::Vector<T,N>& vector ) {
+	return uf::vector::subtract( this->m_pod, vector.data() );
+}
+template<typename T, std::size_t N>  												// 	Multiplication set between two vectors
+inline uf::Vector<T,N>& uf::Vector<T,N>::operator *=( const uf::Vector<T,N>& vector ) {
+	return uf::vector::multiply( this->m_pod, vector.data() );
+}
+template<typename T, std::size_t N>  												// 	Division set between two vectors
+inline uf::Vector<T,N>& uf::Vector<T,N>::operator /=( const uf::Vector<T,N>& vector ) {
+	return uf::vector::divide( this->m_pod, vector.data() );
+}
+template<typename T, std::size_t N>  												// 	Multiplication set with scalar
+inline uf::Vector<T,N>& uf::Vector<T,N>::operator *=( T scalar ) {
+	return uf::vector::multiply( this->m_pod, scalar );
+}
+template<typename T, std::size_t N>  												// 	Division set with scalar
+inline uf::Vector<T,N>& uf::Vector<T,N>::operator /=( T scalar ) {
+	return uf::vector::divide( this->m_pod, scalar );
+}
+template<typename T, std::size_t N>  												// 	Equality check between two vectors (equals)
+inline bool uf::Vector<T,N>::operator==( const uf::Vector<T,N>& vector ) const {
+	return uf::vector::equals(this->m_pod, vector.data() );
+}
+template<typename T, std::size_t N>  												// 	Equality check between two vectors (not equals)
+inline bool uf::Vector<T,N>::operator!=( const uf::Vector<T,N>& vector ) const {
+	return !uf::vector::equals(this->m_pod, vector.data() );
+}
+template<typename T, std::size_t N>  												// 	Equality check between two vectors (less than)
+inline bool uf::Vector<T,N>::operator<( const uf::Vector<T,N>& vector ) const {
+	return uf::vector::compareTo(this->m_pod, vector.data() ) < 0;
+}
+template<typename T, std::size_t N>  												// 	Equality check between two vectors (less than or equals)
+inline bool uf::Vector<T,N>::operator<=( const uf::Vector<T,N>& vector ) const {
+	return uf::vector::compareTo(this->m_pod, vector.data() ) <= 0;
+}
+template<typename T, std::size_t N>  												// 	Equality check between two vectors (greater than)
+inline bool uf::Vector<T,N>::operator>( const uf::Vector<T,N>& vector ) const {
+	return uf::vector::compareTo(this->m_pod, vector.data() ) > 0;
+}
+template<typename T, std::size_t N>  												// 	Equality check between two vectors (greater than or equals)
+inline bool uf::Vector<T,N>::operator>=( const uf::Vector<T,N>& vector ) const {
+	return uf::vector::compareTo(this->m_pod, vector.data() ) >= 0;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/math/vector/pod.inl b/engine/inc/uf/utils/math/vector/pod.inl
new file mode 100644
index 00000000..300f0ca7
--- /dev/null
+++ b/engine/inc/uf/utils/math/vector/pod.inl
@@ -0,0 +1,336 @@
+#if UF_USE_SIMD
+	#include "simd.h"
+#endif
+#include "redundancy.inl"
+// 	Equality checking
+template<typename T>
+pod::Vector1t<T> /*UF_API*/ uf::vector::create( T x ) { pod::Vector1t<T> vec; vec.x = x; return vec; }
+template<typename T>
+pod::Vector2t<T> /*UF_API*/ uf::vector::create( T x, T y ) { pod::Vector2t<T> vec; vec.x = x, vec.y = y; return vec; }
+template<typename T>
+pod::Vector3t<T> /*UF_API*/ uf::vector::create( T x, T y, T z ) { pod::Vector3t<T> vec; vec.x = x, vec.y = y, vec.z = z; return vec; }
+template<typename T>
+pod::Vector4t<T> /*UF_API*/ uf::vector::create( T x, T y, T z, T w ) { pod::Vector4t<T> vec; vec.x = x, vec.y = y, vec.z = z, vec.w = w; return vec; }
+template<typename T, size_t N>
+pod::Vector<T, N> /*UF_API*/ uf::vector::copy( const pod::Vector<T, N>& v ) { return v; }
+template<typename T, size_t N, typename U>
+pod::Vector<T, N> /*UF_API*/ uf::vector::cast( const U& from ) {
+	pod::Vector<T, N> to;
+	for ( size_t i = 0; i < N && i < U::size; ++i ) to[i] = from[i];
+	return to;
+}
+// 	Equality checking
+template<typename T> 														// 	Equality check between two vectors (less than)
+int /*UF_API*/ uf::vector::compareTo( const T& left, const T& right ) {
+	return memcmp( &left, &right, T::size );
+}
+template<typename T> 														// 	Equality check between two vectors (equals)
+bool /*UF_API*/ uf::vector::equals( const T& left, const T& right ) {
+//	return uf::vector::compareTo(left, right) == 0;
+	for ( std::size_t i = 0; i < T::size; ++i ) if ( left[i] != right[i] ) return false;
+	return true;
+}
+// Basic arithmetic
+template<typename T> 														// Adds two vectors of same type and size together
+T /*UF_API*/ uf::vector::add( const T& left, const T& right ) {
+#if UF_USE_SIMD
+	return uf::simd::add( left, right );
+#endif
+	T res;
+	for ( std::size_t i = 0; i < T::size; ++i ) res[i] = left[i] + right[i];
+	return res;
+}
+template<typename T> 														// Subtracts two vectors of same type and size together
+T /*UF_API*/ uf::vector::subtract( const T& left, const T& right ) {
+#if UF_USE_SIMD
+	return uf::simd::sub( left, right );
+#endif
+	T res;
+	for ( std::size_t i = 0; i < T::size; ++i ) res[i] = left[i] - right[i];
+	return res;
+}
+template<typename T> 														// Multiplies two vectors of same type and size together
+T /*UF_API*/ uf::vector::multiply( const T& left, const T& right ) {
+#if UF_USE_SIMD
+	return uf::simd::mul( left, right );
+#endif
+	T res;
+	for ( std::size_t i = 0; i < T::size; ++i ) res[i] = left[i] * right[i];
+	return res;
+}
+template<typename T> 														// Multiplies this vector by a scalar
+T /*UF_API*/ uf::vector::multiply( const T& vector, const typename T::type_t& scalar ) {
+#if UF_USE_SIMD
+	return uf::simd::mul( vector, scalar );
+#endif
+	T res;
+	for ( std::size_t i = 0; i < T::size; ++i ) res[i] = vector[i] * scalar;
+	return res;
+}
+template<typename T> 														// Divides two vectors of same type and size together
+T /*UF_API*/ uf::vector::divide( const T& left, const T& right ) {
+#if UF_USE_SIMD
+	return uf::simd::div( left, right );
+#endif
+	T res;
+	for ( std::size_t i = 0; i < T::size; ++i ) res[i] = left[i] / right[i];
+	return res;
+}
+template<typename T> 														// Divides this vector by a scalar
+T /*UF_API*/ uf::vector::divide( const T& vector, const typename T::type_t& scalar ) {
+#if UF_USE_SIMD
+	return uf::simd::div( vector, scalar );
+#endif
+	T res;
+	for ( std::size_t i = 0; i < T::size; ++i ) res[i] = vector[i] / scalar;
+	return res;
+}
+template<typename T> 														// Compute the sum of all components 
+typename T::type_t /*UF_API*/ uf::vector::sum( const T& vector ) {
+	typename T::type_t res = 0;
+	for ( std::size_t i = 0; i < T::size; ++i ) res += vector[i];
+	return res;
+}
+template<typename T> 														// Compute the product of all components 
+typename T::type_t /*UF_API*/ uf::vector::product( const T& vector ) {
+	typename T::type_t res = 0;
+	for ( std::size_t i = 0; i < T::size; ++i ) res *= vector[i];
+	return res;
+}
+template<typename T> 														// Flip sign of all components
+T /*UF_API*/ uf::vector::negate( const T& vector ) {
+#if UF_USE_SIMD
+	return uf::simd::mul( vector, -1.f );
+#endif
+	T res;
+	for ( std::size_t i = 0; i < T::size; ++i ) res[i] = -vector[i];
+	return res;
+}
+// Writes to first value
+template<typename T> 														// Adds two vectors of same type and size together
+T& /*UF_API*/ uf::vector::add( T& left, const T& right ) {
+#if UF_USE_SIMD
+	return left = uf::vector::add( (const T&) left, right );
+#endif
+	for ( std::size_t i = 0; i < T::size; ++i ) left[i] += right[i];
+	return left;
+}
+template<typename T> 														// Subtracts two vectors of same type and size together
+T& /*UF_API*/ uf::vector::subtract( T& left, const T& right ) {
+#if UF_USE_SIMD
+	return left = uf::vector::subtract( (const T&) left, right );
+#endif
+	for ( std::size_t i = 0; i < T::size; ++i ) left[i] -= right[i];
+	return left;
+}
+template<typename T> 														// Multiplies two vectors of same type and size together
+T& /*UF_API*/ uf::vector::multiply( T& left, const T& right ) {
+#if UF_USE_SIMD
+	return left = uf::vector::multiply( (const T&) left, right );
+#endif
+	for ( std::size_t i = 0; i < T::size; ++i ) left[i] *= right[i];
+	return left;
+}
+template<typename T> 														// Multiplies this vector by a scalar
+T& /*UF_API*/ uf::vector::multiply( T& vector, const typename T::type_t& scalar ) {
+#if UF_USE_SIMD
+	return vector = uf::vector::multiply( (const T&) vector, scalar );
+#endif
+	for ( std::size_t i = 0; i < T::size; ++i ) vector[i] *= scalar;
+	return vector;
+}
+template<typename T> 														// Divides two vectors of same type and size together
+T& /*UF_API*/ uf::vector::divide( T& left, const T& right ) {
+#if UF_USE_SIMD
+	return left = uf::vector::divide( (const T&) left, right );
+#endif
+	for ( std::size_t i = 0; i < T::size; ++i ) left[i] /= right[i];
+	return left;
+}
+template<typename T> 														// Divides this vector by a scalar
+T& /*UF_API*/ uf::vector::divide( T& vector, const typename T::type_t& scalar ) {
+#if UF_USE_SIMD
+	return vector = uf::vector::divide( (const T&) vector, scalar );
+#endif
+	for ( std::size_t i = 0; i < T::size; ++i ) vector[i] /= scalar;
+	return vector;
+}
+template<typename T> 														// Flip sign of all components
+T& /*UF_API*/ uf::vector::negate( T& vector ) {
+#if UF_USE_SIMD
+	return vector = uf::vector::negate( (const T&) vector );
+#endif
+	for ( std::size_t i = 0; i < T::size; ++i ) vector[i] = -vector[i];
+	return vector;
+}
+template<typename T> 														// Normalizes a vector
+T& /*UF_API*/ uf::vector::normalize( T& vector ) {
+	typename T::type_t norm = uf::vector::norm(vector);
+	if ( norm == 0 ) return vector;	
+	return uf::vector::divide(vector, norm);
+}
+// Complex arithmetic
+template<typename T> 														// Compute the dot product between two vectors
+typename T::type_t /*UF_API*/ uf::vector::dot( const T& left, const T& right ) {
+#if UF_USE_SIMD
+	return uf::simd::dot( left, right );
+#endif
+	return uf::vector::sum(uf::vector::multiply(left, right));
+}
+template<typename T> 														// Compute the angle between two vectors
+pod::Angle /*UF_API*/ uf::vector::angle( const T& a, const T& b ) {
+	return acos(uf::vector::dot(a, b));
+}
+template<typename T> 														// Linearly interpolate between two vectors
+T /*UF_API*/ uf::vector::lerp( const T& from, const T& to, double delta, bool clamp ) {
+	delta = fmax( 0, fmin(1,delta) );
+	// from + ( ( to - from ) * delta )
+#if UF_USE_SIMD
+	return uf::simd::add(from, uf::simd::mul( uf::simd::sub(to, from), (float) delta) );
+#endif
+	return uf::vector::add(from, uf::vector::multiply( uf::vector::subtract(to, from), delta ) );
+}
+template<typename T> 														// Linearly interpolate between two vectors
+T /*UF_API*/ uf::vector::lerp( const T& from, const T& to, const T& delta, bool clamp ) {
+	//delta = fmax( 0, fmin(1,delta) );
+	// from + ( ( to - from ) * delta )
+#if UF_USE_SIMD
+	return uf::simd::add(from, uf::simd::mul( uf::simd::sub(to, from), delta) );
+#endif
+	return uf::vector::add(from, uf::vector::multiply( uf::vector::subtract(to, from), delta ) );
+}
+template<typename T> 														// Spherically interpolate between two vectors
+T /*UF_API*/ uf::vector::slerp( const T& from, const T& to, double delta, bool clamp ) {
+	if ( clamp ) delta = fmax( 0, fmin(1,delta) );
+	typename T::type_t dot = uf::vector::dot(from, to);
+	typename T::type_t theta = acos(dot);
+	typename T::type_t sTheta = sin(theta);
+
+	typename T::type_t w1 = sin((1.0f - delta) * theta / sTheta);
+	typename T::type_t w2 = sin( delta * theta / sTheta );
+#if UF_USE_SIMD
+	return uf::simd::add( uf::simd::mul( from, w1 ), uf::simd::mul( to, w2 ) );
+#endif
+	return uf::vector::add(uf::vector::multiply(from, w1), uf::vector::multiply(to, w2));
+}
+template<typename T> 														// 
+T /*UF_API*/ uf::vector::mix( const T& x, const T& y, double a, bool clamp ) {
+	if ( clamp ) a = fmax( 0, fmin(1,a) );
+	// x * (1.0 - a) + y * a
+#if UF_USE_SIMD
+	return uf::simd::add( uf::simd::mul( x, 1.0f - (float) a ), uf::simd::mul( y, (float) a ) );
+#endif
+	return uf::vector::add( uf::vector::multiply( x, 1 - a ), uf::vector::multiply( y, a ) );
+}
+template<typename T> 														// Compute the distance between two vectors (doesn't sqrt)
+typename T::type_t /*UF_API*/ uf::vector::distanceSquared( const T& a, const T& b ) {
+#if UF_USE_SIMD
+	uf::simd::value<typename T::type_t> delta = uf::simd::sub( b, a );
+	return uf::vector::sum( uf::simd::vector( uf::simd::mul( delta, delta ) ) );
+#else
+	T delta = uf::vector::subtract(b, a);
+	uf::vector::multiply( delta, delta );
+	return uf::vector::sum(delta);
+#endif
+}
+template<typename T> 														// Compute the distance between two vectors
+typename T::type_t /*UF_API*/ uf::vector::distance( const T& a, const T& b ) {
+	return sqrt(uf::vector::distanceSquared(a,b));
+}
+template<typename T> 														// Gets the magnitude of the vector
+typename T::type_t /*UF_API*/ uf::vector::magnitude( const T& vector ) {
+	return uf::vector::dot(vector, vector);
+}
+template<typename T> 														// Compute the norm of the vector
+typename T::type_t /*UF_API*/ uf::vector::norm( const T& vector ) {
+	return sqrt( uf::vector::magnitude(vector) );
+}
+template<typename T> 														// Normalizes a vector
+T /*UF_API*/ uf::vector::normalize( const T& vector ) {
+	typename T::type_t norm = uf::vector::norm(vector);
+	if ( norm == 0 ) return vector;	
+	return uf::vector::divide(vector, norm);
+}
+template<typename T> 														// Normalizes a vector
+void /*UF_API*/ uf::vector::orthonormalize( T& normal, T& tangent ) {
+	normal = uf::vector::normalize( normal );
+	T norm = normal;
+	T tan = uf::vector::normalize( tangent );
+	tangent = uf::vector::subtract( tan, uf::vector::multiply( norm, uf::vector::dot( norm, tan ) ) );
+	tangent = uf::vector::normalize( tangent );
+}
+template<typename T> 														// Normalizes a vector
+T /*UF_API*/ uf::vector::orthonormalize( const T& x, const T& y ) {
+	return uf::vector::normalize( uf::vector::subtract( x, uf::vector::multiply( y, uf::vector::dot( y, x ) ) ) );
+}
+template<typename T> 														// Normalizes a vector
+T /*UF_API*/ uf::vector::cross( const T& a, const T& b ) {
+#if UF_USE_SIMD
+		uf::simd::value<typename T::type_t> x = a;
+		uf::simd::value<typename T::type_t> y = b;
+	#if SSE_INSTR_SET >= 7
+		uf::simd::value<typename T::type_t> tmp0 = _mm_shuffle_ps(y,y,_MM_SHUFFLE(3,0,2,1));
+		uf::simd::value<typename T::type_t> tmp1 = _mm_shuffle_ps(x,x,_MM_SHUFFLE(3,0,2,1));
+		tmp1 = _mm_mul_ps(tmp1,y);
+		uf::simd::value<typename T::type_t> tmp2 = _mm_fmsub_ps( tmp0,x, tmp1 );
+		uf::simd::value<typename T::type_t> res = _mm_shuffle_ps(tmp2,tmp2,_MM_SHUFFLE(3,0,2,1));
+		return res;
+	#else
+		uf::simd::value<typename T::type_t> tmp0 = _mm_shuffle_ps(y,y,_MM_SHUFFLE(3,0,2,1));
+		uf::simd::value<typename T::type_t> tmp1 = _mm_shuffle_ps(x,x,_MM_SHUFFLE(3,0,2,1));
+		tmp0 = _mm_mul_ps(tmp0,x);
+		tmp1 = _mm_mul_ps(tmp1,y);
+		uf::simd::value<typename T::type_t> tmp2 = _mm_sub_ps(tmp0,tmp1);
+		uf::simd::value<typename T::type_t> res = _mm_shuffle_ps(tmp2,tmp2,_MM_SHUFFLE(3,0,2,1));
+		return res;
+	#endif
+#endif
+	return T{
+		a.y * b.z - b.y * a.z,
+		a.z * b.x - b.z * a.x,
+		a.x * b.y - b.x * a.y
+	};
+}
+template<typename T> 														// Normalizes a vector
+std::string /*UF_API*/ uf::vector::toString( const T& v ) {
+	size_t size = T::size;
+	std::stringstream ss;
+	ss << "Vector(";
+	for ( size_t i = 0; i < size; ++i ) {
+		ss << v[i];
+		if ( i + 1 < size ) ss << ", ";
+	}
+	ss << ")";
+	return ss.str();
+}
+
+template<typename T, size_t N>
+ext::json::Value /*UF_API*/ uf::vector::encode( const pod::Vector<T,N>& v, bool compress ) {
+	ext::json::Value json;
+	if ( compress ) for ( size_t i = 0; i < N; ++i ) json[i] = uf::math::quantizeShort( v[i] );
+	else for ( size_t i = 0; i < N; ++i ) json[i] = v[i];
+	return json;
+}
+template<typename T, size_t N>
+pod::Vector<T,N>& /*UF_API*/ uf::vector::decode( const ext::json::Value& json, pod::Vector<T,N>& v ) {
+	if ( ext::json::isArray(json) ) for ( size_t i = 0; i < N; ++i ) v[i] = json[i].as<T>();
+	else if ( ext::json::isObject(json) ) {
+		size_t i = 0;
+		ext::json::forEach(json, [&](const ext::json::Value& c){
+			if ( i < N ) v[i++] = uf::math::unquantize( c.as<T>() );
+		});
+	}
+	return v;
+}
+template<typename T, size_t N>
+pod::Vector<T,N> /*UF_API*/ uf::vector::decode( const ext::json::Value& json, const pod::Vector<T,N>& _v ) {
+	pod::Vector<T,N> v = _v;
+	if ( ext::json::isArray(json) ) for ( size_t i = 0; i < N; ++i ) v[i] = json[i].as<T>();
+	else if ( ext::json::isObject(json) ) {
+		size_t i = 0;
+		ext::json::forEach(json, [&](const ext::json::Value& c){
+			if ( i < N ) v[i++] = c.as<T>();
+		});
+	}
+	return v;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/math/vector/redundancy.inl b/engine/inc/uf/utils/math/vector/redundancy.inl
new file mode 100644
index 00000000..988870b1
--- /dev/null
+++ b/engine/inc/uf/utils/math/vector/redundancy.inl
@@ -0,0 +1,1894 @@
+//
+//
+template<typename T, std::size_t N>
+T& pod::Vector<T,N>::operator[](std::size_t i) {
+	return this->components[i];
+}
+template<typename T, std::size_t N>
+const T& pod::Vector<T,N>::operator[](std::size_t i) const {
+	return this->components[i];
+}
+// Arithmetic
+template<typename T, std::size_t N> 												// 	Negation
+inline pod::Vector<T,N> pod::Vector<T,N>::operator-() const {
+	return uf::vector::negate( *this );
+}			
+template<typename T, std::size_t N> 												// 	Addition between two vectors
+inline pod::Vector<T,N> pod::Vector<T,N>::operator+( const pod::Vector<T,N>& vector ) const {
+	return uf::vector::add( *this, vector );
+}
+template<typename T, std::size_t N> 												// 	Subtraction between two vectors
+inline pod::Vector<T,N> pod::Vector<T,N>::operator-( const pod::Vector<T,N>& vector ) const {
+	return uf::vector::subtract( *this, vector );
+}
+template<typename T, std::size_t N> 												// 	Multiplication between two vectors
+inline pod::Vector<T,N> pod::Vector<T,N>::operator*( const pod::Vector<T,N>& vector ) const {
+	return uf::vector::multiply( *this, vector );
+}
+template<typename T, std::size_t N> 												// 	Division between two vectors
+inline pod::Vector<T,N> pod::Vector<T,N>::operator/( const pod::Vector<T,N>& vector ) const {
+	return uf::vector::divide( *this, vector );
+}
+template<typename T, std::size_t N> 												// 	Multiplication with scalar
+inline pod::Vector<T,N> pod::Vector<T,N>::operator*( T scalar ) const {
+	return uf::vector::multiply( *this, scalar );
+}
+template<typename T, std::size_t N> 												// 	Division with scalar
+inline pod::Vector<T,N> pod::Vector<T,N>::operator/( T scalar ) const {
+	return uf::vector::divide( *this, scalar );
+}
+template<typename T, std::size_t N> 												// 	Addition set between two vectors
+inline pod::Vector<T,N>& pod::Vector<T,N>::operator +=( const pod::Vector<T,N>& vector ) {
+	return uf::vector::add( *this, vector );
+}
+template<typename T, std::size_t N> 												// 	Subtraction set between two vectors
+inline pod::Vector<T,N>& pod::Vector<T,N>::operator -=( const pod::Vector<T,N>& vector ) {
+	return uf::vector::subtract( *this, vector );
+}
+template<typename T, std::size_t N> 												// 	Multiplication set between two vectors
+inline pod::Vector<T,N>& pod::Vector<T,N>::operator *=( const pod::Vector<T,N>& vector ) {
+	return uf::vector::multiply( *this, vector );
+}
+template<typename T, std::size_t N> 												// 	Division set between two vectors
+inline pod::Vector<T,N>& pod::Vector<T,N>::operator /=( const pod::Vector<T,N>& vector ) {
+	return uf::vector::divide( *this, vector );
+}
+template<typename T, std::size_t N> 												// 	Multiplication set with scalar
+inline pod::Vector<T,N>& pod::Vector<T,N>::operator *=( T scalar ) {
+	return uf::vector::multiply( *this, scalar );
+}
+template<typename T, std::size_t N> 												// 	Division set with scalar
+inline pod::Vector<T,N>& pod::Vector<T,N>::operator /=( T scalar ) {
+	return uf::vector::divide( *this, scalar );
+}
+template<typename T, std::size_t N> 												// 	Equality check between two vectors (equals)
+inline bool pod::Vector<T,N>::operator==( const pod::Vector<T,N>& vector ) const {
+	return uf::vector::equals(*this, vector);
+}
+template<typename T, std::size_t N> 												// 	Equality check between two vectors (not equals)
+inline bool pod::Vector<T,N>::operator!=( const pod::Vector<T,N>& vector ) const {
+	return !uf::vector::equals(*this, vector);
+}
+template<typename T, std::size_t N> 												// 	Equality check between two vectors (less than)
+inline bool pod::Vector<T,N>::operator<( const pod::Vector<T,N>& vector ) const {
+	return uf::vector::compareTo(*this, vector) < 0;
+}
+template<typename T, std::size_t N> 												// 	Equality check between two vectors (less than or equals)
+inline bool pod::Vector<T,N>::operator<=( const pod::Vector<T,N>& vector ) const {
+	return uf::vector::compareTo(*this, vector) <= 0;
+}
+template<typename T, std::size_t N> 												// 	Equality check between two vectors (greater than)
+inline bool pod::Vector<T,N>::operator>( const pod::Vector<T,N>& vector ) const {
+	return uf::vector::compareTo(*this, vector) > 0;
+}
+template<typename T, std::size_t N> 												// 	Equality check between two vectors (greater than or equals)
+inline bool pod::Vector<T,N>::operator>=( const pod::Vector<T,N>& vector ) const {
+	return uf::vector::compareTo(*this, vector) >= 0;
+}
+template<typename T, std::size_t N> 												// 	Equality check between two vectors (greater than or equals)
+inline pod::Vector<T,N>::operator bool() const {
+	return !uf::vector::equals(*this, pod::Vector<T,N>{});
+}
+
+template<typename T, size_t N>
+template<typename U, size_t M>
+pod::Vector<T,N>::operator pod::Vector<U,M>() {
+	return uf::vector::cast<U,M>(*this);
+}
+template<typename T, size_t N>
+template<typename U, size_t M>
+pod::Vector<T,N>& pod::Vector<T,N>::operator=( const pod::Vector<U,M>& vector ) {
+	return *this = uf::vector::cast<T,N>(vector);
+}
+//
+template<typename T>
+T& pod::Vector<T,1>::operator[](std::size_t i) {
+	if ( i >= this->size ) i = this->size - 1;
+	return (&this->x)[i];
+}
+template<typename T>
+const T& pod::Vector<T,1>::operator[](std::size_t i) const {
+	if ( i >= this->size ) i = this->size - 1;
+	return (&this->x)[i];
+}
+// Arithmetic
+template<typename T> 												// 	Negation
+inline pod::Vector<T,1> pod::Vector<T,1>::operator()() const {
+	return uf::vector::create<T>(0);
+}			
+template<typename T> 												// 	Negation
+inline pod::Vector<T,1> pod::Vector<T,1>::operator-() const {
+	return uf::vector::negate( *this );
+}			
+template<typename T> 												// 	Addition between two vectors
+inline pod::Vector<T,1> pod::Vector<T,1>::operator+( const pod::Vector<T,1>& vector ) const {
+	return uf::vector::add( *this, vector );
+}
+template<typename T> 												// 	Subtraction between two vectors
+inline pod::Vector<T,1> pod::Vector<T,1>::operator-( const pod::Vector<T,1>& vector ) const {
+	return uf::vector::subtract( *this, vector );
+}
+template<typename T> 												// 	Multiplication between two vectors
+inline pod::Vector<T,1> pod::Vector<T,1>::operator*( const pod::Vector<T,1>& vector ) const {
+	return uf::vector::multiply( *this, vector );
+}
+template<typename T> 												// 	Division between two vectors
+inline pod::Vector<T,1> pod::Vector<T,1>::operator/( const pod::Vector<T,1>& vector ) const {
+	return uf::vector::divide( *this, vector );
+}
+template<typename T> 												// 	Multiplication with scalar
+inline pod::Vector<T,1> pod::Vector<T,1>::operator*( T scalar ) const {
+	return uf::vector::multiply( *this, scalar );
+}
+template<typename T> 												// 	Division with scalar
+inline pod::Vector<T,1> pod::Vector<T,1>::operator/( T scalar ) const {
+	return uf::vector::divide( *this, scalar );
+}
+template<typename T> 												// 	Addition set between two vectors
+inline pod::Vector<T,1>& pod::Vector<T,1>::operator +=( const pod::Vector<T,1>& vector ) {
+	return uf::vector::add( *this, vector );
+}
+template<typename T> 												// 	Subtraction set between two vectors
+inline pod::Vector<T,1>& pod::Vector<T,1>::operator -=( const pod::Vector<T,1>& vector ) {
+	return uf::vector::subtract( *this, vector );
+}
+template<typename T> 												// 	Multiplication set between two vectors
+inline pod::Vector<T,1>& pod::Vector<T,1>::operator *=( const pod::Vector<T,1>& vector ) {
+	return uf::vector::multiply( *this, vector );
+}
+template<typename T> 												// 	Division set between two vectors
+inline pod::Vector<T,1>& pod::Vector<T,1>::operator /=( const pod::Vector<T,1>& vector ) {
+	return uf::vector::divide( *this, vector );
+}
+template<typename T> 												// 	Multiplication set with scalar
+inline pod::Vector<T,1>& pod::Vector<T,1>::operator *=( T scalar ) {
+	return uf::vector::multiply( *this, scalar );
+}
+template<typename T> 												// 	Division set with scalar
+inline pod::Vector<T,1>& pod::Vector<T,1>::operator /=( T scalar ) {
+	return uf::vector::divide( *this, scalar );
+}
+template<typename T> 												// 	Equality check between two vectors (equals)
+inline bool pod::Vector<T,1>::operator==( const pod::Vector<T,1>& vector ) const {
+	return uf::vector::equals(*this, vector);
+}
+template<typename T> 												// 	Equality check between two vectors (not equals)
+inline bool pod::Vector<T,1>::operator!=( const pod::Vector<T,1>& vector ) const {
+	return !uf::vector::equals(*this, vector);
+}
+template<typename T> 												// 	Equality check between two vectors (less than)
+inline bool pod::Vector<T,1>::operator<( const pod::Vector<T,1>& vector ) const {
+	return uf::vector::compareTo(*this, vector) < 0;
+}
+template<typename T> 												// 	Equality check between two vectors (less than or equals)
+inline bool pod::Vector<T,1>::operator<=( const pod::Vector<T,1>& vector ) const {
+	return uf::vector::compareTo(*this, vector) <= 0;
+}
+template<typename T> 												// 	Equality check between two vectors (greater than)
+inline bool pod::Vector<T,1>::operator>( const pod::Vector<T,1>& vector ) const {
+	return uf::vector::compareTo(*this, vector) > 0;
+}
+template<typename T> 												// 	Equality check between two vectors (greater than or equals)
+inline bool pod::Vector<T,1>::operator>=( const pod::Vector<T,1>& vector ) const {
+	return uf::vector::compareTo(*this, vector) >= 0;
+}
+template<typename T>
+inline pod::Vector<T,1>::operator bool() const {
+	return !uf::vector::equals(*this, pod::Vector<T,1>{});
+}
+template<typename T>
+template<typename U, std::size_t M>
+pod::Vector<T,1>::operator pod::Vector<U,M>() {
+	return uf::vector::cast<U,M>(*this);
+}
+template<typename T>
+template<typename U, std::size_t M>
+pod::Vector<T,1>& pod::Vector<T,1>::operator=( const pod::Vector<U,M>& vector ) {
+	return *this = uf::vector::cast<T,1>(vector);
+}
+//
+template<typename T>
+T& pod::Vector<T,2>::operator[](std::size_t i) {
+	if ( i >= this->size ) i = this->size - 1;
+	return (&this->x)[i];
+}
+template<typename T>
+const T& pod::Vector<T,2>::operator[](std::size_t i) const {
+	if ( i >= this->size ) i = this->size - 1;
+	return (&this->x)[i];
+}
+// Arithmetic
+template<typename T> 												// 	Negation
+inline pod::Vector<T,2> pod::Vector<T,2>::operator()() const {
+	return uf::vector::create<T>(0,0);
+}			
+template<typename T> 												// 	Negation
+inline pod::Vector<T,2> pod::Vector<T,2>::operator-() const {
+	return uf::vector::negate( *this );
+}			
+template<typename T> 												// 	Addition between two vectors
+inline pod::Vector<T,2> pod::Vector<T,2>::operator+( const pod::Vector<T,2>& vector ) const {
+	return uf::vector::add( *this, vector );
+}
+template<typename T> 												// 	Subtraction between two vectors
+inline pod::Vector<T,2> pod::Vector<T,2>::operator-( const pod::Vector<T,2>& vector ) const {
+	return uf::vector::subtract( *this, vector );
+}
+template<typename T> 												// 	Multiplication between two vectors
+inline pod::Vector<T,2> pod::Vector<T,2>::operator*( const pod::Vector<T,2>& vector ) const {
+	return uf::vector::multiply( *this, vector );
+}
+template<typename T> 												// 	Division between two vectors
+inline pod::Vector<T,2> pod::Vector<T,2>::operator/( const pod::Vector<T,2>& vector ) const {
+	return uf::vector::divide( *this, vector );
+}
+template<typename T> 												// 	Multiplication with scalar
+inline pod::Vector<T,2> pod::Vector<T,2>::operator*( T scalar ) const {
+	return uf::vector::multiply( *this, scalar );
+}
+template<typename T> 												// 	Division with scalar
+inline pod::Vector<T,2> pod::Vector<T,2>::operator/( T scalar ) const {
+	return uf::vector::divide( *this, scalar );
+}
+template<typename T> 												// 	Addition set between two vectors
+inline pod::Vector<T,2>& pod::Vector<T,2>::operator +=( const pod::Vector<T,2>& vector ) {
+	return uf::vector::add( *this, vector );
+}
+template<typename T> 												// 	Subtraction set between two vectors
+inline pod::Vector<T,2>& pod::Vector<T,2>::operator -=( const pod::Vector<T,2>& vector ) {
+	return uf::vector::subtract( *this, vector );
+}
+template<typename T> 												// 	Multiplication set between two vectors
+inline pod::Vector<T,2>& pod::Vector<T,2>::operator *=( const pod::Vector<T,2>& vector ) {
+	return uf::vector::multiply( *this, vector );
+}
+template<typename T> 												// 	Division set between two vectors
+inline pod::Vector<T,2>& pod::Vector<T,2>::operator /=( const pod::Vector<T,2>& vector ) {
+	return uf::vector::divide( *this, vector );
+}
+template<typename T> 												// 	Multiplication set with scalar
+inline pod::Vector<T,2>& pod::Vector<T,2>::operator *=( T scalar ) {
+	return uf::vector::multiply( *this, scalar );
+}
+template<typename T> 												// 	Division set with scalar
+inline pod::Vector<T,2>& pod::Vector<T,2>::operator /=( T scalar ) {
+	return uf::vector::divide( *this, scalar );
+}
+template<typename T> 												// 	Equality check between two vectors (equals)
+inline bool pod::Vector<T,2>::operator==( const pod::Vector<T,2>& vector ) const {
+	return uf::vector::equals(*this, vector);
+}
+template<typename T> 												// 	Equality check between two vectors (not equals)
+inline bool pod::Vector<T,2>::operator!=( const pod::Vector<T,2>& vector ) const {
+	return !uf::vector::equals(*this, vector);
+}
+template<typename T> 												// 	Equality check between two vectors (less than)
+inline bool pod::Vector<T,2>::operator<( const pod::Vector<T,2>& vector ) const {
+	return uf::vector::compareTo(*this, vector) < 0;
+}
+template<typename T> 												// 	Equality check between two vectors (less than or equals)
+inline bool pod::Vector<T,2>::operator<=( const pod::Vector<T,2>& vector ) const {
+	return uf::vector::compareTo(*this, vector) <= 0;
+}
+template<typename T> 												// 	Equality check between two vectors (greater than)
+inline bool pod::Vector<T,2>::operator>( const pod::Vector<T,2>& vector ) const {
+	return uf::vector::compareTo(*this, vector) > 0;
+}
+template<typename T> 												// 	Equality check between two vectors (greater than or equals)
+inline bool pod::Vector<T,2>::operator>=( const pod::Vector<T,2>& vector ) const {
+	return uf::vector::compareTo(*this, vector) >= 0;
+}
+template<typename T>
+inline pod::Vector<T,2>::operator bool() const {
+	return !uf::vector::equals(*this, pod::Vector<T,2>{});
+}
+template<typename T>
+template<typename U, std::size_t M>
+pod::Vector<T,2>::operator pod::Vector<U,M>() {
+	return uf::vector::cast<U,M>(*this);
+}
+template<typename T>
+template<typename U, std::size_t M>
+pod::Vector<T,2>& pod::Vector<T,2>::operator=( const pod::Vector<U,M>& vector ) {
+	return *this = uf::vector::cast<T,2>(vector);
+}
+//
+template<typename T>
+T& pod::Vector<T,3>::operator[](std::size_t i) {
+	if ( i >= this->size ) i = this->size - 1;
+	return (&this->x)[i];
+}
+template<typename T>
+const T& pod::Vector<T,3>::operator[](std::size_t i) const {
+	if ( i >= this->size ) i = this->size - 1;
+	return (&this->x)[i];
+}
+// Arithmetic
+template<typename T> 												// 	Negation
+inline pod::Vector<T,3> pod::Vector<T,3>::operator()() const {
+	return uf::vector::create<T>(0,0,0);
+}			
+template<typename T> 												// 	Negation
+inline pod::Vector<T,3> pod::Vector<T,3>::operator-() const {
+	return uf::vector::negate( *this );
+}			
+template<typename T> 												// 	Addition between two vectors
+inline pod::Vector<T,3> pod::Vector<T,3>::operator+( const pod::Vector<T,3>& vector ) const {
+	return uf::vector::add( *this, vector );
+}
+template<typename T> 												// 	Subtraction between two vectors
+inline pod::Vector<T,3> pod::Vector<T,3>::operator-( const pod::Vector<T,3>& vector ) const {
+	return uf::vector::subtract( *this, vector );
+}
+template<typename T> 												// 	Multiplication between two vectors
+inline pod::Vector<T,3> pod::Vector<T,3>::operator*( const pod::Vector<T,3>& vector ) const {
+	return uf::vector::multiply( *this, vector );
+}
+template<typename T> 												// 	Division between two vectors
+inline pod::Vector<T,3> pod::Vector<T,3>::operator/( const pod::Vector<T,3>& vector ) const {
+	return uf::vector::divide( *this, vector );
+}
+template<typename T> 												// 	Multiplication with scalar
+inline pod::Vector<T,3> pod::Vector<T,3>::operator*( T scalar ) const {
+	return uf::vector::multiply( *this, scalar );
+}
+template<typename T> 												// 	Division with scalar
+inline pod::Vector<T,3> pod::Vector<T,3>::operator/( T scalar ) const {
+	return uf::vector::divide( *this, scalar );
+}
+template<typename T> 												// 	Addition set between two vectors
+inline pod::Vector<T,3>& pod::Vector<T,3>::operator +=( const pod::Vector<T,3>& vector ) {
+	return uf::vector::add( *this, vector );
+}
+template<typename T> 												// 	Subtraction set between two vectors
+inline pod::Vector<T,3>& pod::Vector<T,3>::operator -=( const pod::Vector<T,3>& vector ) {
+	return uf::vector::subtract( *this, vector );
+}
+template<typename T> 												// 	Multiplication set between two vectors
+inline pod::Vector<T,3>& pod::Vector<T,3>::operator *=( const pod::Vector<T,3>& vector ) {
+	return uf::vector::multiply( *this, vector );
+}
+template<typename T> 												// 	Division set between two vectors
+inline pod::Vector<T,3>& pod::Vector<T,3>::operator /=( const pod::Vector<T,3>& vector ) {
+	return uf::vector::divide( *this, vector );
+}
+template<typename T> 												// 	Multiplication set with scalar
+inline pod::Vector<T,3>& pod::Vector<T,3>::operator *=( T scalar ) {
+	return uf::vector::multiply( *this, scalar );
+}
+template<typename T> 												// 	Division set with scalar
+inline pod::Vector<T,3>& pod::Vector<T,3>::operator /=( T scalar ) {
+	return uf::vector::divide( *this, scalar );
+}
+template<typename T> 												// 	Equality check between two vectors (equals)
+inline bool pod::Vector<T,3>::operator==( const pod::Vector<T,3>& vector ) const {
+	return uf::vector::equals(*this, vector);
+}
+template<typename T> 												// 	Equality check between two vectors (not equals)
+inline bool pod::Vector<T,3>::operator!=( const pod::Vector<T,3>& vector ) const {
+	return !uf::vector::equals(*this, vector);
+}
+template<typename T> 												// 	Equality check between two vectors (less than)
+inline bool pod::Vector<T,3>::operator<( const pod::Vector<T,3>& vector ) const {
+	return uf::vector::compareTo(*this, vector) < 0;
+}
+template<typename T> 												// 	Equality check between two vectors (less than or equals)
+inline bool pod::Vector<T,3>::operator<=( const pod::Vector<T,3>& vector ) const {
+	return uf::vector::compareTo(*this, vector) <= 0;
+}
+template<typename T> 												// 	Equality check between two vectors (greater than)
+inline bool pod::Vector<T,3>::operator>( const pod::Vector<T,3>& vector ) const {
+	return uf::vector::compareTo(*this, vector) > 0;
+}
+template<typename T> 												// 	Equality check between two vectors (greater than or equals)
+inline bool pod::Vector<T,3>::operator>=( const pod::Vector<T,3>& vector ) const {
+	return uf::vector::compareTo(*this, vector) >= 0;
+}
+template<typename T>
+inline pod::Vector<T,3>::operator bool() const {
+	return !uf::vector::equals(*this, pod::Vector<T,3>{});
+}
+template<typename T>
+template<typename U, std::size_t M>
+pod::Vector<T,3>::operator pod::Vector<U,M>() {
+	return uf::vector::cast<U,M>(*this);
+/*
+	pod::Vector<U,M> vector = {};
+	for ( size_t i = 0; i < 3 && i < M; ++i ) {
+		vector[i] = (*this)[i];
+	}
+	return vector;
+*/
+}
+template<typename T>
+template<typename U, std::size_t M>
+pod::Vector<T,3>& pod::Vector<T,3>::operator=( const pod::Vector<U,M>& vector ) {
+	return *this = uf::vector::cast<T,3>(vector);
+/*
+	for ( size_t i = 0; i < 3 && i < M; ++i ) {
+		(*this)[i] = vector[i];
+	}
+	return *this;
+*/
+}
+//
+template<typename T>
+T& pod::Vector<T,4>::operator[](std::size_t i) {
+	if ( i >= this->size ) i = this->size - 1;
+	return (&this->x)[i];
+}
+template<typename T>
+const T& pod::Vector<T,4>::operator[](std::size_t i) const {
+	if ( i >= this->size ) i = this->size - 1;
+	return (&this->x)[i];
+}
+// Arithmetic
+template<typename T> 												// 	Negation
+inline pod::Vector<T,4> pod::Vector<T,4>::operator()() const {
+	return uf::vector::create<T>(0,0,0,1);
+}			
+template<typename T> 												// 	Negation
+inline pod::Vector<T,4> pod::Vector<T,4>::operator-() const {
+	return uf::vector::negate( *this );
+}			
+template<typename T> 												// 	Addition between two vectors
+inline pod::Vector<T,4> pod::Vector<T,4>::operator+( const pod::Vector<T,4>& vector ) const {
+	return uf::vector::add( *this, vector );
+}
+template<typename T> 												// 	Subtraction between two vectors
+inline pod::Vector<T,4> pod::Vector<T,4>::operator-( const pod::Vector<T,4>& vector ) const {
+	return uf::vector::subtract( *this, vector );
+}
+template<typename T> 												// 	Multiplication between two vectors
+inline pod::Vector<T,4> pod::Vector<T,4>::operator*( const pod::Vector<T,4>& vector ) const {
+	return uf::vector::multiply( *this, vector );
+}
+template<typename T> 												// 	Division between two vectors
+inline pod::Vector<T,4> pod::Vector<T,4>::operator/( const pod::Vector<T,4>& vector ) const {
+	return uf::vector::divide( *this, vector );
+}
+template<typename T> 												// 	Multiplication with scalar
+inline pod::Vector<T,4> pod::Vector<T,4>::operator*( T scalar ) const {
+	return uf::vector::multiply( *this, scalar );
+}
+template<typename T> 												// 	Division with scalar
+inline pod::Vector<T,4> pod::Vector<T,4>::operator/( T scalar ) const {
+	return uf::vector::divide( *this, scalar );
+}
+template<typename T> 												// 	Addition set between two vectors
+inline pod::Vector<T,4>& pod::Vector<T,4>::operator +=( const pod::Vector<T,4>& vector ) {
+	return uf::vector::add( *this, vector );
+}
+template<typename T> 												// 	Subtraction set between two vectors
+inline pod::Vector<T,4>& pod::Vector<T,4>::operator -=( const pod::Vector<T,4>& vector ) {
+	return uf::vector::subtract( *this, vector );
+}
+template<typename T> 												// 	Multiplication set between two vectors
+inline pod::Vector<T,4>& pod::Vector<T,4>::operator *=( const pod::Vector<T,4>& vector ) {
+	return uf::vector::multiply( *this, vector );
+}
+template<typename T> 												// 	Division set between two vectors
+inline pod::Vector<T,4>& pod::Vector<T,4>::operator /=( const pod::Vector<T,4>& vector ) {
+	return uf::vector::divide( *this, vector );
+}
+template<typename T> 												// 	Multiplication set with scalar
+inline pod::Vector<T,4>& pod::Vector<T,4>::operator *=( T scalar ) {
+	return uf::vector::multiply( *this, scalar );
+}
+template<typename T> 												// 	Division set with scalar
+inline pod::Vector<T,4>& pod::Vector<T,4>::operator /=( T scalar ) {
+	return uf::vector::divide( *this, scalar );
+}
+template<typename T> 												// 	Equality check between two vectors (equals)
+inline bool pod::Vector<T,4>::operator==( const pod::Vector<T,4>& vector ) const {
+	return uf::vector::equals(*this, vector);
+}
+template<typename T> 												// 	Equality check between two vectors (not equals)
+inline bool pod::Vector<T,4>::operator!=( const pod::Vector<T,4>& vector ) const {
+	return !uf::vector::equals(*this, vector);
+}
+template<typename T> 												// 	Equality check between two vectors (less than)
+inline bool pod::Vector<T,4>::operator<( const pod::Vector<T,4>& vector ) const {
+	return uf::vector::compareTo(*this, vector) < 0;
+}
+template<typename T> 												// 	Equality check between two vectors (less than or equals)
+inline bool pod::Vector<T,4>::operator<=( const pod::Vector<T,4>& vector ) const {
+	return uf::vector::compareTo(*this, vector) <= 0;
+}
+template<typename T> 												// 	Equality check between two vectors (greater than)
+inline bool pod::Vector<T,4>::operator>( const pod::Vector<T,4>& vector ) const {
+	return uf::vector::compareTo(*this, vector) > 0;
+}
+template<typename T> 												// 	Equality check between two vectors (greater than or equals)
+inline bool pod::Vector<T,4>::operator>=( const pod::Vector<T,4>& vector ) const {
+	return uf::vector::compareTo(*this, vector) >= 0;
+}
+template<typename T> 
+inline pod::Vector<T,4>::operator bool() const {
+	return !uf::vector::equals(*this, pod::Vector<T,4>{});
+}
+template<typename T>
+template<typename U, std::size_t M>
+pod::Vector<T,4>::operator pod::Vector<U,M>() {
+	return uf::vector::cast<U,M>(*this);
+}
+template<typename T>
+template<typename U, std::size_t M>
+pod::Vector<T,4>& pod::Vector<T,4>::operator=( const pod::Vector<U,M>& vector ) {
+	return *this = uf::vector::cast<T,4>(vector);
+}
+//
+namespace uf {
+	template<typename T>
+	struct /*UF_API*/ Vector<T,1> {
+	public:
+	// 	Easily access POD's type
+		typedef pod::Vector<T,1> pod_t;
+	// 	Replicate POD information
+		typedef T type_t;
+		typedef T* container_t;
+		static const std::size_t size = 1;
+	protected:
+	// 	POD storage
+		Vector<T,1>::pod_t m_pod;
+	public:
+		T& x = m_pod.x;
+	public:
+	// 	C-tor
+		Vector(); 																		// initializes POD to 'def'
+		Vector(T def); 																	// initializes POD to 'def'
+		Vector(T x, T y); 																// initializes POD to 'def'
+		Vector(const Vector<T,1>::pod_t& pod); 											// copies POD altogether
+		Vector(const T components[1]); 													// copies data into POD from 'components' (typed as C array)
+		Vector(const std::vector<T>& components); 										// copies data into POD from 'components' (typed as std::vector<T>)
+	// 	D-tor
+		// Unneccesary
+	// 	POD access
+		Vector<T,1>::pod_t& data(); 													// 	Returns a reference of POD
+		const Vector<T,1>::pod_t& data() const; 										// 	Returns a const-reference of POD
+	// 	Alternative POD access
+		T* get();																		// 	Returns a pointer to the entire array
+		const T* get() const; 															// 	Returns a const-pointer to the entire array
+		T& getComponent( std::size_t i );												// 	Returns a reference to a single element
+		const T& getComponent( std::size_t i ) const; 									// 	Returns a const-reference to a single element
+	// 	POD manipulation
+		T* set(const T components[1]);													// 	Sets the entire array
+		T& setComponent( std::size_t i, const T& value );								// 	Sets a single element
+	// 	Validation
+		bool isValid() const; 															// 	Checks if all components are valid (non NaN, inf, etc.)
+	// 	Basic arithmetic
+		inline uf::Vector<T,1>& add( const Vector<T, 1>& vector );						// 	Adds two vectors of same type and size together
+		inline uf::Vector<T,1>& subtract( const Vector<T, 1>& vector );					// 	Subtracts two vectors of same type and size together
+		inline uf::Vector<T,1>& multiply( const Vector<T, 1>& vector );					// 	Multiplies two vectors of same type and size together
+		inline uf::Vector<T,1>& multiply( T scalar );									// 	Multiplies this vector by a scalar
+		inline uf::Vector<T,1>& divide( const Vector<T, 1>& vector );					// 	Divides two vectors of same type and size together
+		inline uf::Vector<T,1>& divide( T scalar );										// 	Divides this vector by a scalar
+		inline T sum() const;															// 	Compute the sum of all components 
+		inline T product() const;														// 	Compute the product of all components 
+		inline uf::Vector<T,1>& negate();												// 	Flip sign of all components
+	// 	Complex arithmetic
+		inline T dot( const Vector<T,1> right ) const; 									// 	Compute the dot product between two vectors
+		inline pod::Angle angle( const Vector<T,1>& b ) const; 							// 	Compute the angle between two vectors
+		
+		inline uf::Vector<T,1> lerp( const Vector<T,1> to, double delta ) const; 		// 	Linearly interpolate between two vectors
+		inline uf::Vector<T,1> slerp( const Vector<T,1> to, double delta ) const; 		// 	Spherically interpolate between two vectors
+		
+		inline T distanceSquared( const Vector<T,1> b ) const; 							// 	Compute the distance between two vectors (doesn't sqrt)
+		inline T distance( const Vector<T,1> b ) const; 								// 	Compute the distance between two vectors
+		inline T magnitude() const; 													// 	Gets the magnitude of the vector
+		inline T norm() const; 															// 	Compute the norm of the vector
+		
+		inline uf::Vector<T,1>& normalize(); 											// 	Normalizes a vector
+		uf::Vector<T,1> getNormalized() const; 											// 	Return a normalized vector
+		inline std::string toString() const;
+	// 	Overloaded ops
+		// Accessing via subscripts
+		T& operator[](std::size_t i);
+		const T& operator[](std::size_t i) const;
+		// Arithmetic
+		inline Vector<T,1> operator-() const; 								// 	Negation
+		inline Vector<T,1> operator+( const Vector<T,1>& vector ) const; 	// 	Addition between two vectors
+		inline Vector<T,1> operator-( const Vector<T,1>& vector ) const; 	// 	Subtraction between two vectors
+		inline Vector<T,1> operator*( const Vector<T,1>& vector ) const; 	// 	Multiplication between two vectors
+		inline Vector<T,1> operator/( const Vector<T,1>& vector ) const; 	// 	Division between two vectors
+		inline Vector<T,1> operator*( T scalar ) const; 					// 	Multiplication with scalar
+		inline Vector<T,1> operator/( T scalar ) const; 					// 	Division with scalar
+		inline Vector<T,1>& operator +=( const Vector<T,1>& vector ); 		// 	Addition set between two vectors
+		inline Vector<T,1>& operator -=( const Vector<T,1>& vector ); 		// 	Subtraction set between two vectors
+		inline Vector<T,1>& operator *=( const Vector<T,1>& vector ); 		// 	Multiplication set between two vectors
+		inline Vector<T,1>& operator /=( const Vector<T,1>& vector ); 		// 	Division set between two vectors
+		inline Vector<T,1>& operator *=( T scalar ); 						// 	Multiplication set with scalar
+		inline Vector<T,1>& operator /=( T scalar ); 						// 	Division set with scalar
+		inline bool operator==( const Vector<T,1>& vector ) const; 			// 	Equality check between two vectors (equals)
+		inline bool operator!=( const Vector<T,1>& vector ) const; 			// 	Equality check between two vectors (not equals)
+		inline bool operator<( const Vector<T,1>& vector ) const; 			// 	Equality check between two vectors (less than)
+		inline bool operator<=( const Vector<T,1>& vector ) const; 			// 	Equality check between two vectors (less than or equals)
+		inline bool operator>( const Vector<T,1>& vector ) const; 			// 	Equality check between two vectors (greater than)
+		inline bool operator>=( const Vector<T,1>& vector ) const; 			// 	Equality check between two vectors (greater than or equals)
+		
+		inline operator pod_t&() { return this->m_pod; }
+		inline operator const pod_t&() const { return this->m_pod; }
+	};
+	template<typename T>
+	struct /*UF_API*/ Vector<T,2> {
+	public:
+	// 	Easily access POD's type
+		typedef pod::Vector<T,2> pod_t;
+	// 	Replicate POD information
+		typedef T type_t;
+		typedef T* container_t;
+		static const std::size_t size = 2;
+	protected:
+	// 	POD storage
+		Vector<T,2>::pod_t m_pod;
+	public:
+		T& x = m_pod.x;
+		T& y = m_pod.y;
+	public:
+	// 	C-tor
+		Vector(); 																		// initializes POD to 'def'
+		Vector(T def); 																	// initializes POD to 'def'
+		Vector(T x, T y); 																// initializes POD to 'def'
+		Vector(const Vector<T,2>::pod_t& pod); 											// copies POD altogether
+		Vector(const T components[2]); 													// copies data into POD from 'components' (typed as C array)
+		Vector(const std::vector<T>& components); 										// copies data into POD from 'components' (typed as std::vector<T>)
+	// 	D-tor
+		// Unneccesary
+	// 	POD access
+		Vector<T,2>::pod_t& data(); 													// 	Returns a reference of POD
+		const Vector<T,2>::pod_t& data() const; 										// 	Returns a const-reference of POD
+	// 	Alternative POD access
+		T* get();																		// 	Returns a pointer to the entire array
+		const T* get() const; 															// 	Returns a const-pointer to the entire array
+		T& getComponent( std::size_t i );												// 	Returns a reference to a single element
+		const T& getComponent( std::size_t i ) const; 									// 	Returns a const-reference to a single element
+	// 	POD manipulation
+		T* set(const T components[2]);													// 	Sets the entire array
+		T& setComponent( std::size_t i, const T& value );								// 	Sets a single element
+	// 	Validation
+		bool isValid() const; 															// 	Checks if all components are valid (non NaN, inf, etc.)
+	// 	Basic arithmetic
+		inline uf::Vector<T,2>& add( const Vector<T, 2>& vector );						// 	Adds two vectors of same type and size together
+		inline uf::Vector<T,2>& subtract( const Vector<T, 2>& vector );					// 	Subtracts two vectors of same type and size together
+		inline uf::Vector<T,2>& multiply( const Vector<T, 2>& vector );					// 	Multiplies two vectors of same type and size together
+		inline uf::Vector<T,2>& multiply( T scalar );									// 	Multiplies this vector by a scalar
+		inline uf::Vector<T,2>& divide( const Vector<T, 2>& vector );					// 	Divides two vectors of same type and size together
+		inline uf::Vector<T,2>& divide( T scalar );										// 	Divides this vector by a scalar
+		inline T sum() const;															// 	Compute the sum of all components 
+		inline T product() const;														// 	Compute the product of all components 
+		inline uf::Vector<T,2>& negate();												// 	Flip sign of all components
+	// 	Complex arithmetic
+		inline T dot( const Vector<T,2> right ) const; 									// 	Compute the dot product between two vectors
+		inline pod::Angle angle( const Vector<T,2>& b ) const; 							// 	Compute the angle between two vectors
+		
+		inline uf::Vector<T,2> lerp( const Vector<T,2> to, double delta ) const; 		// 	Linearly interpolate between two vectors
+		inline uf::Vector<T,2> slerp( const Vector<T,2> to, double delta ) const; 		// 	Spherically interpolate between two vectors
+		
+		inline T distanceSquared( const Vector<T,2> b ) const; 							// 	Compute the distance between two vectors (doesn't sqrt)
+		inline T distance( const Vector<T,2> b ) const; 								// 	Compute the distance between two vectors
+		inline T magnitude() const; 													// 	Gets the magnitude of the vector
+		inline T norm() const; 															// 	Compute the norm of the vector
+		
+		inline uf::Vector<T,2>& normalize(); 											// 	Normalizes a vector
+		uf::Vector<T,2> getNormalized() const; 											// 	Return a normalized vector
+		inline std::string toString() const;
+	// 	Overloaded ops
+		// Accessing via subscripts
+		T& operator[](std::size_t i);
+		const T& operator[](std::size_t i) const;
+		// Arithmetic
+		inline Vector<T,2> operator-() const; 								// 	Negation
+		inline Vector<T,2> operator+( const Vector<T,2>& vector ) const; 	// 	Addition between two vectors
+		inline Vector<T,2> operator-( const Vector<T,2>& vector ) const; 	// 	Subtraction between two vectors
+		inline Vector<T,2> operator*( const Vector<T,2>& vector ) const; 	// 	Multiplication between two vectors
+		inline Vector<T,2> operator/( const Vector<T,2>& vector ) const; 	// 	Division between two vectors
+		inline Vector<T,2> operator*( T scalar ) const; 					// 	Multiplication with scalar
+		inline Vector<T,2> operator/( T scalar ) const; 					// 	Division with scalar
+		inline Vector<T,2>& operator +=( const Vector<T,2>& vector ); 		// 	Addition set between two vectors
+		inline Vector<T,2>& operator -=( const Vector<T,2>& vector ); 		// 	Subtraction set between two vectors
+		inline Vector<T,2>& operator *=( const Vector<T,2>& vector ); 		// 	Multiplication set between two vectors
+		inline Vector<T,2>& operator /=( const Vector<T,2>& vector ); 		// 	Division set between two vectors
+		inline Vector<T,2>& operator *=( T scalar ); 						// 	Multiplication set with scalar
+		inline Vector<T,2>& operator /=( T scalar ); 						// 	Division set with scalar
+		inline bool operator==( const Vector<T,2>& vector ) const; 			// 	Equality check between two vectors (equals)
+		inline bool operator!=( const Vector<T,2>& vector ) const; 			// 	Equality check between two vectors (not equals)
+		inline bool operator<( const Vector<T,2>& vector ) const; 			// 	Equality check between two vectors (less than)
+		inline bool operator<=( const Vector<T,2>& vector ) const; 			// 	Equality check between two vectors (less than or equals)
+		inline bool operator>( const Vector<T,2>& vector ) const; 			// 	Equality check between two vectors (greater than)
+		inline bool operator>=( const Vector<T,2>& vector ) const; 			// 	Equality check between two vectors (greater than or equals)
+		
+		inline operator pod_t&() { return this->m_pod; }
+		inline operator const pod_t&() const { return this->m_pod; }
+	};
+	template<typename T>
+	struct /*UF_API*/ Vector<T,3> {
+	public:
+	// 	Easily access POD's type
+		typedef pod::Vector<T,3> pod_t;
+	// 	Replicate POD information
+		typedef T type_t;
+		typedef T* container_t;
+		static const std::size_t size = 3;
+	protected:
+	// 	POD storage
+		Vector<T,3>::pod_t m_pod;
+	public:
+		T& x = m_pod.x;
+		T& y = m_pod.y;
+		T& z = m_pod.z;
+
+		T& r = m_pod.x;
+		T& g = m_pod.y;
+		T& b = m_pod.z;
+	public:
+	// 	C-tor
+		Vector(); 																		// initializes POD to 'def'
+		Vector(T def); 																	// initializes POD to 'def'
+		Vector(T x, T y, T z); 															// initializes POD to 'def'
+		Vector(const Vector<T,3>::pod_t& pod); 											// copies POD altogether
+		Vector(const T components[3]); 													// copies data into POD from 'components' (typed as C array)
+		Vector(const std::vector<T>& components); 										// copies data into POD from 'components' (typed as std::vector<T>)
+	// 	D-tor
+		// Unneccesary
+	// 	POD access
+		Vector<T,3>::pod_t& data(); 													// 	Returns a reference of POD
+		const Vector<T,3>::pod_t& data() const; 										// 	Returns a const-reference of POD
+	// 	Alternative POD access
+		T* get();																		// 	Returns a pointer to the entire array
+		const T* get() const; 															// 	Returns a const-pointer to the entire array
+		T& getComponent( std::size_t i );												// 	Returns a reference to a single element
+		const T& getComponent( std::size_t i ) const; 									// 	Returns a const-reference to a single element
+	// 	POD manipulation
+		T* set(const T components[3]);													// 	Sets the entire array
+		T& setComponent( std::size_t i, const T& value );								// 	Sets a single element
+	// 	Validation
+		bool isValid() const; 															// 	Checks if all components are valid (non NaN, inf, etc.)
+	// 	Basic arithmetic
+		inline uf::Vector<T,3>& add( const Vector<T, 3>& vector );						// 	Adds two vectors of same type and size together
+		inline uf::Vector<T,3>& subtract( const Vector<T, 3>& vector );					// 	Subtracts two vectors of same type and size together
+		inline uf::Vector<T,3>& multiply( const Vector<T, 3>& vector );					// 	Multiplies two vectors of same type and size together
+		inline uf::Vector<T,3>& multiply( T scalar );									// 	Multiplies this vector by a scalar
+		inline uf::Vector<T,3>& divide( const Vector<T, 3>& vector );					// 	Divides two vectors of same type and size together
+		inline uf::Vector<T,3>& divide( T scalar );										// 	Divides this vector by a scalar
+		inline T sum() const;															// 	Compute the sum of all components 
+		inline T product() const;														// 	Compute the product of all components 
+		inline uf::Vector<T,3>& negate();												// 	Flip sign of all components
+	// 	Complex arithmetic
+		inline T dot( const Vector<T,3> right ) const; 									// 	Compute the dot product between two vectors
+		inline pod::Angle angle( const Vector<T,3>& b ) const; 							// 	Compute the angle between two vectors
+		
+		inline uf::Vector<T,3> lerp( const Vector<T,3> to, double delta ) const; 		// 	Linearly interpolate between two vectors
+		inline uf::Vector<T,3> slerp( const Vector<T,3> to, double delta ) const; 		// 	Spherically interpolate between two vectors
+		
+		inline T distanceSquared( const Vector<T,3> b ) const; 							// 	Compute the distance between two vectors (doesn't sqrt)
+		inline T distance( const Vector<T,3> b ) const; 								// 	Compute the distance between two vectors
+		inline T magnitude() const; 													// 	Gets the magnitude of the vector
+		inline T norm() const; 															// 	Compute the norm of the vector
+		
+		inline uf::Vector<T,3>& normalize(); 											// 	Normalizes a vector
+		uf::Vector<T,3> getNormalized() const; 											// 	Return a normalized vector
+		inline std::string toString() const;
+	// 	Overloaded ops
+		// Accessing via subscripts
+		T& operator[](std::size_t i);
+		const T& operator[](std::size_t i) const;
+		// Arithmetic
+		inline Vector<T,3> operator-() const; 								// 	Negation
+		inline Vector<T,3> operator+( const Vector<T,3>& vector ) const; 	// 	Addition between two vectors
+		inline Vector<T,3> operator-( const Vector<T,3>& vector ) const; 	// 	Subtraction between two vectors
+		inline Vector<T,3> operator*( const Vector<T,3>& vector ) const; 	// 	Multiplication between two vectors
+		inline Vector<T,3> operator/( const Vector<T,3>& vector ) const; 	// 	Division between two vectors
+		inline Vector<T,3> operator*( T scalar ) const; 					// 	Multiplication with scalar
+		inline Vector<T,3> operator/( T scalar ) const; 					// 	Division with scalar
+		inline Vector<T,3>& operator +=( const Vector<T,3>& vector ); 		// 	Addition set between two vectors
+		inline Vector<T,3>& operator -=( const Vector<T,3>& vector ); 		// 	Subtraction set between two vectors
+		inline Vector<T,3>& operator *=( const Vector<T,3>& vector ); 		// 	Multiplication set between two vectors
+		inline Vector<T,3>& operator /=( const Vector<T,3>& vector ); 		// 	Division set between two vectors
+		inline Vector<T,3>& operator *=( T scalar ); 						// 	Multiplication set with scalar
+		inline Vector<T,3>& operator /=( T scalar ); 						// 	Division set with scalar
+		inline bool operator==( const Vector<T,3>& vector ) const; 			// 	Equality check between two vectors (equals)
+		inline bool operator!=( const Vector<T,3>& vector ) const; 			// 	Equality check between two vectors (not equals)
+		inline bool operator<( const Vector<T,3>& vector ) const; 			// 	Equality check between two vectors (less than)
+		inline bool operator<=( const Vector<T,3>& vector ) const; 			// 	Equality check between two vectors (less than or equals)
+		inline bool operator>( const Vector<T,3>& vector ) const; 			// 	Equality check between two vectors (greater than)
+		inline bool operator>=( const Vector<T,3>& vector ) const; 			// 	Equality check between two vectors (greater than or equals)
+		
+		inline operator pod_t&() { return this->m_pod; }
+		inline operator const pod_t&() const { return this->m_pod; }
+	};
+	template<typename T>
+	struct /*UF_API*/ Vector<T,4> {
+	public:
+	// 	Easily access POD's type
+		typedef pod::Vector<T,4> pod_t;
+	// 	Replicate POD information
+		typedef T type_t;
+		typedef T* container_t;
+		static const std::size_t size = 4;
+	protected:
+	// 	POD storage
+		Vector<T,4>::pod_t m_pod;
+	public:
+		T& x = m_pod.x;
+		T& y = m_pod.y;
+		T& z = m_pod.z;
+		T& w = m_pod.w;
+
+		T& r = m_pod.x;
+		T& g = m_pod.y;
+		T& b = m_pod.z;
+		T& a = m_pod.w;
+	public:
+	// 	C-tor
+		Vector(); 																		// initializes POD to 'def'
+		Vector(T def); 																	// initializes POD to 'def'
+		Vector(T x, T y, T z, T w); 													// initializes POD to 'def'
+		Vector(const Vector<T,4>::pod_t& pod); 											// copies POD altogether
+		Vector(const T components[4]); 													// copies data into POD from 'components' (typed as C array)
+		Vector(const std::vector<T>& components); 										// copies data into POD from 'components' (typed as std::vector<T>)
+	// 	D-tor
+		// Unneccesary
+	// 	POD access
+		Vector<T,4>::pod_t& data(); 													// 	Returns a reference of POD
+		const Vector<T,4>::pod_t& data() const; 										// 	Returns a const-reference of POD
+	// 	Alternative POD access
+		T* get();																		// 	Returns a pointer to the entire array
+		const T* get() const; 															// 	Returns a const-pointer to the entire array
+		T& getComponent( std::size_t i );												// 	Returns a reference to a single element
+		const T& getComponent( std::size_t i ) const; 									// 	Returns a const-reference to a single element
+	// 	POD manipulation
+		T* set(const T components[4]);													// 	Sets the entire array
+		T& setComponent( std::size_t i, const T& value );								// 	Sets a single element
+	// 	Validation
+		bool isValid() const; 															// 	Checks if all components are valid (non NaN, inf, etc.)
+	// 	Basic arithmetic
+		inline uf::Vector<T,4>& add( const Vector<T, 4>& vector );						// 	Adds two vectors of same type and size together
+		inline uf::Vector<T,4>& subtract( const Vector<T, 4>& vector );					// 	Subtracts two vectors of same type and size together
+		inline uf::Vector<T,4>& multiply( const Vector<T, 4>& vector );					// 	Multiplies two vectors of same type and size together
+		inline uf::Vector<T,4>& multiply( T scalar );									// 	Multiplies this vector by a scalar
+		inline uf::Vector<T,4>& divide( const Vector<T, 4>& vector );					// 	Divides two vectors of same type and size together
+		inline uf::Vector<T,4>& divide( T scalar );										// 	Divides this vector by a scalar
+		inline T sum() const;															// 	Compute the sum of all components 
+		inline T product() const;														// 	Compute the product of all components 
+		inline uf::Vector<T,4>& negate();												// 	Flip sign of all components
+	// 	Complex arithmetic
+		inline T dot( const Vector<T,4> right ) const; 									// 	Compute the dot product between two vectors
+		inline pod::Angle angle( const Vector<T,4>& b ) const; 							// 	Compute the angle between two vectors
+		
+		inline uf::Vector<T,4> lerp( const Vector<T,4> to, double delta ) const; 		// 	Linearly interpolate between two vectors
+		inline uf::Vector<T,4> slerp( const Vector<T,4> to, double delta ) const; 		// 	Spherically interpolate between two vectors
+		
+		inline T distanceSquared( const Vector<T,4> b ) const; 							// 	Compute the distance between two vectors (doesn't sqrt)
+		inline T distance( const Vector<T,4> b ) const; 								// 	Compute the distance between two vectors
+		inline T magnitude() const; 													// 	Gets the magnitude of the vector
+		inline T norm() const; 															// 	Compute the norm of the vector
+		
+		inline uf::Vector<T,4>& normalize(); 											// 	Normalizes a vector
+		uf::Vector<T,4> getNormalized() const; 											// 	Return a normalized vector
+		inline std::string toString() const;
+	// 	Overloaded ops
+		// Accessing via subscripts
+		T& operator[](std::size_t i);
+		const T& operator[](std::size_t i) const;
+		// Arithmetic
+		inline Vector<T,4> operator-() const; 								// 	Negation
+		inline Vector<T,4> operator+( const Vector<T,4>& vector ) const; 	// 	Addition between two vectors
+		inline Vector<T,4> operator-( const Vector<T,4>& vector ) const; 	// 	Subtraction between two vectors
+		inline Vector<T,4> operator*( const Vector<T,4>& vector ) const; 	// 	Multiplication between two vectors
+		inline Vector<T,4> operator/( const Vector<T,4>& vector ) const; 	// 	Division between two vectors
+		inline Vector<T,4> operator*( T scalar ) const; 					// 	Multiplication with scalar
+		inline Vector<T,4> operator/( T scalar ) const; 					// 	Division with scalar
+		inline Vector<T,4>& operator +=( const Vector<T,4>& vector ); 		// 	Addition set between two vectors
+		inline Vector<T,4>& operator -=( const Vector<T,4>& vector ); 		// 	Subtraction set between two vectors
+		inline Vector<T,4>& operator *=( const Vector<T,4>& vector ); 		// 	Multiplication set between two vectors
+		inline Vector<T,4>& operator /=( const Vector<T,4>& vector ); 		// 	Division set between two vectors
+		inline Vector<T,4>& operator *=( T scalar ); 						// 	Multiplication set with scalar
+		inline Vector<T,4>& operator /=( T scalar ); 						// 	Division set with scalar
+		inline bool operator==( const Vector<T,4>& vector ) const; 			// 	Equality check between two vectors (equals)
+		inline bool operator!=( const Vector<T,4>& vector ) const; 			// 	Equality check between two vectors (not equals)
+		inline bool operator<( const Vector<T,4>& vector ) const; 			// 	Equality check between two vectors (less than)
+		inline bool operator<=( const Vector<T,4>& vector ) const; 			// 	Equality check between two vectors (less than or equals)
+		inline bool operator>( const Vector<T,4>& vector ) const; 			// 	Equality check between two vectors (greater than)
+		inline bool operator>=( const Vector<T,4>& vector ) const; 			// 	Equality check between two vectors (greater than or equals)
+		
+		inline operator pod_t&() { return this->m_pod; }
+		inline operator const pod_t&() const { return this->m_pod; }
+	};
+}
+// 	C-tor
+template<typename T> 														// initializes POD to 'def'
+uf::Vector<T,1>::Vector() {
+}
+template<typename T> 														// initializes POD to 'def'
+uf::Vector<T,1>::Vector(T def) {
+	for ( std::size_t i = 0; i < 1; ++i ) this->m_pod[i] = def;
+}
+template<typename T> 														// initializes POD to 'def'
+uf::Vector<T,1>::Vector(T x, T y) {
+	this->m_pod.x = x;
+	this->m_pod.y = y;
+}
+template<typename T> 														// copies POD altogether
+uf::Vector<T,1>::Vector(const typename uf::Vector<T,1>::pod_t& pod) : m_pod(pod) {
+}
+template<typename T> 														// copies data into POD from 'components' (typed as C array)
+uf::Vector<T,1>::Vector(const T components[1]) {
+	this->set(&components[0]);
+}
+template<typename T> 														// copies data into POD from 'components' (typed as std::vector<T>)
+uf::Vector<T,1>::Vector(const std::vector<T>& components) {
+	if ( components.size() >= 1 ) this->set(&components[0]);
+}
+// 	D-tor
+// Unneccesary
+// 	POD access
+template<typename T> 														// 	Returns a reference of POD
+typename uf::Vector<T,1>::pod_t& uf::Vector<T,1>::data() {
+	return this->m_pod;
+}
+template<typename T> 														// 	Returns a const-reference of POD
+const typename uf::Vector<T,1>::pod_t& uf::Vector<T,1>::data() const {
+	return this->m_pod;
+}
+// 	Alternative POD access
+template<typename T> 														// 	Returns a pointer to the entire array
+T* uf::Vector<T,1>::get() {
+	return &this->m_pod[0];
+}
+template<typename T> 														// 	Returns a const-pointer to the entire array
+const T* uf::Vector<T,1>::get() const {
+	return &this->m_pod[0];
+}
+template<typename T> 														// 	Returns a reference to a single element
+T& uf::Vector<T,1>::getComponent( std::size_t i ) {
+	if ( i >= 1 ) return NULL;
+	return this->m_pod[i];
+}
+template<typename T> 														// 	Returns a const-reference to a single element
+const T& uf::Vector<T,1>::getComponent( std::size_t i ) const {
+	if ( i >= 1 ) return NULL;
+	return this->m_pod[i];
+}
+// 	POD manipulation
+template<typename T> 														// 	Sets the entire array
+T* uf::Vector<T,1>::set(const T components[1]) {
+	for ( std::size_t i = 0; i < 1; ++i ) this->m_pod[i] = components[i];
+	return &this->m_pod[0];
+}
+template<typename T> 														// 	Sets a single element
+T& uf::Vector<T,1>::setComponent( std::size_t i, const T& value ) {
+	this->m_pod[i] = value;
+}
+// 	Validation
+template<typename T> 														// 	Checks if all components are valid (non NaN, inf, etc.)
+bool uf::Vector<T,1>::isValid() const {
+	for ( std::size_t i = 0; i < 1; ++i ) if ( this->m_pod[i] != this->m_pod[i] ) return false;
+	return true;
+}
+// 	Basic arithmetic
+template<typename T> 														// 	Adds two vectors of same type and size together
+inline uf::Vector<T,1>& uf::Vector<T,1>::add( const uf::Vector<T, 1>& vector ) {
+	return uf::vector::add( this->m_pod, vector.data() );
+}
+template<typename T> 														// 	Subtracts two vectors of same type and size together
+inline uf::Vector<T,1>& uf::Vector<T,1>::subtract( const uf::Vector<T, 1>& vector ) {
+	return uf::vector::subtract( this->m_pod, vector.data() );
+}
+template<typename T> 														// 	Multiplies two vectors of same type and size together
+inline uf::Vector<T,1>& uf::Vector<T,1>::multiply( const uf::Vector<T, 1>& vector ) {
+	return uf::vector::multiply( this->m_pod, vector.data() );
+}
+template<typename T> 														// 	Multiplies this vector by a scalar
+inline uf::Vector<T,1>& uf::Vector<T,1>::multiply( T scalar ) {
+	return uf::vector::multiply( this->m_pod, scalar );
+}
+template<typename T> 														// 	Divides two vectors of same type and size together
+inline uf::Vector<T,1>& uf::Vector<T,1>::divide( const uf::Vector<T, 1>& vector ) {
+	return uf::vector::divide( this->m_pod, vector.data() );
+}
+template<typename T> 														// 	Divides this vector by a scalar
+inline uf::Vector<T,1>& uf::Vector<T,1>::divide( T scalar ) {
+	return uf::vector::divide( this->m_pod, scalar );
+}
+template<typename T> 														// 	Compute the sum of all components 
+inline T uf::Vector<T,1>::sum() const {
+	return uf::vector::sum( this->m_pod );
+}
+template<typename T> 														// 	Compute the product of all components 
+inline T uf::Vector<T,1>::product() const {
+	return uf::vector::product( this->m_pod );
+}
+template<typename T> 														// 	Flip sign of all components
+inline uf::Vector<T,1>& uf::Vector<T,1>::negate() {
+	return uf::vector::negate( this->m_pod );
+}
+// 	Complex arithmetic
+template<typename T> 														// 	Compute the dot product between two vectors
+inline T uf::Vector<T,1>::dot( const uf::Vector<T,1> right ) const {
+	return uf::vector::dot( this->m_pod, right );
+}
+template<typename T> 														// 	Compute the angle between two vectors
+inline pod::Angle uf::Vector<T,1>::angle( const uf::Vector<T,1>& b ) const {
+	return uf::vector::angle( this->m_pod, b );
+}
+
+template<typename T> 														// 	Linearly interpolate between two vectors
+inline uf::Vector<T,1> uf::Vector<T,1>::lerp( const uf::Vector<T,1> to, double delta ) const {
+	return uf::vector::lerp( this->m_pod, to, delta );
+}
+template<typename T> 														// 	Spherically interpolate between two vectors
+inline uf::Vector<T,1> uf::Vector<T,1>::slerp( const uf::Vector<T,1> to, double delta ) const {
+	return uf::vector::slerp( this->m_pod, to, delta );
+}
+
+template<typename T> 														// 	Compute the distance between two vectors (doesn't sqrt)
+inline T uf::Vector<T,1>::distanceSquared( const uf::Vector<T,1> b ) const {
+	return uf::vector::distanceSquared( this->m_pod, b );
+}
+template<typename T> 														// 	Compute the distance between two vectors
+inline T uf::Vector<T,1>::distance( const uf::Vector<T,1> b ) const {
+	return uf::vector::distance( this->m_pod, b );
+}
+template<typename T> 														// 	Gets the magnitude of the vector
+inline T uf::Vector<T,1>::magnitude() const {
+	return uf::vector::magnitude( this->m_pod );
+}
+template<typename T> 														// 	Compute the norm of the vector
+inline T uf::Vector<T,1>::norm() const {
+	return uf::vector::norm( this->m_pod );
+}
+
+template<typename T> 														// 	Normalizes a vector
+inline uf::Vector<T,1>& uf::Vector<T,1>::normalize() {
+	return uf::vector::normalize( this->m_pod );
+}
+template<typename T> 														// 	Return a normalized vector
+uf::Vector<T,1> uf::Vector<T,1>::getNormalized() const {
+	return uf::vector::normalize( this->m_pod );
+}
+template<typename T> 														// 	Return a string
+std::string uf::Vector<T,1>::toString() const {
+	return uf::vector::toString( this->m_pod );
+}
+// Overloaded ops
+template<typename T> 
+T& uf::Vector<T,1>::operator[](std::size_t i) {
+	if ( i >= 1 ) return NULL;
+	return this->m_pod[i];
+}
+template<typename T> 
+const T& uf::Vector<T,1>::operator[](std::size_t i) const {
+	if ( i >= 1 ) return NULL;
+	return this->m_pod[i];
+}
+// Arithmetic
+template<typename T>  															// 	Negation
+inline uf::Vector<T,1> uf::Vector<T,1>::operator-() const {
+	return uf::vector::negate( this->m_pod );
+}			
+template<typename T>  															// 	Addition between two vectors
+inline uf::Vector<T,1> uf::Vector<T,1>::operator+( const uf::Vector<T,1>& vector ) const {
+	return uf::vector::add( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Subtraction between two vectors
+inline uf::Vector<T,1> uf::Vector<T,1>::operator-( const uf::Vector<T,1>& vector ) const {
+	return uf::vector::subtract( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Multiplication between two vectors
+inline uf::Vector<T,1> uf::Vector<T,1>::operator*( const uf::Vector<T,1>& vector ) const {
+	return uf::vector::multiply( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Division between two vectors
+inline uf::Vector<T,1> uf::Vector<T,1>::operator/( const uf::Vector<T,1>& vector ) const {
+	return uf::vector::divide( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Multiplication with scalar
+inline uf::Vector<T,1> uf::Vector<T,1>::operator*( T scalar ) const {
+	return uf::vector::multiply( this->m_pod, scalar );
+}
+template<typename T>  															// 	Division with scalar
+inline uf::Vector<T,1> uf::Vector<T,1>::operator/( T scalar ) const {
+	return uf::vector::divide( this->m_pod, scalar );
+}
+template<typename T>  															// 	Addition set between two vectors
+inline uf::Vector<T,1>& uf::Vector<T,1>::operator +=( const uf::Vector<T,1>& vector ) {
+	return uf::vector::add( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Subtraction set between two vectors
+inline uf::Vector<T,1>& uf::Vector<T,1>::operator -=( const uf::Vector<T,1>& vector ) {
+	return uf::vector::subtract( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Multiplication set between two vectors
+inline uf::Vector<T,1>& uf::Vector<T,1>::operator *=( const uf::Vector<T,1>& vector ) {
+	return uf::vector::multiply( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Division set between two vectors
+inline uf::Vector<T,1>& uf::Vector<T,1>::operator /=( const uf::Vector<T,1>& vector ) {
+	return uf::vector::divide( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Multiplication set with scalar
+inline uf::Vector<T,1>& uf::Vector<T,1>::operator *=( T scalar ) {
+	return uf::vector::multiply( this->m_pod, scalar );
+}
+template<typename T>  															// 	Division set with scalar
+inline uf::Vector<T,1>& uf::Vector<T,1>::operator /=( T scalar ) {
+	return uf::vector::divide( this->m_pod, scalar );
+}
+template<typename T>  															// 	Equality check between two vectors (equals)
+inline bool uf::Vector<T,1>::operator==( const uf::Vector<T,1>& vector ) const {
+	return uf::vector::equals(this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Equality check between two vectors (not equals)
+inline bool uf::Vector<T,1>::operator!=( const uf::Vector<T,1>& vector ) const {
+	return !uf::vector::equals(this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Equality check between two vectors (less than)
+inline bool uf::Vector<T,1>::operator<( const uf::Vector<T,1>& vector ) const {
+	return uf::vector::compareTo(this->m_pod, vector.data() ) < 0;
+}
+template<typename T>  															// 	Equality check between two vectors (less than or equals)
+inline bool uf::Vector<T,1>::operator<=( const uf::Vector<T,1>& vector ) const {
+	return uf::vector::compareTo(this->m_pod, vector.data() ) <= 0;
+}
+template<typename T>  															// 	Equality check between two vectors (greater than)
+inline bool uf::Vector<T,1>::operator>( const uf::Vector<T,1>& vector ) const {
+	return uf::vector::compareTo(this->m_pod, vector.data() ) > 0;
+}
+template<typename T>  															// 	Equality check between two vectors (greater than or equals)
+inline bool uf::Vector<T,1>::operator>=( const uf::Vector<T,1>& vector ) const {
+	return uf::vector::compareTo(this->m_pod, vector.data() ) >= 0;
+}
+// 	C-tor
+template<typename T> 														// initializes POD to 'def'
+uf::Vector<T,2>::Vector() {
+}
+template<typename T> 														// initializes POD to 'def'
+uf::Vector<T,2>::Vector(T def) {
+	for ( std::size_t i = 0; i < 2; ++i ) this->m_pod[i] = def;
+}
+template<typename T> 														// initializes POD to 'def'
+uf::Vector<T,2>::Vector(T x, T y) {
+	this->m_pod.x = x;
+	this->m_pod.y = y;
+}
+template<typename T> 														// copies POD altogether
+uf::Vector<T,2>::Vector(const typename uf::Vector<T,2>::pod_t& pod) : m_pod(pod) {
+}
+template<typename T> 														// copies data into POD from 'components' (typed as C array)
+uf::Vector<T,2>::Vector(const T components[2]) {
+	this->set(&components[0]);
+}
+template<typename T> 														// copies data into POD from 'components' (typed as std::vector<T>)
+uf::Vector<T,2>::Vector(const std::vector<T>& components) {
+	if ( components.size() >= 2 ) this->set(&components[0]);
+}
+// 	D-tor
+// Unneccesary
+// 	POD access
+template<typename T> 														// 	Returns a reference of POD
+typename uf::Vector<T,2>::pod_t& uf::Vector<T,2>::data() {
+	return this->m_pod;
+}
+template<typename T> 														// 	Returns a const-reference of POD
+const typename uf::Vector<T,2>::pod_t& uf::Vector<T,2>::data() const {
+	return this->m_pod;
+}
+// 	Alternative POD access
+template<typename T> 														// 	Returns a pointer to the entire array
+T* uf::Vector<T,2>::get() {
+	return &this->m_pod[0];
+}
+template<typename T> 														// 	Returns a const-pointer to the entire array
+const T* uf::Vector<T,2>::get() const {
+	return &this->m_pod[0];
+}
+template<typename T> 														// 	Returns a reference to a single element
+T& uf::Vector<T,2>::getComponent( std::size_t i ) {
+	if ( i >= 2 ) return NULL;
+	return this->m_pod[i];
+}
+template<typename T> 														// 	Returns a const-reference to a single element
+const T& uf::Vector<T,2>::getComponent( std::size_t i ) const {
+	if ( i >= 2 ) return NULL;
+	return this->m_pod[i];
+}
+// 	POD manipulation
+template<typename T> 														// 	Sets the entire array
+T* uf::Vector<T,2>::set(const T components[2]) {
+	for ( std::size_t i = 0; i < 2; ++i ) this->m_pod[i] = components[i];
+	return &this->m_pod[0];
+}
+template<typename T> 														// 	Sets a single element
+T& uf::Vector<T,2>::setComponent( std::size_t i, const T& value ) {
+	this->m_pod[i] = value;
+}
+// 	Validation
+template<typename T> 														// 	Checks if all components are valid (non NaN, inf, etc.)
+bool uf::Vector<T,2>::isValid() const {
+	for ( std::size_t i = 0; i < 2; ++i ) if ( this->m_pod[i] != this->m_pod[i] ) return false;
+	return true;
+}
+// 	Basic arithmetic
+template<typename T> 														// 	Adds two vectors of same type and size together
+inline uf::Vector<T,2>& uf::Vector<T,2>::add( const uf::Vector<T, 2>& vector ) {
+	return uf::vector::add( this->m_pod, vector.data() );
+}
+template<typename T> 														// 	Subtracts two vectors of same type and size together
+inline uf::Vector<T,2>& uf::Vector<T,2>::subtract( const uf::Vector<T, 2>& vector ) {
+	return uf::vector::subtract( this->m_pod, vector.data() );
+}
+template<typename T> 														// 	Multiplies two vectors of same type and size together
+inline uf::Vector<T,2>& uf::Vector<T,2>::multiply( const uf::Vector<T, 2>& vector ) {
+	return uf::vector::multiply( this->m_pod, vector.data() );
+}
+template<typename T> 														// 	Multiplies this vector by a scalar
+inline uf::Vector<T,2>& uf::Vector<T,2>::multiply( T scalar ) {
+	return uf::vector::multiply( this->m_pod, scalar );
+}
+template<typename T> 														// 	Divides two vectors of same type and size together
+inline uf::Vector<T,2>& uf::Vector<T,2>::divide( const uf::Vector<T, 2>& vector ) {
+	return uf::vector::divide( this->m_pod, vector.data() );
+}
+template<typename T> 														// 	Divides this vector by a scalar
+inline uf::Vector<T,2>& uf::Vector<T,2>::divide( T scalar ) {
+	return uf::vector::divide( this->m_pod, scalar );
+}
+template<typename T> 														// 	Compute the sum of all components 
+inline T uf::Vector<T,2>::sum() const {
+	return uf::vector::sum( this->m_pod );
+}
+template<typename T> 														// 	Compute the product of all components 
+inline T uf::Vector<T,2>::product() const {
+	return uf::vector::product( this->m_pod );
+}
+template<typename T> 														// 	Flip sign of all components
+inline uf::Vector<T,2>& uf::Vector<T,2>::negate() {
+	return uf::vector::negate( this->m_pod );
+}
+// 	Complex arithmetic
+template<typename T> 														// 	Compute the dot product between two vectors
+inline T uf::Vector<T,2>::dot( const uf::Vector<T,2> right ) const {
+	return uf::vector::dot( this->m_pod, right );
+}
+template<typename T> 														// 	Compute the angle between two vectors
+inline pod::Angle uf::Vector<T,2>::angle( const uf::Vector<T,2>& b ) const {
+	return uf::vector::angle( this->m_pod, b );
+}
+
+template<typename T> 														// 	Linearly interpolate between two vectors
+inline uf::Vector<T,2> uf::Vector<T,2>::lerp( const uf::Vector<T,2> to, double delta ) const {
+	return uf::vector::lerp( this->m_pod, to, delta );
+}
+template<typename T> 														// 	Spherically interpolate between two vectors
+inline uf::Vector<T,2> uf::Vector<T,2>::slerp( const uf::Vector<T,2> to, double delta ) const {
+	return uf::vector::slerp( this->m_pod, to, delta );
+}
+
+template<typename T> 														// 	Compute the distance between two vectors (doesn't sqrt)
+inline T uf::Vector<T,2>::distanceSquared( const uf::Vector<T,2> b ) const {
+	return uf::vector::distanceSquared( this->m_pod, b );
+}
+template<typename T> 														// 	Compute the distance between two vectors
+inline T uf::Vector<T,2>::distance( const uf::Vector<T,2> b ) const {
+	return uf::vector::distance( this->m_pod, b );
+}
+template<typename T> 														// 	Gets the magnitude of the vector
+inline T uf::Vector<T,2>::magnitude() const {
+	return uf::vector::magnitude( this->m_pod );
+}
+template<typename T> 														// 	Compute the norm of the vector
+inline T uf::Vector<T,2>::norm() const {
+	return uf::vector::norm( this->m_pod );
+}
+
+template<typename T> 														// 	Normalizes a vector
+inline uf::Vector<T,2>& uf::Vector<T,2>::normalize() {
+	return uf::vector::normalize( this->m_pod );
+}
+template<typename T> 														// 	Return a normalized vector
+uf::Vector<T,2> uf::Vector<T,2>::getNormalized() const {
+	return uf::vector::normalize( this->m_pod );
+}
+template<typename T> 														// 	Return a string
+std::string uf::Vector<T,2>::toString() const {
+	return uf::vector::toString( this->m_pod );
+}
+// Overloaded ops
+template<typename T> 
+T& uf::Vector<T,2>::operator[](std::size_t i) {
+	if ( i >= 2 ) return NULL;
+	return this->m_pod[i];
+}
+template<typename T> 
+const T& uf::Vector<T,2>::operator[](std::size_t i) const {
+	if ( i >= 2 ) return NULL;
+	return this->m_pod[i];
+}
+// Arithmetic
+template<typename T>  															// 	Negation
+inline uf::Vector<T,2> uf::Vector<T,2>::operator-() const {
+	return uf::vector::negate( this->m_pod );
+}			
+template<typename T>  															// 	Addition between two vectors
+inline uf::Vector<T,2> uf::Vector<T,2>::operator+( const uf::Vector<T,2>& vector ) const {
+	return uf::vector::add( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Subtraction between two vectors
+inline uf::Vector<T,2> uf::Vector<T,2>::operator-( const uf::Vector<T,2>& vector ) const {
+	return uf::vector::subtract( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Multiplication between two vectors
+inline uf::Vector<T,2> uf::Vector<T,2>::operator*( const uf::Vector<T,2>& vector ) const {
+	return uf::vector::multiply( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Division between two vectors
+inline uf::Vector<T,2> uf::Vector<T,2>::operator/( const uf::Vector<T,2>& vector ) const {
+	return uf::vector::divide( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Multiplication with scalar
+inline uf::Vector<T,2> uf::Vector<T,2>::operator*( T scalar ) const {
+	return uf::vector::multiply( this->m_pod, scalar );
+}
+template<typename T>  															// 	Division with scalar
+inline uf::Vector<T,2> uf::Vector<T,2>::operator/( T scalar ) const {
+	return uf::vector::divide( this->m_pod, scalar );
+}
+template<typename T>  															// 	Addition set between two vectors
+inline uf::Vector<T,2>& uf::Vector<T,2>::operator +=( const uf::Vector<T,2>& vector ) {
+	return uf::vector::add( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Subtraction set between two vectors
+inline uf::Vector<T,2>& uf::Vector<T,2>::operator -=( const uf::Vector<T,2>& vector ) {
+	return uf::vector::subtract( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Multiplication set between two vectors
+inline uf::Vector<T,2>& uf::Vector<T,2>::operator *=( const uf::Vector<T,2>& vector ) {
+	return uf::vector::multiply( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Division set between two vectors
+inline uf::Vector<T,2>& uf::Vector<T,2>::operator /=( const uf::Vector<T,2>& vector ) {
+	return uf::vector::divide( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Multiplication set with scalar
+inline uf::Vector<T,2>& uf::Vector<T,2>::operator *=( T scalar ) {
+	return uf::vector::multiply( this->m_pod, scalar );
+}
+template<typename T>  															// 	Division set with scalar
+inline uf::Vector<T,2>& uf::Vector<T,2>::operator /=( T scalar ) {
+	return uf::vector::divide( this->m_pod, scalar );
+}
+template<typename T>  															// 	Equality check between two vectors (equals)
+inline bool uf::Vector<T,2>::operator==( const uf::Vector<T,2>& vector ) const {
+	return uf::vector::equals(this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Equality check between two vectors (not equals)
+inline bool uf::Vector<T,2>::operator!=( const uf::Vector<T,2>& vector ) const {
+	return !uf::vector::equals(this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Equality check between two vectors (less than)
+inline bool uf::Vector<T,2>::operator<( const uf::Vector<T,2>& vector ) const {
+	return uf::vector::compareTo(this->m_pod, vector.data() ) < 0;
+}
+template<typename T>  															// 	Equality check between two vectors (less than or equals)
+inline bool uf::Vector<T,2>::operator<=( const uf::Vector<T,2>& vector ) const {
+	return uf::vector::compareTo(this->m_pod, vector.data() ) <= 0;
+}
+template<typename T>  															// 	Equality check between two vectors (greater than)
+inline bool uf::Vector<T,2>::operator>( const uf::Vector<T,2>& vector ) const {
+	return uf::vector::compareTo(this->m_pod, vector.data() ) > 0;
+}
+template<typename T>  															// 	Equality check between two vectors (greater than or equals)
+inline bool uf::Vector<T,2>::operator>=( const uf::Vector<T,2>& vector ) const {
+	return uf::vector::compareTo(this->m_pod, vector.data() ) >= 0;
+}
+//
+// 	C-tor
+template<typename T> 														// initializes POD to 'def'
+uf::Vector<T,3>::Vector() {
+}
+template<typename T> 														// initializes POD to 'def'
+uf::Vector<T,3>::Vector(T def) {
+	for ( std::size_t i = 0; i < 3; ++i ) this->m_pod[i] = def;
+}
+template<typename T> 														// initializes POD to 'def'
+uf::Vector<T,3>::Vector(T x, T y, T z) {
+	this->m_pod.x = x;
+	this->m_pod.y = y;
+	this->m_pod.z = z;
+}
+template<typename T> 														// copies POD altogether
+uf::Vector<T,3>::Vector(const typename uf::Vector<T,3>::pod_t& pod) : m_pod(pod) {
+}
+template<typename T> 														// copies data into POD from 'components' (typed as C array)
+uf::Vector<T,3>::Vector(const T components[3]) {
+	this->set(&components[0]);
+}
+template<typename T> 														// copies data into POD from 'components' (typed as std::vector<T>)
+uf::Vector<T,3>::Vector(const std::vector<T>& components) {
+	if ( components.size() >= 3 ) this->set(&components[0]);
+}
+// 	D-tor
+// Unneccesary
+// 	POD access
+template<typename T> 														// 	Returns a reference of POD
+typename uf::Vector<T,3>::pod_t& uf::Vector<T,3>::data() {
+	return this->m_pod;
+}
+template<typename T> 														// 	Returns a const-reference of POD
+const typename uf::Vector<T,3>::pod_t& uf::Vector<T,3>::data() const {
+	return this->m_pod;
+}
+// 	Alternative POD access
+template<typename T> 														// 	Returns a pointer to the entire array
+T* uf::Vector<T,3>::get() {
+	return &this->m_pod[0];
+}
+template<typename T> 														// 	Returns a const-pointer to the entire array
+const T* uf::Vector<T,3>::get() const {
+	return &this->m_pod[0];
+}
+template<typename T> 														// 	Returns a reference to a single element
+T& uf::Vector<T,3>::getComponent( std::size_t i ) {
+	if ( i >= 3 ) return NULL;
+	return this->m_pod[i];
+}
+template<typename T> 														// 	Returns a const-reference to a single element
+const T& uf::Vector<T,3>::getComponent( std::size_t i ) const {
+	if ( i >= 3 ) return NULL;
+	return this->m_pod[i];
+}
+// 	POD manipulation
+template<typename T> 														// 	Sets the entire array
+T* uf::Vector<T,3>::set(const T components[3]) {
+	for ( std::size_t i = 0; i < 3; ++i ) this->m_pod[i] = components[i];
+	return &this->m_pod[0];
+}
+template<typename T> 														// 	Sets a single element
+T& uf::Vector<T,3>::setComponent( std::size_t i, const T& value ) {
+	this->m_pod[i] = value;
+}
+// 	Validation
+template<typename T> 														// 	Checks if all components are valid (non NaN, inf, etc.)
+bool uf::Vector<T,3>::isValid() const {
+	for ( std::size_t i = 0; i < 3; ++i ) if ( this->m_pod[i] != this->m_pod[i] ) return false;
+	return true;
+}
+// 	Basic arithmetic
+template<typename T> 														// 	Adds two vectors of same type and size together
+inline uf::Vector<T,3>& uf::Vector<T,3>::add( const uf::Vector<T,3>& vector ) {
+	return uf::vector::add( this->m_pod, vector.data() );
+}
+template<typename T> 														// 	Subtracts two vectors of same type and size together
+inline uf::Vector<T,3>& uf::Vector<T,3>::subtract( const uf::Vector<T,3>& vector ) {
+	return uf::vector::subtract( this->m_pod, vector.data() );
+}
+template<typename T> 														// 	Multiplies two vectors of same type and size together
+inline uf::Vector<T,3>& uf::Vector<T,3>::multiply( const uf::Vector<T,3>& vector ) {
+	return uf::vector::multiply( this->m_pod, vector.data() );
+}
+template<typename T> 														// 	Multiplies this vector by a scalar
+inline uf::Vector<T,3>& uf::Vector<T,3>::multiply( T scalar ) {
+	return uf::vector::multiply( this->m_pod, scalar );
+}
+template<typename T> 														// 	Divides two vectors of same type and size together
+inline uf::Vector<T,3>& uf::Vector<T,3>::divide( const uf::Vector<T,3>& vector ) {
+	return uf::vector::divide( this->m_pod, vector.data() );
+}
+template<typename T> 														// 	Divides this vector by a scalar
+inline uf::Vector<T,3>& uf::Vector<T,3>::divide( T scalar ) {
+	return uf::vector::divide( this->m_pod, scalar );
+}
+template<typename T> 														// 	Compute the sum of all components 
+inline T uf::Vector<T,3>::sum() const {
+	return uf::vector::sum( this->m_pod );
+}
+template<typename T> 														// 	Compute the product of all components 
+inline T uf::Vector<T,3>::product() const {
+	return uf::vector::product( this->m_pod );
+}
+template<typename T> 														// 	Flip sign of all components
+inline uf::Vector<T,3>& uf::Vector<T,3>::negate() {
+	return uf::vector::negate( this->m_pod );
+}
+// 	Complex arithmetic
+template<typename T> 														// 	Compute the dot product between two vectors
+inline T uf::Vector<T,3>::dot( const uf::Vector<T,3> right ) const {
+	return uf::vector::dot( this->m_pod, right );
+}
+template<typename T> 														// 	Compute the angle between two vectors
+inline pod::Angle uf::Vector<T,3>::angle( const uf::Vector<T,3>& b ) const {
+	return uf::vector::angle( this->m_pod, b );
+}
+
+template<typename T> 														// 	Linearly interpolate between two vectors
+inline uf::Vector<T,3> uf::Vector<T,3>::lerp( const uf::Vector<T,3> to, double delta ) const {
+	return uf::vector::lerp( this->m_pod, to, delta );
+}
+template<typename T> 														// 	Spherically interpolate between two vectors
+inline uf::Vector<T,3> uf::Vector<T,3>::slerp( const uf::Vector<T,3> to, double delta ) const {
+	return uf::vector::slerp( this->m_pod, to, delta );
+}
+
+template<typename T> 														// 	Compute the distance between two vectors (doesn't sqrt)
+inline T uf::Vector<T,3>::distanceSquared( const uf::Vector<T,3> b ) const {
+	return uf::vector::distanceSquared( this->m_pod, b );
+}
+template<typename T> 														// 	Compute the distance between two vectors
+inline T uf::Vector<T,3>::distance( const uf::Vector<T,3> b ) const {
+	return uf::vector::distance( this->m_pod, b );
+}
+template<typename T> 														// 	Gets the magnitude of the vector
+inline T uf::Vector<T,3>::magnitude() const {
+	return uf::vector::magnitude( this->m_pod );
+}
+template<typename T> 														// 	Compute the norm of the vector
+inline T uf::Vector<T,3>::norm() const {
+	return uf::vector::norm( this->m_pod );
+}
+
+template<typename T> 														// 	Normalizes a vector
+inline uf::Vector<T,3>& uf::Vector<T,3>::normalize() {
+	return uf::vector::normalize( this->m_pod );
+}
+template<typename T> 														// 	Return a normalized vector
+uf::Vector<T,3> uf::Vector<T,3>::getNormalized() const {
+	return uf::vector::normalize( this->m_pod );
+}
+template<typename T> 														// 	Return a string
+std::string uf::Vector<T,3>::toString() const {
+	return uf::vector::toString( this->m_pod );
+}
+// Overloaded ops
+template<typename T> 
+T& uf::Vector<T,3>::operator[](std::size_t i) {
+	if ( i >= 3 ) return NULL;
+	return this->m_pod[i];
+}
+template<typename T> 
+const T& uf::Vector<T,3>::operator[](std::size_t i) const {
+	if ( i >= 3 ) return NULL;
+	return this->m_pod[i];
+}
+// Arithmetic
+template<typename T>  															// 	Negation
+inline uf::Vector<T,3> uf::Vector<T,3>::operator-() const {
+	return uf::vector::negate( this->m_pod );
+}			
+template<typename T>  															// 	Addition between two vectors
+inline uf::Vector<T,3> uf::Vector<T,3>::operator+( const uf::Vector<T,3>& vector ) const {
+	return uf::vector::add( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Subtraction between two vectors
+inline uf::Vector<T,3> uf::Vector<T,3>::operator-( const uf::Vector<T,3>& vector ) const {
+	return uf::vector::subtract( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Multiplication between two vectors
+inline uf::Vector<T,3> uf::Vector<T,3>::operator*( const uf::Vector<T,3>& vector ) const {
+	return uf::vector::multiply( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Division between two vectors
+inline uf::Vector<T,3> uf::Vector<T,3>::operator/( const uf::Vector<T,3>& vector ) const {
+	return uf::vector::divide( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Multiplication with scalar
+inline uf::Vector<T,3> uf::Vector<T,3>::operator*( T scalar ) const {
+	return uf::vector::multiply( this->m_pod, scalar );
+}
+template<typename T>  															// 	Division with scalar
+inline uf::Vector<T,3> uf::Vector<T,3>::operator/( T scalar ) const {
+	return uf::vector::divide( this->m_pod, scalar );
+}
+template<typename T>  															// 	Addition set between two vectors
+inline uf::Vector<T,3>& uf::Vector<T,3>::operator +=( const uf::Vector<T,3>& vector ) {
+	return uf::vector::add( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Subtraction set between two vectors
+inline uf::Vector<T,3>& uf::Vector<T,3>::operator -=( const uf::Vector<T,3>& vector ) {
+	return uf::vector::subtract( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Multiplication set between two vectors
+inline uf::Vector<T,3>& uf::Vector<T,3>::operator *=( const uf::Vector<T,3>& vector ) {
+	return uf::vector::multiply( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Division set between two vectors
+inline uf::Vector<T,3>& uf::Vector<T,3>::operator /=( const uf::Vector<T,3>& vector ) {
+	return uf::vector::divide( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Multiplication set with scalar
+inline uf::Vector<T,3>& uf::Vector<T,3>::operator *=( T scalar ) {
+	return uf::vector::multiply( this->m_pod, scalar );
+}
+template<typename T>  															// 	Division set with scalar
+inline uf::Vector<T,3>& uf::Vector<T,3>::operator /=( T scalar ) {
+	return uf::vector::divide( this->m_pod, scalar );
+}
+template<typename T>  															// 	Equality check between two vectors (equals)
+inline bool uf::Vector<T,3>::operator==( const uf::Vector<T,3>& vector ) const {
+	return uf::vector::equals(this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Equality check between two vectors (not equals)
+inline bool uf::Vector<T,3>::operator!=( const uf::Vector<T,3>& vector ) const {
+	return !uf::vector::equals(this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Equality check between two vectors (less than)
+inline bool uf::Vector<T,3>::operator<( const uf::Vector<T,3>& vector ) const {
+	return uf::vector::compareTo(this->m_pod, vector.data() ) < 0;
+}
+template<typename T>  															// 	Equality check between two vectors (less than or equals)
+inline bool uf::Vector<T,3>::operator<=( const uf::Vector<T,3>& vector ) const {
+	return uf::vector::compareTo(this->m_pod, vector.data() ) <= 0;
+}
+template<typename T>  															// 	Equality check between two vectors (greater than)
+inline bool uf::Vector<T,3>::operator>( const uf::Vector<T,3>& vector ) const {
+	return uf::vector::compareTo(this->m_pod, vector.data() ) > 0;
+}
+template<typename T>  															// 	Equality check between two vectors (greater than or equals)
+inline bool uf::Vector<T,3>::operator>=( const uf::Vector<T,3>& vector ) const {
+	return uf::vector::compareTo(this->m_pod, vector.data() ) >= 0;
+}
+//
+// 	C-tor
+template<typename T> 														// initializes POD to 'def'
+uf::Vector<T,4>::Vector() {
+}
+template<typename T> 														// initializes POD to 'def'
+uf::Vector<T,4>::Vector(T def) {
+	for ( std::size_t i = 0; i < 4; ++i ) this->m_pod[i] = def;
+}
+template<typename T> 														// initializes POD to 'def'
+uf::Vector<T,4>::Vector(T x, T y, T z, T w) {
+	this->m_pod.x = x;
+	this->m_pod.y = y;
+	this->m_pod.z = z;
+	this->m_pod.w = w;
+}
+template<typename T> 														// copies POD altogether
+uf::Vector<T,4>::Vector(const typename uf::Vector<T,4>::pod_t& pod) : m_pod(pod) {
+}
+template<typename T> 														// copies data into POD from 'components' (typed as C array)
+uf::Vector<T,4>::Vector(const T components[4]) {
+	this->set(&components[0]);
+}
+template<typename T> 														// copies data into POD from 'components' (typed as std::vector<T>)
+uf::Vector<T,4>::Vector(const std::vector<T>& components) {
+	if ( components.size() >= 4 ) this->set(&components[0]);
+}
+// 	D-tor
+// Unneccesary
+// 	POD access
+template<typename T> 														// 	Returns a reference of POD
+typename uf::Vector<T,4>::pod_t& uf::Vector<T,4>::data() {
+	return this->m_pod;
+}
+template<typename T> 														// 	Returns a const-reference of POD
+const typename uf::Vector<T,4>::pod_t& uf::Vector<T,4>::data() const {
+	return this->m_pod;
+}
+// 	Alternative POD access
+template<typename T> 														// 	Returns a pointer to the entire array
+T* uf::Vector<T,4>::get() {
+	return &this->m_pod[0];
+}
+template<typename T> 														// 	Returns a const-pointer to the entire array
+const T* uf::Vector<T,4>::get() const {
+	return &this->m_pod[0];
+}
+template<typename T> 														// 	Returns a reference to a single element
+T& uf::Vector<T,4>::getComponent( std::size_t i ) {
+	if ( i >= 4 ) return NULL;
+	return this->m_pod[i];
+}
+template<typename T> 														// 	Returns a const-reference to a single element
+const T& uf::Vector<T,4>::getComponent( std::size_t i ) const {
+	if ( i >= 4 ) return NULL;
+	return this->m_pod[i];
+}
+// 	POD manipulation
+template<typename T> 														// 	Sets the entire array
+T* uf::Vector<T,4>::set(const T components[4]) {
+	for ( std::size_t i = 0; i < 4; ++i ) this->m_pod[i] = components[i];
+	return &this->m_pod[0];
+}
+template<typename T> 														// 	Sets a single element
+T& uf::Vector<T,4>::setComponent( std::size_t i, const T& value ) {
+	this->m_pod[i] = value;
+}
+// 	Validation
+template<typename T> 														// 	Checks if all components are valid (non NaN, inf, etc.)
+bool uf::Vector<T,4>::isValid() const {
+	for ( std::size_t i = 0; i < 4; ++i ) if ( this->m_pod[i] != this->m_pod[i] ) return false;
+	return true;
+}
+// 	Basic arithmetic
+template<typename T> 														// 	Adds two vectors of same type and size together
+inline uf::Vector<T,4>& uf::Vector<T,4>::add( const uf::Vector<T, 4>& vector ) {
+	return uf::vector::add( this->m_pod, vector.data() );
+}
+template<typename T> 														// 	Subtracts two vectors of same type and size together
+inline uf::Vector<T,4>& uf::Vector<T,4>::subtract( const uf::Vector<T, 4>& vector ) {
+	return uf::vector::subtract( this->m_pod, vector.data() );
+}
+template<typename T> 														// 	Multiplies two vectors of same type and size together
+inline uf::Vector<T,4>& uf::Vector<T,4>::multiply( const uf::Vector<T, 4>& vector ) {
+	return uf::vector::multiply( this->m_pod, vector.data() );
+}
+template<typename T> 														// 	Multiplies this vector by a scalar
+inline uf::Vector<T,4>& uf::Vector<T,4>::multiply( T scalar ) {
+	return uf::vector::multiply( this->m_pod, scalar );
+}
+template<typename T> 														// 	Divides two vectors of same type and size together
+inline uf::Vector<T,4>& uf::Vector<T,4>::divide( const uf::Vector<T, 4>& vector ) {
+	return uf::vector::divide( this->m_pod, vector.data() );
+}
+template<typename T> 														// 	Divides this vector by a scalar
+inline uf::Vector<T,4>& uf::Vector<T,4>::divide( T scalar ) {
+	return uf::vector::divide( this->m_pod, scalar );
+}
+template<typename T> 														// 	Compute the sum of all components 
+inline T uf::Vector<T,4>::sum() const {
+	return uf::vector::sum( this->m_pod );
+}
+template<typename T> 														// 	Compute the product of all components 
+inline T uf::Vector<T,4>::product() const {
+	return uf::vector::product( this->m_pod );
+}
+template<typename T> 														// 	Flip sign of all components
+inline uf::Vector<T,4>& uf::Vector<T,4>::negate() {
+	return uf::vector::negate( this->m_pod );
+}
+// 	Complex arithmetic
+template<typename T> 														// 	Compute the dot product between two vectors
+inline T uf::Vector<T,4>::dot( const uf::Vector<T,4> right ) const {
+	return uf::vector::dot( this->m_pod, right );
+}
+template<typename T> 														// 	Compute the angle between two vectors
+inline pod::Angle uf::Vector<T,4>::angle( const uf::Vector<T,4>& b ) const {
+	return uf::vector::angle( this->m_pod, b );
+}
+
+template<typename T> 														// 	Linearly interpolate between two vectors
+inline uf::Vector<T,4> uf::Vector<T,4>::lerp( const uf::Vector<T,4> to, double delta ) const {
+	return uf::vector::lerp( this->m_pod, to, delta );
+}
+template<typename T> 														// 	Spherically interpolate between two vectors
+inline uf::Vector<T,4> uf::Vector<T,4>::slerp( const uf::Vector<T,4> to, double delta ) const {
+	return uf::vector::slerp( this->m_pod, to, delta );
+}
+
+template<typename T> 														// 	Compute the distance between two vectors (doesn't sqrt)
+inline T uf::Vector<T,4>::distanceSquared( const uf::Vector<T,4> b ) const {
+	return uf::vector::distanceSquared( this->m_pod, b );
+}
+template<typename T> 														// 	Compute the distance between two vectors
+inline T uf::Vector<T,4>::distance( const uf::Vector<T,4> b ) const {
+	return uf::vector::distance( this->m_pod, b );
+}
+template<typename T> 														// 	Gets the magnitude of the vector
+inline T uf::Vector<T,4>::magnitude() const {
+	return uf::vector::magnitude( this->m_pod );
+}
+template<typename T> 														// 	Compute the norm of the vector
+inline T uf::Vector<T,4>::norm() const {
+	return uf::vector::norm( this->m_pod );
+}
+
+template<typename T> 														// 	Normalizes a vector
+inline uf::Vector<T,4>& uf::Vector<T,4>::normalize() {
+	return uf::vector::normalize( this->m_pod );
+}
+template<typename T> 														// 	Return a normalized vector
+uf::Vector<T,4> uf::Vector<T,4>::getNormalized() const {
+	return uf::vector::normalize( this->m_pod );
+}
+template<typename T> 														// 	Return a string
+std::string uf::Vector<T,4>::toString() const {
+	return uf::vector::toString( this->m_pod );
+}
+// Overloaded ops
+template<typename T> 
+T& uf::Vector<T,4>::operator[](std::size_t i) {
+	if ( i >= 4 ) return NULL;
+	return this->m_pod[i];
+}
+template<typename T> 
+const T& uf::Vector<T,4>::operator[](std::size_t i) const {
+	if ( i >= 4 ) return NULL;
+	return this->m_pod[i];
+}
+// Arithmetic
+template<typename T>  															// 	Negation
+inline uf::Vector<T,4> uf::Vector<T,4>::operator-() const {
+	return uf::vector::negate( this->m_pod );
+}			
+template<typename T>  															// 	Addition between two vectors
+inline uf::Vector<T,4> uf::Vector<T,4>::operator+( const uf::Vector<T,4>& vector ) const {
+	return uf::vector::add( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Subtraction between two vectors
+inline uf::Vector<T,4> uf::Vector<T,4>::operator-( const uf::Vector<T,4>& vector ) const {
+	return uf::vector::subtract( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Multiplication between two vectors
+inline uf::Vector<T,4> uf::Vector<T,4>::operator*( const uf::Vector<T,4>& vector ) const {
+	return uf::vector::multiply( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Division between two vectors
+inline uf::Vector<T,4> uf::Vector<T,4>::operator/( const uf::Vector<T,4>& vector ) const {
+	return uf::vector::divide( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Multiplication with scalar
+inline uf::Vector<T,4> uf::Vector<T,4>::operator*( T scalar ) const {
+	return uf::vector::multiply( this->m_pod, scalar );
+}
+template<typename T>  															// 	Division with scalar
+inline uf::Vector<T,4> uf::Vector<T,4>::operator/( T scalar ) const {
+	return uf::vector::divide( this->m_pod, scalar );
+}
+template<typename T>  															// 	Addition set between two vectors
+inline uf::Vector<T,4>& uf::Vector<T,4>::operator +=( const uf::Vector<T,4>& vector ) {
+	return uf::vector::add( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Subtraction set between two vectors
+inline uf::Vector<T,4>& uf::Vector<T,4>::operator -=( const uf::Vector<T,4>& vector ) {
+	return uf::vector::subtract( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Multiplication set between two vectors
+inline uf::Vector<T,4>& uf::Vector<T,4>::operator *=( const uf::Vector<T,4>& vector ) {
+	return uf::vector::multiply( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Division set between two vectors
+inline uf::Vector<T,4>& uf::Vector<T,4>::operator /=( const uf::Vector<T,4>& vector ) {
+	return uf::vector::divide( this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Multiplication set with scalar
+inline uf::Vector<T,4>& uf::Vector<T,4>::operator *=( T scalar ) {
+	return uf::vector::multiply( this->m_pod, scalar );
+}
+template<typename T>  															// 	Division set with scalar
+inline uf::Vector<T,4>& uf::Vector<T,4>::operator /=( T scalar ) {
+	return uf::vector::divide( this->m_pod, scalar );
+}
+template<typename T>  															// 	Equality check between two vectors (equals)
+inline bool uf::Vector<T,4>::operator==( const uf::Vector<T,4>& vector ) const {
+	return uf::vector::equals(this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Equality check between two vectors (not equals)
+inline bool uf::Vector<T,4>::operator!=( const uf::Vector<T,4>& vector ) const {
+	return !uf::vector::equals(this->m_pod, vector.data() );
+}
+template<typename T>  															// 	Equality check between two vectors (less than)
+inline bool uf::Vector<T,4>::operator<( const uf::Vector<T,4>& vector ) const {
+	return uf::vector::compareTo(this->m_pod, vector.data() ) < 0;
+}
+template<typename T>  															// 	Equality check between two vectors (less than or equals)
+inline bool uf::Vector<T,4>::operator<=( const uf::Vector<T,4>& vector ) const {
+	return uf::vector::compareTo(this->m_pod, vector.data() ) <= 0;
+}
+template<typename T>  															// 	Equality check between two vectors (greater than)
+inline bool uf::Vector<T,4>::operator>( const uf::Vector<T,4>& vector ) const {
+	return uf::vector::compareTo(this->m_pod, vector.data() ) > 0;
+}
+template<typename T>  															// 	Equality check between two vectors (greater than or equals)
+inline bool uf::Vector<T,4>::operator>=( const uf::Vector<T,4>& vector ) const {
+	return uf::vector::compareTo(this->m_pod, vector.data() ) >= 0;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/math/vector/simd.h b/engine/inc/uf/utils/math/vector/simd.h
new file mode 100644
index 00000000..2638e123
--- /dev/null
+++ b/engine/inc/uf/utils/math/vector/simd.h
@@ -0,0 +1,115 @@
+#pragma once
+
+#include <uf/config.h>
+
+namespace uf {
+	namespace simd {
+		template<typename T>
+		struct UF_API traits {
+			static const size_t size = 4;
+			typedef T type;
+			typedef __m128 value;
+			typedef pod::Vector<T,size> vector;
+		};
+
+		template<>
+		struct UF_API traits<int32_t> {
+			static const size_t size = 4;
+			typedef int32_t type;
+			typedef __m128i value;
+			typedef pod::Vector<int32_t,4> vector;
+		};
+		template<>
+		struct UF_API traits<uint32_t> {
+			static const size_t size = 4;
+			typedef uint32_t type;
+			typedef __m128i value;
+			typedef pod::Vector<uint32_t,4> vector;
+		};
+		template<>
+		struct UF_API traits<float> {
+			static const size_t size = 4;
+			typedef float type;
+			typedef __m128 value;
+			typedef pod::Vector<float,4> vector;
+		};
+
+		template<typename T>
+		class UF_API value {
+		private:
+		//	__m128 m_value;
+			typedef typename traits<T>::value value_type;
+			value_type m_value;
+		public:
+			inline value();
+			inline value(const T* f);
+			inline value(T f);
+			inline value(T f0, T f1, T f2, T f3);
+			inline value(const value_type& rhs);
+			inline value(const value& rhs);
+
+			inline value(const pod::Vector<T,1>& rhs);
+			inline value(const pod::Vector<T,2>& rhs);
+			inline value(const pod::Vector<T,3>& rhs);
+			inline value(const pod::Vector<T,4>& rhs);
+
+			inline value operator+( const value& y );
+			inline value operator-( const value& y );
+			inline value operator*( const value& y );
+			inline value operator/( const value& y );
+			inline value& operator=(const value_type& rhs);
+			inline value& operator=(const value& rhs);
+			inline value& operator=(const pod::Vector4f& rhs);
+			inline operator value_type() const;
+			
+			template<size_t N> inline operator pod::Vector<T,N>() const;
+		};
+
+		inline value<float> /**UF_API**/ load( const float* );
+		inline void /**UF_API**/ store( value<float>, float* );
+		inline value<float> /**UF_API**/ set( float );
+		inline value<float> /**UF_API**/ set( float, float, float, float );
+		inline value<float> /**UF_API**/ add( value<float>, value<float> );
+		inline value<float> /**UF_API**/ sub( value<float>, value<float> );
+		inline value<float> /**UF_API**/ mul( value<float>, value<float> );
+		inline value<float> /**UF_API**/ div( value<float>, value<float> );
+		inline value<float> /**UF_API**/ min( value<float>, value<float> );
+		inline value<float> /**UF_API**/ max( value<float>, value<float> );
+		inline value<float> /**UF_API**/ sqrt( value<float> );
+	//	inline value<float> /**UF_API**/ hadd( value<float>, value<float> );
+		inline float /**UF_API**/ dot( value<float>, value<float> );
+		template<size_t N=4> inline pod::Vector<float,N> vector( const value<float> );
+
+		inline value<int32_t> /**UF_API**/ load( const int32_t* );
+		inline void /**UF_API**/ store( value<int32_t>, int32_t* );
+		inline value<int32_t> /**UF_API**/ set( int32_t );
+		inline value<int32_t> /**UF_API**/ set( int32_t, int32_t, int32_t, int32_t );
+		inline value<int32_t> /**UF_API**/ add( value<int32_t>, value<int32_t> );
+		inline value<int32_t> /**UF_API**/ sub( value<int32_t>, value<int32_t> );
+		inline value<int32_t> /**UF_API**/ mul( value<int32_t>, value<int32_t> );
+		inline value<int32_t> /**UF_API**/ div( value<int32_t>, value<int32_t> );
+		inline value<int32_t> /**UF_API**/ min( value<int32_t>, value<int32_t> );
+		inline value<int32_t> /**UF_API**/ max( value<int32_t>, value<int32_t> );
+		inline value<int32_t> /**UF_API**/ sqrt( value<int32_t> );
+	//	inline value<int32_t> /**UF_API**/ hadd( value<int32_t>, value<int32_t> );
+		inline int32_t /**UF_API**/ dot( value<int32_t>, value<int32_t> );
+		template<size_t N=4> inline pod::Vector<int32_t,N> vector( const value<int32_t> );
+
+		inline value<uint> /**UF_API**/ load( const uint* );
+		inline void /**UF_API**/ store( value<uint>, uint* );
+		inline value<uint> /**UF_API**/ set( uint );
+		inline value<uint> /**UF_API**/ set( uint, uint, uint, uint );
+		inline value<uint> /**UF_API**/ add( value<uint>, value<uint> );
+		inline value<uint> /**UF_API**/ sub( value<uint>, value<uint> );
+		inline value<uint> /**UF_API**/ mul( value<uint>, value<uint> );
+		inline value<uint> /**UF_API**/ div( value<uint>, value<uint> );
+		inline value<uint> /**UF_API**/ min( value<uint>, value<uint> );
+		inline value<uint> /**UF_API**/ max( value<uint>, value<uint> );
+		inline value<uint> /**UF_API**/ sqrt( value<uint> );
+	//	inline value<uint> /**UF_API**/ hadd( value<uint>, value<uint> );
+		inline uint /**UF_API**/ dot( value<uint>, value<uint> );
+		template<size_t N=4> inline pod::Vector<uint,N> vector( const value<uint> );
+	}
+}
+
+#include "simd.inl"
\ No newline at end of file
diff --git a/engine/inc/uf/utils/math/vector/simd.inl b/engine/inc/uf/utils/math/vector/simd.inl
new file mode 100644
index 00000000..fff7a968
--- /dev/null
+++ b/engine/inc/uf/utils/math/vector/simd.inl
@@ -0,0 +1,295 @@
+template<typename T>
+inline uf::simd::value<T>::value() {}
+template<typename T>
+inline uf::simd::value<T>::value(const T* f) : m_value(uf::simd::load(f)) {}
+template<typename T>
+inline uf::simd::value<T>::value(T f) : m_value(uf::simd::set(f)) {}
+template<typename T>
+inline uf::simd::value<T>::value(T f0, T f1, T f2, T f3) : m_value(uf::simd::set(f0,f1,f2,f3)) {}
+template<typename T>
+inline uf::simd::value<T>::value(const value_type& rhs) : m_value(rhs) {}
+template<typename T>
+inline uf::simd::value<T>::value(const value& rhs) : m_value(rhs.m_value) {}
+
+template<typename T>
+inline uf::simd::value<T>::value(const pod::Vector<T,1>& rhs) : value((T) rhs[0]){}
+template<typename T>
+inline uf::simd::value<T>::value(const pod::Vector<T,2>& rhs) : value((T) rhs[0], (T) rhs[1], 0, 0){}
+template<typename T>
+inline uf::simd::value<T>::value(const pod::Vector<T,3>& rhs) : value((T) rhs[0], (T) rhs[1], (T) rhs[2], 0){}
+template<typename T>
+inline uf::simd::value<T>::value(const pod::Vector<T,4>& rhs) : value((T) rhs[0], (T) rhs[1], (T) rhs[2], (T) rhs[3]){}
+
+template<typename T>
+inline uf::simd::value<T> uf::simd::value<T>::operator+( const value& rhs ) {
+	return uf::simd::add( *this, rhs );
+}
+template<typename T>
+inline uf::simd::value<T> uf::simd::value<T>::operator-( const value& rhs ) {
+	return uf::simd::sub( *this, rhs );
+}
+template<typename T>
+inline uf::simd::value<T> uf::simd::value<T>::operator*( const value& rhs ) {
+	return uf::simd::mul( *this, rhs );
+}
+template<typename T>
+inline uf::simd::value<T> uf::simd::value<T>::operator/( const value& rhs ) {
+	return uf::simd::div( *this, rhs );
+}
+template<typename T>
+inline uf::simd::value<T>& uf::simd::value<T>::operator=(const uf::simd::value<T>::value_type& rhs) {
+	m_value = rhs;
+	return *this;
+}
+template<typename T>
+inline uf::simd::value<T>& uf::simd::value<T>::operator=(const value& rhs) {
+	m_value = rhs.m_value;
+	return *this;
+}
+template<typename T>
+inline uf::simd::value<T>& uf::simd::value<T>::operator=(const pod::Vector4f& rhs) {
+	m_value = uf::simd::load(&rhs[0]);
+	return *this;
+}
+template<typename T>
+inline uf::simd::value<T>::operator uf::simd::value<T>::value_type() const {
+	return m_value;
+}
+
+template<typename T>
+template<size_t N>
+inline uf::simd::value<T>::operator pod::Vector<T,N>() const {
+	return uf::simd::vector<N>(*this);
+}
+
+template<size_t N>
+inline pod::Vector<float,N> uf::simd::vector( const uf::simd::value<float> v ){
+	pod::Vector4f r;
+	uf::simd::store( v, &r[0] );
+	return uf::vector::cast<float,N>(r);
+}
+template<size_t N>
+inline pod::Vector<int,N> uf::simd::vector( const uf::simd::value<int> v ){
+	pod::Vector4i r;
+	uf::simd::store( v, &r[0] );
+	return uf::vector::cast<int,N>(r);
+}
+template<size_t N>
+inline pod::Vector<uint,N> uf::simd::vector( const uf::simd::value<uint> v ){
+	pod::Vector4ui r;
+	uf::simd::store( v, &r[0] );
+	return uf::vector::cast<uint,N>(r);
+}
+
+inline uf::simd::value<float> /*UF_API*/ uf::simd::load( const float* f ) {
+#if 1
+	return _mm_loadu_ps(f);
+#else
+	return _mm_load_ps(f);
+#endif
+}
+inline void /*UF_API*/ uf::simd::store( uf::simd::value<float> v, float* f ) {
+	_mm_store_ps(f, v);
+}
+inline uf::simd::value<float> /*UF_API*/ uf::simd::set( float f ) {
+	return _mm_set1_ps(f);
+}
+inline uf::simd::value<float> /*UF_API*/ uf::simd::set( float x, float y, float z, float w ) {
+	return _mm_setr_ps(x, y, z, w);
+}
+inline uf::simd::value<float> /*UF_API*/ uf::simd::add( uf::simd::value<float> x, uf::simd::value<float> y ) {
+	return _mm_add_ps( x, y );
+}
+inline uf::simd::value<float> /*UF_API*/ uf::simd::sub( uf::simd::value<float> x, uf::simd::value<float> y ) {
+	return _mm_sub_ps( x, y );
+}
+inline uf::simd::value<float> /*UF_API*/ uf::simd::mul( uf::simd::value<float> x, uf::simd::value<float> y ) {
+	return _mm_mul_ps( x, y );
+}
+inline uf::simd::value<float> /*UF_API*/ uf::simd::div( uf::simd::value<float> x, uf::simd::value<float> y ) {
+	return _mm_div_ps( x, y );
+}
+/*
+inline uf::simd::value<float> uf::simd::hadd( uf::simd::value<float> x, uf::simd::value<float> y ) {
+	return _mm_hadd_ps( x, y );
+}
+*/
+inline uf::simd::value<float> /*UF_API*/ uf::simd::min( uf::simd::value<float> x, uf::simd::value<float> y ) {
+	return _mm_min_ps( x, y );
+}
+inline uf::simd::value<float> /*UF_API*/ uf::simd::max( uf::simd::value<float> x, uf::simd::value<float> y ) {
+	return _mm_max_ps( x, y );
+}
+inline uf::simd::value<float> /*UF_API*/ uf::simd::sqrt( uf::simd::value<float> v ) {
+	return _mm_sqrt_ps( v );
+}
+inline float /*UF_API*/ uf::simd::dot( uf::simd::value<float> x, uf::simd::value<float> y ) {
+#if SSE_INSTR_SET >= 5
+	__m128 result = _mm_dp_ps(x, y, 0xFF);
+	return uf::simd::vector<float,4>( result )[0];
+#elif SSE_INSTR_SET >= 3
+	__m128 mulRes = _mm_mul_ps(x, y);
+	__m128 shufReg = _mm_movehdup_ps(mulRes);
+	__m128 sumsReg = _mm_add_ps(mulRes, shufReg);
+    shufReg = _mm_movehl_ps(shufReg, sumsReg);
+    sumsReg = _mm_add_ss(sumsReg, shufReg);
+    return _mm_cvtss_f32(sumsReg);
+#else
+	return uf::vector::sum( uf::simd::vector( uf::simd::mul( x, y ) ) );
+#endif
+}
+inline uf::simd::value<int32_t> /*UF_API*/ uf::simd::load( const int32_t* f ) {
+	return uf::simd::value<int32_t>( f[0], f[1], f[2], f[3] );
+}
+inline void /*UF_API*/ uf::simd::store( uf::simd::value<int32_t> v, int32_t* f ) {
+	union {
+		__m128i x;
+		int32_t y[4];
+	} kludge;
+	kludge.x = v;
+	f[0] = kludge.y[0];
+	f[1] = kludge.y[1];
+	f[2] = kludge.y[2];
+	f[3] = kludge.y[3];
+}
+inline uf::simd::value<int32_t> /*UF_API*/ uf::simd::set( int32_t f ) {
+	return _mm_set1_epi32(f);
+}
+inline uf::simd::value<int32_t> /*UF_API*/ uf::simd::set( int32_t x, int32_t y, int32_t z, int32_t w ) {
+	return _mm_setr_epi32(x, y, z, w);
+}
+inline uf::simd::value<int32_t> /*UF_API*/ uf::simd::add( uf::simd::value<int32_t> x, uf::simd::value<int32_t> y ) {
+	auto X = uf::simd::vector( x );
+	auto Y = uf::simd::vector( y );
+	return uf::simd::set( X[0] + Y[0], X[1] + Y[1], X[2] + Y[2], X[3] + Y[3] );
+}
+inline uf::simd::value<int32_t> /*UF_API*/ uf::simd::sub( uf::simd::value<int32_t> x, uf::simd::value<int32_t> y ) {
+	auto X = uf::simd::vector( x );
+	auto Y = uf::simd::vector( y );
+	return uf::simd::set( X[0] - Y[0], X[1] - Y[1], X[2] - Y[2], X[3] - Y[3] );
+}
+inline uf::simd::value<int32_t> /*UF_API*/ uf::simd::mul( uf::simd::value<int32_t> x, uf::simd::value<int32_t> y ) {
+	auto X = uf::simd::vector( x );
+	auto Y = uf::simd::vector( y );
+	return uf::simd::set( X[0] * Y[0], X[1] * Y[1], X[2] * Y[2], X[3] * Y[3] );
+}
+inline uf::simd::value<int32_t> /*UF_API*/ uf::simd::div( uf::simd::value<int32_t> x, uf::simd::value<int32_t> y ) {
+	auto X = uf::simd::vector( x );
+	auto Y = uf::simd::vector( y );
+	return uf::simd::set( X[0] / Y[0], X[1] / Y[1], X[2] / Y[2], X[3] / Y[3] );
+}
+/*
+inline uf::simd::value<int32_t> uf::simd::hadd( uf::simd::value<int32_t> x, uf::simd::value<int32_t> y ) {
+	auto X = uf::simd::vector( x );
+	auto Y = uf::simd::vector( y );
+	return uf::simd::set( X[0] + Y[0], X[1] + Y[1], X[2] + Y[2], X[3] + Y[3] );
+}
+*/
+inline uf::simd::value<int32_t> /*UF_API*/ uf::simd::min( uf::simd::value<int32_t> x, uf::simd::value<int32_t> y ) {
+	auto X = uf::simd::vector( x );
+	auto Y = uf::simd::vector( y );
+	return uf::simd::set( std::min(X[0], Y[0]), std::min(X[1], Y[1]), std::min(X[2], Y[2]), std::min(X[3], Y[3]) );
+}
+inline uf::simd::value<int32_t> /*UF_API*/ uf::simd::max( uf::simd::value<int32_t> x, uf::simd::value<int32_t> y ) {
+	auto X = uf::simd::vector( x );
+	auto Y = uf::simd::vector( y );
+	return uf::simd::set( std::max(X[0], Y[0]), std::max(X[1], Y[1]), std::max(X[2], Y[2]), std::max(X[3], Y[3]) );
+}
+inline uf::simd::value<int32_t> /*UF_API*/ uf::simd::sqrt( uf::simd::value<int32_t> v ) {
+	auto V = uf::simd::vector( v );
+	return uf::simd::set( (int32_t) std::sqrt(V[0]), (int32_t) std::sqrt(V[1]), (int32_t) std::sqrt(V[2]), (int32_t) std::sqrt(V[3]) );
+}
+inline int32_t /*UF_API*/ uf::simd::dot( uf::simd::value<int32_t> x, uf::simd::value<int32_t> y ) {
+	auto X = uf::simd::vector( x );
+	auto Y = uf::simd::vector( y );
+	return X[0] * Y[0] + X[1] * Y[1] + X[2] * Y[2] + X[3] * Y[3];
+}
+
+inline uf::simd::value<uint32_t> /*UF_API*/ uf::simd::load( const uint32_t* f ) {
+	return uf::simd::value<uint32_t>( f[0], f[1], f[2], f[3] );
+}
+inline void /*UF_API*/ uf::simd::store( uf::simd::value<uint32_t> v, uint32_t* f ) {
+	union {
+		__m128i x;
+		uint32_t y[4];
+	} kludge;
+	kludge.x = v;
+	f[0] = kludge.y[0];
+	f[1] = kludge.y[1];
+	f[2] = kludge.y[2];
+	f[3] = kludge.y[3];
+}
+inline uf::simd::value<uint32_t> /*UF_API*/ uf::simd::set( uint32_t f ) {
+#if 0
+	union {
+		__m128i x;
+		uint32_t y[4];
+	} kludge;
+	kludge.y[0] = f;
+	kludge.y[1] = f;
+	kludge.y[2] = f;
+	kludge.y[3] = f;
+#else
+	return _mm_set1_epi32(f);
+#endif
+}
+inline uf::simd::value<uint32_t> /*UF_API*/ uf::simd::set( uint32_t x, uint32_t y, uint32_t z, uint32_t w ) {
+#if 0
+	union {
+		__m128i x;
+		uint32_t y[4];
+	} kludge;
+	kludge.y[0] = x;
+	kludge.y[1] = y;
+	kludge.y[2] = z;
+	kludge.y[3] = w;
+#else
+	return _mm_setr_epi32(x, y, z, w);
+#endif
+}
+inline uf::simd::value<uint32_t> /*UF_API*/ uf::simd::add( uf::simd::value<uint32_t> x, uf::simd::value<uint32_t> y ) {
+	auto X = uf::simd::vector( x );
+	auto Y = uf::simd::vector( y );
+	return uf::simd::set( X[0] + Y[0], X[1] + Y[1], X[2] + Y[2], X[3] + Y[3] );
+}
+inline uf::simd::value<uint32_t> /*UF_API*/ uf::simd::sub( uf::simd::value<uint32_t> x, uf::simd::value<uint32_t> y ) {
+	auto X = uf::simd::vector( x );
+	auto Y = uf::simd::vector( y );
+	return uf::simd::set( X[0] - Y[0], X[1] - Y[1], X[2] - Y[2], X[3] - Y[3] );
+}
+inline uf::simd::value<uint32_t> /*UF_API*/ uf::simd::mul( uf::simd::value<uint32_t> x, uf::simd::value<uint32_t> y ) {
+	auto X = uf::simd::vector( x );
+	auto Y = uf::simd::vector( y );
+	return uf::simd::set( X[0] * Y[0], X[1] * Y[1], X[2] * Y[2], X[3] * Y[3] );
+}
+inline uf::simd::value<uint32_t> /*UF_API*/ uf::simd::div( uf::simd::value<uint32_t> x, uf::simd::value<uint32_t> y ) {
+	auto X = uf::simd::vector( x );
+	auto Y = uf::simd::vector( y );
+	return uf::simd::set( X[0] / Y[0], X[1] / Y[1], X[2] / Y[2], X[3] / Y[3] );
+}
+/*
+inline uf::simd::value<uint32_t> uf::simd::hadd( uf::simd::value<uint32_t> x, uf::simd::value<uint32_t> y ) {
+	auto X = uf::simd::vector( x );
+	auto Y = uf::simd::vector( y );
+	return uf::simd::set( X[0] + Y[0], X[1] + Y[1], X[2] + Y[2], X[3] + Y[3] );
+}
+*/
+inline uf::simd::value<uint32_t> /*UF_API*/ uf::simd::min( uf::simd::value<uint32_t> x, uf::simd::value<uint32_t> y ) {
+	auto X = uf::simd::vector( x );
+	auto Y = uf::simd::vector( y );
+	return uf::simd::set( std::min(X[0], Y[0]), std::min(X[1], Y[1]), std::min(X[2], Y[2]), std::min(X[3], Y[3]) );
+}
+inline uf::simd::value<uint32_t> /*UF_API*/ uf::simd::max( uf::simd::value<uint32_t> x, uf::simd::value<uint32_t> y ) {
+	auto X = uf::simd::vector( x );
+	auto Y = uf::simd::vector( y );
+	return uf::simd::set( std::max(X[0], Y[0]), std::max(X[1], Y[1]), std::max(X[2], Y[2]), std::max(X[3], Y[3]) );
+}
+inline uf::simd::value<uint32_t> /*UF_API*/ uf::simd::sqrt( uf::simd::value<uint32_t> v ) {
+	auto V = uf::simd::vector( v );
+	return uf::simd::set( (uint32_t) std::sqrt(V[0]), (uint32_t) std::sqrt(V[1]), (uint32_t) std::sqrt(V[2]), (uint32_t) std::sqrt(V[3]) );
+}
+inline uint32_t /*UF_API*/ uf::simd::dot( uf::simd::value<uint32_t> x, uf::simd::value<uint32_t> y ) {
+	auto X = uf::simd::vector( x );
+	auto Y = uf::simd::vector( y );
+	return X[0] * Y[0] + X[1] * Y[1] + X[2] * Y[2] + X[3] * Y[3];
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/math/vector/vector.inl b/engine/inc/uf/utils/math/vector/vector.inl
new file mode 100644
index 00000000..8edb02e3
--- /dev/null
+++ b/engine/inc/uf/utils/math/vector/vector.inl
@@ -0,0 +1,21 @@
+#include "pod.inl"
+#include "class.inl"
+
+template<typename T, size_t N>
+std::string /*UF_API*/ uf::string::toString( const pod::Vector<T,N>& v ) {
+	return uf::vector::toString(v);
+}
+
+template<typename T, size_t N>
+ext::json::Value /*UF_API*/ ext::json::encode( const pod::Vector<T,N>& v ) {
+	return uf::vector::encode(v);
+}
+
+template<typename T, size_t N>
+pod::Vector<T,N>& /*UF_API*/ ext::json::decode( const ext::json::Value& json, pod::Vector<T,N>& v ) {
+	return uf::vector::decode<T,N>(json, v);
+}
+template<typename T, size_t N>
+pod::Vector<T,N> /*UF_API*/ ext::json::decode( const ext::json::Value& json, const pod::Vector<T,N>& v ) {
+	return uf::vector::decode<T,N>(json, v);
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/mempool/mempool.h b/engine/inc/uf/utils/mempool/mempool.h
new file mode 100644
index 00000000..51315ef8
--- /dev/null
+++ b/engine/inc/uf/utils/mempool/mempool.h
@@ -0,0 +1,74 @@
+#pragma once
+
+#include <uf/config.h>
+#include <stdint.h>
+#include <vector>
+#include <string>
+#include <mutex>
+
+#define UF_MEMORYPOOL_MUTEX 1
+#define UF_MEMORYPOOL_INVALID_MALLOC 0
+#define UF_MEMORYPOOL_INVALID_FREE 0
+#define UF_MEMORYPOOL_OVERRIDE_NEW_DELETE 0
+#define UF_MEMORYPOOL_CACHED_ALLOCATIONS 0
+
+namespace pod {
+	struct UF_API Userdata;
+	struct UF_API Allocation {
+		size_t index = 0;
+		size_t size = 0;
+		void* pointer = NULL;
+	};
+}
+
+namespace uf {
+	class UF_API MemoryPool {
+	protected:
+		size_t m_size;
+		uint8_t* m_pool;
+		std::mutex m_mutex;
+
+		typedef std::vector<pod::Allocation> allocations_t;
+		allocations_t m_allocations;
+		allocations_t m_cachedFreeAllocations;
+	public:
+		static bool globalOverride;
+		static bool subPool;
+		static MemoryPool global;
+
+		MemoryPool( size_t = 0 );
+		~MemoryPool();
+
+		size_t size() const;
+		size_t allocated() const;
+		std::string stats() const;
+		void initialize( size_t );
+		void destroy();
+
+		pod::Allocation allocate( void*, size_t );
+		void* alloc( void*, size_t );
+		inline void* alloc( size_t size, void* data = NULL ) { return alloc(data, size); }
+		pod::Allocation& fetch( size_t, size_t = 0 );
+		bool exists( void*, size_t = 0 );
+		bool free( void*, size_t = 0 );
+		
+		template<typename T> T& alloc( const T& = T() );
+		template<typename T> pod::Allocation allocate( const T& = T() );
+		template<typename T> bool exists( const T& = T() );
+		template<typename T> bool free( const T& = T() );
+
+		const allocations_t& allocations() const;
+	/*
+		struct Iterator {
+			uf::MemoryPool& pool;
+			pod::Allocation& allocation;
+			pod::Allocation& next;
+			pod::Allocation& prev;
+		};
+		Iterator begin();
+		Iterator end();
+	*/
+	};
+}
+
+#include "mempool.inl"
\ No newline at end of file
diff --git a/engine/inc/uf/utils/mempool/mempool.inl b/engine/inc/uf/utils/mempool/mempool.inl
new file mode 100644
index 00000000..d6b92808
--- /dev/null
+++ b/engine/inc/uf/utils/mempool/mempool.inl
@@ -0,0 +1,36 @@
+#include <uf/utils/type/type.h>
+
+template<typename T>
+T& uf::MemoryPool::alloc( const T& data ) {
+	auto allocation = this->allocate( data );
+	union {
+		uint8_t* from;
+		T* to;
+	} kludge;
+	kludge.from = (uint8_t*) allocation.pointer;
+	return *kludge.to;
+}
+template<typename T>
+pod::Allocation uf::MemoryPool::allocate( const T& data ) {
+	auto allocation = this->allocate( NULL, sizeof(data) );
+	if ( !allocation.pointer ) return allocation;
+	union {
+		uint8_t* from;
+		T* to;
+	} kludge;
+	kludge.from = (uint8_t*) allocation.pointer;
+	::new (kludge.to) T(data);
+	return allocation;
+}
+template<typename T>
+bool uf::MemoryPool::exists( const T& data ) {
+	if ( std::is_pointer<T>::value ) return this->exists( (void*) data );
+	return this->exists( (void*) &data, sizeof(data) );
+//	return this->exists( (void*) (std::is_pointer<T>::value ? data : &data), sizeof(data) );
+}
+template<typename T>
+bool uf::MemoryPool::free( const T& data ) {
+	if ( std::is_pointer<T>::value ) return this->free( (void*) data );
+	return this->free( (void*) &data, sizeof(data) );
+//	return this->free( (void*) (std::is_pointer<T>::value ? data : &data), sizeof(data) );
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/mesh/grid.h b/engine/inc/uf/utils/mesh/grid.h
new file mode 100644
index 00000000..c05e2463
--- /dev/null
+++ b/engine/inc/uf/utils/mesh/grid.h
@@ -0,0 +1,59 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/utils/mesh/mesh.h>
+#include <limits>
+
+namespace uf {
+	class UF_API MeshGrid {
+	protected:
+		struct Node {
+			pod::Vector3f center = {}; // not necessary since we can easily calculate this on the fly in get()
+			pod::Vector3f extent = {}; // not necessary since this can be pre-computed on initialization()
+	#if 0
+			size_t count = 0;
+			uint32_t* indices = NULL;
+	#else
+			std::vector<uint32_t> indices;
+	#endif
+		};
+		pod::Vector3ui m_size = {1,1,1};
+		pod::Vector3f m_center = {};
+		pod::Vector3f m_extent = {};
+		std::vector<Node> m_nodes;
+
+		void initialize( const pod::Vector3f&, const pod::Vector3f&, const pod::Vector3ui& );
+		void destroy();
+		
+		void allocate( Node&, size_t );
+		Node& at( const pod::Vector3f& );
+		const Node& at( const pod::Vector3f& ) const;
+		pod::Vector3f centroid( const pod::Vector3f&, const pod::Vector3f&, const pod::Vector3f& ) const;
+
+		pod::Vector3i wrapIndex( size_t index );
+		size_t unwrapIndex( const pod::Vector3i& );
+
+		void insert( uint32_t, uint32_t, uint32_t, const pod::Vector3f&, const pod::Vector3f&, const pod::Vector3f& );
+	public:
+		~MeshGrid();
+
+		template<typename T, typename U>
+		void initialize( const uf::BaseMesh<T,U>& mesh, size_t = 1 );
+
+		template<typename T, typename U>
+		void initialize( const uf::BaseMesh<T,U>& mesh, const pod::Vector3ui& );
+		
+		template<typename U = uint32_t>
+		std::vector<U> get() const;
+
+		template<typename U = uint32_t>
+		const std::vector<U>& get( const pod::Vector3f& ) const;
+
+		const pod::Vector3f& center() const;
+		const pod::Vector3f& extent() const;
+
+		void analyze() const;
+	};
+};
+
+#include "grid.inl"
\ No newline at end of file
diff --git a/engine/inc/uf/utils/mesh/grid.inl b/engine/inc/uf/utils/mesh/grid.inl
new file mode 100644
index 00000000..ae6b7528
--- /dev/null
+++ b/engine/inc/uf/utils/mesh/grid.inl
@@ -0,0 +1,65 @@
+template<typename T, typename U>
+void uf::MeshGrid::initialize( const uf::BaseMesh<T,U>& mesh, size_t divisions ) {
+	return initialize<T,U>( mesh, pod::Vector3ui{ divisions, divisions, divisions } );
+}
+template<typename T, typename U>
+void uf::MeshGrid::initialize( const uf::BaseMesh<T,U>& mesh, const pod::Vector3ui& size ) {
+	// calculate our extents
+	pod::Vector3f min = {  std::numeric_limits<float>::max(),  std::numeric_limits<float>::max(),  std::numeric_limits<float>::max() };
+	pod::Vector3f max = { -std::numeric_limits<float>::max(), -std::numeric_limits<float>::max(), -std::numeric_limits<float>::max() };
+	for ( auto& vertex : mesh.vertices ) {
+		auto& position = vertex.position;
+		min.x = std::min( position.x, min.x );
+		min.y = std::min( position.z, min.y );
+		min.z = std::min( position.y, min.z );
+
+		max.x = std::max( position.x, max.x );
+		max.y = std::max( position.z, max.y );
+		max.z = std::max( position.y, max.z );
+	}
+	pod::Vector3f center = (max + min) / 2;
+	pod::Vector3f extent = (max - min) / 2;
+	// pre-generate nodes
+	initialize( center, extent, size );
+	// fill our nodes
+	for ( size_t i = 0; i < mesh.indices.size() / 3; ++i ) {
+		// triangle face
+		auto& i1 = mesh.indices[i*3+0];
+		auto& i2 = mesh.indices[i*3+1];
+		auto& i3 = mesh.indices[i*3+2];
+		// triangle positions
+		auto& v1 = mesh.vertices[i1].position;
+		auto& v2 = mesh.vertices[i2].position;
+		auto& v3 = mesh.vertices[i3].position;
+
+		insert(i1, i2, i3, v1, v2, v3);
+	}
+}
+
+template<typename U = uint32_t>
+std::vector<U> uf::MeshGrid::get() const {
+#if 0
+	auto& node = get( point );
+	std::vector<U> indices(node.count);
+	for ( size_t i = 0; i < node.count; ++i ) indices[i] = node.indices[i];
+	return indices;
+#else
+	std::vector<U> indices;
+	for ( auto& node : this->m_nodes ) {
+		indices.insert( indices.end(), node.indices.begin(), node.indices.end() );
+	}
+	return indices;
+#endif
+}
+		
+template<typename U = uint32_t>
+const std::vector<U>& uf::MeshGrid::get( const pod::Vector3f& point ) const {
+#if 0
+	auto& node = get( point );
+	std::vector<U> indices(node.count);
+	for ( size_t i = 0; i < node.count; ++i ) indices[i] = node.indices[i];
+	return indices;
+#else
+	return at( point ).indices;
+#endif
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/mesh/mesh.h b/engine/inc/uf/utils/mesh/mesh.h
new file mode 100644
index 00000000..df28dbc0
--- /dev/null
+++ b/engine/inc/uf/utils/mesh/mesh.h
@@ -0,0 +1,43 @@
+#pragma once
+
+#include <uf/utils/math/vector.h>
+#include <uf/utils/math/matrix.h>
+#include <uf/utils/graphic/descriptor.h>
+#include <uf/ext/meshopt/meshopt.h>
+
+#include <functional>
+#include <unordered_map>
+
+#if UF_USE_VULKAN
+	namespace uf {
+		namespace renderer = ext::vulkan;
+	}
+#elif UF_USE_OPENGL
+	namespace uf {
+		namespace renderer = ext::opengl;
+	}
+#endif
+
+namespace uf {
+	template<typename T, typename U = uf::renderer::index_t>
+	class /*UF_API*/ BaseMesh : public BaseGeometry {
+	public:
+		typedef T vertex_t;
+		typedef U indices_t;
+		std::vector<vertex_t> vertices;
+		std::vector<indices_t> indices;
+
+		void initialize( size_t = SIZE_MAX );
+		void destroy();
+
+		void expand( bool = true );
+		uf::BaseMesh<T,U> simplify( float = 0.2f );
+		void optimize( size_t = SIZE_MAX );
+
+		virtual void updateDescriptor();
+		virtual void resizeVertices( size_t );
+		virtual void resizeIndices( size_t );
+	};
+}
+
+#include "mesh.inl"
\ No newline at end of file
diff --git a/engine/inc/uf/utils/mesh/mesh.inl b/engine/inc/uf/utils/mesh/mesh.inl
new file mode 100644
index 00000000..d234dd9a
--- /dev/null
+++ b/engine/inc/uf/utils/mesh/mesh.inl
@@ -0,0 +1,93 @@
+template<typename T, typename U>
+void uf::BaseMesh<T, U>::initialize( size_t o ) {
+	this->optimize(o);
+	if ( this->indices.empty() ) this->generateIndices();
+	this->updateDescriptor();
+}	
+template<typename T, typename U>
+void uf::BaseMesh<T, U>::expand( bool check ) {
+	if ( this->indices.empty() ) return;
+	std::vector<vertex_t> _vertices = std::move( this->vertices );
+	this->vertices.clear();
+	this->vertices.reserve( this->indices.size() );
+	if ( !check ) {
+		for ( auto& index : this->indices ) this->vertices.emplace_back( _vertices[index] );
+	} else {
+		std::vector<vertex_t> cache;
+		bool valid = true;
+		cache.reserve(3);
+		for ( auto& index : this->indices ) {
+			// flush cache
+			if ( cache.size() == 3 ) {
+				if ( valid ) {
+					this->vertices.emplace_back(cache[0]);
+					this->vertices.emplace_back(cache[1]);
+					this->vertices.emplace_back(cache[2]);
+				}
+				cache.clear();
+				valid = true;
+			}
+			// invalid index, mark cache as invalid
+			if ( index >= _vertices.size() ) {
+				UF_DEBUG_MSG("Invalid index: Max: " << _vertices.size() << "\tGot: " << index);
+				valid = false;
+				cache.emplace_back( cache.empty() ? vertex_t{} : cache.back() );
+				continue;
+			}
+			// fill cache
+			cache.emplace_back( _vertices[index] );
+		}
+	}
+	this->generateIndices();
+	this->updateDescriptor();
+}
+template<typename T, typename U>
+void uf::BaseMesh<T, U>::updateDescriptor() {
+	attributes.vertex.size = sizeof(vertex_t);
+	attributes.index.size = sizeof(indices_t);
+	attributes.vertex.pointer = &this->vertices[0];
+	attributes.index.pointer = &this->indices[0];
+	attributes.vertex.length = this->vertices.size();
+	attributes.index.length = this->indices.size();
+	attributes.descriptor = vertex_t::descriptor;
+}
+template<typename T, typename U>
+void uf::BaseMesh<T, U>::destroy() {
+	this->indices.clear();
+	this->vertices.clear();
+}
+
+template<typename T, typename U>
+uf::BaseMesh<T,U> uf::BaseMesh<T,U>::simplify( float threshold ) {
+	size_t target = size_t(this->indices.size() * threshold);
+	float error = 1e-2f;
+	uf::BaseMesh<T,U> lod;
+	lod.indices.resize(this->indices.size()); // note: simplify needs space for index_count elements in the destination array, not target
+	lod.indices.resize(meshopt_simplify(&lod.indices[0], &this->indices[0], this->indices.size(), (float*) &this->vertices[0].position, this->vertices.size(), sizeof(T), target, error));
+	lod.vertices.resize(lod.indices.size() < this->vertices.size() ? lod.indices.size() : this->vertices.size()); // note: this is just to reduce the cost of resize()
+	lod.vertices.resize(meshopt_optimizeVertexFetch(&lod.vertices[0], &lod.indices[0], lod.indices.size(), &this->vertices[0], this->vertices.size(), sizeof(T)));
+	return lod;
+}
+template<typename T, typename U>
+void uf::BaseMesh<T,U>::optimize( size_t o ) {
+#if UF_USE_MESHOPTIMIZER
+	ext::meshopt::optimize( *this, o );
+#else
+	this->indices.clear();
+	this->indices.reserve(vertices.size());
+	for ( size_t i = 0; i < vertices.size(); ++i )
+		this->indices.emplace_back(i);
+#endif
+	this->updateDescriptor();
+}
+
+template<typename T, typename U>
+void uf::BaseMesh<T,U>::resizeVertices( size_t n ) {
+	this->vertices.resize(n);
+	this->updateDescriptor();
+}
+template<typename T, typename U>
+void uf::BaseMesh<T,U>::resizeIndices( size_t n ) {
+	this->indices.resize(n);
+	this->updateDescriptor();
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/noise/noise.h b/engine/inc/uf/utils/noise/noise.h
new file mode 100644
index 00000000..56f5e90d
--- /dev/null
+++ b/engine/inc/uf/utils/noise/noise.h
@@ -0,0 +1,47 @@
+#pragma once
+
+#include <uf/config.h>
+
+#include <cmath>
+#include <vector>
+#include <random>
+#include <numeric>
+#include <algorithm>
+#include <functional>
+
+#include <uf/utils/math/vector.h>
+
+namespace uf {
+	class UF_API PerlinNoise {
+	protected:
+		std::size_t m_seed;
+		std::vector<int> m_permutations;
+	public:
+		typedef std::function<double(double&)> callback_t;
+
+		PerlinNoise();
+		PerlinNoise( std::size_t seed );
+		void seed( std::size_t seed );
+		std::size_t seed() const;
+		double noise( double x, double y, double z ) const;
+		double fade(double t) const;
+		double lerp(double t, double a, double b) const;
+		double grad(int hash, double x, double y, double z) const;
+		std::vector<double> collect( uint size, const pod::Vector3d& noiseCoeff, const callback_t& callback = [](double& n)->double{
+			return n;
+		} );
+		std::vector<double> collect( const pod::Vector2ui& size, const pod::Vector3d& noiseCoeff, const callback_t& callback = [](double& n)->double{
+			return n;
+		} );
+		std::vector<double> collect( const pod::Vector3ui& size, const pod::Vector3d& noiseCoeff, const callback_t& callback = [](double& n)->double{
+			return n;
+		} );
+
+		double sample( const pod::Vector3d& position, const pod::Vector3d& noiseCoeff = { 1, 1, 1 }, const callback_t& callback = [](double& n)->double{
+			return n;
+		} );
+		double sample( const pod::Vector3f& position, const pod::Vector3d& noiseCoeff = { 1, 1, 1 }, const callback_t& callback = [](double& n)->double{
+			return n;
+		} );
+	};
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/renderer/renderer.h b/engine/inc/uf/utils/renderer/renderer.h
new file mode 100644
index 00000000..bdc9e297
--- /dev/null
+++ b/engine/inc/uf/utils/renderer/renderer.h
@@ -0,0 +1,6 @@
+#pragma once
+
+#include <uf/spec/renderer/universal.h>
+namespace uf {
+	namespace renderer = spec::renderer;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/serialize/serializable.h b/engine/inc/uf/utils/serialize/serializable.h
new file mode 100644
index 00000000..eaf5a58a
--- /dev/null
+++ b/engine/inc/uf/utils/serialize/serializable.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <uf/config.h>
+#include "serializer.h"
+
+namespace uf {
+	class UF_API Serializable {
+	protected:
+
+	public:
+		virtual Serializer::output_t serialize() = 0;
+		virtual Serializer::output_t serialize() const = 0;
+		virtual void deserialize( const Serializer& input );
+		virtual void deserialize( const Serializer::input_t& input ) = 0;
+
+		virtual void operator<<( const Serializer::input_t& input );
+		virtual void operator>>( Serializer::output_t& output );
+	};
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/serialize/serializer.h b/engine/inc/uf/utils/serialize/serializer.h
new file mode 100644
index 00000000..de33fdee
--- /dev/null
+++ b/engine/inc/uf/utils/serialize/serializer.h
@@ -0,0 +1,85 @@
+#pragma once
+
+#include <uf/config.h>
+
+#include <uf/utils/userdata/userdata.h>
+#include <uf/ext/lua/lua.h>
+#include <uf/ext/json/json.h>
+
+#include <string>
+#include <type_traits>
+
+namespace uf {
+	class UF_API Serializer : public ext::json::Document {
+	public:
+		typedef std::string output_t;
+		typedef std::string  input_t;
+	
+		Serializer( const std::string& str = "{}" );
+		Serializer( const ext::json::base_value& );
+		Serializer( const ext::json::Value& );
+	#if UF_USE_LUA
+		Serializer( const sol::table& );
+	#endif
+		
+		Serializer::output_t serialize( bool pretty = false ) const;
+		Serializer::output_t serialize( size_t precision, bool pretty = false ) const;
+		void deserialize( const std::string& );
+
+		// serializeable
+		template<typename T>
+		static bool serializeable() {
+			return std::is_standard_layout<T>::value && std::is_trivial<T>::value; // std::is_pod<T>::value;
+		}
+		template<typename T>
+		static bool serializeable( const T& input ) {
+			return serializeable<T>();
+		}
+	
+		// serialize to base64
+		template<typename T>
+		static uf::Serializer toBase64( const T& input ) {
+			// ensure this is a safe type to serialize
+			if ( !serializeable(input) ) return std::string("");
+			pod::Userdata* userdata = uf::userdata::create(input);
+			uf::Serializer res;
+			res["base64"] = uf::userdata::toBase64( userdata );
+			uf::userdata::destroy( userdata );
+			return res;
+		}
+		// convert from base64 to POD
+		template<typename T>
+		static T fromBase64( const uf::Serializer& input ) {
+			// ensure this is a safe type to serialize
+			if ( !serializeable(input) ) return T();
+			// ensure it's "proper"
+			if ( !input["base64"].is<std::string>() ) return T();
+			pod::Userdata* userdata = uf::userdata::fromBase64(input["base64"].as<std::string>());
+			T res = uf::userdata::get<T>( userdata );
+			uf::userdata::destroy( userdata );
+			return res;
+		}
+	
+		bool readFromFile( const std::string& from, const std::string& hash = "" );
+		bool writeToFile( const std::string& to ) const;
+		bool writeToFile( const std::string& to, size_t precision ) const;
+		
+		void merge( const uf::Serializer& other, bool priority = true );
+		void import( const uf::Serializer& other );
+		ext::json::Value& path( const std::string& );
+
+		operator Serializer::output_t();
+		operator Serializer::output_t() const;
+		uf::Serializer& operator=( const std::string& str );
+		uf::Serializer& operator=( const ext::json::base_value& json );
+		uf::Serializer& operator=( const ext::json::Value& json );
+	#if UF_USE_LUA
+		uf::Serializer& operator=( const sol::table& json );
+	#endif
+		uf::Serializer& operator<<( const std::string& str );
+		uf::Serializer& operator>>( std::string& str );
+		const uf::Serializer& operator>>( std::string& str ) const;
+	};
+
+	typedef Serializer Metadata;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/singletons/pre_main.h b/engine/inc/uf/utils/singletons/pre_main.h
new file mode 100644
index 00000000..7dc80485
--- /dev/null
+++ b/engine/inc/uf/utils/singletons/pre_main.h
@@ -0,0 +1,11 @@
+#pragma once
+
+#include <uf/config.h>
+#include <functional>
+
+namespace uf {
+	struct UF_API StaticInitialization {
+	public:
+		StaticInitialization(std::function<void()>);
+	};
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/string/base64.h b/engine/inc/uf/utils/string/base64.h
new file mode 100644
index 00000000..053d41c4
--- /dev/null
+++ b/engine/inc/uf/utils/string/base64.h
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <uf/config.h>
+
+#include <vector>
+#include <string>
+#include <stdint.h>
+
+namespace uf {
+	namespace base64 {
+		UF_API std::string encode( const uint8_t*, std::size_t );
+		UF_API std::vector<uint8_t> decode( const std::string& );
+
+		template<typename T>
+		std::string encode( const T& input ) {
+			return encode( (const uint8_t*) &input[0], input.size() * sizeof( input[0] ) );
+		}
+		template<typename T>
+		std::vector<uint8_t> decode( const T& input ) {
+			return decode( (const uint8_t*) &input[0], input.size() * sizeof( input[0] ) );
+		}
+	}
+	namespace string {
+		namespace base64 {
+			UF_API std::string encode( const std::string& );
+			UF_API std::string decode( const std::string& );
+		}
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/string/encoding.h b/engine/inc/uf/utils/string/encoding.h
new file mode 100644
index 00000000..4423fb9b
--- /dev/null
+++ b/engine/inc/uf/utils/string/encoding.h
@@ -0,0 +1,16 @@
+#pragma once
+
+// References:
+//
+// http://www.unicode.org/
+// http://www.unicode.org/Public/PROGRAMS/CVTUTF/ConvertUTF.c
+// http://www.unicode.org/Public/PROGRAMS/CVTUTF/ConvertUTF.h
+// http://people.w3.org/rishida/scripts/uniview/conversion
+
+#include <uf/config.h>
+#include "locale.h"
+#include "encoding/default.h"
+#include "encoding/ansi.h"
+#include "encoding/utf8.h"
+#include "encoding/utf16.h"
+#include "encoding/utf32.h"
\ No newline at end of file
diff --git a/engine/inc/uf/utils/string/encoding/ansi.h b/engine/inc/uf/utils/string/encoding/ansi.h
new file mode 100644
index 00000000..4e8ca433
--- /dev/null
+++ b/engine/inc/uf/utils/string/encoding/ansi.h
@@ -0,0 +1,40 @@
+#pragma once
+#include "default.h"
+
+namespace uf {
+	namespace locale {
+		class UF_API Ansi : public Encoding {
+		public:
+			typedef uint8_t literal_t;
+		protected:
+			typedef literal_t Literal;
+			Literal m_literal;
+		public:
+		// 	Converts from UTF-8 to UTF-32
+			template<typename Input>
+			static Input UF_API_CALL decode( Input input, Input dead, Encoding::Literal& output, Encoding::Literal fallback = 0 );
+			template<typename Input>
+			inline static Encoding::Literal UF_API_CALL decode( Input input, Input dead = 0, Encoding::Literal fallback = 0 ) {
+				Encoding::Literal literal;
+				Ansi::decode(input, dead, literal, fallback);
+				return literal;
+			}
+		// 	Converts from UTF-32 to UTF-8
+			template<typename Input, typename Output>
+			static Output UF_API_CALL encode( Input input, Output output, Literal fallback = 0 );
+		// 	Go to the next character in UTF-8's sequence
+			template<typename Input>
+			static Input UF_API_CALL next(Input begin, Input end);
+		// 	Number of characters in UTF-8's sequence
+			template<typename Input>
+			static Input UF_API_CALL length(Input begin, Input end);
+		// 	Encoding's name
+			static std::string UF_API_CALL getName() { return "ANSI"; }
+		};
+	}
+}
+/*
+#include "encoding_constructor.h"
+ENCODING_CONSTRUCTOR(Ansi: public Encoding, uint8_t, "UTF-8")
+*/
+#include "ansi.inl"
\ No newline at end of file
diff --git a/engine/inc/uf/utils/string/encoding/ansi.inl b/engine/inc/uf/utils/string/encoding/ansi.inl
new file mode 100644
index 00000000..46ebd789
--- /dev/null
+++ b/engine/inc/uf/utils/string/encoding/ansi.inl
@@ -0,0 +1,58 @@
+//  Converts from ANSI to default encoding (UTF-32)
+template<typename Input>
+Input UF_API_CALL uf::locale::Ansi::decode( Input input, Input, Encoding::Literal& output, Encoding::Literal fallback) {
+	// On Windows, gcc's standard library (glibc++) has almost
+	// no support for Unicode stuff. As a consequence, in this
+	// context we can only use the default locale and ignore
+	// the one passed as parameter.
+
+	#if defined(UF_ENV_WINDOWS) && 								/* if Windows ... 								*/\
+	   (defined(__GLIBCPP__) || defined (__GLIBCXX__)) && 		/* ... and standard library is glibc++ ... 		*/\
+	  !(defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)) 	/* ... and STLPort is not used on top of it 	*/
+		wchar_t character = 0;
+		mbtowc(&character, &input, 1);
+		return (uint32_t) character;
+	#else
+		// Get the facet of the locale which deals with character conversion
+		const std::ctype<wchar_t>& facet = std::use_facet< std::ctype<wchar_t> >(std::locale(""));
+
+		// Use the facet to convert each character of the input string
+		return (uint32_t) facet.widen(input);
+	#endif
+}
+
+//  Converts from default encoding (UTF-32) to ANSI
+template<typename Input, typename Output>
+Output UF_API_CALL uf::locale::Ansi::encode( Input input, Output output, Literal fallback ) {
+	// On Windows, gcc's standard library (glibc++) has almost
+	// no support for Unicode stuff. As a consequence, in this
+	// context we can only use the default locale and ignore
+	// the one passed as parameter.
+
+	#if defined(UF_ENV_WINDOWS) && 								/* if Windows ... 								*/\
+	   (defined(__GLIBCPP__) || defined (__GLIBCXX__)) && 		/* ... and standard library is glibc++ ... 		*/\
+	  !(defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)) 	/* ... and STLPort is not used on top of it 	*/
+		char character = 0;
+		if (wctomb(&character, (wchar_t) input) >= 0) 	*output++ = character;
+		else if (fallback) 								*output++ = fallback;
+	#else
+		// Get the facet of the locale which deals with character conversion
+		const std::ctype<wchar_t>& facet = std::use_facet< std::ctype<wchar_t> >(std::locale(""));
+
+		// Use the facet to convert each character of the input string
+		*output++ = facet.narrow((wchar_t) input, fallback);
+	#endif
+	return output;
+}
+
+//  Go to the next character in ANSI's sequence
+template<typename Input>
+Input UF_API_CALL uf::locale::Ansi::next(Input begin, Input end) {
+	return ++begin;
+}
+
+//  Number of characters in ANSI's sequence
+template<typename Input>
+Input UF_API_CALL uf::locale::Ansi::length(Input begin, Input end) {
+	return begin - end;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/string/encoding/default.h b/engine/inc/uf/utils/string/encoding/default.h
new file mode 100644
index 00000000..1ecd7b9d
--- /dev/null
+++ b/engine/inc/uf/utils/string/encoding/default.h
@@ -0,0 +1,49 @@
+#pragma once
+
+#include <uf/config.h>
+#include <string>
+
+namespace uf {
+	namespace locale {
+		class UF_API Literal {
+		public:
+			typedef uint8_t min_t;
+			typedef uint32_t max_t;
+			typedef uint32_t default_t;
+		};
+
+		// Internal encoding used is UTF-32
+		class UF_API Encoding {
+		public:
+			typedef uf::locale::Literal::default_t literal_t;
+		protected:
+			typedef literal_t Literal;
+			Literal m_literal;
+		public:
+		// 	Converts from [this encoding] to [arbitrary encoding]
+			template<typename Input>
+			static Input UF_API_CALL decode( Input begin, Input end, Literal& output, Literal fallback = 0 );
+			template<typename Input>
+			inline static Literal UF_API_CALL decode( Input begin, Input end, Literal fallback = 0 ) {
+				return *begin++;
+			}
+		// 	Converts from [arbitrary encoding] to [this encoding]
+			template<typename Input, typename Output>
+			static Output UF_API_CALL encode( Input input, Output output, Literal fallback = 0 );
+		// 	Go to the next character in [this encoding]'s sequence
+			template<typename Input>
+			static Input UF_API_CALL next(Input begin, Input end);
+		// 	Number of characters in [this encoding]'s sequence
+			template<typename Input>
+			static Input UF_API_CALL length(Input begin, Input end);
+		// 	Encoding's name
+			static std::string UF_API_CALL getName() { return "UTF-32"; }
+		};
+
+	}
+}
+/*
+#include "encoding_constructor.h"
+ENCODING_CONSTRUCTOR(Encoding, uf::locale::Literal::default_t, "UTF-32")
+*/
+#include "default.inl"
\ No newline at end of file
diff --git a/engine/inc/uf/utils/string/encoding/default.inl b/engine/inc/uf/utils/string/encoding/default.inl
new file mode 100644
index 00000000..5d2e855b
--- /dev/null
+++ b/engine/inc/uf/utils/string/encoding/default.inl
@@ -0,0 +1,27 @@
+#include <uf/config.h>
+
+// 	Converts from UTF-32 to default encoding (UTF-32) (nothing happens)
+template<typename Input>
+Input UF_API_CALL uf::locale::Encoding::decode( Input begin, Input end, Encoding::Literal& output, Encoding::Literal fallback) {
+	output = *begin++;
+	return begin;
+}
+
+// 	Converts from default encoding (UTF-32) to UTF-32 (nothing happens)
+template<typename Input, typename Output>
+Output UF_API_CALL uf::locale::Encoding::encode( Input input, Output output, Literal fallback ) {
+	*output++ = input;
+	return output;
+}
+
+// 	Go to the next character in UTF-32's sequence
+template<typename Input>
+Input UF_API_CALL uf::locale::Encoding::next(Input begin, Input end) {
+	return ++begin;
+}
+
+// 	Number of characters in UTF-32's sequence
+template<typename Input>
+Input UF_API_CALL uf::locale::Encoding::length(Input begin, Input end) {
+	return begin - end;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/string/encoding/encoding_constructor.h b/engine/inc/uf/utils/string/encoding/encoding_constructor.h
new file mode 100644
index 00000000..00ba9800
--- /dev/null
+++ b/engine/inc/uf/utils/string/encoding/encoding_constructor.h
@@ -0,0 +1,32 @@
+#pragma once
+
+#define ENCODING_CONSTRUCTOR(CLASS_NAME, LITERAL_TYPE, ENCODING_NAME) \
+namespace uf { \
+	namespace locale { \
+		// Internal encoding used is UTF-32 \
+		class UF_API CLASS_NAME { \
+		public: \
+			typedef LITERAL_TYPE literal_t; \
+		protected: \
+			typedef literal_t Literal; \
+			Literal m_literal; \
+		public: \
+		// 	Converts from [this encoding] to [arbitrary encoding] \
+			template<typename Input> \
+			static Input UF_API_CALL decode( Input begin, Input end, Encoding::Literal& output, Encoding::Literal fallback = 0 ); \
+			template<typename Input> \
+			static Encoding::Literal UF_API_CALL decode( Input begin, Input end, Encoding::Literal fallback = 0 ); \
+		// 	Converts from [arbitrary encoding] to [this encoding] \
+			template<typename Input, typename Output> \
+			static Output UF_API_CALL encode( Input input, Output output, Output fallback = 0 ); \
+		// 	Go to the next character in [this encoding]'s sequence \
+			template<typename Input> \
+			static Input UF_API_CALL next(Input begin, Input end); \
+		// 	Number of characters in [this encoding]'s sequence \
+			template<typename Input> \
+			static Input UF_API_CALL length(Input begin, Input end); \
+		// 	Encoding's name \
+			static std::string name = ENCODING_NAME; \
+		}; \
+	} \
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/string/encoding/utf.inl b/engine/inc/uf/utils/string/encoding/utf.inl
new file mode 100644
index 00000000..ef767fbb
--- /dev/null
+++ b/engine/inc/uf/utils/string/encoding/utf.inl
@@ -0,0 +1,84 @@
+// 	Converts from [this encoding] to [arbitrary encoding]
+template<typename Input>
+Input UF_API_CALL uf::locale::Utf8::decode( Input begin, Input end, Literal& output, Literal fallback) {
+	static const int utf8_table[256] = {
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+		2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5
+	};
+	static const uint32_t utf32_offsets[6] = {
+		0x00000000, 0x00003080, 0x000E2080, 0x03C82080, 0xFA082080, 0x82082080
+	};
+	int length = utf8_table[static_cast<uint8_t>(*begin)];
+	if (begin + length < end) {
+		output = 0;
+		switch (length) {
+			case 5: output += static_cast<uint8_t>(*begin++); output <<= 6;
+			case 4: output += static_cast<uint8_t>(*begin++); output <<= 6;
+			case 3: output += static_cast<uint8_t>(*begin++); output <<= 6;
+			case 2: output += static_cast<uint8_t>(*begin++); output <<= 6;
+			case 1: output += static_cast<uint8_t>(*begin++); output <<= 6;
+			case 0: output += static_cast<uint8_t>(*begin++);
+		}
+		output -= utf32_offsets[length];
+	} else {
+		begin = end;
+		output = replacement;
+	}
+
+	return begin;
+}
+
+template<typename Input>
+Literal UF_API_CALL uf::locale::Utf8::decode( Input begin, Input end, Literal fallback ) {
+	Literal literal;
+	this->decode(begin, end, literal, fallback);
+	return literal;
+}
+
+// 	Converts from [arbitrary encoding] to [this encoding]
+template<typename Input, typename Output>
+Output UF_API_CALL uf::locale::Utf8::encode( Input input, Output output, Output fallback ) {
+	static const uint8_t firstBytes[7] = {
+		0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC
+	};
+
+	if ((input > 0x0010FFFF) || ((input >= 0xD800) && (input <= 0xDBFF))) {
+		if (replacement) *output++ = replacement;
+	} else {
+		uint8_t characters[4];
+		std::size_t length = 1;
+		if	  		(input <  0x00000080) length = 1;
+		else if 	(input <  0x00000800) length = 2;
+		else if 	(input <  0x00010000) length = 3;
+		else if 	(input <= 0x0010FFFF) length = 4;
+		switch (length) {
+			case 4: characters[3] = static_cast<uint8_t>((input | 0x80) & 0xBF); 		input >>= 6;
+			case 3: characters[2] = static_cast<uint8_t>((input | 0x80) & 0xBF); 		input >>= 6;
+			case 2: characters[1] = static_cast<uint8_t>((input | 0x80) & 0xBF); 		input >>= 6;
+			case 1: characters[0] = static_cast<uint8_t>((input | firstBytes[length]));
+		}
+		output = std::copy(characters, characters + length, output);
+	}
+	return output;
+}
+
+// 	Go to the next character in [this encoding]'s sequence
+template<typename Input>
+Input UF_API_CALL uf::locale::Utf8::next(Input begin, Input end) {
+	uint32_t codepoint;
+	return this->decode( begin, end, codepoint );
+}
+
+// 	Number of characters in [this encoding]'s sequence
+template<typename Input>
+Input UF_API_CALL uf::locale::Utf8::length(Input begin, Input end) {
+	std::size_t length = 0;
+	while ( begin < end ) begin = this->next( begin, end ), ++length;
+	return length;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/string/encoding/utf16.h b/engine/inc/uf/utils/string/encoding/utf16.h
new file mode 100644
index 00000000..45e70492
--- /dev/null
+++ b/engine/inc/uf/utils/string/encoding/utf16.h
@@ -0,0 +1,40 @@
+#pragma once
+#include "default.h"
+
+namespace uf {
+	namespace locale {
+		class UF_API Utf16 : public Encoding {
+		public:
+			typedef uint16_t literal_t;
+		protected:
+			typedef literal_t Literal;
+			Literal m_literal;
+		public:
+		// 	Converts from UTF-16 to UTF-32
+			template<typename Input>
+			static Input UF_API_CALL decode( Input begin, Input end, Encoding::Literal& output, Encoding::Literal fallback = 0 );
+			template<typename Input>
+			inline static Encoding::Literal UF_API_CALL decode( Input begin, Input end, Encoding::Literal fallback = 0 ) {
+				Encoding::Literal literal;
+				Utf16::decode(begin, end, literal, fallback);
+				return literal;
+			}
+		// 	Converts from UTF-32 to UTF-16
+			template<typename Input, typename Output>
+			static Output UF_API_CALL encode( Input input, Output output, Literal fallback = 0 );
+		// 	Go to the next character in UTF-16's sequence
+			template<typename Input>
+			static Input UF_API_CALL next(Input begin, Input end);
+		// 	Number of characters in UTF-16's sequence
+			template<typename Input>
+			static Input UF_API_CALL length(Input begin, Input end);
+		// 	Encoding's name
+			static std::string UF_API_CALL getName() { return "UTF-16"; }
+		};
+	}
+}
+/*
+#include "encoding_constructor.h"
+ENCODING_CONSTRUCTOR(Utf16: public Encoding, uint16_t, "UTF-16")
+*/
+#include "utf16.inl"
\ No newline at end of file
diff --git a/engine/inc/uf/utils/string/encoding/utf16.inl b/engine/inc/uf/utils/string/encoding/utf16.inl
new file mode 100644
index 00000000..8d993556
--- /dev/null
+++ b/engine/inc/uf/utils/string/encoding/utf16.inl
@@ -0,0 +1,50 @@
+#include <uf/config.h>
+#include "default.h"
+
+// 	Converts from UTF-16 to default encoding (UTF-32)
+template<typename Input>
+Input UF_API_CALL uf::locale::Utf16::decode( Input begin, Input end, Encoding::Literal& output, Encoding::Literal fallback) {
+	uint16_t first = *begin++;
+	if ((first >= 0xD800) && (first <= 0xDBFF)) {
+		if (begin < end) {
+			uint32_t second = *begin++;
+			output = ((second >= 0xDC00) && (second <= 0xDFFF)) ? static_cast<uint32_t>(((first - 0xD800) << 10) + (second - 0xDC00) + 0x0010000) : fallback;
+		}
+		else begin = end, output = fallback;
+	} else output = first;
+
+	return begin;
+}
+
+// 	Converts from default encoding (UTF-32) to UTF-16
+template<typename Input, typename Output>
+Output UF_API_CALL uf::locale::Utf16::encode( Input input, Output output, Literal fallback ) {
+	if (input < 0xFFFF) {
+		if ((input >= 0xD800) && (input <= 0xDFFF)) {
+			if (fallback) 	*output++ = fallback;
+			else 			*output++ = static_cast<uint16_t>(input);
+		}
+	} else if (input > 0x0010FFFF) {
+		if (fallback) 		*output++ = fallback;
+	} else {
+		input -= 0x0010000;
+		*output++ = static_cast<uint16_t>((input >> 10)	 	+ 0xD800);
+		*output++ = static_cast<uint16_t>((input & 0x3FFUL)	+ 0xDC00);
+	}
+	return output;
+}
+
+// 	Go to the next character in UTF-16's sequence
+template<typename Input>
+Input UF_API_CALL uf::locale::Utf16::next(Input begin, Input end) {
+	uint32_t codepoint;
+	return Utf16::decode( begin, end, codepoint );
+}
+
+// 	Number of characters in UTF-16's sequence
+template<typename Input>
+Input UF_API_CALL uf::locale::Utf16::length(Input begin, Input end) {
+	std::size_t length = 0;
+	while ( begin < end ) begin = Utf16::next( begin, end ), ++length;
+	return length;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/string/encoding/utf32.h b/engine/inc/uf/utils/string/encoding/utf32.h
new file mode 100644
index 00000000..605ab728
--- /dev/null
+++ b/engine/inc/uf/utils/string/encoding/utf32.h
@@ -0,0 +1,38 @@
+#pragma once
+#include "default.h"
+
+namespace uf {
+	namespace locale {
+		class UF_API Utf32 : public Encoding {
+		public:
+			typedef uint32_t literal_t;
+		protected:
+			typedef literal_t Literal;
+			Literal m_literal;
+		public:
+		// 	Converts from UTF-32 to default encoding (UTF-32) (so nothing)
+			template<typename Input>
+			static Input UF_API_CALL decode( Input begin, Input end, Encoding::Literal& output, Encoding::Literal fallback = 0 );
+			template<typename Input>
+			inline static Encoding::Literal UF_API_CALL decode( Input begin, Input end, Encoding::Literal fallback = 0 ) {
+				return *begin++;
+			}
+		// 	Converts from default encoding (UTF-32) to UTF-32 (so nothing)
+			template<typename Input, typename Output>
+			static Output UF_API_CALL encode( Input input, Output output, Literal fallback = 0 );
+		// 	Go to the next character in UTF-32's sequence
+			template<typename Input>
+			static Input UF_API_CALL next(Input begin, Input end);
+		// 	Number of characters in UTF-32's sequence
+			template<typename Input>
+			static Input UF_API_CALL length(Input begin, Input end);
+		// 	Encoding's name
+			static std::string UF_API_CALL getName() { return "UTF-32"; }
+		};
+	}
+}
+/*
+#include "encoding_constructor.h"
+ENCODING_CONSTRUCTOR(Utf32: public Encoding, uint32_t, "UTF-32")
+*/
+#include "utf32.inl"
\ No newline at end of file
diff --git a/engine/inc/uf/utils/string/encoding/utf32.inl b/engine/inc/uf/utils/string/encoding/utf32.inl
new file mode 100644
index 00000000..4774991d
--- /dev/null
+++ b/engine/inc/uf/utils/string/encoding/utf32.inl
@@ -0,0 +1,28 @@
+#include <uf/config.h>
+#include "default.h"
+
+// 	Converts from UTF-32 to default encoding (UTF-32) (nothing happens)
+template<typename Input>
+Input UF_API_CALL uf::locale::Utf32::decode( Input begin, Input end, Encoding::Literal& output, Encoding::Literal fallback) {
+	output = *begin++;
+	return begin;
+}
+
+// 	Converts from default encoding (UTF-32) to UTF-32 (nothing happens)
+template<typename Input, typename Output>
+Output UF_API_CALL uf::locale::Utf32::encode( Input input, Output output, Literal fallback ) {
+	*output++ = input;
+	return output;
+}
+
+// 	Go to the next character in UTF-32's sequence
+template<typename Input>
+Input UF_API_CALL uf::locale::Utf32::next(Input begin, Input end) {
+	return ++begin;
+}
+
+// 	Number of characters in UTF-32's sequence
+template<typename Input>
+Input UF_API_CALL uf::locale::Utf32::length(Input begin, Input end) {
+	return begin - end;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/string/encoding/utf8.h b/engine/inc/uf/utils/string/encoding/utf8.h
new file mode 100644
index 00000000..605dd2cf
--- /dev/null
+++ b/engine/inc/uf/utils/string/encoding/utf8.h
@@ -0,0 +1,40 @@
+#pragma once
+#include "default.h"
+
+namespace uf {
+	namespace locale {
+		class UF_API Utf8 : public Encoding {
+		public:
+			typedef uint8_t literal_t;
+		protected:
+			typedef literal_t Literal;
+			Literal m_literal;
+		public:
+		// 	Converts from UTF-8 to UTF-32
+			template<typename Input>
+			static Input UF_API_CALL decode( Input begin, Input end, Encoding::Literal& output, Encoding::Literal fallback = 0 );
+			template<typename Input>
+			inline static Encoding::Literal UF_API_CALL decode( Input begin, Input end, Encoding::Literal fallback = 0 ) {
+				Encoding::Literal literal;
+				Utf8::decode(begin, end, literal, fallback);
+				return literal;
+			}
+		// 	Converts from UTF-32 to UTF-8
+			template<typename Input, typename Output>
+			static Output UF_API_CALL encode( Input input, Output output, Literal fallback = 0 );
+		// 	Go to the next character in UTF-8's sequence
+			template<typename Input>
+			static Input UF_API_CALL next(Input begin, Input end);
+		// 	Number of characters in UTF-8's sequence
+			template<typename Input>
+			static Input UF_API_CALL length(Input begin, Input end);
+		// 	Encoding's name
+			static std::string UF_API_CALL getName() { return "UTF-8"; }
+		};
+	}
+}
+/*
+#include "encoding_constructor.h"
+ENCODING_CONSTRUCTOR(Utf8: public Encoding, uint8_t, "UTF-8")
+*/
+#include "utf8.inl"
\ No newline at end of file
diff --git a/engine/inc/uf/utils/string/encoding/utf8.inl b/engine/inc/uf/utils/string/encoding/utf8.inl
new file mode 100644
index 00000000..131bfaf1
--- /dev/null
+++ b/engine/inc/uf/utils/string/encoding/utf8.inl
@@ -0,0 +1,82 @@
+#include <uf/config.h>
+#include "default.h"
+
+// Converts from UTF-8 to default encoding (UTF-32)
+template<typename Input>
+Input UF_API_CALL uf::locale::Utf8::decode( Input begin, Input end, Encoding::Literal& output, Encoding::Literal fallback) {
+	static const int utf8_table[256] = {
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+		2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5
+	};
+	static const uint32_t utf32_offsets[6] = {
+		0x00000000, 0x00003080, 0x000E2080, 0x03C82080, 0xFA082080, 0x82082080
+	};
+	int length = utf8_table[static_cast<uint8_t>(*begin)];
+
+	if ( uf::locale::Encoding::getName() == "UTF-32" ) {
+		if (begin + length < end) {
+			output = 0;
+			switch (length) {
+				case 5: output += static_cast<uint8_t>(*begin++); output <<= 6;
+				case 4: output += static_cast<uint8_t>(*begin++); output <<= 6;
+				case 3: output += static_cast<uint8_t>(*begin++); output <<= 6;
+				case 2: output += static_cast<uint8_t>(*begin++); output <<= 6;
+				case 1: output += static_cast<uint8_t>(*begin++); output <<= 6;
+				case 0: output += static_cast<uint8_t>(*begin++);
+			}
+			output -= utf32_offsets[length];
+		} else {
+			begin = end;
+			output = fallback;
+		}
+	}
+	return begin;
+}
+
+// Converts from default encoding (UTF-32) to UTF-8
+template<typename Input, typename Output>
+Output UF_API_CALL uf::locale::Utf8::encode( Input input, Output output, Literal fallback ) {
+	static const uint8_t firstBytes[7] = {
+		0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC
+	};
+
+	if ((input > 0x0010FFFF) || ((input >= 0xD800) && (input <= 0xDBFF))) {
+		if (fallback) *output++ = fallback;
+	} else {
+		uint8_t characters[4];
+		std::size_t length = 1;
+		if	  		(input <  0x00000080) length = 1;
+		else if 	(input <  0x00000800) length = 2;
+		else if 	(input <  0x00010000) length = 3;
+		else if 	(input <= 0x0010FFFF) length = 4;
+		switch (length) {
+			case 4: characters[3] = static_cast<uint8_t>((input | 0x80) & 0xBF); 		input >>= 6;
+			case 3: characters[2] = static_cast<uint8_t>((input | 0x80) & 0xBF); 		input >>= 6;
+			case 2: characters[1] = static_cast<uint8_t>((input | 0x80) & 0xBF); 		input >>= 6;
+			case 1: characters[0] = static_cast<uint8_t>((input | firstBytes[length]));
+		}
+		output = std::copy(characters, characters + length, output);
+	}
+	return output;
+}
+
+// Go to the next character in UTF-8's sequence
+template<typename Input>
+Input UF_API_CALL uf::locale::Utf8::next(Input begin, Input end) {
+	uint32_t codepoint;
+	return Utf8::decode( begin, end, codepoint );
+}
+
+// Number of characters in UTF-8's sequence
+template<typename Input>
+Input UF_API_CALL uf::locale::Utf8::length(Input begin, Input end) {
+	std::size_t length = 0;
+	while ( begin < end ) begin = Utf8::next( begin, end ), ++length;
+	return length;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/string/ext.h b/engine/inc/uf/utils/string/ext.h
new file mode 100644
index 00000000..09b38deb
--- /dev/null
+++ b/engine/inc/uf/utils/string/ext.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <uf/config.h>
+#include <string>
+#include <vector>
+#include <sstream>
+
+#include "io.h"
+
+namespace uf {
+	namespace string {
+
+		std::string UF_API replace( const std::string&, const std::string&, const std::string& );
+		std::string UF_API lowercase( const std::string& );
+		std::string UF_API uppercase( const std::string& );
+		std::vector<std::string> UF_API split( const std::string&, const std::string& );
+		std::string UF_API si( double value, const std::string& unit, size_t precision = 3 );
+		bool UF_API contains( const std::string&, const std::string& );
+
+		template<typename T>
+		std::string /*UF_API*/ join( const T&, const std::string& = "\n", bool = false );
+		template<typename T>
+		std::string /*UF_API*/ toString( const T& );
+	}
+}
+
+#include "ext.inl"
\ No newline at end of file
diff --git a/engine/inc/uf/utils/string/ext.inl b/engine/inc/uf/utils/string/ext.inl
new file mode 100644
index 00000000..304286b0
--- /dev/null
+++ b/engine/inc/uf/utils/string/ext.inl
@@ -0,0 +1,16 @@
+template<typename T>
+std::string /*UF_API*/ uf::string::join( const T& container, const std::string& token, bool trailing ) {
+	std::stringstream ss;
+	size_t len = container.size();
+	for ( size_t i = 0; i < len; ++i ) {
+		ss << container[i];
+		if ( trailing || i + 1 < len ) ss << token;
+	}
+	return ss.str();
+}
+template<typename T>
+std::string /*UF_API*/ uf::string::toString( const T& var ) {
+	std::stringstream ss;
+	ss << &var;
+	return ss.str();
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/string/hash.h b/engine/inc/uf/utils/string/hash.h
new file mode 100644
index 00000000..7f3b6448
--- /dev/null
+++ b/engine/inc/uf/utils/string/hash.h
@@ -0,0 +1,20 @@
+#pragma once
+
+#include <uf/config.h>
+
+#include <vector>
+#include <string>
+#include <stdint.h>
+#include <picosha2.h>
+
+namespace uf {
+	namespace string {
+		template<typename T>
+		std::string sha256( const T& input ) {
+		//	std::vector<unsigned char> hash(picosha2::k_digest_size);
+		//	picosha2::hash256(input.begin(), input.end(), hash);
+		//	return picosha2::bytes_to_hex_string(hash.begin(), hash.end());
+			return picosha2::hash256_hex_string(input);
+		}
+	}
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/string/io.h b/engine/inc/uf/utils/string/io.h
new file mode 100644
index 00000000..f8b784be
--- /dev/null
+++ b/engine/inc/uf/utils/string/io.h
@@ -0,0 +1,3 @@
+#pragma once
+
+#include <uf/utils/io/file.h>
\ No newline at end of file
diff --git a/engine/inc/uf/utils/string/locale.h b/engine/inc/uf/utils/string/locale.h
new file mode 100644
index 00000000..5b556010
--- /dev/null
+++ b/engine/inc/uf/utils/string/locale.h
@@ -0,0 +1,8 @@
+#include <uf/config.h>
+#include <locale>
+
+namespace uf {	
+	namespace locale {
+		extern UF_API std::string current;
+	};
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/string/rle.h b/engine/inc/uf/utils/string/rle.h
new file mode 100644
index 00000000..af4f7867
--- /dev/null
+++ b/engine/inc/uf/utils/string/rle.h
@@ -0,0 +1,48 @@
+#pragma once
+
+#include <uf/config.h>
+
+#include <vector>
+#include <stdint.h>
+
+namespace pod {
+	template<typename T, typename U = uint16_t>
+	struct RLE {
+		typedef std::vector<pod::RLE<T,U>> string_t;
+		typedef U length_t;
+		typedef T value_t;
+		U length;
+		T value;
+	};
+}
+
+namespace uf {
+	namespace rle {
+		template<typename T, typename U = uint16_t>
+		typename pod::RLE<T,U>::string_t encode( const std::vector<T>& );
+		template<typename T, typename U = uint16_t>
+		std::vector<T> decode( const pod::RLE<T,U>& );
+	}
+}
+
+#include "rle.inl"
+
+/*
+namespace pod {
+	struct RLE {
+		typedef std::vector<pod::RLE> string_t;
+		uint16_t length;
+		uint16_t value;
+	};
+}
+
+namespace uf {
+	namespace rle {
+		UF_API pod::RLE::string_t encode( const std::vector<uint16_t>& );
+		UF_API std::vector<uint16_t> decode( const pod::RLE::string_t& );
+
+		UF_API pod::RLE::string_t wrap( const std::vector<uint16_t>& );
+		UF_API std::vector<uint16_t> unwrap( const pod::RLE::string_t& );
+	}
+}
+*/
\ No newline at end of file
diff --git a/engine/inc/uf/utils/string/rle.inl b/engine/inc/uf/utils/string/rle.inl
new file mode 100644
index 00000000..f3e1e833
--- /dev/null
+++ b/engine/inc/uf/utils/string/rle.inl
@@ -0,0 +1,26 @@
+template<typename T, typename U>
+typename pod::RLE<T,U>::string_t uf::rle::encode( const std::vector<T>& source ) {
+	typename pod::RLE<T,U>::string_t destination;
+	destination.reserve( source.size() );
+
+	for ( std::size_t i = 0; i < source.size(); ++i ) {
+		pod::RLE<T,U> reg = { 1, source[i] };
+		while ( i + 1 < source.size() && source[i] == source[i + 1] ) ++reg.length, ++i;
+		destination.push_back( reg );
+	}
+
+	destination.shrink_to_fit();
+	return destination;
+}
+template<typename T, typename U>
+std::vector<T> uf::rle::decode( const pod::RLE<T,U>& source ) {
+	std::vector<T> destination;
+
+	for ( auto& s : source ) {
+		destination.reserve( destination.size() + s.length );
+		for ( std::size_t i = 0; i < s.length; ++i ) destination.push_back(s.value);
+	}
+
+	destination.shrink_to_fit();
+	return destination;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/string/string.h b/engine/inc/uf/utils/string/string.h
new file mode 100644
index 00000000..c95a62fd
--- /dev/null
+++ b/engine/inc/uf/utils/string/string.h
@@ -0,0 +1,114 @@
+#pragma once
+
+#include <uf/config.h>
+
+#include "encoding.h"
+#include <string>
+#include <locale>
+#include <cstring>
+
+namespace uf {
+	class UF_API String {
+	public:
+		typedef uf::locale::Utf8 						encoding_t;
+		typedef uf::String::encoding_t::literal_t		literal_t;
+		typedef std::basic_string<literal_t> 			string_t;
+
+		typedef uf::String::string_t::iterator 			iterator_t;
+		typedef uf::String::string_t::const_iterator 	const_iterator_t;
+	protected:
+		uf::String::string_t m_string;
+	public:
+	/// C-tors
+	// 	Default C-tor
+		UF_API_CALL String();
+	// 	ANSI literals/strings
+		UF_API_CALL String( char ch );
+		UF_API_CALL String( const char* c_str );
+		UF_API_CALL String( const std::basic_string<char>& str );
+
+	// 	Wide literals/strings
+		UF_API_CALL String( wchar_t ch );
+		UF_API_CALL String( const wchar_t* c_str );
+		UF_API_CALL String( const std::basic_string<wchar_t>& str );
+
+	// 	UTF-8 literals/strings
+		UF_API_CALL String( uint8_t ch );
+		UF_API_CALL String( const uint8_t* c_str );
+		UF_API_CALL String( const std::basic_string<uint8_t>& str );
+	// 	UTF-16 literals/strings
+		UF_API_CALL String( uint16_t ch );
+		UF_API_CALL String( const uint16_t* c_str );
+		UF_API_CALL String( const std::basic_string<uint16_t>& str );
+	// 	UTF-32 literals/strings
+		UF_API_CALL String( uint32_t ch );
+		UF_API_CALL String( const uint32_t* c_str );
+		UF_API_CALL String( const std::basic_string<uint32_t>& str );
+	//	~String();
+
+	// 	Parses bytes
+		void UF_API_CALL parse( char ch );
+		void UF_API_CALL parse( const char* c_str );
+		void UF_API_CALL parse( const std::basic_string<char>& str );
+
+	// 	Wide literals/strings
+		void UF_API_CALL parse( wchar_t ch );
+		void UF_API_CALL parse( const wchar_t* c_str );
+		void UF_API_CALL parse( const std::basic_string<wchar_t>& str );
+
+	// 	UTF-8 literals/strings
+		void UF_API_CALL parse( uint8_t ch );
+		void UF_API_CALL parse( const uint8_t* c_str );
+		void UF_API_CALL parse( const std::basic_string<uint8_t>& str );
+	// 	UTF-16 literals/strings
+		void UF_API_CALL parse( uint16_t ch );
+		void UF_API_CALL parse( const uint16_t* c_str );
+		void UF_API_CALL parse( const std::basic_string<uint16_t>& str );
+	// 	UTF-32 literals/strings
+		void UF_API_CALL parse( uint32_t ch );
+		void UF_API_CALL parse( const uint32_t* c_str );
+		void UF_API_CALL parse( const std::basic_string<uint32_t>& str );
+
+	// 	Converts using Encoding
+		template<typename Encoding>
+		std::basic_string<typename Encoding::literal_t> UF_API_CALL translate() const {
+			typedef std::basic_string<typename Encoding::literal_t> string_t;
+			string_t res;
+			for ( auto x : this->m_string ) {
+				uint32_t codepoint = Encoding::decode( &x, &x + 1 );
+				uint8_t chars[4] = { 0, 0, 0, 0 };
+				String::encoding_t::encode( codepoint, &chars[0] );
+				res += string_t((typename Encoding::literal_t*) chars);
+			}
+			return res;
+		}
+	// 	Access internal string
+		uf::String::string_t& UF_API_CALL getString();
+		const uf::String::string_t& UF_API_CALL getString() const;
+	// 	Access internal string as a C string
+		literal_t* UF_API_CALL c_str();
+		const literal_t* UF_API_CALL c_str() const;
+	// 	Append
+		void UF_API_CALL operator +=( char ch );
+		void UF_API_CALL operator +=( wchar_t ch );
+		void UF_API_CALL operator +=( uint8_t ch );
+		void UF_API_CALL operator +=( uint16_t ch );
+		void UF_API_CALL operator +=( uint32_t ch );
+	// 	Truncate
+		uf::String& UF_API_CALL operator --();
+		uf::String UF_API_CALL operator --(int);
+		uf::String& UF_API_CALL operator -=( std::size_t i );
+	// 	Convert to standard string
+		UF_API_CALL operator std::string();
+		UF_API_CALL operator std::string() const;
+	// 	Convert to standard wide string
+		UF_API_CALL operator std::wstring();
+		UF_API_CALL operator std::wstring() const;
+	// 	Write to an output stream
+		friend std::ostream& operator <<( std::ostream& os, const uf::String& string ) {
+			auto* pointer = string.getString().c_str();
+			std::string str = (const char*) pointer;
+			return os << str;
+		}
+	};
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/string/utf.h b/engine/inc/uf/utils/string/utf.h
new file mode 100644
index 00000000..0487a1aa
--- /dev/null
+++ b/engine/inc/uf/utils/string/utf.h
@@ -0,0 +1,64 @@
+#pragma once
+
+#include <uf/config.h>
+
+#include <algorithm>
+#include <locale>
+#include <string>
+#include <cstdlib>
+
+////
+#define template_in 		template<typename in_t> static in_t UF_API_CALL
+#define template_in_int 	template<typename in_t> static int_t UF_API_CALL
+#define template_in_size 	template<typename in_t> static std::size_t UF_API_CALL
+#define template_in_out 	template<typename in_t, typename out_t> static out_t UF_API_CALL
+#define template_out 		template<typename out_t> static out_t UF_API_CALL
+#define template_out_in 	template<typename out_t, typename in_t> static out_t UF_API_CALL
+///
+#define declarations \
+	template_in decode(in_t begin, in_t end, uint32_t& output, uint32_t replacement = 0); \
+	template_out encode(uint32_t input, out_t output, int_t replacement = 0); \
+	template_in next(in_t begin, in_t end); \
+	template_in_size count(in_t begin, in_t end); \
+	template_in_out fromAnsi(in_t begin, in_t end, out_t output, const std::locale& locale = std::locale()); \
+	template_in_out fromWide(in_t begin, in_t end, out_t output); \
+	template_in_out fromLatin1(in_t begin, in_t end, out_t output); \
+	template_in_out toAnsi(in_t begin, in_t end, out_t output, char replacement = 0, const std::locale& locale = std::locale()); \
+	template_in_out toWide(in_t begin, in_t end, out_t output, wchar_t replacement = 0); \
+	template_in_out toLatin1(in_t begin, in_t end, out_t output, char replacement = 0); \
+	template_in_out toUtf8(in_t begin, in_t end, out_t output); \
+	template_in_out toUtf16(in_t begin, in_t end, out_t output); \
+	template_in_out toUtf32(in_t begin, in_t end, out_t output); \
+	template_in_int decodeAnsi(in_t input, const std::locale& locale = std::locale()); \
+	template_in_int decodeWide(in_t input); \
+	template_out encodeAnsi(uint32_t codepoint, out_t output, char replacement = 0, const std::locale& locale = std::locale()); \
+	template_out encodeWide(uint32_t codepoint, out_t output, wchar_t replacement = 0);
+///
+#define template_declaration(utf_name, int_type) \
+	class UF_API utf_name { \
+	public: \
+		typedef int_type int_t; \
+		declarations; \
+	};
+////
+namespace uf {
+	template_declaration( Utf8,  uint8_t)
+	template_declaration(Utf16, uint16_t)
+	template_declaration(Utf32, uint32_t)
+	class UF_API Utf {
+	public:
+		typedef uf::Utf8 							default_encoding_t;
+		typedef uf::Utf::default_encoding_t::int_t 	default_int_t;
+		typedef uint32_t 							max_default_int_t;
+	};
+	
+#undef template_in
+#undef template_in_int
+#undef template_in_size
+#undef template_in_out
+#undef template_out
+#undef template_out_in
+#undef declarations
+#undef template_declaration
+}
+#include "utf.inl"
\ No newline at end of file
diff --git a/engine/inc/uf/utils/string/utf.inl b/engine/inc/uf/utils/string/utf.inl
new file mode 100644
index 00000000..f7d9f8a6
--- /dev/null
+++ b/engine/inc/uf/utils/string/utf.inl
@@ -0,0 +1,597 @@
+// References:
+//
+// http://www.unicode.org/
+// http://www.unicode.org/Public/PROGRAMS/CVTUTF/ConvertUTF.c
+// http://www.unicode.org/Public/PROGRAMS/CVTUTF/ConvertUTF.h
+// http://people.w3.org/rishida/scripts/uniview/conversion
+
+#include <uf/config.h>
+
+template <typename in_t>
+in_t UF_API_CALL uf::Utf8::decode(in_t begin, in_t end, uint32_t& output, uint32_t replacement) {
+	// Some useful precomputed data
+	static const int trailing[256] = {
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+		2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5
+	};
+	static const uint32_t offsets[6] = {
+		0x00000000, 0x00003080, 0x000E2080, 0x03C82080, 0xFA082080, 0x82082080
+	};
+
+	// decode the character
+	int trailingBytes = trailing[static_cast<uint8_t>(*begin)];
+	if (begin + trailingBytes < end) {
+		output = 0;
+		switch (trailingBytes) {
+			case 5: output += static_cast<uint8_t>(*begin++); output <<= 6;
+			case 4: output += static_cast<uint8_t>(*begin++); output <<= 6;
+			case 3: output += static_cast<uint8_t>(*begin++); output <<= 6;
+			case 2: output += static_cast<uint8_t>(*begin++); output <<= 6;
+			case 1: output += static_cast<uint8_t>(*begin++); output <<= 6;
+			case 0: output += static_cast<uint8_t>(*begin++);
+		}
+		output -= offsets[trailingBytes];
+	}
+	else {
+		// incomplete character
+		begin = end;
+		output = replacement;
+	}
+
+	return begin;
+}
+
+
+template <typename out_t>
+out_t UF_API_CALL uf::Utf8::encode(uint32_t input, out_t output, uint8_t replacement) {
+	// Some useful precomputed data
+	static const uint8_t firstBytes[7] = {
+		0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC
+	};
+
+	// encode the character
+	if ((input > 0x0010FFFF) || ((input >= 0xD800) && (input <= 0xDBFF))) {
+		// invalid character
+		if (replacement)
+			*output++ = replacement;
+	}
+	else {
+		// Valid character
+
+		// Get the number of bytes to write
+		std::size_t bytestoWrite = 1;
+		if	  	(input <  0x80)	   		bytestoWrite = 1;
+		else if (input <  0x800)	  	bytestoWrite = 2;
+		else if (input <  0x10000)		bytestoWrite = 3;
+		else if (input <= 0x0010FFFF) 	bytestoWrite = 4;
+
+		// Extract the bytes to write
+		uint8_t bytes[4];
+		switch (bytestoWrite) {
+			case 4: bytes[3] = static_cast<uint8_t>((input | 0x80) & 0xBF); input >>= 6;
+			case 3: bytes[2] = static_cast<uint8_t>((input | 0x80) & 0xBF); input >>= 6;
+			case 2: bytes[1] = static_cast<uint8_t>((input | 0x80) & 0xBF); input >>= 6;
+			case 1: bytes[0] = static_cast<uint8_t> (input | firstBytes[bytestoWrite]);
+		}
+
+		// Add them to the output
+		output = std::copy(bytes, bytes + bytestoWrite, output);
+	}
+
+	return output;
+}
+
+
+template <typename in_t>
+in_t UF_API_CALL uf::Utf8::next(in_t begin, in_t end) {
+	uint32_t codepoint;
+	return decode(begin, end, codepoint);
+}
+
+
+template <typename in_t>
+std::size_t UF_API_CALL uf::Utf8::count(in_t begin, in_t end) {
+	std::size_t length = 0;
+	while (begin < end) {
+		begin = next(begin, end);
+		++length;
+	}
+
+	return length;
+}
+
+
+template <typename in_t, typename out_t>
+out_t UF_API_CALL uf::Utf8::fromAnsi(in_t begin, in_t end, out_t output, const std::locale& locale) {
+	while (begin < end) {
+		uint32_t codepoint = uf::Utf32::decodeAnsi(*begin++, locale);
+		output = encode(codepoint, output);
+	}
+
+	return output;
+}
+
+
+template <typename in_t, typename out_t>
+out_t UF_API_CALL uf::Utf8::fromWide(in_t begin, in_t end, out_t output) {
+	while (begin < end) {
+		uint32_t codepoint = uf::Utf32::decodeWide(*begin++);
+		output = encode(codepoint, output);
+	}
+
+	return output;
+}
+
+
+template <typename in_t, typename out_t>
+out_t UF_API_CALL uf::Utf8::fromLatin1(in_t begin, in_t end, out_t output) {
+	// Latin-1 is directly compatible with Unicode encodings,
+	// and can thus be treated as (a sub-range of) UTF-32
+	while (begin < end)
+		output = encode(*begin++, output);
+
+	return output;
+}
+
+
+template <typename in_t, typename out_t>
+out_t UF_API_CALL uf::Utf8::toAnsi(in_t begin, in_t end, out_t output, char replacement, const std::locale& locale) {
+	while (begin < end) {
+		uint32_t codepoint;
+		begin = decode(begin, end, codepoint);
+		output = uf::Utf32::encodeAnsi(codepoint, output, replacement, locale);
+	}
+
+	return output;
+}
+
+
+template <typename in_t, typename out_t>
+out_t UF_API_CALL uf::Utf8::toWide(in_t begin, in_t end, out_t output, wchar_t replacement) {
+	while (begin < end) {
+		uint32_t codepoint;
+		begin = decode(begin, end, codepoint);
+		output = uf::Utf32::encodeWide(codepoint, output, replacement);
+	}
+
+	return output;
+}
+
+
+template <typename in_t, typename out_t>
+out_t UF_API_CALL uf::Utf8::toLatin1(in_t begin, in_t end, out_t output, char replacement) {
+	// Latin-1 is directly compatible with Unicode encodings,
+	// and can thus be treated as (a sub-range of) UTF-32
+	while (begin < end) {
+		uint32_t codepoint;
+		begin = decode(begin, end, codepoint);
+		*output++ = codepoint < 256 ? static_cast<char>(codepoint) : replacement;
+	}
+
+	return output;
+}
+
+
+template <typename in_t, typename out_t>
+out_t UF_API_CALL uf::Utf8::toUtf8(in_t begin, in_t end, out_t output) {
+	return std::copy(begin, end, output);
+}
+
+
+template <typename in_t, typename out_t>
+out_t UF_API_CALL uf::Utf8::toUtf16(in_t begin, in_t end, out_t output) {
+	while (begin < end) {
+		uint32_t codepoint;
+		begin = decode(begin, end, codepoint);
+		output = uf::Utf16::encode(codepoint, output);
+	}
+
+	return output;
+}
+
+
+template <typename in_t, typename out_t>
+out_t UF_API_CALL uf::Utf8::toUtf32(in_t begin, in_t end, out_t output) {
+	while (begin < end) {
+		uint32_t codepoint;
+		begin = decode(begin, end, codepoint);
+		*output++ = codepoint;
+	}
+
+	return output;
+}
+
+
+template <typename in_t>
+in_t UF_API_CALL uf::Utf16::decode(in_t begin, in_t end, uint32_t& output, uint32_t replacement) {
+	uint16_t first = *begin++;
+
+	// If it's a surrogate pair, first convert to a single UTF-32 character
+	if ((first >= 0xD800) && (first <= 0xDBFF)) {
+		if (begin < end) {
+			uint32_t second = *begin++;
+			if ((second >= 0xDC00) && (second <= 0xDFFF)) {
+				// The second element is valid: convert the two elements to a UTF-32 character
+				output = static_cast<uint32_t>(((first - 0xD800) << 10) + (second - 0xDC00) + 0x0010000);
+			}
+			else {
+				// invalid character
+				output = replacement;
+			}
+		}
+		else {
+			// invalid character
+			begin = end;
+			output = replacement;
+		}
+	}
+	else {
+		// We can make a direct copy
+		output = first;
+	}
+
+	return begin;
+}
+
+
+template <typename out_t>
+out_t UF_API_CALL uf::Utf16::encode(uint32_t input, out_t output, uint16_t replacement) {
+	if (input < 0xFFFF) {
+		// The character can be copied directly, we just need to check if it's in the valid range
+		if ((input >= 0xD800) && (input <= 0xDFFF)) {
+			// invalid character (this range is reserved)
+			if (replacement)
+				*output++ = replacement;
+		}
+		else {
+			// Valid character directly convertible to a single UTF-16 character
+			*output++ = static_cast<uint16_t>(input);
+		}
+	}
+	else if (input > 0x0010FFFF) {
+		// invalid character (greater than the maximum Unicode value)
+		if (replacement)
+			*output++ = replacement;
+	}
+	else {
+		// The input character will be converted to two UTF-16 elements
+		input -= 0x0010000;
+		*output++ = static_cast<uint16_t>((input >> 10)	 + 0xD800);
+		*output++ = static_cast<uint16_t>((input & 0x3FFUL) + 0xDC00);
+	}
+
+	return output;
+}
+
+
+template <typename in_t>
+in_t UF_API_CALL uf::Utf16::next(in_t begin, in_t end) {
+	uint32_t codepoint;
+	return decode(begin, end, codepoint);
+}
+
+
+template <typename in_t>
+std::size_t UF_API_CALL uf::Utf16::count(in_t begin, in_t end) {
+	std::size_t length = 0;
+	while (begin < end) {
+		begin = next(begin, end);
+		++length;
+	}
+
+	return length;
+}
+
+
+template <typename in_t, typename out_t>
+out_t UF_API_CALL uf::Utf16::fromAnsi(in_t begin, in_t end, out_t output, const std::locale& locale) {
+	while (begin < end) {
+		uint32_t codepoint = uf::Utf32::decodeAnsi(*begin++, locale);
+		output = encode(codepoint, output);
+	}
+
+	return output;
+}
+
+
+template <typename in_t, typename out_t>
+out_t UF_API_CALL uf::Utf16::fromWide(in_t begin, in_t end, out_t output) {
+	while (begin < end) {
+		uint32_t codepoint = uf::Utf32::decodeWide(*begin++);
+		output = encode(codepoint, output);
+	}
+
+	return output;
+}
+
+
+template <typename in_t, typename out_t>
+out_t UF_API_CALL uf::Utf16::fromLatin1(in_t begin, in_t end, out_t output) {
+	// Latin-1 is directly compatible with Unicode encodings,
+	// and can thus be treated as (a sub-range of) UTF-32
+	return std::copy(begin, end, output);
+}
+
+
+template <typename in_t, typename out_t>
+out_t UF_API_CALL uf::Utf16::toAnsi(in_t begin, in_t end, out_t output, char replacement, const std::locale& locale) {
+	while (begin < end) {
+		uint32_t codepoint;
+		begin = decode(begin, end, codepoint);
+		output = uf::Utf32::encodeAnsi(codepoint, output, replacement, locale);
+	}
+
+	return output;
+}
+
+
+template <typename in_t, typename out_t>
+out_t UF_API_CALL uf::Utf16::toWide(in_t begin, in_t end, out_t output, wchar_t replacement) {
+	while (begin < end) {
+		uint32_t codepoint;
+		begin = decode(begin, end, codepoint);
+		output = uf::Utf32::encodeWide(codepoint, output, replacement);
+	}
+
+	return output;
+}
+
+
+template <typename in_t, typename out_t>
+out_t UF_API_CALL uf::Utf16::toLatin1(in_t begin, in_t end, out_t output, char replacement) {
+	// Latin-1 is directly compatible with Unicode encodings,
+	// and can thus be treated as (a sub-range of) UTF-32
+	while (begin < end) {
+		*output++ = *begin < 256 ? static_cast<char>(*begin) : replacement;
+		begin++;
+	}
+
+	return output;
+}
+
+
+template <typename in_t, typename out_t>
+out_t UF_API_CALL uf::Utf16::toUtf8(in_t begin, in_t end, out_t output) {
+	while (begin < end) {
+		uint32_t codepoint;
+		begin = decode(begin, end, codepoint);
+		output = uf::Utf8::encode(codepoint, output);
+	}
+
+	return output;
+}
+
+
+template <typename in_t, typename out_t>
+out_t UF_API_CALL uf::Utf16::toUtf16(in_t begin, in_t end, out_t output) {
+	return std::copy(begin, end, output);
+}
+
+
+template <typename in_t, typename out_t>
+out_t UF_API_CALL uf::Utf16::toUtf32(in_t begin, in_t end, out_t output) {
+	while (begin < end) {
+		uint32_t codepoint;
+		begin = decode(begin, end, codepoint);
+		*output++ = codepoint;
+	}
+
+	return output;
+}
+
+
+template <typename in_t>
+in_t UF_API_CALL uf::Utf32::decode(in_t begin, in_t /*end*/, uint32_t& output, uint32_t /*replacement*/) {
+	output = *begin++;
+	return begin;
+}
+
+
+template <typename out_t>
+out_t UF_API_CALL uf::Utf32::encode(uint32_t input, out_t output, uint32_t /*replacement*/) {
+	*output++ = input;
+	return output;
+}
+
+
+template <typename in_t>
+in_t UF_API_CALL uf::Utf32::next(in_t begin, in_t /*end*/) {
+	return ++begin;
+}
+
+
+template <typename in_t>
+std::size_t UF_API_CALL uf::Utf32::count(in_t begin, in_t end) {
+	return begin - end;
+}
+
+
+template <typename in_t, typename out_t>
+out_t UF_API_CALL uf::Utf32::fromAnsi(in_t begin, in_t end, out_t output, const std::locale& locale) {
+	while (begin < end)
+		*output++ = decodeAnsi(*begin++, locale);
+
+	return output;
+}
+
+
+template <typename in_t, typename out_t>
+out_t UF_API_CALL uf::Utf32::fromWide(in_t begin, in_t end, out_t output) {
+	while (begin < end)
+		*output++ = decodeWide(*begin++);
+
+	return output;
+}
+
+
+template <typename in_t, typename out_t>
+out_t UF_API_CALL uf::Utf32::fromLatin1(in_t begin, in_t end, out_t output) {
+	// Latin-1 is directly compatible with Unicode encodings,
+	// and can thus be treated as (a sub-range of) UTF-32
+	return std::copy(begin, end, output);
+}
+
+
+template <typename in_t, typename out_t>
+out_t UF_API_CALL uf::Utf32::toAnsi(in_t begin, in_t end, out_t output, char replacement, const std::locale& locale) {
+	while (begin < end)
+		output = encodeAnsi(*begin++, output, replacement, locale);
+
+	return output;
+}
+
+
+template <typename in_t, typename out_t>
+out_t UF_API_CALL uf::Utf32::toWide(in_t begin, in_t end, out_t output, wchar_t replacement) {
+	while (begin < end)
+		output = encodeWide(*begin++, output, replacement);
+
+	return output;
+}
+
+
+template <typename in_t, typename out_t>
+out_t UF_API_CALL uf::Utf32::toLatin1(in_t begin, in_t end, out_t output, char replacement) {
+	// Latin-1 is directly compatible with Unicode encodings,
+	// and can thus be treated as (a sub-range of) UTF-32
+	while (begin < end) {
+		*output++ = *begin < 256 ? static_cast<char>(*begin) : replacement;
+		begin++;
+	}
+
+	return output;
+}
+
+
+template <typename in_t, typename out_t>
+out_t UF_API_CALL uf::Utf32::toUtf8(in_t begin, in_t end, out_t output) {
+	while (begin < end)
+		output = uf::Utf8::encode(*begin++, output);
+
+	return output;
+}
+
+template <typename in_t, typename out_t>
+out_t UF_API_CALL uf::Utf32::toUtf16(in_t begin, in_t end, out_t output) {
+	while (begin < end)
+		output = uf::Utf16::encode(*begin++, output);
+
+	return output;
+}
+
+
+template <typename in_t, typename out_t>
+out_t UF_API_CALL uf::Utf32::toUtf32(in_t begin, in_t end, out_t output) {
+	return std::copy(begin, end, output);
+}
+
+
+template <typename in_t>
+uint32_t UF_API_CALL uf::Utf32::decodeAnsi(in_t input, const std::locale& locale) {
+	// On Windows, GCC's standard library (glibc++) has almost
+	// no support for Unicode stuff. As a consequence, in this
+	// context we can only use the default locale and ignore
+	// the one passed as parameter.
+
+	#if defined(UF_ENV_WINDOWS) &&					   /* if Windows ... */						  \
+	   (defined(__GLIBCPP__) || defined (__GLIBCXX__)) &&	 /* ... and standard library is glibc++ ... */ \
+	  !(defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)) /* ... and STLPort is not used on top of it */
+
+		(void)locale; // to avoid warnings
+
+		wchar_t character = 0;
+		mbtowc(&character, &input, 1);
+		return static_cast<uint32_t>(character);
+
+	#else
+
+		// Get the facet of the locale which deals with character conversion
+		const std::ctype<wchar_t>& facet = std::use_facet< std::ctype<wchar_t> >(locale);
+
+		// Use the facet to convert each character of the input string
+		return static_cast<uint32_t>(facet.widen(input));
+
+	#endif
+}
+
+
+template <typename in_t>
+uint32_t UF_API_CALL uf::Utf32::decodeWide(in_t input) {
+	// The encoding of wide characters is not well defined and is left to the system;
+	// however we can safely assume that it is UCS-2 on Windows and
+	// UCS-4 on Unix systems.
+	// in_t both cases, a simple copy is enough (UCS-2 is a subset of UCS-4,
+	// and UCS-4 *is* UTF-32).
+
+	return input;
+}
+
+
+template <typename out_t>
+out_t UF_API_CALL uf::Utf32::encodeAnsi(uint32_t codepoint, out_t output, char replacement, const std::locale& locale) {
+	// On Windows, gcc's standard library (glibc++) has almost
+	// no support for Unicode stuff. As a consequence, in this
+	// context we can only use the default locale and ignore
+	// the one passed as parameter.
+
+	#if defined(UF_ENV_WINDOWS) &&					   /* if Windows ... */						  \
+	   (defined(__GLIBCPP__) || defined (__GLIBCXX__)) &&	 /* ... and standard library is glibc++ ... */ \
+	  !(defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)) /* ... and STLPort is not used on top of it */
+
+		(void)locale; // to avoid warnings
+
+		char character = 0;
+		if (wctomb(&character, static_cast<wchar_t>(codepoint)) >= 0)
+			*output++ = character;
+		else if (replacement)
+			*output++ = replacement;
+
+		return output;
+
+	#else
+
+		// Get the facet of the locale which deals with character conversion
+		const std::ctype<wchar_t>& facet = std::use_facet< std::ctype<wchar_t> >(locale);
+
+		// Use the facet to convert each character of the input string
+		*output++ = facet.narrow(static_cast<wchar_t>(codepoint), replacement);
+
+		return output;
+
+	#endif
+}
+
+
+template <typename out_t>
+out_t UF_API_CALL uf::Utf32::encodeWide(uint32_t codepoint, out_t output, wchar_t replacement) {
+	// The encoding of wide characters is not well defined and is left to the system;
+	// however we can safely assume that it is UCS-2 on Windows and
+	// UCS-4 on Unix systems.
+	// For UCS-2 we need to check if the source characters fits in (UCS-2 is a subset of UCS-4).
+	// For UCS-4 we can do a direct copy (UCS-4 *is* UTF-32).
+
+	switch (sizeof(wchar_t)) {
+		case 4: {
+			*output++ = static_cast<wchar_t>(codepoint);
+			break;
+		}
+
+		default: {
+			if ((codepoint <= 0xFFFF) && ((codepoint < 0xD800) || (codepoint > 0xDFFF))) {
+				*output++ = static_cast<wchar_t>(codepoint);
+			}
+			else if (replacement) {
+				*output++ = replacement;
+			}
+			break;
+		}
+	}
+
+	return output;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/text/glyph.h b/engine/inc/uf/utils/text/glyph.h
new file mode 100644
index 00000000..5b011bf9
--- /dev/null
+++ b/engine/inc/uf/utils/text/glyph.h
@@ -0,0 +1,51 @@
+#pragma once
+
+#include <uf/config.h>
+#if UF_USE_FREETYPE
+#include <vector>
+
+#include <uf/utils/math/vector.h>
+#include <uf/ext/freetype/freetype.h>
+
+namespace uf {
+	class UF_API Glyph {
+	protected:
+		pod::Vector2ui m_size = { 0, 0 };
+		pod::Vector2i m_bearing = { 0, 0 };
+		pod::Vector2i m_advance = { 0, 0 };
+		
+		pod::Vector2i m_padding = { 0, 0 };
+		
+		bool m_sdf = false;
+		int m_spread = 0;
+		uint8_t* m_buffer;
+	public:
+		~Glyph();
+
+		bool generated();
+		uint8_t* generate( const std::string&, unsigned long, uint = 48 );
+		uint8_t* generate( ext::freetype::Glyph&, unsigned long, uint = 48 );
+		uint8_t* generate( const std::string&, const uf::String&, uint = 48 );
+		uint8_t* generate( ext::freetype::Glyph&, const uf::String&, uint = 48 );
+
+		void generateSdf( uint8_t* );
+	// 	Get
+		const pod::Vector2ui& getSize() const;
+		const pod::Vector2i& getBearing() const;
+		const pod::Vector2i& getAdvance() const;
+		const pod::Vector2i& getPadding() const;
+		const uint8_t* getBuffer() const;
+		
+		bool isSdf() const;
+		int getSpread() const;
+	//	Set
+		void setSize( const pod::Vector2ui& );
+		void setBearing( const pod::Vector2i& );
+		void setAdvance( const pod::Vector2i& );
+		void setPadding( const pod::Vector2i& );
+
+		void useSdf( bool = true );
+		void setSpread( int );
+	};
+}
+#endif
\ No newline at end of file
diff --git a/engine/inc/uf/utils/thread/perthread.h b/engine/inc/uf/utils/thread/perthread.h
new file mode 100644
index 00000000..63e9705c
--- /dev/null
+++ b/engine/inc/uf/utils/thread/perthread.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include <uf/config.h>
+#include "thread.h"
+
+namespace uf {
+	template<typename T>
+	class UF_API ThreadUnique {
+	public:
+		typedef T type_t;
+		typedef std::thread::id id_t;
+		typedef std::unordered_map<id_t, type_t> container_t;
+	protected:
+		container_t m_container;
+	public:
+		bool has( id_t id = std::this_thread::get_id() ) const;
+		T& get( id_t id = std::this_thread::get_id() );
+		container_t& container();
+	};
+}
+
+#include "perthread.inl"
\ No newline at end of file
diff --git a/engine/inc/uf/utils/thread/perthread.inl b/engine/inc/uf/utils/thread/perthread.inl
new file mode 100644
index 00000000..9fea5b60
--- /dev/null
+++ b/engine/inc/uf/utils/thread/perthread.inl
@@ -0,0 +1,12 @@
+template<typename T>
+bool uf::ThreadUnique<T>::has( id_t id ) const {
+	return m_container.count(id) > 0;
+}
+template<typename T>
+T& uf::ThreadUnique<T>::get( id_t id ) {
+	return m_container[id];
+}
+template<typename T>
+typename uf::ThreadUnique<T>::container_t& uf::ThreadUnique<T>::container() {
+	return m_container;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/thread/thread.h b/engine/inc/uf/utils/thread/thread.h
new file mode 100644
index 00000000..a5d8d93d
--- /dev/null
+++ b/engine/inc/uf/utils/thread/thread.h
@@ -0,0 +1,129 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/utils/time/time.h>
+#include <uf/utils/math/math.h>
+
+#include <queue>
+#include <mutex>
+#include <thread>
+#include <vector>
+#include <functional>
+#include <condition_variable>
+
+namespace pod {
+	struct UF_API Thread {
+		typedef std::function<int()> function_t;
+		typedef std::queue<pod::Thread::function_t> queue_t;
+		typedef std::vector<pod::Thread::function_t> container_t;
+
+		uint uid;
+		double limiter;
+		std::string name;
+		bool running, terminates;
+
+		std::mutex* mutex;
+		std::condition_variable condition;
+		std::thread thread;
+
+		pod::Thread::queue_t temps;
+		pod::Thread::container_t consts;
+
+		uf::Timer<long long> timer;
+		uint affinity = 0;
+	};
+}
+
+namespace uf {
+	namespace thread {
+		extern UF_API double limiter;
+		extern UF_API uint workers;
+		extern UF_API std::thread::id mainThreadId;
+
+	/* Acts on thread */
+		void UF_API start( pod::Thread& );
+		void UF_API quit( pod::Thread& );
+
+		void UF_API tick( pod::Thread& );
+	//	void UF_API tick( pod::Thread&, const std::function<void()>& = NULL );
+
+		pod::Thread& UF_API fetchWorker( const std::string& name = "Aux" );
+		void UF_API batchWorkers( const std::vector<pod::Thread::function_t>&, bool = true, const std::string& name = "Aux" );
+		void UF_API add( pod::Thread&, const pod::Thread::function_t&, bool = false );
+		void UF_API assertExecute( pod::Thread&, const pod::Thread::function_t& );
+		void UF_API process( pod::Thread& );
+
+		void UF_API wait( pod::Thread& );
+
+		const std::string& UF_API name( const pod::Thread& );
+		uint UF_API uid( const pod::Thread& );
+		bool UF_API running( const pod::Thread& );
+	/* Acts on global threads */
+		typedef std::vector<pod::Thread*> container_t;
+		extern UF_API uf::thread::container_t threads;
+		
+
+		void UF_API terminate();
+
+		pod::Thread& UF_API create( const std::string& = "", bool = true, bool = true );
+		void UF_API destroy( pod::Thread& );
+		bool UF_API has( uint );
+		bool UF_API has( const std::string& );
+		pod::Thread& UF_API get( uint );
+		pod::Thread& UF_API get( const std::string& );
+
+		bool UF_API isMain();
+	}
+}
+
+/*
+namespace uf {
+	class UF_API Thread {
+	public:
+		typedef std::function<int()> function_t;
+		typedef std::queue<uf::Thread::function_t> queue_t;
+		typedef std::vector<uf::Thread::function_t> container_t;
+
+		enum {
+			TEMP = 0,
+			CONSTANT = 1,
+		};
+	protected:
+		uint m_uid;
+		uint m_mode;
+		bool m_running;
+		bool m_shouldLock;
+		bool m_terminateOnEmpty;
+		std::mutex m_mutex;
+		std::string m_name;
+		std::thread m_thread;
+		uf::Thread::queue_t m_temps;
+		uf::Thread::container_t m_consts;
+	public:
+		static uint fps;
+		static uint thread_count;
+		Thread( const std::string& = "", bool = true, uint = 0 );
+		virtual ~Thread();
+
+		void start();
+		virtual void tick(const std::function<void()>& = NULL);
+		void add( const uf::Thread::function_t&, uint = 0 );
+		void process();
+		void quit();
+
+		std::string toString() const;
+		const std::string& getName() const;
+		uint getUid() const;
+		const bool& isRunning() const;
+	};
+	namespace thread {
+		typedef std::unordered_map<std::string, uf::Thread*> container_t;
+		extern UF_API uf::thread::container_t threads;
+
+		void UF_API add( uf::Thread* );
+		uf::Thread& UF_API get( const std::string& );
+		bool UF_API add( const std::string&, const uf::Thread::function_t&, uint = 0 );
+		bool UF_API quit( const std::string& );
+	};
+}
+*/
\ No newline at end of file
diff --git a/engine/inc/uf/utils/time/time.h b/engine/inc/uf/utils/time/time.h
new file mode 100644
index 00000000..bafe7ead
--- /dev/null
+++ b/engine/inc/uf/utils/time/time.h
@@ -0,0 +1,85 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/spec/time/time.h>
+#include <cmath>
+
+namespace uf {
+	template<typename T = spec::Time::time_t>
+	class UF_API Time {
+	public:
+		typedef T time_t;
+		typedef spec::Time::exp_t exp_t;
+	protected:
+		uf::Time<T>::time_t m_time;
+		uf::Time<T>::exp_t m_exp;
+	public:
+		static const uf::Time<T>::exp_t seconds = 0;
+		static const uf::Time<T>::exp_t milliseconds = -3;
+		static const uf::Time<T>::exp_t microseconds = -6;
+		static const uf::Time<T>::exp_t nanoseconds = -9;
+
+		UF_API_CALL Time(uf::Time<T>::time_t t = 0, uf::Time<T>::exp_t b = spec::Time::unit );
+
+		void UF_API_CALL set(uf::Time<T>::time_t t);
+		void UF_API_CALL set(uf::Time<T>::time_t t, uf::Time<T>::exp_t b);
+		inline void UF_API_CALL fromSeconds(uf::Time<T>::time_t t);
+		inline void UF_API_CALL fromMilliseconds(uf::Time<T>::time_t t);
+		inline void UF_API_CALL fromMicroseconds(uf::Time<T>::time_t t);
+		inline void UF_API_CALL fromNanoseconds(uf::Time<T>::time_t t);
+
+		uf::Time<T>::time_t UF_API_CALL get() const;
+		uf::Time<T>::exp_t UF_API_CALL getBase() const;
+
+		uf::Time<T>::time_t UF_API_CALL asBase(uf::Time<T>::exp_t base = spec::Time::unit );
+		inline uf::Time<T>::time_t UF_API_CALL asSeconds();
+		inline uf::Time<T>::time_t UF_API_CALL asMilliseconds();
+		inline uf::Time<T>::time_t UF_API_CALL asMicroseconds();
+		inline uf::Time<T>::time_t UF_API_CALL asNanoseconds();
+		double UF_API_CALL asDouble();
+
+		uf::Time<T>& UF_API_CALL operator=( const uf::Time<T>::time_t& t );
+		UF_API_CALL operator double();
+		bool UF_API_CALL operator>( const uf::Time<T>::time_t& t );
+		bool UF_API_CALL operator>=( const uf::Time<T>::time_t& t );
+		bool UF_API_CALL operator<( const uf::Time<T>::time_t& t );
+		bool UF_API_CALL operator<=( const uf::Time<T>::time_t& t );
+		bool UF_API_CALL operator==( const uf::Time<T>::time_t& t );
+		bool UF_API_CALL operator>( const uf::Time<T>& t );
+		bool UF_API_CALL operator>=( const uf::Time<T>& t );
+		bool UF_API_CALL operator<( const uf::Time<T>& t );
+		bool UF_API_CALL operator<=( const uf::Time<T>& t );
+		bool UF_API_CALL operator==( const uf::Time<T>& t );
+		uf::Time<T> UF_API_CALL operator-( const uf::Time<T>& t );
+		uf::Time<T> UF_API_CALL operator+( const uf::Time<T>& t );
+	};
+	template<typename T = spec::Time::time_t>
+	class /*UF_API*/ Timer {
+	public:
+		typedef T time_t;
+		typedef spec::Time::exp_t exp_t;
+	protected:
+		bool m_running;
+		uf::Time<T> m_begin;
+		uf::Time<T> m_end;
+	public:
+		Timer(bool running = true, uf::Timer<T>::exp_t b = spec::Time::unit);
+
+		void start( uf::Time<T> = 0 );
+		void stop();
+		void reset();
+		void update();
+		bool running() const;
+	
+		uf::Time<T>& getStarting();
+		uf::Time<T>& getEnding();
+	
+		uf::Time<T> elapsed();
+		uf::Time<T> elapsed() const;
+		const uf::Time<T>& getStarting() const;
+		const uf::Time<T>& getEnding() const;
+	};
+}
+
+#include "time.inl"
+#include "timer.inl"
\ No newline at end of file
diff --git a/engine/inc/uf/utils/time/time.inl b/engine/inc/uf/utils/time/time.inl
new file mode 100644
index 00000000..116e46d9
--- /dev/null
+++ b/engine/inc/uf/utils/time/time.inl
@@ -0,0 +1,124 @@
+template<typename T>
+uf::Time<T>::Time(uf::Time<T>::time_t t, uf::Time<T>::exp_t b ) : 
+	m_time(t),
+	m_exp(b)
+{
+
+}
+template<typename T>
+void uf::Time<T>::set(uf::Time<T>::time_t t) { 
+	this->m_time = t;
+}
+template<typename T>
+void uf::Time<T>::set(uf::Time<T>::time_t t, uf::Time<T>::exp_t b) { 
+	this->m_time = t;
+	this->m_exp = b;
+}
+template<typename T>
+inline void uf::Time<T>::fromSeconds(uf::Time<T>::time_t t) { 
+	this->set(t, uf::Time<T>::seconds );
+}
+template<typename T>
+inline void uf::Time<T>::fromMilliseconds(uf::Time<T>::time_t t) { 
+	this->set(t, uf::Time<T>::milliseconds );
+}
+template<typename T>
+inline void uf::Time<T>::fromMicroseconds(uf::Time<T>::time_t t) { 
+	this->set(t, uf::Time<T>::microseconds );
+}
+template<typename T>
+inline void uf::Time<T>::fromNanoseconds(uf::Time<T>::time_t t) { 
+	this->set(t, uf::Time<T>::nanoseconds );
+}
+
+template<typename T>
+typename uf::Time<T>::time_t uf::Time<T>::get() const { 
+	return this->m_time;
+}
+template<typename T>
+typename uf::Time<T>::exp_t uf::Time<T>::getBase() const { 
+	return this->m_exp;
+}
+
+template<typename T>
+typename uf::Time<T>::time_t uf::Time<T>::asBase(uf::Time<T>::exp_t base) { 
+	return this->m_time * pow((int) 10, this->m_exp - base);
+}
+template<typename T>
+inline typename uf::Time<T>::time_t uf::Time<T>::asSeconds() {
+	return this->asBase( uf::Time<T>::seconds );
+}
+template<typename T>
+inline typename uf::Time<T>::time_t uf::Time<T>::asMilliseconds() {
+	return this->asBase( uf::Time<T>::milliseconds );
+}
+template<typename T>
+inline typename uf::Time<T>::time_t uf::Time<T>::asMicroseconds() {
+	return this->asBase( uf::Time<T>::microseconds );
+}
+template<typename T>
+inline typename uf::Time<T>::time_t uf::Time<T>::asNanoseconds() {
+	return this->asBase( uf::Time<T>::nanoseconds );
+}
+template<typename T>
+double uf::Time<T>::asDouble() {
+	return this->m_time * pow(10.0, this->m_exp);
+}
+
+template<typename T>
+uf::Time<T>& uf::Time<T>::operator=( const uf::Time<T>::time_t& t ) { 
+	this->m_time = t;
+	return *this;
+}
+template<typename T>
+uf::Time<T>::operator double() {
+	return this->asDouble();
+}
+template<typename T>
+bool uf::Time<T>::operator>( const uf::Time<T>::time_t& t ) {
+	return this->m_time > t;
+}
+template<typename T>
+bool uf::Time<T>::operator>=( const uf::Time<T>::time_t& t ) {
+	return this->m_time >= t;
+}
+template<typename T>
+bool uf::Time<T>::operator<( const uf::Time<T>::time_t& t ) {
+	return this->m_time < t;
+}
+template<typename T>
+bool uf::Time<T>::operator<=( const uf::Time<T>::time_t& t ) {
+	return this->m_time <= t;
+}
+template<typename T>
+bool uf::Time<T>::operator==( const uf::Time<T>::time_t& t ) {
+	return this->m_time == t;
+}
+template<typename T>
+bool uf::Time<T>::operator>( const uf::Time<T>& t ) {
+	return this->m_time > t.m_time;
+}
+template<typename T>
+bool uf::Time<T>::operator>=( const uf::Time<T>& t ) {
+	return this->m_time >= t.m_time;
+}
+template<typename T>
+bool uf::Time<T>::operator<( const uf::Time<T>& t ) {
+	return this->m_time < t.m_time;
+}
+template<typename T>
+bool uf::Time<T>::operator<=( const uf::Time<T>& t ) {
+	return this->m_time <= t.m_time;
+}
+template<typename T>
+bool uf::Time<T>::operator==( const uf::Time<T>& t ) {
+	return this->m_time == t.m_time;
+}
+template<typename T>
+uf::Time<T> uf::Time<T>::operator-( const uf::Time<T>& t ) {
+	return uf::Time<T>(this->m_time - t.m_time);
+}
+template<typename T>
+uf::Time<T> uf::Time<T>::operator+( const uf::Time<T>& t ) {
+	return uf::Time<T>(this->m_time + t.m_time);
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/time/timer.inl b/engine/inc/uf/utils/time/timer.inl
new file mode 100644
index 00000000..c96dcad9
--- /dev/null
+++ b/engine/inc/uf/utils/time/timer.inl
@@ -0,0 +1,61 @@
+template <typename T>
+uf::Timer<T>::Timer(bool running, uf::Timer<T>::exp_t b) :
+	m_running(running),
+	m_begin(0, b),
+	m_end(0, b)
+{
+	if ( running ) this->start();
+}
+
+template <typename T>
+void uf::Timer<T>::start( uf::Time<T> offset ) {
+	this->m_running = true;
+	this->reset();
+	this->m_begin = this->m_begin + offset;
+}
+template <typename T>
+void uf::Timer<T>::stop() {
+	this->update();
+	this->m_running = false;
+}
+template <typename T>
+void uf::Timer<T>::reset() {
+	this->m_end = this->m_begin = spec::time.getTime();
+}
+template <typename T>
+void uf::Timer<T>::update() {
+	if ( !this->m_running ) return;
+	this->m_end = spec::time.getTime();
+}
+template <typename T>
+bool uf::Timer<T>::running() const {
+	return this->m_running;
+}
+
+template <typename T>
+uf::Time<T>& uf::Timer<T>::getStarting() {
+	return this->m_begin;
+}
+template <typename T>
+uf::Time<T>& uf::Timer<T>::getEnding() {
+	this->update();
+	return this->m_end;
+}
+
+template <typename T>
+uf::Time<T> uf::Timer<T>::elapsed() {
+	this->update();
+	return this->m_end - this->m_begin;
+}
+template <typename T>
+uf::Time<T> uf::Timer<T>::elapsed() const {
+	return this->m_end - this->m_begin;
+}
+template <typename T>
+const uf::Time<T>& uf::Timer<T>::getStarting() const {
+	return this->m_begin;
+}
+template <typename T>
+const uf::Time<T>& uf::Timer<T>::getEnding() const {
+	return this->m_end;
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/type/type.h b/engine/inc/uf/utils/type/type.h
new file mode 100644
index 00000000..a8c21b04
--- /dev/null
+++ b/engine/inc/uf/utils/type/type.h
@@ -0,0 +1,54 @@
+#pragma once
+
+#include <uf/config.h>
+#include <typeindex>
+#include <unordered_map>
+
+#define UF_TYPE_REGISTER 1
+
+#include <string>
+namespace pod {
+	struct UF_API TypeInfo {
+		size_t hash;
+		size_t size;
+		struct {
+			std::string pretty;
+			std::string compiler;
+		} name;
+	};
+}
+namespace std {
+	template<> struct hash<pod::TypeInfo> {
+	    size_t operator()(const pod::TypeInfo& type) const {
+			return type.hash;
+	    }
+	};
+}
+
+
+namespace uf {
+	namespace typeInfo {
+		typedef std::type_index index_t;
+		typedef pod::TypeInfo type_t;
+
+		extern UF_API std::unordered_map<index_t, pod::TypeInfo>* types;
+
+		void UF_API registerType( const index_t&, size_t = 0, const std::string& = "" );
+		const pod::TypeInfo& UF_API getType( size_t );
+		const pod::TypeInfo& UF_API getType( const index_t& );
+
+		template<typename T>
+		const std::type_index getIndex();
+		template<typename T>
+		void registerType( const std::string& pretty = "" );
+		template<typename T>
+		const pod::TypeInfo& getType();
+	/*
+		template<typename T> const index_t getIndex();
+		template<typename T> void registerType( const std::string& = "" );
+		template<typename T> const pod::TypeInfo& getType();
+	*/
+	}
+}
+
+#include "type.inl"
\ No newline at end of file
diff --git a/engine/inc/uf/utils/type/type.inl b/engine/inc/uf/utils/type/type.inl
new file mode 100644
index 00000000..e127fc29
--- /dev/null
+++ b/engine/inc/uf/utils/type/type.inl
@@ -0,0 +1,12 @@
+template<typename T>
+const std::type_index uf::typeInfo::getIndex() {
+	return typeid(T);
+}
+template<typename T>
+void uf::typeInfo::registerType( const std::string& pretty ) {
+	return registerType(getIndex<T>(), sizeof(T), pretty);
+}
+template<typename T>
+const pod::TypeInfo& uf::typeInfo::getType() {
+	return getType(getIndex<T>());
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/userdata/pointered.inl b/engine/inc/uf/utils/userdata/pointered.inl
new file mode 100644
index 00000000..bb086b61
--- /dev/null
+++ b/engine/inc/uf/utils/userdata/pointered.inl
@@ -0,0 +1,192 @@
+namespace pod {
+	struct UF_API PointeredUserdata {
+		size_t len = 0;
+	#if UF_USERDATA_RTTI
+		std::size_t type = 0;
+	#endif
+		uint8_t* data = NULL;
+	};
+}
+
+namespace uf {
+	namespace pointeredUserdata {
+		pod::PointeredUserdata UF_API create( std::size_t len, void* data = NULL );
+		void UF_API destroy( pod::PointeredUserdata& userdata );
+		pod::PointeredUserdata UF_API copy( const pod::PointeredUserdata& userdata );
+
+		template<typename T> pod::PointeredUserdata create( const T& data = T() );
+		template<typename T> T& get( pod::PointeredUserdata& userdata, bool validate = true);
+		template<typename T> const T& get(const pod::PointeredUserdata& userdata, bool validate = true );
+		template<typename T> bool is(const pod::PointeredUserdata& userdata);
+
+		std::string UF_API toBase64( pod::PointeredUserdata& userdata );
+		pod::PointeredUserdata UF_API fromBase64( const std::string& base64 );
+
+	//	void move( pod::PointeredUserdata& to, pod::PointeredUserdata&& from );
+	//	void copy( pod::PointeredUserdata& to, const pod::PointeredUserdata& from );
+
+		// usage with MemoryPool
+		pod::PointeredUserdata UF_API create( uf::MemoryPool&, std::size_t len, void* data = NULL );
+		template<typename T> pod::PointeredUserdata create( uf::MemoryPool&, const T& data = T() );
+		void UF_API destroy( uf::MemoryPool&, pod::PointeredUserdata& userdata );
+		pod::PointeredUserdata UF_API copy( uf::MemoryPool&, const pod::PointeredUserdata& userdata );
+
+		size_t UF_API size( size_t size, size_t padding = 0 );
+	}
+}
+
+namespace uf {
+	// Provides operations for POD Userdata
+	class UF_API PointeredUserdata {
+	public:
+	// 	Easily access POD's type
+		typedef pod::PointeredUserdata pod_t;
+		bool autoDestruct = uf::userdata::autoDestruct;
+	protected:
+	// 	POD storage
+		PointeredUserdata::pod_t m_pod = {};
+	public:
+	// 	C-tor
+	
+		PointeredUserdata(std::size_t len = 0, void* data = NULL); 	// initializes POD to default
+		PointeredUserdata( const pod::PointeredUserdata& ); 						// initializes from POD
+		PointeredUserdata( PointeredUserdata&& move ) noexcept; 					// Move c-tor
+		PointeredUserdata( const PointeredUserdata& copy ); 				// Copy c-tor
+	
+		pod::PointeredUserdata& create( std::size_t len, void* data = NULL );
+		void move( PointeredUserdata& move );
+		void move( PointeredUserdata&& move );
+		void copy( const PointeredUserdata& copy );
+	// 	D-tor
+		~PointeredUserdata() noexcept;
+		void destroy();
+	// 	POD access
+		PointeredUserdata::pod_t& data(); 								// 	Returns a reference of POD
+		const PointeredUserdata::pod_t& data() const; 					// 	Returns a const-reference of POD
+	// 	Validity checks
+		bool initialized() const;
+	// 	Variadic construction
+		template<typename T> pod::PointeredUserdata& create( const T& data = T() );
+		template<typename T> T& get();
+		template<typename T> const T& get() const;
+
+		template<typename T> bool is() const;
+		template<typename T> inline T& as() { return get<T>(); }
+		template<typename T> inline const T& as() const { return get<T>(); }
+	// 	Overloaded ops
+		operator void*();
+		operator void*() const;
+		
+		operator bool() const;
+	
+		PointeredUserdata& operator=( pod::PointeredUserdata pointer );
+		PointeredUserdata& operator=( PointeredUserdata&& move );
+		PointeredUserdata& operator=( const PointeredUserdata& copy );
+	};
+}
+
+#include <cstdlib> // malloc, free
+
+// Allows copy via assignment!
+template<typename T>
+pod::PointeredUserdata uf::pointeredUserdata::create( const T& data ) {
+	return uf::pointeredUserdata::create<T>( uf::userdata::memoryPool, data );
+}
+template<typename T>
+pod::PointeredUserdata uf::pointeredUserdata::create( uf::MemoryPool& requestedMemoryPool, const T& data ) {
+//	uf::MemoryPool& memoryPool = uf::MemoryPool::global.size() > 0 ? uf::MemoryPool::global : requestedMemoryPool;
+	size_t len = sizeof(data);
+#if UF_MEMORYPOOL_INVALID_MALLOC
+	uf::MemoryPool& memoryPool = requestedMemoryPool.size() > 0 ? requestedMemoryPool : uf::MemoryPool::global;
+	pod::PointeredUserdata userdata;
+	userdata.len = len;
+	userdata.data = (uint8_t*) memoryPool.alloc( NULL, len );
+#else
+	uf::MemoryPool* memoryPool = NULL;
+	if ( requestedMemoryPool.size() > 0 ) memoryPool = &requestedMemoryPool;
+	else if ( uf::MemoryPool::global.size() > 0 ) memoryPool = &uf::MemoryPool::global;
+	pod::PointeredUserdata userdata;
+	userdata.len = len;
+	userdata.data = NULL;
+	if ( memoryPool )
+		userdata.data = (uint8_t*) memoryPool->alloc( NULL, len );
+	else
+		userdata.data = (uint8_t*) operator new( len ); 	// allocate data for the userdata struct, and then some	}
+#endif
+	userdata.len = len;
+#if UF_USERDATA_RTTI
+	userdata.type = typeid(T).hash_code();
+#endif
+	union {
+		uint8_t* from;
+		T* to;
+	} kludge;
+	kludge.from = userdata.data;
+	::new (kludge.to) T(data);
+	return userdata;
+}
+// Easy way to get the userdata as a reference
+#include <stdexcept>
+template<typename T>
+T& uf::pointeredUserdata::get( pod::PointeredUserdata& userdata, bool validate ) {
+	if ( validate && !uf::pointeredUserdata::is<T>( userdata ) ) UF_EXCEPTION("PointeredUserdata size|type mismatch");
+	union {
+		uint8_t* original;
+		T* casted;
+	} cast;
+	cast.original = userdata.data;
+	return *cast.casted;
+}
+template<typename T>
+const T& uf::pointeredUserdata::get( const pod::PointeredUserdata& userdata, bool validate ) {
+	if ( validate && !uf::pointeredUserdata::is<T>( userdata ) ) UF_EXCEPTION("PointeredUserdata size|type mismatch");
+	union {
+		const uint8_t* original;
+		const T* casted;
+	} cast;
+	cast.original = userdata.data;
+	return *cast.casted;
+}
+
+template<typename T>
+bool uf::pointeredUserdata::is( const pod::PointeredUserdata& userdata ) {
+#if UF_USERDATA_RTTI
+	return userdata.type == typeid(T).hash_code();
+#else
+	return userdata.len == sizeof(T);
+#endif
+}
+
+// No need to cast data to a pointer AND get the data's size!
+template<typename T>
+pod::PointeredUserdata& uf::PointeredUserdata::create( const T& data ) {
+	this->destroy();
+	return this->m_pod = uf::pointeredUserdata::create(data);
+}
+// Easy way to get the userdata as a reference
+template<typename T>
+T& uf::PointeredUserdata::get() {
+	union {
+		uint8_t* original;
+		T* casted;
+	} cast;
+	cast.original = this->m_pod.data;
+	return *cast.casted;
+//	return uf::pointeredUserdata::get<T>( this->m_pod );
+}
+// Easy way to get the userdata as a const-reference
+template<typename T>
+const T& uf::PointeredUserdata::get() const {
+	union {
+		const uint8_t* original;
+		const T* casted;
+	} cast;
+	cast.original = this->m_pod.data;
+	return *cast.casted;
+//	return uf::pointeredUserdata::get<T>( this->m_pod );
+}
+
+template<typename T>
+bool uf::PointeredUserdata::is() const {
+	return uf::pointeredUserdata::is<T>( this->m_pod );
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/userdata/userdata.h b/engine/inc/uf/utils/userdata/userdata.h
new file mode 100644
index 00000000..592c2060
--- /dev/null
+++ b/engine/inc/uf/utils/userdata/userdata.h
@@ -0,0 +1,108 @@
+#pragma once
+
+#include <uf/config.h>
+
+#include <uf/utils/mempool/mempool.h>
+
+#include <stdint.h>
+#include <cstddef>
+#include <string>
+#include <algorithm>
+#include <typeindex>
+
+#define UF_USERDATA_POOLED 0
+#define UF_USERDATA_KLUDGE 0
+#define UF_USERDATA_RTTI 1
+
+namespace pod {
+	struct UF_API Userdata {
+		std::size_t len = 0;
+	#if UF_USERDATA_RTTI
+		std::size_t type;
+	#endif
+		uint8_t data[1];
+	};
+}
+
+namespace uf {
+	namespace userdata {
+		extern UF_API uf::MemoryPool memoryPool;
+		extern UF_API bool autoDestruct;
+
+		pod::Userdata* UF_API create( std::size_t len, void* data = NULL );
+		void UF_API destroy( pod::Userdata* userdata );
+		pod::Userdata* UF_API copy( const pod::Userdata* userdata );
+
+		template<typename T> pod::Userdata* create( const T& data = T() );
+		template<typename T> T& get( pod::Userdata* userdata, bool validate = true);
+		template<typename T> const T& get(const pod::Userdata* userdata, bool validate = true );
+		template<typename T> bool is(const pod::Userdata* userdata);
+
+		std::string UF_API toBase64( pod::Userdata* userdata );
+		pod::Userdata* UF_API fromBase64( const std::string& base64 );
+
+	//	void move( pod::Userdata& to, pod::Userdata&& from );
+	//	void copy( pod::Userdata& to, const pod::Userdata& from );
+
+		// usage with MemoryPool
+		pod::Userdata* UF_API create( uf::MemoryPool&, std::size_t len, void* data = NULL );
+		template<typename T> pod::Userdata* create( uf::MemoryPool&, const T& data = T() );
+		void UF_API destroy( uf::MemoryPool&, pod::Userdata* userdata );
+		pod::Userdata* UF_API copy( uf::MemoryPool&, const pod::Userdata* userdata );
+
+		size_t UF_API size( size_t size, size_t padding = 0 );
+	}
+}
+
+namespace uf {
+	// Provides operations for POD Userdata
+	class UF_API Userdata {
+	public:
+	// 	Easily access POD's type
+		typedef pod::Userdata pod_t;
+		bool autoDestruct = uf::userdata::autoDestruct;
+	protected:
+	// 	POD storage
+		Userdata::pod_t* m_pod = NULL;
+	public:
+	// 	C-tor
+	
+		Userdata(std::size_t len = 0, void* data = NULL); 	// initializes POD to default
+		Userdata( pod::Userdata* ); 						// initializes from POD
+		Userdata( Userdata&& move ) noexcept ; 				// Move c-tor
+		Userdata( const Userdata& copy ); 		// Copy c-tor
+	
+		pod::Userdata* create( std::size_t len, void* data = NULL );
+		void move( Userdata& move );
+		void move( Userdata&& move );
+		void copy( const Userdata& copy );
+	// 	D-tor
+		~Userdata() noexcept;
+		void destroy();
+	// 	POD access
+		Userdata::pod_t& data(); 								// 	Returns a reference of POD
+		const Userdata::pod_t& data() const; 					// 	Returns a const-reference of POD
+	// 	Validity checks
+		bool initialized() const;
+	// 	Variadic construction
+		template<typename T> pod::Userdata* create( const T& data = T() );
+		template<typename T> T& get();
+		template<typename T> const T& get() const;
+
+		template<typename T> bool is() const;
+		template<typename T> inline T& as() { return get<T>(); }
+		template<typename T> inline const T& as() const { return get<T>(); }
+	// 	Overloaded ops
+		operator void*();
+		operator void*() const;
+		
+		operator bool() const;
+	
+		Userdata& operator=( pod::Userdata* pointer );
+		Userdata& operator=( Userdata&& move );
+		Userdata& operator=( const Userdata& copy );
+	};
+}
+
+#include "userdata.inl"
+#include "pointered.inl"
\ No newline at end of file
diff --git a/engine/inc/uf/utils/userdata/userdata.inl b/engine/inc/uf/utils/userdata/userdata.inl
new file mode 100644
index 00000000..8cd10765
--- /dev/null
+++ b/engine/inc/uf/utils/userdata/userdata.inl
@@ -0,0 +1,106 @@
+#include <cstdlib> // malloc, free
+
+// Allows copy via assignment!
+template<typename T>
+pod::Userdata* uf::userdata::create( const T& data ) {
+	return uf::userdata::create<T>( uf::userdata::memoryPool, data );
+}
+template<typename T>
+pod::Userdata* uf::userdata::create( uf::MemoryPool& requestedMemoryPool, const T& data ) {
+//	uf::MemoryPool& memoryPool = uf::MemoryPool::global.size() > 0 ? uf::MemoryPool::global : requestedMemoryPool;
+	size_t len = sizeof(data);
+	size_t requestedLen = size( len );
+#if UF_MEMORYPOOL_INVALID_MALLOC
+	uf::MemoryPool& memoryPool = requestedMemoryPool.size() > 0 ? requestedMemoryPool : uf::MemoryPool::global;
+	pod::Userdata* userdata = (pod::Userdata*) memoryPool.alloc( NULL, requestedLen );
+#else
+	uf::MemoryPool* memoryPool = NULL;
+	if ( requestedMemoryPool.size() > 0 ) memoryPool = &requestedMemoryPool;
+	else if ( uf::MemoryPool::global.size() > 0 ) memoryPool = &uf::MemoryPool::global;
+	pod::Userdata* userdata = NULL;
+	if ( memoryPool )
+		userdata = (pod::Userdata*) memoryPool->alloc( NULL, requestedLen );
+	else
+		userdata = (pod::Userdata*) operator new( requestedLen ); 	// allocate data for the userdata struct, and then some	}
+#endif
+	userdata->len = len;
+#if UF_USERDATA_RTTI
+	userdata->type = typeid(T).hash_code();
+#endif
+	union {
+		uint8_t* from;
+		T* to;
+	} kludge;
+	kludge.from = userdata->data;
+	::new (kludge.to) T(data);
+	return userdata;
+}
+// Easy way to get the userdata as a reference
+#include <stdexcept>
+template<typename T>
+T& uf::userdata::get( pod::Userdata* userdata, bool validate ) {
+	if ( validate && !uf::userdata::is<T>( userdata ) ) {
+		UF_EXCEPTION("Userdata size|type mismatch");
+	}
+	union {
+		uint8_t* original;
+		T* casted;
+	} cast;
+	cast.original = userdata->data;
+	return *cast.casted;
+}
+template<typename T>
+const T& uf::userdata::get( const pod::Userdata* userdata, bool validate ) {
+	if ( validate && !uf::userdata::is<T>( userdata ) ) {
+		UF_EXCEPTION("Userdata size|type mismatch");
+	}
+	union {
+		const uint8_t* original;
+		const T* casted;
+	} cast;
+	cast.original = userdata->data;
+	return *cast.casted;
+}
+
+template<typename T>
+bool uf::userdata::is( const pod::Userdata* userdata ) {
+#if UF_USERDATA_RTTI
+	return userdata && userdata->type == typeid(T).hash_code();
+#else
+	return userdata && userdata->len == sizeof(T);
+#endif
+}
+
+// No need to cast data to a pointer AND get the data's size!
+template<typename T>
+pod::Userdata* uf::Userdata::create( const T& data ) {
+	this->destroy();
+	return this->m_pod = uf::userdata::create(data);
+}
+// Easy way to get the userdata as a reference
+template<typename T>
+T& uf::Userdata::get() {
+	union {
+		uint8_t* original;
+		T* casted;
+	} cast;
+	cast.original = this->m_pod->data;
+	return *cast.casted;
+//	return uf::userdata::get<T>( this->m_pod );
+}
+// Easy way to get the userdata as a const-reference
+template<typename T>
+const T& uf::Userdata::get() const {
+	union {
+		const uint8_t* original;
+		const T* casted;
+	} cast;
+	cast.original = this->m_pod->data;
+	return *cast.casted;
+//	return uf::userdata::get<T>( this->m_pod );
+}
+
+template<typename T>
+bool uf::Userdata::is() const {
+	return this->m_pod && uf::userdata::is<T>( this->m_pod );
+}
\ No newline at end of file
diff --git a/engine/inc/uf/utils/window/window.h b/engine/inc/uf/utils/window/window.h
new file mode 100644
index 00000000..d33e4c06
--- /dev/null
+++ b/engine/inc/uf/utils/window/window.h
@@ -0,0 +1,69 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/spec/window/window.h>
+#include <uf/spec/context/context.h>
+
+#if !UF_USE_SFML
+namespace uf {
+	class UF_API Window : public spec::uni::Window {
+	public:
+		typedef spec::Window window_t;
+		typedef spec::Context context_t;
+	protected:
+		Window::window_t* m_window;
+		Window::context_t* m_context;
+	public:
+	// 	C-tors
+		UF_API_CALL Window();
+		UF_API_CALL Window( const spec::uni::Window::vector_t& size, const spec::uni::Window::title_t& title = L"Window", const spec::Context::Settings& settings = spec::Context::Settings() );
+		/*virtual*/ void UF_API_CALL create( const spec::uni::Window::vector_t& size, const spec::uni::Window::title_t& title = L"Window", const spec::Context::Settings& settings = spec::Context::Settings() );
+	// 	D-tors
+		/*virtual*/ ~Window();
+		/*virtual*/ void UF_API_CALL terminate();
+	// 	Gets
+		/*virtual*/ spec::uni::Window::vector_t UF_API_CALL getPosition() const;
+		/*virtual*/ spec::uni::Window::vector_t UF_API_CALL getSize() const;
+		/*virtual*/ size_t UF_API_CALL getRefreshRate() const;
+	// 	Attribute modifiers
+		/*virtual*/ void UF_API_CALL setPosition( const spec::uni::Window::vector_t& position );
+		/*virtual*/ void UF_API_CALL centerWindow();
+		/*virtual*/ void UF_API_CALL setMousePosition( const spec::uni::Window::vector_t& position );
+		/*virtual*/ spec::uni::Window::vector_t UF_API_CALL getMousePosition();
+		/*virtual*/ void UF_API_CALL setSize( const spec::uni::Window::vector_t& size );
+		/*virtual*/ void UF_API_CALL setTitle( const spec::uni::Window::title_t& title );
+		/*virtual*/ void UF_API_CALL setIcon( const spec::uni::Window::vector_t& size, uint8_t* pixels );
+		/*virtual*/ void UF_API_CALL setVisible( bool visibility );
+		/*virtual*/ void UF_API_CALL setCursorVisible( bool visibility );
+		/*virtual*/ void UF_API_CALL setKeyRepeatEnabled( bool state );
+		/*virtual*/ void UF_API_CALL setMouseGrabbed( bool state );
+	
+		/*virtual*/ void UF_API_CALL requestFocus();
+		/*virtual*/ bool UF_API_CALL hasFocus() const;
+		static pod::Vector2ui UF_API_CALL getResolution();
+		/*virtual*/ void UF_API_CALL switchToFullscreen( bool borderless = false );
+	// 	Update
+	#if defined(UF_USE_VULKAN) && UF_USE_VULKAN == 1
+		std::vector<std::string> getExtensions( bool validationEnabled = true );
+		void createSurface( VkInstance instance, VkSurfaceKHR& surface );
+	#endif
+		static bool focused;
+		static /*virtual*/ bool UF_API_CALL isKeyPressed(const std::string&);
+		/*virtual*/ void UF_API_CALL processEvents();
+		/*virtual*/ bool UF_API_CALL pollEvents(bool block = false);
+		/*virtual*/ bool UF_API_CALL setActive( bool active = true );
+		/*virtual*/ void UF_API_CALL display();
+		/*virtual*/ Window::window_t* UF_API_CALL getHandle();
+		/*virtual*/ const Window::window_t* UF_API_CALL getHandle() const;
+	};
+}
+#elif UF_USE_SFML
+namespace uf {
+	typedef ext::sfml::Window Window;	
+}
+#elif UF_USE_GLFW
+#include <uf/ext/glfw/glfw.h>
+namespace uf {
+	typedef ext::glfw::Window Window;
+}
+#endif
\ No newline at end of file
diff --git a/engine/inc/vk_mem_alloc.h b/engine/inc/vk_mem_alloc.h
new file mode 100644
index 00000000..73ba0eb0
--- /dev/null
+++ b/engine/inc/vk_mem_alloc.h
@@ -0,0 +1,19304 @@
+//
+// Copyright (c) 2017-2020 Advanced Micro Devices, Inc. All rights reserved.
+//
+// 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.
+//
+
+#ifndef AMD_VULKAN_MEMORY_ALLOCATOR_H
+#define AMD_VULKAN_MEMORY_ALLOCATOR_H
+
+/** \mainpage Vulkan Memory Allocator
+
+<b>Version 3.0.0-development</b> (2020-11-03)
+
+Copyright (c) 2017-2020 Advanced Micro Devices, Inc. All rights reserved. \n
+License: MIT
+
+Documentation of all members: vk_mem_alloc.h
+
+\section main_table_of_contents Table of contents
+
+- <b>User guide</b>
+  - \subpage quick_start
+    - [Project setup](@ref quick_start_project_setup)
+    - [Initialization](@ref quick_start_initialization)
+    - [Resource allocation](@ref quick_start_resource_allocation)
+  - \subpage choosing_memory_type
+    - [Usage](@ref choosing_memory_type_usage)
+    - [Required and preferred flags](@ref choosing_memory_type_required_preferred_flags)
+    - [Explicit memory types](@ref choosing_memory_type_explicit_memory_types)
+    - [Custom memory pools](@ref choosing_memory_type_custom_memory_pools)
+    - [Dedicated allocations](@ref choosing_memory_type_dedicated_allocations)
+  - \subpage memory_mapping
+    - [Mapping functions](@ref memory_mapping_mapping_functions)
+    - [Persistently mapped memory](@ref memory_mapping_persistently_mapped_memory)
+    - [Cache flush and invalidate](@ref memory_mapping_cache_control)
+    - [Finding out if memory is mappable](@ref memory_mapping_finding_if_memory_mappable)
+  - \subpage staying_within_budget
+    - [Querying for budget](@ref staying_within_budget_querying_for_budget)
+    - [Controlling memory usage](@ref staying_within_budget_controlling_memory_usage)
+  - \subpage resource_aliasing
+  - \subpage custom_memory_pools
+    - [Choosing memory type index](@ref custom_memory_pools_MemTypeIndex)
+    - [Linear allocation algorithm](@ref linear_algorithm)
+      - [Free-at-once](@ref linear_algorithm_free_at_once)
+      - [Stack](@ref linear_algorithm_stack)
+      - [Double stack](@ref linear_algorithm_double_stack)
+      - [Ring buffer](@ref linear_algorithm_ring_buffer)
+    - [Buddy allocation algorithm](@ref buddy_algorithm)
+  - \subpage defragmentation
+      - [Defragmenting CPU memory](@ref defragmentation_cpu)
+      - [Defragmenting GPU memory](@ref defragmentation_gpu)
+      - [Additional notes](@ref defragmentation_additional_notes)
+      - [Writing custom allocation algorithm](@ref defragmentation_custom_algorithm)
+  - \subpage lost_allocations
+  - \subpage statistics
+    - [Numeric statistics](@ref statistics_numeric_statistics)
+    - [JSON dump](@ref statistics_json_dump)
+  - \subpage allocation_annotation
+    - [Allocation user data](@ref allocation_user_data)
+    - [Allocation names](@ref allocation_names)
+  - \subpage debugging_memory_usage
+    - [Memory initialization](@ref debugging_memory_usage_initialization)
+    - [Margins](@ref debugging_memory_usage_margins)
+    - [Corruption detection](@ref debugging_memory_usage_corruption_detection)
+  - \subpage record_and_replay
+- \subpage usage_patterns
+  - [Common mistakes](@ref usage_patterns_common_mistakes)
+  - [Simple patterns](@ref usage_patterns_simple)
+  - [Advanced patterns](@ref usage_patterns_advanced)
+- \subpage configuration
+  - [Pointers to Vulkan functions](@ref config_Vulkan_functions)
+  - [Custom host memory allocator](@ref custom_memory_allocator)
+  - [Device memory allocation callbacks](@ref allocation_callbacks)
+  - [Device heap memory limit](@ref heap_memory_limit)
+  - \subpage vk_khr_dedicated_allocation
+  - \subpage enabling_buffer_device_address
+  - \subpage vk_amd_device_coherent_memory
+- \subpage general_considerations
+  - [Thread safety](@ref general_considerations_thread_safety)
+  - [Validation layer warnings](@ref general_considerations_validation_layer_warnings)
+  - [Allocation algorithm](@ref general_considerations_allocation_algorithm)
+  - [Features not supported](@ref general_considerations_features_not_supported)
+
+\section main_see_also See also
+
+- [Product page on GPUOpen](https://gpuopen.com/gaming-product/vulkan-memory-allocator/)
+- [Source repository on GitHub](https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator)
+
+
+
+
+\page quick_start Quick start
+
+\section quick_start_project_setup Project setup
+
+Vulkan Memory Allocator comes in form of a "stb-style" single header file.
+You don't need to build it as a separate library project.
+You can add this file directly to your project and submit it to code repository next to your other source files.
+
+"Single header" doesn't mean that everything is contained in C/C++ declarations,
+like it tends to be in case of inline functions or C++ templates.
+It means that implementation is bundled with interface in a single file and needs to be extracted using preprocessor macro.
+If you don't do it properly, you will get linker errors.
+
+To do it properly:
+
+-# Include "vk_mem_alloc.h" file in each CPP file where you want to use the library.
+   This includes declarations of all members of the library.
+-# In exacly one CPP file define following macro before this include.
+   It enables also internal definitions.
+
+\code
+#define VMA_IMPLEMENTATION
+#include "vk_mem_alloc.h"
+\endcode
+
+It may be a good idea to create dedicated CPP file just for this purpose.
+
+Note on language: This library is written in C++, but has C-compatible interface.
+Thus you can include and use vk_mem_alloc.h in C or C++ code, but full
+implementation with `VMA_IMPLEMENTATION` macro must be compiled as C++, NOT as C.
+
+Please note that this library includes header `<vulkan/vulkan.h>`, which in turn
+includes `<windows.h>` on Windows. If you need some specific macros defined
+before including these headers (like `WIN32_LEAN_AND_MEAN` or
+`WINVER` for Windows, `VK_USE_PLATFORM_WIN32_KHR` for Vulkan), you must define
+them before every `#include` of this library.
+
+You may need to configure the way you import Vulkan functions.
+
+- By default, VMA assumes you you link statically with Vulkan API. If this is not the case,
+  `#define VMA_STATIC_VULKAN_FUNCTIONS 0` before `#include` of the VMA implementation and use another way.
+- You can `#define VMA_DYNAMIC_VULKAN_FUNCTIONS 1` and make sure `vkGetInstanceProcAddr` and `vkGetDeviceProcAddr` globals are defined.
+  All the remaining Vulkan functions will be fetched automatically.
+- Finally, you can provide your own pointers to all Vulkan functions needed by VMA using structure member
+  VmaAllocatorCreateInfo::pVulkanFunctions, if you fetched them in some custom way e.g. using some loader like [Volk](https://github.com/zeux/volk).
+
+
+\section quick_start_initialization Initialization
+
+At program startup:
+
+-# Initialize Vulkan to have `VkPhysicalDevice`, `VkDevice` and `VkInstance` object.
+-# Fill VmaAllocatorCreateInfo structure and create #VmaAllocator object by
+   calling vmaCreateAllocator().
+
+\code
+VmaAllocatorCreateInfo allocatorInfo = {};
+allocatorInfo.vulkanApiVersion = VK_API_VERSION_1_2;
+allocatorInfo.physicalDevice = physicalDevice;
+allocatorInfo.device = device;
+allocatorInfo.instance = instance;
+
+VmaAllocator allocator;
+vmaCreateAllocator(&allocatorInfo, &allocator);
+\endcode
+
+Only members `physicalDevice`, `device`, `instance` are required.
+However, you should inform the library which Vulkan version do you use by setting
+VmaAllocatorCreateInfo::vulkanApiVersion and which extensions did you enable
+by setting VmaAllocatorCreateInfo::flags (like #VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT for VK_KHR_buffer_device_address).
+Otherwise, VMA would use only features of Vulkan 1.0 core with no extensions.
+
+
+\section quick_start_resource_allocation Resource allocation
+
+When you want to create a buffer or image:
+
+-# Fill `VkBufferCreateInfo` / `VkImageCreateInfo` structure.
+-# Fill VmaAllocationCreateInfo structure.
+-# Call vmaCreateBuffer() / vmaCreateImage() to get `VkBuffer`/`VkImage` with memory
+   already allocated and bound to it.
+
+\code
+VkBufferCreateInfo bufferInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
+bufferInfo.size = 65536;
+bufferInfo.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+
+VmaAllocationCreateInfo allocInfo = {};
+allocInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY;
+
+VkBuffer buffer;
+VmaAllocation allocation;
+vmaCreateBuffer(allocator, &bufferInfo, &allocInfo, &buffer, &allocation, nullptr);
+\endcode
+
+Don't forget to destroy your objects when no longer needed:
+
+\code
+vmaDestroyBuffer(allocator, buffer, allocation);
+vmaDestroyAllocator(allocator);
+\endcode
+
+
+\page choosing_memory_type Choosing memory type
+
+Physical devices in Vulkan support various combinations of memory heaps and
+types. Help with choosing correct and optimal memory type for your specific
+resource is one of the key features of this library. You can use it by filling
+appropriate members of VmaAllocationCreateInfo structure, as described below.
+You can also combine multiple methods.
+
+-# If you just want to find memory type index that meets your requirements, you
+   can use function: vmaFindMemoryTypeIndex(), vmaFindMemoryTypeIndexForBufferInfo(),
+   vmaFindMemoryTypeIndexForImageInfo().
+-# If you want to allocate a region of device memory without association with any
+   specific image or buffer, you can use function vmaAllocateMemory(). Usage of
+   this function is not recommended and usually not needed.
+   vmaAllocateMemoryPages() function is also provided for creating multiple allocations at once,
+   which may be useful for sparse binding.
+-# If you already have a buffer or an image created, you want to allocate memory
+   for it and then you will bind it yourself, you can use function
+   vmaAllocateMemoryForBuffer(), vmaAllocateMemoryForImage().
+   For binding you should use functions: vmaBindBufferMemory(), vmaBindImageMemory()
+   or their extended versions: vmaBindBufferMemory2(), vmaBindImageMemory2().
+-# If you want to create a buffer or an image, allocate memory for it and bind
+   them together, all in one call, you can use function vmaCreateBuffer(),
+   vmaCreateImage(). This is the easiest and recommended way to use this library.
+
+When using 3. or 4., the library internally queries Vulkan for memory types
+supported for that buffer or image (function `vkGetBufferMemoryRequirements()`)
+and uses only one of these types.
+
+If no memory type can be found that meets all the requirements, these functions
+return `VK_ERROR_FEATURE_NOT_PRESENT`.
+
+You can leave VmaAllocationCreateInfo structure completely filled with zeros.
+It means no requirements are specified for memory type.
+It is valid, although not very useful.
+
+\section choosing_memory_type_usage Usage
+
+The easiest way to specify memory requirements is to fill member
+VmaAllocationCreateInfo::usage using one of the values of enum #VmaMemoryUsage.
+It defines high level, common usage types.
+For more details, see description of this enum.
+
+For example, if you want to create a uniform buffer that will be filled using
+transfer only once or infrequently and used for rendering every frame, you can
+do it using following code:
+
+\code
+VkBufferCreateInfo bufferInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
+bufferInfo.size = 65536;
+bufferInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+
+VmaAllocationCreateInfo allocInfo = {};
+allocInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY;
+
+VkBuffer buffer;
+VmaAllocation allocation;
+vmaCreateBuffer(allocator, &bufferInfo, &allocInfo, &buffer, &allocation, nullptr);
+\endcode
+
+\section choosing_memory_type_required_preferred_flags Required and preferred flags
+
+You can specify more detailed requirements by filling members
+VmaAllocationCreateInfo::requiredFlags and VmaAllocationCreateInfo::preferredFlags
+with a combination of bits from enum `VkMemoryPropertyFlags`. For example,
+if you want to create a buffer that will be persistently mapped on host (so it
+must be `HOST_VISIBLE`) and preferably will also be `HOST_COHERENT` and `HOST_CACHED`,
+use following code:
+
+\code
+VmaAllocationCreateInfo allocInfo = {};
+allocInfo.requiredFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
+allocInfo.preferredFlags = VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
+allocInfo.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
+
+VkBuffer buffer;
+VmaAllocation allocation;
+vmaCreateBuffer(allocator, &bufferInfo, &allocInfo, &buffer, &allocation, nullptr);
+\endcode
+
+A memory type is chosen that has all the required flags and as many preferred
+flags set as possible.
+
+If you use VmaAllocationCreateInfo::usage, it is just internally converted to
+a set of required and preferred flags.
+
+\section choosing_memory_type_explicit_memory_types Explicit memory types
+
+If you inspected memory types available on the physical device and you have
+a preference for memory types that you want to use, you can fill member
+VmaAllocationCreateInfo::memoryTypeBits. It is a bit mask, where each bit set
+means that a memory type with that index is allowed to be used for the
+allocation. Special value 0, just like `UINT32_MAX`, means there are no
+restrictions to memory type index.
+
+Please note that this member is NOT just a memory type index.
+Still you can use it to choose just one, specific memory type.
+For example, if you already determined that your buffer should be created in
+memory type 2, use following code:
+
+\code
+uint32_t memoryTypeIndex = 2;
+
+VmaAllocationCreateInfo allocInfo = {};
+allocInfo.memoryTypeBits = 1u << memoryTypeIndex;
+
+VkBuffer buffer;
+VmaAllocation allocation;
+vmaCreateBuffer(allocator, &bufferInfo, &allocInfo, &buffer, &allocation, nullptr);
+\endcode
+
+
+\section choosing_memory_type_custom_memory_pools Custom memory pools
+
+If you allocate from custom memory pool, all the ways of specifying memory
+requirements described above are not applicable and the aforementioned members
+of VmaAllocationCreateInfo structure are ignored. Memory type is selected
+explicitly when creating the pool and then used to make all the allocations from
+that pool. For further details, see \ref custom_memory_pools.
+
+\section choosing_memory_type_dedicated_allocations Dedicated allocations
+
+Memory for allocations is reserved out of larger block of `VkDeviceMemory`
+allocated from Vulkan internally. That's the main feature of this whole library.
+You can still request a separate memory block to be created for an allocation,
+just like you would do in a trivial solution without using any allocator.
+In that case, a buffer or image is always bound to that memory at offset 0.
+This is called a "dedicated allocation".
+You can explicitly request it by using flag #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT.
+The library can also internally decide to use dedicated allocation in some cases, e.g.:
+
+- When the size of the allocation is large.
+- When [VK_KHR_dedicated_allocation](@ref vk_khr_dedicated_allocation) extension is enabled
+  and it reports that dedicated allocation is required or recommended for the resource.
+- When allocation of next big memory block fails due to not enough device memory,
+  but allocation with the exact requested size succeeds.
+
+
+\page memory_mapping Memory mapping
+
+To "map memory" in Vulkan means to obtain a CPU pointer to `VkDeviceMemory`,
+to be able to read from it or write to it in CPU code.
+Mapping is possible only of memory allocated from a memory type that has
+`VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT` flag.
+Functions `vkMapMemory()`, `vkUnmapMemory()` are designed for this purpose.
+You can use them directly with memory allocated by this library,
+but it is not recommended because of following issue:
+Mapping the same `VkDeviceMemory` block multiple times is illegal - only one mapping at a time is allowed.
+This includes mapping disjoint regions. Mapping is not reference-counted internally by Vulkan.
+Because of this, Vulkan Memory Allocator provides following facilities:
+
+\section memory_mapping_mapping_functions Mapping functions
+
+The library provides following functions for mapping of a specific #VmaAllocation: vmaMapMemory(), vmaUnmapMemory().
+They are safer and more convenient to use than standard Vulkan functions.
+You can map an allocation multiple times simultaneously - mapping is reference-counted internally.
+You can also map different allocations simultaneously regardless of whether they use the same `VkDeviceMemory` block.
+The way it's implemented is that the library always maps entire memory block, not just region of the allocation.
+For further details, see description of vmaMapMemory() function.
+Example:
+
+\code
+// Having these objects initialized:
+
+struct ConstantBuffer
+{
+    ...
+};
+ConstantBuffer constantBufferData;
+
+VmaAllocator allocator;
+VkBuffer constantBuffer;
+VmaAllocation constantBufferAllocation;
+
+// You can map and fill your buffer using following code:
+
+void* mappedData;
+vmaMapMemory(allocator, constantBufferAllocation, &mappedData);
+memcpy(mappedData, &constantBufferData, sizeof(constantBufferData));
+vmaUnmapMemory(allocator, constantBufferAllocation);
+\endcode
+
+When mapping, you may see a warning from Vulkan validation layer similar to this one:
+
+<i>Mapping an image with layout VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL can result in undefined behavior if this memory is used by the device. Only GENERAL or PREINITIALIZED should be used.</i>
+
+It happens because the library maps entire `VkDeviceMemory` block, where different
+types of images and buffers may end up together, especially on GPUs with unified memory like Intel.
+You can safely ignore it if you are sure you access only memory of the intended
+object that you wanted to map.
+
+
+\section memory_mapping_persistently_mapped_memory Persistently mapped memory
+
+Kepping your memory persistently mapped is generally OK in Vulkan.
+You don't need to unmap it before using its data on the GPU.
+The library provides a special feature designed for that:
+Allocations made with #VMA_ALLOCATION_CREATE_MAPPED_BIT flag set in
+VmaAllocationCreateInfo::flags stay mapped all the time,
+so you can just access CPU pointer to it any time
+without a need to call any "map" or "unmap" function.
+Example:
+
+\code
+VkBufferCreateInfo bufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
+bufCreateInfo.size = sizeof(ConstantBuffer);
+bufCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
+
+VmaAllocationCreateInfo allocCreateInfo = {};
+allocCreateInfo.usage = VMA_MEMORY_USAGE_CPU_ONLY;
+allocCreateInfo.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
+
+VkBuffer buf;
+VmaAllocation alloc;
+VmaAllocationInfo allocInfo;
+vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &buf, &alloc, &allocInfo);
+
+// Buffer is already mapped. You can access its memory.
+memcpy(allocInfo.pMappedData, &constantBufferData, sizeof(constantBufferData));
+\endcode
+
+There are some exceptions though, when you should consider mapping memory only for a short period of time:
+
+- When operating system is Windows 7 or 8.x (Windows 10 is not affected because it uses WDDM2),
+  device is discrete AMD GPU,
+  and memory type is the special 256 MiB pool of `DEVICE_LOCAL + HOST_VISIBLE` memory
+  (selected when you use #VMA_MEMORY_USAGE_CPU_TO_GPU),
+  then whenever a memory block allocated from this memory type stays mapped
+  for the time of any call to `vkQueueSubmit()` or `vkQueuePresentKHR()`, this
+  block is migrated by WDDM to system RAM, which degrades performance. It doesn't
+  matter if that particular memory block is actually used by the command buffer
+  being submitted.
+- On Mac/MoltenVK there is a known bug - [Issue #175](https://github.com/KhronosGroup/MoltenVK/issues/175)
+  which requires unmapping before GPU can see updated texture.
+- Keeping many large memory blocks mapped may impact performance or stability of some debugging tools.
+
+\section memory_mapping_cache_control Cache flush and invalidate
+
+Memory in Vulkan doesn't need to be unmapped before using it on GPU,
+but unless a memory types has `VK_MEMORY_PROPERTY_HOST_COHERENT_BIT` flag set,
+you need to manually **invalidate** cache before reading of mapped pointer
+and **flush** cache after writing to mapped pointer.
+Map/unmap operations don't do that automatically.
+Vulkan provides following functions for this purpose `vkFlushMappedMemoryRanges()`,
+`vkInvalidateMappedMemoryRanges()`, but this library provides more convenient
+functions that refer to given allocation object: vmaFlushAllocation(),
+vmaInvalidateAllocation(),
+or multiple objects at once: vmaFlushAllocations(), vmaInvalidateAllocations().
+
+Regions of memory specified for flush/invalidate must be aligned to
+`VkPhysicalDeviceLimits::nonCoherentAtomSize`. This is automatically ensured by the library.
+In any memory type that is `HOST_VISIBLE` but not `HOST_COHERENT`, all allocations
+within blocks are aligned to this value, so their offsets are always multiply of
+`nonCoherentAtomSize` and two different allocations never share same "line" of this size.
+
+Please note that memory allocated with #VMA_MEMORY_USAGE_CPU_ONLY is guaranteed to be `HOST_COHERENT`.
+
+Also, Windows drivers from all 3 **PC** GPU vendors (AMD, Intel, NVIDIA)
+currently provide `HOST_COHERENT` flag on all memory types that are
+`HOST_VISIBLE`, so on this platform you may not need to bother.
+
+\section memory_mapping_finding_if_memory_mappable Finding out if memory is mappable
+
+It may happen that your allocation ends up in memory that is `HOST_VISIBLE` (available for mapping)
+despite it wasn't explicitly requested.
+For example, application may work on integrated graphics with unified memory (like Intel) or
+allocation from video memory might have failed, so the library chose system memory as fallback.
+
+You can detect this case and map such allocation to access its memory on CPU directly,
+instead of launching a transfer operation.
+In order to do that: inspect `allocInfo.memoryType`, call vmaGetMemoryTypeProperties(),
+and look for `VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT` flag in properties of that memory type.
+
+\code
+VkBufferCreateInfo bufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
+bufCreateInfo.size = sizeof(ConstantBuffer);
+bufCreateInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+
+VmaAllocationCreateInfo allocCreateInfo = {};
+allocCreateInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY;
+allocCreateInfo.preferredFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
+
+VkBuffer buf;
+VmaAllocation alloc;
+VmaAllocationInfo allocInfo;
+vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &buf, &alloc, &allocInfo);
+
+VkMemoryPropertyFlags memFlags;
+vmaGetMemoryTypeProperties(allocator, allocInfo.memoryType, &memFlags);
+if((memFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
+{
+    // Allocation ended up in mappable memory. You can map it and access it directly.
+    void* mappedData;
+    vmaMapMemory(allocator, alloc, &mappedData);
+    memcpy(mappedData, &constantBufferData, sizeof(constantBufferData));
+    vmaUnmapMemory(allocator, alloc);
+}
+else
+{
+    // Allocation ended up in non-mappable memory.
+    // You need to create CPU-side buffer in VMA_MEMORY_USAGE_CPU_ONLY and make a transfer.
+}
+\endcode
+
+You can even use #VMA_ALLOCATION_CREATE_MAPPED_BIT flag while creating allocations
+that are not necessarily `HOST_VISIBLE` (e.g. using #VMA_MEMORY_USAGE_GPU_ONLY).
+If the allocation ends up in memory type that is `HOST_VISIBLE`, it will be persistently mapped and you can use it directly.
+If not, the flag is just ignored.
+Example:
+
+\code
+VkBufferCreateInfo bufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
+bufCreateInfo.size = sizeof(ConstantBuffer);
+bufCreateInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+
+VmaAllocationCreateInfo allocCreateInfo = {};
+allocCreateInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY;
+allocCreateInfo.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
+
+VkBuffer buf;
+VmaAllocation alloc;
+VmaAllocationInfo allocInfo;
+vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &buf, &alloc, &allocInfo);
+
+if(allocInfo.pMappedData != nullptr)
+{
+    // Allocation ended up in mappable memory.
+    // It's persistently mapped. You can access it directly.
+    memcpy(allocInfo.pMappedData, &constantBufferData, sizeof(constantBufferData));
+}
+else
+{
+    // Allocation ended up in non-mappable memory.
+    // You need to create CPU-side buffer in VMA_MEMORY_USAGE_CPU_ONLY and make a transfer.
+}
+\endcode
+
+
+\page staying_within_budget Staying within budget
+
+When developing a graphics-intensive game or program, it is important to avoid allocating
+more GPU memory than it's physically available. When the memory is over-committed,
+various bad things can happen, depending on the specific GPU, graphics driver, and
+operating system:
+
+- It may just work without any problems.
+- The application may slow down because some memory blocks are moved to system RAM
+  and the GPU has to access them through PCI Express bus.
+- A new allocation may take very long time to complete, even few seconds, and possibly
+  freeze entire system.
+- The new allocation may fail with `VK_ERROR_OUT_OF_DEVICE_MEMORY`.
+- It may even result in GPU crash (TDR), observed as `VK_ERROR_DEVICE_LOST`
+  returned somewhere later.
+
+\section staying_within_budget_querying_for_budget Querying for budget
+
+To query for current memory usage and available budget, use function vmaGetBudget().
+Returned structure #VmaBudget contains quantities expressed in bytes, per Vulkan memory heap.
+
+Please note that this function returns different information and works faster than
+vmaCalculateStats(). vmaGetBudget() can be called every frame or even before every
+allocation, while vmaCalculateStats() is intended to be used rarely,
+only to obtain statistical information, e.g. for debugging purposes.
+
+It is recommended to use <b>VK_EXT_memory_budget</b> device extension to obtain information
+about the budget from Vulkan device. VMA is able to use this extension automatically.
+When not enabled, the allocator behaves same way, but then it estimates current usage
+and available budget based on its internal information and Vulkan memory heap sizes,
+which may be less precise. In order to use this extension:
+
+1. Make sure extensions VK_EXT_memory_budget and VK_KHR_get_physical_device_properties2
+   required by it are available and enable them. Please note that the first is a device
+   extension and the second is instance extension!
+2. Use flag #VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT when creating #VmaAllocator object.
+3. Make sure to call vmaSetCurrentFrameIndex() every frame. Budget is queried from
+   Vulkan inside of it to avoid overhead of querying it with every allocation.
+
+\section staying_within_budget_controlling_memory_usage Controlling memory usage
+
+There are many ways in which you can try to stay within the budget.
+
+First, when making new allocation requires allocating a new memory block, the library
+tries not to exceed the budget automatically. If a block with default recommended size
+(e.g. 256 MB) would go over budget, a smaller block is allocated, possibly even
+dedicated memory for just this resource.
+
+If the size of the requested resource plus current memory usage is more than the
+budget, by default the library still tries to create it, leaving it to the Vulkan
+implementation whether the allocation succeeds or fails. You can change this behavior
+by using #VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT flag. With it, the allocation is
+not made if it would exceed the budget or if the budget is already exceeded.
+Some other allocations become lost instead to make room for it, if the mechanism of
+[lost allocations](@ref lost_allocations) is used.
+If that is not possible, the allocation fails with `VK_ERROR_OUT_OF_DEVICE_MEMORY`.
+Example usage pattern may be to pass the #VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT flag
+when creating resources that are not essential for the application (e.g. the texture
+of a specific object) and not to pass it when creating critically important resources
+(e.g. render targets).
+
+Finally, you can also use #VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT flag to make sure
+a new allocation is created only when it fits inside one of the existing memory blocks.
+If it would require to allocate a new block, if fails instead with `VK_ERROR_OUT_OF_DEVICE_MEMORY`.
+This also ensures that the function call is very fast because it never goes to Vulkan
+to obtain a new block.
+
+Please note that creating \ref custom_memory_pools with VmaPoolCreateInfo::minBlockCount
+set to more than 0 will try to allocate memory blocks without checking whether they
+fit within budget.
+
+
+\page resource_aliasing Resource aliasing (overlap)
+
+New explicit graphics APIs (Vulkan and Direct3D 12), thanks to manual memory
+management, give an opportunity to alias (overlap) multiple resources in the
+same region of memory - a feature not available in the old APIs (Direct3D 11, OpenGL).
+It can be useful to save video memory, but it must be used with caution.
+
+For example, if you know the flow of your whole render frame in advance, you
+are going to use some intermediate textures or buffers only during a small range of render passes,
+and you know these ranges don't overlap in time, you can bind these resources to
+the same place in memory, even if they have completely different parameters (width, height, format etc.).
+
+![Resource aliasing (overlap)](../gfx/Aliasing.png)
+
+Such scenario is possible using VMA, but you need to create your images manually.
+Then you need to calculate parameters of an allocation to be made using formula:
+
+- allocation size = max(size of each image)
+- allocation alignment = max(alignment of each image)
+- allocation memoryTypeBits = bitwise AND(memoryTypeBits of each image)
+
+Following example shows two different images bound to the same place in memory,
+allocated to fit largest of them.
+
+\code
+// A 512x512 texture to be sampled.
+VkImageCreateInfo img1CreateInfo = { VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
+img1CreateInfo.imageType = VK_IMAGE_TYPE_2D;
+img1CreateInfo.extent.width = 512;
+img1CreateInfo.extent.height = 512;
+img1CreateInfo.extent.depth = 1;
+img1CreateInfo.mipLevels = 10;
+img1CreateInfo.arrayLayers = 1;
+img1CreateInfo.format = VK_FORMAT_R8G8B8A8_SRGB;
+img1CreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
+img1CreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+img1CreateInfo.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
+img1CreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
+
+// A full screen texture to be used as color attachment.
+VkImageCreateInfo img2CreateInfo = { VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
+img2CreateInfo.imageType = VK_IMAGE_TYPE_2D;
+img2CreateInfo.extent.width = 1920;
+img2CreateInfo.extent.height = 1080;
+img2CreateInfo.extent.depth = 1;
+img2CreateInfo.mipLevels = 1;
+img2CreateInfo.arrayLayers = 1;
+img2CreateInfo.format = VK_FORMAT_R8G8B8A8_UNORM;
+img2CreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
+img2CreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+img2CreateInfo.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+img2CreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
+
+VkImage img1;
+res = vkCreateImage(device, &img1CreateInfo, nullptr, &img1);
+VkImage img2;
+res = vkCreateImage(device, &img2CreateInfo, nullptr, &img2);
+
+VkMemoryRequirements img1MemReq;
+vkGetImageMemoryRequirements(device, img1, &img1MemReq);
+VkMemoryRequirements img2MemReq;
+vkGetImageMemoryRequirements(device, img2, &img2MemReq);
+
+VkMemoryRequirements finalMemReq = {};
+finalMemReq.size = std::max(img1MemReq.size, img2MemReq.size);
+finalMemReq.alignment = std::max(img1MemReq.alignment, img2MemReq.alignment);
+finalMemReq.memoryTypeBits = img1MemReq.memoryTypeBits & img2MemReq.memoryTypeBits;
+// Validate if(finalMemReq.memoryTypeBits != 0)
+
+VmaAllocationCreateInfo allocCreateInfo = {};
+allocCreateInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY;
+
+VmaAllocation alloc;
+res = vmaAllocateMemory(allocator, &finalMemReq, &allocCreateInfo, &alloc, nullptr);
+
+res = vmaBindImageMemory(allocator, alloc, img1);
+res = vmaBindImageMemory(allocator, alloc, img2);
+
+// You can use img1, img2 here, but not at the same time!
+
+vmaFreeMemory(allocator, alloc);
+vkDestroyImage(allocator, img2, nullptr);
+vkDestroyImage(allocator, img1, nullptr);
+\endcode
+
+Remember that using resouces that alias in memory requires proper synchronization.
+You need to issue a memory barrier to make sure commands that use `img1` and `img2`
+don't overlap on GPU timeline.
+You also need to treat a resource after aliasing as uninitialized - containing garbage data.
+For example, if you use `img1` and then want to use `img2`, you need to issue
+an image memory barrier for `img2` with `oldLayout` = `VK_IMAGE_LAYOUT_UNDEFINED`.
+
+Additional considerations:
+
+- Vulkan also allows to interpret contents of memory between aliasing resources consistently in some cases.
+See chapter 11.8. "Memory Aliasing" of Vulkan specification or `VK_IMAGE_CREATE_ALIAS_BIT` flag.
+- You can create more complex layout where different images and buffers are bound
+at different offsets inside one large allocation. For example, one can imagine
+a big texture used in some render passes, aliasing with a set of many small buffers
+used between in some further passes. To bind a resource at non-zero offset of an allocation,
+use vmaBindBufferMemory2() / vmaBindImageMemory2().
+- Before allocating memory for the resources you want to alias, check `memoryTypeBits`
+returned in memory requirements of each resource to make sure the bits overlap.
+Some GPUs may expose multiple memory types suitable e.g. only for buffers or
+images with `COLOR_ATTACHMENT` usage, so the sets of memory types supported by your
+resources may be disjoint. Aliasing them is not possible in that case.
+
+
+\page custom_memory_pools Custom memory pools
+
+A memory pool contains a number of `VkDeviceMemory` blocks.
+The library automatically creates and manages default pool for each memory type available on the device.
+Default memory pool automatically grows in size.
+Size of allocated blocks is also variable and managed automatically.
+
+You can create custom pool and allocate memory out of it.
+It can be useful if you want to:
+
+- Keep certain kind of allocations separate from others.
+- Enforce particular, fixed size of Vulkan memory blocks.
+- Limit maximum amount of Vulkan memory allocated for that pool.
+- Reserve minimum or fixed amount of Vulkan memory always preallocated for that pool.
+
+To use custom memory pools:
+
+-# Fill VmaPoolCreateInfo structure.
+-# Call vmaCreatePool() to obtain #VmaPool handle.
+-# When making an allocation, set VmaAllocationCreateInfo::pool to this handle.
+   You don't need to specify any other parameters of this structure, like `usage`.
+
+Example:
+
+\code
+// Create a pool that can have at most 2 blocks, 128 MiB each.
+VmaPoolCreateInfo poolCreateInfo = {};
+poolCreateInfo.memoryTypeIndex = ...
+poolCreateInfo.blockSize = 128ull * 1024 * 1024;
+poolCreateInfo.maxBlockCount = 2;
+
+VmaPool pool;
+vmaCreatePool(allocator, &poolCreateInfo, &pool);
+
+// Allocate a buffer out of it.
+VkBufferCreateInfo bufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
+bufCreateInfo.size = 1024;
+bufCreateInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+
+VmaAllocationCreateInfo allocCreateInfo = {};
+allocCreateInfo.pool = pool;
+
+VkBuffer buf;
+VmaAllocation alloc;
+VmaAllocationInfo allocInfo;
+vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &buf, &alloc, &allocInfo);
+\endcode
+
+You have to free all allocations made from this pool before destroying it.
+
+\code
+vmaDestroyBuffer(allocator, buf, alloc);
+vmaDestroyPool(allocator, pool);
+\endcode
+
+\section custom_memory_pools_MemTypeIndex Choosing memory type index
+
+When creating a pool, you must explicitly specify memory type index.
+To find the one suitable for your buffers or images, you can use helper functions
+vmaFindMemoryTypeIndexForBufferInfo(), vmaFindMemoryTypeIndexForImageInfo().
+You need to provide structures with example parameters of buffers or images
+that you are going to create in that pool.
+
+\code
+VkBufferCreateInfo exampleBufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
+exampleBufCreateInfo.size = 1024; // Whatever.
+exampleBufCreateInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT; // Change if needed.
+
+VmaAllocationCreateInfo allocCreateInfo = {};
+allocCreateInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY; // Change if needed.
+
+uint32_t memTypeIndex;
+vmaFindMemoryTypeIndexForBufferInfo(allocator, &exampleBufCreateInfo, &allocCreateInfo, &memTypeIndex);
+
+VmaPoolCreateInfo poolCreateInfo = {};
+poolCreateInfo.memoryTypeIndex = memTypeIndex;
+// ...
+\endcode
+
+When creating buffers/images allocated in that pool, provide following parameters:
+
+- `VkBufferCreateInfo`: Prefer to pass same parameters as above.
+  Otherwise you risk creating resources in a memory type that is not suitable for them, which may result in undefined behavior.
+  Using different `VK_BUFFER_USAGE_` flags may work, but you shouldn't create images in a pool intended for buffers
+  or the other way around.
+- VmaAllocationCreateInfo: You don't need to pass same parameters. Fill only `pool` member.
+  Other members are ignored anyway.
+
+\section linear_algorithm Linear allocation algorithm
+
+Each Vulkan memory block managed by this library has accompanying metadata that
+keeps track of used and unused regions. By default, the metadata structure and
+algorithm tries to find best place for new allocations among free regions to
+optimize memory usage. This way you can allocate and free objects in any order.
+
+![Default allocation algorithm](../gfx/Linear_allocator_1_algo_default.png)
+
+Sometimes there is a need to use simpler, linear allocation algorithm. You can
+create custom pool that uses such algorithm by adding flag
+#VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT to VmaPoolCreateInfo::flags while creating
+#VmaPool object. Then an alternative metadata management is used. It always
+creates new allocations after last one and doesn't reuse free regions after
+allocations freed in the middle. It results in better allocation performance and
+less memory consumed by metadata.
+
+![Linear allocation algorithm](../gfx/Linear_allocator_2_algo_linear.png)
+
+With this one flag, you can create a custom pool that can be used in many ways:
+free-at-once, stack, double stack, and ring buffer. See below for details.
+
+\subsection linear_algorithm_free_at_once Free-at-once
+
+In a pool that uses linear algorithm, you still need to free all the allocations
+individually, e.g. by using vmaFreeMemory() or vmaDestroyBuffer(). You can free
+them in any order. New allocations are always made after last one - free space
+in the middle is not reused. However, when you release all the allocation and
+the pool becomes empty, allocation starts from the beginning again. This way you
+can use linear algorithm to speed up creation of allocations that you are going
+to release all at once.
+
+![Free-at-once](../gfx/Linear_allocator_3_free_at_once.png)
+
+This mode is also available for pools created with VmaPoolCreateInfo::maxBlockCount
+value that allows multiple memory blocks.
+
+\subsection linear_algorithm_stack Stack
+
+When you free an allocation that was created last, its space can be reused.
+Thanks to this, if you always release allocations in the order opposite to their
+creation (LIFO - Last In First Out), you can achieve behavior of a stack.
+
+![Stack](../gfx/Linear_allocator_4_stack.png)
+
+This mode is also available for pools created with VmaPoolCreateInfo::maxBlockCount
+value that allows multiple memory blocks.
+
+\subsection linear_algorithm_double_stack Double stack
+
+The space reserved by a custom pool with linear algorithm may be used by two
+stacks:
+
+- First, default one, growing up from offset 0.
+- Second, "upper" one, growing down from the end towards lower offsets.
+
+To make allocation from upper stack, add flag #VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT
+to VmaAllocationCreateInfo::flags.
+
+![Double stack](../gfx/Linear_allocator_7_double_stack.png)
+
+Double stack is available only in pools with one memory block -
+VmaPoolCreateInfo::maxBlockCount must be 1. Otherwise behavior is undefined.
+
+When the two stacks' ends meet so there is not enough space between them for a
+new allocation, such allocation fails with usual
+`VK_ERROR_OUT_OF_DEVICE_MEMORY` error.
+
+\subsection linear_algorithm_ring_buffer Ring buffer
+
+When you free some allocations from the beginning and there is not enough free space
+for a new one at the end of a pool, allocator's "cursor" wraps around to the
+beginning and starts allocation there. Thanks to this, if you always release
+allocations in the same order as you created them (FIFO - First In First Out),
+you can achieve behavior of a ring buffer / queue.
+
+![Ring buffer](../gfx/Linear_allocator_5_ring_buffer.png)
+
+Pools with linear algorithm support [lost allocations](@ref lost_allocations) when used as ring buffer.
+If there is not enough free space for a new allocation, but existing allocations
+from the front of the queue can become lost, they become lost and the allocation
+succeeds.
+
+![Ring buffer with lost allocations](../gfx/Linear_allocator_6_ring_buffer_lost.png)
+
+Ring buffer is available only in pools with one memory block -
+VmaPoolCreateInfo::maxBlockCount must be 1. Otherwise behavior is undefined.
+
+\section buddy_algorithm Buddy allocation algorithm
+
+There is another allocation algorithm that can be used with custom pools, called
+"buddy". Its internal data structure is based on a tree of blocks, each having
+size that is a power of two and a half of its parent's size. When you want to
+allocate memory of certain size, a free node in the tree is located. If it's too
+large, it is recursively split into two halves (called "buddies"). However, if
+requested allocation size is not a power of two, the size of a tree node is
+aligned up to the nearest power of two and the remaining space is wasted. When
+two buddy nodes become free, they are merged back into one larger node.
+
+![Buddy allocator](../gfx/Buddy_allocator.png)
+
+The advantage of buddy allocation algorithm over default algorithm is faster
+allocation and deallocation, as well as smaller external fragmentation. The
+disadvantage is more wasted space (internal fragmentation).
+
+For more information, please read ["Buddy memory allocation" on Wikipedia](https://en.wikipedia.org/wiki/Buddy_memory_allocation)
+or other sources that describe this concept in general.
+
+To use buddy allocation algorithm with a custom pool, add flag
+#VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT to VmaPoolCreateInfo::flags while creating
+#VmaPool object.
+
+Several limitations apply to pools that use buddy algorithm:
+
+- It is recommended to use VmaPoolCreateInfo::blockSize that is a power of two.
+  Otherwise, only largest power of two smaller than the size is used for
+  allocations. The remaining space always stays unused.
+- [Margins](@ref debugging_memory_usage_margins) and
+  [corruption detection](@ref debugging_memory_usage_corruption_detection)
+  don't work in such pools.
+- [Lost allocations](@ref lost_allocations) don't work in such pools. You can
+  use them, but they never become lost. Support may be added in the future.
+- [Defragmentation](@ref defragmentation) doesn't work with allocations made from
+  such pool.
+
+\page defragmentation Defragmentation
+
+Interleaved allocations and deallocations of many objects of varying size can
+cause fragmentation over time, which can lead to a situation where the library is unable
+to find a continuous range of free memory for a new allocation despite there is
+enough free space, just scattered across many small free ranges between existing
+allocations.
+
+To mitigate this problem, you can use defragmentation feature:
+structure #VmaDefragmentationInfo2, function vmaDefragmentationBegin(), vmaDefragmentationEnd().
+Given set of allocations,
+this function can move them to compact used memory, ensure more continuous free
+space and possibly also free some `VkDeviceMemory` blocks.
+
+What the defragmentation does is:
+
+- Updates #VmaAllocation objects to point to new `VkDeviceMemory` and offset.
+  After allocation has been moved, its VmaAllocationInfo::deviceMemory and/or
+  VmaAllocationInfo::offset changes. You must query them again using
+  vmaGetAllocationInfo() if you need them.
+- Moves actual data in memory.
+
+What it doesn't do, so you need to do it yourself:
+
+- Recreate buffers and images that were bound to allocations that were defragmented and
+  bind them with their new places in memory.
+  You must use `vkDestroyBuffer()`, `vkDestroyImage()`,
+  `vkCreateBuffer()`, `vkCreateImage()`, vmaBindBufferMemory(), vmaBindImageMemory()
+  for that purpose and NOT vmaDestroyBuffer(),
+  vmaDestroyImage(), vmaCreateBuffer(), vmaCreateImage(), because you don't need to
+  destroy or create allocation objects!
+- Recreate views and update descriptors that point to these buffers and images.
+
+\section defragmentation_cpu Defragmenting CPU memory
+
+Following example demonstrates how you can run defragmentation on CPU.
+Only allocations created in memory types that are `HOST_VISIBLE` can be defragmented.
+Others are ignored.
+
+The way it works is:
+
+- It temporarily maps entire memory blocks when necessary.
+- It moves data using `memmove()` function.
+
+\code
+// Given following variables already initialized:
+VkDevice device;
+VmaAllocator allocator;
+std::vector<VkBuffer> buffers;
+std::vector<VmaAllocation> allocations;
+
+
+const uint32_t allocCount = (uint32_t)allocations.size();
+std::vector<VkBool32> allocationsChanged(allocCount);
+
+VmaDefragmentationInfo2 defragInfo = {};
+defragInfo.allocationCount = allocCount;
+defragInfo.pAllocations = allocations.data();
+defragInfo.pAllocationsChanged = allocationsChanged.data();
+defragInfo.maxCpuBytesToMove = VK_WHOLE_SIZE; // No limit.
+defragInfo.maxCpuAllocationsToMove = UINT32_MAX; // No limit.
+
+VmaDefragmentationContext defragCtx;
+vmaDefragmentationBegin(allocator, &defragInfo, nullptr, &defragCtx);
+vmaDefragmentationEnd(allocator, defragCtx);
+
+for(uint32_t i = 0; i < allocCount; ++i)
+{
+    if(allocationsChanged[i])
+    {
+        // Destroy buffer that is immutably bound to memory region which is no longer valid.
+        vkDestroyBuffer(device, buffers[i], nullptr);
+
+        // Create new buffer with same parameters.
+        VkBufferCreateInfo bufferInfo = ...;
+        vkCreateBuffer(device, &bufferInfo, nullptr, &buffers[i]);
+
+        // You can make dummy call to vkGetBufferMemoryRequirements here to silence validation layer warning.
+
+        // Bind new buffer to new memory region. Data contained in it is already moved.
+        VmaAllocationInfo allocInfo;
+        vmaGetAllocationInfo(allocator, allocations[i], &allocInfo);
+        vmaBindBufferMemory(allocator, allocations[i], buffers[i]);
+    }
+}
+\endcode
+
+Setting VmaDefragmentationInfo2::pAllocationsChanged is optional.
+This output array tells whether particular allocation in VmaDefragmentationInfo2::pAllocations at the same index
+has been modified during defragmentation.
+You can pass null, but you then need to query every allocation passed to defragmentation
+for new parameters using vmaGetAllocationInfo() if you might need to recreate and rebind a buffer or image associated with it.
+
+If you use [Custom memory pools](@ref choosing_memory_type_custom_memory_pools),
+you can fill VmaDefragmentationInfo2::poolCount and VmaDefragmentationInfo2::pPools
+instead of VmaDefragmentationInfo2::allocationCount and VmaDefragmentationInfo2::pAllocations
+to defragment all allocations in given pools.
+You cannot use VmaDefragmentationInfo2::pAllocationsChanged in that case.
+You can also combine both methods.
+
+\section defragmentation_gpu Defragmenting GPU memory
+
+It is also possible to defragment allocations created in memory types that are not `HOST_VISIBLE`.
+To do that, you need to pass a command buffer that meets requirements as described in
+VmaDefragmentationInfo2::commandBuffer. The way it works is:
+
+- It creates temporary buffers and binds them to entire memory blocks when necessary.
+- It issues `vkCmdCopyBuffer()` to passed command buffer.
+
+Example:
+
+\code
+// Given following variables already initialized:
+VkDevice device;
+VmaAllocator allocator;
+VkCommandBuffer commandBuffer;
+std::vector<VkBuffer> buffers;
+std::vector<VmaAllocation> allocations;
+
+
+const uint32_t allocCount = (uint32_t)allocations.size();
+std::vector<VkBool32> allocationsChanged(allocCount);
+
+VkCommandBufferBeginInfo cmdBufBeginInfo = ...;
+vkBeginCommandBuffer(commandBuffer, &cmdBufBeginInfo);
+
+VmaDefragmentationInfo2 defragInfo = {};
+defragInfo.allocationCount = allocCount;
+defragInfo.pAllocations = allocations.data();
+defragInfo.pAllocationsChanged = allocationsChanged.data();
+defragInfo.maxGpuBytesToMove = VK_WHOLE_SIZE; // Notice it's "GPU" this time.
+defragInfo.maxGpuAllocationsToMove = UINT32_MAX; // Notice it's "GPU" this time.
+defragInfo.commandBuffer = commandBuffer;
+
+VmaDefragmentationContext defragCtx;
+vmaDefragmentationBegin(allocator, &defragInfo, nullptr, &defragCtx);
+
+vkEndCommandBuffer(commandBuffer);
+
+// Submit commandBuffer.
+// Wait for a fence that ensures commandBuffer execution finished.
+
+vmaDefragmentationEnd(allocator, defragCtx);
+
+for(uint32_t i = 0; i < allocCount; ++i)
+{
+    if(allocationsChanged[i])
+    {
+        // Destroy buffer that is immutably bound to memory region which is no longer valid.
+        vkDestroyBuffer(device, buffers[i], nullptr);
+
+        // Create new buffer with same parameters.
+        VkBufferCreateInfo bufferInfo = ...;
+        vkCreateBuffer(device, &bufferInfo, nullptr, &buffers[i]);
+
+        // You can make dummy call to vkGetBufferMemoryRequirements here to silence validation layer warning.
+
+        // Bind new buffer to new memory region. Data contained in it is already moved.
+        VmaAllocationInfo allocInfo;
+        vmaGetAllocationInfo(allocator, allocations[i], &allocInfo);
+        vmaBindBufferMemory(allocator, allocations[i], buffers[i]);
+    }
+}
+\endcode
+
+You can combine these two methods by specifying non-zero `maxGpu*` as well as `maxCpu*` parameters.
+The library automatically chooses best method to defragment each memory pool.
+
+You may try not to block your entire program to wait until defragmentation finishes,
+but do it in the background, as long as you carefully fullfill requirements described
+in function vmaDefragmentationBegin().
+
+\section defragmentation_additional_notes Additional notes
+
+It is only legal to defragment allocations bound to:
+
+- buffers
+- images created with `VK_IMAGE_CREATE_ALIAS_BIT`, `VK_IMAGE_TILING_LINEAR`, and
+  being currently in `VK_IMAGE_LAYOUT_GENERAL` or `VK_IMAGE_LAYOUT_PREINITIALIZED`.
+
+Defragmentation of images created with `VK_IMAGE_TILING_OPTIMAL` or in any other
+layout may give undefined results.
+
+If you defragment allocations bound to images, new images to be bound to new
+memory region after defragmentation should be created with `VK_IMAGE_LAYOUT_PREINITIALIZED`
+and then transitioned to their original layout from before defragmentation if
+needed using an image memory barrier.
+
+While using defragmentation, you may experience validation layer warnings, which you just need to ignore.
+See [Validation layer warnings](@ref general_considerations_validation_layer_warnings).
+
+Please don't expect memory to be fully compacted after defragmentation.
+Algorithms inside are based on some heuristics that try to maximize number of Vulkan
+memory blocks to make totally empty to release them, as well as to maximimze continuous
+empty space inside remaining blocks, while minimizing the number and size of allocations that
+need to be moved. Some fragmentation may still remain - this is normal.
+
+\section defragmentation_custom_algorithm Writing custom defragmentation algorithm
+
+If you want to implement your own, custom defragmentation algorithm,
+there is infrastructure prepared for that,
+but it is not exposed through the library API - you need to hack its source code.
+Here are steps needed to do this:
+
+-# Main thing you need to do is to define your own class derived from base abstract
+   class `VmaDefragmentationAlgorithm` and implement your version of its pure virtual methods.
+   See definition and comments of this class for details.
+-# Your code needs to interact with device memory block metadata.
+   If you need more access to its data than it's provided by its public interface,
+   declare your new class as a friend class e.g. in class `VmaBlockMetadata_Generic`.
+-# If you want to create a flag that would enable your algorithm or pass some additional
+   flags to configure it, add them to `VmaDefragmentationFlagBits` and use them in
+   VmaDefragmentationInfo2::flags.
+-# Modify function `VmaBlockVectorDefragmentationContext::Begin` to create object
+   of your new class whenever needed.
+
+
+\page lost_allocations Lost allocations
+
+If your game oversubscribes video memory, if may work OK in previous-generation
+graphics APIs (DirectX 9, 10, 11, OpenGL) because resources are automatically
+paged to system RAM. In Vulkan you can't do it because when you run out of
+memory, an allocation just fails. If you have more data (e.g. textures) that can
+fit into VRAM and you don't need it all at once, you may want to upload them to
+GPU on demand and "push out" ones that are not used for a long time to make room
+for the new ones, effectively using VRAM (or a cartain memory pool) as a form of
+cache. Vulkan Memory Allocator can help you with that by supporting a concept of
+"lost allocations".
+
+To create an allocation that can become lost, include #VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT
+flag in VmaAllocationCreateInfo::flags. Before using a buffer or image bound to
+such allocation in every new frame, you need to query it if it's not lost.
+To check it, call vmaTouchAllocation().
+If the allocation is lost, you should not use it or buffer/image bound to it.
+You mustn't forget to destroy this allocation and this buffer/image.
+vmaGetAllocationInfo() can also be used for checking status of the allocation.
+Allocation is lost when returned VmaAllocationInfo::deviceMemory == `VK_NULL_HANDLE`.
+
+To create an allocation that can make some other allocations lost to make room
+for it, use #VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT flag. You will
+usually use both flags #VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT and
+#VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT at the same time.
+
+Warning! Current implementation uses quite naive, brute force algorithm,
+which can make allocation calls that use #VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT
+flag quite slow. A new, more optimal algorithm and data structure to speed this
+up is planned for the future.
+
+<b>Q: When interleaving creation of new allocations with usage of existing ones,
+how do you make sure that an allocation won't become lost while it's used in the
+current frame?</b>
+
+It is ensured because vmaTouchAllocation() / vmaGetAllocationInfo() not only returns allocation
+status/parameters and checks whether it's not lost, but when it's not, it also
+atomically marks it as used in the current frame, which makes it impossible to
+become lost in that frame. It uses lockless algorithm, so it works fast and
+doesn't involve locking any internal mutex.
+
+<b>Q: What if my allocation may still be in use by the GPU when it's rendering a
+previous frame while I already submit new frame on the CPU?</b>
+
+You can make sure that allocations "touched" by vmaTouchAllocation() / vmaGetAllocationInfo() will not
+become lost for a number of additional frames back from the current one by
+specifying this number as VmaAllocatorCreateInfo::frameInUseCount (for default
+memory pool) and VmaPoolCreateInfo::frameInUseCount (for custom pool).
+
+<b>Q: How do you inform the library when new frame starts?</b>
+
+You need to call function vmaSetCurrentFrameIndex().
+
+Example code:
+
+\code
+struct MyBuffer
+{
+    VkBuffer m_Buf = nullptr;
+    VmaAllocation m_Alloc = nullptr;
+
+    // Called when the buffer is really needed in the current frame.
+    void EnsureBuffer();
+};
+
+void MyBuffer::EnsureBuffer()
+{
+    // Buffer has been created.
+    if(m_Buf != VK_NULL_HANDLE)
+    {
+        // Check if its allocation is not lost + mark it as used in current frame.
+        if(vmaTouchAllocation(allocator, m_Alloc))
+        {
+            // It's all OK - safe to use m_Buf.
+            return;
+        }
+    }
+
+    // Buffer not yet exists or lost - destroy and recreate it.
+
+    vmaDestroyBuffer(allocator, m_Buf, m_Alloc);
+
+    VkBufferCreateInfo bufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
+    bufCreateInfo.size = 1024;
+    bufCreateInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+
+    VmaAllocationCreateInfo allocCreateInfo = {};
+    allocCreateInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY;
+    allocCreateInfo.flags = VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT |
+        VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT;
+
+    vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &m_Buf, &m_Alloc, nullptr);
+}
+\endcode
+
+When using lost allocations, you may see some Vulkan validation layer warnings
+about overlapping regions of memory bound to different kinds of buffers and
+images. This is still valid as long as you implement proper handling of lost
+allocations (like in the example above) and don't use them.
+
+You can create an allocation that is already in lost state from the beginning using function
+vmaCreateLostAllocation(). It may be useful if you need a "dummy" allocation that is not null.
+
+You can call function vmaMakePoolAllocationsLost() to set all eligible allocations
+in a specified custom pool to lost state.
+Allocations that have been "touched" in current frame or VmaPoolCreateInfo::frameInUseCount frames back
+cannot become lost.
+
+<b>Q: Can I touch allocation that cannot become lost?</b>
+
+Yes, although it has no visible effect.
+Calls to vmaGetAllocationInfo() and vmaTouchAllocation() update last use frame index
+also for allocations that cannot become lost, but the only way to observe it is to dump
+internal allocator state using vmaBuildStatsString().
+You can use this feature for debugging purposes to explicitly mark allocations that you use
+in current frame and then analyze JSON dump to see for how long each allocation stays unused.
+
+
+\page statistics Statistics
+
+This library contains functions that return information about its internal state,
+especially the amount of memory allocated from Vulkan.
+Please keep in mind that these functions need to traverse all internal data structures
+to gather these information, so they may be quite time-consuming.
+Don't call them too often.
+
+\section statistics_numeric_statistics Numeric statistics
+
+You can query for overall statistics of the allocator using function vmaCalculateStats().
+Information are returned using structure #VmaStats.
+It contains #VmaStatInfo - number of allocated blocks, number of allocations
+(occupied ranges in these blocks), number of unused (free) ranges in these blocks,
+number of bytes used and unused (but still allocated from Vulkan) and other information.
+They are summed across memory heaps, memory types and total for whole allocator.
+
+You can query for statistics of a custom pool using function vmaGetPoolStats().
+Information are returned using structure #VmaPoolStats.
+
+You can query for information about specific allocation using function vmaGetAllocationInfo().
+It fill structure #VmaAllocationInfo.
+
+\section statistics_json_dump JSON dump
+
+You can dump internal state of the allocator to a string in JSON format using function vmaBuildStatsString().
+The result is guaranteed to be correct JSON.
+It uses ANSI encoding.
+Any strings provided by user (see [Allocation names](@ref allocation_names))
+are copied as-is and properly escaped for JSON, so if they use UTF-8, ISO-8859-2 or any other encoding,
+this JSON string can be treated as using this encoding.
+It must be freed using function vmaFreeStatsString().
+
+The format of this JSON string is not part of official documentation of the library,
+but it will not change in backward-incompatible way without increasing library major version number
+and appropriate mention in changelog.
+
+The JSON string contains all the data that can be obtained using vmaCalculateStats().
+It can also contain detailed map of allocated memory blocks and their regions -
+free and occupied by allocations.
+This allows e.g. to visualize the memory or assess fragmentation.
+
+
+\page allocation_annotation Allocation names and user data
+
+\section allocation_user_data Allocation user data
+
+You can annotate allocations with your own information, e.g. for debugging purposes.
+To do that, fill VmaAllocationCreateInfo::pUserData field when creating
+an allocation. It's an opaque `void*` pointer. You can use it e.g. as a pointer,
+some handle, index, key, ordinal number or any other value that would associate
+the allocation with your custom metadata.
+
+\code
+VkBufferCreateInfo bufferInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
+// Fill bufferInfo...
+
+MyBufferMetadata* pMetadata = CreateBufferMetadata();
+
+VmaAllocationCreateInfo allocCreateInfo = {};
+allocCreateInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY;
+allocCreateInfo.pUserData = pMetadata;
+
+VkBuffer buffer;
+VmaAllocation allocation;
+vmaCreateBuffer(allocator, &bufferInfo, &allocCreateInfo, &buffer, &allocation, nullptr);
+\endcode
+
+The pointer may be later retrieved as VmaAllocationInfo::pUserData:
+
+\code
+VmaAllocationInfo allocInfo;
+vmaGetAllocationInfo(allocator, allocation, &allocInfo);
+MyBufferMetadata* pMetadata = (MyBufferMetadata*)allocInfo.pUserData;
+\endcode
+
+It can also be changed using function vmaSetAllocationUserData().
+
+Values of (non-zero) allocations' `pUserData` are printed in JSON report created by
+vmaBuildStatsString(), in hexadecimal form.
+
+\section allocation_names Allocation names
+
+There is alternative mode available where `pUserData` pointer is used to point to
+a null-terminated string, giving a name to the allocation. To use this mode,
+set #VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT flag in VmaAllocationCreateInfo::flags.
+Then `pUserData` passed as VmaAllocationCreateInfo::pUserData or argument to
+vmaSetAllocationUserData() must be either null or pointer to a null-terminated string.
+The library creates internal copy of the string, so the pointer you pass doesn't need
+to be valid for whole lifetime of the allocation. You can free it after the call.
+
+\code
+VkImageCreateInfo imageInfo = { VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
+// Fill imageInfo...
+
+std::string imageName = "Texture: ";
+imageName += fileName;
+
+VmaAllocationCreateInfo allocCreateInfo = {};
+allocCreateInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY;
+allocCreateInfo.flags = VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT;
+allocCreateInfo.pUserData = imageName.c_str();
+
+VkImage image;
+VmaAllocation allocation;
+vmaCreateImage(allocator, &imageInfo, &allocCreateInfo, &image, &allocation, nullptr);
+\endcode
+
+The value of `pUserData` pointer of the allocation will be different than the one
+you passed when setting allocation's name - pointing to a buffer managed
+internally that holds copy of the string.
+
+\code
+VmaAllocationInfo allocInfo;
+vmaGetAllocationInfo(allocator, allocation, &allocInfo);
+const char* imageName = (const char*)allocInfo.pUserData;
+printf("Image name: %s\n", imageName);
+\endcode
+
+That string is also printed in JSON report created by vmaBuildStatsString().
+
+\note Passing string name to VMA allocation doesn't automatically set it to the Vulkan buffer or image created with it.
+You must do it manually using an extension like VK_EXT_debug_utils, which is independent of this library.
+
+
+\page debugging_memory_usage Debugging incorrect memory usage
+
+If you suspect a bug with memory usage, like usage of uninitialized memory or
+memory being overwritten out of bounds of an allocation,
+you can use debug features of this library to verify this.
+
+\section debugging_memory_usage_initialization Memory initialization
+
+If you experience a bug with incorrect and nondeterministic data in your program and you suspect uninitialized memory to be used,
+you can enable automatic memory initialization to verify this.
+To do it, define macro `VMA_DEBUG_INITIALIZE_ALLOCATIONS` to 1.
+
+\code
+#define VMA_DEBUG_INITIALIZE_ALLOCATIONS 1
+#include "vk_mem_alloc.h"
+\endcode
+
+It makes memory of all new allocations initialized to bit pattern `0xDCDCDCDC`.
+Before an allocation is destroyed, its memory is filled with bit pattern `0xEFEFEFEF`.
+Memory is automatically mapped and unmapped if necessary.
+
+If you find these values while debugging your program, good chances are that you incorrectly
+read Vulkan memory that is allocated but not initialized, or already freed, respectively.
+
+Memory initialization works only with memory types that are `HOST_VISIBLE`.
+It works also with dedicated allocations.
+It doesn't work with allocations created with #VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT flag,
+as they cannot be mapped.
+
+\section debugging_memory_usage_margins Margins
+
+By default, allocations are laid out in memory blocks next to each other if possible
+(considering required alignment, `bufferImageGranularity`, and `nonCoherentAtomSize`).
+
+![Allocations without margin](../gfx/Margins_1.png)
+
+Define macro `VMA_DEBUG_MARGIN` to some non-zero value (e.g. 16) to enforce specified
+number of bytes as a margin before and after every allocation.
+
+\code
+#define VMA_DEBUG_MARGIN 16
+#include "vk_mem_alloc.h"
+\endcode
+
+![Allocations with margin](../gfx/Margins_2.png)
+
+If your bug goes away after enabling margins, it means it may be caused by memory
+being overwritten outside of allocation boundaries. It is not 100% certain though.
+Change in application behavior may also be caused by different order and distribution
+of allocations across memory blocks after margins are applied.
+
+The margin is applied also before first and after last allocation in a block.
+It may occur only once between two adjacent allocations.
+
+Margins work with all types of memory.
+
+Margin is applied only to allocations made out of memory blocks and not to dedicated
+allocations, which have their own memory block of specific size.
+It is thus not applied to allocations made using #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT flag
+or those automatically decided to put into dedicated allocations, e.g. due to its
+large size or recommended by VK_KHR_dedicated_allocation extension.
+Margins are also not active in custom pools created with #VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT flag.
+
+Margins appear in [JSON dump](@ref statistics_json_dump) as part of free space.
+
+Note that enabling margins increases memory usage and fragmentation.
+
+\section debugging_memory_usage_corruption_detection Corruption detection
+
+You can additionally define macro `VMA_DEBUG_DETECT_CORRUPTION` to 1 to enable validation
+of contents of the margins.
+
+\code
+#define VMA_DEBUG_MARGIN 16
+#define VMA_DEBUG_DETECT_CORRUPTION 1
+#include "vk_mem_alloc.h"
+\endcode
+
+When this feature is enabled, number of bytes specified as `VMA_DEBUG_MARGIN`
+(it must be multiply of 4) before and after every allocation is filled with a magic number.
+This idea is also know as "canary".
+Memory is automatically mapped and unmapped if necessary.
+
+This number is validated automatically when the allocation is destroyed.
+If it's not equal to the expected value, `VMA_ASSERT()` is executed.
+It clearly means that either CPU or GPU overwritten the memory outside of boundaries of the allocation,
+which indicates a serious bug.
+
+You can also explicitly request checking margins of all allocations in all memory blocks
+that belong to specified memory types by using function vmaCheckCorruption(),
+or in memory blocks that belong to specified custom pool, by using function
+vmaCheckPoolCorruption().
+
+Margin validation (corruption detection) works only for memory types that are
+`HOST_VISIBLE` and `HOST_COHERENT`.
+
+
+\page record_and_replay Record and replay
+
+\section record_and_replay_introduction Introduction
+
+While using the library, sequence of calls to its functions together with their
+parameters can be recorded to a file and later replayed using standalone player
+application. It can be useful to:
+
+- Test correctness - check if same sequence of calls will not cause crash or
+  failures on a target platform.
+- Gather statistics - see number of allocations, peak memory usage, number of
+  calls etc.
+- Benchmark performance - see how much time it takes to replay the whole
+  sequence.
+
+\section record_and_replay_usage Usage
+
+Recording functionality is disabled by default.
+To enable it, define following macro before every include of this library:
+
+\code
+#define VMA_RECORDING_ENABLED 1
+\endcode
+
+<b>To record sequence of calls to a file:</b> Fill in
+VmaAllocatorCreateInfo::pRecordSettings member while creating #VmaAllocator
+object. File is opened and written during whole lifetime of the allocator.
+
+<b>To replay file:</b> Use VmaReplay - standalone command-line program.
+Precompiled binary can be found in "bin" directory.
+Its source can be found in "src/VmaReplay" directory.
+Its project is generated by Premake.
+Command line syntax is printed when the program is launched without parameters.
+Basic usage:
+
+    VmaReplay.exe MyRecording.csv
+
+<b>Documentation of file format</b> can be found in file: "docs/Recording file format.md".
+It's a human-readable, text file in CSV format (Comma Separated Values).
+
+\section record_and_replay_additional_considerations Additional considerations
+
+- Replaying file that was recorded on a different GPU (with different parameters
+  like `bufferImageGranularity`, `nonCoherentAtomSize`, and especially different
+  set of memory heaps and types) may give different performance and memory usage
+  results, as well as issue some warnings and errors.
+- Current implementation of recording in VMA, as well as VmaReplay application, is
+  coded and tested only on Windows. Inclusion of recording code is driven by
+  `VMA_RECORDING_ENABLED` macro. Support for other platforms should be easy to
+  add. Contributions are welcomed.
+
+
+\page usage_patterns Recommended usage patterns
+
+See also slides from talk:
+[Sawicki, Adam. Advanced Graphics Techniques Tutorial: Memory management in Vulkan and DX12. Game Developers Conference, 2018](https://www.gdcvault.com/play/1025458/Advanced-Graphics-Techniques-Tutorial-New)
+
+
+\section usage_patterns_common_mistakes Common mistakes
+
+<b>Use of CPU_TO_GPU instead of CPU_ONLY memory</b>
+
+#VMA_MEMORY_USAGE_CPU_TO_GPU is recommended only for resources that will be
+mapped and written by the CPU, as well as read directly by the GPU - like some
+buffers or textures updated every frame (dynamic). If you create a staging copy
+of a resource to be written by CPU and then used as a source of transfer to
+another resource placed in the GPU memory, that staging resource should be
+created with #VMA_MEMORY_USAGE_CPU_ONLY. Please read the descriptions of these
+enums carefully for details.
+
+<b>Unnecessary use of custom pools</b>
+
+\ref custom_memory_pools may be useful for special purposes - when you want to
+keep certain type of resources separate e.g. to reserve minimum amount of memory
+for them, limit maximum amount of memory they can occupy, or make some of them
+push out the other through the mechanism of \ref lost_allocations. For most
+resources this is not needed and so it is not recommended to create #VmaPool
+objects and allocations out of them. Allocating from the default pool is sufficient.
+
+\section usage_patterns_simple Simple patterns
+
+\subsection usage_patterns_simple_render_targets Render targets
+
+<b>When:</b>
+Any resources that you frequently write and read on GPU,
+e.g. images used as color attachments (aka "render targets"), depth-stencil attachments,
+images/buffers used as storage image/buffer (aka "Unordered Access View (UAV)").
+
+<b>What to do:</b>
+Create them in video memory that is fastest to access from GPU using
+#VMA_MEMORY_USAGE_GPU_ONLY.
+
+Consider using [VK_KHR_dedicated_allocation](@ref vk_khr_dedicated_allocation) extension
+and/or manually creating them as dedicated allocations using #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT,
+especially if they are large or if you plan to destroy and recreate them e.g. when
+display resolution changes.
+Prefer to create such resources first and all other GPU resources (like textures and vertex buffers) later.
+
+\subsection usage_patterns_simple_immutable_resources Immutable resources
+
+<b>When:</b>
+Any resources that you fill on CPU only once (aka "immutable") or infrequently
+and then read frequently on GPU,
+e.g. textures, vertex and index buffers, constant buffers that don't change often.
+
+<b>What to do:</b>
+Create them in video memory that is fastest to access from GPU using
+#VMA_MEMORY_USAGE_GPU_ONLY.
+
+To initialize content of such resource, create a CPU-side (aka "staging") copy of it
+in system memory - #VMA_MEMORY_USAGE_CPU_ONLY, map it, fill it,
+and submit a transfer from it to the GPU resource.
+You can keep the staging copy if you need it for another upload transfer in the future.
+If you don't, you can destroy it or reuse this buffer for uploading different resource
+after the transfer finishes.
+
+Prefer to create just buffers in system memory rather than images, even for uploading textures.
+Use `vkCmdCopyBufferToImage()`.
+Dont use images with `VK_IMAGE_TILING_LINEAR`.
+
+\subsection usage_patterns_dynamic_resources Dynamic resources
+
+<b>When:</b>
+Any resources that change frequently (aka "dynamic"), e.g. every frame or every draw call,
+written on CPU, read on GPU.
+
+<b>What to do:</b>
+Create them using #VMA_MEMORY_USAGE_CPU_TO_GPU.
+You can map it and write to it directly on CPU, as well as read from it on GPU.
+
+This is a more complex situation. Different solutions are possible,
+and the best one depends on specific GPU type, but you can use this simple approach for the start.
+Prefer to write to such resource sequentially (e.g. using `memcpy`).
+Don't perform random access or any reads from it on CPU, as it may be very slow.
+Also note that textures written directly from the host through a mapped pointer need to be in LINEAR not OPTIMAL layout.
+
+\subsection usage_patterns_readback Readback
+
+<b>When:</b>
+Resources that contain data written by GPU that you want to read back on CPU,
+e.g. results of some computations.
+
+<b>What to do:</b>
+Create them using #VMA_MEMORY_USAGE_GPU_TO_CPU.
+You can write to them directly on GPU, as well as map and read them on CPU.
+
+\section usage_patterns_advanced Advanced patterns
+
+\subsection usage_patterns_integrated_graphics Detecting integrated graphics
+
+You can support integrated graphics (like Intel HD Graphics, AMD APU) better
+by detecting it in Vulkan.
+To do it, call `vkGetPhysicalDeviceProperties()`, inspect
+`VkPhysicalDeviceProperties::deviceType` and look for `VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU`.
+When you find it, you can assume that memory is unified and all memory types are comparably fast
+to access from GPU, regardless of `VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT`.
+
+You can then sum up sizes of all available memory heaps and treat them as useful for
+your GPU resources, instead of only `DEVICE_LOCAL` ones.
+You can also prefer to create your resources in memory types that are `HOST_VISIBLE` to map them
+directly instead of submitting explicit transfer (see below).
+
+\subsection usage_patterns_direct_vs_transfer Direct access versus transfer
+
+For resources that you frequently write on CPU and read on GPU, many solutions are possible:
+
+-# Create one copy in video memory using #VMA_MEMORY_USAGE_GPU_ONLY,
+   second copy in system memory using #VMA_MEMORY_USAGE_CPU_ONLY and submit explicit transfer each time.
+-# Create just a single copy using #VMA_MEMORY_USAGE_CPU_TO_GPU, map it and fill it on CPU,
+   read it directly on GPU.
+-# Create just a single copy using #VMA_MEMORY_USAGE_CPU_ONLY, map it and fill it on CPU,
+   read it directly on GPU.
+
+Which solution is the most efficient depends on your resource and especially on the GPU.
+It is best to measure it and then make the decision.
+Some general recommendations:
+
+- On integrated graphics use (2) or (3) to avoid unnecesary time and memory overhead
+  related to using a second copy and making transfer.
+- For small resources (e.g. constant buffers) use (2).
+  Discrete AMD cards have special 256 MiB pool of video memory that is directly mappable.
+  Even if the resource ends up in system memory, its data may be cached on GPU after first
+  fetch over PCIe bus.
+- For larger resources (e.g. textures), decide between (1) and (2).
+  You may want to differentiate NVIDIA and AMD, e.g. by looking for memory type that is
+  both `DEVICE_LOCAL` and `HOST_VISIBLE`. When you find it, use (2), otherwise use (1).
+
+Similarly, for resources that you frequently write on GPU and read on CPU, multiple
+solutions are possible:
+
+-# Create one copy in video memory using #VMA_MEMORY_USAGE_GPU_ONLY,
+   second copy in system memory using #VMA_MEMORY_USAGE_GPU_TO_CPU and submit explicit tranfer each time.
+-# Create just single copy using #VMA_MEMORY_USAGE_GPU_TO_CPU, write to it directly on GPU,
+   map it and read it on CPU.
+
+You should take some measurements to decide which option is faster in case of your specific
+resource.
+
+Note that textures accessed directly from the host through a mapped pointer need to be in LINEAR layout,
+which may slow down their usage on the device.
+Textures accessed only by the device and transfer operations can use OPTIMAL layout.
+
+If you don't want to specialize your code for specific types of GPUs, you can still make
+an simple optimization for cases when your resource ends up in mappable memory to use it
+directly in this case instead of creating CPU-side staging copy.
+For details see [Finding out if memory is mappable](@ref memory_mapping_finding_if_memory_mappable).
+
+
+\page configuration Configuration
+
+Please check "CONFIGURATION SECTION" in the code to find macros that you can define
+before each include of this file or change directly in this file to provide
+your own implementation of basic facilities like assert, `min()` and `max()` functions,
+mutex, atomic etc.
+The library uses its own implementation of containers by default, but you can switch to using
+STL containers instead.
+
+For example, define `VMA_ASSERT(expr)` before including the library to provide
+custom implementation of the assertion, compatible with your project.
+By default it is defined to standard C `assert(expr)` in `_DEBUG` configuration
+and empty otherwise.
+
+\section config_Vulkan_functions Pointers to Vulkan functions
+
+There are multiple ways to import pointers to Vulkan functions in the library.
+In the simplest case you don't need to do anything.
+If the compilation or linking of your program or the initialization of the #VmaAllocator
+doesn't work for you, you can try to reconfigure it.
+
+First, the allocator tries to fetch pointers to Vulkan functions linked statically,
+like this:
+
+\code
+m_VulkanFunctions.vkAllocateMemory = (PFN_vkAllocateMemory)vkAllocateMemory;
+\endcode
+
+If you want to disable this feature, set configuration macro: `#define VMA_STATIC_VULKAN_FUNCTIONS 0`.
+
+Second, you can provide the pointers yourself by setting member VmaAllocatorCreateInfo::pVulkanFunctions.
+You can fetch them e.g. using functions `vkGetInstanceProcAddr` and `vkGetDeviceProcAddr` or
+by using a helper library like [volk](https://github.com/zeux/volk).
+
+Third, VMA tries to fetch remaining pointers that are still null by calling
+`vkGetInstanceProcAddr` and `vkGetDeviceProcAddr` on its own.
+If you want to disable this feature, set configuration macro: `#define VMA_DYNAMIC_VULKAN_FUNCTIONS 0`.
+
+Finally, all the function pointers required by the library (considering selected
+Vulkan version and enabled extensions) are checked with `VMA_ASSERT` if they are not null.
+
+
+\section custom_memory_allocator Custom host memory allocator
+
+If you use custom allocator for CPU memory rather than default operator `new`
+and `delete` from C++, you can make this library using your allocator as well
+by filling optional member VmaAllocatorCreateInfo::pAllocationCallbacks. These
+functions will be passed to Vulkan, as well as used by the library itself to
+make any CPU-side allocations.
+
+\section allocation_callbacks Device memory allocation callbacks
+
+The library makes calls to `vkAllocateMemory()` and `vkFreeMemory()` internally.
+You can setup callbacks to be informed about these calls, e.g. for the purpose
+of gathering some statistics. To do it, fill optional member
+VmaAllocatorCreateInfo::pDeviceMemoryCallbacks.
+
+\section heap_memory_limit Device heap memory limit
+
+When device memory of certain heap runs out of free space, new allocations may
+fail (returning error code) or they may succeed, silently pushing some existing
+memory blocks from GPU VRAM to system RAM (which degrades performance). This
+behavior is implementation-dependent - it depends on GPU vendor and graphics
+driver.
+
+On AMD cards it can be controlled while creating Vulkan device object by using
+VK_AMD_memory_overallocation_behavior extension, if available.
+
+Alternatively, if you want to test how your program behaves with limited amount of Vulkan device
+memory available without switching your graphics card to one that really has
+smaller VRAM, you can use a feature of this library intended for this purpose.
+To do it, fill optional member VmaAllocatorCreateInfo::pHeapSizeLimit.
+
+
+
+\page vk_khr_dedicated_allocation VK_KHR_dedicated_allocation
+
+VK_KHR_dedicated_allocation is a Vulkan extension which can be used to improve
+performance on some GPUs. It augments Vulkan API with possibility to query
+driver whether it prefers particular buffer or image to have its own, dedicated
+allocation (separate `VkDeviceMemory` block) for better efficiency - to be able
+to do some internal optimizations.
+
+The extension is supported by this library. It will be used automatically when
+enabled. To enable it:
+
+1 . When creating Vulkan device, check if following 2 device extensions are
+supported (call `vkEnumerateDeviceExtensionProperties()`).
+If yes, enable them (fill `VkDeviceCreateInfo::ppEnabledExtensionNames`).
+
+- VK_KHR_get_memory_requirements2
+- VK_KHR_dedicated_allocation
+
+If you enabled these extensions:
+
+2 . Use #VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT flag when creating
+your #VmaAllocator`to inform the library that you enabled required extensions
+and you want the library to use them.
+
+\code
+allocatorInfo.flags |= VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT;
+
+vmaCreateAllocator(&allocatorInfo, &allocator);
+\endcode
+
+That's all. The extension will be automatically used whenever you create a
+buffer using vmaCreateBuffer() or image using vmaCreateImage().
+
+When using the extension together with Vulkan Validation Layer, you will receive
+warnings like this:
+
+    vkBindBufferMemory(): Binding memory to buffer 0x33 but vkGetBufferMemoryRequirements() has not been called on that buffer.
+
+It is OK, you should just ignore it. It happens because you use function
+`vkGetBufferMemoryRequirements2KHR()` instead of standard
+`vkGetBufferMemoryRequirements()`, while the validation layer seems to be
+unaware of it.
+
+To learn more about this extension, see:
+
+- [VK_KHR_dedicated_allocation in Vulkan specification](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/chap44.html#VK_KHR_dedicated_allocation)
+- [VK_KHR_dedicated_allocation unofficial manual](http://asawicki.info/articles/VK_KHR_dedicated_allocation.php5)
+
+
+
+\page vk_amd_device_coherent_memory VK_AMD_device_coherent_memory
+
+VK_AMD_device_coherent_memory is a device extension that enables access to
+additional memory types with `VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD` and
+`VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD` flag. It is useful mostly for
+allocation of buffers intended for writing "breadcrumb markers" in between passes
+or draw calls, which in turn are useful for debugging GPU crash/hang/TDR cases.
+
+When the extension is available but has not been enabled, Vulkan physical device
+still exposes those memory types, but their usage is forbidden. VMA automatically
+takes care of that - it returns `VK_ERROR_FEATURE_NOT_PRESENT` when an attempt
+to allocate memory of such type is made.
+
+If you want to use this extension in connection with VMA, follow these steps:
+
+\section vk_amd_device_coherent_memory_initialization Initialization
+
+1) Call `vkEnumerateDeviceExtensionProperties` for the physical device.
+Check if the extension is supported - if returned array of `VkExtensionProperties` contains "VK_AMD_device_coherent_memory".
+
+2) Call `vkGetPhysicalDeviceFeatures2` for the physical device instead of old `vkGetPhysicalDeviceFeatures`.
+Attach additional structure `VkPhysicalDeviceCoherentMemoryFeaturesAMD` to `VkPhysicalDeviceFeatures2::pNext` to be returned.
+Check if the device feature is really supported - check if `VkPhysicalDeviceCoherentMemoryFeaturesAMD::deviceCoherentMemory` is true.
+
+3) While creating device with `vkCreateDevice`, enable this extension - add "VK_AMD_device_coherent_memory"
+to the list passed as `VkDeviceCreateInfo::ppEnabledExtensionNames`.
+
+4) While creating the device, also don't set `VkDeviceCreateInfo::pEnabledFeatures`.
+Fill in `VkPhysicalDeviceFeatures2` structure instead and pass it as `VkDeviceCreateInfo::pNext`.
+Enable this device feature - attach additional structure `VkPhysicalDeviceCoherentMemoryFeaturesAMD` to
+`VkPhysicalDeviceFeatures2::pNext` and set its member `deviceCoherentMemory` to `VK_TRUE`.
+
+5) While creating #VmaAllocator with vmaCreateAllocator() inform VMA that you
+have enabled this extension and feature - add #VMA_ALLOCATOR_CREATE_AMD_DEVICE_COHERENT_MEMORY_BIT
+to VmaAllocatorCreateInfo::flags.
+
+\section vk_amd_device_coherent_memory_usage Usage
+
+After following steps described above, you can create VMA allocations and custom pools
+out of the special `DEVICE_COHERENT` and `DEVICE_UNCACHED` memory types on eligible
+devices. There are multiple ways to do it, for example:
+
+- You can request or prefer to allocate out of such memory types by adding
+  `VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD` to VmaAllocationCreateInfo::requiredFlags
+  or VmaAllocationCreateInfo::preferredFlags. Those flags can be freely mixed with
+  other ways of \ref choosing_memory_type, like setting VmaAllocationCreateInfo::usage.
+- If you manually found memory type index to use for this purpose, force allocation
+  from this specific index by setting VmaAllocationCreateInfo::memoryTypeBits `= 1u << index`.
+
+\section vk_amd_device_coherent_memory_more_information More information
+
+To learn more about this extension, see [VK_AMD_device_coherent_memory in Vulkan specification](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/chap44.html#VK_AMD_device_coherent_memory)
+
+Example use of this extension can be found in the code of the sample and test suite
+accompanying this library.
+
+
+\page enabling_buffer_device_address Enabling buffer device address
+
+Device extension VK_KHR_buffer_device_address
+allow to fetch raw GPU pointer to a buffer and pass it for usage in a shader code.
+It is promoted to core Vulkan 1.2.
+
+If you want to use this feature in connection with VMA, follow these steps:
+
+\section enabling_buffer_device_address_initialization Initialization
+
+1) (For Vulkan version < 1.2) Call `vkEnumerateDeviceExtensionProperties` for the physical device.
+Check if the extension is supported - if returned array of `VkExtensionProperties` contains
+"VK_KHR_buffer_device_address".
+
+2) Call `vkGetPhysicalDeviceFeatures2` for the physical device instead of old `vkGetPhysicalDeviceFeatures`.
+Attach additional structure `VkPhysicalDeviceBufferDeviceAddressFeatures*` to `VkPhysicalDeviceFeatures2::pNext` to be returned.
+Check if the device feature is really supported - check if `VkPhysicalDeviceBufferDeviceAddressFeatures*::bufferDeviceAddress` is true.
+
+3) (For Vulkan version < 1.2) While creating device with `vkCreateDevice`, enable this extension - add
+"VK_KHR_buffer_device_address" to the list passed as `VkDeviceCreateInfo::ppEnabledExtensionNames`.
+
+4) While creating the device, also don't set `VkDeviceCreateInfo::pEnabledFeatures`.
+Fill in `VkPhysicalDeviceFeatures2` structure instead and pass it as `VkDeviceCreateInfo::pNext`.
+Enable this device feature - attach additional structure `VkPhysicalDeviceBufferDeviceAddressFeatures*` to
+`VkPhysicalDeviceFeatures2::pNext` and set its member `bufferDeviceAddress` to `VK_TRUE`.
+
+5) While creating #VmaAllocator with vmaCreateAllocator() inform VMA that you
+have enabled this feature - add #VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT
+to VmaAllocatorCreateInfo::flags.
+
+\section enabling_buffer_device_address_usage Usage
+
+After following steps described above, you can create buffers with `VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT*` using VMA.
+The library automatically adds `VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT*` to
+allocated memory blocks wherever it might be needed.
+
+Please note that the library supports only `VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT*`.
+The second part of this functionality related to "capture and replay" is not supported,
+as it is intended for usage in debugging tools like RenderDoc, not in everyday Vulkan usage.
+
+\section enabling_buffer_device_address_more_information More information
+
+To learn more about this extension, see [VK_KHR_buffer_device_address in Vulkan specification](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/chap46.html#VK_KHR_buffer_device_address)
+
+Example use of this extension can be found in the code of the sample and test suite
+accompanying this library.
+
+\page general_considerations General considerations
+
+\section general_considerations_thread_safety Thread safety
+
+- The library has no global state, so separate #VmaAllocator objects can be used
+  independently.
+  There should be no need to create multiple such objects though - one per `VkDevice` is enough.
+- By default, all calls to functions that take #VmaAllocator as first parameter
+  are safe to call from multiple threads simultaneously because they are
+  synchronized internally when needed.
+- When the allocator is created with #VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT
+  flag, calls to functions that take such #VmaAllocator object must be
+  synchronized externally.
+- Access to a #VmaAllocation object must be externally synchronized. For example,
+  you must not call vmaGetAllocationInfo() and vmaMapMemory() from different
+  threads at the same time if you pass the same #VmaAllocation object to these
+  functions.
+
+\section general_considerations_validation_layer_warnings Validation layer warnings
+
+When using this library, you can meet following types of warnings issued by
+Vulkan validation layer. They don't necessarily indicate a bug, so you may need
+to just ignore them.
+
+- *vkBindBufferMemory(): Binding memory to buffer 0xeb8e4 but vkGetBufferMemoryRequirements() has not been called on that buffer.*
+  - It happens when VK_KHR_dedicated_allocation extension is enabled.
+    `vkGetBufferMemoryRequirements2KHR` function is used instead, while validation layer seems to be unaware of it.
+- *Mapping an image with layout VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL can result in undefined behavior if this memory is used by the device. Only GENERAL or PREINITIALIZED should be used.*
+  - It happens when you map a buffer or image, because the library maps entire
+    `VkDeviceMemory` block, where different types of images and buffers may end
+    up together, especially on GPUs with unified memory like Intel.
+- *Non-linear image 0xebc91 is aliased with linear buffer 0xeb8e4 which may indicate a bug.*
+  - It happens when you use lost allocations, and a new image or buffer is
+    created in place of an existing object that bacame lost.
+  - It may happen also when you use [defragmentation](@ref defragmentation).
+
+\section general_considerations_allocation_algorithm Allocation algorithm
+
+The library uses following algorithm for allocation, in order:
+
+-# Try to find free range of memory in existing blocks.
+-# If failed, try to create a new block of `VkDeviceMemory`, with preferred block size.
+-# If failed, try to create such block with size/2, size/4, size/8.
+-# If failed and #VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT flag was
+   specified, try to find space in existing blocks, possilby making some other
+   allocations lost.
+-# If failed, try to allocate separate `VkDeviceMemory` for this allocation,
+   just like when you use #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT.
+-# If failed, choose other memory type that meets the requirements specified in
+   VmaAllocationCreateInfo and go to point 1.
+-# If failed, return `VK_ERROR_OUT_OF_DEVICE_MEMORY`.
+
+\section general_considerations_features_not_supported Features not supported
+
+Features deliberately excluded from the scope of this library:
+
+- Data transfer. Uploading (straming) and downloading data of buffers and images
+  between CPU and GPU memory and related synchronization is responsibility of the user.
+  Defining some "texture" object that would automatically stream its data from a
+  staging copy in CPU memory to GPU memory would rather be a feature of another,
+  higher-level library implemented on top of VMA.
+- Allocations for imported/exported external memory. They tend to require
+  explicit memory type index and dedicated allocation anyway, so they don't
+  interact with main features of this library. Such special purpose allocations
+  should be made manually, using `vkCreateBuffer()` and `vkAllocateMemory()`.
+- Sub-allocation of parts of one large buffer. Although recommended as a good practice,
+  it is the user's responsibility to implement such logic on top of VMA.
+- Recreation of buffers and images. Although the library has functions for
+  buffer and image creation (vmaCreateBuffer(), vmaCreateImage()), you need to
+  recreate these objects yourself after defragmentation. That's because the big
+  structures `VkBufferCreateInfo`, `VkImageCreateInfo` are not stored in
+  #VmaAllocation object.
+- Handling CPU memory allocation failures. When dynamically creating small C++
+  objects in CPU memory (not Vulkan memory), allocation failures are not checked
+  and handled gracefully, because that would complicate code significantly and
+  is usually not needed in desktop PC applications anyway.
+  Success of an allocation is just checked with an assert.
+- Code free of any compiler warnings. Maintaining the library to compile and
+  work correctly on so many different platforms is hard enough. Being free of
+  any warnings, on any version of any compiler, is simply not feasible.
+- This is a C++ library with C interface.
+  Bindings or ports to any other programming languages are welcomed as external projects and
+  are not going to be included into this repository.
+
+*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+Define this macro to 0/1 to disable/enable support for recording functionality,
+available through VmaAllocatorCreateInfo::pRecordSettings.
+*/
+#ifndef VMA_RECORDING_ENABLED
+    #define VMA_RECORDING_ENABLED 0
+#endif
+
+#if !defined(NOMINMAX) && defined(VMA_IMPLEMENTATION)
+    #define NOMINMAX // For windows.h
+#endif
+
+#if defined(__ANDROID__) && defined(VK_NO_PROTOTYPES) && VMA_STATIC_VULKAN_FUNCTIONS
+    extern PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
+    extern PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr;
+    extern PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties;
+    extern PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties;
+    extern PFN_vkAllocateMemory vkAllocateMemory;
+    extern PFN_vkFreeMemory vkFreeMemory;
+    extern PFN_vkMapMemory vkMapMemory;
+    extern PFN_vkUnmapMemory vkUnmapMemory;
+    extern PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges;
+    extern PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges;
+    extern PFN_vkBindBufferMemory vkBindBufferMemory;
+    extern PFN_vkBindImageMemory vkBindImageMemory;
+    extern PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements;
+    extern PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements;
+    extern PFN_vkCreateBuffer vkCreateBuffer;
+    extern PFN_vkDestroyBuffer vkDestroyBuffer;
+    extern PFN_vkCreateImage vkCreateImage;
+    extern PFN_vkDestroyImage vkDestroyImage;
+    extern PFN_vkCmdCopyBuffer vkCmdCopyBuffer;
+    #if VMA_VULKAN_VERSION >= 1001000
+        extern PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2;
+        extern PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2;
+        extern PFN_vkBindBufferMemory2 vkBindBufferMemory2;
+        extern PFN_vkBindImageMemory2 vkBindImageMemory2;
+        extern PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2;
+    #endif // #if VMA_VULKAN_VERSION >= 1001000
+#endif // #if defined(__ANDROID__) && VMA_STATIC_VULKAN_FUNCTIONS && VK_NO_PROTOTYPES
+
+#ifndef VULKAN_H_
+    #include <vulkan/vulkan.h>
+#endif
+
+// Define this macro to declare maximum supported Vulkan version in format AAABBBCCC,
+// where AAA = major, BBB = minor, CCC = patch.
+// If you want to use version > 1.0, it still needs to be enabled via VmaAllocatorCreateInfo::vulkanApiVersion.
+#if !defined(VMA_VULKAN_VERSION)
+    #if defined(VK_VERSION_1_2)
+        #define VMA_VULKAN_VERSION 1002000
+    #elif defined(VK_VERSION_1_1)
+        #define VMA_VULKAN_VERSION 1001000
+    #else
+        #define VMA_VULKAN_VERSION 1000000
+    #endif
+#endif
+
+#if !defined(VMA_DEDICATED_ALLOCATION)
+    #if VK_KHR_get_memory_requirements2 && VK_KHR_dedicated_allocation
+        #define VMA_DEDICATED_ALLOCATION 1
+    #else
+        #define VMA_DEDICATED_ALLOCATION 0
+    #endif
+#endif
+
+#if !defined(VMA_BIND_MEMORY2)
+    #if VK_KHR_bind_memory2
+        #define VMA_BIND_MEMORY2 1
+    #else
+        #define VMA_BIND_MEMORY2 0
+    #endif
+#endif
+
+#if !defined(VMA_MEMORY_BUDGET)
+    #if VK_EXT_memory_budget && (VK_KHR_get_physical_device_properties2 || VMA_VULKAN_VERSION >= 1001000)
+        #define VMA_MEMORY_BUDGET 1
+    #else
+        #define VMA_MEMORY_BUDGET 0
+    #endif
+#endif
+
+// Defined to 1 when VK_KHR_buffer_device_address device extension or equivalent core Vulkan 1.2 feature is defined in its headers.
+#if !defined(VMA_BUFFER_DEVICE_ADDRESS)
+    #if VK_KHR_buffer_device_address || VMA_VULKAN_VERSION >= 1002000
+        #define VMA_BUFFER_DEVICE_ADDRESS 1
+    #else
+        #define VMA_BUFFER_DEVICE_ADDRESS 0
+    #endif
+#endif
+
+// Defined to 1 when VK_EXT_memory_priority device extension is defined in Vulkan headers.
+#if !defined(VMA_MEMORY_PRIORITY)
+    #if VK_EXT_memory_priority
+        #define VMA_MEMORY_PRIORITY 1
+    #else
+        #define VMA_MEMORY_PRIORITY 0
+    #endif
+#endif
+
+// Define these macros to decorate all public functions with additional code,
+// before and after returned type, appropriately. This may be useful for
+// exporting the functions when compiling VMA as a separate library. Example:
+// #define VMA_CALL_PRE  __declspec(dllexport)
+// #define VMA_CALL_POST __cdecl
+#ifndef VMA_CALL_PRE
+    #define VMA_CALL_PRE
+#endif
+#ifndef VMA_CALL_POST
+    #define VMA_CALL_POST
+#endif
+
+// Define this macro to decorate pointers with an attribute specifying the
+// length of the array they point to if they are not null.
+//
+// The length may be one of
+// - The name of another parameter in the argument list where the pointer is declared
+// - The name of another member in the struct where the pointer is declared
+// - The name of a member of a struct type, meaning the value of that member in
+//   the context of the call. For example
+//   VMA_LEN_IF_NOT_NULL("VkPhysicalDeviceMemoryProperties::memoryHeapCount"),
+//   this means the number of memory heaps available in the device associated
+//   with the VmaAllocator being dealt with.
+#ifndef VMA_LEN_IF_NOT_NULL
+    #define VMA_LEN_IF_NOT_NULL(len)
+#endif
+
+// The VMA_NULLABLE macro is defined to be _Nullable when compiling with Clang.
+// see: https://clang.llvm.org/docs/AttributeReference.html#nullable
+#ifndef VMA_NULLABLE
+    #ifdef __clang__
+        #define VMA_NULLABLE _Nullable
+    #else
+        #define VMA_NULLABLE
+    #endif
+#endif
+
+// The VMA_NOT_NULL macro is defined to be _Nonnull when compiling with Clang.
+// see: https://clang.llvm.org/docs/AttributeReference.html#nonnull
+#ifndef VMA_NOT_NULL
+    #ifdef __clang__
+        #define VMA_NOT_NULL _Nonnull
+    #else
+        #define VMA_NOT_NULL
+    #endif
+#endif
+
+// If non-dispatchable handles are represented as pointers then we can give
+// then nullability annotations
+#ifndef VMA_NOT_NULL_NON_DISPATCHABLE
+    #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
+        #define VMA_NOT_NULL_NON_DISPATCHABLE VMA_NOT_NULL
+    #else
+        #define VMA_NOT_NULL_NON_DISPATCHABLE
+    #endif
+#endif
+
+#ifndef VMA_NULLABLE_NON_DISPATCHABLE
+    #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
+        #define VMA_NULLABLE_NON_DISPATCHABLE VMA_NULLABLE
+    #else
+        #define VMA_NULLABLE_NON_DISPATCHABLE
+    #endif
+#endif
+
+/** \struct VmaAllocator
+\brief Represents main object of this library initialized.
+
+Fill structure #VmaAllocatorCreateInfo and call function vmaCreateAllocator() to create it.
+Call function vmaDestroyAllocator() to destroy it.
+
+It is recommended to create just one object of this type per `VkDevice` object,
+right after Vulkan is initialized and keep it alive until before Vulkan device is destroyed.
+*/
+VK_DEFINE_HANDLE(VmaAllocator)
+
+/// Callback function called after successful vkAllocateMemory.
+typedef void (VKAPI_PTR *PFN_vmaAllocateDeviceMemoryFunction)(
+    VmaAllocator VMA_NOT_NULL                    allocator,
+    uint32_t                                     memoryType,
+    VkDeviceMemory VMA_NOT_NULL_NON_DISPATCHABLE memory,
+    VkDeviceSize                                 size,
+    void* VMA_NULLABLE                           pUserData);
+/// Callback function called before vkFreeMemory.
+typedef void (VKAPI_PTR *PFN_vmaFreeDeviceMemoryFunction)(
+    VmaAllocator VMA_NOT_NULL                    allocator,
+    uint32_t                                     memoryType,
+    VkDeviceMemory VMA_NOT_NULL_NON_DISPATCHABLE memory,
+    VkDeviceSize                                 size,
+    void* VMA_NULLABLE                           pUserData);
+
+/** \brief Set of callbacks that the library will call for `vkAllocateMemory` and `vkFreeMemory`.
+
+Provided for informative purpose, e.g. to gather statistics about number of
+allocations or total amount of memory allocated in Vulkan.
+
+Used in VmaAllocatorCreateInfo::pDeviceMemoryCallbacks.
+*/
+typedef struct VmaDeviceMemoryCallbacks {
+    /// Optional, can be null.
+    PFN_vmaAllocateDeviceMemoryFunction VMA_NULLABLE pfnAllocate;
+    /// Optional, can be null.
+    PFN_vmaFreeDeviceMemoryFunction VMA_NULLABLE pfnFree;
+    /// Optional, can be null.
+    void* VMA_NULLABLE pUserData;
+} VmaDeviceMemoryCallbacks;
+
+/// Flags for created #VmaAllocator.
+typedef enum VmaAllocatorCreateFlagBits {
+    /** \brief Allocator and all objects created from it will not be synchronized internally, so you must guarantee they are used from only one thread at a time or synchronized externally by you.
+
+    Using this flag may increase performance because internal mutexes are not used.
+    */
+    VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT = 0x00000001,
+    /** \brief Enables usage of VK_KHR_dedicated_allocation extension.
+
+    The flag works only if VmaAllocatorCreateInfo::vulkanApiVersion `== VK_API_VERSION_1_0`.
+    When it's `VK_API_VERSION_1_1`, the flag is ignored because the extension has been promoted to Vulkan 1.1.
+
+    Using this extenion will automatically allocate dedicated blocks of memory for
+    some buffers and images instead of suballocating place for them out of bigger
+    memory blocks (as if you explicitly used #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT
+    flag) when it is recommended by the driver. It may improve performance on some
+    GPUs.
+
+    You may set this flag only if you found out that following device extensions are
+    supported, you enabled them while creating Vulkan device passed as
+    VmaAllocatorCreateInfo::device, and you want them to be used internally by this
+    library:
+
+    - VK_KHR_get_memory_requirements2 (device extension)
+    - VK_KHR_dedicated_allocation (device extension)
+
+    When this flag is set, you can experience following warnings reported by Vulkan
+    validation layer. You can ignore them.
+
+    > vkBindBufferMemory(): Binding memory to buffer 0x2d but vkGetBufferMemoryRequirements() has not been called on that buffer.
+    */
+    VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT = 0x00000002,
+    /**
+    Enables usage of VK_KHR_bind_memory2 extension.
+
+    The flag works only if VmaAllocatorCreateInfo::vulkanApiVersion `== VK_API_VERSION_1_0`.
+    When it's `VK_API_VERSION_1_1`, the flag is ignored because the extension has been promoted to Vulkan 1.1.
+
+    You may set this flag only if you found out that this device extension is supported,
+    you enabled it while creating Vulkan device passed as VmaAllocatorCreateInfo::device,
+    and you want it to be used internally by this library.
+
+    The extension provides functions `vkBindBufferMemory2KHR` and `vkBindImageMemory2KHR`,
+    which allow to pass a chain of `pNext` structures while binding.
+    This flag is required if you use `pNext` parameter in vmaBindBufferMemory2() or vmaBindImageMemory2().
+    */
+    VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT = 0x00000004,
+    /**
+    Enables usage of VK_EXT_memory_budget extension.
+
+    You may set this flag only if you found out that this device extension is supported,
+    you enabled it while creating Vulkan device passed as VmaAllocatorCreateInfo::device,
+    and you want it to be used internally by this library, along with another instance extension
+    VK_KHR_get_physical_device_properties2, which is required by it (or Vulkan 1.1, where this extension is promoted).
+
+    The extension provides query for current memory usage and budget, which will probably
+    be more accurate than an estimation used by the library otherwise.
+    */
+    VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT = 0x00000008,
+    /**
+    Enables usage of VK_AMD_device_coherent_memory extension.
+
+    You may set this flag only if you:
+
+    - found out that this device extension is supported and enabled it while creating Vulkan device passed as VmaAllocatorCreateInfo::device,
+    - checked that `VkPhysicalDeviceCoherentMemoryFeaturesAMD::deviceCoherentMemory` is true and set it while creating the Vulkan device,
+    - want it to be used internally by this library.
+
+    The extension and accompanying device feature provide access to memory types with
+    `VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD` and `VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD` flags.
+    They are useful mostly for writing breadcrumb markers - a common method for debugging GPU crash/hang/TDR.
+
+    When the extension is not enabled, such memory types are still enumerated, but their usage is illegal.
+    To protect from this error, if you don't create the allocator with this flag, it will refuse to allocate any memory or create a custom pool in such memory type,
+    returning `VK_ERROR_FEATURE_NOT_PRESENT`.
+    */
+    VMA_ALLOCATOR_CREATE_AMD_DEVICE_COHERENT_MEMORY_BIT = 0x00000010,
+    /**
+    Enables usage of "buffer device address" feature, which allows you to use function
+    `vkGetBufferDeviceAddress*` to get raw GPU pointer to a buffer and pass it for usage inside a shader.
+
+    You may set this flag only if you:
+
+    1. (For Vulkan version < 1.2) Found as available and enabled device extension
+    VK_KHR_buffer_device_address.
+    This extension is promoted to core Vulkan 1.2.
+    2. Found as available and enabled device feature `VkPhysicalDeviceBufferDeviceAddressFeatures::bufferDeviceAddress`.
+
+    When this flag is set, you can create buffers with `VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT` using VMA.
+    The library automatically adds `VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT` to
+    allocated memory blocks wherever it might be needed.
+
+    For more information, see documentation chapter \ref enabling_buffer_device_address.
+    */
+    VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT = 0x00000020,
+    /**
+    Enables usage of VK_EXT_memory_priority extension in the library.
+
+    You may set this flag only if you found available and enabled this device extension,
+    along with `VkPhysicalDeviceMemoryPriorityFeaturesEXT::memoryPriority == VK_TRUE`,
+    while creating Vulkan device passed as VmaAllocatorCreateInfo::device.
+
+    When this flag is used, VmaAllocationCreateInfo::priority and VmaPoolCreateInfo::priority
+    are used to set priorities of allocated Vulkan memory. Without it, these variables are ignored.
+
+    A priority must be a floating-point value between 0 and 1, indicating the priority of the allocation relative to other memory allocations.
+    Larger values are higher priority. The granularity of the priorities is implementation-dependent.
+    It is automatically passed to every call to `vkAllocateMemory` done by the library using structure `VkMemoryPriorityAllocateInfoEXT`.
+    The value to be used for default priority is 0.5.
+    For more details, see the documentation of the VK_EXT_memory_priority extension.
+    */
+    VMA_ALLOCATOR_CREATE_EXT_MEMORY_PRIORITY_BIT = 0x00000040,
+
+    VMA_ALLOCATOR_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VmaAllocatorCreateFlagBits;
+typedef VkFlags VmaAllocatorCreateFlags;
+
+/** \brief Pointers to some Vulkan functions - a subset used by the library.
+
+Used in VmaAllocatorCreateInfo::pVulkanFunctions.
+*/
+typedef struct VmaVulkanFunctions {
+    PFN_vkGetPhysicalDeviceProperties VMA_NULLABLE vkGetPhysicalDeviceProperties;
+    PFN_vkGetPhysicalDeviceMemoryProperties VMA_NULLABLE vkGetPhysicalDeviceMemoryProperties;
+    PFN_vkAllocateMemory VMA_NULLABLE vkAllocateMemory;
+    PFN_vkFreeMemory VMA_NULLABLE vkFreeMemory;
+    PFN_vkMapMemory VMA_NULLABLE vkMapMemory;
+    PFN_vkUnmapMemory VMA_NULLABLE vkUnmapMemory;
+    PFN_vkFlushMappedMemoryRanges VMA_NULLABLE vkFlushMappedMemoryRanges;
+    PFN_vkInvalidateMappedMemoryRanges VMA_NULLABLE vkInvalidateMappedMemoryRanges;
+    PFN_vkBindBufferMemory VMA_NULLABLE vkBindBufferMemory;
+    PFN_vkBindImageMemory VMA_NULLABLE vkBindImageMemory;
+    PFN_vkGetBufferMemoryRequirements VMA_NULLABLE vkGetBufferMemoryRequirements;
+    PFN_vkGetImageMemoryRequirements VMA_NULLABLE vkGetImageMemoryRequirements;
+    PFN_vkCreateBuffer VMA_NULLABLE vkCreateBuffer;
+    PFN_vkDestroyBuffer VMA_NULLABLE vkDestroyBuffer;
+    PFN_vkCreateImage VMA_NULLABLE vkCreateImage;
+    PFN_vkDestroyImage VMA_NULLABLE vkDestroyImage;
+    PFN_vkCmdCopyBuffer VMA_NULLABLE vkCmdCopyBuffer;
+#if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
+    PFN_vkGetBufferMemoryRequirements2KHR VMA_NULLABLE vkGetBufferMemoryRequirements2KHR;
+    PFN_vkGetImageMemoryRequirements2KHR VMA_NULLABLE vkGetImageMemoryRequirements2KHR;
+#endif
+#if VMA_BIND_MEMORY2 || VMA_VULKAN_VERSION >= 1001000
+    PFN_vkBindBufferMemory2KHR VMA_NULLABLE vkBindBufferMemory2KHR;
+    PFN_vkBindImageMemory2KHR VMA_NULLABLE vkBindImageMemory2KHR;
+#endif
+#if VMA_MEMORY_BUDGET || VMA_VULKAN_VERSION >= 1001000
+    PFN_vkGetPhysicalDeviceMemoryProperties2KHR VMA_NULLABLE vkGetPhysicalDeviceMemoryProperties2KHR;
+#endif
+} VmaVulkanFunctions;
+
+/// Flags to be used in VmaRecordSettings::flags.
+typedef enum VmaRecordFlagBits {
+    /** \brief Enables flush after recording every function call.
+
+    Enable it if you expect your application to crash, which may leave recording file truncated.
+    It may degrade performance though.
+    */
+    VMA_RECORD_FLUSH_AFTER_CALL_BIT = 0x00000001,
+
+    VMA_RECORD_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VmaRecordFlagBits;
+typedef VkFlags VmaRecordFlags;
+
+/// Parameters for recording calls to VMA functions. To be used in VmaAllocatorCreateInfo::pRecordSettings.
+typedef struct VmaRecordSettings
+{
+    /// Flags for recording. Use #VmaRecordFlagBits enum.
+    VmaRecordFlags flags;
+    /** \brief Path to the file that should be written by the recording.
+
+    Suggested extension: "csv".
+    If the file already exists, it will be overwritten.
+    It will be opened for the whole time #VmaAllocator object is alive.
+    If opening this file fails, creation of the whole allocator object fails.
+    */
+    const char* VMA_NOT_NULL pFilePath;
+} VmaRecordSettings;
+
+/// Description of a Allocator to be created.
+typedef struct VmaAllocatorCreateInfo
+{
+    /// Flags for created allocator. Use #VmaAllocatorCreateFlagBits enum.
+    VmaAllocatorCreateFlags flags;
+    /// Vulkan physical device.
+    /** It must be valid throughout whole lifetime of created allocator. */
+    VkPhysicalDevice VMA_NOT_NULL physicalDevice;
+    /// Vulkan device.
+    /** It must be valid throughout whole lifetime of created allocator. */
+    VkDevice VMA_NOT_NULL device;
+    /// Preferred size of a single `VkDeviceMemory` block to be allocated from large heaps > 1 GiB. Optional.
+    /** Set to 0 to use default, which is currently 256 MiB. */
+    VkDeviceSize preferredLargeHeapBlockSize;
+    /// Custom CPU memory allocation callbacks. Optional.
+    /** Optional, can be null. When specified, will also be used for all CPU-side memory allocations. */
+    const VkAllocationCallbacks* VMA_NULLABLE pAllocationCallbacks;
+    /// Informative callbacks for `vkAllocateMemory`, `vkFreeMemory`. Optional.
+    /** Optional, can be null. */
+    const VmaDeviceMemoryCallbacks* VMA_NULLABLE pDeviceMemoryCallbacks;
+    /** \brief Maximum number of additional frames that are in use at the same time as current frame.
+
+    This value is used only when you make allocations with
+    VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT flag. Such allocation cannot become
+    lost if allocation.lastUseFrameIndex >= allocator.currentFrameIndex - frameInUseCount.
+
+    For example, if you double-buffer your command buffers, so resources used for
+    rendering in previous frame may still be in use by the GPU at the moment you
+    allocate resources needed for the current frame, set this value to 1.
+
+    If you want to allow any allocations other than used in the current frame to
+    become lost, set this value to 0.
+    */
+    uint32_t frameInUseCount;
+    /** \brief Either null or a pointer to an array of limits on maximum number of bytes that can be allocated out of particular Vulkan memory heap.
+
+    If not NULL, it must be a pointer to an array of
+    `VkPhysicalDeviceMemoryProperties::memoryHeapCount` elements, defining limit on
+    maximum number of bytes that can be allocated out of particular Vulkan memory
+    heap.
+
+    Any of the elements may be equal to `VK_WHOLE_SIZE`, which means no limit on that
+    heap. This is also the default in case of `pHeapSizeLimit` = NULL.
+
+    If there is a limit defined for a heap:
+
+    - If user tries to allocate more memory from that heap using this allocator,
+      the allocation fails with `VK_ERROR_OUT_OF_DEVICE_MEMORY`.
+    - If the limit is smaller than heap size reported in `VkMemoryHeap::size`, the
+      value of this limit will be reported instead when using vmaGetMemoryProperties().
+
+    Warning! Using this feature may not be equivalent to installing a GPU with
+    smaller amount of memory, because graphics driver doesn't necessary fail new
+    allocations with `VK_ERROR_OUT_OF_DEVICE_MEMORY` result when memory capacity is
+    exceeded. It may return success and just silently migrate some device memory
+    blocks to system RAM. This driver behavior can also be controlled using
+    VK_AMD_memory_overallocation_behavior extension.
+    */
+    const VkDeviceSize* VMA_NULLABLE VMA_LEN_IF_NOT_NULL("VkPhysicalDeviceMemoryProperties::memoryHeapCount") pHeapSizeLimit;
+
+    /** \brief Pointers to Vulkan functions. Can be null.
+
+    For details see [Pointers to Vulkan functions](@ref config_Vulkan_functions).
+    */
+    const VmaVulkanFunctions* VMA_NULLABLE pVulkanFunctions;
+    /** \brief Parameters for recording of VMA calls. Can be null.
+
+    If not null, it enables recording of calls to VMA functions to a file.
+    If support for recording is not enabled using `VMA_RECORDING_ENABLED` macro,
+    creation of the allocator object fails with `VK_ERROR_FEATURE_NOT_PRESENT`.
+    */
+    const VmaRecordSettings* VMA_NULLABLE pRecordSettings;
+    /** \brief Handle to Vulkan instance object.
+
+    Starting from version 3.0.0 this member is no longer optional, it must be set!
+    */
+    VkInstance VMA_NOT_NULL instance;
+    /** \brief Optional. The highest version of Vulkan that the application is designed to use.
+
+    It must be a value in the format as created by macro `VK_MAKE_VERSION` or a constant like: `VK_API_VERSION_1_1`, `VK_API_VERSION_1_0`.
+    The patch version number specified is ignored. Only the major and minor versions are considered.
+    It must be less or equal (preferably equal) to value as passed to `vkCreateInstance` as `VkApplicationInfo::apiVersion`.
+    Only versions 1.0, 1.1, 1.2 are supported by the current implementation.
+    Leaving it initialized to zero is equivalent to `VK_API_VERSION_1_0`.
+    */
+    uint32_t vulkanApiVersion;
+} VmaAllocatorCreateInfo;
+
+/// Creates Allocator object.
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAllocator(
+    const VmaAllocatorCreateInfo* VMA_NOT_NULL pCreateInfo,
+    VmaAllocator VMA_NULLABLE * VMA_NOT_NULL pAllocator);
+
+/// Destroys allocator object.
+VMA_CALL_PRE void VMA_CALL_POST vmaDestroyAllocator(
+    VmaAllocator VMA_NULLABLE allocator);
+
+/** \brief Information about existing #VmaAllocator object.
+*/
+typedef struct VmaAllocatorInfo
+{
+    /** \brief Handle to Vulkan instance object.
+
+    This is the same value as has been passed through VmaAllocatorCreateInfo::instance.
+    */
+    VkInstance VMA_NOT_NULL instance;
+    /** \brief Handle to Vulkan physical device object.
+
+    This is the same value as has been passed through VmaAllocatorCreateInfo::physicalDevice.
+    */
+    VkPhysicalDevice VMA_NOT_NULL physicalDevice;
+    /** \brief Handle to Vulkan device object.
+
+    This is the same value as has been passed through VmaAllocatorCreateInfo::device.
+    */
+    VkDevice VMA_NOT_NULL device;
+} VmaAllocatorInfo;
+
+/** \brief Returns information about existing #VmaAllocator object - handle to Vulkan device etc.
+
+It might be useful if you want to keep just the #VmaAllocator handle and fetch other required handles to
+`VkPhysicalDevice`, `VkDevice` etc. every time using this function.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaGetAllocatorInfo(VmaAllocator VMA_NOT_NULL allocator, VmaAllocatorInfo* VMA_NOT_NULL pAllocatorInfo);
+
+/**
+PhysicalDeviceProperties are fetched from physicalDevice by the allocator.
+You can access it here, without fetching it again on your own.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaGetPhysicalDeviceProperties(
+    VmaAllocator VMA_NOT_NULL allocator,
+    const VkPhysicalDeviceProperties* VMA_NULLABLE * VMA_NOT_NULL ppPhysicalDeviceProperties);
+
+/**
+PhysicalDeviceMemoryProperties are fetched from physicalDevice by the allocator.
+You can access it here, without fetching it again on your own.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaGetMemoryProperties(
+    VmaAllocator VMA_NOT_NULL allocator,
+    const VkPhysicalDeviceMemoryProperties* VMA_NULLABLE * VMA_NOT_NULL ppPhysicalDeviceMemoryProperties);
+
+/**
+\brief Given Memory Type Index, returns Property Flags of this memory type.
+
+This is just a convenience function. Same information can be obtained using
+vmaGetMemoryProperties().
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaGetMemoryTypeProperties(
+    VmaAllocator VMA_NOT_NULL allocator,
+    uint32_t memoryTypeIndex,
+    VkMemoryPropertyFlags* VMA_NOT_NULL pFlags);
+
+/** \brief Sets index of the current frame.
+
+This function must be used if you make allocations with
+#VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT and
+#VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT flags to inform the allocator
+when a new frame begins. Allocations queried using vmaGetAllocationInfo() cannot
+become lost in the current frame.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaSetCurrentFrameIndex(
+    VmaAllocator VMA_NOT_NULL allocator,
+    uint32_t frameIndex);
+
+/** \brief Calculated statistics of memory usage in entire allocator.
+*/
+typedef struct VmaStatInfo
+{
+    /// Number of `VkDeviceMemory` Vulkan memory blocks allocated.
+    uint32_t blockCount;
+    /// Number of #VmaAllocation allocation objects allocated.
+    uint32_t allocationCount;
+    /// Number of free ranges of memory between allocations.
+    uint32_t unusedRangeCount;
+    /// Total number of bytes occupied by all allocations.
+    VkDeviceSize usedBytes;
+    /// Total number of bytes occupied by unused ranges.
+    VkDeviceSize unusedBytes;
+    VkDeviceSize allocationSizeMin, allocationSizeAvg, allocationSizeMax;
+    VkDeviceSize unusedRangeSizeMin, unusedRangeSizeAvg, unusedRangeSizeMax;
+} VmaStatInfo;
+
+/// General statistics from current state of Allocator.
+typedef struct VmaStats
+{
+    VmaStatInfo memoryType[VK_MAX_MEMORY_TYPES];
+    VmaStatInfo memoryHeap[VK_MAX_MEMORY_HEAPS];
+    VmaStatInfo total;
+} VmaStats;
+
+/** \brief Retrieves statistics from current state of the Allocator.
+
+This function is called "calculate" not "get" because it has to traverse all
+internal data structures, so it may be quite slow. For faster but more brief statistics
+suitable to be called every frame or every allocation, use vmaGetBudget().
+
+Note that when using allocator from multiple threads, returned information may immediately
+become outdated.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaCalculateStats(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaStats* VMA_NOT_NULL pStats);
+
+/** \brief Statistics of current memory usage and available budget, in bytes, for specific memory heap.
+*/
+typedef struct VmaBudget
+{
+    /** \brief Sum size of all `VkDeviceMemory` blocks allocated from particular heap, in bytes.
+    */
+    VkDeviceSize blockBytes;
+
+    /** \brief Sum size of all allocations created in particular heap, in bytes.
+
+    Usually less or equal than `blockBytes`.
+    Difference `blockBytes - allocationBytes` is the amount of memory allocated but unused -
+    available for new allocations or wasted due to fragmentation.
+
+    It might be greater than `blockBytes` if there are some allocations in lost state, as they account
+    to this value as well.
+    */
+    VkDeviceSize allocationBytes;
+
+    /** \brief Estimated current memory usage of the program, in bytes.
+
+    Fetched from system using `VK_EXT_memory_budget` extension if enabled.
+
+    It might be different than `blockBytes` (usually higher) due to additional implicit objects
+    also occupying the memory, like swapchain, pipelines, descriptor heaps, command buffers, or
+    `VkDeviceMemory` blocks allocated outside of this library, if any.
+    */
+    VkDeviceSize usage;
+
+    /** \brief Estimated amount of memory available to the program, in bytes.
+
+    Fetched from system using `VK_EXT_memory_budget` extension if enabled.
+
+    It might be different (most probably smaller) than `VkMemoryHeap::size[heapIndex]` due to factors
+    external to the program, like other programs also consuming system resources.
+    Difference `budget - usage` is the amount of additional memory that can probably
+    be allocated without problems. Exceeding the budget may result in various problems.
+    */
+    VkDeviceSize budget;
+} VmaBudget;
+
+/** \brief Retrieves information about current memory budget for all memory heaps.
+
+\param[out] pBudget Must point to array with number of elements at least equal to number of memory heaps in physical device used.
+
+This function is called "get" not "calculate" because it is very fast, suitable to be called
+every frame or every allocation. For more detailed statistics use vmaCalculateStats().
+
+Note that when using allocator from multiple threads, returned information may immediately
+become outdated.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaGetBudget(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaBudget* VMA_NOT_NULL pBudget);
+
+#ifndef VMA_STATS_STRING_ENABLED
+#define VMA_STATS_STRING_ENABLED 1
+#endif
+
+#if VMA_STATS_STRING_ENABLED
+
+/// Builds and returns statistics as string in JSON format.
+/** @param[out] ppStatsString Must be freed using vmaFreeStatsString() function.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaBuildStatsString(
+    VmaAllocator VMA_NOT_NULL allocator,
+    char* VMA_NULLABLE * VMA_NOT_NULL ppStatsString,
+    VkBool32 detailedMap);
+
+VMA_CALL_PRE void VMA_CALL_POST vmaFreeStatsString(
+    VmaAllocator VMA_NOT_NULL allocator,
+    char* VMA_NULLABLE pStatsString);
+
+#endif // #if VMA_STATS_STRING_ENABLED
+
+/** \struct VmaPool
+\brief Represents custom memory pool
+
+Fill structure VmaPoolCreateInfo and call function vmaCreatePool() to create it.
+Call function vmaDestroyPool() to destroy it.
+
+For more information see [Custom memory pools](@ref choosing_memory_type_custom_memory_pools).
+*/
+VK_DEFINE_HANDLE(VmaPool)
+
+typedef enum VmaMemoryUsage
+{
+    /** No intended memory usage specified.
+    Use other members of VmaAllocationCreateInfo to specify your requirements.
+    */
+    VMA_MEMORY_USAGE_UNKNOWN = 0,
+    /** Memory will be used on device only, so fast access from the device is preferred.
+    It usually means device-local GPU (video) memory.
+    No need to be mappable on host.
+    It is roughly equivalent of `D3D12_HEAP_TYPE_DEFAULT`.
+
+    Usage:
+
+    - Resources written and read by device, e.g. images used as attachments.
+    - Resources transferred from host once (immutable) or infrequently and read by
+      device multiple times, e.g. textures to be sampled, vertex buffers, uniform
+      (constant) buffers, and majority of other types of resources used on GPU.
+
+    Allocation may still end up in `HOST_VISIBLE` memory on some implementations.
+    In such case, you are free to map it.
+    You can use #VMA_ALLOCATION_CREATE_MAPPED_BIT with this usage type.
+    */
+    VMA_MEMORY_USAGE_GPU_ONLY = 1,
+    /** Memory will be mappable on host.
+    It usually means CPU (system) memory.
+    Guarantees to be `HOST_VISIBLE` and `HOST_COHERENT`.
+    CPU access is typically uncached. Writes may be write-combined.
+    Resources created in this pool may still be accessible to the device, but access to them can be slow.
+    It is roughly equivalent of `D3D12_HEAP_TYPE_UPLOAD`.
+
+    Usage: Staging copy of resources used as transfer source.
+    */
+    VMA_MEMORY_USAGE_CPU_ONLY = 2,
+    /**
+    Memory that is both mappable on host (guarantees to be `HOST_VISIBLE`) and preferably fast to access by GPU.
+    CPU access is typically uncached. Writes may be write-combined.
+
+    Usage: Resources written frequently by host (dynamic), read by device. E.g. textures (with LINEAR layout), vertex buffers, uniform buffers updated every frame or every draw call.
+    */
+    VMA_MEMORY_USAGE_CPU_TO_GPU = 3,
+    /** Memory mappable on host (guarantees to be `HOST_VISIBLE`) and cached.
+    It is roughly equivalent of `D3D12_HEAP_TYPE_READBACK`.
+
+    Usage:
+
+    - Resources written by device, read by host - results of some computations, e.g. screen capture, average scene luminance for HDR tone mapping.
+    - Any resources read or accessed randomly on host, e.g. CPU-side copy of vertex buffer used as source of transfer, but also used for collision detection.
+    */
+    VMA_MEMORY_USAGE_GPU_TO_CPU = 4,
+    /** CPU memory - memory that is preferably not `DEVICE_LOCAL`, but also not guaranteed to be `HOST_VISIBLE`.
+
+    Usage: Staging copy of resources moved from GPU memory to CPU memory as part
+    of custom paging/residency mechanism, to be moved back to GPU memory when needed.
+    */
+    VMA_MEMORY_USAGE_CPU_COPY = 5,
+    /** Lazily allocated GPU memory having `VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT`.
+    Exists mostly on mobile platforms. Using it on desktop PC or other GPUs with no such memory type present will fail the allocation.
+
+    Usage: Memory for transient attachment images (color attachments, depth attachments etc.), created with `VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT`.
+
+    Allocations with this usage are always created as dedicated - it implies #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT.
+    */
+    VMA_MEMORY_USAGE_GPU_LAZILY_ALLOCATED = 6,
+
+    VMA_MEMORY_USAGE_MAX_ENUM = 0x7FFFFFFF
+} VmaMemoryUsage;
+
+/// Flags to be passed as VmaAllocationCreateInfo::flags.
+typedef enum VmaAllocationCreateFlagBits {
+    /** \brief Set this flag if the allocation should have its own memory block.
+
+    Use it for special, big resources, like fullscreen images used as attachments.
+
+    You should not use this flag if VmaAllocationCreateInfo::pool is not null.
+    */
+    VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT = 0x00000001,
+
+    /** \brief Set this flag to only try to allocate from existing `VkDeviceMemory` blocks and never create new such block.
+
+    If new allocation cannot be placed in any of the existing blocks, allocation
+    fails with `VK_ERROR_OUT_OF_DEVICE_MEMORY` error.
+
+    You should not use #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT and
+    #VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT at the same time. It makes no sense.
+
+    If VmaAllocationCreateInfo::pool is not null, this flag is implied and ignored. */
+    VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT = 0x00000002,
+    /** \brief Set this flag to use a memory that will be persistently mapped and retrieve pointer to it.
+
+    Pointer to mapped memory will be returned through VmaAllocationInfo::pMappedData.
+
+    It is valid to use this flag for allocation made from memory type that is not
+    `HOST_VISIBLE`. This flag is then ignored and memory is not mapped. This is
+    useful if you need an allocation that is efficient to use on GPU
+    (`DEVICE_LOCAL`) and still want to map it directly if possible on platforms that
+    support it (e.g. Intel GPU).
+
+    You should not use this flag together with #VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT.
+    */
+    VMA_ALLOCATION_CREATE_MAPPED_BIT = 0x00000004,
+    /** Allocation created with this flag can become lost as a result of another
+    allocation with #VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT flag, so you
+    must check it before use.
+
+    To check if allocation is not lost, call vmaGetAllocationInfo() and check if
+    VmaAllocationInfo::deviceMemory is not `VK_NULL_HANDLE`.
+
+    For details about supporting lost allocations, see Lost Allocations
+    chapter of User Guide on Main Page.
+
+    You should not use this flag together with #VMA_ALLOCATION_CREATE_MAPPED_BIT.
+    */
+    VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT = 0x00000008,
+    /** While creating allocation using this flag, other allocations that were
+    created with flag #VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT can become lost.
+
+    For details about supporting lost allocations, see Lost Allocations
+    chapter of User Guide on Main Page.
+    */
+    VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT = 0x00000010,
+    /** Set this flag to treat VmaAllocationCreateInfo::pUserData as pointer to a
+    null-terminated string. Instead of copying pointer value, a local copy of the
+    string is made and stored in allocation's `pUserData`. The string is automatically
+    freed together with the allocation. It is also used in vmaBuildStatsString().
+    */
+    VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT = 0x00000020,
+    /** Allocation will be created from upper stack in a double stack pool.
+
+    This flag is only allowed for custom pools created with #VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT flag.
+    */
+    VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT = 0x00000040,
+    /** Create both buffer/image and allocation, but don't bind them together.
+    It is useful when you want to bind yourself to do some more advanced binding, e.g. using some extensions.
+    The flag is meaningful only with functions that bind by default: vmaCreateBuffer(), vmaCreateImage().
+    Otherwise it is ignored.
+    */
+    VMA_ALLOCATION_CREATE_DONT_BIND_BIT = 0x00000080,
+    /** Create allocation only if additional device memory required for it, if any, won't exceed
+    memory budget. Otherwise return `VK_ERROR_OUT_OF_DEVICE_MEMORY`.
+    */
+    VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT = 0x00000100,
+
+    /** Allocation strategy that chooses smallest possible free range for the
+    allocation.
+    */
+    VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT  = 0x00010000,
+    /** Allocation strategy that chooses biggest possible free range for the
+    allocation.
+    */
+    VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT = 0x00020000,
+    /** Allocation strategy that chooses first suitable free range for the
+    allocation.
+
+    "First" doesn't necessarily means the one with smallest offset in memory,
+    but rather the one that is easiest and fastest to find.
+    */
+    VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT = 0x00040000,
+
+    /** Allocation strategy that tries to minimize memory usage.
+    */
+    VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT = VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT,
+    /** Allocation strategy that tries to minimize allocation time.
+    */
+    VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT = VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT,
+    /** Allocation strategy that tries to minimize memory fragmentation.
+    */
+    VMA_ALLOCATION_CREATE_STRATEGY_MIN_FRAGMENTATION_BIT = VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT,
+
+    /** A bit mask to extract only `STRATEGY` bits from entire set of flags.
+    */
+    VMA_ALLOCATION_CREATE_STRATEGY_MASK =
+        VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT |
+        VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT |
+        VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT,
+
+    VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VmaAllocationCreateFlagBits;
+typedef VkFlags VmaAllocationCreateFlags;
+
+typedef struct VmaAllocationCreateInfo
+{
+    /// Use #VmaAllocationCreateFlagBits enum.
+    VmaAllocationCreateFlags flags;
+    /** \brief Intended usage of memory.
+
+    You can leave #VMA_MEMORY_USAGE_UNKNOWN if you specify memory requirements in other way. \n
+    If `pool` is not null, this member is ignored.
+    */
+    VmaMemoryUsage usage;
+    /** \brief Flags that must be set in a Memory Type chosen for an allocation.
+
+    Leave 0 if you specify memory requirements in other way. \n
+    If `pool` is not null, this member is ignored.*/
+    VkMemoryPropertyFlags requiredFlags;
+    /** \brief Flags that preferably should be set in a memory type chosen for an allocation.
+
+    Set to 0 if no additional flags are preferred. \n
+    If `pool` is not null, this member is ignored. */
+    VkMemoryPropertyFlags preferredFlags;
+    /** \brief Bitmask containing one bit set for every memory type acceptable for this allocation.
+
+    Value 0 is equivalent to `UINT32_MAX` - it means any memory type is accepted if
+    it meets other requirements specified by this structure, with no further
+    restrictions on memory type index. \n
+    If `pool` is not null, this member is ignored.
+    */
+    uint32_t memoryTypeBits;
+    /** \brief Pool that this allocation should be created in.
+
+    Leave `VK_NULL_HANDLE` to allocate from default pool. If not null, members:
+    `usage`, `requiredFlags`, `preferredFlags`, `memoryTypeBits` are ignored.
+    */
+    VmaPool VMA_NULLABLE pool;
+    /** \brief Custom general-purpose pointer that will be stored in #VmaAllocation, can be read as VmaAllocationInfo::pUserData and changed using vmaSetAllocationUserData().
+
+    If #VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT is used, it must be either
+    null or pointer to a null-terminated string. The string will be then copied to
+    internal buffer, so it doesn't need to be valid after allocation call.
+    */
+    void* VMA_NULLABLE pUserData;
+    /** \brief A floating-point value between 0 and 1, indicating the priority of the allocation relative to other memory allocations.
+    
+    It is used only when #VMA_ALLOCATOR_CREATE_EXT_MEMORY_PRIORITY_BIT flag was used during creation of the #VmaAllocator object
+    and this allocation ends up as dedicated or is explicitly forced as dedicated using #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT.
+    Otherwise, it has the priority of a memory block where it is placed and this variable is ignored.
+    */
+    float priority;
+} VmaAllocationCreateInfo;
+
+/**
+\brief Helps to find memoryTypeIndex, given memoryTypeBits and VmaAllocationCreateInfo.
+
+This algorithm tries to find a memory type that:
+
+- Is allowed by memoryTypeBits.
+- Contains all the flags from pAllocationCreateInfo->requiredFlags.
+- Matches intended usage.
+- Has as many flags from pAllocationCreateInfo->preferredFlags as possible.
+
+\return Returns VK_ERROR_FEATURE_NOT_PRESENT if not found. Receiving such result
+from this function or any other allocating function probably means that your
+device doesn't support any memory type with requested features for the specific
+type of resource you want to use it for. Please check parameters of your
+resource, like image layout (OPTIMAL versus LINEAR) or mip level count.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndex(
+    VmaAllocator VMA_NOT_NULL allocator,
+    uint32_t memoryTypeBits,
+    const VmaAllocationCreateInfo* VMA_NOT_NULL pAllocationCreateInfo,
+    uint32_t* VMA_NOT_NULL pMemoryTypeIndex);
+
+/**
+\brief Helps to find memoryTypeIndex, given VkBufferCreateInfo and VmaAllocationCreateInfo.
+
+It can be useful e.g. to determine value to be used as VmaPoolCreateInfo::memoryTypeIndex.
+It internally creates a temporary, dummy buffer that never has memory bound.
+It is just a convenience function, equivalent to calling:
+
+- `vkCreateBuffer`
+- `vkGetBufferMemoryRequirements`
+- `vmaFindMemoryTypeIndex`
+- `vkDestroyBuffer`
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForBufferInfo(
+    VmaAllocator VMA_NOT_NULL allocator,
+    const VkBufferCreateInfo* VMA_NOT_NULL pBufferCreateInfo,
+    const VmaAllocationCreateInfo* VMA_NOT_NULL pAllocationCreateInfo,
+    uint32_t* VMA_NOT_NULL pMemoryTypeIndex);
+
+/**
+\brief Helps to find memoryTypeIndex, given VkImageCreateInfo and VmaAllocationCreateInfo.
+
+It can be useful e.g. to determine value to be used as VmaPoolCreateInfo::memoryTypeIndex.
+It internally creates a temporary, dummy image that never has memory bound.
+It is just a convenience function, equivalent to calling:
+
+- `vkCreateImage`
+- `vkGetImageMemoryRequirements`
+- `vmaFindMemoryTypeIndex`
+- `vkDestroyImage`
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForImageInfo(
+    VmaAllocator VMA_NOT_NULL allocator,
+    const VkImageCreateInfo* VMA_NOT_NULL pImageCreateInfo,
+    const VmaAllocationCreateInfo* VMA_NOT_NULL pAllocationCreateInfo,
+    uint32_t* VMA_NOT_NULL pMemoryTypeIndex);
+
+/// Flags to be passed as VmaPoolCreateInfo::flags.
+typedef enum VmaPoolCreateFlagBits {
+    /** \brief Use this flag if you always allocate only buffers and linear images or only optimal images out of this pool and so Buffer-Image Granularity can be ignored.
+
+    This is an optional optimization flag.
+
+    If you always allocate using vmaCreateBuffer(), vmaCreateImage(),
+    vmaAllocateMemoryForBuffer(), then you don't need to use it because allocator
+    knows exact type of your allocations so it can handle Buffer-Image Granularity
+    in the optimal way.
+
+    If you also allocate using vmaAllocateMemoryForImage() or vmaAllocateMemory(),
+    exact type of such allocations is not known, so allocator must be conservative
+    in handling Buffer-Image Granularity, which can lead to suboptimal allocation
+    (wasted memory). In that case, if you can make sure you always allocate only
+    buffers and linear images or only optimal images out of this pool, use this flag
+    to make allocator disregard Buffer-Image Granularity and so make allocations
+    faster and more optimal.
+    */
+    VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT = 0x00000002,
+
+    /** \brief Enables alternative, linear allocation algorithm in this pool.
+
+    Specify this flag to enable linear allocation algorithm, which always creates
+    new allocations after last one and doesn't reuse space from allocations freed in
+    between. It trades memory consumption for simplified algorithm and data
+    structure, which has better performance and uses less memory for metadata.
+
+    By using this flag, you can achieve behavior of free-at-once, stack,
+    ring buffer, and double stack. For details, see documentation chapter
+    \ref linear_algorithm.
+
+    When using this flag, you must specify VmaPoolCreateInfo::maxBlockCount == 1 (or 0 for default).
+
+    For more details, see [Linear allocation algorithm](@ref linear_algorithm).
+    */
+    VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT = 0x00000004,
+
+    /** \brief Enables alternative, buddy allocation algorithm in this pool.
+
+    It operates on a tree of blocks, each having size that is a power of two and
+    a half of its parent's size. Comparing to default algorithm, this one provides
+    faster allocation and deallocation and decreased external fragmentation,
+    at the expense of more memory wasted (internal fragmentation).
+
+    For more details, see [Buddy allocation algorithm](@ref buddy_algorithm).
+    */
+    VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT = 0x00000008,
+
+    /** Bit mask to extract only `ALGORITHM` bits from entire set of flags.
+    */
+    VMA_POOL_CREATE_ALGORITHM_MASK =
+        VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT |
+        VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT,
+
+    VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VmaPoolCreateFlagBits;
+typedef VkFlags VmaPoolCreateFlags;
+
+/** \brief Describes parameter of created #VmaPool.
+*/
+typedef struct VmaPoolCreateInfo {
+    /** \brief Vulkan memory type index to allocate this pool from.
+    */
+    uint32_t memoryTypeIndex;
+    /** \brief Use combination of #VmaPoolCreateFlagBits.
+    */
+    VmaPoolCreateFlags flags;
+    /** \brief Size of a single `VkDeviceMemory` block to be allocated as part of this pool, in bytes. Optional.
+
+    Specify nonzero to set explicit, constant size of memory blocks used by this
+    pool.
+
+    Leave 0 to use default and let the library manage block sizes automatically.
+    Sizes of particular blocks may vary.
+    */
+    VkDeviceSize blockSize;
+    /** \brief Minimum number of blocks to be always allocated in this pool, even if they stay empty.
+
+    Set to 0 to have no preallocated blocks and allow the pool be completely empty.
+    */
+    size_t minBlockCount;
+    /** \brief Maximum number of blocks that can be allocated in this pool. Optional.
+
+    Set to 0 to use default, which is `SIZE_MAX`, which means no limit.
+
+    Set to same value as VmaPoolCreateInfo::minBlockCount to have fixed amount of memory allocated
+    throughout whole lifetime of this pool.
+    */
+    size_t maxBlockCount;
+    /** \brief Maximum number of additional frames that are in use at the same time as current frame.
+
+    This value is used only when you make allocations with
+    #VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT flag. Such allocation cannot become
+    lost if allocation.lastUseFrameIndex >= allocator.currentFrameIndex - frameInUseCount.
+
+    For example, if you double-buffer your command buffers, so resources used for
+    rendering in previous frame may still be in use by the GPU at the moment you
+    allocate resources needed for the current frame, set this value to 1.
+
+    If you want to allow any allocations other than used in the current frame to
+    become lost, set this value to 0.
+    */
+    uint32_t frameInUseCount;
+    /** \brief A floating-point value between 0 and 1, indicating the priority of the allocations in this pool relative to other memory allocations.
+
+    It is used only when #VMA_ALLOCATOR_CREATE_EXT_MEMORY_PRIORITY_BIT flag was used during creation of the #VmaAllocator object.
+    Otherwise, this variable is ignored.
+    */
+    float priority;
+} VmaPoolCreateInfo;
+
+/** \brief Describes parameter of existing #VmaPool.
+*/
+typedef struct VmaPoolStats {
+    /** \brief Total amount of `VkDeviceMemory` allocated from Vulkan for this pool, in bytes.
+    */
+    VkDeviceSize size;
+    /** \brief Total number of bytes in the pool not used by any #VmaAllocation.
+    */
+    VkDeviceSize unusedSize;
+    /** \brief Number of #VmaAllocation objects created from this pool that were not destroyed or lost.
+    */
+    size_t allocationCount;
+    /** \brief Number of continuous memory ranges in the pool not used by any #VmaAllocation.
+    */
+    size_t unusedRangeCount;
+    /** \brief Size of the largest continuous free memory region available for new allocation.
+
+    Making a new allocation of that size is not guaranteed to succeed because of
+    possible additional margin required to respect alignment and buffer/image
+    granularity.
+    */
+    VkDeviceSize unusedRangeSizeMax;
+    /** \brief Number of `VkDeviceMemory` blocks allocated for this pool.
+    */
+    size_t blockCount;
+} VmaPoolStats;
+
+/** \brief Allocates Vulkan device memory and creates #VmaPool object.
+
+@param allocator Allocator object.
+@param pCreateInfo Parameters of pool to create.
+@param[out] pPool Handle to created pool.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreatePool(
+    VmaAllocator VMA_NOT_NULL allocator,
+    const VmaPoolCreateInfo* VMA_NOT_NULL pCreateInfo,
+    VmaPool VMA_NULLABLE * VMA_NOT_NULL pPool);
+
+/** \brief Destroys #VmaPool object and frees Vulkan device memory.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaDestroyPool(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaPool VMA_NULLABLE pool);
+
+/** \brief Retrieves statistics of existing #VmaPool object.
+
+@param allocator Allocator object.
+@param pool Pool object.
+@param[out] pPoolStats Statistics of specified pool.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaGetPoolStats(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaPool VMA_NOT_NULL pool,
+    VmaPoolStats* VMA_NOT_NULL pPoolStats);
+
+/** \brief Marks all allocations in given pool as lost if they are not used in current frame or VmaPoolCreateInfo::frameInUseCount back from now.
+
+@param allocator Allocator object.
+@param pool Pool.
+@param[out] pLostAllocationCount Number of allocations marked as lost. Optional - pass null if you don't need this information.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaMakePoolAllocationsLost(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaPool VMA_NOT_NULL pool,
+    size_t* VMA_NULLABLE pLostAllocationCount);
+
+/** \brief Checks magic number in margins around all allocations in given memory pool in search for corruptions.
+
+Corruption detection is enabled only when `VMA_DEBUG_DETECT_CORRUPTION` macro is defined to nonzero,
+`VMA_DEBUG_MARGIN` is defined to nonzero and the pool is created in memory type that is
+`HOST_VISIBLE` and `HOST_COHERENT`. For more information, see [Corruption detection](@ref debugging_memory_usage_corruption_detection).
+
+Possible return values:
+
+- `VK_ERROR_FEATURE_NOT_PRESENT` - corruption detection is not enabled for specified pool.
+- `VK_SUCCESS` - corruption detection has been performed and succeeded.
+- `VK_ERROR_VALIDATION_FAILED_EXT` - corruption detection has been performed and found memory corruptions around one of the allocations.
+  `VMA_ASSERT` is also fired in that case.
+- Other value: Error returned by Vulkan, e.g. memory mapping failure.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckPoolCorruption(VmaAllocator VMA_NOT_NULL allocator, VmaPool VMA_NOT_NULL pool);
+
+/** \brief Retrieves name of a custom pool.
+
+After the call `ppName` is either null or points to an internally-owned null-terminated string
+containing name of the pool that was previously set. The pointer becomes invalid when the pool is
+destroyed or its name is changed using vmaSetPoolName().
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaGetPoolName(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaPool VMA_NOT_NULL pool,
+    const char* VMA_NULLABLE * VMA_NOT_NULL ppName);
+
+/** \brief Sets name of a custom pool.
+
+`pName` can be either null or pointer to a null-terminated string with new name for the pool.
+Function makes internal copy of the string, so it can be changed or freed immediately after this call.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaSetPoolName(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaPool VMA_NOT_NULL pool,
+    const char* VMA_NULLABLE pName);
+
+/** \struct VmaAllocation
+\brief Represents single memory allocation.
+
+It may be either dedicated block of `VkDeviceMemory` or a specific region of a bigger block of this type
+plus unique offset.
+
+There are multiple ways to create such object.
+You need to fill structure VmaAllocationCreateInfo.
+For more information see [Choosing memory type](@ref choosing_memory_type).
+
+Although the library provides convenience functions that create Vulkan buffer or image,
+allocate memory for it and bind them together,
+binding of the allocation to a buffer or an image is out of scope of the allocation itself.
+Allocation object can exist without buffer/image bound,
+binding can be done manually by the user, and destruction of it can be done
+independently of destruction of the allocation.
+
+The object also remembers its size and some other information.
+To retrieve this information, use function vmaGetAllocationInfo() and inspect
+returned structure VmaAllocationInfo.
+
+Some kinds allocations can be in lost state.
+For more information, see [Lost allocations](@ref lost_allocations).
+*/
+VK_DEFINE_HANDLE(VmaAllocation)
+
+/** \brief Parameters of #VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
+*/
+typedef struct VmaAllocationInfo {
+    /** \brief Memory type index that this allocation was allocated from.
+
+    It never changes.
+    */
+    uint32_t memoryType;
+    /** \brief Handle to Vulkan memory object.
+
+    Same memory object can be shared by multiple allocations.
+
+    It can change after call to vmaDefragment() if this allocation is passed to the function, or if allocation is lost.
+
+    If the allocation is lost, it is equal to `VK_NULL_HANDLE`.
+    */
+    VkDeviceMemory VMA_NULLABLE_NON_DISPATCHABLE deviceMemory;
+    /** \brief Offset in `VkDeviceMemory` object to the beginning of this allocation, in bytes. `(deviceMemory, offset)` pair is unique to this allocation.
+
+    You usually don't need to use this offset. If you create a buffer or an image together with the allocation using e.g. function
+    vmaCreateBuffer(), vmaCreateImage(), functions that operate on these resources refer to the beginning of the buffer or image,
+    not entire device memory block. Functions like vmaMapMemory(), vmaBindBufferMemory() also refer to the beginning of the allocation
+    and apply this offset automatically.
+
+    It can change after call to vmaDefragment() if this allocation is passed to the function, or if allocation is lost.
+    */
+    VkDeviceSize offset;
+    /** \brief Size of this allocation, in bytes.
+
+    It never changes, unless allocation is lost.
+
+    \note Allocation size returned in this variable may be greater than the size
+    requested for the resource e.g. as `VkBufferCreateInfo::size`. Whole size of the
+    allocation is accessible for operations on memory e.g. using a pointer after
+    mapping with vmaMapMemory(), but operations on the resource e.g. using
+    `vkCmdCopyBuffer` must be limited to the size of the resource.
+    */
+    VkDeviceSize size;
+    /** \brief Pointer to the beginning of this allocation as mapped data.
+
+    If the allocation hasn't been mapped using vmaMapMemory() and hasn't been
+    created with #VMA_ALLOCATION_CREATE_MAPPED_BIT flag, this value is null.
+
+    It can change after call to vmaMapMemory(), vmaUnmapMemory().
+    It can also change after call to vmaDefragment() if this allocation is passed to the function.
+    */
+    void* VMA_NULLABLE pMappedData;
+    /** \brief Custom general-purpose pointer that was passed as VmaAllocationCreateInfo::pUserData or set using vmaSetAllocationUserData().
+
+    It can change after call to vmaSetAllocationUserData() for this allocation.
+    */
+    void* VMA_NULLABLE pUserData;
+} VmaAllocationInfo;
+
+/** \brief General purpose memory allocation.
+
+@param[out] pAllocation Handle to allocated memory.
+@param[out] pAllocationInfo Optional. Information about allocated memory. It can be later fetched using function vmaGetAllocationInfo().
+
+You should free the memory using vmaFreeMemory() or vmaFreeMemoryPages().
+
+It is recommended to use vmaAllocateMemoryForBuffer(), vmaAllocateMemoryForImage(),
+vmaCreateBuffer(), vmaCreateImage() instead whenever possible.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemory(
+    VmaAllocator VMA_NOT_NULL allocator,
+    const VkMemoryRequirements* VMA_NOT_NULL pVkMemoryRequirements,
+    const VmaAllocationCreateInfo* VMA_NOT_NULL pCreateInfo,
+    VmaAllocation VMA_NULLABLE * VMA_NOT_NULL pAllocation,
+    VmaAllocationInfo* VMA_NULLABLE pAllocationInfo);
+
+/** \brief General purpose memory allocation for multiple allocation objects at once.
+
+@param allocator Allocator object.
+@param pVkMemoryRequirements Memory requirements for each allocation.
+@param pCreateInfo Creation parameters for each alloction.
+@param allocationCount Number of allocations to make.
+@param[out] pAllocations Pointer to array that will be filled with handles to created allocations.
+@param[out] pAllocationInfo Optional. Pointer to array that will be filled with parameters of created allocations.
+
+You should free the memory using vmaFreeMemory() or vmaFreeMemoryPages().
+
+Word "pages" is just a suggestion to use this function to allocate pieces of memory needed for sparse binding.
+It is just a general purpose allocation function able to make multiple allocations at once.
+It may be internally optimized to be more efficient than calling vmaAllocateMemory() `allocationCount` times.
+
+All allocations are made using same parameters. All of them are created out of the same memory pool and type.
+If any allocation fails, all allocations already made within this function call are also freed, so that when
+returned result is not `VK_SUCCESS`, `pAllocation` array is always entirely filled with `VK_NULL_HANDLE`.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryPages(
+    VmaAllocator VMA_NOT_NULL allocator,
+    const VkMemoryRequirements* VMA_NOT_NULL VMA_LEN_IF_NOT_NULL(allocationCount) pVkMemoryRequirements,
+    const VmaAllocationCreateInfo* VMA_NOT_NULL VMA_LEN_IF_NOT_NULL(allocationCount) pCreateInfo,
+    size_t allocationCount,
+    VmaAllocation VMA_NULLABLE * VMA_NOT_NULL VMA_LEN_IF_NOT_NULL(allocationCount) pAllocations,
+    VmaAllocationInfo* VMA_NULLABLE VMA_LEN_IF_NOT_NULL(allocationCount) pAllocationInfo);
+
+/**
+@param[out] pAllocation Handle to allocated memory.
+@param[out] pAllocationInfo Optional. Information about allocated memory. It can be later fetched using function vmaGetAllocationInfo().
+
+You should free the memory using vmaFreeMemory().
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForBuffer(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VkBuffer VMA_NOT_NULL_NON_DISPATCHABLE buffer,
+    const VmaAllocationCreateInfo* VMA_NOT_NULL pCreateInfo,
+    VmaAllocation VMA_NULLABLE * VMA_NOT_NULL pAllocation,
+    VmaAllocationInfo* VMA_NULLABLE pAllocationInfo);
+
+/// Function similar to vmaAllocateMemoryForBuffer().
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForImage(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VkImage VMA_NOT_NULL_NON_DISPATCHABLE image,
+    const VmaAllocationCreateInfo* VMA_NOT_NULL pCreateInfo,
+    VmaAllocation VMA_NULLABLE * VMA_NOT_NULL pAllocation,
+    VmaAllocationInfo* VMA_NULLABLE pAllocationInfo);
+
+/** \brief Frees memory previously allocated using vmaAllocateMemory(), vmaAllocateMemoryForBuffer(), or vmaAllocateMemoryForImage().
+
+Passing `VK_NULL_HANDLE` as `allocation` is valid. Such function call is just skipped.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemory(
+    VmaAllocator VMA_NOT_NULL allocator,
+    const VmaAllocation VMA_NULLABLE allocation);
+
+/** \brief Frees memory and destroys multiple allocations.
+
+Word "pages" is just a suggestion to use this function to free pieces of memory used for sparse binding.
+It is just a general purpose function to free memory and destroy allocations made using e.g. vmaAllocateMemory(),
+vmaAllocateMemoryPages() and other functions.
+It may be internally optimized to be more efficient than calling vmaFreeMemory() `allocationCount` times.
+
+Allocations in `pAllocations` array can come from any memory pools and types.
+Passing `VK_NULL_HANDLE` as elements of `pAllocations` array is valid. Such entries are just skipped.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemoryPages(
+    VmaAllocator VMA_NOT_NULL allocator,
+    size_t allocationCount,
+    const VmaAllocation VMA_NULLABLE * VMA_NOT_NULL VMA_LEN_IF_NOT_NULL(allocationCount) pAllocations);
+
+/** \brief Deprecated.
+
+\deprecated
+In version 2.2.0 it used to try to change allocation's size without moving or reallocating it.
+In current version it returns `VK_SUCCESS` only if `newSize` equals current allocation's size.
+Otherwise returns `VK_ERROR_OUT_OF_POOL_MEMORY`, indicating that allocation's size could not be changed.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaResizeAllocation(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL allocation,
+    VkDeviceSize newSize);
+
+/** \brief Returns current information about specified allocation and atomically marks it as used in current frame.
+
+Current paramteres of given allocation are returned in `pAllocationInfo`.
+
+This function also atomically "touches" allocation - marks it as used in current frame,
+just like vmaTouchAllocation().
+If the allocation is in lost state, `pAllocationInfo->deviceMemory == VK_NULL_HANDLE`.
+
+Although this function uses atomics and doesn't lock any mutex, so it should be quite efficient,
+you can avoid calling it too often.
+
+- You can retrieve same VmaAllocationInfo structure while creating your resource, from function
+  vmaCreateBuffer(), vmaCreateImage(). You can remember it if you are sure parameters don't change
+  (e.g. due to defragmentation or allocation becoming lost).
+- If you just want to check if allocation is not lost, vmaTouchAllocation() will work faster.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaGetAllocationInfo(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL allocation,
+    VmaAllocationInfo* VMA_NOT_NULL pAllocationInfo);
+
+/** \brief Returns `VK_TRUE` if allocation is not lost and atomically marks it as used in current frame.
+
+If the allocation has been created with #VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT flag,
+this function returns `VK_TRUE` if it's not in lost state, so it can still be used.
+It then also atomically "touches" the allocation - marks it as used in current frame,
+so that you can be sure it won't become lost in current frame or next `frameInUseCount` frames.
+
+If the allocation is in lost state, the function returns `VK_FALSE`.
+Memory of such allocation, as well as buffer or image bound to it, should not be used.
+Lost allocation and the buffer/image still need to be destroyed.
+
+If the allocation has been created without #VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT flag,
+this function always returns `VK_TRUE`.
+*/
+VMA_CALL_PRE VkBool32 VMA_CALL_POST vmaTouchAllocation(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL allocation);
+
+/** \brief Sets pUserData in given allocation to new value.
+
+If the allocation was created with VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT,
+pUserData must be either null, or pointer to a null-terminated string. The function
+makes local copy of the string and sets it as allocation's `pUserData`. String
+passed as pUserData doesn't need to be valid for whole lifetime of the allocation -
+you can free it after this call. String previously pointed by allocation's
+pUserData is freed from memory.
+
+If the flag was not used, the value of pointer `pUserData` is just copied to
+allocation's `pUserData`. It is opaque, so you can use it however you want - e.g.
+as a pointer, ordinal number or some handle to you own data.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaSetAllocationUserData(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL allocation,
+    void* VMA_NULLABLE pUserData);
+
+/** \brief Creates new allocation that is in lost state from the beginning.
+
+It can be useful if you need a dummy, non-null allocation.
+
+You still need to destroy created object using vmaFreeMemory().
+
+Returned allocation is not tied to any specific memory pool or memory type and
+not bound to any image or buffer. It has size = 0. It cannot be turned into
+a real, non-empty allocation.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaCreateLostAllocation(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NULLABLE * VMA_NOT_NULL pAllocation);
+
+/** \brief Maps memory represented by given allocation and returns pointer to it.
+
+Maps memory represented by given allocation to make it accessible to CPU code.
+When succeeded, `*ppData` contains pointer to first byte of this memory.
+If the allocation is part of bigger `VkDeviceMemory` block, the pointer is
+correctly offseted to the beginning of region assigned to this particular
+allocation.
+
+Mapping is internally reference-counted and synchronized, so despite raw Vulkan
+function `vkMapMemory()` cannot be used to map same block of `VkDeviceMemory`
+multiple times simultaneously, it is safe to call this function on allocations
+assigned to the same memory block. Actual Vulkan memory will be mapped on first
+mapping and unmapped on last unmapping.
+
+If the function succeeded, you must call vmaUnmapMemory() to unmap the
+allocation when mapping is no longer needed or before freeing the allocation, at
+the latest.
+
+It also safe to call this function multiple times on the same allocation. You
+must call vmaUnmapMemory() same number of times as you called vmaMapMemory().
+
+It is also safe to call this function on allocation created with
+#VMA_ALLOCATION_CREATE_MAPPED_BIT flag. Its memory stays mapped all the time.
+You must still call vmaUnmapMemory() same number of times as you called
+vmaMapMemory(). You must not call vmaUnmapMemory() additional time to free the
+"0-th" mapping made automatically due to #VMA_ALLOCATION_CREATE_MAPPED_BIT flag.
+
+This function fails when used on allocation made in memory type that is not
+`HOST_VISIBLE`.
+
+This function always fails when called for allocation that was created with
+#VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT flag. Such allocations cannot be
+mapped.
+
+This function doesn't automatically flush or invalidate caches.
+If the allocation is made from a memory types that is not `HOST_COHERENT`,
+you also need to use vmaInvalidateAllocation() / vmaFlushAllocation(), as required by Vulkan specification.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaMapMemory(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL allocation,
+    void* VMA_NULLABLE * VMA_NOT_NULL ppData);
+
+/** \brief Unmaps memory represented by given allocation, mapped previously using vmaMapMemory().
+
+For details, see description of vmaMapMemory().
+
+This function doesn't automatically flush or invalidate caches.
+If the allocation is made from a memory types that is not `HOST_COHERENT`,
+you also need to use vmaInvalidateAllocation() / vmaFlushAllocation(), as required by Vulkan specification.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaUnmapMemory(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL allocation);
+
+/** \brief Flushes memory of given allocation.
+
+Calls `vkFlushMappedMemoryRanges()` for memory associated with given range of given allocation.
+It needs to be called after writing to a mapped memory for memory types that are not `HOST_COHERENT`.
+Unmap operation doesn't do that automatically.
+
+- `offset` must be relative to the beginning of allocation.
+- `size` can be `VK_WHOLE_SIZE`. It means all memory from `offset` the the end of given allocation.
+- `offset` and `size` don't have to be aligned.
+  They are internally rounded down/up to multiply of `nonCoherentAtomSize`.
+- If `size` is 0, this call is ignored.
+- If memory type that the `allocation` belongs to is not `HOST_VISIBLE` or it is `HOST_COHERENT`,
+  this call is ignored.
+
+Warning! `offset` and `size` are relative to the contents of given `allocation`.
+If you mean whole allocation, you can pass 0 and `VK_WHOLE_SIZE`, respectively.
+Do not pass allocation's offset as `offset`!!!
+
+This function returns the `VkResult` from `vkFlushMappedMemoryRanges` if it is
+called, otherwise `VK_SUCCESS`.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaFlushAllocation(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL allocation,
+    VkDeviceSize offset,
+    VkDeviceSize size);
+
+/** \brief Invalidates memory of given allocation.
+
+Calls `vkInvalidateMappedMemoryRanges()` for memory associated with given range of given allocation.
+It needs to be called before reading from a mapped memory for memory types that are not `HOST_COHERENT`.
+Map operation doesn't do that automatically.
+
+- `offset` must be relative to the beginning of allocation.
+- `size` can be `VK_WHOLE_SIZE`. It means all memory from `offset` the the end of given allocation.
+- `offset` and `size` don't have to be aligned.
+  They are internally rounded down/up to multiply of `nonCoherentAtomSize`.
+- If `size` is 0, this call is ignored.
+- If memory type that the `allocation` belongs to is not `HOST_VISIBLE` or it is `HOST_COHERENT`,
+  this call is ignored.
+
+Warning! `offset` and `size` are relative to the contents of given `allocation`.
+If you mean whole allocation, you can pass 0 and `VK_WHOLE_SIZE`, respectively.
+Do not pass allocation's offset as `offset`!!!
+
+This function returns the `VkResult` from `vkInvalidateMappedMemoryRanges` if
+it is called, otherwise `VK_SUCCESS`.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaInvalidateAllocation(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL allocation,
+    VkDeviceSize offset,
+    VkDeviceSize size);
+
+/** \brief Flushes memory of given set of allocations.
+
+Calls `vkFlushMappedMemoryRanges()` for memory associated with given ranges of given allocations.
+For more information, see documentation of vmaFlushAllocation().
+
+\param allocator
+\param allocationCount
+\param allocations
+\param offsets If not null, it must point to an array of offsets of regions to flush, relative to the beginning of respective allocations. Null means all ofsets are zero.
+\param sizes If not null, it must point to an array of sizes of regions to flush in respective allocations. Null means `VK_WHOLE_SIZE` for all allocations.
+
+This function returns the `VkResult` from `vkFlushMappedMemoryRanges` if it is
+called, otherwise `VK_SUCCESS`.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaFlushAllocations(
+    VmaAllocator VMA_NOT_NULL allocator,
+    uint32_t allocationCount,
+    const VmaAllocation VMA_NOT_NULL * VMA_NULLABLE VMA_LEN_IF_NOT_NULL(allocationCount) allocations,
+    const VkDeviceSize* VMA_NULLABLE VMA_LEN_IF_NOT_NULL(allocationCount) offsets,
+    const VkDeviceSize* VMA_NULLABLE VMA_LEN_IF_NOT_NULL(allocationCount) sizes);
+
+/** \brief Invalidates memory of given set of allocations.
+
+Calls `vkInvalidateMappedMemoryRanges()` for memory associated with given ranges of given allocations.
+For more information, see documentation of vmaInvalidateAllocation().
+
+\param allocator
+\param allocationCount
+\param allocations
+\param offsets If not null, it must point to an array of offsets of regions to flush, relative to the beginning of respective allocations. Null means all ofsets are zero.
+\param sizes If not null, it must point to an array of sizes of regions to flush in respective allocations. Null means `VK_WHOLE_SIZE` for all allocations.
+
+This function returns the `VkResult` from `vkInvalidateMappedMemoryRanges` if it is
+called, otherwise `VK_SUCCESS`.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaInvalidateAllocations(
+    VmaAllocator VMA_NOT_NULL allocator,
+    uint32_t allocationCount,
+    const VmaAllocation VMA_NOT_NULL * VMA_NULLABLE VMA_LEN_IF_NOT_NULL(allocationCount) allocations,
+    const VkDeviceSize* VMA_NULLABLE VMA_LEN_IF_NOT_NULL(allocationCount) offsets,
+    const VkDeviceSize* VMA_NULLABLE VMA_LEN_IF_NOT_NULL(allocationCount) sizes);
+
+/** \brief Checks magic number in margins around all allocations in given memory types (in both default and custom pools) in search for corruptions.
+
+@param memoryTypeBits Bit mask, where each bit set means that a memory type with that index should be checked.
+
+Corruption detection is enabled only when `VMA_DEBUG_DETECT_CORRUPTION` macro is defined to nonzero,
+`VMA_DEBUG_MARGIN` is defined to nonzero and only for memory types that are
+`HOST_VISIBLE` and `HOST_COHERENT`. For more information, see [Corruption detection](@ref debugging_memory_usage_corruption_detection).
+
+Possible return values:
+
+- `VK_ERROR_FEATURE_NOT_PRESENT` - corruption detection is not enabled for any of specified memory types.
+- `VK_SUCCESS` - corruption detection has been performed and succeeded.
+- `VK_ERROR_VALIDATION_FAILED_EXT` - corruption detection has been performed and found memory corruptions around one of the allocations.
+  `VMA_ASSERT` is also fired in that case.
+- Other value: Error returned by Vulkan, e.g. memory mapping failure.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckCorruption(VmaAllocator VMA_NOT_NULL allocator, uint32_t memoryTypeBits);
+
+/** \struct VmaDefragmentationContext
+\brief Represents Opaque object that represents started defragmentation process.
+
+Fill structure #VmaDefragmentationInfo2 and call function vmaDefragmentationBegin() to create it.
+Call function vmaDefragmentationEnd() to destroy it.
+*/
+VK_DEFINE_HANDLE(VmaDefragmentationContext)
+
+/// Flags to be used in vmaDefragmentationBegin(). None at the moment. Reserved for future use.
+typedef enum VmaDefragmentationFlagBits {
+    VMA_DEFRAGMENTATION_FLAG_INCREMENTAL = 0x1,
+    VMA_DEFRAGMENTATION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VmaDefragmentationFlagBits;
+typedef VkFlags VmaDefragmentationFlags;
+
+/** \brief Parameters for defragmentation.
+
+To be used with function vmaDefragmentationBegin().
+*/
+typedef struct VmaDefragmentationInfo2 {
+    /** \brief Reserved for future use. Should be 0.
+    */
+    VmaDefragmentationFlags flags;
+    /** \brief Number of allocations in `pAllocations` array.
+    */
+    uint32_t allocationCount;
+    /** \brief Pointer to array of allocations that can be defragmented.
+
+    The array should have `allocationCount` elements.
+    The array should not contain nulls.
+    Elements in the array should be unique - same allocation cannot occur twice.
+    It is safe to pass allocations that are in the lost state - they are ignored.
+    All allocations not present in this array are considered non-moveable during this defragmentation.
+    */
+    const VmaAllocation VMA_NOT_NULL * VMA_NULLABLE VMA_LEN_IF_NOT_NULL(allocationCount) pAllocations;
+    /** \brief Optional, output. Pointer to array that will be filled with information whether the allocation at certain index has been changed during defragmentation.
+
+    The array should have `allocationCount` elements.
+    You can pass null if you are not interested in this information.
+    */
+    VkBool32* VMA_NULLABLE VMA_LEN_IF_NOT_NULL(allocationCount) pAllocationsChanged;
+    /** \brief Numer of pools in `pPools` array.
+    */
+    uint32_t poolCount;
+    /** \brief Either null or pointer to array of pools to be defragmented.
+
+    All the allocations in the specified pools can be moved during defragmentation
+    and there is no way to check if they were really moved as in `pAllocationsChanged`,
+    so you must query all the allocations in all these pools for new `VkDeviceMemory`
+    and offset using vmaGetAllocationInfo() if you might need to recreate buffers
+    and images bound to them.
+
+    The array should have `poolCount` elements.
+    The array should not contain nulls.
+    Elements in the array should be unique - same pool cannot occur twice.
+
+    Using this array is equivalent to specifying all allocations from the pools in `pAllocations`.
+    It might be more efficient.
+    */
+    const VmaPool VMA_NOT_NULL * VMA_NULLABLE VMA_LEN_IF_NOT_NULL(poolCount) pPools;
+    /** \brief Maximum total numbers of bytes that can be copied while moving allocations to different places using transfers on CPU side, like `memcpy()`, `memmove()`.
+
+    `VK_WHOLE_SIZE` means no limit.
+    */
+    VkDeviceSize maxCpuBytesToMove;
+    /** \brief Maximum number of allocations that can be moved to a different place using transfers on CPU side, like `memcpy()`, `memmove()`.
+
+    `UINT32_MAX` means no limit.
+    */
+    uint32_t maxCpuAllocationsToMove;
+    /** \brief Maximum total numbers of bytes that can be copied while moving allocations to different places using transfers on GPU side, posted to `commandBuffer`.
+
+    `VK_WHOLE_SIZE` means no limit.
+    */
+    VkDeviceSize maxGpuBytesToMove;
+    /** \brief Maximum number of allocations that can be moved to a different place using transfers on GPU side, posted to `commandBuffer`.
+
+    `UINT32_MAX` means no limit.
+    */
+    uint32_t maxGpuAllocationsToMove;
+    /** \brief Optional. Command buffer where GPU copy commands will be posted.
+
+    If not null, it must be a valid command buffer handle that supports Transfer queue type.
+    It must be in the recording state and outside of a render pass instance.
+    You need to submit it and make sure it finished execution before calling vmaDefragmentationEnd().
+
+    Passing null means that only CPU defragmentation will be performed.
+    */
+    VkCommandBuffer VMA_NULLABLE commandBuffer;
+} VmaDefragmentationInfo2;
+
+typedef struct VmaDefragmentationPassMoveInfo {
+    VmaAllocation VMA_NOT_NULL allocation;
+    VkDeviceMemory VMA_NOT_NULL_NON_DISPATCHABLE memory;
+    VkDeviceSize offset;
+} VmaDefragmentationPassMoveInfo;
+
+/** \brief Parameters for incremental defragmentation steps.
+
+To be used with function vmaBeginDefragmentationPass().
+*/
+typedef struct VmaDefragmentationPassInfo {
+    uint32_t moveCount;
+    VmaDefragmentationPassMoveInfo* VMA_NOT_NULL VMA_LEN_IF_NOT_NULL(moveCount) pMoves;
+} VmaDefragmentationPassInfo;
+
+/** \brief Deprecated. Optional configuration parameters to be passed to function vmaDefragment().
+
+\deprecated This is a part of the old interface. It is recommended to use structure #VmaDefragmentationInfo2 and function vmaDefragmentationBegin() instead.
+*/
+typedef struct VmaDefragmentationInfo {
+    /** \brief Maximum total numbers of bytes that can be copied while moving allocations to different places.
+
+    Default is `VK_WHOLE_SIZE`, which means no limit.
+    */
+    VkDeviceSize maxBytesToMove;
+    /** \brief Maximum number of allocations that can be moved to different place.
+
+    Default is `UINT32_MAX`, which means no limit.
+    */
+    uint32_t maxAllocationsToMove;
+} VmaDefragmentationInfo;
+
+/** \brief Statistics returned by function vmaDefragment(). */
+typedef struct VmaDefragmentationStats {
+    /// Total number of bytes that have been copied while moving allocations to different places.
+    VkDeviceSize bytesMoved;
+    /// Total number of bytes that have been released to the system by freeing empty `VkDeviceMemory` objects.
+    VkDeviceSize bytesFreed;
+    /// Number of allocations that have been moved to different places.
+    uint32_t allocationsMoved;
+    /// Number of empty `VkDeviceMemory` objects that have been released to the system.
+    uint32_t deviceMemoryBlocksFreed;
+} VmaDefragmentationStats;
+
+/** \brief Begins defragmentation process.
+
+@param allocator Allocator object.
+@param pInfo Structure filled with parameters of defragmentation.
+@param[out] pStats Optional. Statistics of defragmentation. You can pass null if you are not interested in this information.
+@param[out] pContext Context object that must be passed to vmaDefragmentationEnd() to finish defragmentation.
+@return `VK_SUCCESS` and `*pContext == null` if defragmentation finished within this function call. `VK_NOT_READY` and `*pContext != null` if defragmentation has been started and you need to call vmaDefragmentationEnd() to finish it. Negative value in case of error.
+
+Use this function instead of old, deprecated vmaDefragment().
+
+Warning! Between the call to vmaDefragmentationBegin() and vmaDefragmentationEnd():
+
+- You should not use any of allocations passed as `pInfo->pAllocations` or
+  any allocations that belong to pools passed as `pInfo->pPools`,
+  including calling vmaGetAllocationInfo(), vmaTouchAllocation(), or access
+  their data.
+- Some mutexes protecting internal data structures may be locked, so trying to
+  make or free any allocations, bind buffers or images, map memory, or launch
+  another simultaneous defragmentation in between may cause stall (when done on
+  another thread) or deadlock (when done on the same thread), unless you are
+  100% sure that defragmented allocations are in different pools.
+- Information returned via `pStats` and `pInfo->pAllocationsChanged` are undefined.
+  They become valid after call to vmaDefragmentationEnd().
+- If `pInfo->commandBuffer` is not null, you must submit that command buffer
+  and make sure it finished execution before calling vmaDefragmentationEnd().
+
+For more information and important limitations regarding defragmentation, see documentation chapter:
+[Defragmentation](@ref defragmentation).
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragmentationBegin(
+    VmaAllocator VMA_NOT_NULL allocator,
+    const VmaDefragmentationInfo2* VMA_NOT_NULL pInfo,
+    VmaDefragmentationStats* VMA_NULLABLE pStats,
+    VmaDefragmentationContext VMA_NULLABLE * VMA_NOT_NULL pContext);
+
+/** \brief Ends defragmentation process.
+
+Use this function to finish defragmentation started by vmaDefragmentationBegin().
+It is safe to pass `context == null`. The function then does nothing.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragmentationEnd(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaDefragmentationContext VMA_NULLABLE context);
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaBeginDefragmentationPass(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaDefragmentationContext VMA_NULLABLE context,
+    VmaDefragmentationPassInfo* VMA_NOT_NULL pInfo
+);
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaEndDefragmentationPass(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaDefragmentationContext VMA_NULLABLE context
+);
+
+/** \brief Deprecated. Compacts memory by moving allocations.
+
+@param pAllocations Array of allocations that can be moved during this compation.
+@param allocationCount Number of elements in pAllocations and pAllocationsChanged arrays.
+@param[out] pAllocationsChanged Array of boolean values that will indicate whether matching allocation in pAllocations array has been moved. This parameter is optional. Pass null if you don't need this information.
+@param pDefragmentationInfo Configuration parameters. Optional - pass null to use default values.
+@param[out] pDefragmentationStats Statistics returned by the function. Optional - pass null if you don't need this information.
+@return `VK_SUCCESS` if completed, negative error code in case of error.
+
+\deprecated This is a part of the old interface. It is recommended to use structure #VmaDefragmentationInfo2 and function vmaDefragmentationBegin() instead.
+
+This function works by moving allocations to different places (different
+`VkDeviceMemory` objects and/or different offsets) in order to optimize memory
+usage. Only allocations that are in `pAllocations` array can be moved. All other
+allocations are considered nonmovable in this call. Basic rules:
+
+- Only allocations made in memory types that have
+  `VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT` and `VK_MEMORY_PROPERTY_HOST_COHERENT_BIT`
+  flags can be compacted. You may pass other allocations but it makes no sense -
+  these will never be moved.
+- Custom pools created with #VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT or
+  #VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT flag are not defragmented. Allocations
+  passed to this function that come from such pools are ignored.
+- Allocations created with #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT or
+  created as dedicated allocations for any other reason are also ignored.
+- Both allocations made with or without #VMA_ALLOCATION_CREATE_MAPPED_BIT
+  flag can be compacted. If not persistently mapped, memory will be mapped
+  temporarily inside this function if needed.
+- You must not pass same #VmaAllocation object multiple times in `pAllocations` array.
+
+The function also frees empty `VkDeviceMemory` blocks.
+
+Warning: This function may be time-consuming, so you shouldn't call it too often
+(like after every resource creation/destruction).
+You can call it on special occasions (like when reloading a game level or
+when you just destroyed a lot of objects). Calling it every frame may be OK, but
+you should measure that on your platform.
+
+For more information, see [Defragmentation](@ref defragmentation) chapter.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragment(
+    VmaAllocator VMA_NOT_NULL allocator,
+    const VmaAllocation VMA_NOT_NULL * VMA_NOT_NULL VMA_LEN_IF_NOT_NULL(allocationCount) pAllocations,
+    size_t allocationCount,
+    VkBool32* VMA_NULLABLE VMA_LEN_IF_NOT_NULL(allocationCount) pAllocationsChanged,
+    const VmaDefragmentationInfo* VMA_NULLABLE pDefragmentationInfo,
+    VmaDefragmentationStats* VMA_NULLABLE pDefragmentationStats);
+
+/** \brief Binds buffer to allocation.
+
+Binds specified buffer to region of memory represented by specified allocation.
+Gets `VkDeviceMemory` handle and offset from the allocation.
+If you want to create a buffer, allocate memory for it and bind them together separately,
+you should use this function for binding instead of standard `vkBindBufferMemory()`,
+because it ensures proper synchronization so that when a `VkDeviceMemory` object is used by multiple
+allocations, calls to `vkBind*Memory()` or `vkMapMemory()` won't happen from multiple threads simultaneously
+(which is illegal in Vulkan).
+
+It is recommended to use function vmaCreateBuffer() instead of this one.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL allocation,
+    VkBuffer VMA_NOT_NULL_NON_DISPATCHABLE buffer);
+
+/** \brief Binds buffer to allocation with additional parameters.
+
+@param allocationLocalOffset Additional offset to be added while binding, relative to the beginnig of the `allocation`. Normally it should be 0.
+@param pNext A chain of structures to be attached to `VkBindBufferMemoryInfoKHR` structure used internally. Normally it should be null.
+
+This function is similar to vmaBindBufferMemory(), but it provides additional parameters.
+
+If `pNext` is not null, #VmaAllocator object must have been created with #VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT flag
+or with VmaAllocatorCreateInfo::vulkanApiVersion `>= VK_API_VERSION_1_1`. Otherwise the call fails.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory2(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL allocation,
+    VkDeviceSize allocationLocalOffset,
+    VkBuffer VMA_NOT_NULL_NON_DISPATCHABLE buffer,
+    const void* VMA_NULLABLE pNext);
+
+/** \brief Binds image to allocation.
+
+Binds specified image to region of memory represented by specified allocation.
+Gets `VkDeviceMemory` handle and offset from the allocation.
+If you want to create an image, allocate memory for it and bind them together separately,
+you should use this function for binding instead of standard `vkBindImageMemory()`,
+because it ensures proper synchronization so that when a `VkDeviceMemory` object is used by multiple
+allocations, calls to `vkBind*Memory()` or `vkMapMemory()` won't happen from multiple threads simultaneously
+(which is illegal in Vulkan).
+
+It is recommended to use function vmaCreateImage() instead of this one.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL allocation,
+    VkImage VMA_NOT_NULL_NON_DISPATCHABLE image);
+
+/** \brief Binds image to allocation with additional parameters.
+
+@param allocationLocalOffset Additional offset to be added while binding, relative to the beginnig of the `allocation`. Normally it should be 0.
+@param pNext A chain of structures to be attached to `VkBindImageMemoryInfoKHR` structure used internally. Normally it should be null.
+
+This function is similar to vmaBindImageMemory(), but it provides additional parameters.
+
+If `pNext` is not null, #VmaAllocator object must have been created with #VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT flag
+or with VmaAllocatorCreateInfo::vulkanApiVersion `>= VK_API_VERSION_1_1`. Otherwise the call fails.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory2(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL allocation,
+    VkDeviceSize allocationLocalOffset,
+    VkImage VMA_NOT_NULL_NON_DISPATCHABLE image,
+    const void* VMA_NULLABLE pNext);
+
+/**
+@param[out] pBuffer Buffer that was created.
+@param[out] pAllocation Allocation that was created.
+@param[out] pAllocationInfo Optional. Information about allocated memory. It can be later fetched using function vmaGetAllocationInfo().
+
+This function automatically:
+
+-# Creates buffer.
+-# Allocates appropriate memory for it.
+-# Binds the buffer with the memory.
+
+If any of these operations fail, buffer and allocation are not created,
+returned value is negative error code, *pBuffer and *pAllocation are null.
+
+If the function succeeded, you must destroy both buffer and allocation when you
+no longer need them using either convenience function vmaDestroyBuffer() or
+separately, using `vkDestroyBuffer()` and vmaFreeMemory().
+
+If #VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT flag was used,
+VK_KHR_dedicated_allocation extension is used internally to query driver whether
+it requires or prefers the new buffer to have dedicated allocation. If yes,
+and if dedicated allocation is possible (VmaAllocationCreateInfo::pool is null
+and #VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT is not used), it creates dedicated
+allocation for this buffer, just like when using
+#VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT.
+
+\note This function creates a new `VkBuffer`. Sub-allocation of parts of one large buffer,
+although recommended as a good practice, is out of scope of this library and could be implemented
+by the user as a higher-level logic on top of VMA.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBuffer(
+    VmaAllocator VMA_NOT_NULL allocator,
+    const VkBufferCreateInfo* VMA_NOT_NULL pBufferCreateInfo,
+    const VmaAllocationCreateInfo* VMA_NOT_NULL pAllocationCreateInfo,
+    VkBuffer VMA_NULLABLE_NON_DISPATCHABLE * VMA_NOT_NULL pBuffer,
+    VmaAllocation VMA_NULLABLE * VMA_NOT_NULL pAllocation,
+    VmaAllocationInfo* VMA_NULLABLE pAllocationInfo);
+
+/** \brief Destroys Vulkan buffer and frees allocated memory.
+
+This is just a convenience function equivalent to:
+
+\code
+vkDestroyBuffer(device, buffer, allocationCallbacks);
+vmaFreeMemory(allocator, allocation);
+\endcode
+
+It it safe to pass null as buffer and/or allocation.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaDestroyBuffer(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VkBuffer VMA_NULLABLE_NON_DISPATCHABLE buffer,
+    VmaAllocation VMA_NULLABLE allocation);
+
+/// Function similar to vmaCreateBuffer().
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateImage(
+    VmaAllocator VMA_NOT_NULL allocator,
+    const VkImageCreateInfo* VMA_NOT_NULL pImageCreateInfo,
+    const VmaAllocationCreateInfo* VMA_NOT_NULL pAllocationCreateInfo,
+    VkImage VMA_NULLABLE_NON_DISPATCHABLE * VMA_NOT_NULL pImage,
+    VmaAllocation VMA_NULLABLE * VMA_NOT_NULL pAllocation,
+    VmaAllocationInfo* VMA_NULLABLE pAllocationInfo);
+
+/** \brief Destroys Vulkan image and frees allocated memory.
+
+This is just a convenience function equivalent to:
+
+\code
+vkDestroyImage(device, image, allocationCallbacks);
+vmaFreeMemory(allocator, allocation);
+\endcode
+
+It it safe to pass null as image and/or allocation.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaDestroyImage(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VkImage VMA_NULLABLE_NON_DISPATCHABLE image,
+    VmaAllocation VMA_NULLABLE allocation);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // AMD_VULKAN_MEMORY_ALLOCATOR_H
+
+// For Visual Studio IntelliSense.
+#if defined(__cplusplus) && defined(__INTELLISENSE__)
+#define VMA_IMPLEMENTATION
+#endif
+
+#ifdef VMA_IMPLEMENTATION
+#undef VMA_IMPLEMENTATION
+
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <utility>
+
+#if VMA_RECORDING_ENABLED
+    #include <chrono>
+    #if defined(_WIN32)
+        #include <windows.h>
+    #else
+        #include <sstream>
+        #include <thread>
+    #endif
+#endif
+
+/*******************************************************************************
+CONFIGURATION SECTION
+
+Define some of these macros before each #include of this header or change them
+here if you need other then default behavior depending on your environment.
+*/
+
+/*
+Define this macro to 1 to make the library fetch pointers to Vulkan functions
+internally, like:
+
+    vulkanFunctions.vkAllocateMemory = &vkAllocateMemory;
+*/
+#if !defined(VMA_STATIC_VULKAN_FUNCTIONS) && !defined(VK_NO_PROTOTYPES)
+    #define VMA_STATIC_VULKAN_FUNCTIONS 1
+#endif
+
+/*
+Define this macro to 1 to make the library fetch pointers to Vulkan functions
+internally, like:
+
+    vulkanFunctions.vkAllocateMemory = (PFN_vkAllocateMemory)vkGetDeviceProcAddr(m_hDevice, vkAllocateMemory);
+*/
+#if !defined(VMA_DYNAMIC_VULKAN_FUNCTIONS)
+    #define VMA_DYNAMIC_VULKAN_FUNCTIONS 1
+    #if defined(VK_NO_PROTOTYPES)
+        extern PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
+        extern PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr;
+    #endif
+#endif
+
+// Define this macro to 1 to make the library use STL containers instead of its own implementation.
+//#define VMA_USE_STL_CONTAINERS 1
+
+/* Set this macro to 1 to make the library including and using STL containers:
+std::pair, std::vector, std::list, std::unordered_map.
+
+Set it to 0 or undefined to make the library using its own implementation of
+the containers.
+*/
+#if VMA_USE_STL_CONTAINERS
+   #define VMA_USE_STL_VECTOR 1
+   #define VMA_USE_STL_UNORDERED_MAP 1
+   #define VMA_USE_STL_LIST 1
+#endif
+
+#ifndef VMA_USE_STL_SHARED_MUTEX
+    // Compiler conforms to C++17.
+    #if __cplusplus >= 201703L
+        #define VMA_USE_STL_SHARED_MUTEX 1
+    // Visual studio defines __cplusplus properly only when passed additional parameter: /Zc:__cplusplus
+    // Otherwise it's always 199711L, despite shared_mutex works since Visual Studio 2015 Update 2.
+    // See: https://blogs.msdn.microsoft.com/vcblog/2018/04/09/msvc-now-correctly-reports-__cplusplus/
+    #elif defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023918 && __cplusplus == 199711L && _MSVC_LANG >= 201703L
+        #define VMA_USE_STL_SHARED_MUTEX 1
+    #else
+        #define VMA_USE_STL_SHARED_MUTEX 0
+    #endif
+#endif
+
+/*
+THESE INCLUDES ARE NOT ENABLED BY DEFAULT.
+Library has its own container implementation.
+*/
+#if VMA_USE_STL_VECTOR
+   #include <vector>
+#endif
+
+#if VMA_USE_STL_UNORDERED_MAP
+   #include <unordered_map>
+#endif
+
+#if VMA_USE_STL_LIST
+   #include <list>
+#endif
+
+/*
+Following headers are used in this CONFIGURATION section only, so feel free to
+remove them if not needed.
+*/
+#include <cassert> // for assert
+#include <algorithm> // for min, max
+#include <mutex>
+
+#ifndef VMA_NULL
+   // Value used as null pointer. Define it to e.g.: nullptr, NULL, 0, (void*)0.
+   #define VMA_NULL   nullptr
+#endif
+
+#if defined(__ANDROID_API__) && (__ANDROID_API__ < 16)
+#include <cstdlib>
+static void* vma_aligned_alloc(size_t alignment, size_t size)
+{
+    // alignment must be >= sizeof(void*)
+    if(alignment < sizeof(void*))
+    {
+        alignment = sizeof(void*);
+    }
+
+    return memalign(alignment, size);
+}
+#elif defined(__APPLE__) || defined(__ANDROID__) || (defined(__linux__) && defined(__GLIBCXX__) && !defined(_GLIBCXX_HAVE_ALIGNED_ALLOC))
+#include <cstdlib>
+
+#if defined(__APPLE__)
+#include <AvailabilityMacros.h>
+#endif
+
+static void* vma_aligned_alloc(size_t alignment, size_t size)
+{
+#if defined(__APPLE__) && (defined(MAC_OS_X_VERSION_10_16) || defined(__IPHONE_14_0))
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_16 || __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_14_0
+    // For C++14, usr/include/malloc/_malloc.h declares aligned_alloc()) only
+    // with the MacOSX11.0 SDK in Xcode 12 (which is what adds
+    // MAC_OS_X_VERSION_10_16), even though the function is marked
+    // availabe for 10.15. That's why the preprocessor checks for 10.16 but
+    // the __builtin_available checks for 10.15.
+    // People who use C++17 could call aligned_alloc with the 10.15 SDK already.
+    if (__builtin_available(macOS 10.15, iOS 13, *))
+        return aligned_alloc(alignment, size);
+#endif
+#endif
+    // alignment must be >= sizeof(void*)
+    if(alignment < sizeof(void*))
+    {
+        alignment = sizeof(void*);
+    }
+
+    void *pointer;
+    if(posix_memalign(&pointer, alignment, size) == 0)
+        return pointer;
+    return VMA_NULL;
+}
+#elif defined(_WIN32)
+static void* vma_aligned_alloc(size_t alignment, size_t size)
+{
+    return _aligned_malloc(size, alignment);
+}
+#else
+static void* vma_aligned_alloc(size_t alignment, size_t size)
+{
+    return aligned_alloc(alignment, size);
+}
+#endif
+
+#if defined(_WIN32)
+static void vma_aligned_free(void* ptr)
+{
+    _aligned_free(ptr);
+}
+#else
+static void vma_aligned_free(void* ptr)
+{
+    free(ptr);
+}
+#endif
+
+// If your compiler is not compatible with C++11 and definition of
+// aligned_alloc() function is missing, uncommeting following line may help:
+
+//#include <malloc.h>
+
+// Normal assert to check for programmer's errors, especially in Debug configuration.
+#ifndef VMA_ASSERT
+   #ifdef NDEBUG
+       #define VMA_ASSERT(expr)
+   #else
+       #define VMA_ASSERT(expr)         assert(expr)
+   #endif
+#endif
+
+// Assert that will be called very often, like inside data structures e.g. operator[].
+// Making it non-empty can make program slow.
+#ifndef VMA_HEAVY_ASSERT
+   #ifdef NDEBUG
+       #define VMA_HEAVY_ASSERT(expr)
+   #else
+       #define VMA_HEAVY_ASSERT(expr)   //VMA_ASSERT(expr)
+   #endif
+#endif
+
+#ifndef VMA_ALIGN_OF
+   #define VMA_ALIGN_OF(type)       (__alignof(type))
+#endif
+
+#ifndef VMA_SYSTEM_ALIGNED_MALLOC
+   #define VMA_SYSTEM_ALIGNED_MALLOC(size, alignment) vma_aligned_alloc((alignment), (size))
+#endif
+
+#ifndef VMA_SYSTEM_ALIGNED_FREE
+   // VMA_SYSTEM_FREE is the old name, but might have been defined by the user
+   #if defined(VMA_SYSTEM_FREE)
+      #define VMA_SYSTEM_ALIGNED_FREE(ptr)     VMA_SYSTEM_FREE(ptr)
+   #else
+      #define VMA_SYSTEM_ALIGNED_FREE(ptr)     vma_aligned_free(ptr)
+    #endif
+#endif
+
+#ifndef VMA_MIN
+   #define VMA_MIN(v1, v2)    (std::min((v1), (v2)))
+#endif
+
+#ifndef VMA_MAX
+   #define VMA_MAX(v1, v2)    (std::max((v1), (v2)))
+#endif
+
+#ifndef VMA_SWAP
+   #define VMA_SWAP(v1, v2)   std::swap((v1), (v2))
+#endif
+
+#ifndef VMA_SORT
+   #define VMA_SORT(beg, end, cmp)  std::sort(beg, end, cmp)
+#endif
+
+#ifndef VMA_DEBUG_LOG
+   #define VMA_DEBUG_LOG(format, ...)
+   /*
+   #define VMA_DEBUG_LOG(format, ...) do { \
+       printf(format, __VA_ARGS__); \
+       printf("\n"); \
+   } while(false)
+   */
+#endif
+
+// Define this macro to 1 to enable functions: vmaBuildStatsString, vmaFreeStatsString.
+#if VMA_STATS_STRING_ENABLED
+    static inline void VmaUint32ToStr(char* outStr, size_t strLen, uint32_t num)
+    {
+        snprintf(outStr, strLen, "%u", static_cast<unsigned int>(num));
+    }
+    static inline void VmaUint64ToStr(char* outStr, size_t strLen, uint64_t num)
+    {
+        snprintf(outStr, strLen, "%llu", static_cast<unsigned long long>(num));
+    }
+    static inline void VmaPtrToStr(char* outStr, size_t strLen, const void* ptr)
+    {
+        snprintf(outStr, strLen, "%p", ptr);
+    }
+#endif
+
+#ifndef VMA_MUTEX
+    class VmaMutex
+    {
+    public:
+        void Lock() { m_Mutex.lock(); }
+        void Unlock() { m_Mutex.unlock(); }
+        bool TryLock() { return m_Mutex.try_lock(); }
+    private:
+        std::mutex m_Mutex;
+    };
+    #define VMA_MUTEX VmaMutex
+#endif
+
+// Read-write mutex, where "read" is shared access, "write" is exclusive access.
+#ifndef VMA_RW_MUTEX
+    #if VMA_USE_STL_SHARED_MUTEX
+        // Use std::shared_mutex from C++17.
+        #include <shared_mutex>
+        class VmaRWMutex
+        {
+        public:
+            void LockRead() { m_Mutex.lock_shared(); }
+            void UnlockRead() { m_Mutex.unlock_shared(); }
+            bool TryLockRead() { return m_Mutex.try_lock_shared(); }
+            void LockWrite() { m_Mutex.lock(); }
+            void UnlockWrite() { m_Mutex.unlock(); }
+            bool TryLockWrite() { return m_Mutex.try_lock(); }
+        private:
+            std::shared_mutex m_Mutex;
+        };
+        #define VMA_RW_MUTEX VmaRWMutex
+    #elif defined(_WIN32) && defined(WINVER) && WINVER >= 0x0600
+        // Use SRWLOCK from WinAPI.
+        // Minimum supported client = Windows Vista, server = Windows Server 2008.
+        class VmaRWMutex
+        {
+        public:
+            VmaRWMutex() { InitializeSRWLock(&m_Lock); }
+            void LockRead() { AcquireSRWLockShared(&m_Lock); }
+            void UnlockRead() { ReleaseSRWLockShared(&m_Lock); }
+            bool TryLockRead() { return TryAcquireSRWLockShared(&m_Lock) != FALSE; }
+            void LockWrite() { AcquireSRWLockExclusive(&m_Lock); }
+            void UnlockWrite() { ReleaseSRWLockExclusive(&m_Lock); }
+            bool TryLockWrite() { return TryAcquireSRWLockExclusive(&m_Lock) != FALSE; }
+        private:
+            SRWLOCK m_Lock;
+        };
+        #define VMA_RW_MUTEX VmaRWMutex
+    #else
+        // Less efficient fallback: Use normal mutex.
+        class VmaRWMutex
+        {
+        public:
+            void LockRead() { m_Mutex.Lock(); }
+            void UnlockRead() { m_Mutex.Unlock(); }
+            bool TryLockRead() { return m_Mutex.TryLock(); }
+            void LockWrite() { m_Mutex.Lock(); }
+            void UnlockWrite() { m_Mutex.Unlock(); }
+            bool TryLockWrite() { return m_Mutex.TryLock(); }
+        private:
+            VMA_MUTEX m_Mutex;
+        };
+        #define VMA_RW_MUTEX VmaRWMutex
+    #endif // #if VMA_USE_STL_SHARED_MUTEX
+#endif // #ifndef VMA_RW_MUTEX
+
+/*
+If providing your own implementation, you need to implement a subset of std::atomic.
+*/
+#ifndef VMA_ATOMIC_UINT32
+    #include <atomic>
+    #define VMA_ATOMIC_UINT32 std::atomic<uint32_t>
+#endif
+
+#ifndef VMA_ATOMIC_UINT64
+    #include <atomic>
+    #define VMA_ATOMIC_UINT64 std::atomic<uint64_t>
+#endif
+
+#ifndef VMA_DEBUG_ALWAYS_DEDICATED_MEMORY
+    /**
+    Every allocation will have its own memory block.
+    Define to 1 for debugging purposes only.
+    */
+    #define VMA_DEBUG_ALWAYS_DEDICATED_MEMORY (0)
+#endif
+
+#ifndef VMA_DEBUG_ALIGNMENT
+    /**
+    Minimum alignment of all allocations, in bytes.
+    Set to more than 1 for debugging purposes only. Must be power of two.
+    */
+    #define VMA_DEBUG_ALIGNMENT (1)
+#endif
+
+#ifndef VMA_DEBUG_MARGIN
+    /**
+    Minimum margin before and after every allocation, in bytes.
+    Set nonzero for debugging purposes only.
+    */
+    #define VMA_DEBUG_MARGIN (0)
+#endif
+
+#ifndef VMA_DEBUG_INITIALIZE_ALLOCATIONS
+    /**
+    Define this macro to 1 to automatically fill new allocations and destroyed
+    allocations with some bit pattern.
+    */
+    #define VMA_DEBUG_INITIALIZE_ALLOCATIONS (0)
+#endif
+
+#ifndef VMA_DEBUG_DETECT_CORRUPTION
+    /**
+    Define this macro to 1 together with non-zero value of VMA_DEBUG_MARGIN to
+    enable writing magic value to the margin before and after every allocation and
+    validating it, so that memory corruptions (out-of-bounds writes) are detected.
+    */
+    #define VMA_DEBUG_DETECT_CORRUPTION (0)
+#endif
+
+#ifndef VMA_DEBUG_GLOBAL_MUTEX
+    /**
+    Set this to 1 for debugging purposes only, to enable single mutex protecting all
+    entry calls to the library. Can be useful for debugging multithreading issues.
+    */
+    #define VMA_DEBUG_GLOBAL_MUTEX (0)
+#endif
+
+#ifndef VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY
+    /**
+    Minimum value for VkPhysicalDeviceLimits::bufferImageGranularity.
+    Set to more than 1 for debugging purposes only. Must be power of two.
+    */
+    #define VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY (1)
+#endif
+
+#ifndef VMA_SMALL_HEAP_MAX_SIZE
+   /// Maximum size of a memory heap in Vulkan to consider it "small".
+   #define VMA_SMALL_HEAP_MAX_SIZE (1024ull * 1024 * 1024)
+#endif
+
+#ifndef VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE
+   /// Default size of a block allocated as single VkDeviceMemory from a "large" heap.
+   #define VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE (256ull * 1024 * 1024)
+#endif
+
+#ifndef VMA_CLASS_NO_COPY
+    #define VMA_CLASS_NO_COPY(className) \
+        private: \
+            className(const className&) = delete; \
+            className& operator=(const className&) = delete;
+#endif
+
+static const uint32_t VMA_FRAME_INDEX_LOST = UINT32_MAX;
+
+// Decimal 2139416166, float NaN, little-endian binary 66 E6 84 7F.
+static const uint32_t VMA_CORRUPTION_DETECTION_MAGIC_VALUE = 0x7F84E666;
+
+static const uint8_t VMA_ALLOCATION_FILL_PATTERN_CREATED   = 0xDC;
+static const uint8_t VMA_ALLOCATION_FILL_PATTERN_DESTROYED = 0xEF;
+
+/*******************************************************************************
+END OF CONFIGURATION
+*/
+
+// # Copy of some Vulkan definitions so we don't need to check their existence just to handle few constants.
+
+static const uint32_t VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD_COPY = 0x00000040;
+static const uint32_t VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD_COPY = 0x00000080;
+static const uint32_t VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_COPY = 0x00020000;
+
+static const uint32_t VMA_ALLOCATION_INTERNAL_STRATEGY_MIN_OFFSET = 0x10000000u;
+
+static VkAllocationCallbacks VmaEmptyAllocationCallbacks = {
+    VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL };
+
+// Returns number of bits set to 1 in (v).
+static inline uint32_t VmaCountBitsSet(uint32_t v)
+{
+    uint32_t c = v - ((v >> 1) & 0x55555555);
+    c = ((c >>  2) & 0x33333333) + (c & 0x33333333);
+    c = ((c >>  4) + c) & 0x0F0F0F0F;
+    c = ((c >>  8) + c) & 0x00FF00FF;
+    c = ((c >> 16) + c) & 0x0000FFFF;
+    return c;
+}
+
+/*
+Returns true if given number is a power of two.
+T must be unsigned integer number or signed integer but always nonnegative.
+For 0 returns true.
+*/
+template <typename T>
+inline bool VmaIsPow2(T x)
+{
+    return (x & (x-1)) == 0;
+}
+
+// Aligns given value up to nearest multiply of align value. For example: VmaAlignUp(11, 8) = 16.
+// Use types like uint32_t, uint64_t as T.
+template <typename T>
+static inline T VmaAlignUp(T val, T alignment)
+{
+    VMA_HEAVY_ASSERT(VmaIsPow2(alignment));
+    return (val + alignment - 1) & ~(alignment - 1);
+}
+// Aligns given value down to nearest multiply of align value. For example: VmaAlignUp(11, 8) = 8.
+// Use types like uint32_t, uint64_t as T.
+template <typename T>
+static inline T VmaAlignDown(T val, T alignment)
+{
+    VMA_HEAVY_ASSERT(VmaIsPow2(alignment));
+    return val & ~(alignment - 1);
+}
+
+// Division with mathematical rounding to nearest number.
+template <typename T>
+static inline T VmaRoundDiv(T x, T y)
+{
+    return (x + (y / (T)2)) / y;
+}
+
+// Returns smallest power of 2 greater or equal to v.
+static inline uint32_t VmaNextPow2(uint32_t v)
+{
+    v--;
+    v |= v >> 1;
+    v |= v >> 2;
+    v |= v >> 4;
+    v |= v >> 8;
+    v |= v >> 16;
+    v++;
+    return v;
+}
+static inline uint64_t VmaNextPow2(uint64_t v)
+{
+    v--;
+    v |= v >> 1;
+    v |= v >> 2;
+    v |= v >> 4;
+    v |= v >> 8;
+    v |= v >> 16;
+    v |= v >> 32;
+    v++;
+    return v;
+}
+
+// Returns largest power of 2 less or equal to v.
+static inline uint32_t VmaPrevPow2(uint32_t v)
+{
+    v |= v >> 1;
+    v |= v >> 2;
+    v |= v >> 4;
+    v |= v >> 8;
+    v |= v >> 16;
+    v = v ^ (v >> 1);
+    return v;
+}
+static inline uint64_t VmaPrevPow2(uint64_t v)
+{
+    v |= v >> 1;
+    v |= v >> 2;
+    v |= v >> 4;
+    v |= v >> 8;
+    v |= v >> 16;
+    v |= v >> 32;
+    v = v ^ (v >> 1);
+    return v;
+}
+
+static inline bool VmaStrIsEmpty(const char* pStr)
+{
+    return pStr == VMA_NULL || *pStr == '\0';
+}
+
+#if VMA_STATS_STRING_ENABLED
+
+static const char* VmaAlgorithmToStr(uint32_t algorithm)
+{
+    switch(algorithm)
+    {
+    case VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT:
+        return "Linear";
+    case VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT:
+        return "Buddy";
+    case 0:
+        return "Default";
+    default:
+        VMA_ASSERT(0);
+        return "";
+    }
+}
+
+#endif // #if VMA_STATS_STRING_ENABLED
+
+#ifndef VMA_SORT
+
+template<typename Iterator, typename Compare>
+Iterator VmaQuickSortPartition(Iterator beg, Iterator end, Compare cmp)
+{
+    Iterator centerValue = end; --centerValue;
+    Iterator insertIndex = beg;
+    for(Iterator memTypeIndex = beg; memTypeIndex < centerValue; ++memTypeIndex)
+    {
+        if(cmp(*memTypeIndex, *centerValue))
+        {
+            if(insertIndex != memTypeIndex)
+            {
+                VMA_SWAP(*memTypeIndex, *insertIndex);
+            }
+            ++insertIndex;
+        }
+    }
+    if(insertIndex != centerValue)
+    {
+        VMA_SWAP(*insertIndex, *centerValue);
+    }
+    return insertIndex;
+}
+
+template<typename Iterator, typename Compare>
+void VmaQuickSort(Iterator beg, Iterator end, Compare cmp)
+{
+    if(beg < end)
+    {
+        Iterator it = VmaQuickSortPartition<Iterator, Compare>(beg, end, cmp);
+        VmaQuickSort<Iterator, Compare>(beg, it, cmp);
+        VmaQuickSort<Iterator, Compare>(it + 1, end, cmp);
+    }
+}
+
+#define VMA_SORT(beg, end, cmp) VmaQuickSort(beg, end, cmp)
+
+#endif // #ifndef VMA_SORT
+
+/*
+Returns true if two memory blocks occupy overlapping pages.
+ResourceA must be in less memory offset than ResourceB.
+
+Algorithm is based on "Vulkan 1.0.39 - A Specification (with all registered Vulkan extensions)"
+chapter 11.6 "Resource Memory Association", paragraph "Buffer-Image Granularity".
+*/
+static inline bool VmaBlocksOnSamePage(
+    VkDeviceSize resourceAOffset,
+    VkDeviceSize resourceASize,
+    VkDeviceSize resourceBOffset,
+    VkDeviceSize pageSize)
+{
+    VMA_ASSERT(resourceAOffset + resourceASize <= resourceBOffset && resourceASize > 0 && pageSize > 0);
+    VkDeviceSize resourceAEnd = resourceAOffset + resourceASize - 1;
+    VkDeviceSize resourceAEndPage = resourceAEnd & ~(pageSize - 1);
+    VkDeviceSize resourceBStart = resourceBOffset;
+    VkDeviceSize resourceBStartPage = resourceBStart & ~(pageSize - 1);
+    return resourceAEndPage == resourceBStartPage;
+}
+
+enum VmaSuballocationType
+{
+    VMA_SUBALLOCATION_TYPE_FREE = 0,
+    VMA_SUBALLOCATION_TYPE_UNKNOWN = 1,
+    VMA_SUBALLOCATION_TYPE_BUFFER = 2,
+    VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN = 3,
+    VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR = 4,
+    VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL = 5,
+    VMA_SUBALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
+};
+
+/*
+Returns true if given suballocation types could conflict and must respect
+VkPhysicalDeviceLimits::bufferImageGranularity. They conflict if one is buffer
+or linear image and another one is optimal image. If type is unknown, behave
+conservatively.
+*/
+static inline bool VmaIsBufferImageGranularityConflict(
+    VmaSuballocationType suballocType1,
+    VmaSuballocationType suballocType2)
+{
+    if(suballocType1 > suballocType2)
+    {
+        VMA_SWAP(suballocType1, suballocType2);
+    }
+
+    switch(suballocType1)
+    {
+    case VMA_SUBALLOCATION_TYPE_FREE:
+        return false;
+    case VMA_SUBALLOCATION_TYPE_UNKNOWN:
+        return true;
+    case VMA_SUBALLOCATION_TYPE_BUFFER:
+        return
+            suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
+            suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
+    case VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN:
+        return
+            suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
+            suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR ||
+            suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
+    case VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR:
+        return
+            suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
+    case VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL:
+        return false;
+    default:
+        VMA_ASSERT(0);
+        return true;
+    }
+}
+
+static void VmaWriteMagicValue(void* pData, VkDeviceSize offset)
+{
+#if VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_DETECT_CORRUPTION
+    uint32_t* pDst = (uint32_t*)((char*)pData + offset);
+    const size_t numberCount = VMA_DEBUG_MARGIN / sizeof(uint32_t);
+    for(size_t i = 0; i < numberCount; ++i, ++pDst)
+    {
+        *pDst = VMA_CORRUPTION_DETECTION_MAGIC_VALUE;
+    }
+#else
+    // no-op
+#endif
+}
+
+static bool VmaValidateMagicValue(const void* pData, VkDeviceSize offset)
+{
+#if VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_DETECT_CORRUPTION
+    const uint32_t* pSrc = (const uint32_t*)((const char*)pData + offset);
+    const size_t numberCount = VMA_DEBUG_MARGIN / sizeof(uint32_t);
+    for(size_t i = 0; i < numberCount; ++i, ++pSrc)
+    {
+        if(*pSrc != VMA_CORRUPTION_DETECTION_MAGIC_VALUE)
+        {
+            return false;
+        }
+    }
+#endif
+    return true;
+}
+
+/*
+Fills structure with parameters of an example buffer to be used for transfers
+during GPU memory defragmentation.
+*/
+static void VmaFillGpuDefragmentationBufferCreateInfo(VkBufferCreateInfo& outBufCreateInfo)
+{
+    memset(&outBufCreateInfo, 0, sizeof(outBufCreateInfo));
+    outBufCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+    outBufCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+    outBufCreateInfo.size = (VkDeviceSize)VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE; // Example size.
+}
+
+// Helper RAII class to lock a mutex in constructor and unlock it in destructor (at the end of scope).
+struct VmaMutexLock
+{
+    VMA_CLASS_NO_COPY(VmaMutexLock)
+public:
+    VmaMutexLock(VMA_MUTEX& mutex, bool useMutex = true) :
+        m_pMutex(useMutex ? &mutex : VMA_NULL)
+    { if(m_pMutex) { m_pMutex->Lock(); } }
+    ~VmaMutexLock()
+    { if(m_pMutex) { m_pMutex->Unlock(); } }
+private:
+    VMA_MUTEX* m_pMutex;
+};
+
+// Helper RAII class to lock a RW mutex in constructor and unlock it in destructor (at the end of scope), for reading.
+struct VmaMutexLockRead
+{
+    VMA_CLASS_NO_COPY(VmaMutexLockRead)
+public:
+    VmaMutexLockRead(VMA_RW_MUTEX& mutex, bool useMutex) :
+        m_pMutex(useMutex ? &mutex : VMA_NULL)
+    { if(m_pMutex) { m_pMutex->LockRead(); } }
+    ~VmaMutexLockRead() { if(m_pMutex) { m_pMutex->UnlockRead(); } }
+private:
+    VMA_RW_MUTEX* m_pMutex;
+};
+
+// Helper RAII class to lock a RW mutex in constructor and unlock it in destructor (at the end of scope), for writing.
+struct VmaMutexLockWrite
+{
+    VMA_CLASS_NO_COPY(VmaMutexLockWrite)
+public:
+    VmaMutexLockWrite(VMA_RW_MUTEX& mutex, bool useMutex) :
+        m_pMutex(useMutex ? &mutex : VMA_NULL)
+    { if(m_pMutex) { m_pMutex->LockWrite(); } }
+    ~VmaMutexLockWrite() { if(m_pMutex) { m_pMutex->UnlockWrite(); } }
+private:
+    VMA_RW_MUTEX* m_pMutex;
+};
+
+#if VMA_DEBUG_GLOBAL_MUTEX
+    static VMA_MUTEX gDebugGlobalMutex;
+    #define VMA_DEBUG_GLOBAL_MUTEX_LOCK VmaMutexLock debugGlobalMutexLock(gDebugGlobalMutex, true);
+#else
+    #define VMA_DEBUG_GLOBAL_MUTEX_LOCK
+#endif
+
+// Minimum size of a free suballocation to register it in the free suballocation collection.
+static const VkDeviceSize VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER = 16;
+
+/*
+Performs binary search and returns iterator to first element that is greater or
+equal to (key), according to comparison (cmp).
+
+Cmp should return true if first argument is less than second argument.
+
+Returned value is the found element, if present in the collection or place where
+new element with value (key) should be inserted.
+*/
+template <typename CmpLess, typename IterT, typename KeyT>
+static IterT VmaBinaryFindFirstNotLess(IterT beg, IterT end, const KeyT &key, const CmpLess& cmp)
+{
+    size_t down = 0, up = (end - beg);
+    while(down < up)
+    {
+        const size_t mid = down + (up - down) / 2;  // Overflow-safe midpoint calculation
+        if(cmp(*(beg+mid), key))
+        {
+            down = mid + 1;
+        }
+        else
+        {
+            up = mid;
+        }
+    }
+    return beg + down;
+}
+
+template<typename CmpLess, typename IterT, typename KeyT>
+IterT VmaBinaryFindSorted(const IterT& beg, const IterT& end, const KeyT& value, const CmpLess& cmp)
+{
+    IterT it = VmaBinaryFindFirstNotLess<CmpLess, IterT, KeyT>(
+        beg, end, value, cmp);
+    if(it == end ||
+        (!cmp(*it, value) && !cmp(value, *it)))
+    {
+        return it;
+    }
+    return end;
+}
+
+/*
+Returns true if all pointers in the array are not-null and unique.
+Warning! O(n^2) complexity. Use only inside VMA_HEAVY_ASSERT.
+T must be pointer type, e.g. VmaAllocation, VmaPool.
+*/
+template<typename T>
+static bool VmaValidatePointerArray(uint32_t count, const T* arr)
+{
+    for(uint32_t i = 0; i < count; ++i)
+    {
+        const T iPtr = arr[i];
+        if(iPtr == VMA_NULL)
+        {
+            return false;
+        }
+        for(uint32_t j = i + 1; j < count; ++j)
+        {
+            if(iPtr == arr[j])
+            {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+template<typename MainT, typename NewT>
+static inline void VmaPnextChainPushFront(MainT* mainStruct, NewT* newStruct)
+{
+    newStruct->pNext = mainStruct->pNext;
+    mainStruct->pNext = newStruct;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Memory allocation
+
+static void* VmaMalloc(const VkAllocationCallbacks* pAllocationCallbacks, size_t size, size_t alignment)
+{
+    void* result = VMA_NULL;
+    if((pAllocationCallbacks != VMA_NULL) &&
+        (pAllocationCallbacks->pfnAllocation != VMA_NULL))
+    {
+        result = (*pAllocationCallbacks->pfnAllocation)(
+            pAllocationCallbacks->pUserData,
+            size,
+            alignment,
+            VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+    }
+    else
+    {
+        result = VMA_SYSTEM_ALIGNED_MALLOC(size, alignment);
+    }
+    VMA_ASSERT(result != VMA_NULL && "CPU memory allocation failed.");
+    return result;
+}
+
+static void VmaFree(const VkAllocationCallbacks* pAllocationCallbacks, void* ptr)
+{
+    if((pAllocationCallbacks != VMA_NULL) &&
+        (pAllocationCallbacks->pfnFree != VMA_NULL))
+    {
+        (*pAllocationCallbacks->pfnFree)(pAllocationCallbacks->pUserData, ptr);
+    }
+    else
+    {
+        VMA_SYSTEM_ALIGNED_FREE(ptr);
+    }
+}
+
+template<typename T>
+static T* VmaAllocate(const VkAllocationCallbacks* pAllocationCallbacks)
+{
+    return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T), VMA_ALIGN_OF(T));
+}
+
+template<typename T>
+static T* VmaAllocateArray(const VkAllocationCallbacks* pAllocationCallbacks, size_t count)
+{
+    return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T) * count, VMA_ALIGN_OF(T));
+}
+
+#define vma_new(allocator, type)   new(VmaAllocate<type>(allocator))(type)
+
+#define vma_new_array(allocator, type, count)   new(VmaAllocateArray<type>((allocator), (count)))(type)
+
+template<typename T>
+static void vma_delete(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr)
+{
+    ptr->~T();
+    VmaFree(pAllocationCallbacks, ptr);
+}
+
+template<typename T>
+static void vma_delete_array(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr, size_t count)
+{
+    if(ptr != VMA_NULL)
+    {
+        for(size_t i = count; i--; )
+        {
+            ptr[i].~T();
+        }
+        VmaFree(pAllocationCallbacks, ptr);
+    }
+}
+
+static char* VmaCreateStringCopy(const VkAllocationCallbacks* allocs, const char* srcStr)
+{
+    if(srcStr != VMA_NULL)
+    {
+        const size_t len = strlen(srcStr);
+        char* const result = vma_new_array(allocs, char, len + 1);
+        memcpy(result, srcStr, len + 1);
+        return result;
+    }
+    else
+    {
+        return VMA_NULL;
+    }
+}
+
+static void VmaFreeString(const VkAllocationCallbacks* allocs, char* str)
+{
+    if(str != VMA_NULL)
+    {
+        const size_t len = strlen(str);
+        vma_delete_array(allocs, str, len + 1);
+    }
+}
+
+// STL-compatible allocator.
+template<typename T>
+class VmaStlAllocator
+{
+public:
+    const VkAllocationCallbacks* const m_pCallbacks;
+    typedef T value_type;
+
+    VmaStlAllocator(const VkAllocationCallbacks* pCallbacks) : m_pCallbacks(pCallbacks) { }
+    template<typename U> VmaStlAllocator(const VmaStlAllocator<U>& src) : m_pCallbacks(src.m_pCallbacks) { }
+
+    T* allocate(size_t n) { return VmaAllocateArray<T>(m_pCallbacks, n); }
+    void deallocate(T* p, size_t n) { VmaFree(m_pCallbacks, p); }
+
+    template<typename U>
+    bool operator==(const VmaStlAllocator<U>& rhs) const
+    {
+        return m_pCallbacks == rhs.m_pCallbacks;
+    }
+    template<typename U>
+    bool operator!=(const VmaStlAllocator<U>& rhs) const
+    {
+        return m_pCallbacks != rhs.m_pCallbacks;
+    }
+
+    VmaStlAllocator& operator=(const VmaStlAllocator& x) = delete;
+};
+
+#if VMA_USE_STL_VECTOR
+
+#define VmaVector std::vector
+
+template<typename T, typename allocatorT>
+static void VmaVectorInsert(std::vector<T, allocatorT>& vec, size_t index, const T& item)
+{
+    vec.insert(vec.begin() + index, item);
+}
+
+template<typename T, typename allocatorT>
+static void VmaVectorRemove(std::vector<T, allocatorT>& vec, size_t index)
+{
+    vec.erase(vec.begin() + index);
+}
+
+#else // #if VMA_USE_STL_VECTOR
+
+/* Class with interface compatible with subset of std::vector.
+T must be POD because constructors and destructors are not called and memcpy is
+used for these objects. */
+template<typename T, typename AllocatorT>
+class VmaVector
+{
+public:
+    typedef T value_type;
+
+    VmaVector(const AllocatorT& allocator) :
+        m_Allocator(allocator),
+        m_pArray(VMA_NULL),
+        m_Count(0),
+        m_Capacity(0)
+    {
+    }
+
+    VmaVector(size_t count, const AllocatorT& allocator) :
+        m_Allocator(allocator),
+        m_pArray(count ? (T*)VmaAllocateArray<T>(allocator.m_pCallbacks, count) : VMA_NULL),
+        m_Count(count),
+        m_Capacity(count)
+    {
+    }
+
+    // This version of the constructor is here for compatibility with pre-C++14 std::vector.
+    // value is unused.
+    VmaVector(size_t count, const T& value, const AllocatorT& allocator)
+        : VmaVector(count, allocator) {}
+
+    VmaVector(const VmaVector<T, AllocatorT>& src) :
+        m_Allocator(src.m_Allocator),
+        m_pArray(src.m_Count ? (T*)VmaAllocateArray<T>(src.m_Allocator.m_pCallbacks, src.m_Count) : VMA_NULL),
+        m_Count(src.m_Count),
+        m_Capacity(src.m_Count)
+    {
+        if(m_Count != 0)
+        {
+            memcpy(m_pArray, src.m_pArray, m_Count * sizeof(T));
+        }
+    }
+
+    ~VmaVector()
+    {
+        VmaFree(m_Allocator.m_pCallbacks, m_pArray);
+    }
+
+    VmaVector& operator=(const VmaVector<T, AllocatorT>& rhs)
+    {
+        if(&rhs != this)
+        {
+            resize(rhs.m_Count);
+            if(m_Count != 0)
+            {
+                memcpy(m_pArray, rhs.m_pArray, m_Count * sizeof(T));
+            }
+        }
+        return *this;
+    }
+
+    bool empty() const { return m_Count == 0; }
+    size_t size() const { return m_Count; }
+    T* data() { return m_pArray; }
+    const T* data() const { return m_pArray; }
+
+    T& operator[](size_t index)
+    {
+        VMA_HEAVY_ASSERT(index < m_Count);
+        return m_pArray[index];
+    }
+    const T& operator[](size_t index) const
+    {
+        VMA_HEAVY_ASSERT(index < m_Count);
+        return m_pArray[index];
+    }
+
+    T& front()
+    {
+        VMA_HEAVY_ASSERT(m_Count > 0);
+        return m_pArray[0];
+    }
+    const T& front() const
+    {
+        VMA_HEAVY_ASSERT(m_Count > 0);
+        return m_pArray[0];
+    }
+    T& back()
+    {
+        VMA_HEAVY_ASSERT(m_Count > 0);
+        return m_pArray[m_Count - 1];
+    }
+    const T& back() const
+    {
+        VMA_HEAVY_ASSERT(m_Count > 0);
+        return m_pArray[m_Count - 1];
+    }
+
+    void reserve(size_t newCapacity, bool freeMemory = false)
+    {
+        newCapacity = VMA_MAX(newCapacity, m_Count);
+
+        if((newCapacity < m_Capacity) && !freeMemory)
+        {
+            newCapacity = m_Capacity;
+        }
+
+        if(newCapacity != m_Capacity)
+        {
+            T* const newArray = newCapacity ? VmaAllocateArray<T>(m_Allocator, newCapacity) : VMA_NULL;
+            if(m_Count != 0)
+            {
+                memcpy(newArray, m_pArray, m_Count * sizeof(T));
+            }
+            VmaFree(m_Allocator.m_pCallbacks, m_pArray);
+            m_Capacity = newCapacity;
+            m_pArray = newArray;
+        }
+    }
+
+    void resize(size_t newCount, bool freeMemory = false)
+    {
+        size_t newCapacity = m_Capacity;
+        if(newCount > m_Capacity)
+        {
+            newCapacity = VMA_MAX(newCount, VMA_MAX(m_Capacity * 3 / 2, (size_t)8));
+        }
+        else if(freeMemory)
+        {
+            newCapacity = newCount;
+        }
+
+        if(newCapacity != m_Capacity)
+        {
+            T* const newArray = newCapacity ? VmaAllocateArray<T>(m_Allocator.m_pCallbacks, newCapacity) : VMA_NULL;
+            const size_t elementsToCopy = VMA_MIN(m_Count, newCount);
+            if(elementsToCopy != 0)
+            {
+                memcpy(newArray, m_pArray, elementsToCopy * sizeof(T));
+            }
+            VmaFree(m_Allocator.m_pCallbacks, m_pArray);
+            m_Capacity = newCapacity;
+            m_pArray = newArray;
+        }
+
+        m_Count = newCount;
+    }
+
+    void clear(bool freeMemory = false)
+    {
+        resize(0, freeMemory);
+    }
+
+    void insert(size_t index, const T& src)
+    {
+        VMA_HEAVY_ASSERT(index <= m_Count);
+        const size_t oldCount = size();
+        resize(oldCount + 1);
+        if(index < oldCount)
+        {
+            memmove(m_pArray + (index + 1), m_pArray + index, (oldCount - index) * sizeof(T));
+        }
+        m_pArray[index] = src;
+    }
+
+    void remove(size_t index)
+    {
+        VMA_HEAVY_ASSERT(index < m_Count);
+        const size_t oldCount = size();
+        if(index < oldCount - 1)
+        {
+            memmove(m_pArray + index, m_pArray + (index + 1), (oldCount - index - 1) * sizeof(T));
+        }
+        resize(oldCount - 1);
+    }
+
+    void push_back(const T& src)
+    {
+        const size_t newIndex = size();
+        resize(newIndex + 1);
+        m_pArray[newIndex] = src;
+    }
+
+    void pop_back()
+    {
+        VMA_HEAVY_ASSERT(m_Count > 0);
+        resize(size() - 1);
+    }
+
+    void push_front(const T& src)
+    {
+        insert(0, src);
+    }
+
+    void pop_front()
+    {
+        VMA_HEAVY_ASSERT(m_Count > 0);
+        remove(0);
+    }
+
+    typedef T* iterator;
+
+    iterator begin() { return m_pArray; }
+    iterator end() { return m_pArray + m_Count; }
+
+private:
+    AllocatorT m_Allocator;
+    T* m_pArray;
+    size_t m_Count;
+    size_t m_Capacity;
+};
+
+template<typename T, typename allocatorT>
+static void VmaVectorInsert(VmaVector<T, allocatorT>& vec, size_t index, const T& item)
+{
+    vec.insert(index, item);
+}
+
+template<typename T, typename allocatorT>
+static void VmaVectorRemove(VmaVector<T, allocatorT>& vec, size_t index)
+{
+    vec.remove(index);
+}
+
+#endif // #if VMA_USE_STL_VECTOR
+
+template<typename CmpLess, typename VectorT>
+size_t VmaVectorInsertSorted(VectorT& vector, const typename VectorT::value_type& value)
+{
+    const size_t indexToInsert = VmaBinaryFindFirstNotLess(
+        vector.data(),
+        vector.data() + vector.size(),
+        value,
+        CmpLess()) - vector.data();
+    VmaVectorInsert(vector, indexToInsert, value);
+    return indexToInsert;
+}
+
+template<typename CmpLess, typename VectorT>
+bool VmaVectorRemoveSorted(VectorT& vector, const typename VectorT::value_type& value)
+{
+    CmpLess comparator;
+    typename VectorT::iterator it = VmaBinaryFindFirstNotLess(
+        vector.begin(),
+        vector.end(),
+        value,
+        comparator);
+    if((it != vector.end()) && !comparator(*it, value) && !comparator(value, *it))
+    {
+        size_t indexToRemove = it - vector.begin();
+        VmaVectorRemove(vector, indexToRemove);
+        return true;
+    }
+    return false;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// class VmaSmallVector
+
+/*
+This is a vector (a variable-sized array), optimized for the case when the array is small.
+
+It contains some number of elements in-place, which allows it to avoid heap allocation
+when the actual number of elements is below that threshold. This allows normal "small"
+cases to be fast without losing generality for large inputs.
+*/
+
+template<typename T, typename AllocatorT, size_t N>
+class VmaSmallVector
+{
+public:
+    typedef T value_type;
+
+    VmaSmallVector(const AllocatorT& allocator) :
+        m_Count(0),
+        m_DynamicArray(allocator)
+    {
+    }
+    VmaSmallVector(size_t count, const AllocatorT& allocator) :
+        m_Count(count),
+        m_DynamicArray(count > N ? count : 0, allocator)
+    {
+    }
+    template<typename SrcT, typename SrcAllocatorT, size_t SrcN>
+    VmaSmallVector(const VmaSmallVector<SrcT, SrcAllocatorT, SrcN>& src) = delete;
+    template<typename SrcT, typename SrcAllocatorT, size_t SrcN>
+    VmaSmallVector<T, AllocatorT, N>& operator=(const VmaSmallVector<SrcT, SrcAllocatorT, SrcN>& rhs) = delete;
+
+    bool empty() const { return m_Count == 0; }
+    size_t size() const { return m_Count; }
+    T* data() { return m_Count > N ? m_DynamicArray.data() : m_StaticArray; }
+    const T* data() const { return m_Count > N ? m_DynamicArray.data() : m_StaticArray; }
+
+    T& operator[](size_t index)
+    {
+        VMA_HEAVY_ASSERT(index < m_Count);
+        return data()[index];
+    }
+    const T& operator[](size_t index) const
+    {
+        VMA_HEAVY_ASSERT(index < m_Count);
+        return data()[index];
+    }
+
+    T& front()
+    {
+        VMA_HEAVY_ASSERT(m_Count > 0);
+        return data()[0];
+    }
+    const T& front() const
+    {
+        VMA_HEAVY_ASSERT(m_Count > 0);
+        return data()[0];
+    }
+    T& back()
+    {
+        VMA_HEAVY_ASSERT(m_Count > 0);
+        return data()[m_Count - 1];
+    }
+    const T& back() const
+    {
+        VMA_HEAVY_ASSERT(m_Count > 0);
+        return data()[m_Count - 1];
+    }
+
+    void resize(size_t newCount, bool freeMemory = false)
+    {
+        if(newCount > N && m_Count > N)
+        {
+            // Any direction, staying in m_DynamicArray
+            m_DynamicArray.resize(newCount, freeMemory);
+        }
+        else if(newCount > N && m_Count <= N)
+        {
+            // Growing, moving from m_StaticArray to m_DynamicArray
+            m_DynamicArray.resize(newCount, freeMemory);
+            if(m_Count > 0)
+            {
+                memcpy(m_DynamicArray.data(), m_StaticArray, m_Count * sizeof(T));
+            }
+        }
+        else if(newCount <= N && m_Count > N)
+        {
+            // Shrinking, moving from m_DynamicArray to m_StaticArray
+            if(newCount > 0)
+            {
+                memcpy(m_StaticArray, m_DynamicArray.data(), newCount * sizeof(T));
+            }
+            m_DynamicArray.resize(0, freeMemory);
+        }
+        else
+        {
+            // Any direction, staying in m_StaticArray - nothing to do here
+        }
+        m_Count = newCount;
+    }
+
+    void clear(bool freeMemory = false)
+    {
+        m_DynamicArray.clear(freeMemory);
+        m_Count = 0;
+    }
+
+    void insert(size_t index, const T& src)
+    {
+        VMA_HEAVY_ASSERT(index <= m_Count);
+        const size_t oldCount = size();
+        resize(oldCount + 1);
+        T* const dataPtr = data();
+        if(index < oldCount)
+        {
+            //  I know, this could be more optimal for case where memmove can be memcpy directly from m_StaticArray to m_DynamicArray.
+            memmove(dataPtr + (index + 1), dataPtr + index, (oldCount - index) * sizeof(T));
+        }
+        dataPtr[index] = src;
+    }
+
+    void remove(size_t index)
+    {
+        VMA_HEAVY_ASSERT(index < m_Count);
+        const size_t oldCount = size();
+        if(index < oldCount - 1)
+        {
+            //  I know, this could be more optimal for case where memmove can be memcpy directly from m_DynamicArray to m_StaticArray.
+            T* const dataPtr = data();
+            memmove(dataPtr + index, dataPtr + (index + 1), (oldCount - index - 1) * sizeof(T));
+        }
+        resize(oldCount - 1);
+    }
+
+    void push_back(const T& src)
+    {
+        const size_t newIndex = size();
+        resize(newIndex + 1);
+        data()[newIndex] = src;
+    }
+
+    void pop_back()
+    {
+        VMA_HEAVY_ASSERT(m_Count > 0);
+        resize(size() - 1);
+    }
+
+    void push_front(const T& src)
+    {
+        insert(0, src);
+    }
+
+    void pop_front()
+    {
+        VMA_HEAVY_ASSERT(m_Count > 0);
+        remove(0);
+    }
+
+    typedef T* iterator;
+
+    iterator begin() { return data(); }
+    iterator end() { return data() + m_Count; }
+
+private:
+    size_t m_Count;
+    T m_StaticArray[N]; // Used when m_Size <= N
+    VmaVector<T, AllocatorT> m_DynamicArray; // Used when m_Size > N
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// class VmaPoolAllocator
+
+/*
+Allocator for objects of type T using a list of arrays (pools) to speed up
+allocation. Number of elements that can be allocated is not bounded because
+allocator can create multiple blocks.
+*/
+template<typename T>
+class VmaPoolAllocator
+{
+    VMA_CLASS_NO_COPY(VmaPoolAllocator)
+public:
+    VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, uint32_t firstBlockCapacity);
+    ~VmaPoolAllocator();
+    template<typename... Types> T* Alloc(Types... args);
+    void Free(T* ptr);
+
+private:
+    union Item
+    {
+        uint32_t NextFreeIndex;
+        alignas(T) char Value[sizeof(T)];
+    };
+
+    struct ItemBlock
+    {
+        Item* pItems;
+        uint32_t Capacity;
+        uint32_t FirstFreeIndex;
+    };
+
+    const VkAllocationCallbacks* m_pAllocationCallbacks;
+    const uint32_t m_FirstBlockCapacity;
+    VmaVector< ItemBlock, VmaStlAllocator<ItemBlock> > m_ItemBlocks;
+
+    ItemBlock& CreateNewBlock();
+};
+
+template<typename T>
+VmaPoolAllocator<T>::VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, uint32_t firstBlockCapacity) :
+    m_pAllocationCallbacks(pAllocationCallbacks),
+    m_FirstBlockCapacity(firstBlockCapacity),
+    m_ItemBlocks(VmaStlAllocator<ItemBlock>(pAllocationCallbacks))
+{
+    VMA_ASSERT(m_FirstBlockCapacity > 1);
+}
+
+template<typename T>
+VmaPoolAllocator<T>::~VmaPoolAllocator()
+{
+    for(size_t i = m_ItemBlocks.size(); i--; )
+        vma_delete_array(m_pAllocationCallbacks, m_ItemBlocks[i].pItems, m_ItemBlocks[i].Capacity);
+    m_ItemBlocks.clear();
+}
+
+template<typename T>
+template<typename... Types> T* VmaPoolAllocator<T>::Alloc(Types... args)
+{
+    for(size_t i = m_ItemBlocks.size(); i--; )
+    {
+        ItemBlock& block = m_ItemBlocks[i];
+        // This block has some free items: Use first one.
+        if(block.FirstFreeIndex != UINT32_MAX)
+        {
+            Item* const pItem = &block.pItems[block.FirstFreeIndex];
+            block.FirstFreeIndex = pItem->NextFreeIndex;
+            T* result = (T*)&pItem->Value;
+            new(result)T(std::forward<Types>(args)...); // Explicit constructor call.
+            return result;
+        }
+    }
+
+    // No block has free item: Create new one and use it.
+    ItemBlock& newBlock = CreateNewBlock();
+    Item* const pItem = &newBlock.pItems[0];
+    newBlock.FirstFreeIndex = pItem->NextFreeIndex;
+    T* result = (T*)&pItem->Value;
+    new(result)T(std::forward<Types>(args)...); // Explicit constructor call.
+    return result;
+}
+
+template<typename T>
+void VmaPoolAllocator<T>::Free(T* ptr)
+{
+    // Search all memory blocks to find ptr.
+    for(size_t i = m_ItemBlocks.size(); i--; )
+    {
+        ItemBlock& block = m_ItemBlocks[i];
+
+        // Casting to union.
+        Item* pItemPtr;
+        memcpy(&pItemPtr, &ptr, sizeof(pItemPtr));
+
+        // Check if pItemPtr is in address range of this block.
+        if((pItemPtr >= block.pItems) && (pItemPtr < block.pItems + block.Capacity))
+        {
+            ptr->~T(); // Explicit destructor call.
+            const uint32_t index = static_cast<uint32_t>(pItemPtr - block.pItems);
+            pItemPtr->NextFreeIndex = block.FirstFreeIndex;
+            block.FirstFreeIndex = index;
+            return;
+        }
+    }
+    VMA_ASSERT(0 && "Pointer doesn't belong to this memory pool.");
+}
+
+template<typename T>
+typename VmaPoolAllocator<T>::ItemBlock& VmaPoolAllocator<T>::CreateNewBlock()
+{
+    const uint32_t newBlockCapacity = m_ItemBlocks.empty() ?
+        m_FirstBlockCapacity : m_ItemBlocks.back().Capacity * 3 / 2;
+
+    const ItemBlock newBlock = {
+        vma_new_array(m_pAllocationCallbacks, Item, newBlockCapacity),
+        newBlockCapacity,
+        0 };
+
+    m_ItemBlocks.push_back(newBlock);
+
+    // Setup singly-linked list of all free items in this block.
+    for(uint32_t i = 0; i < newBlockCapacity - 1; ++i)
+        newBlock.pItems[i].NextFreeIndex = i + 1;
+    newBlock.pItems[newBlockCapacity - 1].NextFreeIndex = UINT32_MAX;
+    return m_ItemBlocks.back();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// class VmaRawList, VmaList
+
+#if VMA_USE_STL_LIST
+
+#define VmaList std::list
+
+#else // #if VMA_USE_STL_LIST
+
+template<typename T>
+struct VmaListItem
+{
+    VmaListItem* pPrev;
+    VmaListItem* pNext;
+    T Value;
+};
+
+// Doubly linked list.
+template<typename T>
+class VmaRawList
+{
+    VMA_CLASS_NO_COPY(VmaRawList)
+public:
+    typedef VmaListItem<T> ItemType;
+
+    VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks);
+    ~VmaRawList();
+    void Clear();
+
+    size_t GetCount() const { return m_Count; }
+    bool IsEmpty() const { return m_Count == 0; }
+
+    ItemType* Front() { return m_pFront; }
+    const ItemType* Front() const { return m_pFront; }
+    ItemType* Back() { return m_pBack; }
+    const ItemType* Back() const { return m_pBack; }
+
+    ItemType* PushBack();
+    ItemType* PushFront();
+    ItemType* PushBack(const T& value);
+    ItemType* PushFront(const T& value);
+    void PopBack();
+    void PopFront();
+
+    // Item can be null - it means PushBack.
+    ItemType* InsertBefore(ItemType* pItem);
+    // Item can be null - it means PushFront.
+    ItemType* InsertAfter(ItemType* pItem);
+
+    ItemType* InsertBefore(ItemType* pItem, const T& value);
+    ItemType* InsertAfter(ItemType* pItem, const T& value);
+
+    void Remove(ItemType* pItem);
+
+private:
+    const VkAllocationCallbacks* const m_pAllocationCallbacks;
+    VmaPoolAllocator<ItemType> m_ItemAllocator;
+    ItemType* m_pFront;
+    ItemType* m_pBack;
+    size_t m_Count;
+};
+
+template<typename T>
+VmaRawList<T>::VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks) :
+    m_pAllocationCallbacks(pAllocationCallbacks),
+    m_ItemAllocator(pAllocationCallbacks, 128),
+    m_pFront(VMA_NULL),
+    m_pBack(VMA_NULL),
+    m_Count(0)
+{
+}
+
+template<typename T>
+VmaRawList<T>::~VmaRawList()
+{
+    // Intentionally not calling Clear, because that would be unnecessary
+    // computations to return all items to m_ItemAllocator as free.
+}
+
+template<typename T>
+void VmaRawList<T>::Clear()
+{
+    if(IsEmpty() == false)
+    {
+        ItemType* pItem = m_pBack;
+        while(pItem != VMA_NULL)
+        {
+            ItemType* const pPrevItem = pItem->pPrev;
+            m_ItemAllocator.Free(pItem);
+            pItem = pPrevItem;
+        }
+        m_pFront = VMA_NULL;
+        m_pBack = VMA_NULL;
+        m_Count = 0;
+    }
+}
+
+template<typename T>
+VmaListItem<T>* VmaRawList<T>::PushBack()
+{
+    ItemType* const pNewItem = m_ItemAllocator.Alloc();
+    pNewItem->pNext = VMA_NULL;
+    if(IsEmpty())
+    {
+        pNewItem->pPrev = VMA_NULL;
+        m_pFront = pNewItem;
+        m_pBack = pNewItem;
+        m_Count = 1;
+    }
+    else
+    {
+        pNewItem->pPrev = m_pBack;
+        m_pBack->pNext = pNewItem;
+        m_pBack = pNewItem;
+        ++m_Count;
+    }
+    return pNewItem;
+}
+
+template<typename T>
+VmaListItem<T>* VmaRawList<T>::PushFront()
+{
+    ItemType* const pNewItem = m_ItemAllocator.Alloc();
+    pNewItem->pPrev = VMA_NULL;
+    if(IsEmpty())
+    {
+        pNewItem->pNext = VMA_NULL;
+        m_pFront = pNewItem;
+        m_pBack = pNewItem;
+        m_Count = 1;
+    }
+    else
+    {
+        pNewItem->pNext = m_pFront;
+        m_pFront->pPrev = pNewItem;
+        m_pFront = pNewItem;
+        ++m_Count;
+    }
+    return pNewItem;
+}
+
+template<typename T>
+VmaListItem<T>* VmaRawList<T>::PushBack(const T& value)
+{
+    ItemType* const pNewItem = PushBack();
+    pNewItem->Value = value;
+    return pNewItem;
+}
+
+template<typename T>
+VmaListItem<T>* VmaRawList<T>::PushFront(const T& value)
+{
+    ItemType* const pNewItem = PushFront();
+    pNewItem->Value = value;
+    return pNewItem;
+}
+
+template<typename T>
+void VmaRawList<T>::PopBack()
+{
+    VMA_HEAVY_ASSERT(m_Count > 0);
+    ItemType* const pBackItem = m_pBack;
+    ItemType* const pPrevItem = pBackItem->pPrev;
+    if(pPrevItem != VMA_NULL)
+    {
+        pPrevItem->pNext = VMA_NULL;
+    }
+    m_pBack = pPrevItem;
+    m_ItemAllocator.Free(pBackItem);
+    --m_Count;
+}
+
+template<typename T>
+void VmaRawList<T>::PopFront()
+{
+    VMA_HEAVY_ASSERT(m_Count > 0);
+    ItemType* const pFrontItem = m_pFront;
+    ItemType* const pNextItem = pFrontItem->pNext;
+    if(pNextItem != VMA_NULL)
+    {
+        pNextItem->pPrev = VMA_NULL;
+    }
+    m_pFront = pNextItem;
+    m_ItemAllocator.Free(pFrontItem);
+    --m_Count;
+}
+
+template<typename T>
+void VmaRawList<T>::Remove(ItemType* pItem)
+{
+    VMA_HEAVY_ASSERT(pItem != VMA_NULL);
+    VMA_HEAVY_ASSERT(m_Count > 0);
+
+    if(pItem->pPrev != VMA_NULL)
+    {
+        pItem->pPrev->pNext = pItem->pNext;
+    }
+    else
+    {
+        VMA_HEAVY_ASSERT(m_pFront == pItem);
+        m_pFront = pItem->pNext;
+    }
+
+    if(pItem->pNext != VMA_NULL)
+    {
+        pItem->pNext->pPrev = pItem->pPrev;
+    }
+    else
+    {
+        VMA_HEAVY_ASSERT(m_pBack == pItem);
+        m_pBack = pItem->pPrev;
+    }
+
+    m_ItemAllocator.Free(pItem);
+    --m_Count;
+}
+
+template<typename T>
+VmaListItem<T>* VmaRawList<T>::InsertBefore(ItemType* pItem)
+{
+    if(pItem != VMA_NULL)
+    {
+        ItemType* const prevItem = pItem->pPrev;
+        ItemType* const newItem = m_ItemAllocator.Alloc();
+        newItem->pPrev = prevItem;
+        newItem->pNext = pItem;
+        pItem->pPrev = newItem;
+        if(prevItem != VMA_NULL)
+        {
+            prevItem->pNext = newItem;
+        }
+        else
+        {
+            VMA_HEAVY_ASSERT(m_pFront == pItem);
+            m_pFront = newItem;
+        }
+        ++m_Count;
+        return newItem;
+    }
+    else
+        return PushBack();
+}
+
+template<typename T>
+VmaListItem<T>* VmaRawList<T>::InsertAfter(ItemType* pItem)
+{
+    if(pItem != VMA_NULL)
+    {
+        ItemType* const nextItem = pItem->pNext;
+        ItemType* const newItem = m_ItemAllocator.Alloc();
+        newItem->pNext = nextItem;
+        newItem->pPrev = pItem;
+        pItem->pNext = newItem;
+        if(nextItem != VMA_NULL)
+        {
+            nextItem->pPrev = newItem;
+        }
+        else
+        {
+            VMA_HEAVY_ASSERT(m_pBack == pItem);
+            m_pBack = newItem;
+        }
+        ++m_Count;
+        return newItem;
+    }
+    else
+        return PushFront();
+}
+
+template<typename T>
+VmaListItem<T>* VmaRawList<T>::InsertBefore(ItemType* pItem, const T& value)
+{
+    ItemType* const newItem = InsertBefore(pItem);
+    newItem->Value = value;
+    return newItem;
+}
+
+template<typename T>
+VmaListItem<T>* VmaRawList<T>::InsertAfter(ItemType* pItem, const T& value)
+{
+    ItemType* const newItem = InsertAfter(pItem);
+    newItem->Value = value;
+    return newItem;
+}
+
+template<typename T, typename AllocatorT>
+class VmaList
+{
+    VMA_CLASS_NO_COPY(VmaList)
+public:
+    class iterator
+    {
+    public:
+        iterator() :
+            m_pList(VMA_NULL),
+            m_pItem(VMA_NULL)
+        {
+        }
+
+        T& operator*() const
+        {
+            VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
+            return m_pItem->Value;
+        }
+        T* operator->() const
+        {
+            VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
+            return &m_pItem->Value;
+        }
+
+        iterator& operator++()
+        {
+            VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
+            m_pItem = m_pItem->pNext;
+            return *this;
+        }
+        iterator& operator--()
+        {
+            if(m_pItem != VMA_NULL)
+            {
+                m_pItem = m_pItem->pPrev;
+            }
+            else
+            {
+                VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
+                m_pItem = m_pList->Back();
+            }
+            return *this;
+        }
+
+        iterator operator++(int)
+        {
+            iterator result = *this;
+            ++*this;
+            return result;
+        }
+        iterator operator--(int)
+        {
+            iterator result = *this;
+            --*this;
+            return result;
+        }
+
+        bool operator==(const iterator& rhs) const
+        {
+            VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
+            return m_pItem == rhs.m_pItem;
+        }
+        bool operator!=(const iterator& rhs) const
+        {
+            VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
+            return m_pItem != rhs.m_pItem;
+        }
+
+    private:
+        VmaRawList<T>* m_pList;
+        VmaListItem<T>* m_pItem;
+
+        iterator(VmaRawList<T>* pList, VmaListItem<T>* pItem) :
+            m_pList(pList),
+            m_pItem(pItem)
+        {
+        }
+
+        friend class VmaList<T, AllocatorT>;
+    };
+
+    class const_iterator
+    {
+    public:
+        const_iterator() :
+            m_pList(VMA_NULL),
+            m_pItem(VMA_NULL)
+        {
+        }
+
+        const_iterator(const iterator& src) :
+            m_pList(src.m_pList),
+            m_pItem(src.m_pItem)
+        {
+        }
+
+        const T& operator*() const
+        {
+            VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
+            return m_pItem->Value;
+        }
+        const T* operator->() const
+        {
+            VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
+            return &m_pItem->Value;
+        }
+
+        const_iterator& operator++()
+        {
+            VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
+            m_pItem = m_pItem->pNext;
+            return *this;
+        }
+        const_iterator& operator--()
+        {
+            if(m_pItem != VMA_NULL)
+            {
+                m_pItem = m_pItem->pPrev;
+            }
+            else
+            {
+                VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
+                m_pItem = m_pList->Back();
+            }
+            return *this;
+        }
+
+        const_iterator operator++(int)
+        {
+            const_iterator result = *this;
+            ++*this;
+            return result;
+        }
+        const_iterator operator--(int)
+        {
+            const_iterator result = *this;
+            --*this;
+            return result;
+        }
+
+        bool operator==(const const_iterator& rhs) const
+        {
+            VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
+            return m_pItem == rhs.m_pItem;
+        }
+        bool operator!=(const const_iterator& rhs) const
+        {
+            VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
+            return m_pItem != rhs.m_pItem;
+        }
+
+    private:
+        const_iterator(const VmaRawList<T>* pList, const VmaListItem<T>* pItem) :
+            m_pList(pList),
+            m_pItem(pItem)
+        {
+        }
+
+        const VmaRawList<T>* m_pList;
+        const VmaListItem<T>* m_pItem;
+
+        friend class VmaList<T, AllocatorT>;
+    };
+
+    VmaList(const AllocatorT& allocator) : m_RawList(allocator.m_pCallbacks) { }
+
+    bool empty() const { return m_RawList.IsEmpty(); }
+    size_t size() const { return m_RawList.GetCount(); }
+
+    iterator begin() { return iterator(&m_RawList, m_RawList.Front()); }
+    iterator end() { return iterator(&m_RawList, VMA_NULL); }
+
+    const_iterator cbegin() const { return const_iterator(&m_RawList, m_RawList.Front()); }
+    const_iterator cend() const { return const_iterator(&m_RawList, VMA_NULL); }
+
+    void clear() { m_RawList.Clear(); }
+    void push_back(const T& value) { m_RawList.PushBack(value); }
+    void erase(iterator it) { m_RawList.Remove(it.m_pItem); }
+    iterator insert(iterator it, const T& value) { return iterator(&m_RawList, m_RawList.InsertBefore(it.m_pItem, value)); }
+
+private:
+    VmaRawList<T> m_RawList;
+};
+
+#endif // #if VMA_USE_STL_LIST
+
+////////////////////////////////////////////////////////////////////////////////
+// class VmaMap
+
+// Unused in this version.
+#if 0
+
+#if VMA_USE_STL_UNORDERED_MAP
+
+#define VmaPair std::pair
+
+#define VMA_MAP_TYPE(KeyT, ValueT) \
+    std::unordered_map< KeyT, ValueT, std::hash<KeyT>, std::equal_to<KeyT>, VmaStlAllocator< std::pair<KeyT, ValueT> > >
+
+#else // #if VMA_USE_STL_UNORDERED_MAP
+
+template<typename T1, typename T2>
+struct VmaPair
+{
+    T1 first;
+    T2 second;
+
+    VmaPair() : first(), second() { }
+    VmaPair(const T1& firstSrc, const T2& secondSrc) : first(firstSrc), second(secondSrc) { }
+};
+
+/* Class compatible with subset of interface of std::unordered_map.
+KeyT, ValueT must be POD because they will be stored in VmaVector.
+*/
+template<typename KeyT, typename ValueT>
+class VmaMap
+{
+public:
+    typedef VmaPair<KeyT, ValueT> PairType;
+    typedef PairType* iterator;
+
+    VmaMap(const VmaStlAllocator<PairType>& allocator) : m_Vector(allocator) { }
+
+    iterator begin() { return m_Vector.begin(); }
+    iterator end() { return m_Vector.end(); }
+
+    void insert(const PairType& pair);
+    iterator find(const KeyT& key);
+    void erase(iterator it);
+
+private:
+    VmaVector< PairType, VmaStlAllocator<PairType> > m_Vector;
+};
+
+#define VMA_MAP_TYPE(KeyT, ValueT) VmaMap<KeyT, ValueT>
+
+template<typename FirstT, typename SecondT>
+struct VmaPairFirstLess
+{
+    bool operator()(const VmaPair<FirstT, SecondT>& lhs, const VmaPair<FirstT, SecondT>& rhs) const
+    {
+        return lhs.first < rhs.first;
+    }
+    bool operator()(const VmaPair<FirstT, SecondT>& lhs, const FirstT& rhsFirst) const
+    {
+        return lhs.first < rhsFirst;
+    }
+};
+
+template<typename KeyT, typename ValueT>
+void VmaMap<KeyT, ValueT>::insert(const PairType& pair)
+{
+    const size_t indexToInsert = VmaBinaryFindFirstNotLess(
+        m_Vector.data(),
+        m_Vector.data() + m_Vector.size(),
+        pair,
+        VmaPairFirstLess<KeyT, ValueT>()) - m_Vector.data();
+    VmaVectorInsert(m_Vector, indexToInsert, pair);
+}
+
+template<typename KeyT, typename ValueT>
+VmaPair<KeyT, ValueT>* VmaMap<KeyT, ValueT>::find(const KeyT& key)
+{
+    PairType* it = VmaBinaryFindFirstNotLess(
+        m_Vector.data(),
+        m_Vector.data() + m_Vector.size(),
+        key,
+        VmaPairFirstLess<KeyT, ValueT>());
+    if((it != m_Vector.end()) && (it->first == key))
+    {
+        return it;
+    }
+    else
+    {
+        return m_Vector.end();
+    }
+}
+
+template<typename KeyT, typename ValueT>
+void VmaMap<KeyT, ValueT>::erase(iterator it)
+{
+    VmaVectorRemove(m_Vector, it - m_Vector.begin());
+}
+
+#endif // #if VMA_USE_STL_UNORDERED_MAP
+
+#endif // #if 0
+
+////////////////////////////////////////////////////////////////////////////////
+
+class VmaDeviceMemoryBlock;
+
+enum VMA_CACHE_OPERATION { VMA_CACHE_FLUSH, VMA_CACHE_INVALIDATE };
+
+struct VmaAllocation_T
+{
+private:
+    static const uint8_t MAP_COUNT_FLAG_PERSISTENT_MAP = 0x80;
+
+    enum FLAGS
+    {
+        FLAG_USER_DATA_STRING = 0x01,
+    };
+
+public:
+    enum ALLOCATION_TYPE
+    {
+        ALLOCATION_TYPE_NONE,
+        ALLOCATION_TYPE_BLOCK,
+        ALLOCATION_TYPE_DEDICATED,
+    };
+
+    /*
+    This struct is allocated using VmaPoolAllocator.
+    */
+
+    VmaAllocation_T(uint32_t currentFrameIndex, bool userDataString) :
+        m_Alignment{1},
+        m_Size{0},
+        m_pUserData{VMA_NULL},
+        m_LastUseFrameIndex{currentFrameIndex},
+        m_MemoryTypeIndex{0},
+        m_Type{(uint8_t)ALLOCATION_TYPE_NONE},
+        m_SuballocationType{(uint8_t)VMA_SUBALLOCATION_TYPE_UNKNOWN},
+        m_MapCount{0},
+        m_Flags{userDataString ? (uint8_t)FLAG_USER_DATA_STRING : (uint8_t)0}
+    {
+#if VMA_STATS_STRING_ENABLED
+        m_CreationFrameIndex = currentFrameIndex;
+        m_BufferImageUsage = 0;
+#endif
+    }
+
+    ~VmaAllocation_T()
+    {
+        VMA_ASSERT((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) == 0 && "Allocation was not unmapped before destruction.");
+
+        // Check if owned string was freed.
+        VMA_ASSERT(m_pUserData == VMA_NULL);
+    }
+
+    void InitBlockAllocation(
+        VmaDeviceMemoryBlock* block,
+        VkDeviceSize offset,
+        VkDeviceSize alignment,
+        VkDeviceSize size,
+        uint32_t memoryTypeIndex,
+        VmaSuballocationType suballocationType,
+        bool mapped,
+        bool canBecomeLost)
+    {
+        VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
+        VMA_ASSERT(block != VMA_NULL);
+        m_Type = (uint8_t)ALLOCATION_TYPE_BLOCK;
+        m_Alignment = alignment;
+        m_Size = size;
+        m_MemoryTypeIndex = memoryTypeIndex;
+        m_MapCount = mapped ? MAP_COUNT_FLAG_PERSISTENT_MAP : 0;
+        m_SuballocationType = (uint8_t)suballocationType;
+        m_BlockAllocation.m_Block = block;
+        m_BlockAllocation.m_Offset = offset;
+        m_BlockAllocation.m_CanBecomeLost = canBecomeLost;
+    }
+
+    void InitLost()
+    {
+        VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
+        VMA_ASSERT(m_LastUseFrameIndex.load() == VMA_FRAME_INDEX_LOST);
+        m_Type = (uint8_t)ALLOCATION_TYPE_BLOCK;
+        m_MemoryTypeIndex = 0;
+        m_BlockAllocation.m_Block = VMA_NULL;
+        m_BlockAllocation.m_Offset = 0;
+        m_BlockAllocation.m_CanBecomeLost = true;
+    }
+
+    void ChangeBlockAllocation(
+        VmaAllocator hAllocator,
+        VmaDeviceMemoryBlock* block,
+        VkDeviceSize offset);
+
+    void ChangeOffset(VkDeviceSize newOffset);
+
+    // pMappedData not null means allocation is created with MAPPED flag.
+    void InitDedicatedAllocation(
+        uint32_t memoryTypeIndex,
+        VkDeviceMemory hMemory,
+        VmaSuballocationType suballocationType,
+        void* pMappedData,
+        VkDeviceSize size)
+    {
+        VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
+        VMA_ASSERT(hMemory != VK_NULL_HANDLE);
+        m_Type = (uint8_t)ALLOCATION_TYPE_DEDICATED;
+        m_Alignment = 0;
+        m_Size = size;
+        m_MemoryTypeIndex = memoryTypeIndex;
+        m_SuballocationType = (uint8_t)suballocationType;
+        m_MapCount = (pMappedData != VMA_NULL) ? MAP_COUNT_FLAG_PERSISTENT_MAP : 0;
+        m_DedicatedAllocation.m_hMemory = hMemory;
+        m_DedicatedAllocation.m_pMappedData = pMappedData;
+    }
+
+    ALLOCATION_TYPE GetType() const { return (ALLOCATION_TYPE)m_Type; }
+    VkDeviceSize GetAlignment() const { return m_Alignment; }
+    VkDeviceSize GetSize() const { return m_Size; }
+    bool IsUserDataString() const { return (m_Flags & FLAG_USER_DATA_STRING) != 0; }
+    void* GetUserData() const { return m_pUserData; }
+    void SetUserData(VmaAllocator hAllocator, void* pUserData);
+    VmaSuballocationType GetSuballocationType() const { return (VmaSuballocationType)m_SuballocationType; }
+
+    VmaDeviceMemoryBlock* GetBlock() const
+    {
+        VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
+        return m_BlockAllocation.m_Block;
+    }
+    VkDeviceSize GetOffset() const;
+    VkDeviceMemory GetMemory() const;
+    uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
+    bool IsPersistentMap() const { return (m_MapCount & MAP_COUNT_FLAG_PERSISTENT_MAP) != 0; }
+    void* GetMappedData() const;
+    bool CanBecomeLost() const;
+
+    uint32_t GetLastUseFrameIndex() const
+    {
+        return m_LastUseFrameIndex.load();
+    }
+    bool CompareExchangeLastUseFrameIndex(uint32_t& expected, uint32_t desired)
+    {
+        return m_LastUseFrameIndex.compare_exchange_weak(expected, desired);
+    }
+    /*
+    - If hAllocation.LastUseFrameIndex + frameInUseCount < allocator.CurrentFrameIndex,
+      makes it lost by setting LastUseFrameIndex = VMA_FRAME_INDEX_LOST and returns true.
+    - Else, returns false.
+
+    If hAllocation is already lost, assert - you should not call it then.
+    If hAllocation was not created with CAN_BECOME_LOST_BIT, assert.
+    */
+    bool MakeLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
+
+    void DedicatedAllocCalcStatsInfo(VmaStatInfo& outInfo)
+    {
+        VMA_ASSERT(m_Type == ALLOCATION_TYPE_DEDICATED);
+        outInfo.blockCount = 1;
+        outInfo.allocationCount = 1;
+        outInfo.unusedRangeCount = 0;
+        outInfo.usedBytes = m_Size;
+        outInfo.unusedBytes = 0;
+        outInfo.allocationSizeMin = outInfo.allocationSizeMax = m_Size;
+        outInfo.unusedRangeSizeMin = UINT64_MAX;
+        outInfo.unusedRangeSizeMax = 0;
+    }
+
+    void BlockAllocMap();
+    void BlockAllocUnmap();
+    VkResult DedicatedAllocMap(VmaAllocator hAllocator, void** ppData);
+    void DedicatedAllocUnmap(VmaAllocator hAllocator);
+
+#if VMA_STATS_STRING_ENABLED
+    uint32_t GetCreationFrameIndex() const { return m_CreationFrameIndex; }
+    uint32_t GetBufferImageUsage() const { return m_BufferImageUsage; }
+
+    void InitBufferImageUsage(uint32_t bufferImageUsage)
+    {
+        VMA_ASSERT(m_BufferImageUsage == 0);
+        m_BufferImageUsage = bufferImageUsage;
+    }
+
+    void PrintParameters(class VmaJsonWriter& json) const;
+#endif
+
+private:
+    VkDeviceSize m_Alignment;
+    VkDeviceSize m_Size;
+    void* m_pUserData;
+    VMA_ATOMIC_UINT32 m_LastUseFrameIndex;
+    uint32_t m_MemoryTypeIndex;
+    uint8_t m_Type; // ALLOCATION_TYPE
+    uint8_t m_SuballocationType; // VmaSuballocationType
+    // Bit 0x80 is set when allocation was created with VMA_ALLOCATION_CREATE_MAPPED_BIT.
+    // Bits with mask 0x7F are reference counter for vmaMapMemory()/vmaUnmapMemory().
+    uint8_t m_MapCount;
+    uint8_t m_Flags; // enum FLAGS
+
+    // Allocation out of VmaDeviceMemoryBlock.
+    struct BlockAllocation
+    {
+        VmaDeviceMemoryBlock* m_Block;
+        VkDeviceSize m_Offset;
+        bool m_CanBecomeLost;
+    };
+
+    // Allocation for an object that has its own private VkDeviceMemory.
+    struct DedicatedAllocation
+    {
+        VkDeviceMemory m_hMemory;
+        void* m_pMappedData; // Not null means memory is mapped.
+    };
+
+    union
+    {
+        // Allocation out of VmaDeviceMemoryBlock.
+        BlockAllocation m_BlockAllocation;
+        // Allocation for an object that has its own private VkDeviceMemory.
+        DedicatedAllocation m_DedicatedAllocation;
+    };
+
+#if VMA_STATS_STRING_ENABLED
+    uint32_t m_CreationFrameIndex;
+    uint32_t m_BufferImageUsage; // 0 if unknown.
+#endif
+
+    void FreeUserDataString(VmaAllocator hAllocator);
+};
+
+/*
+Represents a region of VmaDeviceMemoryBlock that is either assigned and returned as
+allocated memory block or free.
+*/
+struct VmaSuballocation
+{
+    VkDeviceSize offset;
+    VkDeviceSize size;
+    VmaAllocation hAllocation;
+    VmaSuballocationType type;
+};
+
+// Comparator for offsets.
+struct VmaSuballocationOffsetLess
+{
+    bool operator()(const VmaSuballocation& lhs, const VmaSuballocation& rhs) const
+    {
+        return lhs.offset < rhs.offset;
+    }
+};
+struct VmaSuballocationOffsetGreater
+{
+    bool operator()(const VmaSuballocation& lhs, const VmaSuballocation& rhs) const
+    {
+        return lhs.offset > rhs.offset;
+    }
+};
+
+typedef VmaList< VmaSuballocation, VmaStlAllocator<VmaSuballocation> > VmaSuballocationList;
+
+// Cost of one additional allocation lost, as equivalent in bytes.
+static const VkDeviceSize VMA_LOST_ALLOCATION_COST = 1048576;
+
+enum class VmaAllocationRequestType
+{
+    Normal,
+    // Used by "Linear" algorithm.
+    UpperAddress,
+    EndOf1st,
+    EndOf2nd,
+};
+
+/*
+Parameters of planned allocation inside a VmaDeviceMemoryBlock.
+
+If canMakeOtherLost was false:
+- item points to a FREE suballocation.
+- itemsToMakeLostCount is 0.
+
+If canMakeOtherLost was true:
+- item points to first of sequence of suballocations, which are either FREE,
+  or point to VmaAllocations that can become lost.
+- itemsToMakeLostCount is the number of VmaAllocations that need to be made lost for
+  the requested allocation to succeed.
+*/
+struct VmaAllocationRequest
+{
+    VkDeviceSize offset;
+    VkDeviceSize sumFreeSize; // Sum size of free items that overlap with proposed allocation.
+    VkDeviceSize sumItemSize; // Sum size of items to make lost that overlap with proposed allocation.
+    VmaSuballocationList::iterator item;
+    size_t itemsToMakeLostCount;
+    void* customData;
+    VmaAllocationRequestType type;
+
+    VkDeviceSize CalcCost() const
+    {
+        return sumItemSize + itemsToMakeLostCount * VMA_LOST_ALLOCATION_COST;
+    }
+};
+
+/*
+Data structure used for bookkeeping of allocations and unused ranges of memory
+in a single VkDeviceMemory block.
+*/
+class VmaBlockMetadata
+{
+public:
+    VmaBlockMetadata(VmaAllocator hAllocator);
+    virtual ~VmaBlockMetadata() { }
+    virtual void Init(VkDeviceSize size) { m_Size = size; }
+
+    // Validates all data structures inside this object. If not valid, returns false.
+    virtual bool Validate() const = 0;
+    VkDeviceSize GetSize() const { return m_Size; }
+    virtual size_t GetAllocationCount() const = 0;
+    virtual VkDeviceSize GetSumFreeSize() const = 0;
+    virtual VkDeviceSize GetUnusedRangeSizeMax() const = 0;
+    // Returns true if this block is empty - contains only single free suballocation.
+    virtual bool IsEmpty() const = 0;
+
+    virtual void CalcAllocationStatInfo(VmaStatInfo& outInfo) const = 0;
+    // Shouldn't modify blockCount.
+    virtual void AddPoolStats(VmaPoolStats& inoutStats) const = 0;
+
+#if VMA_STATS_STRING_ENABLED
+    virtual void PrintDetailedMap(class VmaJsonWriter& json) const = 0;
+#endif
+
+    // Tries to find a place for suballocation with given parameters inside this block.
+    // If succeeded, fills pAllocationRequest and returns true.
+    // If failed, returns false.
+    virtual bool CreateAllocationRequest(
+        uint32_t currentFrameIndex,
+        uint32_t frameInUseCount,
+        VkDeviceSize bufferImageGranularity,
+        VkDeviceSize allocSize,
+        VkDeviceSize allocAlignment,
+        bool upperAddress,
+        VmaSuballocationType allocType,
+        bool canMakeOtherLost,
+        // Always one of VMA_ALLOCATION_CREATE_STRATEGY_* or VMA_ALLOCATION_INTERNAL_STRATEGY_* flags.
+        uint32_t strategy,
+        VmaAllocationRequest* pAllocationRequest) = 0;
+
+    virtual bool MakeRequestedAllocationsLost(
+        uint32_t currentFrameIndex,
+        uint32_t frameInUseCount,
+        VmaAllocationRequest* pAllocationRequest) = 0;
+
+    virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount) = 0;
+
+    virtual VkResult CheckCorruption(const void* pBlockData) = 0;
+
+    // Makes actual allocation based on request. Request must already be checked and valid.
+    virtual void Alloc(
+        const VmaAllocationRequest& request,
+        VmaSuballocationType type,
+        VkDeviceSize allocSize,
+        VmaAllocation hAllocation) = 0;
+
+    // Frees suballocation assigned to given memory region.
+    virtual void Free(const VmaAllocation allocation) = 0;
+    virtual void FreeAtOffset(VkDeviceSize offset) = 0;
+
+protected:
+    const VkAllocationCallbacks* GetAllocationCallbacks() const { return m_pAllocationCallbacks; }
+
+#if VMA_STATS_STRING_ENABLED
+    void PrintDetailedMap_Begin(class VmaJsonWriter& json,
+        VkDeviceSize unusedBytes,
+        size_t allocationCount,
+        size_t unusedRangeCount) const;
+    void PrintDetailedMap_Allocation(class VmaJsonWriter& json,
+        VkDeviceSize offset,
+        VmaAllocation hAllocation) const;
+    void PrintDetailedMap_UnusedRange(class VmaJsonWriter& json,
+        VkDeviceSize offset,
+        VkDeviceSize size) const;
+    void PrintDetailedMap_End(class VmaJsonWriter& json) const;
+#endif
+
+private:
+    VkDeviceSize m_Size;
+    const VkAllocationCallbacks* m_pAllocationCallbacks;
+};
+
+#define VMA_VALIDATE(cond) do { if(!(cond)) { \
+        VMA_ASSERT(0 && "Validation failed: " #cond); \
+        return false; \
+    } } while(false)
+
+class VmaBlockMetadata_Generic : public VmaBlockMetadata
+{
+    VMA_CLASS_NO_COPY(VmaBlockMetadata_Generic)
+public:
+    VmaBlockMetadata_Generic(VmaAllocator hAllocator);
+    virtual ~VmaBlockMetadata_Generic();
+    virtual void Init(VkDeviceSize size);
+
+    virtual bool Validate() const;
+    virtual size_t GetAllocationCount() const { return m_Suballocations.size() - m_FreeCount; }
+    virtual VkDeviceSize GetSumFreeSize() const { return m_SumFreeSize; }
+    virtual VkDeviceSize GetUnusedRangeSizeMax() const;
+    virtual bool IsEmpty() const;
+
+    virtual void CalcAllocationStatInfo(VmaStatInfo& outInfo) const;
+    virtual void AddPoolStats(VmaPoolStats& inoutStats) const;
+
+#if VMA_STATS_STRING_ENABLED
+    virtual void PrintDetailedMap(class VmaJsonWriter& json) const;
+#endif
+
+    virtual bool CreateAllocationRequest(
+        uint32_t currentFrameIndex,
+        uint32_t frameInUseCount,
+        VkDeviceSize bufferImageGranularity,
+        VkDeviceSize allocSize,
+        VkDeviceSize allocAlignment,
+        bool upperAddress,
+        VmaSuballocationType allocType,
+        bool canMakeOtherLost,
+        uint32_t strategy,
+        VmaAllocationRequest* pAllocationRequest);
+
+    virtual bool MakeRequestedAllocationsLost(
+        uint32_t currentFrameIndex,
+        uint32_t frameInUseCount,
+        VmaAllocationRequest* pAllocationRequest);
+
+    virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
+
+    virtual VkResult CheckCorruption(const void* pBlockData);
+
+    virtual void Alloc(
+        const VmaAllocationRequest& request,
+        VmaSuballocationType type,
+        VkDeviceSize allocSize,
+        VmaAllocation hAllocation);
+
+    virtual void Free(const VmaAllocation allocation);
+    virtual void FreeAtOffset(VkDeviceSize offset);
+
+    ////////////////////////////////////////////////////////////////////////////////
+    // For defragmentation
+
+    bool IsBufferImageGranularityConflictPossible(
+        VkDeviceSize bufferImageGranularity,
+        VmaSuballocationType& inOutPrevSuballocType) const;
+
+private:
+    friend class VmaDefragmentationAlgorithm_Generic;
+    friend class VmaDefragmentationAlgorithm_Fast;
+
+    uint32_t m_FreeCount;
+    VkDeviceSize m_SumFreeSize;
+    VmaSuballocationList m_Suballocations;
+    // Suballocations that are free and have size greater than certain threshold.
+    // Sorted by size, ascending.
+    VmaVector< VmaSuballocationList::iterator, VmaStlAllocator< VmaSuballocationList::iterator > > m_FreeSuballocationsBySize;
+
+    bool ValidateFreeSuballocationList() const;
+
+    // Checks if requested suballocation with given parameters can be placed in given pFreeSuballocItem.
+    // If yes, fills pOffset and returns true. If no, returns false.
+    bool CheckAllocation(
+        uint32_t currentFrameIndex,
+        uint32_t frameInUseCount,
+        VkDeviceSize bufferImageGranularity,
+        VkDeviceSize allocSize,
+        VkDeviceSize allocAlignment,
+        VmaSuballocationType allocType,
+        VmaSuballocationList::const_iterator suballocItem,
+        bool canMakeOtherLost,
+        VkDeviceSize* pOffset,
+        size_t* itemsToMakeLostCount,
+        VkDeviceSize* pSumFreeSize,
+        VkDeviceSize* pSumItemSize) const;
+    // Given free suballocation, it merges it with following one, which must also be free.
+    void MergeFreeWithNext(VmaSuballocationList::iterator item);
+    // Releases given suballocation, making it free.
+    // Merges it with adjacent free suballocations if applicable.
+    // Returns iterator to new free suballocation at this place.
+    VmaSuballocationList::iterator FreeSuballocation(VmaSuballocationList::iterator suballocItem);
+    // Given free suballocation, it inserts it into sorted list of
+    // m_FreeSuballocationsBySize if it's suitable.
+    void RegisterFreeSuballocation(VmaSuballocationList::iterator item);
+    // Given free suballocation, it removes it from sorted list of
+    // m_FreeSuballocationsBySize if it's suitable.
+    void UnregisterFreeSuballocation(VmaSuballocationList::iterator item);
+};
+
+/*
+Allocations and their references in internal data structure look like this:
+
+if(m_2ndVectorMode == SECOND_VECTOR_EMPTY):
+
+        0 +-------+
+          |       |
+          |       |
+          |       |
+          +-------+
+          | Alloc |  1st[m_1stNullItemsBeginCount]
+          +-------+
+          | Alloc |  1st[m_1stNullItemsBeginCount + 1]
+          +-------+
+          |  ...  |
+          +-------+
+          | Alloc |  1st[1st.size() - 1]
+          +-------+
+          |       |
+          |       |
+          |       |
+GetSize() +-------+
+
+if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER):
+
+        0 +-------+
+          | Alloc |  2nd[0]
+          +-------+
+          | Alloc |  2nd[1]
+          +-------+
+          |  ...  |
+          +-------+
+          | Alloc |  2nd[2nd.size() - 1]
+          +-------+
+          |       |
+          |       |
+          |       |
+          +-------+
+          | Alloc |  1st[m_1stNullItemsBeginCount]
+          +-------+
+          | Alloc |  1st[m_1stNullItemsBeginCount + 1]
+          +-------+
+          |  ...  |
+          +-------+
+          | Alloc |  1st[1st.size() - 1]
+          +-------+
+          |       |
+GetSize() +-------+
+
+if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK):
+
+        0 +-------+
+          |       |
+          |       |
+          |       |
+          +-------+
+          | Alloc |  1st[m_1stNullItemsBeginCount]
+          +-------+
+          | Alloc |  1st[m_1stNullItemsBeginCount + 1]
+          +-------+
+          |  ...  |
+          +-------+
+          | Alloc |  1st[1st.size() - 1]
+          +-------+
+          |       |
+          |       |
+          |       |
+          +-------+
+          | Alloc |  2nd[2nd.size() - 1]
+          +-------+
+          |  ...  |
+          +-------+
+          | Alloc |  2nd[1]
+          +-------+
+          | Alloc |  2nd[0]
+GetSize() +-------+
+
+*/
+class VmaBlockMetadata_Linear : public VmaBlockMetadata
+{
+    VMA_CLASS_NO_COPY(VmaBlockMetadata_Linear)
+public:
+    VmaBlockMetadata_Linear(VmaAllocator hAllocator);
+    virtual ~VmaBlockMetadata_Linear();
+    virtual void Init(VkDeviceSize size);
+
+    virtual bool Validate() const;
+    virtual size_t GetAllocationCount() const;
+    virtual VkDeviceSize GetSumFreeSize() const { return m_SumFreeSize; }
+    virtual VkDeviceSize GetUnusedRangeSizeMax() const;
+    virtual bool IsEmpty() const { return GetAllocationCount() == 0; }
+
+    virtual void CalcAllocationStatInfo(VmaStatInfo& outInfo) const;
+    virtual void AddPoolStats(VmaPoolStats& inoutStats) const;
+
+#if VMA_STATS_STRING_ENABLED
+    virtual void PrintDetailedMap(class VmaJsonWriter& json) const;
+#endif
+
+    virtual bool CreateAllocationRequest(
+        uint32_t currentFrameIndex,
+        uint32_t frameInUseCount,
+        VkDeviceSize bufferImageGranularity,
+        VkDeviceSize allocSize,
+        VkDeviceSize allocAlignment,
+        bool upperAddress,
+        VmaSuballocationType allocType,
+        bool canMakeOtherLost,
+        uint32_t strategy,
+        VmaAllocationRequest* pAllocationRequest);
+
+    virtual bool MakeRequestedAllocationsLost(
+        uint32_t currentFrameIndex,
+        uint32_t frameInUseCount,
+        VmaAllocationRequest* pAllocationRequest);
+
+    virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
+
+    virtual VkResult CheckCorruption(const void* pBlockData);
+
+    virtual void Alloc(
+        const VmaAllocationRequest& request,
+        VmaSuballocationType type,
+        VkDeviceSize allocSize,
+        VmaAllocation hAllocation);
+
+    virtual void Free(const VmaAllocation allocation);
+    virtual void FreeAtOffset(VkDeviceSize offset);
+
+private:
+    /*
+    There are two suballocation vectors, used in ping-pong way.
+    The one with index m_1stVectorIndex is called 1st.
+    The one with index (m_1stVectorIndex ^ 1) is called 2nd.
+    2nd can be non-empty only when 1st is not empty.
+    When 2nd is not empty, m_2ndVectorMode indicates its mode of operation.
+    */
+    typedef VmaVector< VmaSuballocation, VmaStlAllocator<VmaSuballocation> > SuballocationVectorType;
+
+    enum SECOND_VECTOR_MODE
+    {
+        SECOND_VECTOR_EMPTY,
+        /*
+        Suballocations in 2nd vector are created later than the ones in 1st, but they
+        all have smaller offset.
+        */
+        SECOND_VECTOR_RING_BUFFER,
+        /*
+        Suballocations in 2nd vector are upper side of double stack.
+        They all have offsets higher than those in 1st vector.
+        Top of this stack means smaller offsets, but higher indices in this vector.
+        */
+        SECOND_VECTOR_DOUBLE_STACK,
+    };
+
+    VkDeviceSize m_SumFreeSize;
+    SuballocationVectorType m_Suballocations0, m_Suballocations1;
+    uint32_t m_1stVectorIndex;
+    SECOND_VECTOR_MODE m_2ndVectorMode;
+
+    SuballocationVectorType& AccessSuballocations1st() { return m_1stVectorIndex ? m_Suballocations1 : m_Suballocations0; }
+    SuballocationVectorType& AccessSuballocations2nd() { return m_1stVectorIndex ? m_Suballocations0 : m_Suballocations1; }
+    const SuballocationVectorType& AccessSuballocations1st() const { return m_1stVectorIndex ? m_Suballocations1 : m_Suballocations0; }
+    const SuballocationVectorType& AccessSuballocations2nd() const { return m_1stVectorIndex ? m_Suballocations0 : m_Suballocations1; }
+
+    // Number of items in 1st vector with hAllocation = null at the beginning.
+    size_t m_1stNullItemsBeginCount;
+    // Number of other items in 1st vector with hAllocation = null somewhere in the middle.
+    size_t m_1stNullItemsMiddleCount;
+    // Number of items in 2nd vector with hAllocation = null.
+    size_t m_2ndNullItemsCount;
+
+    bool ShouldCompact1st() const;
+    void CleanupAfterFree();
+
+    bool CreateAllocationRequest_LowerAddress(
+        uint32_t currentFrameIndex,
+        uint32_t frameInUseCount,
+        VkDeviceSize bufferImageGranularity,
+        VkDeviceSize allocSize,
+        VkDeviceSize allocAlignment,
+        VmaSuballocationType allocType,
+        bool canMakeOtherLost,
+        uint32_t strategy,
+        VmaAllocationRequest* pAllocationRequest);
+    bool CreateAllocationRequest_UpperAddress(
+        uint32_t currentFrameIndex,
+        uint32_t frameInUseCount,
+        VkDeviceSize bufferImageGranularity,
+        VkDeviceSize allocSize,
+        VkDeviceSize allocAlignment,
+        VmaSuballocationType allocType,
+        bool canMakeOtherLost,
+        uint32_t strategy,
+        VmaAllocationRequest* pAllocationRequest);
+};
+
+/*
+- GetSize() is the original size of allocated memory block.
+- m_UsableSize is this size aligned down to a power of two.
+  All allocations and calculations happen relative to m_UsableSize.
+- GetUnusableSize() is the difference between them.
+  It is repoted as separate, unused range, not available for allocations.
+
+Node at level 0 has size = m_UsableSize.
+Each next level contains nodes with size 2 times smaller than current level.
+m_LevelCount is the maximum number of levels to use in the current object.
+*/
+class VmaBlockMetadata_Buddy : public VmaBlockMetadata
+{
+    VMA_CLASS_NO_COPY(VmaBlockMetadata_Buddy)
+public:
+    VmaBlockMetadata_Buddy(VmaAllocator hAllocator);
+    virtual ~VmaBlockMetadata_Buddy();
+    virtual void Init(VkDeviceSize size);
+
+    virtual bool Validate() const;
+    virtual size_t GetAllocationCount() const { return m_AllocationCount; }
+    virtual VkDeviceSize GetSumFreeSize() const { return m_SumFreeSize + GetUnusableSize(); }
+    virtual VkDeviceSize GetUnusedRangeSizeMax() const;
+    virtual bool IsEmpty() const { return m_Root->type == Node::TYPE_FREE; }
+
+    virtual void CalcAllocationStatInfo(VmaStatInfo& outInfo) const;
+    virtual void AddPoolStats(VmaPoolStats& inoutStats) const;
+
+#if VMA_STATS_STRING_ENABLED
+    virtual void PrintDetailedMap(class VmaJsonWriter& json) const;
+#endif
+
+    virtual bool CreateAllocationRequest(
+        uint32_t currentFrameIndex,
+        uint32_t frameInUseCount,
+        VkDeviceSize bufferImageGranularity,
+        VkDeviceSize allocSize,
+        VkDeviceSize allocAlignment,
+        bool upperAddress,
+        VmaSuballocationType allocType,
+        bool canMakeOtherLost,
+        uint32_t strategy,
+        VmaAllocationRequest* pAllocationRequest);
+
+    virtual bool MakeRequestedAllocationsLost(
+        uint32_t currentFrameIndex,
+        uint32_t frameInUseCount,
+        VmaAllocationRequest* pAllocationRequest);
+
+    virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
+
+    virtual VkResult CheckCorruption(const void* pBlockData) { return VK_ERROR_FEATURE_NOT_PRESENT; }
+
+    virtual void Alloc(
+        const VmaAllocationRequest& request,
+        VmaSuballocationType type,
+        VkDeviceSize allocSize,
+        VmaAllocation hAllocation);
+
+    virtual void Free(const VmaAllocation allocation) { FreeAtOffset(allocation, allocation->GetOffset()); }
+    virtual void FreeAtOffset(VkDeviceSize offset) { FreeAtOffset(VMA_NULL, offset); }
+
+private:
+    static const VkDeviceSize MIN_NODE_SIZE = 32;
+    static const size_t MAX_LEVELS = 30;
+
+    struct ValidationContext
+    {
+        size_t calculatedAllocationCount;
+        size_t calculatedFreeCount;
+        VkDeviceSize calculatedSumFreeSize;
+
+        ValidationContext() :
+            calculatedAllocationCount(0),
+            calculatedFreeCount(0),
+            calculatedSumFreeSize(0) { }
+    };
+
+    struct Node
+    {
+        VkDeviceSize offset;
+        enum TYPE
+        {
+            TYPE_FREE,
+            TYPE_ALLOCATION,
+            TYPE_SPLIT,
+            TYPE_COUNT
+        } type;
+        Node* parent;
+        Node* buddy;
+
+        union
+        {
+            struct
+            {
+                Node* prev;
+                Node* next;
+            } free;
+            struct
+            {
+                VmaAllocation alloc;
+            } allocation;
+            struct
+            {
+                Node* leftChild;
+            } split;
+        };
+    };
+
+    // Size of the memory block aligned down to a power of two.
+    VkDeviceSize m_UsableSize;
+    uint32_t m_LevelCount;
+
+    Node* m_Root;
+    struct {
+        Node* front;
+        Node* back;
+    } m_FreeList[MAX_LEVELS];
+    // Number of nodes in the tree with type == TYPE_ALLOCATION.
+    size_t m_AllocationCount;
+    // Number of nodes in the tree with type == TYPE_FREE.
+    size_t m_FreeCount;
+    // This includes space wasted due to internal fragmentation. Doesn't include unusable size.
+    VkDeviceSize m_SumFreeSize;
+
+    VkDeviceSize GetUnusableSize() const { return GetSize() - m_UsableSize; }
+    void DeleteNode(Node* node);
+    bool ValidateNode(ValidationContext& ctx, const Node* parent, const Node* curr, uint32_t level, VkDeviceSize levelNodeSize) const;
+    uint32_t AllocSizeToLevel(VkDeviceSize allocSize) const;
+    inline VkDeviceSize LevelToNodeSize(uint32_t level) const { return m_UsableSize >> level; }
+    // Alloc passed just for validation. Can be null.
+    void FreeAtOffset(VmaAllocation alloc, VkDeviceSize offset);
+    void CalcAllocationStatInfoNode(VmaStatInfo& outInfo, const Node* node, VkDeviceSize levelNodeSize) const;
+    // Adds node to the front of FreeList at given level.
+    // node->type must be FREE.
+    // node->free.prev, next can be undefined.
+    void AddToFreeListFront(uint32_t level, Node* node);
+    // Removes node from FreeList at given level.
+    // node->type must be FREE.
+    // node->free.prev, next stay untouched.
+    void RemoveFromFreeList(uint32_t level, Node* node);
+
+#if VMA_STATS_STRING_ENABLED
+    void PrintDetailedMapNode(class VmaJsonWriter& json, const Node* node, VkDeviceSize levelNodeSize) const;
+#endif
+};
+
+/*
+Represents a single block of device memory (`VkDeviceMemory`) with all the
+data about its regions (aka suballocations, #VmaAllocation), assigned and free.
+
+Thread-safety: This class must be externally synchronized.
+*/
+class VmaDeviceMemoryBlock
+{
+    VMA_CLASS_NO_COPY(VmaDeviceMemoryBlock)
+public:
+    VmaBlockMetadata* m_pMetadata;
+
+    VmaDeviceMemoryBlock(VmaAllocator hAllocator);
+
+    ~VmaDeviceMemoryBlock()
+    {
+        VMA_ASSERT(m_MapCount == 0 && "VkDeviceMemory block is being destroyed while it is still mapped.");
+        VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);
+    }
+
+    // Always call after construction.
+    void Init(
+        VmaAllocator hAllocator,
+        VmaPool hParentPool,
+        uint32_t newMemoryTypeIndex,
+        VkDeviceMemory newMemory,
+        VkDeviceSize newSize,
+        uint32_t id,
+        uint32_t algorithm);
+    // Always call before destruction.
+    void Destroy(VmaAllocator allocator);
+
+    VmaPool GetParentPool() const { return m_hParentPool; }
+    VkDeviceMemory GetDeviceMemory() const { return m_hMemory; }
+    uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
+    uint32_t GetId() const { return m_Id; }
+    void* GetMappedData() const { return m_pMappedData; }
+
+    // Validates all data structures inside this object. If not valid, returns false.
+    bool Validate() const;
+
+    VkResult CheckCorruption(VmaAllocator hAllocator);
+
+    // ppData can be null.
+    VkResult Map(VmaAllocator hAllocator, uint32_t count, void** ppData);
+    void Unmap(VmaAllocator hAllocator, uint32_t count);
+
+    VkResult WriteMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize);
+    VkResult ValidateMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize);
+
+    VkResult BindBufferMemory(
+        const VmaAllocator hAllocator,
+        const VmaAllocation hAllocation,
+        VkDeviceSize allocationLocalOffset,
+        VkBuffer hBuffer,
+        const void* pNext);
+    VkResult BindImageMemory(
+        const VmaAllocator hAllocator,
+        const VmaAllocation hAllocation,
+        VkDeviceSize allocationLocalOffset,
+        VkImage hImage,
+        const void* pNext);
+
+private:
+    VmaPool m_hParentPool; // VK_NULL_HANDLE if not belongs to custom pool.
+    uint32_t m_MemoryTypeIndex;
+    uint32_t m_Id;
+    VkDeviceMemory m_hMemory;
+
+    /*
+    Protects access to m_hMemory so it's not used by multiple threads simultaneously, e.g. vkMapMemory, vkBindBufferMemory.
+    Also protects m_MapCount, m_pMappedData.
+    Allocations, deallocations, any change in m_pMetadata is protected by parent's VmaBlockVector::m_Mutex.
+    */
+    VMA_MUTEX m_Mutex;
+    uint32_t m_MapCount;
+    void* m_pMappedData;
+};
+
+struct VmaPointerLess
+{
+    bool operator()(const void* lhs, const void* rhs) const
+    {
+        return lhs < rhs;
+    }
+};
+
+struct VmaDefragmentationMove
+{
+    size_t srcBlockIndex;
+    size_t dstBlockIndex;
+    VkDeviceSize srcOffset;
+    VkDeviceSize dstOffset;
+    VkDeviceSize size;
+    VmaAllocation hAllocation;
+    VmaDeviceMemoryBlock* pSrcBlock;
+    VmaDeviceMemoryBlock* pDstBlock;
+};
+
+class VmaDefragmentationAlgorithm;
+
+/*
+Sequence of VmaDeviceMemoryBlock. Represents memory blocks allocated for a specific
+Vulkan memory type.
+
+Synchronized internally with a mutex.
+*/
+struct VmaBlockVector
+{
+    VMA_CLASS_NO_COPY(VmaBlockVector)
+public:
+    VmaBlockVector(
+        VmaAllocator hAllocator,
+        VmaPool hParentPool,
+        uint32_t memoryTypeIndex,
+        VkDeviceSize preferredBlockSize,
+        size_t minBlockCount,
+        size_t maxBlockCount,
+        VkDeviceSize bufferImageGranularity,
+        uint32_t frameInUseCount,
+        bool explicitBlockSize,
+        uint32_t algorithm,
+        float priority);
+    ~VmaBlockVector();
+
+    VkResult CreateMinBlocks();
+
+    VmaAllocator GetAllocator() const { return m_hAllocator; }
+    VmaPool GetParentPool() const { return m_hParentPool; }
+    bool IsCustomPool() const { return m_hParentPool != VMA_NULL; }
+    uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
+    VkDeviceSize GetPreferredBlockSize() const { return m_PreferredBlockSize; }
+    VkDeviceSize GetBufferImageGranularity() const { return m_BufferImageGranularity; }
+    uint32_t GetFrameInUseCount() const { return m_FrameInUseCount; }
+    uint32_t GetAlgorithm() const { return m_Algorithm; }
+
+    void GetPoolStats(VmaPoolStats* pStats);
+
+    bool IsEmpty();
+    bool IsCorruptionDetectionEnabled() const;
+
+    VkResult Allocate(
+        uint32_t currentFrameIndex,
+        VkDeviceSize size,
+        VkDeviceSize alignment,
+        const VmaAllocationCreateInfo& createInfo,
+        VmaSuballocationType suballocType,
+        size_t allocationCount,
+        VmaAllocation* pAllocations);
+
+    void Free(const VmaAllocation hAllocation);
+
+    // Adds statistics of this BlockVector to pStats.
+    void AddStats(VmaStats* pStats);
+
+#if VMA_STATS_STRING_ENABLED
+    void PrintDetailedMap(class VmaJsonWriter& json);
+#endif
+
+    void MakePoolAllocationsLost(
+        uint32_t currentFrameIndex,
+        size_t* pLostAllocationCount);
+    VkResult CheckCorruption();
+
+    // Saves results in pCtx->res.
+    void Defragment(
+        class VmaBlockVectorDefragmentationContext* pCtx,
+        VmaDefragmentationStats* pStats, VmaDefragmentationFlags flags,
+        VkDeviceSize& maxCpuBytesToMove, uint32_t& maxCpuAllocationsToMove,
+        VkDeviceSize& maxGpuBytesToMove, uint32_t& maxGpuAllocationsToMove,
+        VkCommandBuffer commandBuffer);
+    void DefragmentationEnd(
+        class VmaBlockVectorDefragmentationContext* pCtx,
+        uint32_t flags,
+        VmaDefragmentationStats* pStats);
+
+    uint32_t ProcessDefragmentations(
+        class VmaBlockVectorDefragmentationContext *pCtx,
+        VmaDefragmentationPassMoveInfo* pMove, uint32_t maxMoves);
+
+    void CommitDefragmentations(
+        class VmaBlockVectorDefragmentationContext *pCtx,
+        VmaDefragmentationStats* pStats);
+
+    ////////////////////////////////////////////////////////////////////////////////
+    // To be used only while the m_Mutex is locked. Used during defragmentation.
+
+    size_t GetBlockCount() const { return m_Blocks.size(); }
+    VmaDeviceMemoryBlock* GetBlock(size_t index) const { return m_Blocks[index]; }
+    size_t CalcAllocationCount() const;
+    bool IsBufferImageGranularityConflictPossible() const;
+
+private:
+    friend class VmaDefragmentationAlgorithm_Generic;
+
+    const VmaAllocator m_hAllocator;
+    const VmaPool m_hParentPool;
+    const uint32_t m_MemoryTypeIndex;
+    const VkDeviceSize m_PreferredBlockSize;
+    const size_t m_MinBlockCount;
+    const size_t m_MaxBlockCount;
+    const VkDeviceSize m_BufferImageGranularity;
+    const uint32_t m_FrameInUseCount;
+    const bool m_ExplicitBlockSize;
+    const uint32_t m_Algorithm;
+    const float m_Priority;
+    VMA_RW_MUTEX m_Mutex;
+
+    /* There can be at most one allocation that is completely empty (except when minBlockCount > 0) -
+    a hysteresis to avoid pessimistic case of alternating creation and destruction of a VkDeviceMemory. */
+    bool m_HasEmptyBlock;
+    // Incrementally sorted by sumFreeSize, ascending.
+    VmaVector< VmaDeviceMemoryBlock*, VmaStlAllocator<VmaDeviceMemoryBlock*> > m_Blocks;
+    uint32_t m_NextBlockId;
+
+    VkDeviceSize CalcMaxBlockSize() const;
+
+    // Finds and removes given block from vector.
+    void Remove(VmaDeviceMemoryBlock* pBlock);
+
+    // Performs single step in sorting m_Blocks. They may not be fully sorted
+    // after this call.
+    void IncrementallySortBlocks();
+
+    VkResult AllocatePage(
+        uint32_t currentFrameIndex,
+        VkDeviceSize size,
+        VkDeviceSize alignment,
+        const VmaAllocationCreateInfo& createInfo,
+        VmaSuballocationType suballocType,
+        VmaAllocation* pAllocation);
+
+    // To be used only without CAN_MAKE_OTHER_LOST flag.
+    VkResult AllocateFromBlock(
+        VmaDeviceMemoryBlock* pBlock,
+        uint32_t currentFrameIndex,
+        VkDeviceSize size,
+        VkDeviceSize alignment,
+        VmaAllocationCreateFlags allocFlags,
+        void* pUserData,
+        VmaSuballocationType suballocType,
+        uint32_t strategy,
+        VmaAllocation* pAllocation);
+
+    VkResult CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex);
+
+    // Saves result to pCtx->res.
+    void ApplyDefragmentationMovesCpu(
+        class VmaBlockVectorDefragmentationContext* pDefragCtx,
+        const VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves);
+    // Saves result to pCtx->res.
+    void ApplyDefragmentationMovesGpu(
+        class VmaBlockVectorDefragmentationContext* pDefragCtx,
+        VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
+        VkCommandBuffer commandBuffer);
+
+    /*
+    Used during defragmentation. pDefragmentationStats is optional. It's in/out
+    - updated with new data.
+    */
+    void FreeEmptyBlocks(VmaDefragmentationStats* pDefragmentationStats);
+
+    void UpdateHasEmptyBlock();
+};
+
+struct VmaPool_T
+{
+    VMA_CLASS_NO_COPY(VmaPool_T)
+public:
+    VmaBlockVector m_BlockVector;
+
+    VmaPool_T(
+        VmaAllocator hAllocator,
+        const VmaPoolCreateInfo& createInfo,
+        VkDeviceSize preferredBlockSize);
+    ~VmaPool_T();
+
+    uint32_t GetId() const { return m_Id; }
+    void SetId(uint32_t id) { VMA_ASSERT(m_Id == 0); m_Id = id; }
+
+    const char* GetName() const { return m_Name; }
+    void SetName(const char* pName);
+
+#if VMA_STATS_STRING_ENABLED
+    //void PrintDetailedMap(class VmaStringBuilder& sb);
+#endif
+
+private:
+    uint32_t m_Id;
+    char* m_Name;
+};
+
+/*
+Performs defragmentation:
+
+- Updates `pBlockVector->m_pMetadata`.
+- Updates allocations by calling ChangeBlockAllocation() or ChangeOffset().
+- Does not move actual data, only returns requested moves as `moves`.
+*/
+class VmaDefragmentationAlgorithm
+{
+    VMA_CLASS_NO_COPY(VmaDefragmentationAlgorithm)
+public:
+    VmaDefragmentationAlgorithm(
+        VmaAllocator hAllocator,
+        VmaBlockVector* pBlockVector,
+        uint32_t currentFrameIndex) :
+        m_hAllocator(hAllocator),
+        m_pBlockVector(pBlockVector),
+        m_CurrentFrameIndex(currentFrameIndex)
+    {
+    }
+    virtual ~VmaDefragmentationAlgorithm()
+    {
+    }
+
+    virtual void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged) = 0;
+    virtual void AddAll() = 0;
+
+    virtual VkResult Defragment(
+        VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
+        VkDeviceSize maxBytesToMove,
+        uint32_t maxAllocationsToMove,
+        VmaDefragmentationFlags flags) = 0;
+
+    virtual VkDeviceSize GetBytesMoved() const = 0;
+    virtual uint32_t GetAllocationsMoved() const = 0;
+
+protected:
+    VmaAllocator const m_hAllocator;
+    VmaBlockVector* const m_pBlockVector;
+    const uint32_t m_CurrentFrameIndex;
+
+    struct AllocationInfo
+    {
+        VmaAllocation m_hAllocation;
+        VkBool32* m_pChanged;
+
+        AllocationInfo() :
+            m_hAllocation(VK_NULL_HANDLE),
+            m_pChanged(VMA_NULL)
+        {
+        }
+        AllocationInfo(VmaAllocation hAlloc, VkBool32* pChanged) :
+            m_hAllocation(hAlloc),
+            m_pChanged(pChanged)
+        {
+        }
+    };
+};
+
+class VmaDefragmentationAlgorithm_Generic : public VmaDefragmentationAlgorithm
+{
+    VMA_CLASS_NO_COPY(VmaDefragmentationAlgorithm_Generic)
+public:
+    VmaDefragmentationAlgorithm_Generic(
+        VmaAllocator hAllocator,
+        VmaBlockVector* pBlockVector,
+        uint32_t currentFrameIndex,
+        bool overlappingMoveSupported);
+    virtual ~VmaDefragmentationAlgorithm_Generic();
+
+    virtual void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged);
+    virtual void AddAll() { m_AllAllocations = true; }
+
+    virtual VkResult Defragment(
+        VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
+        VkDeviceSize maxBytesToMove,
+        uint32_t maxAllocationsToMove,
+        VmaDefragmentationFlags flags);
+
+    virtual VkDeviceSize GetBytesMoved() const { return m_BytesMoved; }
+    virtual uint32_t GetAllocationsMoved() const { return m_AllocationsMoved; }
+
+private:
+    uint32_t m_AllocationCount;
+    bool m_AllAllocations;
+
+    VkDeviceSize m_BytesMoved;
+    uint32_t m_AllocationsMoved;
+
+    struct AllocationInfoSizeGreater
+    {
+        bool operator()(const AllocationInfo& lhs, const AllocationInfo& rhs) const
+        {
+            return lhs.m_hAllocation->GetSize() > rhs.m_hAllocation->GetSize();
+        }
+    };
+
+    struct AllocationInfoOffsetGreater
+    {
+        bool operator()(const AllocationInfo& lhs, const AllocationInfo& rhs) const
+        {
+            return lhs.m_hAllocation->GetOffset() > rhs.m_hAllocation->GetOffset();
+        }
+    };
+
+    struct BlockInfo
+    {
+        size_t m_OriginalBlockIndex;
+        VmaDeviceMemoryBlock* m_pBlock;
+        bool m_HasNonMovableAllocations;
+        VmaVector< AllocationInfo, VmaStlAllocator<AllocationInfo> > m_Allocations;
+
+        BlockInfo(const VkAllocationCallbacks* pAllocationCallbacks) :
+            m_OriginalBlockIndex(SIZE_MAX),
+            m_pBlock(VMA_NULL),
+            m_HasNonMovableAllocations(true),
+            m_Allocations(pAllocationCallbacks)
+        {
+        }
+
+        void CalcHasNonMovableAllocations()
+        {
+            const size_t blockAllocCount = m_pBlock->m_pMetadata->GetAllocationCount();
+            const size_t defragmentAllocCount = m_Allocations.size();
+            m_HasNonMovableAllocations = blockAllocCount != defragmentAllocCount;
+        }
+
+        void SortAllocationsBySizeDescending()
+        {
+            VMA_SORT(m_Allocations.begin(), m_Allocations.end(), AllocationInfoSizeGreater());
+        }
+
+        void SortAllocationsByOffsetDescending()
+        {
+            VMA_SORT(m_Allocations.begin(), m_Allocations.end(), AllocationInfoOffsetGreater());
+        }
+    };
+
+    struct BlockPointerLess
+    {
+        bool operator()(const BlockInfo* pLhsBlockInfo, const VmaDeviceMemoryBlock* pRhsBlock) const
+        {
+            return pLhsBlockInfo->m_pBlock < pRhsBlock;
+        }
+        bool operator()(const BlockInfo* pLhsBlockInfo, const BlockInfo* pRhsBlockInfo) const
+        {
+            return pLhsBlockInfo->m_pBlock < pRhsBlockInfo->m_pBlock;
+        }
+    };
+
+    // 1. Blocks with some non-movable allocations go first.
+    // 2. Blocks with smaller sumFreeSize go first.
+    struct BlockInfoCompareMoveDestination
+    {
+        bool operator()(const BlockInfo* pLhsBlockInfo, const BlockInfo* pRhsBlockInfo) const
+        {
+            if(pLhsBlockInfo->m_HasNonMovableAllocations && !pRhsBlockInfo->m_HasNonMovableAllocations)
+            {
+                return true;
+            }
+            if(!pLhsBlockInfo->m_HasNonMovableAllocations && pRhsBlockInfo->m_HasNonMovableAllocations)
+            {
+                return false;
+            }
+            if(pLhsBlockInfo->m_pBlock->m_pMetadata->GetSumFreeSize() < pRhsBlockInfo->m_pBlock->m_pMetadata->GetSumFreeSize())
+            {
+                return true;
+            }
+            return false;
+        }
+    };
+
+    typedef VmaVector< BlockInfo*, VmaStlAllocator<BlockInfo*> > BlockInfoVector;
+    BlockInfoVector m_Blocks;
+
+    VkResult DefragmentRound(
+        VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
+        VkDeviceSize maxBytesToMove,
+        uint32_t maxAllocationsToMove,
+        bool freeOldAllocations);
+
+    size_t CalcBlocksWithNonMovableCount() const;
+
+    static bool MoveMakesSense(
+        size_t dstBlockIndex, VkDeviceSize dstOffset,
+        size_t srcBlockIndex, VkDeviceSize srcOffset);
+};
+
+class VmaDefragmentationAlgorithm_Fast : public VmaDefragmentationAlgorithm
+{
+    VMA_CLASS_NO_COPY(VmaDefragmentationAlgorithm_Fast)
+public:
+    VmaDefragmentationAlgorithm_Fast(
+        VmaAllocator hAllocator,
+        VmaBlockVector* pBlockVector,
+        uint32_t currentFrameIndex,
+        bool overlappingMoveSupported);
+    virtual ~VmaDefragmentationAlgorithm_Fast();
+
+    virtual void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged) { ++m_AllocationCount; }
+    virtual void AddAll() { m_AllAllocations = true; }
+
+    virtual VkResult Defragment(
+        VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
+        VkDeviceSize maxBytesToMove,
+        uint32_t maxAllocationsToMove,
+        VmaDefragmentationFlags flags);
+
+    virtual VkDeviceSize GetBytesMoved() const { return m_BytesMoved; }
+    virtual uint32_t GetAllocationsMoved() const { return m_AllocationsMoved; }
+
+private:
+    struct BlockInfo
+    {
+        size_t origBlockIndex;
+    };
+
+    class FreeSpaceDatabase
+    {
+    public:
+        FreeSpaceDatabase()
+        {
+            FreeSpace s = {};
+            s.blockInfoIndex = SIZE_MAX;
+            for(size_t i = 0; i < MAX_COUNT; ++i)
+            {
+                m_FreeSpaces[i] = s;
+            }
+        }
+
+        void Register(size_t blockInfoIndex, VkDeviceSize offset, VkDeviceSize size)
+        {
+            if(size < VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
+            {
+                return;
+            }
+
+            // Find first invalid or the smallest structure.
+            size_t bestIndex = SIZE_MAX;
+            for(size_t i = 0; i < MAX_COUNT; ++i)
+            {
+                // Empty structure.
+                if(m_FreeSpaces[i].blockInfoIndex == SIZE_MAX)
+                {
+                    bestIndex = i;
+                    break;
+                }
+                if(m_FreeSpaces[i].size < size &&
+                    (bestIndex == SIZE_MAX || m_FreeSpaces[bestIndex].size > m_FreeSpaces[i].size))
+                {
+                    bestIndex = i;
+                }
+            }
+
+            if(bestIndex != SIZE_MAX)
+            {
+                m_FreeSpaces[bestIndex].blockInfoIndex = blockInfoIndex;
+                m_FreeSpaces[bestIndex].offset = offset;
+                m_FreeSpaces[bestIndex].size = size;
+            }
+        }
+
+        bool Fetch(VkDeviceSize alignment, VkDeviceSize size,
+            size_t& outBlockInfoIndex, VkDeviceSize& outDstOffset)
+        {
+            size_t bestIndex = SIZE_MAX;
+            VkDeviceSize bestFreeSpaceAfter = 0;
+            for(size_t i = 0; i < MAX_COUNT; ++i)
+            {
+                // Structure is valid.
+                if(m_FreeSpaces[i].blockInfoIndex != SIZE_MAX)
+                {
+                    const VkDeviceSize dstOffset = VmaAlignUp(m_FreeSpaces[i].offset, alignment);
+                    // Allocation fits into this structure.
+                    if(dstOffset + size <= m_FreeSpaces[i].offset + m_FreeSpaces[i].size)
+                    {
+                        const VkDeviceSize freeSpaceAfter = (m_FreeSpaces[i].offset + m_FreeSpaces[i].size) -
+                            (dstOffset + size);
+                        if(bestIndex == SIZE_MAX || freeSpaceAfter > bestFreeSpaceAfter)
+                        {
+                            bestIndex = i;
+                            bestFreeSpaceAfter = freeSpaceAfter;
+                        }
+                    }
+                }
+            }
+
+            if(bestIndex != SIZE_MAX)
+            {
+                outBlockInfoIndex = m_FreeSpaces[bestIndex].blockInfoIndex;
+                outDstOffset = VmaAlignUp(m_FreeSpaces[bestIndex].offset, alignment);
+
+                if(bestFreeSpaceAfter >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
+                {
+                    // Leave this structure for remaining empty space.
+                    const VkDeviceSize alignmentPlusSize = (outDstOffset - m_FreeSpaces[bestIndex].offset) + size;
+                    m_FreeSpaces[bestIndex].offset += alignmentPlusSize;
+                    m_FreeSpaces[bestIndex].size -= alignmentPlusSize;
+                }
+                else
+                {
+                    // This structure becomes invalid.
+                    m_FreeSpaces[bestIndex].blockInfoIndex = SIZE_MAX;
+                }
+
+                return true;
+            }
+
+            return false;
+        }
+
+    private:
+        static const size_t MAX_COUNT = 4;
+
+        struct FreeSpace
+        {
+            size_t blockInfoIndex; // SIZE_MAX means this structure is invalid.
+            VkDeviceSize offset;
+            VkDeviceSize size;
+        } m_FreeSpaces[MAX_COUNT];
+    };
+
+    const bool m_OverlappingMoveSupported;
+
+    uint32_t m_AllocationCount;
+    bool m_AllAllocations;
+
+    VkDeviceSize m_BytesMoved;
+    uint32_t m_AllocationsMoved;
+
+    VmaVector< BlockInfo, VmaStlAllocator<BlockInfo> > m_BlockInfos;
+
+    void PreprocessMetadata();
+    void PostprocessMetadata();
+    void InsertSuballoc(VmaBlockMetadata_Generic* pMetadata, const VmaSuballocation& suballoc);
+};
+
+struct VmaBlockDefragmentationContext
+{
+    enum BLOCK_FLAG
+    {
+        BLOCK_FLAG_USED = 0x00000001,
+    };
+    uint32_t flags;
+    VkBuffer hBuffer;
+};
+
+class VmaBlockVectorDefragmentationContext
+{
+    VMA_CLASS_NO_COPY(VmaBlockVectorDefragmentationContext)
+public:
+    VkResult res;
+    bool mutexLocked;
+    VmaVector< VmaBlockDefragmentationContext, VmaStlAllocator<VmaBlockDefragmentationContext> > blockContexts;
+    VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> > defragmentationMoves;
+    uint32_t defragmentationMovesProcessed;
+    uint32_t defragmentationMovesCommitted;
+    bool hasDefragmentationPlan;
+
+    VmaBlockVectorDefragmentationContext(
+        VmaAllocator hAllocator,
+        VmaPool hCustomPool, // Optional.
+        VmaBlockVector* pBlockVector,
+        uint32_t currFrameIndex);
+    ~VmaBlockVectorDefragmentationContext();
+
+    VmaPool GetCustomPool() const { return m_hCustomPool; }
+    VmaBlockVector* GetBlockVector() const { return m_pBlockVector; }
+    VmaDefragmentationAlgorithm* GetAlgorithm() const { return m_pAlgorithm; }
+
+    void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged);
+    void AddAll() { m_AllAllocations = true; }
+
+    void Begin(bool overlappingMoveSupported, VmaDefragmentationFlags flags);
+
+private:
+    const VmaAllocator m_hAllocator;
+    // Null if not from custom pool.
+    const VmaPool m_hCustomPool;
+    // Redundant, for convenience not to fetch from m_hCustomPool->m_BlockVector or m_hAllocator->m_pBlockVectors.
+    VmaBlockVector* const m_pBlockVector;
+    const uint32_t m_CurrFrameIndex;
+    // Owner of this object.
+    VmaDefragmentationAlgorithm* m_pAlgorithm;
+
+    struct AllocInfo
+    {
+        VmaAllocation hAlloc;
+        VkBool32* pChanged;
+    };
+    // Used between constructor and Begin.
+    VmaVector< AllocInfo, VmaStlAllocator<AllocInfo> > m_Allocations;
+    bool m_AllAllocations;
+};
+
+struct VmaDefragmentationContext_T
+{
+private:
+    VMA_CLASS_NO_COPY(VmaDefragmentationContext_T)
+public:
+    VmaDefragmentationContext_T(
+        VmaAllocator hAllocator,
+        uint32_t currFrameIndex,
+        uint32_t flags,
+        VmaDefragmentationStats* pStats);
+    ~VmaDefragmentationContext_T();
+
+    void AddPools(uint32_t poolCount, const VmaPool* pPools);
+    void AddAllocations(
+        uint32_t allocationCount,
+        const VmaAllocation* pAllocations,
+        VkBool32* pAllocationsChanged);
+
+    /*
+    Returns:
+    - `VK_SUCCESS` if succeeded and object can be destroyed immediately.
+    - `VK_NOT_READY` if succeeded but the object must remain alive until vmaDefragmentationEnd().
+    - Negative value if error occured and object can be destroyed immediately.
+    */
+    VkResult Defragment(
+        VkDeviceSize maxCpuBytesToMove, uint32_t maxCpuAllocationsToMove,
+        VkDeviceSize maxGpuBytesToMove, uint32_t maxGpuAllocationsToMove,
+        VkCommandBuffer commandBuffer, VmaDefragmentationStats* pStats, VmaDefragmentationFlags flags);
+
+    VkResult DefragmentPassBegin(VmaDefragmentationPassInfo* pInfo);
+    VkResult DefragmentPassEnd();
+
+private:
+    const VmaAllocator m_hAllocator;
+    const uint32_t m_CurrFrameIndex;
+    const uint32_t m_Flags;
+    VmaDefragmentationStats* const m_pStats;
+
+    VkDeviceSize m_MaxCpuBytesToMove;
+    uint32_t m_MaxCpuAllocationsToMove;
+    VkDeviceSize m_MaxGpuBytesToMove;
+    uint32_t m_MaxGpuAllocationsToMove;
+
+    // Owner of these objects.
+    VmaBlockVectorDefragmentationContext* m_DefaultPoolContexts[VK_MAX_MEMORY_TYPES];
+    // Owner of these objects.
+    VmaVector< VmaBlockVectorDefragmentationContext*, VmaStlAllocator<VmaBlockVectorDefragmentationContext*> > m_CustomPoolContexts;
+};
+
+#if VMA_RECORDING_ENABLED
+
+class VmaRecorder
+{
+public:
+    VmaRecorder();
+    VkResult Init(const VmaRecordSettings& settings, bool useMutex);
+    void WriteConfiguration(
+        const VkPhysicalDeviceProperties& devProps,
+        const VkPhysicalDeviceMemoryProperties& memProps,
+        uint32_t vulkanApiVersion,
+        bool dedicatedAllocationExtensionEnabled,
+        bool bindMemory2ExtensionEnabled,
+        bool memoryBudgetExtensionEnabled,
+        bool deviceCoherentMemoryExtensionEnabled);
+    ~VmaRecorder();
+
+    void RecordCreateAllocator(uint32_t frameIndex);
+    void RecordDestroyAllocator(uint32_t frameIndex);
+    void RecordCreatePool(uint32_t frameIndex,
+        const VmaPoolCreateInfo& createInfo,
+        VmaPool pool);
+    void RecordDestroyPool(uint32_t frameIndex, VmaPool pool);
+    void RecordAllocateMemory(uint32_t frameIndex,
+        const VkMemoryRequirements& vkMemReq,
+        const VmaAllocationCreateInfo& createInfo,
+        VmaAllocation allocation);
+    void RecordAllocateMemoryPages(uint32_t frameIndex,
+        const VkMemoryRequirements& vkMemReq,
+        const VmaAllocationCreateInfo& createInfo,
+        uint64_t allocationCount,
+        const VmaAllocation* pAllocations);
+    void RecordAllocateMemoryForBuffer(uint32_t frameIndex,
+        const VkMemoryRequirements& vkMemReq,
+        bool requiresDedicatedAllocation,
+        bool prefersDedicatedAllocation,
+        const VmaAllocationCreateInfo& createInfo,
+        VmaAllocation allocation);
+    void RecordAllocateMemoryForImage(uint32_t frameIndex,
+        const VkMemoryRequirements& vkMemReq,
+        bool requiresDedicatedAllocation,
+        bool prefersDedicatedAllocation,
+        const VmaAllocationCreateInfo& createInfo,
+        VmaAllocation allocation);
+    void RecordFreeMemory(uint32_t frameIndex,
+        VmaAllocation allocation);
+    void RecordFreeMemoryPages(uint32_t frameIndex,
+        uint64_t allocationCount,
+        const VmaAllocation* pAllocations);
+    void RecordSetAllocationUserData(uint32_t frameIndex,
+        VmaAllocation allocation,
+        const void* pUserData);
+    void RecordCreateLostAllocation(uint32_t frameIndex,
+        VmaAllocation allocation);
+    void RecordMapMemory(uint32_t frameIndex,
+        VmaAllocation allocation);
+    void RecordUnmapMemory(uint32_t frameIndex,
+        VmaAllocation allocation);
+    void RecordFlushAllocation(uint32_t frameIndex,
+        VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
+    void RecordInvalidateAllocation(uint32_t frameIndex,
+        VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
+    void RecordCreateBuffer(uint32_t frameIndex,
+        const VkBufferCreateInfo& bufCreateInfo,
+        const VmaAllocationCreateInfo& allocCreateInfo,
+        VmaAllocation allocation);
+    void RecordCreateImage(uint32_t frameIndex,
+        const VkImageCreateInfo& imageCreateInfo,
+        const VmaAllocationCreateInfo& allocCreateInfo,
+        VmaAllocation allocation);
+    void RecordDestroyBuffer(uint32_t frameIndex,
+        VmaAllocation allocation);
+    void RecordDestroyImage(uint32_t frameIndex,
+        VmaAllocation allocation);
+    void RecordTouchAllocation(uint32_t frameIndex,
+        VmaAllocation allocation);
+    void RecordGetAllocationInfo(uint32_t frameIndex,
+        VmaAllocation allocation);
+    void RecordMakePoolAllocationsLost(uint32_t frameIndex,
+        VmaPool pool);
+    void RecordDefragmentationBegin(uint32_t frameIndex,
+        const VmaDefragmentationInfo2& info,
+        VmaDefragmentationContext ctx);
+    void RecordDefragmentationEnd(uint32_t frameIndex,
+        VmaDefragmentationContext ctx);
+    void RecordSetPoolName(uint32_t frameIndex,
+        VmaPool pool,
+        const char* name);
+
+private:
+    struct CallParams
+    {
+        uint32_t threadId;
+        double time;
+    };
+
+    class UserDataString
+    {
+    public:
+        UserDataString(VmaAllocationCreateFlags allocFlags, const void* pUserData);
+        const char* GetString() const { return m_Str; }
+
+    private:
+        char m_PtrStr[17];
+        const char* m_Str;
+    };
+
+    bool m_UseMutex;
+    VmaRecordFlags m_Flags;
+    FILE* m_File;
+    VMA_MUTEX m_FileMutex;
+    std::chrono::time_point<std::chrono::high_resolution_clock> m_RecordingStartTime;
+
+    void GetBasicParams(CallParams& outParams);
+
+    // T must be a pointer type, e.g. VmaAllocation, VmaPool.
+    template<typename T>
+    void PrintPointerList(uint64_t count, const T* pItems)
+    {
+        if(count)
+        {
+            fprintf(m_File, "%p", pItems[0]);
+            for(uint64_t i = 1; i < count; ++i)
+            {
+                fprintf(m_File, " %p", pItems[i]);
+            }
+        }
+    }
+
+    void PrintPointerList(uint64_t count, const VmaAllocation* pItems);
+    void Flush();
+};
+
+#endif // #if VMA_RECORDING_ENABLED
+
+/*
+Thread-safe wrapper over VmaPoolAllocator free list, for allocation of VmaAllocation_T objects.
+*/
+class VmaAllocationObjectAllocator
+{
+    VMA_CLASS_NO_COPY(VmaAllocationObjectAllocator)
+public:
+    VmaAllocationObjectAllocator(const VkAllocationCallbacks* pAllocationCallbacks);
+
+    template<typename... Types> VmaAllocation Allocate(Types... args);
+    void Free(VmaAllocation hAlloc);
+
+private:
+    VMA_MUTEX m_Mutex;
+    VmaPoolAllocator<VmaAllocation_T> m_Allocator;
+};
+
+struct VmaCurrentBudgetData
+{
+    VMA_ATOMIC_UINT64 m_BlockBytes[VK_MAX_MEMORY_HEAPS];
+    VMA_ATOMIC_UINT64 m_AllocationBytes[VK_MAX_MEMORY_HEAPS];
+
+#if VMA_MEMORY_BUDGET
+    VMA_ATOMIC_UINT32 m_OperationsSinceBudgetFetch;
+    VMA_RW_MUTEX m_BudgetMutex;
+    uint64_t m_VulkanUsage[VK_MAX_MEMORY_HEAPS];
+    uint64_t m_VulkanBudget[VK_MAX_MEMORY_HEAPS];
+    uint64_t m_BlockBytesAtBudgetFetch[VK_MAX_MEMORY_HEAPS];
+#endif // #if VMA_MEMORY_BUDGET
+
+    VmaCurrentBudgetData()
+    {
+        for(uint32_t heapIndex = 0; heapIndex < VK_MAX_MEMORY_HEAPS; ++heapIndex)
+        {
+            m_BlockBytes[heapIndex] = 0;
+            m_AllocationBytes[heapIndex] = 0;
+#if VMA_MEMORY_BUDGET
+            m_VulkanUsage[heapIndex] = 0;
+            m_VulkanBudget[heapIndex] = 0;
+            m_BlockBytesAtBudgetFetch[heapIndex] = 0;
+#endif
+        }
+
+#if VMA_MEMORY_BUDGET
+        m_OperationsSinceBudgetFetch = 0;
+#endif
+    }
+
+    void AddAllocation(uint32_t heapIndex, VkDeviceSize allocationSize)
+    {
+        m_AllocationBytes[heapIndex] += allocationSize;
+#if VMA_MEMORY_BUDGET
+        ++m_OperationsSinceBudgetFetch;
+#endif
+    }
+
+    void RemoveAllocation(uint32_t heapIndex, VkDeviceSize allocationSize)
+    {
+        VMA_ASSERT(m_AllocationBytes[heapIndex] >= allocationSize); // DELME
+        m_AllocationBytes[heapIndex] -= allocationSize;
+#if VMA_MEMORY_BUDGET
+        ++m_OperationsSinceBudgetFetch;
+#endif
+    }
+};
+
+// Main allocator object.
+struct VmaAllocator_T
+{
+    VMA_CLASS_NO_COPY(VmaAllocator_T)
+public:
+    bool m_UseMutex;
+    uint32_t m_VulkanApiVersion;
+    bool m_UseKhrDedicatedAllocation; // Can be set only if m_VulkanApiVersion < VK_MAKE_VERSION(1, 1, 0).
+    bool m_UseKhrBindMemory2; // Can be set only if m_VulkanApiVersion < VK_MAKE_VERSION(1, 1, 0).
+    bool m_UseExtMemoryBudget;
+    bool m_UseAmdDeviceCoherentMemory;
+    bool m_UseKhrBufferDeviceAddress;
+    bool m_UseExtMemoryPriority;
+    VkDevice m_hDevice;
+    VkInstance m_hInstance;
+    bool m_AllocationCallbacksSpecified;
+    VkAllocationCallbacks m_AllocationCallbacks;
+    VmaDeviceMemoryCallbacks m_DeviceMemoryCallbacks;
+    VmaAllocationObjectAllocator m_AllocationObjectAllocator;
+
+    // Each bit (1 << i) is set if HeapSizeLimit is enabled for that heap, so cannot allocate more than the heap size.
+    uint32_t m_HeapSizeLimitMask;
+
+    VkPhysicalDeviceProperties m_PhysicalDeviceProperties;
+    VkPhysicalDeviceMemoryProperties m_MemProps;
+
+    // Default pools.
+    VmaBlockVector* m_pBlockVectors[VK_MAX_MEMORY_TYPES];
+
+    // Each vector is sorted by memory (handle value).
+    typedef VmaVector< VmaAllocation, VmaStlAllocator<VmaAllocation> > AllocationVectorType;
+    AllocationVectorType* m_pDedicatedAllocations[VK_MAX_MEMORY_TYPES];
+    VMA_RW_MUTEX m_DedicatedAllocationsMutex[VK_MAX_MEMORY_TYPES];
+
+    VmaCurrentBudgetData m_Budget;
+
+    VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo);
+    VkResult Init(const VmaAllocatorCreateInfo* pCreateInfo);
+    ~VmaAllocator_T();
+
+    const VkAllocationCallbacks* GetAllocationCallbacks() const
+    {
+        return m_AllocationCallbacksSpecified ? &m_AllocationCallbacks : 0;
+    }
+    const VmaVulkanFunctions& GetVulkanFunctions() const
+    {
+        return m_VulkanFunctions;
+    }
+
+    VkPhysicalDevice GetPhysicalDevice() const { return m_PhysicalDevice; }
+
+    VkDeviceSize GetBufferImageGranularity() const
+    {
+        return VMA_MAX(
+            static_cast<VkDeviceSize>(VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY),
+            m_PhysicalDeviceProperties.limits.bufferImageGranularity);
+    }
+
+    uint32_t GetMemoryHeapCount() const { return m_MemProps.memoryHeapCount; }
+    uint32_t GetMemoryTypeCount() const { return m_MemProps.memoryTypeCount; }
+
+    uint32_t MemoryTypeIndexToHeapIndex(uint32_t memTypeIndex) const
+    {
+        VMA_ASSERT(memTypeIndex < m_MemProps.memoryTypeCount);
+        return m_MemProps.memoryTypes[memTypeIndex].heapIndex;
+    }
+    // True when specific memory type is HOST_VISIBLE but not HOST_COHERENT.
+    bool IsMemoryTypeNonCoherent(uint32_t memTypeIndex) const
+    {
+        return (m_MemProps.memoryTypes[memTypeIndex].propertyFlags & (VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) ==
+            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
+    }
+    // Minimum alignment for all allocations in specific memory type.
+    VkDeviceSize GetMemoryTypeMinAlignment(uint32_t memTypeIndex) const
+    {
+        return IsMemoryTypeNonCoherent(memTypeIndex) ?
+            VMA_MAX((VkDeviceSize)VMA_DEBUG_ALIGNMENT, m_PhysicalDeviceProperties.limits.nonCoherentAtomSize) :
+            (VkDeviceSize)VMA_DEBUG_ALIGNMENT;
+    }
+
+    bool IsIntegratedGpu() const
+    {
+        return m_PhysicalDeviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
+    }
+
+    uint32_t GetGlobalMemoryTypeBits() const { return m_GlobalMemoryTypeBits; }
+
+#if VMA_RECORDING_ENABLED
+    VmaRecorder* GetRecorder() const { return m_pRecorder; }
+#endif
+
+    void GetBufferMemoryRequirements(
+        VkBuffer hBuffer,
+        VkMemoryRequirements& memReq,
+        bool& requiresDedicatedAllocation,
+        bool& prefersDedicatedAllocation) const;
+    void GetImageMemoryRequirements(
+        VkImage hImage,
+        VkMemoryRequirements& memReq,
+        bool& requiresDedicatedAllocation,
+        bool& prefersDedicatedAllocation) const;
+
+    // Main allocation function.
+    VkResult AllocateMemory(
+        const VkMemoryRequirements& vkMemReq,
+        bool requiresDedicatedAllocation,
+        bool prefersDedicatedAllocation,
+        VkBuffer dedicatedBuffer,
+        VkBufferUsageFlags dedicatedBufferUsage, // UINT32_MAX when unknown.
+        VkImage dedicatedImage,
+        const VmaAllocationCreateInfo& createInfo,
+        VmaSuballocationType suballocType,
+        size_t allocationCount,
+        VmaAllocation* pAllocations);
+
+    // Main deallocation function.
+    void FreeMemory(
+        size_t allocationCount,
+        const VmaAllocation* pAllocations);
+
+    VkResult ResizeAllocation(
+        const VmaAllocation alloc,
+        VkDeviceSize newSize);
+
+    void CalculateStats(VmaStats* pStats);
+
+    void GetBudget(
+        VmaBudget* outBudget, uint32_t firstHeap, uint32_t heapCount);
+
+#if VMA_STATS_STRING_ENABLED
+    void PrintDetailedMap(class VmaJsonWriter& json);
+#endif
+
+    VkResult DefragmentationBegin(
+        const VmaDefragmentationInfo2& info,
+        VmaDefragmentationStats* pStats,
+        VmaDefragmentationContext* pContext);
+    VkResult DefragmentationEnd(
+        VmaDefragmentationContext context);
+
+    VkResult DefragmentationPassBegin(
+        VmaDefragmentationPassInfo* pInfo,
+        VmaDefragmentationContext context);
+    VkResult DefragmentationPassEnd(
+        VmaDefragmentationContext context);
+
+    void GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo);
+    bool TouchAllocation(VmaAllocation hAllocation);
+
+    VkResult CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool);
+    void DestroyPool(VmaPool pool);
+    void GetPoolStats(VmaPool pool, VmaPoolStats* pPoolStats);
+
+    void SetCurrentFrameIndex(uint32_t frameIndex);
+    uint32_t GetCurrentFrameIndex() const { return m_CurrentFrameIndex.load(); }
+
+    void MakePoolAllocationsLost(
+        VmaPool hPool,
+        size_t* pLostAllocationCount);
+    VkResult CheckPoolCorruption(VmaPool hPool);
+    VkResult CheckCorruption(uint32_t memoryTypeBits);
+
+    void CreateLostAllocation(VmaAllocation* pAllocation);
+
+    // Call to Vulkan function vkAllocateMemory with accompanying bookkeeping.
+    VkResult AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory);
+    // Call to Vulkan function vkFreeMemory with accompanying bookkeeping.
+    void FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory);
+    // Call to Vulkan function vkBindBufferMemory or vkBindBufferMemory2KHR.
+    VkResult BindVulkanBuffer(
+        VkDeviceMemory memory,
+        VkDeviceSize memoryOffset,
+        VkBuffer buffer,
+        const void* pNext);
+    // Call to Vulkan function vkBindImageMemory or vkBindImageMemory2KHR.
+    VkResult BindVulkanImage(
+        VkDeviceMemory memory,
+        VkDeviceSize memoryOffset,
+        VkImage image,
+        const void* pNext);
+
+    VkResult Map(VmaAllocation hAllocation, void** ppData);
+    void Unmap(VmaAllocation hAllocation);
+
+    VkResult BindBufferMemory(
+        VmaAllocation hAllocation,
+        VkDeviceSize allocationLocalOffset,
+        VkBuffer hBuffer,
+        const void* pNext);
+    VkResult BindImageMemory(
+        VmaAllocation hAllocation,
+        VkDeviceSize allocationLocalOffset,
+        VkImage hImage,
+        const void* pNext);
+
+    VkResult FlushOrInvalidateAllocation(
+        VmaAllocation hAllocation,
+        VkDeviceSize offset, VkDeviceSize size,
+        VMA_CACHE_OPERATION op);
+    VkResult FlushOrInvalidateAllocations(
+        uint32_t allocationCount,
+        const VmaAllocation* allocations,
+        const VkDeviceSize* offsets, const VkDeviceSize* sizes,
+        VMA_CACHE_OPERATION op);
+
+    void FillAllocation(const VmaAllocation hAllocation, uint8_t pattern);
+
+    /*
+    Returns bit mask of memory types that can support defragmentation on GPU as
+    they support creation of required buffer for copy operations.
+    */
+    uint32_t GetGpuDefragmentationMemoryTypeBits();
+
+private:
+    VkDeviceSize m_PreferredLargeHeapBlockSize;
+
+    VkPhysicalDevice m_PhysicalDevice;
+    VMA_ATOMIC_UINT32 m_CurrentFrameIndex;
+    VMA_ATOMIC_UINT32 m_GpuDefragmentationMemoryTypeBits; // UINT32_MAX means uninitialized.
+
+    VMA_RW_MUTEX m_PoolsMutex;
+    // Protected by m_PoolsMutex. Sorted by pointer value.
+    VmaVector<VmaPool, VmaStlAllocator<VmaPool> > m_Pools;
+    uint32_t m_NextPoolId;
+
+    VmaVulkanFunctions m_VulkanFunctions;
+
+    // Global bit mask AND-ed with any memoryTypeBits to disallow certain memory types.
+    uint32_t m_GlobalMemoryTypeBits;
+
+#if VMA_RECORDING_ENABLED
+    VmaRecorder* m_pRecorder;
+#endif
+
+    void ImportVulkanFunctions(const VmaVulkanFunctions* pVulkanFunctions);
+
+#if VMA_STATIC_VULKAN_FUNCTIONS == 1
+    void ImportVulkanFunctions_Static();
+#endif
+
+    void ImportVulkanFunctions_Custom(const VmaVulkanFunctions* pVulkanFunctions);
+
+#if VMA_DYNAMIC_VULKAN_FUNCTIONS == 1
+    void ImportVulkanFunctions_Dynamic();
+#endif
+
+    void ValidateVulkanFunctions();
+
+    VkDeviceSize CalcPreferredBlockSize(uint32_t memTypeIndex);
+
+    VkResult AllocateMemoryOfType(
+        VkDeviceSize size,
+        VkDeviceSize alignment,
+        bool dedicatedAllocation,
+        VkBuffer dedicatedBuffer,
+        VkBufferUsageFlags dedicatedBufferUsage,
+        VkImage dedicatedImage,
+        const VmaAllocationCreateInfo& createInfo,
+        uint32_t memTypeIndex,
+        VmaSuballocationType suballocType,
+        size_t allocationCount,
+        VmaAllocation* pAllocations);
+
+    // Helper function only to be used inside AllocateDedicatedMemory.
+    VkResult AllocateDedicatedMemoryPage(
+        VkDeviceSize size,
+        VmaSuballocationType suballocType,
+        uint32_t memTypeIndex,
+        const VkMemoryAllocateInfo& allocInfo,
+        bool map,
+        bool isUserDataString,
+        void* pUserData,
+        VmaAllocation* pAllocation);
+
+    // Allocates and registers new VkDeviceMemory specifically for dedicated allocations.
+    VkResult AllocateDedicatedMemory(
+        VkDeviceSize size,
+        VmaSuballocationType suballocType,
+        uint32_t memTypeIndex,
+        bool withinBudget,
+        bool map,
+        bool isUserDataString,
+        void* pUserData,
+        float priority,
+        VkBuffer dedicatedBuffer,
+        VkBufferUsageFlags dedicatedBufferUsage,
+        VkImage dedicatedImage,
+        size_t allocationCount,
+        VmaAllocation* pAllocations);
+
+    void FreeDedicatedMemory(const VmaAllocation allocation);
+
+    /*
+    Calculates and returns bit mask of memory types that can support defragmentation
+    on GPU as they support creation of required buffer for copy operations.
+    */
+    uint32_t CalculateGpuDefragmentationMemoryTypeBits() const;
+
+    uint32_t CalculateGlobalMemoryTypeBits() const;
+
+    bool GetFlushOrInvalidateRange(
+        VmaAllocation allocation,
+        VkDeviceSize offset, VkDeviceSize size,
+        VkMappedMemoryRange& outRange) const;
+
+#if VMA_MEMORY_BUDGET
+    void UpdateVulkanBudget();
+#endif // #if VMA_MEMORY_BUDGET
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// Memory allocation #2 after VmaAllocator_T definition
+
+static void* VmaMalloc(VmaAllocator hAllocator, size_t size, size_t alignment)
+{
+    return VmaMalloc(&hAllocator->m_AllocationCallbacks, size, alignment);
+}
+
+static void VmaFree(VmaAllocator hAllocator, void* ptr)
+{
+    VmaFree(&hAllocator->m_AllocationCallbacks, ptr);
+}
+
+template<typename T>
+static T* VmaAllocate(VmaAllocator hAllocator)
+{
+    return (T*)VmaMalloc(hAllocator, sizeof(T), VMA_ALIGN_OF(T));
+}
+
+template<typename T>
+static T* VmaAllocateArray(VmaAllocator hAllocator, size_t count)
+{
+    return (T*)VmaMalloc(hAllocator, sizeof(T) * count, VMA_ALIGN_OF(T));
+}
+
+template<typename T>
+static void vma_delete(VmaAllocator hAllocator, T* ptr)
+{
+    if(ptr != VMA_NULL)
+    {
+        ptr->~T();
+        VmaFree(hAllocator, ptr);
+    }
+}
+
+template<typename T>
+static void vma_delete_array(VmaAllocator hAllocator, T* ptr, size_t count)
+{
+    if(ptr != VMA_NULL)
+    {
+        for(size_t i = count; i--; )
+            ptr[i].~T();
+        VmaFree(hAllocator, ptr);
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// VmaStringBuilder
+
+#if VMA_STATS_STRING_ENABLED
+
+class VmaStringBuilder
+{
+public:
+    VmaStringBuilder(VmaAllocator alloc) : m_Data(VmaStlAllocator<char>(alloc->GetAllocationCallbacks())) { }
+    size_t GetLength() const { return m_Data.size(); }
+    const char* GetData() const { return m_Data.data(); }
+
+    void Add(char ch) { m_Data.push_back(ch); }
+    void Add(const char* pStr);
+    void AddNewLine() { Add('\n'); }
+    void AddNumber(uint32_t num);
+    void AddNumber(uint64_t num);
+    void AddPointer(const void* ptr);
+
+private:
+    VmaVector< char, VmaStlAllocator<char> > m_Data;
+};
+
+void VmaStringBuilder::Add(const char* pStr)
+{
+    const size_t strLen = strlen(pStr);
+    if(strLen > 0)
+    {
+        const size_t oldCount = m_Data.size();
+        m_Data.resize(oldCount + strLen);
+        memcpy(m_Data.data() + oldCount, pStr, strLen);
+    }
+}
+
+void VmaStringBuilder::AddNumber(uint32_t num)
+{
+    char buf[11];
+    buf[10] = '\0';
+    char *p = &buf[10];
+    do
+    {
+        *--p = '0' + (num % 10);
+        num /= 10;
+    }
+    while(num);
+    Add(p);
+}
+
+void VmaStringBuilder::AddNumber(uint64_t num)
+{
+    char buf[21];
+    buf[20] = '\0';
+    char *p = &buf[20];
+    do
+    {
+        *--p = '0' + (num % 10);
+        num /= 10;
+    }
+    while(num);
+    Add(p);
+}
+
+void VmaStringBuilder::AddPointer(const void* ptr)
+{
+    char buf[21];
+    VmaPtrToStr(buf, sizeof(buf), ptr);
+    Add(buf);
+}
+
+#endif // #if VMA_STATS_STRING_ENABLED
+
+////////////////////////////////////////////////////////////////////////////////
+// VmaJsonWriter
+
+#if VMA_STATS_STRING_ENABLED
+
+class VmaJsonWriter
+{
+    VMA_CLASS_NO_COPY(VmaJsonWriter)
+public:
+    VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb);
+    ~VmaJsonWriter();
+
+    void BeginObject(bool singleLine = false);
+    void EndObject();
+
+    void BeginArray(bool singleLine = false);
+    void EndArray();
+
+    void WriteString(const char* pStr);
+    void BeginString(const char* pStr = VMA_NULL);
+    void ContinueString(const char* pStr);
+    void ContinueString(uint32_t n);
+    void ContinueString(uint64_t n);
+    void ContinueString_Pointer(const void* ptr);
+    void EndString(const char* pStr = VMA_NULL);
+
+    void WriteNumber(uint32_t n);
+    void WriteNumber(uint64_t n);
+    void WriteBool(bool b);
+    void WriteNull();
+
+private:
+    static const char* const INDENT;
+
+    enum COLLECTION_TYPE
+    {
+        COLLECTION_TYPE_OBJECT,
+        COLLECTION_TYPE_ARRAY,
+    };
+    struct StackItem
+    {
+        COLLECTION_TYPE type;
+        uint32_t valueCount;
+        bool singleLineMode;
+    };
+
+    VmaStringBuilder& m_SB;
+    VmaVector< StackItem, VmaStlAllocator<StackItem> > m_Stack;
+    bool m_InsideString;
+
+    void BeginValue(bool isString);
+    void WriteIndent(bool oneLess = false);
+};
+
+const char* const VmaJsonWriter::INDENT = "  ";
+
+VmaJsonWriter::VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb) :
+    m_SB(sb),
+    m_Stack(VmaStlAllocator<StackItem>(pAllocationCallbacks)),
+    m_InsideString(false)
+{
+}
+
+VmaJsonWriter::~VmaJsonWriter()
+{
+    VMA_ASSERT(!m_InsideString);
+    VMA_ASSERT(m_Stack.empty());
+}
+
+void VmaJsonWriter::BeginObject(bool singleLine)
+{
+    VMA_ASSERT(!m_InsideString);
+
+    BeginValue(false);
+    m_SB.Add('{');
+
+    StackItem item;
+    item.type = COLLECTION_TYPE_OBJECT;
+    item.valueCount = 0;
+    item.singleLineMode = singleLine;
+    m_Stack.push_back(item);
+}
+
+void VmaJsonWriter::EndObject()
+{
+    VMA_ASSERT(!m_InsideString);
+
+    WriteIndent(true);
+    m_SB.Add('}');
+
+    VMA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_OBJECT);
+    m_Stack.pop_back();
+}
+
+void VmaJsonWriter::BeginArray(bool singleLine)
+{
+    VMA_ASSERT(!m_InsideString);
+
+    BeginValue(false);
+    m_SB.Add('[');
+
+    StackItem item;
+    item.type = COLLECTION_TYPE_ARRAY;
+    item.valueCount = 0;
+    item.singleLineMode = singleLine;
+    m_Stack.push_back(item);
+}
+
+void VmaJsonWriter::EndArray()
+{
+    VMA_ASSERT(!m_InsideString);
+
+    WriteIndent(true);
+    m_SB.Add(']');
+
+    VMA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_ARRAY);
+    m_Stack.pop_back();
+}
+
+void VmaJsonWriter::WriteString(const char* pStr)
+{
+    BeginString(pStr);
+    EndString();
+}
+
+void VmaJsonWriter::BeginString(const char* pStr)
+{
+    VMA_ASSERT(!m_InsideString);
+
+    BeginValue(true);
+    m_SB.Add('"');
+    m_InsideString = true;
+    if(pStr != VMA_NULL && pStr[0] != '\0')
+    {
+        ContinueString(pStr);
+    }
+}
+
+void VmaJsonWriter::ContinueString(const char* pStr)
+{
+    VMA_ASSERT(m_InsideString);
+
+    const size_t strLen = strlen(pStr);
+    for(size_t i = 0; i < strLen; ++i)
+    {
+        char ch = pStr[i];
+        if(ch == '\\')
+        {
+            m_SB.Add("\\\\");
+        }
+        else if(ch == '"')
+        {
+            m_SB.Add("\\\"");
+        }
+        else if(ch >= 32)
+        {
+            m_SB.Add(ch);
+        }
+        else switch(ch)
+        {
+        case '\b':
+            m_SB.Add("\\b");
+            break;
+        case '\f':
+            m_SB.Add("\\f");
+            break;
+        case '\n':
+            m_SB.Add("\\n");
+            break;
+        case '\r':
+            m_SB.Add("\\r");
+            break;
+        case '\t':
+            m_SB.Add("\\t");
+            break;
+        default:
+            VMA_ASSERT(0 && "Character not currently supported.");
+            break;
+        }
+    }
+}
+
+void VmaJsonWriter::ContinueString(uint32_t n)
+{
+    VMA_ASSERT(m_InsideString);
+    m_SB.AddNumber(n);
+}
+
+void VmaJsonWriter::ContinueString(uint64_t n)
+{
+    VMA_ASSERT(m_InsideString);
+    m_SB.AddNumber(n);
+}
+
+void VmaJsonWriter::ContinueString_Pointer(const void* ptr)
+{
+    VMA_ASSERT(m_InsideString);
+    m_SB.AddPointer(ptr);
+}
+
+void VmaJsonWriter::EndString(const char* pStr)
+{
+    VMA_ASSERT(m_InsideString);
+    if(pStr != VMA_NULL && pStr[0] != '\0')
+    {
+        ContinueString(pStr);
+    }
+    m_SB.Add('"');
+    m_InsideString = false;
+}
+
+void VmaJsonWriter::WriteNumber(uint32_t n)
+{
+    VMA_ASSERT(!m_InsideString);
+    BeginValue(false);
+    m_SB.AddNumber(n);
+}
+
+void VmaJsonWriter::WriteNumber(uint64_t n)
+{
+    VMA_ASSERT(!m_InsideString);
+    BeginValue(false);
+    m_SB.AddNumber(n);
+}
+
+void VmaJsonWriter::WriteBool(bool b)
+{
+    VMA_ASSERT(!m_InsideString);
+    BeginValue(false);
+    m_SB.Add(b ? "true" : "false");
+}
+
+void VmaJsonWriter::WriteNull()
+{
+    VMA_ASSERT(!m_InsideString);
+    BeginValue(false);
+    m_SB.Add("null");
+}
+
+void VmaJsonWriter::BeginValue(bool isString)
+{
+    if(!m_Stack.empty())
+    {
+        StackItem& currItem = m_Stack.back();
+        if(currItem.type == COLLECTION_TYPE_OBJECT &&
+            currItem.valueCount % 2 == 0)
+        {
+            VMA_ASSERT(isString);
+        }
+
+        if(currItem.type == COLLECTION_TYPE_OBJECT &&
+            currItem.valueCount % 2 != 0)
+        {
+            m_SB.Add(": ");
+        }
+        else if(currItem.valueCount > 0)
+        {
+            m_SB.Add(", ");
+            WriteIndent();
+        }
+        else
+        {
+            WriteIndent();
+        }
+        ++currItem.valueCount;
+    }
+}
+
+void VmaJsonWriter::WriteIndent(bool oneLess)
+{
+    if(!m_Stack.empty() && !m_Stack.back().singleLineMode)
+    {
+        m_SB.AddNewLine();
+
+        size_t count = m_Stack.size();
+        if(count > 0 && oneLess)
+        {
+            --count;
+        }
+        for(size_t i = 0; i < count; ++i)
+        {
+            m_SB.Add(INDENT);
+        }
+    }
+}
+
+#endif // #if VMA_STATS_STRING_ENABLED
+
+////////////////////////////////////////////////////////////////////////////////
+
+void VmaAllocation_T::SetUserData(VmaAllocator hAllocator, void* pUserData)
+{
+    if(IsUserDataString())
+    {
+        VMA_ASSERT(pUserData == VMA_NULL || pUserData != m_pUserData);
+
+        FreeUserDataString(hAllocator);
+
+        if(pUserData != VMA_NULL)
+        {
+            m_pUserData = VmaCreateStringCopy(hAllocator->GetAllocationCallbacks(), (const char*)pUserData);
+        }
+    }
+    else
+    {
+        m_pUserData = pUserData;
+    }
+}
+
+void VmaAllocation_T::ChangeBlockAllocation(
+    VmaAllocator hAllocator,
+    VmaDeviceMemoryBlock* block,
+    VkDeviceSize offset)
+{
+    VMA_ASSERT(block != VMA_NULL);
+    VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
+
+    // Move mapping reference counter from old block to new block.
+    if(block != m_BlockAllocation.m_Block)
+    {
+        uint32_t mapRefCount = m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP;
+        if(IsPersistentMap())
+            ++mapRefCount;
+        m_BlockAllocation.m_Block->Unmap(hAllocator, mapRefCount);
+        block->Map(hAllocator, mapRefCount, VMA_NULL);
+    }
+
+    m_BlockAllocation.m_Block = block;
+    m_BlockAllocation.m_Offset = offset;
+}
+
+void VmaAllocation_T::ChangeOffset(VkDeviceSize newOffset)
+{
+    VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
+    m_BlockAllocation.m_Offset = newOffset;
+}
+
+VkDeviceSize VmaAllocation_T::GetOffset() const
+{
+    switch(m_Type)
+    {
+    case ALLOCATION_TYPE_BLOCK:
+        return m_BlockAllocation.m_Offset;
+    case ALLOCATION_TYPE_DEDICATED:
+        return 0;
+    default:
+        VMA_ASSERT(0);
+        return 0;
+    }
+}
+
+VkDeviceMemory VmaAllocation_T::GetMemory() const
+{
+    switch(m_Type)
+    {
+    case ALLOCATION_TYPE_BLOCK:
+        return m_BlockAllocation.m_Block->GetDeviceMemory();
+    case ALLOCATION_TYPE_DEDICATED:
+        return m_DedicatedAllocation.m_hMemory;
+    default:
+        VMA_ASSERT(0);
+        return VK_NULL_HANDLE;
+    }
+}
+
+void* VmaAllocation_T::GetMappedData() const
+{
+    switch(m_Type)
+    {
+    case ALLOCATION_TYPE_BLOCK:
+        if(m_MapCount != 0)
+        {
+            void* pBlockData = m_BlockAllocation.m_Block->GetMappedData();
+            VMA_ASSERT(pBlockData != VMA_NULL);
+            return (char*)pBlockData + m_BlockAllocation.m_Offset;
+        }
+        else
+        {
+            return VMA_NULL;
+        }
+        break;
+    case ALLOCATION_TYPE_DEDICATED:
+        VMA_ASSERT((m_DedicatedAllocation.m_pMappedData != VMA_NULL) == (m_MapCount != 0));
+        return m_DedicatedAllocation.m_pMappedData;
+    default:
+        VMA_ASSERT(0);
+        return VMA_NULL;
+    }
+}
+
+bool VmaAllocation_T::CanBecomeLost() const
+{
+    switch(m_Type)
+    {
+    case ALLOCATION_TYPE_BLOCK:
+        return m_BlockAllocation.m_CanBecomeLost;
+    case ALLOCATION_TYPE_DEDICATED:
+        return false;
+    default:
+        VMA_ASSERT(0);
+        return false;
+    }
+}
+
+bool VmaAllocation_T::MakeLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
+{
+    VMA_ASSERT(CanBecomeLost());
+
+    /*
+    Warning: This is a carefully designed algorithm.
+    Do not modify unless you really know what you're doing :)
+    */
+    uint32_t localLastUseFrameIndex = GetLastUseFrameIndex();
+    for(;;)
+    {
+        if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
+        {
+            VMA_ASSERT(0);
+            return false;
+        }
+        else if(localLastUseFrameIndex + frameInUseCount >= currentFrameIndex)
+        {
+            return false;
+        }
+        else // Last use time earlier than current time.
+        {
+            if(CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, VMA_FRAME_INDEX_LOST))
+            {
+                // Setting hAllocation.LastUseFrameIndex atomic to VMA_FRAME_INDEX_LOST is enough to mark it as LOST.
+                // Calling code just needs to unregister this allocation in owning VmaDeviceMemoryBlock.
+                return true;
+            }
+        }
+    }
+}
+
+#if VMA_STATS_STRING_ENABLED
+
+// Correspond to values of enum VmaSuballocationType.
+static const char* VMA_SUBALLOCATION_TYPE_NAMES[] = {
+    "FREE",
+    "UNKNOWN",
+    "BUFFER",
+    "IMAGE_UNKNOWN",
+    "IMAGE_LINEAR",
+    "IMAGE_OPTIMAL",
+};
+
+void VmaAllocation_T::PrintParameters(class VmaJsonWriter& json) const
+{
+    json.WriteString("Type");
+    json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[m_SuballocationType]);
+
+    json.WriteString("Size");
+    json.WriteNumber(m_Size);
+
+    if(m_pUserData != VMA_NULL)
+    {
+        json.WriteString("UserData");
+        if(IsUserDataString())
+        {
+            json.WriteString((const char*)m_pUserData);
+        }
+        else
+        {
+            json.BeginString();
+            json.ContinueString_Pointer(m_pUserData);
+            json.EndString();
+        }
+    }
+
+    json.WriteString("CreationFrameIndex");
+    json.WriteNumber(m_CreationFrameIndex);
+
+    json.WriteString("LastUseFrameIndex");
+    json.WriteNumber(GetLastUseFrameIndex());
+
+    if(m_BufferImageUsage != 0)
+    {
+        json.WriteString("Usage");
+        json.WriteNumber(m_BufferImageUsage);
+    }
+}
+
+#endif
+
+void VmaAllocation_T::FreeUserDataString(VmaAllocator hAllocator)
+{
+    VMA_ASSERT(IsUserDataString());
+    VmaFreeString(hAllocator->GetAllocationCallbacks(), (char*)m_pUserData);
+    m_pUserData = VMA_NULL;
+}
+
+void VmaAllocation_T::BlockAllocMap()
+{
+    VMA_ASSERT(GetType() == ALLOCATION_TYPE_BLOCK);
+
+    if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) < 0x7F)
+    {
+        ++m_MapCount;
+    }
+    else
+    {
+        VMA_ASSERT(0 && "Allocation mapped too many times simultaneously.");
+    }
+}
+
+void VmaAllocation_T::BlockAllocUnmap()
+{
+    VMA_ASSERT(GetType() == ALLOCATION_TYPE_BLOCK);
+
+    if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) != 0)
+    {
+        --m_MapCount;
+    }
+    else
+    {
+        VMA_ASSERT(0 && "Unmapping allocation not previously mapped.");
+    }
+}
+
+VkResult VmaAllocation_T::DedicatedAllocMap(VmaAllocator hAllocator, void** ppData)
+{
+    VMA_ASSERT(GetType() == ALLOCATION_TYPE_DEDICATED);
+
+    if(m_MapCount != 0)
+    {
+        if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) < 0x7F)
+        {
+            VMA_ASSERT(m_DedicatedAllocation.m_pMappedData != VMA_NULL);
+            *ppData = m_DedicatedAllocation.m_pMappedData;
+            ++m_MapCount;
+            return VK_SUCCESS;
+        }
+        else
+        {
+            VMA_ASSERT(0 && "Dedicated allocation mapped too many times simultaneously.");
+            return VK_ERROR_MEMORY_MAP_FAILED;
+        }
+    }
+    else
+    {
+        VkResult result = (*hAllocator->GetVulkanFunctions().vkMapMemory)(
+            hAllocator->m_hDevice,
+            m_DedicatedAllocation.m_hMemory,
+            0, // offset
+            VK_WHOLE_SIZE,
+            0, // flags
+            ppData);
+        if(result == VK_SUCCESS)
+        {
+            m_DedicatedAllocation.m_pMappedData = *ppData;
+            m_MapCount = 1;
+        }
+        return result;
+    }
+}
+
+void VmaAllocation_T::DedicatedAllocUnmap(VmaAllocator hAllocator)
+{
+    VMA_ASSERT(GetType() == ALLOCATION_TYPE_DEDICATED);
+
+    if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) != 0)
+    {
+        --m_MapCount;
+        if(m_MapCount == 0)
+        {
+            m_DedicatedAllocation.m_pMappedData = VMA_NULL;
+            (*hAllocator->GetVulkanFunctions().vkUnmapMemory)(
+                hAllocator->m_hDevice,
+                m_DedicatedAllocation.m_hMemory);
+        }
+    }
+    else
+    {
+        VMA_ASSERT(0 && "Unmapping dedicated allocation not previously mapped.");
+    }
+}
+
+#if VMA_STATS_STRING_ENABLED
+
+static void VmaPrintStatInfo(VmaJsonWriter& json, const VmaStatInfo& stat)
+{
+    json.BeginObject();
+
+    json.WriteString("Blocks");
+    json.WriteNumber(stat.blockCount);
+
+    json.WriteString("Allocations");
+    json.WriteNumber(stat.allocationCount);
+
+    json.WriteString("UnusedRanges");
+    json.WriteNumber(stat.unusedRangeCount);
+
+    json.WriteString("UsedBytes");
+    json.WriteNumber(stat.usedBytes);
+
+    json.WriteString("UnusedBytes");
+    json.WriteNumber(stat.unusedBytes);
+
+    if(stat.allocationCount > 1)
+    {
+        json.WriteString("AllocationSize");
+        json.BeginObject(true);
+        json.WriteString("Min");
+        json.WriteNumber(stat.allocationSizeMin);
+        json.WriteString("Avg");
+        json.WriteNumber(stat.allocationSizeAvg);
+        json.WriteString("Max");
+        json.WriteNumber(stat.allocationSizeMax);
+        json.EndObject();
+    }
+
+    if(stat.unusedRangeCount > 1)
+    {
+        json.WriteString("UnusedRangeSize");
+        json.BeginObject(true);
+        json.WriteString("Min");
+        json.WriteNumber(stat.unusedRangeSizeMin);
+        json.WriteString("Avg");
+        json.WriteNumber(stat.unusedRangeSizeAvg);
+        json.WriteString("Max");
+        json.WriteNumber(stat.unusedRangeSizeMax);
+        json.EndObject();
+    }
+
+    json.EndObject();
+}
+
+#endif // #if VMA_STATS_STRING_ENABLED
+
+struct VmaSuballocationItemSizeLess
+{
+    bool operator()(
+        const VmaSuballocationList::iterator lhs,
+        const VmaSuballocationList::iterator rhs) const
+    {
+        return lhs->size < rhs->size;
+    }
+    bool operator()(
+        const VmaSuballocationList::iterator lhs,
+        VkDeviceSize rhsSize) const
+    {
+        return lhs->size < rhsSize;
+    }
+};
+
+
+////////////////////////////////////////////////////////////////////////////////
+// class VmaBlockMetadata
+
+VmaBlockMetadata::VmaBlockMetadata(VmaAllocator hAllocator) :
+    m_Size(0),
+    m_pAllocationCallbacks(hAllocator->GetAllocationCallbacks())
+{
+}
+
+#if VMA_STATS_STRING_ENABLED
+
+void VmaBlockMetadata::PrintDetailedMap_Begin(class VmaJsonWriter& json,
+    VkDeviceSize unusedBytes,
+    size_t allocationCount,
+    size_t unusedRangeCount) const
+{
+    json.BeginObject();
+
+    json.WriteString("TotalBytes");
+    json.WriteNumber(GetSize());
+
+    json.WriteString("UnusedBytes");
+    json.WriteNumber(unusedBytes);
+
+    json.WriteString("Allocations");
+    json.WriteNumber((uint64_t)allocationCount);
+
+    json.WriteString("UnusedRanges");
+    json.WriteNumber((uint64_t)unusedRangeCount);
+
+    json.WriteString("Suballocations");
+    json.BeginArray();
+}
+
+void VmaBlockMetadata::PrintDetailedMap_Allocation(class VmaJsonWriter& json,
+    VkDeviceSize offset,
+    VmaAllocation hAllocation) const
+{
+    json.BeginObject(true);
+
+    json.WriteString("Offset");
+    json.WriteNumber(offset);
+
+    hAllocation->PrintParameters(json);
+
+    json.EndObject();
+}
+
+void VmaBlockMetadata::PrintDetailedMap_UnusedRange(class VmaJsonWriter& json,
+    VkDeviceSize offset,
+    VkDeviceSize size) const
+{
+    json.BeginObject(true);
+
+    json.WriteString("Offset");
+    json.WriteNumber(offset);
+
+    json.WriteString("Type");
+    json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[VMA_SUBALLOCATION_TYPE_FREE]);
+
+    json.WriteString("Size");
+    json.WriteNumber(size);
+
+    json.EndObject();
+}
+
+void VmaBlockMetadata::PrintDetailedMap_End(class VmaJsonWriter& json) const
+{
+    json.EndArray();
+    json.EndObject();
+}
+
+#endif // #if VMA_STATS_STRING_ENABLED
+
+////////////////////////////////////////////////////////////////////////////////
+// class VmaBlockMetadata_Generic
+
+VmaBlockMetadata_Generic::VmaBlockMetadata_Generic(VmaAllocator hAllocator) :
+    VmaBlockMetadata(hAllocator),
+    m_FreeCount(0),
+    m_SumFreeSize(0),
+    m_Suballocations(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),
+    m_FreeSuballocationsBySize(VmaStlAllocator<VmaSuballocationList::iterator>(hAllocator->GetAllocationCallbacks()))
+{
+}
+
+VmaBlockMetadata_Generic::~VmaBlockMetadata_Generic()
+{
+}
+
+void VmaBlockMetadata_Generic::Init(VkDeviceSize size)
+{
+    VmaBlockMetadata::Init(size);
+
+    m_FreeCount = 1;
+    m_SumFreeSize = size;
+
+    VmaSuballocation suballoc = {};
+    suballoc.offset = 0;
+    suballoc.size = size;
+    suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
+    suballoc.hAllocation = VK_NULL_HANDLE;
+
+    VMA_ASSERT(size > VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER);
+    m_Suballocations.push_back(suballoc);
+    VmaSuballocationList::iterator suballocItem = m_Suballocations.end();
+    --suballocItem;
+    m_FreeSuballocationsBySize.push_back(suballocItem);
+}
+
+bool VmaBlockMetadata_Generic::Validate() const
+{
+    VMA_VALIDATE(!m_Suballocations.empty());
+
+    // Expected offset of new suballocation as calculated from previous ones.
+    VkDeviceSize calculatedOffset = 0;
+    // Expected number of free suballocations as calculated from traversing their list.
+    uint32_t calculatedFreeCount = 0;
+    // Expected sum size of free suballocations as calculated from traversing their list.
+    VkDeviceSize calculatedSumFreeSize = 0;
+    // Expected number of free suballocations that should be registered in
+    // m_FreeSuballocationsBySize calculated from traversing their list.
+    size_t freeSuballocationsToRegister = 0;
+    // True if previous visited suballocation was free.
+    bool prevFree = false;
+
+    for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
+        suballocItem != m_Suballocations.cend();
+        ++suballocItem)
+    {
+        const VmaSuballocation& subAlloc = *suballocItem;
+
+        // Actual offset of this suballocation doesn't match expected one.
+        VMA_VALIDATE(subAlloc.offset == calculatedOffset);
+
+        const bool currFree = (subAlloc.type == VMA_SUBALLOCATION_TYPE_FREE);
+        // Two adjacent free suballocations are invalid. They should be merged.
+        VMA_VALIDATE(!prevFree || !currFree);
+
+        VMA_VALIDATE(currFree == (subAlloc.hAllocation == VK_NULL_HANDLE));
+
+        if(currFree)
+        {
+            calculatedSumFreeSize += subAlloc.size;
+            ++calculatedFreeCount;
+            if(subAlloc.size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
+            {
+                ++freeSuballocationsToRegister;
+            }
+
+            // Margin required between allocations - every free space must be at least that large.
+            VMA_VALIDATE(subAlloc.size >= VMA_DEBUG_MARGIN);
+        }
+        else
+        {
+            VMA_VALIDATE(subAlloc.hAllocation->GetOffset() == subAlloc.offset);
+            VMA_VALIDATE(subAlloc.hAllocation->GetSize() == subAlloc.size);
+
+            // Margin required between allocations - previous allocation must be free.
+            VMA_VALIDATE(VMA_DEBUG_MARGIN == 0 || prevFree);
+        }
+
+        calculatedOffset += subAlloc.size;
+        prevFree = currFree;
+    }
+
+    // Number of free suballocations registered in m_FreeSuballocationsBySize doesn't
+    // match expected one.
+    VMA_VALIDATE(m_FreeSuballocationsBySize.size() == freeSuballocationsToRegister);
+
+    VkDeviceSize lastSize = 0;
+    for(size_t i = 0; i < m_FreeSuballocationsBySize.size(); ++i)
+    {
+        VmaSuballocationList::iterator suballocItem = m_FreeSuballocationsBySize[i];
+
+        // Only free suballocations can be registered in m_FreeSuballocationsBySize.
+        VMA_VALIDATE(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE);
+        // They must be sorted by size ascending.
+        VMA_VALIDATE(suballocItem->size >= lastSize);
+
+        lastSize = suballocItem->size;
+    }
+
+    // Check if totals match calculacted values.
+    VMA_VALIDATE(ValidateFreeSuballocationList());
+    VMA_VALIDATE(calculatedOffset == GetSize());
+    VMA_VALIDATE(calculatedSumFreeSize == m_SumFreeSize);
+    VMA_VALIDATE(calculatedFreeCount == m_FreeCount);
+
+    return true;
+}
+
+VkDeviceSize VmaBlockMetadata_Generic::GetUnusedRangeSizeMax() const
+{
+    if(!m_FreeSuballocationsBySize.empty())
+    {
+        return m_FreeSuballocationsBySize.back()->size;
+    }
+    else
+    {
+        return 0;
+    }
+}
+
+bool VmaBlockMetadata_Generic::IsEmpty() const
+{
+    return (m_Suballocations.size() == 1) && (m_FreeCount == 1);
+}
+
+void VmaBlockMetadata_Generic::CalcAllocationStatInfo(VmaStatInfo& outInfo) const
+{
+    outInfo.blockCount = 1;
+
+    const uint32_t rangeCount = (uint32_t)m_Suballocations.size();
+    outInfo.allocationCount = rangeCount - m_FreeCount;
+    outInfo.unusedRangeCount = m_FreeCount;
+
+    outInfo.unusedBytes = m_SumFreeSize;
+    outInfo.usedBytes = GetSize() - outInfo.unusedBytes;
+
+    outInfo.allocationSizeMin = UINT64_MAX;
+    outInfo.allocationSizeMax = 0;
+    outInfo.unusedRangeSizeMin = UINT64_MAX;
+    outInfo.unusedRangeSizeMax = 0;
+
+    for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
+        suballocItem != m_Suballocations.cend();
+        ++suballocItem)
+    {
+        const VmaSuballocation& suballoc = *suballocItem;
+        if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
+        {
+            outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
+            outInfo.allocationSizeMax = VMA_MAX(outInfo.allocationSizeMax, suballoc.size);
+        }
+        else
+        {
+            outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, suballoc.size);
+            outInfo.unusedRangeSizeMax = VMA_MAX(outInfo.unusedRangeSizeMax, suballoc.size);
+        }
+    }
+}
+
+void VmaBlockMetadata_Generic::AddPoolStats(VmaPoolStats& inoutStats) const
+{
+    const uint32_t rangeCount = (uint32_t)m_Suballocations.size();
+
+    inoutStats.size += GetSize();
+    inoutStats.unusedSize += m_SumFreeSize;
+    inoutStats.allocationCount += rangeCount - m_FreeCount;
+    inoutStats.unusedRangeCount += m_FreeCount;
+    inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, GetUnusedRangeSizeMax());
+}
+
+#if VMA_STATS_STRING_ENABLED
+
+void VmaBlockMetadata_Generic::PrintDetailedMap(class VmaJsonWriter& json) const
+{
+    PrintDetailedMap_Begin(json,
+        m_SumFreeSize, // unusedBytes
+        m_Suballocations.size() - (size_t)m_FreeCount, // allocationCount
+        m_FreeCount); // unusedRangeCount
+
+    size_t i = 0;
+    for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
+        suballocItem != m_Suballocations.cend();
+        ++suballocItem, ++i)
+    {
+        if(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
+        {
+            PrintDetailedMap_UnusedRange(json, suballocItem->offset, suballocItem->size);
+        }
+        else
+        {
+            PrintDetailedMap_Allocation(json, suballocItem->offset, suballocItem->hAllocation);
+        }
+    }
+
+    PrintDetailedMap_End(json);
+}
+
+#endif // #if VMA_STATS_STRING_ENABLED
+
+bool VmaBlockMetadata_Generic::CreateAllocationRequest(
+    uint32_t currentFrameIndex,
+    uint32_t frameInUseCount,
+    VkDeviceSize bufferImageGranularity,
+    VkDeviceSize allocSize,
+    VkDeviceSize allocAlignment,
+    bool upperAddress,
+    VmaSuballocationType allocType,
+    bool canMakeOtherLost,
+    uint32_t strategy,
+    VmaAllocationRequest* pAllocationRequest)
+{
+    VMA_ASSERT(allocSize > 0);
+    VMA_ASSERT(!upperAddress);
+    VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
+    VMA_ASSERT(pAllocationRequest != VMA_NULL);
+    VMA_HEAVY_ASSERT(Validate());
+
+    pAllocationRequest->type = VmaAllocationRequestType::Normal;
+
+    // There is not enough total free space in this block to fullfill the request: Early return.
+    if(canMakeOtherLost == false &&
+        m_SumFreeSize < allocSize + 2 * VMA_DEBUG_MARGIN)
+    {
+        return false;
+    }
+
+    // New algorithm, efficiently searching freeSuballocationsBySize.
+    const size_t freeSuballocCount = m_FreeSuballocationsBySize.size();
+    if(freeSuballocCount > 0)
+    {
+        if(strategy == VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT)
+        {
+            // Find first free suballocation with size not less than allocSize + 2 * VMA_DEBUG_MARGIN.
+            VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
+                m_FreeSuballocationsBySize.data(),
+                m_FreeSuballocationsBySize.data() + freeSuballocCount,
+                allocSize + 2 * VMA_DEBUG_MARGIN,
+                VmaSuballocationItemSizeLess());
+            size_t index = it - m_FreeSuballocationsBySize.data();
+            for(; index < freeSuballocCount; ++index)
+            {
+                if(CheckAllocation(
+                    currentFrameIndex,
+                    frameInUseCount,
+                    bufferImageGranularity,
+                    allocSize,
+                    allocAlignment,
+                    allocType,
+                    m_FreeSuballocationsBySize[index],
+                    false, // canMakeOtherLost
+                    &pAllocationRequest->offset,
+                    &pAllocationRequest->itemsToMakeLostCount,
+                    &pAllocationRequest->sumFreeSize,
+                    &pAllocationRequest->sumItemSize))
+                {
+                    pAllocationRequest->item = m_FreeSuballocationsBySize[index];
+                    return true;
+                }
+            }
+        }
+        else if(strategy == VMA_ALLOCATION_INTERNAL_STRATEGY_MIN_OFFSET)
+        {
+            for(VmaSuballocationList::iterator it = m_Suballocations.begin();
+                it != m_Suballocations.end();
+                ++it)
+            {
+                if(it->type == VMA_SUBALLOCATION_TYPE_FREE && CheckAllocation(
+                    currentFrameIndex,
+                    frameInUseCount,
+                    bufferImageGranularity,
+                    allocSize,
+                    allocAlignment,
+                    allocType,
+                    it,
+                    false, // canMakeOtherLost
+                    &pAllocationRequest->offset,
+                    &pAllocationRequest->itemsToMakeLostCount,
+                    &pAllocationRequest->sumFreeSize,
+                    &pAllocationRequest->sumItemSize))
+                {
+                    pAllocationRequest->item = it;
+                    return true;
+                }
+            }
+        }
+        else // WORST_FIT, FIRST_FIT
+        {
+            // Search staring from biggest suballocations.
+            for(size_t index = freeSuballocCount; index--; )
+            {
+                if(CheckAllocation(
+                    currentFrameIndex,
+                    frameInUseCount,
+                    bufferImageGranularity,
+                    allocSize,
+                    allocAlignment,
+                    allocType,
+                    m_FreeSuballocationsBySize[index],
+                    false, // canMakeOtherLost
+                    &pAllocationRequest->offset,
+                    &pAllocationRequest->itemsToMakeLostCount,
+                    &pAllocationRequest->sumFreeSize,
+                    &pAllocationRequest->sumItemSize))
+                {
+                    pAllocationRequest->item = m_FreeSuballocationsBySize[index];
+                    return true;
+                }
+            }
+        }
+    }
+
+    if(canMakeOtherLost)
+    {
+        // Brute-force algorithm. TODO: Come up with something better.
+
+        bool found = false;
+        VmaAllocationRequest tmpAllocRequest = {};
+        tmpAllocRequest.type = VmaAllocationRequestType::Normal;
+        for(VmaSuballocationList::iterator suballocIt = m_Suballocations.begin();
+            suballocIt != m_Suballocations.end();
+            ++suballocIt)
+        {
+            if(suballocIt->type == VMA_SUBALLOCATION_TYPE_FREE ||
+                suballocIt->hAllocation->CanBecomeLost())
+            {
+                if(CheckAllocation(
+                    currentFrameIndex,
+                    frameInUseCount,
+                    bufferImageGranularity,
+                    allocSize,
+                    allocAlignment,
+                    allocType,
+                    suballocIt,
+                    canMakeOtherLost,
+                    &tmpAllocRequest.offset,
+                    &tmpAllocRequest.itemsToMakeLostCount,
+                    &tmpAllocRequest.sumFreeSize,
+                    &tmpAllocRequest.sumItemSize))
+                {
+                    if(strategy == VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT)
+                    {
+                        *pAllocationRequest = tmpAllocRequest;
+                        pAllocationRequest->item = suballocIt;
+                        break;
+                    }
+                    if(!found || tmpAllocRequest.CalcCost() < pAllocationRequest->CalcCost())
+                    {
+                        *pAllocationRequest = tmpAllocRequest;
+                        pAllocationRequest->item = suballocIt;
+                        found = true;
+                    }
+                }
+            }
+        }
+
+        return found;
+    }
+
+    return false;
+}
+
+bool VmaBlockMetadata_Generic::MakeRequestedAllocationsLost(
+    uint32_t currentFrameIndex,
+    uint32_t frameInUseCount,
+    VmaAllocationRequest* pAllocationRequest)
+{
+    VMA_ASSERT(pAllocationRequest && pAllocationRequest->type == VmaAllocationRequestType::Normal);
+
+    while(pAllocationRequest->itemsToMakeLostCount > 0)
+    {
+        if(pAllocationRequest->item->type == VMA_SUBALLOCATION_TYPE_FREE)
+        {
+            ++pAllocationRequest->item;
+        }
+        VMA_ASSERT(pAllocationRequest->item != m_Suballocations.end());
+        VMA_ASSERT(pAllocationRequest->item->hAllocation != VK_NULL_HANDLE);
+        VMA_ASSERT(pAllocationRequest->item->hAllocation->CanBecomeLost());
+        if(pAllocationRequest->item->hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
+        {
+            pAllocationRequest->item = FreeSuballocation(pAllocationRequest->item);
+            --pAllocationRequest->itemsToMakeLostCount;
+        }
+        else
+        {
+            return false;
+        }
+    }
+
+    VMA_HEAVY_ASSERT(Validate());
+    VMA_ASSERT(pAllocationRequest->item != m_Suballocations.end());
+    VMA_ASSERT(pAllocationRequest->item->type == VMA_SUBALLOCATION_TYPE_FREE);
+
+    return true;
+}
+
+uint32_t VmaBlockMetadata_Generic::MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
+{
+    uint32_t lostAllocationCount = 0;
+    for(VmaSuballocationList::iterator it = m_Suballocations.begin();
+        it != m_Suballocations.end();
+        ++it)
+    {
+        if(it->type != VMA_SUBALLOCATION_TYPE_FREE &&
+            it->hAllocation->CanBecomeLost() &&
+            it->hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
+        {
+            it = FreeSuballocation(it);
+            ++lostAllocationCount;
+        }
+    }
+    return lostAllocationCount;
+}
+
+VkResult VmaBlockMetadata_Generic::CheckCorruption(const void* pBlockData)
+{
+    for(VmaSuballocationList::iterator it = m_Suballocations.begin();
+        it != m_Suballocations.end();
+        ++it)
+    {
+        if(it->type != VMA_SUBALLOCATION_TYPE_FREE)
+        {
+            if(!VmaValidateMagicValue(pBlockData, it->offset - VMA_DEBUG_MARGIN))
+            {
+                VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE VALIDATED ALLOCATION!");
+                return VK_ERROR_VALIDATION_FAILED_EXT;
+            }
+            if(!VmaValidateMagicValue(pBlockData, it->offset + it->size))
+            {
+                VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
+                return VK_ERROR_VALIDATION_FAILED_EXT;
+            }
+        }
+    }
+
+    return VK_SUCCESS;
+}
+
+void VmaBlockMetadata_Generic::Alloc(
+    const VmaAllocationRequest& request,
+    VmaSuballocationType type,
+    VkDeviceSize allocSize,
+    VmaAllocation hAllocation)
+{
+    VMA_ASSERT(request.type == VmaAllocationRequestType::Normal);
+    VMA_ASSERT(request.item != m_Suballocations.end());
+    VmaSuballocation& suballoc = *request.item;
+    // Given suballocation is a free block.
+    VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
+    // Given offset is inside this suballocation.
+    VMA_ASSERT(request.offset >= suballoc.offset);
+    const VkDeviceSize paddingBegin = request.offset - suballoc.offset;
+    VMA_ASSERT(suballoc.size >= paddingBegin + allocSize);
+    const VkDeviceSize paddingEnd = suballoc.size - paddingBegin - allocSize;
+
+    // Unregister this free suballocation from m_FreeSuballocationsBySize and update
+    // it to become used.
+    UnregisterFreeSuballocation(request.item);
+
+    suballoc.offset = request.offset;
+    suballoc.size = allocSize;
+    suballoc.type = type;
+    suballoc.hAllocation = hAllocation;
+
+    // If there are any free bytes remaining at the end, insert new free suballocation after current one.
+    if(paddingEnd)
+    {
+        VmaSuballocation paddingSuballoc = {};
+        paddingSuballoc.offset = request.offset + allocSize;
+        paddingSuballoc.size = paddingEnd;
+        paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
+        VmaSuballocationList::iterator next = request.item;
+        ++next;
+        const VmaSuballocationList::iterator paddingEndItem =
+            m_Suballocations.insert(next, paddingSuballoc);
+        RegisterFreeSuballocation(paddingEndItem);
+    }
+
+    // If there are any free bytes remaining at the beginning, insert new free suballocation before current one.
+    if(paddingBegin)
+    {
+        VmaSuballocation paddingSuballoc = {};
+        paddingSuballoc.offset = request.offset - paddingBegin;
+        paddingSuballoc.size = paddingBegin;
+        paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
+        const VmaSuballocationList::iterator paddingBeginItem =
+            m_Suballocations.insert(request.item, paddingSuballoc);
+        RegisterFreeSuballocation(paddingBeginItem);
+    }
+
+    // Update totals.
+    m_FreeCount = m_FreeCount - 1;
+    if(paddingBegin > 0)
+    {
+        ++m_FreeCount;
+    }
+    if(paddingEnd > 0)
+    {
+        ++m_FreeCount;
+    }
+    m_SumFreeSize -= allocSize;
+}
+
+void VmaBlockMetadata_Generic::Free(const VmaAllocation allocation)
+{
+    for(VmaSuballocationList::iterator suballocItem = m_Suballocations.begin();
+        suballocItem != m_Suballocations.end();
+        ++suballocItem)
+    {
+        VmaSuballocation& suballoc = *suballocItem;
+        if(suballoc.hAllocation == allocation)
+        {
+            FreeSuballocation(suballocItem);
+            VMA_HEAVY_ASSERT(Validate());
+            return;
+        }
+    }
+    VMA_ASSERT(0 && "Not found!");
+}
+
+void VmaBlockMetadata_Generic::FreeAtOffset(VkDeviceSize offset)
+{
+    for(VmaSuballocationList::iterator suballocItem = m_Suballocations.begin();
+        suballocItem != m_Suballocations.end();
+        ++suballocItem)
+    {
+        VmaSuballocation& suballoc = *suballocItem;
+        if(suballoc.offset == offset)
+        {
+            FreeSuballocation(suballocItem);
+            return;
+        }
+    }
+    VMA_ASSERT(0 && "Not found!");
+}
+
+bool VmaBlockMetadata_Generic::ValidateFreeSuballocationList() const
+{
+    VkDeviceSize lastSize = 0;
+    for(size_t i = 0, count = m_FreeSuballocationsBySize.size(); i < count; ++i)
+    {
+        const VmaSuballocationList::iterator it = m_FreeSuballocationsBySize[i];
+
+        VMA_VALIDATE(it->type == VMA_SUBALLOCATION_TYPE_FREE);
+        VMA_VALIDATE(it->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER);
+        VMA_VALIDATE(it->size >= lastSize);
+        lastSize = it->size;
+    }
+    return true;
+}
+
+bool VmaBlockMetadata_Generic::CheckAllocation(
+    uint32_t currentFrameIndex,
+    uint32_t frameInUseCount,
+    VkDeviceSize bufferImageGranularity,
+    VkDeviceSize allocSize,
+    VkDeviceSize allocAlignment,
+    VmaSuballocationType allocType,
+    VmaSuballocationList::const_iterator suballocItem,
+    bool canMakeOtherLost,
+    VkDeviceSize* pOffset,
+    size_t* itemsToMakeLostCount,
+    VkDeviceSize* pSumFreeSize,
+    VkDeviceSize* pSumItemSize) const
+{
+    VMA_ASSERT(allocSize > 0);
+    VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
+    VMA_ASSERT(suballocItem != m_Suballocations.cend());
+    VMA_ASSERT(pOffset != VMA_NULL);
+
+    *itemsToMakeLostCount = 0;
+    *pSumFreeSize = 0;
+    *pSumItemSize = 0;
+
+    if(canMakeOtherLost)
+    {
+        if(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
+        {
+            *pSumFreeSize = suballocItem->size;
+        }
+        else
+        {
+            if(suballocItem->hAllocation->CanBecomeLost() &&
+                suballocItem->hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
+            {
+                ++*itemsToMakeLostCount;
+                *pSumItemSize = suballocItem->size;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        // Remaining size is too small for this request: Early return.
+        if(GetSize() - suballocItem->offset < allocSize)
+        {
+            return false;
+        }
+
+        // Start from offset equal to beginning of this suballocation.
+        *pOffset = suballocItem->offset;
+
+        // Apply VMA_DEBUG_MARGIN at the beginning.
+        if(VMA_DEBUG_MARGIN > 0)
+        {
+            *pOffset += VMA_DEBUG_MARGIN;
+        }
+
+        // Apply alignment.
+        *pOffset = VmaAlignUp(*pOffset, allocAlignment);
+
+        // Check previous suballocations for BufferImageGranularity conflicts.
+        // Make bigger alignment if necessary.
+        if(bufferImageGranularity > 1)
+        {
+            bool bufferImageGranularityConflict = false;
+            VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;
+            while(prevSuballocItem != m_Suballocations.cbegin())
+            {
+                --prevSuballocItem;
+                const VmaSuballocation& prevSuballoc = *prevSuballocItem;
+                if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, *pOffset, bufferImageGranularity))
+                {
+                    if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
+                    {
+                        bufferImageGranularityConflict = true;
+                        break;
+                    }
+                }
+                else
+                    // Already on previous page.
+                    break;
+            }
+            if(bufferImageGranularityConflict)
+            {
+                *pOffset = VmaAlignUp(*pOffset, bufferImageGranularity);
+            }
+        }
+
+        // Now that we have final *pOffset, check if we are past suballocItem.
+        // If yes, return false - this function should be called for another suballocItem as starting point.
+        if(*pOffset >= suballocItem->offset + suballocItem->size)
+        {
+            return false;
+        }
+
+        // Calculate padding at the beginning based on current offset.
+        const VkDeviceSize paddingBegin = *pOffset - suballocItem->offset;
+
+        // Calculate required margin at the end.
+        const VkDeviceSize requiredEndMargin = VMA_DEBUG_MARGIN;
+
+        const VkDeviceSize totalSize = paddingBegin + allocSize + requiredEndMargin;
+        // Another early return check.
+        if(suballocItem->offset + totalSize > GetSize())
+        {
+            return false;
+        }
+
+        // Advance lastSuballocItem until desired size is reached.
+        // Update itemsToMakeLostCount.
+        VmaSuballocationList::const_iterator lastSuballocItem = suballocItem;
+        if(totalSize > suballocItem->size)
+        {
+            VkDeviceSize remainingSize = totalSize - suballocItem->size;
+            while(remainingSize > 0)
+            {
+                ++lastSuballocItem;
+                if(lastSuballocItem == m_Suballocations.cend())
+                {
+                    return false;
+                }
+                if(lastSuballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
+                {
+                    *pSumFreeSize += lastSuballocItem->size;
+                }
+                else
+                {
+                    VMA_ASSERT(lastSuballocItem->hAllocation != VK_NULL_HANDLE);
+                    if(lastSuballocItem->hAllocation->CanBecomeLost() &&
+                        lastSuballocItem->hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
+                    {
+                        ++*itemsToMakeLostCount;
+                        *pSumItemSize += lastSuballocItem->size;
+                    }
+                    else
+                    {
+                        return false;
+                    }
+                }
+                remainingSize = (lastSuballocItem->size < remainingSize) ?
+                    remainingSize - lastSuballocItem->size : 0;
+            }
+        }
+
+        // Check next suballocations for BufferImageGranularity conflicts.
+        // If conflict exists, we must mark more allocations lost or fail.
+        if(bufferImageGranularity > 1)
+        {
+            VmaSuballocationList::const_iterator nextSuballocItem = lastSuballocItem;
+            ++nextSuballocItem;
+            while(nextSuballocItem != m_Suballocations.cend())
+            {
+                const VmaSuballocation& nextSuballoc = *nextSuballocItem;
+                if(VmaBlocksOnSamePage(*pOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
+                {
+                    if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
+                    {
+                        VMA_ASSERT(nextSuballoc.hAllocation != VK_NULL_HANDLE);
+                        if(nextSuballoc.hAllocation->CanBecomeLost() &&
+                            nextSuballoc.hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
+                        {
+                            ++*itemsToMakeLostCount;
+                        }
+                        else
+                        {
+                            return false;
+                        }
+                    }
+                }
+                else
+                {
+                    // Already on next page.
+                    break;
+                }
+                ++nextSuballocItem;
+            }
+        }
+    }
+    else
+    {
+        const VmaSuballocation& suballoc = *suballocItem;
+        VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
+
+        *pSumFreeSize = suballoc.size;
+
+        // Size of this suballocation is too small for this request: Early return.
+        if(suballoc.size < allocSize)
+        {
+            return false;
+        }
+
+        // Start from offset equal to beginning of this suballocation.
+        *pOffset = suballoc.offset;
+
+        // Apply VMA_DEBUG_MARGIN at the beginning.
+        if(VMA_DEBUG_MARGIN > 0)
+        {
+            *pOffset += VMA_DEBUG_MARGIN;
+        }
+
+        // Apply alignment.
+        *pOffset = VmaAlignUp(*pOffset, allocAlignment);
+
+        // Check previous suballocations for BufferImageGranularity conflicts.
+        // Make bigger alignment if necessary.
+        if(bufferImageGranularity > 1)
+        {
+            bool bufferImageGranularityConflict = false;
+            VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;
+            while(prevSuballocItem != m_Suballocations.cbegin())
+            {
+                --prevSuballocItem;
+                const VmaSuballocation& prevSuballoc = *prevSuballocItem;
+                if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, *pOffset, bufferImageGranularity))
+                {
+                    if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
+                    {
+                        bufferImageGranularityConflict = true;
+                        break;
+                    }
+                }
+                else
+                    // Already on previous page.
+                    break;
+            }
+            if(bufferImageGranularityConflict)
+            {
+                *pOffset = VmaAlignUp(*pOffset, bufferImageGranularity);
+            }
+        }
+
+        // Calculate padding at the beginning based on current offset.
+        const VkDeviceSize paddingBegin = *pOffset - suballoc.offset;
+
+        // Calculate required margin at the end.
+        const VkDeviceSize requiredEndMargin = VMA_DEBUG_MARGIN;
+
+        // Fail if requested size plus margin before and after is bigger than size of this suballocation.
+        if(paddingBegin + allocSize + requiredEndMargin > suballoc.size)
+        {
+            return false;
+        }
+
+        // Check next suballocations for BufferImageGranularity conflicts.
+        // If conflict exists, allocation cannot be made here.
+        if(bufferImageGranularity > 1)
+        {
+            VmaSuballocationList::const_iterator nextSuballocItem = suballocItem;
+            ++nextSuballocItem;
+            while(nextSuballocItem != m_Suballocations.cend())
+            {
+                const VmaSuballocation& nextSuballoc = *nextSuballocItem;
+                if(VmaBlocksOnSamePage(*pOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
+                {
+                    if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
+                    {
+                        return false;
+                    }
+                }
+                else
+                {
+                    // Already on next page.
+                    break;
+                }
+                ++nextSuballocItem;
+            }
+        }
+    }
+
+    // All tests passed: Success. pOffset is already filled.
+    return true;
+}
+
+void VmaBlockMetadata_Generic::MergeFreeWithNext(VmaSuballocationList::iterator item)
+{
+    VMA_ASSERT(item != m_Suballocations.end());
+    VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
+
+    VmaSuballocationList::iterator nextItem = item;
+    ++nextItem;
+    VMA_ASSERT(nextItem != m_Suballocations.end());
+    VMA_ASSERT(nextItem->type == VMA_SUBALLOCATION_TYPE_FREE);
+
+    item->size += nextItem->size;
+    --m_FreeCount;
+    m_Suballocations.erase(nextItem);
+}
+
+VmaSuballocationList::iterator VmaBlockMetadata_Generic::FreeSuballocation(VmaSuballocationList::iterator suballocItem)
+{
+    // Change this suballocation to be marked as free.
+    VmaSuballocation& suballoc = *suballocItem;
+    suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
+    suballoc.hAllocation = VK_NULL_HANDLE;
+
+    // Update totals.
+    ++m_FreeCount;
+    m_SumFreeSize += suballoc.size;
+
+    // Merge with previous and/or next suballocation if it's also free.
+    bool mergeWithNext = false;
+    bool mergeWithPrev = false;
+
+    VmaSuballocationList::iterator nextItem = suballocItem;
+    ++nextItem;
+    if((nextItem != m_Suballocations.end()) && (nextItem->type == VMA_SUBALLOCATION_TYPE_FREE))
+    {
+        mergeWithNext = true;
+    }
+
+    VmaSuballocationList::iterator prevItem = suballocItem;
+    if(suballocItem != m_Suballocations.begin())
+    {
+        --prevItem;
+        if(prevItem->type == VMA_SUBALLOCATION_TYPE_FREE)
+        {
+            mergeWithPrev = true;
+        }
+    }
+
+    if(mergeWithNext)
+    {
+        UnregisterFreeSuballocation(nextItem);
+        MergeFreeWithNext(suballocItem);
+    }
+
+    if(mergeWithPrev)
+    {
+        UnregisterFreeSuballocation(prevItem);
+        MergeFreeWithNext(prevItem);
+        RegisterFreeSuballocation(prevItem);
+        return prevItem;
+    }
+    else
+    {
+        RegisterFreeSuballocation(suballocItem);
+        return suballocItem;
+    }
+}
+
+void VmaBlockMetadata_Generic::RegisterFreeSuballocation(VmaSuballocationList::iterator item)
+{
+    VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
+    VMA_ASSERT(item->size > 0);
+
+    // You may want to enable this validation at the beginning or at the end of
+    // this function, depending on what do you want to check.
+    VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
+
+    if(item->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
+    {
+        if(m_FreeSuballocationsBySize.empty())
+        {
+            m_FreeSuballocationsBySize.push_back(item);
+        }
+        else
+        {
+            VmaVectorInsertSorted<VmaSuballocationItemSizeLess>(m_FreeSuballocationsBySize, item);
+        }
+    }
+
+    //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
+}
+
+
+void VmaBlockMetadata_Generic::UnregisterFreeSuballocation(VmaSuballocationList::iterator item)
+{
+    VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
+    VMA_ASSERT(item->size > 0);
+
+    // You may want to enable this validation at the beginning or at the end of
+    // this function, depending on what do you want to check.
+    VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
+
+    if(item->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
+    {
+        VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
+            m_FreeSuballocationsBySize.data(),
+            m_FreeSuballocationsBySize.data() + m_FreeSuballocationsBySize.size(),
+            item,
+            VmaSuballocationItemSizeLess());
+        for(size_t index = it - m_FreeSuballocationsBySize.data();
+            index < m_FreeSuballocationsBySize.size();
+            ++index)
+        {
+            if(m_FreeSuballocationsBySize[index] == item)
+            {
+                VmaVectorRemove(m_FreeSuballocationsBySize, index);
+                return;
+            }
+            VMA_ASSERT((m_FreeSuballocationsBySize[index]->size == item->size) && "Not found.");
+        }
+        VMA_ASSERT(0 && "Not found.");
+    }
+
+    //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
+}
+
+bool VmaBlockMetadata_Generic::IsBufferImageGranularityConflictPossible(
+    VkDeviceSize bufferImageGranularity,
+    VmaSuballocationType& inOutPrevSuballocType) const
+{
+    if(bufferImageGranularity == 1 || IsEmpty())
+    {
+        return false;
+    }
+
+    VkDeviceSize minAlignment = VK_WHOLE_SIZE;
+    bool typeConflictFound = false;
+    for(VmaSuballocationList::const_iterator it = m_Suballocations.cbegin();
+        it != m_Suballocations.cend();
+        ++it)
+    {
+        const VmaSuballocationType suballocType = it->type;
+        if(suballocType != VMA_SUBALLOCATION_TYPE_FREE)
+        {
+            minAlignment = VMA_MIN(minAlignment, it->hAllocation->GetAlignment());
+            if(VmaIsBufferImageGranularityConflict(inOutPrevSuballocType, suballocType))
+            {
+                typeConflictFound = true;
+            }
+            inOutPrevSuballocType = suballocType;
+        }
+    }
+
+    return typeConflictFound || minAlignment >= bufferImageGranularity;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// class VmaBlockMetadata_Linear
+
+VmaBlockMetadata_Linear::VmaBlockMetadata_Linear(VmaAllocator hAllocator) :
+    VmaBlockMetadata(hAllocator),
+    m_SumFreeSize(0),
+    m_Suballocations0(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),
+    m_Suballocations1(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),
+    m_1stVectorIndex(0),
+    m_2ndVectorMode(SECOND_VECTOR_EMPTY),
+    m_1stNullItemsBeginCount(0),
+    m_1stNullItemsMiddleCount(0),
+    m_2ndNullItemsCount(0)
+{
+}
+
+VmaBlockMetadata_Linear::~VmaBlockMetadata_Linear()
+{
+}
+
+void VmaBlockMetadata_Linear::Init(VkDeviceSize size)
+{
+    VmaBlockMetadata::Init(size);
+    m_SumFreeSize = size;
+}
+
+bool VmaBlockMetadata_Linear::Validate() const
+{
+    const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+    const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+
+    VMA_VALIDATE(suballocations2nd.empty() == (m_2ndVectorMode == SECOND_VECTOR_EMPTY));
+    VMA_VALIDATE(!suballocations1st.empty() ||
+        suballocations2nd.empty() ||
+        m_2ndVectorMode != SECOND_VECTOR_RING_BUFFER);
+
+    if(!suballocations1st.empty())
+    {
+        // Null item at the beginning should be accounted into m_1stNullItemsBeginCount.
+        VMA_VALIDATE(suballocations1st[m_1stNullItemsBeginCount].hAllocation != VK_NULL_HANDLE);
+        // Null item at the end should be just pop_back().
+        VMA_VALIDATE(suballocations1st.back().hAllocation != VK_NULL_HANDLE);
+    }
+    if(!suballocations2nd.empty())
+    {
+        // Null item at the end should be just pop_back().
+        VMA_VALIDATE(suballocations2nd.back().hAllocation != VK_NULL_HANDLE);
+    }
+
+    VMA_VALIDATE(m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount <= suballocations1st.size());
+    VMA_VALIDATE(m_2ndNullItemsCount <= suballocations2nd.size());
+
+    VkDeviceSize sumUsedSize = 0;
+    const size_t suballoc1stCount = suballocations1st.size();
+    VkDeviceSize offset = VMA_DEBUG_MARGIN;
+
+    if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
+    {
+        const size_t suballoc2ndCount = suballocations2nd.size();
+        size_t nullItem2ndCount = 0;
+        for(size_t i = 0; i < suballoc2ndCount; ++i)
+        {
+            const VmaSuballocation& suballoc = suballocations2nd[i];
+            const bool currFree = (suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
+
+            VMA_VALIDATE(currFree == (suballoc.hAllocation == VK_NULL_HANDLE));
+            VMA_VALIDATE(suballoc.offset >= offset);
+
+            if(!currFree)
+            {
+                VMA_VALIDATE(suballoc.hAllocation->GetOffset() == suballoc.offset);
+                VMA_VALIDATE(suballoc.hAllocation->GetSize() == suballoc.size);
+                sumUsedSize += suballoc.size;
+            }
+            else
+            {
+                ++nullItem2ndCount;
+            }
+
+            offset = suballoc.offset + suballoc.size + VMA_DEBUG_MARGIN;
+        }
+
+        VMA_VALIDATE(nullItem2ndCount == m_2ndNullItemsCount);
+    }
+
+    for(size_t i = 0; i < m_1stNullItemsBeginCount; ++i)
+    {
+        const VmaSuballocation& suballoc = suballocations1st[i];
+        VMA_VALIDATE(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE &&
+            suballoc.hAllocation == VK_NULL_HANDLE);
+    }
+
+    size_t nullItem1stCount = m_1stNullItemsBeginCount;
+
+    for(size_t i = m_1stNullItemsBeginCount; i < suballoc1stCount; ++i)
+    {
+        const VmaSuballocation& suballoc = suballocations1st[i];
+        const bool currFree = (suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
+
+        VMA_VALIDATE(currFree == (suballoc.hAllocation == VK_NULL_HANDLE));
+        VMA_VALIDATE(suballoc.offset >= offset);
+        VMA_VALIDATE(i >= m_1stNullItemsBeginCount || currFree);
+
+        if(!currFree)
+        {
+            VMA_VALIDATE(suballoc.hAllocation->GetOffset() == suballoc.offset);
+            VMA_VALIDATE(suballoc.hAllocation->GetSize() == suballoc.size);
+            sumUsedSize += suballoc.size;
+        }
+        else
+        {
+            ++nullItem1stCount;
+        }
+
+        offset = suballoc.offset + suballoc.size + VMA_DEBUG_MARGIN;
+    }
+    VMA_VALIDATE(nullItem1stCount == m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount);
+
+    if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
+    {
+        const size_t suballoc2ndCount = suballocations2nd.size();
+        size_t nullItem2ndCount = 0;
+        for(size_t i = suballoc2ndCount; i--; )
+        {
+            const VmaSuballocation& suballoc = suballocations2nd[i];
+            const bool currFree = (suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
+
+            VMA_VALIDATE(currFree == (suballoc.hAllocation == VK_NULL_HANDLE));
+            VMA_VALIDATE(suballoc.offset >= offset);
+
+            if(!currFree)
+            {
+                VMA_VALIDATE(suballoc.hAllocation->GetOffset() == suballoc.offset);
+                VMA_VALIDATE(suballoc.hAllocation->GetSize() == suballoc.size);
+                sumUsedSize += suballoc.size;
+            }
+            else
+            {
+                ++nullItem2ndCount;
+            }
+
+            offset = suballoc.offset + suballoc.size + VMA_DEBUG_MARGIN;
+        }
+
+        VMA_VALIDATE(nullItem2ndCount == m_2ndNullItemsCount);
+    }
+
+    VMA_VALIDATE(offset <= GetSize());
+    VMA_VALIDATE(m_SumFreeSize == GetSize() - sumUsedSize);
+
+    return true;
+}
+
+size_t VmaBlockMetadata_Linear::GetAllocationCount() const
+{
+    return AccessSuballocations1st().size() - (m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount) +
+        AccessSuballocations2nd().size() - m_2ndNullItemsCount;
+}
+
+VkDeviceSize VmaBlockMetadata_Linear::GetUnusedRangeSizeMax() const
+{
+    const VkDeviceSize size = GetSize();
+
+    /*
+    We don't consider gaps inside allocation vectors with freed allocations because
+    they are not suitable for reuse in linear allocator. We consider only space that
+    is available for new allocations.
+    */
+    if(IsEmpty())
+    {
+        return size;
+    }
+
+    const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+
+    switch(m_2ndVectorMode)
+    {
+    case SECOND_VECTOR_EMPTY:
+        /*
+        Available space is after end of 1st, as well as before beginning of 1st (which
+        whould make it a ring buffer).
+        */
+        {
+            const size_t suballocations1stCount = suballocations1st.size();
+            VMA_ASSERT(suballocations1stCount > m_1stNullItemsBeginCount);
+            const VmaSuballocation& firstSuballoc = suballocations1st[m_1stNullItemsBeginCount];
+            const VmaSuballocation& lastSuballoc  = suballocations1st[suballocations1stCount - 1];
+            return VMA_MAX(
+                firstSuballoc.offset,
+                size - (lastSuballoc.offset + lastSuballoc.size));
+        }
+        break;
+
+    case SECOND_VECTOR_RING_BUFFER:
+        /*
+        Available space is only between end of 2nd and beginning of 1st.
+        */
+        {
+            const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+            const VmaSuballocation& lastSuballoc2nd = suballocations2nd.back();
+            const VmaSuballocation& firstSuballoc1st = suballocations1st[m_1stNullItemsBeginCount];
+            return firstSuballoc1st.offset - (lastSuballoc2nd.offset + lastSuballoc2nd.size);
+        }
+        break;
+
+    case SECOND_VECTOR_DOUBLE_STACK:
+        /*
+        Available space is only between end of 1st and top of 2nd.
+        */
+        {
+            const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+            const VmaSuballocation& topSuballoc2nd = suballocations2nd.back();
+            const VmaSuballocation& lastSuballoc1st = suballocations1st.back();
+            return topSuballoc2nd.offset - (lastSuballoc1st.offset + lastSuballoc1st.size);
+        }
+        break;
+
+    default:
+        VMA_ASSERT(0);
+        return 0;
+    }
+}
+
+void VmaBlockMetadata_Linear::CalcAllocationStatInfo(VmaStatInfo& outInfo) const
+{
+    const VkDeviceSize size = GetSize();
+    const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+    const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+    const size_t suballoc1stCount = suballocations1st.size();
+    const size_t suballoc2ndCount = suballocations2nd.size();
+
+    outInfo.blockCount = 1;
+    outInfo.allocationCount = (uint32_t)GetAllocationCount();
+    outInfo.unusedRangeCount = 0;
+    outInfo.usedBytes = 0;
+    outInfo.allocationSizeMin = UINT64_MAX;
+    outInfo.allocationSizeMax = 0;
+    outInfo.unusedRangeSizeMin = UINT64_MAX;
+    outInfo.unusedRangeSizeMax = 0;
+
+    VkDeviceSize lastOffset = 0;
+
+    if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
+    {
+        const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
+        size_t nextAlloc2ndIndex = 0;
+        while(lastOffset < freeSpace2ndTo1stEnd)
+        {
+            // Find next non-null allocation or move nextAllocIndex to the end.
+            while(nextAlloc2ndIndex < suballoc2ndCount &&
+                suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
+            {
+                ++nextAlloc2ndIndex;
+            }
+
+            // Found non-null allocation.
+            if(nextAlloc2ndIndex < suballoc2ndCount)
+            {
+                const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
+
+                // 1. Process free space before this allocation.
+                if(lastOffset < suballoc.offset)
+                {
+                    // There is free space from lastOffset to suballoc.offset.
+                    const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
+                    ++outInfo.unusedRangeCount;
+                    outInfo.unusedBytes += unusedRangeSize;
+                    outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
+                    outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
+                }
+
+                // 2. Process this allocation.
+                // There is allocation with suballoc.offset, suballoc.size.
+                outInfo.usedBytes += suballoc.size;
+                outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
+                outInfo.allocationSizeMax = VMA_MIN(outInfo.allocationSizeMax, suballoc.size);
+
+                // 3. Prepare for next iteration.
+                lastOffset = suballoc.offset + suballoc.size;
+                ++nextAlloc2ndIndex;
+            }
+            // We are at the end.
+            else
+            {
+                // There is free space from lastOffset to freeSpace2ndTo1stEnd.
+                if(lastOffset < freeSpace2ndTo1stEnd)
+                {
+                    const VkDeviceSize unusedRangeSize = freeSpace2ndTo1stEnd - lastOffset;
+                    ++outInfo.unusedRangeCount;
+                    outInfo.unusedBytes += unusedRangeSize;
+                    outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
+                    outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
+               }
+
+                // End of loop.
+                lastOffset = freeSpace2ndTo1stEnd;
+            }
+        }
+    }
+
+    size_t nextAlloc1stIndex = m_1stNullItemsBeginCount;
+    const VkDeviceSize freeSpace1stTo2ndEnd =
+        m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ? suballocations2nd.back().offset : size;
+    while(lastOffset < freeSpace1stTo2ndEnd)
+    {
+        // Find next non-null allocation or move nextAllocIndex to the end.
+        while(nextAlloc1stIndex < suballoc1stCount &&
+            suballocations1st[nextAlloc1stIndex].hAllocation == VK_NULL_HANDLE)
+        {
+            ++nextAlloc1stIndex;
+        }
+
+        // Found non-null allocation.
+        if(nextAlloc1stIndex < suballoc1stCount)
+        {
+            const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
+
+            // 1. Process free space before this allocation.
+            if(lastOffset < suballoc.offset)
+            {
+                // There is free space from lastOffset to suballoc.offset.
+                const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
+                ++outInfo.unusedRangeCount;
+                outInfo.unusedBytes += unusedRangeSize;
+                outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
+                outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
+            }
+
+            // 2. Process this allocation.
+            // There is allocation with suballoc.offset, suballoc.size.
+            outInfo.usedBytes += suballoc.size;
+            outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
+            outInfo.allocationSizeMax = VMA_MIN(outInfo.allocationSizeMax, suballoc.size);
+
+            // 3. Prepare for next iteration.
+            lastOffset = suballoc.offset + suballoc.size;
+            ++nextAlloc1stIndex;
+        }
+        // We are at the end.
+        else
+        {
+            // There is free space from lastOffset to freeSpace1stTo2ndEnd.
+            if(lastOffset < freeSpace1stTo2ndEnd)
+            {
+                const VkDeviceSize unusedRangeSize = freeSpace1stTo2ndEnd - lastOffset;
+                ++outInfo.unusedRangeCount;
+                outInfo.unusedBytes += unusedRangeSize;
+                outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
+                outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
+           }
+
+            // End of loop.
+            lastOffset = freeSpace1stTo2ndEnd;
+        }
+    }
+
+    if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
+    {
+        size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
+        while(lastOffset < size)
+        {
+            // Find next non-null allocation or move nextAllocIndex to the end.
+            while(nextAlloc2ndIndex != SIZE_MAX &&
+                suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
+            {
+                --nextAlloc2ndIndex;
+            }
+
+            // Found non-null allocation.
+            if(nextAlloc2ndIndex != SIZE_MAX)
+            {
+                const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
+
+                // 1. Process free space before this allocation.
+                if(lastOffset < suballoc.offset)
+                {
+                    // There is free space from lastOffset to suballoc.offset.
+                    const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
+                    ++outInfo.unusedRangeCount;
+                    outInfo.unusedBytes += unusedRangeSize;
+                    outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
+                    outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
+                }
+
+                // 2. Process this allocation.
+                // There is allocation with suballoc.offset, suballoc.size.
+                outInfo.usedBytes += suballoc.size;
+                outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
+                outInfo.allocationSizeMax = VMA_MIN(outInfo.allocationSizeMax, suballoc.size);
+
+                // 3. Prepare for next iteration.
+                lastOffset = suballoc.offset + suballoc.size;
+                --nextAlloc2ndIndex;
+            }
+            // We are at the end.
+            else
+            {
+                // There is free space from lastOffset to size.
+                if(lastOffset < size)
+                {
+                    const VkDeviceSize unusedRangeSize = size - lastOffset;
+                    ++outInfo.unusedRangeCount;
+                    outInfo.unusedBytes += unusedRangeSize;
+                    outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
+                    outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
+               }
+
+                // End of loop.
+                lastOffset = size;
+            }
+        }
+    }
+
+    outInfo.unusedBytes = size - outInfo.usedBytes;
+}
+
+void VmaBlockMetadata_Linear::AddPoolStats(VmaPoolStats& inoutStats) const
+{
+    const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+    const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+    const VkDeviceSize size = GetSize();
+    const size_t suballoc1stCount = suballocations1st.size();
+    const size_t suballoc2ndCount = suballocations2nd.size();
+
+    inoutStats.size += size;
+
+    VkDeviceSize lastOffset = 0;
+
+    if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
+    {
+        const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
+        size_t nextAlloc2ndIndex = m_1stNullItemsBeginCount;
+        while(lastOffset < freeSpace2ndTo1stEnd)
+        {
+            // Find next non-null allocation or move nextAlloc2ndIndex to the end.
+            while(nextAlloc2ndIndex < suballoc2ndCount &&
+                suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
+            {
+                ++nextAlloc2ndIndex;
+            }
+
+            // Found non-null allocation.
+            if(nextAlloc2ndIndex < suballoc2ndCount)
+            {
+                const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
+
+                // 1. Process free space before this allocation.
+                if(lastOffset < suballoc.offset)
+                {
+                    // There is free space from lastOffset to suballoc.offset.
+                    const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
+                    inoutStats.unusedSize += unusedRangeSize;
+                    ++inoutStats.unusedRangeCount;
+                    inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
+                }
+
+                // 2. Process this allocation.
+                // There is allocation with suballoc.offset, suballoc.size.
+                ++inoutStats.allocationCount;
+
+                // 3. Prepare for next iteration.
+                lastOffset = suballoc.offset + suballoc.size;
+                ++nextAlloc2ndIndex;
+            }
+            // We are at the end.
+            else
+            {
+                if(lastOffset < freeSpace2ndTo1stEnd)
+                {
+                    // There is free space from lastOffset to freeSpace2ndTo1stEnd.
+                    const VkDeviceSize unusedRangeSize = freeSpace2ndTo1stEnd - lastOffset;
+                    inoutStats.unusedSize += unusedRangeSize;
+                    ++inoutStats.unusedRangeCount;
+                    inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
+                }
+
+                // End of loop.
+                lastOffset = freeSpace2ndTo1stEnd;
+            }
+        }
+    }
+
+    size_t nextAlloc1stIndex = m_1stNullItemsBeginCount;
+    const VkDeviceSize freeSpace1stTo2ndEnd =
+        m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ? suballocations2nd.back().offset : size;
+    while(lastOffset < freeSpace1stTo2ndEnd)
+    {
+        // Find next non-null allocation or move nextAllocIndex to the end.
+        while(nextAlloc1stIndex < suballoc1stCount &&
+            suballocations1st[nextAlloc1stIndex].hAllocation == VK_NULL_HANDLE)
+        {
+            ++nextAlloc1stIndex;
+        }
+
+        // Found non-null allocation.
+        if(nextAlloc1stIndex < suballoc1stCount)
+        {
+            const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
+
+            // 1. Process free space before this allocation.
+            if(lastOffset < suballoc.offset)
+            {
+                // There is free space from lastOffset to suballoc.offset.
+                const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
+                inoutStats.unusedSize += unusedRangeSize;
+                ++inoutStats.unusedRangeCount;
+                inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
+            }
+
+            // 2. Process this allocation.
+            // There is allocation with suballoc.offset, suballoc.size.
+            ++inoutStats.allocationCount;
+
+            // 3. Prepare for next iteration.
+            lastOffset = suballoc.offset + suballoc.size;
+            ++nextAlloc1stIndex;
+        }
+        // We are at the end.
+        else
+        {
+            if(lastOffset < freeSpace1stTo2ndEnd)
+            {
+                // There is free space from lastOffset to freeSpace1stTo2ndEnd.
+                const VkDeviceSize unusedRangeSize = freeSpace1stTo2ndEnd - lastOffset;
+                inoutStats.unusedSize += unusedRangeSize;
+                ++inoutStats.unusedRangeCount;
+                inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
+            }
+
+            // End of loop.
+            lastOffset = freeSpace1stTo2ndEnd;
+        }
+    }
+
+    if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
+    {
+        size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
+        while(lastOffset < size)
+        {
+            // Find next non-null allocation or move nextAlloc2ndIndex to the end.
+            while(nextAlloc2ndIndex != SIZE_MAX &&
+                suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
+            {
+                --nextAlloc2ndIndex;
+            }
+
+            // Found non-null allocation.
+            if(nextAlloc2ndIndex != SIZE_MAX)
+            {
+                const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
+
+                // 1. Process free space before this allocation.
+                if(lastOffset < suballoc.offset)
+                {
+                    // There is free space from lastOffset to suballoc.offset.
+                    const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
+                    inoutStats.unusedSize += unusedRangeSize;
+                    ++inoutStats.unusedRangeCount;
+                    inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
+                }
+
+                // 2. Process this allocation.
+                // There is allocation with suballoc.offset, suballoc.size.
+                ++inoutStats.allocationCount;
+
+                // 3. Prepare for next iteration.
+                lastOffset = suballoc.offset + suballoc.size;
+                --nextAlloc2ndIndex;
+            }
+            // We are at the end.
+            else
+            {
+                if(lastOffset < size)
+                {
+                    // There is free space from lastOffset to size.
+                    const VkDeviceSize unusedRangeSize = size - lastOffset;
+                    inoutStats.unusedSize += unusedRangeSize;
+                    ++inoutStats.unusedRangeCount;
+                    inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
+                }
+
+                // End of loop.
+                lastOffset = size;
+            }
+        }
+    }
+}
+
+#if VMA_STATS_STRING_ENABLED
+void VmaBlockMetadata_Linear::PrintDetailedMap(class VmaJsonWriter& json) const
+{
+    const VkDeviceSize size = GetSize();
+    const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+    const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+    const size_t suballoc1stCount = suballocations1st.size();
+    const size_t suballoc2ndCount = suballocations2nd.size();
+
+    // FIRST PASS
+
+    size_t unusedRangeCount = 0;
+    VkDeviceSize usedBytes = 0;
+
+    VkDeviceSize lastOffset = 0;
+
+    size_t alloc2ndCount = 0;
+    if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
+    {
+        const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
+        size_t nextAlloc2ndIndex = 0;
+        while(lastOffset < freeSpace2ndTo1stEnd)
+        {
+            // Find next non-null allocation or move nextAlloc2ndIndex to the end.
+            while(nextAlloc2ndIndex < suballoc2ndCount &&
+                suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
+            {
+                ++nextAlloc2ndIndex;
+            }
+
+            // Found non-null allocation.
+            if(nextAlloc2ndIndex < suballoc2ndCount)
+            {
+                const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
+
+                // 1. Process free space before this allocation.
+                if(lastOffset < suballoc.offset)
+                {
+                    // There is free space from lastOffset to suballoc.offset.
+                    ++unusedRangeCount;
+                }
+
+                // 2. Process this allocation.
+                // There is allocation with suballoc.offset, suballoc.size.
+                ++alloc2ndCount;
+                usedBytes += suballoc.size;
+
+                // 3. Prepare for next iteration.
+                lastOffset = suballoc.offset + suballoc.size;
+                ++nextAlloc2ndIndex;
+            }
+            // We are at the end.
+            else
+            {
+                if(lastOffset < freeSpace2ndTo1stEnd)
+                {
+                    // There is free space from lastOffset to freeSpace2ndTo1stEnd.
+                    ++unusedRangeCount;
+                }
+
+                // End of loop.
+                lastOffset = freeSpace2ndTo1stEnd;
+            }
+        }
+    }
+
+    size_t nextAlloc1stIndex = m_1stNullItemsBeginCount;
+    size_t alloc1stCount = 0;
+    const VkDeviceSize freeSpace1stTo2ndEnd =
+        m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ? suballocations2nd.back().offset : size;
+    while(lastOffset < freeSpace1stTo2ndEnd)
+    {
+        // Find next non-null allocation or move nextAllocIndex to the end.
+        while(nextAlloc1stIndex < suballoc1stCount &&
+            suballocations1st[nextAlloc1stIndex].hAllocation == VK_NULL_HANDLE)
+        {
+            ++nextAlloc1stIndex;
+        }
+
+        // Found non-null allocation.
+        if(nextAlloc1stIndex < suballoc1stCount)
+        {
+            const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
+
+            // 1. Process free space before this allocation.
+            if(lastOffset < suballoc.offset)
+            {
+                // There is free space from lastOffset to suballoc.offset.
+                ++unusedRangeCount;
+            }
+
+            // 2. Process this allocation.
+            // There is allocation with suballoc.offset, suballoc.size.
+            ++alloc1stCount;
+            usedBytes += suballoc.size;
+
+            // 3. Prepare for next iteration.
+            lastOffset = suballoc.offset + suballoc.size;
+            ++nextAlloc1stIndex;
+        }
+        // We are at the end.
+        else
+        {
+            if(lastOffset < size)
+            {
+                // There is free space from lastOffset to freeSpace1stTo2ndEnd.
+                ++unusedRangeCount;
+            }
+
+            // End of loop.
+            lastOffset = freeSpace1stTo2ndEnd;
+        }
+    }
+
+    if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
+    {
+        size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
+        while(lastOffset < size)
+        {
+            // Find next non-null allocation or move nextAlloc2ndIndex to the end.
+            while(nextAlloc2ndIndex != SIZE_MAX &&
+                suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
+            {
+                --nextAlloc2ndIndex;
+            }
+
+            // Found non-null allocation.
+            if(nextAlloc2ndIndex != SIZE_MAX)
+            {
+                const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
+
+                // 1. Process free space before this allocation.
+                if(lastOffset < suballoc.offset)
+                {
+                    // There is free space from lastOffset to suballoc.offset.
+                    ++unusedRangeCount;
+                }
+
+                // 2. Process this allocation.
+                // There is allocation with suballoc.offset, suballoc.size.
+                ++alloc2ndCount;
+                usedBytes += suballoc.size;
+
+                // 3. Prepare for next iteration.
+                lastOffset = suballoc.offset + suballoc.size;
+                --nextAlloc2ndIndex;
+            }
+            // We are at the end.
+            else
+            {
+                if(lastOffset < size)
+                {
+                    // There is free space from lastOffset to size.
+                    ++unusedRangeCount;
+                }
+
+                // End of loop.
+                lastOffset = size;
+            }
+        }
+    }
+
+    const VkDeviceSize unusedBytes = size - usedBytes;
+    PrintDetailedMap_Begin(json, unusedBytes, alloc1stCount + alloc2ndCount, unusedRangeCount);
+
+    // SECOND PASS
+    lastOffset = 0;
+
+    if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
+    {
+        const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
+        size_t nextAlloc2ndIndex = 0;
+        while(lastOffset < freeSpace2ndTo1stEnd)
+        {
+            // Find next non-null allocation or move nextAlloc2ndIndex to the end.
+            while(nextAlloc2ndIndex < suballoc2ndCount &&
+                suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
+            {
+                ++nextAlloc2ndIndex;
+            }
+
+            // Found non-null allocation.
+            if(nextAlloc2ndIndex < suballoc2ndCount)
+            {
+                const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
+
+                // 1. Process free space before this allocation.
+                if(lastOffset < suballoc.offset)
+                {
+                    // There is free space from lastOffset to suballoc.offset.
+                    const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
+                    PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
+                }
+
+                // 2. Process this allocation.
+                // There is allocation with suballoc.offset, suballoc.size.
+                PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.hAllocation);
+
+                // 3. Prepare for next iteration.
+                lastOffset = suballoc.offset + suballoc.size;
+                ++nextAlloc2ndIndex;
+            }
+            // We are at the end.
+            else
+            {
+                if(lastOffset < freeSpace2ndTo1stEnd)
+                {
+                    // There is free space from lastOffset to freeSpace2ndTo1stEnd.
+                    const VkDeviceSize unusedRangeSize = freeSpace2ndTo1stEnd - lastOffset;
+                    PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
+                }
+
+                // End of loop.
+                lastOffset = freeSpace2ndTo1stEnd;
+            }
+        }
+    }
+
+    nextAlloc1stIndex = m_1stNullItemsBeginCount;
+    while(lastOffset < freeSpace1stTo2ndEnd)
+    {
+        // Find next non-null allocation or move nextAllocIndex to the end.
+        while(nextAlloc1stIndex < suballoc1stCount &&
+            suballocations1st[nextAlloc1stIndex].hAllocation == VK_NULL_HANDLE)
+        {
+            ++nextAlloc1stIndex;
+        }
+
+        // Found non-null allocation.
+        if(nextAlloc1stIndex < suballoc1stCount)
+        {
+            const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
+
+            // 1. Process free space before this allocation.
+            if(lastOffset < suballoc.offset)
+            {
+                // There is free space from lastOffset to suballoc.offset.
+                const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
+                PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
+            }
+
+            // 2. Process this allocation.
+            // There is allocation with suballoc.offset, suballoc.size.
+            PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.hAllocation);
+
+            // 3. Prepare for next iteration.
+            lastOffset = suballoc.offset + suballoc.size;
+            ++nextAlloc1stIndex;
+        }
+        // We are at the end.
+        else
+        {
+            if(lastOffset < freeSpace1stTo2ndEnd)
+            {
+                // There is free space from lastOffset to freeSpace1stTo2ndEnd.
+                const VkDeviceSize unusedRangeSize = freeSpace1stTo2ndEnd - lastOffset;
+                PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
+            }
+
+            // End of loop.
+            lastOffset = freeSpace1stTo2ndEnd;
+        }
+    }
+
+    if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
+    {
+        size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
+        while(lastOffset < size)
+        {
+            // Find next non-null allocation or move nextAlloc2ndIndex to the end.
+            while(nextAlloc2ndIndex != SIZE_MAX &&
+                suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
+            {
+                --nextAlloc2ndIndex;
+            }
+
+            // Found non-null allocation.
+            if(nextAlloc2ndIndex != SIZE_MAX)
+            {
+                const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
+
+                // 1. Process free space before this allocation.
+                if(lastOffset < suballoc.offset)
+                {
+                    // There is free space from lastOffset to suballoc.offset.
+                    const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
+                    PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
+                }
+
+                // 2. Process this allocation.
+                // There is allocation with suballoc.offset, suballoc.size.
+                PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.hAllocation);
+
+                // 3. Prepare for next iteration.
+                lastOffset = suballoc.offset + suballoc.size;
+                --nextAlloc2ndIndex;
+            }
+            // We are at the end.
+            else
+            {
+                if(lastOffset < size)
+                {
+                    // There is free space from lastOffset to size.
+                    const VkDeviceSize unusedRangeSize = size - lastOffset;
+                    PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
+                }
+
+                // End of loop.
+                lastOffset = size;
+            }
+        }
+    }
+
+    PrintDetailedMap_End(json);
+}
+#endif // #if VMA_STATS_STRING_ENABLED
+
+bool VmaBlockMetadata_Linear::CreateAllocationRequest(
+    uint32_t currentFrameIndex,
+    uint32_t frameInUseCount,
+    VkDeviceSize bufferImageGranularity,
+    VkDeviceSize allocSize,
+    VkDeviceSize allocAlignment,
+    bool upperAddress,
+    VmaSuballocationType allocType,
+    bool canMakeOtherLost,
+    uint32_t strategy,
+    VmaAllocationRequest* pAllocationRequest)
+{
+    VMA_ASSERT(allocSize > 0);
+    VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
+    VMA_ASSERT(pAllocationRequest != VMA_NULL);
+    VMA_HEAVY_ASSERT(Validate());
+    return upperAddress ?
+        CreateAllocationRequest_UpperAddress(
+            currentFrameIndex, frameInUseCount, bufferImageGranularity,
+            allocSize, allocAlignment, allocType, canMakeOtherLost, strategy, pAllocationRequest) :
+        CreateAllocationRequest_LowerAddress(
+            currentFrameIndex, frameInUseCount, bufferImageGranularity,
+            allocSize, allocAlignment, allocType, canMakeOtherLost, strategy, pAllocationRequest);
+}
+
+bool VmaBlockMetadata_Linear::CreateAllocationRequest_UpperAddress(
+    uint32_t currentFrameIndex,
+    uint32_t frameInUseCount,
+    VkDeviceSize bufferImageGranularity,
+    VkDeviceSize allocSize,
+    VkDeviceSize allocAlignment,
+    VmaSuballocationType allocType,
+    bool canMakeOtherLost,
+    uint32_t strategy,
+    VmaAllocationRequest* pAllocationRequest)
+{
+    const VkDeviceSize size = GetSize();
+    SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+    SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+
+    if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
+    {
+        VMA_ASSERT(0 && "Trying to use pool with linear algorithm as double stack, while it is already being used as ring buffer.");
+        return false;
+    }
+
+    // Try to allocate before 2nd.back(), or end of block if 2nd.empty().
+    if(allocSize > size)
+    {
+        return false;
+    }
+    VkDeviceSize resultBaseOffset = size - allocSize;
+    if(!suballocations2nd.empty())
+    {
+        const VmaSuballocation& lastSuballoc = suballocations2nd.back();
+        resultBaseOffset = lastSuballoc.offset - allocSize;
+        if(allocSize > lastSuballoc.offset)
+        {
+            return false;
+        }
+    }
+
+    // Start from offset equal to end of free space.
+    VkDeviceSize resultOffset = resultBaseOffset;
+
+    // Apply VMA_DEBUG_MARGIN at the end.
+    if(VMA_DEBUG_MARGIN > 0)
+    {
+        if(resultOffset < VMA_DEBUG_MARGIN)
+        {
+            return false;
+        }
+        resultOffset -= VMA_DEBUG_MARGIN;
+    }
+
+    // Apply alignment.
+    resultOffset = VmaAlignDown(resultOffset, allocAlignment);
+
+    // Check next suballocations from 2nd for BufferImageGranularity conflicts.
+    // Make bigger alignment if necessary.
+    if(bufferImageGranularity > 1 && !suballocations2nd.empty())
+    {
+        bool bufferImageGranularityConflict = false;
+        for(size_t nextSuballocIndex = suballocations2nd.size(); nextSuballocIndex--; )
+        {
+            const VmaSuballocation& nextSuballoc = suballocations2nd[nextSuballocIndex];
+            if(VmaBlocksOnSamePage(resultOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
+            {
+                if(VmaIsBufferImageGranularityConflict(nextSuballoc.type, allocType))
+                {
+                    bufferImageGranularityConflict = true;
+                    break;
+                }
+            }
+            else
+                // Already on previous page.
+                break;
+        }
+        if(bufferImageGranularityConflict)
+        {
+            resultOffset = VmaAlignDown(resultOffset, bufferImageGranularity);
+        }
+    }
+
+    // There is enough free space.
+    const VkDeviceSize endOf1st = !suballocations1st.empty() ?
+        suballocations1st.back().offset + suballocations1st.back().size :
+        0;
+    if(endOf1st + VMA_DEBUG_MARGIN <= resultOffset)
+    {
+        // Check previous suballocations for BufferImageGranularity conflicts.
+        // If conflict exists, allocation cannot be made here.
+        if(bufferImageGranularity > 1)
+        {
+            for(size_t prevSuballocIndex = suballocations1st.size(); prevSuballocIndex--; )
+            {
+                const VmaSuballocation& prevSuballoc = suballocations1st[prevSuballocIndex];
+                if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, resultOffset, bufferImageGranularity))
+                {
+                    if(VmaIsBufferImageGranularityConflict(allocType, prevSuballoc.type))
+                    {
+                        return false;
+                    }
+                }
+                else
+                {
+                    // Already on next page.
+                    break;
+                }
+            }
+        }
+
+        // All tests passed: Success.
+        pAllocationRequest->offset = resultOffset;
+        pAllocationRequest->sumFreeSize = resultBaseOffset + allocSize - endOf1st;
+        pAllocationRequest->sumItemSize = 0;
+        // pAllocationRequest->item unused.
+        pAllocationRequest->itemsToMakeLostCount = 0;
+        pAllocationRequest->type = VmaAllocationRequestType::UpperAddress;
+        return true;
+    }
+
+    return false;
+}
+
+bool VmaBlockMetadata_Linear::CreateAllocationRequest_LowerAddress(
+    uint32_t currentFrameIndex,
+    uint32_t frameInUseCount,
+    VkDeviceSize bufferImageGranularity,
+    VkDeviceSize allocSize,
+    VkDeviceSize allocAlignment,
+    VmaSuballocationType allocType,
+    bool canMakeOtherLost,
+    uint32_t strategy,
+    VmaAllocationRequest* pAllocationRequest)
+{
+    const VkDeviceSize size = GetSize();
+    SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+    SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+
+    if(m_2ndVectorMode == SECOND_VECTOR_EMPTY || m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
+    {
+        // Try to allocate at the end of 1st vector.
+
+        VkDeviceSize resultBaseOffset = 0;
+        if(!suballocations1st.empty())
+        {
+            const VmaSuballocation& lastSuballoc = suballocations1st.back();
+            resultBaseOffset = lastSuballoc.offset + lastSuballoc.size;
+        }
+
+        // Start from offset equal to beginning of free space.
+        VkDeviceSize resultOffset = resultBaseOffset;
+
+        // Apply VMA_DEBUG_MARGIN at the beginning.
+        if(VMA_DEBUG_MARGIN > 0)
+        {
+            resultOffset += VMA_DEBUG_MARGIN;
+        }
+
+        // Apply alignment.
+        resultOffset = VmaAlignUp(resultOffset, allocAlignment);
+
+        // Check previous suballocations for BufferImageGranularity conflicts.
+        // Make bigger alignment if necessary.
+        if(bufferImageGranularity > 1 && !suballocations1st.empty())
+        {
+            bool bufferImageGranularityConflict = false;
+            for(size_t prevSuballocIndex = suballocations1st.size(); prevSuballocIndex--; )
+            {
+                const VmaSuballocation& prevSuballoc = suballocations1st[prevSuballocIndex];
+                if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, resultOffset, bufferImageGranularity))
+                {
+                    if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
+                    {
+                        bufferImageGranularityConflict = true;
+                        break;
+                    }
+                }
+                else
+                    // Already on previous page.
+                    break;
+            }
+            if(bufferImageGranularityConflict)
+            {
+                resultOffset = VmaAlignUp(resultOffset, bufferImageGranularity);
+            }
+        }
+
+        const VkDeviceSize freeSpaceEnd = m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ?
+            suballocations2nd.back().offset : size;
+
+        // There is enough free space at the end after alignment.
+        if(resultOffset + allocSize + VMA_DEBUG_MARGIN <= freeSpaceEnd)
+        {
+            // Check next suballocations for BufferImageGranularity conflicts.
+            // If conflict exists, allocation cannot be made here.
+            if(bufferImageGranularity > 1 && m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
+            {
+                for(size_t nextSuballocIndex = suballocations2nd.size(); nextSuballocIndex--; )
+                {
+                    const VmaSuballocation& nextSuballoc = suballocations2nd[nextSuballocIndex];
+                    if(VmaBlocksOnSamePage(resultOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
+                    {
+                        if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
+                        {
+                            return false;
+                        }
+                    }
+                    else
+                    {
+                        // Already on previous page.
+                        break;
+                    }
+                }
+            }
+
+            // All tests passed: Success.
+            pAllocationRequest->offset = resultOffset;
+            pAllocationRequest->sumFreeSize = freeSpaceEnd - resultBaseOffset;
+            pAllocationRequest->sumItemSize = 0;
+            // pAllocationRequest->item, customData unused.
+            pAllocationRequest->type = VmaAllocationRequestType::EndOf1st;
+            pAllocationRequest->itemsToMakeLostCount = 0;
+            return true;
+        }
+    }
+
+    // Wrap-around to end of 2nd vector. Try to allocate there, watching for the
+    // beginning of 1st vector as the end of free space.
+    if(m_2ndVectorMode == SECOND_VECTOR_EMPTY || m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
+    {
+        VMA_ASSERT(!suballocations1st.empty());
+
+        VkDeviceSize resultBaseOffset = 0;
+        if(!suballocations2nd.empty())
+        {
+            const VmaSuballocation& lastSuballoc = suballocations2nd.back();
+            resultBaseOffset = lastSuballoc.offset + lastSuballoc.size;
+        }
+
+        // Start from offset equal to beginning of free space.
+        VkDeviceSize resultOffset = resultBaseOffset;
+
+        // Apply VMA_DEBUG_MARGIN at the beginning.
+        if(VMA_DEBUG_MARGIN > 0)
+        {
+            resultOffset += VMA_DEBUG_MARGIN;
+        }
+
+        // Apply alignment.
+        resultOffset = VmaAlignUp(resultOffset, allocAlignment);
+
+        // Check previous suballocations for BufferImageGranularity conflicts.
+        // Make bigger alignment if necessary.
+        if(bufferImageGranularity > 1 && !suballocations2nd.empty())
+        {
+            bool bufferImageGranularityConflict = false;
+            for(size_t prevSuballocIndex = suballocations2nd.size(); prevSuballocIndex--; )
+            {
+                const VmaSuballocation& prevSuballoc = suballocations2nd[prevSuballocIndex];
+                if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, resultOffset, bufferImageGranularity))
+                {
+                    if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
+                    {
+                        bufferImageGranularityConflict = true;
+                        break;
+                    }
+                }
+                else
+                    // Already on previous page.
+                    break;
+            }
+            if(bufferImageGranularityConflict)
+            {
+                resultOffset = VmaAlignUp(resultOffset, bufferImageGranularity);
+            }
+        }
+
+        pAllocationRequest->itemsToMakeLostCount = 0;
+        pAllocationRequest->sumItemSize = 0;
+        size_t index1st = m_1stNullItemsBeginCount;
+
+        if(canMakeOtherLost)
+        {
+            while(index1st < suballocations1st.size() &&
+                resultOffset + allocSize + VMA_DEBUG_MARGIN > suballocations1st[index1st].offset)
+            {
+                // Next colliding allocation at the beginning of 1st vector found. Try to make it lost.
+                const VmaSuballocation& suballoc = suballocations1st[index1st];
+                if(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE)
+                {
+                    // No problem.
+                }
+                else
+                {
+                    VMA_ASSERT(suballoc.hAllocation != VK_NULL_HANDLE);
+                    if(suballoc.hAllocation->CanBecomeLost() &&
+                        suballoc.hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
+                    {
+                        ++pAllocationRequest->itemsToMakeLostCount;
+                        pAllocationRequest->sumItemSize += suballoc.size;
+                    }
+                    else
+                    {
+                        return false;
+                    }
+                }
+                ++index1st;
+            }
+
+            // Check next suballocations for BufferImageGranularity conflicts.
+            // If conflict exists, we must mark more allocations lost or fail.
+            if(bufferImageGranularity > 1)
+            {
+                while(index1st < suballocations1st.size())
+                {
+                    const VmaSuballocation& suballoc = suballocations1st[index1st];
+                    if(VmaBlocksOnSamePage(resultOffset, allocSize, suballoc.offset, bufferImageGranularity))
+                    {
+                        if(suballoc.hAllocation != VK_NULL_HANDLE)
+                        {
+                            // Not checking actual VmaIsBufferImageGranularityConflict(allocType, suballoc.type).
+                            if(suballoc.hAllocation->CanBecomeLost() &&
+                                suballoc.hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
+                            {
+                                ++pAllocationRequest->itemsToMakeLostCount;
+                                pAllocationRequest->sumItemSize += suballoc.size;
+                            }
+                            else
+                            {
+                                return false;
+                            }
+                        }
+                    }
+                    else
+                    {
+                        // Already on next page.
+                        break;
+                    }
+                    ++index1st;
+                }
+            }
+
+            // Special case: There is not enough room at the end for this allocation, even after making all from the 1st lost.
+            if(index1st == suballocations1st.size() &&
+                resultOffset + allocSize + VMA_DEBUG_MARGIN > size)
+            {
+                // TODO: This is a known bug that it's not yet implemented and the allocation is failing.
+                VMA_DEBUG_LOG("Unsupported special case in custom pool with linear allocation algorithm used as ring buffer with allocations that can be lost.");
+            }
+        }
+
+        // There is enough free space at the end after alignment.
+        if((index1st == suballocations1st.size() && resultOffset + allocSize + VMA_DEBUG_MARGIN <= size) ||
+            (index1st < suballocations1st.size() && resultOffset + allocSize + VMA_DEBUG_MARGIN <= suballocations1st[index1st].offset))
+        {
+            // Check next suballocations for BufferImageGranularity conflicts.
+            // If conflict exists, allocation cannot be made here.
+            if(bufferImageGranularity > 1)
+            {
+                for(size_t nextSuballocIndex = index1st;
+                    nextSuballocIndex < suballocations1st.size();
+                    nextSuballocIndex++)
+                {
+                    const VmaSuballocation& nextSuballoc = suballocations1st[nextSuballocIndex];
+                    if(VmaBlocksOnSamePage(resultOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
+                    {
+                        if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
+                        {
+                            return false;
+                        }
+                    }
+                    else
+                    {
+                        // Already on next page.
+                        break;
+                    }
+                }
+            }
+
+            // All tests passed: Success.
+            pAllocationRequest->offset = resultOffset;
+            pAllocationRequest->sumFreeSize =
+                (index1st < suballocations1st.size() ? suballocations1st[index1st].offset : size)
+                - resultBaseOffset
+                - pAllocationRequest->sumItemSize;
+            pAllocationRequest->type = VmaAllocationRequestType::EndOf2nd;
+            // pAllocationRequest->item, customData unused.
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool VmaBlockMetadata_Linear::MakeRequestedAllocationsLost(
+    uint32_t currentFrameIndex,
+    uint32_t frameInUseCount,
+    VmaAllocationRequest* pAllocationRequest)
+{
+    if(pAllocationRequest->itemsToMakeLostCount == 0)
+    {
+        return true;
+    }
+
+    VMA_ASSERT(m_2ndVectorMode == SECOND_VECTOR_EMPTY || m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER);
+
+    // We always start from 1st.
+    SuballocationVectorType* suballocations = &AccessSuballocations1st();
+    size_t index = m_1stNullItemsBeginCount;
+    size_t madeLostCount = 0;
+    while(madeLostCount < pAllocationRequest->itemsToMakeLostCount)
+    {
+        if(index == suballocations->size())
+        {
+            index = 0;
+            // If we get to the end of 1st, we wrap around to beginning of 2nd of 1st.
+            if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
+            {
+                suballocations = &AccessSuballocations2nd();
+            }
+            // else: m_2ndVectorMode == SECOND_VECTOR_EMPTY:
+            // suballocations continues pointing at AccessSuballocations1st().
+            VMA_ASSERT(!suballocations->empty());
+        }
+        VmaSuballocation& suballoc = (*suballocations)[index];
+        if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
+        {
+            VMA_ASSERT(suballoc.hAllocation != VK_NULL_HANDLE);
+            VMA_ASSERT(suballoc.hAllocation->CanBecomeLost());
+            if(suballoc.hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
+            {
+                suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
+                suballoc.hAllocation = VK_NULL_HANDLE;
+                m_SumFreeSize += suballoc.size;
+                if(suballocations == &AccessSuballocations1st())
+                {
+                    ++m_1stNullItemsMiddleCount;
+                }
+                else
+                {
+                    ++m_2ndNullItemsCount;
+                }
+                ++madeLostCount;
+            }
+            else
+            {
+                return false;
+            }
+        }
+        ++index;
+    }
+
+    CleanupAfterFree();
+    //VMA_HEAVY_ASSERT(Validate()); // Already called by ClanupAfterFree().
+
+    return true;
+}
+
+uint32_t VmaBlockMetadata_Linear::MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
+{
+    uint32_t lostAllocationCount = 0;
+
+    SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+    for(size_t i = m_1stNullItemsBeginCount, count = suballocations1st.size(); i < count; ++i)
+    {
+        VmaSuballocation& suballoc = suballocations1st[i];
+        if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE &&
+            suballoc.hAllocation->CanBecomeLost() &&
+            suballoc.hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
+        {
+            suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
+            suballoc.hAllocation = VK_NULL_HANDLE;
+            ++m_1stNullItemsMiddleCount;
+            m_SumFreeSize += suballoc.size;
+            ++lostAllocationCount;
+        }
+    }
+
+    SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+    for(size_t i = 0, count = suballocations2nd.size(); i < count; ++i)
+    {
+        VmaSuballocation& suballoc = suballocations2nd[i];
+        if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE &&
+            suballoc.hAllocation->CanBecomeLost() &&
+            suballoc.hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
+        {
+            suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
+            suballoc.hAllocation = VK_NULL_HANDLE;
+            ++m_2ndNullItemsCount;
+            m_SumFreeSize += suballoc.size;
+            ++lostAllocationCount;
+        }
+    }
+
+    if(lostAllocationCount)
+    {
+        CleanupAfterFree();
+    }
+
+    return lostAllocationCount;
+}
+
+VkResult VmaBlockMetadata_Linear::CheckCorruption(const void* pBlockData)
+{
+    SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+    for(size_t i = m_1stNullItemsBeginCount, count = suballocations1st.size(); i < count; ++i)
+    {
+        const VmaSuballocation& suballoc = suballocations1st[i];
+        if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
+        {
+            if(!VmaValidateMagicValue(pBlockData, suballoc.offset - VMA_DEBUG_MARGIN))
+            {
+                VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE VALIDATED ALLOCATION!");
+                return VK_ERROR_VALIDATION_FAILED_EXT;
+            }
+            if(!VmaValidateMagicValue(pBlockData, suballoc.offset + suballoc.size))
+            {
+                VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
+                return VK_ERROR_VALIDATION_FAILED_EXT;
+            }
+        }
+    }
+
+    SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+    for(size_t i = 0, count = suballocations2nd.size(); i < count; ++i)
+    {
+        const VmaSuballocation& suballoc = suballocations2nd[i];
+        if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
+        {
+            if(!VmaValidateMagicValue(pBlockData, suballoc.offset - VMA_DEBUG_MARGIN))
+            {
+                VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE VALIDATED ALLOCATION!");
+                return VK_ERROR_VALIDATION_FAILED_EXT;
+            }
+            if(!VmaValidateMagicValue(pBlockData, suballoc.offset + suballoc.size))
+            {
+                VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
+                return VK_ERROR_VALIDATION_FAILED_EXT;
+            }
+        }
+    }
+
+    return VK_SUCCESS;
+}
+
+void VmaBlockMetadata_Linear::Alloc(
+    const VmaAllocationRequest& request,
+    VmaSuballocationType type,
+    VkDeviceSize allocSize,
+    VmaAllocation hAllocation)
+{
+    const VmaSuballocation newSuballoc = { request.offset, allocSize, hAllocation, type };
+
+    switch(request.type)
+    {
+    case VmaAllocationRequestType::UpperAddress:
+        {
+            VMA_ASSERT(m_2ndVectorMode != SECOND_VECTOR_RING_BUFFER &&
+                "CRITICAL ERROR: Trying to use linear allocator as double stack while it was already used as ring buffer.");
+            SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+            suballocations2nd.push_back(newSuballoc);
+            m_2ndVectorMode = SECOND_VECTOR_DOUBLE_STACK;
+        }
+        break;
+    case VmaAllocationRequestType::EndOf1st:
+        {
+            SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+
+            VMA_ASSERT(suballocations1st.empty() ||
+                request.offset >= suballocations1st.back().offset + suballocations1st.back().size);
+            // Check if it fits before the end of the block.
+            VMA_ASSERT(request.offset + allocSize <= GetSize());
+
+            suballocations1st.push_back(newSuballoc);
+        }
+        break;
+    case VmaAllocationRequestType::EndOf2nd:
+        {
+            SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+            // New allocation at the end of 2-part ring buffer, so before first allocation from 1st vector.
+            VMA_ASSERT(!suballocations1st.empty() &&
+                request.offset + allocSize <= suballocations1st[m_1stNullItemsBeginCount].offset);
+            SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+
+            switch(m_2ndVectorMode)
+            {
+            case SECOND_VECTOR_EMPTY:
+                // First allocation from second part ring buffer.
+                VMA_ASSERT(suballocations2nd.empty());
+                m_2ndVectorMode = SECOND_VECTOR_RING_BUFFER;
+                break;
+            case SECOND_VECTOR_RING_BUFFER:
+                // 2-part ring buffer is already started.
+                VMA_ASSERT(!suballocations2nd.empty());
+                break;
+            case SECOND_VECTOR_DOUBLE_STACK:
+                VMA_ASSERT(0 && "CRITICAL ERROR: Trying to use linear allocator as ring buffer while it was already used as double stack.");
+                break;
+            default:
+                VMA_ASSERT(0);
+            }
+
+            suballocations2nd.push_back(newSuballoc);
+        }
+        break;
+    default:
+        VMA_ASSERT(0 && "CRITICAL INTERNAL ERROR.");
+    }
+
+    m_SumFreeSize -= newSuballoc.size;
+}
+
+void VmaBlockMetadata_Linear::Free(const VmaAllocation allocation)
+{
+    FreeAtOffset(allocation->GetOffset());
+}
+
+void VmaBlockMetadata_Linear::FreeAtOffset(VkDeviceSize offset)
+{
+    SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+    SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+
+    if(!suballocations1st.empty())
+    {
+        // First allocation: Mark it as next empty at the beginning.
+        VmaSuballocation& firstSuballoc = suballocations1st[m_1stNullItemsBeginCount];
+        if(firstSuballoc.offset == offset)
+        {
+            firstSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
+            firstSuballoc.hAllocation = VK_NULL_HANDLE;
+            m_SumFreeSize += firstSuballoc.size;
+            ++m_1stNullItemsBeginCount;
+            CleanupAfterFree();
+            return;
+        }
+    }
+
+    // Last allocation in 2-part ring buffer or top of upper stack (same logic).
+    if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER ||
+        m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
+    {
+        VmaSuballocation& lastSuballoc = suballocations2nd.back();
+        if(lastSuballoc.offset == offset)
+        {
+            m_SumFreeSize += lastSuballoc.size;
+            suballocations2nd.pop_back();
+            CleanupAfterFree();
+            return;
+        }
+    }
+    // Last allocation in 1st vector.
+    else if(m_2ndVectorMode == SECOND_VECTOR_EMPTY)
+    {
+        VmaSuballocation& lastSuballoc = suballocations1st.back();
+        if(lastSuballoc.offset == offset)
+        {
+            m_SumFreeSize += lastSuballoc.size;
+            suballocations1st.pop_back();
+            CleanupAfterFree();
+            return;
+        }
+    }
+
+    // Item from the middle of 1st vector.
+    {
+        VmaSuballocation refSuballoc;
+        refSuballoc.offset = offset;
+        // Rest of members stays uninitialized intentionally for better performance.
+        SuballocationVectorType::iterator it = VmaBinaryFindSorted(
+            suballocations1st.begin() + m_1stNullItemsBeginCount,
+            suballocations1st.end(),
+            refSuballoc,
+            VmaSuballocationOffsetLess());
+        if(it != suballocations1st.end())
+        {
+            it->type = VMA_SUBALLOCATION_TYPE_FREE;
+            it->hAllocation = VK_NULL_HANDLE;
+            ++m_1stNullItemsMiddleCount;
+            m_SumFreeSize += it->size;
+            CleanupAfterFree();
+            return;
+        }
+    }
+
+    if(m_2ndVectorMode != SECOND_VECTOR_EMPTY)
+    {
+        // Item from the middle of 2nd vector.
+        VmaSuballocation refSuballoc;
+        refSuballoc.offset = offset;
+        // Rest of members stays uninitialized intentionally for better performance.
+        SuballocationVectorType::iterator it = m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER ?
+            VmaBinaryFindSorted(suballocations2nd.begin(), suballocations2nd.end(), refSuballoc, VmaSuballocationOffsetLess()) :
+            VmaBinaryFindSorted(suballocations2nd.begin(), suballocations2nd.end(), refSuballoc, VmaSuballocationOffsetGreater());
+        if(it != suballocations2nd.end())
+        {
+            it->type = VMA_SUBALLOCATION_TYPE_FREE;
+            it->hAllocation = VK_NULL_HANDLE;
+            ++m_2ndNullItemsCount;
+            m_SumFreeSize += it->size;
+            CleanupAfterFree();
+            return;
+        }
+    }
+
+    VMA_ASSERT(0 && "Allocation to free not found in linear allocator!");
+}
+
+bool VmaBlockMetadata_Linear::ShouldCompact1st() const
+{
+    const size_t nullItemCount = m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount;
+    const size_t suballocCount = AccessSuballocations1st().size();
+    return suballocCount > 32 && nullItemCount * 2 >= (suballocCount - nullItemCount) * 3;
+}
+
+void VmaBlockMetadata_Linear::CleanupAfterFree()
+{
+    SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+    SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+
+    if(IsEmpty())
+    {
+        suballocations1st.clear();
+        suballocations2nd.clear();
+        m_1stNullItemsBeginCount = 0;
+        m_1stNullItemsMiddleCount = 0;
+        m_2ndNullItemsCount = 0;
+        m_2ndVectorMode = SECOND_VECTOR_EMPTY;
+    }
+    else
+    {
+        const size_t suballoc1stCount = suballocations1st.size();
+        const size_t nullItem1stCount = m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount;
+        VMA_ASSERT(nullItem1stCount <= suballoc1stCount);
+
+        // Find more null items at the beginning of 1st vector.
+        while(m_1stNullItemsBeginCount < suballoc1stCount &&
+            suballocations1st[m_1stNullItemsBeginCount].hAllocation == VK_NULL_HANDLE)
+        {
+            ++m_1stNullItemsBeginCount;
+            --m_1stNullItemsMiddleCount;
+        }
+
+        // Find more null items at the end of 1st vector.
+        while(m_1stNullItemsMiddleCount > 0 &&
+            suballocations1st.back().hAllocation == VK_NULL_HANDLE)
+        {
+            --m_1stNullItemsMiddleCount;
+            suballocations1st.pop_back();
+        }
+
+        // Find more null items at the end of 2nd vector.
+        while(m_2ndNullItemsCount > 0 &&
+            suballocations2nd.back().hAllocation == VK_NULL_HANDLE)
+        {
+            --m_2ndNullItemsCount;
+            suballocations2nd.pop_back();
+        }
+
+        // Find more null items at the beginning of 2nd vector.
+        while(m_2ndNullItemsCount > 0 &&
+            suballocations2nd[0].hAllocation == VK_NULL_HANDLE)
+        {
+            --m_2ndNullItemsCount;
+            VmaVectorRemove(suballocations2nd, 0);
+        }
+
+        if(ShouldCompact1st())
+        {
+            const size_t nonNullItemCount = suballoc1stCount - nullItem1stCount;
+            size_t srcIndex = m_1stNullItemsBeginCount;
+            for(size_t dstIndex = 0; dstIndex < nonNullItemCount; ++dstIndex)
+            {
+                while(suballocations1st[srcIndex].hAllocation == VK_NULL_HANDLE)
+                {
+                    ++srcIndex;
+                }
+                if(dstIndex != srcIndex)
+                {
+                    suballocations1st[dstIndex] = suballocations1st[srcIndex];
+                }
+                ++srcIndex;
+            }
+            suballocations1st.resize(nonNullItemCount);
+            m_1stNullItemsBeginCount = 0;
+            m_1stNullItemsMiddleCount = 0;
+        }
+
+        // 2nd vector became empty.
+        if(suballocations2nd.empty())
+        {
+            m_2ndVectorMode = SECOND_VECTOR_EMPTY;
+        }
+
+        // 1st vector became empty.
+        if(suballocations1st.size() - m_1stNullItemsBeginCount == 0)
+        {
+            suballocations1st.clear();
+            m_1stNullItemsBeginCount = 0;
+
+            if(!suballocations2nd.empty() && m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
+            {
+                // Swap 1st with 2nd. Now 2nd is empty.
+                m_2ndVectorMode = SECOND_VECTOR_EMPTY;
+                m_1stNullItemsMiddleCount = m_2ndNullItemsCount;
+                while(m_1stNullItemsBeginCount < suballocations2nd.size() &&
+                    suballocations2nd[m_1stNullItemsBeginCount].hAllocation == VK_NULL_HANDLE)
+                {
+                    ++m_1stNullItemsBeginCount;
+                    --m_1stNullItemsMiddleCount;
+                }
+                m_2ndNullItemsCount = 0;
+                m_1stVectorIndex ^= 1;
+            }
+        }
+    }
+
+    VMA_HEAVY_ASSERT(Validate());
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// class VmaBlockMetadata_Buddy
+
+VmaBlockMetadata_Buddy::VmaBlockMetadata_Buddy(VmaAllocator hAllocator) :
+    VmaBlockMetadata(hAllocator),
+    m_Root(VMA_NULL),
+    m_AllocationCount(0),
+    m_FreeCount(1),
+    m_SumFreeSize(0)
+{
+    memset(m_FreeList, 0, sizeof(m_FreeList));
+}
+
+VmaBlockMetadata_Buddy::~VmaBlockMetadata_Buddy()
+{
+    DeleteNode(m_Root);
+}
+
+void VmaBlockMetadata_Buddy::Init(VkDeviceSize size)
+{
+    VmaBlockMetadata::Init(size);
+
+    m_UsableSize = VmaPrevPow2(size);
+    m_SumFreeSize = m_UsableSize;
+
+    // Calculate m_LevelCount.
+    m_LevelCount = 1;
+    while(m_LevelCount < MAX_LEVELS &&
+        LevelToNodeSize(m_LevelCount) >= MIN_NODE_SIZE)
+    {
+        ++m_LevelCount;
+    }
+
+    Node* rootNode = vma_new(GetAllocationCallbacks(), Node)();
+    rootNode->offset = 0;
+    rootNode->type = Node::TYPE_FREE;
+    rootNode->parent = VMA_NULL;
+    rootNode->buddy = VMA_NULL;
+
+    m_Root = rootNode;
+    AddToFreeListFront(0, rootNode);
+}
+
+bool VmaBlockMetadata_Buddy::Validate() const
+{
+    // Validate tree.
+    ValidationContext ctx;
+    if(!ValidateNode(ctx, VMA_NULL, m_Root, 0, LevelToNodeSize(0)))
+    {
+        VMA_VALIDATE(false && "ValidateNode failed.");
+    }
+    VMA_VALIDATE(m_AllocationCount == ctx.calculatedAllocationCount);
+    VMA_VALIDATE(m_SumFreeSize == ctx.calculatedSumFreeSize);
+
+    // Validate free node lists.
+    for(uint32_t level = 0; level < m_LevelCount; ++level)
+    {
+        VMA_VALIDATE(m_FreeList[level].front == VMA_NULL ||
+            m_FreeList[level].front->free.prev == VMA_NULL);
+
+        for(Node* node = m_FreeList[level].front;
+            node != VMA_NULL;
+            node = node->free.next)
+        {
+            VMA_VALIDATE(node->type == Node::TYPE_FREE);
+
+            if(node->free.next == VMA_NULL)
+            {
+                VMA_VALIDATE(m_FreeList[level].back == node);
+            }
+            else
+            {
+                VMA_VALIDATE(node->free.next->free.prev == node);
+            }
+        }
+    }
+
+    // Validate that free lists ar higher levels are empty.
+    for(uint32_t level = m_LevelCount; level < MAX_LEVELS; ++level)
+    {
+        VMA_VALIDATE(m_FreeList[level].front == VMA_NULL && m_FreeList[level].back == VMA_NULL);
+    }
+
+    return true;
+}
+
+VkDeviceSize VmaBlockMetadata_Buddy::GetUnusedRangeSizeMax() const
+{
+    for(uint32_t level = 0; level < m_LevelCount; ++level)
+    {
+        if(m_FreeList[level].front != VMA_NULL)
+        {
+            return LevelToNodeSize(level);
+        }
+    }
+    return 0;
+}
+
+void VmaBlockMetadata_Buddy::CalcAllocationStatInfo(VmaStatInfo& outInfo) const
+{
+    const VkDeviceSize unusableSize = GetUnusableSize();
+
+    outInfo.blockCount = 1;
+
+    outInfo.allocationCount = outInfo.unusedRangeCount = 0;
+    outInfo.usedBytes = outInfo.unusedBytes = 0;
+
+    outInfo.allocationSizeMax = outInfo.unusedRangeSizeMax = 0;
+    outInfo.allocationSizeMin = outInfo.unusedRangeSizeMin = UINT64_MAX;
+    outInfo.allocationSizeAvg = outInfo.unusedRangeSizeAvg = 0; // Unused.
+
+    CalcAllocationStatInfoNode(outInfo, m_Root, LevelToNodeSize(0));
+
+    if(unusableSize > 0)
+    {
+        ++outInfo.unusedRangeCount;
+        outInfo.unusedBytes += unusableSize;
+        outInfo.unusedRangeSizeMax = VMA_MAX(outInfo.unusedRangeSizeMax, unusableSize);
+        outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusableSize);
+    }
+}
+
+void VmaBlockMetadata_Buddy::AddPoolStats(VmaPoolStats& inoutStats) const
+{
+    const VkDeviceSize unusableSize = GetUnusableSize();
+
+    inoutStats.size += GetSize();
+    inoutStats.unusedSize += m_SumFreeSize + unusableSize;
+    inoutStats.allocationCount += m_AllocationCount;
+    inoutStats.unusedRangeCount += m_FreeCount;
+    inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, GetUnusedRangeSizeMax());
+
+    if(unusableSize > 0)
+    {
+        ++inoutStats.unusedRangeCount;
+        // Not updating inoutStats.unusedRangeSizeMax with unusableSize because this space is not available for allocations.
+    }
+}
+
+#if VMA_STATS_STRING_ENABLED
+
+void VmaBlockMetadata_Buddy::PrintDetailedMap(class VmaJsonWriter& json) const
+{
+    // TODO optimize
+    VmaStatInfo stat;
+    CalcAllocationStatInfo(stat);
+
+    PrintDetailedMap_Begin(
+        json,
+        stat.unusedBytes,
+        stat.allocationCount,
+        stat.unusedRangeCount);
+
+    PrintDetailedMapNode(json, m_Root, LevelToNodeSize(0));
+
+    const VkDeviceSize unusableSize = GetUnusableSize();
+    if(unusableSize > 0)
+    {
+        PrintDetailedMap_UnusedRange(json,
+            m_UsableSize, // offset
+            unusableSize); // size
+    }
+
+    PrintDetailedMap_End(json);
+}
+
+#endif // #if VMA_STATS_STRING_ENABLED
+
+bool VmaBlockMetadata_Buddy::CreateAllocationRequest(
+    uint32_t currentFrameIndex,
+    uint32_t frameInUseCount,
+    VkDeviceSize bufferImageGranularity,
+    VkDeviceSize allocSize,
+    VkDeviceSize allocAlignment,
+    bool upperAddress,
+    VmaSuballocationType allocType,
+    bool canMakeOtherLost,
+    uint32_t strategy,
+    VmaAllocationRequest* pAllocationRequest)
+{
+    VMA_ASSERT(!upperAddress && "VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT can be used only with linear algorithm.");
+
+    // Simple way to respect bufferImageGranularity. May be optimized some day.
+    // Whenever it might be an OPTIMAL image...
+    if(allocType == VMA_SUBALLOCATION_TYPE_UNKNOWN ||
+        allocType == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
+        allocType == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL)
+    {
+        allocAlignment = VMA_MAX(allocAlignment, bufferImageGranularity);
+        allocSize = VMA_MAX(allocSize, bufferImageGranularity);
+    }
+
+    if(allocSize > m_UsableSize)
+    {
+        return false;
+    }
+
+    const uint32_t targetLevel = AllocSizeToLevel(allocSize);
+    for(uint32_t level = targetLevel + 1; level--; )
+    {
+        for(Node* freeNode = m_FreeList[level].front;
+            freeNode != VMA_NULL;
+            freeNode = freeNode->free.next)
+        {
+            if(freeNode->offset % allocAlignment == 0)
+            {
+                pAllocationRequest->type = VmaAllocationRequestType::Normal;
+                pAllocationRequest->offset = freeNode->offset;
+                pAllocationRequest->sumFreeSize = LevelToNodeSize(level);
+                pAllocationRequest->sumItemSize = 0;
+                pAllocationRequest->itemsToMakeLostCount = 0;
+                pAllocationRequest->customData = (void*)(uintptr_t)level;
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+bool VmaBlockMetadata_Buddy::MakeRequestedAllocationsLost(
+    uint32_t currentFrameIndex,
+    uint32_t frameInUseCount,
+    VmaAllocationRequest* pAllocationRequest)
+{
+    /*
+    Lost allocations are not supported in buddy allocator at the moment.
+    Support might be added in the future.
+    */
+    return pAllocationRequest->itemsToMakeLostCount == 0;
+}
+
+uint32_t VmaBlockMetadata_Buddy::MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
+{
+    /*
+    Lost allocations are not supported in buddy allocator at the moment.
+    Support might be added in the future.
+    */
+    return 0;
+}
+
+void VmaBlockMetadata_Buddy::Alloc(
+    const VmaAllocationRequest& request,
+    VmaSuballocationType type,
+    VkDeviceSize allocSize,
+    VmaAllocation hAllocation)
+{
+    VMA_ASSERT(request.type == VmaAllocationRequestType::Normal);
+
+    const uint32_t targetLevel = AllocSizeToLevel(allocSize);
+    uint32_t currLevel = (uint32_t)(uintptr_t)request.customData;
+
+    Node* currNode = m_FreeList[currLevel].front;
+    VMA_ASSERT(currNode != VMA_NULL && currNode->type == Node::TYPE_FREE);
+    while(currNode->offset != request.offset)
+    {
+        currNode = currNode->free.next;
+        VMA_ASSERT(currNode != VMA_NULL && currNode->type == Node::TYPE_FREE);
+    }
+
+    // Go down, splitting free nodes.
+    while(currLevel < targetLevel)
+    {
+        // currNode is already first free node at currLevel.
+        // Remove it from list of free nodes at this currLevel.
+        RemoveFromFreeList(currLevel, currNode);
+
+        const uint32_t childrenLevel = currLevel + 1;
+
+        // Create two free sub-nodes.
+        Node* leftChild = vma_new(GetAllocationCallbacks(), Node)();
+        Node* rightChild = vma_new(GetAllocationCallbacks(), Node)();
+
+        leftChild->offset = currNode->offset;
+        leftChild->type = Node::TYPE_FREE;
+        leftChild->parent = currNode;
+        leftChild->buddy = rightChild;
+
+        rightChild->offset = currNode->offset + LevelToNodeSize(childrenLevel);
+        rightChild->type = Node::TYPE_FREE;
+        rightChild->parent = currNode;
+        rightChild->buddy = leftChild;
+
+        // Convert current currNode to split type.
+        currNode->type = Node::TYPE_SPLIT;
+        currNode->split.leftChild = leftChild;
+
+        // Add child nodes to free list. Order is important!
+        AddToFreeListFront(childrenLevel, rightChild);
+        AddToFreeListFront(childrenLevel, leftChild);
+
+        ++m_FreeCount;
+        //m_SumFreeSize -= LevelToNodeSize(currLevel) % 2; // Useful only when level node sizes can be non power of 2.
+        ++currLevel;
+        currNode = m_FreeList[currLevel].front;
+
+        /*
+        We can be sure that currNode, as left child of node previously split,
+        also fullfills the alignment requirement.
+        */
+    }
+
+    // Remove from free list.
+    VMA_ASSERT(currLevel == targetLevel &&
+        currNode != VMA_NULL &&
+        currNode->type == Node::TYPE_FREE);
+    RemoveFromFreeList(currLevel, currNode);
+
+    // Convert to allocation node.
+    currNode->type = Node::TYPE_ALLOCATION;
+    currNode->allocation.alloc = hAllocation;
+
+    ++m_AllocationCount;
+    --m_FreeCount;
+    m_SumFreeSize -= allocSize;
+}
+
+void VmaBlockMetadata_Buddy::DeleteNode(Node* node)
+{
+    if(node->type == Node::TYPE_SPLIT)
+    {
+        DeleteNode(node->split.leftChild->buddy);
+        DeleteNode(node->split.leftChild);
+    }
+
+    vma_delete(GetAllocationCallbacks(), node);
+}
+
+bool VmaBlockMetadata_Buddy::ValidateNode(ValidationContext& ctx, const Node* parent, const Node* curr, uint32_t level, VkDeviceSize levelNodeSize) const
+{
+    VMA_VALIDATE(level < m_LevelCount);
+    VMA_VALIDATE(curr->parent == parent);
+    VMA_VALIDATE((curr->buddy == VMA_NULL) == (parent == VMA_NULL));
+    VMA_VALIDATE(curr->buddy == VMA_NULL || curr->buddy->buddy == curr);
+    switch(curr->type)
+    {
+    case Node::TYPE_FREE:
+        // curr->free.prev, next are validated separately.
+        ctx.calculatedSumFreeSize += levelNodeSize;
+        ++ctx.calculatedFreeCount;
+        break;
+    case Node::TYPE_ALLOCATION:
+        ++ctx.calculatedAllocationCount;
+        ctx.calculatedSumFreeSize += levelNodeSize - curr->allocation.alloc->GetSize();
+        VMA_VALIDATE(curr->allocation.alloc != VK_NULL_HANDLE);
+        break;
+    case Node::TYPE_SPLIT:
+        {
+            const uint32_t childrenLevel = level + 1;
+            const VkDeviceSize childrenLevelNodeSize = levelNodeSize / 2;
+            const Node* const leftChild = curr->split.leftChild;
+            VMA_VALIDATE(leftChild != VMA_NULL);
+            VMA_VALIDATE(leftChild->offset == curr->offset);
+            if(!ValidateNode(ctx, curr, leftChild, childrenLevel, childrenLevelNodeSize))
+            {
+                VMA_VALIDATE(false && "ValidateNode for left child failed.");
+            }
+            const Node* const rightChild = leftChild->buddy;
+            VMA_VALIDATE(rightChild->offset == curr->offset + childrenLevelNodeSize);
+            if(!ValidateNode(ctx, curr, rightChild, childrenLevel, childrenLevelNodeSize))
+            {
+                VMA_VALIDATE(false && "ValidateNode for right child failed.");
+            }
+        }
+        break;
+    default:
+        return false;
+    }
+
+    return true;
+}
+
+uint32_t VmaBlockMetadata_Buddy::AllocSizeToLevel(VkDeviceSize allocSize) const
+{
+    // I know this could be optimized somehow e.g. by using std::log2p1 from C++20.
+    uint32_t level = 0;
+    VkDeviceSize currLevelNodeSize = m_UsableSize;
+    VkDeviceSize nextLevelNodeSize = currLevelNodeSize >> 1;
+    while(allocSize <= nextLevelNodeSize && level + 1 < m_LevelCount)
+    {
+        ++level;
+        currLevelNodeSize = nextLevelNodeSize;
+        nextLevelNodeSize = currLevelNodeSize >> 1;
+    }
+    return level;
+}
+
+void VmaBlockMetadata_Buddy::FreeAtOffset(VmaAllocation alloc, VkDeviceSize offset)
+{
+    // Find node and level.
+    Node* node = m_Root;
+    VkDeviceSize nodeOffset = 0;
+    uint32_t level = 0;
+    VkDeviceSize levelNodeSize = LevelToNodeSize(0);
+    while(node->type == Node::TYPE_SPLIT)
+    {
+        const VkDeviceSize nextLevelSize = levelNodeSize >> 1;
+        if(offset < nodeOffset + nextLevelSize)
+        {
+            node = node->split.leftChild;
+        }
+        else
+        {
+            node = node->split.leftChild->buddy;
+            nodeOffset += nextLevelSize;
+        }
+        ++level;
+        levelNodeSize = nextLevelSize;
+    }
+
+    VMA_ASSERT(node != VMA_NULL && node->type == Node::TYPE_ALLOCATION);
+    VMA_ASSERT(alloc == VK_NULL_HANDLE || node->allocation.alloc == alloc);
+
+    ++m_FreeCount;
+    --m_AllocationCount;
+    m_SumFreeSize += alloc->GetSize();
+
+    node->type = Node::TYPE_FREE;
+
+    // Join free nodes if possible.
+    while(level > 0 && node->buddy->type == Node::TYPE_FREE)
+    {
+        RemoveFromFreeList(level, node->buddy);
+        Node* const parent = node->parent;
+
+        vma_delete(GetAllocationCallbacks(), node->buddy);
+        vma_delete(GetAllocationCallbacks(), node);
+        parent->type = Node::TYPE_FREE;
+
+        node = parent;
+        --level;
+        //m_SumFreeSize += LevelToNodeSize(level) % 2; // Useful only when level node sizes can be non power of 2.
+        --m_FreeCount;
+    }
+
+    AddToFreeListFront(level, node);
+}
+
+void VmaBlockMetadata_Buddy::CalcAllocationStatInfoNode(VmaStatInfo& outInfo, const Node* node, VkDeviceSize levelNodeSize) const
+{
+    switch(node->type)
+    {
+    case Node::TYPE_FREE:
+        ++outInfo.unusedRangeCount;
+        outInfo.unusedBytes += levelNodeSize;
+        outInfo.unusedRangeSizeMax = VMA_MAX(outInfo.unusedRangeSizeMax, levelNodeSize);
+        outInfo.unusedRangeSizeMin = VMA_MAX(outInfo.unusedRangeSizeMin, levelNodeSize);
+        break;
+    case Node::TYPE_ALLOCATION:
+        {
+            const VkDeviceSize allocSize = node->allocation.alloc->GetSize();
+            ++outInfo.allocationCount;
+            outInfo.usedBytes += allocSize;
+            outInfo.allocationSizeMax = VMA_MAX(outInfo.allocationSizeMax, allocSize);
+            outInfo.allocationSizeMin = VMA_MAX(outInfo.allocationSizeMin, allocSize);
+
+            const VkDeviceSize unusedRangeSize = levelNodeSize - allocSize;
+            if(unusedRangeSize > 0)
+            {
+                ++outInfo.unusedRangeCount;
+                outInfo.unusedBytes += unusedRangeSize;
+                outInfo.unusedRangeSizeMax = VMA_MAX(outInfo.unusedRangeSizeMax, unusedRangeSize);
+                outInfo.unusedRangeSizeMin = VMA_MAX(outInfo.unusedRangeSizeMin, unusedRangeSize);
+            }
+        }
+        break;
+    case Node::TYPE_SPLIT:
+        {
+            const VkDeviceSize childrenNodeSize = levelNodeSize / 2;
+            const Node* const leftChild = node->split.leftChild;
+            CalcAllocationStatInfoNode(outInfo, leftChild, childrenNodeSize);
+            const Node* const rightChild = leftChild->buddy;
+            CalcAllocationStatInfoNode(outInfo, rightChild, childrenNodeSize);
+        }
+        break;
+    default:
+        VMA_ASSERT(0);
+    }
+}
+
+void VmaBlockMetadata_Buddy::AddToFreeListFront(uint32_t level, Node* node)
+{
+    VMA_ASSERT(node->type == Node::TYPE_FREE);
+
+    // List is empty.
+    Node* const frontNode = m_FreeList[level].front;
+    if(frontNode == VMA_NULL)
+    {
+        VMA_ASSERT(m_FreeList[level].back == VMA_NULL);
+        node->free.prev = node->free.next = VMA_NULL;
+        m_FreeList[level].front = m_FreeList[level].back = node;
+    }
+    else
+    {
+        VMA_ASSERT(frontNode->free.prev == VMA_NULL);
+        node->free.prev = VMA_NULL;
+        node->free.next = frontNode;
+        frontNode->free.prev = node;
+        m_FreeList[level].front = node;
+    }
+}
+
+void VmaBlockMetadata_Buddy::RemoveFromFreeList(uint32_t level, Node* node)
+{
+    VMA_ASSERT(m_FreeList[level].front != VMA_NULL);
+
+    // It is at the front.
+    if(node->free.prev == VMA_NULL)
+    {
+        VMA_ASSERT(m_FreeList[level].front == node);
+        m_FreeList[level].front = node->free.next;
+    }
+    else
+    {
+        Node* const prevFreeNode = node->free.prev;
+        VMA_ASSERT(prevFreeNode->free.next == node);
+        prevFreeNode->free.next = node->free.next;
+    }
+
+    // It is at the back.
+    if(node->free.next == VMA_NULL)
+    {
+        VMA_ASSERT(m_FreeList[level].back == node);
+        m_FreeList[level].back = node->free.prev;
+    }
+    else
+    {
+        Node* const nextFreeNode = node->free.next;
+        VMA_ASSERT(nextFreeNode->free.prev == node);
+        nextFreeNode->free.prev = node->free.prev;
+    }
+}
+
+#if VMA_STATS_STRING_ENABLED
+void VmaBlockMetadata_Buddy::PrintDetailedMapNode(class VmaJsonWriter& json, const Node* node, VkDeviceSize levelNodeSize) const
+{
+    switch(node->type)
+    {
+    case Node::TYPE_FREE:
+        PrintDetailedMap_UnusedRange(json, node->offset, levelNodeSize);
+        break;
+    case Node::TYPE_ALLOCATION:
+        {
+            PrintDetailedMap_Allocation(json, node->offset, node->allocation.alloc);
+            const VkDeviceSize allocSize = node->allocation.alloc->GetSize();
+            if(allocSize < levelNodeSize)
+            {
+                PrintDetailedMap_UnusedRange(json, node->offset + allocSize, levelNodeSize - allocSize);
+            }
+        }
+        break;
+    case Node::TYPE_SPLIT:
+        {
+            const VkDeviceSize childrenNodeSize = levelNodeSize / 2;
+            const Node* const leftChild = node->split.leftChild;
+            PrintDetailedMapNode(json, leftChild, childrenNodeSize);
+            const Node* const rightChild = leftChild->buddy;
+            PrintDetailedMapNode(json, rightChild, childrenNodeSize);
+        }
+        break;
+    default:
+        VMA_ASSERT(0);
+    }
+}
+#endif // #if VMA_STATS_STRING_ENABLED
+
+
+////////////////////////////////////////////////////////////////////////////////
+// class VmaDeviceMemoryBlock
+
+VmaDeviceMemoryBlock::VmaDeviceMemoryBlock(VmaAllocator hAllocator) :
+    m_pMetadata(VMA_NULL),
+    m_MemoryTypeIndex(UINT32_MAX),
+    m_Id(0),
+    m_hMemory(VK_NULL_HANDLE),
+    m_MapCount(0),
+    m_pMappedData(VMA_NULL)
+{
+}
+
+void VmaDeviceMemoryBlock::Init(
+    VmaAllocator hAllocator,
+    VmaPool hParentPool,
+    uint32_t newMemoryTypeIndex,
+    VkDeviceMemory newMemory,
+    VkDeviceSize newSize,
+    uint32_t id,
+    uint32_t algorithm)
+{
+    VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);
+
+    m_hParentPool = hParentPool;
+    m_MemoryTypeIndex = newMemoryTypeIndex;
+    m_Id = id;
+    m_hMemory = newMemory;
+
+    switch(algorithm)
+    {
+    case VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT:
+        m_pMetadata = vma_new(hAllocator, VmaBlockMetadata_Linear)(hAllocator);
+        break;
+    case VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT:
+        m_pMetadata = vma_new(hAllocator, VmaBlockMetadata_Buddy)(hAllocator);
+        break;
+    default:
+        VMA_ASSERT(0);
+        // Fall-through.
+    case 0:
+        m_pMetadata = vma_new(hAllocator, VmaBlockMetadata_Generic)(hAllocator);
+    }
+    m_pMetadata->Init(newSize);
+}
+
+void VmaDeviceMemoryBlock::Destroy(VmaAllocator allocator)
+{
+    // This is the most important assert in the entire library.
+    // Hitting it means you have some memory leak - unreleased VmaAllocation objects.
+    VMA_ASSERT(m_pMetadata->IsEmpty() && "Some allocations were not freed before destruction of this memory block!");
+
+    VMA_ASSERT(m_hMemory != VK_NULL_HANDLE);
+    allocator->FreeVulkanMemory(m_MemoryTypeIndex, m_pMetadata->GetSize(), m_hMemory);
+    m_hMemory = VK_NULL_HANDLE;
+
+    vma_delete(allocator, m_pMetadata);
+    m_pMetadata = VMA_NULL;
+}
+
+bool VmaDeviceMemoryBlock::Validate() const
+{
+    VMA_VALIDATE((m_hMemory != VK_NULL_HANDLE) &&
+        (m_pMetadata->GetSize() != 0));
+
+    return m_pMetadata->Validate();
+}
+
+VkResult VmaDeviceMemoryBlock::CheckCorruption(VmaAllocator hAllocator)
+{
+    void* pData = nullptr;
+    VkResult res = Map(hAllocator, 1, &pData);
+    if(res != VK_SUCCESS)
+    {
+        return res;
+    }
+
+    res = m_pMetadata->CheckCorruption(pData);
+
+    Unmap(hAllocator, 1);
+
+    return res;
+}
+
+VkResult VmaDeviceMemoryBlock::Map(VmaAllocator hAllocator, uint32_t count, void** ppData)
+{
+    if(count == 0)
+    {
+        return VK_SUCCESS;
+    }
+
+    VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
+    if(m_MapCount != 0)
+    {
+        m_MapCount += count;
+        VMA_ASSERT(m_pMappedData != VMA_NULL);
+        if(ppData != VMA_NULL)
+        {
+            *ppData = m_pMappedData;
+        }
+        return VK_SUCCESS;
+    }
+    else
+    {
+        VkResult result = (*hAllocator->GetVulkanFunctions().vkMapMemory)(
+            hAllocator->m_hDevice,
+            m_hMemory,
+            0, // offset
+            VK_WHOLE_SIZE,
+            0, // flags
+            &m_pMappedData);
+        if(result == VK_SUCCESS)
+        {
+            if(ppData != VMA_NULL)
+            {
+                *ppData = m_pMappedData;
+            }
+            m_MapCount = count;
+        }
+        return result;
+    }
+}
+
+void VmaDeviceMemoryBlock::Unmap(VmaAllocator hAllocator, uint32_t count)
+{
+    if(count == 0)
+    {
+        return;
+    }
+
+    VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
+    if(m_MapCount >= count)
+    {
+        m_MapCount -= count;
+        if(m_MapCount == 0)
+        {
+            m_pMappedData = VMA_NULL;
+            (*hAllocator->GetVulkanFunctions().vkUnmapMemory)(hAllocator->m_hDevice, m_hMemory);
+        }
+    }
+    else
+    {
+        VMA_ASSERT(0 && "VkDeviceMemory block is being unmapped while it was not previously mapped.");
+    }
+}
+
+VkResult VmaDeviceMemoryBlock::WriteMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize)
+{
+    VMA_ASSERT(VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_MARGIN % 4 == 0 && VMA_DEBUG_DETECT_CORRUPTION);
+    VMA_ASSERT(allocOffset >= VMA_DEBUG_MARGIN);
+
+    void* pData;
+    VkResult res = Map(hAllocator, 1, &pData);
+    if(res != VK_SUCCESS)
+    {
+        return res;
+    }
+
+    VmaWriteMagicValue(pData, allocOffset - VMA_DEBUG_MARGIN);
+    VmaWriteMagicValue(pData, allocOffset + allocSize);
+
+    Unmap(hAllocator, 1);
+
+    return VK_SUCCESS;
+}
+
+VkResult VmaDeviceMemoryBlock::ValidateMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize)
+{
+    VMA_ASSERT(VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_MARGIN % 4 == 0 && VMA_DEBUG_DETECT_CORRUPTION);
+    VMA_ASSERT(allocOffset >= VMA_DEBUG_MARGIN);
+
+    void* pData;
+    VkResult res = Map(hAllocator, 1, &pData);
+    if(res != VK_SUCCESS)
+    {
+        return res;
+    }
+
+    if(!VmaValidateMagicValue(pData, allocOffset - VMA_DEBUG_MARGIN))
+    {
+        VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE FREED ALLOCATION!");
+    }
+    else if(!VmaValidateMagicValue(pData, allocOffset + allocSize))
+    {
+        VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER FREED ALLOCATION!");
+    }
+
+    Unmap(hAllocator, 1);
+
+    return VK_SUCCESS;
+}
+
+VkResult VmaDeviceMemoryBlock::BindBufferMemory(
+    const VmaAllocator hAllocator,
+    const VmaAllocation hAllocation,
+    VkDeviceSize allocationLocalOffset,
+    VkBuffer hBuffer,
+    const void* pNext)
+{
+    VMA_ASSERT(hAllocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK &&
+        hAllocation->GetBlock() == this);
+    VMA_ASSERT(allocationLocalOffset < hAllocation->GetSize() &&
+        "Invalid allocationLocalOffset. Did you forget that this offset is relative to the beginning of the allocation, not the whole memory block?");
+    const VkDeviceSize memoryOffset = hAllocation->GetOffset() + allocationLocalOffset;
+    // This lock is important so that we don't call vkBind... and/or vkMap... simultaneously on the same VkDeviceMemory from multiple threads.
+    VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
+    return hAllocator->BindVulkanBuffer(m_hMemory, memoryOffset, hBuffer, pNext);
+}
+
+VkResult VmaDeviceMemoryBlock::BindImageMemory(
+    const VmaAllocator hAllocator,
+    const VmaAllocation hAllocation,
+    VkDeviceSize allocationLocalOffset,
+    VkImage hImage,
+    const void* pNext)
+{
+    VMA_ASSERT(hAllocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK &&
+        hAllocation->GetBlock() == this);
+    VMA_ASSERT(allocationLocalOffset < hAllocation->GetSize() &&
+        "Invalid allocationLocalOffset. Did you forget that this offset is relative to the beginning of the allocation, not the whole memory block?");
+    const VkDeviceSize memoryOffset = hAllocation->GetOffset() + allocationLocalOffset;
+    // This lock is important so that we don't call vkBind... and/or vkMap... simultaneously on the same VkDeviceMemory from multiple threads.
+    VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
+    return hAllocator->BindVulkanImage(m_hMemory, memoryOffset, hImage, pNext);
+}
+
+static void InitStatInfo(VmaStatInfo& outInfo)
+{
+    memset(&outInfo, 0, sizeof(outInfo));
+    outInfo.allocationSizeMin = UINT64_MAX;
+    outInfo.unusedRangeSizeMin = UINT64_MAX;
+}
+
+// Adds statistics srcInfo into inoutInfo, like: inoutInfo += srcInfo.
+static void VmaAddStatInfo(VmaStatInfo& inoutInfo, const VmaStatInfo& srcInfo)
+{
+    inoutInfo.blockCount += srcInfo.blockCount;
+    inoutInfo.allocationCount += srcInfo.allocationCount;
+    inoutInfo.unusedRangeCount += srcInfo.unusedRangeCount;
+    inoutInfo.usedBytes += srcInfo.usedBytes;
+    inoutInfo.unusedBytes += srcInfo.unusedBytes;
+    inoutInfo.allocationSizeMin = VMA_MIN(inoutInfo.allocationSizeMin, srcInfo.allocationSizeMin);
+    inoutInfo.allocationSizeMax = VMA_MAX(inoutInfo.allocationSizeMax, srcInfo.allocationSizeMax);
+    inoutInfo.unusedRangeSizeMin = VMA_MIN(inoutInfo.unusedRangeSizeMin, srcInfo.unusedRangeSizeMin);
+    inoutInfo.unusedRangeSizeMax = VMA_MAX(inoutInfo.unusedRangeSizeMax, srcInfo.unusedRangeSizeMax);
+}
+
+static void VmaPostprocessCalcStatInfo(VmaStatInfo& inoutInfo)
+{
+    inoutInfo.allocationSizeAvg = (inoutInfo.allocationCount > 0) ?
+        VmaRoundDiv<VkDeviceSize>(inoutInfo.usedBytes, inoutInfo.allocationCount) : 0;
+    inoutInfo.unusedRangeSizeAvg = (inoutInfo.unusedRangeCount > 0) ?
+        VmaRoundDiv<VkDeviceSize>(inoutInfo.unusedBytes, inoutInfo.unusedRangeCount) : 0;
+}
+
+VmaPool_T::VmaPool_T(
+    VmaAllocator hAllocator,
+    const VmaPoolCreateInfo& createInfo,
+    VkDeviceSize preferredBlockSize) :
+    m_BlockVector(
+        hAllocator,
+        this, // hParentPool
+        createInfo.memoryTypeIndex,
+        createInfo.blockSize != 0 ? createInfo.blockSize : preferredBlockSize,
+        createInfo.minBlockCount,
+        createInfo.maxBlockCount,
+        (createInfo.flags & VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT) != 0 ? 1 : hAllocator->GetBufferImageGranularity(),
+        createInfo.frameInUseCount,
+        createInfo.blockSize != 0, // explicitBlockSize
+        createInfo.flags & VMA_POOL_CREATE_ALGORITHM_MASK,
+        createInfo.priority), // algorithm
+    m_Id(0),
+    m_Name(VMA_NULL)
+{
+}
+
+VmaPool_T::~VmaPool_T()
+{
+}
+
+void VmaPool_T::SetName(const char* pName)
+{
+    const VkAllocationCallbacks* allocs = m_BlockVector.GetAllocator()->GetAllocationCallbacks();
+    VmaFreeString(allocs, m_Name);
+
+    if(pName != VMA_NULL)
+    {
+        m_Name = VmaCreateStringCopy(allocs, pName);
+    }
+    else
+    {
+        m_Name = VMA_NULL;
+    }
+}
+
+#if VMA_STATS_STRING_ENABLED
+
+#endif // #if VMA_STATS_STRING_ENABLED
+
+VmaBlockVector::VmaBlockVector(
+    VmaAllocator hAllocator,
+    VmaPool hParentPool,
+    uint32_t memoryTypeIndex,
+    VkDeviceSize preferredBlockSize,
+    size_t minBlockCount,
+    size_t maxBlockCount,
+    VkDeviceSize bufferImageGranularity,
+    uint32_t frameInUseCount,
+    bool explicitBlockSize,
+    uint32_t algorithm,
+    float priority) :
+    m_hAllocator(hAllocator),
+    m_hParentPool(hParentPool),
+    m_MemoryTypeIndex(memoryTypeIndex),
+    m_PreferredBlockSize(preferredBlockSize),
+    m_MinBlockCount(minBlockCount),
+    m_MaxBlockCount(maxBlockCount),
+    m_BufferImageGranularity(bufferImageGranularity),
+    m_FrameInUseCount(frameInUseCount),
+    m_ExplicitBlockSize(explicitBlockSize),
+    m_Algorithm(algorithm),
+    m_Priority(priority),
+    m_HasEmptyBlock(false),
+    m_Blocks(VmaStlAllocator<VmaDeviceMemoryBlock*>(hAllocator->GetAllocationCallbacks())),
+    m_NextBlockId(0)
+{
+}
+
+VmaBlockVector::~VmaBlockVector()
+{
+    for(size_t i = m_Blocks.size(); i--; )
+    {
+        m_Blocks[i]->Destroy(m_hAllocator);
+        vma_delete(m_hAllocator, m_Blocks[i]);
+    }
+}
+
+VkResult VmaBlockVector::CreateMinBlocks()
+{
+    for(size_t i = 0; i < m_MinBlockCount; ++i)
+    {
+        VkResult res = CreateBlock(m_PreferredBlockSize, VMA_NULL);
+        if(res != VK_SUCCESS)
+        {
+            return res;
+        }
+    }
+    return VK_SUCCESS;
+}
+
+void VmaBlockVector::GetPoolStats(VmaPoolStats* pStats)
+{
+    VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);
+
+    const size_t blockCount = m_Blocks.size();
+
+    pStats->size = 0;
+    pStats->unusedSize = 0;
+    pStats->allocationCount = 0;
+    pStats->unusedRangeCount = 0;
+    pStats->unusedRangeSizeMax = 0;
+    pStats->blockCount = blockCount;
+
+    for(uint32_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
+    {
+        const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
+        VMA_ASSERT(pBlock);
+        VMA_HEAVY_ASSERT(pBlock->Validate());
+        pBlock->m_pMetadata->AddPoolStats(*pStats);
+    }
+}
+
+bool VmaBlockVector::IsEmpty()
+{
+    VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);
+    return m_Blocks.empty();
+}
+
+bool VmaBlockVector::IsCorruptionDetectionEnabled() const
+{
+    const uint32_t requiredMemFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+    return (VMA_DEBUG_DETECT_CORRUPTION != 0) &&
+        (VMA_DEBUG_MARGIN > 0) &&
+        (m_Algorithm == 0 || m_Algorithm == VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT) &&
+        (m_hAllocator->m_MemProps.memoryTypes[m_MemoryTypeIndex].propertyFlags & requiredMemFlags) == requiredMemFlags;
+}
+
+static const uint32_t VMA_ALLOCATION_TRY_COUNT = 32;
+
+VkResult VmaBlockVector::Allocate(
+    uint32_t currentFrameIndex,
+    VkDeviceSize size,
+    VkDeviceSize alignment,
+    const VmaAllocationCreateInfo& createInfo,
+    VmaSuballocationType suballocType,
+    size_t allocationCount,
+    VmaAllocation* pAllocations)
+{
+    size_t allocIndex;
+    VkResult res = VK_SUCCESS;
+
+    if(IsCorruptionDetectionEnabled())
+    {
+        size = VmaAlignUp<VkDeviceSize>(size, sizeof(VMA_CORRUPTION_DETECTION_MAGIC_VALUE));
+        alignment = VmaAlignUp<VkDeviceSize>(alignment, sizeof(VMA_CORRUPTION_DETECTION_MAGIC_VALUE));
+    }
+
+    {
+        VmaMutexLockWrite lock(m_Mutex, m_hAllocator->m_UseMutex);
+        for(allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
+        {
+            res = AllocatePage(
+                currentFrameIndex,
+                size,
+                alignment,
+                createInfo,
+                suballocType,
+                pAllocations + allocIndex);
+            if(res != VK_SUCCESS)
+            {
+                break;
+            }
+        }
+    }
+
+    if(res != VK_SUCCESS)
+    {
+        // Free all already created allocations.
+        while(allocIndex--)
+        {
+            Free(pAllocations[allocIndex]);
+        }
+        memset(pAllocations, 0, sizeof(VmaAllocation) * allocationCount);
+    }
+
+    return res;
+}
+
+VkResult VmaBlockVector::AllocatePage(
+    uint32_t currentFrameIndex,
+    VkDeviceSize size,
+    VkDeviceSize alignment,
+    const VmaAllocationCreateInfo& createInfo,
+    VmaSuballocationType suballocType,
+    VmaAllocation* pAllocation)
+{
+    const bool isUpperAddress = (createInfo.flags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0;
+    bool canMakeOtherLost = (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT) != 0;
+    const bool mapped = (createInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0;
+    const bool isUserDataString = (createInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0;
+
+    VkDeviceSize freeMemory;
+    {
+        const uint32_t heapIndex = m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex);
+        VmaBudget heapBudget = {};
+        m_hAllocator->GetBudget(&heapBudget, heapIndex, 1);
+        freeMemory = (heapBudget.usage < heapBudget.budget) ? (heapBudget.budget - heapBudget.usage) : 0;
+    }
+
+    const bool canFallbackToDedicated = !IsCustomPool();
+    const bool canCreateNewBlock =
+        ((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0) &&
+        (m_Blocks.size() < m_MaxBlockCount) &&
+        (freeMemory >= size || !canFallbackToDedicated);
+    uint32_t strategy = createInfo.flags & VMA_ALLOCATION_CREATE_STRATEGY_MASK;
+
+    // If linearAlgorithm is used, canMakeOtherLost is available only when used as ring buffer.
+    // Which in turn is available only when maxBlockCount = 1.
+    if(m_Algorithm == VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT && m_MaxBlockCount > 1)
+    {
+        canMakeOtherLost = false;
+    }
+
+    // Upper address can only be used with linear allocator and within single memory block.
+    if(isUpperAddress &&
+        (m_Algorithm != VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT || m_MaxBlockCount > 1))
+    {
+        return VK_ERROR_FEATURE_NOT_PRESENT;
+    }
+
+    // Validate strategy.
+    switch(strategy)
+    {
+    case 0:
+        strategy = VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT;
+        break;
+    case VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT:
+    case VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT:
+    case VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT:
+        break;
+    default:
+        return VK_ERROR_FEATURE_NOT_PRESENT;
+    }
+
+    // Early reject: requested allocation size is larger that maximum block size for this block vector.
+    if(size + 2 * VMA_DEBUG_MARGIN > m_PreferredBlockSize)
+    {
+        return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+    }
+
+    /*
+    Under certain condition, this whole section can be skipped for optimization, so
+    we move on directly to trying to allocate with canMakeOtherLost. That's the case
+    e.g. for custom pools with linear algorithm.
+    */
+    if(!canMakeOtherLost || canCreateNewBlock)
+    {
+        // 1. Search existing allocations. Try to allocate without making other allocations lost.
+        VmaAllocationCreateFlags allocFlagsCopy = createInfo.flags;
+        allocFlagsCopy &= ~VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT;
+
+        if(m_Algorithm == VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT)
+        {
+            // Use only last block.
+            if(!m_Blocks.empty())
+            {
+                VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks.back();
+                VMA_ASSERT(pCurrBlock);
+                VkResult res = AllocateFromBlock(
+                    pCurrBlock,
+                    currentFrameIndex,
+                    size,
+                    alignment,
+                    allocFlagsCopy,
+                    createInfo.pUserData,
+                    suballocType,
+                    strategy,
+                    pAllocation);
+                if(res == VK_SUCCESS)
+                {
+                    VMA_DEBUG_LOG("    Returned from last block #%u", pCurrBlock->GetId());
+                    return VK_SUCCESS;
+                }
+            }
+        }
+        else
+        {
+            if(strategy == VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT)
+            {
+                // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
+                for(size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex )
+                {
+                    VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
+                    VMA_ASSERT(pCurrBlock);
+                    VkResult res = AllocateFromBlock(
+                        pCurrBlock,
+                        currentFrameIndex,
+                        size,
+                        alignment,
+                        allocFlagsCopy,
+                        createInfo.pUserData,
+                        suballocType,
+                        strategy,
+                        pAllocation);
+                    if(res == VK_SUCCESS)
+                    {
+                        VMA_DEBUG_LOG("    Returned from existing block #%u", pCurrBlock->GetId());
+                        return VK_SUCCESS;
+                    }
+                }
+            }
+            else // WORST_FIT, FIRST_FIT
+            {
+                // Backward order in m_Blocks - prefer blocks with largest amount of free space.
+                for(size_t blockIndex = m_Blocks.size(); blockIndex--; )
+                {
+                    VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
+                    VMA_ASSERT(pCurrBlock);
+                    VkResult res = AllocateFromBlock(
+                        pCurrBlock,
+                        currentFrameIndex,
+                        size,
+                        alignment,
+                        allocFlagsCopy,
+                        createInfo.pUserData,
+                        suballocType,
+                        strategy,
+                        pAllocation);
+                    if(res == VK_SUCCESS)
+                    {
+                        VMA_DEBUG_LOG("    Returned from existing block #%u", pCurrBlock->GetId());
+                        return VK_SUCCESS;
+                    }
+                }
+            }
+        }
+
+        // 2. Try to create new block.
+        if(canCreateNewBlock)
+        {
+            // Calculate optimal size for new block.
+            VkDeviceSize newBlockSize = m_PreferredBlockSize;
+            uint32_t newBlockSizeShift = 0;
+            const uint32_t NEW_BLOCK_SIZE_SHIFT_MAX = 3;
+
+            if(!m_ExplicitBlockSize)
+            {
+                // Allocate 1/8, 1/4, 1/2 as first blocks.
+                const VkDeviceSize maxExistingBlockSize = CalcMaxBlockSize();
+                for(uint32_t i = 0; i < NEW_BLOCK_SIZE_SHIFT_MAX; ++i)
+                {
+                    const VkDeviceSize smallerNewBlockSize = newBlockSize / 2;
+                    if(smallerNewBlockSize > maxExistingBlockSize && smallerNewBlockSize >= size * 2)
+                    {
+                        newBlockSize = smallerNewBlockSize;
+                        ++newBlockSizeShift;
+                    }
+                    else
+                    {
+                        break;
+                    }
+                }
+            }
+
+            size_t newBlockIndex = 0;
+            VkResult res = (newBlockSize <= freeMemory || !canFallbackToDedicated) ?
+                CreateBlock(newBlockSize, &newBlockIndex) : VK_ERROR_OUT_OF_DEVICE_MEMORY;
+            // Allocation of this size failed? Try 1/2, 1/4, 1/8 of m_PreferredBlockSize.
+            if(!m_ExplicitBlockSize)
+            {
+                while(res < 0 && newBlockSizeShift < NEW_BLOCK_SIZE_SHIFT_MAX)
+                {
+                    const VkDeviceSize smallerNewBlockSize = newBlockSize / 2;
+                    if(smallerNewBlockSize >= size)
+                    {
+                        newBlockSize = smallerNewBlockSize;
+                        ++newBlockSizeShift;
+                        res = (newBlockSize <= freeMemory || !canFallbackToDedicated) ?
+                            CreateBlock(newBlockSize, &newBlockIndex) : VK_ERROR_OUT_OF_DEVICE_MEMORY;
+                    }
+                    else
+                    {
+                        break;
+                    }
+                }
+            }
+
+            if(res == VK_SUCCESS)
+            {
+                VmaDeviceMemoryBlock* const pBlock = m_Blocks[newBlockIndex];
+                VMA_ASSERT(pBlock->m_pMetadata->GetSize() >= size);
+
+                res = AllocateFromBlock(
+                    pBlock,
+                    currentFrameIndex,
+                    size,
+                    alignment,
+                    allocFlagsCopy,
+                    createInfo.pUserData,
+                    suballocType,
+                    strategy,
+                    pAllocation);
+                if(res == VK_SUCCESS)
+                {
+                    VMA_DEBUG_LOG("    Created new block #%u Size=%llu", pBlock->GetId(), newBlockSize);
+                    return VK_SUCCESS;
+                }
+                else
+                {
+                    // Allocation from new block failed, possibly due to VMA_DEBUG_MARGIN or alignment.
+                    return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+                }
+            }
+        }
+    }
+
+    // 3. Try to allocate from existing blocks with making other allocations lost.
+    if(canMakeOtherLost)
+    {
+        uint32_t tryIndex = 0;
+        for(; tryIndex < VMA_ALLOCATION_TRY_COUNT; ++tryIndex)
+        {
+            VmaDeviceMemoryBlock* pBestRequestBlock = VMA_NULL;
+            VmaAllocationRequest bestRequest = {};
+            VkDeviceSize bestRequestCost = VK_WHOLE_SIZE;
+
+            // 1. Search existing allocations.
+            if(strategy == VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT)
+            {
+                // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
+                for(size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex )
+                {
+                    VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
+                    VMA_ASSERT(pCurrBlock);
+                    VmaAllocationRequest currRequest = {};
+                    if(pCurrBlock->m_pMetadata->CreateAllocationRequest(
+                        currentFrameIndex,
+                        m_FrameInUseCount,
+                        m_BufferImageGranularity,
+                        size,
+                        alignment,
+                        (createInfo.flags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0,
+                        suballocType,
+                        canMakeOtherLost,
+                        strategy,
+                        &currRequest))
+                    {
+                        const VkDeviceSize currRequestCost = currRequest.CalcCost();
+                        if(pBestRequestBlock == VMA_NULL ||
+                            currRequestCost < bestRequestCost)
+                        {
+                            pBestRequestBlock = pCurrBlock;
+                            bestRequest = currRequest;
+                            bestRequestCost = currRequestCost;
+
+                            if(bestRequestCost == 0)
+                            {
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            else // WORST_FIT, FIRST_FIT
+            {
+                // Backward order in m_Blocks - prefer blocks with largest amount of free space.
+                for(size_t blockIndex = m_Blocks.size(); blockIndex--; )
+                {
+                    VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
+                    VMA_ASSERT(pCurrBlock);
+                    VmaAllocationRequest currRequest = {};
+                    if(pCurrBlock->m_pMetadata->CreateAllocationRequest(
+                        currentFrameIndex,
+                        m_FrameInUseCount,
+                        m_BufferImageGranularity,
+                        size,
+                        alignment,
+                        (createInfo.flags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0,
+                        suballocType,
+                        canMakeOtherLost,
+                        strategy,
+                        &currRequest))
+                    {
+                        const VkDeviceSize currRequestCost = currRequest.CalcCost();
+                        if(pBestRequestBlock == VMA_NULL ||
+                            currRequestCost < bestRequestCost ||
+                            strategy == VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT)
+                        {
+                            pBestRequestBlock = pCurrBlock;
+                            bestRequest = currRequest;
+                            bestRequestCost = currRequestCost;
+
+                            if(bestRequestCost == 0 ||
+                                strategy == VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT)
+                            {
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+
+            if(pBestRequestBlock != VMA_NULL)
+            {
+                if(mapped)
+                {
+                    VkResult res = pBestRequestBlock->Map(m_hAllocator, 1, VMA_NULL);
+                    if(res != VK_SUCCESS)
+                    {
+                        return res;
+                    }
+                }
+
+                if(pBestRequestBlock->m_pMetadata->MakeRequestedAllocationsLost(
+                    currentFrameIndex,
+                    m_FrameInUseCount,
+                    &bestRequest))
+                {
+                    // Allocate from this pBlock.
+                    *pAllocation = m_hAllocator->m_AllocationObjectAllocator.Allocate(currentFrameIndex, isUserDataString);
+                    pBestRequestBlock->m_pMetadata->Alloc(bestRequest, suballocType, size, *pAllocation);
+                    UpdateHasEmptyBlock();
+                    (*pAllocation)->InitBlockAllocation(
+                        pBestRequestBlock,
+                        bestRequest.offset,
+                        alignment,
+                        size,
+                        m_MemoryTypeIndex,
+                        suballocType,
+                        mapped,
+                        (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
+                    VMA_HEAVY_ASSERT(pBestRequestBlock->Validate());
+                    VMA_DEBUG_LOG("    Returned from existing block");
+                    (*pAllocation)->SetUserData(m_hAllocator, createInfo.pUserData);
+                    m_hAllocator->m_Budget.AddAllocation(m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex), size);
+                    if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
+                    {
+                        m_hAllocator->FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
+                    }
+                    if(IsCorruptionDetectionEnabled())
+                    {
+                        VkResult res = pBestRequestBlock->WriteMagicValueAroundAllocation(m_hAllocator, bestRequest.offset, size);
+                        VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to write magic value.");
+                    }
+                    return VK_SUCCESS;
+                }
+                // else: Some allocations must have been touched while we are here. Next try.
+            }
+            else
+            {
+                // Could not find place in any of the blocks - break outer loop.
+                break;
+            }
+        }
+        /* Maximum number of tries exceeded - a very unlike event when many other
+        threads are simultaneously touching allocations making it impossible to make
+        lost at the same time as we try to allocate. */
+        if(tryIndex == VMA_ALLOCATION_TRY_COUNT)
+        {
+            return VK_ERROR_TOO_MANY_OBJECTS;
+        }
+    }
+
+    return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+}
+
+void VmaBlockVector::Free(
+    const VmaAllocation hAllocation)
+{
+    VmaDeviceMemoryBlock* pBlockToDelete = VMA_NULL;
+
+    bool budgetExceeded = false;
+    {
+        const uint32_t heapIndex = m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex);
+        VmaBudget heapBudget = {};
+        m_hAllocator->GetBudget(&heapBudget, heapIndex, 1);
+        budgetExceeded = heapBudget.usage >= heapBudget.budget;
+    }
+
+    // Scope for lock.
+    {
+        VmaMutexLockWrite lock(m_Mutex, m_hAllocator->m_UseMutex);
+
+        VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
+
+        if(IsCorruptionDetectionEnabled())
+        {
+            VkResult res = pBlock->ValidateMagicValueAroundAllocation(m_hAllocator, hAllocation->GetOffset(), hAllocation->GetSize());
+            VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to validate magic value.");
+        }
+
+        if(hAllocation->IsPersistentMap())
+        {
+            pBlock->Unmap(m_hAllocator, 1);
+        }
+
+        pBlock->m_pMetadata->Free(hAllocation);
+        VMA_HEAVY_ASSERT(pBlock->Validate());
+
+        VMA_DEBUG_LOG("  Freed from MemoryTypeIndex=%u", m_MemoryTypeIndex);
+
+        const bool canDeleteBlock = m_Blocks.size() > m_MinBlockCount;
+        // pBlock became empty after this deallocation.
+        if(pBlock->m_pMetadata->IsEmpty())
+        {
+            // Already has empty block. We don't want to have two, so delete this one.
+            if((m_HasEmptyBlock || budgetExceeded) && canDeleteBlock)
+            {
+                pBlockToDelete = pBlock;
+                Remove(pBlock);
+            }
+            // else: We now have an empty block - leave it.
+        }
+        // pBlock didn't become empty, but we have another empty block - find and free that one.
+        // (This is optional, heuristics.)
+        else if(m_HasEmptyBlock && canDeleteBlock)
+        {
+            VmaDeviceMemoryBlock* pLastBlock = m_Blocks.back();
+            if(pLastBlock->m_pMetadata->IsEmpty())
+            {
+                pBlockToDelete = pLastBlock;
+                m_Blocks.pop_back();
+            }
+        }
+
+        UpdateHasEmptyBlock();
+        IncrementallySortBlocks();
+    }
+
+    // Destruction of a free block. Deferred until this point, outside of mutex
+    // lock, for performance reason.
+    if(pBlockToDelete != VMA_NULL)
+    {
+        VMA_DEBUG_LOG("    Deleted empty block");
+        pBlockToDelete->Destroy(m_hAllocator);
+        vma_delete(m_hAllocator, pBlockToDelete);
+    }
+}
+
+VkDeviceSize VmaBlockVector::CalcMaxBlockSize() const
+{
+    VkDeviceSize result = 0;
+    for(size_t i = m_Blocks.size(); i--; )
+    {
+        result = VMA_MAX(result, m_Blocks[i]->m_pMetadata->GetSize());
+        if(result >= m_PreferredBlockSize)
+        {
+            break;
+        }
+    }
+    return result;
+}
+
+void VmaBlockVector::Remove(VmaDeviceMemoryBlock* pBlock)
+{
+    for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
+    {
+        if(m_Blocks[blockIndex] == pBlock)
+        {
+            VmaVectorRemove(m_Blocks, blockIndex);
+            return;
+        }
+    }
+    VMA_ASSERT(0);
+}
+
+void VmaBlockVector::IncrementallySortBlocks()
+{
+    if(m_Algorithm != VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT)
+    {
+        // Bubble sort only until first swap.
+        for(size_t i = 1; i < m_Blocks.size(); ++i)
+        {
+            if(m_Blocks[i - 1]->m_pMetadata->GetSumFreeSize() > m_Blocks[i]->m_pMetadata->GetSumFreeSize())
+            {
+                VMA_SWAP(m_Blocks[i - 1], m_Blocks[i]);
+                return;
+            }
+        }
+    }
+}
+
+VkResult VmaBlockVector::AllocateFromBlock(
+    VmaDeviceMemoryBlock* pBlock,
+    uint32_t currentFrameIndex,
+    VkDeviceSize size,
+    VkDeviceSize alignment,
+    VmaAllocationCreateFlags allocFlags,
+    void* pUserData,
+    VmaSuballocationType suballocType,
+    uint32_t strategy,
+    VmaAllocation* pAllocation)
+{
+    VMA_ASSERT((allocFlags & VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT) == 0);
+    const bool isUpperAddress = (allocFlags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0;
+    const bool mapped = (allocFlags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0;
+    const bool isUserDataString = (allocFlags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0;
+
+    VmaAllocationRequest currRequest = {};
+    if(pBlock->m_pMetadata->CreateAllocationRequest(
+        currentFrameIndex,
+        m_FrameInUseCount,
+        m_BufferImageGranularity,
+        size,
+        alignment,
+        isUpperAddress,
+        suballocType,
+        false, // canMakeOtherLost
+        strategy,
+        &currRequest))
+    {
+        // Allocate from pCurrBlock.
+        VMA_ASSERT(currRequest.itemsToMakeLostCount == 0);
+
+        if(mapped)
+        {
+            VkResult res = pBlock->Map(m_hAllocator, 1, VMA_NULL);
+            if(res != VK_SUCCESS)
+            {
+                return res;
+            }
+        }
+
+        *pAllocation = m_hAllocator->m_AllocationObjectAllocator.Allocate(currentFrameIndex, isUserDataString);
+        pBlock->m_pMetadata->Alloc(currRequest, suballocType, size, *pAllocation);
+        UpdateHasEmptyBlock();
+        (*pAllocation)->InitBlockAllocation(
+            pBlock,
+            currRequest.offset,
+            alignment,
+            size,
+            m_MemoryTypeIndex,
+            suballocType,
+            mapped,
+            (allocFlags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
+        VMA_HEAVY_ASSERT(pBlock->Validate());
+        (*pAllocation)->SetUserData(m_hAllocator, pUserData);
+        m_hAllocator->m_Budget.AddAllocation(m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex), size);
+        if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
+        {
+            m_hAllocator->FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
+        }
+        if(IsCorruptionDetectionEnabled())
+        {
+            VkResult res = pBlock->WriteMagicValueAroundAllocation(m_hAllocator, currRequest.offset, size);
+            VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to write magic value.");
+        }
+        return VK_SUCCESS;
+    }
+    return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+}
+
+VkResult VmaBlockVector::CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex)
+{
+    VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
+    allocInfo.memoryTypeIndex = m_MemoryTypeIndex;
+    allocInfo.allocationSize = blockSize;
+
+#if VMA_BUFFER_DEVICE_ADDRESS
+    // Every standalone block can potentially contain a buffer with VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT - always enable the feature.
+    VkMemoryAllocateFlagsInfoKHR allocFlagsInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR };
+    if(m_hAllocator->m_UseKhrBufferDeviceAddress)
+    {
+        allocFlagsInfo.flags = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR;
+        VmaPnextChainPushFront(&allocInfo, &allocFlagsInfo);
+    }
+#endif // #if VMA_BUFFER_DEVICE_ADDRESS
+
+#if VMA_MEMORY_PRIORITY
+    VkMemoryPriorityAllocateInfoEXT priorityInfo = { VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT };
+    if(m_hAllocator->m_UseExtMemoryPriority)
+    {
+        priorityInfo.priority = m_Priority;
+        VmaPnextChainPushFront(&allocInfo, &priorityInfo);
+    }
+#endif // #if VMA_MEMORY_PRIORITY
+
+    VkDeviceMemory mem = VK_NULL_HANDLE;
+    VkResult res = m_hAllocator->AllocateVulkanMemory(&allocInfo, &mem);
+    if(res < 0)
+    {
+        return res;
+    }
+
+    // New VkDeviceMemory successfully created.
+
+    // Create new Allocation for it.
+    VmaDeviceMemoryBlock* const pBlock = vma_new(m_hAllocator, VmaDeviceMemoryBlock)(m_hAllocator);
+    pBlock->Init(
+        m_hAllocator,
+        m_hParentPool,
+        m_MemoryTypeIndex,
+        mem,
+        allocInfo.allocationSize,
+        m_NextBlockId++,
+        m_Algorithm);
+
+    m_Blocks.push_back(pBlock);
+    if(pNewBlockIndex != VMA_NULL)
+    {
+        *pNewBlockIndex = m_Blocks.size() - 1;
+    }
+
+    return VK_SUCCESS;
+}
+
+void VmaBlockVector::ApplyDefragmentationMovesCpu(
+    class VmaBlockVectorDefragmentationContext* pDefragCtx,
+    const VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves)
+{
+    const size_t blockCount = m_Blocks.size();
+    const bool isNonCoherent = m_hAllocator->IsMemoryTypeNonCoherent(m_MemoryTypeIndex);
+
+    enum BLOCK_FLAG
+    {
+        BLOCK_FLAG_USED = 0x00000001,
+        BLOCK_FLAG_MAPPED_FOR_DEFRAGMENTATION = 0x00000002,
+    };
+
+    struct BlockInfo
+    {
+        uint32_t flags;
+        void* pMappedData;
+    };
+    VmaVector< BlockInfo, VmaStlAllocator<BlockInfo> >
+        blockInfo(blockCount, BlockInfo(), VmaStlAllocator<BlockInfo>(m_hAllocator->GetAllocationCallbacks()));
+    memset(blockInfo.data(), 0, blockCount * sizeof(BlockInfo));
+
+    // Go over all moves. Mark blocks that are used with BLOCK_FLAG_USED.
+    const size_t moveCount = moves.size();
+    for(size_t moveIndex = 0; moveIndex < moveCount; ++moveIndex)
+    {
+        const VmaDefragmentationMove& move = moves[moveIndex];
+        blockInfo[move.srcBlockIndex].flags |= BLOCK_FLAG_USED;
+        blockInfo[move.dstBlockIndex].flags |= BLOCK_FLAG_USED;
+    }
+
+    VMA_ASSERT(pDefragCtx->res == VK_SUCCESS);
+
+    // Go over all blocks. Get mapped pointer or map if necessary.
+    for(size_t blockIndex = 0; pDefragCtx->res == VK_SUCCESS && blockIndex < blockCount; ++blockIndex)
+    {
+        BlockInfo& currBlockInfo = blockInfo[blockIndex];
+        VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];
+        if((currBlockInfo.flags & BLOCK_FLAG_USED) != 0)
+        {
+            currBlockInfo.pMappedData = pBlock->GetMappedData();
+            // It is not originally mapped - map it.
+            if(currBlockInfo.pMappedData == VMA_NULL)
+            {
+                pDefragCtx->res = pBlock->Map(m_hAllocator, 1, &currBlockInfo.pMappedData);
+                if(pDefragCtx->res == VK_SUCCESS)
+                {
+                    currBlockInfo.flags |= BLOCK_FLAG_MAPPED_FOR_DEFRAGMENTATION;
+                }
+            }
+        }
+    }
+
+    // Go over all moves. Do actual data transfer.
+    if(pDefragCtx->res == VK_SUCCESS)
+    {
+        const VkDeviceSize nonCoherentAtomSize = m_hAllocator->m_PhysicalDeviceProperties.limits.nonCoherentAtomSize;
+        VkMappedMemoryRange memRange = { VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE };
+
+        for(size_t moveIndex = 0; moveIndex < moveCount; ++moveIndex)
+        {
+            const VmaDefragmentationMove& move = moves[moveIndex];
+
+            const BlockInfo& srcBlockInfo = blockInfo[move.srcBlockIndex];
+            const BlockInfo& dstBlockInfo = blockInfo[move.dstBlockIndex];
+
+            VMA_ASSERT(srcBlockInfo.pMappedData && dstBlockInfo.pMappedData);
+
+            // Invalidate source.
+            if(isNonCoherent)
+            {
+                VmaDeviceMemoryBlock* const pSrcBlock = m_Blocks[move.srcBlockIndex];
+                memRange.memory = pSrcBlock->GetDeviceMemory();
+                memRange.offset = VmaAlignDown(move.srcOffset, nonCoherentAtomSize);
+                memRange.size = VMA_MIN(
+                    VmaAlignUp(move.size + (move.srcOffset - memRange.offset), nonCoherentAtomSize),
+                    pSrcBlock->m_pMetadata->GetSize() - memRange.offset);
+                (*m_hAllocator->GetVulkanFunctions().vkInvalidateMappedMemoryRanges)(m_hAllocator->m_hDevice, 1, &memRange);
+            }
+
+            // THE PLACE WHERE ACTUAL DATA COPY HAPPENS.
+            memmove(
+                reinterpret_cast<char*>(dstBlockInfo.pMappedData) + move.dstOffset,
+                reinterpret_cast<char*>(srcBlockInfo.pMappedData) + move.srcOffset,
+                static_cast<size_t>(move.size));
+
+            if(IsCorruptionDetectionEnabled())
+            {
+                VmaWriteMagicValue(dstBlockInfo.pMappedData, move.dstOffset - VMA_DEBUG_MARGIN);
+                VmaWriteMagicValue(dstBlockInfo.pMappedData, move.dstOffset + move.size);
+            }
+
+            // Flush destination.
+            if(isNonCoherent)
+            {
+                VmaDeviceMemoryBlock* const pDstBlock = m_Blocks[move.dstBlockIndex];
+                memRange.memory = pDstBlock->GetDeviceMemory();
+                memRange.offset = VmaAlignDown(move.dstOffset, nonCoherentAtomSize);
+                memRange.size = VMA_MIN(
+                    VmaAlignUp(move.size + (move.dstOffset - memRange.offset), nonCoherentAtomSize),
+                    pDstBlock->m_pMetadata->GetSize() - memRange.offset);
+                (*m_hAllocator->GetVulkanFunctions().vkFlushMappedMemoryRanges)(m_hAllocator->m_hDevice, 1, &memRange);
+            }
+        }
+    }
+
+    // Go over all blocks in reverse order. Unmap those that were mapped just for defragmentation.
+    // Regardless of pCtx->res == VK_SUCCESS.
+    for(size_t blockIndex = blockCount; blockIndex--; )
+    {
+        const BlockInfo& currBlockInfo = blockInfo[blockIndex];
+        if((currBlockInfo.flags & BLOCK_FLAG_MAPPED_FOR_DEFRAGMENTATION) != 0)
+        {
+            VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];
+            pBlock->Unmap(m_hAllocator, 1);
+        }
+    }
+}
+
+void VmaBlockVector::ApplyDefragmentationMovesGpu(
+    class VmaBlockVectorDefragmentationContext* pDefragCtx,
+    VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
+    VkCommandBuffer commandBuffer)
+{
+    const size_t blockCount = m_Blocks.size();
+
+    pDefragCtx->blockContexts.resize(blockCount);
+    memset(pDefragCtx->blockContexts.data(), 0, blockCount * sizeof(VmaBlockDefragmentationContext));
+
+    // Go over all moves. Mark blocks that are used with BLOCK_FLAG_USED.
+    const size_t moveCount = moves.size();
+    for(size_t moveIndex = 0; moveIndex < moveCount; ++moveIndex)
+    {
+        const VmaDefragmentationMove& move = moves[moveIndex];
+
+        //if(move.type == VMA_ALLOCATION_TYPE_UNKNOWN)
+        {
+            // Old school move still require us to map the whole block
+            pDefragCtx->blockContexts[move.srcBlockIndex].flags |= VmaBlockDefragmentationContext::BLOCK_FLAG_USED;
+            pDefragCtx->blockContexts[move.dstBlockIndex].flags |= VmaBlockDefragmentationContext::BLOCK_FLAG_USED;
+        }
+    }
+
+    VMA_ASSERT(pDefragCtx->res == VK_SUCCESS);
+
+    // Go over all blocks. Create and bind buffer for whole block if necessary.
+    {
+        VkBufferCreateInfo bufCreateInfo;
+        VmaFillGpuDefragmentationBufferCreateInfo(bufCreateInfo);
+
+        for(size_t blockIndex = 0; pDefragCtx->res == VK_SUCCESS && blockIndex < blockCount; ++blockIndex)
+        {
+            VmaBlockDefragmentationContext& currBlockCtx = pDefragCtx->blockContexts[blockIndex];
+            VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];
+            if((currBlockCtx.flags & VmaBlockDefragmentationContext::BLOCK_FLAG_USED) != 0)
+            {
+                bufCreateInfo.size = pBlock->m_pMetadata->GetSize();
+                pDefragCtx->res = (*m_hAllocator->GetVulkanFunctions().vkCreateBuffer)(
+                    m_hAllocator->m_hDevice, &bufCreateInfo, m_hAllocator->GetAllocationCallbacks(), &currBlockCtx.hBuffer);
+                if(pDefragCtx->res == VK_SUCCESS)
+                {
+                    pDefragCtx->res = (*m_hAllocator->GetVulkanFunctions().vkBindBufferMemory)(
+                        m_hAllocator->m_hDevice, currBlockCtx.hBuffer, pBlock->GetDeviceMemory(), 0);
+                }
+            }
+        }
+    }
+
+    // Go over all moves. Post data transfer commands to command buffer.
+    if(pDefragCtx->res == VK_SUCCESS)
+    {
+        for(size_t moveIndex = 0; moveIndex < moveCount; ++moveIndex)
+        {
+            const VmaDefragmentationMove& move = moves[moveIndex];
+
+            const VmaBlockDefragmentationContext& srcBlockCtx = pDefragCtx->blockContexts[move.srcBlockIndex];
+            const VmaBlockDefragmentationContext& dstBlockCtx = pDefragCtx->blockContexts[move.dstBlockIndex];
+
+            VMA_ASSERT(srcBlockCtx.hBuffer && dstBlockCtx.hBuffer);
+
+            VkBufferCopy region = {
+                move.srcOffset,
+                move.dstOffset,
+                move.size };
+            (*m_hAllocator->GetVulkanFunctions().vkCmdCopyBuffer)(
+                commandBuffer, srcBlockCtx.hBuffer, dstBlockCtx.hBuffer, 1, &region);
+        }
+    }
+
+    // Save buffers to defrag context for later destruction.
+    if(pDefragCtx->res == VK_SUCCESS && moveCount > 0)
+    {
+        pDefragCtx->res = VK_NOT_READY;
+    }
+}
+
+void VmaBlockVector::FreeEmptyBlocks(VmaDefragmentationStats* pDefragmentationStats)
+{
+    for(size_t blockIndex = m_Blocks.size(); blockIndex--; )
+    {
+        VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];
+        if(pBlock->m_pMetadata->IsEmpty())
+        {
+            if(m_Blocks.size() > m_MinBlockCount)
+            {
+                if(pDefragmentationStats != VMA_NULL)
+                {
+                    ++pDefragmentationStats->deviceMemoryBlocksFreed;
+                    pDefragmentationStats->bytesFreed += pBlock->m_pMetadata->GetSize();
+                }
+
+                VmaVectorRemove(m_Blocks, blockIndex);
+                pBlock->Destroy(m_hAllocator);
+                vma_delete(m_hAllocator, pBlock);
+            }
+            else
+            {
+                break;
+            }
+        }
+    }
+    UpdateHasEmptyBlock();
+}
+
+void VmaBlockVector::UpdateHasEmptyBlock()
+{
+    m_HasEmptyBlock = false;
+    for(size_t index = 0, count = m_Blocks.size(); index < count; ++index)
+    {
+        VmaDeviceMemoryBlock* const pBlock = m_Blocks[index];
+        if(pBlock->m_pMetadata->IsEmpty())
+        {
+            m_HasEmptyBlock = true;
+            break;
+        }
+    }
+}
+
+#if VMA_STATS_STRING_ENABLED
+
+void VmaBlockVector::PrintDetailedMap(class VmaJsonWriter& json)
+{
+    VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);
+
+    json.BeginObject();
+
+    if(IsCustomPool())
+    {
+        const char* poolName = m_hParentPool->GetName();
+        if(poolName != VMA_NULL && poolName[0] != '\0')
+        {
+            json.WriteString("Name");
+            json.WriteString(poolName);
+        }
+
+        json.WriteString("MemoryTypeIndex");
+        json.WriteNumber(m_MemoryTypeIndex);
+
+        json.WriteString("BlockSize");
+        json.WriteNumber(m_PreferredBlockSize);
+
+        json.WriteString("BlockCount");
+        json.BeginObject(true);
+        if(m_MinBlockCount > 0)
+        {
+            json.WriteString("Min");
+            json.WriteNumber((uint64_t)m_MinBlockCount);
+        }
+        if(m_MaxBlockCount < SIZE_MAX)
+        {
+            json.WriteString("Max");
+            json.WriteNumber((uint64_t)m_MaxBlockCount);
+        }
+        json.WriteString("Cur");
+        json.WriteNumber((uint64_t)m_Blocks.size());
+        json.EndObject();
+
+        if(m_FrameInUseCount > 0)
+        {
+            json.WriteString("FrameInUseCount");
+            json.WriteNumber(m_FrameInUseCount);
+        }
+
+        if(m_Algorithm != 0)
+        {
+            json.WriteString("Algorithm");
+            json.WriteString(VmaAlgorithmToStr(m_Algorithm));
+        }
+    }
+    else
+    {
+        json.WriteString("PreferredBlockSize");
+        json.WriteNumber(m_PreferredBlockSize);
+    }
+
+    json.WriteString("Blocks");
+    json.BeginObject();
+    for(size_t i = 0; i < m_Blocks.size(); ++i)
+    {
+        json.BeginString();
+        json.ContinueString(m_Blocks[i]->GetId());
+        json.EndString();
+
+        m_Blocks[i]->m_pMetadata->PrintDetailedMap(json);
+    }
+    json.EndObject();
+
+    json.EndObject();
+}
+
+#endif // #if VMA_STATS_STRING_ENABLED
+
+void VmaBlockVector::Defragment(
+    class VmaBlockVectorDefragmentationContext* pCtx,
+    VmaDefragmentationStats* pStats, VmaDefragmentationFlags flags,
+    VkDeviceSize& maxCpuBytesToMove, uint32_t& maxCpuAllocationsToMove,
+    VkDeviceSize& maxGpuBytesToMove, uint32_t& maxGpuAllocationsToMove,
+    VkCommandBuffer commandBuffer)
+{
+    pCtx->res = VK_SUCCESS;
+
+    const VkMemoryPropertyFlags memPropFlags =
+        m_hAllocator->m_MemProps.memoryTypes[m_MemoryTypeIndex].propertyFlags;
+    const bool isHostVisible = (memPropFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0;
+
+    const bool canDefragmentOnCpu = maxCpuBytesToMove > 0 && maxCpuAllocationsToMove > 0 &&
+        isHostVisible;
+    const bool canDefragmentOnGpu = maxGpuBytesToMove > 0 && maxGpuAllocationsToMove > 0 &&
+        !IsCorruptionDetectionEnabled() &&
+        ((1u << m_MemoryTypeIndex) & m_hAllocator->GetGpuDefragmentationMemoryTypeBits()) != 0;
+
+    // There are options to defragment this memory type.
+    if(canDefragmentOnCpu || canDefragmentOnGpu)
+    {
+        bool defragmentOnGpu;
+        // There is only one option to defragment this memory type.
+        if(canDefragmentOnGpu != canDefragmentOnCpu)
+        {
+            defragmentOnGpu = canDefragmentOnGpu;
+        }
+        // Both options are available: Heuristics to choose the best one.
+        else
+        {
+            defragmentOnGpu = (memPropFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0 ||
+                m_hAllocator->IsIntegratedGpu();
+        }
+
+        bool overlappingMoveSupported = !defragmentOnGpu;
+
+        if(m_hAllocator->m_UseMutex)
+        {
+            if(flags & VMA_DEFRAGMENTATION_FLAG_INCREMENTAL)
+            {
+                if(!m_Mutex.TryLockWrite())
+                {
+                    pCtx->res = VK_ERROR_INITIALIZATION_FAILED;
+                    return;
+                }
+            }
+            else
+            {
+                m_Mutex.LockWrite();
+                pCtx->mutexLocked = true;
+            }
+        }
+
+        pCtx->Begin(overlappingMoveSupported, flags);
+
+        // Defragment.
+
+        const VkDeviceSize maxBytesToMove = defragmentOnGpu ? maxGpuBytesToMove : maxCpuBytesToMove;
+        const uint32_t maxAllocationsToMove = defragmentOnGpu ? maxGpuAllocationsToMove : maxCpuAllocationsToMove;
+        pCtx->res = pCtx->GetAlgorithm()->Defragment(pCtx->defragmentationMoves, maxBytesToMove, maxAllocationsToMove, flags);
+
+        // Accumulate statistics.
+        if(pStats != VMA_NULL)
+        {
+            const VkDeviceSize bytesMoved = pCtx->GetAlgorithm()->GetBytesMoved();
+            const uint32_t allocationsMoved = pCtx->GetAlgorithm()->GetAllocationsMoved();
+            pStats->bytesMoved += bytesMoved;
+            pStats->allocationsMoved += allocationsMoved;
+            VMA_ASSERT(bytesMoved <= maxBytesToMove);
+            VMA_ASSERT(allocationsMoved <= maxAllocationsToMove);
+            if(defragmentOnGpu)
+            {
+                maxGpuBytesToMove -= bytesMoved;
+                maxGpuAllocationsToMove -= allocationsMoved;
+            }
+            else
+            {
+                maxCpuBytesToMove -= bytesMoved;
+                maxCpuAllocationsToMove -= allocationsMoved;
+            }
+        }
+
+        if(flags & VMA_DEFRAGMENTATION_FLAG_INCREMENTAL)
+        {
+            if(m_hAllocator->m_UseMutex)
+                m_Mutex.UnlockWrite();
+
+            if(pCtx->res >= VK_SUCCESS && !pCtx->defragmentationMoves.empty())
+                pCtx->res = VK_NOT_READY;
+
+            return;
+        }
+
+        if(pCtx->res >= VK_SUCCESS)
+        {
+            if(defragmentOnGpu)
+            {
+                ApplyDefragmentationMovesGpu(pCtx, pCtx->defragmentationMoves, commandBuffer);
+            }
+            else
+            {
+                ApplyDefragmentationMovesCpu(pCtx, pCtx->defragmentationMoves);
+            }
+        }
+    }
+}
+
+void VmaBlockVector::DefragmentationEnd(
+    class VmaBlockVectorDefragmentationContext* pCtx,
+    uint32_t flags,
+    VmaDefragmentationStats* pStats)
+{
+    if(flags & VMA_DEFRAGMENTATION_FLAG_INCREMENTAL && m_hAllocator->m_UseMutex)
+    {
+        VMA_ASSERT(pCtx->mutexLocked == false);
+
+        // Incremental defragmentation doesn't hold the lock, so when we enter here we don't actually have any
+        // lock protecting us. Since we mutate state here, we have to take the lock out now
+        m_Mutex.LockWrite();
+        pCtx->mutexLocked = true;
+    }
+
+    // If the mutex isn't locked we didn't do any work and there is nothing to delete.
+    if(pCtx->mutexLocked || !m_hAllocator->m_UseMutex)
+    {
+        // Destroy buffers.
+        for(size_t blockIndex = pCtx->blockContexts.size(); blockIndex--;)
+        {
+            VmaBlockDefragmentationContext &blockCtx = pCtx->blockContexts[blockIndex];
+            if(blockCtx.hBuffer)
+            {
+                (*m_hAllocator->GetVulkanFunctions().vkDestroyBuffer)(m_hAllocator->m_hDevice, blockCtx.hBuffer, m_hAllocator->GetAllocationCallbacks());
+            }
+        }
+
+        if(pCtx->res >= VK_SUCCESS)
+        {
+            FreeEmptyBlocks(pStats);
+        }
+    }
+
+    if(pCtx->mutexLocked)
+    {
+        VMA_ASSERT(m_hAllocator->m_UseMutex);
+        m_Mutex.UnlockWrite();
+    }
+}
+
+uint32_t VmaBlockVector::ProcessDefragmentations(
+    class VmaBlockVectorDefragmentationContext *pCtx,
+    VmaDefragmentationPassMoveInfo* pMove, uint32_t maxMoves)
+{
+    VmaMutexLockWrite lock(m_Mutex, m_hAllocator->m_UseMutex);
+
+    const uint32_t moveCount = VMA_MIN(uint32_t(pCtx->defragmentationMoves.size()) - pCtx->defragmentationMovesProcessed, maxMoves);
+
+    for(uint32_t i = 0; i < moveCount; ++ i)
+    {
+        VmaDefragmentationMove& move = pCtx->defragmentationMoves[pCtx->defragmentationMovesProcessed + i];
+
+        pMove->allocation = move.hAllocation;
+        pMove->memory = move.pDstBlock->GetDeviceMemory();
+        pMove->offset = move.dstOffset;
+
+        ++ pMove;
+    }
+
+    pCtx->defragmentationMovesProcessed += moveCount;
+
+    return moveCount;
+}
+
+void VmaBlockVector::CommitDefragmentations(
+    class VmaBlockVectorDefragmentationContext *pCtx,
+    VmaDefragmentationStats* pStats)
+{
+    VmaMutexLockWrite lock(m_Mutex, m_hAllocator->m_UseMutex);
+
+    for(uint32_t i = pCtx->defragmentationMovesCommitted; i < pCtx->defragmentationMovesProcessed; ++ i)
+    {
+        const VmaDefragmentationMove &move = pCtx->defragmentationMoves[i];
+
+        move.pSrcBlock->m_pMetadata->FreeAtOffset(move.srcOffset);
+        move.hAllocation->ChangeBlockAllocation(m_hAllocator, move.pDstBlock, move.dstOffset);
+    }
+
+    pCtx->defragmentationMovesCommitted = pCtx->defragmentationMovesProcessed;
+    FreeEmptyBlocks(pStats);
+}
+
+size_t VmaBlockVector::CalcAllocationCount() const
+{
+    size_t result = 0;
+    for(size_t i = 0; i < m_Blocks.size(); ++i)
+    {
+        result += m_Blocks[i]->m_pMetadata->GetAllocationCount();
+    }
+    return result;
+}
+
+bool VmaBlockVector::IsBufferImageGranularityConflictPossible() const
+{
+    if(m_BufferImageGranularity == 1)
+    {
+        return false;
+    }
+    VmaSuballocationType lastSuballocType = VMA_SUBALLOCATION_TYPE_FREE;
+    for(size_t i = 0, count = m_Blocks.size(); i < count; ++i)
+    {
+        VmaDeviceMemoryBlock* const pBlock = m_Blocks[i];
+        VMA_ASSERT(m_Algorithm == 0);
+        VmaBlockMetadata_Generic* const pMetadata = (VmaBlockMetadata_Generic*)pBlock->m_pMetadata;
+        if(pMetadata->IsBufferImageGranularityConflictPossible(m_BufferImageGranularity, lastSuballocType))
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+void VmaBlockVector::MakePoolAllocationsLost(
+    uint32_t currentFrameIndex,
+    size_t* pLostAllocationCount)
+{
+    VmaMutexLockWrite lock(m_Mutex, m_hAllocator->m_UseMutex);
+    size_t lostAllocationCount = 0;
+    for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
+    {
+        VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
+        VMA_ASSERT(pBlock);
+        lostAllocationCount += pBlock->m_pMetadata->MakeAllocationsLost(currentFrameIndex, m_FrameInUseCount);
+    }
+    if(pLostAllocationCount != VMA_NULL)
+    {
+        *pLostAllocationCount = lostAllocationCount;
+    }
+}
+
+VkResult VmaBlockVector::CheckCorruption()
+{
+    if(!IsCorruptionDetectionEnabled())
+    {
+        return VK_ERROR_FEATURE_NOT_PRESENT;
+    }
+
+    VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);
+    for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
+    {
+        VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
+        VMA_ASSERT(pBlock);
+        VkResult res = pBlock->CheckCorruption(m_hAllocator);
+        if(res != VK_SUCCESS)
+        {
+            return res;
+        }
+    }
+    return VK_SUCCESS;
+}
+
+void VmaBlockVector::AddStats(VmaStats* pStats)
+{
+    const uint32_t memTypeIndex = m_MemoryTypeIndex;
+    const uint32_t memHeapIndex = m_hAllocator->MemoryTypeIndexToHeapIndex(memTypeIndex);
+
+    VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);
+
+    for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
+    {
+        const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
+        VMA_ASSERT(pBlock);
+        VMA_HEAVY_ASSERT(pBlock->Validate());
+        VmaStatInfo allocationStatInfo;
+        pBlock->m_pMetadata->CalcAllocationStatInfo(allocationStatInfo);
+        VmaAddStatInfo(pStats->total, allocationStatInfo);
+        VmaAddStatInfo(pStats->memoryType[memTypeIndex], allocationStatInfo);
+        VmaAddStatInfo(pStats->memoryHeap[memHeapIndex], allocationStatInfo);
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// VmaDefragmentationAlgorithm_Generic members definition
+
+VmaDefragmentationAlgorithm_Generic::VmaDefragmentationAlgorithm_Generic(
+    VmaAllocator hAllocator,
+    VmaBlockVector* pBlockVector,
+    uint32_t currentFrameIndex,
+    bool overlappingMoveSupported) :
+    VmaDefragmentationAlgorithm(hAllocator, pBlockVector, currentFrameIndex),
+    m_AllocationCount(0),
+    m_AllAllocations(false),
+    m_BytesMoved(0),
+    m_AllocationsMoved(0),
+    m_Blocks(VmaStlAllocator<BlockInfo*>(hAllocator->GetAllocationCallbacks()))
+{
+    // Create block info for each block.
+    const size_t blockCount = m_pBlockVector->m_Blocks.size();
+    for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
+    {
+        BlockInfo* pBlockInfo = vma_new(m_hAllocator, BlockInfo)(m_hAllocator->GetAllocationCallbacks());
+        pBlockInfo->m_OriginalBlockIndex = blockIndex;
+        pBlockInfo->m_pBlock = m_pBlockVector->m_Blocks[blockIndex];
+        m_Blocks.push_back(pBlockInfo);
+    }
+
+    // Sort them by m_pBlock pointer value.
+    VMA_SORT(m_Blocks.begin(), m_Blocks.end(), BlockPointerLess());
+}
+
+VmaDefragmentationAlgorithm_Generic::~VmaDefragmentationAlgorithm_Generic()
+{
+    for(size_t i = m_Blocks.size(); i--; )
+    {
+        vma_delete(m_hAllocator, m_Blocks[i]);
+    }
+}
+
+void VmaDefragmentationAlgorithm_Generic::AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged)
+{
+    // Now as we are inside VmaBlockVector::m_Mutex, we can make final check if this allocation was not lost.
+    if(hAlloc->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST)
+    {
+        VmaDeviceMemoryBlock* pBlock = hAlloc->GetBlock();
+        BlockInfoVector::iterator it = VmaBinaryFindFirstNotLess(m_Blocks.begin(), m_Blocks.end(), pBlock, BlockPointerLess());
+        if(it != m_Blocks.end() && (*it)->m_pBlock == pBlock)
+        {
+            AllocationInfo allocInfo = AllocationInfo(hAlloc, pChanged);
+            (*it)->m_Allocations.push_back(allocInfo);
+        }
+        else
+        {
+            VMA_ASSERT(0);
+        }
+
+        ++m_AllocationCount;
+    }
+}
+
+VkResult VmaDefragmentationAlgorithm_Generic::DefragmentRound(
+    VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
+    VkDeviceSize maxBytesToMove,
+    uint32_t maxAllocationsToMove,
+    bool freeOldAllocations)
+{
+    if(m_Blocks.empty())
+    {
+        return VK_SUCCESS;
+    }
+
+    // This is a choice based on research.
+    // Option 1:
+    uint32_t strategy = VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT;
+    // Option 2:
+    //uint32_t strategy = VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT;
+    // Option 3:
+    //uint32_t strategy = VMA_ALLOCATION_CREATE_STRATEGY_MIN_FRAGMENTATION_BIT;
+
+    size_t srcBlockMinIndex = 0;
+    // When FAST_ALGORITHM, move allocations from only last out of blocks that contain non-movable allocations.
+    /*
+    if(m_AlgorithmFlags & VMA_DEFRAGMENTATION_FAST_ALGORITHM_BIT)
+    {
+        const size_t blocksWithNonMovableCount = CalcBlocksWithNonMovableCount();
+        if(blocksWithNonMovableCount > 0)
+        {
+            srcBlockMinIndex = blocksWithNonMovableCount - 1;
+        }
+    }
+    */
+
+    size_t srcBlockIndex = m_Blocks.size() - 1;
+    size_t srcAllocIndex = SIZE_MAX;
+    for(;;)
+    {
+        // 1. Find next allocation to move.
+        // 1.1. Start from last to first m_Blocks - they are sorted from most "destination" to most "source".
+        // 1.2. Then start from last to first m_Allocations.
+        while(srcAllocIndex >= m_Blocks[srcBlockIndex]->m_Allocations.size())
+        {
+            if(m_Blocks[srcBlockIndex]->m_Allocations.empty())
+            {
+                // Finished: no more allocations to process.
+                if(srcBlockIndex == srcBlockMinIndex)
+                {
+                    return VK_SUCCESS;
+                }
+                else
+                {
+                    --srcBlockIndex;
+                    srcAllocIndex = SIZE_MAX;
+                }
+            }
+            else
+            {
+                srcAllocIndex = m_Blocks[srcBlockIndex]->m_Allocations.size() - 1;
+            }
+        }
+
+        BlockInfo* pSrcBlockInfo = m_Blocks[srcBlockIndex];
+        AllocationInfo& allocInfo = pSrcBlockInfo->m_Allocations[srcAllocIndex];
+
+        const VkDeviceSize size = allocInfo.m_hAllocation->GetSize();
+        const VkDeviceSize srcOffset = allocInfo.m_hAllocation->GetOffset();
+        const VkDeviceSize alignment = allocInfo.m_hAllocation->GetAlignment();
+        const VmaSuballocationType suballocType = allocInfo.m_hAllocation->GetSuballocationType();
+
+        // 2. Try to find new place for this allocation in preceding or current block.
+        for(size_t dstBlockIndex = 0; dstBlockIndex <= srcBlockIndex; ++dstBlockIndex)
+        {
+            BlockInfo* pDstBlockInfo = m_Blocks[dstBlockIndex];
+            VmaAllocationRequest dstAllocRequest;
+            if(pDstBlockInfo->m_pBlock->m_pMetadata->CreateAllocationRequest(
+                m_CurrentFrameIndex,
+                m_pBlockVector->GetFrameInUseCount(),
+                m_pBlockVector->GetBufferImageGranularity(),
+                size,
+                alignment,
+                false, // upperAddress
+                suballocType,
+                false, // canMakeOtherLost
+                strategy,
+                &dstAllocRequest) &&
+            MoveMakesSense(
+                dstBlockIndex, dstAllocRequest.offset, srcBlockIndex, srcOffset))
+            {
+                VMA_ASSERT(dstAllocRequest.itemsToMakeLostCount == 0);
+
+                // Reached limit on number of allocations or bytes to move.
+                if((m_AllocationsMoved + 1 > maxAllocationsToMove) ||
+                    (m_BytesMoved + size > maxBytesToMove))
+                {
+                    return VK_SUCCESS;
+                }
+
+                VmaDefragmentationMove move = {};
+                move.srcBlockIndex = pSrcBlockInfo->m_OriginalBlockIndex;
+                move.dstBlockIndex = pDstBlockInfo->m_OriginalBlockIndex;
+                move.srcOffset = srcOffset;
+                move.dstOffset = dstAllocRequest.offset;
+                move.size = size;
+                move.hAllocation = allocInfo.m_hAllocation;
+                move.pSrcBlock = pSrcBlockInfo->m_pBlock;
+                move.pDstBlock = pDstBlockInfo->m_pBlock;
+
+                moves.push_back(move);
+
+                pDstBlockInfo->m_pBlock->m_pMetadata->Alloc(
+                    dstAllocRequest,
+                    suballocType,
+                    size,
+                    allocInfo.m_hAllocation);
+
+                if(freeOldAllocations)
+                {
+                    pSrcBlockInfo->m_pBlock->m_pMetadata->FreeAtOffset(srcOffset);
+                    allocInfo.m_hAllocation->ChangeBlockAllocation(m_hAllocator, pDstBlockInfo->m_pBlock, dstAllocRequest.offset);
+                }
+
+                if(allocInfo.m_pChanged != VMA_NULL)
+                {
+                    *allocInfo.m_pChanged = VK_TRUE;
+                }
+
+                ++m_AllocationsMoved;
+                m_BytesMoved += size;
+
+                VmaVectorRemove(pSrcBlockInfo->m_Allocations, srcAllocIndex);
+
+                break;
+            }
+        }
+
+        // If not processed, this allocInfo remains in pBlockInfo->m_Allocations for next round.
+
+        if(srcAllocIndex > 0)
+        {
+            --srcAllocIndex;
+        }
+        else
+        {
+            if(srcBlockIndex > 0)
+            {
+                --srcBlockIndex;
+                srcAllocIndex = SIZE_MAX;
+            }
+            else
+            {
+                return VK_SUCCESS;
+            }
+        }
+    }
+}
+
+size_t VmaDefragmentationAlgorithm_Generic::CalcBlocksWithNonMovableCount() const
+{
+    size_t result = 0;
+    for(size_t i = 0; i < m_Blocks.size(); ++i)
+    {
+        if(m_Blocks[i]->m_HasNonMovableAllocations)
+        {
+            ++result;
+        }
+    }
+    return result;
+}
+
+VkResult VmaDefragmentationAlgorithm_Generic::Defragment(
+    VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
+    VkDeviceSize maxBytesToMove,
+    uint32_t maxAllocationsToMove,
+    VmaDefragmentationFlags flags)
+{
+    if(!m_AllAllocations && m_AllocationCount == 0)
+    {
+        return VK_SUCCESS;
+    }
+
+    const size_t blockCount = m_Blocks.size();
+    for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
+    {
+        BlockInfo* pBlockInfo = m_Blocks[blockIndex];
+
+        if(m_AllAllocations)
+        {
+            VmaBlockMetadata_Generic* pMetadata = (VmaBlockMetadata_Generic*)pBlockInfo->m_pBlock->m_pMetadata;
+            for(VmaSuballocationList::const_iterator it = pMetadata->m_Suballocations.begin();
+                it != pMetadata->m_Suballocations.end();
+                ++it)
+            {
+                if(it->type != VMA_SUBALLOCATION_TYPE_FREE)
+                {
+                    AllocationInfo allocInfo = AllocationInfo(it->hAllocation, VMA_NULL);
+                    pBlockInfo->m_Allocations.push_back(allocInfo);
+                }
+            }
+        }
+
+        pBlockInfo->CalcHasNonMovableAllocations();
+
+        // This is a choice based on research.
+        // Option 1:
+        pBlockInfo->SortAllocationsByOffsetDescending();
+        // Option 2:
+        //pBlockInfo->SortAllocationsBySizeDescending();
+    }
+
+    // Sort m_Blocks this time by the main criterium, from most "destination" to most "source" blocks.
+    VMA_SORT(m_Blocks.begin(), m_Blocks.end(), BlockInfoCompareMoveDestination());
+
+    // This is a choice based on research.
+    const uint32_t roundCount = 2;
+
+    // Execute defragmentation rounds (the main part).
+    VkResult result = VK_SUCCESS;
+    for(uint32_t round = 0; (round < roundCount) && (result == VK_SUCCESS); ++round)
+    {
+        result = DefragmentRound(moves, maxBytesToMove, maxAllocationsToMove, !(flags & VMA_DEFRAGMENTATION_FLAG_INCREMENTAL));
+    }
+
+    return result;
+}
+
+bool VmaDefragmentationAlgorithm_Generic::MoveMakesSense(
+        size_t dstBlockIndex, VkDeviceSize dstOffset,
+        size_t srcBlockIndex, VkDeviceSize srcOffset)
+{
+    if(dstBlockIndex < srcBlockIndex)
+    {
+        return true;
+    }
+    if(dstBlockIndex > srcBlockIndex)
+    {
+        return false;
+    }
+    if(dstOffset < srcOffset)
+    {
+        return true;
+    }
+    return false;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// VmaDefragmentationAlgorithm_Fast
+
+VmaDefragmentationAlgorithm_Fast::VmaDefragmentationAlgorithm_Fast(
+    VmaAllocator hAllocator,
+    VmaBlockVector* pBlockVector,
+    uint32_t currentFrameIndex,
+    bool overlappingMoveSupported) :
+    VmaDefragmentationAlgorithm(hAllocator, pBlockVector, currentFrameIndex),
+    m_OverlappingMoveSupported(overlappingMoveSupported),
+    m_AllocationCount(0),
+    m_AllAllocations(false),
+    m_BytesMoved(0),
+    m_AllocationsMoved(0),
+    m_BlockInfos(VmaStlAllocator<BlockInfo>(hAllocator->GetAllocationCallbacks()))
+{
+    VMA_ASSERT(VMA_DEBUG_MARGIN == 0);
+
+}
+
+VmaDefragmentationAlgorithm_Fast::~VmaDefragmentationAlgorithm_Fast()
+{
+}
+
+VkResult VmaDefragmentationAlgorithm_Fast::Defragment(
+    VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
+    VkDeviceSize maxBytesToMove,
+    uint32_t maxAllocationsToMove,
+    VmaDefragmentationFlags flags)
+{
+    VMA_ASSERT(m_AllAllocations || m_pBlockVector->CalcAllocationCount() == m_AllocationCount);
+
+    const size_t blockCount = m_pBlockVector->GetBlockCount();
+    if(blockCount == 0 || maxBytesToMove == 0 || maxAllocationsToMove == 0)
+    {
+        return VK_SUCCESS;
+    }
+
+    PreprocessMetadata();
+
+    // Sort blocks in order from most destination.
+
+    m_BlockInfos.resize(blockCount);
+    for(size_t i = 0; i < blockCount; ++i)
+    {
+        m_BlockInfos[i].origBlockIndex = i;
+    }
+
+    VMA_SORT(m_BlockInfos.begin(), m_BlockInfos.end(), [this](const BlockInfo& lhs, const BlockInfo& rhs) -> bool {
+        return m_pBlockVector->GetBlock(lhs.origBlockIndex)->m_pMetadata->GetSumFreeSize() <
+            m_pBlockVector->GetBlock(rhs.origBlockIndex)->m_pMetadata->GetSumFreeSize();
+    });
+
+    // THE MAIN ALGORITHM
+
+    FreeSpaceDatabase freeSpaceDb;
+
+    size_t dstBlockInfoIndex = 0;
+    size_t dstOrigBlockIndex = m_BlockInfos[dstBlockInfoIndex].origBlockIndex;
+    VmaDeviceMemoryBlock* pDstBlock = m_pBlockVector->GetBlock(dstOrigBlockIndex);
+    VmaBlockMetadata_Generic* pDstMetadata = (VmaBlockMetadata_Generic*)pDstBlock->m_pMetadata;
+    VkDeviceSize dstBlockSize = pDstMetadata->GetSize();
+    VkDeviceSize dstOffset = 0;
+
+    bool end = false;
+    for(size_t srcBlockInfoIndex = 0; !end && srcBlockInfoIndex < blockCount; ++srcBlockInfoIndex)
+    {
+        const size_t srcOrigBlockIndex = m_BlockInfos[srcBlockInfoIndex].origBlockIndex;
+        VmaDeviceMemoryBlock* const pSrcBlock = m_pBlockVector->GetBlock(srcOrigBlockIndex);
+        VmaBlockMetadata_Generic* const pSrcMetadata = (VmaBlockMetadata_Generic*)pSrcBlock->m_pMetadata;
+        for(VmaSuballocationList::iterator srcSuballocIt = pSrcMetadata->m_Suballocations.begin();
+            !end && srcSuballocIt != pSrcMetadata->m_Suballocations.end(); )
+        {
+            VmaAllocation_T* const pAlloc = srcSuballocIt->hAllocation;
+            const VkDeviceSize srcAllocAlignment = pAlloc->GetAlignment();
+            const VkDeviceSize srcAllocSize = srcSuballocIt->size;
+            if(m_AllocationsMoved == maxAllocationsToMove ||
+                m_BytesMoved + srcAllocSize > maxBytesToMove)
+            {
+                end = true;
+                break;
+            }
+            const VkDeviceSize srcAllocOffset = srcSuballocIt->offset;
+
+            VmaDefragmentationMove move = {};
+            // Try to place it in one of free spaces from the database.
+            size_t freeSpaceInfoIndex;
+            VkDeviceSize dstAllocOffset;
+            if(freeSpaceDb.Fetch(srcAllocAlignment, srcAllocSize,
+                freeSpaceInfoIndex, dstAllocOffset))
+            {
+                size_t freeSpaceOrigBlockIndex = m_BlockInfos[freeSpaceInfoIndex].origBlockIndex;
+                VmaDeviceMemoryBlock* pFreeSpaceBlock = m_pBlockVector->GetBlock(freeSpaceOrigBlockIndex);
+                VmaBlockMetadata_Generic* pFreeSpaceMetadata = (VmaBlockMetadata_Generic*)pFreeSpaceBlock->m_pMetadata;
+
+                // Same block
+                if(freeSpaceInfoIndex == srcBlockInfoIndex)
+                {
+                    VMA_ASSERT(dstAllocOffset <= srcAllocOffset);
+
+                    // MOVE OPTION 1: Move the allocation inside the same block by decreasing offset.
+
+                    VmaSuballocation suballoc = *srcSuballocIt;
+                    suballoc.offset = dstAllocOffset;
+                    suballoc.hAllocation->ChangeOffset(dstAllocOffset);
+                    m_BytesMoved += srcAllocSize;
+                    ++m_AllocationsMoved;
+
+                    VmaSuballocationList::iterator nextSuballocIt = srcSuballocIt;
+                    ++nextSuballocIt;
+                    pSrcMetadata->m_Suballocations.erase(srcSuballocIt);
+                    srcSuballocIt = nextSuballocIt;
+
+                    InsertSuballoc(pFreeSpaceMetadata, suballoc);
+
+                    move.srcBlockIndex = srcOrigBlockIndex;
+                    move.dstBlockIndex = freeSpaceOrigBlockIndex;
+                    move.srcOffset = srcAllocOffset;
+                    move.dstOffset = dstAllocOffset;
+                    move.size = srcAllocSize;
+
+                    moves.push_back(move);
+                }
+                // Different block
+                else
+                {
+                    // MOVE OPTION 2: Move the allocation to a different block.
+
+                    VMA_ASSERT(freeSpaceInfoIndex < srcBlockInfoIndex);
+
+                    VmaSuballocation suballoc = *srcSuballocIt;
+                    suballoc.offset = dstAllocOffset;
+                    suballoc.hAllocation->ChangeBlockAllocation(m_hAllocator, pFreeSpaceBlock, dstAllocOffset);
+                    m_BytesMoved += srcAllocSize;
+                    ++m_AllocationsMoved;
+
+                    VmaSuballocationList::iterator nextSuballocIt = srcSuballocIt;
+                    ++nextSuballocIt;
+                    pSrcMetadata->m_Suballocations.erase(srcSuballocIt);
+                    srcSuballocIt = nextSuballocIt;
+
+                    InsertSuballoc(pFreeSpaceMetadata, suballoc);
+
+                    move.srcBlockIndex = srcOrigBlockIndex;
+                    move.dstBlockIndex = freeSpaceOrigBlockIndex;
+                    move.srcOffset = srcAllocOffset;
+                    move.dstOffset = dstAllocOffset;
+                    move.size = srcAllocSize;
+
+                    moves.push_back(move);
+                }
+            }
+            else
+            {
+                dstAllocOffset = VmaAlignUp(dstOffset, srcAllocAlignment);
+
+                // If the allocation doesn't fit before the end of dstBlock, forward to next block.
+                while(dstBlockInfoIndex < srcBlockInfoIndex &&
+                    dstAllocOffset + srcAllocSize > dstBlockSize)
+                {
+                    // But before that, register remaining free space at the end of dst block.
+                    freeSpaceDb.Register(dstBlockInfoIndex, dstOffset, dstBlockSize - dstOffset);
+
+                    ++dstBlockInfoIndex;
+                    dstOrigBlockIndex = m_BlockInfos[dstBlockInfoIndex].origBlockIndex;
+                    pDstBlock = m_pBlockVector->GetBlock(dstOrigBlockIndex);
+                    pDstMetadata = (VmaBlockMetadata_Generic*)pDstBlock->m_pMetadata;
+                    dstBlockSize = pDstMetadata->GetSize();
+                    dstOffset = 0;
+                    dstAllocOffset = 0;
+                }
+
+                // Same block
+                if(dstBlockInfoIndex == srcBlockInfoIndex)
+                {
+                    VMA_ASSERT(dstAllocOffset <= srcAllocOffset);
+
+                    const bool overlap = dstAllocOffset + srcAllocSize > srcAllocOffset;
+
+                    bool skipOver = overlap;
+                    if(overlap && m_OverlappingMoveSupported && dstAllocOffset < srcAllocOffset)
+                    {
+                        // If destination and source place overlap, skip if it would move it
+                        // by only < 1/64 of its size.
+                        skipOver = (srcAllocOffset - dstAllocOffset) * 64 < srcAllocSize;
+                    }
+
+                    if(skipOver)
+                    {
+                        freeSpaceDb.Register(dstBlockInfoIndex, dstOffset, srcAllocOffset - dstOffset);
+
+                        dstOffset = srcAllocOffset + srcAllocSize;
+                        ++srcSuballocIt;
+                    }
+                    // MOVE OPTION 1: Move the allocation inside the same block by decreasing offset.
+                    else
+                    {
+                        srcSuballocIt->offset = dstAllocOffset;
+                        srcSuballocIt->hAllocation->ChangeOffset(dstAllocOffset);
+                        dstOffset = dstAllocOffset + srcAllocSize;
+                        m_BytesMoved += srcAllocSize;
+                        ++m_AllocationsMoved;
+                        ++srcSuballocIt;
+
+                        move.srcBlockIndex = srcOrigBlockIndex;
+                        move.dstBlockIndex = dstOrigBlockIndex;
+                        move.srcOffset = srcAllocOffset;
+                        move.dstOffset = dstAllocOffset;
+                        move.size = srcAllocSize;
+
+                        moves.push_back(move);
+                    }
+                }
+                // Different block
+                else
+                {
+                    // MOVE OPTION 2: Move the allocation to a different block.
+
+                    VMA_ASSERT(dstBlockInfoIndex < srcBlockInfoIndex);
+                    VMA_ASSERT(dstAllocOffset + srcAllocSize <= dstBlockSize);
+
+                    VmaSuballocation suballoc = *srcSuballocIt;
+                    suballoc.offset = dstAllocOffset;
+                    suballoc.hAllocation->ChangeBlockAllocation(m_hAllocator, pDstBlock, dstAllocOffset);
+                    dstOffset = dstAllocOffset + srcAllocSize;
+                    m_BytesMoved += srcAllocSize;
+                    ++m_AllocationsMoved;
+
+                    VmaSuballocationList::iterator nextSuballocIt = srcSuballocIt;
+                    ++nextSuballocIt;
+                    pSrcMetadata->m_Suballocations.erase(srcSuballocIt);
+                    srcSuballocIt = nextSuballocIt;
+
+                    pDstMetadata->m_Suballocations.push_back(suballoc);
+
+                    move.srcBlockIndex = srcOrigBlockIndex;
+                    move.dstBlockIndex = dstOrigBlockIndex;
+                    move.srcOffset = srcAllocOffset;
+                    move.dstOffset = dstAllocOffset;
+                    move.size = srcAllocSize;
+
+                    moves.push_back(move);
+                }
+            }
+        }
+    }
+
+    m_BlockInfos.clear();
+
+    PostprocessMetadata();
+
+    return VK_SUCCESS;
+}
+
+void VmaDefragmentationAlgorithm_Fast::PreprocessMetadata()
+{
+    const size_t blockCount = m_pBlockVector->GetBlockCount();
+    for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
+    {
+        VmaBlockMetadata_Generic* const pMetadata =
+            (VmaBlockMetadata_Generic*)m_pBlockVector->GetBlock(blockIndex)->m_pMetadata;
+        pMetadata->m_FreeCount = 0;
+        pMetadata->m_SumFreeSize = pMetadata->GetSize();
+        pMetadata->m_FreeSuballocationsBySize.clear();
+        for(VmaSuballocationList::iterator it = pMetadata->m_Suballocations.begin();
+            it != pMetadata->m_Suballocations.end(); )
+        {
+            if(it->type == VMA_SUBALLOCATION_TYPE_FREE)
+            {
+                VmaSuballocationList::iterator nextIt = it;
+                ++nextIt;
+                pMetadata->m_Suballocations.erase(it);
+                it = nextIt;
+            }
+            else
+            {
+                ++it;
+            }
+        }
+    }
+}
+
+void VmaDefragmentationAlgorithm_Fast::PostprocessMetadata()
+{
+    const size_t blockCount = m_pBlockVector->GetBlockCount();
+    for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
+    {
+        VmaBlockMetadata_Generic* const pMetadata =
+            (VmaBlockMetadata_Generic*)m_pBlockVector->GetBlock(blockIndex)->m_pMetadata;
+        const VkDeviceSize blockSize = pMetadata->GetSize();
+
+        // No allocations in this block - entire area is free.
+        if(pMetadata->m_Suballocations.empty())
+        {
+            pMetadata->m_FreeCount = 1;
+            //pMetadata->m_SumFreeSize is already set to blockSize.
+            VmaSuballocation suballoc = {
+                0, // offset
+                blockSize, // size
+                VMA_NULL, // hAllocation
+                VMA_SUBALLOCATION_TYPE_FREE };
+            pMetadata->m_Suballocations.push_back(suballoc);
+            pMetadata->RegisterFreeSuballocation(pMetadata->m_Suballocations.begin());
+        }
+        // There are some allocations in this block.
+        else
+        {
+            VkDeviceSize offset = 0;
+            VmaSuballocationList::iterator it;
+            for(it = pMetadata->m_Suballocations.begin();
+                it != pMetadata->m_Suballocations.end();
+                ++it)
+            {
+                VMA_ASSERT(it->type != VMA_SUBALLOCATION_TYPE_FREE);
+                VMA_ASSERT(it->offset >= offset);
+
+                // Need to insert preceding free space.
+                if(it->offset > offset)
+                {
+                    ++pMetadata->m_FreeCount;
+                    const VkDeviceSize freeSize = it->offset - offset;
+                    VmaSuballocation suballoc = {
+                        offset, // offset
+                        freeSize, // size
+                        VMA_NULL, // hAllocation
+                        VMA_SUBALLOCATION_TYPE_FREE };
+                    VmaSuballocationList::iterator precedingFreeIt = pMetadata->m_Suballocations.insert(it, suballoc);
+                    if(freeSize >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
+                    {
+                        pMetadata->m_FreeSuballocationsBySize.push_back(precedingFreeIt);
+                    }
+                }
+
+                pMetadata->m_SumFreeSize -= it->size;
+                offset = it->offset + it->size;
+            }
+
+            // Need to insert trailing free space.
+            if(offset < blockSize)
+            {
+                ++pMetadata->m_FreeCount;
+                const VkDeviceSize freeSize = blockSize - offset;
+                VmaSuballocation suballoc = {
+                    offset, // offset
+                    freeSize, // size
+                    VMA_NULL, // hAllocation
+                    VMA_SUBALLOCATION_TYPE_FREE };
+                VMA_ASSERT(it == pMetadata->m_Suballocations.end());
+                VmaSuballocationList::iterator trailingFreeIt = pMetadata->m_Suballocations.insert(it, suballoc);
+                if(freeSize > VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
+                {
+                    pMetadata->m_FreeSuballocationsBySize.push_back(trailingFreeIt);
+                }
+            }
+
+            VMA_SORT(
+                pMetadata->m_FreeSuballocationsBySize.begin(),
+                pMetadata->m_FreeSuballocationsBySize.end(),
+                VmaSuballocationItemSizeLess());
+        }
+
+        VMA_HEAVY_ASSERT(pMetadata->Validate());
+    }
+}
+
+void VmaDefragmentationAlgorithm_Fast::InsertSuballoc(VmaBlockMetadata_Generic* pMetadata, const VmaSuballocation& suballoc)
+{
+    // TODO: Optimize somehow. Remember iterator instead of searching for it linearly.
+    VmaSuballocationList::iterator it = pMetadata->m_Suballocations.begin();
+    while(it != pMetadata->m_Suballocations.end())
+    {
+        if(it->offset < suballoc.offset)
+        {
+            ++it;
+        }
+    }
+    pMetadata->m_Suballocations.insert(it, suballoc);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// VmaBlockVectorDefragmentationContext
+
+VmaBlockVectorDefragmentationContext::VmaBlockVectorDefragmentationContext(
+    VmaAllocator hAllocator,
+    VmaPool hCustomPool,
+    VmaBlockVector* pBlockVector,
+    uint32_t currFrameIndex) :
+    res(VK_SUCCESS),
+    mutexLocked(false),
+    blockContexts(VmaStlAllocator<VmaBlockDefragmentationContext>(hAllocator->GetAllocationCallbacks())),
+    defragmentationMoves(VmaStlAllocator<VmaDefragmentationMove>(hAllocator->GetAllocationCallbacks())),
+    defragmentationMovesProcessed(0),
+    defragmentationMovesCommitted(0),
+    hasDefragmentationPlan(0),
+    m_hAllocator(hAllocator),
+    m_hCustomPool(hCustomPool),
+    m_pBlockVector(pBlockVector),
+    m_CurrFrameIndex(currFrameIndex),
+    m_pAlgorithm(VMA_NULL),
+    m_Allocations(VmaStlAllocator<AllocInfo>(hAllocator->GetAllocationCallbacks())),
+    m_AllAllocations(false)
+{
+}
+
+VmaBlockVectorDefragmentationContext::~VmaBlockVectorDefragmentationContext()
+{
+    vma_delete(m_hAllocator, m_pAlgorithm);
+}
+
+void VmaBlockVectorDefragmentationContext::AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged)
+{
+    AllocInfo info = { hAlloc, pChanged };
+    m_Allocations.push_back(info);
+}
+
+void VmaBlockVectorDefragmentationContext::Begin(bool overlappingMoveSupported, VmaDefragmentationFlags flags)
+{
+    const bool allAllocations = m_AllAllocations ||
+        m_Allocations.size() == m_pBlockVector->CalcAllocationCount();
+
+    /********************************
+    HERE IS THE CHOICE OF DEFRAGMENTATION ALGORITHM.
+    ********************************/
+
+    /*
+    Fast algorithm is supported only when certain criteria are met:
+    - VMA_DEBUG_MARGIN is 0.
+    - All allocations in this block vector are moveable.
+    - There is no possibility of image/buffer granularity conflict.
+    - The defragmentation is not incremental
+    */
+    if(VMA_DEBUG_MARGIN == 0 &&
+        allAllocations &&
+        !m_pBlockVector->IsBufferImageGranularityConflictPossible() &&
+        !(flags & VMA_DEFRAGMENTATION_FLAG_INCREMENTAL))
+    {
+        m_pAlgorithm = vma_new(m_hAllocator, VmaDefragmentationAlgorithm_Fast)(
+            m_hAllocator, m_pBlockVector, m_CurrFrameIndex, overlappingMoveSupported);
+    }
+    else
+    {
+        m_pAlgorithm = vma_new(m_hAllocator, VmaDefragmentationAlgorithm_Generic)(
+            m_hAllocator, m_pBlockVector, m_CurrFrameIndex, overlappingMoveSupported);
+    }
+
+    if(allAllocations)
+    {
+        m_pAlgorithm->AddAll();
+    }
+    else
+    {
+        for(size_t i = 0, count = m_Allocations.size(); i < count; ++i)
+        {
+            m_pAlgorithm->AddAllocation(m_Allocations[i].hAlloc, m_Allocations[i].pChanged);
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// VmaDefragmentationContext
+
+VmaDefragmentationContext_T::VmaDefragmentationContext_T(
+    VmaAllocator hAllocator,
+    uint32_t currFrameIndex,
+    uint32_t flags,
+    VmaDefragmentationStats* pStats) :
+    m_hAllocator(hAllocator),
+    m_CurrFrameIndex(currFrameIndex),
+    m_Flags(flags),
+    m_pStats(pStats),
+    m_CustomPoolContexts(VmaStlAllocator<VmaBlockVectorDefragmentationContext*>(hAllocator->GetAllocationCallbacks()))
+{
+    memset(m_DefaultPoolContexts, 0, sizeof(m_DefaultPoolContexts));
+}
+
+VmaDefragmentationContext_T::~VmaDefragmentationContext_T()
+{
+    for(size_t i = m_CustomPoolContexts.size(); i--; )
+    {
+        VmaBlockVectorDefragmentationContext* pBlockVectorCtx = m_CustomPoolContexts[i];
+        pBlockVectorCtx->GetBlockVector()->DefragmentationEnd(pBlockVectorCtx, m_Flags, m_pStats);
+        vma_delete(m_hAllocator, pBlockVectorCtx);
+    }
+    for(size_t i = m_hAllocator->m_MemProps.memoryTypeCount; i--; )
+    {
+        VmaBlockVectorDefragmentationContext* pBlockVectorCtx = m_DefaultPoolContexts[i];
+        if(pBlockVectorCtx)
+        {
+            pBlockVectorCtx->GetBlockVector()->DefragmentationEnd(pBlockVectorCtx, m_Flags, m_pStats);
+            vma_delete(m_hAllocator, pBlockVectorCtx);
+        }
+    }
+}
+
+void VmaDefragmentationContext_T::AddPools(uint32_t poolCount, const VmaPool* pPools)
+{
+    for(uint32_t poolIndex = 0; poolIndex < poolCount; ++poolIndex)
+    {
+        VmaPool pool = pPools[poolIndex];
+        VMA_ASSERT(pool);
+        // Pools with algorithm other than default are not defragmented.
+        if(pool->m_BlockVector.GetAlgorithm() == 0)
+        {
+            VmaBlockVectorDefragmentationContext* pBlockVectorDefragCtx = VMA_NULL;
+
+            for(size_t i = m_CustomPoolContexts.size(); i--; )
+            {
+                if(m_CustomPoolContexts[i]->GetCustomPool() == pool)
+                {
+                    pBlockVectorDefragCtx = m_CustomPoolContexts[i];
+                    break;
+                }
+            }
+
+            if(!pBlockVectorDefragCtx)
+            {
+                pBlockVectorDefragCtx = vma_new(m_hAllocator, VmaBlockVectorDefragmentationContext)(
+                    m_hAllocator,
+                    pool,
+                    &pool->m_BlockVector,
+                    m_CurrFrameIndex);
+                m_CustomPoolContexts.push_back(pBlockVectorDefragCtx);
+            }
+
+            pBlockVectorDefragCtx->AddAll();
+        }
+    }
+}
+
+void VmaDefragmentationContext_T::AddAllocations(
+    uint32_t allocationCount,
+    const VmaAllocation* pAllocations,
+    VkBool32* pAllocationsChanged)
+{
+    // Dispatch pAllocations among defragmentators. Create them when necessary.
+    for(uint32_t allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
+    {
+        const VmaAllocation hAlloc = pAllocations[allocIndex];
+        VMA_ASSERT(hAlloc);
+        // DedicatedAlloc cannot be defragmented.
+        if((hAlloc->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK) &&
+            // Lost allocation cannot be defragmented.
+            (hAlloc->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST))
+        {
+            VmaBlockVectorDefragmentationContext* pBlockVectorDefragCtx = VMA_NULL;
+
+            const VmaPool hAllocPool = hAlloc->GetBlock()->GetParentPool();
+            // This allocation belongs to custom pool.
+            if(hAllocPool != VK_NULL_HANDLE)
+            {
+                // Pools with algorithm other than default are not defragmented.
+                if(hAllocPool->m_BlockVector.GetAlgorithm() == 0)
+                {
+                    for(size_t i = m_CustomPoolContexts.size(); i--; )
+                    {
+                        if(m_CustomPoolContexts[i]->GetCustomPool() == hAllocPool)
+                        {
+                            pBlockVectorDefragCtx = m_CustomPoolContexts[i];
+                            break;
+                        }
+                    }
+                    if(!pBlockVectorDefragCtx)
+                    {
+                        pBlockVectorDefragCtx = vma_new(m_hAllocator, VmaBlockVectorDefragmentationContext)(
+                            m_hAllocator,
+                            hAllocPool,
+                            &hAllocPool->m_BlockVector,
+                            m_CurrFrameIndex);
+                        m_CustomPoolContexts.push_back(pBlockVectorDefragCtx);
+                    }
+                }
+            }
+            // This allocation belongs to default pool.
+            else
+            {
+                const uint32_t memTypeIndex = hAlloc->GetMemoryTypeIndex();
+                pBlockVectorDefragCtx = m_DefaultPoolContexts[memTypeIndex];
+                if(!pBlockVectorDefragCtx)
+                {
+                    pBlockVectorDefragCtx = vma_new(m_hAllocator, VmaBlockVectorDefragmentationContext)(
+                        m_hAllocator,
+                        VMA_NULL, // hCustomPool
+                        m_hAllocator->m_pBlockVectors[memTypeIndex],
+                        m_CurrFrameIndex);
+                    m_DefaultPoolContexts[memTypeIndex] = pBlockVectorDefragCtx;
+                }
+            }
+
+            if(pBlockVectorDefragCtx)
+            {
+                VkBool32* const pChanged = (pAllocationsChanged != VMA_NULL) ?
+                    &pAllocationsChanged[allocIndex] : VMA_NULL;
+                pBlockVectorDefragCtx->AddAllocation(hAlloc, pChanged);
+            }
+        }
+    }
+}
+
+VkResult VmaDefragmentationContext_T::Defragment(
+    VkDeviceSize maxCpuBytesToMove, uint32_t maxCpuAllocationsToMove,
+    VkDeviceSize maxGpuBytesToMove, uint32_t maxGpuAllocationsToMove,
+    VkCommandBuffer commandBuffer, VmaDefragmentationStats* pStats, VmaDefragmentationFlags flags)
+{
+    if(pStats)
+    {
+        memset(pStats, 0, sizeof(VmaDefragmentationStats));
+    }
+
+    if(flags & VMA_DEFRAGMENTATION_FLAG_INCREMENTAL)
+    {
+        // For incremental defragmetnations, we just earmark how much we can move
+        // The real meat is in the defragmentation steps
+        m_MaxCpuBytesToMove = maxCpuBytesToMove;
+        m_MaxCpuAllocationsToMove = maxCpuAllocationsToMove;
+
+        m_MaxGpuBytesToMove = maxGpuBytesToMove;
+        m_MaxGpuAllocationsToMove = maxGpuAllocationsToMove;
+
+        if(m_MaxCpuBytesToMove == 0 && m_MaxCpuAllocationsToMove == 0 &&
+            m_MaxGpuBytesToMove == 0 && m_MaxGpuAllocationsToMove == 0)
+            return VK_SUCCESS;
+
+        return VK_NOT_READY;
+    }
+
+    if(commandBuffer == VK_NULL_HANDLE)
+    {
+        maxGpuBytesToMove = 0;
+        maxGpuAllocationsToMove = 0;
+    }
+
+    VkResult res = VK_SUCCESS;
+
+    // Process default pools.
+    for(uint32_t memTypeIndex = 0;
+        memTypeIndex < m_hAllocator->GetMemoryTypeCount() && res >= VK_SUCCESS;
+        ++memTypeIndex)
+    {
+        VmaBlockVectorDefragmentationContext* pBlockVectorCtx = m_DefaultPoolContexts[memTypeIndex];
+        if(pBlockVectorCtx)
+        {
+            VMA_ASSERT(pBlockVectorCtx->GetBlockVector());
+            pBlockVectorCtx->GetBlockVector()->Defragment(
+                pBlockVectorCtx,
+                pStats, flags,
+                maxCpuBytesToMove, maxCpuAllocationsToMove,
+                maxGpuBytesToMove, maxGpuAllocationsToMove,
+                commandBuffer);
+            if(pBlockVectorCtx->res != VK_SUCCESS)
+            {
+                res = pBlockVectorCtx->res;
+            }
+        }
+    }
+
+    // Process custom pools.
+    for(size_t customCtxIndex = 0, customCtxCount = m_CustomPoolContexts.size();
+        customCtxIndex < customCtxCount && res >= VK_SUCCESS;
+        ++customCtxIndex)
+    {
+        VmaBlockVectorDefragmentationContext* pBlockVectorCtx = m_CustomPoolContexts[customCtxIndex];
+        VMA_ASSERT(pBlockVectorCtx && pBlockVectorCtx->GetBlockVector());
+        pBlockVectorCtx->GetBlockVector()->Defragment(
+            pBlockVectorCtx,
+            pStats, flags,
+            maxCpuBytesToMove, maxCpuAllocationsToMove,
+            maxGpuBytesToMove, maxGpuAllocationsToMove,
+            commandBuffer);
+        if(pBlockVectorCtx->res != VK_SUCCESS)
+        {
+            res = pBlockVectorCtx->res;
+        }
+    }
+
+    return res;
+}
+
+VkResult VmaDefragmentationContext_T::DefragmentPassBegin(VmaDefragmentationPassInfo* pInfo)
+{
+    VmaDefragmentationPassMoveInfo* pCurrentMove = pInfo->pMoves;
+    uint32_t movesLeft = pInfo->moveCount;
+
+    // Process default pools.
+    for(uint32_t memTypeIndex = 0;
+        memTypeIndex < m_hAllocator->GetMemoryTypeCount();
+        ++memTypeIndex)
+    {
+        VmaBlockVectorDefragmentationContext *pBlockVectorCtx = m_DefaultPoolContexts[memTypeIndex];
+        if(pBlockVectorCtx)
+        {
+            VMA_ASSERT(pBlockVectorCtx->GetBlockVector());
+
+            if(!pBlockVectorCtx->hasDefragmentationPlan)
+            {
+                pBlockVectorCtx->GetBlockVector()->Defragment(
+                    pBlockVectorCtx,
+                    m_pStats, m_Flags,
+                    m_MaxCpuBytesToMove, m_MaxCpuAllocationsToMove,
+                    m_MaxGpuBytesToMove, m_MaxGpuAllocationsToMove,
+                    VK_NULL_HANDLE);
+
+                if(pBlockVectorCtx->res < VK_SUCCESS)
+                    continue;
+
+                pBlockVectorCtx->hasDefragmentationPlan = true;
+            }
+
+            const uint32_t processed = pBlockVectorCtx->GetBlockVector()->ProcessDefragmentations(
+                pBlockVectorCtx,
+                pCurrentMove, movesLeft);
+
+            movesLeft -= processed;
+            pCurrentMove += processed;
+        }
+    }
+
+    // Process custom pools.
+    for(size_t customCtxIndex = 0, customCtxCount = m_CustomPoolContexts.size();
+        customCtxIndex < customCtxCount;
+        ++customCtxIndex)
+    {
+        VmaBlockVectorDefragmentationContext *pBlockVectorCtx = m_CustomPoolContexts[customCtxIndex];
+        VMA_ASSERT(pBlockVectorCtx && pBlockVectorCtx->GetBlockVector());
+
+        if(!pBlockVectorCtx->hasDefragmentationPlan)
+        {
+            pBlockVectorCtx->GetBlockVector()->Defragment(
+                pBlockVectorCtx,
+                m_pStats, m_Flags,
+                m_MaxCpuBytesToMove, m_MaxCpuAllocationsToMove,
+                m_MaxGpuBytesToMove, m_MaxGpuAllocationsToMove,
+                VK_NULL_HANDLE);
+
+            if(pBlockVectorCtx->res < VK_SUCCESS)
+                continue;
+
+            pBlockVectorCtx->hasDefragmentationPlan = true;
+        }
+
+        const uint32_t processed = pBlockVectorCtx->GetBlockVector()->ProcessDefragmentations(
+            pBlockVectorCtx,
+            pCurrentMove, movesLeft);
+
+        movesLeft -= processed;
+        pCurrentMove += processed;
+    }
+
+    pInfo->moveCount = pInfo->moveCount - movesLeft;
+
+    return VK_SUCCESS;
+}
+VkResult VmaDefragmentationContext_T::DefragmentPassEnd()
+{
+    VkResult res = VK_SUCCESS;
+
+    // Process default pools.
+    for(uint32_t memTypeIndex = 0;
+        memTypeIndex < m_hAllocator->GetMemoryTypeCount();
+        ++memTypeIndex)
+    {
+        VmaBlockVectorDefragmentationContext *pBlockVectorCtx = m_DefaultPoolContexts[memTypeIndex];
+        if(pBlockVectorCtx)
+        {
+            VMA_ASSERT(pBlockVectorCtx->GetBlockVector());
+
+            if(!pBlockVectorCtx->hasDefragmentationPlan)
+            {
+                res = VK_NOT_READY;
+                continue;
+            }
+
+            pBlockVectorCtx->GetBlockVector()->CommitDefragmentations(
+                pBlockVectorCtx, m_pStats);
+
+            if(pBlockVectorCtx->defragmentationMoves.size() != pBlockVectorCtx->defragmentationMovesCommitted)
+                res = VK_NOT_READY;
+        }
+    }
+
+    // Process custom pools.
+    for(size_t customCtxIndex = 0, customCtxCount = m_CustomPoolContexts.size();
+        customCtxIndex < customCtxCount;
+        ++customCtxIndex)
+    {
+        VmaBlockVectorDefragmentationContext *pBlockVectorCtx = m_CustomPoolContexts[customCtxIndex];
+        VMA_ASSERT(pBlockVectorCtx && pBlockVectorCtx->GetBlockVector());
+
+        if(!pBlockVectorCtx->hasDefragmentationPlan)
+        {
+            res = VK_NOT_READY;
+            continue;
+        }
+
+        pBlockVectorCtx->GetBlockVector()->CommitDefragmentations(
+            pBlockVectorCtx, m_pStats);
+
+        if(pBlockVectorCtx->defragmentationMoves.size() != pBlockVectorCtx->defragmentationMovesCommitted)
+            res = VK_NOT_READY;
+    }
+
+    return res;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// VmaRecorder
+
+#if VMA_RECORDING_ENABLED
+
+VmaRecorder::VmaRecorder() :
+    m_UseMutex(true),
+    m_Flags(0),
+    m_File(VMA_NULL),
+    m_RecordingStartTime(std::chrono::high_resolution_clock::now())
+{
+}
+
+VkResult VmaRecorder::Init(const VmaRecordSettings& settings, bool useMutex)
+{
+    m_UseMutex = useMutex;
+    m_Flags = settings.flags;
+
+#if defined(_WIN32)
+    // Open file for writing.
+    errno_t err = fopen_s(&m_File, settings.pFilePath, "wb");
+
+    if(err != 0)
+    {
+        return VK_ERROR_INITIALIZATION_FAILED;
+    }
+#else
+    // Open file for writing.
+    m_File = fopen(settings.pFilePath, "wb");
+
+    if(m_File == 0)
+    {
+        return VK_ERROR_INITIALIZATION_FAILED;
+    }
+#endif
+
+    // Write header.
+    fprintf(m_File, "%s\n", "Vulkan Memory Allocator,Calls recording");
+    fprintf(m_File, "%s\n", "1,8");
+
+    return VK_SUCCESS;
+}
+
+VmaRecorder::~VmaRecorder()
+{
+    if(m_File != VMA_NULL)
+    {
+        fclose(m_File);
+    }
+}
+
+void VmaRecorder::RecordCreateAllocator(uint32_t frameIndex)
+{
+    CallParams callParams;
+    GetBasicParams(callParams);
+
+    VmaMutexLock lock(m_FileMutex, m_UseMutex);
+    fprintf(m_File, "%u,%.3f,%u,vmaCreateAllocator\n", callParams.threadId, callParams.time, frameIndex);
+    Flush();
+}
+
+void VmaRecorder::RecordDestroyAllocator(uint32_t frameIndex)
+{
+    CallParams callParams;
+    GetBasicParams(callParams);
+
+    VmaMutexLock lock(m_FileMutex, m_UseMutex);
+    fprintf(m_File, "%u,%.3f,%u,vmaDestroyAllocator\n", callParams.threadId, callParams.time, frameIndex);
+    Flush();
+}
+
+void VmaRecorder::RecordCreatePool(uint32_t frameIndex, const VmaPoolCreateInfo& createInfo, VmaPool pool)
+{
+    CallParams callParams;
+    GetBasicParams(callParams);
+
+    VmaMutexLock lock(m_FileMutex, m_UseMutex);
+    fprintf(m_File, "%u,%.3f,%u,vmaCreatePool,%u,%u,%llu,%llu,%llu,%u,%p\n", callParams.threadId, callParams.time, frameIndex,
+        createInfo.memoryTypeIndex,
+        createInfo.flags,
+        createInfo.blockSize,
+        (uint64_t)createInfo.minBlockCount,
+        (uint64_t)createInfo.maxBlockCount,
+        createInfo.frameInUseCount,
+        pool);
+    Flush();
+}
+
+void VmaRecorder::RecordDestroyPool(uint32_t frameIndex, VmaPool pool)
+{
+    CallParams callParams;
+    GetBasicParams(callParams);
+
+    VmaMutexLock lock(m_FileMutex, m_UseMutex);
+    fprintf(m_File, "%u,%.3f,%u,vmaDestroyPool,%p\n", callParams.threadId, callParams.time, frameIndex,
+        pool);
+    Flush();
+}
+
+void VmaRecorder::RecordAllocateMemory(uint32_t frameIndex,
+        const VkMemoryRequirements& vkMemReq,
+        const VmaAllocationCreateInfo& createInfo,
+        VmaAllocation allocation)
+{
+    CallParams callParams;
+    GetBasicParams(callParams);
+
+    VmaMutexLock lock(m_FileMutex, m_UseMutex);
+    UserDataString userDataStr(createInfo.flags, createInfo.pUserData);
+    fprintf(m_File, "%u,%.3f,%u,vmaAllocateMemory,%llu,%llu,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
+        vkMemReq.size,
+        vkMemReq.alignment,
+        vkMemReq.memoryTypeBits,
+        createInfo.flags,
+        createInfo.usage,
+        createInfo.requiredFlags,
+        createInfo.preferredFlags,
+        createInfo.memoryTypeBits,
+        createInfo.pool,
+        allocation,
+        userDataStr.GetString());
+    Flush();
+}
+
+void VmaRecorder::RecordAllocateMemoryPages(uint32_t frameIndex,
+    const VkMemoryRequirements& vkMemReq,
+    const VmaAllocationCreateInfo& createInfo,
+    uint64_t allocationCount,
+    const VmaAllocation* pAllocations)
+{
+    CallParams callParams;
+    GetBasicParams(callParams);
+
+    VmaMutexLock lock(m_FileMutex, m_UseMutex);
+    UserDataString userDataStr(createInfo.flags, createInfo.pUserData);
+    fprintf(m_File, "%u,%.3f,%u,vmaAllocateMemoryPages,%llu,%llu,%u,%u,%u,%u,%u,%u,%p,", callParams.threadId, callParams.time, frameIndex,
+        vkMemReq.size,
+        vkMemReq.alignment,
+        vkMemReq.memoryTypeBits,
+        createInfo.flags,
+        createInfo.usage,
+        createInfo.requiredFlags,
+        createInfo.preferredFlags,
+        createInfo.memoryTypeBits,
+        createInfo.pool);
+    PrintPointerList(allocationCount, pAllocations);
+    fprintf(m_File, ",%s\n", userDataStr.GetString());
+    Flush();
+}
+
+void VmaRecorder::RecordAllocateMemoryForBuffer(uint32_t frameIndex,
+    const VkMemoryRequirements& vkMemReq,
+    bool requiresDedicatedAllocation,
+    bool prefersDedicatedAllocation,
+    const VmaAllocationCreateInfo& createInfo,
+    VmaAllocation allocation)
+{
+    CallParams callParams;
+    GetBasicParams(callParams);
+
+    VmaMutexLock lock(m_FileMutex, m_UseMutex);
+    UserDataString userDataStr(createInfo.flags, createInfo.pUserData);
+    fprintf(m_File, "%u,%.3f,%u,vmaAllocateMemoryForBuffer,%llu,%llu,%u,%u,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
+        vkMemReq.size,
+        vkMemReq.alignment,
+        vkMemReq.memoryTypeBits,
+        requiresDedicatedAllocation ? 1 : 0,
+        prefersDedicatedAllocation ? 1 : 0,
+        createInfo.flags,
+        createInfo.usage,
+        createInfo.requiredFlags,
+        createInfo.preferredFlags,
+        createInfo.memoryTypeBits,
+        createInfo.pool,
+        allocation,
+        userDataStr.GetString());
+    Flush();
+}
+
+void VmaRecorder::RecordAllocateMemoryForImage(uint32_t frameIndex,
+    const VkMemoryRequirements& vkMemReq,
+    bool requiresDedicatedAllocation,
+    bool prefersDedicatedAllocation,
+    const VmaAllocationCreateInfo& createInfo,
+    VmaAllocation allocation)
+{
+    CallParams callParams;
+    GetBasicParams(callParams);
+
+    VmaMutexLock lock(m_FileMutex, m_UseMutex);
+    UserDataString userDataStr(createInfo.flags, createInfo.pUserData);
+    fprintf(m_File, "%u,%.3f,%u,vmaAllocateMemoryForImage,%llu,%llu,%u,%u,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
+        vkMemReq.size,
+        vkMemReq.alignment,
+        vkMemReq.memoryTypeBits,
+        requiresDedicatedAllocation ? 1 : 0,
+        prefersDedicatedAllocation ? 1 : 0,
+        createInfo.flags,
+        createInfo.usage,
+        createInfo.requiredFlags,
+        createInfo.preferredFlags,
+        createInfo.memoryTypeBits,
+        createInfo.pool,
+        allocation,
+        userDataStr.GetString());
+    Flush();
+}
+
+void VmaRecorder::RecordFreeMemory(uint32_t frameIndex,
+    VmaAllocation allocation)
+{
+    CallParams callParams;
+    GetBasicParams(callParams);
+
+    VmaMutexLock lock(m_FileMutex, m_UseMutex);
+    fprintf(m_File, "%u,%.3f,%u,vmaFreeMemory,%p\n", callParams.threadId, callParams.time, frameIndex,
+        allocation);
+    Flush();
+}
+
+void VmaRecorder::RecordFreeMemoryPages(uint32_t frameIndex,
+    uint64_t allocationCount,
+    const VmaAllocation* pAllocations)
+{
+    CallParams callParams;
+    GetBasicParams(callParams);
+
+    VmaMutexLock lock(m_FileMutex, m_UseMutex);
+    fprintf(m_File, "%u,%.3f,%u,vmaFreeMemoryPages,", callParams.threadId, callParams.time, frameIndex);
+    PrintPointerList(allocationCount, pAllocations);
+    fprintf(m_File, "\n");
+    Flush();
+}
+
+void VmaRecorder::RecordSetAllocationUserData(uint32_t frameIndex,
+    VmaAllocation allocation,
+    const void* pUserData)
+{
+    CallParams callParams;
+    GetBasicParams(callParams);
+
+    VmaMutexLock lock(m_FileMutex, m_UseMutex);
+    UserDataString userDataStr(
+        allocation->IsUserDataString() ? VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT : 0,
+        pUserData);
+    fprintf(m_File, "%u,%.3f,%u,vmaSetAllocationUserData,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
+        allocation,
+        userDataStr.GetString());
+    Flush();
+}
+
+void VmaRecorder::RecordCreateLostAllocation(uint32_t frameIndex,
+    VmaAllocation allocation)
+{
+    CallParams callParams;
+    GetBasicParams(callParams);
+
+    VmaMutexLock lock(m_FileMutex, m_UseMutex);
+    fprintf(m_File, "%u,%.3f,%u,vmaCreateLostAllocation,%p\n", callParams.threadId, callParams.time, frameIndex,
+        allocation);
+    Flush();
+}
+
+void VmaRecorder::RecordMapMemory(uint32_t frameIndex,
+    VmaAllocation allocation)
+{
+    CallParams callParams;
+    GetBasicParams(callParams);
+
+    VmaMutexLock lock(m_FileMutex, m_UseMutex);
+    fprintf(m_File, "%u,%.3f,%u,vmaMapMemory,%p\n", callParams.threadId, callParams.time, frameIndex,
+        allocation);
+    Flush();
+}
+
+void VmaRecorder::RecordUnmapMemory(uint32_t frameIndex,
+    VmaAllocation allocation)
+{
+    CallParams callParams;
+    GetBasicParams(callParams);
+
+    VmaMutexLock lock(m_FileMutex, m_UseMutex);
+    fprintf(m_File, "%u,%.3f,%u,vmaUnmapMemory,%p\n", callParams.threadId, callParams.time, frameIndex,
+        allocation);
+    Flush();
+}
+
+void VmaRecorder::RecordFlushAllocation(uint32_t frameIndex,
+    VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
+{
+    CallParams callParams;
+    GetBasicParams(callParams);
+
+    VmaMutexLock lock(m_FileMutex, m_UseMutex);
+    fprintf(m_File, "%u,%.3f,%u,vmaFlushAllocation,%p,%llu,%llu\n", callParams.threadId, callParams.time, frameIndex,
+        allocation,
+        offset,
+        size);
+    Flush();
+}
+
+void VmaRecorder::RecordInvalidateAllocation(uint32_t frameIndex,
+    VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
+{
+    CallParams callParams;
+    GetBasicParams(callParams);
+
+    VmaMutexLock lock(m_FileMutex, m_UseMutex);
+    fprintf(m_File, "%u,%.3f,%u,vmaInvalidateAllocation,%p,%llu,%llu\n", callParams.threadId, callParams.time, frameIndex,
+        allocation,
+        offset,
+        size);
+    Flush();
+}
+
+void VmaRecorder::RecordCreateBuffer(uint32_t frameIndex,
+    const VkBufferCreateInfo& bufCreateInfo,
+    const VmaAllocationCreateInfo& allocCreateInfo,
+    VmaAllocation allocation)
+{
+    CallParams callParams;
+    GetBasicParams(callParams);
+
+    VmaMutexLock lock(m_FileMutex, m_UseMutex);
+    UserDataString userDataStr(allocCreateInfo.flags, allocCreateInfo.pUserData);
+    fprintf(m_File, "%u,%.3f,%u,vmaCreateBuffer,%u,%llu,%u,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
+        bufCreateInfo.flags,
+        bufCreateInfo.size,
+        bufCreateInfo.usage,
+        bufCreateInfo.sharingMode,
+        allocCreateInfo.flags,
+        allocCreateInfo.usage,
+        allocCreateInfo.requiredFlags,
+        allocCreateInfo.preferredFlags,
+        allocCreateInfo.memoryTypeBits,
+        allocCreateInfo.pool,
+        allocation,
+        userDataStr.GetString());
+    Flush();
+}
+
+void VmaRecorder::RecordCreateImage(uint32_t frameIndex,
+    const VkImageCreateInfo& imageCreateInfo,
+    const VmaAllocationCreateInfo& allocCreateInfo,
+    VmaAllocation allocation)
+{
+    CallParams callParams;
+    GetBasicParams(callParams);
+
+    VmaMutexLock lock(m_FileMutex, m_UseMutex);
+    UserDataString userDataStr(allocCreateInfo.flags, allocCreateInfo.pUserData);
+    fprintf(m_File, "%u,%.3f,%u,vmaCreateImage,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
+        imageCreateInfo.flags,
+        imageCreateInfo.imageType,
+        imageCreateInfo.format,
+        imageCreateInfo.extent.width,
+        imageCreateInfo.extent.height,
+        imageCreateInfo.extent.depth,
+        imageCreateInfo.mipLevels,
+        imageCreateInfo.arrayLayers,
+        imageCreateInfo.samples,
+        imageCreateInfo.tiling,
+        imageCreateInfo.usage,
+        imageCreateInfo.sharingMode,
+        imageCreateInfo.initialLayout,
+        allocCreateInfo.flags,
+        allocCreateInfo.usage,
+        allocCreateInfo.requiredFlags,
+        allocCreateInfo.preferredFlags,
+        allocCreateInfo.memoryTypeBits,
+        allocCreateInfo.pool,
+        allocation,
+        userDataStr.GetString());
+    Flush();
+}
+
+void VmaRecorder::RecordDestroyBuffer(uint32_t frameIndex,
+    VmaAllocation allocation)
+{
+    CallParams callParams;
+    GetBasicParams(callParams);
+
+    VmaMutexLock lock(m_FileMutex, m_UseMutex);
+    fprintf(m_File, "%u,%.3f,%u,vmaDestroyBuffer,%p\n", callParams.threadId, callParams.time, frameIndex,
+        allocation);
+    Flush();
+}
+
+void VmaRecorder::RecordDestroyImage(uint32_t frameIndex,
+    VmaAllocation allocation)
+{
+    CallParams callParams;
+    GetBasicParams(callParams);
+
+    VmaMutexLock lock(m_FileMutex, m_UseMutex);
+    fprintf(m_File, "%u,%.3f,%u,vmaDestroyImage,%p\n", callParams.threadId, callParams.time, frameIndex,
+        allocation);
+    Flush();
+}
+
+void VmaRecorder::RecordTouchAllocation(uint32_t frameIndex,
+    VmaAllocation allocation)
+{
+    CallParams callParams;
+    GetBasicParams(callParams);
+
+    VmaMutexLock lock(m_FileMutex, m_UseMutex);
+    fprintf(m_File, "%u,%.3f,%u,vmaTouchAllocation,%p\n", callParams.threadId, callParams.time, frameIndex,
+        allocation);
+    Flush();
+}
+
+void VmaRecorder::RecordGetAllocationInfo(uint32_t frameIndex,
+    VmaAllocation allocation)
+{
+    CallParams callParams;
+    GetBasicParams(callParams);
+
+    VmaMutexLock lock(m_FileMutex, m_UseMutex);
+    fprintf(m_File, "%u,%.3f,%u,vmaGetAllocationInfo,%p\n", callParams.threadId, callParams.time, frameIndex,
+        allocation);
+    Flush();
+}
+
+void VmaRecorder::RecordMakePoolAllocationsLost(uint32_t frameIndex,
+    VmaPool pool)
+{
+    CallParams callParams;
+    GetBasicParams(callParams);
+
+    VmaMutexLock lock(m_FileMutex, m_UseMutex);
+    fprintf(m_File, "%u,%.3f,%u,vmaMakePoolAllocationsLost,%p\n", callParams.threadId, callParams.time, frameIndex,
+        pool);
+    Flush();
+}
+
+void VmaRecorder::RecordDefragmentationBegin(uint32_t frameIndex,
+    const VmaDefragmentationInfo2& info,
+    VmaDefragmentationContext ctx)
+{
+    CallParams callParams;
+    GetBasicParams(callParams);
+
+    VmaMutexLock lock(m_FileMutex, m_UseMutex);
+    fprintf(m_File, "%u,%.3f,%u,vmaDefragmentationBegin,%u,", callParams.threadId, callParams.time, frameIndex,
+        info.flags);
+    PrintPointerList(info.allocationCount, info.pAllocations);
+    fprintf(m_File, ",");
+    PrintPointerList(info.poolCount, info.pPools);
+    fprintf(m_File, ",%llu,%u,%llu,%u,%p,%p\n",
+        info.maxCpuBytesToMove,
+        info.maxCpuAllocationsToMove,
+        info.maxGpuBytesToMove,
+        info.maxGpuAllocationsToMove,
+        info.commandBuffer,
+        ctx);
+    Flush();
+}
+
+void VmaRecorder::RecordDefragmentationEnd(uint32_t frameIndex,
+    VmaDefragmentationContext ctx)
+{
+    CallParams callParams;
+    GetBasicParams(callParams);
+
+    VmaMutexLock lock(m_FileMutex, m_UseMutex);
+    fprintf(m_File, "%u,%.3f,%u,vmaDefragmentationEnd,%p\n", callParams.threadId, callParams.time, frameIndex,
+        ctx);
+    Flush();
+}
+
+void VmaRecorder::RecordSetPoolName(uint32_t frameIndex,
+    VmaPool pool,
+    const char* name)
+{
+    CallParams callParams;
+    GetBasicParams(callParams);
+
+    VmaMutexLock lock(m_FileMutex, m_UseMutex);
+    fprintf(m_File, "%u,%.3f,%u,vmaSetPoolName,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
+        pool, name != VMA_NULL ? name : "");
+    Flush();
+}
+
+VmaRecorder::UserDataString::UserDataString(VmaAllocationCreateFlags allocFlags, const void* pUserData)
+{
+    if(pUserData != VMA_NULL)
+    {
+        if((allocFlags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0)
+        {
+            m_Str = (const char*)pUserData;
+        }
+        else
+        {
+            // If VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT is not specified, convert the string's memory address to a string and store it.
+            snprintf(m_PtrStr, 17, "%p", pUserData);
+            m_Str = m_PtrStr;
+        }
+    }
+    else
+    {
+        m_Str = "";
+    }
+}
+
+void VmaRecorder::WriteConfiguration(
+    const VkPhysicalDeviceProperties& devProps,
+    const VkPhysicalDeviceMemoryProperties& memProps,
+    uint32_t vulkanApiVersion,
+    bool dedicatedAllocationExtensionEnabled,
+    bool bindMemory2ExtensionEnabled,
+    bool memoryBudgetExtensionEnabled,
+    bool deviceCoherentMemoryExtensionEnabled)
+{
+    fprintf(m_File, "Config,Begin\n");
+
+    fprintf(m_File, "VulkanApiVersion,%u,%u\n", VK_VERSION_MAJOR(vulkanApiVersion), VK_VERSION_MINOR(vulkanApiVersion));
+
+    fprintf(m_File, "PhysicalDevice,apiVersion,%u\n", devProps.apiVersion);
+    fprintf(m_File, "PhysicalDevice,driverVersion,%u\n", devProps.driverVersion);
+    fprintf(m_File, "PhysicalDevice,vendorID,%u\n", devProps.vendorID);
+    fprintf(m_File, "PhysicalDevice,deviceID,%u\n", devProps.deviceID);
+    fprintf(m_File, "PhysicalDevice,deviceType,%u\n", devProps.deviceType);
+    fprintf(m_File, "PhysicalDevice,deviceName,%s\n", devProps.deviceName);
+
+    fprintf(m_File, "PhysicalDeviceLimits,maxMemoryAllocationCount,%u\n", devProps.limits.maxMemoryAllocationCount);
+    fprintf(m_File, "PhysicalDeviceLimits,bufferImageGranularity,%llu\n", devProps.limits.bufferImageGranularity);
+    fprintf(m_File, "PhysicalDeviceLimits,nonCoherentAtomSize,%llu\n", devProps.limits.nonCoherentAtomSize);
+
+    fprintf(m_File, "PhysicalDeviceMemory,HeapCount,%u\n", memProps.memoryHeapCount);
+    for(uint32_t i = 0; i < memProps.memoryHeapCount; ++i)
+    {
+        fprintf(m_File, "PhysicalDeviceMemory,Heap,%u,size,%llu\n", i, memProps.memoryHeaps[i].size);
+        fprintf(m_File, "PhysicalDeviceMemory,Heap,%u,flags,%u\n", i, memProps.memoryHeaps[i].flags);
+    }
+    fprintf(m_File, "PhysicalDeviceMemory,TypeCount,%u\n", memProps.memoryTypeCount);
+    for(uint32_t i = 0; i < memProps.memoryTypeCount; ++i)
+    {
+        fprintf(m_File, "PhysicalDeviceMemory,Type,%u,heapIndex,%u\n", i, memProps.memoryTypes[i].heapIndex);
+        fprintf(m_File, "PhysicalDeviceMemory,Type,%u,propertyFlags,%u\n", i, memProps.memoryTypes[i].propertyFlags);
+    }
+
+    fprintf(m_File, "Extension,VK_KHR_dedicated_allocation,%u\n", dedicatedAllocationExtensionEnabled ? 1 : 0);
+    fprintf(m_File, "Extension,VK_KHR_bind_memory2,%u\n", bindMemory2ExtensionEnabled ? 1 : 0);
+    fprintf(m_File, "Extension,VK_EXT_memory_budget,%u\n", memoryBudgetExtensionEnabled ? 1 : 0);
+    fprintf(m_File, "Extension,VK_AMD_device_coherent_memory,%u\n", deviceCoherentMemoryExtensionEnabled ? 1 : 0);
+
+    fprintf(m_File, "Macro,VMA_DEBUG_ALWAYS_DEDICATED_MEMORY,%u\n", VMA_DEBUG_ALWAYS_DEDICATED_MEMORY ? 1 : 0);
+    fprintf(m_File, "Macro,VMA_DEBUG_ALIGNMENT,%llu\n", (VkDeviceSize)VMA_DEBUG_ALIGNMENT);
+    fprintf(m_File, "Macro,VMA_DEBUG_MARGIN,%llu\n", (VkDeviceSize)VMA_DEBUG_MARGIN);
+    fprintf(m_File, "Macro,VMA_DEBUG_INITIALIZE_ALLOCATIONS,%u\n", VMA_DEBUG_INITIALIZE_ALLOCATIONS ? 1 : 0);
+    fprintf(m_File, "Macro,VMA_DEBUG_DETECT_CORRUPTION,%u\n", VMA_DEBUG_DETECT_CORRUPTION ? 1 : 0);
+    fprintf(m_File, "Macro,VMA_DEBUG_GLOBAL_MUTEX,%u\n", VMA_DEBUG_GLOBAL_MUTEX ? 1 : 0);
+    fprintf(m_File, "Macro,VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY,%llu\n", (VkDeviceSize)VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY);
+    fprintf(m_File, "Macro,VMA_SMALL_HEAP_MAX_SIZE,%llu\n", (VkDeviceSize)VMA_SMALL_HEAP_MAX_SIZE);
+    fprintf(m_File, "Macro,VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE,%llu\n", (VkDeviceSize)VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE);
+
+    fprintf(m_File, "Config,End\n");
+}
+
+void VmaRecorder::GetBasicParams(CallParams& outParams)
+{
+    #if defined(_WIN32)
+        outParams.threadId = GetCurrentThreadId();
+    #else
+        // Use C++11 features to get thread id and convert it to uint32_t.
+        // There is room for optimization since sstream is quite slow.
+        // Is there a better way to convert std::this_thread::get_id() to uint32_t?
+        std::thread::id thread_id = std::this_thread::get_id();
+        std::stringstream thread_id_to_string_converter;
+        thread_id_to_string_converter << thread_id;
+        std::string thread_id_as_string = thread_id_to_string_converter.str();
+        outParams.threadId = static_cast<uint32_t>(std::stoi(thread_id_as_string.c_str()));
+    #endif
+
+    auto current_time = std::chrono::high_resolution_clock::now();
+
+    outParams.time = std::chrono::duration<double, std::chrono::seconds::period>(current_time - m_RecordingStartTime).count();
+}
+
+void VmaRecorder::PrintPointerList(uint64_t count, const VmaAllocation* pItems)
+{
+    if(count)
+    {
+        fprintf(m_File, "%p", pItems[0]);
+        for(uint64_t i = 1; i < count; ++i)
+        {
+            fprintf(m_File, " %p", pItems[i]);
+        }
+    }
+}
+
+void VmaRecorder::Flush()
+{
+    if((m_Flags & VMA_RECORD_FLUSH_AFTER_CALL_BIT) != 0)
+    {
+        fflush(m_File);
+    }
+}
+
+#endif // #if VMA_RECORDING_ENABLED
+
+////////////////////////////////////////////////////////////////////////////////
+// VmaAllocationObjectAllocator
+
+VmaAllocationObjectAllocator::VmaAllocationObjectAllocator(const VkAllocationCallbacks* pAllocationCallbacks) :
+    m_Allocator(pAllocationCallbacks, 1024)
+{
+}
+
+template<typename... Types> VmaAllocation VmaAllocationObjectAllocator::Allocate(Types... args)
+{
+    VmaMutexLock mutexLock(m_Mutex);
+    return m_Allocator.Alloc<Types...>(std::forward<Types>(args)...);
+}
+
+void VmaAllocationObjectAllocator::Free(VmaAllocation hAlloc)
+{
+    VmaMutexLock mutexLock(m_Mutex);
+    m_Allocator.Free(hAlloc);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// VmaAllocator_T
+
+VmaAllocator_T::VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo) :
+    m_UseMutex((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT) == 0),
+    m_VulkanApiVersion(pCreateInfo->vulkanApiVersion != 0 ? pCreateInfo->vulkanApiVersion : VK_API_VERSION_1_0),
+    m_UseKhrDedicatedAllocation((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT) != 0),
+    m_UseKhrBindMemory2((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT) != 0),
+    m_UseExtMemoryBudget((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT) != 0),
+    m_UseAmdDeviceCoherentMemory((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_AMD_DEVICE_COHERENT_MEMORY_BIT) != 0),
+    m_UseKhrBufferDeviceAddress((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT) != 0),
+    m_UseExtMemoryPriority((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXT_MEMORY_PRIORITY_BIT) != 0),
+    m_hDevice(pCreateInfo->device),
+    m_hInstance(pCreateInfo->instance),
+    m_AllocationCallbacksSpecified(pCreateInfo->pAllocationCallbacks != VMA_NULL),
+    m_AllocationCallbacks(pCreateInfo->pAllocationCallbacks ?
+        *pCreateInfo->pAllocationCallbacks : VmaEmptyAllocationCallbacks),
+    m_AllocationObjectAllocator(&m_AllocationCallbacks),
+    m_HeapSizeLimitMask(0),
+    m_PreferredLargeHeapBlockSize(0),
+    m_PhysicalDevice(pCreateInfo->physicalDevice),
+    m_CurrentFrameIndex(0),
+    m_GpuDefragmentationMemoryTypeBits(UINT32_MAX),
+    m_Pools(VmaStlAllocator<VmaPool>(GetAllocationCallbacks())),
+    m_NextPoolId(0),
+    m_GlobalMemoryTypeBits(UINT32_MAX)
+#if VMA_RECORDING_ENABLED
+    ,m_pRecorder(VMA_NULL)
+#endif
+{
+    if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
+    {
+        m_UseKhrDedicatedAllocation = false;
+        m_UseKhrBindMemory2 = false;
+    }
+
+    if(VMA_DEBUG_DETECT_CORRUPTION)
+    {
+        // Needs to be multiply of uint32_t size because we are going to write VMA_CORRUPTION_DETECTION_MAGIC_VALUE to it.
+        VMA_ASSERT(VMA_DEBUG_MARGIN % sizeof(uint32_t) == 0);
+    }
+
+    VMA_ASSERT(pCreateInfo->physicalDevice && pCreateInfo->device && pCreateInfo->instance);
+
+    if(m_VulkanApiVersion < VK_MAKE_VERSION(1, 1, 0))
+    {
+#if !(VMA_DEDICATED_ALLOCATION)
+        if((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT) != 0)
+        {
+            VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT set but required extensions are disabled by preprocessor macros.");
+        }
+#endif
+#if !(VMA_BIND_MEMORY2)
+        if((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT) != 0)
+        {
+            VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT set but required extension is disabled by preprocessor macros.");
+        }
+#endif
+    }
+#if !(VMA_MEMORY_BUDGET)
+    if((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT) != 0)
+    {
+        VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT set but required extension is disabled by preprocessor macros.");
+    }
+#endif
+#if !(VMA_BUFFER_DEVICE_ADDRESS)
+    if(m_UseKhrBufferDeviceAddress)
+    {
+        VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT is set but required extension or Vulkan 1.2 is not available in your Vulkan header or its support in VMA has been disabled by a preprocessor macro.");
+    }
+#endif
+#if VMA_VULKAN_VERSION < 1002000
+    if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 2, 0))
+    {
+        VMA_ASSERT(0 && "vulkanApiVersion >= VK_API_VERSION_1_2 but required Vulkan version is disabled by preprocessor macros.");
+    }
+#endif
+#if VMA_VULKAN_VERSION < 1001000
+    if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
+    {
+        VMA_ASSERT(0 && "vulkanApiVersion >= VK_API_VERSION_1_1 but required Vulkan version is disabled by preprocessor macros.");
+    }
+#endif
+#if !(VMA_MEMORY_PRIORITY)
+    if(m_UseExtMemoryPriority)
+    {
+        VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_EXT_MEMORY_PRIORITY_BIT is set but required extension is not available in your Vulkan header or its support in VMA has been disabled by a preprocessor macro.");
+    }
+#endif
+
+    memset(&m_DeviceMemoryCallbacks, 0 ,sizeof(m_DeviceMemoryCallbacks));
+    memset(&m_PhysicalDeviceProperties, 0, sizeof(m_PhysicalDeviceProperties));
+    memset(&m_MemProps, 0, sizeof(m_MemProps));
+
+    memset(&m_pBlockVectors, 0, sizeof(m_pBlockVectors));
+    memset(&m_pDedicatedAllocations, 0, sizeof(m_pDedicatedAllocations));
+    memset(&m_VulkanFunctions, 0, sizeof(m_VulkanFunctions));
+
+    if(pCreateInfo->pDeviceMemoryCallbacks != VMA_NULL)
+    {
+        m_DeviceMemoryCallbacks.pUserData = pCreateInfo->pDeviceMemoryCallbacks->pUserData;
+        m_DeviceMemoryCallbacks.pfnAllocate = pCreateInfo->pDeviceMemoryCallbacks->pfnAllocate;
+        m_DeviceMemoryCallbacks.pfnFree = pCreateInfo->pDeviceMemoryCallbacks->pfnFree;
+    }
+
+    ImportVulkanFunctions(pCreateInfo->pVulkanFunctions);
+
+    (*m_VulkanFunctions.vkGetPhysicalDeviceProperties)(m_PhysicalDevice, &m_PhysicalDeviceProperties);
+    (*m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties)(m_PhysicalDevice, &m_MemProps);
+
+    VMA_ASSERT(VmaIsPow2(VMA_DEBUG_ALIGNMENT));
+    VMA_ASSERT(VmaIsPow2(VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY));
+    VMA_ASSERT(VmaIsPow2(m_PhysicalDeviceProperties.limits.bufferImageGranularity));
+    VMA_ASSERT(VmaIsPow2(m_PhysicalDeviceProperties.limits.nonCoherentAtomSize));
+
+    m_PreferredLargeHeapBlockSize = (pCreateInfo->preferredLargeHeapBlockSize != 0) ?
+        pCreateInfo->preferredLargeHeapBlockSize : static_cast<VkDeviceSize>(VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE);
+
+    m_GlobalMemoryTypeBits = CalculateGlobalMemoryTypeBits();
+
+    if(pCreateInfo->pHeapSizeLimit != VMA_NULL)
+    {
+        for(uint32_t heapIndex = 0; heapIndex < GetMemoryHeapCount(); ++heapIndex)
+        {
+            const VkDeviceSize limit = pCreateInfo->pHeapSizeLimit[heapIndex];
+            if(limit != VK_WHOLE_SIZE)
+            {
+                m_HeapSizeLimitMask |= 1u << heapIndex;
+                if(limit < m_MemProps.memoryHeaps[heapIndex].size)
+                {
+                    m_MemProps.memoryHeaps[heapIndex].size = limit;
+                }
+            }
+        }
+    }
+
+    for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
+    {
+        const VkDeviceSize preferredBlockSize = CalcPreferredBlockSize(memTypeIndex);
+
+        m_pBlockVectors[memTypeIndex] = vma_new(this, VmaBlockVector)(
+            this,
+            VK_NULL_HANDLE, // hParentPool
+            memTypeIndex,
+            preferredBlockSize,
+            0,
+            SIZE_MAX,
+            GetBufferImageGranularity(),
+            pCreateInfo->frameInUseCount,
+            false, // explicitBlockSize
+            false, // linearAlgorithm
+            0.5f); // priority (0.5 is the default per Vulkan spec)
+        // No need to call m_pBlockVectors[memTypeIndex][blockVectorTypeIndex]->CreateMinBlocks here,
+        // becase minBlockCount is 0.
+        m_pDedicatedAllocations[memTypeIndex] = vma_new(this, AllocationVectorType)(VmaStlAllocator<VmaAllocation>(GetAllocationCallbacks()));
+
+    }
+}
+
+VkResult VmaAllocator_T::Init(const VmaAllocatorCreateInfo* pCreateInfo)
+{
+    VkResult res = VK_SUCCESS;
+
+    if(pCreateInfo->pRecordSettings != VMA_NULL &&
+        !VmaStrIsEmpty(pCreateInfo->pRecordSettings->pFilePath))
+    {
+#if VMA_RECORDING_ENABLED
+        m_pRecorder = vma_new(this, VmaRecorder)();
+        res = m_pRecorder->Init(*pCreateInfo->pRecordSettings, m_UseMutex);
+        if(res != VK_SUCCESS)
+        {
+            return res;
+        }
+        m_pRecorder->WriteConfiguration(
+            m_PhysicalDeviceProperties,
+            m_MemProps,
+            m_VulkanApiVersion,
+            m_UseKhrDedicatedAllocation,
+            m_UseKhrBindMemory2,
+            m_UseExtMemoryBudget,
+            m_UseAmdDeviceCoherentMemory);
+        m_pRecorder->RecordCreateAllocator(GetCurrentFrameIndex());
+#else
+        VMA_ASSERT(0 && "VmaAllocatorCreateInfo::pRecordSettings used, but not supported due to VMA_RECORDING_ENABLED not defined to 1.");
+        return VK_ERROR_FEATURE_NOT_PRESENT;
+#endif
+    }
+
+#if VMA_MEMORY_BUDGET
+    if(m_UseExtMemoryBudget)
+    {
+        UpdateVulkanBudget();
+    }
+#endif // #if VMA_MEMORY_BUDGET
+
+    return res;
+}
+
+VmaAllocator_T::~VmaAllocator_T()
+{
+#if VMA_RECORDING_ENABLED
+    if(m_pRecorder != VMA_NULL)
+    {
+        m_pRecorder->RecordDestroyAllocator(GetCurrentFrameIndex());
+        vma_delete(this, m_pRecorder);
+    }
+#endif
+
+    VMA_ASSERT(m_Pools.empty());
+
+    for(size_t i = GetMemoryTypeCount(); i--; )
+    {
+        if(m_pDedicatedAllocations[i] != VMA_NULL && !m_pDedicatedAllocations[i]->empty())
+        {
+            VMA_ASSERT(0 && "Unfreed dedicated allocations found.");
+        }
+
+        vma_delete(this, m_pDedicatedAllocations[i]);
+        vma_delete(this, m_pBlockVectors[i]);
+    }
+}
+
+void VmaAllocator_T::ImportVulkanFunctions(const VmaVulkanFunctions* pVulkanFunctions)
+{
+#if VMA_STATIC_VULKAN_FUNCTIONS == 1
+    ImportVulkanFunctions_Static();
+#endif
+
+    if(pVulkanFunctions != VMA_NULL)
+    {
+        ImportVulkanFunctions_Custom(pVulkanFunctions);
+    }
+
+#if VMA_DYNAMIC_VULKAN_FUNCTIONS == 1
+    ImportVulkanFunctions_Dynamic();
+#endif
+
+    ValidateVulkanFunctions();
+}
+
+#if VMA_STATIC_VULKAN_FUNCTIONS == 1
+
+void VmaAllocator_T::ImportVulkanFunctions_Static()
+{
+    // Vulkan 1.0
+    m_VulkanFunctions.vkGetPhysicalDeviceProperties = (PFN_vkGetPhysicalDeviceProperties)vkGetPhysicalDeviceProperties;
+    m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties = (PFN_vkGetPhysicalDeviceMemoryProperties)vkGetPhysicalDeviceMemoryProperties;
+    m_VulkanFunctions.vkAllocateMemory = (PFN_vkAllocateMemory)vkAllocateMemory;
+    m_VulkanFunctions.vkFreeMemory = (PFN_vkFreeMemory)vkFreeMemory;
+    m_VulkanFunctions.vkMapMemory = (PFN_vkMapMemory)vkMapMemory;
+    m_VulkanFunctions.vkUnmapMemory = (PFN_vkUnmapMemory)vkUnmapMemory;
+    m_VulkanFunctions.vkFlushMappedMemoryRanges = (PFN_vkFlushMappedMemoryRanges)vkFlushMappedMemoryRanges;
+    m_VulkanFunctions.vkInvalidateMappedMemoryRanges = (PFN_vkInvalidateMappedMemoryRanges)vkInvalidateMappedMemoryRanges;
+    m_VulkanFunctions.vkBindBufferMemory = (PFN_vkBindBufferMemory)vkBindBufferMemory;
+    m_VulkanFunctions.vkBindImageMemory = (PFN_vkBindImageMemory)vkBindImageMemory;
+    m_VulkanFunctions.vkGetBufferMemoryRequirements = (PFN_vkGetBufferMemoryRequirements)vkGetBufferMemoryRequirements;
+    m_VulkanFunctions.vkGetImageMemoryRequirements = (PFN_vkGetImageMemoryRequirements)vkGetImageMemoryRequirements;
+    m_VulkanFunctions.vkCreateBuffer = (PFN_vkCreateBuffer)vkCreateBuffer;
+    m_VulkanFunctions.vkDestroyBuffer = (PFN_vkDestroyBuffer)vkDestroyBuffer;
+    m_VulkanFunctions.vkCreateImage = (PFN_vkCreateImage)vkCreateImage;
+    m_VulkanFunctions.vkDestroyImage = (PFN_vkDestroyImage)vkDestroyImage;
+    m_VulkanFunctions.vkCmdCopyBuffer = (PFN_vkCmdCopyBuffer)vkCmdCopyBuffer;
+
+    // Vulkan 1.1
+#if VMA_VULKAN_VERSION >= 1001000
+    if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
+    {
+        m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR = (PFN_vkGetBufferMemoryRequirements2)vkGetBufferMemoryRequirements2;
+        m_VulkanFunctions.vkGetImageMemoryRequirements2KHR = (PFN_vkGetImageMemoryRequirements2)vkGetImageMemoryRequirements2;
+        m_VulkanFunctions.vkBindBufferMemory2KHR = (PFN_vkBindBufferMemory2)vkBindBufferMemory2;
+        m_VulkanFunctions.vkBindImageMemory2KHR = (PFN_vkBindImageMemory2)vkBindImageMemory2;
+        m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties2KHR = (PFN_vkGetPhysicalDeviceMemoryProperties2)vkGetPhysicalDeviceMemoryProperties2;
+    }
+#endif
+}
+
+#endif // #if VMA_STATIC_VULKAN_FUNCTIONS == 1
+
+void VmaAllocator_T::ImportVulkanFunctions_Custom(const VmaVulkanFunctions* pVulkanFunctions)
+{
+    VMA_ASSERT(pVulkanFunctions != VMA_NULL);
+
+#define VMA_COPY_IF_NOT_NULL(funcName) \
+    if(pVulkanFunctions->funcName != VMA_NULL) m_VulkanFunctions.funcName = pVulkanFunctions->funcName;
+
+    VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceProperties);
+    VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceMemoryProperties);
+    VMA_COPY_IF_NOT_NULL(vkAllocateMemory);
+    VMA_COPY_IF_NOT_NULL(vkFreeMemory);
+    VMA_COPY_IF_NOT_NULL(vkMapMemory);
+    VMA_COPY_IF_NOT_NULL(vkUnmapMemory);
+    VMA_COPY_IF_NOT_NULL(vkFlushMappedMemoryRanges);
+    VMA_COPY_IF_NOT_NULL(vkInvalidateMappedMemoryRanges);
+    VMA_COPY_IF_NOT_NULL(vkBindBufferMemory);
+    VMA_COPY_IF_NOT_NULL(vkBindImageMemory);
+    VMA_COPY_IF_NOT_NULL(vkGetBufferMemoryRequirements);
+    VMA_COPY_IF_NOT_NULL(vkGetImageMemoryRequirements);
+    VMA_COPY_IF_NOT_NULL(vkCreateBuffer);
+    VMA_COPY_IF_NOT_NULL(vkDestroyBuffer);
+    VMA_COPY_IF_NOT_NULL(vkCreateImage);
+    VMA_COPY_IF_NOT_NULL(vkDestroyImage);
+    VMA_COPY_IF_NOT_NULL(vkCmdCopyBuffer);
+
+#if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
+    VMA_COPY_IF_NOT_NULL(vkGetBufferMemoryRequirements2KHR);
+    VMA_COPY_IF_NOT_NULL(vkGetImageMemoryRequirements2KHR);
+#endif
+
+#if VMA_BIND_MEMORY2 || VMA_VULKAN_VERSION >= 1001000
+    VMA_COPY_IF_NOT_NULL(vkBindBufferMemory2KHR);
+    VMA_COPY_IF_NOT_NULL(vkBindImageMemory2KHR);
+#endif
+
+#if VMA_MEMORY_BUDGET
+    VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceMemoryProperties2KHR);
+#endif
+
+#undef VMA_COPY_IF_NOT_NULL
+}
+
+#if VMA_DYNAMIC_VULKAN_FUNCTIONS == 1
+
+void VmaAllocator_T::ImportVulkanFunctions_Dynamic()
+{
+#define VMA_FETCH_INSTANCE_FUNC(memberName, functionPointerType, functionNameString) \
+    if(m_VulkanFunctions.memberName == VMA_NULL) \
+        m_VulkanFunctions.memberName = \
+            (functionPointerType)vkGetInstanceProcAddr(m_hInstance, functionNameString);
+#define VMA_FETCH_DEVICE_FUNC(memberName, functionPointerType, functionNameString) \
+    if(m_VulkanFunctions.memberName == VMA_NULL) \
+        m_VulkanFunctions.memberName = \
+            (functionPointerType)vkGetDeviceProcAddr(m_hDevice, functionNameString);
+
+    VMA_FETCH_INSTANCE_FUNC(vkGetPhysicalDeviceProperties, PFN_vkGetPhysicalDeviceProperties, "vkGetPhysicalDeviceProperties");
+    VMA_FETCH_INSTANCE_FUNC(vkGetPhysicalDeviceMemoryProperties, PFN_vkGetPhysicalDeviceMemoryProperties, "vkGetPhysicalDeviceMemoryProperties");
+    VMA_FETCH_DEVICE_FUNC(vkAllocateMemory, PFN_vkAllocateMemory, "vkAllocateMemory");
+    VMA_FETCH_DEVICE_FUNC(vkFreeMemory, PFN_vkFreeMemory, "vkFreeMemory");
+    VMA_FETCH_DEVICE_FUNC(vkMapMemory, PFN_vkMapMemory, "vkMapMemory");
+    VMA_FETCH_DEVICE_FUNC(vkUnmapMemory, PFN_vkUnmapMemory, "vkUnmapMemory");
+    VMA_FETCH_DEVICE_FUNC(vkFlushMappedMemoryRanges, PFN_vkFlushMappedMemoryRanges, "vkFlushMappedMemoryRanges");
+    VMA_FETCH_DEVICE_FUNC(vkInvalidateMappedMemoryRanges, PFN_vkInvalidateMappedMemoryRanges, "vkInvalidateMappedMemoryRanges");
+    VMA_FETCH_DEVICE_FUNC(vkBindBufferMemory, PFN_vkBindBufferMemory, "vkBindBufferMemory");
+    VMA_FETCH_DEVICE_FUNC(vkBindImageMemory, PFN_vkBindImageMemory, "vkBindImageMemory");
+    VMA_FETCH_DEVICE_FUNC(vkGetBufferMemoryRequirements, PFN_vkGetBufferMemoryRequirements, "vkGetBufferMemoryRequirements");
+    VMA_FETCH_DEVICE_FUNC(vkGetImageMemoryRequirements, PFN_vkGetImageMemoryRequirements, "vkGetImageMemoryRequirements");
+    VMA_FETCH_DEVICE_FUNC(vkCreateBuffer, PFN_vkCreateBuffer, "vkCreateBuffer");
+    VMA_FETCH_DEVICE_FUNC(vkDestroyBuffer, PFN_vkDestroyBuffer, "vkDestroyBuffer");
+    VMA_FETCH_DEVICE_FUNC(vkCreateImage, PFN_vkCreateImage, "vkCreateImage");
+    VMA_FETCH_DEVICE_FUNC(vkDestroyImage, PFN_vkDestroyImage, "vkDestroyImage");
+    VMA_FETCH_DEVICE_FUNC(vkCmdCopyBuffer, PFN_vkCmdCopyBuffer, "vkCmdCopyBuffer");
+
+#if VMA_VULKAN_VERSION >= 1001000
+    if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
+    {
+        VMA_FETCH_DEVICE_FUNC(vkGetBufferMemoryRequirements2KHR, PFN_vkGetBufferMemoryRequirements2, "vkGetBufferMemoryRequirements2");
+        VMA_FETCH_DEVICE_FUNC(vkGetImageMemoryRequirements2KHR, PFN_vkGetImageMemoryRequirements2, "vkGetImageMemoryRequirements2");
+        VMA_FETCH_DEVICE_FUNC(vkBindBufferMemory2KHR, PFN_vkBindBufferMemory2, "vkBindBufferMemory2");
+        VMA_FETCH_DEVICE_FUNC(vkBindImageMemory2KHR, PFN_vkBindImageMemory2, "vkBindImageMemory2");
+        VMA_FETCH_INSTANCE_FUNC(vkGetPhysicalDeviceMemoryProperties2KHR, PFN_vkGetPhysicalDeviceMemoryProperties2, "vkGetPhysicalDeviceMemoryProperties2");
+    }
+#endif
+
+#if VMA_DEDICATED_ALLOCATION
+    if(m_UseKhrDedicatedAllocation)
+    {
+        VMA_FETCH_DEVICE_FUNC(vkGetBufferMemoryRequirements2KHR, PFN_vkGetBufferMemoryRequirements2KHR, "vkGetBufferMemoryRequirements2KHR");
+        VMA_FETCH_DEVICE_FUNC(vkGetImageMemoryRequirements2KHR, PFN_vkGetImageMemoryRequirements2KHR, "vkGetImageMemoryRequirements2KHR");
+    }
+#endif
+
+#if VMA_BIND_MEMORY2
+    if(m_UseKhrBindMemory2)
+    {
+        VMA_FETCH_DEVICE_FUNC(vkBindBufferMemory2KHR, PFN_vkBindBufferMemory2KHR, "vkBindBufferMemory2KHR");
+        VMA_FETCH_DEVICE_FUNC(vkBindImageMemory2KHR, PFN_vkBindImageMemory2KHR, "vkBindImageMemory2KHR");
+    }
+#endif // #if VMA_BIND_MEMORY2
+
+#if VMA_MEMORY_BUDGET
+    if(m_UseExtMemoryBudget)
+    {
+        VMA_FETCH_INSTANCE_FUNC(vkGetPhysicalDeviceMemoryProperties2KHR, PFN_vkGetPhysicalDeviceMemoryProperties2KHR, "vkGetPhysicalDeviceMemoryProperties2KHR");
+    }
+#endif // #if VMA_MEMORY_BUDGET
+
+#undef VMA_FETCH_DEVICE_FUNC
+#undef VMA_FETCH_INSTANCE_FUNC
+}
+
+#endif // #if VMA_DYNAMIC_VULKAN_FUNCTIONS == 1
+
+void VmaAllocator_T::ValidateVulkanFunctions()
+{
+    VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceProperties != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkAllocateMemory != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkFreeMemory != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkMapMemory != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkUnmapMemory != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkFlushMappedMemoryRanges != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkInvalidateMappedMemoryRanges != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkBindBufferMemory != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkBindImageMemory != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkGetBufferMemoryRequirements != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkGetImageMemoryRequirements != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkCreateBuffer != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkDestroyBuffer != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkCreateImage != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkDestroyImage != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkCmdCopyBuffer != VMA_NULL);
+
+#if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
+    if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0) || m_UseKhrDedicatedAllocation)
+    {
+        VMA_ASSERT(m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR != VMA_NULL);
+        VMA_ASSERT(m_VulkanFunctions.vkGetImageMemoryRequirements2KHR != VMA_NULL);
+    }
+#endif
+
+#if VMA_BIND_MEMORY2 || VMA_VULKAN_VERSION >= 1001000
+    if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0) || m_UseKhrBindMemory2)
+    {
+        VMA_ASSERT(m_VulkanFunctions.vkBindBufferMemory2KHR != VMA_NULL);
+        VMA_ASSERT(m_VulkanFunctions.vkBindImageMemory2KHR != VMA_NULL);
+    }
+#endif
+
+#if VMA_MEMORY_BUDGET || VMA_VULKAN_VERSION >= 1001000
+    if(m_UseExtMemoryBudget || m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
+    {
+        VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties2KHR != VMA_NULL);
+    }
+#endif
+}
+
+VkDeviceSize VmaAllocator_T::CalcPreferredBlockSize(uint32_t memTypeIndex)
+{
+    const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
+    const VkDeviceSize heapSize = m_MemProps.memoryHeaps[heapIndex].size;
+    const bool isSmallHeap = heapSize <= VMA_SMALL_HEAP_MAX_SIZE;
+    return VmaAlignUp(isSmallHeap ? (heapSize / 8) : m_PreferredLargeHeapBlockSize, (VkDeviceSize)32);
+}
+
+VkResult VmaAllocator_T::AllocateMemoryOfType(
+    VkDeviceSize size,
+    VkDeviceSize alignment,
+    bool dedicatedAllocation,
+    VkBuffer dedicatedBuffer,
+    VkBufferUsageFlags dedicatedBufferUsage,
+    VkImage dedicatedImage,
+    const VmaAllocationCreateInfo& createInfo,
+    uint32_t memTypeIndex,
+    VmaSuballocationType suballocType,
+    size_t allocationCount,
+    VmaAllocation* pAllocations)
+{
+    VMA_ASSERT(pAllocations != VMA_NULL);
+    VMA_DEBUG_LOG("  AllocateMemory: MemoryTypeIndex=%u, AllocationCount=%zu, Size=%llu", memTypeIndex, allocationCount, size);
+
+    VmaAllocationCreateInfo finalCreateInfo = createInfo;
+
+    // If memory type is not HOST_VISIBLE, disable MAPPED.
+    if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
+        (m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
+    {
+        finalCreateInfo.flags &= ~VMA_ALLOCATION_CREATE_MAPPED_BIT;
+    }
+    // If memory is lazily allocated, it should be always dedicated.
+    if(finalCreateInfo.usage == VMA_MEMORY_USAGE_GPU_LAZILY_ALLOCATED)
+    {
+        finalCreateInfo.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
+    }
+
+    VmaBlockVector* const blockVector = m_pBlockVectors[memTypeIndex];
+    VMA_ASSERT(blockVector);
+
+    const VkDeviceSize preferredBlockSize = blockVector->GetPreferredBlockSize();
+    bool preferDedicatedMemory =
+        VMA_DEBUG_ALWAYS_DEDICATED_MEMORY ||
+        dedicatedAllocation ||
+        // Heuristics: Allocate dedicated memory if requested size if greater than half of preferred block size.
+        size > preferredBlockSize / 2;
+
+    if(preferDedicatedMemory &&
+        (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0 &&
+        finalCreateInfo.pool == VK_NULL_HANDLE)
+    {
+        finalCreateInfo.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
+    }
+
+    if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0)
+    {
+        if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
+        {
+            return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+        }
+        else
+        {
+            return AllocateDedicatedMemory(
+                size,
+                suballocType,
+                memTypeIndex,
+                (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT) != 0,
+                (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
+                (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
+                finalCreateInfo.pUserData,
+                finalCreateInfo.priority,
+                dedicatedBuffer,
+                dedicatedBufferUsage,
+                dedicatedImage,
+                allocationCount,
+                pAllocations);
+        }
+    }
+    else
+    {
+        VkResult res = blockVector->Allocate(
+            m_CurrentFrameIndex.load(),
+            size,
+            alignment,
+            finalCreateInfo,
+            suballocType,
+            allocationCount,
+            pAllocations);
+        if(res == VK_SUCCESS)
+        {
+            return res;
+        }
+
+        // 5. Try dedicated memory.
+        if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
+        {
+            return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+        }
+        else
+        {
+            res = AllocateDedicatedMemory(
+                size,
+                suballocType,
+                memTypeIndex,
+                (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT) != 0,
+                (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
+                (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
+                finalCreateInfo.pUserData,
+                finalCreateInfo.priority,
+                dedicatedBuffer,
+                dedicatedBufferUsage,
+                dedicatedImage,
+                allocationCount,
+                pAllocations);
+            if(res == VK_SUCCESS)
+            {
+                // Succeeded: AllocateDedicatedMemory function already filld pMemory, nothing more to do here.
+                VMA_DEBUG_LOG("    Allocated as DedicatedMemory");
+                return VK_SUCCESS;
+            }
+            else
+            {
+                // Everything failed: Return error code.
+                VMA_DEBUG_LOG("    vkAllocateMemory FAILED");
+                return res;
+            }
+        }
+    }
+}
+
+VkResult VmaAllocator_T::AllocateDedicatedMemory(
+    VkDeviceSize size,
+    VmaSuballocationType suballocType,
+    uint32_t memTypeIndex,
+    bool withinBudget,
+    bool map,
+    bool isUserDataString,
+    void* pUserData,
+    float priority,
+    VkBuffer dedicatedBuffer,
+    VkBufferUsageFlags dedicatedBufferUsage,
+    VkImage dedicatedImage,
+    size_t allocationCount,
+    VmaAllocation* pAllocations)
+{
+    VMA_ASSERT(allocationCount > 0 && pAllocations);
+
+    if(withinBudget)
+    {
+        const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
+        VmaBudget heapBudget = {};
+        GetBudget(&heapBudget, heapIndex, 1);
+        if(heapBudget.usage + size * allocationCount > heapBudget.budget)
+        {
+            return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+        }
+    }
+
+    VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
+    allocInfo.memoryTypeIndex = memTypeIndex;
+    allocInfo.allocationSize = size;
+
+#if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
+    VkMemoryDedicatedAllocateInfoKHR dedicatedAllocInfo = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR };
+    if(m_UseKhrDedicatedAllocation || m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
+    {
+        if(dedicatedBuffer != VK_NULL_HANDLE)
+        {
+            VMA_ASSERT(dedicatedImage == VK_NULL_HANDLE);
+            dedicatedAllocInfo.buffer = dedicatedBuffer;
+            VmaPnextChainPushFront(&allocInfo, &dedicatedAllocInfo);
+        }
+        else if(dedicatedImage != VK_NULL_HANDLE)
+        {
+            dedicatedAllocInfo.image = dedicatedImage;
+            VmaPnextChainPushFront(&allocInfo, &dedicatedAllocInfo);
+        }
+    }
+#endif // #if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
+
+#if VMA_BUFFER_DEVICE_ADDRESS
+    VkMemoryAllocateFlagsInfoKHR allocFlagsInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR };
+    if(m_UseKhrBufferDeviceAddress)
+    {
+        bool canContainBufferWithDeviceAddress = true;
+        if(dedicatedBuffer != VK_NULL_HANDLE)
+        {
+            canContainBufferWithDeviceAddress = dedicatedBufferUsage == UINT32_MAX || // Usage flags unknown
+                (dedicatedBufferUsage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT) != 0;
+        }
+        else if(dedicatedImage != VK_NULL_HANDLE)
+        {
+            canContainBufferWithDeviceAddress = false;
+        }
+        if(canContainBufferWithDeviceAddress)
+        {
+            allocFlagsInfo.flags = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR;
+            VmaPnextChainPushFront(&allocInfo, &allocFlagsInfo);
+        }
+    }
+#endif // #if VMA_BUFFER_DEVICE_ADDRESS
+
+#if VMA_MEMORY_PRIORITY
+    VkMemoryPriorityAllocateInfoEXT priorityInfo = { VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT };
+    if(m_UseExtMemoryPriority)
+    {
+        priorityInfo.priority = priority;
+        VmaPnextChainPushFront(&allocInfo, &priorityInfo);
+    }
+#endif // #if VMA_MEMORY_PRIORITY
+
+    size_t allocIndex;
+    VkResult res = VK_SUCCESS;
+    for(allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
+    {
+        res = AllocateDedicatedMemoryPage(
+            size,
+            suballocType,
+            memTypeIndex,
+            allocInfo,
+            map,
+            isUserDataString,
+            pUserData,
+            pAllocations + allocIndex);
+        if(res != VK_SUCCESS)
+        {
+            break;
+        }
+    }
+
+    if(res == VK_SUCCESS)
+    {
+        // Register them in m_pDedicatedAllocations.
+        {
+            VmaMutexLockWrite lock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
+            AllocationVectorType* pDedicatedAllocations = m_pDedicatedAllocations[memTypeIndex];
+            VMA_ASSERT(pDedicatedAllocations);
+            for(allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
+            {
+                VmaVectorInsertSorted<VmaPointerLess>(*pDedicatedAllocations, pAllocations[allocIndex]);
+            }
+        }
+
+        VMA_DEBUG_LOG("    Allocated DedicatedMemory Count=%zu, MemoryTypeIndex=#%u", allocationCount, memTypeIndex);
+    }
+    else
+    {
+        // Free all already created allocations.
+        while(allocIndex--)
+        {
+            VmaAllocation currAlloc = pAllocations[allocIndex];
+            VkDeviceMemory hMemory = currAlloc->GetMemory();
+
+            /*
+            There is no need to call this, because Vulkan spec allows to skip vkUnmapMemory
+            before vkFreeMemory.
+
+            if(currAlloc->GetMappedData() != VMA_NULL)
+            {
+                (*m_VulkanFunctions.vkUnmapMemory)(m_hDevice, hMemory);
+            }
+            */
+
+            FreeVulkanMemory(memTypeIndex, currAlloc->GetSize(), hMemory);
+            m_Budget.RemoveAllocation(MemoryTypeIndexToHeapIndex(memTypeIndex), currAlloc->GetSize());
+            currAlloc->SetUserData(this, VMA_NULL);
+            m_AllocationObjectAllocator.Free(currAlloc);
+        }
+
+        memset(pAllocations, 0, sizeof(VmaAllocation) * allocationCount);
+    }
+
+    return res;
+}
+
+VkResult VmaAllocator_T::AllocateDedicatedMemoryPage(
+    VkDeviceSize size,
+    VmaSuballocationType suballocType,
+    uint32_t memTypeIndex,
+    const VkMemoryAllocateInfo& allocInfo,
+    bool map,
+    bool isUserDataString,
+    void* pUserData,
+    VmaAllocation* pAllocation)
+{
+    VkDeviceMemory hMemory = VK_NULL_HANDLE;
+    VkResult res = AllocateVulkanMemory(&allocInfo, &hMemory);
+    if(res < 0)
+    {
+        VMA_DEBUG_LOG("    vkAllocateMemory FAILED");
+        return res;
+    }
+
+    void* pMappedData = VMA_NULL;
+    if(map)
+    {
+        res = (*m_VulkanFunctions.vkMapMemory)(
+            m_hDevice,
+            hMemory,
+            0,
+            VK_WHOLE_SIZE,
+            0,
+            &pMappedData);
+        if(res < 0)
+        {
+            VMA_DEBUG_LOG("    vkMapMemory FAILED");
+            FreeVulkanMemory(memTypeIndex, size, hMemory);
+            return res;
+        }
+    }
+
+    *pAllocation = m_AllocationObjectAllocator.Allocate(m_CurrentFrameIndex.load(), isUserDataString);
+    (*pAllocation)->InitDedicatedAllocation(memTypeIndex, hMemory, suballocType, pMappedData, size);
+    (*pAllocation)->SetUserData(this, pUserData);
+    m_Budget.AddAllocation(MemoryTypeIndexToHeapIndex(memTypeIndex), size);
+    if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
+    {
+        FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
+    }
+
+    return VK_SUCCESS;
+}
+
+void VmaAllocator_T::GetBufferMemoryRequirements(
+    VkBuffer hBuffer,
+    VkMemoryRequirements& memReq,
+    bool& requiresDedicatedAllocation,
+    bool& prefersDedicatedAllocation) const
+{
+#if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
+    if(m_UseKhrDedicatedAllocation || m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
+    {
+        VkBufferMemoryRequirementsInfo2KHR memReqInfo = { VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR };
+        memReqInfo.buffer = hBuffer;
+
+        VkMemoryDedicatedRequirementsKHR memDedicatedReq = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR };
+
+        VkMemoryRequirements2KHR memReq2 = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR };
+        VmaPnextChainPushFront(&memReq2, &memDedicatedReq);
+
+        (*m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR)(m_hDevice, &memReqInfo, &memReq2);
+
+        memReq = memReq2.memoryRequirements;
+        requiresDedicatedAllocation = (memDedicatedReq.requiresDedicatedAllocation != VK_FALSE);
+        prefersDedicatedAllocation  = (memDedicatedReq.prefersDedicatedAllocation  != VK_FALSE);
+    }
+    else
+#endif // #if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
+    {
+        (*m_VulkanFunctions.vkGetBufferMemoryRequirements)(m_hDevice, hBuffer, &memReq);
+        requiresDedicatedAllocation = false;
+        prefersDedicatedAllocation  = false;
+    }
+}
+
+void VmaAllocator_T::GetImageMemoryRequirements(
+    VkImage hImage,
+    VkMemoryRequirements& memReq,
+    bool& requiresDedicatedAllocation,
+    bool& prefersDedicatedAllocation) const
+{
+#if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
+    if(m_UseKhrDedicatedAllocation || m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
+    {
+        VkImageMemoryRequirementsInfo2KHR memReqInfo = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR };
+        memReqInfo.image = hImage;
+
+        VkMemoryDedicatedRequirementsKHR memDedicatedReq = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR };
+
+        VkMemoryRequirements2KHR memReq2 = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR };
+        VmaPnextChainPushFront(&memReq2, &memDedicatedReq);
+
+        (*m_VulkanFunctions.vkGetImageMemoryRequirements2KHR)(m_hDevice, &memReqInfo, &memReq2);
+
+        memReq = memReq2.memoryRequirements;
+        requiresDedicatedAllocation = (memDedicatedReq.requiresDedicatedAllocation != VK_FALSE);
+        prefersDedicatedAllocation  = (memDedicatedReq.prefersDedicatedAllocation  != VK_FALSE);
+    }
+    else
+#endif // #if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
+    {
+        (*m_VulkanFunctions.vkGetImageMemoryRequirements)(m_hDevice, hImage, &memReq);
+        requiresDedicatedAllocation = false;
+        prefersDedicatedAllocation  = false;
+    }
+}
+
+VkResult VmaAllocator_T::AllocateMemory(
+    const VkMemoryRequirements& vkMemReq,
+    bool requiresDedicatedAllocation,
+    bool prefersDedicatedAllocation,
+    VkBuffer dedicatedBuffer,
+    VkBufferUsageFlags dedicatedBufferUsage,
+    VkImage dedicatedImage,
+    const VmaAllocationCreateInfo& createInfo,
+    VmaSuballocationType suballocType,
+    size_t allocationCount,
+    VmaAllocation* pAllocations)
+{
+    memset(pAllocations, 0, sizeof(VmaAllocation) * allocationCount);
+
+    VMA_ASSERT(VmaIsPow2(vkMemReq.alignment));
+
+    if(vkMemReq.size == 0)
+    {
+        return VK_ERROR_VALIDATION_FAILED_EXT;
+    }
+    if((createInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0 &&
+        (createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
+    {
+        VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT together with VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT makes no sense.");
+        return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+    }
+    if((createInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
+        (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0)
+    {
+        VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_MAPPED_BIT together with VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT is invalid.");
+        return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+    }
+    if(requiresDedicatedAllocation)
+    {
+        if((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
+        {
+            VMA_ASSERT(0 && "VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT specified while dedicated allocation is required.");
+            return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+        }
+        if(createInfo.pool != VK_NULL_HANDLE)
+        {
+            VMA_ASSERT(0 && "Pool specified while dedicated allocation is required.");
+            return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+        }
+    }
+    if((createInfo.pool != VK_NULL_HANDLE) &&
+        ((createInfo.flags & (VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT)) != 0))
+    {
+        VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT when pool != null is invalid.");
+        return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+    }
+
+    if(createInfo.pool != VK_NULL_HANDLE)
+    {
+        const VkDeviceSize alignmentForPool = VMA_MAX(
+            vkMemReq.alignment,
+            GetMemoryTypeMinAlignment(createInfo.pool->m_BlockVector.GetMemoryTypeIndex()));
+
+        VmaAllocationCreateInfo createInfoForPool = createInfo;
+        // If memory type is not HOST_VISIBLE, disable MAPPED.
+        if((createInfoForPool.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
+            (m_MemProps.memoryTypes[createInfo.pool->m_BlockVector.GetMemoryTypeIndex()].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
+        {
+            createInfoForPool.flags &= ~VMA_ALLOCATION_CREATE_MAPPED_BIT;
+        }
+
+        return createInfo.pool->m_BlockVector.Allocate(
+            m_CurrentFrameIndex.load(),
+            vkMemReq.size,
+            alignmentForPool,
+            createInfoForPool,
+            suballocType,
+            allocationCount,
+            pAllocations);
+    }
+    else
+    {
+        // Bit mask of memory Vulkan types acceptable for this allocation.
+        uint32_t memoryTypeBits = vkMemReq.memoryTypeBits;
+        uint32_t memTypeIndex = UINT32_MAX;
+        VkResult res = vmaFindMemoryTypeIndex(this, memoryTypeBits, &createInfo, &memTypeIndex);
+        if(res == VK_SUCCESS)
+        {
+            VkDeviceSize alignmentForMemType = VMA_MAX(
+                vkMemReq.alignment,
+                GetMemoryTypeMinAlignment(memTypeIndex));
+
+            res = AllocateMemoryOfType(
+                vkMemReq.size,
+                alignmentForMemType,
+                requiresDedicatedAllocation || prefersDedicatedAllocation,
+                dedicatedBuffer,
+                dedicatedBufferUsage,
+                dedicatedImage,
+                createInfo,
+                memTypeIndex,
+                suballocType,
+                allocationCount,
+                pAllocations);
+            // Succeeded on first try.
+            if(res == VK_SUCCESS)
+            {
+                return res;
+            }
+            // Allocation from this memory type failed. Try other compatible memory types.
+            else
+            {
+                for(;;)
+                {
+                    // Remove old memTypeIndex from list of possibilities.
+                    memoryTypeBits &= ~(1u << memTypeIndex);
+                    // Find alternative memTypeIndex.
+                    res = vmaFindMemoryTypeIndex(this, memoryTypeBits, &createInfo, &memTypeIndex);
+                    if(res == VK_SUCCESS)
+                    {
+                        alignmentForMemType = VMA_MAX(
+                            vkMemReq.alignment,
+                            GetMemoryTypeMinAlignment(memTypeIndex));
+
+                        res = AllocateMemoryOfType(
+                            vkMemReq.size,
+                            alignmentForMemType,
+                            requiresDedicatedAllocation || prefersDedicatedAllocation,
+                            dedicatedBuffer,
+                            dedicatedBufferUsage,
+                            dedicatedImage,
+                            createInfo,
+                            memTypeIndex,
+                            suballocType,
+                            allocationCount,
+                            pAllocations);
+                        // Allocation from this alternative memory type succeeded.
+                        if(res == VK_SUCCESS)
+                        {
+                            return res;
+                        }
+                        // else: Allocation from this memory type failed. Try next one - next loop iteration.
+                    }
+                    // No other matching memory type index could be found.
+                    else
+                    {
+                        // Not returning res, which is VK_ERROR_FEATURE_NOT_PRESENT, because we already failed to allocate once.
+                        return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+                    }
+                }
+            }
+        }
+        // Can't find any single memory type maching requirements. res is VK_ERROR_FEATURE_NOT_PRESENT.
+        else
+            return res;
+    }
+}
+
+void VmaAllocator_T::FreeMemory(
+    size_t allocationCount,
+    const VmaAllocation* pAllocations)
+{
+    VMA_ASSERT(pAllocations);
+
+    for(size_t allocIndex = allocationCount; allocIndex--; )
+    {
+        VmaAllocation allocation = pAllocations[allocIndex];
+
+        if(allocation != VK_NULL_HANDLE)
+        {
+            if(TouchAllocation(allocation))
+            {
+                if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
+                {
+                    FillAllocation(allocation, VMA_ALLOCATION_FILL_PATTERN_DESTROYED);
+                }
+
+                switch(allocation->GetType())
+                {
+                case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
+                    {
+                        VmaBlockVector* pBlockVector = VMA_NULL;
+                        VmaPool hPool = allocation->GetBlock()->GetParentPool();
+                        if(hPool != VK_NULL_HANDLE)
+                        {
+                            pBlockVector = &hPool->m_BlockVector;
+                        }
+                        else
+                        {
+                            const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
+                            pBlockVector = m_pBlockVectors[memTypeIndex];
+                        }
+                        pBlockVector->Free(allocation);
+                    }
+                    break;
+                case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
+                    FreeDedicatedMemory(allocation);
+                    break;
+                default:
+                    VMA_ASSERT(0);
+                }
+            }
+
+            // Do this regardless of whether the allocation is lost. Lost allocations still account to Budget.AllocationBytes.
+            m_Budget.RemoveAllocation(MemoryTypeIndexToHeapIndex(allocation->GetMemoryTypeIndex()), allocation->GetSize());
+            allocation->SetUserData(this, VMA_NULL);
+            m_AllocationObjectAllocator.Free(allocation);
+        }
+    }
+}
+
+VkResult VmaAllocator_T::ResizeAllocation(
+    const VmaAllocation alloc,
+    VkDeviceSize newSize)
+{
+    // This function is deprecated and so it does nothing. It's left for backward compatibility.
+    if(newSize == 0 || alloc->GetLastUseFrameIndex() == VMA_FRAME_INDEX_LOST)
+    {
+        return VK_ERROR_VALIDATION_FAILED_EXT;
+    }
+    if(newSize == alloc->GetSize())
+    {
+        return VK_SUCCESS;
+    }
+    return VK_ERROR_OUT_OF_POOL_MEMORY;
+}
+
+void VmaAllocator_T::CalculateStats(VmaStats* pStats)
+{
+    // Initialize.
+    InitStatInfo(pStats->total);
+    for(size_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i)
+        InitStatInfo(pStats->memoryType[i]);
+    for(size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i)
+        InitStatInfo(pStats->memoryHeap[i]);
+
+    // Process default pools.
+    for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
+    {
+        VmaBlockVector* const pBlockVector = m_pBlockVectors[memTypeIndex];
+        VMA_ASSERT(pBlockVector);
+        pBlockVector->AddStats(pStats);
+    }
+
+    // Process custom pools.
+    {
+        VmaMutexLockRead lock(m_PoolsMutex, m_UseMutex);
+        for(size_t poolIndex = 0, poolCount = m_Pools.size(); poolIndex < poolCount; ++poolIndex)
+        {
+            m_Pools[poolIndex]->m_BlockVector.AddStats(pStats);
+        }
+    }
+
+    // Process dedicated allocations.
+    for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
+    {
+        const uint32_t memHeapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
+        VmaMutexLockRead dedicatedAllocationsLock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
+        AllocationVectorType* const pDedicatedAllocVector = m_pDedicatedAllocations[memTypeIndex];
+        VMA_ASSERT(pDedicatedAllocVector);
+        for(size_t allocIndex = 0, allocCount = pDedicatedAllocVector->size(); allocIndex < allocCount; ++allocIndex)
+        {
+            VmaStatInfo allocationStatInfo;
+            (*pDedicatedAllocVector)[allocIndex]->DedicatedAllocCalcStatsInfo(allocationStatInfo);
+            VmaAddStatInfo(pStats->total, allocationStatInfo);
+            VmaAddStatInfo(pStats->memoryType[memTypeIndex], allocationStatInfo);
+            VmaAddStatInfo(pStats->memoryHeap[memHeapIndex], allocationStatInfo);
+        }
+    }
+
+    // Postprocess.
+    VmaPostprocessCalcStatInfo(pStats->total);
+    for(size_t i = 0; i < GetMemoryTypeCount(); ++i)
+        VmaPostprocessCalcStatInfo(pStats->memoryType[i]);
+    for(size_t i = 0; i < GetMemoryHeapCount(); ++i)
+        VmaPostprocessCalcStatInfo(pStats->memoryHeap[i]);
+}
+
+void VmaAllocator_T::GetBudget(VmaBudget* outBudget, uint32_t firstHeap, uint32_t heapCount)
+{
+#if VMA_MEMORY_BUDGET
+    if(m_UseExtMemoryBudget)
+    {
+        if(m_Budget.m_OperationsSinceBudgetFetch < 30)
+        {
+            VmaMutexLockRead lockRead(m_Budget.m_BudgetMutex, m_UseMutex);
+            for(uint32_t i = 0; i < heapCount; ++i, ++outBudget)
+            {
+                const uint32_t heapIndex = firstHeap + i;
+
+                outBudget->blockBytes = m_Budget.m_BlockBytes[heapIndex];
+                outBudget->allocationBytes = m_Budget.m_AllocationBytes[heapIndex];
+
+                if(m_Budget.m_VulkanUsage[heapIndex] + outBudget->blockBytes > m_Budget.m_BlockBytesAtBudgetFetch[heapIndex])
+                {
+                    outBudget->usage = m_Budget.m_VulkanUsage[heapIndex] +
+                        outBudget->blockBytes - m_Budget.m_BlockBytesAtBudgetFetch[heapIndex];
+                }
+                else
+                {
+                    outBudget->usage = 0;
+                }
+
+                // Have to take MIN with heap size because explicit HeapSizeLimit is included in it.
+                outBudget->budget = VMA_MIN(
+                    m_Budget.m_VulkanBudget[heapIndex], m_MemProps.memoryHeaps[heapIndex].size);
+            }
+        }
+        else
+        {
+            UpdateVulkanBudget(); // Outside of mutex lock
+            GetBudget(outBudget, firstHeap, heapCount); // Recursion
+        }
+    }
+    else
+#endif
+    {
+        for(uint32_t i = 0; i < heapCount; ++i, ++outBudget)
+        {
+            const uint32_t heapIndex = firstHeap + i;
+
+            outBudget->blockBytes = m_Budget.m_BlockBytes[heapIndex];
+            outBudget->allocationBytes = m_Budget.m_AllocationBytes[heapIndex];
+
+            outBudget->usage = outBudget->blockBytes;
+            outBudget->budget = m_MemProps.memoryHeaps[heapIndex].size * 8 / 10; // 80% heuristics.
+        }
+    }
+}
+
+static const uint32_t VMA_VENDOR_ID_AMD = 4098;
+
+VkResult VmaAllocator_T::DefragmentationBegin(
+    const VmaDefragmentationInfo2& info,
+    VmaDefragmentationStats* pStats,
+    VmaDefragmentationContext* pContext)
+{
+    if(info.pAllocationsChanged != VMA_NULL)
+    {
+        memset(info.pAllocationsChanged, 0, info.allocationCount * sizeof(VkBool32));
+    }
+
+    *pContext = vma_new(this, VmaDefragmentationContext_T)(
+        this, m_CurrentFrameIndex.load(), info.flags, pStats);
+
+    (*pContext)->AddPools(info.poolCount, info.pPools);
+    (*pContext)->AddAllocations(
+        info.allocationCount, info.pAllocations, info.pAllocationsChanged);
+
+    VkResult res = (*pContext)->Defragment(
+        info.maxCpuBytesToMove, info.maxCpuAllocationsToMove,
+        info.maxGpuBytesToMove, info.maxGpuAllocationsToMove,
+        info.commandBuffer, pStats, info.flags);
+
+    if(res != VK_NOT_READY)
+    {
+        vma_delete(this, *pContext);
+        *pContext = VMA_NULL;
+    }
+
+    return res;
+}
+
+VkResult VmaAllocator_T::DefragmentationEnd(
+    VmaDefragmentationContext context)
+{
+    vma_delete(this, context);
+    return VK_SUCCESS;
+}
+
+VkResult VmaAllocator_T::DefragmentationPassBegin(
+    VmaDefragmentationPassInfo* pInfo,
+    VmaDefragmentationContext context)
+{
+    return context->DefragmentPassBegin(pInfo);
+}
+VkResult VmaAllocator_T::DefragmentationPassEnd(
+    VmaDefragmentationContext context)
+{
+    return context->DefragmentPassEnd();
+
+}
+
+void VmaAllocator_T::GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo)
+{
+    if(hAllocation->CanBecomeLost())
+    {
+        /*
+        Warning: This is a carefully designed algorithm.
+        Do not modify unless you really know what you're doing :)
+        */
+        const uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
+        uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
+        for(;;)
+        {
+            if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
+            {
+                pAllocationInfo->memoryType = UINT32_MAX;
+                pAllocationInfo->deviceMemory = VK_NULL_HANDLE;
+                pAllocationInfo->offset = 0;
+                pAllocationInfo->size = hAllocation->GetSize();
+                pAllocationInfo->pMappedData = VMA_NULL;
+                pAllocationInfo->pUserData = hAllocation->GetUserData();
+                return;
+            }
+            else if(localLastUseFrameIndex == localCurrFrameIndex)
+            {
+                pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();
+                pAllocationInfo->deviceMemory = hAllocation->GetMemory();
+                pAllocationInfo->offset = hAllocation->GetOffset();
+                pAllocationInfo->size = hAllocation->GetSize();
+                pAllocationInfo->pMappedData = VMA_NULL;
+                pAllocationInfo->pUserData = hAllocation->GetUserData();
+                return;
+            }
+            else // Last use time earlier than current time.
+            {
+                if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
+                {
+                    localLastUseFrameIndex = localCurrFrameIndex;
+                }
+            }
+        }
+    }
+    else
+    {
+#if VMA_STATS_STRING_ENABLED
+        uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
+        uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
+        for(;;)
+        {
+            VMA_ASSERT(localLastUseFrameIndex != VMA_FRAME_INDEX_LOST);
+            if(localLastUseFrameIndex == localCurrFrameIndex)
+            {
+                break;
+            }
+            else // Last use time earlier than current time.
+            {
+                if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
+                {
+                    localLastUseFrameIndex = localCurrFrameIndex;
+                }
+            }
+        }
+#endif
+
+        pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();
+        pAllocationInfo->deviceMemory = hAllocation->GetMemory();
+        pAllocationInfo->offset = hAllocation->GetOffset();
+        pAllocationInfo->size = hAllocation->GetSize();
+        pAllocationInfo->pMappedData = hAllocation->GetMappedData();
+        pAllocationInfo->pUserData = hAllocation->GetUserData();
+    }
+}
+
+bool VmaAllocator_T::TouchAllocation(VmaAllocation hAllocation)
+{
+    // This is a stripped-down version of VmaAllocator_T::GetAllocationInfo.
+    if(hAllocation->CanBecomeLost())
+    {
+        uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
+        uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
+        for(;;)
+        {
+            if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
+            {
+                return false;
+            }
+            else if(localLastUseFrameIndex == localCurrFrameIndex)
+            {
+                return true;
+            }
+            else // Last use time earlier than current time.
+            {
+                if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
+                {
+                    localLastUseFrameIndex = localCurrFrameIndex;
+                }
+            }
+        }
+    }
+    else
+    {
+#if VMA_STATS_STRING_ENABLED
+        uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
+        uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
+        for(;;)
+        {
+            VMA_ASSERT(localLastUseFrameIndex != VMA_FRAME_INDEX_LOST);
+            if(localLastUseFrameIndex == localCurrFrameIndex)
+            {
+                break;
+            }
+            else // Last use time earlier than current time.
+            {
+                if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
+                {
+                    localLastUseFrameIndex = localCurrFrameIndex;
+                }
+            }
+        }
+#endif
+
+        return true;
+    }
+}
+
+VkResult VmaAllocator_T::CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool)
+{
+    VMA_DEBUG_LOG("  CreatePool: MemoryTypeIndex=%u, flags=%u", pCreateInfo->memoryTypeIndex, pCreateInfo->flags);
+
+    VmaPoolCreateInfo newCreateInfo = *pCreateInfo;
+
+    if(newCreateInfo.maxBlockCount == 0)
+    {
+        newCreateInfo.maxBlockCount = SIZE_MAX;
+    }
+    if(newCreateInfo.minBlockCount > newCreateInfo.maxBlockCount)
+    {
+        return VK_ERROR_INITIALIZATION_FAILED;
+    }
+    // Memory type index out of range or forbidden.
+    if(pCreateInfo->memoryTypeIndex >= GetMemoryTypeCount() ||
+        ((1u << pCreateInfo->memoryTypeIndex) & m_GlobalMemoryTypeBits) == 0)
+    {
+        return VK_ERROR_FEATURE_NOT_PRESENT;
+    }
+
+    const VkDeviceSize preferredBlockSize = CalcPreferredBlockSize(newCreateInfo.memoryTypeIndex);
+
+    *pPool = vma_new(this, VmaPool_T)(this, newCreateInfo, preferredBlockSize);
+
+    VkResult res = (*pPool)->m_BlockVector.CreateMinBlocks();
+    if(res != VK_SUCCESS)
+    {
+        vma_delete(this, *pPool);
+        *pPool = VMA_NULL;
+        return res;
+    }
+
+    // Add to m_Pools.
+    {
+        VmaMutexLockWrite lock(m_PoolsMutex, m_UseMutex);
+        (*pPool)->SetId(m_NextPoolId++);
+        VmaVectorInsertSorted<VmaPointerLess>(m_Pools, *pPool);
+    }
+
+    return VK_SUCCESS;
+}
+
+void VmaAllocator_T::DestroyPool(VmaPool pool)
+{
+    // Remove from m_Pools.
+    {
+        VmaMutexLockWrite lock(m_PoolsMutex, m_UseMutex);
+        bool success = VmaVectorRemoveSorted<VmaPointerLess>(m_Pools, pool);
+        VMA_ASSERT(success && "Pool not found in Allocator.");
+    }
+
+    vma_delete(this, pool);
+}
+
+void VmaAllocator_T::GetPoolStats(VmaPool pool, VmaPoolStats* pPoolStats)
+{
+    pool->m_BlockVector.GetPoolStats(pPoolStats);
+}
+
+void VmaAllocator_T::SetCurrentFrameIndex(uint32_t frameIndex)
+{
+    m_CurrentFrameIndex.store(frameIndex);
+
+#if VMA_MEMORY_BUDGET
+    if(m_UseExtMemoryBudget)
+    {
+        UpdateVulkanBudget();
+    }
+#endif // #if VMA_MEMORY_BUDGET
+}
+
+void VmaAllocator_T::MakePoolAllocationsLost(
+    VmaPool hPool,
+    size_t* pLostAllocationCount)
+{
+    hPool->m_BlockVector.MakePoolAllocationsLost(
+        m_CurrentFrameIndex.load(),
+        pLostAllocationCount);
+}
+
+VkResult VmaAllocator_T::CheckPoolCorruption(VmaPool hPool)
+{
+    return hPool->m_BlockVector.CheckCorruption();
+}
+
+VkResult VmaAllocator_T::CheckCorruption(uint32_t memoryTypeBits)
+{
+    VkResult finalRes = VK_ERROR_FEATURE_NOT_PRESENT;
+
+    // Process default pools.
+    for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
+    {
+        if(((1u << memTypeIndex) & memoryTypeBits) != 0)
+        {
+            VmaBlockVector* const pBlockVector = m_pBlockVectors[memTypeIndex];
+            VMA_ASSERT(pBlockVector);
+            VkResult localRes = pBlockVector->CheckCorruption();
+            switch(localRes)
+            {
+            case VK_ERROR_FEATURE_NOT_PRESENT:
+                break;
+            case VK_SUCCESS:
+                finalRes = VK_SUCCESS;
+                break;
+            default:
+                return localRes;
+            }
+        }
+    }
+
+    // Process custom pools.
+    {
+        VmaMutexLockRead lock(m_PoolsMutex, m_UseMutex);
+        for(size_t poolIndex = 0, poolCount = m_Pools.size(); poolIndex < poolCount; ++poolIndex)
+        {
+            if(((1u << m_Pools[poolIndex]->m_BlockVector.GetMemoryTypeIndex()) & memoryTypeBits) != 0)
+            {
+                VkResult localRes = m_Pools[poolIndex]->m_BlockVector.CheckCorruption();
+                switch(localRes)
+                {
+                case VK_ERROR_FEATURE_NOT_PRESENT:
+                    break;
+                case VK_SUCCESS:
+                    finalRes = VK_SUCCESS;
+                    break;
+                default:
+                    return localRes;
+                }
+            }
+        }
+    }
+
+    return finalRes;
+}
+
+void VmaAllocator_T::CreateLostAllocation(VmaAllocation* pAllocation)
+{
+    *pAllocation = m_AllocationObjectAllocator.Allocate(VMA_FRAME_INDEX_LOST, false);
+    (*pAllocation)->InitLost();
+}
+
+VkResult VmaAllocator_T::AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory)
+{
+    const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(pAllocateInfo->memoryTypeIndex);
+
+    // HeapSizeLimit is in effect for this heap.
+    if((m_HeapSizeLimitMask & (1u << heapIndex)) != 0)
+    {
+        const VkDeviceSize heapSize = m_MemProps.memoryHeaps[heapIndex].size;
+        VkDeviceSize blockBytes = m_Budget.m_BlockBytes[heapIndex];
+        for(;;)
+        {
+            const VkDeviceSize blockBytesAfterAllocation = blockBytes + pAllocateInfo->allocationSize;
+            if(blockBytesAfterAllocation > heapSize)
+            {
+                return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+            }
+            if(m_Budget.m_BlockBytes[heapIndex].compare_exchange_strong(blockBytes, blockBytesAfterAllocation))
+            {
+                break;
+            }
+        }
+    }
+    else
+    {
+        m_Budget.m_BlockBytes[heapIndex] += pAllocateInfo->allocationSize;
+    }
+
+    // VULKAN CALL vkAllocateMemory.
+    VkResult res = (*m_VulkanFunctions.vkAllocateMemory)(m_hDevice, pAllocateInfo, GetAllocationCallbacks(), pMemory);
+
+    if(res == VK_SUCCESS)
+    {
+#if VMA_MEMORY_BUDGET
+        ++m_Budget.m_OperationsSinceBudgetFetch;
+#endif
+
+        // Informative callback.
+        if(m_DeviceMemoryCallbacks.pfnAllocate != VMA_NULL)
+        {
+            (*m_DeviceMemoryCallbacks.pfnAllocate)(this, pAllocateInfo->memoryTypeIndex, *pMemory, pAllocateInfo->allocationSize, m_DeviceMemoryCallbacks.pUserData);
+        }
+    }
+    else
+    {
+        m_Budget.m_BlockBytes[heapIndex] -= pAllocateInfo->allocationSize;
+    }
+
+    return res;
+}
+
+void VmaAllocator_T::FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory)
+{
+    // Informative callback.
+    if(m_DeviceMemoryCallbacks.pfnFree != VMA_NULL)
+    {
+        (*m_DeviceMemoryCallbacks.pfnFree)(this, memoryType, hMemory, size, m_DeviceMemoryCallbacks.pUserData);
+    }
+
+    // VULKAN CALL vkFreeMemory.
+    (*m_VulkanFunctions.vkFreeMemory)(m_hDevice, hMemory, GetAllocationCallbacks());
+
+    m_Budget.m_BlockBytes[MemoryTypeIndexToHeapIndex(memoryType)] -= size;
+}
+
+VkResult VmaAllocator_T::BindVulkanBuffer(
+    VkDeviceMemory memory,
+    VkDeviceSize memoryOffset,
+    VkBuffer buffer,
+    const void* pNext)
+{
+    if(pNext != VMA_NULL)
+    {
+#if VMA_VULKAN_VERSION >= 1001000 || VMA_BIND_MEMORY2
+        if((m_UseKhrBindMemory2 || m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0)) &&
+            m_VulkanFunctions.vkBindBufferMemory2KHR != VMA_NULL)
+        {
+            VkBindBufferMemoryInfoKHR bindBufferMemoryInfo = { VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR };
+            bindBufferMemoryInfo.pNext = pNext;
+            bindBufferMemoryInfo.buffer = buffer;
+            bindBufferMemoryInfo.memory = memory;
+            bindBufferMemoryInfo.memoryOffset = memoryOffset;
+            return (*m_VulkanFunctions.vkBindBufferMemory2KHR)(m_hDevice, 1, &bindBufferMemoryInfo);
+        }
+        else
+#endif // #if VMA_VULKAN_VERSION >= 1001000 || VMA_BIND_MEMORY2
+        {
+            return VK_ERROR_EXTENSION_NOT_PRESENT;
+        }
+    }
+    else
+    {
+        return (*m_VulkanFunctions.vkBindBufferMemory)(m_hDevice, buffer, memory, memoryOffset);
+    }
+}
+
+VkResult VmaAllocator_T::BindVulkanImage(
+    VkDeviceMemory memory,
+    VkDeviceSize memoryOffset,
+    VkImage image,
+    const void* pNext)
+{
+    if(pNext != VMA_NULL)
+    {
+#if VMA_VULKAN_VERSION >= 1001000 || VMA_BIND_MEMORY2
+        if((m_UseKhrBindMemory2 || m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0)) &&
+            m_VulkanFunctions.vkBindImageMemory2KHR != VMA_NULL)
+        {
+            VkBindImageMemoryInfoKHR bindBufferMemoryInfo = { VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR };
+            bindBufferMemoryInfo.pNext = pNext;
+            bindBufferMemoryInfo.image = image;
+            bindBufferMemoryInfo.memory = memory;
+            bindBufferMemoryInfo.memoryOffset = memoryOffset;
+            return (*m_VulkanFunctions.vkBindImageMemory2KHR)(m_hDevice, 1, &bindBufferMemoryInfo);
+        }
+        else
+#endif // #if VMA_BIND_MEMORY2
+        {
+            return VK_ERROR_EXTENSION_NOT_PRESENT;
+        }
+    }
+    else
+    {
+        return (*m_VulkanFunctions.vkBindImageMemory)(m_hDevice, image, memory, memoryOffset);
+    }
+}
+
+VkResult VmaAllocator_T::Map(VmaAllocation hAllocation, void** ppData)
+{
+    if(hAllocation->CanBecomeLost())
+    {
+        return VK_ERROR_MEMORY_MAP_FAILED;
+    }
+
+    switch(hAllocation->GetType())
+    {
+    case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
+        {
+            VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
+            char *pBytes = VMA_NULL;
+            VkResult res = pBlock->Map(this, 1, (void**)&pBytes);
+            if(res == VK_SUCCESS)
+            {
+                *ppData = pBytes + (ptrdiff_t)hAllocation->GetOffset();
+                hAllocation->BlockAllocMap();
+            }
+            return res;
+        }
+    case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
+        return hAllocation->DedicatedAllocMap(this, ppData);
+    default:
+        VMA_ASSERT(0);
+        return VK_ERROR_MEMORY_MAP_FAILED;
+    }
+}
+
+void VmaAllocator_T::Unmap(VmaAllocation hAllocation)
+{
+    switch(hAllocation->GetType())
+    {
+    case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
+        {
+            VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
+            hAllocation->BlockAllocUnmap();
+            pBlock->Unmap(this, 1);
+        }
+        break;
+    case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
+        hAllocation->DedicatedAllocUnmap(this);
+        break;
+    default:
+        VMA_ASSERT(0);
+    }
+}
+
+VkResult VmaAllocator_T::BindBufferMemory(
+    VmaAllocation hAllocation,
+    VkDeviceSize allocationLocalOffset,
+    VkBuffer hBuffer,
+    const void* pNext)
+{
+    VkResult res = VK_SUCCESS;
+    switch(hAllocation->GetType())
+    {
+    case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
+        res = BindVulkanBuffer(hAllocation->GetMemory(), allocationLocalOffset, hBuffer, pNext);
+        break;
+    case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
+    {
+        VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
+        VMA_ASSERT(pBlock && "Binding buffer to allocation that doesn't belong to any block. Is the allocation lost?");
+        res = pBlock->BindBufferMemory(this, hAllocation, allocationLocalOffset, hBuffer, pNext);
+        break;
+    }
+    default:
+        VMA_ASSERT(0);
+    }
+    return res;
+}
+
+VkResult VmaAllocator_T::BindImageMemory(
+    VmaAllocation hAllocation,
+    VkDeviceSize allocationLocalOffset,
+    VkImage hImage,
+    const void* pNext)
+{
+    VkResult res = VK_SUCCESS;
+    switch(hAllocation->GetType())
+    {
+    case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
+        res = BindVulkanImage(hAllocation->GetMemory(), allocationLocalOffset, hImage, pNext);
+        break;
+    case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
+    {
+        VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
+        VMA_ASSERT(pBlock && "Binding image to allocation that doesn't belong to any block. Is the allocation lost?");
+        res = pBlock->BindImageMemory(this, hAllocation, allocationLocalOffset, hImage, pNext);
+        break;
+    }
+    default:
+        VMA_ASSERT(0);
+    }
+    return res;
+}
+
+VkResult VmaAllocator_T::FlushOrInvalidateAllocation(
+    VmaAllocation hAllocation,
+    VkDeviceSize offset, VkDeviceSize size,
+    VMA_CACHE_OPERATION op)
+{
+    VkResult res = VK_SUCCESS;
+
+    VkMappedMemoryRange memRange = {};
+    if(GetFlushOrInvalidateRange(hAllocation, offset, size, memRange))
+    {
+        switch(op)
+        {
+        case VMA_CACHE_FLUSH:
+            res = (*GetVulkanFunctions().vkFlushMappedMemoryRanges)(m_hDevice, 1, &memRange);
+            break;
+        case VMA_CACHE_INVALIDATE:
+            res = (*GetVulkanFunctions().vkInvalidateMappedMemoryRanges)(m_hDevice, 1, &memRange);
+            break;
+        default:
+            VMA_ASSERT(0);
+        }
+    }
+    // else: Just ignore this call.
+    return res;
+}
+
+VkResult VmaAllocator_T::FlushOrInvalidateAllocations(
+    uint32_t allocationCount,
+    const VmaAllocation* allocations,
+    const VkDeviceSize* offsets, const VkDeviceSize* sizes,
+    VMA_CACHE_OPERATION op)
+{
+    typedef VmaStlAllocator<VkMappedMemoryRange> RangeAllocator;
+    typedef VmaSmallVector<VkMappedMemoryRange, RangeAllocator, 16> RangeVector;
+    RangeVector ranges = RangeVector(RangeAllocator(GetAllocationCallbacks()));
+
+    for(uint32_t allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
+    {
+        const VmaAllocation alloc = allocations[allocIndex];
+        const VkDeviceSize offset = offsets != VMA_NULL ? offsets[allocIndex] : 0;
+        const VkDeviceSize size = sizes != VMA_NULL ? sizes[allocIndex] : VK_WHOLE_SIZE;
+        VkMappedMemoryRange newRange;
+        if(GetFlushOrInvalidateRange(alloc, offset, size, newRange))
+        {
+            ranges.push_back(newRange);
+        }
+    }
+
+    VkResult res = VK_SUCCESS;
+    if(!ranges.empty())
+    {
+        switch(op)
+        {
+        case VMA_CACHE_FLUSH:
+            res = (*GetVulkanFunctions().vkFlushMappedMemoryRanges)(m_hDevice, (uint32_t)ranges.size(), ranges.data());
+            break;
+        case VMA_CACHE_INVALIDATE:
+            res = (*GetVulkanFunctions().vkInvalidateMappedMemoryRanges)(m_hDevice, (uint32_t)ranges.size(), ranges.data());
+            break;
+        default:
+            VMA_ASSERT(0);
+        }
+    }
+    // else: Just ignore this call.
+    return res;
+}
+
+void VmaAllocator_T::FreeDedicatedMemory(const VmaAllocation allocation)
+{
+    VMA_ASSERT(allocation && allocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_DEDICATED);
+
+    const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
+    {
+        VmaMutexLockWrite lock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
+        AllocationVectorType* const pDedicatedAllocations = m_pDedicatedAllocations[memTypeIndex];
+        VMA_ASSERT(pDedicatedAllocations);
+        bool success = VmaVectorRemoveSorted<VmaPointerLess>(*pDedicatedAllocations, allocation);
+        VMA_ASSERT(success);
+    }
+
+    VkDeviceMemory hMemory = allocation->GetMemory();
+
+    /*
+    There is no need to call this, because Vulkan spec allows to skip vkUnmapMemory
+    before vkFreeMemory.
+
+    if(allocation->GetMappedData() != VMA_NULL)
+    {
+        (*m_VulkanFunctions.vkUnmapMemory)(m_hDevice, hMemory);
+    }
+    */
+
+    FreeVulkanMemory(memTypeIndex, allocation->GetSize(), hMemory);
+
+    VMA_DEBUG_LOG("    Freed DedicatedMemory MemoryTypeIndex=%u", memTypeIndex);
+}
+
+uint32_t VmaAllocator_T::CalculateGpuDefragmentationMemoryTypeBits() const
+{
+    VkBufferCreateInfo dummyBufCreateInfo;
+    VmaFillGpuDefragmentationBufferCreateInfo(dummyBufCreateInfo);
+
+    uint32_t memoryTypeBits = 0;
+
+    // Create buffer.
+    VkBuffer buf = VK_NULL_HANDLE;
+    VkResult res = (*GetVulkanFunctions().vkCreateBuffer)(
+        m_hDevice, &dummyBufCreateInfo, GetAllocationCallbacks(), &buf);
+    if(res == VK_SUCCESS)
+    {
+        // Query for supported memory types.
+        VkMemoryRequirements memReq;
+        (*GetVulkanFunctions().vkGetBufferMemoryRequirements)(m_hDevice, buf, &memReq);
+        memoryTypeBits = memReq.memoryTypeBits;
+
+        // Destroy buffer.
+        (*GetVulkanFunctions().vkDestroyBuffer)(m_hDevice, buf, GetAllocationCallbacks());
+    }
+
+    return memoryTypeBits;
+}
+
+uint32_t VmaAllocator_T::CalculateGlobalMemoryTypeBits() const
+{
+    // Make sure memory information is already fetched.
+    VMA_ASSERT(GetMemoryTypeCount() > 0);
+
+    uint32_t memoryTypeBits = UINT32_MAX;
+
+    if(!m_UseAmdDeviceCoherentMemory)
+    {
+        // Exclude memory types that have VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD.
+        for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
+        {
+            if((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD_COPY) != 0)
+            {
+                memoryTypeBits &= ~(1u << memTypeIndex);
+            }
+        }
+    }
+
+    return memoryTypeBits;
+}
+
+bool VmaAllocator_T::GetFlushOrInvalidateRange(
+    VmaAllocation allocation,
+    VkDeviceSize offset, VkDeviceSize size,
+    VkMappedMemoryRange& outRange) const
+{
+    const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
+    if(size > 0 && IsMemoryTypeNonCoherent(memTypeIndex))
+    {
+        const VkDeviceSize nonCoherentAtomSize = m_PhysicalDeviceProperties.limits.nonCoherentAtomSize;
+        const VkDeviceSize allocationSize = allocation->GetSize();
+        VMA_ASSERT(offset <= allocationSize);
+
+        outRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
+        outRange.pNext = VMA_NULL;
+        outRange.memory = allocation->GetMemory();
+
+        switch(allocation->GetType())
+        {
+        case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
+            outRange.offset = VmaAlignDown(offset, nonCoherentAtomSize);
+            if(size == VK_WHOLE_SIZE)
+            {
+                outRange.size = allocationSize - outRange.offset;
+            }
+            else
+            {
+                VMA_ASSERT(offset + size <= allocationSize);
+                outRange.size = VMA_MIN(
+                    VmaAlignUp(size + (offset - outRange.offset), nonCoherentAtomSize),
+                    allocationSize - outRange.offset);
+            }
+            break;
+        case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
+        {
+            // 1. Still within this allocation.
+            outRange.offset = VmaAlignDown(offset, nonCoherentAtomSize);
+            if(size == VK_WHOLE_SIZE)
+            {
+                size = allocationSize - offset;
+            }
+            else
+            {
+                VMA_ASSERT(offset + size <= allocationSize);
+            }
+            outRange.size = VmaAlignUp(size + (offset - outRange.offset), nonCoherentAtomSize);
+
+            // 2. Adjust to whole block.
+            const VkDeviceSize allocationOffset = allocation->GetOffset();
+            VMA_ASSERT(allocationOffset % nonCoherentAtomSize == 0);
+            const VkDeviceSize blockSize = allocation->GetBlock()->m_pMetadata->GetSize();
+            outRange.offset += allocationOffset;
+            outRange.size = VMA_MIN(outRange.size, blockSize - outRange.offset);
+
+            break;
+        }
+        default:
+            VMA_ASSERT(0);
+        }
+        return true;
+    }
+    return false;
+}
+
+#if VMA_MEMORY_BUDGET
+
+void VmaAllocator_T::UpdateVulkanBudget()
+{
+    VMA_ASSERT(m_UseExtMemoryBudget);
+
+    VkPhysicalDeviceMemoryProperties2KHR memProps = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR };
+
+    VkPhysicalDeviceMemoryBudgetPropertiesEXT budgetProps = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT };
+    VmaPnextChainPushFront(&memProps, &budgetProps);
+
+    GetVulkanFunctions().vkGetPhysicalDeviceMemoryProperties2KHR(m_PhysicalDevice, &memProps);
+
+    {
+        VmaMutexLockWrite lockWrite(m_Budget.m_BudgetMutex, m_UseMutex);
+
+        for(uint32_t heapIndex = 0; heapIndex < GetMemoryHeapCount(); ++heapIndex)
+        {
+            m_Budget.m_VulkanUsage[heapIndex] = budgetProps.heapUsage[heapIndex];
+            m_Budget.m_VulkanBudget[heapIndex] = budgetProps.heapBudget[heapIndex];
+            m_Budget.m_BlockBytesAtBudgetFetch[heapIndex] = m_Budget.m_BlockBytes[heapIndex].load();
+
+            // Some bugged drivers return the budget incorrectly, e.g. 0 or much bigger than heap size.
+            if(m_Budget.m_VulkanBudget[heapIndex] == 0)
+            {
+                m_Budget.m_VulkanBudget[heapIndex] = m_MemProps.memoryHeaps[heapIndex].size * 8 / 10; // 80% heuristics.
+            }
+            else if(m_Budget.m_VulkanBudget[heapIndex] > m_MemProps.memoryHeaps[heapIndex].size)
+            {
+                m_Budget.m_VulkanBudget[heapIndex] = m_MemProps.memoryHeaps[heapIndex].size;
+            }
+            if(m_Budget.m_VulkanUsage[heapIndex] == 0 && m_Budget.m_BlockBytesAtBudgetFetch[heapIndex] > 0)
+            {
+                m_Budget.m_VulkanUsage[heapIndex] = m_Budget.m_BlockBytesAtBudgetFetch[heapIndex];
+            }
+        }
+        m_Budget.m_OperationsSinceBudgetFetch = 0;
+    }
+}
+
+#endif // #if VMA_MEMORY_BUDGET
+
+void VmaAllocator_T::FillAllocation(const VmaAllocation hAllocation, uint8_t pattern)
+{
+    if(VMA_DEBUG_INITIALIZE_ALLOCATIONS &&
+        !hAllocation->CanBecomeLost() &&
+        (m_MemProps.memoryTypes[hAllocation->GetMemoryTypeIndex()].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
+    {
+        void* pData = VMA_NULL;
+        VkResult res = Map(hAllocation, &pData);
+        if(res == VK_SUCCESS)
+        {
+            memset(pData, (int)pattern, (size_t)hAllocation->GetSize());
+            FlushOrInvalidateAllocation(hAllocation, 0, VK_WHOLE_SIZE, VMA_CACHE_FLUSH);
+            Unmap(hAllocation);
+        }
+        else
+        {
+            VMA_ASSERT(0 && "VMA_DEBUG_INITIALIZE_ALLOCATIONS is enabled, but couldn't map memory to fill allocation.");
+        }
+    }
+}
+
+uint32_t VmaAllocator_T::GetGpuDefragmentationMemoryTypeBits()
+{
+    uint32_t memoryTypeBits = m_GpuDefragmentationMemoryTypeBits.load();
+    if(memoryTypeBits == UINT32_MAX)
+    {
+        memoryTypeBits = CalculateGpuDefragmentationMemoryTypeBits();
+        m_GpuDefragmentationMemoryTypeBits.store(memoryTypeBits);
+    }
+    return memoryTypeBits;
+}
+
+#if VMA_STATS_STRING_ENABLED
+
+void VmaAllocator_T::PrintDetailedMap(VmaJsonWriter& json)
+{
+    bool dedicatedAllocationsStarted = false;
+    for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
+    {
+        VmaMutexLockRead dedicatedAllocationsLock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
+        AllocationVectorType* const pDedicatedAllocVector = m_pDedicatedAllocations[memTypeIndex];
+        VMA_ASSERT(pDedicatedAllocVector);
+        if(pDedicatedAllocVector->empty() == false)
+        {
+            if(dedicatedAllocationsStarted == false)
+            {
+                dedicatedAllocationsStarted = true;
+                json.WriteString("DedicatedAllocations");
+                json.BeginObject();
+            }
+
+            json.BeginString("Type ");
+            json.ContinueString(memTypeIndex);
+            json.EndString();
+
+            json.BeginArray();
+
+            for(size_t i = 0; i < pDedicatedAllocVector->size(); ++i)
+            {
+                json.BeginObject(true);
+                const VmaAllocation hAlloc = (*pDedicatedAllocVector)[i];
+                hAlloc->PrintParameters(json);
+                json.EndObject();
+            }
+
+            json.EndArray();
+        }
+    }
+    if(dedicatedAllocationsStarted)
+    {
+        json.EndObject();
+    }
+
+    {
+        bool allocationsStarted = false;
+        for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
+        {
+            if(m_pBlockVectors[memTypeIndex]->IsEmpty() == false)
+            {
+                if(allocationsStarted == false)
+                {
+                    allocationsStarted = true;
+                    json.WriteString("DefaultPools");
+                    json.BeginObject();
+                }
+
+                json.BeginString("Type ");
+                json.ContinueString(memTypeIndex);
+                json.EndString();
+
+                m_pBlockVectors[memTypeIndex]->PrintDetailedMap(json);
+            }
+        }
+        if(allocationsStarted)
+        {
+            json.EndObject();
+        }
+    }
+
+    // Custom pools
+    {
+        VmaMutexLockRead lock(m_PoolsMutex, m_UseMutex);
+        const size_t poolCount = m_Pools.size();
+        if(poolCount > 0)
+        {
+            json.WriteString("Pools");
+            json.BeginObject();
+            for(size_t poolIndex = 0; poolIndex < poolCount; ++poolIndex)
+            {
+                json.BeginString();
+                json.ContinueString(m_Pools[poolIndex]->GetId());
+                json.EndString();
+
+                m_Pools[poolIndex]->m_BlockVector.PrintDetailedMap(json);
+            }
+            json.EndObject();
+        }
+    }
+}
+
+#endif // #if VMA_STATS_STRING_ENABLED
+
+////////////////////////////////////////////////////////////////////////////////
+// Public interface
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAllocator(
+    const VmaAllocatorCreateInfo* pCreateInfo,
+    VmaAllocator* pAllocator)
+{
+    VMA_ASSERT(pCreateInfo && pAllocator);
+    VMA_ASSERT(pCreateInfo->vulkanApiVersion == 0 ||
+        (VK_VERSION_MAJOR(pCreateInfo->vulkanApiVersion) == 1 && VK_VERSION_MINOR(pCreateInfo->vulkanApiVersion) <= 2));
+    VMA_DEBUG_LOG("vmaCreateAllocator");
+    *pAllocator = vma_new(pCreateInfo->pAllocationCallbacks, VmaAllocator_T)(pCreateInfo);
+    return (*pAllocator)->Init(pCreateInfo);
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaDestroyAllocator(
+    VmaAllocator allocator)
+{
+    if(allocator != VK_NULL_HANDLE)
+    {
+        VMA_DEBUG_LOG("vmaDestroyAllocator");
+        VkAllocationCallbacks allocationCallbacks = allocator->m_AllocationCallbacks;
+        vma_delete(&allocationCallbacks, allocator);
+    }
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaGetAllocatorInfo(VmaAllocator allocator, VmaAllocatorInfo* pAllocatorInfo)
+{
+    VMA_ASSERT(allocator && pAllocatorInfo);
+    pAllocatorInfo->instance = allocator->m_hInstance;
+    pAllocatorInfo->physicalDevice = allocator->GetPhysicalDevice();
+    pAllocatorInfo->device = allocator->m_hDevice;
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaGetPhysicalDeviceProperties(
+    VmaAllocator allocator,
+    const VkPhysicalDeviceProperties **ppPhysicalDeviceProperties)
+{
+    VMA_ASSERT(allocator && ppPhysicalDeviceProperties);
+    *ppPhysicalDeviceProperties = &allocator->m_PhysicalDeviceProperties;
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaGetMemoryProperties(
+    VmaAllocator allocator,
+    const VkPhysicalDeviceMemoryProperties** ppPhysicalDeviceMemoryProperties)
+{
+    VMA_ASSERT(allocator && ppPhysicalDeviceMemoryProperties);
+    *ppPhysicalDeviceMemoryProperties = &allocator->m_MemProps;
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaGetMemoryTypeProperties(
+    VmaAllocator allocator,
+    uint32_t memoryTypeIndex,
+    VkMemoryPropertyFlags* pFlags)
+{
+    VMA_ASSERT(allocator && pFlags);
+    VMA_ASSERT(memoryTypeIndex < allocator->GetMemoryTypeCount());
+    *pFlags = allocator->m_MemProps.memoryTypes[memoryTypeIndex].propertyFlags;
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaSetCurrentFrameIndex(
+    VmaAllocator allocator,
+    uint32_t frameIndex)
+{
+    VMA_ASSERT(allocator);
+    VMA_ASSERT(frameIndex != VMA_FRAME_INDEX_LOST);
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    allocator->SetCurrentFrameIndex(frameIndex);
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaCalculateStats(
+    VmaAllocator allocator,
+    VmaStats* pStats)
+{
+    VMA_ASSERT(allocator && pStats);
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+    allocator->CalculateStats(pStats);
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaGetBudget(
+    VmaAllocator allocator,
+    VmaBudget* pBudget)
+{
+    VMA_ASSERT(allocator && pBudget);
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+    allocator->GetBudget(pBudget, 0, allocator->GetMemoryHeapCount());
+}
+
+#if VMA_STATS_STRING_ENABLED
+
+VMA_CALL_PRE void VMA_CALL_POST vmaBuildStatsString(
+    VmaAllocator allocator,
+    char** ppStatsString,
+    VkBool32 detailedMap)
+{
+    VMA_ASSERT(allocator && ppStatsString);
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    VmaStringBuilder sb(allocator);
+    {
+        VmaJsonWriter json(allocator->GetAllocationCallbacks(), sb);
+        json.BeginObject();
+
+        VmaBudget budget[VK_MAX_MEMORY_HEAPS];
+        allocator->GetBudget(budget, 0, allocator->GetMemoryHeapCount());
+
+        VmaStats stats;
+        allocator->CalculateStats(&stats);
+
+        json.WriteString("Total");
+        VmaPrintStatInfo(json, stats.total);
+
+        for(uint32_t heapIndex = 0; heapIndex < allocator->GetMemoryHeapCount(); ++heapIndex)
+        {
+            json.BeginString("Heap ");
+            json.ContinueString(heapIndex);
+            json.EndString();
+            json.BeginObject();
+
+            json.WriteString("Size");
+            json.WriteNumber(allocator->m_MemProps.memoryHeaps[heapIndex].size);
+
+            json.WriteString("Flags");
+            json.BeginArray(true);
+            if((allocator->m_MemProps.memoryHeaps[heapIndex].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) != 0)
+            {
+                json.WriteString("DEVICE_LOCAL");
+            }
+            json.EndArray();
+
+            json.WriteString("Budget");
+            json.BeginObject();
+            {
+                json.WriteString("BlockBytes");
+                json.WriteNumber(budget[heapIndex].blockBytes);
+                json.WriteString("AllocationBytes");
+                json.WriteNumber(budget[heapIndex].allocationBytes);
+                json.WriteString("Usage");
+                json.WriteNumber(budget[heapIndex].usage);
+                json.WriteString("Budget");
+                json.WriteNumber(budget[heapIndex].budget);
+            }
+            json.EndObject();
+
+            if(stats.memoryHeap[heapIndex].blockCount > 0)
+            {
+                json.WriteString("Stats");
+                VmaPrintStatInfo(json, stats.memoryHeap[heapIndex]);
+            }
+
+            for(uint32_t typeIndex = 0; typeIndex < allocator->GetMemoryTypeCount(); ++typeIndex)
+            {
+                if(allocator->MemoryTypeIndexToHeapIndex(typeIndex) == heapIndex)
+                {
+                    json.BeginString("Type ");
+                    json.ContinueString(typeIndex);
+                    json.EndString();
+
+                    json.BeginObject();
+
+                    json.WriteString("Flags");
+                    json.BeginArray(true);
+                    VkMemoryPropertyFlags flags = allocator->m_MemProps.memoryTypes[typeIndex].propertyFlags;
+                    if((flags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0)
+                    {
+                        json.WriteString("DEVICE_LOCAL");
+                    }
+                    if((flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
+                    {
+                        json.WriteString("HOST_VISIBLE");
+                    }
+                    if((flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) != 0)
+                    {
+                        json.WriteString("HOST_COHERENT");
+                    }
+                    if((flags & VK_MEMORY_PROPERTY_HOST_CACHED_BIT) != 0)
+                    {
+                        json.WriteString("HOST_CACHED");
+                    }
+                    if((flags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) != 0)
+                    {
+                        json.WriteString("LAZILY_ALLOCATED");
+                    }
+                    if((flags & VK_MEMORY_PROPERTY_PROTECTED_BIT) != 0)
+                    {
+                        json.WriteString(" PROTECTED");
+                    }
+                    if((flags & VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD_COPY) != 0)
+                    {
+                        json.WriteString(" DEVICE_COHERENT");
+                    }
+                    if((flags & VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD_COPY) != 0)
+                    {
+                        json.WriteString(" DEVICE_UNCACHED");
+                    }
+                    json.EndArray();
+
+                    if(stats.memoryType[typeIndex].blockCount > 0)
+                    {
+                        json.WriteString("Stats");
+                        VmaPrintStatInfo(json, stats.memoryType[typeIndex]);
+                    }
+
+                    json.EndObject();
+                }
+            }
+
+            json.EndObject();
+        }
+        if(detailedMap == VK_TRUE)
+        {
+            allocator->PrintDetailedMap(json);
+        }
+
+        json.EndObject();
+    }
+
+    const size_t len = sb.GetLength();
+    char* const pChars = vma_new_array(allocator, char, len + 1);
+    if(len > 0)
+    {
+        memcpy(pChars, sb.GetData(), len);
+    }
+    pChars[len] = '\0';
+    *ppStatsString = pChars;
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaFreeStatsString(
+    VmaAllocator allocator,
+    char* pStatsString)
+{
+    if(pStatsString != VMA_NULL)
+    {
+        VMA_ASSERT(allocator);
+        size_t len = strlen(pStatsString);
+        vma_delete_array(allocator, pStatsString, len + 1);
+    }
+}
+
+#endif // #if VMA_STATS_STRING_ENABLED
+
+/*
+This function is not protected by any mutex because it just reads immutable data.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndex(
+    VmaAllocator allocator,
+    uint32_t memoryTypeBits,
+    const VmaAllocationCreateInfo* pAllocationCreateInfo,
+    uint32_t* pMemoryTypeIndex)
+{
+    VMA_ASSERT(allocator != VK_NULL_HANDLE);
+    VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
+    VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
+
+    memoryTypeBits &= allocator->GetGlobalMemoryTypeBits();
+
+    if(pAllocationCreateInfo->memoryTypeBits != 0)
+    {
+        memoryTypeBits &= pAllocationCreateInfo->memoryTypeBits;
+    }
+
+    uint32_t requiredFlags = pAllocationCreateInfo->requiredFlags;
+    uint32_t preferredFlags = pAllocationCreateInfo->preferredFlags;
+    uint32_t notPreferredFlags = 0;
+
+    // Convert usage to requiredFlags and preferredFlags.
+    switch(pAllocationCreateInfo->usage)
+    {
+    case VMA_MEMORY_USAGE_UNKNOWN:
+        break;
+    case VMA_MEMORY_USAGE_GPU_ONLY:
+        if(!allocator->IsIntegratedGpu() || (preferredFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
+        {
+            preferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+        }
+        break;
+    case VMA_MEMORY_USAGE_CPU_ONLY:
+        requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+        break;
+    case VMA_MEMORY_USAGE_CPU_TO_GPU:
+        requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
+        if(!allocator->IsIntegratedGpu() || (preferredFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
+        {
+            preferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+        }
+        break;
+    case VMA_MEMORY_USAGE_GPU_TO_CPU:
+        requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
+        preferredFlags |= VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
+        break;
+    case VMA_MEMORY_USAGE_CPU_COPY:
+        notPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+        break;
+    case VMA_MEMORY_USAGE_GPU_LAZILY_ALLOCATED:
+        requiredFlags |= VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT;
+        break;
+    default:
+        VMA_ASSERT(0);
+        break;
+    }
+
+    // Avoid DEVICE_COHERENT unless explicitly requested.
+    if(((pAllocationCreateInfo->requiredFlags | pAllocationCreateInfo->preferredFlags) &
+        (VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD_COPY | VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD_COPY)) == 0)
+    {
+        notPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD_COPY;
+    }
+
+    *pMemoryTypeIndex = UINT32_MAX;
+    uint32_t minCost = UINT32_MAX;
+    for(uint32_t memTypeIndex = 0, memTypeBit = 1;
+        memTypeIndex < allocator->GetMemoryTypeCount();
+        ++memTypeIndex, memTypeBit <<= 1)
+    {
+        // This memory type is acceptable according to memoryTypeBits bitmask.
+        if((memTypeBit & memoryTypeBits) != 0)
+        {
+            const VkMemoryPropertyFlags currFlags =
+                allocator->m_MemProps.memoryTypes[memTypeIndex].propertyFlags;
+            // This memory type contains requiredFlags.
+            if((requiredFlags & ~currFlags) == 0)
+            {
+                // Calculate cost as number of bits from preferredFlags not present in this memory type.
+                uint32_t currCost = VmaCountBitsSet(preferredFlags & ~currFlags) +
+                    VmaCountBitsSet(currFlags & notPreferredFlags);
+                // Remember memory type with lowest cost.
+                if(currCost < minCost)
+                {
+                    *pMemoryTypeIndex = memTypeIndex;
+                    if(currCost == 0)
+                    {
+                        return VK_SUCCESS;
+                    }
+                    minCost = currCost;
+                }
+            }
+        }
+    }
+    return (*pMemoryTypeIndex != UINT32_MAX) ? VK_SUCCESS : VK_ERROR_FEATURE_NOT_PRESENT;
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForBufferInfo(
+    VmaAllocator allocator,
+    const VkBufferCreateInfo* pBufferCreateInfo,
+    const VmaAllocationCreateInfo* pAllocationCreateInfo,
+    uint32_t* pMemoryTypeIndex)
+{
+    VMA_ASSERT(allocator != VK_NULL_HANDLE);
+    VMA_ASSERT(pBufferCreateInfo != VMA_NULL);
+    VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
+    VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
+
+    const VkDevice hDev = allocator->m_hDevice;
+    VkBuffer hBuffer = VK_NULL_HANDLE;
+    VkResult res = allocator->GetVulkanFunctions().vkCreateBuffer(
+        hDev, pBufferCreateInfo, allocator->GetAllocationCallbacks(), &hBuffer);
+    if(res == VK_SUCCESS)
+    {
+        VkMemoryRequirements memReq = {};
+        allocator->GetVulkanFunctions().vkGetBufferMemoryRequirements(
+            hDev, hBuffer, &memReq);
+
+        res = vmaFindMemoryTypeIndex(
+            allocator,
+            memReq.memoryTypeBits,
+            pAllocationCreateInfo,
+            pMemoryTypeIndex);
+
+        allocator->GetVulkanFunctions().vkDestroyBuffer(
+            hDev, hBuffer, allocator->GetAllocationCallbacks());
+    }
+    return res;
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForImageInfo(
+    VmaAllocator allocator,
+    const VkImageCreateInfo* pImageCreateInfo,
+    const VmaAllocationCreateInfo* pAllocationCreateInfo,
+    uint32_t* pMemoryTypeIndex)
+{
+    VMA_ASSERT(allocator != VK_NULL_HANDLE);
+    VMA_ASSERT(pImageCreateInfo != VMA_NULL);
+    VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
+    VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
+
+    const VkDevice hDev = allocator->m_hDevice;
+    VkImage hImage = VK_NULL_HANDLE;
+    VkResult res = allocator->GetVulkanFunctions().vkCreateImage(
+        hDev, pImageCreateInfo, allocator->GetAllocationCallbacks(), &hImage);
+    if(res == VK_SUCCESS)
+    {
+        VkMemoryRequirements memReq = {};
+        allocator->GetVulkanFunctions().vkGetImageMemoryRequirements(
+            hDev, hImage, &memReq);
+
+        res = vmaFindMemoryTypeIndex(
+            allocator,
+            memReq.memoryTypeBits,
+            pAllocationCreateInfo,
+            pMemoryTypeIndex);
+
+        allocator->GetVulkanFunctions().vkDestroyImage(
+            hDev, hImage, allocator->GetAllocationCallbacks());
+    }
+    return res;
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreatePool(
+    VmaAllocator allocator,
+    const VmaPoolCreateInfo* pCreateInfo,
+    VmaPool* pPool)
+{
+    VMA_ASSERT(allocator && pCreateInfo && pPool);
+
+    VMA_DEBUG_LOG("vmaCreatePool");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    VkResult res = allocator->CreatePool(pCreateInfo, pPool);
+
+#if VMA_RECORDING_ENABLED
+    if(allocator->GetRecorder() != VMA_NULL)
+    {
+        allocator->GetRecorder()->RecordCreatePool(allocator->GetCurrentFrameIndex(), *pCreateInfo, *pPool);
+    }
+#endif
+
+    return res;
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaDestroyPool(
+    VmaAllocator allocator,
+    VmaPool pool)
+{
+    VMA_ASSERT(allocator);
+
+    if(pool == VK_NULL_HANDLE)
+    {
+        return;
+    }
+
+    VMA_DEBUG_LOG("vmaDestroyPool");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+#if VMA_RECORDING_ENABLED
+    if(allocator->GetRecorder() != VMA_NULL)
+    {
+        allocator->GetRecorder()->RecordDestroyPool(allocator->GetCurrentFrameIndex(), pool);
+    }
+#endif
+
+    allocator->DestroyPool(pool);
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaGetPoolStats(
+    VmaAllocator allocator,
+    VmaPool pool,
+    VmaPoolStats* pPoolStats)
+{
+    VMA_ASSERT(allocator && pool && pPoolStats);
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    allocator->GetPoolStats(pool, pPoolStats);
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaMakePoolAllocationsLost(
+    VmaAllocator allocator,
+    VmaPool pool,
+    size_t* pLostAllocationCount)
+{
+    VMA_ASSERT(allocator && pool);
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+#if VMA_RECORDING_ENABLED
+    if(allocator->GetRecorder() != VMA_NULL)
+    {
+        allocator->GetRecorder()->RecordMakePoolAllocationsLost(allocator->GetCurrentFrameIndex(), pool);
+    }
+#endif
+
+    allocator->MakePoolAllocationsLost(pool, pLostAllocationCount);
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckPoolCorruption(VmaAllocator allocator, VmaPool pool)
+{
+    VMA_ASSERT(allocator && pool);
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    VMA_DEBUG_LOG("vmaCheckPoolCorruption");
+
+    return allocator->CheckPoolCorruption(pool);
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaGetPoolName(
+    VmaAllocator allocator,
+    VmaPool pool,
+    const char** ppName)
+{
+    VMA_ASSERT(allocator && pool && ppName);
+
+    VMA_DEBUG_LOG("vmaGetPoolName");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    *ppName = pool->GetName();
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaSetPoolName(
+    VmaAllocator allocator,
+    VmaPool pool,
+    const char* pName)
+{
+    VMA_ASSERT(allocator && pool);
+
+    VMA_DEBUG_LOG("vmaSetPoolName");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    pool->SetName(pName);
+
+#if VMA_RECORDING_ENABLED
+    if(allocator->GetRecorder() != VMA_NULL)
+    {
+        allocator->GetRecorder()->RecordSetPoolName(allocator->GetCurrentFrameIndex(), pool, pName);
+    }
+#endif
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemory(
+    VmaAllocator allocator,
+    const VkMemoryRequirements* pVkMemoryRequirements,
+    const VmaAllocationCreateInfo* pCreateInfo,
+    VmaAllocation* pAllocation,
+    VmaAllocationInfo* pAllocationInfo)
+{
+    VMA_ASSERT(allocator && pVkMemoryRequirements && pCreateInfo && pAllocation);
+
+    VMA_DEBUG_LOG("vmaAllocateMemory");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    VkResult result = allocator->AllocateMemory(
+        *pVkMemoryRequirements,
+        false, // requiresDedicatedAllocation
+        false, // prefersDedicatedAllocation
+        VK_NULL_HANDLE, // dedicatedBuffer
+        UINT32_MAX, // dedicatedBufferUsage
+        VK_NULL_HANDLE, // dedicatedImage
+        *pCreateInfo,
+        VMA_SUBALLOCATION_TYPE_UNKNOWN,
+        1, // allocationCount
+        pAllocation);
+
+#if VMA_RECORDING_ENABLED
+    if(allocator->GetRecorder() != VMA_NULL)
+    {
+        allocator->GetRecorder()->RecordAllocateMemory(
+            allocator->GetCurrentFrameIndex(),
+            *pVkMemoryRequirements,
+            *pCreateInfo,
+            *pAllocation);
+    }
+#endif
+
+    if(pAllocationInfo != VMA_NULL && result == VK_SUCCESS)
+    {
+        allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
+    }
+
+    return result;
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryPages(
+    VmaAllocator allocator,
+    const VkMemoryRequirements* pVkMemoryRequirements,
+    const VmaAllocationCreateInfo* pCreateInfo,
+    size_t allocationCount,
+    VmaAllocation* pAllocations,
+    VmaAllocationInfo* pAllocationInfo)
+{
+    if(allocationCount == 0)
+    {
+        return VK_SUCCESS;
+    }
+
+    VMA_ASSERT(allocator && pVkMemoryRequirements && pCreateInfo && pAllocations);
+
+    VMA_DEBUG_LOG("vmaAllocateMemoryPages");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    VkResult result = allocator->AllocateMemory(
+        *pVkMemoryRequirements,
+        false, // requiresDedicatedAllocation
+        false, // prefersDedicatedAllocation
+        VK_NULL_HANDLE, // dedicatedBuffer
+        UINT32_MAX, // dedicatedBufferUsage
+        VK_NULL_HANDLE, // dedicatedImage
+        *pCreateInfo,
+        VMA_SUBALLOCATION_TYPE_UNKNOWN,
+        allocationCount,
+        pAllocations);
+
+#if VMA_RECORDING_ENABLED
+    if(allocator->GetRecorder() != VMA_NULL)
+    {
+        allocator->GetRecorder()->RecordAllocateMemoryPages(
+            allocator->GetCurrentFrameIndex(),
+            *pVkMemoryRequirements,
+            *pCreateInfo,
+            (uint64_t)allocationCount,
+            pAllocations);
+    }
+#endif
+
+    if(pAllocationInfo != VMA_NULL && result == VK_SUCCESS)
+    {
+        for(size_t i = 0; i < allocationCount; ++i)
+        {
+            allocator->GetAllocationInfo(pAllocations[i], pAllocationInfo + i);
+        }
+    }
+
+    return result;
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForBuffer(
+    VmaAllocator allocator,
+    VkBuffer buffer,
+    const VmaAllocationCreateInfo* pCreateInfo,
+    VmaAllocation* pAllocation,
+    VmaAllocationInfo* pAllocationInfo)
+{
+    VMA_ASSERT(allocator && buffer != VK_NULL_HANDLE && pCreateInfo && pAllocation);
+
+    VMA_DEBUG_LOG("vmaAllocateMemoryForBuffer");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    VkMemoryRequirements vkMemReq = {};
+    bool requiresDedicatedAllocation = false;
+    bool prefersDedicatedAllocation = false;
+    allocator->GetBufferMemoryRequirements(buffer, vkMemReq,
+        requiresDedicatedAllocation,
+        prefersDedicatedAllocation);
+
+    VkResult result = allocator->AllocateMemory(
+        vkMemReq,
+        requiresDedicatedAllocation,
+        prefersDedicatedAllocation,
+        buffer, // dedicatedBuffer
+        UINT32_MAX, // dedicatedBufferUsage
+        VK_NULL_HANDLE, // dedicatedImage
+        *pCreateInfo,
+        VMA_SUBALLOCATION_TYPE_BUFFER,
+        1, // allocationCount
+        pAllocation);
+
+#if VMA_RECORDING_ENABLED
+    if(allocator->GetRecorder() != VMA_NULL)
+    {
+        allocator->GetRecorder()->RecordAllocateMemoryForBuffer(
+            allocator->GetCurrentFrameIndex(),
+            vkMemReq,
+            requiresDedicatedAllocation,
+            prefersDedicatedAllocation,
+            *pCreateInfo,
+            *pAllocation);
+    }
+#endif
+
+    if(pAllocationInfo && result == VK_SUCCESS)
+    {
+        allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
+    }
+
+    return result;
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForImage(
+    VmaAllocator allocator,
+    VkImage image,
+    const VmaAllocationCreateInfo* pCreateInfo,
+    VmaAllocation* pAllocation,
+    VmaAllocationInfo* pAllocationInfo)
+{
+    VMA_ASSERT(allocator && image != VK_NULL_HANDLE && pCreateInfo && pAllocation);
+
+    VMA_DEBUG_LOG("vmaAllocateMemoryForImage");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    VkMemoryRequirements vkMemReq = {};
+    bool requiresDedicatedAllocation = false;
+    bool prefersDedicatedAllocation  = false;
+    allocator->GetImageMemoryRequirements(image, vkMemReq,
+        requiresDedicatedAllocation, prefersDedicatedAllocation);
+
+    VkResult result = allocator->AllocateMemory(
+        vkMemReq,
+        requiresDedicatedAllocation,
+        prefersDedicatedAllocation,
+        VK_NULL_HANDLE, // dedicatedBuffer
+        UINT32_MAX, // dedicatedBufferUsage
+        image, // dedicatedImage
+        *pCreateInfo,
+        VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN,
+        1, // allocationCount
+        pAllocation);
+
+#if VMA_RECORDING_ENABLED
+    if(allocator->GetRecorder() != VMA_NULL)
+    {
+        allocator->GetRecorder()->RecordAllocateMemoryForImage(
+            allocator->GetCurrentFrameIndex(),
+            vkMemReq,
+            requiresDedicatedAllocation,
+            prefersDedicatedAllocation,
+            *pCreateInfo,
+            *pAllocation);
+    }
+#endif
+
+    if(pAllocationInfo && result == VK_SUCCESS)
+    {
+        allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
+    }
+
+    return result;
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemory(
+    VmaAllocator allocator,
+    VmaAllocation allocation)
+{
+    VMA_ASSERT(allocator);
+
+    if(allocation == VK_NULL_HANDLE)
+    {
+        return;
+    }
+
+    VMA_DEBUG_LOG("vmaFreeMemory");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+#if VMA_RECORDING_ENABLED
+    if(allocator->GetRecorder() != VMA_NULL)
+    {
+        allocator->GetRecorder()->RecordFreeMemory(
+            allocator->GetCurrentFrameIndex(),
+            allocation);
+    }
+#endif
+
+    allocator->FreeMemory(
+        1, // allocationCount
+        &allocation);
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemoryPages(
+    VmaAllocator allocator,
+    size_t allocationCount,
+    const VmaAllocation* pAllocations)
+{
+    if(allocationCount == 0)
+    {
+        return;
+    }
+
+    VMA_ASSERT(allocator);
+
+    VMA_DEBUG_LOG("vmaFreeMemoryPages");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+#if VMA_RECORDING_ENABLED
+    if(allocator->GetRecorder() != VMA_NULL)
+    {
+        allocator->GetRecorder()->RecordFreeMemoryPages(
+            allocator->GetCurrentFrameIndex(),
+            (uint64_t)allocationCount,
+            pAllocations);
+    }
+#endif
+
+    allocator->FreeMemory(allocationCount, pAllocations);
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaResizeAllocation(
+    VmaAllocator allocator,
+    VmaAllocation allocation,
+    VkDeviceSize newSize)
+{
+    VMA_ASSERT(allocator && allocation);
+
+    VMA_DEBUG_LOG("vmaResizeAllocation");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    return allocator->ResizeAllocation(allocation, newSize);
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaGetAllocationInfo(
+    VmaAllocator allocator,
+    VmaAllocation allocation,
+    VmaAllocationInfo* pAllocationInfo)
+{
+    VMA_ASSERT(allocator && allocation && pAllocationInfo);
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+#if VMA_RECORDING_ENABLED
+    if(allocator->GetRecorder() != VMA_NULL)
+    {
+        allocator->GetRecorder()->RecordGetAllocationInfo(
+            allocator->GetCurrentFrameIndex(),
+            allocation);
+    }
+#endif
+
+    allocator->GetAllocationInfo(allocation, pAllocationInfo);
+}
+
+VMA_CALL_PRE VkBool32 VMA_CALL_POST vmaTouchAllocation(
+    VmaAllocator allocator,
+    VmaAllocation allocation)
+{
+    VMA_ASSERT(allocator && allocation);
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+#if VMA_RECORDING_ENABLED
+    if(allocator->GetRecorder() != VMA_NULL)
+    {
+        allocator->GetRecorder()->RecordTouchAllocation(
+            allocator->GetCurrentFrameIndex(),
+            allocation);
+    }
+#endif
+
+    return allocator->TouchAllocation(allocation);
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaSetAllocationUserData(
+    VmaAllocator allocator,
+    VmaAllocation allocation,
+    void* pUserData)
+{
+    VMA_ASSERT(allocator && allocation);
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    allocation->SetUserData(allocator, pUserData);
+
+#if VMA_RECORDING_ENABLED
+    if(allocator->GetRecorder() != VMA_NULL)
+    {
+        allocator->GetRecorder()->RecordSetAllocationUserData(
+            allocator->GetCurrentFrameIndex(),
+            allocation,
+            pUserData);
+    }
+#endif
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaCreateLostAllocation(
+    VmaAllocator allocator,
+    VmaAllocation* pAllocation)
+{
+    VMA_ASSERT(allocator && pAllocation);
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK;
+
+    allocator->CreateLostAllocation(pAllocation);
+
+#if VMA_RECORDING_ENABLED
+    if(allocator->GetRecorder() != VMA_NULL)
+    {
+        allocator->GetRecorder()->RecordCreateLostAllocation(
+            allocator->GetCurrentFrameIndex(),
+            *pAllocation);
+    }
+#endif
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaMapMemory(
+    VmaAllocator allocator,
+    VmaAllocation allocation,
+    void** ppData)
+{
+    VMA_ASSERT(allocator && allocation && ppData);
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    VkResult res = allocator->Map(allocation, ppData);
+
+#if VMA_RECORDING_ENABLED
+    if(allocator->GetRecorder() != VMA_NULL)
+    {
+        allocator->GetRecorder()->RecordMapMemory(
+            allocator->GetCurrentFrameIndex(),
+            allocation);
+    }
+#endif
+
+    return res;
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaUnmapMemory(
+    VmaAllocator allocator,
+    VmaAllocation allocation)
+{
+    VMA_ASSERT(allocator && allocation);
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+#if VMA_RECORDING_ENABLED
+    if(allocator->GetRecorder() != VMA_NULL)
+    {
+        allocator->GetRecorder()->RecordUnmapMemory(
+            allocator->GetCurrentFrameIndex(),
+            allocation);
+    }
+#endif
+
+    allocator->Unmap(allocation);
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaFlushAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
+{
+    VMA_ASSERT(allocator && allocation);
+
+    VMA_DEBUG_LOG("vmaFlushAllocation");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    const VkResult res = allocator->FlushOrInvalidateAllocation(allocation, offset, size, VMA_CACHE_FLUSH);
+
+#if VMA_RECORDING_ENABLED
+    if(allocator->GetRecorder() != VMA_NULL)
+    {
+        allocator->GetRecorder()->RecordFlushAllocation(
+            allocator->GetCurrentFrameIndex(),
+            allocation, offset, size);
+    }
+#endif
+
+    return res;
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaInvalidateAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
+{
+    VMA_ASSERT(allocator && allocation);
+
+    VMA_DEBUG_LOG("vmaInvalidateAllocation");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    const VkResult res = allocator->FlushOrInvalidateAllocation(allocation, offset, size, VMA_CACHE_INVALIDATE);
+
+#if VMA_RECORDING_ENABLED
+    if(allocator->GetRecorder() != VMA_NULL)
+    {
+        allocator->GetRecorder()->RecordInvalidateAllocation(
+            allocator->GetCurrentFrameIndex(),
+            allocation, offset, size);
+    }
+#endif
+
+    return res;
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaFlushAllocations(
+    VmaAllocator allocator,
+    uint32_t allocationCount,
+    const VmaAllocation* allocations,
+    const VkDeviceSize* offsets,
+    const VkDeviceSize* sizes)
+{
+    VMA_ASSERT(allocator);
+
+    if(allocationCount == 0)
+    {
+        return VK_SUCCESS;
+    }
+
+    VMA_ASSERT(allocations);
+
+    VMA_DEBUG_LOG("vmaFlushAllocations");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    const VkResult res = allocator->FlushOrInvalidateAllocations(allocationCount, allocations, offsets, sizes, VMA_CACHE_FLUSH);
+
+#if VMA_RECORDING_ENABLED
+    if(allocator->GetRecorder() != VMA_NULL)
+    {
+        //TODO
+    }
+#endif
+
+    return res;
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaInvalidateAllocations(
+    VmaAllocator allocator,
+    uint32_t allocationCount,
+    const VmaAllocation* allocations,
+    const VkDeviceSize* offsets,
+    const VkDeviceSize* sizes)
+{
+    VMA_ASSERT(allocator);
+
+    if(allocationCount == 0)
+    {
+        return VK_SUCCESS;
+    }
+
+    VMA_ASSERT(allocations);
+
+    VMA_DEBUG_LOG("vmaInvalidateAllocations");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    const VkResult res = allocator->FlushOrInvalidateAllocations(allocationCount, allocations, offsets, sizes, VMA_CACHE_INVALIDATE);
+
+#if VMA_RECORDING_ENABLED
+    if(allocator->GetRecorder() != VMA_NULL)
+    {
+        //TODO
+    }
+#endif
+
+    return res;
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckCorruption(VmaAllocator allocator, uint32_t memoryTypeBits)
+{
+    VMA_ASSERT(allocator);
+
+    VMA_DEBUG_LOG("vmaCheckCorruption");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    return allocator->CheckCorruption(memoryTypeBits);
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragment(
+    VmaAllocator allocator,
+    const VmaAllocation* pAllocations,
+    size_t allocationCount,
+    VkBool32* pAllocationsChanged,
+    const VmaDefragmentationInfo *pDefragmentationInfo,
+    VmaDefragmentationStats* pDefragmentationStats)
+{
+    // Deprecated interface, reimplemented using new one.
+
+    VmaDefragmentationInfo2 info2 = {};
+    info2.allocationCount = (uint32_t)allocationCount;
+    info2.pAllocations = pAllocations;
+    info2.pAllocationsChanged = pAllocationsChanged;
+    if(pDefragmentationInfo != VMA_NULL)
+    {
+        info2.maxCpuAllocationsToMove = pDefragmentationInfo->maxAllocationsToMove;
+        info2.maxCpuBytesToMove = pDefragmentationInfo->maxBytesToMove;
+    }
+    else
+    {
+        info2.maxCpuAllocationsToMove = UINT32_MAX;
+        info2.maxCpuBytesToMove = VK_WHOLE_SIZE;
+    }
+    // info2.flags, maxGpuAllocationsToMove, maxGpuBytesToMove, commandBuffer deliberately left zero.
+
+    VmaDefragmentationContext ctx;
+    VkResult res = vmaDefragmentationBegin(allocator, &info2, pDefragmentationStats, &ctx);
+    if(res == VK_NOT_READY)
+    {
+        res = vmaDefragmentationEnd( allocator, ctx);
+    }
+    return res;
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragmentationBegin(
+    VmaAllocator allocator,
+    const VmaDefragmentationInfo2* pInfo,
+    VmaDefragmentationStats* pStats,
+    VmaDefragmentationContext *pContext)
+{
+    VMA_ASSERT(allocator && pInfo && pContext);
+
+    // Degenerate case: Nothing to defragment.
+    if(pInfo->allocationCount == 0 && pInfo->poolCount == 0)
+    {
+        return VK_SUCCESS;
+    }
+
+    VMA_ASSERT(pInfo->allocationCount == 0 || pInfo->pAllocations != VMA_NULL);
+    VMA_ASSERT(pInfo->poolCount == 0 || pInfo->pPools != VMA_NULL);
+    VMA_HEAVY_ASSERT(VmaValidatePointerArray(pInfo->allocationCount, pInfo->pAllocations));
+    VMA_HEAVY_ASSERT(VmaValidatePointerArray(pInfo->poolCount, pInfo->pPools));
+
+    VMA_DEBUG_LOG("vmaDefragmentationBegin");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    VkResult res = allocator->DefragmentationBegin(*pInfo, pStats, pContext);
+
+#if VMA_RECORDING_ENABLED
+    if(allocator->GetRecorder() != VMA_NULL)
+    {
+        allocator->GetRecorder()->RecordDefragmentationBegin(
+            allocator->GetCurrentFrameIndex(), *pInfo, *pContext);
+    }
+#endif
+
+    return res;
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragmentationEnd(
+    VmaAllocator allocator,
+    VmaDefragmentationContext context)
+{
+    VMA_ASSERT(allocator);
+
+    VMA_DEBUG_LOG("vmaDefragmentationEnd");
+
+    if(context != VK_NULL_HANDLE)
+    {
+        VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+#if VMA_RECORDING_ENABLED
+        if(allocator->GetRecorder() != VMA_NULL)
+        {
+            allocator->GetRecorder()->RecordDefragmentationEnd(
+                allocator->GetCurrentFrameIndex(), context);
+        }
+#endif
+
+        return allocator->DefragmentationEnd(context);
+    }
+    else
+    {
+        return VK_SUCCESS;
+    }
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaBeginDefragmentationPass(
+    VmaAllocator allocator,
+    VmaDefragmentationContext context,
+    VmaDefragmentationPassInfo* pInfo
+    )
+{
+    VMA_ASSERT(allocator);
+    VMA_ASSERT(pInfo);
+
+    VMA_DEBUG_LOG("vmaBeginDefragmentationPass");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    if(context == VK_NULL_HANDLE)
+    {
+        pInfo->moveCount = 0;
+        return VK_SUCCESS;
+    }
+
+    return allocator->DefragmentationPassBegin(pInfo, context);
+}
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaEndDefragmentationPass(
+    VmaAllocator allocator,
+    VmaDefragmentationContext context)
+{
+    VMA_ASSERT(allocator);
+
+    VMA_DEBUG_LOG("vmaEndDefragmentationPass");
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    if(context == VK_NULL_HANDLE)
+        return VK_SUCCESS;
+
+    return allocator->DefragmentationPassEnd(context);
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory(
+    VmaAllocator allocator,
+    VmaAllocation allocation,
+    VkBuffer buffer)
+{
+    VMA_ASSERT(allocator && allocation && buffer);
+
+    VMA_DEBUG_LOG("vmaBindBufferMemory");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    return allocator->BindBufferMemory(allocation, 0, buffer, VMA_NULL);
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory2(
+    VmaAllocator allocator,
+    VmaAllocation allocation,
+    VkDeviceSize allocationLocalOffset,
+    VkBuffer buffer,
+    const void* pNext)
+{
+    VMA_ASSERT(allocator && allocation && buffer);
+
+    VMA_DEBUG_LOG("vmaBindBufferMemory2");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    return allocator->BindBufferMemory(allocation, allocationLocalOffset, buffer, pNext);
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory(
+    VmaAllocator allocator,
+    VmaAllocation allocation,
+    VkImage image)
+{
+    VMA_ASSERT(allocator && allocation && image);
+
+    VMA_DEBUG_LOG("vmaBindImageMemory");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    return allocator->BindImageMemory(allocation, 0, image, VMA_NULL);
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory2(
+    VmaAllocator allocator,
+    VmaAllocation allocation,
+    VkDeviceSize allocationLocalOffset,
+    VkImage image,
+    const void* pNext)
+{
+    VMA_ASSERT(allocator && allocation && image);
+
+    VMA_DEBUG_LOG("vmaBindImageMemory2");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+        return allocator->BindImageMemory(allocation, allocationLocalOffset, image, pNext);
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBuffer(
+    VmaAllocator allocator,
+    const VkBufferCreateInfo* pBufferCreateInfo,
+    const VmaAllocationCreateInfo* pAllocationCreateInfo,
+    VkBuffer* pBuffer,
+    VmaAllocation* pAllocation,
+    VmaAllocationInfo* pAllocationInfo)
+{
+    VMA_ASSERT(allocator && pBufferCreateInfo && pAllocationCreateInfo && pBuffer && pAllocation);
+
+    if(pBufferCreateInfo->size == 0)
+    {
+        return VK_ERROR_VALIDATION_FAILED_EXT;
+    }
+    if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_COPY) != 0 &&
+        !allocator->m_UseKhrBufferDeviceAddress)
+    {
+        VMA_ASSERT(0 && "Creating a buffer with VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT is not valid if VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT was not used.");
+        return VK_ERROR_VALIDATION_FAILED_EXT;
+    }
+
+    VMA_DEBUG_LOG("vmaCreateBuffer");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    *pBuffer = VK_NULL_HANDLE;
+    *pAllocation = VK_NULL_HANDLE;
+
+    // 1. Create VkBuffer.
+    VkResult res = (*allocator->GetVulkanFunctions().vkCreateBuffer)(
+        allocator->m_hDevice,
+        pBufferCreateInfo,
+        allocator->GetAllocationCallbacks(),
+        pBuffer);
+    if(res >= 0)
+    {
+        // 2. vkGetBufferMemoryRequirements.
+        VkMemoryRequirements vkMemReq = {};
+        bool requiresDedicatedAllocation = false;
+        bool prefersDedicatedAllocation  = false;
+        allocator->GetBufferMemoryRequirements(*pBuffer, vkMemReq,
+            requiresDedicatedAllocation, prefersDedicatedAllocation);
+
+        // 3. Allocate memory using allocator.
+        res = allocator->AllocateMemory(
+            vkMemReq,
+            requiresDedicatedAllocation,
+            prefersDedicatedAllocation,
+            *pBuffer, // dedicatedBuffer
+            pBufferCreateInfo->usage, // dedicatedBufferUsage
+            VK_NULL_HANDLE, // dedicatedImage
+            *pAllocationCreateInfo,
+            VMA_SUBALLOCATION_TYPE_BUFFER,
+            1, // allocationCount
+            pAllocation);
+
+#if VMA_RECORDING_ENABLED
+        if(allocator->GetRecorder() != VMA_NULL)
+        {
+            allocator->GetRecorder()->RecordCreateBuffer(
+                allocator->GetCurrentFrameIndex(),
+                *pBufferCreateInfo,
+                *pAllocationCreateInfo,
+                *pAllocation);
+        }
+#endif
+
+        if(res >= 0)
+        {
+            // 3. Bind buffer with memory.
+            if((pAllocationCreateInfo->flags & VMA_ALLOCATION_CREATE_DONT_BIND_BIT) == 0)
+            {
+                res = allocator->BindBufferMemory(*pAllocation, 0, *pBuffer, VMA_NULL);
+            }
+            if(res >= 0)
+            {
+                // All steps succeeded.
+                #if VMA_STATS_STRING_ENABLED
+                    (*pAllocation)->InitBufferImageUsage(pBufferCreateInfo->usage);
+                #endif
+                if(pAllocationInfo != VMA_NULL)
+                {
+                    allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
+                }
+
+                return VK_SUCCESS;
+            }
+            allocator->FreeMemory(
+                1, // allocationCount
+                pAllocation);
+            *pAllocation = VK_NULL_HANDLE;
+            (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
+            *pBuffer = VK_NULL_HANDLE;
+            return res;
+        }
+        (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
+        *pBuffer = VK_NULL_HANDLE;
+        return res;
+    }
+    return res;
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaDestroyBuffer(
+    VmaAllocator allocator,
+    VkBuffer buffer,
+    VmaAllocation allocation)
+{
+    VMA_ASSERT(allocator);
+
+    if(buffer == VK_NULL_HANDLE && allocation == VK_NULL_HANDLE)
+    {
+        return;
+    }
+
+    VMA_DEBUG_LOG("vmaDestroyBuffer");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+#if VMA_RECORDING_ENABLED
+    if(allocator->GetRecorder() != VMA_NULL)
+    {
+        allocator->GetRecorder()->RecordDestroyBuffer(
+            allocator->GetCurrentFrameIndex(),
+            allocation);
+    }
+#endif
+
+    if(buffer != VK_NULL_HANDLE)
+    {
+        (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, buffer, allocator->GetAllocationCallbacks());
+    }
+
+    if(allocation != VK_NULL_HANDLE)
+    {
+        allocator->FreeMemory(
+            1, // allocationCount
+            &allocation);
+    }
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateImage(
+    VmaAllocator allocator,
+    const VkImageCreateInfo* pImageCreateInfo,
+    const VmaAllocationCreateInfo* pAllocationCreateInfo,
+    VkImage* pImage,
+    VmaAllocation* pAllocation,
+    VmaAllocationInfo* pAllocationInfo)
+{
+    VMA_ASSERT(allocator && pImageCreateInfo && pAllocationCreateInfo && pImage && pAllocation);
+
+    if(pImageCreateInfo->extent.width == 0 ||
+        pImageCreateInfo->extent.height == 0 ||
+        pImageCreateInfo->extent.depth == 0 ||
+        pImageCreateInfo->mipLevels == 0 ||
+        pImageCreateInfo->arrayLayers == 0)
+    {
+        return VK_ERROR_VALIDATION_FAILED_EXT;
+    }
+
+    VMA_DEBUG_LOG("vmaCreateImage");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    *pImage = VK_NULL_HANDLE;
+    *pAllocation = VK_NULL_HANDLE;
+
+    // 1. Create VkImage.
+    VkResult res = (*allocator->GetVulkanFunctions().vkCreateImage)(
+        allocator->m_hDevice,
+        pImageCreateInfo,
+        allocator->GetAllocationCallbacks(),
+        pImage);
+    if(res >= 0)
+    {
+        VmaSuballocationType suballocType = pImageCreateInfo->tiling == VK_IMAGE_TILING_OPTIMAL ?
+            VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL :
+            VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR;
+
+        // 2. Allocate memory using allocator.
+        VkMemoryRequirements vkMemReq = {};
+        bool requiresDedicatedAllocation = false;
+        bool prefersDedicatedAllocation  = false;
+        allocator->GetImageMemoryRequirements(*pImage, vkMemReq,
+            requiresDedicatedAllocation, prefersDedicatedAllocation);
+
+        res = allocator->AllocateMemory(
+            vkMemReq,
+            requiresDedicatedAllocation,
+            prefersDedicatedAllocation,
+            VK_NULL_HANDLE, // dedicatedBuffer
+            UINT32_MAX, // dedicatedBufferUsage
+            *pImage, // dedicatedImage
+            *pAllocationCreateInfo,
+            suballocType,
+            1, // allocationCount
+            pAllocation);
+
+#if VMA_RECORDING_ENABLED
+        if(allocator->GetRecorder() != VMA_NULL)
+        {
+            allocator->GetRecorder()->RecordCreateImage(
+                allocator->GetCurrentFrameIndex(),
+                *pImageCreateInfo,
+                *pAllocationCreateInfo,
+                *pAllocation);
+        }
+#endif
+
+        if(res >= 0)
+        {
+            // 3. Bind image with memory.
+            if((pAllocationCreateInfo->flags & VMA_ALLOCATION_CREATE_DONT_BIND_BIT) == 0)
+            {
+                res = allocator->BindImageMemory(*pAllocation, 0, *pImage, VMA_NULL);
+            }
+            if(res >= 0)
+            {
+                // All steps succeeded.
+                #if VMA_STATS_STRING_ENABLED
+                    (*pAllocation)->InitBufferImageUsage(pImageCreateInfo->usage);
+                #endif
+                if(pAllocationInfo != VMA_NULL)
+                {
+                    allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
+                }
+
+                return VK_SUCCESS;
+            }
+            allocator->FreeMemory(
+                1, // allocationCount
+                pAllocation);
+            *pAllocation = VK_NULL_HANDLE;
+            (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, *pImage, allocator->GetAllocationCallbacks());
+            *pImage = VK_NULL_HANDLE;
+            return res;
+        }
+        (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, *pImage, allocator->GetAllocationCallbacks());
+        *pImage = VK_NULL_HANDLE;
+        return res;
+    }
+    return res;
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaDestroyImage(
+    VmaAllocator allocator,
+    VkImage image,
+    VmaAllocation allocation)
+{
+    VMA_ASSERT(allocator);
+
+    if(image == VK_NULL_HANDLE && allocation == VK_NULL_HANDLE)
+    {
+        return;
+    }
+
+    VMA_DEBUG_LOG("vmaDestroyImage");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+#if VMA_RECORDING_ENABLED
+    if(allocator->GetRecorder() != VMA_NULL)
+    {
+        allocator->GetRecorder()->RecordDestroyImage(
+            allocator->GetCurrentFrameIndex(),
+            allocation);
+    }
+#endif
+
+    if(image != VK_NULL_HANDLE)
+    {
+        (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, image, allocator->GetAllocationCallbacks());
+    }
+    if(allocation != VK_NULL_HANDLE)
+    {
+        allocator->FreeMemory(
+            1, // allocationCount
+            &allocation);
+    }
+}
+
+#endif // #ifdef VMA_IMPLEMENTATION
\ No newline at end of file
diff --git a/engine/lib/win64/discord_game_sdk.bundle b/engine/lib/win64/discord_game_sdk.bundle
new file mode 100644
index 00000000..34e2f559
Binary files /dev/null and b/engine/lib/win64/discord_game_sdk.bundle differ
diff --git a/engine/lib/win64/openvr_api.dll.sig b/engine/lib/win64/openvr_api.dll.sig
new file mode 100644
index 00000000..58c40fba
Binary files /dev/null and b/engine/lib/win64/openvr_api.dll.sig differ
diff --git a/engine/lib/win64/openvr_api.pdb b/engine/lib/win64/openvr_api.pdb
new file mode 100644
index 00000000..d82ded06
Binary files /dev/null and b/engine/lib/win64/openvr_api.pdb differ
diff --git a/engine/src/engine/asset/asset.cpp b/engine/src/engine/asset/asset.cpp
new file mode 100644
index 00000000..b841207f
--- /dev/null
+++ b/engine/src/engine/asset/asset.cpp
@@ -0,0 +1,215 @@
+#include <uf/engine/asset/asset.h>
+#include <regex>
+#include <functional>
+#include <iomanip>
+#include <sys/stat.h>
+#include <fstream>
+#include <iostream>
+
+#include <uf/utils/image/image.h>
+#include <uf/utils/audio/audio.h>
+#include <uf/utils/serialize/serializer.h>
+#include <uf/utils/string/ext.h>
+#include <uf/utils/string/io.h>
+#include <uf/utils/string/hash.h>
+#include <uf/utils/thread/thread.h>
+#include <uf/ext/lua/lua.h>
+#include <uf/ext/gltf/gltf.h>
+
+#include <mutex>
+
+namespace {
+	bool retrieve( const std::string& url, const std::string& filename, const std::string& hash = "" ) {
+		uf::Http http = uf::http::get( url );
+		if ( http.code < 200 || http.code > 300 ) {
+			uf::iostream << "HTTP Error " << http.code << " on GET " << url << "\n";
+			return false;
+		}
+		std::ofstream output;
+
+		std::string actual = hash;
+		if ( hash != "" && (actual = uf::string::sha256(url)) != hash ) {
+			uf::iostream << "HTTP hash mismatch on GET " << url << ": expected " << hash << ", got " <<  actual << "\n";
+			return false;
+		}
+
+		output.open("./" + filename, std::ios::binary);
+		output.write( http.response.c_str(), http.response.size() );
+		output.close();
+		return true;
+	}
+	std::string hashed( const std::string& uri ) {
+		return uf::string::sha256(uri);
+	/*
+		std::size_t value = std::hash<std::string>{}( uri );
+		std::stringstream stream;
+		stream << std::hex << value;
+		return stream.str();
+	*/
+	}
+
+	std::mutex mutex;
+	uint64_t uid = 0;
+	struct Job {
+		std::string callback;
+		std::string type;
+		std::string uri;
+		std::string hash;
+		std::string category;
+	};
+}
+
+uf::Asset uf::Asset::masterAssetLoader;
+
+void uf::Asset::processQueue() {
+	auto& jobs = this->getComponent<std::queue<Job>>();
+	mutex.lock();
+	while ( !jobs.empty() ) {
+		auto job = jobs.front();
+		jobs.pop();
+		std::string callback = job.callback;
+		std::string type = job.type;
+		std::string uri = job.uri;
+		std::string hash = job.hash;
+		std::string category = job.category;
+		if ( uri == "" || callback == "" ) {
+			continue;
+		}
+		std::string filename = type == "cache" ? this->cache(uri, hash, category) : this->load(uri, hash, category);
+		if ( callback != "" && filename != "" ) {
+			uf::Serializer payload;
+			payload["filename"] = filename;
+			payload["hash"] = hash;
+			payload["category"] = category;
+			uf::hooks.call(callback, payload);
+		}
+	}
+	mutex.unlock();
+}
+void uf::Asset::cache( const std::string& callback, const std::string& uri, const std::string& hash, const std::string& category ) {
+	mutex.lock();
+	auto& jobs = this->getComponent<std::queue<Job>>();
+	jobs.push({ callback, "cache", uri, hash, category });
+	mutex.unlock();
+}
+void uf::Asset::load( const std::string& callback, const std::string& uri, const std::string& hash, const std::string& category ) {
+	mutex.lock();
+	auto& jobs = this->getComponent<std::queue<Job>>();
+	jobs.push({ callback, "load", uri, hash, category });
+	mutex.unlock();
+}
+std::string uf::Asset::cache( const std::string& uri, const std::string& hash, const std::string& category ) {
+	std::string filename = uri;
+	std::string extension = uf::io::extension( uri );
+	if ( uri.substr(0,5) == "https" ) {
+		std::string hash = hashed( uri );
+		std::string cached = uf::io::root + "/cache/" + hash + "." + extension;
+		if ( !uf::io::exists( cached ) && !retrieve( uri, cached, hash ) ) {
+			uf::iostream << "Failed to preload `" + uri + "` (`" + cached + "`): HTTP error" << "\n"; 
+			return "";
+		}
+		filename = cached;
+	}
+	if ( !uf::io::exists( filename ) ) {
+		uf::iostream << "Failed to preload `" + filename + "`: Does not exist" << "\n"; 
+		return "";
+	}
+	std::string actual = hash;
+	if ( hash != "" && (actual = uf::io::hash( filename )) != hash ) {
+		uf::iostream << "Failed to preload `" << filename << "`: Hash mismatch; expected " << hash <<  ", got " << actual << "\n";
+		return "";
+	}
+	return filename;
+}
+std::string uf::Asset::load( const std::string& uri, const std::string& hash, const std::string& category ) {
+	std::string filename = uri;
+	std::string extension = uf::io::extension( uri );
+	if ( uri.substr(0,5) == "https" ) {
+		std::string hash = hashed( uri );
+		std::string cached = uf::io::root + "/cache/" + hash + "." + extension;
+		if ( !uf::io::exists( cached ) && !retrieve( uri, cached, hash ) ) {
+			uf::iostream << "Failed to load `" + uri + "` (`" + cached + "`): HTTP error" << "\n"; 
+			return "";
+		}
+		filename = cached;
+	}
+	if ( !uf::io::exists( filename ) ) {
+		uf::iostream << "Failed to load `" + filename + "`: Does not exist" << "\n"; 
+		return "";
+	}
+	std::string actual = hash;
+	if ( hash != "" && (actual = uf::io::hash( filename )) != hash ) {
+		uf::iostream << "Failed to load `" << filename << "`: Hash mismatch; expected " << hash <<  ", got " << actual << "\n";
+		return "";
+	}
+	#define UF_ASSET_REGISTER(type)\
+		auto& container = this->getContainer<type>();\
+		if ( !ext::json::isNull( map[extension][uri] ) ) return filename;\
+		if ( !ext::json::isNull( map[extension][filename] ) ) return filename;\
+		map[extension][uri] = container.size();\
+		map[extension][filename] = container.size();\
+		type& asset = container.emplace_back();
+
+
+	auto& map = this->getComponent<uf::Serializer>();
+	// deduce PNG, load as texture
+	if ( category == "images" || (category == "" && extension == "png") ) {
+		UF_ASSET_REGISTER(uf::Image)
+		asset.open(filename);
+	} else if ( category == "audio" || (category == "" && extension == "ogg") ) {
+		UF_ASSET_REGISTER(uf::Audio)
+		asset.load(filename);
+	} else if ( category == "entities" || (category == "" && extension == "json") ) {
+		UF_ASSET_REGISTER(uf::Serializer)
+		asset.readFromFile(filename);
+	#if UF_USE_LUA
+	} else if ( category == "scripts" || (category == "" && extension == "lua") ) {
+		UF_ASSET_REGISTER(pod::LuaScript)
+		asset = ext::lua::script( filename );
+	#endif
+	} else if ( category == "models" || (category == "" && (extension == "gltf" || extension == "glb" || extension == "graph" ) ) ) {
+		UF_ASSET_REGISTER(pod::Graph)
+		auto& metadata = this->getComponent<uf::Serializer>();
+
+	#if UF_USE_OPENGL_FIXED_FUNCTION
+		// force disable use of a texture atlas, for now
+		metadata[uri]["flags"]["ATLAS"] = false;
+	#else
+		metadata[uri]["flags"]["ATLAS"] = true;
+	#endif
+		ext::gltf::load_mode_t LOAD_FLAGS = 0;
+		#define LOAD_FLAG(name)\
+			if ( metadata[uri]["flags"][#name].as<bool>() )\
+				LOAD_FLAGS |= ext::gltf::LoadMode::name;
+
+		LOAD_FLAG(RENDER) 				// = 0x1 << 0,
+		LOAD_FLAG(COLLISION) 			// = 0x1 << 1,
+		LOAD_FLAG(SEPARATE) 			// = 0x1 << 2,
+		LOAD_FLAG(NORMALS) 				// = 0x1 << 3,
+		LOAD_FLAG(LOAD) 				// = 0x1 << 4,
+		LOAD_FLAG(ATLAS) 				// = 0x1 << 5,
+		LOAD_FLAG(SKINNED) 				// = 0x1 << 6,
+		LOAD_FLAG(INVERT) 				// = 0x1 << 7,
+		LOAD_FLAG(TRANSFORM) 			// = 0x1 << 8,
+
+		asset = ext::gltf::load( filename, LOAD_FLAGS, metadata[uri] );
+		//uf::graph::process( asset );
+	} else {
+		uf::iostream << "Failed to parse `" + filename + "`: Unimplemented extension: " + extension << "\n"; 
+	}
+	// uf::iostream << "Parsed URI: `" + uri + "` -> `" + filename + "`" << "\n"; 
+	return filename;
+}
+std::string uf::Asset::getOriginal( const std::string& uri ) {
+	std::string extension = uf::io::extension( uri );
+	auto& map = this->getComponent<uf::Serializer>();
+	if ( ext::json::isNull( map[extension][uri] ) ) return uri;
+	std::size_t index = map[extension][uri].as<size_t>();
+
+	std::string key = uri;
+	ext::json::forEach( map[extension], [&]( const std::string& k, ext::json::Value& v ) {
+		std::size_t i = v.as<size_t>();
+		if ( index == i && key != uri ) key = k;
+	});
+	return key;
+}
\ No newline at end of file
diff --git a/engine/src/engine/asset/masterdata.cpp b/engine/src/engine/asset/masterdata.cpp
new file mode 100644
index 00000000..bb17f9d6
--- /dev/null
+++ b/engine/src/engine/asset/masterdata.cpp
@@ -0,0 +1,31 @@
+#include <uf/engine/asset/masterdata.h>
+#include <iostream>
+
+//std::string uf::MasterData::root = "https://el..xyz/mastertable/get/%TABLE%/%KEY%?.json";
+std::string uf::MasterData::root = uf::io::root + "/master/%TABLE%.json";
+uf::Asset uf::MasterData::assetLoader;
+
+uf::Serializer uf::MasterData::load( const std::string& table, size_t key ) {
+	return this->load( table, std::to_string(key) );
+}
+uf::Serializer uf::MasterData::load( const std::string& table, const std::string& key ) {
+	this->m_table = table;
+	this->m_key = key;
+
+	std::string url = uf::string::replace( root, "%TABLE%", table );
+	url = uf::string::replace( url, "%KEY%", key );
+	std::string filename = assetLoader.cache(url);
+	if ( filename != "" ) this->m_data.readFromFile(filename);
+	return this->get();
+}
+uf::Serializer uf::MasterData::get( const std::string& key ) const {
+	std::string k = (key == "" ? this->m_key : key);
+	if ( k != "" ) return this->m_data[k];
+	return this->m_data;
+}
+const std::string& uf::MasterData::tableName() const {
+	return this->m_table;
+}
+const std::string& uf::MasterData::keyName() const {
+	return this->m_key;
+}
\ No newline at end of file
diff --git a/engine/src/engine/behavior/behavior.cpp b/engine/src/engine/behavior/behavior.cpp
new file mode 100644
index 00000000..5343ca51
--- /dev/null
+++ b/engine/src/engine/behavior/behavior.cpp
@@ -0,0 +1,176 @@
+#include <uf/engine/behavior/behavior.h>
+#include <uf/engine/object/object.h>
+#include <uf/utils/serialize/serializer.h>
+#include <uf/utils/thread/thread.h>
+
+bool uf::Behaviors::hasBehavior( const pod::Behavior& target ) {
+	for ( auto& behavior : this->m_behaviors ) {
+		if ( behavior.type == target.type ) return true;
+	}
+	return false;
+}
+void uf::Behaviors::addBehavior( const pod::Behavior& behavior ) {
+	if ( hasBehavior( behavior ) ) return;
+	this->m_behaviors.emplace_back(behavior);
+}
+void uf::Behaviors::removeBehavior( const pod::Behavior& behavior ) {
+	//if ( hasBehavior( behavior ) ) return;
+	// this->m_behaviors.emplace_back(behavior);
+	auto it = this->m_behaviors.begin();
+	while ( it != this->m_behaviors.end() ) {
+		if ( it->type == behavior.type ) break;
+		++it;
+	}
+	if ( it != this->m_behaviors.end() ) this->m_behaviors.erase(it);
+}
+
+#define FUNCTION_AS_VARIABLE(x) x
+
+#define UF_BEHAVIOR_POLYFILL UF_BEHAVIOR_POLYFILL_SAFE
+/*
+//	if ( this->hasComponent<uf::Serializer>() ) {\
+//		auto& metadata = this->getComponent<uf::Serializer>();\
+//		if ( !ext::json::isNull( metadata["system"]["behavior"][#f]["head loop children"] ) )\
+//			headLoopChildren = metadata["system"]["behavior"][#f]["head loop children"].as<bool>();\
+//		if ( !ext::json::isNull( metadata["system"]["behavior"][#f]["forward iteration"] ) )\
+//			forwardIteration = metadata["system"]["behavior"][#f]["forward iteration"].as<bool>();\
+//		if ( !ext::json::isNull( metadata["system"]["behavior"][#f]["multithreading"] ) )\
+//			multithreading = metadata["system"]["behavior"][#f]["multithreading"].as<bool>();\
+//	}\
+*/
+#define UF_BEHAVIOR_POLYFILL_SAFE(f)\
+	bool headLoopChildren = true;\
+	bool forwardIteration = true;\
+	bool multithreading = false;\
+	auto function = [&]() -> int {\
+		if ( headLoopChildren ) {\
+			if ( forwardIteration )\
+				for ( auto& behavior : this->m_behaviors )\
+					behavior.f(self);\
+			else\
+				for ( auto it = this->m_behaviors.rbegin(); it != this->m_behaviors.rend(); ++it )\
+					it->f(self);\
+		} else {\
+			if ( forwardIteration ) {\
+				auto it = this->m_behaviors.begin();\
+				for ( ++it; it != this->m_behaviors.end(); ++it )\
+					it->f(self);\
+				if ( (it = this->m_behaviors.begin()) != this->m_behaviors.end() ) {\
+					it->f(self);\
+				}\
+			} else {\
+				auto it = this->m_behaviors.rbegin();\
+				for ( ++it; it != this->m_behaviors.rend(); ++it )\
+					it->f(self);\
+				if ( (it = this->m_behaviors.rbegin()) != this->m_behaviors.rend() ) {\
+					it->f(self);\
+				}\
+			}\
+		}\
+		return 0;\
+	};\
+	if ( multithreading ) uf::thread::add( uf::thread::fetchWorker(), function, true ); else function();
+
+#define UF_BEHAVIOR_POLYFILL_FAST(f)\
+	if ( this->m_behaviors.empty() ) return;\
+	uf::Object& self = *((uf::Object*) this);\
+	bool headLoopChildren = true;\
+	bool forwardIteration = true;\
+	bool multithreading = false;\
+	bool useWorkers = false;\
+	std::vector<std::function<int()>> jobs;\
+	if ( this->hasComponent<uf::Serializer>() ) {\
+		auto& metadata = this->getComponent<uf::Serializer>();\
+		if ( !ext::json::isNull( metadata["system"]["behavior"][#f]["head loop children"] ) )\
+			headLoopChildren = metadata["system"]["behavior"][#f]["head loop children"].as<bool>();\
+		if ( !ext::json::isNull( metadata["system"]["behavior"][#f]["forward iteration"] ) )\
+			forwardIteration = metadata["system"]["behavior"][#f]["forward iteration"].as<bool>();\
+		if ( !ext::json::isNull( metadata["system"]["behavior"][#f]["multithreading"] ) )\
+			multithreading = metadata["system"]["behavior"][#f]["multithreading"].as<bool>();\
+		if ( !ext::json::isNull( metadata["system"]["behavior"][#f]["use workers"] ) )\
+			useWorkers = metadata["system"]["behavior"][#f]["use workers"].as<bool>();\
+	}\
+	if ( headLoopChildren ) {\
+		if ( forwardIteration ) {\
+			auto it = this->m_behaviors.begin();\
+			if ( it != this->m_behaviors.end() ) {\
+				it->f(self);\
+			}\
+			for ( ++it; it != this->m_behaviors.end(); ++it ) {\
+				auto function = [&]() -> int {\
+					it->f(self);\
+					return 0;\
+				};\
+				if ( multithreading && useWorkers ) jobs.emplace_back(function);\
+				else if ( multithreading ) uf::thread::add( uf::thread::fetchWorker(), function, true );\
+				else function();\
+			}\
+		} else {\
+			auto it = this->m_behaviors.rbegin();\
+			if ( it != this->m_behaviors.rend() ) {\
+				it->f(self);\
+			}\
+			for ( ++it; it != this->m_behaviors.rend(); ++it ) {\
+				auto function = [&]() -> int {\
+					it->f(self);\
+					return 0;\
+				};\
+				if ( multithreading && useWorkers ) jobs.emplace_back(function);\
+				else if ( multithreading ) uf::thread::add( uf::thread::fetchWorker(), function, true );\
+				else function();\
+			}\
+		}\
+	} else {\
+		if ( forwardIteration ) {\
+			auto it = this->m_behaviors.begin();\
+			for ( ++it; it != this->m_behaviors.end(); ++it ) {\
+				auto function = [&]() -> int {\
+					it->f(self);\
+					return 0;\
+				};\
+				if ( multithreading && useWorkers ) jobs.emplace_back(function);\
+				else if ( multithreading ) uf::thread::add( uf::thread::fetchWorker(), function, true );\
+				else function();\
+			}\
+			if ( (it = this->m_behaviors.begin()) != this->m_behaviors.end() ) {\
+				it->f(self);\
+			}\
+		} else {\
+			auto it = this->m_behaviors.rbegin();\
+			for ( ++it; it != this->m_behaviors.rend(); ++it ) {\
+				auto function = [&]() -> int {\
+					it->f(self);\
+					return 0;\
+				};\
+				if ( multithreading && useWorkers ) jobs.emplace_back(function);\
+				else if ( multithreading ) uf::thread::add( uf::thread::fetchWorker(), function, true );\
+				else function();\
+			}\
+			if ( (it = this->m_behaviors.rbegin()) != this->m_behaviors.rend() ) {\
+				it->f(self);\
+			}\
+		}\
+	}\
+	if ( !jobs.empty() ) uf::thread::batchWorkers( jobs );
+
+
+void uf::Behaviors::initialize() {
+	uf::Object& self = *((uf::Object*) this);
+//	if ( !self.isValid() ) return;
+	UF_BEHAVIOR_POLYFILL(initialize)
+}
+void uf::Behaviors::tick() {
+	uf::Object& self = *((uf::Object*) this);
+	if ( !self.isValid() ) return;
+	UF_BEHAVIOR_POLYFILL(tick)
+}
+void uf::Behaviors::render() {
+	uf::Object& self = *((uf::Object*) this);
+	if ( !self.isValid() ) return;
+	UF_BEHAVIOR_POLYFILL(render)
+}
+void uf::Behaviors::destroy() {
+	uf::Object& self = *((uf::Object*) this);
+	if ( !self.isValid() ) return;
+	UF_BEHAVIOR_POLYFILL(destroy)
+}
\ No newline at end of file
diff --git a/engine/src/engine/entity/behavior.cpp b/engine/src/engine/entity/behavior.cpp
new file mode 100644
index 00000000..741edadc
--- /dev/null
+++ b/engine/src/engine/entity/behavior.cpp
@@ -0,0 +1,48 @@
+#include <uf/engine/entity/entity.h>
+#include <uf/engine/instantiator/instantiator.h>
+
+UF_BEHAVIOR_ENTITY_CPP_BEGIN(uf::Entity)
+uf::Entity::Entity() UF_BEHAVIOR_ENTITY_CPP_ATTACH(uf::Entity)
+#define this ((uf::Entity*) &self)
+void uf::EntityBehavior::initialize( uf::Object& self ) {
+	if ( !this->isValid() ) this->m_uid = ++uf::Entity::uids;
+	// sanitize children
+/*
+	for ( auto& kv : this->m_children ) {
+		if ( !uf::instantiator::valid(kv) ) {
+			std::cout << "FOUND INVALID CHILD IN " << this->getName() << ": " << this->getUid() << ": " << kv << std::endl;
+			kv = NULL;
+		}
+	}
+*/
+}
+void uf::EntityBehavior::tick( uf::Object& self ) {
+	for ( uf::Entity* kv : this->m_children ) {
+		if ( !kv ) continue;
+		if ( !kv->isValid() ) continue;
+		kv->tick();
+	}
+}
+void uf::EntityBehavior::render( uf::Object& self ) {
+	for ( uf::Entity* kv : this->m_children ) {
+		if ( !kv ) continue;
+		if ( !kv->isValid() ) continue;
+		kv->render();
+	}
+}
+void uf::EntityBehavior::destroy( uf::Object& self ) {
+	for ( uf::Entity* kv : this->m_children ) {
+		if ( !kv ) continue;
+		if ( !kv->isValid() ) continue;
+		kv->destroy();
+		if ( uf::Entity::deleteChildrenOnDestroy ) delete kv;
+	}
+	this->m_children.clear();
+	this->m_uid = 0;
+	if ( this->hasParent() )
+		this->getParent().removeChild(*this);
+
+	if ( uf::Entity::deleteComponentsOnDestroy ) this->destroyComponents();
+}
+#undef this
+UF_BEHAVIOR_ENTITY_CPP_END(Entity)
\ No newline at end of file
diff --git a/engine/src/engine/entity/entity.cpp b/engine/src/engine/entity/entity.cpp
new file mode 100644
index 00000000..0872c117
--- /dev/null
+++ b/engine/src/engine/entity/entity.cpp
@@ -0,0 +1,134 @@
+#include <uf/engine/entity/entity.h>
+#include <uf/engine/instantiator/instantiator.h>
+#include <uf/utils/io/iostream.h>
+
+uf::Entity uf::Entity::null;
+std::size_t uf::Entity::uids = 0;
+uf::MemoryPool uf::Entity::memoryPool;
+bool uf::Entity::deleteChildrenOnDestroy = false;
+bool uf::Entity::deleteComponentsOnDestroy = false;
+uf::Entity::~Entity(){
+	this->destroy();
+}
+bool uf::Entity::isValid() const {
+//	if ( uf::Entity::memoryPool.size() == 0 ) return false;
+	if ( uf::Entity::memoryPool.size() > 0 && !uf::Entity::memoryPool.exists((void*) this) ) return false;
+	return 0 < this->m_uid && this->m_uid <= uf::Entity::uids;
+}
+bool uf::Entity::hasParent() const {
+	return this->m_parent;
+}
+void uf::Entity::setParent() {
+	this->m_parent = NULL;
+}
+void uf::Entity::setParent( uf::Entity& parent ) {
+	this->m_parent = &parent == &uf::Entity::null ? NULL : &parent;
+}
+uf::Entity& uf::Entity::addChild( uf::Entity& child ) {
+	this->m_children.push_back(&child);
+	child.setParent(*this);
+	return child;
+}
+void uf::Entity::addChild( uf::Entity* child ) {
+	if ( !child ) return;
+	this->m_children.push_back(child);
+	child->setParent(*this);
+}
+void uf::Entity::removeChild( uf::Entity& child ) {
+	auto it = std::find( this->m_children.begin(), this->m_children.end(), &child );
+	if ( it == this->m_children.end() ) return;
+	this->m_children.erase(it);
+	child.setParent();
+}
+void uf::Entity::moveChild( uf::Entity& child ) {
+	if ( !child.m_parent ) return;
+	uf::Entity& parent = *child.m_parent;
+	parent.removeChild( child );
+	this->addChild( child );
+}
+uf::Entity::container_t& uf::Entity::getChildren() {
+	return this->m_children;
+}
+const uf::Entity::container_t& uf::Entity::getChildren() const {
+	return this->m_children;
+}
+const std::string& uf::Entity::getName() const {
+	return this->m_name;
+}
+void uf::Entity::setName( const std::string& name ) {
+	this->m_name = name;
+}
+std::size_t uf::Entity::getUid() const {
+	return this->m_uid;
+}
+
+void* uf::Entity::operator new(size_t size, const std::string& type ) {
+	return type != "" && size == sizeof(uf::Entity) ? &uf::instantiator::instantiate( type ) : uf::instantiator::alloc( size );
+}
+void uf::Entity::operator delete( void* pointer ) {
+	uf::instantiator::free( (uf::Entity*) pointer );
+}
+
+uf::Entity* uf::Entity::findByName( const std::string& name ) {
+	for ( uf::Entity* entity : this->getChildren() ) {
+		if ( entity->getName() == name ) return entity;
+		uf::Entity* p = entity->findByName(name);
+		if ( p ) return p;
+	}
+	return (uf::Entity*) NULL;
+};
+uf::Entity* uf::Entity::findByUid( std::size_t id ) {
+	for ( uf::Entity* entity : this->getChildren() ) {
+		if ( entity->getUid() == id ) return entity;
+		uf::Entity* p = entity->findByUid(id);
+		if ( p ) return p;
+	}
+	return (uf::Entity*) NULL;
+};
+
+const uf::Entity* uf::Entity::findByName( const std::string& name ) const {
+	for ( uf::Entity* entity : this->getChildren() ) {
+		if ( entity->getName() == name ) return entity;
+		uf::Entity* p = entity->findByName(name);
+		if ( p ) return p;
+	}
+	return (uf::Entity*) NULL;
+};
+const uf::Entity* uf::Entity::findByUid( std::size_t id ) const {
+	for ( const uf::Entity* entity : this->getChildren() ) {
+		if ( entity->getUid() == id ) return entity;
+		const uf::Entity* p = entity->findByUid(id);
+		if ( p ) return p;
+	}
+	return (const uf::Entity*) NULL;
+};
+
+void uf::Entity::process( std::function<void(uf::Entity*)> fn ) {
+	fn(this);
+	for ( uf::Entity* entity : this->getChildren() ) {
+		if ( !entity ) continue;
+		entity->process(fn);
+	}
+}
+void uf::Entity::process( std::function<void(uf::Entity*, int)> fn, int depth ) {
+	fn(this, depth);
+	for ( uf::Entity* entity : this->getChildren() ) {
+		if ( !entity ) continue;
+		entity->process(fn, depth + 1);
+	}
+}
+uf::Entity* uf::Entity::globalFindByUid( size_t uid ) {
+	for ( auto& allocation : uf::Entity::memoryPool.allocations() ) {
+		uf::Entity* entity = (uf::Entity*) allocation.pointer;
+		if ( entity->getUid() == uid ) return entity;
+	}
+	return NULL;
+}
+uf::Entity* uf::Entity::globalFindByName( const std::string& name ) {
+	for ( auto& allocation : uf::Entity::memoryPool.allocations() ) {
+		uf::Entity* entity = (uf::Entity*) allocation.pointer;
+		if ( !entity->isValid() ) continue;
+		if ( entity->getName() == name ) return entity;
+	}
+	return NULL;
+}
\ No newline at end of file
diff --git a/engine/src/engine/instantiator/instantiator.cpp b/engine/src/engine/instantiator/instantiator.cpp
new file mode 100644
index 00000000..13ef7fc0
--- /dev/null
+++ b/engine/src/engine/instantiator/instantiator.cpp
@@ -0,0 +1,148 @@
+#include <uf/engine/instantiator/instantiator.h>
+#include <uf/engine/object/object.h>
+#include <uf/engine/scene/scene.h>
+#include <assert.h>
+
+pod::NamedTypes<pod::Instantiator>* uf::instantiator::objects = NULL;
+pod::NamedTypes<pod::Behavior>* uf::instantiator::behaviors = NULL;
+
+uf::Entity* uf::instantiator::reuse( size_t size ) {
+	uf::Entity* laxed = NULL;
+	auto& allocations = uf::Entity::memoryPool.allocations();
+
+	for ( auto& allocation : allocations ) {
+		uf::Entity* e = (uf::Entity*) allocation.pointer;
+		// no scenes
+		if ( std::find( uf::scene::scenes.begin(), uf::scene::scenes.end(), (uf::Scene*) e ) != uf::scene::scenes.end() ) continue;
+		// only orphaned
+		if ( e->hasParent() ) continue;
+		// only destroyed entities 
+		if ( e->getName() == "Entity" || e->getUid() > 0 ) continue;
+		if ( allocation.size == size ) return e;
+		if ( allocation.size > size ) laxed = e;
+	}
+	return laxed;
+}
+size_t uf::instantiator::collect( uint8_t level ) {
+	size_t collected = 0;
+	auto& allocations = uf::Entity::memoryPool.allocations();
+	auto& scene = uf::scene::getCurrentScene();
+	for ( auto& allocation : allocations ) {
+		uf::Entity* e = (uf::Entity*) allocation.pointer;
+		// no scenes
+		// if ( std::find( uf::scene::scenes.begin(), uf::scene::scenes.end(), (uf::Scene*) e ) != uf::scene::scenes.end() ) continue;
+		// not current scene
+		if ( e->getUid() == scene.getUid() ) continue;
+		// only orphaned
+		if ( e->hasParent() ) continue;
+		// uninitialized
+		if ( e->getName() == "Entity" && !e->isValid() ) continue;
+		// uf::iostream << "Found orphan: " << e->getName() << ": " << e->getUid() << "\n";
+		uf::instantiator::free( e );
+		++collected;
+	}
+	return collected;
+}
+
+uf::Entity* uf::instantiator::alloc( size_t size ) {
+	// auto* reused = reuse( size ); if ( reused ) return reused;
+#if UF_MEMORYPOOL_INVALID_MALLOC
+	uf::MemoryPool& memoryPool = uf::Entity::memoryPool.size() > 0 ? uf::Entity::memoryPool : uf::MemoryPool::global;
+	return (uf::Entity*) memoryPool.alloc( NULL, size );
+#else
+	uf::Entity* pointer = NULL;
+	uf::MemoryPool* memoryPool = NULL;
+	if ( uf::Entity::memoryPool.size() > 0 )
+		memoryPool = &uf::Entity::memoryPool;
+	else if ( uf::MemoryPool::global.size() > 0 )
+		memoryPool = &uf::MemoryPool::global;
+	if ( memoryPool ) pointer = (uf::Entity*) memoryPool->alloc( NULL, size );
+	else pointer = (uf::Entity*) malloc( size );
+	return pointer;
+#endif
+}
+void uf::instantiator::free( uf::Entity* pointer ) {
+	if ( !pointer ) return;
+	if ( pointer->getUid() > 0 )
+		pointer->destroy();
+
+#if UF_MEMORYPOOL_INVALID_FREE
+	uf::MemoryPool& memoryPool = uf::Entity::memoryPool.size() > 0 ? uf::Entity::memoryPool : uf::MemoryPool::global;
+	memoryPool.free( pointer );
+#else
+	uf::MemoryPool* memoryPool = NULL;
+	if ( uf::Entity::memoryPool.size() > 0 )
+		memoryPool = &uf::Entity::memoryPool;
+	else if ( uf::MemoryPool::global.size() > 0 )
+		memoryPool = &uf::MemoryPool::global;
+	if ( memoryPool ) memoryPool->free( pointer );
+	else ::free( pointer );
+#endif
+}
+bool uf::instantiator::valid( uf::Entity* pointer ) {
+#if UF_MEMORYPOOL_INVALID_FREE
+	uf::MemoryPool& memoryPool = uf::Entity::memoryPool.size() > 0 ? uf::Entity::memoryPool : uf::MemoryPool::global;
+	return memoryPool.exists( pointer );
+#else
+	uf::MemoryPool* memoryPool = NULL;
+	if ( uf::Entity::memoryPool.size() > 0 )
+		memoryPool = &uf::Entity::memoryPool;
+	else if ( uf::MemoryPool::global.size() > 0 )
+		memoryPool = &uf::MemoryPool::global;
+	return memoryPool ? memoryPool->exists( pointer ) : pointer && pointer->isValid();
+#endif
+}
+
+void uf::instantiator::registerBinding( const std::string& object, const std::string& behavior ) {
+	if ( !objects ) objects = new pod::NamedTypes<pod::Instantiator>;
+/*
+	if ( !uf::instantiator::objects->has( object ) ) {
+	//	uf::instantiator::registerObject<uf::Object>( object );
+	}
+*/
+	auto& instantiator = uf::instantiator::objects->get( object );
+	instantiator.behaviors.emplace_back( behavior );
+	
+	if ( UF_INSTANTIATOR_ANNOUNCE ) std::cout << "Registered binding: " << object << " and " << behavior << ": " << instantiator.behaviors.size() << std::endl;
+}
+
+uf::Entity& uf::instantiator::instantiate( const std::string& name ) {
+	if ( !uf::instantiator::objects->has( name ) ) {
+		auto& object = uf::instantiator::instantiate<uf::Object>();
+		return *((uf::Entity*) &object);
+	}
+	auto& instantiator = uf::instantiator::objects->get( name );
+	auto& entity = *instantiator.function();
+	bind( name, entity );
+	return entity;
+}
+
+void uf::instantiator::bind( const std::string& name, uf::Entity& entity ) {
+	// was actually a behavior name, single bind
+	if ( !uf::instantiator::objects->has( name, false ) ) {
+		if ( !uf::instantiator::behaviors->has( name, false ) ) return;
+		auto& behavior = uf::instantiator::behaviors->get( name );
+		entity.addBehavior(behavior);
+		return;
+	}
+	auto& instantiator = uf::instantiator::objects->get( name );
+	for ( auto& name : instantiator.behaviors ) {
+		auto& behavior = uf::instantiator::behaviors->get( name );
+		entity.addBehavior(behavior);
+	}
+}
+
+void uf::instantiator::unbind( const std::string& name, uf::Entity& entity ) {
+	// was actually a behavior name, single bind
+	if ( !uf::instantiator::objects->has( name, false ) ) {
+		if ( !uf::instantiator::behaviors->has( name, false ) ) return;
+		auto& behavior = uf::instantiator::behaviors->get( name );
+		entity.removeBehavior(behavior);
+		return;
+	}
+	auto& instantiator = uf::instantiator::objects->get( name );
+	for ( auto& name : instantiator.behaviors ) {
+		auto& behavior = uf::instantiator::behaviors->get( name );
+		entity.removeBehavior(behavior);
+	}
+}
\ No newline at end of file
diff --git a/engine/src/engine/object/behavior.cpp b/engine/src/engine/object/behavior.cpp
new file mode 100644
index 00000000..16fade92
--- /dev/null
+++ b/engine/src/engine/object/behavior.cpp
@@ -0,0 +1,192 @@
+#include <uf/engine/object/object.h>
+#include <uf/engine/asset/asset.h>
+#include <uf/engine/scene/scene.h>
+#include <uf/utils/time/time.h>
+#include <uf/utils/audio/audio.h>
+#include <uf/utils/math/transform.h>
+#include <uf/utils/math/physics.h>
+#include <uf/utils/graphic/graphic.h>
+#include <uf/utils/camera/camera.h>
+#include <uf/utils/graphic/mesh.h>
+#include <uf/utils/renderer/renderer.h>
+#include <uf/ext/gltf/gltf.h>
+#include <uf/ext/bullet/bullet.h>
+
+UF_BEHAVIOR_ENTITY_CPP_BEGIN(uf::Object)
+#define this (&self)
+void uf::ObjectBehavior::initialize( uf::Object& self ) {
+	auto& scene = uf::scene::getCurrentScene();
+	auto& assetLoader = scene.getComponent<uf::Asset>();
+	auto& metadata = this->getComponent<uf::Serializer>();
+
+	// 
+	{
+		size_t assets = metadata["system"]["assets"].size();
+		if ( metadata["system"]["load"]["ignore"].is<bool>() ) assets = 0;
+		metadata["system"]["load"]["progress"] = 0;
+		metadata["system"]["load"]["total"] = assets;
+		if ( assets == 0 )  {
+			auto& parent = this->getParent().as<uf::Object>();
+			uf::Serializer payload;
+			payload["uid"] = this->getUid();
+			parent.callHook("asset:Parsed.%UID%", payload);
+		}
+	}
+
+#if UF_USE_BULLET
+	if ( ext::json::isObject(metadata["system"]["physics"]) ) {
+		float mass = metadata["system"]["physics"]["mass"].as<float>();
+		if ( metadata["system"]["physics"]["type"].as<std::string>() == "BoundingBox" ) {
+			pod::Vector3f corner = uf::vector::decode( metadata["system"]["physics"]["corner"], pod::Vector3f{0.5, 0.5, 0.5} );
+			ext::bullet::create( *this, corner, mass );
+		} else if ( metadata["system"]["physics"]["type"].as<std::string>() == "Capsule" ) {
+			float radius = metadata["system"]["physics"]["radius"].as<float>();
+			float height = metadata["system"]["physics"]["height"].as<float>();
+			ext::bullet::create( *this, radius, height, mass );
+		} else {
+			return;
+		}
+
+		auto& collider = this->getComponent<pod::Bullet>();
+		if ( !ext::json::isNull( metadata["system"]["physics"]["gravity"] ) ) {
+			collider.body->setGravity( btVector3(
+				metadata["system"]["physics"]["gravity"][0].as<float>(),
+				metadata["system"]["physics"]["gravity"][1].as<float>(),
+				metadata["system"]["physics"]["gravity"][2].as<float>()
+			) );
+			if ( metadata["system"]["physics"]["shared"].is<bool>() ) {
+				collider.shared = metadata["system"]["physics"]["shared"].as<bool>();
+			}
+		}
+	}
+#endif
+
+	this->addHook( "object:TransformReferenceController.%UID%", [&](ext::json::Value& json){
+		auto& transform = this->getComponent<pod::Transform<>>();
+		auto& controller = scene.getController();
+		if ( json["target"].as<std::string>() == "camera" ) {
+			auto& camera = controller.getComponent<uf::Camera>();
+			transform.reference = &camera.getTransform();
+		} else {
+			transform.reference = &controller.getComponent<pod::Transform<>>();
+		}
+	});
+	this->addHook( "object:UpdateMetadata.%UID%", [&](ext::json::Value& json){	
+		if ( json["type"].as<std::string>() == "merge" ) {
+			metadata.merge(json["value"], true);
+		} else if ( json["type"].as<std::string>() == "import" ) {
+			metadata.import(json["value"]);
+		} else if ( json["path"].is<std::string>() ) {
+			metadata.path(json["path"].as<std::string>()) = json["value"];
+		} else {
+			metadata.merge(json, true);
+		}
+	});
+	this->addHook( "asset:QueueLoad.%UID%", [&](ext::json::Value& json){
+		std::string filename = json["filename"].as<std::string>();
+		std::string hash = json["hash"].as<std::string>();
+		std::string category = json["category"].as<std::string>();
+		std::string callback = this->formatHookName("asset:FinishedLoad.%UID%");
+		if ( json["single threaded"].as<bool>() ) {
+			assetLoader.load( filename, hash, category );
+			this->queueHook( callback, json );
+		} else {
+			assetLoader.load( callback, filename, hash, category );
+		}
+	});
+	this->addHook( "asset:FinishedLoad.%UID%", [&](ext::json::Value& json){
+		this->queueHook("asset:Load.%UID%", json);
+		this->queueHook("asset:Parsed.%UID%", json);
+	});	
+	this->addHook( "asset:Load.%UID%", [&](ext::json::Value& json){
+		std::string filename = json["filename"].as<std::string>();
+		std::string category = json["category"].as<std::string>();
+		bool initialize = ext::json::isNull( json["initialize"] ) ? true : json["initialize"].as<bool>();
+		if ( category != "" && category != "entities" ) return;
+		if ( category == "" && uf::io::extension(filename) != "json" ) return;
+		{
+			uf::Serializer json;
+			if ( !json.readFromFile(filename) ) return;
+
+			json["root"] = uf::io::directory(filename);
+			json["source"] = filename;
+			json["hot reload"]["mtime"] = uf::io::mtime( filename ) + 10;
+
+			if ( this->loadChildUid(json, initialize) == -1 ) return;
+		}
+	});
+	this->addHook( "asset:Parsed.%UID%", [&](ext::json::Value& json){	
+		int portion = 1;
+		auto& total = metadata["system"]["load"]["total"];
+		auto& progress = metadata["system"]["load"]["progress"];
+		progress = progress.as<int>() + portion;
+		if ( progress.as<int>() == total.as<int>() ) {
+			auto& parent = this->getParent().as<uf::Object>();
+
+			uf::Serializer payload;
+			payload["uid"] = this->getUid();
+			parent.callHook("asset:Parsed.%UID%", payload);
+		}
+	});
+}
+void uf::ObjectBehavior::destroy( uf::Object& self ) {
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	for( auto it = metadata["system"]["hooks"]["alloc"].begin() ; it != metadata["system"]["hooks"]["alloc"].end() ; ++it ) {
+	 	std::string name = it.key();
+		for ( size_t i = 0; i < metadata["system"]["hooks"]["alloc"][name].size(); ++i ) {
+			size_t id = metadata["system"]["hooks"]["alloc"][name][(int) i].as<size_t>();
+			uf::hooks.removeHook(name, id);
+		}
+	}
+
+	if ( this->hasComponent<uf::Audio>() ) {
+		auto& audio = this->getComponent<uf::Audio>();
+		audio.destroy();
+	}
+	if ( this->hasComponent<uf::SoundEmitter>() ) {
+		auto& audio = this->getComponent<uf::SoundEmitter>();
+		audio.cleanup(true);
+	}
+	if ( this->hasComponent<uf::Graphic>() ) {
+		auto& graphic = this->getComponent<uf::Graphic>();
+		graphic.destroy();
+		uf::renderer::states::rebuild = true;
+	}
+}
+void uf::ObjectBehavior::tick( uf::Object& self ) {
+	// listen for metadata file changes
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	if ( metadata["system"]["hot reload"]["enabled"].as<bool>() ) {
+		size_t mtime = uf::io::mtime( metadata["system"]["source"].as<std::string>() );
+		if ( metadata["system"]["hot reload"]["mtime"].as<size_t>() < mtime ) {
+			std::cout << "File reload detected: " << ": " << metadata["system"]["source"].as<std::string>() << ", " << metadata["system"]["hot reload"]["mtime"] << " -> " << mtime << std::endl;
+			metadata["system"]["hot reload"]["mtime"] = mtime;
+			this->reload();
+			//this->queueHook("metadata:Reload.%UID%");
+		}
+	}
+
+	// Call queued hooks
+	{
+		if ( !uf::Object::timer.running() ) uf::Object::timer.start();
+		float curTime = uf::Object::timer.elapsed().asDouble();
+		uf::Serializer newQueue = ext::json::array();
+		if ( !ext::json::isNull( metadata["system"]["hooks"]["queue"] ) ) {
+			ext::json::forEach(metadata["system"]["hooks"]["queue"], [&](ext::json::Value& member){
+				if ( !ext::json::isObject(member) ) return;
+				uf::Serializer payload = member["payload"];
+				std::string name = member["name"].as<std::string>();
+				float timeout = member["timeout"].as<float>();
+				if ( timeout < curTime ) {
+					this->callHook( name, payload );
+				} else {
+					newQueue.emplace_back(member);
+				}
+			});
+		}
+		if ( ext::json::isObject( metadata ) ) metadata["system"]["hooks"]["queue"] = newQueue;
+	}
+}
+void uf::ObjectBehavior::render( uf::Object& self ) {}
+#undef this
+UF_BEHAVIOR_ENTITY_CPP_END(Object)
\ No newline at end of file
diff --git a/engine/src/engine/object/behaviors/gltf.cpp b/engine/src/engine/object/behaviors/gltf.cpp
new file mode 100644
index 00000000..77774448
--- /dev/null
+++ b/engine/src/engine/object/behaviors/gltf.cpp
@@ -0,0 +1,463 @@
+#include <uf/engine/object/behaviors/gltf.h>
+
+#include <uf/engine/object/object.h>
+#include <uf/engine/asset/asset.h>
+#include <uf/engine/scene/scene.h>
+#include <uf/utils/time/time.h>
+#include <uf/utils/math/transform.h>
+#include <uf/utils/math/physics.h>
+#include <uf/utils/graphic/graphic.h>
+#include <uf/utils/camera/camera.h>
+#include <uf/utils/thread/thread.h>
+#include <uf/utils/graphic/mesh.h>
+#include <uf/ext/gltf/gltf.h>
+#include <uf/utils/string/hash.h>
+
+UF_BEHAVIOR_REGISTER_CPP(uf::GltfBehavior)
+#define this (&self)
+void uf::GltfBehavior::initialize( uf::Object& self ) {	
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	metadata["textures"]["additional"] = ext::json::array(); //Json::Value(Json::arrayValue);
+	// Default load: GLTF model
+	this->addHook( "asset:Load.%UID%", [&](ext::json::Value& json){
+		std::string filename = json["filename"].as<std::string>();
+		std::string category = json["category"].as<std::string>();
+		if ( category != "" && category != "images" ) return;
+		if ( category == "" && uf::io::extension(filename) != "png" ) return;
+		auto& vector = metadata["textures"]["additional"];
+		vector[vector.size()] = filename;
+	});
+	this->addHook( "animation:Set.%UID%", [&](ext::json::Value& json){
+		std::string name = json["name"].as<std::string>();
+
+		if ( !this->hasComponent<pod::Graph>() ) return;
+		auto& graph = this->getComponent<pod::Graph>();
+		uf::graph::animate( graph, name );
+	});
+	this->addHook( "asset:Load.%UID%", [&](ext::json::Value& json){
+		std::string filename = json["filename"].as<std::string>();
+		std::string category = json["category"].as<std::string>();
+		if ( category != "" && category != "models" ) return;
+		if ( category == "" && uf::io::extension(filename) != "gltf" && uf::io::extension(filename) != "glb" && uf::io::extension(filename) != "graph" ) return;
+		
+		auto& scene = uf::scene::getCurrentScene();
+		auto& assetLoader = scene.getComponent<uf::Asset>();
+
+		{
+			pod::Graph* graphPointer = NULL;
+			if ( !assetLoader.has<pod::Graph>(filename) ) return;
+			graphPointer = &assetLoader.get<pod::Graph>(filename);
+
+			if ( !graphPointer ) return;
+			auto& graph = this->getComponent<pod::Graph>();
+			graph = std::move( *graphPointer );
+			graphPointer = &graph;
+		}
+		auto& graph = this->getComponent<pod::Graph>();
+		uf::Object* objectPointer = graph.root.entity;
+		objectPointer->process([&]( uf::Entity* entity ) {
+			if ( !entity->hasComponent<uf::Graphic>() ) return;
+			auto& graphic = entity->getComponent<uf::Graphic>();
+			if ( !(graph.mode & ext::gltf::LoadMode::LOAD) ) {
+				if ( graph.mode & ext::gltf::LoadMode::SEPARATE ) {
+					{
+						std::string filename = "/gltf/vert.spv";
+						if ( graph.mode & ext::gltf::LoadMode::SKINNED ) {
+							filename = "/gltf/skinned.vert.spv";
+						}
+						if ( metadata["system"]["renderer"]["shaders"]["vertex"].is<std::string>() )
+							filename = metadata["system"]["renderer"]["shaders"]["vertex"].as<std::string>();
+						filename = this->grabURI( filename, metadata["system"]["root"].as<std::string>() );
+						graphic.material.attachShader(filename, uf::renderer::enums::Shader::VERTEX);
+					}
+					{
+						std::string filename = "/gltf/frag.spv";
+						if ( metadata["system"]["renderer"]["shaders"]["fragment"].is<std::string>() ) 
+							filename = metadata["system"]["renderer"]["shaders"]["fragment"].as<std::string>();
+						filename = this->grabURI( filename, metadata["system"]["root"].as<std::string>() );
+						graphic.material.attachShader(filename, uf::renderer::enums::Shader::FRAGMENT);
+					}
+				} else {
+					{
+						std::string filename = "/gltf/instanced.vert.spv";
+						if ( graph.mode & ext::gltf::LoadMode::SKINNED ) {
+							filename = "/gltf/skinned.instanced.vert.spv";
+						}
+						if ( metadata["system"]["renderer"]["shaders"]["vertex"].is<std::string>() )
+							filename = metadata["system"]["renderer"]["shaders"]["vertex"].as<std::string>();
+						filename = this->grabURI( filename, metadata["system"]["root"].as<std::string>() );
+						graphic.material.attachShader(filename, uf::renderer::enums::Shader::VERTEX);
+					}
+					{
+						std::string filename = "/gltf/frag.spv";
+						if ( metadata["system"]["renderer"]["shaders"]["fragment"].is<std::string>() ) 
+							filename = metadata["system"]["renderer"]["shaders"]["fragment"].as<std::string>();
+						filename = this->grabURI( filename, metadata["system"]["root"].as<std::string>() );
+						graphic.material.attachShader(filename, uf::renderer::enums::Shader::FRAGMENT);
+					}
+				}
+			}
+
+			for ( int i = 0; i < metadata["textures"]["additional"].size(); ++i ) {
+				std::string filename = metadata["textures"]["additional"][i].as<std::string>();
+				auto& scene = uf::scene::getCurrentScene();
+				auto& assetLoader = scene.getComponent<uf::Asset>();
+				const uf::Image* imagePointer = NULL;
+				if ( !assetLoader.has<uf::Image>(filename) ) return;
+				imagePointer = &assetLoader.get<uf::Image>(filename);
+				if ( !imagePointer ) continue;
+				uf::Image image = *imagePointer;
+				auto& texture = graphic.material.textures.emplace_back();
+				texture.loadFromImage( image );
+			}
+			graphic.process = true;
+
+		#if UF_USE_VULKAN
+			{
+				auto& shader = graphic.material.getShader("vertex");
+				struct SpecializationConstant {
+					uint32_t passes = 6;
+				};
+				auto& specializationConstants = shader.specializationConstants.get<SpecializationConstant>();
+				specializationConstants.passes = uf::renderer::settings::maxViews;
+
+			
+				ext::json::forEach( shader.metadata["specializationConstants"], [&]( ext::json::Value& sc ){
+					std::string name = sc["name"].as<std::string>();
+					if ( name == "PASSES" ) {
+						sc["value"] = specializationConstants.passes;
+					}
+				});
+			
+			}
+			{
+				auto& shader = graphic.material.getShader("fragment");
+				struct SpecializationConstant {
+					uint32_t textures = 1;
+				};
+				auto& specializationConstants = shader.specializationConstants.get<SpecializationConstant>();
+				specializationConstants.textures = graphic.material.textures.size();
+			
+				ext::json::forEach( shader.metadata["specializationConstants"], [&]( ext::json::Value& sc ){
+					std::string name = sc["name"].as<std::string>();
+					if ( name == "TEXTURES" ) {
+						sc["value"] = specializationConstants.textures;
+					}
+				});
+			
+				for ( auto& binding : shader.descriptorSetLayoutBindings ) {
+					if ( binding.descriptorCount > 1 )
+						binding.descriptorCount = specializationConstants.textures;
+				}
+				{
+					auto& definition = shader.metadata["definitions"]["uniforms"]["UBO"];
+					size_t size = definition["size"].as<size_t>();
+					size_t elements = definition["value"].size();
+					if ( elements > 0 ) {
+						definition["size"] = size / elements * specializationConstants.textures;
+						ext::json::Value value = definition["value"][0];
+						definition["value"] = ext::json::array();
+						for ( size_t i = 0; i < specializationConstants.textures; ++i ) {
+							definition["value"].emplace_back(value);
+						}
+					}
+				}
+			}
+		#endif
+		});
+		this->addChild(objectPointer->as<uf::Entity>());
+
+		auto& transform = this->getComponent<pod::Transform<>>();
+		objectPointer->getComponent<pod::Transform<>>().reference = &transform;
+		
+		objectPointer->initialize();
+		objectPointer->process([&]( uf::Entity* entity ) {
+			if ( !entity->hasComponent<uf::Graphic>() ) {
+				if ( entity->getUid() == 0 ) entity->initialize();
+				return;
+			}
+			auto& eMetadata = entity->getComponent<uf::Serializer>();
+			eMetadata["textures"]["map"] = metadata["textures"]["map"];
+		//	if ( graph.mode & ext::gltf::LoadMode::SEPARATE ) uf::instantiator::bind( "RenderBehavior", *entity );
+			uf::instantiator::bind( "GltfBehavior", *entity );
+			uf::instantiator::unbind( "RenderBehavior", *entity );
+			if ( entity->getUid() == 0 ) entity->initialize();
+		});
+
+		if ( graph.mode & ext::gltf::LoadMode::SKINNED ) {
+			if ( metadata["model"]["animation"].is<std::string>() ) {
+				uf::graph::animate( graph, metadata["model"]["animation"].as<std::string>() );
+			}
+			if ( metadata["model"]["print animations"].as<bool>() ) {
+				uf::Serializer json = ext::json::array(); //Json::Value(Json::arrayValue);
+				for ( auto pair : graph.animations ) json.emplace_back( pair.first );
+				uf::iostream << "Animations found: " << json << "\n";
+			}
+		}
+	});
+}
+void uf::GltfBehavior::destroy( uf::Object& self ) {
+	if ( this->hasComponent<pod::Graph>() ) {
+		auto& graph = this->getComponent<pod::Graph>();
+		uf::graph::destroy( graph );
+	}
+}
+void uf::GltfBehavior::tick( uf::Object& self ) {
+	/* Animation change test */ 
+	if ( this->hasComponent<pod::Graph>() ) {
+		std::vector<std::string> animations = { "wank","walk","sit_wank","run","idle_wank","sit","idle" };
+		bool anyNumber =
+			uf::Window::isKeyPressed("1") ||
+			uf::Window::isKeyPressed("2") ||
+			uf::Window::isKeyPressed("3") ||
+			uf::Window::isKeyPressed("4") ||
+			uf::Window::isKeyPressed("5") ||
+			uf::Window::isKeyPressed("6") ||
+			uf::Window::isKeyPressed("7") ||
+			uf::Window::isKeyPressed("8") ||
+			uf::Window::isKeyPressed("9") ||
+			uf::Window::isKeyPressed("0");
+		TIMER(1, anyNumber && ) {
+			auto& graph = this->getComponent<pod::Graph>();
+			std::string target = "";
+			if ( uf::Window::isKeyPressed("1") && animations.size() >= 1 ) target = animations[0];
+			else if ( uf::Window::isKeyPressed("2") && animations.size() >= 2 ) target = animations[1];
+			else if ( uf::Window::isKeyPressed("3") && animations.size() >= 3 ) target = animations[2];
+			else if ( uf::Window::isKeyPressed("4") && animations.size() >= 4 ) target = animations[3];
+			else if ( uf::Window::isKeyPressed("5") && animations.size() >= 5 ) target = animations[4];
+			else if ( uf::Window::isKeyPressed("6") && animations.size() >= 6 ) target = animations[5];
+			else if ( uf::Window::isKeyPressed("7") && animations.size() >= 7 ) target = animations[6];
+			else if ( uf::Window::isKeyPressed("8") && animations.size() >= 8 ) target = animations[7];
+			else if ( uf::Window::isKeyPressed("9") && animations.size() >= 9 ) target = animations[8];
+			else if ( uf::Window::isKeyPressed("0") && animations.size() >= 10 ) target = animations[9];
+			std::cout << "CHANGING ANIMATION TO " << target << std::endl;
+			// graph.animationSettings.loop = false;
+			uf::graph::animate( graph, target, 1 / 0.125f );
+		}
+	}
+
+	/* Update animations */ if ( this->hasComponent<pod::Graph>() ) {
+		auto& graph = this->getComponent<pod::Graph>();
+		if ( graph.mode & ext::gltf::LoadMode::SKINNED ) {
+			uf::graph::update( graph );
+		}
+	/*
+		auto& transform = this->getComponent<pod::Transform<>>();
+		auto& node = graph.node->children.size() == 1 ? *graph.node->children[0] : *graph.node;
+		pod::Matrix4f nodeMatrix = node.transform.model;
+		pod::Node* currentParent = uf::graph::find(graph, node.parent);
+		while ( currentParent ) {
+			nodeMatrix = currentParent->transform.model * nodeMatrix;
+			currentParent = uf::graph::find(graph, currentParent->parent);
+		}
+		transform.model = nodeMatrix;
+	*/
+	}
+#if UF_USE_OPENGL
+	/* Update uniforms */ if ( this->hasComponent<uf::Graphic>() ) {
+		auto& scene = uf::scene::getCurrentScene();
+		auto& metadata = this->getComponent<uf::Serializer>();
+		auto& graphic = this->getComponent<uf::Graphic>();
+		auto& controller = scene.getController();
+		auto& camera = controller.getComponent<uf::Camera>();
+
+		if ( !graphic.initialized ) return;
+		if ( !graphic.material.hasShader("vertex") ) return;
+
+		auto* objectWithGraph = this;
+		while ( objectWithGraph != &scene ) {
+			if ( objectWithGraph->hasComponent<pod::Graph>() ) break;
+			objectWithGraph = &objectWithGraph->getParent().as<uf::Object>();
+		}
+		if ( !objectWithGraph->hasComponent<pod::Graph>() ) return;
+
+		auto& shader = graphic.material.getShader("vertex");
+		auto& graph = objectWithGraph->getComponent<pod::Graph>();
+		auto& mesh = this->getComponent<ext::gltf::mesh_t>();
+
+		if ( !(graph.mode & ext::gltf::LoadMode::SEPARATE) ) {
+			std::vector<pod::Matrix4f> instances( graph.nodes.size() );
+			for ( size_t i = 0; i < graph.nodes.size(); ++i ) {
+				auto& node = graph.nodes[i];
+				instances[i] = node.entity ? uf::transform::model( node.entity->getComponent<pod::Transform<>>() ) : uf::transform::model( node.transform );
+			}
+
+			graphic.updateBuffer( (void*) instances.data(), instances.size() * sizeof(pod::Matrix4f), graph.instanceBufferIndex );
+			shader.execute( graphic, &mesh.vertices[0] );
+		} else if ( graph.mode & ext::gltf::LoadMode::SKINNED ) {
+			shader.execute( graphic, &mesh.vertices[0] );
+		}
+	}
+#elif UF_USE_VULKAN
+	/* Update uniforms */ if ( this->hasComponent<uf::Graphic>() ) {
+		auto& scene = uf::scene::getCurrentScene();
+		auto& metadata = this->getComponent<uf::Serializer>();
+		auto& graphic = this->getComponent<uf::Graphic>();
+		auto& controller = scene.getController();
+		auto& camera = controller.getComponent<uf::Camera>();
+
+		if ( !graphic.initialized ) return;
+		if ( !graphic.material.hasShader("fragment") ) return;
+
+		auto* objectWithGraph = this;
+		while ( objectWithGraph != &scene ) {
+			if ( objectWithGraph->hasComponent<pod::Graph>() ) break;
+			objectWithGraph = &objectWithGraph->getParent().as<uf::Object>();
+		}
+		if ( !objectWithGraph->hasComponent<pod::Graph>() ) return;
+
+		auto& graph = objectWithGraph->getComponent<pod::Graph>();
+		if ( !(graph.mode & ext::gltf::LoadMode::SEPARATE) ) {
+			auto& shader = graphic.material.getShader("vertex");
+			std::vector<pod::Matrix4f> instances( graph.nodes.size() );
+			for ( size_t i = 0; i < graph.nodes.size(); ++i ) {
+				auto& node = graph.nodes[i];
+				instances[i] = node.entity ? uf::transform::model( node.entity->getComponent<pod::Transform<>>() ) : uf::transform::model( node.transform );
+			}
+			auto& storageBuffer = *graphic.getStorageBuffer("Models");
+			graphic.updateBuffer( (void*) instances.data(), instances.size() * sizeof(pod::Matrix4f), graph.instanceBufferIndex /*storageBuffer*/ );
+		}
+	/*
+		if ( graph.materials.empty() && graphic.hasStorage("Materials") ) {
+			auto& shader = graphic.material.getShader("fragment");
+			std::vector<pod::Material::Storage> materials( graph.materials.size() );
+			for ( size_t i = 0; i < graph.materials.size(); ++i ) {
+				materials[i] = graph.materials[i].storage;
+				materials[i].indexMappedTarget = graph.mode & ext::gltf::LoadMode::ATLAS ? 0 : i;
+				materials[i].factorMappedBlend = graph.mode & ext::gltf::LoadMode::ATLAS ? 1.0f : 0.0f;
+			}
+			{
+				size_t texturesLen = graphic.material.textures.size();
+				ext::json::forEach(metadata["textures"]["map"], [&]( const std::string& key, const ext::json::Value& mapping ){
+					uint32_t from = std::stoi(key);
+					if ( mapping["alpha cutoff"].is<float>() ) {
+						materials[from].factorAlphaCutoff = mapping["alpha cutoff"].as<float>();
+					}
+					if ( mapping["to"].is<size_t>() ) {
+						uint32_t to = mapping["to"].as<size_t>();
+						float blend = 1.0f;
+						if ( mapping["factor"].as<std::string>() == "sin(time)" ) {
+							blend = sin(uf::physics::time::current)*0.5f+0.5f;
+						} else if ( mapping["factor"].as<std::string>() == "cos(time)" ) {
+							blend = cos(uf::physics::time::current)*0.5f+0.5f;
+						} else if ( mapping["factor"].is<float>() ) {
+							blend = mapping["factor"].as<float>();
+						}
+						if ( from >= texturesLen || to >= texturesLen ) return;
+						materials[from].indexMappedTarget = to;
+						materials[from].factorMappedBlend = blend;
+					}
+				});
+			}
+			auto& storageBuffer = *graphic.getStorageBuffer("Materials");
+			graphic.updateBuffer( (void*) materials.data(), materials.size() * sizeof(pod::Material::Storage), graph.root.materialBufferIndex /storageBuffer/ );
+		}
+	*/
+	}
+#endif
+}
+
+namespace {
+	template<size_t N = uf::renderer::settings::maxViews>
+	struct UniformDescriptor {
+		alignas(16) pod::Matrix4f view[N];
+		alignas(16) pod::Matrix4f projection[N];
+	};
+}
+
+void uf::GltfBehavior::render( uf::Object& self ) {
+	/* Update uniforms */ if ( this->hasComponent<uf::Graphic>() ) {
+		auto& scene = uf::scene::getCurrentScene();
+		auto& metadata = this->getComponent<uf::Serializer>();
+		auto& graphic = this->getComponent<uf::Graphic>();
+		auto& controller = scene.getController();
+		auto& camera = controller.getComponent<uf::Camera>();
+		auto& transform = this->getComponent<pod::Transform<>>();
+
+		if ( !graphic.initialized ) return;
+
+		auto* objectWithGraph = this;
+		while ( objectWithGraph != &scene ) {
+			if ( objectWithGraph->hasComponent<pod::Graph>() ) break;
+			objectWithGraph = &objectWithGraph->getParent().as<uf::Object>();
+		}
+		if ( !objectWithGraph->hasComponent<pod::Graph>() ) return;
+		auto& graph = objectWithGraph->getComponent<pod::Graph>();
+
+#if UF_USE_OPENGL
+		auto uniformBuffer = graphic.getUniform();
+		pod::Uniform& uniform = *((pod::Uniform*) graphic.device->getBuffer(uniformBuffer.buffer));
+		uniform.projection = camera.getProjection();
+		if ( !(graph.mode & ext::gltf::LoadMode::SEPARATE) ) {
+			uniform.modelView = camera.getView();
+		} else {
+			uniform.modelView = camera.getView() * uf::transform::model( transform );
+		}
+		graphic.updateUniform( (void*) &uniform, sizeof(uniform) );
+#elif UF_USE_VULKAN
+		if ( !graphic.material.hasShader("fragment") ) return;
+		if ( !graphic.hasStorage("Materials") ) return;
+		
+		// std::cout << "START" << std::endl;
+		auto& shader = graphic.material.getShader("vertex");
+		auto& uniform = shader.getUniform("UBO");
+		if ( !(graph.mode & ext::gltf::LoadMode::SEPARATE) ) {
+		#if UF_UNIFORMS_UPDATE_WITH_JSON
+		//	auto uniforms = shader.getUniformJson("UBO");
+			ext::json::Value uniforms;
+			for ( std::size_t i = 0; i < uf::renderer::settings::maxViews; ++i ) {
+				uniforms["view"][i] = uf::matrix::encode( camera.getView( i ) );
+				uniforms["projection"][i] = uf::matrix::encode( camera.getProjection( i ) );
+			}
+			shader.updateUniform("UBO", uniforms );
+		#else
+			auto& uniforms = uniform.get<UniformDescriptor<>>();
+			for ( std::size_t i = 0; i < uf::renderer::settings::maxViews; ++i ) {
+				uniforms.view[i] = camera.getView( i );
+				uniforms.projection[i] = camera.getProjection( i );
+			}
+			shader.updateUniform( "UBO", uniform );
+		#endif
+		} else {
+		#if UF_UNIFORMS_UPDATE_WITH_JSON
+		//	auto uniforms = shader.getUniformJson("UBO");
+			ext::json::Value uniforms;
+			uniforms["matrices"]["model"] = uf::matrix::encode( uf::transform::model( transform ) );
+			for ( std::size_t i = 0; i < uf::renderer::settings::maxViews; ++i ) {
+				uniforms["matrices"]["view"][i] = uf::matrix::encode( camera.getView( i ) );
+				uniforms["matrices"]["projection"][i] = uf::matrix::encode( camera.getProjection( i ) );
+			}
+			if ( ext::json::isArray(metadata["color"]) ) {
+				uniforms["color"][0] = metadata["color"][0];
+				uniforms["color"][1] = metadata["color"][1];
+				uniforms["color"][2] = metadata["color"][2];
+				uniforms["color"][3] = metadata["color"][3];
+			} else {
+				uniforms["color"][0] = 1.0f;
+				uniforms["color"][1] = 1.0f;
+				uniforms["color"][2] = 1.0f;
+				uniforms["color"][3] = 1.0f;
+			}
+			shader.updateUniform("UBO", uniforms );
+		#else
+			auto& uniforms = uniform.get<uf::MeshDescriptor<>>();
+			uniforms.matrices.model = uf::transform::model( transform );
+			for ( std::size_t i = 0; i < uf::renderer::settings::maxViews; ++i ) {
+				uniforms.matrices.view[i] = camera.getView( i );
+				uniforms.matrices.projection[i] = camera.getProjection( i );
+			}
+			if ( ext::json::isArray(metadata["color"]) ) {
+				uniforms.color[0] = metadata["color"][0].as<float>();
+				uniforms.color[1] = metadata["color"][1].as<float>();
+				uniforms.color[2] = metadata["color"][2].as<float>();
+				uniforms.color[3] = metadata["color"][3].as<float>();
+			} else {
+				uniforms.color = { 1, 1, 1, 1 };
+			}
+			shader.updateUniform( "UBO", uniform );
+		#endif
+		}
+#endif
+	}
+}
+#undef this
\ No newline at end of file
diff --git a/engine/src/engine/object/behaviors/loading.cpp b/engine/src/engine/object/behaviors/loading.cpp
new file mode 100644
index 00000000..13c70f65
--- /dev/null
+++ b/engine/src/engine/object/behaviors/loading.cpp
@@ -0,0 +1,94 @@
+#include <uf/engine/object/behaviors/loading.h>
+
+#include <uf/engine/object/object.h>
+#include <uf/engine/asset/asset.h>
+#include <uf/engine/scene/scene.h>
+#include <uf/utils/time/time.h>
+#include <uf/utils/math/transform.h>
+#include <uf/utils/math/physics.h>
+#include <uf/utils/graphic/graphic.h>
+#include <uf/utils/camera/camera.h>
+#include <uf/utils/thread/thread.h>
+#include <uf/utils/graphic/mesh.h>
+#include <uf/ext/gltf/gltf.h>
+
+UF_BEHAVIOR_REGISTER_CPP(uf::LoadingBehavior)
+#define this (&self)
+void uf::LoadingBehavior::initialize( uf::Object& self ) {
+	auto& metadata = this->getComponent<uf::Serializer>();
+	this->addHook( "system:Load.Finished.%UID%", [&](ext::json::Value& json){
+		metadata["system"]["loaded"] = true;
+		this->removeBehavior<uf::LoadingBehavior>();
+
+		auto& parent = this->getParent();
+		auto& scene = uf::scene::getCurrentScene();
+		if ( parent.getUid() != scene.getUid() ) {
+			scene.moveChild(*this);
+			uf::Serializer payload;
+			payload["uid"] = parent.getUid();
+			parent.getParent().removeChild(parent);
+			
+			std::function<void(uf::Entity*)> filter = [&]( uf::Entity* entity ) {
+				if ( !entity || !entity->isValid() || !entity->hasComponent<pod::Transform<>>() ) return;
+				auto& transform = entity->getComponent<pod::Transform<>>();
+				transform.scale = { 0, 0, 0 };
+				entity->render();
+			};
+			parent.process(filter);
+			
+			scene.queueHook("system:Destroy", payload);
+		}
+		return;
+	});
+}
+void uf::LoadingBehavior::destroy( uf::Object& self ) {
+
+}
+void uf::LoadingBehavior::tick( uf::Object& self ) {
+	auto& metadata = this->getComponent<uf::Serializer>();
+	if ( metadata["system"]["loaded"].as<bool>() ) return;
+	size_t loading = 0;
+	size_t loaded = 1;
+	std::function<void(uf::Entity*)> filter = [&]( uf::Entity* entity ) {
+		if ( !entity || !entity->isValid() || !entity->hasComponent<uf::Serializer>() ) return;
+		auto& metadata = entity->getComponent<uf::Serializer>();
+		if ( metadata["system"]["load"]["ignore"].is<bool>() ) return;
+		if ( ext::json::isNull( metadata["system"]["load"] ) ) return;
+		++loading;
+		if ( metadata["system"]["load"]["progress"].as<int>() < metadata["system"]["load"]["total"].as<int>() ) return;
+		++loaded;
+	};
+	this->process(filter);
+	if ( loading == loaded ) {
+		metadata["system"]["loaded"] = true;
+		this->callHook("system:Load.Finished.%UID%");
+	}
+/*
+	auto& metadata = this->getComponent<uf::Serializer>();
+	if ( !metadata["system"]["loaded"].as<bool>() ) {
+		size_t loading = 0;
+		size_t loaded = 0;
+		std::function<void(uf::Entity*)> filter = [&]( uf::Entity* entity ) {
+			if ( !entity || !entity->isValid() || !entity->hasComponent<uf::Serializer>() ) return;
+			auto& metadata = entity->getComponent<uf::Serializer>();
+			if ( ext::json::isNull( metadata["system"]["load"] ) ) return;
+			++loading;
+			if ( metadata["system"]["load"]["progress"].as<float>() < 1.0f ) return;
+			++loaded;
+		};
+		this->process(filter);
+
+		if ( loading == loaded ) {
+			this->callHook("system:Load.Finished.%UID%");
+		}
+		auto& metadata = this->getComponent<uf::Serializer>();
+		if ( metadata["system"]["load"]["progress"].as<float>() >= 1.0f ) {
+			this->callHook("system:Load.Finished.%UID%");
+		}
+	}
+*/
+}
+void uf::LoadingBehavior::render( uf::Object& self ) {
+
+}
+#undef this
\ No newline at end of file
diff --git a/engine/src/engine/object/behaviors/lua.cpp b/engine/src/engine/object/behaviors/lua.cpp
new file mode 100644
index 00000000..c221d216
--- /dev/null
+++ b/engine/src/engine/object/behaviors/lua.cpp
@@ -0,0 +1,48 @@
+#include <uf/engine/object/behaviors/lua.h>
+
+#include <uf/engine/object/object.h>
+#include <uf/engine/asset/asset.h>
+#include <uf/engine/scene/scene.h>
+#include <uf/utils/time/time.h>
+#include <uf/utils/math/transform.h>
+#include <uf/utils/math/physics.h>
+#include <uf/utils/graphic/graphic.h>
+#include <uf/utils/camera/camera.h>
+#include <uf/utils/graphic/mesh.h>
+#include <uf/engine/asset/asset.h>
+#include <uf/ext/lua/lua.h>
+
+UF_BEHAVIOR_REGISTER_CPP(uf::LuaBehavior)
+#define this (&self)
+void uf::LuaBehavior::initialize( uf::Object& self ) {	
+#if UF_USE_LUA
+	this->addHook( "asset:Load.%UID%", [&](ext::json::Value& json){
+		std::string filename = json["filename"].as<std::string>();
+		std::string category = json["category"].as<std::string>();
+		if ( category != "" && category != "scripts" ) return;
+		if ( category == "" && uf::io::extension(filename) != "lua" ) return;
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Asset& assetLoader = scene.getComponent<uf::Asset>();
+		const pod::LuaScript* assetPointer = NULL;
+		if ( !assetLoader.has<pod::LuaScript>(filename) ) return;
+		assetPointer = &assetLoader.get<pod::LuaScript>(filename);
+		if ( !assetPointer ) return;
+		pod::LuaScript script = *assetPointer;
+	//	script.header = "local ent = entities.get("+ std::to_string((uint) this->getUid()) +")";
+		script.env["ent"] = &this->as<uf::Object>();
+		ext::lua::run( script );
+
+		return;
+	});
+#endif
+}
+void uf::LuaBehavior::destroy( uf::Object& self ) {
+
+}
+void uf::LuaBehavior::tick( uf::Object& self ) {
+
+}
+void uf::LuaBehavior::render( uf::Object& self ) {
+
+}
+#undef this
\ No newline at end of file
diff --git a/engine/src/engine/object/behaviors/render.cpp b/engine/src/engine/object/behaviors/render.cpp
new file mode 100644
index 00000000..629003a9
--- /dev/null
+++ b/engine/src/engine/object/behaviors/render.cpp
@@ -0,0 +1,83 @@
+#include <uf/engine/object/behaviors/render.h>
+
+#include <uf/engine/object/object.h>
+#include <uf/engine/asset/asset.h>
+#include <uf/engine/scene/scene.h>
+#include <uf/utils/time/time.h>
+#include <uf/utils/math/transform.h>
+#include <uf/utils/math/physics.h>
+#include <uf/utils/graphic/graphic.h>
+#include <uf/utils/camera/camera.h>
+#include <uf/utils/graphic/mesh.h>
+#include <uf/ext/gltf/gltf.h>
+
+#define UF_UNIFORMS_UPDATE_WITH_JSON 0
+
+UF_BEHAVIOR_REGISTER_CPP(uf::RenderBehavior)
+#define this (&self)
+void uf::RenderBehavior::initialize( uf::Object& self ) {}
+void uf::RenderBehavior::destroy( uf::Object& self ) {}
+void uf::RenderBehavior::tick( uf::Object& self ) {}
+void uf::RenderBehavior::render( uf::Object& self ) {
+	if ( !this->hasComponent<uf::Graphic>() ) return;
+	auto& metadata = this->getComponent<uf::Serializer>();
+	auto& scene = uf::scene::getCurrentScene();
+	auto& graphic = this->getComponent<uf::Graphic>();
+	auto& transform = this->getComponent<pod::Transform<>>();
+	auto& controller = scene.getController();
+	auto& camera = controller.getComponent<uf::Camera>();
+	
+	if ( !graphic.initialized ) return;
+#if UF_USE_OPENGL
+	auto uniformBuffer = graphic.getUniform();
+	pod::Uniform& uniform = *((pod::Uniform*) uf::renderer::device.getBuffer(uniformBuffer.buffer));
+	uniform.projection = camera.getProjection();
+	uniform.modelView = camera.getView(); // * uf::transform::model( transform );
+	graphic.updateUniform( &uniform, sizeof(uniform) );
+#elif UF_USE_VULKAN
+	if ( !graphic.material.hasShader("vertex") ) return;
+
+	auto& shader = graphic.material.getShader("vertex");
+	auto& uniform = shader.getUniform("UBO");
+
+	if ( !ext::json::isNull(metadata["system"]["loaded"]) && !metadata["system"]["loaded"].as<bool>() ) return;
+#if UF_UNIFORMS_UPDATE_WITH_JSON
+//	auto uniforms = shader.getUniformJson("UBO");
+	ext::json::Value uniforms;
+	uniforms["matrices"]["model"] = uf::matrix::encode( uf::transform::model( transform ) );
+	for ( std::size_t i = 0; i < uf::renderer::settings::maxViews; ++i ) {
+		uniforms["matrices"]["view"][i] = uf::matrix::encode( camera.getView( i ) );
+		uniforms["matrices"]["projection"][i] = uf::matrix::encode( camera.getProjection( i ) );
+	}
+	if ( ext::json::isArray(metadata["color"]) ) {
+		uniforms["color"][0] = metadata["color"][0];
+		uniforms["color"][1] = metadata["color"][1];
+		uniforms["color"][2] = metadata["color"][2];
+		uniforms["color"][3] = metadata["color"][3];
+	} else {
+		uniforms["color"][0] = 1.0f;
+		uniforms["color"][1] = 1.0f;
+		uniforms["color"][2] = 1.0f;
+		uniforms["color"][3] = 1.0f;
+	}
+	shader.updateUniform("UBO", uniforms );
+#else
+	auto& uniforms = uniform.get<uf::MeshDescriptor<>>();
+	uniforms.matrices.model = uf::transform::model( transform );
+	for ( std::size_t i = 0; i < uf::renderer::settings::maxViews; ++i ) {
+		uniforms.matrices.view[i] = camera.getView( i );
+		uniforms.matrices.projection[i] = camera.getProjection( i );
+	}
+	if ( ext::json::isArray(metadata["color"]) ) {
+		uniforms.color[0] = metadata["color"][0].as<float>();
+		uniforms.color[1] = metadata["color"][1].as<float>();
+		uniforms.color[2] = metadata["color"][2].as<float>();
+		uniforms.color[3] = metadata["color"][3].as<float>();
+	} else {
+		uniforms.color = { 1, 1, 1, 1 };
+	}
+	shader.updateUniform( "UBO", uniform );
+#endif
+#endif
+}
+#undef this
\ No newline at end of file
diff --git a/engine/src/engine/object/object.cpp b/engine/src/engine/object/object.cpp
new file mode 100644
index 00000000..ea04f805
--- /dev/null
+++ b/engine/src/engine/object/object.cpp
@@ -0,0 +1,455 @@
+#include <uf/engine/object/object.h>
+#include <uf/engine/asset/asset.h>
+#include <uf/engine/scene/scene.h>
+#include <uf/utils/time/time.h>
+#include <uf/utils/math/transform.h>
+#include <uf/utils/math/physics.h>
+#include <uf/utils/graphic/graphic.h>
+#include <uf/utils/camera/camera.h>
+#include <uf/utils/graphic/mesh.h>
+#include <uf/ext/gltf/gltf.h>
+
+uf::Timer<long long> uf::Object::timer(false);
+namespace {
+	uf::Object null;
+}
+
+UF_OBJECT_REGISTER_BEGIN(uf::Object)
+	UF_OBJECT_REGISTER_BEHAVIOR(uf::EntityBehavior)
+	UF_OBJECT_REGISTER_BEHAVIOR(uf::ObjectBehavior)
+UF_OBJECT_REGISTER_END()
+uf::Object::Object() UF_BEHAVIOR_ENTITY_CPP_ATTACH(uf::Object)
+/*
+void uf::Object::queueHook( const std::string& name, const std::string& payload, double timeout ) {
+	if ( !uf::Object::timer.running() ) uf::Object::timer.start();
+	float start = uf::Object::timer.elapsed().asDouble();
+	uf::Serializer queue;
+	queue["name"] = name;
+	queue["payload"] = uf::Serializer{payload};
+	queue["timeout"] = start + timeout;
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	metadata["system"]["hooks"]["queue"].emplace_back(queue);
+}
+*/
+void uf::Object::queueHook( const std::string& name, const ext::json::Value& payload, double timeout ) {
+	if ( !uf::Object::timer.running() ) uf::Object::timer.start();
+	float start = uf::Object::timer.elapsed().asDouble();
+	uf::Serializer queue;
+	queue["name"] = name;
+	queue["payload"] = payload;
+	queue["timeout"] = start + timeout;
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	metadata["system"]["hooks"]["queue"].emplace_back(queue);
+}
+std::string uf::Object::formatHookName( const std::string& n, size_t uid, bool fetch ) {
+	if ( fetch ) {
+		uf::Object* object = (uf::Object*) uf::Entity::globalFindByUid( uid );
+		if ( object ) return object->formatHookName( n );
+	}
+	std::unordered_map<std::string, std::string> formats = {
+		{"%UID%", std::to_string(uid)},
+	};
+	std::string name = n;
+	for ( auto& pair : formats ) {
+		name = uf::string::replace( name, pair.first, pair.second );
+	}
+	return name;
+}
+std::string uf::Object::formatHookName( const std::string& n ) {
+	size_t uid = this->getUid();
+	size_t parent = uid;
+	if ( this->hasParent() ) {
+		parent = this->getParent().getUid();
+	}
+	std::unordered_map<std::string, std::string> formats = {
+		{"%UID%", std::to_string(uid)},
+		{"%P-UID%", std::to_string(parent)},
+	};
+	std::string name = n;
+	for ( auto& pair : formats ) {
+		name = uf::string::replace( name, pair.first, pair.second );
+	}
+	return name;
+}
+
+uf::Hooks::return_t uf::Object::callHook( const std::string& name ) {
+	return uf::hooks.call( this->formatHookName( name ), ext::json::null() );
+}
+uf::Hooks::return_t uf::Object::callHook( const std::string& name, const ext::json::Value& json ) {
+	return uf::hooks.call( this->formatHookName( name ), json );
+}
+uf::Hooks::return_t uf::Object::callHook( const std::string& name, const uf::Serializer& serializer ) {
+	return uf::hooks.call( this->formatHookName( name ), (const ext::json::Value&) serializer );
+}
+/*
+std::vector<ext::json::Value> uf::Object::callHook( const std::string& name, const ext::json::Value& payload ) {
+	std::vector<ext::json::Value> jsons;
+	auto results = uf::hooks.call( this->formatHookName( name ), payload );
+	for ( auto& result : results ) {
+		if ( result.is<std::string>() ) jsons.emplace_back( uf::Serializer(result.as<std::string>()) );
+		else if ( result.is<ext::json::Value>() ) jsons.emplace_back( result.as<ext::json::Value>() );
+		else if ( result.is<uf::Serializer>() ) jsons.emplace_back( result.as<uf::Serializer>() );
+	}
+	return jsons;
+}
+*/
+/*
+std::vector<std::string> uf::Object::callHook( const std::string& name, const std::string& payload ) {
+	std::vector<std::string> strings;
+	auto results = uf::hooks.call( this->formatHookName( name ), payload );
+	for ( auto& result : results ) {
+		if ( result.is<std::string>() ) {
+			strings.emplace_back( result.as<std::string>() );
+		}
+	}
+	return strings;
+}
+*/
+/*
+std::size_t uf::Object::addHook( const std::string& name, const uf::HookHandler::Readable::function_t& callback ) {
+	std::string parsed = this->formatHookName( name );
+	std::size_t id = uf::hooks.addHook( parsed, callback );
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	metadata["system"]["hooks"]["alloc"][parsed].emplace_back(id);
+	return id;
+}
+*/
+bool uf::Object::load( const std::string& f, bool inheritRoot ) {
+	uf::Serializer json;
+	std::string root = "";
+	if ( inheritRoot && this->hasParent() ) {
+		auto& parent = this->getParent<uf::Object>();
+		uf::Serializer& metadata = parent.getComponent<uf::Serializer>();
+		root = metadata["system"]["root"].as<std::string>();
+	}
+	std::string filename = grabURI( f, root );
+//	std::cout << "Reading: " << filename << std::endl;
+	if ( !json.readFromFile( filename ) ) return false;
+
+	json["root"] = uf::io::directory(filename);
+	json["source"] = filename;
+	json["hot reload"]["mtime"] = uf::io::mtime(filename) + 10;
+	return this->load(json);
+}
+
+bool uf::Object::reload( bool hard ) {
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	if ( !metadata["system"]["source"].is<std::string>() ) return false;
+	uf::Serializer json;
+	uf::Serializer payload;
+	std::string filename = metadata["system"]["source"].as<std::string>();
+	if ( !json.readFromFile( filename ) ) return false;
+	if ( hard ) return this->load(filename);
+
+	payload["old"] = metadata;
+	ext::json::forEach( json["metadata"], [&]( const std::string& key, const ext::json::Value& value ){
+		metadata[key] = value;
+	});
+	// update transform if requested
+	if ( ext::json::isObject(json["transform"]) ) {
+		auto& transform = this->getComponent<pod::Transform<>>();
+		auto* reference = transform.reference;
+		transform = uf::transform::decode( json["transform"], transform );
+		transform.reference = reference;
+	}
+/*
+	for ( auto it = json["metadata"].begin(); it != json["metadata"].end(); ++it ) {
+		metadata[it.key()] = json["metadata"][it.key()];
+	}
+*/
+	payload["new"] = metadata;
+	uf::iostream << "Updated metadata for " << uf::string::toString( this ) << "\n";
+
+	this->queueHook("object:Reload.%UID%", payload);
+	return true;
+}
+
+bool uf::Object::load( const uf::Serializer& _json ) {
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	uf::Serializer json = _json;
+	// import
+	if ( json["import"].is<std::string>() || json["include"].is<std::string>() ) {
+		uf::Serializer chain = json;
+		std::string root = json["root"].as<std::string>();
+		uf::Serializer separated;
+		separated["assets"] = json["assets"];
+		separated["behaviors"] = json["behaviors"];
+		do {
+			std::string filename = chain["import"].is<std::string>() ? chain["import"].as<std::string>() : chain["include"].as<std::string>();
+			filename = grabURI( filename, root );
+		//	std::cout << "Importing: " << filename << std::endl;
+			chain.readFromFile( filename );
+			// set new root
+			root = uf::io::directory( filename );
+			// get real path for assets to merge separately
+			ext::json::forEach(chain["assets"], [&](ext::json::Value& value){
+				if ( ext::json::isObject( value ) ) value["filename"] = grabURI( value["filename"].as<std::string>(), root );
+				else value = grabURI( value.as<std::string>(), root );
+				separated["assets"].emplace_back( value );
+			});
+			ext::json::forEach(chain["behaviors"], [&](ext::json::Value& value){
+				separated["behaviors"].emplace_back(value);
+			});
+			chain["assets"] = ext::json::null();
+			chain["behaviors"] = ext::json::null();
+			// merge table
+			json.import( chain );
+		} while ( chain["import"].is<std::string>() || chain["include"].is<std::string>() );
+		json["import"] = ext::json::null();
+		json["assets"] = separated["assets"];
+		json["behaviors"] = separated["behaviors"];
+	}
+	// copy system table to base
+	ext::json::forEach( json["system"], [&](const std::string& key, const ext::json::Value& value){
+		if ( ext::json::isNull( json[key] ) )
+			json[key] = value;
+	});
+	json["hot reload"]["enabled"] = json["system"]["hot reload"]["enabled"];
+	// Basic entity information
+	// Set name
+	this->m_name = json["name"].is<std::string>() ? json["name"].as<std::string>() : json["type"].as<std::string>();
+	uf::Scene& scene = uf::scene::getCurrentScene();
+	uf::Asset& assetLoader = scene.getComponent<uf::Asset>();
+	// Set transform
+	{
+		bool load = true;
+		if ( this->hasComponent<pod::Transform<>>() ) {
+			pod::Transform<>& transform = this->getComponent<pod::Transform<>>();
+			load = transform.position.x == 0 && transform.position.y == 0 && transform.position.z == 0;
+		}
+		if ( load && ext::json::isObject( json["transform"] ) ) {
+			pod::Transform<>& transform = this->getComponent<pod::Transform<>>();
+			transform = uf::transform::decode(json["transform"], transform);
+			if ( json["transform"]["reference"].as<std::string>() == "parent" ) {
+				auto& parent = this->getParent().as<uf::Object>();
+				transform.reference = &parent.getComponent<pod::Transform<>>();
+			}
+		}
+	}
+	// Set movement
+	{
+		if ( ext::json::isObject( json["physics"] ) && !this->hasComponent<pod::Physics>() ) {
+			auto& physics = this->getComponent<pod::Physics>();
+			if ( ext::json::isArray( json["physics"]["linear"]["velocity"] ) )
+				for ( uint j = 0; j < 3; ++j )
+					physics.linear.velocity[j] = json["physics"]["linear"]["velocity"][j].as<float>();
+			if ( ext::json::isArray( json["physics"]["linear"]["acceleration"] ) )
+				for ( uint j = 0; j < 3; ++j )
+					physics.linear.acceleration[j] = json["physics"]["linear"]["acceleration"][j].as<float>();
+			
+			if ( ext::json::isArray( json["physics"]["rotational"]["velocity"] ) )
+				for ( uint j = 0; j < 4; ++j )
+					physics.rotational.velocity[j] = json["physics"]["rotational"]["velocity"][j].as<float>();
+			if ( ext::json::isArray( json["physics"]["rotational"]["acceleration"] ) )
+				for ( uint j = 0; j < 4; ++j )
+					physics.rotational.acceleration[j] = json["physics"]["rotational"]["acceleration"][j].as<float>();
+		}
+	}
+	#define UF_OBJECT_LOAD_ASSET_HEADER(type)\
+		std::string assetCategory = #type;\
+		uf::Serializer target;\
+		if ( ext::json::isObject( metadata["system"]["assets"] ) ) {\
+			target = metadata["system"]["assets"];\
+		} else if ( ext::json::isArray( json["assets"] ) ) {\
+			target = json["assets"];\
+		} else if ( ext::json::isObject( json["assets"] ) && !ext::json::isNull( json["assets"][#type] )  ) {\
+			target = json["assets"][#type];\
+		}
+
+	#define UF_OBJECT_LOAD_ASSET(...)\
+		std::string canonical = "";\
+		std::string hash = ext::json::isObject( target[i] ) ? target[i]["hash"].as<std::string>() : "";\
+		std::string f = ext::json::isObject( target[i] ) ? target[i]["filename"].as<std::string>() : target[i].as<std::string>();\
+		float delay = ext::json::isObject( target[i] ) ? target[i]["delay"].as<float>() : 0;\
+		std::string category = ext::json::isObject( target[i] ) ? target[i]["category"].as<std::string>() : "";\
+		std::string filename = grabURI( f, json["root"].as<std::string>() );\
+		bool singleThreaded = ext::json::isObject( target[i] ) ? target[i]["single threaded"].as<bool>() : false;\
+		std::vector<std::string> allowedExtensions = {__VA_ARGS__};\
+		std::string extension = uf::io::extension(filename);\
+		if ( category != "" && category != assetCategory ) continue;\
+		if ( category == "" && std::find( allowedExtensions.begin(), allowedExtensions.end(), extension ) == allowedExtensions.end() ) continue;\
+		uf::Serializer payload;\
+		payload["filename"] = filename;\
+		if ( hash != "" ) payload["hash"] = hash;\
+		payload["category"] = assetCategory;\
+		payload["single threaded"] = singleThreaded;\
+		this->queueHook( "asset:QueueLoad.%UID%", payload, delay );\
+
+	// Audio
+	{
+		UF_OBJECT_LOAD_ASSET_HEADER(audio)
+		for ( uint i = 0; i < target.size(); ++i ) {
+			UF_OBJECT_LOAD_ASSET("ogg")
+		}
+	}
+
+	// Images
+	{
+		UF_OBJECT_LOAD_ASSET_HEADER(images)
+		for ( uint i = 0; i < target.size(); ++i ) {
+			UF_OBJECT_LOAD_ASSET("png", "jpg", "jpeg")
+		}
+	}
+
+	// GLTf models
+	{
+		UF_OBJECT_LOAD_ASSET_HEADER(models)
+		for ( uint i = 0; i < target.size(); ++i ) {
+			UF_OBJECT_LOAD_ASSET("gltf", "glb", "graph")
+			uf::instantiator::bind("GltfBehavior", *this);
+			
+			auto& aMetadata = assetLoader.getComponent<uf::Serializer>();
+			aMetadata[filename] = json["metadata"]["model"];
+			aMetadata[filename]["root"] = json["root"];
+		}
+	}
+	// Lua scripts
+	{
+		UF_OBJECT_LOAD_ASSET_HEADER(scripts)
+		for ( uint i = 0; i < target.size(); ++i ) {
+			UF_OBJECT_LOAD_ASSET("lua")
+			uf::instantiator::bind("LuaBehavior", *this);
+		}
+	}
+	// Bind behaviors
+	{
+		if ( json["type"].is<std::string>() ) uf::instantiator::bind( json["type"].as<std::string>(), *this );
+
+		uf::Serializer target;
+		if ( ext::json::isArray( metadata["system"]["behaviors"] ) ) {
+			target = metadata["system"]["behaviors"];
+		} else if ( ext::json::isArray( json["behaviors"] ) ) {
+			target = json["behaviors"];
+		}
+		for ( uint i = 0; i < target.size(); ++i ) {
+			uf::instantiator::bind( target[i].as<std::string>(), *this );
+		}
+	}
+	uf::Serializer hooks = metadata["system"]["hooks"];
+	// Metadata
+	if ( !ext::json::isNull( json["metadata"] ) ) {
+		uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+		if ( json["metadata"].is<std::string>() ) {
+			std::string f = json["metadata"].as<std::string>();
+			std::string filename = grabURI( json["metadata"].as<std::string>(), json["root"].as<std::string>() );
+			if ( !metadata.readFromFile(filename) ) return false;
+		} else {
+			metadata = json["metadata"];
+		}
+	}
+	metadata["system"] = json;
+	metadata["system"].erase("metadata");
+	metadata["system"]["hooks"] = hooks;
+
+	// check for children
+	{
+		UF_OBJECT_LOAD_ASSET_HEADER(entities)
+		for ( uint i = 0; i < target.size(); ++i ) {
+			std::string canonical = "";
+			std::string hash = ext::json::isObject( target[i] ) ? target[i]["hash"].as<std::string>() : "";
+			std::string f = ext::json::isObject( target[i] ) ? target[i]["filename"].as<std::string>() : target[i].as<std::string>();
+			float delay = ext::json::isObject( target[i] ) ? target[i]["delay"].as<float>() : -1;
+			std::string category = ext::json::isObject( target[i] ) ? target[i]["category"].as<std::string>() : "";\
+			std::string filename = grabURI( f, json["root"].as<std::string>() );
+			if ( category != "" && category != assetCategory ) continue;
+			if ( category == "" && uf::io::extension(filename) != "json" ) continue;
+			if ( (canonical = assetLoader.load( filename, hash )) == "" ) continue;
+			if ( delay > -1 ) {
+				uf::Serializer payload;
+				payload["filename"] = canonical;
+				if ( hash != "" ) payload["hash"] = hash;
+				payload["category"] = assetCategory;
+				this->queueHook( "asset:Load.%UID%", payload, delay );
+				continue;
+			}
+			{
+				uf::Serializer json;
+				if ( !json.readFromFile(filename, hash) ) continue;
+
+				json["root"] = uf::io::directory(filename);
+				json["source"] = filename;
+				json["hot reload"]["mtime"] = uf::io::mtime( filename ) + 10;
+
+				if ( this->loadChildUid(json) == -1 ) continue;
+			}
+		}
+	}
+	// Add lights
+	if ( ext::json::isArray( metadata["system"]["lights"] ) ) {
+		uf::Serializer target = metadata["system"]["lights"];
+		auto& pTransform = this->getComponent<pod::Transform<>>();
+		for ( size_t i = 0; i < target.size(); ++i ) {
+			uf::Serializer json = target[i];			
+
+			auto* light = this->loadChildPointer("/light.json", false);
+			if ( !light ) continue;
+			auto& lightTransform = light->getComponent<pod::Transform<>>();
+			auto& lightMetadata = light->getComponent<uf::Serializer>();
+			lightTransform = uf::transform::decode( json["transform"], lightTransform );
+			ext::json::forEach( json, [&]( const std::string& key, ext::json::Value& value ){
+				if ( key == "transform" ) return;
+				lightMetadata["light"][key] = value;
+			});
+			light->initialize();
+		}
+	}
+
+	return true;
+}
+uf::Object& uf::Object::loadChild( const std::string& f, bool initialize ) {
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	uf::Serializer json;
+	std::string filename = grabURI( f, metadata["system"]["root"].as<std::string>() );
+	if ( !json.readFromFile(filename) ) {
+		return ::null;
+	}
+
+	json["root"] = uf::io::directory(filename);
+	json["source"] = filename;
+	json["hot reload"]["mtime"] = uf::io::mtime( filename ) + 10;
+	return this->loadChild(json, initialize);
+}
+uf::Object& uf::Object::loadChild( const uf::Serializer& _json, bool initialize ) {
+	uf::Serializer json = _json;
+	std::string type = json["type"].as<std::string>();
+	if ( type == "" ) type = "Object";
+	if ( json["ignore"].as<bool>() ) return ::null;
+
+	uf::Entity& entity = uf::instantiator::instantiate(type);
+	uf::Object& object = entity.as<uf::Object>();
+	this->addChild(entity);
+	if ( !object.load(json) ) {
+		this->removeChild(entity);
+		return ::null;
+	}
+	if ( initialize ) entity.initialize();
+	return object;
+}
+uf::Object* uf::Object::loadChildPointer( const std::string& f, bool initialize ) {
+	uf::Object* pointer = &this->loadChild(f, initialize);
+	return pointer != &::null ? pointer : NULL;
+}
+uf::Object* uf::Object::loadChildPointer( const uf::Serializer& json, bool initialize ) {
+	uf::Object* pointer = &this->loadChild(json, initialize);
+	return pointer != &::null ? pointer : NULL;
+}
+std::size_t uf::Object::loadChildUid( const std::string& f, bool initialize ) {
+	uf::Object* pointer = this->loadChildPointer(f, initialize);
+	return pointer ? pointer->getUid() : -1;
+}
+std::size_t uf::Object::loadChildUid( const uf::Serializer& json, bool initialize ) {
+	uf::Object* pointer = this->loadChildPointer(json, initialize);
+	return pointer ? pointer->getUid() : -1;
+}
+
+std::string uf::Object::grabURI( const std::string& filename, const std::string& root  ) {
+	return uf::io::resolveURI( filename, root );
+}
+
+
+#include <uf/utils/string/ext.h>
+std::string uf::string::toString( const uf::Object& object ) {
+	std::stringstream ss;
+	ss << object.getName() << ": " << object.getUid();
+	return ss.str();
+}
\ No newline at end of file
diff --git a/engine/src/engine/scene/behavior.cpp b/engine/src/engine/scene/behavior.cpp
new file mode 100644
index 00000000..5247d3c3
--- /dev/null
+++ b/engine/src/engine/scene/behavior.cpp
@@ -0,0 +1,34 @@
+#include <uf/engine/scene/scene.h>
+#include <uf/utils/string/ext.h>
+#include <uf/utils/camera/camera.h>
+#include <uf/utils/renderer/renderer.h>
+
+UF_BEHAVIOR_ENTITY_CPP_BEGIN(uf::Scene)
+#define this ((uf::Scene*) &self)
+void uf::SceneBehavior::initialize( uf::Object& self ) {
+//	uf::renderer::scenes.push_back(this);
+	uf::renderer::states::rebuild = true;
+
+	this->addHook( "system:Renderer.QueueRebuild", [&](ext::json::Value& json){
+		uf::renderer::states::rebuild = true;
+	});
+	this->addHook( "system:Destroy", [&](ext::json::Value& json){
+		size_t uid = json["uid"].as<size_t>();
+		if ( uid <= 0 ) return;
+		auto* target = this->findByUid(uid);
+		if ( !target ) return;
+		target->destroy();
+		delete target;
+
+		this->queueHook("system:Renderer.QueueRebuild");
+	});
+}
+void uf::SceneBehavior::tick( uf::Object& self ) {
+}
+void uf::SceneBehavior::render( uf::Object& self ) {
+}
+void uf::SceneBehavior::destroy( uf::Object& self ) {
+	uf::renderer::states::rebuild = true;
+}
+#undef self
+UF_BEHAVIOR_ENTITY_CPP_END(Scene)
\ No newline at end of file
diff --git a/engine/src/engine/scene/scene.cpp b/engine/src/engine/scene/scene.cpp
new file mode 100644
index 00000000..762b3182
--- /dev/null
+++ b/engine/src/engine/scene/scene.cpp
@@ -0,0 +1,103 @@
+#include <uf/engine/scene/scene.h>
+#include <uf/utils/string/ext.h>
+#include <uf/utils/camera/camera.h>
+#include <uf/utils/renderer/renderer.h>
+#include <regex>
+
+UF_OBJECT_REGISTER_BEGIN(uf::Scene)
+	UF_OBJECT_REGISTER_BEHAVIOR(uf::EntityBehavior)
+	UF_OBJECT_REGISTER_BEHAVIOR(uf::ObjectBehavior)
+	UF_OBJECT_REGISTER_BEHAVIOR(uf::SceneBehavior)
+UF_OBJECT_REGISTER_END()
+uf::Scene::Scene() UF_BEHAVIOR_ENTITY_CPP_ATTACH(uf::Scene)
+uf::Entity& uf::Scene::getController() {
+	static uf::Entity* cachedController = NULL;
+	if ( uf::renderer::currentRenderMode ) {
+		static uf::renderer::RenderMode* cachedRenderMode = NULL;
+		auto& renderMode = *uf::renderer::currentRenderMode;
+
+		if ( cachedRenderMode == &renderMode && cachedController && cachedController->getUid() > 0 ) {
+			return *cachedController;
+		}
+		cachedController = NULL;
+		cachedRenderMode = &renderMode;
+		auto split = uf::string::split( renderMode.getName(), ":" );
+		if ( split.front() == "RT" ) {
+			uint64_t uid = std::stoi( split.back() );
+			uf::Entity* ent = this->findByUid( uid );
+			if ( ent ) return *(cachedController = ent);
+		}
+	}
+	if ( cachedController && cachedController->getUid() > 0 ) return *cachedController;
+	cachedController = this->findByName("Player");
+	return cachedController ? *cachedController : *this;
+	// return this;
+}
+const uf::Entity& uf::Scene::getController() const {
+	uf::Scene& scene = *const_cast<uf::Scene*>(this);
+	return scene.getController();
+}
+std::vector<uf::Scene*> uf::scene::scenes;
+uf::Scene& uf::scene::loadScene( const std::string& name, const std::string& filename ) {
+	uf::Scene* scene = uf::instantiator::objects->has( name ) ? (uf::Scene*) &uf::instantiator::instantiate( name ) : new uf::Scene;
+
+//	uf::scene::scenes.insert(uf::scene::scenes.begin(), scene);
+	uf::scene::scenes.emplace_back( scene );
+	
+	std::string target = name;
+	
+	std::regex regex("^(TestScene_?)?(.+?)(_?Scene)?$");
+	std::smatch match;
+	
+	if ( std::regex_search( target, match, regex ) ) {
+		target = match[2];
+	}
+	target = uf::string::lowercase( target );
+	scene->load(filename != "" ? filename : "./scenes/" + target + "/scene.json");
+	scene->initialize();
+	return *scene;
+}
+uf::Scene& uf::scene::loadScene( const std::string& name, const uf::Serializer& data ) {
+	uf::Scene* scene = uf::instantiator::objects->has( name ) ? (uf::Scene*) &uf::instantiator::instantiate( name ) : new uf::Scene;
+
+//	uf::scene::scenes.insert(uf::scene::scenes.begin(), scene);
+	uf::scene::scenes.emplace_back( scene );
+
+	if ( data != "" ) scene->load(data);
+	scene->initialize();
+	return *scene;
+}
+void uf::scene::unloadScene() {
+	uf::Scene* current = uf::scene::scenes.back();
+	current->destroy();
+	uf::scene::scenes.pop_back();
+	//delete current;
+}
+uf::Scene& uf::scene::getCurrentScene() {
+	return *uf::scene::scenes.back();
+}
+void uf::scene::tick() {
+	// uf::scene::getCurrentScene().tick();
+	for ( auto scene : scenes ) scene->tick();
+}
+void uf::scene::render() {
+	// uf::scene::getCurrentScene().render();
+	for ( auto scene : scenes ) scene->render();
+}
+void uf::scene::destroy() {
+	while ( !scenes.empty() ) {
+		unloadScene();
+	}
+}
+/*
+uf::Camera& uf::Scene::getCamera() {
+	if ( !::camera ) ::camera = this->getPlayer().getComponentPointer<uf::Camera>();
+	return *::camera;
+}
+uf::Player& uf::Scene::getPlayer() {
+	return *((uf::Player*) this->findByName("Player"));
+}
+const uf::Player& uf::Scene::getPlayer() const {
+	return *((const uf::Player*) this->findByName("Player"));
+}
+*/
\ No newline at end of file
diff --git a/engine/src/ext/bullet/bullet.cpp b/engine/src/ext/bullet/bullet.cpp
new file mode 100644
index 00000000..660833f4
--- /dev/null
+++ b/engine/src/ext/bullet/bullet.cpp
@@ -0,0 +1,403 @@
+#include <uf/ext/bullet/bullet.h>
+#if UF_USE_BULLET
+
+#include <uf/utils/math/physics.h>
+#include <uf/utils/renderer/renderer.h>
+#include <uf/utils/graphic/graphic.h>
+#include <uf/engine/scene/scene.h>
+#include <BulletCollision/CollisionShapes/btTriangleShape.h>
+
+class BulletDebugDrawer : public btIDebugDraw {
+protected:
+	int m;
+	uf::BaseMesh<pod::Vertex_3F2F3F4F> mesh;
+public:
+	virtual void drawLine( const btVector3& from, const btVector3& to, const btVector3& color ) {
+		drawLine( from, to, color, color );
+	}
+	virtual void drawLine( const btVector3& from, const btVector3& to, const btVector3& fromColor, const btVector3& toColor ) {
+		auto& A = mesh.vertices.emplace_back();
+		A.position = { from.getX(), from.getY(), from.getZ() };
+		//{0.0f, 0.0f},
+		//{0.0f, 0.0f, 0.0f},
+		A.color = { fromColor.getX(), fromColor.getY(), fromColor.getZ(), 1.0f };
+		auto& B = mesh.vertices.emplace_back();
+		B.position = { to.getX(), to.getY(), to.getZ() };
+		//{0.0f, 0.0f},
+		//{0.0f, 0.0f, 0.0f},
+		B.color = { toColor.getX(), toColor.getY(), toColor.getZ(), 1.0f };
+	}
+	virtual void drawContactPoint(const btVector3&, const btVector3&, btScalar, int, const btVector3&) {
+
+	}
+	virtual void reportErrorWarning(const char* str ) {
+		uf::iostream << "[Bullet] " << str << "\n";
+	}
+	virtual void draw3dText(const btVector3& , const char* str ) {
+
+	}
+	virtual void setDebugMode(int p) {
+		m = p;
+	}
+	virtual void clearLines() {
+		mesh.destroy();
+	}
+	virtual void flushLines() {
+		auto& scene = uf::scene::getCurrentScene();
+		ext::bullet::debugDraw( scene );
+	}
+	int getDebugMode(void) const { return m; }
+
+	uf::BaseMesh<pod::Vertex_3F2F3F4F>& getMesh() { return mesh; }
+	const uf::BaseMesh<pod::Vertex_3F2F3F4F>& getMesh() const { return mesh; }
+};
+
+bool ext::bullet::debugDrawEnabled = false;
+float ext::bullet::debugDrawRate = 1.0f;
+size_t ext::bullet::iterations = 1;
+size_t ext::bullet::substeps = 12;
+float ext::bullet::timescale = 1.0f;
+
+size_t ext::bullet::defaultMaxCollisionAlgorithmPoolSize = 65535;
+size_t ext::bullet::defaultMaxPersistentManifoldPoolSize = 65535;
+
+namespace ext {
+	namespace bullet {
+		btDefaultCollisionConstructionInfo constructionInfo;
+		btDefaultCollisionConfiguration* collisionConfiguration = NULL;
+		btCollisionDispatcher* dispatcher = NULL;
+		btBroadphaseInterface* overlappingPairCache = NULL;
+		btSequentialImpulseConstraintSolver* solver = NULL;
+		btDiscreteDynamicsWorld* dynamicsWorld = NULL;
+		btAlignedObjectArray<btCollisionShape*> collisionShapes;
+
+		std::unordered_map<btRigidBody*, size_t> rigidBodyMap;
+
+		BulletDebugDrawer debugDrawer;
+	}
+}
+
+#if !UF_ENV_DREAMCAST
+static bool contactCallback(btManifoldPoint &ManifoldPoint, const btCollisionObjectWrapper *Object0, int PartID0, int Index0, const btCollisionObjectWrapper *Object1, int PartID1, int Index1) {
+	if( Object1->getCollisionShape()->getShapeType() != TRIANGLE_SHAPE_PROXYTYPE ) return false;
+
+	pod::Vector3f Before = {
+		ManifoldPoint.m_normalWorldOnB.getX(),
+		ManifoldPoint.m_normalWorldOnB.getY(),
+		ManifoldPoint.m_normalWorldOnB.getZ(),
+	};
+	btAdjustInternalEdgeContacts(ManifoldPoint, Object1, Object0, PartID1, Index1);
+	btAdjustInternalEdgeContacts(ManifoldPoint, Object0, Object1, PartID0, Index0);
+
+	pod::Vector3f After = {
+		ManifoldPoint.m_normalWorldOnB.getX(),
+		ManifoldPoint.m_normalWorldOnB.getY(),
+		ManifoldPoint.m_normalWorldOnB.getZ(),
+	};
+
+	return false;
+}
+#endif
+
+
+void ext::bullet::initialize() {
+	ext::bullet::constructionInfo = btDefaultCollisionConstructionInfo();
+	ext::bullet::constructionInfo.m_defaultMaxCollisionAlgorithmPoolSize = ext::bullet::defaultMaxCollisionAlgorithmPoolSize;
+	ext::bullet::constructionInfo.m_defaultMaxPersistentManifoldPoolSize = ext::bullet::defaultMaxPersistentManifoldPoolSize;
+	ext::bullet::collisionConfiguration = new btDefaultCollisionConfiguration(ext::bullet::constructionInfo);
+	ext::bullet::dispatcher = new btCollisionDispatcher(ext::bullet::collisionConfiguration);
+	ext::bullet::overlappingPairCache = new btDbvtBroadphase(); // new btAxis3Sweep();
+	ext::bullet::solver = new btSequentialImpulseConstraintSolver;
+	ext::bullet::dynamicsWorld = new btDiscreteDynamicsWorld(ext::bullet::dispatcher, ext::bullet::overlappingPairCache, ext::bullet::solver, ext::bullet::collisionConfiguration);
+	ext::bullet::dynamicsWorld->setGravity(btVector3(0, -9.81, 0));
+
+	ext::bullet::debugDrawer.setDebugMode(btIDebugDraw::DBG_DrawWireframe);
+    ext::bullet::dynamicsWorld->setDebugDrawer(&ext::bullet::debugDrawer);
+
+#if !UF_ENV_DREAMCAST
+	gContactAddedCallback = contactCallback;
+#endif
+}
+void ext::bullet::tick( float delta ) { if ( delta == 0.0f ) delta = uf::physics::time::delta;
+	ext::bullet::syncToBullet();
+	delta = delta * ext::bullet::timescale / ext::bullet::iterations;
+	for ( size_t i = 0; i < ext::bullet::iterations; ++i ) {
+		ext::bullet::dynamicsWorld->stepSimulation(delta, ext::bullet::substeps, delta / ext::bullet::substeps);
+	}
+	ext::bullet::syncFromBullet();
+	TIMER(ext::bullet::debugDrawRate, ext::bullet::debugDrawEnabled && ) {
+		ext::bullet::dynamicsWorld->debugDrawWorld();
+	}
+}
+void ext::bullet::terminate() {
+	for ( int i = ext::bullet::dynamicsWorld->getNumCollisionObjects() - 1; i >= 0; i--) {
+		btCollisionObject* obj = ext::bullet::dynamicsWorld->getCollisionObjectArray()[i];
+		btRigidBody* body = btRigidBody::upcast(obj);
+		if (body && body->getMotionState()) delete body->getMotionState();
+		ext::bullet::dynamicsWorld->removeCollisionObject(obj);
+		delete obj;
+	}
+	for ( size_t i = 0; i < ext::bullet::collisionShapes.size(); ++i ) {
+		btCollisionShape* shape = ext::bullet::collisionShapes[i];
+		ext::bullet::collisionShapes[i] = NULL;
+		delete shape;
+	}
+
+	if ( ext::bullet::dynamicsWorld ) delete ext::bullet::dynamicsWorld;
+	if ( ext::bullet::solver ) delete ext::bullet::solver;
+	if ( ext::bullet::overlappingPairCache ) delete ext::bullet::overlappingPairCache;
+	if ( ext::bullet::dispatcher ) delete ext::bullet::dispatcher;
+	if ( ext::bullet::collisionConfiguration ) delete ext::bullet::collisionConfiguration;
+	ext::bullet::collisionShapes.clear();
+}
+void ext::bullet::syncToBullet() {
+	auto& scene = uf::scene::getCurrentScene();
+	// update bullet transforms
+	for ( int i = ext::bullet::dynamicsWorld->getNumCollisionObjects() - 1; i >= 0; --i) {
+		btCollisionObject* obj = ext::bullet::dynamicsWorld->getCollisionObjectArray()[i];
+		btRigidBody* body = btRigidBody::upcast(obj);
+		if ( !body || !body->getMotionState() ) return;
+	
+	#if 0
+		if ( rigidBodyMap.count(body) == 0 ) return;
+		size_t uid = rigidBodyMap[body];
+	#else
+		size_t uid = (size_t) body->getUserPointer();
+	#endif
+		if ( !uid ) continue;
+		auto* entity = scene.findByUid( uid );
+		if ( !entity ) continue;
+
+		auto& collider = entity->getComponent<pod::Bullet>();
+		if ( !collider.shared ) continue;
+		{
+			auto& physics = entity->getComponent<pod::Physics>();
+			body->setLinearVelocity( btVector3( physics.linear.velocity.x, physics.linear.velocity.y, physics.linear.velocity.z ) );
+		}
+		{
+			auto& transform = entity->getComponent<pod::Transform<>>();
+			auto modelMatrix = uf::transform::model( transform );
+			
+			btTransform t;
+			t = body->getWorldTransform();
+			t.setFromOpenGLMatrix(&modelMatrix[0]);
+
+		//	t.setOrigin( btVector3( transform.position.x, transform.position.y, transform.position.z ) );
+		//	t.setRotation( btQuaternion( transform.orientation.x, transform.orientation.y, transform.orientation.z, transform.orientation.w ) );
+
+			body->setWorldTransform(t);
+			body->setCenterOfMassTransform(t);
+		}
+	}
+}
+void ext::bullet::syncFromBullet() {
+	auto& scene = uf::scene::getCurrentScene();
+	for ( int i = ext::bullet::dynamicsWorld->getNumCollisionObjects() - 1; i >= 0; --i) {
+		btCollisionObject* obj = ext::bullet::dynamicsWorld->getCollisionObjectArray()[i];
+		btRigidBody* body = btRigidBody::upcast(obj);
+		if ( !body || !body->getMotionState() ) return;
+		btTransform t;
+		body->getMotionState()->getWorldTransform(t);
+	#if 0
+		if ( rigidBodyMap.count(body) == 0 ) return;
+		size_t uid = rigidBodyMap[body];
+	#else
+		size_t uid = (size_t) body->getUserPointer();
+	#endif
+		if ( !uid ) continue;
+		auto* entity = scene.findByUid( uid );
+		if ( !entity ) continue;
+
+		auto& transform = entity->getComponent<pod::Transform<>>();
+		transform.position.x = t.getOrigin().getX();
+		transform.position.y = t.getOrigin().getY();
+		transform.position.z = t.getOrigin().getZ();
+
+		transform.orientation.x = t.getRotation().getX();
+		transform.orientation.y = t.getRotation().getY();
+		transform.orientation.z = t.getRotation().getZ();
+		transform.orientation.w = t.getRotation().getW();
+
+		{
+			auto& physics = entity->getComponent<pod::Physics>();
+			physics.linear.velocity.x = body->getLinearVelocity().getX();
+			physics.linear.velocity.y = body->getLinearVelocity().getY();
+			physics.linear.velocity.z = body->getLinearVelocity().getZ();
+
+			physics.rotational.velocity.x = body->getAngularVelocity().getX();
+			physics.rotational.velocity.y = body->getAngularVelocity().getY();
+			physics.rotational.velocity.z = body->getAngularVelocity().getZ();
+		}
+
+
+		transform = uf::transform::reorient( transform );
+	
+	//	std::cout << entity->getName() << ": " << uid << " (" << i << ") @ " << uf::string::toString(transform.position) << std::endl;
+	}
+}
+pod::Bullet& ext::bullet::create( uf::Object& object ) {
+	auto& collider = object.getComponent<pod::Bullet>();
+
+	collider.uid = object.getUid();
+	collider.transform = &object.getComponent<pod::Transform<>>();
+	collider.shared = false;
+	return collider;
+}
+void ext::bullet::attach( pod::Bullet& collider ) {
+	if ( !collider.shape ) return;
+	
+	btTransform t;
+	t.setIdentity();
+	t.setOrigin(btVector3(collider.transform->position.x, collider.transform->position.y, collider.transform->position.z));
+	t.setRotation(btQuaternion(collider.transform->orientation.x, collider.transform->orientation.y, collider.transform->orientation.z, collider.transform->orientation.w));
+
+	btVector3 inertia(collider.inertia.x, collider.inertia.y, collider.inertia.z);
+	btDefaultMotionState* motion = new btDefaultMotionState(t);
+	if ( collider.mass != 0.0f ) collider.shape->calculateLocalInertia(collider.mass, inertia);
+	btRigidBody::btRigidBodyConstructionInfo info(collider.mass, motion, collider.shape, inertia);
+	
+	collider.body = new btRigidBody(info);
+#if 0
+	rigidBodyMap[collider.body] = collider.uid;
+#else
+	collider.body->setUserPointer((void*) collider.uid);
+#endif
+
+	if ( collider.mass > 0 ) {
+		collider.body->activate(true);
+		collider.body->setActivationState(DISABLE_DEACTIVATION);
+	}
+
+
+	ext::bullet::dynamicsWorld->addRigidBody(collider.body);
+	ext::bullet::collisionShapes.push_back(collider.shape);
+}
+
+void ext::bullet::detach( pod::Bullet& collider ) {
+	if ( !collider.body || !collider.shape ) return;
+	ext::bullet::dynamicsWorld->removeCollisionObject( collider.body );
+}
+
+pod::Bullet& ext::bullet::create( uf::Object& object, const pod::Vector3f& corner, float mass ) {
+	auto& collider = ext::bullet::create( object );
+	collider.mass = mass;
+
+	collider.shape = new btBoxShape(btVector3(corner.x, corner.y, corner.z));
+	ext::bullet::attach( collider );
+
+	collider.body->setContactProcessingThreshold(0.0);
+	collider.body->setAngularFactor(0.0);
+	collider.body->setCcdMotionThreshold(1e-7);
+	collider.body->setCcdSweptSphereRadius(0.25 * 0.2);
+	return collider;
+}
+
+pod::Bullet& ext::bullet::create( uf::Object& object, float radius, float height, float mass ) {
+	auto& collider = ext::bullet::create( object );
+	collider.mass = mass;
+
+	collider.shape = new btCapsuleShape(radius, height); // 1, 1.5
+	ext::bullet::attach( collider );
+
+	collider.body->setContactProcessingThreshold(0.0);
+	collider.body->setAngularFactor(0.0);
+	collider.body->setCcdMotionThreshold(1e-7);
+	collider.body->setCcdSweptSphereRadius(0.25 * 0.2);
+	return collider;
+}
+
+void UF_API ext::bullet::move( pod::Bullet& collider, const pod::Vector3f& v, bool override ) {
+	if ( !collider.body ) return;
+/*	
+	float x = collider.body->getLinearVelocity().getX();
+	float y = collider.body->getLinearVelocity().getY();
+	float z = collider.body->getLinearVelocity().getZ();
+	if ( fabs(x) < 0.001f ) x = v.x;
+	if ( fabs(y) < 0.001f ) y = v.y;
+	if ( fabs(z) < 0.001f ) z = v.z;
+	if ( override ) {
+		x = v.x;
+		y = v.y;
+		z = v.z;
+	}
+	collider.body->setLinearVelocity( btVector3( x, y, z ) );
+*/
+	collider.body->setLinearVelocity( btVector3( v.x, v.y, v.z ) );
+
+//	btTransform transform = collider.body->getWorldTransform();
+//	transform.setOrigin( transform.getOrigin() + btVector3( v.x, v.y, v.z ) * uf::physics::time::delta );
+//	collider.body->setWorldTransform(transform);
+//	collider.body->setCenterOfMassTransform(transform);
+}
+void UF_API ext::bullet::applyImpulse( pod::Bullet& collider, const pod::Vector3f& v ) {
+	if ( !collider.body ) return;
+	collider.body->applyCentralImpulse( btVector3( v.x, v.y, v.z ) /** uf::physics::time::delta*/ );
+}
+void UF_API ext::bullet::applyMovement( pod::Bullet& collider, const pod::Vector3f& v ) {
+	if ( !collider.body ) return;
+	btTransform transform;
+	collider.body->getMotionState()->getWorldTransform(transform);
+
+	transform.setOrigin( transform.getOrigin() + btVector3( v.x, v.y, v.z ) * uf::physics::time::delta );
+
+	collider.body->getMotionState()->setWorldTransform(transform);
+	collider.body->setCenterOfMassTransform(transform);
+}
+void UF_API ext::bullet::applyVelocity( pod::Bullet& collider, const pod::Vector3f& v ) {
+	if ( !collider.body ) return;
+	collider.body->setLinearVelocity( collider.body->getLinearVelocity() + btVector3( v.x, v.y, v.z ) );
+}
+void UF_API ext::bullet::applyRotation( pod::Bullet& collider, const pod::Vector3f& axis, float delta ) {
+	if ( !collider.body ) return;
+	ext::bullet::applyRotation( collider, uf::quaternion::axisAngle( axis, delta ) );
+}
+void UF_API ext::bullet::applyRotation( pod::Bullet& collider, const pod::Quaternion<>& q ) {
+	if ( !collider.body ) return;
+	btTransform transform;
+	collider.body->getMotionState()->getWorldTransform(transform);
+
+	pod::Quaternion<> orientation = uf::vector::normalize(uf::quaternion::multiply({
+		transform.getRotation().getX(),
+		transform.getRotation().getY(),
+		transform.getRotation().getZ(),
+		transform.getRotation().getW(),
+	}, q));
+	transform.setRotation( btQuaternion( orientation.x, orientation.y, orientation.z, orientation.w ) );
+
+	collider.body->getMotionState()->setWorldTransform(transform);
+	collider.body->setCenterOfMassTransform(transform);
+}
+void UF_API ext::bullet::activateCollision( pod::Bullet& collider, bool enabled ) {
+	if ( !collider.body ) return;
+	collider.body->activate(enabled);
+}
+
+void UF_API ext::bullet::debugDraw( uf::Object& object ) {
+	auto& mesh = ext::bullet::debugDrawer.getMesh();
+	if ( mesh.vertices.empty() ) return;
+	bool create = !object.hasComponent<uf::Graphic>();
+	auto& graphic = object.getComponent<uf::Graphic>();
+	graphic.process = false;
+	if ( create ) {
+		graphic.process = true;
+
+		graphic.device = &uf::renderer::device;
+		graphic.material.device = &uf::renderer::device;
+		graphic.descriptor.cullMode = uf::renderer::enums::CullMode::NONE;
+
+		graphic.material.attachShader(uf::io::root + "/shaders/base/colored.vert.spv", uf::renderer::enums::Shader::VERTEX);
+		graphic.material.attachShader(uf::io::root + "/shaders/base/frag.spv", uf::renderer::enums::Shader::FRAGMENT);
+
+		graphic.initialize();
+		graphic.initializeMesh( mesh, 0 );
+		graphic.descriptor.topology = uf::renderer::enums::PrimitiveTopology::LINE_LIST;
+		graphic.descriptor.fill = uf::renderer::enums::PolygonMode::LINE;
+		graphic.descriptor.lineWidth = 8.0f;
+	} else {
+		graphic.process = true;
+
+		graphic.initializeMesh( mesh, 0 );
+		graphic.getPipeline().update( graphic );
+	}
+}
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/discord/achievement_manager.cpp b/engine/src/ext/discord/achievement_manager.cpp
new file mode 100644
index 00000000..7eeb374a
--- /dev/null
+++ b/engine/src/ext/discord/achievement_manager.cpp
@@ -0,0 +1,100 @@
+#if defined(UF_USE_DISCORD)
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <discord/achievement_manager.h>
+
+#include <discord/core.h>
+
+#include <cstring>
+#include <memory>
+
+namespace discord {
+
+class AchievementEvents final {
+public:
+    static void OnUserAchievementUpdate(void* callbackData, DiscordUserAchievement* userAchievement)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->AchievementManager();
+        module.OnUserAchievementUpdate(*reinterpret_cast<UserAchievement const*>(userAchievement));
+    }
+};
+
+IDiscordAchievementEvents AchievementManager::events_{
+  &AchievementEvents::OnUserAchievementUpdate,
+};
+
+void AchievementManager::SetUserAchievement(Snowflake achievementId,
+                                            std::int64_t percentComplete,
+                                            std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->set_user_achievement(
+      internal_, achievementId, percentComplete, cb.release(), wrapper);
+}
+
+void AchievementManager::FetchUserAchievements(std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->fetch_user_achievements(internal_, cb.release(), wrapper);
+}
+
+void AchievementManager::CountUserAchievements(std::int32_t* count)
+{
+    if (!count) {
+        return;
+    }
+
+    internal_->count_user_achievements(internal_, reinterpret_cast<int32_t*>(count));
+}
+
+Result AchievementManager::GetUserAchievement(Snowflake userAchievementId,
+                                              UserAchievement* userAchievement)
+{
+    if (!userAchievement) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->get_user_achievement(
+      internal_, userAchievementId, reinterpret_cast<DiscordUserAchievement*>(userAchievement));
+    return static_cast<Result>(result);
+}
+
+Result AchievementManager::GetUserAchievementAt(std::int32_t index,
+                                                UserAchievement* userAchievement)
+{
+    if (!userAchievement) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->get_user_achievement_at(
+      internal_, index, reinterpret_cast<DiscordUserAchievement*>(userAchievement));
+    return static_cast<Result>(result);
+}
+
+} // namespace discord
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/discord/activity_manager.cpp b/engine/src/ext/discord/activity_manager.cpp
new file mode 100644
index 00000000..fcb9b704
--- /dev/null
+++ b/engine/src/ext/discord/activity_manager.cpp
@@ -0,0 +1,179 @@
+#if defined(UF_USE_DISCORD)
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <discord/activity_manager.h>
+
+#include <discord/core.h>
+
+#include <cstring>
+#include <memory>
+
+namespace discord {
+
+class ActivityEvents final {
+public:
+    static void OnActivityJoin(void* callbackData, char const* secret)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->ActivityManager();
+        module.OnActivityJoin(static_cast<const char*>(secret));
+    }
+
+    static void OnActivitySpectate(void* callbackData, char const* secret)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->ActivityManager();
+        module.OnActivitySpectate(static_cast<const char*>(secret));
+    }
+
+    static void OnActivityJoinRequest(void* callbackData, DiscordUser* user)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->ActivityManager();
+        module.OnActivityJoinRequest(*reinterpret_cast<User const*>(user));
+    }
+
+    static void OnActivityInvite(void* callbackData,
+                                 EDiscordActivityActionType type,
+                                 DiscordUser* user,
+                                 DiscordActivity* activity)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->ActivityManager();
+        module.OnActivityInvite(static_cast<ActivityActionType>(type),
+                                *reinterpret_cast<User const*>(user),
+                                *reinterpret_cast<Activity const*>(activity));
+    }
+};
+
+IDiscordActivityEvents ActivityManager::events_{
+  &ActivityEvents::OnActivityJoin,
+  &ActivityEvents::OnActivitySpectate,
+  &ActivityEvents::OnActivityJoinRequest,
+  &ActivityEvents::OnActivityInvite,
+};
+
+Result ActivityManager::RegisterCommand(char const* command)
+{
+    auto result = internal_->register_command(internal_, const_cast<char*>(command));
+    return static_cast<Result>(result);
+}
+
+Result ActivityManager::RegisterSteam(std::uint32_t steamId)
+{
+    auto result = internal_->register_steam(internal_, steamId);
+    return static_cast<Result>(result);
+}
+
+void ActivityManager::UpdateActivity(Activity const& activity, std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->update_activity(internal_,
+                               reinterpret_cast<DiscordActivity*>(const_cast<Activity*>(&activity)),
+                               cb.release(),
+                               wrapper);
+}
+
+void ActivityManager::ClearActivity(std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->clear_activity(internal_, cb.release(), wrapper);
+}
+
+void ActivityManager::SendRequestReply(UserId userId,
+                                       ActivityJoinRequestReply reply,
+                                       std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->send_request_reply(internal_,
+                                  userId,
+                                  static_cast<EDiscordActivityJoinRequestReply>(reply),
+                                  cb.release(),
+                                  wrapper);
+}
+
+void ActivityManager::SendInvite(UserId userId,
+                                 ActivityActionType type,
+                                 char const* content,
+                                 std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->send_invite(internal_,
+                           userId,
+                           static_cast<EDiscordActivityActionType>(type),
+                           const_cast<char*>(content),
+                           cb.release(),
+                           wrapper);
+}
+
+void ActivityManager::AcceptInvite(UserId userId, std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->accept_invite(internal_, userId, cb.release(), wrapper);
+}
+
+} // namespace discord
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/discord/application_manager.cpp b/engine/src/ext/discord/application_manager.cpp
new file mode 100644
index 00000000..f77e7230
--- /dev/null
+++ b/engine/src/ext/discord/application_manager.cpp
@@ -0,0 +1,80 @@
+#if defined(UF_USE_DISCORD)
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <discord/application_manager.h>
+
+#include <discord/core.h>
+
+#include <cstring>
+#include <memory>
+
+namespace discord {
+
+void ApplicationManager::ValidateOrExit(std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->validate_or_exit(internal_, cb.release(), wrapper);
+}
+
+void ApplicationManager::GetCurrentLocale(char locale[128])
+{
+    if (!locale) {
+        return;
+    }
+
+    internal_->get_current_locale(internal_, reinterpret_cast<DiscordLocale*>(locale));
+}
+
+void ApplicationManager::GetCurrentBranch(char branch[4096])
+{
+    if (!branch) {
+        return;
+    }
+
+    internal_->get_current_branch(internal_, reinterpret_cast<DiscordBranch*>(branch));
+}
+
+void ApplicationManager::GetOAuth2Token(std::function<void(Result, OAuth2Token const&)> callback)
+{
+    static auto wrapper =
+      [](void* callbackData, EDiscordResult result, DiscordOAuth2Token* oauth2Token) -> void {
+        std::unique_ptr<std::function<void(Result, OAuth2Token const&)>> cb(
+          reinterpret_cast<std::function<void(Result, OAuth2Token const&)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result), *reinterpret_cast<OAuth2Token const*>(oauth2Token));
+    };
+    std::unique_ptr<std::function<void(Result, OAuth2Token const&)>> cb{};
+    cb.reset(new std::function<void(Result, OAuth2Token const&)>(std::move(callback)));
+    internal_->get_oauth2_token(internal_, cb.release(), wrapper);
+}
+
+void ApplicationManager::GetTicket(std::function<void(Result, char const*)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result, char const* data) -> void {
+        std::unique_ptr<std::function<void(Result, char const*)>> cb(
+          reinterpret_cast<std::function<void(Result, char const*)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result), static_cast<const char*>(data));
+    };
+    std::unique_ptr<std::function<void(Result, char const*)>> cb{};
+    cb.reset(new std::function<void(Result, char const*)>(std::move(callback)));
+    internal_->get_ticket(internal_, cb.release(), wrapper);
+}
+
+} // namespace discord
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/discord/core.cpp b/engine/src/ext/discord/core.cpp
new file mode 100644
index 00000000..c04e0206
--- /dev/null
+++ b/engine/src/ext/discord/core.cpp
@@ -0,0 +1,184 @@
+#if defined(UF_USE_DISCORD)
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <discord/core.h>
+
+#include <cstring>
+#include <memory>
+
+namespace discord {
+
+Result Core::Create(ClientId clientId, std::uint64_t flags, Core** instance)
+{
+    if (!instance) {
+        return Result::InternalError;
+    }
+
+    (*instance) = new Core();
+    DiscordCreateParams params{};
+    DiscordCreateParamsSetDefault(&params);
+    params.client_id = clientId;
+    params.flags = flags;
+    params.events = nullptr;
+    params.event_data = *instance;
+    params.user_events = &UserManager::events_;
+    params.activity_events = &ActivityManager::events_;
+    params.relationship_events = &RelationshipManager::events_;
+    params.lobby_events = &LobbyManager::events_;
+    params.network_events = &NetworkManager::events_;
+    params.overlay_events = &OverlayManager::events_;
+    params.store_events = &StoreManager::events_;
+    params.voice_events = &VoiceManager::events_;
+    params.achievement_events = &AchievementManager::events_;
+    auto result = DiscordCreate(DISCORD_VERSION, &params, &((*instance)->internal_));
+    if (result != DiscordResult_Ok || !(*instance)->internal_) {
+        delete (*instance);
+        (*instance) = nullptr;
+    }
+
+    return static_cast<Result>(result);
+}
+
+Core::~Core()
+{
+    if (internal_) {
+        internal_->destroy(internal_);
+        internal_ = nullptr;
+    }
+}
+
+Result Core::RunCallbacks()
+{
+    auto result = internal_->run_callbacks(internal_);
+    return static_cast<Result>(result);
+}
+
+void Core::SetLogHook(LogLevel minLevel, std::function<void(LogLevel, char const*)> hook)
+{
+    setLogHook_.DisconnectAll();
+    setLogHook_.Connect(std::move(hook));
+    static auto wrapper =
+      [](void* callbackData, EDiscordLogLevel level, char const* message) -> void {
+        auto cb(reinterpret_cast<decltype(setLogHook_)*>(callbackData));
+        if (!cb) {
+            return;
+        }
+        (*cb)(static_cast<LogLevel>(level), static_cast<const char*>(message));
+    };
+
+    internal_->set_log_hook(
+      internal_, static_cast<EDiscordLogLevel>(minLevel), &setLogHook_, wrapper);
+}
+
+discord::ApplicationManager& Core::ApplicationManager()
+{
+    if (!applicationManager_.internal_) {
+        applicationManager_.internal_ = internal_->get_application_manager(internal_);
+    }
+
+    return applicationManager_;
+}
+
+discord::UserManager& Core::UserManager()
+{
+    if (!userManager_.internal_) {
+        userManager_.internal_ = internal_->get_user_manager(internal_);
+    }
+
+    return userManager_;
+}
+
+discord::ImageManager& Core::ImageManager()
+{
+    if (!imageManager_.internal_) {
+        imageManager_.internal_ = internal_->get_image_manager(internal_);
+    }
+
+    return imageManager_;
+}
+
+discord::ActivityManager& Core::ActivityManager()
+{
+    if (!activityManager_.internal_) {
+        activityManager_.internal_ = internal_->get_activity_manager(internal_);
+    }
+
+    return activityManager_;
+}
+
+discord::RelationshipManager& Core::RelationshipManager()
+{
+    if (!relationshipManager_.internal_) {
+        relationshipManager_.internal_ = internal_->get_relationship_manager(internal_);
+    }
+
+    return relationshipManager_;
+}
+
+discord::LobbyManager& Core::LobbyManager()
+{
+    if (!lobbyManager_.internal_) {
+        lobbyManager_.internal_ = internal_->get_lobby_manager(internal_);
+    }
+
+    return lobbyManager_;
+}
+
+discord::NetworkManager& Core::NetworkManager()
+{
+    if (!networkManager_.internal_) {
+        networkManager_.internal_ = internal_->get_network_manager(internal_);
+    }
+
+    return networkManager_;
+}
+
+discord::OverlayManager& Core::OverlayManager()
+{
+    if (!overlayManager_.internal_) {
+        overlayManager_.internal_ = internal_->get_overlay_manager(internal_);
+    }
+
+    return overlayManager_;
+}
+
+discord::StorageManager& Core::StorageManager()
+{
+    if (!storageManager_.internal_) {
+        storageManager_.internal_ = internal_->get_storage_manager(internal_);
+    }
+
+    return storageManager_;
+}
+
+discord::StoreManager& Core::StoreManager()
+{
+    if (!storeManager_.internal_) {
+        storeManager_.internal_ = internal_->get_store_manager(internal_);
+    }
+
+    return storeManager_;
+}
+
+discord::VoiceManager& Core::VoiceManager()
+{
+    if (!voiceManager_.internal_) {
+        voiceManager_.internal_ = internal_->get_voice_manager(internal_);
+    }
+
+    return voiceManager_;
+}
+
+discord::AchievementManager& Core::AchievementManager()
+{
+    if (!achievementManager_.internal_) {
+        achievementManager_.internal_ = internal_->get_achievement_manager(internal_);
+    }
+
+    return achievementManager_;
+}
+
+} // namespace discord
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/discord/discord.cpp b/engine/src/ext/discord/discord.cpp
new file mode 100644
index 00000000..ea04c43c
--- /dev/null
+++ b/engine/src/ext/discord/discord.cpp
@@ -0,0 +1,444 @@
+#include <uf/ext/discord/discord.h>
+#if defined(UF_USE_DISCORD)
+#define _CRT_SECURE_NO_WARNINGS
+
+#include <array>
+#include <cassert>
+#include <csignal>
+#include <cstdio>
+#include <cstdlib>
+#include <iostream>
+#include <thread>
+#include <vector>
+
+#include <uf/utils/hook/hook.h>
+#include <uf/utils/serialize/serializer.h>
+
+#if defined(_WIN32)
+#pragma pack(push, 1)
+struct BitmapImageHeader {
+	uint32_t const structSize{sizeof(BitmapImageHeader)};
+	int32_t width{0};
+	int32_t height{0};
+	uint16_t const planes{1};
+	uint16_t const bpp{32};
+	uint32_t const pad0{0};
+	uint32_t const pad1{0};
+	uint32_t const hres{2835};
+	uint32_t const vres{2835};
+	uint32_t const pad4{0};
+	uint32_t const pad5{0};
+
+	BitmapImageHeader& operator=(BitmapImageHeader const&) = delete;
+};
+
+struct BitmapFileHeader {
+	uint8_t const magic0{'B'};
+	uint8_t const magic1{'M'};
+	uint32_t size{0};
+	uint32_t const pad{0};
+	uint32_t const offset{sizeof(BitmapFileHeader) + sizeof(BitmapImageHeader)};
+
+	BitmapFileHeader& operator=(BitmapFileHeader const&) = delete;
+};
+#pragma pack(pop)
+#endif
+
+struct DiscordState {
+	::discord::User currentUser;
+
+	std::unique_ptr<::discord::Core> core;
+};
+
+namespace {
+	volatile bool interrupted{false};
+	DiscordState state{};
+}
+
+void UF_API ext::discord::initialize(){
+
+	::discord::Core* core{};
+	auto result = ::discord::Core::Create(600081027943366656, DiscordCreateFlags_Default, &core);
+	state.core.reset(core);
+	if (!state.core) {
+		std::cout << "Failed to instantiate discord core! (err " << static_cast<int>(result) << ")\n";
+		std::exit(-1);
+	}
+
+	state.core->SetLogHook(
+		::discord::LogLevel::Debug, [](::discord::LogLevel level, const char* message) {
+			std::cerr << "Log(" << static_cast<uint32_t>(level) << "): " << message << "\n";
+		}
+	);
+/*
+	core->UserManager().OnCurrentUserUpdate.Connect([&state]() {
+		state.core->UserManager().GetCurrentUser(&state.currentUser);
+
+		std::cout << "Current user updated: " << state.currentUser.GetUsername() << "#" << state.currentUser.GetDiscriminator() << "\n";
+
+		state.core->UserManager().GetUser(170271159441424384, [](::discord::Result result, ::discord::User const& user) {
+			if (result == ::discord::Result::Ok) {
+				std::cout << "Get " << user.GetUsername() << "\n";
+			}
+			else {
+				std::cout << "Failed to get user!\n";
+			}
+		});
+
+		::discord::ImageHandle handle{};
+		handle.SetId(state.currentUser.GetId());
+		handle.SetType(::discord::ImageType::User);
+		handle.SetSize(256);
+
+		state.core->ImageManager().Fetch( handle, true, [&state](::discord::Result res, ::discord::ImageHandle handle) {
+			if (res == ::discord::Result::Ok) {
+				::discord::ImageDimensions dims{};
+				state.core->ImageManager().GetDimensions(handle, &dims);
+				std::cout << "Fetched " << dims.GetWidth() << "x" << dims.GetHeight() << " avatar!\n";
+				std::vector<uint8_t> data;
+				data.reserve(dims.GetWidth() * dims.GetHeight() * 4);
+				uint8_t* d = data.data();
+				state.core->ImageManager().GetData(handle, d, data.size());
+#if defined(_WIN32)
+				auto fileSize = data.size() + sizeof(BitmapImageHeader) + sizeof(BitmapFileHeader);
+
+				BitmapImageHeader imageHeader;
+				imageHeader.width = static_cast<int32_t>(dims.GetWidth());
+				imageHeader.height = static_cast<int32_t>(dims.GetHeight());
+
+				BitmapFileHeader fileHeader;
+				fileHeader.size = static_cast<uint32_t>(fileSize);
+
+				FILE* fp = fopen("avatar.bmp", "wb");
+				fwrite(&fileHeader, sizeof(BitmapFileHeader), 1, fp);
+				fwrite(&imageHeader, sizeof(BitmapImageHeader), 1, fp);
+
+				for (auto y = 0u; y < dims.GetHeight(); ++y) {
+				  auto pixels = reinterpret_cast<uint32_t const*>(data.data());
+				  auto invY = dims.GetHeight() - y - 1;
+				  fwrite(
+					&pixels[invY * dims.GetWidth()], sizeof(uint32_t) * dims.GetWidth(), 1, fp);
+				}
+
+				fflush(fp);
+				fclose(fp);
+#endif
+			} else {
+				std::cout << "Failed fetching avatar. (err " << static_cast<int>(res) << ")\n";
+			}
+		});
+	});
+*/
+/*
+	state.core->ActivityManager().RegisterCommand("run/command/foo/bar/baz/here.exe");
+	state.core->ActivityManager().RegisterSteam(123123321);
+*/
+/*
+	state.core->ActivityManager().OnActivityJoin.Connect( [](const char* secret) {
+		std::cout << "Join " << secret << "\n";
+	});
+	state.core->ActivityManager().OnActivitySpectate.Connect( [](const char* secret) {
+		std::cout << "Spectate " << secret << "\n";
+	});
+	state.core->ActivityManager().OnActivityJoinRequest.Connect([](::discord::User const& user) {
+		std::cout << "Join Request " << user.GetUsername() << "\n";
+	});
+	state.core->ActivityManager().OnActivityInvite.Connect( [](::discord::ActivityActionType, ::discord::User const& user, ::discord::Activity const&) {
+		std::cout << "Invite " << user.GetUsername() << "\n";
+	});
+
+	state.core->LobbyManager().OnLobbyUpdate.Connect( [](std::int64_t lobbyId) {
+		std::cout << "Lobby update " << lobbyId << "\n";
+	});
+
+	state.core->LobbyManager().OnLobbyDelete.Connect( [](std::int64_t lobbyId, std::uint32_t reason) {
+		std::cout << "Lobby delete " << lobbyId << " (reason: " << reason << ")\n";
+	});
+
+	state.core->LobbyManager().OnMemberConnect.Connect( [](std::int64_t lobbyId, std::int64_t userId) {
+		std::cout << "Lobby member connect " << lobbyId << " userId " << userId << "\n";
+	});
+
+	state.core->LobbyManager().OnMemberUpdate.Connect( [](std::int64_t lobbyId, std::int64_t userId) {
+		std::cout << "Lobby member update " << lobbyId << " userId " << userId << "\n";
+	});
+
+	state.core->LobbyManager().OnMemberDisconnect.Connect( [](std::int64_t lobbyId, std::int64_t userId) {
+		std::cout << "Lobby member disconnect " << lobbyId << " userId " << userId << "\n";
+	});
+
+	state.core->LobbyManager().OnLobbyMessage.Connect([&](std::int64_t lobbyId,
+														  std::int64_t userId,
+														  std::uint8_t* payload,
+														  std::uint32_t payloadLength) {
+		std::vector<uint8_t> buffer{};
+		buffer.resize(payloadLength);
+		memcpy(buffer.data(), payload, payloadLength);
+		std::cout << "Lobby message " << lobbyId << " from " << userId << " of length "
+				  << payloadLength << " bytes.\n";
+
+		char fourtyNinetySix[4096];
+		state.core->LobbyManager().GetLobbyMetadataValue(lobbyId, "foo", fourtyNinetySix);
+
+		std::cout << "Metadata for key foo is " << fourtyNinetySix << "\n";
+	});
+*/
+/*
+	state.core->LobbyManager().OnSpeaking.Connect( [&](std::int64_t, std::int64_t userId, bool speaking) {
+		std::cout << "User " << userId << " is " << (speaking ? "" : "NOT ") << "speaking.\n";
+	});
+*/
+
+
+
+	uf::hooks.addHook( "discord:Activity.Update", [&](ext::json::Value& json){
+		static uf::Serializer canonical; if ( ext::json::isNull( canonical["details"] ) ) {
+			canonical["large image"] = "icon";
+			canonical["large text"] = "Playing";
+		}
+
+		{
+			if ( json["details"].is<std::string>() ) canonical["details"] = json["details"];
+			if ( json["state"].is<std::string>() ) canonical["state"] = json["state"];
+			if ( json["small image"].is<std::string>() ) canonical["small image"] = json["small image"];
+			if ( json["small text"].is<std::string>() ) canonical["small text"] = json["small text"];
+			if ( json["large image"].is<std::string>() ) canonical["large image"] = json["large image"];
+			if ( json["large text"].is<std::string>() ) canonical["large text"] = json["large text"];
+		}
+
+		::discord::Activity activity{};
+		if ( canonical["details"].is<std::string>() ) activity.SetDetails(canonical["details"].asCString());
+		if ( canonical["state"].is<std::string>() ) activity.SetState(canonical["state"].asCString());
+		if ( canonical["small image"].is<std::string>() ) activity.GetAssets().SetSmallImage(canonical["small image"].asCString());
+		if ( canonical["small text"].is<std::string>() ) activity.GetAssets().SetSmallText(canonical["small text"].asCString());
+		if ( canonical["large image"].is<std::string>() ) activity.GetAssets().SetLargeImage(canonical["large image"].asCString());
+		if ( canonical["large text"].is<std::string>() ) activity.GetAssets().SetLargeText(canonical["large text"].asCString());
+		activity.SetType(::discord::ActivityType::Playing);
+		state.core->ActivityManager().UpdateActivity(activity, [](::discord::Result result) {
+			std::cout << ((result == ::discord::Result::Ok) ? "Succeeded" : "Failed") << " updating activity!\n";
+		});
+	});
+
+
+/*
+	::discord::LobbyTransaction lobby{};
+	state.core->LobbyManager().GetLobbyCreateTransaction(&lobby);
+	lobby.SetCapacity(2);
+	lobby.SetMetadata("foo", "bar");
+	lobby.SetMetadata("baz", "bat");
+	lobby.SetType(::discord::LobbyType::Public);
+	state.core->LobbyManager().CreateLobby(
+	  lobby, [&state](::discord::Result result, ::discord::Lobby const& lobby) {
+		  if (result == ::discord::Result::Ok) {
+			  std::cout << "Created lobby with secret " << lobby.GetSecret() << "\n";
+			  std::array<uint8_t, 234> data{};
+			  state.core->LobbyManager().SendLobbyMessage(
+				lobby.GetId(),
+				reinterpret_cast<uint8_t*>(data.data()),
+				data.size(),
+				[](::discord::Result result) {
+					std::cout << "Sent message. Result: " << static_cast<int>(result) << "\n";
+				});
+		  }
+		  else {
+			  std::cout << "Failed creating lobby. (err " << static_cast<int>(result) << ")\n";
+		  }
+
+		  ::discord::LobbySearchQuery query{};
+		  state.core->LobbyManager().GetSearchQuery(&query);
+		  query.Limit(1);
+		  state.core->LobbyManager().Search(query, [&state](::discord::Result result) {
+			  if (result == ::discord::Result::Ok) {
+				  std::int32_t lobbyCount{};
+				  state.core->LobbyManager().LobbyCount(&lobbyCount);
+				  std::cout << "Lobby search succeeded with " << lobbyCount << " lobbies.\n";
+				  for (auto i = 0; i < lobbyCount; ++i) {
+					  ::discord::LobbyId lobbyId{};
+					  state.core->LobbyManager().GetLobbyId(i, &lobbyId);
+					  std::cout << "  " << lobbyId << "\n";
+				  }
+			  }
+			  else {
+				  std::cout << "Lobby search failed. (err " << static_cast<int>(result) << ")\n";
+			  }
+		  });
+	  });
+*/
+/*
+	state.core->RelationshipManager().OnRefresh.Connect([&]() {
+		std::cout << "Relationships refreshed!\n";
+
+		state.core->RelationshipManager().Filter( [](::discord::Relationship const& relationship) -> bool {
+			return relationship.GetType() == ::discord::RelationshipType::Friend;
+		});
+
+		std::int32_t friendCount{0};
+		state.core->RelationshipManager().Count(&friendCount);
+
+		state.core->RelationshipManager().Filter( [&](::discord::Relationship const& relationship) -> bool {
+			return relationship.GetType() == ::discord::RelationshipType::Friend && relationship.GetUser().GetId() < state.currentUser.GetId();
+		});
+
+		std::int32_t filteredCount{0};
+		state.core->RelationshipManager().Count(&filteredCount);
+
+		::discord::Relationship relationship{};
+		for (auto i = 0; i < filteredCount; ++i) {
+			state.core->RelationshipManager().GetAt(i, &relationship);
+			std::cout << relationship.GetUser().GetId() << " "
+					  << relationship.GetUser().GetUsername() << "#"
+					  << relationship.GetUser().GetDiscriminator() << "\n";
+		}
+	});
+
+	state.core->RelationshipManager().OnRelationshipUpdate.Connect( [](::discord::Relationship const& relationship) {
+		std::cout << "Relationship with " << relationship.GetUser().GetUsername() << " updated!\n";
+	});
+*/
+}
+
+void UF_API ext::discord::tick() {
+	state.core->RunCallbacks();
+}
+
+
+/*
+#include <cstdio>
+#include <iostream>
+#include <assert.h>
+
+#define DISCORD_REQUIRE(x) assert(x == DiscordResult_Ok)
+namespace {
+	struct Application {
+		struct IDiscordCore* core;
+		struct IDiscordUserManager* users;
+		struct IDiscordAchievementManager* achievements;
+		struct IDiscordActivityManager* activities;
+		struct IDiscordRelationshipManager* relationships;
+		struct IDiscordApplicationManager* application;
+		struct IDiscordLobbyManager* lobbies;
+		DiscordUserId user_id;
+	};
+
+	void UpdateActivityCallback(void* data, enum EDiscordResult result) {
+		DISCORD_REQUIRE(result);
+	}
+
+	bool RelationshipPassFilter(void* data, struct DiscordRelationship* relationship) {
+		return (relationship->type == DiscordRelationshipType_Friend);
+	}
+
+	bool RelationshipSnowflakeFilter(void* data, struct DiscordRelationship* relationship) {
+		struct Application* app = (struct Application*)data;
+		return (relationship->type == DiscordRelationshipType_Friend && relationship->user.id < app->user_id);
+	}
+
+	void OnRelationshipsRefresh(void* data) {
+		struct Application* app = (struct Application*)data;
+		struct IDiscordRelationshipManager* module = app->relationships;
+
+		module->filter(module, app, RelationshipPassFilter);
+
+		int32_t unfiltered_count = 0;
+		DISCORD_REQUIRE(module->count(module, &unfiltered_count));
+
+		module->filter(module, app, RelationshipSnowflakeFilter);
+
+		int32_t filtered_count = 0;
+		DISCORD_REQUIRE(module->count(module, &filtered_count));
+
+		printf("=== Cool Friends ===\n");
+		for (int32_t i = 0; i < filtered_count; i += 1) {
+			struct DiscordRelationship relationship;
+			DISCORD_REQUIRE(module->get_at(module, i, &relationship));
+
+			printf("%lld %s#%s\n",
+				   relationship.user.id,
+				   relationship.user.username,
+				   relationship.user.discriminator);
+		}
+		printf("(%d friends less cool than you omitted)\n", unfiltered_count - filtered_count);
+
+		struct DiscordActivity activity;
+		memset(&activity, 0, sizeof(activity));
+		sprintf(activity.details, "Cooler than %d friends", unfiltered_count - filtered_count);
+		sprintf(activity.state, "%d friends total", unfiltered_count);
+
+		app->activities->update_activity(app->activities, &activity, app, UpdateActivityCallback);
+	}
+
+	void OnUserUpdated(void* data) {
+		struct Application* app = (struct Application*)data;
+		struct DiscordUser user;
+		app->users->get_current_user(app->users, &user);
+		app->user_id = user.id;
+	}
+
+	void OnOAuth2Token(void* data, enum EDiscordResult result, struct DiscordOAuth2Token* token) {
+		if (result == DiscordResult_Ok) {
+			printf("OAuth2 token: %s\n", token->access_token);
+		} else {
+			printf("GetOAuth2Token failed with %d\n", (int)result);
+		}
+	}
+
+	void OnLobbyConnect(void* data, enum EDiscordResult result, struct DiscordLobby* lobby) {
+		printf("LobbyConnect returned %d\n", (int)result);
+	}
+}
+
+namespace {
+	struct Application app;
+}
+
+void UF_API ext::::discord::initialize() {
+	memset(&app, 0, sizeof(app));
+
+	struct IDiscordUserEvents users_events;
+	memset(&users_events, 0, sizeof(users_events));
+	users_events.on_current_user_update = OnUserUpdated;
+
+	struct IDiscordActivityEvents activities_events;
+	memset(&activities_events, 0, sizeof(activities_events));
+
+	struct IDiscordRelationshipEvents relationships_events;
+	memset(&relationships_events, 0, sizeof(relationships_events));
+	relationships_events.on_refresh = OnRelationshipsRefresh;
+
+	struct DiscordCreateParams params;
+	DiscordCreateParamsSetDefault(&params);
+	params.client_id = 600081027943366656;
+	params.flags = DiscordCreateFlags_Default;
+	params.event_data = &app;
+	params.activity_events = &activities_events;
+	params.relationship_events = &relationships_events;
+	params.user_events = &users_events;
+	DISCORD_REQUIRE(DiscordCreate(DISCORD_VERSION, &params, &app.core));
+
+	app.users = app.core->get_user_manager(app.core);
+	app.achievements = app.core->get_achievement_manager(app.core);
+	app.activities = app.core->get_activity_manager(app.core);
+	app.application = app.core->get_application_manager(app.core);
+	app.lobbies = app.core->get_lobby_manager(app.core);
+
+	app.lobbies->connect_lobby_with_activity_secret( app.lobbies, "X4QbKBKWUfU93wtxNasxNi4R3NigTVYQ", &app, OnLobbyConnect);
+
+	app.application->get_oauth2_token(app.application, &app, OnOAuth2Token);
+
+	DiscordBranch branch;
+	app.application->get_current_branch(app.application, &branch);
+	printf("Current branch %s\n", branch);
+
+	app.relationships = app.core->get_relationship_manager(app.core);
+}
+
+void UF_API ext::::discord::tick() {
+	DISCORD_REQUIRE(app.core->run_callbacks(app.core));
+}
+*/
+#else
+void UF_API ext::discord::initialize(){
+}
+void UF_API ext::discord::tick(){
+}
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/discord/image_manager.cpp b/engine/src/ext/discord/image_manager.cpp
new file mode 100644
index 00000000..c767f3cb
--- /dev/null
+++ b/engine/src/ext/discord/image_manager.cpp
@@ -0,0 +1,59 @@
+#if defined(UF_USE_DISCORD)
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <discord/image_manager.h>
+
+#include <discord/core.h>
+
+#include <cstring>
+#include <memory>
+
+namespace discord {
+
+void ImageManager::Fetch(ImageHandle handle,
+                         bool refresh,
+                         std::function<void(Result, ImageHandle)> callback)
+{
+    static auto wrapper =
+      [](void* callbackData, EDiscordResult result, DiscordImageHandle handleResult) -> void {
+        std::unique_ptr<std::function<void(Result, ImageHandle)>> cb(
+          reinterpret_cast<std::function<void(Result, ImageHandle)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result), *reinterpret_cast<ImageHandle const*>(&handleResult));
+    };
+    std::unique_ptr<std::function<void(Result, ImageHandle)>> cb{};
+    cb.reset(new std::function<void(Result, ImageHandle)>(std::move(callback)));
+    internal_->fetch(internal_,
+                     *reinterpret_cast<DiscordImageHandle const*>(&handle),
+                     (refresh ? 1 : 0),
+                     cb.release(),
+                     wrapper);
+}
+
+Result ImageManager::GetDimensions(ImageHandle handle, ImageDimensions* dimensions)
+{
+    if (!dimensions) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->get_dimensions(internal_,
+                                            *reinterpret_cast<DiscordImageHandle const*>(&handle),
+                                            reinterpret_cast<DiscordImageDimensions*>(dimensions));
+    return static_cast<Result>(result);
+}
+
+Result ImageManager::GetData(ImageHandle handle, std::uint8_t* data, std::uint32_t dataLength)
+{
+    auto result = internal_->get_data(internal_,
+                                      *reinterpret_cast<DiscordImageHandle const*>(&handle),
+                                      reinterpret_cast<uint8_t*>(data),
+                                      dataLength);
+    return static_cast<Result>(result);
+}
+
+} // namespace discord
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/discord/lobby_manager.cpp b/engine/src/ext/discord/lobby_manager.cpp
new file mode 100644
index 00000000..ca71cc33
--- /dev/null
+++ b/engine/src/ext/discord/lobby_manager.cpp
@@ -0,0 +1,549 @@
+#if defined(UF_USE_DISCORD)
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <discord/lobby_manager.h>
+
+#include <discord/core.h>
+
+#include <cstring>
+#include <memory>
+
+namespace discord {
+
+class LobbyEvents final {
+public:
+    static void OnLobbyUpdate(void* callbackData, int64_t lobbyId)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->LobbyManager();
+        module.OnLobbyUpdate(lobbyId);
+    }
+
+    static void OnLobbyDelete(void* callbackData, int64_t lobbyId, uint32_t reason)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->LobbyManager();
+        module.OnLobbyDelete(lobbyId, reason);
+    }
+
+    static void OnMemberConnect(void* callbackData, int64_t lobbyId, int64_t userId)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->LobbyManager();
+        module.OnMemberConnect(lobbyId, userId);
+    }
+
+    static void OnMemberUpdate(void* callbackData, int64_t lobbyId, int64_t userId)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->LobbyManager();
+        module.OnMemberUpdate(lobbyId, userId);
+    }
+
+    static void OnMemberDisconnect(void* callbackData, int64_t lobbyId, int64_t userId)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->LobbyManager();
+        module.OnMemberDisconnect(lobbyId, userId);
+    }
+
+    static void OnLobbyMessage(void* callbackData,
+                               int64_t lobbyId,
+                               int64_t userId,
+                               uint8_t* data,
+                               uint32_t dataLength)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->LobbyManager();
+        module.OnLobbyMessage(lobbyId, userId, data, dataLength);
+    }
+
+    static void OnSpeaking(void* callbackData, int64_t lobbyId, int64_t userId, bool speaking)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->LobbyManager();
+        module.OnSpeaking(lobbyId, userId, (speaking != 0));
+    }
+
+    static void OnNetworkMessage(void* callbackData,
+                                 int64_t lobbyId,
+                                 int64_t userId,
+                                 uint8_t channelId,
+                                 uint8_t* data,
+                                 uint32_t dataLength)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->LobbyManager();
+        module.OnNetworkMessage(lobbyId, userId, channelId, data, dataLength);
+    }
+};
+
+IDiscordLobbyEvents LobbyManager::events_{
+  &LobbyEvents::OnLobbyUpdate,
+  &LobbyEvents::OnLobbyDelete,
+  &LobbyEvents::OnMemberConnect,
+  &LobbyEvents::OnMemberUpdate,
+  &LobbyEvents::OnMemberDisconnect,
+  &LobbyEvents::OnLobbyMessage,
+  &LobbyEvents::OnSpeaking,
+  &LobbyEvents::OnNetworkMessage,
+};
+
+Result LobbyManager::GetLobbyCreateTransaction(LobbyTransaction* transaction)
+{
+    if (!transaction) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->get_lobby_create_transaction(internal_, transaction->Receive());
+    return static_cast<Result>(result);
+}
+
+Result LobbyManager::GetLobbyUpdateTransaction(LobbyId lobbyId, LobbyTransaction* transaction)
+{
+    if (!transaction) {
+        return Result::InternalError;
+    }
+
+    auto result =
+      internal_->get_lobby_update_transaction(internal_, lobbyId, transaction->Receive());
+    return static_cast<Result>(result);
+}
+
+Result LobbyManager::GetMemberUpdateTransaction(LobbyId lobbyId,
+                                                UserId userId,
+                                                LobbyMemberTransaction* transaction)
+{
+    if (!transaction) {
+        return Result::InternalError;
+    }
+
+    auto result =
+      internal_->get_member_update_transaction(internal_, lobbyId, userId, transaction->Receive());
+    return static_cast<Result>(result);
+}
+
+void LobbyManager::CreateLobby(LobbyTransaction const& transaction,
+                               std::function<void(Result, Lobby const&)> callback)
+{
+    static auto wrapper =
+      [](void* callbackData, EDiscordResult result, DiscordLobby* lobby) -> void {
+        std::unique_ptr<std::function<void(Result, Lobby const&)>> cb(
+          reinterpret_cast<std::function<void(Result, Lobby const&)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result), *reinterpret_cast<Lobby const*>(lobby));
+    };
+    std::unique_ptr<std::function<void(Result, Lobby const&)>> cb{};
+    cb.reset(new std::function<void(Result, Lobby const&)>(std::move(callback)));
+    internal_->create_lobby(
+      internal_, const_cast<LobbyTransaction&>(transaction).Internal(), cb.release(), wrapper);
+}
+
+void LobbyManager::UpdateLobby(LobbyId lobbyId,
+                               LobbyTransaction const& transaction,
+                               std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->update_lobby(internal_,
+                            lobbyId,
+                            const_cast<LobbyTransaction&>(transaction).Internal(),
+                            cb.release(),
+                            wrapper);
+}
+
+void LobbyManager::DeleteLobby(LobbyId lobbyId, std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->delete_lobby(internal_, lobbyId, cb.release(), wrapper);
+}
+
+void LobbyManager::ConnectLobby(LobbyId lobbyId,
+                                LobbySecret secret,
+                                std::function<void(Result, Lobby const&)> callback)
+{
+    static auto wrapper =
+      [](void* callbackData, EDiscordResult result, DiscordLobby* lobby) -> void {
+        std::unique_ptr<std::function<void(Result, Lobby const&)>> cb(
+          reinterpret_cast<std::function<void(Result, Lobby const&)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result), *reinterpret_cast<Lobby const*>(lobby));
+    };
+    std::unique_ptr<std::function<void(Result, Lobby const&)>> cb{};
+    cb.reset(new std::function<void(Result, Lobby const&)>(std::move(callback)));
+    internal_->connect_lobby(internal_, lobbyId, const_cast<char*>(secret), cb.release(), wrapper);
+}
+
+void LobbyManager::ConnectLobbyWithActivitySecret(
+  LobbySecret activitySecret,
+  std::function<void(Result, Lobby const&)> callback)
+{
+    static auto wrapper =
+      [](void* callbackData, EDiscordResult result, DiscordLobby* lobby) -> void {
+        std::unique_ptr<std::function<void(Result, Lobby const&)>> cb(
+          reinterpret_cast<std::function<void(Result, Lobby const&)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result), *reinterpret_cast<Lobby const*>(lobby));
+    };
+    std::unique_ptr<std::function<void(Result, Lobby const&)>> cb{};
+    cb.reset(new std::function<void(Result, Lobby const&)>(std::move(callback)));
+    internal_->connect_lobby_with_activity_secret(
+      internal_, const_cast<char*>(activitySecret), cb.release(), wrapper);
+}
+
+void LobbyManager::DisconnectLobby(LobbyId lobbyId, std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->disconnect_lobby(internal_, lobbyId, cb.release(), wrapper);
+}
+
+Result LobbyManager::GetLobby(LobbyId lobbyId, Lobby* lobby)
+{
+    if (!lobby) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->get_lobby(internal_, lobbyId, reinterpret_cast<DiscordLobby*>(lobby));
+    return static_cast<Result>(result);
+}
+
+Result LobbyManager::GetLobbyActivitySecret(LobbyId lobbyId, char secret[128])
+{
+    if (!secret) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->get_lobby_activity_secret(
+      internal_, lobbyId, reinterpret_cast<DiscordLobbySecret*>(secret));
+    return static_cast<Result>(result);
+}
+
+Result LobbyManager::GetLobbyMetadataValue(LobbyId lobbyId, MetadataKey key, char value[4096])
+{
+    if (!value) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->get_lobby_metadata_value(
+      internal_, lobbyId, const_cast<char*>(key), reinterpret_cast<DiscordMetadataValue*>(value));
+    return static_cast<Result>(result);
+}
+
+Result LobbyManager::GetLobbyMetadataKey(LobbyId lobbyId, std::int32_t index, char key[256])
+{
+    if (!key) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->get_lobby_metadata_key(
+      internal_, lobbyId, index, reinterpret_cast<DiscordMetadataKey*>(key));
+    return static_cast<Result>(result);
+}
+
+Result LobbyManager::LobbyMetadataCount(LobbyId lobbyId, std::int32_t* count)
+{
+    if (!count) {
+        return Result::InternalError;
+    }
+
+    auto result =
+      internal_->lobby_metadata_count(internal_, lobbyId, reinterpret_cast<int32_t*>(count));
+    return static_cast<Result>(result);
+}
+
+Result LobbyManager::MemberCount(LobbyId lobbyId, std::int32_t* count)
+{
+    if (!count) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->member_count(internal_, lobbyId, reinterpret_cast<int32_t*>(count));
+    return static_cast<Result>(result);
+}
+
+Result LobbyManager::GetMemberUserId(LobbyId lobbyId, std::int32_t index, UserId* userId)
+{
+    if (!userId) {
+        return Result::InternalError;
+    }
+
+    auto result =
+      internal_->get_member_user_id(internal_, lobbyId, index, reinterpret_cast<int64_t*>(userId));
+    return static_cast<Result>(result);
+}
+
+Result LobbyManager::GetMemberUser(LobbyId lobbyId, UserId userId, User* user)
+{
+    if (!user) {
+        return Result::InternalError;
+    }
+
+    auto result =
+      internal_->get_member_user(internal_, lobbyId, userId, reinterpret_cast<DiscordUser*>(user));
+    return static_cast<Result>(result);
+}
+
+Result LobbyManager::GetMemberMetadataValue(LobbyId lobbyId,
+                                            UserId userId,
+                                            MetadataKey key,
+                                            char value[4096])
+{
+    if (!value) {
+        return Result::InternalError;
+    }
+
+    auto result =
+      internal_->get_member_metadata_value(internal_,
+                                           lobbyId,
+                                           userId,
+                                           const_cast<char*>(key),
+                                           reinterpret_cast<DiscordMetadataValue*>(value));
+    return static_cast<Result>(result);
+}
+
+Result LobbyManager::GetMemberMetadataKey(LobbyId lobbyId,
+                                          UserId userId,
+                                          std::int32_t index,
+                                          char key[256])
+{
+    if (!key) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->get_member_metadata_key(
+      internal_, lobbyId, userId, index, reinterpret_cast<DiscordMetadataKey*>(key));
+    return static_cast<Result>(result);
+}
+
+Result LobbyManager::MemberMetadataCount(LobbyId lobbyId, UserId userId, std::int32_t* count)
+{
+    if (!count) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->member_metadata_count(
+      internal_, lobbyId, userId, reinterpret_cast<int32_t*>(count));
+    return static_cast<Result>(result);
+}
+
+void LobbyManager::UpdateMember(LobbyId lobbyId,
+                                UserId userId,
+                                LobbyMemberTransaction const& transaction,
+                                std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->update_member(internal_,
+                             lobbyId,
+                             userId,
+                             const_cast<LobbyMemberTransaction&>(transaction).Internal(),
+                             cb.release(),
+                             wrapper);
+}
+
+void LobbyManager::SendLobbyMessage(LobbyId lobbyId,
+                                    std::uint8_t* data,
+                                    std::uint32_t dataLength,
+                                    std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->send_lobby_message(
+      internal_, lobbyId, reinterpret_cast<uint8_t*>(data), dataLength, cb.release(), wrapper);
+}
+
+Result LobbyManager::GetSearchQuery(LobbySearchQuery* query)
+{
+    if (!query) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->get_search_query(internal_, query->Receive());
+    return static_cast<Result>(result);
+}
+
+void LobbyManager::Search(LobbySearchQuery const& query, std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->search(
+      internal_, const_cast<LobbySearchQuery&>(query).Internal(), cb.release(), wrapper);
+}
+
+void LobbyManager::LobbyCount(std::int32_t* count)
+{
+    if (!count) {
+        return;
+    }
+
+    internal_->lobby_count(internal_, reinterpret_cast<int32_t*>(count));
+}
+
+Result LobbyManager::GetLobbyId(std::int32_t index, LobbyId* lobbyId)
+{
+    if (!lobbyId) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->get_lobby_id(internal_, index, reinterpret_cast<int64_t*>(lobbyId));
+    return static_cast<Result>(result);
+}
+
+void LobbyManager::ConnectVoice(LobbyId lobbyId, std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->connect_voice(internal_, lobbyId, cb.release(), wrapper);
+}
+
+void LobbyManager::DisconnectVoice(LobbyId lobbyId, std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->disconnect_voice(internal_, lobbyId, cb.release(), wrapper);
+}
+
+Result LobbyManager::ConnectNetwork(LobbyId lobbyId)
+{
+    auto result = internal_->connect_network(internal_, lobbyId);
+    return static_cast<Result>(result);
+}
+
+Result LobbyManager::DisconnectNetwork(LobbyId lobbyId)
+{
+    auto result = internal_->disconnect_network(internal_, lobbyId);
+    return static_cast<Result>(result);
+}
+
+Result LobbyManager::FlushNetwork()
+{
+    auto result = internal_->flush_network(internal_);
+    return static_cast<Result>(result);
+}
+
+Result LobbyManager::OpenNetworkChannel(LobbyId lobbyId, std::uint8_t channelId, bool reliable)
+{
+    auto result =
+      internal_->open_network_channel(internal_, lobbyId, channelId, (reliable ? 1 : 0));
+    return static_cast<Result>(result);
+}
+
+Result LobbyManager::SendNetworkMessage(LobbyId lobbyId,
+                                        UserId userId,
+                                        std::uint8_t channelId,
+                                        std::uint8_t* data,
+                                        std::uint32_t dataLength)
+{
+    auto result = internal_->send_network_message(
+      internal_, lobbyId, userId, channelId, reinterpret_cast<uint8_t*>(data), dataLength);
+    return static_cast<Result>(result);
+}
+
+} // namespace discord
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/discord/network_manager.cpp b/engine/src/ext/discord/network_manager.cpp
new file mode 100644
index 00000000..65b48276
--- /dev/null
+++ b/engine/src/ext/discord/network_manager.cpp
@@ -0,0 +1,105 @@
+#if defined(UF_USE_DISCORD)
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <discord/network_manager.h>
+
+#include <discord/core.h>
+
+#include <cstring>
+#include <memory>
+
+namespace discord {
+
+class NetworkEvents final {
+public:
+    static void OnMessage(void* callbackData,
+                          DiscordNetworkPeerId peerId,
+                          DiscordNetworkChannelId channelId,
+                          uint8_t* data,
+                          uint32_t dataLength)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->NetworkManager();
+        module.OnMessage(peerId, channelId, data, dataLength);
+    }
+
+    static void OnRouteUpdate(void* callbackData, char const* routeData)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->NetworkManager();
+        module.OnRouteUpdate(static_cast<const char*>(routeData));
+    }
+};
+
+IDiscordNetworkEvents NetworkManager::events_{
+  &NetworkEvents::OnMessage,
+  &NetworkEvents::OnRouteUpdate,
+};
+
+void NetworkManager::GetPeerId(NetworkPeerId* peerId)
+{
+    if (!peerId) {
+        return;
+    }
+
+    internal_->get_peer_id(internal_, reinterpret_cast<uint64_t*>(peerId));
+}
+
+Result NetworkManager::Flush()
+{
+    auto result = internal_->flush(internal_);
+    return static_cast<Result>(result);
+}
+
+Result NetworkManager::OpenPeer(NetworkPeerId peerId, char const* routeData)
+{
+    auto result = internal_->open_peer(internal_, peerId, const_cast<char*>(routeData));
+    return static_cast<Result>(result);
+}
+
+Result NetworkManager::UpdatePeer(NetworkPeerId peerId, char const* routeData)
+{
+    auto result = internal_->update_peer(internal_, peerId, const_cast<char*>(routeData));
+    return static_cast<Result>(result);
+}
+
+Result NetworkManager::ClosePeer(NetworkPeerId peerId)
+{
+    auto result = internal_->close_peer(internal_, peerId);
+    return static_cast<Result>(result);
+}
+
+Result NetworkManager::OpenChannel(NetworkPeerId peerId, NetworkChannelId channelId, bool reliable)
+{
+    auto result = internal_->open_channel(internal_, peerId, channelId, (reliable ? 1 : 0));
+    return static_cast<Result>(result);
+}
+
+Result NetworkManager::CloseChannel(NetworkPeerId peerId, NetworkChannelId channelId)
+{
+    auto result = internal_->close_channel(internal_, peerId, channelId);
+    return static_cast<Result>(result);
+}
+
+Result NetworkManager::SendMessage(NetworkPeerId peerId,
+                                   NetworkChannelId channelId,
+                                   std::uint8_t* data,
+                                   std::uint32_t dataLength)
+{
+    auto result = internal_->send_message(
+      internal_, peerId, channelId, reinterpret_cast<uint8_t*>(data), dataLength);
+    return static_cast<Result>(result);
+}
+
+} // namespace discord
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/discord/overlay_manager.cpp b/engine/src/ext/discord/overlay_manager.cpp
new file mode 100644
index 00000000..f585beac
--- /dev/null
+++ b/engine/src/ext/discord/overlay_manager.cpp
@@ -0,0 +1,114 @@
+#if defined(UF_USE_DISCORD)
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <discord/overlay_manager.h>
+
+#include <discord/core.h>
+
+#include <cstring>
+#include <memory>
+
+namespace discord {
+
+class OverlayEvents final {
+public:
+    static void OnToggle(void* callbackData, bool locked)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->OverlayManager();
+        module.OnToggle((locked != 0));
+    }
+};
+
+IDiscordOverlayEvents OverlayManager::events_{
+  &OverlayEvents::OnToggle,
+};
+
+void OverlayManager::IsEnabled(bool* enabled)
+{
+    if (!enabled) {
+        return;
+    }
+
+    internal_->is_enabled(internal_, reinterpret_cast<bool*>(enabled));
+}
+
+void OverlayManager::IsLocked(bool* locked)
+{
+    if (!locked) {
+        return;
+    }
+
+    internal_->is_locked(internal_, reinterpret_cast<bool*>(locked));
+}
+
+void OverlayManager::SetLocked(bool locked, std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->set_locked(internal_, (locked ? 1 : 0), cb.release(), wrapper);
+}
+
+void OverlayManager::OpenActivityInvite(ActivityActionType type,
+                                        std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->open_activity_invite(
+      internal_, static_cast<EDiscordActivityActionType>(type), cb.release(), wrapper);
+}
+
+void OverlayManager::OpenGuildInvite(char const* code, std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->open_guild_invite(internal_, const_cast<char*>(code), cb.release(), wrapper);
+}
+
+void OverlayManager::OpenVoiceSettings(std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->open_voice_settings(internal_, cb.release(), wrapper);
+}
+
+} // namespace discord
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/discord/relationship_manager.cpp b/engine/src/ext/discord/relationship_manager.cpp
new file mode 100644
index 00000000..4e57ab1d
--- /dev/null
+++ b/engine/src/ext/discord/relationship_manager.cpp
@@ -0,0 +1,92 @@
+#if defined(UF_USE_DISCORD)
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <discord/relationship_manager.h>
+
+#include <discord/core.h>
+
+#include <cstring>
+#include <memory>
+
+namespace discord {
+
+class RelationshipEvents final {
+public:
+    static void OnRefresh(void* callbackData)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->RelationshipManager();
+        module.OnRefresh();
+    }
+
+    static void OnRelationshipUpdate(void* callbackData, DiscordRelationship* relationship)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->RelationshipManager();
+        module.OnRelationshipUpdate(*reinterpret_cast<Relationship const*>(relationship));
+    }
+};
+
+IDiscordRelationshipEvents RelationshipManager::events_{
+  &RelationshipEvents::OnRefresh,
+  &RelationshipEvents::OnRelationshipUpdate,
+};
+
+void RelationshipManager::Filter(std::function<bool(Relationship const&)> filter)
+{
+    static auto wrapper = [](void* callbackData, DiscordRelationship* relationship) -> bool {
+        auto cb(reinterpret_cast<std::function<bool(Relationship const&)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return {};
+        }
+        return (*cb)(*reinterpret_cast<Relationship const*>(relationship));
+    };
+    std::unique_ptr<std::function<bool(Relationship const&)>> cb{};
+    cb.reset(new std::function<bool(Relationship const&)>(std::move(filter)));
+    internal_->filter(internal_, cb.get(), wrapper);
+}
+
+Result RelationshipManager::Count(std::int32_t* count)
+{
+    if (!count) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->count(internal_, reinterpret_cast<int32_t*>(count));
+    return static_cast<Result>(result);
+}
+
+Result RelationshipManager::Get(UserId userId, Relationship* relationship)
+{
+    if (!relationship) {
+        return Result::InternalError;
+    }
+
+    auto result =
+      internal_->get(internal_, userId, reinterpret_cast<DiscordRelationship*>(relationship));
+    return static_cast<Result>(result);
+}
+
+Result RelationshipManager::GetAt(std::uint32_t index, Relationship* relationship)
+{
+    if (!relationship) {
+        return Result::InternalError;
+    }
+
+    auto result =
+      internal_->get_at(internal_, index, reinterpret_cast<DiscordRelationship*>(relationship));
+    return static_cast<Result>(result);
+}
+
+} // namespace discord
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/discord/storage_manager.cpp b/engine/src/ext/discord/storage_manager.cpp
new file mode 100644
index 00000000..de04a5f8
--- /dev/null
+++ b/engine/src/ext/discord/storage_manager.cpp
@@ -0,0 +1,160 @@
+#if defined(UF_USE_DISCORD)
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <discord/storage_manager.h>
+
+#include <discord/core.h>
+
+#include <cstring>
+#include <memory>
+
+namespace discord {
+
+Result StorageManager::Read(char const* name,
+                            std::uint8_t* data,
+                            std::uint32_t dataLength,
+                            std::uint32_t* read)
+{
+    if (!read) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->read(internal_,
+                                  const_cast<char*>(name),
+                                  reinterpret_cast<uint8_t*>(data),
+                                  dataLength,
+                                  reinterpret_cast<uint32_t*>(read));
+    return static_cast<Result>(result);
+}
+
+void StorageManager::ReadAsync(char const* name,
+                               std::function<void(Result, std::uint8_t*, std::uint32_t)> callback)
+{
+    static auto wrapper =
+      [](void* callbackData, EDiscordResult result, uint8_t* data, uint32_t dataLength) -> void {
+        std::unique_ptr<std::function<void(Result, std::uint8_t*, std::uint32_t)>> cb(
+          reinterpret_cast<std::function<void(Result, std::uint8_t*, std::uint32_t)>*>(
+            callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result), data, dataLength);
+    };
+    std::unique_ptr<std::function<void(Result, std::uint8_t*, std::uint32_t)>> cb{};
+    cb.reset(new std::function<void(Result, std::uint8_t*, std::uint32_t)>(std::move(callback)));
+    internal_->read_async(internal_, const_cast<char*>(name), cb.release(), wrapper);
+}
+
+void StorageManager::ReadAsyncPartial(
+  char const* name,
+  std::uint64_t offset,
+  std::uint64_t length,
+  std::function<void(Result, std::uint8_t*, std::uint32_t)> callback)
+{
+    static auto wrapper =
+      [](void* callbackData, EDiscordResult result, uint8_t* data, uint32_t dataLength) -> void {
+        std::unique_ptr<std::function<void(Result, std::uint8_t*, std::uint32_t)>> cb(
+          reinterpret_cast<std::function<void(Result, std::uint8_t*, std::uint32_t)>*>(
+            callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result), data, dataLength);
+    };
+    std::unique_ptr<std::function<void(Result, std::uint8_t*, std::uint32_t)>> cb{};
+    cb.reset(new std::function<void(Result, std::uint8_t*, std::uint32_t)>(std::move(callback)));
+    internal_->read_async_partial(
+      internal_, const_cast<char*>(name), offset, length, cb.release(), wrapper);
+}
+
+Result StorageManager::Write(char const* name, std::uint8_t* data, std::uint32_t dataLength)
+{
+    auto result = internal_->write(
+      internal_, const_cast<char*>(name), reinterpret_cast<uint8_t*>(data), dataLength);
+    return static_cast<Result>(result);
+}
+
+void StorageManager::WriteAsync(char const* name,
+                                std::uint8_t* data,
+                                std::uint32_t dataLength,
+                                std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->write_async(internal_,
+                           const_cast<char*>(name),
+                           reinterpret_cast<uint8_t*>(data),
+                           dataLength,
+                           cb.release(),
+                           wrapper);
+}
+
+Result StorageManager::Delete(char const* name)
+{
+    auto result = internal_->delete_(internal_, const_cast<char*>(name));
+    return static_cast<Result>(result);
+}
+
+Result StorageManager::Exists(char const* name, bool* exists)
+{
+    if (!exists) {
+        return Result::InternalError;
+    }
+
+    auto result =
+      internal_->exists(internal_, const_cast<char*>(name), reinterpret_cast<bool*>(exists));
+    return static_cast<Result>(result);
+}
+
+void StorageManager::Count(std::int32_t* count)
+{
+    if (!count) {
+        return;
+    }
+
+    internal_->count(internal_, reinterpret_cast<int32_t*>(count));
+}
+
+Result StorageManager::Stat(char const* name, FileStat* stat)
+{
+    if (!stat) {
+        return Result::InternalError;
+    }
+
+    auto result =
+      internal_->stat(internal_, const_cast<char*>(name), reinterpret_cast<DiscordFileStat*>(stat));
+    return static_cast<Result>(result);
+}
+
+Result StorageManager::StatAt(std::int32_t index, FileStat* stat)
+{
+    if (!stat) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->stat_at(internal_, index, reinterpret_cast<DiscordFileStat*>(stat));
+    return static_cast<Result>(result);
+}
+
+Result StorageManager::GetPath(char path[4096])
+{
+    if (!path) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->get_path(internal_, reinterpret_cast<DiscordPath*>(path));
+    return static_cast<Result>(result);
+}
+
+} // namespace discord
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/discord/store_manager.cpp b/engine/src/ext/discord/store_manager.cpp
new file mode 100644
index 00000000..5c500f78
--- /dev/null
+++ b/engine/src/ext/discord/store_manager.cpp
@@ -0,0 +1,162 @@
+#if defined(UF_USE_DISCORD)
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <discord/store_manager.h>
+
+#include <discord/core.h>
+
+#include <cstring>
+#include <memory>
+
+namespace discord {
+
+class StoreEvents final {
+public:
+    static void OnEntitlementCreate(void* callbackData, DiscordEntitlement* entitlement)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->StoreManager();
+        module.OnEntitlementCreate(*reinterpret_cast<Entitlement const*>(entitlement));
+    }
+
+    static void OnEntitlementDelete(void* callbackData, DiscordEntitlement* entitlement)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->StoreManager();
+        module.OnEntitlementDelete(*reinterpret_cast<Entitlement const*>(entitlement));
+    }
+};
+
+IDiscordStoreEvents StoreManager::events_{
+  &StoreEvents::OnEntitlementCreate,
+  &StoreEvents::OnEntitlementDelete,
+};
+
+void StoreManager::FetchSkus(std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->fetch_skus(internal_, cb.release(), wrapper);
+}
+
+void StoreManager::CountSkus(std::int32_t* count)
+{
+    if (!count) {
+        return;
+    }
+
+    internal_->count_skus(internal_, reinterpret_cast<int32_t*>(count));
+}
+
+Result StoreManager::GetSku(Snowflake skuId, Sku* sku)
+{
+    if (!sku) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->get_sku(internal_, skuId, reinterpret_cast<DiscordSku*>(sku));
+    return static_cast<Result>(result);
+}
+
+Result StoreManager::GetSkuAt(std::int32_t index, Sku* sku)
+{
+    if (!sku) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->get_sku_at(internal_, index, reinterpret_cast<DiscordSku*>(sku));
+    return static_cast<Result>(result);
+}
+
+void StoreManager::FetchEntitlements(std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->fetch_entitlements(internal_, cb.release(), wrapper);
+}
+
+void StoreManager::CountEntitlements(std::int32_t* count)
+{
+    if (!count) {
+        return;
+    }
+
+    internal_->count_entitlements(internal_, reinterpret_cast<int32_t*>(count));
+}
+
+Result StoreManager::GetEntitlement(Snowflake entitlementId, Entitlement* entitlement)
+{
+    if (!entitlement) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->get_entitlement(
+      internal_, entitlementId, reinterpret_cast<DiscordEntitlement*>(entitlement));
+    return static_cast<Result>(result);
+}
+
+Result StoreManager::GetEntitlementAt(std::int32_t index, Entitlement* entitlement)
+{
+    if (!entitlement) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->get_entitlement_at(
+      internal_, index, reinterpret_cast<DiscordEntitlement*>(entitlement));
+    return static_cast<Result>(result);
+}
+
+Result StoreManager::HasSkuEntitlement(Snowflake skuId, bool* hasEntitlement)
+{
+    if (!hasEntitlement) {
+        return Result::InternalError;
+    }
+
+    auto result =
+      internal_->has_sku_entitlement(internal_, skuId, reinterpret_cast<bool*>(hasEntitlement));
+    return static_cast<Result>(result);
+}
+
+void StoreManager::StartPurchase(Snowflake skuId, std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->start_purchase(internal_, skuId, cb.release(), wrapper);
+}
+
+} // namespace discord
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/discord/types.cpp b/engine/src/ext/discord/types.cpp
new file mode 100644
index 00000000..8dd6f853
--- /dev/null
+++ b/engine/src/ext/discord/types.cpp
@@ -0,0 +1,771 @@
+#if defined(UF_USE_DISCORD)
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <discord/types.h>
+
+#include <cstring>
+#include <memory>
+
+namespace discord {
+
+void User::SetId(UserId id)
+{
+    internal_.id = id;
+}
+
+UserId User::GetId() const
+{
+    return internal_.id;
+}
+
+void User::SetUsername(char const* username)
+{
+    strncpy(internal_.username, username, 256);
+    internal_.username[256 - 1] = '\0';
+}
+
+char const* User::GetUsername() const
+{
+    return internal_.username;
+}
+
+void User::SetDiscriminator(char const* discriminator)
+{
+    strncpy(internal_.discriminator, discriminator, 8);
+    internal_.discriminator[8 - 1] = '\0';
+}
+
+char const* User::GetDiscriminator() const
+{
+    return internal_.discriminator;
+}
+
+void User::SetAvatar(char const* avatar)
+{
+    strncpy(internal_.avatar, avatar, 128);
+    internal_.avatar[128 - 1] = '\0';
+}
+
+char const* User::GetAvatar() const
+{
+    return internal_.avatar;
+}
+
+void User::SetBot(bool bot)
+{
+    internal_.bot = bot;
+}
+
+bool User::GetBot() const
+{
+    return internal_.bot != 0;
+}
+
+void OAuth2Token::SetAccessToken(char const* accessToken)
+{
+    strncpy(internal_.access_token, accessToken, 128);
+    internal_.access_token[128 - 1] = '\0';
+}
+
+char const* OAuth2Token::GetAccessToken() const
+{
+    return internal_.access_token;
+}
+
+void OAuth2Token::SetScopes(char const* scopes)
+{
+    strncpy(internal_.scopes, scopes, 1024);
+    internal_.scopes[1024 - 1] = '\0';
+}
+
+char const* OAuth2Token::GetScopes() const
+{
+    return internal_.scopes;
+}
+
+void OAuth2Token::SetExpires(Timestamp expires)
+{
+    internal_.expires = expires;
+}
+
+Timestamp OAuth2Token::GetExpires() const
+{
+    return internal_.expires;
+}
+
+void ImageHandle::SetType(ImageType type)
+{
+    internal_.type = static_cast<EDiscordImageType>(type);
+}
+
+ImageType ImageHandle::GetType() const
+{
+    return static_cast<ImageType>(internal_.type);
+}
+
+void ImageHandle::SetId(std::int64_t id)
+{
+    internal_.id = id;
+}
+
+std::int64_t ImageHandle::GetId() const
+{
+    return internal_.id;
+}
+
+void ImageHandle::SetSize(std::uint32_t size)
+{
+    internal_.size = size;
+}
+
+std::uint32_t ImageHandle::GetSize() const
+{
+    return internal_.size;
+}
+
+void ImageDimensions::SetWidth(std::uint32_t width)
+{
+    internal_.width = width;
+}
+
+std::uint32_t ImageDimensions::GetWidth() const
+{
+    return internal_.width;
+}
+
+void ImageDimensions::SetHeight(std::uint32_t height)
+{
+    internal_.height = height;
+}
+
+std::uint32_t ImageDimensions::GetHeight() const
+{
+    return internal_.height;
+}
+
+void ActivityTimestamps::SetStart(Timestamp start)
+{
+    internal_.start = start;
+}
+
+Timestamp ActivityTimestamps::GetStart() const
+{
+    return internal_.start;
+}
+
+void ActivityTimestamps::SetEnd(Timestamp end)
+{
+    internal_.end = end;
+}
+
+Timestamp ActivityTimestamps::GetEnd() const
+{
+    return internal_.end;
+}
+
+void ActivityAssets::SetLargeImage(char const* largeImage)
+{
+    strncpy(internal_.large_image, largeImage, 128);
+    internal_.large_image[128 - 1] = '\0';
+}
+
+char const* ActivityAssets::GetLargeImage() const
+{
+    return internal_.large_image;
+}
+
+void ActivityAssets::SetLargeText(char const* largeText)
+{
+    strncpy(internal_.large_text, largeText, 128);
+    internal_.large_text[128 - 1] = '\0';
+}
+
+char const* ActivityAssets::GetLargeText() const
+{
+    return internal_.large_text;
+}
+
+void ActivityAssets::SetSmallImage(char const* smallImage)
+{
+    strncpy(internal_.small_image, smallImage, 128);
+    internal_.small_image[128 - 1] = '\0';
+}
+
+char const* ActivityAssets::GetSmallImage() const
+{
+    return internal_.small_image;
+}
+
+void ActivityAssets::SetSmallText(char const* smallText)
+{
+    strncpy(internal_.small_text, smallText, 128);
+    internal_.small_text[128 - 1] = '\0';
+}
+
+char const* ActivityAssets::GetSmallText() const
+{
+    return internal_.small_text;
+}
+
+void PartySize::SetCurrentSize(std::int32_t currentSize)
+{
+    internal_.current_size = currentSize;
+}
+
+std::int32_t PartySize::GetCurrentSize() const
+{
+    return internal_.current_size;
+}
+
+void PartySize::SetMaxSize(std::int32_t maxSize)
+{
+    internal_.max_size = maxSize;
+}
+
+std::int32_t PartySize::GetMaxSize() const
+{
+    return internal_.max_size;
+}
+
+void ActivityParty::SetId(char const* id)
+{
+    strncpy(internal_.id, id, 128);
+    internal_.id[128 - 1] = '\0';
+}
+
+char const* ActivityParty::GetId() const
+{
+    return internal_.id;
+}
+
+PartySize& ActivityParty::GetSize()
+{
+    return reinterpret_cast<PartySize&>(internal_.size);
+}
+
+PartySize const& ActivityParty::GetSize() const
+{
+    return reinterpret_cast<PartySize const&>(internal_.size);
+}
+
+void ActivitySecrets::SetMatch(char const* match)
+{
+    strncpy(internal_.match, match, 128);
+    internal_.match[128 - 1] = '\0';
+}
+
+char const* ActivitySecrets::GetMatch() const
+{
+    return internal_.match;
+}
+
+void ActivitySecrets::SetJoin(char const* join)
+{
+    strncpy(internal_.join, join, 128);
+    internal_.join[128 - 1] = '\0';
+}
+
+char const* ActivitySecrets::GetJoin() const
+{
+    return internal_.join;
+}
+
+void ActivitySecrets::SetSpectate(char const* spectate)
+{
+    strncpy(internal_.spectate, spectate, 128);
+    internal_.spectate[128 - 1] = '\0';
+}
+
+char const* ActivitySecrets::GetSpectate() const
+{
+    return internal_.spectate;
+}
+
+void Activity::SetType(ActivityType type)
+{
+    internal_.type = static_cast<EDiscordActivityType>(type);
+}
+
+ActivityType Activity::GetType() const
+{
+    return static_cast<ActivityType>(internal_.type);
+}
+
+void Activity::SetApplicationId(std::int64_t applicationId)
+{
+    internal_.application_id = applicationId;
+}
+
+std::int64_t Activity::GetApplicationId() const
+{
+    return internal_.application_id;
+}
+
+void Activity::SetName(char const* name)
+{
+    strncpy(internal_.name, name, 128);
+    internal_.name[128 - 1] = '\0';
+}
+
+char const* Activity::GetName() const
+{
+    return internal_.name;
+}
+
+void Activity::SetState(char const* state)
+{
+    strncpy(internal_.state, state, 128);
+    internal_.state[128 - 1] = '\0';
+}
+
+char const* Activity::GetState() const
+{
+    return internal_.state;
+}
+
+void Activity::SetDetails(char const* details)
+{
+    strncpy(internal_.details, details, 128);
+    internal_.details[128 - 1] = '\0';
+}
+
+char const* Activity::GetDetails() const
+{
+    return internal_.details;
+}
+
+ActivityTimestamps& Activity::GetTimestamps()
+{
+    return reinterpret_cast<ActivityTimestamps&>(internal_.timestamps);
+}
+
+ActivityTimestamps const& Activity::GetTimestamps() const
+{
+    return reinterpret_cast<ActivityTimestamps const&>(internal_.timestamps);
+}
+
+ActivityAssets& Activity::GetAssets()
+{
+    return reinterpret_cast<ActivityAssets&>(internal_.assets);
+}
+
+ActivityAssets const& Activity::GetAssets() const
+{
+    return reinterpret_cast<ActivityAssets const&>(internal_.assets);
+}
+
+ActivityParty& Activity::GetParty()
+{
+    return reinterpret_cast<ActivityParty&>(internal_.party);
+}
+
+ActivityParty const& Activity::GetParty() const
+{
+    return reinterpret_cast<ActivityParty const&>(internal_.party);
+}
+
+ActivitySecrets& Activity::GetSecrets()
+{
+    return reinterpret_cast<ActivitySecrets&>(internal_.secrets);
+}
+
+ActivitySecrets const& Activity::GetSecrets() const
+{
+    return reinterpret_cast<ActivitySecrets const&>(internal_.secrets);
+}
+
+void Activity::SetInstance(bool instance)
+{
+    internal_.instance = instance;
+}
+
+bool Activity::GetInstance() const
+{
+    return internal_.instance != 0;
+}
+
+void Presence::SetStatus(Status status)
+{
+    internal_.status = static_cast<EDiscordStatus>(status);
+}
+
+Status Presence::GetStatus() const
+{
+    return static_cast<Status>(internal_.status);
+}
+
+Activity& Presence::GetActivity()
+{
+    return reinterpret_cast<Activity&>(internal_.activity);
+}
+
+Activity const& Presence::GetActivity() const
+{
+    return reinterpret_cast<Activity const&>(internal_.activity);
+}
+
+void Relationship::SetType(RelationshipType type)
+{
+    internal_.type = static_cast<EDiscordRelationshipType>(type);
+}
+
+RelationshipType Relationship::GetType() const
+{
+    return static_cast<RelationshipType>(internal_.type);
+}
+
+User& Relationship::GetUser()
+{
+    return reinterpret_cast<User&>(internal_.user);
+}
+
+User const& Relationship::GetUser() const
+{
+    return reinterpret_cast<User const&>(internal_.user);
+}
+
+Presence& Relationship::GetPresence()
+{
+    return reinterpret_cast<Presence&>(internal_.presence);
+}
+
+Presence const& Relationship::GetPresence() const
+{
+    return reinterpret_cast<Presence const&>(internal_.presence);
+}
+
+void Lobby::SetId(LobbyId id)
+{
+    internal_.id = id;
+}
+
+LobbyId Lobby::GetId() const
+{
+    return internal_.id;
+}
+
+void Lobby::SetType(LobbyType type)
+{
+    internal_.type = static_cast<EDiscordLobbyType>(type);
+}
+
+LobbyType Lobby::GetType() const
+{
+    return static_cast<LobbyType>(internal_.type);
+}
+
+void Lobby::SetOwnerId(UserId ownerId)
+{
+    internal_.owner_id = ownerId;
+}
+
+UserId Lobby::GetOwnerId() const
+{
+    return internal_.owner_id;
+}
+
+void Lobby::SetSecret(LobbySecret secret)
+{
+    strncpy(internal_.secret, secret, 128);
+    internal_.secret[128 - 1] = '\0';
+}
+
+LobbySecret Lobby::GetSecret() const
+{
+    return internal_.secret;
+}
+
+void Lobby::SetCapacity(std::uint32_t capacity)
+{
+    internal_.capacity = capacity;
+}
+
+std::uint32_t Lobby::GetCapacity() const
+{
+    return internal_.capacity;
+}
+
+void Lobby::SetLocked(bool locked)
+{
+    internal_.locked = locked;
+}
+
+bool Lobby::GetLocked() const
+{
+    return internal_.locked != 0;
+}
+
+void FileStat::SetFilename(char const* filename)
+{
+    strncpy(internal_.filename, filename, 260);
+    internal_.filename[260 - 1] = '\0';
+}
+
+char const* FileStat::GetFilename() const
+{
+    return internal_.filename;
+}
+
+void FileStat::SetSize(std::uint64_t size)
+{
+    internal_.size = size;
+}
+
+std::uint64_t FileStat::GetSize() const
+{
+    return internal_.size;
+}
+
+void FileStat::SetLastModified(std::uint64_t lastModified)
+{
+    internal_.last_modified = lastModified;
+}
+
+std::uint64_t FileStat::GetLastModified() const
+{
+    return internal_.last_modified;
+}
+
+void Entitlement::SetId(Snowflake id)
+{
+    internal_.id = id;
+}
+
+Snowflake Entitlement::GetId() const
+{
+    return internal_.id;
+}
+
+void Entitlement::SetType(EntitlementType type)
+{
+    internal_.type = static_cast<EDiscordEntitlementType>(type);
+}
+
+EntitlementType Entitlement::GetType() const
+{
+    return static_cast<EntitlementType>(internal_.type);
+}
+
+void Entitlement::SetSkuId(Snowflake skuId)
+{
+    internal_.sku_id = skuId;
+}
+
+Snowflake Entitlement::GetSkuId() const
+{
+    return internal_.sku_id;
+}
+
+void SkuPrice::SetAmount(std::uint32_t amount)
+{
+    internal_.amount = amount;
+}
+
+std::uint32_t SkuPrice::GetAmount() const
+{
+    return internal_.amount;
+}
+
+void SkuPrice::SetCurrency(char const* currency)
+{
+    strncpy(internal_.currency, currency, 16);
+    internal_.currency[16 - 1] = '\0';
+}
+
+char const* SkuPrice::GetCurrency() const
+{
+    return internal_.currency;
+}
+
+void Sku::SetId(Snowflake id)
+{
+    internal_.id = id;
+}
+
+Snowflake Sku::GetId() const
+{
+    return internal_.id;
+}
+
+void Sku::SetType(SkuType type)
+{
+    internal_.type = static_cast<EDiscordSkuType>(type);
+}
+
+SkuType Sku::GetType() const
+{
+    return static_cast<SkuType>(internal_.type);
+}
+
+void Sku::SetName(char const* name)
+{
+    strncpy(internal_.name, name, 256);
+    internal_.name[256 - 1] = '\0';
+}
+
+char const* Sku::GetName() const
+{
+    return internal_.name;
+}
+
+SkuPrice& Sku::GetPrice()
+{
+    return reinterpret_cast<SkuPrice&>(internal_.price);
+}
+
+SkuPrice const& Sku::GetPrice() const
+{
+    return reinterpret_cast<SkuPrice const&>(internal_.price);
+}
+
+void InputMode::SetType(InputModeType type)
+{
+    internal_.type = static_cast<EDiscordInputModeType>(type);
+}
+
+InputModeType InputMode::GetType() const
+{
+    return static_cast<InputModeType>(internal_.type);
+}
+
+void InputMode::SetShortcut(char const* shortcut)
+{
+    strncpy(internal_.shortcut, shortcut, 256);
+    internal_.shortcut[256 - 1] = '\0';
+}
+
+char const* InputMode::GetShortcut() const
+{
+    return internal_.shortcut;
+}
+
+void UserAchievement::SetUserId(Snowflake userId)
+{
+    internal_.user_id = userId;
+}
+
+Snowflake UserAchievement::GetUserId() const
+{
+    return internal_.user_id;
+}
+
+void UserAchievement::SetAchievementId(Snowflake achievementId)
+{
+    internal_.achievement_id = achievementId;
+}
+
+Snowflake UserAchievement::GetAchievementId() const
+{
+    return internal_.achievement_id;
+}
+
+void UserAchievement::SetPercentComplete(std::uint8_t percentComplete)
+{
+    internal_.percent_complete = percentComplete;
+}
+
+std::uint8_t UserAchievement::GetPercentComplete() const
+{
+    return internal_.percent_complete;
+}
+
+void UserAchievement::SetUnlockedAt(DateTime unlockedAt)
+{
+    strncpy(internal_.unlocked_at, unlockedAt, 64);
+    internal_.unlocked_at[64 - 1] = '\0';
+}
+
+DateTime UserAchievement::GetUnlockedAt() const
+{
+    return internal_.unlocked_at;
+}
+
+Result LobbyTransaction::SetType(LobbyType type)
+{
+    auto result = internal_->set_type(internal_, static_cast<EDiscordLobbyType>(type));
+    return static_cast<Result>(result);
+}
+
+Result LobbyTransaction::SetOwner(UserId ownerId)
+{
+    auto result = internal_->set_owner(internal_, ownerId);
+    return static_cast<Result>(result);
+}
+
+Result LobbyTransaction::SetCapacity(std::uint32_t capacity)
+{
+    auto result = internal_->set_capacity(internal_, capacity);
+    return static_cast<Result>(result);
+}
+
+Result LobbyTransaction::SetMetadata(MetadataKey key, MetadataValue value)
+{
+    auto result =
+      internal_->set_metadata(internal_, const_cast<char*>(key), const_cast<char*>(value));
+    return static_cast<Result>(result);
+}
+
+Result LobbyTransaction::DeleteMetadata(MetadataKey key)
+{
+    auto result = internal_->delete_metadata(internal_, const_cast<char*>(key));
+    return static_cast<Result>(result);
+}
+
+Result LobbyTransaction::SetLocked(bool locked)
+{
+    auto result = internal_->set_locked(internal_, (locked ? 1 : 0));
+    return static_cast<Result>(result);
+}
+
+Result LobbyMemberTransaction::SetMetadata(MetadataKey key, MetadataValue value)
+{
+    auto result =
+      internal_->set_metadata(internal_, const_cast<char*>(key), const_cast<char*>(value));
+    return static_cast<Result>(result);
+}
+
+Result LobbyMemberTransaction::DeleteMetadata(MetadataKey key)
+{
+    auto result = internal_->delete_metadata(internal_, const_cast<char*>(key));
+    return static_cast<Result>(result);
+}
+
+Result LobbySearchQuery::Filter(MetadataKey key,
+                                LobbySearchComparison comparison,
+                                LobbySearchCast cast,
+                                MetadataValue value)
+{
+    auto result = internal_->filter(internal_,
+                                    const_cast<char*>(key),
+                                    static_cast<EDiscordLobbySearchComparison>(comparison),
+                                    static_cast<EDiscordLobbySearchCast>(cast),
+                                    const_cast<char*>(value));
+    return static_cast<Result>(result);
+}
+
+Result LobbySearchQuery::Sort(MetadataKey key, LobbySearchCast cast, MetadataValue value)
+{
+    auto result = internal_->sort(internal_,
+                                  const_cast<char*>(key),
+                                  static_cast<EDiscordLobbySearchCast>(cast),
+                                  const_cast<char*>(value));
+    return static_cast<Result>(result);
+}
+
+Result LobbySearchQuery::Limit(std::uint32_t limit)
+{
+    auto result = internal_->limit(internal_, limit);
+    return static_cast<Result>(result);
+}
+
+Result LobbySearchQuery::Distance(LobbySearchDistance distance)
+{
+    auto result =
+      internal_->distance(internal_, static_cast<EDiscordLobbySearchDistance>(distance));
+    return static_cast<Result>(result);
+}
+
+} // namespace discord
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/discord/user_manager.cpp b/engine/src/ext/discord/user_manager.cpp
new file mode 100644
index 00000000..506d154a
--- /dev/null
+++ b/engine/src/ext/discord/user_manager.cpp
@@ -0,0 +1,82 @@
+#if defined(UF_USE_DISCORD)
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <discord/user_manager.h>
+
+#include <discord/core.h>
+
+#include <cstring>
+#include <memory>
+
+namespace discord {
+
+class UserEvents final {
+public:
+    static void OnCurrentUserUpdate(void* callbackData)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->UserManager();
+        module.OnCurrentUserUpdate();
+    }
+};
+
+IDiscordUserEvents UserManager::events_{
+  &UserEvents::OnCurrentUserUpdate,
+};
+
+Result UserManager::GetCurrentUser(User* currentUser)
+{
+    if (!currentUser) {
+        return Result::InternalError;
+    }
+
+    auto result =
+      internal_->get_current_user(internal_, reinterpret_cast<DiscordUser*>(currentUser));
+    return static_cast<Result>(result);
+}
+
+void UserManager::GetUser(UserId userId, std::function<void(Result, User const&)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result, DiscordUser* user) -> void {
+        std::unique_ptr<std::function<void(Result, User const&)>> cb(
+          reinterpret_cast<std::function<void(Result, User const&)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result), *reinterpret_cast<User const*>(user));
+    };
+    std::unique_ptr<std::function<void(Result, User const&)>> cb{};
+    cb.reset(new std::function<void(Result, User const&)>(std::move(callback)));
+    internal_->get_user(internal_, userId, cb.release(), wrapper);
+}
+
+Result UserManager::GetCurrentUserPremiumType(PremiumType* premiumType)
+{
+    if (!premiumType) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->get_current_user_premium_type(
+      internal_, reinterpret_cast<EDiscordPremiumType*>(premiumType));
+    return static_cast<Result>(result);
+}
+
+Result UserManager::CurrentUserHasFlag(UserFlag flag, bool* hasFlag)
+{
+    if (!hasFlag) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->current_user_has_flag(
+      internal_, static_cast<EDiscordUserFlag>(flag), reinterpret_cast<bool*>(hasFlag));
+    return static_cast<Result>(result);
+}
+
+} // namespace discord
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/discord/voice_manager.cpp b/engine/src/ext/discord/voice_manager.cpp
new file mode 100644
index 00000000..d642d910
--- /dev/null
+++ b/engine/src/ext/discord/voice_manager.cpp
@@ -0,0 +1,126 @@
+#if defined(UF_USE_DISCORD)
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <discord/voice_manager.h>
+
+#include <discord/core.h>
+
+#include <cstring>
+#include <memory>
+
+namespace discord {
+
+class VoiceEvents final {
+public:
+    static void OnSettingsUpdate(void* callbackData)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->VoiceManager();
+        module.OnSettingsUpdate();
+    }
+};
+
+IDiscordVoiceEvents VoiceManager::events_{
+  &VoiceEvents::OnSettingsUpdate,
+};
+
+Result VoiceManager::GetInputMode(InputMode* inputMode)
+{
+    if (!inputMode) {
+        return Result::InternalError;
+    }
+
+    auto result =
+      internal_->get_input_mode(internal_, reinterpret_cast<DiscordInputMode*>(inputMode));
+    return static_cast<Result>(result);
+}
+
+void VoiceManager::SetInputMode(InputMode inputMode, std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->set_input_mode(
+      internal_, *reinterpret_cast<DiscordInputMode const*>(&inputMode), cb.release(), wrapper);
+}
+
+Result VoiceManager::IsSelfMute(bool* mute)
+{
+    if (!mute) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->is_self_mute(internal_, reinterpret_cast<bool*>(mute));
+    return static_cast<Result>(result);
+}
+
+Result VoiceManager::SetSelfMute(bool mute)
+{
+    auto result = internal_->set_self_mute(internal_, (mute ? 1 : 0));
+    return static_cast<Result>(result);
+}
+
+Result VoiceManager::IsSelfDeaf(bool* deaf)
+{
+    if (!deaf) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->is_self_deaf(internal_, reinterpret_cast<bool*>(deaf));
+    return static_cast<Result>(result);
+}
+
+Result VoiceManager::SetSelfDeaf(bool deaf)
+{
+    auto result = internal_->set_self_deaf(internal_, (deaf ? 1 : 0));
+    return static_cast<Result>(result);
+}
+
+Result VoiceManager::IsLocalMute(Snowflake userId, bool* mute)
+{
+    if (!mute) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->is_local_mute(internal_, userId, reinterpret_cast<bool*>(mute));
+    return static_cast<Result>(result);
+}
+
+Result VoiceManager::SetLocalMute(Snowflake userId, bool mute)
+{
+    auto result = internal_->set_local_mute(internal_, userId, (mute ? 1 : 0));
+    return static_cast<Result>(result);
+}
+
+Result VoiceManager::GetLocalVolume(Snowflake userId, std::uint8_t* volume)
+{
+    if (!volume) {
+        return Result::InternalError;
+    }
+
+    auto result =
+      internal_->get_local_volume(internal_, userId, reinterpret_cast<uint8_t*>(volume));
+    return static_cast<Result>(result);
+}
+
+Result VoiceManager::SetLocalVolume(Snowflake userId, std::uint8_t volume)
+{
+    auto result = internal_->set_local_volume(internal_, userId, volume);
+    return static_cast<Result>(result);
+}
+
+} // namespace discord
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/freetype/freetype.cpp b/engine/src/ext/freetype/freetype.cpp
new file mode 100644
index 00000000..5e9b20d7
--- /dev/null
+++ b/engine/src/ext/freetype/freetype.cpp
@@ -0,0 +1,108 @@
+#include <iostream>
+#if UF_USE_FREETYPE
+#include <uf/ext/freetype/freetype.h>
+
+ext::freetype::Library ext::freetype::library;
+
+UF_API ext::freetype::Library::Library() : loaded(false) {
+	ext::freetype::initialize();
+}
+ext::freetype::Library::~Library() {
+	this->loaded = false;
+	ext::freetype::terminate();
+}
+ext::freetype::Glyph::~Glyph() {
+	ext::freetype::destroy(*this);
+}
+
+UF_API bool ext::freetype::initialize() {
+	int error = 0;
+	if ( (error = FT_Init_FreeType( &ext::freetype::library.library ) )) {
+		std::cout << "Error #" << ext::freetype::getError(error) << ": FreeType failed to initialize" << std::endl;
+		return false;
+	}
+	ext::freetype::library.loaded = true;
+	return true;
+}
+UF_API bool ext::freetype::initialized() {
+	return ext::freetype::library.loaded;
+}
+UF_API void ext::freetype::terminate() {
+	FT_Done_FreeType(ext::freetype::library.library);
+}
+
+UF_API ext::freetype::Glyph ext::freetype::initialize( const std::string& font ) {
+	if ( !ext::freetype::initialized() ) ext::freetype::initialize();
+	ext::freetype::Glyph glyph;
+	int error = 0;
+	if ( (error = FT_New_Face( ext::freetype::library.library, font.c_str(), 0, &glyph.face )) ) {
+		std::cout << "Error #" <<  ext::freetype::getError(error) << ": FreeType failed to load file `" << font << "`" << std::endl;
+	}
+	if ( (error = FT_Select_Charmap( glyph.face, FT_ENCODING_UNICODE )) ) {
+		std::cout << "Error #" <<  ext::freetype::getError(error) << ": FreeType failed to load file `" << font << "`" << std::endl;
+	}
+	return glyph;
+}
+UF_API bool ext::freetype::initialize( ext::freetype::Glyph& glyph, const std::string& font ) {
+	if ( !ext::freetype::initialized() ) ext::freetype::initialize();
+	int error = 0;
+	if ( (error = FT_New_Face( ext::freetype::library.library, font.c_str(), 0, &glyph.face )) ) {
+		std::cout << "Error #" <<  ext::freetype::getError(error) << ": FreeType failed to load file `" << font << "`" << std::endl;
+		return false;
+	}
+	if ( (error = FT_Select_Charmap( glyph.face, FT_ENCODING_UNICODE )) ) {
+		std::cout << "Error #" <<  ext::freetype::getError(error) << ": FreeType failed to load file `" << font << "`" << std::endl;
+		return false;
+	}
+	return true;
+}
+UF_API void ext::freetype::destroy( ext::freetype::Glyph& glyph ) {
+	FT_Done_Face( glyph.face );
+}
+
+UF_API void ext::freetype::setPixelSizes( ext::freetype::Glyph& glyph, int height ) {
+	FT_Set_Pixel_Sizes( glyph.face, 0, height );
+}
+UF_API void ext::freetype::setPixelSizes( ext::freetype::Glyph& glyph, int width, int height ) {
+	FT_Set_Pixel_Sizes( glyph.face, width, height );
+}
+
+UF_API bool ext::freetype::load( ext::freetype::Glyph& glyph, unsigned long c ) {
+	int error = 0;
+	if ( (error = FT_Load_Char(glyph.face, c, FT_LOAD_RENDER) )) {
+		std::cout << "Error #" << ext::freetype::getError(error) << ": FreeType failed to load glyph `" << c << "`" << std::endl;
+		return false;
+	}
+	return true;
+}
+UF_API bool ext::freetype::load( ext::freetype::Glyph& glyph, const uf::String& string ) {
+	unsigned long c = string.translate<uf::locale::Utf32>().at(0);
+	int error = 0;
+	if ( (error = FT_Load_Char(glyph.face, FT_Get_Char_Index(glyph.face, c), FT_LOAD_RENDER) )) {
+		std::cout << "Error #" << ext::freetype::getError(error) << ": FreeType failed to load glyph `" << c << "`" << std::endl;
+		return false;
+	}
+	return true;
+}
+
+UF_API std::string ext::freetype::getError( int error ) {
+	#undef FTERRORS_H_
+	#define FT_ERRORDEF( e, v, s )  { e, s },
+	#define FT_ERROR_START_LIST     {
+	#define FT_ERROR_END_LIST       { 0, NULL } };
+
+	const struct FTErrors {
+		int err_code;
+		const char* err_msg;
+	} ft_errors[] =
+	#include FT_ERRORS_H
+
+	for ( int i = 0; i < sizeof(ft_errors) / sizeof(FTErrors); ++i ) {
+	//	std::cout << ft_errors[i].err_msg << std::endl;
+		if ( ft_errors[i].err_code == error )
+			return ft_errors[i].err_msg;
+	}
+
+	return ft_errors[0].err_msg;
+}
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/glfw/glfw.cpp b/engine/src/ext/glfw/glfw.cpp
new file mode 100644
index 00000000..e16e75d2
--- /dev/null
+++ b/engine/src/ext/glfw/glfw.cpp
@@ -0,0 +1,72 @@
+#if defined(UF_USE_GLFW) && UF_USE_GLFW == 1
+
+#include <uf/ext/glfw/glfw.h>
+#include <uf/utils/window/window.h>
+#include <uf/ext/vulkan/vulkan.h>
+#include <uf/utils/hook/hook.h>
+#include <uf/utils/serialize/serializer.h>
+
+namespace {
+	static void framebufferResizeCallback(GLFWwindow* window, int width, int height) {
+	// 	auto klass = reinterpret_cast<ext::glfw::Window*>(glfwGetWindowUserPointer(window));
+		ext::vulkan::resizedFramebuffer = true;
+	}
+	static void keyCallback(GLFWwindow* window, int key, int scancode, int action, int mods) {
+		if ( key == GLFW_KEY_W ) {
+			uf::Serializer json;
+			std::string hook = "window:Key.W";
+			json["type"] = hook;
+			json["invoker"] = "os";
+			json["state"] = action != 0;
+			uf::hooks.call( hook, json );
+		}
+	}
+}
+
+void ext::glfw::Window::initialize( size_t width, size_t height, const std::string& title ) {
+	glfwInit();
+	glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
+	this->m_window = glfwCreateWindow(this->m_width = width, this->m_height = height, (this->m_title = title).c_str(), nullptr, nullptr);
+	glfwSetWindowUserPointer(this->m_window, this);
+	glfwSetFramebufferSizeCallback(this->m_window, framebufferResizeCallback);
+	glfwSetKeyCallback(this->m_window, keyCallback);
+}
+void ext::glfw::Window::createSurface( VkInstance instance, VkSurfaceKHR& surface ) {
+	if ( glfwCreateWindowSurface( instance, this->m_window, nullptr, &surface ) != VK_SUCCESS )
+		UF_EXCEPTION("failed to create window surface!");
+}
+bool ext::glfw::Window::loop() {
+	return !glfwWindowShouldClose( this->m_window );
+}
+void ext::glfw::Window::poll() {
+	glfwPollEvents();
+}
+void ext::glfw::Window::destroy() {
+	glfwDestroyWindow( this->m_window );
+	glfwTerminate();
+}
+bool ext::glfw::Window::minimized() {
+	int width = 0;
+	int height = 0;
+	glfwGetFramebufferSize(this->m_window, &width, &height);
+	glfwWaitEvents();
+	return width == 0 || height == 0;
+}
+ext::glfw::Window::operator GLFWwindow*(){
+	return this->m_window;
+}
+std::vector<const char*> ext::glfw::Window::getExtensions( bool enableValidationLayers ) {
+	uint32_t glfwExtensionCount = 0;
+	const char** glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
+	std::vector<const char*> supportedExtensions(glfwExtensions, glfwExtensions + glfwExtensionCount);
+	
+	if ( enableValidationLayers ) supportedExtensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
+/*
+	std::cout << "available GLFW extensions ("<< glfwExtensionCount <<"):" << std::endl;
+	for ( auto i = 0; i < glfwExtensionCount; ++i ) {
+		std::cout << "\t" << glfwExtensions[i] << std::endl;
+	}
+*/
+	return supportedExtensions;
+}
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/gltf/gltf.cpp b/engine/src/ext/gltf/gltf.cpp
new file mode 100644
index 00000000..a20003c9
--- /dev/null
+++ b/engine/src/ext/gltf/gltf.cpp
@@ -0,0 +1,486 @@
+#include <uf/config.h>
+
+#define TINYGLTF_IMPLEMENTATION
+
+#if UF_JSON_USE_NLOHMANN
+	#define TINYGLTF_NO_INCLUDE_JSON
+#endif
+#if UF_USE_DRACO
+	#define TINYGLTF_ENABLE_DRACO
+#endif
+
+#include <uf/utils/string/ext.h>
+
+#include <uf/utils/thread/thread.h>
+#include <uf/utils/serialize/serializer.h>
+#include <uf/utils/image/atlas.h>
+#include <uf/utils/string/hash.h>
+
+#include <gltf/tiny_gltf.h>
+#include <uf/ext/gltf/gltf.h>
+
+namespace {
+	decltype(auto) getWrapMode(int32_t wrapMode) {
+		switch (wrapMode) {
+			case 10497: return uf::renderer::enums::AddressMode::REPEAT;
+			case 33071: return uf::renderer::enums::AddressMode::CLAMP_TO_EDGE;
+			case 33648: return uf::renderer::enums::AddressMode::MIRRORED_REPEAT;
+			default: return uf::renderer::enums::AddressMode::REPEAT;
+		}
+	}
+
+	decltype(auto) getFilterMode(int32_t filterMode) {
+		switch (filterMode) {
+			case 9728: return uf::renderer::enums::Filter::NEAREST;
+			case 9984: return uf::renderer::enums::Filter::NEAREST;
+			case 9985: return uf::renderer::enums::Filter::NEAREST;
+			case 9729: return uf::renderer::enums::Filter::LINEAR;
+			case 9986: return uf::renderer::enums::Filter::LINEAR;
+			case 9987: return uf::renderer::enums::Filter::LINEAR;
+			default: return uf::renderer::enums::Filter::LINEAR;
+		}
+	}
+}
+
+namespace {
+	int32_t loadNode( const tinygltf::Model& model, pod::Graph& graph, int32_t nodeIndex, int32_t parentIndex );
+
+	int32_t loadNodes( const tinygltf::Model& model, pod::Graph& graph, const std::vector<int>& nodes, int32_t nodeIndex ) {
+		graph.nodes[nodeIndex].children.reserve( nodes.size() );
+		for ( auto i : nodes ) {
+			int32_t childIndex = loadNode( model, graph, i, nodeIndex );
+			if ( 0 <= childIndex && childIndex < graph.nodes.size() && childIndex != nodeIndex &&
+				std::find( graph.nodes[nodeIndex].children.begin(), graph.nodes[nodeIndex].children.end(), childIndex ) == graph.nodes[nodeIndex].children.end()
+			 ) {
+				graph.nodes[nodeIndex].children.emplace_back(childIndex);
+			}
+		}
+		return nodeIndex;
+	}
+	int32_t loadNode( const tinygltf::Model& model, pod::Graph& graph, int32_t nodeIndex, int32_t parentIndex ) {
+		if ( nodeIndex < 0 ) return nodeIndex;
+		auto& node = model.nodes[nodeIndex];
+
+		graph.nodes[nodeIndex].parent = parentIndex;
+		graph.nodes[nodeIndex].index = nodeIndex;
+		graph.nodes[nodeIndex].skin = node.skin;
+
+		graph.nodes[nodeIndex].name = node.name;
+
+		auto& transform = graph.nodes[nodeIndex].transform;
+		if ( node.translation.size() == 3 ) {
+			transform.position.x = node.translation[0];
+			transform.position.y = node.translation[1];
+			transform.position.z = node.translation[2];
+		} else {
+			transform.position = { 0, 0, 0 };
+		}
+		if ( !(graph.mode & ext::gltf::LoadMode::INVERT) ) {
+			transform.position.x *= -1;
+		}
+		if ( node.rotation.size() == 4 ) {
+			transform.orientation.x = node.rotation[0];
+			transform.orientation.y = node.rotation[1];
+			transform.orientation.z = node.rotation[2];
+			transform.orientation.w = node.rotation[3];
+		} else {
+			transform.orientation = { 0, 0, 0, 1 };
+		}
+		if ( node.scale.size() == 3 ) {
+			transform.scale.x = node.scale[0];
+			transform.scale.y = node.scale[1];
+			transform.scale.z = node.scale[2];
+		} else {
+			transform.scale = { 1, 1, 1 };
+		}
+		if ( node.matrix.size() == 16 ) {
+			for ( size_t i = 0; i < node.matrix.size(); ++i ) transform.model[i] = node.matrix[i];
+		} else {
+			transform.model = uf::matrix::identity();
+		}
+		if ( 0 <= parentIndex && parentIndex < graph.nodes.size() && nodeIndex != parentIndex ) {
+			transform.reference = &graph.nodes[parentIndex].transform;
+		}
+		if ( node.children.size() > 0 ) {
+			loadNodes( model, graph, node.children, nodeIndex );
+		}
+		if ( node.mesh > -1 ) {
+			graph.nodes[nodeIndex].mesh = node.mesh;
+		}
+		return nodeIndex;
+	}
+}
+
+pod::Graph ext::gltf::load( const std::string& filename, ext::gltf::load_mode_t mode, const uf::Serializer& metadata ) {
+	std::string extension = uf::io::extension( filename );
+	if ( extension != "glb" && extension != "gltf" ) {
+		return uf::graph::load( filename, mode, metadata );
+	}
+
+	tinygltf::Model model;
+	tinygltf::TinyGLTF loader;
+
+	std::string warn, err;
+	bool ret = extension == "glb" ? loader.LoadBinaryFromFile(&model, &err, &warn, filename) : loader.LoadASCIIFromFile(&model, &err, &warn, filename);
+
+	pod::Graph graph;
+	graph.mode = mode;
+	graph.metadata = metadata;
+
+	if ( !warn.empty() ) UF_DEBUG_MSG("glTF warning: " << warn);
+	if ( !err.empty() ) UF_DEBUG_MSG("glTF error: " << err);
+	if ( !ret ) { UF_DEBUG_MSG("glTF error: failed to parse file: " << filename);
+		return graph;
+	}
+
+	// load samplers
+	{
+		graph.samplers.reserve(model.samplers.size());
+		for ( auto& s : model.samplers ) {
+			auto& sampler = graph.samplers.emplace_back();
+			sampler.descriptor.filter.min = getFilterMode( s.minFilter );
+			sampler.descriptor.filter.mag = getFilterMode( s.magFilter );
+			sampler.descriptor.addressMode.u = getWrapMode( s.wrapS );
+			sampler.descriptor.addressMode.v = getWrapMode( s.wrapT );
+			sampler.descriptor.addressMode.w = sampler.descriptor.addressMode.v;
+		}
+	}
+
+	// load images
+	{
+		graph.images.reserve(model.images.size());
+		for ( auto& i : model.images ) {
+			auto& image = graph.images.emplace_back();
+			image.loadFromBuffer( &i.image[0], {i.width, i.height}, 8, i.component, true );
+		}
+	}
+	// generate atlas
+	if ( mode & ext::gltf::LoadMode::ATLAS ) { if ( graph.atlas ) delete graph.atlas; graph.atlas = new uf::Atlas;
+		auto& atlas = *graph.atlas;
+		atlas.generate( graph.images );
+	}
+	// load textures
+	{
+		graph.textures.reserve(model.textures.size());
+		for ( auto& t : model.textures ) {
+			auto& texture = graph.textures.emplace_back();
+			texture.name = t.name;
+
+			texture.storage.index = t.source;
+			texture.storage.sampler = t.sampler;
+			if ( graph.atlas ) {
+				auto& atlas = *graph.atlas;
+				auto atlasMin = atlas.mapUv( {0, 0}, t.source );
+				auto atlasMax = atlas.mapUv( {1, 1}, t.source );
+
+				texture.storage.lerp = {
+					atlasMin.x,
+					atlasMin.y,
+
+					atlasMax.x,
+					atlasMax.y,
+				};
+			}
+		}
+	}
+	// load materials
+	{
+		graph.materials.reserve(model.materials.size());
+		for ( auto& m : model.materials ) {
+			auto& material = graph.materials.emplace_back();
+			material.name = m.name;
+			material.storage.indexAlbedo = m.pbrMetallicRoughness.baseColorTexture.index;
+			material.storage.indexNormal = m.normalTexture.index;
+			material.storage.indexEmissive = m.emissiveTexture.index;
+			material.storage.indexOcclusion = m.occlusionTexture.index;
+			material.storage.indexMetallicRoughness = m.pbrMetallicRoughness.metallicRoughnessTexture.index;
+			material.storage.colorBase = {
+				m.pbrMetallicRoughness.baseColorFactor[0],
+				m.pbrMetallicRoughness.baseColorFactor[1],
+				m.pbrMetallicRoughness.baseColorFactor[2],
+				m.pbrMetallicRoughness.baseColorFactor[3],
+			};
+			material.storage.colorEmissive = {
+				m.emissiveFactor[0],
+				m.emissiveFactor[1],
+				m.emissiveFactor[2],
+				0
+			};
+
+			material.storage.factorMetallic = m.pbrMetallicRoughness.metallicFactor;
+			material.storage.factorRoughness = m.pbrMetallicRoughness.roughnessFactor;
+			material.storage.factorOcclusion = m.occlusionTexture.strength;
+			material.storage.factorAlphaCutoff = m.alphaCutoff;
+
+			material.alphaMode = m.alphaMode;
+			if ( material.alphaMode == "OPAQUE" ) {
+				material.storage.modeAlpha = 0;
+			} else if ( material.alphaMode == "BLEND" ) {
+				material.storage.modeAlpha = 1;
+			} else if ( material.alphaMode == "MASK" ) {
+				material.storage.modeAlpha = 2;
+			} else {
+				UF_DEBUG_MSG("Unhandled alpha mode: " << material.alphaMode)
+			}
+			if ( m.doubleSided && graph.metadata["cull mode"].as<std::string>() == "auto" ) {
+				graph.metadata["cull mode"] = "none";
+			}
+		}
+	}
+	// load meshes
+	{
+		graph.meshes.reserve(model.meshes.size());
+		for ( auto& m : model.meshes ) {
+			auto& mesh = graph.meshes.emplace_back();
+			pod::DrawCall drawCall; //auto& drawCall = graph.nodes[nodeIndex].drawCall;
+		//	drawCall.name = node.name;
+			drawCall.verticesIndex = mesh.vertices.size();
+			drawCall.indicesIndex = mesh.indices.size();
+			drawCall.vertices = 0;
+			drawCall.indices = 0;
+			for ( auto& primitive : m.primitives ) {
+				pod::DrawCall dc; //auto& dc = graph.nodes[nodeIndex].primitives.emplace_back();
+				dc.verticesIndex = mesh.vertices.size();
+				dc.indicesIndex = mesh.indices.size();
+
+				struct Attribute {
+					std::string name = "";
+					size_t components = 1;
+					std::vector<float> buffer;
+					std::vector<uint16_t> indices;
+				};
+				std::unordered_map<std::string, Attribute> attributes = {
+					{"POSITION", {}},
+					{"TEXCOORD_0", {}},
+					{"NORMAL", {}},
+					{"TANGENT", {}},
+					{"JOINTS_0", {}},
+					{"WEIGHTS_0", {}},
+				};
+
+				for ( auto& kv : attributes ) {
+					auto& attribute = kv.second;
+					attribute.name = kv.first;
+					auto it = primitive.attributes.find(attribute.name);
+					if ( it == primitive.attributes.end() ) continue;
+
+					auto& accessor = model.accessors[it->second];
+					auto& view = model.bufferViews[accessor.bufferView];
+					
+					if ( attribute.name == "POSITION" ) {
+						dc.vertices = accessor.count;
+						pod::Vector3f minCorner = { accessor.minValues[0], accessor.minValues[1], accessor.minValues[2] };
+						pod::Vector3f maxCorner = { accessor.maxValues[0], accessor.maxValues[1], accessor.maxValues[2] };
+
+						pod::Vector3f origin = (maxCorner + minCorner) * 0.5f;
+						pod::Vector3f size = (maxCorner - minCorner) * 0.5f;
+					}
+					if ( attribute.name == "JOINTS_0" ) {
+						auto* buffer = reinterpret_cast<const uint16_t*>(&(model.buffers[view.buffer].data[accessor.byteOffset + view.byteOffset]));
+						attribute.components = accessor.ByteStride(view) / sizeof(uint16_t);
+						size_t len = accessor.count * attribute.components;
+						attribute.indices.reserve( len );
+						attribute.indices.insert( attribute.indices.end(), &buffer[0], &buffer[len] );
+					} else {
+						auto* buffer = reinterpret_cast<const float*>(&(model.buffers[view.buffer].data[accessor.byteOffset + view.byteOffset]));
+						attribute.components = accessor.ByteStride(view) / sizeof(float);
+						size_t len = accessor.count * attribute.components;
+						attribute.buffer.reserve( len );
+						attribute.buffer.insert( attribute.buffer.end(), &buffer[0], &buffer[len] );
+					}
+				}
+
+				mesh.vertices.reserve( dc.vertices + dc.verticesIndex );
+				for ( size_t i = 0; i < dc.vertices; ++i ) {
+					#define ITERATE_ATTRIBUTE( name, member )\
+						if ( !attributes[name].indices.empty() ) { \
+							for ( size_t j = 0; j < attributes[name].components; ++j )\
+								vertex.member[j] = attributes[name].indices[i * attributes[name].components + j];\
+						} else if ( !attributes[name].buffer.empty() ) { \
+							for ( size_t j = 0; j < attributes[name].components; ++j )\
+								vertex.member[j] = attributes[name].buffer[i * attributes[name].components + j];\
+						}
+
+					auto& vertex = mesh.vertices.emplace_back();
+					ITERATE_ATTRIBUTE("POSITION", position);
+					ITERATE_ATTRIBUTE("TEXCOORD_0", uv);
+					ITERATE_ATTRIBUTE("NORMAL", normal);
+					ITERATE_ATTRIBUTE("TANGENT", tangent);
+					ITERATE_ATTRIBUTE("JOINTS_0", joints);
+					ITERATE_ATTRIBUTE("WEIGHTS_0", weights);
+
+					#undef ITERATE_ATTRIBUTE
+					vertex.id.x = 0;
+					vertex.id.y = primitive.material;
+
+					// required due to reverse-Z projection matrix flipping the X axis as well
+					// default is to proceed with this
+					if ( !(graph.mode & ext::gltf::LoadMode::INVERT) ){
+						vertex.position.x *= -1;
+						vertex.normal.x *= -1;
+						vertex.tangent.x *= -1;
+					}
+				}
+
+				if ( primitive.indices > -1 ) {
+					auto& accessor = model.accessors[primitive.indices];
+					auto& view = model.bufferViews[accessor.bufferView];
+					auto& buffer = model.buffers[view.buffer];
+
+					dc.indices = static_cast<uint32_t>(accessor.count);
+					mesh.indices.reserve( dc.indices + dc.indicesIndex );
+					const void* pointer = &(buffer.data[accessor.byteOffset + view.byteOffset]);
+
+					#define COPY_INDICES()\
+						for (size_t index = 0; index < dc.indices; index++)\
+								mesh.indices.emplace_back(buf[index] + dc.verticesIndex);
+
+					switch (accessor.componentType) {
+						case TINYGLTF_PARAMETER_TYPE_UNSIGNED_INT: {
+							auto* buf = static_cast<const uint32_t*>( pointer );
+							COPY_INDICES()
+							break;
+						}
+						case TINYGLTF_PARAMETER_TYPE_UNSIGNED_SHORT: {
+							auto* buf = static_cast<const uint16_t*>( pointer );
+							COPY_INDICES()
+							break;
+						}
+						case TINYGLTF_PARAMETER_TYPE_UNSIGNED_BYTE: {
+							auto* buf = static_cast<const uint8_t*>( pointer );
+							COPY_INDICES()
+							break;
+						}
+					}
+					#undef COPY_INDICES
+				}
+
+				drawCall.vertices += dc.vertices;
+				drawCall.indices += dc.indices;
+				
+				mesh.updateDescriptor();
+			/*
+				UF_DEBUG_MSG( "Indices: " << mesh.indices.size() << " | Vertices: " << mesh.vertices.size() );
+				size_t o = graph.metadata["mesh optimization"].is<size_t>() ? graph.metadata["mesh optimization"].as<size_t>() : SIZE_MAX;
+				if ( o > 0 ) mesh.optimize(o);
+				UF_DEBUG_MSG( "Indices: " << mesh.indices.size() << " | Vertices: " << mesh.vertices.size() );
+			*/
+			}
+		}
+	}
+	// load node information/meshes
+	{
+		const auto& scene = model.scenes[model.defaultScene > -1 ? model.defaultScene : 0];
+		graph.nodes.resize( model.nodes.size() );
+		graph.root.index = -1;
+		graph.root.children.reserve( scene.nodes.size() );
+		for ( auto i : scene.nodes ) {
+			size_t childIndex = loadNode( model, graph, i, -1 );
+			graph.root.children.emplace_back(childIndex);
+		}
+	}
+	// load lights
+	{
+		for ( auto& l : model.lights ) {
+			auto& light = graph.lights.emplace_back();
+			light.name = l.name;
+			light.color = { l.color[0], l.color[1], l.color[2], };
+			light.intensity = l.intensity;
+			light.range = l.range;
+		}
+	}
+	// load skins
+	{
+		graph.skins.reserve( model.skins.size() );
+		for ( auto& s : model.skins ) {
+			auto& skin = graph.skins.emplace_back();
+			skin.name = s.name;			
+			if ( s.inverseBindMatrices > -1 ) {
+				const tinygltf::Accessor& accessor = model.accessors[s.inverseBindMatrices];
+				const tinygltf::BufferView& view = model.bufferViews[accessor.bufferView];
+				const tinygltf::Buffer& buffer = model.buffers[view.buffer];
+				const void* dataPtr = &buffer.data[accessor.byteOffset + view.byteOffset];
+				const pod::Matrix4f* buf = static_cast<const pod::Matrix4f*>(dataPtr);
+					
+				skin.inverseBindMatrices.reserve(accessor.count);
+				for ( size_t i = 0; i < accessor.count; ++i ) skin.inverseBindMatrices.emplace_back( buf[i] );
+			}
+
+			skin.joints.reserve( s.joints.size() );
+			for ( auto& joint : s.joints ) skin.joints.emplace_back( joint );
+		}
+	}
+	// load animations
+	{
+		graph.animations.reserve( model.animations.size() );
+		for ( auto& a : model.animations ) {
+			auto& animation = graph.animations[a.name];
+			animation.name = a.name;
+
+			// load samplers
+			animation.samplers.reserve( a.samplers.size() );
+			for ( auto& s : a.samplers ) {
+				auto& sampler = animation.samplers.emplace_back();
+				sampler.interpolator = s.interpolation;
+				{
+					const tinygltf::Accessor& accessor = model.accessors[s.input];
+					const tinygltf::BufferView& view = model.bufferViews[accessor.bufferView];
+					const tinygltf::Buffer& buffer = model.buffers[view.buffer];
+					const void* dataPtr = &buffer.data[accessor.byteOffset + view.byteOffset];
+					const float* buf = static_cast<const float*>(dataPtr);
+					
+					sampler.inputs.reserve( accessor.count );
+					for ( size_t i = 0; i < accessor.count; ++i )
+						sampler.inputs.emplace_back( buf[i] );
+
+					for ( auto& input : sampler.inputs ) {
+						if ( input < animation.start ) animation.start = input;
+						else if ( input > animation.end ) animation.end = input;
+					}
+				}
+				{
+					const tinygltf::Accessor& accessor = model.accessors[s.output];
+					const tinygltf::BufferView& view = model.bufferViews[accessor.bufferView];
+					const tinygltf::Buffer& buffer = model.buffers[view.buffer];
+					const void* dataPtr = &buffer.data[accessor.byteOffset + view.byteOffset];
+					const float* buf = static_cast<const float*>(dataPtr);
+
+					sampler.outputs.reserve( accessor.count );
+					size_t components = accessor.ByteStride(view) / sizeof(float);
+
+					for ( size_t i = 0; i < accessor.count; ++i ) {
+						auto& output = sampler.outputs.emplace_back(pod::Vector4f{0, 0, 0, 0});
+						for ( size_t j = 0; j < components; ++j ) {
+							output[j] = buf[i * components + j];
+						}
+					}
+				}
+			}
+
+			// load channels
+			animation.channels.reserve( a.channels.size() );
+			for ( auto& c : a.channels ) {
+				auto& channel = animation.channels.emplace_back();
+				channel.path = c.target_path;
+				channel.sampler = c.sampler;
+				channel.node = c.target_node;
+			}
+		}
+	}
+	{
+		bool shouldExport = false;
+		if ( graph.metadata["debug"]["export"].is<bool>() ) shouldExport = graph.metadata["debug"]["export"].as<bool>();
+		else if ( ext::json::isObject( graph.metadata["debug"]["export"] ) ) {
+			if ( graph.metadata["debug"]["export"]["should"].is<bool>() )
+				shouldExport = graph.metadata["debug"]["export"]["should"].as<bool>();
+			else
+				shouldExport = true;
+		}
+		if ( shouldExport ) uf::graph::save( filename, graph );
+	}
+	uf::graph::process( graph );
+	if ( graph.metadata["debug"]["print stats"].as<bool>() ) UF_DEBUG_MSG(uf::graph::stats( graph ).dump(1,'\t'));
+	if ( graph.metadata["debug"]["print tree"].as<bool>() ) UF_DEBUG_MSG(uf::graph::print( graph ));
+	if ( !graph.metadata["debug"]["no cleanup"].as<bool>() ) uf::graph::cleanup( graph );
+	return graph;
+}
\ No newline at end of file
diff --git a/engine/src/ext/gltf/graph.cpp b/engine/src/ext/gltf/graph.cpp
new file mode 100644
index 00000000..807ffc04
--- /dev/null
+++ b/engine/src/ext/gltf/graph.cpp
@@ -0,0 +1,1328 @@
+#include <uf/ext/gltf/graph.h>
+#include <uf/ext/bullet/bullet.h>
+#include <uf/utils/math/physics.h>
+#include <uf/utils/mesh/grid.h>
+
+#define UF_VK_TESTING 1
+
+namespace {
+	void initializeGraphics( pod::Graph& graph, uf::Object& entity ) {
+		auto& graphic = entity.getComponent<uf::Graphic>();
+		graphic.device = &uf::renderer::device;
+		graphic.material.device = &uf::renderer::device;
+		graphic.descriptor.frontFace = uf::renderer::enums::Face::CCW;
+		graphic.descriptor.cullMode = !(graph.mode & ext::gltf::LoadMode::INVERT) ? uf::renderer::enums::CullMode::BACK : uf::renderer::enums::CullMode::FRONT;
+		if ( graph.metadata["cull mode"].is<std::string>() ) {
+			if ( graph.metadata["cull mode"].as<std::string>() == "back" ) {
+				graphic.descriptor.cullMode = uf::renderer::enums::CullMode::BACK;
+			} else if ( graph.metadata["cull mode"].as<std::string>() == "front" ) {
+				graphic.descriptor.cullMode = uf::renderer::enums::CullMode::FRONT;
+			} else if ( graph.metadata["cull mode"].as<std::string>() == "none" ) {
+				graphic.descriptor.cullMode = uf::renderer::enums::CullMode::NONE;
+			} else if ( graph.metadata["cull mode"].as<std::string>() == "both" ) {
+				graphic.descriptor.cullMode = uf::renderer::enums::CullMode::BOTH;
+			}
+		}
+		{
+		#if UF_VK_TESTING
+			for ( auto& texture : graph.textures ) {
+				graphic.material.textures.emplace_back().aliasTexture(texture.texture);
+			}
+		#else
+			if ( graph.mode & ext::gltf::LoadMode::ATLAS ) {
+				auto& atlas = *graph.atlas;
+				auto& texture = graphic.material.textures.emplace_back();
+				texture.loadFromImage( atlas.getAtlas() );
+			} else {
+				graphic.material.textures.emplace_back().aliasTexture(uf::renderer::Texture2D::empty);
+				for ( auto& image : graph.images ) {
+					auto& texture = graphic.material.textures.emplace_back();
+
+					if ( graph.metadata["filter"].is<std::string>() ) {
+						std::string filter = graph.metadata["filter"].as<std::string>();
+						if ( filter == "NEAREST" ) {
+							texture.sampler.descriptor.filter.min = uf::renderer::enums::Filter::NEAREST;
+							texture.sampler.descriptor.filter.mag = uf::renderer::enums::Filter::NEAREST;
+						} else if ( filter == "LINEAR" ) {
+							texture.sampler.descriptor.filter.min = uf::renderer::enums::Filter::LINEAR;
+							texture.sampler.descriptor.filter.mag = uf::renderer::enums::Filter::LINEAR;
+						}
+					}
+					texture.loadFromImage( image );
+				}
+			}
+		#endif
+			for ( auto& sampler : graph.samplers ) {
+				graphic.material.samplers.emplace_back( sampler );
+			}
+		}
+		if ( graph.mode & ext::gltf::LoadMode::LOAD ) {
+			if ( graph.mode & ext::gltf::LoadMode::SEPARATE ) {
+				if ( graph.mode & ext::gltf::LoadMode::SKINNED ) {
+					graphic.material.attachShader(uf::io::root + "/shaders/gltf/skinned.vert.spv", uf::renderer::enums::Shader::VERTEX);
+				} else {
+					graphic.material.attachShader(uf::io::root + "/shaders/gltf/vert.spv", uf::renderer::enums::Shader::VERTEX);
+				}
+			} else {
+				if ( graph.mode & ext::gltf::LoadMode::SKINNED ) {
+					graphic.material.attachShader(uf::io::root + "/shaders/gltf/skinned.instanced.vert.spv", uf::renderer::enums::Shader::VERTEX);
+				} else {
+					graphic.material.attachShader(uf::io::root + "/shaders/gltf/instanced.vert.spv", uf::renderer::enums::Shader::VERTEX);
+				}
+			}
+			graphic.material.attachShader(uf::io::root + "/shaders/gltf/frag.spv", uf::renderer::enums::Shader::FRAGMENT);
+		#if UF_USE_VULKAN
+			{
+				auto& shader = graphic.material.getShader("vertex");
+				struct SpecializationConstant {
+					uint32_t passes = 6;
+				};
+				auto& specializationConstants = shader.specializationConstants.get<SpecializationConstant>();
+				specializationConstants.passes = uf::renderer::settings::maxViews;
+			}
+			{
+				auto& shader = graphic.material.getShader("fragment");
+				struct SpecializationConstant {
+					uint32_t textures = 1;
+				};
+				auto& specializationConstants = shader.specializationConstants.get<SpecializationConstant>();
+				specializationConstants.textures = graphic.material.textures.size();
+				for ( auto& binding : shader.descriptorSetLayoutBindings ) {
+					if ( binding.descriptorCount > 1 )
+						binding.descriptorCount = specializationConstants.textures;
+				}
+			}
+		#endif
+		} else {
+			graphic.process = false;
+		}
+	}
+}
+
+pod::Matrix4f uf::graph::local( pod::Graph& graph, int32_t index ) {
+	auto& node = 0 < index && index <= graph.nodes.size() ? graph.nodes[index] : graph.root;
+	return
+		uf::matrix::translate( uf::matrix::identity(), node.transform.position ) *
+		uf::quaternion::matrix(node.transform.orientation) *
+		uf::matrix::scale( uf::matrix::identity(), node.transform.scale ) *
+		node.transform.model;
+}
+pod::Matrix4f uf::graph::matrix( pod::Graph& graph, int32_t index ) {
+	pod::Matrix4f matrix = local( graph, index );
+	auto& node = *uf::graph::find( graph, index );
+	int32_t parent = node.parent;
+	while ( 0 < parent && parent <= graph.nodes.size() ) {
+		matrix = local( graph, parent ) * matrix;
+		parent = graph.nodes[parent].parent;
+	}
+	return matrix;
+}
+pod::Node* uf::graph::find( pod::Graph& graph, int32_t index ) {
+	return 0 <= index && index < graph.nodes.size() ? &graph.nodes[index] : NULL;
+}
+pod::Node* uf::graph::find( pod::Graph& graph, const std::string& name ) {
+	for ( auto& node : graph.nodes ) if ( node.name == name ) return &node;
+	return NULL;
+}
+
+void uf::graph::process( uf::Object& entity ) {
+	auto& graph = entity.getComponent<pod::Graph>();
+	for ( auto index : graph.root.children ) process( graph, index, entity );
+}
+void uf::graph::process( pod::Graph& graph ) {
+	if ( graph.atlas ) {
+		auto& texture = *graph.textures.emplace(graph.textures.begin());
+		texture.name = "atlas";
+		texture.storage.index = 0;
+		texture.storage.sampler = 0;
+		texture.storage.remap = 0;
+		texture.storage.blend = 0;
+		auto& image = *graph.images.emplace(graph.images.begin(), graph.atlas->getAtlas());
+	}
+#if UF_VK_TESTING
+	if ( graph.atlas ) {
+		auto& image = graph.images[0];
+		auto& texture = graph.textures[0].texture;
+
+		if ( graph.metadata["filter"].is<std::string>() ) {
+			std::string filter = graph.metadata["filter"].as<std::string>();
+			if ( filter == "NEAREST" ) {
+				texture.sampler.descriptor.filter.min = uf::renderer::enums::Filter::NEAREST;
+				texture.sampler.descriptor.filter.mag = uf::renderer::enums::Filter::NEAREST;
+			} else if ( filter == "LINEAR" ) {
+				texture.sampler.descriptor.filter.min = uf::renderer::enums::Filter::LINEAR;
+				texture.sampler.descriptor.filter.mag = uf::renderer::enums::Filter::LINEAR;
+			}
+		}
+		texture.loadFromImage( image );
+	} else {
+		for ( size_t i = 0; i < graph.textures.size() && i < graph.images.size(); ++i ) {
+			auto& image = graph.images[i];
+			auto& texture = graph.textures[i].texture;
+
+			if ( graph.metadata["filter"].is<std::string>() ) {
+				std::string filter = graph.metadata["filter"].as<std::string>();
+				if ( filter == "NEAREST" ) {
+					texture.sampler.descriptor.filter.min = uf::renderer::enums::Filter::NEAREST;
+					texture.sampler.descriptor.filter.mag = uf::renderer::enums::Filter::NEAREST;
+				} else if ( filter == "LINEAR" ) {
+					texture.sampler.descriptor.filter.min = uf::renderer::enums::Filter::LINEAR;
+					texture.sampler.descriptor.filter.mag = uf::renderer::enums::Filter::LINEAR;
+				}
+			}
+			texture.loadFromImage( image );
+		}
+	}
+#endif
+
+	if ( !graph.root.entity ) graph.root.entity = new uf::Object;
+	for ( auto index : graph.root.children ) process( graph, index, *graph.root.entity );
+
+	if ( !(graph.mode & ext::gltf::LoadMode::SEPARATE) ) {
+		initializeGraphics( graph, *graph.root.entity );
+
+		auto& graphic = graph.root.entity->getComponent<uf::Graphic>();
+		
+		std::vector<pod::Matrix4f> instances;
+		instances.reserve( graph.nodes.size() );
+		for ( auto& node : graph.nodes ) {
+			instances.emplace_back( uf::transform::model( node.transform ) );
+		}
+		// Models storage buffer
+		graph.instanceBufferIndex = graphic.initializeBuffer(
+			(void*) instances.data(),
+			instances.size() * sizeof(pod::Matrix4f),
+			uf::renderer::enums::Buffer::STORAGE
+		);
+		// Joints storage buffer
+		if ( graph.mode & ext::gltf::LoadMode::SKINNED ) {
+			for ( auto& node : graph.nodes ) {
+				if ( node.skin < 0 ) continue;
+				auto& skin = graph.skins[node.skin];
+				node.jointBufferIndex = graphic.initializeBuffer(
+					(void*) skin.inverseBindMatrices.data(),
+					(1 + skin.inverseBindMatrices.size()) * sizeof(pod::Matrix4f),
+					uf::renderer::enums::Buffer::STORAGE
+				);
+				break;
+			}
+		}
+		// Materials storage buffer
+		std::vector<pod::Material::Storage> materials( graph.materials.size() );
+		for ( size_t i = 0; i < graph.materials.size(); ++i ) {
+			materials[i] = graph.materials[i].storage;
+			if ( graph.metadata["alpha cutoff"].is<float>() )
+				materials[i].factorAlphaCutoff = graph.metadata["alpha cutoff"].as<float>();
+		}
+		graph.root.materialBufferIndex = graphic.initializeBuffer(
+			(void*) materials.data(),
+			materials.size() * sizeof(pod::Material::Storage),
+			uf::renderer::enums::Buffer::STORAGE
+		);
+		// Texture storage buffer
+		std::vector<pod::Texture::Storage> textures( graph.textures.size() );
+		for ( size_t i = 0; i < graph.textures.size(); ++i ) {
+			textures[i] = graph.textures[i].storage;
+			textures[i].remap = i;
+		}
+		graph.root.textureBufferIndex = graphic.initializeBuffer(
+			(void*) textures.data(),
+			textures.size() * sizeof(pod::Texture::Storage),
+			uf::renderer::enums::Buffer::STORAGE
+		);
+	}
+
+	graph.root.entity->process([&]( uf::Entity* entity ) {
+		if ( !entity->hasComponent<ext::gltf::mesh_t>() ) return;
+		
+		auto& mesh = entity->getComponent<ext::gltf::mesh_t>();
+		auto& metadata = entity->getComponent<uf::Serializer>();
+		std::string nodeName = metadata["system"]["graph"]["name"].as<std::string>();
+	#if 0
+		if ( graph.mode & ext::gltf::LoadMode::NORMALS ) {
+			// bool invert = false;
+			bool INVERTED = graph.mode & ext::gltf::LoadMode::INVERT;
+			if ( !mesh.indices.empty() ) {
+				for ( size_t i = 0; i < mesh.vertices.size(); i+=3 ) {
+					auto& a = mesh.vertices[i+(INVERTED ? 0 : 0)].position;
+					auto& b = mesh.vertices[i+(INVERTED ? 1 : 2)].position;
+					auto& c = mesh.vertices[i+(INVERTED ? 2 : 1)].position;
+
+					pod::Vector3f normal = uf::vector::normalize( uf::vector::cross( b - a, c - a ) );
+					mesh.vertices[i+0].normal = normal;
+					mesh.vertices[i+1].normal = normal;
+					mesh.vertices[i+2].normal = normal;
+				}
+			} else {
+				for ( size_t i = 0; i < mesh.indices.size(); i+=3 ) {
+					auto& A = mesh.vertices[mesh.indices[i+(INVERTED ? 0 : 0)]];
+					auto& B = mesh.vertices[mesh.indices[i+(INVERTED ? 1 : 2)]];
+					auto& C = mesh.vertices[mesh.indices[i+(INVERTED ? 2 : 1)]];
+
+					auto& a = A.position;
+					auto& b = B.position;
+					auto& c = C.position;
+
+					pod::Vector3f normal = uf::vector::normalize( uf::vector::cross( b - a, c - a ) );
+					
+					A.normal = normal;
+					B.normal = normal;
+					C.normal = normal;
+				}
+			}
+		}
+	#endif
+		if ( entity->hasComponent<uf::Graphic>() ) {
+		/*
+			size_t o = graph.metadata["mesh optimization"].is<size_t>() ? graph.metadata["mesh optimization"].as<size_t>() : SIZE_MAX;
+			auto& graphic = entity->getComponent<uf::Graphic>();
+			graphic.initialize();
+			if ( mesh.indices.empty() ) mesh.initialize( o );
+			else mesh.optimize( o );
+			graphic.initializeMesh( mesh, o );	
+		*/
+			auto& graphic = entity->getComponent<uf::Graphic>();
+			graphic.initialize();
+			graphic.initializeMesh( mesh, 0 );
+		#if 1
+			if ( ext::json::isObject( graph.metadata["grid"] ) ) {
+				auto& grid = entity->getComponent<uf::MeshGrid>();
+				grid.initialize( mesh, uf::vector::decode( graph.metadata["grid"]["size"], pod::Vector3ui{1,1,1} ) );
+				grid.analyze();
+
+				auto center = uf::vector::decode( graph.metadata["grid"]["center"], grid.center() );
+				auto indices = grid.get<>( center );
+				graphic.descriptor.indices = indices.size();
+				UF_DEBUG_MSG("Center: " << uf::vector::toString(center) << " | Indices: " << indices.size());
+				int32_t indexBuffer = -1;
+				for ( size_t i = 0; i < graphic.buffers.size(); ++i ) {
+					if ( graphic.buffers[i].usage & uf::renderer::enums::Buffer::INDEX ) indexBuffer = i;
+				}
+				if ( indexBuffer >= 0 && !indices.empty() && indices.size() % 3 == 0 ) {
+					graphic.updateBuffer(
+						(void*) indices.data(),
+						indices.size() * mesh.attributes.index.size,
+						indexBuffer
+					);
+				}
+			}
+		#endif
+		}
+		
+		if ( !ext::json::isNull( graph.metadata["tags"][nodeName] ) ) {
+			auto& info = graph.metadata["tags"][nodeName];
+			if ( info["collision"].is<std::string>() ) {
+				std::string type = info["collision"].as<std::string>();
+			#if UF_USE_BULLET
+				if ( type == "static mesh" ) {
+					bool applyTransform = false; //!(graph.mode & ext::gltf::LoadMode::TRANSFORM);
+					auto& collider = ext::bullet::create( entity->as<uf::Object>(), mesh, applyTransform, 1 );
+					if ( !applyTransform ) {
+						btBvhTriangleMeshShape* triangleMeshShape = (btBvhTriangleMeshShape*) collider.shape;
+						btTriangleInfoMap* triangleInfoMap = new btTriangleInfoMap();
+						triangleInfoMap->m_edgeDistanceThreshold = 0.01f;
+					    triangleInfoMap->m_maxEdgeAngleThreshold = SIMD_HALF_PI*0.25;
+						if ( applyTransform ) {
+							btGenerateInternalEdgeInfo(triangleMeshShape, triangleInfoMap);
+						}
+						collider.body->setCollisionFlags(collider.body->getCollisionFlags() | btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK);
+					}
+				} else if ( type == "bounding box" ) {
+
+				}
+			#endif
+			}
+		}
+	});
+}
+void uf::graph::process( pod::Graph& graph, int32_t index, uf::Object& parent ) {
+	// create child if requested
+	uf::Object* pointer = new uf::Object;
+	parent.addChild(*pointer);
+
+	uf::Object& entity = *pointer;
+	auto& node = graph.nodes[index];
+	node.entity = &entity;
+	
+	bool setName = entity.getName() == "Entity";
+	auto& metadata = entity.getComponent<uf::Serializer>();
+	metadata["system"]["graph"]["name"] = node.name;
+	// tie to tag
+	if ( !ext::json::isNull( graph.metadata["tags"][node.name] ) ) {
+		auto& info = graph.metadata["tags"][node.name];
+		if ( info["action"].as<std::string>() == "load" ) {
+			if ( info["filename"].is<std::string>() ) {
+				std::string filename = uf::io::resolveURI( info["filename"].as<std::string>(), graph.metadata["root"].as<std::string>() );
+				entity.load(filename);
+			} else if ( ext::json::isObject( info["payload"] ) ) {
+				uf::Serializer json = info["payload"];
+				json["root"] = graph.metadata["root"];
+				entity.load(json);
+			}
+		} else if ( info["action"].as<std::string>() == "attach" ) {
+			std::string filename = uf::io::resolveURI( info["filename"].as<std::string>(), graph.metadata["root"].as<std::string>() );
+			auto& child = entity.loadChild( filename, false );
+			auto& childTransform = child.getComponent<pod::Transform<>>();
+			auto flatten = uf::transform::flatten( node.transform );
+			if ( !info["preserve position"].as<bool>() ) childTransform.position = flatten.position;
+			if ( !info["preserve orientation"].as<bool>() ) childTransform.orientation = flatten.orientation;
+		}
+	}
+	// create as light
+	for ( auto& l : graph.lights ) {
+		if ( l.name != node.name ) continue;
+		entity.load("/light.json");
+		auto& metadata = entity.getComponent<uf::Serializer>();
+
+		metadata["light"]["radius"][0] = 0.001;
+		metadata["light"]["radius"][1] = l.range; // l.range <= 0.001f ? graph.metadata["lights"]["range cap"].as<float>() : l.range;
+		metadata["light"]["power"] = l.intensity; //  * graph.metadata["lights"]["power scale"].as<float>();
+		metadata["light"]["color"][0] = l.color.x;
+		metadata["light"]["color"][1] = l.color.y;
+		metadata["light"]["color"][2] = l.color.z;
+		metadata["light"]["shadows"] = graph.metadata["lights"]["shadows"].as<bool>();
+		if ( metadata["light"]["shadows"].as<bool>() ) {
+			metadata["light"]["radius"][1] = 0;
+		}
+		if ( ext::json::isArray( graph.metadata["lights"]["radius"] ) ) {
+			metadata["light"]["radius"] = graph.metadata["lights"]["radius"];
+		}
+		if ( graph.metadata["lights"]["bias"].is<float>() ) {
+			metadata["light"]["bias"] = graph.metadata["lights"]["bias"].as<float>();
+		}
+		// copy from tag information
+		ext::json::forEach( graph.metadata["tags"][node.name]["light"], [&]( const std::string& key, ext::json::Value& value ){
+			if ( key == "transform" ) return;
+			metadata["light"][key] = value;
+		});
+
+		if ( metadata["light"]["shadows"].as<bool>() ) {
+			ext::json::Value m;
+			if ( ext::json::isObject( graph.metadata["tags"][node.name]["renderMode"] ) ) {
+				m = graph.metadata["tags"][node.name]["renderMode"];
+			} else if ( ext::json::isObject( graph.metadata["lights"]["renderMode"] ) ) {
+				m = graph.metadata["lights"]["renderMode"];
+			}
+		}
+		break;
+	}
+
+	// set name
+	if ( setName ) entity.setName( node.name );
+
+	// reference transform to parent
+	{
+		auto& transform = entity.getComponent<pod::Transform<>>();
+		transform = node.transform;
+		// is a child
+		if ( node.index != -1 )
+			transform.reference = &entity.getParent().getComponent<pod::Transform<>>();
+		// override transform
+		if ( !ext::json::isNull( graph.metadata["tags"][node.name] ) ) {
+			auto& info = graph.metadata["tags"][node.name];
+			if ( info["transform"]["offset"].as<bool>() ) {
+				auto parsed = uf::transform::decode( info["transform"], pod::Transform<>{} );
+				transform.position += parsed.position;
+				transform.orientation = uf::quaternion::multiply( transform.orientation, parsed.orientation );
+			} else {
+				transform = uf::transform::decode( info["transform"], transform );
+				if ( info["transform"]["parent"].is<std::string>() ) {
+					auto* parentPointer = uf::graph::find( graph, info["transform"]["parent"].as<std::string>() );
+					if ( parentPointer ) {
+						auto& parentNode = *parentPointer;
+						// entity already exists, bind to its transform
+						if ( parentNode.entity && parentNode.entity->hasComponent<pod::Transform<>>() ) {
+							auto& parentTransform = parentNode.entity->getComponent<pod::Transform<>>();
+							transform = uf::transform::reference( transform, parentTransform, info["transform"]["reorient"].as<bool>() );
+							transform.position = -transform.position;
+						// doesnt exist, bind to the node transform
+						} else {
+							transform = uf::transform::reference( transform, parentNode.transform, info["transform"]["reorient"].as<bool>() );
+						}
+					}
+				}
+			}
+		}
+	}
+	// copy mesh
+	if ( 0 <= node.mesh && node.mesh < graph.meshes.size() ) {
+		auto& nodeMesh = graph.meshes[node.mesh];
+		auto& mesh = entity.getComponent<ext::gltf::mesh_t>();
+		struct {
+			size_t vertices = 0;
+			size_t indices = 0;
+		} start = {
+			mesh.vertices.size(),
+			mesh.indices.size(),
+		};
+		mesh.vertices.reserve( nodeMesh.vertices.size() + start.vertices );
+		mesh.indices.reserve( nodeMesh.indices.size() + start.indices );
+		for ( auto& v : nodeMesh.vertices ) {
+			auto& vertex = mesh.vertices.emplace_back( v );
+			vertex.id.x = node.index;
+		// in almost-software mode, material ID is actually its albedo ID, as we can't use any other forms of mapping
+		#if UF_USE_OPENGL_FIXED_FUNCTION
+			if ( !(graph.mode & ext::gltf::LoadMode::ATLAS) ) {
+				auto& material = graph.materials[vertex.id.y];
+				auto& texture = graph.textures[material.storage.indexAlbedo];
+				vertex.id.y = texture.storage.index;
+			}
+		#endif
+		}
+		for ( auto& i : nodeMesh.indices ) mesh.indices.emplace_back( i + start.vertices );
+
+		if ( !(graph.mode & ext::gltf::LoadMode::SEPARATE) ) {
+			auto& mesh = graph.root.entity->getComponent<ext::gltf::mesh_t>();
+			struct {
+				size_t vertices = 0;
+				size_t indices = 0;
+			} start = {
+				mesh.vertices.size(),
+				mesh.indices.size(),
+			};
+			mesh.vertices.reserve( nodeMesh.vertices.size() + start.vertices );
+			mesh.indices.reserve( nodeMesh.indices.size() + start.indices );
+			for ( auto& v : nodeMesh.vertices ) {
+				auto& vertex = mesh.vertices.emplace_back( v );
+				vertex.id.x = node.index;
+			// in almost-software mode, material ID is actually its albedo ID, as we can't use any other forms of mapping
+			#if UF_USE_OPENGL_FIXED_FUNCTION
+				if ( !(graph.mode & ext::gltf::LoadMode::ATLAS) ) {
+					auto& material = graph.materials[vertex.id.y];
+					auto& texture = graph.textures[material.storage.indexAlbedo];
+					vertex.id.y = texture.storage.index;
+				}
+			#endif
+			}
+			for ( auto& i : nodeMesh.indices ) mesh.indices.emplace_back( i + start.vertices );
+		/*
+			ext::gltf::mesh_t expanded = nodeMesh;
+			expanded.expand();
+			mesh.vertices.reserve( mesh.vertices.size() + expanded.vertices.size() );
+			for ( auto& v : expanded.vertices ) {
+				auto& vertex = mesh.vertices.emplace_back( v );
+				vertex.id.x = node.index;
+			#if UF_USE_OPENGL_FIXED_FUNCTION
+				if ( !(graph.mode & ext::gltf::LoadMode::ATLAS) ) {
+					auto& material = graph.materials[vertex.id.y];
+					auto& texture = graph.textures[material.storage.indexAlbedo];
+					vertex.id.y = texture.storage.index;
+				}
+			#endif
+			}
+		*/
+		} else if ( graph.mode & ext::gltf::LoadMode::RENDER ) {
+			uf::instantiator::bind("RenderBehavior", entity);
+			initializeGraphics( graph, entity );
+			auto& graphic = entity.getComponent<uf::Graphic>();
+			// Joints storage buffer
+			if ( graph.mode & ext::gltf::LoadMode::SKINNED && node.skin >= 0 ) {
+				auto& skin = graph.skins[node.skin];
+				node.jointBufferIndex = graphic.initializeBuffer(
+					(void*) skin.inverseBindMatrices.data(),
+					skin.inverseBindMatrices.size() * sizeof(pod::Matrix4f),
+					uf::renderer::enums::Buffer::STORAGE
+				);
+			}
+			// Materials storage buffer
+			std::vector<pod::Material::Storage> materials( graph.materials.size() );
+			for ( size_t i = 0; i < graph.materials.size(); ++i ) {
+				materials[i] = graph.materials[i].storage;
+			}
+			node.materialBufferIndex = graphic.initializeBuffer(
+				(void*) materials.data(),
+				materials.size() * sizeof(pod::Material::Storage),
+				uf::renderer::enums::Buffer::STORAGE
+			);
+			// Texture storage buffer
+			std::vector<pod::Texture::Storage> textures( graph.textures.size() );
+			for ( size_t i = 0; i < graph.textures.size(); ++i ) {
+				textures[i] = graph.textures[i].storage;
+				textures[i].remap = i;
+			}
+			graph.root.textureBufferIndex = graphic.initializeBuffer(
+				(void*) textures.data(),
+				textures.size() * sizeof(pod::Texture::Storage),
+				uf::renderer::enums::Buffer::STORAGE
+			);
+		}
+	}
+	
+	for ( auto index : node.children ) uf::graph::process( graph, index, entity );
+}
+void uf::graph::cleanup( pod::Graph& graph ) {
+	graph.images.clear();
+	graph.meshes.clear();
+}
+void uf::graph::override( pod::Graph& graph ) {
+	graph.settings.animations.override.a = 0;
+	graph.settings.animations.override.map.clear();
+	bool toNeutralPose = graph.sequence.empty();
+	// store every node's current transform
+	for ( auto& node : graph.nodes ) {
+		graph.settings.animations.override.map[node.index].first = node.transform;
+		graph.settings.animations.override.map[node.index].second = node.transform;
+		if ( toNeutralPose ) {
+			graph.settings.animations.override.map[node.index].second.position = { 0, 0, 0 };
+			graph.settings.animations.override.map[node.index].second.orientation = { 0, 0, 0, 1 };
+			graph.settings.animations.override.map[node.index].second.scale = { 1, 1, 1 };
+		}
+	}
+	// set our destination transform per node
+	if ( !toNeutralPose ) {
+		std::string name = graph.sequence.front();
+		pod::Animation& animation = graph.animations[name];
+		for ( auto& channel : animation.channels ) {
+			auto& override = graph.settings.animations.override.map[channel.node];
+			auto& sampler = animation.samplers[channel.sampler];
+			if ( sampler.interpolator != "LINEAR" ) continue;
+			for ( size_t i = 0; i < sampler.inputs.size() - 1; ++i ) {
+				if ( !(animation.start >= sampler.inputs[i] && animation.start <= sampler.inputs[i+1]) ) continue;
+				if ( channel.path == "translation" ) {
+					override.second.position = sampler.outputs[i];
+				} else if ( channel.path == "rotation" ) {
+					override.second.orientation = uf::quaternion::normalize( sampler.outputs[i] );
+				} else if ( channel.path == "scale" ) {
+					override.second.scale = sampler.outputs[i];
+				}
+			}
+		}
+	}
+}
+
+void uf::graph::animate( pod::Graph& graph, const std::string& name, float speed, bool immediate ) {
+	if ( !(graph.mode & ext::gltf::LoadMode::SKINNED) ) return;
+	if ( graph.animations.count( name ) > 0 ) {
+		// if already playing, ignore it
+		if ( !graph.sequence.empty() && graph.sequence.front() == name ) return;
+		if ( immediate ) {
+			while ( !graph.sequence.empty() ) graph.sequence.pop();
+		}
+		bool empty = graph.sequence.empty();
+		graph.sequence.emplace(name);
+		if ( empty ) uf::graph::override( graph );
+		graph.settings.animations.speed = speed;
+	}
+	update( graph, 0 );
+}
+void uf::graph::update( pod::Graph& graph ) {
+	return update( graph, uf::physics::time::delta );
+}
+void uf::graph::update( pod::Graph& graph, float delta ) {
+	// no override
+	if ( !(graph.mode & ext::gltf::LoadMode::SKINNED) ) return;
+	if ( graph.sequence.empty() ) goto UPDATE;
+	if ( graph.settings.animations.override.a >= 0 ) goto OVERRIDE;
+	{
+		std::string name = graph.sequence.front();
+		pod::Animation* animation = &graph.animations[name];
+	//	std::cout << "ANIMATION: " << name << "\t" << animation->cur << std::endl;
+		animation->cur += delta * graph.settings.animations.speed; // * graph.settings.animations.override.speed;
+		if ( animation->end < animation->cur ) {
+			animation->cur = graph.settings.animations.loop ? animation->cur - animation->end : 0;
+			// go-to next animation
+			if ( !graph.settings.animations.loop ) {
+				graph.sequence.pop();
+				// out of animations, set to neutral pose
+				if ( graph.sequence.empty() ) {
+					uf::graph::override( graph );
+					goto OVERRIDE;
+				}
+				name = graph.sequence.front();
+				animation = &graph.animations[name];
+			}
+		}
+		for ( auto& channel : animation->channels ) {
+			auto& sampler = animation->samplers[channel.sampler];
+			if ( sampler.interpolator != "LINEAR" ) continue;
+			for ( size_t i = 0; i < sampler.inputs.size() - 1; ++i ) {
+				if ( !(animation->cur >= sampler.inputs[i] && animation->cur <= sampler.inputs[i+1]) ) continue;
+				float a = (animation->cur - sampler.inputs[i]) / (sampler.inputs[i+1] - sampler.inputs[i]);
+				auto& transform = graph.nodes[channel.node].transform;
+				if ( channel.path == "translation" ) {
+					transform.position = uf::vector::mix( sampler.outputs[i], sampler.outputs[i+1], a );
+				} else if ( channel.path == "rotation" ) {
+					transform.orientation = uf::quaternion::normalize( uf::quaternion::slerp(sampler.outputs[i], sampler.outputs[i+1], a) );
+				} else if ( channel.path == "scale" ) {
+					transform.scale = uf::vector::mix( sampler.outputs[i], sampler.outputs[i+1], a );
+				}
+			}
+		}
+		goto UPDATE;
+	}
+OVERRIDE:
+	// std::cout << "OVERRIDED: " << graph.settings.animations.override.a << "\t" << -std::numeric_limits<float>::max() << std::endl;
+	for ( auto pair : graph.settings.animations.override.map ) {
+		graph.nodes[pair.first].transform.position = uf::vector::mix( pair.second.first.position, pair.second.second.position, graph.settings.animations.override.a );
+		graph.nodes[pair.first].transform.orientation = uf::quaternion::normalize( uf::quaternion::slerp(pair.second.first.orientation, pair.second.second.orientation, graph.settings.animations.override.a) );
+		graph.nodes[pair.first].transform.scale = uf::vector::mix( pair.second.first.scale, pair.second.second.scale, graph.settings.animations.override.a );
+	}
+	// finished our overrided interpolation, clear it
+	if ( (graph.settings.animations.override.a += delta * graph.settings.animations.override.speed) >= 1 ) {
+		graph.settings.animations.override.a = -std::numeric_limits<float>::max();
+		graph.settings.animations.override.map.clear();
+	}
+UPDATE:
+	for ( auto& node : graph.nodes ) uf::graph::update( graph, node );
+}
+void uf::graph::update( pod::Graph& graph, pod::Node& node ) {
+	if ( node.skin >= 0 ) {
+		pod::Matrix4f nodeMatrix = uf::graph::matrix( graph, node.index );
+		pod::Matrix4f inverseTransform = uf::matrix::inverse( nodeMatrix );
+		auto& skin = graph.skins[node.skin];
+		std::vector<pod::Matrix4f> joints;
+		joints.reserve( skin.joints.size() );
+		for ( size_t i = 0; i < skin.joints.size(); ++i ) {
+			joints.emplace_back( uf::matrix::identity() );
+		}
+		if ( graph.settings.animations.override.a >= 0 || !graph.sequence.empty() ) {
+			for ( size_t i = 0; i < skin.joints.size(); ++i ) {
+				joints[i] = inverseTransform * (uf::graph::matrix(graph, skin.joints[i]) * skin.inverseBindMatrices[i]);
+			}
+		}
+		if ( node.entity && node.entity->hasComponent<uf::Graphic>() ) {
+			auto& graphic = node.entity->getComponent<uf::Graphic>();
+			if ( node.jointBufferIndex < graphic.buffers.size() ) {
+				auto& buffer = graphic.buffers.at(node.jointBufferIndex);
+				graphic.updateBuffer( (void*) joints.data(), joints.size() * sizeof(pod::Matrix4f), buffer );
+			}
+		}
+	}
+}
+void uf::graph::destroy( pod::Graph& graph ) {
+	for ( auto& t : graph.textures ) {
+		t.texture.destroy();
+	}
+	delete graph.atlas;
+}
+
+#include <uf/utils/string/base64.h>
+
+namespace {
+	uf::Image decodeImage( ext::json::Value& json ) {
+		uf::Image image;
+		auto size = uf::vector::decode( json["size"], pod::Vector2ui{} );
+		size_t bpp = json["bpp"].as<size_t>();
+		size_t channels = json["channels"].as<size_t>();
+		auto pixels = uf::base64::decode( json["data"].as<std::string>() );
+		image.loadFromBuffer( &pixels[0], size, bpp, channels, true );
+		return image;
+	}
+	uf::Image& decode( ext::json::Value& json, uf::Image& image ) {
+		return image = decodeImage( json );
+	}
+
+	pod::Texture decodeTexture( ext::json::Value& json ) {
+		pod::Texture texture;
+		texture.name = json["name"].as<std::string>();
+		texture.storage.index = json["index"].is<size_t>() ? json["index"].as<size_t>() : -1;
+		texture.storage.sampler = json["sampler"].is<size_t>() ? json["sampler"].as<size_t>() : -1;
+		texture.storage.remap = json["remap"].is<size_t>() ? json["remap"].as<size_t>() : -1;
+		texture.storage.blend = json["blend"].is<size_t>() ? json["blend"].as<size_t>() : -1;
+		texture.storage.lerp = uf::vector::decode( json["lerp"], pod::Vector4f{} );
+		return texture;
+	}
+	pod::Texture& decode( ext::json::Value& json, pod::Texture& texture ) {
+		return texture = decodeTexture( json );
+	}
+
+	uf::renderer::Sampler decodeSampler( ext::json::Value& json ) {
+		uf::renderer::Sampler sampler;
+		sampler.descriptor.filter.min = (uf::renderer::enums::Filter::type_t) json["min"].as<size_t>();
+		sampler.descriptor.filter.mag = (uf::renderer::enums::Filter::type_t) json["mag"].as<size_t>();
+		sampler.descriptor.addressMode.u = (uf::renderer::enums::AddressMode::type_t) json["u"].as<size_t>();
+		sampler.descriptor.addressMode.v = (uf::renderer::enums::AddressMode::type_t) json["v"].as<size_t>();
+		sampler.descriptor.addressMode.w = sampler.descriptor.addressMode.v;
+		return sampler;
+	}
+	uf::renderer::Sampler& decode( ext::json::Value& json, uf::renderer::Sampler& sampler ) {
+		return sampler = decodeSampler( json );
+	}
+
+	pod::Material decodeMaterial( ext::json::Value& json ) {
+		pod::Material material;
+		material.name = json["name"].as<std::string>();
+		material.alphaMode = json["alphaMode"].as<std::string>();
+		material.storage.colorBase = uf::vector::decode( json["base"], pod::Vector4f{} );
+		material.storage.colorEmissive = uf::vector::decode( json["emissive"], pod::Vector4f{} );
+		material.storage.factorMetallic = json["fMetallic"].as<float>();
+		material.storage.factorRoughness = json["fRoughness"].as<float>();
+		material.storage.factorOcclusion = json["fOcclusion"].as<float>();
+		material.storage.factorAlphaCutoff = json["fAlphaCutoff"].as<float>();
+		material.storage.indexAlbedo = json["iAlbedo"].is<size_t>() ? json["iAlbedo"].as<size_t>() : -1;
+		material.storage.indexNormal = json["iNormal"].is<size_t>() ? json["iNormal"].as<size_t>() : -1;
+		material.storage.indexEmissive = json["iEmissive"].is<size_t>() ? json["iEmissive"].as<size_t>() : -1;
+		material.storage.indexOcclusion = json["iOcclusion"].is<size_t>() ? json["iOcclusion"].as<size_t>() : -1;
+		material.storage.indexMetallicRoughness = json["iMetallicRoughness"].is<size_t>() ? json["iMetallicRoughness"].as<size_t>() : -1;
+		material.storage.modeAlpha = json["modeAlpha"].as<size_t>();
+		return material;
+	}
+	pod::Material& decode( ext::json::Value& json, pod::Material& material ) {
+		return material = decodeMaterial( json );
+	}
+
+	pod::Light decodeLight( ext::json::Value& json ) {
+		pod::Light light;
+		light.name = json["name"].as<std::string>();
+		light.color = uf::vector::decode( json["color"], pod::Vector3f{} );
+		light.intensity = json["intensity"].as<float>();
+		light.range = json["range"].as<float>();
+		return light;
+	}
+	pod::Light& decode( ext::json::Value& json, pod::Light& light ) {
+		return light = decodeLight( json );
+	}
+
+	pod::Animation decodeAnimation( ext::json::Value& json ) {
+		pod::Animation animation;
+		animation.name = json["name"].as<std::string>();
+		animation.start = json["start"].as<float>();
+		animation.end = json["end"].as<float>();
+
+		ext::json::forEach( json["samplers"], [&]( ext::json::Value& value ){
+			auto& sampler = animation.samplers.emplace_back();
+			sampler.interpolator = value["interpolator"].as<std::string>();
+
+			sampler.inputs.reserve( value["inputs"].size() );
+			ext::json::forEach( value["inputs"], [&]( ext::json::Value& input ){
+				sampler.inputs.emplace_back( input.as<float>() );
+			});
+			
+			sampler.outputs.reserve( value["outputs"].size() );
+			ext::json::forEach( value["outputs"], [&]( ext::json::Value& output ){
+				sampler.outputs.emplace_back( uf::vector::decode( output, pod::Vector4f{} ) );
+			});
+		});
+
+		ext::json::forEach( json["channels"], [&]( ext::json::Value& value ){
+			auto& channel = animation.channels.emplace_back();
+			channel.path = value["path"].as<std::string>();
+			channel.node = value["node"].as<int32_t>();
+			channel.sampler = value["sampler"].as<uint32_t>();
+		});
+		return animation;
+	}
+	pod::Animation& decode( ext::json::Value& json, pod::Animation& animation ) {
+		return animation = decodeAnimation( json );
+	}
+
+	pod::Skin decodeSkin( ext::json::Value& json ) {
+		pod::Skin skin;
+		skin.name = json["name"].as<std::string>();
+		
+		skin.joints.reserve( json["joints"].size() );
+		ext::json::forEach( json["joints"], [&]( ext::json::Value& value ){
+			skin.joints.emplace_back( value.as<int32_t>() );
+		});
+		
+		skin.inverseBindMatrices.reserve( json["inverseBindMatrices"].size() );
+		ext::json::forEach( json["inverseBindMatrices"], [&]( ext::json::Value& value ){
+			skin.inverseBindMatrices.emplace_back( uf::matrix::decode( value, pod::Matrix4f{} ) );
+		});
+		
+		return skin;
+	}
+	pod::Skin& decode( ext::json::Value& json, pod::Skin& skin ) {
+		return skin = decodeSkin( json );
+	}
+/*
+	pod::DrawCall decodeDrawCall( ext::json::Value& json ) {
+		pod::DrawCall drawCall;
+		drawCall.name = json["name"].as<std::string>();
+
+		drawCall.storage.materialIndex = json["materialIndex"].as<int32_t>();
+		drawCall.storage.materials = json["materials"].as<uint32_t>();
+		drawCall.storage.textureIndex = json["textureIndex"].as<int32_t>();
+		drawCall.storage.textures = json["textures"].as<uint32_t>();
+
+		drawCall.verticesIndex = json["verticesIndex"].as<size_t>();
+		drawCall.vertices = json["vertices"].as<size_t>();
+		drawCall.indicesIndex = json["indicesIndex"].as<size_t>();
+		drawCall.indices = json["indices"].as<size_t>();
+		return drawCall;
+	}
+	pod::DrawCall& decode( ext::json::Value& json, pod::DrawCall& drawCall ) {
+		return drawCall = decodeDrawCall( json );
+	}
+*/
+	pod::Graph::Mesh decodeMesh( ext::json::Value& json ) {
+		pod::Graph::Mesh mesh;
+		mesh.vertices.reserve( json["vertices"].size() );
+		ext::json::forEach( json["vertices"], [&]( ext::json::Value& value ){
+			auto& vertex = mesh.vertices.emplace_back();
+			size_t attr = 0;
+			vertex.position = uf::vector::decode( value[attr++], pod::Vector3f{} );
+			vertex.uv = uf::vector::decode( value[attr++], pod::Vector2f{} );
+			vertex.normal = uf::vector::decode( value[attr++], pod::Vector3f{} );
+			vertex.tangent = uf::vector::decode( value[attr++], pod::Vector4f{} );
+			vertex.id = uf::vector::decode( value[attr++], pod::Vector2ui{} );
+			vertex.joints = uf::vector::decode( value[attr++], pod::Vector4ui{} );
+			vertex.weights = uf::vector::decode( value[attr++], pod::Vector4f{} );
+		});
+		mesh.indices.reserve( json["indices"].size() );
+		ext::json::forEach( json["indices"], [&]( ext::json::Value& value ){
+			mesh.indices.emplace_back( value.as<size_t>() );
+		});
+		return mesh;
+	}
+	pod::Graph::Mesh& decode( ext::json::Value& json, pod::Graph::Mesh& mesh ) {
+		return mesh = decodeMesh( json );
+	}
+
+	pod::Node decodeNode( ext::json::Value& json ) {
+		pod::Node node;
+		node.name = json["name"].as<std::string>();
+		node.index = json["index"].as<int32_t>();
+		node.skin = json["skin"].is<int32_t>() ? json["skin"].as<int32_t>() : -1;
+		node.mesh = json["mesh"].is<int32_t>() ? json["mesh"].as<int32_t>() : -1;
+		node.parent = json["parent"].is<int32_t>() ? json["parent"].as<int32_t>() : -1;
+		node.children.reserve( json["children"].size() );
+		ext::json::forEach( json["children"], [&]( ext::json::Value& value ){
+			node.children.emplace_back( value.as<int32_t>() );
+		});
+		node.transform = uf::transform::decode( json["transform"], pod::Transform<>{} );
+		return node;
+	}
+	pod::Node& decode( ext::json::Value& json, pod::Node& node ) {
+		return node = decodeNode( json );
+	}
+}
+
+pod::Graph uf::graph::load( const std::string& filename, ext::gltf::load_mode_t mode, const uf::Serializer& metadata ) {
+#if UF_ENV_DREAMCAST
+	#define UF_DEBUG_TRACE_MSG(X) UF_DEBUG_MSG(X); malloc_stats();
+	uf::Timer<long long> timer(false);
+	if ( !timer.running() ) timer.start();
+#else
+	#define UF_DEBUG_TRACE_MSG(X)
+#endif
+	std::string directory = uf::io::directory( filename ) + "/";
+	pod::Graph graph;
+	uf::Serializer serializer;
+	UF_DEBUG_TRACE_MSG("Reading " << filename);
+	serializer.readFromFile( filename );
+	// load metadata
+	graph.name = serializer["name"].as<std::string>();
+	graph.mode = mode; // serializer["mode"].as<size_t>();
+	graph.metadata = metadata; // serializer["metadata"];
+
+	// load mesh information
+	UF_DEBUG_TRACE_MSG("Reading meshes...");
+	graph.meshes.reserve( serializer["meshes"].size() );
+	ext::json::forEach( serializer["meshes"], [&]( ext::json::Value& value ){
+		auto& mesh = graph.meshes.emplace_back();
+		if ( value.is<std::string>() ) {
+			UF_DEBUG_TRACE_MSG(directory + "/" + value.as<std::string>());
+			uf::Serializer json;
+			json.readFromFile( directory + "/" + value.as<std::string>() );
+			decode( json, mesh );
+		
+		} else {
+			decode( value, mesh );
+		}
+	});
+	// load images
+	UF_DEBUG_TRACE_MSG("Reading images...");
+	graph.images.reserve( serializer["images"].size() );
+	ext::json::forEach( serializer["images"], [&]( ext::json::Value& value ){
+		auto& image = graph.images.emplace_back();
+		if ( value.is<std::string>() ) {
+			UF_DEBUG_TRACE_MSG("Reading image " << directory << "/" << value.as<std::string>());
+			image.open(directory + "/" + value.as<std::string>(), false);
+		} else {
+			decode( value, image );
+		}
+	});
+	// load texture information
+	UF_DEBUG_TRACE_MSG("Reading texture information...");
+	graph.textures.reserve( serializer["textures"].size() );
+	ext::json::forEach( serializer["textures"], [&]( ext::json::Value& value ){
+		decode( value, graph.textures.emplace_back() );
+	});
+	// load sampler information
+	UF_DEBUG_TRACE_MSG("Reading sampler information...");
+	graph.samplers.reserve( serializer["samplers"].size() );
+	ext::json::forEach( serializer["samplers"], [&]( ext::json::Value& value ){
+		decode( value, graph.samplers.emplace_back() );
+	});
+	// load material information
+	UF_DEBUG_TRACE_MSG("Reading material information...");
+	graph.materials.reserve( serializer["materials"].size() );
+	ext::json::forEach( serializer["materials"], [&]( ext::json::Value& value ){
+		decode( value, graph.materials.emplace_back() );
+	});
+	// load light information
+	UF_DEBUG_TRACE_MSG("Reading lighting information...");
+	graph.lights.reserve( serializer["lighting"].size() );
+	ext::json::forEach( serializer["lighting"], [&]( ext::json::Value& value ){
+		decode( value, graph.lights.emplace_back() );
+	});
+	// load animation information
+	UF_DEBUG_TRACE_MSG("Reading animation information...");
+	graph.animations.reserve( serializer["animations"].size() );
+	ext::json::forEach( serializer["animations"], [&]( ext::json::Value& value ){
+		if ( value.is<std::string>() ) {
+			uf::Serializer json;
+			json.readFromFile( directory + "/" + value.as<std::string>() );
+			std::string key = json["name"].as<std::string>();
+			decode( json, graph.animations[key] );
+		} else {
+			std::string key = value["name"].as<std::string>();
+			decode( value, graph.animations[key] );
+		}
+	});
+	// load skin information
+	UF_DEBUG_TRACE_MSG("Reading skinning information...");
+	graph.skins.reserve( serializer["skins"].size() );
+	ext::json::forEach( serializer["skins"], [&]( ext::json::Value& value ){
+		decode( value, graph.skins.emplace_back() );
+	});
+	// load node information
+	UF_DEBUG_TRACE_MSG("Reading nodes...");
+	graph.nodes.reserve( serializer["nodes"].size() );
+	ext::json::forEach( serializer["nodes"], [&]( ext::json::Value& value ){
+		decode( value, graph.nodes.emplace_back() );
+	});
+	decode(serializer["root"], graph.root);
+
+	// generate atlas
+	if ( graph.mode & ext::gltf::LoadMode::ATLAS ) { if ( graph.atlas ) delete graph.atlas; graph.atlas = new uf::Atlas;
+		UF_DEBUG_TRACE_MSG("Generating atlas...");
+		auto& atlas = *graph.atlas;
+		atlas.generate( graph.images );
+	}
+	// re-reference all transform parents
+	for ( auto& node : graph.nodes ) {
+		if ( 0 <= node.parent && node.parent < graph.nodes.size() && node.index != node.parent ) {
+			node.transform.reference = &graph.nodes[node.parent].transform;
+		}
+	}
+	UF_DEBUG_TRACE_MSG("Processing graph...");
+	uf::graph::process( graph );
+	UF_DEBUG_TRACE_MSG("Finished in " << timer.elapsed().asDouble() << " seconds");
+	if ( graph.metadata["debug"]["print stats"].as<bool>() ) UF_DEBUG_TRACE_MSG(stats( graph ).dump(1,'\t'));
+	if ( graph.metadata["debug"]["print tree"].as<bool>() ) UF_DEBUG_TRACE_MSG(print( graph ));
+	if ( !graph.metadata["debug"]["no cleanup"].as<bool>() ) uf::graph::cleanup( graph );
+	return graph;
+}
+
+namespace {
+	uf::Serializer encode( const uf::Image& image, bool compress = false ) {
+		uf::Serializer json;
+		json["size"] = uf::vector::encode( image.getDimensions() );
+		json["bpp"] = image.getBpp() / image.getChannels();
+		json["channels"] = image.getChannels();
+		json["data"] = uf::base64::encode( image.getPixels() );
+		return json;
+	}
+	uf::Serializer encode( const pod::Texture& texture, bool compress = false ) {
+		uf::Serializer json;
+		json["name"] = texture.name;
+		json["index"] = texture.storage.index;
+		json["sampler"] = texture.storage.sampler;
+		json["remap"] = texture.storage.remap;
+		json["blend"] = texture.storage.blend;
+		json["lerp"] = uf::vector::encode(texture.storage.lerp);
+		return json;
+	}
+	uf::Serializer encode( const uf::renderer::Sampler& sampler, bool compress = false ) {
+		uf::Serializer json;
+		json["min"] = sampler.descriptor.filter.min;
+		json["mag"] = sampler.descriptor.filter.mag;
+		json["u"] = sampler.descriptor.addressMode.u;
+		json["v"] = sampler.descriptor.addressMode.v;
+		return json;
+	}
+	uf::Serializer encode( const pod::Material& material, bool compress = false ) {
+		uf::Serializer json;
+		json["name"] = material.name;
+		json["alphaMode"] = material.alphaMode;
+		json["base"] = uf::vector::encode( material.storage.colorBase );
+		json["emissive"] = uf::vector::encode( material.storage.colorEmissive );
+		json["fMetallic"] = material.storage.factorMetallic;
+		json["fRoughness"] = material.storage.factorRoughness;
+		json["fOcclusion"] = material.storage.factorOcclusion;
+		json["fAlphaCutoff"] = material.storage.factorAlphaCutoff;
+		if ( material.storage.indexAlbedo >= 0 ) json["iAlbedo"] = material.storage.indexAlbedo;
+		if ( material.storage.indexNormal >= 0 ) json["iNormal"] = material.storage.indexNormal;
+		if ( material.storage.indexEmissive >= 0 ) json["iEmissive"] = material.storage.indexEmissive;
+		if ( material.storage.indexOcclusion >= 0 ) json["iOcclusion"] = material.storage.indexOcclusion;
+		if ( material.storage.indexMetallicRoughness >= 0 ) json["iMetallicRoughness"] = material.storage.indexMetallicRoughness;
+		json["modeAlpha"] = material.storage.modeAlpha;
+		return json;
+	}
+	uf::Serializer encode( const pod::Light& light, bool compress = false ) {
+		uf::Serializer json;
+		json["name"] = light.name;
+		json["color"] = uf::vector::encode( light.color );
+		json["intensity"] = light.intensity;
+		json["range"] = light.range;
+		return json;
+	}
+/*
+	uf::Serializer encode( const pod::DrawCall& drawCall, bool compress = false ) {
+		uf::Serializer json;
+		json["name"] = drawCall.name;
+
+		json["materialIndex"] = drawCall.storage.materialIndex;
+		json["materials"] = drawCall.storage.materials;
+		json["textureIndex"] = drawCall.storage.textureIndex;
+		json["textures"] = drawCall.storage.textures;
+
+		json["verticesIndex"] = drawCall.verticesIndex;
+		json["vertices"] = drawCall.vertices;
+		json["indicesIndex"] = drawCall.indicesIndex;
+		json["indices"] = drawCall.indices;
+		return json;
+	}
+*/
+	uf::Serializer encode( const pod::Animation& animation, bool compress = false ) {
+		uf::Serializer json;
+		json["name"] = animation.name;
+		json["start"] = animation.start;
+		json["end"] = animation.end;
+
+		ext::json::reserve( json["samplers"], animation.samplers.size() );
+		auto& samplers = json["samplers"];
+		for ( auto& sampler : animation.samplers ) {
+			auto& json = samplers.emplace_back();
+			json["interpolator"] = sampler.interpolator;
+			for ( auto& input : sampler.inputs ) json["inputs"].emplace_back(input);
+			for ( auto& output : sampler.outputs ) {
+				json["outputs"].emplace_back(uf::vector::encode( output, compress ));
+			}
+		}
+		ext::json::reserve( json["channels"], animation.channels.size() );
+		auto& channels = json["channels"];
+		for ( auto& channel : animation.channels ) {
+			auto& json = channels.emplace_back();
+			json["path"] = channel.path;
+			json["node"] = channel.node;
+			json["sampler"] = channel.sampler;
+		}
+		return json;
+	}	
+	uf::Serializer encode( const pod::Skin& skin, bool compress = false ) {
+		uf::Serializer json;
+		json["name"] = skin.name;
+
+		ext::json::reserve( json["joints"], skin.joints.size() );
+		for ( auto& joint : skin.joints ) json["joints"].emplace_back( joint );
+
+		ext::json::reserve( json["inverseBindMatrices"], skin.inverseBindMatrices.size() );
+		for ( auto& inverseBindMatrix : skin.inverseBindMatrices )
+			json["inverseBindMatrices"].emplace_back( uf::matrix::encode(inverseBindMatrix, compress) );
+		return json;
+	}	
+	uf::Serializer encode( const pod::Graph::Mesh& mesh, bool compress = false ) {
+		uf::Serializer json;
+		ext::json::reserve( json["attributes"], mesh.attributes.descriptor.size() );
+		for ( auto& attribute : mesh.attributes.descriptor ) {
+			auto& a = json["attributes"].emplace_back();
+			a["name"] = attribute.name;
+			a["size"] = attribute.size;
+			a["type"] = attribute.type;
+			a["format"] = attribute.format;
+			a["offset"] = attribute.offset;
+			a["components"] = attribute.components;
+		}
+		ext::json::reserve( json["vertices"], mesh.vertices.size() );
+		for ( auto& vertex : mesh.vertices ) {
+			auto& v = json["vertices"].emplace_back();
+			v.emplace_back(!vertex.position ? ext::json::array() : uf::vector::encode(vertex.position, compress));
+			v.emplace_back(!vertex.uv ? ext::json::array() : uf::vector::encode(vertex.uv, compress));
+			v.emplace_back(!vertex.normal ? ext::json::array() : uf::vector::encode(vertex.normal, compress));
+			v.emplace_back(!vertex.tangent ? ext::json::array() : uf::vector::encode(vertex.tangent, compress));
+			v.emplace_back(!vertex.id ? ext::json::array() : uf::vector::encode(vertex.id, compress));
+			v.emplace_back(!vertex.joints ? ext::json::array() : uf::vector::encode(vertex.joints, compress));
+			v.emplace_back(!vertex.weights ? ext::json::array() : uf::vector::encode(vertex.weights, compress));
+		}
+		ext::json::reserve( json["indices"], mesh.indices.size() );
+		for ( auto& index : mesh.indices ) json["indices"].emplace_back(index);
+		return json;
+	}
+	uf::Serializer encode( const pod::Node& node, bool compress = false ) {
+		uf::Serializer json;
+		json["name"] = node.name;
+		json["index"] = node.index;
+		if ( node.skin >= 0 ) json["skin"] = node.skin;
+		if ( node.mesh >= 0 ) json["mesh"] = node.mesh;
+		if ( node.parent >= 0 ) json["parent"] = node.parent;
+		ext::json::reserve( json["children"], node.children.size() );
+		for ( auto& child : node.children ) json["children"].emplace_back(child);
+
+		json["transform"] = uf::transform::encode( node.transform, false, compress );
+		return json;
+	}
+}
+void uf::graph::save( const std::string& filename, const pod::Graph& graph ) {
+	std::string directory = uf::io::directory( filename ) + "/" + uf::io::basename(filename) + "/";
+	std::string target = uf::io::directory( filename ) + "/" + uf::io::basename(filename) + ".graph";
+
+	uf::Serializer serializer;
+	// store metadata
+	serializer["name"] = graph.name;
+	serializer["mode"] = graph.mode;
+	serializer["metadata"] = graph.metadata;
+	serializer["metadata"]["mesh optimization"] = 0;
+	bool saveSeparately = graph.metadata["debug"]["export"]["split"].as<bool>();
+	bool compression = graph.metadata["debug"]["export"]["compression"].as<bool>();
+	// store images
+	if ( saveSeparately ) {
+		uf::io::mkdir(directory);
+	}
+	ext::json::reserve( serializer["images"], graph.images.size() );
+	if ( saveSeparately ) {
+		for ( size_t i = 0; i < graph.images.size(); ++i ) {
+			std::string f = "image."+std::to_string(i)+(compression?".jpg":".png");
+			graph.images[i].save(directory + "/" + f);
+			serializer["images"].emplace_back(f);
+		}
+	} else {
+		for ( auto& image : graph.images ) serializer["images"].emplace_back( encode(image, compression) );
+	}
+	// store texture information
+	ext::json::reserve( serializer["textures"], graph.textures.size() );
+	for ( auto& texture : graph.textures ) serializer["textures"].emplace_back( encode(texture, compression) );
+	// store sampler information
+	ext::json::reserve( serializer["samplers"], graph.samplers.size() );
+	for ( auto& sampler : graph.samplers ) serializer["samplers"].emplace_back( encode(sampler, compression) );
+	// store material information
+	ext::json::reserve( serializer["materials"], graph.materials.size() );
+	for ( auto& material : graph.materials ) serializer["materials"].emplace_back( encode(material, compression) );
+	// store light information
+	ext::json::reserve( serializer["lighting"], graph.lights.size() );
+	for ( auto& light : graph.lights ) serializer["lighting"].emplace_back( encode(light, compression) );
+	// store animation information
+	ext::json::reserve( serializer["animations"], graph.animations.size() );
+	if ( saveSeparately ) {
+		for ( auto pair : graph.animations ) {
+			std::string f = "animation."+pair.first+".json";
+			encode(pair.second, compression).writeToFile(directory+"/" + f);
+			serializer["animations"].emplace_back(f);
+		}
+	} else {
+		for ( auto pair : graph.animations ) serializer["animations"][pair.first] = encode(pair.second, compression);
+	}
+	// store skin information
+	ext::json::reserve( serializer["skins"], graph.skins.size() );
+	for ( auto& skin : graph.skins ) serializer["skins"].emplace_back( encode(skin, compression) );
+	// store mesh information
+	ext::json::reserve( serializer["meshes"], graph.meshes.size() );
+	if ( saveSeparately ) {
+		for ( size_t i = 0; i < graph.meshes.size(); ++i ) {
+			std::string f = "mesh."+std::to_string(i)+".json";
+			encode(graph.meshes[i], compression).writeToFile(directory+"/" + f);
+			serializer["meshes"].emplace_back(f);
+		}
+	} else {
+		for ( auto& mesh : graph.meshes ) serializer["meshes"].emplace_back( encode(mesh, compression) );
+	}
+	// store node information
+	ext::json::reserve( serializer["nodes"], graph.nodes.size() );
+	for ( auto& node : graph.nodes ) serializer["nodes"].emplace_back( encode(node, compression) );
+	serializer["root"] = encode(graph.root, compression);
+
+	if ( saveSeparately ) target = directory + "/graph.json";
+	if ( graph.metadata["debug"]["export"]["precision"].is<size_t>() ) {
+		serializer.writeToFile( target, graph.metadata["debug"]["export"]["precision"].as<size_t>() );
+	} else {
+		serializer.writeToFile( target );
+	}
+}
+
+std::string uf::graph::print( const pod::Graph& graph ) {
+	std::stringstream ss;
+	ss << "Graph Data:"
+		"\n\tImages: " << graph.images.size() << ""
+		"\n\tTextures: " << graph.textures.size() << ""
+		"\n\tMaterials: " << graph.materials.size() << ""
+		"\n\tLights: " << graph.lights.size() << ""
+		"\n\tMeshes: " << graph.meshes.size() << ""
+		"\n\tAnimations: " << graph.animations.size() << ""
+		"\n\tNodes: " << graph.nodes.size() << ""
+		"\n";
+	ss << "Graph Tree: \n";
+	std::function<void(const pod::Node&, size_t)> print = [&]( const pod::Node& node, size_t indent ) {
+		for ( size_t i = 0; i < indent; ++i ) ss << "\t";
+		ss << "Node[" << node.index << "] " << node.name << ":\n";
+		for ( auto index : node.children ) print( graph.nodes[index], indent + 1 );
+	};
+	print( graph.root, 1 );
+	return ss.str();
+}
+uf::Serializer uf::graph::stats( const pod::Graph& graph ) {
+	ext::json::Value json;
+
+	size_t memoryTextures = sizeof(pod::Texture::Storage) * graph.textures.size();
+	size_t memoryMaterials = sizeof(pod::Material::Storage) * graph.materials.size();
+	size_t memoryLights = sizeof(pod::Light) * graph.lights.size();
+	size_t memoryImages = 0;
+	size_t memoryMeshes = 0;
+	size_t memoryAnimations = 0;
+	size_t memoryNodes = 0;
+	size_t memoryStrings = 0;
+	size_t stringsCount = 0;
+
+	for ( auto& texture : graph.textures ) {
+		memoryStrings += sizeof(char) * texture.name.length();
+		++memoryStrings;
+	}
+	for ( auto& material : graph.materials ) {
+		memoryStrings += sizeof(char) * material.name.length();
+		++memoryStrings;
+	}
+	for ( auto& light : graph.lights ) {
+		memoryStrings += sizeof(char) * light.name.length();
+		++memoryStrings;
+	}
+
+	for ( auto& image : graph.images ) memoryImages += image.getPixels().size();
+	for ( auto& mesh : graph.meshes ) {
+		memoryMeshes += sizeof(ext::gltf::mesh_t::vertex_t) * mesh.vertices.size();
+		memoryMeshes += sizeof(ext::gltf::mesh_t::indices_t) * mesh.indices.size();
+	}
+	for ( auto pair : graph.animations ) {
+		memoryAnimations += sizeof(float) * 3;
+		for ( auto& sampler : pair.second.samplers ) {
+			memoryAnimations += sizeof(float) * 1 * sampler.inputs.size();
+			memoryAnimations += sizeof(float) * 4 * sampler.outputs.size();
+			memoryStrings += sizeof(char) * sampler.interpolator.length();
+			++stringsCount;
+		}
+		for ( auto& channel : pair.second.channels ) {
+			memoryAnimations += sizeof(uint32_t) * 2;
+			memoryStrings += sizeof(char) * channel.path.length();
+			++stringsCount;
+		}
+	}
+	for ( auto& node : graph.nodes ) {
+		memoryNodes += sizeof(int32_t) * 4;
+		memoryNodes += sizeof(int32_t) * node.children.size();
+		memoryStrings += sizeof(char) * node.name.length();
+		++stringsCount;
+	}
+
+	json["strings"]["size"] = stringsCount; json["strings"]["bytes"] = memoryStrings;
+	json["images"]["size"] = graph.images.size(); json["images"]["bytes"] = memoryImages;
+	json["textures"]["size"] = graph.textures.size(); json["textures"]["bytes"] = memoryTextures;
+	json["materials"]["size"] = graph.materials.size(); json["materials"]["bytes"] = memoryMaterials;
+	json["lights"]["size"] = graph.lights.size(); json["lights"]["bytes"] = memoryLights;
+	json["meshes"]["size"] = graph.meshes.size(); json["meshes"]["bytes"] = memoryMeshes;
+	json["animations"]["size"] = graph.animations.size(); json["animations"]["bytes"] = memoryAnimations;
+	json["nodes"]["size"] = graph.nodes.size(); json["nodes"]["bytes"] = memoryNodes;
+	json["bytes"] = (memoryTextures + memoryMaterials + memoryLights + memoryImages + memoryMeshes + memoryAnimations + memoryNodes + memoryStrings);
+/*
+	std::cout << "Graph stats: " << 
+		"\n\tNames: Bytes: " << memoryStrings << ""
+		"\n\tImages: " << graph.images.size() << " | Bytes: " << memoryImages << ""
+		"\n\tTextures: " << graph.textures.size() << " | Bytes: " << memoryTextures << ""
+		"\n\tMaterials: " << graph.materials.size() << " | Bytes: " << memoryMaterials << ""
+		"\n\tLights: " << graph.lights.size() << " | Bytes: " << memoryLights << ""
+		"\n\tMeshes: " << graph.meshes.size() << " | Bytes: " << memoryMeshes << ""
+		"\n\tAnimations: " << graph.animations.size() << " | Bytes: " << memoryAnimations << ""
+		"\n\tNodes: " << graph.nodes.size() << " | Bytes: " << memoryNodes << ""
+		"\n\tTotal: " << (memoryTextures + memoryMaterials + memoryLights + memoryImages + memoryMeshes + memoryAnimations + memoryNodes + memoryStrings) << std::endl;
+*/
+	return json;
+}
\ No newline at end of file
diff --git a/engine/src/ext/gltf/mesh.cpp b/engine/src/ext/gltf/mesh.cpp
new file mode 100644
index 00000000..e46dbdef
--- /dev/null
+++ b/engine/src/ext/gltf/mesh.cpp
@@ -0,0 +1,19 @@
+#include <uf/ext/gltf/mesh.h>
+#include <uf/utils/graphic/descriptor.h>
+
+UF_VERTEX_DESCRIPTOR(ext::gltf::mesh::ID,
+	UF_VERTEX_DESCRIPTION(ext::gltf::mesh::ID, R32G32B32_SFLOAT, position)
+	UF_VERTEX_DESCRIPTION(ext::gltf::mesh::ID, R32G32_SFLOAT, uv)
+	UF_VERTEX_DESCRIPTION(ext::gltf::mesh::ID, R32G32B32_SFLOAT, normal)
+	UF_VERTEX_DESCRIPTION(ext::gltf::mesh::ID, R32G32B32_SFLOAT, tangent)
+	UF_VERTEX_DESCRIPTION(ext::gltf::mesh::ID, R32G32_SINT, id)
+);
+UF_VERTEX_DESCRIPTOR(ext::gltf::mesh::Skinned,
+	UF_VERTEX_DESCRIPTION(ext::gltf::mesh::Skinned, R32G32B32_SFLOAT, position)
+	UF_VERTEX_DESCRIPTION(ext::gltf::mesh::Skinned, R32G32_SFLOAT, uv)
+	UF_VERTEX_DESCRIPTION(ext::gltf::mesh::Skinned, R32G32B32_SFLOAT, normal)
+	UF_VERTEX_DESCRIPTION(ext::gltf::mesh::Skinned, R32G32B32_SFLOAT, tangent)
+	UF_VERTEX_DESCRIPTION(ext::gltf::mesh::Skinned, R32G32_SINT, id)
+	UF_VERTEX_DESCRIPTION(ext::gltf::mesh::Skinned, R32G32B32A32_SINT, joints)
+	UF_VERTEX_DESCRIPTION(ext::gltf::mesh::Skinned, R32G32B32A32_SFLOAT, weights)
+);
\ No newline at end of file
diff --git a/engine/src/ext/json/json.cpp b/engine/src/ext/json/json.cpp
new file mode 100644
index 00000000..a7679777
--- /dev/null
+++ b/engine/src/ext/json/json.cpp
@@ -0,0 +1,185 @@
+#include <uf/ext/json/json.h>
+#include <uf/utils/io/iostream.h>
+#include <iomanip>
+
+//#define SAFE_ASSERT(...) if ( !(__VA_ARGS__) ) UF_DEBUG_MSG("ASSERTION FAILED:" << #__VA_ARGS__);
+#define SAFE_ASSERT(...) UF_DEBUG_MSG("ASSERTION FAILED: " << #__VA_ARGS__);
+
+ext::json::Value& ext::json::Value::operator=( const ext::json::Value& json ) {
+	ext::json::base_value::operator=( (const ext::json::base_value&) json );
+	return *this;
+}
+
+ext::json::Value& ext::json::reserve( ext::json::Value& value, size_t size ) {
+	if ( !ext::json::isArray( value ) ) value = ext::json::array();
+	value.reserve(size);
+	return value;
+}
+
+#if UF_JSON_USE_NLOHMANN
+ext::json::Value& ext::json::Value::reserve( size_t n ) {
+	auto* ptr = this->get_ptr<ext::json::base_value::array_t*>();
+	if ( ptr ) ptr->reserve(n);
+	return *this;
+}
+#endif
+
+void ext::json::forEach( ext::json::Value& json, const std::function<void(ext::json::Value&)>& function ) {
+//	SAFE_ASSERT( ext::json::isArray(json) || ext::json::isObject(json) );
+//	for ( auto it = json.begin(); it != json.end(); ++it ) { auto& v = *it;
+	for ( auto& v : json ) {
+		function( (ext::json::Value&) v );
+	}
+}
+void ext::json::forEach( ext::json::Value& json, const std::function<void(size_t, ext::json::Value&)>& function ) {
+//	SAFE_ASSERT( ext::json::isArray(json) );
+	for ( size_t i = 0; i < json.size(); ++i ) {
+		function( i, (ext::json::Value&) json[i] );
+	}
+}
+void ext::json::forEach( ext::json::Value& json, const std::function<void(const std::string&, ext::json::Value&)>& function ) {
+//	SAFE_ASSERT( ext::json::isObject(json) );
+	for ( auto it = json.begin(); it != json.end(); ++it ) {
+		function( it.key(), (ext::json::Value&) *it );
+	}
+}
+void ext::json::forEach( ext::json::Value& json, const std::function<void(ext::json::Value&, bool&)>& function ) {
+//	SAFE_ASSERT( ext::json::isArray(json) || ext::json::isObject(json) );
+//	for ( auto it = json.begin(); it != json.end(); ++it ) { auto& v = *it;
+	for ( auto& v : json ) {
+		bool breaks = false;
+		function( (ext::json::Value&) v, breaks );
+		if ( breaks ) break;
+	}
+}
+void ext::json::forEach( ext::json::Value& json, const std::function<void(size_t, ext::json::Value&, bool&)>& function ) {
+//	SAFE_ASSERT( ext::json::isArray(json) );
+	for ( size_t i = 0; i < json.size(); ++i ) {
+		bool breaks = false;
+		function( i, (ext::json::Value&) json[i], breaks );
+		if ( breaks ) break;
+	}
+}
+void ext::json::forEach( ext::json::Value& json, const std::function<void(const std::string&, ext::json::Value&, bool&)>& function ) {
+//	SAFE_ASSERT( ext::json::isObject(json) );
+	for ( auto it = json.begin(); it != json.end(); ++it ) {
+		bool breaks = false;
+		function( it.key(), (ext::json::Value&) *it, breaks );
+		if ( breaks ) break;
+	}
+}
+
+void ext::json::forEach( const ext::json::Value& json, const std::function<void(size_t, const ext::json::Value&)>& function ) {
+//	SAFE_ASSERT( ext::json::isArray(json) );
+	for ( size_t i = 0; i < json.size(); ++i ) {
+		function( i, (const ext::json::Value&) json[i] );
+	}
+}
+void ext::json::forEach( const ext::json::Value& json, const std::function<void(const std::string&, const ext::json::Value&)>& function ) {
+//	SAFE_ASSERT( ext::json::isObject(json) );
+	for ( auto it = json.begin(); it != json.end(); ++it ) {
+		function( it.key(), (const ext::json::Value&) *it );
+	}
+}
+void ext::json::forEach( const ext::json::Value& json, const std::function<void(size_t, const ext::json::Value&, bool&)>& function ) {
+//	SAFE_ASSERT( ext::json::isArray(json) );
+	for ( size_t i = 0; i < json.size(); ++i ) {
+		bool breaks = false;
+		function( i, (const ext::json::Value&) json[i], breaks );
+		if ( breaks ) break;
+	}
+}
+void ext::json::forEach( const ext::json::Value& json, const std::function<void(const std::string&, const ext::json::Value&, bool&)>& function ) {
+//	SAFE_ASSERT( ext::json::isObject(json) );
+	for ( auto it = json.begin(); it != json.end(); ++it ) {
+		bool breaks = false;
+		function( it.key(), (const ext::json::Value&) *it, breaks );
+		if ( breaks ) break;
+	}
+}
+void ext::json::forEach( const ext::json::Value& json, const std::function<void(const ext::json::Value&)>& function ) {
+//	SAFE_ASSERT( ext::json::isArray(json) || ext::json::isObject(json) );
+//	for ( auto it = json.begin(); it != json.end(); ++it ) { auto& v = *it;
+	for ( auto& v : json ) {
+		function( (const ext::json::Value&) v );
+	}
+}
+void ext::json::forEach( const ext::json::Value& json, const std::function<void(const ext::json::Value&, bool&)>& function ) {
+//	SAFE_ASSERT( ext::json::isArray(json) || ext::json::isObject(json) );
+//	for ( auto it = json.begin(); it != json.end(); ++it ) { auto& v = *it;
+	for ( auto& v : json ) {
+		bool breaks = false;
+		function( (const ext::json::Value&) v, breaks );
+		if ( breaks ) break;
+	}
+}
+
+#if defined(UF_JSON_USE_NLOHMANN) && UF_JSON_USE_NLOHMANN
+std::vector<std::string> ext::json::keys( const ext::json::Value& v ) {
+	std::vector<std::string> keys;
+	if ( !ext::json::isObject( v ) ) return keys;
+	for ( auto it = v.begin(); it != v.end(); ++it ) {
+		keys.emplace_back(it.key());
+	}
+	return keys;
+}
+#elif defined(UF_JSON_USE_RAPIDJSON) && UF_JSON_USE_RAPIDJSON
+	rapidjson::Document::AllocatorType ext::json::allocator;
+#endif
+
+std::string ext::json::encode( const ext::json::Value& json, bool pretty ) {
+#if defined(UF_JSON_USE_NLOHMANN) && UF_JSON_USE_NLOHMANN
+	return pretty ? json.dump(1, '\t') : json.dump();
+#elif defined(UF_JSON_USE_JSONCPP) && UF_JSON_USE_JSONCPP
+	Json::FastWriter fast;
+	Json::StyledWriter styled;
+	std::string output = pretty ? styled.write(json) : fast.write(json);
+	if ( output.back() == '\n' ) output.pop_back();
+	return output;
+#elif defined(UF_JSON_USE_LUA) && UF_JSON_USE_LUA
+	return ext::lua::state["json"]["encode"]( table );
+#endif
+}
+std::string ext::json::encode( const ext::json::Value& json, size_t precision, bool pretty ) {
+#if defined(UF_JSON_USE_NLOHMANN) && UF_JSON_USE_NLOHMANN
+	std::stringstream ss;
+	ss.precision(precision);
+	if ( pretty ) ss << std::setw(4);
+	ss << json;
+	return ss.str();
+//	return pretty ? json.dump(1, '\t') : json.dump();
+#elif defined(UF_JSON_USE_JSONCPP) && UF_JSON_USE_JSONCPP
+	Json::FastWriter fast;
+	Json::StyledWriter styled;
+	std::string output = pretty ? styled.write(json) : fast.write(json);
+	if ( output.back() == '\n' ) output.pop_back();
+	return output;
+#elif defined(UF_JSON_USE_LUA) && UF_JSON_USE_LUA
+	return ext::lua::state["json"]["encode"]( table );
+#endif
+}
+#if UF_USE_LUA
+std::string ext::json::encode( const sol::table& table ) {
+	return ext::lua::state["json"]["encode"]( table );
+}
+#endif
+void ext::json::decode( ext::json::Value& json, const std::string& str ) {
+#if defined(UF_JSON_USE_NLOHMANN) && UF_JSON_USE_NLOHMANN
+#if UF_NO_EXCEPTIONS
+	json = nlohmann::json::parse(str, nullptr, true, true);
+#else
+	try {
+		json = nlohmann::json::parse(str, nullptr, true, true);
+	} catch ( nlohmann::json::parse_error& e ) {
+		uf::iostream << "[JSON] " << e.what() << "\n";
+	}
+#endif
+#elif defined(UF_JSON_USE_JSONCPP) && UF_JSON_USE_JSONCPP 
+	Json::Reader reader;
+	if ( !reader.parse(str, json) ) {
+		uf::iostream << "JSON Error: " << reader.getFormattedErrorMessages() << "\n";
+	}
+#elif defined(UF_JSON_USE_LUA) && UF_JSON_USE_LUA
+	json = ext::lua::state["json"]["decode"]( str );
+#endif
+}
\ No newline at end of file
diff --git a/engine/src/ext/lua/lua.cpp b/engine/src/ext/lua/lua.cpp
new file mode 100644
index 00000000..fe417d68
--- /dev/null
+++ b/engine/src/ext/lua/lua.cpp
@@ -0,0 +1,266 @@
+#include <uf/ext/lua/lua.h>
+#if UF_USE_LUA
+sol::state ext::lua::state;
+std::string ext::lua::main = uf::io::root + "/scripts/main.lua";
+std::unordered_map<std::string, std::string> ext::lua::modules;
+
+#include <uf/utils/math/transform.h>
+#include <uf/utils/math/physics.h>
+#include <uf/utils/serialize/serializer.h>
+#include <uf/engine/asset/asset.h>
+#include <uf/engine/object/object.h>
+#include <uf/engine/object/behaviors/lua.h>
+#include <uf/utils/string/io.h>
+#include <uf/utils/string/ext.h>
+#include <uf/utils/window/window.h>
+#include <uf/utils/audio/audio.h>
+
+sol::table ext::lua::createTable() {
+	return sol::table(ext::lua::state, sol::create);
+}
+std::string ext::lua::sanitize( const std::string& dirty, int index  ) {
+	auto split = uf::string::split( dirty, "::" );
+	if ( index < 0 ) index = split.size() + index;
+	std::string part = split.at(index);
+	part = uf::string::replace( part, "<>", "" );
+	return part;
+}
+std::optional<std::string> ext::lua::encode( sol::table table ) {
+	sol::protected_function fun = ext::lua::state["json"]["encode"];
+	auto result = fun( table );
+	if ( !result.valid() ) {
+		sol::error err = result;
+		uf::iostream << err.what() << "\n";
+		return "{}";
+	}
+	return result;
+}
+std::optional<sol::table> ext::lua::decode( const std::string& string ) {
+	sol::protected_function fun = ext::lua::state["json"]["decode"];
+	auto result = fun( string );
+	if ( !result.valid() ) {
+		sol::error err = result;
+		uf::iostream << err.what() << "\n";
+		return createTable();
+	}
+	return result;
+}
+
+std::vector<std::function<void()>>* ext::lua::onInitializationFunctions = NULL;
+void ext::lua::onInitialization( const std::function<void()>& function ) {
+	if ( !ext::lua::onInitializationFunctions ) {
+		ext::lua::onInitializationFunctions = new std::vector<std::function<void()>>;
+	}
+	auto& functions = *ext::lua::onInitializationFunctions;
+	functions.emplace_back(function);
+}
+
+void ext::lua::initialize() {
+	state.open_libraries(sol::lib::base, sol::lib::package, sol::lib::table, sol::lib::math, sol::lib::string, sol::lib::ffi, sol::lib::jit);
+
+	// load modules
+	for ( auto pair : modules ) {
+		const std::string& name = pair.first;
+		const std::string& script = pair.second;
+		if ( uf::io::extension(script) == "lua" ) {
+			state.require_file(name, uf::io::resolveURI( script ), true);
+		} else {
+			state.require_script(name, script, true);
+		}
+	}
+
+	// load on-initialization defines
+	if ( ext::lua::onInitializationFunctions ) {
+		auto& functions = *ext::lua::onInitializationFunctions;
+		for ( auto& function : functions ) function();
+	}
+	
+	// `hooks` table
+	{
+
+		auto hooks = state["hooks"].get_or_create<sol::table>();
+		hooks["add"] = []( const std::string& name, const sol::function& function ) {
+			uf::hooks.addHook( name, [function](ext::json::Value& json){
+				sol::table table = ext::lua::state["json"]["decode"]( json.dump() );
+				auto result = function( table );
+				if ( !result.valid() ) {
+					sol::error err = result;
+					uf::iostream << err.what() << "\n";
+				}
+			});
+		};
+		hooks["call"] = []( const std::string& name, sol::table table = createTable() ) {
+			uf::Serializer payload = table;
+			return uf::hooks.call( name, (ext::json::Value&) payload );
+		};
+	}
+	// `entities` table
+	{
+		auto entities = state["entities"].get_or_create<sol::table>();
+		entities["get"] = [](const uint& uid)->uf::Object&{
+			auto* p = uf::Entity::globalFindByUid(uid);
+			if ( p ) return p->as<uf::Object>();
+			static uf::Object null;
+			return null;
+		};
+		entities["currentScene"] = []()->uf::Object&{
+			return uf::scene::getCurrentScene().as<uf::Object>();
+		};
+		entities["controller"] = []()->uf::Object&{
+			return uf::scene::getCurrentScene().getController().as<uf::Object>();
+		};
+		entities["destroy"] = []( uf::Object& object ){
+			object.getParent().removeChild(object);
+			object.destroy();
+		//	delete &object;
+		};
+	}
+	// `string` table
+	{
+		auto string = state["string"].get_or_create<sol::table>();
+		string["extension"] = []( const std::string& filename ) {
+			return uf::io::extension( filename );
+		};
+		string["resolveURI"] = []( const std::string& filename, sol::variadic_args va ) {
+			auto it = va.begin();
+			std::string root = it != va.end() ? *(it++) : std::string("");
+			return uf::io::resolveURI( filename, root );
+		};
+		string["si"] = []( sol::variadic_args va ) {
+			auto it = va.begin();
+			double value = *(it++);
+			std::string unit = *(it++);
+			size_t precision = va.size() > 2 ? *(it++) : 3;
+			return uf::string::si( value, unit, precision );
+		};
+	}
+	// `io` table
+	{
+		auto io = state["io"].get_or_create<sol::table>();
+		io["print"] = []( sol::variadic_args va ) {
+			size_t count = va.size();
+			for ( auto value : va ) {
+				std::string str = ext::lua::state["tostring"]( value );
+				uf::iostream << str;
+				if ( --count != 0 ) uf::iostream << "\t";
+			}
+			uf::iostream << "\n";
+		};
+	}
+	// `math` table
+	{
+		auto math = state["math"].get_or_create<sol::table>();
+		math["clamp"] = []( double value, double min, double max ) {
+			return std::clamp( value, min, max );
+		};
+	}
+	// `time` table
+	{
+		auto time = state["time"].get_or_create<sol::table>();
+		time["current"] = []()->double{ return uf::physics::time::current; };
+		time["previous"] = []()->double{ return uf::physics::time::previous; };
+		time["delta"] = []()->double{ return uf::physics::time::delta; };
+	}
+	// `json` table
+	{
+		state["json"]["pretty"] = []( const std::string& json )->std::string{
+			uf::Serializer serializer = json;
+			return serializer.serialize();
+		};
+		state["json"]["readFromFile"] = []( const std::string& filename ){
+			uf::Serializer serializer;
+			serializer.readFromFile( filename );
+			std::string string = serializer.serialize(false);
+			auto decoded = decode( string );
+			return decoded ? decoded.value() : ext::lua::createTable();
+		};
+		state["json"]["writeToFile"] = []( sol::table table, const std::string& path ) {
+			if ( uf::io::extension(path) != "json" ) return false;
+			auto encoded = encode( table );
+			if ( encoded ) {
+				uf::Serializer json = encoded.value();
+				json.writeToFile( path );
+				return true;
+			}
+			return false;
+		};
+	}
+	// `window` table
+	{
+		auto window = state["window"].get_or_create<sol::table>();
+		window["keyPressed"] = [](const std::string& name)->bool{
+			return uf::Window::isKeyPressed(name);
+		};
+	}
+	run(main);
+}
+bool ext::lua::run( const std::string& s, bool safe ) {
+	// is file
+	if ( uf::io::extension(s) == "lua" ) {
+		if ( safe ) {
+			auto result = state.safe_script_file( uf::io::resolveURI( s ), sol::script_pass_on_error );
+			if ( !result.valid() ) {
+				sol::error err = result;
+				uf::iostream << err.what() << "\n";
+				return false;
+			}
+		} else {
+			state.script_file( uf::io::resolveURI( s ) );
+		}
+	// is string with lua
+	} else {
+		if ( safe ) {
+			auto result = state.safe_script( s, sol::script_pass_on_error );
+			if ( !result.valid() ) {
+				sol::error err = result;
+				uf::iostream << err.what() << "\n";
+				return false;
+			}
+		} else {
+			state.script( s );
+		}
+	}
+	return true;
+}
+
+pod::LuaScript ext::lua::script( const std::string& filename ) {
+	pod::LuaScript script;
+	script.file = filename;
+	script.env = sol::environment( ext::lua::state, sol::create, ext::lua::state.globals() );
+	return script;
+}
+bool ext::lua::run( const pod::LuaScript& s, bool safe ) {
+	// is file
+	if ( uf::io::extension(s.file) == "lua" ) {
+		if ( safe ) {
+			auto result = state.safe_script_file( s.file, s.env, sol::script_pass_on_error );
+			if ( !result.valid() ) {
+				sol::error err = result;
+				uf::iostream << err.what() << "\n";
+				return false;
+			}
+		} else {
+			state.script_file( s.file );
+		}
+	// is string with lua
+	} else {
+		if ( safe ) {
+			auto result = state.safe_script( s.file, s.env, sol::script_pass_on_error );
+			if ( !result.valid() ) {
+				sol::error err = result;
+				uf::iostream << err.what() << "\n";
+				return false;
+			}
+		} else {
+			state.script( s.file );
+		}
+	}
+	return true;
+}
+void ext::lua::terminate() {
+	if ( ext::lua::onInitializationFunctions ) {
+		delete ext::lua::onInitializationFunctions;
+		ext::lua::onInitializationFunctions = NULL;
+	}
+}
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/lua/usertypes/asset.cpp b/engine/src/ext/lua/usertypes/asset.cpp
new file mode 100644
index 00000000..05c3d5c2
--- /dev/null
+++ b/engine/src/ext/lua/usertypes/asset.cpp
@@ -0,0 +1,38 @@
+#include <uf/ext/lua/lua.h>
+#if UF_USE_LUA
+#include <uf/engine/asset/asset.h>
+
+UF_LUA_REGISTER_USERTYPE(uf::Asset,
+	UF_LUA_REGISTER_USERTYPE_DEFINE( load, []( uf::Asset& asset, sol::variadic_args va ) {
+		auto it = va.begin();
+		std::string callback = "";
+		std::string uri = "";
+		std::string hash = "";
+		std::string category = "";
+		if ( it != va.end() ) callback = *(it++);
+		if ( it != va.end() ) uri = *(it++);
+		if ( it != va.end() ) hash = *(it++);
+		if ( it != va.end() ) category = *(it++);
+		if ( callback == "" )
+			asset.load( uri, hash, category );
+		else
+			asset.load( callback, uri, hash, category );
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( cache, []( uf::Asset& asset, sol::variadic_args va ) {
+		auto it = va.begin();
+		std::string callback = "";
+		std::string uri = "";
+		std::string hash = "";
+		std::string category = "";
+		if ( it != va.end() ) callback = *(it++);
+		if ( it != va.end() ) uri = *(it++);
+		if ( it != va.end() ) hash = *(it++);
+		if ( it != va.end() ) category = *(it++);
+		if ( callback == "" )
+			asset.cache( uri, hash, category );
+		else
+			asset.cache( callback, uri, hash, category );
+	}),
+	UF_LUA_REGISTER_USERTYPE_MEMBER( uf::Asset::getOriginal )
+)
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/lua/usertypes/audio.cpp b/engine/src/ext/lua/usertypes/audio.cpp
new file mode 100644
index 00000000..bb090bbd
--- /dev/null
+++ b/engine/src/ext/lua/usertypes/audio.cpp
@@ -0,0 +1,34 @@
+#include <uf/ext/lua/lua.h>
+#if UF_USE_LUA
+#include <uf/utils/audio/audio.h>
+
+UF_LUA_REGISTER_USERTYPE(uf::Audio,
+	sol::call_constructor, sol::initializers( []( uf::Audio& self ){},
+	[]( uf::Audio& self, const std::string& filename = "", double volume = 1 ){
+		if ( filename != "" ) self.load(filename);
+		self.setVolume(volume);
+	}),
+	UF_LUA_REGISTER_USERTYPE_MEMBER( uf::Audio::initialized ),
+	UF_LUA_REGISTER_USERTYPE_MEMBER( uf::Audio::playing ),
+	UF_LUA_REGISTER_USERTYPE_MEMBER( uf::Audio::destroy ),
+	UF_LUA_REGISTER_USERTYPE_MEMBER( uf::Audio::load ),
+	UF_LUA_REGISTER_USERTYPE_MEMBER( uf::Audio::play ),
+	UF_LUA_REGISTER_USERTYPE_MEMBER( uf::Audio::stop ),
+	UF_LUA_REGISTER_USERTYPE_MEMBER( uf::Audio::getTime ),
+	UF_LUA_REGISTER_USERTYPE_MEMBER( uf::Audio::setTime ),
+	UF_LUA_REGISTER_USERTYPE_MEMBER( uf::Audio::getDuration ),
+	UF_LUA_REGISTER_USERTYPE_MEMBER( uf::Audio::setPosition ),
+	UF_LUA_REGISTER_USERTYPE_MEMBER( uf::Audio::setOrientation ),
+	UF_LUA_REGISTER_USERTYPE_MEMBER( uf::Audio::setVolume ),
+	UF_LUA_REGISTER_USERTYPE_MEMBER( uf::Audio::getPitch ),
+	UF_LUA_REGISTER_USERTYPE_MEMBER( uf::Audio::setPitch ),
+	UF_LUA_REGISTER_USERTYPE_MEMBER( uf::Audio::getGain ),
+	UF_LUA_REGISTER_USERTYPE_MEMBER( uf::Audio::setGain ),
+	UF_LUA_REGISTER_USERTYPE_MEMBER( uf::Audio::getRolloffFactor ),
+	UF_LUA_REGISTER_USERTYPE_MEMBER( uf::Audio::setRolloffFactor ),
+	UF_LUA_REGISTER_USERTYPE_MEMBER( uf::Audio::getMaxDistance ),
+	UF_LUA_REGISTER_USERTYPE_MEMBER( uf::Audio::setMaxDistance ),
+	UF_LUA_REGISTER_USERTYPE_MEMBER( uf::Audio::getVolume ),
+	UF_LUA_REGISTER_USERTYPE_MEMBER( uf::Audio::getFilename )
+)
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/lua/usertypes/camera.cpp b/engine/src/ext/lua/usertypes/camera.cpp
new file mode 100644
index 00000000..9a3b30a8
--- /dev/null
+++ b/engine/src/ext/lua/usertypes/camera.cpp
@@ -0,0 +1,43 @@
+#include <uf/ext/lua/lua.h>
+#if UF_USE_LUA
+#include <uf/utils/camera/camera.h>
+
+UF_LUA_REGISTER_USERTYPE(uf::Camera,
+	UF_LUA_REGISTER_USERTYPE_DEFINE( getTransform, []( uf::Camera& self ) {
+		return self.getTransform();
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( getView, []( const uf::Camera& self, sol::variadic_args va ) {
+		auto it = va.begin();
+		if ( va.size() > 0 ) {
+			size_t i = *it++;
+			return self.getView(i);
+		}
+		return self.getView();
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( getProjection, []( const uf::Camera& self, sol::variadic_args va ) {
+		auto it = va.begin();
+		if ( va.size() > 0 ) {
+			size_t i = *it++;
+			return self.getProjection(i);
+		}
+		return self.getProjection();
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( setView, []( uf::Camera& self, const pod::Matrix4f& matrix, sol::variadic_args va ) {
+		auto it = va.begin();
+		if ( va.size() > 0 ) {
+			size_t i = *it++;
+			return self.setView(matrix, i);
+		}
+		return self.setView(matrix);
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( setProjection, []( uf::Camera& self, const pod::Matrix4f& matrix, sol::variadic_args va ) {
+		auto it = va.begin();
+		if ( va.size() > 0 ) {
+			size_t i = *it++;
+			return self.setProjection(matrix, i);
+		}
+		return self.setProjection(matrix);
+	}),
+	UF_LUA_REGISTER_USERTYPE_MEMBER( uf::Camera::update )
+)
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/lua/usertypes/matrix.cpp b/engine/src/ext/lua/usertypes/matrix.cpp
new file mode 100644
index 00000000..8fd200d1
--- /dev/null
+++ b/engine/src/ext/lua/usertypes/matrix.cpp
@@ -0,0 +1,36 @@
+#include <uf/ext/lua/lua.h>
+#if UF_USE_LUA
+#include <uf/utils/math/matrix.h>
+
+UF_LUA_REGISTER_USERTYPE(pod::Matrix4f,
+	sol::call_constructor, sol::initializers( 
+		[]( pod::Matrix4f& self ) {
+			return self = uf::matrix::identity();
+		},
+		[]( pod::Matrix4f& self, const pod::Matrix4f& copy ) {
+			return self = copy;
+		}
+	),
+	sol::meta_function::multiplication, []( const pod::Matrix4f& left, const pod::Matrix4f& right ) {
+		return uf::matrix::multiply( left, right );
+	},
+	UF_LUA_REGISTER_USERTYPE_DEFINE( m, []( pod::Matrix4f& self, const size_t& index ) {
+		return self[index];
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( multiply, []( const pod::Matrix4f& left, const pod::Matrix4f& right ) {
+		return uf::matrix::multiply( left, right );
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( inverse, []( const pod::Matrix4f& m ) {
+		return uf::matrix::inverse( m );
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( translate, []( const pod::Vector3f& v ) {
+		return uf::matrix::translate( uf::matrix::identity(), v );
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( scale, []( const pod::Vector3f& v ) {
+		return uf::matrix::scale( uf::matrix::identity(), v );
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( identity, []( ) {
+		return uf::matrix::identity();
+	})
+)
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/lua/usertypes/object.cpp b/engine/src/ext/lua/usertypes/object.cpp
new file mode 100644
index 00000000..42bca2c2
--- /dev/null
+++ b/engine/src/ext/lua/usertypes/object.cpp
@@ -0,0 +1,165 @@
+#include <uf/ext/lua/lua.h>
+#if UF_USE_LUA
+#include <uf/utils/math/transform.h>
+#include <uf/utils/audio/audio.h>
+#include <uf/utils/camera/camera.h>
+#include <uf/engine/object/object.h>
+#include <uf/engine/asset/asset.h>
+#include <uf/engine/object/behaviors/lua.h>
+
+namespace {
+	static uf::StaticInitialization TOKEN_PASTE(STATIC_INITIALIZATION_, __LINE__)( []{
+		ext::lua::onInitialization( []{
+			ext::lua::state.new_usertype<uf::Object>(UF_NS_GET_LAST(uf::Object),
+				sol::call_constructor, sol::initializers( []( uf::Object& self, sol::object arg, bool init = true ){
+					if ( arg.is<std::string>() ) {
+						self.load( arg.as<std::string>() );
+					} else if ( arg.is<sol::table>() ) {
+						auto encoded = ext::lua::encode( arg.as<sol::table>() );
+						if ( encoded ) {
+							uf::Serializer json = encoded.value();
+							self.load(json);
+						}
+					}
+					if ( init ) {
+						self.initialize();
+					}
+				}),
+				"uid", &uf::Object::getUid ,
+				"name", &uf::Object::getName ,
+				"formatHookName", [](uf::Object& self, const std::string n ){
+					return self.formatHookName(n);
+				},
+				"getComponent", [](uf::Object& self, const std::string& type )->sol::object{
+					#define UF_LUA_RETRIEVE_COMPONENT( T )\
+						if ( type == UF_NS_GET_LAST(T) ) return sol::make_object( ext::lua::state, std::ref(self.getComponent<T>()) );
+
+					if ( type == "Metadata" ) {
+						auto& metadata = self.getComponent<uf::Serializer>();
+						auto decoded = ext::lua::decode( metadata );
+						if ( decoded ) {
+							sol::table table = decoded.value();
+							return sol::make_object( ext::lua::state, table );
+						}
+					}
+					UF_LUA_RETRIEVE_COMPONENT(pod::Transform<>)
+					UF_LUA_RETRIEVE_COMPONENT(uf::Audio)
+					UF_LUA_RETRIEVE_COMPONENT(uf::Asset)
+					UF_LUA_RETRIEVE_COMPONENT(uf::Camera)
+					return sol::make_object( ext::lua::state, sol::lua_nil );
+				},
+				"setComponent", [](uf::Object& self, const std::string& type, sol::object value ) {
+					#define UF_LUA_UPDATE_COMPONENT( T )\
+						else if ( type == UF_NS_GET_LAST(T) ) self.getComponent<T>() = std::move(value.as<T>());
+
+					if ( type == "Metadata" ) {
+						auto encoded = ext::lua::encode( value.as<sol::table>() );
+						if ( encoded ) {
+							auto& metadata = self.getComponent<uf::Serializer>();
+							std::string str = encoded.value();
+							uf::Serializer hooks = metadata["system"]["hooks"];
+							metadata.merge( str, false );
+							metadata["system"]["hooks"] = hooks;
+						}
+					}
+					UF_LUA_UPDATE_COMPONENT(pod::Transform<>)
+					UF_LUA_UPDATE_COMPONENT(uf::Audio)
+					UF_LUA_UPDATE_COMPONENT(uf::Asset)
+					UF_LUA_UPDATE_COMPONENT(uf::Camera)
+				},
+				"bind", [](uf::Object& self, const std::string& type, sol::protected_function fun ) {
+					if ( !self.hasBehavior<uf::LuaBehavior>() ) uf::instantiator::bind( "LuaBehavior", self );
+					pod::Behavior* behaviorPointer = NULL;
+					auto& behaviors = self.getBehaviors();
+					for ( auto& b : behaviors ) {
+						if ( b.type != self.getType<uf::LuaBehavior>() ) continue;
+						behaviorPointer = &b;
+						break;
+					}
+					if ( !behaviorPointer ) return false;
+					pod::Behavior& behavior = *behaviorPointer;
+
+					pod::Behavior::function_t* functionPointer = NULL;
+					if ( type == "initialize" ) functionPointer = &behavior.initialize;
+					else if ( type == "tick" ) functionPointer = &behavior.tick;
+					else if ( type == "render" ) functionPointer = &behavior.render;
+					else if ( type == "destroy" ) functionPointer = &behavior.destroy;
+					
+					if ( !functionPointer ) return false;
+					pod::Behavior::function_t& function = *functionPointer;
+
+					function = [fun]( uf::Object& s ) {
+						auto result = fun(s);
+						if ( !result.valid() ) {
+							sol::error err = result;
+							uf::iostream << err.what() << "\n";
+						}
+					};
+					return true;
+				},
+				"findByUid", []( uf::Object& self, const size_t& index )->uf::Object&{
+					auto* pointer = self.findByUid( index );
+					if ( pointer ) return pointer->as<uf::Object>();
+					static uf::Object null;
+					return null;
+				},
+				"findByName", []( uf::Object& self, const std::string& index )->uf::Object&{
+					auto* pointer = self.findByName( index );
+					if ( pointer ) return pointer->as<uf::Object>();
+					static uf::Object null;
+					return null;
+				},
+				"addChild", []( uf::Object& self, uf::Object& child )->uf::Object&{
+					self.addChild( child );
+					return self;
+				},
+				"removeChild", []( uf::Object& self, uf::Object& child )->uf::Object&{
+					self.removeChild( child );
+					return self;
+				},
+				"loadChild", []( uf::Object& self, const std::string& filename, bool init = true )->uf::Object&{
+					auto* pointer = self.loadChildPointer( filename, init );
+					if ( pointer ) return pointer->as<uf::Object>();
+					static uf::Object null;
+					return null;
+				},
+				"getChildren", []( uf::Object& self )->sol::table{
+					sol::table table = ext::lua::createTable();
+					for ( auto* child : self.getChildren() ) {
+						table.add(&child->as<uf::Object>());
+					}
+					return table;
+				},
+				"getParent", []( uf::Object& self )->uf::Object&{
+					return self.getParent().as<uf::Object>();
+				},
+				"addHook", []( uf::Object& self, const std::string& name, const sol::function& function ) {
+					self.addHook( name, [function](ext::json::Value& json){
+						std::string payload = json.dump();
+						auto decoded = ext::lua::decode( payload );
+						if ( !decoded ) return;
+						sol::table table = decoded.value();
+						auto result = function( table );
+						if ( !result.valid() ) {
+							sol::error err = result;
+							uf::iostream << err.what() << "\n";
+							return;
+						}
+					});
+				},
+				"callHook", []( uf::Object& self, const std::string& name, sol::table table = ext::lua::createTable() ) {
+					uf::Serializer payload = table;
+					self.callHook( name, (ext::json::Value&) payload );
+				},
+				"queueHook", []( uf::Object& self, const std::string& name, sol::table table, float delay = 0.0f ) {
+					uf::Serializer payload = table;
+					self.queueHook( name, (ext::json::Value&) payload, delay );
+				},
+				"__tostring", []( uf::Object& self ) {
+					return self.getName() + ": " + std::to_string( self.getUid() );
+				}
+			);
+		});
+	});
+}
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/lua/usertypes/quaternion.cpp b/engine/src/ext/lua/usertypes/quaternion.cpp
new file mode 100644
index 00000000..a29ea801
--- /dev/null
+++ b/engine/src/ext/lua/usertypes/quaternion.cpp
@@ -0,0 +1,76 @@
+#include <uf/ext/lua/lua.h>
+#if UF_USE_LUA
+#include <uf/utils/math/quaternion.h>
+
+UF_LUA_REGISTER_USERTYPE(pod::Quaternion<>,
+	sol::call_constructor, sol::initializers( 
+		[]( pod::Quaternion<>& self ) {
+			return self = {0,0,0,1};
+		},
+		[]( pod::Quaternion<>& self, const pod::Quaternion<>& copy ) {
+			return self = copy;
+		},
+		[]( pod::Quaternion<>& self, float x, float y, float z, float w ) {
+			return self = uf::vector::create(x, y, z, w);
+		}
+	),
+	UF_LUA_REGISTER_USERTYPE_MEMBER(pod::Quaternion<>::x),
+	UF_LUA_REGISTER_USERTYPE_MEMBER(pod::Quaternion<>::y),
+	UF_LUA_REGISTER_USERTYPE_MEMBER(pod::Quaternion<>::z),
+	UF_LUA_REGISTER_USERTYPE_MEMBER(pod::Quaternion<>::w),
+	UF_LUA_REGISTER_USERTYPE_DEFINE(v, []( pod::Quaternion<>& self, const size_t& index ) {
+		return self[index];
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( lookAt, []( const pod::Vector3f& source, const pod::Vector3f& destination ) {
+		return uf::quaternion::lookAt( source, destination );
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( normalize, []( const pod::Quaternion<>& self ) {
+		return uf::quaternion::normalize( self );
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( multiply, []( const pod::Quaternion<>& left, const pod::Quaternion<>& right ) {
+		return uf::quaternion::multiply( left, right );
+	}),
+	sol::meta_function::multiplication, []( const pod::Quaternion<>& left, const pod::Quaternion<>& right ) {
+		return uf::quaternion::multiply( left, right );
+	},
+	UF_LUA_REGISTER_USERTYPE_DEFINE(axisAngle, []( sol::object arg, float angle ){
+		if ( arg.is<pod::Vector3f>() ) {
+			return uf::quaternion::axisAngle( arg.as<pod::Vector3f>(), angle );
+		} else if ( arg.is<sol::table>() ) {
+			sol::table table = arg.as<sol::table>();
+			return uf::quaternion::axisAngle( pod::Vector3f{ table[0], table[1], table[2] }, angle );
+		}
+		return pod::Quaternion<>{};
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( rotate, []( const pod::Quaternion<>& left, const pod::Vector3f& right ) {
+		return uf::quaternion::rotate( left, right );
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( eulerAngles, []( const pod::Quaternion<>& quaternion ) {
+		return uf::quaternion::eulerAngles( quaternion );
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( conjugate, []( const pod::Quaternion<>& quaternion ) {
+		return uf::quaternion::conjugate( quaternion );
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( inverse, []( const pod::Quaternion<>& quaternion ) {
+		return uf::quaternion::inverse( quaternion );
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( pitch, []( const pod::Quaternion<>& quaternion ) {
+		return uf::quaternion::pitch( quaternion );
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( yaw, []( const pod::Quaternion<>& quaternion ) {
+		return uf::quaternion::yaw( quaternion );
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( roll, []( const pod::Quaternion<>& quaternion ) {
+		return uf::quaternion::roll( quaternion );
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( slerp, []( const pod::Quaternion<>& left, const pod::Quaternion<>& right, float a ) {
+		return uf::quaternion::slerp( left, right, a );
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( matrix, []( const pod::Quaternion<>& q ) {
+		return uf::quaternion::matrix( q );
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( __tostring, []( const pod::Quaternion<>& self ) {
+		return uf::string::toString( self );
+	})
+)
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/lua/usertypes/timer.cpp b/engine/src/ext/lua/usertypes/timer.cpp
new file mode 100644
index 00000000..f0fc87b2
--- /dev/null
+++ b/engine/src/ext/lua/usertypes/timer.cpp
@@ -0,0 +1,15 @@
+#include <uf/ext/lua/lua.h>
+#if UF_USE_LUA
+#include <uf/utils/math/physics.h>
+
+UF_LUA_REGISTER_USERTYPE(uf::Timer<>,
+	UF_LUA_REGISTER_USERTYPE_DEFINE( elapsed, []( uf::Timer<>& self ) {
+		return self.elapsed().asDouble();
+	}),
+	UF_LUA_REGISTER_USERTYPE_MEMBER( uf::Timer<>::start ),
+	UF_LUA_REGISTER_USERTYPE_MEMBER( uf::Timer<>::stop ),
+	UF_LUA_REGISTER_USERTYPE_MEMBER( uf::Timer<>::reset ),
+	UF_LUA_REGISTER_USERTYPE_MEMBER( uf::Timer<>::update ),
+	UF_LUA_REGISTER_USERTYPE_MEMBER( uf::Timer<>::running )
+)
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/lua/usertypes/transform.cpp b/engine/src/ext/lua/usertypes/transform.cpp
new file mode 100644
index 00000000..118d5b94
--- /dev/null
+++ b/engine/src/ext/lua/usertypes/transform.cpp
@@ -0,0 +1,52 @@
+#include <uf/ext/lua/lua.h>
+#if UF_USE_LUA
+#include <uf/utils/math/transform.h>
+
+UF_LUA_REGISTER_USERTYPE(pod::Transform<>,
+	UF_LUA_REGISTER_USERTYPE_MEMBER(pod::Transform<>::position),
+	UF_LUA_REGISTER_USERTYPE_MEMBER(pod::Transform<>::scale),
+	UF_LUA_REGISTER_USERTYPE_MEMBER(pod::Transform<>::up),
+	UF_LUA_REGISTER_USERTYPE_MEMBER(pod::Transform<>::right),
+	UF_LUA_REGISTER_USERTYPE_MEMBER(pod::Transform<>::forward),
+	UF_LUA_REGISTER_USERTYPE_MEMBER(pod::Transform<>::orientation),
+	UF_LUA_REGISTER_USERTYPE_MEMBER(pod::Transform<>::model),
+	UF_LUA_REGISTER_USERTYPE_DEFINE(move, []( pod::Transform<>& self, sol::variadic_args va ) {
+		auto it = va.begin();
+		if ( va.size() == 1 ) {
+			pod::Vector3f delta = *it++;
+			self = uf::transform::move( self, delta );
+		} else if ( va.size() == 2 ) {
+			pod::Vector3f axis = *it++;
+			double delta = *it++;
+			self = uf::transform::move( self, axis, delta );
+		}
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE(rotate, []( pod::Transform<>& self, sol::variadic_args va ) {
+		auto it = va.begin();
+		if ( va.size() == 1 ) {
+			pod::Quaternion<> delta = *it++;
+			self = uf::transform::rotate( self, delta );
+		} else if ( va.size() == 2 ) {
+			pod::Vector3f axis = *it++;
+			double delta = *it++;
+			self = uf::transform::rotate( self, axis, delta );
+		}
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE(flatten, []( const pod::Transform<>& t ) {
+		return uf::transform::flatten(t);
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE(reorient, []( const pod::Transform<>& t ) {
+		return uf::transform::reorient( t );
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE(getReference, []( pod::Transform<>& t ) {
+		return t.reference ? *t.reference : t;
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE(lookAt, []( const pod::Transform<>& t, pod::Vector3f& at ) {
+		auto transform = t;
+		return uf::transform::lookAt( transform, at );
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE(getModel, []( const pod::Transform<>& t ) {
+		return uf::transform::model( t );
+	})
+)
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/lua/usertypes/vector.cpp b/engine/src/ext/lua/usertypes/vector.cpp
new file mode 100644
index 00000000..a8eb6a6a
--- /dev/null
+++ b/engine/src/ext/lua/usertypes/vector.cpp
@@ -0,0 +1,119 @@
+#include <uf/ext/lua/lua.h>
+#if UF_USE_LUA
+#include <uf/utils/math/vector.h>
+
+UF_LUA_REGISTER_USERTYPE(pod::Vector3f,
+	sol::call_constructor, sol::initializers( 
+		[]( pod::Vector3f& self ) {
+			return self = pod::Vector3f{};
+		},
+		[]( pod::Vector3f& self, const pod::Vector3f& copy ) {
+			return self = copy;
+		},
+		[]( pod::Vector3f& self, float x, float y, float z ) {
+			return self = uf::vector::create(x, y, z);
+		}
+	),
+	UF_LUA_REGISTER_USERTYPE_MEMBER(pod::Vector3f::x),
+	UF_LUA_REGISTER_USERTYPE_MEMBER(pod::Vector3f::y),
+	UF_LUA_REGISTER_USERTYPE_MEMBER(pod::Vector3f::z),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( v, []( pod::Vector3f& self, const size_t& index ) {
+		return self[index];
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( distance, []( pod::Vector3f& self, const pod::Vector3f& other ) {
+		return uf::vector::distance( self, other );
+	}),
+	sol::meta_function::addition, []( const pod::Vector3f& left, const pod::Vector3f& right ) {
+		return uf::vector::add( left, right );
+	},
+	sol::meta_function::subtraction, []( const pod::Vector3f& left, const pod::Vector3f& right ) {
+		return uf::vector::subtract( left, right );
+	},
+	sol::meta_function::multiplication, []( const pod::Vector3f& left, const pod::Vector3f& right ) {
+		return uf::vector::multiply( left, right );
+	},
+	sol::meta_function::multiplication, []( const pod::Vector3f& left, double right ) {
+		return uf::vector::multiply( left, right );
+	},
+	sol::meta_function::division, []( const pod::Vector3f& left, const pod::Vector3f& right ) {
+		return uf::vector::divide( left, right );
+	},
+	sol::meta_function::division, []( const pod::Vector3f& left, double right ) {
+		return uf::vector::divide( left, right );
+	},
+	UF_LUA_REGISTER_USERTYPE_DEFINE( lerp, []( const pod::Vector3f& start, const pod::Vector3f& end, double delta ) {
+		return uf::vector::lerp( start, end, delta );
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( normalize, []( const pod::Vector3f& self ) {
+		return uf::vector::normalize( self );
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( magnitude, []( const pod::Vector3f& self ) {
+		return uf::vector::magnitude( self );
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( dot, []( const pod::Vector3f& left, const pod::Vector3f& right ) {
+		return uf::vector::dot( left, right );
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( __tostring, []( pod::Vector3f& self ) {
+		return uf::string::toString( self );
+	})
+)
+UF_LUA_REGISTER_USERTYPE(pod::Vector4f,
+	sol::call_constructor, sol::initializers( 
+		[]( pod::Vector4f& self ) {
+			return self = pod::Vector4f{};
+		},
+		[]( pod::Vector4f& self, const pod::Vector4f& copy ) {
+			return self = copy;
+		},
+		[]( pod::Vector4f& self, float x, float y, float z, float w ) {
+			return self = uf::vector::create(x, y, z, w);
+		}
+	),
+	UF_LUA_REGISTER_USERTYPE_MEMBER(pod::Vector4f::x),
+	UF_LUA_REGISTER_USERTYPE_MEMBER(pod::Vector4f::y),
+	UF_LUA_REGISTER_USERTYPE_MEMBER(pod::Vector4f::z),
+	UF_LUA_REGISTER_USERTYPE_MEMBER(pod::Vector4f::w),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( v, []( pod::Vector4f& self, const size_t& index ) {
+		return self[index];
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( distance, []( pod::Vector4f& self, const pod::Vector4f& other ) {
+		return uf::vector::distance( self, other );
+	}),
+	sol::meta_function::addition, []( const pod::Vector4f& left, const pod::Vector4f& right ) {
+		return uf::vector::add( left, right );
+	},
+	sol::meta_function::subtraction, []( const pod::Vector4f& left, const pod::Vector4f& right ) {
+		return uf::vector::subtract( left, right );
+	},
+	sol::meta_function::multiplication, []( const pod::Vector4f& left, const pod::Vector4f& right ) {
+		return uf::vector::multiply( left, right );
+	},
+	sol::meta_function::multiplication, []( const pod::Vector4f& left, double right ) {
+		return uf::vector::multiply( left, right );
+	},
+	sol::meta_function::division, []( const pod::Vector4f& left, const pod::Vector4f& right ) {
+		return uf::vector::divide( left, right );
+	},
+	sol::meta_function::division, []( const pod::Vector4f& left, double right ) {
+		return uf::vector::divide( left, right );
+	},
+	UF_LUA_REGISTER_USERTYPE_DEFINE( lerp, []( const pod::Vector4f& start, const pod::Vector4f& end, double delta ) {
+		return uf::vector::lerp( start, end, delta );
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( slerp, []( const pod::Vector4f& start, const pod::Vector4f& end, double delta ) {
+		return uf::vector::slerp( start, end, delta );
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( normalize, []( const pod::Vector3f& self ) {
+		return uf::vector::normalize( self );
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( magnitude, []( const pod::Vector3f& self ) {
+		return uf::vector::magnitude( self );
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( dot, []( const pod::Vector3f& left, const pod::Vector3f& right ) {
+		return uf::vector::dot( left, right );
+	}),
+	UF_LUA_REGISTER_USERTYPE_DEFINE( __tostring, []( pod::Vector4f& self ) {
+		return uf::string::toString( self );
+	})
+)
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/meshopt/meshopt.cpp b/engine/src/ext/meshopt/meshopt.cpp
new file mode 100644
index 00000000..aadcdece
--- /dev/null
+++ b/engine/src/ext/meshopt/meshopt.cpp
@@ -0,0 +1,126 @@
+#include <uf/utils/mesh/mesh.h>
+#if UF_USE_MESHOPTIMIZER
+	#include <meshoptimizer.h>
+#endif
+
+void ext::meshopt::optimize( uf::BaseGeometry& mesh, size_t o ) {
+#if 0
+	mesh.updateDescriptor();
+
+	void* vertices = NULL;
+	void* indices = NULL;
+	size_t verticesCount = mesh.attributes.vertex.length;
+	size_t indicesCount = mesh.attributes.index.length;
+
+	if ( !indicesCount ) mesh.generateIndices();
+	if ( o == 0 ) {
+		if ( !indicesCount ) {
+			mesh.resizeIndices(verticesCount);
+			switch ( mesh.attributes.index.size ) {
+				case sizeof(uint32_t):
+					for ( size_t i = 0; i < verticesCount; ++i ) ((uint32_t*) mesh.attributes.index.pointer)[i] = i;
+				break;
+				case sizeof(uint16_t):
+					for ( size_t i = 0; i < verticesCount; ++i ) ((uint16_t*) mesh.attributes.index.pointer)[i] = i;
+				break;
+				case sizeof(uint8_t):
+					for ( size_t i = 0; i < verticesCount; ++i ) ((uint8_t*) mesh.attributes.index.pointer)[i] = i;
+				break;
+			}
+		}
+		return;
+	}
+	{
+		vertices = malloc(verticesCount * mesh.attributes.vertex.size);
+		memcpy( vertices, mesh.attributes.vertex.pointer, verticesCount );
+	}
+	if ( indicesCount > 0 ) {
+		indices = malloc(indicesCount);
+		memcpy( indices, mesh.attributes.index.pointer, indicesCount );
+	}
+
+	std::vector<uint32_t> remap(verticesCount);
+	verticesCount = meshopt_generateVertexRemap(&remap[0], (uint32_t*) indices, indicesCount ? indicesCount : verticesCount, (float*) vertices, verticesCount, mesh.attributes.vertex.size);
+	
+	mesh.resizeIndices(indicesCount);
+	mesh.resizeVertices(verticesCount);
+
+	meshopt_remapIndexBuffer((uint32_t*) mesh.attributes.index.pointer, (uint32_t*) indices, indicesCount, &remap[0]);
+	meshopt_remapVertexBuffer(mesh.attributes.vertex.pointer, (float*) vertices, verticesCount, mesh.attributes.vertex.size, &remap[0]);
+
+	if ( vertices ) free(vertices);
+	if ( indices ) free(indices);
+#endif
+#if 0
+	auto vertices = std::move( this->vertices );
+	size_t valueCount = vertices.size();
+
+	std::vector<uint32_t> remap(valueCount);
+	size_t verticesCount = meshopt_generateVertexRemap(&remap[0], NULL, valueCount, &vertices[0], valueCount, sizeof(T));
+	
+	this->indices.resize(valueCount);
+	meshopt_remapIndexBuffer(&this->indices[0], NULL, valueCount, &remap[0]);
+	//meshopt_remapIndexBuffer(&this->indices[0], (const U*) NULL, indices, &remap[0]);
+	this->vertices.resize(verticesCount);
+	meshopt_remapVertexBuffer(&this->vertices[0], &vertices[0], valueCount, sizeof(T), &remap[0]);
+
+	size_t verticesCount = this->vertices.size();
+	size_t indicesCount = this->indices.size();
+	if ( indicesCount == 0 ) indicesCount = verticesCount;
+
+	auto vertices = std::move( this->vertices );
+	auto indices = std::move( this->indices );
+
+	std::vector<uint32_t> remap(indicesCount);
+	verticesCount = meshopt_generateVertexRemap(&remap[0], &indices[0], indicesCount, &vertices[0], verticesCount, sizeof(T));
+	
+	this->indices.resize(indicesCount);
+	this->vertices.resize(verticesCount);
+
+	meshopt_remapIndexBuffer(&this->indices[0], &indices[0], indicesCount, &remap[0]);
+	meshopt_remapVertexBuffer(&this->vertices[0], &vertices[0], verticesCount, sizeof(T), &remap[0]);
+#endif
+#if 0
+	// optimize for cache
+	if ( o >= 2 ) {
+		meshopt_optimizeVertexCache(mesh.attributes.index.pointer, mesh.attributes.index.pointer, mesh.attributes.index.length, mesh.attributes.vertex.length);
+	}
+	// optimize for overdraw
+	if ( o >= 3 ) {
+		const float kOverdrawThreshold = 3.f;
+		meshopt_optimizeOverdraw(mesh.attributes.index.pointer, mesh.attributes.index.pointer, mesh.attributes.index.length, (float*) mesh.attributes.vertex.pointer.position, mesh.attributes.vertex.length, sizeof(T), kOverdrawThreshold);
+	}
+	// optimize for fetch
+	if ( o >= 4 ) {
+		meshopt_optimizeVertexFetch(mesh.attributes.vertex.pointer, mesh.attributes.index.pointer, mesh.attributes.index.length, mesh.attributes.vertex.pointer, mesh.attributes.vertex.length, mesh.attributes.vertex.size);
+	}
+#endif
+}
+
+
+/*
+auto vertices = std::move( this->vertices );
+U indices = vertices.size();
+
+std::vector<uint32_t> remap(indices);
+size_t verticesCount = meshopt_generateVertexRemap(&remap[0], NULL, indices, &vertices[0], indices, sizeof(T));
+
+this->indices.resize(indices);
+//meshopt_remapIndexBuffer(&this->indices[0], NULL, indices, &remap[0]);
+meshopt_remapIndexBuffer(&this->indices[0], (const U*) NULL, indices, &remap[0]);
+this->vertices.resize(verticesCount);
+meshopt_remapVertexBuffer(&this->vertices[0], &vertices[0], indices, sizeof(T), &remap[0]);
+// optimize for cache
+if ( o >= 1 ) {
+	meshopt_optimizeVertexCache(&this->indices[0], &this->indices[0], this->indices.size(), this->vertices.size());
+}
+// optimize for overdraw
+if ( o >= 2 ) {
+	const float kOverdrawThreshold = 3.f;
+	meshopt_optimizeOverdraw(&this->indices[0], &this->indices[0], this->indices.size(), (float*) &this->vertices[0].position, this->vertices.size(), sizeof(T), kOverdrawThreshold);
+}
+// optimize for fetch
+if ( o >= 3 ) {
+	meshopt_optimizeVertexFetch(&this->vertices[0], &this->indices[0], this->indices.size(), &this->vertices[0], this->vertices.size(), sizeof(T));
+}
+*/
\ No newline at end of file
diff --git a/engine/src/ext/ncurses/ncurses.cpp b/engine/src/ext/ncurses/ncurses.cpp
new file mode 100644
index 00000000..12002eca
--- /dev/null
+++ b/engine/src/ext/ncurses/ncurses.cpp
@@ -0,0 +1,156 @@
+#include <uf/ext/ncurses/ncurses.h>
+
+ext::Ncurses ext::ncurses;
+
+#if defined(UF_USE_NCURSES)
+#include <ncursesw/ncurses.h>
+#include <uf/spec/terminal/terminal.h>
+#include <locale.h>
+
+UF_API_CALL ext::Ncurses::Ncurses() : 
+	m_initialized(false),
+	m_window(NULL),
+	m_timeout(0)
+{
+	if ( this->m_initializeOnCtor ) this->initialize();
+}
+
+ext::Ncurses::~Ncurses() {
+	this->terminate();
+}
+
+void UF_API_CALL ext::Ncurses::initialize() {
+//	setlocale(LC_ALL, "");
+	spec::terminal.setLocale();
+	
+	this->m_initialized = true;
+	this->m_window = (void*) initscr();
+
+	keypad((WINDOW*) this->m_window, true);
+	scrollok((WINDOW*) this->m_window, true);
+	mousemask(ALL_MOUSE_EVENTS, NULL);
+	mouseinterval(0);
+	timeout(this->m_timeout);
+	nonl();
+	noecho();
+	cbreak();
+}
+bool UF_API_CALL ext::Ncurses::initialized() {
+	return this->m_initialized;
+}
+
+void UF_API_CALL ext::Ncurses::terminate() {
+	if ( !this->m_initialized ) return;
+	if ( (WINDOW*) this->m_window != stdscr ) delwin((WINDOW*) this->m_window);
+	endwin();
+}
+
+void UF_API_CALL ext::Ncurses::move(int row, int column) {
+	if ( !this->m_initialized ) this->initialize();
+	wmove((WINDOW*) this->m_window, row, column);
+}
+void UF_API_CALL ext::Ncurses::move(int toRow, int toColumn, int& row, int& column) {
+	if ( !this->m_initialized ) this->initialize();
+	this->move(-1 ? row : toRow, -1 ? column : toColumn);
+	this->getYX(row, column);
+}
+void UF_API_CALL ext::Ncurses::getYX(int& row, int& column) { 
+	if ( !this->m_initialized ) this->initialize();
+	getyx((WINDOW*) this->m_window, row, column);
+}
+void UF_API_CALL ext::Ncurses::getMaxYX(int& row, int& column) {
+	if ( !this->m_initialized ) this->initialize();
+	getmaxyx((WINDOW*) this->m_window, row, column);
+}
+void UF_API_CALL ext::Ncurses::refresh() {
+	if ( !this->m_initialized ) this->initialize();
+	wrefresh((WINDOW*) this->m_window);
+}
+void UF_API_CALL ext::Ncurses::clrToEol() {
+	if ( !this->m_initialized ) this->initialize();
+//	if ( !this->m_initialized ) return;
+	wclrtoeol((WINDOW*) this->m_window);
+}
+void UF_API_CALL ext::Ncurses::clrToBot() {
+	if ( !this->m_initialized ) this->initialize();
+//	if ( !this->m_initialized ) return;
+	wclrtobot((WINDOW*) this->m_window);
+}
+ int UF_API_CALL ext::Ncurses::getCh() {
+ 	if ( !this->m_initialized ) this->initialize();
+	return wgetch((WINDOW*) this->m_window);
+}
+void UF_API_CALL ext::Ncurses::delCh() {
+	if ( !this->m_initialized ) this->initialize();
+//	if ( !this->m_initialized ) return;
+	wdelch((WINDOW*) this->m_window);
+}
+void UF_API_CALL ext::Ncurses::addCh( char c ) {
+	if ( !this->m_initialized ) this->initialize();
+//	if ( !this->m_initialized ) return;
+	waddch((WINDOW*) this->m_window, c);
+}
+void UF_API_CALL ext::Ncurses::addStr(const char* c_str) {
+	if ( !this->m_initialized ) this->initialize();
+//	if ( !this->m_initialized ) return;
+	waddstr((WINDOW*) this->m_window, c_str);
+}
+void UF_API_CALL ext::Ncurses::addStr(const std::string str) {
+	if ( !this->m_initialized ) this->initialize();
+//	if ( !this->m_initialized ) return;
+	waddstr((WINDOW*) this->m_window, str.c_str());
+}
+void UF_API_CALL ext::Ncurses::attrOn(int att) {
+	if ( !this->m_initialized ) this->initialize();
+//	if ( !this->m_initialized ) return;
+	wattron((WINDOW*) this->m_window, att);
+}
+void UF_API_CALL ext::Ncurses::attrOff(int att) {
+	if ( !this->m_initialized ) this->initialize();
+//	if ( !this->m_initialized ) return;
+	wattroff((WINDOW*) this->m_window, att);
+}
+bool UF_API_CALL ext::Ncurses::hasColors() {
+	if ( !this->m_initialized ) this->initialize();
+	return has_colors();
+}
+bool UF_API_CALL ext::Ncurses::startColor() {
+	if ( !this->m_initialized ) this->initialize();
+	return start_color();
+}
+void UF_API_CALL ext::Ncurses::initPair( short id, short fore, short back ) {
+	if ( !this->m_initialized ) this->initialize();
+	init_pair(id, fore, back);
+}
+// Define dummy implementation
+#else
+
+UF_API_CALL ext::Ncurses::Ncurses() {}
+
+ext::Ncurses::~Ncurses() {}
+
+void UF_API_CALL ext::Ncurses::initialize() {}
+bool UF_API_CALL ext::Ncurses::initialized() { return false; }
+
+void UF_API_CALL ext::Ncurses::terminate() {}
+
+void UF_API_CALL ext::Ncurses::move(int row, int column) {}
+void UF_API_CALL ext::Ncurses::move(int toRow, int toColumn, int& row, int& column) {}
+void UF_API_CALL ext::Ncurses::getYX(int& row, int& column) { 
+}
+void UF_API_CALL ext::Ncurses::getMaxYX(int& row, int& column) {}
+void UF_API_CALL ext::Ncurses::refresh() {}
+void UF_API_CALL ext::Ncurses::clrToEol() {}
+void UF_API_CALL ext::Ncurses::clrToBot() {}
+ int UF_API_CALL ext::Ncurses::getCh() { return 0; }
+void UF_API_CALL ext::Ncurses::delCh() {}
+void UF_API_CALL ext::Ncurses::addCh( char c ) {}
+void UF_API_CALL ext::Ncurses::addStr(const char* c_str) {}
+void UF_API_CALL ext::Ncurses::addStr(const std::string str) {}
+void UF_API_CALL ext::Ncurses::attrOn(int att) {}
+void UF_API_CALL ext::Ncurses::attrOff(int att) {}
+bool UF_API_CALL ext::Ncurses::hasColors() { return false; }
+bool UF_API_CALL ext::Ncurses::startColor() { return false; }
+void UF_API_CALL ext::Ncurses::initPair( short id, short fore, short back ) {}
+
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/oal/oal.cpp b/engine/src/ext/oal/oal.cpp
new file mode 100644
index 00000000..408ac029
--- /dev/null
+++ b/engine/src/ext/oal/oal.cpp
@@ -0,0 +1,196 @@
+#include <uf/config.h>
+#if defined(UF_USE_OPENAL)
+
+#include <uf/ext/oal/oal.h>
+#include <iostream>
+
+ext::AL ext::oal;
+UF_API_CALL ext::AL::AL() : m_initialized(false), m_device(NULL) {
+}
+ext::AL::~AL() {
+	this->terminate();
+}
+
+bool UF_API_CALL ext::AL::initialize() {
+/*
+	this->m_device = alcOpenDevice(NULL);
+	if ( !this->m_device ) { this->checkError(__LINE__);
+		return false;
+	}
+
+	ALboolean enumeration = alcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT");
+	if (enumeration == AL_FALSE) { this->checkError(__LINE__);
+		// do something
+		std::cout << "Device enumeration not available" << std::endl;
+	}
+
+	this->m_context = alcCreateContext(this->m_device, NULL);
+	if ( !alcMakeContextCurrent(this->m_context) ) {
+		this->checkError(__LINE__);
+		return false;
+	}
+	return this->m_initialized = true;
+*/
+	this->m_initialized = alutInit(NULL, NULL)  == AL_TRUE;
+	auto error = alutGetError();
+	std::cout << alutGetErrorString(error) << std::endl;
+	this->checkError(__FUNCTION__, __LINE__);
+	return this->m_initialized;
+}
+bool UF_API_CALL ext::AL::terminate() {
+/*
+	this->m_device = alcGetContextsDevice(this->m_context);
+	alcMakeContextCurrent(NULL);
+	alcDestroyContext(this->m_context);
+	alcCloseDevice(this->m_device);
+*/
+	return alutExit();
+}
+void UF_API_CALL ext::AL::checkError( const std::string& function, int line, const std::string& aux ) const {
+	std::string error = this->getError();
+	if ( error != "AL_NO_ERROR" ) std::cerr << "AL error @ " << function << ":" << line << ": "<<(aux!=""?"("+aux+") ":"")<< error << std::endl;
+	error = alutGetErrorString(alutGetError());
+	if ( error != "No ALUT error found" ) std::cerr << "AL error @ " << function << ":" << line << ": "<<(aux!=""?"("+aux+") ":"")<< error << std::endl;
+}
+std::string UF_API_CALL ext::AL::getError() const {
+	ALCenum error = alGetError();
+	switch (error) {
+		case AL_NO_ERROR: return "AL_NO_ERROR";
+		case AL_INVALID_NAME: return "AL_INVALID_NAME"; // a bad name (ID) was passed to an OpenAL function
+		case AL_INVALID_ENUM: return "AL_INVALID_ENUM"; // an invalid enum value was passed to an OpenAL function
+		case AL_INVALID_VALUE: return "AL_INVALID_VALUE"; // an invalid value was passed to an OpenAL function
+		case AL_INVALID_OPERATION: return "AL_INVALID_OPERATION"; // the requested operation is not valid
+		case AL_OUT_OF_MEMORY: return "AL_OUT_OF_MEMORY"; // the requested operation resulted in OpenAL running out ofmemory 
+	}
+	return "AL_UNKNOWN(" + std::to_string(error) + ")";
+}
+void UF_API_CALL ext::AL::listener( ALenum name, std::vector<ALfloat> parameters ) {
+	switch ( parameters.size() ) {
+		case 1: alListenerf( name, parameters[0] ); break;
+		case 3: alListener3f( name, parameters[0], parameters[1], parameters[2] ); break;
+		default: alListenerfv( name, &parameters[0] ); break;
+	}
+	AL_CHECK_ERROR();
+}
+void UF_API_CALL ext::AL::listener( const std::string string, std::vector<ALfloat> parameters ) {
+	if ( string == "GAIN" ) return this->listener( AL_GAIN, parameters );
+
+	if ( string == "POSITION" ) return this->listener( AL_POSITION, parameters );
+	if ( string == "VELOCITY" ) return this->listener( AL_VELOCITY, parameters );
+
+	if ( string == "ORIENTATION" ) return this->listener( AL_ORIENTATION, parameters );
+}
+
+////////
+UF_API_CALL ext::al::Source::Source() : m_index(0) {
+}
+ext::al::Source::~Source() {
+	this->destroy();
+}
+
+void UF_API_CALL ext::al::Source::generate() {
+	if ( this->m_index ) this->destroy();
+	AL_CHECK_ERROR(alGenSources(1, &this->m_index));
+}
+void UF_API_CALL ext::al::Source::destroy() {
+	if ( this->m_index && alIsSource(this->m_index) ) {
+		if ( this->playing() ) this->stop();
+		AL_CHECK_ERROR(alSourcei(this->m_index, AL_BUFFER, 0));
+		AL_CHECK_ERROR(alDeleteSources(1, &this->m_index));
+	}
+	this->m_index = 0;
+}
+ALuint& UF_API_CALL ext::al::Source::getIndex() { return this->m_index; }
+ALuint UF_API_CALL ext::al::Source::getIndex() const { return this->m_index; }
+
+void UF_API_CALL ext::al::Source::source( ALenum name, std::vector<ALfloat> parameters ) {
+	if ( !this->m_index ) this->generate();
+	switch ( parameters.size() ) {
+		case 1: alSourcef( this->m_index, name, parameters[0] ); break;
+		case 3: alSource3f( this->m_index, name, parameters[0], parameters[1], parameters[2] ); break;
+		default: alSourcefv( this->m_index, name, &parameters[0] ); break;
+	}
+	AL_CHECK_ERROR();
+	//ext::oal.checkError(__FUNCTION__, __LINE__, std::to_string(name));
+}
+void UF_API_CALL ext::al::Source::source( const std::string string, std::vector<ALfloat> parameters ) {
+	// alSourcef
+	if ( string == "PITCH" ) return this->source( AL_PITCH, parameters );
+	if ( string == "GAIN" ) return this->source( AL_GAIN, parameters );
+	if ( string == "MIN_GAIN" ) return this->source( AL_MIN_GAIN, parameters );
+	if ( string == "MAX_GAIN" ) return this->source( AL_MAX_GAIN, parameters );
+	if ( string == "MAX_DISTANCE" ) return this->source( AL_MAX_DISTANCE, parameters );
+	if ( string == "ROLLOFF_FACTOR" ) return this->source( AL_ROLLOFF_FACTOR, parameters );
+	if ( string == "CONE_OUTER_GAIN" ) return this->source( AL_CONE_OUTER_GAIN, parameters );
+	if ( string == "CONE_INNER_ANGLE" ) return this->source( AL_CONE_INNER_ANGLE, parameters );
+	if ( string == "CONE_OUTER_ANGLE" ) return this->source( AL_CONE_OUTER_ANGLE, parameters );
+	if ( string == "REFERENCE_DISTANCE" ) return this->source( AL_REFERENCE_DISTANCE, parameters );
+	if ( string == "SEC_OFFSET" ) return this->source( AL_SEC_OFFSET, parameters );
+	// alSource3f
+	// alSourcefv
+	if ( string == "POSITION" ) return this->source( AL_POSITION, parameters );
+	if ( string == "VELOCITY" ) return this->source( AL_VELOCITY, parameters );
+	if ( string == "DIRECTION" ) return this->source( AL_DIRECTION, parameters );
+}
+void UF_API_CALL ext::al::Source::source( ALenum name, std::vector<ALint> parameters ) {
+	if ( !this->m_index ) this->generate();
+	switch ( parameters.size() ) {
+		case 1: alSourcei( this->m_index, name, parameters[0] ); break;
+		case 3: alSource3i( this->m_index, name, parameters[0], parameters[1], parameters[2] ); break;
+		default: alSourceiv( this->m_index, name, &parameters[0] ); break;
+	}
+	AL_CHECK_ERROR();
+}
+void UF_API_CALL ext::al::Source::source( const std::string string, std::vector<ALint> parameters ) {
+	// alSourcei
+	if ( string == "SOURCE_RELATIVE" ) return this->source( AL_SOURCE_RELATIVE, parameters );
+	if ( string == "CONE_INNER_ANGLE" ) return this->source( AL_CONE_INNER_ANGLE, parameters );
+	if ( string == "CONE_OUTER_ANGLE" ) return this->source( AL_CONE_OUTER_ANGLE, parameters );
+	if ( string == "LOOPING" ) return this->source( AL_LOOPING, parameters );
+	if ( string == "BUFFER" ) return this->source( AL_BUFFER, parameters );
+	if ( string == "SOURCE_STATE" ) return this->source( AL_SOURCE_STATE, parameters );	
+	// alSource3i
+	// alSourceiv
+	if ( string == "POSITION" ) return this->source( AL_POSITION, parameters );
+	if ( string == "VELOCITY" ) return this->source( AL_VELOCITY, parameters );
+	if ( string == "DIRECTION" ) return this->source( AL_DIRECTION, parameters );
+}
+void UF_API_CALL ext::al::Source::play() {
+	AL_CHECK_ERROR(alSourcePlay(this->m_index));
+}
+void UF_API_CALL ext::al::Source::stop() {
+	AL_CHECK_ERROR(alSourceStop(this->m_index));
+}
+bool UF_API_CALL ext::al::Source::playing() {
+	ALCenum state;
+	AL_CHECK_ERROR(alGetSourcei(this->m_index, AL_SOURCE_STATE, &state));
+	return state == AL_PLAYING;
+}
+
+////////
+UF_API_CALL ext::al::Buffer::Buffer() : m_index(0) {
+}
+ext::al::Buffer::~Buffer() {
+	this->destroy();
+}
+
+void UF_API_CALL ext::al::Buffer::generate() {
+	if ( this->m_index ) this->destroy();
+	AL_CHECK_ERROR(alGenBuffers(1, &this->m_index));
+}
+void UF_API_CALL ext::al::Buffer::destroy() {
+	if ( this->m_index && alIsBuffer(this->m_index) ) {
+		AL_CHECK_ERROR(alDeleteBuffers(1, &this->m_index));
+	}
+	this->m_index = 0;
+}
+ALuint& UF_API_CALL ext::al::Buffer::getIndex() { return this->m_index; }
+ALuint UF_API_CALL ext::al::Buffer::getIndex() const { return this->m_index; }
+
+void UF_API_CALL ext::al::Buffer::buffer(ALenum format, const ALvoid* data, ALsizei size, ALsizei frequency) {
+	if ( !this->m_index ) this->generate();
+	AL_CHECK_ERROR(alBufferData(this->m_index, format, data, size, frequency));
+}
+
+
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/opengl/buffer.cpp b/engine/src/ext/opengl/buffer.cpp
new file mode 100644
index 00000000..7ef9667e
--- /dev/null
+++ b/engine/src/ext/opengl/buffer.cpp
@@ -0,0 +1,123 @@
+#if UF_USE_OPENGL
+
+#define VMA_IMPLEMENTATION
+
+#include <uf/ext/opengl/buffer.h>
+#include <uf/ext/opengl/opengl.h>
+#include <uf/ext/opengl/device.h>
+
+bool ext::opengl::Buffer::map( GLsizeiptr size, GLsizeiptr offset ) {
+	return false;
+}
+void ext::opengl::Buffer::unmap() {
+}
+
+bool ext::opengl::Buffer::bind( GLsizeiptr offset ) {
+	return false;
+}
+
+void ext::opengl::Buffer::setupDescriptor( GLsizeiptr size, GLsizeiptr offset ) {
+	descriptor.buffer = buffer;
+	descriptor.offset = offset;
+	descriptor.range = size;
+}
+
+void ext::opengl::Buffer::copyTo( void* data, GLsizeiptr len ) {
+	if ( !buffer || !data ) return;
+	if ( len >= size ) len = size;
+#if !UF_USE_OPENGL_FIXED_FUNCTION
+// GPU-bound buffer
+	GLenum usage;
+	if ( usage & enums::Buffer::STREAM ) {
+		if ( usage & enums::Buffer::DRAW ) usage = GL_STREAM_DRAW;
+		if ( usage & enums::Buffer::READ ) usage = GL_STREAM_READ;
+		if ( usage & enums::Buffer::COPY ) usage = GL_STREAM_COPY;
+	}
+	if ( usage & enums::Buffer::STATIC ) {
+		if ( usage & enums::Buffer::DRAW ) usage = GL_STATIC_DRAW;
+		if ( usage & enums::Buffer::READ ) usage = GL_STATIC_READ;
+		if ( usage & enums::Buffer::COPY ) usage = GL_STATIC_COPY;
+	}
+	if ( usage & enums::Buffer::DYNAMIC ) {
+		if ( usage & enums::Buffer::DRAW ) usage = GL_DYNAMIC_DRAW;
+		if ( usage & enums::Buffer::READ ) usage = GL_DYNAMIC_READ;
+		if ( usage & enums::Buffer::COPY ) usage = GL_DYNAMIC_COPY;
+	}
+	GL_ERROR_CHECK(glBindBuffer(GL_COPY_WRITE_BUFFER, buffer));
+	GL_ERROR_CHECK(glBufferData(GL_COPY_WRITE_BUFFER, len, data, usage));
+	GL_ERROR_CHECK(glBindBuffer(GL_COPY_WRITE_BUFFER, 0));
+#else
+// CPU-bound buffer
+	void* pointer = device->getBuffer( buffer );
+	if ( pointer ) memcpy( pointer, data, len );
+#endif
+}
+
+bool ext::opengl::Buffer::flush( GLsizeiptr size, GLsizeiptr offset ) {
+	return 0;
+}
+bool ext::opengl::Buffer::invalidate( GLsizeiptr size, GLsizeiptr offset ) {
+	return 0;
+}
+
+void ext::opengl::Buffer::allocate( const CreateInfo& bufferCreateInfo ) {
+	this->destroy();
+	if ( !device ) device = &ext::opengl::device;
+
+	this->buffer = device->createBuffer( bufferCreateInfo.usage, bufferCreateInfo.size );
+	this->usage = bufferCreateInfo.usage;
+
+	this->size = bufferCreateInfo.size;
+	this->allocationInfo.size = bufferCreateInfo.size;
+	this->allocationInfo.offset = 0;
+
+	setupDescriptor( bufferCreateInfo.size, 0 );
+}
+
+// RAII
+ext::opengl::Buffer::~Buffer() {
+//	this->destroy();
+}
+void ext::opengl::Buffer::initialize( Device& device ) {
+	this->device = &device;
+}
+void ext::opengl::Buffer::destroy() {
+	if ( device && buffer ) device->destroyBuffer( buffer );
+	device = NULL;
+	buffer = NULL;
+}
+
+//
+// Buffers
+void ext::opengl::Buffers::initialize( Device& device ) {
+	this->device = &device;
+}
+
+void ext::opengl::Buffers::destroy() {
+	for ( auto& buffer : buffers ) buffer.destroy();
+	buffers.clear();
+}
+
+size_t ext::opengl::Buffers::initializeBuffer( void* data, GLsizeiptr length, GLenum usage, bool stage ) {
+	size_t index = buffers.size();
+	auto& buffer = buffers.emplace_back();
+	
+	buffer.initialize( *device );
+	buffer.allocate( Buffer::CreateInfo{ 
+		.flags = 0,
+		.size = length,
+		.usage = usage,
+	} );
+	buffer.copyTo( data, length );
+
+	return index;
+}
+void ext::opengl::Buffers::updateBuffer( void* data, GLsizeiptr length, size_t index, bool stage ) {
+	Buffer& buffer = buffers.at(index);
+	return updateBuffer( data, length, buffer, stage );
+}
+void ext::opengl::Buffers::updateBuffer( void* data, GLsizeiptr length, Buffer& buffer, bool stage ) {
+	buffer.copyTo( data, length );
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/opengl/commands.cpp b/engine/src/ext/opengl/commands.cpp
new file mode 100644
index 00000000..649c8a8e
--- /dev/null
+++ b/engine/src/ext/opengl/commands.cpp
@@ -0,0 +1,748 @@
+#if UF_USE_OPENGL
+
+#include <uf/ext/opengl/opengl.h>
+#include <uf/ext/opengl/commands.h>
+#include <uf/ext/opengl/graphic.h>
+
+#include <vector>
+#include <bitset>
+
+#include <uf/utils/graphic/mesh.h>
+#include <uf/ext/gltf/mesh.h>
+
+#define VERBOSE false
+#define VERBOSE_SUBMIT false
+
+#define GL_DRAW_ARRAYS( vertexPointer, vertices )\
+	GL_ERROR_CHECK(glBegin(GL_TRIANGLES)); {\
+		for ( size_t i = 0; i < vertices; i++ ) {\
+			uint8_t* vertex = vertexPointer + (i * vertexStride);\
+			if ( vertexAttributeNormal.name != "" ) {\
+				float* normal = (float*) (vertex + vertexAttributeNormal.offset);\
+				GL_ERROR_CHECK(glNormal3f(normal[0], normal[1], normal[2]));\
+			}\
+			if ( vertexAttributeColor.name != "" ) {\
+				float* color = (float*) (vertex + vertexAttributeColor.offset);\
+				GL_ERROR_CHECK(glColor3f(color[0], color[1], color[2]));\
+			}\
+			if ( vertexAttributeUv.name != "" ) {\
+				float* uv = (float*) (vertex + vertexAttributeUv.offset);\
+				GL_ERROR_CHECK(glTexCoord2f(uv[0], uv[1]));\
+			}\
+			{\
+				float* position = (float*) (vertex + vertexAttributePosition.offset);\
+				GL_ERROR_CHECK(glVertex3f(position[0], position[1], position[2]));\
+			}\
+		}\
+	} GL_ERROR_CHECK(glEnd());
+
+#define GL_DRAW_ELEMENTS( indicesPointer, indices )\
+	GL_ERROR_CHECK(glBegin(GL_TRIANGLES)); {\
+		for ( size_t i = 0; i < indices; ++i ) {\
+			size_t index = indicesPointer[i];\
+			void* vertex = vertexPointer + (index * vertexStride);\
+			if ( vertexAttributeNormal.name != "" ) {\
+				float* normal = (float*) (vertex + vertexAttributeNormal.offset);\
+				GL_ERROR_CHECK(glNormal3f(normal[0], normal[1], normal[2]));\
+			}\
+			if ( vertexAttributeColor.name != "" ) {\
+				float* color = (float*) (vertex + vertexAttributeColor.offset);\
+				GL_ERROR_CHECK(glColor3f(color[0], color[1], color[2]));\
+			}\
+			if ( vertexAttributeUv.name != "" ) {\
+				float* uv = (float*) (vertex + vertexAttributeUv.offset);\
+				GL_ERROR_CHECK(glTexCoord2f(uv[0], uv[1]));\
+			}\
+			{\
+				float* position = (float*) (vertex + vertexAttributePosition.offset);\
+				GL_ERROR_CHECK(glVertex3f(position[0], position[1], position[2]));\
+			}\
+		}\
+	} GL_ERROR_CHECK(glEnd());
+
+#define GL_BIND_POINTERS()\
+	if ( vertexAttributeNormal.name != "" ) GL_ERROR_CHECK(glNormalPointer(GL_FLOAT, vertexStride, vertexPointer + vertexAttributeNormal.offset));\
+	if ( vertexAttributeColor.name != "" ) GL_ERROR_CHECK(glColorPointer(3, GL_FLOAT, vertexStride, vertexPointer + vertexAttributeColor.offset));\
+	if ( vertexAttributeUv.name != "" ) GL_ERROR_CHECK(glTexCoordPointer(2, GL_FLOAT, vertexStride, vertexPointer + vertexAttributeUv.offset));\
+	GL_ERROR_CHECK(glVertexPointer(3, GL_FLOAT, vertexStride, vertexPointer + vertexAttributePosition.offset));
+
+size_t ext::opengl::CommandBuffer::preallocate = 8;
+
+void ext::opengl::CommandBuffer::initialize( Device& device ) {
+	this->device = &device;
+	if ( !this->mutex ) this->mutex = new std::mutex;
+	infos.reserve(CommandBuffer::preallocate);
+}
+void ext::opengl::CommandBuffer::destroy() {
+	this->flush();
+	
+	if ( this->mutex ) delete this->mutex;
+	this->mutex = NULL;
+}
+void ext::opengl::CommandBuffer::start() {
+	if ( state == 1 ) {
+		std::cout << "ERROR: COMMAND BUFFER " << this << " NOT READY FOR RECORDING" << std::endl;
+		return;
+	}
+	flush();
+	state = 1;
+//	if ( VERBOSE ) std::cout << "==== ["<<this<<"] COMMAND BUFFER RECORDING START ====\n";
+	mutex->lock();
+}
+void ext::opengl::CommandBuffer::end() {
+	if ( state != 1 ) {
+		std::cout << "ERROR: COMMAND BUFFER " << this << " WAS NOT RECORDING" << std::endl;
+		return;
+	}
+	if ( !infos.empty() ) {
+		if ( VERBOSE ) std::cout << "==== ["<<this<<"] COMMAND BUFFER RECORDING END ==== " << std::endl;
+	}
+	state = 2;
+	mutex->unlock();
+
+	// traverse list chain
+/*
+	Info* currentInfo = (Info*) (void*) startInfo;
+	while ( currentInfo ) {
+		std::cout << "COMMAND: " << currentInfo << "[" << currentInfo->type << "]";
+		currentInfo = currentInfo->next;
+		if ( currentInfo ) std::cout << " -> ";
+	}
+	std::cout << std::endl;
+*/
+}
+void ext::opengl::CommandBuffer::record( const CommandBuffer::Info& header ) {
+	if ( state != 1 ) {
+		std::cout << "ERROR: COMMAND BUFFER " << this << " NOT READY FOR RECORDING" << std::endl;
+		return;
+	}
+
+	if ( infos.empty() ) {
+		if ( VERBOSE ) std::cout << "==== ["<<this<<"] COMMAND BUFFER RECORDING START ==== " << std::endl;
+	}
+
+	switch ( header.type ) {
+		case ext::opengl::enums::Command::CLEAR: {
+			InfoClear* info = (InfoClear*) &header;
+			info->next = NULL;
+			auto& userdata = infos.emplace_back();
+			userdata.autoDestruct = false;
+			userdata.create<InfoClear>( *info );
+			info = &userdata.get<InfoClear>();
+			info->type = enums::Command::CLEAR;
+			if ( VERBOSE ) std::cout << "[" << infos.size() << "] ["<<info<<"] COMMAND BUFFER " << this << " | CLEAR: " << uf::vector::toString(info->color) << " | " << info->depth << "\n";
+		} break;
+		case ext::opengl::enums::Command::VIEWPORT: {
+			InfoViewport* info = (InfoViewport*) &header;
+			info->next = NULL;
+			if ( info->size.x == 0 ) info->size.x = ext::opengl::settings::width;
+			if ( info->size.y == 0 ) info->size.y = ext::opengl::settings::height;
+			auto& userdata = infos.emplace_back();
+			userdata.autoDestruct = false;
+			userdata.create<InfoViewport>( *info );
+			info = &userdata.get<InfoViewport>();
+			info->type = enums::Command::VIEWPORT;
+			if ( VERBOSE ) std::cout << "[" << infos.size() << "] ["<<info<<"] COMMAND BUFFER " << this << " | VIEWPORT: " << uf::vector::toString(info->corner) << " | " << uf::vector::toString(info->size) << "\n";
+		} break;
+		case ext::opengl::enums::Command::VARIANT: {
+			InfoVariant* info = (InfoVariant*) &header;
+			info->next = NULL;
+			auto& userdata = infos.emplace_back();
+			userdata.autoDestruct = false;
+			userdata.create<InfoVariant>( *info );
+			info = &userdata.get<InfoVariant>();
+			info->type = enums::Command::VARIANT;
+			if ( VERBOSE ) std::cout << "[" << infos.size() << "] ["<<info<<"] COMMAND BUFFER " << this << " | VARIANT: " << "\n";
+		} break;
+		case ext::opengl::enums::Command::BIND_BUFFER: {
+			InfoBuffer* info = (InfoBuffer*) &header;
+			info->next = NULL;
+			auto& userdata = infos.emplace_back();
+			userdata.autoDestruct = false;
+			userdata.create<InfoBuffer>( *info );
+			info = &userdata.get<InfoBuffer>();
+			info->type = enums::Command::BIND_BUFFER;
+			if ( VERBOSE ) std::cout << "[" << infos.size() << "] ["<<info<<"] COMMAND BUFFER " << this << " | BIND_BUFFER: " << info->descriptor.buffer << "\n";
+		} break;
+		case ext::opengl::enums::Command::BIND_GRAPHIC_BUFFER: {
+			InfoGraphicBuffer* info = (InfoGraphicBuffer*) &header;
+			info->next = NULL;
+			auto& userdata = infos.emplace_back();
+			userdata.autoDestruct = false;
+			userdata.create<InfoGraphicBuffer>( *info );
+			info = &userdata.get<InfoGraphicBuffer>();
+			info->type = enums::Command::BIND_GRAPHIC_BUFFER;
+			if ( VERBOSE ) std::cout << "[" << infos.size() << "] ["<<info<<"] COMMAND BUFFER " << this << " | BIND_GRAPHIC_BUFFER: " << info->graphic << "[" << info->bufferIndex << "] = " << info->graphic->buffers[info->bufferIndex].descriptor.buffer << "\n";
+		} break;
+		case ext::opengl::enums::Command::BIND_TEXTURE: {
+			InfoTexture* info = (InfoTexture*) &header;
+			info->next = NULL;
+			auto& userdata = infos.emplace_back();
+			userdata.autoDestruct = false;
+			userdata.create<InfoTexture>( *info );
+			info = &userdata.get<InfoTexture>();
+			info->type = enums::Command::BIND_TEXTURE;
+			if ( VERBOSE ) std::cout << "[" << infos.size() << "] ["<<info<<"] COMMAND BUFFER " << this << " | BIND_TEXTURE: " << info->descriptor.image << "\n";
+		} break;
+		case ext::opengl::enums::Command::BIND_PIPELINE: {
+			InfoPipeline* info = (InfoPipeline*) &header;
+			info->next = NULL;
+			auto& userdata = infos.emplace_back();
+			userdata.autoDestruct = false;
+			userdata.create<InfoPipeline>( *info );
+			info = &userdata.get<InfoPipeline>();
+			info->type = enums::Command::BIND_PIPELINE;
+			if ( VERBOSE ) std::cout << "[" << infos.size() << "] ["<<info<<"] COMMAND BUFFER " << this << " | BIND PIPELINE: " << info->descriptor.pipeline << " | " << info->descriptor.vertexArray << "\n";
+		} break;
+		case ext::opengl::enums::Command::DRAW: {
+			InfoDraw* info = (InfoDraw*) &header;
+			info->next = NULL;
+			auto& userdata = infos.emplace_back();
+			userdata.autoDestruct = false;
+			userdata.create<InfoDraw>( *info );
+			info = &userdata.get<InfoDraw>();
+			info->type = enums::Command::DRAW;
+			if ( VERBOSE ) std::cout << "[" << infos.size() << "] ["<<info<<"] COMMAND BUFFER " << this << " | COUNT: " << info->length << "\n";
+		} break;
+		case ext::opengl::enums::Command::GENERATE_TEXTURE: {
+			InfoGenerateTexture* info = (InfoGenerateTexture*) &header;
+			auto& userdata = infos.emplace_back();
+			userdata.autoDestruct = false;
+			userdata.create( *info );
+			info = &userdata.get<InfoGenerateTexture>();
+			info->type = enums::Command::GENERATE_TEXTURE;
+			if ( VERBOSE ) std::cout << "[" << infos.size() << "] ["<<info<<"] COMMAND BUFFER " << this << " | GENERATE_TEXTURE: " << info->descriptor.image << " | " << info->data << "[" << info->size << "]" << "\n";
+		} break;
+		default: {
+			if ( VERBOSE ) std::cout << "UNKNOWN COMMAND TYPE: " << header.type << std::endl;
+		} break;
+	}
+}
+void ext::opengl::CommandBuffer::record( const InfoVariant::function_t& lambda ) {
+	InfoVariant lambdaCommandInfo = {};
+	lambdaCommandInfo.type = ext::opengl::enums::Command::VARIANT;
+	lambdaCommandInfo.lambda = lambda;
+	record(lambdaCommandInfo);
+}
+void ext::opengl::CommandBuffer::record( const CommandBuffer& commandBuffer ) {
+	infos.insert( infos.end(), commandBuffer.infos.begin(), commandBuffer.infos.end() );
+}
+void ext::opengl::CommandBuffer::submit() {
+	if ( infos.empty() ) return;
+
+	mutex->lock();
+#if UF_ENV_DREAMCAST
+	static GLint maxTextures = 80;
+#else
+	static GLint maxTextures = 0;
+	if ( maxTextures <= 0 ) {
+		glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &maxTextures);
+		std::cout << "MAX COMBINED TEXTURE UNITS: " << maxTextures << std::endl;
+	}
+#endif
+	CommandBuffer::Info* vertexBufferInfo = GL_NULL_HANDLE;
+	CommandBuffer::Info* indexBufferInfo = GL_NULL_HANDLE;
+	std::vector<CommandBuffer::InfoTexture*> textureInfos;
+
+	if ( state == 2 && VERBOSE_SUBMIT ) std::cout << "==== ["<<this<<"] COMMAND BUFFER SUBMIT START ====\n";
+	for ( auto& info : infos ) {
+		CommandBuffer::Info* header = (CommandBuffer::Info*) (void*) info;
+		switch ( header->type ) {
+			case ext::opengl::enums::Command::CLEAR: {
+				InfoClear* info = (InfoClear*) header;
+				if ( state == 2 && VERBOSE_SUBMIT ) std::cout << "["<<info<<"] CLEARING SCREEN TO " << uf::vector::toString( info->color ) << " | DEPTH: " << info->depth << " | BITS: " << std::bitset<32>(info->bits) << "\n";
+				GL_ERROR_CHECK(glClearColor(info->color[0], info->color[1], info->color[2], info->color[3]));
+				GL_ERROR_CHECK(glClearDepth(info->depth));
+				GL_ERROR_CHECK(glClear(info->bits));
+			} break;
+			case ext::opengl::enums::Command::VIEWPORT: {
+				InfoViewport* info = (InfoViewport*) header;
+				if ( state == 2 && VERBOSE_SUBMIT ) std::cout << "["<<info<<"] SETTING VIEWPORT TO " << uf::vector::toString(info->corner) << " | " << uf::vector::toString(info->size) << "\n";
+				GL_ERROR_CHECK(glViewport(info->corner[0], info->corner[1], info->size[0], info->size[1]));
+			} break;
+			case ext::opengl::enums::Command::VARIANT: {
+				InfoVariant* info = (InfoVariant*) header;
+				if ( state == 2 && VERBOSE_SUBMIT ) std::cout << "["<<info<<"] CALLING LAMBDA\n";
+				if ( info->lambda ) info->lambda();
+			} break;
+			case ext::opengl::enums::Command::BIND_BUFFER: {
+				InfoBuffer* info = (InfoBuffer*) header;
+				if ( state == 2 && VERBOSE_SUBMIT ) std::cout << "["<<info<<"] BINDING BUFFER: " << info->descriptor.buffer << " | FLAGS: " << /*std::bitset<16>*/(info->usage) << "\n";
+				if ( info->usage & enums::Buffer::UNIFORM ) bindUniform( info->descriptor );
+				if ( info->usage & enums::Buffer::VERTEX ) vertexBufferInfo = header;
+				if ( info->usage & enums::Buffer::INDEX ) indexBufferInfo = header;
+			} break;
+			case ext::opengl::enums::Command::BIND_GRAPHIC_BUFFER: {
+				InfoGraphicBuffer* info = (InfoGraphicBuffer*) header;
+				if ( state == 2 && VERBOSE_SUBMIT ) std::cout << "["<<info<<"] BINDING BUFFER: ";
+				auto& buffer = info->graphic->buffers[info->bufferIndex];
+				if ( state == 2 && VERBOSE_SUBMIT ) std::cout << buffer.descriptor.buffer << " | FLAGS: " << /*std::bitset<16>*/(buffer.usage) << "\n";
+				if ( buffer.usage & enums::Buffer::UNIFORM ) bindUniform( buffer.descriptor );
+				if ( buffer.usage & enums::Buffer::VERTEX ) vertexBufferInfo = header;
+				if ( buffer.usage & enums::Buffer::INDEX ) indexBufferInfo = header;
+			} break;
+			case ext::opengl::enums::Command::BIND_TEXTURE: {
+				InfoTexture* info = (InfoTexture*) header;
+				if ( state == 2 && VERBOSE_SUBMIT ) std::cout << "["<<info<<"] BINDING TEXTURE: " << info->descriptor.image << " | " << info->descriptor.viewType << "\n";
+			/*
+				if ( textureInfos.size() < maxTextures ) {
+				#if !UF_ENV_DREAMCAST
+					GL_ERROR_CHECK(glActiveTexture(GL_TEXTURE0 + textureInfos.size()));
+				#endif
+					GL_ERROR_CHECK(glEnable(info->descriptor.viewType));
+					GL_ERROR_CHECK(glBindTexture(info->descriptor.viewType, info->descriptor.image));
+					textureInfos.emplace_back(info);
+				}
+			*/
+				textureInfos.emplace_back(info);
+			} break;
+			case ext::opengl::enums::Command::BIND_PIPELINE: {
+				InfoPipeline* info = (InfoPipeline*) header;
+				if ( state == 2 && VERBOSE_SUBMIT ) std::cout << "["<<info<<"] BINDING PIPELINE: " << info->descriptor.pipeline << " | " << info->descriptor.vertexArray << "\n";
+			#if !UF_USE_OPENGL_FIXED_FUNCTION
+				GL_ERROR_CHECK(glUseProgram(info->descriptor.pipeline));
+			#endif
+			} break;
+			case ext::opengl::enums::Command::DRAW: {
+				InfoDraw* info = (InfoDraw*) header;
+				if ( state == 2 && VERBOSE_SUBMIT ) std::cout << "["<<info<<"] DRAW CALL | COUNT: " << info->length << " | VERTEX INFO: " << vertexBufferInfo << " | INDEX INFO: " << indexBufferInfo << "\n";
+				if ( vertexBufferInfo ) {
+			/*
+				#if !UF_ENV_DREAMCAST
+					GL_ERROR_CHECK(glActiveTexture(GL_TEXTURE0));
+				#endif
+			*/
+					if ( indexBufferInfo ) drawIndexed( *info, *vertexBufferInfo, *indexBufferInfo, textureInfos );
+					else draw( *info, *vertexBufferInfo, textureInfos );
+				}
+			/*
+				while ( !textureInfos.empty() ) {
+					auto& info = textureInfos.back();
+				#if !UF_ENV_DREAMCAST
+					GL_ERROR_CHECK(glActiveTexture(GL_TEXTURE0 + textureInfos.size() - 1));
+				#endif
+					GL_ERROR_CHECK(glDisable(info->descriptor.viewType));
+					GL_ERROR_CHECK(glBindTexture(info->descriptor.viewType, 0));
+					textureInfos.pop_back();
+				}
+			*/
+				textureInfos.clear();
+				vertexBufferInfo = NULL;
+				indexBufferInfo = NULL;
+			} break;
+			case ext::opengl::enums::Command::GENERATE_TEXTURE: {
+				InfoGenerateTexture* info = (InfoGenerateTexture*) header;
+				if ( state == 2 && VERBOSE_SUBMIT ) std::cout << "["<<info<<"] GENERATING TEXTURE | " << info->descriptor.image << " | " << info->data << "\n";
+
+				GLenum format = GL_RGBA;
+				GLenum type = GL_UNSIGNED_BYTE;
+				switch ( info->descriptor.format ) {
+				#if !UF_ENV_DREAMCAST
+					case enums::Format::R8_UNORM: format = GL_RED; break;
+					case enums::Format::R8G8_UNORM: format = GL_RG; break;
+				#endif
+					case enums::Format::R8G8B8_UNORM: format = GL_RGB; break;
+					case enums::Format::R8G8B8A8_UNORM: format = GL_RGBA; break;
+				}
+				GL_ERROR_CHECK(glBindTexture(info->descriptor.viewType, info->descriptor.image));
+				switch ( info->descriptor.viewType ) {
+					case enums::Image::VIEW_TYPE_2D: GL_ERROR_CHECK(glTexImage2D(info->descriptor.viewType, 0, format, info->descriptor.width, info->descriptor.height, 0, format, type, info->data)); break;
+				#if !UF_ENV_DREAMCAST
+					case enums::Image::VIEW_TYPE_3D: GL_ERROR_CHECK(glTexImage3D(info->descriptor.viewType, 0, format, info->descriptor.width, info->descriptor.height, info->descriptor.depth, 0, format, type, info->data)); break;
+				#endif
+				}
+				GL_ERROR_CHECK(glBindTexture(info->descriptor.viewType, 0));
+			} break;
+			default: {
+				if ( state == 2 && VERBOSE_SUBMIT ) {
+					std::cout << "["<<header<<"] UNKNOWN COMMAND TYPE: " << header->type << ": " << info.data().len << std::endl;;
+				/*
+					// dump contents
+					std::cout << "["<<header<<"] UNKNOWN COMMAND TYPE: " << header->type << ": " << std::hex;
+					uint8_t* start = (uint8_t*) header;
+					for ( size_t i = 0; i < info.data().len; ++i ) {
+						std::cout << (int) start[i] << " ";
+					}
+					std::cout << std::dec << std::endl;
+				*/
+				}
+			} break;
+		}
+	}
+	if ( state == 2 && VERBOSE_SUBMIT ) std::cout << "==== ["<<this<<"] COMMAND BUFFER SUBMIT END ==== " << std::endl;
+	state = 3;
+	mutex->unlock();
+}
+void ext::opengl::CommandBuffer::flush() {
+	mutex->lock();
+	for ( auto& userdata : infos ) userdata.destroy();
+	infos.clear();
+	state = 0;
+/*
+	startInfo = NULL;
+	endInfo = NULL;
+*/
+	mutex->unlock();
+}
+size_t ext::opengl::CommandBuffer::size() const {
+	return infos.size();
+}
+
+void ext::opengl::CommandBuffer::bindUniform( const ext::opengl::Buffer::Descriptor& descriptor ) {
+#if UF_USE_OPENGL_FIXED_FUNCTION
+	pod::Uniform* uniform = (pod::Uniform*) (device->getBuffer( descriptor.buffer ) + descriptor.offset);
+
+	GL_ERROR_CHECK(glMatrixMode(GL_PROJECTION));
+	GL_ERROR_CHECK(glLoadMatrixf( &uniform->projection[0] ));
+
+	GL_ERROR_CHECK(glMatrixMode(GL_MODELVIEW));
+	GL_ERROR_CHECK(glLoadMatrixf( &uniform->modelView[0] ));
+#endif
+}
+void ext::opengl::CommandBuffer::draw( const ext::opengl::CommandBuffer::InfoDraw& drawInfo, const ext::opengl::CommandBuffer::Info& vertexBufferInfo, const std::vector<InfoTexture*>& textureInfos ) {
+	ext::opengl::Buffer::Descriptor vertexBuffer = {};
+
+	switch ( vertexBufferInfo.type ) {
+		case ext::opengl::enums::Command::BIND_BUFFER: {
+			ext::opengl::CommandBuffer::InfoBuffer* info = (ext::opengl::CommandBuffer::InfoBuffer*) &vertexBufferInfo;
+			vertexBuffer = info->descriptor;
+		} break;
+		case ext::opengl::enums::Command::BIND_GRAPHIC_BUFFER: {
+			ext::opengl::CommandBuffer::InfoGraphicBuffer* info = (ext::opengl::CommandBuffer::InfoGraphicBuffer*) &vertexBufferInfo;
+			vertexBuffer = info->graphic->buffers[info->bufferIndex].descriptor;
+		} break;
+	}
+	if ( !vertexBuffer.buffer ) return;
+
+	size_t vertexStride = drawInfo.descriptor.geometry.attributes.vertex.size;
+	size_t vertices = vertexBuffer.range / vertexStride;
+	
+	uf::renderer::VertexDescriptor 	vertexAttributePosition, 
+									vertexAttributeNormal,
+									vertexAttributeColor,
+									vertexAttributeUv,
+									vertexAttributeId;
+
+	for ( auto& attribute : drawInfo.descriptor.geometry.attributes.descriptor ) {
+		if ( attribute.name == "position" ) vertexAttributePosition = attribute;
+		else if ( attribute.name == "normal" ) vertexAttributeNormal = attribute;
+		else if ( attribute.name == "color" ) vertexAttributeColor = attribute;
+		else if ( attribute.name == "uv" ) vertexAttributeUv = attribute;
+		else if ( attribute.name == "id" ) vertexAttributeId = attribute;
+	}
+	if ( vertexAttributePosition.name == "" ) return;
+
+	if ( drawInfo.descriptor.cullMode == GL_NONE ) {
+		GL_ERROR_CHECK(glDisable(GL_CULL_FACE));
+	} else {
+		GL_ERROR_CHECK(glEnable(GL_CULL_FACE));
+		GL_ERROR_CHECK(glFrontFace(drawInfo.descriptor.frontFace));
+		GL_ERROR_CHECK(glCullFace(drawInfo.descriptor.cullMode));
+	}
+	if ( drawInfo.descriptor.depth.test ) {
+		GL_ERROR_CHECK(glEnable(GL_DEPTH_TEST));
+	} else {
+		GL_ERROR_CHECK(glDisable(GL_DEPTH_TEST));
+	}
+	GL_ERROR_CHECK(glDepthMask(drawInfo.descriptor.depth.write ? GL_TRUE : GL_FALSE));
+
+	// GPU-buffer based command dispatching
+#if !UF_USE_OPENGL_FIXED_FUNCTION
+
+#else
+	// CPU-buffer based command dispatching
+	uint8_t* vertexPointer = (uint8_t*) ( device->getBuffer( vertexBuffer.buffer ) + vertexBuffer.offset );
+
+	// vertices do not need to be transformed
+	//if ( vertexAttributeId.name == "" )
+#if !UF_USE_OPENGL_IMMEDIATE_MODE
+	if ( vertexAttributeNormal.name != "" )	GL_ERROR_CHECK(glEnableClientState(GL_NORMAL_ARRAY));
+	if ( vertexAttributeColor.name != "" )GL_ERROR_CHECK(glEnableClientState(GL_COLOR_ARRAY));
+	if ( vertexAttributeUv.name != "" )	GL_ERROR_CHECK(glEnableClientState(GL_TEXTURE_COORD_ARRAY));
+	GL_ERROR_CHECK(glEnableClientState(GL_VERTEX_ARRAY));
+	
+	
+	// no ID attribute found, fallback
+	if ( vertexAttributeId.name == "" ) {
+		if ( !textureInfos.empty() ) {
+			InfoTexture* info = textureInfos.front();
+			GL_ERROR_CHECK(glEnable(info->descriptor.viewType));
+			GL_ERROR_CHECK(glBindTexture(info->descriptor.viewType, info->descriptor.image));
+		}
+		GL_BIND_POINTERS();
+		GL_ERROR_CHECK(glDrawArrays(GL_TRIANGLES, 0, vertices));
+	} else {
+		if ( textureInfos.empty() ) {
+			GL_BIND_POINTERS();
+			GL_ERROR_CHECK(glDrawArrays(GL_TRIANGLES, 0, vertices));
+		} else if ( textureInfos.size() == 1 ) {
+			InfoTexture* info = textureInfos.front();
+			GL_ERROR_CHECK(glEnable(info->descriptor.viewType));
+			GL_ERROR_CHECK(glBindTexture(info->descriptor.viewType, info->descriptor.image));
+			GL_BIND_POINTERS();
+			GL_ERROR_CHECK(glDrawArrays(GL_TRIANGLES, 0, vertices));
+		} else {
+			std::vector<std::vector<uf::renderer::index_t>> sorted( textureInfos.size() );
+			for ( uf::renderer::index_t index = 0; index < vertices; ++index ) {
+				uint8_t* vertex = vertexPointer + (index * vertexStride);
+
+				const pod::Vector2ui& id = *((pod::Vector2ui*) (vertex + vertexAttributeId.offset));
+				size_t textureId = id.y;
+				if ( textureInfos.size() < textureId ) continue;
+				sorted[textureId].emplace_back(index);
+			}
+			GLenum indicesType = GL_UNSIGNED_INT;
+			switch ( sizeof(uf::renderer::index_t) ) {
+				case sizeof(uint32_t): indicesType = GL_UNSIGNED_INT; break;
+				case sizeof(uint16_t): indicesType = GL_UNSIGNED_SHORT; break;
+				case sizeof(uint8_t): indicesType = GL_UNSIGNED_BYTE; break;
+			}
+			for ( size_t textureId = 0; textureId < sorted.size(); ++textureId ) {
+				auto& indices = sorted[textureId];
+				InfoTexture* info = textureInfos[textureId];
+				GL_ERROR_CHECK(glEnable(info->descriptor.viewType));
+				GL_ERROR_CHECK(glBindTexture(info->descriptor.viewType, info->descriptor.image));
+				GL_BIND_POINTERS();
+				GL_ERROR_CHECK(glDrawElements(GL_TRIANGLES, indices.size(), indicesType, &indices[0]));
+			}
+		}
+	}
+	
+	if ( vertexAttributeNormal.name != "" )	GL_ERROR_CHECK(glDisableClientState(GL_NORMAL_ARRAY));
+	if ( vertexAttributeColor.name != "" )	GL_ERROR_CHECK(glDisableClientState(GL_COLOR_ARRAY));
+	if ( vertexAttributeUv.name != "" )	GL_ERROR_CHECK(glDisableClientState(GL_TEXTURE_COORD_ARRAY));
+	GL_ERROR_CHECK(glDisableClientState(GL_VERTEX_ARRAY));
+#else
+	// no ID attribute found, fallback
+	if ( vertexAttributeId.name == "" ) {
+		if ( !textureInfos.empty() ) {
+			InfoTexture* info = textureInfos.front();
+			GL_ERROR_CHECK(glEnable(info->descriptor.viewType));
+			GL_ERROR_CHECK(glBindTexture(info->descriptor.viewType, info->descriptor.image));
+		}
+		GL_DRAW_ARRAYS( vertexPointer, vertices );
+	} else {
+		if ( textureInfos.empty() ) {
+			GL_DRAW_ARRAYS( vertexPointer, vertices );
+		} else if ( textureInfos.size() == 1 ) {
+			InfoTexture* info = textureInfos.front();
+			GL_ERROR_CHECK(glEnable(info->descriptor.viewType));
+			GL_ERROR_CHECK(glBindTexture(info->descriptor.viewType, info->descriptor.image));
+			GL_DRAW_ARRAYS( vertexPointer, vertices );
+		} else {
+			std::vector<std::vector<uf::renderer::index_t>> sorted( textureInfos.size() );
+			for ( uf::renderer::index_t index = 0; index < vertices; ++index ) {
+				uint8_t* vertex = vertexPointer + (index * vertexStride);
+
+				const pod::Vector2ui& id = *((pod::Vector2ui*) (vertex + vertexAttributeId.offset));
+				size_t textureId = id.y;
+				if ( textureInfos.size() < textureId ) continue;
+				sorted[textureId].emplace_back(index);
+			}
+			for ( size_t textureId = 0; textureId < sorted.size(); ++textureId ) {
+				auto& indices = sorted[textureId];
+				InfoTexture* info = textureInfos[textureId];
+				GL_ERROR_CHECK(glEnable(info->descriptor.viewType));
+				GL_ERROR_CHECK(glBindTexture(info->descriptor.viewType, info->descriptor.image));
+				GL_DRAW_ELEMENTS( (&indices[0]) , (indices.size()) );
+			}
+		}
+	}
+#endif
+#endif
+}
+void ext::opengl::CommandBuffer::drawIndexed( const ext::opengl::CommandBuffer::InfoDraw& drawInfo, const ext::opengl::CommandBuffer::Info& vertexBufferInfo, const ext::opengl::CommandBuffer::Info& indexBufferInfo, const std::vector<InfoTexture*>& textureInfos ) {
+	ext::opengl::Buffer::Descriptor vertexBuffer = {};
+	ext::opengl::Buffer::Descriptor indexBuffer = {};
+
+	switch ( vertexBufferInfo.type ) {
+		case ext::opengl::enums::Command::BIND_BUFFER: {
+			ext::opengl::CommandBuffer::InfoBuffer* info = (ext::opengl::CommandBuffer::InfoBuffer*) &vertexBufferInfo;
+			vertexBuffer = info->descriptor;
+		} break;
+		case ext::opengl::enums::Command::BIND_GRAPHIC_BUFFER: {
+			ext::opengl::CommandBuffer::InfoGraphicBuffer* info = (ext::opengl::CommandBuffer::InfoGraphicBuffer*) &vertexBufferInfo;
+			vertexBuffer = info->graphic->buffers[info->bufferIndex].descriptor;
+		} break;
+	}
+	switch ( indexBufferInfo.type ) {
+		case ext::opengl::enums::Command::BIND_BUFFER: {
+			ext::opengl::CommandBuffer::InfoBuffer* info = (ext::opengl::CommandBuffer::InfoBuffer*) &indexBufferInfo;
+			indexBuffer = info->descriptor;
+		} break;
+		case ext::opengl::enums::Command::BIND_GRAPHIC_BUFFER: {
+			ext::opengl::CommandBuffer::InfoGraphicBuffer* info = (ext::opengl::CommandBuffer::InfoGraphicBuffer*) &indexBufferInfo;
+			indexBuffer = info->graphic->buffers[info->bufferIndex].descriptor;
+		} break;
+	}
+
+	if ( !vertexBuffer.buffer || !indexBuffer.buffer ) return;
+
+	size_t indices = drawInfo.length;
+	size_t indicesStride = drawInfo.descriptor.geometry.attributes.index.size;
+	size_t vertexStride = drawInfo.descriptor.geometry.attributes.vertex.size;
+	size_t vertices = vertexBuffer.range / vertexStride;
+	
+	uf::renderer::VertexDescriptor 	vertexAttributePosition, 
+									vertexAttributeNormal,
+									vertexAttributeColor,
+									vertexAttributeUv,
+									vertexAttributeId;
+
+	for ( auto& attribute : drawInfo.descriptor.geometry.attributes.descriptor ) {
+		if ( attribute.name == "position" ) vertexAttributePosition = attribute;
+		else if ( attribute.name == "normal" ) vertexAttributeNormal = attribute;
+		else if ( attribute.name == "color" ) vertexAttributeColor = attribute;
+		else if ( attribute.name == "uv" ) vertexAttributeUv = attribute;
+		else if ( attribute.name == "id" ) vertexAttributeId = attribute;
+	}
+	if ( vertexAttributePosition.name == "" ) return;
+
+	if ( drawInfo.descriptor.cullMode == GL_NONE ) {
+		GL_ERROR_CHECK(glDisable(GL_CULL_FACE));
+	} else {
+		GL_ERROR_CHECK(glEnable(GL_CULL_FACE));
+		GL_ERROR_CHECK(glFrontFace(drawInfo.descriptor.frontFace));
+		GL_ERROR_CHECK(glCullFace(drawInfo.descriptor.cullMode));
+	}
+#if !UF_USE_OPENGL_FIXED_FUNCTION
+	// GPU-buffer based command dispatching
+	{
+
+	}
+#else
+	// CPU-buffer based command dispatching
+	void* vertexPointer = (void*) ( device->getBuffer( vertexBuffer.buffer ) + vertexBuffer.offset );
+	uf::renderer::index_t* indicesPointer = (uf::renderer::index_t*) ( device->getBuffer( indexBuffer.buffer ) + indexBuffer.offset );
+
+	// vertices do not need to be transformed
+	//if ( vertexAttributeId.name == "" )
+#if !UF_USE_OPENGL_IMMEDIATE_MODE
+	if ( vertexAttributeNormal.name != "" )	GL_ERROR_CHECK(glEnableClientState(GL_NORMAL_ARRAY));
+	if ( vertexAttributeColor.name != "" )GL_ERROR_CHECK(glEnableClientState(GL_COLOR_ARRAY));
+	if ( vertexAttributeUv.name != "" )	GL_ERROR_CHECK(glEnableClientState(GL_TEXTURE_COORD_ARRAY));
+	GL_ERROR_CHECK(glEnableClientState(GL_VERTEX_ARRAY));
+
+	GLenum indicesType = GL_UNSIGNED_INT;
+	switch ( indicesStride ) {
+		case sizeof(uint32_t): indicesType = GL_UNSIGNED_INT; break;
+		case sizeof(uint16_t): indicesType = GL_UNSIGNED_SHORT; break;
+		case sizeof(uint8_t): indicesType = GL_UNSIGNED_BYTE; break;
+	}
+	// no ID attribute found, fallback
+	if ( vertexAttributeId.name == "" ) {
+		if ( !textureInfos.empty() ) {
+			InfoTexture* info = textureInfos.front();
+			GL_ERROR_CHECK(glEnable(info->descriptor.viewType));
+			GL_ERROR_CHECK(glBindTexture(info->descriptor.viewType, info->descriptor.image));
+		}
+		GL_BIND_POINTERS();
+		GL_ERROR_CHECK(glDrawElements(GL_TRIANGLES, indices, indicesType, indicesPointer));
+	} else {
+		if ( textureInfos.empty() ) {
+			GL_BIND_POINTERS();
+			GL_ERROR_CHECK(glDrawElements(GL_TRIANGLES, indices, indicesType, indicesPointer));
+		} else if ( textureInfos.size() == 1 ) {
+			InfoTexture* info = textureInfos.front();
+			GL_ERROR_CHECK(glEnable(info->descriptor.viewType));
+			GL_ERROR_CHECK(glBindTexture(info->descriptor.viewType, info->descriptor.image));
+			GL_BIND_POINTERS();
+			GL_ERROR_CHECK(glDrawElements(GL_TRIANGLES, indices, indicesType, indicesPointer));
+		} else {
+			std::vector<std::vector<uf::renderer::index_t>> sorted( textureInfos.size() );
+			for ( size_t currentIndex = 0; currentIndex < indices; ++currentIndex ) {
+				auto index = indicesPointer[currentIndex];
+				void* vertices = vertexPointer + (index * vertexStride);
+
+				const pod::Vector2ui& id = *((pod::Vector2ui*) (vertices + vertexAttributeId.offset));
+				size_t textureId = id.y;
+				if ( textureInfos.size() < textureId ) continue;
+				sorted[textureId].emplace_back(index);
+			}
+			GLenum indicesType = GL_UNSIGNED_INT;
+			switch ( sizeof(uf::renderer::index_t) ) {
+				case sizeof(uint32_t): indicesType = GL_UNSIGNED_INT; break;
+				case sizeof(uint16_t): indicesType = GL_UNSIGNED_SHORT; break;
+				case sizeof(uint8_t): indicesType = GL_UNSIGNED_BYTE; break;
+			}
+			for ( size_t textureId = 0; textureId < sorted.size(); ++textureId ) {
+				auto& indices = sorted[textureId];
+				InfoTexture* info = textureInfos[textureId];
+				GL_ERROR_CHECK(glEnable(info->descriptor.viewType));
+				GL_ERROR_CHECK(glBindTexture(info->descriptor.viewType, info->descriptor.image));
+				GL_BIND_POINTERS();
+				GL_ERROR_CHECK(glDrawElements(GL_TRIANGLES, indices.size(), indicesType, &indices[0]));
+			}
+		}
+	}
+
+    if ( vertexAttributeNormal.name != "" )	GL_ERROR_CHECK(glDisableClientState(GL_NORMAL_ARRAY));
+	if ( vertexAttributeColor.name != "" )	GL_ERROR_CHECK(glDisableClientState(GL_COLOR_ARRAY));
+	if ( vertexAttributeUv.name != "" )	GL_ERROR_CHECK(glDisableClientState(GL_TEXTURE_COORD_ARRAY));
+	GL_ERROR_CHECK(glDisableClientState(GL_VERTEX_ARRAY));
+#else
+	// no ID attribute found, fallback
+	if ( vertexAttributeId.name == "" ) {
+		if ( !textureInfos.empty() ) {
+			InfoTexture* info = textureInfos.front();
+			GL_ERROR_CHECK(glEnable(info->descriptor.viewType));
+			GL_ERROR_CHECK(glBindTexture(info->descriptor.viewType, info->descriptor.image));
+		}
+		GL_DRAW_ELEMENTS( indicesPointer, indices );
+	} else {
+		if ( textureInfos.empty() ) {
+			GL_DRAW_ELEMENTS( indicesPointer, indices );
+		} else if ( textureInfos.size() == 1 ) {
+			InfoTexture* info = textureInfos.front();
+			GL_ERROR_CHECK(glEnable(info->descriptor.viewType));
+			GL_ERROR_CHECK(glBindTexture(info->descriptor.viewType, info->descriptor.image));
+			GL_DRAW_ELEMENTS( indicesPointer, indices );
+		} else {
+			std::vector<std::vector<uf::renderer::index_t>> sorted( textureInfos.size() );
+			for ( size_t currentIndex = 0; currentIndex < indices; ++currentIndex ) {
+				uf::renderer::index_t index = indicesPointer[currentIndex];
+				void* vertices = vertexPointer + (index * vertexStride);
+
+				const pod::Vector2ui& id = *((pod::Vector2ui*) (vertices + vertexAttributeId.offset));
+				size_t textureId = id.y;
+				if ( textureInfos.size() < textureId ) continue;
+				sorted[textureId].emplace_back(index);
+			}
+			for ( size_t textureId = 0; textureId < sorted.size(); ++textureId ) {
+				auto& indices = sorted[textureId];
+				InfoTexture* info = textureInfos[textureId];
+				GL_ERROR_CHECK(glEnable(info->descriptor.viewType));
+				GL_ERROR_CHECK(glBindTexture(info->descriptor.viewType, info->descriptor.image));
+				GL_DRAW_ELEMENTS( (&indices[0]) , (indices.size()) );
+			}
+		}
+	}
+#endif
+#if 0
+	GL_ERROR_CHECK(glBegin(GL_TRIANGLES)); {
+		for ( size_t i = 0; i < indices; ++i ) {
+			size_t index = indicesPointer[i];
+			void* vertex = vertexPointer + (index * vertexStride);
+			if ( vertexAttributeNormal.name != "" ) {
+				float* normal = (float*) (vertex + vertexAttributeNormal.offset);
+				GL_ERROR_CHECK(glNormal3f(normal[0], normal[1], normal[2]));
+			}
+			if ( vertexAttributeColor.name != "" ) {
+				float* color = (float*) (vertex + vertexAttributeColor.offset);
+				GL_ERROR_CHECK(glColor3f(color[0], color[1], color[2]));
+			}
+			if ( vertexAttributeUv.name != "" ) {
+				float* uv = (float*) (vertex + vertexAttributeUv.offset);
+				GL_ERROR_CHECK(glTexCoord2f(uv[0], uv[1]));
+			}
+			{
+				float* position = (float*) (vertex + vertexAttributePosition.offset);
+				GL_ERROR_CHECK(glVertex3f(position[0], position[1], position[2]));
+			}
+		}
+	} GL_ERROR_CHECK(glEnd());
+#endif
+#endif
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/opengl/device.cpp b/engine/src/ext/opengl/device.cpp
new file mode 100644
index 00000000..47fbbc15
--- /dev/null
+++ b/engine/src/ext/opengl/device.cpp
@@ -0,0 +1,222 @@
+#if UF_USE_OPENGL
+
+#include <uf/ext/opengl/opengl.h>
+#include <uf/ext/opengl/device.h>
+#include <uf/ext/opengl/initializers.h>
+#include <uf/utils/window/window.h>
+#include <uf/utils/string/ext.h>
+#include <uf/utils/mempool/mempool.h>
+#include <uf/ext/openvr/openvr.h>
+
+#include <set>
+#include <map>
+
+#include <uf/utils/serialize/serializer.h>
+
+#if UF_USE_OPENGL_FIXED_FUNCTION
+namespace {
+	std::vector<void*> localBuffers;
+}
+#endif
+
+size_t ext::opengl::Device::HandlePool::pageSize = 128;
+void ext::opengl::Device::HandlePool::allocate() {
+	return allocate(HandlePool::pageSize);
+}
+void ext::opengl::Device::HandlePool::allocate( size_t count ) {
+	size_t initial = available.size();
+	available.resize(initial + count);
+	switch ( type ) {
+		case enums::Command::GENERATE_TEXTURE: GL_ERROR_CHECK(glGenTextures(count, &available[initial])); break;
+	#if !UF_ENV_DREAMCAST
+		case enums::Command::GENERATE_BUFFER: GL_ERROR_CHECK(glGenBuffers(count, &available[initial])); break;
+	#endif
+	}
+}
+void ext::opengl::Device::HandlePool::clear() {
+	switch ( type ) {
+		case enums::Command::GENERATE_TEXTURE: GL_ERROR_CHECK(glDeleteTextures(available.size(), &available[0])); break;
+	#if !UF_ENV_DREAMCAST
+		case enums::Command::GENERATE_BUFFER: GL_ERROR_CHECK(glDeleteBuffers(available.size(), &available[0])); break;
+	#endif
+	}
+	available.clear();
+	pool.clear();
+}
+bool ext::opengl::Device::HandlePool::used( ext::opengl::Device::HandlePool::handle_t handle ) {
+	return std::find( pool.begin(), pool.end(), handle ) != pool.end();
+}
+size_t ext::opengl::Device::HandlePool::alloc( ext::opengl::Device::HandlePool::handle_t& target ) {
+	switch ( type ) {
+		case enums::Command::GENERATE_TEXTURE: if ( glIsTexture(target) ) return SIZE_MAX; break;
+	#if !UF_ENV_DREAMCAST
+		case enums::Command::GENERATE_BUFFER: if ( glIsBuffer(target) ) return SIZE_MAX; break;
+	#endif
+	}
+	if ( used(target) ) return SIZE_MAX;
+	target = available.front();
+	available.pop_front();
+
+	size_t index = pool.size();
+	pool.emplace_back(target);
+	return index;
+}
+void ext::opengl::Device::HandlePool::free( ext::opengl::Device::HandlePool::handle_t& handle ) {
+	ext::opengl::Device::HandlePool::handle_t index = handle;
+	handle = 0;
+
+	if ( !used(index) ) return;
+
+	pool.erase( std::remove(pool.begin(), pool.end(), index), pool.end() );
+
+	switch ( type ) {
+		case enums::Command::GENERATE_TEXTURE: if ( glIsTexture(index) ) glDeleteTextures(1, &index); break;
+	#if !UF_ENV_DREAMCAST
+		case enums::Command::GENERATE_BUFFER: if ( glIsBuffer(index) ) glDeleteBuffers(1, &index); break;
+	#endif
+	}
+}
+
+void ext::opengl::Device::initialize() {
+	spec::Context::globalInit();
+	activateContext();
+
+#if UF_ENV_DREAMCAST
+	#if UF_USE_OPENGL_GLDC
+		GLdcConfig config;
+		glKosInitConfig(&config);
+		config.fsaa_enabled = GL_FALSE;
+		glKosInitEx(&config);
+	#else
+		glKosInit();
+	#endif
+#else
+	glewExperimental = GL_TRUE;
+	GLenum error;
+	if ( (error = glewInit()) != GLEW_OK ) {
+		std::cout << "ERROR: " << glewGetErrorString(error) << std::endl;
+		std::exit(EXIT_FAILURE);
+		return;
+	}
+#endif
+#if UF_USE_OPENGL_FIXED_FUNCTION
+	{
+		::localBuffers.emplace_back((void*) NULL);
+	}
+#endif
+	{
+		commandBuffer.initialize(*this);
+		commandBuffer.start();
+	}
+	if ( false ) {
+		textures.type = enums::Command::GENERATE_TEXTURE;
+		textures.allocate();
+		
+		buffers.type = enums::Command::GENERATE_BUFFER;
+		buffers.allocate();
+	}
+}
+void ext::opengl::Device::destroy() {
+	commandBuffer.end();
+	commandBuffer.flush();
+	for ( auto& pair : this->contexts.container() ) {
+		if ( pair.second ) delete pair.second;
+		pair.second = NULL;
+	}
+	spec::Context::globalCleanup();
+}
+spec::Context& ext::opengl::Device::activateContext() {
+	return activateContext( std::this_thread::get_id() );
+}
+spec::Context& ext::opengl::Device::activateContext( std::thread::id id ) {
+	bool exists = this->contexts.has(id);
+	auto& context = this->contexts.get(id);
+	if ( !exists ) {
+		context = (spec::Context*) spec::uni::Context::create( contextSettings, *this->window->getHandle() );
+	}
+	context->setActive(true);
+	return *context;
+}
+
+GLuint ext::opengl::Device::createBuffer( enums::Buffer::type_t usage, GLsizeiptr size, void* data ) {
+	GLuint index = 0;
+// GPU-based buffer
+#if !UF_USE_OPENGL_FIXED_FUNCTION
+	GLenum usage;
+	if ( usage & enums::Buffer::STREAM ) {
+		if ( usage & enums::Buffer::DRAW ) usage = GL_STREAM_DRAW;
+		if ( usage & enums::Buffer::READ ) usage = GL_STREAM_READ;
+		if ( usage & enums::Buffer::COPY ) usage = GL_STREAM_COPY;
+	}
+	if ( usage & enums::Buffer::STATIC ) {
+		if ( usage & enums::Buffer::DRAW ) usage = GL_STATIC_DRAW;
+		if ( usage & enums::Buffer::READ ) usage = GL_STATIC_READ;
+		if ( usage & enums::Buffer::COPY ) usage = GL_STATIC_COPY;
+	}
+	if ( usage & enums::Buffer::DYNAMIC ) {
+		if ( usage & enums::Buffer::DRAW ) usage = GL_DYNAMIC_DRAW;
+		if ( usage & enums::Buffer::READ ) usage = GL_DYNAMIC_READ;
+		if ( usage & enums::Buffer::COPY ) usage = GL_DYNAMIC_COPY;
+	}
+
+//	GL_ERROR_CHECK(glGenBuffers(1, &index));
+	buffers.alloc( index );
+	GL_ERROR_CHECK(glBindBuffer(GL_COPY_WRITE_BUFFER, index));
+	GL_ERROR_CHECK(glBufferData(GL_COPY_WRITE_BUFFER, size, data, usage));
+	GL_ERROR_CHECK(glBindBuffer(GL_COPY_WRITE_BUFFER, 0));
+#else
+// CPU-based buffer
+	index = ::localBuffers.size();
+	auto& buffer = ::localBuffers.emplace_back();
+#if UF_MEMORYPOOL_INVALID_MALLOC
+	buffer = (void*) uf::MemoryPool::global.alloc( data, size );
+#else
+	uf::MemoryPool* memoryPool = uf::MemoryPool::global.size() > 0 ? &uf::MemoryPool::global : NULL;
+	if ( memoryPool )
+		buffer = (void*) memoryPool->alloc( data, size );
+	else {
+		buffer = malloc( size );
+		if ( data ) memcpy( buffer, data, size );
+		else memset( buffer, 0, size );
+	}
+#endif
+#endif
+	return index;
+}
+#if UF_USE_OPENGL_FIXED_FUNCTION
+void* ext::opengl::Device::getBuffer( GLuint index ) {
+	return !index || index >= ::localBuffers.size() ? NULL : ::localBuffers[index];
+}
+#endif
+void ext::opengl::Device::destroyBuffer( GLuint& index ) {
+#if !UF_USE_OPENGL_FIXED_FUNCTION
+// glDeleteBuffers
+	//if ( glIsBuffer(index) ) GL_ERROR_CHECK(glDeleteBuffers(1, index));
+	buffers.free(index);
+#else
+// CPU-based buffer
+	// invalid index
+	if ( !index || index >= ::localBuffers.size() ) return;
+	auto& buffer = ::localBuffers[index];
+	if ( buffer ) {
+	#if UF_MEMORYPOOL_INVALID_FREE
+		uf::MemoryPool::global.free( buffer );
+	#else
+		uf::MemoryPool* memoryPool = uf::MemoryPool::global.size() > 0 ? &uf::MemoryPool::global : NULL;	
+		if ( memoryPool ) memoryPool->free( buffer );
+		else free( buffer );
+	#endif
+	}
+#endif
+
+	index = GL_NULL_HANDLE;
+}
+
+size_t ext::opengl::Device::createTexture( GLuint& handle ) {
+	return textures.alloc(handle);
+}
+void ext::opengl::Device::destroyTexture( GLuint& handle ) {
+	textures.free(handle);
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/opengl/graphic.cpp b/engine/src/ext/opengl/graphic.cpp
new file mode 100644
index 00000000..fb8035c9
--- /dev/null
+++ b/engine/src/ext/opengl/graphic.cpp
@@ -0,0 +1,1927 @@
+#if UF_USE_OPENGL
+
+#include <uf/ext/opengl/graphic.h>
+#include <uf/ext/opengl/initializers.h>
+#include <uf/ext/opengl/opengl.h>
+#include <uf/ext/opengl/commands.h>
+#include <uf/ext/openvr/openvr.h>
+
+#if 0
+#include <spirv_cross/spirv_cross.hpp>
+#include <spirv_cross/spirv_glsl.hpp>
+#endif
+#include <fstream>
+#include <regex>
+
+#define GL_DEBUG_VALIDATION_MESSAGE(x)\
+	GL_VALIDATION_MESSAGE(x);
+
+namespace {
+	uint32_t VERTEX_BUFFER_BIND_ID = 0;
+#if UF_USE_OPENGL_FIXED_FUNCTION
+	std::unordered_map<std::string, ext::opengl::Shader::module_t> modules;
+#endif
+}
+
+#if UF_USE_OPENGL_FIXED_FUNCTION
+void ext::opengl::Shader::bind( const std::string& name, const module_t& module ) {
+	::modules[name] = module;
+}
+void ext::opengl::Shader::execute( const ext::opengl::Graphic& graphic, void* userdata ) {
+	if ( module ) module( *this, graphic, userdata );
+}
+#endif
+
+/*
+ext::opengl::Shader::~Shader() {
+	if ( !aliased ) destroy();
+}
+*/
+void ext::opengl::Shader::initialize( ext::opengl::Device& device, const std::string& filename, enums::Shader::type_t stage ) {
+	this->device = &device;
+	descriptor.stage = stage;
+
+	ext::opengl::Buffers::initialize( device );
+	aliased = false;
+
+	// set up metadata
+	{
+		metadata["filename"] = filename;
+		metadata["type"] = "";
+	}
+// GPU-based shader execution
+#if !UF_USE_OPENGL_FIXED_FUNCTION
+	std::string glsl;
+	{
+		std::ifstream is(this->filename = filename, std::ios::binary | std::ios::in | std::ios::ate);
+		if ( !is.is_open() ) {
+			GL_VALIDATION_MESSAGE("Error: Could not open shader file \"" << filename << "\"");
+			return;
+		}
+		is.seekg(0, std::ios::end); spirv.reserve(is.tellg()); is.seekg(0, std::ios::beg);
+		spirv.assign((std::istreambuf_iterator<char>(is)), std::istreambuf_iterator<char>());
+	
+		assert(spirv.size() > 0);
+	}
+	{
+		device.activateContext();
+		module = glCreateShader(stage);
+		GL_ERROR_CHECK(glShaderSource(module, 1, &glsl.c_str(), NULL));
+		GL_ERROR_CHECK(glCompileShader(module));
+	}
+	{
+		size_t len = 1024;
+		GLint status;
+		GLbyte log[len];
+		GL_ERROR_CHECK(glGetShaderiv(module, GL_LINK_STATUS, &status));
+		if ( !status ) {
+			GL_ERROR_CHECK(glGetShaderInfoLog(module, len, NULL, log));
+			GL_VALIDATION_MESSAGE(log);
+		}
+	}
+// CPU-based shader execution
+#else
+	{
+	//	GL_VALIDATION_MESSAGE(filename);
+		if ( ::modules.count(filename) > 0 ) {
+			module = ::modules[filename];
+		}
+	}
+#endif
+#if 0	
+	std::string spirv;
+	
+	{
+		std::ifstream is(this->filename = filename, std::ios::binary | std::ios::in | std::ios::ate);
+		if ( !is.is_open() ) {
+			GL_VALIDATION_MESSAGE("Error: Could not open shader file \"" << filename << "\"");
+			return;
+		}
+		is.seekg(0, std::ios::end); spirv.reserve(is.tellg()); is.seekg(0, std::ios::beg);
+		spirv.assign((std::istreambuf_iterator<char>(is)), std::istreambuf_iterator<char>());
+	
+		assert(spirv.size() > 0);
+	}
+	
+	{
+	
+		GLhandle(VkShaderModuleCreateInfo) moduleCreateInfo = {};
+		moduleCreateInfo.sType = GL_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+		moduleCreateInfo.codeSize = spirv.size();
+		moduleCreateInfo.pCode = (uint32_t*) spirv.data();
+
+		GL_CHECK_RESULT(vkCreateShaderModule(device, &moduleCreateInfo, NULL, &module));
+	}
+	
+	{
+		descriptor.sType = GL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+		descriptor.stage = stage;
+		descriptor.module = module;
+		descriptor.pName = "main";
+
+		assert(descriptor.module != GL_NULL_HANDLE);
+	}
+	// set up metadata
+	{
+		metadata["filename"] = filename;
+		metadata["type"] = "";
+	}
+	// do reflection
+	{
+		spirv_cross::Compiler comp( (uint32_t*) &spirv[0], spirv.size() / 4 );
+		spirv_cross::ShaderResources res = comp.get_shader_resources();
+
+		std::function<ext::json::Value(spirv_cross::TypeID)> parseMembers = [&]( spirv_cross::TypeID type_id ) {
+			auto parseMember = [&]( auto type_id ){
+				uf::Serializer payload;
+				
+				auto type = comp.get_type(type_id);
+
+				std::string name = "";
+				size_t size = 1;
+				ext::json::Value value;
+				switch ( type.basetype ) {
+					case spirv_cross::SPIRType::BaseType::Boolean: 		name = "bool"; 		size = sizeof(bool); 		value = (bool) 0; 		break;
+					case spirv_cross::SPIRType::BaseType::SByte: 		name = "int8_t"; 	size = sizeof(int8_t); 		value = (int8_t) 0; 	break;
+					case spirv_cross::SPIRType::BaseType::UByte: 		name = "uint8_t"; 	size = sizeof(uint8_t); 	value = (uint8_t) 0; 	break;
+					case spirv_cross::SPIRType::BaseType::Short: 		name = "int16_t"; 	size = sizeof(int16_t); 	value = (int16_t) 0; 	break;
+					case spirv_cross::SPIRType::BaseType::UShort: 		name = "uint16_t";	size = sizeof(uint16_t); 	value = (uint16_t) 0; 	break;
+					case spirv_cross::SPIRType::BaseType::Int: 			name = "int32_t"; 	size = sizeof(int32_t); 	value = (int32_t) 0; 	break;
+					case spirv_cross::SPIRType::BaseType::UInt: 		name = "uint32_t";	size = sizeof(uint32_t); 	value = (uint32_t) 0; 	break;
+					case spirv_cross::SPIRType::BaseType::Int64: 		name = "int64_t"; 	size = sizeof(int64_t); 	value = (int64_t) 0; 	break;
+					case spirv_cross::SPIRType::BaseType::UInt64: 		name = "uint64_t";	size = sizeof(uint64_t); 	value = (uint64_t) 0; 	break;
+					case spirv_cross::SPIRType::BaseType::Half: 		name = "half"; 		size = sizeof(float)/2; 	value = (float) 0; 		break;
+					case spirv_cross::SPIRType::BaseType::Float: 		name = "float"; 	size = sizeof(float); 		value = (float) 0; 		break;
+					case spirv_cross::SPIRType::BaseType::Double: 		name = "double"; 	size = sizeof(double); 		value = (double) 0; 		break;
+					case spirv_cross::SPIRType::BaseType::Image: 		name = "image2D"; 	break;
+					case spirv_cross::SPIRType::BaseType::SampledImage: name = "sampler2D"; break;
+					case spirv_cross::SPIRType::BaseType::Sampler: 		name = "sampler"; 	break;
+					default:
+						name = comp.get_name(type_id);
+						size = comp.get_declared_struct_size(type);
+					break;
+				}
+				if ( name == "" ) name = comp.get_name(type.type_alias);
+				if ( name == "" ) name = comp.get_name(type.type_alias);
+				if ( name == "" ) name = comp.get_name(type.parent_type);
+				if ( name == "" ) name = comp.get_fallback_name(type_id);
+				if ( type.vecsize > 1 ) {
+					name = "<"+name+">";
+					if ( type.columns > 1 ) {
+						name = "Matrix"+std::to_string(type.vecsize)+"x"+std::to_string(type.columns)+name;
+					} else {
+						name = "Vector"+std::to_string(type.vecsize)+name;
+					}
+				}
+				{
+					ext::json::Value source = value;
+					value = ext::json::array();
+					for ( size_t i = 0; i < type.vecsize * type.columns; ++i ) {
+						value.emplace_back(source);
+					}
+					size *= type.columns * type.vecsize;
+				}
+				for ( auto arraySize : type.array ) {
+					if ( arraySize > 1 ) {
+						ext::json::Value source = value;
+						value = ext::json::array();
+						for ( size_t i = 0; i < arraySize; ++i ) {
+							value.emplace_back(source);
+						}
+						name += "[" + std::to_string(arraySize) + "]";
+						size *= arraySize;
+					}
+				}
+				if ( ext::json::isArray(value) && value.size() == 1 ) {
+					value = value[0];
+				}
+				payload["name"] = name;
+				payload["size"] = size;
+				payload["value"] = value;
+				return payload;
+			};
+			uf::Serializer payload = ext::json::array();
+			const auto& type = comp.get_type(type_id);
+			for ( auto& member_type_id : type.member_types ) {
+				const auto& member_type = comp.get_type(member_type_id);
+				std::string name = comp.get_member_name(type.type_alias, payload.size());
+				if ( name == "" ) name = comp.get_member_name(type.parent_type, payload.size());
+				if ( name == "" ) name = comp.get_member_name(type_id, payload.size());
+				
+				auto& entry = payload.emplace_back();
+				auto parsed = parseMember(member_type_id);
+				std::string type_name = parsed["name"];
+				entry["name"] = type_name + " " + name; 
+				if ( member_type.basetype == spirv_cross::SPIRType::BaseType::Struct ) {
+					entry["struct"] = true;
+					auto parsed = parseMembers(member_type_id);
+					if ( !member_type.array.empty() && member_type.array[0] > 1 ) {
+						size_t size = comp.get_declared_struct_size(member_type);
+						for ( auto arraySize : member_type.array ) {
+							ext::json::Value source = parsed;
+							parsed = ext::json::array();
+							for ( size_t i = 0; i < arraySize; ++i ) {
+								parsed.emplace_back(source);
+							}
+							size = size * arraySize;
+						}
+						entry["size"] = size;
+						entry["value"] = parsed;
+					} else {
+						entry["size"] = comp.get_declared_struct_size(member_type);
+						entry["members"] = parsed;
+					}
+				} else {
+					entry["size"] = parsed["size"];
+					entry["value"] = parsed["value"];
+				}
+			}
+			return payload;
+		};
+
+		auto parseResource = [&]( const spirv_cross::Resource& resource, GLhandle(VkDescriptorType) descriptorType, size_t index ) {			
+			const auto& type = comp.get_type(resource.type_id);
+			const auto& base_type = comp.get_type(resource.base_type_id);
+			std::string name = resource.name;
+			
+			switch ( descriptorType ) {
+				case GL_DESCRIPTOR_TYPE_UNIFORM_BUFFER: {
+					size_t size = comp.get_declared_struct_size(base_type);
+					if ( size <= 0 ) break;
+					if ( size > device.properties.limits.maxUniformBufferRange ) {
+						GL_DEBUG_VALIDATION_MESSAGE("Invalid uniform buffer length of " << size << " for shader " << filename);
+						size = device.properties.limits.maxUniformBufferRange;
+					}
+					size_t misalignment = size % device.properties.limits.minStorageBufferOffsetAlignment;
+					if ( misalignment != 0 ) {
+						GL_DEBUG_VALIDATION_MESSAGE("Invalid uniform buffer alignment of " << misalignment << " for shader " << filename << ", correcting...");
+						size += misalignment;
+					}
+					{
+						GL_DEBUG_VALIDATION_MESSAGE("Uniform size of " << size << " for shader " << filename);
+						auto& uniform = uniforms.emplace_back();
+						uniform.create( size );
+					}		
+					// generate definition to JSON
+					{
+						metadata["definitions"]["uniforms"][name]["name"] = name;
+						metadata["definitions"]["uniforms"][name]["index"] = index;
+						metadata["definitions"]["uniforms"][name]["size"] = size;
+						metadata["definitions"]["uniforms"][name]["members"] = parseMembers(resource.type_id);
+					}
+				} break;
+				case GL_DESCRIPTOR_TYPE_STORAGE_BUFFER: {
+					// generate definition to JSON
+					{
+						metadata["definitions"]["storage"][name]["name"] = name;
+						metadata["definitions"]["storage"][name]["index"] = index;
+						metadata["definitions"]["storage"][name]["members"] = parseMembers(resource.type_id);
+					}
+					// test
+					{
+					//	updateUniform(name, getUniform(name));
+					}
+				} break;
+			}
+
+			size_t size = 1;
+			if ( !type.array.empty() ) {
+				size = type.array[0];
+			}
+			descriptorSetLayoutBindings.push_back( ext::opengl::initializers::descriptorSetLayoutBinding( descriptorType, stage, comp.get_decoration(resource.id, spv::DecorationBinding), size ) );
+		};
+		
+
+		//for ( const auto& resource : res.key ) {
+		#define LOOP_RESOURCES( key, type ) for ( size_t i = 0; i < res.key.size(); ++i ) {\
+			const auto& resource = res.key[i];\
+			GL_DEBUG_VALIDATION_MESSAGE("["<<filename<<"] Found resource: "#type " with binding: " << comp.get_decoration(resource.id, spv::DecorationBinding));\
+			parseResource( resource, type, i );\
+		}
+		LOOP_RESOURCES( sampled_images, GL_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER );
+		LOOP_RESOURCES( separate_images, GL_DESCRIPTOR_TYPE_SAMPLED_IMAGE );
+		LOOP_RESOURCES( storage_images, GL_DESCRIPTOR_TYPE_STORAGE_IMAGE );
+		LOOP_RESOURCES( separate_samplers, GL_DESCRIPTOR_TYPE_SAMPLER );
+		LOOP_RESOURCES( subpass_inputs, GL_DESCRIPTOR_TYPE_INPUT_ATTACHMENT );
+		LOOP_RESOURCES( uniform_buffers, GL_DESCRIPTOR_TYPE_UNIFORM_BUFFER );
+		LOOP_RESOURCES( storage_buffers, GL_DESCRIPTOR_TYPE_STORAGE_BUFFER );
+		#undef LOOP_RESOURCES
+
+	//	if ( filename == uf::io::root + "/shaders/display.subpass.stereo.frag.spv" )
+	//		std::cout << filename << ": " << ext::json::encode(metadata, true) << std::endl;
+		
+		for ( const auto& resource : res.push_constant_buffers ) {
+			const auto& type = comp.get_type(resource.type_id);
+			const auto& base_type = comp.get_type(resource.base_type_id);
+			std::string name = resource.name;
+			size_t size = comp.get_declared_struct_size(type);
+			if ( size <= 0 ) continue;
+			// not a multiple of 4, for some reason
+			if ( size % 4 != 0 ) {
+				GL_DEBUG_VALIDATION_MESSAGE("Invalid push constant length of " << size << " for shader " << filename << ", must be multiple of 4, correcting...");
+				size /= 4;
+				++size; 
+				size *= 4;
+			}
+			if ( size > device.properties.limits.maxPushConstantsSize ) {
+				GL_DEBUG_VALIDATION_MESSAGE("Invalid push constant length of " << size << " for shader " << filename);
+				size = device.properties.limits.maxPushConstantsSize;
+			}
+			GL_DEBUG_VALIDATION_MESSAGE("Push constant size of " << size << " for shader " << filename);
+			{
+				auto& pushConstant = pushConstants.emplace_back();
+				pushConstant.create( size );
+			}
+			// generate definition to JSON
+			{
+				metadata["definitions"]["pushConstants"][name]["name"] = name;
+				metadata["definitions"]["pushConstants"][name]["size"] = size;
+				metadata["definitions"]["pushConstants"][name]["index"] = pushConstants.size() - 1;
+				metadata["definitions"]["pushConstants"][name]["members"] = parseMembers(resource.type_id);
+			}
+		}
+		
+		size_t specializationSize = 0;
+		for ( const auto& constant : comp.get_specialization_constants() ) {
+			const auto& value = comp.get_constant(constant.id);
+			const auto& type = comp.get_type(value.constant_type);
+			size_t size = 4; //comp.get_declared_struct_size(type);
+
+			GLhandle(VkSpecializationMapEntry) specializationMapEntry;
+			specializationMapEntry.constantID = constant.constant_id;
+			specializationMapEntry.size = size;
+			specializationMapEntry.offset = specializationSize;
+			specializationMapEntries.push_back(specializationMapEntry);
+			specializationSize += size;
+		}
+		if ( specializationSize > 0 ) {			
+			specializationConstants.create( specializationSize );
+			GL_DEBUG_VALIDATION_MESSAGE("Specialization constants size of " << specializationSize << " for shader " << filename);
+
+			uint8_t* s = (uint8_t*) (void*) specializationConstants;
+			size_t offset = 0;
+
+			metadata["specializationConstants"] = ext::json::array();
+			for ( const auto& constant : comp.get_specialization_constants() ) {
+				const auto& value = comp.get_constant(constant.id);
+				const auto& type = comp.get_type(value.constant_type);
+				std::string name = comp.get_name (constant.id);
+
+				ext::json::Value member;
+
+				size_t size = 4;
+				uint8_t buffer[size];
+				switch ( type.basetype ) {
+					case spirv_cross::SPIRType::UInt: {
+						auto v = value.scalar();
+						member["type"] = "uint32_t";
+						member["value"] = v;
+						member["validate"] = true;
+						memcpy( &buffer[0], &v, sizeof(v) );
+					} break;
+					case spirv_cross::SPIRType::Int: {
+						auto v = value.scalar_i32();
+						member["type"] = "int32_t";
+						member["value"] = v;
+						memcpy( &buffer[0], &v, sizeof(v) );
+					} break;
+					case spirv_cross::SPIRType::Float: {
+						auto v = value.scalar_f32();
+						member["type"] = "float";
+						member["value"] = v;
+						memcpy( &buffer[0], &v, sizeof(v) );
+					} break;
+					case spirv_cross::SPIRType::Boolean: {
+						auto v = value.scalar()!=0;
+						member["type"] = "bool";
+						member["value"] = v;
+						memcpy( &buffer[0], &v, sizeof(v) );
+					} break;
+					default: {
+						GL_DEBUG_VALIDATION_MESSAGE("Unregistered specialization constant type at offset " << offset << " for shader " << filename );
+					} break;
+				}
+				member["name"] = name;
+				member["size"] = size;
+				member["default"] = member["value"];
+				GL_DEBUG_VALIDATION_MESSAGE("Specialization constant: " << member["type"].as<std::string>() << " " << name << " = " << member["value"].dump() << "; at offset " << offset << " for shader " << filename );
+				metadata["specializationConstants"].emplace_back(member);
+
+				memcpy( &s[offset], &buffer, size );
+				offset += size;
+			}
+		/*
+			{
+				specializationInfo = {};
+				specializationInfo.dataSize = specializationSize;
+				specializationInfo.mapEntryCount = specializationMapEntries.size();
+				specializationInfo.pMapEntries = specializationMapEntries.data();
+				specializationInfo.pData = (void*) specializationConstants;
+				descriptor.pSpecializationInfo = &specializationInfo;
+			}
+		*/
+		}
+	/*
+	*/
+	//	LOOP_RESOURCES( stage_inputs, GLhandle(VkVertexInputAttributeDescription) );
+	//	LOOP_RESOURCES( stage_outputs, GLhandle(VkPipelineColorBlendAttachmentState) );
+	}
+
+	// organize layouts
+	{
+		std::sort( descriptorSetLayoutBindings.begin(), descriptorSetLayoutBindings.end(), [&]( const GLhandle(VkDescriptorSetLayoutBinding)& l, const GLhandle(VkDescriptorSetLayoutBinding)& r ){
+			return l.binding < r.binding;
+		} );
+	}
+	// update uniform buffers
+	for ( auto& uniform : uniforms ) {
+		auto& userdata = uniform.data();
+		initializeBuffer(
+			(void*) userdata.data,
+			userdata.len,
+			uf::renderer::enums::Buffer::UNIFORM
+		);
+	}
+#endif
+}
+
+void ext::opengl::Shader::destroy() {
+	if ( aliased ) return;
+	if ( !device ) return;
+
+	ext::opengl::Buffers::destroy();
+#if !UF_USE_OPENGL_FIXED_FUNCTION
+	if ( module != GL_NULL_HANDLE ) {
+		GL_ERROR_CHECK(glDeleteShader( module ));
+		module = GL_NULL_HANDLE;
+		descriptor = {};
+	}
+#endif
+
+	for ( auto& userdata : uniforms ) userdata.destroy();
+	for ( auto& userdata : pushConstants ) userdata.destroy();
+	uniforms.clear();
+	pushConstants.clear();
+}
+
+bool ext::opengl::Shader::validate() {
+	// check if uniforms match buffer size
+	bool valid = true;
+#if 0
+	{
+		auto it = uniforms.begin();
+		for ( auto& buffer : buffers ) {
+			if ( !(buffer.usage & uf::renderer::enums::Buffer::UNIFORM) ) continue;
+			if ( it == uniforms.end() ) break;
+			auto& uniform = *(it++);
+			if ( uniform.data().len != buffer.allocationInfo.size ) {
+				GL_DEBUG_VALIDATION_MESSAGE("Uniform size mismatch: Expected " << buffer.allocationInfo.size << ", got " << uniform.data().len << "; fixing...");
+				uniform.destroy();
+				uniform.create(buffer.allocationInfo.size);
+				valid = false;
+			}
+		}
+	}
+#endif
+	return valid;
+}
+bool ext::opengl::Shader::hasUniform( const std::string& name ) {
+	return !ext::json::isNull(metadata["definitions"]["uniforms"][name]);
+}
+ext::opengl::Buffer* ext::opengl::Shader::getUniformBuffer( const std::string& name ) {
+	if ( !hasUniform(name) ) return NULL;
+	size_t uniformIndex = metadata["definitions"]["uniforms"][name]["index"].as<size_t>();
+	for ( size_t bufferIndex = 0, uniformCounter = 0; bufferIndex < buffers.size(); ++bufferIndex ) {
+		if ( !(buffers[bufferIndex].usage & uf::renderer::enums::Buffer::UNIFORM) ) continue;
+		if ( uniformCounter++ != uniformIndex ) continue;
+		return &buffers[bufferIndex];
+	}
+	return NULL;
+}
+ext::opengl::userdata_t& ext::opengl::Shader::getUniform( const std::string& name ) {
+	if ( !hasUniform(name) ) {
+		static ext::opengl::userdata_t null;
+		return null;
+	}
+	auto& definition = metadata["definitions"]["uniforms"][name];
+	size_t uniformSize = definition["size"].as<size_t>();
+	size_t uniformIndex = definition["index"].as<size_t>();
+	auto& userdata = uniforms[uniformIndex];
+	return userdata;
+}
+bool ext::opengl::Shader::updateUniform( const std::string& name ) {
+	if ( !hasUniform(name) ) return false;
+	auto& uniform = getUniform(name);
+	return updateUniform(name, uniform);
+}
+bool ext::opengl::Shader::updateUniform( const std::string& name, const ext::opengl::userdata_t& userdata ) {
+	if ( !hasUniform(name) ) return false;
+	auto* bufferObject = getUniformBuffer(name);
+	if ( !bufferObject ) return false;
+	size_t size = std::max(metadata["definitions"]["uniforms"][name]["size"].as<size_t>(), (size_t) bufferObject->allocationInfo.size);
+	updateBuffer( (void*) userdata, size, *bufferObject );
+	return true;
+}
+
+uf::Serializer ext::opengl::Shader::getUniformJson( const std::string& name, bool cache ) {
+	if ( !hasUniform(name) ) return ext::json::null();
+	if ( cache && !ext::json::isNull(metadata["uniforms"][name]) ) return metadata["uniforms"][name];
+	auto& definition = metadata["definitions"]["uniforms"][name];
+	if ( cache ) return metadata["uniforms"][name] = definitionToJson(definition);
+	return definitionToJson(definition);
+}
+ext::opengl::userdata_t ext::opengl::Shader::getUniformUserdata( const std::string& name, const ext::json::Value& payload ) {
+	if ( !hasUniform(name) ) return false;
+	return jsonToUserdata(payload, metadata["definitions"]["uniforms"][name]);
+}
+bool ext::opengl::Shader::updateUniform( const std::string& name, const ext::json::Value& payload ) {
+	if ( !hasUniform(name) ) return false;
+
+	auto* bufferObject = getUniformBuffer(name);
+	if ( !bufferObject ) return false;
+
+	auto uniform = getUniformUserdata( name, payload );	
+	updateBuffer( (void*) uniform, uniform.data().len, *bufferObject );
+	return true;
+}
+
+bool ext::opengl::Shader::hasStorage( const std::string& name ) {
+	return !ext::json::isNull(metadata["definitions"]["storage"][name]);
+}
+
+ext::opengl::Buffer* ext::opengl::Shader::getStorageBuffer( const std::string& name ) {
+	if ( !hasStorage(name) ) return NULL;
+	size_t storageIndex = metadata["definitions"]["storage"][name]["index"].as<size_t>();
+	for ( size_t bufferIndex = 0, storageCounter = 0; bufferIndex < buffers.size(); ++bufferIndex ) {
+		if ( !(buffers[bufferIndex].usage & uf::renderer::enums::Buffer::STORAGE) ) continue;
+		if ( storageCounter++ != storageIndex ) continue;
+		return &buffers[bufferIndex];
+	}
+	return NULL;
+}
+uf::Serializer ext::opengl::Shader::getStorageJson( const std::string& name, bool cache ) {
+	if ( !hasStorage(name) ) return ext::json::null();
+	if ( cache && !ext::json::isNull(metadata["storage"][name]) ) return metadata["storage"][name];
+	auto& definition = metadata["definitions"]["storage"][name];
+	if ( cache ) return metadata["storage"][name] = definitionToJson(definition);
+	return definitionToJson(definition);
+}
+ext::opengl::userdata_t ext::opengl::Shader::getStorageUserdata( const std::string& name, const ext::json::Value& payload ) {
+	if ( !hasStorage(name) ) return false;
+	return jsonToUserdata(payload, metadata["definitions"]["storage"][name]);
+}
+
+void ext::opengl::Pipeline::initialize( Graphic& graphic ) {
+	return this->initialize( graphic, graphic.descriptor );
+}
+void ext::opengl::Pipeline::initialize( Graphic& graphic, GraphicDescriptor& descriptor ) {
+	this->device = graphic.device;
+	//this->descriptor = descriptor;
+	Device& device = *graphic.device;
+#if !UF_USE_OPENGL_FIXED_FUNCTION
+	{
+		pipeline = glCreateProgram();
+		for ( auto& shader : graphic.material.shaders ) {
+			GL_ERROR_CHECK(glAttachShader(pipeline, shader.module));
+		}
+		GL_ERROR_CHECK(glLinkProgram(pipeline));
+	}
+	{
+		size_t len = 1024;
+		GLint status;
+		GLbyte log[len];
+		GL_ERROR_CHECK(glGetProgramiv(pipeline, GL_LINK_STATUS, &status));
+		if ( !status ) {
+			GL_ERROR_CHECK(glGetProgramInfoLog(pipeline, len, NULL, log));
+			GL_VALIDATION_MESSAGE(log);
+		}
+	}
+	{
+		GL_ERROR_CHECK(glGenVertexArrays(1, &vertexArray));
+		GL_ERROR_CHECK(glBindVertexArray(vertexArray));
+		for ( size_t i = 0; i < descriptor.geometry.attributes.descriptor.size(); ++i ) {
+			auto& attribute = descriptor.geometry.attributes.descriptor[i];
+
+			GL_ERROR_CHECK(glEnableVertexAttribArray(i));
+			GL_ERROR_CHECK(glVertexAttribPointer(0, attribute.components, attribute.type, false, descriptor.geometry.attributes.vertex.size, attribute.offset));
+		}
+		GL_ERROR_CHECK(glBindVertexArray(0));
+	}
+	{
+		descriptor.pipeline = pipeline;
+		descriptor.vertexArray = vertexArray;
+	}
+#endif
+	graphic.process = true;
+#if 0
+	// GL_VALIDATION_MESSAGE(&graphic << ": Shaders: " << graphic.material.shaders.size() << " Textures: " << graphic.material.textures.size());
+	assert( graphic.material.shaders.size() > 0 );
+
+	RenderMode& renderMode = ext::opengl::getRenderMode( descriptor.renderMode, true);
+	auto& renderTarget = renderMode.getRenderTarget(  descriptor.renderTarget );
+	{
+		std::vector<GLhandle(VkDescriptorSetLayoutBinding)> descriptorSetLayoutBindings;
+		std::vector<GLhandle(VkPushConstantRange)> pushConstantRanges;
+		std::vector<GLhandle(VkDescriptorPoolSize)> poolSizes;
+		std::unordered_map<GLhandle(VkDescriptorType), uint32_t> descriptorTypes;
+
+		for ( auto& shader : graphic.material.shaders ) {
+			descriptorSetLayoutBindings.insert( descriptorSetLayoutBindings.begin(), shader.descriptorSetLayoutBindings.begin(), shader.descriptorSetLayoutBindings.end() );
+
+			std::size_t offset = 0;
+			for ( auto& pushConstant : shader.pushConstants ) {
+				size_t len = pushConstant.data().len;
+				if ( len <= 0 || len > device.properties.limits.maxPushConstantsSize ) {
+					GL_DEBUG_VALIDATION_MESSAGE("Invalid push constant length of " << len << " for shader " << shader.filename);
+				//	goto PIPELINE_INITIALIZATION_INVALID;
+					len = device.properties.limits.maxPushConstantsSize;
+				}
+				pushConstantRanges.push_back(ext::opengl::initializers::pushConstantRange(
+					shader.descriptor.stage,
+					len,
+					offset
+				));
+				offset += len;
+			}
+		}
+		for ( auto& descriptor : descriptorSetLayoutBindings ) {
+			if ( descriptorTypes.count( descriptor.descriptorType ) < 0 ) descriptorTypes[descriptor.descriptorType] = 0;
+			descriptorTypes[descriptor.descriptorType] += descriptor.descriptorCount;
+		}
+		for ( auto pair : descriptorTypes ) {
+			poolSizes.push_back(ext::opengl::initializers::descriptorPoolSize(pair.first, pair.second));
+		}
+		GLhandle(VkDescriptorPoolCreateInfo) descriptorPoolInfo = ext::opengl::initializers::descriptorPoolCreateInfo(
+			poolSizes.size(),
+			poolSizes.data(),
+			1
+		);
+		
+		GL_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool));
+
+
+		GLhandle(VkDescriptorSetLayoutCreateInfo) descriptorLayout = ext::opengl::initializers::descriptorSetLayoutCreateInfo(
+			descriptorSetLayoutBindings.data(),
+			descriptorSetLayoutBindings.size()
+		);
+		GL_CHECK_RESULT(vkCreateDescriptorSetLayout( device, &descriptorLayout, nullptr, &descriptorSetLayout ));
+
+		GLhandle(VkDescriptorSetAllocateInfo) allocInfo = ext::opengl::initializers::descriptorSetAllocateInfo(
+			descriptorPool,
+			&descriptorSetLayout,
+			1
+		);
+		GL_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSet));
+
+		GLhandle(VkPipelineLayoutCreateInfo) pPipelineLayoutCreateInfo = ext::opengl::initializers::pipelineLayoutCreateInfo(
+			&descriptorSetLayout,
+			1
+		);
+		pPipelineLayoutCreateInfo.pushConstantRangeCount = pushConstantRanges.size();
+		pPipelineLayoutCreateInfo.pPushConstantRanges = pushConstantRanges.data();
+
+		GL_CHECK_RESULT(vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo, nullptr, &pipelineLayout));
+	}
+	// Compute
+	for ( auto& shader : graphic.material.shaders ) {
+		if ( shader.descriptor.stage != uf::renderer::enums::Shader::COMPUTE ) continue;
+
+		// Create compute shader pipelines
+		GLhandle(VkComputePipelineCreateInfo) computePipelineCreateInfo = ext::opengl::initializers::computePipelineCreateInfo(
+			pipelineLayout,
+			0
+		);
+		computePipelineCreateInfo.stage = shader.descriptor;
+		GL_CHECK_RESULT(vkCreateComputePipelines(device, device.pipelineCache, 1, &computePipelineCreateInfo, nullptr, &pipeline));
+	
+		return;
+	}
+	// Graphic
+	{
+		GLhandle(VkPipelineInputAssemblyStateCreateInfo) inputAssemblyState = ext::opengl::initializers::pipelineInputAssemblyStateCreateInfo(
+			descriptor.topology,
+			0,
+			GL_FALSE
+		);
+		GLhandle(VkPipelineRasterizationStateCreateInfo) rasterizationState = ext::opengl::initializers::pipelineRasterizationStateCreateInfo(
+			descriptor.fill,
+			descriptor.cullMode, //	uf::renderer::enums::CullMode::NONE,
+			descriptor.frontFace,
+			0
+		);
+		rasterizationState.lineWidth = graphic.descriptor.lineWidth;
+		rasterizationState.depthBiasEnable = graphic.descriptor.depth.bias.enable;
+		rasterizationState.depthBiasConstantFactor = graphic.descriptor.depth.bias.constant;
+		rasterizationState.depthBiasSlopeFactor = graphic.descriptor.depth.bias.slope;
+		rasterizationState.depthBiasClamp = graphic.descriptor.depth.bias.clamp;
+
+		std::vector<GLhandle(VkPipelineColorBlendAttachmentState)> blendAttachmentStates;
+
+		GLhandle(VkSampleCountFlagBits) samples = GL_SAMPLE_COUNT_1;
+		if ( renderMode.getType() != "Swapchain" ) {
+			auto& subpass = renderTarget.passes[descriptor.subpass];
+			for ( auto& color : subpass.colors ) {
+				auto& attachment = renderTarget.attachments[color.attachment];
+				blendAttachmentStates.push_back(attachment.blendState);
+				samples = std::max(samples, ext::opengl::sampleCount( attachment.descriptor.samples ));
+			}
+			// require blending if independentBlend is not an enabled feature
+			if ( device.enabledFeatures.independentBlend == GL_FALSE ) {
+				for ( size_t i = 1; i < blendAttachmentStates.size(); ++i ) {
+					blendAttachmentStates[i] = blendAttachmentStates[0];
+				}
+			}
+		} else {
+			descriptor.subpass = 0;
+
+			GLhandle(VkBool32) blendEnabled = GL_FALSE;
+			GLhandle(VkColorComponentFlags) writeMask = GL_COLOR_COMPONENT_R_BIT | GL_COLOR_COMPONENT_G_BIT | GL_COLOR_COMPONENT_B_BIT;
+
+			if ( true ) {
+				blendEnabled = GL_TRUE;
+				writeMask |= GL_COLOR_COMPONENT_A_BIT;
+			}
+
+			GLhandle(VkPipelineColorBlendAttachmentState) blendAttachmentState = ext::opengl::initializers::pipelineColorBlendAttachmentState(
+				writeMask,
+				blendEnabled
+			);
+			if ( blendEnabled == GL_TRUE ) {
+				blendAttachmentState.srcColorBlendFactor = GL_BLEND_FACTOR_SRC_ALPHA;
+				blendAttachmentState.dstColorBlendFactor = GL_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
+				blendAttachmentState.colorBlendOp = GL_BLEND_OP_ADD;
+				blendAttachmentState.srcAlphaBlendFactor = GL_BLEND_FACTOR_SRC_ALPHA;
+				blendAttachmentState.dstAlphaBlendFactor = GL_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
+				blendAttachmentState.alphaBlendOp = GL_BLEND_OP_ADD;
+			}
+			blendAttachmentStates.push_back(blendAttachmentState);
+		}
+
+		GLhandle(VkPipelineColorBlendStateCreateInfo) colorBlendState = ext::opengl::initializers::pipelineColorBlendStateCreateInfo(
+			blendAttachmentStates.size(),
+			blendAttachmentStates.data()
+		);
+		GLhandle(VkPipelineDepthStencilStateCreateInfo) depthStencilState = ext::opengl::initializers::pipelineDepthStencilStateCreateInfo(
+			descriptor.depth.test,
+			descriptor.depth.write,
+			descriptor.depth.operation //GL_COMPARE_OP_LESS_OR_EQUAL
+		);
+		GLhandle(VkPipelineViewportStateCreateInfo) viewportState = ext::opengl::initializers::pipelineViewportStateCreateInfo(
+			1, 1, 0
+		);
+		GLhandle(VkPipelineMultisampleStateCreateInfo) multisampleState = ext::opengl::initializers::pipelineMultisampleStateCreateInfo(
+			samples,
+			0
+		);
+		if ( device.features.sampleRateShading ) {
+			multisampleState.sampleShadingEnable = GL_TRUE;
+			multisampleState.minSampleShading = 0.25f;
+		}
+
+
+		std::vector<GLhandle(VkDynamicState)> dynamicStateEnables = {
+			GL_DYNAMIC_STATE_VIEWPORT,
+			GL_DYNAMIC_STATE_SCISSOR
+		};
+		GLhandle(VkPipelineDynamicStateCreateInfo) dynamicState = ext::opengl::initializers::pipelineDynamicStateCreateInfo(
+			dynamicStateEnables.data(),
+			dynamicStateEnables.size(),
+			0
+		);
+
+		// Binding description
+		std::vector<GLhandle(VkVertexInputBindingDescription)> vertexBindingDescriptions = {
+			ext::opengl::initializers::vertexInputBindingDescription(
+				VERTEX_BUFFER_BIND_ID, 
+				descriptor.geometry.attributes.vertex.size, 
+				GL_VERTEX_INPUT_RATE_VERTEX
+			)
+		};
+		// Attribute descriptions
+		// Describes memory layout and shader positions
+		std::vector<GLhandle(VkVertexInputAttributeDescription)> vertexAttributeDescriptions = {};
+		for ( auto& attribute : descriptor.geometry.attributes.descriptor ) {
+			auto d = ext::opengl::initializers::vertexInputAttributeDescription(
+				VERTEX_BUFFER_BIND_ID,
+				vertexAttributeDescriptions.size(),
+				attribute.format,
+				attribute.offset
+			);
+			vertexAttributeDescriptions.push_back(d);
+		}
+
+		GLhandle(VkPipelineVertexInputStateCreateInfo) vertexInputState = ext::opengl::initializers::pipelineVertexInputStateCreateInfo();
+		vertexInputState.vertexBindingDescriptionCount = vertexBindingDescriptions.size();
+		vertexInputState.pVertexBindingDescriptions = vertexBindingDescriptions.data();
+		vertexInputState.vertexAttributeDescriptionCount = vertexAttributeDescriptions.size();
+		vertexInputState.pVertexAttributeDescriptions = vertexAttributeDescriptions.data();
+
+		std::vector<GLhandle(VkPipelineShaderStageCreateInfo)> shaderDescriptors;
+		for ( auto& shader : graphic.material.shaders ) {
+			void* s = (void*) shader.specializationConstants;
+			size_t len = shader.specializationConstants.data().len;
+			for ( size_t i = 0; i < len / 4; ++i ) {
+				auto& payload = shader.metadata["specializationConstants"][i];
+				std::string type = payload["type"].as<std::string>();
+				if ( type == "int32_t" ) {
+					int32_t& v = ((int32_t*) s)[i];
+					// failsafe, because for some reason things break
+					if ( payload["validate"].as<bool>() && v == 0 ) {
+						GL_DEBUG_VALIDATION_MESSAGE("Specialization constant of 0 for `" << payload.dump() << "` for shader `" << shader.filename << "`");
+						v = payload["value"].is<int32_t>() ? payload["value"].as<int32_t>() : payload["default"].as<int32_t>();
+					}
+					payload["value"] = v;
+				} else if ( type == "uint32_t" ) {
+					uint32_t& v = ((uint32_t*) s)[i];
+					// failsafe, because for some reason things break
+					if ( payload["validate"].as<bool>() && v == 0 ) {
+						GL_DEBUG_VALIDATION_MESSAGE("Specialization constant of 0 for `" << payload.dump() << "` for shader `" << shader.filename << "`");
+						v = payload["value"].is<uint32_t>() ? payload["value"].as<uint32_t>() : payload["default"].as<uint32_t>();
+					}
+					payload["value"] = v;
+				} else if ( type == "float" ) {
+					float& v = ((float*) s)[i];
+					// failsafe, because for some reason things break
+					if ( payload["validate"].as<bool>() && v == 0 ) {
+						GL_DEBUG_VALIDATION_MESSAGE("Specialization constant of 0 for `" << payload.dump() << "` for shader `" << shader.filename << "`");
+						v = payload["value"].is<float>() ? payload["value"].as<float>() : payload["default"].as<float>();
+					}
+					payload["value"] = v;
+				}
+			}
+			GL_DEBUG_VALIDATION_MESSAGE("Specialization constants for shader `" << shader.filename << "`: " << shader.metadata["specializationConstants"].dump(1, '\t'));
+
+
+			{
+				shader.specializationInfo = {};
+				shader.specializationInfo.mapEntryCount = shader.specializationMapEntries.size();
+				shader.specializationInfo.pMapEntries = shader.specializationMapEntries.data();
+				shader.specializationInfo.pData = (void*) shader.specializationConstants;
+				shader.specializationInfo.dataSize = shader.specializationConstants.data().len;
+				shader.descriptor.pSpecializationInfo = &shader.specializationInfo;
+			}
+			shaderDescriptors.push_back(shader.descriptor);
+		}
+
+		GLhandle(VkGraphicsPipelineCreateInfo) pipelineCreateInfo = ext::opengl::initializers::pipelineCreateInfo(
+			pipelineLayout,
+			renderTarget.renderPass,
+			0
+		);
+		pipelineCreateInfo.pVertexInputState = &vertexInputState;
+		pipelineCreateInfo.pInputAssemblyState = &inputAssemblyState;
+		pipelineCreateInfo.pRasterizationState = &rasterizationState;
+		pipelineCreateInfo.pColorBlendState = &colorBlendState;
+		pipelineCreateInfo.pMultisampleState = &multisampleState;
+		pipelineCreateInfo.pViewportState = &viewportState;
+		pipelineCreateInfo.pDepthStencilState = &depthStencilState;
+		pipelineCreateInfo.pDynamicState = &dynamicState;
+		pipelineCreateInfo.stageCount = shaderDescriptors.size();
+		pipelineCreateInfo.pStages = shaderDescriptors.data();
+		pipelineCreateInfo.subpass = descriptor.subpass;
+
+		GL_CHECK_RESULT(vkCreateGraphicsPipelines( device, device.pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipeline));
+		GL_DEBUG_VALIDATION_MESSAGE("Created graphics pipeline");
+	}
+
+	graphic.process = true;
+	return;
+PIPELINE_INITIALIZATION_INVALID:
+	graphic.process = false;
+	GL_DEBUG_VALIDATION_MESSAGE("Pipeline initialization invalid, updating next tick...");
+	uf::thread::add( uf::thread::get("Main"), [&]() -> int {
+		this->initialize( graphic, descriptor );
+	return 0;}, true );
+	return;
+#endif
+}
+void ext::opengl::Pipeline::record( Graphic& graphic, CommandBuffer& commandBuffer, size_t pass, size_t draw ) {
+#if !UF_USE_OPENGL_FIXED_FUNCTION
+	CommandBuffer::InfoPipeline pipelineCommandInfo = {};
+	pipelineCommandInfo.type = ext::opengl::enums::Command::BIND_BUFFER;
+	pipelineCommandInfo.descriptor.pipeline = descriptor.pipeline;
+	pipelineCommandInfo.descriptor.vertexArray = descriptor.vertexArray;
+	commandBuffer.record(pipelineCommandInfo);
+#endif
+#if 0
+	auto bindPoint = GL_PIPELINE_BIND_POINT_GRAPHICS;
+	for ( auto& shader : graphic.material.shaders ) {
+		if ( shader.descriptor.stage == uf::renderer::enums::Shader::COMPUTE ) {
+			bindPoint = GL_PIPELINE_BIND_POINT_COMPUTE;
+		}
+		size_t offset = 0;
+		for ( auto& pushConstant : shader.pushConstants ) {
+			// 
+			if ( ext::json::isObject( shader.metadata["definitions"]["pushConstants"]["PushConstant"] ) ) {
+				if ( shader.descriptor.stage == uf::renderer::enums::Shader::VERTEX ) {
+					struct PushConstant {
+						uint32_t pass;
+						uint32_t draw;
+					} pushConstant = { pass, draw };
+					vkCmdPushConstants( commandBuffer, pipelineLayout, shader.descriptor.stage, 0, sizeof(pushConstant), &pushConstant );
+				}
+			} else {
+				size_t len = pushConstant.data().len;
+				void* pointer = pushConstant.data().data;
+				if ( len > 0 && pointer ) {
+					vkCmdPushConstants( commandBuffer, pipelineLayout, shader.descriptor.stage, 0, len, pointer );
+				}
+			}
+		}
+	}
+	// Bind descriptor sets describing shader binding points
+	vkCmdBindDescriptorSets(commandBuffer, bindPoint, pipelineLayout, 0, 1, &descriptorSet, 0, nullptr);
+	// Bind the rendering pipeline
+	// The pipeline (state object) contains all states of the rendering pipeline, binding it will set all the states specified at pipeline creation time
+	vkCmdBindPipeline(commandBuffer, bindPoint, pipeline);
+#endif
+}
+void ext::opengl::Pipeline::update( Graphic& graphic ) {
+	return this->update( graphic, graphic.descriptor );
+}
+void ext::opengl::Pipeline::update( Graphic& graphic, GraphicDescriptor& descriptor ) {
+#if 0
+	//
+	if ( descriptorSet == GL_NULL_HANDLE ) return;
+	//descriptor = d;
+	// generate fallback empty texture
+	auto& emptyTexture = Texture2D::empty;
+
+	RenderMode& renderMode = ext::opengl::getRenderMode(descriptor.renderMode, true);
+	auto& renderTarget = renderMode.getRenderTarget(descriptor.renderTarget );
+
+	std::vector<GLhandle(VkDescriptorSetLayoutBinding)> descriptorSetLayoutBindings;
+	for ( auto& shader : graphic.material.shaders ) {
+		descriptorSetLayoutBindings.insert( descriptorSetLayoutBindings.begin(), shader.descriptorSetLayoutBindings.begin(), shader.descriptorSetLayoutBindings.end() );
+	}
+
+	struct {
+		std::vector<GLhandle(VkDescriptorBufferInfo)> uniform;
+		std::vector<GLhandle(VkDescriptorBufferInfo)> storage;
+		std::vector<GLhandle(VkDescriptorImageInfo)> image;
+		std::vector<GLhandle(VkDescriptorImageInfo)> sampler;
+		std::vector<GLhandle(VkDescriptorImageInfo)> input;
+	} infos;
+
+	if ( descriptor.subpass < renderTarget.passes.size() ) {
+		auto& subpass = renderTarget.passes[descriptor.subpass];
+		for ( auto& input : subpass.inputs ) {
+			infos.input.push_back(ext::opengl::initializers::descriptorImageInfo( 
+				renderTarget.attachments[input.attachment].view,
+			//	input.layout
+				input.layout == GL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL ? GL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL : input.layout
+			));
+		}
+	}
+
+	{
+		for ( auto& texture : graphic.material.textures ) {
+			infos.image.emplace_back(texture.descriptor);
+		}
+		for ( auto& sampler : graphic.material.samplers ) {
+			infos.sampler.emplace_back(sampler.descriptor.info);
+		}
+	}
+
+	for ( auto& shader : graphic.material.shaders ) {
+		#define PARSE_BUFFER( buffers ) for ( auto& buffer : buffers ) {\
+			if ( buffer.usage & uf::renderer::enums::Buffer::UNIFORM ) {\
+				infos.uniform.emplace_back(buffer.descriptor);\
+			}\
+			if ( buffer.usage & uf::renderer::enums::Buffer::STORAGE ) {\
+				infos.storage.emplace_back(buffer.descriptor);\
+			}\
+		}
+
+		PARSE_BUFFER(shader.buffers)
+		PARSE_BUFFER(graphic.buffers)
+
+		// check if we can even consume that many infos
+		size_t consumes = 0;
+		for ( auto& layout : shader.descriptorSetLayoutBindings ) {
+			switch ( layout.descriptorType ) {
+				// consume an texture image info
+				case GL_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+				case GL_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+				case GL_DESCRIPTOR_TYPE_STORAGE_IMAGE: {
+					consumes += layout.descriptorCount;
+				} break;
+			}
+		}
+		for ( size_t i = infos.image.size(); i < consumes; ++i ) {
+			 infos.image.push_back(emptyTexture.descriptor);
+		}
+	}
+
+	auto uniformBufferInfo = infos.uniform.begin();
+	auto storageBufferInfo = infos.storage.begin();
+	auto imageInfo = infos.image.begin();
+	auto samplerInfo = infos.sampler.begin();
+	auto inputInfo = infos.input.begin();
+
+	#define BREAK_ASSERT(condition, ...) if ( condition ) { GL_VALIDATION_MESSAGE(#condition << "\t" << __VA_ARGS__); break; }
+	std::vector<GLhandle(VkWriteDescriptorSet)> writeDescriptorSets;
+	for ( auto& shader : graphic.material.shaders ) {
+	//	std::cout << shader.filename << ": " << std::endl;
+	//	std::cout << "\tAVAILABLE UNIFORM BUFFERS: " << infos.uniform.size() << std::endl;
+	//	std::cout << "\tAVAILABLE STORAGE BUFFERS: " << infos.storage.size() << std::endl;
+	//	std::cout << "\tCONSUMING : " << shader.descriptorSetLayoutBindings.size() << std::endl;
+		for ( auto& layout : shader.descriptorSetLayoutBindings ) {
+	//		GL_VALIDATION_MESSAGE(shader.filename << "\tType: " << layout.descriptorType << "\tConsuming: " << layout.descriptorCount);
+			switch ( layout.descriptorType ) {
+				// consume an texture image info
+				case GL_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+				case GL_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+				case GL_DESCRIPTOR_TYPE_STORAGE_IMAGE: {
+				//	std::cout << "\tINSERTING IMAGE" << std::endl;
+					BREAK_ASSERT( imageInfo == infos.image.end(), "Filename: " << shader.filename << "\tCount: " << layout.descriptorCount )
+					writeDescriptorSets.push_back(ext::opengl::initializers::writeDescriptorSet(
+						descriptorSet,
+						layout.descriptorType,
+						layout.binding,
+						&(*imageInfo),
+						layout.descriptorCount
+					));
+					imageInfo += layout.descriptorCount;
+				} break;
+				case GL_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: {
+				//	std::cout << "\tINSERTING INPUT_ATTACHMENT" << std::endl;
+					BREAK_ASSERT( inputInfo == infos.input.end(), "Filename: " << shader.filename << "\tCount: " << layout.descriptorCount )
+					writeDescriptorSets.push_back(ext::opengl::initializers::writeDescriptorSet(
+						descriptorSet,
+						layout.descriptorType,
+						layout.binding,
+						&(*inputInfo),
+						layout.descriptorCount
+					));
+					inputInfo += layout.descriptorCount;
+				} break;
+				case GL_DESCRIPTOR_TYPE_SAMPLER: {
+				//	std::cout << "\tINSERTING SAMPLER" << std::endl;
+					BREAK_ASSERT( samplerInfo == infos.sampler.end(), "Filename: " << shader.filename << "\tCount: " << layout.descriptorCount )
+					writeDescriptorSets.push_back(ext::opengl::initializers::writeDescriptorSet(
+						descriptorSet,
+						layout.descriptorType,
+						layout.binding,
+						&(*samplerInfo),
+						layout.descriptorCount
+					));
+					samplerInfo += layout.descriptorCount;
+				} break;
+				case GL_DESCRIPTOR_TYPE_UNIFORM_BUFFER: {
+				//	std::cout << "\tINSERTING UNIFORM_BUFFER" << std::endl;
+					BREAK_ASSERT( uniformBufferInfo == infos.uniform.end(), "Filename: " << shader.filename << "\tCount: " << layout.descriptorCount )
+					writeDescriptorSets.push_back(ext::opengl::initializers::writeDescriptorSet(
+						descriptorSet,
+						layout.descriptorType,
+						layout.binding,
+						&(*uniformBufferInfo),
+						layout.descriptorCount
+					));
+					uniformBufferInfo += layout.descriptorCount;
+				} break;
+				case GL_DESCRIPTOR_TYPE_STORAGE_BUFFER: {
+				//	std::cout << "\tINSERTING STORAGE_BUFFER" << std::endl;
+					BREAK_ASSERT( storageBufferInfo == infos.storage.end(), "Filename: " << shader.filename << "\tCount: " << layout.descriptorCount )
+					writeDescriptorSets.push_back(ext::opengl::initializers::writeDescriptorSet(
+						descriptorSet,
+						layout.descriptorType,
+						layout.binding,
+						&(*storageBufferInfo),
+						layout.descriptorCount
+					));
+					storageBufferInfo += layout.descriptorCount;
+				} break;
+			}
+
+		}
+	}
+
+	for ( auto& descriptor : writeDescriptorSets ) {
+		for ( size_t i = 0; i < descriptor.descriptorCount; ++i ) {
+			if ( descriptor.pBufferInfo ) {
+				if ( descriptor.pBufferInfo[i].offset % device->properties.limits.minUniformBufferOffsetAlignment != 0 ) {
+					GL_DEBUG_VALIDATION_MESSAGE("Invalid descriptor for buffer: " << descriptor.pBufferInfo[i].buffer << " (Offset: " << descriptor.pBufferInfo[i].offset << ", Range: " << descriptor.pBufferInfo[i].range << "), invalidating...");
+					goto PIPELINE_UPDATE_INVALID;
+				}
+			}
+			if ( descriptor.pImageInfo ) {
+				if ( descriptor.pImageInfo[i].imageView == 0x0 ) {
+					GL_DEBUG_VALIDATION_MESSAGE("Null image view, replacing with fallback texture...");
+					auto pointer = const_cast<GLhandle(VkDescriptorImageInfo)*>(&descriptor.pImageInfo[i]);
+					*pointer = emptyTexture.descriptor;
+				}
+				if ( descriptor.pImageInfo[i].imageLayout == GL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL ) {
+					GL_DEBUG_VALIDATION_MESSAGE("Image layout is GL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, fixing to GL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL");
+					auto pointer = const_cast<GLhandle(VkDescriptorImageInfo)*>(&descriptor.pImageInfo[i]);
+					pointer->imageLayout = GL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;
+				}
+				if ( descriptor.descriptorType == GL_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER && !descriptor.pImageInfo[i].sampler ) {
+					GL_DEBUG_VALIDATION_MESSAGE("Image descriptor type is GL_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, yet lacks a sampler, adding default sampler...");
+					auto pointer = const_cast<GLhandle(VkDescriptorImageInfo)*>(&descriptor.pImageInfo[i]);
+					pointer->sampler = emptyTexture.sampler.sampler;
+				}
+			}
+		}
+	}
+	renderMode.rebuild = true;
+	graphic.process = true;
+
+	vkUpdateDescriptorSets(
+		*device,
+		writeDescriptorSets.size(),
+		writeDescriptorSets.data(),
+		0,
+		NULL
+	);
+	return;
+
+PIPELINE_UPDATE_INVALID:
+	graphic.process = false;
+	GL_DEBUG_VALIDATION_MESSAGE("Pipeline update invalid, updating next tick...");
+	uf::thread::add( uf::thread::get("Main"), [&]() -> int {
+		this->update( graphic, descriptor );
+	return 0;}, true );
+	return;
+#endif
+}
+void ext::opengl::Pipeline::destroy() {
+	if ( aliased ) return;
+#if !UF_USE_OPENGL_FIXED_FUNCTION
+	if ( pipeline != GL_NULL_HANDLE ) {
+		GL_ERROR_CHECK(glDeleteProgram(pipeline));
+	}
+	if ( vertexArray != GL_NULL_HANDLE ) {
+		GL_ERROR_CHECK(glDeleteVertexArrays(1, &vertexArray));
+	}
+#endif
+	descriptor = {};
+#if 0
+	if ( aliased ) return;
+
+	if ( descriptorPool != GL_NULL_HANDLE) {
+		vkDestroyDescriptorPool( *device, descriptorPool, nullptr );
+		descriptorPool = GL_NULL_HANDLE;
+	}
+	if ( pipelineLayout != GL_NULL_HANDLE ) {
+		vkDestroyPipelineLayout( *device, pipelineLayout, nullptr );
+		pipelineLayout = GL_NULL_HANDLE;
+	}
+	if ( pipeline != GL_NULL_HANDLE ) {
+		vkDestroyPipeline( *device, pipeline, nullptr );
+		pipeline = GL_NULL_HANDLE;
+	}
+	if ( descriptorSetLayout != GL_NULL_HANDLE ) {
+		vkDestroyDescriptorSetLayout( *device, descriptorSetLayout, nullptr );
+		descriptorSetLayout = GL_NULL_HANDLE;
+	}
+#endif
+}
+
+void ext::opengl::Material::initialize( Device& device ) {
+	this->device = &device;
+}
+void ext::opengl::Material::destroy() {
+	if ( aliased ) return;
+
+	for ( auto& texture : textures ) texture.destroy();
+	for ( auto& shader : shaders ) shader.destroy();
+	for ( auto& sampler : samplers ) sampler.destroy();
+
+	shaders.clear();
+	textures.clear();
+	samplers.clear();
+}
+void ext::opengl::Material::attachShader( const std::string& filename, enums::Shader::type_t stage ) {
+	auto& shader = shaders.emplace_back();
+	shader.initialize( *device, filename, stage );
+
+#if 0
+	// check how many samplers requested
+	for ( auto& layout : shader.descriptorSetLayoutBindings ) {
+		if ( layout.descriptorType != GL_DESCRIPTOR_TYPE_SAMPLER ) continue;
+		Sampler& sampler = samplers.emplace_back();
+		sampler.initialize( *device );
+	}
+#endif
+	
+	std::string type = "unknown";
+	switch ( stage ) {
+		case uf::renderer::enums::Shader::VERTEX: type = "vertex"; break;
+		case uf::renderer::enums::Shader::FRAGMENT: type = "fragment"; break;
+		case uf::renderer::enums::Shader::COMPUTE: type = "compute"; break;
+	/*
+		case uf::renderer::enums::Shader::TESSELLATION_CONTROL: type = "tessellation_control"; break;
+		case uf::renderer::enums::Shader::TESSELLATION_EVALUATION: type = "tessellation_evaluation"; break;
+		case uf::renderer::enums::Shader::GEOMETRY: type = "geometry"; break;
+		case uf::renderer::enums::Shader::ALL_GRAPHICS: type = "all_graphics"; break;
+		case uf::renderer::enums::Shader::ALL: type = "all"; break;
+		case uf::renderer::enums::Shader::RAYGEN_KHR: type = "raygen"; break;
+		case uf::renderer::enums::Shader::ANY_HIT_KHR: type = "any_hit"; break;
+		case uf::renderer::enums::Shader::CLOSEST_HIT_KHR: type = "closest_hit"; break;
+		case uf::renderer::enums::Shader::MISS_KHR: type = "miss"; break;
+		case uf::renderer::enums::Shader::INTERSECTION_KHR: type = "intersection"; break;
+		case uf::renderer::enums::Shader::CALLABLE_KHR: type = "callable"; break;
+	*/
+	}
+	metadata["shaders"][type]["index"] = shaders.size() - 1;
+	metadata["shaders"][type]["filename"] = filename;
+}
+void ext::opengl::Material::initializeShaders( const std::vector<std::pair<std::string, enums::Shader::type_t>>& layout ) {
+	shaders.clear(); shaders.reserve( layout.size() );
+	for ( auto& request : layout ) {
+		attachShader( request.first, request.second );
+	}
+}
+bool ext::opengl::Material::hasShader( const std::string& type ) {
+#if !UF_USE_OPENGL_FIXED_FUNCTION
+	return !ext::json::isNull( metadata["shaders"][type] );
+#else
+	if ( ext::json::isNull( metadata["shaders"][type] ) ) return false;
+	size_t index = metadata["shaders"][type]["index"].as<size_t>();
+	auto& shader = shaders.at(index);
+	return (bool) shader.module;
+#endif
+}
+ext::opengl::Shader& ext::opengl::Material::getShader( const std::string& type ) {
+	if ( !hasShader(type) ) {
+		static ext::opengl::Shader null;
+		return null;
+	}
+	size_t index = metadata["shaders"][type]["index"].as<size_t>();
+	return shaders.at(index);
+}
+bool ext::opengl::Material::validate() {
+	bool was = true;
+	for ( auto& shader : shaders ) {
+		if ( !shader.validate() ) was = false;
+	}
+	return was;
+}
+ext::opengl::Graphic::~Graphic() {
+	this->destroy();
+}
+void ext::opengl::Graphic::initialize( const std::string& renderModeName ) {
+	RenderMode& renderMode = ext::opengl::getRenderMode(renderModeName, true);
+
+	this->descriptor.renderMode = renderModeName;
+	auto* device = renderMode.device;
+	if ( !device ) device = &ext::opengl::device;
+
+	material.initialize( *device );
+
+	ext::opengl::Buffers::initialize( *device );
+
+	// attach our "uniform"
+	{
+		pod::Uniform uniform;
+		initializeBuffer(
+			(void*) &uniform,
+			sizeof(pod::Uniform),
+			uf::renderer::enums::Buffer::UNIFORM
+		);
+	}
+}
+void ext::opengl::Graphic::initializePipeline() {
+	initializePipeline( this->descriptor, false );
+}
+ext::opengl::Pipeline& ext::opengl::Graphic::initializePipeline( GraphicDescriptor& descriptor, bool update ) {
+	auto& pipeline = pipelines[descriptor.hash()];
+
+//	auto previous = this->descriptor;
+//	this->descriptor = descriptor;
+	pipeline.initialize(*this, descriptor);
+	pipeline.update(*this, descriptor);
+//	if ( !update ) this->descriptor = previous;
+
+	initialized = true;
+	material.validate();
+
+	return pipeline;
+}
+void ext::opengl::Graphic::initializeGeometry( const uf::BaseGeometry& mesh ) {
+	// already generated, check if we can just update
+	if ( descriptor.indices > 0 ) {
+		if ( descriptor.geometry.attributes.vertex.size == mesh.attributes.vertex.size && descriptor.geometry.attributes.index.size == mesh.attributes.index.size && descriptor.indices == mesh.attributes.index.length ) {
+			// too lazy to check if this equals, only matters in pipeline creation anyways
+			descriptor.geometry = mesh;
+
+			int32_t vertexBuffer = -1;
+			int32_t indexBuffer = -1;
+			for ( size_t i = 0; i < buffers.size(); ++i ) {
+				if ( buffers[i].usage & uf::renderer::enums::Buffer::VERTEX ) vertexBuffer = i;
+				if ( buffers[i].usage & uf::renderer::enums::Buffer::INDEX ) indexBuffer = i;
+			}
+
+			if ( vertexBuffer > 0 && indexBuffer > 0 ) {
+				updateBuffer(
+					(void*) mesh.attributes.vertex.pointer,
+					mesh.attributes.vertex.size * mesh.attributes.vertex.length,
+					vertexBuffer
+				);
+				updateBuffer(
+					(void*) mesh.attributes.index.pointer,
+					mesh.attributes.index.size * mesh.attributes.index.length,
+					indexBuffer
+				);
+				return;
+			}
+		}
+	}
+
+	descriptor.geometry = mesh;
+	descriptor.indices = mesh.attributes.index.length;
+
+	initializeBuffer(
+		(void*) mesh.attributes.vertex.pointer,
+		mesh.attributes.vertex.size * mesh.attributes.vertex.length,
+		uf::renderer::enums::Buffer::VERTEX
+	);
+	initializeBuffer(
+		(void*) mesh.attributes.index.pointer,
+		mesh.attributes.index.size * mesh.attributes.index.length,
+		uf::renderer::enums::Buffer::INDEX
+	);
+}
+bool ext::opengl::Graphic::hasPipeline( GraphicDescriptor& descriptor ) {
+	return pipelines.count( descriptor.hash() ) > 0;
+}
+ext::opengl::Pipeline& ext::opengl::Graphic::getPipeline() {
+	return getPipeline( descriptor );
+}
+ext::opengl::Pipeline& ext::opengl::Graphic::getPipeline( GraphicDescriptor& descriptor ) {
+	if ( !hasPipeline(descriptor) ) return initializePipeline( descriptor );
+	return pipelines[descriptor.hash()];
+}
+void ext::opengl::Graphic::updatePipelines() {
+	for ( auto pair : this->pipelines ) {
+		pair.second.update( *this );
+	}
+}
+void ext::opengl::Graphic::record( CommandBuffer& commandBuffer, size_t pass, size_t draw ) {
+	return this->record( commandBuffer, descriptor, pass, draw );
+}
+
+#include <uf/ext/gltf/mesh.h>
+void ext::opengl::Graphic::record( CommandBuffer& commandBuffer, GraphicDescriptor& descriptor, size_t pass, size_t draw ) {
+	if ( !process ) return;
+#if 0
+	if ( !this->hasPipeline( descriptor ) ) {
+		GL_DEBUG_VALIDATION_MESSAGE(this << ": has no valid pipeline");
+		return;
+	}
+	auto& pipeline = this->getPipeline( descriptor );
+	if ( pipeline.descriptorSet == GL_NULL_HANDLE ) {
+		GL_DEBUG_VALIDATION_MESSAGE(this << ": has no valid pipeline descriptor set");
+		return;
+	}
+	pipeline.record(*this, commandBuffer, pass, draw);
+#endif
+
+#if 1
+	Buffer::Descriptor vertexBuffer = {};
+	Buffer::Descriptor indexBuffer = {};
+	Buffer::Descriptor uniformBuffer = {};
+	size_t vertexBufferSize = {};
+	size_t indexBufferSize = {};
+	size_t uniformBufferSize = {};
+	for ( auto& buffer : buffers ) {
+		if ( buffer.usage & uf::renderer::enums::Buffer::VERTEX ) { vertexBuffer = buffer.descriptor; vertexBufferSize = buffer.size; }
+		if ( buffer.usage & uf::renderer::enums::Buffer::INDEX ) { indexBuffer = buffer.descriptor; indexBufferSize = buffer.size; }
+		if ( buffer.usage & uf::renderer::enums::Buffer::UNIFORM ) { uniformBuffer = buffer.descriptor; uniformBufferSize = buffer.size; }
+	}
+	if ( !vertexBuffer.buffer ) return;
+
+	size_t length = vertexBufferSize / descriptor.geometry.attributes.vertex.size;
+	for ( auto& texture : material.textures ) {
+	//	if ( !glIsTexture(texture.image) ) continue;
+		if ( !texture.image ) continue;
+		CommandBuffer::InfoTexture textureCommandInfo = {};
+		textureCommandInfo.type = ext::opengl::enums::Command::BIND_TEXTURE;
+		textureCommandInfo.descriptor = texture.descriptor;
+		commandBuffer.record(textureCommandInfo);
+	}
+
+	CommandBuffer::InfoBuffer vertexBufferCommandInfo = {};
+	vertexBufferCommandInfo.type = ext::opengl::enums::Command::BIND_BUFFER;
+	vertexBufferCommandInfo.descriptor = vertexBuffer;
+	vertexBufferCommandInfo.usage = uf::renderer::enums::Buffer::VERTEX;
+	commandBuffer.record(vertexBufferCommandInfo);
+
+	if ( indexBuffer.buffer ) {
+		length = descriptor.indices;
+		CommandBuffer::InfoBuffer indexBufferCommandInfo = {};
+		indexBufferCommandInfo.type = ext::opengl::enums::Command::BIND_BUFFER;
+		indexBufferCommandInfo.descriptor = indexBuffer;
+		indexBufferCommandInfo.usage = uf::renderer::enums::Buffer::INDEX;
+		commandBuffer.record(indexBufferCommandInfo);
+	}
+	if ( uniformBuffer.buffer ) {
+		CommandBuffer::InfoBuffer uniformBufferCommandInfo = {};
+		uniformBufferCommandInfo.type = ext::opengl::enums::Command::BIND_BUFFER;
+		uniformBufferCommandInfo.descriptor = uniformBuffer;
+		uniformBufferCommandInfo.usage = uf::renderer::enums::Buffer::UNIFORM;
+		commandBuffer.record(uniformBufferCommandInfo);
+	}
+
+	CommandBuffer::InfoDraw drawCommandInfo = {};
+	drawCommandInfo.type = ext::opengl::enums::Command::DRAW;
+	drawCommandInfo.length = length;
+	drawCommandInfo.descriptor = descriptor;
+	commandBuffer.record(drawCommandInfo);
+#else
+	size_t vertexBuffer = GL_WHOLE_SIZE;
+	size_t indexBuffer = GL_WHOLE_SIZE;
+	size_t uniformBuffer = GL_WHOLE_SIZE;
+	for ( size_t i = 0; i < buffers.size(); ++i ) {
+		if ( buffers[i].usage & uf::renderer::enums::Buffer::VERTEX ) vertexBuffer = i;
+		if ( buffers[i].usage & uf::renderer::enums::Buffer::INDEX ) indexBuffer = i;
+		if ( buffers[i].usage & uf::renderer::enums::Buffer::UNIFORM ) uniformBuffer = i;
+	}
+	if ( vertexBuffer >= buffers.size() ) return;
+
+	size_t length = buffers[vertexBuffer].size / descriptor.geometry.attributes.vertex.size;
+	for ( auto& texture : material.textures ) {
+		if ( !texture.generated() ) continue;
+		commandBuffer.record(CommandBuffer::InfoTexture{
+			/*.type =*/ ext::opengl::enums::Command::BIND_TEXTURE,
+			/*.descriptor =*/ texture.descriptor
+		});
+	}
+
+	commandBuffer.record(CommandBuffer::InfoGraphicBuffer{
+		/*.type =*/ ext::opengl::enums::Command::BIND_GRAPHIC_BUFFER,
+		/*.graphic =*/ this,
+		/*.bufferIndex =*/ vertexBuffer
+	});
+
+	if ( 0 <= indexBuffer && indexBuffer < buffers.size() ) {
+		length = descriptor.indices;
+		commandBuffer.record(CommandBuffer::InfoGraphicBuffer{
+			/*.type =*/ ext::opengl::enums::Command::BIND_GRAPHIC_BUFFER,
+			/*.graphic =*/ this,
+			/*.bufferIndex =*/ indexBuffer
+		});
+	}
+	if ( 0 <= uniformBuffer && uniformBuffer < buffers.size() ) {
+		commandBuffer.record(CommandBuffer::InfoGraphicBuffer{
+			/*.type =*/ ext::opengl::enums::Command::BIND_GRAPHIC_BUFFER,
+			/*.graphic =*/ this,
+			/*.bufferIndex =*/ uniformBuffer
+		});
+	}
+	commandBuffer.record(CommandBuffer::InfoDraw{
+		/*.type =*/ ext::opengl::enums::Command::DRAW,
+		/*.length =*/ length,
+		/*.descriptor = */ descriptor
+	});
+#endif
+
+#if 0
+	// Bind triangle vertex buffer (contains position and colors)
+	GLhandle(VkDeviceSize) offsets[1] = { descriptor.offsets.vertex };
+	vkCmdBindVertexBuffers(commandBuffer, 0, 1, &vertexBuffer->buffer, offsets);
+	// Bind triangle index buffer
+	GLhandle(VkIndexType) indicesType = GL_INDEX_TYPE_UINT32;
+	switch ( descriptor.geometry.attributes.index.size * 8 ) {
+		case  8: indicesType = GL_INDEX_TYPE_UINT8_EXT; break;
+		case 16: indicesType = GL_INDEX_TYPE_UINT16; break;
+		case 32: indicesType = GL_INDEX_TYPE_UINT32; break;
+		default:
+			UF_EXCEPTION("invalid indices size of " + std::to_string((int) descriptor.geometry.attributes.index.size));
+		break;
+	}
+	vkCmdBindIndexBuffer(commandBuffer, indexBuffer->buffer, descriptor.offsets.index, indicesType);
+	// Draw indexed triangle
+	vkCmdDrawIndexed(commandBuffer, descriptor.indices, 1, 0, 0, 1);
+	//std::cout << (int) descriptor.indices << "\t" << (int) descriptor.offsets.index << std::endl;
+#endif
+}
+void ext::opengl::Graphic::destroy() {
+	for ( auto& pair : pipelines ) pair.second.destroy();
+	pipelines.clear();
+
+	material.destroy();
+
+	ext::opengl::Buffers::destroy();
+
+	ext::opengl::states::rebuild = true;
+}
+
+bool ext::opengl::Graphic::hasStorage( const std::string& name ) {
+	for ( auto& shader : material.shaders ) {
+		if ( shader.hasStorage(name) ) return true;
+	}
+	return false;
+}
+ext::opengl::Buffer* ext::opengl::Graphic::getStorageBuffer( const std::string& name ) {
+	size_t storageIndex = -1;
+	for ( auto& shader : material.shaders ) {
+		if ( !shader.hasStorage(name) ) continue;
+		storageIndex = shader.metadata["definitions"]["storage"][name]["index"].as<size_t>();
+		break;
+	}
+	for ( size_t bufferIndex = 0, storageCounter = 0; bufferIndex < buffers.size(); ++bufferIndex ) {
+		if ( !(buffers[bufferIndex].usage & uf::renderer::enums::Buffer::STORAGE) ) continue;
+		if ( storageCounter++ != storageIndex ) continue;
+		return &buffers[bufferIndex];
+	}
+	return NULL;
+}
+uf::Serializer ext::opengl::Graphic::getStorageJson( const std::string& name, bool cache ) {
+	for ( auto& shader : material.shaders ) {
+		if ( !shader.hasStorage(name) ) continue;
+		return shader.getStorageJson(name, cache);
+	}
+	return ext::json::null();
+}
+ext::opengl::userdata_t ext::opengl::Graphic::getStorageUserdata( const std::string& name, const ext::json::Value& payload ) {
+	for ( auto& shader : material.shaders ) {
+		if ( !shader.hasStorage(name) ) continue;
+		return shader.getStorageUserdata(name, payload);
+	}
+	return ext::opengl::userdata_t();
+}
+
+ext::opengl::Buffer::Descriptor ext::opengl::Graphic::getUniform( size_t target ) const {
+	size_t offset = 0;
+	for ( auto& buffer : buffers ) {
+		if ( !(buffer.usage & uf::renderer::enums::Buffer::UNIFORM) ) continue;
+		if ( offset++ != target ) continue;
+	//	return device->getBuffer( buffer.buffer );
+		return buffer.descriptor;
+	}
+	return {};
+}
+void ext::opengl::Graphic::updateUniform( void* data, size_t size, size_t target ) {
+	size_t offset = 0;
+	for ( auto& buffer : buffers ) {
+		if ( !(buffer.usage & uf::renderer::enums::Buffer::UNIFORM) ) continue;
+		if ( offset++ != target ) continue;
+		updateBuffer( data, size, buffer );
+	}
+}
+
+ext::opengl::Buffer::Descriptor ext::opengl::Graphic::getStorage( size_t target ) const {
+	size_t offset = 0;
+	for ( auto& buffer : buffers ) {
+		if ( !(buffer.usage & uf::renderer::enums::Buffer::STORAGE) ) continue;
+		if ( offset++ != target ) continue;
+	//	return device->getBuffer( buffer.buffer );
+		return buffer.descriptor;
+	}
+	return {};
+}
+void ext::opengl::Graphic::updateStorage( void* data, size_t size, size_t target ) {
+	size_t offset = 0;
+	for ( auto& buffer : buffers ) {
+		if ( !(buffer.usage & uf::renderer::enums::Buffer::STORAGE) ) continue;
+		if ( offset++ != target ) continue;
+		updateBuffer( data, size, buffer );
+	}
+}
+
+#include <uf/utils/string/hash.h>
+void ext::opengl::GraphicDescriptor::parse( ext::json::Value& metadata ) {
+	if ( metadata["front face"].is<std::string>() ) {
+		if ( metadata["front face"].as<std::string>() == "ccw" ) {
+			frontFace = uf::renderer::enums::Face::CCW;
+		} else if ( metadata["front face"].as<std::string>() == "cw" ) {
+			frontFace = uf::renderer::enums::Face::CW;
+		}
+	}
+	if ( metadata["cull mode"].is<std::string>() ) {
+		if ( metadata["cull mode"].as<std::string>() == "back" ) {
+			cullMode = uf::renderer::enums::CullMode::BACK;
+		} else if ( metadata["cull mode"].as<std::string>() == "front" ) {
+			cullMode = uf::renderer::enums::CullMode::FRONT;
+		} else if ( metadata["cull mode"].as<std::string>() == "none" ) {
+			cullMode = uf::renderer::enums::CullMode::NONE;
+		} else if ( metadata["cull mode"].as<std::string>() == "both" ) {
+			cullMode = uf::renderer::enums::CullMode::BOTH;
+		}
+	}
+	if ( metadata["indices"].is<size_t>() ) {
+		indices = metadata["indices"].as<size_t>();
+	}
+	if ( ext::json::isObject( metadata["offsets"] ) ) {
+		offsets.vertex = metadata["offsets"]["vertex"].as<size_t>();
+		offsets.index = metadata["offsets"]["index"].as<size_t>();
+	}
+	if ( ext::json::isObject(metadata["depth bias"]) ) {
+		depth.bias.enable = true;
+		depth.bias.constant = metadata["depth bias"]["constant"].as<float>();
+		depth.bias.slope = metadata["depth bias"]["slope"].as<float>();
+		depth.bias.clamp = metadata["depth bias"]["clamp"].as<float>();
+	}
+}
+std::string ext::opengl::GraphicDescriptor::hash() const {
+	uf::Serializer serializer;
+
+	serializer["subpass"] = subpass;
+	if ( settings::experimental::individualPipelines ) serializer["renderMode"] = renderMode;
+
+	serializer["renderTarget"] = renderTarget;
+	serializer["geometry"]["sizes"]["vertex"] = geometry.attributes.vertex.size;
+	serializer["geometry"]["sizes"]["indices"] = geometry.attributes.index.size;
+	serializer["indices"] = indices;
+	serializer["offsets"]["vertex"] = offsets.vertex;
+	serializer["offsets"]["index"] = offsets.index;
+
+	{
+		int i = 0;
+		for ( auto& attribute : geometry.attributes.descriptor ) {
+			serializer["geometry"]["attributes"][i]["format"] = attribute.format;
+			serializer["geometry"]["attributes"][i]["offset"] = attribute.offset;
+			++i;
+		}
+	}
+	serializer["topology"] = topology;
+	serializer["cullMode"] = cullMode;
+	serializer["fill"] = fill;
+	serializer["lineWidth"] = lineWidth;
+	serializer["frontFace"] = frontFace;
+	serializer["depth"]["test"] = depth.test;
+	serializer["depth"]["write"] = depth.write;
+	serializer["depth"]["operation"] = depth.operation;
+	serializer["depth"]["bias"]["enable"] = depth.bias.enable;
+	serializer["depth"]["bias"]["constant"] = depth.bias.constant;
+	serializer["depth"]["bias"]["slope"] = depth.bias.slope;
+	serializer["depth"]["bias"]["clamp"] = depth.bias.clamp;
+
+//	if ( renderMode != "Gui" ) uf::iostream << this << ": " << indices << ": " << renderMode << ": " << subpass << ": " << serializer << "\n";
+//	return uf::string::sha256( serializer.serialize() );
+	return serializer.dump();
+}
+
+ext::json::Value ext::opengl::definitionToJson(/*const*/ ext::json::Value& definition ) {
+	ext::json::Value member;
+	// is object
+	if ( !ext::json::isNull(definition["members"]) ) {
+		ext::json::forEach(definition["members"], [&](/*const*/ ext::json::Value& value){
+			std::string key = uf::string::split(value["name"].as<std::string>(), " ").back();
+			member[key] = ext::opengl::definitionToJson(value);
+		});
+	// is primitive
+	} else if ( !ext::json::isNull(definition["value"]) ) {
+		// is array of structs
+		if ( definition["struct"].as<bool>() ) {
+			ext::json::forEach(definition["value"], [&](/*const*/ ext::json::Value& value){
+				ext::json::Value parsed;
+				parsed["name"] = definition["name"];
+				parsed["size"] = definition["size"];
+				parsed["struct"] = definition["struct"];
+				parsed["members"] = value;
+				parsed = ext::opengl::definitionToJson(parsed);
+				member.emplace_back(parsed);
+			});
+		} else {
+			member = definition["value"];
+		}
+	}
+	return member;
+}
+ext::opengl::userdata_t ext::opengl::jsonToUserdata( const ext::json::Value& payload, const ext::json::Value& definition ) {
+	size_t bufferLen = definition["size"].as<size_t>();
+	
+	ext::opengl::userdata_t userdata;
+	userdata.create(bufferLen);
+
+	uint8_t* byteBuffer = (uint8_t*) (void*) userdata;
+	uint8_t* byteBufferStart = byteBuffer;
+	uint8_t* byteBufferEnd = byteBuffer + bufferLen;
+
+#if UF_JSON_NLOHMANN_ORDERED
+	// JSON is ordered, we can just push directly
+#define UF_SHADER_TRACK_NAMES 0
+#if UF_SHADER_TRACK_NAMES
+	std::vector<std::string> variableName;	
+#endif
+	std::function<void(const ext::json::Value&)> parse = [&]( const ext::json::Value& value ){
+		// is array or object
+	#if UF_SHADER_TRACK_NAMES
+		if ( ext::json::isObject(value) ) {
+			ext::json::forEach(value, [&]( const std::string& name, const ext::json::Value& member ){
+			#if UF_SHADER_TRACK_NAMES
+				variableName.emplace_back(name);
+			#endif
+				parse(member);
+			});
+			#if UF_SHADER_TRACK_NAMES
+				if ( !variableName.empty() ) variableName.pop_back();
+			#endif
+			return;
+		}
+		if ( ext::json::isArray(value) ) {
+			ext::json::forEach(value, [&]( size_t i, const ext::json::Value& element ){
+				variableName.emplace_back("["+std::to_string(i)+"]");
+				parse(element);
+			});
+			#if UF_SHADER_TRACK_NAMES
+				if ( !variableName.empty() ) variableName.pop_back();
+			#endif
+			return;
+		}
+	#else
+		if ( ext::json::isArray(value) || ext::json::isObject(value) ) {
+			ext::json::forEach(value, parse);
+			return;
+		}
+	#endif
+	#if UF_SHADER_TRACK_NAMES
+		std::string path = uf::string::join(variableName, ".");
+		path = uf::string::replace( path, ".[", "[" );
+		GL_VALIDATION_MESSAGE("[" << (byteBuffer - byteBufferStart) << " / "<< (byteBufferEnd - byteBuffer) <<"]\tInserting: " << path << " = " << value.dump());
+	#endif
+		// is strictly an int
+		if ( value.is<int>(true) ) {
+			size_t size = sizeof(int32_t);
+			auto get = value.as<int32_t>();
+			memcpy( byteBuffer, &get, size );
+			byteBuffer += size;
+		// is strictly an unsigned int
+		} else if ( value.is<size_t>(true) ) {
+			size_t size = sizeof(uint32_t);
+			auto get = value.as<uint32_t>();
+			memcpy( byteBuffer, &get, size );
+			byteBuffer += size;
+		// is strictly a float
+		} else if ( value.is<float>(true) ) {
+			size_t size = sizeof(float);
+			auto get = value.as<float>();
+			memcpy( byteBuffer, &get, size );
+			byteBuffer += size;
+		}
+	#if UF_SHADER_TRACK_NAMES
+		if ( !variableName.empty() ) variableName.pop_back();
+	#endif
+	};
+#if UF_SHADER_TRACK_NAMES
+	GL_VALIDATION_MESSAGE("Updating " << name << " in " << filename);
+	GL_VALIDATION_MESSAGE("Iterator: " << (void*) byteBuffer << "\t" << (void*) byteBufferEnd << "\t" << (byteBufferEnd - byteBuffer));
+#endif
+	parse(payload);
+#if UF_SHADER_TRACK_NAMES
+	GL_VALIDATION_MESSAGE("Iterator: " << (void*) byteBuffer << "\t" << (void*) byteBufferEnd << "\t" << (byteBufferEnd - byteBuffer));
+#endif
+
+#else
+	auto pushValue = [&]( const std::string& primitive, const ext::json::Value& input ){
+		if ( primitive == "bool" ) {
+			size_t size = sizeof(bool); // v["size"].as<size_t>();
+			if ( byteBufferEnd < byteBuffer + size ) return false; // overflow
+			auto get = input.as<bool>();
+			memcpy( byteBuffer, &get, size );
+			byteBuffer += size;
+		} else if ( primitive == "int8_t" ) {
+			size_t size = sizeof(int8_t); // v["size"].as<size_t>();
+			if ( byteBufferEnd < byteBuffer + size ) return false; // overflow
+	
+		//	auto get = input.as<int8_t>();
+		//	memcpy( byteBuffer, &get, size );
+			byteBuffer += size;
+		} else if ( primitive == "uint8_t" ) {
+			size_t size = sizeof(uint8_t); // v["size"].as<size_t>();
+			if ( byteBufferEnd < byteBuffer + size ) return false; // overflow
+		//	auto get = input.as<uint8_t>();
+		//	memcpy( byteBuffer, &get, size );
+			byteBuffer += size;
+		} else if ( primitive == "int16_t" ) {
+			size_t size = sizeof(int16_t); // v["size"].as<size_t>();
+			if ( byteBufferEnd < byteBuffer + size ) return false; // overflow
+		//	auto get = input.as<int16_t>();
+		//	memcpy( byteBuffer, &get, size );
+			byteBuffer += size;
+		} else if ( primitive == "uint16_t" ) {
+			size_t size = sizeof(uint16_t); // v["size"].as<size_t>();
+			if ( byteBufferEnd < byteBuffer + size ) return false; // overflow
+		//	auto get = input.as<uint16_t>();
+		//	memcpy( byteBuffer, &get, size );
+			byteBuffer += size;
+		} else if ( primitive == "int32_t" ) {
+			size_t size = sizeof(int32_t); // v["size"].as<size_t>();
+			if ( byteBufferEnd < byteBuffer + size ) return false; // overflow
+			auto get = input.as<int32_t>();
+			memcpy( byteBuffer, &get, size );
+			byteBuffer += size;
+		} else if ( primitive == "uint32_t" ) {
+			size_t size = sizeof(uint32_t); // v["size"].as<size_t>();
+			if ( byteBufferEnd < byteBuffer + size ) return false; // overflow
+			auto get = input.as<int32_t>();
+			memcpy( byteBuffer, &get, size );
+			byteBuffer += size;
+		} else if ( primitive == "int64_t" ) {
+			size_t size = sizeof(int64_t); // v["size"].as<size_t>();
+			if ( byteBufferEnd < byteBuffer + size ) return false; // overflow
+			auto get = input.as<uint64_t>();
+			memcpy( byteBuffer, &get, size );
+			byteBuffer += size;
+		} else if ( primitive == "uint64_t" ) {
+			size_t size = sizeof(uint64_t); // v["size"].as<size_t>();
+			if ( byteBufferEnd < byteBuffer + size ) return false; // overflow
+			auto get = input.as<uint64_t>();
+			memcpy( byteBuffer, &get, size );
+			byteBuffer += size;
+		} else if ( primitive == "half" ) {
+			size_t size = sizeof(float); // v["size"].as<size_t>();
+			if ( byteBufferEnd < byteBuffer + size ) return false; // overflow
+		//	auto get = input.as<float>();
+		//	memcpy( byteBuffer, &get, size );
+			byteBuffer += size;
+		} else if ( primitive == "float" ) {
+			size_t size = sizeof(float); // v["size"].as<size_t>();
+			if ( byteBufferEnd < byteBuffer + size ) return false; // overflow
+			auto get = input.as<float>();
+			memcpy( byteBuffer, &get, size );
+			byteBuffer += size;
+		} else if ( primitive == "double" ) {
+			auto get = input.as<double>();
+			size_t size = sizeof(double); // v["size"].as<size_t>();
+			if ( byteBufferEnd < byteBuffer + size ) return false; // overflow
+			memcpy( byteBuffer, &get, size );
+			byteBuffer += size;
+		}
+		return true;
+	};
+	#define UF_SHADER_TRACK_NAMES 0
+	#if UF_SHADER_TRACK_NAMES
+		bool SKIP_ADD = false;
+		std::vector<std::string> variableName;
+	#endif
+	std::function<void(const ext::json::Value&, const ext::json::Value&)> parseDefinition = [&](const ext::json::Value& input, const ext::json::Value& definition ){
+	#if UF_SHADER_TRACK_NAMES
+		if ( SKIP_ADD ) {
+			SKIP_ADD = false;
+		} else {
+			auto split = uf::string::split(definition["name"].as<std::string>(), " ");
+			std::string type = split.front();
+			std::string name = split.back();
+			variableName.emplace_back(name);
+		}
+	#endif
+		// is object
+		if ( !ext::json::isNull(definition["members"]) ) {
+			ext::json::forEach(definition["members"], [&](const ext::json::Value& member){
+				std::string key = uf::string::split(member["name"].as<std::string>(), " ").back();
+				parseDefinition(input[key], member);
+			});
+		// is array or primitive
+		} else if ( !ext::json::isNull(definition["value"]) ) {
+			// is object
+			auto split = uf::string::split(definition["name"].as<std::string>(), " ");
+			std::string type = split.front();
+			std::string name = split.back();
+			std::regex regex("^(?:(.+?)\\<)?(.+?)(?:\\>)?(?:\\[(\\d+)\\])?$");
+			std::smatch match;
+			if ( !std::regex_search( type, match, regex ) ) {
+				std::cout << "Ill formatted typename: " << definition["name"].as<std::string>() << std::endl;
+				return;
+			}
+			std::string vectorMatrix = match[1].str();
+			std::string primitive = match[2].str();
+			std::string arraySize = match[3].str();	
+			if ( ext::json::isObject(input) ) {
+				ext::json::Value cloned;
+				cloned["name"] = definition["name"];
+				cloned["size"] = definition["size"].as<size_t>() / definition["value"].size();
+				cloned["members"] = definition["value"][0];
+				parseDefinition( input, cloned );
+			}
+			// is array
+			else if ( ext::json::isArray(input) ) {
+				ext::json::forEach( input, [&]( size_t i, const ext::json::Value& value){
+				#if UF_SHADER_TRACK_NAMES
+					variableName.emplace_back("["+std::to_string(i)+"]");
+					SKIP_ADD = true;
+				#endif
+					parseDefinition(input[i], definition);
+				});
+			}
+			// is primitive
+			else {
+			#if UF_SHADER_TRACK_NAMES
+				std::string path = uf::string::join(variableName, ".");
+				path = uf::string::replace( path, ".[", "[" );
+				GL_VALIDATION_MESSAGE("[" << (byteBuffer - byteBufferStart) << " / "<< (byteBufferEnd - byteBuffer) <<"]\tInserting: " << path << " = (" << primitive << ") " << input.dump());
+			#endif
+				pushValue( primitive, input );
+			}
+		}
+	#if UF_SHADER_TRACK_NAMES
+		if ( !variableName.empty() ) variableName.pop_back();
+	#endif
+	};
+	//auto& definitions = metadata["definitions"]["uniforms"][name];
+#if UF_SHADER_TRACK_NAMES
+	GL_VALIDATION_MESSAGE("Updating " << name << " in " << filename);
+	GL_VALIDATION_MESSAGE("Iterator: " << (void*) byteBuffer << "\t" << (void*) byteBufferEnd << "\t" << (byteBufferEnd - byteBuffer));
+#endif
+	parseDefinition(payload, definition);
+#if UF_SHADER_TRACK_NAMES
+	GL_VALIDATION_MESSAGE("Iterator: " << (void*) byteBuffer << "\t" << (void*) byteBufferEnd << "\t" << (byteBufferEnd - byteBuffer));
+#endif
+#endif
+	return userdata;
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/opengl/opengl.cpp b/engine/src/ext/opengl/opengl.cpp
new file mode 100644
index 00000000..781d1b97
--- /dev/null
+++ b/engine/src/ext/opengl/opengl.cpp
@@ -0,0 +1,699 @@
+#if UF_USE_OPENGL
+
+#include <uf/ext/opengl/opengl.h>
+#include <uf/ext/opengl/initializers.h>
+#include <uf/ext/opengl/graphic.h>
+#include <uf/ext/opengl/rendermode.h>
+#include <uf/utils/graphic/graphic.h>
+
+#include <uf/ext/openvr/openvr.h>
+#include <uf/ext/gltf/graph.h>
+
+#include <ostream>
+#include <fstream>
+#include <atomic>
+
+namespace {
+	float fract( float n ) {
+		float whole, fractional;
+		return std::modf(n, &whole);
+	}
+}
+
+uint32_t ext::opengl::settings::width = 1280;
+uint32_t ext::opengl::settings::height = 720;
+uint8_t ext::opengl::settings::msaa = 1;
+bool ext::opengl::settings::validation = true;
+// constexpr size_t ext::opengl::settings::maxViews = 6;
+size_t ext::opengl::settings::viewCount = 2;
+
+std::vector<std::string> ext::opengl::settings::validationFilters;
+std::vector<std::string> ext::opengl::settings::requestedDeviceFeatures;
+std::vector<std::string> ext::opengl::settings::requestedDeviceExtensions;
+std::vector<std::string> ext::opengl::settings::requestedInstanceExtensions;
+
+ext::opengl::enums::Filter::type_t ext::opengl::settings::swapchainUpscaleFilter = ext::opengl::enums::Filter::LINEAR;
+
+bool ext::opengl::settings::experimental::rebuildOnTickBegin = false;
+bool ext::opengl::settings::experimental::waitOnRenderEnd = false;
+bool ext::opengl::settings::experimental::individualPipelines = true;
+bool ext::opengl::settings::experimental::multithreadedCommandRecording = true;
+std::string ext::opengl::settings::experimental::deferredMode = "";
+bool ext::opengl::settings::experimental::deferredReconstructPosition = false;
+bool ext::opengl::settings::experimental::deferredAliasOutputToSwapchain = true;
+bool ext::opengl::settings::experimental::multiview = true;
+bool ext::opengl::settings::experimental::vsync = true;
+bool ext::opengl::settings::experimental::hdr = true;
+
+GLhandle(VkColorSpaceKHR) ext::opengl::settings::formats::colorSpace;
+ext::opengl::enums::Format::type_t ext::opengl::settings::formats::color = ext::opengl::enums::Format::R8G8B8A8_UNORM;
+ext::opengl::enums::Format::type_t ext::opengl::settings::formats::depth = ext::opengl::enums::Format::D32_SFLOAT;
+ext::opengl::enums::Format::type_t ext::opengl::settings::formats::normal = ext::opengl::enums::Format::R16G16B16A16_SFLOAT;
+ext::opengl::enums::Format::type_t ext::opengl::settings::formats::position = ext::opengl::enums::Format::R16G16B16A16_SFLOAT;
+
+ext::opengl::Device ext::opengl::device;
+std::mutex ext::opengl::mutex;
+std::mutex ext::opengl::immediateModeMutex;
+
+bool ext::opengl::states::resized = false;
+bool ext::opengl::states::rebuild = false;
+uint32_t ext::opengl::states::currentBuffer = 0;
+
+std::vector<uf::Scene*> ext::opengl::scenes;
+ext::opengl::RenderMode* ext::opengl::currentRenderMode = NULL;
+std::vector<ext::opengl::RenderMode*> ext::opengl::renderModes = {
+	new ext::opengl::BaseRenderMode,
+};
+
+std::string UF_API ext::opengl::errorString() {
+	return ext::opengl::errorString(glGetError());
+}
+std::string UF_API ext::opengl::errorString( GLenum error ) {
+	std::string str = "";
+	if (error == GL_NO_ERROR) return str;
+#if UF_ENV_DREAMCAST
+#else
+	const GLubyte* bytes = gluErrorString(error);
+	str = reinterpret_cast<const char*>(bytes);
+#endif
+	return str;
+}
+
+/////
+bool ext::opengl::hasRenderMode( const std::string& name, bool isName ) {
+	for ( auto& renderMode: ext::opengl::renderModes ) {
+		if ( isName ) {
+			if ( renderMode->getName() == name ) return true;
+		} else {
+			if ( renderMode->getType() == name ) return true;
+		}
+	}
+	return false;
+}
+
+ext::opengl::RenderMode& ext::opengl::addRenderMode( ext::opengl::RenderMode* mode, const std::string& name ) {
+	mode->metadata["name"] = name;
+	renderModes.push_back(mode);
+	if ( ext::opengl::settings::validation ) uf::iostream << "Adding RenderMode: " << name << ": " << mode->getType() << "\n";
+	// reorder
+	ext::opengl::states::rebuild = true;
+	return *mode;
+}
+ext::opengl::RenderMode& ext::opengl::getRenderMode( const std::string& name, bool isName ) {
+	RenderMode* target = renderModes[0];
+	for ( auto& renderMode: renderModes ) {
+		if ( isName ) {
+			if ( renderMode->getName() == "" )  target = renderMode;
+			if ( renderMode->getName() == name ) {
+				target = renderMode;
+				break;
+			}
+		} else {
+			if ( renderMode->getType() == name ) {
+				target = renderMode;
+				break;
+			}
+		}
+	}
+//	if ( ext::opengl::settings::validation ) uf::iostream << "Requesting RenderMode `" << name << "`, got `" << target->getName() << "` (" << target->getType() << ")" << "\n";
+	return *target;
+}
+std::vector<ext::opengl::RenderMode*> ext::opengl::getRenderModes( const std::string& name, bool isName ) {
+	return ext::opengl::getRenderModes({name}, isName);
+}
+std::vector<ext::opengl::RenderMode*> ext::opengl::getRenderModes( const std::vector<std::string>& names, bool isName ) {
+	std::vector<RenderMode*> targets;
+	for ( auto& renderMode: renderModes ) {
+		if ( ( isName && std::find(names.begin(), names.end(), renderMode->getName()) != names.end() ) || std::find(names.begin(), names.end(), renderMode->getType()) != names.end() ) {
+			targets.push_back(renderMode);
+//			if ( ext::opengl::settings::validation ) uf::iostream << "Requestings RenderMode `" << name << "`, got `" << renderMode->getName() << "` (" << renderMode->getType() << ")" << "\n";
+		}
+	}
+	return targets;
+}
+void UF_API ext::opengl::removeRenderMode( ext::opengl::RenderMode* mode, bool free ) {
+	if ( !mode ) return;
+	renderModes.erase( std::remove( renderModes.begin(), renderModes.end(), mode ), renderModes.end() );
+	mode->destroy();
+	if ( free ) delete mode;
+	ext::opengl::states::rebuild = true;
+}
+void UF_API ext::opengl::initialize() {
+	device.initialize();
+	// swapchain.initialize( device );
+	if ( 0 ) {
+		std::vector<uint8_t> pixels = { 
+			255,   0, 255, 255,      0,   0,   0, 255,
+			  0,   0,   0, 255,    255,   0, 255, 255,
+		};
+		Texture2D::empty.sampler.descriptor.filter.min = uf::renderer::enums::Filter::NEAREST;
+		Texture2D::empty.sampler.descriptor.filter.mag = uf::renderer::enums::Filter::NEAREST;
+		Texture2D::empty.fromBuffers( (void*) &pixels[0], pixels.size(), uf::renderer::enums::Format::R8G8B8A8_UNORM, 2, 2 );
+	}
+	for ( auto& renderMode : renderModes ) {
+		if ( !renderMode ) continue;
+		renderMode->initialize(device);
+	}
+	
+	std::vector<std::function<int()>> jobs;
+	for ( auto& renderMode : renderModes ) {
+		if ( !renderMode ) continue;
+		if ( settings::experimental::individualPipelines ) renderMode->bindPipelines();
+		if ( settings::experimental::multithreadedCommandRecording ) {
+			jobs.emplace_back([&]{
+				renderMode->createCommandBuffers();
+				return 0;
+			});
+		} else {
+			renderMode->createCommandBuffers();
+		}
+	}
+	if ( !jobs.empty() ) {
+		uf::thread::batchWorkers( jobs );
+	}
+	// bind shaders
+#if !UF_ENV_DREAMCAST
+	{
+		ext::opengl::Shader::bind( "./data/shaders/gltf/instanced.vert.spv", [](const ext::opengl::Shader& shader, const ext::opengl::Graphic& graphic, void* userdata) {
+			if ( !userdata ) return;
+
+			ext::gltf::mesh_t::vertex_t* verticesSrc = (ext::gltf::mesh_t::vertex_t*) userdata;
+
+			uf::renderer::Buffer::Descriptor vertexBuffer = {};
+			uf::renderer::Buffer::Descriptor instancesBuffer = graphic.getStorage(0);
+			uf::renderer::Buffer::Descriptor materialsBuffer = graphic.getStorage(1);
+			uf::renderer::Buffer::Descriptor texturesBuffer  = graphic.getStorage(2);
+
+			for ( auto& buffer : graphic.buffers ) {
+				if ( (buffer.usage & uf::renderer::enums::Buffer::VERTEX) && !vertexBuffer.buffer ) vertexBuffer = buffer.descriptor;
+			}
+
+			if ( !vertexBuffer.buffer || !instancesBuffer.buffer ) return;
+
+			size_t vertexStride = graphic.descriptor.geometry.attributes.vertex.size;
+			size_t vertices = vertexBuffer.range / vertexStride;
+			
+			uf::renderer::VertexDescriptor 	vertexAttributePosition,
+											vertexAttributeUv,
+											vertexAttributeId;
+
+			for ( auto& attribute : graphic.descriptor.geometry.attributes.descriptor ) {
+				if ( attribute.name == "position" ) vertexAttributePosition = attribute;
+				else if ( attribute.name == "uv" ) vertexAttributeUv = attribute;
+				else if ( attribute.name == "id" ) vertexAttributeId = attribute;
+			}
+			if ( vertexAttributePosition.name == "" ||  vertexAttributeUv.name == "" || vertexAttributeId.name == "" ) return;
+			// GPU-buffer based command dispatching
+
+			// CPU-buffer based command dispatching
+			pod::Matrix4f* instances 			= (pod::Matrix4f*) ( graphic.device->getBuffer( instancesBuffer.buffer ) + instancesBuffer.offset );
+			pod::Material::Storage* materials 	= (pod::Material::Storage*) ( graphic.device->getBuffer( materialsBuffer.buffer ) + materialsBuffer.offset );
+			pod::Texture::Storage*  textures 	= (pod::Texture::Storage*) ( graphic.device->getBuffer( texturesBuffer.buffer ) + texturesBuffer.offset );
+			size_t instancesCount = instancesBuffer.range / sizeof(pod::Matrix4f);
+			size_t materialsCount = materialsBuffer.range / sizeof(pod::Material::Storage);
+			size_t texturesCount  = texturesBuffer.range / sizeof(pod::Texture::Storage);
+
+			uint8_t* vertexSrcPointer = (uint8_t*) ( verticesSrc );
+			uint8_t* vertexDstPointer = (uint8_t*) ( graphic.device->getBuffer( vertexBuffer.buffer ) + vertexBuffer.offset );
+			vertexSrcPointer += vertexBuffer.offset;
+
+			for ( size_t currentIndex = 0; currentIndex < vertices; ++currentIndex ) {
+				uint8_t* vertexSrc = vertexSrcPointer + (currentIndex * vertexStride);
+				uint8_t* vertexDst = vertexDstPointer + (currentIndex * vertexStride);
+			
+				const pod::Vector3f& position = *((pod::Vector3f*) (vertexSrc + vertexAttributePosition.offset));
+				const pod::Vector2ui& id = *((pod::Vector2ui*) (vertexSrc + vertexAttributeId.offset));
+				const pod::Vector2f& uv = *((pod::Vector2f*) (vertexSrc + vertexAttributeUv.offset));
+
+				pod::Vector3f& positionDst 	= *((pod::Vector3f*) (vertexDst + vertexAttributePosition.offset));
+				pod::Vector2f& uvDst 		= *((pod::Vector2f*) (vertexDst + vertexAttributeUv.offset));
+
+				auto& model = instances[id.x];
+				auto& material = materials[id.y];
+				auto& texture = textures[material.indexAlbedo];
+
+				positionDst = uf::matrix::multiply<float>( model, pod::Vector4f{ position[0], position[1], position[2], 1.0f } );
+			}
+		});
+		ext::opengl::Shader::bind( "./data/shaders/gltf/skinned.vert.spv", [](const ext::opengl::Shader& shader, const ext::opengl::Graphic& graphic, void* userdata) {
+			if ( !userdata ) return;
+
+			ext::gltf::mesh_t::vertex_t* verticesSrc = (ext::gltf::mesh_t::vertex_t*) userdata;
+
+			uf::renderer::Buffer::Descriptor vertexBuffer = {};
+			uf::renderer::Buffer::Descriptor jointsBuffer = graphic.getStorage(0);
+
+			for ( auto& buffer : graphic.buffers ) {
+				if ( (buffer.usage & uf::renderer::enums::Buffer::VERTEX) && !vertexBuffer.buffer ) vertexBuffer = buffer.descriptor;
+			}
+			if ( !vertexBuffer.buffer || !jointsBuffer.buffer ) return;
+
+			size_t vertexStride = graphic.descriptor.geometry.attributes.vertex.size;
+			size_t vertices = vertexBuffer.range / vertexStride;
+			
+			uf::renderer::VertexDescriptor 	vertexAttributePosition,
+											vertexAttributeJoints,
+											vertexAttributeWeights;
+
+			for ( auto& attribute : graphic.descriptor.geometry.attributes.descriptor ) {
+				if ( attribute.name == "position" ) 		vertexAttributePosition = attribute;
+				else if ( attribute.name == "joints" ) 		vertexAttributeJoints = attribute;
+				else if ( attribute.name == "weights" ) 	vertexAttributeWeights = attribute;
+			}
+			if ( vertexAttributePosition.name == "" || vertexAttributeJoints.name == "" || vertexAttributeWeights.name == "" ) return;
+			// GPU-buffer based command dispatching
+
+			// CPU-buffer based command dispatching
+			pod::Matrix4f* jointMatrices = (pod::Matrix4f*) ( graphic.device->getBuffer( jointsBuffer.buffer ) + jointsBuffer.offset );
+			size_t jointsCount = jointsBuffer.range / sizeof(pod::Matrix4f);
+
+			uint8_t* vertexSrcPointer = (uint8_t*) ( verticesSrc );
+			uint8_t* vertexDstPointer = (uint8_t*) ( graphic.device->getBuffer( vertexBuffer.buffer ) + vertexBuffer.offset );
+			vertexSrcPointer += vertexBuffer.offset;
+			for ( size_t currentIndex = 0; currentIndex < vertices; ++currentIndex ) {
+				uint8_t* vertexSrc = vertexSrcPointer + (currentIndex * vertexStride);
+				uint8_t* vertexDst = vertexDstPointer + (currentIndex * vertexStride);
+			
+				const pod::Vector3f& position = *((pod::Vector3f*) (vertexSrc + vertexAttributePosition.offset));
+				const pod::Vector4ui& joints = *((pod::Vector4ui*) (vertexSrc + vertexAttributeJoints.offset));
+				const pod::Vector4f& weights = *((pod::Vector4f*) (vertexSrc + vertexAttributeWeights.offset));
+
+				pod::Vector3f& positionDst 	= *((pod::Vector3f*) (vertexDst + vertexAttributePosition.offset));
+				pod::Matrix4f model = jointMatrices[joints[0]] * weights[0] + jointMatrices[joints[1]] * weights[1] + jointMatrices[joints[2]] * weights[2] + jointMatrices[joints[3]] * weights[3];
+				positionDst = uf::matrix::multiply<float>( model, pod::Vector4f{ position[0], position[1], position[2], 1.0f } );
+			}
+		});
+	}
+#endif
+}
+void UF_API ext::opengl::tick(){
+	ext::opengl::mutex.lock();
+	if ( ext::opengl::states::resized || ext::opengl::settings::experimental::rebuildOnTickBegin ) {
+		ext::opengl::states::rebuild = true;
+	}
+
+	std::function<void(uf::Entity*)> filter = [&]( uf::Entity* entity ) {
+		if ( !entity->hasComponent<uf::Graphic>() ) return;
+		ext::opengl::Graphic& graphic = entity->getComponent<uf::Graphic>();
+		if ( graphic.initialized || !graphic.process || graphic.initialized ) return;
+		graphic.initializePipeline();
+		ext::opengl::states::rebuild = true;
+	};
+	for ( uf::Scene* scene : uf::scene::scenes ) {
+		if ( !scene ) continue;
+		scene->process(filter);
+	}
+	for ( auto& renderMode : renderModes ) {
+		if ( !renderMode ) continue;
+		if ( !renderMode->device ) {
+			renderMode->initialize(ext::opengl::device);
+			ext::opengl::states::rebuild = true;
+		}
+		renderMode->tick();
+	}
+
+	std::vector<std::function<int()>> jobs;
+	for ( auto& renderMode : renderModes ) {
+		if ( !renderMode ) continue;
+		if ( ext::opengl::states::rebuild || renderMode->rebuild ) {
+			if ( settings::experimental::individualPipelines ) renderMode->bindPipelines();
+			if ( settings::experimental::multithreadedCommandRecording ) {
+				jobs.emplace_back([&]{
+					renderMode->createCommandBuffers();
+					return 0;
+				});
+			} else {
+				renderMode->createCommandBuffers();
+			}
+		}
+	}
+	if ( !jobs.empty() ) {
+		uf::thread::batchWorkers( jobs );
+	}
+	
+	ext::opengl::device.activateContext();
+
+	ext::opengl::device.commandBuffer.end();
+	ext::opengl::device.commandBuffer.submit();
+	ext::opengl::device.commandBuffer.flush();
+	ext::opengl::device.commandBuffer.start();
+	
+	ext::opengl::states::rebuild = false;
+	ext::opengl::states::resized = false;
+	ext::opengl::mutex.unlock();
+}
+void UF_API ext::opengl::render(){
+	ext::opengl::mutex.lock();
+	if ( hasRenderMode("Gui", true) ) {
+		RenderMode& primary = getRenderMode("Gui", true);
+		auto it = std::find( renderModes.begin(), renderModes.end(), &primary );
+		if ( it + 1 != renderModes.end() ) std::rotate( it, it + 1, renderModes.end() );
+	}
+	if ( hasRenderMode("", true) ) {
+		RenderMode& primary = getRenderMode("", true);
+		auto it = std::find( renderModes.begin(), renderModes.end(), &primary );
+		if ( it + 1 != renderModes.end() ) std::rotate( it, it + 1, renderModes.end() );
+	} else {
+		RenderMode& primary = getRenderMode("Swapchain", true);
+		auto it = std::find( renderModes.begin(), renderModes.end(), &primary );
+		if ( it + 1 != renderModes.end() ) std::rotate( it, it + 1, renderModes.end() );
+	}
+
+	ext::opengl::device.activateContext();
+	for ( auto& renderMode : renderModes ) {
+		if ( !renderMode ) continue;
+		if ( !renderMode->execute ) continue;
+		ext::opengl::currentRenderMode = renderMode;
+		for ( uf::Scene* scene : uf::scene::scenes ) scene->render();
+		renderMode->render();
+	}
+/*
+	{
+		glClearColor(0.0f, 0.0f, 0.0f, 0.0f);		// This Will Clear The Background Color To Black
+		glClearDepth(1.0);				// Enables Clearing Of The Depth Buffer
+		glDepthFunc(GL_LESS);				// The Type Of Depth Test To Do
+
+		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+		glMatrixMode(GL_PROJECTION);
+		glLoadIdentity();				// Reset The Projection Matrix
+
+		gluPerspective(45.0f, (GLfloat) settings::width / (GLfloat) settings::height, 0.1f, 100.0f);	// Calculate The Aspect Ratio Of The Window
+		glMatrixMode(GL_MODELVIEW);
+		
+		glLoadIdentity();				// Reset The View
+		glTranslatef(-3.0f, 1.5f, -10.0f);		// Move Left 1.5 Units And Into The Screen 6.0
+
+		// draw a triangle
+		glBegin(GL_TRIANGLES);				// start drawing a polygon
+		    glVertex3f( 0.0f, 1.0f, 0.0f);		// Top
+		    glVertex3f( 1.0f,-1.0f, 0.0f);		// Bottom Right
+		    glVertex3f(-1.0f,-1.0f, 0.0f);		// Bottom Left
+		glEnd();					// we're done with the polygon
+
+		glTranslatef(3.0f, 0.0f, 0.0f);		        // Move Right 3 Units
+
+		// draw a square (quadrilateral)
+		glBegin(GL_QUADS);				// start drawing a polygon (4 sided)
+		    glVertex3f(-1.0f, 1.0f, 0.0f);		// Top Left
+		    glVertex3f( 1.0f, 1.0f, 0.0f);		// Top Right
+		    glVertex3f( 1.0f,-1.0f, 0.0f);		// Bottom Right
+		    glVertex3f(-1.0f,-1.0f, 0.0f);		// Bottom Left
+		glEnd();					// done with the polygon
+
+		glTranslatef(3.0f, 0.0f, 0.0f);
+
+		glBegin(GL_POLYGON);				// start drawing a polygon (4 sided)
+		    glVertex3f(-0.0f, 1.0f, 0.0f);		// Top Left
+		    glVertex3f(-0.75f, 0.75f, 0.0f);
+		    glVertex3f(-1.0f, 0.0f, 0.0f);		// Top Right
+		    glVertex3f(-0.75f,-0.75f, 0.0f);		// Bottom Right
+		    glVertex3f(-0.0f,-1.0f, 0.0f);		// Bottom Left
+		    glVertex3f( 0.75f,-0.75f, 0.0f);		// Bottom Right
+		    glVertex3f( 1.0f, 0.0f, 0.0f);		// Top Right
+		    glVertex3f( 0.75f, 0.75f, 0.0f);
+		glEnd();					// done with the polygon
+
+		glTranslatef(-6.0f, -3.0f, 0.0f);
+
+		// draw a triangle
+		glBegin(GL_POLYGON);				// start drawing a polygon
+		    glVertex3f( 0.0f, 1.0f, 0.0f);		// Top
+		    glVertex3f( 1.0f,-1.0f, 0.0f);		// Bottom Right
+		    glVertex3f(-1.0f,-1.0f, 0.0f);		// Bottom Left
+		glEnd();					// we're done with the polygon
+
+		glTranslatef(3.0f, 0.0f, 0.0f);		        // Move Right 3 Units
+
+		// draw a square (quadrilateral)
+		glBegin(GL_POLYGON);				// start drawing a polygon (4 sided)
+		    glVertex3f(-1.0f, 1.0f, 0.0f);		// Top Left
+		    glVertex3f( 1.0f, 1.0f, 0.0f);		// Top Right
+		    glVertex3f( 1.0f,-1.0f, 0.0f);		// Bottom Right
+		    glVertex3f(-1.0f,-1.0f, 0.0f);		// Bottom Left
+		glEnd();					// done with the polygon
+
+		glTranslatef(3.0f, 0.0f, 0.0f);
+
+		glBegin(GL_POLYGON);				// start drawing a polygon (4 sided)
+		    glVertex3f(-0.0f, 1.0f, 0.0f);		// Top Left
+		    glVertex3f(-0.75f, 0.75f, 0.0f);
+		    glVertex3f(-1.0f, 0.0f, 0.0f);		// Top Right
+		    glVertex3f(-0.75f,-0.75f, 0.0f);		// Bottom Right
+		    glVertex3f(-0.0f,-1.0f, 0.0f);		// Bottom Left
+		    glVertex3f( 0.75f,-0.75f, 0.0f);		// Bottom Right
+		    glVertex3f( 1.0f, 0.0f, 0.0f);		// Top Right
+		    glVertex3f( 0.75f, 0.75f, 0.0f);
+		glEnd();					// done with the polygon
+	#if UF_ENV_DREAMCAST
+		glKosSwapBuffers();
+	#else
+		device.activateContext().display();
+	#endif
+	}
+*/
+	ext::opengl::currentRenderMode = NULL;
+	if ( ext::opengl::settings::experimental::waitOnRenderEnd ) {
+		synchronize();
+	}
+#if UF_USE_OPENVR
+/*
+	if ( ext::openvr::context ) {
+		ext::openvr::postSubmit();
+	}
+*/
+#endif
+	ext::opengl::mutex.unlock();
+}
+void UF_API ext::opengl::destroy() {
+	ext::opengl::mutex.lock();
+	synchronize();
+
+	Texture2D::empty.destroy();
+
+	std::function<void(uf::Entity*)> filter = [&]( uf::Entity* entity ) {
+		if ( !entity->hasComponent<uf::Graphic>() ) return;
+		uf::Graphic& graphic = entity->getComponent<uf::Graphic>();
+		graphic.destroy();
+	};
+	for ( uf::Scene* scene : uf::scene::scenes ) {
+		if ( !scene ) continue;
+		scene->process(filter);
+	}
+
+	for ( auto& renderMode : renderModes ) {
+		if ( !renderMode ) continue;
+		renderMode->destroy();
+		renderMode = NULL;
+	}
+//	swapchain.destroy();
+	device.destroy();
+	ext::opengl::mutex.unlock();
+}
+void UF_API ext::opengl::synchronize( uint8_t flag ) {
+	if ( flag & 0b01 ) {
+		for ( auto& renderMode : renderModes ) {
+			if ( !renderMode ) continue;
+			if ( !renderMode->execute ) continue;
+			renderMode->synchronize();
+		}
+	}
+	if ( flag & 0b10 ) {
+	//	vkDeviceWaitIdle( device );
+	}
+}
+std::string UF_API ext::opengl::allocatorStats(){
+	return "";
+}
+ext::opengl::enums::Format::type_t ext::opengl::formatFromString( const std::string& string ) {
+	std::unordered_map<std::string,ext::opengl::enums::Format::type_t> table = {
+		{ "UNDEFINED", ext::opengl::enums::Format::UNDEFINED },
+		{ "R4G4_UNORM_PACK8", ext::opengl::enums::Format::R4G4_UNORM_PACK8 },
+		{ "R4G4B4A4_UNORM_PACK16", ext::opengl::enums::Format::R4G4B4A4_UNORM_PACK16 },
+		{ "B4G4R4A4_UNORM_PACK16", ext::opengl::enums::Format::B4G4R4A4_UNORM_PACK16 },
+		{ "R5G6B5_UNORM_PACK16", ext::opengl::enums::Format::R5G6B5_UNORM_PACK16 },
+		{ "B5G6R5_UNORM_PACK16", ext::opengl::enums::Format::B5G6R5_UNORM_PACK16 },
+		{ "R5G5B5A1_UNORM_PACK16", ext::opengl::enums::Format::R5G5B5A1_UNORM_PACK16 },
+		{ "B5G5R5A1_UNORM_PACK16", ext::opengl::enums::Format::B5G5R5A1_UNORM_PACK16 },
+		{ "A1R5G5B5_UNORM_PACK16", ext::opengl::enums::Format::A1R5G5B5_UNORM_PACK16 },
+		{ "R8_UNORM", ext::opengl::enums::Format::R8_UNORM },
+		{ "R8_SNORM", ext::opengl::enums::Format::R8_SNORM },
+		{ "R8_USCALED", ext::opengl::enums::Format::R8_USCALED },
+		{ "R8_SSCALED", ext::opengl::enums::Format::R8_SSCALED },
+		{ "R8_UINT", ext::opengl::enums::Format::R8_UINT },
+		{ "R8_SINT", ext::opengl::enums::Format::R8_SINT },
+		{ "R8_SRGB", ext::opengl::enums::Format::R8_SRGB },
+		{ "R8G8_UNORM", ext::opengl::enums::Format::R8G8_UNORM },
+		{ "R8G8_SNORM", ext::opengl::enums::Format::R8G8_SNORM },
+		{ "R8G8_USCALED", ext::opengl::enums::Format::R8G8_USCALED },
+		{ "R8G8_SSCALED", ext::opengl::enums::Format::R8G8_SSCALED },
+		{ "R8G8_UINT", ext::opengl::enums::Format::R8G8_UINT },
+		{ "R8G8_SINT", ext::opengl::enums::Format::R8G8_SINT },
+		{ "R8G8_SRGB", ext::opengl::enums::Format::R8G8_SRGB },
+		{ "R8G8B8_UNORM", ext::opengl::enums::Format::R8G8B8_UNORM },
+		{ "R8G8B8_SNORM", ext::opengl::enums::Format::R8G8B8_SNORM },
+		{ "R8G8B8_USCALED", ext::opengl::enums::Format::R8G8B8_USCALED },
+		{ "R8G8B8_SSCALED", ext::opengl::enums::Format::R8G8B8_SSCALED },
+		{ "R8G8B8_UINT", ext::opengl::enums::Format::R8G8B8_UINT },
+		{ "R8G8B8_SINT", ext::opengl::enums::Format::R8G8B8_SINT },
+		{ "R8G8B8_SRGB", ext::opengl::enums::Format::R8G8B8_SRGB },
+		{ "B8G8R8_UNORM", ext::opengl::enums::Format::B8G8R8_UNORM },
+		{ "B8G8R8_SNORM", ext::opengl::enums::Format::B8G8R8_SNORM },
+		{ "B8G8R8_USCALED", ext::opengl::enums::Format::B8G8R8_USCALED },
+		{ "B8G8R8_SSCALED", ext::opengl::enums::Format::B8G8R8_SSCALED },
+		{ "B8G8R8_UINT", ext::opengl::enums::Format::B8G8R8_UINT },
+		{ "B8G8R8_SINT", ext::opengl::enums::Format::B8G8R8_SINT },
+		{ "B8G8R8_SRGB", ext::opengl::enums::Format::B8G8R8_SRGB },
+		{ "R8G8B8A8_UNORM", ext::opengl::enums::Format::R8G8B8A8_UNORM },
+		{ "R8G8B8A8_SNORM", ext::opengl::enums::Format::R8G8B8A8_SNORM },
+		{ "R8G8B8A8_USCALED", ext::opengl::enums::Format::R8G8B8A8_USCALED },
+		{ "R8G8B8A8_SSCALED", ext::opengl::enums::Format::R8G8B8A8_SSCALED },
+		{ "R8G8B8A8_UINT", ext::opengl::enums::Format::R8G8B8A8_UINT },
+		{ "R8G8B8A8_SINT", ext::opengl::enums::Format::R8G8B8A8_SINT },
+		{ "R8G8B8A8_SRGB", ext::opengl::enums::Format::R8G8B8A8_SRGB },
+		{ "B8G8R8A8_UNORM", ext::opengl::enums::Format::B8G8R8A8_UNORM },
+		{ "B8G8R8A8_SNORM", ext::opengl::enums::Format::B8G8R8A8_SNORM },
+		{ "B8G8R8A8_USCALED", ext::opengl::enums::Format::B8G8R8A8_USCALED },
+		{ "B8G8R8A8_SSCALED", ext::opengl::enums::Format::B8G8R8A8_SSCALED },
+		{ "B8G8R8A8_UINT", ext::opengl::enums::Format::B8G8R8A8_UINT },
+		{ "B8G8R8A8_SINT", ext::opengl::enums::Format::B8G8R8A8_SINT },
+		{ "B8G8R8A8_SRGB", ext::opengl::enums::Format::B8G8R8A8_SRGB },
+		{ "A8B8G8R8_UNORM_PACK32", ext::opengl::enums::Format::A8B8G8R8_UNORM_PACK32 },
+		{ "A8B8G8R8_SNORM_PACK32", ext::opengl::enums::Format::A8B8G8R8_SNORM_PACK32 },
+		{ "A8B8G8R8_USCALED_PACK32", ext::opengl::enums::Format::A8B8G8R8_USCALED_PACK32 },
+		{ "A8B8G8R8_SSCALED_PACK32", ext::opengl::enums::Format::A8B8G8R8_SSCALED_PACK32 },
+		{ "A8B8G8R8_UINT_PACK32", ext::opengl::enums::Format::A8B8G8R8_UINT_PACK32 },
+		{ "A8B8G8R8_SINT_PACK32", ext::opengl::enums::Format::A8B8G8R8_SINT_PACK32 },
+		{ "A8B8G8R8_SRGB_PACK32", ext::opengl::enums::Format::A8B8G8R8_SRGB_PACK32 },
+		{ "A2R10G10B10_UNORM_PACK32", ext::opengl::enums::Format::A2R10G10B10_UNORM_PACK32 },
+		{ "A2R10G10B10_SNORM_PACK32", ext::opengl::enums::Format::A2R10G10B10_SNORM_PACK32 },
+		{ "A2R10G10B10_USCALED_PACK32", ext::opengl::enums::Format::A2R10G10B10_USCALED_PACK32 },
+		{ "A2R10G10B10_SSCALED_PACK32", ext::opengl::enums::Format::A2R10G10B10_SSCALED_PACK32 },
+		{ "A2R10G10B10_UINT_PACK32", ext::opengl::enums::Format::A2R10G10B10_UINT_PACK32 },
+		{ "A2R10G10B10_SINT_PACK32", ext::opengl::enums::Format::A2R10G10B10_SINT_PACK32 },
+		{ "A2B10G10R10_UNORM_PACK32", ext::opengl::enums::Format::A2B10G10R10_UNORM_PACK32 },
+		{ "A2B10G10R10_SNORM_PACK32", ext::opengl::enums::Format::A2B10G10R10_SNORM_PACK32 },
+		{ "A2B10G10R10_USCALED_PACK32", ext::opengl::enums::Format::A2B10G10R10_USCALED_PACK32 },
+		{ "A2B10G10R10_SSCALED_PACK32", ext::opengl::enums::Format::A2B10G10R10_SSCALED_PACK32 },
+		{ "A2B10G10R10_UINT_PACK32", ext::opengl::enums::Format::A2B10G10R10_UINT_PACK32 },
+		{ "A2B10G10R10_SINT_PACK32", ext::opengl::enums::Format::A2B10G10R10_SINT_PACK32 },
+		{ "R16_UNORM", ext::opengl::enums::Format::R16_UNORM },
+		{ "R16_SNORM", ext::opengl::enums::Format::R16_SNORM },
+		{ "R16_USCALED", ext::opengl::enums::Format::R16_USCALED },
+		{ "R16_SSCALED", ext::opengl::enums::Format::R16_SSCALED },
+		{ "R16_UINT", ext::opengl::enums::Format::R16_UINT },
+		{ "R16_SINT", ext::opengl::enums::Format::R16_SINT },
+		{ "R16_SFLOAT", ext::opengl::enums::Format::R16_SFLOAT },
+		{ "R16G16_UNORM", ext::opengl::enums::Format::R16G16_UNORM },
+		{ "R16G16_SNORM", ext::opengl::enums::Format::R16G16_SNORM },
+		{ "R16G16_USCALED", ext::opengl::enums::Format::R16G16_USCALED },
+		{ "R16G16_SSCALED", ext::opengl::enums::Format::R16G16_SSCALED },
+		{ "R16G16_UINT", ext::opengl::enums::Format::R16G16_UINT },
+		{ "R16G16_SINT", ext::opengl::enums::Format::R16G16_SINT },
+		{ "R16G16_SFLOAT", ext::opengl::enums::Format::R16G16_SFLOAT },
+		{ "R16G16B16_UNORM", ext::opengl::enums::Format::R16G16B16_UNORM },
+		{ "R16G16B16_SNORM", ext::opengl::enums::Format::R16G16B16_SNORM },
+		{ "R16G16B16_USCALED", ext::opengl::enums::Format::R16G16B16_USCALED },
+		{ "R16G16B16_SSCALED", ext::opengl::enums::Format::R16G16B16_SSCALED },
+		{ "R16G16B16_UINT", ext::opengl::enums::Format::R16G16B16_UINT },
+		{ "R16G16B16_SINT", ext::opengl::enums::Format::R16G16B16_SINT },
+		{ "R16G16B16_SFLOAT", ext::opengl::enums::Format::R16G16B16_SFLOAT },
+		{ "R16G16B16A16_UNORM", ext::opengl::enums::Format::R16G16B16A16_UNORM },
+		{ "R16G16B16A16_SNORM", ext::opengl::enums::Format::R16G16B16A16_SNORM },
+		{ "R16G16B16A16_USCALED", ext::opengl::enums::Format::R16G16B16A16_USCALED },
+		{ "R16G16B16A16_SSCALED", ext::opengl::enums::Format::R16G16B16A16_SSCALED },
+		{ "R16G16B16A16_UINT", ext::opengl::enums::Format::R16G16B16A16_UINT },
+		{ "R16G16B16A16_SINT", ext::opengl::enums::Format::R16G16B16A16_SINT },
+		{ "R16G16B16A16_SFLOAT", ext::opengl::enums::Format::R16G16B16A16_SFLOAT },
+		{ "R32_UINT", ext::opengl::enums::Format::R32_UINT },
+		{ "R32_SINT", ext::opengl::enums::Format::R32_SINT },
+		{ "R32_SFLOAT", ext::opengl::enums::Format::R32_SFLOAT },
+		{ "R32G32_UINT", ext::opengl::enums::Format::R32G32_UINT },
+		{ "R32G32_SINT", ext::opengl::enums::Format::R32G32_SINT },
+		{ "R32G32_SFLOAT", ext::opengl::enums::Format::R32G32_SFLOAT },
+		{ "R32G32B32_UINT", ext::opengl::enums::Format::R32G32B32_UINT },
+		{ "R32G32B32_SINT", ext::opengl::enums::Format::R32G32B32_SINT },
+		{ "R32G32B32_SFLOAT", ext::opengl::enums::Format::R32G32B32_SFLOAT },
+		{ "R32G32B32A32_UINT", ext::opengl::enums::Format::R32G32B32A32_UINT },
+		{ "R32G32B32A32_SINT", ext::opengl::enums::Format::R32G32B32A32_SINT },
+		{ "R32G32B32A32_SFLOAT", ext::opengl::enums::Format::R32G32B32A32_SFLOAT },
+		{ "R64_UINT", ext::opengl::enums::Format::R64_UINT },
+		{ "R64_SINT", ext::opengl::enums::Format::R64_SINT },
+		{ "R64_SFLOAT", ext::opengl::enums::Format::R64_SFLOAT },
+		{ "R64G64_UINT", ext::opengl::enums::Format::R64G64_UINT },
+		{ "R64G64_SINT", ext::opengl::enums::Format::R64G64_SINT },
+		{ "R64G64_SFLOAT", ext::opengl::enums::Format::R64G64_SFLOAT },
+		{ "R64G64B64_UINT", ext::opengl::enums::Format::R64G64B64_UINT },
+		{ "R64G64B64_SINT", ext::opengl::enums::Format::R64G64B64_SINT },
+		{ "R64G64B64_SFLOAT", ext::opengl::enums::Format::R64G64B64_SFLOAT },
+		{ "R64G64B64A64_UINT", ext::opengl::enums::Format::R64G64B64A64_UINT },
+		{ "R64G64B64A64_SINT", ext::opengl::enums::Format::R64G64B64A64_SINT },
+		{ "R64G64B64A64_SFLOAT", ext::opengl::enums::Format::R64G64B64A64_SFLOAT },
+		{ "B10G11R11_UFLOAT_PACK32", ext::opengl::enums::Format::B10G11R11_UFLOAT_PACK32 },
+		{ "E5B9G9R9_UFLOAT_PACK32", ext::opengl::enums::Format::E5B9G9R9_UFLOAT_PACK32 },
+		{ "D16_UNORM", ext::opengl::enums::Format::D16_UNORM },
+		{ "X8_D24_UNORM_PACK32", ext::opengl::enums::Format::X8_D24_UNORM_PACK32 },
+		{ "D32_SFLOAT", ext::opengl::enums::Format::D32_SFLOAT },
+		{ "S8_UINT", ext::opengl::enums::Format::S8_UINT },
+		{ "D16_UNORM_S8_UINT", ext::opengl::enums::Format::D16_UNORM_S8_UINT },
+		{ "D24_UNORM_S8_UINT", ext::opengl::enums::Format::D24_UNORM_S8_UINT },
+		{ "D32_SFLOAT_S8_UINT", ext::opengl::enums::Format::D32_SFLOAT_S8_UINT },
+		{ "BC1_RGB_UNORM_BLOCK", ext::opengl::enums::Format::BC1_RGB_UNORM_BLOCK },
+		{ "BC1_RGB_SRGB_BLOCK", ext::opengl::enums::Format::BC1_RGB_SRGB_BLOCK },
+		{ "BC1_RGBA_UNORM_BLOCK", ext::opengl::enums::Format::BC1_RGBA_UNORM_BLOCK },
+		{ "BC1_RGBA_SRGB_BLOCK", ext::opengl::enums::Format::BC1_RGBA_SRGB_BLOCK },
+		{ "BC2_UNORM_BLOCK", ext::opengl::enums::Format::BC2_UNORM_BLOCK },
+		{ "BC2_SRGB_BLOCK", ext::opengl::enums::Format::BC2_SRGB_BLOCK },
+		{ "BC3_UNORM_BLOCK", ext::opengl::enums::Format::BC3_UNORM_BLOCK },
+		{ "BC3_SRGB_BLOCK", ext::opengl::enums::Format::BC3_SRGB_BLOCK },
+		{ "BC4_UNORM_BLOCK", ext::opengl::enums::Format::BC4_UNORM_BLOCK },
+		{ "BC4_SNORM_BLOCK", ext::opengl::enums::Format::BC4_SNORM_BLOCK },
+		{ "BC5_UNORM_BLOCK", ext::opengl::enums::Format::BC5_UNORM_BLOCK },
+		{ "BC5_SNORM_BLOCK", ext::opengl::enums::Format::BC5_SNORM_BLOCK },
+		{ "BC6H_UFLOAT_BLOCK", ext::opengl::enums::Format::BC6H_UFLOAT_BLOCK },
+		{ "BC6H_SFLOAT_BLOCK", ext::opengl::enums::Format::BC6H_SFLOAT_BLOCK },
+		{ "BC7_UNORM_BLOCK", ext::opengl::enums::Format::BC7_UNORM_BLOCK },
+		{ "BC7_SRGB_BLOCK", ext::opengl::enums::Format::BC7_SRGB_BLOCK },
+		{ "ETC2_R8G8B8_UNORM_BLOCK", ext::opengl::enums::Format::ETC2_R8G8B8_UNORM_BLOCK },
+		{ "ETC2_R8G8B8_SRGB_BLOCK", ext::opengl::enums::Format::ETC2_R8G8B8_SRGB_BLOCK },
+		{ "ETC2_R8G8B8A1_UNORM_BLOCK", ext::opengl::enums::Format::ETC2_R8G8B8A1_UNORM_BLOCK },
+		{ "ETC2_R8G8B8A1_SRGB_BLOCK", ext::opengl::enums::Format::ETC2_R8G8B8A1_SRGB_BLOCK },
+		{ "ETC2_R8G8B8A8_UNORM_BLOCK", ext::opengl::enums::Format::ETC2_R8G8B8A8_UNORM_BLOCK },
+		{ "ETC2_R8G8B8A8_SRGB_BLOCK", ext::opengl::enums::Format::ETC2_R8G8B8A8_SRGB_BLOCK },
+		{ "EAC_R11_UNORM_BLOCK", ext::opengl::enums::Format::EAC_R11_UNORM_BLOCK },
+		{ "EAC_R11_SNORM_BLOCK", ext::opengl::enums::Format::EAC_R11_SNORM_BLOCK },
+		{ "EAC_R11G11_UNORM_BLOCK", ext::opengl::enums::Format::EAC_R11G11_UNORM_BLOCK },
+		{ "EAC_R11G11_SNORM_BLOCK", ext::opengl::enums::Format::EAC_R11G11_SNORM_BLOCK },
+		{ "ASTC_4x4_UNORM_BLOCK", ext::opengl::enums::Format::ASTC_4x4_UNORM_BLOCK },
+		{ "ASTC_4x4_SRGB_BLOCK", ext::opengl::enums::Format::ASTC_4x4_SRGB_BLOCK },
+		{ "ASTC_5x4_UNORM_BLOCK", ext::opengl::enums::Format::ASTC_5x4_UNORM_BLOCK },
+		{ "ASTC_5x4_SRGB_BLOCK", ext::opengl::enums::Format::ASTC_5x4_SRGB_BLOCK },
+		{ "ASTC_5x5_UNORM_BLOCK", ext::opengl::enums::Format::ASTC_5x5_UNORM_BLOCK },
+		{ "ASTC_5x5_SRGB_BLOCK", ext::opengl::enums::Format::ASTC_5x5_SRGB_BLOCK },
+		{ "ASTC_6x5_UNORM_BLOCK", ext::opengl::enums::Format::ASTC_6x5_UNORM_BLOCK },
+		{ "ASTC_6x5_SRGB_BLOCK", ext::opengl::enums::Format::ASTC_6x5_SRGB_BLOCK },
+		{ "ASTC_6x6_UNORM_BLOCK", ext::opengl::enums::Format::ASTC_6x6_UNORM_BLOCK },
+		{ "ASTC_6x6_SRGB_BLOCK", ext::opengl::enums::Format::ASTC_6x6_SRGB_BLOCK },
+		{ "ASTC_8x5_UNORM_BLOCK", ext::opengl::enums::Format::ASTC_8x5_UNORM_BLOCK },
+		{ "ASTC_8x5_SRGB_BLOCK", ext::opengl::enums::Format::ASTC_8x5_SRGB_BLOCK },
+		{ "ASTC_8x6_UNORM_BLOCK", ext::opengl::enums::Format::ASTC_8x6_UNORM_BLOCK },
+		{ "ASTC_8x6_SRGB_BLOCK", ext::opengl::enums::Format::ASTC_8x6_SRGB_BLOCK },
+		{ "ASTC_8x8_UNORM_BLOCK", ext::opengl::enums::Format::ASTC_8x8_UNORM_BLOCK },
+		{ "ASTC_8x8_SRGB_BLOCK", ext::opengl::enums::Format::ASTC_8x8_SRGB_BLOCK },
+		{ "ASTC_10x5_UNORM_BLOCK", ext::opengl::enums::Format::ASTC_10x5_UNORM_BLOCK },
+		{ "ASTC_10x5_SRGB_BLOCK", ext::opengl::enums::Format::ASTC_10x5_SRGB_BLOCK },
+		{ "ASTC_10x6_UNORM_BLOCK", ext::opengl::enums::Format::ASTC_10x6_UNORM_BLOCK },
+		{ "ASTC_10x6_SRGB_BLOCK", ext::opengl::enums::Format::ASTC_10x6_SRGB_BLOCK },
+		{ "ASTC_10x8_UNORM_BLOCK", ext::opengl::enums::Format::ASTC_10x8_UNORM_BLOCK },
+		{ "ASTC_10x8_SRGB_BLOCK", ext::opengl::enums::Format::ASTC_10x8_SRGB_BLOCK },
+		{ "ASTC_10x10_UNORM_BLOCK", ext::opengl::enums::Format::ASTC_10x10_UNORM_BLOCK },
+		{ "ASTC_10x10_SRGB_BLOCK", ext::opengl::enums::Format::ASTC_10x10_SRGB_BLOCK },
+		{ "ASTC_12x10_UNORM_BLOCK", ext::opengl::enums::Format::ASTC_12x10_UNORM_BLOCK },
+		{ "ASTC_12x10_SRGB_BLOCK", ext::opengl::enums::Format::ASTC_12x10_SRGB_BLOCK },
+		{ "ASTC_12x12_UNORM_BLOCK", ext::opengl::enums::Format::ASTC_12x12_UNORM_BLOCK },
+		{ "ASTC_12x12_SRGB_BLOCK", ext::opengl::enums::Format::ASTC_12x12_SRGB_BLOCK }
+	};
+	return table[string];
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/opengl/rendermode.cpp b/engine/src/ext/opengl/rendermode.cpp
new file mode 100644
index 00000000..a16eadf6
--- /dev/null
+++ b/engine/src/ext/opengl/rendermode.cpp
@@ -0,0 +1,165 @@
+#if UF_USE_OPENGL
+
+#include <uf/ext/opengl/opengl.h>
+#include <uf/ext/opengl/rendermode.h>
+#include <uf/ext/opengl/initializers.h>
+#include <uf/ext/opengl/graphic.h>
+#include <uf/utils/window/window.h>
+
+#include <uf/ext/opengl/rendertarget.h>
+#include <uf/utils/graphic/graphic.h>
+#include <uf/utils/serialize/serializer.h>
+#include <uf/engine/scene/scene.h>
+#include <uf/utils/math/transform.h>
+#include <uf/utils/camera/camera.h>
+
+#include <uf/ext/openvr/openvr.h>
+
+ext::opengl::RenderMode::~RenderMode() {
+	this->destroy();
+}
+const std::string ext::opengl::RenderMode::getType() const {
+	return "";
+}
+const std::string ext::opengl::RenderMode::getName() const {
+	auto& metadata = *const_cast<uf::Serializer*>(&this->metadata);
+	return metadata["name"].as<std::string>();
+}
+ext::opengl::RenderTarget& ext::opengl::RenderMode::getRenderTarget( size_t i ) {
+	return renderTarget;
+}
+const ext::opengl::RenderTarget& ext::opengl::RenderMode::getRenderTarget( size_t i ) const {
+	return renderTarget;
+}
+
+const size_t ext::opengl::RenderMode::blitters() const {
+	return 0;
+}
+ext::opengl::Graphic* ext::opengl::RenderMode::getBlitter( size_t i ) {
+	return NULL;
+}
+std::vector<ext::opengl::Graphic*> ext::opengl::RenderMode::getBlitters() {
+	return {};
+}
+
+ext::opengl::GraphicDescriptor ext::opengl::RenderMode::bindGraphicDescriptor( const ext::opengl::GraphicDescriptor& reference, size_t pass ) {
+	ext::opengl::GraphicDescriptor descriptor = reference;
+	descriptor.renderMode = this->getName();
+	descriptor.subpass = pass;
+	descriptor.parse( metadata );
+	return descriptor;
+}
+void ext::opengl::RenderMode::bindGraphicPushConstants( ext::opengl::Graphic* pointer, size_t pass ) {
+}
+
+void ext::opengl::RenderMode::createCommandBuffers() {
+	this->execute = true;
+
+	std::vector<ext::opengl::Graphic*> graphics;
+	for ( uf::Scene* scene : uf::scene::scenes ) {
+		if ( !scene ) continue;
+		scene->process([&]( uf::Entity* entity ) {
+			if ( !entity->hasComponent<uf::Graphic>() ) return;
+			ext::opengl::Graphic& graphic = entity->getComponent<uf::Graphic>();
+			if ( !graphic.initialized || !graphic.process ) return;
+			graphics.push_back(&graphic);
+		});
+	}
+
+	this->synchronize();
+//	bindPipelines( graphics );
+	createCommandBuffers( graphics );
+	this->mostRecentCommandPoolId = std::this_thread::get_id();
+	this->rebuild = false;
+}
+ext::opengl::CommandBuffer& ext::opengl::RenderMode::getCommands() {
+	return getCommands( std::this_thread::get_id() );
+}
+ext::opengl::CommandBuffer& ext::opengl::RenderMode::getCommands( std::thread::id id ) {
+	bool exists = this->commands.has(id); //this->commands.count(id) > 0;
+	auto& commands = this->commands.get(id); //this->commands[id];
+	if ( !exists ) {
+		commands.initialize( *device );
+	}
+	return commands;
+}
+void ext::opengl::RenderMode::createCommandBuffers( const std::vector<ext::opengl::Graphic*>& graphics ) {
+
+}
+void ext::opengl::RenderMode::bindPipelines() {
+	this->execute = true;
+
+	std::vector<ext::opengl::Graphic*> graphics;
+	for ( uf::Scene* scene : uf::scene::scenes ) {
+		if ( !scene ) continue;
+		scene->process([&]( uf::Entity* entity ) {
+			if ( !entity->hasComponent<uf::Graphic>() ) return;
+			ext::opengl::Graphic& graphic = entity->getComponent<uf::Graphic>();
+			if ( !graphic.initialized ) return;
+			if ( !graphic.process ) return;
+			graphics.push_back(&graphic);
+		});
+	}
+
+	this->synchronize();
+	this->bindPipelines( graphics );
+}
+void ext::opengl::RenderMode::bindPipelines( const std::vector<ext::opengl::Graphic*>& graphics ) {
+	for ( auto* pointer : graphics ) {
+		auto& graphic = *pointer;
+		for ( size_t currentPass = 0; currentPass < renderTarget.passes.size(); ++currentPass ) {
+			auto& subpass = renderTarget.passes[currentPass];
+			if ( !subpass.autoBuildPipeline ) continue;
+			// bind to this render mode
+			ext::opengl::GraphicDescriptor descriptor = bindGraphicDescriptor(graphic.descriptor, currentPass);
+			// ignore if pipeline exists for this render mode
+			if ( graphic.hasPipeline( descriptor ) ) continue;
+			graphic.initializePipeline( descriptor );
+		}
+	}
+}
+
+void ext::opengl::RenderMode::render() {
+	auto& commands = getCommands(this->mostRecentCommandPoolId);
+	commands.submit();
+#if UF_ENV_DREAMCAST
+	#if UF_USE_OPENGL_GLDC
+		glKosSwapBuffers();
+	#else
+		glutSwapBuffers();
+	#endif
+#else
+	if ( device ) {
+		device->activateContext().display();
+	}
+#endif
+}
+
+void ext::opengl::RenderMode::initialize( Device& device ) {
+	this->device = &device;
+
+	// this->width = 0; //ext::opengl::width;
+	// this->height = 0; //ext::opengl::height;
+	{
+		if ( this->width > 0 ) renderTarget.width = this->width;
+		if ( this->height > 0 ) renderTarget.height = this->height;
+	}
+}
+
+void ext::opengl::RenderMode::tick() {
+	this->synchronize();
+}
+
+void ext::opengl::RenderMode::destroy() {
+	this->synchronize();
+	for ( auto& pair : this->commands.container() ) {
+		pair.second.flush();
+	}
+	renderTarget.destroy();
+}
+void ext::opengl::RenderMode::synchronize( uint64_t timeout ) {
+}
+void ext::opengl::RenderMode::pipelineBarrier( GLhandle(VkCommandBuffer) command, uint8_t stage ) {
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/opengl/rendermodes/base.cpp b/engine/src/ext/opengl/rendermodes/base.cpp
new file mode 100644
index 00000000..b000101e
--- /dev/null
+++ b/engine/src/ext/opengl/rendermodes/base.cpp
@@ -0,0 +1,95 @@
+#if UF_USE_OPENGL
+
+#include <uf/ext/opengl/opengl.h>
+#include <uf/ext/opengl/rendermodes/base.h>
+#include <uf/ext/opengl/initializers.h>
+#include <uf/utils/window/window.h>
+#include <uf/ext/opengl/graphic.h>
+#include <uf/ext/opengl/rendertarget.h>
+#include <uf/utils/graphic/graphic.h>
+#include <uf/utils/camera/camera.h>
+
+const std::string ext::opengl::BaseRenderMode::getType() const {
+	return "Swapchain";
+}
+void ext::opengl::BaseRenderMode::createCommandBuffers( const std::vector<ext::opengl::Graphic*>& graphics ) {
+	float width = this->width > 0 ? this->width : ext::opengl::settings::width;
+	float height = this->height > 0 ? this->height : ext::opengl::settings::height;
+
+	auto& scene = uf::scene::getCurrentScene();
+	auto& sceneMetadata = scene.getComponent<uf::Serializer>();
+
+	size_t currentSubpass = 0;
+	size_t currentPass = 0;
+	size_t currentDraw = 0;
+	auto& commands = getCommands();
+	commands.start(); {
+		CommandBuffer::InfoClear clearCommandInfo = {};
+		clearCommandInfo.type = enums::Command::CLEAR;
+		clearCommandInfo.color = {1.0f, 0.0f, 1.0f, 0.0f};
+		clearCommandInfo.depth = uf::Camera::USE_REVERSE_INFINITE_PROJECTION ? 0.0f : 1.0f;
+		clearCommandInfo.bits = GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT;
+		if ( !ext::json::isNull( sceneMetadata["system"]["renderer"]["clear values"][0] ) ) {
+			clearCommandInfo.color = uf::vector::decode( sceneMetadata["system"]["renderer"]["clear values"][0], pod::Vector4f{} );
+		}
+		if ( !ext::json::isNull( sceneMetadata["light"]["ambient"] ) ) {
+			clearCommandInfo.color = uf::vector::decode( sceneMetadata["light"]["ambient"], pod::Vector3f{} );
+		}
+		commands.record(clearCommandInfo);
+
+		CommandBuffer::InfoViewport viewportCommandInfo = {};
+		viewportCommandInfo.type = enums::Command::VIEWPORT;
+		viewportCommandInfo.corner = pod::Vector2ui{0, 0};
+		viewportCommandInfo.size = pod::Vector2ui{width, height};
+		commands.record(viewportCommandInfo);
+		for ( auto graphic : graphics ) {
+			if ( graphic->descriptor.renderMode != "" ) continue;
+			GraphicDescriptor descriptor = bindGraphicDescriptor(graphic->descriptor, currentSubpass );
+			graphic->record( commands, descriptor, currentPass, currentDraw++ );
+		}
+	} commands.end();
+}
+
+void ext::opengl::BaseRenderMode::initialize( Device& device ) {
+	this->metadata["name"] = "Swapchain";
+	auto windowSize = device.window->getSize();
+	this->width = windowSize.x;
+	this->height = windowSize.y;
+
+	if ( uf::Camera::USE_REVERSE_INFINITE_PROJECTION ) {
+		GL_ERROR_CHECK(glDepthFunc(GL_GEQUAL));
+		#if !UF_ENV_DREAMCAST || (UF_ENV_DREAMCAST && UF_USE_OPENGL_GLDC)
+			glDepthRange(0, 1);
+		#endif
+	} else {
+		GL_ERROR_CHECK(glDepthFunc(GL_LESS));
+	}
+	GL_ERROR_CHECK(glEnable(GL_DEPTH_TEST));
+	GL_ERROR_CHECK(glShadeModel(GL_SMOOTH));
+	GL_ERROR_CHECK(glEnable(GL_TEXTURE_2D));
+	GL_ERROR_CHECK(glEnable(GL_BLEND));
+	GL_ERROR_CHECK(glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
+
+	ext::opengl::RenderMode::initialize( device );
+}
+
+void ext::opengl::BaseRenderMode::tick() {
+	if ( ext::opengl::states::resized ) {
+		auto windowSize = device->window->getSize();
+		this->width = windowSize.x;
+		this->height = windowSize.y;
+		this->rebuild = true;
+	}
+	ext::opengl::RenderMode::tick();
+}
+void ext::opengl::BaseRenderMode::render() {
+//	if ( ext::opengl::renderModes.size() > 1 ) return;
+	if ( ext::opengl::renderModes.back() != this ) return;
+	ext::opengl::RenderMode::render();
+}
+
+void ext::opengl::BaseRenderMode::destroy() {
+	ext::opengl::RenderMode::destroy();
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/opengl/rendermodes/compute.cpp b/engine/src/ext/opengl/rendermodes/compute.cpp
new file mode 100644
index 00000000..48d765c2
--- /dev/null
+++ b/engine/src/ext/opengl/rendermodes/compute.cpp
@@ -0,0 +1,49 @@
+#if UF_USE_OPENGL
+
+#include <uf/ext/opengl/opengl.h>
+#include <uf/ext/opengl/rendermodes/compute.h>
+#include <uf/ext/opengl/rendermodes/deferred.h>
+#include <uf/ext/opengl/rendermodes/rendertarget.h>
+#include <uf/ext/opengl/initializers.h>
+#include <uf/ext/openvr/openvr.h>
+#include <uf/utils/window/window.h>
+#include <uf/utils/graphic/graphic.h>
+#include <uf/ext/opengl/graphic.h>
+#include <uf/engine/scene/scene.h>
+#include <uf/utils/camera/camera.h>
+#include <uf/utils/math/transform.h>
+
+#include <uf/ext/opengl/graphic.h>
+
+const std::string ext::opengl::ComputeRenderMode::getType() const {
+	return "Compute";
+}
+const size_t ext::opengl::ComputeRenderMode::blitters() const {
+	return 1;
+}
+ext::opengl::Graphic* ext::opengl::ComputeRenderMode::getBlitter( size_t i ) {
+	return &this->blitter;
+}
+std::vector<ext::opengl::Graphic*> ext::opengl::ComputeRenderMode::getBlitters() {
+	return { &this->blitter };
+}
+
+void ext::opengl::ComputeRenderMode::initialize( Device& device ) {
+	ext::opengl::RenderMode::initialize( device );
+}
+void ext::opengl::ComputeRenderMode::render() {
+}
+void ext::opengl::ComputeRenderMode::tick() {
+	ext::opengl::RenderMode::tick();
+}
+void ext::opengl::ComputeRenderMode::destroy() {
+	ext::opengl::RenderMode::destroy();
+}
+void ext::opengl::ComputeRenderMode::pipelineBarrier( GLhandle(VkCommandBuffer) commandBuffer, uint8_t state ) {
+}
+void ext::opengl::ComputeRenderMode::createCommandBuffers( ) {
+}
+void ext::opengl::ComputeRenderMode::bindPipelines() {
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/opengl/rendermodes/deferred.cpp b/engine/src/ext/opengl/rendermodes/deferred.cpp
new file mode 100644
index 00000000..5178dd03
--- /dev/null
+++ b/engine/src/ext/opengl/rendermodes/deferred.cpp
@@ -0,0 +1,70 @@
+#if UF_USE_OPENGL
+
+#include <uf/ext/opengl/opengl.h>
+#include <uf/ext/opengl/rendermodes/deferred.h>
+#include <uf/ext/opengl/rendermodes/rendertarget.h>
+#include <uf/ext/opengl/initializers.h>
+#include <uf/utils/window/window.h>
+#include <uf/utils/graphic/graphic.h>
+#include <uf/ext/opengl/graphic.h>
+#include <uf/engine/scene/scene.h>
+#include <uf/utils/camera/camera.h>
+#include <uf/utils/math/transform.h>
+
+#include <uf/ext/opengl/graphic.h>
+#include <uf/ext/gltf/graph.h>
+#include <uf/utils/camera/camera.h>
+
+const std::string ext::opengl::DeferredRenderMode::getType() const {
+	return "Deferred";
+}
+const size_t ext::opengl::DeferredRenderMode::blitters() const {
+	return 1;
+}
+ext::opengl::Graphic* ext::opengl::DeferredRenderMode::getBlitter( size_t i ) {
+	return &this->blitter;
+}
+std::vector<ext::opengl::Graphic*> ext::opengl::DeferredRenderMode::getBlitters() {
+	return { &this->blitter };
+}
+
+void ext::opengl::DeferredRenderMode::initialize( Device& device ) {
+	ext::opengl::RenderMode::initialize( device );
+}
+void ext::opengl::DeferredRenderMode::tick() {
+	ext::opengl::RenderMode::tick();
+}
+void ext::opengl::DeferredRenderMode::destroy() {
+	ext::opengl::RenderMode::destroy();
+}
+void ext::opengl::DeferredRenderMode::createCommandBuffers( const std::vector<ext::opengl::Graphic*>& graphics ) {
+	float width = this->width > 0 ? this->width : ext::opengl::settings::width;
+	float height = this->height > 0 ? this->height : ext::opengl::settings::height;
+	
+	auto& commands = getCommands();	
+	commands.start(); {
+		CommandBuffer::InfoClear clearCommandInfo = {};
+		clearCommandInfo.type = enums::Command::CLEAR;
+		clearCommandInfo.color = {0.0f, 0.0f, 0.0f, 0.0f};
+		clearCommandInfo.depth = uf::Camera::USE_REVERSE_INFINITE_PROJECTION ? 0.0f : 1.0f;
+		clearCommandInfo.bits = GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT;
+		commands.record(clearCommandInfo);
+
+		CommandBuffer::InfoViewport viewportCommandInfo = {};
+		viewportCommandInfo.type = enums::Command::VIEWPORT;
+		viewportCommandInfo.corner = pod::Vector2ui{0, 0};
+		viewportCommandInfo.size = pod::Vector2ui{width, height};
+		commands.record(viewportCommandInfo);
+		
+		size_t currentSubpass = 0;
+		size_t currentPass = 0;
+		size_t currentDraw = 0;
+		for ( auto graphic : graphics ) {
+			if ( graphic->descriptor.renderMode != this->getName() ) continue;
+			GraphicDescriptor descriptor = bindGraphicDescriptor(graphic->descriptor, currentSubpass);
+			graphic->record( commands, descriptor, currentPass, currentDraw++ );
+		}
+	} commands.end();
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/opengl/rendermodes/rendertarget.cpp b/engine/src/ext/opengl/rendermodes/rendertarget.cpp
new file mode 100644
index 00000000..b311fdf7
--- /dev/null
+++ b/engine/src/ext/opengl/rendermodes/rendertarget.cpp
@@ -0,0 +1,86 @@
+#if UF_USE_OPENGL
+
+#include <uf/ext/opengl/opengl.h>
+#include <uf/ext/opengl/rendermodes/rendertarget.h>
+#include <uf/ext/opengl/initializers.h>
+#include <uf/utils/window/window.h>
+#include <uf/utils/graphic/graphic.h>
+#include <uf/ext/opengl/graphic.h>
+#include <uf/utils/camera/camera.h>
+
+
+const std::string ext::opengl::RenderTargetRenderMode::getTarget() const {
+	auto& metadata = *const_cast<uf::Serializer*>(&this->metadata);
+	return metadata["target"].as<std::string>();
+}
+void ext::opengl::RenderTargetRenderMode::setTarget( const std::string& target ) {
+	this->metadata["target"] = target;
+}
+
+const std::string ext::opengl::RenderTargetRenderMode::getType() const {
+	return "RenderTarget";
+}
+const size_t ext::opengl::RenderTargetRenderMode::blitters() const {
+	return 1;
+}
+ext::opengl::Graphic* ext::opengl::RenderTargetRenderMode::getBlitter( size_t i ) {
+	return &this->blitter;
+}
+std::vector<ext::opengl::Graphic*> ext::opengl::RenderTargetRenderMode::getBlitters() {
+	return { &this->blitter };
+}
+
+ext::opengl::GraphicDescriptor ext::opengl::RenderTargetRenderMode::bindGraphicDescriptor( const ext::opengl::GraphicDescriptor& reference, size_t pass ) {
+	ext::opengl::GraphicDescriptor descriptor = ext::opengl::RenderMode::bindGraphicDescriptor(reference, pass);
+	descriptor.parse(metadata["descriptor"]);
+	std::string type = metadata["type"].as<std::string>();
+	return descriptor;
+}
+
+void ext::opengl::RenderTargetRenderMode::initialize( Device& device ) {
+	ext::opengl::RenderMode::initialize( device );
+}
+
+void ext::opengl::RenderTargetRenderMode::tick() {
+	ext::opengl::RenderMode::tick();
+}
+void ext::opengl::RenderTargetRenderMode::destroy() {
+	ext::opengl::RenderMode::destroy();
+	blitter.destroy();
+}
+void ext::opengl::RenderTargetRenderMode::render() {
+	auto& commands = getCommands( this->mostRecentCommandPoolId );
+}
+void ext::opengl::RenderTargetRenderMode::pipelineBarrier( GLhandle(VkCommandBuffer) commandBuffer, uint8_t state ) {
+}
+void ext::opengl::RenderTargetRenderMode::createCommandBuffers( const std::vector<ext::opengl::Graphic*>& graphics ) {
+	float width = this->width > 0 ? this->width : ext::opengl::settings::width;
+	float height = this->height > 0 ? this->height : ext::opengl::settings::height;
+	
+	auto& commands = getCommands();	
+	commands.start(); {
+		CommandBuffer::InfoClear clearCommandInfo = {};
+		clearCommandInfo.type = enums::Command::CLEAR;
+		clearCommandInfo.color = {0.0f, 0.0f, 0.0f, 0.0f};
+		clearCommandInfo.depth = uf::Camera::USE_REVERSE_INFINITE_PROJECTION ? 0.0f : 1.0f;
+		clearCommandInfo.bits = GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT;
+		commands.record(clearCommandInfo);
+		
+		CommandBuffer::InfoViewport viewportCommandInfo = {};
+		viewportCommandInfo.type = enums::Command::VIEWPORT;
+		viewportCommandInfo.corner = pod::Vector2ui{0, 0};
+		viewportCommandInfo.size = pod::Vector2ui{width, height};
+		commands.record(viewportCommandInfo);
+
+		size_t currentSubpass = 0;
+		size_t currentPass = 0;
+		size_t currentDraw = 0;
+		for ( auto graphic : graphics ) {
+			if ( graphic->descriptor.renderMode != this->getName() ) continue;
+			GraphicDescriptor descriptor = bindGraphicDescriptor(graphic->descriptor, currentSubpass);
+			graphic->record( commands, descriptor, currentPass, currentDraw++ );
+		}
+	} commands.end();
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/opengl/rendertarget.cpp b/engine/src/ext/opengl/rendertarget.cpp
new file mode 100644
index 00000000..44abad37
--- /dev/null
+++ b/engine/src/ext/opengl/rendertarget.cpp
@@ -0,0 +1,19 @@
+#if UF_USE_OPENGL
+
+#include <uf/ext/opengl/opengl.h>
+#include <uf/ext/opengl/rendertarget.h>
+#include <uf/ext/opengl/initializers.h>
+#include <uf/utils/window/window.h>
+
+void ext::opengl::RenderTarget::addPass( GLhandle(VkPipelineStageFlags) stage, GLhandle(VkAccessFlags) access, const std::vector<size_t>& colors, const std::vector<size_t>& inputs, const std::vector<size_t>& resolves, size_t depth, bool autoBuildPipeline ) {
+}
+size_t ext::opengl::RenderTarget::attach( const Attachment::Descriptor& descriptor, Attachment* attachment ) {
+	return attachments.size()-1;
+}
+void ext::opengl::RenderTarget::initialize( Device& device ) {
+}
+
+void ext::opengl::RenderTarget::destroy() {
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/opengl/swapchain.cpp b/engine/src/ext/opengl/swapchain.cpp
new file mode 100644
index 00000000..37a24851
--- /dev/null
+++ b/engine/src/ext/opengl/swapchain.cpp
@@ -0,0 +1,22 @@
+#if UF_USE_OPENGL
+
+#include <uf/ext/opengl/opengl.h>
+#include <uf/ext/opengl/swapchain.h>
+#include <uf/ext/opengl/initializers.h>
+#include <uf/utils/window/window.h>
+
+GLhandle(VkResult) ext::opengl::Swapchain::acquireNextImage( uint32_t* imageIndex, GLhandle(VkSemaphore) presentCompleteSemaphore ) {
+	return false;
+}
+
+GLhandle(VkResult) ext::opengl::Swapchain::queuePresent( GLhandle(VkQueue) queue, uint32_t imageIndex, GLhandle(VkSemaphore) waitSemaphore ) {
+	return false;
+}
+
+void ext::opengl::Swapchain::initialize( Device& device ) {
+}
+
+void ext::opengl::Swapchain::destroy() {
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/opengl/texture.cpp b/engine/src/ext/opengl/texture.cpp
new file mode 100644
index 00000000..2973fc20
--- /dev/null
+++ b/engine/src/ext/opengl/texture.cpp
@@ -0,0 +1,264 @@
+#if UF_USE_OPENGL
+
+#include <uf/ext/opengl/texture.h>
+#include <uf/ext/opengl/initializers.h>
+#include <uf/utils/image/image.h>
+#include <uf/ext/opengl/opengl.h>
+
+#include <cmath>
+
+ext::opengl::Texture2D ext::opengl::Texture2D::empty;
+
+void ext::opengl::Sampler::initialize( Device& device ) {
+}
+void ext::opengl::Sampler::destroy() {
+}
+
+void ext::opengl::Texture::initialize( Device& device, size_t width, size_t height, size_t depth, size_t layers ) {
+	this->device = &device;
+	this->width = width;
+	this->height = height;
+	this->depth = depth;
+	this->layers = layers;
+	// implicitly set type
+	if ( width > 1 && height > 1 && depth > 1 ) {
+		this->type = enums::Image::TYPE_3D;
+	} else if ( (width == 1 && height > 1 && depth > 1) || (width > 1 && height == 1 && depth > 1) || (width > 1 && height > 1 && depth == 1) ) {
+		this->type = enums::Image::TYPE_2D;
+	} else if ( (width > 1 && height == 1 && depth == 1) || (width == 1 && height > 1 && depth == 1) || (width == 1 && height == 1 && depth > 1) ) {
+		this->type = enums::Image::TYPE_1D;
+	}
+	if ( layers > 1 ) {
+		if ( viewType == enums::Image::VIEW_TYPE_1D ) viewType = enums::Image::VIEW_TYPE_1D_ARRAY;
+		if ( viewType == enums::Image::VIEW_TYPE_2D ) viewType = enums::Image::VIEW_TYPE_2D_ARRAY;
+		if ( viewType == enums::Image::VIEW_TYPE_CUBE ) viewType = enums::Image::VIEW_TYPE_CUBE_ARRAY;
+	}
+}
+void ext::opengl::Texture::initialize( Device& device, enums::Image::viewType_t viewType, size_t width, size_t height, size_t depth, size_t layers ) {
+	this->initialize( device, width, height, depth, layers );
+	this->viewType = viewType;
+	switch ( viewType ) {
+		case enums::Image::VIEW_TYPE_1D:
+		case enums::Image::VIEW_TYPE_1D_ARRAY:
+			type = enums::Image::TYPE_1D;
+		break;
+		case enums::Image::VIEW_TYPE_2D:
+		case enums::Image::VIEW_TYPE_CUBE:
+		case enums::Image::VIEW_TYPE_2D_ARRAY:
+		case enums::Image::VIEW_TYPE_CUBE_ARRAY: 
+			type = enums::Image::TYPE_2D;
+		break;
+		case enums::Image::VIEW_TYPE_3D:
+			type = enums::Image::TYPE_3D;
+		break;
+	}
+}
+void ext::opengl::Texture::updateDescriptors() {
+	descriptor.image = image;
+	descriptor.viewType = viewType;
+	descriptor.format = format;
+	descriptor.width = width;
+	descriptor.height = height;
+	descriptor.depth = depth;
+	descriptor.layers = layers;
+}
+bool ext::opengl::Texture::generated() const {
+	return glIsTexture(image);
+}
+void ext::opengl::Texture::destroy() {
+	if ( !device ) return;
+	if ( generated() ) GL_ERROR_CHECK(glDeleteTextures(1, &image));
+	image = GL_NULL_HANDLE;
+}
+void ext::opengl::Texture::loadFromFile(
+	const std::string& filename, 
+	enums::Format::type_t format
+) {
+	return loadFromFile( filename, ext::opengl::device, format );
+}
+void ext::opengl::Texture::loadFromImage(
+	uf::Image& image, 
+	enums::Format::type_t format
+) {
+	return loadFromImage( image, ext::opengl::device, format );
+}
+void ext::opengl::Texture::loadFromFile(
+	const std::string& filename, 
+	Device& device,
+	enums::Format::type_t format
+) {
+	uf::Image image;
+	image.open(filename);
+	return loadFromImage( image, device, format );
+}
+void ext::opengl::Texture::loadFromImage(
+	uf::Image& image, 
+	Device& device,
+	enums::Format::type_t format
+) {
+	switch ( image.getChannels() ) {
+		// R
+		case 1:
+			switch ( image.getBpp() ) {
+				case 8:
+					format = enums::Format::R8_UNORM;
+				break;
+				default:
+				UF_EXCEPTION("unsupported BPP of " + std::to_string(image.getBpp()));
+				break;
+			}
+		break;
+		// RGB
+		case 3:
+			switch ( image.getBpp() ) {
+				case 24:
+					format = enums::Format::R8G8B8_UNORM;
+				break;
+				default:
+				UF_EXCEPTION("unsupported BPP of " + std::to_string(image.getBpp()));
+				break;
+			}
+		break;
+		// RGBA
+		case 4:
+			switch ( image.getBpp() ) {
+				case 32:
+					format = enums::Format::R8G8B8A8_UNORM;
+				break;
+				default:
+				UF_EXCEPTION("unsupported BPP of " + std::to_string(image.getBpp()));
+				break;
+			}
+		break;
+		default:
+		UF_EXCEPTION("unsupported channels of " + std::to_string(image.getChannels()));
+		break;
+	}
+
+	// convert to power of two
+	//image.padToPowerOfTwo();
+
+	this->fromBuffers( 
+		(void*) image.getPixelsPtr(),
+		image.getPixels().size(),
+		format,
+		image.getDimensions()[0],
+		image.getDimensions()[1],
+		1,
+		1,
+		device
+	);
+}
+
+void ext::opengl::Texture::fromBuffers(
+	void* buffer,
+	size_t bufferSize,
+	enums::Format::type_t format,
+	uint32_t texWidth,
+	uint32_t texHeight,
+	uint32_t texDepth,
+	uint32_t layers
+) {
+	return this->fromBuffers( buffer, bufferSize, format, texWidth, texHeight, texDepth, layers, ext::opengl::device );
+}
+
+
+void ext::opengl::Texture::fromBuffers(
+	void* data,
+	size_t bufferSize,
+	enums::Format::type_t format,
+	uint32_t texWidth,
+	uint32_t texHeight,
+	uint32_t texDepth,
+	uint32_t layers,
+	Device& device
+) {
+	this->initialize(device, viewType, texWidth, texHeight, texDepth, layers);
+
+#if !UF_ENV_DREAMCAST
+	if ( this->mips == 0 ) {
+		this->mips = 1;
+	} else if ( this->depth == 1 ) {
+		this->mips = static_cast<uint32_t>(std::floor(std::log2(std::max(texWidth, texHeight)))) + 1;
+	}
+#endif
+	// Create sampler
+	sampler.descriptor.mip.min = 0;
+	sampler.descriptor.mip.max = static_cast<float>(this->mips);
+	sampler.initialize( device );
+	
+	device.activateContext();
+#if 0
+	device.createTexture(image);
+	this->updateDescriptors();
+	if ( data ) this->update( data, bufferSize, 0 );
+#else
+	GL_ERROR_CHECK(glGenTextures(1, &image));
+	GL_ERROR_CHECK(glBindTexture(viewType, image));
+	GL_ERROR_CHECK(glTexParameteri(viewType, GL_TEXTURE_MIN_FILTER, sampler.descriptor.filter.min));
+	GL_ERROR_CHECK(glTexParameteri(viewType, GL_TEXTURE_MAG_FILTER, sampler.descriptor.filter.mag));
+	GL_ERROR_CHECK(glBindTexture(viewType, 0));
+	if ( data ) this->update( data, bufferSize, 0 );
+	this->updateDescriptors();
+#endif
+}
+
+void ext::opengl::Texture::asRenderTarget( Device& device, uint32_t width, uint32_t height, enums::Format::type_t format ) {
+}
+void ext::opengl::Texture::aliasTexture( const Texture& texture ) {
+	image = texture.image;
+	type = texture.type;
+	viewType = texture.viewType;
+	format = texture.format;
+	sampler = texture.sampler;
+	width = texture.width;
+	height = texture.height;
+	depth = texture.depth;
+	layers = texture.layers;
+	
+	this->updateDescriptors();
+}
+void ext::opengl::Texture::aliasAttachment( const RenderTarget::Attachment& attachment, bool createSampler ) {
+}
+
+void ext::opengl::Texture::update( uf::Image& image, uint32_t layer ) {
+	return this->update( (void*) image.getPixelsPtr(), image.getPixels().size(), layer );
+}
+void ext::opengl::Texture::update( void* data, size_t bufferSize, uint32_t layer ) {
+	GLenum format = GL_RGBA;
+	GLenum type = GL_UNSIGNED_BYTE;
+	switch ( this->format ) {
+	#if !UF_ENV_DREAMCAST
+		case enums::Format::R8_UNORM: format = GL_RED;; break;
+		case enums::Format::R8G8_UNORM: format = GL_RG;; break;
+	#endif
+		case enums::Format::R8G8B8_UNORM: format = GL_RGB;; break;
+		case enums::Format::R8G8B8A8_UNORM: format = GL_RGBA;; break;
+	}
+	GL_ERROR_CHECK(glBindTexture(viewType, image));
+	switch ( viewType ) {
+		case enums::Image::VIEW_TYPE_2D: { GL_ERROR_CHECK(glTexImage2D(viewType, 0, format, width, height, 0, format, type, data)); } break;
+	#if !UF_ENV_DREAMCAST
+		case enums::Image::VIEW_TYPE_3D: { GL_ERROR_CHECK(glTexImage3D(viewType, 0, format, width, height, depth, 0, format, type, data)); } break;
+	#endif
+	}
+	GL_ERROR_CHECK(glBindTexture(viewType, 0));
+}
+
+void ext::opengl::Texture::generateMipmaps( uint32_t layer ) {
+}
+
+ext::opengl::Texture2D::Texture2D() {
+	type = enums::Image::TYPE_2D;
+	viewType = enums::Image::VIEW_TYPE_2D;
+}
+ext::opengl::Texture3D::Texture3D() {
+	type = enums::Image::TYPE_3D;
+	viewType = enums::Image::VIEW_TYPE_3D;
+}
+ext::opengl::TextureCube::TextureCube() {
+	type = enums::Image::TYPE_2D;
+	viewType = enums::Image::VIEW_TYPE_CUBE;
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/openvr/openvr.cpp b/engine/src/ext/openvr/openvr.cpp
new file mode 100644
index 00000000..2007ae58
--- /dev/null
+++ b/engine/src/ext/openvr/openvr.cpp
@@ -0,0 +1,729 @@
+#include <uf/ext/openvr/openvr.h>
+
+#if UF_USE_OPENVR
+#include <uf/utils/io/iostream.h>
+#include <uf/utils/string/ext.h>
+#include <uf/utils/string/io.h>
+#include <uf/utils/renderer/renderer.h>
+
+#include <stdlib.h>
+#define DEBUG_MARKER 0
+
+vr::IVRSystem* ext::openvr::context;
+ext::openvr::Driver ext::openvr::driver;
+uint8_t ext::openvr::renderPass = 0;
+float ext::openvr::width = 0;
+float ext::openvr::height = 0;
+bool ext::openvr::enabled = false;
+bool ext::openvr::swapEyes = false;
+uint8_t ext::openvr::dominantEye = 0;
+
+#define VR_CHECK_INPUT_RESULT(f)\
+	if ( f != vr::VRInputError_None ) {\
+		uf::iostream << __FILE__ << ":" << __FUNCTION__ << ":L" << __LINE__ << ": VR Error: " << vr::VR_GetVRInitErrorAsEnglishDescription(err) << "\n";\
+		return false;\
+	}
+
+// toPort
+namespace {
+	std::string GetTrackedDeviceString(vr::IVRSystem *pHmd, vr::TrackedDeviceIndex_t unDevice, vr::TrackedDeviceProperty prop, vr::TrackedPropertyError *peError = NULL) {
+		uint32_t requiredBufferLen = pHmd->GetStringTrackedDeviceProperty(unDevice, prop, NULL, 0, peError);
+		if( requiredBufferLen == 0 ) return "";
+
+		char *pchBuffer = new char[requiredBufferLen];
+		requiredBufferLen = pHmd->GetStringTrackedDeviceProperty(unDevice,prop,pchBuffer,requiredBufferLen,peError);
+		std::string sResult = pchBuffer;
+		delete[] pchBuffer;
+
+		return sResult;
+	}
+
+	std::string GetTrackedDeviceClassString(vr::ETrackedDeviceClass klass) {
+		std::string str = "Unknown class";
+
+		switch ( klass ) {
+			case vr::TrackedDeviceClass_Invalid:			// = 0, the ID was not valid.
+				str = "invalid";
+			break;
+			case vr::TrackedDeviceClass_HMD:				// = 1, Head-Mounted Displays
+				str = "hmd";
+			break;
+			case vr::TrackedDeviceClass_Controller:			// = 2, Tracked controllers
+				str = "controller";
+			break;
+			case vr::TrackedDeviceClass_GenericTracker:		// = 3, Generic trackers, similar to controllers
+				str = "generic tracker";
+			break;
+			case vr::TrackedDeviceClass_TrackingReference:	// = 4, Camera and base stations that serve as tracking reference points
+				str = "base station";
+			break;
+			case vr::TrackedDeviceClass_DisplayRedirect:	// = 5, Accessories that aren't necessarily tracked themselves, but may redirect video output from other tracked devices
+				str = "display redirect";
+			break;
+		}
+
+		return str;
+	}
+	struct {
+		struct {
+			pod::Matrix4t<> matrix;
+		} hmd;
+		struct {
+			struct {
+				uint32_t index;
+				bool active;
+				uf::Serializer state;
+				pod::Matrix4t<> matrix;
+				pod::Matrix4t<> tip;
+				uf::Graphic graphic;
+			} left, right;
+		} controllers;
+	} devices;
+
+	struct {
+		std::unordered_map<std::string, vr::VRActionHandle_t> actions;
+		std::unordered_map<std::string, vr::VRActionSetHandle_t> actionSets;
+	//	std::vector<vr::VRInputValueHandle_t> inputs;
+		std::vector<vr::VRActiveActionSet_t> activeActionSets;
+	} handles;
+
+	struct QueuedRenderModel {
+		vr::RenderModel_t* model;
+		vr::RenderModel_TextureMap_t* texture;
+	};
+	std::unordered_map<std::string, QueuedRenderModel> queuedRenderModels;
+	std::unordered_map<std::string, uf::Graphic> renderModels;
+	std::vector<std::string> renderModelNames;
+}
+
+bool ext::openvr::initialize( int stage ) {
+	if ( stage == 1 ) {
+		if ( !vr::VRCompositor() ) {
+			uf::iostream << "Error while initializing HMD: VRCompositor() failed" << "\n";
+			return false;
+		}
+		return true;
+	}
+	if ( !vr::VR_IsHmdPresent() ) {
+		uf::iostream << "Error while initializing HMD: not present" << "\n";
+		return false;
+	}
+	if ( !vr::VR_IsRuntimeInstalled() ) {
+		uf::iostream << "Error while initializing HMD: no runtime is installed" << "\n";
+		return false;
+	}
+	
+	int baseStations = 0;
+	// const char* runtime_path = vr::VR_GetRuntimePath();
+	vr::HmdError err;
+	ext::openvr::context = vr::VR_Init( &err, vr::EVRApplicationType::VRApplication_Scene );
+	if ( err != vr::VRInitError_None || ext::openvr::context == NULL ) {
+		uf::iostream << "Error while initializing SteamVR runtime: " << vr::VR_GetVRInitErrorAsEnglishDescription(err) << "\n";
+		return false;
+	}
+
+	// Get connected devices
+	for ( uint32_t i = vr::k_unTrackedDeviceIndex_Hmd; i < vr::k_unMaxTrackedDeviceCount; ++i ) {
+		if ( !ext::openvr::context->IsTrackedDeviceConnected(i) ) continue;
+		vr::ETrackedDeviceClass trackedDeviceClass = ext::openvr::context->GetTrackedDeviceClass(i);
+		std::string trackedDeviceType = ::GetTrackedDeviceClassString(trackedDeviceClass);
+		ext::openvr::driver.types[i] = trackedDeviceType;
+
+		uf::iostream << "Tracking device " << i << " is connected " << "\n";
+		uf::iostream << "  Device type: " << trackedDeviceType << ". Name: " << ::GetTrackedDeviceString(ext::openvr::context, i, vr::Prop_TrackingSystemName_String) << "\n";
+
+		if (trackedDeviceClass == vr::ETrackedDeviceClass::TrackedDeviceClass_TrackingReference)
+			++baseStations;
+		else if ( trackedDeviceClass == vr::ETrackedDeviceClass::TrackedDeviceClass_Controller ) {
+			vr::ETrackedControllerRole role = ext::openvr::context->GetControllerRoleForTrackedDeviceIndex(i);
+			if ( role == vr::TrackedControllerRole_LeftHand ) ::devices.controllers.left.index = i;
+			else if ( role == vr::TrackedControllerRole_RightHand ) ::devices.controllers.right.index = i;
+		}
+		if (i == vr::k_unTrackedDeviceIndex_Hmd) {
+			ext::openvr::driver.name = ::GetTrackedDeviceString(ext::openvr::context, i, vr::Prop_TrackingSystemName_String);
+			ext::openvr::driver.serial = ::GetTrackedDeviceString(ext::openvr::context, i, vr::Prop_SerialNumber_String);
+		}
+	}
+/*
+	// Get render models
+	driver.renderModels = (vr::IVRRenderModels*) vr::VR_GetGenericInterface( vr::IVRRenderModels_Version, &err );
+	if ( err != vr::VRInitError_None ) {
+		uf::iostream << "Error while retrieving render model interface: " << vr::VR_GetVRInitErrorAsEnglishDescription(err) << "\n";
+		return false;
+	}
+*/
+	uf::iostream << "HMD " << ext::openvr::driver.name << " " << ext::openvr::driver.serial << "\n";
+
+	// load manifest
+	{
+		VR_CHECK_INPUT_RESULT( vr::VRInput()->SetActionManifestPath( uf::io::absolute(ext::openvr::driver.manifest).c_str() ) );
+		// configure action handles
+		{
+			uf::Serializer manifest;
+			manifest.readFromFile(ext::openvr::driver.manifest);
+
+			if ( DEBUG_MARKER ) std::cout << ext::openvr::driver.manifest << std::endl;
+			for ( auto i = 0; i < manifest["action_sets"].size(); ++i ) {
+				if ( DEBUG_MARKER ) std::cout << manifest["action_sets"][i] << std::endl;
+				std::string name = manifest["action_sets"][i]["name"].as<std::string>();
+				vr::VRActionSetHandle_t handle;
+				VR_CHECK_INPUT_RESULT( vr::VRInput()->GetActionSetHandle( name.c_str(), &handle ) );
+				handles.actionSets[name] = handle;
+				if ( DEBUG_MARKER ) std::cout << "Registered action set: " << name << std::endl;
+				// handles.actionSets.push_back(handle);
+			}
+			for ( auto i = 0; i < manifest["actions"].size(); ++i ) {
+				std::string name = manifest["actions"][i]["name"].as<std::string>();
+				vr::VRActionHandle_t handle;
+				VR_CHECK_INPUT_RESULT( vr::VRInput()->GetActionHandle( name.c_str(), &handle ) );
+				handles.actions[name] = handle;
+				if ( DEBUG_MARKER ) std::cout << "Registered action: " << name << std::endl;
+				// handles.actions.push_back(handle);
+
+				// add haptics to hooks
+				{
+					std::vector<std::string> split = uf::string::split( name, "/" );
+					std::string shortname = split.back();
+					split = uf::string::split( shortname, "." );
+					if ( split.front() == "hapticVibration" ) {
+						if ( DEBUG_MARKER ) std::cout << "Registered hook for haptic: " << ("VR:Haptics."+split.back()) << std::endl;
+						uf::hooks.addHook( "VR:Haptics."+split.back(), [&](ext::json::Value& json){
+							if ( vr::VRInputError_None != vr::VRInput()->TriggerHapticVibrationAction( handle, json["delay"].as<float>(), json["duration"].as<float>(), json["frequency"].as<float>(), json["amplitude"].as<float>(), vr::k_ulInvalidInputValueHandle ) )
+								return;
+							return;
+						});
+					}
+				}
+			}
+		}
+	}
+
+	// load render models
+	{
+		size_t count = vr::VRRenderModels()->GetRenderModelCount();
+		::renderModelNames.reserve(count);
+		for ( size_t i = 0; i < count; ++i ) {
+			size_t strlen = vr::VRRenderModels()->GetRenderModelName( i, NULL, 0 );
+			char buffer[strlen];
+			vr::VRRenderModels()->GetRenderModelName( i, &buffer[0], strlen );
+			std::string name = buffer;
+			::renderModelNames.push_back( name );
+		}
+	}
+
+	uf::hooks.addHook( "VR:Seat.Reset", [&](ext::json::Value& json){
+		ext::openvr::resetPosition();
+	});
+
+	vr::VRCompositor()->WaitGetPoses(&driver.poses[0], vr::k_unMaxTrackedDeviceCount, nullptr, 0);
+	vr::VRCompositor()->SetExplicitTimingMode(vr::EVRCompositorTimingMode::VRCompositorTimingMode_Explicit_ApplicationPerformsPostPresentHandoff);
+
+	return true;
+}
+void ext::openvr::terminate() {
+//	::devices.controllers.left.graphic.destroy();
+//	::devices.controllers.right.graphic.destroy();
+	for ( auto pair : ::renderModels ) {
+		pair.second.destroy();
+	}
+
+	vr::VR_Shutdown();
+	ext::openvr::context = NULL;
+}
+void ext::openvr::resetPosition() {
+//	ext::openvr::context->ResetSeatedZeroPose();
+}
+void ext::openvr::tick() {
+	if ( !ext::openvr::context ) return;
+	
+	if ( DEBUG_MARKER ) std::cout << "OPENVR TICK" << std::endl;
+
+	// load render model from api
+	for ( auto& pair : ::queuedRenderModels ) {
+		if ( DEBUG_MARKER ) std::cout << "QUEUED: " << pair.first << std::endl;
+		std::string name = pair.first;
+		auto& queued = pair.second;
+		{
+			vr::EVRRenderModelError status = vr::VRRenderModels()->LoadRenderModel_Async( name.c_str(), &queued.model );
+			// wait for load
+			if ( status == vr::VRRenderModelError_Loading ) continue;
+			// error'd out
+			if ( status != vr::VRRenderModelError_None ) {
+				if ( DEBUG_MARKER ) std::cout << "Failed to load render model " << name << ": " << vr::VRRenderModels()->GetRenderModelErrorNameFromEnum( status ) << std::endl;
+				::queuedRenderModels.erase(name);
+				break;
+			}
+		}
+		// loaded, now to load texture
+		{
+			vr::EVRRenderModelError status = vr::VRRenderModels()->LoadTexture_Async( queued.model->diffuseTextureId, &queued.texture );
+			// wait for load
+			if ( status == vr::VRRenderModelError_Loading ) continue;
+			// error'd out
+			if ( status != vr::VRRenderModelError_None ) {
+				if ( DEBUG_MARKER ) std::cout << "Failed to load render model " << name << "'s texture: " << vr::VRRenderModels()->GetRenderModelErrorNameFromEnum( status ) << std::endl;
+				vr::VRRenderModels()->FreeRenderModel( queued.model );
+				::queuedRenderModels.erase(name);
+				break;
+			}
+		}
+		// loaded texture, process
+		{
+		//	uf::Mesh& mesh = renderModels[name];
+			uf::Graphic& graphic = renderModels[name];
+
+			uf::Mesh mesh;
+			mesh.vertices.reserve(queued.model->unVertexCount);
+			for ( size_t i = 0; i < queued.model->unVertexCount; ++i ) {
+				auto& v = queued.model->rVertexData[i];
+				
+				uf::Mesh::vertex_t vertex;
+				vertex.position = pod::Vector3f{ v.vPosition.v[0], v.vPosition.v[1], -v.vPosition.v[2] };
+				vertex.normal = pod::Vector3f{ v.vNormal.v[0], v.vNormal.v[1], v.vNormal.v[2] };
+				vertex.uv = pod::Vector2f{ v.rfTextureCoord[0], v.rfTextureCoord[1] };
+				
+				mesh.vertices.push_back(vertex);
+			}
+			mesh.indices.reserve(queued.model->unTriangleCount * 3);
+			for ( std::size_t i = 0; i < queued.model->unTriangleCount * 3; ++i ) {
+				mesh.indices.push_back( queued.model->rIndexData[i] );
+			}
+			// grab texture
+			size_t len = queued.texture->unWidth * queued.texture->unHeight * 4;
+			graphic.initialize();
+			graphic.initializeMesh(mesh);
+		
+			auto& texture = graphic.material.textures.emplace_back();
+			texture.fromBuffers( (void*) queued.texture->rubTextureMapData, len, uf::renderer::enums::Format::R8G8B8A8_UNORM, queued.texture->unWidth, queued.texture->unHeight );
+		}
+		// call hook
+		uf::Serializer payload;
+		payload["name"] = name;
+		uf::hooks.call( "VR:Model.Loaded", payload );
+		
+		// clear
+		{
+			if ( DEBUG_MARKER ) std::cout << "QUEUED MODEL: " << queued.model << std::endl;
+			if ( DEBUG_MARKER ) std::cout << "QUEUED TEXTURE: " << queued.texture << std::endl;
+			vr::VRRenderModels()->FreeRenderModel( queued.model );
+			vr::VRRenderModels()->FreeTexture( queued.texture );
+		}
+		{
+			if ( DEBUG_MARKER ) std::cout << "FINISHED LOADING: " << name << std::endl;
+			::queuedRenderModels.erase(name);
+			break;
+		}
+	}
+	// 
+
+	// Obtain tracking device poses
+	float fPredictedSecondsFromNow = ext::openvr::predictedTimeToDisplay();
+	// Parse actions
+	{
+		{
+			handles.activeActionSets.clear();
+			for ( auto pair : handles.actionSets ) {
+				vr::VRActiveActionSet_t actionSet = { 0 };
+				actionSet.ulActionSet = pair.second;
+				handles.activeActionSets.push_back(actionSet);
+			}
+		}
+		vr::VRInput()->UpdateActionState( handles.activeActionSets.data(), sizeof(vr::VRActiveActionSet_t), handles.activeActionSets.size() );
+		for ( auto pair : handles.actions ) {
+			std::string name = pair.first;
+			auto& handle = pair.second;
+			// analog data
+			{
+				vr::InputAnalogActionData_t data;
+				if ( vr::VRInputError_None == vr::VRInput()->GetAnalogActionData(handle, &data, sizeof(data), vr::k_ulInvalidInputValueHandle) ) {
+					float deltaTime = data.fUpdateTime;
+					pod::Vector3f delta = { data.deltaX, data.deltaY, data.deltaZ };
+					pod::Vector3f position = { data.x, data.y, data.z };
+					if ( data.bActive ) {
+						uf::Serializer payload;
+						std::vector<std::string> split = uf::string::split( name, "/" );
+						std::string shortname = split.back();
+						split = uf::string::split( shortname, "." );
+						
+						payload["name"] = split.front();
+						payload["hand"] = split.back();
+						payload["full name"] = name;
+						payload["deltaTime"] = deltaTime;
+						payload["analog"]["position"][0] = position.x;
+						payload["analog"]["position"][1] = position.y;
+						payload["analog"]["position"][2] = position.z;
+						payload["analog"]["delta"][0] = delta.x;
+						payload["analog"]["delta"][1] = delta.y;
+						payload["analog"]["delta"][2] = delta.z;
+						// store state
+						if ( split.back() == "left" ) ::devices.controllers.left.state[split.front()] = payload;
+						else if ( split.back() == "right" ) ::devices.controllers.right.state[split.front()] = payload;
+						// send payload only on deltas
+						if ( delta != pod::Vector3f{ 0, 0, 0 } ) uf::hooks.call( "VR:Input.Analog", payload );
+					}
+				}
+			}
+			// digital data
+			{
+				vr::InputDigitalActionData_t data;
+				if ( vr::VRInputError_None == vr::VRInput()->GetDigitalActionData(handle, &data, sizeof(data), vr::k_ulInvalidInputValueHandle) ) {
+					if ( data.bActive ) {
+						uf::Serializer payload;
+						std::vector<std::string> split = uf::string::split( name, "/" );
+						std::string shortname = split.back();
+						split = uf::string::split( shortname, "." );
+						
+						payload["name"] = split.front();
+						payload["hand"] = split.back();
+						payload["full name"] = name;
+						payload["deltaTime"] = data.fUpdateTime;
+						payload["state"] = data.bState;
+						// store state
+						if ( split.back() == "left" ) ::devices.controllers.left.state[split.front()] = payload;
+						else if ( split.back() == "right" ) ::devices.controllers.right.state[split.front()] = payload;
+						// send payload only on deltas
+						if ( data.bChanged ) uf::hooks.call( "VR:Input.Digital", payload );
+					}
+				}
+			}
+			// pose data
+			{
+				vr::InputPoseActionData_t data;
+				if ( vr::VRInputError_None == vr::VRInput()->GetPoseActionDataRelativeToNow(handle, vr::TrackingUniverseStanding,  fPredictedSecondsFromNow, &data, sizeof(data), vr::k_ulInvalidInputValueHandle) ) {
+					std::vector<std::string> split = uf::string::split( name, "/" );
+					std::string shortname = split.back();
+					split = uf::string::split( shortname, "." );
+					if ( split.front() == "handPose" ) {
+						if ( split.back() == "left" ) ::devices.controllers.left.active = data.bActive;
+						else if ( split.back() == "right" ) ::devices.controllers.right.active = data.bActive;
+					}
+					if ( data.bActive ) {
+						vr::HmdMatrix34_t mat = data.pose.mDeviceToAbsoluteTracking;
+						pod::Matrix4t<> res = {
+							mat.m[0][0], mat.m[1][0], mat.m[2][0], 0.0, 
+							mat.m[0][1], mat.m[1][1], mat.m[2][1], 0.0,
+							mat.m[0][2], mat.m[1][2], mat.m[2][2], 0.0,
+							mat.m[0][3], mat.m[1][3], mat.m[2][3], 1.0f
+						};
+						if ( split.back() == "left" ) {
+							if ( split.front() == "handPose" ) ::devices.controllers.left.matrix = res;
+							else if ( split.front() == "handTip" ) ::devices.controllers.left.tip = res;
+						}
+						else if ( split.back() == "right" ) {
+							if ( split.front() == "handPose" ) ::devices.controllers.right.matrix = res;
+							else if ( split.front() == "handTip" ) ::devices.controllers.right.tip = res;
+						}
+					}
+				}
+			}
+		}
+	}
+}
+bool ext::openvr::requestRenderModel( const std::string& name ) {
+	if ( DEBUG_MARKER ) std::cout << "Requesting render model: " << name << std::endl;
+	if ( std::find( renderModelNames.begin(), renderModelNames.end(), name ) == renderModelNames.end() ) return false;
+	if ( renderModels.count(name) == 1 ) return true;
+	::queuedRenderModels[name];
+	return false;	
+}
+void ext::openvr::submit() { bool invert = swapEyes;
+#if UF_USE_VULKAN
+	auto& renderMode = uf::renderer::getRenderMode("");
+	
+	float width = renderMode.width > 0 ? renderMode.width : uf::renderer::settings::width;
+	float height = renderMode.height > 0 ? renderMode.height : uf::renderer::settings::height;
+	auto& leftOutputAttachment = renderMode.renderTarget.attachments[renderMode.metadata["outputs"][0].as<size_t>()];
+	auto& rightOutputAttachment = renderMode.renderTarget.attachments[renderMode.metadata["outputs"][1].as<size_t>()];
+
+	// Submit to SteamVR
+	vr::VRTextureBounds_t bounds;
+	bounds.uMin = 0.0f;
+	bounds.uMax = 1.0f;
+	bounds.vMin = 0.0f;
+	bounds.vMax = 1.0f;
+
+	vr::VRVulkanTextureData_t vulkanData;
+	vulkanData.m_pDevice = ( VkDevice_T * ) uf::renderer::device;
+	vulkanData.m_pPhysicalDevice = ( VkPhysicalDevice_T * ) uf::renderer::device.physicalDevice;
+	vulkanData.m_pInstance = ( VkInstance_T *) uf::renderer::device.instance;
+	vulkanData.m_pQueue = ( VkQueue_T * ) uf::renderer::device.getQueue( uf::renderer::Device::QueueEnum::PRESENT );
+	vulkanData.m_nQueueFamilyIndex = uf::renderer::device.queueFamilyIndices.present;
+
+	vulkanData.m_nWidth = width;
+	vulkanData.m_nHeight = height;
+	vulkanData.m_nSampleCount = 1;
+
+	vr::Texture_t texture = { &vulkanData, vr::TextureType_Vulkan, vr::ColorSpace_Auto };
+	
+	vulkanData.m_nFormat = leftOutputAttachment.descriptor.format;
+	vulkanData.m_nImage = (uint64_t) (VkImage) leftOutputAttachment.image;
+	vr::VRCompositor()->Submit( invert ? vr::Eye_Right : vr::Eye_Left, &texture, &bounds );
+
+	vulkanData.m_nFormat = rightOutputAttachment.descriptor.format;
+	vulkanData.m_nImage = (uint64_t) (VkImage) rightOutputAttachment.image;
+	vr::VRCompositor()->Submit( invert ? vr::Eye_Left : vr::Eye_Right, &texture, &bounds );
+
+	vr::VRCompositor()->PostPresentHandoff();
+#endif
+}
+void ext::openvr::synchronize( bool async ) {
+	if ( async ) uf::thread::add( uf::thread::fetchWorker(), [](){ vr::VRCompositor()->WaitGetPoses(nullptr, 0, nullptr, 0); return true; }, true );
+	else vr::VRCompositor()->WaitGetPoses(nullptr, 0, nullptr, 0);
+	
+	ext::openvr::updateTracking(1);
+}
+float ext::openvr::predictedTimeToDisplay( float additional ) {
+	float displayFrequency = ext::openvr::context->GetFloatTrackedDeviceProperty(vr::k_unTrackedDeviceIndex_Hmd, vr::Prop_DisplayFrequency_Float);
+	float fFrameDuration = 1.f / displayFrequency;
+	
+	float fSecondsSinceLastVsync = 0.0f;
+	ext::openvr::context->GetTimeSinceLastVsync( &fSecondsSinceLastVsync, NULL );
+	
+	float fSecondsFromVSyncToPhotons = ext::openvr::context->GetFloatTrackedDeviceProperty(vr::k_unTrackedDeviceIndex_Hmd, vr::Prop_SecondsFromVsyncToPhotons_Float);
+	float fPredictedSecondsFromNow = additional * fFrameDuration - fSecondsSinceLastVsync + fSecondsFromVSyncToPhotons;
+// 	fFrameDuration - fSecondsSinceLastVsync + fFrameDuration + fSecondsFromVSyncToPhotons;
+//	frameDuration + vsyncToPhotons;
+	return fPredictedSecondsFromNow;
+}
+float ext::openvr::updateTracking(float additional) {
+	float fPredictedSecondsFromNow = ext::openvr::predictedTimeToDisplay(additional);
+	ext::openvr::context->GetDeviceToAbsoluteTrackingPose(
+		vr::ETrackingUniverseOrigin::TrackingUniverseStanding,
+		fPredictedSecondsFromNow,
+		ext::openvr::driver.poses,
+		vr::k_unMaxTrackedDeviceCount
+	);
+
+//	vr::VRCompositor()->WaitGetPoses(&driver.poses[0], vr::k_unMaxTrackedDeviceCount, nullptr, 0);
+	if ( ext::openvr::driver.poses[vr::k_unTrackedDeviceIndex_Hmd].bDeviceIsConnected && ext::openvr::driver.poses[vr::k_unTrackedDeviceIndex_Hmd].bPoseIsValid ) {
+		vr::HmdMatrix34_t mat = ext::openvr::driver.poses[vr::k_unTrackedDeviceIndex_Hmd].mDeviceToAbsoluteTracking;
+		::devices.hmd.matrix = {
+			mat.m[0][0], mat.m[1][0], mat.m[2][0], 0.0,
+			mat.m[0][1], mat.m[1][1], mat.m[2][1], 0.0,
+			mat.m[0][2], mat.m[1][2], mat.m[2][2], 0.0,
+			mat.m[0][3], mat.m[1][3], mat.m[2][3], 1.0f
+		};
+		::devices.hmd.matrix = uf::matrix::invert(::devices.hmd.matrix);
+	}
+	return fPredictedSecondsFromNow;
+}
+
+void ext::openvr::recommendedResolution( uint32_t& width, uint32_t& height ) {
+	ext::openvr::width = width;
+	ext::openvr::height = height;
+	ext::openvr::context->GetRecommendedRenderTargetSize( &width, &height );
+}
+
+pod::Matrix4t<> ext::openvr::hmdHeadPositionMatrix() {
+	return ::devices.hmd.matrix;
+}
+pod::Matrix4t<> ext::openvr::hmdEyePositionMatrix( vr::Hmd_Eye eye ) {
+	vr::HmdMatrix34_t mat = ext::openvr::context->GetEyeToHeadTransform( eye );
+	pod::Matrix4t<> res = {
+		mat.m[0][0], mat.m[1][0], mat.m[2][0], 0.0, 
+		mat.m[0][1], mat.m[1][1], mat.m[2][1], 0.0,
+		mat.m[0][2], mat.m[1][2], mat.m[2][2], 0.0,
+		mat.m[0][3], mat.m[1][3], mat.m[2][3], 1.0f
+	};
+	res = uf::matrix::inverse( res );
+	return res;
+}
+pod::Matrix4t<> ext::openvr::hmdViewTranslationMatrix() {
+	return uf::matrix::translate( uf::matrix::identity(), hmdPosition() );
+}
+pod::Matrix4t<> ext::openvr::hmdViewRotationMatrix() {
+	pod::Matrix4t<> mat = hmdHeadPositionMatrix();
+	mat[(4*3)+0] = 0;
+	mat[(4*3)+1] = 0;
+	mat[(4*3)+2] = 0;
+	return mat;
+}
+pod::Vector3f ext::openvr::hmdPosition() {
+	pod::Matrix4t<> mat = hmdHeadPositionMatrix();
+	return {
+		mat[(4*3)+0],
+		mat[(4*3)+1],
+		-mat[(4*3)+2],
+	};
+}
+pod::Vector3f ext::openvr::hmdEyePosition( vr::Hmd_Eye eye ) {
+	vr::HmdMatrix34_t mat = ext::openvr::context->GetEyeToHeadTransform( eye );
+	pod::Vector3f offset = { mat.m[0][3], mat.m[1][3], mat.m[2][3] };
+	return offset;
+}
+pod::Vector3f ext::openvr::hmdPosition( vr::Hmd_Eye eye ) {
+	return hmdPosition() + hmdEyePosition( eye );
+}
+pod::Quaternion<> ext::openvr::hmdQuaternion() {
+	pod::Quaternion<> q = uf::quaternion::fromMatrix( hmdHeadPositionMatrix() );
+//	q.w *= -1;
+	return q;
+/*
+	pod::Matrix4t<> mat = hmdHeadPositionMatrix();
+	pod::Quaternion<> q;
+	q.w = sqrt(fmax(0, 1 + mat[(4*0)+0] + mat[(4*1)+1] + mat[(4*2)+2])) / 2;
+	q.x = sqrt(fmax(0, 1 + mat[(4*0)+0] - mat[(4*1)+1] - mat[(4*2)+2])) / 2;
+	q.y = sqrt(fmax(0, 1 - mat[(4*0)+0] + mat[(4*1)+1] - mat[(4*2)+2])) / 2;
+	q.z = sqrt(fmax(0, 1 - mat[(4*0)+0] - mat[(4*1)+1] + mat[(4*2)+2])) / 2;
+
+	q.x = copysign(q.x, mat[(4*1)+2] - mat[(4*2)+1]);
+	q.y = copysign(q.y, mat[(4*2)+0] - mat[(4*0)+2]);
+	q.z = copysign(q.z, mat[(4*0)+1] - mat[(4*1)+0]);
+
+	q.w *= -1;
+	return q; // * pod::Vector4f{ 1, 1, -1, -1 };
+*/
+}
+pod::Matrix4t<> ext::openvr::hmdViewMatrix( vr::Hmd_Eye eye, const pod::Matrix4f& view ) {
+	return
+		hmdEyePositionMatrix( eye ) *
+		uf::matrix::translate( uf::matrix::identity(), hmdPosition() ) *
+		uf::matrix::inverse( uf::quaternion::matrix( ext::openvr::hmdQuaternion() * pod::Vector4f{ 1, 1, -1, 1 } ) ) *
+	//	uf::matrix::inverse( uf::quaternion::matrix( ext::openvr::hmdQuaternion() * pod::Vector4f{ 1, 1, -1, -1 } ) ) *
+		view;
+//	return hmdEyePositionMatrix( eye ) * uf::matrix::translate( uf::matrix::identity(), hmdPosition() ) * uf::matrix::inverse( uf::quaternion::matrix( ext::openvr::hmdQuaternion() * pod::Vector4f{ 1, 1, -1, -1 } ) ) * view;
+//	return uf::matrix::translate( uf::matrix::identity(), hmdEyePosition( eye ) ) * uf::matrix::inverse( uf::quaternion::matrix( ext::openvr::hmdQuaternion() ) ) * view;
+//	return uf::matrix::scale(uf::matrix::identity(), pod::Vector3f{1,1,-1}) * hmdEyePositionMatrix( eye ) * hmdHeadPositionMatrix() * view;
+}
+pod::Matrix4t<> ext::openvr::hmdProjectionMatrix( vr::Hmd_Eye eye, float zNear, float zFar ) {
+	struct {
+		float left;
+		float right;
+		float top;
+		float bottom;
+	} frustum;
+	ext::openvr::context->GetProjectionRaw( eye, &frustum.left, &frustum.right, &frustum.top, &frustum.bottom );
+
+	if ( true ) {
+		frustum.left = -abs( frustum.left );
+		frustum.right = abs( frustum.right );
+		frustum.top = -abs( frustum.top );
+		frustum.bottom = abs( frustum.bottom );
+	} else {
+	}
+	//	if ( DEBUG_MARKER ) std::cout << frustum.left << "\t" << frustum.right << "\t" << frustum.top << "\t" << frustum.bottom << std::endl;
+
+	/*
+		float fov = this->m_settings.perspective.fov * (3.14159265358f / 180.0f);
+		float raidou = (float) this->m_settings.perspective.size.x / (float) this->m_settings.perspective.size.y;
+		float f = 1.0f / tan( 0.5f * fov );
+		this->m_matrices.projection = {
+			f / raidou, 	0.0f, 	 0.0f, 	0.0f,
+			0.0f, 			-f, 	 0.0f, 	0.0f,
+			0.0f,       	0.0f,    0.0f, 	1.0f,
+			0.0f,       	0.0f,   this->m_settings.perspective.bounds.x, 	0.0f
+		};
+	*/
+
+	switch ( 0 ) {
+		case 0: {
+			float Sx = 2 / (frustum.right - frustum.left);
+			float Sy = 2 / (frustum.top - frustum.bottom);
+			float S20 = (frustum.right + frustum.left) / (frustum.right - frustum.left);
+			float S21 = (frustum.top + frustum.bottom) / (frustum.top - frustum.bottom);
+			float Sz = -zFar / (zFar - zNear);
+			float S32 = -zFar * zNear / (zFar - zNear);
+		/*
+			return {
+				 Sx,   0,   0,   0,
+				  0,  Sy,   0,   0,
+				S20, S21,   0,   1,
+				  0,   0, zNear,   0,
+			};
+		*/
+			return uf::matrix::multiply( pod::Matrix4f{
+				1, 0, 0, 0,
+				0, 1, 0, 0,
+				0, 0, 1, 0,
+				0, 0, 0, 1,
+			}, pod::Matrix4f{
+				 Sx,   0,   0,   0,
+				  0,  Sy,   0,   0,
+				-S20, -S21,   0,   1,
+				  0,   0, zNear,   0,
+			});
+		} break;
+		default: {
+			vr::HmdMatrix44_t mat = ext::openvr::context->GetProjectionMatrix( eye, zFar, zNear );
+			return uf::matrix::multiply( pod::Matrix4f{
+				1, 0, 0, 0,
+				0,-1, 0, 0,
+				0, 0, 1, 0,
+				0, 0, 0, 1,
+			}, pod::Matrix4f{
+				mat.m[0][0], mat.m[1][0], mat.m[2][0], mat.m[3][0],
+				mat.m[0][1], mat.m[1][1], mat.m[2][1], mat.m[3][1], 
+			    -mat.m[0][2], -mat.m[1][2], mat.m[2][2],-mat.m[3][2], 
+				mat.m[0][3], mat.m[1][3], mat.m[2][3], mat.m[3][3]
+			});
+		} break;
+	}
+}
+uf::Serializer ext::openvr::controllerState( vr::Controller_Hand hand, const std::string& key ) {
+	if ( hand == vr::Controller_Hand::Hand_Left ) return key == "" ? ::devices.controllers.left.state : ::devices.controllers.left.state[key];
+	else if ( hand == vr::Controller_Hand::Hand_Right ) return key == "" ? ::devices.controllers.right.state : ::devices.controllers.right.state[key];
+	return uf::Serializer();
+}
+pod::Vector3f ext::openvr::controllerPosition( vr::Controller_Hand hand, bool tip ) {
+	pod::Matrix4t<> mat = controllerMatrix( hand, tip );
+	return {
+		 mat[(4*3)+0],
+		 mat[(4*3)+1],
+		-mat[(4*3)+2],
+	};
+}
+pod::Quaternion<> ext::openvr::controllerQuaternion( vr::Controller_Hand hand, bool tip ) {
+	pod::Quaternion<> q = uf::quaternion::fromMatrix( controllerMatrix( hand, tip ) );
+	q.w *= -1;
+	return q;
+/*
+	pod::Matrix4t<> mat = controllerMatrix( hand, tip );
+	pod::Quaternion<> q;
+	q.w = sqrt(fmax(0, 1 + mat[(4*0)+0] + mat[(4*1)+1] + mat[(4*2)+2])) / 2;
+	q.x = sqrt(fmax(0, 1 + mat[(4*0)+0] - mat[(4*1)+1] - mat[(4*2)+2])) / 2;
+	q.y = sqrt(fmax(0, 1 - mat[(4*0)+0] + mat[(4*1)+1] - mat[(4*2)+2])) / 2;
+	q.z = sqrt(fmax(0, 1 - mat[(4*0)+0] - mat[(4*1)+1] + mat[(4*2)+2])) / 2;
+
+	q.x = copysign(q.x, mat[(4*1)+2] - mat[(4*2)+1]);
+	q.y = copysign(q.y, mat[(4*2)+0] - mat[(4*0)+2]);
+	q.z = copysign(q.z, mat[(4*0)+1] - mat[(4*1)+0]);
+	return q * pod::Vector4f{ 1, 1, -1, 1 };
+*/
+}
+pod::Matrix4t<> ext::openvr::controllerTranslationMatrix( vr::Controller_Hand hand, bool tip ) {
+	return uf::matrix::translate( uf::matrix::identity(), controllerPosition( hand, tip ) );
+}
+pod::Matrix4t<> ext::openvr::controllerRotationMatrix( vr::Controller_Hand hand, bool tip ) {
+	pod::Matrix4t<> mat = controllerMatrix( hand, tip );
+	mat[(4*3)+0] = 0;
+	mat[(4*3)+1] = 0;
+	mat[(4*3)+2] = 0;
+	return uf::matrix::inverse( mat );
+}
+pod::Matrix4t<> ext::openvr::controllerModelMatrix( vr::Controller_Hand hand, bool tip ) {
+	return
+		uf::matrix::translate( uf::matrix::identity(), controllerPosition( hand, tip ) ) *
+		uf::quaternion::matrix( controllerQuaternion( hand, tip ) );
+//	return uf::matrix::translate( uf::matrix::identity(), controllerPosition( hand, tip ) ) * controllerRotationMatrix( hand, tip );
+//	return uf::matrix::scale( uf::matrix::identity(), pod::Vector3f{ 1, 1, -1 } ) * controllerMatrix( hand, tip );
+//	return uf::matrix::translate(  uf::quaternion::matrix( ext::openvr::controllerQuaternion( hand, tip ) ),  controllerPosition( hand, tip ) );
+}
+pod::Matrix4t<> ext::openvr::controllerMatrix( vr::Controller_Hand hand, bool tip ) {
+	if ( hand == vr::Controller_Hand::Hand_Left ) return tip ? ::devices.controllers.left.tip : ::devices.controllers.left.matrix;
+	else if ( hand == vr::Controller_Hand::Hand_Right ) return tip ? ::devices.controllers.right.tip : ::devices.controllers.right.matrix;
+	return uf::matrix::identity();
+}
+bool ext::openvr::controllerActive( vr::Controller_Hand hand ) {
+	if ( hand == vr::Controller_Hand::Hand_Left ) return ::devices.controllers.left.active;
+	else if ( hand == vr::Controller_Hand::Hand_Right ) return ::devices.controllers.right.active;
+	return false;
+}
+uf::Graphic& ext::openvr::getRenderModel( const std::string& name ) {
+	return ::renderModels[name];
+}
+uf::Graphic& ext::openvr::controllerRenderModel( vr::Controller_Hand hand ) {
+	if ( hand == vr::Controller_Hand::Hand_Left ) return renderModels["{indexcontroller}valve_controller_knu_1_0_left"]; //return ::devices.controllers.left.mesh;
+	else if ( hand == vr::Controller_Hand::Hand_Right ) return renderModels["{indexcontroller}valve_controller_knu_1_0_right"]; //return ::devices.controllers.right.mesh;
+	UF_EXCEPTION("Invalid hand");
+}
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/ultralight/ultralight.cpp b/engine/src/ext/ultralight/ultralight.cpp
new file mode 100644
index 00000000..632dab47
--- /dev/null
+++ b/engine/src/ext/ultralight/ultralight.cpp
@@ -0,0 +1,270 @@
+#include <uf/ext/ultralight/ultralight.h>
+#if UF_USE_ULTRALIGHT
+#include <AppCore/CAPI.h>
+
+#include <uf/utils/io/iostream.h>
+#include <uf/utils/hook/hook.h>
+// std::string ext::ultralight::resourcesDir = uf::io::root + "/resources/";
+
+namespace {
+	size_t uids = 0;
+	ULRenderer renderer;
+
+	std::vector<std::string> queue;
+	void OnFinishLoading(void* user_data, ULView caller, unsigned long long frame_id, bool is_main_frame, ULString url) {
+		if ( !is_main_frame ) return;
+		pod::HTML& container = *((pod::HTML*) user_data);
+		container.pending = true;
+		if ( container.callbacks.load != "" ) {
+			queue.emplace_back( container.callbacks.load );
+			container.callbacks.load = "";
+		}
+	}
+	void ConsoleMessageCallback(void* user_data, ULView caller, ULMessageSource _source, ULMessageLevel _level, ULString _message, unsigned int line_number, unsigned int column_number, ULString source_id) {
+		std::string level = "?";
+		std::string source = "?";
+		switch ( _level ) {
+			case ULMessageLevel::kMessageLevel_Log: level = "Log"; break;
+			case ULMessageLevel::kMessageLevel_Warning: level = "Warning"; break;
+			case ULMessageLevel::kMessageLevel_Error: level = "Error"; break;
+			case ULMessageLevel::kMessageLevel_Debug: level = "Debug"; break;
+			case ULMessageLevel::kMessageLevel_Info: level = "Info"; break;
+		}
+		switch ( _source ) {
+			case ULMessageSource::kMessageSource_XML: source = "XML"; break;
+			case ULMessageSource::kMessageSource_JS: source = "JS"; break;
+			case ULMessageSource::kMessageSource_Network: source = "Network"; break;
+			case ULMessageSource::kMessageSource_ConsoleAPI: source = "ConsoleAPI"; break;
+			case ULMessageSource::kMessageSource_Storage: source = "Storage"; break;
+			case ULMessageSource::kMessageSource_AppCache: source = "AppCache"; break;
+			case ULMessageSource::kMessageSource_Rendering: source = "Rendering"; break;
+			case ULMessageSource::kMessageSource_CSS: source = "CSS"; break;
+			case ULMessageSource::kMessageSource_Security: source = "Security"; break;
+			case ULMessageSource::kMessageSource_ContentBlocker: source = "ContentBlocker"; break;
+			case ULMessageSource::kMessageSource_Other: source = "Other"; break;
+		}
+		uf::String message; {
+			size_t len = ulStringGetLength(_message);
+			const ULChar16* data = ulStringGetData(_message);
+			for ( size_t i = 0; i < len; ++i ) message += data[i];
+		}
+		if ( _level + 1 >= ext::ultralight::log ) uf::iostream << "[UL-UX] [" << level << "] " << "[" << source << "] " << message << "\n";
+	}
+}
+
+namespace UL {
+	struct String {
+		ULString handle;
+		String( const std::string& str = "" ) {
+			handle = ulCreateString( str.c_str() );
+		}
+		String( uint32_t c ) {
+			handle = ulCreateStringUTF16( (uint16_t*) &c, 2 );
+		}
+		~String() {
+			if ( !handle ) return;
+			ulDestroyString(handle);
+		}
+		operator ULString() {
+			return handle;
+		}
+	};
+
+	uint32_t getModifiers( const uf::Serializer& event ) {
+		uint32_t modifiers = 0;
+		if ( event["alt"].as<bool>() ) modifiers |= 1 << 0;		// ULKeyEvent::kMod_AltKey;
+		if ( event["control"].as<bool>() ) modifiers |= 1 << 1; // ULKeyEvent::kMod_CtrlKey;
+		if ( event["system"].as<bool>() ) modifiers |= 1 << 2; 	// ULKeyEvent::kMod_MetaKey;
+		if ( event["shift"].as<bool>() ) modifiers |= 1 << 3; 	// ULKeyEvent::kMod_ShiftKey;
+		return modifiers;
+	}
+
+	struct KeyEvent {
+		ULKeyEvent handle;
+		KeyEvent( const std::string& payload ) {
+			uf::Serializer event = payload;
+			ULKeyEventType type;
+			if ( event["key"]["state"].is<std::string>() ) {
+				std::string s = event["key"]["state"].as<std::string>();
+				if ( s == "Down" ) type = ULKeyEventType::kKeyEventType_RawKeyDown;
+				else if ( s == "Up" ) type = ULKeyEventType::kKeyEventType_KeyUp;
+			}
+			if ( event["type"].as<std::string>() == "window:Text.Entered" ) {
+				type = ULKeyEventType::kKeyEventType_Char;
+				uint32_t modifiers = 0;
+				int32_t virtualKeyCode = 0;
+				int32_t nativeKeyCode = 0;
+				bool isKeypad = false;
+				bool isAutoRepeat = false;
+				bool isSystemKey = false;
+
+				handle = ulCreateKeyEvent( type, modifiers, virtualKeyCode, nativeKeyCode, UL::String(event["text"]["uint32_t"].as<size_t>()), UL::String(event["text"]["uint32_t"].as<size_t>()), isKeypad, isAutoRepeat, isSystemKey );
+				return;
+			}
+		#if defined(_WIN32) && 0
+		//	std::cout << "EVENT: " << event << std::endl;
+			handle = ulCreateKeyEventWindows( type, event["key"]["wparam"].as<size_t>(), event["key"]["lparam"].as<size_t>(), event["key"]["modifier"]["system"].as<bool>());
+		#else
+			uint32_t modifiers = getModifiers( event["key"]["modifier"] );
+			int32_t virtualKeyCode = event["key"]["raw"].as<size_t>();
+			int32_t nativeKeyCode = event["key"]["lparam"].as<size_t>();
+			std::string text = ""; //event["key"]["code"].as<std::string>();
+			std::string unmodifiedText = ""; //event["key"]["code"].as<std::string>();
+			bool isKeypad = false;
+			bool isAutoRepeat = false;
+			bool isSystemKey = event["key"]["modifier"]["system"].as<bool>();
+
+			handle = ulCreateKeyEvent( type, modifiers, virtualKeyCode, nativeKeyCode, UL::String(text), UL::String(unmodifiedText), isKeypad, isAutoRepeat, isSystemKey );
+		#endif
+		}
+		~KeyEvent() {
+			if ( !handle ) return;
+			ulDestroyKeyEvent(handle);
+		}
+		operator ULKeyEvent() {
+			return handle;
+		}
+	};
+	struct MouseEvent {
+		ULMouseEvent handle;
+		MouseEvent( const std::string& payload ) {
+			uf::Serializer event = payload;
+			ULMouseEventType type = ULMouseEventType::kMouseEventType_MouseMoved;
+			ULMouseButton button = ULMouseButton::kMouseButton_None;
+
+			if ( event["mouse"]["state"].is<std::string>() ) {
+				std::string s = event["mouse"]["state"].as<std::string>();
+				if ( s == "Up" ) type = ULMouseEventType::kMouseEventType_MouseUp;
+				else if ( s == "Down" ) type = ULMouseEventType::kMouseEventType_MouseDown;
+			}
+			if ( event["mouse"]["button"].is<std::string>() ) {
+				std::string s = event["mouse"]["button"].as<std::string>();
+				if ( s == "Left" ) button = ULMouseButton::kMouseButton_Left;
+				else if ( s == "Middle" ) button = ULMouseButton::kMouseButton_Middle;
+				else if ( s == "Right" ) button = ULMouseButton::kMouseButton_Right;
+			}
+			int x = event["mouse"]["position"]["x"].as<int>() / ext::ultralight::scale;
+			int y = event["mouse"]["position"]["y"].as<int>() / ext::ultralight::scale;
+			handle = ulCreateMouseEvent( type, x, y, button );
+		}
+		~MouseEvent() {
+			if ( !handle ) return;
+			ulDestroyMouseEvent(handle);
+		}
+		operator ULMouseEvent() {
+			return handle;
+		}		
+	};
+	struct ScrollEvent {
+		ULScrollEvent handle;
+		ScrollEvent( const std::string& payload ) {
+			uf::Serializer event = payload;
+			ULScrollEventType type = ULScrollEventType::kScrollEventType_ScrollByPixel;
+			handle = ulCreateScrollEvent( type, 0, event["mouse"]["delta"].as<int>() );
+		}
+		~ScrollEvent() {
+			if ( !handle ) return;
+			ulDestroyScrollEvent(handle);
+		}
+		operator ULScrollEvent() {
+			return handle;
+		}
+	};
+}
+
+uint8_t ext::ultralight::log = 0;
+double ext::ultralight::scale = 1.0;
+
+void ext::ultralight::initialize() {
+	ULConfig config = ulCreateConfig();
+
+	ulConfigSetDeviceScale(config, ext::ultralight::scale);
+
+	ulConfigSetFontFamilyStandard(config, UL::String("Arial"));
+	ulConfigSetResourcePath(config, UL::String(uf::io::root + "/html/resources/"));
+	ulConfigSetUseGPURenderer(config, false);
+	ulEnablePlatformFontLoader();
+	ulEnablePlatformFileSystem(UL::String(uf::io::root + "/html/assets/"));
+	ulEnableDefaultLogger(UL::String(uf::io::root + "/logs/ultralight.log"));
+
+
+	::renderer = ulCreateRenderer(config);
+}
+void ext::ultralight::tick() {
+	for ( auto& callback : queue ) uf::hooks.call(callback);
+	queue.clear();
+
+	ulUpdate(renderer);
+}
+void ext::ultralight::render() {
+	ulRender(renderer);
+}
+void ext::ultralight::terminate() {
+	ulDestroyRenderer(renderer);
+}
+
+pod::HTML ext::ultralight::create( const std::string& html, const pod::Vector2ui& size ) {
+	pod::HTML container;
+	return create( container, html, size );
+}
+pod::HTML& ext::ultralight::create( pod::HTML& container, const std::string& html, const pod::Vector2ui& size ) {
+	container.uid = ++uids;
+	container.view = ulCreateView(::renderer, size.x, size.y, false, 0, false);
+	container.size = size;
+
+	// is URI
+	if ( html.find("://") != std::string::npos ) {
+		ulViewLoadURL(container.view, UL::String(html));
+	// is filename
+	} else if ( uf::io::extension(html) == "html" ) {
+		std::string html = uf::io::readAsString( uf::io::resolveURI( html ) );
+		ulViewLoadHTML(container.view, UL::String(html));
+	// is HTML
+	} else {
+		ulViewLoadHTML(container.view, UL::String(html));
+	}
+
+	ulViewSetFinishLoadingCallback(container.view, &OnFinishLoading, &container);
+	ulViewSetAddConsoleMessageCallback(container.view, &ConsoleMessageCallback, &container);
+
+	return container;
+}
+void ext::ultralight::destroy( pod::HTML& container ) {
+	ulDestroyView(container.view);
+}
+void ext::ultralight::on( pod::HTML& container, const std::string& name, const std::string& hook ) {
+	if ( name == "load" ) container.callbacks.load = hook;
+}
+void ext::ultralight::resize( pod::HTML& container, const pod::Vector2ui& size ) {
+	container.size = size;
+	container.pending = true;
+	ulViewResize( container.view, size.x, size.y );
+}
+void ext::ultralight::input( pod::HTML& container, const std::string& payload ) {
+	uf::Serializer event = payload;
+
+	// std::cout << payload << std::endl;
+	if  ( event["type"].as<std::string>() == "window:Key.Pressed" || event["type"].as<std::string>() == "window:Key.Released" || event["type"].as<std::string>() == "window:Text.Entered" ) {
+		ulViewFireKeyEvent( container.view, UL::KeyEvent( payload ) );
+	} else if ( event["type"].as<std::string>() == "window:Mouse.Moved" || event["type"].as<std::string>() == "window:Mouse.Click" ) {
+		ulViewFireMouseEvent( container.view, UL::MouseEvent( payload ) );
+	} else if ( event["type"].as<std::string>() == "window:Mouse.Wheel" )	{
+		ulViewFireScrollEvent( container.view, UL::ScrollEvent( payload ) );
+	} else {
+	//	std::cout << "Unknown event: " << event << std::endl;
+	}
+	container.pending = true;
+}
+uf::Image ext::ultralight::capture( pod::HTML& container ) {
+	uf::Image image;
+
+	ULSurface surface = ulViewGetSurface(container.view);
+	ULBitmap bitmap = ulBitmapSurfaceGetBitmap(surface);
+	ulBitmapSwapRedBlueChannels(bitmap);
+	ulBitmapLockPixels(bitmap);
+	image.loadFromBuffer( (uint8_t*) ulBitmapRawPixels(bitmap), {ulBitmapGetWidth(bitmap), ulBitmapGetHeight(bitmap)}, ulBitmapGetBpp(bitmap) * 2, 4, true );
+	ulBitmapUnlockPixels(bitmap);
+	ulBitmapSwapRedBlueChannels(bitmap);
+	return image;
+}
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/vorbis/vorbis.cpp b/engine/src/ext/vorbis/vorbis.cpp
new file mode 100644
index 00000000..b30f6b02
--- /dev/null
+++ b/engine/src/ext/vorbis/vorbis.cpp
@@ -0,0 +1,65 @@
+#include <uf/config.h>
+#if UF_USE_VORBIS
+
+#if UF_USE_OPENAL
+#include <uf/ext/oal/oal.h>
+#endif
+
+#include <uf/ext/vorbis/vorbis.h>
+#include <iostream>
+#include <cstdio>
+
+int ext::Vorbis::BUFFER = 32768;
+
+void UF_API_CALL ext::Vorbis::load( const std::string& filename ) {
+	int endian = 0;
+	int bitStream;
+	long bytes;
+	char buffer[ext::Vorbis::BUFFER];
+	FILE* fp = fopen( filename.c_str(), "rb" );
+
+	if ( !fp ) { 
+		std::cerr << "Vorbis: failed to open `" << filename << "`. File error." << std::endl;
+		return;
+	}
+
+	OggVorbis_File file;
+//	ov_open( fp, &file, NULL, 0 );
+	if( ov_open_callbacks(fp, &file, NULL, 0, OV_CALLBACKS_DEFAULT) < 0 ) {
+		std::cerr << "Vorbis: failed to open `" << filename << "`. Not Ogg." << std::endl;
+		return;
+	}
+
+	vorbis_info* info = ov_info(&file, -1);
+	#if UF_USE_OPENAL
+		this->m_format = info->channels == 1 ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16;
+	#endif
+	this->m_frequency = info->rate;
+
+	do {
+		bytes = ov_read( &file, buffer, ext::Vorbis::BUFFER, endian, 2, 1, &bitStream );
+		this->m_buffer.insert( this->m_buffer.end(), buffer, buffer + bytes );
+	} while ( bytes > 0 );
+	
+	this->m_duration = ov_time_total(&file, -1);
+
+	ov_clear(&file);
+}
+
+std::vector<char>& UF_API_CALL ext::Vorbis::getBuffer() {
+	return this->m_buffer;
+}
+const std::vector<char>& UF_API_CALL ext::Vorbis::getBuffer() const {
+	return this->m_buffer;
+}
+int UF_API_CALL ext::Vorbis::getFormat() const {
+	return this->m_format;
+}
+int UF_API_CALL ext::Vorbis::getFrequency() const {
+	return this->m_frequency;
+}
+float UF_API_CALL ext::Vorbis::getDuration() const {
+	return this->m_duration;
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/vulkan/buffer.cpp b/engine/src/ext/vulkan/buffer.cpp
new file mode 100644
index 00000000..bd439d20
--- /dev/null
+++ b/engine/src/ext/vulkan/buffer.cpp
@@ -0,0 +1,253 @@
+#if UF_USE_VULKAN
+
+#define VMA_IMPLEMENTATION
+
+#include <uf/ext/vulkan/buffer.h>
+#include <uf/ext/vulkan/vulkan.h>
+#include <uf/ext/vulkan/device.h>
+
+VkResult ext::vulkan::Buffer::map( VkDeviceSize size, VkDeviceSize offset ) {
+//	return vkMapMemory( device, memory, offset, size, 0, &mapped );
+	return vmaMapMemory( allocator, allocation, &mapped );
+}
+
+/**
+* Unmap a mapped memory range
+*
+* @note Does not return a result as vkUnmapMemory can't fail
+*/
+void ext::vulkan::Buffer::unmap() {
+	if ( !mapped ) return;
+//	vkUnmapMemory( device, memory );
+	vmaUnmapMemory( allocator, allocation );
+	mapped = nullptr;
+}
+
+/** 
+* Attach the allocated memory block to the buffer
+* 
+* @param offset (Optional) Byte offset (from the beginning) for the memory region to bind
+* 
+* @return VkResult of the bindBufferMemory call
+*/
+VkResult ext::vulkan::Buffer::bind( VkDeviceSize offset ) {
+//	return vkBindBufferMemory( device, buffer, memory, offset );
+//	return vmaBindBufferMemory( allocator, allocation, buffer );
+	return VK_SUCCESS;
+}
+
+/**
+* Setup the default descriptor for this buffer
+*
+* @param size (Optional) Size of the memory range of the descriptor
+* @param offset (Optional) Byte offset from beginning
+*
+*/
+void ext::vulkan::Buffer::setupDescriptor( VkDeviceSize size, VkDeviceSize offset ) {
+	descriptor.offset = offset;
+	descriptor.buffer = buffer;
+	descriptor.range = size;
+}
+
+/**
+* Copies the specified data to the mapped buffer
+* 
+* @param data Pointer to the data to copy
+* @param size Size of the data to copy in machine units
+*
+*/
+void ext::vulkan::Buffer::copyTo( void* data, VkDeviceSize size ) {
+	assert(mapped);
+	memcpy(mapped, data, size);
+}
+
+/** 
+* Flush a memory range of the buffer to make it visible to the device
+*
+* @note Only required for non-coherent memory
+*
+* @param size (Optional) Size of the memory range to flush. Pass VK_WHOLE_SIZE to flush the complete buffer range.
+* @param offset (Optional) Byte offset from beginning
+*
+* @return VkResult of the flush call
+*/
+VkResult ext::vulkan::Buffer::flush( VkDeviceSize size, VkDeviceSize offset ) {
+/*
+	VkMappedMemoryRange mappedRange = {};
+	mappedRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
+	mappedRange.memory = memory;
+	mappedRange.offset = offset;
+	mappedRange.size = size;
+	return vkFlushMappedMemoryRanges(device, 1, &mappedRange);
+*/
+	return VK_SUCCESS;
+}
+
+/**
+* Invalidate a memory range of the buffer to make it visible to the host
+*
+* @note Only required for non-coherent memory
+*
+* @param size (Optional) Size of the memory range to invalidate. Pass VK_WHOLE_SIZE to invalidate the complete buffer range.
+* @param offset (Optional) Byte offset from beginning
+*
+* @return VkResult of the invalidate call
+*/
+VkResult ext::vulkan::Buffer::invalidate( VkDeviceSize size, VkDeviceSize offset ) {
+/*
+	VkMappedMemoryRange mappedRange = {};
+	mappedRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
+	mappedRange.memory = memory;
+	mappedRange.offset = offset;
+	mappedRange.size = size;
+	return vkInvalidateMappedMemoryRanges(device, 1, &mappedRange);
+*/
+	return VK_SUCCESS;
+}
+
+void ext::vulkan::Buffer::allocate( VkBufferCreateInfo bufferCreateInfo ) {
+//	VK_CHECK_RESULT(vkCreateBuffer( device, &bufferCreateInfo, nullptr, &buffer));
+	VmaAllocationCreateInfo allocCreateInfo = {};
+	
+	allocCreateInfo.usage = VMA_MEMORY_USAGE_CPU_TO_GPU;
+	allocCreateInfo.preferredFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
+	if ( bufferCreateInfo.usage & (VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT) ) {
+		allocCreateInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY;
+	}
+
+	vmaCreateBuffer( allocator, &bufferCreateInfo, &allocCreateInfo, &buffer, &allocation, &allocationInfo );
+//	VkMemoryPropertyFlags memFlags;
+//	vmaGetMemoryTypeProperties(allocator, allocationInfo.memoryType, &memFlags);
+//	memory = allocationInfo.deviceMemory;
+	size = allocationInfo.size;
+}
+
+// RAII
+ext::vulkan::Buffer::~Buffer() {
+//	this->destroy();
+}
+void ext::vulkan::Buffer::initialize( VkDevice device ) {
+	this->device = device;
+}
+void ext::vulkan::Buffer::destroy() {
+	if ( buffer ) {
+		vmaDestroyBuffer( allocator, buffer, allocation );
+//		vkDestroyBuffer(device, buffer, nullptr);
+	}
+
+	if ( memory ) {
+//		vkFreeMemory(device, memory, nullptr);
+	}
+
+	buffer = nullptr;
+	memory = nullptr;
+}
+
+//
+// Buffers
+void ext::vulkan::Buffers::initialize( Device& device ) {
+	this->device = &device;
+}
+/*
+ext::vulkan::Buffers::~Buffers() {
+	for ( auto& buffer : buffers ) buffer.destroy();
+	buffers.clear();
+}
+*/
+void ext::vulkan::Buffers::destroy() {
+	for ( auto& buffer : buffers ) buffer.destroy();
+	buffers.clear();
+}
+
+size_t ext::vulkan::Buffers::initializeBuffer( void* data, VkDeviceSize length, VkBufferUsageFlags usage, VkMemoryPropertyFlags memoryProperties, bool stage ) {
+//	Buffer buffer;
+	size_t index = buffers.size();
+	Buffer& buffer = buffers.emplace_back();
+	
+	// Stage
+	if ( !stage ) {
+		VK_CHECK_RESULT(device->createBuffer(
+			usage,
+			memoryProperties,
+			buffer,
+			length
+		));
+		this->updateBuffer( data, length, buffer, stage );
+		return index;
+	}
+
+	// implicitly set properties
+	usage |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+
+	Buffer staging;
+	VkDeviceSize storageBufferSize = length;
+	device->createBuffer(
+		VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
+		VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+		staging,
+		storageBufferSize,
+		data
+	);
+
+	device->createBuffer(
+		usage,
+		memoryProperties,
+		buffer,
+		storageBufferSize
+	);
+
+	// Copy to staging buffer
+	VkCommandBuffer copyCmd = device->createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true);
+	VkBufferCopy copyRegion = {};
+	copyRegion.size = storageBufferSize;
+	vkCmdCopyBuffer(copyCmd, staging.buffer, buffer.buffer, 1, &copyRegion);
+	device->flushCommandBuffer(copyCmd, true);
+	staging.destroy();
+
+//	buffers.push_back( std::move(buffer) );
+	return index;
+}
+void ext::vulkan::Buffers::updateBuffer( void* data, VkDeviceSize length, size_t index, bool stage ) {
+	Buffer& buffer = buffers.at(index);
+	return updateBuffer( data, length, buffer, stage );
+}
+void ext::vulkan::Buffers::updateBuffer( void* data, VkDeviceSize length, Buffer& buffer, bool stage ) {
+//	assert(buffer.allocationInfo.size == length);
+
+	if ( length > buffer.allocationInfo.size ) {
+		if ( !true ) {
+			VK_VALIDATION_MESSAGE("Mismatch buffer update: Requesting " << buffer.allocationInfo.size << ", got " << length << "; Userdata might've been corrupted, please try validating with shader.validate() before updating buffer");
+		} else {
+			VK_VALIDATION_MESSAGE("Mismatch buffer update: Requesting " << buffer.allocationInfo.size << ", got " << length << ", resetting for safety");
+			length = buffer.allocationInfo.size;
+		}
+//		assert(buffer.allocationInfo.size > length);
+	}
+
+
+	if ( !stage ) {
+		VK_CHECK_RESULT(buffer.map());
+		memcpy(buffer.mapped, data, length);
+		buffer.unmap();
+		return;
+	}
+	// VkQueue queue = device->queues.transfer;
+	Buffer staging;
+	device->createBuffer(
+		VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
+		VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+		staging,
+		length,
+		data
+	);
+
+	// Copy to staging buffer
+	VkCommandBuffer copyCmd = device->createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true);
+	VkBufferCopy copyRegion = {};
+	copyRegion.size = length;
+	vkCmdCopyBuffer(copyCmd, staging.buffer, buffer.buffer, 1, &copyRegion);
+	device->flushCommandBuffer(copyCmd, true);
+	staging.destroy();
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/vulkan/device.cpp b/engine/src/ext/vulkan/device.cpp
new file mode 100644
index 00000000..eb522794
--- /dev/null
+++ b/engine/src/ext/vulkan/device.cpp
@@ -0,0 +1,965 @@
+#if UF_USE_VULKAN
+
+#include <uf/ext/vulkan/vulkan.h>
+#include <uf/ext/vulkan/device.h>
+#include <uf/ext/vulkan/initializers.h>
+#include <uf/utils/window/window.h>
+#include <uf/utils/string/ext.h>
+#include <uf/ext/openvr/openvr.h>
+
+#include <set>
+#include <map>
+
+#include <uf/utils/serialize/serializer.h>
+
+namespace {
+#if UF_USE_OPENVR
+	void VRInstanceExtensions( std::vector<std::string>& requested ) {
+		if ( !vr::VRCompositor() ) return;
+		int32_t nBufferSize = vr::VRCompositor()->GetVulkanInstanceExtensionsRequired( nullptr, 0 );
+		if ( nBufferSize < 0 ) return;
+		char pExtensionStr[nBufferSize];
+		pExtensionStr[0] = 0;
+		vr::VRCompositor()->GetVulkanInstanceExtensionsRequired( pExtensionStr, nBufferSize );
+		std::vector<std::string> extensions = uf::string::split( pExtensionStr, " " );
+		for ( auto& str : extensions ) {
+			// uf::iostream << str << "\n";
+			requested.push_back(str);
+		}
+		// requested.insert( requested.end(), extensions.begin(), extensions.end() );
+	}
+	void VRDeviceExtensions( VkPhysicalDevice_T* physicalDevice, std::vector<std::string>& requested ) {
+		if ( !vr::VRCompositor() ) return;
+		int32_t nBufferSize = vr::VRCompositor()->GetVulkanDeviceExtensionsRequired( physicalDevice, nullptr, 0 );
+		if ( nBufferSize < 0 ) return;
+		char pExtensionStr[nBufferSize];
+		pExtensionStr[0] = 0;
+		vr::VRCompositor()->GetVulkanDeviceExtensionsRequired( physicalDevice , pExtensionStr, nBufferSize );
+		std::vector<std::string> extensions = uf::string::split( pExtensionStr, " " );
+		for ( auto& str : extensions ) requested.push_back(str);
+		// requested.insert( requested.end(), extensions.begin(), extensions.end() );
+	}
+#endif
+	void validateRequestedExtensions( const std::vector<VkExtensionProperties>& extensionProperties, const std::vector<std::string>& requestedExtensions, std::vector<std::string>& supportedExtensions ) {
+		for ( auto& requestedExtension : requestedExtensions ) {
+			bool found = false;
+			for ( auto& extensionProperty : extensionProperties ) {
+				std::string extensionName = extensionProperty.extensionName;
+				if ( requestedExtension != extensionName ) continue;
+				if ( std::find( supportedExtensions.begin(), supportedExtensions.end(), extensionName ) != supportedExtensions.end() ) {
+					found = true;
+					break;
+				}
+				if ( found ) break;
+				found = true;
+				supportedExtensions.push_back( extensionName );
+				break;
+			}
+			if ( !found ) {
+				uf::iostream << "Vulkan missing requested extension: " << requestedExtension << "\n";
+			}
+		}
+	}
+
+	void enableRequestedDeviceFeatures( ext::vulkan::Device& device ) {
+		uf::Serializer json;
+
+	#define CHECK_FEATURE( NAME )\
+		if ( feature == #NAME ) {\
+			if ( device.features.NAME == VK_TRUE ) {\
+				device.enabledFeatures.NAME = true;\
+				if ( ext::vulkan::settings::validation ) uf::iostream << "Enabled feature: " << feature << "\n";\
+			} else if ( ext::vulkan::settings::validation ) uf::iostream << "Failed to enable feature: " << feature << "\n";\
+		}
+
+		for ( auto& feature : ext::vulkan::settings::requestedDeviceFeatures ) {
+			CHECK_FEATURE(robustBufferAccess);
+			CHECK_FEATURE(fullDrawIndexUint32);
+			CHECK_FEATURE(imageCubeArray);
+			CHECK_FEATURE(independentBlend);
+			CHECK_FEATURE(geometryShader);
+			CHECK_FEATURE(tessellationShader);
+			CHECK_FEATURE(sampleRateShading);
+			CHECK_FEATURE(dualSrcBlend);
+			CHECK_FEATURE(logicOp);
+			CHECK_FEATURE(multiDrawIndirect);
+			CHECK_FEATURE(drawIndirectFirstInstance);
+			CHECK_FEATURE(depthClamp);
+			CHECK_FEATURE(depthBiasClamp);
+			CHECK_FEATURE(fillModeNonSolid);
+			CHECK_FEATURE(depthBounds);
+			CHECK_FEATURE(wideLines);
+			CHECK_FEATURE(largePoints);
+			CHECK_FEATURE(alphaToOne);
+			CHECK_FEATURE(multiViewport);
+			CHECK_FEATURE(samplerAnisotropy);
+			CHECK_FEATURE(textureCompressionETC2);
+			CHECK_FEATURE(textureCompressionASTC_LDR);
+			CHECK_FEATURE(textureCompressionBC);
+			CHECK_FEATURE(occlusionQueryPrecise);
+			CHECK_FEATURE(pipelineStatisticsQuery);
+			CHECK_FEATURE(vertexPipelineStoresAndAtomics);
+			CHECK_FEATURE(fragmentStoresAndAtomics);
+			CHECK_FEATURE(shaderTessellationAndGeometryPointSize);
+			CHECK_FEATURE(shaderImageGatherExtended);
+			CHECK_FEATURE(shaderStorageImageExtendedFormats);
+			CHECK_FEATURE(shaderStorageImageMultisample);
+			CHECK_FEATURE(shaderStorageImageReadWithoutFormat);
+			CHECK_FEATURE(shaderStorageImageWriteWithoutFormat);
+			CHECK_FEATURE(shaderUniformBufferArrayDynamicIndexing);
+			CHECK_FEATURE(shaderSampledImageArrayDynamicIndexing);
+			CHECK_FEATURE(shaderStorageBufferArrayDynamicIndexing);
+			CHECK_FEATURE(shaderStorageImageArrayDynamicIndexing);
+			CHECK_FEATURE(shaderClipDistance);
+			CHECK_FEATURE(shaderCullDistance);
+			CHECK_FEATURE(shaderFloat64);
+			CHECK_FEATURE(shaderInt64);
+			CHECK_FEATURE(shaderInt16);
+			CHECK_FEATURE(shaderResourceResidency);
+			CHECK_FEATURE(shaderResourceMinLod);
+			CHECK_FEATURE(sparseBinding);
+			CHECK_FEATURE(sparseResidencyBuffer);
+			CHECK_FEATURE(sparseResidencyImage2D);
+			CHECK_FEATURE(sparseResidencyImage3D);
+			CHECK_FEATURE(sparseResidency2Samples);
+			CHECK_FEATURE(sparseResidency4Samples);
+			CHECK_FEATURE(sparseResidency8Samples);
+			CHECK_FEATURE(sparseResidency16Samples);
+			CHECK_FEATURE(sparseResidencyAliased);
+			CHECK_FEATURE(variableMultisampleRate);
+			CHECK_FEATURE(inheritedQueries);
+		}
+	#undef CHECK_FEATURE
+
+	#define CHECK_FEATURE2( NAME )\
+		if ( feature == #NAME ) {\
+			if ( device.features2.NAME == VK_TRUE ) {\
+				device.enabledFeatures2.NAME = true;\
+				if ( ext::vulkan::settings::validation ) uf::iostream << "Enabled feature: " << feature << "\n";\
+			} else if ( ext::vulkan::settings::validation ) uf::iostream << "Failed to enable feature: " << feature << "\n";\
+		}
+	#undef CHECK_FEATURE2
+	}
+	uf::Serializer retrieveDeviceFeatures( ext::vulkan::Device& device ) {
+		uf::Serializer json;
+
+	#define CHECK_FEATURE( NAME )\
+		json[#NAME]["supported"] = device.features.NAME;\
+		json[#NAME]["enabled"] = device.enabledFeatures.NAME;
+
+		CHECK_FEATURE(robustBufferAccess);
+		CHECK_FEATURE(fullDrawIndexUint32);
+		CHECK_FEATURE(imageCubeArray);
+		CHECK_FEATURE(independentBlend);
+		CHECK_FEATURE(geometryShader);
+		CHECK_FEATURE(tessellationShader);
+		CHECK_FEATURE(sampleRateShading);
+		CHECK_FEATURE(dualSrcBlend);
+		CHECK_FEATURE(logicOp);
+		CHECK_FEATURE(multiDrawIndirect);
+		CHECK_FEATURE(drawIndirectFirstInstance);
+		CHECK_FEATURE(depthClamp);
+		CHECK_FEATURE(depthBiasClamp);
+		CHECK_FEATURE(fillModeNonSolid);
+		CHECK_FEATURE(depthBounds);
+		CHECK_FEATURE(wideLines);
+		CHECK_FEATURE(largePoints);
+		CHECK_FEATURE(alphaToOne);
+		CHECK_FEATURE(multiViewport);
+		CHECK_FEATURE(samplerAnisotropy);
+		CHECK_FEATURE(textureCompressionETC2);
+		CHECK_FEATURE(textureCompressionASTC_LDR);
+		CHECK_FEATURE(textureCompressionBC);
+		CHECK_FEATURE(occlusionQueryPrecise);
+		CHECK_FEATURE(pipelineStatisticsQuery);
+		CHECK_FEATURE(vertexPipelineStoresAndAtomics);
+		CHECK_FEATURE(fragmentStoresAndAtomics);
+		CHECK_FEATURE(shaderTessellationAndGeometryPointSize);
+		CHECK_FEATURE(shaderImageGatherExtended);
+		CHECK_FEATURE(shaderStorageImageExtendedFormats);
+		CHECK_FEATURE(shaderStorageImageMultisample);
+		CHECK_FEATURE(shaderStorageImageReadWithoutFormat);
+		CHECK_FEATURE(shaderStorageImageWriteWithoutFormat);
+		CHECK_FEATURE(shaderUniformBufferArrayDynamicIndexing);
+		CHECK_FEATURE(shaderSampledImageArrayDynamicIndexing);
+		CHECK_FEATURE(shaderStorageBufferArrayDynamicIndexing);
+		CHECK_FEATURE(shaderStorageImageArrayDynamicIndexing);
+		CHECK_FEATURE(shaderClipDistance);
+		CHECK_FEATURE(shaderCullDistance);
+		CHECK_FEATURE(shaderFloat64);
+		CHECK_FEATURE(shaderInt64);
+		CHECK_FEATURE(shaderInt16);
+		CHECK_FEATURE(shaderResourceResidency);
+		CHECK_FEATURE(shaderResourceMinLod);
+		CHECK_FEATURE(sparseBinding);
+		CHECK_FEATURE(sparseResidencyBuffer);
+		CHECK_FEATURE(sparseResidencyImage2D);
+		CHECK_FEATURE(sparseResidencyImage3D);
+		CHECK_FEATURE(sparseResidency2Samples);
+		CHECK_FEATURE(sparseResidency4Samples);
+		CHECK_FEATURE(sparseResidency8Samples);
+		CHECK_FEATURE(sparseResidency16Samples);
+		CHECK_FEATURE(sparseResidencyAliased);
+		CHECK_FEATURE(variableMultisampleRate);
+		CHECK_FEATURE(inheritedQueries);
+	#undef CHECK_FEATURE
+
+	#define CHECK_FEATURE2( NAME )\
+		json[#NAME]["supported"] = device.features2.NAME;\
+		json[#NAME]["enabled"] = device.enabledFeatures2.NAME;
+	#undef CHECK_FEATURE2
+
+		return json;
+	}
+}
+
+uint32_t ext::vulkan::Device::getQueueFamilyIndex( VkQueueFlagBits queueFlags ) {
+	if ( queueFlags & VK_QUEUE_COMPUTE_BIT ) {
+		for ( uint32_t i = 0; i < static_cast<uint32_t>(queueFamilyProperties.size()); ++i ) {
+			if ( 
+				(queueFamilyProperties[i].queueFlags & queueFlags) &&
+				((queueFamilyProperties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) == 0)
+			)
+				return i;
+		}
+	}
+	if ( queueFlags & VK_QUEUE_TRANSFER_BIT ) {
+		for ( uint32_t i = 0; i < static_cast<uint32_t>(queueFamilyProperties.size()); ++i ) {
+			if (
+				(queueFamilyProperties[i].queueFlags & queueFlags) && 
+				((queueFamilyProperties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) == 0) && 
+				((queueFamilyProperties[i].queueFlags & VK_QUEUE_COMPUTE_BIT) == 0)
+			)
+				return i;
+		}
+	}
+	for ( uint32_t i = 0; i < static_cast<uint32_t>(queueFamilyProperties.size()); ++i ) {
+		if ( queueFamilyProperties[i].queueFlags & queueFlags )
+			return i;
+	}
+	UF_EXCEPTION("Could not find a matching queue family index");
+}
+uint32_t ext::vulkan::Device::getMemoryType( uint32_t typeBits, VkMemoryPropertyFlags properties, VkBool32 *memTypeFound ) {
+	for ( uint32_t i = 0; i < memoryProperties.memoryTypeCount; ++i ) {
+		if ( (typeBits & 1) == 1 ) {
+			if ( (memoryProperties.memoryTypes[i].propertyFlags & properties) == properties ) {
+				if ( memTypeFound ) *memTypeFound = true;
+				return i;
+			}
+		}
+		typeBits >>= 1;
+	}
+	if ( memTypeFound ) {
+		*memTypeFound = false;
+		return 0;
+	}
+	// UF_EXCEPTION("Could not find a matching memory type");
+}
+
+int ext::vulkan::Device::rate( VkPhysicalDevice device ) {
+	VkPhysicalDeviceProperties deviceProperties;
+	vkGetPhysicalDeviceProperties(device, &deviceProperties);
+
+	VkPhysicalDeviceFeatures deviceFeatures;
+	vkGetPhysicalDeviceFeatures(device, &deviceFeatures);
+	int score = 0;
+	// Discrete GPUs have a significant performance advantage
+	if (deviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU)
+		score += 1000;
+	// Maximum possible size of textures affects graphics quality
+	score += deviceProperties.limits.maxImageDimension2D;
+	// Application can't function without geometry shaders
+	if ( !deviceFeatures.geometryShader ) return 0;
+	//
+	{
+		const std::vector<const char*> deviceExtensions = {
+			VK_KHR_SWAPCHAIN_EXTENSION_NAME
+		};
+		uint32_t extensionCount;
+		vkEnumerateDeviceExtensionProperties( device, nullptr, &extensionCount, nullptr );
+		std::vector<VkExtensionProperties> availableExtensions( extensionCount );
+		vkEnumerateDeviceExtensionProperties( device, nullptr, &extensionCount, availableExtensions.data() );
+		std::set<std::string> requiredExtensions( deviceExtensions.begin(), deviceExtensions.end() );
+
+		for ( const auto& extension : availableExtensions )
+			requiredExtensions.erase( extension.extensionName );
+
+		if ( !requiredExtensions.empty() ) return 0;
+	}
+	//
+	{
+		VkSurfaceCapabilitiesKHR capabilities;
+		std::vector<VkSurfaceFormatKHR> formats;
+		std::vector<VkPresentModeKHR> presentModes;
+
+		vkGetPhysicalDeviceSurfaceCapabilitiesKHR( device, this->surface, &capabilities );
+
+		uint32_t formatCount;
+		vkGetPhysicalDeviceSurfaceFormatsKHR(device, this->surface, &formatCount, nullptr);
+		if ( formatCount != 0 ) {
+			formats.resize( formatCount );
+			vkGetPhysicalDeviceSurfaceFormatsKHR( device, this->surface, &formatCount, formats.data() );
+		}
+		uint32_t presentModeCount;
+		vkGetPhysicalDeviceSurfacePresentModesKHR( device, this->surface, &presentModeCount, nullptr );
+		if ( presentModeCount != 0 ) {
+			presentModes.resize(presentModeCount);
+			vkGetPhysicalDeviceSurfacePresentModesKHR( device, this->surface, &presentModeCount, presentModes.data() );
+		}
+		if ( formats.empty() || presentModes.empty() ) return 0;
+	}
+	return score;
+}
+
+VkCommandBuffer ext::vulkan::Device::createCommandBuffer( VkCommandBufferLevel level, bool begin ){
+	VkCommandBufferAllocateInfo cmdBufAllocateInfo = ext::vulkan::initializers::commandBufferAllocateInfo( getCommandPool(QueueEnum::TRANSFER), level, 1 );
+
+	VkCommandBuffer commandBuffer;
+	VK_CHECK_RESULT( vkAllocateCommandBuffers( logicalDevice, &cmdBufAllocateInfo, &commandBuffer ) );
+	// If requested, also start recording for the new command buffer
+	if ( begin ) {
+		VkCommandBufferBeginInfo cmdBufInfo = ext::vulkan::initializers::commandBufferBeginInfo();
+		VK_CHECK_RESULT( vkBeginCommandBuffer( commandBuffer, &cmdBufInfo ) );
+	}
+	return commandBuffer;
+}
+
+void ext::vulkan::Device::flushCommandBuffer( VkCommandBuffer commandBuffer, bool free ) {
+	if ( commandBuffer == VK_NULL_HANDLE ) return;
+
+	VK_CHECK_RESULT( vkEndCommandBuffer( commandBuffer ) );
+
+	VkSubmitInfo submitInfo = ext::vulkan::initializers::submitInfo();
+	submitInfo.commandBufferCount = 1;
+	submitInfo.pCommandBuffers = &commandBuffer;
+
+	// Create fence to ensure that the command buffer has finished executing
+	VkFenceCreateInfo fenceInfo = ext::vulkan::initializers::fenceCreateInfo(VK_FLAGS_NONE);
+	VkFence fence;
+	VK_CHECK_RESULT(vkCreateFence(logicalDevice, &fenceInfo, nullptr, &fence));
+	
+	// Submit to the queue
+	VK_CHECK_RESULT(vkQueueSubmit( getQueue( QueueEnum::TRANSFER ), 1, &submitInfo, fence));
+	// vkQueueSubmit(device.queues.transfer, 1, &submitInfo, fence);
+	// Wait for the fence to signal that command buffer has finished executing
+	VK_CHECK_RESULT(vkWaitForFences(logicalDevice, 1, &fence, VK_TRUE, DEFAULT_FENCE_TIMEOUT));
+
+	vkDestroyFence(logicalDevice, fence, nullptr);
+
+	if ( free ) vkFreeCommandBuffers(logicalDevice, getCommandPool( QueueEnum::TRANSFER ), 1, &commandBuffer);
+}
+
+VkResult ext::vulkan::Device::createBuffer( VkBufferUsageFlags usage, VkMemoryPropertyFlags memoryProperties, VkDeviceSize size, VkBuffer* buffer, VkDeviceMemory* memory, void *data ) {
+	// Create the buffer handle
+	VkBufferCreateInfo bufferCreateInfo = ext::vulkan::initializers::bufferCreateInfo(usage, size);
+	bufferCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+	VK_CHECK_RESULT( vkCreateBuffer(logicalDevice, &bufferCreateInfo, nullptr, buffer));
+
+	// Create the memory backing up the buffer handle
+	VkMemoryRequirements memReqs;
+	VkMemoryAllocateInfo memAlloc = ext::vulkan::initializers::memoryAllocateInfo();
+	vkGetBufferMemoryRequirements(logicalDevice, *buffer, &memReqs);
+	memAlloc.allocationSize = memReqs.size;
+	// Find a memory type index that fits the properties of the buffer
+	memAlloc.memoryTypeIndex = getMemoryType(memReqs.memoryTypeBits, memoryProperties);
+
+	VK_CHECK_RESULT( vkAllocateMemory(logicalDevice, &memAlloc, nullptr, memory));
+	
+	// If a pointer to the buffer data has been passed, map the buffer and copy over the data
+	if ( data != nullptr ) {
+		void *mapped;
+		VK_CHECK_RESULT(vkMapMemory(logicalDevice, *memory, 0, size, 0, &mapped));
+			
+		memcpy(mapped, data, size);
+		// If host coherency hasn't been requested, do a manual flush to make writes visible
+		if ( (memoryProperties & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) == 0 ) {
+			VkMappedMemoryRange mappedRange = ext::vulkan::initializers::mappedMemoryRange();
+			mappedRange.memory = *memory;
+			mappedRange.offset = 0;
+			mappedRange.size = size;
+			vkFlushMappedMemoryRanges(logicalDevice, 1, &mappedRange);
+		}
+		vkUnmapMemory(logicalDevice, *memory);
+	}
+
+	// Attach the memory to the buffer object
+	VK_CHECK_RESULT(vkBindBufferMemory(logicalDevice, *buffer, *memory, 0));
+	return VK_SUCCESS;
+}
+
+VkResult ext::vulkan::Device::createBuffer(
+	VkBufferUsageFlags usage,
+	VkMemoryPropertyFlags memoryProperties,
+	ext::vulkan::Buffer& buffer,
+	VkDeviceSize size,
+	void *data
+) {
+	buffer.device = logicalDevice;
+	buffer.usage = usage;
+	buffer.memoryProperties = memoryProperties;
+
+	// Create the buffer handle
+	VkBufferCreateInfo bufferCreateInfo = ext::vulkan::initializers::bufferCreateInfo(usage, size);
+	buffer.allocate( bufferCreateInfo );
+
+/*
+//	VK_CHECK_RESULT(vkCreateBuffer(logicalDevice, &bufferCreateInfo, nullptr, &buffer.buffer));
+	// Create the memory backing up the buffer handle
+	VkMemoryRequirements memReqs;
+	VkMemoryAllocateInfo memAlloc = ext::vulkan::initializers::memoryAllocateInfo();
+	vkGetBufferMemoryRequirements(logicalDevice, buffer.buffer, &memReqs);
+	memAlloc.allocationSize = memReqs.size;
+	// Find a memory type index that fits the properties of the buffer
+	memAlloc.memoryTypeIndex = getMemoryType(memReqs.memoryTypeBits, memoryProperties);
+	VK_CHECK_RESULT(vkAllocateMemory(logicalDevice, &memAlloc, nullptr, &buffer.memory));
+
+	buffer.alignment = memReqs.alignment;
+	buffer.size = memAlloc.allocationSize;
+	buffer.usage = usage;
+	buffer.memoryProperties = memoryProperties;
+	buffer.memAlloc = memAlloc;
+	buffer.memReqs = memReqs;
+*/
+
+	// If a pointer to the buffer data has been passed, map the buffer and copy over the data
+
+	if (data != nullptr) {
+		VK_CHECK_RESULT(buffer.map());
+		memcpy(buffer.mapped, data, size);
+		if ((memoryProperties & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) == 0) buffer.flush();
+		buffer.unmap();
+	}
+
+
+	// Initialize a default descriptor that covers the whole buffer size
+	buffer.setupDescriptor();
+
+	// Attach the memory to the buffer object
+	return buffer.bind();
+}
+VkCommandPool& ext::vulkan::Device::getCommandPool( ext::vulkan::Device::QueueEnum queueEnum) {
+	return this->getCommandPool( queueEnum, std::this_thread::get_id() );
+}
+VkQueue& ext::vulkan::Device::getQueue( ext::vulkan::Device::QueueEnum queueEnum ) {
+	return this->getQueue( queueEnum, std::this_thread::get_id() );
+}
+VkCommandPool& ext::vulkan::Device::getCommandPool( ext::vulkan::Device::QueueEnum queueEnum, std::thread::id id ) {
+	uint32_t index = 0;
+	VkCommandPool* pool = NULL;
+	bool exists = false;
+	switch ( queueEnum ) {
+		case QueueEnum::GRAPHICS:
+			index = device.queueFamilyIndices.graphics;
+		//	if ( commandPool.graphics.count(id) > 0 ) exists = true;
+		//	pool = &commandPool.graphics[id];
+			exists = commandPool.graphics.has(id);
+			pool = &commandPool.graphics.get(id);
+		break;
+		case QueueEnum::COMPUTE:
+			index = device.queueFamilyIndices.compute;
+		//	if ( commandPool.compute.count(id) > 0 ) exists = true;
+		//	pool = &commandPool.compute[id];
+			exists = commandPool.compute.has(id);
+			pool = &commandPool.compute.get(id);
+		break;
+		case QueueEnum::TRANSFER:
+			index = device.queueFamilyIndices.transfer;
+		//	if ( commandPool.transfer.count(id) > 0 ) exists = true;
+		//	pool = &commandPool.transfer[id];
+			exists = commandPool.transfer.has(id);
+			pool = &commandPool.transfer.get(id);
+		break;
+	}
+	if ( !exists ) {
+		VkCommandPoolCreateFlags createFlags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
+		VkCommandPoolCreateInfo cmdPoolInfo = {};
+		cmdPoolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
+		cmdPoolInfo.queueFamilyIndex = index;
+		cmdPoolInfo.flags = createFlags;
+		if ( vkCreateCommandPool( this->logicalDevice, &cmdPoolInfo, nullptr, pool ) != VK_SUCCESS )
+			UF_EXCEPTION("failed to create command pool for graphics!");
+	}
+	return *pool;
+}
+VkQueue& ext::vulkan::Device::getQueue( ext::vulkan::Device::QueueEnum queueEnum, std::thread::id id ) {
+	uint32_t index = 0;
+	VkQueue* queue = NULL;
+	bool exists = false;
+	switch ( queueEnum ) {
+		case QueueEnum::GRAPHICS:
+			index = device.queueFamilyIndices.graphics;
+			exists = queues.graphics.has(id);
+			queue = &queues.graphics.get(id);
+		//	if ( queues.graphics.count(id) > 0 ) exists = true;
+		//	queue = &queues.graphics[id];
+		break;
+		case QueueEnum::PRESENT:
+			index = device.queueFamilyIndices.present;
+			exists = queues.present.has(id);
+			queue = &queues.present.get(id);
+		//	if ( queues.present.count(id) > 0 ) exists = true;
+		//	queue = &queues.present[id];
+		break;
+		case QueueEnum::COMPUTE:
+			index = device.queueFamilyIndices.compute;
+			exists = queues.compute.has(id);
+			queue = &queues.compute.get(id);
+		//	if ( queues.compute.count(id) > 0 ) exists = true;
+		//	queue = &queues.compute[id];
+		break;
+		case QueueEnum::TRANSFER:
+			index = device.queueFamilyIndices.transfer;
+			exists = queues.transfer.has(id);
+			queue = &queues.transfer.get(id);
+		//	if ( queues.transfer.count(id) > 0 ) exists = true;
+		//	queue = &queues.transfer[id];
+		break;
+	}
+	if ( !exists ) {
+		vkGetDeviceQueue( device, index, 0, queue );
+	}
+	return *queue;
+}
+
+void ext::vulkan::Device::initialize() {	
+	const std::vector<const char*> validationLayers = {
+		"VK_LAYER_KHRONOS_validation"
+	};
+	// Assert validation layers
+	if ( ext::vulkan::settings::validation ) {
+		uint32_t layerCount;
+		vkEnumerateInstanceLayerProperties(&layerCount, nullptr);
+		std::vector<VkLayerProperties> availableLayers(layerCount);
+		vkEnumerateInstanceLayerProperties(&layerCount, availableLayers.data());
+		for ( const char* layerName : validationLayers ) {
+			bool layerFound = false;
+			for ( const auto& layerProperties : availableLayers ) {
+				if ( strcmp(layerName, layerProperties.layerName) == 0 ) {
+					layerFound = true; break;
+				}
+			}
+			if ( !layerFound ) UF_EXCEPTION("validation layers requested, but not available!");
+		}
+	}
+	// 
+	// Get extensions
+	std::vector<std::string> requestedExtensions = window->getExtensions( ext::vulkan::settings::validation );
+	// Load any requested extensions
+	requestedExtensions.insert( requestedExtensions.end(), ext::vulkan::settings::requestedInstanceExtensions.begin(), ext::vulkan::settings::requestedInstanceExtensions.end() );
+#if UF_USE_OPENVR
+	// OpenVR Support
+	if ( ext::openvr::enabled ) VRInstanceExtensions(requestedExtensions);
+#endif
+	{
+		if ( ext::vulkan::settings::validation )
+			for ( auto ext : requestedExtensions )
+				uf::iostream << "Requested instance extension: " << ext << "\n";
+
+		uint32_t extensionsCount = 0;
+		uint32_t enabledExtensionsCount = 0;
+		
+		VK_CHECK_RESULT(vkEnumerateInstanceExtensionProperties( NULL, &extensionsCount, NULL ));
+		extensionProperties.instance.resize(extensionsCount);
+		VK_CHECK_RESULT( vkEnumerateInstanceExtensionProperties( NULL, &extensionsCount, extensionProperties.instance.data() ) );
+
+		validateRequestedExtensions( extensionProperties.instance, requestedExtensions, supportedExtensions.instance );
+	}
+	// Create instance
+	{
+		std::vector<const char*> instanceExtensions;
+		for ( auto& s : supportedExtensions.instance ) {
+			if ( ext::vulkan::settings::validation )
+				uf::iostream << "Enabled instance extension: " << s << "\n";
+			instanceExtensions.push_back( s.c_str() );
+		}
+
+		VkApplicationInfo appInfo = {};
+		appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
+		appInfo.pApplicationName = "Program";
+		appInfo.applicationVersion = VK_MAKE_VERSION(1, 2, 0);
+		appInfo.pEngineName = "Engine";
+		appInfo.engineVersion = VK_MAKE_VERSION(1, 2, 0);
+		appInfo.apiVersion = VK_API_VERSION_1_2;
+
+		VkInstanceCreateInfo createInfo = {};
+		createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
+		createInfo.pApplicationInfo = &appInfo;
+
+		createInfo.enabledExtensionCount = static_cast<uint32_t>(instanceExtensions.size());
+		createInfo.ppEnabledExtensionNames = instanceExtensions.data();
+
+		if ( ext::vulkan::settings::validation ) {
+			createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());
+			createInfo.ppEnabledLayerNames = validationLayers.data();
+		} else {
+			createInfo.enabledLayerCount = 0;
+		}
+
+		VK_CHECK_RESULT( vkCreateInstance( &createInfo, nullptr, &this->instance ));
+
+		{
+			ext::json::Value payload = ext::json::array();
+			for ( auto* c_str : instanceExtensions ) {
+				payload.emplace_back( std::string(c_str) );
+			}
+			uf::hooks.call("vulkan:Instance.ExtensionsEnabled", payload);
+		}
+	}
+	// Setup debug
+	if ( ext::vulkan::settings::validation ) {
+		VkDebugUtilsMessengerCreateInfoEXT createInfo = {};
+
+		createInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
+		createInfo.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
+		createInfo.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT;
+		createInfo.pfnUserCallback = ext::vulkan::debugCallback;
+		createInfo.pUserData = nullptr; // Optional
+
+		VK_CHECK_RESULT(CreateDebugUtilsMessengerEXT( this->instance, &createInfo, nullptr, &this->debugMessenger ));
+	}
+	// Create surface
+	{
+		window->createSurface( instance, surface );
+	}
+	// Create physical device
+	{
+		uint32_t deviceCount = 0;
+		vkEnumeratePhysicalDevices( this->instance, &deviceCount, nullptr );
+		if ( deviceCount == 0 ) UF_EXCEPTION("failed to find GPUs with Vulkan support!");
+
+		std::vector<VkPhysicalDevice> devices(deviceCount);
+		vkEnumeratePhysicalDevices( this->instance, &deviceCount, devices.data() );
+		// Use an ordered map to automatically sort candidates by increasing score
+		std::multimap<int, VkPhysicalDevice> candidates;
+		for ( const VkPhysicalDevice& device : devices ) {
+			int score = rate( device );
+			candidates.insert( std::make_pair(score, device) );
+		}
+		// Check if the best candidate is suitable at all
+		if ( candidates.rbegin()->first <= 0 ) UF_EXCEPTION("failed to find a suitable GPU!");
+		this->physicalDevice = candidates.rbegin()->second;
+	}
+	// Update properties
+	{
+		{
+			vkGetPhysicalDeviceProperties( this->physicalDevice, &properties );
+			// Features should be checked by the examples before using them
+			vkGetPhysicalDeviceFeatures( this->physicalDevice, &features );
+			// Memory properties are used regularly for creating all kinds of buffers
+			vkGetPhysicalDeviceMemoryProperties( this->physicalDevice, &memoryProperties );
+		}
+		{
+			properties2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
+			features2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
+			memoryProperties2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
+
+			vkGetPhysicalDeviceProperties2( this->physicalDevice, &properties2 );
+			// Features should be checked by the examples before using them
+			vkGetPhysicalDeviceFeatures2( this->physicalDevice, &features2 );
+			// Memory properties are used regularly for creating all kinds of buffers
+			vkGetPhysicalDeviceMemoryProperties2( this->physicalDevice, &memoryProperties2 );
+		}
+		// Queue family properties, used for setting up requested queues upon device creation
+		uint32_t queueFamilyCount;
+		vkGetPhysicalDeviceQueueFamilyProperties( this->physicalDevice, &queueFamilyCount, nullptr );
+		// assert(queueFamilyCount > 0);
+		queueFamilyProperties.resize(queueFamilyCount);
+		vkGetPhysicalDeviceQueueFamilyProperties( this->physicalDevice, &queueFamilyCount, queueFamilyProperties.data() );
+		{
+			VkSampleCountFlags counts = properties.limits.framebufferColorSampleCounts & properties.limits.framebufferDepthSampleCounts;
+			uint8_t maxSamples = 1;
+			if (counts & VK_SAMPLE_COUNT_64_BIT) maxSamples = 64;
+			else if (counts & VK_SAMPLE_COUNT_32_BIT) maxSamples = 32;
+			else if (counts & VK_SAMPLE_COUNT_16_BIT) maxSamples = 16;
+			else if (counts & VK_SAMPLE_COUNT_8_BIT) maxSamples = 8;
+			else if (counts & VK_SAMPLE_COUNT_4_BIT) maxSamples = 4;
+			else if (counts & VK_SAMPLE_COUNT_2_BIT) maxSamples = 2;
+			ext::vulkan::settings::msaa = std::min( maxSamples, ext::vulkan::settings::msaa );
+		}
+	}
+	// Create logical device
+	{
+		bool useSwapChain = true;
+		VkQueueFlags requestedQueueTypes = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT;
+		std::vector<std::string> requestedExtensions;
+		requestedExtensions.insert( requestedExtensions.end(), ext::vulkan::settings::requestedDeviceExtensions.begin(), ext::vulkan::settings::requestedDeviceExtensions.end() );
+	#if UF_USE_OPENVR		
+		// OpenVR Support
+		if ( ext::openvr::enabled ) {
+			VRDeviceExtensions( this->physicalDevice, requestedExtensions);
+		}
+	#endif
+		{
+			// Allocate enough ExtensionProperties to support all extensions being enabled
+			if ( ext::vulkan::settings::validation )
+				for ( auto ext : requestedExtensions ) uf::iostream << "Requested device extension: " << ext << "\n";
+
+			uint32_t extensionsCount = 0;
+			uint32_t enabledExtensionsCount = 0;
+			
+			VK_CHECK_RESULT(vkEnumerateDeviceExtensionProperties( this->physicalDevice, NULL, &extensionsCount, NULL ));
+			extensionProperties.device.resize( extensionsCount );
+			VK_CHECK_RESULT( vkEnumerateDeviceExtensionProperties( this->physicalDevice, NULL, &extensionsCount, extensionProperties.device.data() ) );
+			
+			validateRequestedExtensions( extensionProperties.device, requestedExtensions, supportedExtensions.device );
+		}
+		std::vector<const char*> deviceExtensions = {
+			VK_KHR_SWAPCHAIN_EXTENSION_NAME
+		};
+		for ( auto& s : supportedExtensions.device ) {
+			if ( ext::vulkan::settings::validation ) uf::iostream << "Enabled device extension: " << s << "\n";
+			deviceExtensions.push_back( s.c_str() );
+		}
+
+		// Desired queues need to be requested upon logical device creation
+		// Due to differing queue family configurations of Vulkan implementations this can be a bit tricky, especially if the application
+		// requests different queue types
+		std::vector<VkDeviceQueueCreateInfo> queueCreateInfos{};
+		// Get queue family indices for the requested queue family types
+		// Note that the indices may overlap depending on the implementation
+		const float defaultQueuePriority(0.0f);
+		// Graphics queue
+		if ( requestedQueueTypes & VK_QUEUE_GRAPHICS_BIT ) {
+			queueFamilyIndices.graphics = getQueueFamilyIndex(VK_QUEUE_GRAPHICS_BIT);
+			VkDeviceQueueCreateInfo queueInfo{};
+			queueInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+			queueInfo.queueFamilyIndex = queueFamilyIndices.graphics;
+			queueInfo.queueCount = 1;
+			queueInfo.pQueuePriorities = &defaultQueuePriority;
+			queueCreateInfos.push_back(queueInfo);
+		} else {
+			queueFamilyIndices.graphics = VK_NULL_HANDLE;
+		}
+		// Dedicated compute queue
+		if ( requestedQueueTypes & VK_QUEUE_COMPUTE_BIT ) {
+			queueFamilyIndices.compute = getQueueFamilyIndex(VK_QUEUE_COMPUTE_BIT);
+			if ( queueFamilyIndices.compute != queueFamilyIndices.graphics ) {
+				// If compute family index differs, we need an additional queue create info for the compute queue
+				VkDeviceQueueCreateInfo queueInfo{};
+				queueInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+				queueInfo.queueFamilyIndex = queueFamilyIndices.compute;
+				queueInfo.queueCount = 1;
+				queueInfo.pQueuePriorities = &defaultQueuePriority;
+				queueCreateInfos.push_back(queueInfo);
+			}
+		} else {
+			// Else we use the same queue
+			queueFamilyIndices.compute = queueFamilyIndices.graphics;
+		}
+		// Dedicated transfer queue
+		if ( requestedQueueTypes & VK_QUEUE_TRANSFER_BIT ) {
+			queueFamilyIndices.transfer = getQueueFamilyIndex(VK_QUEUE_TRANSFER_BIT);
+			if ((queueFamilyIndices.transfer != queueFamilyIndices.graphics) && (queueFamilyIndices.transfer != queueFamilyIndices.compute)) {
+				// If compute family index differs, we need an additional queue create info for the compute queue
+				VkDeviceQueueCreateInfo queueInfo{};
+				queueInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+				queueInfo.queueFamilyIndex = queueFamilyIndices.transfer;
+				queueInfo.queueCount = 1;
+				queueInfo.pQueuePriorities = &defaultQueuePriority;
+				queueCreateInfos.push_back(queueInfo);
+			}
+		} else {
+			// Else we use the same queue
+			queueFamilyIndices.transfer = queueFamilyIndices.graphics;
+		}
+
+		// Create the logical device representation
+		if ( useSwapChain ) {
+			// If the device will be used for presenting to a display via a swapchain we need to request the swapchain extension
+			deviceExtensions.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+		}
+
+		enableRequestedDeviceFeatures( *this );
+
+		VkDeviceCreateInfo deviceCreateInfo = {};
+		deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
+		deviceCreateInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());;
+		deviceCreateInfo.pQueueCreateInfos = queueCreateInfos.data();
+		deviceCreateInfo.pEnabledFeatures = &enabledFeatures;
+
+		if ( deviceExtensions.size() > 0 ) {
+			deviceCreateInfo.enabledExtensionCount = (uint32_t) deviceExtensions.size();
+			deviceCreateInfo.ppEnabledExtensionNames = deviceExtensions.data();
+		}
+
+		if ( vkCreateDevice( this->physicalDevice, &deviceCreateInfo, nullptr, &this->logicalDevice) != VK_SUCCESS )
+			UF_EXCEPTION("failed to create logical device!"); 
+
+		
+
+		{
+			uf::Serializer payload = ext::json::array();
+			for ( auto* c_str : deviceExtensions ) {
+				payload.emplace_back( std::string(c_str) );
+			}
+			uf::hooks.call("vulkan:Device.ExtensionsEnabled", payload);
+		}
+		{
+			uf::Serializer payload = retrieveDeviceFeatures( *this );
+			if ( ext::vulkan::settings::validation ) uf::iostream << payload.dump() << "\n";
+			uf::hooks.call("vulkan:Device.FeaturesEnabled", payload);
+		}
+	}
+	// Create command pool
+	getCommandPool( QueueEnum::GRAPHICS );
+	getCommandPool( QueueEnum::COMPUTE );
+	getCommandPool( QueueEnum::TRANSFER );
+	// Set queue
+	{
+		uint32_t graphicsQueueNodeIndex = UINT32_MAX;
+		uint32_t presentQueueNodeIndex = UINT32_MAX;
+		uint32_t computeQueueNodeIndex = UINT32_MAX;
+		uint32_t transferQueueNodeIndex = UINT32_MAX;
+
+		int i = 0;
+		for (const auto& queueFamily : queueFamilyProperties) {
+			if ( queueFamily.queueCount > 0 && queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT )
+				graphicsQueueNodeIndex = i;
+
+			if ( queueFamily.queueCount > 0 && queueFamily.queueFlags & VK_QUEUE_COMPUTE_BIT )
+				computeQueueNodeIndex = i;
+
+			if ( queueFamily.queueCount > 0 && queueFamily.queueFlags & VK_QUEUE_TRANSFER_BIT )
+				transferQueueNodeIndex = i;
+
+			VkBool32 presentSupport = false;
+			vkGetPhysicalDeviceSurfaceSupportKHR( this->physicalDevice, i, surface, &presentSupport );
+			if ( queueFamily.queueCount > 0 && presentSupport )
+				presentQueueNodeIndex = i;
+
+			if ( graphicsQueueNodeIndex != UINT32_MAX && presentQueueNodeIndex != UINT32_MAX && computeQueueNodeIndex != UINT32_MAX ) break;
+
+			i++;
+		}
+
+		device.queueFamilyIndices.present = presentQueueNodeIndex;
+		getQueue( QueueEnum::GRAPHICS );
+		getQueue( QueueEnum::PRESENT );
+		getQueue( QueueEnum::COMPUTE );
+		getQueue( QueueEnum::TRANSFER );
+	/*
+		vkGetDeviceQueue( device, device.queueFamilyIndices.graphics, 0, &queues.graphics[std::this_thread::get_id()] );
+		vkGetDeviceQueue( device, device.queueFamilyIndices.present, 0, &queues.present[std::this_thread::get_id()] );
+		vkGetDeviceQueue( device, device.queueFamilyIndices.compute, 0, &queues.compute[std::this_thread::get_id()] );
+		vkGetDeviceQueue( device, device.queueFamilyIndices.transfer, 0, &queues.transfer[std::this_thread::get_id()] );
+	*/
+	}
+	// Set formats
+	{
+		std::vector<VkSurfaceFormatKHR> formats;
+		uint32_t formatCount; vkGetPhysicalDeviceSurfaceFormatsKHR( this->physicalDevice, device.surface, &formatCount, nullptr);
+		formats.resize( formatCount );
+		vkGetPhysicalDeviceSurfaceFormatsKHR( this->physicalDevice, device.surface, &formatCount, formats.data() );
+		// If the surface format list only includes one entry with VK_FORMAT_UNDEFINED,
+		// there is no preferered format, so we assume VK_FORMAT_B8G8R8A8_UNORM
+		if ( (formatCount == 1) && (formats[0].format == VK_FORMAT_UNDEFINED) ) {
+			ext::vulkan::settings::formats::color = VK_FORMAT_B8G8R8A8_UNORM;
+			ext::vulkan::settings::formats::colorSpace = formats[0].colorSpace;
+		} else {
+			// iterate over the list of available surface format and
+			// check for the presence of VK_FORMAT_B8G8R8A8_UNORM
+			bool found = false;
+			for ( auto&& surfaceFormat : formats ) {
+				if ( surfaceFormat.format == ext::vulkan::settings::formats::color ) {
+					ext::vulkan::settings::formats::color = surfaceFormat.format;
+					ext::vulkan::settings::formats::colorSpace = surfaceFormat.colorSpace;
+					found = true;
+					break;
+				}
+			}
+			if ( !found ) {
+				for ( auto&& surfaceFormat : formats ) {
+					if ( surfaceFormat.format == VK_FORMAT_B8G8R8A8_UNORM ) {
+						ext::vulkan::settings::formats::color = surfaceFormat.format;
+						ext::vulkan::settings::formats::colorSpace = surfaceFormat.colorSpace;
+						found = true;
+						break;
+					}
+				}
+				// in case VK_FORMAT_B8G8R8A8_UNORM is not available
+				// select the first available color format
+				if ( !found ) {
+					ext::vulkan::settings::formats::color = formats[0].format;
+					ext::vulkan::settings::formats::colorSpace = formats[0].colorSpace;
+				}
+			}
+		}
+	}
+	// Grab depth/stencil format
+	{
+		// Since all depth formats may be optional, we need to find a suitable depth format to use
+		// Start with the highest precision packed format
+		std::vector<VkFormat> depthFormats = {
+			VK_FORMAT_D32_SFLOAT_S8_UINT,
+			VK_FORMAT_D32_SFLOAT,
+			VK_FORMAT_D24_UNORM_S8_UINT,
+			VK_FORMAT_D16_UNORM_S8_UINT,
+			VK_FORMAT_D16_UNORM,
+			ext::vulkan::settings::formats::depth
+		};
+
+		for ( auto& format : depthFormats ) {
+			VkFormatProperties formatProps;
+			vkGetPhysicalDeviceFormatProperties( this->physicalDevice, format, &formatProps );
+			// Format must support depth stencil attachment for optimal tiling
+			if (formatProps.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) {
+				ext::vulkan::settings::formats::depth = format;
+			}
+		}
+	}
+	// create pipeline cache
+	{
+		VkPipelineCacheCreateInfo pipelineCacheCreateInfo = {};
+		pipelineCacheCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
+		VK_CHECK_RESULT(vkCreatePipelineCache( device, &pipelineCacheCreateInfo, nullptr, &this->pipelineCache));
+	}
+	// setup allocator
+	{
+		VmaAllocatorCreateInfo allocatorInfo = {};
+		allocatorInfo.vulkanApiVersion = VK_API_VERSION_1_2;
+		allocatorInfo.physicalDevice = physicalDevice;
+		allocatorInfo.instance = instance;
+		allocatorInfo.device = logicalDevice;
+		vmaCreateAllocator(&allocatorInfo, &allocator);
+	}
+}
+
+void ext::vulkan::Device::destroy() {
+	if ( this->pipelineCache ) {
+		vkDestroyPipelineCache( this->logicalDevice, this->pipelineCache, nullptr );
+		this->pipelineCache = nullptr;
+	}
+	for ( auto& pair : this->commandPool.graphics.container() ) {
+		vkDestroyCommandPool( this->logicalDevice, pair.second, nullptr );
+		pair.second = VK_NULL_HANDLE;
+	}
+	for ( auto& pair : this->commandPool.compute.container() ) {
+		vkDestroyCommandPool( this->logicalDevice, pair.second, nullptr );
+		pair.second = VK_NULL_HANDLE;
+	}
+	for ( auto& pair : this->commandPool.transfer.container() ) {
+		vkDestroyCommandPool( this->logicalDevice, pair.second, nullptr );
+		pair.second = VK_NULL_HANDLE;
+	}
+	if ( this->logicalDevice ) {
+		vkDestroyDevice( this->logicalDevice, nullptr );
+		this->logicalDevice = nullptr;
+	}
+	if ( this->surface ) {
+		vkDestroySurfaceKHR( this->instance, this->surface, nullptr );
+		this->surface = nullptr;
+	}
+	if ( this->debugMessenger ) {
+		DestroyDebugUtilsMessengerEXT( this->instance, this->debugMessenger, nullptr );
+		this->debugMessenger = nullptr;
+	}
+	if ( this->instance ) {
+		vkDestroyInstance( this->instance, nullptr );
+		this->instance = nullptr;
+	}
+/*
+	vmaDestroyAllocator( allocator );
+*/
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/vulkan/graphic.cpp b/engine/src/ext/vulkan/graphic.cpp
new file mode 100644
index 00000000..429de986
--- /dev/null
+++ b/engine/src/ext/vulkan/graphic.cpp
@@ -0,0 +1,1704 @@
+#if UF_USE_VULKAN
+
+#include <uf/ext/vulkan/graphic.h>
+#include <uf/ext/vulkan/initializers.h>
+#include <uf/ext/vulkan/vulkan.h>
+#include <uf/ext/openvr/openvr.h>
+
+#include <spirv_cross/spirv_cross.hpp>
+#include <spirv_cross/spirv_glsl.hpp>
+#include <fstream>
+#include <regex>
+
+#define VK_DEBUG_VALIDATION_MESSAGE(x)\
+	//VK_VALIDATION_MESSAGE(x);
+
+namespace {
+	uint32_t VERTEX_BUFFER_BIND_ID = 0;
+}
+ext::json::Value ext::vulkan::definitionToJson(/*const*/ ext::json::Value& definition ) {
+	ext::json::Value member;
+	// is object
+	if ( !ext::json::isNull(definition["members"]) ) {
+		ext::json::forEach(definition["members"], [&](/*const*/ ext::json::Value& value){
+			std::string key = uf::string::split(value["name"].as<std::string>(), " ").back();
+			member[key] = ext::vulkan::definitionToJson(value);
+		});
+	// is primitive
+	} else if ( !ext::json::isNull(definition["value"]) ) {
+		// is array of structs
+		if ( definition["struct"].as<bool>() ) {
+			ext::json::forEach(definition["value"], [&](/*const*/ ext::json::Value& value){
+				ext::json::Value parsed;
+				parsed["name"] = definition["name"];
+				parsed["size"] = definition["size"];
+				parsed["struct"] = definition["struct"];
+				parsed["members"] = value;
+				parsed = ext::vulkan::definitionToJson(parsed);
+				member.emplace_back(parsed);
+			});
+		} else {
+			member = definition["value"];
+		}
+	}
+	return member;
+}
+ext::vulkan::userdata_t ext::vulkan::jsonToUserdata( const ext::json::Value& payload, const ext::json::Value& definition ) {
+	size_t bufferLen = definition["size"].as<size_t>();
+	
+	ext::vulkan::userdata_t userdata;
+	userdata.create(bufferLen);
+
+	uint8_t* byteBuffer = (uint8_t*) (void*) userdata;
+	uint8_t* byteBufferStart = byteBuffer;
+	uint8_t* byteBufferEnd = byteBuffer + bufferLen;
+
+#if UF_JSON_NLOHMANN_ORDERED
+	// JSON is ordered, we can just push directly
+#define UF_SHADER_TRACK_NAMES 0
+#if UF_SHADER_TRACK_NAMES
+	std::vector<std::string> variableName;	
+#endif
+	std::function<void(const ext::json::Value&)> parse = [&]( const ext::json::Value& value ){
+		// is array or object
+	#if UF_SHADER_TRACK_NAMES
+		if ( ext::json::isObject(value) ) {
+			ext::json::forEach(value, [&]( const std::string& name, const ext::json::Value& member ){
+			#if UF_SHADER_TRACK_NAMES
+				variableName.emplace_back(name);
+			#endif
+				parse(member);
+			});
+			#if UF_SHADER_TRACK_NAMES
+				if ( !variableName.empty() ) variableName.pop_back();
+			#endif
+			return;
+		}
+		if ( ext::json::isArray(value) ) {
+			ext::json::forEach(value, [&]( size_t i, const ext::json::Value& element ){
+				variableName.emplace_back("["+std::to_string(i)+"]");
+				parse(element);
+			});
+			#if UF_SHADER_TRACK_NAMES
+				if ( !variableName.empty() ) variableName.pop_back();
+			#endif
+			return;
+		}
+	#else
+		if ( ext::json::isArray(value) || ext::json::isObject(value) ) {
+			ext::json::forEach(value, parse);
+			return;
+		}
+	#endif
+	#if UF_SHADER_TRACK_NAMES
+		std::string path = uf::string::join(variableName, ".");
+		path = uf::string::replace( path, ".[", "[" );
+		VK_VALIDATION_MESSAGE("[" << (byteBuffer - byteBufferStart) << " / "<< (byteBufferEnd - byteBuffer) <<"]\tInserting: " << path << " = " << value.dump());
+	#endif
+		// is strictly an int
+		if ( value.is<int>(true) ) {
+			size_t size = sizeof(int32_t);
+			auto get = value.as<int32_t>();
+			memcpy( byteBuffer, &get, size );
+			byteBuffer += size;
+		// is strictly an unsigned int
+		} else if ( value.is<size_t>(true) ) {
+			size_t size = sizeof(uint32_t);
+			auto get = value.as<uint32_t>();
+			memcpy( byteBuffer, &get, size );
+			byteBuffer += size;
+		// is strictly a float
+		} else if ( value.is<float>(true) ) {
+			size_t size = sizeof(float);
+			auto get = value.as<float>();
+			memcpy( byteBuffer, &get, size );
+			byteBuffer += size;
+		}
+	#if UF_SHADER_TRACK_NAMES
+		if ( !variableName.empty() ) variableName.pop_back();
+	#endif
+	};
+#if UF_SHADER_TRACK_NAMES
+	VK_VALIDATION_MESSAGE("Updating " << name << " in " << filename);
+	VK_VALIDATION_MESSAGE("Iterator: " << (void*) byteBuffer << "\t" << (void*) byteBufferEnd << "\t" << (byteBufferEnd - byteBuffer));
+#endif
+	parse(payload);
+#if UF_SHADER_TRACK_NAMES
+	VK_VALIDATION_MESSAGE("Iterator: " << (void*) byteBuffer << "\t" << (void*) byteBufferEnd << "\t" << (byteBufferEnd - byteBuffer));
+#endif
+#else
+	auto pushValue = [&]( const std::string& primitive, const ext::json::Value& input ){
+		if ( primitive == "bool" ) {
+			size_t size = sizeof(bool); // v["size"].as<size_t>();
+			if ( byteBufferEnd < byteBuffer + size ) return false; // overflow
+			auto get = input.as<bool>();
+			memcpy( byteBuffer, &get, size );
+			byteBuffer += size;
+		} else if ( primitive == "int8_t" ) {
+			size_t size = sizeof(int8_t); // v["size"].as<size_t>();
+			if ( byteBufferEnd < byteBuffer + size ) return false; // overflow
+	
+		//	auto get = input.as<int8_t>();
+		//	memcpy( byteBuffer, &get, size );
+			byteBuffer += size;
+		} else if ( primitive == "uint8_t" ) {
+			size_t size = sizeof(uint8_t); // v["size"].as<size_t>();
+			if ( byteBufferEnd < byteBuffer + size ) return false; // overflow
+		//	auto get = input.as<uint8_t>();
+		//	memcpy( byteBuffer, &get, size );
+			byteBuffer += size;
+		} else if ( primitive == "int16_t" ) {
+			size_t size = sizeof(int16_t); // v["size"].as<size_t>();
+			if ( byteBufferEnd < byteBuffer + size ) return false; // overflow
+		//	auto get = input.as<int16_t>();
+		//	memcpy( byteBuffer, &get, size );
+			byteBuffer += size;
+		} else if ( primitive == "uint16_t" ) {
+			size_t size = sizeof(uint16_t); // v["size"].as<size_t>();
+			if ( byteBufferEnd < byteBuffer + size ) return false; // overflow
+		//	auto get = input.as<uint16_t>();
+		//	memcpy( byteBuffer, &get, size );
+			byteBuffer += size;
+		} else if ( primitive == "int32_t" ) {
+			size_t size = sizeof(int32_t); // v["size"].as<size_t>();
+			if ( byteBufferEnd < byteBuffer + size ) return false; // overflow
+			auto get = input.as<int32_t>();
+			memcpy( byteBuffer, &get, size );
+			byteBuffer += size;
+		}
+ else if ( primitive == "uint32_t" ) {
+			size_t size = sizeof(uint32_t); // v["size"].as<size_t>();
+			if ( byteBufferEnd < byteBuffer + size ) return false; // overflow
+			auto get = input.as<int32_t>();
+			memcpy( byteBuffer, &get, size );
+			byteBuffer += size;
+		} else if ( primitive == "int64_t" ) {
+			size_t size = sizeof(int64_t); // v["size"].as<size_t>();
+			if ( byteBufferEnd < byteBuffer + size ) return false; // overflow
+			auto get = input.as<uint64_t>();
+			memcpy( byteBuffer, &get, size );
+			byteBuffer += size;
+		} else if ( primitive == "uint64_t" ) {
+			size_t size = sizeof(uint64_t); // v["size"].as<size_t>();
+			if ( byteBufferEnd < byteBuffer + size ) return false; // overflow
+			auto get = input.as<uint64_t>();
+			memcpy( byteBuffer, &get, size );
+			byteBuffer += size;
+		} else if ( primitive == "half" ) {
+			size_t size = sizeof(float); // v["size"].as<size_t>();
+			if ( byteBufferEnd < byteBuffer + size ) return false; // overflow
+		//	auto get = input.as<float>();
+		//	memcpy( byteBuffer, &get, size );
+			byteBuffer += size;
+		} else if ( primitive == "float" ) {
+			size_t size = sizeof(float); // v["size"].as<size_t>();
+			if ( byteBufferEnd < byteBuffer + size ) return false; // overflow
+			auto get = input.as<float>();
+			memcpy( byteBuffer, &get, size );
+			byteBuffer += size;
+		} else if ( primitive == "double" ) {
+			auto get = input.as<double>();
+			size_t size = sizeof(double); // v["size"].as<size_t>();
+			if ( byteBufferEnd < byteBuffer + size ) return false; // overflow
+			memcpy( byteBuffer, &get, size );
+			byteBuffer += size;
+		}
+		return true;
+	};
+	#define UF_SHADER_TRACK_NAMES 0
+	#if UF_SHADER_TRACK_NAMES
+		bool SKIP_ADD = false;
+		std::vector<std::string> variableName;
+	#endif
+	std::function<void(const ext::json::Value&, const ext::json::Value&)> parseDefinition = [&](const ext::json::Value& input, const ext::json::Value& definition ){
+	#if UF_SHADER_TRACK_NAMES
+		if ( SKIP_ADD ) {
+			SKIP_ADD = false;
+		} else {
+			auto split = uf::string::split(definition["name"].as<std::string>(), " ");
+			std::string type = split.front();
+			std::string name = split.back();
+			variableName.emplace_back(name);
+		}
+	#endif
+		// is object
+		if ( !ext::json::isNull(definition["members"]) ) {
+			ext::json::forEach(definition["members"], [&](const ext::json::Value& member){
+				std::string key = uf::string::split(member["name"].as<std::string>(), " ").back();
+				parseDefinition(input[key], member);
+			});
+		// is array or primitive
+		} else if ( !ext::json::isNull(definition["value"]) ) {
+			// is object
+			auto split = uf::string::split(definition["name"].as<std::string>(), " ");
+			std::string type = split.front();
+			std::string name = split.back();
+			std::regex regex("^(?:(.+?)\\<)?(.+?)(?:\\>)?(?:\\[(\\d+)\\])?$");
+			std::smatch match;
+			if ( !std::regex_search( type, match, regex ) ) {
+				std::cout << "Ill formatted typename: " << definition["name"].as<std::string>() << std::endl;
+				return;
+			}
+			std::string vectorMatrix = match[1].str();
+			std::string primitive = match[2].str();
+			std::string arraySize = match[3].str();	
+			if ( ext::json::isObject(input) ) {
+				ext::json::Value cloned;
+				cloned["name"] = definition["name"];
+				cloned["size"] = definition["size"].as<size_t>() / definition["value"].size();
+				cloned["members"] = definition["value"][0];
+				parseDefinition( input, cloned );
+			}
+			// is array
+			else if ( ext::json::isArray(input) ) {
+				ext::json::forEach( input, [&]( size_t i, const ext::json::Value& value){
+				#if UF_SHADER_TRACK_NAMES
+					variableName.emplace_back("["+std::to_string(i)+"]");
+					SKIP_ADD = true;
+				#endif
+					parseDefinition(input[i], definition);
+				});
+			}
+			// is primitive
+			else {
+			#if UF_SHADER_TRACK_NAMES
+				std::string path = uf::string::join(variableName, ".");
+				path = uf::string::replace( path, ".[", "[" );
+				VK_VALIDATION_MESSAGE("[" << (byteBuffer - byteBufferStart) << " / "<< (byteBufferEnd - byteBuffer) <<"]\tInserting: " << path << " = (" << primitive << ") " << input.dump());
+			#endif
+				pushValue( primitive, input );
+			}
+		}
+	#if UF_SHADER_TRACK_NAMES
+		if ( !variableName.empty() ) variableName.pop_back();
+	#endif
+	};
+	auto& definitions = metadata["definitions"]["uniforms"][name];
+#if UF_SHADER_TRACK_NAMES
+	VK_VALIDATION_MESSAGE("Updating " << name << " in " << filename);
+	VK_VALIDATION_MESSAGE("Iterator: " << (void*) byteBuffer << "\t" << (void*) byteBufferEnd << "\t" << (byteBufferEnd - byteBuffer));
+#endif
+	parseDefinition(payload, definitions);
+#if UF_SHADER_TRACK_NAMES
+	VK_VALIDATION_MESSAGE("Iterator: " << (void*) byteBuffer << "\t" << (void*) byteBufferEnd << "\t" << (byteBufferEnd - byteBuffer));
+#endif
+#endif
+	return userdata;
+}
+/*
+ext::vulkan::Shader::~Shader() {
+	if ( !aliased ) destroy();
+}
+*/
+void ext::vulkan::Shader::initialize( ext::vulkan::Device& device, const std::string& filename, VkShaderStageFlagBits stage ) {
+	this->device = &device;
+	ext::vulkan::Buffers::initialize( device );
+	aliased = false;
+	
+	std::string spirv;
+	
+	{
+		std::ifstream is(this->filename = filename, std::ios::binary | std::ios::in | std::ios::ate);
+		if ( !is.is_open() ) {
+			VK_VALIDATION_MESSAGE("Error: Could not open shader file \"" << filename << "\"");
+			return;
+		}
+		is.seekg(0, std::ios::end); spirv.reserve(is.tellg()); is.seekg(0, std::ios::beg);
+		spirv.assign((std::istreambuf_iterator<char>(is)), std::istreambuf_iterator<char>());
+	
+		assert(spirv.size() > 0);
+	}
+	
+	{
+	
+		VkShaderModuleCreateInfo moduleCreateInfo = {};
+		moduleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+		moduleCreateInfo.codeSize = spirv.size();
+		moduleCreateInfo.pCode = (uint32_t*) spirv.data();
+
+		VK_CHECK_RESULT(vkCreateShaderModule(device, &moduleCreateInfo, NULL, &module));
+	}
+	
+	{
+		descriptor.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+		descriptor.stage = stage;
+		descriptor.module = module;
+		descriptor.pName = "main";
+
+		assert(descriptor.module != VK_NULL_HANDLE);
+	}
+	// set up metadata
+	{
+		metadata["filename"] = filename;
+		metadata["type"] = "";
+	}
+	// do reflection
+	{
+		spirv_cross::Compiler comp( (uint32_t*) &spirv[0], spirv.size() / 4 );
+		spirv_cross::ShaderResources res = comp.get_shader_resources();
+
+		std::function<ext::json::Value(spirv_cross::TypeID)> parseMembers = [&]( spirv_cross::TypeID type_id ) {
+			auto parseMember = [&]( auto type_id ){
+				uf::Serializer payload;
+				
+				auto type = comp.get_type(type_id);
+
+				std::string name = "";
+				size_t size = 1;
+				ext::json::Value value;
+				switch ( type.basetype ) {
+					case spirv_cross::SPIRType::BaseType::Boolean: 		name = "bool"; 		size = sizeof(bool); 		value = (bool) 0; 		break;
+					case spirv_cross::SPIRType::BaseType::SByte: 		name = "int8_t"; 	size = sizeof(int8_t); 		value = (int8_t) 0; 	break;
+					case spirv_cross::SPIRType::BaseType::UByte: 		name = "uint8_t"; 	size = sizeof(uint8_t); 	value = (uint8_t) 0; 	break;
+					case spirv_cross::SPIRType::BaseType::Short: 		name = "int16_t"; 	size = sizeof(int16_t); 	value = (int16_t) 0; 	break;
+					case spirv_cross::SPIRType::BaseType::UShort: 		name = "uint16_t";	size = sizeof(uint16_t); 	value = (uint16_t) 0; 	break;
+					case spirv_cross::SPIRType::BaseType::Int: 			name = "int32_t"; 	size = sizeof(int32_t); 	value = (int32_t) 0; 	break;
+					case spirv_cross::SPIRType::BaseType::UInt: 		name = "uint32_t";	size = sizeof(uint32_t); 	value = (uint32_t) 0; 	break;
+					case spirv_cross::SPIRType::BaseType::Int64: 		name = "int64_t"; 	size = sizeof(int64_t); 	value = (int64_t) 0; 	break;
+					case spirv_cross::SPIRType::BaseType::UInt64: 		name = "uint64_t";	size = sizeof(uint64_t); 	value = (uint64_t) 0; 	break;
+					case spirv_cross::SPIRType::BaseType::Half: 		name = "half"; 		size = sizeof(float)/2; 	value = (float) 0; 		break;
+					case spirv_cross::SPIRType::BaseType::Float: 		name = "float"; 	size = sizeof(float); 		value = (float) 0; 		break;
+					case spirv_cross::SPIRType::BaseType::Double: 		name = "double"; 	size = sizeof(double); 		value = (double) 0; 		break;
+					case spirv_cross::SPIRType::BaseType::Image: 		name = "image2D"; 	break;
+					case spirv_cross::SPIRType::BaseType::SampledImage: name = "sampler2D"; break;
+					case spirv_cross::SPIRType::BaseType::Sampler: 		name = "sampler"; 	break;
+					default:
+						name = comp.get_name(type_id);
+						size = comp.get_declared_struct_size(type);
+					break;
+				}
+				if ( name == "" ) name = comp.get_name(type.type_alias);
+				if ( name == "" ) name = comp.get_name(type.type_alias);
+				if ( name == "" ) name = comp.get_name(type.parent_type);
+				if ( name == "" ) name = comp.get_fallback_name(type_id);
+				if ( type.vecsize > 1 ) {
+					name = "<"+name+">";
+					if ( type.columns > 1 ) {
+						name = "Matrix"+std::to_string(type.vecsize)+"x"+std::to_string(type.columns)+name;
+					} else {
+						name = "Vector"+std::to_string(type.vecsize)+name;
+					}
+				}
+				{
+					ext::json::Value source = value;
+					value = ext::json::array();
+					for ( size_t i = 0; i < type.vecsize * type.columns; ++i ) {
+						value.emplace_back(source);
+					}
+					size *= type.columns * type.vecsize;
+				}
+				for ( auto arraySize : type.array ) {
+					if ( arraySize > 1 ) {
+						ext::json::Value source = value;
+						value = ext::json::array();
+						for ( size_t i = 0; i < arraySize; ++i ) {
+							value.emplace_back(source);
+						}
+						name += "[" + std::to_string(arraySize) + "]";
+						size *= arraySize;
+					}
+				}
+				if ( ext::json::isArray(value) && value.size() == 1 ) {
+					value = value[0];
+				}
+				payload["name"] = name;
+				payload["size"] = size;
+				payload["value"] = value;
+				return payload;
+			};
+			uf::Serializer payload = ext::json::array();
+			const auto& type = comp.get_type(type_id);
+			for ( auto& member_type_id : type.member_types ) {
+				const auto& member_type = comp.get_type(member_type_id);
+				std::string name = comp.get_member_name(type.type_alias, payload.size());
+				if ( name == "" ) name = comp.get_member_name(type.parent_type, payload.size());
+				if ( name == "" ) name = comp.get_member_name(type_id, payload.size());
+				
+				auto& entry = payload.emplace_back();
+				auto parsed = parseMember(member_type_id);
+				std::string type_name = parsed["name"];
+				entry["name"] = type_name + " " + name; 
+				if ( member_type.basetype == spirv_cross::SPIRType::BaseType::Struct ) {
+					entry["struct"] = true;
+					auto parsed = parseMembers(member_type_id);
+					if ( !member_type.array.empty() && member_type.array[0] > 1 ) {
+						size_t size = comp.get_declared_struct_size(member_type);
+						for ( auto arraySize : member_type.array ) {
+							ext::json::Value source = parsed;
+							parsed = ext::json::array();
+							for ( size_t i = 0; i < arraySize; ++i ) {
+								parsed.emplace_back(source);
+							}
+							size = size * arraySize;
+						}
+						entry["size"] = size;
+						entry["value"] = parsed;
+					} else {
+						entry["size"] = comp.get_declared_struct_size(member_type);
+						entry["members"] = parsed;
+					}
+				} else {
+					entry["size"] = parsed["size"];
+					entry["value"] = parsed["value"];
+				}
+			}
+			return payload;
+		};
+
+		auto parseResource = [&]( const spirv_cross::Resource& resource, VkDescriptorType descriptorType, size_t index ) {			
+			const auto& type = comp.get_type(resource.type_id);
+			const auto& base_type = comp.get_type(resource.base_type_id);
+			std::string name = resource.name;
+			size_t arraySize = 1;
+			if ( !type.array.empty() ) {
+				arraySize = type.array[0];
+			}
+			
+			switch ( descriptorType ) {
+				case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+				case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+				case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: {
+					std::string tname = "";
+					switch ( type.image.dim ) {
+						case spv::Dim::Dim1D: tname = "1D"; break;
+						case spv::Dim::Dim2D: tname = "2D"; break;
+						case spv::Dim::Dim3D: tname = "3D"; break;
+						case spv::Dim::DimCube: tname = "Cube"; break;
+						case spv::Dim::DimRect: tname = "Rect"; break;
+						case spv::Dim::DimBuffer: tname = "Buffer"; break;
+						case spv::Dim::DimSubpassData: tname = "SubpassData"; break;
+
+					}
+					size_t binding = comp.get_decoration(resource.id, spv::DecorationBinding);
+					std::string key = std::to_string(binding);
+					metadata["definitions"]["textures"][key]["name"] = name;
+					metadata["definitions"]["textures"][key]["index"] = index;
+					metadata["definitions"]["textures"][key]["binding"] = binding;
+					metadata["definitions"]["textures"][key]["size"] = arraySize;
+					metadata["definitions"]["textures"][key]["type"] = tname;
+				} break;
+				case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: {
+					size_t bufferSize = comp.get_declared_struct_size(base_type);
+					if ( bufferSize <= 0 ) break;
+					if ( bufferSize > device.properties.limits.maxUniformBufferRange ) {
+						VK_DEBUG_VALIDATION_MESSAGE("Invalid uniform buffer length of " << bufferSize << " for shader " << filename);
+						bufferSize = device.properties.limits.maxUniformBufferRange;
+					}
+					size_t misalignment = bufferSize % device.properties.limits.minStorageBufferOffsetAlignment;
+					if ( misalignment != 0 ) {
+						VK_DEBUG_VALIDATION_MESSAGE("Invalid uniform buffer alignment of " << misalignment << " for shader " << filename << ", correcting...");
+						bufferSize += misalignment;
+					}
+					{
+						VK_DEBUG_VALIDATION_MESSAGE("Uniform size of " << bufferSize << " for shader " << filename);
+						auto& uniform = uniforms.emplace_back();
+						uniform.create( bufferSize );
+					}		
+					// generate definition to JSON
+					{
+						metadata["definitions"]["uniforms"][name]["name"] = name;
+						metadata["definitions"]["uniforms"][name]["index"] = index;
+						metadata["definitions"]["uniforms"][name]["size"] = bufferSize;
+						metadata["definitions"]["uniforms"][name]["members"] = parseMembers(resource.type_id);
+					}
+				} break;
+				case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: {
+					// generate definition to JSON
+					{
+						metadata["definitions"]["storage"][name]["name"] = name;
+						metadata["definitions"]["storage"][name]["index"] = index;
+						metadata["definitions"]["storage"][name]["members"] = parseMembers(resource.type_id);
+					}
+					// test
+					{
+					//	updateUniform(name, getUniform(name));
+					}
+				} break;
+			}
+			descriptorSetLayoutBindings.push_back( ext::vulkan::initializers::descriptorSetLayoutBinding( descriptorType, stage, comp.get_decoration(resource.id, spv::DecorationBinding), arraySize ) );
+		};
+		
+
+		//for ( const auto& resource : res.key ) {
+		#define LOOP_RESOURCES( key, type ) for ( size_t i = 0; i < res.key.size(); ++i ) {\
+			const auto& resource = res.key[i];\
+			VK_DEBUG_VALIDATION_MESSAGE("["<<filename<<"] Found resource: "#type " with binding: " << comp.get_decoration(resource.id, spv::DecorationBinding));\
+			parseResource( resource, type, i );\
+		}
+		LOOP_RESOURCES( sampled_images, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER );
+		LOOP_RESOURCES( separate_images, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE );
+		LOOP_RESOURCES( storage_images, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE );
+		LOOP_RESOURCES( separate_samplers, VK_DESCRIPTOR_TYPE_SAMPLER );
+		LOOP_RESOURCES( subpass_inputs, VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT );
+		LOOP_RESOURCES( uniform_buffers, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER );
+		LOOP_RESOURCES( storage_buffers, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER );
+		#undef LOOP_RESOURCES
+
+		for ( const auto& resource : res.push_constant_buffers ) {
+			const auto& type = comp.get_type(resource.type_id);
+			const auto& base_type = comp.get_type(resource.base_type_id);
+			std::string name = resource.name;
+			size_t size = comp.get_declared_struct_size(type);
+			if ( size <= 0 ) continue;
+			// not a multiple of 4, for some reason
+			if ( size % 4 != 0 ) {
+				VK_DEBUG_VALIDATION_MESSAGE("Invalid push constant length of " << size << " for shader " << filename << ", must be multiple of 4, correcting...");
+				size /= 4;
+				++size; 
+				size *= 4;
+			}
+			if ( size > device.properties.limits.maxPushConstantsSize ) {
+				VK_DEBUG_VALIDATION_MESSAGE("Invalid push constant length of " << size << " for shader " << filename);
+				size = device.properties.limits.maxPushConstantsSize;
+			}
+			VK_DEBUG_VALIDATION_MESSAGE("Push constant size of " << size << " for shader " << filename);
+			{
+				auto& pushConstant = pushConstants.emplace_back();
+				pushConstant.create( size );
+			}
+			// generate definition to JSON
+			{
+				metadata["definitions"]["pushConstants"][name]["name"] = name;
+				metadata["definitions"]["pushConstants"][name]["size"] = size;
+				metadata["definitions"]["pushConstants"][name]["index"] = pushConstants.size() - 1;
+				metadata["definitions"]["pushConstants"][name]["members"] = parseMembers(resource.type_id);
+			}
+		}
+		
+		size_t specializationSize = 0;
+		for ( const auto& constant : comp.get_specialization_constants() ) {
+			const auto& value = comp.get_constant(constant.id);
+			const auto& type = comp.get_type(value.constant_type);
+			size_t size = 4; //comp.get_declared_struct_size(type);
+
+			VkSpecializationMapEntry specializationMapEntry;
+			specializationMapEntry.constantID = constant.constant_id;
+			specializationMapEntry.size = size;
+			specializationMapEntry.offset = specializationSize;
+			specializationMapEntries.push_back(specializationMapEntry);
+			specializationSize += size;
+		}
+		if ( specializationSize > 0 ) {			
+			specializationConstants.create( specializationSize );
+			VK_DEBUG_VALIDATION_MESSAGE("Specialization constants size of " << specializationSize << " for shader " << filename);
+
+			uint8_t* s = (uint8_t*) (void*) specializationConstants;
+			size_t offset = 0;
+
+			metadata["specializationConstants"] = ext::json::array();
+			for ( const auto& constant : comp.get_specialization_constants() ) {
+				const auto& value = comp.get_constant(constant.id);
+				const auto& type = comp.get_type(value.constant_type);
+				std::string name = comp.get_name (constant.id);
+
+				ext::json::Value member;
+
+				size_t size = 4;
+				uint8_t buffer[size];
+				switch ( type.basetype ) {
+					case spirv_cross::SPIRType::UInt: {
+						auto v = value.scalar();
+						member["type"] = "uint32_t";
+						member["value"] = v;
+						member["validate"] = true;
+						memcpy( &buffer[0], &v, sizeof(v) );
+					} break;
+					case spirv_cross::SPIRType::Int: {
+						auto v = value.scalar_i32();
+						member["type"] = "int32_t";
+						member["value"] = v;
+						memcpy( &buffer[0], &v, sizeof(v) );
+					} break;
+					case spirv_cross::SPIRType::Float: {
+						auto v = value.scalar_f32();
+						member["type"] = "float";
+						member["value"] = v;
+						memcpy( &buffer[0], &v, sizeof(v) );
+					} break;
+					case spirv_cross::SPIRType::Boolean: {
+						auto v = value.scalar()!=0;
+						member["type"] = "bool";
+						member["value"] = v;
+						memcpy( &buffer[0], &v, sizeof(v) );
+					} break;
+					default: {
+						VK_DEBUG_VALIDATION_MESSAGE("Unregistered specialization constant type at offset " << offset << " for shader " << filename );
+					} break;
+				}
+				member["name"] = name;
+				member["size"] = size;
+				member["default"] = member["value"];
+				VK_DEBUG_VALIDATION_MESSAGE("Specialization constant: " << member["type"].as<std::string>() << " " << name << " = " << member["value"].dump() << "; at offset " << offset << " for shader " << filename );
+				metadata["specializationConstants"].emplace_back(member);
+
+				memcpy( &s[offset], &buffer, size );
+				offset += size;
+			}
+		/*
+			{
+				specializationInfo = {};
+				specializationInfo.dataSize = specializationSize;
+				specializationInfo.mapEntryCount = specializationMapEntries.size();
+				specializationInfo.pMapEntries = specializationMapEntries.data();
+				specializationInfo.pData = (void*) specializationConstants;
+				descriptor.pSpecializationInfo = &specializationInfo;
+			}
+		*/
+		}
+	/*
+	*/
+	//	LOOP_RESOURCES( stage_inputs, VkVertexInputAttributeDescription );
+	//	LOOP_RESOURCES( stage_outputs, VkPipelineColorBlendAttachmentState );
+	}
+
+	// organize layouts
+	{
+		std::sort( descriptorSetLayoutBindings.begin(), descriptorSetLayoutBindings.end(), [&]( const VkDescriptorSetLayoutBinding& l, const VkDescriptorSetLayoutBinding& r ){
+			return l.binding < r.binding;
+		} );
+	}
+
+	// update uniform buffers
+	for ( auto& uniform : uniforms ) {
+		auto& userdata = uniform.data();
+		initializeBuffer(
+			(void*) userdata.data,
+			userdata.len,
+			VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT
+		);
+	}
+}
+
+void ext::vulkan::Shader::destroy() {
+	if ( aliased ) return;
+	if ( !device ) return;
+
+	ext::vulkan::Buffers::destroy();
+
+	if ( module != VK_NULL_HANDLE ) {
+		vkDestroyShaderModule( *device, module, nullptr );
+		module = VK_NULL_HANDLE;
+		descriptor = {};
+	}
+	for ( auto& userdata : uniforms ) userdata.destroy();
+	for ( auto& userdata : pushConstants ) userdata.destroy();
+	uniforms.clear();
+	pushConstants.clear();
+}
+
+bool ext::vulkan::Shader::validate() {
+	// check if uniforms match buffer size
+	bool valid = true;
+	{
+		auto it = uniforms.begin();
+		for ( auto& buffer : buffers ) {
+			if ( !(buffer.usage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) ) continue;
+			if ( it == uniforms.end() ) break;
+			auto& uniform = *(it++);
+			if ( uniform.data().len != buffer.allocationInfo.size ) {
+				VK_DEBUG_VALIDATION_MESSAGE("Uniform size mismatch: Expected " << buffer.allocationInfo.size << ", got " << uniform.data().len << "; fixing...");
+				uniform.destroy();
+				uniform.create(buffer.allocationInfo.size);
+				valid = false;
+			}
+		}
+	}
+	return valid;
+}
+bool ext::vulkan::Shader::hasUniform( const std::string& name ) {
+	return !ext::json::isNull(metadata["definitions"]["uniforms"][name]);
+}
+ext::vulkan::Buffer* ext::vulkan::Shader::getUniformBuffer( const std::string& name ) {
+	if ( !hasUniform(name) ) return NULL;
+	size_t uniformIndex = metadata["definitions"]["uniforms"][name]["index"].as<size_t>();
+	for ( size_t bufferIndex = 0, uniformCounter = 0; bufferIndex < buffers.size(); ++bufferIndex ) {
+		if ( !(buffers[bufferIndex].usage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) ) continue;
+		if ( uniformCounter++ != uniformIndex ) continue;
+		return &buffers[bufferIndex];
+	}
+	return NULL;
+}
+ext::vulkan::userdata_t& ext::vulkan::Shader::getUniform( const std::string& name ) {
+	if ( !hasUniform(name) ) {
+		static ext::vulkan::userdata_t null;
+		return null;
+	}
+	auto& definition = metadata["definitions"]["uniforms"][name];
+	size_t uniformSize = definition["size"].as<size_t>();
+	size_t uniformIndex = definition["index"].as<size_t>();
+	auto& userdata = uniforms[uniformIndex];
+	return userdata;
+}
+bool ext::vulkan::Shader::updateUniform( const std::string& name ) {
+	if ( !hasUniform(name) ) return false;
+	auto& uniform = getUniform(name);
+	return updateUniform(name, uniform);
+}
+bool ext::vulkan::Shader::updateUniform( const std::string& name, const ext::vulkan::userdata_t& userdata ) {
+	if ( !hasUniform(name) ) return false;
+	auto* bufferObject = getUniformBuffer(name);
+	if ( !bufferObject ) return false;
+	size_t size = std::max(metadata["definitions"]["uniforms"][name]["size"].as<size_t>(), bufferObject->allocationInfo.size);
+	updateBuffer( (void*) userdata, size, *bufferObject );
+	return true;
+}
+
+uf::Serializer ext::vulkan::Shader::getUniformJson( const std::string& name, bool cache ) {
+	if ( !hasUniform(name) ) return ext::json::null();
+	if ( cache && !ext::json::isNull(metadata["uniforms"][name]) ) return metadata["uniforms"][name];
+	auto& definition = metadata["definitions"]["uniforms"][name];
+	if ( cache ) return metadata["uniforms"][name] = definitionToJson(definition);
+	return definitionToJson(definition);
+}
+ext::vulkan::userdata_t ext::vulkan::Shader::getUniformUserdata( const std::string& name, const ext::json::Value& payload ) {
+	if ( !hasUniform(name) ) return false;
+	return jsonToUserdata(payload, metadata["definitions"]["uniforms"][name]);
+}
+bool ext::vulkan::Shader::updateUniform( const std::string& name, const ext::json::Value& payload ) {
+	if ( !hasUniform(name) ) return false;
+
+	auto* bufferObject = getUniformBuffer(name);
+	if ( !bufferObject ) return false;
+
+	auto uniform = getUniformUserdata( name, payload );	
+	updateBuffer( (void*) uniform, uniform.data().len, *bufferObject );
+	return true;
+}
+
+bool ext::vulkan::Shader::hasStorage( const std::string& name ) {
+	return !ext::json::isNull(metadata["definitions"]["storage"][name]);
+}
+
+ext::vulkan::Buffer* ext::vulkan::Shader::getStorageBuffer( const std::string& name ) {
+	if ( !hasStorage(name) ) return NULL;
+	size_t storageIndex = metadata["definitions"]["storage"][name]["index"].as<size_t>();
+	for ( size_t bufferIndex = 0, storageCounter = 0; bufferIndex < buffers.size(); ++bufferIndex ) {
+		if ( !(buffers[bufferIndex].usage & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) ) continue;
+		if ( storageCounter++ != storageIndex ) continue;
+		return &buffers[bufferIndex];
+	}
+	return NULL;
+}
+uf::Serializer ext::vulkan::Shader::getStorageJson( const std::string& name, bool cache ) {
+	if ( !hasStorage(name) ) return ext::json::null();
+	if ( cache && !ext::json::isNull(metadata["storage"][name]) ) return metadata["storage"][name];
+	auto& definition = metadata["definitions"]["storage"][name];
+	if ( cache ) return metadata["storage"][name] = definitionToJson(definition);
+	return definitionToJson(definition);
+}
+ext::vulkan::userdata_t ext::vulkan::Shader::getStorageUserdata( const std::string& name, const ext::json::Value& payload ) {
+	if ( !hasStorage(name) ) return false;
+	return jsonToUserdata(payload, metadata["definitions"]["storage"][name]);
+}
+
+void ext::vulkan::Pipeline::initialize( Graphic& graphic ) {
+	return this->initialize( graphic, graphic.descriptor );
+}
+void ext::vulkan::Pipeline::initialize( Graphic& graphic, GraphicDescriptor& descriptor ) {
+	this->device = graphic.device;
+	//this->descriptor = descriptor;
+	Device& device = *graphic.device;
+
+	// VK_VALIDATION_MESSAGE(&graphic << ": Shaders: " << graphic.material.shaders.size() << " Textures: " << graphic.material.textures.size());
+	assert( graphic.material.shaders.size() > 0 );
+
+	RenderMode& renderMode = ext::vulkan::getRenderMode( descriptor.renderMode, true);
+	auto& renderTarget = renderMode.getRenderTarget(  descriptor.renderTarget );
+	{
+		std::vector<VkDescriptorSetLayoutBinding> descriptorSetLayoutBindings;
+		std::vector<VkPushConstantRange> pushConstantRanges;
+		std::vector<VkDescriptorPoolSize> poolSizes;
+		std::unordered_map<VkDescriptorType, uint32_t> descriptorTypes;
+
+		for ( auto& shader : graphic.material.shaders ) {
+			descriptorSetLayoutBindings.insert( descriptorSetLayoutBindings.begin(), shader.descriptorSetLayoutBindings.begin(), shader.descriptorSetLayoutBindings.end() );
+
+			std::size_t offset = 0;
+			for ( auto& pushConstant : shader.pushConstants ) {
+				size_t len = pushConstant.data().len;
+				if ( len <= 0 || len > device.properties.limits.maxPushConstantsSize ) {
+					VK_DEBUG_VALIDATION_MESSAGE("Invalid push constant length of " << len << " for shader " << shader.filename);
+				//	goto PIPELINE_INITIALIZATION_INVALID;
+					len = device.properties.limits.maxPushConstantsSize;
+				}
+				pushConstantRanges.push_back(ext::vulkan::initializers::pushConstantRange(
+					shader.descriptor.stage,
+					len,
+					offset
+				));
+				offset += len;
+			}
+		}
+		for ( auto& descriptor : descriptorSetLayoutBindings ) {
+			if ( descriptorTypes.count( descriptor.descriptorType ) < 0 ) descriptorTypes[descriptor.descriptorType] = 0;
+			descriptorTypes[descriptor.descriptorType] += descriptor.descriptorCount;
+		}
+		for ( auto pair : descriptorTypes ) {
+			poolSizes.push_back(ext::vulkan::initializers::descriptorPoolSize(pair.first, pair.second));
+		}
+		VkDescriptorPoolCreateInfo descriptorPoolInfo = ext::vulkan::initializers::descriptorPoolCreateInfo(
+			poolSizes.size(),
+			poolSizes.data(),
+			1
+		);
+		
+		VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool));
+
+
+		VkDescriptorSetLayoutCreateInfo descriptorLayout = ext::vulkan::initializers::descriptorSetLayoutCreateInfo(
+			descriptorSetLayoutBindings.data(),
+			descriptorSetLayoutBindings.size()
+		);
+		VK_CHECK_RESULT(vkCreateDescriptorSetLayout( device, &descriptorLayout, nullptr, &descriptorSetLayout ));
+
+		VkDescriptorSetAllocateInfo allocInfo = ext::vulkan::initializers::descriptorSetAllocateInfo(
+			descriptorPool,
+			&descriptorSetLayout,
+			1
+		);
+		VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSet));
+
+		VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = ext::vulkan::initializers::pipelineLayoutCreateInfo(
+			&descriptorSetLayout,
+			1
+		);
+		pPipelineLayoutCreateInfo.pushConstantRangeCount = pushConstantRanges.size();
+		pPipelineLayoutCreateInfo.pPushConstantRanges = pushConstantRanges.data();
+
+		VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo, nullptr, &pipelineLayout));
+	}
+	// Compute
+	for ( auto& shader : graphic.material.shaders ) {
+		if ( shader.descriptor.stage != VK_SHADER_STAGE_COMPUTE_BIT ) continue;
+
+		// Create compute shader pipelines
+		VkComputePipelineCreateInfo computePipelineCreateInfo = ext::vulkan::initializers::computePipelineCreateInfo(
+			pipelineLayout,
+			0
+		);
+		computePipelineCreateInfo.stage = shader.descriptor;
+		VK_CHECK_RESULT(vkCreateComputePipelines(device, device.pipelineCache, 1, &computePipelineCreateInfo, nullptr, &pipeline));
+	
+		return;
+	}
+	// Graphic
+	{
+		VkPipelineInputAssemblyStateCreateInfo inputAssemblyState = ext::vulkan::initializers::pipelineInputAssemblyStateCreateInfo(
+			descriptor.topology,
+			0,
+			VK_FALSE
+		);
+		VkPipelineRasterizationStateCreateInfo rasterizationState = ext::vulkan::initializers::pipelineRasterizationStateCreateInfo(
+			descriptor.fill,
+			descriptor.cullMode, //	VK_CULL_MODE_NONE,
+			descriptor.frontFace,
+			0
+		);
+		rasterizationState.lineWidth = graphic.descriptor.lineWidth;
+		rasterizationState.depthBiasEnable = graphic.descriptor.depth.bias.enable;
+		rasterizationState.depthBiasConstantFactor = graphic.descriptor.depth.bias.constant;
+		rasterizationState.depthBiasSlopeFactor = graphic.descriptor.depth.bias.slope;
+		rasterizationState.depthBiasClamp = graphic.descriptor.depth.bias.clamp;
+
+		std::vector<VkPipelineColorBlendAttachmentState> blendAttachmentStates;
+
+		VkSampleCountFlagBits samples = VK_SAMPLE_COUNT_1_BIT;
+		if ( renderMode.getType() != "Swapchain" ) {
+			auto& subpass = renderTarget.passes[descriptor.subpass];
+			for ( auto& color : subpass.colors ) {
+				auto& attachment = renderTarget.attachments[color.attachment];
+				blendAttachmentStates.push_back(attachment.blendState);
+				samples = std::max(samples, ext::vulkan::sampleCount( attachment.descriptor.samples ));
+			}
+			// require blending if independentBlend is not an enabled feature
+			if ( device.enabledFeatures.independentBlend == VK_FALSE ) {
+				for ( size_t i = 1; i < blendAttachmentStates.size(); ++i ) {
+					blendAttachmentStates[i] = blendAttachmentStates[0];
+				}
+			}
+		} else {
+			descriptor.subpass = 0;
+
+			VkBool32 blendEnabled = VK_FALSE;
+			VkColorComponentFlags writeMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT;
+
+			if ( true ) {
+				blendEnabled = VK_TRUE;
+				writeMask |= VK_COLOR_COMPONENT_A_BIT;
+			}
+
+			VkPipelineColorBlendAttachmentState blendAttachmentState = ext::vulkan::initializers::pipelineColorBlendAttachmentState(
+				writeMask,
+				blendEnabled
+			);
+			if ( blendEnabled == VK_TRUE ) {
+				blendAttachmentState.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
+				blendAttachmentState.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
+				blendAttachmentState.colorBlendOp = VK_BLEND_OP_ADD;
+				blendAttachmentState.srcAlphaBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
+				blendAttachmentState.dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
+				blendAttachmentState.alphaBlendOp = VK_BLEND_OP_ADD;
+			}
+			blendAttachmentStates.push_back(blendAttachmentState);
+		}
+
+		VkPipelineColorBlendStateCreateInfo colorBlendState = ext::vulkan::initializers::pipelineColorBlendStateCreateInfo(
+			blendAttachmentStates.size(),
+			blendAttachmentStates.data()
+		);
+		VkPipelineDepthStencilStateCreateInfo depthStencilState = ext::vulkan::initializers::pipelineDepthStencilStateCreateInfo(
+			descriptor.depth.test,
+			descriptor.depth.write,
+			descriptor.depth.operation //VK_COMPARE_OP_LESS_OR_EQUAL
+		);
+		VkPipelineViewportStateCreateInfo viewportState = ext::vulkan::initializers::pipelineViewportStateCreateInfo(
+			1, 1, 0
+		);
+		VkPipelineMultisampleStateCreateInfo multisampleState = ext::vulkan::initializers::pipelineMultisampleStateCreateInfo(
+			samples,
+			0
+		);
+		if ( samples > 1 && device.features.sampleRateShading ) {
+			multisampleState.sampleShadingEnable = VK_TRUE;
+			multisampleState.minSampleShading = 0.25f;
+		}
+
+
+		std::vector<VkDynamicState> dynamicStateEnables = {
+			VK_DYNAMIC_STATE_VIEWPORT,
+			VK_DYNAMIC_STATE_SCISSOR
+		};
+		VkPipelineDynamicStateCreateInfo dynamicState = ext::vulkan::initializers::pipelineDynamicStateCreateInfo(
+			dynamicStateEnables.data(),
+			dynamicStateEnables.size(),
+			0
+		);
+
+		// Binding description
+		std::vector<VkVertexInputBindingDescription> vertexBindingDescriptions = {
+			ext::vulkan::initializers::vertexInputBindingDescription(
+				VERTEX_BUFFER_BIND_ID, 
+				descriptor.geometry.attributes.vertex.size, 
+				VK_VERTEX_INPUT_RATE_VERTEX
+			)
+		};
+		// Attribute descriptions
+		// Describes memory layout and shader positions
+		std::vector<VkVertexInputAttributeDescription> vertexAttributeDescriptions = {};
+		for ( auto& attribute : descriptor.geometry.attributes.descriptor ) {
+			auto d = ext::vulkan::initializers::vertexInputAttributeDescription(
+				VERTEX_BUFFER_BIND_ID,
+				vertexAttributeDescriptions.size(),
+				attribute.format,
+				attribute.offset
+			);
+			vertexAttributeDescriptions.push_back(d);
+		}
+
+		VkPipelineVertexInputStateCreateInfo vertexInputState = ext::vulkan::initializers::pipelineVertexInputStateCreateInfo();
+		vertexInputState.vertexBindingDescriptionCount = vertexBindingDescriptions.size();
+		vertexInputState.pVertexBindingDescriptions = vertexBindingDescriptions.data();
+		vertexInputState.vertexAttributeDescriptionCount = vertexAttributeDescriptions.size();
+		vertexInputState.pVertexAttributeDescriptions = vertexAttributeDescriptions.data();
+
+		std::vector<VkPipelineShaderStageCreateInfo> shaderDescriptors;
+		for ( auto& shader : graphic.material.shaders ) {
+			void* s = (void*) shader.specializationConstants;
+			size_t len = shader.specializationConstants.data().len;
+			for ( size_t i = 0; i < len / 4; ++i ) {
+				auto& payload = shader.metadata["specializationConstants"][i];
+				std::string type = payload["type"].as<std::string>();
+				if ( type == "int32_t" ) {
+					int32_t& v = ((int32_t*) s)[i];
+					// failsafe, because for some reason things break
+					if ( payload["validate"].as<bool>() && v == 0 ) {
+						VK_DEBUG_VALIDATION_MESSAGE("Specialization constant of 0 for `" << payload.dump() << "` for shader `" << shader.filename << "`");
+						v = payload["value"].is<int32_t>() ? payload["value"].as<int32_t>() : payload["default"].as<int32_t>();
+					}
+					payload["value"] = v;
+				} else if ( type == "uint32_t" ) {
+					uint32_t& v = ((uint32_t*) s)[i];
+					// failsafe, because for some reason things break
+					if ( payload["validate"].as<bool>() && v == 0 ) {
+						VK_DEBUG_VALIDATION_MESSAGE("Specialization constant of 0 for `" << payload.dump() << "` for shader `" << shader.filename << "`");
+						v = payload["value"].is<uint32_t>() ? payload["value"].as<uint32_t>() : payload["default"].as<uint32_t>();
+					}
+					payload["value"] = v;
+				} else if ( type == "float" ) {
+					float& v = ((float*) s)[i];
+					// failsafe, because for some reason things break
+					if ( payload["validate"].as<bool>() && v == 0 ) {
+						VK_DEBUG_VALIDATION_MESSAGE("Specialization constant of 0 for `" << payload.dump() << "` for shader `" << shader.filename << "`");
+						v = payload["value"].is<float>() ? payload["value"].as<float>() : payload["default"].as<float>();
+					}
+					payload["value"] = v;
+				}
+			}
+			VK_DEBUG_VALIDATION_MESSAGE("Specialization constants for shader `" << shader.filename << "`: " << shader.metadata["specializationConstants"].dump(1, '\t'));
+
+
+			{
+				shader.specializationInfo = {};
+				shader.specializationInfo.mapEntryCount = shader.specializationMapEntries.size();
+				shader.specializationInfo.pMapEntries = shader.specializationMapEntries.data();
+				shader.specializationInfo.pData = (void*) shader.specializationConstants;
+				shader.specializationInfo.dataSize = shader.specializationConstants.data().len;
+				shader.descriptor.pSpecializationInfo = &shader.specializationInfo;
+			}
+			shaderDescriptors.push_back(shader.descriptor);
+		}
+
+		VkGraphicsPipelineCreateInfo pipelineCreateInfo = ext::vulkan::initializers::pipelineCreateInfo(
+			pipelineLayout,
+			renderTarget.renderPass,
+			0
+		);
+		pipelineCreateInfo.pVertexInputState = &vertexInputState;
+		pipelineCreateInfo.pInputAssemblyState = &inputAssemblyState;
+		pipelineCreateInfo.pRasterizationState = &rasterizationState;
+		pipelineCreateInfo.pColorBlendState = &colorBlendState;
+		pipelineCreateInfo.pMultisampleState = &multisampleState;
+		pipelineCreateInfo.pViewportState = &viewportState;
+		pipelineCreateInfo.pDepthStencilState = &depthStencilState;
+		pipelineCreateInfo.pDynamicState = &dynamicState;
+		pipelineCreateInfo.stageCount = shaderDescriptors.size();
+		pipelineCreateInfo.pStages = shaderDescriptors.data();
+		pipelineCreateInfo.subpass = descriptor.subpass;
+
+		VK_CHECK_RESULT(vkCreateGraphicsPipelines( device, device.pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipeline));
+		VK_DEBUG_VALIDATION_MESSAGE("Created graphics pipeline");
+	}
+
+	graphic.process = true;
+	return;
+PIPELINE_INITIALIZATION_INVALID:
+	graphic.process = false;
+	VK_DEBUG_VALIDATION_MESSAGE("Pipeline initialization invalid, updating next tick...");
+	uf::thread::add( uf::thread::get("Main"), [&]() -> int {
+		this->initialize( graphic, descriptor );
+	return 0;}, true );
+	return;
+}
+void ext::vulkan::Pipeline::record( Graphic& graphic, VkCommandBuffer commandBuffer, size_t pass, size_t draw ) {
+	auto bindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
+	for ( auto& shader : graphic.material.shaders ) {
+		if ( shader.descriptor.stage == VK_SHADER_STAGE_COMPUTE_BIT ) {
+			bindPoint = VK_PIPELINE_BIND_POINT_COMPUTE;
+		}
+		size_t offset = 0;
+		for ( auto& pushConstant : shader.pushConstants ) {
+			// 
+			if ( ext::json::isObject( shader.metadata["definitions"]["pushConstants"]["PushConstant"] ) ) {
+				if ( shader.descriptor.stage == VK_SHADER_STAGE_VERTEX_BIT ) {
+					struct PushConstant {
+						uint32_t pass;
+						uint32_t draw;
+					} pushConstant = { pass, draw };
+					vkCmdPushConstants( commandBuffer, pipelineLayout, shader.descriptor.stage, 0, sizeof(pushConstant), &pushConstant );
+				}
+			} else {
+				size_t len = pushConstant.data().len;
+				void* pointer = pushConstant.data().data;
+				if ( len > 0 && pointer ) {
+					vkCmdPushConstants( commandBuffer, pipelineLayout, shader.descriptor.stage, 0, len, pointer );
+				}
+			}
+		}
+	}
+	// Bind descriptor sets describing shader binding points
+	vkCmdBindDescriptorSets(commandBuffer, bindPoint, pipelineLayout, 0, 1, &descriptorSet, 0, nullptr);
+	// Bind the rendering pipeline
+	// The pipeline (state object) contains all states of the rendering pipeline, binding it will set all the states specified at pipeline creation time
+	vkCmdBindPipeline(commandBuffer, bindPoint, pipeline);
+}
+void ext::vulkan::Pipeline::update( Graphic& graphic ) {
+	return this->update( graphic, graphic.descriptor );
+}
+void ext::vulkan::Pipeline::update( Graphic& graphic, GraphicDescriptor& descriptor ) {
+	//
+	if ( descriptorSet == VK_NULL_HANDLE ) return;
+	//descriptor = d;
+	RenderMode& renderMode = ext::vulkan::getRenderMode(descriptor.renderMode, true);
+	auto& renderTarget = renderMode.getRenderTarget(descriptor.renderTarget );
+
+	std::vector<VkDescriptorSetLayoutBinding> descriptorSetLayoutBindings;
+	for ( auto& shader : graphic.material.shaders ) {
+		descriptorSetLayoutBindings.insert( descriptorSetLayoutBindings.begin(), shader.descriptorSetLayoutBindings.begin(), shader.descriptorSetLayoutBindings.end() );
+	}
+
+	struct {
+		std::vector<VkDescriptorBufferInfo> uniform;
+		std::vector<VkDescriptorBufferInfo> storage;
+		std::vector<VkDescriptorImageInfo> image;
+		std::vector<VkDescriptorImageInfo> sampler;
+		std::vector<VkDescriptorImageInfo> input;
+	} infos;
+
+	if ( descriptor.subpass < renderTarget.passes.size() ) {
+		auto& subpass = renderTarget.passes[descriptor.subpass];
+		for ( auto& input : subpass.inputs ) {
+			infos.input.push_back(ext::vulkan::initializers::descriptorImageInfo( 
+				renderTarget.attachments[input.attachment].view,
+			//	input.layout
+				input.layout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL : input.layout
+			));
+		}
+	}
+
+	{
+		for ( auto& texture : graphic.material.textures ) {
+			infos.image.emplace_back(texture.descriptor);
+		}
+		for ( auto& sampler : graphic.material.samplers ) {
+			infos.sampler.emplace_back(sampler.descriptor.info);
+		}
+	}
+
+	ext::json::Value bindingMapping;
+	for ( auto& shader : graphic.material.shaders ) {
+		#define PARSE_BUFFER( buffers ) for ( auto& buffer : buffers ) {\
+			if ( buffer.usage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT ) {\
+				infos.uniform.emplace_back(buffer.descriptor);\
+			}\
+			if ( buffer.usage & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT ) {\
+				infos.storage.emplace_back(buffer.descriptor);\
+			}\
+		}
+
+		PARSE_BUFFER(shader.buffers)
+		PARSE_BUFFER(graphic.buffers)
+
+		// check if we can even consume that many infos
+		size_t consumes = 0;
+		std::vector<std::string> types;
+		for ( auto& layout : shader.descriptorSetLayoutBindings ) {
+			switch ( layout.descriptorType ) {
+				// consume an texture image info
+				case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+				case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+				case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: {
+					consumes += layout.descriptorCount;
+					std::string imageType = "";
+					std::string binding = std::to_string(layout.binding);
+					for ( auto& shader : graphic.material.shaders ) {
+						auto& info = shader.metadata["definitions"]["textures"][binding];
+						if ( ext::json::isNull(info) ) continue;
+						imageType = info["type"].as<std::string>();
+						break;
+					}
+					types.reserve(consumes);
+					for ( size_t i = 0; i < layout.descriptorCount; ++i ) types.emplace_back(imageType);
+				} break;
+			}
+		}
+		for ( size_t i = infos.image.size(); i < consumes; ++i ) {
+			std::string type = i < types.size() ? types[i] : "";
+			if ( type == "3D" ) {
+				infos.image.push_back(Texture3D::empty.descriptor);
+			} else if ( type == "Cube" ) {
+				infos.image.push_back(TextureCube::empty.descriptor);
+			} else {
+				infos.image.push_back(Texture2D::empty.descriptor);
+			}
+		}
+	}
+
+	auto uniformBufferInfo = infos.uniform.begin();
+	auto storageBufferInfo = infos.storage.begin();
+	auto imageInfo = infos.image.begin();
+	auto samplerInfo = infos.sampler.begin();
+	auto inputInfo = infos.input.begin();
+
+	#define BREAK_ASSERT(condition, ...) if ( condition ) { VK_VALIDATION_MESSAGE(#condition << "\t" << __VA_ARGS__); break; }
+	std::vector<VkWriteDescriptorSet> writeDescriptorSets;
+	for ( auto& shader : graphic.material.shaders ) {
+	//	std::cout << shader.filename << ": " << std::endl;
+	//	std::cout << "\tAVAILABLE UNIFORM BUFFERS: " << infos.uniform.size() << std::endl;
+	//	std::cout << "\tAVAILABLE STORAGE BUFFERS: " << infos.storage.size() << std::endl;
+	//	std::cout << "\tCONSUMING : " << shader.descriptorSetLayoutBindings.size() << std::endl;
+
+		for ( auto& layout : shader.descriptorSetLayoutBindings ) {
+	//		VK_VALIDATION_MESSAGE(shader.filename << "\tType: " << layout.descriptorType << "\tConsuming: " << layout.descriptorCount);
+			switch ( layout.descriptorType ) {
+				// consume an texture image info
+				case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+				case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+				case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: {
+				//	std::cout << "\tINSERTING IMAGE" << std::endl;
+					BREAK_ASSERT( imageInfo == infos.image.end(), "Filename: " << shader.filename << "\tCount: " << layout.descriptorCount )
+					writeDescriptorSets.push_back(ext::vulkan::initializers::writeDescriptorSet(
+						descriptorSet,
+						layout.descriptorType,
+						layout.binding,
+						&(*imageInfo),
+						layout.descriptorCount
+					));
+					imageInfo += layout.descriptorCount;
+				} break;
+				case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: {
+				//	std::cout << "\tINSERTING INPUT_ATTACHMENT" << std::endl;
+					BREAK_ASSERT( inputInfo == infos.input.end(), "Filename: " << shader.filename << "\tCount: " << layout.descriptorCount )
+					writeDescriptorSets.push_back(ext::vulkan::initializers::writeDescriptorSet(
+						descriptorSet,
+						layout.descriptorType,
+						layout.binding,
+						&(*inputInfo),
+						layout.descriptorCount
+					));
+					inputInfo += layout.descriptorCount;
+				} break;
+				case VK_DESCRIPTOR_TYPE_SAMPLER: {
+				//	std::cout << "\tINSERTING SAMPLER" << std::endl;
+					BREAK_ASSERT( samplerInfo == infos.sampler.end(), "Filename: " << shader.filename << "\tCount: " << layout.descriptorCount )
+					writeDescriptorSets.push_back(ext::vulkan::initializers::writeDescriptorSet(
+						descriptorSet,
+						layout.descriptorType,
+						layout.binding,
+						&(*samplerInfo),
+						layout.descriptorCount
+					));
+					samplerInfo += layout.descriptorCount;
+				} break;
+				case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: {
+				//	std::cout << "\tINSERTING UNIFORM_BUFFER" << std::endl;
+					BREAK_ASSERT( uniformBufferInfo == infos.uniform.end(), "Filename: " << shader.filename << "\tCount: " << layout.descriptorCount )
+					writeDescriptorSets.push_back(ext::vulkan::initializers::writeDescriptorSet(
+						descriptorSet,
+						layout.descriptorType,
+						layout.binding,
+						&(*uniformBufferInfo),
+						layout.descriptorCount
+					));
+					uniformBufferInfo += layout.descriptorCount;
+				} break;
+				case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: {
+				//	std::cout << "\tINSERTING STORAGE_BUFFER" << std::endl;
+					BREAK_ASSERT( storageBufferInfo == infos.storage.end(), "Filename: " << shader.filename << "\tCount: " << layout.descriptorCount )
+					writeDescriptorSets.push_back(ext::vulkan::initializers::writeDescriptorSet(
+						descriptorSet,
+						layout.descriptorType,
+						layout.binding,
+						&(*storageBufferInfo),
+						layout.descriptorCount
+					));
+					storageBufferInfo += layout.descriptorCount;
+				} break;
+			}
+		}
+	}
+
+	for ( auto& descriptor : writeDescriptorSets ) {
+		for ( size_t i = 0; i < descriptor.descriptorCount; ++i ) {
+			if ( descriptor.pBufferInfo ) {
+				if ( descriptor.pBufferInfo[i].offset % device->properties.limits.minUniformBufferOffsetAlignment != 0 ) {
+					VK_DEBUG_VALIDATION_MESSAGE("Invalid descriptor for buffer: " << descriptor.pBufferInfo[i].buffer << " (Offset: " << descriptor.pBufferInfo[i].offset << ", Range: " << descriptor.pBufferInfo[i].range << "), invalidating...");
+					goto PIPELINE_UPDATE_INVALID;
+				}
+			}
+			if ( descriptor.pImageInfo ) {
+				if (  	descriptor.descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER ||
+						descriptor.descriptorType == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE ||
+						descriptor.descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE ||
+						descriptor.descriptorType == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT
+				 ) {
+					if ( descriptor.pImageInfo[i].imageView == VK_NULL_HANDLE) {
+						VK_DEBUG_VALIDATION_MESSAGE("Null image view, replacing with fallback texture...");
+						auto pointer = const_cast<VkDescriptorImageInfo*>(&descriptor.pImageInfo[i]);
+						std::string binding = std::to_string(descriptor.dstBinding);
+						std::string imageType = "";
+						for ( auto& shader : graphic.material.shaders ) {
+							auto& info = shader.metadata["definitions"]["textures"][binding];
+							if ( ext::json::isNull(info) ) continue;
+							imageType = info["type"].as<std::string>();
+							break;
+						}
+						if ( imageType == "3D" ) {
+							*pointer = Texture3D::empty.descriptor;
+						} else if ( imageType == "Cube" ) {
+							*pointer = TextureCube::empty.descriptor;
+						} else {
+							*pointer = Texture2D::empty.descriptor;
+						}
+					}
+					if ( descriptor.pImageInfo[i].imageLayout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL ) {
+						VK_DEBUG_VALIDATION_MESSAGE("Image layout is VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, fixing to VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL");
+						auto pointer = const_cast<VkDescriptorImageInfo*>(&descriptor.pImageInfo[i]);
+						pointer->imageLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;
+					}
+				}
+				if ( 	descriptor.descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER ||
+						descriptor.descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER
+				) {
+					if ( !descriptor.pImageInfo[i].sampler ) {
+						VK_DEBUG_VALIDATION_MESSAGE("Image descriptor type is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, yet lacks a sampler, adding default sampler...");
+						auto pointer = const_cast<VkDescriptorImageInfo*>(&descriptor.pImageInfo[i]);
+						pointer->sampler = Texture2D::empty.sampler.sampler;
+					}
+				}
+			}
+		}
+	}
+
+	renderMode.rebuild = true;
+	graphic.process = true;
+
+	vkUpdateDescriptorSets(
+		*device,
+		writeDescriptorSets.size(),
+		writeDescriptorSets.data(),
+		0,
+		NULL
+	);
+	return;
+
+PIPELINE_UPDATE_INVALID:
+	graphic.process = false;
+	VK_DEBUG_VALIDATION_MESSAGE("Pipeline update invalid, updating next tick...");
+	uf::thread::add( uf::thread::get("Main"), [&]() -> int {
+		this->update( graphic, descriptor );
+	return 0;}, true );
+	return;
+}
+void ext::vulkan::Pipeline::destroy() {
+	if ( aliased ) return;
+
+	if ( descriptorPool != VK_NULL_HANDLE) {
+		vkDestroyDescriptorPool( *device, descriptorPool, nullptr );
+		descriptorPool = VK_NULL_HANDLE;
+	}
+	if ( pipelineLayout != VK_NULL_HANDLE ) {
+		vkDestroyPipelineLayout( *device, pipelineLayout, nullptr );
+		pipelineLayout = VK_NULL_HANDLE;
+	}
+	if ( pipeline != VK_NULL_HANDLE ) {
+		vkDestroyPipeline( *device, pipeline, nullptr );
+		pipeline = VK_NULL_HANDLE;
+	}
+	if ( descriptorSetLayout != VK_NULL_HANDLE ) {
+		vkDestroyDescriptorSetLayout( *device, descriptorSetLayout, nullptr );
+		descriptorSetLayout = VK_NULL_HANDLE;
+	}
+}
+
+void ext::vulkan::Material::initialize( Device& device ) {
+	this->device = &device;
+}
+void ext::vulkan::Material::destroy() {
+	if ( aliased ) return;
+
+	for ( auto& texture : textures ) texture.destroy();
+	for ( auto& shader : shaders ) shader.destroy();
+	for ( auto& sampler : samplers ) sampler.destroy();
+
+	shaders.clear();
+	textures.clear();
+	samplers.clear();
+}
+void ext::vulkan::Material::attachShader( const std::string& filename, VkShaderStageFlagBits stage ) {
+	auto& shader = shaders.emplace_back();
+	shader.initialize( *device, filename, stage );
+
+	// check how many samplers requested
+	for ( auto& layout : shader.descriptorSetLayoutBindings ) {
+		if ( layout.descriptorType != VK_DESCRIPTOR_TYPE_SAMPLER ) continue;
+		Sampler& sampler = samplers.emplace_back();
+		sampler.initialize( *device );
+	}
+	
+	std::string type = "unknown";
+	switch ( stage ) {
+		case VK_SHADER_STAGE_VERTEX_BIT: type = "vertex"; break;
+		case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT: type = "tessellation_control"; break;
+		case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT: type = "tessellation_evaluation"; break;
+		case VK_SHADER_STAGE_GEOMETRY_BIT: type = "geometry"; break;
+		case VK_SHADER_STAGE_FRAGMENT_BIT: type = "fragment"; break;
+		case VK_SHADER_STAGE_COMPUTE_BIT: type = "compute"; break;
+		case VK_SHADER_STAGE_ALL_GRAPHICS: type = "all_graphics"; break;
+		case VK_SHADER_STAGE_ALL: type = "all"; break;
+		case VK_SHADER_STAGE_RAYGEN_BIT_KHR: type = "raygen"; break;
+		case VK_SHADER_STAGE_ANY_HIT_BIT_KHR: type = "any_hit"; break;
+		case VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR: type = "closest_hit"; break;
+		case VK_SHADER_STAGE_MISS_BIT_KHR: type = "miss"; break;
+		case VK_SHADER_STAGE_INTERSECTION_BIT_KHR: type = "intersection"; break;
+		case VK_SHADER_STAGE_CALLABLE_BIT_KHR: type = "callable"; break;
+	}
+	metadata["shaders"][type]["index"] = shaders.size() - 1;
+	metadata["shaders"][type]["filename"] = filename;
+}
+void ext::vulkan::Material::initializeShaders( const std::vector<std::pair<std::string, VkShaderStageFlagBits>>& layout ) {
+	shaders.clear(); shaders.reserve( layout.size() );
+	for ( auto& request : layout ) {
+		attachShader( request.first, request.second );
+	}
+}
+bool ext::vulkan::Material::hasShader( const std::string& type ) {
+	return !ext::json::isNull( metadata["shaders"][type] );
+}
+ext::vulkan::Shader& ext::vulkan::Material::getShader( const std::string& type ) {
+	if ( !hasShader(type) ) {
+		static ext::vulkan::Shader null;
+		return null;
+	}
+	size_t index = metadata["shaders"][type]["index"].as<size_t>();
+	return shaders.at(index);
+}
+bool ext::vulkan::Material::validate() {
+	bool was = true;
+	for ( auto& shader : shaders ) {
+		if ( !shader.validate() ) was = false;
+	}
+	return was;
+}
+ext::vulkan::Graphic::~Graphic() {
+	this->destroy();
+}
+void ext::vulkan::Graphic::initialize( const std::string& renderModeName ) {
+	RenderMode& renderMode = ext::vulkan::getRenderMode(renderModeName, true);
+
+	this->descriptor.renderMode = renderModeName;
+	auto* device = renderMode.device;
+	if ( !device ) device = &ext::vulkan::device;
+
+	material.initialize( *device );
+
+	ext::vulkan::Buffers::initialize( *device );
+}
+void ext::vulkan::Graphic::initializePipeline() {
+	initializePipeline( this->descriptor, false );
+}
+ext::vulkan::Pipeline& ext::vulkan::Graphic::initializePipeline( GraphicDescriptor& descriptor, bool update ) {
+	auto& pipeline = pipelines[descriptor.hash()];
+
+//	auto previous = this->descriptor;
+//	this->descriptor = descriptor;
+	pipeline.initialize(*this, descriptor);
+	pipeline.update(*this, descriptor);
+//	if ( !update ) this->descriptor = previous;
+
+	initialized = true;
+	material.validate();
+
+	return pipeline;
+}
+void ext::vulkan::Graphic::initializeGeometry( const uf::BaseGeometry& mesh ) {
+	// already generated, check if we can just update
+	if ( descriptor.indices > 0 ) {
+		if ( descriptor.geometry.attributes.vertex.size == mesh.attributes.vertex.size && descriptor.geometry.attributes.index.size == mesh.attributes.index.size && descriptor.indices == mesh.attributes.index.length ) {
+			// too lazy to check if this equals, only matters in pipeline creation anyways
+			descriptor.geometry = mesh;
+
+			int32_t vertexBuffer = -1;
+			int32_t indexBuffer = -1;
+			for ( size_t i = 0; i < buffers.size(); ++i ) {
+				if ( buffers[i].usage & uf::renderer::enums::Buffer::VERTEX ) vertexBuffer = i;
+				if ( buffers[i].usage & uf::renderer::enums::Buffer::INDEX ) indexBuffer = i;
+			}
+
+			if ( vertexBuffer > 0 && indexBuffer > 0 ) {
+				updateBuffer(
+					(void*) mesh.attributes.vertex.pointer,
+					mesh.attributes.vertex.size * mesh.attributes.vertex.length,
+					vertexBuffer
+				);
+				updateBuffer(
+					(void*) mesh.attributes.index.pointer,
+					mesh.attributes.index.size * mesh.attributes.index.length,
+					indexBuffer
+				);
+				return;
+			}
+		}
+	}
+
+	descriptor.geometry = mesh;
+	descriptor.indices = mesh.attributes.index.length;
+
+	initializeBuffer(
+		(void*) mesh.attributes.vertex.pointer,
+		mesh.attributes.vertex.size * mesh.attributes.vertex.length,
+		uf::renderer::enums::Buffer::VERTEX
+	);
+	initializeBuffer(
+		(void*) mesh.attributes.index.pointer,
+		mesh.attributes.index.size * mesh.attributes.index.length,
+		uf::renderer::enums::Buffer::INDEX
+	);
+}
+bool ext::vulkan::Graphic::hasPipeline( GraphicDescriptor& descriptor ) {
+	return pipelines.count( descriptor.hash() ) > 0;
+}
+ext::vulkan::Pipeline& ext::vulkan::Graphic::getPipeline() {
+	return getPipeline( descriptor );
+}
+ext::vulkan::Pipeline& ext::vulkan::Graphic::getPipeline( GraphicDescriptor& descriptor ) {
+	if ( !hasPipeline(descriptor) ) return initializePipeline( descriptor );
+	return pipelines[descriptor.hash()];
+}
+void ext::vulkan::Graphic::updatePipelines() {
+	for ( auto pair : this->pipelines ) {
+		pair.second.update( *this );
+	}
+}
+void ext::vulkan::Graphic::record( VkCommandBuffer commandBuffer, size_t pass, size_t draw ) {
+	return this->record( commandBuffer, descriptor, pass, draw );
+}
+void ext::vulkan::Graphic::record( VkCommandBuffer commandBuffer, GraphicDescriptor& descriptor, size_t pass, size_t draw ) {
+	if ( !process ) return;
+	if ( !this->hasPipeline( descriptor ) ) {
+		VK_DEBUG_VALIDATION_MESSAGE(this << ": has no valid pipeline");
+		return;
+	}
+
+	auto& pipeline = this->getPipeline( descriptor );
+	if ( pipeline.descriptorSet == VK_NULL_HANDLE ) {
+		VK_DEBUG_VALIDATION_MESSAGE(this << ": has no valid pipeline descriptor set");
+		return;
+	}
+
+	Buffer* vertexBuffer = NULL;
+	Buffer* indexBuffer = NULL;
+	for ( auto& buffer : buffers ) {
+		if ( buffer.usage & VK_BUFFER_USAGE_VERTEX_BUFFER_BIT ) vertexBuffer = &buffer;
+		if ( buffer.usage & VK_BUFFER_USAGE_INDEX_BUFFER_BIT ) indexBuffer = &buffer;
+	}
+	assert( vertexBuffer && indexBuffer );
+
+	pipeline.record(*this, commandBuffer, pass, draw);
+	// Bind triangle vertex buffer (contains position and colors)
+	VkDeviceSize offsets[1] = { descriptor.offsets.vertex };
+	vkCmdBindVertexBuffers(commandBuffer, 0, 1, &vertexBuffer->buffer, offsets);
+	// Bind triangle index buffer
+	VkIndexType indicesType = VK_INDEX_TYPE_UINT32;
+	switch ( descriptor.geometry.attributes.index.size * 8 ) {
+		case  8: indicesType = VK_INDEX_TYPE_UINT8_EXT; break;
+		case 16: indicesType = VK_INDEX_TYPE_UINT16; break;
+		case 32: indicesType = VK_INDEX_TYPE_UINT32; break;
+		default:
+			UF_EXCEPTION("invalid indices size of " + std::to_string((int) descriptor.geometry.attributes.index.size));
+		break;
+	}
+	vkCmdBindIndexBuffer(commandBuffer, indexBuffer->buffer, descriptor.offsets.index, indicesType);
+	// Draw indexed triangle
+	vkCmdDrawIndexed(commandBuffer, descriptor.indices, 1, 0, 0, 1);
+	//std::cout << (int) descriptor.indices << "\t" << (int) descriptor.offsets.index << std::endl;
+}
+void ext::vulkan::Graphic::destroy() {
+	for ( auto& pair : pipelines ) pair.second.destroy();
+	pipelines.clear();
+
+	material.destroy();
+
+	ext::vulkan::Buffers::destroy();
+
+	ext::vulkan::states::rebuild = true;
+}
+
+bool ext::vulkan::Graphic::hasStorage( const std::string& name ) {
+	for ( auto& shader : material.shaders ) {
+		if ( shader.hasStorage(name) ) return true;
+	}
+	return false;
+}
+ext::vulkan::Buffer* ext::vulkan::Graphic::getStorageBuffer( const std::string& name ) {
+	size_t storageIndex = -1;
+	for ( auto& shader : material.shaders ) {
+		if ( !shader.hasStorage(name) ) continue;
+		storageIndex = shader.metadata["definitions"]["storage"][name]["index"].as<size_t>();
+		break;
+	}
+	for ( size_t bufferIndex = 0, storageCounter = 0; bufferIndex < buffers.size(); ++bufferIndex ) {
+		if ( !(buffers[bufferIndex].usage & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) ) continue;
+		if ( storageCounter++ != storageIndex ) continue;
+		return &buffers[bufferIndex];
+	}
+	return NULL;
+}
+uf::Serializer ext::vulkan::Graphic::getStorageJson( const std::string& name, bool cache ) {
+	for ( auto& shader : material.shaders ) {
+		if ( !shader.hasStorage(name) ) continue;
+		return shader.getStorageJson(name, cache);
+	}
+	return ext::json::null();
+}
+ext::vulkan::userdata_t ext::vulkan::Graphic::getStorageUserdata( const std::string& name, const ext::json::Value& payload ) {
+	for ( auto& shader : material.shaders ) {
+		if ( !shader.hasStorage(name) ) continue;
+		return shader.getStorageUserdata(name, payload);
+	}
+	return ext::vulkan::userdata_t();
+}
+
+#include <uf/utils/string/hash.h>
+void ext::vulkan::GraphicDescriptor::parse( ext::json::Value& metadata ) {
+	if ( metadata["front face"].is<std::string>() ) {
+		if ( metadata["front face"].as<std::string>() == "ccw" ) {
+			frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
+		} else if ( metadata["front face"].as<std::string>() == "cw" ) {
+			frontFace = VK_FRONT_FACE_CLOCKWISE;
+		}
+	}
+	if ( metadata["cull mode"].is<std::string>() ) {
+		if ( metadata["cull mode"].as<std::string>() == "back" ) {
+			cullMode = VK_CULL_MODE_BACK_BIT;
+		} else if ( metadata["cull mode"].as<std::string>() == "front" ) {
+			cullMode = VK_CULL_MODE_FRONT_BIT;
+		} else if ( metadata["cull mode"].as<std::string>() == "none" ) {
+			cullMode = VK_CULL_MODE_NONE;
+		} else if ( metadata["cull mode"].as<std::string>() == "both" ) {
+			cullMode = VK_CULL_MODE_FRONT_AND_BACK;
+		}
+	}
+	if ( metadata["indices"].is<size_t>() ) {
+		indices = metadata["indices"].as<size_t>();
+	}
+	if ( ext::json::isObject( metadata["offsets"] ) ) {
+		offsets.vertex = metadata["offsets"]["vertex"].as<size_t>();
+		offsets.index = metadata["offsets"]["index"].as<size_t>();
+	}
+	if ( ext::json::isObject(metadata["depth bias"]) ) {
+		depth.bias.enable = VK_TRUE;
+		depth.bias.constant = metadata["depth bias"]["constant"].as<float>();
+		depth.bias.slope = metadata["depth bias"]["slope"].as<float>();
+		depth.bias.clamp = metadata["depth bias"]["clamp"].as<float>();
+	}
+}
+std::string ext::vulkan::GraphicDescriptor::hash() const {
+	uf::Serializer serializer;
+
+	serializer["subpass"] = subpass;
+	if ( settings::experimental::individualPipelines ) serializer["renderMode"] = renderMode;
+
+	serializer["renderTarget"] = renderTarget;
+	serializer["geometry"]["sizes"]["vertex"] = geometry.attributes.vertex.size;
+	serializer["geometry"]["sizes"]["indices"] = geometry.attributes.index.size;
+	serializer["indices"] = indices;
+	serializer["offsets"]["vertex"] = offsets.vertex;
+	serializer["offsets"]["index"] = offsets.index;
+
+	{
+		int i = 0;
+		for ( auto& attribute : geometry.attributes.descriptor ) {
+			serializer["geometry"]["attributes"][i]["format"] = attribute.format;
+			serializer["geometry"]["attributes"][i]["offset"] = attribute.offset;
+			++i;
+		}
+	}
+	serializer["topology"] = topology;
+	serializer["cullMode"] = cullMode;
+	serializer["fill"] = fill;
+	serializer["lineWidth"] = lineWidth;
+	serializer["frontFace"] = frontFace;
+	serializer["depth"]["test"] = depth.test;
+	serializer["depth"]["write"] = depth.write;
+	serializer["depth"]["operation"] = depth.operation;
+	serializer["depth"]["bias"]["enable"] = depth.bias.enable;
+	serializer["depth"]["bias"]["constant"] = depth.bias.constant;
+	serializer["depth"]["bias"]["slope"] = depth.bias.slope;
+	serializer["depth"]["bias"]["clamp"] = depth.bias.clamp;
+
+//	if ( renderMode != "Gui" ) uf::iostream << this << ": " << indices << ": " << renderMode << ": " << subpass << ": " << serializer << "\n";
+//	return uf::string::sha256( serializer.serialize() );
+	return serializer.dump();
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/vulkan/rendermode.cpp b/engine/src/ext/vulkan/rendermode.cpp
new file mode 100644
index 00000000..37231236
--- /dev/null
+++ b/engine/src/ext/vulkan/rendermode.cpp
@@ -0,0 +1,282 @@
+#if UF_USE_VULKAN
+
+#include <uf/ext/vulkan/vulkan.h>
+#include <uf/ext/vulkan/rendermode.h>
+#include <uf/ext/vulkan/initializers.h>
+#include <uf/ext/vulkan/graphic.h>
+#include <uf/utils/window/window.h>
+
+#include <uf/ext/vulkan/rendertarget.h>
+#include <uf/utils/graphic/graphic.h>
+#include <uf/utils/serialize/serializer.h>
+#include <uf/engine/scene/scene.h>
+
+#include <uf/ext/openvr/openvr.h>
+
+ext::vulkan::RenderMode::~RenderMode() {
+	this->destroy();
+}
+const std::string ext::vulkan::RenderMode::getType() const {
+	return "";
+}
+const std::string ext::vulkan::RenderMode::getName() const {
+	auto& metadata = *const_cast<uf::Serializer*>(&this->metadata);
+	return metadata["name"].as<std::string>();
+}
+ext::vulkan::RenderTarget& ext::vulkan::RenderMode::getRenderTarget( size_t i ) {
+	return renderTarget;
+}
+const ext::vulkan::RenderTarget& ext::vulkan::RenderMode::getRenderTarget( size_t i ) const {
+	return renderTarget;
+}
+
+const size_t ext::vulkan::RenderMode::blitters() const {
+	return 0;
+}
+ext::vulkan::Graphic* ext::vulkan::RenderMode::getBlitter( size_t i ) {
+	return NULL;
+}
+std::vector<ext::vulkan::Graphic*> ext::vulkan::RenderMode::getBlitters() {
+	return {};
+}
+
+ext::vulkan::GraphicDescriptor ext::vulkan::RenderMode::bindGraphicDescriptor( const ext::vulkan::GraphicDescriptor& reference, size_t pass ) {
+	ext::vulkan::GraphicDescriptor descriptor = reference;
+	descriptor.renderMode = this->getName();
+	descriptor.subpass = pass;
+	descriptor.parse( metadata );
+	return descriptor;
+}
+void ext::vulkan::RenderMode::bindGraphicPushConstants( ext::vulkan::Graphic* pointer, size_t pass ) {
+	auto& graphic = *pointer;
+	// bind vertex shader push constants
+	{
+		auto& shader = graphic.material.getShader("vertex");
+		auto& metadata = shader.metadata["definitions"]["pushConstants"]["PushConstant"];
+		struct PushConstant {
+			uint32_t pass = 0;
+		};
+		if ( ext::json::isObject( metadata ) ) {
+			auto& pushConstant = shader.pushConstants.at( metadata["index"].as<size_t>() ).get<PushConstant>();
+			pushConstant.pass = pass;
+		}
+	}
+	// bind fragment shader push constants
+	{
+		auto& shader = graphic.material.getShader("fragment");
+		auto& metadata = shader.metadata["definitions"]["pushConstants"]["PushConstant"];
+	}
+}
+
+void ext::vulkan::RenderMode::createCommandBuffers() {
+	this->execute = true;
+
+	std::vector<ext::vulkan::Graphic*> graphics;
+	std::function<void(uf::Entity*)> filter = [&]( uf::Entity* entity ) {
+		if ( !entity->hasComponent<uf::Graphic>() ) return;
+		ext::vulkan::Graphic& graphic = entity->getComponent<uf::Graphic>();
+		if ( !graphic.initialized || !graphic.process ) return;
+		graphics.push_back(&graphic);
+	};
+	for ( uf::Scene* scene : uf::scene::scenes ) {
+		if ( !scene ) continue;
+		scene->process(filter);
+	}
+
+	this->synchronize();
+//	bindPipelines( graphics );
+	createCommandBuffers( graphics );
+	this->mostRecentCommandPoolId = std::this_thread::get_id();
+	this->rebuild = false;
+}
+ext::vulkan::RenderMode::commands_container_t& ext::vulkan::RenderMode::getCommands() {
+	return getCommands( std::this_thread::get_id() );
+}
+ext::vulkan::RenderMode::commands_container_t& ext::vulkan::RenderMode::getCommands( std::thread::id id ) {
+	bool exists = this->commands.has(id); //this->commands.count(id) > 0;
+	auto& commands = this->commands.get(id); //this->commands[id];
+	if ( !exists ) {
+		commands.resize( swapchain.buffers );
+
+		VkCommandBufferAllocateInfo cmdBufAllocateInfo = ext::vulkan::initializers::commandBufferAllocateInfo(
+			this->getType() == "Compute" ? device->getCommandPool(Device::QueueEnum::COMPUTE) : device->getCommandPool(Device::QueueEnum::GRAPHICS),
+			VK_COMMAND_BUFFER_LEVEL_PRIMARY,
+			static_cast<uint32_t>(commands.size())
+		);
+
+		VK_CHECK_RESULT(vkAllocateCommandBuffers(*device, &cmdBufAllocateInfo, commands.data()));
+	}
+	return commands;
+}
+void ext::vulkan::RenderMode::createCommandBuffers( const std::vector<ext::vulkan::Graphic*>& graphics ) {
+
+}
+void ext::vulkan::RenderMode::bindPipelines() {
+	this->execute = true;
+
+	std::vector<ext::vulkan::Graphic*> graphics;
+	std::function<void(uf::Entity*)> filter = [&]( uf::Entity* entity ) {
+		if ( !entity->hasComponent<uf::Graphic>() ) return;
+		ext::vulkan::Graphic& graphic = entity->getComponent<uf::Graphic>();
+		if ( !graphic.initialized ) return;
+		if ( !graphic.process ) return;
+		graphics.push_back(&graphic);
+	};
+	for ( uf::Scene* scene : uf::scene::scenes ) {
+		if ( !scene ) continue;
+		scene->process(filter);
+	}
+
+	this->synchronize();
+	this->bindPipelines( graphics );
+}
+void ext::vulkan::RenderMode::bindPipelines( const std::vector<ext::vulkan::Graphic*>& graphics ) {
+	for ( auto* pointer : graphics ) {
+		auto& graphic = *pointer;
+		for ( size_t currentPass = 0; currentPass < renderTarget.passes.size(); ++currentPass ) {
+			auto& subpass = renderTarget.passes[currentPass];
+			if ( !subpass.autoBuildPipeline ) continue;
+			// bind to this render mode
+			ext::vulkan::GraphicDescriptor descriptor = bindGraphicDescriptor(graphic.descriptor, currentPass);
+			// ignore if pipeline exists for this render mode
+			if ( graphic.hasPipeline( descriptor ) ) continue;
+			graphic.initializePipeline( descriptor );
+		}
+	}
+/*
+	size_t subpasses = metadata["subpasses"].as<size_t>();
+	for ( auto* pointer : graphics ) {
+		auto& graphic = *pointer;
+		for ( size_t currentPass = 0; currentPass < subpasses; ++currentPass ) {
+			// bind to this render mode
+			ext::vulkan::GraphicDescriptor descriptor = bindGraphicDescriptor(graphic.descriptor, currentPass);
+			// ignore if pipeline exists for this render mode
+			if ( graphic.hasPipeline( descriptor ) ) continue;
+			graphic.initializePipeline( descriptor );
+		}
+	}
+*/
+}
+
+void ext::vulkan::RenderMode::render() {
+/*
+	if ( ext::openvr::context ) {
+		ext::openvr::submit();
+	}
+*/
+	auto& commands = getCommands( this->mostRecentCommandPoolId );
+	// Get next image in the swap chain (back/front buffer)
+	VK_CHECK_RESULT(swapchain.acquireNextImage(&states::currentBuffer, swapchain.presentCompleteSemaphore));
+
+	// Use a fence to wait until the command buffer has finished execution before using it again
+	VK_CHECK_RESULT(vkWaitForFences(*device, 1, &fences[states::currentBuffer], VK_TRUE, UINT64_MAX));
+	VK_CHECK_RESULT(vkResetFences(*device, 1, &fences[states::currentBuffer]));
+
+	// Pipeline stage at which the queue submission will wait (via pWaitSemaphores)
+	VkPipelineStageFlags waitStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+	// The submit info structure specifices a command buffer queue submission batch
+	VkSubmitInfo submitInfo = {};
+	submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+	submitInfo.pWaitDstStageMask = &waitStageMask;									// Pointer to the list of pipeline stages that the semaphore waits will occur at
+	submitInfo.pWaitSemaphores = &swapchain.presentCompleteSemaphore;				// Semaphore(s) to wait upon before the submitted command buffer starts executing
+	submitInfo.waitSemaphoreCount = 1;												// One wait semaphore																				
+	submitInfo.pSignalSemaphores = &renderCompleteSemaphore;						// Semaphore(s) to be signaled when command buffers have completed
+	submitInfo.signalSemaphoreCount = 1;											// One signal semaphore
+	submitInfo.pCommandBuffers = &commands[states::currentBuffer];					// Command buffers(s) to execute in this batch (submission)
+	submitInfo.commandBufferCount = 1;
+
+	// Submit to the graphics queue passing a wait fence
+	VK_CHECK_RESULT(vkQueueSubmit( device->getQueue( Device::QueueEnum::GRAPHICS ), 1, &submitInfo, fences[states::currentBuffer]));
+	//vkQueueSubmit(device->queues.graphics, 1, &submitInfo, fences[states::currentBuffer]);
+	
+	// Present the current buffer to the swap chain
+	// Pass the semaphore signaled by the command buffer submission from the submit info as the wait semaphore for swap chain presentation
+	// This ensures that the image is not presented to the windowing system until all commands have been submitted
+	VK_CHECK_RESULT(swapchain.queuePresent(device->getQueue( Device::QueueEnum::PRESENT ), states::currentBuffer, renderCompleteSemaphore));
+	VK_CHECK_RESULT(vkQueueWaitIdle(device->getQueue( Device::QueueEnum::PRESENT )));
+}
+
+void ext::vulkan::RenderMode::initialize( Device& device ) {
+	this->device = &device;
+
+	// this->width = 0; //ext::vulkan::width;
+	// this->height = 0; //ext::vulkan::height;
+	{
+		if ( this->width > 0 ) renderTarget.width = this->width;
+		if ( this->height > 0 ) renderTarget.height = this->height;
+	}
+
+	// Create command buffers
+/*
+	{
+		commands.resize( swapchain.buffers );
+
+		VkCommandBufferAllocateInfo cmdBufAllocateInfo = ext::vulkan::initializers::commandBufferAllocateInfo(
+			this->getType() == "Compute" ? device.getCommandPool(Device::QueueEnum::COMPUTE) : device.getCommandPool(Device::QueueEnum::GRAPHICS),
+			VK_COMMAND_BUFFER_LEVEL_PRIMARY,
+			static_cast<uint32_t>(commands.size())
+		);
+
+		VK_CHECK_RESULT(vkAllocateCommandBuffers(device, &cmdBufAllocateInfo, commands.data()));
+	}
+*/
+	// Set sync objects
+	{
+		// Fences (Used to check draw command buffer completion)
+		VkFenceCreateInfo fenceCreateInfo = {};
+		fenceCreateInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
+		// Create in signaled state so we don't wait on first render of each command buffer
+		fenceCreateInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
+		fences.resize( swapchain.buffers );
+		for ( auto& fence : fences ) {
+			VK_CHECK_RESULT(vkCreateFence(device, &fenceCreateInfo, nullptr, &fence));
+		}
+		// Set sync objects
+		{
+			// Semaphores (Used for correct command ordering)
+			VkSemaphoreCreateInfo semaphoreCreateInfo = {};
+			semaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
+			semaphoreCreateInfo.pNext = nullptr;
+			// Semaphore used to ensures that all commands submitted have been finished before submitting the image to the queue
+			VK_CHECK_RESULT(vkCreateSemaphore(device, &semaphoreCreateInfo, nullptr, &renderCompleteSemaphore));
+		}
+	}
+}
+
+void ext::vulkan::RenderMode::tick() {
+	this->synchronize();
+}
+
+void ext::vulkan::RenderMode::destroy() {
+	this->synchronize();
+
+	renderTarget.destroy();
+/*	
+	if ( commands.size() > 0 ) {
+		vkFreeCommandBuffers( *device, this->getType() == "Compute" ? device->getCommandPool(Device::QueueEnum::COMPUTE) : device->getCommandPool(Device::QueueEnum::GRAPHICS), static_cast<uint32_t>(commands.size()), commands.data());
+	}
+	commands.clear();
+*/
+	for ( auto& pair : this->commands.container() ) {
+		vkFreeCommandBuffers( *device, device->getCommandPool(this->getType() == "Compute" ? Device::QueueEnum::COMPUTE : Device::QueueEnum::GRAPHICS, pair.first), static_cast<uint32_t>(pair.second.size()), pair.second.data());
+		pair.second.clear();
+	}
+	if ( renderCompleteSemaphore != VK_NULL_HANDLE ) {
+		vkDestroySemaphore( *device, renderCompleteSemaphore, nullptr);
+		renderCompleteSemaphore = VK_NULL_HANDLE;
+	}
+
+	for ( auto& fence : fences ) {
+		vkDestroyFence( *device, fence, nullptr);
+	}
+	fences.clear();
+}
+void ext::vulkan::RenderMode::synchronize( uint64_t timeout ) {
+	if ( !device ) return;
+	if ( fences.empty() ) return;
+	VK_CHECK_RESULT(vkWaitForFences( *device, fences.size(), fences.data(), VK_TRUE, timeout ));
+}
+void ext::vulkan::RenderMode::pipelineBarrier( VkCommandBuffer command, uint8_t stage ) {
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/vulkan/rendermodes/base.cpp b/engine/src/ext/vulkan/rendermodes/base.cpp
new file mode 100644
index 00000000..3db80363
--- /dev/null
+++ b/engine/src/ext/vulkan/rendermodes/base.cpp
@@ -0,0 +1,391 @@
+#if UF_USE_VULKAN
+
+#include <uf/ext/vulkan/vulkan.h>
+#include <uf/ext/vulkan/rendermodes/base.h>
+#include <uf/ext/vulkan/initializers.h>
+#include <uf/utils/window/window.h>
+#include <uf/ext/vulkan/graphic.h>
+#include <uf/ext/vulkan/rendertarget.h>
+#include <uf/utils/graphic/graphic.h>
+
+namespace {
+	std::vector<VkImage> images;
+}
+
+/*
+ext::vulkan::BaseRenderMode::~BaseRenderMode() {
+	this->destroy();
+}
+*/
+const std::string ext::vulkan::BaseRenderMode::getType() const {
+	return "Swapchain";
+}
+void ext::vulkan::BaseRenderMode::createCommandBuffers( const std::vector<ext::vulkan::Graphic*>& graphics ) {
+	if ( ext::vulkan::renderModes.size() > 1 ) return;
+
+	auto windowSize = device->window->getSize();
+	float width = windowSize.x; //this->width > 0 ? this->width : windowSize.x;
+	float height = windowSize.y; //this->height > 0 ? this->height : windowSize.y;
+
+	VkCommandBufferBeginInfo commandBufferInfo = {};
+	commandBufferInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+	commandBufferInfo.pNext = nullptr;
+
+	// Set clear values for all framebuffer attachments with loadOp set to clear
+	// We use two attachments (color and depth) that are cleared at the start of the subpass and as such we need to set clear values for both
+	VkClearValue clearValues[2];
+	clearValues[0].color = { { 0, 0, 0, 0 } };
+	clearValues[1].depthStencil = { 0.0f, 0 };
+
+	VkRenderPassBeginInfo renderPassBeginInfo = {};
+	renderPassBeginInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
+	renderPassBeginInfo.pNext = nullptr;
+	renderPassBeginInfo.renderPass = renderTarget.renderPass;
+	renderPassBeginInfo.renderArea.offset.x = 0;
+	renderPassBeginInfo.renderArea.offset.y = 0;
+	renderPassBeginInfo.renderArea.extent.width = width;
+	renderPassBeginInfo.renderArea.extent.height = height;
+	renderPassBeginInfo.clearValueCount = 2;
+	renderPassBeginInfo.pClearValues = clearValues;
+	auto& commands = getCommands();
+	for (size_t i = 0; i < commands.size(); ++i) {
+		// Set target frame buffer
+		renderPassBeginInfo.framebuffer = renderTarget.framebuffers[i];
+
+		VK_CHECK_RESULT(vkBeginCommandBuffer(commands[i], &commandBufferInfo));
+
+		// Start the first sub pass specified in our default render pass setup by the base class
+		// This will clear the color and depth attachment
+		vkCmdBeginRenderPass(commands[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
+			// Update dynamic viewport state
+			VkViewport viewport = {};
+			viewport.height = (float) height;
+			viewport.width = (float) width;
+			viewport.minDepth = (float) 0.0f;
+			viewport.maxDepth = (float) 1.0f;
+			vkCmdSetViewport(commands[i], 0, 1, &viewport);
+			// Update dynamic scissor state
+			VkRect2D scissor = {};
+			scissor.extent.width = width;
+			scissor.extent.height = height;
+			scissor.offset.x = 0;
+			scissor.offset.y = 0;
+			vkCmdSetScissor(commands[i], 0, 1, &scissor);
+
+			for ( auto graphic : graphics ) {
+				graphic->record(commands[i] );
+			}
+		vkCmdEndRenderPass(commands[i]);
+
+		// Ending the render pass will add an implicit barrier transitioning the frame buffer color attachment to 
+		// VK_IMAGE_LAYOUT_PRESENT_SRC_KHR for presenting it to the windowing system
+
+		VK_CHECK_RESULT(vkEndCommandBuffer(commands[i]));
+	}
+}
+
+void ext::vulkan::BaseRenderMode::tick() {
+	ext::vulkan::RenderMode::tick();
+	if ( ext::vulkan::states::resized ) {
+		this->destroy();
+		this->initialize( *this->device );
+	}
+}
+void ext::vulkan::BaseRenderMode::render() {
+//	if ( ext::vulkan::renderModes.size() > 1 ) return;
+	if ( ext::vulkan::renderModes.back() != this ) return;
+	ext::vulkan::RenderMode::render();
+}
+
+void ext::vulkan::BaseRenderMode::initialize( Device& device ) {
+	this->metadata["name"] = "Swapchain";
+	auto windowSize = device.window->getSize();
+	this->width = windowSize.x;
+	this->height = windowSize.y;
+
+	ext::vulkan::RenderMode::initialize( device );
+	// manual initialization
+	// recreate swapchain
+	// destroy any existing imageviews
+	// attachments marked as aliased are actually from the swapchain
+	// swapchain.destroy();
+	swapchain.initialize( device );
+	// bind swapchain images
+	images.resize( ext::vulkan::swapchain.buffers );
+	VK_CHECK_RESULT(vkGetSwapchainImagesKHR( device, swapchain.swapChain, &swapchain.buffers, images.data()));
+	// create image views for swapchain images
+	
+	renderTarget.attachments.clear();
+	renderTarget.attachments.resize( ext::vulkan::swapchain.buffers + 1 );
+
+//	uint32_t width = windowSize.x; //this->width > 0 ? this->width : windowSize.x;
+//	uint32_t height = windowSize.y; //this->height > 0 ? this->height : windowSize.y;
+
+	for ( size_t i = 0; i < images.size(); ++i ) {
+		VkImageViewCreateInfo colorAttachmentView = {};
+		colorAttachmentView.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+		colorAttachmentView.pNext = NULL;
+		colorAttachmentView.format = ext::vulkan::settings::formats::color;
+		colorAttachmentView.components = {
+			VK_COMPONENT_SWIZZLE_R,
+			VK_COMPONENT_SWIZZLE_G,
+			VK_COMPONENT_SWIZZLE_B,
+			VK_COMPONENT_SWIZZLE_A
+		};
+		colorAttachmentView.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+		colorAttachmentView.subresourceRange.baseMipLevel = 0;
+		colorAttachmentView.subresourceRange.levelCount = 1;
+		colorAttachmentView.subresourceRange.baseArrayLayer = 0;
+		colorAttachmentView.subresourceRange.layerCount = 1;
+		colorAttachmentView.viewType = VK_IMAGE_VIEW_TYPE_2D;
+		colorAttachmentView.flags = 0;
+		colorAttachmentView.image = images[i];
+
+		VK_CHECK_RESULT(vkCreateImageView( device, &colorAttachmentView, nullptr, &renderTarget.attachments[i].view));
+
+		renderTarget.attachments[i].descriptor.format = ext::vulkan::settings::formats::color;
+		renderTarget.attachments[i].descriptor.layout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
+		renderTarget.attachments[i].descriptor.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+		renderTarget.attachments[i].descriptor.aliased = true;
+		renderTarget.attachments[i].image = images[i];
+		renderTarget.attachments[i].mem = VK_NULL_HANDLE;
+	}
+	// Create depth
+	auto& depthAttachment = renderTarget.attachments.back();
+	{
+		// Create an optimal image used as the depth stencil attachment
+		VkImageCreateInfo imageCreateInfo = {};
+		imageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
+		imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
+		imageCreateInfo.format = ext::vulkan::settings::formats::depth;
+		// Use example's height and width
+		imageCreateInfo.extent = { width, height, 1 };
+		imageCreateInfo.mipLevels = 1;
+		imageCreateInfo.arrayLayers = 1;
+		imageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
+		imageCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
+		imageCreateInfo.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+		imageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+	
+		VmaAllocationCreateInfo allocInfo = {};
+		allocInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY;
+		VK_CHECK_RESULT(vmaCreateImage(allocator, &imageCreateInfo, &allocInfo, &depthAttachment.image, &depthAttachment.allocation, &depthAttachment.allocationInfo));
+		depthAttachment.mem = depthAttachment.allocationInfo.deviceMemory;
+	
+	/*
+		VK_CHECK_RESULT(vkCreateImage(device, &imageCreateInfo, nullptr, &depthAttachment.image));
+
+		// Allocate memory for the image (device local) and bind it to our image
+		VkMemoryAllocateInfo memAlloc = {};
+		memAlloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
+		VkMemoryRequirements memReqs;
+		vkGetImageMemoryRequirements(device, depthAttachment.image, &memReqs);
+		memAlloc.allocationSize = memReqs.size;
+		memAlloc.memoryTypeIndex = getMemoryTypeIndex(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+		VK_CHECK_RESULT(vkAllocateMemory(device, &memAlloc, nullptr, &depthAttachment.mem));
+		VK_CHECK_RESULT(vkBindImageMemory(device, depthAttachment.image, depthAttachment.mem, 0));
+	*/
+		// Create a view for the depth stencil image
+		// Images aren't directly accessed in Vulkan, but rather through views described by a subresource range
+		// This allows for multiple views of one image with differing ranges (e.g. for different layers)
+		VkImageViewCreateInfo depthStencilView = {};
+		depthStencilView.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+		depthStencilView.viewType = VK_IMAGE_VIEW_TYPE_2D;
+		depthStencilView.format = ext::vulkan::settings::formats::depth;
+		depthStencilView.subresourceRange = {};
+		depthStencilView.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
+		depthStencilView.subresourceRange.baseMipLevel = 0;
+		depthStencilView.subresourceRange.levelCount = 1;
+		depthStencilView.subresourceRange.baseArrayLayer = 0;
+		depthStencilView.subresourceRange.layerCount = 1;
+		depthStencilView.image = depthAttachment.image;
+
+		VK_CHECK_RESULT(vkCreateImageView(device, &depthStencilView, nullptr, &depthAttachment.view));
+	
+	}
+	// Create renderpass
+	if ( !renderTarget.renderPass ) {// Create render pass
+		// This example will use a single render pass with one subpass
+
+		// Descriptors for the attachments used by this renderpass
+		std::array<VkAttachmentDescription, 2> attachments = {};
+
+		// Color attachment
+		attachments[0].format = ext::vulkan::settings::formats::color;					// Use the color format selected by the swapchain
+		attachments[0].samples = VK_SAMPLE_COUNT_1_BIT;									// We don't use multi sampling in this example
+		attachments[0].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;							// Clear this attachment at the start of the render pass
+		attachments[0].storeOp = VK_ATTACHMENT_STORE_OP_STORE;							// Keep it's contents after the render pass is finished (for displaying it)
+		attachments[0].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;					// We don't use stencil, so don't care for load
+		attachments[0].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;				// Same for store
+		attachments[0].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;						// Layout at render pass start. Initial doesn't matter, so we use undefined
+		attachments[0].finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;					// Layout to which the attachment is transitioned when the render pass is finished
+																						// As we want to present the color buffer to the swapchain, we transition to PRESENT_KHR	
+		// Depth attachment
+		attachments[1].format = ext::vulkan::settings::formats::depth;					// A proper depth format is selected in the example base
+		attachments[1].samples = VK_SAMPLE_COUNT_1_BIT;						
+		attachments[1].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;							// Clear depth at start of first subpass
+		attachments[1].storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;						// We don't need depth after render pass has finished (DONT_CARE may result in better performance)
+		attachments[1].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;					// No stencil
+		attachments[1].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;				// No Stencil
+		attachments[1].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;						// Layout at render pass start. Initial doesn't matter, so we use undefined
+		attachments[1].finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;	// Transition to depth/stencil attachment
+
+		// Setup attachment references
+		VkAttachmentReference colorReference = {};
+		colorReference.attachment = 0;													// Attachment 0 is color
+		colorReference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;				// Attachment layout used as color during the subpass
+
+		VkAttachmentReference depthReference = {};
+		depthReference.attachment = 1;													// Attachment 1 is color
+		depthReference.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;		// Attachment used as depth/stemcil used during the subpass
+
+		// Setup a single subpass reference
+		VkSubpassDescription subpassDescription = {};
+		subpassDescription.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;			
+		subpassDescription.colorAttachmentCount = 1;									// Subpass uses one color attachment
+		subpassDescription.pColorAttachments = &colorReference;							// Reference to the color attachment in slot 0
+		subpassDescription.pDepthStencilAttachment = &depthReference;					// Reference to the depth attachment in slot 1
+		subpassDescription.inputAttachmentCount = 0;									// Input attachments can be used to sample from contents of a previous subpass
+		subpassDescription.pInputAttachments = nullptr;									// (Input attachments not used by this example)
+		subpassDescription.preserveAttachmentCount = 0;									// Preserved attachments can be used to loop (and preserve) attachments through subpasses
+		subpassDescription.pPreserveAttachments = nullptr;								// (Preserve attachments not used by this example)
+		subpassDescription.pResolveAttachments = nullptr;								// Resolve attachments are resolved at the end of a sub pass and can be used for e.g. multi sampling
+
+		// Setup subpass dependencies
+		// These will add the implicit ttachment layout transitionss specified by the attachment descriptions
+		// The actual usage layout is preserved through the layout specified in the attachment reference		
+		// Each subpass dependency will introduce a memory and execution dependency between the source and dest subpass described by
+		// srcStageMask, dstStageMask, srcAccessMask, dstAccessMask (and dependencyFlags is set)
+		// Note: VK_SUBPASS_EXTERNAL is a special constant that refers to all commands executed outside of the actual renderpass)
+		std::array<VkSubpassDependency, 2> dependencies;
+
+		// First dependency at the start of the renderpass
+		// Does the transition from final to initial layout 
+		dependencies[0].srcSubpass = VK_SUBPASS_EXTERNAL;								// Producer of the dependency 
+		dependencies[0].dstSubpass = 0;													// Consumer is our single subpass that will wait for the execution depdendency
+		dependencies[0].srcStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;			
+		dependencies[0].dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;	
+		dependencies[0].srcAccessMask = VK_ACCESS_MEMORY_READ_BIT;
+		dependencies[0].dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+		dependencies[0].dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
+
+		// Second dependency at the end the renderpass
+		// Does the transition from the initial to the final layout
+		dependencies[1].srcSubpass = 0;													// Producer of the dependency is our single subpass
+		dependencies[1].dstSubpass = VK_SUBPASS_EXTERNAL;								// Consumer are all commands outside of the renderpass
+		dependencies[1].srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;	
+		dependencies[1].dstStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
+		dependencies[1].srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+		dependencies[1].dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
+		dependencies[1].dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
+
+		// Create the actual renderpass
+		VkRenderPassCreateInfo renderPassInfo = {};
+		renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
+		renderPassInfo.attachmentCount = static_cast<uint32_t>(attachments.size());		// Number of attachments used by this render pass
+		renderPassInfo.pAttachments = attachments.data();								// Descriptions of the attachments used by the render pass
+		renderPassInfo.subpassCount = 1;												// We only use one subpass in this example
+		renderPassInfo.pSubpasses = &subpassDescription;								// Description of that subpass
+		renderPassInfo.dependencyCount = static_cast<uint32_t>(dependencies.size());	// Number of subpass dependencies
+		renderPassInfo.pDependencies = dependencies.data();								// Subpass dependencies used by the render pass
+
+		VK_CHECK_RESULT(vkCreateRenderPass( device, &renderPassInfo, nullptr, &renderTarget.renderPass));
+	}
+	// Create framebuffer
+	{	
+		// Create a frame buffer for every image in the swapchain
+		renderTarget.framebuffers.resize(images.size());
+		for (size_t i = 0; i < renderTarget.framebuffers.size(); i++)
+		{
+			std::array<VkImageView, 2> attachments;										
+			attachments[0] = renderTarget.attachments[i].view;	// Color attachment is the view of the swapchain image			
+			attachments[1] = depthAttachment.view;				// Depth/Stencil attachment is the same for all frame buffers			
+
+			VkFramebufferCreateInfo frameBufferCreateInfo = {};
+			frameBufferCreateInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
+			// All frame buffers use the same renderpass setup
+			frameBufferCreateInfo.renderPass = renderTarget.renderPass;
+			frameBufferCreateInfo.attachmentCount = static_cast<uint32_t>(attachments.size());
+			frameBufferCreateInfo.pAttachments = attachments.data();
+			frameBufferCreateInfo.width = width;
+			frameBufferCreateInfo.height = height;
+			frameBufferCreateInfo.layers = 1;
+			// Create the framebuffer
+			VK_CHECK_RESULT(vkCreateFramebuffer( device, &frameBufferCreateInfo, nullptr, &renderTarget.framebuffers[i]));
+		}
+	
+	}
+/*
+	{
+		renderTarget.device = &device;
+		// attach targets
+		struct {
+			size_t color, depth;
+		} attachments;
+
+		attachments.color = 0; {
+
+		}
+		attachments.depth = renderTarget.attach( ext::vulkan::settings::formats::depth, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL ); // depth
+
+		// First pass: fill the G-Buffer
+		{
+			renderTarget.addPass(
+				VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+				{ attachments.color },
+				{},
+				attachments.depth
+			);
+		}
+	}
+	renderTarget.initialize( device );
+*/
+	// Set sync objects
+	{
+		// Semaphores (Used for correct command ordering)
+		VkSemaphoreCreateInfo semaphoreCreateInfo = {};
+		semaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
+		semaphoreCreateInfo.pNext = nullptr;
+
+		// Semaphore used to ensures that image presentation is complete before starting to submit again
+		VK_CHECK_RESULT(vkCreateSemaphore(device, &semaphoreCreateInfo, nullptr, &swapchain.presentCompleteSemaphore));
+	}
+}
+
+void ext::vulkan::BaseRenderMode::destroy() {
+	if ( renderTarget.renderPass != VK_NULL_HANDLE ) {
+		vkDestroyRenderPass( *device, renderTarget.renderPass, nullptr );
+		renderTarget.renderPass = VK_NULL_HANDLE;
+	}
+	
+	for ( uint32_t i = 0; i < renderTarget.framebuffers.size(); i++ ) {
+		if ( renderTarget.framebuffers[i] != VK_NULL_HANDLE ) {
+			vkDestroyFramebuffer( *device, renderTarget.framebuffers[i], nullptr );
+			renderTarget.framebuffers[i] = VK_NULL_HANDLE;
+		}
+	}
+	for ( auto& attachment : renderTarget.attachments ) {
+		if ( attachment.view != VK_NULL_HANDLE ) {
+			vkDestroyImageView( *device, attachment.view, nullptr);
+			attachment.view = VK_NULL_HANDLE;
+		}
+		if ( attachment.descriptor.aliased ) continue;
+		if ( attachment.image != VK_NULL_HANDLE ) {
+		//	vkDestroyImage( *device, attachment.image, nullptr );
+			vmaDestroyImage( allocator, attachment.image, attachment.allocation );
+			attachment.image = VK_NULL_HANDLE;
+		}
+		if ( attachment.mem != VK_NULL_HANDLE ) {
+		//	vkFreeMemory( *device, attachment.mem, nullptr );
+			attachment.mem = VK_NULL_HANDLE;
+		}
+	}
+	
+	ext::vulkan::RenderMode::destroy();
+
+	if ( swapchain.presentCompleteSemaphore != VK_NULL_HANDLE ) {
+		vkDestroySemaphore( *device, swapchain.presentCompleteSemaphore, nullptr);
+	}
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/vulkan/rendermodes/compute.cpp b/engine/src/ext/vulkan/rendermodes/compute.cpp
new file mode 100644
index 00000000..d08a348e
--- /dev/null
+++ b/engine/src/ext/vulkan/rendermodes/compute.cpp
@@ -0,0 +1,245 @@
+#if UF_USE_VULKAN
+
+#include <uf/ext/vulkan/vulkan.h>
+#include <uf/ext/vulkan/rendermodes/compute.h>
+#include <uf/ext/vulkan/rendermodes/deferred.h>
+#include <uf/ext/vulkan/rendermodes/rendertarget.h>
+#include <uf/ext/vulkan/initializers.h>
+#include <uf/ext/openvr/openvr.h>
+#include <uf/utils/window/window.h>
+#include <uf/utils/graphic/graphic.h>
+#include <uf/ext/vulkan/graphic.h>
+#include <uf/engine/scene/scene.h>
+#include <uf/utils/camera/camera.h>
+#include <uf/utils/math/transform.h>
+
+#include <uf/ext/vulkan/graphic.h>
+
+const std::string ext::vulkan::ComputeRenderMode::getType() const {
+	return "Compute";
+}
+const size_t ext::vulkan::ComputeRenderMode::blitters() const {
+	return 1;
+}
+ext::vulkan::Graphic* ext::vulkan::ComputeRenderMode::getBlitter( size_t i ) {
+	return &this->blitter;
+}
+std::vector<ext::vulkan::Graphic*> ext::vulkan::ComputeRenderMode::getBlitters() {
+	return { &this->blitter };
+}
+
+void ext::vulkan::ComputeRenderMode::initialize( Device& device ) {
+	ext::vulkan::RenderMode::initialize( device );
+
+//	this->width = 3840;
+//	this->height = 2160;
+
+	{
+		auto width = this->width > 0 ? this->width : ext::vulkan::settings::width;
+		auto height = this->height > 0 ? this->height : ext::vulkan::settings::height;
+
+		compute.device = &device;
+		compute.material.device = &device;
+		compute.descriptor.renderMode = this->getName();
+		compute.material.initializeShaders({
+			{uf::io::root+"/shaders/raytracing/comp.spv", VK_SHADER_STAGE_COMPUTE_BIT},
+		});
+	#if UF_USE_OPENVR
+		size_t eyes = (ext::openvr::context ? 2 : 1);
+	#else
+		size_t eyes = 1;
+	#endif
+		for ( size_t i = 0; i < eyes; ++i ) {
+			Texture2D& texture = compute.material.textures.emplace_back();
+			texture.asRenderTarget( device, width, height );
+		}
+
+		{
+			auto& scene = uf::scene::getCurrentScene();
+			auto& metadata = scene.getComponent<uf::Serializer>();
+
+			auto& shader = compute.material.shaders.front();
+
+			struct SpecializationConstant {
+				uint32_t maxLights = 16;
+				uint32_t eyes = 2;
+			};
+			auto& specializationConstants = shader.specializationConstants.get<SpecializationConstant>();
+			specializationConstants.maxLights = metadata["system"]["config"]["engine"]["scenes"]["lights"]["max"].as<size_t>();
+			specializationConstants.eyes = eyes;
+			for ( auto& binding : shader.descriptorSetLayoutBindings ) {
+				if ( binding.descriptorCount > 1 ) {
+					binding.descriptorCount = specializationConstants.eyes;
+				}
+			}
+		}
+
+		// update buffers
+		if ( !compute.buffers.empty() ) {
+		//	compute.getPipeline().update( compute );
+			compute.updatePipelines();
+		}
+	}
+	{
+		uf::BaseMesh<pod::Vertex_2F2F, uint32_t> mesh;
+		mesh.vertices = {
+			{ {-1.0f, 1.0f}, {0.0f, 1.0f}, },
+			{ {-1.0f, -1.0f}, {0.0f, 0.0f}, },
+			{ {1.0f, -1.0f}, {1.0f, 0.0f}, },
+			{ {1.0f, 1.0f}, {1.0f, 1.0f}, }
+		};
+		mesh.indices = {
+			0, 1, 2, 2, 3, 0
+		};
+		blitter.device = &device;
+		blitter.material.device = &device;
+		blitter.descriptor.subpass = 1;
+
+		blitter.descriptor.depth.test = false;
+		blitter.descriptor.depth.write = false;
+
+		blitter.initializeMesh( mesh );
+		blitter.material.initializeShaders({
+			{uf::io::root+"/shaders/display/blit.vert.spv", VK_SHADER_STAGE_VERTEX_BIT},
+			{uf::io::root+"/shaders/display/blit.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT}
+		});
+		for ( auto& computeTexture : compute.material.textures ) {
+			Texture2D& texture = blitter.material.textures.emplace_back();
+			texture = computeTexture;
+			texture.device = NULL;
+		}
+		blitter.initializePipeline();
+	}
+}
+void ext::vulkan::ComputeRenderMode::render() {
+	if ( compute.buffers.empty() ) return;
+
+	auto& commands = getCommands( this->mostRecentCommandPoolId );
+	// Submit compute commands
+	// Use a fence to ensure that compute command buffer has finished executing before using it again
+	VK_CHECK_RESULT(vkWaitForFences( *device, 1, &fences[states::currentBuffer], VK_TRUE, UINT64_MAX ));
+	VK_CHECK_RESULT(vkResetFences( *device, 1, &fences[states::currentBuffer] ));
+
+	VkSubmitInfo submitInfo = ext::vulkan::initializers::submitInfo();
+	submitInfo.commandBufferCount = 1;
+	submitInfo.pCommandBuffers = &commands[states::currentBuffer];
+
+	VK_CHECK_RESULT(vkQueueSubmit(device->getQueue( Device::QueueEnum::COMPUTE ), 1, &submitInfo, fences[states::currentBuffer]));
+	//vkQueueSubmit(device->queues.compute, 1, &submitInfo, fences[states::currentBuffer]);
+}
+void ext::vulkan::ComputeRenderMode::tick() {
+	ext::vulkan::RenderMode::tick();
+
+#if UF_USE_OPENVR
+	size_t eyes = (ext::openvr::context ? 2 : 1);
+#else
+	size_t eyes = 1;
+#endif
+	if ( ext::vulkan::states::resized ) {
+		// auto-resize texture
+		if ( this->width == 0 && this->height == 0 ) {
+			auto width = this->width > 0 ? this->width : ext::vulkan::settings::width;
+			auto height = this->height > 0 ? this->height : ext::vulkan::settings::height;
+			for ( auto& texture : compute.material.textures ) {
+				texture.destroy();
+			}
+			compute.material.textures.clear();
+			for ( size_t i = 0; i < eyes; ++i ) {
+				Texture2D& texture = compute.material.textures.emplace_back();
+				texture.asRenderTarget( *device, width, height );
+			}
+		}
+		// update blitter descriptor set
+		if ( blitter.initialized ) {
+			blitter.material.textures.clear();
+			for ( auto& computeTexture : compute.material.textures ) {
+				Texture2D& texture = blitter.material.textures.emplace_back();
+				texture = computeTexture;
+				texture.device = NULL;
+			}
+			blitter.getPipeline().update( blitter );
+		//	blitter.updatePipelines();
+		}
+		if ( !compute.buffers.empty() ) {
+			compute.getPipeline().update( compute );
+		//	compute.updatePipelines();
+		}
+	}
+}
+void ext::vulkan::ComputeRenderMode::destroy() {
+	ext::vulkan::RenderMode::destroy();
+	blitter.destroy();
+	compute.destroy();
+}
+void ext::vulkan::ComputeRenderMode::pipelineBarrier( VkCommandBuffer commandBuffer, uint8_t state ) {
+	if ( compute.buffers.empty() ) return;
+	
+	VkImageMemoryBarrier imageMemoryBarrier = {};
+	imageMemoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+	imageMemoryBarrier.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
+
+	for ( auto& texture : compute.material.textures ) {
+		VkPipelineStageFlags srcStageMask, dstStageMask;
+		imageMemoryBarrier.image = texture.image;
+		imageMemoryBarrier.oldLayout = texture.descriptor.imageLayout;
+		imageMemoryBarrier.newLayout = texture.descriptor.imageLayout;
+	
+		switch ( state ) {
+			case 0: {
+				imageMemoryBarrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
+				imageMemoryBarrier.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_SHADER_READ_BIT;
+				imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_GENERAL;
+				srcStageMask = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
+				dstStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
+			} break;
+			case 1: {
+				imageMemoryBarrier.srcAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_SHADER_READ_BIT;
+				imageMemoryBarrier.dstAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
+				imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_GENERAL;
+				srcStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
+				dstStageMask = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
+			} break;
+			// ensure 
+			default: {
+				imageMemoryBarrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
+				imageMemoryBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
+				srcStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
+				dstStageMask = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
+			}
+		}
+		
+		vkCmdPipelineBarrier( commandBuffer,
+			srcStageMask, dstStageMask,
+			VK_FLAGS_NONE,
+			0, NULL,
+			0, NULL,
+			1, &imageMemoryBarrier
+		);
+	
+		texture.descriptor.imageLayout = imageMemoryBarrier.newLayout;
+	}
+}
+void ext::vulkan::ComputeRenderMode::createCommandBuffers( ) {
+	this->synchronize();
+
+	float width = this->width > 0 ? this->width : ext::vulkan::settings::width;
+	float height = this->height > 0 ? this->height : ext::vulkan::settings::height;
+
+	VkCommandBufferBeginInfo cmdBufInfo = ext::vulkan::initializers::commandBufferBeginInfo();
+	auto& pipeline = compute.getPipeline();
+	auto& commands = getCommands();
+	if ( compute.buffers.empty() ) return;
+	for (size_t i = 0; i < commands.size(); ++i) {
+		VK_CHECK_RESULT(vkBeginCommandBuffer(commands[i], &cmdBufInfo));
+			pipeline.record(compute, commands[i]);
+			vkCmdDispatch(commands[i], width / dispatchSize.x, height / dispatchSize.y, 1);
+		VK_CHECK_RESULT(vkEndCommandBuffer(commands[i]));
+	}
+	
+	this->mostRecentCommandPoolId = std::this_thread::get_id();
+}
+void ext::vulkan::ComputeRenderMode::bindPipelines() {
+	
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/vulkan/rendermodes/deferred.cpp b/engine/src/ext/vulkan/rendermodes/deferred.cpp
new file mode 100644
index 00000000..e9db4a1e
--- /dev/null
+++ b/engine/src/ext/vulkan/rendermodes/deferred.cpp
@@ -0,0 +1,494 @@
+#if UF_USE_VULKAN
+
+#include <uf/ext/vulkan/vulkan.h>
+#include <uf/ext/vulkan/rendermodes/deferred.h>
+#include <uf/ext/vulkan/rendermodes/rendertarget.h>
+#include <uf/ext/vulkan/initializers.h>
+#include <uf/utils/window/window.h>
+#include <uf/utils/graphic/graphic.h>
+#include <uf/ext/vulkan/graphic.h>
+#include <uf/engine/scene/scene.h>
+#include <uf/utils/camera/camera.h>
+#include <uf/utils/math/transform.h>
+
+#include <uf/ext/vulkan/graphic.h>
+#include <uf/ext/gltf/graph.h>
+
+const std::string ext::vulkan::DeferredRenderMode::getType() const {
+	return "Deferred";
+}
+const size_t ext::vulkan::DeferredRenderMode::blitters() const {
+	return 1;
+}
+ext::vulkan::Graphic* ext::vulkan::DeferredRenderMode::getBlitter( size_t i ) {
+	return &this->blitter;
+}
+std::vector<ext::vulkan::Graphic*> ext::vulkan::DeferredRenderMode::getBlitters() {
+	return { &this->blitter };
+}
+
+void ext::vulkan::DeferredRenderMode::initialize( Device& device ) {
+	if ( !metadata["eyes"].is<size_t>() ) metadata["eyes"] = 1;
+	metadata["outputs"] = ext::json::array();
+	{
+		float width = this->width > 0 ? this->width : ext::vulkan::settings::width;
+		float height = this->height > 0 ? this->height : ext::vulkan::settings::height;
+		auto& swapchainRender = ext::vulkan::getRenderMode("Swapchain");
+		if ( swapchainRender.renderTarget.width != width || swapchainRender.renderTarget.height != height ) {
+			settings::experimental::deferredAliasOutputToSwapchain = false;
+		}
+	}
+
+	ext::vulkan::RenderMode::initialize( device );
+	renderTarget.device = &device;
+	size_t eyes = metadata["eyes"].as<size_t>();
+	for ( size_t eye = 0; eye < eyes; ++eye ) {
+		struct {
+			size_t id, normals, uvs, albedo, depth, output;
+		} attachments;
+		size_t msaa = ext::vulkan::settings::msaa;
+
+		attachments.id = renderTarget.attach(RenderTarget::Attachment::Descriptor{
+			/*.format = */VK_FORMAT_R16G16_UINT,
+			/*.layout = */VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+			/*.usage = */VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
+			/*.blend = */false,
+			/*.samples = */msaa,
+		});
+		attachments.normals = renderTarget.attach(RenderTarget::Attachment::Descriptor{
+			/*.format = */VK_FORMAT_R16G16_SFLOAT,
+			/*.layout = */VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+			/*.usage = */VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
+			/*.blend = */false,
+			/*.samples = */msaa,
+		});
+		if ( ext::vulkan::settings::experimental::deferredMode == "deferredSampling" ) {
+			attachments.uvs = renderTarget.attach(RenderTarget::Attachment::Descriptor{
+				/*.format = */VK_FORMAT_R16G16_UNORM,
+				/*.layout = */VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+				/*.usage = */VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
+				/*.blend = */false,
+				/*.samples = */msaa,
+			});
+		} else {
+			attachments.albedo = renderTarget.attach(RenderTarget::Attachment::Descriptor{
+				/*.format = */VK_FORMAT_R8G8B8A8_UNORM,
+				/*.layout = */VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+				/*.usage = */VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
+				/*.blend = */true,
+				/*.samples = */msaa,
+			});
+		}
+		attachments.depth = renderTarget.attach(RenderTarget::Attachment::Descriptor{
+			/*.format = */ext::vulkan::settings::formats::depth,
+			/*.layout = */VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+			/*.usage = */VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
+			/*.blend = */false,
+			/*.samples = */msaa,
+		});
+
+		// Attach swapchain's image as output
+		if ( settings::experimental::deferredAliasOutputToSwapchain ) {
+			attachments.output = renderTarget.attachments.size();
+			auto& swapchainAttachment = renderTarget.attachments.emplace_back();
+			swapchainAttachment.descriptor.format = ext::vulkan::settings::formats::color; //device.formats.color;
+			swapchainAttachment.descriptor.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+			swapchainAttachment.descriptor.layout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
+			swapchainAttachment.descriptor.aliased = true;
+			{
+				VkBool32 blendEnabled = VK_TRUE;
+				VkColorComponentFlags writeMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
+				VkPipelineColorBlendAttachmentState blendAttachmentState = ext::vulkan::initializers::pipelineColorBlendAttachmentState(
+					writeMask,
+					blendEnabled
+				);
+				if ( blendEnabled == VK_TRUE ) {
+					blendAttachmentState.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
+					blendAttachmentState.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
+					blendAttachmentState.colorBlendOp = VK_BLEND_OP_ADD;
+					blendAttachmentState.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
+					blendAttachmentState.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
+					blendAttachmentState.alphaBlendOp = VK_BLEND_OP_ADD;
+				}
+				swapchainAttachment.blendState = blendAttachmentState;
+			}
+		} else {
+			attachments.output = renderTarget.attach(RenderTarget::Attachment::Descriptor{
+				/*.format =*/ VK_FORMAT_R8G8B8A8_UNORM,
+				/*.layout = */ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+				/*.usage =*/ VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
+				/*.blend =*/ true,
+				/*.samples =*/ 1,
+			});
+		}
+		metadata["outputs"].emplace_back(attachments.output);
+		if ( ext::vulkan::settings::experimental::deferredMode == "deferredSampling" ) {
+			// First pass: fill the G-Buffer
+			{
+				renderTarget.addPass(
+					/*.*/ VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+					/*.colors =*/ { attachments.id, attachments.normals, attachments.uvs },
+					/*.inputs =*/ {},
+					/*.resolve =*/ {},
+					/*.depth = */ attachments.depth,
+					/*.autoBuildPipeline =*/ true
+				);
+			}
+			// Second pass: write to output
+			{
+				renderTarget.addPass(
+					/*.*/ VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
+					/*.colors =*/ { attachments.output },
+					/*.inputs =*/ { attachments.id, attachments.normals, attachments.uvs, attachments.depth },
+					/*.resolve =*/ {},
+					/*.depth = */ attachments.depth,
+					/*.autoBuildPipeline =*/ false
+				);
+			}
+		} else {
+			// First pass: fill the G-Buffer
+			{
+				renderTarget.addPass(
+					/*.*/ VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+					/*.colors =*/ { attachments.id, attachments.normals, attachments.albedo },
+					/*.inputs =*/ {},
+					/*.resolve =*/ {},
+					/*.depth = */ attachments.depth,
+					/*.autoBuildPipeline =*/ true
+				);
+			}
+			// Second pass: write to output
+			{
+				renderTarget.addPass(
+					/*.*/ VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
+					/*.colors =*/ { attachments.output },
+					/*.inputs =*/ { attachments.id, attachments.normals, attachments.albedo, attachments.depth },
+					/*.resolve =*/ {},
+					/*.depth = */ attachments.depth,
+					/*.autoBuildPipeline =*/ false
+				);
+			}
+		}
+	}
+	renderTarget.initialize( device );
+
+	{
+		uf::BaseMesh<pod::Vertex_2F2F> mesh;
+		mesh.vertices = {
+			{ {-1.0f, 1.0f}, {0.0f, 1.0f}, },
+			{ {-1.0f, -1.0f}, {0.0f, 0.0f}, },
+			{ {1.0f, -1.0f}, {1.0f, 0.0f}, },
+			{ {1.0f, 1.0f}, {1.0f, 1.0f}, }
+		};
+		mesh.indices = {
+			0, 1, 2, 0, 2, 3
+		};
+		blitter.descriptor.subpass = 1;
+		blitter.descriptor.depth.test = false;
+		blitter.descriptor.depth.write = false;
+
+		blitter.initialize( this->getName() );
+		blitter.initializeMesh( mesh );
+
+		blitter.material.initializeShaders({
+			{uf::io::root+"/shaders/display/subpass.vert.spv", VK_SHADER_STAGE_VERTEX_BIT},
+			{uf::io::root+"/shaders/display/subpass.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT}
+		});
+		{
+			auto& scene = uf::scene::getCurrentScene();
+
+			auto& shader = blitter.material.shaders.back();
+			struct SpecializationConstant {
+				uint32_t maxTextures = 512;
+			};
+			auto& specializationConstants = shader.specializationConstants.get<SpecializationConstant>();
+
+			auto& metadata = scene.getComponent<uf::Serializer>();
+			size_t maxLights = metadata["system"]["config"]["engine"]["scenes"]["lights"]["max"].as<size_t>();
+			specializationConstants.maxTextures = metadata["system"]["config"]["engine"]["scenes"]["textures"]["max"].as<size_t>();
+			for ( auto& binding : shader.descriptorSetLayoutBindings ) {
+				if ( binding.descriptorCount > 1 )
+					binding.descriptorCount = specializationConstants.maxTextures;
+			}
+
+			std::vector<pod::Light::Storage> lights(maxLights);
+			std::vector<pod::Material::Storage> materials(specializationConstants.maxTextures);
+			std::vector<pod::Texture::Storage> textures(specializationConstants.maxTextures);
+			std::vector<pod::DrawCall::Storage> drawCalls(specializationConstants.maxTextures);
+
+			for ( auto& material : materials ) material.colorBase = {0,0,0,0};
+
+			this->metadata["lightBufferIndex"] = blitter.initializeBuffer(
+				(void*) lights.data(),
+				lights.size() * sizeof(pod::Light::Storage),
+				VK_BUFFER_USAGE_STORAGE_BUFFER_BIT
+			);
+			this->metadata["materialBufferIndex"] = blitter.initializeBuffer(
+				(void*) materials.data(),
+				materials.size() * sizeof(pod::Material::Storage),
+				VK_BUFFER_USAGE_STORAGE_BUFFER_BIT
+			);
+
+			this->metadata["textureBufferIndex"] = blitter.initializeBuffer(
+				(void*) textures.data(),
+				textures.size() * sizeof(pod::Texture::Storage),
+				VK_BUFFER_USAGE_STORAGE_BUFFER_BIT
+			);
+
+			this->metadata["drawCallBufferIndex"] = blitter.initializeBuffer(
+				(void*) drawCalls.data(),
+				drawCalls.size() * sizeof(pod::DrawCall::Storage),
+				VK_BUFFER_USAGE_STORAGE_BUFFER_BIT
+			);
+		}
+		blitter.initializePipeline();
+		for ( size_t eye = 0; eye < eyes; ++eye ) {
+			ext::vulkan::GraphicDescriptor descriptor = blitter.descriptor;
+			descriptor.subpass = 2 * eye + 1;
+			if ( blitter.hasPipeline( descriptor ) ) continue;
+			blitter.initializePipeline( descriptor );
+		}
+	}
+}
+void ext::vulkan::DeferredRenderMode::tick() {
+	ext::vulkan::RenderMode::tick();
+	
+	if ( ext::vulkan::states::resized ) {
+		renderTarget.initialize( *renderTarget.device );
+		// update blitter descriptor set
+		if ( blitter.initialized ) {
+			blitter.getPipeline().update( blitter );
+		//	blitter.updatePipelines();
+		}
+	}
+}
+void ext::vulkan::DeferredRenderMode::destroy() {
+	ext::vulkan::RenderMode::destroy();
+	blitter.destroy();
+}
+void ext::vulkan::DeferredRenderMode::createCommandBuffers( const std::vector<ext::vulkan::Graphic*>& graphics ) {
+	float width = this->width > 0 ? this->width : ext::vulkan::settings::width;
+	float height = this->height > 0 ? this->height : ext::vulkan::settings::height;
+
+	if ( !metadata["eyes"].is<size_t>() ) metadata["eyes"] = 1;
+	size_t eyes = metadata["eyes"].as<size_t>();
+
+	VkCommandBufferBeginInfo cmdBufInfo = {};
+	cmdBufInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+	cmdBufInfo.pNext = nullptr;
+
+	VkImageMemoryBarrier imageMemoryBarrier = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
+	imageMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; // ext::vulkan::device.queueFamilyIndices.graphics; //VK_QUEUE_FAMILY_IGNORED
+	imageMemoryBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; // ext::vulkan::device.queueFamilyIndices.graphics; //VK_QUEUE_FAMILY_IGNORED
+	imageMemoryBarrier.subresourceRange.baseMipLevel = 0;
+	imageMemoryBarrier.subresourceRange.levelCount = 1;
+	imageMemoryBarrier.subresourceRange.baseArrayLayer = 0;
+	imageMemoryBarrier.subresourceRange.layerCount = 1;
+	imageMemoryBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+
+	std::vector<RenderMode*> layers = ext::vulkan::getRenderModes(std::vector<std::string>{"RenderTarget", "Compute"}, false);
+	auto& scene = uf::scene::getCurrentScene();
+	auto& sceneMetadata = scene.getComponent<uf::Serializer>();
+	auto& commands = getCommands();
+	auto& swapchainRender = ext::vulkan::getRenderMode("Swapchain");
+	for (size_t i = 0; i < commands.size(); ++i) {
+		VK_CHECK_RESULT(vkBeginCommandBuffer(commands[i], &cmdBufInfo));
+		// Fill GBuffer
+		{
+			std::vector<VkClearValue> clearValues;
+			for ( auto& attachment : renderTarget.attachments ) {
+				VkClearValue clearValue;
+				if ( attachment.descriptor.usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT ) {
+					if ( !ext::json::isNull( sceneMetadata["system"]["renderer"]["clear values"][(int) clearValues.size()] ) ) {
+						auto& v = sceneMetadata["system"]["renderer"]["clear values"][(int) clearValues.size()];
+						clearValue.color = { {
+							v[0].as<float>(),
+							v[1].as<float>(),
+							v[2].as<float>(),
+							v[3].as<float>(),
+						} };
+					} else {
+						clearValue.color = { { 0, 0, 0, 0 } };
+					}
+				} else if ( attachment.descriptor.usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT ) {
+					clearValue.depthStencil = { 0.0f, 0 };
+				}
+				clearValues.push_back(clearValue);
+			}
+
+			VkRenderPassBeginInfo renderPassBeginInfo = {};
+			renderPassBeginInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
+			renderPassBeginInfo.pNext = nullptr;
+			renderPassBeginInfo.renderArea.offset.x = 0;
+			renderPassBeginInfo.renderArea.offset.y = 0;
+			renderPassBeginInfo.renderArea.extent.width = width;
+			renderPassBeginInfo.renderArea.extent.height = height;
+			renderPassBeginInfo.clearValueCount = clearValues.size();
+			renderPassBeginInfo.pClearValues = &clearValues[0];
+			renderPassBeginInfo.renderPass = renderTarget.renderPass;
+			renderPassBeginInfo.framebuffer = renderTarget.framebuffers[i];
+
+			// Update dynamic viewport state
+			VkViewport viewport = {};
+			viewport.width = (float) width;
+			viewport.height = (float) height;
+			viewport.minDepth = (float) 0.0f;
+			viewport.maxDepth = (float) 1.0f;
+			
+			// Update dynamic scissor state
+			VkRect2D scissor = {};
+			scissor.extent.width = width;
+			scissor.extent.height = height;
+			scissor.offset.x = 0;
+			scissor.offset.y = 0;
+
+			// transition layers for read
+			for ( auto layer : layers ) {
+				layer->pipelineBarrier( commands[i], 0 );
+			}
+
+			size_t currentSubpass = 0;
+			vkCmdBeginRenderPass(commands[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
+				vkCmdSetViewport(commands[i], 0, 1, &viewport);
+				vkCmdSetScissor(commands[i], 0, 1, &scissor);
+				// render to geometry buffers
+				for ( size_t eye = 0; eye < eyes; ++eye ) {
+					size_t currentPass = 0;
+					size_t currentDraw = 0;
+					for ( auto graphic : graphics ) {
+						// only draw graphics that are assigned to this type of render mode
+						if ( graphic->descriptor.renderMode != this->getName() ) continue;
+						ext::vulkan::GraphicDescriptor descriptor = bindGraphicDescriptor(graphic->descriptor, currentSubpass);
+						graphic->record( commands[i], descriptor, eye, currentDraw++ );
+					}
+					// blit any RT's that request this subpass
+					{
+						for ( auto _ : layers ) {
+							RenderTargetRenderMode* layer = (RenderTargetRenderMode*) _;
+							auto& blitter = layer->blitter;
+							if ( !blitter.initialized || !blitter.process || blitter.descriptor.subpass != currentPass ) continue;
+							ext::vulkan::GraphicDescriptor descriptor = bindGraphicDescriptor(blitter.descriptor, currentSubpass);
+							blitter.record(commands[i], descriptor);
+						}
+					}
+				vkCmdNextSubpass(commands[i], VK_SUBPASS_CONTENTS_INLINE); ++currentPass; ++currentSubpass;
+					// deferred post-processing lighting pass
+					{
+						ext::vulkan::GraphicDescriptor descriptor = bindGraphicDescriptor(blitter.descriptor, currentSubpass);
+						blitter.record(commands[i], descriptor, eye, currentDraw++);
+					}
+					// blit any RT's that request this subpass
+					{
+						for ( auto _ : layers ) {
+							RenderTargetRenderMode* layer = (RenderTargetRenderMode*) _;
+							auto& blitter = layer->blitter;
+							if ( !blitter.initialized || !blitter.process || blitter.descriptor.subpass != currentPass ) continue;
+							ext::vulkan::GraphicDescriptor descriptor = bindGraphicDescriptor(blitter.descriptor, currentSubpass);
+							blitter.record(commands[i], descriptor, eye, currentDraw++);
+						}
+					}
+					if ( eye + 1 < eyes ) vkCmdNextSubpass(commands[i], VK_SUBPASS_CONTENTS_INLINE); ++currentSubpass;
+				}
+			vkCmdEndRenderPass(commands[i]);
+
+			for ( auto layer : layers ) {
+				layer->pipelineBarrier( commands[i], 1 );
+			}
+			
+			if ( !settings::experimental::deferredAliasOutputToSwapchain ) {
+				{
+					auto& renderTarget = swapchainRender.renderTarget;
+					float width = renderTarget.width;
+					float height = renderTarget.height;
+
+					std::vector<VkClearValue> clearValues; clearValues.resize(2);
+					clearValues[0].color = { { 0.0f, 0.0f, 0.0f, 1.0f } };
+					clearValues[1].depthStencil = { 1.0f, 0 };
+
+					VkRenderPassBeginInfo renderPassBeginInfo = {};
+					renderPassBeginInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
+					renderPassBeginInfo.pNext = nullptr;
+					renderPassBeginInfo.renderArea.offset.x = 0;
+					renderPassBeginInfo.renderArea.offset.y = 0;
+					renderPassBeginInfo.renderArea.extent.width = width;
+					renderPassBeginInfo.renderArea.extent.height = height;
+					renderPassBeginInfo.clearValueCount = clearValues.size();
+					renderPassBeginInfo.pClearValues = &clearValues[0];
+					renderPassBeginInfo.renderPass = renderTarget.renderPass;
+					renderPassBeginInfo.framebuffer = renderTarget.framebuffers[i];
+
+					vkCmdBeginRenderPass(commands[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
+					vkCmdEndRenderPass(commands[i]);
+				}
+
+				{
+					VkImageBlit imageBlitRegion{};
+					imageBlitRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+					imageBlitRegion.srcSubresource.layerCount = 1;
+					imageBlitRegion.srcOffsets[1] = { width, height, 1 };
+					imageBlitRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+					imageBlitRegion.dstSubresource.layerCount = 1;
+					imageBlitRegion.dstOffsets[1] = {
+						swapchainRender.width > 0 ? swapchainRender.width : ext::vulkan::settings::width,
+						swapchainRender.height > 0 ? swapchainRender.height : ext::vulkan::settings::height,
+						1
+					};
+					auto& outputAttachment = renderTarget.attachments[metadata["outputs"][0].as<size_t>()];
+					// Transition to KHR
+					{
+						imageMemoryBarrier.image = outputAttachment.image;
+						imageMemoryBarrier.srcAccessMask = 0;
+						imageMemoryBarrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+						imageMemoryBarrier.oldLayout = outputAttachment.descriptor.layout;
+						imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+						vkCmdPipelineBarrier( commands[i], VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, NULL, 0, NULL, 1, &imageMemoryBarrier );
+						outputAttachment.descriptor.layout = imageMemoryBarrier.newLayout;
+					}
+					{
+						imageMemoryBarrier.image = swapchainRender.renderTarget.attachments[i].image;
+						imageMemoryBarrier.srcAccessMask = 0;
+						imageMemoryBarrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+						imageMemoryBarrier.oldLayout = swapchainRender.renderTarget.attachments[i].descriptor.layout;
+						imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+						vkCmdPipelineBarrier( commands[i], VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, NULL, 0, NULL, 1, &imageMemoryBarrier );
+						swapchainRender.renderTarget.attachments[i].descriptor.layout = imageMemoryBarrier.newLayout;
+					}
+
+					vkCmdBlitImage(
+						commands[i],
+						outputAttachment.image,
+						VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+						swapchainRender.renderTarget.attachments[i].image,
+						VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+						1,
+						&imageBlitRegion,
+						settings::swapchainUpscaleFilter
+					);
+
+					{
+						imageMemoryBarrier.image = outputAttachment.image;
+						imageMemoryBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+						imageMemoryBarrier.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+						imageMemoryBarrier.oldLayout = outputAttachment.descriptor.layout;
+						imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+						vkCmdPipelineBarrier( commands[i], VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, NULL, 0, NULL, 1, &imageMemoryBarrier );
+						outputAttachment.descriptor.layout = imageMemoryBarrier.newLayout;
+					}
+					{
+						imageMemoryBarrier.image = swapchainRender.renderTarget.attachments[i].image;
+						imageMemoryBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+						imageMemoryBarrier.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+						imageMemoryBarrier.oldLayout = swapchainRender.renderTarget.attachments[i].descriptor.layout;
+						imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
+						vkCmdPipelineBarrier( commands[i], VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, NULL, 0, NULL, 1, &imageMemoryBarrier );
+						swapchainRender.renderTarget.attachments[i].descriptor.layout = imageMemoryBarrier.newLayout;
+					}
+				}
+			}
+		}
+
+		VK_CHECK_RESULT(vkEndCommandBuffer(commands[i]));
+	}
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/vulkan/rendermodes/rendertarget.cpp b/engine/src/ext/vulkan/rendermodes/rendertarget.cpp
new file mode 100644
index 00000000..e30d1a50
--- /dev/null
+++ b/engine/src/ext/vulkan/rendermodes/rendertarget.cpp
@@ -0,0 +1,467 @@
+#if UF_USE_VULKAN
+
+#include <uf/ext/vulkan/vulkan.h>
+#include <uf/ext/vulkan/rendermodes/rendertarget.h>
+#include <uf/ext/vulkan/initializers.h>
+#include <uf/utils/window/window.h>
+#include <uf/utils/graphic/graphic.h>
+#include <uf/ext/vulkan/graphic.h>
+
+const std::string ext::vulkan::RenderTargetRenderMode::getTarget() const {
+	auto& metadata = *const_cast<uf::Serializer*>(&this->metadata);
+	return metadata["target"].as<std::string>();
+}
+void ext::vulkan::RenderTargetRenderMode::setTarget( const std::string& target ) {
+	this->metadata["target"] = target;
+}
+
+const std::string ext::vulkan::RenderTargetRenderMode::getType() const {
+	return "RenderTarget";
+}
+const size_t ext::vulkan::RenderTargetRenderMode::blitters() const {
+	return 1;
+}
+ext::vulkan::Graphic* ext::vulkan::RenderTargetRenderMode::getBlitter( size_t i ) {
+	return &this->blitter;
+}
+std::vector<ext::vulkan::Graphic*> ext::vulkan::RenderTargetRenderMode::getBlitters() {
+	return { &this->blitter };
+}
+
+ext::vulkan::GraphicDescriptor ext::vulkan::RenderTargetRenderMode::bindGraphicDescriptor( const ext::vulkan::GraphicDescriptor& reference, size_t pass ) {
+	ext::vulkan::GraphicDescriptor descriptor = ext::vulkan::RenderMode::bindGraphicDescriptor(reference, pass);
+	descriptor.parse(metadata["descriptor"]);
+	std::string type = metadata["type"].as<std::string>();
+	if ( type == "depth" ) {
+		descriptor.cullMode = VK_CULL_MODE_NONE;
+	}
+	// allows for "easy" remapping for indices ranges
+	if ( ext::json::isObject( metadata["renderMode"]["target"][std::to_string(descriptor.indices)] ) ) {
+		auto& map = metadata["renderMode"]["target"][std::to_string(descriptor.indices)];
+		std::cout << "Replacing " << descriptor.indices;
+		descriptor.indices = map["size"].as<size_t>();
+		descriptor.offsets.index = map["offset"].as<size_t>();
+		std::cout << " with " << descriptor.offsets.index << " + " << descriptor.indices << std::endl;
+	}
+	return descriptor;
+}
+
+void ext::vulkan::RenderTargetRenderMode::initialize( Device& device ) {
+	ext::vulkan::RenderMode::initialize( device );
+
+	this->setTarget( this->getName() );
+	std::string type = metadata["type"].as<std::string>();
+	size_t subpasses = metadata["subpasses"].as<size_t>();
+	if ( subpasses == 0 ) subpasses = 1;
+	renderTarget.device = &device;
+	for ( size_t currentPass = 0; currentPass < subpasses; ++currentPass ) {
+		if ( type == "depth" ) {
+			struct {
+				size_t depth;
+			} attachments;
+
+			attachments.depth = renderTarget.attach(RenderTarget::Attachment::Descriptor{
+				/*.format = */ ext::vulkan::settings::formats::depth,
+				/*.layout = */ VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+				/*.usage = */ VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
+				/*.blend = */ false,
+				/*.samples = */ 1,
+			});
+			renderTarget.addPass(
+				VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+				{},
+				{},
+				{},
+				attachments.depth,
+				true
+			);
+		} else {
+		#if 0
+			struct {
+				size_t albedo, normals, position, depth;
+			} attachments;
+
+			attachments.albedo = renderTarget.attach(RenderTarget::Attachment::Descriptor{
+				/*.format = */ ext::vulkan::settings::formats::color,
+				/*.layout = */ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+				/*.usage = */ VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
+				/*.blend = */ true,
+				/*.samples = */ 1,
+			});
+			attachments.normals = renderTarget.attach(RenderTarget::Attachment::Descriptor{
+				/*.format = */ ext::vulkan::settings::formats::normal,
+				/*.layout = */ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+				/*.usage = */ VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
+				/*.blend = */ false,
+				/*.samples = */ 1,
+			});
+
+			if ( !settings::experimental::deferredReconstructPosition )
+				attachments.position = renderTarget.attach(RenderTarget::Attachment::Descriptor{
+					/*.format = */ ext::vulkan::settings::formats::position,
+					/*.layout = */ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+					/*.usage = */ VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
+					/*.blend = */ false,
+					/*.samples = */ 1,
+				});
+
+			attachments.depth = renderTarget.attach(RenderTarget::Attachment::Descriptor{
+				/*.format = */ ext::vulkan::settings::formats::depth,
+				/*.layout = */ VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+				/*.usage = */ VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
+				/*.blend = */ false,
+				/*.samples = */ 1,
+			});
+
+			// First pass: write to target
+			if ( settings::experimental::deferredReconstructPosition ) {
+				renderTarget.addPass(
+					VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+					{ attachments.albedo, attachments.normals },
+					{},
+					{},
+					attachments.depth
+				);
+			} else {
+				renderTarget.addPass(
+					VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+					{ attachments.albedo, attachments.normals, attachments.position },
+					{},
+					{},
+					attachments.depth
+				);
+			}
+		#else
+			struct {
+				size_t id, normals, uvs, albedo, depth, output;
+			} attachments;
+			size_t msaa = ext::vulkan::settings::msaa;
+
+			attachments.id = renderTarget.attach(RenderTarget::Attachment::Descriptor{
+				/*.format = */VK_FORMAT_R16G16_UINT,
+				/*.layout = */VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+				/*.usage = */VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
+				/*.blend = */false,
+				/*.samples = */msaa,
+			});
+			attachments.normals = renderTarget.attach(RenderTarget::Attachment::Descriptor{
+				/*.format = */VK_FORMAT_R16G16_SFLOAT,
+				/*.layout = */VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+				/*.usage = */VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
+				/*.blend = */false,
+				/*.samples = */msaa,
+			});
+			if ( ext::vulkan::settings::experimental::deferredMode == "deferredSampling" ) {
+				attachments.uvs = renderTarget.attach(RenderTarget::Attachment::Descriptor{
+					/*.format = */VK_FORMAT_R16G16_UNORM,
+					/*.layout = */VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+					/*.usage = */VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
+					/*.blend = */false,
+					/*.samples = */msaa,
+				});
+			} else {
+				attachments.albedo = renderTarget.attach(RenderTarget::Attachment::Descriptor{
+					/*.format = */VK_FORMAT_R8G8B8A8_UNORM,
+					/*.layout = */VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+					/*.usage = */VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
+					/*.blend = */true,
+					/*.samples = */msaa,
+				});
+			}
+			attachments.depth = renderTarget.attach(RenderTarget::Attachment::Descriptor{
+				/*.format = */ext::vulkan::settings::formats::depth,
+				/*.layout = */VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+				/*.usage = */VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
+				/*.blend = */false,
+				/*.samples = */msaa,
+			});
+			attachments.output = renderTarget.attach(RenderTarget::Attachment::Descriptor{
+				/*.format =*/ VK_FORMAT_R8G8B8A8_UNORM,
+				/*.layout = */ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+				/*.usage =*/ VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
+				/*.blend =*/ true,
+				/*.samples =*/ 1,
+			});
+			if ( ext::vulkan::settings::experimental::deferredMode == "deferredSampling" ) {
+				// First pass: fill the G-Buffer
+				{
+					renderTarget.addPass(
+						VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+						{ attachments.id, attachments.normals, attachments.uvs },
+						{},
+						{},
+						attachments.depth,
+						true
+					);
+				}
+				// Second pass: write to output
+				{
+					renderTarget.addPass(
+						VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
+						{ attachments.output },
+						{ attachments.id, attachments.normals, attachments.uvs, attachments.depth },
+						{},
+						attachments.depth,
+						false
+					);
+				}
+			} else {
+				// First pass: fill the G-Buffer
+				{
+					renderTarget.addPass(
+						VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+						{ attachments.id, attachments.normals, attachments.albedo },
+						{},
+						{},
+						attachments.depth,
+						true
+					);
+				}
+				// Second pass: write to output
+				{
+					renderTarget.addPass(
+						VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
+						{ attachments.output },
+						{ attachments.id, attachments.normals, attachments.albedo, attachments.depth },
+						{},
+						attachments.depth,
+						false
+					);
+				}
+			}
+			metadata["outputs"][0] = attachments.output;
+		#endif
+		}
+	}
+
+	renderTarget.initialize( device );
+
+	if ( blitter.process ) {
+		uf::BaseMesh<pod::Vertex_2F2F, uint32_t> mesh;
+		mesh.vertices = {
+			{ {-1.0f, 1.0f}, {0.0f, 1.0f}, },
+			{ {-1.0f, -1.0f}, {0.0f, 0.0f}, },
+			{ {1.0f, -1.0f}, {1.0f, 0.0f}, },
+			{ {1.0f, 1.0f}, {1.0f, 1.0f}, }
+		};
+		mesh.indices = {
+			0, 1, 2, 2, 3, 0
+		};
+		blitter.device = &device;
+		blitter.material.device = &device;
+		blitter.initializeMesh( mesh );
+		blitter.material.initializeShaders({
+			{uf::io::root+"/shaders/display/renderTarget.vert.spv", VK_SHADER_STAGE_VERTEX_BIT},
+			{uf::io::root+"/shaders/display/renderTarget.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT}
+		});
+		
+		for ( auto& attachment : renderTarget.attachments ) {
+			if ( !(attachment.descriptor.usage & VK_IMAGE_USAGE_SAMPLED_BIT) ) continue;
+
+			Texture2D& texture = blitter.material.textures.emplace_back();
+			enums::Filter::type_t filter = VK_FILTER_NEAREST;
+		/*
+			VkFormatProperties formatProperties;
+			vkGetPhysicalDeviceFormatProperties( device.physicalDevice, texture.format, &formatProperties );
+			if ( formatProperties.linearTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT )
+				filter = VK_FILTER_LINEAR;
+		*/
+			texture.sampler.descriptor.filter.min = filter;
+			texture.sampler.descriptor.filter.mag = filter;
+			texture.aliasAttachment(attachment);
+		}
+	}
+}
+
+void ext::vulkan::RenderTargetRenderMode::tick() {
+	ext::vulkan::RenderMode::tick();
+	if ( ext::vulkan::states::resized ) {
+		renderTarget.initialize( *renderTarget.device );
+	/*
+		for ( auto& texture : blitter.material.textures ) {
+			texture.sampler.destroy();
+		}
+	*/
+		blitter.material.textures.clear();
+		for ( auto& attachment : renderTarget.attachments ) {
+			if ( !(attachment.descriptor.usage & VK_IMAGE_USAGE_SAMPLED_BIT) ) continue;
+			Texture2D& texture = blitter.material.textures.emplace_back();
+			enums::Filter::type_t filter = VK_FILTER_NEAREST;
+		/*
+			VkFormatProperties formatProperties;
+			vkGetPhysicalDeviceFormatProperties( device->physicalDevice, texture.format, &formatProperties );
+			if ( formatProperties.linearTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT )
+				filter = VK_FILTER_LINEAR;
+		*/
+			texture.sampler.descriptor.filter.min = filter;
+			texture.sampler.descriptor.filter.mag = filter;
+			texture.aliasAttachment(attachment);
+		}
+		if ( blitter.process ) {
+			blitter.getPipeline().update( blitter );
+		}
+	}
+}
+void ext::vulkan::RenderTargetRenderMode::destroy() {
+	ext::vulkan::RenderMode::destroy();
+	blitter.destroy();
+}
+void ext::vulkan::RenderTargetRenderMode::render() {
+	auto& commands = getCommands( this->mostRecentCommandPoolId );
+	// Submit commands
+	// Use a fence to ensure that command buffer has finished executing before using it again
+	VK_CHECK_RESULT(vkWaitForFences( *device, 1, &fences[states::currentBuffer], VK_TRUE, UINT64_MAX ));
+	VK_CHECK_RESULT(vkResetFences( *device, 1, &fences[states::currentBuffer] ));
+
+	// Pipeline stage at which the queue submission will wait (via pWaitSemaphores)
+	VkPipelineStageFlags waitStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+	// The submit info structure specifices a command buffer queue submission batch
+	VkSubmitInfo submitInfo = {};
+	submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+	submitInfo.pWaitDstStageMask = &waitStageMask;						// Pointer to the list of pipeline stages that the semaphore waits will occur at
+	submitInfo.pWaitSemaphores = NULL;									// Semaphore(s) to wait upon before the submitted command buffer starts executing
+	submitInfo.waitSemaphoreCount = 0;									// One wait semaphore																				
+//	submitInfo.pSignalSemaphores = &renderCompleteSemaphore;			// Semaphore(s) to be signaled when command buffers have completed
+//	submitInfo.signalSemaphoreCount = 1;								// One signal semaphore
+	submitInfo.pSignalSemaphores = NULL;								// Semaphore(s) to be signaled when command buffers have completed
+	submitInfo.signalSemaphoreCount = 0;								// One signal semaphore
+	submitInfo.pCommandBuffers = &commands[states::currentBuffer];		// Command buffers(s) to execute in this batch (submission)
+	submitInfo.commandBufferCount = 1;
+
+	VK_CHECK_RESULT(vkQueueSubmit(device->getQueue( Device::QueueEnum::GRAPHICS ), 1, &submitInfo, fences[states::currentBuffer]));
+	//vkQueueSubmit(device->queues.graphics, 1, &submitInfo, fences[states::currentBuffer]);
+/*
+	VkSemaphoreWaitInfo waitInfo = {};
+	waitInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO;
+	waitInfo.flags = VK_SEMAPHORE_WAIT_ANY_BIT;
+	waitInfo.semaphoreCount = 1;
+	waitInfo.pSemaphores = &renderCompleteSemaphore;
+	waitInfo.pValues = NULL;
+	VK_CHECK_RESULT(vkWaitSemaphores( *device, &waitInfo, UINT64_MAX ));
+*/
+}
+void ext::vulkan::RenderTargetRenderMode::pipelineBarrier( VkCommandBuffer commandBuffer, uint8_t state ) {
+	VkImageMemoryBarrier imageMemoryBarrier = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
+	imageMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; // ext::vulkan::device.queueFamilyIndices.graphics; //VK_QUEUE_FAMILY_IGNORED
+	imageMemoryBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; // ext::vulkan::device.queueFamilyIndices.graphics; //VK_QUEUE_FAMILY_IGNORED
+	imageMemoryBarrier.subresourceRange.baseMipLevel = 0;
+	imageMemoryBarrier.subresourceRange.levelCount = 1;
+	imageMemoryBarrier.subresourceRange.baseArrayLayer = 0;
+	imageMemoryBarrier.subresourceRange.layerCount = 1;
+	imageMemoryBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+
+	for ( auto& attachment : renderTarget.attachments ) {
+		if ( !(attachment.descriptor.usage & VK_IMAGE_USAGE_SAMPLED_BIT) ) continue;
+		if (  (attachment.descriptor.usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) ) continue;
+		
+		VkPipelineStageFlags srcStageMask, dstStageMask;
+		imageMemoryBarrier.image = attachment.image;
+		imageMemoryBarrier.oldLayout = attachment.descriptor.layout;
+		imageMemoryBarrier.newLayout = attachment.descriptor.layout;
+	
+		switch ( state ) {
+			case 0: {
+				imageMemoryBarrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+				imageMemoryBarrier.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_SHADER_READ_BIT;
+				imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+				srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+				dstStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
+			} break;
+			case 1: {
+				imageMemoryBarrier.srcAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_SHADER_READ_BIT;
+				imageMemoryBarrier.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+				imageMemoryBarrier.newLayout = attachment.descriptor.usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+				srcStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
+				dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+			} break;
+			// ensure 
+			default: {
+				imageMemoryBarrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
+				imageMemoryBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
+				srcStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
+				dstStageMask = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
+			}
+		}
+		
+		vkCmdPipelineBarrier( commandBuffer,
+			srcStageMask, dstStageMask,
+			VK_FLAGS_NONE,
+			0, NULL,
+			0, NULL,
+			1, &imageMemoryBarrier
+		);
+
+		attachment.descriptor.layout = imageMemoryBarrier.newLayout;
+	}
+}
+void ext::vulkan::RenderTargetRenderMode::createCommandBuffers( const std::vector<ext::vulkan::Graphic*>& graphics ) {
+	// destroy if exists
+	float width = this->width > 0 ? this->width : ext::vulkan::settings::width;
+	float height = this->height > 0 ? this->height : ext::vulkan::settings::height;
+
+	VkCommandBufferBeginInfo cmdBufInfo = {};
+	cmdBufInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+	cmdBufInfo.pNext = nullptr;
+	auto& commands = getCommands();
+	for (size_t i = 0; i < commands.size(); ++i) {
+		VK_CHECK_RESULT(vkBeginCommandBuffer(commands[i], &cmdBufInfo));
+		{
+			std::vector<VkClearValue> clearValues;
+			for ( auto& attachment : renderTarget.attachments ) {
+				VkClearValue clearValue;
+				if ( attachment.descriptor.usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT ) {
+					clearValue.color = { { 0.0f, 0.0f, 0.0f, 0.0f } };
+				} else if ( attachment.descriptor.usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT ) {
+					clearValue.depthStencil = { 0.0f, 0 };
+				}
+				clearValues.push_back(clearValue);
+			}
+
+			VkRenderPassBeginInfo renderPassBeginInfo = {};
+			renderPassBeginInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
+			renderPassBeginInfo.pNext = nullptr;
+			renderPassBeginInfo.renderArea.offset.x = 0;
+			renderPassBeginInfo.renderArea.offset.y = 0;
+			renderPassBeginInfo.renderArea.extent.width = width;
+			renderPassBeginInfo.renderArea.extent.height = height;
+			renderPassBeginInfo.clearValueCount = clearValues.size();
+			renderPassBeginInfo.pClearValues = &clearValues[0];
+			renderPassBeginInfo.renderPass = renderTarget.renderPass;
+			renderPassBeginInfo.framebuffer = renderTarget.framebuffers[i];
+
+			// Update dynamic viewport state
+			VkViewport viewport = {};
+			viewport.width = (float) width;
+			viewport.height = (float) height;
+			viewport.minDepth = (float) 0.0f;
+			viewport.maxDepth = (float) 1.0f;
+			
+			// Update dynamic scissor state
+			VkRect2D scissor = {};
+			scissor.extent.width = width;
+			scissor.extent.height = height;
+			scissor.offset.x = 0;
+			scissor.offset.y = 0;
+
+			size_t subpasses = renderTarget.passes.size();
+			size_t currentPass = 0;
+			vkCmdBeginRenderPass(commands[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
+				vkCmdSetViewport(commands[i], 0, 1, &viewport);
+				vkCmdSetScissor(commands[i], 0, 1, &scissor);
+				for ( ; currentPass < subpasses; ++currentPass ) {
+					size_t currentDraw = 0;
+					for ( auto graphic : graphics ) {
+						if ( graphic->descriptor.renderMode != this->getTarget() ) continue;
+						ext::vulkan::GraphicDescriptor descriptor = bindGraphicDescriptor(graphic->descriptor, currentPass);
+						graphic->record( commands[i], descriptor, currentPass, currentDraw++ );
+					}
+					if ( currentPass + 1 < subpasses ) vkCmdNextSubpass(commands[i], VK_SUBPASS_CONTENTS_INLINE);
+				}
+			vkCmdEndRenderPass(commands[i]);
+		}
+
+		VK_CHECK_RESULT(vkEndCommandBuffer(commands[i]));
+	}
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/vulkan/rendertarget.cpp b/engine/src/ext/vulkan/rendertarget.cpp
new file mode 100644
index 00000000..348d5383
--- /dev/null
+++ b/engine/src/ext/vulkan/rendertarget.cpp
@@ -0,0 +1,347 @@
+#if UF_USE_VULKAN
+
+#include <uf/ext/vulkan/vulkan.h>
+#include <uf/ext/vulkan/rendertarget.h>
+#include <uf/ext/vulkan/initializers.h>
+#include <uf/utils/window/window.h>
+
+void ext::vulkan::RenderTarget::addPass( VkPipelineStageFlags stage, VkAccessFlags access, const std::vector<size_t>& colors, const std::vector<size_t>& inputs, const std::vector<size_t>& resolves, size_t depth, bool autoBuildPipeline ) {
+	Subpass pass;
+	pass.stage = stage;
+	pass.access = access;
+	pass.autoBuildPipeline = autoBuildPipeline;
+	for ( auto& i : colors )  pass.colors.push_back(  { (uint32_t) i, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL } );
+	for ( auto& i : inputs )  pass.inputs.push_back(  { (uint32_t) i, i == depth ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL  : VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL } );
+	for ( auto& i : resolves ) pass.resolves.push_back( { (uint32_t) i, i == depth ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL  : VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL } );
+//	for ( auto& i : inputs )  pass.inputs.push_back(  { (uint32_t) i, i == depth ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL } );
+	if ( depth < attachments.size() ) pass.depth = { (uint32_t) depth, attachments[depth].descriptor.layout };
+
+	if ( !resolves.empty() && resolves.size() != colors.size() )
+		VK_VALIDATION_MESSAGE("Mismatching resolves count: Expecting " << colors.size() << ", got " << resolves.size());
+
+	passes.push_back(pass);
+}
+size_t ext::vulkan::RenderTarget::attach( const Attachment::Descriptor& descriptor, Attachment* attachment ) {
+	uint32_t width = this->width > 0 ? this->width : ext::vulkan::settings::width;
+	uint32_t height = this->height > 0 ? this->height : ext::vulkan::settings::height;
+
+	if ( attachment ) {
+		if ( attachment->view ) {
+			vkDestroyImageView(*device, attachment->view, nullptr);
+			attachment->view = VK_NULL_HANDLE;
+		}
+		if ( attachment->image ) {
+			vmaDestroyImage( allocator, attachment->image, attachment->allocation );
+			attachment->image = VK_NULL_HANDLE;
+		}
+		if ( attachment->mem ) {
+			attachment->mem = VK_NULL_HANDLE;
+		}
+	} else {
+		attachment = &attachments.emplace_back();
+		attachment->descriptor = descriptor;
+	}
+	// un-request transient attachments if not supported yet requested
+	if ( attachment->descriptor.usage & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT ) {
+		bool supported = false;
+		auto& properties = device->memoryProperties;
+		for ( uint32_t i = 0; i < properties.memoryTypeCount; ++i ) {
+			auto prop = properties.memoryTypes[i].propertyFlags;
+			if ( prop & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT ) {
+				supported = true;
+			}
+		}
+		if ( !supported  ) {
+			VK_VALIDATION_MESSAGE("Transient attachment requested yet not supported, disabling...");
+			attachment->descriptor.usage &= ~VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
+		}
+	}
+
+	VkImageCreateInfo imageCreateInfo = {};
+	imageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
+	imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
+	imageCreateInfo.format = attachment->descriptor.format;
+	imageCreateInfo.extent = { width, height, 1 };
+	imageCreateInfo.mipLevels = 1;
+	imageCreateInfo.arrayLayers = this->views;
+	imageCreateInfo.samples = ext::vulkan::sampleCount( attachment->descriptor.samples );
+	imageCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
+	imageCreateInfo.usage = attachment->descriptor.usage;
+	imageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+
+	VmaAllocationCreateInfo allocInfo = {};
+	allocInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY;
+	if ( attachment->descriptor.usage & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT ) {
+		allocInfo.usage = VMA_MEMORY_USAGE_GPU_LAZILY_ALLOCATED;
+	}
+	VK_CHECK_RESULT(vmaCreateImage(allocator, &imageCreateInfo, &allocInfo, &attachment->image, &attachment->allocation, &attachment->allocationInfo));
+	attachment->mem = attachment->allocationInfo.deviceMemory;
+
+	VkImageAspectFlags aspectMask = 0;
+	// specialization: depth buffer
+	if ( attachment->descriptor.usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT ) {
+		aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; // | VK_IMAGE_ASPECT_STENCIL_BIT;
+	} else {
+		aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+	}
+	VkImageViewCreateInfo imageView = {};
+	imageView.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+	imageView.viewType = VK_IMAGE_VIEW_TYPE_2D;
+	imageView.format = attachment->descriptor.format;
+	imageView.subresourceRange = {};
+	imageView.subresourceRange.aspectMask = aspectMask;
+	imageView.subresourceRange.baseMipLevel = 0;
+	imageView.subresourceRange.levelCount = 1;
+	imageView.subresourceRange.baseArrayLayer = 0;
+	imageView.subresourceRange.layerCount = this->views;
+	imageView.image = attachment->image;
+
+	VK_CHECK_RESULT(vkCreateImageView(*device, &imageView, nullptr, &attachment->view));
+
+	{
+		VkBool32 blendEnabled = VK_FALSE;
+		VkColorComponentFlags writeMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT;
+
+		if ( attachment->descriptor.blend ) {
+			blendEnabled = VK_TRUE;
+			writeMask |= VK_COLOR_COMPONENT_A_BIT;
+		}
+
+		VkPipelineColorBlendAttachmentState blendAttachmentState = ext::vulkan::initializers::pipelineColorBlendAttachmentState(
+			writeMask,
+			blendEnabled
+		);
+		if ( blendEnabled == VK_TRUE ) {
+			blendAttachmentState.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
+			blendAttachmentState.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
+			blendAttachmentState.colorBlendOp = VK_BLEND_OP_ADD;
+			blendAttachmentState.srcAlphaBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
+			blendAttachmentState.dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
+			blendAttachmentState.alphaBlendOp = VK_BLEND_OP_ADD;
+		}
+		attachment->blendState = blendAttachmentState;
+	}
+
+	return attachments.size()-1;
+}
+void ext::vulkan::RenderTarget::initialize( Device& device ) {
+	// Bind
+	this->device = &device;
+	uint32_t width = this->width > 0 ? this->width : ext::vulkan::settings::width;
+	uint32_t height = this->height > 0 ? this->height : ext::vulkan::settings::height;
+
+	// resize attachments if necessary
+	if ( initialized ) {
+		for ( auto& attachment: this->attachments ) {
+			if ( attachment.descriptor.aliased ) continue;
+			attach( attachment.descriptor, &attachment );
+		}
+	}
+	// ensure attachments are already created
+	assert( this->attachments.size() > 0 );
+
+	// Create render pass
+	if ( !renderPass ) {
+		std::vector<VkAttachmentDescription> attachments; attachments.reserve( this->attachments.size() );
+		
+		for ( auto& attachment : this->attachments ) {
+			VkAttachmentDescription description;
+			description.format = attachment.descriptor.format;
+			description.samples = ext::vulkan::sampleCount( attachment.descriptor.samples );
+			description.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
+			description.storeOp = attachment.descriptor.usage & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT ? VK_ATTACHMENT_STORE_OP_DONT_CARE : VK_ATTACHMENT_STORE_OP_STORE;
+			description.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+			description.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+			description.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+			description.finalLayout = attachment.descriptor.layout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL : attachment.descriptor.layout;
+			description.flags = 0;
+
+			attachments.push_back(description);
+		}
+
+		// ensure that the subpasses are already described
+		assert( passes.size() > 0 );
+
+		std::vector<VkSubpassDescription> descriptions;
+		std::vector<VkSubpassDependency> dependencies;
+
+		// dependency: transition from final
+		VkSubpassDependency dependency;
+		dependency.dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
+
+		dependency.dstSubpass = VK_SUBPASS_EXTERNAL;
+		dependency.dstStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
+		dependency.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
+		size_t i = 0;
+	//	std::cout << this << ": " << std::endl;
+		for ( auto& pass : passes ) {
+			VkSubpassDescription description;
+			// describe renderpass
+			description.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;			
+			description.colorAttachmentCount = pass.colors.size();
+			description.pColorAttachments = &pass.colors[0];
+			description.pResolveAttachments = &pass.resolves[0];
+			description.inputAttachmentCount = pass.inputs.size();
+			description.pInputAttachments = &pass.inputs[0];
+			description.pDepthStencilAttachment = &pass.depth;
+			description.preserveAttachmentCount = 0;
+			description.pPreserveAttachments = nullptr;
+			description.flags = 0;
+			for ( auto& input : pass.inputs ) {
+				if ( input.attachment == pass.depth.attachment ) {
+					description.pDepthStencilAttachment = NULL;
+					break;
+				}
+			}
+			descriptions.push_back(description);
+		/*
+			std::cout << "Pass: " << descriptions.size() - 1 << std::endl;
+			for ( auto& color : pass.colors ) std::cout << "Color: " << color.attachment << "\t" << std::hex << color.layout << "\t" << this->attachments[color.attachment].image << std::endl;
+			for ( auto& input : pass.inputs ) std::cout << "Input: " << input.attachment << "\t" << std::hex << input.layout << "\t" << this->attachments[input.attachment].image << std::endl;
+			std::cout << std::endl;
+		*/
+			// transition dependency between subpasses
+			dependency.srcSubpass = dependency.dstSubpass;
+			dependency.srcStageMask = dependency.dstStageMask;
+			dependency.srcAccessMask = dependency.dstAccessMask;
+			dependency.dstSubpass = i++;
+			dependency.dstStageMask = pass.stage;
+			dependency.dstAccessMask = pass.access;
+			dependencies.push_back(dependency);
+		}
+		// dependency: transition to final
+		{
+			dependency.srcSubpass = dependency.dstSubpass;
+			dependency.srcStageMask = dependency.dstStageMask;
+			dependency.srcAccessMask = dependency.dstAccessMask;
+			dependency.dstSubpass = VK_SUBPASS_EXTERNAL;
+			dependency.dstStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
+			dependency.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
+			dependencies.push_back(dependency);
+		}
+
+		// depth dependency
+		{
+			VkSubpassDependency dependency;
+			dependency.dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
+
+			
+			dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
+			dependency.srcStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
+			dependency.srcAccessMask = VK_ACCESS_SHADER_READ_BIT;
+
+			dependency.dstSubpass = 0;
+			dependency.dstStageMask = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
+			dependency.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
+			
+			dependencies.push_back(dependency);
+		}
+		{
+			VkSubpassDependency dependency;
+			dependency.dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
+			
+			dependency.srcSubpass = 0;
+			dependency.srcStageMask = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
+			dependency.srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
+
+			dependency.dstSubpass = i == 1 ? VK_SUBPASS_EXTERNAL : 1;
+			dependency.dstStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
+			dependency.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
+			
+			dependencies.push_back(dependency);
+		}
+	/*
+		for ( auto& dependency : dependencies  ) {
+			std::cout << "Pass: " << dependency.srcSubpass << " -> " << dependency.dstSubpass << std::endl;
+			std::cout << "\tStage: " << std::hex << dependency.srcStageMask << " -> " << std::hex << dependency.dstStageMask << std::endl;
+			std::cout << "\tAccess: " << std::hex << dependency.srcAccessMask << " -> " << std::hex << dependency.dstAccessMask << std::endl;
+		}
+		std::cout << std::endl;
+	*/
+	
+		VkRenderPassCreateInfo renderPassInfo = {};
+		renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
+		renderPassInfo.flags = 0;
+		renderPassInfo.attachmentCount = static_cast<uint32_t>(attachments.size());
+		renderPassInfo.pAttachments = &attachments[0];
+		renderPassInfo.subpassCount = static_cast<uint32_t>(descriptions.size());
+		renderPassInfo.pSubpasses = &descriptions[0];
+		renderPassInfo.dependencyCount = static_cast<uint32_t>(dependencies.size());
+		renderPassInfo.pDependencies = &dependencies[0];
+
+/*
+		uint32_t mask = 0;
+		std::vector<uint32_t> masks;
+		for ( size_t i = 0; i < this->views; ++i ) {
+			mask |= (0b00000001 << i);
+		}
+		for ( size_t i = 0; i < static_cast<uint32_t>(descriptions.size()); ++i ) {
+			masks.emplace_back(mask);
+		}
+		VkRenderPassMultiviewCreateInfo renderPassMultiviewInfo = {};
+		renderPassMultiviewInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO;
+		renderPassMultiviewInfo.subpassCount = 1; //static_cast<uint32_t>(descriptions.size());
+	//	renderPassMultiviewInfo.dependencyCount = static_cast<uint32_t>(dependencies.size());
+		renderPassMultiviewInfo.pViewMasks = masks.data();
+		renderPassMultiviewInfo.pCorrelationMasks = masks.data();
+		renderPassMultiviewInfo.correlationMaskCount = 1;
+		if ( this->views > 1 ) {
+			renderPassInfo.pNext = &renderPassMultiviewInfo;
+		}
+*/
+		VK_CHECK_RESULT(vkCreateRenderPass(device, &renderPassInfo, nullptr, &renderPass));
+
+	//	std::cout << renderPass << ": " << attachments.size() << std::endl;
+	}
+
+	{	
+		// destroy previous framebuffers
+		for ( auto& framebuffer : framebuffers ) vkDestroyFramebuffer( device, framebuffer, nullptr );
+
+		RenderMode& base = ext::vulkan::getRenderMode( "Swapchain", false );
+		framebuffers.resize(ext::vulkan::swapchain.buffers);
+		for ( size_t i = 0; i < framebuffers.size(); ++i ) {
+			std::vector<VkImageView> attachments;										
+			for ( auto& attachment : this->attachments ) {
+				if ( attachment.descriptor.aliased && attachment.descriptor.layout == VK_IMAGE_LAYOUT_PRESENT_SRC_KHR ) {
+					attachments.push_back(base.renderTarget.attachments[i].view);
+				} else attachments.push_back(attachment.view);
+			}
+
+			VkFramebufferCreateInfo frameBufferCreateInfo = {};
+			frameBufferCreateInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
+			// All frame buffers use the same renderpass setup
+			frameBufferCreateInfo.renderPass = renderPass;
+			frameBufferCreateInfo.attachmentCount = static_cast<uint32_t>(attachments.size());
+			frameBufferCreateInfo.pAttachments = attachments.data();
+			frameBufferCreateInfo.width = width;
+			frameBufferCreateInfo.height = height;
+			frameBufferCreateInfo.layers = 1;
+			// Create the framebuffer
+			VK_CHECK_RESULT(vkCreateFramebuffer( device, &frameBufferCreateInfo, nullptr, &framebuffers[i]));
+		}
+	}
+	initialized = true;
+}
+
+void ext::vulkan::RenderTarget::destroy() {
+	if ( !device ) return;
+	vkDestroyRenderPass( *device, renderPass, nullptr );
+	for ( auto& framebuffer : framebuffers ) vkDestroyFramebuffer( *device, framebuffer, nullptr );
+	
+	for ( auto& attachment : attachments ) {
+		if ( attachment.descriptor.aliased ) continue;
+		vkDestroyImageView( *device, attachment.view, nullptr );
+		attachment.view = VK_NULL_HANDLE;
+	//	vkDestroyImage( *device, attachment.image, nullptr );
+		vmaDestroyImage( allocator, attachment.image, attachment.allocation );
+		attachment.image = VK_NULL_HANDLE;
+	//	vkFreeMemory( *device, attachment.mem, nullptr );
+		attachment.mem = VK_NULL_HANDLE;
+	}
+
+	renderPass = VK_NULL_HANDLE;
+	device = VK_NULL_HANDLE;
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/vulkan/swapchain.cpp b/engine/src/ext/vulkan/swapchain.cpp
new file mode 100644
index 00000000..897f6b22
--- /dev/null
+++ b/engine/src/ext/vulkan/swapchain.cpp
@@ -0,0 +1,191 @@
+#if UF_USE_VULKAN
+
+#include <uf/ext/vulkan/vulkan.h>
+#include <uf/ext/vulkan/swapchain.h>
+#include <uf/ext/vulkan/initializers.h>
+#include <uf/utils/window/window.h>
+
+VkResult ext::vulkan::Swapchain::acquireNextImage( uint32_t* imageIndex, VkSemaphore presentCompleteSemaphore ) {
+	// By setting timeout to UINT64_MAX we will always wait until the next image has been acquired or an actual error is thrown
+	// With that we don't have to handle VK_NOT_READY
+	return vkAcquireNextImageKHR( *device, swapChain, UINT64_MAX, presentCompleteSemaphore, (VkFence) nullptr, imageIndex );
+}
+
+VkResult ext::vulkan::Swapchain::queuePresent( VkQueue queue, uint32_t imageIndex, VkSemaphore waitSemaphore ) {
+	VkPresentInfoKHR presentInfo = {};
+	presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
+	presentInfo.pNext = NULL;
+	presentInfo.swapchainCount = 1;
+	presentInfo.pSwapchains = &swapChain;
+	presentInfo.pImageIndices = &imageIndex;
+	// Check if a wait semaphore has been specified to wait for before presenting the image
+	if ( waitSemaphore != VK_NULL_HANDLE ) {
+		presentInfo.pWaitSemaphores = &waitSemaphore;
+		presentInfo.waitSemaphoreCount = 1;
+	}
+	return vkQueuePresentKHR(queue, &presentInfo);
+}
+
+void ext::vulkan::Swapchain::initialize( Device& device ) {
+	// Bind
+	{
+		this->device = &device;
+//		if ( width == 0 ) width = ext::vulkan::settings::width;
+//		if ( height == 0 ) height = ext::vulkan::settings::height;
+	}
+	// Set present
+	VkPresentModeKHR swapchainPresentMode = VK_PRESENT_MODE_FIFO_KHR;
+	{
+		// Get available present modes
+		uint32_t presentModeCount;
+		VK_CHECK_RESULT(vkGetPhysicalDeviceSurfacePresentModesKHR(device.physicalDevice, device.surface, &presentModeCount, NULL));
+		assert(presentModeCount > 0);
+
+		std::vector<VkPresentModeKHR> presentModes(presentModeCount);
+		VK_CHECK_RESULT(vkGetPhysicalDeviceSurfacePresentModesKHR(device.physicalDevice, device.surface, &presentModeCount, presentModes.data()));
+	#if 1
+		if ( settings::experimental::vsync ) {
+			swapchainPresentMode = VK_PRESENT_MODE_FIFO_KHR;
+			for ( size_t i = 0; i < presentModeCount; i++ ) {
+				if ( presentModes[i] == VK_PRESENT_MODE_MAILBOX_KHR ) {
+					swapchainPresentMode = VK_PRESENT_MODE_MAILBOX_KHR;
+					break;
+				}
+			}
+		} else {
+			swapchainPresentMode = VK_PRESENT_MODE_IMMEDIATE_KHR;
+			for ( size_t i = 0; i < presentModeCount; i++ ) {
+				if ( presentModes[i] == VK_PRESENT_MODE_FIFO_RELAXED_KHR ) {
+					swapchainPresentMode = VK_PRESENT_MODE_FIFO_RELAXED_KHR;
+					break;
+				}
+			}
+		}
+	#else
+		if ( !settings::experimental::vsync ) {
+			for ( size_t i = 0; i < presentModeCount; i++ ) {
+				if ( presentModes[i] == VK_PRESENT_MODE_MAILBOX_KHR ) {
+					swapchainPresentMode = VK_PRESENT_MODE_MAILBOX_KHR;
+					break;
+				}
+				if ( (swapchainPresentMode != VK_PRESENT_MODE_MAILBOX_KHR) && (presentModes[i] == VK_PRESENT_MODE_IMMEDIATE_KHR) )
+					swapchainPresentMode = VK_PRESENT_MODE_IMMEDIATE_KHR;
+			}
+		}
+	#endif
+	
+		switch ( swapchainPresentMode ) {
+			case VK_PRESENT_MODE_IMMEDIATE_KHR: VK_VALIDATION_MESSAGE("Swapchain present mode: VK_PRESENT_MODE_IMMEDIATE_KHR"); break;
+			case VK_PRESENT_MODE_MAILBOX_KHR: VK_VALIDATION_MESSAGE("Swapchain present mode: VK_PRESENT_MODE_MAILBOX_KHR"); break;
+			case VK_PRESENT_MODE_FIFO_KHR: VK_VALIDATION_MESSAGE("Swapchain present mode: VK_PRESENT_MODE_FIFO_KHR"); break;
+			case VK_PRESENT_MODE_FIFO_RELAXED_KHR: VK_VALIDATION_MESSAGE("Swapchain present mode: VK_PRESENT_MODE_FIFO_RELAXED_KHR"); break;
+			default: VK_VALIDATION_MESSAGE("Swapchain present mode: " << swapchainPresentMode);
+		}
+	}
+	// Set extent
+	VkExtent2D swapchainExtent = {};
+	{
+		VkSurfaceCapabilitiesKHR capabilities;
+		vkGetPhysicalDeviceSurfaceCapabilitiesKHR( device.physicalDevice, device.surface, &capabilities );
+		if (capabilities.currentExtent.width != std::numeric_limits<uint32_t>::max()) {
+			swapchainExtent = capabilities.currentExtent;
+		} else {
+			auto size = device.window->getSize();
+			VkExtent2D swapchainExtent = {
+				static_cast<uint32_t>(size[0]),
+				static_cast<uint32_t>(size[1])
+			};
+
+			swapchainExtent.width = std::max(capabilities.minImageExtent.width, std::min(capabilities.maxImageExtent.width, swapchainExtent.width));
+			swapchainExtent.height = std::max(capabilities.minImageExtent.height, std::min(capabilities.maxImageExtent.height, swapchainExtent.height));
+		}
+	}
+	// Create (re)swap chain
+	{
+		VkSwapchainKHR oldSwapchain = swapChain;
+
+		// Get physical device surface properties and formats
+		VkSurfaceCapabilitiesKHR surfCaps;
+		VK_CHECK_RESULT(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device.physicalDevice, device.surface, &surfCaps));
+
+		// Determine the number of images
+		uint32_t desiredNumberOfSwapchainImages = surfCaps.minImageCount + 1;
+		if ( (surfCaps.maxImageCount > 0) && (desiredNumberOfSwapchainImages > surfCaps.maxImageCount) ) {
+			desiredNumberOfSwapchainImages = surfCaps.maxImageCount;
+		}
+
+		// Find the transformation of the surface
+		VkSurfaceTransformFlagsKHR preTransform;
+		if ( surfCaps.supportedTransforms & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR ) {
+			// We prefer a non-rotated transform
+			preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
+		} else
+			preTransform = surfCaps.currentTransform;
+
+		// Find a supported composite alpha format (not all devices support alpha opaque)
+		VkCompositeAlphaFlagBitsKHR compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
+		// Simply select the first composite alpha format available
+		std::vector<VkCompositeAlphaFlagBitsKHR> compositeAlphaFlags = {
+			VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
+			VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR,
+			VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR,
+			VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR,
+		};
+		for ( auto& compositeAlphaFlag : compositeAlphaFlags ) {
+			if ( surfCaps.supportedCompositeAlpha & compositeAlphaFlag ) {
+				compositeAlpha = compositeAlphaFlag;
+				break;
+			};
+		}
+
+		VkSwapchainCreateInfoKHR swapchainCI = {};
+		swapchainCI.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
+		swapchainCI.pNext = NULL;
+		swapchainCI.surface = device.surface;
+		swapchainCI.minImageCount = desiredNumberOfSwapchainImages;
+		swapchainCI.imageFormat = ext::vulkan::settings::formats::color; // device.formats.color;
+		swapchainCI.imageColorSpace = ext::vulkan::settings::formats::colorSpace; // device.formats.space;
+		swapchainCI.imageExtent = { swapchainExtent.width, swapchainExtent.height };
+		swapchainCI.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+		swapchainCI.preTransform = (VkSurfaceTransformFlagBitsKHR)preTransform;
+		swapchainCI.imageArrayLayers = 1;
+		swapchainCI.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
+		swapchainCI.queueFamilyIndexCount = 0;
+		swapchainCI.pQueueFamilyIndices = NULL;
+		swapchainCI.presentMode = swapchainPresentMode;
+		swapchainCI.oldSwapchain = oldSwapchain;
+		// Setting clipped to VK_TRUE allows the implementation to discard rendering outside of the surface area
+		swapchainCI.clipped = VK_TRUE;
+		swapchainCI.compositeAlpha = compositeAlpha;
+
+		// Enable transfer source on swap chain images if supported
+		if (surfCaps.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_SRC_BIT) {
+			swapchainCI.imageUsage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+		}
+
+		// Enable transfer destination on swap chain images if supported
+		if (surfCaps.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_DST_BIT) {
+			swapchainCI.imageUsage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+		}
+
+		VK_CHECK_RESULT(vkCreateSwapchainKHR( device.logicalDevice, &swapchainCI, nullptr, &swapChain));
+
+		// If an existing swap chain is re-created, destroy the old swap chain
+		// This also cleans up all the presentable images
+		if (oldSwapchain != VK_NULL_HANDLE) vkDestroySwapchainKHR( device.logicalDevice, oldSwapchain, nullptr);
+		VK_CHECK_RESULT(vkGetSwapchainImagesKHR( device.logicalDevice, swapChain, &buffers, NULL));
+	}
+}
+
+void ext::vulkan::Swapchain::destroy() {
+	if ( !device ) return;
+
+	if ( swapChain != VK_NULL_HANDLE ) {
+		vkDestroySwapchainKHR( *device, swapChain, nullptr);
+	}
+
+	swapChain = VK_NULL_HANDLE;
+	device = VK_NULL_HANDLE;
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/vulkan/texture.cpp b/engine/src/ext/vulkan/texture.cpp
new file mode 100644
index 00000000..5d4b4461
--- /dev/null
+++ b/engine/src/ext/vulkan/texture.cpp
@@ -0,0 +1,785 @@
+#if UF_USE_VULKAN
+
+#include <uf/ext/vulkan/texture.h>
+#include <uf/ext/vulkan/initializers.h>
+#include <uf/utils/image/image.h>
+#include <uf/ext/vulkan/vulkan.h>
+
+ext::vulkan::Texture2D ext::vulkan::Texture2D::empty;
+ext::vulkan::Texture3D ext::vulkan::Texture3D::empty;
+ext::vulkan::TextureCube ext::vulkan::TextureCube::empty;
+
+void ext::vulkan::Sampler::initialize( Device& device ) {
+	this->device = &device;
+	if ( device.enabledFeatures.samplerAnisotropy == VK_FALSE ) {
+		descriptor.anisotropy.enabled = VK_FALSE;
+	}
+	{
+		VkSamplerCreateInfo samplerCreateInfo = {};
+		samplerCreateInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
+		samplerCreateInfo.minFilter = descriptor.filter.min;
+		samplerCreateInfo.magFilter = descriptor.filter.mag;
+		samplerCreateInfo.borderColor = descriptor.filter.borderColor;
+		samplerCreateInfo.addressModeU = descriptor.addressMode.u;
+		samplerCreateInfo.addressModeV = descriptor.addressMode.v;
+		samplerCreateInfo.addressModeW = descriptor.addressMode.w;
+		samplerCreateInfo.unnormalizedCoordinates = descriptor.addressMode.unnormalizedCoordinates;
+
+		samplerCreateInfo.mipmapMode = descriptor.mip.mode;
+		samplerCreateInfo.mipLodBias = descriptor.mip.lodBias;
+		samplerCreateInfo.compareEnable = descriptor.mip.compareEnable;
+		samplerCreateInfo.compareOp = descriptor.mip.compareOp;
+		samplerCreateInfo.minLod = descriptor.mip.min;
+		samplerCreateInfo.maxLod = descriptor.mip.max;
+
+		samplerCreateInfo.anisotropyEnable = descriptor.anisotropy.enabled;
+		samplerCreateInfo.maxAnisotropy = descriptor.anisotropy.max;
+		VK_CHECK_RESULT(vkCreateSampler(device.logicalDevice, &samplerCreateInfo, nullptr, &sampler));
+	}
+	{
+		descriptor.info.sampler = sampler;
+	}
+}
+void ext::vulkan::Sampler::destroy() {
+	if ( sampler != VK_NULL_HANDLE ) {
+		vkDestroySampler(device->logicalDevice, sampler, nullptr);
+		sampler = VK_NULL_HANDLE;
+	}
+}
+
+void ext::vulkan::Texture::initialize( Device& device, size_t width, size_t height, size_t depth, size_t layers ) {
+	this->device = &device;
+	this->width = width;
+	this->height = height;
+	this->depth = depth;
+	this->layers = layers;
+	// implicitly set type
+	if ( width > 1 && height > 1 && depth > 1 ) {
+		this->type = VK_IMAGE_TYPE_3D;
+	} else if ( (width == 1 && height > 1 && depth > 1) || (width > 1 && height == 1 && depth > 1) || (width > 1 && height > 1 && depth == 1) ) {
+		this->type = VK_IMAGE_TYPE_2D;
+	} else if ( (width > 1 && height == 1 && depth == 1) || (width == 1 && height > 1 && depth == 1) || (width == 1 && height == 1 && depth > 1) ) {
+		this->type = VK_IMAGE_TYPE_1D;
+	}
+/*
+	if ( layers > 1 ) {
+		if ( viewType == VK_IMAGE_VIEW_TYPE_1D ) viewType = VK_IMAGE_VIEW_TYPE_1D_ARRAY;
+		if ( viewType == VK_IMAGE_VIEW_TYPE_2D ) viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY;
+		if ( viewType == VK_IMAGE_VIEW_TYPE_CUBE ) viewType = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
+	}
+*/
+}
+void ext::vulkan::Texture::initialize( Device& device, VkImageViewType viewType, size_t width, size_t height, size_t depth, size_t layers ) {
+	this->initialize( device, width, height, depth, layers );
+	this->viewType = viewType;
+	switch ( viewType ) {
+		case VK_IMAGE_VIEW_TYPE_1D:
+		case VK_IMAGE_VIEW_TYPE_1D_ARRAY:
+			type = VK_IMAGE_TYPE_1D;
+		break;
+		case VK_IMAGE_VIEW_TYPE_2D:
+		case VK_IMAGE_VIEW_TYPE_CUBE:
+		case VK_IMAGE_VIEW_TYPE_2D_ARRAY:
+		case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY: 
+			type = VK_IMAGE_TYPE_2D;
+		break;
+		case VK_IMAGE_VIEW_TYPE_3D:
+			type = VK_IMAGE_TYPE_3D;
+		break;
+	}
+}
+void ext::vulkan::Texture::updateDescriptors() {
+	descriptor.sampler = sampler.sampler;
+	descriptor.imageView = view;
+	descriptor.imageLayout = imageLayout;
+}
+bool ext::vulkan::Texture::generated() const {
+	return view != VK_NULL_HANDLE;
+}
+void ext::vulkan::Texture::destroy() {
+	if ( !device ) return;
+
+	if ( view != VK_NULL_HANDLE ) {
+		vkDestroyImageView(device->logicalDevice, view, nullptr);
+		view = VK_NULL_HANDLE;
+	}
+	if ( image != VK_NULL_HANDLE ) {
+//		vkDestroyImage(device->logicalDevice, image, nullptr);
+		vmaDestroyImage( allocator, image, allocation );
+		image = VK_NULL_HANDLE;
+	}
+	if ( deviceMemory != VK_NULL_HANDLE ) {
+//		vkFreeMemory(device->logicalDevice, deviceMemory, nullptr);
+		deviceMemory = VK_NULL_HANDLE;
+	}
+	sampler.destroy(); // should be above
+}
+void ext::vulkan::Texture::setImageLayout(
+	VkCommandBuffer cmdbuffer,
+	VkImage image,
+	VkImageLayout oldImageLayout,
+	VkImageLayout newImageLayout,
+	VkImageSubresourceRange subresourceRange
+) {
+	// Create an image barrier object
+	VkImageMemoryBarrier imageMemoryBarrier = ext::vulkan::initializers::imageMemoryBarrier();
+	imageMemoryBarrier.oldLayout = oldImageLayout;
+	imageMemoryBarrier.newLayout = newImageLayout;
+	imageMemoryBarrier.image = image;
+	imageMemoryBarrier.subresourceRange = subresourceRange;
+
+	VkPipelineStageFlags srcStageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
+	VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
+
+	// Source layouts (old)
+	// Source access mask controls actions that have to be finished on the old layout
+	// before it will be transitioned to the new layout
+	switch ( oldImageLayout ) {
+		case VK_IMAGE_LAYOUT_UNDEFINED:
+			// Image layout is undefined (or does not matter)
+			// Only valid as initial layout
+			// No flags required, listed only for completeness
+			imageMemoryBarrier.srcAccessMask = 0;
+		break;
+		case VK_IMAGE_LAYOUT_PREINITIALIZED:
+			// Image is preinitialized
+			// Only valid as initial layout for linear images, preserves memory contents
+			// Make sure host writes have been finished
+			imageMemoryBarrier.srcAccessMask = VK_ACCESS_HOST_WRITE_BIT;
+		break;
+		case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
+			// Image is a color attachment
+			// Make sure any writes to the color buffer have been finished
+			imageMemoryBarrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+		break;
+		case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
+			// Image is a depth/stencil attachment
+			// Make sure any writes to the depth/stencil buffer have been finished
+			imageMemoryBarrier.srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
+		break;
+		case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
+			// Image is a transfer source 
+			// Make sure any reads from the image have been finished
+			imageMemoryBarrier.srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
+		break;
+		case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
+			// Image is a transfer destination
+			// Make sure any writes to the image have been finished
+			imageMemoryBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+		break;
+		case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
+			// Image is read by a shader
+			// Make sure any shader reads from the image have been finished
+			imageMemoryBarrier.srcAccessMask = VK_ACCESS_SHADER_READ_BIT;
+		break;
+		default:
+			// Other source layouts aren't handled (yet)
+		break;
+	}
+
+	// Target layouts (new)
+	// Destination access mask controls the dependency for the new image layout
+	switch ( newImageLayout ) {
+		case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
+			// Image will be used as a transfer destination
+			// Make sure any writes to the image have been finished
+			imageMemoryBarrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+		break;
+		case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
+			// Image will be used as a transfer source
+			// Make sure any reads from the image have been finished
+			imageMemoryBarrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
+		break;
+		case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
+			// Image will be used as a color attachment
+			// Make sure any writes to the color buffer have been finished
+			imageMemoryBarrier.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+		break;
+		case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
+			// Image layout will be used as a depth/stencil attachment
+			// Make sure any writes to depth/stencil buffer have been finished
+			imageMemoryBarrier.dstAccessMask = imageMemoryBarrier.dstAccessMask | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
+		break;
+		case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
+			// Image will be read in a shader (sampler, input attachment)
+			// Make sure any writes to the image have been finished
+			if (imageMemoryBarrier.srcAccessMask == 0) {
+				imageMemoryBarrier.srcAccessMask = VK_ACCESS_HOST_WRITE_BIT | VK_ACCESS_TRANSFER_WRITE_BIT;
+			}
+			imageMemoryBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
+		break;
+		default:
+			// Other source layouts aren't handled (yet)
+		break;
+	}
+
+	 if ( oldImageLayout == VK_IMAGE_LAYOUT_UNDEFINED && newImageLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL ) {
+		imageMemoryBarrier.srcAccessMask = 0;
+		imageMemoryBarrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+
+		srcStageMask = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
+		dstStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
+	} else if ( oldImageLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL && newImageLayout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL ) {
+		imageMemoryBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+		imageMemoryBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
+
+		srcStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
+		dstStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
+	}
+	// Put barrier inside setup command buffer
+	vkCmdPipelineBarrier(
+		cmdbuffer,
+		srcStageMask, dstStageMask,
+		0,
+		0, nullptr,
+		0, nullptr,
+		1, &imageMemoryBarrier
+	);
+}
+void ext::vulkan::Texture::setImageLayout(
+	VkCommandBuffer cmdbuffer,
+	VkImage image,
+	VkImageAspectFlags aspectMask,
+	VkImageLayout oldImageLayout,
+	VkImageLayout newImageLayout,
+	uint32_t mipLevels
+) {
+	VkImageSubresourceRange subresourceRange = {};
+	subresourceRange.aspectMask = aspectMask;
+	subresourceRange.baseMipLevel = 0;
+	subresourceRange.levelCount = mipLevels;
+	subresourceRange.layerCount = 1;
+	setImageLayout(cmdbuffer, image, oldImageLayout, newImageLayout, subresourceRange);
+}
+void ext::vulkan::Texture::loadFromFile(
+	const std::string& filename, 
+	VkFormat format,
+	VkImageUsageFlags imageUsageFlags,
+	VkImageLayout imageLayout
+) {
+	return loadFromFile( filename, ext::vulkan::device, format, imageUsageFlags, imageLayout );
+}
+void ext::vulkan::Texture::loadFromFile(
+	const std::string& filename, 
+	Device& device,
+	VkFormat format,
+	VkImageUsageFlags imageUsageFlags,
+	VkImageLayout imageLayout 
+) {
+	uf::Image image;
+	image.open( filename );
+	switch ( image.getChannels() ) {
+		// R
+		case 1:
+			switch ( image.getBpp() ) {
+				case 8:
+					format = VK_FORMAT_R8_UNORM;
+				break;
+				default:
+					UF_EXCEPTION("unsupported BPP of " + std::to_string(image.getBpp()));
+				break;
+			}
+		break;
+		// RGB
+		case 3:
+			switch ( image.getBpp() ) {
+				case 24:
+					format = VK_FORMAT_R8G8B8_UNORM;
+				break;
+				default:
+					UF_EXCEPTION("unsupported BPP of " + std::to_string(image.getBpp()));
+				break;
+			}
+		break;
+		// RGBA
+		case 4:
+			switch ( image.getBpp() ) {
+				case 32:
+					format = VK_FORMAT_R8G8B8A8_UNORM;
+				break;
+				default:
+					UF_EXCEPTION("unsupported BPP of " + std::to_string(image.getBpp()));
+				break;
+			}
+		break;
+		default:
+			UF_EXCEPTION("unsupported channels of " + std::to_string(image.getChannels()));
+		break;
+	}
+/*
+	if (device.features.textureCompressionBC) {
+		format = VK_FORMAT_BC3_UNORM_BLOCK;
+	}
+	else if (device.features.textureCompressionASTC_LDR) {
+		format = VK_FORMAT_ASTC_8x8_UNORM_BLOCK;
+	}
+	else if (device.features.textureCompressionETC2) {
+		format = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK;
+	}
+	else {
+		UF_EXCEPTION("VK_ERROR_FEATURE_NOT_PRESENT");
+	}
+*/
+
+	// convert to power of two
+	//image.padToPowerOfTwo();
+
+	this->fromBuffers( 
+		(void*) image.getPixelsPtr(),
+		image.getPixels().size(),
+		format,
+		image.getDimensions()[0],
+		image.getDimensions()[1],
+		device,
+		imageUsageFlags,
+		imageLayout
+	);
+}
+void ext::vulkan::Texture::loadFromImage(
+	uf::Image& image,
+	VkFormat format,
+	VkImageUsageFlags imageUsageFlags,
+	VkImageLayout imageLayout
+) {
+	return loadFromImage( image, ext::vulkan::device, format, imageUsageFlags, imageLayout );
+}
+void ext::vulkan::Texture::loadFromImage(
+	uf::Image& image, 
+	Device& device,
+	VkFormat format,
+	VkImageUsageFlags imageUsageFlags,
+	VkImageLayout imageLayout
+) {
+	switch ( image.getChannels() ) {
+		// R
+		case 1:
+			switch ( image.getBpp() ) {
+				case 8:
+					format = VK_FORMAT_R8_UNORM;
+				break;
+				default:
+					UF_EXCEPTION("unsupported BPP of " + std::to_string(image.getBpp()));
+				break;
+			}
+		break;
+		// RGB
+		case 3:
+			switch ( image.getBpp() ) {
+				case 24:
+					format = VK_FORMAT_R8G8B8_UNORM;
+				break;
+				default:
+					UF_EXCEPTION("unsupported BPP of " + std::to_string(image.getBpp()));
+				break;
+			}
+		break;
+		// RGBA
+		case 4:
+			switch ( image.getBpp() ) {
+				case 32:
+					format = VK_FORMAT_R8G8B8A8_UNORM;
+				break;
+				default:
+					UF_EXCEPTION("unsupported BPP of " + std::to_string(image.getBpp()));
+				break;
+			}
+		break;
+		default:
+			UF_EXCEPTION("unsupported channels of " + std::to_string(image.getChannels()));
+		break;
+	}
+
+	// convert to power of two
+	//image.padToPowerOfTwo();
+
+	this->fromBuffers( 
+		(void*) image.getPixelsPtr(),
+		image.getPixels().size(),
+		format,
+		image.getDimensions()[0],
+		image.getDimensions()[1],
+		1,
+		1,
+		device,
+		imageUsageFlags,
+		imageLayout
+	);
+}
+
+void ext::vulkan::Texture::fromBuffers(
+	void* buffer,
+	VkDeviceSize bufferSize,
+	VkFormat format,
+	uint32_t texWidth,
+	uint32_t texHeight,
+	uint32_t texDepth,
+	uint32_t layers,
+	VkImageUsageFlags imageUsageFlags,
+	VkImageLayout imageLayout
+) {
+	return this->fromBuffers( buffer, bufferSize, format, texWidth, texHeight, texDepth, layers, ext::vulkan::device, imageUsageFlags, imageLayout );
+}
+
+
+void ext::vulkan::Texture::fromBuffers(
+	void* data,
+	VkDeviceSize bufferSize,
+	VkFormat format,
+	uint32_t texWidth,
+	uint32_t texHeight,
+	uint32_t texDepth,
+	uint32_t layers,
+	Device& device,
+	VkImageUsageFlags imageUsageFlags,
+	VkImageLayout imageLayout
+) {
+	this->initialize(device, texWidth, texHeight, texDepth, layers);
+
+	if ( this->mips == 0 ) {
+		this->mips = 1;
+	} else if ( this->depth == 1 ) {
+		this->mips = static_cast<uint32_t>(std::floor(std::log2(std::max(texWidth, texHeight)))) + 1;
+		VkFormatProperties formatProperties;
+		vkGetPhysicalDeviceFormatProperties(device.physicalDevice, format, &formatProperties);
+		if (!(formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT)) {
+			this->mips = 1;
+			VK_VALIDATION_MESSAGE("Texture image format does not support linear blitting!");
+		}
+	}
+
+	// Create optimal tiled target image
+	VkImageCreateInfo imageCreateInfo = ext::vulkan::initializers::imageCreateInfo();
+	imageCreateInfo.imageType = this->type;
+	imageCreateInfo.format = this->format = format;
+	imageCreateInfo.mipLevels = this->mips;
+	imageCreateInfo.arrayLayers = this->layers;
+	imageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
+	imageCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
+	imageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+	imageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+	imageCreateInfo.extent = { width, height, depth };
+	imageCreateInfo.usage = imageUsageFlags;
+	// Ensure that the TRANSFER_SRC bit is set for mip creation
+	if ( this->mips > 1 && !(imageCreateInfo.usage & VK_IMAGE_USAGE_TRANSFER_SRC_BIT)) {
+		imageCreateInfo.usage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+	}
+	// Ensure that the TRANSFER_DST bit is set for staging
+	if (!(imageCreateInfo.usage & VK_IMAGE_USAGE_TRANSFER_DST_BIT)) {
+		imageCreateInfo.usage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+	}
+	// Ensure cube maps get the compat flag bit
+	if ( this->viewType == VK_IMAGE_VIEW_TYPE_CUBE || this->viewType == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY ) {
+		imageCreateInfo.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
+	}
+
+	VmaAllocationCreateInfo allocInfo = {};
+	allocInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY;
+	VK_CHECK_RESULT(vmaCreateImage(allocator, &imageCreateInfo, &allocInfo, &image, &allocation, &allocationInfo));
+	deviceMemory = allocationInfo.deviceMemory;
+
+	// Create sampler
+	sampler.descriptor.mip.min = 0;
+	sampler.descriptor.mip.max = static_cast<float>(this->mips);
+	sampler.initialize( device );
+
+	// Create image view	
+	VkImageViewCreateInfo viewCreateInfo = {};
+	viewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+	viewCreateInfo.pNext = NULL;
+	viewCreateInfo.viewType = viewType;
+	viewCreateInfo.format = format;
+	viewCreateInfo.components = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A };
+	viewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+	viewCreateInfo.subresourceRange.baseMipLevel = 0;
+	viewCreateInfo.subresourceRange.layerCount = this->layers;
+	viewCreateInfo.subresourceRange.levelCount = this->mips;
+	viewCreateInfo.image = image;
+	VK_CHECK_RESULT(vkCreateImageView(device.logicalDevice, &viewCreateInfo, nullptr, &view));
+
+	if ( data ) {
+		uint8_t* layerPointer = (uint8_t*) data;
+		VkDeviceSize layerSize = bufferSize / this->layers;
+		for ( size_t layer = 0; layer < this->layers; ++layer ) {
+			this->update( (void*) layerPointer, layerSize, imageLayout, layer );
+			layerPointer += layerSize;
+		}
+	}
+/*	
+	if ( this->layers > 1 ) {
+		// Create image view
+		VkImageSubresourceRange subresourceRange = {};
+		subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+		subresourceRange.baseMipLevel = 0;
+		subresourceRange.baseArrayLayer = 1;
+		subresourceRange.levelCount = this->mips;
+		subresourceRange.layerCount = this->layers - 1;
+
+		VkCommandBuffer commandBuffer = device.createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true);
+		setImageLayout(
+			commandBuffer,
+			image,
+			VK_IMAGE_LAYOUT_UNDEFINED,
+			imageLayout,
+			subresourceRange
+		);
+		device.flushCommandBuffer(commandBuffer);
+	}
+*/
+	this->updateDescriptors();
+}
+
+void ext::vulkan::Texture::asRenderTarget( Device& device, uint32_t width, uint32_t height, VkFormat format ) {
+	// Prepare blit target texture
+	this->initialize( device, width, height );
+	
+	// Get device properties for the requested texture format
+	VkFormatProperties formatProperties;
+	vkGetPhysicalDeviceFormatProperties(device.physicalDevice, format, &formatProperties);
+	// Check if requested image format supports image storage operations
+	assert(formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT);
+
+	VkImageCreateInfo imageCreateInfo = ext::vulkan::initializers::imageCreateInfo();
+	imageCreateInfo.imageType = type;
+	imageCreateInfo.format = format;
+	imageCreateInfo.extent = { width, height, depth };
+	imageCreateInfo.mipLevels = this->mips = 1;
+	imageCreateInfo.arrayLayers = 1;
+	imageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
+	imageCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
+	imageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+	// Image will be sampled in the fragment shader and used as storage target in the compute shader
+	imageCreateInfo.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT;
+	imageCreateInfo.flags = 0;
+
+	VkMemoryAllocateInfo memAllocInfo = ext::vulkan::initializers::memoryAllocateInfo();
+	VkMemoryRequirements memReqs;
+
+	VmaAllocationCreateInfo allocInfo = {};
+	allocInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY;
+	VK_CHECK_RESULT(vmaCreateImage(allocator, &imageCreateInfo, &allocInfo, &image, &allocation, &allocationInfo));
+	deviceMemory = allocationInfo.deviceMemory;
+
+	VkCommandBuffer layoutCmd = device.createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true);
+
+	imageLayout = VK_IMAGE_LAYOUT_GENERAL;
+	setImageLayout(
+		layoutCmd, 
+		image,
+		VK_IMAGE_ASPECT_COLOR_BIT, 
+		VK_IMAGE_LAYOUT_UNDEFINED,
+		imageLayout,
+		this->mips
+	);
+
+	device.flushCommandBuffer(layoutCmd, true);
+
+	// Create sampler
+	sampler.initialize( device );
+
+	// Create image view
+	VkImageViewCreateInfo viewCreateInfo = ext::vulkan::initializers::imageViewCreateInfo();
+	viewCreateInfo.viewType = viewType;
+	viewCreateInfo.format = format;
+	viewCreateInfo.components = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A };
+	viewCreateInfo.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
+	viewCreateInfo.image = image;
+	VK_CHECK_RESULT(vkCreateImageView(device, &viewCreateInfo, nullptr, &view));
+
+	// Initialize a descriptor for later use
+	this->updateDescriptors();
+}
+void ext::vulkan::Texture::aliasTexture( const Texture& texture ) {
+	image = texture.image;
+	view = texture.view;
+	imageLayout = texture.imageLayout;
+	deviceMemory = texture.deviceMemory;
+	sampler = texture.sampler;
+	
+	this->updateDescriptors();
+}
+void ext::vulkan::Texture::aliasAttachment( const RenderTarget::Attachment& attachment, bool createSampler ) {
+	image = attachment.image;
+	view = attachment.view;
+	imageLayout = attachment.descriptor.layout == VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL ? VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL : attachment.descriptor.layout;
+	deviceMemory = attachment.mem;
+
+	// Create sampler
+	if ( createSampler ) sampler.initialize( ext::vulkan::device );
+	
+	this->updateDescriptors();
+}
+
+void ext::vulkan::Texture::update( uf::Image& image, VkImageLayout targetImageLayout, uint32_t layer ) {
+	if ( width != image.getDimensions()[0] || height != image.getDimensions()[1] ) return;
+	return this->update( (void*) image.getPixelsPtr(), image.getPixels().size(), layer );
+}
+void ext::vulkan::Texture::update( void* data, VkDeviceSize bufferSize, VkImageLayout targetImageLayout, uint32_t layer ) {
+		// Update descriptor image info member that can be used for setting up descriptor sets
+
+	auto& device = *this->device;
+
+	if ( targetImageLayout == VK_IMAGE_LAYOUT_UNDEFINED ) {
+		targetImageLayout = this->imageLayout;
+	}
+
+	// Create image view
+	VkImageSubresourceRange subresourceRange = {};
+	subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+	subresourceRange.baseMipLevel = 0;
+	subresourceRange.baseArrayLayer = layer;
+	subresourceRange.levelCount = this->mips;
+	subresourceRange.layerCount = 1;
+
+	VkBufferImageCopy bufferCopyRegion = {};
+	bufferCopyRegion.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+	bufferCopyRegion.imageSubresource.mipLevel = 0;
+	bufferCopyRegion.imageSubresource.baseArrayLayer = layer;
+	bufferCopyRegion.imageSubresource.layerCount = 1;
+	bufferCopyRegion.imageExtent.width = width;
+	bufferCopyRegion.imageExtent.height = height;
+	bufferCopyRegion.imageExtent.depth = depth;
+	bufferCopyRegion.bufferOffset = 0;
+	//
+	Buffer staging;
+	VK_CHECK_RESULT(device.createBuffer(
+		VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
+		VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+		staging,
+		bufferSize,
+		data
+	));
+
+	// Use a separate command buffer for texture loading
+	VkCommandBuffer commandBuffer = device.createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true);
+
+	// Image barrier for optimal image (target)
+	// Optimal image will be used as destination for the copy
+	setImageLayout(
+		commandBuffer,
+		image,
+		imageLayout,
+		VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+		subresourceRange
+	);
+
+	// Copy mip levels from staging buffer
+	vkCmdCopyBufferToImage(
+		commandBuffer,
+		staging.buffer,
+		image,
+		VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+		1,
+		&bufferCopyRegion
+	);
+
+	if ( this->mips > 1 ) this->generateMipmaps(commandBuffer, layer);
+	
+	setImageLayout(
+		commandBuffer,
+		image,
+		VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+		targetImageLayout,
+		subresourceRange
+	);
+	device.flushCommandBuffer(commandBuffer);
+	// Clean up staging resources
+	staging.destroy();
+	
+	this->imageLayout = targetImageLayout;
+
+	this->updateDescriptors();
+}
+
+void ext::vulkan::Texture::generateMipmaps( VkCommandBuffer commandBuffer, uint32_t layer ) {
+	auto& device = *this->device;
+
+	if ( this->mips <= 1 ) return;
+
+	VkFormatProperties formatProperties;
+	vkGetPhysicalDeviceFormatProperties(device.physicalDevice, format, &formatProperties);
+	if (!(formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT)) {
+		UF_EXCEPTION("texture image format does not support linear blitting!");
+	}
+
+	// base layer barrier
+	VkImageMemoryBarrier barrier{};
+	barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+	barrier.image = image;
+	barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+	barrier.subresourceRange.baseArrayLayer = layer;
+	barrier.subresourceRange.layerCount = 1;
+	barrier.subresourceRange.levelCount = 1;
+
+	int32_t mipWidth = width;
+	int32_t mipHeight = height;
+	int32_t mipDepth = depth;
+	for ( size_t i = 1; i < this->mips; ++i ) {
+		// transition previous layer to read from it
+		barrier.subresourceRange.baseMipLevel = i - 1;
+		barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+		barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+		barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+		barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
+		vkCmdPipelineBarrier(commandBuffer,
+			VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0,
+			0, nullptr,
+			0, nullptr,
+			1, &barrier
+		);
+
+		// blit to current mip layer
+		VkImageBlit blit{};
+		blit.srcOffsets[0] = { 0, 0, 0 };
+		blit.srcOffsets[1] = { mipWidth, mipHeight, mipDepth };
+		blit.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+		blit.srcSubresource.mipLevel = i - 1;
+		blit.srcSubresource.baseArrayLayer = layer;
+		blit.srcSubresource.layerCount = 1;
+		blit.dstOffsets[0] = { 0, 0, 0 };
+		blit.dstOffsets[1] = { mipWidth > 1 ? mipWidth / 2 : 1, mipHeight > 1 ? mipHeight / 2 : 1, mipDepth > 1 ? mipDepth / 2 : 1 };
+		blit.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+		blit.dstSubresource.mipLevel = i;
+		blit.dstSubresource.baseArrayLayer = layer;
+		blit.dstSubresource.layerCount = 1;
+
+		vkCmdBlitImage(
+			commandBuffer,
+			image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+			image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+			1, &blit,
+			VK_FILTER_LINEAR
+		);
+
+		// transition previous layer back
+		barrier.subresourceRange.baseMipLevel = i - 1;
+		barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+		barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+		barrier.srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
+		barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+		vkCmdPipelineBarrier(commandBuffer,
+			VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0,
+			0, nullptr,
+			0, nullptr,
+			1, &barrier
+		);
+
+		if (mipWidth > 1) mipWidth /= 2;
+    	if (mipHeight > 1) mipHeight /= 2;
+    	if (mipDepth > 1) mipDepth /= 2;
+	}
+}
+
+ext::vulkan::Texture2D::Texture2D() {
+	type = VK_IMAGE_TYPE_2D;
+	viewType = VK_IMAGE_VIEW_TYPE_2D;
+}
+ext::vulkan::Texture3D::Texture3D() {
+	type = VK_IMAGE_TYPE_3D;
+	viewType = VK_IMAGE_VIEW_TYPE_3D;
+}
+ext::vulkan::TextureCube::TextureCube() {
+	type = VK_IMAGE_TYPE_2D;
+	viewType = VK_IMAGE_VIEW_TYPE_CUBE;
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/src/ext/vulkan/vulkan.cpp b/engine/src/ext/vulkan/vulkan.cpp
new file mode 100644
index 00000000..5f7d17a4
--- /dev/null
+++ b/engine/src/ext/vulkan/vulkan.cpp
@@ -0,0 +1,740 @@
+#if UF_USE_VULKAN
+
+#include <uf/ext/vulkan/vulkan.h>
+#include <uf/ext/vulkan/initializers.h>
+#include <uf/ext/vulkan/graphic.h>
+#include <uf/ext/vulkan/rendermode.h>
+#include <uf/utils/graphic/graphic.h>
+
+#include <uf/ext/openvr/openvr.h>
+
+#include <ostream>
+#include <fstream>
+#include <atomic>
+
+uint32_t ext::vulkan::settings::width = 1280;
+uint32_t ext::vulkan::settings::height = 720;
+uint8_t ext::vulkan::settings::msaa = 1;
+bool ext::vulkan::settings::validation = true;
+// constexpr size_t ext::vulkan::settings::maxViews = 6;
+size_t ext::vulkan::settings::viewCount = 2;
+
+std::vector<std::string> ext::vulkan::settings::validationFilters;
+std::vector<std::string> ext::vulkan::settings::requestedDeviceFeatures;
+std::vector<std::string> ext::vulkan::settings::requestedDeviceExtensions;
+std::vector<std::string> ext::vulkan::settings::requestedInstanceExtensions;
+
+VkFilter ext::vulkan::settings::swapchainUpscaleFilter = VK_FILTER_LINEAR;
+
+bool ext::vulkan::settings::experimental::rebuildOnTickBegin = false;
+bool ext::vulkan::settings::experimental::waitOnRenderEnd = false;
+bool ext::vulkan::settings::experimental::individualPipelines = false;
+bool ext::vulkan::settings::experimental::multithreadedCommandRecording = false;
+std::string ext::vulkan::settings::experimental::deferredMode = "";
+bool ext::vulkan::settings::experimental::deferredReconstructPosition = false;
+bool ext::vulkan::settings::experimental::deferredAliasOutputToSwapchain = true;
+bool ext::vulkan::settings::experimental::multiview = true;
+bool ext::vulkan::settings::experimental::vsync = true;
+bool ext::vulkan::settings::experimental::hdr = true;
+
+VkColorSpaceKHR ext::vulkan::settings::formats::colorSpace;
+ext::vulkan::enums::Format::type_t ext::vulkan::settings::formats::color = ext::vulkan::enums::Format::R8G8B8A8_UNORM;
+ext::vulkan::enums::Format::type_t ext::vulkan::settings::formats::depth = ext::vulkan::enums::Format::D32_SFLOAT;
+ext::vulkan::enums::Format::type_t ext::vulkan::settings::formats::normal = ext::vulkan::enums::Format::R16G16B16A16_SFLOAT;
+ext::vulkan::enums::Format::type_t ext::vulkan::settings::formats::position = ext::vulkan::enums::Format::R16G16B16A16_SFLOAT;
+
+ext::vulkan::Device ext::vulkan::device;
+ext::vulkan::Allocator ext::vulkan::allocator;
+ext::vulkan::Swapchain ext::vulkan::swapchain;
+std::mutex ext::vulkan::mutex;
+
+bool ext::vulkan::states::resized = false;
+bool ext::vulkan::states::rebuild = false;
+uint32_t ext::vulkan::states::currentBuffer = 0;
+
+std::vector<uf::Scene*> ext::vulkan::scenes;
+ext::vulkan::RenderMode* ext::vulkan::currentRenderMode = NULL;
+std::vector<ext::vulkan::RenderMode*> ext::vulkan::renderModes = {
+	new ext::vulkan::BaseRenderMode,
+};
+
+VkResult ext::vulkan::CreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pDebugMessenger) {
+	auto func = (PFN_vkCreateDebugUtilsMessengerEXT) vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT");
+	if ( func == nullptr ) return VK_ERROR_EXTENSION_NOT_PRESENT;
+	return func(instance, pCreateInfo, pAllocator, pDebugMessenger);
+}
+
+void ext::vulkan::DestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT debugMessenger, const VkAllocationCallbacks* pAllocator) {
+	auto func = (PFN_vkDestroyDebugUtilsMessengerEXT) vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT");
+	if (func != nullptr) func(instance, debugMessenger, pAllocator);
+}
+
+VKAPI_ATTR VkBool32 VKAPI_CALL ext::vulkan::debugCallback(
+	VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+	VkDebugUtilsMessageTypeFlagsEXT messageType,
+	const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
+	void* pUserData
+) {
+//	if ( messageSeverity <= VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT ) return VK_FALSE;
+	std::string message = pCallbackData->pMessage;
+	for ( auto& filter : ext::vulkan::settings::validationFilters ) {
+		if ( message.find(filter) != std::string::npos ) return VK_FALSE;
+	}
+	uf::iostream << "[Validation Layer] " << message << "\n";
+	return VK_FALSE;
+}
+
+std::string ext::vulkan::errorString( VkResult result ) {
+	switch ( result ) {
+#define STR(r) case VK_ ##r: return #r
+		STR(NOT_READY);
+		STR(TIMEOUT);
+		STR(EVENT_SET);
+		STR(EVENT_RESET);
+		STR(INCOMPLETE);
+		STR(ERROR_OUT_OF_HOST_MEMORY);
+		STR(ERROR_OUT_OF_DEVICE_MEMORY);
+		STR(ERROR_INITIALIZATION_FAILED);
+		STR(ERROR_DEVICE_LOST);
+		STR(ERROR_MEMORY_MAP_FAILED);
+		STR(ERROR_LAYER_NOT_PRESENT);
+		STR(ERROR_EXTENSION_NOT_PRESENT);
+		STR(ERROR_FEATURE_NOT_PRESENT);
+		STR(ERROR_INCOMPATIBLE_DRIVER);
+		STR(ERROR_TOO_MANY_OBJECTS);
+		STR(ERROR_FORMAT_NOT_SUPPORTED);
+		STR(ERROR_SURFACE_LOST_KHR);
+		STR(ERROR_NATIVE_WINDOW_IN_USE_KHR);
+		STR(SUBOPTIMAL_KHR);
+		STR(ERROR_OUT_OF_DATE_KHR);
+		STR(ERROR_INCOMPATIBLE_DISPLAY_KHR);
+		STR(ERROR_VALIDATION_FAILED_EXT);
+		STR(ERROR_INVALID_SHADER_NV);
+#undef STR
+	default:
+		return "UNKNOWN_ERROR";
+	}
+}
+VkSampleCountFlagBits ext::vulkan::sampleCount( uint8_t count ) {
+	VkSampleCountFlags counts = std::min(ext::vulkan::device.properties.limits.framebufferColorSampleCounts, ext::vulkan::device.properties.limits.framebufferDepthSampleCounts);
+	if ( count < counts ) counts = count;
+	
+	if ( counts & VK_SAMPLE_COUNT_64_BIT ) return VK_SAMPLE_COUNT_64_BIT;
+	if ( counts & VK_SAMPLE_COUNT_32_BIT ) return VK_SAMPLE_COUNT_32_BIT;
+	if ( counts & VK_SAMPLE_COUNT_16_BIT ) return VK_SAMPLE_COUNT_16_BIT;
+	if ( counts & VK_SAMPLE_COUNT_8_BIT  ) return VK_SAMPLE_COUNT_8_BIT;
+	if ( counts & VK_SAMPLE_COUNT_4_BIT  ) return VK_SAMPLE_COUNT_4_BIT;
+	if ( counts & VK_SAMPLE_COUNT_2_BIT  ) return VK_SAMPLE_COUNT_2_BIT;
+	return VK_SAMPLE_COUNT_1_BIT;
+}
+void* ext::vulkan::alignedAlloc( size_t size, size_t alignment ) {
+	void *data = nullptr;
+#if defined(_MSC_VER) || defined(__MINGW32__)
+	data = _aligned_malloc(size, alignment);
+#else 
+	int res = posix_memalign(&data, alignment, size);
+	if (res != 0)
+		data = nullptr;
+#endif
+	return data;
+}
+
+void ext::vulkan::alignedFree(void* data) {
+#if	defined(_MSC_VER) || defined(__MINGW32__)
+	_aligned_free(data);
+#else 
+	free(data);
+#endif
+}
+
+bool ext::vulkan::hasRenderMode( const std::string& name, bool isName ) {
+	for ( auto& renderMode: ext::vulkan::renderModes ) {
+		if ( isName ) {
+			if ( renderMode->getName() == name ) return true;
+		} else {
+			if ( renderMode->getType() == name ) return true;
+		}
+	}
+	return false;
+}
+
+ext::vulkan::RenderMode& ext::vulkan::addRenderMode( ext::vulkan::RenderMode* mode, const std::string& name ) {
+	mode->metadata["name"] = name;
+	renderModes.push_back(mode);
+	VK_VALIDATION_MESSAGE("Adding RenderMode: " << name << ": " << mode->getType());
+	// reorder
+	ext::vulkan::states::rebuild = true;
+	return *mode;
+}
+ext::vulkan::RenderMode& ext::vulkan::getRenderMode( const std::string& name, bool isName ) {
+	RenderMode* target = renderModes[0];
+	for ( auto& renderMode: renderModes ) {
+		if ( isName ) {
+			if ( renderMode->getName() == "" )  target = renderMode;
+			if ( renderMode->getName() == name ) {
+				target = renderMode;
+				break;
+			}
+		} else {
+			if ( renderMode->getType() == name ) {
+				target = renderMode;
+				break;
+			}
+		}
+	}
+//	VK_VALIDATION_MESSAGE("Requesting RenderMode `" << name << "`, got `" << target->getName() << "` (" << target->getType() << ")");
+	return *target;
+}
+std::vector<ext::vulkan::RenderMode*> ext::vulkan::getRenderModes( const std::string& name, bool isName ) {
+	return ext::vulkan::getRenderModes({name}, isName);
+}
+std::vector<ext::vulkan::RenderMode*> ext::vulkan::getRenderModes( const std::vector<std::string>& names, bool isName ) {
+	std::vector<RenderMode*> targets;
+	for ( auto& renderMode: renderModes ) {
+		if ( ( isName && std::find(names.begin(), names.end(), renderMode->getName()) != names.end() ) || std::find(names.begin(), names.end(), renderMode->getType()) != names.end() ) {
+			targets.push_back(renderMode);
+//			VK_VALIDATION_MESSAGE("Requestings RenderMode `" << name << "`, got `" << renderMode->getName() << "` (" << renderMode->getType() << ")");
+		}
+	}
+	return targets;
+}
+void ext::vulkan::removeRenderMode( ext::vulkan::RenderMode* mode, bool free ) {
+	if ( !mode ) return;
+	renderModes.erase( std::remove( renderModes.begin(), renderModes.end(), mode ), renderModes.end() );
+	mode->destroy();
+	if ( free ) delete mode;
+	ext::vulkan::states::rebuild = true;
+}
+
+void ext::vulkan::initialize( /*uint8_t stage*/ ) {
+/*
+	switch ( stage ) {
+		case 0: {
+*/
+			device.initialize();
+			swapchain.initialize( device );
+			{
+				std::vector<uint8_t> pixels = { 
+					255,   0, 255, 255,      0,   0,   0, 255,
+					  0,   0,   0, 255,    255,   0, 255, 255,
+				};
+				Texture2D::empty.sampler.descriptor.filter.min = VK_FILTER_NEAREST;
+				Texture2D::empty.sampler.descriptor.filter.mag = VK_FILTER_NEAREST;
+				Texture2D::empty.fromBuffers( (void*) &pixels[0], pixels.size(), ext::vulkan::enums::Format::R8G8B8A8_UNORM, 2, 2, ext::vulkan::device, VK_IMAGE_USAGE_SAMPLED_BIT );
+			}
+			{
+				std::vector<uint8_t> pixels = { 
+					255,   0, 255, 255,      0,   0,   0, 255,
+					  0,   0,   0, 255,    255,   0, 255, 255,
+
+					 255,   0, 255, 255,      0,   0,   0, 255,
+					  0,   0,   0, 255,    255,   0, 255, 255,
+				};
+				Texture3D::empty.sampler.descriptor.filter.min = VK_FILTER_NEAREST;
+				Texture3D::empty.sampler.descriptor.filter.mag = VK_FILTER_NEAREST;
+				Texture3D::empty.fromBuffers( (void*) &pixels[0], pixels.size(), ext::vulkan::enums::Format::R8G8B8A8_UNORM, 2, 2, 2, 1, ext::vulkan::device, VK_IMAGE_USAGE_SAMPLED_BIT );
+			}
+			{
+				std::vector<uint8_t> pixels = { 
+					255,   0, 255, 255,      0,   0,   0, 255,
+					  0,   0,   0, 255,    255,   0, 255, 255,
+					
+					255,   0, 255, 255,      0,   0,   0, 255,
+					  0,   0,   0, 255,    255,   0, 255, 255,
+					
+					255,   0, 255, 255,      0,   0,   0, 255,
+					  0,   0,   0, 255,    255,   0, 255, 255,
+					
+					255,   0, 255, 255,      0,   0,   0, 255,
+					  0,   0,   0, 255,    255,   0, 255, 255,
+					
+					255,   0, 255, 255,      0,   0,   0, 255,
+					  0,   0,   0, 255,    255,   0, 255, 255,
+
+					255,   0, 255, 255,      0,   0,   0, 255,
+					  0,   0,   0, 255,    255,   0, 255, 255,
+				};
+				TextureCube::empty.sampler.descriptor.filter.min = VK_FILTER_NEAREST;
+				TextureCube::empty.sampler.descriptor.filter.mag = VK_FILTER_NEAREST;
+				TextureCube::empty.fromBuffers( (void*) &pixels[0], pixels.size(), ext::vulkan::enums::Format::R8G8B8A8_UNORM, 2, 2, 1, 6, ext::vulkan::device, VK_IMAGE_USAGE_SAMPLED_BIT );
+			}
+			for ( auto& renderMode : renderModes ) {
+				if ( !renderMode ) continue;
+				renderMode->initialize(device);
+			}
+			std::vector<std::function<int()>> jobs;
+			for ( auto& renderMode : renderModes ) {
+				if ( !renderMode ) continue;
+				if ( settings::experimental::individualPipelines ) renderMode->bindPipelines();
+				if ( settings::experimental::multithreadedCommandRecording ) {
+					jobs.emplace_back([&]{
+						renderMode->createCommandBuffers();
+						return 0;
+					});
+				} else {
+					renderMode->createCommandBuffers();
+				}
+			}
+			if ( !jobs.empty() ) {
+				uf::thread::batchWorkers( jobs );
+			}
+/*
+		} break;
+		case 1: {
+			std::function<void(uf::Entity*)> filter = [&]( uf::Entity* entity ) {
+				if ( !entity->hasComponent<uf::Graphic>() ) return;
+				ext::vulkan::Graphic& graphic = entity->getComponent<uf::Graphic>();
+				if ( graphic.initialized ) return;
+
+				graphic.initializePipeline();
+				ext::vulkan::states::rebuild = true;
+			};
+			for ( uf::Scene* scene : uf::scene::scenes ) {
+				if ( !scene ) continue;
+				scene->process(filter);
+			}
+		}
+		case 2: {
+			std::vector<std::function<int()>> jobs;
+			for ( auto& renderMode : renderModes ) {
+				if ( !renderMode ) continue;
+				if ( settings::experimental::individualPipelines ) renderMode->bindPipelines();
+				if ( settings::experimental::multithreadedCommandRecording ) {
+					jobs.emplace_back([&]{
+						renderMode->createCommandBuffers();
+						return 0;
+					});
+				} else {
+					renderMode->createCommandBuffers();
+				}
+			}
+			if ( !jobs.empty() ) {
+				uf::thread::batchWorkers( jobs );
+			}
+		} break;
+		default: {
+			UF_EXCEPTION("invalid stage id");
+		} break;
+	}
+*/
+}
+void ext::vulkan::tick() {
+	ext::vulkan::mutex.lock();
+	if ( ext::vulkan::states::resized || ext::vulkan::settings::experimental::rebuildOnTickBegin ) {
+		ext::vulkan::states::rebuild = true;
+	}
+
+	std::function<void(uf::Entity*)> filter = [&]( uf::Entity* entity ) {
+		if ( !entity->hasComponent<uf::Graphic>() ) return;
+		ext::vulkan::Graphic& graphic = entity->getComponent<uf::Graphic>();
+		if ( graphic.initialized || !graphic.process || graphic.initialized ) return;
+		graphic.initializePipeline();
+		ext::vulkan::states::rebuild = true;
+	};
+	for ( uf::Scene* scene : uf::scene::scenes ) {
+		if ( !scene ) continue;
+		scene->process(filter);
+	}
+	for ( auto& renderMode : renderModes ) {
+		if ( !renderMode ) continue;
+		if ( !renderMode->device ) {
+			renderMode->initialize(ext::vulkan::device);
+			ext::vulkan::states::rebuild = true;
+		}
+		renderMode->tick();
+	}
+
+	std::vector<std::function<int()>> jobs;
+	for ( auto& renderMode : renderModes ) {
+		if ( !renderMode ) continue;
+		if ( ext::vulkan::states::rebuild || renderMode->rebuild ) {
+			if ( settings::experimental::individualPipelines ) renderMode->bindPipelines();
+			if ( settings::experimental::multithreadedCommandRecording ) {
+				jobs.emplace_back([&]{
+					renderMode->createCommandBuffers();
+					return 0;
+				});
+			} else {
+				renderMode->createCommandBuffers();
+			}
+		}
+	}
+	if ( !jobs.empty() ) {
+		uf::thread::batchWorkers( jobs );
+	}
+	
+	ext::vulkan::states::rebuild = false;
+	ext::vulkan::states::resized = false;
+	ext::vulkan::mutex.unlock();
+}
+void ext::vulkan::render() {
+	ext::vulkan::mutex.lock();
+	if ( hasRenderMode("Gui", true) ) {
+		RenderMode& primary = getRenderMode("Gui", true);
+		auto it = std::find( renderModes.begin(), renderModes.end(), &primary );
+		if ( it + 1 != renderModes.end() ) std::rotate( it, it + 1, renderModes.end() );
+	}
+	if ( hasRenderMode("", true) ) {
+		RenderMode& primary = getRenderMode("", true);
+		auto it = std::find( renderModes.begin(), renderModes.end(), &primary );
+		if ( it + 1 != renderModes.end() ) std::rotate( it, it + 1, renderModes.end() );
+	} else {
+		RenderMode& primary = getRenderMode("Swapchain", true);
+		auto it = std::find( renderModes.begin(), renderModes.end(), &primary );
+		if ( it + 1 != renderModes.end() ) std::rotate( it, it + 1, renderModes.end() );
+	}
+
+	for ( auto& renderMode : renderModes ) {
+		if ( !renderMode ) continue;
+		if ( !renderMode->execute ) continue;
+		ext::vulkan::currentRenderMode = renderMode;
+		for ( uf::Scene* scene : uf::scene::scenes ) scene->render();
+		renderMode->render();
+	}
+
+	ext::vulkan::currentRenderMode = NULL;
+	if ( ext::vulkan::settings::experimental::waitOnRenderEnd ) {
+		synchronize();
+	}
+/*
+	if ( ext::openvr::context ) {
+		ext::openvr::postSubmit();
+	}
+*/
+	ext::vulkan::mutex.unlock();
+}
+void ext::vulkan::destroy() {
+	ext::vulkan::mutex.lock();
+	synchronize();
+
+	Texture2D::empty.destroy();
+	Texture3D::empty.destroy();
+	TextureCube::empty.destroy();
+
+	std::function<void(uf::Entity*)> filter = [&]( uf::Entity* entity ) {
+		if ( !entity->hasComponent<uf::Graphic>() ) return;
+		uf::Graphic& graphic = entity->getComponent<uf::Graphic>();
+		graphic.destroy();
+	};
+	for ( uf::Scene* scene : uf::scene::scenes ) {
+		if ( !scene ) continue;
+		scene->process(filter);
+	}
+
+	for ( auto& renderMode : renderModes ) {
+		if ( !renderMode ) continue;
+		renderMode->destroy();
+	//	delete renderMode;
+		renderMode = NULL;
+	}
+
+	swapchain.destroy();
+	device.destroy();
+	ext::vulkan::mutex.unlock();
+}
+void ext::vulkan::synchronize( uint8_t flag ) {
+	if ( flag & 0b01 ) {
+		for ( auto& renderMode : renderModes ) {
+			if ( !renderMode ) continue;
+			if ( !renderMode->execute ) continue;
+			renderMode->synchronize();
+		}
+	}
+	if ( flag & 0b10 )
+		vkDeviceWaitIdle( device );
+}
+
+std::string ext::vulkan::allocatorStats() {
+	char* statsString = nullptr;
+	vmaBuildStatsString(ext::vulkan::allocator, &statsString, true);
+	std::string result = statsString;
+	vmaFreeStatsString(ext::vulkan::allocator, statsString);
+	return result;
+}
+
+ext::vulkan::enums::Format::type_t ext::vulkan::formatFromString( const std::string& string ) {
+	std::unordered_map<std::string,ext::vulkan::enums::Format::type_t> table = {
+		{ "UNDEFINED", ext::vulkan::enums::Format::UNDEFINED },
+		{ "R4G4_UNORM_PACK8", ext::vulkan::enums::Format::R4G4_UNORM_PACK8 },
+		{ "R4G4B4A4_UNORM_PACK16", ext::vulkan::enums::Format::R4G4B4A4_UNORM_PACK16 },
+		{ "B4G4R4A4_UNORM_PACK16", ext::vulkan::enums::Format::B4G4R4A4_UNORM_PACK16 },
+		{ "R5G6B5_UNORM_PACK16", ext::vulkan::enums::Format::R5G6B5_UNORM_PACK16 },
+		{ "B5G6R5_UNORM_PACK16", ext::vulkan::enums::Format::B5G6R5_UNORM_PACK16 },
+		{ "R5G5B5A1_UNORM_PACK16", ext::vulkan::enums::Format::R5G5B5A1_UNORM_PACK16 },
+		{ "B5G5R5A1_UNORM_PACK16", ext::vulkan::enums::Format::B5G5R5A1_UNORM_PACK16 },
+		{ "A1R5G5B5_UNORM_PACK16", ext::vulkan::enums::Format::A1R5G5B5_UNORM_PACK16 },
+		{ "R8_UNORM", ext::vulkan::enums::Format::R8_UNORM },
+		{ "R8_SNORM", ext::vulkan::enums::Format::R8_SNORM },
+		{ "R8_USCALED", ext::vulkan::enums::Format::R8_USCALED },
+		{ "R8_SSCALED", ext::vulkan::enums::Format::R8_SSCALED },
+		{ "R8_UINT", ext::vulkan::enums::Format::R8_UINT },
+		{ "R8_SINT", ext::vulkan::enums::Format::R8_SINT },
+		{ "R8_SRGB", ext::vulkan::enums::Format::R8_SRGB },
+		{ "R8G8_UNORM", ext::vulkan::enums::Format::R8G8_UNORM },
+		{ "R8G8_SNORM", ext::vulkan::enums::Format::R8G8_SNORM },
+		{ "R8G8_USCALED", ext::vulkan::enums::Format::R8G8_USCALED },
+		{ "R8G8_SSCALED", ext::vulkan::enums::Format::R8G8_SSCALED },
+		{ "R8G8_UINT", ext::vulkan::enums::Format::R8G8_UINT },
+		{ "R8G8_SINT", ext::vulkan::enums::Format::R8G8_SINT },
+		{ "R8G8_SRGB", ext::vulkan::enums::Format::R8G8_SRGB },
+		{ "R8G8B8_UNORM", ext::vulkan::enums::Format::R8G8B8_UNORM },
+		{ "R8G8B8_SNORM", ext::vulkan::enums::Format::R8G8B8_SNORM },
+		{ "R8G8B8_USCALED", ext::vulkan::enums::Format::R8G8B8_USCALED },
+		{ "R8G8B8_SSCALED", ext::vulkan::enums::Format::R8G8B8_SSCALED },
+		{ "R8G8B8_UINT", ext::vulkan::enums::Format::R8G8B8_UINT },
+		{ "R8G8B8_SINT", ext::vulkan::enums::Format::R8G8B8_SINT },
+		{ "R8G8B8_SRGB", ext::vulkan::enums::Format::R8G8B8_SRGB },
+		{ "B8G8R8_UNORM", ext::vulkan::enums::Format::B8G8R8_UNORM },
+		{ "B8G8R8_SNORM", ext::vulkan::enums::Format::B8G8R8_SNORM },
+		{ "B8G8R8_USCALED", ext::vulkan::enums::Format::B8G8R8_USCALED },
+		{ "B8G8R8_SSCALED", ext::vulkan::enums::Format::B8G8R8_SSCALED },
+		{ "B8G8R8_UINT", ext::vulkan::enums::Format::B8G8R8_UINT },
+		{ "B8G8R8_SINT", ext::vulkan::enums::Format::B8G8R8_SINT },
+		{ "B8G8R8_SRGB", ext::vulkan::enums::Format::B8G8R8_SRGB },
+		{ "R8G8B8A8_UNORM", ext::vulkan::enums::Format::R8G8B8A8_UNORM },
+		{ "R8G8B8A8_SNORM", ext::vulkan::enums::Format::R8G8B8A8_SNORM },
+		{ "R8G8B8A8_USCALED", ext::vulkan::enums::Format::R8G8B8A8_USCALED },
+		{ "R8G8B8A8_SSCALED", ext::vulkan::enums::Format::R8G8B8A8_SSCALED },
+		{ "R8G8B8A8_UINT", ext::vulkan::enums::Format::R8G8B8A8_UINT },
+		{ "R8G8B8A8_SINT", ext::vulkan::enums::Format::R8G8B8A8_SINT },
+		{ "R8G8B8A8_SRGB", ext::vulkan::enums::Format::R8G8B8A8_SRGB },
+		{ "B8G8R8A8_UNORM", ext::vulkan::enums::Format::B8G8R8A8_UNORM },
+		{ "B8G8R8A8_SNORM", ext::vulkan::enums::Format::B8G8R8A8_SNORM },
+		{ "B8G8R8A8_USCALED", ext::vulkan::enums::Format::B8G8R8A8_USCALED },
+		{ "B8G8R8A8_SSCALED", ext::vulkan::enums::Format::B8G8R8A8_SSCALED },
+		{ "B8G8R8A8_UINT", ext::vulkan::enums::Format::B8G8R8A8_UINT },
+		{ "B8G8R8A8_SINT", ext::vulkan::enums::Format::B8G8R8A8_SINT },
+		{ "B8G8R8A8_SRGB", ext::vulkan::enums::Format::B8G8R8A8_SRGB },
+		{ "A8B8G8R8_UNORM_PACK32", ext::vulkan::enums::Format::A8B8G8R8_UNORM_PACK32 },
+		{ "A8B8G8R8_SNORM_PACK32", ext::vulkan::enums::Format::A8B8G8R8_SNORM_PACK32 },
+		{ "A8B8G8R8_USCALED_PACK32", ext::vulkan::enums::Format::A8B8G8R8_USCALED_PACK32 },
+		{ "A8B8G8R8_SSCALED_PACK32", ext::vulkan::enums::Format::A8B8G8R8_SSCALED_PACK32 },
+		{ "A8B8G8R8_UINT_PACK32", ext::vulkan::enums::Format::A8B8G8R8_UINT_PACK32 },
+		{ "A8B8G8R8_SINT_PACK32", ext::vulkan::enums::Format::A8B8G8R8_SINT_PACK32 },
+		{ "A8B8G8R8_SRGB_PACK32", ext::vulkan::enums::Format::A8B8G8R8_SRGB_PACK32 },
+		{ "A2R10G10B10_UNORM_PACK32", ext::vulkan::enums::Format::A2R10G10B10_UNORM_PACK32 },
+		{ "A2R10G10B10_SNORM_PACK32", ext::vulkan::enums::Format::A2R10G10B10_SNORM_PACK32 },
+		{ "A2R10G10B10_USCALED_PACK32", ext::vulkan::enums::Format::A2R10G10B10_USCALED_PACK32 },
+		{ "A2R10G10B10_SSCALED_PACK32", ext::vulkan::enums::Format::A2R10G10B10_SSCALED_PACK32 },
+		{ "A2R10G10B10_UINT_PACK32", ext::vulkan::enums::Format::A2R10G10B10_UINT_PACK32 },
+		{ "A2R10G10B10_SINT_PACK32", ext::vulkan::enums::Format::A2R10G10B10_SINT_PACK32 },
+		{ "A2B10G10R10_UNORM_PACK32", ext::vulkan::enums::Format::A2B10G10R10_UNORM_PACK32 },
+		{ "A2B10G10R10_SNORM_PACK32", ext::vulkan::enums::Format::A2B10G10R10_SNORM_PACK32 },
+		{ "A2B10G10R10_USCALED_PACK32", ext::vulkan::enums::Format::A2B10G10R10_USCALED_PACK32 },
+		{ "A2B10G10R10_SSCALED_PACK32", ext::vulkan::enums::Format::A2B10G10R10_SSCALED_PACK32 },
+		{ "A2B10G10R10_UINT_PACK32", ext::vulkan::enums::Format::A2B10G10R10_UINT_PACK32 },
+		{ "A2B10G10R10_SINT_PACK32", ext::vulkan::enums::Format::A2B10G10R10_SINT_PACK32 },
+		{ "R16_UNORM", ext::vulkan::enums::Format::R16_UNORM },
+		{ "R16_SNORM", ext::vulkan::enums::Format::R16_SNORM },
+		{ "R16_USCALED", ext::vulkan::enums::Format::R16_USCALED },
+		{ "R16_SSCALED", ext::vulkan::enums::Format::R16_SSCALED },
+		{ "R16_UINT", ext::vulkan::enums::Format::R16_UINT },
+		{ "R16_SINT", ext::vulkan::enums::Format::R16_SINT },
+		{ "R16_SFLOAT", ext::vulkan::enums::Format::R16_SFLOAT },
+		{ "R16G16_UNORM", ext::vulkan::enums::Format::R16G16_UNORM },
+		{ "R16G16_SNORM", ext::vulkan::enums::Format::R16G16_SNORM },
+		{ "R16G16_USCALED", ext::vulkan::enums::Format::R16G16_USCALED },
+		{ "R16G16_SSCALED", ext::vulkan::enums::Format::R16G16_SSCALED },
+		{ "R16G16_UINT", ext::vulkan::enums::Format::R16G16_UINT },
+		{ "R16G16_SINT", ext::vulkan::enums::Format::R16G16_SINT },
+		{ "R16G16_SFLOAT", ext::vulkan::enums::Format::R16G16_SFLOAT },
+		{ "R16G16B16_UNORM", ext::vulkan::enums::Format::R16G16B16_UNORM },
+		{ "R16G16B16_SNORM", ext::vulkan::enums::Format::R16G16B16_SNORM },
+		{ "R16G16B16_USCALED", ext::vulkan::enums::Format::R16G16B16_USCALED },
+		{ "R16G16B16_SSCALED", ext::vulkan::enums::Format::R16G16B16_SSCALED },
+		{ "R16G16B16_UINT", ext::vulkan::enums::Format::R16G16B16_UINT },
+		{ "R16G16B16_SINT", ext::vulkan::enums::Format::R16G16B16_SINT },
+		{ "R16G16B16_SFLOAT", ext::vulkan::enums::Format::R16G16B16_SFLOAT },
+		{ "R16G16B16A16_UNORM", ext::vulkan::enums::Format::R16G16B16A16_UNORM },
+		{ "R16G16B16A16_SNORM", ext::vulkan::enums::Format::R16G16B16A16_SNORM },
+		{ "R16G16B16A16_USCALED", ext::vulkan::enums::Format::R16G16B16A16_USCALED },
+		{ "R16G16B16A16_SSCALED", ext::vulkan::enums::Format::R16G16B16A16_SSCALED },
+		{ "R16G16B16A16_UINT", ext::vulkan::enums::Format::R16G16B16A16_UINT },
+		{ "R16G16B16A16_SINT", ext::vulkan::enums::Format::R16G16B16A16_SINT },
+		{ "R16G16B16A16_SFLOAT", ext::vulkan::enums::Format::R16G16B16A16_SFLOAT },
+		{ "R32_UINT", ext::vulkan::enums::Format::R32_UINT },
+		{ "R32_SINT", ext::vulkan::enums::Format::R32_SINT },
+		{ "R32_SFLOAT", ext::vulkan::enums::Format::R32_SFLOAT },
+		{ "R32G32_UINT", ext::vulkan::enums::Format::R32G32_UINT },
+		{ "R32G32_SINT", ext::vulkan::enums::Format::R32G32_SINT },
+		{ "R32G32_SFLOAT", ext::vulkan::enums::Format::R32G32_SFLOAT },
+		{ "R32G32B32_UINT", ext::vulkan::enums::Format::R32G32B32_UINT },
+		{ "R32G32B32_SINT", ext::vulkan::enums::Format::R32G32B32_SINT },
+		{ "R32G32B32_SFLOAT", ext::vulkan::enums::Format::R32G32B32_SFLOAT },
+		{ "R32G32B32A32_UINT", ext::vulkan::enums::Format::R32G32B32A32_UINT },
+		{ "R32G32B32A32_SINT", ext::vulkan::enums::Format::R32G32B32A32_SINT },
+		{ "R32G32B32A32_SFLOAT", ext::vulkan::enums::Format::R32G32B32A32_SFLOAT },
+		{ "R64_UINT", ext::vulkan::enums::Format::R64_UINT },
+		{ "R64_SINT", ext::vulkan::enums::Format::R64_SINT },
+		{ "R64_SFLOAT", ext::vulkan::enums::Format::R64_SFLOAT },
+		{ "R64G64_UINT", ext::vulkan::enums::Format::R64G64_UINT },
+		{ "R64G64_SINT", ext::vulkan::enums::Format::R64G64_SINT },
+		{ "R64G64_SFLOAT", ext::vulkan::enums::Format::R64G64_SFLOAT },
+		{ "R64G64B64_UINT", ext::vulkan::enums::Format::R64G64B64_UINT },
+		{ "R64G64B64_SINT", ext::vulkan::enums::Format::R64G64B64_SINT },
+		{ "R64G64B64_SFLOAT", ext::vulkan::enums::Format::R64G64B64_SFLOAT },
+		{ "R64G64B64A64_UINT", ext::vulkan::enums::Format::R64G64B64A64_UINT },
+		{ "R64G64B64A64_SINT", ext::vulkan::enums::Format::R64G64B64A64_SINT },
+		{ "R64G64B64A64_SFLOAT", ext::vulkan::enums::Format::R64G64B64A64_SFLOAT },
+		{ "B10G11R11_UFLOAT_PACK32", ext::vulkan::enums::Format::B10G11R11_UFLOAT_PACK32 },
+		{ "E5B9G9R9_UFLOAT_PACK32", ext::vulkan::enums::Format::E5B9G9R9_UFLOAT_PACK32 },
+		{ "D16_UNORM", ext::vulkan::enums::Format::D16_UNORM },
+		{ "X8_D24_UNORM_PACK32", ext::vulkan::enums::Format::X8_D24_UNORM_PACK32 },
+		{ "D32_SFLOAT", ext::vulkan::enums::Format::D32_SFLOAT },
+		{ "S8_UINT", ext::vulkan::enums::Format::S8_UINT },
+		{ "D16_UNORM_S8_UINT", ext::vulkan::enums::Format::D16_UNORM_S8_UINT },
+		{ "D24_UNORM_S8_UINT", ext::vulkan::enums::Format::D24_UNORM_S8_UINT },
+		{ "D32_SFLOAT_S8_UINT", ext::vulkan::enums::Format::D32_SFLOAT_S8_UINT },
+		{ "BC1_RGB_UNORM_BLOCK", ext::vulkan::enums::Format::BC1_RGB_UNORM_BLOCK },
+		{ "BC1_RGB_SRGB_BLOCK", ext::vulkan::enums::Format::BC1_RGB_SRGB_BLOCK },
+		{ "BC1_RGBA_UNORM_BLOCK", ext::vulkan::enums::Format::BC1_RGBA_UNORM_BLOCK },
+		{ "BC1_RGBA_SRGB_BLOCK", ext::vulkan::enums::Format::BC1_RGBA_SRGB_BLOCK },
+		{ "BC2_UNORM_BLOCK", ext::vulkan::enums::Format::BC2_UNORM_BLOCK },
+		{ "BC2_SRGB_BLOCK", ext::vulkan::enums::Format::BC2_SRGB_BLOCK },
+		{ "BC3_UNORM_BLOCK", ext::vulkan::enums::Format::BC3_UNORM_BLOCK },
+		{ "BC3_SRGB_BLOCK", ext::vulkan::enums::Format::BC3_SRGB_BLOCK },
+		{ "BC4_UNORM_BLOCK", ext::vulkan::enums::Format::BC4_UNORM_BLOCK },
+		{ "BC4_SNORM_BLOCK", ext::vulkan::enums::Format::BC4_SNORM_BLOCK },
+		{ "BC5_UNORM_BLOCK", ext::vulkan::enums::Format::BC5_UNORM_BLOCK },
+		{ "BC5_SNORM_BLOCK", ext::vulkan::enums::Format::BC5_SNORM_BLOCK },
+		{ "BC6H_UFLOAT_BLOCK", ext::vulkan::enums::Format::BC6H_UFLOAT_BLOCK },
+		{ "BC6H_SFLOAT_BLOCK", ext::vulkan::enums::Format::BC6H_SFLOAT_BLOCK },
+		{ "BC7_UNORM_BLOCK", ext::vulkan::enums::Format::BC7_UNORM_BLOCK },
+		{ "BC7_SRGB_BLOCK", ext::vulkan::enums::Format::BC7_SRGB_BLOCK },
+		{ "ETC2_R8G8B8_UNORM_BLOCK", ext::vulkan::enums::Format::ETC2_R8G8B8_UNORM_BLOCK },
+		{ "ETC2_R8G8B8_SRGB_BLOCK", ext::vulkan::enums::Format::ETC2_R8G8B8_SRGB_BLOCK },
+		{ "ETC2_R8G8B8A1_UNORM_BLOCK", ext::vulkan::enums::Format::ETC2_R8G8B8A1_UNORM_BLOCK },
+		{ "ETC2_R8G8B8A1_SRGB_BLOCK", ext::vulkan::enums::Format::ETC2_R8G8B8A1_SRGB_BLOCK },
+		{ "ETC2_R8G8B8A8_UNORM_BLOCK", ext::vulkan::enums::Format::ETC2_R8G8B8A8_UNORM_BLOCK },
+		{ "ETC2_R8G8B8A8_SRGB_BLOCK", ext::vulkan::enums::Format::ETC2_R8G8B8A8_SRGB_BLOCK },
+		{ "EAC_R11_UNORM_BLOCK", ext::vulkan::enums::Format::EAC_R11_UNORM_BLOCK },
+		{ "EAC_R11_SNORM_BLOCK", ext::vulkan::enums::Format::EAC_R11_SNORM_BLOCK },
+		{ "EAC_R11G11_UNORM_BLOCK", ext::vulkan::enums::Format::EAC_R11G11_UNORM_BLOCK },
+		{ "EAC_R11G11_SNORM_BLOCK", ext::vulkan::enums::Format::EAC_R11G11_SNORM_BLOCK },
+		{ "ASTC_4x4_UNORM_BLOCK", ext::vulkan::enums::Format::ASTC_4x4_UNORM_BLOCK },
+		{ "ASTC_4x4_SRGB_BLOCK", ext::vulkan::enums::Format::ASTC_4x4_SRGB_BLOCK },
+		{ "ASTC_5x4_UNORM_BLOCK", ext::vulkan::enums::Format::ASTC_5x4_UNORM_BLOCK },
+		{ "ASTC_5x4_SRGB_BLOCK", ext::vulkan::enums::Format::ASTC_5x4_SRGB_BLOCK },
+		{ "ASTC_5x5_UNORM_BLOCK", ext::vulkan::enums::Format::ASTC_5x5_UNORM_BLOCK },
+		{ "ASTC_5x5_SRGB_BLOCK", ext::vulkan::enums::Format::ASTC_5x5_SRGB_BLOCK },
+		{ "ASTC_6x5_UNORM_BLOCK", ext::vulkan::enums::Format::ASTC_6x5_UNORM_BLOCK },
+		{ "ASTC_6x5_SRGB_BLOCK", ext::vulkan::enums::Format::ASTC_6x5_SRGB_BLOCK },
+		{ "ASTC_6x6_UNORM_BLOCK", ext::vulkan::enums::Format::ASTC_6x6_UNORM_BLOCK },
+		{ "ASTC_6x6_SRGB_BLOCK", ext::vulkan::enums::Format::ASTC_6x6_SRGB_BLOCK },
+		{ "ASTC_8x5_UNORM_BLOCK", ext::vulkan::enums::Format::ASTC_8x5_UNORM_BLOCK },
+		{ "ASTC_8x5_SRGB_BLOCK", ext::vulkan::enums::Format::ASTC_8x5_SRGB_BLOCK },
+		{ "ASTC_8x6_UNORM_BLOCK", ext::vulkan::enums::Format::ASTC_8x6_UNORM_BLOCK },
+		{ "ASTC_8x6_SRGB_BLOCK", ext::vulkan::enums::Format::ASTC_8x6_SRGB_BLOCK },
+		{ "ASTC_8x8_UNORM_BLOCK", ext::vulkan::enums::Format::ASTC_8x8_UNORM_BLOCK },
+		{ "ASTC_8x8_SRGB_BLOCK", ext::vulkan::enums::Format::ASTC_8x8_SRGB_BLOCK },
+		{ "ASTC_10x5_UNORM_BLOCK", ext::vulkan::enums::Format::ASTC_10x5_UNORM_BLOCK },
+		{ "ASTC_10x5_SRGB_BLOCK", ext::vulkan::enums::Format::ASTC_10x5_SRGB_BLOCK },
+		{ "ASTC_10x6_UNORM_BLOCK", ext::vulkan::enums::Format::ASTC_10x6_UNORM_BLOCK },
+		{ "ASTC_10x6_SRGB_BLOCK", ext::vulkan::enums::Format::ASTC_10x6_SRGB_BLOCK },
+		{ "ASTC_10x8_UNORM_BLOCK", ext::vulkan::enums::Format::ASTC_10x8_UNORM_BLOCK },
+		{ "ASTC_10x8_SRGB_BLOCK", ext::vulkan::enums::Format::ASTC_10x8_SRGB_BLOCK },
+		{ "ASTC_10x10_UNORM_BLOCK", ext::vulkan::enums::Format::ASTC_10x10_UNORM_BLOCK },
+		{ "ASTC_10x10_SRGB_BLOCK", ext::vulkan::enums::Format::ASTC_10x10_SRGB_BLOCK },
+		{ "ASTC_12x10_UNORM_BLOCK", ext::vulkan::enums::Format::ASTC_12x10_UNORM_BLOCK },
+		{ "ASTC_12x10_SRGB_BLOCK", ext::vulkan::enums::Format::ASTC_12x10_SRGB_BLOCK },
+		{ "ASTC_12x12_UNORM_BLOCK", ext::vulkan::enums::Format::ASTC_12x12_UNORM_BLOCK },
+		{ "ASTC_12x12_SRGB_BLOCK", ext::vulkan::enums::Format::ASTC_12x12_SRGB_BLOCK },
+/*
+		{ "G8B8G8R8_422_UNORM", ext::vulkan::enums::Format::G8B8G8R8_422_UNORM },
+		{ "B8G8R8G8_422_UNORM", ext::vulkan::enums::Format::B8G8R8G8_422_UNORM },
+		{ "G8_B8_R8_3PLANE_420_UNORM", ext::vulkan::enums::Format::G8_B8_R8_3PLANE_420_UNORM },
+		{ "G8_B8R8_2PLANE_420_UNORM", ext::vulkan::enums::Format::G8_B8R8_2PLANE_420_UNORM },
+		{ "G8_B8_R8_3PLANE_422_UNORM", ext::vulkan::enums::Format::G8_B8_R8_3PLANE_422_UNORM },
+		{ "G8_B8R8_2PLANE_422_UNORM", ext::vulkan::enums::Format::G8_B8R8_2PLANE_422_UNORM },
+		{ "G8_B8_R8_3PLANE_444_UNORM", ext::vulkan::enums::Format::G8_B8_R8_3PLANE_444_UNORM },
+		{ "R10X6_UNORM_PACK16", ext::vulkan::enums::Format::R10X6_UNORM_PACK16 },
+		{ "R10X6G10X6_UNORM_2PACK16", ext::vulkan::enums::Format::R10X6G10X6_UNORM_2PACK16 },
+		{ "R10X6G10X6B10X6A10X6_UNORM_4PACK16", ext::vulkan::enums::Format::R10X6G10X6B10X6A10X6_UNORM_4PACK16 },
+		{ "G10X6B10X6G10X6R10X6_422_UNORM_4PACK16", ext::vulkan::enums::Format::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 },
+		{ "B10X6G10X6R10X6G10X6_422_UNORM_4PACK16", ext::vulkan::enums::Format::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 },
+		{ "G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16", ext::vulkan::enums::Format::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 },
+		{ "G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16", ext::vulkan::enums::Format::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 },
+		{ "G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16", ext::vulkan::enums::Format::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 },
+		{ "G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16", ext::vulkan::enums::Format::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 },
+		{ "G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16", ext::vulkan::enums::Format::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 },
+		{ "R12X4_UNORM_PACK16", ext::vulkan::enums::Format::R12X4_UNORM_PACK16 },
+		{ "R12X4G12X4_UNORM_2PACK16", ext::vulkan::enums::Format::R12X4G12X4_UNORM_2PACK16 },
+		{ "R12X4G12X4B12X4A12X4_UNORM_4PACK16", ext::vulkan::enums::Format::R12X4G12X4B12X4A12X4_UNORM_4PACK16 },
+		{ "G12X4B12X4G12X4R12X4_422_UNORM_4PACK16", ext::vulkan::enums::Format::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 },
+		{ "B12X4G12X4R12X4G12X4_422_UNORM_4PACK16", ext::vulkan::enums::Format::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 },
+		{ "G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16", ext::vulkan::enums::Format::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 },
+		{ "G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16", ext::vulkan::enums::Format::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 },
+		{ "G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16", ext::vulkan::enums::Format::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 },
+		{ "G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16", ext::vulkan::enums::Format::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 },
+		{ "G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16", ext::vulkan::enums::Format::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 },
+		{ "G16B16G16R16_422_UNORM", ext::vulkan::enums::Format::G16B16G16R16_422_UNORM },
+		{ "B16G16R16G16_422_UNORM", ext::vulkan::enums::Format::B16G16R16G16_422_UNORM },
+		{ "G16_B16_R16_3PLANE_420_UNORM", ext::vulkan::enums::Format::G16_B16_R16_3PLANE_420_UNORM },
+		{ "G16_B16R16_2PLANE_420_UNORM", ext::vulkan::enums::Format::G16_B16R16_2PLANE_420_UNORM },
+		{ "G16_B16_R16_3PLANE_422_UNORM", ext::vulkan::enums::Format::G16_B16_R16_3PLANE_422_UNORM },
+		{ "G16_B16R16_2PLANE_422_UNORM", ext::vulkan::enums::Format::G16_B16R16_2PLANE_422_UNORM },
+		{ "G16_B16_R16_3PLANE_444_UNORM", ext::vulkan::enums::Format::G16_B16_R16_3PLANE_444_UNORM },
+		{ "PVRTC1_2BPP_UNORM_BLOCK_IMG", ext::vulkan::enums::Format::PVRTC1_2BPP_UNORM_BLOCK_IMG },
+		{ "PVRTC1_4BPP_UNORM_BLOCK_IMG", ext::vulkan::enums::Format::PVRTC1_4BPP_UNORM_BLOCK_IMG },
+		{ "PVRTC2_2BPP_UNORM_BLOCK_IMG", ext::vulkan::enums::Format::PVRTC2_2BPP_UNORM_BLOCK_IMG },
+		{ "PVRTC2_4BPP_UNORM_BLOCK_IMG", ext::vulkan::enums::Format::PVRTC2_4BPP_UNORM_BLOCK_IMG },
+		{ "PVRTC1_2BPP_SRGB_BLOCK_IMG", ext::vulkan::enums::Format::PVRTC1_2BPP_SRGB_BLOCK_IMG },
+		{ "PVRTC1_4BPP_SRGB_BLOCK_IMG", ext::vulkan::enums::Format::PVRTC1_4BPP_SRGB_BLOCK_IMG },
+		{ "PVRTC2_2BPP_SRGB_BLOCK_IMG", ext::vulkan::enums::Format::PVRTC2_2BPP_SRGB_BLOCK_IMG },
+		{ "PVRTC2_4BPP_SRGB_BLOCK_IMG", ext::vulkan::enums::Format::PVRTC2_4BPP_SRGB_BLOCK_IMG },
+		{ "ASTC_4x4_SFLOAT_BLOCK_EXT", ext::vulkan::enums::Format::ASTC_4x4_SFLOAT_BLOCK_EXT },
+		{ "ASTC_5x4_SFLOAT_BLOCK_EXT", ext::vulkan::enums::Format::ASTC_5x4_SFLOAT_BLOCK_EXT },
+		{ "ASTC_5x5_SFLOAT_BLOCK_EXT", ext::vulkan::enums::Format::ASTC_5x5_SFLOAT_BLOCK_EXT },
+		{ "ASTC_6x5_SFLOAT_BLOCK_EXT", ext::vulkan::enums::Format::ASTC_6x5_SFLOAT_BLOCK_EXT },
+		{ "ASTC_6x6_SFLOAT_BLOCK_EXT", ext::vulkan::enums::Format::ASTC_6x6_SFLOAT_BLOCK_EXT },
+		{ "ASTC_8x5_SFLOAT_BLOCK_EXT", ext::vulkan::enums::Format::ASTC_8x5_SFLOAT_BLOCK_EXT },
+		{ "ASTC_8x6_SFLOAT_BLOCK_EXT", ext::vulkan::enums::Format::ASTC_8x6_SFLOAT_BLOCK_EXT },
+		{ "ASTC_8x8_SFLOAT_BLOCK_EXT", ext::vulkan::enums::Format::ASTC_8x8_SFLOAT_BLOCK_EXT },
+		{ "ASTC_10x5_SFLOAT_BLOCK_EXT", ext::vulkan::enums::Format::ASTC_10x5_SFLOAT_BLOCK_EXT },
+		{ "ASTC_10x6_SFLOAT_BLOCK_EXT", ext::vulkan::enums::Format::ASTC_10x6_SFLOAT_BLOCK_EXT },
+		{ "ASTC_10x8_SFLOAT_BLOCK_EXT", ext::vulkan::enums::Format::ASTC_10x8_SFLOAT_BLOCK_EXT },
+		{ "ASTC_10x10_SFLOAT_BLOCK_EXT", ext::vulkan::enums::Format::ASTC_10x10_SFLOAT_BLOCK_EXT },
+		{ "ASTC_12x10_SFLOAT_BLOCK_EXT", ext::vulkan::enums::Format::ASTC_12x10_SFLOAT_BLOCK_EXT },
+		{ "ASTC_12x12_SFLOAT_BLOCK_EXT", ext::vulkan::enums::Format::ASTC_12x12_SFLOAT_BLOCK_EXT },
+		{ "A4R4G4B4_UNORM_PACK16_EXT", ext::vulkan::enums::Format::A4R4G4B4_UNORM_PACK16_EXT },
+		{ "A4B4G4R4_UNORM_PACK16_EXT", ext::vulkan::enums::Format::A4B4G4R4_UNORM_PACK16_EXT },
+		{ "G8B8G8R8_422_UNORM_KHR", ext::vulkan::enums::Format::G8B8G8R8_422_UNORM_KHR },
+		{ "B8G8R8G8_422_UNORM_KHR", ext::vulkan::enums::Format::B8G8R8G8_422_UNORM_KHR },
+		{ "G8_B8_R8_3PLANE_420_UNORM_KHR", ext::vulkan::enums::Format::G8_B8_R8_3PLANE_420_UNORM_KHR },
+		{ "G8_B8R8_2PLANE_420_UNORM_KHR", ext::vulkan::enums::Format::G8_B8R8_2PLANE_420_UNORM_KHR },
+		{ "G8_B8_R8_3PLANE_422_UNORM_KHR", ext::vulkan::enums::Format::G8_B8_R8_3PLANE_422_UNORM_KHR },
+		{ "G8_B8R8_2PLANE_422_UNORM_KHR", ext::vulkan::enums::Format::G8_B8R8_2PLANE_422_UNORM_KHR },
+		{ "G8_B8_R8_3PLANE_444_UNORM_KHR", ext::vulkan::enums::Format::G8_B8_R8_3PLANE_444_UNORM_KHR },
+		{ "R10X6_UNORM_PACK16_KHR", ext::vulkan::enums::Format::R10X6_UNORM_PACK16_KHR },
+		{ "R10X6G10X6_UNORM_2PACK16_KHR", ext::vulkan::enums::Format::R10X6G10X6_UNORM_2PACK16_KHR },
+		{ "R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR", ext::vulkan::enums::Format::R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR },
+		{ "G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR", ext::vulkan::enums::Format::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR },
+		{ "B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR", ext::vulkan::enums::Format::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR },
+		{ "G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR", ext::vulkan::enums::Format::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR },
+		{ "G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR", ext::vulkan::enums::Format::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR },
+		{ "G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR", ext::vulkan::enums::Format::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR },
+		{ "G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR", ext::vulkan::enums::Format::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR },
+		{ "G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR", ext::vulkan::enums::Format::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR },
+		{ "R12X4_UNORM_PACK16_KHR", ext::vulkan::enums::Format::R12X4_UNORM_PACK16_KHR },
+		{ "R12X4G12X4_UNORM_2PACK16_KHR", ext::vulkan::enums::Format::R12X4G12X4_UNORM_2PACK16_KHR },
+		{ "R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR", ext::vulkan::enums::Format::R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR },
+		{ "G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR", ext::vulkan::enums::Format::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR },
+		{ "B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR", ext::vulkan::enums::Format::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR },
+		{ "G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR", ext::vulkan::enums::Format::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR },
+		{ "G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR", ext::vulkan::enums::Format::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR },
+		{ "G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR", ext::vulkan::enums::Format::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR },
+		{ "G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR", ext::vulkan::enums::Format::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR },
+		{ "G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR", ext::vulkan::enums::Format::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR },
+		{ "G16B16G16R16_422_UNORM_KHR", ext::vulkan::enums::Format::G16B16G16R16_422_UNORM_KHR },
+		{ "B16G16R16G16_422_UNORM_KHR", ext::vulkan::enums::Format::B16G16R16G16_422_UNORM_KHR },
+		{ "G16_B16_R16_3PLANE_420_UNORM_KHR", ext::vulkan::enums::Format::G16_B16_R16_3PLANE_420_UNORM_KHR },
+		{ "G16_B16R16_2PLANE_420_UNORM_KHR", ext::vulkan::enums::Format::G16_B16R16_2PLANE_420_UNORM_KHR },
+		{ "G16_B16_R16_3PLANE_422_UNORM_KHR", ext::vulkan::enums::Format::G16_B16_R16_3PLANE_422_UNORM_KHR },
+		{ "G16_B16R16_2PLANE_422_UNORM_KHR", ext::vulkan::enums::Format::G16_B16R16_2PLANE_422_UNORM_KHR },
+		{ "G16_B16_R16_3PLANE_444_UNORM_KHR", ext::vulkan::enums::Format::G16_B16_R16_3PLANE_444_UNORM_KHR },
+*/
+	};
+	return table[string];
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/src/spec/context/universal.cpp b/engine/src/spec/context/universal.cpp
new file mode 100644
index 00000000..a684f729
--- /dev/null
+++ b/engine/src/spec/context/universal.cpp
@@ -0,0 +1,140 @@
+#include <uf/config.h>
+
+#include <uf/spec/context/context.h>
+#include <cmath>
+#include <set>
+
+namespace {
+	// This per-thread variable holds the current context for each thread
+	// sf::ThreadLocalPtr<spec::Context> currentContext(NULL);
+	spec::uni::Context* currentContext = NULL;
+
+	// The hidden, inactive context that will be shared with all other contexts
+	spec::uni::Context* sharedContext = NULL;
+
+	// Internal contexts
+	// sf::ThreadLocalPtr<spec::Context> internalContext(NULL);
+	spec::uni::Context* internalContext = NULL;
+	std::set<spec::uni::Context*> internalContexts;
+	// sf::Mutex internalContextsMutex;
+
+	// Check if the internal context of the current thread is valid
+	bool hasInternalContext() {
+		// The internal context can be null...
+		if (!internalContext) return false;
+		// ... or non-null but deleted from the list of internal contexts
+	//	sf::Lock lock(internalContextsMutex);
+		return internalContexts.find(internalContext) != internalContexts.end();
+	}
+
+	// Retrieve the internal context for the current thread
+	spec::uni::Context* getInternalContext() {
+		if (!hasInternalContext()) {
+			internalContext = spec::uni::Context::create();
+		//	sf::Lock lock(internalContextsMutex);
+			internalContexts.insert(internalContext);
+		}
+
+		return internalContext;
+	}
+}
+//
+bool UF_API_CALL spec::uni::Context::setActive(bool active) {
+	if (active) {
+		if (this != currentContext) {
+			// Activate the context
+			if (this->makeCurrent()) {
+				// Set it as the new current context for this thread
+				currentContext = this;
+				return true;
+			}
+			return false;
+		}
+		return true; // This context is already the active one on this thread, don't do anything
+	}
+	
+	if (this == currentContext) {
+		// To deactivate the context, we actually activate another one so that we make
+		// sure that there is always an active context for subsequent graphics operations
+		return getInternalContext()->setActive(true);
+	}
+	return true; // This context is not the active one on this thread, don't do anything
+}
+//
+void UF_API_CALL spec::uni::Context::initialize() {
+	// Activate the context
+	this->setActive(true);
+}
+void UF_API_CALL spec::uni::Context::globalInit() {
+	// Create the shared context
+	sharedContext = new spec::Context(NULL);
+	sharedContext->initialize();
+
+	// This call makes sure that:
+	// - the shared context is inactive (it must never be)
+	// - another valid context is activated in the current thread
+	sharedContext->setActive(false);
+}
+void UF_API_CALL spec::uni::Context::globalCleanup() {
+	// Destroy the shared context
+	delete sharedContext;
+	sharedContext = NULL;
+
+	// Destroy the internal contexts
+	// sf::Lock lock(internalContextsMutex);
+	for (std::set<spec::uni::Context*>::iterator it = internalContexts.begin(); it != internalContexts.end(); ++it) delete *it;
+	internalContexts.clear();
+}
+void UF_API_CALL spec::uni::Context::ensureContext() {
+	// If there's no active context on the current thread, activate an internal one
+	if (!currentContext) getInternalContext()->setActive(true);
+}
+spec::uni::Context* UF_API_CALL spec::uni::Context::create() {
+	spec::uni::Context* context = new spec::Context(sharedContext);
+	context->initialize();
+
+	return context;
+}
+spec::uni::Context* UF_API_CALL spec::uni::Context::create(const spec::uni::Context::Settings& settings, const Context::window_t& owner) {
+	// Make sure that there's an active context (context creation may need extensions, and thus a valid context)
+	Context::ensureContext();
+	// Create the context
+	spec::uni::Context* context = new spec::Context(sharedContext, settings, owner);
+	context->initialize();
+	return context;
+}
+spec::uni::Context* UF_API_CALL spec::uni::Context::create(const spec::uni::Context::Settings& settings, unsigned int width, unsigned int height) {
+	// Make sure that there's an active context (context creation may need extensions, and thus a valid context)
+	Context::ensureContext();
+	// Create the context
+	spec::uni::Context* context = new spec::Context(sharedContext, settings, width, height);
+	context->initialize();
+	return context;
+}
+//
+
+//
+UF_API_CALL spec::uni::Context::Context() :
+	m_window 		(NULL),
+	m_ownsWindow 	(false)
+{
+
+}
+UF_API_CALL spec::uni::Context::Context( Context::window_t::handle_t window, bool ownsWindow, const spec::uni::Context::Settings& settings ) :
+	m_window 		(window),
+	m_ownsWindow 	(ownsWindow),
+	m_settings 		(settings)
+{
+
+}
+spec::uni::Context::~Context() {
+	if ( sharedContext ) this->setActive(false);
+//	this->terminate();
+}
+
+int UF_API_CALL spec::uni::Context::evaluateFormat( const spec::uni::Context::Settings& settings, int colorBits, int depthBits, int stencilBits, int antialiasing ) {
+	return std::abs(int(settings.bitsPerPixel	  - colorBits))   +
+		   std::abs(int(settings.depthBits		 - depthBits))   +
+		   std::abs(int(settings.stencilBits	   - stencilBits)) +
+		   std::abs(int(settings.antialiasingLevel - antialiasing));
+}
\ No newline at end of file
diff --git a/engine/src/spec/context/windows.cpp b/engine/src/spec/context/windows.cpp
new file mode 100644
index 00000000..7a77fea6
--- /dev/null
+++ b/engine/src/spec/context/windows.cpp
@@ -0,0 +1,248 @@
+#include <uf/spec/context/context.h>
+
+#include <uf/utils/io/iostream.h>
+
+#if UF_ENV_WINDOWS && !UF_USE_SFML
+UF_API_CALL spec::win32::Context::Context( uni::Context* shared, const Context::Settings& settings ) : 
+	uni::Context( NULL, true, settings ),
+	m_deviceContext 	(NULL),
+	m_context 			(NULL)
+{
+	// Creating a dummy window is mandatory: we could create a memory DC but then
+	// its pixel format wouldn't match the regular contexts' format, and thus
+	// wglShareLists would always fail. Too bad...
+#if UF_USE_OPENGL
+	// Create a dummy window (disabled and hidden)
+	this->m_window = CreateWindowA("STATIC", "", WS_POPUP | WS_DISABLED, 0, 0, 1, 1, NULL, NULL, GetModuleHandle(NULL), NULL);
+	ShowWindow(this->m_window, SW_HIDE);
+	this->m_deviceContext = GetDC(this->m_window);
+
+	if ( this->m_deviceContext ) this->create(shared);
+#endif
+}
+UF_API_CALL spec::win32::Context::Context( uni::Context* shared, const Context::Settings& settings, const Context::window_t& window ) :
+	uni::Context( NULL, false, settings ),
+	m_deviceContext 	(NULL),
+	m_context 			(NULL)
+{
+#if UF_USE_OPENGL
+	// Get the owner window and its device context
+	this->m_window = window.getHandle();
+	this->m_deviceContext = GetDC(this->m_window);
+
+	// Create the context
+	if ( this->m_deviceContext )
+		this->create(shared);
+#endif
+}
+UF_API_CALL spec::win32::Context::Context( uni::Context* shared, const Context::Settings& settings, unsigned int width, unsigned int height ) : Context( shared, settings ) {
+	
+}
+spec::win32::Context::~Context() {
+	this->terminate();
+}
+
+void UF_API_CALL spec::win32::Context::create( uni::Context* shared ) {
+#if UF_USE_OPENGL
+//	this->m_settings = settings;
+	Context::Settings glSettings{24, 4, 8, 0, 3, 3};
+
+	int bestFormat = 0;
+	if ( glSettings.antialiasingLevel > 0 ) {
+		// Get the wglChoosePixelFormatARB function (it is an extension)
+		PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB = reinterpret_cast<PFNWGLCHOOSEPIXELFORMATARBPROC>(wglGetProcAddress("wglChoosePixelFormatARB"));
+		if ( wglChoosePixelFormatARB ) {
+			// Define the basic attributes we want for our window
+			int attributes_ints[] = {
+					WGL_DRAW_TO_WINDOW_ARB, 	GL_TRUE,
+					WGL_SUPPORT_OPENGL_ARB, 	GL_TRUE,
+					WGL_ACCELERATION_ARB, 		WGL_FULL_ACCELERATION_ARB,
+					WGL_DOUBLE_BUFFER_ARB, 		GL_TRUE,
+					WGL_SAMPLE_BUFFERS_ARB, 	(glSettings.antialiasingLevel ? GL_TRUE : GL_FALSE),
+					WGL_SAMPLES_ARB, 			(int) glSettings.antialiasingLevel,
+					0, 							0
+				};
+			float attributes_floats[] = {
+				0, 							0
+			};
+			// Let's check how many formats are supporting our requirements
+			int formats[128];
+			UINT nbFormats;
+			bool isValid = false;
+			// 	Decrease AA level until a valid one is found
+			do {
+				attributes_ints[11] = glSettings.antialiasingLevel;
+				isValid = wglChoosePixelFormatARB(
+					this->m_deviceContext,
+					attributes_ints,
+					attributes_floats,
+					sizeof(formats) / sizeof(*formats),
+					formats,
+					&nbFormats
+				);
+			} while ( (!isValid || nbFormats == 0) && glSettings.antialiasingLevel-- > 0 );
+			// Get the best format among the returned ones
+			if ( isValid && nbFormats > 0 ) {
+				int bestScore = 0xFFFF;
+				for ( UINT i = 0; i < nbFormats; ++i ) {
+					// Get the current format's attributes
+					PIXELFORMATDESCRIPTOR attributes;
+					attributes.nSize	= sizeof(attributes);
+					attributes.nVersion = 1;
+					DescribePixelFormat(this->m_deviceContext, formats[i], sizeof(attributes), &attributes);
+
+					// Evaluate the current configuration
+					int score = this->evaluateFormat(
+						glSettings,
+						attributes.cRedBits + attributes.cGreenBits + attributes.cBlueBits + attributes.cAlphaBits,
+						attributes.cDepthBits,
+						attributes.cStencilBits,
+						glSettings.antialiasingLevel
+					);
+
+					// Keep it if it's better than the current best
+					if (score < bestScore) {
+						bestScore  = score;
+						bestFormat = formats[i];
+					}
+				}
+			}
+		} else {
+		// wglChoosePixelFormatARB not supported ; disabling antialiasing
+			uf::iostream << "[" << uf::IoStream::Color()("Red") << "ERROR" << "]" << "Antialiasing is not supported ; it will be disabled" << "\n";
+			uf::iostream << "[" << uf::IoStream::Color()("Red") << "ERROR" << "]" << "Antialiasing is not supported ; it will be disabled" << "\n";
+			glSettings.antialiasingLevel = 0;
+		}
+	}
+
+	// Find a pixel format with no antialiasing, if not needed or not supported
+	if (bestFormat == 0) {
+		// Setup a pixel format descriptor from the rendering settings
+		PIXELFORMATDESCRIPTOR descriptor;
+		ZeroMemory(&descriptor,   sizeof(descriptor));
+		descriptor.nSize		= sizeof(descriptor);
+		descriptor.nVersion	 	= 1;
+		descriptor.iLayerType   = PFD_MAIN_PLANE;
+		descriptor.dwFlags	  	= PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
+		descriptor.iPixelType   = PFD_TYPE_RGBA;
+		descriptor.cColorBits   = (BYTE) glSettings.bitsPerPixel;
+		descriptor.cDepthBits   = (BYTE) glSettings.depthBits;
+		descriptor.cStencilBits = (BYTE) glSettings.stencilBits;
+		descriptor.cAlphaBits   = glSettings.bitsPerPixel == 32 ? 8 : 0;
+
+		// Get the pixel format that best matches our requirements
+		bestFormat = ChoosePixelFormat(this->m_deviceContext, &descriptor);
+		if (bestFormat == 0) {
+			uf::iostream << "[" << uf::IoStream::Color()("Red") << "ERROR" << "]" << "Failed to find a suitable pixel format for device context -- cannot create OpenGL context" << "\n";
+			return;
+		}
+	}
+
+	// Extract the depth and stencil bits from the chosen format
+	PIXELFORMATDESCRIPTOR actualFormat;
+	actualFormat.nSize		= sizeof(actualFormat);
+	actualFormat.nVersion 	= 1;
+	DescribePixelFormat(this->m_deviceContext, bestFormat, sizeof(actualFormat), &actualFormat);
+	glSettings.depthBits   	= actualFormat.cDepthBits;
+	glSettings.stencilBits 	= actualFormat.cStencilBits;
+
+	// Set the chosen pixel format
+	if (!SetPixelFormat(this->m_deviceContext, bestFormat, &actualFormat)) {
+		uf::iostream << "[" << uf::IoStream::Color()("Red") << "ERROR" << "]" << "Failed to set pixel format for device context -- cannot create OpenGL context" << "\n";
+		return;
+	}
+
+	// Get the context to share display lists with
+	HGLRC sharedContext = shared ? ((win32::Context*) shared)->m_context : NULL;
+
+	// Create the OpenGL context -- first try context versions >= 3.0 if it is requested (they require special code)
+	while (!this->m_context && (glSettings.majorVersion >= 3)) {
+		PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAttribsARB = reinterpret_cast<PFNWGLCREATECONTEXTATTRIBSARBPROC>(wglGetProcAddress("wglCreateContextAttribsARB"));
+		if (wglCreateContextAttribsARB) {
+			int attributes[] = {
+				WGL_CONTEXT_MAJOR_VERSION_ARB,  (int) glSettings.majorVersion,
+				WGL_CONTEXT_MINOR_VERSION_ARB,  (int) glSettings.minorVersion,
+				WGL_CONTEXT_PROFILE_MASK_ARB, 	WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB,
+				0, 								0
+			};
+			this->m_context = wglCreateContextAttribsARB(this->m_deviceContext, sharedContext, attributes);
+		}
+
+		// If we couldn't create the context, lower the version number and try again -- stop at 3.0
+		// Invalid version numbers will be generated by this algorithm (like 3.9), but we really don't care
+		if (!this->m_context) {
+			if (glSettings.minorVersion > 0) {
+				// If the minor version is not 0, we decrease it and try again
+				glSettings.minorVersion--;
+			}
+			else {
+				// If the minor version is 0, we decrease the major version
+				glSettings.majorVersion--;
+				glSettings.minorVersion = 9;
+			}
+		}
+	}
+
+	// If the OpenGL >= 3.0 context failed or if we don't want one, create a regular OpenGL 1.x/2.x context
+	if (!this->m_context) {
+		// set the context version to 2.0 (arbitrary)
+		glSettings.majorVersion = 2;
+		glSettings.minorVersion = 0;
+
+		this->m_context = wglCreateContext(this->m_deviceContext);
+		if (!this->m_context) {
+			uf::iostream << "[" << uf::IoStream::Color()("Red") << "ERROR" << "]" << "Failed to create an OpenGL context for this window" << "\n";
+			return;
+		}
+
+		// Share this context with others
+		if (sharedContext) {
+		// 	wglShareLists doesn't seem to be thread-safe
+		//	static Mutex mutex;
+		//	Lock lock(mutex);
+
+			if (!wglShareLists(sharedContext, this->m_context)) {
+				uf::iostream << "[" << uf::IoStream::Color()("Red") << "ERROR" << "]" << "Failed to share the OpenGL context" << "\n";
+			}
+		}
+	}
+#endif
+}
+void UF_API_CALL spec::win32::Context::terminate() {
+#if UF_USE_OPENGL
+	// Destroy the OpenGL context
+	if ( this->m_context ) {
+		if ( wglGetCurrentContext() == this->m_context) wglMakeCurrent(NULL, NULL);
+		wglDeleteContext(this->m_context);
+	}
+
+	// Destroy the device context
+	if ( this->m_deviceContext ) ReleaseDC(this->m_window, this->m_deviceContext);
+
+	// Destroy the window if we own it
+	if ( this->m_window && this->m_ownsWindow ) DestroyWindow(this->m_window);
+#endif
+}
+
+bool spec::win32::Context::makeCurrent() {
+#if UF_USE_OPENGL
+	return this->m_deviceContext && this->m_context && wglMakeCurrent(this->m_deviceContext, this->m_context);
+#else
+	return true;
+#endif
+}
+
+void spec::win32::Context::display() {
+#if UF_USE_OPENGL
+	if (this->m_deviceContext && this->m_context)
+		SwapBuffers(this->m_deviceContext);
+#endif
+}
+
+void spec::win32::Context::setVerticalSyncEnabled(bool enabled) {
+#if UF_USE_OPENGL
+	PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT = reinterpret_cast<PFNWGLSWAPINTERVALEXTPROC>(wglGetProcAddress("wglSwapIntervalEXT"));
+	if (wglSwapIntervalEXT) wglSwapIntervalEXT(enabled ? 1 : 0);
+#endif
+}
+#endif
\ No newline at end of file
diff --git a/engine/src/spec/terminal/dreamcast.cpp b/engine/src/spec/terminal/dreamcast.cpp
new file mode 100644
index 00000000..321a444a
--- /dev/null
+++ b/engine/src/spec/terminal/dreamcast.cpp
@@ -0,0 +1,17 @@
+#include <uf/spec/terminal/terminal.h>
+
+#ifdef UF_ENV_DREAMCAST
+
+void UF_API_CALL spec::Terminal::clear() {
+	spec::uni::Terminal::clear();
+}
+void UF_API_CALL spec::Terminal::setLocale() {
+	spec::uni::Terminal::setLocale();
+}
+
+void UF_API_CALL spec::Terminal::hide() {
+}
+void UF_API_CALL spec::Terminal::show() {
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/src/spec/terminal/universal.cpp b/engine/src/spec/terminal/universal.cpp
new file mode 100644
index 00000000..02d65d3c
--- /dev/null
+++ b/engine/src/spec/terminal/universal.cpp
@@ -0,0 +1,39 @@
+#include <uf/spec/terminal/terminal.h>
+#include <uf/utils/io/iostream.h>
+#include <uf/utils/string/locale.h>
+
+#include <locale>
+#include <clocale>
+
+
+spec::Terminal spec::terminal;
+spec::uni::Terminal& UF_API_CALL spec::Terminal::getUniversal() {
+	return (spec::uni::Terminal&) *this;
+}
+
+void UF_API_CALL spec::uni::Terminal::clear() {
+}
+void UF_API_CALL spec::uni::Terminal::hide() {
+}
+void UF_API_CALL spec::uni::Terminal::show() {
+}
+void UF_API_CALL spec::uni::Terminal::setLocale() {
+#if UF_ENV_DREAMCAST
+#else
+	const char* locales[4] = {
+		"", "C.utf8", "C", "POSIX"
+	};
+	for ( unsigned int i = 0; i < 4; ++i ) {	
+		const char*& name = locales[i];
+		try {	
+			std::setlocale(LC_ALL, name);
+			std::locale::global(std::locale(name));
+			uf::locale::current = name;
+			break;
+		} catch ( ... ) {
+			std::cout << "Attempted to set invalid locale: " << name << std::endl;
+			continue;
+		}
+	}
+#endif
+}
\ No newline at end of file
diff --git a/engine/src/spec/terminal/unknown.cpp b/engine/src/spec/terminal/unknown.cpp
new file mode 100644
index 00000000..3586ab11
--- /dev/null
+++ b/engine/src/spec/terminal/unknown.cpp
@@ -0,0 +1,12 @@
+#include <uf/spec/terminal/terminal.h>
+
+#if UF_ENV_UNKNOWN
+
+void UF_API_CALL spec::Terminal::clear() {
+	spec::uni::Terminal::clear();
+}
+void UF_API_CALL spec::Terminal::setLocale() {
+	spec::uni::Terminal::setLocale();
+}
+
+#endif
\ No newline at end of file
diff --git a/engine/src/spec/terminal/windows.cpp b/engine/src/spec/terminal/windows.cpp
new file mode 100644
index 00000000..f6103613
--- /dev/null
+++ b/engine/src/spec/terminal/windows.cpp
@@ -0,0 +1,38 @@
+#include <uf/spec/terminal/terminal.h>
+
+#ifdef UF_ENV_WINDOWS
+
+void UF_API_CALL spec::Terminal::clear() {
+	spec::uni::Terminal::clear();
+
+	COORD topLeft  = { 0, 0 };
+	HANDLE console = GetStdHandle(STD_OUTPUT_HANDLE);
+	CONSOLE_SCREEN_BUFFER_INFO screen;
+	DWORD written;
+
+	GetConsoleScreenBufferInfo(console, &screen);
+	FillConsoleOutputCharacterA(
+		console, ' ', screen.dwSize.X * screen.dwSize.Y, topLeft, &written
+	);
+	FillConsoleOutputAttribute(
+		console, FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE,
+		screen.dwSize.X * screen.dwSize.Y, topLeft, &written
+	);
+	SetConsoleCursorPosition(console, topLeft);
+}
+void UF_API_CALL spec::Terminal::setLocale() {
+	spec::uni::Terminal::setLocale();
+
+	SetConsoleOutputCP(CP_UTF8);
+}
+
+void UF_API_CALL spec::Terminal::hide() {
+	ShowWindow( GetConsoleWindow(), SW_HIDE);
+}
+void UF_API_CALL spec::Terminal::show() {
+	ShowWindow( GetConsoleWindow(), SW_RESTORE);
+}
+
+
+
+#endif
\ No newline at end of file
diff --git a/engine/src/spec/time/dreamcast.cpp b/engine/src/spec/time/dreamcast.cpp
new file mode 100644
index 00000000..593bc5d8
--- /dev/null
+++ b/engine/src/spec/time/dreamcast.cpp
@@ -0,0 +1,14 @@
+#include <uf/spec/time/time.h>
+#ifdef UF_ENV_DREAMCAST
+#include <arch/timer.h>
+
+spec::uni::Time::time_t UF_API_CALL spec::dreamcast::Time::getTime() {
+	return timer_us_gettime64();
+}
+spec::uni::Time& UF_API_CALL spec::dreamcast::Time::getUniversal() {
+	return (spec::uni::Time&) *this;
+}
+
+spec::dreamcast::Time spec::time;
+spec::dreamcast::Time::exp_t spec::dreamcast::Time::unit = -6;
+#endif
\ No newline at end of file
diff --git a/engine/src/spec/time/universal.cpp b/engine/src/spec/time/universal.cpp
new file mode 100644
index 00000000..887f0b81
--- /dev/null
+++ b/engine/src/spec/time/universal.cpp
@@ -0,0 +1,18 @@
+#include <uf/spec/time/time.h>
+
+#include <chrono>
+
+spec::uni::Time::exp_t spec::uni::Time::unit = -6;
+
+namespace {
+	typedef std::chrono::time_point<std::chrono::system_clock> chrono_time_t;
+	chrono_time_t getTimePoint() {
+		return std::chrono::system_clock::now();
+	}
+	chrono_time_t start = getTimePoint();
+}
+
+spec::uni::Time::time_t UF_API_CALL spec::uni::Time::getTime() {
+	std::chrono::duration<double> elapsed = getTimePoint() - start;
+	return elapsed.count() * 1000000;
+}
\ No newline at end of file
diff --git a/engine/src/spec/time/unknown.cpp b/engine/src/spec/time/unknown.cpp
new file mode 100644
index 00000000..d624a451
--- /dev/null
+++ b/engine/src/spec/time/unknown.cpp
@@ -0,0 +1,9 @@
+#include <uf/spec/time/time.h>
+
+#ifdef UF_ENV_UNKNOWN
+/*
+spec::uni::Time::time_t UF_API_CALL spec::Time::getTime() {
+	return spec::uni::Time::getTime();
+}
+*/
+#endif
\ No newline at end of file
diff --git a/engine/src/spec/time/windows.cpp b/engine/src/spec/time/windows.cpp
new file mode 100644
index 00000000..54d48ae1
--- /dev/null
+++ b/engine/src/spec/time/windows.cpp
@@ -0,0 +1,30 @@
+#include <uf/spec/time/time.h>
+
+#ifdef UF_ENV_WINDOWS
+
+namespace {
+	LARGE_INTEGER getFrequency() {
+		LARGE_INTEGER freq;
+		QueryPerformanceFrequency(&freq);
+		return freq;
+	}
+}
+
+
+spec::uni::Time::time_t UF_API_CALL spec::win32::Time::getTime() {
+	HANDLE curThread = GetCurrentThread();
+	DWORD_PTR prevMask = SetThreadAffinityMask(curThread, 1);
+	static LARGE_INTEGER freq = getFrequency();
+	LARGE_INTEGER time;
+	QueryPerformanceCounter(&time);
+	SetThreadAffinityMask(curThread, prevMask);
+
+	return 1000000 * time.QuadPart / freq.QuadPart;
+}
+spec::uni::Time& UF_API_CALL spec::win32::Time::getUniversal() {
+	return (spec::uni::Time&) *this;
+}
+
+spec::win32::Time spec::time;
+spec::win32::Time::exp_t spec::win32::Time::unit = -6;
+#endif
\ No newline at end of file
diff --git a/engine/src/spec/window/dreamcast.cpp b/engine/src/spec/window/dreamcast.cpp
new file mode 100644
index 00000000..33424848
--- /dev/null
+++ b/engine/src/spec/window/dreamcast.cpp
@@ -0,0 +1,229 @@
+#include <uf/spec/window/window.h>
+#include <uf/utils/io/iostream.h>
+#include <uf/utils/string/utf.h>
+
+#if UF_ENV_DREAMCAST
+
+/*
+
+INIT_NONE        	-- don't do any auto init
+INIT_IRQ     		-- Enable IRQs
+INIT_THD_PREEMPT 	-- Enable pre-emptive threading
+INIT_NET     		-- Enable networking (including sockets)
+INIT_MALLOCSTATS 	-- Enable a call to malloc_stats() right before shutdown
+
+*/
+
+extern uint8 romdisk[];
+KOS_INIT_FLAGS(INIT_DEFAULT | INIT_MALLOCSTATS);
+KOS_INIT_ROMDISK(romdisk);
+
+namespace {
+	struct {
+		maple_device_t* device = NULL;
+		cont_state_t* state = NULL;
+	} controller, keyboard;
+}
+
+UF_API_CALL spec::dreamcast::Window::Window() : 
+	m_handle 			(NULL),
+//	m_callback			(0),
+//	m_cursor			(NULL),
+//	m_icon				(NULL),
+	m_lastSize			({}),
+	m_keyRepeatEnabled	(true),
+	m_resizing			(false),
+	m_mouseInside		(false),
+	m_mouseGrabbed		(false),
+	m_syncParse			(true),
+	m_asyncParse		(false)
+{
+}
+UF_API_CALL spec::dreamcast::Window::Window( spec::dreamcast::Window::handle_t handle ) :
+	m_handle 			(handle),
+//	m_callback			(0),
+//	m_cursor			(NULL),
+//	m_icon				(NULL),
+	m_lastSize			({}),
+	m_keyRepeatEnabled	(true),
+	m_resizing			(false),
+	m_mouseInside		(false),
+	m_mouseGrabbed		(false),
+	m_syncParse			(true),
+	m_asyncParse		(false)
+{
+
+}
+UF_API_CALL spec::dreamcast::Window::Window( const spec::dreamcast::Window::vector_t& size, const spec::dreamcast::Window::title_t& title ) : 
+	m_handle 			(NULL),
+//	m_callback			(0),
+//	m_cursor			(NULL),
+//	m_icon				(NULL),
+	m_keyRepeatEnabled	(true),
+	m_resizing			(false),
+	m_mouseInside		(false),
+	m_mouseGrabbed		(false),
+	m_syncParse			(true),
+	m_asyncParse		(false)
+{
+	this->create(size, title);
+}
+void UF_API_CALL spec::dreamcast::Window::create( const spec::dreamcast::Window::vector_t& _size, const spec::dreamcast::Window::title_t& title ) {
+	//dbglog_set_level(DBG_WARNING);
+	::controller.device = maple_enum_type(0, MAPLE_FUNC_CONTROLLER);
+	::keyboard.device = maple_enum_type(0, MAPLE_FUNC_KEYBOARD);
+}
+
+spec::dreamcast::Window::~Window() {
+}
+void UF_API_CALL spec::dreamcast::Window::terminate() {
+}
+
+spec::dreamcast::Window::handle_t UF_API_CALL spec::dreamcast::Window::getHandle() const {
+	return this->m_handle;
+}
+spec::dreamcast::Window::vector_t UF_API_CALL spec::dreamcast::Window::getPosition() const {
+	return { 0, 0 };
+}
+spec::dreamcast::Window::vector_t UF_API_CALL spec::dreamcast::Window::getSize() const {
+	return { 640, 480 };
+}
+size_t UF_API_CALL spec::dreamcast::Window::getRefreshRate() const {
+	return 60;
+}
+
+void UF_API_CALL spec::dreamcast::Window::centerWindow() {
+}
+void UF_API_CALL spec::dreamcast::Window::setPosition( const spec::dreamcast::Window::vector_t& position ) {
+}
+void UF_API_CALL spec::dreamcast::Window::setMousePosition( const spec::dreamcast::Window::vector_t& position ) {
+}
+spec::dreamcast::Window::vector_t UF_API_CALL spec::dreamcast::Window::getMousePosition( ) {
+	return { 320, 240 };
+}
+void UF_API_CALL spec::dreamcast::Window::setSize( const spec::dreamcast::Window::vector_t& size ) {
+}
+
+void UF_API_CALL spec::dreamcast::Window::setTitle( const spec::dreamcast::Window::title_t& title ) {
+}
+void UF_API_CALL spec::dreamcast::Window::setIcon( const spec::dreamcast::Window::vector_t& size, uint8_t* pixels ) {
+}
+void UF_API_CALL spec::dreamcast::Window::setVisible( bool visibility ) {
+}
+void UF_API_CALL spec::dreamcast::Window::setCursorVisible( bool visibility ) {
+}
+void UF_API_CALL spec::dreamcast::Window::setKeyRepeatEnabled( bool state ) {
+	this->m_keyRepeatEnabled = state;
+}
+
+void UF_API_CALL spec::dreamcast::Window::requestFocus() {
+}
+bool UF_API_CALL spec::dreamcast::Window::hasFocus() const {
+	return true;
+}
+
+
+#include <uf/utils/serialize/serializer.h>
+void UF_API_CALL spec::dreamcast::Window::processEvents() {
+	if ( !::controller.device ) ::controller.device = maple_enum_type(0, MAPLE_FUNC_CONTROLLER);
+	if ( !::keyboard.device ) ::keyboard.device = maple_enum_type(0, MAPLE_FUNC_KEYBOARD);
+
+	if ( ::controller.device ) ::controller.state = (cont_state_t*) maple_dev_status(::controller.device);
+	if ( ::keyboard.device ) ::keyboard.state = (cont_state_t*) maple_dev_status(::keyboard.device);
+
+	if ( ::controller.state ) {
+		if ( ::controller.state->buttons & CONT_START ) {
+
+		}
+	}
+}
+bool UF_API_CALL spec::dreamcast::Window::pollEvents( bool block ) {
+	if ( this->m_events.empty() ) {
+		do {
+			this->processEvents();
+		} while ( block && this->m_events.empty() );
+	}
+
+	while ( !this->m_events.empty() ) {
+		auto& event = this->m_events.front();
+		if ( event.payload.is<std::string>() ) {
+			ext::json::Value payload = uf::Serializer( event.payload.as<std::string>() );
+		//	std::cout << event.name << " (string)\t" << payload << std::endl;
+			uf::hooks.call( "window:Event", payload );
+			uf::hooks.call( event.name, payload );
+		} else if ( event.payload.is<uf::Serializer>() ) {
+			uf::Serializer& payload = event.payload.as<uf::Serializer>();
+		//	std::cout << event.name << " (serializer)\t" << payload << std::endl;
+			uf::hooks.call( "window:Event", payload );
+			uf::hooks.call( event.name, payload );
+		} else if ( event.payload.is<ext::json::Value>() ) {
+			ext::json::Value& payload = event.payload.as<ext::json::Value>();
+		//	std::cout << event.name << " (json)\t" << payload << std::endl;
+			uf::hooks.call( "window:Event", payload );
+			uf::hooks.call( event.name, payload );
+		} else {
+		//	std::cout << event.name << "(???)" << std::endl;		
+			uf::hooks.call( "window:Event", event.payload );
+			uf::hooks.call( event.name, event.payload );
+		}
+	/*
+		try {
+			uf::hooks.call( "window:Event", payload );
+			uf::hooks.call( event.name, payload );
+		} catch ( ... ) {
+			// Let the hook handler handle the exceptions
+		}
+	*/
+		this->m_events.pop();
+	}
+	return true;
+}
+
+void UF_API_CALL spec::dreamcast::Window::registerWindowClass() {
+}
+void UF_API_CALL spec::dreamcast::Window::processEvent(/*UINT message, WPARAM wParam, LPARAM lParam*/) {
+}
+
+void UF_API_CALL spec::dreamcast::Window::setTracking(bool state) {
+}
+void UF_API_CALL spec::dreamcast::Window::setMouseGrabbed(bool state) {
+	this->m_mouseGrabbed = state;
+	this->grabMouse(state);
+}
+void UF_API_CALL spec::dreamcast::Window::grabMouse(bool state) {
+}
+pod::Vector2ui UF_API_CALL spec::dreamcast::Window::getResolution() {
+	return { 640, 480 };
+}
+void UF_API_CALL spec::dreamcast::Window::switchToFullscreen( bool borderless ) {
+}
+
+bool UF_API_CALL spec::dreamcast::Window::isKeyPressed(const std::string& key) {
+	if ( !::controller.state ) return false;
+
+	if ( (key == "Up") && (::controller.state->buttons & CONT_DPAD_UP) ) return true;
+	if ( (key == "Down") && (::controller.state->buttons & CONT_DPAD_DOWN) ) return true;
+	if ( (key == "Left") && (::controller.state->buttons & CONT_DPAD_LEFT) ) return true;
+	if ( (key == "Right") && (::controller.state->buttons & CONT_DPAD_RIGHT) ) return true;
+
+	if ( (key == "Up2") && (::controller.state->buttons & CONT_DPAD2_UP) ) return true;
+	if ( (key == "Down2") && (::controller.state->buttons & CONT_DPAD2_DOWN) ) return true;
+	if ( (key == "Left2") && (::controller.state->buttons & CONT_DPAD2_LEFT) ) return true;
+	if ( (key == "Right2") && (::controller.state->buttons & CONT_DPAD2_RIGHT) ) return true;
+
+	if ( (key == "Start") && (::controller.state->buttons & CONT_START) ) return true;
+
+	if ( (key == "A") && (::controller.state->buttons & CONT_A) ) return true;
+	if ( (key == "B") && (::controller.state->buttons & CONT_B) ) return true;
+	if ( (key == "C") && (::controller.state->buttons & CONT_C) ) return true;
+	if ( (key == "D") && (::controller.state->buttons & CONT_D) ) return true;
+	if ( (key == "X") && (::controller.state->buttons & CONT_X) ) return true;
+	if ( (key == "Y") && (::controller.state->buttons & CONT_Y) ) return true;
+	if ( (key == "Z") && (::controller.state->buttons & CONT_Z) ) return true;
+
+	return false;
+}
+std::string UF_API_CALL spec::dreamcast::Window::getKey(/*WPARAM key, LPARAM flags*/) {
+	return "";
+}
+#endif
\ No newline at end of file
diff --git a/engine/src/spec/window/universal.cpp b/engine/src/spec/window/universal.cpp
new file mode 100644
index 00000000..777a39e1
--- /dev/null
+++ b/engine/src/spec/window/universal.cpp
@@ -0,0 +1,148 @@
+#include <uf/spec/window/window.h>
+#include <uf/utils/hook/hook.h>
+#include <uf/utils/io/iostream.h>
+
+#include <uf/utils/serialize/serializer.h>
+#include <sstream>
+/*
+void UF_API_CALL spec::uni::Window::pushEvent( const uf::ReadableHook::name_t& name, const uf::ReadableHook::argument_t& argument ) {
+	if ( !uf::hooks.prefersReadable() ) return;
+	if ( !uf::hooks.exists(name) ) return;
+	this->m_events.readable.push({name, argument});
+}
+void UF_API_CALL spec::uni::Window::pushEvent( const uf::OptimalHook::name_t& name, const uf::OptimalHook::argument_t& argument ) {
+	if ( uf::hooks.prefersReadable() ) {
+		uf::userdata::destroy(argument);
+		return;
+	}
+	if ( !uf::hooks.exists(name) ) {
+		uf::userdata::destroy(argument);
+		return;
+	}
+	this->m_events.optimal.push({name});
+	this->m_events.optimal.back().argument = argument;
+}
+void UF_API_CALL spec::uni::Window::pushEvent( const uf::ReadableHook::argument_t& serialized ) {
+	if ( !uf::hooks.prefersReadable() ) return;
+	uf::Serializer json = serialized;
+	if ( !uf::hooks.exists(json["type"].as<std::string>()) ) return;
+	this->m_events.readable.push({json["type"].as<std::string>(), serialized});
+}
+void UF_API_CALL spec::uni::Window::pushEvent( const uf::OptimalHook::argument_t& userdata ) {
+	if ( uf::hooks.prefersReadable() ) return;
+	// Header userdata
+	struct Header {
+		std::string type;
+	};
+//	Header header = userdata.get<Header>();
+	const Header& header = uf::userdata::get<Header>(userdata);
+	this->m_events.optimal.push({header.type});
+	if ( !uf::hooks.exists(header.type) ) {
+		uf::userdata::destroy(userdata);
+		return;
+	}
+	this->m_events.optimal.back().argument = userdata;
+}
+*/
+void UF_API_CALL spec::uni::Window::pushEvent( const uf::Hooks::name_t& name, const std::string& payload ) {
+	auto& event = this->m_events.emplace();
+	event.name = name;
+	event.payload.create<ext::json::Value>( uf::Serializer(payload) );
+}
+void UF_API_CALL spec::uni::Window::pushEvent( const uf::Hooks::name_t& name, const ext::json::Value& payload ) {
+	auto& event = this->m_events.emplace();
+	event.name = name;
+	event.payload.create<ext::json::Value>( uf::Serializer(payload) );
+}
+void UF_API_CALL spec::uni::Window::pushEvent( const uf::Hooks::name_t& name, const uf::Serializer& payload ) {
+	auto& event = this->m_events.emplace();
+	event.name = name;
+	event.payload.create<ext::json::Value>( uf::Serializer(payload) );
+}
+void UF_API_CALL spec::uni::Window::pushEvent( const uf::Hooks::name_t& name, const uf::Hooks::argument_t& payload ) {
+	auto& event = this->m_events.emplace();
+	event.name = name;
+}
+void UF_API_CALL spec::uni::Window::pushEvent( const uf::Hooks::argument_t& payload ) {
+	struct Header {
+		std::string type;
+	};
+	const Header& header = payload.get<Header>();
+	if ( !uf::hooks.exists(header.type) ) return;
+	this->m_events.push({ header.type, std::move(payload) });
+}
+void UF_API_CALL spec::uni::Window::processEvents() {
+}
+bool UF_API_CALL spec::uni::Window::isKeyPressed(const std::string& key) {
+	return false;
+}
+bool UF_API_CALL spec::uni::Window::pollEvents( bool block ) {
+	if ( this->m_events.empty() ) {
+		do {
+			this->processEvents();
+		} while ( block && this->m_events.empty() );
+	}
+	// doesnt get used
+	while ( !this->m_events.empty() ) {
+		auto& event = this->m_events.front();
+		if ( event.payload.is<std::string>() ) {
+			ext::json::Value payload = uf::Serializer( event.payload.as<std::string>() );
+			uf::hooks.call( "window:Event", payload );
+			uf::hooks.call( event.name, payload );
+		} else if ( event.payload.is<uf::Serializer>() ) {
+			uf::Serializer& payload = event.payload.as<uf::Serializer>();
+			uf::hooks.call( "window:Event", payload );
+			uf::hooks.call( event.name, payload );
+		} else if ( event.payload.is<ext::json::Value>() ) {
+			ext::json::Value& payload = event.payload.as<ext::json::Value>();
+			uf::hooks.call( "window:Event", payload );
+			uf::hooks.call( event.name, payload );
+		} else {			
+			uf::hooks.call( "window:Event", event.payload );
+			uf::hooks.call( event.name, event.payload );
+		}
+		this->m_events.pop();
+	}
+	return true;
+#if 0
+	/* Empty; look for something! */ if ( this->m_events.readable.empty() && this->m_events.optimal.empty() ) {
+		do {
+			this->processEvents();
+		} while ( block && this->m_events.readable.empty() && this->m_events.optimal.empty() );
+	}
+
+	if ( uf::hooks.prefersReadable() ) // Should we handle events in a readable format...
+	/* Process events parsed in a readable format */ {
+		// process things
+		while ( !this->m_events.readable.empty() ) {
+			auto& event = this->m_events.readable.front();
+			try {
+				uf::hooks.call( "window:Event", event.argument );
+				uf::hooks.call( event.name, event.argument );
+			//	uf::iostream << event.name << "\t" << event.argument << "\n";
+			} catch ( ... ) {
+				// Let the hook handler handle the exceptions
+			}
+			this->m_events.readable.pop();
+		}
+	//	this->m_events.optimal.clear(); 	// flush queue in case
+	} else // ... or in an optimal format?
+	/* Process events parsed in an optimal format */ {
+		// process things
+		while ( !this->m_events.optimal.empty() ) {
+			auto& event = this->m_events.optimal.front();
+			try {
+				uf::hooks.call( "window:Event", event.argument );
+				uf::hooks.call( event.name, event.argument );
+			//	uf::iostream << event.name << "\t" << event.argument << "\n";
+			} catch ( ... ) {
+				// Let the hook handler handle the exceptions
+			}
+			uf::userdata::destroy(event.argument);
+			this->m_events.optimal.pop();
+		}
+	//	this->m_events.readable.clear(); 	// flush queue in case
+	}
+	return true;
+#endif
+}
\ No newline at end of file
diff --git a/engine/src/spec/window/unknown.cpp b/engine/src/spec/window/unknown.cpp
new file mode 100644
index 00000000..5833b043
--- /dev/null
+++ b/engine/src/spec/window/unknown.cpp
@@ -0,0 +1,12 @@
+#include <uf/spec/window/window.h>
+
+#include <uf/utils/io/iostream.h>
+#include <uf/utils/math/vector.h>
+
+#include <string>
+
+#ifdef UF_ENV_UNKNOWN
+
+
+
+#endif
\ No newline at end of file
diff --git a/engine/src/spec/window/windows.cpp b/engine/src/spec/window/windows.cpp
new file mode 100644
index 00000000..4e8e5fb0
--- /dev/null
+++ b/engine/src/spec/window/windows.cpp
@@ -0,0 +1,1374 @@
+#include <uf/spec/window/window.h>
+#include <uf/utils/io/iostream.h>
+#include <uf/utils/string/utf.h>
+
+#define USE_OPTIMAL 0
+
+#if defined(UF_ENV_WINDOWS) && (!defined(UF_USE_SFML) || (defined(UF_USE_SFML) && UF_USE_SFML == 0))
+namespace {
+	int windowCount 		= 0;
+	std::wstring className 	= L"uf::Window::Class";
+	void* fullscreenWindow 	= NULL;
+	void setProcessDpiAware() {
+		HINSTANCE shCoreDll = LoadLibrary("Shcore.dll");
+		if (shCoreDll) {
+			enum ProcessDpiAwareness {
+				ProcessDpiUnaware		 = 0,
+				ProcessSystemDpiAware	 = 1,
+				ProcessPerMonitorDpiAware = 2
+			};
+
+			typedef HRESULT (WINAPI* SetProcessDpiAwarenessFuncType)(ProcessDpiAwareness);
+			SetProcessDpiAwarenessFuncType SetProcessDpiAwarenessFunc = reinterpret_cast<SetProcessDpiAwarenessFuncType>(GetProcAddress(shCoreDll, "SetProcessDpiAwareness"));
+			if (SetProcessDpiAwarenessFunc) {
+				if (SetProcessDpiAwarenessFunc(ProcessSystemDpiAware) == E_INVALIDARG) {
+					uf::iostream << "Failed to set process DPI awareness" << "\n";
+				} else {
+					FreeLibrary(shCoreDll);
+					return;
+				}
+			}
+			FreeLibrary(shCoreDll);
+		}
+		HINSTANCE user32Dll = LoadLibrary("user32.dll");
+		if (user32Dll) {
+			typedef BOOL (WINAPI* SetProcessDPIAwareFuncType)(void);
+			SetProcessDPIAwareFuncType SetProcessDPIAwareFunc = reinterpret_cast<SetProcessDPIAwareFuncType>(GetProcAddress(user32Dll, "SetProcessDPIAware"));
+			if (SetProcessDPIAwareFunc) {
+				if (!SetProcessDPIAwareFunc())
+					uf::iostream << "Failed to set process DPI awareness" << "\n";
+			}
+			FreeLibrary(user32Dll);
+		}
+	}
+	LRESULT CALLBACK globalOnEvent(spec::win32::Window::handle_t handle, UINT message, WPARAM wParam, LPARAM lParam) {
+		if (message == WM_CREATE) {
+			LONG_PTR window = (LONG_PTR)reinterpret_cast<CREATESTRUCT*>(lParam)->lpCreateParams;
+			SetWindowLongPtrW(handle, GWLP_USERDATA, window);
+		}
+		spec::win32::Window* window = handle ? reinterpret_cast<spec::win32::Window*>(GetWindowLongPtr(handle, GWLP_USERDATA)) : NULL;
+		if (window) {
+			window->processEvent(message, wParam, lParam);
+			if (window->m_callback) return CallWindowProcW(reinterpret_cast<WNDPROC>(window->m_callback), handle, message, wParam, lParam);
+		}
+		if (message == WM_CLOSE) return 0;
+		if ((message == WM_SYSCOMMAND) && (wParam == SC_KEYMENU)) return 0;
+		return DefWindowProcW(handle, message, wParam, lParam);
+	}
+}
+
+UF_API_CALL spec::win32::Window::Window() : 
+	m_handle 			(NULL),
+	m_callback			(0),
+	m_cursor			(NULL),
+	m_icon				(NULL),
+	m_lastSize			({}),
+	m_keyRepeatEnabled	(true),
+	m_resizing			(false),
+	m_mouseInside		(false),
+	m_mouseGrabbed		(false),
+	m_syncParse			(true),
+	m_asyncParse		(false)
+{
+}
+UF_API_CALL spec::win32::Window::Window( spec::win32::Window::handle_t handle ) :
+	m_handle 			(handle),
+	m_callback			(0),
+	m_cursor			(NULL),
+	m_icon				(NULL),
+	m_lastSize			({}),
+	m_keyRepeatEnabled	(true),
+	m_resizing			(false),
+	m_mouseInside		(false),
+	m_mouseGrabbed		(false),
+	m_syncParse			(true),
+	m_asyncParse		(false)
+{
+	if ( handle ) {
+		SetWindowLongPtrW(this->m_handle, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(this));
+		m_callback = SetWindowLongPtrW(this->m_handle, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(&::globalOnEvent));
+	}
+}
+UF_API_CALL spec::win32::Window::Window( const spec::win32::Window::vector_t& size, const spec::win32::Window::title_t& title ) : 
+	m_handle 			(NULL),
+	m_callback			(0),
+	m_cursor			(NULL),
+	m_icon				(NULL),
+	m_keyRepeatEnabled	(true),
+	m_resizing			(false),
+	m_mouseInside		(false),
+	m_mouseGrabbed		(false),
+	m_syncParse			(true),
+	m_asyncParse		(false)
+{
+	this->create(size, title);
+}
+void UF_API_CALL spec::win32::Window::create( const spec::win32::Window::vector_t& _size, const spec::win32::Window::title_t& title ) {
+	setProcessDpiAware();
+	if ( windowCount == 0 ) this->registerWindowClass();
+
+	auto size = _size;
+	if ( size.x <= 0 && size.y <= 0 ) {
+		size.x = GetSystemMetrics(SM_CXSCREEN);
+		size.y = GetSystemMetrics(SM_CYSCREEN);
+	}
+	HDC screenDC = GetDC(NULL);
+	spec::win32::Window::vector_t position;
+	position.x = (uint) ((GetDeviceCaps(screenDC, HORZRES) - size.x ) / 2);
+	position.y = (uint) ((GetDeviceCaps(screenDC, VERTRES) - size.y ) / 2);
+	ReleaseDC(NULL, screenDC);
+
+	DWORD winStyle = WS_VISIBLE | WS_CAPTION | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_THICKFRAME | WS_SYSMENU;
+
+	RECT rectangle = { 0, 0, size.x, size.y };
+	AdjustWindowRect( &rectangle, winStyle, false );
+
+	int width = rectangle.right - rectangle.left;
+	int height = rectangle.bottom - rectangle.top;
+
+	this->m_handle = CreateWindowW(
+		className.c_str(),
+		std::wstring(title).c_str(),
+		winStyle,
+		position.x,
+		position.y,
+		width,
+		height,
+		NULL,
+		NULL,
+		GetModuleHandle(NULL),
+		this
+	);
+
+	this->setSize( size );
+	// m_callback = SetWindowLongPtrW(this->m_handle, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(&::globalOnEvent));
+
+	++windowCount;
+}
+
+spec::win32::Window::~Window() {
+	if ( this->m_icon ) DestroyIcon(this->m_icon);
+	if ( !this->m_callback ) {
+		if ( this->m_handle ) DestroyWindow(this->m_handle);
+		if ( --windowCount == 0 ) UnregisterClassW( className.c_str(), GetModuleHandleW(NULL) );
+	} else {
+		SetWindowLongPtrW( this->m_handle, GWLP_WNDPROC, this->m_callback );
+	}
+}
+void UF_API_CALL spec::win32::Window::terminate() {
+	if ( this == (spec::win32::Window*) fullscreenWindow ) {
+		ChangeDisplaySettingsW(NULL, 0);
+		fullscreenWindow = NULL;
+	}
+	this->setCursorVisible(true);
+	this->setTracking(false);
+	ReleaseCapture();
+}
+
+spec::win32::Window::handle_t UF_API_CALL spec::win32::Window::getHandle() const {
+	return this->m_handle;
+}
+spec::win32::Window::vector_t UF_API_CALL spec::win32::Window::getPosition() const {
+	RECT rectangle;
+	GetWindowRect( this->m_handle, &rectangle );
+	spec::win32::Window::vector_t vec;
+	vec.x = rectangle.left;
+	vec.y = rectangle.top;
+	return vec;
+}
+spec::win32::Window::vector_t UF_API_CALL spec::win32::Window::getSize() const {
+	RECT rectangle;
+	GetClientRect( this->m_handle, &rectangle );
+	spec::win32::Window::vector_t vec;
+	vec.x = rectangle.right - rectangle.left;
+	vec.y = rectangle.bottom - rectangle.top;
+	return vec;
+}
+size_t UF_API_CALL spec::win32::Window::getRefreshRate() const {
+	HDC screenDC = GetDC(NULL);
+	int refreshRate = GetDeviceCaps( screenDC, VREFRESH );
+	ReleaseDC(NULL, screenDC);
+	return refreshRate;
+}
+
+void UF_API_CALL spec::win32::Window::centerWindow() {
+	if ( fullscreenWindow == (void*) this ) return;
+	RECT rect;
+	GetWindowRect ( this->m_handle, &rect ) ;
+	
+	pod::Vector2i offset = {
+		(GetSystemMetrics(SM_CXSCREEN)-rect.right),
+		(GetSystemMetrics(SM_CYSCREEN)-rect.bottom)
+	};
+	offset /= 2;
+	SetWindowPos( this->m_handle, 0, offset.x, offset.y, 0, 0, SWP_NOZORDER | SWP_NOSIZE );
+}
+void UF_API_CALL spec::win32::Window::setPosition( const spec::win32::Window::vector_t& position ) {
+	if ( fullscreenWindow == (void*) this ) return;
+	SetWindowPos(this->m_handle, NULL, position.x, position.y, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
+}
+void UF_API_CALL spec::win32::Window::setMousePosition( const spec::win32::Window::vector_t& position ) {
+	POINT pt = { position.x, position.y };
+	ClientToScreen(this->m_handle, &pt);
+	ReleaseCapture();
+	SetCursorPos(pt.x,pt.y);
+	SetCapture(this->m_handle);
+}
+spec::win32::Window::vector_t UF_API_CALL spec::win32::Window::getMousePosition( ) {
+	POINT pt;
+	GetCursorPos( &pt );
+	ScreenToClient( this->m_handle, &pt );
+	return { pt.x, pt.y };
+}
+void UF_API_CALL spec::win32::Window::setSize( const spec::win32::Window::vector_t& size ) {
+	if ( fullscreenWindow == (void*) this ) return;
+	RECT rectangle = { 0, 0, size.x, size.y };
+	if ( rectangle.right <= 0 && rectangle.bottom <= 0 ) {
+		rectangle.right = GetSystemMetrics(SM_CXSCREEN);
+		rectangle.bottom = GetSystemMetrics(SM_CYSCREEN);
+	}
+	AdjustWindowRect( &rectangle, GetWindowLong(this->m_handle, GWL_STYLE), false );
+	SetWindowPos(this->m_handle, NULL, 0, 0, rectangle.right - rectangle.left, rectangle.bottom - rectangle.top, SWP_NOMOVE | SWP_NOZORDER);
+}
+
+void UF_API_CALL spec::win32::Window::setTitle( const spec::win32::Window::title_t& title ) {
+	SetWindowTextW(this->m_handle, std::wstring(title).c_str());
+//	SetWindowTextW(this->m_handle, (wchar_t*) std::wstring(title).c_str());
+}
+void UF_API_CALL spec::win32::Window::setIcon( const spec::win32::Window::vector_t& size, uint8_t* pixels ) {
+	// First destroy the previous one
+
+	std::vector<uint8_t> iconPixels(size.x * size.y * 4);
+	for (std::size_t i = 0; i < iconPixels.size() / 4; ++i) {
+		iconPixels[i * 4 + 0] = pixels[i * 4 + 2];
+		iconPixels[i * 4 + 1] = pixels[i * 4 + 1];
+		iconPixels[i * 4 + 2] = pixels[i * 4 + 0];
+		iconPixels[i * 4 + 3] = pixels[i * 4 + 3];
+	}
+	this->m_icon = CreateIcon(GetModuleHandleW(NULL), size.x, size.y, 1, 32, NULL, &iconPixels[0]);
+	if (this->m_icon) {
+		SendMessageW(m_handle, WM_SETICON, ICON_BIG,   (LPARAM)this->m_icon);
+		SendMessageW(m_handle, WM_SETICON, ICON_SMALL, (LPARAM)this->m_icon);
+	}
+/*
+	if ( this->m_icon ) DestroyIcon(this->m_icon);
+	
+	// RGBA -> BGRA
+	std::vector<uint8_t> icon( uf::vector::product(size) * 4 );
+	for ( std::size_t i = 0; i < icon.size() / 4; ++i ) {
+		icon[i * 4 + 0] = pixels[i * 4 + 2];
+		icon[i * 4 + 1] = pixels[i * 4 + 1];
+		icon[i * 4 + 2] = pixels[i * 4 + 0];
+		icon[i * 4 + 3] = pixels[i * 4 + 3];
+	}
+	this->m_icon = CreateIcon( GetModuleHandleW(NULL), size.x, size.y, 1, 32, NULL, &icon[0] );
+	if ( this->m_icon ) {
+		SendMessageW(this->m_handle, WM_SETICON, ICON_BIG,	(LPARAM) m_icon);
+		SendMessageW(this->m_handle, WM_SETICON, ICON_SMALL, (LPARAM) m_icon);
+	}
+*/
+}
+void UF_API_CALL spec::win32::Window::setVisible( bool visibility ) {
+	ShowWindow(this->m_handle, visibility ? SW_SHOW : SW_HIDE);
+}
+void UF_API_CALL spec::win32::Window::setCursorVisible( bool visibility ) {
+	this->m_cursor = ( visibility ? LoadCursor(NULL, IDC_ARROW) : NULL );
+	SetCursor(this->m_cursor);
+}
+void UF_API_CALL spec::win32::Window::setKeyRepeatEnabled( bool state ) {
+	this->m_keyRepeatEnabled = state;
+}
+
+void UF_API_CALL spec::win32::Window::requestFocus() {
+	DWORD thisPid = GetWindowThreadProcessId(this->m_handle, NULL);
+	DWORD forePid = GetWindowThreadProcessId(GetForegroundWindow(), NULL);
+
+	if ( thisPid == forePid ) {
+		SetForegroundWindow(this->m_handle);
+	} else {
+		FLASHWINFO info;
+		info.cbSize 	= sizeof(info);
+		info.hwnd 		= this->m_handle;
+		info.dwFlags 	= FLASHW_TRAY;
+		info.dwTimeout 	= 0;
+		info.uCount 	= 3;
+
+		FlashWindowEx(&info);
+	}
+}
+bool UF_API_CALL spec::win32::Window::hasFocus() const {
+	return this->m_handle == GetForegroundWindow();
+}
+
+
+#include <uf/utils/serialize/serializer.h>
+void UF_API_CALL spec::win32::Window::processEvents() {
+	if ( !this->m_callback ) {
+		MSG message;
+		while ( PeekMessageW( &message, NULL, 0, 0, PM_REMOVE ) ) {
+			TranslateMessage(&message);
+			DispatchMessage(&message);
+		}
+	}
+	/* Key inputs */ if ( this->m_asyncParse ) {
+		std::vector<WPARAM> keys;
+		if ( GetAsyncKeyState('A') & 0x8000 ) keys.push_back('A'); // keys.push_back(this->getKey('A', 0));
+		if ( GetAsyncKeyState('B') & 0x8000 ) keys.push_back('B'); // keys.push_back(this->getKey('B', 0));
+		if ( GetAsyncKeyState('C') & 0x8000 ) keys.push_back('C'); // keys.push_back(this->getKey('C', 0));
+		if ( GetAsyncKeyState('D') & 0x8000 ) keys.push_back('D'); // keys.push_back(this->getKey('D', 0));
+		if ( GetAsyncKeyState('E') & 0x8000 ) keys.push_back('E'); // keys.push_back(this->getKey('E', 0));
+		if ( GetAsyncKeyState('F') & 0x8000 ) keys.push_back('F'); // keys.push_back(this->getKey('F', 0));
+		if ( GetAsyncKeyState('G') & 0x8000 ) keys.push_back('G'); // keys.push_back(this->getKey('G', 0));
+		if ( GetAsyncKeyState('H') & 0x8000 ) keys.push_back('H'); // keys.push_back(this->getKey('H', 0));
+		if ( GetAsyncKeyState('I') & 0x8000 ) keys.push_back('I'); // keys.push_back(this->getKey('I', 0));
+		if ( GetAsyncKeyState('J') & 0x8000 ) keys.push_back('J'); // keys.push_back(this->getKey('J', 0));
+		if ( GetAsyncKeyState('K') & 0x8000 ) keys.push_back('K'); // keys.push_back(this->getKey('K', 0));
+		if ( GetAsyncKeyState('L') & 0x8000 ) keys.push_back('L'); // keys.push_back(this->getKey('L', 0));
+		if ( GetAsyncKeyState('M') & 0x8000 ) keys.push_back('M'); // keys.push_back(this->getKey('M', 0));
+		if ( GetAsyncKeyState('N') & 0x8000 ) keys.push_back('N'); // keys.push_back(this->getKey('N', 0));
+		if ( GetAsyncKeyState('O') & 0x8000 ) keys.push_back('O'); // keys.push_back(this->getKey('O', 0));
+		if ( GetAsyncKeyState('P') & 0x8000 ) keys.push_back('P'); // keys.push_back(this->getKey('P', 0));
+		if ( GetAsyncKeyState('Q') & 0x8000 ) keys.push_back('Q'); // keys.push_back(this->getKey('Q', 0));
+		if ( GetAsyncKeyState('R') & 0x8000 ) keys.push_back('R'); // keys.push_back(this->getKey('R', 0));
+		if ( GetAsyncKeyState('S') & 0x8000 ) keys.push_back('S'); // keys.push_back(this->getKey('S', 0));
+		if ( GetAsyncKeyState('T') & 0x8000 ) keys.push_back('T'); // keys.push_back(this->getKey('T', 0));
+		if ( GetAsyncKeyState('U') & 0x8000 ) keys.push_back('U'); // keys.push_back(this->getKey('U', 0));
+		if ( GetAsyncKeyState('V') & 0x8000 ) keys.push_back('V'); // keys.push_back(this->getKey('V', 0));
+		if ( GetAsyncKeyState('W') & 0x8000 ) keys.push_back('W'); // keys.push_back(this->getKey('W', 0));
+		if ( GetAsyncKeyState('X') & 0x8000 ) keys.push_back('X'); // keys.push_back(this->getKey('X', 0));
+		if ( GetAsyncKeyState('Y') & 0x8000 ) keys.push_back('Y'); // keys.push_back(this->getKey('Y', 0));
+		if ( GetAsyncKeyState('Z') & 0x8000 ) keys.push_back('Z'); // keys.push_back(this->getKey('Z', 0));
+		if ( GetAsyncKeyState('0') & 0x8000 ) keys.push_back('0'); // keys.push_back(this->getKey('0', 0));
+		if ( GetAsyncKeyState('1') & 0x8000 ) keys.push_back('1'); // keys.push_back(this->getKey('1', 0));
+		if ( GetAsyncKeyState('2') & 0x8000 ) keys.push_back('2'); // keys.push_back(this->getKey('2', 0));
+		if ( GetAsyncKeyState('3') & 0x8000 ) keys.push_back('3'); // keys.push_back(this->getKey('3', 0));
+		if ( GetAsyncKeyState('4') & 0x8000 ) keys.push_back('4'); // keys.push_back(this->getKey('4', 0));
+		if ( GetAsyncKeyState('5') & 0x8000 ) keys.push_back('5'); // keys.push_back(this->getKey('5', 0));
+		if ( GetAsyncKeyState('6') & 0x8000 ) keys.push_back('6'); // keys.push_back(this->getKey('6', 0));
+		if ( GetAsyncKeyState('7') & 0x8000 ) keys.push_back('7'); // keys.push_back(this->getKey('7', 0));
+		if ( GetAsyncKeyState('8') & 0x8000 ) keys.push_back('8'); // keys.push_back(this->getKey('8', 0));
+		if ( GetAsyncKeyState('9') & 0x8000 ) keys.push_back('9'); // keys.push_back(this->getKey('9', 0));
+		if ( GetAsyncKeyState(VK_ESCAPE) & 0x8000 ) keys.push_back(VK_ESCAPE); // keys.push_back(this->getKey(VK_ESCAPE, 0));
+		if ( GetAsyncKeyState(VK_LCONTROL) & 0x8000 ) keys.push_back(VK_LCONTROL); // keys.push_back(this->getKey(VK_LCONTROL, 0));
+		if ( GetAsyncKeyState(VK_LSHIFT) & 0x8000 ) keys.push_back(VK_LSHIFT); // keys.push_back(this->getKey(VK_LSHIFT, 0));
+		if ( GetAsyncKeyState(VK_LMENU) & 0x8000 ) keys.push_back(VK_LMENU); // keys.push_back(this->getKey(VK_LMENU, 0));
+		if ( GetAsyncKeyState(VK_LWIN) & 0x8000 ) keys.push_back(VK_LWIN); // keys.push_back(this->getKey(VK_LWIN, 0));
+		if ( GetAsyncKeyState(VK_RCONTROL) & 0x8000 ) keys.push_back(VK_RCONTROL); // keys.push_back(this->getKey(VK_RCONTROL, 0));
+		if ( GetAsyncKeyState(VK_RSHIFT) & 0x8000 ) keys.push_back(VK_RSHIFT); // keys.push_back(this->getKey(VK_RSHIFT, 0));
+		if ( GetAsyncKeyState(VK_RMENU) & 0x8000 ) keys.push_back(VK_RMENU); // keys.push_back(this->getKey(VK_RMENU, 0));
+		if ( GetAsyncKeyState(VK_RWIN) & 0x8000 ) keys.push_back(VK_RWIN); // keys.push_back(this->getKey(VK_RWIN, 0));
+		if ( GetAsyncKeyState(VK_APPS) & 0x8000 ) keys.push_back(VK_APPS); // keys.push_back(this->getKey(VK_APPS, 0));
+		if ( GetAsyncKeyState(VK_OEM_4) & 0x8000 ) keys.push_back(VK_OEM_4); // keys.push_back(this->getKey(VK_OEM_4, 0));
+		if ( GetAsyncKeyState(VK_OEM_6) & 0x8000 ) keys.push_back(VK_OEM_6); // keys.push_back(this->getKey(VK_OEM_6, 0));
+		if ( GetAsyncKeyState(VK_OEM_1) & 0x8000 ) keys.push_back(VK_OEM_1); // keys.push_back(this->getKey(VK_OEM_1, 0));
+		if ( GetAsyncKeyState(VK_OEM_COMMA) & 0x8000 ) keys.push_back(VK_OEM_COMMA); // keys.push_back(this->getKey(VK_OEM_COMMA, 0));
+		if ( GetAsyncKeyState(VK_OEM_PERIOD) & 0x8000 ) keys.push_back(VK_OEM_PERIOD); // keys.push_back(this->getKey(VK_OEM_PERIOD, 0));
+		if ( GetAsyncKeyState(VK_OEM_7) & 0x8000 ) keys.push_back(VK_OEM_7); // keys.push_back(this->getKey(VK_OEM_7, 0));
+		if ( GetAsyncKeyState(VK_OEM_2) & 0x8000 ) keys.push_back(VK_OEM_2); // keys.push_back(this->getKey(VK_OEM_2, 0));
+		if ( GetAsyncKeyState(VK_OEM_5) & 0x8000 ) keys.push_back(VK_OEM_5); // keys.push_back(this->getKey(VK_OEM_5, 0));
+		if ( GetAsyncKeyState(VK_OEM_3) & 0x8000 ) keys.push_back(VK_OEM_3); // keys.push_back(this->getKey(VK_OEM_3, 0));
+		if ( GetAsyncKeyState(VK_OEM_PLUS) & 0x8000 ) keys.push_back(VK_OEM_PLUS); // keys.push_back(this->getKey(VK_OEM_PLUS, 0));
+		if ( GetAsyncKeyState(VK_OEM_MINUS) & 0x8000 ) keys.push_back(VK_OEM_MINUS); // keys.push_back(this->getKey(VK_OEM_MINUS, 0));
+		if ( GetAsyncKeyState(VK_SPACE) & 0x8000 ) keys.push_back(VK_SPACE); // keys.push_back(this->getKey(VK_SPACE, 0));
+		if ( GetAsyncKeyState(VK_RETURN) & 0x8000 ) keys.push_back(VK_RETURN); // keys.push_back(this->getKey(VK_RETURN, 0));
+		if ( GetAsyncKeyState(VK_BACK) & 0x8000 ) keys.push_back(VK_BACK); // keys.push_back(this->getKey(VK_BACK, 0));
+		if ( GetAsyncKeyState(VK_TAB) & 0x8000 ) keys.push_back(VK_TAB); // keys.push_back(this->getKey(VK_TAB, 0));
+		if ( GetAsyncKeyState(VK_PRIOR) & 0x8000 ) keys.push_back(VK_PRIOR); // keys.push_back(this->getKey(VK_PRIOR, 0));
+		if ( GetAsyncKeyState(VK_NEXT) & 0x8000 ) keys.push_back(VK_NEXT); // keys.push_back(this->getKey(VK_NEXT, 0));
+		if ( GetAsyncKeyState(VK_END) & 0x8000 ) keys.push_back(VK_END); // keys.push_back(this->getKey(VK_END, 0));
+		if ( GetAsyncKeyState(VK_HOME) & 0x8000 ) keys.push_back(VK_HOME); // keys.push_back(this->getKey(VK_HOME, 0));
+		if ( GetAsyncKeyState(VK_INSERT) & 0x8000 ) keys.push_back(VK_INSERT); // keys.push_back(this->getKey(VK_INSERT, 0));
+		if ( GetAsyncKeyState(VK_DELETE) & 0x8000 ) keys.push_back(VK_DELETE); // keys.push_back(this->getKey(VK_DELETE, 0));
+		if ( GetAsyncKeyState(VK_ADD) & 0x8000 ) keys.push_back(VK_ADD); // keys.push_back(this->getKey(VK_ADD, 0));
+		if ( GetAsyncKeyState(VK_SUBTRACT) & 0x8000 ) keys.push_back(VK_SUBTRACT); // keys.push_back(this->getKey(VK_SUBTRACT, 0));
+		if ( GetAsyncKeyState(VK_MULTIPLY) & 0x8000 ) keys.push_back(VK_MULTIPLY); // keys.push_back(this->getKey(VK_MULTIPLY, 0));
+		if ( GetAsyncKeyState(VK_DIVIDE) & 0x8000 ) keys.push_back(VK_DIVIDE); // keys.push_back(this->getKey(VK_DIVIDE, 0));
+		if ( GetAsyncKeyState(VK_LEFT) & 0x8000 ) keys.push_back(VK_LEFT); // keys.push_back(this->getKey(VK_LEFT, 0));
+		if ( GetAsyncKeyState(VK_RIGHT) & 0x8000 ) keys.push_back(VK_RIGHT); // keys.push_back(this->getKey(VK_RIGHT, 0));
+		if ( GetAsyncKeyState(VK_UP) & 0x8000 ) keys.push_back(VK_UP); // keys.push_back(this->getKey(VK_UP, 0));
+		if ( GetAsyncKeyState(VK_DOWN) & 0x8000 ) keys.push_back(VK_DOWN); // keys.push_back(this->getKey(VK_DOWN, 0));
+		if ( GetAsyncKeyState(VK_NUMPAD0) & 0x8000 ) keys.push_back(VK_NUMPAD0); // keys.push_back(this->getKey(VK_NUMPAD0, 0));
+		if ( GetAsyncKeyState(VK_NUMPAD1) & 0x8000 ) keys.push_back(VK_NUMPAD1); // keys.push_back(this->getKey(VK_NUMPAD1, 0));
+		if ( GetAsyncKeyState(VK_NUMPAD2) & 0x8000 ) keys.push_back(VK_NUMPAD2); // keys.push_back(this->getKey(VK_NUMPAD2, 0));
+		if ( GetAsyncKeyState(VK_NUMPAD3) & 0x8000 ) keys.push_back(VK_NUMPAD3); // keys.push_back(this->getKey(VK_NUMPAD3, 0));
+		if ( GetAsyncKeyState(VK_NUMPAD4) & 0x8000 ) keys.push_back(VK_NUMPAD4); // keys.push_back(this->getKey(VK_NUMPAD4, 0));
+		if ( GetAsyncKeyState(VK_NUMPAD5) & 0x8000 ) keys.push_back(VK_NUMPAD5); // keys.push_back(this->getKey(VK_NUMPAD5, 0));
+		if ( GetAsyncKeyState(VK_NUMPAD6) & 0x8000 ) keys.push_back(VK_NUMPAD6); // keys.push_back(this->getKey(VK_NUMPAD6, 0));
+		if ( GetAsyncKeyState(VK_NUMPAD7) & 0x8000 ) keys.push_back(VK_NUMPAD7); // keys.push_back(this->getKey(VK_NUMPAD7, 0));
+		if ( GetAsyncKeyState(VK_NUMPAD8) & 0x8000 ) keys.push_back(VK_NUMPAD8); // keys.push_back(this->getKey(VK_NUMPAD8, 0));
+		if ( GetAsyncKeyState(VK_NUMPAD9) & 0x8000 ) keys.push_back(VK_NUMPAD9); // keys.push_back(this->getKey(VK_NUMPAD9, 0));
+		if ( GetAsyncKeyState(VK_F1) & 0x8000 ) keys.push_back(VK_F1); // keys.push_back(this->getKey(VK_F1, 0));
+		if ( GetAsyncKeyState(VK_F2) & 0x8000 ) keys.push_back(VK_F2); // keys.push_back(this->getKey(VK_F2, 0));
+		if ( GetAsyncKeyState(VK_F3) & 0x8000 ) keys.push_back(VK_F3); // keys.push_back(this->getKey(VK_F3, 0));
+		if ( GetAsyncKeyState(VK_F4) & 0x8000 ) keys.push_back(VK_F4); // keys.push_back(this->getKey(VK_F4, 0));
+		if ( GetAsyncKeyState(VK_F5) & 0x8000 ) keys.push_back(VK_F5); // keys.push_back(this->getKey(VK_F5, 0));
+		if ( GetAsyncKeyState(VK_F6) & 0x8000 ) keys.push_back(VK_F6); // keys.push_back(this->getKey(VK_F6, 0));
+		if ( GetAsyncKeyState(VK_F7) & 0x8000 ) keys.push_back(VK_F7); // keys.push_back(this->getKey(VK_F7, 0));
+		if ( GetAsyncKeyState(VK_F8) & 0x8000 ) keys.push_back(VK_F8); // keys.push_back(this->getKey(VK_F8, 0));
+		if ( GetAsyncKeyState(VK_F9) & 0x8000 ) keys.push_back(VK_F9); // keys.push_back(this->getKey(VK_F9, 0));
+		if ( GetAsyncKeyState(VK_F10) & 0x8000 ) keys.push_back(VK_F10); // keys.push_back(this->getKey(VK_F10, 0));
+		if ( GetAsyncKeyState(VK_F11) & 0x8000 ) keys.push_back(VK_F11); // keys.push_back(this->getKey(VK_F11, 0));
+		if ( GetAsyncKeyState(VK_F12) & 0x8000 ) keys.push_back(VK_F12); // keys.push_back(this->getKey(VK_F12, 0));
+		if ( GetAsyncKeyState(VK_F13) & 0x8000 ) keys.push_back(VK_F13); // keys.push_back(this->getKey(VK_F13, 0));
+		if ( GetAsyncKeyState(VK_F14) & 0x8000 ) keys.push_back(VK_F14); // keys.push_back(this->getKey(VK_F14, 0));
+		if ( GetAsyncKeyState(VK_F15) & 0x8000 ) keys.push_back(VK_F15); // keys.push_back(this->getKey(VK_F15, 0));
+		if ( GetAsyncKeyState(VK_PAUSE) & 0x8000 ) keys.push_back(VK_PAUSE); // keys.push_back(this->getKey(VK_PAUSE, 0));
+
+   		if ( GetAsyncKeyState(VK_LBUTTON) & 0x8000 ) keys.push_back(VK_LBUTTON); // keys.push_back( this->getKey(VK_LBUTTON, 0) );
+		if ( GetAsyncKeyState(VK_RBUTTON) & 0x8000 ) keys.push_back(VK_RBUTTON); // keys.push_back( this->getKey(VK_RBUTTON, 0) );
+		if ( GetAsyncKeyState(VK_MBUTTON) & 0x8000 ) keys.push_back(VK_MBUTTON); // keys.push_back( this->getKey(VK_MBUTTON, 0) );
+		if ( GetAsyncKeyState(VK_XBUTTON1) & 0x8000 ) keys.push_back(VK_XBUTTON1); // keys.push_back( this->getKey(VK_XBUTTON1, 0) );
+		if ( GetAsyncKeyState(VK_XBUTTON2) & 0x8000 ) keys.push_back(VK_XBUTTON2); // keys.push_back( this->getKey(VK_XBUTTON2, 0) );
+
+		struct Event {
+			std::string type = "unknown";
+			std::string invoker = "???";
+
+			struct {
+				int state;
+				std::string code;
+				uint32_t raw;
+				bool async;
+
+				struct {
+					bool alt;
+					bool ctrl;
+					bool shift;
+					bool sys;
+				} modifier;
+			} key;
+		};
+		Event event; {
+			event.type 			= "window:Key";
+			event.invoker 		= "window";
+			event.key.state 	= -1;
+			event.key.code 		= "NULL";
+			event.key.raw 		= 0;
+			event.key.async 	= true;
+			event.key.modifier 	= {	
+				.alt		= HIWORD(GetAsyncKeyState(VK_MENU))		!= 0,
+				.ctrl 		= HIWORD(GetAsyncKeyState(VK_CONTROL)) 	!= 0,
+				.shift		= HIWORD(GetAsyncKeyState(VK_SHIFT))	!= 0,
+				.sys  		= HIWORD(GetAsyncKeyState(VK_LWIN)) 	|| HIWORD(GetAsyncKeyState(VK_RWIN)),
+			};
+		}
+		/* Readable (JSON) + Optimal (Userdata) event */ {
+			uf::Serializer json;	
+			/* Set up JSON data*/ {
+				json["type"] 							= event.type + "." + ((event.key.state == -1)?"Pressed":"Released");
+				json["invoker"] 						= event.invoker;
+				json["key"]["state"] 					= (event.key.state == -1) ? "Down" : "Up";
+				json["key"]["async"] 					= event.key.async;
+				json["key"]["modifier"]["alt"]			= event.key.modifier.alt;
+				json["key"]["modifier"]["control"] 		= event.key.modifier.ctrl;
+				json["key"]["modifier"]["shift"]		= event.key.modifier.shift;
+				json["key"]["modifier"]["system"]  		= event.key.modifier.sys;
+			}
+			/* Loop through key inputs */ {	
+				for ( auto& key : keys ) {
+					auto code = this->getKey(key, 0);
+					event.key.code 	= code;
+					event.key.raw  	= key;
+				//	if ( USE_OPTIMAL ) this->pushEvent(event.type + "." + code, uf::Userdata(uf::userdata::create(event)));
+				//	if ( USE_OPTIMAL ) this->pushEvent(event.type, uf::Userdata(uf::userdata::create(event)));
+
+					json["key"]["code"] = code;
+					json["key"]["raw"] = key;
+					this->pushEvent(event.type, json);
+					this->pushEvent(event.type + "." + code, json);
+				}
+			}
+		}
+	}
+}
+bool UF_API_CALL spec::win32::Window::pollEvents( bool block ) {
+	if ( this->m_events.empty() ) {
+		do {
+			this->processEvents();
+		} while ( block && this->m_events.empty() );
+	}
+
+	while ( !this->m_events.empty() ) {
+		auto& event = this->m_events.front();
+		if ( event.payload.is<std::string>() ) {
+			ext::json::Value payload = uf::Serializer( event.payload.as<std::string>() );
+		//	std::cout << event.name << " (string)\t" << payload << std::endl;
+			uf::hooks.call( "window:Event", payload );
+			uf::hooks.call( event.name, payload );
+		} else if ( event.payload.is<uf::Serializer>() ) {
+			uf::Serializer& payload = event.payload.as<uf::Serializer>();
+		//	std::cout << event.name << " (serializer)\t" << payload << std::endl;
+			uf::hooks.call( "window:Event", payload );
+			uf::hooks.call( event.name, payload );
+		} else if ( event.payload.is<ext::json::Value>() ) {
+			ext::json::Value& payload = event.payload.as<ext::json::Value>();
+		//	std::cout << event.name << " (json)\t" << payload << std::endl;
+			uf::hooks.call( "window:Event", payload );
+			uf::hooks.call( event.name, payload );
+		} else {
+		//	std::cout << event.name << "(???)" << std::endl;		
+			uf::hooks.call( "window:Event", event.payload );
+			uf::hooks.call( event.name, event.payload );
+		}
+	/*
+		try {
+			uf::hooks.call( "window:Event", payload );
+			uf::hooks.call( event.name, payload );
+		} catch ( ... ) {
+			// Let the hook handler handle the exceptions
+		}
+	*/
+		this->m_events.pop();
+	}
+	return true;
+#if 0
+	/* Empty; look for something! */ if ( this->m_events.readable.empty() && this->m_events.optimal.empty() ) {
+		do {
+			this->processEvents();
+		} while ( block && this->m_events.readable.empty() && this->m_events.optimal.empty() );
+	}
+
+	if ( uf::hooks.prefersReadable() ) // Should we handle events in a readable format...
+	/* Process events parsed in a readable format */ {
+		// process things
+		while ( !this->m_events.readable.empty() ) {
+			auto& event = this->m_events.readable.front();
+			uf::hooks.call( event.name, event.argument );
+		/*
+			try {
+				uf::hooks.call( "window:Event", event.argument );
+				uf::hooks.call( event.name, event.argument );
+			//	uf::iostream << event.name << "\t" << event.argument << "\n";
+			} catch ( ... ) {
+				// Let the hook handler handle the exceptions
+			}
+		*/
+			this->m_events.readable.pop();
+		}
+	//	this->m_events.optimal.clear(); 	// flush queue in case
+	} else // ... or in an optimal format?
+	/* Process events parsed in an optimal format */ {
+		// process things
+		while ( !this->m_events.optimal.empty() ) {
+			auto& event = this->m_events.optimal.front();
+			uf::hooks.call( event.name, event.argument );
+		/*
+			try {
+				uf::hooks.call( "window:Event", event.argument );
+				uf::hooks.call( event.name, event.argument );
+			//	uf::iostream << event.name << "\t" << event.argument << "\n";
+			} catch ( ... ) {
+				// Let the hook handler handle the exceptions
+			}
+		*/
+			uf::userdata::destroy(event.argument);
+			this->m_events.optimal.pop();
+		}
+	//	this->m_events.readable.clear(); 	// flush queue in case
+	}
+	return true;
+#endif
+}
+
+void UF_API_CALL spec::win32::Window::registerWindowClass() {
+	WNDCLASSW windowClass;
+	windowClass.style 			= 0;
+	windowClass.lpfnWndProc 	= &(::globalOnEvent);
+	windowClass.cbClsExtra 		= 0;
+	windowClass.cbWndExtra 		= 0;
+	windowClass.hInstance 		= GetModuleHandleW(NULL);
+	windowClass.hIcon 			= NULL;
+	windowClass.hCursor 		= 0;
+	windowClass.hbrBackground 	= 0;
+	windowClass.lpszMenuName 	= NULL;
+	windowClass.lpszClassName 	= className.c_str();
+	RegisterClassW(&windowClass);
+}
+void UF_API_CALL spec::win32::Window::processEvent(UINT message, WPARAM wParam, LPARAM lParam) {
+	if (!this->m_handle) return;
+	
+	uf::Serializer json;
+	std::string hook = "window:Unknown";
+	std::string serialized = "";
+	std::stringstream serializer;
+	bool labelAsDelta = true;
+
+	switch (message) {
+		case WM_DESTROY:
+			this->terminate();
+		break;
+		case WM_SETCURSOR:
+			if (LOWORD(lParam) == HTCLIENT) SetCursor(this->m_cursor);
+		break;
+		case WM_CLOSE: {
+			struct Event {
+				std::string type = "unknown";
+				std::string invoker = "???";
+			};
+			Event event; {
+				event.type = "window:Closed";
+				event.invoker = "os";
+			};
+			if ( USE_OPTIMAL ) this->pushEvent(event.type, uf::Userdata(uf::userdata::create(event))); {
+				json["type"] = event.type;
+				json["invoker"] = event.invoker;
+				this->pushEvent(event.type, json);
+			}
+		} break;
+		case WM_SIZE: {
+			if (wParam != SIZE_MINIMIZED && !this->m_resizing && this->m_lastSize != getSize()) {
+				this->m_lastSize = this->getSize();
+
+				struct Event {
+					std::string type = "unknown";
+					std::string invoker = "???";
+
+					struct {
+						pod::Vector2i size;
+					} window;
+				};
+				Event event; {
+					event.type = "window:Resized";
+					event.invoker = "os";
+					event.window.size = this->m_lastSize;
+				};
+				if ( USE_OPTIMAL ) this->pushEvent(event.type, uf::Userdata(uf::userdata::create(event))); {
+					json["type"] = event.type;
+					json["invoker"] = event.invoker;
+					json["window"]["size"]["x"] = event.window.size.x;
+					json["window"]["size"]["y"] = event.window.size.y;
+					this->pushEvent(event.type, json);
+				}
+				
+				this->grabMouse(this->m_mouseGrabbed);
+			}
+		} break;
+		case WM_ENTERSIZEMOVE: {	
+			this->m_resizing = true;
+			this->grabMouse(false);
+		} break;
+		case WM_EXITSIZEMOVE:{
+			this->m_resizing = false;
+			if(this->m_lastSize != this->getSize()) {
+				this->m_lastSize = this->getSize();
+
+				struct Event {
+					std::string type = "unknown";
+					std::string invoker = "???";
+
+					struct {
+						pod::Vector2i size;
+					} window;
+				};
+				Event event; {
+					event.type = "window:Resized";
+					event.invoker = "os";
+					event.window.size = this->m_lastSize;
+				};
+				if ( USE_OPTIMAL ) this->pushEvent(event.type, uf::Userdata(uf::userdata::create(event))); {
+					json["type"] = event.type;
+					json["invoker"] = event.invoker;
+					json["window"]["size"]["x"] = event.window.size.x;
+					json["window"]["size"]["y"] = event.window.size.y;
+					this->pushEvent(event.type, json);
+				}
+			} else {
+				struct Event {
+					std::string type = "unknown";
+					std::string invoker = "???";
+				};
+				Event event; {
+					event.type = "window:Moved";
+					event.invoker = "os";
+				};
+				if ( USE_OPTIMAL ) this->pushEvent(event.type, uf::Userdata(uf::userdata::create(event))); {
+					json["type"] = event.type;
+					json["invoker"] = event.invoker;
+					this->pushEvent(event.type, json);
+				}
+			}
+			this->grabMouse(this->m_mouseGrabbed);
+		} break;
+		case WM_GETMINMAXINFO: {
+			MINMAXINFO* info = reinterpret_cast<MINMAXINFO*>(lParam);
+			info->ptMaxTrackSize.x = 50000;
+			info->ptMaxTrackSize.y = 50000;
+		} break;
+		case WM_KILLFOCUS:
+		case WM_SETFOCUS: {
+			if ( message == WM_KILLFOCUS ) {
+				this->grabMouse(false);
+				SetCursor(NULL);
+			}
+			if ( message == WM_SETFOCUS ) {
+				this->grabMouse(this->m_mouseGrabbed);
+				SetCursor(this->m_cursor);
+			}
+			struct Event {
+				std::string type = "unknown";
+				std::string invoker = "???";
+
+				struct {
+					int state = 0;
+				} window;
+			};
+			Event event; {
+				event.type = "window:Focus.Changed";
+				event.invoker = "os";
+
+				switch ( message ) {
+					case WM_SETFOCUS: event.window.state 	=  1; break;
+					case WM_KILLFOCUS: event.window.state 	= -1; break;
+				}
+			};
+			if ( USE_OPTIMAL ) this->pushEvent(event.type, uf::Userdata(uf::userdata::create(event))); {
+				json["type"] = event.type;
+				json["invoker"] = event.invoker;
+				switch ( message ) {
+					case WM_SETFOCUS: json["window"]["state"] = "Gained"; break;
+					case WM_KILLFOCUS: json["window"]["state"] =  "Lost"; break;
+				}
+				this->pushEvent(event.type, json);
+			}
+		} break;
+		// Text event
+		case WM_CHAR: if ( /*true ||*/ this->m_syncParse ) {
+			if (this->m_keyRepeatEnabled || ((lParam & (1 << 30)) == 0)) {
+				// Get the code of the typed character
+				uint32_t character = static_cast<uint32_t>(wParam);
+				// Check if it is the first part of a surrogate pair, or a regular character
+				if ((character >= 0xD800) && (character <= 0xDBFF)) {
+					// First part of a surrogate pair: store it and wait for the second one
+					this->m_surrogate = static_cast<uint16_t>(character);
+				}
+				else {
+					// Check if it is the second part of a surrogate pair, or a regular character
+					if ((character >= 0xDC00) && (character <= 0xDFFF)) {
+						// Convert the UTF-16 surrogate pair to a single UTF-32 value
+						uint16_t utf16[] = {this->m_surrogate, static_cast<uint16_t>(character)};
+						uf::Utf16::toUtf32(utf16, utf16 + 2, &character);
+						this->m_surrogate = 0;
+					}
+					std::basic_string<uint32_t> 	utf32; 	utf32+=character;
+					std::basic_string<uint8_t> 		utf8; 	utf8.reserve(utf32.length());
+					uf::Utf32::toUtf8(utf32.begin(), utf32.end(), std::back_inserter(utf8));
+					
+					std::stringstream to_hex;
+					to_hex << std::hex << character;
+
+					struct Event {
+						std::string type = "unknown";
+						std::string invoker = "???";
+
+						struct {
+							uint32_t utf32;
+							std::string unicode;
+						} text;
+					};
+					Event event; {
+						event.type = "window:Text.Entered";
+						event.invoker = "os";
+
+						event.text.utf32 = character;
+						event.text.unicode = std::string(utf8.begin(), utf8.end());
+					};
+					if ( USE_OPTIMAL ) this->pushEvent(event.type, uf::Userdata(uf::userdata::create(event))); 
+					json["type"] = event.type;
+					json["invoker"] = event.invoker;
+
+					json["text"]["uint32_t"] = event.text.utf32;
+					json["text"]["unicode"] 		= std::string(utf8.begin(), utf8.end());
+					this->pushEvent(event.type, json);
+				}
+			}
+		} break;
+		case WM_KEYDOWN:
+		case WM_SYSKEYDOWN:
+		case WM_KEYUP:
+		case WM_SYSKEYUP: if ( /*true ||*/ this->m_syncParse ) {
+			if (this->m_keyRepeatEnabled || ((HIWORD(lParam) & KF_REPEAT) == 0)) {
+				struct Event {
+					std::string type = "unknown";
+					std::string invoker = "???";
+
+					struct {
+						int state = -1;
+						std::string code;
+						uint32_t raw;
+						bool async;
+
+						struct {
+							bool alt;
+							bool ctrl;
+							bool shift;
+							bool sys;
+						} modifier;
+					} key;
+				};
+				Event event; {
+					event.type 			= "window:Key",
+					event.invoker 		= "window",
+					event.key.code 		= this->getKey(wParam, lParam),
+					event.key.raw 		= wParam,
+					event.key.async 	= false,
+					event.key.modifier 	= {	
+						.alt		= HIWORD(GetAsyncKeyState(VK_MENU))		!= 0,
+						.ctrl 		= HIWORD(GetAsyncKeyState(VK_CONTROL)) 	!= 0,
+						.shift		= HIWORD(GetAsyncKeyState(VK_SHIFT))	!= 0,
+						.sys  		= HIWORD(GetAsyncKeyState(VK_LWIN)) 	|| HIWORD(GetAsyncKeyState(VK_RWIN)),
+					};
+					switch ( message ) {
+						case WM_KEYDOWN:
+						case WM_SYSKEYDOWN: event.key.state 	= -1; break;
+
+						case WM_KEYUP:
+						case WM_SYSKEYUP: event.key.state 		=  1; break;
+					}
+				}
+			//	if ( USE_OPTIMAL ) this->pushEvent(event.type, uf::Userdata(uf::userdata::create(event)));
+			//	if ( USE_OPTIMAL ) this->pushEvent(event.type + "." + event.key.code, uf::Userdata(uf::userdata::create(event)));
+				json["type"] 							= event.type + "." + ((event.key.state == -1)?"Pressed":"Released");
+				json["invoker"] 						= event.invoker;
+				json["key"]["state"] 					= (event.key.state == -1) ? "Down" : "Up";
+				json["key"]["async"] 					= event.key.async;
+				json["key"]["modifier"]["alt"]			= event.key.modifier.alt;
+				json["key"]["modifier"]["control"] 		= event.key.modifier.ctrl;
+				json["key"]["modifier"]["shift"]		= event.key.modifier.shift;
+				json["key"]["modifier"]["system"]  		= event.key.modifier.sys;
+				
+				json["key"]["code"] 					= event.key.code;
+				json["key"]["raw"] 						= event.key.raw;
+				json["key"]["lparam"] 					= lParam;
+
+				// don't know why things dont like things
+			/*
+				if (event.key.state == -1) {
+					uf::hooks.call(event.type, json);
+					uf::hooks.call(event.type + "." + event.key.code, json);
+				} else {
+					this->pushEvent(event.type, json);
+					this->pushEvent(event.type + "." + event.key.code, json);
+				}
+			*/
+				this->pushEvent(event.type, json);
+				this->pushEvent(event.type + "." + event.key.code, json);
+			}
+		} break;
+		case WM_MOUSEWHEEL: {
+			POINT position;
+			position.x = static_cast<int16_t>(LOWORD(lParam));
+			position.y = static_cast<int16_t>(HIWORD(lParam));
+			ScreenToClient(this->m_handle, &position);
+
+			int16_t delta = static_cast<int16_t>(HIWORD(wParam));
+
+			struct Event {
+				std::string type = "unknown";
+				std::string invoker = "???";
+
+				struct {
+					pod::Vector2ui 	position = {};
+					float 			delta = 0;
+				} mouse;
+			};
+			Event event; {
+				event.type = "window:Mouse.Wheel";
+				event.invoker = "os";
+
+				event.mouse.position.x = position.x;
+				event.mouse.position.y = position.y;
+				event.mouse.delta = delta; // 120.0f;
+			};
+			if ( USE_OPTIMAL ) this->pushEvent(event.type, uf::Userdata(uf::userdata::create(event))); {
+				json["type"] = event.type;
+				json["invoker"] = event.invoker;
+
+				json["mouse"]["position"]["x"]		= event.mouse.position.x;
+				json["mouse"]["position"]["y"]		= event.mouse.position.y;
+				json["mouse"]["delta"] 				= event.mouse.delta;
+
+				this->pushEvent(event.type, json);
+			}
+		} break;
+		case WM_LBUTTONDOWN:
+		case WM_LBUTTONUP:
+		case WM_RBUTTONDOWN:
+		case WM_RBUTTONUP:
+		case WM_MBUTTONDOWN:
+		case WM_MBUTTONUP:
+		case WM_XBUTTONDOWN:
+		case WM_XBUTTONUP: if ( true || this->m_syncParse ) {
+			static pod::Vector2i lastPosition = {};
+			struct Event {
+				std::string type = "unknown";
+				std::string invoker = "???";
+
+				struct {
+					pod::Vector2i 	position = {};
+					pod::Vector2i 	delta = lastPosition;
+					std::string 	button = "???";
+					int 			state = 0;
+				} mouse;
+			};
+			Event event; {
+				event.type = "window:Mouse.Click";
+				event.invoker = "os";
+
+			//	event.mouse.position = this->getMousePosition();
+				event.mouse.position.x 	= static_cast<int16_t>(LOWORD(lParam));
+				event.mouse.position.y 	= static_cast<int16_t>(HIWORD(lParam));
+				event.mouse.delta 		= event.mouse.position - lastPosition;
+				switch ( message ) {	
+					case WM_LBUTTONDOWN:
+					case WM_LBUTTONUP: 		event.mouse.button = "Left"; break;
+					
+					case WM_RBUTTONDOWN:
+					case WM_RBUTTONUP: 		event.mouse.button = "Right"; break;
+					
+					case WM_MBUTTONDOWN:
+					case WM_MBUTTONUP: 		event.mouse.button = "Middle"; break;
+					
+					case WM_XBUTTONDOWN:
+					case WM_XBUTTONUP: 		event.mouse.button = "Aux"; break;
+
+					default: 				event.mouse.button = "???"; break;
+				}
+				switch ( message ) {	
+					case WM_LBUTTONUP:
+					case WM_RBUTTONUP:
+					case WM_MBUTTONUP:
+					case WM_XBUTTONUP: 		event.mouse.state = 1; break;
+
+					case WM_LBUTTONDOWN:
+					case WM_RBUTTONDOWN:
+					case WM_MBUTTONDOWN:
+					case WM_XBUTTONDOWN: 	event.mouse.state = -1; break;
+					default: 				event.mouse.state =  0; break; 
+				}
+			};
+			if ( true || this->m_syncParse ){
+				if ( USE_OPTIMAL ) this->pushEvent(event.type, uf::Userdata(uf::userdata::create(event)));
+				json["type"] = event.type;
+				json["invoker"] = event.invoker;
+
+				json["mouse"]["position"]["x"]		= event.mouse.position.x;
+				json["mouse"]["position"]["y"]		= event.mouse.position.y;
+				json["mouse"]["delta"]["x"] 		= event.mouse.delta.x;
+				json["mouse"]["delta"]["y"] 		= event.mouse.delta.y;
+				json["mouse"]["button"] 			= event.mouse.button;
+				switch (event.mouse.state) {
+					case 1:
+						json["mouse"]["state"] = "Up";
+					break;
+					case -1:
+						json["mouse"]["state"] = "Down";
+					break;
+					default: 
+						json["mouse"]["state"] = "???";
+					break;
+				}
+
+				this->pushEvent(event.type, json);
+			}
+			lastPosition = event.mouse.position; //this->getMousePosition();
+		} break;
+		case WM_MOUSELEAVE:
+			if (this->m_mouseInside) {
+				this->m_mouseInside = false;
+
+				struct Event {
+					std::string type = "unknown";
+					std::string invoker = "???";
+
+					struct {
+						int state = 0;
+					} mouse;
+				};
+				Event event; {
+					event.type = "window:Mouse.Moved";
+					event.invoker = "os";
+
+					event.mouse.state = -1;
+				};
+				if ( USE_OPTIMAL ) this->pushEvent(event.type, uf::Userdata(uf::userdata::create(event))); {
+					json["type"] = event.type;
+					json["invoker"] = event.invoker;
+
+					switch (event.mouse.state) {
+						case 1:
+							json["mouse"]["state"] = "Entered";
+						break;
+						case -1:
+							json["mouse"]["state"] = "Left";
+						break;
+						default: 
+							json["mouse"]["state"] = "???";
+						break;
+					}
+					this->pushEvent(event.type, json);
+				}
+			}
+		break;
+		case WM_MOUSEMOVE: {
+			static pod::Vector2i lastPosition = {};
+			struct Event {
+				std::string type = "unknown";
+				std::string invoker = "???";
+
+				struct {
+					int state = 0;
+					pod::Vector2i position;
+					pod::Vector2i delta;
+					pod::Vector2i size;
+				} mouse;
+			};
+			Event event; {
+				event.type = "window:Mouse.Moved";
+				event.invoker = "os";
+			};
+
+			int x = static_cast<int16_t>(LOWORD(lParam));
+			int y = static_cast<int16_t>(HIWORD(lParam));
+			RECT area;
+			GetClientRect(this->m_handle, &area);
+			if ((wParam & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON | MK_XBUTTON1 | MK_XBUTTON2)) == 0) {
+				if (GetCapture() == this->m_handle) ReleaseCapture();
+			}
+			else if (GetCapture() != this->m_handle) {
+				SetCapture(this->m_handle);
+			}
+
+			if ((x < area.left) || (x > area.right) || (y < area.top) || (y > area.bottom)) {
+				if (this->m_mouseInside) {
+					this->m_mouseInside = false;
+					this->setTracking(false);
+					event.mouse.state = -1;
+				}
+			} else {
+				if (!this->m_mouseInside) {
+					this->m_mouseInside = true;
+					this->setTracking(true);
+					event.mouse.state =  1;
+				}
+			}
+			{
+				event.mouse.position.x = x;
+				event.mouse.position.y = y;
+				event.mouse.size = {area.right, area.bottom};
+				event.mouse.delta = event.mouse.position - lastPosition;
+			}
+			if ( USE_OPTIMAL ) this->pushEvent(event.type, uf::Userdata(uf::userdata::create(event))); {
+				json["type"] = event.type;
+				json["invoker"] = event.invoker;
+
+				json["mouse"]["position"]["x"] = event.mouse.position.x;
+				json["mouse"]["position"]["y"] = event.mouse.position.y;
+				json["mouse"]["delta"]["x"] = event.mouse.delta.x;
+				json["mouse"]["delta"]["y"] = event.mouse.delta.y;
+				json["mouse"]["size"]["x"] = event.mouse.size.x;
+				json["mouse"]["size"]["y"] = event.mouse.size.y;
+				switch (event.mouse.state) {
+					case 1:
+						json["mouse"]["state"] = "Entered";
+					break;
+					case -1:
+						json["mouse"]["state"] = "Left";
+					break;
+					default: 
+						json["mouse"]["state"] = "???";
+					break;
+				}
+				this->pushEvent(event.type, json);
+			}
+			lastPosition = event.mouse.position; //this->getMousePosition();
+		break;
+		}
+	}
+}
+
+void UF_API_CALL spec::win32::Window::setTracking(bool state) {
+	TRACKMOUSEEVENT mouseEvent;
+	mouseEvent.cbSize = sizeof(TRACKMOUSEEVENT);
+	mouseEvent.hwndTrack = this->m_handle;
+	mouseEvent.dwFlags = state ? TME_LEAVE : TME_CANCEL;
+	mouseEvent.dwHoverTime = HOVER_DEFAULT;
+	TrackMouseEvent(&mouseEvent);
+}
+void UF_API_CALL spec::win32::Window::setMouseGrabbed(bool state) {
+	this->m_mouseGrabbed = state;
+	this->grabMouse(state);
+}
+void UF_API_CALL spec::win32::Window::grabMouse(bool state) {
+	if (state) {
+		RECT rect;
+		GetClientRect(m_handle, &rect);
+		MapWindowPoints(m_handle, NULL, reinterpret_cast<LPPOINT>(&rect), 2);
+		ClipCursor(&rect);
+	} else {
+		ClipCursor(NULL);
+	}
+}
+pod::Vector2ui UF_API_CALL spec::win32::Window::getResolution() {
+	return { GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN) };
+}
+void UF_API_CALL spec::win32::Window::switchToFullscreen( bool borderless ) {
+	if ( borderless ) {
+		SetWindowLong(this->m_handle, GWL_STYLE, WS_POPUP );
+	//	SetWindowLong(this->m_handle, GWL_EXSTYLE, 0);
+	//	SetWindowPos(this->m_handle, HWND_TOP, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN), SWP_FRAMECHANGED);
+		ShowWindow(this->m_handle, SW_SHOW);
+		return;
+	}
+	SetWindowLong(this->m_handle, GWL_STYLE, WS_POPUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS);
+	SetWindowLong(this->m_handle, GWL_EXSTYLE, WS_EX_APPWINDOW);
+	SetWindowPos(this->m_handle, HWND_TOP, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN), SWP_FRAMECHANGED);
+	ShowWindow(this->m_handle, SW_SHOW);
+	fullscreenWindow = (void*) this;
+}
+
+bool UF_API_CALL spec::win32::Window::isKeyPressed(const std::string& key) {
+	if ( (key == "A") && (GetAsyncKeyState('A') & 0x8000) ) return true;
+	if ( (key == "B") && (GetAsyncKeyState('B') & 0x8000) ) return true;
+	if ( (key == "C") && (GetAsyncKeyState('C') & 0x8000) ) return true;
+	if ( (key == "D") && (GetAsyncKeyState('D') & 0x8000) ) return true;
+	if ( (key == "E") && (GetAsyncKeyState('E') & 0x8000) ) return true;
+	if ( (key == "F") && (GetAsyncKeyState('F') & 0x8000) ) return true;
+	if ( (key == "G") && (GetAsyncKeyState('G') & 0x8000) ) return true;
+	if ( (key == "H") && (GetAsyncKeyState('H') & 0x8000) ) return true;
+	if ( (key == "I") && (GetAsyncKeyState('I') & 0x8000) ) return true;
+	if ( (key == "J") && (GetAsyncKeyState('J') & 0x8000) ) return true;
+	if ( (key == "K") && (GetAsyncKeyState('K') & 0x8000) ) return true;
+	if ( (key == "L") && (GetAsyncKeyState('L') & 0x8000) ) return true;
+	if ( (key == "M") && (GetAsyncKeyState('M') & 0x8000) ) return true;
+	if ( (key == "N") && (GetAsyncKeyState('N') & 0x8000) ) return true;
+	if ( (key == "O") && (GetAsyncKeyState('O') & 0x8000) ) return true;
+	if ( (key == "P") && (GetAsyncKeyState('P') & 0x8000) ) return true;
+	if ( (key == "Q") && (GetAsyncKeyState('Q') & 0x8000) ) return true;
+	if ( (key == "R") && (GetAsyncKeyState('R') & 0x8000) ) return true;
+	if ( (key == "S") && (GetAsyncKeyState('S') & 0x8000) ) return true;
+	if ( (key == "T") && (GetAsyncKeyState('T') & 0x8000) ) return true;
+	if ( (key == "U") && (GetAsyncKeyState('U') & 0x8000) ) return true;
+	if ( (key == "V") && (GetAsyncKeyState('V') & 0x8000) ) return true;
+	if ( (key == "W") && (GetAsyncKeyState('W') & 0x8000) ) return true;
+	if ( (key == "X") && (GetAsyncKeyState('X') & 0x8000) ) return true;
+	if ( (key == "Y") && (GetAsyncKeyState('Y') & 0x8000) ) return true;
+	if ( (key == "Z") && (GetAsyncKeyState('Z') & 0x8000) ) return true;
+	if ( (key == "0") && (GetAsyncKeyState('0') & 0x8000) ) return true;
+	if ( (key == "1") && (GetAsyncKeyState('1') & 0x8000) ) return true;
+	if ( (key == "2") && (GetAsyncKeyState('2') & 0x8000) ) return true;
+	if ( (key == "3") && (GetAsyncKeyState('3') & 0x8000) ) return true;
+	if ( (key == "4") && (GetAsyncKeyState('4') & 0x8000) ) return true;
+	if ( (key == "5") && (GetAsyncKeyState('5') & 0x8000) ) return true;
+	if ( (key == "6") && (GetAsyncKeyState('6') & 0x8000) ) return true;
+	if ( (key == "7") && (GetAsyncKeyState('7') & 0x8000) ) return true;
+	if ( (key == "8") && (GetAsyncKeyState('8') & 0x8000) ) return true;
+	if ( (key == "9") && (GetAsyncKeyState('9') & 0x8000) ) return true;
+	if ( (key == "Escape") && (GetAsyncKeyState(VK_ESCAPE) & 0x8000) ) return true;
+	if ( (key == "LControl") && (GetAsyncKeyState(VK_LCONTROL) & 0x8000) ) return true;
+	if ( (key == "LShift") && (GetAsyncKeyState(VK_LSHIFT) & 0x8000) ) return true;
+	if ( (key == "LAlt") && (GetAsyncKeyState(VK_LMENU) & 0x8000) ) return true;
+	if ( (key == "LSystem") && (GetAsyncKeyState(VK_LWIN) & 0x8000) ) return true;
+	if ( (key == "RControl") && (GetAsyncKeyState(VK_RCONTROL) & 0x8000) ) return true;
+	if ( (key == "RShift") && (GetAsyncKeyState(VK_RSHIFT) & 0x8000) ) return true;
+	if ( (key == "RAlt") && (GetAsyncKeyState(VK_RMENU) & 0x8000) ) return true;
+	if ( (key == "RSystem") && (GetAsyncKeyState(VK_RWIN) & 0x8000) ) return true;
+	if ( (key == "Apps") && (GetAsyncKeyState(VK_APPS) & 0x8000) ) return true;
+	if ( (key == "OEM4") && (GetAsyncKeyState(VK_OEM_4) & 0x8000) ) return true;
+	if ( (key == "OEM6") && (GetAsyncKeyState(VK_OEM_6) & 0x8000) ) return true;
+	if ( (key == "OEM1") && (GetAsyncKeyState(VK_OEM_1) & 0x8000) ) return true;
+	if ( (key == "OEMComma") && (GetAsyncKeyState(VK_OEM_COMMA) & 0x8000) ) return true;
+	if ( (key == "OEMPeriod") && (GetAsyncKeyState(VK_OEM_PERIOD) & 0x8000) ) return true;
+	if ( (key == "OEM7") && (GetAsyncKeyState(VK_OEM_7) & 0x8000) ) return true;
+	if ( (key == "OEM2") && (GetAsyncKeyState(VK_OEM_2) & 0x8000) ) return true;
+	if ( (key == "OEM5") && (GetAsyncKeyState(VK_OEM_5) & 0x8000) ) return true;
+	if ( (key == "OEM3") && (GetAsyncKeyState(VK_OEM_3) & 0x8000) ) return true;
+	if ( (key == "OEM+") && (GetAsyncKeyState(VK_OEM_PLUS) & 0x8000) ) return true;
+	if ( (key == "OEM-") && (GetAsyncKeyState(VK_OEM_MINUS) & 0x8000) ) return true;
+	if ( (key == " ") && (GetAsyncKeyState(VK_SPACE) & 0x8000) ) return true;
+	if ( (key == "Enter") && (GetAsyncKeyState(VK_RETURN) & 0x8000) ) return true;
+	if ( (key == "Back") && (GetAsyncKeyState(VK_BACK) & 0x8000) ) return true;
+	if ( (key == "Tab") && (GetAsyncKeyState(VK_TAB) & 0x8000) ) return true;
+	if ( (key == "Prior") && (GetAsyncKeyState(VK_PRIOR) & 0x8000) ) return true;
+	if ( (key == "Next") && (GetAsyncKeyState(VK_NEXT) & 0x8000) ) return true;
+	if ( (key == "End") && (GetAsyncKeyState(VK_END) & 0x8000) ) return true;
+	if ( (key == "Home") && (GetAsyncKeyState(VK_HOME) & 0x8000) ) return true;
+	if ( (key == "Insert") && (GetAsyncKeyState(VK_INSERT) & 0x8000) ) return true;
+	if ( (key == "Delete") && (GetAsyncKeyState(VK_DELETE) & 0x8000) ) return true;
+	if ( (key == "+") && (GetAsyncKeyState(VK_ADD) & 0x8000) ) return true;
+	if ( (key == "-") && (GetAsyncKeyState(VK_SUBTRACT) & 0x8000) ) return true;
+	if ( (key == "*") && (GetAsyncKeyState(VK_MULTIPLY) & 0x8000) ) return true;
+	if ( (key == "/") && (GetAsyncKeyState(VK_DIVIDE) & 0x8000) ) return true;
+	if ( (key == "Left") && (GetAsyncKeyState(VK_LEFT) & 0x8000) ) return true;
+	if ( (key == "Right") && (GetAsyncKeyState(VK_RIGHT) & 0x8000) ) return true;
+	if ( (key == "Up") && (GetAsyncKeyState(VK_UP) & 0x8000) ) return true;
+	if ( (key == "Down") && (GetAsyncKeyState(VK_DOWN) & 0x8000) ) return true;
+	if ( (key == "Num0") && (GetAsyncKeyState(VK_NUMPAD0) & 0x8000) ) return true;
+	if ( (key == "Num1") && (GetAsyncKeyState(VK_NUMPAD1) & 0x8000) ) return true;
+	if ( (key == "Num2") && (GetAsyncKeyState(VK_NUMPAD2) & 0x8000) ) return true;
+	if ( (key == "Num3") && (GetAsyncKeyState(VK_NUMPAD3) & 0x8000) ) return true;
+	if ( (key == "Num4") && (GetAsyncKeyState(VK_NUMPAD4) & 0x8000) ) return true;
+	if ( (key == "Num5") && (GetAsyncKeyState(VK_NUMPAD5) & 0x8000) ) return true;
+	if ( (key == "Num6") && (GetAsyncKeyState(VK_NUMPAD6) & 0x8000) ) return true;
+	if ( (key == "Num7") && (GetAsyncKeyState(VK_NUMPAD7) & 0x8000) ) return true;
+	if ( (key == "Num8") && (GetAsyncKeyState(VK_NUMPAD8) & 0x8000) ) return true;
+	if ( (key == "Num9") && (GetAsyncKeyState(VK_NUMPAD9) & 0x8000) ) return true;
+	if ( (key == "F1") && (GetAsyncKeyState(VK_F1) & 0x8000) ) return true;
+	if ( (key == "F2") && (GetAsyncKeyState(VK_F2) & 0x8000) ) return true;
+	if ( (key == "F3") && (GetAsyncKeyState(VK_F3) & 0x8000) ) return true;
+	if ( (key == "F4") && (GetAsyncKeyState(VK_F4) & 0x8000) ) return true;
+	if ( (key == "F5") && (GetAsyncKeyState(VK_F5) & 0x8000) ) return true;
+	if ( (key == "F6") && (GetAsyncKeyState(VK_F6) & 0x8000) ) return true;
+	if ( (key == "F7") && (GetAsyncKeyState(VK_F7) & 0x8000) ) return true;
+	if ( (key == "F8") && (GetAsyncKeyState(VK_F8) & 0x8000) ) return true;
+	if ( (key == "F9") && (GetAsyncKeyState(VK_F9) & 0x8000) ) return true;
+	if ( (key == "F10") && (GetAsyncKeyState(VK_F10) & 0x8000) ) return true;
+	if ( (key == "F11") && (GetAsyncKeyState(VK_F11) & 0x8000) ) return true;
+	if ( (key == "F12") && (GetAsyncKeyState(VK_F12) & 0x8000) ) return true;
+	if ( (key == "F13") && (GetAsyncKeyState(VK_F13) & 0x8000) ) return true;
+	if ( (key == "F14") && (GetAsyncKeyState(VK_F14) & 0x8000) ) return true;
+	if ( (key == "F15") && (GetAsyncKeyState(VK_F15) & 0x8000) ) return true;
+	if ( (key == "Pause") && (GetAsyncKeyState(VK_PAUSE) & 0x8000) ) return true;
+
+	if ( (key == "LeftMouse") && (GetAsyncKeyState(VK_LBUTTON) & 0x8000) ) return true;
+	if ( (key == "RightMouse") && (GetAsyncKeyState(VK_RBUTTON) & 0x8000) ) return true;
+	if ( (key == "MiddleMouse") && (GetAsyncKeyState(VK_MBUTTON) & 0x8000) ) return true;
+	if ( (key == "XButton1") && (GetAsyncKeyState(VK_XBUTTON1) & 0x8000) ) return true;
+	if ( (key == "XButton2") && (GetAsyncKeyState(VK_XBUTTON2) & 0x8000) ) return true;
+	return false;
+}
+std::string UF_API_CALL spec::win32::Window::getKey(WPARAM key, LPARAM flags) {
+	switch (key) {
+		// Check the scancode to distinguish between left and right shift
+		case VK_SHIFT: {	
+			static UINT lShift = MapVirtualKeyW(VK_LSHIFT, MAPVK_VK_TO_VSC);
+			UINT scancode = static_cast<UINT>((flags & (0xFF << 16)) >> 16);
+			return scancode == lShift ? "LShift" : "RShift";
+		}
+		// Check the "extended" flag to distinguish between left and right alt
+		case VK_MENU : return (HIWORD(flags) & KF_EXTENDED) ? "RAlt" : "LAlt";
+		// Check the "extended" flag to distinguish between left and right control
+		case VK_CONTROL : return (HIWORD(flags) & KF_EXTENDED) ? "RControl" : "LControl";
+
+		// Other keys are reported properly
+		case VK_LWIN:			return "LSystem";
+		case VK_RWIN:			return "RSystem";
+		case VK_APPS:			return "Menu";
+		case VK_OEM_1:			return "SemiColon";
+		case VK_OEM_2:			return "Slash";
+		case VK_OEM_PLUS:		return "Equal";
+		case VK_OEM_MINUS:  	return "Dash";
+		case VK_OEM_4:			return "LBracket";
+		case VK_OEM_6:			return "RBracket";
+		case VK_OEM_COMMA:  	return "Comma";
+		case VK_OEM_PERIOD:		return "Period";
+		case VK_OEM_7:			return "Quote";
+		case VK_OEM_5:			return "BackSlash";
+		case VK_OEM_3:			return "Tilde";
+		
+		case VK_ESCAPE:			return "Escape";
+		case VK_SPACE:			return "Space";
+		case VK_RETURN:			return "Enter";
+		case VK_BACK:			return "BackSpace";
+		case VK_TAB:			return "Tab";
+		case VK_PRIOR:			return "PageUp";
+		case VK_NEXT:			return "PageDown";
+		case VK_END:			return "End";
+		case VK_HOME:			return "Home";
+		case VK_INSERT:			return "Insert";
+		case VK_DELETE:			return "Delete";
+		case VK_ADD:			return "Add";
+		case VK_SUBTRACT:		return "Subtract";
+		case VK_MULTIPLY:		return "Multiply";
+		case VK_DIVIDE:			return "Divide";
+		case VK_PAUSE:			return "Pause";
+		
+		case VK_F1:				return "F1";
+		case VK_F2:				return "F2";
+		case VK_F3:				return "F3";
+		case VK_F4:				return "F4";
+		case VK_F5:				return "F5";
+		case VK_F6:				return "F6";
+		case VK_F7:				return "F7";
+		case VK_F8:				return "F8";
+		case VK_F9:				return "F9";
+		case VK_F10:			return "F10";
+		case VK_F11:			return "F11";
+		case VK_F12:			return "F12";
+		case VK_F13:			return "F13";
+		case VK_F14:			return "F14";
+		case VK_F15:			return "F15";
+		
+		case VK_LEFT:			return "Left";
+		case VK_RIGHT:			return "Right";
+		case VK_UP:				return "Up";
+		case VK_DOWN:			return "Down";
+
+		case VK_NUMPAD0:		return "Numpad0";
+		case VK_NUMPAD1:		return "Numpad1";
+		case VK_NUMPAD2:		return "Numpad2";
+		case VK_NUMPAD3:		return "Numpad3";
+		case VK_NUMPAD4:		return "Numpad4";
+		case VK_NUMPAD5:		return "Numpad5";
+		case VK_NUMPAD6:		return "Numpad6";
+		case VK_NUMPAD7:		return "Numpad7";
+		case VK_NUMPAD8:		return "Numpad8";
+		case VK_NUMPAD9:		return "Numpad9";
+
+		case 'Q':				return "Q";
+		case 'W':				return "W";
+		case 'E':				return "E";
+		case 'R':				return "R";
+		case 'T':				return "T";
+		case 'Y':				return "Y";
+		case 'U':				return "U";
+		case 'I':				return "I";
+		case 'O':				return "O";
+		case 'P':				return "P";
+		
+		case 'A':				return "A";
+		case 'S':				return "S";
+		case 'D':				return "D";
+		case 'F':				return "F";
+		case 'G':				return "G";
+		case 'H':				return "H";
+		case 'J':				return "J";
+		case 'K':				return "K";
+		case 'L':				return "L";
+		
+		case 'Z':				return "Z";
+		case 'X':				return "X";
+		case 'C':				return "C";
+		case 'V':				return "V";
+		case 'B':				return "B";
+		case 'N':				return "N";
+		case 'M':				return "M";
+		
+		case '1':				return "Num1";
+		case '2':				return "Num2";
+		case '3':				return "Num3";
+		case '4':				return "Num4";
+		case '5':				return "Num5";
+		case '6':				return "Num6";
+		case '7':				return "Num7";
+		case '8':				return "Num8";
+		case '9':				return "Num9";
+		case '0':				return "Num0";
+	}
+// 	return "Unknown";	
+	return std::to_string((int) key);
+}
+#if defined(UF_USE_VULKAN) && UF_USE_VULKAN == 1
+std::vector<std::string> UF_API_CALL spec::win32::Window::getExtensions( bool validationEnabled ) {
+	std::vector<std::string> instanceExtensions = { VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_WIN32_SURFACE_EXTENSION_NAME  };
+	if ( validationEnabled ) instanceExtensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
+	return instanceExtensions;
+}
+void UF_API_CALL spec::win32::Window::createSurface( VkInstance instance, VkSurfaceKHR& surface ) {
+	VkWin32SurfaceCreateInfoKHR surfaceCreateInfo = {};
+	surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
+	surfaceCreateInfo.hinstance = (HINSTANCE) GetModuleHandleW(NULL);
+	surfaceCreateInfo.hwnd = (HWND) this->m_handle; 
+	vkCreateWin32SurfaceKHR( instance, &surfaceCreateInfo, nullptr, &surface);
+}
+#endif
+#endif
\ No newline at end of file
diff --git a/engine/src/utils/audio/audio.cpp b/engine/src/utils/audio/audio.cpp
new file mode 100644
index 00000000..2617d967
--- /dev/null
+++ b/engine/src/utils/audio/audio.cpp
@@ -0,0 +1,307 @@
+#include <uf/utils/audio/audio.h>
+#include <uf/utils/string/ext.h>
+
+#if defined(UF_USE_OPENAL)
+#include <uf/ext/vorbis/vorbis.h>
+#include <uf/ext/oal/oal.h>
+#endif
+
+UF_API uf::Audio::Audio( const std::string& filename ) : m_filename(filename) {
+}
+UF_API uf::Audio::Audio( uf::Audio&& move ) :
+	m_filename(move.m_filename),
+	m_source(move.m_source),
+	m_buffer(move.m_buffer)
+{
+}
+UF_API uf::Audio::Audio( const uf::Audio& copy ) :
+	m_filename(copy.m_filename)
+{
+
+}
+
+bool uf::Audio::mute = false;
+uf::Audio uf::Audio::null;
+
+uf::Audio::~Audio() {
+	this->destroy();
+}
+
+bool UF_API uf::Audio::initialized() {
+#if UF_USE_OPENAL
+	if ( !this->m_source.getIndex() ) return false;
+	if ( !this->m_buffer.getIndex() ) return false;
+	return true;
+#else
+	return false;
+#endif
+}
+void UF_API uf::Audio::destroy() {
+#if UF_USE_OPENAL
+	this->m_source.destroy();
+	this->m_buffer.destroy();
+#endif
+}
+bool UF_API uf::Audio::playing() {
+#if UF_USE_OPENAL
+	if ( !this->initialized() ) return false;
+	if ( !this->m_source.playing() ) return false;
+	return true;
+#else
+	return false;
+#endif
+}
+void UF_API uf::Audio::load( const std::string& filename ) {
+#if UF_USE_OPENAL
+	if ( uf::Audio::mute ) return;
+	if ( this->initialized() ) this->destroy();
+	if ( filename != "" ) this->m_filename = filename;
+	ALenum format;
+	ALsizei frequency;
+	std::vector<char> buffer;
+	std::string extension = uf::io::extension( this->m_filename );
+	if ( extension == "ogg" ) {
+		ext::Vorbis vorbis; vorbis.load( this->m_filename );
+
+		buffer = vorbis.getBuffer();
+		format = vorbis.getFormat();
+		frequency = vorbis.getFrequency();
+		this->m_duration = vorbis.getDuration();
+	}
+
+	if ( buffer.empty() ) return;
+
+	AL_CHECK_ERROR(this->m_buffer.generate());
+	AL_CHECK_ERROR(this->m_source.generate());
+
+	AL_CHECK_ERROR(this->m_buffer.buffer( format, &buffer[0], buffer.size(), frequency ));
+	AL_CHECK_ERROR(this->m_source.source( "BUFFER", std::vector<ALint>{ this->m_buffer.getIndex() } ));
+
+	AL_CHECK_ERROR(this->m_source.source( "PITCH", std::vector<ALfloat>{ 1 } ));
+	AL_CHECK_ERROR(this->m_source.source( "GAIN", std::vector<ALfloat>{ 1 } ));
+	AL_CHECK_ERROR(this->m_source.source( "LOOPING", std::vector<ALint>{ AL_FALSE } ));
+#endif
+}
+
+void UF_API uf::Audio::play() {
+#if UF_USE_OPENAL
+	if ( !this->initialized() ) return;
+	this->m_source.play();
+#endif
+}
+void UF_API uf::Audio::stop() {
+#if UF_USE_OPENAL
+	if ( !this->initialized() ) return;
+	this->m_source.stop();
+#endif
+}
+const std::string& UF_API uf::Audio::getFilename() const {
+	return this->m_filename;
+}
+
+uf::Audio& uf::Audio::operator=( const uf::Audio& copy ) {
+	this->m_filename = copy.m_filename;
+	return *this;
+}
+
+float uf::Audio::getDuration() const {
+	return this->m_duration;
+}
+
+ALfloat UF_API uf::Audio::getTime() {
+#if UF_USE_OPENAL
+	if ( !this->playing() ) return 0;
+	ALfloat pos; 
+	AL_CHECK_ERROR(alGetSourcef(this->m_source.getIndex(), AL_SEC_OFFSET,  &pos ));
+	return pos;
+#else
+	return 0;
+#endif
+}
+void UF_API uf::Audio::setTime( ALfloat pos ) { 
+#if UF_USE_OPENAL
+	if ( !this->initialized() ) return;
+	this->m_source.source("SEC_OFFSET", std::vector<ALfloat>{ pos } ); 
+#endif
+}
+
+ALfloat UF_API uf::Audio::getPitch() {
+#if UF_USE_OPENAL
+	if ( !this->initialized() ) return 0;
+	ALfloat pitch; 
+	AL_CHECK_ERROR(alGetSourcef(this->m_source.getIndex(), AL_PITCH,  &pitch ));
+	return pitch;
+#else
+	return 0;
+#endif
+}
+void UF_API uf::Audio::setPitch( ALfloat pitch ) { 
+#if UF_USE_OPENAL
+	if ( !this->initialized() ) return;
+	this->m_source.source("PITCH", std::vector<ALfloat>{ pitch } ); 
+#endif
+}
+
+ALfloat UF_API uf::Audio::getGain() {
+#if UF_USE_OPENAL
+	if ( !this->initialized() ) return 0;
+	ALfloat gain; 
+	AL_CHECK_ERROR(alGetSourcef(this->m_source.getIndex(), AL_GAIN,  &gain ));
+	return gain;
+#else
+	return 0;
+#endif
+}
+void UF_API uf::Audio::setGain( ALfloat gain ) { 
+#if UF_USE_OPENAL
+	if ( !this->initialized() ) return;
+	this->m_source.source("GAIN", std::vector<ALfloat>{ gain } ); 
+#endif
+}
+
+ALfloat UF_API uf::Audio::getRolloffFactor() {
+#if UF_USE_OPENAL
+	if ( !this->initialized() ) return 0;
+	ALfloat rolloffFactor; 
+	AL_CHECK_ERROR(alGetSourcef(this->m_source.getIndex(), AL_ROLLOFF_FACTOR,  &rolloffFactor ));
+	return rolloffFactor;
+#else
+	return 0;
+#endif
+}
+void UF_API uf::Audio::setRolloffFactor( ALfloat rolloffFactor ) { 
+#if UF_USE_OPENAL
+	if ( !this->initialized() ) return;
+	this->m_source.source("ROLLOFF_FACTOR", std::vector<ALfloat>{ rolloffFactor } ); 
+#endif
+}
+
+ALfloat UF_API uf::Audio::getMaxDistance() {
+#if UF_USE_OPENAL
+	if ( !this->initialized() ) return 0;
+	ALfloat maxDistance; 
+	AL_CHECK_ERROR(alGetSourcef(this->m_source.getIndex(), AL_MAX_DISTANCE,  &maxDistance ));
+	return maxDistance;
+#else
+	return 0;
+#endif
+}
+void UF_API uf::Audio::setMaxDistance( ALfloat maxDistance ) { 
+#if UF_USE_OPENAL
+	if ( !this->initialized() ) return;
+	this->m_source.source("MAX_DISTANCE", std::vector<ALfloat>{ maxDistance } ); 
+#endif
+}
+
+void UF_API uf::Audio::setPosition( const pod::Vector3& position ) {
+#if UF_USE_OPENAL
+	if ( !this->initialized() ) return;
+	this->m_source.source("POSITION", std::vector<ALfloat>{position.x, position.y, position.z} );
+#endif
+}
+void UF_API uf::Audio::setOrientation( const pod::Quaternion<>& orientation ) {
+
+}
+
+void UF_API uf::Audio::setVolume( float volume ) {
+#if UF_USE_OPENAL
+	this->m_source.source("GAIN", std::vector<ALfloat>{volume} );
+#endif
+}
+float UF_API uf::Audio::getVolume() const {
+#if UF_USE_OPENAL
+	ALfloat pos; 
+	AL_CHECK_ERROR(alGetSourcef(this->m_source.getIndex(), AL_GAIN,  &pos ));	
+	return pos;
+#endif
+}
+//
+
+uf::SoundEmitter::~SoundEmitter() {
+	this->cleanup(true);
+}
+bool uf::SoundEmitter::has( const std::string& filename ) const {
+	for ( auto* pointer : this->m_container ) {
+		if ( pointer->getFilename() == filename ) return true;
+	}
+	return false;
+}
+uf::Audio& UF_API uf::SoundEmitter::add( const std::string& filename, bool unique ) {
+	if ( unique && this->has(filename) ) return this->get(filename);
+
+	uf::Audio& sound = *this->m_container.emplace_back(new uf::Audio);
+	sound.load(filename);
+	return sound;
+}
+uf::Audio& UF_API uf::SoundEmitter::add( const uf::Audio& audio, bool unique ) {
+	return this->add(audio.getFilename(), unique);
+}
+uf::Audio& UF_API uf::SoundEmitter::get( const std::string& filename ) {
+	if ( !this->has(filename) ) return this->add(filename);
+	for ( auto* pointer : this->m_container ) {
+		if ( pointer->getFilename() == filename ) return *pointer;
+	}
+	return uf::Audio::null;
+}
+const uf::Audio& UF_API uf::SoundEmitter::get( const std::string& filename ) const {
+	for ( auto* pointer : this->m_container ) {
+		if ( pointer->getFilename() == filename ) return *pointer;
+	}
+	return uf::Audio::null;
+}
+uf::SoundEmitter::container_t& UF_API uf::SoundEmitter::get() {
+	return this->m_container;
+}
+const uf::SoundEmitter::container_t& UF_API uf::SoundEmitter::get() const {
+	return this->m_container;
+}
+void UF_API uf::SoundEmitter::cleanup( bool purge ) {
+	for ( size_t i = 0; i < this->m_container.size(); ++i ) {
+		if ( !purge && this->m_container[i]->playing() ) continue;
+		this->m_container[i]->destroy();
+		delete this->m_container[i];
+		this->m_container.erase(this->m_container.begin() + i);
+	}
+}
+
+//
+uf::MappedSoundEmitter::~MappedSoundEmitter() {
+	this->cleanup(true);
+}
+bool uf::MappedSoundEmitter::has( const std::string& filename ) const {
+	return this->m_container.count(filename) > 0;
+}
+uf::Audio& UF_API uf::MappedSoundEmitter::add( const std::string& filename ) {
+	if ( this->has(filename) ) return this->get(filename);
+
+	this->m_container.emplace(filename, new uf::Audio);
+	uf::Audio& sound = this->get(filename);
+	sound.load(filename);
+	return sound;
+}
+uf::Audio& UF_API uf::MappedSoundEmitter::add( const uf::Audio& audio ) {
+	return this->add(audio.getFilename());
+}
+uf::Audio& UF_API uf::MappedSoundEmitter::get( const std::string& filename ) {
+	if ( !this->has(filename) ) return this->add(filename);
+	return *this->m_container[filename];
+}
+const uf::Audio& UF_API uf::MappedSoundEmitter::get( const std::string& filename ) const {
+	return *this->m_container.at(filename);
+}
+uf::MappedSoundEmitter::container_t& UF_API uf::MappedSoundEmitter::get() {
+	return this->m_container;
+}
+const uf::MappedSoundEmitter::container_t& UF_API uf::MappedSoundEmitter::get() const {
+	return this->m_container;
+}
+void UF_API uf::MappedSoundEmitter::cleanup( bool purge ) {
+	for ( auto& pair : this->m_container ) {
+		if ( purge || !pair.second->playing() ) {
+			pair.second->stop();
+			pair.second->destroy();
+			delete pair.second;
+			this->m_container.erase(pair.first);
+		}
+	}
+}
\ No newline at end of file
diff --git a/engine/src/utils/camera/camera.cpp b/engine/src/utils/camera/camera.cpp
new file mode 100644
index 00000000..47bc4589
--- /dev/null
+++ b/engine/src/utils/camera/camera.cpp
@@ -0,0 +1,329 @@
+#include <uf/utils/camera/camera.h>
+
+#include <uf/utils/renderer/renderer.h>
+#include <uf/ext/openvr/openvr.h>
+
+#if UF_ENV_DREAMCAST
+	bool uf::Camera::USE_REVERSE_INFINITE_PROJECTION = false;
+#else
+	bool uf::Camera::USE_REVERSE_INFINITE_PROJECTION = true;
+#endif
+
+uf::Camera::Camera() : m_modified(false) {
+	this->m_settings.perspective.fov = 100;
+	this->m_settings.perspective.size = {1280, 720};
+	this->m_settings.perspective.bounds = {0.001, 32};
+	this->m_settings.offset = {0, 0, 0};
+	this->m_settings.mode = 1;
+	
+//	this->setModel(uf::matrix::identity());
+//	this->setView(uf::matrix::identity());
+//	this->setProjection(uf::matrix::identity());
+	this->m_matrices.views.resize(6, uf::matrix::identity());
+	this->m_matrices.projections.resize(6, uf::matrix::identity());
+	
+	this->m_transform = uf::transform::initialize(this->m_transform);
+	this->m_transform.position = {0, 0, 0};
+}
+
+bool uf::Camera::modified() const {
+	return !this->m_modified;
+}
+pod::Transform<>& uf::Camera::getTransform() {
+	return this->m_transform;
+}
+const pod::Transform<>& uf::Camera::getTransform() const {
+	return this->m_transform;
+}
+
+pod::Matrix4& uf::Camera::getView( size_t eye ) {
+	if ( eye >= this->m_matrices.views.size() ) eye = 0;
+	return this->m_matrices.views[eye];
+//	if ( eye >= this->m_matrices.views.size() ) return uf::matrix::identity();
+//	if ( eye >= this->m_matrices.views.size() ) this->m_matrices.views.resize( uf::matrix::identity() );
+/*
+	switch ( eye ) {
+		case 0:
+			return this->m_matrices.left.view;
+		break;
+		case 1:
+			return this->m_matrices.right.view;
+		break;
+		default:
+			return this->m_matrices.left.view;
+		break;
+	}
+*/
+}
+pod::Matrix4& uf::Camera::getProjection( size_t eye ) {
+	if ( eye >= this->m_matrices.projections.size() ) eye = 0;
+	return this->m_matrices.projections[eye];
+//	if ( eye >= this->m_matrices.projections.size() ) return uf::matrix::identity();
+//	if ( eye >= this->m_matrices.projections.size() ) this->m_matrices.projections.resize( eye, uf::matrix::identity() );
+/*
+	switch ( eye ) {
+		case 0:
+			return this->m_matrices.left.projection;
+		break;
+		case 1:
+			return this->m_matrices.right.projection;
+		break;
+		default:
+			return this->m_matrices.left.projection;
+		break;
+	}
+*/
+}
+/*
+pod::Matrix4& uf::Camera::getModel() {
+	return this->m_matrices.model;
+}
+*/
+const pod::Matrix4& uf::Camera::getView( size_t eye ) const {
+	if ( eye >= this->m_matrices.views.size() ) eye = 0;
+	return this->m_matrices.views[eye];
+//	if ( eye >= this->m_matrices.views.size() ) return uf::matrix::identity();
+//	if ( eye >= this->m_matrices.views.size() ) this->m_matrices.views.resize( eye, uf::matrix::identity() );
+/*
+	switch ( eye ) {
+		case 0:
+			return this->m_matrices.left.view;
+		break;
+		case 1:
+			return this->m_matrices.right.view;
+		break;
+		default:
+			return this->m_matrices.left.view;
+		break;
+	}
+*/
+}
+const pod::Matrix4& uf::Camera::getProjection( size_t eye ) const {
+	if ( eye >= this->m_matrices.projections.size() ) eye = 0;
+	return this->m_matrices.projections[eye];
+//	if ( eye >= this->m_matrices.projections.size() ) return uf::matrix::identity();
+//	if ( eye >= this->m_matrices.projections.size() ) this->m_matrices.projections.resize( eye, uf::matrix::identity() );
+/*
+	switch ( eye ) {
+		case 0:
+			return this->m_matrices.left.projection;
+		break;
+		case 1:
+			return this->m_matrices.right.projection;
+		break;
+		default:
+			return this->m_matrices.left.projection;
+		break;
+	}
+*/
+}
+/*
+const pod::Matrix4& uf::Camera::getModel() const {
+	return this->m_matrices.model;
+}
+*/
+pod::Math::num_t& uf::Camera::getFov() {
+	return this->m_settings.perspective.fov;
+}
+pod::Math::num_t uf::Camera::getFov() const {
+	return this->m_settings.perspective.fov;
+}
+
+pod::Vector2& uf::Camera::getSize() {
+	return this->m_settings.perspective.size;
+}
+const pod::Vector2& uf::Camera::getSize() const {
+	return this->m_settings.perspective.size;
+}
+
+pod::Vector2& uf::Camera::getBounds() {
+	return this->m_settings.perspective.bounds;
+}
+const pod::Vector2& uf::Camera::getBounds() const {
+	return this->m_settings.perspective.bounds;
+}
+
+pod::Vector3& uf::Camera::getOffset() {
+	return this->m_settings.offset;
+}
+const pod::Vector3& uf::Camera::getOffset() const {
+	return this->m_settings.offset;
+}
+
+void uf::Camera::setTransform( const pod::Transform<>& transform ) {
+	this->m_transform = transform;
+	this->update(true);
+}
+void uf::Camera::setView( const pod::Matrix4& mat, size_t i ) {
+	if ( i >= uf::renderer::settings::maxViews ) {
+		for ( i = 0; i < this->m_matrices.views.size(); ++i )
+			this->m_matrices.views[i] = mat;
+		return;
+	}
+	if ( i >= this->m_matrices.views.size() ) this->m_matrices.views.resize( i, uf::matrix::identity() );
+	this->m_matrices.views[i] = mat;
+/*
+	switch ( i ) {
+		case 0:
+			this->m_matrices.left.view = mat;
+		break;
+		case 1:
+			this->m_matrices.right.view = mat;
+		break;
+		default:
+			this->setView( mat, 0 );
+			this->setView( mat, 1 );
+		break;
+	}
+*/
+}
+void uf::Camera::setProjection( const pod::Matrix4& mat, size_t i ) {
+	if ( i >= uf::renderer::settings::maxViews ) {
+		for ( i = 0; i < this->m_matrices.projections.size(); ++i )
+			this->m_matrices.projections[i] = mat;
+		return;
+	}
+	if ( i >= this->m_matrices.projections.size() ) this->m_matrices.projections.resize( i, uf::matrix::identity() );
+	this->m_matrices.projections[i] = mat;
+/*
+	switch ( i ) {
+		case 0:
+			this->m_matrices.left.projection = mat;
+		break;
+		case 1:
+			this->m_matrices.right.projection = mat;
+		break;
+		default:
+			this->setProjection( mat, 0 );
+			this->setProjection( mat, 1 );
+		break;
+	}
+*/
+}
+/*
+void uf::Camera::setModel( const pod::Matrix4& mat ) {
+	this->m_matrices.model = mat;
+}
+*/
+void uf::Camera::setFov( pod::Math::num_t fov ) {
+	this->m_settings.mode = 1;
+	this->m_settings.perspective.fov = fov;
+	this->update(true);
+}
+void uf::Camera::setSize( const pod::Vector2& size ) {
+	this->m_settings.perspective.size = size;
+	this->update(true);
+}
+void uf::Camera::setBounds( const pod::Vector2& bounds ) {
+	this->m_settings.mode = 1;
+	this->m_settings.perspective.bounds = bounds;
+	this->update(true);
+}
+void uf::Camera::setOffset( const pod::Vector3& offset ) {
+	this->m_settings.offset = offset;
+	this->update(true);
+}
+
+void uf::Camera::ortho( const pod::Vector2& lr, const pod::Vector2& bt, const pod::Vector2& nf ) {
+	this->m_settings.mode = -1;
+	this->m_settings.ortho.lr = lr;
+	this->m_settings.ortho.bt = bt;
+	this->m_settings.ortho.nf = nf;
+
+	this->update(true);
+}
+void uf::Camera::setStereoscopic(bool settings) {
+	this->m_settings.stereoscopic = settings;
+}
+void uf::Camera::update(bool override) {
+	if ( !override && !this->modified() ) return;
+	this->updateView();
+	this->updateProjection();
+	this->m_modified = true;
+}
+void uf::Camera::updateView() {
+	auto& transform = this->getTransform();
+#if UF_USE_OPENVR
+	if ( this->m_settings.stereoscopic && ext::openvr::context ) {
+		transform.orientation = uf::quaternion::identity();
+		pod::Matrix4t<> view = uf::matrix::inverse( uf::transform::model( transform, false, 1 ) );
+		transform.orientation = ext::openvr::hmdQuaternion();
+
+		this->setView( ext::openvr::hmdViewMatrix(vr::Eye_Left, view ), 0 );
+		this->setView( ext::openvr::hmdViewMatrix(vr::Eye_Right, view ), 1 );
+	} else {
+#else
+	{
+#endif
+		pod::Matrix4t<> view = uf::matrix::inverse( uf::transform::model( transform, false, 1 ) );
+		this->setView( view );
+	}
+}
+void uf::Camera::updateProjection() {
+#if UF_USE_OPENVR
+	if ( this->m_settings.stereoscopic && ext::openvr::context ) {
+		this->setProjection( ext::openvr::hmdProjectionMatrix( vr::Eye_Left, this->m_settings.perspective.bounds.x, this->m_settings.perspective.bounds.y ), 0 );
+		this->setProjection( ext::openvr::hmdProjectionMatrix( vr::Eye_Right, this->m_settings.perspective.bounds.x, this->m_settings.perspective.bounds.y ), 1 );
+		return;
+	}
+#endif
+	if ( this->m_settings.mode < 0 ) {
+		// Maintain aspect ratio
+		if ( this->m_settings.ortho.lr.x == this->m_settings.ortho.bt.x && this->m_settings.ortho.lr.y == this->m_settings.ortho.bt.y && this->m_settings.ortho.bt.x == -this->m_settings.ortho.bt.y ) {
+			pod::Math::num_t raidou = this->m_settings.perspective.size.x / this->m_settings.perspective.size.y;
+			pod::Math::num_t range = this->m_settings.ortho.bt.y - this->m_settings.ortho.bt.x;
+			pod::Math::num_t correction = raidou * range / 2.0;
+			this->setProjection(uf::matrix::ortho(
+				-correction, correction,
+				this->m_settings.ortho.bt.x, this->m_settings.ortho.bt.y, 
+				this->m_settings.ortho.nf.x, this->m_settings.ortho.nf.y
+			));
+			return;
+		}
+		this->setProjection(uf::matrix::ortho(
+			this->m_settings.ortho.lr.x, this->m_settings.ortho.lr.y, 
+			this->m_settings.ortho.bt.x, this->m_settings.ortho.bt.y, 
+			this->m_settings.ortho.nf.x, this->m_settings.ortho.nf.y
+		));
+		return;
+	}
+	float zNear = this->m_settings.perspective.bounds.x;
+	float zFar = this->m_settings.perspective.bounds.y;
+	float fov = this->m_settings.perspective.fov * (3.14159265358f / 180.0f);
+	float raidou = (float) this->m_settings.perspective.size.x / (float) this->m_settings.perspective.size.y;
+	if ( USE_REVERSE_INFINITE_PROJECTION ) {
+		float f = 1.0f / tan( 0.5f * fov );
+	#if UF_USE_OPENGL
+		this->setProjection({
+			f / raidou, 	0.0f, 	 0.0f, 	0.0f,
+			0.0f, 			 f, 	 0.0f, 	0.0f,
+			0.0f,       	0.0f,    0.0f, 	1.0f,
+			0.0f,       	0.0f,   zNear, 	0.0f
+		});
+	#elif UF_USE_VULKAN
+		this->setProjection({
+			f / raidou, 	0.0f, 	 0.0f, 	0.0f,
+			0.0f, 			-f, 	 0.0f, 	0.0f,
+			0.0f,       	0.0f,    0.0f, 	1.0f,
+			0.0f,       	0.0f,   zNear, 	0.0f
+		});
+	#endif
+	} else {
+		float range = zNear - zFar;
+		float f = tanf( fov / 2.0 );
+
+		float Sx = 1.0 / (f * raidou);
+		float Sy = 1.0 / f;
+		float Sz = (-zNear - zFar) / range;
+		float Pz = 2.0 * zFar * zNear / range;
+	#if UF_USE_VULKAN
+		Sy = -Sy;
+	#endif
+		this->setProjection({
+			Sx, 	 0, 	 0, 	  0,
+			 0, 	Sy, 	 0, 	  0,
+			 0, 	 0, 	Sz, 	  1,
+			 0, 	 0, 	Pz, 	  0
+		});
+	}
+}
\ No newline at end of file
diff --git a/engine/src/utils/component/component.cpp b/engine/src/utils/component/component.cpp
new file mode 100644
index 00000000..53bb30cd
--- /dev/null
+++ b/engine/src/utils/component/component.cpp
@@ -0,0 +1,26 @@
+#include <uf/utils/component/component.h>
+
+UF_API uf::MemoryPool uf::component::memoryPool;
+uf::Component::~Component() {
+	this->destroyComponents();
+}
+
+void uf::Component::destroyComponents() {
+	for ( auto& kv : this->m_container ) {
+		pod::Component& component = kv.second;
+	#if UF_COMPONENT_POINTERED_USERDATA
+		uf::pointeredUserdata::destroy(uf::component::memoryPool, component.userdata);
+	#else
+		uf::userdata::destroy(uf::component::memoryPool, component.userdata);
+	#endif
+	}
+	this->m_container.clear();
+}
+
+#include <uf/utils/serialize/serializer.h>
+// override serializers
+template<>
+uf::Serializer uf::Serializer::toBase64( const pod::Component& input ) {
+	uf::Serializer serialized;
+	return serialized;
+}
\ No newline at end of file
diff --git a/engine/src/utils/graphic/mesh.cpp b/engine/src/utils/graphic/mesh.cpp
new file mode 100644
index 00000000..c764fd4d
--- /dev/null
+++ b/engine/src/utils/graphic/mesh.cpp
@@ -0,0 +1,66 @@
+#include <uf/utils/graphic/mesh.h>
+
+// Used for per-vertex colors
+UF_VERTEX_DESCRIPTOR(pod::Vertex_3F2F3F4F,
+	UF_VERTEX_DESCRIPTION(pod::Vertex_3F2F3F4F, R32G32B32_SFLOAT, position)
+	UF_VERTEX_DESCRIPTION(pod::Vertex_3F2F3F4F, R32G32_SFLOAT, uv)
+	UF_VERTEX_DESCRIPTION(pod::Vertex_3F2F3F4F, R32G32B32_SFLOAT, normal)
+	UF_VERTEX_DESCRIPTION(pod::Vertex_3F2F3F4F, R32_UINT, color)
+)
+// Used for terrain
+UF_VERTEX_DESCRIPTOR(pod::Vertex_3F2F3F32B,
+	UF_VERTEX_DESCRIPTION(pod::Vertex_3F2F3F32B, R32G32B32_SFLOAT, position)
+	UF_VERTEX_DESCRIPTION(pod::Vertex_3F2F3F32B, R32G32_SFLOAT, uv)
+	UF_VERTEX_DESCRIPTION(pod::Vertex_3F2F3F32B, R32G32B32_SFLOAT, normal)
+	UF_VERTEX_DESCRIPTION(pod::Vertex_3F2F3F32B, R32_UINT, color)
+)
+// Used for normal meshses
+UF_VERTEX_DESCRIPTOR(pod::Vertex_3F2F3F,
+	UF_VERTEX_DESCRIPTION(pod::Vertex_3F2F3F, R32G32B32_SFLOAT, position)
+	UF_VERTEX_DESCRIPTION(pod::Vertex_3F2F3F, R32G32_SFLOAT, uv)
+	UF_VERTEX_DESCRIPTION(pod::Vertex_3F2F3F, R32G32B32_SFLOAT, normal)
+)
+// (Typically) used for displaying textures
+UF_VERTEX_DESCRIPTOR(pod::Vertex_3F2F,
+	UF_VERTEX_DESCRIPTION(pod::Vertex_3F2F, R32G32B32_SFLOAT, position)
+	UF_VERTEX_DESCRIPTION(pod::Vertex_3F2F, R32G32_SFLOAT, uv)
+)
+UF_VERTEX_DESCRIPTOR(pod::Vertex_2F2F,
+	UF_VERTEX_DESCRIPTION(pod::Vertex_2F2F, R32G32B32_SFLOAT, position)
+	UF_VERTEX_DESCRIPTION(pod::Vertex_2F2F, R32G32_SFLOAT, uv)
+)
+// used for texture arrays
+UF_VERTEX_DESCRIPTOR(pod::Vertex_3F3F3F,
+	UF_VERTEX_DESCRIPTION(pod::Vertex_3F3F3F, R32G32B32_SFLOAT, position)
+	UF_VERTEX_DESCRIPTION(pod::Vertex_3F3F3F, R32G32B32_SFLOAT, uv)
+	UF_VERTEX_DESCRIPTION(pod::Vertex_3F3F3F, R32G32B32_SFLOAT, normal)
+)
+UF_VERTEX_DESCRIPTOR(pod::Vertex_3F2F3F1UI,
+	UF_VERTEX_DESCRIPTION(pod::Vertex_3F2F3F1UI, R32G32B32_SFLOAT, position)
+	UF_VERTEX_DESCRIPTION(pod::Vertex_3F2F3F1UI, R32G32_SFLOAT, uv)
+	UF_VERTEX_DESCRIPTION(pod::Vertex_3F2F3F1UI, R32G32B32_SFLOAT, normal)
+	UF_VERTEX_DESCRIPTION(pod::Vertex_3F2F3F1UI, R32_UINT, id)
+)
+// Basic
+UF_VERTEX_DESCRIPTOR(pod::Vertex_3F,
+	UF_VERTEX_DESCRIPTION(pod::Vertex_3F, R32G32B32_SFLOAT, position)
+)
+
+uf::BaseGeometry::~BaseGeometry() {}
+void uf::BaseGeometry::generateIndices() {
+	this->resizeIndices(this->attributes.vertex.length);
+	switch ( this->attributes.index.size ) {
+		case sizeof(uint32_t):
+			for ( size_t i = 0; i < this->attributes.vertex.length; ++i ) ((uint32_t*) this->attributes.index.pointer)[i] = i;
+		break;
+		case sizeof(uint16_t):
+			for ( size_t i = 0; i < this->attributes.vertex.length; ++i ) ((uint16_t*) this->attributes.index.pointer)[i] = i;
+		break;
+		case sizeof(uint8_t):
+			for ( size_t i = 0; i < this->attributes.vertex.length; ++i ) ((uint8_t*) this->attributes.index.pointer)[i] = i;
+		break;
+	}
+}
+void uf::BaseGeometry::updateDescriptor() {}
+void uf::BaseGeometry::resizeVertices( size_t n ) {}
+void uf::BaseGeometry::resizeIndices( size_t n ) {}
\ No newline at end of file
diff --git a/engine/src/utils/hook/hook.cpp b/engine/src/utils/hook/hook.cpp
new file mode 100644
index 00000000..a9ec8896
--- /dev/null
+++ b/engine/src/utils/hook/hook.cpp
@@ -0,0 +1,389 @@
+#include <uf/utils/hook/hook.h>
+#include <uf/utils/io/iostream.h> 	// uf::iostream
+
+size_t uf::Hooks::uids = 0;
+uf::Hooks uf::hooks;
+
+size_t uf::Hooks::addHook( const uf::Hooks::name_t& name, const pod::Hook::function_t& callback, size_t type ) {
+	auto& hook = this->m_container[name].emplace_back();
+	hook.uid = ++uids;
+	hook.type = type;
+	hook.callback = callback;
+
+	return hook.uid;
+}
+void uf::Hooks::removeHook( const uf::Hooks::name_t& name, size_t uid ) {
+	auto& container = this->m_container[name];
+	for ( auto it = container.begin(); it != container.end(); ++it ) {
+		if ( it->uid == uid ) {
+			this->m_container[name].erase(it);
+			break;
+		}
+	}
+}
+uf::Hooks::return_t uf::Hooks::call( const uf::Hooks::name_t& name, const uf::Userdata& payload ) {
+	auto& container = this->m_container[name];
+	std::vector<uf::Userdata> results;
+	results.reserve( container.size() );
+/*
+	if ( name[0] == 'w' ) {
+		std::cout << "Calling hook: " << name;
+		if ( payload.is<std::string>() ) std::cout << " (string) " << payload.get<std::string>();
+		else if ( payload.is<ext::json::Value>() ) std::cout << " (json) " << payload.get<ext::json::Value>();
+		else if ( payload.is<uf::Serializer>() ) std::cout << " (serializer) " << payload.get<uf::Serializer>();
+		std::cout << std::endl;
+	}
+*/
+	for ( auto& hook : container ) {
+		uf::Userdata& unconst_payload = const_cast<uf::Userdata&>(payload);
+		uf::Userdata hookResult = hook.callback(unconst_payload);
+		auto& returnResult = results.emplace_back();
+		returnResult.move( hookResult );
+	}
+	
+
+	return results;
+}
+uf::Hooks::return_t uf::Hooks::call( const uf::Hooks::name_t& name, const std::string& s ) {
+	uf::Userdata payload;
+	payload.create<ext::json::Value>();
+	auto& value = payload.get<ext::json::Value>();
+	value = uf::Serializer(s);
+//	payload.create<std::string>( s );
+	return call(name, payload);
+}
+uf::Hooks::return_t uf::Hooks::call( const uf::Hooks::name_t& name, const ext::json::Value& s ) {
+	uf::Userdata payload;
+	payload.create<ext::json::Value>( s );
+//	payload.create<std::string>( ext::json::encode( s ) );
+	return call(name, payload);
+}
+uf::Hooks::return_t uf::Hooks::call( const uf::Hooks::name_t& name, const uf::Serializer& s ) {
+	uf::Userdata payload;
+	payload.create<ext::json::Value>( (const ext::json::Value&) s );
+//	payload.create<std::string>( s.serialize() );
+	return call(name, payload);
+}
+// specialization: void function
+size_t uf::Hooks::addHook( const uf::Hooks::name_t& name, const std::function<void()>& callback ) {
+	return addHook( name, [=]( const uf::Userdata& userdata ){
+		callback();
+		uf::Userdata ret;
+		return ret;
+	});
+}
+/*
+// specialization: serialized JSON handling
+size_t uf::Hooks::addHook( const uf::Hooks::name_t& name, const std::function<void(const std::string&)>& callback ) {
+	return addHook( name, [=]( const uf::Userdata& userdata ){
+		std::string payload = userdata.is<std::string>() ? userdata.get<std::string>() : "";
+		callback( payload );
+		uf::Userdata ret;
+		return ret;
+	});
+}
+// specialization: legacy callback handling
+size_t uf::Hooks::addHook( const uf::Hooks::name_t& name, const std::function<std::string(const std::string&)>& callback ) {
+	return addHook( name, [=]( const uf::Userdata& userdata ){
+		std::string payload = userdata.is<std::string>() ? userdata.get<std::string>() : "";
+		std::string res = callback( payload );
+
+		uf::Userdata ret;
+		ret.create<std::string>(res);
+		return ret;
+	});
+}
+*/
+bool uf::Hooks::exists( const uf::Hooks::name_t& name ) {
+	return this->m_container.count(name) > 0;
+}
+
+#if 0
+uf::HookHandler uf::hooks;
+namespace {
+	std::size_t hooks = 0;
+}
+uf::Hooks::~Hooks() {
+	this->clear();
+}
+
+std::size_t uf::Hooks::addHook( const uf::HookHandler::Readable::name_t& name, const uf::HookHandler::Readable::function_t& callback ) {
+	std::size_t id = uf::hooks.addHook( name, callback );
+	this->m_container[name].push_back( id );
+	return id;
+}
+std::size_t uf::Hooks::addHook( const uf::HookHandler::Optimal::name_t& name, const uf::HookHandler::Optimal::function_t& callback ) {
+	std::size_t id = uf::hooks.addHook( name, callback );
+	this->m_container[name].push_back( id );
+	return id;
+}
+void uf::Hooks::clear() {
+	for ( uf::Hooks::container_t::iterator it = this->m_container.begin(); it != this->m_container.end(); ++it ) {
+	 	const std::string& name = it->first;
+	 	const std::vector<std::size_t>& vector = it->second;
+		for ( std::size_t id : vector ) uf::hooks.removeHook(name, id);
+	}
+	this->m_container.clear();
+}
+
+uf::HookHandler::HookHandler() :
+	m_preferReadable(false)
+{
+}
+// Adds a hook that receives readable data
+std::size_t uf::HookHandler::addHook( const Readable::name_t& name, const Readable::function_t& callback ) {
+	std::size_t uid = ++::hooks;
+	this->m_readable.hooks[name].emplace_back( Readable::hook_t{
+		.name = name,
+		.callback = callback,
+		.uid = uid,
+	} );
+	return uid;
+}
+// Adds a hook that receives optimal data
+std::size_t uf::HookHandler::addHook( const Optimal::name_t& name, const Optimal::function_t& callback ) {
+	std::size_t uid = ++::hooks;
+	this->m_optimal.hooks[name].emplace_back( Optimal::hook_t{
+		.name = name, 
+		.callback = callback,
+		.uid = uid,
+	} );
+	return uid;
+}
+// Removes a hook
+void uf::HookHandler::removeHook( const std::string& name, std::size_t id ) {
+	if ( this->isReadable(name) ) {
+		auto& hooks = this->m_readable.hooks.at(name);
+		for ( auto& hook : hooks ) {
+			if ( hook.uid == id ) {
+				hooks.erase(std::find(hooks.begin(), hooks.end(), hook));
+			}
+		}
+	}
+	if ( this->isOptimal(name) ) {
+		auto& hooks = this->m_optimal.hooks.at(name);
+		for ( auto& hook : hooks ) {
+			if ( hook.uid == id ) {
+				hooks.erase(std::find(hooks.begin(), hooks.end(), hook));
+			}
+		}
+	}
+}
+
+// Is there a hook bound to a name in either lists?
+bool uf::HookHandler::exists( const Readable::name_t& name ) const {
+	return this->m_readable.hooks.count(name) > 0 || this->m_optimal.hooks.count(name) > 0;
+}
+
+// Is a hook receiving in a readable format...
+bool uf::HookHandler::isReadable( const Readable::name_t& name ) const {
+	return this->m_readable.hooks.count(name) > 0;
+}
+// ...or in an optimal one?
+bool uf::HookHandler::isOptimal( const Optimal::name_t& name ) const {
+	return this->m_optimal.hooks.count(name) > 0;
+}
+// Swaps between biasing towards readable or not
+void uf::HookHandler::shouldPreferReadable(bool bias) {
+	this->m_preferReadable = bias;
+}
+// Do we have a bias towards readable format over optimal? (Used for evaluating hook parameters in dev.)
+bool uf::HookHandler::prefersReadable() const {
+	return this->m_preferReadable;
+}
+
+// 	Aliases
+void uf::HookHandler::addAlias( const Readable::alias_t::name_t& name, const Readable::alias_t::name_t& target, const Readable::alias_t::argument_t& argument ) {
+	// Can't alias to itself
+	if ( name == target ) return;
+	this->m_readable.aliases[name].emplace_back( Readable::alias_t{
+		.name = name,
+		.target = target,
+		.argument = argument
+	} );
+}
+void uf::HookHandler::addAlias( const Optimal::alias_t::name_t& name, const Optimal::alias_t::name_t& target, const Optimal::alias_t::argument_t& argument ) {
+	// Can't alias to itself
+	if ( name == target ) return;
+	this->m_optimal.aliases[name].emplace_back( Optimal::alias_t{
+		.name = name,
+		.target = target,
+		.argument = argument
+	} );
+}
+// Is there an alias bound to a hook?
+bool uf::HookHandler::isAlias( const Readable::alias_t::name_t& name ) const {
+	return this->m_readable.aliases.count(name) > 0 || this->m_optimal.aliases.count(name) > 0;
+}
+bool uf::HookHandler::isAliasToReadable( const Readable::alias_t::name_t& name ) const {
+	return this->m_readable.aliases.count(name) > 0;
+}
+bool uf::HookHandler::isAliasToOptimal( const Readable::alias_t::name_t& name ) const {
+	return this->m_optimal.aliases.count(name) > 0;
+}
+
+// Calls a hook in either readable or optimal format (no argument is passed unless it's aliased)
+std::vector<uf::HookHandler::Readable::return_t> uf::HookHandler::call( const Readable::name_t& name ) {
+	struct {
+		std::vector<uf::HookHandler::Readable::return_t> readable;
+		std::vector<uf::HookHandler::Optimal::return_t> optimal;
+	} returns;
+	if ( !this->exists(name) ) return returns.readable;
+
+	returns.readable = this->call(name, Readable::argument_t());
+	returns.optimal = this->call(name, Optimal::argument_t());
+/*
+	if ( typeid(Readable::return_t) == typeid(Optimal::return_t) ) {
+		returns.readable.insert( returns.readable.end(), returns.optimal.begin(), returns.optimal.end() );
+	}
+*/
+	return returns.readable;
+}
+// Calls a hook in readable format
+std::vector<uf::HookHandler::Readable::return_t> uf::HookHandler::call( const Readable::name_t& name, const Readable::argument_t& argument ) {
+	std::vector<uf::HookHandler::Readable::return_t> returns;
+	if ( !this->exists(name) ) return returns;
+	if ( !this->isReadable(name) ) {
+		if ( !this->isAliasToReadable(name) ) return returns;
+		auto& aliases = this->m_readable.aliases.at(name);
+		for ( auto& alias : aliases ) {
+			auto result = this->call( alias.name, (argument != "" ? argument : alias.argument) );
+			returns.insert( returns.end(), result.begin(), result.end() );
+		}
+		return returns;
+	}
+	
+	auto& hooks = this->m_readable.hooks.at(name);
+	for ( auto& hook : hooks ) {
+		try{
+			auto result = hook( argument );
+			returns.push_back(result);
+		} catch ( ... ) {
+			returns.push_back("");
+		}
+	}
+	return returns;
+}
+// Calls a hook in optimal format
+std::vector<uf::HookHandler::Optimal::return_t> uf::HookHandler::call( const Optimal::name_t& name, const Optimal::argument_t& argument ) {
+	std::vector<uf::HookHandler::Optimal::return_t> returns;
+	if ( !this->exists(name) ) return returns;
+	if ( !this->isOptimal(name) ) {
+		if ( !this->isAliasToOptimal(name) ) return returns;
+		auto& aliases = this->m_optimal.aliases.at(name);
+		for ( auto& alias : aliases ) {
+			auto result = this->call( alias.name, (argument ? argument : alias.argument) );
+			returns.insert( returns.end(), result.begin(), result.end() );
+		}
+		return returns;
+	}
+	
+	auto& hooks = this->m_optimal.hooks.at(name);
+	for ( auto& hook : hooks ) {
+		auto result = hook( argument );
+		returns.push_back(result);
+	}
+	return returns;
+}
+/*
+
+// uf::Hook
+UF_API_CALL uf::Hook::Hook( const uf::Hook::name_t& name, const uf::Hook::function_t& func ) : 
+	m_name(name),
+	m_function(func)
+{
+
+}
+
+const uf::Hook::name_t& UF_API_CALL uf::Hook::getName() const {
+	return this->m_name;
+}
+const uf::Hook::function_t& UF_API_CALL uf::Hook::getFunction() const {
+	return this->m_function;
+}
+
+uf::Hook::return_t UF_API_CALL uf::Hook::call( const uf::Hook::argument_t& arg ) {
+	return this->m_function(arg);
+}
+// uf::HookAlias
+UF_API_CALL uf::HookAlias::HookAlias( const uf::HookAlias::name_t& name, const uf::HookAlias::name_t& target, const uf::HookAlias::argument_t& arg ) : 
+	m_name(name),
+	m_target(target),
+	m_argument(arg)
+{
+
+}
+
+const uf::HookAlias::name_t& UF_API_CALL uf::HookAlias::getName() const {
+	return this->m_name;
+}
+const uf::HookAlias::name_t& UF_API_CALL uf::HookAlias::getTarget() const {
+	return this->m_target;
+}
+const uf::HookAlias::argument_t& UF_API_CALL uf::HookAlias::getArgument() const {
+	return this->m_argument;
+}
+// uf::HookHandler
+UF_API_CALL uf::HookHandler::HookHandler() {
+
+}
+
+void UF_API_CALL uf::HookHandler::addHook( const uf::Hook::name_t& name, const uf::Hook::function_t& function ) {
+	uf::HookHandler::vector_t& hooks = this->m_hooks[name];
+	hooks.emplace_back( name, function );
+}
+const uf::HookHandler::map_t& UF_API_CALL uf::HookHandler::getHooks() const {
+	return this->m_hooks;
+}
+const uf::HookHandler::vector_t& UF_API_CALL uf::HookHandler::getHooks( const uf::Hook::name_t& name ) const {
+	static uf::HookHandler::vector_t empty;
+	return !this->hookExists(name) ? empty : this->m_hooks.at(name);
+}
+bool UF_API_CALL uf::HookHandler::hookExists( const uf::Hook::name_t& name ) const {
+	return this->m_hooks.count(name) > 0;
+}
+
+void UF_API_CALL uf::HookHandler::addAlias( const uf::Hook::name_t& name, const uf::Hook::name_t& target, const uf::Hook::argument_t& arg ) {
+	// Can't alias to itself
+	if ( name == target ) return;
+
+	uf::HookHandler::alias_vector_t& aliases = this->m_aliases[name];
+	aliases.emplace_back( name, target, arg );
+}
+const uf::HookHandler::alias_map_t& UF_API_CALL uf::HookHandler::getAliases() const {
+	return this->m_aliases;
+}
+const uf::HookHandler::alias_vector_t& UF_API_CALL uf::HookHandler::getAliases( const uf::Hook::name_t& name ) const {
+	static uf::HookHandler::alias_vector_t empty;
+	return !this->aliasExists(name) ? empty : this->m_aliases.at(name);
+}
+bool UF_API_CALL uf::HookHandler::aliasExists( const uf::Hook::name_t& name ) const {
+	return this->m_aliases.count(name) > 0;
+}
+
+uf::HookHandler::return_vector_t UF_API_CALL uf::HookHandler::call( const uf::Hook::name_t& name, const uf::Hook::argument_t& arg ) {
+	uf::HookHandler::return_vector_t returns;
+
+	if ( !this->hookExists(name) ) {
+		if ( !this->aliasExists(name) ) {
+			return returns;
+		}
+		auto& aliases = this->getAliases(name);
+		for ( auto& alias : aliases ) {
+			uf::HookHandler::return_vector_t toAppend = this->call( alias.getTarget(), arg );
+			returns.insert( returns.end(), toAppend.begin(), toAppend.end() );
+		}
+		return returns;
+	}
+	
+
+	auto& hooks = this->m_hooks.at(name);
+	for ( auto& hook : hooks ) {
+		returns.push_back( hook.call(arg) );
+	}
+
+	return returns;
+}
+
+*/
+#endif
\ No newline at end of file
diff --git a/engine/src/utils/http/http.cpp b/engine/src/utils/http/http.cpp
new file mode 100644
index 00000000..4b64c7e1
--- /dev/null
+++ b/engine/src/utils/http/http.cpp
@@ -0,0 +1,43 @@
+#include <uf/utils/http/http.h>
+#if UF_USE_CURL
+#include <curl/curl.h>
+#endif
+#include <iostream>
+
+namespace {
+	size_t writeFunction(void *ptr, size_t size, size_t nmemb, std::string* data) {
+    	data->append((char*) ptr, size * nmemb);
+    	return size * nmemb;
+	}
+}
+
+uf::Http UF_API uf::http::get( const std::string& url ) {
+	uf::Http http;
+
+#if UF_USE_CURL
+	auto curl = curl_easy_init();
+	if ( !curl ) return http;
+
+	std::cout << curl << " " << url << std::endl;
+	curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
+	curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1L);
+//	curl_easy_setopt(curl, CURLOPT_USERPWD, "user:pass");
+	curl_easy_setopt(curl, CURLOPT_USERAGENT, "curl/7.42.0");
+	curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 50L);
+	curl_easy_setopt(curl, CURLOPT_TCP_KEEPALIVE, 1L);
+	curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
+	curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writeFunction);
+	curl_easy_setopt(curl, CURLOPT_WRITEDATA, &http.response);
+	curl_easy_setopt(curl, CURLOPT_HEADERDATA, &http.header);
+
+	curl_easy_perform(curl);
+	
+	curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http.code);
+	curl_easy_getinfo(curl, CURLINFO_TOTAL_TIME, &http.elapsed);
+	curl_easy_getinfo(curl, CURLINFO_EFFECTIVE_URL, &http.effective);
+
+	curl_easy_cleanup(curl);
+	curl = NULL;
+#endif
+    return http;
+}
\ No newline at end of file
diff --git a/engine/src/utils/image/atlas.cpp b/engine/src/utils/image/atlas.cpp
new file mode 100644
index 00000000..a2bfe53a
--- /dev/null
+++ b/engine/src/utils/image/atlas.cpp
@@ -0,0 +1,301 @@
+#include <uf/utils/image/atlas.h>
+#include <iostream>
+
+void uf::Atlas::addImage( const uf::Image& _image, bool regenerate ) {
+	auto& image = this->m_images.emplace_back( _image );
+	if ( regenerate ) this->generate();
+}
+void uf::Atlas::addImage( uf::Image&& _image, bool regenerate ) {
+	auto& image = this->m_images.emplace_back( _image );
+	if ( regenerate ) this->generate();
+}
+void uf::Atlas::addImage( const uint8_t* pointer, const pod::Vector2ui& size, std::size_t bpp, std::size_t channels, bool flip, bool regenerate ) {
+	auto& image = this->m_images.emplace_back();
+	image.loadFromBuffer( pointer, size, bpp, channels, flip );
+	if ( regenerate ) this->generate();
+
+}
+void uf::Atlas::generate( float padding ) {
+	return generate( this->m_images, padding );
+}
+void uf::Atlas::generate( const uf::Atlas::images_t& images, float padding ) {
+	if ( images.empty() ) return;
+	// destroy atlas
+	this->m_image.clear();
+
+	BinPack2D::ContentAccumulator<uf::Atlas::identifier_t> queue;
+	pod::Vector2ui size = {0,0};
+	pod::Vector3ui largest = {0,0,0};
+	size_t index = 0;
+	size_t area = 0;
+	for ( auto& image : images ) {
+		auto& dim = image.getDimensions();
+		queue += BinPack2D::Content<uf::Atlas::identifier_t>({index++}, BinPack2D::Coord(), BinPack2D::Size(dim.x, dim.y), false );
+		size += dim;
+		area += dim.x * dim.y;
+		if ( area >= largest.z ) {
+			largest.x = dim.x;
+			largest.y = dim.y;
+		}
+	}
+	size_t tries = 16;
+	BinPack2D::ContentAccumulator<uf::Atlas::identifier_t> stored, remainder;
+	do {
+		{
+		//	size_t area = largest.x * largest.y * images.size();
+			size_t side = std::sqrt( area ) * padding;
+			size = { side, side };
+			{
+				size.x--;
+				size.x |= size.x >> 1;
+				size.x |= size.x >> 2;
+				size.x |= size.x >> 4;
+				size.x |= size.x >> 8;
+				size.x |= size.x >> 16;
+				size.x++;
+				size.y--;
+				size.y |= size.y >> 1;
+				size.y |= size.y >> 2;
+				size.y |= size.y >> 4;
+				size.y |= size.y >> 8;
+				size.y |= size.y >> 16;
+				size.y++;
+			}
+		}
+		queue.Sort();
+		this->m_atlas = BinPack2D::UniformCanvasArrayBuilder<uf::Atlas::identifier_t>(size.x, size.y, 1).Build();
+		bool success = this->m_atlas.Place( queue, remainder );
+		if ( success && remainder.Get().empty() ) break;
+		// increase padding
+		padding += 0.10f;
+	} while ( --tries );
+	this->m_image.loadFromBuffer( NULL, size, 8, 4 );
+	this->m_atlas.CollectContent( stored );
+
+	auto& dstBuffer = this->m_image.getPixels();
+
+	for ( size_t i = 0; i < size.x * size.y * 4; i+=4 ) {
+		dstBuffer[i+0] = 0;
+		dstBuffer[i+1] = 0;
+		dstBuffer[i+2] = 0;
+		dstBuffer[i+3] = 0;
+	}
+
+	for ( auto& it : stored.Get() ) {
+		size_t index = it.content.index;
+		auto& image = images[index];
+		auto& dim = image.getDimensions();
+		auto channels = image.getChannels();
+		auto& srcBuffer = image.getPixels();
+
+		for ( size_t y = 0; y < dim.y; ++y ) {
+		for ( size_t x = 0; x < dim.x; ++x ) {
+			size_t src = (y *  dim.x * channels) + (x * channels);
+			size_t dst = ((y + it.coord.y) * size.x * 4) + ((x + it.coord.x) * 4);
+			for ( size_t i = 0; i < channels; ++i ) {
+				dstBuffer[dst+i] = srcBuffer[src+i];
+			}
+		}
+		}
+	}
+}
+void uf::Atlas::clear() {
+	this->m_images.clear();
+	this->m_image.clear();
+	this->m_atlas = uf::Atlas::atlas_t{};
+}
+pod::Vector2f uf::Atlas::mapUv( const pod::Vector2f& uv, size_t index ) {
+	BinPack2D::ContentAccumulator<uf::Atlas::identifier_t> stored;
+	this->m_atlas.CollectContent( stored );
+	auto& size = this->m_image.getDimensions();
+	for ( auto& it : stored.Get() ) {
+		if ( it.content.index != index ) continue;
+		pod::Vector2ui dim = { it.size.w, it.size.h };
+		pod::Vector2f nuv = uv;
+		if ( nuv.x > 1.0f ) nuv.x = std::fmod( nuv.x, 1.0f );
+		if ( nuv.y > 1.0f ) nuv.y = std::fmod( nuv.y, 1.0f );
+
+		pod::Vector2ui coord = { uv.x * dim.x + it.coord.x, uv.y * dim.y + it.coord.y };
+		nuv = { (float) coord.x / (float) size.x, (float) coord.y / (float) size.y };
+		// nuv.y = 1.0f - nuv.y;
+		return nuv;
+	}
+	//	std::cout << "Could not find requested index of " << index << std::endl;
+	return uv;
+}
+pod::Vector3f uf::Atlas::mapUv( const pod::Vector3f& uv ) {
+	pod::Vector2f nuv = mapUv( { uv.x, uv.y }, uv.z );
+	return { nuv.x, nuv.y, uv.z };
+}
+uf::Image& uf::Atlas::getAtlas() {
+	return this->m_image;
+}
+uf::Atlas::images_t& uf::Atlas::getImages() {
+	return this->m_images;
+}
+const uf::Atlas::images_t& uf::Atlas::getImages() const {
+	return this->m_images;
+}
+
+
+
+
+
+
+
+
+
+#include <uf/utils/image/atlas.h>
+#include <iostream>
+
+uf::HashAtlas::hash_t uf::HashAtlas::addImage( const uf::Image& _image, bool regenerate ) {
+	auto hash = _image.getHash();
+	if ( this->has( hash ) ) return hash;
+
+	auto& image = *(this->m_images.emplace(hash, _image)).first;
+	if ( regenerate ) this->generate();
+
+	return hash;
+}
+uf::HashAtlas::hash_t uf::HashAtlas::addImage( uf::Image&& _image, bool regenerate ) {
+	auto hash = _image.getHash();
+	if ( this->has( hash ) ) return hash;
+
+	auto& image = *(this->m_images.emplace(hash, _image)).first;
+	if ( regenerate ) this->generate();
+	
+	return hash;
+}
+uf::HashAtlas::hash_t uf::HashAtlas::addImage( const uint8_t* pointer, const pod::Vector2ui& size, std::size_t bpp, std::size_t channels, bool flip, bool regenerate ) {
+	uf::Image image;
+	image.loadFromBuffer( pointer, size, bpp, channels, flip );
+	std::string hash = image.getHash();
+	if ( this->has( hash ) ) return hash;
+	this->m_images.emplace( hash, std::move(image) );
+	if ( regenerate ) this->generate();
+	return hash;
+
+}
+bool uf::HashAtlas::has( const uf::Image& image ) const {
+	return this->has( image.getHash() );
+}
+bool uf::HashAtlas::has( const std::string& hash ) const {
+	return this->m_images.count(hash) > 0;
+}
+void uf::HashAtlas::generate( float padding ) {
+	return generate( this->m_images, padding );
+}
+void uf::HashAtlas::generate( const uf::HashAtlas::images_t& images, float padding ) {
+	if ( images.empty() ) return;
+	// destroy atlas
+	this->m_image.clear();
+
+	BinPack2D::ContentAccumulator<uf::HashAtlas::identifier_t> queue;
+	pod::Vector2ui size = {0,0};
+	pod::Vector3ui largest = {0,0,0};
+	size_t index = 0;
+	size_t area = 0;
+	for ( auto& pair : images ) {
+		auto hash = pair.first;
+		auto& dim = pair.second.getDimensions();
+		queue += BinPack2D::Content<uf::HashAtlas::identifier_t>({hash}, BinPack2D::Coord(), BinPack2D::Size(dim.x, dim.y), false );
+		size += dim;
+		area += dim.x * dim.y;
+		if ( area >= largest.z ) {
+			largest.x = dim.x;
+			largest.y = dim.y;
+		}
+	}
+	size_t tries = 16;
+	BinPack2D::ContentAccumulator<uf::HashAtlas::identifier_t> stored, remainder;
+	do {
+		{
+		//	size_t area = largest.x * largest.y * images.size();
+			size_t side = std::sqrt( area ) * padding;
+			size = { side, side };
+			{
+				size.x--;
+				size.x |= size.x >> 1;
+				size.x |= size.x >> 2;
+				size.x |= size.x >> 4;
+				size.x |= size.x >> 8;
+				size.x |= size.x >> 16;
+				size.x++;
+				size.y--;
+				size.y |= size.y >> 1;
+				size.y |= size.y >> 2;
+				size.y |= size.y >> 4;
+				size.y |= size.y >> 8;
+				size.y |= size.y >> 16;
+				size.y++;
+			}
+		}
+		queue.Sort();
+		this->m_atlas = BinPack2D::UniformCanvasArrayBuilder<uf::HashAtlas::identifier_t>(size.x, size.y ,1).Build();
+		bool success = this->m_atlas.Place( queue, remainder );
+		if ( success && remainder.Get().empty() ) break;
+		// increase padding
+		padding += 0.10f;
+	} while ( --tries );
+	this->m_image.loadFromBuffer( NULL, size, 8, 4 );
+	this->m_atlas.CollectContent( stored );
+
+	auto& dstBuffer = this->m_image.getPixels();
+
+	for ( size_t i = 0; i < size.x * size.y * 4; i+=4 ) {
+		dstBuffer[i+0] = 0;
+		dstBuffer[i+1] = 0;
+		dstBuffer[i+2] = 0;
+		dstBuffer[i+3] = 0;
+	}
+
+	for ( auto& it : stored.Get() ) {
+		auto& hash = it.content.hash;
+		auto& image = images.at(hash);
+		auto& dim = image.getDimensions();
+		auto channels = image.getChannels();
+		auto& srcBuffer = image.getPixels();
+
+		for ( size_t y = 0; y < dim.y; ++y ) {
+		for ( size_t x = 0; x < dim.x; ++x ) {
+			size_t src = (y *  dim.x * channels) + (x * channels);
+			size_t dst = ((y + it.coord.y) * size.x * 4) + ((x + it.coord.x) * 4);
+			for ( size_t i = 0; i < channels; ++i ) {
+				dstBuffer[dst+i] = srcBuffer[src+i];
+			}
+		}
+		}
+	}
+}
+void uf::HashAtlas::clear() {
+	this->m_images.clear();
+	this->m_image.clear();
+	this->m_atlas = uf::HashAtlas::atlas_t{};
+}
+pod::Vector2f uf::HashAtlas::mapUv( const pod::Vector2f& uv, const uf::HashAtlas::hash_t& hash ) {
+	BinPack2D::ContentAccumulator<uf::HashAtlas::identifier_t> stored;
+	this->m_atlas.CollectContent( stored );
+	auto& size = this->m_image.getDimensions();
+	for ( auto& it : stored.Get() ) {
+		if ( it.content.hash != hash ) continue;
+		pod::Vector2ui dim = { it.size.w, it.size.h };
+		pod::Vector2f nuv = uv;
+		if ( nuv.x > 1.0f ) nuv.x = std::fmod( nuv.x, 1.0f );
+		if ( nuv.y > 1.0f ) nuv.y = std::fmod( nuv.y, 1.0f );
+
+		pod::Vector2ui coord = { uv.x * dim.x + it.coord.x, uv.y * dim.y + it.coord.y };
+		nuv = { (float) coord.x / (float) size.x, (float) coord.y / (float) size.y };
+		nuv.y = 1.0f - nuv.y;
+		return nuv;
+	}
+	return uv;
+}
+uf::Image& uf::HashAtlas::getAtlas() {
+	return this->m_image;
+}
+uf::HashAtlas::images_t& uf::HashAtlas::getImages() {
+	return this->m_images;
+}
+const uf::HashAtlas::images_t& uf::HashAtlas::getImages() const {
+	return this->m_images;
+}
\ No newline at end of file
diff --git a/engine/src/utils/image/image.cpp b/engine/src/utils/image/image.cpp
new file mode 100644
index 00000000..37a7d3a9
--- /dev/null
+++ b/engine/src/utils/image/image.cpp
@@ -0,0 +1,409 @@
+#include <uf/utils/image/image.h>
+#include <uf/utils/string/ext.h>
+#include <uf/utils/string/hash.h>
+#include <uf/utils/io/iostream.h>
+#include <fstream> 					// std::fstream
+#include <iostream> 				// std::fstream
+#include <png/png.h> 				// libpng
+
+#define STB_IMAGE_IMPLEMENTATION
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#include <gltf/stb_image.h>
+#include <gltf/stb_image_write.h>
+
+// 	C-tor
+// Default
+uf::Image::Image() :
+	m_bpp(8),
+	m_channels(4) {
+
+}
+// Just Size
+uf::Image::Image( const Image::vec2_t& size ) :
+	m_dimensions(size),
+	m_bpp(8),
+	m_channels(4)
+{
+	this->m_pixels.reserve(size.x*size.y*this->m_channels);
+}
+// Move pixels
+uf::Image::Image( Image&& move ) : 
+	m_pixels(std::move(move.m_pixels)),
+	m_dimensions(std::move(move.m_dimensions)),
+	m_bpp(move.m_bpp),
+	m_channels(move.m_channels),
+	m_filename(move.m_filename)
+{
+
+}
+// Copy pixels
+uf::Image::Image( const Image& copy ) :
+	m_pixels(copy.m_pixels),
+	m_dimensions(copy.m_dimensions),
+	m_bpp(copy.m_bpp),
+	m_channels(copy.m_channels),
+	m_filename(copy.m_filename)
+{
+
+}
+// Move from vector of pixels
+uf::Image::Image( Image::container_t&& move, const Image::vec2_t& size ) :
+	m_pixels(std::move(move)),
+	m_dimensions(size),
+	m_bpp(8),
+	m_channels(4)
+{
+
+}
+// Copy from vector of pixels
+uf::Image::Image( const Image::container_t& copy, const Image::vec2_t& size ) :
+	m_pixels(copy),
+	m_dimensions(size),
+	m_bpp(8),
+	m_channels(4)
+{
+
+}
+
+std::string uf::Image::getFilename() const {
+	return this->m_filename;
+}
+
+// from file
+bool uf::Image::open( const std::string& filename, bool flip ) {
+	if ( !uf::io::exists(filename) ) UF_EXCEPTION("does not exist: " + filename);
+	std::string extension = uf::io::extension(filename);
+	this->m_filename = filename;
+	this->m_pixels.clear();
+	int width, height, channels, bit_depth;
+	bit_depth = 8;
+	stbi_set_flip_vertically_on_load(flip);
+	uint8_t* buffer = stbi_load( filename.c_str(), &width, &height, &channels, STBI_rgb_alpha );
+	
+	channels = 4;
+	uint len = width * height * channels;
+	this->m_dimensions.x = width;
+	this->m_dimensions.y = height;
+	this->m_bpp = bit_depth * channels;
+	this->m_channels = channels;
+	this->m_pixels.insert( this->m_pixels.end(), (uint8_t*) buffer, buffer + len );
+	stbi_image_free(buffer);
+	return true;
+}
+void uf::Image::loadFromBuffer( const Image::pixel_t::type_t* pointer, const pod::Vector2ui& size, std::size_t bit_depth, std::size_t channels, bool flip ) {
+	this->m_dimensions = size;
+	this->m_bpp = bit_depth * channels;
+	this->m_channels = channels;
+
+	size_t len = size.x * size.y * channels;
+	this->m_pixels.clear();
+	this->m_pixels.resize( len );
+
+	if ( pointer ) memcpy( &this->m_pixels[0], pointer, len );
+	else memset( &this->m_pixels[0], 0, len );
+
+	if ( flip ) this->flip();
+}
+void uf::Image::loadFromBuffer( const Image::container_t& container, const pod::Vector2ui& size, std::size_t bit_depth, std::size_t channels, bool flip ) {
+	this->m_dimensions = size;
+	this->m_bpp = bit_depth * channels;
+	this->m_channels = channels;
+	this->m_pixels = container;
+
+	if ( flip ) this->flip();
+}
+void uf::Image::flip() {
+	auto w = this->m_dimensions.x;
+	auto h = this->m_dimensions.y;
+	uint8_t* pixels = &this->m_pixels[0];
+	for (uint j = 0; j * 2 < h; ++j) {
+		uint x = j * w * this->m_bpp/8;
+		uint y = (h - 1 - j) * w * this->m_bpp/8;
+		for (uint i = w * this->m_bpp/8; i > 0; --i) {
+			std::swap( pixels[x], pixels[y] );
+			++x, ++y;
+		}
+	}
+}
+void uf::Image::padToPowerOfTwo(  ) {
+	pod::Vector2ui next = {
+		this->m_dimensions.x,
+		this->m_dimensions.y
+	}; {
+		next.x--;
+		next.x |= next.x >> 1;
+		next.x |= next.x >> 2;
+		next.x |= next.x >> 4;
+		next.x |= next.x >> 8;
+		next.x |= next.x >> 16;
+		next.x++;
+		next.y--;
+		next.y |= next.y >> 1;
+		next.y |= next.y >> 2;
+		next.y |= next.y >> 4;
+		next.y |= next.y >> 8;
+		next.y |= next.y >> 16;
+		next.y++;
+	}
+	// no point in repadding
+	if ( this->m_dimensions.x == next.x && this->m_dimensions.y == next.y ) {
+		return;
+	}
+
+	uint len = next.x * next.y * this->m_bpp / 8;
+	uint8_t* buffer = new uint8_t[len];
+	for ( size_t i = 0; i < len; ++i ) buffer[i] = 0;
+
+	for ( size_t y = 0; y < this->m_dimensions.y; ++y ) {
+	for ( size_t x = 0; x < this->m_dimensions.x; ++x ) {
+		size_t src = x * this->m_channels + this->m_dimensions.x * this->m_channels * y;
+		size_t dst = x * this->m_channels + next.x * this->m_channels * y;
+		for ( size_t i = 0; i < this->m_channels; ++i ) {
+			buffer[dst+i] = this->m_pixels[src+i];
+		}
+	}
+	}
+
+	this->m_dimensions.x = next.x;
+	this->m_dimensions.y = next.y;
+
+	this->m_pixels.clear();
+	this->m_pixels.insert( this->m_pixels.end(), (uint8_t*) buffer, buffer + len );
+	delete[] buffer;
+}
+// from stream
+void uf::Image::open( const std::istream& stream ) {
+	// ?
+}
+// move from vector of pixels
+void uf::Image::move( Image::container_t&& move, const Image::vec2_t& size ) {
+	this->m_pixels = std::move(move);
+	this->m_dimensions = size;
+}
+// copy from vector of pixels
+void uf::Image::copy( const Image::container_t& copy, const Image::vec2_t& size ) {
+	this->m_pixels = copy;
+	this->m_dimensions = size;
+}
+void uf::Image::copy( const uf::Image& copy ) {
+	this->m_pixels = copy.m_pixels;
+	this->m_dimensions = copy.m_dimensions;
+	this->m_bpp = copy.m_bpp;
+	this->m_channels = copy.m_channels;
+	this->m_filename = copy.m_filename;
+}
+// 	D-tor
+uf::Image::~Image() {
+	this->clear();
+}
+// empties pixel container
+void uf::Image::clear() {
+	this->m_pixels.clear();
+}
+uf::Image::container_t& uf::Image::getPixels() {
+	return this->m_pixels;	
+}
+const uf::Image::container_t& uf::Image::getPixels() const {
+	return this->m_pixels;	
+}
+uf::Image::pixel_t::type_t* uf::Image::getPixelsPtr() {
+//	return (this->m_pixels.empty() ? NULL : &this->m_pixels[0]);
+	return ( this->m_pixels.empty() ) ? NULL : &this->m_pixels[0];
+}
+const uf::Image::pixel_t::type_t* uf::Image::getPixelsPtr() const {
+//	return (this->m_pixels.empty() ? NULL : &this->m_pixels[0]);
+	return ( this->m_pixels.empty() ) ? NULL : &this->m_pixels[0];
+}
+uf::Image::vec2_t& uf::Image::getDimensions() {
+	return this->m_dimensions;
+}
+const uf::Image::vec2_t& uf::Image::getDimensions() const {
+	return this->m_dimensions;
+}
+std::size_t& uf::Image::getBpp() {
+	return this->m_bpp;
+}
+std::size_t uf::Image::getBpp() const {
+	return this->m_bpp;
+}
+std::size_t& uf::Image::getChannels() {
+	return this->m_channels;
+}
+std::size_t uf::Image::getChannels() const {
+	return this->m_channels;
+}
+std::string uf::Image::getHash() const {
+	return uf::string::sha256( this->m_pixels );
+}
+uf::Image::pixel_t uf::Image::at( const uf::Image::vec2_t& at ) {
+	std::size_t i = at.x * this->m_channels + this->m_dimensions.x*this->m_channels*at.y;
+	uf::Image::pixel_t pixel;
+	pixel.r = this->m_pixels[i++];
+	pixel.g = this->m_pixels[i++];
+	pixel.b = this->m_pixels[i++];
+	pixel.a = this->m_pixels[i++];
+	return pixel;
+}
+// 	Modifiers
+// to file
+bool uf::Image::save( const std::string& filename, bool flip ) const {
+	uint w = this->m_dimensions.x;
+	uint h = this->m_dimensions.y;
+	auto* pixels = &this->m_pixels[0];
+	std::string extension = uf::io::extension(filename);
+	stbi_flip_vertically_on_write(flip);
+	if ( extension == "png" ) {
+	#if 0
+		if ( flip )
+			for (uint j = 0; j * 2 < h; ++j) {
+				uint x = j * w * this->m_bpp/8;
+				uint y = (h - 1 - j) * w * this->m_bpp/8;
+				for (uint i = w * this->m_bpp/8; i > 0; --i) {
+					std::swap( pixels[x], pixels[y] );
+					++x, ++y;
+				}
+			}
+	#endif
+	#if 0
+		png_structp png = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+		if (!png)
+			return false;
+
+		png_infop info = png_create_info_struct(png);
+		if (!info) {
+			png_destroy_write_struct(&png, &info);
+			return false;
+		}
+
+		FILE *fp = fopen(filename.c_str(), "wb");
+		if (!fp) {
+			png_destroy_write_struct(&png, &info);
+			return false;
+		}
+
+		png_init_io(png, fp);
+		png_set_IHDR(png, info, w, h, 8 /* depth */, PNG_COLOR_TYPE_RGBA, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
+		if ( this->m_channels == 4 ) png_set_IHDR(png, info, w, h, 8 /* depth */, PNG_COLOR_TYPE_RGBA, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
+		if ( this->m_channels == 3 ) png_set_IHDR(png, info, w, h, 8 /* depth */, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
+		png_colorp palette = (png_colorp)png_malloc(png, PNG_MAX_PALETTE_LENGTH * sizeof(png_color));
+		if (!palette) {
+			fclose(fp);
+			png_destroy_write_struct(&png, &info);
+			return false;
+		}
+		png_set_PLTE(png, info, palette, PNG_MAX_PALETTE_LENGTH);
+		png_write_info(png, info);
+		png_set_packing(png);
+
+		png_bytepp rows = (png_bytepp)png_malloc(png, h * sizeof(png_bytep));
+		for (uint i = 0; i < h; ++i)
+			rows[i] = (png_bytep)(pixels + (h - i - 1) * w * this->m_bpp/8);
+
+		png_write_image(png, rows);
+		png_write_end(png, info);
+		png_free(png, palette);
+		png_destroy_write_struct(&png, &info);
+
+		fclose(fp);
+		delete[] rows;
+	#endif
+		stbi_write_png(filename.c_str(), w, h, this->m_channels, &pixels[0], w * this->m_channels);
+	} else if ( extension == "jpg" || extension == "jpeg" ) {
+		stbi_write_jpg(filename.c_str(), w, h, this->m_channels, &pixels[0], w * this->m_channels);
+	}
+	return true;
+}
+// to stream
+void uf::Image::save( std::ostream& stream ) const {
+
+}
+#include <uf/utils/string/ext.h>
+void uf::Image::convert( const std::string& from, const std::string& to ) {
+	uf::Image::container_t pixels = std::move(this->m_pixels);
+	if ( uf::string::lowercase(to) != "rgba" ) {
+	} else {
+		this->m_pixels.reserve(this->m_dimensions.x * this->m_dimensions.y * 4);
+		for ( size_t i = 0; i < this->m_dimensions.x * this->m_dimensions.y * this->m_channels; i += this->m_channels ) {
+			if ( uf::string::lowercase(from) == "r" ) {
+				this->m_pixels.emplace_back( pixels[i] );
+				this->m_pixels.emplace_back( pixels[i] );
+				this->m_pixels.emplace_back( pixels[i] );
+				this->m_pixels.emplace_back( 0xFF );
+			} else if ( uf::string::lowercase(from) == "ra" ) {
+				this->m_pixels.emplace_back( pixels[i+0] );
+				this->m_pixels.emplace_back( pixels[i+0] );
+				this->m_pixels.emplace_back( pixels[i+0] );
+				this->m_pixels.emplace_back( pixels[i+1] );
+			} else if ( uf::string::lowercase(from) == "rgba" ) {
+				this->m_pixels.emplace_back( pixels[i+0] );
+				this->m_pixels.emplace_back( pixels[i+1] );
+				this->m_pixels.emplace_back( pixels[i+2] );
+				this->m_pixels.emplace_back( 0xFF );
+			}
+		}
+	}
+	if ( !this->m_pixels.empty() ) {
+		this->m_channels = 4;
+		this->m_bpp = 8 * this->m_channels;
+	} else {
+		this->m_pixels = std::move(pixels);
+	}
+}
+// Merges one image on top of another
+uf::Image uf::Image::overlay(const Image& top, const Image::vec2_t& corner) const {
+	return *this;
+}
+// Changes all pixel from one color (from), to another (to)
+uf::Image uf::Image::replace(const Image::pixel_t& from, const Image::pixel_t& to ) const {
+	return *this;
+}
+// Crops an image
+uf::Image uf::Image::subImage( const Image::vec2_t& start, const Image::vec2_t& end) const {
+	return *this;
+/*
+	uf::Vector2ui size = parameter;
+	if ( mode == uf::Image::CropMode::START_SPAN_SIZE ) size = parameter;
+	if ( mode == uf::Image::CropMode::START_TO_END ) size = parameter - start;
+	if ( size > this->size ) return uf::Image(*this);
+
+
+	uint len = size.product() * this->bpp / 8;
+	uint8_t* src = (uint8_t*) this->raw;
+	uint8_t* dst = new uint8_t[len];
+
+	uint minX = start.x();
+	uint minY = start.y();
+	uint dstWidth = size.x();
+	uint dstHeight = size.x();
+	uint srcWidth = this->size.x();
+	uint srcHeight = this->size.y();
+
+	for(uint x = minX; x < dstWidth + minX; x++) {
+		for(uint y = minY; y < dstHeight + minY; y++) {
+			uint srcOffset = y * srcWidth + x;
+			uint dstOffset = (y - minY) * dstWidth + (x - minX);
+			srcOffset *= this->bpp / 8;
+			dstOffset *= this->bpp / 8;
+
+			for ( uint i = 0; i < this->bpp/4; i++ ) dst[dstOffset+i] = src[srcOffset+i];
+		}
+	}
+
+	uf::Image image;
+	image.raw = (uint8_t*) dst;
+	image.len = len;
+	image.bpp = this->bpp;
+	image.size = size;
+	image.format = this->format;
+	return image;
+*/
+}
+
+uf::Image& uf::Image::operator=( const uf::Image& copy ) {
+	this->m_pixels = copy.m_pixels;
+	this->m_dimensions = copy.m_dimensions;
+	this->m_bpp = copy.m_bpp;
+	this->m_channels = copy.m_channels;
+	this->m_filename = copy.m_filename;
+	return *this;
+}
\ No newline at end of file
diff --git a/engine/src/utils/io/file.cpp b/engine/src/utils/io/file.cpp
new file mode 100644
index 00000000..7c8da37f
--- /dev/null
+++ b/engine/src/utils/io/file.cpp
@@ -0,0 +1,167 @@
+#include <uf/utils/io/file.h>
+#include <uf/utils/string/ext.h>
+#include <uf/utils/string/hash.h>
+
+#include <sys/stat.h>
+#include <algorithm>
+#include <iostream>
+#include <fstream>
+#include <uf/utils/io/file.h>
+#include <uf/utils/io/iostream.h>
+
+#ifdef WINDOWS
+	#include <direct.h>
+	#define GetCurrentDir _getcwd
+#else
+	#include <unistd.h>
+	#define GetCurrentDir getcwd
+#endif
+
+const std::string uf::io::root = UF_IO_ROOT;
+
+std::string UF_API uf::io::absolute( const std::string& path ) {
+	char buff[FILENAME_MAX];
+	GetCurrentDir( buff, FILENAME_MAX );
+	return std::string(buff) + path;
+}
+std::string UF_API uf::io::filename( const std::string& str ) {
+	return str.substr( str.find_last_of('/') + 1 );
+}
+std::string UF_API uf::io::basename( const std::string& filename ) {
+	std::string str = uf::io::filename( filename );
+	std::string extension = uf::io::extension( filename );
+	return uf::string::replace( str, "." + extension, "" );
+}
+std::string UF_API uf::io::extension( const std::string& str ) {
+	std::string filename = uf::io::filename(str);
+	return filename.substr( filename.find_last_of('.') + 1 );
+}
+std::string UF_API uf::io::extension( const std::string& str, int32_t count ) {
+	std::string filename = uf::io::filename(str);
+	std::string extension = "";
+	auto split = uf::string::split( filename, "." );
+	size_t offset = split.size() - 1;
+	if ( count < 0 ) {
+		offset = -count;
+	} else {
+		offset = split.size() - count;
+	}
+	for ( size_t i = offset; i < split.size(); ++i ) {
+		extension += split[i];
+		if ( i + 1 < split.size() ) extension += ".";
+	}
+	return extension;
+}
+std::string UF_API uf::io::directory( const std::string& str ) {
+	return str.substr( 0, str.find_last_of('/') ) + "/";
+}
+std::string UF_API uf::io::sanitize( const std::string& str, const std::string& _root ) {
+	// resolve %root% to hard root
+	std::string path = str;
+	std::string root = _root;
+	// append root to path
+	if ( path.find("%root%") == 0 ) {
+		path = uf::string::replace( path, "%root%", "" );
+		if ( root == "" ) root = uf::io::root;
+	}
+	if ( path.find(root) == std::string::npos ) {
+		path = root + "/" + path;
+	}
+	// flatten all "/./"
+	{
+		std::string tmp;
+		while ( path != (tmp = uf::string::replace(path, "/./", "/")) ) {
+			path = tmp;
+		}
+	}
+	// flatten all "//"
+	{
+		std::string tmp;
+		while ( path != (tmp = uf::string::replace(path, "//", "/")) ) {
+			path = tmp;
+		}
+	}
+	return path;
+}
+std::string UF_API uf::io::readAsString( const std::string& _filename, const std::string& hash ) {
+	std::string filename = sanitize(_filename);
+	std::string buffer;
+	std::ifstream is(filename, std::ios::binary | std::ios::in | std::ios::ate);
+	if ( !is.is_open() ) {
+		uf::iostream << "Error: Could not open file \"" << filename << "\"" << "\n";
+		return buffer;
+	}
+	is.seekg(0, std::ios::end); buffer.reserve(is.tellg()); is.seekg(0, std::ios::beg);
+	buffer.assign((std::istreambuf_iterator<char>(is)), std::istreambuf_iterator<char>());
+	std::string expected = "";
+	if ( hash != "" && (expected = uf::string::sha256( buffer )) != hash ) {
+		uf::iostream << "Error: Hash mismatch for file \"" << filename << "\"; expecting " << hash << ", got " << expected << "\n";
+		return "";
+	}
+	return buffer;
+}
+std::vector<uint8_t> UF_API uf::io::readAsBuffer( const std::string& filename, const std::string& hash ) {
+	std::vector<uint8_t> buffer;
+	std::ifstream is(filename, std::ios::binary | std::ios::in | std::ios::ate);
+	if ( !is.is_open() ) {
+		uf::iostream << "Error: Could not open file \"" << filename << "\"" << "\n";
+		return buffer;
+	}
+	is.seekg(0, std::ios::end); buffer.reserve(is.tellg()); is.seekg(0, std::ios::beg);
+	buffer.assign((std::istreambuf_iterator<char>(is)), std::istreambuf_iterator<char>());
+	std::string expected = "";
+	if ( hash != "" && (expected = uf::string::sha256( buffer )) != hash ) {
+		uf::iostream << "Error: Hash mismatch for file \"" << filename << "\"; expecting " << hash << ", got " << expected << "\n";
+		return std::vector<uint8_t>();
+	}
+	return buffer;
+}
+std::string UF_API uf::io::hash( const std::string& filename ) {
+	return uf::string::sha256( uf::io::readAsBuffer( filename ) );
+}
+bool UF_API uf::io::exists( const std::string& _filename ) {
+	std::string filename = sanitize(_filename);
+	static struct stat buffer;
+	return stat(filename.c_str(), &buffer) == 0;
+}
+size_t UF_API uf::io::mtime( const std::string& _filename ) {
+	std::string filename = sanitize(_filename);
+	static struct stat buffer;
+	if ( stat(filename.c_str(), &buffer) != 0 ) return -1;
+	return buffer.st_mtime;
+}
+bool UF_API uf::io::mkdir( const std::string& _filename ) {
+#if UF_ENV_DREAMCAST
+	return false;
+#else
+	std::string filename = sanitize(_filename);
+	int status = ::mkdir(filename.c_str());
+	return status != -1;
+#endif
+}
+std::string UF_API uf::io::resolveURI( const std::string& filename, const std::string& _root ) {
+	std::string root = _root;
+	if ( filename.substr(0,8) == "https://" ) return filename;
+	std::string extension = uf::io::extension(filename);
+	// just sanitize
+	if ( filename.find(uf::io::root) == 0 )
+		return uf::io::sanitize( uf::io::filename( filename ), uf::io::directory( filename ) );
+	if ( filename.find("%root%") == 0 ) {
+		std::string f = uf::string::replace( filename, "%root%", uf::io::root );
+		return uf::io::sanitize( uf::io::filename( f ), uf::io::directory( f ) );
+	}
+	// if the filename contains an absolute path or if no root is provided
+	if ( filename[0] == '/' || root == "" ) {
+		if ( filename.substr(0,9) == "/smtsamo/" ) root = uf::io::root;
+		else if ( uf::io::extension(filename, -1) == "graph.json" ) root = uf::io::root + "/models/";
+		else if ( extension == "json" ) root = uf::io::root + "/entities/";
+		else if ( extension == "png" ) root = uf::io::root + "/textures/";
+		else if ( extension == "glb" ) root = uf::io::root + "/models/";
+		else if ( extension == "gltf" ) root = uf::io::root + "/models/";
+		else if ( extension == "graph" ) root = uf::io::root + "/models/";
+		else if ( extension == "ogg" ) root = uf::io::root + "/audio/";
+		else if ( extension == "spv" ) root = uf::io::root + "/shaders/";
+		else if ( extension == "lua" ) root = uf::io::root + "/scripts/";
+	}
+	return uf::io::sanitize(filename, root);
+}
\ No newline at end of file
diff --git a/engine/src/utils/io/iostream.cpp b/engine/src/utils/io/iostream.cpp
new file mode 100644
index 00000000..04c6e49f
--- /dev/null
+++ b/engine/src/utils/io/iostream.cpp
@@ -0,0 +1,703 @@
+#define _X_OPEN_SOURCE_EXTENDED
+#include <uf/utils/io/iostream.h>
+
+#if UF_USE_NCURSES
+#include <uf/ext/ncurses/ncurses.h>
+#include <ncursesw/ncurses.h>
+#endif
+#include <uf/spec/terminal/terminal.h>
+
+#include <sstream>
+#include <iostream>
+
+#include <vector>
+
+namespace {
+	struct {
+		int character;
+		std::string temporary;
+		struct {
+			std::string buffer;
+			std::vector<std::string> history;
+		} input, output;
+		struct {
+			unsigned int buffer = 0;
+			unsigned int history = -1;
+		} indices;
+		struct {
+			int rows = 0;
+			int columns = 0;
+		} window;
+		struct {
+			int row = 0;
+			int column = 0;
+		} cursor, origin;
+		struct {
+			short last = 0;
+		} color;
+	} info;
+	void addCh( char ch ) {
+		if ( ch == '\r' ) ch = '\n';
+		if ( ch == '\n' ) {
+			::info.output.history.push_back(::info.output.buffer);
+			::info.output.buffer = "";
+			return;
+		} else if ( ch < 32 || ch > 127 ) return;
+		::info.output.buffer += ch;
+	}
+	void addStr( const std::string& str ) {
+		for ( auto x : str ) addCh(x);
+	}
+	void addUStr( const uf::String& str ) {
+		for ( auto x : str.getString() ) addCh(x);
+	}
+};
+#ifndef UF_USE_NCURSES
+	bool uf::IoStream::ncurses = false;
+#else
+	bool uf::IoStream::ncurses = true;
+#endif
+uf::IoStream uf::iostream;
+
+UF_API_CALL uf::IoStream::IoStream() {
+	spec::terminal.setLocale();
+}
+uf::IoStream::~IoStream() {
+}
+
+void UF_API_CALL uf::IoStream::initialize() {
+#if UF_USE_NCURSES
+	if ( !uf::IoStream::ncurses ) return;
+	ext::ncurses.initialize();
+	if ( ext::ncurses.hasColors() ) {
+		ext::ncurses.startColor();
+
+		this->m_registeredColors = {
+			{"Red", 	{1, COLOR_RED,		COLOR_BLACK, "COLOR_RED"		} },
+			{"Green", 	{2, COLOR_GREEN,	COLOR_BLACK, "COLOR_GREEN"		} },
+			{"Yellow", 	{3, COLOR_YELLOW,	COLOR_BLACK, "COLOR_YELLOW"		} },
+			{"Blue", 	{4, COLOR_BLUE,		COLOR_BLACK, "COLOR_BLUE"		} },
+			{"Cyan", 	{5, COLOR_CYAN,		COLOR_BLACK, "COLOR_CYAN"		} },
+			{"Magenta", {6, COLOR_MAGENTA,	COLOR_BLACK, "COLOR_MAGENTA"	} },
+			{"White", 	{7, COLOR_WHITE,	COLOR_BLACK, "COLOR_WHITE"		} },
+		};
+		for ( auto& pair : this->m_registeredColors ) {
+			auto& color = pair.second;
+			ext::ncurses.initPair( color.id, color.foreground, color.background );
+		}
+		this->setColor("White");
+	} else {
+		uf::iostream << "Color not supported!" << "\n";
+		this->readChar();
+		this->terminate();
+	}
+#endif
+}
+void UF_API_CALL uf::IoStream::terminate() {
+#if UF_USE_NCURSES
+	if (uf::IoStream::ncurses) ext::ncurses.terminate();
+#endif
+}
+void UF_API_CALL uf::IoStream::clear(bool all) {
+#if UF_USE_NCURSES
+	if ( !ext::ncurses.initialized() ) this->initialize();
+#endif
+	if ( !uf::IoStream::ncurses ) {
+		if ( all ) {
+			spec::terminal.clear();
+		}
+	}
+#if UF_USE_NCURSES
+	if ( all ) {
+		ext::ncurses.move(0,0);
+		ext::ncurses.clear(true);
+		return;
+	}
+	
+	ext::ncurses.getYX(::info.cursor.row, ::info.cursor.column);
+	ext::ncurses.move(::info.cursor.row, 0);
+	ext::ncurses.clear();
+#endif
+}
+std::string uf::IoStream::getBuffer() {
+	return ::info.output.buffer;
+}
+std::vector<std::string> uf::IoStream::getHistory() {
+	return ::info.output.history;
+}
+void UF_API_CALL uf::IoStream::back() {
+#if UF_USE_NCURSES
+	if ( !ext::ncurses.initialized() ) return;
+	if ( !uf::IoStream::ncurses ) return;
+/*
+	ext::ncurses.getYX(::info.cursor.row, ::info.cursor.column);
+	struct {
+		int row = ::info.cursor.row, column = ::info.cursor.column;
+	} target;
+	if ( ::info.output.buffer.size() > 0 ) {
+		::info.output.buffer = ::info.output.buffer.substr( 0, ::info.output.buffer.size() );
+	} else if ( ::info.output.history.size() > 0 ) {
+		::info.output.buffer = ::info.output.history.back();
+		::info.output.history.erase( ::info.output.history.end() - 1 );
+		ext::ncurses.move(::info.cursor.row, ::info.output.buffer.size(), ::info.cursor.row, ::info.cursor.column);
+	}
+*/
+	if ( !::info.output.buffer.empty() ) {
+		::info.output.buffer.pop_back();
+		ext::ncurses.delChar();
+	} else if ( !::info.output.history.empty() ) {
+		::info.output.buffer = ::info.output.history.back();
+		::info.output.history.pop_back();
+		ext::ncurses.getYX(::info.cursor.row, ::info.cursor.column);
+		ext::ncurses.move(::info.cursor.row - 1, ::info.output.buffer.size(), ::info.cursor.row, ::info.cursor.column);
+	}
+	ext::ncurses.refresh();
+#endif
+}
+char UF_API_CALL uf::IoStream::readChar(const bool& loop) {
+#if UF_USE_NCURSES
+	if ( !ext::ncurses.initialized() ) this->initialize();
+#endif
+	if ( !uf::IoStream::ncurses ) {
+		return std::cin.get();
+	}
+#if UF_USE_NCURSES
+	while ( loop ) {
+		::info.character = ext::ncurses.getCh();
+		if ( ::info.character == ERR ) continue;
+		if ( ::info.character > 0 && ::info.character < 128 ) return ::info.character;
+	}
+	return 0;
+#endif
+}
+std::string UF_API_CALL uf::IoStream::readString(const bool& loop) {
+#if UF_USE_NCURSES
+	if ( !ext::ncurses.initialized() ) this->initialize();
+	// static std::vector<std::string> history;
+#endif
+	if ( !uf::IoStream::ncurses ) {
+		std::string in;
+		std::getline(std::cin, in);
+		return in;
+	}
+#if UF_USE_NCURSES
+	/*std::string ::info.input.buffer;
+	int ch;
+	struct {
+		int r = 0, c = 0;
+		int r_max = 0, c_max = 0;
+	} home;
+	unsigned int cursor = 0;
+	
+	std::string ::info.temporary;
+	int ::info.indices.history = -1;*/
+	ext::ncurses.getYX(::info.cursor.row, ::info.cursor.column);
+	ext::ncurses.getMaxYX(::info.window.rows, ::info.window.columns);
+	::info.origin = ::info.cursor;
+
+	// break on new line or carriage return
+	while ( loop && (::info.character = ext::ncurses.getCh()) != '\n' && ::info.character != '\r' ) {
+		// err
+		if ( ::info.character == ERR ) {
+			continue;
+		// mouse
+		} else if ( ::info.character == KEY_MOUSE ) {
+		/*
+			MEVENT event;
+			if ( wgetmouse(&event) == OK ) {
+
+			}
+		*/
+		// backspace
+		} else if ( ::info.character == '\b' && ::info.input.buffer.length() > 0 ) {
+			::info.input.buffer = ::info.input.buffer.substr( 0, ::info.input.buffer.length() - 1 );
+			ext::ncurses.getYX(::info.cursor.row, ::info.cursor.column);
+			ext::ncurses.move(::info.cursor.row, ::info.cursor.column-1, ::info.cursor.row, ::info.cursor.column);
+			ext::ncurses.delChar();
+			ext::ncurses.refresh();
+			--::info.indices.buffer;
+		// left/right arrow keys
+		} else if ( ::info.character == KEY_LEFT || ::info.character == KEY_RIGHT ) {
+			int dir = (::info.character == KEY_LEFT) ? -1 : 1;
+			ext::ncurses.getYX(::info.cursor.row, ::info.cursor.column);
+			if ( ::info.cursor.column < ::info.window.columns && ::info.cursor.column > ::info.origin.column ) {
+				::info.cursor.column += dir;
+				::info.indices.buffer += dir;
+				ext::ncurses.move(-1, ::info.cursor.column);
+			}
+		// up/down arrow keys
+		} else if ( ::info.character == KEY_UP || ::info.character == KEY_DOWN ) {
+			if ( ::info.temporary == "" ) ::info.temporary = ::info.input.buffer;
+			int dir = (::info.character == KEY_UP) ? -1 : 1;
+			if ( ::info.indices.history - 1 >= 0 && ::info.indices.history + 1 < ::info.input.history.size() ) {
+				ext::ncurses.move(::info.origin.row, ::info.origin.column, ::info.cursor.row, ::info.cursor.column);
+				ext::ncurses.clear();
+				::info.indices.history += dir;
+				::info.input.buffer = *(::info.input.history.end() - ::info.indices.history - 1);
+				::info.indices.buffer = ::info.input.buffer.size();
+				uf::iostream << ::info.input.buffer;
+			}
+		/*	else if ( delta < 0 ) {
+				ext::ncurses.move(home.r, home.c);
+				ext::ncurses.clear();
+				::info.input.buffer = ::info.temporary;
+				::info.indices.buffer = ::info.input.buffer.size();
+				uf::iostream << ::info.input.buffer;
+			}
+		*/
+		// valid characters
+		} else if ( ::info.character >= 32 && ::info.character <= 127 ) {
+			char at = ::info.character;
+			::info.temporary = "";
+			if ( ::info.indices.buffer == ::info.input.buffer.length() ) {	
+				::info.input.buffer += this->writeChar(at);
+			} else {
+				::info.input.buffer[::info.indices.buffer] = this->writeChar(at);
+			}
+			++::info.indices.buffer;
+		}
+	}
+	uf::iostream << "\n";
+	::info.input.history.push_back(::info.input.buffer);
+	return ::info.input.buffer;
+#endif
+}
+uf::String UF_API_CALL uf::IoStream::readUString(const bool& loop) {
+#if UF_USE_NCURSES
+	if ( !ext::ncurses.initialized() ) this->initialize();
+	// static std::vector<std::string> history;
+#endif
+	if ( !uf::IoStream::ncurses ) {
+		std::string in;
+		std::getline(std::cin, in);
+		return in;
+	}
+#if UF_USE_NCURSES
+	/*std::string ::info.input.buffer;
+	int ch;
+	struct {
+		int r = 0, c = 0;
+		int r_max = 0, c_max = 0;
+	} home;
+	unsigned int cursor = 0;
+	
+	std::string ::info.temporary;
+	int ::info.indices.history = -1;*/
+	ext::ncurses.getYX(::info.cursor.row, ::info.cursor.column);
+	ext::ncurses.getMaxYX(::info.window.rows, ::info.window.columns);
+	::info.origin = ::info.cursor;
+
+	// break on new line or carriage return
+	while ( loop && (::info.character = ext::ncurses.getCh()) != '\n' && ::info.character != '\r' ) {
+		// err
+		if ( ::info.character == ERR ) {
+			continue;
+		// mouse
+		} else if ( ::info.character == KEY_MOUSE ) {
+		/*
+			MEVENT event;
+			if ( wgetmouse(&event) == OK ) {
+
+			}
+		*/
+		// backspace
+		} else if ( ::info.character == '\b' && ::info.input.buffer.length() > 0 ) {
+			::info.input.buffer = ::info.input.buffer.substr( 0, ::info.input.buffer.length() - 1 );
+			ext::ncurses.getYX(::info.cursor.row, ::info.cursor.column);
+			ext::ncurses.move(::info.cursor.row, ::info.cursor.column-1, ::info.cursor.row, ::info.cursor.column);
+			ext::ncurses.delChar();
+			ext::ncurses.refresh();
+			--::info.indices.buffer;
+		// left/right arrow keys
+		} else if ( ::info.character == KEY_LEFT || ::info.character == KEY_RIGHT ) {
+			int dir = (::info.character == KEY_LEFT) ? -1 : 1;
+			ext::ncurses.getYX(::info.cursor.row, ::info.cursor.column);
+			if ( ::info.cursor.column < ::info.window.columns && ::info.cursor.column > ::info.origin.column ) {
+				::info.cursor.column += dir;
+				::info.indices.buffer += dir;
+				ext::ncurses.move(-1, ::info.cursor.column);
+			}
+		// up/down arrow keys
+		} else if ( ::info.character == KEY_UP || ::info.character == KEY_DOWN ) {
+			if ( ::info.temporary == "" ) ::info.temporary = ::info.input.buffer;
+			int dir = (::info.character == KEY_UP) ? -1 : 1;
+			if ( ::info.indices.history - 1 >= 0 && ::info.indices.history + 1 < ::info.input.history.size() ) {
+				ext::ncurses.move(::info.origin.row, ::info.origin.column, ::info.cursor.row, ::info.cursor.column);
+				ext::ncurses.clear();
+				::info.indices.history += dir;
+				::info.input.buffer = *(::info.input.history.end() - ::info.indices.history - 1);
+				::info.indices.buffer = ::info.input.buffer.size();
+				uf::iostream << ::info.input.buffer;
+			}
+		/*	else if ( delta < 0 ) {
+				ext::ncurses.move(home.r, home.c);
+				ext::ncurses.clear();
+				::info.input.buffer = ::info.temporary;
+				::info.indices.buffer = ::info.input.buffer.size();
+				uf::iostream << ::info.input.buffer;
+			}
+		*/
+		// valid characters
+		// UTF-8 char
+		} else {
+			int iterations = 0;
+			char at = ::info.character;
+			if (  32 <= ::info.character && ::info.character <= 127 ) iterations = 1;
+			if ( 194 <= ::info.character && ::info.character <= 223 ) iterations = 2;
+			if ( 224 <= ::info.character && ::info.character <= 239 ) iterations = 3;
+			if ( 240 <= ::info.character && ::info.character <= 244 ) iterations = 4;
+			for ( int i = 0; i < iterations; ++i, ++::info.indices.buffer ) {
+				if ( at != ::info.character ) at = ext::ncurses.getCh(); 
+				if ( ::info.indices.buffer == ::info.input.buffer.length() ) ::info.input.buffer += this->writeChar(at);
+				else ::info.input.buffer[::info.indices.buffer] = this->writeChar(at);
+				at = 0;
+			}
+		}
+	/*
+		// ANSI / 1-byte UTF-8
+		} else if ( 32 <= ch && ch <= 127 ) {
+			char at = ch;
+			if ( cursor == ::info.input.buffer.length() ) {	
+				::info.input.buffer += this->writeChar(at);
+			} else {
+				::info.input.buffer[cursor] = this->writeChar(at);
+			}
+			++cursor;
+		// 2-byte UTF-8
+		} else if ( 194 <= ch && ch <= 223 ) {
+			char at = ch;
+			for ( int i = 0; i < 2; ++i, ++cursor ) {
+				if ( at != ch ) at = ext::ncurses.getCh(); 
+				if ( cursor == ::info.input.buffer.length() ) ::info.input.buffer += this->writeChar(at);
+				else ::info.input.buffer[cursor] = this->writeChar(at);
+				at = 0;
+			}
+		}
+	*/
+	}
+	uf::iostream << "\n";
+	::info.input.history.push_back(::info.input.buffer);
+	return ::info.input.buffer;
+#endif
+}
+char UF_API_CALL uf::IoStream::writeChar( char ch ) {
+#if UF_USE_NCURSES
+	if ( !ext::ncurses.initialized() ) this->initialize();
+#endif
+	addCh(ch);
+/*
+	if ( ch == '\r' ) ch = '\n';
+	if ( ch != '\n' ) {
+		::info.output.buffer += ch;
+	} else {
+		this->writeString("new line: " + ::info.output.buffer + "\n");
+		::info.output.history.push_back(::info.output.buffer);
+		::info.output.buffer = "";
+	}
+*/
+	if ( !uf::IoStream::ncurses ) {
+		if ( ch == '\n' ) std::cout << std::endl;
+		else std::cout << ch;
+		return ch;
+	}
+#if UF_USE_NCURSES
+	ext::ncurses.addChar(ch);
+	ext::ncurses.refresh();
+	return ch;
+#endif
+}
+const std::string& UF_API_CALL uf::IoStream::writeString( const std::string& str ) {
+#if UF_USE_NCURSES
+	if ( !ext::ncurses.initialized() ) this->initialize();
+#endif
+	addStr(str);
+/*
+	std::size_t needle;
+	std::string haystack = str;
+	while ( (needle = haystack.find('\n')) != std::string::npos ) {
+		::info.output.buffer += haystack.substr( 0, needle );
+		::info.output.history.push_back(::info.output.buffer);
+		::info.output.buffer = "";
+		haystack = haystack.substr( needle + 1 );
+	}
+	::info.output.buffer += haystack;
+*/
+	if ( !uf::IoStream::ncurses ) {
+		if ( str == "\n" ) std::cout << std::endl;
+		else std::cout << str;
+		return str;
+	}
+#if UF_USE_NCURSES
+	ext::ncurses.addStr(str.c_str());
+	ext::ncurses.refresh();
+	return str;
+#endif
+}
+const uf::String& UF_API_CALL uf::IoStream::writeUString( const uf::String& str ) {
+#if UF_USE_NCURSES
+	if ( !ext::ncurses.initialized() ) this->initialize();
+#endif
+	addUStr(str);
+/*
+	std::size_t needle;
+	auto haystack = str.getString();
+	while ( (needle = haystack.find('\n')) != std::string::npos ) {
+		::info.output.buffer += std::string((const char*) haystack.substr( 0, needle ).c_str());
+		::info.output.history.push_back(::info.output.buffer);
+		::info.output.buffer = "";
+		haystack = haystack.substr( needle + 1 );
+	}
+*/
+	if ( !uf::IoStream::ncurses ) {
+		std::cout << (const char*) str.getString().c_str();
+		return str;
+	}
+#if UF_USE_NCURSES
+	ext::ncurses.addStr((const char*) str.getString().c_str());
+	ext::ncurses.refresh();
+	return str;
+#endif
+}
+
+void UF_API_CALL uf::IoStream::operator>> (bool& val) {
+	std::stringstream ss;
+	ss << this->readString();
+	ss >> val;
+}
+
+void UF_API_CALL uf::IoStream::operator>> (char& val) {
+	std::stringstream ss;
+	ss << this->readString();
+	ss >> val;
+}
+void UF_API_CALL uf::IoStream::operator>> (short& val) {
+	std::stringstream ss;
+	ss << this->readString();
+	ss >> val;
+}
+void UF_API_CALL uf::IoStream::operator>> (unsigned short& val) {
+	std::stringstream ss;
+	ss << this->readString();
+	ss >> val;
+}
+void UF_API_CALL uf::IoStream::operator>> (int& val) {
+	std::stringstream ss;
+	ss << this->readString();
+	ss >> val;
+}
+void UF_API_CALL uf::IoStream::operator>> (unsigned int& val) {
+	std::stringstream ss;
+	ss << this->readString();
+	ss >> val;
+}
+void UF_API_CALL uf::IoStream::operator>> (long& val) {
+	std::stringstream ss;
+	ss << this->readString();
+	ss >> val;
+}
+void UF_API_CALL uf::IoStream::operator>> (unsigned long& val) {
+	std::stringstream ss;
+	ss << this->readString();
+	ss >> val;
+}
+void UF_API_CALL uf::IoStream::operator>> (long long& val) {
+	std::stringstream ss;
+	ss << this->readString();
+	ss >> val;
+}
+void UF_API_CALL uf::IoStream::operator>> (unsigned long long& val) {
+	std::stringstream ss;
+	ss << this->readString();
+	ss >> val;
+}
+void UF_API_CALL uf::IoStream::operator>> (float& val) {
+	std::stringstream ss;
+	ss << this->readString();
+	ss >> val;
+}
+void UF_API_CALL uf::IoStream::operator>> (double& val) {
+	std::stringstream ss;
+	ss << this->readString();
+	ss >> val;
+}
+void UF_API_CALL uf::IoStream::operator>> (long double& val) {
+	std::stringstream ss;
+	ss << this->readString();
+	ss >> val;
+}
+void UF_API_CALL uf::IoStream::operator>> (std::string& val) {
+	val = this->readString();
+}
+void UF_API_CALL uf::IoStream::operator>> (uf::String& val) {
+	val = this->readUString();
+}
+std::istream& UF_API_CALL uf::IoStream::operator>> ( std::istream& is ) {
+	std::string input;
+	is >> input;
+	this->writeString(input);
+	return is;
+}
+std::istream& UF_API_CALL operator>> ( std::istream& is, uf::IoStream& io ) {
+	std::string input;
+	is >> input;
+	io.writeString(input);
+	return is;
+}
+
+
+
+uf::IoStream& UF_API_CALL uf::IoStream::operator<< (const bool& val) {
+	std::stringstream ss;
+	ss << val;
+	this->writeString(ss.str());
+	return *this;
+}
+uf::IoStream& UF_API_CALL uf::IoStream::operator<< (const char& val) {
+	std::stringstream ss;
+	ss << val;
+	this->writeString(ss.str());
+	return *this;
+}
+uf::IoStream& UF_API_CALL uf::IoStream::operator<< (const short& val) {
+	std::stringstream ss;
+	ss << val;
+	this->writeString(ss.str());
+	return *this;
+}
+uf::IoStream& UF_API_CALL uf::IoStream::operator<< (const unsigned short& val) {
+	std::stringstream ss;
+	ss << val;
+	this->writeString(ss.str());
+	return *this;
+}
+uf::IoStream& UF_API_CALL uf::IoStream::operator<< (const int& val) {
+	std::stringstream ss;
+	ss << val;
+	this->writeString(ss.str());
+	return *this;
+}
+uf::IoStream& UF_API_CALL uf::IoStream::operator<< (const unsigned int& val) {
+	std::stringstream ss;
+	ss << val;
+	this->writeString(ss.str());
+	return *this;
+}
+uf::IoStream& UF_API_CALL uf::IoStream::operator<< (const long& val) {
+	std::stringstream ss;
+	ss << val;
+	this->writeString(ss.str());
+	return *this;
+}
+uf::IoStream& UF_API_CALL uf::IoStream::operator<< (const unsigned long& val) {
+	std::stringstream ss;
+	ss << val;
+	this->writeString(ss.str());
+	return *this;
+}
+uf::IoStream& UF_API_CALL uf::IoStream::operator<< (const long long& val) {
+	std::stringstream ss;
+	ss << val;
+	this->writeString(ss.str());
+	return *this;
+}
+uf::IoStream& UF_API_CALL uf::IoStream::operator<< (const unsigned long long& val) {
+	std::stringstream ss;
+	ss << val;
+	this->writeString(ss.str());
+	return *this;
+}
+uf::IoStream& UF_API_CALL uf::IoStream::operator<< (const float& val) {
+	std::stringstream ss;
+	ss << val;
+	this->writeString(ss.str());
+	return *this;
+}
+uf::IoStream& UF_API_CALL uf::IoStream::operator<< (const double& val) {
+	std::stringstream ss;
+	ss << val;
+	this->writeString(ss.str());
+	return *this;
+}
+uf::IoStream& UF_API_CALL uf::IoStream::operator<< (const long double& val) {
+	std::stringstream ss;
+	ss << val;
+	this->writeString(ss.str());
+	return *this;
+}
+uf::IoStream& UF_API_CALL uf::IoStream::operator<< (const std::string& val) {
+	this->writeString(val);
+	return *this;
+}
+uf::IoStream& UF_API_CALL uf::IoStream::operator<< (const uf::String& val) {
+	this->writeUString(val);
+	return *this;
+}
+uf::IoStream& UF_API_CALL uf::IoStream::operator<< (const char* cstr) {
+	this->writeString(std::string(cstr));
+	return *this;
+}
+uf::IoStream& UF_API_CALL uf::IoStream::operator<< (const uf::Serializer& val) {
+	this->writeString(val.serialize());
+	return *this;
+}
+uf::IoStream& UF_API_CALL uf::IoStream::operator<< (void* ptr) {
+	std::stringstream ss;
+	ss << ptr;
+	this->writeString(ss.str());
+	return *this;
+}
+uf::IoStream& UF_API_CALL uf::IoStream::operator<< ( std::ostream& os ) {
+	std::stringstream str;
+	str << os.rdbuf();
+	this->writeString( str.str() );
+	return *this;
+}
+std::ostream& UF_API_CALL operator<< ( std::ostream& os, uf::IoStream& io ) {
+	std::string output = io.readString();
+	os << output;
+	return os;
+}
+
+std::string uf::IoStream::getColor() {
+	return this->m_currentColor;
+}
+void UF_API_CALL uf::IoStream::setColor( const std::string& str ) {
+#if UF_USE_NCURSES
+	if ( !uf::IoStream::ncurses ) return;
+	if ( !ext::ncurses.initialized() ) this->initialize();
+
+	if ( this->m_registeredColors.count(str) < 1 ) return;
+
+	if ( ::info.color.last != 0 ) ext::ncurses.attrOff(COLOR_PAIR(::info.color.last));
+	short id = this->m_registeredColors.at(str).id;
+	ext::ncurses.attrOn(COLOR_PAIR(id));
+	::info.color.last = id;
+
+	this->m_currentColor = str;
+#endif
+}
+
+// manip via stream manipulator
+UF_API_CALL uf::IoStream::Color::Manip1::Manip1( uf::IoStream& _io ) : io(_io) {}
+uf::IoStream::Color::Manip1 UF_API_CALL uf::IoStream::operator<< ( const uf::IoStream::Color& color) {
+	return uf::IoStream::Color::Manip1(*this);
+}
+uf::IoStream& UF_API_CALL uf::IoStream::Color::Manip1::operator<<( const std::string& name ) {
+	this->io.setColor(name);
+	return this->io;
+}
+
+// manip via function call
+UF_API_CALL uf::IoStream::Color::Manip2::Manip2( const std::string& _name ) : name(_name) {}
+uf::IoStream::Color::Manip2 UF_API_CALL uf::IoStream::Color::operator()( const std::string& name ) const {
+	return uf::IoStream::Color::Manip2(name);
+}
+uf::IoStream& UF_API_CALL uf::IoStream::Color::operator()( uf::IoStream& io, const std::string& name ) const {
+	io.setColor(name);
+	return io;
+}
+
+uf::IoStream& UF_API_CALL uf::IoStream::operator<< (const uf::IoStream::Color::Manip2& color) {
+	this->setColor(color.name);
+	return *this;
+}
\ No newline at end of file
diff --git a/engine/src/utils/math/collider.cpp b/engine/src/utils/math/collider.cpp
new file mode 100644
index 00000000..e5db8fe1
--- /dev/null
+++ b/engine/src/utils/math/collider.cpp
@@ -0,0 +1,62 @@
+#include <uf/utils/math/collision.h>
+#include <uf/utils/math/collision/gjk.h>
+#include <uf/utils/math/collision/boundingbox.h>
+#include <uf/utils/math/collision/sphere.h>
+#include <uf/utils/math/collision/mesh.h>
+#include <uf/utils/math/collision/modular.h>
+#include <iostream>
+
+uf::Collider::~Collider() {
+	this->clear();
+}
+void UF_API uf::Collider::clear() {
+	for ( pod::Collider* pointer : this->m_container ) delete pointer;
+	this->m_container.clear();
+}
+
+void UF_API uf::Collider::add( pod::Collider* pointer ) {
+	this->m_container.push_back(pointer);
+}
+uf::Collider::container_t& UF_API uf::Collider::getContainer() {
+	return this->m_container;
+}
+const uf::Collider::container_t& UF_API uf::Collider::getContainer() const {
+	return this->m_container;
+}
+
+std::size_t UF_API uf::Collider::getSize() const {
+	return this->m_container.size();
+}
+
+std::vector<pod::Collider::Manifold> UF_API uf::Collider::intersects( const uf::Collider& body, bool smart ) const {
+	std::vector<pod::Collider::Manifold> manifolds;
+	manifolds.reserve( this->m_container.size() * body.m_container.size() );
+	for ( const pod::Collider* pointer : body.m_container ) {
+		std::vector<pod::Collider::Manifold> result = this->intersects( *pointer, smart );
+		manifolds.insert( manifolds.end(), result.begin(), result.end() );
+	}
+	return manifolds;
+}
+
+std::vector<pod::Collider::Manifold> UF_API uf::Collider::intersects( const pod::Collider& body, bool smart ) const {
+	// smart = false;
+	std::vector<pod::Collider::Manifold> manifolds;
+	for ( const pod::Collider* pointer : this->m_container ) {
+		pod::Collider::Manifold& manifold = manifolds.emplace_back();
+		if ( !pointer ) continue;
+		if ( smart && pointer->type() == body.type() ) {
+			if ( pointer->type() == "BoundingBox" ) {
+				const uf::BoundingBox& a = *((const uf::BoundingBox*) pointer);
+				const uf::BoundingBox& b = *((const uf::BoundingBox*) &body);
+				manifold = a.intersects(b);
+			} else if ( pointer->type() == "Sphere" ) {
+				const uf::SphereCollider& a = *((const uf::SphereCollider*) pointer);
+				const uf::SphereCollider& b = *((const uf::SphereCollider*) &body);
+				manifold = a.intersects(b);
+			}
+			else
+				manifold = pointer->intersects( body );
+		} else manifold = pointer->intersects( body );
+	}
+	return manifolds;
+}
\ No newline at end of file
diff --git a/engine/src/utils/math/collision/boundingbox.cpp b/engine/src/utils/math/collision/boundingbox.cpp
new file mode 100644
index 00000000..36bd562e
--- /dev/null
+++ b/engine/src/utils/math/collision/boundingbox.cpp
@@ -0,0 +1,157 @@
+#include <uf/utils/math/collision/boundingbox.h>
+
+UF_API uf::BoundingBox::BoundingBox( const pod::Vector3& origin, const pod::Vector3& corner ) {
+	this->m_origin = origin;
+	this->m_corner = corner;
+}
+const pod::Vector3& uf::BoundingBox::getOrigin() const {
+	return this->m_origin;
+}
+const pod::Vector3& uf::BoundingBox::getCorner() const {
+	return this->m_corner;
+}
+void uf::BoundingBox::setOrigin( const pod::Vector3& origin ) {
+	this->m_origin = origin;
+}
+void uf::BoundingBox::setCorner( const pod::Vector3& corner ) {
+	this->m_corner = corner;
+}
+pod::Vector3 uf::BoundingBox::min() const {
+	pod::Vector3f position = this->getPosition() + this->m_origin;
+	// const pod::Vector3f& position = this->m_origin;
+	return position - this->m_corner;
+}
+pod::Vector3 uf::BoundingBox::max() const {
+	pod::Vector3f position = this->getPosition() + this->m_origin;
+	// const pod::Vector3f& position = this->m_origin;
+	return position + this->m_corner;
+}
+pod::Vector3 uf::BoundingBox::closest( const pod::Vector3f& point ) const {
+	pod::Vector3f position = this->getPosition() + this->m_origin;
+	// const pod::Vector3f& position = this->m_origin;
+
+	float distance = 9E9;
+	pod::Vector3f vector = point;
+	pod::Vector3f min = position - this->m_corner;
+	pod::Vector3f max = position + this->m_corner;
+
+	float test = 0;
+	if ( (test = fabs(min.x - point.x)) < distance ) {
+		distance = test;
+		vector.x = min.x;
+	}
+	if ( (test = fabs(max.x - point.x)) < distance ) {
+		distance = test;
+		vector.x = max.x;
+	}
+
+	if ( (test = fabs(min.y - point.y)) < distance ) {
+		distance = test;
+		vector.y = min.y;
+	}
+	if ( (test = fabs(max.y - point.y)) < distance ) {
+		distance = test;
+		vector.y = max.y;
+	}
+
+	if ( (test = fabs(min.z - point.z)) < distance ) {
+		distance = test;
+		vector.z = min.z;
+	}
+	if ( (test = fabs(max.z - point.z)) < distance ) {
+		distance = test;
+		vector.z = max.z;
+	}
+
+	return vector;
+}
+std::string UF_API uf::BoundingBox::type() const { return "BoundingBox"; }
+pod::Vector3* UF_API uf::BoundingBox::expand() const {
+	pod::Vector3* raw = new pod::Vector3[8];
+	raw[0] = pod::Vector3{  this->m_corner.x,  this->m_corner.y,  this->m_corner.z};
+	raw[1] = pod::Vector3{  this->m_corner.x,  this->m_corner.y, -this->m_corner.z};
+	raw[2] = pod::Vector3{ -this->m_corner.x,  this->m_corner.y, -this->m_corner.z};
+	raw[3] = pod::Vector3{ -this->m_corner.x,  this->m_corner.y,  this->m_corner.z};
+	raw[4] = pod::Vector3{ -this->m_corner.x, -this->m_corner.y,  this->m_corner.z};
+	raw[5] = pod::Vector3{  this->m_corner.x, -this->m_corner.y,  this->m_corner.z};
+	raw[6] = pod::Vector3{  this->m_corner.x, -this->m_corner.y, -this->m_corner.z};
+	raw[7] = pod::Vector3{ -this->m_corner.x, -this->m_corner.y,  this->m_corner.z};
+
+	pod::Vector3f position = this->getPosition() + this->m_origin;
+	// const pod::Vector3f& position = this->m_origin;
+	for ( uint i = 0; i < 8; i++ ) raw[0] += position;
+
+	return raw;
+}
+pod::Vector3 UF_API uf::BoundingBox::support( const pod::Vector3& direction ) const {
+	pod::Vector3f position = this->getPosition() + this->m_origin;
+	// const pod::Vector3f& position = this->m_origin;
+	pod::Vector3 res = {
+		position.x + fabs(this->m_corner.x) * (direction.x > 0 ? 1 : -1),
+		position.y + fabs(this->m_corner.y) * (direction.y > 0 ? 1 : -1),
+		position.z + fabs(this->m_corner.z) * (direction.z > 0 ? 1 : -1),
+	};
+	return res;
+}
+
+pod::Collider::Manifold UF_API uf::BoundingBox::intersects( const uf::BoundingBox& b ) const {
+	const uf::BoundingBox& a = *this;
+	pod::Collider::Manifold manifold(a, b);
+
+	BoundingBox difference(a.min() - b.max() + a.m_corner + b.m_corner, (a.m_corner + b.m_corner) * 2.0f);
+
+	pod::Vector3f min = difference.m_origin - this->m_corner;
+	pod::Vector3f max = difference.m_origin + this->m_corner;
+	manifold.colliding = min.x <= 0 && max.x >= 0 && min.y <= 0 && max.y >= 0;
+
+	if ( !manifold.colliding ) return manifold;
+
+	pod::Vector3f penetration = difference.closest( {0, 0, 0} );
+	manifold.depth = uf::vector::norm( penetration );
+	manifold.normal = penetration / manifold.depth;
+
+/*
+	float a_left 	= position_a.x - a.m_corner.x;
+	float a_right 	= position_a.x + a.m_corner.x;
+	float a_bottom 	= position_a.y - a.m_corner.y;
+	float a_top 	= position_a.y + a.m_corner.y;
+	float a_back 	= position_a.z - a.m_corner.z;
+	float a_front 	= position_a.z + a.m_corner.z;
+
+
+	float b_left 	= position_b.x - b.m_corner.x;
+	float b_right 	= position_b.x + b.m_corner.x;
+	float b_bottom 	= position_b.y - b.m_corner.y;
+	float b_top 	= position_b.y + b.m_corner.y;
+	float b_back 	= position_b.z - b.m_corner.z;
+	float b_front 	= position_b.z + b.m_corner.z;
+
+	manifold.depth = 9E9;
+	auto test = [&]( const pod::Vector3& axis, float minA, float maxA, float minB, float maxB )->bool{
+		float axisLSqr = uf::vector::dot(axis, axis);
+		if ( axisLSqr < 1E-8f ) return true;
+
+		float d0 = maxB - minA;
+		float d1 = maxA - minB;
+		if ( d0 < 0 || d1 < 0 ) return false;
+		float overlap = d0 < d1 ? d0 : -d1;
+		pod::Vector3 sep = axis * ( overlap / axisLSqr );
+		float sepLSqr = uf::vector::dot( sep, sep );
+		if ( sepLSqr < manifold.depth ) {
+			manifold.normal = sep;
+			manifold.depth = sepLSqr;
+		}
+		return true;
+	};
+
+	if ( !test( {1, 0, 0}, a_left, a_right, b_left, b_right ) ) return manifold;
+	if ( !test( {0, 1, 0}, a_bottom, a_top, b_bottom, b_top ) ) return manifold;
+	if ( !test( {0, 0, 1}, a_back, a_front, b_back, b_front ) ) return manifold;
+
+	manifold.normal = uf::vector::normalize( manifold.normal );
+	manifold.depth = sqrt( manifold.depth );
+//	manifold.depth = manifold.depth;
+	manifold.colliding = true;
+*/
+	return manifold;
+}
\ No newline at end of file
diff --git a/engine/src/utils/math/collision/gjk.cpp b/engine/src/utils/math/collision/gjk.cpp
new file mode 100644
index 00000000..17015b3e
--- /dev/null
+++ b/engine/src/utils/math/collision/gjk.cpp
@@ -0,0 +1,247 @@
+#include <uf/utils/math/collision/gjk.h>
+
+/*
+pod::Simplex::Simplex( const pod::Vector3& b, const pod::Vector3& c, const pod::Vector3& d ) {
+	this->set(b, c, d);
+}
+void pod::Simplex::add( const pod::Vector3& a ) {
+	this->d = this->c;
+	this->c = this->b;
+	this->b = a;
+}
+void pod::Simplex::set( const pod::Vector3& b, const pod::Vector3& c, const pod::Vector3& d ) {
+	this->b = b;
+	this->c = c;
+	this->d = d;
+	if ( b != pod::Vector3{} ) this->size++;
+	if ( c != pod::Vector3{} ) this->size++;
+	if ( d != pod::Vector3{} ) this->size++;
+}
+*/
+pod::Collider::~Collider(){}
+std::string UF_API pod::Collider::type() const { return ""; }
+pod::Collider::Manifold UF_API pod::Collider::intersects( const pod::Collider& y ) const {
+	const pod::Collider& x = *this;
+	
+	pod::Simplex::SupportPoint a;
+	pod::Simplex simplex;
+	pod::Vector3 direction = pod::Vector3{ 1.0f, 0.0f, 0.0f };
+	
+	pod::Collider::Manifold manifold(x, y);
+	float dot = -0.1;
+	uint16_t iterations = 0;
+	uint16_t iterations_cap = 25;
+	while ( iterations++ < iterations_cap ) {
+		direction = uf::vector::normalize(direction);
+
+		a = pod::Simplex::SupportPoint{};
+		a.a = x.support(direction);
+		a.b = y.support(-direction);
+		a.v = a.a - a.b;
+
+		if ( (dot = a.dot(direction)) < 0 ) {
+			return manifold;
+		}
+		if( simplex.size == 0 ) {	
+			simplex.b = a;
+
+			direction = direction * -1;
+			simplex.size = 1;
+			continue;
+		}
+		if ( simplex.size == 1 ) {
+			direction = uf::vector::cross(a.cross(simplex.b), a.v);
+			simplex.c = simplex.b;
+			simplex.b = a;
+			simplex.size = 2;
+			continue;
+		}
+		if ( simplex.size == 2 ) {
+			pod::Vector3 ao = a * -1;
+			pod::Vector3 ab = simplex.b - a;
+			pod::Vector3 ac = simplex.c - a;
+			pod::Vector3 abc = uf::vector::cross(ab, ac);
+			pod::Vector3 abP = uf::vector::cross(ab, abc);
+			if ( uf::vector::dot(abP, ao) > 0 ) {
+				simplex.c = simplex.b;
+				simplex.b = a;
+
+				direction = uf::vector::cross(ab, ao);
+				continue;
+			}
+			pod::Vector3 acP = uf::vector::cross(abc, ac);
+			if ( uf::vector::dot(acP, ao) > 0 ) {
+				simplex.b = a;
+
+				direction = uf::vector::cross(ac, ao);
+				continue;
+			}
+			if ( uf::vector::dot(abc, ao) > 0 ) {
+				simplex.d = simplex.c;
+				simplex.c = simplex.b;
+				simplex.b = a;
+
+				direction = abc;
+				continue;
+			}
+			simplex.d = simplex.b;
+			simplex.b = a;
+
+			direction = abc * -1;
+			simplex.size = 3;
+			continue;
+		}
+		if ( simplex.size == 3 ) {
+			pod::Vector3 ao = a * -1;
+			pod::Vector3 ab = simplex.b - a;
+			pod::Vector3 ac = simplex.c - a;
+			pod::Vector3 abc = uf::vector::cross(ab, ac);
+			pod::Vector3 ad, acd, adb;
+			if ( uf::vector::dot(abc, ao) > 0 ) {
+				goto check_face;
+			}
+			ad = simplex.d - a;
+			acd = uf::vector::cross(ac, ad);
+			if ( uf::vector::dot(acd, ao) > 0 ) {
+				simplex.b = simplex.c;
+				simplex.c = simplex.d;
+
+				ab = ac;
+				ac = ad;
+				abc = acd;
+
+				goto check_face;
+			}
+			goto EPA;
+
+		check_face:
+			pod::Vector3 abP = uf::vector::cross(ab, abc);
+			if ( uf::vector::dot(abP, ao) > 0 ) {
+				simplex.c = simplex.b;
+				simplex.b = a;
+
+				direction = uf::vector::cross(uf::vector::cross(ab, ao), ab);
+				simplex.size = 2;
+				continue;
+			}
+			pod::Vector3 acP = uf::vector::cross(abc, ac);
+			if ( uf::vector::dot(acP, ao) > 0 ) {
+				simplex.b = a;
+				direction = uf::vector::cross(uf::vector::cross(ac, ao), ac);
+				simplex.size = 2;
+				continue;
+			}
+			simplex.d = simplex.c;
+			simplex.c = simplex.b;
+			simplex.b = a;
+			direction = abc;
+			simplex.size = 3;
+			continue;
+		}
+	}
+	return manifold;
+
+EPA:
+	struct Triangle {
+		pod::Simplex::SupportPoint points[3];
+		pod::Vector3f normal;
+		Triangle( const pod::Simplex::SupportPoint& a, const pod::Simplex::SupportPoint& b, const pod::Simplex::SupportPoint& c ) {
+			points[0] = a;
+			points[1] = b;
+			points[2] = c;
+			normal = uf::vector::normalize( uf::vector::cross( b.v - a.v, c.v - a.v ) );
+		}
+	};
+	struct Edge {
+		pod::Simplex::SupportPoint points[2];
+		Edge( const pod::Simplex::SupportPoint& a, const pod::Simplex::SupportPoint& b ) {
+			points[0] = a;
+			points[1] = b;
+		}
+	};
+
+	iterations = 0;
+	manifold.colliding = true;
+	manifold.depth = 0.0f;
+	manifold.normal = { 0, 0, 0 };
+
+	std::vector<Triangle> triangles;
+	std::vector<Edge> edges;
+
+	triangles.emplace_back(         a, simplex.b, simplex.c );
+	triangles.emplace_back(         a, simplex.b, simplex.d );
+	triangles.emplace_back(         a, simplex.c, simplex.d );
+	triangles.emplace_back( simplex.b, simplex.c, simplex.d );
+
+	auto addEdge = [&]( const pod::Simplex::SupportPoint& a, const pod::Simplex::SupportPoint& b ) {
+		for ( auto it = edges.begin(); it != edges.end(); ++it ) {
+			if( it->points[0]== b && it->points[1]== a ) {
+				edges.erase(it);
+				return;
+			}
+		}
+		edges.emplace_back( a, b );
+	};
+
+	while ( iterations++ < iterations_cap ) {
+		// find closest triangle to origin
+		struct {
+			std::vector<Triangle>::iterator it;
+			float distance = 9E9;
+			pod::Simplex::SupportPoint support;
+		} closest = { triangles.begin() };
+
+		for(auto it = triangles.begin(); it != triangles.end(); it++) {
+			float distance = fabs( uf::vector::dot(it->normal, it->points[0].v) );
+			if( distance < closest.distance ) {
+				closest.distance = distance;
+				closest.it = it;
+			}
+		}
+		{
+			closest.support.a = x.support(closest.it->normal);
+			closest.support.b = y.support(-closest.it->normal);
+			closest.support.v = closest.support.a - closest.support.b;
+		}
+
+		manifold.normal = -closest.it->normal;
+		manifold.depth = uf::vector::dot( closest.it->normal, closest.support.v );
+		if( manifold.depth - closest.distance < 0.00001f ) {
+			manifold.depth = uf::vector::dot( closest.it->normal, closest.it->points[0].v );
+			return manifold;
+		}
+
+		for(auto it = triangles.begin(); it != triangles.end();) {
+			// can this face be 'seen' by closest.support?
+			if( uf::vector::dot( it->normal, (closest.support.v - it->points[0].v) ) > 0) {
+				addEdge( it->points[0], it->points[1] );
+				addEdge( it->points[1], it->points[2] );
+				addEdge( it->points[2], it->points[0] );
+				it = triangles.erase(it);
+				continue;
+			}
+			it++;
+		}
+
+		// create new triangles from the edges in the edge list
+		for(auto it = edges.begin(); it != edges.end(); it++)
+			triangles.emplace_back( closest.support, it->points[0], it->points[1] );
+
+		edges.clear();
+	}
+	return manifold;
+}
+
+pod::Vector3f pod::Collider::getPosition() const {
+	return this->m_transform.reference ? this->m_transform.reference->position : this->m_transform.position;
+//	return uf::transform::flatten( this->m_transform.reference ? *this->m_transform.reference : this->m_transform ).position;
+}
+pod::Transform<>& pod::Collider::getTransform() {
+	return this->m_transform;
+}
+const pod::Transform<>& pod::Collider::getTransform() const {
+	return this->m_transform;
+}
+void pod::Collider::setTransform( const pod::Transform<>& transform ) {
+	this->m_transform = transform;
+}
\ No newline at end of file
diff --git a/engine/src/utils/math/collision/mesh.cpp b/engine/src/utils/math/collision/mesh.cpp
new file mode 100644
index 00000000..e165f9a1
--- /dev/null
+++ b/engine/src/utils/math/collision/mesh.cpp
@@ -0,0 +1,42 @@
+#include <uf/utils/math/collision/mesh.h>
+
+uf::MeshCollider::MeshCollider( const pod::Transform<>& transform, const std::vector<pod::Vector3>& positions ) : m_positions(positions) {
+	this->setTransform(transform);
+}
+std::string UF_API uf::MeshCollider::type() const { return "Mesh"; }
+
+std::vector<pod::Vector3>& uf::MeshCollider::getPositions() {
+	return this->m_positions;
+}
+
+const std::vector<pod::Vector3>& uf::MeshCollider::getPositions() const {
+	return this->m_positions;
+}
+
+void uf::MeshCollider::setPositions( const std::vector<pod::Vector3>& positions ) {
+	this->m_positions = positions;
+}
+
+pod::Vector3* uf::MeshCollider::expand() const {
+	return (pod::Vector3*) &this->m_positions[0];
+}
+pod::Vector3 uf::MeshCollider::support( const pod::Vector3& direction ) const {
+	size_t len = this->m_positions.size();
+	pod::Vector3* points = this->expand();
+	pod::Matrix4f model = uf::transform::model( this->m_transform );
+
+	struct {
+		size_t i = 0;
+		float dot = 0;
+	} best;
+
+	for ( size_t i = 0; i < len; ++i ) {
+		float dot = uf::vector::dot( uf::matrix::multiply<float>( model, points[i] ), direction);
+	//	float dot = uf::vector::dot( points[i], direction);
+		if ( i == 0 || dot > best.dot ) {
+			best.i = i;
+			best.dot = dot;
+		}
+	}
+	return points[best.i];
+}
\ No newline at end of file
diff --git a/engine/src/utils/math/collision/modular.cpp b/engine/src/utils/math/collision/modular.cpp
new file mode 100644
index 00000000..97b39242
--- /dev/null
+++ b/engine/src/utils/math/collision/modular.cpp
@@ -0,0 +1,55 @@
+#include <uf/utils/math/collision/modular.h>
+
+UF_API uf::ModularCollider::ModularCollider( uint len, pod::Vector3* container, bool should_free, const uf::ModularCollider::function_expand_t& expand, const uf::ModularCollider::function_support_t& support  ) {
+	this->m_len = len;
+	this->m_container = container;
+	this->m_should_free = should_free;
+	this->m_function_expand = expand;
+	this->m_function_support = support;
+}
+UF_API uf::ModularCollider::~ModularCollider() {
+	if ( this->m_container != NULL && this->m_should_free ) delete[] this->m_container;
+}
+std::string UF_API uf::ModularCollider::type() const { return "Modular"; }
+void UF_API uf::ModularCollider::setExpand( const uf::ModularCollider::function_expand_t& expand ) {
+	this->m_function_expand = expand;
+}
+void UF_API uf::ModularCollider::setSupport( const uf::ModularCollider::function_support_t& support ) {
+	this->m_function_support = support;
+}
+
+pod::Vector3* UF_API uf::ModularCollider::getContainer() {
+	return this->m_container;
+}
+uint UF_API uf::ModularCollider::getSize() const {
+	return this->m_len;
+}
+void UF_API uf::ModularCollider::setContainer( pod::Vector3* container, uint len ) {
+	this->m_container = container;
+	this->m_len = len;
+}
+
+pod::Vector3* UF_API uf::ModularCollider::expand() const {
+	return this->m_function_expand ? this->m_function_expand() : this->m_container;
+}
+pod::Vector3 UF_API uf::ModularCollider::support( const pod::Vector3& direction ) const {
+	if ( this->m_function_support ) return this->m_function_support(direction);
+	
+	pod::Vector3* points = this->expand();
+	uint len = this->m_len;
+	
+	struct {
+		size_t i = 0;
+		float dot = 0;
+	} best;
+
+	for ( size_t i = 0; i < len; ++i ) {
+	//	float dot = uf::vector::dot( uf::matrix::multiply<float>( model, points[i] ), direction);
+		float dot = uf::vector::dot( points[i], direction);
+		if ( i == 0 || dot > best.dot ) {
+			best.i = i;
+			best.dot = dot;
+		}
+	}
+	return points[best.i];
+}
\ No newline at end of file
diff --git a/engine/src/utils/math/collision/sphere.cpp b/engine/src/utils/math/collision/sphere.cpp
new file mode 100644
index 00000000..5501458c
--- /dev/null
+++ b/engine/src/utils/math/collision/sphere.cpp
@@ -0,0 +1,49 @@
+#include <uf/utils/math/collision/sphere.h>
+
+UF_API uf::SphereCollider::SphereCollider( float r, const pod::Vector3& origin ) {
+	this->m_radius = r;
+	this->m_origin = origin;
+}
+std::string UF_API uf::SphereCollider::type() const { return "Sphere"; }
+float UF_API uf::SphereCollider::getRadius() const {
+	return this->m_radius;
+}
+const pod::Vector3& UF_API uf::SphereCollider::getOrigin() const {
+	return this->m_origin;
+}
+
+void UF_API uf::SphereCollider::setRadius( float r ) {
+	this->m_radius = r;
+}
+void UF_API uf::SphereCollider::setOrigin( const pod::Vector3& origin ) {
+	this->m_origin = origin;
+}
+
+pod::Vector3* UF_API uf::SphereCollider::expand() const {
+	return NULL;
+}
+pod::Vector3 UF_API uf::SphereCollider::support( const pod::Vector3& direction ) const {
+	pod::Vector3f position = this->getPosition() + this->m_origin;
+//	const pod::Vector3f& position = this->m_origin;
+	return position + direction * (this->m_radius/uf::vector::magnitude(direction));
+}
+pod::Collider::Manifold uf::SphereCollider::intersects( const uf::SphereCollider& b ) const {
+	const uf::SphereCollider& a = *this;
+	pod::Collider::Manifold manifold(a, b);
+
+	pod::Vector3f position_a = a.getPosition() + a.m_origin;
+	pod::Vector3f position_b = b.getPosition() + b.m_origin;
+	// const pod::Vector3f& position_a = a.m_origin;
+	// const pod::Vector3f& position_b = b.m_origin;
+
+	float distanceSquared = uf::vector::distanceSquared(position_a, position_b);
+	float sum = a.m_radius + b.m_radius;
+	float sumSquared = sum * sum;
+
+	if ( distanceSquared >= sumSquared ) return manifold;
+
+	manifold.depth = fabs(b.m_radius - a.m_radius);
+	manifold.normal = position_b - position_a;
+	manifold.colliding = true;
+	return manifold;
+}
\ No newline at end of file
diff --git a/engine/src/utils/math/math.cpp b/engine/src/utils/math/math.cpp
new file mode 100644
index 00000000..688fff6b
--- /dev/null
+++ b/engine/src/utils/math/math.cpp
@@ -0,0 +1,16 @@
+#include <uf/utils/math/math.h>
+
+uint16_t uf::math::quantizeShort( float v ) {
+	union { float f; uint32_t ui; } u = {v};
+	uint32_t ui = u.ui;
+	int s = (ui >> 16) & 0x8000;
+	int em = ui & 0x7fffffff;
+	int h = (em - (112 << 23) + (1 << 12)) >> 13;
+	h = (em < (113 << 23)) ? 0 : h;
+	h = (em >= (143 << 23)) ? 0x7c00 : h;
+	h = (em > (255 << 23)) ? 0x7e00 : h;
+	return (uint16_t)(s | h);
+}
+float uf::math::unquantize( uint16_t v ) {
+	return v;
+}
\ No newline at end of file
diff --git a/engine/src/utils/math/physics.cpp b/engine/src/utils/math/physics.cpp
new file mode 100644
index 00000000..9b2c51a5
--- /dev/null
+++ b/engine/src/utils/math/physics.cpp
@@ -0,0 +1,18 @@
+#include <uf/utils/math/physics.h>
+
+uf::Timer<> uf::physics::time::timer;
+double uf::physics::time::current;
+double uf::physics::time::previous;
+double uf::physics::time::delta;
+double uf::physics::time::clamp;
+
+#include <iostream>
+
+void UF_API uf::physics::tick() {
+	uf::physics::time::previous = uf::physics::time::current;
+	uf::physics::time::current = uf::physics::time::timer.elapsed().asDouble();
+	uf::physics::time::delta = uf::physics::time::current - uf::physics::time::previous;
+	if ( uf::physics::time::delta > uf::physics::time::clamp ) {
+		uf::physics::time::delta = uf::physics::time::clamp;
+	}
+}
\ No newline at end of file
diff --git a/engine/src/utils/math/rayt.cpp b/engine/src/utils/math/rayt.cpp
new file mode 100644
index 00000000..4049f640
--- /dev/null
+++ b/engine/src/utils/math/rayt.cpp
@@ -0,0 +1,336 @@
+#include <uf/utils/math/collision.h>
+#include <uf/utils/math/rayt.h>
+#include <iostream>
+
+// compile-time assert to ensure objects are of same size, if using multiple types of objects
+
+// takes a vector of primitives and groups them under leaves (end point of a tree)
+std::vector<pod::Tree> UF_API uf::primitive::populate( const std::vector<pod::Primitive>& cubes ) { // assert(cubes.size() > 0);
+	std::vector<pod::Tree> trees;
+	std::vector<const pod::Primitive*> copy;
+	std::vector<const pod::Primitive*> alloced;
+	copy.reserve( cubes.size() );
+//	std::cout << "Size: " << cubes.size() << std::endl;
+	for ( const auto& cube : cubes ) {
+		copy.push_back( &cube );
+	}
+
+	trees.reserve( copy.size() / pod::Tree::TREE_SIZE );
+	alloced.reserve( copy.size() );
+	const float cubeRoot = std::cbrt(pod::Tree::TREE_SIZE);
+	for ( const auto& cube : cubes ) {
+		// already allocated, skip
+		if ( std::find( alloced.begin(), alloced.end(), &cube ) != alloced.end() ) continue;
+		size_t index = 0;
+		pod::Tree tree;
+		// sort by closest cube
+		std::sort( copy.begin(), copy.end(), [&]( const pod::Primitive* l, const pod::Primitive* r ) {
+			return uf::vector::distanceSquared( cube.position, l->position ) < uf::vector::distanceSquared( cube.position, r->position );
+		} );
+//		std::cout << trees.size() << ": " << alloced.size() << std::endl;
+		while ( index < pod::Tree::TREE_SIZE && copy.begin() != copy.end() ) {
+			const pod::Primitive* ptr = *copy.begin();
+			copy.erase( copy.begin() );
+			tree.children[index++] = (ptr - &cubes[0]);
+		}
+		for ( size_t i = index; i < pod::Tree::TREE_SIZE; ++i ) {
+			tree.children[i] = pod::Primitive::EMPTY;
+		}
+		// mark children as allocated
+	/*
+		for ( int i = 0; i < pod::Tree::TREE_SIZE && i < index; ++i ) {
+			const auto& cube = cubes.at(tree.children[i]);
+			alloced.push_back(&cube);
+			tree.primitive.position.x += cube.position.x; tree.primitive.position.y += cube.position.y; tree.primitive.position.z += cube.position.z;
+		}
+		tree.primitive.position.x /= pod::Tree::TREE_SIZE;
+		tree.primitive.position.y /= pod::Tree::TREE_SIZE;
+		tree.primitive.position.z /= pod::Tree::TREE_SIZE;
+	*/
+		pod::Vector3f min = { 0, 0, 0 }, max = { 0, 0, 0 };
+		for ( int i = 0; i < pod::Tree::TREE_SIZE && i < index; ++i ) {
+			const auto& cube = cubes.at(tree.children[i]);
+			alloced.push_back(&cube);
+			if ( i == 0 ) {
+				min.x = cube.position.x - cube.position.w;
+				min.y = cube.position.y - cube.position.w;
+				min.z = cube.position.z - cube.position.w;
+				max.x = cube.position.x + cube.position.w;
+				max.y = cube.position.y + cube.position.w;
+				max.z = cube.position.z + cube.position.w;
+				continue;
+			}
+			min.x = std::min( cube.position.x - cube.position.w, min.x ); min.y = std::min( cube.position.y - cube.position.w, min.y ); min.z = std::min( cube.position.z - cube.position.w, min.z );
+			max.x = std::max( cube.position.x + cube.position.w, max.x ); max.y = std::max( cube.position.y + cube.position.w, max.y ); max.z = std::max( cube.position.z + cube.position.w, max.z );
+		}
+		tree.position.x = (max.x + min.x) * 0.5f;
+		tree.position.y = (max.y + min.y) * 0.5f;
+		tree.position.z = (max.z + min.z) * 0.5f;
+	
+		tree.position.w = std::max( tree.position.w, (max.x - min.x) * 0.5f );
+		tree.position.w = std::max( tree.position.w, (max.y - min.y) * 0.5f );
+		tree.position.w = std::max( tree.position.w, (max.z - min.z) * 0.5f );
+	//	tree.position.w = 0.5;
+		tree.type = pod::Primitive::LEAF; // leaves point to cubes
+		trees.push_back(tree);
+	}
+	return trees;
+}
+
+// takes a list of leaves (ends of trees) and properly populate an entire tree
+std::vector<pod::Tree> UF_API uf::primitive::populateEntirely( const std::vector<pod::Tree>& trees, bool rooted ) { // assert(trees.size() > 0);
+	// generate first layer
+	std::vector<pod::Tree> tree = trees;
+	std::vector<uint32_t> referred;
+	std::vector<uint32_t> queue;
+	uint32_t iteration = 0;
+	uint32_t start = 0;
+/*
+	std::cout << "Primitives:\n\t";
+	for ( auto& prim : primitives ) {
+		size_t i = &prim - &primitives[0];
+		std::cout << (i < 10 ? "0" : "" ) <<  i << " ";
+		if ( (i+1) % 8 == 0 ) std::cout << "\n\t";
+	}
+	std::cout << std::endl;
+*/
+loop: {
+//	std::cout << "Iteration #" << ++iteration << std::endl;
+	referred.clear();
+	// grab all unreferenced trees
+	for ( auto& branch : tree ) {
+		if ( branch.type != pod::Primitive::TREE ) continue;
+		referred.insert( referred.end(), &branch.children[0], &branch.children[7] );
+//		std::cout << "Tree #" << (&branch - &tree[0]) << " refers to:\n";
+		for ( uint i = 0; i < pod::Tree::TREE_SIZE; ++i ) {
+//			std::cout << "\t" << branch.children[i] << " ";
+			referred.push_back(branch.children[i]);
+		}
+//		std::cout << std::endl;
+	}
+	queue.clear();
+	// check if referred
+//	std::cout << "Queueing:\n\t";
+	for ( auto& branch : tree ) {
+		size_t i = &branch - &tree[0];
+		if ( std::find( referred.begin(), referred.end(), i ) != referred.end() ) continue;
+//		std::cout << i << " ";
+		queue.push_back( &branch - &tree[0] );
+	}
+//	std::cout << std::endl;
+	// grab the branches' primitives
+	std::vector<pod::Primitive> enqueued; enqueued.reserve( queue.size() );
+	for ( uint32_t i : queue ) {
+		pod::Tree t = tree.at(i);
+		pod::Primitive primitive;
+		primitive.position = t.position;
+		primitive.position.w = t.position.w;
+		primitive.type = i;
+		enqueued.push_back( primitive );
+	}
+	// create a parent tree
+	std::vector<pod::Tree> newTree = populate( enqueued );
+	// convert indices and type
+	for ( auto& branch : newTree ) {
+		branch.type = pod::Primitive::TREE;
+		branch.position.w = (iteration+1.0f) * 0.5f;
+		for ( size_t i = 0; i < pod::Tree::TREE_SIZE; ++i ) {
+			size_t index = branch.children[i];
+			if ( index == pod::Primitive::EMPTY ) continue;
+			branch.children[i] = enqueued.at(index).type;
+		}
+	}
+	// copy new tree to beginning of tree list
+	tree.insert( tree.end(), newTree.begin(), newTree.end() );
+	start = tree.size();
+	// cannot divide furter
+	if ( newTree.size() <= 1 ) goto finished;
+}
+	goto loop;
+finished:
+	if ( rooted ) tree.at(tree.size()-1).type = pod::Primitive::ROOT;
+
+//	std::cout << "Full tree:\n";
+	for ( auto& branch : tree ) {
+//		std::cout << "\t" << (&branch - &tree[0]) << " (type: " << (branch.type) << ") has children:\n\t\t";
+		for ( size_t i = 0; i < pod::Tree::TREE_SIZE; ++i ) {
+//			std::cout << branch.children[i] << " ";
+		}
+//		std::cout << std::endl;
+ 	}
+//	std::cout << std::endl;
+	for ( auto& branch : tree ) {
+//		std::cout << (&branch - &tree[0]) << " (type: " << (branch.type) << ") primitive:\n";
+//		std::cout << "\tPosition: " << branch.position.x << ", " << branch.position.y << ", " << branch.position.z << "\n\tSize: " << branch.position.w << "\n\t\t";
+		for ( size_t i = 0; i < pod::Tree::TREE_SIZE; ++i ) {
+//			std::cout << branch.children[i] << " ";
+		}
+//		std::cout << std::endl;
+		/*
+		if ( branch.type == pod::Primitive::LEAF ) {
+			for ( size_t i = 0; i < pod::Tree::TREE_SIZE; ++i ) {
+				if ( branch.children[i] == pod::Primitive::EMPTY ) continue;
+				auto& pr = primitives.at(branch.children[i]);
+//				std::cout << "\t\tPosition: " << pr.position.x << ", " << pr.position.y << ", " << pr.position.z << "\n\t\tSize: " << pr.position.w << std::endl;
+			}
+		} else {
+			for ( size_t i = 0; i < pod::Tree::TREE_SIZE; ++i ) {
+				if ( branch.children[i] == pod::Primitive::EMPTY ) continue;
+				auto& pr = tree.at(branch.children[i]);
+//				std::cout << "\t\tPosition: " << pr.position.x << ", " << pr.position.y << ", " << pr.position.z << "\n\t\tSize: " << pr.position.w << std::endl;
+			}
+		}
+		*/
+ 	}
+//	std::cout << std::endl;
+
+	return tree;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+////////////////////////
+namespace {
+	#define EPSILON 0.0001f
+	#define MAXLEN 1000.0f
+	#define SHADOW 0.5f
+
+	#define TREE_SIZE 8
+	#define TREE_STACK 8
+	#define PRIMITIVE_TYPE_EMPTY UINT32_MAX
+	#define PRIMITIVE_TYPE_CUBE 1
+	#define PRIMITIVE_TYPE_LEAF 2
+	#define PRIMITIVE_TYPE_TREE 3
+	#define PRIMITIVE_TYPE_ROOT 4
+	struct StackIterator {
+		uint tree;
+		uint child;
+	};
+	struct Stack {
+		int pointer;
+		StackIterator container[TREE_STACK];
+	} stack;
+	void printStack( ) {
+		std::cout << "[*] Pointer @ " << stack.pointer << std::endl;
+		for ( int i = stack.pointer; i >= 0; --i ) { 
+			std::cout << "[*] " << stack.container[i].tree << ", " << stack.container[i].child << std::endl;
+		}
+		std::cout << std::endl;
+	}
+	StackIterator popStack( ) {
+		StackIterator top = stack.container[stack.pointer];
+		stack.container[stack.pointer--] = { UINT32_MAX, UINT32_MAX };
+		std::cout << "[?] popped stack" << std::endl;
+		printStack();
+		return top;
+	}
+	StackIterator topStack( ) {
+		StackIterator pointer = stack.container[stack.pointer];
+		printStack();
+		return pointer;
+	}
+	void pushStack( StackIterator item ) {
+		stack.container[++stack.pointer] = item;
+		std::cout << "[?] pushed to stack" << std::endl;
+		printStack();
+	}
+	float cubeIntersect( const pod::Vector3f& rayO, const pod::Vector3f& rayD, const pod::Vector3f& rayDRecip, const pod::Primitive& cube) {
+		float t[10];
+		t[1] = ( cube.position.x - cube.position.w - rayO.x) / rayD.x;
+		t[2] = ( cube.position.x + cube.position.w - rayO.x) / rayD.x;
+		t[3] = ( cube.position.y - cube.position.w - rayO.y) / rayD.y;
+		t[4] = ( cube.position.y + cube.position.w - rayO.y) / rayD.y;
+		t[5] = ( cube.position.z - cube.position.w - rayO.z) / rayD.z;
+		t[6] = ( cube.position.z + cube.position.w - rayO.z) / rayD.z;
+		t[7] = std::max(std::max(std::min(t[1], t[2]), std::min(t[3], t[4])), std::min(t[5], t[6]));
+		t[8] = std::min(std::min(std::max(t[1], t[2]), std::max(t[3], t[4])), std::max(t[5], t[6]));
+		t[9] = (t[8] < 0 || t[7] > t[8]) ? 0.0 : t[7];
+		return t[9];
+	}
+	float treeIntersect( const pod::Vector3f& rayO, const pod::Vector3f& rayD, const pod::Vector3f& rayDRecip, const pod::Tree& tree ) {
+		pod::Primitive treecube;
+		treecube.type = tree.type;
+		treecube.position = tree.position;
+		return cubeIntersect( rayO, rayD, rayDRecip, treecube );
+	}
+}
+
+void uf::primitive::test( const std::vector<pod::Primitive>& cubes, const std::vector<pod::Tree>& trees ) {
+	pod::Vector3f rayO = { 0, 5, 0 };
+	pod::Vector3f rayD = uf::vector::normalize( pod::Vector3f{ 0, -1, -0.25 } );
+	pod::Vector3f rayDRecip = { 1.0f / rayD.x, 1.0f / rayD.y, 1.0f / rayD.z };
+	float resT = MAXLEN;
+	uint root = trees.size() - 1;
+	uint id = UINT32_MAX;
+	if ( root == UINT32_MAX ) return;
+
+	// set up stack
+	stack.pointer = -1;
+	for ( uint i = 0; i < TREE_STACK; ++i ) stack.container[i] = {UINT32_MAX, UINT32_MAX};
+	pushStack({ root, UINT32_MAX });
+
+	while ( true ) {
+		StackIterator it = popStack();
+		// end of stack
+		if ( it.tree == UINT32_MAX ) break;
+		pod::Tree tree = trees[it.tree];
+		// invalid tree
+		if ( tree.type == PRIMITIVE_TYPE_EMPTY ) break;
+		// new tree, parse collision
+		if ( it.child == UINT32_MAX ) {
+			float t = treeIntersect( rayO, rayD, rayDRecip, tree );
+			// bad intersection with this tree, continue with next iteration
+			std::cout << "[?] Collision: 0 < " << t << " < " << resT << std::endl;
+			if ( t <= EPSILON || t >= resT ) continue;
+			// push back with new stack
+			it.child = 0;
+			pushStack( it );
+			// continue with next iteration
+			continue;
+		} else if ( it.child >= TREE_SIZE ) {
+			// no new children, continue with next iteration
+			continue;
+		} else {
+			// is leaf
+			if ( tree.type == PRIMITIVE_TYPE_LEAF ) {
+				// check children for a match
+				for ( uint i = 0; i < TREE_SIZE; ++i ) {
+					uint branchId = tree.children[i];
+					// unallocated, skip
+					if ( branchId == UINT32_MAX ) continue;
+					pod::Primitive primitive = cubes[branchId];
+					if ( primitive.type == PRIMITIVE_TYPE_EMPTY ) continue;
+					float t = cubeIntersect( rayO, rayD, rayDRecip, primitive );
+					// branch intersects with ray, set as new parent
+					if ( (t <= EPSILON) || (t >= resT) ) continue;
+					id = branchId;
+					resT = t;
+				}
+				// continue with next iteration
+				continue;
+			}
+			// parse children
+			uint branchId = tree.children[it.child++];
+			// add new iterator to the stack
+			pushStack( it );
+			// unused child, continue with next iteration
+			if ( branchId == UINT32_MAX ) continue;
+			// tree branch, push to stack
+			// the first if block will check its collision
+			it.tree = branchId;
+			it.child = UINT32_MAX;
+			pushStack( it );
+			continue;
+		}
+	}
+	std::cout << "ID: " << id << std::endl;
+}
\ No newline at end of file
diff --git a/engine/src/utils/math/simd/simd.cpp b/engine/src/utils/math/simd/simd.cpp
new file mode 100644
index 00000000..53745311
--- /dev/null
+++ b/engine/src/utils/math/simd/simd.cpp
@@ -0,0 +1,22 @@
+#include <uf/utils/math/vector.h>
+#if UF_USE_SIMD
+
+#if SSE_INSTR_SET > 7                  // AVX2 and later
+	#pragma message "Using AVX2"
+#elif SSE_INSTR_SET == 7
+	#pragma message "Using AVX"
+#elif SSE_INSTR_SET == 6
+	#pragma message "Using SSE4.2"
+#elif SSE_INSTR_SET == 5
+	#pragma message "Using SSE4.1"
+#elif SSE_INSTR_SET == 4
+	#pragma message "Using SSSE3"
+#elif SSE_INSTR_SET == 3
+	#pragma message "Using SSE3"
+#elif SSE_INSTR_SET == 2
+	#pragma message "Using SSE2"
+#elif SSE_INSTR_SET == 1
+	#pragma message "Using SSE"
+#endif
+
+#endif
\ No newline at end of file
diff --git a/engine/src/utils/mempool/mempool.cpp b/engine/src/utils/mempool/mempool.cpp
new file mode 100644
index 00000000..a7dceefb
--- /dev/null
+++ b/engine/src/utils/mempool/mempool.cpp
@@ -0,0 +1,321 @@
+#include <uf/utils/mempool/mempool.h>
+#include <uf/utils/userdata/userdata.h>
+
+#include <cstring>
+#include <iostream>
+#include <sstream>
+#include <uf/utils/serialize/serializer.h>
+#include <uf/utils/thread/perthread.h>
+#include <uf/utils/io/iostream.h>
+
+namespace {
+	uf::ThreadUnique<bool> globalOverrides;
+}
+
+#define DEBUG_PRINT 0
+
+bool uf::MemoryPool::globalOverride = true;
+bool uf::MemoryPool::subPool = true;
+uf::MemoryPool uf::MemoryPool::global;
+
+uf::MemoryPool::MemoryPool( size_t size ) {
+	if ( size > 0 ) this->initialize( size );
+}
+uf::MemoryPool::~MemoryPool( ) {
+	this->destroy();
+}
+size_t uf::MemoryPool::size() const {
+	return this->m_size;
+}
+size_t uf::MemoryPool::allocated() const {
+	size_t allocated = 0;
+	for ( auto& allocation : this->m_allocations ) {
+		allocated += allocation.size;
+	}
+	return allocated;
+}
+std::string uf::MemoryPool::stats() const {
+	uf::Serializer metadata;
+
+	size_t size = this->size();
+	size_t allocated = this->allocated();
+
+	metadata["size"] = size;
+	metadata["used"] = allocated;
+	metadata["free"] = size - allocated;
+	metadata["objects"] = this->m_allocations.size();
+	{
+		std::stringstream ss; ss << std::hex << (void*) this->m_pool;
+		metadata["pool"] = ss.str();
+	}
+
+	return metadata;
+}
+void uf::MemoryPool::initialize( size_t size ) {
+	if ( size <= 0 ) return;
+	if ( this->size() > 0 ) this->destroy();
+	this->m_size = size;
+	if ( uf::MemoryPool::subPool && uf::MemoryPool::global.size() > 0 && this != &uf::MemoryPool::global ) {
+		this->m_pool = (uint8_t*) uf::MemoryPool::global.alloc( NULL, size );
+	} else {
+		this->m_pool = (uint8_t*) malloc( size );
+	}
+	memset( this->m_pool, 0, size );
+}
+void uf::MemoryPool::destroy() {
+	if ( this->size() <= 0 ) return;
+	if ( uf::MemoryPool::subPool && this != &uf::MemoryPool::global ) {
+		uf::MemoryPool::global.free( this->m_pool );
+	} else {
+		delete[] this->m_pool;
+	}
+	this->m_size = 0;
+	this->m_pool = NULL;
+}
+
+pod::Allocation uf::MemoryPool::allocate( void* data, size_t size ) {
+	if ( UF_MEMORYPOOL_MUTEX ) this->m_mutex.lock();
+	// find next available allocation
+	size_t index = 0;
+	size_t len = this->size();
+	pod::Allocation allocation;
+	// pool not initialized
+	if ( len <= 0 ) {
+		if ( DEBUG_PRINT ) uf::iostream << "CANNOT MALLOC: " << size << ", POOL NOT INITIALIZED" << "\n";
+		goto MANUAL_MALLOC;
+	}
+
+	// an optimization by quickly reusing free'd allocations seemed like a good idea
+	// but still have to iterate through allocation information
+	// to keep allocation information in order
+
+	// check our cache of first
+#if UF_MEMORYPOOL_CACHED_ALLOCATIONS
+	if ( !this->m_cachedFreeAllocations.empty() ) {
+		auto it = this->m_cachedFreeAllocations.begin();
+		// check if any recently free'd allocation is big enough for our new allocation
+		for ( ; it != this->m_cachedFreeAllocations.end(); ++it ) {
+			if ( it->size < size ) break;
+		}
+		// found a suitable allocation, use it
+		if ( it != this->m_cachedFreeAllocations.end() ) {
+			index = it->index;
+			// find where to insert in our allocation table
+			auto next = this->m_allocations.begin();
+			while ( next != this->m_allocations.end() ) {
+				if ( index + size < next->index  ) break;
+				++next;
+			}
+			// check if it was actually valid
+			if ( next != this->m_allocations.end() ) {	
+				// initialize allocation info
+				allocation.index = index;
+				allocation.size = size;
+				allocation.pointer = &this->m_pool[0] + index;
+				
+				// security
+				if ( data ) memcpy( allocation.pointer, data, size );
+				else memset( allocation.pointer, 0, size );
+
+				// overrides if we're overloading global new/delete
+				globalOverrides.get() = true;
+				// register as allocated
+				this->m_allocations.insert(next, allocation);
+				globalOverrides.get() = false;
+
+				goto RETURN;
+			}
+			// remove from cache
+			this->m_cachedFreeAllocations.erase(it);
+		}
+	}
+#endif
+	{
+		// find any availble spots in-between existing allocations
+		auto next = this->m_allocations.begin();
+		for ( auto it = next; it != this->m_allocations.end(); ++it ) {
+			index = it->index + it->size;
+			if ( ++next == this->m_allocations.end() ) break;
+			// target index is behind next allocated space, use it
+			if ( index < next->index ) break;
+		}
+		// no allocation found, OOM
+		if ( index + size > len ) {
+			uf::iostream << "MemoryPool: " << this << ": Out of Memory!\n";
+			uf::iostream << "Trying to request " << size << " bytes of memory\n";
+			uf::iostream << "Stats: " << this->stats() << "\n";
+			goto MANUAL_MALLOC;
+		}
+
+		// initialize allocation info
+		allocation.index = index;
+		allocation.size = size;
+		allocation.pointer = &this->m_pool[0] + index;
+		
+		// security
+		if ( data ) memcpy( allocation.pointer, data, size );
+		else memset( allocation.pointer, 0, size );
+
+		// overrides if we're overloading global new/delete
+		globalOverrides.get() = true;
+		// register as allocated
+		this->m_allocations.insert(next, allocation);
+		globalOverrides.get() = false;
+	}
+	goto RETURN;
+MANUAL_MALLOC:
+	if ( UF_MEMORYPOOL_INVALID_MALLOC ) {
+		allocation.index = -1;
+		allocation.size = size;
+		allocation.pointer = malloc(size);
+	} else {
+		UF_EXCEPTION("INVALID MALLOC");
+	}
+RETURN:
+	if ( UF_MEMORYPOOL_MUTEX ) this->m_mutex.unlock();
+	if ( DEBUG_PRINT ) uf::iostream << "MALLOC'd: " << allocation.pointer << ", " << allocation.size << ", " << allocation.index << "\n";
+	return allocation;
+}
+void* uf::MemoryPool::alloc( void* data, size_t size ) {
+	auto allocation = this->allocate( data, size );
+	return allocation.pointer;
+}
+
+pod::Allocation& uf::MemoryPool::fetch( size_t index, size_t size ) {
+	static pod::Allocation missing;
+	for ( auto& allocation : this->m_allocations ) {
+		if ( index == allocation.index ) {
+			if ( (size > 0 && allocation.size == size) || (size == 0) ) return allocation;
+		}
+	}
+	return missing;
+}
+bool uf::MemoryPool::exists( void* pointer, size_t size ) {
+	// bound check
+	if ( pointer < &this->m_pool[0] ) return false;
+	size_t index = (uint8_t*) pointer - &this->m_pool[0];
+	// size check
+	if ( size > 0 ) {
+		auto& allocation = this->fetch( index, size );
+		return allocation.index == index && allocation.size == size;
+	}
+	return true;
+}
+bool uf::MemoryPool::free( void* pointer, size_t size ) {
+	if ( UF_MEMORYPOOL_MUTEX ) this->m_mutex.lock();
+	// fail if uninitialized or pointer is outside of our pool
+	if ( this->m_size <= 0 || pointer < &this->m_pool[0] || pointer >= &this->m_pool[0] + this->m_size ) {
+		if ( DEBUG_PRINT ) uf::iostream << "CANNOT FREE: " << pointer << ", ERROR: " << (this->m_size <= 0) << " " << (pointer < &this->m_pool[0]) << " " << (pointer >= &this->m_pool[0] + this->m_size) << "\n";
+		goto MANUAL_FREE;
+	}
+	{
+		// pointer arithmatic
+		size_t index = (uint8_t*) pointer - &this->m_pool[0];
+		auto it = this->m_allocations.begin();
+		pod::Allocation allocation;
+		// find our allocation in the allocation pool
+		for ( ; it != this->m_allocations.end(); ++it ) {
+			if ( it->index == index ) {
+				allocation = *it;
+				break;
+			}
+		}
+		// pointer isn't actually allocated
+		if ( allocation.index != index ) {
+			if ( DEBUG_PRINT ) uf::iostream << "CANNOT FREE: " << pointer << ", NOT FOUND" << "\n";
+			goto MANUAL_FREE;
+		}
+		// size validation mismatch, do not free
+		if (size > 0 && allocation.size != size) {
+			if ( DEBUG_PRINT ) uf::iostream << "CANNOT FREE: " << pointer << ", MISMATCHED SIZES (" << size << " != " << allocation.size << ")" << "\n";
+			goto MANUAL_FREE;
+		}
+		if ( DEBUG_PRINT ) uf::iostream << "FREE'D ALLOCATION: " << pointer << ", " << size << "\t" << allocation.pointer << ", " << allocation.size << ", " << allocation.index << "\n";
+		// remove from our allocation table...
+		this->m_allocations.erase(it);
+		// ...but add it to our free'd allocation cache
+#if UF_MEMORYPOOL_CACHED_ALLOCATIONS
+		this->m_cachedFreeAllocations.push_back(allocation);
+#endif
+		if ( UF_MEMORYPOOL_MUTEX ) this->m_mutex.unlock();
+		return true;
+	}
+MANUAL_FREE:
+	if ( UF_MEMORYPOOL_MUTEX ) this->m_mutex.unlock();
+	if ( UF_MEMORYPOOL_INVALID_FREE ) ::free(pointer);
+	return false;
+}
+
+const uf::MemoryPool::allocations_t& uf::MemoryPool::allocations() const {
+	return this->m_allocations;
+}
+#if UF_MEMORYPOOL_OVERRIDE_NEW_DELETE
+void* operator new( size_t size ) {
+	if ( !uf::MemoryPool::globalOverride || globalOverrides.get() || uf::MemoryPool::global.size() <= 0 )
+		return malloc(size);
+	return uf::MemoryPool::global.alloc( (void*) NULL, size );
+}
+void operator delete( void* pointer ) {
+	if ( !uf::MemoryPool::globalOverride ) return ::free( pointer );
+	uf::MemoryPool::global.free( pointer );
+}
+#endif
+/*
+uf::MemoryPool::Iterator uf::MemoryPool::begin() {
+	static pod::Allocation end;
+	end = {
+		.index = 0
+		.size = 0,
+		.pointer = this->m_pool
+	};
+	struct {
+		pod::Allocation* begin = NULL;
+		pod::Allocation* end = NULL;
+		pod::Allocation* next = NULL;
+	} pointers;
+	pointers.begin = &end;
+	pointers.end = &end;
+	pointers.prev = &end;
+
+	if ( this->m_allocations.size() > 0 ) {
+		auto it = this->m_allocations.begin();
+		pointers.begin = &(*it++);
+		if ( it != this->m_allocations.end() )
+			pointers.next = &(*it);
+	}
+
+	return {
+		.pool = *this,
+		.allocation = *pointers.begin,
+		.prev = *pointers.end,
+		.next = *pointers.next
+	};
+}
+uf::MemoryPool::Iterator uf::MemoryPool::end() {
+	static pod::Allocation end;
+	end = {
+		.index = this->m_size,
+		.size = this->m_size,
+		.pointer = this->m_pool + this->m_size;
+	}
+	struct {
+		pod::Allocation* end = NULL;
+		pod::Allocation* prev = NULL;
+	} pointers;
+	
+	if ( this->m_allocations.size() > 0 ) {
+		auto it = this->m_allocations.begin();
+		pointers.end = &(*it++);
+		if ( it != this->m_allocations.end() )
+			pointers.prev = &(*it);
+	}
+	pointers.prev = &end;
+
+	return {
+		.pool = *this,
+		.allocation = *pointers.end,
+		.prev = *pointers.prev,
+		.next = *pointers.end
+	};
+}
+*/
\ No newline at end of file
diff --git a/engine/src/utils/mesh/grid.cpp b/engine/src/utils/mesh/grid.cpp
new file mode 100644
index 00000000..cdd0c789
--- /dev/null
+++ b/engine/src/utils/mesh/grid.cpp
@@ -0,0 +1,273 @@
+#include <uf/utils/mempool/mempool.h>
+#include <uf/utils/mesh/grid.h>
+#include <uf/utils/math/collision/mesh.h>
+#include <uf/utils/math/collision/boundingbox.h>
+
+uf::MeshGrid::~MeshGrid() {
+	this->destroy();
+}
+
+void uf::MeshGrid::initialize( const pod::Vector3f& center, const pod::Vector3f& extent, const pod::Vector3ui& size ) {
+	float epsilon = 1.0f;
+	this->m_center = center;
+	this->m_extent = extent + pod::Vector3f{ epsilon, epsilon, epsilon };
+	this->m_size = size;
+
+	pod::Vector3f min = center - extent;
+	pod::Vector3f max = center + extent;
+
+	this->m_nodes.reserve(size.x * size.y * size.y);
+	for ( size_t z = 0; z < size.z; ++z )
+	for ( size_t y = 0; y < size.y; ++y )
+	for ( size_t x = 0; x < size.x; ++x ) {
+		auto& node = this->m_nodes.emplace_back();
+		node.extent = pod::Vector3f{ extent.x / size.x, extent.y / size.y, extent.z / size.z };
+		node.center = min + node.extent * pod::Vector3f{ 1 + 2 * x, 1 + 2 * y, 1 + 2 * z };
+	}
+}
+void uf::MeshGrid::destroy() {
+#if 0 
+	for ( auto& node : this->m_nodes ) {
+	#if UF_MEMORYPOOL_INVALID_FREE
+		uf::MemoryPool::global.free( node.indices );
+	#else
+		uf::MemoryPool* memoryPool = uf::MemoryPool::global.size() > 0 ? &uf::MemoryPool::global : NULL;	
+		if ( memoryPool ) memoryPool->free( node.indices );
+		else free( node.indices );
+	#endif
+		node.size = 0;
+		node.indices = NULL;
+	}
+#endif
+	this->m_nodes.clear();
+}
+
+void uf::MeshGrid::allocate( uf::MeshGrid::Node& node, size_t indices ) {
+#if 0
+	size_t size = indices * sizeof(uint32_t);
+	uint32_t* buffer = NULL;
+
+#if UF_MEMORYPOOL_INVALID_MALLOC
+	buffer = (void*) uf::MemoryPool::global.alloc( data, size );
+#else
+	uf::MemoryPool* memoryPool = uf::MemoryPool::global.size() > 0 ? &uf::MemoryPool::global : NULL;
+	if ( memoryPool )
+		buffer = (void*) memoryPool->alloc( data, size );
+	else {
+		buffer = malloc( size );
+		memset( buffer, 0, size );
+	}
+#endif
+	node.count = indices;
+	node.indices = buffer;
+#else
+	node.indices.reserve( indices );
+#endif
+}
+
+uf::MeshGrid::Node& uf::MeshGrid::at( const pod::Vector3f& point ) {
+	// naive way, bound check every node
+	for ( auto& node : this->m_nodes ) {
+		pod::Vector3f min = node.center - node.extent;
+		pod::Vector3f max = node.center + node.extent;
+		if ( min.x < point.x && point.x < max.x && min.y < point.y && point.y < max.y && min.z < point.z && point.z < max.z ) return node;
+	//	if ( min <= point && point <= max ) return node;
+	}
+	return this->m_nodes.front();
+}
+const uf::MeshGrid::Node& uf::MeshGrid::at( const pod::Vector3f& point ) const {
+	// naive way, bound check every node
+	for ( auto& node : this->m_nodes ) {
+		pod::Vector3f min = node.center - node.extent;
+		pod::Vector3f max = node.center + node.extent;
+		if ( min.x < point.x && point.x < max.x && min.y < point.y && point.y < max.y && min.z < point.z && point.z < max.z ) return node;
+	//	if ( min <= point && point <= max ) return node;
+	}
+	return this->m_nodes.front();
+}
+pod::Vector3f uf::MeshGrid::centroid( const pod::Vector3f& p1, const pod::Vector3f& p2, const pod::Vector3f& p3 ) const {
+	return (p1 + p2 + p3) / 3;
+}
+
+const pod::Vector3f& uf::MeshGrid::center() const { return this->m_center; }
+const pod::Vector3f& uf::MeshGrid::extent() const { return this->m_extent; }
+
+void uf::MeshGrid::insert( uint32_t i1, uint32_t i2, uint32_t i3, const pod::Vector3f& v1, const pod::Vector3f& v2, const pod::Vector3f& v3 ) {
+#if 1
+	bool useStrongest = false;
+	int32_t strongestNode = -1;
+	pod::Collider::Manifold strongestManifold = {};	
+	for ( size_t i = 0; i < this->m_nodes.size(); ++i ) {
+		auto& node = this->m_nodes[i];
+		uf::MeshCollider cTriangle;
+		cTriangle.setPositions({v1,v2,v3});
+
+		uf::BoundingBox cNode;
+		cNode.setOrigin( node.center );
+		cNode.setCorner( node.extent );
+
+		auto manifold = cTriangle.intersects( cNode );
+		if ( manifold.colliding ) {
+			if ( useStrongest && manifold.depth > strongestManifold.depth ) {
+				strongestManifold = manifold;
+			} else {
+				node.indices.emplace_back(i1);
+				node.indices.emplace_back(i2);
+				node.indices.emplace_back(i3);
+			}
+		}
+	}
+	if ( useStrongest && strongestNode >= 0 ) {
+		auto& node = this->m_nodes[strongestNode];
+		node.indices.emplace_back(i1);
+		node.indices.emplace_back(i2);
+		node.indices.emplace_back(i3);
+	}
+#endif
+#if 0
+	auto center = centroid( v1, v2, v3 );
+	for ( size_t i = 0; i < this->m_nodes.size(); ++i ) {
+		auto& node = this->m_nodes[i];
+		pod::Vector3f min = node.center - node.extent;
+		pod::Vector3f max = node.center + node.extent;
+		if ( 
+			( min.x < v1.x && v1.x < max.x && min.y < v1.y && v1.y < max.y && min.z < v1.z && v1.z < max.z ) ||
+			( min.x < v2.x && v2.x < max.x && min.y < v2.y && v2.y < max.y && min.z < v2.z && v2.z < max.z ) ||
+			( min.x < v3.x && v3.x < max.x && min.y < v3.y && v3.y < max.y && min.z < v3.z && v3.z < max.z ) ||
+			( min.x < center.x && center.x < max.x && min.y < center.y && center.y < max.y && min.z < center.z && center.z < max.z )	
+	//		( min <= v1 && v1 <= max ) || ( min <= v2 && v2 <= max ) || ( min <= v3 && v3 <= max ) || ( min <= center && center <= max )
+		) {
+			node.indices.emplace_back(i1);
+			node.indices.emplace_back(i2);
+			node.indices.emplace_back(i3);
+		}
+	}
+#endif
+#if 0
+	// get associated node
+	auto& node = at( centroid( v1, v2, v3 ) );
+	// naive way: inserting triangle's indices rather than the triangle's position in the indices
+	node.indices.emplace_back(i1);
+	node.indices.emplace_back(i2);
+	node.indices.emplace_back(i3);
+#endif
+}
+
+void uf::MeshGrid::analyze() const {
+	pod::Vector3f min = this->m_center - this->m_extent;
+	pod::Vector3f max = this->m_center + this->m_extent;
+	UF_DEBUG_MSG(
+		"Region count: " << this->m_nodes.size() << " | "
+		"Size: " << uf::vector::toString(this->m_size) << " | "
+		"Center: " << uf::vector::toString(this->m_center) << " | "
+		"Extent: " << uf::vector::toString(this->m_extent) << " | "
+		"Min: " << uf::vector::toString(min) << " | "
+		"Max: " << uf::vector::toString(max)
+	);
+	size_t total = 0;
+	for ( auto& node : this->m_nodes ) total += node.indices.size();
+	for ( size_t i = 0; i < this->m_nodes.size(); ++i ) {
+		auto& node = this->m_nodes[i];
+		UF_DEBUG_MSG("Node[" << i << "]: Center: " << uf::vector::toString(node.center) << " | Percentage: " << ( 100.0f * (float) node.indices.size() / (float) total ) << "%" );
+	}
+}
+
+#if 0
+namespace {
+	enum Swizzle {
+		XYZ, YZX, ZXY
+	} swizzle = Swizzle::YZX;
+}
+size_t uf::MeshGrid::wrapPosition( const pod::Vector3f& position ) {
+	// ordered from first to change to last to change
+	pod::Vector3f input;
+	pod::Vector3f size;
+	switch ( ::swizzle ) {
+		case Swizzle::YZX:
+			input = {
+				position.x,
+				position.z,
+				position.y,
+			};
+			size = {
+				this->m_size.x,
+				this->m_size.z,
+				this->m_size.y,
+			};
+		break;
+		case Swizzle::ZXY:
+			input = {
+				position.y,
+				position.x,
+				position.z,
+			};
+			size = {
+				this->m_size.y,
+				this->m_size.x,
+				this->m_size.z,
+			};
+		break;
+		case Swizzle::XYZ:
+			input = {
+				position.z,
+				position.y,
+				position.x,
+			};
+			size = {
+				this->m_size.z,
+				this->m_size.y,
+				this->m_size.x,
+			};
+		break;
+	}
+	return size.y * size.x * input.z + size.x * input.y + input.x;
+}
+pod::Vector3i uf::MeshGrid::unwrapIndex( size_t i ) {
+	// ordered from first to change to last to change
+	/*
+		result.x = i % this->m_size.x;
+		result.y = ( i / this->m_size.x ) % this->m_size.y;
+		result.z = i / ( this->m_size.x * this->m_size.y );
+	*/
+	pod::Vector3ui size;
+	switch ( ::swizzle ) {
+		case Swizzle::YZX:
+			size = {
+				this->m_size.x,
+				this->m_size.z,
+				this->m_size.y,
+			};
+			return {
+				i % size.x,
+				i / ( size.x * size.y ),
+				( i / size.x ) % size.y,
+			};
+		break;
+		case Swizzle::ZXY:
+			size = {
+				this->m_size.y,
+				this->m_size.x,
+				this->m_size.z,
+			};
+			return {
+				( i / size.x ) % size.y,
+				i % size.x,
+				i / ( size.x * size.y ),
+			};
+		break;
+		case Swizzle::XYZ:
+		default:
+			size = {
+				this->m_size.z,
+				this->m_size.y,
+				this->m_size.x,
+			};
+			return {
+				( i / size.x ) % size.y,
+				i / ( size.x * size.y ),
+				i % size.x,
+			};
+		break;
+	}
+}
+#endif
\ No newline at end of file
diff --git a/engine/src/utils/noise/perlin.cpp b/engine/src/utils/noise/perlin.cpp
new file mode 100644
index 00000000..085ed72f
--- /dev/null
+++ b/engine/src/utils/noise/perlin.cpp
@@ -0,0 +1,133 @@
+#include <uf/utils/noise/noise.h>
+
+uf::PerlinNoise::PerlinNoise() {
+	this->m_permutations = {
+		151,160,137,91,90,15,131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,
+		8,99,37,240,21,10,23,190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,
+		35,11,32,57,177,33,88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,
+		134,139,48,27,166,77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,
+		55,46,245,40,244,102,143,54, 65,25,63,161,1,216,80,73,209,76,132,187,208, 89,
+		18,169,200,196,135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,
+		250,124,123,5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,
+		189,28,42,223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167,
+		43,172,9,129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,
+		97,228,251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,
+		107,49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,
+		138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180
+	};
+	this->m_permutations.insert(this->m_permutations.end(), this->m_permutations.begin(), this->m_permutations.end());
+}
+uf::PerlinNoise::PerlinNoise(std::size_t seed) {
+	this->seed(seed);
+}
+std::size_t uf::PerlinNoise::seed() const {
+	return this->m_seed;
+}
+void uf::PerlinNoise::seed( std::size_t seed ) {
+	this->m_seed = seed;
+	this->m_permutations.clear();
+	this->m_permutations.resize(256);
+
+	std::iota(this->m_permutations.begin(), this->m_permutations.end(), 0);
+	std::default_random_engine engine(this->m_seed);
+	std::shuffle(this->m_permutations.begin(), this->m_permutations.end(), engine);
+	this->m_permutations.insert(this->m_permutations.end(), this->m_permutations.begin(), this->m_permutations.end());
+}
+double uf::PerlinNoise::noise( double x, double y, double z ) const {
+	// Find the unit cube that contains the point
+	int X = (int) std::floor(x) & 255;
+	int Y = (int) std::floor(y) & 255;
+	int Z = (int) std::floor(z) & 255;
+	// Find relative x, y,z of point in cube
+	x -= std::floor(x);
+	y -= std::floor(y);
+	z -= std::floor(z);
+	// Compute fade curves for each of x, y, z
+	double u = fade(x);
+	double v = fade(y);
+	double w = fade(z);
+	// P
+	auto& p = this->m_permutations;
+	// Hash coordinates of the 8 cube corners
+	int A = p[X] + Y;
+	int AA = p[A] + Z;
+	int AB = p[A + 1] + Z;
+	int B = p[X + 1] + Y;
+	int BA = p[B] + Z;
+	int BB = p[B + 1] + Z;
+	// Add blended results from 8 corners of cube
+	double res = lerp(w, lerp(v, lerp(u, grad(p[AA], x, y, z), grad(p[BA], x-1, y, z)), lerp(u, grad(p[AB], x, y-1, z), grad(p[BB], x-1, y-1, z))), lerp(v, lerp(u, grad(p[AA+1], x, y, z-1), grad(p[BA+1], x-1, y, z-1)), lerp(u, grad(p[AB+1], x, y-1, z-1), grad(p[BB+1], x-1, y-1, z-1))));
+	return (res + 1.0)/2.0;
+}
+double uf::PerlinNoise::fade(double t) const {
+	return t * t * t * (t * (t * 6 - 15) + 10);
+}
+double uf::PerlinNoise::lerp(double t, double a, double b) const {
+	return a + t * (b - a);
+}
+double uf::PerlinNoise::grad(int hash, double x, double y, double z) const {
+	int h = hash & 15;
+	// Convert lower 4 bits of hash inot 12 gradient directions
+	double u = h < 8 ? x : y,
+	v = h < 4 ? y : h == 12 || h == 14 ? x : z;
+	return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
+}
+std::vector<double> uf::PerlinNoise::collect( uint size, const pod::Vector3d& noiseCoeff, const callback_t& callback ) {
+	std::vector<double> res;
+	res.reserve( size );
+	for(unsigned int i = 0; i < size; ++i) { // x
+		double x = (double)i/((double)size);
+
+		double n = this->noise(noiseCoeff.x * x, noiseCoeff.y, noiseCoeff.z);
+		callback(n);
+		res.push_back(n);
+	}
+	return res;
+}
+std::vector<double> uf::PerlinNoise::collect( const pod::Vector2ui& size, const pod::Vector3d& noiseCoeff, const callback_t& callback ) {
+	std::vector<double> res;
+	res.reserve( size.x * size.y );
+	for(unsigned int i = 0; i < size.y; ++i) { // y
+	for(unsigned int j = 0; j < size.x; ++j) { // x
+		double x = (double)j/((double)size.x);
+		double y = (double)i/((double)size.y);
+
+		double n = this->noise(noiseCoeff.x * x, noiseCoeff.y * y, noiseCoeff.z);
+		callback(n);
+		res.push_back(n);
+	}
+	}
+	return res;
+}
+std::vector<double> uf::PerlinNoise::collect( const pod::Vector3ui& size, const pod::Vector3d& noiseCoeff, const callback_t& callback ) {
+	std::vector<double> res;
+	res.reserve( size.x * size.y * size.z );
+	for(unsigned int Z = 0; Z < size.z; ++Z) { // z
+	for(unsigned int Y = 0; Y < size.y; ++Y) { // y
+	for(unsigned int X = 0; X < size.x; ++X) { // x
+		double x = (double) Z / (double) size.x;
+		double y = (double) Y / (double) size.y;
+		double z = (double) X / (double) size.z;
+
+		double n = this->noise(noiseCoeff.x * x, noiseCoeff.y * y, noiseCoeff.z * z);
+		callback(n);
+		res.push_back(n);
+	}
+	}
+	}
+	return res;
+}
+
+double uf::PerlinNoise::sample( const pod::Vector3d& position, const pod::Vector3d& noiseCoeff, const callback_t& callback ) {
+	std::vector<double> res;
+	double n = this->noise(noiseCoeff.x * position.x, noiseCoeff.y * position.y, noiseCoeff.z * position.z);
+	callback(n);
+	return n;
+}
+
+double uf::PerlinNoise::sample( const pod::Vector3f& position, const pod::Vector3d& noiseCoeff, const callback_t& callback ) {
+	std::vector<double> res;
+	double n = this->noise(noiseCoeff.x * position.x, noiseCoeff.y * position.y, noiseCoeff.z * position.z);
+	callback(n);
+	return n;
+}
\ No newline at end of file
diff --git a/engine/src/utils/serialize/serializable.cpp b/engine/src/utils/serialize/serializable.cpp
new file mode 100644
index 00000000..31aad235
--- /dev/null
+++ b/engine/src/utils/serialize/serializable.cpp
@@ -0,0 +1,12 @@
+#include <uf/utils/serialize/serializable.h>
+
+ void uf::Serializable::deserialize( const Serializer& input ) {
+ 	this->deserialize((const Serializer::input_t&) input);
+ }
+
+void uf::Serializable::operator<<( const Serializer::input_t& input ) {
+	this->deserialize(input);
+}
+void uf::Serializable::operator>>( Serializer::output_t& output ) {
+	output = this->serialize();
+}
\ No newline at end of file
diff --git a/engine/src/utils/serialize/serializer.cpp b/engine/src/utils/serialize/serializer.cpp
new file mode 100644
index 00000000..436ab197
--- /dev/null
+++ b/engine/src/utils/serialize/serializer.cpp
@@ -0,0 +1,188 @@
+#include <uf/utils/serialize/serializer.h>
+#include <uf/utils/string/string.h>
+#include <uf/utils/string/ext.h>
+
+#include <uf/utils/io/iostream.h>
+
+#include <sstream>
+#include <fstream>
+#include <functional>
+
+uf::Serializer::Serializer( const std::string& str ) { //: sol::table(ext::lua::state, sol::create) {
+	this->deserialize(str);
+}
+#if UF_USE_LUA
+uf::Serializer::Serializer( const sol::table& table ) { //: sol::table(ext::lua::state, sol::create) {
+	this->deserialize( ext::json::encode( table ) );
+}
+#endif
+uf::Serializer::Serializer( const ext::json::Value& json ) { //: sol::table(ext::lua::state, sol::create) {
+//	this->deserialize( ext::json::encode( json ) );
+	*this = json;
+}
+uf::Serializer::Serializer( const ext::json::base_value& json ) { //: sol::table(ext::lua::state, sol::create) {
+//	this->deserialize( ext::json::encode( json ) );
+	*this = json;
+}
+uf::Serializer::output_t uf::Serializer::serialize( bool pretty ) const {
+	return ext::json::encode( *this, pretty );
+}
+uf::Serializer::output_t uf::Serializer::serialize( size_t precision, bool pretty ) const {
+	return ext::json::encode( *this, precision, pretty );
+}
+void uf::Serializer::deserialize( const std::string& str ) {
+	if ( str == "" ) return;
+	ext::json::decode( *this, str );
+}
+
+bool uf::Serializer::readFromFile( const std::string& from, const std::string& hash ) {
+	uf::String string;
+	bool exists = uf::io::exists(from);
+	if ( !exists ) {
+		UF_ERROR_MSG("Failed to read JSON file `" << from << "`: does not exist");
+		return false;
+	}
+	auto buffer = uf::io::readAsBuffer( from, hash );
+	if ( buffer.empty() ) {
+		UF_ERROR_MSG("Failed to read JSON file `" << from << "`: empty file or hash mismatch");
+		return false;
+	}
+
+	auto& str = string.getString();
+	str.reserve(buffer.size());
+	str.assign(buffer.begin(), buffer.end());
+
+	this->deserialize(string);
+	return true;
+/*	
+	struct {
+		std::ifstream input;
+		uf::String buffer;
+		std::string filename;
+		bool exists;
+	} file; {
+		file.exists = uf::io::exists(from);
+		file.filename = from;
+	}
+
+	if ( !file.exists ) return false;
+
+	file.input.open(file.filename, std::ios::binary );
+	file.input.seekg(0, std::ios::end);
+	str.reserve(file.input.tellg());
+	file.input.seekg(0, std::ios::beg);
+	str.assign((std::istreambuf_iterator<char>(file.input)),std::istreambuf_iterator<char>());
+	file.input.close();
+
+	this->deserialize(file.buffer);
+	return true;
+*/
+}
+bool uf::Serializer::writeToFile( const std::string& to ) const {
+	std::string buffer = this->serialize();
+	std::ofstream output;
+	output.open(to, std::ios::binary);
+	output.write( buffer.c_str(), buffer.size() );
+	output.close();
+	return true;
+}
+bool uf::Serializer::writeToFile( const std::string& to, size_t precision ) const {
+	std::string buffer = this->serialize(precision);
+	std::ofstream output;
+	output.open(to, std::ios::binary);
+	output.write( buffer.c_str(), buffer.size() );
+	output.close();
+	return true;
+}
+
+void uf::Serializer::merge( const uf::Serializer& other, bool priority ) {
+	if ( !ext::json::isObject( *this ) || !ext::json::isObject( other ) ) return;
+
+	std::function<void(ext::json::Value&, const ext::json::Value&)> update = [&]( ext::json::Value& a, const ext::json::Value& b ) {
+		if ( !ext::json::isObject( b ) ) return;
+		auto keys = ext::json::keys( b );
+			for ( auto key : keys ) {
+			if( ext::json::isObject(a[key]) && ext::json::isObject(b[key]) ) {
+				update(a[key], b[key]);
+			}
+			if ( !priority )
+				a[key] = b[key];
+		}
+	};
+
+	update(*this, other);
+}
+void uf::Serializer::import( const uf::Serializer& other ) {
+/*
+	uf::Serializer diff = nlohmann::json::diff(*this, other);
+	uf::Serializer filtered;
+	for ( size_t i = 0; i < diff.size(); ++i ) {
+		if ( diff[i]["op"].as<std::string>() != "remove" )
+			filtered.emplace_back(diff[i]);
+	}
+	patch( filtered );
+	std::cout << this->dump(1, '\t') << std::endl;
+*/
+
+	if ( !ext::json::isObject( *this ) || !ext::json::isObject( other ) ) return;
+	std::function<void(ext::json::Value&, const ext::json::Value&)> update = [&]( ext::json::Value& a, const ext::json::Value& b ) {
+		// doesn't exist, just copy it
+		if ( ext::json::isNull( a ) && !ext::json::isNull( b ) ) {
+			a = b;
+		// exists, iterate through children
+		} else if ( ext::json::isObject( a ) && ext::json::isObject( b ) ) {
+			auto keys = ext::json::keys( b );
+			for ( auto key : keys )
+				update(a[key], b[key]);
+		}
+	};
+	update(*this, other);
+}
+ext::json::Value& uf::Serializer::path( const std::string& path ) {
+	auto keys = uf::string::split(path, ".");
+	ext::json::Value* traversal = this;
+	for ( auto& key : keys ) {
+		traversal = &((*traversal)[key]);
+	}
+	return *traversal;
+}
+
+uf::Serializer::operator Serializer::output_t() {
+	return this->serialize();
+}
+uf::Serializer::operator Serializer::output_t() const {
+	return this->serialize();
+}
+
+uf::Serializer& uf::Serializer::operator=( const std::string& str ) {
+	this->deserialize(str);
+	return *this;
+}
+#if UF_USE_LUA
+uf::Serializer& uf::Serializer::operator=( const sol::table& table ) {
+	this->deserialize( ext::json::encode( table ) );
+	return *this;
+}
+#endif
+uf::Serializer& uf::Serializer::operator=( const ext::json::Value& json ) {
+	// this->deserialize( ext::json::encode( json ) );
+	ext::json::Value::operator=(json);
+	return *this;
+}
+uf::Serializer& uf::Serializer::operator=( const ext::json::base_value& json ) {
+	// this->deserialize( ext::json::encode( json ) );
+	ext::json::Value::operator=(json);
+	return *this;
+}
+uf::Serializer& uf::Serializer::operator<<( const std::string& str ) {
+	this->deserialize(str);
+	return *this;
+}
+uf::Serializer& uf::Serializer::operator>>( std::string& str ) {
+	str = this->serialize();
+	return *this;
+}
+const uf::Serializer& uf::Serializer::operator>>( std::string& str ) const {
+	str = this->serialize();
+	return *this;
+}
\ No newline at end of file
diff --git a/engine/src/utils/singletons/pre_main.cpp b/engine/src/utils/singletons/pre_main.cpp
new file mode 100644
index 00000000..f7a4958c
--- /dev/null
+++ b/engine/src/utils/singletons/pre_main.cpp
@@ -0,0 +1,5 @@
+#include <uf/utils/singletons/pre_main.h>
+
+uf::StaticInitialization::StaticInitialization( std::function<void()> fun ) {
+	if ( fun ) fun();
+}
\ No newline at end of file
diff --git a/engine/src/utils/string/base64.cpp b/engine/src/utils/string/base64.cpp
new file mode 100644
index 00000000..e6176a67
--- /dev/null
+++ b/engine/src/utils/string/base64.cpp
@@ -0,0 +1,189 @@
+#include <uf/utils/string/base64.h>
+
+
+static const int B64index[256] = { 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 62, 63, 62, 62, 63, 52, 53, 54, 55,
+56, 57, 58, 59, 60, 61,  0,  0,  0,  0,  0,  0,  0,  0,  1,  2,  3,  4,  5,  6,
+7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,  0,
+0,  0,  0, 63,  0, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51 };
+
+static const uint8_t base64_table[65] =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+std::string uf::base64::encode( const uint8_t* src, size_t len ) {
+    uint8_t *out, *pos;
+    const uint8_t *end, *in;
+
+    size_t olen;
+
+    olen = 4*((len + 2) / 3);
+
+    if (olen < len)
+        return std::string();
+
+    std::string outStr;
+    outStr.resize(olen);
+    out = (uint8_t*)&outStr[0];
+
+    end = src + len;
+    in = src;
+    pos = out;
+    while (end - in >= 3) {
+        *pos++ = base64_table[in[0] >> 2];
+        *pos++ = base64_table[((in[0] & 0x03) << 4) | (in[1] >> 4)];
+        *pos++ = base64_table[((in[1] & 0x0f) << 2) | (in[2] >> 6)];
+        *pos++ = base64_table[in[2] & 0x3f];
+        in += 3;
+    }
+
+    if (end - in) {
+        *pos++ = base64_table[in[0] >> 2];
+        if (end - in == 1) {
+            *pos++ = base64_table[(in[0] & 0x03) << 4];
+            *pos++ = '=';
+        }
+        else {
+            *pos++ = base64_table[((in[0] & 0x03) << 4) |
+                (in[1] >> 4)];
+            *pos++ = base64_table[(in[1] & 0x0f) << 2];
+        }
+        *pos++ = '=';
+    }
+
+    return outStr;
+}
+
+// std::vector<uint8_t> uf::base64::decode( const uint8_t* data, size_t len ) {
+std::vector<uint8_t> uf::base64::decode( const std::string& data ) {
+	size_t len = data.size();
+    uint8_t* p = (uint8_t*) &data[0];
+    int pad = len > 0 && (len % 4 || p[len - 1] == '=');
+    const size_t L = ((len + 3) / 4 - pad) * 4;
+    std::vector<uint8_t> str(L / 4 * 3 + pad, '\0');
+
+    for (size_t i = 0, j = 0; i < L; i += 4)
+    {
+        int n = B64index[p[i]] << 18 | B64index[p[i + 1]] << 12 | B64index[p[i + 2]] << 6 | B64index[p[i + 3]];
+        str[j++] = n >> 16;
+        str[j++] = n >> 8 & 0xFF;
+        str[j++] = n & 0xFF;
+    }
+    if (pad)
+    {
+        int n = B64index[p[L]] << 18 | B64index[p[L + 1]] << 12;
+        str[str.size() - 1] = n >> 16;
+
+        if (len > L + 2 && p[L + 2] != '=')
+        {
+            n |= B64index[p[L + 2]] << 6;
+            str.push_back(n >> 8 & 0xFF);
+        }
+    }
+    return str;
+}
+
+std::string uf::string::base64::encode( const std::string& input ) {
+	return uf::base64::encode( input );
+}
+std::string uf::string::base64::decode( const std::string& input ) {
+	auto v = uf::base64::decode( input );
+	return std::string( v.begin(), v.end() );
+}
+
+/*
+
+static const std::string base64_chars = 
+             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+             "abcdefghijklmnopqrstuvwxyz"
+             "0123456789+/";
+
+
+static inline bool is_base64(uint8_t c) {
+  return (isalnum(c) || (c == '+') || (c == '/'));
+}
+
+std::string uf::base64::encode(const uint8_t* buf, std::size_t bufLen) {
+  std::string ret;
+  int i = 0;
+  int j = 0;
+  uint8_t char_array_3[3];
+  uint8_t char_array_4[4];
+
+  while (bufLen--) {
+    char_array_3[i++] = *(buf++);
+    if (i == 3) {
+      char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
+      char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
+      char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
+      char_array_4[3] = char_array_3[2] & 0x3f;
+
+      for(i = 0; (i <4) ; i++)
+        ret += base64_chars[char_array_4[i]];
+      i = 0;
+    }
+  }
+
+  if (i)
+  {
+    for(j = i; j < 3; j++)
+      char_array_3[j] = '\0';
+
+    char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
+    char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
+    char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
+    char_array_4[3] = char_array_3[2] & 0x3f;
+
+    for (j = 0; (j < i + 1); j++)
+      ret += base64_chars[char_array_4[j]];
+
+    while((i++ < 3))
+      ret += '=';
+  }
+
+  return ret;
+}
+
+std::vector<uint8_t> uf::base64::decode(const std::string& encoded_string) {
+  int in_len = encoded_string.size();
+  int i = 0;
+  int j = 0;
+  int in_ = 0;
+  uint8_t char_array_4[4], char_array_3[3];
+  std::vector<uint8_t> ret;
+
+  while (in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {
+    char_array_4[i++] = encoded_string[in_]; in_++;
+    if (i ==4) {
+      for (i = 0; i <4; i++)
+        char_array_4[i] = base64_chars.find(char_array_4[i]);
+
+      char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
+      char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
+      char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+
+      for (i = 0; (i < 3); i++)
+          ret.push_back(char_array_3[i]);
+      i = 0;
+    }
+  }
+
+  if (i) {
+    for (j = i; j <4; j++)
+      char_array_4[j] = 0;
+
+    for (j = 0; j <4; j++)
+      char_array_4[j] = base64_chars.find(char_array_4[j]);
+
+    char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
+    char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
+    char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+
+    for (j = 0; (j < i - 1); j++) ret.push_back(char_array_3[j]);
+  }
+
+  return ret;
+}
+
+*/
\ No newline at end of file
diff --git a/engine/src/utils/string/ext.cpp b/engine/src/utils/string/ext.cpp
new file mode 100644
index 00000000..d52bac89
--- /dev/null
+++ b/engine/src/utils/string/ext.cpp
@@ -0,0 +1,131 @@
+#include <uf/utils/string/ext.h>
+#include <algorithm>
+#include <bitset>
+#include <iomanip>
+#include <sstream>
+#include <cmath>
+#include <iostream>
+
+std::string UF_API uf::string::lowercase( const std::string& str ) {
+	std::string lower = str;
+	std::transform(lower.begin(), lower.end(), lower.begin(), ::tolower);
+	return lower;
+}
+std::string UF_API uf::string::uppercase( const std::string& str ) {
+	std::string upper = str;
+	std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
+	return upper;
+}
+std::vector<std::string> UF_API uf::string::split( const std::string& str, const std::string& delim ) {
+	std::vector<std::string> tokens;
+	size_t prev = 0, pos = 0;
+	do {
+		pos = str.find(delim, prev);
+		if (pos == std::string::npos) pos = str.length();
+		std::string token = str.substr(prev, pos-prev);
+		if (!token.empty()) tokens.push_back(token);
+		prev = pos + delim.length();
+	} while (pos < str.length() && prev < str.length());
+	if ( tokens.empty() ) tokens.emplace_back(str);
+    return tokens;
+/*
+	std::vector<std::string> cont;
+	size_t last = 0, next = 0;
+	while ((next = str.find(needle, last)) != std::string::npos) {
+		cont.push_back(str.substr(last, next-last));
+		last = next + 1;
+	}
+	cont.push_back( str.substr(last) );
+	return cont;
+*/
+}
+/*
+std::string UF_API uf::string::join( const std::vector<std::string>& strings, const std::string& delim, bool trailing ) {
+	std::stringstream ss;
+	size_t len = strings.size();
+	for ( size_t i = 0; i < len; ++i ) {
+		ss << strings[i];
+		if ( trailing || i + 1 < len ) ss << delim;
+	}
+	return ss.str();
+}
+*/
+std::string UF_API uf::string::replace( const std::string& string, const std::string& search, const std::string& replace ) {
+	std::string result = string;
+	size_t start_pos = string.find(search);
+	if( start_pos == std::string::npos ) return result;
+	result.replace(start_pos, search.length(), replace);
+	return result;
+}
+bool UF_API uf::string::contains( const std::string& string, const std::string& search ) {
+	return string.find(search) != std::string::npos;
+}
+std::string UF_API uf::string::si( double value, const std::string& unit, size_t precision ) {
+	int power = floor(std::log10( value ));
+	double base = value / std::pow( 10, power );
+
+//	std::cout << base << " x 10^" << power << " -> ";
+
+	size_t pValue = -1;
+	#define REDUCE(VAL)\
+		while ( pValue > power && power > VAL ) {\
+			--power;\
+			base *= 10;\
+		}\
+		pValue = VAL;
+	#define INCREASE(VAL)\
+		if ( pValue < power && power < VAL ) std::cout << " (increasing (" << pValue << ", " << VAL << ")) ";\
+		while ( pValue < power && power < VAL ) {\
+			++power;\
+			base /= 10;\
+		}\
+		pValue = VAL;
+	
+	REDUCE(24)
+	REDUCE(21)
+	REDUCE(18)
+	REDUCE(15)
+	REDUCE(12)
+	REDUCE( 9)
+	REDUCE( 6)
+	REDUCE( 3)
+//	REDUCE( 2)
+//	REDUCE( 1)
+	REDUCE( 0)
+/*
+//	INCREASE(-1)
+	INCREASE(-2)
+	INCREASE(-3)
+	INCREASE(-6)
+	INCREASE(-9)
+	INCREASE(-12)
+*/
+
+	// std::cout << base << " x 10^" << power << std::endl;
+
+	std::stringstream ss;
+	ss << std::fixed << std::setprecision(precision) << base;
+	std::string string = ss.str();
+
+	switch ( power ) {
+		case 24: string += "Y"; break;
+		case 21: string += "Z"; break;
+		case 18: string += "E"; break;
+		case 15: string += "P"; break;
+		case 12: string += "T"; break;
+		case  9: string += "G"; break;
+		case  6: string += "M"; break;
+		case  3: string += "k"; break;
+	//	case  2: string += "h"; break;
+	//	case  1: string += "da"; break;
+		case  0: string += ""; break;
+	//	case -1: string += "d"; break;
+		case -2: string += "c"; break;
+		case -3: string += "m"; break;
+		case -6: string += "μ"; break;
+		case -9: string += "n"; break;
+		case-12: string += "p"; break;
+	}
+	string += unit;
+	return string;
+}
\ No newline at end of file
diff --git a/engine/src/utils/string/hash.cpp b/engine/src/utils/string/hash.cpp
new file mode 100644
index 00000000..b57bf29d
--- /dev/null
+++ b/engine/src/utils/string/hash.cpp
@@ -0,0 +1 @@
+#include <uf/utils/string/hash.h>
\ No newline at end of file
diff --git a/engine/src/utils/string/rle.cpp b/engine/src/utils/string/rle.cpp
new file mode 100644
index 00000000..44542dea
--- /dev/null
+++ b/engine/src/utils/string/rle.cpp
@@ -0,0 +1,58 @@
+/*
+#include <uf/utils/string/rle.h>
+
+#include <iostream>
+pod::RLE::string_t uf::rle::encode( const std::vector<uint16_t>& source ) {
+	pod::RLE::string_t destination;
+	destination.reserve( source.size() );
+
+	for ( std::size_t i = 0; i < source.size(); ++i ) {
+		pod::RLE reg = { 1, source[i] };
+		while ( i + 1 < source.size() && source[i] == source[i + 1] ) ++reg.length, ++i;
+		destination.push_back( reg );
+	}
+
+	destination.shrink_to_fit();
+	return destination;
+}
+
+std::vector<uint16_t> uf::rle::decode( const pod::RLE::string_t& source ) {
+	std::vector<uint16_t> destination;
+
+	for ( auto& s : source ) {
+		destination.reserve( destination.size() + s.length );
+		for ( std::size_t i = 0; i < s.length; ++i ) destination.push_back(s.value);
+	}
+
+	destination.shrink_to_fit();
+	return destination;
+}
+
+pod::RLE::string_t uf::rle::wrap( const std::vector<uint16_t>& source ) {
+	pod::RLE::string_t destination;
+	destination.reserve( source.size() / 2 );
+
+	pod::RLE reg = { 0, 0 };
+
+	for ( auto& s : source ) {
+		if ( reg.length == 0 ) {
+			reg.length = s;
+		} else {
+			reg.value = s;
+			destination.push_back(reg);
+			reg.length = 0;
+		}
+	}
+	return destination;
+}
+
+std::vector<uint16_t> uf::rle::unwrap( const pod::RLE::string_t& source ) {
+	std::vector<uint16_t> destination;
+	destination.reserve( source.size() * 2 );
+	for ( auto& s : source ) {
+		destination.push_back( s.length );
+		destination.push_back( s.value );
+	}
+	return destination;
+}
+*/
\ No newline at end of file
diff --git a/engine/src/utils/string/string.cpp b/engine/src/utils/string/string.cpp
new file mode 100644
index 00000000..c7f8fad4
--- /dev/null
+++ b/engine/src/utils/string/string.cpp
@@ -0,0 +1,225 @@
+#include <uf/utils/string/string.h>
+#include <uf/utils/string/encoding.h>
+//uf::String uf::locale::current;
+std::string uf::locale::current;
+UF_API_CALL uf::String::String() {
+}
+// 	ANSI literals/strings
+UF_API_CALL uf::String::String( char ch ) {
+//	this->m_string += ch;
+	this->parse( ch );
+}
+UF_API_CALL uf::String::String( const char* c_str ) {
+//	this->m_string = (const uint8_t*) c_str;
+	this->parse( c_str );
+}
+UF_API_CALL uf::String::String( const std::basic_string<char>& str ) {
+//	this->m_string = (const uint8_t*) str.c_str();
+	this->parse( str );
+}
+// 	Wide literals/strings
+UF_API_CALL uf::String::String( wchar_t ch ) {
+	this->parse(ch);
+}
+UF_API_CALL uf::String::String( const wchar_t* c_str ) {
+	this->parse(c_str);
+}
+UF_API_CALL uf::String::String( const std::basic_string<wchar_t>& str ) {
+	this->parse(str);
+}
+// 	UTF-8 literals/strings
+UF_API_CALL uf::String::String( uint8_t ch ) {
+	this->parse(ch);
+}
+UF_API_CALL uf::String::String( const uint8_t* c_str ) {
+	this->parse(c_str);
+}
+UF_API_CALL uf::String::String( const std::basic_string<uint8_t>& str ) {
+	this->parse(str);
+}
+// 	UTF-16 literals/strings
+UF_API_CALL uf::String::String( uint16_t ch ) {
+	this->parse(ch);
+}
+UF_API_CALL uf::String::String( const uint16_t* c_str ) {
+	this->parse(c_str);
+}
+UF_API_CALL uf::String::String( const std::basic_string<uint16_t>& str ) {
+	this->parse(str);
+}
+// 	UTF-32 literals/strings
+UF_API_CALL uf::String::String( uint32_t ch ) {
+	this->parse(ch);
+}
+UF_API_CALL uf::String::String( const uint32_t* c_str ) {
+	this->parse(c_str);
+}
+UF_API_CALL uf::String::String( const std::basic_string<uint32_t>& str ) {
+	this->parse(str);
+}
+
+// 	Parses ANSI/ASCII
+void UF_API_CALL uf::String::parse( char ch ) {
+	this->m_string += ch;
+/*
+	uint32_t codepoint = uf::locale::Ansi::decode( ch, ch );
+	uint8_t chars[4] = { 0, 0, 0, 0 };
+	String::encoding_t::encode( codepoint, &chars[0] );
+	this->m_string += uf::String::string_t(chars);
+*/
+}
+void UF_API_CALL uf::String::parse( const char* c_str ) {
+//	this->m_string = c_str;
+	this->parse(std::basic_string<char>(c_str));
+}
+void UF_API_CALL uf::String::parse( const std::basic_string<char>& str ) {
+//	this->m_string = str;
+	for ( auto ch : str ) this->parse(ch);
+}
+
+// 	Wide literals/strings
+void UF_API_CALL uf::String::parse( wchar_t ch ) {
+	switch ( sizeof(wchar_t) * 8 ) {
+		case 16: this->parse((uint16_t) ch); break;
+		case 32: this->parse((uint32_t) ch); break;
+	}
+}
+void UF_API_CALL uf::String::parse( const wchar_t* c_str ) {
+	this->parse(std::basic_string<wchar_t>(c_str));
+}
+void UF_API_CALL uf::String::parse( const std::basic_string<wchar_t>& str ) {
+	switch ( sizeof(wchar_t) * 8 ) {
+		case 16:
+			for ( auto ch : str ) this->parse((uint16_t)ch);
+		break;
+		case 32:
+			for ( auto ch : str ) this->parse((uint32_t)ch);
+		break;
+	}
+}
+
+// 	UTF-8 literals/strings
+void UF_API_CALL uf::String::parse( uint8_t ch ) {
+//	this->m_string += ch;
+	uint32_t codepoint = uf::locale::Utf8::decode( &ch, &ch + 1 );
+	uint8_t chars[4] = { 0, 0, 0, 0 };
+	String::encoding_t::encode( codepoint, &chars[0] );
+	this->m_string += uf::String::string_t(chars);
+}
+void UF_API_CALL uf::String::parse( const uint8_t* c_str ) {
+//	this->m_string = c_str;
+	this->parse(std::basic_string<uint8_t>(c_str));
+}
+void UF_API_CALL uf::String::parse( const std::basic_string<uint8_t>& str ) {
+//	this->m_string = str;
+	for ( auto ch : str ) this->parse(ch);
+}
+// 	UTF-16 literals/strings
+void UF_API_CALL uf::String::parse( uint16_t ch ) {
+	uint32_t codepoint = uf::locale::Utf16::decode( &ch, &ch + 1 );
+	uint8_t chars[4] = { 0, 0, 0, 0 };
+	String::encoding_t::encode( codepoint, &chars[0] );
+	this->m_string += uf::String::string_t(chars);
+}
+void UF_API_CALL uf::String::parse( const uint16_t* c_str ) {
+	this->parse(std::basic_string<uint16_t>(c_str));
+}
+void UF_API_CALL uf::String::parse( const std::basic_string<uint16_t>& str ) {
+	for ( auto ch : str ) this->parse(ch);
+}
+// 	UTF-32 literals/strings
+void UF_API_CALL uf::String::parse( uint32_t ch ) {
+	uint32_t codepoint = ch;
+	uint8_t chars[4] = { 0, 0, 0, 0 };
+	String::encoding_t::encode( codepoint, &chars[0] );
+	this->m_string += uf::String::string_t(chars);
+}
+void UF_API_CALL uf::String::parse( const uint32_t* c_str ) {
+	this->parse(std::basic_string<uint32_t>(c_str));
+}
+void UF_API_CALL uf::String::parse( const std::basic_string<uint32_t>& str ) {
+	for ( auto ch : str ) this->parse(ch);
+}
+
+//
+uf::String::string_t& UF_API_CALL uf::String::getString() {
+	return this->m_string;
+}
+const uf::String::string_t& UF_API_CALL uf::String::getString() const {
+	return this->m_string;
+}
+// 
+uf::String::literal_t* UF_API_CALL uf::String::c_str() {
+	return (uf::String::literal_t*) this->m_string.c_str();
+}
+const uf::String::literal_t* UF_API_CALL uf::String::c_str() const {
+	return (const uf::String::literal_t*) this->m_string.c_str();
+}
+//
+void UF_API_CALL uf::String::operator +=( char ch ) {
+	this->parse(ch);
+}
+void UF_API_CALL uf::String::operator +=( wchar_t ch ) {
+	this->parse(ch);
+}
+void UF_API_CALL uf::String::operator +=( uint8_t ch ) {
+	this->parse(ch);
+}
+void UF_API_CALL uf::String::operator +=( uint16_t ch ) {
+	this->parse(ch);
+}
+void UF_API_CALL uf::String::operator +=( uint32_t ch ) {
+	this->parse(ch);
+}
+// Truncate
+uf::String& UF_API_CALL uf::String::operator --() {
+	this->m_string.pop_back();
+	return *this;
+}
+uf::String UF_API_CALL uf::String::operator --(int) {
+	auto before = this->m_string;
+	this->m_string.pop_back();
+	return before;
+}
+uf::String& UF_API_CALL uf::String::operator -=( std::size_t i ) {
+	for ( std::size_t ii = 0; ii < i; ++ii ) this->m_string.pop_back();
+	return *this;
+}
+// 
+UF_API_CALL uf::String::operator std::string() {
+	return std::string((char*) this->c_str());
+}
+UF_API_CALL uf::String::operator std::string() const {
+	return std::string((const char*) this->c_str());
+}
+// 
+UF_API_CALL uf::String::operator std::wstring() {
+	switch ( sizeof(wchar_t) * 8 ) {
+		case 16: {
+			std::basic_string<uint16_t> w_str = this->translate<uf::locale::Utf16>();
+			return std::wstring((wchar_t*) w_str.c_str());
+		}
+		case 32: {
+			std::basic_string<uint32_t> w_str = this->translate<uf::locale::Utf32	>();
+			return std::wstring((wchar_t*) w_str.c_str());
+		}
+	}
+	std::wstring w_str;
+	for ( auto c : this->m_string ) w_str += c;
+	return w_str;
+}
+UF_API_CALL uf::String::operator std::wstring() const {
+	switch ( sizeof(wchar_t) * 8 ) {
+		case 16: {
+			std::basic_string<uint16_t> w_str = this->translate<uf::locale::Utf16>();
+			return std::wstring((wchar_t*) w_str.c_str());
+		}
+		case 32: {	
+			std::basic_string<uint32_t> w_str = this->translate<uf::locale::Utf32>();
+			return std::wstring((wchar_t*) w_str.c_str());
+		}
+	}
+	std::wstring w_str;
+	for ( auto c : this->m_string ) w_str += c;
+	return w_str;
+}
\ No newline at end of file
diff --git a/engine/src/utils/string/utf.cpp b/engine/src/utils/string/utf.cpp
new file mode 100644
index 00000000..e69de29b
diff --git a/engine/src/utils/text/glyph.cpp b/engine/src/utils/text/glyph.cpp
new file mode 100644
index 00000000..9915e0f2
--- /dev/null
+++ b/engine/src/utils/text/glyph.cpp
@@ -0,0 +1,241 @@
+#include <uf/utils/text/glyph.h>
+#include <iostream>
+#if UF_USE_FREETYPE
+uf::Glyph::~Glyph() {
+	delete[] this->m_buffer;
+}
+
+// 	OpenGL ops
+uint8_t* uf::Glyph::generate( const std::string& font, unsigned long c, uint size ) {
+	ext::freetype::Glyph glyph = ext::freetype::initialize(font);
+	return this->generate( glyph, c );
+}
+uint8_t* uf::Glyph::generate( ext::freetype::Glyph& glyph, unsigned long c, uint size ) {
+	ext::freetype::setPixelSizes( glyph, size );
+	if ( !ext::freetype::load( glyph, c ) ) return NULL;
+	if ( this->m_buffer ) {
+		delete[] this->m_buffer;
+	}
+
+//	this->m_sdf = false;
+//	this->setSize( { static_cast<int>(glyph.face->glyph->metrics.width) >> 6, static_cast<int>(glyph.face->glyph->metrics.height) >> 6 } );
+	this->setSize( { static_cast<int>(glyph.face->glyph->bitmap.width), static_cast<int>(glyph.face->glyph->bitmap.rows) } );
+	this->setBearing( { glyph.face->glyph->bitmap_left, glyph.face->glyph->bitmap_top } );
+	this->setAdvance( {static_cast<int>(glyph.face->glyph->advance.x) >> 6, static_cast<int>(glyph.face->glyph->advance.y) >> 6} );
+//	this->setPadding( {4, 4} );
+
+	uint8_t* bitmap = glyph.face->glyph->bitmap.buffer;
+	
+	pod::Vector2i padding = this->getPadding();
+	if ( padding.x > 0 && padding.y > 0 ) {
+		uint8_t unheadache[this->m_size.x + padding.x * 2][this->m_size.y + padding.y * 2];
+		this->m_buffer = new uint8_t[ ( this->m_size.x + padding.x * 2 ) * ( this->m_size.y + padding.y * 2 ) ];
+
+		// Zero out
+		for ( uint y = 0; y < this->m_size.y + padding.y * 2; ++y ) {
+			for ( uint x = 0; x < this->m_size.x + padding.x * 2; ++x ) {
+				unheadache[x][y] = 0;
+			}
+		}
+		// Fill
+		for ( uint y = 0; y < this->m_size.y; ++y ) {
+			for ( uint x = 0; x < this->m_size.x; ++x ) {
+				unheadache[x + padding.x][y + padding.y] = bitmap[y * this->m_size.x + x];
+			}
+		}
+		// Migrate
+		this->setSize( pod::Vector2ui{ this->m_size.x + padding.x * 2, this->m_size.y + padding.y * 2 } );
+		for ( uint y = 0; y < this->m_size.y; ++y ) {
+			for ( uint x = 0; x < this->m_size.x; ++x ) {
+				this->m_buffer[y * this->m_size.x + x] = unheadache[x][y];
+			}
+		}
+	} else {
+		std::size_t len = this->m_size.x * this->m_size.y;
+		this->m_buffer = new uint8_t[len];
+		memcpy(this->m_buffer, bitmap, len);
+	}
+
+	if ( this->isSdf() ) this->generateSdf(this->m_buffer);
+	return this->m_buffer;
+}
+uint8_t* uf::Glyph::generate( const std::string& font, const uf::String& c, uint size ) {
+	ext::freetype::Glyph glyph = ext::freetype::initialize(font);
+	return this->generate( glyph, c );
+}
+uint8_t* uf::Glyph::generate( ext::freetype::Glyph& glyph, const uf::String& c, uint size ) {
+	ext::freetype::setPixelSizes( glyph, size );
+	if ( !ext::freetype::load( glyph, c ) ) return NULL;
+	if ( this->m_buffer ) {
+		delete[] this->m_buffer;
+	}
+
+	this->setSize( { static_cast<int>(glyph.face->glyph->bitmap.width), static_cast<int>(glyph.face->glyph->bitmap.rows) } );
+	this->setBearing( { glyph.face->glyph->bitmap_left, glyph.face->glyph->bitmap_top } );
+	this->setAdvance( {static_cast<int>(glyph.face->glyph->advance.x) >> 6, static_cast<int>(glyph.face->glyph->advance.y) >> 6} );
+
+	uint8_t* bitmap = glyph.face->glyph->bitmap.buffer;
+	std::size_t len = this->m_size.x * this->m_size.y;
+	this->m_buffer = new uint8_t[len];
+	memcpy(this->m_buffer, bitmap, len);
+
+	if ( this->isSdf() ) this->generateSdf(this->m_buffer);
+
+	return this->m_buffer;
+}
+bool uf::Glyph::generated() {
+	return this->m_buffer != NULL;
+}
+void uf::Glyph::generateSdf( uint8_t* buffer ) { if ( !buffer ) return;
+	pod::Vector2ui size = this->getSize();
+	this->m_sdf = true;
+
+	int HEIGHT = size.y; int WIDTH = size.x;
+	struct Point {
+		int dx, dy;
+		int DistSq() const { return dx*dx + dy*dy; }
+	};
+	struct Grid {
+		int w, h;
+		Point grid[128][128];
+	/*
+		Point** grid;
+		Grid( int w, int h ) { this->w = w; this->h = h; this->grid = new Point*[h]; for (int y = 0; y < h; ++y ) this->grid[y] = new Point[w]; }
+		~Grid() { std::cout << this->grid << std::endl; for ( int y = 0; y < this->w; ++y ) if ( this->grid[y] ) delete[] this->grid[y]; if ( this->grid ) delete[] this->grid; }
+	*/
+	};
+
+	Point inside = { 0, 0 };
+	Point empty = { 9999, 9999 };
+	Grid grid1; //( WIDTH, HEIGHT );
+	Grid grid2; //( WIDTH, HEIGHT );
+
+	auto Get = [&]( Grid &g, int x, int y )->Point{
+		return ( x >= 0 && y >= 0 && x < WIDTH && y < HEIGHT ) ? g.grid[y][x] : empty;
+	};
+	auto Put = [&]( Grid &g, int x, int y, const Point &p )->void{
+		g.grid[y][x] = p;
+	};
+	auto Compare = [&]( Grid &g, Point &p, int x, int y, int offsetx, int offsety )->void{
+		Point other = Get( g, x+offsetx, y+offsety );
+		other.dx += offsetx;
+		other.dy += offsety;
+		if (other.DistSq() < p.DistSq()) p = other;
+	};
+	auto GenerateSDF = [&]( Grid &g )->void{
+		// Pass 0
+		for (int y=0;y<HEIGHT;y++) {
+			for (int x=0;x<WIDTH;x++) {
+				Point p = Get( g, x, y );
+				Compare( g, p, x, y, -1,  0 );
+				Compare( g, p, x, y,  0, -1 );
+				Compare( g, p, x, y, -1, -1 );
+				Compare( g, p, x, y,  1, -1 );
+				Put( g, x, y, p );
+			}
+			for (int x=WIDTH-1;x>=0;x--) {
+				Point p = Get( g, x, y );
+				Compare( g, p, x, y, 1, 0 );
+				Put( g, x, y, p );
+			}
+		}
+		// Pass 1
+		for (int y=HEIGHT-1;y>=0;y--) {
+			for (int x=WIDTH-1;x>=0;x--) {
+				Point p = Get( g, x, y );
+				Compare( g, p, x, y,  1,  0 );
+				Compare( g, p, x, y,  0,  1 );
+				Compare( g, p, x, y, -1,  1 );
+				Compare( g, p, x, y,  1,  1 );
+				Put( g, x, y, p );
+			}
+			for (int x=0;x<WIDTH;x++) {
+				Point p = Get( g, x, y );
+				Compare( g, p, x, y, -1, 0 );
+				Put( g, x, y, p );
+			}
+		}
+	};
+
+
+	for ( int y = 0; y < this->m_size.y; ++y ) {
+		for ( int x = 0; x < this->m_size.x; ++x ) {
+			int a = buffer[y * this->m_size.x + x];
+			Put( grid1, x, y, a < 128 ? inside : empty );
+			Put( grid2, x, y, a < 128 ? empty : inside );
+		}
+	}
+
+	GenerateSDF( grid1 );
+	GenerateSDF( grid2 );
+
+	int lowest = 255;
+	int highest = 0;
+	for ( uint y = 0; y < this->m_size.y; ++y ) {
+		for ( uint x = 0; x < this->m_size.x; ++x ) {
+			int dist1 = (int)( sqrt( (double)Get( grid1, x, y ).DistSq() ) );
+			int dist2 = (int)( sqrt( (double)Get( grid2, x, y ).DistSq() ) );
+			int dist = dist1 - dist2;
+
+			lowest = std::min( lowest, dist );
+			highest = std::max( highest, dist );
+		
+			{
+				int value = dist * this->getSpread() + 128;
+				uint8_t uvalue = std::max( 0, std::min(255, value) );
+				buffer[y * this->m_size.x + x] = uvalue;
+			}
+		
+		/*
+			{
+				float value = 0.5f + 0.5f * ((float) dist / (float) this->getSpread());
+				value = std::max( 0.0f, std::min(1.0f, value) );
+				uint8_t uvalue = value * 256;
+				buffer[y * this->m_size.x + x] = uvalue;
+			}
+		*/
+		}
+	}
+}
+// 	Get
+const pod::Vector2ui& uf::Glyph::getSize() const {
+	return this->m_size;
+}
+const pod::Vector2i& uf::Glyph::getBearing() const {
+	return this->m_bearing;
+}
+const pod::Vector2i& uf::Glyph::getAdvance() const {
+	return this->m_advance;
+}
+const pod::Vector2i& uf::Glyph::getPadding() const {
+	return this->m_padding;
+}
+const uint8_t* uf::Glyph::getBuffer() const {
+	return this->m_buffer;
+}
+int uf::Glyph::getSpread() const {
+	return this->m_spread;
+}
+bool uf::Glyph::isSdf() const {
+	return this->m_sdf;
+}
+//	Set
+void uf::Glyph::setSize( const pod::Vector2ui& size ) {
+	this->m_size = size;
+}
+void uf::Glyph::setBearing( const pod::Vector2i& bearing ) {
+	this->m_bearing = bearing;
+}
+void uf::Glyph::setAdvance( const pod::Vector2i& advance ) {
+	this->m_advance = advance;
+}
+void uf::Glyph::setPadding( const pod::Vector2i& padding ) {
+	this->m_padding = padding;
+}
+void uf::Glyph::setSpread( int spread ) {
+	this->m_spread = spread;
+} 
+void uf::Glyph::useSdf( bool b ) {
+	this->m_sdf = b;
+}
+#endif
\ No newline at end of file
diff --git a/engine/src/utils/thread/thread.cpp b/engine/src/utils/thread/thread.cpp
new file mode 100644
index 00000000..8c4d1fc3
--- /dev/null
+++ b/engine/src/utils/thread/thread.cpp
@@ -0,0 +1,248 @@
+#include <uf/utils/thread/thread.h>
+#include <uf/utils/io/iostream.h>
+#include <iostream>
+
+uf::thread::container_t uf::thread::threads;
+double uf::thread::limiter = 1.0f / 120.0f;
+uint uf::thread::workers = 1;
+std::thread::id uf::thread::mainThreadId = std::this_thread::get_id();
+
+#define UF_THREAD_ANNOUNCE(x)\
+	//uf::iostream << x << "\n";
+
+void UF_API uf::thread::start( pod::Thread& thread ) { if ( thread.running ) return;
+	thread.thread = std::thread( uf::thread::tick, std::ref(thread) );
+	thread.running = true;
+}
+void UF_API uf::thread::quit( pod::Thread& thread ) { // if ( !thread.running ) return;
+	thread.running = false;
+
+	if ( thread.mutex != NULL ) thread.mutex->lock();
+	if ( thread.thread.joinable() ) thread.thread.join();
+	if ( thread.mutex != NULL ) thread.mutex->unlock();
+
+}
+void UF_API uf::thread::tick( pod::Thread& thread ) {
+/*
+	bool res = SetThreadAffinityMask(GetCurrentThread(), (1u << thread.affinity));
+	if ( !res ) UF_THREAD_ANNOUNCE("Failed to set affinity of Thread #" << thread.uid << " (" << thread.name << " on ID " << pthread_self() << "/" << thread.affinity << ")");
+	if ( !thread.timer.running() ) thread.timer.start();
+*/
+#if !UF_ENV_DREAMCAST
+	bool res = SetThreadAffinityMask(GetCurrentThread(), (1u << thread.affinity));
+	if ( !res ) UF_THREAD_ANNOUNCE("Failed to set affinity of Thread #" << thread.uid << " (" << thread.name << " on ID " << pthread_self() << "/" << thread.affinity << ")");
+#endif
+	UF_THREAD_ANNOUNCE("Starting Thread #" << thread.uid << " (" << thread.name << " on ID " << thread.affinity << ") (Limiter: " << (1.0f / thread.limiter) << " FPS)");
+	thread.timer.start();
+	
+	while ( thread.running ) {
+		uf::thread::process( thread );
+		if ( thread.terminates && thread.temps.empty() && thread.consts.empty() ) uf::thread::quit( thread );
+
+		if ( thread.limiter > 0 ) {
+			long long sleep = (thread.limiter * 1000) - thread.timer.elapsed().asMilliseconds();
+			if ( sleep > 0 ) {
+				std::this_thread::sleep_for(std::chrono::milliseconds(sleep));
+			}
+			thread.timer.reset();
+		}
+	}
+}
+
+pod::Thread& UF_API uf::thread::fetchWorker( const std::string& name ) {
+	static int current = 0;
+	static int limit = uf::thread::workers;
+	static uint threads = std::thread::hardware_concurrency();
+	if ( ++current >= limit ) current = 0;
+	std::string thread = name;
+	if ( current > 0 ) thread += " " + std::to_string(current);
+	bool exists = uf::thread::has(thread);
+	auto& pod = exists ? uf::thread::get(thread) : uf::thread::create( thread, true );
+	if ( !exists ) {
+/*
+		pod.affinity = (current + 1) % threads;
+		std::cout << "Create: " << thread << ": " << pod.affinity << std::endl;
+		BOOL res = SetThreadAffinityMask((HANDLE) pod.thread.native_handle(), 1u << pod.affinity );
+		if ( res ) if ( UF_THREAD_ANNOUNCE ) uf::iostream << "Bound worker thread #" << current << " to ID " << pod.affinity << "\n";
+		else if ( UF_THREAD_ANNOUNCE ) uf::iostream << "Failed to bind worker thread #" << current << " to ID " << pod.affinity << "\n";
+*/
+	}
+	return pod;
+}
+void UF_API uf::thread::batchWorkers( const std::vector<pod::Thread::function_t>& functions, bool wait, const std::string& name ) {
+	std::vector<pod::Thread*> workers;
+	for ( auto& function : functions ) {
+		auto& worker = uf::thread::fetchWorker( name );
+		workers.emplace_back(&worker);
+		uf::thread::add( worker, function, true );
+	}
+	if ( wait )
+		for ( auto& worker : workers )
+			uf::thread::wait( *worker );
+}
+/*
+void UF_API uf::thread::tick( pod::Thread& thread, const std::function<void()>& callback ) {
+	while ( thread.running ) {
+		uf::thread::process( thread );
+		if ( callback ) callback();
+		if ( thread.terminates && thread.temps.empty() && thread.consts.empty() ) uf::thread::quit( thread );
+	}
+}
+*/
+void UF_API uf::thread::add( pod::Thread& thread, const pod::Thread::function_t& function, bool temporary ) {
+	if ( thread.mutex != NULL ) thread.mutex->lock();
+	temporary ? thread.temps.push( function ) : thread.consts.push_back( function );
+	if ( thread.mutex != NULL ) thread.mutex->unlock();
+}
+void UF_API uf::thread::assertExecute( pod::Thread& thread, const pod::Thread::function_t& f ) {
+	std::cout << "ASSERT EXECUTION: " << thread.name << "\t" << uf::thread::isMain() << "\t" << std::this_thread::get_id() << "\t" << thread.thread.get_id() << std::endl;
+	if ( thread.name == "Main" && uf::thread::isMain() ) f();
+	else if ( std::this_thread::get_id() == thread.thread.get_id() ) f();
+	else uf::thread::add( thread, f, true );
+}
+void UF_API uf::thread::process( pod::Thread& thread ) { if ( !uf::thread::has(uf::thread::uid(thread)) ) { UF_THREAD_ANNOUNCE("Bad Thread: " << thread.uid << " " << thread.name); return; } //ops
+/*
+	std::function<int()> temps = [&] {
+		int i = 0;
+		while ( !thread.temps.empty() ) {
+			auto& function = thread.temps.front();
+			if ( function ) function();
+			thread.temps.pop();
+			++i;
+		}
+		return i;
+	};
+	std::function<int()> consts = [&] {
+		int i = 0;
+		for ( auto function : thread.consts ) {
+			function();
+			++i;
+		}
+		return i;
+	};
+	if ( thread.mutex != NULL ) thread.mutex->lock();
+	temps();
+	consts();
+	if ( thread.mutex != NULL ) thread.mutex->unlock();
+*/
+	size_t temps = 0;
+	size_t consts = 0;
+	while ( !thread.temps.empty() ) {
+		auto& function = thread.temps.front();
+	#if UF_NO_EXCEPTIONS
+		if ( function ) function();
+	#else
+		if ( function ) try {
+			function();
+		} catch ( std::exception& e ) {
+			uf::iostream << "Thread " << thread.name << " (UID: " << thread.uid << ") caught exception: " << e.what() << "\n";
+		}
+	#endif
+		thread.temps.pop();
+		++temps;
+	}
+	for ( auto function : thread.consts ) {
+	#if UF_NO_EXCEPTIONS
+		if ( function ) function();
+	#else
+		if ( function ) try {
+			function();
+		} catch ( std::exception& e ) {
+			uf::iostream << "Thread " << thread.name << " (UID: " << thread.uid << ") caught exception: " << e.what() << "\n";
+		}
+	#endif
+		++consts;
+	}
+	thread.condition.notify_one();
+}
+void UF_API uf::thread::wait( pod::Thread& thread ) {
+	if ( thread.mutex != NULL ) {
+		std::unique_lock<std::mutex> lock(*thread.mutex);
+    	thread.condition.wait(lock, [&]{return thread.temps.empty();});
+    	return;
+    }
+	while ( !thread.temps.empty() );
+/*
+	if ( thread.mutex != NULL ) {
+		thread.mutex->lock();
+		thread.mutex->unlock();
+		return;
+	}
+	while ( !thread.temps.empty() );
+*/
+}
+
+const std::string& UF_API uf::thread::name( const pod::Thread& thread ) {
+	return thread.name;
+}
+uint UF_API uf::thread::uid( const pod::Thread& thread ) {
+	return thread.uid;
+}
+bool UF_API uf::thread::running( const pod::Thread& thread ) {
+	return thread.running;
+}
+
+void UF_API uf::thread::terminate() {
+	while ( !uf::thread::threads.empty() ) {
+		pod::Thread& thread = **uf::thread::threads.begin();
+		uf::thread::destroy( thread );
+	}
+}
+pod::Thread& UF_API uf::thread::create( const std::string& name, bool start, bool locks ) {
+	pod::Thread* pointer = NULL;
+	uf::thread::threads.emplace_back(pointer = new pod::Thread);
+	pod::Thread& thread = *pointer;
+
+	static uint uids = 0;
+	static int limit = uf::thread::workers;
+	static uint threads = std::thread::hardware_concurrency();
+	thread.name = name;
+	thread.uid = uids++;
+	thread.terminates = false;
+	thread.running = false;
+	thread.mutex = NULL;
+	thread.mutex = locks ? new std::mutex() : NULL;
+	thread.limiter = uf::thread::limiter;
+	thread.affinity = (thread.uid % limit) + 1;
+
+	UF_THREAD_ANNOUNCE("Creating Thread #" << thread.uid << " (" << name << ") " << &thread << " (Affinity: " << thread.affinity << ") (Limiter: " << (1.0f / thread.limiter) << " FPS)");
+
+	if ( start ) uf::thread::start( thread );
+
+	return thread;
+}
+void UF_API uf::thread::destroy( pod::Thread& thread ) {
+	if ( !uf::thread::has( uf::thread::uid(thread) ) ) return; // oops
+
+	UF_THREAD_ANNOUNCE("Quitting Thread #" << thread.uid << " (" << thread.name << ")");
+	uf::thread::quit( thread );
+	UF_THREAD_ANNOUNCE("Quitted Thread #" << thread.uid << " (" << thread.name << ")");
+
+	if ( thread.mutex != NULL ) delete thread.mutex;
+
+	for ( auto it = uf::thread::threads.begin(); it != uf::thread::threads.end(); ++it )
+		if ( uf::thread::uid( **it ) == uf::thread::uid(thread) ) {
+			delete *it;
+			uf::thread::threads.erase( it );
+			break;
+		}
+}
+bool UF_API uf::thread::has( uint uid ) {
+	for ( const pod::Thread* thread : uf::thread::threads ) if ( uf::thread::uid(*thread) == uid ) return true;
+	return false;
+}
+bool UF_API uf::thread::has( const std::string& name ) {
+	for ( const pod::Thread* thread : uf::thread::threads ) if ( uf::thread::name(*thread) == name ) return true;
+	return false;
+}
+pod::Thread& UF_API uf::thread::get( uint uid ) {
+	for ( pod::Thread* thread : uf::thread::threads ) if ( uf::thread::uid(*thread) == uid ) return *thread;
+	UF_EXCEPTION("invalid call to uf::thread::get");
+}
+pod::Thread& UF_API uf::thread::get( const std::string& name ) {
+	for ( pod::Thread* thread : uf::thread::threads ) if ( uf::thread::name(*thread) == name ) return *thread;
+	UF_EXCEPTION("invalid call to uf::thread::get");
+}
+bool UF_API uf::thread::isMain() {
+	return uf::thread::mainThreadId == std::this_thread::get_id();
+}
\ No newline at end of file
diff --git a/engine/src/utils/time/time.cpp b/engine/src/utils/time/time.cpp
new file mode 100644
index 00000000..a868456c
--- /dev/null
+++ b/engine/src/utils/time/time.cpp
@@ -0,0 +1,6 @@
+#include <uf/utils/time/time.h> // time(r)
+
+namespace {
+	uf::Time<> zero = spec::time.getTime(); 	// Program epoch, used for getting time deltas (without uf::Timer)
+}
+extern UF_API uf::Timer<> timer; 				// System timer, used for getting time deltas
\ No newline at end of file
diff --git a/engine/src/utils/type/type.cpp b/engine/src/utils/type/type.cpp
new file mode 100644
index 00000000..daced6a0
--- /dev/null
+++ b/engine/src/utils/type/type.cpp
@@ -0,0 +1,50 @@
+#include <uf/utils/type/type.h>
+#include <uf/utils/io/iostream.h>
+
+#include <cxxabi.h>
+#include <memory>
+namespace {
+	std::string demangle( const std::string& mangled ) {
+
+		int status = -4;
+		std::unique_ptr<char, void(*)(void*)> demangled{
+	        abi::__cxa_demangle(mangled.c_str(), NULL, NULL, &status),
+	        std::free
+	    };
+	    return ( status == 0 ) ? demangled.get() : mangled;
+	/*
+		int status;
+		char* pointer = abi::__cxa_demangle(mangled.c_str(), 0, 0, &status);
+		std::string demangled;
+		demangled.copy( pointer, strlen(pointer) );
+		free(pointer);
+		return demangled;
+	*/
+	}
+}
+
+std::unordered_map<uf::typeInfo::index_t, pod::TypeInfo>* uf::typeInfo::types = NULL;
+void uf::typeInfo::registerType( const index_t& index, size_t size, const std::string& pretty ) {
+	if ( !uf::typeInfo::types ) uf::typeInfo::types = new std::unordered_map<uf::typeInfo::index_t, pod::TypeInfo>;
+	bool exists = uf::typeInfo::types->count(index) > 0;
+	auto& type = (*uf::typeInfo::types)[index];
+	if ( !exists || type.size < size ) type.size = size;
+	if ( !exists ) type.hash = index.hash_code();
+	if ( !exists ) type.name.compiler = index.name();
+	if ( !exists || pretty != "" ) type.name.pretty = pretty != "" ? pretty : demangle( type.name.compiler );
+
+	// if ( !exists ) uf::iostream << "Registered type " << type.name.pretty << " (Mangled: " << type.name.compiler << ") of size " << size << "\n";
+}
+const pod::TypeInfo& UF_API uf::typeInfo::getType( size_t hash ) {
+	if ( !uf::typeInfo::types ) uf::typeInfo::types = new std::unordered_map<uf::typeInfo::index_t, pod::TypeInfo>;
+	auto& types = *uf::typeInfo::types;
+	for ( auto& pair : types ) {
+		if ( pair.second.hash == hash ) return pair.second;
+	}
+	static pod::TypeInfo null;
+	return null;
+}
+const pod::TypeInfo& uf::typeInfo::getType( const index_t& index ) {
+	if ( !uf::typeInfo::types ) uf::typeInfo::types = new std::unordered_map<uf::typeInfo::index_t, pod::TypeInfo>;
+	return (*uf::typeInfo::types)[index];
+}
\ No newline at end of file
diff --git a/engine/src/utils/userdata/pointered.cpp b/engine/src/utils/userdata/pointered.cpp
new file mode 100644
index 00000000..c1e7d573
--- /dev/null
+++ b/engine/src/utils/userdata/pointered.cpp
@@ -0,0 +1,192 @@
+#include <uf/utils/userdata/userdata.h> 	// userdata
+#include <uf/utils/string/base64.h> 		// base64
+#include <cstdlib> 							// malloc, free
+#include <cstring> 							// memcpy
+#include <iostream> 						
+
+// Constructs a pod::PointeredUserdata struct
+pod::PointeredUserdata UF_API uf::pointeredUserdata::create( std::size_t len, void* data ) {
+	return uf::pointeredUserdata::create( uf::userdata::memoryPool, len, data );
+}
+void UF_API uf::pointeredUserdata::destroy( pod::PointeredUserdata& userdata ) {
+	return uf::pointeredUserdata::destroy( uf::userdata::memoryPool, userdata );
+}
+pod::PointeredUserdata UF_API uf::pointeredUserdata::copy( const pod::PointeredUserdata& userdata ) {
+	return uf::pointeredUserdata::copy( uf::userdata::memoryPool, userdata );
+}
+
+size_t uf::pointeredUserdata::size( size_t len, size_t padding ) {
+	// padding = 0;
+	// return sizeof(size_t) + len + ( sizeof(uint8_t) * padding );
+	return len;
+}
+
+//
+pod::PointeredUserdata UF_API uf::pointeredUserdata::create( uf::MemoryPool& requestedMemoryPool, std::size_t len, void* data ) {
+	if ( len <= 0 ) return {};
+	size_t requestedLen = size( len );
+#if UF_MEMORYPOOL_INVALID_MALLOC
+	uf::MemoryPool& memoryPool = requestedMemoryPool.size() > 0 ? requestedMemoryPool : uf::MemoryPool::global;
+	pod::PointeredUserdata userdata = {
+		.len = requestedLen,
+		.data = memoryPool.alloc( data, requestedLen ),
+	};
+#else
+	uf::MemoryPool* memoryPool = {};
+	if ( requestedMemoryPool.size() > 0 ) memoryPool = &requestedMemoryPool;
+	else if ( uf::MemoryPool::global.size() > 0 ) memoryPool = &uf::MemoryPool::global;
+	pod::PointeredUserdata userdata = {};
+	if ( memoryPool )
+		userdata.data = (uint8_t*) memoryPool->alloc( data, requestedLen );
+	else {
+		userdata.data = (uint8_t*) operator new( requestedLen ); 	// allocate data for the userdata struct, and then some
+		if ( data ) memcpy( userdata.data, data, len );
+		else memset( userdata.data, 0, len );
+	}
+#endif
+	userdata.len = len;
+	userdata.type = typeid(NULL).hash_code();
+	return userdata;
+}
+void UF_API uf::pointeredUserdata::destroy( uf::MemoryPool& requestedMemoryPool, pod::PointeredUserdata& userdata ) {
+#if UF_MEMORYPOOL_INVALID_FREE
+	uf::MemoryPool& memoryPool = requestedMemoryPool.size() > 0 ? requestedMemoryPool : uf::MemoryPool::global;
+	memoryPool.free( userdata, size(userdata.len) );
+#else
+	uf::MemoryPool* memoryPool = NULL;
+	if ( requestedMemoryPool.size() > 0 ) memoryPool = &requestedMemoryPool;
+	else if ( uf::MemoryPool::global.size() > 0 ) memoryPool = &uf::MemoryPool::global;
+	
+	if ( memoryPool ) memoryPool->free( userdata.data, size(userdata.len) );
+	else {
+		// free(userdata);
+		delete[] userdata.data;
+	}
+#endif
+	userdata.len = 0;
+	userdata.data = NULL;
+}
+pod::PointeredUserdata UF_API uf::pointeredUserdata::copy( uf::MemoryPool& requestedMemoryPool, const pod::PointeredUserdata& userdata ) {
+	if ( !userdata.data || userdata.len <= 0 ) return {};
+	auto copied = uf::pointeredUserdata::create( userdata.len, const_cast<uint8_t*>(userdata.data) );
+#if UF_USERDATA_RTTI
+//	copied->type = userdata.type;
+#endif
+	return copied;
+}
+
+std::string UF_API uf::pointeredUserdata::toBase64( pod::PointeredUserdata& userdata ) {
+	return uf::base64::encode( userdata.data, userdata.len );
+}
+pod::PointeredUserdata UF_API uf::pointeredUserdata::fromBase64( const std::string& base64 ) {
+	std::vector<uint8_t> decoded = uf::base64::decode( base64 );
+	return uf::pointeredUserdata::create( decoded.size(), decoded.data() );
+}
+// 	C-tor
+
+// 	Initializes POD
+uf::PointeredUserdata::PointeredUserdata(std::size_t len, void* data) : m_pod({}), autoDestruct(uf::userdata::autoDestruct) {
+	if ( len && data ) this->create(len, data);
+}
+
+// Initializes from POD
+uf::PointeredUserdata::PointeredUserdata( const pod::PointeredUserdata& pointer ) : m_pod(pointer), autoDestruct(uf::userdata::autoDestruct) {
+
+}
+
+// Move c-tor
+uf::PointeredUserdata::PointeredUserdata( PointeredUserdata&& move ) noexcept :
+	m_pod(std::move(move.m_pod)),
+	autoDestruct(move.autoDestruct) {
+}
+// Copy c-tor
+uf::PointeredUserdata::PointeredUserdata( const PointeredUserdata& userdata ) {
+	autoDestruct = userdata.autoDestruct;
+	this->copy( userdata );
+}
+
+// 	Creates the POD
+pod::PointeredUserdata& uf::PointeredUserdata::create( std::size_t len, void* data ) {
+	if ( len <= 0 ) return this->m_pod;
+	this->destroy();
+	return this->m_pod = uf::pointeredUserdata::create( len, data );
+}
+void uf::PointeredUserdata::move( PointeredUserdata& moved ) {
+//	if ( this->m_pod && move.m_pod ) uf::pointeredUserdata::move( *this->m_pod, *move.m_pod );
+	this->destroy();
+	this->m_pod = moved.m_pod;
+	moved.m_pod.len = 0;
+	moved.m_pod.data = NULL;
+}
+void uf::PointeredUserdata::move( PointeredUserdata&& moved ) {
+//	if ( this->m_pod && move.m_pod ) uf::pointeredUserdata::move( *this->m_pod, *move.m_pod );
+	this->destroy();
+	this->m_pod = moved.m_pod;
+	moved.m_pod.len = 0;
+	moved.m_pod.data = NULL;
+}
+void uf::PointeredUserdata::copy( const PointeredUserdata& userdata ) {
+	if ( !userdata.m_pod.data || !userdata.m_pod.len ) return;
+	this->destroy();
+//	this->m_pod = uf::pointeredUserdata::copy( userdata.m_pod );
+	this->create( userdata.m_pod.len, userdata.m_pod.data );
+#if UF_USERDATA_RTTI
+//	this->m_pod.type = userdata.m_pod.type;
+#endif
+/*
+//	if ( this->m_pod && copy.m_pod ) uf::pointeredUserdata::copy( *this->m_pod, *copy.m_pod );
+	if ( !userdata ) return;
+	this->destroy();
+//	this->m_pod = uf::pointeredUserdata::copy( userdata.m_pod );
+*/
+}
+// 	D-tor
+uf::PointeredUserdata::~PointeredUserdata() noexcept {
+	if ( autoDestruct ) this->destroy();
+}
+// 	Destroys the POD
+void uf::PointeredUserdata::destroy() {
+	uf::pointeredUserdata::destroy( this->m_pod );
+}
+// 	POD access
+// 	Returns a reference of POD
+uf::PointeredUserdata::pod_t& uf::PointeredUserdata::data() {
+	return this->m_pod;
+}
+// 	Returns a const-reference of POD
+const uf::PointeredUserdata::pod_t& uf::PointeredUserdata::data() const {
+	return this->m_pod;
+}
+// 	Validity checks
+bool uf::PointeredUserdata::initialized() const {
+	return this->m_pod.len > 0 && this->m_pod.data;
+}
+// Overloaded ops
+uf::PointeredUserdata::operator void*() {
+	// return this->m_pod ? (void*) this->m_pod.data : NULL;
+	return this->m_pod.data;
+}
+uf::PointeredUserdata::operator void*() const {
+	// return this->m_pod ? (void*) this->m_pod.data : NULL;
+	return this->m_pod.data;
+}
+		
+uf::PointeredUserdata::operator bool() const {
+	return this->initialized();
+}
+
+uf::PointeredUserdata& uf::PointeredUserdata::operator=( pod::PointeredUserdata pointer ) {
+	this->m_pod = pointer;
+	return *this;
+}
+uf::PointeredUserdata& uf::PointeredUserdata::operator=( PointeredUserdata&& move ) {
+	if ( this->initialized() && move.initialized() ) {
+		this->m_pod = move.m_pod;
+		move.m_pod = {};
+	}
+	return *this;
+}
+uf::PointeredUserdata& uf::PointeredUserdata::operator=( const PointeredUserdata& copy ) {
+	if ( this->initialized() && copy.initialized() ) this->copy( copy );
+	return *this;
+}
\ No newline at end of file
diff --git a/engine/src/utils/userdata/userdata.cpp b/engine/src/utils/userdata/userdata.cpp
new file mode 100644
index 00000000..c1952ab3
--- /dev/null
+++ b/engine/src/utils/userdata/userdata.cpp
@@ -0,0 +1,188 @@
+#include <uf/utils/userdata/userdata.h> 	// userdata
+#include <uf/utils/string/base64.h> 		// base64
+#include <cstdlib> 							// malloc, free
+#include <cstring> 							// memcpy
+#include <iostream> 						
+
+uf::MemoryPool uf::userdata::memoryPool;
+bool uf::userdata::autoDestruct = true;
+// Constructs a pod::Userdata struct
+pod::Userdata* UF_API uf::userdata::create( std::size_t len, void* data ) {
+	return uf::userdata::create( uf::userdata::memoryPool, len, data );
+}
+void UF_API uf::userdata::destroy( pod::Userdata* userdata ) {
+	return uf::userdata::destroy( uf::userdata::memoryPool, userdata );
+}
+pod::Userdata* UF_API uf::userdata::copy( const pod::Userdata* userdata ) {
+	return uf::userdata::copy( uf::userdata::memoryPool, userdata );
+}
+
+size_t uf::userdata::size( size_t len, size_t padding ) {
+	// padding = 0;
+	// return sizeof(size_t) + len + ( sizeof(uint8_t) * padding );
+	return sizeof(pod::Userdata) - sizeof(uint8_t) + len;
+}
+
+//
+pod::Userdata* UF_API uf::userdata::create( uf::MemoryPool& requestedMemoryPool, std::size_t len, void* data ) {
+	if ( len <= 0 ) return NULL;
+	size_t requestedLen = size( len );
+#if UF_MEMORYPOOL_INVALID_MALLOC
+	uf::MemoryPool& memoryPool = requestedMemoryPool.size() > 0 ? requestedMemoryPool : uf::MemoryPool::global;
+	pod::Userdata* userdata = (pod::Userdata*) memoryPool.alloc( data, requestedLen );
+#else
+	uf::MemoryPool* memoryPool = NULL;
+	if ( requestedMemoryPool.size() > 0 ) memoryPool = &requestedMemoryPool;
+	else if ( uf::MemoryPool::global.size() > 0 ) memoryPool = &uf::MemoryPool::global;
+	pod::Userdata* userdata = NULL;
+	if ( memoryPool )
+		userdata = (pod::Userdata*) memoryPool->alloc( data, requestedLen );
+	else {
+		userdata = (pod::Userdata*) operator new( requestedLen ); 	// allocate data for the userdata struct, and then some
+		if ( data ) memcpy( userdata->data, data, len );
+		else memset( userdata->data, 0, len );
+	}
+#endif
+	userdata->len = len;
+	userdata->type = typeid(NULL).hash_code();
+	return userdata;
+}
+void UF_API uf::userdata::destroy( uf::MemoryPool& requestedMemoryPool, pod::Userdata* userdata ) {
+#if UF_MEMORYPOOL_INVALID_FREE
+	uf::MemoryPool& memoryPool = requestedMemoryPool.size() > 0 ? requestedMemoryPool : uf::MemoryPool::global;
+	memoryPool.free( userdata, size(userdata->len) );
+#else
+	uf::MemoryPool* memoryPool = NULL;
+	if ( requestedMemoryPool.size() > 0 ) memoryPool = &requestedMemoryPool;
+	else if ( uf::MemoryPool::global.size() > 0 ) memoryPool = &uf::MemoryPool::global;
+	
+	if ( memoryPool ) memoryPool->free( userdata, size(userdata->len) );
+	else {
+		// free(userdata);
+		delete[] userdata;
+	}
+#endif
+}
+pod::Userdata* UF_API uf::userdata::copy( uf::MemoryPool& requestedMemoryPool, const pod::Userdata* userdata ) {
+	if ( !userdata || userdata->len <= 0 ) return NULL;
+	auto* copied = uf::userdata::create( userdata->len, const_cast<uint8_t*>(userdata->data) );
+#if UF_USERDATA_RTTI
+//	copied->type = userdata->type;
+#endif
+	return copied;
+}
+
+std::string UF_API uf::userdata::toBase64( pod::Userdata* userdata ) {
+	return uf::base64::encode( userdata->data, userdata->len );
+}
+pod::Userdata* UF_API uf::userdata::fromBase64( const std::string& base64 ) {
+	std::vector<uint8_t> decoded = uf::base64::decode( base64 );
+	return uf::userdata::create( decoded.size(), decoded.data() );
+}
+// 	C-tor
+
+// 	Initializes POD
+uf::Userdata::Userdata(std::size_t len, void* data) : m_pod(NULL), autoDestruct(uf::userdata::autoDestruct) {
+	if ( len && data ) this->create(len, data);
+}
+
+// Initializes from POD
+uf::Userdata::Userdata( pod::Userdata* pointer ) : m_pod(pointer), autoDestruct(uf::userdata::autoDestruct) {
+
+}
+
+// Move c-tor
+uf::Userdata::Userdata( Userdata&& move ) noexcept :
+	m_pod(std::move(move.m_pod)),
+	autoDestruct(move.autoDestruct) {
+}
+// Copy c-tor
+uf::Userdata::Userdata( const Userdata& userdata ) {
+	autoDestruct = userdata.autoDestruct;
+	this->copy( userdata );
+}
+
+// 	Creates the POD
+pod::Userdata* uf::Userdata::create( std::size_t len, void* data ) {
+	if ( len <= 0 ) return NULL;
+	this->destroy();
+	return this->m_pod = uf::userdata::create( len, data );
+}
+void uf::Userdata::move( Userdata& moved ) {
+//	if ( this->m_pod && move.m_pod ) uf::userdata::move( *this->m_pod, *move.m_pod );
+	this->destroy();
+	this->m_pod = moved.m_pod;
+	moved.m_pod = NULL;
+}
+void uf::Userdata::move( Userdata&& moved ) {
+//	if ( this->m_pod && move.m_pod ) uf::userdata::move( *this->m_pod, *move.m_pod );
+	this->destroy();
+	this->m_pod = moved.m_pod;
+	moved.m_pod = NULL;
+}
+void uf::Userdata::copy( const Userdata& userdata ) {
+	if ( !userdata.m_pod || !userdata.m_pod->len ) return;
+	this->destroy();
+//	this->m_pod = uf::userdata::copy( userdata.m_pod );
+	this->create( userdata.m_pod->len, userdata.m_pod->data );
+#if UF_USERDATA_RTTI
+//	this->m_pod->type = userdata.m_pod->type;
+#endif
+/*
+//	if ( this->m_pod && copy.m_pod ) uf::userdata::copy( *this->m_pod, *copy.m_pod );
+	if ( !userdata ) return;
+	this->destroy();
+//	this->m_pod = uf::userdata::copy( userdata.m_pod );
+*/
+}
+// 	D-tor
+uf::Userdata::~Userdata() noexcept {
+	if ( autoDestruct ) this->destroy();
+}
+// 	Destroys the POD
+void uf::Userdata::destroy() {
+	if ( this->m_pod ) uf::userdata::destroy( this->m_pod );
+}
+// 	POD access
+// 	Returns a reference of POD
+uf::Userdata::pod_t& uf::Userdata::data() {
+	static Userdata::pod_t null = { 0 };
+	return this->m_pod ? *this->m_pod : null;
+}
+// 	Returns a const-reference of POD
+const uf::Userdata::pod_t& uf::Userdata::data() const {
+	static Userdata::pod_t null = { 0 };
+	return this->m_pod ? *this->m_pod : null;
+}
+// 	Validity checks
+bool uf::Userdata::initialized() const {
+	return this->m_pod != NULL;
+}
+// Overloaded ops
+uf::Userdata::operator void*() {
+	// return this->m_pod ? (void*) this->m_pod->data : NULL;
+	if ( !this->m_pod ) return NULL;
+	return this->m_pod->data;
+}
+uf::Userdata::operator void*() const {
+	// return this->m_pod ? (void*) this->m_pod->data : NULL;
+	if ( !this->m_pod ) return NULL;
+	return this->m_pod->data;
+}
+		
+uf::Userdata::operator bool() const {
+	return this->initialized();
+}
+
+uf::Userdata& uf::Userdata::operator=( pod::Userdata* pointer ) {
+	this->m_pod = pointer;
+	return *this;
+}
+uf::Userdata& uf::Userdata::operator=( Userdata&& move ) {
+	if ( this->m_pod && move.m_pod ) this->m_pod = move.m_pod, move.m_pod = NULL;
+	return *this;
+}
+uf::Userdata& uf::Userdata::operator=( const Userdata& copy ) {
+	if ( this->m_pod && copy.m_pod ) this->copy( copy );
+	return *this;
+}
\ No newline at end of file
diff --git a/engine/src/utils/window/window.cpp b/engine/src/utils/window/window.cpp
new file mode 100644
index 00000000..e7575918
--- /dev/null
+++ b/engine/src/utils/window/window.cpp
@@ -0,0 +1,163 @@
+#include <uf/config.h>
+#if !UF_USE_SFML
+#define UF_OPENGL_CONTEXT_IN_WINDOW 0
+#include <uf/utils/window/window.h>
+#include <uf/utils/io/iostream.h>
+bool uf::Window::focused = false;
+
+// 	C-tors
+UF_API_CALL uf::Window::Window() :
+	m_window(NULL),
+	m_context(NULL)
+{
+
+}
+UF_API_CALL uf::Window::Window( const spec::uni::Window::vector_t& size, const spec::uni::Window::title_t& title, const spec::Context::Settings& settings ) : Window() {
+	this->create(size, title, settings);
+}
+void UF_API_CALL uf::Window::create( const spec::uni::Window::vector_t& size, const spec::uni::Window::title_t& title, const spec::Context::Settings& settings ) {
+	this->m_window = new uf::Window::window_t;
+	this->m_window->create( size, title );
+#if UF_USE_OPENGL && UF_OPENGL_CONTEXT_IN_WINDOW
+	this->m_context = (spec::Context*) spec::uni::Context::create( settings, *this->m_window );
+#endif
+}
+// 	D-tors
+uf::Window::~Window() {
+	this->terminate();
+}
+void UF_API_CALL uf::Window::terminate() {
+#if UF_OPENGL_CONTEXT_IN_WINDOW
+	if ( this->m_context ) {
+		this->m_context->terminate();
+		delete this->m_context;
+		this->m_context = NULL;
+	}
+#endif
+	if ( this->m_window ) {
+		this->m_window->terminate();
+		delete this->m_window;
+		this->m_window = NULL;
+	}
+}
+// 	Gets
+spec::uni::Window::vector_t UF_API_CALL uf::Window::getPosition() const {
+	static spec::uni::Window::vector_t null = {};
+	return this->m_window ? this->m_window->getPosition() : null;
+}
+spec::uni::Window::vector_t UF_API_CALL uf::Window::getSize() const {
+	static spec::uni::Window::vector_t null = {};
+	return this->m_window ? this->m_window->getSize() : null;
+}
+size_t UF_API_CALL uf::Window::getRefreshRate() const {
+	static spec::uni::Window::vector_t null = {};
+	return this->m_window ? this->m_window->getRefreshRate() : 0;
+}
+// 	Attribute modifiers
+void UF_API_CALL uf::Window::setPosition( const spec::uni::Window::vector_t& position ) {
+	if ( this->m_window ) this->m_window->setPosition(position);
+}
+void UF_API_CALL uf::Window::centerWindow() {
+	if ( this->m_window ) this->m_window->centerWindow();
+}
+void UF_API_CALL uf::Window::setMousePosition( const spec::uni::Window::vector_t& position ) {
+	if ( this->m_window ) this->m_window->setMousePosition(position);
+}
+spec::uni::Window::vector_t UF_API_CALL uf::Window::getMousePosition() {
+	if ( this->m_window ) return this->m_window->getMousePosition();
+	return { 0, 0 };
+}
+void UF_API_CALL uf::Window::setSize( const spec::uni::Window::vector_t& size ) {
+	if ( this->m_window ) this->m_window->setSize(size);
+}
+void UF_API_CALL uf::Window::setTitle( const spec::uni::Window::title_t& title ) {
+	if ( this->m_window ) this->m_window->setTitle(title);
+}
+void UF_API_CALL uf::Window::setIcon( const spec::uni::Window::vector_t& size, uint8_t* pixels ) {
+	if ( this->m_window ) this->m_window->setIcon(size, pixels);
+}
+void UF_API_CALL uf::Window::setVisible( bool visibility ) {
+	if ( this->m_window ) this->m_window->setVisible(visibility);
+}
+void UF_API_CALL uf::Window::setCursorVisible( bool visibility ) {
+	if ( this->m_window ) this->m_window->setCursorVisible(visibility);
+}
+void UF_API_CALL uf::Window::setKeyRepeatEnabled( bool state ) {
+	if ( this->m_window ) this->m_window->setKeyRepeatEnabled(state);
+}
+void UF_API_CALL uf::Window::setMouseGrabbed( bool state ) {
+	if ( this->m_window ) this->m_window->setMouseGrabbed(state);
+}
+
+void UF_API_CALL uf::Window::requestFocus() {
+	if ( this->m_window ) this->m_window->requestFocus();
+}
+bool UF_API_CALL uf::Window::hasFocus() const {
+	return uf::Window::focused = (this->m_window ? this->m_window->hasFocus() : false);
+}
+pod::Vector2ui UF_API_CALL uf::Window::getResolution() {
+	return uf::Window::window_t::getResolution();
+}
+void UF_API_CALL uf::Window::switchToFullscreen( bool borderless ) {
+	if ( this->m_window ) this->m_window->switchToFullscreen( borderless );
+}
+// 	Update
+void UF_API_CALL uf::Window::processEvents() {
+	if ( this->m_window ) this->m_window->processEvents();
+}
+bool UF_API_CALL uf::Window::pollEvents( bool block ) {
+	return this->m_window ? this->m_window->pollEvents(block) : false;
+}
+bool UF_API_CALL uf::Window::isKeyPressed( const std::string& key ) {
+	return uf::Window::focused && uf::Window::window_t::isKeyPressed(key);
+}
+bool UF_API_CALL uf::Window::setActive(bool active) {
+#if UF_USE_OPENGL && UF_OPENGL_CONTEXT_IN_WINDOW 
+	if (this->m_context) {
+		if (this->m_context->setActive(active)) return true;
+		uf::iostream << "[" << uf::IoStream::Color()("Red") << "ERROR" << "]" << "Failed to activate the window's context" << "\n";
+		return false;
+	}
+#endif
+	return false;
+}
+#if UF_USE_VULKAN
+std::vector<std::string> UF_API_CALL uf::Window::getExtensions( bool x ) {
+	return this->m_window->getExtensions( x );
+}
+void UF_API_CALL uf::Window::createSurface( VkInstance instance, VkSurfaceKHR& surface ) {
+	this->m_window->createSurface( instance, surface );
+}
+#endif
+
+/*virtual*/ uf::Window::window_t* UF_API_CALL uf::Window::getHandle() {
+	return this->m_window;
+}
+/*virtual*/ const uf::Window::window_t* UF_API_CALL uf::Window::getHandle() const {
+	return this->m_window;
+}
+
+
+////////////////////////////////////////////////////////////
+
+#include <thread>
+#include <chrono>
+#include <uf/utils/time/time.h>
+void UF_API_CALL uf::Window::display() {
+	// Display the backbuffer on screen
+#if UF_USE_OPENGL && UF_OPENGL_CONTEXT_IN_WINDOW
+	if (this->m_context && this->setActive()) this->m_context->display();
+#endif
+	/* FPS */ if ( false ) {
+		static double limit = 1.0 / 60;
+		static uf::Timer<long long> timer(false);
+		if ( !timer.running() ) timer.start();
+		double delta = limit - timer.elapsed().asDouble();
+		if ( delta > 0 ) {
+			std::this_thread::sleep_for( std::chrono::milliseconds( (int) delta * 1000 ) );
+			timer.reset();
+		}
+	}
+}
+
+#endif
\ No newline at end of file
diff --git a/exe/default.config b/exe/default.config
deleted file mode 100644
index b08d5af5..00000000
--- a/exe/default.config
+++ /dev/null
@@ -1 +0,0 @@
-gcc
\ No newline at end of file
diff --git a/exe/program.clang.bat b/exe/program.clang.bat
deleted file mode 100644
index 924336bf..00000000
--- a/exe/program.clang.bat
+++ /dev/null
@@ -1,3 +0,0 @@
-cd ..
-set PATH=%CD%\exe\lib\win64\;%CD%\exe\lib\win64\clang;%PATH%
-.\exe\program.clang.exe %*
diff --git a/exe/program.gcc10.bat b/exe/program.gcc10.bat
deleted file mode 100644
index d8709501..00000000
--- a/exe/program.gcc10.bat
+++ /dev/null
@@ -1,3 +0,0 @@
-cd ..
-set PATH=%CD%\exe\lib\win64\;%CD%\exe\lib\win64\gcc10;%PATH%
-.\exe\program.gcc10.exe %*
diff --git a/ext/behaviors/craeture/behavior.cpp b/ext/behaviors/craeture/behavior.cpp
new file mode 100644
index 00000000..6596ea3b
--- /dev/null
+++ b/ext/behaviors/craeture/behavior.cpp
@@ -0,0 +1,176 @@
+#include "behavior.h"
+
+#include <uf/utils/hook/hook.h>
+#include <uf/utils/time/time.h>
+#include <uf/utils/serialize/serializer.h>
+#include <uf/utils/userdata/userdata.h>
+#include <uf/utils/window/window.h>
+#include <uf/utils/camera/camera.h>
+#include <uf/utils/thread/thread.h>
+#include <uf/utils/string/ext.h>
+#include <uf/utils/audio/audio.h>
+#include <uf/utils/math/transform.h>
+#include <uf/utils/math/collision.h>
+
+#include "../../scenes/worldscape//battle.h"
+
+#include "../../scenes/worldscape/terrain/generator.h"
+
+#include <uf/engine/asset/asset.h>
+
+UF_BEHAVIOR_REGISTER_CPP(ext::CraetureBehavior)
+#define this (&self)
+void ext::CraetureBehavior::initialize( uf::Object& self ) {
+	pod::Transform<>& transform = this->getComponent<pod::Transform<>>();
+	auto& camera = this->getComponent<uf::Camera>();
+	camera.getTransform().reference = &transform;
+
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+#if 0
+	pod::Physics& physics = this->getComponent<pod::Physics>();
+	physics.linear.velocity = {0,0,0};
+	physics.linear.acceleration = {0,-9.81,0};
+	physics.rotational.velocity = uf::quaternion::axisAngle( {0,1,0}, (pod::Math::num_t) 0 );
+	physics.rotational.acceleration = {0,0,0,0};
+
+	/* Gravity */ {
+		if ( !ext::json::isNull( metadata["system"]["physics"]["gravity"] ) ) {
+			physics.linear.acceleration.x = metadata["system"]["physics"]["gravity"][0].as<float>();
+			physics.linear.acceleration.y = metadata["system"]["physics"]["gravity"][1].as<float>();
+			physics.linear.acceleration.z = metadata["system"]["physics"]["gravity"][2].as<float>();
+		}
+		if ( !metadata["system"]["physics"]["collision"].as<bool>() )  {
+			physics.linear.acceleration.x = 0;
+			physics.linear.acceleration.y = 0;
+			physics.linear.acceleration.z = 0;
+		}
+	}
+	/* Collider */ {
+		uf::Collider& collider = this->getComponent<uf::Collider>();
+
+		collider.clear();
+		auto* box = new uf::BoundingBox( {0, 1.5, 0}, {0.7, 1.6, 0.7} );
+		box->getTransform().reference = &transform;
+		collider.add(box);
+	}
+	/* RPG */ {
+		ext::HousamoBattle& battle = this->getComponent<ext::HousamoBattle>();
+	}
+#endif
+	// Hooks
+/*
+	struct {
+		uf::Timer<long long> flash = uf::Timer<long long>(false);
+		uf::Timer<long long> sound = uf::Timer<long long>(false);
+	} timers;
+*/
+	static uf::Timer<long long> timer(true);
+	this->addHook( "world:Collision.%UID%", [&](ext::json::Value& json){
+		size_t uid = json["uid"].as<size_t>();
+		// do not collide with children
+		// if ( this->findByUid(uid) ) return;
+
+		pod::Vector3 normal;
+		float scale = metadata["system"]["physics"]["collision"].as<float>();
+		float depth = json["depth"].as<float>() * scale;
+	//	if ( fabs(depth) < 0.005 ) return; //std::cout << "Collision depth: " << depth << std::endl;
+
+		normal.x = json["normal"][0].as<float>();
+		normal.y = json["normal"][1].as<float>();
+		normal.z = json["normal"][2].as<float>();
+		pod::Vector3 correction = normal * depth;
+
+	#if 0
+		transform.position -= correction;
+
+		if ( normal.x == 1 || normal.x == -1 ) physics.linear.velocity.x = 0;
+		if ( normal.y == 1 || normal.y == -1 ) physics.linear.velocity.y = 0;
+		if ( normal.z == 1 || normal.z == -1 ) physics.linear.velocity.z = 0;
+	#endif
+	});
+	this->addHook( "asset:Cache.Sound.%UID%", [&](ext::json::Value& json){
+		uf::Scene& world = uf::scene::getCurrentScene();
+		uf::Serializer& masterdata = world.getComponent<uf::Serializer>();
+		
+		std::string filename = json["filename"].as<std::string>();
+
+		if ( uf::io::extension(filename) != "ogg" ) return;
+
+		if ( filename == "" ) return;
+		uf::Audio& sfx = this->getComponent<uf::SoundEmitter>().add(filename);
+		sfx.setVolume(masterdata["volumes"]["sfx"].as<float>());
+		auto& pTransform = world.getController().getComponent<pod::Transform<>>();
+		sfx.setPosition( transform.position );
+		sfx.play();
+	});
+	this->addHook( "world:Craeture.OnHit.%UID%", [&](ext::json::Value& json){
+		uint64_t phase = json["phase"].as<size_t>();
+		// start color
+		pod::Vector4f color = { 1, 1, 1, 0 };
+		if ( phase == 0 ) {
+			color = pod::Vector4f{
+				json["color"][0].as<float>(),
+				json["color"][1].as<float>(),
+				json["color"][2].as<float>(),
+				json["color"][3].as<float>(),
+			};
+		}
+		metadata["color"][0] = color[0];
+		metadata["color"][1] = color[1];
+		metadata["color"][2] = color[2];
+		metadata["color"][3] = color[3];
+
+		if ( metadata["timers"]["hurt"].as<float>() < timer.elapsed().asDouble() ) {
+
+			metadata["timers"]["hurt"] = timer.elapsed().asDouble() + 1.0f;
+			uf::Scene& scene = uf::scene::getCurrentScene();
+			uf::Asset& assetLoader = scene.getComponent<uf::Asset>();
+			assetLoader.cache(uf::io::root+"/audio/battle/hurt.ogg", "asset:Cache.Sound." + std::to_string(this->getUid()));
+		}
+	});
+	this->addHook( "world:Craeture.Hurt.%UID%", [&](ext::json::Value& json){
+		if ( metadata["timers"]["flash"].as<float>() < timer.elapsed().asDouble() ) {
+			metadata["timers"]["flash"] = timer.elapsed().asDouble() + 0.4f;
+			for ( int i = 0; i < 16; ++i ) {
+				uf::Serializer payload;
+				payload["phase"] = i % 2 == 0 ? 0 : 1;
+				payload["color"][0] = 1.0f;
+				payload["color"][1] = 0.0f;
+				payload["color"][2] = 0.0f;
+				payload["color"][3] = 0.6f;
+				this->queueHook("world:Craeture.OnHit.%UID%", payload, 0.05f * i);
+			}
+		}
+	});
+}
+void ext::CraetureBehavior::tick( uf::Object& self ) {
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	uf::Scene& scene = uf::scene::getCurrentScene();
+	uf::Serializer& sMetadata = scene.getComponent<uf::Serializer>();
+	uf::Serializer& pMetadata = scene.getController().getComponent<uf::Serializer>();
+
+#if 0
+	if ( !pMetadata["system"]["control"].as<bool>() ) return;
+	if ( !sMetadata["system"]["physics"]["optimizations"]["entity-local update"].as<bool>() ) return;
+
+	pod::Transform<>& transform = this->getComponent<pod::Transform<>>();
+	pod::Physics& physics = this->getComponent<pod::Physics>();
+	/* Gravity */ {
+		if ( !ext::json::isNull( metadata["system"]["physics"]["gravity"] ) ) {
+			physics.linear.acceleration.x = metadata["system"]["physics"]["gravity"][0].as<float>();
+			physics.linear.acceleration.y = metadata["system"]["physics"]["gravity"][1].as<float>();
+			physics.linear.acceleration.z = metadata["system"]["physics"]["gravity"][2].as<float>();
+		}
+		if ( !metadata["system"]["physics"]["collision"].as<bool>() )  {
+			physics.linear.acceleration.x = 0;
+			physics.linear.acceleration.y = 0;
+			physics.linear.acceleration.z = 0;
+		}
+	}
+	transform = uf::physics::update( transform, physics );
+#endif
+}
+
+void ext::CraetureBehavior::render( uf::Object& self ){}
+void ext::CraetureBehavior::destroy( uf::Object& self ){}
+#undef this
\ No newline at end of file
diff --git a/ext/behaviors/craeture/behavior.h b/ext/behaviors/craeture/behavior.h
new file mode 100644
index 00000000..b702b123
--- /dev/null
+++ b/ext/behaviors/craeture/behavior.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/ext/ext.h>
+#include <uf/engine/entity/entity.h>
+#include <uf/engine/scene/scene.h>
+
+namespace ext {
+	class EXT_API CraetureBehavior {
+	public:
+		static void attach( uf::Object& );
+		static void initialize( uf::Object& );
+		static void tick( uf::Object& );
+		static void render( uf::Object& );
+		static void destroy( uf::Object& );
+	};
+}
\ No newline at end of file
diff --git a/ext/behaviors/hands/behavior.cpp b/ext/behaviors/hands/behavior.cpp
new file mode 100644
index 00000000..40577244
--- /dev/null
+++ b/ext/behaviors/hands/behavior.cpp
@@ -0,0 +1,487 @@
+#include "behavior.h"
+
+#include <uf/utils/hook/hook.h>
+#include <uf/utils/time/time.h>
+#include <uf/utils/serialize/serializer.h>
+#include <uf/utils/userdata/userdata.h>
+#include <uf/utils/window/window.h>
+#include <uf/utils/camera/camera.h>
+#include <uf/utils/audio/audio.h>
+#include <uf/ext/openvr/openvr.h>
+#include <uf/utils/math/physics.h>
+#include <uf/utils/graphic/mesh.h>
+#include <uf/utils/graphic/graphic.h>
+#include <uf/utils/math/transform.h>
+#include <uf/utils/math/collision.h>
+#include <uf/utils/thread/thread.h>
+#include <uf/utils/renderer/renderer.h>
+
+#include <sstream>
+
+namespace {
+	struct {
+		uf::Object* left;
+		uf::Object* right;
+	} hands, lines, lights;
+}
+
+UF_BEHAVIOR_REGISTER_CPP(ext::PlayerHandBehavior)
+#define this (&self)
+void ext::PlayerHandBehavior::initialize( uf::Object& self ) {
+#if UF_USE_OPENVR
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	{
+		::hands.left = (uf::Object*) &uf::instantiator::instantiate("Object");
+		::hands.right = (uf::Object*) &uf::instantiator::instantiate("Object");
+		
+		::lines.left = (uf::Object*) &uf::instantiator::instantiate("Object");
+		::lines.right = (uf::Object*) &uf::instantiator::instantiate("Object");
+
+		this->addChild(::hands.left);
+		this->addChild(::hands.right);
+
+		::hands.left->addChild(::lines.left);
+		::hands.right->addChild(::lines.right);
+	}
+	{
+		bool loaded = true;
+		for ( auto it = metadata["hands"].begin(); it != metadata["hands"].end(); ++it ) {
+			std::string key = it.key();
+			if ( !ext::openvr::requestRenderModel(metadata["hands"][key]["controller"]["model"].as<std::string>()) ) loaded = false;
+		}
+		if ( !loaded ) {
+			this->addHook( "VR:Model.Loaded", [&](ext::json::Value& json){
+				std::string name = json["name"].as<std::string>();
+				std::string side = "";
+				if ( name == metadata["hands"]["left"]["controller"]["model"].as<std::string>() ) {
+					side = "left";
+				} else if ( name == metadata["hands"]["right"]["controller"]["model"].as<std::string>() ) {
+					side = "right";
+				};
+				if ( side == "" ) return;
+
+				uf::Object& hand = *(side == "left" ? ::hands.left : ::hands.right);
+				uf::Object& line = *(side == "left" ? ::lines.left : ::lines.right);
+				{
+					uf::Graphic& graphic = (hand.getComponent<uf::Graphic>() = ext::openvr::getRenderModel( name ));
+					
+					graphic.process = true;
+
+					graphic.descriptor.frontFace = uf::renderer::enums::Face::CCW;
+					graphic.material.attachShader(uf::io::root+"/shaders/base/vert.spv", uf::renderer::enums::Shader::VERTEX);
+					graphic.material.attachShader(uf::io::root+"/shaders/base/frag.spv", uf::renderer::enums::Shader::FRAGMENT);
+
+					uf::instantiator::bind( "EntityBehavior", hand );
+					uf::instantiator::bind( "ObjectBehavior", hand );
+					hand.initialize();
+				}
+				if ( metadata["hands"][side]["pointer"]["length"].as<float>() > 0 ) {
+				//	line.addAlias<uf::LineMesh, uf::Mesh>();
+
+					pod::Transform<>& transform = line.getComponent<pod::Transform<>>();
+					transform.orientation = uf::quaternion::axisAngle( 
+						{
+							metadata["hands"][side]["pointer"]["orientation"]["axis"][0].as<float>(),
+							metadata["hands"][side]["pointer"]["orientation"]["axis"][1].as<float>(),
+							metadata["hands"][side]["pointer"]["orientation"]["axis"][2].as<float>()
+						},
+						metadata["hands"][side]["pointer"]["orientation"]["angle"].as<float>() * 3.14159f / 180.0f
+					);
+					transform.position = {
+						metadata["hands"][side]["pointer"]["offset"][0].as<float>(),
+						metadata["hands"][side]["pointer"]["offset"][1].as<float>(),
+						metadata["hands"][side]["pointer"]["offset"][2].as<float>()
+					};
+
+					auto& mesh = line.getComponent<uf::LineMesh>();
+					auto& graphic = line.getComponent<uf::Graphic>();
+
+					mesh.vertices = {
+						{ {0.0f, 0.0f, 0.0f} },
+						{ {0.0f, 0.0f, metadata["hands"][side]["pointer"]["length"].as<float>()} },
+					};
+					graphic.initialize();
+					graphic.initializeMesh(mesh);
+					
+					graphic.material.attachShader(uf::io::root+"/shaders/line/vert.spv", uf::renderer::enums::Shader::VERTEX);
+					graphic.material.attachShader(uf::io::root+"/shaders/line/frag.spv", uf::renderer::enums::Shader::FRAGMENT);
+					graphic.descriptor.topology = uf::renderer::enums::PrimitiveTopology::LINE_STRIP;
+					graphic.descriptor.fill = uf::renderer::enums::PolygonMode::LINE;
+					graphic.descriptor.lineWidth = metadata["hands"][side]["pointer"]["width"].as<float>();
+
+					line.initialize();
+				}
+				if ( metadata["hands"][side]["light"]["should"].as<bool>() ){
+					auto& child = hand.loadChild("/light.json", false);
+					if (side == "left" )
+						lights.left = &child;
+					else
+						lights.right = &child;
+
+					auto& json = metadata["hands"][side]["light"];
+					auto& light = side == "left" ? *lights.left : *lights.right;
+
+					auto& metadata = light.getComponent<uf::Serializer>();
+					if ( !ext::json::isNull( json["color"] ) ) metadata["light"]["color"] = json["color"];
+					if ( !ext::json::isNull( json["radius"] ) ) metadata["light"]["radius"] = json["radius"];
+					if ( !ext::json::isNull( json["power"] ) ) metadata["light"]["power"] = json["power"];
+					if ( !ext::json::isNull( json["type"] ) ) metadata["light"]["type"] = json["type"];
+					if ( !ext::json::isNull( json["shadows"] ) ) metadata["light"]["shadows"] = json["shadows"];
+					metadata["lights"]["external update"] = true;
+
+					// light.initialize();
+				/*
+					auto* child = (uf::Object*) hand.findByUid(hand.loadChild("/light.json", false));
+					if ( child ) {
+						if (side == "left" ) lights.left = child; else lights.right = child;
+						auto& json = metadata["hands"][side]["light"];
+						auto& light = side == "left" ? *lights.left : *lights.right;
+
+						auto& metadata = light.getComponent<uf::Serializer>();
+						if ( !ext::json::isNull( json["color"] ) ) metadata["light"]["color"] = json["color"];
+						if ( !ext::json::isNull( json["radius"] ) ) metadata["light"]["radius"] = json["radius"];
+						if ( !ext::json::isNull( json["power"] ) ) metadata["light"]["power"] = json["power"];
+						if ( !ext::json::isNull( json["shadows"] ) ) metadata["light"]["shadows"] = json["shadows"];
+						metadata["lights"]["external update"] = true;
+
+						light.initialize();
+					}
+				*/
+				}
+
+				
+			});
+		}
+		std::vector<uf::Object*> vHands = { ::hands.left, ::hands.right };
+		for ( auto pointer : vHands ) {
+			auto& hand = *pointer;
+			hand.addHook("VR:Input.Digital", [&](ext::json::Value& json){
+				std::string side = &hand == hands.left ? "left" : "right";
+				if ( json["hand"].as<std::string>() != side ) return;
+
+				// fire mouse click
+				if ( json["name"].as<std::string>() == "click" ) {
+
+					uf::Serializer payload;
+					payload["type"] = "window:Mouse.Click";
+					payload["invoker"] = "vr";
+					payload["mouse"]["position"]["x"]	= metadata["hands"][side]["cursor"]["position"][0].as<float>();
+					payload["mouse"]["position"]["y"]	= metadata["hands"][side]["cursor"]["position"][1].as<float>();
+					payload["mouse"]["delta"]["x"] 		= 0;
+					payload["mouse"]["delta"]["y"] 		= 0;
+					payload["mouse"]["button"] 			= side == "left" ? "Right" : "Left";
+					payload["mouse"]["state"] = json["state"].as<bool>() ? "Down": "Up";
+
+					uf::hooks.call( payload["type"].as<std::string>(), payload );
+				}				
+			});
+			hand.addHook("world:Collision.%UID%", [&](ext::json::Value& json){
+				std::string side = &hand == hands.left ? "left" : "right";
+
+				float mag = json["depth"].as<float>();
+				uf::Serializer payload;
+				payload["delay"] = 0.0f;
+				payload["duration"] = uf::physics::time::delta;
+				payload["frequency"] = 1.0f;
+				payload["amplitude"] = fmin(1.0f, 1000.0f * mag);
+				payload["side"] = side;
+				uf::hooks.call( "VR:Haptics." + side, payload );
+			});
+
+			auto& transform = hand.getComponent<pod::Transform<>>();
+			auto& collider = hand.getComponent<uf::Collider>();
+
+		//	auto* box = new uf::BoundingBox( transform.position, {0.25, 0.25, 0.25} );
+		//	box->getTransform().reference = &transform;
+		//	collider.add(box);
+		}
+	}
+#endif
+}
+void ext::PlayerHandBehavior::tick( uf::Object& self ) {
+#if UF_USE_OPENVR
+	auto& scene = uf::scene::getCurrentScene();
+	auto& controller = scene.getController();
+	auto& controllerCamera = controller.getComponent<uf::Camera>();
+	auto& controllerTransform = controller.getComponent<pod::Transform<>>();
+	auto& controllerCameraTransform = controllerCamera.getTransform();
+	{
+		pod::Transform<>& transform = ::hands.left->getComponent<pod::Transform<>>();
+		transform.position = ext::openvr::controllerPosition( vr::Controller_Hand::Hand_Left );
+		transform.orientation = ext::openvr::controllerQuaternion( vr::Controller_Hand::Hand_Left );
+		transform.scale = { 1, 1, 1 };
+		transform.reference = &controllerTransform;
+
+		auto& collider = ::hands.left->getComponent<uf::Collider>();
+		for ( auto* box : collider.getContainer() ) {
+			box->getTransform().position = transform.position + controllerTransform.position + controllerCameraTransform.position;
+		}
+	}
+	{
+		pod::Transform<>& transform = ::hands.right->getComponent<pod::Transform<>>();
+		transform.position = ext::openvr::controllerPosition( vr::Controller_Hand::Hand_Right );
+		transform.orientation = ext::openvr::controllerQuaternion( vr::Controller_Hand::Hand_Right );
+		transform.scale = { 1, 1, 1 };
+		transform.reference = &controllerTransform;
+
+		auto& collider = ::hands.right->getComponent<uf::Collider>();
+		for ( auto* box : collider.getContainer() ) {
+			box->getTransform().position = transform.position + controllerTransform.position + controllerCameraTransform.position;
+		}
+	}
+	{
+		pod::Transform<>& transform = ::lines.left->getComponent<pod::Transform<>>();
+		transform.position = ext::openvr::controllerPosition( vr::Controller_Hand::Hand_Left, true );
+		transform.orientation = ext::openvr::controllerQuaternion( vr::Controller_Hand::Hand_Left, true );
+		transform.scale = { 1, 1, 1 };
+		transform.reference = &controllerTransform;
+
+		if ( lights.left ) {
+			if ( lights.left->getUid() == 0 ) {
+				lights.left->initialize();
+			}
+			auto& light = *lights.left;
+			auto& lightTransform = light.getComponent<pod::Transform<>>();
+			lightTransform.position = controllerCameraTransform.position + controller.getComponent<pod::Transform<>>().position + transform.position;
+
+			auto& lightCamera = light.getComponent<uf::Camera>();
+			pod::Matrix4f playerModel = uf::matrix::identity();
+			pod::Matrix4f translation = uf::matrix::translate( uf::matrix::identity(), controllerCameraTransform.position + controllerTransform.position );
+			pod::Matrix4f rotation = uf::quaternion::matrix( controllerTransform.orientation );
+			playerModel = translation * rotation;
+
+			pod::Matrix4f model = uf::matrix::inverse( playerModel * ext::openvr::controllerModelMatrix( vr::Controller_Hand::Hand_Left, true ) );
+			for ( size_t i = 0; i < 2; ++i ) lightCamera.setView( model, i );
+		}
+	}
+	{
+		pod::Transform<>& transform = ::lines.right->getComponent<pod::Transform<>>();
+		transform.position = ext::openvr::controllerPosition( vr::Controller_Hand::Hand_Right, true );
+		transform.orientation = ext::openvr::controllerQuaternion( vr::Controller_Hand::Hand_Right, true );
+		transform.scale = { 1, 1, 1 };
+		transform.reference = &controllerTransform;
+
+		if ( lights.right ) {
+			if ( lights.right->getUid() == 0 ) {
+				lights.right->initialize();
+			}
+			auto& light = *lights.right;
+			auto& lightTransform = light.getComponent<pod::Transform<>>();
+			lightTransform.position = controllerCameraTransform.position + controllerTransform.position + transform.position;
+
+			auto& lightCamera = light.getComponent<uf::Camera>();
+			pod::Matrix4f playerModel = uf::matrix::identity();
+			pod::Matrix4f translation = uf::matrix::translate( uf::matrix::identity(), controllerCameraTransform.position + controllerTransform.position );
+			pod::Matrix4f rotation = uf::quaternion::matrix( controllerTransform.orientation );
+			playerModel = translation * rotation;
+
+			pod::Matrix4f model = uf::matrix::inverse( playerModel * ext::openvr::controllerModelMatrix( vr::Controller_Hand::Hand_Right, true ) );
+			for ( size_t i = 0; i < 2; ++i ) lightCamera.setView( model, i );
+		}
+	}
+
+	// raytrace pointer / hand collision
+	{
+		std::vector<uf::Object*> handPointers = { ::hands.left, ::hands.right };
+		for ( auto pointer : handPointers ) { auto& hand = *pointer;
+			std::string side = &hand == ::hands.left ? "left" : "right";
+			if ( !ext::openvr::controllerActive( side == "left" ? vr::Controller_Hand::Hand_Left : vr::Controller_Hand::Hand_Right ) ) continue;
+			{
+				pod::Transform<>& transform = (side == "left" ? ::lines.left : ::lines.right)->getComponent<pod::Transform<>>();
+				struct {
+					pod::Vector3f origin;
+					pod::Vector3f direction;
+				} ray;
+				struct {
+					pod::Vector3f center;
+					pod::Vector3f normal;
+				} plane;
+
+				transform = uf::transform::reorient( transform );
+				ray.origin = transform.position;
+				ray.direction = transform.forward;
+
+				pod::Transform<> gtransform;
+				pod::Matrix4f mvp;
+				uf::Serializer& cMetadata = controller.getComponent<uf::Serializer>();
+				if ( ext::json::isArray( cMetadata["overlay"]["position"] ) ) 
+					gtransform.position = {
+						cMetadata["overlay"]["position"][0].as<float>(),
+						cMetadata["overlay"]["position"][1].as<float>(),
+						cMetadata["overlay"]["position"][2].as<float>(),
+					};
+				if ( ext::json::isArray( cMetadata["overlay"]["scale"] ) ) 
+					gtransform.scale = {
+						cMetadata["overlay"]["scale"][0].as<float>(),
+						cMetadata["overlay"]["scale"][1].as<float>(),
+						cMetadata["overlay"]["scale"][2].as<float>(),
+					};
+				if ( ext::json::isArray( cMetadata["overlay"]["orientation"] ) ) 
+					gtransform.orientation = {
+						cMetadata["overlay"]["orientation"][0].as<float>(),
+						cMetadata["overlay"]["orientation"][1].as<float>(),
+						cMetadata["overlay"]["orientation"][2].as<float>(),
+						cMetadata["overlay"]["orientation"][3].as<float>(),
+					};
+
+				plane.center = gtransform.position;
+				{
+					auto rotated = uf::quaternion::multiply( gtransform.orientation, pod::Vector4f{ 0, 0, 1, 1 } );
+					plane.normal.x = rotated.x;
+					plane.normal.y = rotated.y;
+					plane.normal.z = rotated.z;
+					plane.normal = uf::vector::normalize( plane.normal );
+				}
+
+				float denom = uf::vector::dot(plane.normal, ray.direction);
+				if (abs(denom) > 0.0001f) {
+					float t = uf::vector::dot( uf::vector::subtract(plane.center, ray.origin), plane.normal ) / denom;
+					if ( t >= 0 ) {
+						pod::Vector3f hit = ray.origin + (ray.direction * t);
+						pod::Vector3f translated = uf::matrix::multiply<float>( uf::matrix::inverse( uf::matrix::scale( uf::matrix::identity(), gtransform.scale ) ), uf::vector::subtract( plane.center, hit ) );
+						{
+							auto& metadata = this->getComponent<uf::Serializer>();
+							cMetadata["overlay"]["cursor"]["type"] = "vr";
+							cMetadata["overlay"]["cursor"]["position"][0] =  translated.x;
+							cMetadata["overlay"]["cursor"]["position"][1] =  translated.y;
+							cMetadata["overlay"]["cursor"]["position"][2] =  translated.z;
+
+							metadata["hands"][side]["cursor"] = cMetadata["overlay"]["cursor"];
+						}
+					}
+				}
+			}
+		}
+	}
+#endif
+}
+
+void ext::PlayerHandBehavior::render( uf::Object& self ){
+#if UF_USE_OPENVR
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	auto& scene = uf::scene::getCurrentScene();
+	auto& controller = scene.getController();
+	auto& camera = controller.getComponent<uf::Camera>();
+
+	pod::Matrix4f playerModel = uf::matrix::identity(); {
+		auto& controller = this->getParent();
+		auto& camera = controller.getComponent<uf::Camera>();
+		pod::Matrix4f translation = uf::matrix::translate( uf::matrix::identity(), camera.getTransform().position + controller.getComponent<pod::Transform<>>().position );
+		pod::Matrix4f rotation = uf::quaternion::matrix( controller.getComponent<pod::Transform<>>().orientation );
+		playerModel = translation * rotation;
+	}
+//	pod::Matrix4f cameraModel = uf::matrix::translate( uf::matrix::identity(), camera.getTransform().position + controller.getComponent<pod::Transform<>>().position ) * uf::quaternion::matrix( controller.getComponent<pod::Transform<>>().orientation );	
+	if ( ::hands.left && ::hands.left->hasComponent<uf::Graphic>() ) {
+		auto& graphic = ::hands.left->getComponent<uf::Graphic>();
+		auto& transform = ::hands.left->getComponent<pod::Transform<>>();
+		graphic.process = ext::openvr::controllerActive( vr::Controller_Hand::Hand_Left );
+		pod::Matrix4f model = playerModel * ext::openvr::controllerModelMatrix( vr::Controller_Hand::Hand_Left, false );
+		if ( graphic.initialized && graphic.material.hasShader("vertex") ) {	
+			auto& shader = graphic.material.getShader("vertex");
+			auto& uniform = shader.getUniform("UBO");
+			auto& uniforms = uniform.get<uf::MeshDescriptor<>>();
+
+			uniforms.matrices.model = model;
+			for ( std::size_t i = 0; i < uf::renderer::settings::maxViews; ++i ) {
+				uniforms.matrices.view[i] = camera.getView( i );
+				uniforms.matrices.projection[i] = camera.getProjection( i );
+			}
+			uniforms.color[0] = metadata["hands"]["left"]["controller"]["color"][0].as<float>();
+			uniforms.color[1] = metadata["hands"]["left"]["controller"]["color"][1].as<float>();
+			uniforms.color[2] = metadata["hands"]["left"]["controller"]["color"][2].as<float>();
+			uniforms.color[3] = metadata["hands"]["left"]["controller"]["color"][3].as<float>();
+
+			if ( uf::renderer::currentRenderMode ) {
+				auto& renderMode = *uf::renderer::currentRenderMode;
+				if ( renderMode.getName() == "" )
+					uniforms.matrices.model = pod::Matrix4f{};
+			} else {
+				uniforms.matrices.model = pod::Matrix4f{};
+			}
+
+			shader.updateUniform( "UBO", uniform );
+		}
+	}
+	if ( ::hands.right && ::hands.right->hasComponent<uf::Graphic>() ) {
+		auto& graphic = ::hands.right->getComponent<uf::Graphic>();
+		auto& transform = ::hands.right->getComponent<pod::Transform<>>();
+		graphic.process = ext::openvr::controllerActive( vr::Controller_Hand::Hand_Right );
+		pod::Matrix4f model = playerModel * ext::openvr::controllerModelMatrix( vr::Controller_Hand::Hand_Right, false );
+		if ( graphic.initialized && graphic.material.hasShader("vertex") ) {	
+			auto& shader = graphic.material.getShader("vertex");
+			auto& uniform = shader.getUniform("UBO");
+			auto& uniforms = uniform.get<uf::MeshDescriptor<>>();
+
+			uniforms.matrices.model = model;
+			for ( std::size_t i = 0; i < uf::renderer::settings::maxViews; ++i ) {
+				uniforms.matrices.view[i] = camera.getView( i );
+				uniforms.matrices.projection[i] = camera.getProjection( i );
+			}
+			uniforms.color[0] = metadata["hands"]["right"]["controller"]["color"][0].as<float>();
+			uniforms.color[1] = metadata["hands"]["right"]["controller"]["color"][1].as<float>();
+			uniforms.color[2] = metadata["hands"]["right"]["controller"]["color"][2].as<float>();
+			uniforms.color[3] = metadata["hands"]["right"]["controller"]["color"][3].as<float>();
+
+			if ( uf::renderer::currentRenderMode ) {
+				auto& renderMode = *uf::renderer::currentRenderMode;
+				if ( renderMode.getName() == "" )
+					uniforms.matrices.model = pod::Matrix4f{};
+			} else {
+				uniforms.matrices.model = pod::Matrix4f{};
+			}
+
+			shader.updateUniform( "UBO", uniform );
+		}
+	}
+	if ( ::lines.left && ::lines.left->hasComponent<uf::Graphic>() ) {
+		auto& graphic = ::lines.left->getComponent<uf::Graphic>();
+		auto& transform = ::lines.left->getComponent<pod::Transform<>>();
+		graphic.process = ext::openvr::controllerActive( vr::Controller_Hand::Hand_Left );
+		pod::Matrix4f model = playerModel * ext::openvr::controllerModelMatrix( vr::Controller_Hand::Hand_Left, true );
+		if ( graphic.initialized && graphic.material.hasShader("vertex") ) {	
+			auto& shader = graphic.material.getShader("vertex");
+			auto& uniform = shader.getUniform("UBO");
+			auto& uniforms = uniform.get<uf::MeshDescriptor<>>();
+
+			uniforms.matrices.model = model;
+			for ( std::size_t i = 0; i < uf::renderer::settings::maxViews; ++i ) {
+				uniforms.matrices.view[i] = camera.getView( i );
+				uniforms.matrices.projection[i] = camera.getProjection( i );
+			}
+			uniforms.color[0] = metadata["hands"]["left"]["pointer"]["color"][0].as<float>();
+			uniforms.color[1] = metadata["hands"]["left"]["pointer"]["color"][1].as<float>();
+			uniforms.color[2] = metadata["hands"]["left"]["pointer"]["color"][2].as<float>();
+			uniforms.color[3] = metadata["hands"]["left"]["pointer"]["color"][3].as<float>();
+			
+			shader.updateUniform( "UBO", uniform );
+		}
+	}
+	if ( ::lines.right && ::lines.right->hasComponent<uf::Graphic>() ) {
+		auto& graphic = ::lines.right->getComponent<uf::Graphic>();
+		auto& transform = ::lines.right->getComponent<pod::Transform<>>();
+		graphic.process = ext::openvr::controllerActive( vr::Controller_Hand::Hand_Right );
+		pod::Matrix4f model = playerModel * ext::openvr::controllerModelMatrix( vr::Controller_Hand::Hand_Right, true );
+		if ( graphic.initialized && graphic.material.hasShader("vertex") ) {	
+			auto& shader = graphic.material.getShader("vertex");
+			auto& uniform = shader.getUniform("UBO");
+			auto& uniforms = uniform.get<uf::MeshDescriptor<>>();
+
+			uniforms.matrices.model = model;
+			for ( std::size_t i = 0; i < uf::renderer::settings::maxViews; ++i ) {
+				uniforms.matrices.view[i] = camera.getView( i );
+				uniforms.matrices.projection[i] = camera.getProjection( i );
+			}
+			uniforms.color[0] = metadata["hands"]["right"]["pointer"]["color"][0].as<float>();
+			uniforms.color[1] = metadata["hands"]["right"]["pointer"]["color"][1].as<float>();
+			uniforms.color[2] = metadata["hands"]["right"]["pointer"]["color"][2].as<float>();
+			uniforms.color[3] = metadata["hands"]["right"]["pointer"]["color"][3].as<float>();
+			
+			shader.updateUniform( "UBO", uniform );
+		}
+	}
+#endif
+}
+void ext::PlayerHandBehavior::destroy( uf::Object& self ){
+
+}
+#undef this
\ No newline at end of file
diff --git a/ext/behaviors/hands/behavior.h b/ext/behaviors/hands/behavior.h
new file mode 100644
index 00000000..bb24d347
--- /dev/null
+++ b/ext/behaviors/hands/behavior.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/ext/ext.h>
+#include <uf/engine/entity/entity.h>
+#include <uf/engine/scene/scene.h>
+
+namespace ext {
+	class EXT_API PlayerHandBehavior {
+	public:
+		static void attach( uf::Object& );
+		static void initialize( uf::Object& );
+		static void tick( uf::Object& );
+		static void render( uf::Object& );
+		static void destroy( uf::Object& );
+	};
+}
\ No newline at end of file
diff --git a/ext/behaviors/light/behavior.cpp b/ext/behaviors/light/behavior.cpp
new file mode 100644
index 00000000..96fc49d3
--- /dev/null
+++ b/ext/behaviors/light/behavior.cpp
@@ -0,0 +1,247 @@
+#include "behavior.h"
+
+#include <uf/utils/renderer/renderer.h>
+
+#include <uf/utils/math/transform.h>
+#include <uf/utils/math/physics.h>
+#include <uf/utils/camera/camera.h>
+
+namespace {
+	struct {
+		size_t current = 0;
+		std::vector<uf::Object*> lights;
+	} roundRobin;
+}
+
+UF_BEHAVIOR_REGISTER_CPP(ext::LightBehavior)
+#define this (&self)
+void ext::LightBehavior::initialize( uf::Object& self ) {
+	auto& metadata = this->getComponent<uf::Serializer>();
+	auto& transform = this->getComponent<pod::Transform<>>();
+	auto& camera = this->getComponent<uf::Camera>();
+	auto& scene = uf::scene::getCurrentScene();
+	auto& controller = scene.getController();
+	auto& sceneMetadata = scene.getComponent<uf::Serializer>();
+
+	if ( !sceneMetadata["system"]["lights"]["round robin hook bound"].as<bool>() ) {
+		sceneMetadata["system"]["lights"]["round robin hook bound"] = true;
+		scene.addHook("game:Frame.Start", [&]( const ext::json::Value& payload ){
+			if ( ++::roundRobin.current >= ::roundRobin.lights.size() ) ::roundRobin.current = 0;
+		});
+	}
+
+	if ( !metadata["light"]["bias"]["constant"].is<float>() ) {
+		metadata["light"]["bias"]["constant"] = 0.00005f;
+	}
+	if ( !ext::json::isArray( metadata["light"]["color"] ) ) {
+		metadata["light"]["color"][0] = 1; //metadata["light"]["color"]["random"].as<bool>() ? (rand() % 100) / 100.0 : 1;
+		metadata["light"]["color"][1] = 1; //metadata["light"]["color"]["random"].as<bool>() ? (rand() % 100) / 100.0 : 1;
+		metadata["light"]["color"][2] = 1; //metadata["light"]["color"]["random"].as<bool>() ? (rand() % 100) / 100.0 : 1;
+	}
+#if UF_USE_OPENGL
+	metadata["light"]["shadows"] = false;
+#endif
+	if ( metadata["light"]["shadows"].as<bool>() ) {
+		auto& cameraTransform = camera.getTransform();
+		cameraTransform.reference = &transform;
+		camera.setStereoscopic(false);
+		if ( ext::json::isArray( metadata["light"]["radius"] ) ) {
+			auto bounds = camera.getBounds();
+			bounds.x = metadata["light"]["radius"][0].as<float>();
+			bounds.y = metadata["light"]["radius"][1].as<float>();
+			camera.setBounds(bounds);
+		}
+		if ( ext::json::isArray( metadata["light"]["resolution"] ) ) {
+			camera.setSize( uf::vector::decode( metadata["light"]["resolution"], pod::Vector2ui{ uf::renderer::settings::width, uf::renderer::settings::height } ) );
+		} else if ( metadata["light"]["resolution"].is<float>() ) {
+			size_t size = metadata["light"]["resolution"].as<size_t>();
+			camera.setSize( {size, size} );
+		} else {
+			camera.setSize( pod::Vector2ui{ uf::renderer::settings::width, uf::renderer::settings::height } );
+		}
+		
+		::roundRobin.lights.emplace_back(this);
+
+		auto& renderMode = this->getComponent<uf::renderer::RenderTargetRenderMode>();
+		renderMode.metadata["type"] = "depth";
+		renderMode.metadata["depth bias"] = metadata["light"]["bias"];
+		renderMode.metadata["renderMode"] = metadata["renderMode"];
+		// std::cout << this->getName() << ": " << renderMode.metadata["renderMode"] << std::endl;
+
+		if ( metadata["light"]["type"].as<std::string>() == "point" ) {
+			metadata["light"]["fov"] = 90.0f;
+			renderMode.metadata["subpasses"] = 6;
+		}
+		if ( metadata["light"]["fov"].is<float>() ) {
+			camera.setFov( metadata["light"]["fov"].as<float>() );
+		}
+		camera.updateView();
+		camera.updateProjection();
+		
+		std::string name = "RT:" + std::to_string((int) this->getUid());
+		uf::renderer::addRenderMode( &renderMode, name );
+		renderMode.blitter.process = false;
+		auto& cameraSize = camera.getSize();
+		renderMode.width = cameraSize.x;
+		renderMode.height = cameraSize.y;
+
+	}
+
+}
+void ext::LightBehavior::tick( uf::Object& self ) {
+	auto& metadata = this->getComponent<uf::Serializer>();
+	if ( this->hasComponent<uf::renderer::RenderTargetRenderMode>() ) {
+		auto& renderMode = this->getComponent<uf::renderer::RenderTargetRenderMode>();
+		renderMode.setTarget("");
+	}
+	
+	auto& transform = this->getComponent<pod::Transform<>>();
+	auto& parent = this->getParent();
+	auto& parentMetadata = parent.getComponent<uf::Serializer>();
+	auto& parentTransform = parent.getComponent<pod::Transform<>>();
+	// copy from our parent
+//	if ( parentMetadata["system"]["name"] == "Light" ) {
+	if ( metadata["light"]["bound"].as<bool>() ) {
+		metadata["light"] = parentMetadata["light"];
+		metadata["light"]["bound"] = true;
+		if ( metadata["light"]["static"].as<bool>() ) {
+			auto flatten = uf::transform::flatten( parentTransform );
+			transform.position = flatten.position;
+		}
+	} else {
+		// light fade action
+		if ( ext::json::isObject( metadata["light"]["fade"] ) ) {
+			if ( ext::json::isNull( metadata["light"]["backup"]["power"] ) ) {
+				metadata["light"]["backup"]["power"] = metadata["light"]["power"];
+			}
+			if ( ext::json::isNull( metadata["light"]["backup"]["color"] ) ) {
+				metadata["light"]["backup"]["color"] = metadata["light"]["color"];
+			}
+			// fade towards
+			int direction = metadata["light"]["fade"]["increment"].as<bool>() ? 1 : -1;
+			metadata["light"]["fade"]["timer"] = metadata["light"]["fade"]["timer"].as<float>() + metadata["light"]["fade"]["rate"].as<float>() * uf::physics::time::delta * direction;
+
+			// 0 .. delta .. 1 .. (1 + timeout * 0.5)
+			if ( direction == 1 && metadata["light"]["fade"]["timer"].as<float>() >= 0.5f * metadata["light"]["fade"]["timeout"].as<float>() + 1.0f ) {
+				metadata["light"]["fade"]["increment"] = false;
+			} else if ( direction == -1 && metadata["light"]["fade"]["timer"].as<float>() <= -0.5f * metadata["light"]["fade"]["timeout"].as<float>() ) {
+				metadata["light"]["fade"]["increment"] = true;
+			}
+			{
+				float delta = metadata["light"]["fade"]["timer"].as<float>();
+				delta = std::clamp( delta, 0.f, 1.f );
+				if ( metadata["light"]["fade"]["power"].is<double>() ) {
+					metadata["light"]["power"] = uf::math::lerp( metadata["light"]["backup"]["power"].as<float>(), metadata["light"]["fade"]["power"].as<float>(), delta );
+				}
+				if ( ext::json::isArray( metadata["light"]["fade"]["color"] ) ) {
+					pod::Vector3f fadeColor; {
+						fadeColor.x = metadata["light"]["fade"]["color"][0].as<float>();
+						fadeColor.y = metadata["light"]["fade"]["color"][1].as<float>();
+						fadeColor.z = metadata["light"]["fade"]["color"][2].as<float>();
+					}
+					pod::Vector3f origColor; {
+						origColor.x = metadata["light"]["backup"]["color"][0].as<float>();
+						origColor.y = metadata["light"]["backup"]["color"][1].as<float>();
+						origColor.z = metadata["light"]["backup"]["color"][2].as<float>();
+					}
+					pod::Vector3f color = uf::vector::lerp( origColor, fadeColor, delta );
+
+					metadata["light"]["color"][0] = color[0];
+					metadata["light"]["color"][1] = color[1];
+					metadata["light"]["color"][2] = color[2];
+				}
+			}
+		}
+		// light flicker action
+		if ( ext::json::isObject( metadata["light"]["flicker"] ) ) {
+			float r = (rand() % 100) / 100.0;
+			float rate = metadata["light"]["flicker"]["rate"].as<float>();
+			if ( ext::json::isNull( metadata["light"]["backup"]["power"] ) ) {
+				metadata["light"]["backup"]["power"] = metadata["light"]["power"];
+			}
+			metadata["light"]["flicker"]["timer"] = metadata["light"]["flicker"]["timer"].as<float>() + uf::physics::time::delta;
+			if ( metadata["light"]["flicker"]["timer"].as<float>() >= metadata["light"]["flicker"]["timeout"].as<float>() ) {
+				metadata["light"]["flicker"]["timer"] = 0;
+				metadata["light"]["power"] = (r > rate) ? metadata["light"]["flicker"]["power"].as<float>() : metadata["light"]["backup"]["power"].as<float>();
+			}
+		}
+	}
+
+	// skip if we're handling the camera view matrix position ourselves
+	if ( !metadata["light"]["external update"].as<bool>() ) {
+		auto& camera = this->getComponent<uf::Camera>();
+		// omni light
+		if ( metadata["light"]["shadows"].as<bool>() && metadata["light"]["type"].as<std::string>() == "point" ) {
+			auto transform = camera.getTransform();
+			std::vector<pod::Quaternion<>> rotations = {
+			/*
+				{0, 0, 0, 1},
+				{0, 0.707107, 0, -0.707107},
+				{0, 1, 0, 0},
+				{0, 0.707107, 0, 0.707107},
+				{-0.707107, 0, 0, -0.707107},
+				{0.707107,  0, 0, -0.707107},
+			*/
+				uf::quaternion::axisAngle( { 0, 1, 0 }, 0 * 1.57079633 ),
+				uf::quaternion::axisAngle( { 0, 1, 0 }, 1 * 1.57079633 ),
+				uf::quaternion::axisAngle( { 0, 1, 0 }, 2 * 1.57079633 ),
+				uf::quaternion::axisAngle( { 0, 1, 0 }, 3 * 1.57079633 ),
+				
+				uf::quaternion::axisAngle( { 1, 0, 0 }, 1 * 1.57079633 ),
+				uf::quaternion::axisAngle( { 1, 0, 0 }, 3 * 1.57079633 ),
+			};
+			for ( size_t i = 0; i < rotations.size(); ++i ) {
+				auto transform = camera.getTransform();
+				transform.orientation = rotations[i];
+				camera.setView( uf::matrix::inverse( uf::transform::model( transform, false ) ), i );
+			}
+		} else {
+			camera.updateView();
+		}
+	//	for ( std::size_t i = 0; i < 2; ++i ) camera.setView( uf::matrix::inverse( uf::transform::model( transform ) ), i );
+	}
+
+	// limit updating our shadow map
+	if ( this->hasComponent<uf::renderer::RenderTargetRenderMode>() ) {
+		bool execute = true;
+		// enable renderer every X seconds
+		if ( metadata["system"]["renderer"]["limiter"].is<float>() ) {
+			if ( metadata["system"]["renderer"]["timer"].as<float>() > metadata["system"]["renderer"]["limiter"].as<float>() ) {
+				metadata["system"]["renderer"]["timer"] = 0;
+				execute = true;
+			} else {
+				metadata["system"]["renderer"]["timer"] = metadata["system"]["renderer"]["timer"].as<float>() + uf::physics::time::delta;
+				execute = false;
+			}
+		} else if ( metadata["system"]["renderer"]["mode"].is<std::string>() ) {
+			std::string mode = metadata["system"]["renderer"]["mode"].as<std::string>();
+			// round robin, enable if it's the light's current turn
+			if ( mode == "round robin" ) {
+				if ( ::roundRobin.current < ::roundRobin.lights.size() ) execute = ::roundRobin.lights[::roundRobin.current] == this;
+			// render only if the light is used
+			} else if ( mode == "occlusion" ) {
+				execute = metadata["system"]["renderer"]["rendered"].as<bool>();
+			// light baking, but sadly re-bakes every time the command buffer is recorded
+			} else if ( mode == "once" ) {
+				execute = !metadata["system"]["renderer"]["rendered"].as<bool>();
+				metadata["system"]["renderer"]["rendered"] = true;
+			}
+		}
+		auto& renderMode = this->getComponent<uf::renderer::RenderTargetRenderMode>();
+		renderMode.execute = execute;
+	}
+}
+void ext::LightBehavior::render( uf::Object& self ){
+
+}
+void ext::LightBehavior::destroy( uf::Object& self ){
+	if ( this->hasComponent<uf::renderer::RenderTargetRenderMode>() ) {
+		auto& renderMode = this->getComponent<uf::renderer::RenderTargetRenderMode>();
+		uf::renderer::removeRenderMode( &renderMode, false );
+		this->deleteComponent<uf::renderer::RenderTargetRenderMode>();
+	}
+
+	::roundRobin.lights.erase(std::remove(::roundRobin.lights.begin(), ::roundRobin.lights.end(), this), ::roundRobin.lights.end());
+	::roundRobin.current = 0;
+}
+#undef this
\ No newline at end of file
diff --git a/ext/behaviors/light/behavior.h b/ext/behaviors/light/behavior.h
new file mode 100644
index 00000000..def94038
--- /dev/null
+++ b/ext/behaviors/light/behavior.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/ext/ext.h>
+#include <uf/engine/entity/entity.h>
+#include <uf/engine/scene/scene.h>
+
+namespace ext {
+	class EXT_API LightBehavior {
+	public:
+		static void attach( uf::Object& );
+		static void initialize( uf::Object& );
+		static void tick( uf::Object& );
+		static void render( uf::Object& );
+		static void destroy( uf::Object& );
+	};
+}
\ No newline at end of file
diff --git a/ext/behaviors/noise/behavior.cpp b/ext/behaviors/noise/behavior.cpp
new file mode 100644
index 00000000..3481bb3a
--- /dev/null
+++ b/ext/behaviors/noise/behavior.cpp
@@ -0,0 +1,123 @@
+#include "behavior.h"
+
+#include <uf/utils/graphic/mesh.h>
+#include <uf/utils/graphic/graphic.h>
+#include <uf/utils/camera/camera.h>
+#include <uf/utils/math/transform.h>
+#include <uf/utils/math/physics.h>
+#include <uf/utils/serialize/serializer.h>
+#include <uf/utils/math/collision.h>
+#include <uf/utils/thread/thread.h>
+#include <uf/utils/math/physics.h>
+
+#include <uf/utils/window/window.h>
+
+#include <uf/ext/openvr/openvr.h>
+
+#include <uf/utils/renderer/renderer.h>
+#include <uf/utils/noise/noise.h>
+
+UF_BEHAVIOR_REGISTER_CPP(ext::NoiseBehavior)
+#define this ((uf::Scene*) &self)
+void ext::NoiseBehavior::initialize( uf::Object& self ) {
+//	auto& image = this->getComponent<uf::Image>();
+	auto& noiseGenerator = this->getComponent<uf::PerlinNoise>();
+	auto& graphic = this->getComponent<uf::Graphic>();
+	auto mesh = this->getComponent<uf::Mesh>();
+	auto& texture = graphic.material.textures.emplace_back();
+	auto& metadata = this->getComponent<uf::Serializer>();
+	noiseGenerator.seed(rand());
+
+	float high = std::numeric_limits<float>::min();
+	float low = std::numeric_limits<float>::max();
+	float amplitude = metadata["amplitude"].is<float>() ? metadata["amplitude"].as<float>() : 1.5;
+	pod::Vector3ui size = uf::vector::decode(metadata["size"], pod::Vector3ui{512, 512, 1});
+	pod::Vector3d coefficients = uf::vector::decode(metadata["coefficients"], pod::Vector3d{3.0, 3.0, 3.0});
+
+	std::vector<uint8_t> pixels(size.x * size.y * size.z);
+	std::vector<float> perlins(size.x * size.y * size.z);
+#pragma omp parallel for
+	for ( size_t z = 0; z < size.z; ++z ) {
+	for ( size_t y = 0; y < size.y; ++y ) {
+	for ( size_t x = 0; x < size.x; ++x ) {
+		float nx = (float) x / (float) size.x;
+		float ny = (float) y / (float) size.y;
+		float nz = (float) z / (float) size.z;
+
+		float n = amplitude * noiseGenerator.noise(coefficients.x * nx, coefficients.y * ny, coefficients.z * nz);
+		high = std::max( high, n );
+		low = std::min( low, n );
+		perlins[x + y * size.x + z * size.x * size.y] = n;
+	}
+	}
+	}
+	for ( size_t i = 0; i < perlins.size(); ++i ) {
+		float n = perlins[i];
+		n = n - floor(n);
+		float normalized = (n - low) / (high - low);
+		pixels[i] = static_cast<uint8_t>(floor(normalized * 255));
+	}
+	texture.fromBuffers( (void*) pixels.data(), pixels.size(), uf::renderer::enums::Format::R8_UNORM, size.x, size.y, size.z, 1 );
+
+	mesh.vertices = {
+		{{-1*-0.5f, 0.0f, 0.0f}, {1.0f, 0.0f}, { 0.0f, 0.0f, -1.0f } },
+		{{-1*0.5f, 0.0f, 0.0f}, {0.0f, 0.0f}, { 0.0f, 0.0f, -1.0f } },
+		{{-1*0.5f, 1.0f, 0.0f}, {0.0f, 1.0f}, { 0.0f, 0.0f, -1.0f } },
+		{{-1*0.5f, 1.0f, 0.0f}, {0.0f, 1.0f}, { 0.0f, 0.0f, -1.0f } },
+		{{-1*-0.5f, 1.0f, 0.0f}, {1.0f, 1.0f}, { 0.0f, 0.0f, -1.0f } },
+		{{-1*-0.5f, 0.0f, 0.0f}, {1.0f, 0.0f}, { 0.0f, 0.0f, -1.0f } },
+
+		{{-1*0.5f, 1.0f, 0.0f}, {0.0f, 1.0f}, { 0.0f, 0.0f, 1.0f } },
+		{{-1*0.5f, 0.0f, 0.0f}, {0.0f, 0.0f}, { 0.0f, 0.0f, 1.0f } },
+		{{-1*-0.5f, 0.0f, 0.0f}, {1.0f, 0.0f}, { 0.0f, 0.0f, 1.0f } },
+		{{-1*-0.5f, 0.0f, 0.0f}, {1.0f, 0.0f}, { 0.0f, 0.0f, 1.0f } },
+		{{-1*-0.5f, 1.0f, 0.0f}, {1.0f, 1.0f}, { 0.0f, 0.0f, 1.0f } },
+		{{-1*0.5f, 1.0f, 0.0f}, {0.0f, 1.0f}, { 0.0f, 0.0f, 1.0f } },
+	};
+	graphic.initialize();
+	graphic.initializeMesh( mesh );
+
+	this->callHook("entity:TextureUpdate.%UID%");
+
+	graphic.material.attachShader(uf::io::root+"/shaders/base/vert.spv", uf::renderer::enums::Shader::VERTEX);
+	graphic.material.attachShader(uf::io::root+"/shaders/noise/frag.spv", uf::renderer::enums::Shader::FRAGMENT);
+}
+void ext::NoiseBehavior::tick( uf::Object& self ) {
+	auto& metadata = this->getComponent<uf::Serializer>();
+	
+	float slice = metadata["slice"].as<float>();
+	slice += uf::physics::time::delta * metadata["speed"].as<float>();
+//	if ( slice >= metadata["size"][2].as<float>() ) slice = 0;
+	metadata["slice"] = slice;
+
+	if ( !this->hasComponent<uf::Graphic>() ) return;
+	auto& scene = uf::scene::getCurrentScene();
+	auto& graphic = this->getComponent<uf::Graphic>();
+	auto& transform = this->getComponent<pod::Transform<>>();
+	auto& controller = scene.getController();
+	auto& camera = controller.getComponent<uf::Camera>();
+	
+	if ( !graphic.initialized ) return;
+#if UF_USE_VULKAN
+	if ( !graphic.material.hasShader("fragment") ) return;
+
+	auto& shader = graphic.material.getShader("fragment");
+	auto& uniform = shader.getUniform("UBO");
+#if UF_UNIFORMS_UPDATE_WITH_JSON
+//	auto uniforms = shader.getUniformJson("UBO");
+	ext::json::Value uniforms;
+	uniforms["slice"] = slice;
+	shader.updateUniform("UBO", uniforms );
+#else
+	struct UniformDescriptor {
+		alignas(4) float slice = 0;
+	};
+	auto& uniforms = uniform.get<UniformDescriptor>();
+	uniforms.slice = slice;
+	shader.updateUniform( "UBO", uniform );
+#endif
+#endif
+}
+void ext::NoiseBehavior::render( uf::Object& self ) {}
+void ext::NoiseBehavior::destroy( uf::Object& self ) {}
+#undef this
\ No newline at end of file
diff --git a/ext/behaviors/noise/behavior.h b/ext/behaviors/noise/behavior.h
new file mode 100644
index 00000000..f6c9a3d7
--- /dev/null
+++ b/ext/behaviors/noise/behavior.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/ext/ext.h>
+#include <uf/engine/entity/entity.h>
+#include <uf/engine/scene/scene.h>
+
+namespace ext {
+	class EXT_API NoiseBehavior {
+	public:
+		static void attach( uf::Object& );
+		static void initialize( uf::Object& );
+		static void tick( uf::Object& );
+		static void render( uf::Object& );
+		static void destroy( uf::Object& );
+	};
+}
\ No newline at end of file
diff --git a/ext/behaviors/player/behavior.cpp b/ext/behaviors/player/behavior.cpp
new file mode 100644
index 00000000..91ad9590
--- /dev/null
+++ b/ext/behaviors/player/behavior.cpp
@@ -0,0 +1,882 @@
+#include "behavior.h"
+
+#include <uf/utils/hook/hook.h>
+#include <uf/utils/time/time.h>
+#include <uf/utils/serialize/serializer.h>
+#include <uf/utils/userdata/userdata.h>
+#include <uf/utils/window/window.h>
+#include <uf/utils/camera/camera.h>
+#include <uf/utils/audio/audio.h>
+#include <uf/ext/openvr/openvr.h>
+#include <uf/ext/gltf/graph.h>
+#include <uf/ext/bullet/bullet.h>
+#include <uf/utils/math/physics.h>
+
+#include <sstream>
+
+namespace {
+	uf::Serializer masterTableGet( const std::string& table ) {
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Serializer& mastertable = scene.getComponent<uf::Serializer>();
+		return mastertable["system"]["mastertable"][table];
+	}
+	uf::Serializer masterDataGet( const std::string& table, const std::string& key ) {
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Serializer& mastertable = scene.getComponent<uf::Serializer>();
+		return mastertable["system"]["mastertable"][table][key];
+	}
+	inline int64_t parseInt( const std::string& str ) {
+		return atoi(str.c_str());
+	}
+
+	inline std::string colorString( const std::string& hex ) {
+		return "%#" + hex + "%";
+	}
+}
+
+UF_BEHAVIOR_REGISTER_CPP(ext::PlayerBehavior)
+#define this (&self)
+void ext::PlayerBehavior::initialize( uf::Object& self ) {
+	auto& transform = this->getComponent<pod::Transform<>>();
+	auto& camera = this->getComponent<uf::Camera>();
+	camera.getTransform().reference = &transform;
+
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	/* Load Config */ {
+		struct {
+			int mode = 0;
+			struct {
+				pod::Vector2 lr, bt, nf;
+			} ortho;
+			struct {
+				pod::Math::num_t fov = 120;
+				pod::Vector2 size = {640, 480};
+				pod::Vector2 bounds = {0.5, 128.0};
+			} perspective;
+			pod::Vector3 offset = {0, 0, 0};
+			bool stereoscopic = true;
+		} settings;
+
+		uf::Camera& camera = this->getComponent<uf::Camera>();
+		settings.mode = metadata["camera"]["ortho"].as<bool>() ? -1 : 1;
+		settings.perspective.size.x = metadata["camera"]["settings"]["size"]["x"].as<double>();
+		settings.perspective.size.y = metadata["camera"]["settings"]["size"]["y"].as<double>();
+		camera.setSize(settings.perspective.size);
+		if ( settings.mode < 0 ) {
+			settings.ortho.lr.x 	= metadata["camera"]["settings"]["left"].as<double>();
+			settings.ortho.lr.y 	= metadata["camera"]["settings"]["right"].as<double>();
+			settings.ortho.bt.x 	= metadata["camera"]["settings"]["bottom"].as<double>();
+			settings.ortho.bt.y 	= metadata["camera"]["settings"]["top"].as<double>();
+			settings.ortho.nf.x 	= metadata["camera"]["settings"]["near"].as<double>();
+			settings.ortho.nf.y 	= metadata["camera"]["settings"]["far"].as<double>();
+
+			camera.ortho( settings.ortho.lr, settings.ortho.bt, settings.ortho.nf );
+		} else {
+			settings.perspective.fov 		= metadata["camera"]["settings"]["fov"].as<double>();
+			settings.perspective.bounds.x 	= metadata["camera"]["settings"]["clip"]["near"].as<double>();
+			settings.perspective.bounds.y 	= metadata["camera"]["settings"]["clip"]["far"].as<double>();
+
+			camera.setFov(settings.perspective.fov);
+			camera.setBounds(settings.perspective.bounds);
+		}
+		camera.setStereoscopic(true);
+
+		settings.offset.x = metadata["camera"]["offset"][0].as<double>();
+		settings.offset.y = metadata["camera"]["offset"][1].as<double>();
+		settings.offset.z = metadata["camera"]["offset"][2].as<double>();
+
+		pod::Transform<>& transform = camera.getTransform();
+		/* Transform initialization */ {
+			transform.position.x = metadata["camera"]["position"][0].as<double>();
+			transform.position.y = metadata["camera"]["position"][1].as<double>();
+			transform.position.z = metadata["camera"]["position"][2].as<double>();
+
+			transform.scale.x = metadata["camera"]["scale"][0].as<double>();
+			transform.scale.y = metadata["camera"]["scale"][1].as<double>();
+			transform.scale.z = metadata["camera"]["scale"][2].as<double>();
+		}
+
+		camera.setOffset(settings.offset);
+		camera.update(true);
+
+		// Update viewport
+		if ( metadata["camera"]["settings"]["size"]["auto"].as<bool>() )  {
+			this->addHook( "window:Resized", [&](ext::json::Value& json){
+				// Update persistent window sized (size stored to JSON file)
+				pod::Vector2ui size; {
+					size.x = json["window"]["size"]["x"].as<size_t>();
+					size.y = json["window"]["size"]["y"].as<size_t>();
+				}
+				/* Update camera's viewport */ {
+					uf::Camera& camera = this->getComponent<uf::Camera>();
+					camera.setSize({(pod::Math::num_t)size.x, (pod::Math::num_t)size.y});
+				}
+			} );
+		}
+	}
+
+	metadata["system"]["control"] = true;
+	
+	this->addHook( "window:Mouse.CursorVisibility", [&](ext::json::Value& json){
+		metadata["system"]["control"] = !json["state"].as<bool>();	
+	});
+
+	// Rotate Camera
+	this->addHook( "window:Mouse.Moved", [&](ext::json::Value& json){
+		// discard events sent by os, only trust client now
+		if ( !ext::json::isObject(json) ) return;
+		if ( json["invoker"] != "client" ) return;
+
+		pod::Vector2i delta = { json["mouse"]["delta"]["x"].as<int>(), json["mouse"]["delta"]["y"].as<int>() };
+		pod::Vector2i size  = { json["mouse"]["size"]["x"].as<int>(),  json["mouse"]["size"]["y"].as<int>() };
+		pod::Vector2 relta  = { (float) delta.x / size.x, (float) delta.y / size.y };
+		relta *= 2;
+		if ( delta.x == 0 && delta.y == 0 ) return;
+		if ( !metadata["system"]["control"].as<bool>() ) return;
+
+		bool updateCamera = false;
+		uf::Camera& camera = this->getComponent<uf::Camera>();
+		pod::Transform<>& transform = this->getComponent<pod::Transform<>>();
+		pod::Transform<>& cameraTransform = camera.getTransform();
+		auto& collider = this->getComponent<pod::Bullet>();
+		if ( delta.x != 0 ) {
+			double current, minima, maxima; {
+				current = !ext::json::isNull( metadata["camera"]["limit"]["current"][0] ) ? metadata["camera"]["limit"]["current"][0].as<double>() : NAN;
+				minima = !ext::json::isNull( metadata["camera"]["limit"]["minima"][0] ) ? metadata["camera"]["limit"]["minima"][0].as<double>() : NAN;
+				maxima = !ext::json::isNull( metadata["camera"]["limit"]["maxima"][0] ) ? metadata["camera"]["limit"]["maxima"][0].as<double>() : NAN;
+			}
+			if ( metadata["camera"]["invert"][0].as<bool>() ) relta.x *= -1;
+			current += relta.x;
+			if ( current != current || ( current < maxima && current > minima ) ) {
+				if ( collider.body && !collider.shared ) {
+				#if UF_USE_BULLET
+					ext::bullet::applyRotation( collider, transform.up, relta.x );
+				#endif
+				} else {
+					uf::transform::rotate( transform, transform.up, relta.x ), updateCamera = true;
+				}
+			} else current -= relta.x;
+
+			if ( !ext::json::isNull( metadata["camera"]["limit"]["current"][0] ) ) metadata["camera"]["limit"]["current"][0] = current;
+		}
+		if ( delta.y != 0 ) {
+			double current, minima, maxima; {
+				current = !ext::json::isNull( metadata["camera"]["limit"]["current"][1] ) ? metadata["camera"]["limit"]["current"][1].as<double>() : NAN;
+				minima = !ext::json::isNull( metadata["camera"]["limit"]["minima"][1] ) ? metadata["camera"]["limit"]["minima"][1].as<double>() : NAN;
+				maxima = !ext::json::isNull( metadata["camera"]["limit"]["maxima"][1] ) ? metadata["camera"]["limit"]["maxima"][1].as<double>() : NAN;
+			}
+			if ( metadata["camera"]["invert"][1].as<bool>() ) relta.y *= -1;
+			current += relta.y;
+			if ( current != current || ( current < maxima && current > minima ) ) {
+			//	if ( collider.body && !collider.shared ) {
+			//		ext::bullet::applyRotation( collider, cameraTransform.right, relta.y );
+			//	} else {
+					uf::transform::rotate( cameraTransform, cameraTransform.right, relta.y );
+			//	}
+				updateCamera = true;
+			} else current -= relta.y;
+			if ( !ext::json::isNull( metadata["camera"]["limit"]["current"][1] ) ) metadata["camera"]["limit"]["current"][1] = current;
+		}
+		if ( updateCamera ) {
+			camera.updateView();
+		}
+	});
+
+	this->addHook( ":Update.%UID%", [&](ext::json::Value& json){
+	//	for ( auto& member : json[""]["transients"] ) {
+		ext::json::forEach(metadata[""]["transients"], [&](ext::json::Value& member){
+			if ( member["type"] != "player" ) return;
+			std::string id = member["id"].as<std::string>();
+			metadata[""]["transients"][id]["hp"] = member["hp"];
+			metadata[""]["transients"][id]["mp"] = member["mp"];
+		});
+	});
+
+	// handle after battles and establishes cooldowns
+	this->addHook( "world:Battle.End.%UID%", [&](ext::json::Value& json){
+		// update
+		{
+			uf::Serializer payload;
+			payload[""]["transients"] = json["battle"]["transients"];
+			this->callHook( ":Update.%UID%", payload );
+		}
+		
+		metadata["system"].erase("battle");
+		metadata["system"]["cooldown"] = uf::physics::time::current + 5;
+	});
+	
+	// detect collision against transients, engage in battle
+	this->addHook( "world:Collision.%UID%", [&](ext::json::Value& json){
+		if ( metadata["system"]["cooldown"].as<float>() > uf::physics::time::current ) return;
+		if ( !metadata["system"]["control"].as<bool>() ) return;
+		
+		std::string state = metadata["system"]["state"].as<std::string>();
+		if ( state != "" && state != "null" ) return;
+
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Entity* entity = scene.findByUid(json["entity"].as<size_t>());
+
+		if ( !entity ) return;
+
+		uf::Serializer& pMetadata = entity->getComponent<uf::Serializer>();
+
+		std::string onCollision = pMetadata["system"]["onCollision"].as<std::string>();
+
+		if ( onCollision == "battle" ) {
+			uf::Serializer payload;
+			payload["battle"]["enemy"] = pMetadata[""];
+			payload["battle"]["enemy"]["uid"] = json["entity"].as<size_t>();
+			payload["battle"]["player"] = metadata[""];
+			payload["battle"]["player"]["uid"] = this->getUid();
+			payload["battle"]["music"] = pMetadata["music"];
+			
+			this->callHook("world:Battle.Start", payload);
+		} else if ( onCollision == "npc" ) {
+			if ( !uf::Window::isKeyPressed("E") ) return;
+			uf::Serializer payload;
+			payload["dialogue"] = pMetadata["dialogue"];
+			payload["uid"] = json["entity"].as<size_t>();
+			this->callHook("menu:Dialogue.Start", payload);
+		}
+	//	metadata["system"]["cooldown"] = uf::physics::time::current + 5;
+		metadata["system"]["control"] = false;
+		metadata["system"]["menu"] = onCollision;
+	});
+	this->addHook( "world:Battle.End", [&](ext::json::Value& json){
+		metadata["system"]["menu"] = "";
+		metadata["system"]["cooldown"] = uf::physics::time::current + 5;
+
+		// update
+		{
+			uf::Serializer payload;
+			payload[""]["transients"] = json["battle"]["transients"];
+			this->callHook( ":Update.%UID%", payload );
+		}
+	});
+	this->addHook( "menu:Dialogue.End", [&](ext::json::Value& json){
+		metadata["system"]["menu"] = "";
+		metadata["system"]["cooldown"] = uf::physics::time::current + 1;
+	});
+
+	// Discord Integration
+	this->addHook( "discord.Activity.Update.%UID%", [&](ext::json::Value& json){
+		std::string leaderId = metadata[""]["party"][0].as<std::string>();
+		uf::Serializer cardData = masterDataGet("Card", leaderId);
+		uf::Serializer charaData = masterDataGet("Chara", cardData["character_id"].as<std::string>());
+		std::string leader = charaData["name"].as<std::string>();
+
+		uf::Serializer payload = json;
+		payload["details"] = "Leader: " + leader;
+		uf::hooks.call( "discord:Activity.Update", payload );
+	});
+	this->queueHook("discord.Activity.Update.%UID%", ext::json::null(), 1.0);
+}
+void ext::PlayerBehavior::tick( uf::Object& self ) {
+	uf::Camera& camera = this->getComponent<uf::Camera>();
+	pod::Transform<>& transform = this->getComponent<pod::Transform<>>();
+	pod::Physics& physics = this->getComponent<pod::Physics>();
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	uf::Scene& scene = uf::scene::getCurrentScene();
+
+	struct {
+		bool forward;
+		bool backwards;
+		bool left;
+		bool right;
+	
+		bool lookLeft;
+		bool lookRight;
+		bool running;
+		bool walk;
+		bool jump;
+		bool crouch;
+		bool paused;
+		bool vee;
+	} keys = {
+	#if UF_ENV_DREAMCAST
+		.forward = uf::Window::isKeyPressed("Up"),
+		.backwards = uf::Window::isKeyPressed("Down"),
+		.left = uf::Window::isKeyPressed("Left"),
+		.right = uf::Window::isKeyPressed("Right"),
+		.lookLeft = uf::Window::isKeyPressed("C"),
+		.lookRight = uf::Window::isKeyPressed("X"),
+		.running = uf::Window::isKeyPressed("Y"),
+		.walk = uf::Window::isKeyPressed("_"),
+		.jump = uf::Window::isKeyPressed("A"),
+		.crouch = uf::Window::isKeyPressed("X"),
+		.paused = uf::Window::isKeyPressed("Start"),
+		.vee = uf::Window::isKeyPressed("B"),
+	#else
+		.forward = uf::Window::isKeyPressed("W"),
+		.backwards = uf::Window::isKeyPressed("S"),
+		.left = uf::Window::isKeyPressed("A"),
+		.right = uf::Window::isKeyPressed("D"),
+		.lookLeft = uf::Window::isKeyPressed("Left"),
+		.lookRight = uf::Window::isKeyPressed("Right"),
+		.running = uf::Window::isKeyPressed("LShift"),
+		.walk = uf::Window::isKeyPressed("LAlt"),
+		.jump = uf::Window::isKeyPressed(" "),
+		.crouch = uf::Window::isKeyPressed("LControl"),
+		.paused = uf::Window::isKeyPressed("Escape"),
+		.vee = uf::Window::isKeyPressed("V"),
+	#endif
+	};
+
+#if UF_USE_OPENVR
+	if ( ext::openvr::context ) {
+		if ( ext::openvr::controllerState( vr::Controller_Hand::Hand_Right, "dpadUp" )["state"].as<bool>() ) keys.forward = true;
+		if ( ext::openvr::controllerState( vr::Controller_Hand::Hand_Right, "dpadDown" )["state"].as<bool>() ) keys.backwards = true;
+		if ( ext::openvr::controllerState( vr::Controller_Hand::Hand_Right, "dpadLeft" )["state"].as<bool>() ) keys.lookLeft = true; // keys.left = true;
+		if ( ext::openvr::controllerState( vr::Controller_Hand::Hand_Right, "dpadRight" )["state"].as<bool>() ) keys.lookRight = true; // keys.right = true;
+		if ( ext::openvr::controllerState( vr::Controller_Hand::Hand_Right, "thumbclick" )["state"].as<bool>() ) keys.running = true;
+		if ( ext::openvr::controllerState( vr::Controller_Hand::Hand_Right, "a" )["state"].as<bool>() ) keys.jump = true;
+
+		if ( ext::openvr::controllerState( vr::Controller_Hand::Hand_Left, "dpadUp" )["state"].as<bool>() ) keys.forward = true;
+		if ( ext::openvr::controllerState( vr::Controller_Hand::Hand_Left, "dpadDown" )["state"].as<bool>() ) keys.backwards = true;
+		if ( ext::openvr::controllerState( vr::Controller_Hand::Hand_Left, "dpadLeft" )["state"].as<bool>() ) keys.lookLeft = true;
+		if ( ext::openvr::controllerState( vr::Controller_Hand::Hand_Left, "dpadRight" )["state"].as<bool>() ) keys.lookRight = true;
+		if ( ext::openvr::controllerState( vr::Controller_Hand::Hand_Left, "thumbclick" )["state"].as<bool>() ) keys.crouch = true, keys.walk = true;
+		if ( ext::openvr::controllerState( vr::Controller_Hand::Hand_Left, "a" )["state"].as<bool>() ) keys.paused = true;
+	}
+#endif
+	struct {
+		bool updateCamera = true;
+		bool deltaCrouch = false;
+		bool walking = false;
+		bool floored = true;
+		bool impulse = true;
+		bool noclipped = false;
+		std::string menu = "";
+		std::string targetAnimation = "";
+	} stats;
+
+	stats.floored = fabs(physics.linear.velocity.y) < 0.01f;
+	stats.menu = metadata["system"]["menu"].as<std::string>();
+	stats.impulse = metadata["system"]["physics"]["impulse"].as<bool>();
+	stats.noclipped = metadata["system"]["noclipped"].as<bool>();
+	struct {
+		float move = 4;
+		float walk = 1;
+		float run = 8;
+		float rotate = uf::physics::time::delta;
+		float limitSquared = 4*4;
+	} speed; {
+		speed.rotate *= metadata["system"]["physics"]["rotate"].as<float>();
+		speed.move = metadata["system"]["physics"]["move"].as<float>();
+		speed.run = metadata["system"]["physics"]["run"].as<float>() / metadata["system"]["physics"]["move"].as<float>();
+		speed.walk = metadata["system"]["physics"]["walk"].as<float>() / metadata["system"]["physics"]["move"].as<float>();
+	}
+	if ( !metadata["system"]["physics"]["collision"].as<bool>() ) {
+		stats.impulse = true;
+	}
+	if ( keys.running ) speed.move *= speed.run;
+	else if ( keys.walk ) speed.move *= speed.walk;
+	speed.limitSquared = speed.move * speed.move;
+
+	uf::Object* menu = (uf::Object*) this->getRootParent().findByName("Gui: Menu");
+	if ( !menu ) stats.menu = "";
+	// make assumptions
+	if ( stats.menu == "" && keys.paused ) {
+		stats.menu = "paused";
+		metadata["system"]["control"] = false;
+		uf::hooks.call("menu:Pause");
+	}
+	else if ( !metadata["system"]["control"].as<bool>() ) {
+		stats.menu = "menu";
+	} else if ( stats.menu == "" ) {
+		metadata["system"]["control"] = true;
+	} else {
+		metadata["system"]["control"] = false;
+	}
+	metadata["system"]["menu"] = stats.menu;
+	auto& collider = this->getComponent<pod::Bullet>();
+	if ( metadata["system"]["control"].as<bool>() ) {	
+		{
+			TIMER(0.25, keys.vee && ) {
+				bool state = !metadata["system"]["noclipped"].as<bool>();
+				metadata["system"]["noclipped"] = state;
+				
+				std::cout << "Toggling noclip: " << transform.position.x << ", " << transform.position.y << ", " << transform.position.z << std::endl;
+				if ( state ) {
+					std::cout << "Enabled noclip" << std::endl;
+				#if UF_USE_BULLET
+					if ( collider.body ) {
+						collider.body->setGravity(btVector3(0,0.0,0));
+						collider.body->setCollisionFlags(collider.body->getCollisionFlags() | btCollisionObject::CF_NO_CONTACT_RESPONSE);
+						collider.body->setActivationState(DISABLE_SIMULATION);
+					}
+				#endif
+				} else {
+					std::cout << "Disabled noclip" << std::endl;
+				#if UF_USE_BULLET
+					if ( collider.body ) {
+						collider.body->setGravity(btVector3(0,-9.81,0));
+						collider.body->setCollisionFlags(collider.body->getCollisionFlags() & ~btCollisionObject::CF_NO_CONTACT_RESPONSE);
+						collider.body->setActivationState(DISABLE_DEACTIVATION);
+					}
+				#endif
+				}
+				stats.noclipped = state;
+			}
+		}
+
+		if ( stats.floored ) {
+			pod::Transform<> translator = transform;
+		#if UF_USE_OPENVR
+			if ( ext::openvr::context ) {
+				bool useController = true;
+				translator.orientation = uf::quaternion::multiply( transform.orientation * pod::Vector4f{1,1,1,1}, useController ? (ext::openvr::controllerQuaternion( vr::Controller_Hand::Hand_Right ) * pod::Vector4f{1,1,1,1}) : ext::openvr::hmdQuaternion() );
+				translator = uf::transform::reorient( translator );
+				
+				translator.forward *= { 1, 0, 1 };
+				translator.right *= { 1, 0, 1 };
+				
+				translator.forward = uf::vector::normalize( translator.forward );
+				translator.right = uf::vector::normalize( translator.right );
+			}
+		#endif
+			pod::Vector3f queued = {};
+			if ( keys.forward || keys.backwards ) {
+				int polarity = keys.forward ? 1 : -1;
+				float mag = uf::vector::magnitude(physics.linear.velocity * pod::Vector3{1, 0, 1});
+				if ( mag < speed.limitSquared ) {
+				//	physics.linear.velocity += translator.forward * speed.move * polarity;
+				//	mag = uf::vector::magnitude(physics.linear.velocity);
+					mag = uf::vector::magnitude(physics.linear.velocity + translator.forward * speed.move * polarity);
+				} else mag = speed.limitSquared;
+				pod::Vector3 correction = translator.forward * sqrt(mag) * polarity;
+				
+				if ( collider.body && !collider.shared ) {
+				//	physics.linear.velocity.x += correction.x;
+				//	physics.linear.velocity.z += correction.z;
+				//	ext::bullet::move( collider, physics.linear.velocity );
+					queued += correction;
+				} else {
+					if ( stats.impulse && stats.noclipped ) {
+						physics.linear.velocity.x = correction.x;
+						physics.linear.velocity.z = correction.z;
+					} else {
+						correction *= uf::physics::time::delta;
+						transform.position.x += correction.x;
+						transform.position.z += correction.z;
+					}
+				}
+				stats.updateCamera = (stats.walking = true);
+			}
+			if ( keys.left || keys.right ) {
+				int polarity = keys.right ? 1 : -1;
+				float mag = uf::vector::magnitude(physics.linear.velocity * pod::Vector3{1, 0, 1});
+				if ( mag < speed.limitSquared ) {
+				//	physics.linear.velocity += translator.right * speed.move * polarity;
+				//	mag = uf::vector::magnitude(physics.linear.velocity);
+					mag = uf::vector::magnitude(physics.linear.velocity + translator.right * speed.move * polarity);
+				} else mag = speed.limitSquared;
+				pod::Vector3 correction = translator.right * sqrt(mag) * polarity;
+				
+				if ( collider.body && !collider.shared ) {
+				//	physics.linear.velocity.x += correction.x;
+				//	physics.linear.velocity.z += correction.z;
+				//	ext::bullet::move( collider, physics.linear.velocity );
+					queued += correction;
+				} else {
+					if ( stats.impulse && stats.noclipped ) {
+						physics.linear.velocity.x = correction.x;
+						physics.linear.velocity.z = correction.z;
+					} else {
+						correction *= uf::physics::time::delta;
+						transform.position.x += correction.x;
+						transform.position.z += correction.z;
+					}
+				}
+				stats.updateCamera = (stats.walking = true);
+			}
+			if ( keys.left || keys.right || keys.forward || keys.backwards ) {
+				if ( collider.body && !collider.shared ) {
+					physics.linear.velocity.x = queued.x;
+					physics.linear.velocity.z = queued.z;
+				#if UF_USE_BULLET
+					ext::bullet::move( collider, physics.linear.velocity );
+				#endif
+				}
+			}
+			if ( !keys.forward && !keys.backwards && !keys.left && !keys.right ) {
+				if ( collider.body && !collider.shared ) {
+					physics.linear.velocity.x = 0;
+					physics.linear.velocity.z = 0;
+				#if UF_USE_BULLET
+					ext::bullet::move( collider, physics.linear.velocity );
+				#endif
+				}
+			}
+			if ( keys.jump ) {
+				if ( collider.body && !collider.shared ) {
+					pod::Vector3f yump = uf::vector::decode(metadata["system"]["physics"]["jump"], pod::Vector3f{});
+					if ( fabs(yump.x) > 0.001f ) physics.linear.velocity.x = yump.x;
+					if ( fabs(yump.y) > 0.001f ) physics.linear.velocity.y = yump.y;
+					if ( fabs(yump.z) > 0.001f ) physics.linear.velocity.z = yump.z;
+				#if UF_USE_BULLET
+					ext::bullet::move( collider, physics.linear.velocity );
+				#endif
+				} else {
+					if ( metadata["system"]["physics"]["jump"][0].as<float>() != 0 ) transform.position.x += metadata["system"]["physics"]["jump"][0].as<float>() * uf::physics::time::delta;
+					if ( metadata["system"]["physics"]["jump"][1].as<float>() != 0 ) transform.position.y += metadata["system"]["physics"]["jump"][1].as<float>() * uf::physics::time::delta;
+					if ( metadata["system"]["physics"]["jump"][2].as<float>() != 0 ) transform.position.z += metadata["system"]["physics"]["jump"][2].as<float>() * uf::physics::time::delta;
+				}
+			}
+		}
+
+		if ( keys.lookLeft ) {
+			if ( collider.body && !collider.shared ) {
+			#if UF_USE_BULLET
+				ext::bullet::applyRotation( collider, transform.up, -speed.rotate );
+			#endif
+			} else {
+				uf::transform::rotate( transform, transform.up, -speed.rotate ), stats.updateCamera = true;
+			}
+			stats.updateCamera = true;
+		}
+		if ( keys.lookRight ) {
+			if ( collider.body && !collider.shared ) {
+			#if UF_USE_BULLET
+				ext::bullet::applyRotation( collider, transform.up, speed.rotate );
+			#endif
+			} else {
+				uf::transform::rotate( transform, transform.up, speed.rotate ), stats.updateCamera = true;
+			}
+			stats.updateCamera = true;
+		}
+		if ( keys.crouch ) {
+			if ( stats.noclipped ) {
+				if ( collider.body && !collider.shared ) {
+					pod::Vector3f yump = uf::vector::decode(metadata["system"]["physics"]["jump"], pod::Vector3f{});
+					if ( fabs(yump.x) > 0.001f ) physics.linear.velocity.x = -yump.x;
+					if ( fabs(yump.y) > 0.001f ) physics.linear.velocity.y = -yump.y;
+					if ( fabs(yump.z) > 0.001f ) physics.linear.velocity.z = -yump.z;
+				#if UF_USE_BULLET
+					ext::bullet::move( collider, physics.linear.velocity );
+				#endif
+				}
+			} else {
+				if ( !metadata["system"]["physics"]["collision"].as<bool>() ) {
+					if ( metadata["system"]["physics"]["jump"][0].as<float>() != 0 ) transform.position.x -= metadata["system"]["physics"]["jump"][0].as<float>() * uf::physics::time::delta;
+					if ( metadata["system"]["physics"]["jump"][1].as<float>() != 0 ) transform.position.y -= metadata["system"]["physics"]["jump"][1].as<float>() * uf::physics::time::delta;
+					if ( metadata["system"]["physics"]["jump"][2].as<float>() != 0 ) transform.position.z -= metadata["system"]["physics"]["jump"][2].as<float>() * uf::physics::time::delta;
+				} else {
+					if ( !metadata["system"]["crouching"].as<bool>() )  stats.deltaCrouch = true;
+					metadata["system"]["crouching"] = true;
+				}
+			}
+		} else {
+			if ( metadata["system"]["crouching"].as<bool>() ) stats.deltaCrouch = true;
+			metadata["system"]["crouching"] = false;
+		}
+	}
+	if ( stats.noclipped && !keys.forward && !keys.backwards && !keys.left && !keys.right && !keys.jump && !keys.crouch ) {
+		if ( collider.body && !collider.shared ) {
+			physics.linear.velocity = {};
+		#if UF_USE_BULLET
+			ext::bullet::move( collider, physics.linear.velocity );
+		#endif
+		}
+	}
+	if ( stats.deltaCrouch ) {
+		float delta = metadata["system"]["physics"]["crouch"].as<float>();
+		if ( metadata["system"]["crouching"].as<bool>() ) camera.getTransform().position.y -= delta;
+		else camera.getTransform().position.y += delta;
+		stats.updateCamera = true;
+	}
+
+	if ( stats.floored ) {
+		if ( stats.walking ) {
+			auto& emitter = this->getComponent<uf::MappedSoundEmitter>();
+			int cycle = rand() % metadata["audio"]["footstep"]["list"].size();
+			std::string filename = metadata["audio"]["footstep"]["list"][cycle].as<std::string>();
+			uf::Audio& footstep = emitter.add(filename);
+
+			bool playing = false;
+			for ( uint i = 0; i < metadata["audio"]["footstep"]["list"].size(); ++i ) {
+				uf::Audio& audio = emitter.add(metadata["audio"]["footstep"]["list"][i].as<std::string>());
+				if ( audio.playing() ) playing = true;
+			}
+			if ( !playing ) {
+				footstep.play();
+				footstep.setVolume(metadata["audio"]["footstep"]["volume"].as<float>());
+				footstep.setPosition( transform.position );
+
+				// [0, 1]
+				float modulation = (rand() % 100) / 100.0;
+				// [0, 0.1]
+				modulation *= 0.1f;
+				// [-0.05, 0.05]
+				modulation -= 0.05f;
+				if ( keys.running ) modulation += 0.5f;
+				footstep.setPitch(1 + modulation);
+			}
+			// set animation to walk
+			stats.targetAnimation = "walk";
+		} else if ( !keys.jump ) {
+			stats.targetAnimation = "idle_wank";
+		}
+	}
+#if 0
+	{
+		TIMER(0.25, keys.vee && ) {
+			if ( ext::json::isNull( metadata["system"]["physics"]["backup"]["collision"] ) )
+				metadata["system"]["physics"]["backup"]["collision"] = metadata["system"]["physics"]["collision"];
+			if ( !metadata["system"]["physics"]["collision"].as<bool>() ) {
+				metadata["system"]["physics"]["collision"] = metadata["system"]["physics"]["backup"]["collision"];
+			} else {
+				metadata["system"]["physics"]["collision"] = 0;
+			}
+			
+			std::cout << "Toggling noclip: " << transform.position.x << ", " << transform.position.y << ", " << transform.position.z << std::endl;
+			std::cout << metadata.dump(1, '\t') << std::endl;
+
+		//	metadata["system"]["physics"]["collision"] = !metadata["system"]["physics"]["collision"].as<bool>();
+			physics.linear.velocity = {0,0,0};
+		}
+	}
+	
+
+	if ( ext::json::isObject( metadata["system"]["physics"]["clamp"] ) ) {
+		if ( ext::json::isArray( metadata["system"]["physics"]["clamp"]["x"] ) ) {
+			transform.position.x = std::clamp( transform.position.x, metadata["system"]["physics"]["clamp"]["x"][0].as<float>(), metadata["system"]["physics"]["clamp"]["x"][1].as<float>() );
+		}
+		if ( ext::json::isArray( metadata["system"]["physics"]["clamp"]["y"] ) ) {
+			auto previous = transform.position.y;
+			transform.position.y = std::clamp( transform.position.y, metadata["system"]["physics"]["clamp"]["y"][0].as<float>(), metadata["system"]["physics"]["clamp"]["y"][1].as<float>() );
+			if ( transform.position.y > previous ) {
+				physics.linear.velocity.y = 0;
+				stats.floored = true;
+			}
+		}
+		if ( ext::json::isArray( metadata["system"]["physics"]["clamp"]["z"] ) ) {
+			transform.position.z = std::clamp( transform.position.z, metadata["system"]["physics"]["clamp"]["z"][0].as<float>(), metadata["system"]["physics"]["clamp"]["z"][1].as<float>() );
+		}
+	}
+	
+	if ( metadata["system"]["control"].as<bool>() ) {	
+		if ( stats.floored ) {
+			pod::Transform<> translator = transform;
+			if ( ext::openvr::context ) {
+				bool useController = true;
+				translator.orientation = uf::quaternion::multiply( transform.orientation * pod::Vector4f{1,1,1,1}, useController ? (ext::openvr::controllerQuaternion( vr::Controller_Hand::Hand_Right ) * pod::Vector4f{1,1,1,1}) : ext::openvr::hmdQuaternion() );
+				translator = uf::transform::reorient( translator );
+				
+				translator.forward *= { 1, 0, 1 };
+				translator.right *= { 1, 0, 1 };
+				
+				translator.forward = uf::vector::normalize( translator.forward );
+				translator.right = uf::vector::normalize( translator.right );
+			}
+			if ( keys.forward || keys.backwards ) {
+				int polarity = keys.forward ? 1 : -1;
+				float mag = uf::vector::magnitude(physics.linear.velocity * pod::Vector3{1, 0, 1});
+				if ( mag < speed.limitSquared ) {
+					physics.linear.velocity += translator.forward * speed.move * polarity;
+					mag = uf::vector::magnitude(physics.linear.velocity);
+				} else mag = speed.limitSquared;
+				pod::Vector3 correction = translator.forward * sqrt(mag) * polarity;
+				if ( stats.impulse ) {
+					physics.linear.velocity.x = correction.x;
+					physics.linear.velocity.z = correction.z;
+				} else {
+					correction *= uf::physics::time::delta;
+					transform.position.x += correction.x;
+					transform.position.z += correction.z;
+				}
+				stats.updateCamera = (stats.walking = true);
+			}
+			if ( keys.left || keys.right ) {
+				int polarity = keys.right ? 1 : -1;
+				float mag = uf::vector::magnitude(physics.linear.velocity * pod::Vector3{1, 0, 1});
+				if ( mag < speed.limitSquared ) {
+					physics.linear.velocity += translator.right * speed.move * polarity;
+					mag = uf::vector::magnitude(physics.linear.velocity);
+				} else mag = speed.limitSquared;
+				pod::Vector3 correction = translator.right * sqrt(mag) * polarity;
+				if ( stats.impulse ) {
+					physics.linear.velocity.x = correction.x;
+					physics.linear.velocity.z = correction.z;
+				} else {
+					correction *= uf::physics::time::delta;
+					transform.position.x += correction.x;
+					transform.position.z += correction.z;
+				}
+				stats.updateCamera = (stats.walking = true);
+			}
+			if ( keys.jump ) {
+				if ( !metadata["system"]["physics"]["collision"].as<bool>() ) {
+					if ( metadata["system"]["physics"]["jump"][0].as<float>() != 0 ) transform.position.x += metadata["system"]["physics"]["jump"][0].as<float>() * uf::physics::time::delta;
+					if ( metadata["system"]["physics"]["jump"][1].as<float>() != 0 ) transform.position.y += metadata["system"]["physics"]["jump"][1].as<float>() * uf::physics::time::delta;
+					if ( metadata["system"]["physics"]["jump"][2].as<float>() != 0 ) transform.position.z += metadata["system"]["physics"]["jump"][2].as<float>() * uf::physics::time::delta;
+				} else {
+					if ( metadata["system"]["physics"]["jump"][0].as<float>() != 0 ) physics.linear.velocity.x = metadata["system"]["physics"]["jump"][0].as<float>();
+					if ( metadata["system"]["physics"]["jump"][1].as<float>() != 0 ) physics.linear.velocity.y = metadata["system"]["physics"]["jump"][1].as<float>();
+					if ( metadata["system"]["physics"]["jump"][2].as<float>() != 0 ) physics.linear.velocity.z = metadata["system"]["physics"]["jump"][2].as<float>();
+				}
+			}
+		}
+
+		if ( keys.lookLeft ) {
+			uf::transform::rotate( transform, transform.up, -speed.rotate ), stats.updateCamera = true;
+		}
+		if ( keys.lookRight ) {
+			uf::transform::rotate( transform, transform.up, speed.rotate ), stats.updateCamera = true;
+		}
+		
+		if ( keys.crouch ) {
+			if ( !metadata["system"]["physics"]["collision"].as<bool>() ) {
+				if ( metadata["system"]["physics"]["jump"][0].as<float>() != 0 ) transform.position.x -= metadata["system"]["physics"]["jump"][0].as<float>() * uf::physics::time::delta;
+				if ( metadata["system"]["physics"]["jump"][1].as<float>() != 0 ) transform.position.y -= metadata["system"]["physics"]["jump"][1].as<float>() * uf::physics::time::delta;
+				if ( metadata["system"]["physics"]["jump"][2].as<float>() != 0 ) transform.position.z -= metadata["system"]["physics"]["jump"][2].as<float>() * uf::physics::time::delta;
+			} else {
+				if ( !metadata["system"]["crouching"].as<bool>() )  stats.deltaCrouch = true;
+				metadata["system"]["crouching"] = true;
+			}
+		} else {
+			if ( metadata["system"]["crouching"].as<bool>() ) stats.deltaCrouch = true;
+			metadata["system"]["crouching"] = false;
+		}	
+	}
+	if ( stats.deltaCrouch ) {
+		float delta = metadata["system"]["physics"]["crouch"].as<float>();
+		if ( metadata["system"]["crouching"].as<bool>() ) camera.getTransform().position.y -= delta;
+		else camera.getTransform().position.y += delta;
+		stats.updateCamera = true;
+	}
+
+	if ( stats.floored ) {
+		if ( stats.walking ) {
+			uf::SoundEmitter& emitter = this->getComponent<uf::SoundEmitter>();
+			int cycle = rand() % metadata["audio"]["footstep"]["list"].size();
+			std::string filename = metadata["audio"]["footstep"]["list"][cycle].as<std::string>();
+			uf::Audio& footstep = emitter.add(filename);
+
+			bool playing = false;
+			for ( uint i = 0; i < metadata["audio"]["footstep"]["list"].size(); ++i ) {
+				uf::Audio& audio = emitter.add(metadata["audio"]["footstep"]["list"][i].as<std::string>());
+				if ( audio.playing() ) playing = true;
+			}
+			if ( !playing ) {
+				footstep.play();
+				footstep.setVolume(metadata["audio"]["footstep"]["volume"].as<float>());
+				footstep.setPosition( transform.position );
+
+				// [0, 1]
+				float modulation = (rand() % 100) / 100.0;
+				// [0, 0.1]
+				modulation *= 0.1f;
+				// [-0.05, 0.05]
+				modulation -= 0.05f;
+				if ( keys.running ) modulation += 0.5f;
+				footstep.setPitch(1 + modulation);
+			}
+			// set animation to walk
+			stats.targetAnimation = "walk";
+		} else if ( !keys.jump ) {
+			physics.linear.velocity.x = 0;
+			physics.linear.velocity.y = 0;
+			physics.linear.velocity.z = 0;
+			stats.targetAnimation = "idle_wank";
+		}
+	}
+#endif
+	
+	// set animation to idle
+	if ( stats.targetAnimation != "" ) {
+		auto* playerModel = this->findByName("Player: Model");
+		if ( playerModel && playerModel->hasComponent<pod::Graph>() ) {
+			auto& graph = playerModel->getComponent<pod::Graph>();
+			bool should = true;
+			if ( graph.sequence.empty() && graph.sequence.front() == stats.targetAnimation ) should = false;
+			if ( should ) {
+				graph.settings.animations.loop = true;
+				uf::graph::animate( graph, stats.targetAnimation );
+			}
+		}
+	}
+/*
+	{
+		auto flatten = uf::transform::flatten( transform );
+		static pod::Quaternion<> storedCameraOrientation = transform.orientation;
+
+		const pod::Quaternion<> prevCameraOrientation = storedCameraOrientation;
+		const pod::Quaternion<> curCameraOrientation = transform.orientation;
+		const pod::Quaternion<> deltaOrientation = uf::quaternion::multiply( curCameraOrientation, uf::quaternion::inverse( prevCameraOrientation ) ) ;
+		const pod::Vector3f deltaAngles = uf::quaternion::eulerAngles( deltaOrientation );
+		float magnitude = uf::vector::magnitude( deltaOrientation );
+		if ( magnitude > 0.0001f ) {
+			uf::Serializer payload;
+			payload["previous"] = uf::vector::encode( prevCameraOrientation );
+			payload["current"] = uf::vector::encode( curCameraOrientation );
+			payload["delta"] = uf::vector::encode( deltaOrientation );
+			payload["euler"] = uf::vector::encode( deltaAngles );
+			payload["angle"]["pitch"] = deltaAngles.x;
+			payload["angle"]["yaw"] = deltaAngles.y;
+			payload["angle"]["roll"] = deltaAngles.z;
+			payload["magnitude"] = magnitude;
+			this->callHook("controller:Camera.Rotated", payload);
+		}
+		storedCameraOrientation = transform.orientation;
+	}
+*/
+/*
+	// translate movement in HMD to give HUD feedback
+	if ( ext::openvr::context ) {
+		static pod::Quaternion<> prevCameraOrientation = ext::openvr::hmdQuaternion();
+		const pod::Quaternion<> curCameraOrientation = ext::openvr::hmdQuaternion();
+		const pod::Vector3f prevEulerAngle = uf::quaternion::eulerAngles( prevCameraOrientation );
+		const pod::Vector3f curEulerAngle = uf::quaternion::eulerAngles( curCameraOrientation );
+		const pod::Vector3f deltaAngles = uf::vector::subtract( curEulerAngle, prevEulerAngle );
+		float magnitude = uf::vector::magnitude( deltaAngles );
+		if ( magnitude > 0.0001f ) {
+			uf::Serializer payload;
+			payload["previous"] = uf::vector::encode( prevCameraOrientation );
+			payload["current"] = uf::vector::encode( curCameraOrientation );
+			payload["euler"] = uf::vector::encode( deltaAngles );
+			payload["angle"]["pitch"] = deltaAngles.x;
+			payload["angle"]["yaw"] = deltaAngles.y;
+			payload["angle"]["roll"] = deltaAngles.z;
+			payload["magnitude"] = magnitude;
+			this->callHook("controller:Camera.Rotated", payload);
+		}
+		prevCameraOrientation = curCameraOrientation;
+	}
+*/
+	#define TRACK_ORIENTATION(ORIENTATION) {\
+		static pod::Quaternion<> storedCameraOrientation = ORIENTATION;\
+		const pod::Quaternion<> prevCameraOrientation = storedCameraOrientation;\
+		const pod::Quaternion<> curCameraOrientation = ORIENTATION;\
+		const pod::Quaternion<> deltaOrientation = uf::quaternion::multiply( curCameraOrientation, uf::quaternion::inverse( prevCameraOrientation ) ) ;\
+		const pod::Vector3f deltaAngles = uf::quaternion::eulerAngles( deltaOrientation );\
+		combinedDeltaAngles = uf::vector::add( combinedDeltaAngles, deltaAngles );\
+		combinedDeltaOrientation = uf::quaternion::multiply( deltaOrientation, combinedDeltaOrientation );\
+		storedCameraOrientation = ORIENTATION;\
+	}
+
+	{
+		pod::Quaternion<> combinedDeltaOrientation = {0,0,0,1};
+		pod::Vector3f combinedDeltaAngles = {};
+		TRACK_ORIENTATION(transform.orientation);
+		TRACK_ORIENTATION(camera.getTransform().orientation);
+		float magnitude = uf::quaternion::magnitude( combinedDeltaOrientation );
+		if ( magnitude > 0.0001f ) {
+			uf::Serializer payload;
+			payload["delta"] = uf::vector::encode( combinedDeltaOrientation );
+			payload["angle"]["pitch"] = combinedDeltaAngles.x;
+			payload["angle"]["yaw"] = combinedDeltaAngles.y;
+			payload["angle"]["roll"] = combinedDeltaAngles.z;
+			payload["magnitude"] = magnitude;
+			this->callHook("controller:Camera.Rotated", payload);
+		}
+	}
+
+
+	if ( stats.updateCamera )
+		camera.updateView();
+}
+
+void ext::PlayerBehavior::render( uf::Object& self ){}
+void ext::PlayerBehavior::destroy( uf::Object& self ){}
+#undef this
\ No newline at end of file
diff --git a/ext/behaviors/player/behavior.h b/ext/behaviors/player/behavior.h
new file mode 100644
index 00000000..a6b843b3
--- /dev/null
+++ b/ext/behaviors/player/behavior.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/ext/ext.h>
+#include <uf/engine/entity/entity.h>
+#include <uf/engine/scene/scene.h>
+
+namespace ext {
+	class EXT_API PlayerBehavior {
+	public:
+		static void attach( uf::Object& );
+		static void initialize( uf::Object& );
+		static void tick( uf::Object& );
+		static void render( uf::Object& );
+		static void destroy( uf::Object& );
+	};
+}
\ No newline at end of file
diff --git a/ext/behaviors/player/model/behavior.cpp b/ext/behaviors/player/model/behavior.cpp
new file mode 100644
index 00000000..9b72c61c
--- /dev/null
+++ b/ext/behaviors/player/model/behavior.cpp
@@ -0,0 +1,61 @@
+#include "behavior.h"
+#include "../behavior.h"
+#include <uf/utils/serialize/serializer.h>
+#include <uf/utils/hook/hook.h>
+#include <uf/utils/time/time.h>
+#include <uf/utils/serialize/serializer.h>
+#include <uf/utils/userdata/userdata.h>
+#include <uf/utils/window/window.h>
+#include <uf/utils/camera/camera.h>
+#include <uf/utils/audio/audio.h>
+#include <uf/ext/openvr/openvr.h>
+#include <uf/utils/math/physics.h>
+#include <mutex>
+
+UF_BEHAVIOR_REGISTER_CPP(ext::PlayerModelBehavior)
+#define this ((uf::Scene*) &self)
+
+void ext::PlayerModelBehavior::initialize( uf::Object& self ) {
+	auto& scene = uf::scene::getCurrentScene();
+	auto& controller = scene.getController();
+	auto& controllerTransform = controller.getComponent<pod::Transform<>>();
+	auto& transform = this->getComponent<pod::Transform<>>();
+	auto& metadata = this->getComponent<uf::Serializer>();
+	transform.reference = &controllerTransform;
+}
+void ext::PlayerModelBehavior::tick( uf::Object& self ) {
+	if ( this->getChildren().size() != 1 ) return;
+	auto& metadata = this->getComponent<uf::Serializer>();
+	auto& scene = uf::scene::getCurrentScene();
+	auto& controller = scene.getController();
+	auto& controllerTransform = controller.getComponent<pod::Transform<>>();
+	auto& transform = this->getComponent<pod::Transform<>>();
+	if ( metadata["track via reference"].as<bool>() )
+		transform.reference = metadata["track player"].as<bool>() ? &controllerTransform : NULL;
+	else if ( metadata["track player"].as<bool>() ) {
+		transform.position = controllerTransform.position;
+		transform.orientation = controllerTransform.orientation;
+	}
+}
+
+void ext::PlayerModelBehavior::render( uf::Object& self ){
+	if ( this->getChildren().size() != 1 ) return;
+	auto& metadata = this->getComponent<uf::Serializer>();
+	if ( !metadata["hide player model"].as<bool>() ) return;
+	
+	auto& scene = uf::scene::getCurrentScene();
+	auto& controller = scene.getController();
+	auto& player = this->getParent().as<uf::Object>();
+	auto& model = this->getChildren().front()->as<uf::Object>();
+	auto& transform = this->getComponent<pod::Transform<>>();
+
+	if ( player.getUid() == controller.getUid() ) {
+		transform.scale = { 0, 0, 0 };
+	} else {
+		transform.scale = uf::vector::decode( metadata["system"]["transform"]["scale"], pod::Vector3f{1,1,1} );
+	}
+}
+void ext::PlayerModelBehavior::destroy( uf::Object& self ){
+
+}
+#undef this
\ No newline at end of file
diff --git a/ext/behaviors/player/model/behavior.h b/ext/behaviors/player/model/behavior.h
new file mode 100644
index 00000000..9ef6b002
--- /dev/null
+++ b/ext/behaviors/player/model/behavior.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/ext/ext.h>
+#include <uf/engine/entity/entity.h>
+#include <uf/engine/scene/scene.h>
+
+namespace ext {
+	class EXT_API PlayerModelBehavior {
+	public:
+		static void attach( uf::Object& );
+		static void initialize( uf::Object& );
+		static void tick( uf::Object& );
+		static void render( uf::Object& );
+		static void destroy( uf::Object& );
+	};
+}
\ No newline at end of file
diff --git a/ext/behaviors/portal/behavior.cpp b/ext/behaviors/portal/behavior.cpp
new file mode 100644
index 00000000..789405d4
--- /dev/null
+++ b/ext/behaviors/portal/behavior.cpp
@@ -0,0 +1,165 @@
+#include "behavior.h"
+
+#include <uf/utils/graphic/mesh.h>
+#include <uf/utils/graphic/graphic.h>
+#include <uf/utils/camera/camera.h>
+#include <uf/utils/math/transform.h>
+#include <uf/utils/math/physics.h>
+#include <uf/utils/serialize/serializer.h>
+#include <uf/utils/math/collision.h>
+#include <uf/utils/thread/thread.h>
+#include <uf/utils/math/physics.h>
+
+#include <uf/utils/window/window.h>
+
+#include <uf/ext/openvr/openvr.h>
+
+#include <uf/utils/renderer/renderer.h>
+
+UF_BEHAVIOR_REGISTER_CPP(ext::PortalsBehavior)
+UF_BEHAVIOR_REGISTER_AS_OBJECT(ext::PortalsBehavior, Portals)
+#define this (&self)
+void ext::PortalsBehavior::initialize( uf::Object& self ) {
+	auto& metadata = this->getComponent<uf::Serializer>();
+
+	uf::Object& red = *(new uf::Object); this->addChild(red); uf::instantiator::bind( "Portal", red );
+	uf::Object& blue = *(new uf::Object); this->addChild(blue); uf::instantiator::bind( "Portal", blue );
+
+	metadata["portals"][0]["name"] = "Portal";
+	metadata["portals"][1]["name"] = "Portal";
+
+	red.load( (uf::Serializer) metadata["portals"][0] );
+	blue.load( (uf::Serializer) metadata["portals"][1] );
+
+	red.initialize();
+	blue.initialize();
+
+	red.getComponent<uf::Serializer>()["target"] = blue.getUid();
+	blue.getComponent<uf::Serializer>()["target"] = red.getUid();
+}
+void ext::PortalsBehavior::tick( uf::Object& self ) {
+}
+void ext::PortalsBehavior::render( uf::Object& self ){}
+void ext::PortalsBehavior::destroy( uf::Object& self ){}
+#undef this
+
+UF_BEHAVIOR_REGISTER_CPP(ext::PortalBehavior)
+UF_BEHAVIOR_REGISTER_AS_OBJECT(ext::PortalBehavior, Portal)
+#define this (&self)
+void ext::PortalBehavior::initialize( uf::Object& self ) {
+	auto& metadata = this->getComponent<uf::Serializer>();
+	auto& transform = this->getComponent<pod::Transform<>>();
+	auto& camera = this->getComponent<uf::Camera>();
+	{
+		auto& scene = uf::scene::getCurrentScene();
+		auto& controller = scene.getController();
+		// copies camera settings
+		camera = controller.getComponent<uf::Camera>();
+	}
+	{
+		auto& renderMode = this->getComponent<uf::renderer::RenderTargetRenderMode>();
+		std::string name = "RT:" + std::to_string((int) this->getUid());
+		uf::renderer::addRenderMode( &renderMode, name );
+	#if UF_USE_OPENVR
+		if ( ext::openvr::enabled ) {
+			ext::openvr::initialize();
+		
+			uint32_t width, height;
+			ext::openvr::recommendedResolution( width, height );
+
+			renderMode.width = width;
+			renderMode.height = height;
+		}
+	#endif
+	}
+}
+void ext::PortalBehavior::tick( uf::Object& self ) {
+	auto& renderMode = this->getComponent<uf::renderer::RenderTargetRenderMode>();
+	renderMode.setTarget("");
+	
+	auto& scene = uf::scene::getCurrentScene();
+	auto& controller = scene.getController();
+	auto& camera = this->getComponent<uf::Camera>();
+	auto& metadata = this->getComponent<uf::Serializer>();
+/*
+	static pod::Transform<> otherSideTransform = this->getComponent<pod::Transform<>>();
+	{
+		float step = 4.0f;
+		if ( uf::Window::isKeyPressed("B") ) otherSideTransform.position.x -= step * uf::physics::time::delta;
+		if ( uf::Window::isKeyPressed("M") ) otherSideTransform.position.x += step * uf::physics::time::delta;
+		if ( uf::Window::isKeyPressed("G") ) otherSideTransform.position.y += step * uf::physics::time::delta;
+		if ( uf::Window::isKeyPressed("J") ) otherSideTransform.position.y -= step * uf::physics::time::delta;
+		if ( uf::Window::isKeyPressed("H") ) otherSideTransform.position.z += step * uf::physics::time::delta;
+		if ( uf::Window::isKeyPressed("N") ) otherSideTransform.position.z -= step * uf::physics::time::delta;
+		if ( uf::Window::isKeyPressed("L") ) {
+			std::cout << otherSideTransform.position.x << ", " << otherSideTransform.position.y << ", " << otherSideTransform.position.z << "\t" << step * uf::physics::time::delta << std::endl;
+		}
+	}
+*/
+	{
+		auto& conCamera = controller.getComponent<uf::Camera>();
+		auto& prtTransform = this->getComponent<pod::Transform<>>();
+		auto& otherSideTransform = this->getParent().findByUid( metadata["target"].as<size_t>() )->getComponent<pod::Transform<>>();
+
+		for ( std::size_t i = 0; i < 2; ++i ) {
+			pod::Matrix4f controllerCameraToWorldMatrix = uf::matrix::inverse( conCamera.getView(i) );
+			pod::Matrix4f worldToPortalMatrix = uf::matrix::inverse( uf::transform::model( prtTransform ) );
+			pod::Matrix4f otherSideToWorldMatrix = uf::transform::model( otherSideTransform );
+			camera.setView( uf::matrix::inverse(otherSideToWorldMatrix * worldToPortalMatrix * controllerCameraToWorldMatrix), i );
+		}
+	}
+}
+void ext::PortalBehavior::render( uf::Object& self ){
+	{
+		auto& renderMode = this->getComponent<uf::renderer::RenderTargetRenderMode>();
+		auto& blitter = renderMode.blitter;
+
+		auto& transform = this->getComponent<pod::Transform<>>();
+		auto& scene = uf::scene::getCurrentScene();
+		auto& controller = scene.getController();
+		auto& camera = this->getComponent<uf::Camera>();
+		auto& controllerCamera = controller.getComponent<uf::Camera>();
+		if ( !blitter.initialized ) return;
+
+		struct UniformDescriptor {
+			struct {
+				alignas(16) pod::Matrix4f models[2];
+			} matrices;
+			struct {
+				alignas(8) pod::Vector2f position = { 0.5f, 0.5f };
+				alignas(8) pod::Vector2f radius = { 0.1f, 0.1f };
+				alignas(16) pod::Vector4f color = { 1, 1, 1, 1 };
+			} cursor;
+			alignas(4) float alpha;
+		};
+
+		auto& shader = blitter.material.shaders.front();
+		auto& uniforms = shader.uniforms.front().get<UniformDescriptor>();
+
+		for ( std::size_t i = 0; i < 2; ++i ) {
+			pod::Matrix4f model = uf::transform::model( transform );
+
+			uniforms.matrices.models[i] = controllerCamera.getProjection(i) * controllerCamera.getView(i) * model;
+
+			uniforms.alpha = 1.0f;
+
+			uniforms.cursor.position.x = -1.0f;
+			uniforms.cursor.position.y = -1.0f;
+
+			uniforms.cursor.radius.x = 0.0f;
+			uniforms.cursor.radius.y = 0.0f;
+			
+			uniforms.cursor.color.x = 0.0f;
+			uniforms.cursor.color.y = 0.0f;
+			uniforms.cursor.color.z = 0.0f;
+			uniforms.cursor.color.w = 0.0f;
+		}
+		shader.updateBuffer( (void*) &uniforms, sizeof(uniforms), 0 );
+	}
+}
+void ext::PortalBehavior::destroy( uf::Object& self ){
+	auto& renderMode = this->getComponent<uf::renderer::RenderTargetRenderMode>();
+	uf::renderer::removeRenderMode( &renderMode, false );
+	this->deleteComponent<uf::renderer::RenderTargetRenderMode>();
+}
+#undef this
\ No newline at end of file
diff --git a/ext/behaviors/portal/behavior.h b/ext/behaviors/portal/behavior.h
new file mode 100644
index 00000000..293b42a1
--- /dev/null
+++ b/ext/behaviors/portal/behavior.h
@@ -0,0 +1,25 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/ext/ext.h>
+#include <uf/engine/entity/entity.h>
+#include <uf/engine/scene/scene.h>
+
+namespace ext {
+	class EXT_API PortalsBehavior {
+	public:
+		static void attach( uf::Object& );
+		static void initialize( uf::Object& );
+		static void tick( uf::Object& );
+		static void render( uf::Object& );
+		static void destroy( uf::Object& );
+	};
+	class EXT_API PortalBehavior {
+	public:
+		static void attach( uf::Object& );
+		static void initialize( uf::Object& );
+		static void tick( uf::Object& );
+		static void render( uf::Object& );
+		static void destroy( uf::Object& );
+	};
+}
\ No newline at end of file
diff --git a/ext/behaviors/scene/behavior.cpp b/ext/behaviors/scene/behavior.cpp
new file mode 100644
index 00000000..f4e900de
--- /dev/null
+++ b/ext/behaviors/scene/behavior.cpp
@@ -0,0 +1,641 @@
+#include "behavior.h"
+
+#include <uf/utils/time/time.h>
+#include <uf/utils/io/iostream.h>
+#include <uf/utils/math/vector.h>
+#include <uf/utils/math/transform.h>
+#include <uf/utils/window/window.h>
+#include <uf/utils/graphic/graphic.h>
+
+#include <uf/utils/audio/audio.h>
+#include <uf/utils/thread/thread.h>
+#include <uf/utils/camera/camera.h>
+#include <uf/utils/math/physics.h>
+
+#include <uf/engine/asset/asset.h>
+#include <uf/engine/asset/masterdata.h>
+
+#include <uf/utils/renderer/renderer.h>
+#include <uf/utils/noise/noise.h>
+
+#include <uf/ext/gltf/gltf.h>
+
+#include <uf/utils/math/collision.h>
+
+#include "../../ext.h"
+#include "../../gui/gui.h"
+
+UF_BEHAVIOR_REGISTER_CPP(ext::ExtSceneBehavior)
+#define this ((uf::Scene*) &self)
+void ext::ExtSceneBehavior::initialize( uf::Object& self ) {
+	uf::Asset& assetLoader = this->getComponent<uf::Asset>();
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+
+	this->addHook( "system:Quit.%UID%", [&](ext::json::Value& json){
+		std::cout << json << std::endl;
+		ext::ready = false;
+	});
+
+	this->addHook( "world:Music.LoadPrevious.%UID%", [&](ext::json::Value& json){
+
+		if ( metadata["previous bgm"]["filename"] == "" ) return;
+
+		std::string filename = metadata["previous bgm"]["filename"].as<std::string>();
+		float timestamp = metadata["previous bgm"]["timestamp"].as<float>();
+
+//		std::cout << metadata["previous bgm"] << std::endl;
+
+		uf::Audio& audio = this->getComponent<uf::Audio>();
+		if ( audio.playing() ) {
+			metadata["previous bgm"]["filename"] = audio.getFilename();
+			metadata["previous bgm"]["timestamp"] = audio.getTime();
+			audio.stop();
+		}
+		audio.load(filename);
+		audio.setVolume(metadata["volumes"]["bgm"].as<float>());
+		audio.setTime(timestamp);
+		audio.play();
+	});
+	this->addHook( "asset:Load.%UID%", [&](ext::json::Value& json){
+		std::string filename = json["filename"].as<std::string>();
+		std::string category = json["category"].as<std::string>();
+		if ( category != "" && category != "audio" ) return;
+		if ( category == "" && uf::io::extension(filename) != "ogg" ) return;
+		const uf::Audio* audioPointer = NULL;
+		if ( !assetLoader.has<uf::Audio>(filename) ) return;
+		audioPointer = &assetLoader.get<uf::Audio>(filename);
+		if ( !audioPointer ) return;
+
+		uf::Audio& audio = this->getComponent<uf::Audio>();
+		if ( audio.playing() ) audio.stop();
+
+		audio.load(filename);
+		audio.setVolume(metadata["volumes"]["bgm"].as<float>());
+		audio.play();
+	});
+
+	this->addHook( "menu:Pause", [&](ext::json::Value& json){
+		static uf::Timer<long long> timer(false);
+		if ( !timer.running() ) timer.start( uf::Time<>(-1000000) );
+		if ( timer.elapsed().asDouble() < 1 ) return;
+		timer.reset();
+
+		uf::Object* manager = (uf::Object*) this->globalFindByName("Gui Manager");
+		if ( !manager ) return;
+		uf::Serializer payload;
+		std::string config = metadata["menus"]["pause"].is<std::string>() ? metadata["menus"]["pause"].as<std::string>() : "/scenes/worldscape/gui/pause/menu.json";
+		uf::Object& gui = manager->loadChild(config, false);
+		payload["uid"] = gui.getUid();
+
+		uf::Serializer& metadata = gui.getComponent<uf::Serializer>();
+		metadata["menu"] = json["menu"];
+		
+		gui.initialize();
+	//	return payload;
+	});
+	this->addHook( "world:Entity.LoadAsset", [&](ext::json::Value& json){
+		std::string asset = json["asset"].as<std::string>();
+		std::string uid = json["uid"].as<std::string>();
+
+		assetLoader.load(asset, "asset:Load." + uid);
+	});
+	this->addHook( "shader:Update.%UID%", [&](ext::json::Value& _json){
+		uf::Serializer json = _json;
+		json["mode"] = json["mode"].as<size_t>() | metadata["system"]["renderer"]["shader"]["mode"].as<size_t>();
+		metadata["system"]["renderer"]["shader"]["mode"] = json["mode"];
+		metadata["system"]["renderer"]["shader"]["parameters"] = json["parameters"];
+	});
+	/* store viewport size */ {
+//		metadata["system"]["window"]["size"]["x"] = uf::renderer::settings::width;
+//		metadata["system"]["window"]["size"]["y"] = uf::renderer::settings::height;
+//		ext::gui::size.current.x = uf::renderer::settings::width;
+//		ext::gui::size.current.y = uf::renderer::settings::height;
+		
+		this->addHook( "window:Resized", [&](ext::json::Value& json){
+			pod::Vector2ui size; {
+				size.x = json["window"]["size"]["x"].as<size_t>();
+				size.y = json["window"]["size"]["y"].as<size_t>();
+			}
+
+			metadata["system"]["window"] = json["system"]["window"];
+			ext::gui::size.current = size;
+		});
+	}
+
+	// lock control
+	{
+		uf::Serializer payload;
+		payload["state"] = false;
+		uf::hooks.call("window:Mouse.CursorVisibility", payload);
+		uf::hooks.call("window:Mouse.Lock");
+	}
+
+	// initialize perlin noise
+	#if UF_USE_VULKAN
+	{
+		auto& texture = this->getComponent<uf::renderer::Texture3D>();
+		texture.sampler.descriptor.addressMode = {
+			uf::renderer::enums::AddressMode::MIRRORED_REPEAT,
+			uf::renderer::enums::AddressMode::MIRRORED_REPEAT,
+			uf::renderer::enums::AddressMode::MIRRORED_REPEAT
+		};
+
+		auto& noiseGenerator = this->getComponent<uf::PerlinNoise>();
+		auto& metadata = this->getComponent<uf::Serializer>();
+		noiseGenerator.seed(rand());
+
+		float high = std::numeric_limits<float>::min();
+		float low = std::numeric_limits<float>::max();
+		float amplitude = metadata["noise"]["amplitude"].is<float>() ? metadata["noise"]["amplitude"].as<float>() : 1.5;
+		pod::Vector3ui size = uf::vector::decode(metadata["noise"]["size"], pod::Vector3ui{256, 256, 256});
+		pod::Vector3d coefficients = uf::vector::decode(metadata["noise"]["coefficients"], pod::Vector3d{3.0, 3.0, 3.0});
+
+		std::vector<uint8_t> pixels(size.x * size.y * size.z);
+		std::vector<float> perlins(size.x * size.y * size.z);
+	#pragma omp parallel for
+		for ( size_t z = 0; z < size.z; ++z ) {
+		for ( size_t y = 0; y < size.y; ++y ) {
+		for ( size_t x = 0; x < size.x; ++x ) {
+			float nx = (float) x / (float) size.x;
+			float ny = (float) y / (float) size.y;
+			float nz = (float) z / (float) size.z;
+
+			float n = amplitude * noiseGenerator.noise(coefficients.x * nx, coefficients.y * ny, coefficients.z * nz);
+			high = std::max( high, n );
+			low = std::min( low, n );
+			perlins[x + y * size.x + z * size.x * size.y] = n;
+		}
+		}
+		}
+		for ( size_t i = 0; i < perlins.size(); ++i ) {
+			float n = perlins[i];
+			n = n - floor(n);
+			float normalized = (n - low) / (high - low);
+			if ( normalized >= 1.0f ) normalized = 1.0f;
+			pixels[i] = static_cast<uint8_t>(floor(normalized * 255));
+		}
+		texture.fromBuffers( (void*) pixels.data(), pixels.size(), uf::renderer::enums::Format::R8_UNORM, size.x, size.y, size.z, 1 );
+	}
+	// initialize cubemap
+	{
+		std::vector<std::string> filenames = {
+			uf::io::root+"/textures/skybox/front.png",
+			uf::io::root+"/textures/skybox/back.png",
+			uf::io::root+"/textures/skybox/up.png",
+			uf::io::root+"/textures/skybox/down.png",
+			uf::io::root+"/textures/skybox/right.png",
+			uf::io::root+"/textures/skybox/left.png",
+		};
+		uf::Image::container_t pixels;
+		std::vector<uf::Image> images(filenames.size());
+
+		pod::Vector2ui size = {0,0};
+		auto& texture = this->getComponent<uf::renderer::TextureCube>();
+		for ( size_t i = 0; i < filenames.size(); ++i ) {
+			auto& filename = filenames[i];
+			auto& image = images[i];
+			image.open(filename);
+			image.flip();
+
+			if ( size.x == 0 && size.y == 0 ) {
+				size = image.getDimensions();
+			} else if ( size != image.getDimensions() ) {
+				std::cout << "ERROR: MISMATCH CUBEMAP FACE SIZE" << std::endl;
+			}
+
+			auto& p = image.getPixels();
+			pixels.reserve( pixels.size() + p.size() );
+			pixels.insert( pixels.end(), p.begin(), p.end() );
+		}
+		texture.mips = 0;
+		texture.fromBuffers( (void*) pixels.data(), pixels.size(), uf::renderer::enums::Format::R8G8B8A8_UNORM, size.x, size.y, 1, filenames.size() );
+	}
+	#endif
+}
+void ext::ExtSceneBehavior::tick( uf::Object& self ) {
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	uf::Asset& assetLoader = this->getComponent<uf::Asset>();
+
+	/* check if audio needs to loop */ {
+		auto& bgm = this->getComponent<uf::Audio>();
+		float current = bgm.getTime();
+		float end = bgm.getDuration();
+		float epsilon = 0.005f;
+		if ( current + epsilon >= end || !bgm.playing() ) {
+			// intro to main transition
+			std::string filename = bgm.getFilename();
+			filename = assetLoader.getOriginal(filename);
+			if ( filename.find("_intro") != std::string::npos ) {
+				assetLoader.load(uf::string::replace( filename, "_intro", "" ), this->formatHookName("asset:Load.%UID%"));
+			// loop
+			} else {
+				bgm.setTime(0);
+				if ( !bgm.playing() ) bgm.play();
+			}
+		}
+	}
+	{
+		uf::hooks.call("game:Frame.Start");
+	}
+
+	/* Regain control if nothing requests it */ {
+		uf::Object* menu = (uf::Object*) this->globalFindByName("Gui: Menu");
+		if ( !menu ) {
+			uf::Serializer payload;
+			payload["state"] = false;
+			uf::hooks.call("window:Mouse.CursorVisibility", payload);
+			uf::hooks.call("window:Mouse.Lock");
+		} else {
+			uf::Serializer payload;
+			payload["state"] = true;
+			uf::hooks.call("window:Mouse.CursorVisibility", payload);
+		}
+	}
+
+	/* Print World Tree */ {
+		TIMER(1, uf::Window::isKeyPressed("U") && ) {
+			std::function<void(uf::Entity*, int)> filter = []( uf::Entity* entity, int indent ) {
+				for ( int i = 0; i < indent; ++i ) uf::iostream << "\t";
+				uf::iostream << uf::string::toString(entity->as<uf::Object>()) << " ";
+				if ( entity->hasComponent<pod::Transform<>>() ) {
+					pod::Transform<> t = uf::transform::flatten(entity->getComponent<pod::Transform<>>());
+					uf::iostream << uf::string::toString(t.position) << " " << uf::string::toString(t.orientation);
+				}
+				uf::iostream << "\n";
+			};
+			for ( uf::Scene* scene : uf::scene::scenes ) {
+				if ( !scene ) continue;
+				uf::iostream << "Scene: " << scene->getName() << ": " << scene << "\n";
+				scene->process(filter, 1);
+			}
+		}
+	}
+	/* Print World Tree */ {
+		TIMER(1, uf::Window::isKeyPressed("U") && false && ) {
+			std::function<void(uf::Entity*, int)> filter = []( uf::Entity* entity, int indent ) {
+				for ( int i = 0; i < indent; ++i ) uf::iostream << "\t";
+				uf::iostream << uf::string::toString(entity->as<uf::Object>()) << " [";
+				for ( auto& behavior : entity->getBehaviors() ) {
+					uf::iostream << uf::instantiator::behaviors->names[behavior.type] << ", ";
+				}
+				uf::iostream << "]\n";
+			};
+			for ( uf::Scene* scene : uf::scene::scenes ) {
+				if ( !scene ) continue;
+				uf::iostream << "Scene: " << scene->getName() << ": " << scene << "\n";
+				scene->process(filter, 1);
+			}
+			uf::Serializer instantiator;
+			{
+				int i = 0;
+				for ( auto& pair : uf::instantiator::objects->names ) {
+					instantiator["objects"][i++] = pair.second;
+				}
+			}
+			{
+				int i = 0;
+				for ( auto& pair : uf::instantiator::behaviors->names ) {
+					instantiator["behaviors"][i++] = pair.second;
+				}
+			}
+			uf::iostream << instantiator << "\n";
+		}
+	}
+	
+	/* Updates Sound Listener */ {
+		auto& controller = this->getController();
+		// copy
+		pod::Transform<> transform = controller.getComponent<pod::Transform<>>();
+		if ( controller.hasComponent<uf::Camera>() ) {
+			auto& camera = controller.getComponent<uf::Camera>();
+			transform.position += camera.getTransform().position;
+			transform = uf::transform::reorient( transform );
+		}
+		transform.forward *= -1;
+	#if UF_USE_OPENAL
+		ext::oal.listener( "POSITION", { transform.position.x, transform.position.y, transform.position.z } );
+		ext::oal.listener( "VELOCITY", { 0, 0, 0 } );
+		ext::oal.listener( "ORIENTATION", { transform.forward.x, transform.forward.y, transform.forward.z, transform.up.x, transform.up.y, transform.up.z } );
+	#endif
+	}
+
+#if UF_USE_VULKAN
+	/* Update lights */ if ( metadata["light"]["should"].as<bool>() ) {
+		auto& scene = uf::scene::getCurrentScene();
+		auto& controller = scene.getController();
+		auto& camera = controller.getComponent<uf::Camera>();
+		auto& renderMode = uf::renderer::getRenderMode("", true);
+		auto& controllerMetadata = controller.getComponent<uf::Serializer>();
+		auto& controllerTransform = controller.getComponent<pod::Transform<>>();
+		std::vector<uf::Graphic*> blitters = renderMode.getBlitters();
+		
+		size_t maxTextures = metadata["system"]["config"]["engine"]["scenes"]["textures"]["max"].as<size_t>();
+
+		struct UniformDescriptor {
+			struct Matrices {
+				alignas(16) pod::Matrix4f view[2];
+				alignas(16) pod::Matrix4f projection[2];
+				alignas(16) pod::Matrix4f iView[2];
+				alignas(16) pod::Matrix4f iProjection[2];
+				alignas(16) pod::Matrix4f iProjectionView[2];
+			} matrices;
+			struct Mode {
+				alignas(8) pod::Vector2ui type;
+				alignas(8) pod::Vector2ui padding;
+				alignas(16) pod::Vector4f parameters;
+			} mode;
+			struct {
+				alignas(16) pod::Vector4f color; // w: stepScale
+				alignas(16) pod::Vector4f offset; // w: densityScale
+				alignas(4) float densityThreshold;
+				alignas(4) float densityMultiplier;
+
+				alignas(4) float absorbtion;
+				alignas(4) float padding1;
+
+				alignas(8) pod::Vector2f range;
+				alignas(4) float padding2;
+				alignas(4) float padding3;
+			} fog;
+			struct {
+				alignas(4) uint32_t lights = 0;
+				alignas(4) uint32_t materials = 0;
+				alignas(4) uint32_t textures = 0;
+				alignas(4) uint32_t drawCalls = 0;
+			} lengths;
+			alignas(16) pod::Vector4f ambient;
+		//	alignas(16) pod::Vector4f position;
+
+			alignas(4) uint32_t msaa;
+			alignas(4) uint32_t poissonSamples;
+			alignas(4) uint32_t padding1;
+			alignas(4) uint32_t padding2;
+		};
+		struct SpecializationConstant {
+			uint32_t maxTextures = 512;
+		} specializationConstants;
+		specializationConstants.maxTextures = maxTextures;
+
+		struct LightInfo {
+			uf::Entity* entity = NULL;
+			pod::Vector3f position = {0,0,0};
+			float distance = 0;
+			bool shadows = false;
+		};
+		std::vector<LightInfo> entities;
+		std::vector<pod::Graph*> graphs;
+
+		this->process([&]( uf::Entity* entity ) { if ( !entity ) return;
+			auto& metadata = entity->getComponent<uf::Serializer>();
+			if ( entity == &controller ) return;
+			if ( entity == this ) return;
+			if ( entity->hasComponent<pod::Graph>() ) graphs.emplace_back(&entity->getComponent<pod::Graph>());
+		//	if ( entity->hasComponent<pod::Graph>() && entity->hasComponent<uf::Graphic>() ) graphs.emplace_back(entity);
+			//
+			if ( entity->getName() != "Light" && !ext::json::isObject( metadata["light"] ) ) return;
+			//
+			if ( entity->hasComponent<uf::renderer::RenderTargetRenderMode>() ) {
+				auto& renderMode = entity->getComponent<uf::renderer::RenderTargetRenderMode>();
+				metadata["system"]["renderer"]["rendered"] = false;
+				if ( metadata["system"]["renderer"]["mode"].as<std::string>() == "in-range" ) {
+					renderMode.execute = false;
+				}
+			}
+			// is a component of an shadowing point light
+			if ( metadata["light"]["bound"].as<bool>() ) return;
+			LightInfo& info = entities.emplace_back();
+			auto& transform = entity->getComponent<pod::Transform<>>();
+			auto flatten = uf::transform::flatten( transform );
+			info.entity = entity;
+			info.position = flatten.position;
+			info.distance = uf::vector::magnitude( uf::vector::subtract( flatten.position, controllerTransform.position ) );
+			info.shadows = metadata["light"]["shadows"].as<bool>();
+		});
+		std::sort( entities.begin(), entities.end(), [&]( LightInfo& l, LightInfo& r ){
+			return l.distance < r.distance;
+		});
+	
+		int shadowSamples = metadata["system"]["config"]["engine"]["scenes"]["lights"]["shadow samples"].as<size_t>();
+		if ( shadowSamples <= 0 ) shadowSamples = 16;
+
+		int shadowThreshold = metadata["system"]["config"]["engine"]["scenes"]["lights"]["shadow threshold"].as<size_t>();
+		if ( shadowThreshold <= 0 ) shadowThreshold = std::numeric_limits<int>::max();
+		{
+			std::vector<LightInfo> scratch;
+			scratch.reserve(entities.size());
+			for ( size_t i = 0; i < entities.size(); ++i ) {
+				auto& info = entities[i];
+				auto& metadata = info.entity->getComponent<uf::Serializer>();
+				if ( info.shadows && --shadowThreshold <= 0 ) info.shadows = false;
+				scratch.emplace_back(info);
+			}
+			entities = scratch;
+		}
+	
+		if ( controllerMetadata["light"]["should"].as<bool>() ) {
+			auto& info = entities.emplace_back();
+			info.entity = &controller;
+			info.position = controllerTransform.position;
+			info.distance = 0;
+			info.shadows = false;
+		}
+
+		if ( !metadata["light"]["fog"]["step scale"].is<float>() ) metadata["light"]["fog"]["step scale"] = 16.0f;
+		if ( !metadata["light"]["fog"]["absorbtion"].is<float>() ) metadata["light"]["fog"]["absorbtion"] = 0.85f;
+		if ( !metadata["light"]["fog"]["density"]["threshold"].is<float>() ) metadata["light"]["fog"]["density"]["threshold"] = 0.5f;
+		if ( !metadata["light"]["fog"]["density"]["multiplier"].is<float>() ) metadata["light"]["fog"]["density"]["multiplier"] = 5.0f;
+		if ( !metadata["light"]["fog"]["density"]["scale"].is<float>() ) metadata["light"]["fog"]["density"]["scale"] = 50.0f;
+
+		for ( auto* blitter : blitters ) {
+			auto& graphic = *blitter;
+			auto& shader = graphic.material.getShader("fragment");
+			auto& uniform = shader.getUniform("UBO");
+			uint8_t* buffer = (uint8_t*) (void*) uniform;
+
+			UniformDescriptor* uniforms = (UniformDescriptor*) buffer;
+
+			for ( std::size_t i = 0; i < 2; ++i ) {
+				uniforms->matrices.view[i] = camera.getView( i );
+				uniforms->matrices.projection[i] = camera.getProjection( i );
+				uniforms->matrices.iView[i] = uf::matrix::inverse( uniforms->matrices.view[i] );
+				uniforms->matrices.iProjection[i] = uf::matrix::inverse( uniforms->matrices.projection[i] );
+				uniforms->matrices.iProjectionView[i] = uf::matrix::inverse( uniforms->matrices.projection[i] * uniforms->matrices.view[i] );
+			}
+
+			uniforms->ambient = uf::vector::decode( metadata["light"]["ambient"], uniforms->ambient );
+			uniforms->msaa = ext::vulkan::settings::msaa;
+		//	uniforms->msaa = metadata["system"]["config"]["engine"]["ext"]["vulkan"]["framebuffer"]["msaa"].as<size_t>();
+			uniforms->poissonSamples = shadowSamples;
+		/*
+			pod::Transform<> transform = controller.getComponent<pod::Transform<>>();
+			if ( controller.hasComponent<uf::Camera>() ) {
+				auto& camera = controller.getComponent<uf::Camera>();
+				transform.position += camera.getTransform().position;
+				transform = uf::transform::reorient( transform );
+			}
+			uniforms->position = transform.position;
+		*/
+
+			uniforms->fog.color = uf::vector::decode( metadata["light"]["fog"]["color"], uniforms->fog.color );
+			uniforms->fog.color.w = metadata["light"]["fog"]["step scale"].as<float>();
+
+			float timescale = metadata["light"]["fog"]["density"]["timescale"].as<float>();
+			uniforms->fog.offset = uf::vector::decode( metadata["light"]["fog"]["density"]["offset"], uniforms->fog.offset ) * uf::physics::time::current * timescale;
+			uniforms->fog.offset.w = metadata["light"]["fog"]["density"]["scale"].as<float>();
+
+			uniforms->fog.densityThreshold = metadata["light"]["fog"]["density"]["threshold"].as<float>();
+			uniforms->fog.densityMultiplier = metadata["light"]["fog"]["density"]["multiplier"].as<float>();
+			uniforms->fog.absorbtion = metadata["light"]["fog"]["absorbtion"].as<float>();
+
+			uniforms->fog.range = uf::vector::decode( metadata["light"]["fog"]["range"], uniforms->fog.range );
+
+			uniforms->mode.type.x = metadata["system"]["renderer"]["shader"]["mode"].as<size_t>();
+			uniforms->mode.type.y = metadata["system"]["renderer"]["shader"]["scalar"].as<size_t>();
+			
+			uniforms->mode.parameters = uf::vector::decode( metadata["system"]["renderer"]["shader"]["parameters"], uniforms->mode.parameters );
+			if ( metadata["system"]["renderer"]["shader"]["parameters"][3].as<std::string>() == "time" ) {
+				uniforms->mode.parameters.w = uf::physics::time::current;
+			}
+
+			std::vector<VkImage> previousTextures;
+			for ( auto& texture : graphic.material.textures ) previousTextures.emplace_back(texture.image);
+
+			graphic.material.textures.clear();
+			// add noise texture
+			graphic.material.textures.emplace_back().aliasTexture(this->getComponent<uf::renderer::Texture3D>());
+			graphic.material.textures.emplace_back().aliasTexture(this->getComponent<uf::renderer::TextureCube>());
+
+			size_t updateThreshold = metadata["system"]["config"]["engine"]["scenes"]["lights"]["update threshold"].as<size_t>();
+			size_t maxLights = metadata["system"]["config"]["engine"]["scenes"]["lights"]["max"].as<size_t>();
+			size_t textureSlot = 0;
+
+			std::vector<pod::Light::Storage> lights;
+			lights.reserve( maxLights );
+
+			std::vector<pod::Material::Storage> materials;
+			materials.reserve(maxTextures);
+			materials.emplace_back().colorBase = {0,0,0,0};
+
+			std::vector<pod::Texture::Storage> textures;
+			textures.reserve(maxTextures);
+			
+			std::vector<pod::DrawCall::Storage> drawCalls;
+			drawCalls.reserve(maxTextures);
+
+			// add materials
+			{
+				for ( auto* entity : graphs ) {
+					auto& graph = *entity;
+
+					drawCalls.emplace_back(pod::DrawCall::Storage{
+						materials.size(),
+						graph.materials.size(),
+						textures.size(),
+						graph.textures.size()
+					});
+					
+					for ( auto& material : graph.materials ) materials.emplace_back( material.storage );
+					for ( auto& texture : graph.textures ) textures.emplace_back( texture.storage );
+
+					for ( auto& texture : graph.textures ) {
+						if ( !texture.texture.device ) continue;
+
+						graphic.material.textures.emplace_back().aliasTexture(texture.texture);
+						++textureSlot;
+
+						if ( graph.atlas ) break;
+					}
+				}
+
+				uniforms->lengths.materials = std::min( materials.size(), maxTextures );
+				uniforms->lengths.textures = std::min( textures.size(), maxTextures );
+				uniforms->lengths.drawCalls = std::min( drawCalls.size(), maxTextures );
+			}
+			// add lighting
+			for ( size_t i = 0; i < entities.size() && lights.size() < maxLights; ++i ) {
+				auto& info = entities[i];
+				uf::Entity* entity = info.entity;
+
+				auto& transform = entity->getComponent<pod::Transform<>>();
+				auto& metadata = entity->getComponent<uf::Serializer>();
+				auto& camera = entity->getComponent<uf::Camera>();
+				metadata["system"]["renderer"]["rendered"] = true;
+
+				pod::Light::Storage light;
+				light.position = info.position;
+
+				light.color = uf::vector::decode( metadata["light"]["color"], light.color );
+				light.color.w = metadata["light"]["power"].as<float>();
+
+				if ( metadata["light"]["type"].is<size_t>() ) {
+					light.type = metadata["light"]["type"].as<size_t>();
+				} else if ( metadata["light"]["type"].is<std::string>() ) {
+					std::string lightType = metadata["light"]["type"].as<std::string>();
+					if ( lightType == "point" ) light.type = 1;
+					else if ( lightType == "spot" ) light.type = 2;
+				}
+
+				light.mapIndex = -1;
+
+				light.depthBias = metadata["light"]["bias"]["shader"].as<float>();
+				if ( info.shadows && entity->hasComponent<uf::renderer::RenderTargetRenderMode>() ) {
+					auto& renderMode = entity->getComponent<uf::renderer::RenderTargetRenderMode>();
+					if ( metadata["system"]["renderer"]["mode"].as<std::string>() == "in-range" && --updateThreshold > 0 ) {
+						renderMode.execute = true;
+					}
+					size_t view = 0;
+					for ( auto& attachment : renderMode.renderTarget.attachments ) {
+						if ( !(attachment.descriptor.usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) ) continue;
+						if ( attachment.descriptor.layout == VK_IMAGE_LAYOUT_PRESENT_SRC_KHR ) continue;
+
+						graphic.material.textures.emplace_back().aliasAttachment(attachment);
+
+						light.mapIndex = textureSlot++;
+						light.view = camera.getView(view);
+						light.projection = camera.getProjection(view);
+						lights.emplace_back(light);
+
+						++view;
+					}
+					light.mapIndex = -1;
+				} else {
+					lights.emplace_back(light);
+				}
+				uniforms->lengths.lights = std::min( lights.size(), maxLights );
+			}
+		/*
+			while ( textureSlot++ < maxTextures + 3 ) {
+				graphic.material.textures.emplace_back().aliasTexture(uf::renderer::Texture2D::empty);
+			}
+		*/
+			{
+				bool shouldUpdate = graphic.material.textures.size() != previousTextures.size();
+				for ( size_t i = 0; !shouldUpdate && i < previousTextures.size() && i < graphic.material.textures.size(); ++i ) {
+					if ( previousTextures[i] != graphic.material.textures[i].image )
+						shouldUpdate = true;
+				}
+				
+				size_t lightBufferIndex = renderMode.metadata["lightBufferIndex"].as<size_t>();
+				graphic.updateBuffer( (void*) lights.data(), uniforms->lengths.lights * sizeof(pod::Light::Storage), lightBufferIndex, false );
+				
+				if ( shouldUpdate ) {
+					size_t materialBufferIndex = renderMode.metadata["materialBufferIndex"].as<size_t>();
+					graphic.updateBuffer( (void*) materials.data(), uniforms->lengths.materials * sizeof(pod::Material::Storage), materialBufferIndex, false );
+
+					size_t textureBufferIndex = renderMode.metadata["textureBufferIndex"].as<size_t>();
+					graphic.updateBuffer( (void*) textures.data(), uniforms->lengths.textures * sizeof(pod::Texture::Storage), textureBufferIndex, false );
+					
+					size_t drawCallBufferIndex = renderMode.metadata["drawCallBufferIndex"].as<size_t>();
+					graphic.updateBuffer( (void*) drawCalls.data(), uniforms->lengths.drawCalls * sizeof(pod::DrawCall::Storage), drawCallBufferIndex, false );
+
+					graphic.updatePipelines();
+				}
+				shader.updateUniform( "UBO", uniform );	
+			}
+		}
+	}
+#endif
+}
+void ext::ExtSceneBehavior::render( uf::Object& self ) {}
+void ext::ExtSceneBehavior::destroy( uf::Object& self ) {}
+#undef this
\ No newline at end of file
diff --git a/ext/behaviors/scene/behavior.h b/ext/behaviors/scene/behavior.h
new file mode 100644
index 00000000..4197df0e
--- /dev/null
+++ b/ext/behaviors/scene/behavior.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/ext/ext.h>
+#include <uf/engine/entity/entity.h>
+#include <uf/engine/scene/scene.h>
+
+namespace ext {
+	class EXT_API ExtSceneBehavior {
+	public:
+		static void attach( uf::Object& );
+		static void initialize( uf::Object& );
+		static void tick( uf::Object& );
+		static void render( uf::Object& );
+		static void destroy( uf::Object& );
+	};
+}
\ No newline at end of file
diff --git a/ext/behaviors/scene/collision/behavior.cpp b/ext/behaviors/scene/collision/behavior.cpp
new file mode 100644
index 00000000..5716d63b
--- /dev/null
+++ b/ext/behaviors/scene/collision/behavior.cpp
@@ -0,0 +1,322 @@
+#include "behavior.h"
+
+#include <uf/utils/time/time.h>
+#include <uf/utils/io/iostream.h>
+#include <uf/utils/math/vector.h>
+#include <uf/utils/math/transform.h>
+#include <uf/utils/math/physics.h>
+#include <uf/utils/window/window.h>
+
+#include <uf/utils/audio/audio.h>
+#include <uf/utils/thread/thread.h>
+#include <uf/utils/camera/camera.h>
+
+#include <uf/engine/asset/asset.h>
+#include <uf/engine/asset/masterdata.h>
+
+#include <uf/utils/renderer/renderer.h>
+
+#include <uf/ext/gltf/gltf.h>
+
+#include <uf/utils/math/collision.h>
+
+#include <mutex>
+
+#include <unordered_set>
+
+UF_BEHAVIOR_REGISTER_CPP(ext::SceneCollisionBehavior)
+#define this ((uf::Scene*) &self)
+
+void ext::SceneCollisionBehavior::initialize( uf::Object& self ) {
+	uf::instantiator::bind( "RenderBehavior", *this );
+}
+void ext::SceneCollisionBehavior::tick( uf::Object& self ) {
+#if 0
+	auto& metadata = this->getComponent<uf::Serializer>();
+
+	if ( !metadata["system"]["physics"]["collision"].as<bool>() ) return;
+	if ( this->hasComponent<std::mutex*>() ) {
+		this->getComponent<std::mutex*>()->lock();
+	}
+
+	bool threaded = !metadata["system"]["physics"]["single threaded"].as<bool>();
+	bool sort = metadata["system"]["physics"]["sort"].as<bool>();
+	bool useStrongest = metadata["system"]["physics"]["use"]["strongest"].as<bool>();
+	bool queued = metadata["system"]["physics"]["use"]["queue"].as<bool>();
+	bool updatePhysics = !metadata["system"]["physics"]["optimizations"]["entity-local update"].as<bool>();
+	bool ignoreStaticEntities = metadata["system"]["physics"]["optimizations"]["ignore static entities"].as<bool>();
+	bool ignoreDuplicateTests = metadata["system"]["physics"]["optimizations"]["ignore duplicate tests"].as<bool>();
+	bool useWorkers = metadata["system"]["physics"]["use"]["worker"].as<bool>();
+
+	std::vector<std::function<int()>> jobs;
+	std::vector<uf::Object*> entities; {
+		// update physics
+		if ( updatePhysics ) {
+			this->process([&]( uf::Entity* entity ) {
+				if ( !entity->hasComponent<pod::Physics>() ) return;
+				auto& metadata = entity->getComponent<uf::Serializer>();
+				auto& transform = entity->getComponent<pod::Transform<>>();
+				auto& physics = entity->getComponent<pod::Physics>();
+				if ( ext::json::isNull( metadata["system"]["physics"]["gravity"] ) ) {
+					physics.linear.acceleration.x = metadata["system"]["physics"]["gravity"][0].as<float>();
+					physics.linear.acceleration.y = metadata["system"]["physics"]["gravity"][1].as<float>();
+					physics.linear.acceleration.z = metadata["system"]["physics"]["gravity"][2].as<float>();
+				}
+				if ( !metadata["system"]["physics"]["collision"].as<bool>() )  {
+					physics.linear.acceleration.x = 0;
+					physics.linear.acceleration.y = 0;
+					physics.linear.acceleration.z = 0;
+				}
+				transform = uf::physics::update( transform, physics );
+			});
+		}
+		this->process([&]( uf::Entity* entity ) {
+			if ( !entity ) return;
+			auto& metadata = entity->getComponent<uf::Serializer>();
+			if ( !ext::json::isNull( metadata["system"]["physics"]["collision"] ) && !metadata["system"]["physics"]["collision"].as<bool>() ) return;
+			if ( entity->hasComponent<uf::Collider>() )
+				entities.push_back((uf::Object*) entity);
+		});
+		auto onCollision = []( pod::Collider::Manifold& manifold, size_t uidA, size_t uidB, bool queued ){
+			uf::Serializer payload;
+			payload["normal"][0] = manifold.normal.x;
+			payload["normal"][1] = manifold.normal.y;
+			payload["normal"][2] = manifold.normal.z;
+			payload["entity"] = uidB;
+			payload["depth"] = -manifold.depth;
+
+			auto& scene = uf::scene::getCurrentScene();
+			if ( queued ) scene.queueHook(uf::Object::formatHookName("world:Collision.%UID%",uidA), payload);
+			else scene.callHook(uf::Object::formatHookName("world:Collision.%UID%",uidA), payload);
+			
+			payload["entity"] = uidA;
+			payload["depth"] = manifold.depth;
+			if ( queued ) scene.queueHook(uf::Object::formatHookName("world:Collision.%UID%",uidB), payload);
+			else scene.callHook(uf::Object::formatHookName("world:Collision.%UID%",uidB), payload);
+		};
+		auto testColliders = [&]( uf::Collider& colliderA, uf::Collider& colliderB, size_t uidA, size_t uidB, bool useStrongest ){
+			pod::Collider::Manifold strongest;
+			auto manifolds = colliderA.intersects(colliderB);
+			for ( auto manifold : manifolds ) {
+				if ( manifold.colliding && manifold.depth > 0 ) {
+					if ( !useStrongest ) onCollision(manifold, uidA, uidB, queued);
+					else if ( strongest.depth < manifold.depth ) strongest = manifold;
+				}
+			}
+			if ( useStrongest && strongest.colliding ) onCollision(strongest, uidA, uidB, queued);
+		};
+		// collide with others
+		if ( ignoreDuplicateTests ) {
+			struct Pair {
+				uf::Object* a = NULL;
+				uf::Object* b = NULL;
+			};
+			std::unordered_map<std::string, Pair> queued;
+			for ( auto* _a : entities ) {
+				uf::Object& entityA = *_a;
+				if ( ignoreStaticEntities && !entityA.hasComponent<pod::Physics>() ) continue;
+				for ( auto* _b : entities ) { if ( _a == _b ) continue;
+					uf::Object& entityB = *_b;
+
+					std::string hash = std::to_string(std::min( entityA.getUid(), entityB.getUid() )) + ":" + std::to_string(std::max( entityA.getUid(), entityB.getUid() ));
+					if ( queued.count(hash) > 0 ) continue;
+
+					queued[hash] = {
+						.a = _a,
+						.b = _b,
+					};
+				}
+			}
+			for ( auto& pair : queued ) {
+				auto* entityA = pair.second.a;
+				auto* entityB = pair.second.b;
+				auto& colliderA = entityA->getComponent<uf::Collider>();
+				auto& colliderB = entityB->getComponent<uf::Collider>();
+				size_t uidA = entityA->getUid();
+				size_t uidB = entityB->getUid();
+				auto function = [&, uidA, uidB]() -> int {
+					testColliders( colliderA, colliderB, uidA, uidB, useStrongest );
+					return 0;
+				};
+				if ( threaded && useWorkers ) jobs.emplace_back(function); else function();
+			}
+		} else {
+			for ( auto* _a : entities ) {
+				uf::Object& entityA = *_a;
+				size_t uidA = entityA.getUid();
+				if ( ignoreStaticEntities && !entityA.hasComponent<pod::Physics>() ) continue;
+				for ( auto* _b : entities ) { if ( _a == _b ) continue;
+					uf::Object& entityB = *_b;
+					auto& colliderA = entityA.getComponent<uf::Collider>();
+					auto& colliderB = entityB.getComponent<uf::Collider>();
+					size_t uidB = entityB.getUid();
+					auto function = [&, uidA, uidB]() -> int {
+						testColliders( colliderA, colliderB, uidA, uidB, useStrongest );
+						return 0;
+					};
+					if ( threaded && useWorkers ) jobs.emplace_back(function); else function();
+				}
+			}
+		}
+	}
+	if ( !jobs.empty() ) {
+		if ( threaded ) uf::thread::batchWorkers( jobs );
+		else {
+			for ( auto& fun : jobs ) fun();
+		}
+	}
+	if ( this->hasComponent<std::mutex*>() ) {
+		this->getComponent<std::mutex*>()->lock();
+	}
+#endif
+/*
+	pod::Thread& thread = uf::thread::has("Physics") ? uf::thread::get("Physics") : uf::thread::create( "Physics", true, false );
+	auto function = [&]() -> int {
+		std::vector<uf::Object*> entities;
+		// update physics
+		if ( updatePhysics ) {
+			this->process([&]( uf::Entity* entity ) {
+				if ( !entity->hasComponent<pod::Physics>() ) return;
+				auto& metadata = entity->getComponent<uf::Serializer>();
+				auto& transform = entity->getComponent<pod::Transform<>>();
+				auto& physics = entity->getComponent<pod::Physics>();
+				if ( ext::json::isNull( metadata["system"]["physics"]["gravity"] ) ) {
+					physics.linear.acceleration.x = metadata["system"]["physics"]["gravity"][0].as<float>();
+					physics.linear.acceleration.y = metadata["system"]["physics"]["gravity"][1].as<float>();
+					physics.linear.acceleration.z = metadata["system"]["physics"]["gravity"][2].as<float>();
+				}
+				if ( !metadata["system"]["physics"]["collision"].as<bool>() )  {
+					physics.linear.acceleration.x = 0;
+					physics.linear.acceleration.y = 0;
+					physics.linear.acceleration.z = 0;
+				}
+				transform = uf::physics::update( transform, physics );
+			});
+		}
+		this->process([&]( uf::Entity* entity ) {
+			if ( !entity ) return;
+			auto& metadata = entity->getComponent<uf::Serializer>();
+			if ( !ext::json::isNull( metadata["system"]["physics"]["collision"] ) && !metadata["system"]["physics"]["collision"].as<bool>() ) return;
+			if ( entity->hasComponent<uf::Collider>() )
+				entities.push_back((uf::Object*) entity);
+		});
+		auto onCollision = []( pod::Collider::Manifold& manifold, size_t uidA, size_t uidB, bool queued ){
+			uf::Serializer payload;
+			payload["normal"][0] = manifold.normal.x;
+			payload["normal"][1] = manifold.normal.y;
+			payload["normal"][2] = manifold.normal.z;
+			payload["entity"] = uidB;
+			payload["depth"] = -manifold.depth;
+
+			auto& scene = uf::scene::getCurrentScene();
+			if ( queued ) scene.queueHook(uf::Object::formatHookName("world:Collision.%UID%",uidA), payload);
+			else scene.callHook(uf::Object::formatHookName("world:Collision.%UID%",uidA), payload);
+			
+			payload["entity"] = uidA;
+			payload["depth"] = manifold.depth;
+			if ( queued ) scene.queueHook(uf::Object::formatHookName("world:Collision.%UID%",uidB), payload);
+			else scene.callHook(uf::Object::formatHookName("world:Collision.%UID%",uidB), payload);
+		};
+		auto testColliders = [&]( uf::Collider& colliderA, uf::Collider& colliderB, size_t uidA, size_t uidB, bool useStrongest ){
+			pod::Collider::Manifold strongest;
+			auto manifolds = colliderA.intersects(colliderB);
+			for ( auto manifold : manifolds ) {
+				if ( manifold.colliding && manifold.depth > 0 ) {
+					if ( !useStrongest ) onCollision(manifold, uidA, uidB, queued);
+					else if ( strongest.depth < manifold.depth ) strongest = manifold;
+				}
+			}
+			if ( useStrongest && strongest.colliding ) onCollision(strongest, uidA, uidB, queued);
+		};
+		// collide with others
+		if ( ignoreDuplicateTests ) {
+			struct Pair {
+				uf::Object* a = NULL;
+				uf::Object* b = NULL;
+			};
+			std::unordered_map<std::string, Pair> queued;
+			for ( auto* _a : entities ) {
+				uf::Object& entityA = *_a;
+				if ( ignoreStaticEntities && !entityA.hasComponent<pod::Physics>() ) continue;
+				for ( auto* _b : entities ) { if ( _a == _b ) continue;
+					uf::Object& entityB = *_b;
+
+					std::string hash = std::to_string(std::min( entityA.getUid(), entityB.getUid() )) + ":" + std::to_string(std::max( entityA.getUid(), entityB.getUid() ));
+					if ( queued.count(hash) > 0 ) continue;
+
+					queued[hash] = {
+						.a = _a,
+						.b = _b,
+					};
+				}
+			}
+			for ( auto& pair : queued ) {
+				auto* entityA = pair.second.a;
+				auto* entityB = pair.second.b;
+				auto& colliderA = entityA->getComponent<uf::Collider>();
+				auto& colliderB = entityB->getComponent<uf::Collider>();
+				auto function = [&]() -> int {
+					testColliders( colliderA, colliderB, entityA->getUid(), entityB->getUid(), useStrongest );
+					return 0;
+				};
+				if ( threaded && useWorkers ) uf::thread::add( uf::thread::fetchWorker(), function, true ); else function();
+			}
+		} else {
+			for ( auto* _a : entities ) {
+				uf::Object& entityA = *_a;
+				if ( ignoreStaticEntities && !entityA.hasComponent<pod::Physics>() ) continue;
+				for ( auto* _b : entities ) { if ( _a == _b ) continue;
+					uf::Object& entityB = *_b;
+					auto& colliderA = entityA.getComponent<uf::Collider>();
+					auto& colliderB = entityB.getComponent<uf::Collider>();
+					auto function = [&]() -> int {
+						testColliders( colliderA, colliderB, entityA.getUid(), entityB.getUid(), useStrongest );
+						return 0;
+					};
+					if ( threaded && useWorkers ) uf::thread::add( uf::thread::fetchWorker(), function, true ); else function();
+				}
+			}
+		}
+		mutex.unlock();
+		return 0;
+	};
+	if ( threaded ) uf::thread::add( thread, function, true ); else function();
+*/
+}
+
+void ext::SceneCollisionBehavior::render( uf::Object& self ){}
+void ext::SceneCollisionBehavior::destroy( uf::Object& self ){
+/*
+	{
+		for ( int i = ext::bullet::dynamicsWorld->getNumCollisionObjects() - 1; i >= 0; i--) {
+			btCollisionObject* obj = ext::bullet::dynamicsWorld->getCollisionObjectArray()[i];
+			btRigidBody* body = btRigidBody::upcast(obj);
+			if (body && body->getMotionState()) {
+				delete body->getMotionState();
+			}
+			ext::bullet::dynamicsWorld->removeCollisionObject(obj);
+			delete obj;
+		}
+		for ( size_t i = 0; i < ext::bullet::collisionShapes.size(); ++i ) {
+			btCollisionShape* shape = ext::bullet::collisionShapes[i];
+			ext::bullet::collisionShapes[i] = NULL;
+			delete shape;
+		}
+
+		delete ext::bullet::dynamicsWorld;
+		delete ext::bullet::solver;
+		delete ext::bullet::overlappingPairCache;
+		delete ext::bullet::dispatcher;
+		delete ext::bullet::collisionConfiguration;
+		ext::bullet::collisionShapes.clear();
+	}
+*/
+#if 0
+	{
+		auto& mutexPointer = this->getComponent<std::mutex*>();
+		delete mutexPointer;
+		mutexPointer = NULL;
+	}
+#endif
+}
+#undef this
\ No newline at end of file
diff --git a/ext/behaviors/scene/collision/behavior.h b/ext/behaviors/scene/collision/behavior.h
new file mode 100644
index 00000000..6de63e13
--- /dev/null
+++ b/ext/behaviors/scene/collision/behavior.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/ext/ext.h>
+#include <uf/engine/entity/entity.h>
+#include <uf/engine/scene/scene.h>
+
+namespace ext {
+	class EXT_API SceneCollisionBehavior {
+	public:
+		static void attach( uf::Object& );
+		static void initialize( uf::Object& );
+		static void tick( uf::Object& );
+		static void render( uf::Object& );
+		static void destroy( uf::Object& );
+	};
+}
\ No newline at end of file
diff --git a/ext/behaviors/soundemitter/behavior.cpp b/ext/behaviors/soundemitter/behavior.cpp
new file mode 100644
index 00000000..53fa40da
--- /dev/null
+++ b/ext/behaviors/soundemitter/behavior.cpp
@@ -0,0 +1,119 @@
+#include "behavior.h"
+
+#include <uf/utils/serialize/serializer.h>
+
+#include <uf/utils/audio/audio.h>
+#include <uf/utils/math/transform.h>
+#include <uf/engine/asset/asset.h>
+
+#include <mutex>
+
+UF_BEHAVIOR_REGISTER_CPP(ext::SoundEmitterBehavior)
+#define this ((uf::Object*) &self)
+
+void ext::SoundEmitterBehavior::initialize( uf::Object& self ) {
+	auto& metadata = this->getComponent<uf::Serializer>();
+	auto& emitter = this->getComponent<uf::SoundEmitter>();
+	auto& sounds = emitter.get();
+	
+	auto& scene = uf::scene::getCurrentScene();
+	auto& sMetadata = scene.getComponent<uf::Serializer>();
+	auto& assetLoader = scene.getComponent<uf::Asset>();
+
+	if ( !metadata["audio"]["epsilon"].is<float>() )
+		metadata["audio"]["epsilon"] = 0.001f;
+
+	// auto& sounds = this->getComponent<std::vector<uf::Audio*>>();
+	this->addHook( "sound:Stop.%UID%", [&](ext::json::Value& json){
+		std::string filename = json["filename"].as<std::string>();
+		for ( size_t i = 0; i < sounds.size(); ++i ) {
+			if ( sounds[i]->getFilename() != filename ) continue;
+			sounds[i]->destroy();
+			delete sounds[i];
+			sounds.erase(sounds.begin() + i);
+			metadata["sounds"].erase(i);
+		}
+	});
+	this->addHook( "sound:Emit.%UID%", [&](ext::json::Value& json){
+		if ( ext::json::isNull(json["volume"]) ) json["volume"] = metadata["audio"]["volume"];
+		if ( ext::json::isNull(json["pitch"]) ) json["pitch"] = metadata["audio"]["pitch"];
+		if ( ext::json::isNull(json["gain"]) ) json["gain"] = metadata["audio"]["gain"];
+		if ( ext::json::isNull(json["rolloffFactor"]) ) json["rolloffFactor"] = metadata["audio"]["rolloffFactor"];
+		if ( ext::json::isNull(json["maxDistance"]) ) json["maxDistance"] = metadata["audio"]["maxDistance"];
+		if ( ext::json::isNull(json["epsilon"]) ) json["epsilon"] = metadata["audio"]["epsilon"];
+
+		metadata["sounds"].emplace_back(json);
+		uf::Audio& audio = emitter.add( json["filename"].as<std::string>(), json["unique"].as<bool>() );
+
+		{
+			float volume = 1.0f; 
+			if ( json["volume"].is<double>() ) {
+				volume = json["volume"].as<float>();
+			} else if ( json["volume"].is<std::string>() ) {
+				std::string key = json["volume"].as<std::string>();
+				if ( sMetadata["volumes"][key].is<double>() ) {
+					volume = sMetadata["volumes"][key].as<float>();
+				}
+			}
+			audio.setVolume(volume);
+		}
+		if ( json["pitch"].is<double>() ) audio.setPitch(json["pitch"].as<float>());
+		if ( json["gain"].is<double>() ) audio.setGain(json["gain"].as<float>());
+		if ( json["rolloffFactor"].is<double>() ) audio.setRolloffFactor(json["rolloffFactor"].as<float>());
+		if ( json["maxDistance"].is<double>() ) audio.setMaxDistance(json["maxDistance"].as<float>());
+
+		audio.play();
+	});
+	this->addHook( "asset:Load.%UID%", [&](ext::json::Value& json){
+		std::string filename = json["filename"].as<std::string>();
+		std::string category = json["category"].as<std::string>();
+
+		if ( category != "" && category != "audio" ) return;
+		if ( category == "" && uf::io::extension(filename) != "ogg" ) return;
+		const uf::Audio* audioPointer = NULL;
+		if ( !assetLoader.has<uf::Audio>(filename) ) return;
+		audioPointer = &assetLoader.get<uf::Audio>(filename);
+		if ( !audioPointer ) return;
+
+		uf::Serializer payload = metadata["audio"];
+		payload["filename"] = filename;
+		this->callHook("sound:Emit.%UID%", payload);
+	});
+}
+void ext::SoundEmitterBehavior::tick( uf::Object& self ) {
+	auto& transform = this->getComponent<pod::Transform<>>();
+	auto flatten = uf::transform::flatten( transform );
+
+	auto& metadata = this->getComponent<uf::Serializer>();
+	auto& emitter = this->getComponent<uf::SoundEmitter>();
+	auto& sounds = emitter.get();
+
+	for ( size_t i = 0; i < sounds.size(); ++i ) {
+		auto& audio = *sounds[i];
+		auto& json = metadata["sounds"][i];
+
+		if ( json["spatial"].as<bool>() && audio.playing() ) {
+			audio.setPosition( flatten.position );
+			audio.setOrientation( flatten.orientation );
+		}
+
+		if ( json["loop"].as<bool>() ) {
+			float current = audio.getTime();
+			float end = audio.getDuration();
+			float epsilon = json["epsilon"].is<float>() ? json["epsilon"].as<float>() : 0.005f;
+			if ( current + epsilon >= end || !audio.playing() ) {
+				audio.setTime(0);
+				if ( !audio.playing() ) audio.play();
+			}
+		} else if ( !audio.playing() ) {
+			audio.destroy();
+			delete sounds[i];
+			sounds.erase(sounds.begin() + i);
+			metadata["sounds"].erase(i);
+		}
+	}
+}
+
+void ext::SoundEmitterBehavior::render( uf::Object& self ){}
+void ext::SoundEmitterBehavior::destroy( uf::Object& self ){}
+#undef this
\ No newline at end of file
diff --git a/ext/behaviors/soundemitter/behavior.h b/ext/behaviors/soundemitter/behavior.h
new file mode 100644
index 00000000..f504ee82
--- /dev/null
+++ b/ext/behaviors/soundemitter/behavior.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/ext/ext.h>
+#include <uf/engine/entity/entity.h>
+#include <uf/engine/scene/scene.h>
+
+namespace ext {
+	class EXT_API SoundEmitterBehavior {
+	public:
+		static void attach( uf::Object& );
+		static void initialize( uf::Object& );
+		static void tick( uf::Object& );
+		static void render( uf::Object& );
+		static void destroy( uf::Object& );
+	};
+}
\ No newline at end of file
diff --git a/ext/behaviors/sprite/behavior.cpp b/ext/behaviors/sprite/behavior.cpp
new file mode 100644
index 00000000..cc559cd6
--- /dev/null
+++ b/ext/behaviors/sprite/behavior.cpp
@@ -0,0 +1,113 @@
+#include "behavior.h"
+
+#include <uf/utils/hook/hook.h>
+#include <uf/utils/time/time.h>
+#include <uf/utils/serialize/serializer.h>
+#include <uf/utils/userdata/userdata.h>
+#include <uf/utils/graphic/mesh.h>
+#include <uf/utils/graphic/graphic.h>
+#include <uf/utils/window/window.h>
+#include <uf/utils/camera/camera.h>
+
+#include <uf/utils/renderer/renderer.h>
+
+#include <uf/utils/image/image.h>
+
+#include <uf/engine/asset/asset.h>
+#include "../../scenes/worldscape//battle.h"
+#include "../../scenes/worldscape//.h"
+
+namespace {
+	uf::Serializer masterTableGet( const std::string& table ) {
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Serializer& mastertable = scene.getComponent<uf::Serializer>();
+		return mastertable["system"]["mastertable"][table];
+	}
+	uf::Serializer masterDataGet( const std::string& table, const std::string& key ) {
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Serializer& mastertable = scene.getComponent<uf::Serializer>();
+		return mastertable["system"]["mastertable"][table][key];
+	}
+	inline int64_t parseInt( const std::string& str ) {
+		return atoi(str.c_str());
+	}
+}
+
+UF_BEHAVIOR_REGISTER_CPP(ext::HousamoSpriteBehavior)
+#define this (&self)
+void ext::HousamoSpriteBehavior::initialize( uf::Object& self ) {
+	uf::Scene& scene = uf::scene::getCurrentScene();
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	uf::Serializer& masterdata = scene.getComponent<uf::Serializer>();
+	uf::Asset& assetLoader = scene.getComponent<uf::Asset>();
+
+	this->addHook( "graphics:Assign.%UID%", [&](ext::json::Value& json){
+		metadata["system"]["control"] = false;
+		std::string filename = json["filename"].as<std::string>();
+		std::string category = json["category"].as<std::string>();
+
+		if ( category != "" && category != "images" ) return;
+		if ( category == "" && uf::io::extension(filename) != "png" && uf::io::extension(filename) != "jpg" && uf::io::extension(filename) != "jpeg" ) return;
+
+		uf::Scene& scene = this->getRootParent<uf::Scene>();
+		uf::Asset& assetLoader = scene.getComponent<uf::Asset>();
+		const uf::Image* imagePointer = NULL;
+		if ( !assetLoader.has<uf::Image>(filename) ) return;
+		imagePointer = &assetLoader.get<uf::Image>(filename);
+		if ( !imagePointer ) return;
+
+		uf::Image image = *imagePointer;
+		uf::Mesh& mesh = this->getComponent<uf::Mesh>();
+		auto& graphic = this->getComponent<uf::Graphic>();
+		mesh.vertices = {
+			{{-1*-0.5f, 0.0f, 0.0f}, {1.0f, 0.0f}, { 0.0f, 0.0f, -1.0f } },
+			{{-1*0.5f, 0.0f, 0.0f}, {0.0f, 0.0f}, { 0.0f, 0.0f, -1.0f } },
+			{{-1*0.5f, 1.0f, 0.0f}, {0.0f, 1.0f}, { 0.0f, 0.0f, -1.0f } },
+			{{-1*0.5f, 1.0f, 0.0f}, {0.0f, 1.0f}, { 0.0f, 0.0f, -1.0f } },
+			{{-1*-0.5f, 1.0f, 0.0f}, {1.0f, 1.0f}, { 0.0f, 0.0f, -1.0f } },
+			{{-1*-0.5f, 0.0f, 0.0f}, {1.0f, 0.0f}, { 0.0f, 0.0f, -1.0f } },
+
+			{{-1*0.5f, 1.0f, 0.0f}, {0.0f, 1.0f}, { 0.0f, 0.0f, 1.0f } },
+			{{-1*0.5f, 0.0f, 0.0f}, {0.0f, 0.0f}, { 0.0f, 0.0f, 1.0f } },
+			{{-1*-0.5f, 0.0f, 0.0f}, {1.0f, 0.0f}, { 0.0f, 0.0f, 1.0f } },
+			{{-1*-0.5f, 0.0f, 0.0f}, {1.0f, 0.0f}, { 0.0f, 0.0f, 1.0f } },
+			{{-1*-0.5f, 1.0f, 0.0f}, {1.0f, 1.0f}, { 0.0f, 0.0f, 1.0f } },
+			{{-1*0.5f, 1.0f, 0.0f}, {0.0f, 1.0f}, { 0.0f, 0.0f, 1.0f } },
+		};
+
+		graphic.initialize();
+		graphic.initializeMesh( mesh );
+
+		auto& texture = graphic.material.textures.emplace_back();
+		texture.loadFromImage( image );
+
+		graphic.material.attachShader(uf::io::root+"/shaders/base/vert.spv", uf::renderer::enums::Shader::VERTEX);
+		graphic.material.attachShader(uf::io::root+"/shaders/base/frag.spv", uf::renderer::enums::Shader::FRAGMENT);
+
+		metadata["system"]["control"] = true;
+		metadata["system"]["loaded"] = true;
+	});
+	this->addHook( "asset:Load.%UID%", [&](ext::json::Value& json){
+		this->queueHook("graphics:Assign.%UID%", json, 0.0f);
+	});
+
+	{
+		std::string id = metadata[""]["party"][0].as<std::string>();
+		uf::Serializer member = metadata[""]["transients"][id];
+		uf::Serializer cardData = masterDataGet("Card", id);
+		std::string name = cardData["filename"].as<std::string>();
+		if ( member["skin"].is<std::string>() ) name += "_" + member["skin"].as<std::string>();
+		std::string filename = "https://cdn..xyz//unity/Android/fg/fg_" + name + ".png";
+		if ( cardData["internal"].as<bool>() ) {
+			filename = uf::io::root+"/smtsamo/fg/fg_" + name + ".png";
+		}
+		
+		metadata["orientation"] = cardData["orientation"].as<std::string>() == "" ? "portrait" : "landscape";
+		
+		assetLoader.load(filename, "asset:Load." + std::to_string(this->getUid()) );
+	}
+}
+void ext::HousamoSpriteBehavior::tick( uf::Object& self ) {}
+void ext::HousamoSpriteBehavior::render( uf::Object& self ){}
+void ext::HousamoSpriteBehavior::destroy( uf::Object& self ){}
+#undef this
\ No newline at end of file
diff --git a/ext/behaviors/sprite/behavior.h b/ext/behaviors/sprite/behavior.h
new file mode 100644
index 00000000..8d8be2b1
--- /dev/null
+++ b/ext/behaviors/sprite/behavior.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/ext/ext.h>
+#include <uf/engine/entity/entity.h>
+#include <uf/engine/scene/scene.h>
+
+namespace ext {
+	class EXT_API HousamoSpriteBehavior {
+	public:
+		static void attach( uf::Object& );
+		static void initialize( uf::Object& );
+		static void tick( uf::Object& );
+		static void render( uf::Object& );
+		static void destroy( uf::Object& );
+	};
+}
\ No newline at end of file
diff --git a/ext/ext.h b/ext/ext.h
new file mode 100644
index 00000000..60fa21dd
--- /dev/null
+++ b/ext/ext.h
@@ -0,0 +1,10 @@
+#pragma once
+
+#include <fstream>
+
+#include <uf/utils/string/string.h>
+#include <uf/utils/io/iostream.h>
+#include <uf/utils/math/vector.h>
+#include <uf/utils/time/time.h>
+#include <uf/utils/string/ext.h>
+#include <uf/utils/serialize/serializer.h>
\ No newline at end of file
diff --git a/ext/gui/behavior.cpp b/ext/gui/behavior.cpp
new file mode 100644
index 00000000..c778a802
--- /dev/null
+++ b/ext/gui/behavior.cpp
@@ -0,0 +1,1089 @@
+#include "behavior.h"
+#include "gui.h"
+
+#include <uf/utils/hook/hook.h>
+#include <uf/utils/image/atlas.h>
+#include <uf/utils/time/time.h>
+#include <uf/utils/serialize/serializer.h>
+#include <uf/utils/userdata/userdata.h>
+#include <uf/utils/window/window.h>
+#include <uf/utils/camera/camera.h>
+#include <uf/utils/graphic/mesh.h>
+#include <uf/utils/graphic/graphic.h>
+#include <uf/utils/string/ext.h>
+#include <uf/utils/math/physics.h>
+
+#include <uf/utils/text/glyph.h>
+#include <uf/engine/asset/asset.h>
+#include <uf/engine/scene/scene.h>
+
+#include <unordered_map>
+#include <locale>
+#include <codecvt>
+
+#include <uf/utils/renderer/renderer.h>
+#include <uf/ext/openvr/openvr.h>
+
+#include <uf/utils/http/http.h>
+#include <uf/utils/audio/audio.h>
+#include <sys/stat.h>
+#include <fstream>
+
+#include <regex>
+
+namespace {
+#if UF_USE_FREETYPE
+	struct {
+		ext::freetype::Glyph glyph;
+		std::unordered_map<std::string, std::unordered_map<std::string, uf::Glyph>> cache;
+	} glyphs;
+#endif
+
+#if UF_USE_OPENGL
+	std::string defaultRenderMode = "";
+#else
+	std::string defaultRenderMode = "Gui";
+#endif
+	uf::Serializer defaultSettings;
+}
+
+ext::Gui::Gui(){
+	this->addBehavior<ext::GuiBehavior>();
+}
+
+std::vector<pod::GlyphBox> ext::Gui::generateGlyphs( const std::string& _string ) {
+	std::vector<pod::GlyphBox> gs;
+#if UF_USE_FREETYPE
+	uf::Object& gui = *this;
+	std::string string = _string;
+	uf::Serializer& metadata = gui.getComponent<uf::Serializer>();
+	std::string font = uf::io::root+"/fonts/" + metadata["text settings"]["font"].as<std::string>();
+	if ( ::glyphs.cache[font].empty() ) {
+		ext::freetype::initialize( ::glyphs.glyph, font );
+	}
+	if ( string == "" ) {
+		string = metadata["text settings"]["string"].as<std::string>();
+	}
+	pod::Transform<>& transform = gui.getComponent<pod::Transform<>>();
+	struct {
+		struct {
+			float x = 0;
+			float y = 0;
+		} origin;
+		struct {
+			float x = 0;
+			float y = 0;
+		} cursor;
+		struct {
+			float sum = 0;
+			float len = 0;
+			float proc = 0;
+			float tab = 4;
+		} average;
+		
+		struct {
+			float x = 0;
+			float y = 0;
+		} biggest;
+
+		struct {
+			float w = 0;
+			float h = 0;
+		} box;
+
+		struct {
+			std::vector<pod::Vector3f> container;
+			std::size_t index = 0;
+		} colors;
+	} stat;
+
+	float scale = metadata["text settings"]["scale"].as<float>();
+
+	{
+		pod::Vector3f color = {
+			metadata["text settings"]["color"][0].as<float>(),
+			metadata["text settings"]["color"][1].as<float>(),
+			metadata["text settings"]["color"][2].as<float>(),
+		};
+		stat.colors.container.push_back(color);
+	}
+
+	unsigned long COLORCONTROL = 0x7F;
+
+	{
+		std::string text = string;
+		std::regex regex("\\%\\#([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})\\%");
+		std::unordered_map<size_t, pod::Vector3f> colors;
+		std::smatch match;
+		bool matched = false;
+		int maxTries = 128;
+		while ( (matched = std::regex_search( text, match, regex )) && --maxTries > 0 ) {
+			struct {
+				std::string str;
+				int dec;
+			} r, g, b;
+			r.str = match[1].str();
+			g.str = match[2].str();
+			b.str = match[3].str();
+			
+			{ std::stringstream stream; stream << r.str; stream >> std::hex >> r.dec; } 
+			{ std::stringstream stream; stream << g.str; stream >> std::hex >> g.dec; } 
+			{ std::stringstream stream; stream << b.str; stream >> std::hex >> b.dec; } 
+
+			pod::Vector3f color = { r.dec / 255.0f, g.dec / 255.0f, b.dec / 255.0f };
+
+			stat.colors.container.push_back(color);
+			text = uf::string::replace( text, "%#" + r.str + g.str + b.str + "%", "\x7F" );
+		}
+		if ( maxTries == 0 ) {
+			text += "\n(error formatting)";
+		}
+		string = text;
+	}
+
+	std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>, wchar_t> convert;
+	std::wstring str = convert.from_bytes(string);
+	if ( str.size() == 0 ) return gs;
+
+	// Calculate statistics
+	{
+		// Find tallest glyph for new line
+		for ( auto it = str.begin(); it != str.end(); ++it ) {
+			unsigned long c = *it; if ( c == '\n' ) continue; if ( c == '\t' ) continue; if ( c == 0x01 ) continue;
+			std::string key = ""; {
+				key += std::to_string(c) + ";";
+				key += metadata["text settings"]["padding"][0].as<std::string>() + ",";
+				key += metadata["text settings"]["padding"][1].as<std::string>() + ";";
+				key += metadata["text settings"]["spread"].as<std::string>() + ";";
+				key += metadata["text settings"]["size"].as<std::string>() + ";";
+				key += metadata["text settings"]["font"].as<std::string>() + ";";
+				key += metadata["text settings"]["sdf"].as<std::string>();
+			}
+			uf::Glyph& glyph = ::glyphs.cache[font][key];
+
+			if ( !glyph.generated() ) {
+				glyph.setPadding( { metadata["text settings"]["padding"][0].as<size_t>(), metadata["text settings"]["padding"][1].as<size_t>() } );
+				glyph.setSpread( metadata["text settings"]["spread"].as<size_t>() );
+				if ( metadata["text settings"]["sdf"].as<bool>() ) glyph.useSdf(true);
+				glyph.generate( ::glyphs.glyph, c, metadata["text settings"]["size"].as<int>() );
+			}
+			
+			stat.biggest.x = std::max( (float) stat.biggest.x, (float) glyph.getSize().x);
+			stat.biggest.y = std::max( (float) stat.biggest.y, (float) glyph.getSize().y);
+
+			stat.average.sum += glyph.getSize().x;
+			++stat.average.len;
+		}
+		stat.average.proc = stat.average.sum / stat.average.len;
+		stat.average.tab *= stat.average.proc;
+
+		// Calculate box: Second pass required because of tab
+		stat.cursor.x = 0;
+		stat.cursor.y = 0;
+		stat.origin.x = 0;
+		stat.origin.y = 0;
+
+		for ( auto it = str.begin(); it != str.end(); ++it ) {
+			unsigned long c = *it; if ( c == '\n' ) {
+				stat.cursor.y += stat.biggest.y;
+				stat.cursor.x = 0;
+				continue;
+			} else if ( c == '\t' ) {
+				// Fixed movement vs Real Tabbing
+				if ( false ) {
+					stat.cursor.x += stat.average.tab;
+				} else {
+					stat.cursor.x = ((stat.cursor.x / stat.average.tab) + 1) * stat.average.tab;
+				}
+				continue;
+			} else if ( c == COLORCONTROL ) {
+				continue;
+			}
+			std::string key = ""; {
+				key += std::to_string(c) + ";";
+				key += metadata["text settings"]["padding"][0].as<std::string>() + ",";
+				key += metadata["text settings"]["padding"][1].as<std::string>() + ";";
+				key += metadata["text settings"]["spread"].as<std::string>() + ";";
+				key += metadata["text settings"]["size"].as<std::string>() + ";";
+				key += metadata["text settings"]["font"].as<std::string>() + ";";
+				key += metadata["text settings"]["sdf"].as<std::string>();
+			}
+			uf::Glyph& glyph = ::glyphs.cache[font][key];
+			pod::GlyphBox g;
+
+			g.box.w = glyph.getSize().x;
+			g.box.h = glyph.getSize().y;
+				
+			g.box.x = stat.cursor.x + glyph.getBearing().x;
+			g.box.y = stat.cursor.y - glyph.getBearing().y; // - (glyph.getSize().y - glyph.getBearing().y);
+
+			stat.cursor.x += (glyph.getAdvance().x);
+		}
+
+		stat.origin.x = ( !metadata["text settings"]["world"].as<bool>() && transform.position.x != (int) transform.position.x ) ? transform.position.x * ext::gui::size.current.x : transform.position.x;
+		stat.origin.y = ( !metadata["text settings"]["world"].as<bool>() && transform.position.y != (int) transform.position.y ) ? transform.position.y * ext::gui::size.current.y : transform.position.y;
+
+	
+		if ( ext::json::isArray( metadata["text settings"]["origin"] ) ) {
+			stat.origin.x = metadata["text settings"]["origin"][0].as<int>();
+			stat.origin.y = metadata["text settings"]["origin"][1].as<int>();
+		}
+		else if ( metadata["text settings"]["origin"] == "top" ) stat.origin.y = ext::gui::size.current.y - stat.origin.y - stat.biggest.y;// else stat.origin.y = stat.origin.y;
+		if ( metadata["text settings"]["align"] == "right" ) stat.origin.x = ext::gui::size.current.x - stat.origin.x - stat.box.w;// else stat.origin.x = stat.origin.x;
+		else if ( metadata["text settings"]["align"] == "center" )
+			stat.origin.x -= stat.box.w * 0.5f;
+	}
+
+	// Render Glyphs
+	stat.cursor.x = 0;
+	stat.cursor.y = stat.biggest.y;
+	for ( auto it = str.begin(); it != str.end(); ++it ) {
+		unsigned long c = *it; if ( c == '\n' ) {
+			if ( metadata["text settings"]["direction"] == "down" ) stat.cursor.y -= stat.biggest.y; else stat.cursor.y += stat.biggest.y;
+			stat.cursor.x = 0;
+			continue;
+		} else if ( c == '\t' ) {
+			// Fixed movement vs Real Tabbing
+			if ( false ) {
+				stat.cursor.x += stat.average.tab;
+			} else {
+				stat.cursor.x = ((stat.cursor.x / stat.average.tab) + 1) * stat.average.tab;
+			}
+			continue;
+		} else if ( c == ' ' ) {
+			stat.cursor.x += stat.average.tab / 4.0f;
+			continue;
+		} else if ( c == COLORCONTROL ) {
+			++stat.colors.index;
+			continue;
+		}
+		std::string key = ""; {
+			key += std::to_string(c) + ";";
+			key += metadata["text settings"]["padding"][0].as<std::string>() + ",";
+			key += metadata["text settings"]["padding"][1].as<std::string>() + ";";
+			key += metadata["text settings"]["spread"].as<std::string>() + ";";
+			key += metadata["text settings"]["size"].as<std::string>() + ";";
+			key += metadata["text settings"]["font"].as<std::string>() + ";";
+			key += metadata["text settings"]["sdf"].as<std::string>();
+		}
+		uf::Glyph& glyph = ::glyphs.cache[font][key];
+
+		pod::GlyphBox g;
+		g.code = c;
+
+		g.box.w = glyph.getSize().x;
+		g.box.h = glyph.getSize().y;
+			
+		g.box.x = stat.cursor.x + (glyph.getBearing().x);
+		g.box.y = stat.cursor.y - glyph.getBearing().y; // - (glyph.getSize().y - glyph.getBearing().y);
+
+		stat.cursor.x += (glyph.getAdvance().x);
+
+		if ( stat.colors.index < stat.colors.container.size() ) {
+			g.color = stat.colors.container.at(stat.colors.index);
+		} else {
+			std::cout << "Invalid color index `" << stat.colors.index <<  "` for string: " <<  string << ": (" << stat.colors.container.size() << ")" << std::endl;
+			g.color = {
+				metadata["text settings"]["color"][0].as<float>(),
+				metadata["text settings"]["color"][1].as<float>(),
+				metadata["text settings"]["color"][2].as<float>(),
+			};
+		}
+		gs.push_back(g);
+	}
+#endif
+	return gs;
+}
+
+void ext::Gui::load( const uf::Image& _image ) {
+	auto& scene = uf::scene::getCurrentScene();
+	
+	auto& image = this->getComponent<uf::Image>();
+	// image = uf::Image( _image );
+	image.copy( _image );
+	auto& metadata = this->getComponent<uf::Serializer>();
+	metadata["size"][0] = image.getDimensions().x;
+	metadata["size"][1] = image.getDimensions().y;
+
+	auto& graphic = this->getComponent<uf::Graphic>();
+	auto& texture = graphic.material.textures.emplace_back();
+	texture.loadFromImage( image );
+/*
+	{
+		pod::Transform<>& transform = gui.getComponent<pod::Transform<>>();
+		uf::GuiMesh& mesh = gui.getComponent<uf::GuiMesh>();
+		auto& texture = graphic.material.textures.front();
+
+		pod::Vector2f textureSize = {
+			metadata["size"][0].as<float>(),
+			metadata["size"][1].as<float>()
+		};
+
+		if ( metadata["scaling"].as<std::string>() == "fixed" ) {
+			transform.scale = pod::Vector3{ (float) textureSize.x / ext::gui::size.current.x, (float) textureSize.y / ext::gui::size.current.y, 1 };
+		} else if ( metadata["scaling"].as<std::string>() == "fixed-1080p" ) {
+			transform.scale = pod::Vector3{ (float) textureSize.x / 1920, (float) textureSize.y / 1080, 1 };
+		}
+	}
+*/
+
+	auto& mesh = this->getComponent<uf::GuiMesh>();
+	auto& transform = this->getComponent<pod::Transform<>>();
+	mesh.vertices = {
+		{ {1.0f, -1.0f}, {1.0f, 0.0f}, },
+		{ {-1.0f, -1.0f}, {0.0f, 0.0f}, },
+		{ {-1.0f, 1.0f}, {0.0f, 1.0f}, },
+	
+		{ {-1.0f, 1.0f}, {0.0f, 1.0f}, },
+		{ {1.0f, 1.0f}, {1.0f, 1.0f}, },
+		{ {1.0f, -1.0f}, {1.0f, 0.0f}, },
+	/*
+		{ {-1.0f, 1.0f}, {0.0f, 0.0f}, },
+		{ {-1.0f, -1.0f}, {0.0f, 1.0f}, },
+		{ {1.0f, -1.0f}, {1.0f, 1.0f}, },
+
+		{ {-1.0f, 1.0f}, {0.0f, 0.0f}, },
+		{ {1.0f, -1.0f}, {1.0f, 1.0f}, },
+		{ {1.0f, 1.0f}, {1.0f, 0.0f}, }
+	*/
+	};
+
+	pod::Vector2f raidou = { 1, 1 };
+	bool modified = false;
+
+	if ( metadata["mode"].as<std::string>() == "flat" ) {
+		if ( ext::json::isNull(metadata["projection"]) ) metadata["projection"] = false;
+		if ( ext::json::isNull(metadata["flip uv"]) ) metadata["flip uv"] = true;
+		if ( ext::json::isNull(metadata["front face"]) ) metadata["front face"] = "ccw";
+	} else {
+		if ( ext::json::isNull(metadata["projection"]) ) metadata["projection"] = true;
+		if ( ext::json::isNull(metadata["flip uv"]) ) metadata["flip uv"] = false;
+		if ( ext::json::isNull(metadata["front face"]) ) metadata["front face"] = "cw";
+	}
+	graphic.descriptor.parse( metadata );
+	
+	if ( metadata["flip uv"].as<bool>() ) {
+		for ( auto& v : mesh.vertices ) {
+			v.uv.y = 1 - v.uv.y;
+		}
+	}
+	if ( metadata["scaling"].is<std::string>() ) {
+		std::string mode = metadata["scaling"].as<std::string>();
+		if ( mode == "mesh" ) {
+		//	raidou.x = (float) image.getDimensions().x / image.getDimensions().y;
+			raidou.y = (float) image.getDimensions().y / image.getDimensions().x;
+			modified = true;
+		}
+	} else if ( ext::json::isArray(metadata["scaling"]) ) {
+		raidou.x = metadata["scaling"][0].as<float>();
+		raidou.y = metadata["scaling"][1].as<float>();
+		modified = true;
+	}
+	if ( modified ) {
+		transform.scale.x = raidou.x;
+		transform.scale.y = raidou.y;
+	}
+/*
+	for ( auto& vertex : mesh.vertices ) {
+		vertex.position.x *= raidou.x;
+		vertex.position.y *= raidou.y;
+	}
+
+	transform.scale.x = raidou.x;
+	transform.scale.y = raidou.y;
+*/
+/*
+	if ( !metadata["gui layer"].as<bool>() ) {
+		graphic.initialize( ::defaultRenderMode );
+	} else {
+		graphic.initialize();
+	}
+*/
+	if ( metadata["layer"].is<std::string>() ) {
+		graphic.initialize( metadata["layer"].as<std::string>() );
+	} else if ( !ext::json::isNull( metadata["gui layer"] ) && !metadata["gui layer"].as<bool>() ) {
+		graphic.initialize();
+	} else if ( metadata["gui layer"].is<std::string>() ) {
+		graphic.initialize( metadata["gui layer"].as<std::string>() );
+	} else {
+		graphic.initialize( ::defaultRenderMode );
+	}
+	graphic.initializeMesh( mesh );
+	struct {
+		std::string vertex = uf::io::root+"/shaders/gui/vert.spv";
+		std::string fragment = uf::io::root+"/shaders/gui/frag.spv";
+	} filenames;
+	std::string suffix = ""; {
+		std::string _ = scene.getComponent<uf::Serializer>()["shaders"]["gui"]["suffix"].as<std::string>();
+		if ( _ != "" ) suffix = _ + ".";
+	}
+	if ( metadata["shaders"]["vertex"].is<std::string>() ) filenames.vertex = metadata["shaders"]["vertex"].as<std::string>();
+	if ( metadata["shaders"]["fragment"].is<std::string>() ) filenames.fragment = metadata["shaders"]["fragment"].as<std::string>();
+	else if ( suffix != "" ) filenames.fragment = uf::io::root+"/shaders/gui/"+suffix+"frag.spv";
+
+	graphic.material.initializeShaders({
+		{filenames.vertex, uf::renderer::enums::Shader::VERTEX},
+		{filenames.fragment, uf::renderer::enums::Shader::FRAGMENT},
+	});
+#if UF_USE_VULKAN
+	{
+		auto& shader = graphic.material.getShader("vertex");
+		struct SpecializationConstant {
+			uint32_t passes = 6;
+		};
+		auto& specializationConstants = shader.specializationConstants.get<SpecializationConstant>();
+		specializationConstants.passes = uf::renderer::settings::maxViews;
+	}
+#endif
+}
+
+UF_OBJECT_REGISTER_BEGIN(ext::Gui)
+	UF_OBJECT_REGISTER_BEHAVIOR(uf::EntityBehavior)
+	UF_OBJECT_REGISTER_BEHAVIOR(uf::ObjectBehavior)
+	UF_OBJECT_REGISTER_BEHAVIOR(ext::GuiBehavior)
+UF_OBJECT_REGISTER_END()
+#define this (&self)
+void ext::GuiBehavior::initialize( uf::Object& self ) {	
+	auto& metadata = this->getComponent<uf::Serializer>();
+#if UF_USE_FREETYPE
+	this->addHook( "glyph:Load.%UID%", [&](ext::json::Value& json){
+		unsigned long c = json["glyph"].as<size_t>();
+		std::string font = uf::io::root+"/fonts/" + metadata["text settings"]["font"].as<std::string>();
+		std::string key = ""; {
+			key += std::to_string(c) + ";";
+			key += metadata["text settings"]["padding"][0].as<std::string>() + ",";
+			key += metadata["text settings"]["padding"][1].as<std::string>() + ";";
+			key += metadata["text settings"]["spread"].as<std::string>() + ";";
+			key += metadata["text settings"]["size"].as<std::string>() + ";";
+			key += metadata["text settings"]["font"].as<std::string>() + ";";
+			key += metadata["text settings"]["sdf"].as<std::string>();
+		}
+		uf::Glyph& glyph = ::glyphs.cache[font][key];
+		
+		uf::Image image; {
+			const uint8_t* buffer = glyph.getBuffer();
+			uf::Image::container_t pixels;
+			std::size_t len = glyph.getSize().x * glyph.getSize().y;
+			pixels.insert( pixels.end(), buffer, buffer + len );
+			image.loadFromBuffer( pixels, glyph.getSize(), 8, 1, true );
+		}
+		this->as<ext::Gui>().load( image );
+	});
+#endif
+	this->addHook( "asset:Load.%UID%", [&](ext::json::Value& json){
+		std::string filename = json["filename"].as<std::string>();
+		std::string category = json["category"].as<std::string>();
+
+		if ( category != "" && category != "images" ) return;
+		if ( category == "" && uf::io::extension(filename) != "png" && uf::io::extension(filename) != "jpg" && uf::io::extension(filename) != "jpeg" ) return;
+
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Asset& assetLoader = scene.getComponent<uf::Asset>();
+		const uf::Image* imagePointer = NULL;
+		if ( !assetLoader.has<uf::Image>(filename) ) return;
+		imagePointer = &assetLoader.get<uf::Image>(filename);
+		if ( !imagePointer ) return;
+	//	uf::Image image = *imagePointer;
+		this->as<ext::Gui>().load( *imagePointer );
+	});
+	this->addHook( "window:Resized", [&](ext::json::Value& json){
+		if ( !this->hasComponent<uf::GuiMesh>() ) return;
+
+		pod::Vector2ui size; {
+			size.x = json["window"]["size"]["x"].as<size_t>();
+			size.y = json["window"]["size"]["y"].as<size_t>();
+		}
+		pod::Transform<>& transform = this->getComponent<pod::Transform<>>();
+
+	/*
+		pod::Vector2f textureSize = {
+			metadata["size"][0].as<float>(),
+			metadata["size"][1].as<float>()
+		};
+		if ( ext::json::isObject( metadata["text settings"] ) ) {
+		} else if ( metadata["scaling"].as<std::string>() == "fixed" ) {
+			transform.scale = pod::Vector3{ (float) textureSize.x / size.x, (float) textureSize.y / size.y, 1 };
+		} else if ( metadata["scaling"].as<std::string>() == "fixed-1080p" ) {
+			transform.scale = pod::Vector3{ (float) textureSize.x / 1920, (float) textureSize.y / 1080, 1 };
+		}
+	*/
+	} );
+		
+	if ( metadata["system"]["clickable"].as<bool>() ) {
+		uf::Timer<long long> clickTimer(false);
+	//	clickTimer.start( uf::Time<>(-1000000) );
+		if ( !clickTimer.running() ) clickTimer.start();
+		this->addHook( "gui:Clicked.%UID%", [&](ext::json::Value& json){
+			if ( ext::json::isObject( metadata["events"]["click"] ) ) {
+				uf::Serializer event = metadata["events"]["click"];
+				metadata["events"]["click"] = ext::json::array(); //Json::arrayValue;
+				metadata["events"]["click"][0] = event;
+			} else if ( !ext::json::isArray( metadata["events"]["click"] ) ) {
+				this->getParent().as<uf::Object>().callHook("gui:Clicked.%UID%", json);
+				return;
+			}
+			for ( int i = 0; i < metadata["events"]["click"].size(); ++i ) {
+				uf::Serializer event = metadata["events"]["click"][i];
+				uf::Serializer payload = event["payload"];
+				if ( event["delay"].is<float>() ) {
+					this->queueHook(event["name"].as<std::string>(), payload, event["delay"].as<float>());
+				} else {
+					this->callHook(event["name"].as<std::string>(), payload );
+				}
+			}
+		});
+		this->addHook( "window:Mouse.Click", [&](ext::json::Value& json){
+			uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+
+			if ( metadata["world"].as<bool>() ) return;
+			if ( ext::json::isNull( metadata["box"] ) ) return;
+
+			bool down = json["mouse"]["state"].as<std::string>() == "Down";
+			bool clicked = false;
+			if ( down ) {
+				pod::Vector2ui position; {
+					position.x = json["mouse"]["position"]["x"].as<int>() > 0 ? json["mouse"]["position"]["x"].as<size_t>() : 0;
+					position.y = json["mouse"]["position"]["y"].as<int>() > 0 ? json["mouse"]["position"]["y"].as<size_t>() : 0;
+				}
+				pod::Vector2f click; {
+					click.x = (float) position.x / (float) ext::gui::size.current.x;
+					click.y = (float) position.y / (float) ext::gui::size.current.y;
+
+					click.x = (click.x * 2.0f) - 1.0f;
+					click.y = (click.y * 2.0f) - 1.0f;
+
+					float x = click.x;
+					float y = click.y;
+
+
+					if (json["invoker"] == "vr" ) {
+						x = json["mouse"]["position"]["x"].as<float>();
+						y = json["mouse"]["position"]["y"].as<float>();
+					}
+
+					pod::Vector2f min = { metadata["box"]["min"]["x"].as<float>(), metadata["box"]["min"]["y"].as<float>() };
+					pod::Vector2f max = { metadata["box"]["max"]["x"].as<float>(), metadata["box"]["max"]["y"].as<float>() };
+					clicked = ( min.x <= x && min.y <= y && max.x >= x && max.y >= y );
+				}
+
+			}
+			metadata["clicked"] = clicked;
+			if ( clicked ) {
+				this->callHook("gui:Clicked.%UID%", json);
+			}
+			this->callHook("gui:Mouse.Clicked.%UID%", json);
+		} );
+	}
+	if ( metadata["system"]["hoverable"].as<bool>() ) {
+		uf::Timer<long long> hoverTimer(false);
+		hoverTimer.start( uf::Time<>(-1000000) );
+		this->addHook( "gui:Hovered.%UID%", [&](ext::json::Value& json){
+			if ( ext::json::isObject( metadata["events"]["hover"] ) ) {
+				uf::Serializer event = metadata["events"]["hover"];
+				metadata["events"]["hover"] = ext::json::array(); //Json::arrayValue;
+				metadata["events"]["hover"][0] = event;
+			} else if ( !ext::json::isArray( metadata["events"]["hover"] ) ) {
+				this->getParent().as<uf::Object>().callHook("gui:Clicked.%UID%", json);
+				return;
+			}
+			for ( int i = 0; i < metadata["events"]["hover"].size(); ++i ) {
+				uf::Serializer event = metadata["events"]["hover"][i];
+				uf::Serializer payload = event["payload"];
+				float delay = event["delay"].as<float>();
+				if ( event["delay"].is<double>() ) {
+					this->queueHook(event["name"].as<std::string>(), payload, event["delay"].as<float>());
+				} else {
+					this->callHook(event["name"].as<std::string>(), payload );
+				}
+			}
+			return;
+		});
+		this->addHook( "window:Mouse.Moved", [&](ext::json::Value& json){
+			if ( this->getUid() == 0 ) return;
+			if ( !this->hasComponent<uf::GuiMesh>() ) return;
+			uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+			if ( metadata["world"].as<bool>() ) return;
+			if ( ext::json::isNull( metadata["box"] ) ) return;
+
+			bool down = json["mouse"]["state"].as<std::string>() == "Down";
+			bool clicked = false;
+			pod::Vector2ui position; {
+				position.x = json["mouse"]["position"]["x"].as<int>() > 0 ? json["mouse"]["position"]["x"].as<size_t>() : 0;
+				position.y = json["mouse"]["position"]["y"].as<int>() > 0 ? json["mouse"]["position"]["y"].as<size_t>() : 0;
+			}
+			pod::Vector2f click; {
+				click.x = (float) position.x / (float) ext::gui::size.current.x;
+				click.y = (float) position.y / (float) ext::gui::size.current.y;
+
+				click.x = (click.x * 2.0f) - 1.0f;
+				click.y = (click.y * 2.0f) - 1.0f;
+				float x = click.x;
+				float y = click.y;
+
+				pod::Vector2f min = { metadata["box"]["min"]["x"].as<float>(), metadata["box"]["min"]["y"].as<float>() };
+				pod::Vector2f max = { metadata["box"]["max"]["x"].as<float>(), metadata["box"]["max"]["y"].as<float>() };
+				clicked = ( min.x <= x && min.y <= y && max.x >= x && max.y >= y );
+			}
+			metadata["hovered"] = clicked;
+
+			if ( clicked && hoverTimer.elapsed().asDouble() >= 1 ) {
+				hoverTimer.reset();
+				this->callHook("gui:Hovered.%UID%", json);
+			}
+			this->callHook("gui:Mouse.Moved.%UID%", json);
+		} );
+	}
+	if ( metadata["text settings"]["string"].is<std::string>() ) {
+		if ( ext::json::isNull( ::defaultSettings["metadata"] ) ) {
+			::defaultSettings.readFromFile(uf::io::root+"/entities/gui/text/string.json");
+		}
+		for ( auto it = ::defaultSettings["metadata"]["text settings"].begin(); it != ::defaultSettings["metadata"]["text settings"].end(); ++it ) {
+			std::string key = it.key();
+			if ( ext::json::isNull( metadata["text settings"][key] ) ) {
+				metadata["text settings"][key] = ::defaultSettings["metadata"]["text settings"][key];
+			}
+		}
+
+		#if UF_USE_FREETYPE
+		if ( false ) {
+			uf::Serializer payload;
+			payload["first"] = true;
+			payload["string"] = metadata["text settings"]["string"];
+			this->callHook("gui:UpdateString.%UID%", payload);
+		} else {
+			std::vector<pod::GlyphBox> glyphs = this->as<ext::Gui>().generateGlyphs();
+			
+			std::string font = uf::io::root+"/fonts/" + metadata["text settings"]["font"].as<std::string>();
+			std::string key = ""; {
+				key += metadata["text settings"]["padding"][0].as<std::string>() + ",";
+				key += metadata["text settings"]["padding"][1].as<std::string>() + ";";
+				key += metadata["text settings"]["spread"].as<std::string>() + ";";
+				key += metadata["text settings"]["size"].as<std::string>() + ";";
+				key += metadata["text settings"]["font"].as<std::string>() + ";";
+				key += metadata["text settings"]["sdf"].as<std::string>();
+			}
+			auto& scene = uf::scene::getCurrentScene();
+			auto& atlas = this->getComponent<uf::HashAtlas>();
+			auto& images = atlas.getImages();
+			auto& mesh = this->getComponent<ext::Gui::glyph_mesh_t>();
+			auto& graphic = this->getComponent<uf::Graphic>();
+			mesh.vertices.reserve( glyphs.size() * 6 );
+
+			std::unordered_map<std::string, std::string> glyphHashMap;
+			for ( auto& g : glyphs ) {
+				auto glyphKey = std::to_string((uint64_t) g.code) + ";"+key;
+				auto& glyph = ::glyphs.cache[font][glyphKey];
+
+				glyphHashMap[glyphKey] = atlas.addImage( glyph.getBuffer(), glyph.getSize(), 8, 1, true );
+			}
+
+			atlas.generate();
+
+			float scale = metadata["text settings"]["scale"].as<float>();
+			auto& transform = this->getComponent<pod::Transform<>>();
+			transform.scale.x = scale;
+			transform.scale.y = scale;
+
+			for ( auto& g : glyphs ) {
+				auto glyphKey = std::to_string((uint64_t) g.code) + ";"+key;
+				auto& glyph = ::glyphs.cache[font][glyphKey];
+				auto hash = glyphHashMap[glyphKey];
+				// add vertices
+				mesh.vertices.push_back({pod::Vector3f{ g.box.x,           g.box.y + g.box.h, 0 }, atlas.mapUv( pod::Vector2f{ 0.0f, 0.0f }, hash ), g.color});
+				mesh.vertices.push_back({pod::Vector3f{ g.box.x,           g.box.y          , 0 }, atlas.mapUv( pod::Vector2f{ 0.0f, 1.0f }, hash ), g.color});
+				mesh.vertices.push_back({pod::Vector3f{ g.box.x + g.box.w, g.box.y          , 0 }, atlas.mapUv( pod::Vector2f{ 1.0f, 1.0f }, hash ), g.color});
+				mesh.vertices.push_back({pod::Vector3f{ g.box.x,           g.box.y + g.box.h, 0 }, atlas.mapUv( pod::Vector2f{ 0.0f, 0.0f }, hash ), g.color});
+				mesh.vertices.push_back({pod::Vector3f{ g.box.x + g.box.w, g.box.y          , 0 }, atlas.mapUv( pod::Vector2f{ 1.0f, 1.0f }, hash ), g.color});
+				mesh.vertices.push_back({pod::Vector3f{ g.box.x + g.box.w, g.box.y + g.box.h, 0 }, atlas.mapUv( pod::Vector2f{ 1.0f, 0.0f }, hash ), g.color});
+			}
+			for ( size_t i = 0; i < mesh.vertices.size(); i += 6 ) {
+				for ( size_t j = 0; j < 6; ++j ) {
+					auto& vertex = mesh.vertices[i+j];
+					vertex.position.x /= ext::gui::size.reference.x;
+					vertex.position.y /= ext::gui::size.reference.y;
+
+					vertex.uv.y = 1 - vertex.uv.y;
+				}
+			}
+
+			auto& texture = graphic.material.textures.emplace_back();
+			texture.loadFromImage( atlas.getAtlas() );
+			graphic.initialize( ::defaultRenderMode );
+			graphic.initializeMesh( mesh );
+
+			std::string suffix = ""; {
+				std::string _ = scene.getComponent<uf::Serializer>()["shaders"]["gui"]["suffix"].as<std::string>();
+				if ( _ != "" ) suffix = _ + ".";
+			}
+			struct {
+				std::string vertex = uf::io::root+"/shaders/gui/text.vert.spv";
+				std::string fragment = uf::io::root+"/shaders/gui/text.frag.spv";
+			} filenames;
+			if ( metadata["shaders"]["vertex"].is<std::string>() ) filenames.vertex = metadata["shaders"]["vertex"].as<std::string>();
+			if ( metadata["shaders"]["fragment"].is<std::string>() ) filenames.fragment = metadata["shaders"]["fragment"].as<std::string>();
+			else if ( suffix != "" ) filenames.fragment = uf::io::root+"/shaders/gui/text."+suffix+"frag.spv";
+
+			graphic.material.initializeShaders({
+				{filenames.vertex, uf::renderer::enums::Shader::VERTEX},
+				{filenames.fragment, uf::renderer::enums::Shader::FRAGMENT},
+			});
+		}
+		#endif
+
+		this->addHook( "object:Reload.%UID%", [&](ext::json::Value& json){
+
+			if ( json["old"]["text settings"]["string"] == json["new"]["text settings"]["string"] ) return;
+			this->queueHook( "gui:UpdateString.%UID%");
+		});
+		#if UF_USE_FREETYPE
+		this->addHook( "gui:UpdateString.%UID%", [&](ext::json::Value& json){
+			for ( auto it = ::defaultSettings["metadata"]["text settings"].begin(); it != ::defaultSettings["metadata"]["text settings"].end(); ++it ) {
+				std::string key = it.key();
+				if ( ext::json::isNull( metadata["text settings"][key] ) ) {
+					metadata["text settings"][key] = ::defaultSettings["metadata"]["text settings"][key];
+				}
+			}
+			if ( json["string"].is<std::string>() ) {
+				metadata["text settings"]["string"] = json["string"];
+			}
+			std::string string = metadata["text settings"]["string"].as<std::string>();
+
+			std::vector<pod::GlyphBox> glyphs = this->as<ext::Gui>().generateGlyphs( string );
+			
+			std::string font = uf::io::root+"/fonts/" + metadata["text settings"]["font"].as<std::string>();
+			std::string key = ""; {
+				key += metadata["text settings"]["padding"][0].as<std::string>() + ",";
+				key += metadata["text settings"]["padding"][1].as<std::string>() + ";";
+				key += metadata["text settings"]["spread"].as<std::string>() + ";";
+				key += metadata["text settings"]["size"].as<std::string>() + ";";
+				key += metadata["text settings"]["font"].as<std::string>() + ";";
+				key += metadata["text settings"]["sdf"].as<std::string>();
+			}
+			auto& scene = uf::scene::getCurrentScene();
+			auto& atlas = this->getComponent<uf::HashAtlas>();
+			auto& images = atlas.getImages();
+			auto& mesh = this->getComponent<ext::Gui::glyph_mesh_t>();
+			auto& graphic = this->getComponent<uf::Graphic>();
+			if ( !json["first"].as<bool>() ) {
+				atlas.clear();
+				mesh.vertices.clear();
+				mesh.indices.clear();
+				
+				for ( auto& texture : graphic.material.textures ) texture.destroy();
+				graphic.material.textures.clear();
+			}
+			mesh.vertices.reserve( glyphs.size() * 6 );
+
+			std::unordered_map<std::string, std::string> glyphHashMap;
+			for ( auto& g : glyphs ) {
+				auto glyphKey = std::to_string((uint64_t) g.code) + ";"+key;
+				auto& glyph = ::glyphs.cache[font][glyphKey];
+
+				glyphHashMap[glyphKey] = atlas.addImage( glyph.getBuffer(), glyph.getSize(), 8, 1, true );
+			}
+
+			atlas.generate();
+
+			float scale = metadata["text settings"]["scale"].as<float>();
+			auto& transform = this->getComponent<pod::Transform<>>();
+			transform.scale.x = scale;
+			transform.scale.y = scale;
+
+			for ( auto& g : glyphs ) {
+				auto glyphKey = std::to_string((uint64_t) g.code) + ";"+key;
+				auto& glyph = ::glyphs.cache[font][glyphKey];
+				auto hash = glyphHashMap[glyphKey];
+				// add vertices
+				mesh.vertices.push_back({pod::Vector3f{ g.box.x,           g.box.y + g.box.h, 0 }, atlas.mapUv( pod::Vector2f{ 0.0f, 0.0f }, hash ), g.color});
+				mesh.vertices.push_back({pod::Vector3f{ g.box.x,           g.box.y          , 0 }, atlas.mapUv( pod::Vector2f{ 0.0f, 1.0f }, hash ), g.color});
+				mesh.vertices.push_back({pod::Vector3f{ g.box.x + g.box.w, g.box.y          , 0 }, atlas.mapUv( pod::Vector2f{ 1.0f, 1.0f }, hash ), g.color});
+				mesh.vertices.push_back({pod::Vector3f{ g.box.x,           g.box.y + g.box.h, 0 }, atlas.mapUv( pod::Vector2f{ 0.0f, 0.0f }, hash ), g.color});
+				mesh.vertices.push_back({pod::Vector3f{ g.box.x + g.box.w, g.box.y          , 0 }, atlas.mapUv( pod::Vector2f{ 1.0f, 1.0f }, hash ), g.color});
+				mesh.vertices.push_back({pod::Vector3f{ g.box.x + g.box.w, g.box.y + g.box.h, 0 }, atlas.mapUv( pod::Vector2f{ 1.0f, 0.0f }, hash ), g.color});
+			}
+			for ( size_t i = 0; i < mesh.vertices.size(); i += 6 ) {
+				for ( size_t j = 0; j < 6; ++j ) {
+					auto& vertex = mesh.vertices[i+j];
+					vertex.position.x /= ext::gui::size.reference.x;
+					vertex.position.y /= ext::gui::size.reference.y;
+
+					vertex.uv.y = 1 - vertex.uv.y;
+				}
+			}
+
+			auto& texture = graphic.material.textures.emplace_back();
+			texture.loadFromImage( atlas.getAtlas() );
+
+			if ( json["first"].as<bool>() ) {
+				graphic.initialize( ::defaultRenderMode );
+				graphic.initializeMesh( mesh );
+
+				std::string suffix = ""; {
+					std::string _ = scene.getComponent<uf::Serializer>()["shaders"]["gui"]["suffix"].as<std::string>();
+					if ( _ != "" ) suffix = _ + ".";
+				}
+				struct {
+					std::string vertex = uf::io::root+"/shaders/gui/text.vert.spv";
+					std::string fragment = uf::io::root+"/shaders/gui/text.frag.spv";
+				} filenames;
+				if ( metadata["shaders"]["vertex"].is<std::string>() ) filenames.vertex = metadata["shaders"]["vertex"].as<std::string>();
+				if ( metadata["shaders"]["fragment"].is<std::string>() ) filenames.fragment = metadata["shaders"]["fragment"].as<std::string>();
+				else if ( suffix != "" ) filenames.fragment = uf::io::root+"/shaders/gui/text."+suffix+"frag.spv";
+
+				graphic.material.initializeShaders({
+					{filenames.vertex, uf::renderer::enums::Shader::VERTEX},
+					{filenames.fragment, uf::renderer::enums::Shader::FRAGMENT},
+				});
+			} else {
+				graphic.initializeMesh( mesh );
+				graphic.getPipeline().update( graphic );
+			}
+		});
+		#endif
+	}
+}
+void ext::GuiBehavior::tick( uf::Object& self ) {
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	if ( metadata["text settings"]["fade in speed"].is<double>() && !metadata["system"]["faded in"].as<bool>() ) {
+		float speed = metadata["text settings"]["fade in speed"].as<float>();
+		float alpha = metadata["text settings"]["color"][3].as<float>();
+		speed *= uf::physics::time::delta;
+		if ( alpha < 1 && alpha + speed > 1 ) {
+			alpha = 1;
+			speed = 0;
+
+			metadata["system"]["faded in"] = true;
+		}
+		if ( alpha + speed <= 1 ) {
+			metadata["text settings"]["color"][3] = alpha + speed;
+		}
+	}
+/*
+	if ( this->hasComponent<uf::Graphic>() && metadata["experimental"].as<bool>() ) {
+		auto& image = this->getComponent<uf::Image>();
+		auto& pixels = image.getPixels();
+		size_t channels = image.getChannels();
+		size_t len = pixels.size();
+		uint8_t red = fmod( uf::physics::time::current * 64.0f, 255.0f );
+		for ( size_t i = 0; i < len; i += channels ) {
+			pixels[i] = red;
+		}
+		auto& graphic = this->getComponent<uf::Graphic>();
+		auto& texture = graphic.material.textures.front();
+		texture.update( image );
+	}
+*/
+}
+template<size_t N = uf::renderer::settings::maxViews>
+struct UniformDescriptor {
+	struct {
+		alignas(16) pod::Matrix4f model[N];
+	} matrices;
+	struct {
+		alignas(16) pod::Vector4f offset;
+		alignas(16) pod::Vector4f color;
+		alignas(4) int32_t mode = 0;
+		alignas(4) float depth = 0.0f;
+		alignas(8) pod::Vector2f padding;
+	} gui;
+};
+template<size_t N = uf::renderer::settings::maxViews>
+struct GlyphUniformDescriptor {
+	struct {
+		alignas(16) pod::Matrix4f model[N];
+	} matrices;
+	struct {
+		alignas(16) pod::Vector4f offset;
+		alignas(16) pod::Vector4f color;
+		alignas(4) int32_t mode = 0;
+		alignas(4) float depth = 0.0f;
+		alignas(4) int32_t sdf = false;
+		alignas(4) int32_t shadowbox = false;
+		alignas(16) pod::Vector4f stroke;
+		alignas(4) float weight;
+		alignas(4) int32_t spread;
+		alignas(4) float scale;
+		alignas(4) float padding;
+	} gui;
+};
+void ext::GuiBehavior::render( uf::Object& self ){
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	/* Update uniforms */ if ( this->hasComponent<uf::Graphic>() ) {
+		auto& scene = uf::scene::getCurrentScene();
+		auto& graphic = this->getComponent<uf::Graphic>();
+		auto& controller = scene.getController();
+		auto& camera = controller.getComponent<uf::Camera>();
+		auto& transform = this->getComponent<pod::Transform<>>();
+		if ( !graphic.initialized ) return;
+	#if UF_USE_OPENGL
+		auto model = uf::matrix::identity();
+		auto uniformBuffer = graphic.getUniform();
+		pod::Uniform& uniform = *((pod::Uniform*) graphic.device->getBuffer(uniformBuffer.buffer));
+		uniform.projection = uf::matrix::identity();
+		if ( metadata["gui"]["only model"].as<bool>() ) {
+			uniform.modelView = transform.model; 
+		} else if ( metadata["gui"]["world"].as<bool>() ) {
+			auto& scene = uf::scene::getCurrentScene();
+			auto& controller = scene.getController();
+			auto& camera = controller.getComponent<uf::Camera>();
+			uniform.projection = camera.getProjection();
+			uniform.modelView = camera.getView() * uf::transform::model( transform );
+		} else if ( metadata["gui"]["projection"].as<bool>() ) {
+			pod::Transform<> flatten = uf::transform::flatten( transform );
+			uniform.projection = camera.getProjection();
+			uniform.modelView = 
+				uf::matrix::translate( uf::matrix::identity(), flatten.position ) *
+				uf::matrix::scale( uf::matrix::identity(), flatten.scale ) *
+				uf::quaternion::matrix( flatten.orientation ) *
+				flatten.model;
+		} else {
+			pod::Transform<> flatten = uf::transform::flatten( transform );
+			uniform.modelView = 
+				uf::matrix::translate( uf::matrix::identity(), flatten.position ) *
+				uf::matrix::scale( uf::matrix::identity(), flatten.scale ) *
+				uf::quaternion::matrix( flatten.orientation ) *
+				flatten.model;
+		}
+
+		graphic.updateUniform( &uniform, sizeof(uniform) );
+	#else
+		if ( !graphic.material.hasShader("vertex") ) return;
+
+		auto& shader = graphic.material.getShader("vertex");
+		auto& uniform = shader.getUniform("UBO");
+		auto& uniforms = uniform.get<UniformDescriptor<>>();
+
+		bool isGlyph = metadata["text settings"]["string"].is<std::string>();
+		std::vector<std::string> keys = {
+			"uv",
+			"shader",
+			"depth",
+			"color",
+			"world",
+			"projection",
+			"only model",
+			"sdf",
+			"shadowbox",
+			"stroke",
+			"weight",
+			"spread",
+			"scale",
+			"alpha",
+		};
+		for ( auto& key : keys ) {
+			if ( !ext::json::isNull( metadata[key] ) )
+				metadata["gui"][key] = metadata[key];
+			if ( !ext::json::isNull( metadata["text settings"][key] ) )
+				metadata["gui"][key] = metadata["text settings"][key];
+		}
+
+		uniforms.gui.offset = {
+			metadata["gui"]["uv"][0].as<float>(),
+			metadata["gui"]["uv"][1].as<float>(),
+			metadata["gui"]["uv"][2].as<float>(),
+			metadata["gui"]["uv"][3].as<float>()
+		};
+		uniforms.gui.mode = metadata["gui"]["shader"].is<int>() ? metadata["gui"]["shader"].as<int>() : 0;
+		uniforms.gui.depth = metadata["gui"]["depth"].is<double>() ? metadata["gui"]["depth"].as<float>() : 0;
+		uniforms.gui.depth = 1 - uniforms.gui.depth;
+		if ( ext::json::isArray( metadata["gui"]["color"] ) ) {
+			uniforms.gui.color = {
+				metadata["gui"]["color"][0].as<float>(),
+				metadata["gui"]["color"][1].as<float>(),
+				metadata["gui"]["color"][2].as<float>(),
+				metadata["gui"]["color"][3].as<float>(),
+			};
+		} else {
+			uniforms.gui.color = { 1, 1, 1, 1 };
+		}
+		if ( metadata["gui"]["alpha"].is<double>() ) {
+			uniforms.gui.color[3] *= metadata["gui"]["alpha"].as<float>();
+		}
+		for ( std::size_t i = 0; i < 2; ++i ) {
+			if ( metadata["gui"]["only model"].as<bool>() ) {
+				uniforms.matrices.model[i] = transform.model; 
+			} else if ( metadata["gui"]["world"].as<bool>() ) {
+				auto& scene = uf::scene::getCurrentScene();
+				auto& controller = scene.getController();
+				auto& camera = controller.getComponent<uf::Camera>();
+				uniforms.matrices.model[i] = camera.getProjection(i) * camera.getView(i) * uf::transform::model( transform );
+			} else if ( metadata["gui"]["projection"].as<bool>() ) {
+				pod::Transform<> flatten = uf::transform::flatten( transform );
+				uniforms.matrices.model[i] = 
+					camera.getProjection(i) *
+					uf::matrix::translate( uf::matrix::identity(), flatten.position ) *
+					uf::matrix::scale( uf::matrix::identity(), flatten.scale ) *
+					uf::quaternion::matrix( flatten.orientation ) *
+					flatten.model;
+			} else {
+				pod::Transform<> flatten = uf::transform::flatten( transform );
+				uniforms.matrices.model[i] = 
+					uf::matrix::translate( uf::matrix::identity(), flatten.position ) *
+					uf::matrix::scale( uf::matrix::identity(), flatten.scale ) *
+					uf::quaternion::matrix( flatten.orientation ) *
+					flatten.model;
+			}
+		}
+
+		// set glyph-based uniforms
+		if ( isGlyph ) {
+			auto& uniforms = uniform.get<GlyphUniformDescriptor<>>();
+
+			uniforms.gui.sdf = metadata["gui"]["sdf"].as<bool>();
+			uniforms.gui.shadowbox = metadata["gui"]["shadowbox"].as<bool>();
+			if ( ext::json::isArray( metadata["gui"]["stroke"] ) ) {
+				uniforms.gui.stroke = {
+					metadata["gui"]["stroke"][0].as<float>(),
+					metadata["gui"]["stroke"][1].as<float>(),
+					metadata["gui"]["stroke"][2].as<float>(),
+					metadata["gui"]["stroke"][3].as<float>(),
+				};
+			} else {
+				uniforms.gui.stroke = { 1, 1, 1, 1 };
+			}
+			uniforms.gui.weight = metadata["gui"]["weight"].as<float>(); // float
+			uniforms.gui.spread = metadata["gui"]["spread"].as<int>(); // int
+			uniforms.gui.scale = metadata["gui"]["scale"].as<float>(); // float
+		}
+		shader.updateUniform( "UBO", uniform );
+
+		// calculate click box
+		auto& model = uniforms.matrices.model[0];
+	#endif
+		pod::Vector2f min = {  1,  1 };
+		pod::Vector2f max = { -1, -1 };
+
+		if ( this->hasComponent<uf::GuiMesh>() ) {
+			auto& mesh = this->getComponent<uf::GuiMesh>();
+			for ( auto& vertex : mesh.vertices ) {
+				pod::Vector4f position = { vertex.position.x, vertex.position.y, 0, 1 };
+				// gcc10+ doesn't like implicit template arguments
+				pod::Vector4f translated = uf::matrix::multiply<float>( model, position );
+				min.x = std::min( min.x, translated.x );
+				max.x = std::max( max.x, translated.x );
+				
+				min.y = std::min( min.y, translated.y );
+				max.y = std::max( max.y, translated.y );
+			}
+		} else if ( this->hasComponent<ext::Gui::glyph_mesh_t>() ) {
+			auto& mesh = this->getComponent<ext::Gui::glyph_mesh_t>();
+			for ( auto& vertex : mesh.vertices ) {
+				pod::Vector4f position = { vertex.position.x, vertex.position.y, 0, 1 };
+				// gcc10+ doesn't like implicit template arguments
+				pod::Vector4f translated = uf::matrix::multiply<float>( model, position );
+				min.x = std::min( min.x, translated.x );
+				max.x = std::max( max.x, translated.x );
+				
+				min.y = std::min( min.y, translated.y );
+				max.y = std::max( max.y, translated.y );
+			}
+		}
+		
+		metadata["box"]["min"]["x"] = min.x;
+		metadata["box"]["min"]["y"] = min.y;
+		metadata["box"]["max"]["x"] = max.x;
+		metadata["box"]["max"]["y"] = max.y;
+	}
+}
+void ext::GuiBehavior::destroy( uf::Object& self ){}
+#undef this
\ No newline at end of file
diff --git a/ext/gui/behavior.h b/ext/gui/behavior.h
new file mode 100644
index 00000000..1b186c32
--- /dev/null
+++ b/ext/gui/behavior.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/ext/ext.h>
+#include <uf/engine/entity/entity.h>
+#include <uf/engine/scene/scene.h>
+
+namespace ext {
+	class EXT_API GuiBehavior {
+	public:
+		static void attach( uf::Object& );
+		static void initialize( uf::Object& );
+		static void tick( uf::Object& );
+		static void render( uf::Object& );
+		static void destroy( uf::Object& );
+	};
+}
\ No newline at end of file
diff --git a/ext/gui/gui.h b/ext/gui/gui.h
new file mode 100644
index 00000000..425564af
--- /dev/null
+++ b/ext/gui/gui.h
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/ext/ext.h>
+#include <uf/engine/entity/entity.h>
+#include <uf/engine/scene/scene.h>
+#include <uf/utils/math/vector.h>
+#include <uf/utils/renderer/renderer.h>
+
+#include "behavior.h"
+
+namespace pod {
+	struct GlyphBox {
+		struct {
+			float x, y, w, h;
+		} box;
+		uint64_t code;
+		pod::Vector3f color;
+	};
+}
+
+namespace ext {
+	class EXT_API Gui : public uf::Object {
+	public:
+		typedef uf::BaseMesh<pod::Vertex_3F2F3F> glyph_mesh_t;
+
+		Gui();
+		std::vector<pod::GlyphBox> generateGlyphs( const std::string& = "" );
+		void load( const uf::Image& );
+	};
+	namespace gui {
+		struct Size {
+			pod::Vector2ui current = {};
+			pod::Vector2ui reference = {};
+		};
+		extern Size size;
+	}
+}
\ No newline at end of file
diff --git a/ext/gui/html/behavior.cpp b/ext/gui/html/behavior.cpp
new file mode 100644
index 00000000..6f324c43
--- /dev/null
+++ b/ext/gui/html/behavior.cpp
@@ -0,0 +1,121 @@
+#include "behavior.h"
+#include "../gui.h"
+
+#include <uf/utils/hook/hook.h>
+#include <uf/utils/time/time.h>
+#include <uf/utils/serialize/serializer.h>
+#include <uf/utils/userdata/userdata.h>
+#include <uf/utils/window/window.h>
+#include <uf/utils/camera/camera.h>
+#include <uf/utils/graphic/mesh.h>
+#include <uf/utils/graphic/graphic.h>
+#include <uf/utils/string/ext.h>
+#include <uf/utils/math/physics.h>
+
+#include <uf/utils/text/glyph.h>
+#include <uf/engine/asset/asset.h>
+#include <uf/engine/scene/scene.h>
+
+#include <unordered_map>
+#include <locale>
+#include <codecvt>
+
+#include <uf/utils/renderer/renderer.h>
+#include <uf/ext/openvr/openvr.h>
+
+#include <uf/utils/http/http.h>
+#include <uf/utils/audio/audio.h>
+#include <sys/stat.h>
+#include <fstream>
+
+#include <regex>
+#include <uf/ext/ultralight/ultralight.h>
+
+UF_BEHAVIOR_REGISTER_CPP(ext::GuiHtmlBehavior)
+#define this ((uf::Object*) &self)
+void ext::GuiHtmlBehavior::initialize( uf::Object& self ) {
+#if UF_USE_ULTRALIGHT
+	auto& page = this->getComponent<pod::HTML>();
+	auto& metadata = this->getComponent<uf::Serializer>();
+	pod::Vector2ui size = { 1, 1 };
+	if ( ext::json::isArray( metadata["size"] ) ) {
+		size = {
+			metadata["size"][0].as<size_t>(),
+			metadata["size"][1].as<size_t>(),
+		};
+	} else {		
+		size = ext::gui::size.current;
+	}
+	if ( size.x <= 0 && size.y <= 0 ) {
+		size.x = ext::config["window"]["size"]["x"].as<size_t>();
+		size.y = ext::config["window"]["size"]["y"].as<size_t>();
+	}
+	page = ext::ultralight::create( page, metadata["html"].as<std::string>(), size);
+	std::string onLoad = this->formatHookName("html:Load.%UID%");
+	if ( metadata["wait for load"].as<bool>() ) {	
+		ext::ultralight::on(page, "load", onLoad);
+		this->addHook( onLoad, [&](ext::json::Value& json){
+			auto image = ext::ultralight::capture( page );
+			this->as<ext::Gui>().load( image );
+		});
+	} else {
+		auto image = ext::ultralight::capture( page );
+		this->as<ext::Gui>().load( image );
+	}
+
+	this->addHook( "window:Resized", [&](ext::json::Value& json){
+		if ( !this->hasComponent<uf::GuiMesh>() ) return;
+
+		pod::Vector2ui size; {
+			size.x = json["window"]["size"]["x"].as<size_t>();
+			size.y = json["window"]["size"]["y"].as<size_t>();
+		};
+
+		metadata["size"][0] = size.x;
+		metadata["size"][1] = size.y;
+
+		ext::ultralight::resize( page, size );
+	});
+	
+	this->addHook( "window:Key", [&](ext::json::Value& json){
+		if ( json["type"].as<std::string>() == "window:Text.Entered" ) return;
+		if ( metadata["ignore inputs"].as<bool>() ) return;
+		ext::ultralight::input( page, json );
+	});
+	this->addHook( "window:Text.Entered", [&](ext::json::Value& json){
+		if ( metadata["ignore inputs"].as<bool>() ) return;
+		ext::ultralight::input( page, json );
+	});
+	this->addHook( "window:Mouse.Wheel", [&](ext::json::Value& json){
+		if ( metadata["ignore inputs"].as<bool>() ) return;
+		ext::ultralight::input( page, json );
+	});
+	this->addHook( "gui:Mouse.Clicked.%UID%", [&](ext::json::Value& json){
+		if ( metadata["ignore inputs"].as<bool>() ) return;
+		ext::ultralight::input( page, json );
+	});
+	this->addHook( "gui:Mouse.Moved.%UID%", [&](ext::json::Value& json){
+		if ( metadata["ignore inputs"].as<bool>() ) return;
+		ext::ultralight::input( page, json );
+	});
+#endif
+}
+void ext::GuiHtmlBehavior::tick( uf::Object& self ) {
+#if UF_USE_ULTRALIGHT
+	auto& metadata = this->getComponent<uf::Serializer>();
+	auto& page = this->getComponent<pod::HTML>();
+
+	bool should = metadata["update"].as<bool>() || page.pending;
+	if ( !this->hasComponent<uf::Graphic>() || !should ) return;
+	auto& graphic = this->getComponent<uf::Graphic>();
+	auto& texture = graphic.material.textures.front();
+	auto image = ext::ultralight::capture( page );
+	texture.update( image );
+//	page.pending = false;
+#endif
+}
+void ext::GuiHtmlBehavior::render( uf::Object& self ){
+}
+void ext::GuiHtmlBehavior::destroy( uf::Object& self ){
+}
+#undef this
\ No newline at end of file
diff --git a/ext/gui/html/behavior.h b/ext/gui/html/behavior.h
new file mode 100644
index 00000000..f8a79cef
--- /dev/null
+++ b/ext/gui/html/behavior.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/ext/ext.h>
+#include <uf/engine/entity/entity.h>
+#include <uf/engine/scene/scene.h>
+
+namespace ext {
+	class EXT_API GuiHtmlBehavior {
+	public:
+		static void attach( uf::Object& );
+		static void initialize( uf::Object& );
+		static void tick( uf::Object& );
+		static void render( uf::Object& );
+		static void destroy( uf::Object& );
+	};
+}
\ No newline at end of file
diff --git a/ext/gui/manager/behavior.cpp b/ext/gui/manager/behavior.cpp
new file mode 100644
index 00000000..aa054ccb
--- /dev/null
+++ b/ext/gui/manager/behavior.cpp
@@ -0,0 +1,214 @@
+#include "behavior.h"
+#include "../gui.h"
+
+#include <uf/utils/hook/hook.h>
+#include <uf/utils/time/time.h>
+#include <uf/utils/serialize/serializer.h>
+#include <uf/utils/userdata/userdata.h>
+#include <uf/utils/window/window.h>
+#include <uf/utils/camera/camera.h>
+#include <uf/utils/graphic/mesh.h>
+#include <uf/utils/graphic/graphic.h>
+#include <uf/utils/string/ext.h>
+#include <uf/utils/math/physics.h>
+
+#include <uf/utils/text/glyph.h>
+#include <uf/engine/asset/asset.h>
+#include <uf/engine/scene/scene.h>
+
+#include <unordered_map>
+#include <locale>
+#include <codecvt>
+
+#include <uf/utils/renderer/renderer.h>
+#include <uf/ext/openvr/openvr.h>
+
+#include <uf/utils/http/http.h>
+#include <uf/utils/audio/audio.h>
+#include <sys/stat.h>
+#include <fstream>
+
+#include <regex>
+
+ext::gui::Size ext::gui::size = {
+	.current = {
+		0,
+		0,
+	},
+	.reference = {
+		1920,
+		1080
+	},
+};
+
+
+UF_BEHAVIOR_REGISTER_CPP(ext::GuiManagerBehavior)
+UF_BEHAVIOR_REGISTER_AS_OBJECT(ext::GuiManagerBehavior, ext::GuiManager)
+#define this (&self)
+void ext::GuiManagerBehavior::initialize( uf::Object& self ) {
+	{
+		// ext::gui::size.current.x = uf::renderer::settings::width;
+		// ext::gui::size.current.y = uf::renderer::settings::height;
+	}
+	// add gui render mode
+#if UF_USE_VULKAN
+	if ( !uf::renderer::hasRenderMode( "Gui", true ) ) {
+		auto& renderMode = this->getComponent<uf::renderer::RenderTargetRenderMode>();
+		std::string name = "Gui";
+		uf::renderer::addRenderMode( &renderMode, name );
+		renderMode.blitter.descriptor.subpass = 1;
+	}
+#endif
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	uf::Asset& assetLoader = this->getComponent<uf::Asset>();
+
+	this->addHook( "window:Resized", [&](ext::json::Value& json){
+
+		pod::Vector2ui size; {
+			size.x = json["window"]["size"]["x"].as<size_t>();
+			size.y = json["window"]["size"]["y"].as<size_t>();
+		}
+		ext::gui::size.current = size;
+	//	ext::gui::size.reference = size;
+	} );
+	this->addHook( "window:Mouse.Moved", [&](ext::json::Value& json){
+
+		bool down = json["mouse"]["state"].as<std::string>() == "Down";
+		bool clicked = false;
+		pod::Vector2ui position; {
+			position.x = json["mouse"]["position"]["x"].as<int>() > 0 ? json["mouse"]["position"]["x"].as<size_t>() : 0;
+			position.y = json["mouse"]["position"]["y"].as<int>() > 0 ? json["mouse"]["position"]["y"].as<size_t>() : 0;
+		}
+		pod::Vector2f click; {
+			click.x = (float) position.x / (float) ext::gui::size.current.x;
+			click.y = (float) position.y / (float) ext::gui::size.current.y;
+			click.x = (click.x * 2.0f) - 1.0f;
+			click.y = (click.y * 2.0f) - 1.0f;
+			float x = click.x;
+			float y = click.y;
+		}
+
+		{
+			auto& scene = uf::scene::getCurrentScene();
+			auto& controller = scene.getController();
+			auto& metadata = controller.getComponent<uf::Serializer>();
+
+			if ( metadata["overlay"]["cursor"]["type"].as<std::string>() == "mouse" ) {
+				metadata["overlay"]["cursor"]["position"][0] = click.x;
+				metadata["overlay"]["cursor"]["position"][1] = click.y;
+			}
+		}
+	});
+}
+void ext::GuiManagerBehavior::tick( uf::Object& self ) {
+	
+}
+void ext::GuiManagerBehavior::render( uf::Object& self ){
+	auto& scene = uf::scene::getCurrentScene();
+	auto& controller = scene.getController();
+	auto& camera = controller.getComponent<uf::Camera>();
+	auto& metadata = controller.getComponent<uf::Serializer>();
+
+
+	uf::renderer::RenderTargetRenderMode* renderModePointer = NULL;
+	if ( this->hasComponent<uf::renderer::RenderTargetRenderMode>() ) {
+		renderModePointer = this->getComponentPointer<uf::renderer::RenderTargetRenderMode>();
+	} else {
+		renderModePointer = (uf::renderer::RenderTargetRenderMode*) &uf::renderer::getRenderMode( "Gui", true );
+	}
+	auto& renderMode = *renderModePointer;
+	auto& blitter = renderMode.blitter;
+
+	if ( !blitter.initialized ) return;
+#if UF_USE_VULKAN
+	if ( !blitter.material.hasShader("fragment") ) return;
+	
+	struct UniformDescriptor {
+		struct {
+			alignas(16) pod::Matrix4f models[2];
+		} matrices;
+		struct {
+			alignas(8) pod::Vector2f position = { 0.5f, 0.5f };
+			alignas(8) pod::Vector2f radius = { 0.1f, 0.1f };
+			alignas(16) pod::Vector4f color = { 1, 1, 1, 1 };
+		} cursor;
+	//	alignas(8) pod::Vector2f alpha;
+	};
+
+	auto& shader = blitter.material.getShader("vertex");
+	auto& uniform = shader.getUniform("UBO");
+	auto& uniforms = uniform.get<UniformDescriptor>();
+
+	for ( size_t i = 0; i < 2; ++i ) {
+		pod::Transform<> transform;
+		if ( ext::json::isArray( metadata["overlay"]["position"] ) ) 
+			transform.position = {
+				metadata["overlay"]["position"][0].as<float>(),
+				metadata["overlay"]["position"][1].as<float>(),
+				metadata["overlay"]["position"][2].as<float>(),
+			};
+		if ( ext::json::isArray( metadata["overlay"]["scale"] ) ) 
+			transform.scale = {
+				metadata["overlay"]["scale"][0].as<float>(),
+				metadata["overlay"]["scale"][1].as<float>(),
+				metadata["overlay"]["scale"][2].as<float>(),
+			};
+		if ( ext::json::isArray( metadata["overlay"]["orientation"] ) ) 
+			transform.orientation = {
+				metadata["overlay"]["orientation"][0].as<float>(),
+				metadata["overlay"]["orientation"][1].as<float>(),
+				metadata["overlay"]["orientation"][2].as<float>(),
+				metadata["overlay"]["orientation"][3].as<float>(),
+			};
+	#if UF_USE_OPENVR
+		if ( ext::openvr::enabled && (metadata["overlay"]["enabled"].as<bool>() || uf::renderer::getRenderMode("Stereoscopic Deferred", true).getType() == "Stereoscopic Deferred" )) {
+			if ( metadata["overlay"]["floating"].as<bool>() ) {
+				pod::Matrix4f model = uf::transform::model( transform );
+				uniforms.matrices.models[i] = camera.getProjection(i) * ext::openvr::hmdEyePositionMatrix( i == 0 ? vr::Eye_Left : vr::Eye_Right ) * model;
+			} else {
+				auto translation = uf::matrix::translate( uf::matrix::identity(), camera.getTransform().position + controller.getComponent<pod::Transform<>>().position );
+				auto rotation = uf::quaternion::matrix( controller.getComponent<pod::Transform<>>().orientation );
+
+				pod::Matrix4f model = translation * rotation * uf::transform::model( transform );
+				uniforms.matrices.models[i] = camera.getProjection(i) * camera.getView(i) * model;
+			}
+		} else {
+	#else
+		{
+	#endif
+			pod::Matrix4t<> model = uf::matrix::translate( uf::matrix::identity(), { 0, 0, 1 } );
+			uniforms.matrices.models[i] = model;
+		}
+
+
+		pod::Vector3f cursorSize = { 0, 0 };
+		if ( metadata["overlay"]["cursor"]["enabled"].as<bool>() ) {
+			uniforms.cursor.position.x = (metadata["overlay"]["cursor"]["position"][0].as<float>() + 1.0f) * 0.5f; //(::mouse.position.x + 1.0f) * 0.5f;
+			uniforms.cursor.position.y = (metadata["overlay"]["cursor"]["position"][1].as<float>() + 1.0f) * 0.5f; //(::mouse.position.y + 1.0f) * 0.5f;
+
+			cursorSize.x = metadata["overlay"]["cursor"]["radius"].as<float>();
+			cursorSize.y = metadata["overlay"]["cursor"]["radius"].as<float>();
+			
+			cursorSize = uf::matrix::multiply<float>( uf::matrix::inverse( uf::matrix::scale( uf::matrix::identity() , transform.scale) ), cursorSize );
+		
+			uniforms.cursor.radius.x = cursorSize.x;
+			uniforms.cursor.radius.y = cursorSize.y;
+		}
+		
+		uniforms.cursor.color.x = metadata["overlay"]["cursor"]["color"][0].as<float>();
+		uniforms.cursor.color.y = metadata["overlay"]["cursor"]["color"][1].as<float>();
+		uniforms.cursor.color.z = metadata["overlay"]["cursor"]["color"][2].as<float>();
+		uniforms.cursor.color.w = metadata["overlay"]["cursor"]["color"][3].as<float>();
+	}
+
+	shader.updateUniform( "UBO", uniform );
+#endif
+}
+void ext::GuiManagerBehavior::destroy( uf::Object& self ){
+	if ( this->hasComponent<uf::renderer::RenderTargetRenderMode>() ) {
+		auto& renderMode = this->getComponent<uf::renderer::RenderTargetRenderMode>();
+		uf::renderer::removeRenderMode( &renderMode, false );
+		this->deleteComponent<uf::renderer::RenderTargetRenderMode>();
+	}
+}
+#undef this
\ No newline at end of file
diff --git a/ext/gui/manager/behavior.h b/ext/gui/manager/behavior.h
new file mode 100644
index 00000000..7e6b8a9f
--- /dev/null
+++ b/ext/gui/manager/behavior.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/ext/ext.h>
+#include <uf/engine/entity/entity.h>
+#include <uf/engine/scene/scene.h>
+
+namespace ext {
+	class EXT_API GuiManagerBehavior {
+	public:
+		static void attach( uf::Object& );
+		static void initialize( uf::Object& );
+		static void tick( uf::Object& );
+		static void render( uf::Object& );
+		static void destroy( uf::Object& );
+	};
+}
\ No newline at end of file
diff --git a/ext/inits/persistence.inl b/ext/inits/persistence.inl
new file mode 100644
index 00000000..ef9c7264
--- /dev/null
+++ b/ext/inits/persistence.inl
@@ -0,0 +1,37 @@
+#pragma once
+
+/* Read persistent data */ if ( false ) {
+	struct {
+		bool exists = false;
+		std::string filename = uf::io::root+"/persistent.json";
+	} file;
+	struct {
+		uf::Serializer file;
+	} config;
+	/* Read from file */ if (( file.exists = config.file.readFromFile(file.filename) )) {
+		persistent.window.size.x = config.file["window"]["size"]["x"].as<size_t>();
+		persistent.window.size.y = config.file["window"]["size"]["y"].as<size_t>();
+		if ( config.file["window"]["title"] != "null" ) {
+			persistent.window.title = config.file["window"]["title"].as<std::string>();
+		}
+
+		/* Update window size */ {
+			uf::Serializer json;
+			std::string hook = "window:Resized";
+			json["type"] = hook;
+			json["invoker"] = "ext";
+			json["window"]["size"]["x"] = persistent.window.size.x;
+			json["window"]["size"]["y"] = persistent.window.size.y;
+			if ( persistent.window.size.x != 0 && persistent.window.size.y != 0 )
+				uf::hooks.call(hook, json);
+		}
+		/* Update window title */ {
+		uf::Serializer json;
+			std::string hook = "window:Title.Changed";
+			json["type"] = hook;
+			json["invoker"] = "ext";
+			json["window"]["title"] = std::string(persistent.window.title);
+			uf::hooks.call(hook, json);
+		}
+	}
+}
\ No newline at end of file
diff --git a/ext/main.cpp b/ext/main.cpp
new file mode 100644
index 00000000..6d40a5ae
--- /dev/null
+++ b/ext/main.cpp
@@ -0,0 +1,851 @@
+#include "main.h"
+
+#include <uf/ext/ext.h>
+#include <uf/ext/oal/oal.h>
+
+#include <uf/spec/terminal/terminal.h>
+
+#include <uf/utils/time/time.h>
+#include <uf/utils/audio/audio.h>
+#include <uf/utils/hook/hook.h>
+#include <uf/utils/io/iostream.h>
+#include <uf/utils/math/vector.h>
+#include <uf/utils/math/physics.h>
+#include <uf/utils/math/transform.h>
+#include <uf/utils/string/string.h>
+#include <uf/utils/string/ext.h>
+#include <uf/utils/serialize/serializer.h>
+#include <uf/utils/userdata/userdata.h>
+#include <uf/utils/image/image.h>
+#include <uf/utils/thread/thread.h>
+#include <uf/utils/graphic/graphic.h>
+#include <uf/utils/camera/camera.h>
+#include <uf/utils/http/http.h>
+
+#include <uf/engine/entity/entity.h>
+
+#include <sys/stat.h>
+
+#include <string>
+#include <fstream>
+#include <iostream>
+
+#include <regex>
+
+#include "ext.h"
+
+#include <uf/engine/scene/scene.h>
+#include <uf/engine/asset/asset.h>
+
+#include <uf/utils/renderer/renderer.h>
+#include <uf/ext/discord/discord.h>
+#include <uf/ext/openvr/openvr.h>
+#include <uf/ext/lua/lua.h>
+#include <uf/ext/ultralight/ultralight.h>
+#include <uf/ext/bullet/bullet.h>
+
+bool ext::ready = false;
+std::vector<std::string> ext::arguments;
+uf::Serializer ext::config;
+
+namespace {
+	struct {
+		uf::String input;
+		std::ofstream output;
+
+		struct {
+			std::string output = uf::io::root+"/logs/output.txt";
+		} filenames;
+	} io;
+
+	struct {
+		spec::Time::time_t 	epoch;
+		uf::Timer<> 		sys = uf::Timer<>(false);
+		uf::Timer<> 		delta = uf::Timer<>(false);
+		double prevTime = 0;
+		double curTime = 0;
+		double deltaTime = 0;
+		size_t frames = 0;
+		double limiter = 1.0 / 144.0;
+	} times;
+
+	uf::Serializer& config = ext::config;
+}
+
+namespace {
+	std::string getConfig() {
+	#if 1
+		return uf::io::readAsString(uf::io::root+"/config.json");
+	#else
+		struct {
+			bool initialized = false;
+			uf::Serializer file;
+			uf::Serializer fallback;
+			uf::Serializer merged;
+		} static config;
+		if ( config.initialized ) return config.merged;
+
+		struct {
+			bool exists = false;
+			std::string filename = uf::io::root+"/config.json";
+		} file;
+		/* Read from file */  {
+			file.exists = config.file.readFromFile(file.filename);
+		}
+		/* Initialize default configuration */ {
+			config.fallback["window"]["terminal"]["ncurses"] 			= true;
+			config.fallback["window"]["terminal"]["visible"] 			= true;
+			config.fallback["window"]["title"] 							= "Grimgram";
+			config.fallback["window"]["icon"] 							= "";
+			config.fallback["window"]["size"]["x"] 						= 0;
+			config.fallback["window"]["size"]["y"] 						= 0;
+			config.fallback["window"]["visible"] 						= true;
+		//	config.fallback["window"]["fullscreen"] 					= false;
+			config.fallback["window"]["mode"] 							= "windowed";
+			config.fallback["window"]["cursor"]["visible"] 				= true;
+			config.fallback["window"]["cursor"]["center"] 				= false;
+			config.fallback["window"]["keyboard"]["repeat"] 			= true;
+			
+			config.fallback["engine"]["scenes"]["start"]				= "StartMenu";
+			config.fallback["engine"]["scenes"]["lights"]["max"] 		= 32;
+			config.fallback["engine"]["hook"]["mode"] 					= "Readable";
+			config.fallback["engine"]["limiters"]["framerate"] 			= 60;
+			config.fallback["engine"]["limiters"]["deltaTime"] 			= 120;
+			config.fallback["engine"]["threads"]["workers"] 			= "auto";
+			config.fallback["engine"]["threads"]["frame limiter"] 		= 144;
+		#if UF_ENV_DREAMCAST
+			config.fallback["engine"]["memory pool"]["size"] 			= "1 MiB";
+		#else
+			config.fallback["engine"]["memory pool"]["size"] 			= "512 MiB";
+		#endif
+			config.fallback["engine"]["memory pool"]["globalOverride"] 	= false;
+			config.fallback["engine"]["memory pool"]["subPools"] 		= true;
+		}
+		/* Merge */ if ( file.exists ){
+			config.merged = config.file;
+			config.merged.merge( config.fallback, true );
+		} else {
+			config.merged = config.fallback;
+		}
+		/* Write default to file */ if ( false ) {
+			config.merged.writeToFile(file.filename);
+		}
+
+		config.initialized = true;
+		return config.merged;
+	#endif
+	}
+}
+
+#if UF_ENV_DREAMCAST
+	#define UF_DEBUG_TRACE_MSG() UF_DEBUG_PRINT_MARKER(); malloc_stats();
+#else
+	#define UF_DEBUG_TRACE_MSG()
+#endif
+
+void EXT_API ext::load() {
+	ext::config = getConfig();
+}
+void EXT_API ext::initialize() {
+	UF_DEBUG_TRACE_MSG();
+	/* Arguments */ {
+		bool modified = false;
+		auto& arguments = ::config["arguments"];
+		for ( auto& arg : ext::arguments ) {
+			// store raw argument
+			int i = arguments.size();
+			arguments[i] = arg;
+			// parse --key=value
+			{
+				std::regex regex("^--(.+?)=(.+?)$");
+				std::smatch match;
+				if ( std::regex_search( arg, match, regex ) ) {
+					std::string keyString = match[1].str();
+					std::string valueString = match[2].str();
+					uf::Serializer value; value.deserialize(valueString);
+					::config.path(keyString) = value;
+					modified = true;
+				}
+			}
+		}
+		uf::iostream << "Arguments: " << uf::Serializer(arguments) << "\n";
+		if ( modified ) uf::iostream << "New config: " << ::config << "\n";
+	}
+	/* Seed */ {
+		srand(time(NULL));
+	}
+	/* Open output file */ {
+		io.output.open(io.filenames.output);
+	}
+	/* Initialize timers */ {
+		times.epoch = spec::time.getTime();
+		times.sys.start();
+		times.delta.start();
+
+		times.prevTime = times.sys.elapsed().asDouble();
+		times.curTime = times.sys.elapsed().asDouble();
+	}
+	/* Read persistent data */ {
+		// #include "./inits/persistence.inl"
+	}
+	/* Testing scope */ {
+
+	}
+	UF_DEBUG_TRACE_MSG();
+#if UF_USE_LUA
+	/* Lua */ {
+		ext::lua::main = ::config["engine"]["ext"]["lua"]["main"].as<std::string>();
+		for ( auto it  = ::config["engine"]["ext"]["lua"]["modules"].begin(); it != ::config["engine"]["ext"]["lua"]["modules"].end(); ++it ) {
+			std::string key = it.key();
+			ext::lua::modules[key] = ::config["engine"]["ext"]["lua"]["modules"][key].as<std::string>();
+		}
+		ext::lua::initialize();
+	}
+#endif
+	UF_DEBUG_TRACE_MSG();
+	/* Parse config */ {
+		/* Set memory pool sizes */ {
+			auto deduceSize = []( const ext::json::Value& value )->size_t{
+				if ( value.is<size_t>() ) return value.as<size_t>();
+				if ( value.is<std::string>() ) {
+					std::string str = value.as<std::string>();
+					std::regex regex("^(\\d+) ?((?:K|M|G)?(?:i?B)?)$");
+					std::smatch match;
+					if ( std::regex_search( str, match, regex ) ) {
+						size_t requested = std::stoi( match[1].str() );
+						std::string prefix = match[2].str();
+						switch ( prefix.at(0) ) {
+							case 'K': return requested * 1024;
+							case 'M': return requested * 1024 * 1024;
+							case 'G': return requested * 1024 * 1024 * 1024;
+						}
+						return requested;
+					}
+				}
+				return 0;
+			};
+			{
+				size_t size = deduceSize( ::config["engine"]["memory pool"]["size"] );
+				uf::MemoryPool::globalOverride = ::config["engine"]["memory pool"]["globalOverride"].as<bool>();
+				uf::iostream << "Requesting " << (size_t) size << " bytes for global memory pool: " << &uf::MemoryPool::global << "\n";
+				uf::MemoryPool::global.initialize( size );
+				uf::MemoryPool::subPool = ::config["engine"]["memory pool"]["subPools"].as<bool>();
+				if ( size <= 0 || uf::MemoryPool::subPool ) {
+					{
+						size_t size = deduceSize( ::config["engine"]["memory pool"]["pools"]["component"] );
+						uf::iostream << "Requesting " << (int) size << " bytes for component memory pool: " << &uf::component::memoryPool << "\n";
+						uf::component::memoryPool.initialize( size );
+					}
+					{
+						size_t size = deduceSize( ::config["engine"]["memory pool"]["pools"]["userdata"] );
+						uf::iostream << "Requesting " << (int) size << " bytes for userdata memory pool: " << &uf::userdata::memoryPool << "\n";
+						uf::userdata::memoryPool.initialize( size );
+					}
+					{
+						size_t size = deduceSize( ::config["engine"]["memory pool"]["pools"]["entity"] );
+						uf::iostream << "Requesting " << (int) size << " bytes for entity memory pool: " << &uf::Entity::memoryPool << "\n";
+						uf::Entity::memoryPool.initialize( size );
+					}
+				}
+			}
+		}
+		UF_DEBUG_TRACE_MSG();
+		if ( ::config["engine"]["limiters"]["framerate"].as<std::string>() == "auto" && ::config["window"]["refresh rate"].is<size_t>() ) {
+			double scale = 1.0;
+			size_t refreshRate = ::config["window"]["refresh rate"].as<size_t>();
+			::config["engine"]["limiters"]["framerate"] = refreshRate * scale;
+			uf::iostream << "Setting framerate cap to " << (int) refreshRate * scale << "\n";
+		}
+		if ( ::config["engine"]["threads"]["frame limiter"].as<std::string>() == "auto" && ::config["window"]["refresh rate"].is<size_t>() ) {
+			double scale = 2.0;
+			size_t refreshRate = ::config["window"]["refresh rate"].as<size_t>();
+			::config["engine"]["threads"]["frame limiter"] = refreshRate * scale;
+			uf::iostream << "Setting thread frame limiter to " << (int) refreshRate * scale << "\n";
+		}
+		/* Frame limiter */ {
+			double limit = ::config["engine"]["limiters"]["framerate"].as<double>();
+			if ( limit != 0 )
+				::times.limiter = 1.0 / ::config["engine"]["limiters"]["framerate"].as<double>();
+			else ::times.limiter = 0;
+		}
+		/* Thread frame limiter */ {
+			double limit = ::config["engine"]["threads"]["frame limiter"].as<double>();
+			if ( limit != 0 ) 
+				uf::thread::limiter = 1.0 / ::config["engine"]["threads"]["frame limiter"].as<double>();
+			else
+				uf::thread::limiter = 0;
+		}
+		/* Max delta time */{
+			double limit = ::config["engine"]["limiters"]["deltaTime"].as<double>();
+			if ( limit != 0 )
+				uf::physics::time::clamp = 1.0 / ::config["engine"]["limiters"]["deltaTime"].as<double>();
+			else uf::physics::time::clamp = 0;
+		}
+		// Mute audio
+		if ( ::config["engine"]["audio"]["mute"].is<bool>() )
+			uf::Audio::mute = ::config["engine"]["audio"]["mute"].as<bool>();
+
+		// Set worker threads
+		if ( ::config["engine"]["threads"]["workers"].as<std::string>() == "auto" ) {
+			auto threads = std::max( 1, (int) std::thread::hardware_concurrency() - 1 );
+			::config["engine"]["threads"]["workers"] = threads;
+			uf::iostream << "Using " << threads << " worker threads" << "\n";
+		}
+		UF_DEBUG_TRACE_MSG();
+	#if UF_USE_BULLET
+		// set bullet parameters
+		ext::bullet::debugDrawEnabled = ::config["engine"]["ext"]["bullet"]["debug draw"]["enabled"].as<bool>();
+		ext::bullet::debugDrawRate = ::config["engine"]["ext"]["bullet"]["debug draw"]["rate"].as<float>();
+		if ( ::config["engine"]["ext"]["bullet"]["iterations"].is<size_t>() ) {
+			ext::bullet::iterations = ::config["engine"]["ext"]["bullet"]["iterations"].as<size_t>();
+		}
+		if ( ::config["engine"]["ext"]["bullet"]["substeps"].is<size_t>() ) {
+			ext::bullet::substeps = ::config["engine"]["ext"]["bullet"]["substeps"].as<size_t>();
+		}
+		if ( ::config["engine"]["ext"]["bullet"]["timescale"].as<float>() ) {
+			ext::bullet::timescale = ::config["engine"]["ext"]["bullet"]["timescale"].as<float>();
+		}
+		if ( ::config["engine"]["ext"]["bullet"]["pool size"]["max collision algorithm"].as<size_t>() ) {
+			ext::bullet::defaultMaxCollisionAlgorithmPoolSize = ::config["engine"]["ext"]["bullet"]["pool size"]["max collision algorithm"].as<size_t>();
+		}
+		if ( ::config["engine"]["ext"]["bullet"]["pool size"]["max persistent manifold"].as<size_t>() ) {
+			ext::bullet::defaultMaxPersistentManifoldPoolSize = ::config["engine"]["ext"]["bullet"]["pool size"]["max persistent manifold"].as<size_t>();
+		}
+	#endif
+		uf::thread::workers = ::config["engine"]["threads"]["workers"].as<size_t>();
+		// Enable valiation layer
+	{
+	#if UF_USE_VULKAN
+		std::string RENDERER = "vulkan";
+	#elif UF_USE_OPENGL
+		std::string RENDERER = "opengl";
+	#else
+		std::string RENDERER = "software";
+	#endif
+		uf::renderer::settings::validation = ::config["engine"]["ext"][RENDERER]["validation"]["enabled"].as<bool>();
+		
+		if ( ::config["engine"]["ext"][RENDERER]["framebuffer"]["msaa"].is<double>() )
+			uf::renderer::settings::msaa = ::config["engine"]["ext"][RENDERER]["framebuffer"]["msaa"].as<size_t>();
+
+		if ( ::config["engine"]["ext"][RENDERER]["framebuffer"]["size"].is<double>() ) {
+			float scale = ::config["engine"]["ext"][RENDERER]["framebuffer"]["size"].as<float>();
+			uf::renderer::settings::width *= scale;
+			uf::renderer::settings::height *= scale;
+		} else if ( ext::json::isArray( ::config["engine"]["ext"][RENDERER]["framebuffer"]["size"] ) ) {
+			uf::renderer::settings::width = ::config["engine"]["ext"][RENDERER]["framebuffer"]["size"][0].as<float>();
+			uf::renderer::settings::height = ::config["engine"]["ext"][RENDERER]["framebuffer"]["size"][1].as<float>();
+			std::string filter = ::config["engine"]["ext"][RENDERER]["framebuffer"]["size"][2].as<std::string>();
+			if ( uf::string::lowercase( filter )  == "nearest" ) uf::renderer::settings::swapchainUpscaleFilter = uf::renderer::enums::Filter::NEAREST;
+			else if ( uf::string::lowercase( filter )  == "linear" ) uf::renderer::settings::swapchainUpscaleFilter = uf::renderer::enums::Filter::LINEAR;
+		}
+
+		if ( ::config["engine"]["debug"]["entity"]["delete children on destroy"].is<bool>() ) uf::Entity::deleteChildrenOnDestroy = ::config["engine"]["debug"]["entity"]["delete children on destroy"].as<bool>();
+		if ( ::config["engine"]["debug"]["entity"]["delete components on destroy"].is<bool>() ) uf::Entity::deleteComponentsOnDestroy = ::config["engine"]["debug"]["entity"]["delete components on destroy"].as<bool>();
+		
+		for ( int i = 0; i < ::config["engine"]["ext"][RENDERER]["validation"]["filters"].size(); ++i ) {
+			uf::renderer::settings::validationFilters.push_back( ::config["engine"]["ext"][RENDERER]["validation"]["filters"][i].as<std::string>() );
+		}
+		for ( int i = 0; i < ::config["engine"]["ext"][RENDERER]["extensions"]["device"].size(); ++i ) {
+			uf::renderer::settings::requestedDeviceExtensions.push_back( ::config["engine"]["ext"][RENDERER]["extensions"]["device"][i].as<std::string>() );
+		}
+		for ( int i = 0; i < ::config["engine"]["ext"][RENDERER]["extensions"]["instance"].size(); ++i ) {
+			uf::renderer::settings::requestedInstanceExtensions.push_back( ::config["engine"]["ext"][RENDERER]["extensions"]["instance"][i].as<std::string>() );
+		}
+		for ( int i = 0; i < ::config["engine"]["ext"][RENDERER]["features"].size(); ++i ) {
+			uf::renderer::settings::requestedDeviceFeatures.push_back( ::config["engine"]["ext"][RENDERER]["features"][i].as<std::string>() );
+		}
+	#if 1
+		if ( ::config["engine"]["ext"][RENDERER]["experimental"]["rebuild on tick begin"].is<bool>() )
+			uf::renderer::settings::experimental::rebuildOnTickBegin = ::config["engine"]["ext"][RENDERER]["experimental"]["rebuild on tick begin"].as<bool>();
+		if ( ::config["engine"]["ext"][RENDERER]["experimental"]["wait on render end"].is<bool>() )
+			uf::renderer::settings::experimental::waitOnRenderEnd = ::config["engine"]["ext"][RENDERER]["experimental"]["wait on render end"].as<bool>();
+		if ( ::config["engine"]["ext"][RENDERER]["experimental"]["individual pipelines"].is<bool>() )
+			uf::renderer::settings::experimental::individualPipelines = ::config["engine"]["ext"][RENDERER]["experimental"]["individual pipelines"].as<bool>();
+		if ( ::config["engine"]["ext"][RENDERER]["experimental"]["multithreaded command recording"].is<bool>() )
+			uf::renderer::settings::experimental::multithreadedCommandRecording = ::config["engine"]["ext"][RENDERER]["experimental"]["multithreaded command recording"].as<bool>();
+		if ( ::config["engine"]["ext"][RENDERER]["experimental"]["deferred mode"].is<std::string>() )
+			uf::renderer::settings::experimental::deferredMode = ::config["engine"]["ext"][RENDERER]["experimental"]["deferred mode"].as<std::string>();
+		if ( ::config["engine"]["ext"][RENDERER]["experimental"]["deferred reconstruct position"].is<bool>() )
+			uf::renderer::settings::experimental::deferredReconstructPosition = ::config["engine"]["ext"][RENDERER]["experimental"]["deferred reconstruct position"].as<bool>();
+		if ( ::config["engine"]["ext"][RENDERER]["experimental"]["deferred alias output to swapchain"].is<bool>() )
+			uf::renderer::settings::experimental::deferredAliasOutputToSwapchain = ::config["engine"]["ext"][RENDERER]["experimental"]["deferred alias output to swapchain"].as<bool>();
+		if ( ::config["engine"]["ext"][RENDERER]["experimental"]["vsync"].is<bool>() )
+			uf::renderer::settings::experimental::vsync = ::config["engine"]["ext"][RENDERER]["experimental"]["vsync"].as<bool>();
+		if ( ::config["engine"]["ext"][RENDERER]["experimental"]["hdr"].is<bool>() )
+			uf::renderer::settings::experimental::hdr = ::config["engine"]["ext"][RENDERER]["experimental"]["hdr"].as<bool>();
+	#else
+		uf::renderer::settings::experimental::rebuildOnTickBegin = ::config["engine"]["ext"][RENDERER]["experimental"]["rebuild on tick begin"].as<bool>();
+		uf::renderer::settings::experimental::waitOnRenderEnd = ::config["engine"]["ext"][RENDERER]["experimental"]["wait on render end"].as<bool>();
+		uf::renderer::settings::experimental::individualPipelines = ::config["engine"]["ext"][RENDERER]["experimental"]["individual pipelines"].as<bool>();
+		uf::renderer::settings::experimental::multithreadedCommandRecording = ::config["engine"]["ext"][RENDERER]["experimental"]["multithreaded command recording"].as<bool>();
+		uf::renderer::settings::experimental::deferredMode = ::config["engine"]["ext"][RENDERER]["experimental"]["deferred mode"].as<std::string>();
+		uf::renderer::settings::experimental::deferredReconstructPosition = ::config["engine"]["ext"][RENDERER]["experimental"]["deferred reconstruct position"].as<bool>();
+		uf::renderer::settings::experimental::deferredAliasOutputToSwapchain = ::config["engine"]["ext"][RENDERER]["experimental"]["deferred alias output to swapchain"].as<bool>();
+		uf::renderer::settings::experimental::vsync = ::config["engine"]["ext"][RENDERER]["experimental"]["vsync"].as<bool>();
+		uf::renderer::settings::experimental::hdr = ::config["engine"]["ext"][RENDERER]["experimental"]["hdr"].as<bool>();
+		
+	#endif
+	#define JSON_TO_VKFORMAT( key ) if ( ::config["engine"]["ext"][RENDERER]["formats"][#key].is<std::string>() ) {\
+			std::string format = ::config["engine"]["ext"][RENDERER]["formats"][#key].as<std::string>();\
+			format = uf::string::replace( uf::string::uppercase(format), " ", "_" );\
+			uf::renderer::settings::formats::key = uf::renderer::formatFromString( format );\
+		}
+
+		JSON_TO_VKFORMAT(color);
+		JSON_TO_VKFORMAT(depth);
+		JSON_TO_VKFORMAT(normal);
+		JSON_TO_VKFORMAT(position);
+	}
+	UF_DEBUG_TRACE_MSG();
+	#if UF_USE_BULLET
+	/* Bullet */ {
+		ext::bullet::initialize();
+	}
+#endif
+	UF_DEBUG_TRACE_MSG();
+	#if UF_USE_OPENVR
+		ext::openvr::enabled = ::config["engine"]["ext"]["vr"]["enable"].as<bool>();
+		ext::openvr::swapEyes = ::config["engine"]["ext"]["vr"]["swap eyes"].as<bool>();
+		
+		
+		if ( ::config["engine"]["ext"]["vr"]["dominant eye"].is<int>() ) {
+			ext::openvr::dominantEye = ::config["engine"]["ext"]["vr"]["dominant eye"].as<int>();
+		} else if ( ::config["engine"]["ext"]["vr"]["dominant eye"].as<std::string>() == "left" ) ext::openvr::dominantEye = 0;
+		else if ( ::config["engine"]["ext"]["vr"]["dominant eye"].as<std::string>() == "right" ) ext::openvr::dominantEye = 1;
+
+		
+		ext::openvr::driver.manifest = ::config["engine"]["ext"]["vr"]["manifest"].as<std::string>();
+		
+		if ( ext::openvr::enabled ) {
+			::config["engine"]["render modes"]["stereo deferred"] = true;
+		}
+	#endif
+	}
+	UF_DEBUG_TRACE_MSG();
+	/* Create initial scene (kludge) */ {
+		uf::Scene& scene = uf::instantiator::instantiate<uf::Scene>(); //new uf::Scene;
+		uf::scene::scenes.push_back(&scene);
+		auto& metadata = scene.getComponent<uf::Serializer>();
+		metadata["system"]["config"] = ::config;
+	}
+	UF_DEBUG_TRACE_MSG();
+	/* Initialize Vulkan */ {
+		// uf::renderer::width = ::config["window"]["size"]["x"].as<int>();
+		// uf::renderer::height = ::config["window"]["size"]["y"].as<int>();
+	#if UF_USE_VULKAN
+		// setup render mode
+		if ( ::config["engine"]["render modes"]["gui"].as<bool>() ) {
+			auto* renderMode = new uf::renderer::RenderTargetRenderMode;
+			uf::renderer::addRenderMode( renderMode, "Gui" );
+			renderMode->blitter.descriptor.subpass = 1;
+		}
+		if ( ::config["engine"]["render modes"]["deferred"].as<bool>() ) {
+			uf::renderer::addRenderMode( new uf::renderer::DeferredRenderMode, "" );
+			if ( ::config["engine"]["render modes"]["stereo deferred"].as<bool>() ) {
+				auto& renderMode = uf::renderer::getRenderMode("Deferred", true);
+				renderMode.metadata["eyes"] = 2;
+			}
+		}
+	#endif
+	UF_DEBUG_TRACE_MSG();
+	#if UF_USE_OPENVR
+		if ( ext::openvr::enabled ) {
+			ext::openvr::initialize();
+		
+			uint32_t width, height;
+			ext::openvr::recommendedResolution( width, height );
+
+			auto& renderMode = uf::renderer::getRenderMode("Deferred", true);
+			renderMode.width = width;
+			renderMode.height = height;
+
+			uf::iostream << "Recommended VR Resolution: " << renderMode.width << ", " << renderMode.height << "\n";
+
+			if ( ::config["engine"]["ext"]["vr"]["scale"].is<double>() ) {
+				float scale = ::config["engine"]["ext"]["vr"]["scale"].as<float>();
+				renderMode.width *= scale;
+				renderMode.height *= scale;
+				
+				uf::iostream << "VR Resolution: " << renderMode.width << ", " << renderMode.height << "\n";
+			}
+		}
+	#endif
+	#if UF_USE_VULKAN
+		/* Callbacks for 2KHR stuffs */ if ( false ) {
+			uf::hooks.addHook("vulkan:Instance.ExtensionsEnabled", []( const ext::json::Value& json ) {
+			//	std::cout << "vulkan:Instance.ExtensionsEnabled: " << json << std::endl;
+			});
+			uf::hooks.addHook("vulkan:Device.ExtensionsEnabled", []( const ext::json::Value& json ) {
+			//	std::cout << "vulkan:Device.ExtensionsEnabled: " << json << std::endl;
+			});
+			uf::hooks.addHook("vulkan:Device.FeaturesEnabled", []( const ext::json::Value& json ) {
+			//	std::cout << "vulkan:Device.FeaturesEnabled: " << json << std::endl;
+
+				VkPhysicalDeviceFeatures2KHR deviceFeatures2{};
+				VkPhysicalDeviceMultiviewFeaturesKHR extFeatures{};
+				extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR;
+				deviceFeatures2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR;
+				deviceFeatures2.pNext = &extFeatures;
+				PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR = reinterpret_cast<PFN_vkGetPhysicalDeviceFeatures2KHR>(vkGetInstanceProcAddr(uf::renderer::device.instance, "vkGetPhysicalDeviceFeatures2KHR"));
+				vkGetPhysicalDeviceFeatures2KHR(uf::renderer::device.physicalDevice, &deviceFeatures2);
+				std::cout << "Multiview features:" << std::endl;
+				std::cout << "\tmultiview = " << extFeatures.multiview << std::endl;
+				std::cout << "\tmultiviewGeometryShader = " << extFeatures.multiviewGeometryShader << std::endl;
+				std::cout << "\tmultiviewTessellationShader = " << extFeatures.multiviewTessellationShader << std::endl;
+				std::cout << std::endl;
+
+				VkPhysicalDeviceProperties2KHR deviceProps2{};
+				VkPhysicalDeviceMultiviewPropertiesKHR extProps{};
+				extProps.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR;
+				deviceProps2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR;
+				deviceProps2.pNext = &extProps;
+				PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR = reinterpret_cast<PFN_vkGetPhysicalDeviceProperties2KHR>(vkGetInstanceProcAddr(uf::renderer::device.instance, "vkGetPhysicalDeviceProperties2KHR"));
+				vkGetPhysicalDeviceProperties2KHR(uf::renderer::device.physicalDevice, &deviceProps2);
+				std::cout << "Multiview properties:" << std::endl;
+				std::cout << "\tmaxMultiviewViewCount = " << extProps.maxMultiviewViewCount << std::endl;
+				std::cout << "\tmaxMultiviewInstanceIndex = " << extProps.maxMultiviewInstanceIndex << std::endl;
+			});
+		}
+	#endif
+		UF_DEBUG_TRACE_MSG();
+		uf::renderer::initialize();
+	}
+	UF_DEBUG_TRACE_MSG();
+	/* */ {
+		pod::Thread& threadMain = uf::thread::has("Main") ? uf::thread::get("Main") : uf::thread::create( "Main", false );
+		pod::Thread& threadPhysics = uf::thread::has("Physics") ? uf::thread::get("Physics") : uf::thread::create( "Physics", true );
+	}
+#if UF_USE_DISCORD
+	/* Discord */ if ( ::config["engine"]["ext"]["discord"]["enabled"].as<bool>() ) {
+		ext::discord::initialize();
+	}
+#endif
+#if UF_USE_ULTRALIGHT
+	/* Ultralight-UX */ if ( ::config["engine"]["ext"]["ultralight"]["enabled"].as<bool>() ) {
+		if ( ::config["engine"]["ext"]["ultralight"]["scale"].is<double>() ) {
+			ext::ultralight::scale = ::config["engine"]["ext"]["ultralight"]["scale"].as<double>();
+		}
+		if ( ::config["engine"]["ext"]["ultralight"]["log"].is<size_t>() ) {
+			ext::ultralight::log = ::config["engine"]["ext"]["ultralight"]["log"].as<size_t>();
+		}
+		ext::ultralight::initialize();
+	}
+#endif
+	UF_DEBUG_TRACE_MSG();
+//	#define DEBUG_PRINT() std::cout << __FILE__ << ":" __FUNCTION__ << "@" << __LINE__ << std::endl;	
+	/* Add hooks */ {
+		uf::hooks.addHook( "game:Scene.Load", [&](ext::json::Value& json){
+			auto function = [json]() -> int {
+				uf::renderer::synchronize();
+
+				uf::hooks.call("game:Scene.Cleanup");
+				// uf::scene::unloadScene();
+
+				auto& scene = uf::scene::loadScene( json["scene"].as<std::string>() );
+				auto& metadata = scene.getComponent<uf::Serializer>();
+				metadata["system"]["config"] = ::config;
+
+				return 0;
+			};
+			
+			if ( json["immediate"].as<bool>() ) function(); else uf::thread::add( uf::thread::get("Main"), function, true );
+		});
+
+		uf::hooks.addHook( "game:Scene.Cleanup", [&](ext::json::Value& json){
+			for ( auto* scene : uf::scene::scenes ) {
+				if ( scene->hasComponent<uf::Audio>() ) {
+					scene->getComponent<uf::Audio>().destroy();
+				}
+			}
+			uf::scene::unloadScene();
+		});
+		uf::hooks.addHook( "system:Quit", [&](ext::json::Value& json){
+		//	uf::iostream << "system:Quit: " << event << "\n";
+			ext::ready = false;
+		});
+	}
+	UF_DEBUG_TRACE_MSG();
+	/* Initialize root scene*/ {
+		uf::Serializer payload;
+		payload["scene"] = ::config["engine"]["scenes"]["start"];
+		payload["immediate"] = true;
+		uf::hooks.call("game:Scene.Load", payload);
+	}
+	
+	ext::ready = true;
+	uf::iostream << "EXT took " << times.sys.elapsed().asDouble() << " seconds to initialize!" << "\n";
+
+	{
+		uf::thread::add( uf::thread::fetchWorker(), [&]() -> int {
+			auto& scene = uf::scene::getCurrentScene();
+			auto& assetLoader = scene.getComponent<uf::Asset>();
+			assetLoader.processQueue();
+		return 0;}, false );
+	}
+	UF_DEBUG_TRACE_MSG();
+}
+void EXT_API ext::tick() {
+	/* Timer */ {
+		times.prevTime = times.curTime;
+		times.curTime = times.sys.elapsed().asDouble();
+		times.deltaTime = times.curTime - times.prevTime;
+	}
+
+#if UF_USE_OPENVR
+	/* OpenVR */ if ( ext::openvr::context ) {
+		ext::openvr::tick();
+	}
+#endif
+	/* Print Entity Information */  {
+		TIMER(1, uf::Window::isKeyPressed("P") && ) {
+	    //	uf::iostream << uf::renderer::allocatorStats() << "\n";
+			uf::iostream << "==== Memory Pool Information ====";
+			if ( uf::MemoryPool::global.size() > 0 ) uf::iostream << "\nGlobal Memory Pool: " << uf::MemoryPool::global.stats();
+			if ( uf::Entity::memoryPool.size() > 0 ) uf::iostream << "\nEntity Memory Pool: " << uf::Entity::memoryPool.stats();
+			if ( uf::component::memoryPool.size() > 0 ) uf::iostream << "\nComponents Memory Pool: " << uf::component::memoryPool.stats();
+			if ( uf::userdata::memoryPool.size() > 0 ) uf::iostream << "\nUserdata Memory Pool: " << uf::userdata::memoryPool.stats();
+			uf::iostream << "\n";
+		}
+	}
+	/* Attempt to reset VR position */  {
+		TIMER(1, uf::Window::isKeyPressed("Z") && ) {
+	    	uf::hooks.call("VR:Seat.Reset");
+		}
+	}
+	/* Print controller position */ if ( false ) {
+		TIMER(1, uf::Window::isKeyPressed("Z") && ) {
+			auto& scene = uf::scene::getCurrentScene();
+			auto& controller = scene.getController();
+			auto& camera = controller.getComponent<uf::Camera>();
+			auto& t = camera.getTransform(); //controller->getComponent<pod::Transform<>>();
+			uf::iostream << "Viewport position: (" << t.position.x << ", " << t.position.y << ", " << t.position.z << ") (" << t.orientation.x << ", " << t.orientation.y << ", " << t.orientation.z << ", " << t.orientation.w << ")";
+			uf::iostream << "\n";
+			if ( false ) {
+			//	uf::Entity* light = scene.findByUid(scene.loadChildUid("/light.json", true));
+				uf::Object& light = scene.loadChild("/light.json", true);
+				auto& lTransform = light.getComponent<pod::Transform<>>();
+				auto& lMetadata = light.getComponent<uf::Serializer>();
+				lTransform.position = t.position;
+				lTransform.orientation = t.orientation;
+				if ( !ext::json::isArray( lMetadata["light"] ) ) {
+					lMetadata["light"]["color"][0] = (rand() % 100) / 100.0;
+					lMetadata["light"]["color"][1] = (rand() % 100) / 100.0;
+					lMetadata["light"]["color"][2] = (rand() % 100) / 100.0;
+				}
+				auto& sMetadata = scene.getComponent<uf::Serializer>();
+				sMetadata["light"]["should"] = true;
+			}
+		}
+	}
+
+	auto& bulletThread = uf::thread::get("Physics");
+	/* Update physics timer */ {
+		uf::physics::tick();
+	}
+
+#if UF_USE_BULLET
+	/* Update bullet */ {
+		if ( ::config["engine"]["ext"]["bullet"]["multithreaded"].as<bool>() ) {
+			uf::thread::add( bulletThread, [&]() -> int { ext::bullet::tick(); return 0;}, true );
+		} else {
+			ext::bullet::tick();
+		}
+	}
+#endif
+	/* Update entities */ {
+		uf::scene::tick();
+	}
+	
+	/* Tick Main Thread Queue */ {
+		pod::Thread& thread = uf::thread::get("Main");
+		uf::thread::process( thread );
+	}
+
+	/* Garbage collection */ if ( ::config["engine"]["debug"]["garbage collection"]["enabled"].as<bool>() ) {
+		double every = ::config["engine"]["debug"]["garbage collection"]["every"].as<double>();
+		uint8_t mode = ::config["engine"]["debug"]["garbage collection"]["mode"].as<uint64_t>();
+		bool announce = ::config["engine"]["debug"]["garbage collection"]["announce"].as<bool>();
+		TIMER( every ) {
+			size_t collected = uf::instantiator::collect( mode );
+			if ( announce && collected > 0 ) {
+				uf::iostream << "GC collected " << (int) collected << " unused entities" << "\n";
+			}
+		}
+	}
+#if UF_USE_ULTRALIGHT
+	/* Ultralight-UX */ if ( ::config["engine"]["ext"]["ultralight"]["enabled"].as<bool>() ) {
+		ext::ultralight::tick();
+	}
+#endif
+	/* Update vulkan */ {
+		uf::renderer::tick();
+	}
+#if UF_USE_DISCORD
+	/* Discord */ if ( ::config["engine"]["ext"]["discord"]["enable"].as<bool>() ) {
+		ext::discord::tick();
+	}
+#endif
+	/* FPS Print */ if ( ::config["engine"]["debug"]["framerate"]["print"].as<bool>() ) {
+		++::times.frames;
+		double every = ::config["engine"]["debug"]["framerate"]["every"].as<double>();
+		TIMER( every ) {
+//			uf::iostream << "Framerate: " << (1.0/times.deltaTime) << " FPS | Frametime: " << (times.deltaTime * 1000) << "ms" << "\n";
+			uf::iostream << "System: " << (every * 1000.0/::times.frames) << " ms/frame | Time: " << time << " | Frames: " << ::times.frames << " | FPS: " << ::times.frames / time << "\n";
+			::times.frames = 0;
+		}
+	}
+	
+	/* Frame limiter of sorts I guess */ if ( false ) if ( ::times.limiter > 0 ) {
+		static uf::Timer<long long> timer(false);
+		if ( !timer.running() ) timer.start();
+		auto elapsed = timer.elapsed().asMilliseconds();
+		long long sleep = (::times.limiter * 1000) - elapsed;
+		if ( sleep > 0 ) {
+			if ( ::config["engine"]["debug"]["framerate"]["print"].as<bool>() ) {
+				uf::iostream << "Frame limiting: " << elapsed << "ms exceeds limit, sleeping for " << elapsed << "ms" << "\n";
+			}
+			std::this_thread::sleep_for(std::chrono::milliseconds(sleep));
+		}
+		timer.reset();
+	}
+
+	if ( ::config["engine"]["ext"]["bullet"]["multithreaded"].as<bool>() ) {
+		uf::thread::wait( bulletThread );
+	}
+}
+void EXT_API ext::render() {
+
+#if UF_USE_ULTRALIGHT
+	/* Ultralight-UX */ if ( ::config["engine"]["ext"]["ultralight"]["enabled"].as<bool>() ) {
+		ext::ultralight::render();
+	}
+#endif
+#if UF_USE_OPENVR
+	if ( ext::openvr::context ) {
+		vr::VRCompositor()->SubmitExplicitTimingData();
+	}
+#endif
+	/* Render scene */ {
+		uf::renderer::render();
+	}
+#if UF_USE_OPENVR
+	if ( ext::openvr::context ) {
+		ext::openvr::synchronize();
+		ext::openvr::submit();
+	}
+#endif
+}
+void EXT_API ext::terminate() {
+	/* Kill threads */ {
+		uf::thread::terminate();
+	}
+#if UF_USE_BULLET
+	/* Kill bullet */ {
+		ext::bullet::terminate();
+	}
+#endif
+#if UF_USE_ULTRALIGHT
+	/* Ultralight-UX */ if ( ::config["engine"]["ext"]["ultralight"]["enabled"].as<bool>() ) {
+		ext::ultralight::terminate();
+	}
+#endif
+#if UF_USE_OPENVR
+	/* OpenVR */ if ( ext::openvr::context ) {
+		ext::openvr::terminate();
+	}
+#endif
+	uf::scene::destroy();
+
+	/* Garbage collection */ if ( false ) {
+		uint8_t mode = ::config["engine"]["debug"]["garbage collection"]["mode"].as<uint64_t>();
+		bool announce = ::config["engine"]["debug"]["garbage collection"]["announce"].as<bool>();
+		size_t collected = uf::instantiator::collect( mode );
+		if ( announce && collected > 0 ) {
+			uf::iostream << "GC collected " << (int) collected << " unused entities" << "\n";
+		}
+	}
+
+	/* Close vulkan */ {
+		uf::renderer::destroy();
+	}
+
+	/* Flush input buffer */ {
+		io.output << io.input << "\n";
+		for ( const auto& str : uf::iostream.getHistory() ) io.output << str << "\n";
+		io.output << "\nTerminated after " << times.sys.elapsed().asDouble() << " seconds" << "\n";
+		io.output.close();
+	}
+
+	/* Write persistent data */ if ( false ) {
+		struct {
+			bool exists = false;
+			std::string filename = uf::io::root+"/persistent.json";
+		} file;
+		struct {
+			uf::Serializer file;
+		} config;
+		/* Read from file */  {
+			file.exists = config.file.readFromFile(file.filename);
+		}
+		/* Write persistent data */ {
+			config.file.writeToFile(file.filename);
+		}
+	}
+}
+
+#if 0
+std::string EXT_API ext::getConfig() {
+	struct {
+		bool initialized = false;
+		uf::Serializer file;
+		uf::Serializer fallback;
+		uf::Serializer merged;
+	} static config;
+	if ( config.initialized ) return config.merged;
+
+	struct {
+		bool exists = false;
+		std::string filename = uf::io::root+"/config.json";
+	} file;
+	/* Read from file */  {
+		file.exists = config.file.readFromFile(file.filename);
+	}
+	/* Initialize default configuration */ {
+		config.fallback["window"]["terminal"]["ncurses"] 			= true;
+		config.fallback["window"]["terminal"]["visible"] 			= true;
+		config.fallback["window"]["title"] 							= "Grimgram";
+		config.fallback["window"]["icon"] 							= "";
+		config.fallback["window"]["size"]["x"] 						= 0;
+		config.fallback["window"]["size"]["y"] 						= 0;
+		config.fallback["window"]["visible"] 						= true;
+	//	config.fallback["window"]["fullscreen"] 					= false;
+		config.fallback["window"]["mode"] 							= "windowed";
+		config.fallback["window"]["cursor"]["visible"] 				= true;
+		config.fallback["window"]["cursor"]["center"] 				= false;
+		config.fallback["window"]["keyboard"]["repeat"] 			= true;
+		
+		config.fallback["engine"]["scenes"]["start"]				= "StartMenu";
+		config.fallback["engine"]["scenes"]["lights"]["max"] 			= 32;
+		config.fallback["engine"]["hook"]["mode"] 					= "Readable";
+		config.fallback["engine"]["limiters"]["framerate"] 			= 60;
+		config.fallback["engine"]["limiters"]["deltaTime"] 			= 120;
+		config.fallback["engine"]["threads"]["workers"] 			= "auto";
+		config.fallback["engine"]["threads"]["frame limiter"] 		= 144;
+		config.fallback["engine"]["memory pool"]["size"] 			= "512 MiB";
+		config.fallback["engine"]["memory pool"]["globalOverride"] 	= false;
+		config.fallback["engine"]["memory pool"]["subPools"] 		= true;
+	}
+	/* Merge */ if ( file.exists ){
+		config.merged = config.file;
+		config.merged.merge( config.fallback, true );
+	} else {
+		config.merged = config.fallback;
+	}
+	/* Write default to file */ if ( false ) {
+		config.merged.writeToFile(file.filename);
+	}
+
+	config.initialized = true;
+	return config.merged;
+}
+#endif
\ No newline at end of file
diff --git a/ext/main.h b/ext/main.h
new file mode 100644
index 00000000..4e2b6366
--- /dev/null
+++ b/ext/main.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include <uf/ext/ext.h>
+
+#include <uf/utils/camera/camera.h>
+
+namespace ext {
+	
+}
\ No newline at end of file
diff --git a/ext/scenes/raytrace/behavior.cpp b/ext/scenes/raytrace/behavior.cpp
new file mode 100644
index 00000000..6994b39d
--- /dev/null
+++ b/ext/scenes/raytrace/behavior.cpp
@@ -0,0 +1,211 @@
+#include "behavior.h"
+
+#include <uf/utils/time/time.h>
+#include <uf/utils/io/iostream.h>
+#include <uf/utils/math/vector.h>
+#include <uf/utils/math/transform.h>
+#include <uf/utils/window/window.h>
+#include <uf/utils/graphic/graphic.h>
+
+#include <uf/utils/audio/audio.h>
+#include <uf/utils/thread/thread.h>
+#include <uf/utils/camera/camera.h>
+
+#include <uf/engine/asset/asset.h>
+#include <uf/engine/asset/masterdata.h>
+
+#include <uf/utils/renderer/renderer.h>
+
+#include <uf/ext/gltf/gltf.h>
+
+#include <uf/utils/math/collision.h>
+
+#include "../../ext.h"
+#include "../../gui/gui.h"
+
+UF_BEHAVIOR_REGISTER_CPP(ext::RayTracingSceneBehavior)
+#define this ((uf::Scene*) &self)
+void ext::RayTracingSceneBehavior::initialize( uf::Object& self ) {
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	uf::Asset& assetLoader = this->getComponent<uf::Asset>();
+
+	{
+		auto& renderMode = this->getComponent<uf::renderer::ComputeRenderMode>();
+		std::string name = "C:RT:" + std::to_string((int) this->getUid());
+		uf::renderer::addRenderMode( &renderMode, name );
+		if ( ext::json::isArray( metadata["light"]["shadows"]["resolution"] ) ) {
+			renderMode.width = metadata["light"]["shadows"]["resolution"][0].as<size_t>();
+			renderMode.height = metadata["light"]["shadows"]["resolution"][1].as<size_t>();
+		} else {
+			renderMode.width = metadata["light"]["shadows"]["resolution"].as<size_t>();
+			renderMode.height = metadata["light"]["shadows"]["resolution"].as<size_t>();
+		}
+		{
+			struct Shape {
+				pod::Vector4f values;
+				pod::Vector3f diffuse;
+				float specular;
+				uint32_t id;
+				pod::Vector3ui _pad;
+			};
+
+			std::vector<Shape> shapes;
+			{
+				shapes.push_back( {{1.75f, -0.5f, 0.0f, 1.0f },  { 0.0f, 1.0f,   0.0f}, 32.0f, 1} );
+				shapes.push_back( {{0.0f, 1.0f, -0.5f, 1.0f },  {0.65f, 0.77f, 0.97f}, 32.0f, 1} );
+				shapes.push_back( {{-1.75f, -0.75f, -0.5f, 1.25f }, { 0.9f, 0.76f, 0.46f}, 32.0f, 1} );
+			}
+			{
+				float roomDim = 12.0f;
+				shapes.push_back( {{0.0f, 1.0f, 0.0f, roomDim}, {1.0f, 1.0f, 1.0f}, 32.0f, 2} );
+				shapes.push_back( {{0.0f, -1.0f, 0.0f, roomDim}, {1.0f, 1.0f, 1.0f}, 32.0f, 2} );
+				shapes.push_back( {{0.0f, 0.0f, 1.0f, roomDim}, {1.0f, 1.0f, 1.0f}, 32.0f, 2} );
+				shapes.push_back( {{0.0f, 0.0f, -1.0f, roomDim}, {0.0f, 0.0f, 0.0f}, 32.0f, 2} );
+				shapes.push_back( {{-1.0f, 0.0f, 0.0f, roomDim}, {1.0f, 0.0f, 0.0f}, 32.0f, 2} );
+				shapes.push_back( {{1.0f, 0.0f, 0.0f, roomDim}, {0.0f, 1.0f, 0.0f}, 32.0f, 2} );
+			}
+			renderMode.compute.device = &uf::renderer::device;
+			renderMode.compute.initializeBuffer(
+				(void*) shapes.data(),
+				shapes.size() * sizeof(Shape),
+				uf::renderer::enums::Buffer::STORAGE
+			);
+		}
+	}
+}
+void ext::RayTracingSceneBehavior::tick( uf::Object& self ) {
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	uf::Asset& assetLoader = this->getComponent<uf::Asset>();
+
+#if 1
+	if ( this->hasComponent<uf::renderer::ComputeRenderMode>() ) {
+		auto& renderMode = this->getComponent<uf::renderer::ComputeRenderMode>();
+		/* Add lights to scene */ if ( renderMode.compute.initialized ) {
+			renderMode.execute = true;
+			struct UniformDescriptor {
+				alignas(16) pod::Matrix4f matrices[2];
+				alignas(16) pod::Vector4f ambient;
+				struct {
+					alignas(8) pod::Vector2f range;
+					alignas(8) pod::Vector2f padding;
+					alignas(16) pod::Vector4f color;
+				} fog;
+				struct Light {
+					alignas(16) pod::Vector4f position;
+					alignas(16) pod::Vector4f color;
+					alignas(8) pod::Vector2i type;
+					alignas(8) pod::Vector2i padding;
+					alignas(16) pod::Matrix4f view;
+					alignas(16) pod::Matrix4f projection;
+				} lights;
+			};
+			
+			auto& shader = renderMode.compute.material.shaders.front();
+			struct SpecializationConstant {
+				uint32_t maxLights = 16;
+				uint32_t eyes = 2;
+			};
+			auto& specializationConstants = shader.specializationConstants.get<SpecializationConstant>();
+
+			struct PushConstant {
+				uint32_t marchingSteps;
+				uint32_t rayBounces;
+				float shadowFactor;
+				float reflectionStrength;
+				float reflectionFalloff;
+			};
+			auto& pushConstant = shader.pushConstants.front().get<PushConstant>();
+			pushConstant.marchingSteps = metadata["rays"]["marching steps"].as<size_t>();
+			pushConstant.rayBounces = metadata["rays"]["ray bounces"].as<size_t>();
+			pushConstant.shadowFactor = metadata["rays"]["shadow factor"].as<float>();
+			pushConstant.reflectionStrength = metadata["rays"]["reflection"]["strength"].as<float>();
+			pushConstant.reflectionFalloff = metadata["rays"]["reflection"]["falloff"].as<float>();
+
+			auto& scene = uf::scene::getCurrentScene();
+			auto& controller = scene.getController();
+			auto& camera = controller.getComponent<uf::Camera>();
+			auto& transform = controller.getComponent<pod::Transform<>>();
+			
+			auto& userdata = shader.uniforms.front();
+			size_t uniforms_len = userdata.data().len;
+			uint8_t* uniforms_buffer = (uint8_t*) (void*) userdata;
+			UniformDescriptor* uniforms = (UniformDescriptor*) uniforms_buffer;
+			for ( size_t i = 0; i < 2; ++i ) {
+				uniforms->matrices[i] = uf::matrix::inverse( camera.getProjection(i) * camera.getView(i) );
+			}
+
+			{
+				uniforms->ambient.x = metadata["light"]["ambient"][0].as<float>();
+				uniforms->ambient.y = metadata["light"]["ambient"][1].as<float>();
+				uniforms->ambient.z = metadata["light"]["ambient"][2].as<float>();
+				uniforms->ambient.w = metadata["light"]["kexp"].as<float>();
+			}
+			{
+				uniforms->fog.color.x = metadata["light"]["fog"]["color"][0].as<float>();
+				uniforms->fog.color.y = metadata["light"]["fog"]["color"][1].as<float>();
+				uniforms->fog.color.z = metadata["light"]["fog"]["color"][2].as<float>();
+				
+				uniforms->fog.range.x = metadata["light"]["fog"]["range"][0].as<float>();
+				uniforms->fog.range.y = metadata["light"]["fog"]["range"][1].as<float>();
+			}
+		
+			std::vector<uf::Entity*> entities;
+			std::function<void(uf::Entity*)> filter = [&]( uf::Entity* entity ) {
+				if ( !entity || entity->getName() != "Light" ) return;
+				entities.push_back(entity);
+			};
+			for ( uf::Scene* scene : uf::scene::scenes ) { if ( !scene ) continue;
+				scene->process(filter);
+			}
+			{
+				const pod::Vector3& position = controller.getComponent<pod::Transform<>>().position;
+				std::sort( entities.begin(), entities.end(), [&]( const uf::Entity* l, const uf::Entity* r ){
+					if ( !l ) return false; if ( !r ) return true;
+					if ( !l->hasComponent<pod::Transform<>>() ) return false; if ( !r->hasComponent<pod::Transform<>>() ) return true;
+					return uf::vector::magnitude( uf::vector::subtract( l->getComponent<pod::Transform<>>().position, position ) ) < uf::vector::magnitude( uf::vector::subtract( r->getComponent<pod::Transform<>>().position, position ) );
+				} );
+			}
+
+			{
+				uf::Serializer& metadata = controller.getComponent<uf::Serializer>();
+			//	if ( metadata["light"]["should"].as<bool>() )
+					entities.push_back(&controller);
+			}
+			UniformDescriptor::Light* lights = (UniformDescriptor::Light*) &uniforms_buffer[sizeof(UniformDescriptor) - sizeof(UniformDescriptor::Light)];
+			for ( size_t i = 0; i < specializationConstants.maxLights && i < entities.size(); ++i ) {
+				UniformDescriptor::Light& light = lights[i];
+				uf::Entity* entity = entities[i];
+
+				pod::Transform<>& transform = entity->getComponent<pod::Transform<>>();
+				uf::Serializer& metadata = entity->getComponent<uf::Serializer>();
+				uf::Camera& camera = entity->getComponent<uf::Camera>();
+				
+				light.position.x = transform.position.x;
+				light.position.y = transform.position.y;
+				light.position.z = transform.position.z;
+
+				if ( entity == &controller ) light.position.y += 2;
+
+				light.position.w = metadata["light"]["radius"][1].as<float>();
+
+				light.color.x = metadata["light"]["color"][0].as<float>();
+				light.color.y = metadata["light"]["color"][1].as<float>();
+				light.color.z = metadata["light"]["color"][2].as<float>();
+
+				light.color.w = metadata["light"]["power"].as<float>();
+			}
+		
+			shader.updateBuffer( (void*) uniforms_buffer, uniforms_len, 0  );
+		}
+	}
+#endif
+}
+void ext::RayTracingSceneBehavior::render( uf::Object& self ) {
+}
+void ext::RayTracingSceneBehavior::destroy( uf::Object& self ) {
+	if ( this->hasComponent<uf::renderer::ComputeRenderMode>() ) {
+		auto& renderMode = this->getComponent<uf::renderer::ComputeRenderMode>();
+		uf::renderer::removeRenderMode( &renderMode, false );
+	}
+}
+#undef this
\ No newline at end of file
diff --git a/ext/scenes/raytrace/behavior.h b/ext/scenes/raytrace/behavior.h
new file mode 100644
index 00000000..d020acb0
--- /dev/null
+++ b/ext/scenes/raytrace/behavior.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/ext/ext.h>
+#include <uf/engine/entity/entity.h>
+#include <uf/engine/scene/scene.h>
+
+namespace ext {
+	class EXT_API RayTracingSceneBehavior {
+	public:
+		static void attach( uf::Object& );
+		static void initialize( uf::Object& );
+		static void tick( uf::Object& );
+		static void render( uf::Object& );
+		static void destroy( uf::Object& );
+	};
+}
\ No newline at end of file
diff --git a/ext/scenes/worldscape/behavior.cpp b/ext/scenes/worldscape/behavior.cpp
new file mode 100644
index 00000000..7093321e
--- /dev/null
+++ b/ext/scenes/worldscape/behavior.cpp
@@ -0,0 +1,122 @@
+#include "behavior.h"
+
+#include <uf/utils/time/time.h>
+#include <uf/utils/io/iostream.h>
+#include <uf/utils/math/vector.h>
+#include <uf/utils/math/transform.h>
+#include <uf/utils/window/window.h>
+
+#include <uf/utils/audio/audio.h>
+#include <uf/utils/thread/thread.h>
+#include <uf/utils/camera/camera.h>
+
+#include <uf/engine/asset/asset.h>
+#include <uf/engine/asset/masterdata.h>
+
+#include "../../ext.h"
+
+#include <uf/utils/renderer/renderer.h>
+#include <uf/ext/openvr/openvr.h>
+
+UF_BEHAVIOR_REGISTER_CPP(ext::WorldScapeSceneBehavior)
+#define this ((uf::Scene*) &self)
+void ext::WorldScapeSceneBehavior::initialize( uf::Object& self ) {
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	uf::Asset& assetLoader = this->getComponent<uf::Asset>();
+
+	/* Grab master data */ {
+		std::vector<std::string> tables = {
+			"Card",
+			"Chara",
+			"Skill",
+			"Element",
+			"Status",
+		};
+		for ( auto& table : tables ) {
+			uf::MasterData data;
+			metadata["system"]["mastertable"][table] = data.load(table);
+		}
+	}
+
+	static uf::Timer<long long> timer(false);
+	if ( !timer.running() ) timer.start();
+/*	
+	this->addHook( "world:Battle.Prepare", [&](const std::string& event)->std::string{
+		uf::Serializer json = event;
+
+		uf::Entity& player = this->getController();
+		uf::Serializer& pMetadata = player.getComponent<uf::Serializer>();
+
+		uf::Serializer payload;
+		
+		payload["battle"]["music"] = json["music"];
+		payload["battle"]["enemy"] = json[""];
+		payload["battle"]["enemy"]["uid"] = json["uid"];
+
+		payload["battle"]["player"] = pMetadata[""];
+		payload["battle"]["player"]["uid"] = player.getUid();
+
+		pMetadata["system"]["control"] = false;
+		pMetadata["system"]["menu"] = "battle";
+			
+		this->callHook("world:Battle.Start", payload);
+
+		return "true";
+	});
+	this->addHook( "world:Battle.Start", [&](const std::string& event)->std::string{
+		if ( timer.elapsed().asDouble() < 1 ) return "false";
+		timer.reset();
+		uf::Object* guiManager = (uf::Object*) this->globalFindByName("Gui Manager");
+		if ( !guiManager ) return "false";
+		uf::Serializer json = event;
+
+		ext::HousamoBattle* battleManager = new ext::HousamoBattle;
+		this->addChild(*battleManager);
+		battleManager->initialize();
+		battleManager->callHook("world:Battle.Start.%UID%", json);
+
+		uf::Serializer payload;
+		return payload;
+	});
+	this->addHook( "world:Battle.End", [&](const std::string& event)->std::string{
+		uf::Serializer json = event;
+		ext::HousamoBattle* battleManager = (ext::HousamoBattle*) this->globalFindByName("Battle Manager");
+		if ( !battleManager ) return "false";
+
+		this->removeChild(*battleManager);
+		battleManager->destroy();
+		delete battleManager;
+
+		return "true";
+	});
+	this->addHook( "menu:Dialogue.Start", [&](const std::string& event)->std::string{
+		if ( timer.elapsed().asDouble() < 1 ) return "false";
+		timer.reset();
+		uf::Object* guiManager = (uf::Object*) this->globalFindByName("Gui Manager");
+		if ( !guiManager ) return "false";
+		uf::Serializer json = event;
+
+		ext::DialogueManager* dialogueManager = new ext::DialogueManager;
+		this->addChild(*dialogueManager);
+		dialogueManager->initialize();
+		dialogueManager->callHook("menu:Dialogue.Start.%UID%", json);
+		return json;
+	});
+	this->addHook( "menu:Dialogue.End", [&](const std::string& event)->std::string{
+		uf::Serializer json = event;
+		ext::DialogueManager* dialogueManager = (ext::DialogueManager*) this->globalFindByName("Dialogue Manager");
+		if ( !dialogueManager ) return "false";
+
+		this->removeChild(*dialogueManager);
+		dialogueManager->destroy();
+		delete dialogueManager;
+
+		return "true";
+	});
+*/
+}
+void ext::WorldScapeSceneBehavior::tick( uf::Object& self ) {
+}
+void ext::WorldScapeSceneBehavior::render( uf::Object& self ){}
+void ext::WorldScapeSceneBehavior::destroy( uf::Object& self ){}
+#undef this
\ No newline at end of file
diff --git a/ext/scenes/worldscape/behavior.h b/ext/scenes/worldscape/behavior.h
new file mode 100644
index 00000000..5fbbbf23
--- /dev/null
+++ b/ext/scenes/worldscape/behavior.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/ext/ext.h>
+#include <uf/engine/entity/entity.h>
+#include <uf/engine/scene/scene.h>
+
+namespace ext {
+	class EXT_API WorldScapeSceneBehavior {
+	public:
+		static void attach( uf::Object& );
+		static void initialize( uf::Object& );
+		static void tick( uf::Object& );
+		static void render( uf::Object& );
+		static void destroy( uf::Object& );
+	};
+}
\ No newline at end of file
diff --git a/ext/scenes/worldscape/gui/battle.cpp b/ext/scenes/worldscape/gui/battle.cpp
new file mode 100644
index 00000000..963bb666
--- /dev/null
+++ b/ext/scenes/worldscape/gui/battle.cpp
@@ -0,0 +1,1523 @@
+#include "battle.h"
+
+#include <uf/utils/hook/hook.h>
+#include <uf/utils/time/time.h>
+#include <uf/utils/serialize/serializer.h>
+#include <uf/utils/userdata/userdata.h>
+#include <uf/utils/window/window.h>
+#include <uf/utils/camera/camera.h>
+#include <uf/utils/string/ext.h>
+// #include <uf/gl/glyph/glyph.h>
+#include <uf/utils/math/physics.h>
+
+#include "..//battle.h"
+#include <uf/engine/asset/asset.h>
+
+#include <unordered_map>
+
+//#include <uf/ext/renderer/renderer.h>
+
+#include <uf/utils/http/http.h>
+#include <uf/utils/audio/audio.h>
+#include <sys/stat.h>
+#include <fstream>
+
+namespace {
+	ext::Gui* circleIn;
+	ext::Gui* circleOut;
+	ext::Gui* battleMessage;
+	ext::Gui* commandOptions;
+	ext::Gui* battleOptions;
+	ext::Gui* targetOptions;
+	ext::Gui* optionsBackground;
+	ext::Gui* turnCounters;
+	ext::Gui* partyMemberCommandCircle;
+	ext::Gui* critCutInBackground;
+	ext::Gui* critCutIn;
+
+	std::vector<ext::Gui*> partyMemberButtons(5);
+//	std::vector<ext::Gui*> partyMemberIcons(5);
+//	std::vector<ext::Gui*> partyMemberTexts(5);
+	std::vector<ext::Gui*> particles;
+
+	ext::HousamoBattle* battleManager;
+
+
+	uf::Serializer masterTableGet( const std::string& table ) {
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Serializer& mastertable = scene.getComponent<uf::Serializer>();
+		return mastertable["system"]["mastertable"][table];
+	}
+	uf::Serializer masterDataGet( const std::string& table, const std::string& key ) {
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Serializer& mastertable = scene.getComponent<uf::Serializer>();
+		return mastertable["system"]["mastertable"][table][key];
+	}
+	inline int64_t parseInt( const std::string& str ) {
+		return atoi(str.c_str());
+	}
+	inline std::string colorString( const std::string& hex ) {
+		return "%#" + hex + "%";
+	}
+
+	void playSound( ext::GuiBattle& entity, const std::string& id, const std::string& key ) {
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Serializer& masterdata = scene.getComponent<uf::Serializer>();
+
+		uf::Serializer cardData = masterDataGet("Card", id);
+		uf::Serializer charaData = masterDataGet("Chara", cardData["character_id"].as<std::string>());
+		std::string name = charaData["filename"].as<std::string>();
+
+		if ( name == "none" ) return;
+
+		std::string url = "https://cdn..xyz//unity/Android/voice/voice_" + name + "_"+key+".ogg";
+		if ( charaData["internal"].as<bool>() ) {
+			url = "/smtsamo/voice/voice_" + name + "_" + key + ".ogg";
+		}
+
+		uf::Asset& assetLoader = scene.getComponent<uf::Asset>();
+		assetLoader.cache(url, "asset:Cache.Voice." + std::to_string(entity.getUid()));
+	}
+	void playSound( ext::GuiBattle& entity, std::size_t uid, const std::string& key ) {
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Serializer& pMetadata = entity.getComponent<uf::Serializer>();
+		uf::Serializer& masterdata = scene.getComponent<uf::Serializer>();
+
+		uf::Entity*  = scene.findByUid(uid);
+		if ( ! ) return;
+		uf::Serializer& metadata = ->getComponent<uf::Serializer>();
+		std::string id = metadata[""]["id"].as<std::string>();
+		playSound( entity, id, key );
+	}
+	void playSound( ext::GuiBattle& entity, const std::string& key ) {
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Serializer& metadata = entity.getComponent<uf::Serializer>();
+		uf::Serializer& masterdata = scene.getComponent<uf::Serializer>();
+
+		std::string url = uf::io::root+"/audio/ui/" + key + ".ogg";
+
+		uf::Asset& assetLoader = scene.getComponent<uf::Asset>();
+		assetLoader.cache(url, "asset:Cache.SFX." + std::to_string(entity.getUid()));
+	}
+	void playMusic( ext::GuiBattle& entity, const std::string& filename ) {
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Asset& assetLoader = scene.getComponent<uf::Asset>();
+		uf::Serializer& masterdata = scene.getComponent<uf::Serializer>();
+
+		assetLoader.load(filename, "asset:Load." + std::to_string(scene.getUid()));
+	}
+	std::string getKeyFromIndex( uf::Serializer& object, uint64_t index ) {
+		uint64_t i = 0;
+		std::string key = "";
+		for ( auto it = object.begin(); it != object.end(); ++it ) {
+			if ( i++ == index ) key = it.key();
+		}
+		return key;
+	}
+
+	uf::Audio sfx;
+	uf::Audio voice;
+
+	struct BattleStats {
+		struct {
+			int selection = 0;
+			int selectionsMax = 3;
+			std::vector<std::string> invalids;
+		} skill;
+		struct {
+			int selection = 0;
+			int selectionsMax = 3;
+			std::vector<std::string> invalids;
+			uf::Serializer current;
+		} actions;
+		struct {
+			int selection = 0;
+			int selectionsMax = 3;
+			std::vector<std::string> invalids;
+			uf::Serializer current;
+		} targets;
+		uf::Serializer currentMember;
+		uf::Serializer previousMember;
+		std::string state = "open";
+		bool initialized = false;
+	};
+	static BattleStats stats;
+}
+
+
+void ext::GuiBattle::initialize() {
+	ext::Gui::initialize();
+
+	uf::Scene& scene = uf::scene::getCurrentScene();
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	battleManager = (ext::HousamoBattle*) this->getRootParent().findByName( "Battle Manager" );
+
+	partyMemberButtons = std::vector<ext::Gui*>(5);
+
+	this->addHook( "asset:Cache.SFX." + std::to_string(this->getUid()), [&](const std::string& event)->std::string{	
+		uf::Serializer json = event;
+		
+		std::string filename = json["filename"].as<std::string>();
+
+		if ( uf::io::extension(filename) != "ogg" ) return "false";
+
+		if ( filename == "" ) return "false";
+		uf::Serializer& masterdata = scene.getComponent<uf::Serializer>();
+		uf::Audio& sfx = this->getComponent<uf::SoundEmitter>().add(filename);
+	/*
+		uf::Audio& sfx = this->getComponent<uf::Audio>();
+		if ( sfx.playing() ) sfx.stop();
+		sfx = uf::Audio();
+		sfx.load(filename);
+	*/
+		sfx.setVolume(masterdata["volumes"]["sfx"].as<float>());
+		sfx.play();
+
+		return "true";
+	});
+
+	this->addHook( "asset:Cache.Voice." + std::to_string(this->getUid()), [&](const std::string& event)->std::string{	
+		uf::Serializer json = event;
+		
+		std::string filename = json["filename"].as<std::string>();
+
+		if ( uf::io::extension(filename) != "ogg" ) return "false";
+
+		if ( filename == "" ) return "false";
+		uf::Serializer& masterdata = scene.getComponent<uf::Serializer>();
+		uf::Audio& voice = this->getComponent<uf::Audio>();
+		if ( voice.playing() ) voice.stop();
+		voice = uf::Audio();
+		voice.load(filename);
+		voice.setVolume(masterdata["volumes"]["voice"].as<float>());
+		voice.play();
+
+		return "true";
+	});
+
+	// lock control
+	{
+		uf::Serializer payload;
+		payload["state"] = true;
+		uf::hooks.call("window:Mouse.CursorVisibility", payload);
+		uf::hooks.call("window:Mouse.Lock");
+	}
+	{
+		battleMessage = new ext::Gui;
+		this->addChild(*battleMessage);
+		battleMessage->as<uf::Object>().load("./battle-text.json", true);
+		battleMessage->initialize();
+	}
+	/* Magic Circle Outter */ {
+		circleOut = new ext::Gui;
+		this->addChild(*circleOut);
+		circleOut->as<uf::Object>().load("./circle-out.json", true);
+		circleOut->initialize();
+	}
+	/* Magic Circle Inner */ {
+		circleIn = new ext::Gui;
+		this->addChild(*circleIn);
+		circleIn->as<uf::Object>().load("./circle-in.json", true);
+		circleIn->initialize();
+	}
+	/* Command Circle */ {
+		partyMemberCommandCircle = new ext::Gui;
+		this->addChild(*partyMemberCommandCircle);
+		partyMemberCommandCircle->as<uf::Object>().load("./partyMemberCommandCircle.json", true);
+		partyMemberCommandCircle->initialize();
+	}
+	/* Command Circle */ {
+		optionsBackground = new ext::Gui;
+		this->addChild(*optionsBackground);
+		optionsBackground->as<uf::Object>().load("./optionsBackground.json", true);
+		optionsBackground->initialize();
+	}
+	/* Turn Counter Container */ {
+		turnCounters = new ext::Gui;
+		this->addChild(*turnCounters);
+		turnCounters->as<uf::Object>().load("./turnCounters.json", true);
+		turnCounters->initialize();
+	}	
+
+	this->addHook("world:Battle.TurnStart.%UID%", [&](const std::string& event) -> std::string {
+		uf::Serializer json = event;
+
+		
+		// turn start, play sfx
+		if ( json["battle"]["turn"]["start of turn"].as<bool>() ) {
+			playSound(*this, "turn");
+		}
+		
+		return "true";
+	});
+	this->addHook("world:Battle.Damage.%UID%", [&](const std::string& event) -> std::string {
+		uf::Serializer json = event;
+
+		std::string uid = json["target"]["uid"].as<std::string>();
+		std::string damage = json["target"]["damage"].as<std::string>();
+
+		pod::Transform<> pTransform;
+		pTransform.position = { 0, 0, 0 };
+
+		for ( auto* pointerButton : partyMemberButtons ) {
+			if ( !pointerButton ) continue;
+			if ( pointerButton->getUid() == 0 ) continue;
+			for ( auto* pointer : pointerButton->getChildren() ) {
+				if ( !pointer ) continue;
+				if ( pointer->getUid() == 0 ) continue;
+				if ( pointer->getName() == "Menu: Party Member Icon" ) {
+					uf::Serializer& pMetadata = pointer->getComponent<uf::Serializer>();
+					if ( pMetadata[""]["uid"].as<std::string>() != uid ) continue;
+					pTransform = pointer->getComponent<pod::Transform<>>();
+					pTransform.position.y -= (0.1);
+				}
+			}
+		}
+		ext::Gui* particle = new ext::Gui;
+		this->addChild(*particle);
+		uf::Serializer& pMetadata = particle->getComponent<uf::Serializer>();
+		particle->as<uf::Object>().load("./damageText.json", true);
+		std::string color = json["color"].is<std::string>() ? json["color"].as<std::string>() : "FF0000";
+		pMetadata["text settings"]["string"] = "%#"+color+"%" + damage;
+		pod::Transform<>& transform = particle->getComponent<pod::Transform<>>();
+		transform = pTransform;
+		pMetadata["system"]["percent"] = 0;
+		particle->initialize();
+		particles.push_back(particle);
+
+		return "true";
+	});
+	this->addHook("world:Battle.Message.%UID%", [&](const std::string& event) -> std::string {
+		uf::Serializer json = event;
+		std::string message = json["message"].as<std::string>();
+
+		if ( battleMessage ) {
+			battleMessage->destroy();
+			this->removeChild(*battleMessage);
+			delete battleMessage;	
+		}
+		battleMessage = new ext::Gui;
+		this->addChild(*battleMessage);
+		uf::Serializer& pMetadata = battleMessage->getComponent<uf::Serializer>();
+		battleMessage->as<uf::Object>().load("./battle-text.json", true);
+		pMetadata["text settings"]["string"] = message;
+		battleMessage->initialize();
+
+	//	std::cout << message << std::endl;
+
+		return "true";
+	});
+	this->addHook("world:Battle.RemoveOnCrit.%UID%", [&](const std::string& event) -> std::string {
+		if ( critCutInBackground && critCutInBackground->getUid() != 0 ) {
+			critCutInBackground->destroy();
+			this->removeChild(*critCutInBackground);
+			delete critCutInBackground;	
+			critCutInBackground = NULL;
+		}
+		if ( critCutIn && critCutIn->getUid() != 0 ) {
+			critCutIn->destroy();
+			this->removeChild(*critCutIn);
+			delete critCutIn;	
+			critCutIn = NULL;
+		}
+		return "true";
+	});
+	this->addHook("world:Battle.OnCrit.%UID%", [&](const std::string& event) -> std::string {
+		uf::Serializer json = event;
+		if ( critCutInBackground && critCutInBackground->getUid() != 0 ) {
+			critCutInBackground->destroy();
+			this->removeChild(*critCutInBackground);
+			delete critCutInBackground;	
+			critCutInBackground = NULL;
+		}
+		if ( critCutIn && critCutIn->getUid() != 0 ) {
+			critCutIn->destroy();
+			this->removeChild(*critCutIn);
+			delete critCutIn;	
+			critCutIn = NULL;
+		}
+		{
+			critCutInBackground = new ext::Gui;
+			this->addChild(*critCutInBackground);
+			critCutInBackground->as<uf::Object>().load("./critCutInBackground.json", true);
+			critCutInBackground->initialize();
+		}
+		{
+			critCutIn = new ext::Gui;
+			this->addChild(*critCutIn);
+			uf::Serializer& pMetadata = critCutIn->getComponent<uf::Serializer>();
+
+			uf::Serializer cardData = masterDataGet("Card", json["id"].as<std::string>());
+			pMetadata["system"]["assets"][0] = "/smtsamo/ci/ci_"+ cardData["filename"].as<std::string>() +".png";
+			if ( !uf::io::exists( pMetadata["system"]["assets"][0].as<std::string>() ) ) pMetadata["system"]["assets"][0] = ext::json::null();
+			critCutIn->as<uf::Object>().load("./critCutIn.json", true);
+			critCutIn->initialize();
+		}
+
+		playSound(*this, "crit");
+		this->queueHook("world:Battle.RemoveOnCrit.%UID%", ext::json::null(), 1.0);
+
+		return "true";
+	});
+	this->addHook("world:Battle.Update.%UID%", [&](const std::string& event) -> std::string {
+		uf::Serializer json = event;
+	
+		{
+			float turns = json["battle"]["turn"]["counter"].as<float>();
+			if ( turnCounters && turnCounters->getUid() != 0 ) {
+				this->removeChild(*turnCounters);
+				turnCounters->destroy();
+				delete turnCounters;
+			}
+			{
+				turnCounters = new ext::Gui;
+				this->addChild(*turnCounters);
+				turnCounters->as<uf::Object>().load("./turnCounters.json", true);
+				turnCounters->initialize();
+			}
+			// show full counters
+			float i = 0;
+			while ( turns > 0 ) {
+				ext::Gui* counter = new ext::Gui;
+				turnCounters->addChild(*counter);
+				counter->as<uf::Object>().load("./turnCounter.json", true);
+				counter->initialize();
+				pod::Transform<>& pTransform = counter->getComponent<pod::Transform<>>();
+				pTransform.position.x -= 0.142716f * (i++);
+
+				uf::Serializer& pMetadata = counter->getComponent<uf::Serializer>();
+				if ( json["battle"]["turn"]["phase"] == "enemy" ) {
+					pMetadata["color"][0] = 1.0f;
+					pMetadata["color"][1] = 0.4f;
+					pMetadata["color"][2] = 0.4f;
+					pMetadata["color"][3] = 1.0f;
+				} else {
+					pMetadata["color"][0] = 0.4f;
+					pMetadata["color"][1] = 0.0f;
+					pMetadata["color"][2] = 0.8f;
+					pMetadata["color"][3] = 1.0f;
+				}
+
+			//	if ( turns < 1.0f && turns > 0 ) pMetadata["uv"][0] = 0.5f;
+				if ( turns < 1.0f && turns > 0 ) {
+					pMetadata["half counter"] = true;
+					if ( json["battle"]["turn"]["phase"] == "enemy" ) {
+						pMetadata["color"][0] = 1.0f;
+						pMetadata["color"][1] = 0.7f;
+						pMetadata["color"][2] = 0.7f;
+						pMetadata["color"][3] = 1.0f;
+					} else {
+						pMetadata["color"][0] = 0.4f;
+						pMetadata["color"][1] = 0.3f;
+						pMetadata["color"][2] = 0.9f;
+						pMetadata["color"][3] = 1.0f;
+					}
+				}
+				turns = turns - 1.0f;
+			}
+		}
+	
+		
+		int i = 0;
+
+	//	for ( auto& member : json["battle"]["transients"] ) {
+		ext::json::forEach(metadata["battle"]["transients"], [&](ext::json::Value& member, bool breaks){
+			if ( ext::json::isNull( member["uid"] ) ) return;
+			if ( member["type"] == "enemy" ) return;
+			if ( member["hp"].as<float>() <= 0 ) return;
+			if ( i >= 4 ) {
+				breaks = true;
+				return;
+			}
+			uf::Serializer cardData = masterDataGet("Card", member["id"].as<std::string>());
+			std::string name = cardData["filename"].as<std::string>();
+			if ( member["skin"].is<std::string>() ) name += "_" + member["skin"].as<std::string>();
+			std::string filename = "https://cdn..xyz//unity/Android/icon/icon_" + name + ".png";
+			if ( cardData["internal"].as<bool>() ) {
+				filename = "/smtsamo/icon/icon_" + name + ".png";
+			}
+
+			ext::Gui* partyMemberButton = NULL;
+			pod::Transform<> bTransform;
+
+			// completely recreate if different transient
+			if ( partyMemberButtons[i] != NULL ) {
+				partyMemberButton = partyMemberButtons[i];
+				uf::Serializer& pMetadata = partyMemberButton->getComponent<uf::Serializer>();
+				if ( pMetadata[""]["id"] != member["id"] ) {
+					this->removeChild(*partyMemberButton);
+					partyMemberButton->destroy();
+					delete partyMemberButton;
+					partyMemberButton = NULL;
+				} else {
+					pod::Transform<>& transform = partyMemberButton->getComponent<pod::Transform<>>();
+				 	bTransform = transform;
+				}
+			}
+
+			// update
+			if ( partyMemberButton ) {
+				{
+					ext::Gui* partyMemberText = (ext::Gui*) partyMemberButton->findByName("Menu: Party Member Text");
+					if ( partyMemberText ) {
+						partyMemberButton->removeChild(*partyMemberText);
+						partyMemberText->destroy();
+						delete partyMemberText;
+						partyMemberText = NULL;
+					}
+					partyMemberText = new ext::Gui;
+					partyMemberButton->addChild(*partyMemberText);
+					uf::Serializer& pMetadata = partyMemberText->getComponent<uf::Serializer>();
+					partyMemberText->as<uf::Object>().load("./partyMemberText.json", true);
+					pMetadata["text settings"]["string"] = "" + colorString("00FF00") + "" + member["hp"].as<std::string>() + "\n" + colorString("0000FF") + "" + member["mp"].as<std::string>();
+					pMetadata[""] = member;
+					pod::Transform<>& transform = partyMemberText->getComponent<pod::Transform<>>();
+					transform.position = bTransform.position;
+					transform.position.x += (-0.781352 - -0.694634) + 0.1;
+					partyMemberText->initialize();
+				}
+			
+				ext::Gui* partyMemberHP = (ext::Gui*) partyMemberButton->findByName("Menu: Party Member HP Bar");
+				if ( partyMemberHP ) {
+					uf::Serializer& pMetadata = partyMemberHP->getComponent<uf::Serializer>();
+					float percentage = 1.0f;
+					percentage = member["hp"].as<float>() / member["max hp"].as<float>();
+					// uv[0, 0] -> uv[09.43, 23.81]
+					// uv[1, 1] -> uv[84.91, 68.25]
+					pMetadata["uv"][2] = (percentage * 0.8491) + 0.0660;
+				//	pMetadata["uv"][3] = (percentage * 0.6808) + (1 - 0.0952);
+				}
+				ext::Gui* partyMemberMP = (ext::Gui*) partyMemberButton->findByName("Menu: Party Member MP Bar");
+				if ( partyMemberMP ) {
+					uf::Serializer& pMetadata = partyMemberMP->getComponent<uf::Serializer>();
+					float percentage = 1.0f;
+					percentage = member["mp"].as<float>() / member["max mp"].as<float>();
+					// uv[0, 0] -> uv[09.43, 23.81]
+					// uv[1, 1] -> uv[84.91, 68.25]
+					pMetadata["uv"][2] = (percentage * 0.8491) + 0.0943;
+				//	pMetadata["uv"][3] = (percentage * 0.6825) + (1 - 0.2381);
+				}
+			// recreate
+			} else {
+				{
+					partyMemberButton = new ext::Gui;
+					this->addChild(*partyMemberButton);
+					partyMemberButton->as<uf::Object>().load("./partyMemberButton.json", true);
+					
+					pod::Transform<>& transform = partyMemberButton->getComponent<pod::Transform<>>();
+					transform.position.y += (i * 0.45);
+				 	bTransform = transform;
+
+					partyMemberButton->initialize();
+
+					uf::Serializer& pMetadata = partyMemberButton->getComponent<uf::Serializer>();
+					pMetadata[""] = member;
+
+					partyMemberButtons[i] = partyMemberButton;
+				}
+				{
+					ext::Gui* partyMemberIconShadow = NULL;
+					partyMemberIconShadow = new ext::Gui;
+					partyMemberButton->addChild(*partyMemberIconShadow);
+					uf::Serializer& pMetadata = partyMemberIconShadow->getComponent<uf::Serializer>();
+					pMetadata["system"]["assets"][0] = filename;
+					partyMemberIconShadow->as<uf::Object>().load("./partyMemberIconShadow.json", true);
+					pMetadata[""] = member;
+					pod::Transform<>& transform = partyMemberIconShadow->getComponent<pod::Transform<>>();
+					transform.position = bTransform.position;
+					transform.position.x += (-0.781352 - -0.694634) + 0.01;
+					transform.position.y -= 0.01;
+					partyMemberIconShadow->initialize();
+				}
+				{
+					ext::Gui* partyMemberIcon = NULL;
+					partyMemberIcon = new ext::Gui;
+					partyMemberButton->addChild(*partyMemberIcon);
+					uf::Serializer& pMetadata = partyMemberIcon->getComponent<uf::Serializer>();
+					pMetadata["system"]["assets"][0] = filename;
+					partyMemberIcon->as<uf::Object>().load("./partyMemberIcon.json", true);
+					pMetadata[""] = member;
+					pod::Transform<>& transform = partyMemberIcon->getComponent<pod::Transform<>>();
+					transform.position = bTransform.position;
+					transform.position.x += (-0.781352 - -0.694634);
+					partyMemberIcon->initialize();
+				}
+				{
+					ext::Gui* partyMemberText = NULL;
+					partyMemberText = new ext::Gui;
+					partyMemberButton->addChild(*partyMemberText);
+					uf::Serializer& pMetadata = partyMemberText->getComponent<uf::Serializer>();
+					partyMemberText->as<uf::Object>().load("./partyMemberText.json", true);
+					pMetadata["text settings"]["string"] = "" + colorString("FF0000") + "" + member["hp"].as<std::string>() + "\n" + colorString("0000FF") + "" + member["mp"].as<std::string>();
+					pMetadata[""] = member;
+					pod::Transform<>& transform = partyMemberText->getComponent<pod::Transform<>>();
+					transform.position = bTransform.position;
+					transform.position.x += (-0.781352 - -0.694634) + 0.1;
+					partyMemberText->initialize();
+				}
+				{
+					ext::Gui* partyMemberBar = new ext::Gui;
+					partyMemberButton->addChild(*partyMemberBar);
+					partyMemberBar->as<uf::Object>().load("./partyMemberBars.json", true);
+					pod::Transform<>& transform = partyMemberBar->getComponent<pod::Transform<>>();
+					transform.position = bTransform.position;
+					transform.position.x = 0.742573;
+					transform.position.y += 0.1;
+					partyMemberBar->initialize();
+				}
+				{
+					ext::Gui* partyMemberHP = new ext::Gui;
+					partyMemberButton->addChild(*partyMemberHP);
+					partyMemberHP->as<uf::Object>().load("./partyMemberHP.json", true);
+					pod::Transform<>& transform = partyMemberHP->getComponent<pod::Transform<>>();
+					transform.position = bTransform.position;
+					transform.position.x = 0.742573;
+					transform.position.y += 0.1;
+					partyMemberHP->initialize();
+
+					uf::Serializer& pMetadata = partyMemberHP->getComponent<uf::Serializer>();
+					float percentage = 1.0f;
+					percentage = member["hp"].as<float>() / member["max hp"].as<float>();
+					// uv[0, 0] -> uv[09.43, 23.81]
+					// uv[1, 1] -> uv[84.91, 68.25]
+					pMetadata["uv"][2] = (percentage * 0.8491) + 0.0660;
+				//	pMetadata["uv"][3] = (percentage * 0.6808) + (1 - 0.0952);
+				}
+				{
+					ext::Gui* partyMemberMP = new ext::Gui;
+					partyMemberButton->addChild(*partyMemberMP);
+					partyMemberMP->as<uf::Object>().load("./partyMemberMP.json", true);
+					pod::Transform<>& transform = partyMemberMP->getComponent<pod::Transform<>>();
+					transform.position = bTransform.position;
+					transform.position.x = 0.742573;
+					transform.position.y += 0.1;
+					partyMemberMP->initialize();
+
+					uf::Serializer& pMetadata = partyMemberMP->getComponent<uf::Serializer>();
+					float percentage = 1.0f;
+					percentage = member["mp"].as<float>() / member["max mp"].as<float>();
+					// uv[0, 0] -> uv[09.43, 23.81]
+					// uv[1, 1] -> uv[84.91, 68.25]
+					pMetadata["uv"][2] = (percentage * 0.8491) + 0.0943;
+				//	pMetadata["uv"][3] = (percentage * 0.6825) + (1 - 0.2381);
+				}
+			}
+			++i;
+		});
+		for ( ; i < 4; ++i ) {
+			if ( partyMemberButtons[i] != NULL ) {
+				ext::Gui*& partyMemberButton = partyMemberButtons[i];
+				this->removeChild(*partyMemberButton);
+				partyMemberButton->destroy();
+				delete partyMemberButton;
+				partyMemberButton = NULL;
+			}
+		}
+		return "true";
+	});
+
+	this->addHook("menu:Close.%UID%", [&]( const std::string& event ) -> std::string {		
+		// kill
+		this->getParent().removeChild(*this);
+		this->destroy();
+		delete this;
+		return "true";
+	});
+
+	stats = BattleStats();
+}
+void ext::GuiBattle::tick() {
+	if ( !battleManager ) return;
+
+	uf::Scene& scene = uf::scene::getCurrentScene();
+	uf::Serializer& masterdata = scene.getComponent<uf::Serializer>();
+	uf::Serializer& bMetadata = this->getComponent<uf::Serializer>();
+
+	static float alpha = 0.0f;
+	static uf::Timer<long long> timer(false);
+	static float timeout = 1.0f;
+	if ( !timer.running() ) timer.start();
+	static std::string queuedAction;
+
+	std::function<void(uf::Serializer&)> postParseResult = [&]( uf::Serializer& result ) {
+		if ( result["end"].as<bool>() ) bMetadata["system"]["closing"] = true;
+		if ( !ext::json::isNull( result["timeout"] ) ) timeout = result["timeout"].as<float>();
+		else timeout = 1;
+		// modify timeout based on string length
+		if ( result["message"].is<std::string>() && !ext::json::isNull( result["target"] ) ) {
+			uint64_t size = result["message"].as<std::string>().size();
+			float modified = size * 0.025f;
+			if ( timeout < modified ) timeout = modified;
+		}
+
+		uf::Serializer payload;
+		payload["message"] = result["message"];
+		this->callHook("world:Battle.Message.%UID%", payload);
+
+		timer.reset();
+	};
+
+	std::function<void(uf::Serializer)> renderSkillOptions = [&]( uf::Serializer member ) {
+		if ( battleOptions ) {
+			this->removeChild(*battleOptions);
+			battleOptions->destroy();
+			delete battleOptions;
+			battleOptions = NULL;
+		}
+		if ( ext::json::isNull( member["uid"] ) ) {
+			stats.previousMember = stats.currentMember;
+			return;
+		}
+		stats.currentMember = member;
+		std::string string = "";
+		std::size_t counter = 0;
+		std::size_t start = stats.skill.selection;
+		stats.actions.invalids.clear();
+		stats.currentMember["skills"] = ext::json::array();
+		for ( int i = 0; i < member["skills"].size(); ++i ) {
+			std::string id = member["skills"][i].as<std::string>();
+			uf::Serializer skillData = masterDataGet("Skill", id);
+			bool add = false;
+			if ( skillData["type"].as<int>() > 0 && skillData["type"].as<int>() < 16 ) add = true;
+			if ( add ) stats.currentMember["skills"].emplace_back(id);
+		}
+
+		std::string skillDescription = "";
+
+		for ( int i = start; i < stats.currentMember["skills"].size(); ++i ) {
+			std::string id = stats.currentMember["skills"][i].as<std::string>();
+			std::string text = "";
+			if ( std::find( stats.skill.invalids.begin(), stats.skill.invalids.end(), id ) != stats.skill.invalids.end() ) continue;
+			if ( ++counter > stats.skill.selectionsMax ) break;
+			uf::Serializer cardData = masterDataGet("Card", member["id"].as<std::string>());
+			uf::Serializer charaData = masterDataGet("Chara", cardData["character_id"].as<std::string>());
+			uf::Serializer skillData = masterDataGet("Skill", id);
+			if ( id != "0" ) {
+				text = skillData["name"].as<std::string>();
+			} else {
+				text = "攻撃";
+			}
+			if ( i != stats.skill.selection ) {
+				text = "" + colorString("FFFFFF") + "" + text;
+			}
+			else {
+				text = "" + colorString("FF0000") + "" + text;
+				skillDescription = skillData["effect"].as<std::string>();
+				if ( skillData["mp"].is<double>() ) {
+					int64_t cost = skillData["mp"].as<int>();
+					skillDescription = skillData["effect"].as<std::string>() + "\nCost: " + colorString("0000FF") + ""+std::to_string(cost)+" MP" + colorString("FFFFFF") + "";
+				}
+				if ( skillData["hp%"].is<double>() ) {
+					int64_t cost = skillData["hp%"].as<int>();
+					cost = member["max hp"].as<float>() * ( cost / 100.0f );
+					skillDescription = skillData["effect"].as<std::string>() + "\nCost: " + colorString("00FF00") + ""+std::to_string(cost)+" HP" + colorString("FFFFFF") + "";
+				}
+			}
+			string += "\n" + text;
+		}
+		if ( stats.currentMember["skills"].size() > stats.skill.selectionsMax ) {
+			for ( int i = 0; i < stats.currentMember["skills"].size(); ++i ) {
+				std::string id = stats.currentMember["skills"][i].as<std::string>();
+				std::string text = "";
+				if ( std::find( stats.skill.invalids.begin(), stats.skill.invalids.end(), id ) != stats.skill.invalids.end() ) continue;
+				if ( ++counter > stats.skill.selectionsMax ) break;
+				if ( id != "0" ) {
+					uf::Serializer cardData = masterDataGet("Card", member["id"].as<std::string>());
+					uf::Serializer charaData = masterDataGet("Chara", cardData["character_id"].as<std::string>());
+					uf::Serializer skillData = masterDataGet("Skill", id);
+
+					text = skillData["name"].as<std::string>();
+				} else {
+					uf::Serializer cardData = masterDataGet("Card", member["id"].as<std::string>());
+					uf::Serializer charaData = masterDataGet("Chara", cardData["character_id"].as<std::string>());
+
+					text = "攻撃";
+				}
+				if ( i != stats.skill.selection ) text = "" + colorString("FFFFFF") + "" + text;
+				else text = "" + colorString("FF0000") + "" + text;
+				string += "\n" + text;
+			}
+		}
+		if ( string != "" ) {
+			string = string.substr(1);
+			battleOptions = new ext::Gui;
+			this->addChild(*battleOptions);
+			uf::Serializer& pMetadata = battleOptions->getComponent<uf::Serializer>();
+			battleOptions->as<uf::Object>().load("./battle-option.json", true);
+			pMetadata["text settings"]["string"] = string;
+			pod::Transform<>& pTransform = battleOptions->getComponent<pod::Transform<>>();
+			battleOptions->initialize();
+		}
+		if ( skillDescription != "" ) {
+			uf::Serializer payload;
+			payload["message"] = skillDescription;
+			this->callHook("world:Battle.Message.%UID%", payload);
+		}
+	};
+	std::function<void(uf::Serializer)> renderCommandOptions = [&]( uf::Serializer actions ) {
+		if ( commandOptions ) {
+			this->removeChild(*commandOptions);
+			commandOptions->destroy();
+			delete commandOptions;
+			commandOptions = NULL;
+		}
+		if ( ext::json::isNull( actions ) ) {
+			stats.actions.selection = 0;
+			queuedAction = "";
+			return;
+		}
+		stats.actions.current = actions;
+		std::string string = "";
+		std::size_t counter = 0;
+		std::size_t start = stats.actions.selection;
+		auto keys = ext::json::keys( actions );
+		for ( int i = start; i < keys.size(); ++i ) {
+			std::string key = getKeyFromIndex( actions, i );
+			std::string text = actions[key].as<std::string>();
+			if ( std::find( stats.actions.invalids.begin(), stats.actions.invalids.end(), key ) != stats.actions.invalids.end() ) continue;
+			if ( ++counter > stats.actions.selectionsMax ) break;
+			if ( i != stats.actions.selection ) text = "" + colorString("FFFFFF") + "" + text;
+			else text = "" + colorString("FF0000") + "" + text;
+			string += "\n" + text;
+		}
+		if ( keys.size() > stats.actions.selectionsMax ) {
+			for ( int i = 0; i < keys.size(); ++i ) {
+				std::string key = getKeyFromIndex( actions, i );
+				std::string text = actions[key].as<std::string>();
+				if ( std::find( stats.actions.invalids.begin(), stats.actions.invalids.end(), key ) != stats.actions.invalids.end() ) continue;
+				if ( ++counter > stats.actions.selectionsMax ) break;
+				if ( i != stats.actions.selection ) text = "" + colorString("FFFFFF") + "" + text;
+				else text = "" + colorString("FF0000") + "" + text;
+				string += "\n" + text;
+			}
+		}
+		if ( string != "" ) {
+			string = string.substr(1);
+			commandOptions = new ext::Gui;
+			this->addChild(*commandOptions);
+			uf::Serializer& pMetadata = commandOptions->getComponent<uf::Serializer>();
+			commandOptions->as<uf::Object>().load("./battle-option.json", true);
+			pMetadata["text settings"]["string"] = string;
+			pod::Transform<>& pTransform = commandOptions->getComponent<pod::Transform<>>();
+			commandOptions->initialize();
+		}
+	};
+	std::function<void(uf::Serializer)> renderTargetOptions = [&]( uf::Serializer actions ) {
+		if ( targetOptions ) {
+			this->removeChild(*targetOptions);
+			targetOptions->destroy();
+			delete targetOptions;
+			targetOptions = NULL;
+		}
+		if ( ext::json::isNull( actions ) ) {
+			stats.skill.selection = 0;
+			stats.targets.selection = 0;
+			return;
+		}
+		stats.targets.current = actions;
+		std::string string = "";
+		std::size_t counter = 0;
+		std::size_t start = stats.targets.selection;
+		stats.skill.invalids.clear();
+		stats.actions.invalids.clear();
+		std::string targetDescription = "";
+		for ( int i = start; i < actions.size(); ++i ) {
+			uf::Serializer cardData = masterDataGet("Card", actions[i]["id"].as<std::string>());
+			uf::Serializer charaData = masterDataGet("Chara", cardData["character_id"].as<std::string>());
+			std::string text = charaData["name"].as<std::string>();
+			if ( std::find( stats.targets.invalids.begin(), stats.targets.invalids.end(), text ) != stats.targets.invalids.end() ) continue;
+			if ( ++counter > stats.targets.selectionsMax ) break;
+			if ( i != stats.targets.selection ) text = "" + colorString("FFFFFF") + "" + text;
+			else text = "" + colorString("FF0000") + "" + text;
+			string += "\n" + text;
+		}
+		if ( actions.size() > stats.targets.selectionsMax ) {
+			for ( int i = 0; i < actions.size(); ++i ) {
+				uf::Serializer cardData = masterDataGet("Card", actions[i]["id"].as<std::string>());
+				uf::Serializer charaData = masterDataGet("Chara", cardData["character_id"].as<std::string>());
+				std::string text = charaData["name"].as<std::string>();
+				if ( std::find( stats.targets.invalids.begin(), stats.targets.invalids.end(), text ) != stats.targets.invalids.end() ) continue;
+				if ( ++counter > stats.targets.selectionsMax ) break;
+				if ( i != stats.targets.selection ) text = "" + colorString("FFFFFF") + "" + text;
+				else text = "" + colorString("FF0000") + "" + text;
+				string += "\n" + text;
+			}
+		}
+		if ( string != "" ) {
+			string = string.substr(1);
+			targetOptions = new ext::Gui;
+			this->addChild(*targetOptions);
+			uf::Serializer& pMetadata = targetOptions->getComponent<uf::Serializer>();
+			targetOptions->as<uf::Object>().load("./battle-option.json", true);
+			pMetadata["text settings"]["string"] = string;
+			pod::Transform<>& pTransform = targetOptions->getComponent<pod::Transform<>>();
+			targetOptions->initialize();
+		}
+		if ( queuedAction == "analyze" ) {
+			uf::Serializer payload;
+			payload["uid"] = stats.targets.current[stats.targets.selection]["uid"].as<std::string>();
+		//	if ( payload["uid"].as<std::string>() == "")
+			payload["action"] = "analyze";
+			uf::Serializer result = battleManager->callHook("world:Battle.Action.%UID%", payload)[0].as<uf::Serializer>();
+
+			targetDescription = result["message"].as<std::string>();
+		}
+		if ( targetDescription != "" ) {
+			uf::Serializer payload;
+			payload["message"] = targetDescription;
+			this->callHook("world:Battle.Message.%UID%", payload);
+		}
+	};
+
+
+	if ( !stats.initialized ) {
+		stats.initialized = true;
+		uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+		this->addHook("world:Battle.Turn.%UID%", [&](const std::string& event) -> std::string {
+			uf::Serializer json = event;
+			uf::Serializer payload;
+			payload["action"] = "turn-start";
+			if ( !ext::json::isNull( stats.previousMember["uid"] ) ) payload["uid"] = stats.previousMember["uid"].as<size_t>() + 1;
+			auto hookCall = battleManager->callHook("world:Battle.Action.%UID%", payload);
+			if ( hookCall.empty() ) {
+				metadata["system"]["closing"] = true;
+				return "false";
+			}
+			uf::Serializer result = hookCall[0].as<uf::Serializer>();
+
+			if ( result["end"].as<bool>() ) {
+				if ( ext::json::isObject( metadata ) ) metadata["system"]["closing"] = true;
+				return "false";
+			}
+
+			postParseResult(result);
+			if ( ext::json::isNull( result["uid"] ) ) return "false";
+			uint64_t uid = result["uid"].as<size_t>();
+
+			renderCommandOptions(std::string(""));
+			renderSkillOptions(std::string(""));
+			renderTargetOptions(std::string(""));
+
+			payload = uf::Serializer{};
+			payload["uid"] = uid;
+			if ( result[""]["type"] == "enemy" ) {
+				payload["action"] = "enemy-attack";
+			} else if ( result["skipped"].as<bool>() ) {
+				payload["action"] = "forced-pass";
+			} else {
+				stats.currentMember = result[""];
+				renderCommandOptions(result["actions"]);
+				return "true";
+			}
+			result = battleManager->callHook("world:Battle.Action.%UID%", payload)[0].as<uf::Serializer>();
+			postParseResult(result);
+			stats.previousMember = uf::Serializer{};
+			timer.reset();
+			stats.state = "waiting";
+			this->queueHook("world:Battle.Turn.%UID%", ext::json::null(), timeout);
+			return "true";
+		});
+		this->queueHook("world:Battle.Turn.%UID%");
+	}
+
+	{
+		uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+		if ( metadata["system"]["closing"].as<bool>() ) {
+			if ( alpha >= 1.0f ) {
+				uf::Asset assetLoader;
+				std::string canonical = assetLoader.load(uf::io::root+"/audio/ui/menu close.ogg");
+				uf::Audio& sfx = assetLoader.get<uf::Audio>(canonical);
+				sfx.setVolume(masterdata["volumes"]["sfx"].as<float>());
+				sfx.play();
+			}
+			if ( alpha <= 0.0f ) {
+				alpha = 0.0f;
+				metadata["system"]["closing"] = false;
+				metadata["system"]["closed"] = true;
+			} else alpha -= uf::physics::time::delta;
+			metadata["color"][3] = alpha;
+		} else if ( metadata["system"]["closed"].as<bool>() ) {
+			uf::Object& parent = this->getParent<uf::Object>();
+			parent.getComponent<uf::Serializer>()["system"]["closed"] = true;
+			this->destroy();
+			parent.removeChild(*this);
+		} else {
+			if ( !metadata["initialized"].as<bool>() ) alpha = 0.0f;
+			metadata["initialized"] = true;
+			if ( alpha >= 1.0f ) alpha = 1.0f;
+			else alpha += uf::physics::time::delta * 1.5f;
+			metadata["color"][3] = alpha;
+		}
+	}
+
+	if ( circleIn ) {
+		pod::Transform<>& transform = circleIn->getComponent<pod::Transform<>>();
+		static float time = 0.0f;
+		float speed = 0.0125f;
+		uf::Serializer& metadata = circleIn->getComponent<uf::Serializer>();
+		if ( metadata["hovered"].as<bool>() ) speed = -0.25f;
+		time += uf::physics::time::delta * speed;
+		transform.orientation = uf::quaternion::axisAngle( { 0.0f, 0.0f, 1.0f }, time );
+
+		static pod::Vector3f start = { transform.position.x, -2.0f, 0.0f };
+		static pod::Vector3f end = transform.position;
+		static float delta = 0.0f;
+		if ( !metadata["initialized"].as<bool>() ) delta = 0.0f;
+		metadata["initialized"] = true;
+		if ( delta >= 1 ) delta = 1;
+		else {
+			delta += uf::physics::time::delta * 1.5f;
+			transform.position = uf::vector::lerp( start, end, delta );
+		}
+		metadata["color"][3] = alpha * 0.1f;
+	}
+	if ( circleOut ) {
+		pod::Transform<>& transform = circleOut->getComponent<pod::Transform<>>();
+		uf::Serializer& metadata = circleOut->getComponent<uf::Serializer>();
+		static float time = 0.0f;
+		float speed = 0.0125f;
+		if ( metadata["hovered"].as<bool>() ) speed = 0.25f;
+		time += uf::physics::time::delta * speed;
+		transform.orientation = uf::quaternion::axisAngle( { 0.0f, 0.0f, 1.0f }, time );
+
+		static pod::Vector3f start = { transform.position.x, 2.0f, 0.0f };
+		static pod::Vector3f end = transform.position;
+		static float delta = 0.0f;
+		if ( !metadata["initialized"].as<bool>() ) delta = 0.0f;
+		metadata["initialized"] = true;
+		if ( delta >= 1 ) delta = 1;
+		else {
+			delta += uf::physics::time::delta * 1.5f;
+			transform.position = uf::vector::lerp( start, end, delta );
+		}
+		metadata["color"][3] = alpha * 0.1f;
+	}
+	if ( turnCounters ) { 
+		static float time = 0.0f;
+		time += uf::physics::time::delta;
+		for ( uf::Entity* pointer : turnCounters->getChildren() ) {
+			uf::Serializer& pMetadata = pointer->getComponent<uf::Serializer>();
+			float coeff = 2.0f;
+	//		if ( pMetadata["half counter"].as<bool>() ) coeff = 4.0f;
+		//	pMetadata["color"][3] = sin(time * coeff) * 0.25f + 0.75f;
+			pMetadata["color"][3] = std::min( 1.0f, (float) sin(time * coeff) * 0.5f + 1.0f );
+		}
+	}
+	if ( optionsBackground ) {
+		pod::Transform<>& transform = optionsBackground->getComponent<pod::Transform<>>();
+		uf::Serializer& metadata = optionsBackground->getComponent<uf::Serializer>();
+
+		static pod::Vector3f start = { transform.position.x, 2.0f, 0.0f };
+		static pod::Vector3f end = transform.position;
+		static float delta = 0.0f;
+		if ( !metadata["initialized"].as<bool>() ) delta = 0.0f;
+		metadata["initialized"] = true;
+		if ( delta >= 1 ) delta = 1;
+		else {
+			delta += uf::physics::time::delta * 1.5f;
+			transform.position = uf::vector::lerp( start, end, delta );
+		}
+		metadata["color"][3] = alpha;
+		if ( !commandOptions && !battleOptions && !targetOptions ) {
+			metadata["color"][3] = 0.1f;
+		}
+	}
+
+	for ( auto* pointerButton : partyMemberButtons ) {
+		if ( !pointerButton ) continue;
+		if ( pointerButton->getUid() == 0 ) continue;
+		for ( auto* pointer : pointerButton->getChildren() ) {
+			if ( !pointer ) continue;
+			if ( pointer->getUid() == 0 ) continue;
+			if ( pointer->getName() == "Menu: Party Member Icon" ) {
+				pod::Transform<>& transform = pointer->getComponent<pod::Transform<>>();
+				uf::Serializer& metadata = pointer->getComponent<uf::Serializer>();
+				metadata["color"][3] = alpha;
+				if ( metadata["clicked"].as<bool>() && timer.elapsed().asDouble() >= timeout ) {
+				}
+				static float color = 0.0f;
+			//	std::cout << pointer << ": " << metadata << ": " << stats.currentMember << std::endl;
+				if ( metadata[""]["uid"] == stats.currentMember["uid"] ) {
+					color += uf::physics::time::delta * 4.0f;
+					float factor = (1 - (1.0f + cos(color)) / 8.0f);
+					metadata["color"][0] = 1.0f * factor;
+					metadata["color"][1] = 1.0f * factor;
+					metadata["color"][2] = 0.6f * factor;
+
+					if ( partyMemberCommandCircle && partyMemberCommandCircle->getUid() != 0 ) {
+						uf::Serializer& metadata = partyMemberCommandCircle->getComponent<uf::Serializer>();
+						pod::Transform<>& pTransform = partyMemberCommandCircle->getComponent<pod::Transform<>>();
+						if ( pTransform.position.x == 0 && pTransform.position.y == 0 ) {
+							pTransform.position.x = transform.position.x;
+							pTransform.position.y = transform.position.y;
+						}
+						metadata["system"]["lerp"]["delta"] = 0;
+						metadata["system"]["lerp"]["start"][0] = pTransform.position.x;
+						metadata["system"]["lerp"]["start"][1] = pTransform.position.y;
+						metadata["system"]["lerp"]["start"][2] = pTransform.position.z;
+						metadata["system"]["lerp"]["end"][0] = transform.position.x;
+						metadata["system"]["lerp"]["end"][1] = transform.position.y;
+						metadata["system"]["lerp"]["end"][2] = transform.position.z;
+					}
+				} else {
+					metadata["color"][0] = 1.0f;
+					metadata["color"][2] = 1.0f;
+					metadata["color"][2] = 1.0f;
+				}
+			} else if ( pointer->getName() == "Menu: Party Member Text" ) {
+				pod::Transform<>& transform = pointer->getComponent<pod::Transform<>>();
+				uf::Serializer& metadata = pointer->getComponent<uf::Serializer>();
+				metadata["color"][3] = alpha;
+				if ( metadata["clicked"].as<bool>() && timer.elapsed().asDouble() >= timeout ) {
+				}
+				static float color = 0.0f;
+			//	std::cout << pointer << ": " << metadata << ": " << stats.currentMember << std::endl;
+				if ( metadata[""]["uid"] == stats.currentMember["uid"] ) {
+					color += uf::physics::time::delta * 4.0f;
+					float factor = (1 - (1.0f + cos(color)) / 8.0f);
+					metadata["color"][0] = 1.0f * factor;
+					metadata["color"][1] = 1.0f * factor;
+					metadata["color"][2] = 0.6f * factor;
+				} else {
+					metadata["color"][0] = 1.0f;
+					metadata["color"][2] = 1.0f;
+					metadata["color"][2] = 1.0f;
+				}
+			}
+		}
+	}
+	/* particles */ for ( auto it = particles.begin(); it != particles.end(); ++it ) {
+		ext::Gui* particle = *it;
+		if ( !particle ) { particles.erase( it ); return; }
+		if ( particle->getUid() == 0 ) { particles.erase( it ); return; }
+		uf::Serializer& metadata = particle->getComponent<uf::Serializer>();
+		pod::Transform<>& transform = particle->getComponent<pod::Transform<>>();
+		// state 1
+	//	std::cout << particle << ": " <<  metadata["system"]["percent"] << ": " << metadata["text settings"]["string"] <<  std::endl;
+	//	std::cout << transform.position.x << ", " << transform.position.y << ", " << transform.position.z << std::endl;
+	#if !UF_NO_EXCEPTIONS
+		try
+	#endif
+		{
+			if ( !ext::json::isObject( metadata["system"] ) ) {
+				this->removeChild(*particle);
+				particle->destroy();
+				delete particle;
+				*it = NULL;
+				continue;
+			}
+			if ( metadata["system"]["percent"] < 0.25f ) {
+				transform.position.y -= uf::physics::time::delta / 2.0f;
+			} else if ( metadata["system"]["percent"] < 0.5f ) {
+				transform.position.y += uf::physics::time::delta / 2.0f;
+			} else if ( metadata["system"]["percent"] < 1.0f ) {
+			} else {
+				this->removeChild(*particle);
+				particle->destroy();
+				delete particle;
+				*it = NULL;
+				continue;
+			}
+			metadata["system"]["percent"] = metadata["system"]["percent"].as<float>() + uf::physics::time::delta;
+		}
+	#if !UF_NO_EXCEPTIONS
+		catch ( ... ) {
+			if ( particle ) {
+				this->removeChild(*particle);
+				particle->destroy();
+				delete particle;
+				*it = NULL;
+			}
+		}
+	#endif
+	}
+
+	for ( auto* pointer : partyMemberButtons ) {
+		if ( !pointer ) continue;
+		if ( pointer->getUid() == 0 ) continue;
+		pod::Transform<>& transform = pointer->getComponent<pod::Transform<>>();
+		uf::Serializer& metadata = pointer->getComponent<uf::Serializer>();
+		metadata["color"][3] = alpha;
+	}
+
+	if ( partyMemberCommandCircle && partyMemberCommandCircle->getUid() != 0 ) {
+		pod::Transform<>& transform = partyMemberCommandCircle->getComponent<pod::Transform<>>();
+		uf::Serializer& metadata = partyMemberCommandCircle->getComponent<uf::Serializer>();
+		static float time = 0.0f;
+		float speed = 0.5f;
+		if ( metadata["hovered"].as<bool>() ) speed = 0.75f;
+		time += uf::physics::time::delta * speed;
+		transform.orientation = uf::quaternion::axisAngle( { 0.0f, 0.0f, 1.0f }, time );
+		metadata["color"][3] = alpha;
+
+		{
+			pod::Vector3f start = {
+				metadata["system"]["lerp"]["start"][0].as<float>(),
+				metadata["system"]["lerp"]["start"][1].as<float>(),
+				metadata["system"]["lerp"]["start"][2].as<float>(),
+			};
+			pod::Vector3f end = {
+				metadata["system"]["lerp"]["end"][0].as<float>(),
+				metadata["system"]["lerp"]["end"][1].as<float>(),
+				metadata["system"]["lerp"]["end"][2].as<float>(),
+			};
+			float delta = metadata["system"]["lerp"]["delta"].as<float>();
+			if ( delta >= 1 ) delta = 1;
+			else {
+				delta += uf::physics::time::delta * 8.0f;
+				transform.position = uf::vector::lerp( start, end, delta );
+			}
+			metadata["system"]["lerp"]["delta"] = delta;
+		}
+	}
+	
+	ext::Gui::tick();
+
+	if ( stats.state != "open" ) {
+		if ( timer.elapsed().asDouble() >= timeout ) stats.state = "open";
+		return;
+	}
+
+	struct {
+		bool up = uf::Window::isKeyPressed("W");
+		bool down = uf::Window::isKeyPressed("S");
+		bool back = uf::Window::isKeyPressed("Escape");
+		bool select = uf::Window::isKeyPressed("Enter");
+	} keys;
+
+	if ( targetOptions ) {
+		bool delta = false;
+		bool invalid = false;
+		pod::Transform<>& transform = targetOptions->getComponent<pod::Transform<>>();
+		uf::Serializer& metadata = targetOptions->getComponent<uf::Serializer>();
+		metadata["color"][3] = alpha;
+		for ( uf::Entity* pointer : targetOptions->getChildren()  ) {
+			uf::Serializer& cMetadata = pointer->getComponent<uf::Serializer>();
+			cMetadata["text settings"]["color"][3] = alpha;
+		}
+		static bool released = true;
+		if ( keys.up ) { 
+			if ( released ) {
+				delta = true;
+				released = false;
+				do {
+					--stats.targets.selection;
+					if ( stats.targets.selection < 0 ) { stats.targets.selection = stats.targets.current.size() - 1; }
+				} while ( std::find( stats.targets.invalids.begin(), stats.targets.invalids.end(), stats.targets.current[stats.targets.selection]["id"].as<std::string>() ) != stats.targets.invalids.end() );
+			}
+		}
+		else if ( keys.down ) {
+			if ( released ) {
+				delta = true;
+				released = false;
+				do {
+					++stats.targets.selection;
+					if ( stats.targets.selection >= stats.targets.current.size() ) { stats.targets.selection = 0; }
+				} while ( std::find( stats.targets.invalids.begin(), stats.targets.invalids.end(), stats.targets.current[stats.targets.selection]["id"].as<std::string>() ) != stats.targets.invalids.end() );
+			}
+		}
+		else released = true;
+		if ( stats.targets.selection < 0 ) { stats.targets.selection = stats.targets.current.size() - 1; }
+		else if ( stats.targets.selection >= stats.targets.current.size() ) { stats.targets.selection = 0; }
+		if ( queuedAction == "analyze" ) keys.select = false;
+		if ( !released ) {
+			if ( invalid ) {
+				playSound(*this, "invalid select");
+			} else if ( delta ) {
+				playSound(*this, "menu flip");
+				renderTargetOptions(stats.targets.current);
+			}
+		} else if ( keys.back && timer.elapsed().asDouble() >= timeout ) {
+			playSound(*this, "menu close");
+			renderTargetOptions(std::string(""));
+			if ( queuedAction == "analyze" ) {
+				renderSkillOptions(std::string(""));
+				renderCommandOptions(stats.actions.current);
+			} else renderSkillOptions(stats.currentMember);
+			timer.reset();
+		} else if ( keys.select && timer.elapsed().asDouble() >= timeout ) {
+			playSound(*this, "menu close");
+			
+			uf::Serializer payload;
+			payload["action"] = "member-attack";
+			payload["uid"] = stats.currentMember["uid"];
+			payload["target"] = ext::json::array();
+			payload["target"].emplace_back(stats.targets.current[stats.targets.selection]["uid"]);
+			payload["skill"] = stats.currentMember["skills"][stats.skill.selection];
+
+			uf::Serializer result = battleManager->callHook("world:Battle.Action.%UID%", payload)[0].as<uf::Serializer>();
+			postParseResult(result);
+
+			renderTargetOptions(std::string(""));
+			renderCommandOptions(std::string(""));
+			renderSkillOptions(std::string(""));
+
+			timer.reset();
+			stats.state = "waiting";
+			if ( result["invalid"].as<bool>() ) {
+			//	stats.actions.invalids.push_back(action);
+				renderCommandOptions(stats.actions.current);
+			//	this->queueHook("world:Battle.Turn.%UID%", ext::json::null(), timeout);
+			} else {
+				this->queueHook("world:Battle.Turn.%UID%", ext::json::null(), timeout);
+			}
+		}
+	} else if ( battleOptions ) {
+		bool delta = false;
+		bool invalid = false;
+		pod::Transform<>& transform = battleOptions->getComponent<pod::Transform<>>();
+		uf::Serializer& metadata = battleOptions->getComponent<uf::Serializer>();
+		metadata["color"][3] = alpha;
+		for ( uf::Entity* pointer : battleOptions->getChildren()  ) {
+			uf::Serializer& cMetadata = pointer->getComponent<uf::Serializer>();
+			cMetadata["text settings"]["color"][3] = alpha;
+		}
+		static bool released = true;
+		if ( keys.up ) { 
+			if ( released ) {
+				delta = true;
+				released = false;
+				do {
+					--stats.skill.selection;
+					if ( stats.skill.selection < 0 ) { stats.skill.selection = stats.currentMember["skills"].size()- 1; }
+				} while ( std::find( stats.skill.invalids.begin(), stats.skill.invalids.end(), stats.currentMember["skills"][stats.skill.selection].as<std::string>() ) != stats.skill.invalids.end() );
+			}
+		}
+		else if ( keys.down ) {
+			if ( released ) {
+				delta = true;
+				released = false;
+				do {
+					++stats.skill.selection;
+					if ( stats.skill.selection >= stats.currentMember["skills"].size()) { stats.skill.selection = 0; }
+				} while ( std::find( stats.skill.invalids.begin(), stats.skill.invalids.end(), stats.currentMember["skills"][stats.skill.selection].as<std::string>() ) != stats.skill.invalids.end() );
+			}
+		}
+		else released = true;
+		if ( !released ) {
+			if ( invalid ) {
+				playSound(*this, "menu close");
+			} else if ( delta ) {
+				playSound(*this, "menu flip");
+				renderSkillOptions(stats.currentMember);
+			}
+		} else if ( keys.back && timer.elapsed().asDouble() >= timeout ) {
+			playSound(*this, "menu close");
+			renderSkillOptions(std::string(""));
+			renderCommandOptions(stats.actions.current);
+			timer.reset();
+		} else if ( keys.select && timer.elapsed().asDouble() >= timeout ) {
+			playSound(*this, "menu close");
+			bool allRanged = false;
+			renderSkillOptions(std::string(""));
+			renderCommandOptions(std::string(""));
+
+
+			uf::Serializer payload;
+			payload["action"] = "member-targets";
+			payload["uid"] = stats.currentMember["uid"];
+			payload["skill"] = stats.currentMember["skills"][stats.skill.selection];
+			uf::Serializer result = battleManager->callHook("world:Battle.Action.%UID%", payload)[0].as<uf::Serializer>();
+
+			std::string skillId = stats.currentMember["skills"][stats.skill.selection].as<std::string>();
+			uf::Serializer skillData = masterDataGet("Skill", skillId);
+			if ( result["range"].is<double>() ) skillData["range"] = result["range"];
+			if ( skillData["range"].as<int>() > 1 ) {
+				uf::Serializer payload;
+				payload["action"] = "member-attack";
+				payload["uid"] = stats.currentMember["uid"];
+				payload["skill"] = stats.currentMember["skills"][stats.skill.selection];
+				uf::Serializer result = battleManager->callHook("world:Battle.Action.%UID%", payload)[0].as<uf::Serializer>();
+				postParseResult(result);
+				timer.reset();
+				stats.state = "waiting";
+				if ( result["invalid"].as<bool>() ) {
+				//	stats.actions.invalids.push_back(action);
+					renderCommandOptions(stats.actions.current);
+				//	this->queueHook("world:Battle.Turn.%UID%", ext::json::null(), timeout);
+				} else {
+					this->queueHook("world:Battle.Turn.%UID%", ext::json::null(), timeout);
+				}
+			} else {
+				postParseResult(result);
+				renderTargetOptions(result["targets"]);
+			}
+		}
+	} else if ( commandOptions ) {
+/*
+		bool delta = false;
+		bool invalid = false;
+		pod::Transform<>& transform = commandOptions->getComponent<pod::Transform<>>();
+		uf::Serializer& metadata = commandOptions->getComponent<uf::Serializer>();
+		metadata["color"][3] = alpha;
+		for ( uf::Entity* pointer : commandOptions->getChildren()  ) {
+			uf::Serializer& cMetadata = pointer->getComponent<uf::Serializer>();
+			cMetadata["text settings"]["color"][3] = alpha;
+		}
+		static bool released = true;
+		if ( keys.up ) { 
+			if ( released ) {
+				delta = true;
+				released = false;
+				do {
+					--stats.actions.selection;
+					if ( stats.actions.selection < 0 ) { stats.actions.selection = stats.actions.current.size() - 1; }
+				} while ( std::find( stats.actions.invalids.begin(), stats.actions.invalids.end(), stats.actions.current[stats.actions.selection].as<std::string>() ) != stats.actions.invalids.end() );
+			}
+		}
+		else if ( keys.down ) {
+			if ( released ) {
+				delta = true;
+				released = false;
+				do {
+					++stats.actions.selection;
+					if ( stats.actions.selection >= stats.actions.current.size() ) { stats.actions.selection = 0; }
+				} while ( std::find( stats.actions.invalids.begin(), stats.actions.invalids.end(), stats.actions.current[stats.actions.selection].as<std::string>() ) != stats.actions.invalids.end() );
+			}
+		}
+		else released = true;
+		if ( stats.actions.selection < 0 ) { stats.actions.selection = stats.actions.current.size() - 1; }
+		else if ( stats.actions.selection >= stats.actions.current.size() ) { stats.actions.selection = 0; }
+		if ( !released ) {
+			if ( invalid ) {
+				playSound(*this, "invalid select");
+			} else if ( delta ) {
+				playSound(*this, "menu flip");
+				renderCommandOptions(stats.actions.current);
+			}
+		} else if ( keys.back && timer.elapsed().asDouble() >= timeout ) {
+			playSound(*this, "invalid select");
+			timer.reset();
+		} else if ( keys.select && timer.elapsed().asDouble() >= timeout ) {
+			playSound(*this, "menu close");
+			uf::Serializer payload;
+			std::string action = stats.actions.current[stats.actions.selection].as<std::string>();
+			payload["action"] = action;
+			if ( payload["action"] == "member-attack" ) {
+				payload["uid"] = stats.currentMember["uid"];
+				payload["skill"] = stats.currentMember["skills"][stats.skill.selection];
+			}
+			uf::Serializer result = battleManager->callHook("world:Battle.Action.%UID%", payload)[0].as<uf::Serializer>();
+
+			postParseResult(result);
+			timer.reset();
+
+			renderCommandOptions(std::string(""));
+
+			stats.state = "waiting";
+			if ( result["invalid"].as<bool>() ) {
+				stats.actions.invalids.push_back(action);
+				renderCommandOptions(stats.actions.current);
+			//	this->queueHook("world:Battle.Turn.%UID%", ext::json::null(), timeout);
+			} else if ( payload["action"] == "member-attack" ) {
+				renderSkillOptions(std::string(""));
+				stats.state = "waiting";
+				this->queueHook("world:Battle.Turn.%UID%", ext::json::null(), timeout);
+			} else if ( payload["action"] == "member-skill" ) {
+				renderSkillOptions(stats.currentMember);
+			} else if ( payload["action"] == "pass" ) {
+				stats.previousMember = stats.currentMember;
+				this->queueHook("world:Battle.Turn.%UID%", ext::json::null(), timeout);
+			}
+		}
+	}
+*/
+		bool delta = false;
+		bool invalid = false;
+		pod::Transform<>& transform = commandOptions->getComponent<pod::Transform<>>();
+		uf::Serializer& metadata = commandOptions->getComponent<uf::Serializer>();
+		metadata["color"][3] = alpha;
+		for ( uf::Entity* pointer : commandOptions->getChildren()  ) {
+			uf::Serializer& cMetadata = pointer->getComponent<uf::Serializer>();
+			cMetadata["text settings"]["color"][3] = alpha;
+		}
+		static bool released = true;
+		if ( keys.up ) { 
+			if ( released ) {
+				delta = true;
+				released = false;
+				do {
+					--stats.actions.selection;
+					if ( stats.actions.selection < 0 ) { stats.actions.selection = stats.actions.current.size() - 1; }
+				} while ( std::find( stats.actions.invalids.begin(), stats.actions.invalids.end(), getKeyFromIndex(stats.actions.current, stats.actions.selection) ) != stats.actions.invalids.end() );
+			}
+		}
+		else if ( keys.down ) {
+			if ( released ) {
+				delta = true;
+				released = false;
+				do {
+					++stats.actions.selection;
+					if ( stats.actions.selection >= stats.actions.current.size() ) { stats.actions.selection = 0; }
+				} while ( std::find( stats.actions.invalids.begin(), stats.actions.invalids.end(), getKeyFromIndex(stats.actions.current, stats.actions.selection) ) != stats.actions.invalids.end() );
+			}
+		}
+		else released = true;
+		if ( stats.actions.selection < 0 ) { stats.actions.selection = stats.actions.current.size() - 1; }
+		else if ( stats.actions.selection >= stats.actions.current.size() ) { stats.actions.selection = 0; }
+		if ( stats.actions.current.size() == 0 ) released = true;
+		if ( !released ) {
+			if ( invalid ) {
+				playSound(*this, "invalid select");
+			} else if ( delta ) {
+				playSound(*this, "menu flip");
+				renderCommandOptions(stats.actions.current);
+			}
+		} else if ( keys.back && timer.elapsed().asDouble() >= timeout ) {
+			playSound(*this, "invalid select");
+			timer.reset();
+		} else if ( keys.select && timer.elapsed().asDouble() >= timeout ) {
+			playSound(*this, "menu close");
+			uf::Serializer payload;
+			std::string action = getKeyFromIndex(stats.actions.current, stats.actions.selection);
+			action = uf::io::extension(action);
+			payload["action"] = action;
+			payload["uid"] = stats.currentMember["uid"];
+		
+			if ( payload["action"] == "member-attack" ) {
+			//	payload["skill"] = stats.currentMember["skills"][0];
+				payload["skill"] = 0;
+			}
+		
+			if ( payload["action"] == "analyze" ) {
+				payload["action"] = "member-targets";
+			}
+			uf::Serializer result = battleManager->callHook("world:Battle.Action.%UID%", payload)[0].as<uf::Serializer>();
+
+		//	std::cout << payload << ": " << result << std::endl;
+
+			postParseResult(result);
+			timer.reset();
+
+			renderCommandOptions(std::string(""));
+			queuedAction = action;
+
+			stats.state = "waiting";
+			if ( result["invalid"].as<bool>() ) {
+				stats.actions.invalids.push_back(action);
+				renderCommandOptions(stats.actions.current);
+			} else if ( payload["action"] == "member-attack" ) {
+				renderSkillOptions(std::string(""));
+				stats.state = "waiting";
+				this->queueHook("world:Battle.Turn.%UID%", ext::json::null(), timeout);
+			} else if ( payload["action"] == "member-skill" ) {
+				renderSkillOptions(stats.currentMember);
+			} else if ( payload["action"] == "member-targets" ) {
+				renderTargetOptions(result["targets"]);
+			} else if ( payload["action"] == "pass" ) {
+				stats.previousMember = stats.currentMember;
+				this->queueHook("world:Battle.Turn.%UID%", ext::json::null(), timeout);
+			} else {
+				renderCommandOptions(stats.actions.current);
+			}
+		}
+	}
+}
+
+void ext::GuiBattle::render() {
+	ext::Gui::render();
+}
+
+void ext::GuiBattle::destroy() {
+	ext::Gui::destroy();
+}
\ No newline at end of file
diff --git a/ext/scenes/worldscape/gui/battle.h b/ext/scenes/worldscape/gui/battle.h
new file mode 100644
index 00000000..37227939
--- /dev/null
+++ b/ext/scenes/worldscape/gui/battle.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "../../../gui/gui.h"
+
+namespace ext {
+	class EXT_API GuiBattle : public ext::Gui {
+	public:
+		virtual void initialize();
+		virtual void tick();
+		virtual void render();
+		virtual void destroy();
+	};
+}
\ No newline at end of file
diff --git a/ext/scenes/worldscape/gui/dialogue.cpp b/ext/scenes/worldscape/gui/dialogue.cpp
new file mode 100644
index 00000000..0f335c17
--- /dev/null
+++ b/ext/scenes/worldscape/gui/dialogue.cpp
@@ -0,0 +1,393 @@
+#include "dialogue.h"
+
+#include <uf/utils/hook/hook.h>
+#include <uf/utils/time/time.h>
+#include <uf/utils/serialize/serializer.h>
+#include <uf/utils/userdata/userdata.h>
+#include <uf/utils/window/window.h>
+#include <uf/utils/camera/camera.h>
+#include <uf/utils/string/ext.h>
+// #include <uf/gl/glyph/glyph.h>
+#include <uf/engine/asset/asset.h>
+#include <uf/utils/math/physics.h>
+
+#include <unordered_map>
+
+//#include <uf/ext/renderer/renderer.h>
+
+#include <uf/utils/http/http.h>
+#include <uf/utils/audio/audio.h>
+#include <sys/stat.h>
+#include <fstream>
+
+#include "..//dialogue.h"
+
+namespace {
+	ext::Gui* circleIn;
+	ext::Gui* circleOut;
+	ext::Gui* dialogueMessage;
+	ext::Gui* dialogueOptions;
+
+	ext::DialogueManager* dialogueManager;
+
+	uf::Serializer masterTableGet( const std::string& table ) {
+		auto& scene = uf::scene::getCurrentScene();
+		uf::Serializer& mastertable = scene.getComponent<uf::Serializer>();
+		return mastertable["system"]["mastertable"][table];
+	}
+	uf::Serializer masterDataGet( const std::string& table, const std::string& key ) {
+		auto& scene = uf::scene::getCurrentScene();
+		uf::Serializer& mastertable = scene.getComponent<uf::Serializer>();
+		return mastertable["system"]["mastertable"][table][key];
+	}
+	inline int64_t parseInt( const std::string& str ) {
+		return atoi(str.c_str());
+	}
+
+	void playSound( ext::GuiDialogue& entity, const std::string& id, const std::string& key ) {
+		auto& scene = uf::scene::getCurrentScene();
+		uf::Serializer& masterdata = scene.getComponent<uf::Serializer>();
+
+		uf::Serializer cardData = masterDataGet("Card", id);
+		uf::Serializer charaData = masterDataGet("Chara", cardData["character_id"].as<std::string>());
+		std::string name = charaData["filename"].as<std::string>();
+		std::string url = "https://cdn..xyz//unity/Android/voice/voice_" + name + "_"+key+".ogg";
+		if ( charaData["internal"].as<bool>() ) {
+			url = "/smtsamo/voice/voice_" + name + "_" + key + ".ogg";
+		}
+
+		uf::Asset& assetLoader = scene.getComponent<uf::Asset>();
+		assetLoader.cache(url, "asset:Cache.Voice." + std::to_string(entity.getUid()));
+	}
+	void playSound( ext::GuiDialogue& entity, std::size_t uid, const std::string& key ) {
+		auto& scene = uf::scene::getCurrentScene();
+		uf::Serializer& pMetadata = entity.getComponent<uf::Serializer>();
+		uf::Serializer& masterdata = scene.getComponent<uf::Serializer>();
+
+		uf::Entity*  = scene.findByUid(uid);
+		if ( ! ) return;
+		uf::Serializer& metadata = ->getComponent<uf::Serializer>();
+		std::string id = metadata[""]["id"].as<std::string>();
+		playSound( entity, id, key );
+	}
+	void playSound( ext::GuiDialogue& entity, const std::string& key ) {
+		auto& scene = uf::scene::getCurrentScene();
+		uf::Serializer& metadata = entity.getComponent<uf::Serializer>();
+		uf::Serializer& masterdata = scene.getComponent<uf::Serializer>();
+
+		std::string url = uf::io::root+"/audio/ui/" + key + ".ogg";
+
+		uf::Asset& assetLoader = scene.getComponent<uf::Asset>();
+		assetLoader.cache(url, "asset:Cache.SFX." + std::to_string(entity.getUid()));
+	}
+	void playMusic( ext::GuiDialogue& entity, const std::string& filename ) {
+		auto& scene = uf::scene::getCurrentScene();
+		uf::Asset& assetLoader = scene.getComponent<uf::Asset>();
+		uf::Serializer& masterdata = scene.getComponent<uf::Serializer>();
+
+		assetLoader.load(filename, "asset:Load." + std::to_string(scene.getUid()));
+	}
+	std::string getKeyFromIndex( uf::Serializer& object, uint64_t index ) {
+		uint64_t i = 0;
+		std::string key = "";
+		for ( auto it = object.begin(); it != object.end(); ++it ) {
+			if ( i++ == index ) key = it.key();
+		}
+		return key;
+	}
+
+	uf::Audio sfx;
+	uf::Audio voice;
+
+	struct DialogueStats {
+		struct {
+			int selection = 0;
+			int selectionsMax = 3;
+			std::vector<std::string> invalids;
+			uf::Serializer current;
+			std::string index = "0";
+		} actions;
+		std::string state = "open";
+		bool initialized = false;
+	};
+	static DialogueStats stats;
+}
+
+
+void ext::GuiDialogue::initialize() {
+	ext::Gui::initialize();
+
+	uf::Scene& scene = uf::scene::getCurrentScene();
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	dialogueManager = (ext::DialogueManager*) this->getRootParent().findByName( "Dialogue Manager" );
+
+	this->addHook( "asset:Cache.SFX." + std::to_string(this->getUid()), [&](const std::string& event)->std::string{	
+		uf::Serializer json = event;
+		
+		std::string filename = json["filename"].as<std::string>();
+
+		if ( uf::io::extension(filename) != "ogg" ) return "false";
+
+		if ( filename == "" ) return "false";
+		uf::Serializer& masterdata = scene.getComponent<uf::Serializer>();
+		uf::Audio& sfx = this->getComponent<uf::Audio>();
+		if ( sfx.playing() ) sfx.stop();
+		sfx = uf::Audio();
+		sfx.load(filename);
+		sfx.setVolume(masterdata["volumes"]["sfx"].as<float>());
+		sfx.play();
+
+		return "true";
+	});
+
+	this->addHook( "asset:Cache.Voice." + std::to_string(this->getUid()), [&](const std::string& event)->std::string{	
+		uf::Serializer json = event;
+		
+		std::string filename = json["filename"].as<std::string>();
+
+		if ( uf::io::extension(filename) != "ogg" ) return "false";
+
+		if ( filename == "" ) return "false";
+		uf::Serializer& masterdata = scene.getComponent<uf::Serializer>();
+		uf::Audio& voice = this->getComponent<uf::Audio>();
+		if ( voice.playing() ) voice.stop();
+		voice = uf::Audio();
+		voice.load(filename);
+		voice.setVolume(masterdata["volumes"]["voice"].as<float>());
+		voice.play();
+
+		return "true";
+	});
+
+	// lock control
+	{
+		uf::Serializer payload;
+		payload["state"] = true;
+		uf::hooks.call("window:Mouse.CursorVisibility", payload);
+		uf::hooks.call("window:Mouse.Lock");
+	}
+
+	this->addHook("menu:Close.%UID%", [&]( const std::string& event ) -> std::string {		
+		// kill
+		this->getParent().removeChild(*this);
+		this->destroy();
+		delete this;
+		return "true";
+	});
+
+	stats = DialogueStats();
+}
+void ext::GuiDialogue::tick() {
+	if ( !dialogueManager ) return;
+
+	uf::Scene& scene = uf::scene::getCurrentScene();
+	uf::Serializer& masterdata = scene.getComponent<uf::Serializer>();
+	uf::Serializer& bMetadata = this->getComponent<uf::Serializer>();
+
+	static float alpha = 0.0f;
+	static uf::Timer<long long> timer(false);
+	static float timeout = 1.0f;
+	if ( !timer.running() ) timer.start();
+
+	std::function<void(uf::Serializer&)> postParseResult = [&]( uf::Serializer& result ) {
+		if ( result["end"].as<bool>() ) bMetadata["system"]["closing"] = true;
+		if ( !ext::json::isNull( result["timeout"] ) ) timeout = result["timeout"].as<float>();
+		else timeout = 1;
+		if ( result["message"].as<std::string>() != "" ) {
+			if ( dialogueMessage ) {
+				dialogueMessage->destroy();
+				this->removeChild(*dialogueMessage);
+				delete dialogueMessage;	
+			}
+			dialogueMessage = new ext::Gui;
+			this->addChild(*dialogueMessage);
+			uf::Serializer& pMetadata = dialogueMessage->getComponent<uf::Serializer>();
+			dialogueMessage->as<uf::Object>().load("./dialogue-text.json", true);
+			pMetadata["text settings"]["string"] = result["message"].as<std::string>();
+			dialogueMessage->initialize();
+		}
+		timer.reset();
+	};
+
+	std::function<void(uf::Serializer)> renderDialogueOptions = [&]( uf::Serializer actions ) {
+		if ( dialogueOptions ) {
+			this->removeChild(*dialogueOptions);
+			dialogueOptions->destroy();
+			delete dialogueOptions;
+			dialogueOptions = NULL;
+		}
+		if ( ext::json::isNull( actions ) ) {
+			stats.actions.selection = 0;
+			return;
+		}
+		stats.actions.current = actions;
+		std::string string = "";
+		std::size_t counter = 0;
+		std::size_t start = stats.actions.selection;
+		auto keys = ext::json::keys( actions );
+		for ( int i = start; i < keys.size(); ++i ) {
+			std::string key = getKeyFromIndex( actions, i );
+			std::string text = actions[key].as<std::string>();
+			if ( std::find( stats.actions.invalids.begin(), stats.actions.invalids.end(), key ) != stats.actions.invalids.end() ) continue;
+			if ( ++counter > stats.actions.selectionsMax ) break;
+			if ( i != stats.actions.selection ) text = "%#FFFFFF%" + text;
+			else text = "%#FF0000%" + text;
+			string += "\n" + text;
+		}
+		if ( keys.size() > stats.actions.selectionsMax ) {
+			for ( int i = 0; i < keys.size(); ++i ) {
+				std::string key = getKeyFromIndex( actions, i );
+				std::string text = actions[key].as<std::string>();
+				if ( std::find( stats.actions.invalids.begin(), stats.actions.invalids.end(), key ) != stats.actions.invalids.end() ) continue;
+				if ( ++counter > stats.actions.selectionsMax ) break;
+				if ( i != stats.actions.selection ) text = "%#FFFFFF%" + text;
+				else text = "%#FF0000%" + text;
+				string += "\n" + text;
+			}
+		}
+		if ( string != "" ) {
+			string = string.substr(1);
+			dialogueOptions = new ext::Gui;
+			this->addChild(*dialogueOptions);
+			uf::Serializer& pMetadata = dialogueOptions->getComponent<uf::Serializer>();
+			dialogueOptions->as<uf::Object>().load("./dialogue-option.json", true);
+			pMetadata["text settings"]["string"] = string;
+			pod::Transform<>& pTransform = dialogueOptions->getComponent<pod::Transform<>>();
+			dialogueOptions->initialize();
+		}
+	};
+
+	if ( !stats.initialized ) {
+		stats.initialized = true;
+		this->addHook("menu:Dialogue.Turn.%UID%", [&](const std::string& event) -> std::string {
+			uf::Serializer json = event;
+			uf::Serializer payload;
+			payload["action"] = "dialogue-select";
+			payload["index"] = stats.actions.index;
+			uf::Serializer result = dialogueManager->callHook("menu:Dialogue.Action.%UID%", payload)[0].as<uf::Serializer>();
+			postParseResult(result);
+
+			// renderDialogueOptions(std::string(""));
+			renderDialogueOptions(result["actions"]);
+
+			return "true";
+		});
+		this->queueHook("menu:Dialogue.Turn.%UID%");
+	}
+
+	{
+		uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+		if ( metadata["system"]["closing"].as<bool>() ) {
+			if ( alpha >= 1.0f ) {
+				uf::Asset assetLoader;
+				std::string canonical = assetLoader.load(uf::io::root+"/audio/ui/menu close.ogg");
+				uf::Audio& sfx = assetLoader.get<uf::Audio>(canonical);
+				sfx.setVolume(masterdata["volumes"]["sfx"].as<float>());
+				sfx.play();
+			}
+			if ( alpha <= 0.0f ) {
+				alpha = 0.0f;
+				metadata["system"]["closing"] = false;
+				metadata["system"]["closed"] = true;
+			} else alpha -= uf::physics::time::delta;
+			metadata["color"][3] = alpha;
+		} else if ( metadata["system"]["closed"].as<bool>() ) {
+			uf::Object& parent = this->getParent<uf::Object>();
+			parent.getComponent<uf::Serializer>()["system"]["closed"] = true;
+			this->destroy();
+			parent.removeChild(*this);
+		} else {
+			if ( !metadata["initialized"].as<bool>() ) alpha = 0.0f;
+			metadata["initialized"] = true;
+			if ( alpha >= 1.0f ) alpha = 1.0f;
+			else alpha += uf::physics::time::delta * 1.5f;
+			metadata["color"][3] = alpha;
+		}
+	}
+
+	ext::Gui::tick();
+
+	if ( stats.state != "open" ) {
+		if ( timer.elapsed().asDouble() >= timeout ) stats.state = "open";
+		return;
+	}
+
+	struct {
+		bool up = uf::Window::isKeyPressed("W");
+		bool down = uf::Window::isKeyPressed("S");
+		bool back = uf::Window::isKeyPressed("Escape");
+		bool select = uf::Window::isKeyPressed("E");
+	} keys;
+	static bool lastPress = false;
+
+	if ( dialogueOptions ) {
+		bool delta = false;
+		bool invalid = false;
+		pod::Transform<>& transform = dialogueOptions->getComponent<pod::Transform<>>();
+		uf::Serializer& metadata = dialogueOptions->getComponent<uf::Serializer>();
+		metadata["color"][3] = alpha;
+		for ( uf::Entity* pointer : dialogueOptions->getChildren()  ) {
+			uf::Serializer& cMetadata = pointer->getComponent<uf::Serializer>();
+			cMetadata["text settings"]["color"][3] = alpha;
+		}
+		static bool released = true;
+		if ( keys.up ) { 
+			if ( released ) {
+				delta = true;
+				released = false;
+				do {
+					--stats.actions.selection;
+					if ( stats.actions.selection < 0 ) { stats.actions.selection = stats.actions.current.size() - 1; }
+				} while ( std::find( stats.actions.invalids.begin(), stats.actions.invalids.end(), getKeyFromIndex(stats.actions.current, stats.actions.selection) ) != stats.actions.invalids.end() );
+			}
+		}
+		else if ( keys.down ) {
+			if ( released ) {
+				delta = true;
+				released = false;
+				do {
+					++stats.actions.selection;
+					if ( stats.actions.selection >= stats.actions.current.size() ) { stats.actions.selection = 0; }
+				} while ( std::find( stats.actions.invalids.begin(), stats.actions.invalids.end(), getKeyFromIndex(stats.actions.current, stats.actions.selection) ) != stats.actions.invalids.end() );
+			}
+		}
+		else released = true;
+		if ( stats.actions.selection < 0 ) { stats.actions.selection = stats.actions.current.size() - 1; }
+		else if ( stats.actions.selection >= stats.actions.current.size() ) { stats.actions.selection = 0; }
+		if ( stats.actions.current.size() == 0 ) released = true;
+		if ( !released ) {
+			if ( invalid ) {
+				playSound(*this, "invalid select");
+			} else if ( delta ) {
+				playSound(*this, "menu flip");
+				renderDialogueOptions(stats.actions.current);
+			}
+		} else if ( keys.back && timer.elapsed().asDouble() >= timeout ) {
+			playSound(*this, "invalid select");
+			timer.reset();
+		} else if ( keys.select && timer.elapsed().asDouble() >= timeout ) {
+			playSound(*this, "menu close");
+			uf::Serializer payload;
+			std::string action = getKeyFromIndex(stats.actions.current, stats.actions.selection);
+			payload["action"] = "dialogue-select";
+			payload["index"] = action;
+			stats.actions.index = action;
+			
+			renderDialogueOptions(std::string(""));
+
+			timer.reset();
+
+			stats.state = "waiting";
+			stats.actions.invalids.clear();
+			this->queueHook("menu:Dialogue.Turn.%UID%", ext::json::null(), timeout);
+		}
+	}
+}
+
+void ext::GuiDialogue::render() {
+	ext::Gui::render();
+}
+
+void ext::GuiDialogue::destroy() {
+	ext::Gui::destroy();
+}
\ No newline at end of file
diff --git a/ext/scenes/worldscape/gui/dialogue.h b/ext/scenes/worldscape/gui/dialogue.h
new file mode 100644
index 00000000..8e872c47
--- /dev/null
+++ b/ext/scenes/worldscape/gui/dialogue.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "../../../gui/gui.h"
+
+namespace ext {
+	class EXT_API GuiDialogue : public ext::Gui {
+	public:
+		virtual void initialize();
+		virtual void tick();
+		virtual void render();
+		virtual void destroy();
+	};
+}
\ No newline at end of file
diff --git a/ext/scenes/worldscape/housamo/battle.cpp b/ext/scenes/worldscape/housamo/battle.cpp
new file mode 100644
index 00000000..0e185f0c
--- /dev/null
+++ b/ext/scenes/worldscape/housamo/battle.cpp
@@ -0,0 +1,1555 @@
+#include "battle.h"
+
+#include ".h"
+
+#include <uf/utils/hook/hook.h>
+#include <uf/utils/time/time.h>
+#include <uf/utils/serialize/serializer.h>
+#include <uf/utils/userdata/userdata.h>
+#include <uf/utils/graphic/mesh.h>
+#include <uf/utils/window/window.h>
+#include <uf/utils/camera/camera.h>
+
+#include <uf/utils/renderer/renderer.h>
+
+#include <uf/utils/image/image.h>
+#include <uf/utils/audio/audio.h>
+
+#include "../gui/battle.h"
+#include <uf/engine/asset/asset.h>
+
+namespace {
+	ext::Gui* gui;
+	std::string previousMusic;
+
+	uf::Serializer masterTableGet( const std::string& table ) {
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Serializer& mastertable = scene.getComponent<uf::Serializer>();
+		return mastertable["system"]["mastertable"][table];
+	}
+	uf::Serializer masterDataGet( const std::string& table, const std::string& key ) {
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Serializer& mastertable = scene.getComponent<uf::Serializer>();
+		return mastertable["system"]["mastertable"][table][key];
+	}
+	inline int64_t parseInt( const std::string& str ) {
+		return atoi(str.c_str());
+	}
+
+	inline std::string colorString( const std::string& hex ) {
+		return "%#" + hex + "%";
+	}
+
+}
+
+namespace {
+	void playSound( ext::HousamoBattle& entity, const std::string& id, const std::string& key ) {
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Serializer& masterdata = scene.getComponent<uf::Serializer>();
+
+		uf::Serializer cardData = masterDataGet("Card", id);
+		uf::Serializer charaData = masterDataGet("Chara", cardData["character_id"].as<std::string>());
+		std::string name = charaData["filename"].as<std::string>();
+
+		if ( name == "none" ) return;
+
+		std::string url = "https://cdn..xyz//unity/Android/voice/voice_" + name + "_"+key+".ogg";
+		if ( charaData["internal"].as<bool>() ) {
+			url = uf::io::root+"/smtsamo/voice/voice_" + name + "_" + key + ".ogg";
+		}
+
+		uf::Asset& assetLoader = scene.getComponent<uf::Asset>();
+		assetLoader.cache(url, "asset:Cache.Voice." + std::to_string(entity.getUid()));
+	}
+	void playSound( ext::HousamoBattle& entity, std::size_t uid, const std::string& key ) {
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Serializer& pMetadata = entity.getComponent<uf::Serializer>();
+		uf::Serializer& masterdata = scene.getComponent<uf::Serializer>();
+
+		uf::Entity*  = scene.findByUid(uid);
+		if ( ! ) return;
+		uf::Serializer& metadata = ->getComponent<uf::Serializer>();
+		std::string id = metadata[""]["id"].as<std::string>();
+		playSound( entity, id, key );
+	}
+	void playSound( ext::HousamoBattle& entity, const std::string& key ) {
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Serializer& metadata = entity.getComponent<uf::Serializer>();
+		uf::Serializer& masterdata = scene.getComponent<uf::Serializer>();
+
+		std::string url = uf::io::root+"/audio/ui/" + key + ".ogg";
+
+		uf::Asset& assetLoader = scene.getComponent<uf::Asset>();
+		assetLoader.cache(url, "asset:Cache.SFX." + std::to_string(entity.getUid()));
+	}
+	void playMusic( ext::HousamoBattle& entity, const std::string& filename ) {
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Asset& assetLoader = scene.getComponent<uf::Asset>();
+		uf::Serializer& masterdata = scene.getComponent<uf::Serializer>();
+
+		uf::Audio& audio = scene.getComponent<uf::Audio>();
+		if ( audio.playing() ) {
+			uf::Serializer& metadata = scene.getComponent<uf::Serializer>();
+			metadata["previous bgm"]["filename"] = audio.getFilename();
+			metadata["previous bgm"]["timestamp"] = audio.getTime();
+		}
+
+		assetLoader.load(filename, "asset:Load." + std::to_string(scene.getUid()));
+	}
+
+	uf::Audio sfx;
+	uf::Audio voice;
+	std::vector<ext::Housamo*> transients;
+}
+void ext::HousamoBattle::initialize() {	
+	uf::Object::initialize();
+
+	::gui = NULL;
+	transients.clear();
+
+	uf::Scene& scene = uf::scene::getCurrentScene();
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+//	std::vector<ext::Housamo>& transients = this->getComponent<std::vector<ext::Housamo>>();
+
+	this->m_name = "Battle Manager";
+
+	// asset loading
+	this->addHook( "asset:Cache.Voice.%UID%", [&](const std::string& event)->std::string{	
+		uf::Serializer json = event;
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+		uf::Serializer& masterdata = scene.getComponent<uf::Serializer>();
+		
+		std::string filename = json["filename"].as<std::string>();
+
+		if ( uf::io::extension(filename) != "ogg" ) return "false";
+
+		if ( filename == "" ) return "false";
+		if ( voice.playing() ) voice.stop();
+		voice = uf::Audio();
+		voice.load(filename);
+		voice.setVolume(masterdata["volumes"]["voice"].as<float>());
+		voice.play();
+
+		return "true";
+	});
+	this->addHook( "asset:Cache.SFX.%UID%", [&](const std::string& event)->std::string{	
+		uf::Serializer json = event;
+		
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Serializer& masterdata = scene.getComponent<uf::Serializer>();
+		
+		std::string filename = json["filename"].as<std::string>();
+
+		if ( uf::io::extension(filename) != "ogg" ) return "false";
+
+		if ( filename == "" ) return "false";
+		if ( sfx.playing() ) sfx.stop();
+		sfx = uf::Audio();
+		sfx.load(filename);
+		sfx.setVolume(masterdata["volumes"]["sfx"].as<float>());
+		sfx.play();
+
+		return "true";
+	});
+	this->addHook( "asset:Music.Load.%UID%", [&](const std::string& event)->std::string{	
+		uf::Serializer json = event;
+		std::string filename = "";
+		if ( ext::json::isArray( json["music"] ) ) {
+			int ri = floor(rand() % json["music"].size());
+			filename = json["music"][ri].as<std::string>();
+		} else if ( json["music"].is<std::string>() ) {
+			filename = json["music"].as<std::string>();
+		}
+		if ( filename != "" ) playMusic(*this, filename);
+		return "true";
+	});
+
+	// bind events
+	this->addHook( "world:Battle.Start.%UID%", [&](const std::string& event)->std::string{	
+		uf::Serializer json = event;
+
+		metadata["battle"] = json["battle"];
+		{
+			uf::Serializer payload;
+			payload["music"] = metadata["battle"]["music"];
+			this->queueHook( "asset:Music.Load.%UID%", payload );
+		}
+		
+		// generate battle data
+	
+		uf::Serializer actions; actions.readFromFile(uf::io::root+"/entities/gui/battle/actions.json");
+		metadata["actions"] = actions;
+		if ( ext::json::isNull( metadata["actions"] ) ) {
+			metadata["actions"]["00.member-attack"] = "攻撃";
+			metadata["actions"]["01.member-skill"] = "スキル";
+			metadata["actions"]["02.inventory"] = "アイテム";
+			metadata["actions"]["03.talk"] = "話�掛�る";
+			metadata["actions"]["04.transients"] = "転光生";
+			metadata["actions"]["05.escape"] = "脱走";
+			metadata["actions"]["06.analyze"] = "Analyze";
+			metadata["actions"]["07.pass"] = "Pass";
+		}
+
+		// spawn transients accordingly
+	//	for ( auto& id : metadata["battle"]["player"]["party"] ) {
+		ext::json::forEach(metadata["battle"]["player"]["party"], [&](ext::json::Value& id){
+			uint64_t uid = transients.size();
+			auto& member = metadata["battle"]["player"]["transients"][id.as<std::string>()];
+			member["uid"] = uid;
+
+			ext::Housamo* transient = new ext::Housamo;
+			transients.push_back(transient);
+			this->addChild(*transient);
+
+			uf::Serializer& pMetadata = transient->getComponent<uf::Serializer>();
+			pMetadata[""] = member;
+			pMetadata[""]["uid"] = uid;
+			pMetadata[""]["type"] = "player";
+			pMetadata[""]["initialized"] = false;
+			transient->initialize();
+			metadata["battle"]["transients"][std::to_string(uid)] = pMetadata[""];
+		});
+	//	for ( auto& id : metadata["battle"]["enemy"]["party"] ) {
+		ext::json::forEach(metadata["battle"]["enemy"]["party"], [&](ext::json::Value& id){
+			uint64_t uid = transients.size();
+			auto& member = metadata["battle"]["enemy"]["transients"][id.as<std::string>()];
+			member["uid"] = uid;
+
+			ext::Housamo* transient = new ext::Housamo;
+			transients.push_back(transient);
+			this->addChild(*transient);
+
+			uf::Serializer& pMetadata = transient->getComponent<uf::Serializer>();
+			pMetadata[""] = member;
+			pMetadata[""]["uid"] = uid;
+			pMetadata[""]["type"] = "enemy";
+			pMetadata[""]["initialized"] = false;
+			transient->initialize();
+			metadata["battle"]["transients"][std::to_string(uid)] = pMetadata[""];
+		});
+
+		this->queueHook("world:Battle.Gui.%UID%");
+
+		uf::Serializer payload;
+	//	for ( auto& member : metadata["battle"]["transients"] ) {
+		ext::json::forEach(metadata["skills"], [&](ext::json::Value& member){
+		//	for ( auto& skillId : member["skills"]  ) {
+			ext::json::forEach(member["skills"], [&](ext::json::Value& skillId){
+				uf::Serializer skillData = masterDataGet("Skill", skillId.as<std::string>());
+				if ( skillData["type"].as<int>() != 16 ) return;
+			//	for ( auto& status : skillData["statuses"] ) {
+				ext::json::forEach(skillData["status"], [&](ext::json::Value& status){
+					std::string target = status["target"].as<std::string>();
+					std::string statusId = status["id"].as<std::string>();
+					uf::Serializer statusData = masterDataGet("Status", statusId);
+
+					float r = (rand() % 100) / 100.0;
+					if ( statusData["proc"].is<double>() ) {
+						// failed
+						if ( r > statusData["proc"].as<float>() / 100.0f ) {
+							target = "";
+						}
+					}
+					// apply status
+					uf::Serializer targets;								
+					if ( target == "self" ) {
+						targets.emplace_back(member["uid"].as<std::string>());
+					} else if ( target == "enemy" ) {
+					//	for ( auto& tmember :  metadata["battle"]["transients"] ) {
+						ext::json::forEach(metadata["battle"]["transients"], [&](ext::json::Value& tmember){
+							if ( tmember["type"] == member["type"] ) return;
+							targets.emplace_back(tmember["uid"].as<std::string>());
+						});
+					} else if ( target == "ally" ) {
+					//	for ( auto& tmember :  metadata["battle"]["transients"] ) {
+						ext::json::forEach(metadata["battle"]["transients"], [&](ext::json::Value& tmember){
+							if ( tmember["type"] != member["type"] ) return;
+							targets.emplace_back(tmember["uid"].as<std::string>());
+						});
+					}
+				//	for ( auto& target : targets ) {
+					ext::json::forEach(targets, [&](ext::json::Value& target){
+						uf::Serializer statusPayload;
+						statusPayload["id"] = statusId;
+						statusPayload["modifier"] = status["modifier"];
+
+						statusPayload["turns"] = status["turns"].is<double>() ? status["turns"] : statusData["turns"];
+						metadata["battle"]["transients"][target.as<std::string>()]["statuses"].emplace_back(statusPayload);
+
+						uf::Serializer cardData = masterDataGet( "Card", metadata["battle"]["transients"][target.as<std::string>()]["id"].as<std::string>() );
+						uf::Serializer charaData = masterDataGet("Chara", cardData["character_id"].as<std::string>());
+
+						payload["message"] = payload["message"].as<std::string>() + "\nApplied "+colorString("FF0000") + "" + statusData["name"].as<std::string>() + ""+colorString("FFFFFF") + " to " + charaData["name"].as<std::string>();
+					});
+				});
+			});
+		});
+		
+		payload["battle"] = metadata["battle"];
+		return payload;
+	});
+	this->addHook( "world:Battle.Gui.%UID%", [&](const std::string& event)->std::string{	
+		ext::Gui* guiManager = (ext::Gui*) this->globalFindByName("Gui Manager");
+		ext::Gui* guiMenu = new ext::GuiBattle;
+		guiManager->addChild(*guiMenu);
+		guiMenu->as<uf::Object>().load("./scenes/world/gui/battle/menu.json");
+		guiMenu->initialize();
+
+		uf::Serializer payload;
+		payload["battle"] = metadata["battle"];
+		guiMenu->queueHook("world:Battle.Start.%UID%", payload);
+
+		::gui = guiMenu;
+
+		return "true";
+	});
+	// json.action and json.uid
+	this->addHook( "world:Battle.Action.%UID%", [&](const std::string& event)->std::string{	
+		uf::Serializer json = event;
+		
+		std::string hookName = "";
+		uf::Serializer payload;
+
+		std::string action = json["action"].as<std::string>();
+		
+		// dead check
+		struct {
+			struct {
+				int dead = 0;
+				int total = 0;
+			} player, enemy;
+		} counts;
+	//	for ( auto& member : metadata["battle"]["transients"] ) {
+		ext::json::forEach(metadata["battle"]["transients"], [&](ext::json::Value& member){
+			bool dead = member["hp"].as<int>() <= 0;
+			if ( member["type"] == "player" ) {
+				++counts.player.total;
+				if ( dead ) ++counts.player.dead;
+			} else {
+				++counts.enemy.total;
+				if ( dead ) ++counts.enemy.dead;
+			}
+		});
+		
+		if ( counts.player.total > 0 && counts.player.total == counts.player.dead ) {
+			hookName = "world:Battle.End.%UID%";
+			payload["won"] = false;
+		} else if ( counts.enemy.total > 0 && counts.enemy.total == counts.enemy.dead  ) {
+			hookName = "world:Battle.End.%UID%";
+			payload["won"] = true;
+		} else if ( action == "turn-start" ) {
+			payload = json;
+			hookName = "world:Battle.Turn.%UID%";
+		} else if ( action == "member-turn" ) {
+			payload = json;
+			hookName = "world:Battle.Get.%UID%";
+		} else if ( action == "member-skill" ) {
+			payload = json;
+			hookName = "world:Battle.Get.%UID%";
+			// test
+		} else if ( action == "member-attack" ) {
+			payload = json;
+			hookName = "world:Battle.Attack.%UID%";
+			metadata["battle"]["turn"]["decrement"] = 1.0f;
+		} else if ( action == "member-targets" ) {
+			payload = json;
+			hookName = "world:Battle.GetTargets.%UID%";
+		} else if ( action == "enemy-attack" ) {
+			payload = this->callHook("world:Battle.AI.%UID%", json)[0].as<uf::Serializer>();
+			hookName = "world:Battle.Attack.%UID%";
+			metadata["battle"]["turn"]["decrement"] = 1.0f;
+		} else if ( action == "escape" ) {
+			payload = json;
+			hookName = "world:Battle.Escape.%UID%";
+			metadata["battle"]["turn"]["decrement"] = 1.0f;
+		} else if ( action == "talk" ) {
+			payload = json;
+			hookName = "world:Battle.Talk.%UID%";
+			metadata["battle"]["turn"]["decrement"] = 1.0f;
+		} else if ( action == "pass" ) {
+			payload["uid"] = json["uid"];
+			payload["message"] = "Waiting...";
+			payload["timeout"] = 2.0f;
+			// take half
+			metadata["battle"]["turn"]["decrement"] = 0.5f;
+		} else if ( action == "force-pass" ) {
+			payload["uid"] = json["uid"];
+			payload["message"] = "Immobilized...";
+			payload["timeout"] = 2.0f;
+		} else if ( action == "analyze" ) {
+			payload = json;
+			hookName = "world:Battle.Get.%UID%";
+		} else {
+			payload["message"] = "Invalid command.";
+			payload["timeout"] = 2.0f;
+			payload["invalid"] = true;
+		}
+
+		// this->callHook("world:Battle.AI.%UID%", json)[0];
+
+		{
+			auto& turnState = metadata["battle"]["turn"];
+			float decrement = turnState["decrement"].as<float>();
+			turnState["counter"] = turnState["counter"].as<float>() - decrement;
+			turnState["decrement"] = 0;
+		}
+
+		{
+		//	for ( auto it = metadata["battle"]["transients"].begin(); it != metadata["battle"]["transients"].end(); ++it ) {
+		//		std::string key = it.key();
+			ext::json::forEach(metadata["battle"]["transients"], [&](const std::string& key, ext::json::Value& member){
+				if ( key == "" || ext::json::isNull( member["type"] ) ) metadata["battle"].erase(key);
+			});
+		}
+
+		/* remove dead */ if ( false ) {
+		//	for ( auto it = metadata["battle"]["transients"].begin(); it != metadata["battle"]["transients"].end(); ++it ) {
+		//		std::string key = it.key();
+			ext::json::forEach(metadata["battle"]["transients"], [&](const std::string& key, ext::json::Value& member){
+				if ( metadata["battle"]["transients"][key]["hp"].as<int>() > 0 ) return;
+			//	metadata["battle"]["transients"].erase(key);
+			});
+			// std::cout << metadata["battle"]["transients"] << std::endl;
+		}
+
+		if ( ::gui ) {
+			uf::Serializer payload;
+			payload["battle"] = metadata["battle"];
+			::gui->queueHook("world:Battle.Update.%UID%", payload);
+		}
+
+		if ( hookName == "" ) return payload;
+
+		uf::Serializer result;
+		result = this->callHook(hookName, payload)[0].as<uf::Serializer>();
+		return result;
+	});
+
+	this->addHook( "world:Battle.AI.%UID%", [&](const std::string& event)->std::string{	
+		uf::Serializer json = event;
+		// default to attack
+		std::string queuedSkillId = "0";
+		if ( json["uid"] == "" ) {
+			json["skill"] = "0";
+			return json;
+		}
+		auto& member = metadata["battle"]["transients"][json["uid"].as<std::string>()];
+		// deduce member state
+		struct {
+			std::vector<std::string> ailments;
+			int ndas = 0;
+			float factor = 0.0f;
+		} stats;
+	//	for ( auto& status : member["statuses"] ) {
+		ext::json::forEach(metadata["statuses"], [&](ext::json::Value& status){
+			std::string id = status["id"].as<std::string>();
+			if ( id == "0" ) return;
+			stats.ailments.push_back(id);
+			if ( id == "6" ) ++stats.ndas;
+		});
+
+		uf::Serializer possibilities;
+		possibilities = ext::json::array();
+	//	for ( auto& skillId : member["skills"] ) {
+		ext::json::forEach(metadata["skills"], [&](ext::json::Value& skillId, bool breaks){
+			uf::Serializer skillData = masterDataGet("Skill", skillId.as<std::string>());
+			// not recarms
+			std::cout << skillData["name"] << ": ";
+			if ( skillId == "81" || skillId == "82" ) {
+				std::cout << "\tBad skill ID" << std::endl;
+				return;
+			}
+			// invalid skill type
+			if ( skillData["type"].as<int>() < 1 || skillData["type"].as<int>() > 15 ) {
+				std::cout << "\tBad skill type" << std::endl;
+				return;
+			}
+			// no MP
+			if ( skillData["mp"].as<float>() > member["mp"].as<float>() ) {
+				std::cout << "\tNot enough MP" << std::endl;
+				return;
+			}
+			// no HP
+			if ( skillData["hp%"].as<float>() / 100.0f * member["max hp"].as<float>() >= member["hp"].as<float>() ) {
+				std::cout << "\tNot enough HP" << std::endl;
+				return;
+			}
+			// do not use same skills
+			if ( std::find(member["used skills"].begin(), member["used skills"].end(), skillId.as<std::string>()) != member["used skills"].end() ) {
+				std::cout << "\tRecently Used" << std::endl;
+				return;
+			}
+			// grants additional turns
+			if ( skillData["turns+"].is<double>() ) {
+				queuedSkillId = skillId.as<std::string>();
+				std::cout << "\tCan gain turns" << std::endl;
+				breaks = true;
+				return;
+			// try and heal if under 30%
+			} else if ( member["hp"].as<float>() / member["max hp"].as<float>() < 0.3f ) {
+				if ( skillData["type"] != "14" ) return;
+				if ( stats.factor < skillData["power"].as<float>() ) {
+					queuedSkillId = skillId.as<std::string>();
+					stats.factor = skillData["power"].as<float>();
+					std::cout << "\tCan heal" << std::endl;
+				}
+			// remove debuffs
+			} else if ( skillId == "200" ) {
+				if ( stats.ndas * 75.0f > stats.factor ) {
+					queuedSkillId = skillId.as<std::string>();
+					stats.factor = stats.ndas * 75.0f;
+					std::cout << "\tCan Dekunda" << std::endl;
+				}
+				return;
+			} else {
+				// remove negative ailment (fear, etc)
+			//	for ( auto& status : skillData["statuses"] ) {
+				ext::json::forEach(skillData["statuses"], [&](ext::json::Value& status){
+					std::string statusId = status["id"].as<std::string>();
+					uf::Serializer statusData = masterDataGet("Status", statusId);
+					for ( auto it = status["modifier"].begin(); it != status["modifier"].end(); ++it ) {
+						statusData[it.key()] = *it;
+					}
+					// remove statuses
+					if ( statusData["type"] == "remove" && std::find( stats.ailments.begin(), stats.ailments.end(), statusId ) != stats.ailments.end() ) {
+						queuedSkillId = skillId.as<std::string>();
+						stats.factor = 150.0f;
+						std::cout << "\tCan remove status " << statusData["name"] << std::endl;
+					}
+				});
+				std::cout << "\tRandom" << std::endl;
+				// no heal spells
+				if ( skillData["type"] == "14" ) return;
+				// let RNG pick
+				possibilities.emplace_back(skillId);
+			}
+		});
+		// let RNG pick
+		std::cout << queuedSkillId << ": " << possibilities << std::endl;
+		if ( queuedSkillId == "0" && possibilities.size() > 0 ) {
+			possibilities.emplace_back("0");
+			int ri = floor(rand() % possibilities.size());
+			queuedSkillId = possibilities[ri].as<std::string>();
+			auto queuedSkillData = masterDataGet( "Skill", queuedSkillId );
+			std::cout << "Picked " << queuedSkillData["name"].as<std::string>() << std::endl;
+		}
+		json["skill"] = queuedSkillId;
+		return json;
+	});
+	this->addHook( "world:Battle.GetTargets.%UID%", [&](const std::string& event)->std::string{	
+		uf::Serializer json = event;
+		uf::Serializer payload;
+
+		payload["targets"] = ext::json::array();
+		auto& member = metadata["battle"]["transients"][json["uid"].as<std::string>()];
+		if ( json["skill"].is<std::string>() ) {
+			std::string skillId = json["skill"].as<std::string>();
+			if ( json["skill"] == "0" ) {
+			//	for ( auto& status : member["statuses"] ) {
+				ext::json::forEach(member["statuses"], [&](ext::json::Value& status){
+					std::string statusId = status["id"].as<std::string>();
+					uf::Serializer statusData = masterDataGet("Status", statusId);
+					for ( auto it = status["modifier"].begin(); it != status["modifier"].end(); ++it ) {
+						statusData[it.key()] = *it;
+					}
+					if ( statusData["skill"] != skillId ) return;
+					if ( statusData["range"].is<double>() ) json["range"] = statusData["range"];
+				});
+			} else if ( !json["type"].is<std::string>() ) {
+				uf::Serializer skillData = masterDataGet( "Skill", skillId );
+				json["type"] = skillData["target"].as<std::string>();
+				if ( json["type"] == "" ) json["type"] = "enemy";
+			}
+		} else {
+			json["type"] = "all";
+		}
+
+		if ( json["type"].is<std::string>() ) {
+			if ( json["type"] == "self" ) {
+				payload["targets"].emplace_back( metadata["battle"]["transients"][json["uid"].as<std::string>()] );
+			} else {
+				for ( auto& m : metadata["battle"]["transients"] ) {
+					if ( json["type"] == "ally" && m["type"] != member["type"] ) continue;
+					if ( json["type"] == "enemy" && m["type"] == member["type"] ) continue;
+					payload["targets"].emplace_back( m );
+				}
+			}
+		}
+		return payload;
+	});
+	this->addHook( "world:Battle.Escape.%UID%", [&](const std::string& event)->std::string{	
+		uf::Serializer payload;
+		float r = (rand() % 100) / 100.0;
+		if ( r > 0.9 ) {
+			payload["message"] = "Cannot escape!";
+			payload["timeout"] = 2.0f;
+			payload["invalid"] = true;
+		} else {
+			payload["message"] = "Escaped!";
+			payload["timeout"] = 2.0f;
+			this->queueHook("world:Battle.End.%UID%", payload, 2.0f);
+		}
+		return payload;
+	});
+	this->addHook( "world:Battle.Talk.%UID%", [&](const std::string& event)->std::string{	
+		uf::Serializer payload;
+		float r = (rand() % 100) / 100.0;
+		payload["message"] = "";
+		payload["timeout"] = 2.0f;
+		payload["invalid"] = true;
+
+		uf::Serializer target;
+		std::string name;
+
+	//	for ( auto& member : metadata["battle"]["transients"] ) {
+		ext::json::forEach(metadata["battle"]["transients"], [&](ext::json::Value& member, bool breaks){
+			if ( member["type"] != "enemy" ) return;
+			target = (ext::json::Value&) member;
+			size_t uid = member["uid"].as<size_t>();
+			uf::Serializer cardData = masterDataGet("Card", member["id"].as<std::string>());
+			uf::Serializer charaData = masterDataGet("Chara", cardData["character_id"].as<std::string>());
+			name = charaData["name"].as<std::string>();
+			breaks = true;
+		});
+		if ( target ) {
+			playSound(*this, target["id"].as<std::string>(), r > 0.5 ? "turn" : "battlestart");
+			payload["message"] = ""+colorString("FF0000") + "" + name + ""+colorString("FFFFFF") + " speaks.";
+		}
+
+		return payload;
+	});
+	this->addHook( "world:Battle.OnHit.%UID%", [&](const std::string& event)->std::string{	
+		uf::Serializer json = event;
+		uint64_t uid = json["uid"].as<size_t>();
+		ext::Housamo* transient = transients.at(uid);
+		uf::Serializer& member = transient->getComponent<uf::Serializer>();
+
+		uint64_t entid = metadata["battle"]["enemy"]["uid"].as<size_t>();
+		uf::Entity*  = scene.findByUid(entid);
+		if ( ! ) return "false";
+		uf::Serializer& hMetadata = ->getComponent<uf::Serializer>();
+		uint64_t phase = json["phase"].as<size_t>();
+		// start color
+		pod::Vector4f color = { 1, 1, 1, 0 };
+		if ( phase == 0 ) {
+			color = (member[""]["type"] == "enemy") ?  pod::Vector4f{ 1.0f, 0, 0, 0.6f } : pod::Vector4f{ 1.0f, 1.0f, 1.0f, 0.6f };
+		}
+		hMetadata["color"][0] = color[0];
+		hMetadata["color"][1] = color[1];
+		hMetadata["color"][2] = color[2];
+		hMetadata["color"][3] = color[3];
+		return "true";
+	});
+	this->addHook( "world:Battle.Turn.%UID%", [&](const std::string& event)->std::string{	
+		uf::Serializer json = event;
+
+		bool found = false;
+		uint64_t turnPlayer = json["uid"].as<size_t>();
+		std::string name = "";
+		auto& turnState = metadata["battle"]["turn"];
+		{
+			if ( turnState["counter"].as<float>() <= 0 ) {
+				if ( turnState["phase"] == "player" ) turnState["phase"] = "enemy";
+				else turnState["phase"] = "player";
+				int counter = 0;
+			//	for ( auto& member : metadata["battle"]["transients"] ) {
+				ext::json::forEach(metadata["battle"]["transients"], [&](ext::json::Value& member){
+					if ( member["type"] != turnState["phase"] ) return;
+
+					bool locked = false;
+				//	for ( auto& status : member["statuses"] ) {
+					ext::json::forEach(member["statuses"], [&](ext::json::Value& status){
+						std::string statusId = status["id"].as<std::string>();
+						uf::Serializer statusData = masterDataGet("Status", statusId);
+						for ( auto it = status["modifier"].begin(); it != status["modifier"].end(); ++it ) {
+							statusData[it.key()] = *it;
+						}
+
+						if ( statusData["lock"].as<bool>() ) locked = true;
+					});
+					if ( locked ) return;
+
+					++counter;
+				});
+				turnState["counter"] = counter;
+				turnState["start of turn"] = true;
+
+				if ( ::gui ) {
+					uf::Serializer payload;
+					payload["battle"] = metadata["battle"];
+					::gui->queueHook("world:Battle.TurnStart.%UID%", payload);
+				}
+			} else {
+				turnState["start of turn"] = false;
+			}
+		}
+
+		std::function<bool()> getTurnPlayer = [&]()->bool{
+		//	for ( auto& member : metadata["battle"]["transients"] ) {
+			bool found = false;
+			ext::json::forEach(metadata["battle"]["transients"], [&](ext::json::Value& member, bool breaks){
+				if ( member["hp"].as<int>() <= 0 ) return;
+			
+				bool locked = false;
+			//	for ( auto& status : member["statuses"] ) {
+				ext::json::forEach(member["statuses"], [&](ext::json::Value& status){
+					std::string statusId = status["id"].as<std::string>();
+					uf::Serializer statusData = masterDataGet("Status", statusId);
+					for ( auto it = status["modifier"].begin(); it != status["modifier"].end(); ++it ) {
+						statusData[it.key()] = *it;
+					}
+
+					if ( statusData["lock"].as<bool>() ) locked = true;
+				});
+				if ( locked ) return;
+			
+				if ( turnPlayer > member["uid"].as<size_t>() ) return;
+				if ( member["type"] != turnState["phase"] ) return;
+				turnPlayer = member["uid"].as<size_t>();
+				breaks = true;
+				found = true;
+			});
+			return found;
+		};
+
+		uf::Serializer payload;
+		payload["message"] = "An error occurred!";
+
+		if ( !getTurnPlayer() ) {
+			turnPlayer = 0;
+			if ( !getTurnPlayer() ) {
+				std::cout << metadata["battle"]["transients"] << std::endl;
+				payload["end"] = true;
+				return payload;
+			}
+		}
+
+		payload["uid"] = turnPlayer;
+		auto& member = metadata["battle"]["transients"][payload["uid"].as<std::string>()];
+		uf::Serializer cardData = masterDataGet("Card", member["id"].as<std::string>());
+		uf::Serializer charaData = masterDataGet("Chara", cardData["character_id"].as<std::string>());
+		name = charaData["name"].as<std::string>();
+		payload["message"] = "What will "+colorString("FF0000") + "" + name + ""+colorString("FFFFFF") + " do?";
+
+		// 
+		if ( member["type"] == "enemy" ) {
+			payload["message"] = ""+colorString("FF0000") + "" + name + ""+colorString("FFFFFF") + "'s turn...";
+			payload["timeout"] = 2.0f;
+		}
+
+		bool skipped = false;
+		// tick down statuses
+		if ( turnState["start of turn"].as<bool>() ) {
+			/* remove dead */ if ( false ) {
+				for ( auto it = metadata["battle"]["transients"].begin(); it != metadata["battle"]["transients"].end(); ++it ) {
+					std::string key = it.key();
+					if ( metadata["battle"]["transients"][key]["hp"].as<int>() > 0 ) continue;
+				//	metadata["battle"]["transients"].erase(key);
+				}
+			//	std::cout << metadata["battle"]["transients"] << std::endl;
+			}
+		//	for ( auto& member : metadata["battle"]["transients"] ) {
+			ext::json::forEach(metadata["battle"]["transients"], [&](ext::json::Value& member){
+				// clear OPT used skills
+				member["used skills"] = ext::json::array();
+				if ( member["type"] != turnState["phase"] ) return;
+				auto& statuses = member["statuses"];
+//				std::cout << "Before: " << member["uid"].as<std::string>() << ": " << statuses << std::endl;
+			//	for ( int i = 0; i < statuses.size(); ++i ) {
+				ext::json::forEach(statuses, [&](size_t i, ext::json::Value& status){
+					uf::Serializer statusData = masterDataGet("Status", status["id"].as<std::string>());
+					for ( auto it = status["modifier"].begin(); it != status["modifier"].end(); ++it ) {
+						statusData[it.key()] = *it;
+					}
+					
+					uf::Serializer cardData = masterDataGet( "Card", member["id"].as<std::string>() );
+					uf::Serializer charaData = masterDataGet("Chara", cardData["character_id"].as<std::string>());
+					
+					if ( statusData["hp"].is<double>() ) {
+						int64_t hp = statusData["hp"].as<int>();
+						member["hp"] = member["hp"].as<int>() + hp;
+						payload["message"] = payload["message"].as<std::string>() + "\n"+colorString("FF0000") + "" + charaData["name"].as<std::string>() +  ""+colorString("FFFFFF") + " gained "+colorString("00FF00") + ""+ std::to_string(hp) +" HP"+colorString("FFFFFF") + " from "+colorString("FF0000") + "" + statusData["name"].as<std::string>() + ""+colorString("FFFFFF") + "";
+					}
+					if ( statusData["hp%"].is<double>() ) {
+						int64_t hp = member["max hp"].as<float>() * (statusData["hp%"].as<int>() / 100.0f);
+						if ( member["max hp"].as<int>() < member["hp"].as<int>() + hp ) hp = member["max hp"].as<int>() - member["hp"].as<int>();
+						member["hp"] = member["hp"].as<int>() + hp;
+						if ( hp > 0 ) payload["message"] = payload["message"].as<std::string>() + "\n"+colorString("FF0000") + "" + charaData["name"].as<std::string>() +  ""+colorString("FFFFFF") + " gained "+colorString("00FF00") + ""+ std::to_string(hp) +" HP"+colorString("FFFFFF") + " from "+colorString("FF0000") + "" + statusData["name"].as<std::string>() + ""+colorString("FFFFFF") + "";
+					}
+					if ( statusData["mp"].is<double>() ) {
+						int64_t mp = statusData["mp"].as<int>();
+						member["mp"] = member["mp"].as<int>() + mp;
+						if ( member["max mp"].as<int>() < member["mp"].as<int>() + mp ) mp = member["max mp"].as<int>() - member["mp"].as<int>();
+						payload["message"] = payload["message"].as<std::string>() + "\n"+colorString("FF0000") + "" + charaData["name"].as<std::string>() +  ""+colorString("FFFFFF") + " gained "+colorString("0000FF") + ""+ std::to_string(mp) +" MP"+colorString("FFFFFF") + " from "+colorString("FF0000") + "" + statusData["name"].as<std::string>() + ""+colorString("FFFFFF") + "";
+					}
+					if ( statusData["lock"].is<double>() ) {
+						skipped = true;
+					}
+				});
+				uf::Serializer newStatuses;
+				for ( int i = statuses.size() - 1; i >= 0; --i ) {
+					auto& status = statuses[i];
+					uf::Serializer statusData = masterDataGet("Status", status["id"].as<std::string>());
+					if ( !ext::json::isNull( status["turns"] ) ) {
+						status["turns"] = status["turns"].as<int>() - 1;
+						if ( status["turns"].as<int>() < 0 ) {
+							if ( statusData["id"] != "0" ) payload["message"] = payload["message"].as<std::string>() + "\n"+colorString("FF0000") + "" + statusData["name"].as<std::string>() + ""+colorString("FFFFFF") + " wore off.";
+						} else {
+							newStatuses.emplace_back(status);
+						}
+					} else {
+						newStatuses.emplace_back(status);
+					}
+				}
+				statuses = newStatuses;
+//				std::cout << "After: " << member["uid"].as<std::string>() << ": " << statuses << std::endl;
+			});
+		}
+
+		{
+			for ( auto it = metadata["battle"]["transients"].begin(); it != metadata["battle"]["transients"].end(); ++it ) {
+				std::string key = it.key();
+				if ( key == "" || ext::json::isNull( (*it)["type"] ) ) metadata["battle"].erase(key);
+			}
+		}
+
+		if ( ::gui ) {
+			uf::Serializer payload;
+			payload["battle"] = metadata["battle"];
+			::gui->queueHook("world:Battle.Update.%UID%", payload);
+		}
+
+		if ( skipped ) payload["skipped"] = true;
+	/*
+		std::vector<std::string> list = {
+			"member-attack",
+			"member-skill",
+			"inventory",
+			"talk",
+			"transients",
+			"escape",
+			"pass",
+			"analyze",
+		};
+		payload["actions"]["list"] = ext::json::array();
+		payload["actions"]["names"]["member-attack"] = "攻撃";
+		payload["actions"]["names"]["member-skill"] = "スキル";
+		payload["actions"]["names"]["inventory"] = "アイテム";
+		payload["actions"]["names"]["talk"] = "話�掛�る";
+		payload["actions"]["names"]["transients"] = "転光生";
+		payload["actions"]["names"]["escape"] = "脱走";
+		payload["actions"]["names"]["analyze"] = "Analyze";
+		payload["actions"]["names"]["pass"] = "Pass";
+		for ( auto& x : list ) payload["actions"]["list"].emplace_back(x);
+	*/
+		payload["actions"] = metadata["actions"];
+		payload[""] = member;
+		return payload;
+	});
+	this->addHook( "world:Battle.Attack.%UID%", [&](const std::string& event)->std::string{	
+		uf::Serializer json = event;
+
+		std::string skillId = json["skill"].as<std::string>();
+		uf::Serializer skillData = masterDataGet("Skill", skillId);
+
+//		ext::Housamo* transient = transients.at(uid);
+		auto& member = metadata["battle"]["transients"][json["uid"].as<std::string>()];
+
+		uf::Serializer payload;
+		payload["message"] = "";
+		// modify skill data based on statuses
+	//	for ( auto& status : member["statuses"] ) {
+		ext::json::forEach(member["statuses"], [&](ext::json::Value& status){
+			std::string statusId = status["id"].as<std::string>();
+			uf::Serializer statusData = masterDataGet("Status", statusId);
+			for ( auto it = status["modifier"].begin(); it != status["modifier"].end(); ++it ) {
+				statusData[it.key()] = *it;
+			}
+			if ( statusData["skill"] != skillId ) return;
+			if ( statusData["range"].is<double>() ) skillData["range"] = statusData["range"];
+		});
+		// select random target
+		if ( ext::json::isNull(  json["target"] ) ) {
+			if ( ext::json::isNull(  skillData["target"] ) ) skillData["target"] = "enemy";
+			if ( skillData["target"] == "self" ) {
+				json["target"].emplace_back( member["uid"].as<size_t>() );
+			} else if ( skillData["range"].is<double>() && skillData["range"].as<int>() > 1 ) {
+				json["target"] = ext::json::array();
+			//	for ( auto& m : metadata["battle"]["transients"] ) {
+				ext::json::forEach(member["battle"]["transients"], [&](ext::json::Value& m){
+					if ( skillData["target"] == "ally" && m["type"] != member["type"] ) return;
+					if ( skillData["target"] != "ally" && m["type"] == member["type"] ) return;
+					json["target"].emplace_back( m["uid"].as<size_t>() );
+				});
+			} else {
+				std::vector<uint64_t> targets;
+			//	for ( auto& m : metadata["battle"]["transients"] ) {
+				ext::json::forEach(member["battle"]["transients"], [&](ext::json::Value& m){
+					if ( skillData["target"] == "ally" && m["type"] != member["type"] ) return;
+					if ( skillData["target"] != "ally" && m["type"] == member["type"] ) return;
+					targets.push_back( m["uid"].as<size_t>() );
+				});
+				int ri = floor(rand() % targets.size());
+				json["target"] = ext::json::array();
+				json["target"].emplace_back(targets.at(ri));
+			}
+		}
+
+		uf::Serializer elementData;
+		uf::Serializer cardData = masterDataGet("Card", member["id"].as<std::string>());
+		uf::Serializer charaData = masterDataGet("Chara", cardData["character_id"].as<std::string>());
+		std::string elementId;
+		
+		float basePower = member["type"] == "enemy" ? 1.2f : 1.0f;
+
+		if ( skillId != "0" ) {
+			payload["message"] = payload["message"].as<std::string>() + "\n"+colorString("FF0000") + "" + charaData["name"].as<std::string>() + ""+colorString("FFFFFF") + ": "+colorString("7777FF") + "" + skillData["name"].as<std::string>() + colorString("FFFFFF");
+
+			elementId = skillData["type"].as<std::string>();
+			elementData = masterDataGet("Element", elementId);
+		} else {
+			payload["message"] = payload["message"].as<std::string>() + "\n"+colorString("FF0000") + "" + charaData["name"].as<std::string>() + ""+colorString("FFFFFF") + ": "+colorString("7777FF") + "攻撃" + colorString("FFFFFF");
+
+			elementId = "0";
+			if ( cardData["weapon_type"] == "1" ) elementId = "1"; // slash
+			if ( cardData["weapon_type"] == "2" ) elementId = "3"; // strike
+			if ( cardData["weapon_type"] == "3" ) elementId = "2"; // pierce
+			elementData = masterDataGet("Element", elementId);
+		}
+
+		struct {
+			float damage = 0.0f;
+		} delays;
+
+		struct {
+			bool endTurn = false;
+			int loseTurn = 0;
+		} turnEffects;
+
+		std::function<void(uf::Serializer&)> showMessage = [&]( uf::Serializer& json ) {
+			uf::Serializer payload;
+			payload["color"] = json["color"];
+			payload["target"]["uid"] = json["uid"];
+			payload["target"]["damage"] = json["message"];
+			::gui->queueHook("world:Battle.Damage.%UID%", payload, delays.damage);
+			delays.damage += 0.25f;
+		};
+		
+		{
+			int64_t mp = member["mp"].as<int>();
+			int64_t hp = member["hp"].as<int>();
+			int64_t mpCost = skillData["mp"].as<int>();
+			int64_t hpCost = skillData["hp%"].as<int>();
+
+		//	for ( auto& status : member["statuses"] ) {
+			ext::json::forEach(member["statuses"], [&](ext::json::Value& status){
+				std::string statusId = status["id"].as<std::string>();
+				uf::Serializer statusData = masterDataGet("Status", statusId);
+				for ( auto it = status["modifier"].begin(); it != status["modifier"].end(); ++it ) {
+					statusData[it.key()] = *it;
+				}
+
+				if ( !ext::json::isNull( statusData["type"] ) && elementData["type"] != statusData["type"] ) return;
+				if ( !ext::json::isNull( statusData["attributes"] ) ) {
+					bool found = false;
+					for ( auto& value : statusData["attributes"] ) {
+						if ( value == elementData["id"] ) found = true;
+					}
+					if ( !found ) return;
+				}
+
+				if ( hpCost > 0 && statusData["cost"].is<double>() ) {
+					hpCost -= statusData["cost"].as<int>();
+				}
+			});
+
+			hpCost = member["max hp"].as<float>() * ( hpCost / 100.0f );
+
+			if ( mp < mpCost ) {
+				payload["message"] = "Not enough MP to use `"+colorString("FF0000") + ""+skillData["name"].as<std::string>()+""+colorString("FFFFFF") + "`.";
+				payload["timeout"] = 2.0f;
+				if ( member["type"] != "enemy" ) {
+					payload["invalid"] = true;
+				}
+				return payload;
+			} else if ( mpCost > 0 ) {
+				metadata["battle"]["transients"][member["uid"].as<std::string>()]["mp"] = mp - mpCost;
+			}
+			if ( hp < hpCost ) {
+				payload["message"] = "Not enough HP to use `"+colorString("FF0000") + ""+skillData["name"].as<std::string>()+""+colorString("FFFFFF") + "`.";
+				payload["timeout"] = 2.0f;
+				if ( member["type"] != "enemy" ) {
+					payload["invalid"] = true;
+					return payload;
+				} else {
+					skillId = "0";
+					skillData = masterDataGet("Skill", skillId);
+				}
+			} else if ( hpCost > 0 ) {
+				metadata["battle"]["transients"][member["uid"].as<std::string>()]["hp"] = hp - hpCost;
+				{
+					uf::Serializer payload;
+					payload["uid"] = member["uid"];
+					payload["message"] = hpCost;
+					payload["color"] = "FF0000";
+					showMessage( payload );
+				}
+			}
+		}
+
+		if ( skillData["turns+"].is<double>() ) {
+			member["used skills"].emplace_back(skillId);
+			payload["message"] = payload["message"].as<std::string>() + "\nGained "+colorString("FF0000") + ""+skillData["turns+"].as<std::string>()+""+colorString("FFFFFF") + " additional turns!";
+			metadata["battle"]["turn"]["counter"] = metadata["battle"]["turn"]["counter"].as<float>() + skillData["turns+"].as<float>();
+		}
+
+	//	for ( auto& targetId : json["target"] ) {
+		ext::json::forEach(json["target"], [&](ext::json::Value& targetId){
+			uf::Serializer target = metadata["battle"]["transients"][targetId.as<std::string>()];
+
+			float power = basePower;
+			float morePower = 0;
+			float probability = skillData["proc"].is<double>() ? skillData["proc"].as<int>() / 100.0f : 1.0f;
+			// modify probability from statuses
+		//	for ( auto& status : metadata["battle"]["transients"][json["uid"].as<std::string>()]["statuses"] ) {
+			ext::json::forEach(metadata["battle"]["transients"][json["uid"].as<std::string>()]["statuses"], [&](ext::json::Value& status){
+				std::string statusId = status["id"].as<std::string>();
+				uf::Serializer statusData = masterDataGet("Status", statusId);
+				for ( auto it = status["modifier"].begin(); it != status["modifier"].end(); ++it ) {
+					statusData[it.key()] = *it;
+				}
+
+				if ( !ext::json::isNull( statusData["type"] ) && elementData["type"] != statusData["type"] ) return;
+				if ( !ext::json::isNull( statusData["attributes"] ) ) {
+					bool found = false;
+					for ( auto& value : statusData["attributes"] ) {
+						if ( value == elementData["id"] ) found = true;
+					}
+					if ( !found ) return;
+				}
+
+				if ( statusData["proc+"].is<double>() ) {
+					float moreProb = statusData["proc+"].as<float>() / 100.0f;
+					probability += moreProb;
+					payload["message"] = payload["message"].as<std::string>() + "\n"+colorString("FF00FF") + "" + std::to_string((int)(moreProb*100)) + "%"+colorString("FF0000") + " more probability"+colorString("FFFFFF") + "";
+				}
+			});
+			// find attack modifying statuses on attacker
+		//	for ( auto& status : metadata["battle"]["transients"][json["uid"].as<std::string>()]["statuses"] ) {
+			ext::json::forEach(metadata["battle"]["transients"][json["uid"].as<std::string>()]["statuses"], [&](ext::json::Value& status){
+				std::string statusId = status["id"].as<std::string>();
+				uf::Serializer statusData = masterDataGet("Status", statusId);
+				for ( auto it = status["modifier"].begin(); it != status["modifier"].end(); ++it ) {
+					statusData[it.key()] = *it;
+				}
+
+				if ( !ext::json::isNull( statusData["type"] ) && elementData["type"] != statusData["type"] ) return;
+				if ( !ext::json::isNull( statusData["attributes"] ) ) {
+					bool found = false;
+					for ( auto& value : statusData["attributes"] ) {
+						if ( value == elementData["id"] ) found = true;
+					}
+					if ( !found ) return;
+				}
+				if ( !ext::json::isNull( statusData["ailments"] ) ) return;
+
+
+				if ( statusData["power"].is<double>() ) {
+					float adjust = statusData["power"].as<float>() / 100.0f;
+					morePower += adjust;
+				//	payload["message"] = payload["message"].as<std::string>() + "\n"+colorString("FF00FF") + "" + std::to_string((int)(adjust*100)) + "%"+colorString("FF0000") + " more power"+colorString("FFFFFF") + "";
+				}
+			});
+			// find defense modifying statuses on target
+		//	for ( auto& status : metadata["battle"]["transients"][targetId.as<std::string>()]["statuses"] ) {
+			ext::json::forEach(metadata["battle"]["transients"][targetId.as<std::string>()]["statuses"], [&](ext::json::Value& status){
+				std::string statusId = status["id"].as<std::string>();
+				uf::Serializer statusData = masterDataGet("Status", statusId);
+				for ( auto it = status["modifier"].begin(); it != status["modifier"].end(); ++it ) {
+					statusData[it.key()] = *it;
+				}
+
+				if ( !ext::json::isNull( statusData["type"] ) && elementData["type"] != statusData["type"] ) return;
+				if ( !ext::json::isNull( statusData["attributes"] ) ) {
+					bool found = false;
+					for ( auto& value : statusData["attributes"] ) {
+						if ( value == elementData["id"] ) found = true;
+					}
+					if ( !found ) return;
+				}
+
+				if ( statusData["defense"].is<double>() ) {
+					float adjust = statusData["defense"].as<float>() / 100.0f;
+					morePower -= adjust;
+				//	payload["message"] = payload["message"].as<std::string>() + "\n"+colorString("FF00FF") + "" + std::to_string((int)(adjust*100)) + "%"+colorString("FF0000") + " more defense"+colorString("FFFFFF") + "";
+				}
+			});
+		//	if ( morePower != 0 ) payload["message"] = payload["message"].as<std::string>() + "\n"+colorString("FF00FF") + "" + std::to_string((int)(morePower*100)) + "%"+colorString("FF0000") + " power modifier"+colorString("FFFFFF") + "";
+
+			float r = (rand() % 100) / 100.0;
+			// missed
+			if ( r > probability ) {
+				uf::Serializer payload;
+				payload["target"]["uid"] = target["uid"];
+				payload["target"]["damage"] = "Miss";
+				::gui->queueHook("world:Battle.Damage.%UID%", payload);
+				return;
+			}
+
+			bool repel = false;
+			std::function<void(const std::string&)> affinityCheck = [&]( const std::string& targetId ) {
+				auto& target = metadata["battle"]["transients"][targetId];
+				uf::Serializer cardData = masterDataGet("Card", target["id"].as<std::string>());
+				uf::Serializer affinity = cardData["affinity"][elementId];
+				// affinity change check
+			//	for ( auto& status : target["statuses"] ) {
+				ext::json::forEach(target["statuses"], [&](ext::json::Value& status){
+					std::string statusId = status["id"].as<std::string>();
+					uf::Serializer statusData = masterDataGet("Status", statusId);
+					for ( auto it = status["modifier"].begin(); it != status["modifier"].end(); ++it ) {
+						statusData[it.key()] = *it;
+					}
+
+					if ( !ext::json::isNull( statusData["type"] ) && elementData["type"] != statusData["type"] ) return;
+					if ( !ext::json::isNull( statusData["attributes"] ) ) {
+						bool found = false;
+						for ( auto& value : statusData["attributes"] ) {
+							if ( value == elementData["id"] ) found = true;
+						}
+						if ( !found ) return;
+					}
+
+					if ( !ext::json::isNull( statusData["affinity"] ) ) {
+						if ( !ext::json::isNull( statusData["affinity"][elementId] ) ) affinity = statusData["affinity"][elementId];
+					//	payload["message"] = payload["message"].as<std::string>() + "\naffinity modifier."+colorString("FFFFFF") + "";
+					}
+				});
+				if ( !ext::json::isNull( affinity ) ) {
+					std::string affinityStr = affinity.as<std::string>();
+					if ( repel && affinityStr == "repel" ) affinityStr = "null";
+					if ( affinityStr == "weak" ) { payload["message"] = payload["message"].as<std::string>() + "\n"+colorString("FF0000") + "Weak!\n"; morePower *= 2.0f; }
+					else if ( affinityStr == "strong" ) { payload["message"] = payload["message"].as<std::string>() + "\n"+colorString("FF0000") + "Strong!\n"; morePower *= 0.5f; }
+					else if ( affinityStr == "drain" ) { turnEffects.endTurn = true; payload["message"] = payload["message"].as<std::string>() + "\n"+colorString("FF0000") + "Drain!\n"; morePower *= -1.0f; }
+					else if ( affinityStr == "null" ) { turnEffects.loseTurn = 2; payload["message"] = payload["message"].as<std::string>() + "\n"+colorString("FF0000") + "Nulled!\n"; morePower *= 0; }
+					else if ( affinityStr == "repel" ) { turnEffects.endTurn = true; payload["message"] = payload["message"].as<std::string>() + "\n"+colorString("FF0000") + "Repelled!\n"; repel = true;
+						// check again
+						affinityCheck(json["uid"].as<std::string>());
+					} else {
+						affinityStr = "";
+					}
+					if ( affinityStr != "" ) {
+						uf::Serializer payload;
+						payload["uid"] = targetId;
+						payload["message"] = affinityStr;
+						payload["color"] = "FF0000";
+						showMessage( payload );
+					}
+				}
+			}; affinityCheck(target["uid"].as<std::string>());
+
+			power += morePower;
+			
+			// damage calc
+			float damage = 0.0f; {
+				float calcDamage = 0.0f;
+				// normal attack
+				if ( elementData["type"] == "Physical"  ) {
+					if ( skillData["hp%"].is<double>() ) {
+						// max hp * power
+						calcDamage = (member["max hp"].as<float>() * skillData["power"].as<float>() * 0.00114f );
+					} else {
+						// ( lv + str ) * power / 15
+						calcDamage = (member["lv"].as<float>() + member["str"].as<float>()) * skillData["power"].as<float>() / 15.0f;
+					}
+				} else if ( elementData["type"] == "Magic" ) {
+					if ( member["lv"].as<float>() < 30 ) {
+						calcDamage *= skillData["power"].as<float>() * member["lv"].as<float>() * ( 2 * member["mag"].as<float>() + 70.0f ) / 1000.0f;
+					} else if ( member["lv"].as<float>() < 160 ) {
+						calcDamage = 3.0f * skillData["power"].as<float>() * ( 2 * member["mag"].as<float>() + 70.0f - ( 0.4f *  member["lv"].as<float>() ) ) / 100.0f;
+					} else {
+						calcDamage = 3.0f * skillData["power"].as<float>() * ( 2 * member["mag"].as<float>() + 5 ) / 100.0f;
+					}
+				} else {
+					std::cout << elementData << ": " << skillData << std::endl;
+				}
+				damage = (int) (calcDamage * power);
+			}
+
+			if ( ext::json::isArray( skillData["hits"] ) ) {
+				float low = skillData["hits"][0].as<float>();
+				float high = skillData["hits"][1].as<float>();
+				int hits = low + r * (high - low);
+				damage *= hits;
+			}
+
+			// hama/mudo instakill
+			bool instakill = false;
+			if ( elementId == "12" || elementId == "13" ) {
+				instakill = true;
+			}
+
+			bool critted = false;
+			std::function<void(const std::string&)> applyDamage = [&]( const std::string& targetId ) {
+				auto& target = metadata["battle"]["transients"][targetId];
+				uf::Serializer cardData = masterDataGet("Card", target["id"].as<std::string>());
+				uf::Serializer charaData = masterDataGet("Chara", cardData["character_id"].as<std::string>());
+				int curHp = target["hp"].as<float>();
+				bool isCrit = ((rand() % 100) / 100.0) < 0.1;
+				if ( damage == 0 ) isCrit = false;
+				float oldDamage = damage;
+				if ( isCrit ) {
+					damage *= 1.5;
+					critted = true;
+				}
+
+				// is a heal
+				if ( elementId == "14" ) {
+					float power = skillData["power"].as<float>() / 100.0f * (morePower == 0 ? 1 : morePower);
+					std::cout << target["max hp"].as<float>() << ", " << power << std::endl;
+					damage = -1 * std::abs(target["max hp"].as<float>() * power);
+				}
+
+				if ( instakill ) damage = curHp;
+				target["hp"] = (int) (curHp -= damage);
+				if ( target["hp"].as<float>() > target["max hp"].as<float>() ) target["hp"] = target["max hp"].as<float>();
+
+				std::cout << power << ", " << damage << ", " << morePower << (isCrit ? " / crit" : "") << std::endl;
+
+				{
+
+					uf::Serializer payload;
+					payload["uid"] = target["uid"];
+					payload["crit"] = isCrit;
+					payload["message"] = "";
+					if ( damage > 0 ) {
+						payload["color"] = "FF0000";
+						payload["message"] = (int) damage;
+						
+						if ( skillData["drains"].as<bool>() ) {
+							float ratio = damage / target["max hp"].as<float>();
+							int mpDrain = target["max mp"].as<float>() * ratio;
+							if ( target["mp"].as<float>() > mpDrain ) mpDrain = target["mp"].as<float>();
+							target["mp"] = target["mp"].as<float>() - mpDrain;
+							payload["message"] = payload["message"].as<std::string>() + "\n  " + colorString("0000FF") + std::to_string(mpDrain);
+							
+							showMessage( payload );
+
+							payload["uid"] = member["uid"];
+							payload["color"] = "00FF00";
+						}
+					// heal
+					} else if ( damage < 0 ) {
+						payload["message"] = (int) -damage;
+						payload["color"] = "00FF00";
+					}
+					showMessage( payload );
+				}
+
+				damage = oldDamage;
+
+				if ( curHp <= 0 ) {
+					payload["message"] = payload["message"].as<std::string>() + "\n"+colorString("FF0000") + ""+ charaData["name"].as<std::string>() +" "+colorString("FFFFFF") + "died!";
+					target["hp"] = 0;
+
+					uf::Serializer statusPayload;
+					statusPayload["id"] = "21";
+					target["statuses"] = ext::json::array();
+					target["statuses"].emplace_back(statusPayload);
+				}
+			}; applyDamage(repel ? json["uid"].as<std::string>() : target["uid"].as<std::string>());
+			// counter statuses
+			if ( !repel ) {
+			//	for ( auto& status : metadata["battle"]["transients"][target["uid"].as<std::string>()]["statuses"] ) {
+				ext::json::forEach(metadata["battle"]["transients"][target["uid"].as<std::string>()]["statuses"], [&](ext::json::Value& status){
+					std::string statusId = status["id"].as<std::string>();
+					if ( statusId != "19" ) return;
+					uf::Serializer statusData = masterDataGet("Status", statusId);
+					for ( auto it = status["modifier"].begin(); it != status["modifier"].end(); ++it ) {
+						statusData[it.key()] = *it;
+					}
+
+					if ( !ext::json::isNull( statusData["type"] ) && elementData["type"] != statusData["type"] ) return;
+					if ( !ext::json::isNull( statusData["attributes"] ) ) {
+						bool found = false;
+						for ( auto& value : statusData["attributes"] ) {
+							if ( value == elementData["id"] ) found = true;
+						}
+						if ( !found ) return;
+					}
+					if ( statusData["proc"].is<double>() ) {
+						float r = (rand() % 100) / 100.0;
+						if ( r <= statusData["proc"].as<float>() / 100.0f ) {
+							applyDamage(json["uid"].as<std::string>());
+							payload["message"] = payload["message"].as<std::string>() + "\nCountered!";
+						}
+					}
+				});
+			}
+			// apply status
+			{
+			//	for ( auto& status : skillData["statuses"] ) {
+				ext::json::forEach(skillData["statuses"], [&](ext::json::Value& status){
+					std::string target = status["target"].as<std::string>();
+					std::string statusId = status["id"].as<std::string>();
+					uf::Serializer statusData = masterDataGet("Status", statusId);
+					if ( skillData["type"].as<int>() == 16 ) return;
+					float r = (rand() % 100) / 100.0;
+					if ( repel ) {
+						if ( target == "enemy" ) target = "self";
+						else target = "";
+					}
+					if ( statusData["proc"].is<double>() ) {
+						// failed
+						if ( r > statusData["proc"].as<float>() / 100.0f ) {
+							target = "";
+						}
+					}
+
+					uf::Serializer targets;
+					if ( target == "self" ) {
+						targets.emplace_back(json["uid"].as<std::string>());
+				//	} else if ( target == "enemy" || target == "ally" ) {
+					} else {
+						targets.emplace_back(targetId.as<std::string>());
+					}
+				//	for ( auto& target : targets ) {
+					ext::json::forEach(targets, [&](ext::json::Value& target){
+						// remove status(es)
+						if ( status["type"] == "remove" ) {
+							for ( auto& statusC : metadata["battle"]["transients"][target.as<std::string>()]["statuses"] ) {
+								if ( statusC["id"] == statusId ) {
+									statusC = ext::json::null();
+									statusC["id"] = 0;
+									statusC["turns"] = -1;
+								}
+							}
+							return;
+						}
+
+						uf::Serializer statusPayload;
+						statusPayload["id"] = statusId;
+						statusPayload["modifier"] = status["modifier"];
+
+						statusPayload["turns"] = status["turns"].is<double>() ? status["turns"] : statusData["turns"];
+						metadata["battle"]["transients"][target.as<std::string>()]["statuses"].emplace_back(statusPayload);
+
+						for ( auto it = status["modifier"].begin(); it != status["modifier"].end(); ++it ) {
+							statusData[it.key()] = *it;
+						}
+
+						uf::Serializer cardData = masterDataGet( "Card", metadata["battle"]["transients"][target.as<std::string>()]["id"].as<std::string>() );
+						uf::Serializer charaData = masterDataGet("Chara", cardData["character_id"].as<std::string>());
+
+					//	payload["message"] = payload["message"].as<std::string>() + "\nApplied "+colorString("FF0000") + "" + statusData["name"].as<std::string>() + ""+colorString("FFFFFF") + " to " + charaData["name"].as<std::string>();
+						{
+							uf::Serializer payload;
+							payload["uid"] = targetId;
+							payload["message"] = skillData["name"].as<std::string>();
+							payload["color"] = "9900FF";
+							showMessage( payload );
+						}
+					});
+				});
+			}
+
+			if ( damage > 0 ) {
+				float r = (rand() % 100) / 100.0;
+			//	if ( r < 0.5 ) {
+				if ( r < 1.0 ) {
+					playSound(*this, member["id"].as<std::string>(), r > 0.25 ? "attack" : "skill");
+				} else {
+					playSound(*this, target["id"].as<std::string>(), r > 0.75 ? "damagedsmall" : "damagedlarge");
+				}
+				for ( int i = 0; i < 16; ++i ) {
+					uf::Serializer payload;
+					payload["uid"] = target["uid"];
+					payload["phase"] = i % 2 == 0 ? 0 : 1;
+					this->queueHook("world:Battle.OnHit.%UID%", payload, 0.05f * i);
+				}
+			}
+			if ( critted ) {
+				uf::Serializer payload;
+				payload["uid"] = json["uid"];
+				payload["id"] = member["id"];
+				::gui->queueHook("world:Battle.OnCrit.%UID%", payload, 0.1f);
+			}
+		});
+
+		/* heal self */
+		if ( skillData["add hp"].is<double>() ) {
+			int heal = skillData["add hp"].as<float>() / 100.0f * member["max hp"].as<float>();
+			if ( heal + member["hp"].as<float>() >= member["max hp"].as<float>() ) heal = member["max hp"].as<float>() - member["hp"].as<float>();
+			member["hp"] = member["hp"].as<float>() + heal;
+
+			uf::Serializer payload;
+			payload["uid"] = member["uid"];
+			payload["message"] = "";
+			payload["color"] = "00FF00";
+			payload["message"] = (int) heal;
+			showMessage( payload );	
+		}
+
+		if ( turnEffects.endTurn ) {
+			turnEffects.loseTurn = 99;
+		}
+		if ( turnEffects.loseTurn > 0 ) {
+			auto& turnState = metadata["battle"]["turn"];
+			float decrement = turnState["decrement"].as<float>();
+			turnState["counter"] = turnState["counter"].as<float>() - turnEffects.loseTurn;
+			turnState["decrement"] = 0;
+		}
+
+		payload["uid"] = json["uid"];
+		payload["target"] = json["target"];
+		payload[""]["id"] = member["id"];
+		payload[""]["skill"] = skillId;
+		payload["timeout"] = 2.0f;
+		return payload;
+	});
+	this->addHook( "world:Battle.Get.%UID%", [&](const std::string& event)->std::string{
+		uf::Serializer json = event;
+		auto& member = metadata["battle"]["transients"][json["uid"].as<std::string>()];
+	/*
+		ext::Housamo* transient = transients.at(uid);
+		uf::Serializer& member = transient->getComponent<uf::Serializer>();
+	*/
+		std::string message;
+
+		uf::Serializer cardData = masterDataGet("Card", member["id"].as<std::string>());
+		uf::Serializer charaData = masterDataGet("Chara", cardData["character_id"].as<std::string>());
+		uf::Serializer affinity = cardData["affinity"];
+		std::string name = charaData["name"].as<std::string>();
+		if ( member["type"] == "player" ) message += colorString("00FF00");
+		else if ( member["type"] == "enemy" ) message += colorString("FF0000");
+		else  message += colorString("AAAAAA");
+
+
+		message += name + colorString("FFFFFF") + ": " + member["type"].as<std::string>();
+		
+		message += "\n" + colorString("FF0000") + "HP: " + member["hp"].as<std::string>();
+		message += "\n" + colorString("0000FF") + "MP: " + member["mp"].as<std::string>();
+
+
+		message += "\n" + colorString("9900FF") + "Ailments" + colorString("FFFFFF") + ":";
+	//	for ( auto& status : member["statuses"] ) {
+		ext::json::forEach(member["statuses"], [&](ext::json::Value& status){
+			std::string statusId = status["id"].as<std::string>();
+			uf::Serializer statusData = masterDataGet("Status", statusId);
+			for ( auto it = status["modifier"].begin(); it != status["modifier"].end(); ++it ) {
+				statusData[it.key()] = *it;
+			}
+			if ( statusId == "0" ) return;
+			// affinity change check
+			for ( auto it = statusData["affinity"].begin(); it != statusData["affinity"].end(); ++it ) {
+				affinity[it.key()] = *it;
+			}
+			message += "\n\t" + statusData["name"].as<std::string>() + (ext::json::isNull( status["turns"] ) ? "" : " (Turns: " + status["turns"].as<std::string>() + ")" );
+		});
+
+		message += "\n" + colorString("9900FF") + "Affinities" + colorString("FFFFFF") + ":";
+
+	//	for ( auto it = affinity.begin(); it != affinity.end(); ++it ) {
+	//		std::string elementId = it.key();
+	//		std::string value = it->as<std::string>();
+		ext::json::forEach(affinity, [&](const std::string& elementId, ext::json::Value& value){
+			uf::Serializer elementData = masterDataGet("Element", elementId);
+			message += "\n\t" + elementData["name"].as<std::string>() + ": " + value.as<std::string>();
+		});
+
+		uf::Serializer payload;
+		payload[""] = member;
+	//	payload["timeout"] = 0.1f;
+		payload["message"] = message;
+		return payload;
+	});	
+	this->addHook( "world:Battle.End.%UID%", [&](const std::string& event)->std::string{	
+		uf::Serializer json = event;
+		// play music
+	/*
+		std::cout << "Previous BGM: " << previousMusic << std::endl;
+		playMusic(*this, previousMusic);
+	*/
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		scene.callHook("world:Music.LoadPrevious.%UID%");
+		::gui->callHook("menu:Close.%UID%");
+	
+		// cleanup
+		for ( ext::Housamo* pointer : transients ) {
+			pointer->destroy();
+			this->removeChild(*pointer);
+			delete pointer;
+		}
+		transients.clear();
+
+		if ( json["won"].as<bool>() ) {
+			// play death sound
+		//	playSound(*this, metadata["battle"]["enemy"]["uid"].as<size_t>(), "killed");
+			// kill
+			{
+				uf::Scene& scene = uf::scene::getCurrentScene();
+				std::size_t uid = metadata["battle"]["enemy"]["uid"].as<size_t>();
+				uf::Entity*  = scene.findByUid(uid);
+				if (  ) {
+					uf::Object& parent = ->getParent<uf::Object>();
+					->destroy();
+					parent.removeChild(*);
+				}
+			}
+		}
+
+		{
+			uf::Serializer payload;
+			payload["battle"] = metadata["battle"];
+			this->callHook("world:Battle.End", payload);
+		}
+
+		uf::Serializer payload;
+		payload["end"] = true;
+		return payload;
+	/*
+		if ( json["action"].as<std::string>() == "killed" ) {
+			// play death sound
+			playSound(*this, metadata["battle"]["enemy"]["uid"].as<size_t>(), "killed");
+			// kill
+			{
+				uf::Scene& scene = uf::scene::getCurrentScene();
+				std::size_t uid = metadata["battle"]["enemy"]["uid"].as<size_t>();
+				uf::Entity*  = scene.findByUid(uid);
+				if (  ) {
+					uf::Object& parent = ->getParent<uf::Object>();
+					->destroy();
+					parent.removeChild(*);
+				}
+			}
+		}
+
+		// clear battle data on player
+		{
+			uf::Scene& scene = uf::scene::getCurrentScene();
+			std::size_t uid = metadata["battle"]["player"]["uid"].as<size_t>();
+			uf::Entity*  = scene.findByUid(uid);
+			if (  ) {
+				uf::Serializer& pMetadata = ->getComponent<uf::Serializer>();
+				pMetadata["system"].erase("battle");
+			}
+		}
+
+		uf::Serializer payload;
+		payload["end"] = true;
+		return payload;
+		return "true";
+	*/
+	});
+}
+
+void ext::HousamoBattle::tick() {	
+	uf::Object::tick();
+}
+
+void ext::HousamoBattle::destroy() {
+	uf::Object::destroy();
+}
+void ext::HousamoBattle::render() {	
+	uf::Object::render();
+}
\ No newline at end of file
diff --git a/ext/scenes/worldscape/housamo/battle.h b/ext/scenes/worldscape/housamo/battle.h
new file mode 100644
index 00000000..3ea6680e
--- /dev/null
+++ b/ext/scenes/worldscape/housamo/battle.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/ext/ext.h>
+#include <uf/engine/entity/entity.h>
+#include <uf/engine/object/object.h>
+
+namespace ext {
+	class EXT_API HousamoBattle : public uf::Object {
+	protected:
+	public:
+		virtual void initialize();
+		virtual void tick();
+		virtual void render();
+		virtual void destroy();
+	};
+}
\ No newline at end of file
diff --git a/ext/scenes/worldscape/housamo/dialogue.cpp b/ext/scenes/worldscape/housamo/dialogue.cpp
new file mode 100644
index 00000000..8da01c43
--- /dev/null
+++ b/ext/scenes/worldscape/housamo/dialogue.cpp
@@ -0,0 +1,272 @@
+#include "dialogue.h"
+
+#include ".h"
+
+#include <uf/utils/hook/hook.h>
+#include <uf/utils/time/time.h>
+#include <uf/utils/serialize/serializer.h>
+#include <uf/utils/userdata/userdata.h>
+#include <uf/utils/graphic/mesh.h>
+#include <uf/utils/window/window.h>
+#include <uf/utils/camera/camera.h>
+//#include <uf/ext/renderer/renderer.h>
+
+#include <uf/utils/image/image.h>
+#include <uf/utils/audio/audio.h>
+#include <uf/engine/asset/asset.h>
+
+#include "../gui/dialogue.h"
+
+namespace {
+	ext::Gui* gui;
+
+	uf::Serializer masterTableGet( const std::string& table ) {
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Serializer& mastertable = scene.getComponent<uf::Serializer>();
+		return mastertable["system"]["mastertable"][table];
+	}
+	uf::Serializer masterDataGet( const std::string& table, const std::string& key ) {
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Serializer& mastertable = scene.getComponent<uf::Serializer>();
+		return mastertable["system"]["mastertable"][table][key];
+	}
+	inline int64_t parseInt( const std::string& str ) {
+		return atoi(str.c_str());
+	}
+}
+
+namespace {
+	void playSound( ext::DialogueManager& entity, const std::string& id, const std::string& key ) {
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Serializer& masterdata = scene.getComponent<uf::Serializer>();
+
+		uf::Serializer cardData = masterDataGet("Card", id);
+		uf::Serializer charaData = masterDataGet("Chara", cardData["character_id"].as<std::string>());
+		std::string name = charaData["filename"].as<std::string>();
+		std::string url = "https://cdn..xyz//unity/Android/voice/voice_" + name + "_"+key+".ogg";
+
+		std::cout << url << std::endl;
+
+		if ( charaData["internal"].as<bool>() ) {
+			url = uf::io::root+"/smtsamo/voice/voice_" + name + "_" + key + ".ogg";
+		}
+
+		uf::Asset& assetLoader = scene.getComponent<uf::Asset>();
+		assetLoader.cache(url, "asset:Cache.Voice." + std::to_string(entity.getUid()));
+	}
+	void playSound( ext::DialogueManager& entity, std::size_t uid, const std::string& key ) {
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Serializer& pMetadata = entity.getComponent<uf::Serializer>();
+		uf::Serializer& masterdata = scene.getComponent<uf::Serializer>();
+
+		uf::Entity*  = scene.findByUid(uid);
+		if ( ! ) return;
+		uf::Serializer& metadata = ->getComponent<uf::Serializer>();
+		std::string id = metadata[""]["id"].as<std::string>();
+		playSound( entity, id, key );
+	}
+	void playSound( ext::DialogueManager& entity, const std::string& key ) {
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Serializer& metadata = entity.getComponent<uf::Serializer>();
+		uf::Serializer& masterdata = scene.getComponent<uf::Serializer>();
+
+		std::string url = "./" + key + ".ogg";
+
+		uf::Asset& assetLoader = scene.getComponent<uf::Asset>();
+		assetLoader.cache(url, "asset:Cache.SFX." + std::to_string(entity.getUid()));
+	}
+	void playMusic( ext::DialogueManager& entity, const std::string& filename ) {
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Asset& assetLoader = scene.getComponent<uf::Asset>();
+		uf::Serializer& masterdata = scene.getComponent<uf::Serializer>();
+
+		assetLoader.load(filename, "asset:Load." + std::to_string(scene.getUid()));
+	}
+
+	uf::Audio sfx;
+	uf::Audio voice;
+	std::vector<ext::Housamo*> transients;
+}
+void ext::DialogueManager::initialize() {	
+	uf::Object::initialize();
+
+	::gui = NULL;
+	transients.clear();
+
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+//	std::vector<ext::Housamo>& transients = this->getComponent<std::vector<ext::Housamo>>();
+
+	this->m_name = "Dialogue Manager";
+
+	// asset loading
+	this->addHook( "asset:Cache.Voice.%UID%", [&](const std::string& event)->std::string{	
+		uf::Serializer json = event;
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+		uf::Serializer& masterdata = scene.getComponent<uf::Serializer>();
+		
+		std::string filename = json["filename"].as<std::string>();
+
+		if ( uf::io::extension(filename) != "ogg" ) return "false";
+
+		if ( filename == "" ) return "false";
+		if ( voice.playing() ) voice.stop();
+		voice = uf::Audio();
+		voice.load(filename);
+		voice.setVolume(masterdata["volumes"]["voice"].as<float>());
+		voice.play();
+
+		return "true";
+	});
+	this->addHook( "asset:Cache.SFX.%UID%", [&](const std::string& event)->std::string{	
+		uf::Serializer json = event;
+		
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Serializer& masterdata = scene.getComponent<uf::Serializer>();
+		
+		std::string filename = json["filename"].as<std::string>();
+
+		if ( uf::io::extension(filename) != "ogg" ) return "false";
+
+		if ( filename == "" ) return "false";
+		if ( sfx.playing() ) sfx.stop();
+		sfx = uf::Audio();
+		sfx.load(filename);
+		sfx.setVolume(masterdata["volumes"]["sfx"].as<float>());
+		sfx.play();
+
+		return "true";
+	});
+	this->addHook( "asset:Music.Load.%UID%", [&](const std::string& event)->std::string{	
+		uf::Serializer json = event;
+		if ( json["music"].is<std::string>() ) playMusic(*this, json["music"].as<std::string>());
+		return "true";
+	});
+	this->addHook( "asset:Sfx.Load.%UID%", [&](const std::string& event)->std::string{	
+		uf::Serializer json = event;
+		if ( json["sfx"].is<std::string>() ) playSound(*this, json["sfx"].as<std::string>());
+		return "true";
+	});
+	this->addHook( "asset:Voice.Load.%UID%", [&](const std::string& event)->std::string{	
+		uf::Serializer json = event;
+		if ( ext::json::isObject( json["voice"] ) ) playSound(*this, json["voice"]["id"].as<std::string>(), json["voice"]["key"].as<std::string>());
+		return "true";
+	});
+
+	// bind events
+	this->addHook( "menu:Dialogue.Start.%UID%", [&](const std::string& event)->std::string{	
+		uf::Serializer json = event;
+		{
+			metadata["dialogue"] = json["dialogue"];
+			uf::Serializer payload;
+			payload["music"] =  metadata["dialogue"]["music"];
+			payload["sfx"] =  metadata["dialogue"]["sfx"];
+			payload["voice"] =  metadata["dialogue"]["voice"];
+			// this->queueHook( "asset:Music.Load.%UID%", payload );
+		}
+		metadata["uid"] = json["uid"];
+
+		this->queueHook("menu:Dialogue.Gui.%UID%");
+		
+		uf::Serializer payload;
+		payload["dialogue"] = metadata["dialogue"];
+		return payload;
+	});
+	this->addHook( "menu:Dialogue.Gui.%UID%", [&](const std::string& event)->std::string{	
+		ext::Gui* guiManager = (ext::Gui*) this->globalFindByName("Gui Manager");
+		ext::Gui* guiMenu = new ext::GuiDialogue;
+		guiManager->addChild(*guiMenu);
+		guiMenu->as<uf::Object>().load("./entities/gui/dialogue/menu.json");
+		guiMenu->initialize();
+
+		uf::Serializer payload;
+		payload["dialogue"] = metadata["dialogue"];
+		guiMenu->queueHook("menu:Dialogue.Start.%UID%", payload);
+
+		::gui = guiMenu;
+
+		return "true";
+	});
+	// json.action and json.uid
+	this->addHook( "menu:Dialogue.Action.%UID%", [&](const std::string& event)->std::string{	
+		uf::Serializer json = event;
+		
+		std::string hookName = "";
+		uf::Serializer payload;
+
+		std::string action = json["action"].as<std::string>();
+		
+		if ( action == "dialogue-select" ) {
+			payload = json;
+			hookName = "menu:Dialogue.Turn.%UID%";
+		} else {
+			payload["message"] = "Invalid command: %#FF0000%" + action;
+			payload["timeout"] = 2.0f;
+			payload["invalid"] = true;
+			return payload;
+		}
+
+		uf::Serializer result;
+		if ( hookName != "" ) result = this->callHook(hookName, payload)[0].as<uf::Serializer>();
+		return result;
+	});
+
+	this->addHook( "menu:Dialogue.Turn.%UID%", [&](const std::string& event)->std::string{	
+		uf::Serializer json = event;
+
+		uf::Serializer payload;
+		std::string index = json["index"].as<std::string>();
+		uf::Serializer part = metadata["dialogue"][index];
+		if ( part["quit"].as<bool>() ) return this->callHook("menu:Dialogue.End.%UID%")[0].as<uf::Serializer>();
+		payload["message"] = part["message"];
+		payload["actions"] = part["actions"];
+		if ( part["music"].is<std::string>() ) {
+			uf::Serializer pload;
+			pload["music"] =  part["music"];
+			this->queueHook( "asset:Music.Load.%UID%", pload );
+		}
+		if ( part["sfx"].is<std::string>() ) {
+			uf::Serializer pload;
+			pload["sfx"] =  part["sfx"];
+			this->queueHook( "asset:Sfx.Load.%UID%", pload );
+		}
+		if ( ext::json::isObject( part["voice"] ) ) {
+			uf::Serializer pload;
+			pload["voice"] =  part["voice"];
+			this->queueHook( "asset:Voice.Load.%UID%", pload );
+		}
+		if ( ext::json::isObject( part["hook"] ) ) {
+			part["hooks"].emplace_back( part["hook"] );
+		}
+	//	for ( auto hook : part["hooks"] ) {
+		ext::json::forEach(part["hooks"], [&](ext::json::Value& hook){
+			hook["payload"]["uid"] = metadata["uid"];
+			this->queueHook( hook["name"].as<std::string>(), uf::Serializer{hook["payload"]}, hook["timeout"].as<float>() );
+		});
+		return payload;
+	});
+	this->addHook( "menu:Dialogue.End.%UID%", [&](const std::string& event)->std::string{	
+		uf::Serializer json = event;
+		// play music
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		scene.callHook("world:Music.LoadPrevious.%UID%");
+		::gui->callHook("menu:Close.%UID%");
+
+		this->callHook("menu:Dialogue.End");
+
+		uf::Serializer payload;
+		payload["end"] = true;
+		return payload;
+	});
+}
+
+void ext::DialogueManager::tick() {	
+	uf::Object::tick();
+}
+
+void ext::DialogueManager::destroy() {
+	uf::Object::destroy();
+}
+void ext::DialogueManager::render() {	
+	uf::Object::render();
+}
\ No newline at end of file
diff --git a/ext/scenes/worldscape/housamo/dialogue.h b/ext/scenes/worldscape/housamo/dialogue.h
new file mode 100644
index 00000000..6adf0a84
--- /dev/null
+++ b/ext/scenes/worldscape/housamo/dialogue.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/ext/ext.h>
+#include <uf/engine/entity/entity.h>
+#include <uf/engine/object/object.h>
+
+namespace ext {
+	class EXT_API DialogueManager : public uf::Object {
+	protected:
+	public:
+		virtual void initialize();
+		virtual void tick();
+		virtual void render();
+		virtual void destroy();
+	};
+}
\ No newline at end of file
diff --git a/ext/scenes/worldscape/housamo/housamo.cpp b/ext/scenes/worldscape/housamo/housamo.cpp
new file mode 100644
index 00000000..bf1487f0
--- /dev/null
+++ b/ext/scenes/worldscape/housamo/housamo.cpp
@@ -0,0 +1,158 @@
+#include ".h"
+
+#include <uf/engine/scene/scene.h>
+#include <uf/utils/serialize/serializer.h>
+
+namespace {
+	uf::Serializer masterTableGet( const std::string& table ) {
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Serializer& mastertable = scene.getComponent<uf::Serializer>();
+		return mastertable["system"]["mastertable"][table];
+	}
+	uf::Serializer masterDataGet( const std::string& table, const std::string& key ) {
+		uf::Scene& scene = uf::scene::getCurrentScene();
+		uf::Serializer& mastertable = scene.getComponent<uf::Serializer>();
+		return mastertable["system"]["mastertable"][table][key];
+	}
+	inline int64_t parseInt( const std::string& str ) {
+		return atoi(str.c_str());
+	}
+}
+
+void ext::Housamo::initialize() {
+	uf::Object::initialize();
+
+	this->m_name = "Housamo";
+
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	/*
+		{ 
+			"id": "140901",
+			"lv": 60,
+			"sl": 100,
+			"jingi": 100,
+		*	"limit": 3,
+		* 	"hp": 10082,
+		* 	"atk": 6119,
+		* 	"skills": [401,349,203,532],
+		*	"skin": "skin1"
+		},
+	*/
+	std::string id = metadata[""]["id"].as<std::string>();
+	uint64_t lv = !ext::json::isNull( metadata[""]["level"] ) ? parseInt(metadata[""]["level"].as<std::string>()) : parseInt(metadata[""]["lv"].as<std::string>());
+	uint64_t sl = !ext::json::isNull( metadata[""]["skill level"] ) ? parseInt(metadata[""]["skill level"].as<std::string>()) : parseInt(metadata[""]["sl"].as<std::string>());
+	uint64_t jingi = parseInt(metadata[""]["jingi"].as<std::string>());
+	uint64_t limit = parseInt(metadata[""]["limit"].as<std::string>());
+	uint64_t str = parseInt(metadata[""]["str"].as<std::string>());
+	uint64_t mag = parseInt(metadata[""]["mag"].as<std::string>());
+	uint64_t vit = parseInt(metadata[""]["vit"].as<std::string>());
+	uint64_t agi = parseInt(metadata[""]["agi"].as<std::string>());
+	 int64_t hp = ext::json::isNull( metadata[""]["hp"] ) ? -1 : parseInt(metadata[""]["hp"].as<std::string>());
+	 int64_t mp = ext::json::isNull( metadata[""]["mp"] ) ? -1 : parseInt(metadata[""]["mp"].as<std::string>());
+	
+	std::vector<std::string> skills;
+	for ( auto i = 0; i < metadata[""]["skills"].size(); ++i ) {
+		skills.push_back(metadata[""]["skills"][i].as<std::string>());
+	}
+	uf::Serializer cardData = masterDataGet("Card",id);
+/*
+	{
+		uint64_t base = parseInt(cardData["base_hp"].as<std::string>());
+		uint64_t max = parseInt(cardData["max_hp"].as<std::string>());
+		uint64_t maxlv = parseInt(cardData["max_lv"].as<std::string>());
+		max_hp += ( (max - base) * (lv - 1) / (maxlv - 1) ) + base;
+		max_hp /= 20.0f;
+	}
+	{
+		uint64_t base = parseInt(cardData["base_mp"].as<std::string>());
+		uint64_t max = parseInt(cardData["max_mp"].as<std::string>());
+		uint64_t maxlv = parseInt(cardData["max_lv"].as<std::string>());
+		max_mp += ( (max - base) * (lv - 1) / (maxlv - 1) ) + base;
+	}
+*/
+	{
+		float scale = 3.0f;
+		if ( str == 0 ) {
+			uint64_t base = parseInt(cardData["base_atk"].as<std::string>());
+			uint64_t max = parseInt(cardData["max_atk"].as<std::string>());
+			uint64_t maxlv = parseInt(cardData["max_lv"].as<std::string>());
+			str = ( (max - base) * (lv - 1) / (maxlv - 1) ) + base;
+			str /= scale * 100.0f;
+		}
+		if ( mag == 0 ) {
+			uint64_t base = parseInt(cardData["base_atk"].as<std::string>());
+			uint64_t max = parseInt(cardData["max_atk"].as<std::string>());
+			uint64_t maxlv = parseInt(cardData["max_lv"].as<std::string>());
+			mag = ( (max - base) * (lv - 1) / (maxlv - 1) ) + base;
+			mag /= scale * 100.0f;
+		}
+		if ( vit == 0 ) {
+			uint64_t base = parseInt(cardData["base_hp"].as<std::string>());
+			uint64_t max = parseInt(cardData["max_hp"].as<std::string>());
+			uint64_t maxlv = parseInt(cardData["max_lv"].as<std::string>());
+			vit = ( (max - base) * (lv - 1) / (maxlv - 1) ) + base;
+			vit /= scale * 100.0f;
+		}
+	}
+	uint64_t max_hp = (lv + vit) * 6;
+	uint64_t max_mp = (mag + lv) * 3;
+
+	if ( metadata[""]["max hp"].is<double>() ) max_hp = parseInt(metadata[""]["max hp"].as<std::string>());
+	if ( metadata[""]["max mp"].is<double>() ) max_mp = parseInt(metadata[""]["max mp"].as<std::string>());
+
+	if ( hp == -1 ) hp = max_hp;
+	if ( mp == -1 ) mp = max_mp;
+	if ( limit == 0 ) {
+		uint64_t baseL0 = 0;
+		switch ( parseInt(cardData["rarity"].as<std::string>() ) ) {
+			case 1: baseL0 = 20; break;
+			case 2: baseL0 = 25; break;
+			case 3: baseL0 = 30; break;
+			case 4: baseL0 = 35; break;
+			case 5: baseL0 = 40; break;
+		}
+		while ( baseL0 > 0 && baseL0 < lv ) {
+			++limit;
+			baseL0 += 10;
+		}
+	}
+	// populate skills based on masterdata
+	if ( skills.empty() ) {
+		for ( auto i = 0; i < cardData["skill_id"].size(); ++i ) {
+			int learn = cardData["skill_learn_lv"][i].as<int>();
+			if ( lv < learn ) break;
+			skills.push_back(cardData["skill_id"][i].as<std::string>());
+		}
+	}
+	
+
+	// convert back
+	metadata[""].erase("level");
+	metadata[""].erase("skill level");
+	metadata[""]["lv"] = lv;
+	metadata[""]["sl"] = sl;
+	metadata[""]["jingi"] = jingi;
+	metadata[""]["limit"] = limit;
+	metadata[""]["hp"] = hp;
+	metadata[""]["max hp"] = max_hp;
+	metadata[""]["mp"] = mp;
+	metadata[""]["max mp"] = max_mp;
+	metadata[""]["str"] = str;
+	metadata[""]["mag"] = mag;
+	metadata[""]["vit"] = vit;
+	metadata[""]["agi"] = agi;
+	metadata[""]["skills"] = ext::json::array();
+
+//	std::cout << metadata[""] << std::endl;
+
+	for ( auto& id : skills ) metadata[""]["skills"].emplace_back(id);
+}
+void ext::Housamo::tick() {
+	uf::Object::tick();
+}
+void ext::Housamo::render() {
+	uf::Object::render();
+}
+void ext::Housamo::destroy() {
+	uf::Object::destroy();
+}
\ No newline at end of file
diff --git a/ext/scenes/worldscape/housamo/housamo.h b/ext/scenes/worldscape/housamo/housamo.h
new file mode 100644
index 00000000..f4626abe
--- /dev/null
+++ b/ext/scenes/worldscape/housamo/housamo.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/ext/ext.h>
+#include <uf/engine/entity/entity.h>
+#include <uf/engine/object/object.h>
+
+namespace ext {
+	class EXT_API Housamo : public uf::Object {
+	protected:
+	public:
+		virtual void initialize();
+		virtual void tick();
+		virtual void render();
+		virtual void destroy();
+	};
+}
\ No newline at end of file
diff --git a/ext/scenes/worldscape/terrain/behavior.cpp b/ext/scenes/worldscape/terrain/behavior.cpp
new file mode 100644
index 00000000..a14a3228
--- /dev/null
+++ b/ext/scenes/worldscape/terrain/behavior.cpp
@@ -0,0 +1,279 @@
+#include "behavior.h"
+#include "terrain.h"
+#include "generator.h"
+#include "region.h"
+#include "maze.h"
+
+#include <uf/utils/math/transform.h>
+#include <uf/utils/math/physics.h>
+
+#include <uf/engine/object/object.h>
+#include <uf/engine/asset/asset.h>
+
+#include <uf/utils/window/window.h>
+#include <uf/utils/graphic/mesh.h>
+#include <uf/utils/graphic/graphic.h>
+#include <uf/utils/camera/camera.h>
+#include <uf/utils/math/collision.h>
+#include <uf/utils/thread/thread.h>
+#include <uf/utils/renderer/renderer.h>
+#include <uf/utils/string/hash.h>
+
+#include <sys/stat.h>
+
+UF_BEHAVIOR_ENTITY_CPP_BEGIN(ext::Terrain)
+#define this ((ext::Terrain*) &self)
+void ext::TerrainBehavior::initialize( uf::Object& self ) {
+	// alias Mesh types
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+
+	std::size_t seed = 0;
+	if ( metadata["terrain"]["seed"].is<size_t>() ) {
+		seed = metadata["terrain"]["seed"].as<size_t>();
+	} else if ( metadata["terrain"]["seed"].is<std::string>() ) {
+		seed = std::hash<std::string>{}( metadata["terrain"]["seed"].as<std::string>() );
+	}
+	{
+		std::cout << "Seed: " << seed << std::endl;
+		ext::TerrainGenerator::noise.seed( seed );
+	}
+
+	/* setup folder */ {
+		uf::Serializer modifiers;
+		modifiers["terrain"]["seed"] = metadata["terrain"]["seed"];
+		modifiers["region"]["size"] = metadata["region"]["size"];
+		modifiers["region"]["subdivisions"] = metadata["region"]["subdivisions"];
+		modifiers["region"]["modulus"] = metadata["region"]["modulus"];
+		std::string input = modifiers;
+		metadata["system"]["hash"] = uf::string::sha256( input );
+	
+		uf::io::mkdir(uf::io::root+"/save/" + metadata["system"]["hash"].as<std::string>() + "/");
+		uf::io::mkdir(uf::io::root+"/save/" + metadata["system"]["hash"].as<std::string>() + "/regions/");
+	}
+
+	// setup maze
+	{
+		ext::Maze& maze = this->getComponent<ext::Maze>();
+		maze.initialize(8, 8, 1, 0.5, 0.5);
+		maze.seed = seed;
+		maze.build();
+		maze.print();
+	}
+
+	metadata["system"]["state"] = "preinit";
+	metadata["system"]["modified"] = true;
+
+	this->addHook( "system:TickRate.Restore", [&](ext::json::Value& json){
+		std::cout << "Returning limiter from " << uf::thread::limiter << " to " << metadata["system"]["limiter"].as<float>() << std::endl;
+		uf::thread::limiter = metadata["system"]["limiter"].as<float>();
+	});
+	this->addHook( "terrain:GenerateMesh.%UID%", [&](ext::json::Value& json){
+
+		auto& graphic = this->getComponent<uf::Graphic>();
+		auto& mesh = this->getComponent<ext::TerrainGenerator::mesh_t>();
+
+		graphic.initializeMesh( mesh );
+		graphic.getPipeline().update( graphic );
+	//	graphic.updatePipelines();
+		graphic.process = true;
+		uf::renderer::states::rebuild = true;
+	});
+	this->addHook( "terrain:Post-Initialize.%UID%", [&](ext::json::Value& json){
+		if ( metadata["terrain"]["unified"].as<bool>() ) {
+			std::string textureFilename = ""; {
+				uf::Asset assetLoader;
+				for ( uint i = 0; i < metadata["system"]["assets"].size(); ++i ) {
+					if ( textureFilename != "" ) break;
+					std::string filename = this->grabURI( metadata["system"]["assets"][i].as<std::string>(), metadata["system"]["root"].as<std::string>() );
+					textureFilename = assetLoader.cache( filename );
+				}
+			}
+			auto& graphic = this->getComponent<uf::Graphic>();
+
+			graphic.initialize();
+			graphic.process = false;
+
+			auto& texture = graphic.material.textures.emplace_back();
+			texture.sampler.descriptor.filter.min = uf::renderer::enums::Filter::NEAREST;
+			texture.sampler.descriptor.filter.mag = uf::renderer::enums::Filter::NEAREST;
+			texture.loadFromFile( textureFilename );
+
+			std::string suffix = ""; {
+				std::string _ = this->getRootParent<uf::Scene>().getComponent<uf::Serializer>()["shaders"]["region"]["suffix"].as<std::string>();
+				if ( _ != "" ) suffix = _ + ".";
+			}
+			graphic.material.initializeShaders({
+				{uf::io::root+"/shaders/terrain/vert.spv", uf::renderer::enums::Shader::VERTEX},
+				{uf::io::root+"/shaders/terrain/frag.spv", uf::renderer::enums::Shader::FRAGMENT}
+			});
+			// uf::renderer::rebuildOnTickStart = false;
+		}
+
+		this->generate();
+	/*
+		auto& parent = this->getParent().as<uf::Object>();
+		auto& metadata = parent.getComponent<uf::Serializer>();
+		parent.queueHook("system:Load.Finished.%UID%");
+	*/
+	});
+}
+void ext::TerrainBehavior::tick( uf::Object& self ) {
+	auto& scene = uf::scene::getCurrentScene();
+	uf::Object& controller = scene.getController<uf::Object>();
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	pod::Thread& mainThread = uf::thread::has("Main") ? uf::thread::get("Main") : uf::thread::create( "Main", false, true );
+	// lambda to transition from a resolving state
+	auto transitionState = [&]( ext::Terrain& that, const std::string& next, bool unresolved ){
+		uf::Serializer& metadata = that.getComponent<uf::Serializer>();
+	//	uf::thread::add( mainThread, [&]() -> int {
+		//	std::cout << "Transitioning: " << metadata["system"]["state"].as<std::string>() << " -> ";
+			metadata["system"]["state"] = unresolved ? next : "open";
+			metadata["system"]["modified"] = unresolved;
+		//	std::cout << metadata["system"]["state"].as<std::string>() << std::endl;
+	//	return 0;}, true );
+	};
+	// lambda to transition into a resolving state
+	auto transitionResolvingState = [&]( ext::Terrain& that ){
+		uf::Serializer& metadata = that.getComponent<uf::Serializer>();
+	//	std::cout << "Resolving: " << metadata["system"]["state"].as<std::string>() << " -> ";
+		metadata["system"]["state"] = "resolving:" + metadata["system"]["state"].as<std::string>();
+	//	std::cout << metadata["system"]["state"].as<std::string>() << std::endl;
+	};
+	// lambda for sorting regions, nearest to farthest, from the controller
+	auto sortRegions = [&]( uf::Object& controller, std::vector<uf::Object*>& regions ){
+		const pod::Vector3& position = controller.getComponent<pod::Transform<>>().position;
+		std::sort( regions.begin(), regions.end(), [&]( const uf::Object* l, const uf::Object* r ){
+			if ( !l ) return false; if ( !r ) return true;
+			if ( !l->hasComponent<pod::Transform<>>() ) return false; if ( !r->hasComponent<pod::Transform<>>() ) return true;
+			return uf::vector::magnitude( uf::vector::subtract( l->getComponent<pod::Transform<>>().position, position ) ) < uf::vector::magnitude( uf::vector::subtract( r->getComponent<pod::Transform<>>().position, position ) );
+		} );
+	};
+	// generate initial terrain
+	if ( metadata["system"]["state"] == "preinit" ) {
+		uf::Entity* controller = scene.findByName("Player");
+		if ( controller ) {
+			transitionState(*this, "initialize", true);
+			this->generate(true);
+			this->relocateChildren();
+		//	this->queueHook("terrain:Post-Initialize.%UID%", "", 1.0f);
+			this->callHook("terrain:Post-Initialize.%UID%");
+		}
+	}
+	// process only if there's child regions
+	if ( this->getChildren().empty() ) return;
+
+	// multipurpose timer
+	static uf::Timer<long long> timer(false);
+	// open gamestate, look for work
+	if ( metadata["system"]["state"] == "open" ) { transitionResolvingState(*this);
+		// cleanup orphans
+		{
+
+		}
+		// remove regions too far
+		{
+			std::vector<pod::Vector3i> locations;
+			for ( uf::Entity* region : this->getChildren() ) { if ( !region || region->getName() != "Region" ) continue;
+				const pod::Transform<>& transform = region->getComponent<pod::Transform<>>();
+				pod::Vector3i location = { 
+					(int) transform.position.x / metadata["region"]["size"][0].as<int>(),
+					(int) transform.position.y / metadata["region"]["size"][1].as<int>(),
+					(int) transform.position.z / metadata["region"]["size"][2].as<int>()
+				};
+				// location too far
+				bool degenerate = !this->inBounds( location );
+				// keep if an entity requests for it
+				for ( uf::Entity* entity : region->getChildren() ) { if ( !entity ) continue;
+					uf::Serializer& metadata = entity->getComponent<uf::Serializer>();
+					if ( ext::json::isObject( metadata["region"] ) && metadata["region"]["persist"].as<bool>() ) {
+						degenerate = false;
+						break;
+					}
+				}
+				if ( degenerate )
+					locations.push_back(location);
+			}
+			// load new regions, remove old regions
+			if ( !locations.empty() ) {
+				this->generate();
+				for ( pod::Vector3i& location : locations )
+					this->degenerate(location);
+			}
+			// move to next state:
+			transitionState(*this, "initialize", !locations.empty());
+		}
+	}
+	// initialize new regions
+	if ( metadata["system"]["state"] == "initialize" ) { transitionResolvingState(*this);
+		uf::thread::add( uf::thread::fetchWorker(), [&]() -> int {
+			std::vector<uf::Object*> regions;
+			// retrieve changed regions
+			for ( uf::Entity* region : this->getChildren() ) { if ( !region ) continue;
+				uf::Serializer& metadata = region->getComponent<uf::Serializer>();
+			//	if ( ext::json::isObject( metadata["region"]["location"] ) )
+					regions.push_back((uf::Object*) region);
+			}
+			// sort by closest to farthest
+			sortRegions(controller, regions);
+			if ( metadata["terrain"]["unified"].as<bool>() ) {
+				auto& graphic = this->getComponent<uf::Graphic>();
+				auto& mesh = this->getComponent<ext::TerrainGenerator::mesh_t>();
+				mesh.destroy();
+				for ( uf::Object* region : regions ) {
+					uf::Serializer& metadata = region->getComponent<uf::Serializer>();
+					if ( !metadata["region"]["initialized"].as<bool>() ) region->initialize();
+					if ( !metadata["region"]["generated"].as<bool>() ) region->callHook("region:Generate.%UID%");
+					if ( !metadata["region"]["rasterized"].as<bool>() ) {
+						region->queueHook("region:Finalize.%UID%");
+						region->queueHook("region:Populate.%UID%");
+					}
+					auto& generator = region->getComponent<ext::TerrainGenerator>();
+					generator.rasterize(mesh.vertices, *region, false);
+				}
+				this->queueHook("terrain:GenerateMesh.%UID%");
+			} else {
+			// initialize uninitialized regions
+				for ( uf::Object* region : regions ) {
+				//	uf::thread::add( uf::thread::fetchWorker(), [&]() -> int {
+					uf::Serializer& metadata = region->getComponent<uf::Serializer>();
+					if ( !metadata["region"]["initialized"].as<bool>() ) region->initialize();
+					if ( !metadata["region"]["generated"].as<bool>() ) region->callHook("region:Generate.%UID%");
+					if ( !metadata["region"]["rasterized"].as<bool>() ) region->callHook("region:Rasterize.%UID%");
+				//	return 0;}, true );
+				}
+			}
+
+			// move to next state:
+			transitionState(*this, "open", !regions.empty());
+		return 0;}, true );
+	}
+	// check if we need to relocate entities
+	this->relocateChildren();
+}
+void ext::TerrainBehavior::render( uf::Object& self ){
+	uf::Scene& scene = uf::scene::getCurrentScene();
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	
+	if ( !metadata["terrain"]["unified"].as<bool>() ) return;
+	/* Update uniforms */ if ( this->hasComponent<uf::Graphic>() ) {
+		auto& scene = uf::scene::getCurrentScene();
+		auto& graphic = this->getComponent<uf::Graphic>();
+		auto& camera = scene.getController().getComponent<uf::Camera>();		
+		if ( !graphic.initialized ) return;
+
+		auto& shader = graphic.material.getShader("vertex");
+		auto& uniform = shader.getUniform("UBO");
+		auto& uniforms = uniform.get<uf::MeshDescriptor<>>();
+
+		uniforms.matrices.model = uf::matrix::identity();
+		for ( std::size_t i = 0; i < uf::renderer::settings::maxViews; ++i ) {
+			uniforms.matrices.view[i] = camera.getView( i );
+			uniforms.matrices.projection[i] = camera.getProjection( i );
+		}
+
+		shader.updateUniform( "UBO", uniform );
+	}
+}
+void ext::TerrainBehavior::destroy( uf::Object& self ){}
+#undef this
+UF_BEHAVIOR_ENTITY_CPP_END(Terrain)
\ No newline at end of file
diff --git a/ext/scenes/worldscape/terrain/behavior.h b/ext/scenes/worldscape/terrain/behavior.h
new file mode 100644
index 00000000..7cc76cab
--- /dev/null
+++ b/ext/scenes/worldscape/terrain/behavior.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/ext/ext.h>
+#include <uf/engine/entity/entity.h>
+#include <uf/engine/scene/scene.h>
+
+namespace ext {
+	class EXT_API TerrainBehavior {
+	public:
+		static void attach( uf::Entity& );
+		static void initialize( uf::Object& );
+		static void tick( uf::Object& );
+		static void render( uf::Object& );
+		static void destroy( uf::Object& );
+	};
+}
\ No newline at end of file
diff --git a/ext/scenes/worldscape/terrain/generator.cpp b/ext/scenes/worldscape/terrain/generator.cpp
new file mode 100644
index 00000000..eaaa2ba4
--- /dev/null
+++ b/ext/scenes/worldscape/terrain/generator.cpp
@@ -0,0 +1,1439 @@
+#include "generator.h"
+
+#include "../../../ext.h"
+#include "voxel.h"
+
+#include <uf/engine/entity/entity.h>
+
+#include <uf/utils/math/transform.h>
+#include <uf/utils/math/physics.h>
+
+#include <uf/utils/string/rle.h>
+#include <uf/utils/string/base64.h>
+#include <uf/utils/string/hash.h>
+
+#include <fstream>
+#include <queue>
+#include <bitset>
+
+namespace {
+	bool SWIZZLE_OPTIMIZATION = false;
+	ext::TerrainVoxel::light_t AMBIENT_LIGHT = 0x2222; //{std::numeric_limits<ext::TerrainVoxel::light_t::type_t>::max(), std::numeric_limits<ext::TerrainVoxel::light_t::type_t>::max(), std::numeric_limits<ext::TerrainVoxel::light_t::type_t>::max()};
+	struct COLOR {
+		uint r : 4;
+		uint g : 4;
+		uint b : 4;
+		uint a : 4;
+	};
+
+	COLOR uint16ToColor( uint16_t color ) {
+		COLOR result;
+		// memcpy( &result, &color, sizeof color );
+		result.r = (color >> 12) & 0xF;
+		result.g = (color >>  8) & 0xF;
+		result.b = (color >>  4) & 0xF;
+		result.a = (color      ) & 0xF;
+		return result;
+	}
+	uint16_t colorToUint16( COLOR color ) {
+		uint16_t result = 0;
+		// memcpy( &result, &color, sizeof color );
+		result |= (color.r << 12);
+		result |= (color.g <<  8);
+		result |= (color.b <<  4);
+		result |= (color.a      );
+		return result;
+	}
+	bool inBounds( int x, int y, int z, const pod::Vector3ui& size ) {
+		return (x >= 0 && x < size.x && y >= 0 && y < size.y && z >= 0 && z < size.z);
+	}
+}
+
+ext::TerrainGenerator::Swizzle ext::TerrainGenerator::DEFAULT_SWIZZLE = Swizzle::YZX;
+uf::PerlinNoise ext::TerrainGenerator::noise;
+
+void ext::TerrainGenerator::initialize( const pod::Vector3ui& size, uint subdivisions ){
+	this->m_subdivisions = subdivisions;
+	this->m_size = size * m_subdivisions;
+}
+void ext::TerrainGenerator::destroy(){
+/*
+	if ( !this->m_voxels.id.raw ) return;
+	for ( uint x = 0; x < this->m_size.x; ++x ) { 
+		for ( uint y = 0; y < this->m_size.y; ++y ) delete[] this->m_voxels.id.raw[x][y];
+		delete[] this->m_voxels.id.raw[x];
+	}
+	delete[] this->m_voxels.id.raw;
+	this->m_voxels.id.raw = NULL;
+*/
+
+//	this->m_voxels.id.raw.clear();
+//	this->m_voxels.lighting.raw.clear();
+
+}
+void ext::TerrainGenerator::generate( uf::Object& region ){
+	// if ( !this->m_voxels.id.raw.empty() || !this->m_voxels.id.rle.empty() ) return;
+	this->destroy();
+
+	uint half_x = this->m_size.x / 2;
+	uint half_y = this->m_size.y / 2;
+	uint half_z = this->m_size.z / 2;
+
+	const pod::Transform<>& transform = region.getComponent<pod::Transform<>>();
+	const pod::Vector3i location = {
+		transform.position.x / this->m_size.x,
+		transform.position.y / this->m_size.y,
+		transform.position.z / this->m_size.z,
+	}; this->m_location = location;
+	this->m_terrain = &region.getParent();
+/*
+	COLOR ambientLight = uint16ToColor(AMBIENT_LIGHT); {
+		uf::Serializer& tMetadata = region.getComponent<uf::Serializer>();
+		ambientLight.r *= tMetadata["region"]["light"]["ambient"][0].as<float>();
+		ambientLight.g *= tMetadata["region"]["light"]["ambient"][1].as<float>();
+		ambientLight.b *= tMetadata["region"]["light"]["ambient"][2].as<float>();
+	}
+*/
+	std::string base = region.getParent().getComponent<uf::Serializer>()["system"]["hash"].as<std::string>();
+	std::string filename = uf::io::root+"/save/" + base + "/regions/" + std::to_string(location.x) + "." + std::to_string(location.y) + "." + std::to_string(location.z) + ".json";
+	// old region, load save
+	if ( uf::io::exists( filename ) ) {
+		uf::Serializer save; save.readFromFile(filename);
+
+		// ID
+		if ( save["voxels"]["id"]["base64"].is<std::string>() ) {
+			std::string base64 = save["voxels"]["id"]["base64"].as<std::string>();
+			auto raw = uf::base64::decode( base64 );
+
+			if ( save["voxels"]["id"]["rle"].as<bool>() ) {
+				// [uint8_t]*4 -> [uint16_t, uint16_t]
+				this->m_voxels.id.rle.resize( raw.size() / ( sizeof(pod::RLE<ext::TerrainVoxel::uid_t>::length_t) + sizeof(pod::RLE<ext::TerrainVoxel::uid_t>::value_t) ) );
+				memcpy( &this->m_voxels.id.rle[0], &raw[0], raw.size() );
+			// normal voxel load or something
+			} else {
+
+			}
+			this->m_voxels.id.swizzle = (TerrainGenerator::Swizzle) save["voxels"]["id"]["swizzle"].as<size_t>();
+			this->unwrapVoxel();
+		}
+		// Lighting
+		if ( save["voxels"]["lighting"]["base64"].is<std::string>() ) {
+			std::string base64 = save["voxels"]["lighting"]["base64"].as<std::string>();
+			auto raw = uf::base64::decode( base64 );
+
+			if ( save["voxels"]["lighting"]["rle"].as<bool>() ) {
+				// [uint8_t]*4 -> [uint8_t, uint8_t]
+				this->m_voxels.lighting.rle.resize( raw.size() / ( sizeof(pod::RLE<ext::TerrainVoxel::light_t>::length_t) + sizeof(pod::RLE<ext::TerrainVoxel::light_t>::value_t) ) );
+				memcpy( &this->m_voxels.lighting.rle[0], &raw[0], raw.size() );
+			// normal voxel load or something
+			} else {
+
+			}
+			this->m_voxels.lighting.swizzle = (TerrainGenerator::Swizzle) save["voxels"]["lighting"]["swizzle"].as<size_t>();
+			this->unwrapLight();
+		}
+	// load failed / new region
+	}
+
+	// maze
+/*
+	{
+		ext::Maze& maze = this->m_terrain->getComponent<ext::Maze>();
+		struct {
+			int CENTER = ext::Maze::FLOOR | ext::Maze::CEIL;
+			int NORTH = ext::Maze::FLOOR | ext::Maze::CEIL;
+			int SOUTH = ext::Maze::FLOOR | ext::Maze::CEIL;
+			int EAST = ext::Maze::FLOOR | ext::Maze::CEIL;
+			int WEST = ext::Maze::FLOOR | ext::Maze::CEIL;
+		} LABYRINTH;
+		{
+			std::cout << "MAZE AT: " << this->m_location.x << ", " << this->m_location.z << std::endl;
+		}
+		{
+			int COL = this->m_location.x + (maze.LENGTH / 2) - 1;
+			int ROW = -this->m_location.z + (maze.WIDTH / 2) - 1;
+			if ( ROW >= 0 && ROW < maze.WIDTH && COL >= 0 && COL < maze.LENGTH ) LABYRINTH.CENTER = maze( ROW, COL, 0 );
+			std::cout << "CENTER:\n\t"; // << std::bitset<8>(LABYRINTH.CENTER) << std::endl;
+				if ( LABYRINTH.CENTER & ext::Maze::NORTH ) std::cout << "NORTH\t";
+				if ( LABYRINTH.CENTER & ext::Maze::SOUTH ) std::cout << "SOUTH\t";
+				if ( LABYRINTH.CENTER & ext::Maze::EAST ) std::cout << "EAST\t";
+				if ( LABYRINTH.CENTER & ext::Maze::WEST ) std::cout << "WEST\t";
+			std::cout << std::endl;
+		}
+		{
+			int COL = this->m_location.x + (maze.LENGTH / 2) - 1;
+			int ROW = -this->m_location.z + (maze.WIDTH / 2) - 1;
+			--ROW;
+			if ( ROW >= 0 && ROW < maze.WIDTH && COL >= 0 && COL < maze.LENGTH ) LABYRINTH.NORTH = maze( ROW, COL, 0 );
+			std::cout << "NORTH:\n\t"; // << std::bitset<8>(LABYRINTH.NORTH) << std::endl;
+				if ( LABYRINTH.NORTH & ext::Maze::NORTH ) std::cout << "NORTH\t";
+				if ( LABYRINTH.NORTH & ext::Maze::SOUTH ) std::cout << "SOUTH\t";
+				if ( LABYRINTH.NORTH & ext::Maze::EAST ) std::cout << "EAST\t";
+				if ( LABYRINTH.NORTH & ext::Maze::WEST ) std::cout << "WEST\t";
+			std::cout << std::endl;
+		}
+		{
+			int COL = this->m_location.x + (maze.LENGTH / 2) - 1;
+			int ROW = -this->m_location.z + (maze.WIDTH / 2) - 1;
+			++ROW;
+			if ( ROW >= 0 && ROW < maze.WIDTH && COL >= 0 && COL < maze.LENGTH ) LABYRINTH.SOUTH = maze( ROW, COL, 0 );
+			std::cout << "SOUTH:\n\t"; // << std::bitset<8>(LABYRINTH.SOUTH) << std::endl;
+				if ( LABYRINTH.SOUTH & ext::Maze::NORTH ) std::cout << "NORTH\t";
+				if ( LABYRINTH.SOUTH & ext::Maze::SOUTH ) std::cout << "SOUTH\t";
+				if ( LABYRINTH.SOUTH & ext::Maze::EAST ) std::cout << "EAST\t";
+				if ( LABYRINTH.SOUTH & ext::Maze::WEST ) std::cout << "WEST\t";
+			std::cout << std::endl;
+		}
+		{
+			int COL = this->m_location.x + (maze.LENGTH / 2) - 1;
+			int ROW = -this->m_location.z + (maze.WIDTH / 2) - 1;
+			++COL;
+			if ( ROW >= 0 && ROW < maze.WIDTH && COL >= 0 && COL < maze.LENGTH ) LABYRINTH.EAST = maze( ROW, COL, 0 );
+			std::cout << "EAST:\n\t"; // << std::bitset<8>(LABYRINTH.EAST) << std::endl;
+				if ( LABYRINTH.EAST & ext::Maze::NORTH ) std::cout << "NORTH\t";
+				if ( LABYRINTH.EAST & ext::Maze::SOUTH ) std::cout << "SOUTH\t";
+				if ( LABYRINTH.EAST & ext::Maze::EAST ) std::cout << "EAST\t";
+				if ( LABYRINTH.EAST & ext::Maze::WEST ) std::cout << "WEST\t";
+			std::cout << std::endl;
+		}
+		{
+			int COL = this->m_location.x + (maze.LENGTH / 2) - 1;
+			int ROW = -this->m_location.z + (maze.WIDTH / 2) - 1;
+			--COL;
+			if ( ROW >= 0 && ROW < maze.WIDTH && COL >= 0 && COL < maze.LENGTH ) LABYRINTH.WEST = maze( ROW, COL, 0 );
+			std::cout << "WEST:\n\t"; // << std::bitset<8>(LABYRINTH.WEST) << std::endl;
+				if ( LABYRINTH.WEST & ext::Maze::NORTH ) std::cout << "NORTH\t";
+				if ( LABYRINTH.WEST & ext::Maze::SOUTH ) std::cout << "SOUTH\t";
+				if ( LABYRINTH.WEST & ext::Maze::EAST ) std::cout << "EAST\t";
+				if ( LABYRINTH.WEST & ext::Maze::WEST ) std::cout << "WEST\t";
+			std::cout << std::endl;
+		}
+		std::cout << std::endl;
+	}
+*/
+	if ( this->m_voxels.id.rle.empty() ) {
+		double maxValue = 0.0;
+		double base = 0;
+		
+		ext::TerrainVoxel::uid_t raw_id[this->m_size.x][this->m_size.y][this->m_size.z];
+		ext::TerrainVoxel::light_t raw_lighting[this->m_size.x][this->m_size.y][this->m_size.z];
+		double raw_noise[this->m_size.x][this->m_size.y][this->m_size.z];
+
+		for ( uint y = 0; y < this->m_size.y; ++y )
+		for ( uint z = 0; z < this->m_size.z; ++z )
+		for ( uint x = 0; x < this->m_size.x; ++x ) {
+			pod::Vector3d position = {
+				transform.position.x - half_x, transform.position.y - half_y, transform.position.z - half_z
+			};
+			position.x += (double) x / (double) this->m_size.x;
+			position.y += (double) y / (double) this->m_size.y;
+			position.z += (double) z / (double) this->m_size.z;
+			raw_noise[x][y][z] = ext::TerrainGenerator::noise.sample( position );
+			maxValue = std::max( maxValue, raw_noise[x][y][z] );
+		}
+		
+
+		for ( uint y = 0; y < this->m_size.y; ++y )
+		for ( uint z = 0; z < this->m_size.z; ++z )
+		for ( uint x = 0; x < this->m_size.x; ++x )
+			base += raw_noise[x][y][z] / maxValue;
+
+		base /= this->m_size.x * this->m_size.y * this->m_size.z;
+
+		uint partitions = this->m_modulus;
+		struct {
+			ext::TerrainVoxel::uid_t floor = ext::TerrainVoxelFloor().uid();
+			ext::TerrainVoxel::uid_t wall = ext::TerrainVoxelWall().uid();
+			ext::TerrainVoxel::uid_t ceiling = ext::TerrainVoxelCeiling().uid();
+			ext::TerrainVoxel::uid_t stair = ext::TerrainVoxelStair().uid();
+			ext::TerrainVoxel::uid_t pillar = ext::TerrainVoxelPillar().uid();
+			ext::TerrainVoxel::uid_t lava = ext::TerrainVoxelLava().uid();
+		} atlas;
+		
+		this->m_voxels.id.raw.reserve( this->m_size.x * this->m_size.y * this->m_size.z );
+		this->m_voxels.lighting.raw.reserve( this->m_size.x * this->m_size.y * this->m_size.z );
+
+		ext::Maze& maze = this->m_terrain->getComponent<ext::Maze>();
+		struct {
+			int CENTER = ext::Maze::FLOOR | ext::Maze::CEIL;
+		} LABYRINTH;
+		{
+			int COL = this->m_location.x + (maze.LENGTH / 2) - 1;
+			int ROW = -this->m_location.z + (maze.WIDTH / 2) - 1;
+			if ( ROW >= 0 && ROW < maze.WIDTH && COL >= 0 && COL < maze.LENGTH ) LABYRINTH.CENTER = maze( ROW, COL, 0 );
+		}
+
+		std::size_t i = 0;
+		for ( uint y = 0; y < this->m_size.y; ++y ) {
+		for ( uint z = 0; z < this->m_size.z; ++z ) {
+		for ( uint x = 0; x < this->m_size.x; ++x ) {
+			ext::TerrainVoxel::uid_t voxel = 0;
+
+			double e = raw_noise[x][y][z] / maxValue;
+			// generate walls if wall exists in maze
+	
+		//	if ( (x) % (this->m_size.x / partitions) == 0 ) voxel = atlas.wall;
+		//	if ( (z) % (this->m_size.z / partitions) == 0 ) voxel = atlas.wall;
+		/*
+			if ( (x + 1) % (this->m_size.x / partitions) == 0 ) voxel = atlas.wall;
+			if ( (z + 1) % (this->m_size.z / partitions) == 0 ) voxel = atlas.wall;
+
+			if ( y > 0 && y < this->m_size.y - 1 ) {
+				if ( x % (this->m_size.x / partitions) >= 3 && x % (this->m_size.x / partitions) <= partitions - 4 ) voxel = 0;
+				if ( z % (this->m_size.z / partitions) >= 3 && z % (this->m_size.z / partitions) <= partitions - 4 ) voxel = 0;
+			}
+		*/
+			if ( y <= 1 ) voxel = atlas.floor; if ( y == this->m_size.y - 1 ) voxel = atlas.ceiling;
+			if ( uf::vector::sum(location) != 0 ) {
+				if ( e < 0.5 ) voxel = y == 0 ? atlas.lava : 0;
+			//	if ( raw_noise[x][1][z] / maxValue < 0.2 || raw_noise[x][2][z] / maxValue > 0.8 ) voxel = atlas.stair;
+				if ( raw_noise[x][1][z] < 0.2 || raw_noise[x][2][z] > 0.8 ) voxel = atlas.stair;
+			} else {
+			//	if ( x == half_x && y == 4 && z == half_z ) voxel = atlas.lava;
+			}
+	
+			auto light = ext::TerrainVoxel::atlas(voxel).light();
+
+			if ( LABYRINTH.CENTER & ext::Maze::EAST ) if ( x == this->m_size.x - 1 ) voxel = atlas.wall;
+			if ( LABYRINTH.CENTER & ext::Maze::WEST ) if ( x == 0 ) voxel = atlas.wall;
+			if ( LABYRINTH.CENTER & ext::Maze::NORTH ) if ( z == this->m_size.z - 1 ) voxel = atlas.wall;
+			if ( LABYRINTH.CENTER & ext::Maze::SOUTH ) if ( z == 0 ) voxel = atlas.wall;
+		//	if ( LABYRINTH.CENTER & ext::Maze::FLOOR ) if ( y == 0 ) voxel = atlas.floor;
+		//	if ( LABYRINTH.CENTER & ext::Maze::CEIL ) if ( y == this->m_size.y - 1 ) voxel = atlas.ceiling;
+			
+			if ( light < AMBIENT_LIGHT ) light = AMBIENT_LIGHT;
+
+			raw_id[x][y][z] = voxel;
+			raw_lighting[x][y][z] = light;
+			
+			// write to raw buffers
+			this->m_voxels.id.raw.push_back(voxel);
+			this->m_voxels.lighting.raw.push_back(light);
+		}
+		}
+		}
+
+		uf::Serializer serializer;
+		// redundant but sure
+		serializer["location"][0] = location.x;
+		serializer["location"][1] = location.y;
+		serializer["location"][2] = location.z;
+		
+		this->writeToFile();
+	}
+	this->destroy();
+}
+
+void ext::TerrainGenerator::writeToFile() {
+	this->wrapVoxel();
+	this->wrapLight();
+
+	uf::Serializer serializer;
+	std::string base = this->m_terrain ? this->m_terrain->getComponent<uf::Serializer>()["system"]["hash"].as<std::string>() : "UNKNOWN";
+	std::string filename = uf::io::root+"/save/" + base + "/regions/" + std::to_string(this->m_location.x) + "." + std::to_string(this->m_location.y) + "." + std::to_string(this->m_location.z) + ".json";
+	{
+		// encode as base64, json safe
+		serializer["voxels"]["id"]["base64"] = uf::base64::encode( this->m_voxels.id.rle );
+		// hash of raw data for data integrity
+		serializer["voxels"]["id"]["hash"] = uf::string::sha256( uf::base64::decode(serializer["voxels"]["id"]["rle"]["base64"].as<std::string>()) );
+		serializer["voxels"]["id"]["rle"] = true;
+		serializer["voxels"]["id"]["swizzle"] = this->m_voxels.id.swizzle;
+	}
+	{
+		// encode as base64, json safe
+		serializer["voxels"]["lighting"]["base64"] = uf::base64::encode( this->m_voxels.lighting.rle );
+		// hash of raw data for data integrity
+		serializer["voxels"]["lighting"]["hash"] = uf::string::sha256( uf::base64::decode(serializer["voxels"]["lighting"]["rle"]["base64"].as<std::string>()) );
+		serializer["voxels"]["lighting"]["rle"] = true;
+		serializer["voxels"]["lighting"]["swizzle"] = this->m_voxels.lighting.swizzle;
+	}
+
+	serializer.writeToFile(filename);
+
+	this->destroy();
+}
+
+std::vector<ext::TerrainVoxel::uid_t> ext::TerrainGenerator::getRawVoxels() {
+	return this->m_voxels.id.raw;
+}
+const pod::RLE<ext::TerrainVoxel::uid_t>::string_t& ext::TerrainGenerator::getVoxels() const {
+	return this->m_voxels.id.rle;
+}
+
+ext::TerrainVoxel::uid_t ext::TerrainGenerator::getVoxel( int x, int y, int z ) const {
+	// check oob
+	if ( !inBounds( x, y, z, this->m_size )  ) {
+		if ( !this->m_terrain ) return 0;
+
+		const ext::Terrain& terrain = *((const ext::Terrain*)this->m_terrain);
+		pod::Vector3i location = this->m_location;
+		while ( !inBounds( x, y, z, this->m_size )  ) {
+			if ( x < 0 ) {
+				x += this->m_size.x;
+				--location.x;
+			} else if ( x >= this->m_size.x ) {
+				x -= this->m_size.x;
+				++location.x;
+			}
+			if ( y < 0 ) {
+				y += this->m_size.y;
+				--location.y;
+			} else if ( y >= this->m_size.y ) {
+				y -= this->m_size.y;
+				++location.y;
+			}
+			if ( z < 0 ) {
+				z += this->m_size.z;
+				--location.z;
+			} else if ( z >= this->m_size.z ) {
+				z -= this->m_size.z;
+				++location.z;
+			}
+		}
+		uf::Object* region = terrain.at( location );
+		if ( !region ) return 0;
+		return region->getComponent<ext::TerrainGenerator>().getVoxel( x, y, z );
+	/*
+		while ( x < 0 ) {
+			--location.x;
+			x += this->m_size.x;
+		}
+		while ( x >= this->m_size.x - 1 ) {
+			++location.x;
+			x -= this->m_size.x;
+		}
+		while ( y < 0 ) {
+			--location.y;
+			y += this->m_size.y;
+		}
+		while ( y >= this->m_size.y - 1 ) {
+			++location.y;
+			y -= this->m_size.y;
+		}
+		while ( z < 0 ) {
+			--location.z;
+			z += this->m_size.z;
+		}
+		while ( z >= this->m_size.z - 1 ) {
+			++location.z;
+			z -= this->m_size.z;
+		}
+		uf::Object* region = terrain.at( location );
+		if ( !region ) return 0;
+		return region->getComponent<ext::TerrainGenerator>().getVoxel( x, y, z );
+	*/
+	}
+
+//	if ( this->m_voxels.id.raw ) return this->m_voxels.id.raw[x][y][z];
+	if ( !this->m_voxels.id.raw.empty() ) {
+		std::size_t i = this->wrapPosition( x, y, z, this->m_voxels.id.swizzle );
+		return this->m_voxels.id.raw[i];
+	}
+
+	std::size_t i = 0;
+	for ( auto& _ : this->m_voxels.id.rle ) {
+		for ( std::size_t __ = 0; __ < _.length; ++__ ) {
+			auto v = this->unwrapIndex( i++, this->m_voxels.id.swizzle );
+			if ( v.x == x && v.y == y && v.z == z ) return _.value;
+		}
+	}
+	return 0;
+}
+ext::TerrainVoxel::uid_t ext::TerrainGenerator::getVoxel( const pod::Vector3i& location ) const {
+	return this->getVoxel( location.x, location.y, location.z );
+}
+ext::TerrainVoxel::light_t ext::TerrainGenerator::getLight( int x, int y, int z ) const {
+	// check oob
+	if ( !inBounds( x, y, z, this->m_size )  ) {
+		if ( !this->m_terrain ) {
+//			std::cout << "Invalid call @ getLight( " << x << ", " << y << ", " << z << " ) " << std::endl;
+			return 0x0000;
+		}
+
+		const ext::Terrain& terrain = *((const ext::Terrain*)this->m_terrain);
+		pod::Vector3i location = this->m_location;
+		while ( !inBounds( x, y, z, this->m_size )  ) {
+			if ( x < 0 ) {
+				x += this->m_size.x;
+				--location.x;
+			} else if ( x >= this->m_size.x ) {
+				x -= this->m_size.x;
+				++location.x;
+			}
+			if ( y < 0 ) {
+				y += this->m_size.y;
+				--location.y;
+			} else if ( y >= this->m_size.y ) {
+				y -= this->m_size.y;
+				++location.y;
+			}
+			if ( z < 0 ) {
+				z += this->m_size.z;
+				--location.z;
+			} else if ( z >= this->m_size.z ) {
+				z -= this->m_size.z;
+				++location.z;
+			}
+		}
+	/*
+		while ( x < 0 ) {
+			--location.x;
+			x += this->m_size.x;
+		}
+		while ( x >= this->m_size.x - 1 ) {
+			++location.x;
+			x -= this->m_size.x - 1;
+		}
+		while ( y < 0 ) {
+			--location.y;
+			y += this->m_size.y;
+		}
+		while ( y >= this->m_size.y - 1 ) {
+			++location.y;
+			y -= this->m_size.y - 1;
+		}
+		while ( z < 0 ) {
+			--location.z;
+			z += this->m_size.z;
+		}
+		while ( z >= this->m_size.z - 1 ) {
+			++location.z;
+			z -= this->m_size.z - 1;
+		}
+	*/
+		uf::Object* region = terrain.at( location );
+		if ( !region ) {
+		//	std::cout << "Out of bounds Region("<< location.x << ", " << location.y << ", " << location.z <<") @ getLight( " << x << ", " << y << ", " << z << " ) " << std::endl;
+			return 0xFFFF;
+		}
+		return region->getComponent<ext::TerrainGenerator>().getLight( x, y, z );
+	}
+
+/*
+	if ( !this->m_voxels.lighting.raw.empty() ) {
+		std::size_t i = this->wrapPosition( x, y, z, this->m_voxels.lighting.swizzle );
+		return this->m_voxels.lighting.raw[i];
+	}
+*/
+	std::size_t i = 0;
+	for ( auto& _ : this->m_voxels.lighting.rle ) {
+		for ( std::size_t __ = 0; __ < _.length; ++__ ) {
+			auto v = this->unwrapIndex( i++, this->m_voxels.lighting.swizzle );
+			if ( v.x == x && v.y == y && v.z == z ) {
+				return _.value;
+			}
+		}
+	}
+	return 0x0000;
+}
+ext::TerrainVoxel::light_t ext::TerrainGenerator::getLight( const pod::Vector3i& location ) const {
+	return this->getLight( location.x, location.y, location.z );
+}
+pod::Vector3i ext::TerrainGenerator::unwrapIndex( int64_t i, Swizzle swizzle ) const {
+	// ordered from first to change to last to change
+	/*
+		result.x = i % this->m_size.x;
+		result.y = ( i / this->m_size.x ) % this->m_size.y;
+		result.z = i / ( this->m_size.x * this->m_size.y );
+	*/
+	pod::Vector3ui size;
+	switch ( swizzle ) {
+		case Swizzle::YZX:
+			size = {
+				this->m_size.x,
+				this->m_size.z,
+				this->m_size.y,
+			};
+			return {
+				i % size.x,
+				i / ( size.x * size.y ),
+				( i / size.x ) % size.y,
+			};
+		break;
+		case Swizzle::ZXY:
+			size = {
+				this->m_size.y,
+				this->m_size.x,
+				this->m_size.z,
+			};
+			return {
+				( i / size.x ) % size.y,
+				i % size.x,
+				i / ( size.x * size.y ),
+			};
+		break;
+		case Swizzle::XYZ:
+		default:
+			size = {
+				this->m_size.z,
+				this->m_size.y,
+				this->m_size.x,
+			};
+			return {
+				( i / size.x ) % size.y,
+				i / ( size.x * size.y ),
+				i % size.x,
+			};
+		break;
+	}
+}
+
+// (y, z, x) -> (x, y, z)
+int64_t ext::TerrainGenerator::wrapPosition( int64_t x, int64_t y, int64_t z, Swizzle swizzle ) const {
+	// ordered from first to change to last to change
+	pod::Vector3ui input;
+	pod::Vector3ui size;
+	switch ( swizzle ) {
+		case Swizzle::YZX:
+			input = {
+				x,
+				z,
+				y,
+			};
+			size = {
+				this->m_size.x,
+				this->m_size.z,
+				this->m_size.y,
+			};
+		break;
+		case Swizzle::ZXY:
+			input = {
+				y,
+				x,
+				z,
+			};
+			size = {
+				this->m_size.y,
+				this->m_size.x,
+				this->m_size.z,
+			};
+		break;
+		case Swizzle::XYZ:
+			input = {
+				z,
+				y,
+				x,
+			};
+			size = {
+				this->m_size.z,
+				this->m_size.y,
+				this->m_size.x,
+			};
+		break;
+	}
+	return size.y * size.x * input.z + size.x * input.y + input.x;
+//	return size.z * size.x * input.y + size.x * input.z + input.x;
+//	return (x * this->m_size.y * this->m_size.z) + (z * this->m_size.y) + y;
+}
+int64_t ext::TerrainGenerator::wrapPosition( const pod::Vector3i& position, Swizzle swizzle ) const {
+	return this->wrapPosition( position.x, position.y, position.z, swizzle );
+}
+
+void ext::TerrainGenerator::wrapVoxel() { if ( this->m_voxels.id.raw.empty() ) return;
+	this->m_voxels.id.rle.clear();
+
+	ext::TerrainVoxel::uid_t raw_id[this->m_size.x][this->m_size.y][this->m_size.z];
+	this->m_voxels.id.swizzle = ext::TerrainGenerator::DEFAULT_SWIZZLE;
+	
+	for ( std::size_t i = 0; i < this->m_size.x * this->m_size.y * this->m_size.z; ++i ) {
+		auto position = this->unwrapIndex( i, this->m_voxels.id.swizzle );
+		raw_id[position.x][position.y][position.z] = this->m_voxels.id.raw[i];
+	}
+
+	std::vector<ext::TerrainVoxel::uid_t> buffer;
+	buffer.reserve( this->m_size.x * this->m_size.y * this->m_size.z );
+
+	// use YZX
+	if ( SWIZZLE_OPTIMIZATION ) {
+		pod::RLE<ext::TerrainVoxel::uid_t>::string_t xyz, yzx, zxy;
+		{
+			for ( uint x = 0; x < this->m_size.x; x++ ) 
+			for ( uint y = 0; y < this->m_size.y; y++ ) 
+			for ( uint z = 0; z < this->m_size.z; z++ )
+				buffer.push_back( raw_id[x][y][z] );
+			xyz = uf::rle::encode( buffer );
+		}
+		buffer.clear();
+		buffer.reserve( this->m_size.x * this->m_size.y * this->m_size.z );
+		{
+			for ( uint y = 0; y < this->m_size.y; y++ ) 
+			for ( uint z = 0; z < this->m_size.z; z++ )
+			for ( uint x = 0; x < this->m_size.x; x++ ) 
+				buffer.push_back( raw_id[x][y][z] );
+			yzx = uf::rle::encode( buffer );
+		}
+		buffer.clear();
+		buffer.reserve( this->m_size.x * this->m_size.y * this->m_size.z );
+		{
+			for ( uint z = 0; z < this->m_size.z; z++ )
+			for ( uint x = 0; x < this->m_size.x; x++ ) 
+			for ( uint y = 0; y < this->m_size.y; y++ ) 
+				buffer.push_back( raw_id[x][y][z] );
+			zxy = uf::rle::encode( buffer );
+		}
+
+		// xyz
+		if ( xyz.size() <= yzx.size() && xyz.size() <= zxy.size() )  {
+			this->m_voxels.id.swizzle = Swizzle::XYZ;
+			this->m_voxels.id.rle = xyz;
+		// yzx
+		} else if ( yzx.size() <= xyz.size() && yzx.size() <= zxy.size() ) {
+			this->m_voxels.id.swizzle = Swizzle::YZX;
+			this->m_voxels.id.rle = yzx;
+		} else if ( zxy.size() <= xyz.size() && zxy.size() <= yzx.size() ) {
+			this->m_voxels.id.swizzle = Swizzle::ZXY;
+			this->m_voxels.id.rle = zxy;
+		} else {
+			this->m_voxels.id.swizzle = Swizzle::YZX;
+			this->m_voxels.id.rle = yzx;
+		}
+	} else {
+		for ( uint y = 0; y < this->m_size.y; y++ ) 
+		for ( uint z = 0; z < this->m_size.z; z++ )
+		for ( uint x = 0; x < this->m_size.x; x++ ) 
+			buffer.push_back( raw_id[x][y][z] );
+		this->m_voxels.id.swizzle = Swizzle::YZX;
+		this->m_voxels.id.rle = uf::rle::encode( buffer );
+	}
+}
+void ext::TerrainGenerator::wrapLight() { if ( this->m_voxels.lighting.raw.empty() ) return;
+	this->m_voxels.lighting.rle.clear();
+
+	ext::TerrainVoxel::light_t raw_lighting[this->m_size.x][this->m_size.y][this->m_size.z];
+	this->m_voxels.lighting.swizzle = ext::TerrainGenerator::DEFAULT_SWIZZLE;
+	
+	for ( std::size_t i = 0; i < this->m_size.x * this->m_size.y * this->m_size.z; ++i ) {
+		auto position = this->unwrapIndex( i, this->m_voxels.lighting.swizzle );
+		raw_lighting[position.x][position.y][position.z] = this->m_voxels.lighting.raw[i];
+	}
+
+	std::vector<ext::TerrainVoxel::light_t> buffer;
+	buffer.reserve( this->m_size.x * this->m_size.y * this->m_size.z );
+
+	// use YZX
+	if ( SWIZZLE_OPTIMIZATION ) {
+		pod::RLE<ext::TerrainVoxel::light_t>::string_t xyz, yzx, zxy;
+		{
+			for ( uint x = 0; x < this->m_size.x; x++ ) 
+			for ( uint y = 0; y < this->m_size.y; y++ ) 
+			for ( uint z = 0; z < this->m_size.z; z++ )
+				buffer.push_back( raw_lighting[x][y][z] );
+			xyz = uf::rle::encode( buffer );
+		}
+		buffer.clear();
+		buffer.reserve( this->m_size.x * this->m_size.y * this->m_size.z );
+		{
+			for ( uint y = 0; y < this->m_size.y; y++ ) 
+			for ( uint z = 0; z < this->m_size.z; z++ )
+			for ( uint x = 0; x < this->m_size.x; x++ ) 
+				buffer.push_back( raw_lighting[x][y][z] );
+			yzx = uf::rle::encode( buffer );
+		}
+		buffer.clear();
+		buffer.reserve( this->m_size.x * this->m_size.y * this->m_size.z );
+		{
+			for ( uint z = 0; z < this->m_size.z; z++ )
+			for ( uint x = 0; x < this->m_size.x; x++ ) 
+			for ( uint y = 0; y < this->m_size.y; y++ ) 
+				buffer.push_back( raw_lighting[x][y][z] );
+			zxy = uf::rle::encode( buffer );
+		}
+
+		// xyz
+		if ( xyz.size() <= yzx.size() && xyz.size() <= zxy.size() )  {
+			this->m_voxels.lighting.swizzle = Swizzle::XYZ;
+			this->m_voxels.lighting.rle = xyz;
+		// yzx
+		} else if ( yzx.size() <= xyz.size() && yzx.size() <= zxy.size() ) {
+			this->m_voxels.lighting.swizzle = Swizzle::YZX;
+			this->m_voxels.lighting.rle = yzx;
+		} else if ( zxy.size() <= xyz.size() && zxy.size() <= yzx.size() ) {
+			this->m_voxels.lighting.swizzle = Swizzle::ZXY;
+			this->m_voxels.lighting.rle = zxy;
+		} else {
+			this->m_voxels.lighting.swizzle = Swizzle::YZX;
+			this->m_voxels.lighting.rle = yzx;
+		}
+	} else {
+		for ( uint y = 0; y < this->m_size.y; y++ ) 
+		for ( uint z = 0; z < this->m_size.z; z++ )
+		for ( uint x = 0; x < this->m_size.x; x++ ) 
+			buffer.push_back( raw_lighting[x][y][z] );
+		this->m_voxels.lighting.swizzle = Swizzle::YZX;
+
+		this->m_voxels.lighting.rle = uf::rle::encode( buffer );
+	}
+}
+void ext::TerrainGenerator::unwrapVoxel() {
+	ext::TerrainVoxel::uid_t raw_id[this->m_size.x][this->m_size.y][this->m_size.z];
+
+	this->m_voxels.id.raw.clear();
+	this->m_voxels.id.raw.reserve(this->m_size.x * this->m_size.y * this->m_size.z);
+
+	std::size_t i = 0;
+	for ( auto& _ : this->m_voxels.id.rle ) {
+		for ( std::size_t __ = 0; __ < _.length; ++__ ) {
+			auto v = this->unwrapIndex( i++, this->m_voxels.id.swizzle );
+			raw_id[v.x][v.y][v.z] = _.value;
+		}
+	}
+	for ( uint y = 0; y < this->m_size.y; y++ ) 
+	for ( uint z = 0; z < this->m_size.z; z++ )
+	for ( uint x = 0; x < this->m_size.x; x++ ) 
+		this->m_voxels.id.raw.push_back( raw_id[x][y][z] );
+}
+void ext::TerrainGenerator::unwrapLight() {
+	ext::TerrainVoxel::light_t raw_lighting[this->m_size.x][this->m_size.y][this->m_size.z];
+
+	this->m_voxels.lighting.raw.clear();
+	this->m_voxels.lighting.raw.reserve(this->m_size.x * this->m_size.y * this->m_size.z);
+
+	std::size_t i = 0;
+	for ( auto& _ : this->m_voxels.lighting.rle ) {
+		for ( std::size_t __ = 0; __ < _.length; ++__ ) {
+			auto v = this->unwrapIndex( i++, this->m_voxels.lighting.swizzle );
+			raw_lighting[v.x][v.y][v.z] = _.value;
+		}
+	}
+	for ( uint y = 0; y < this->m_size.y; y++ ) 
+	for ( uint z = 0; z < this->m_size.z; z++ )
+	for ( uint x = 0; x < this->m_size.x; x++ ) 
+		this->m_voxels.lighting.raw.push_back( raw_lighting[x][y][z] );
+}
+
+void ext::TerrainGenerator::setVoxel( int x, int y, int z, const ext::TerrainVoxel::uid_t& voxel, bool update ){
+	// check oob
+	if ( !inBounds( x, y, z, this->m_size )  ) {
+		if ( !this->m_terrain ) return;
+
+		const ext::Terrain& terrain = *((const ext::Terrain*)this->m_terrain);
+		pod::Vector3i location = this->m_location;
+		while ( !inBounds( x, y, z, this->m_size )  ) {
+			if ( x < 0 ) {
+				x += this->m_size.x;
+				--location.x;
+			} else if ( x >= this->m_size.x ) {
+				x -= this->m_size.x;
+				++location.x;
+			}
+			if ( y < 0 ) {
+				y += this->m_size.y;
+				--location.y;
+			} else if ( y >= this->m_size.y ) {
+				y -= this->m_size.y;
+				++location.y;
+			}
+			if ( z < 0 ) {
+				z += this->m_size.z;
+				--location.z;
+			} else if ( z >= this->m_size.z ) {
+				z -= this->m_size.z;
+				++location.z;
+			}
+		}
+	/*
+		while ( x < 0 ) {
+			--location.x;
+			x += this->m_size.x;
+		}
+		while ( x >= this->m_size.x - 1 ) {
+			++location.x;
+			x -= this->m_size.x - 1;
+		}
+		while ( y < 0 ) {
+			--location.y;
+			y += this->m_size.y;
+		}
+		while ( y >= this->m_size.y - 1 ) {
+			++location.y;
+			y -= this->m_size.y - 1;
+		}
+		while ( z < 0 ) {
+			--location.z;
+			z += this->m_size.z;
+		}
+		while ( z >= this->m_size.z - 1 ) {
+			++location.z;
+			z -= this->m_size.z - 1;
+		}
+	*/
+		uf::Object* region = terrain.at( location );
+		if ( !region ) return;
+		region->getComponent<ext::TerrainGenerator>().setVoxel( x, y, z, voxel, update );
+		return;
+	}
+
+	// set modified
+	if ( this->m_terrain ) {
+		const ext::Terrain& terrain = *((const ext::Terrain*)this->m_terrain);
+		uf::Object* region = terrain.at( this->m_location );
+		if ( region ) region->getComponent<uf::Serializer>()["region"]["modified"] = true;
+	}
+
+	std::size_t i = this->wrapPosition(x, y, z, this->m_voxels.id.swizzle);
+	this->m_voxels.id.raw[i] = voxel;
+
+	this->wrapVoxel();
+}
+void ext::TerrainGenerator::setVoxel( const pod::Vector3i& location, const ext::TerrainVoxel::uid_t& light, bool update ){
+	return this->setVoxel( location.x, location.y, location.z, light, update );
+}
+void ext::TerrainGenerator::setLight( int x, int y, int z, const ext::TerrainVoxel::light_t& light, bool update ){
+	// check oob
+	if ( !inBounds( x, y, z, this->m_size )  ) {
+		if ( !this->m_terrain ) return;
+
+		const ext::Terrain& terrain = *((const ext::Terrain*)this->m_terrain);
+		pod::Vector3i location = this->m_location;
+		while ( !inBounds( x, y, z, this->m_size )  ) {
+			if ( x < 0 ) {
+				x += this->m_size.x;
+				--location.x;
+			} else if ( x >= this->m_size.x ) {
+				x -= this->m_size.x;
+				++location.x;
+			}
+			if ( y < 0 ) {
+				y += this->m_size.y;
+				--location.y;
+			} else if ( y >= this->m_size.y ) {
+				y -= this->m_size.y;
+				++location.y;
+			}
+			if ( z < 0 ) {
+				z += this->m_size.z;
+				--location.z;
+			} else if ( z >= this->m_size.z ) {
+				z -= this->m_size.z;
+				++location.z;
+			}
+		}
+	/*
+		while ( x < 0 ) {
+			--location.x;
+			x += this->m_size.x;
+		}
+		while ( x >= this->m_size.x - 1 ) {
+			++location.x;
+			x -= this->m_size.x - 1;
+		}
+		while ( y < 0 ) {
+			--location.y;
+			y += this->m_size.y;
+		}
+		while ( y >= this->m_size.y - 1 ) {
+			++location.y;
+			y -= this->m_size.y - 1;
+		}
+		while ( z < 0 ) {
+			--location.z;
+			z += this->m_size.z;
+		}
+		while ( z >= this->m_size.z - 1 ) {
+			++location.z;
+			z -= this->m_size.z - 1;
+		}
+	*/
+		uf::Object* region = terrain.at( location );
+		if ( !region ) {
+		//	std::cout << "Out of bounds Region("<< location.x << ", " << location.y << ", " << location.z <<") @ setLight( " << x << ", " << y << ", " << z << " ) " << std::endl;
+			return;
+		}
+		region->getComponent<ext::TerrainGenerator>().setLight( x, y, z, light, update );
+		return;
+	}
+
+	// set modified
+	if ( this->m_terrain ) {
+		const ext::Terrain& terrain = *((const ext::Terrain*)this->m_terrain);
+		uf::Object* region = terrain.at( this->m_location );
+		if ( region ) region->getComponent<uf::Serializer>()["region"]["modified"] = true;
+	}
+
+	std::size_t i = this->wrapPosition(x, y, z, this->m_voxels.lighting.swizzle);
+//	std::cout << "Set Voxel( " << x << ", " << y << ", " << z << ") ("<< i <<") to level " << light << std::endl;
+	this->m_voxels.lighting.raw[i] = light;
+	this->wrapLight();
+}
+void ext::TerrainGenerator::setLight( const pod::Vector3i& location, const ext::TerrainVoxel::light_t& light, bool update ){
+	return this->setLight( location.x, location.y, location.z, light, update );
+}
+
+void ext::TerrainGenerator::light( int x, int y, int z, const ext::TerrainVoxel::light_t& targetLight ){
+	// reset any existing lighting data
+/*
+	for ( uint i = 0; i < this->m_size.x * this->m_size.y * this->m_size.z; ++i ) {
+		auto v = this->unwrapIndex( i, this->m_voxels.id.swizzle );
+		this->setLight(v.x, v.y, v.z, 0x90FF );
+	}
+	this->writeToFile();
+	return;
+*/
+
+	this->setLight( x,  y,  z, targetLight );
+
+	int lightingMode = 2;
+	// REDGREEENBLUE
+	if ( lightingMode == 1 ) {
+		uint8_t steps = 1;
+		struct bfsNode {
+			pod::Vector3i position;
+			uf::Object* region;
+		};
+		std::queue<bfsNode> bfs;
+		const ext::Terrain& terrain = *((const ext::Terrain*)this->m_terrain);
+
+		{
+			bfsNode root;
+			root.position = pod::Vector3i{x, y, z},
+			root.region = terrain.at( this->m_location );
+			bfs.emplace(root);
+		}
+
+		size_t i = 0;
+		while ( !bfs.empty() ) {
+			bfsNode node = bfs.front(); bfs.pop();
+		//	std::cout << "Calls: " << (++i) << " | Nodes: " << bfs.size() << std::endl; 
+			if ( !node.region ) continue;
+			auto& self = node.region->getComponent<ext::TerrainGenerator>();
+			ext::TerrainVoxel voxel = ext::TerrainVoxel::atlas( self.getVoxel( node.position ) );
+		//	ext::TerrainVoxel::light_t light = (self.getLight( node.position ) >> 12) & 0xF;
+			struct LIGHT {
+				ext::TerrainVoxel::light_t r, g, b;
+			} light;
+			light.r = (self.getLight( node.position ) >> 12) & 0xF;
+			light.g = (self.getLight( node.position ) >>  8) & 0xF;
+			light.b = (self.getLight( node.position ) >>  4) & 0xF;
+
+			std::vector<pod::Vector3i> positions = {
+				node.position + pod::Vector3i{-1, 0, 0 },
+				node.position + pod::Vector3i{ 1, 0, 0 },
+				node.position + pod::Vector3i{ 0,-1, 0 },
+				node.position + pod::Vector3i{ 0, 1, 0 },
+				node.position + pod::Vector3i{ 0, 0,-1 },
+				node.position + pod::Vector3i{ 0, 0, 1 },
+			};
+			
+			for ( auto& position : positions ) {
+				{
+					pod::Vector3i location = self.m_location;
+					if ( position.x < 0 ) {
+						position.x += self.m_size.x;
+						--location.x;
+					} else if ( position.x >= self.m_size.x ) {
+						position.x -= self.m_size.x;
+						++location.x;
+					}
+					if ( position.y < 0 ) {
+						position.y += self.m_size.y;
+						--location.y;
+					} else if ( position.y >= self.m_size.y ) {
+						position.y -= self.m_size.y;
+						++location.y;
+					}
+					if ( position.z < 0 ) {
+						position.z += self.m_size.z;
+						--location.z;
+					} else if ( position.z >= self.m_size.z ) {
+						position.z -= self.m_size.z;
+						++location.z;
+					}
+					node.region = terrain.at( location );
+				}
+				if ( !node.region ) continue;
+				auto& selfGenerator = node.region->getComponent<ext::TerrainGenerator>();
+				
+				struct {
+					ext::TerrainVoxel voxel;
+					ext::TerrainVoxel::light_t light;
+				} neighbor;
+
+				neighbor.voxel = ext::TerrainVoxel::atlas( selfGenerator.getVoxel( position ) );
+				neighbor.light = selfGenerator.getLight( position );
+				
+			//	ext::TerrainVoxel::light_t targetLight = (neighbor.light >> 12) & 0xF;
+				LIGHT targetLight;
+				targetLight.r = (neighbor.light >> 12) & 0xF;
+				targetLight.g = (neighbor.light >>  8) & 0xF;
+				targetLight.b = (neighbor.light >>  4) & 0xF;
+
+				if ( neighbor.voxel.opaque() ) continue;
+				bool spread = false;
+				if ( targetLight.r + (2 * steps) <= light.r ) {
+					selfGenerator.setLight( position, neighbor.light = (neighbor.light & 0x0FFF ) | ((light.r - (1 * steps)) << 12), false );
+					spread = true;
+				}
+				if ( targetLight.g + (2 * steps) <= light.g ) {
+					selfGenerator.setLight( position, neighbor.light = (neighbor.light & 0xF0FF ) | ((light.g - (1 * steps)) <<  8), false );
+					spread = true;
+				}
+				if ( targetLight.b + (2 * steps) <= light.b ) {
+					selfGenerator.setLight( position, neighbor.light = (neighbor.light & 0xFF0F ) | ((light.b - (1 * steps)) <<  4), false );
+					spread = true;
+				}
+				if ( spread ) {
+					node.position = position;
+					bfs.emplace( node );
+				}
+			}
+		}
+	}
+	// REDGREENBLUE
+	if ( lightingMode == 2 ) {
+		uint8_t steps = 1;
+	//	std::queue<pod::Vector3i> bfs;
+		std::queue<int32_t> bfs;
+		bfs.emplace( this->wrapPosition( x, y, z ) );
+
+		while ( !bfs.empty() ) {
+		//	pod::Vector3i node = bfs.front(); bfs.pop();
+			int32_t index = bfs.front(); bfs.pop();
+			pod::Vector3i node = this->unwrapIndex( index );
+			ext::TerrainVoxel voxel = ext::TerrainVoxel::atlas( this->getVoxel( node ) );
+			struct LIGHT {
+				ext::TerrainVoxel::light_t r, g, b;
+			} light;
+			light.r = (this->getLight( node ) >> 12) & 0xF;
+			light.g = (this->getLight( node ) >>  8) & 0xF;
+			light.b = (this->getLight( node ) >>  4) & 0xF;
+
+			std::vector<int32_t> positions = {
+				this->wrapPosition(node + pod::Vector3i{-1, 0, 0 }),
+				this->wrapPosition(node + pod::Vector3i{ 1, 0, 0 }),
+				this->wrapPosition(node + pod::Vector3i{ 0,-1, 0 }),
+				this->wrapPosition(node + pod::Vector3i{ 0, 1, 0 }),
+				this->wrapPosition(node + pod::Vector3i{ 0, 0,-1 }),
+				this->wrapPosition(node + pod::Vector3i{ 0, 0, 1 }),
+			};
+			for ( auto& index : positions ) {
+				struct {
+					ext::TerrainVoxel voxel;
+					ext::TerrainVoxel::light_t light;
+				} neighbor;
+				auto position = this->unwrapIndex( index );
+				neighbor.voxel = ext::TerrainVoxel::atlas( this->getVoxel( position ) );
+				neighbor.light = this->getLight( position );
+				
+			//	ext::TerrainVoxel::light_t targetLight = (neighbor.light >> 12) & 0xF;
+				LIGHT targetLight;
+				 targetLight.r = (neighbor.light >> 12) & 0xF;
+				 targetLight.g = (neighbor.light >>  8) & 0xF;
+				 targetLight.b = (neighbor.light >>  4) & 0xF;
+
+				if ( neighbor.voxel.opaque() ) continue;
+				bool spread = false;
+				if ( targetLight.r + (2 * steps) <= light.r ) {
+					this->setLight( position, neighbor.light = (neighbor.light & 0x0FFF ) | ((light.r - (1 * steps)) << 12), false );
+					spread = true;
+				}
+				if ( targetLight.g + (2 * steps) <= light.g ) {
+					this->setLight( position, neighbor.light = (neighbor.light & 0xF0FF ) | ((light.g - (1 * steps)) <<  8), false );
+					spread = true;
+				}
+				if ( targetLight.b + (2 * steps) <= light.b ) {
+					this->setLight( position, neighbor.light = (neighbor.light & 0xFF0F ) | ((light.b - (1 * steps)) <<  4), false );
+					spread = true;
+				}
+				if ( spread ) bfs.emplace( this->wrapPosition(position) );
+			}
+		}
+	}
+	// RED
+	if ( lightingMode == 3 ) {
+		uint8_t steps = 1;
+		std::queue<pod::Vector3i> bfs;
+		bfs.emplace( pod::Vector3i{x, y, z});
+
+		while ( !bfs.empty() ) {
+			pod::Vector3i node = bfs.front(); bfs.pop();
+			ext::TerrainVoxel voxel = ext::TerrainVoxel::atlas( this->getVoxel( node ) );
+			ext::TerrainVoxel::light_t light = (this->getLight( node ) >> 12) & 0xF;
+
+			std::vector<pod::Vector3i> positions = {
+				node + pod::Vector3i{-1, 0, 0 },
+				node + pod::Vector3i{ 1, 0, 0 },
+				node + pod::Vector3i{ 0,-1, 0 },
+				node + pod::Vector3i{ 0, 1, 0 },
+				node + pod::Vector3i{ 0, 0,-1 },
+				node + pod::Vector3i{ 0, 0, 1 },
+			};
+			
+			for ( auto& position : positions ) {
+				struct {
+					ext::TerrainVoxel voxel;
+					ext::TerrainVoxel::light_t light;
+				} neighbor;
+				neighbor.voxel = ext::TerrainVoxel::atlas( this->getVoxel( position ) );
+				neighbor.light = this->getLight( position );
+				
+				ext::TerrainVoxel::light_t targetLight = (neighbor.light >> 12) & 0xF;
+
+				if ( neighbor.voxel.opaque() ) continue;
+				if ( targetLight + (2 * steps) <= light ) {
+					this->setLight( position, (neighbor.light & 0x0FFF ) | ((light - (1 * steps)) << 12), false );
+					bfs.emplace( position );
+				}
+			}
+		}
+	}
+	// GREEN
+	if ( lightingMode == 3 ) {
+		uint8_t steps = 1;
+		std::queue<pod::Vector3i> bfs;
+		bfs.emplace( pod::Vector3i{x, y, z});
+
+		while ( !bfs.empty() ) {
+			pod::Vector3i node = bfs.front(); bfs.pop();
+			ext::TerrainVoxel voxel = ext::TerrainVoxel::atlas( this->getVoxel( node ) );
+			ext::TerrainVoxel::light_t light = (this->getLight( node ) >> 8) & 0xF;
+
+			std::vector<pod::Vector3i> positions = {
+				node + pod::Vector3i{-1, 0, 0 },
+				node + pod::Vector3i{ 1, 0, 0 },
+				node + pod::Vector3i{ 0,-1, 0 },
+				node + pod::Vector3i{ 0, 1, 0 },
+				node + pod::Vector3i{ 0, 0,-1 },
+				node + pod::Vector3i{ 0, 0, 1 },
+			};
+			
+			for ( auto& position : positions ) {
+				struct {
+					ext::TerrainVoxel voxel;
+					ext::TerrainVoxel::light_t light;
+				} neighbor;
+				neighbor.voxel = ext::TerrainVoxel::atlas( this->getVoxel( position ) );
+				neighbor.light = this->getLight( position );
+				
+				ext::TerrainVoxel::light_t targetLight = (neighbor.light >> 8) & 0xF;
+
+				if ( neighbor.voxel.opaque() ) continue;
+				if ( targetLight + (2 * steps) <= light ) {
+					this->setLight( position, (neighbor.light & 0xF0FF ) | ((light - (1 * steps)) << 8), false );
+					bfs.emplace( position );
+				}
+			}
+		}
+	}
+	// BLUE
+	if ( lightingMode == 3 ) {
+		uint8_t steps = 1;
+		std::queue<pod::Vector3i> bfs;
+		bfs.emplace( pod::Vector3i{x, y, z});
+
+		while ( !bfs.empty() ) {
+			pod::Vector3i node = bfs.front(); bfs.pop();
+			ext::TerrainVoxel voxel = ext::TerrainVoxel::atlas( this->getVoxel( node ) );
+			ext::TerrainVoxel::light_t light = (this->getLight( node ) >> 4) & 0xF;
+
+			std::vector<pod::Vector3i> positions = {
+				node + pod::Vector3i{-1, 0, 0 },
+				node + pod::Vector3i{ 1, 0, 0 },
+				node + pod::Vector3i{ 0,-1, 0 },
+				node + pod::Vector3i{ 0, 1, 0 },
+				node + pod::Vector3i{ 0, 0,-1 },
+				node + pod::Vector3i{ 0, 0, 1 },
+			};
+			
+			for ( auto& position : positions ) {
+				struct {
+					ext::TerrainVoxel voxel;
+					ext::TerrainVoxel::light_t light;
+				} neighbor;
+				neighbor.voxel = ext::TerrainVoxel::atlas( this->getVoxel( position ) );
+				neighbor.light = this->getLight( position );
+				
+				ext::TerrainVoxel::light_t targetLight = (neighbor.light >> 4) & 0xF;
+
+				if ( neighbor.voxel.opaque() ) continue;
+				if ( targetLight + (2 * steps) <= light ) {
+					this->setLight( position, (neighbor.light & 0xFF0F ) | ((light - (1 * steps)) << 4), false );
+					bfs.emplace( position );
+				}
+			}
+		}
+	}
+
+//	this->writeToFile();
+}
+void ext::TerrainGenerator::light( const pod::Vector3i& location, const ext::TerrainVoxel::light_t& targetLight ){
+	return this->light( location.x, location.y, location.z, targetLight );
+}
+void ext::TerrainGenerator::updateLight(){
+//	this->unwrapLight();
+	// set lights to original values
+	std::size_t i = 0;
+/*
+	std::cout << "Updating lights for " << this->m_location.x << ", " << this->m_location.y << ", " << this->m_location.z << std::endl;
+	for ( auto& _ : this->m_voxels.id.rle ) {
+		for ( std::size_t __ = 0; __ < _.length; ++__ ) {
+			ext::TerrainVoxel voxel = ext::TerrainVoxel::atlas( _.value );
+			auto v = this->unwrapIndex( i++, this->m_voxels.id.swizzle );
+			// this->setLight(v.x, v.y, v.z, voxel.light() );
+			this->m_voxels.lighting.raw[i] = AMBIENT_LIGHT;
+		}
+	}
+	//this->wrapLight();
+	// set lights
+*/
+	// std::size_t i = 0;
+	for ( auto& _ : this->m_voxels.id.rle ) {
+		for ( std::size_t __ = 0; __ < _.length; ++__ ) {
+			ext::TerrainVoxel voxel = ext::TerrainVoxel::atlas( _.value );
+			auto v = this->unwrapIndex( i++, this->m_voxels.id.swizzle );
+			if ( voxel.light() == 0x0000 ) continue;
+			this->light(v.x, v.y, v.z, voxel.light() );
+		}
+	}
+//	this->wrapLight();
+//	this->writeToFile();
+}
+void ext::TerrainGenerator::rasterize( std::vector<ext::TerrainGenerator::mesh_t::vertex_t>& vertices, const uf::Object& region, bool applyTransform ){
+	if ( this->m_voxels.id.rle.empty() ) return;
+
+	this->writeToFile();
+				
+	struct { struct { float x, y, z; } position; struct { float u, v, x, y; } uv; } offset;
+
+	const ext::Terrain& terrain = region.getParent<ext::Terrain>();
+	const pod::Transform<>& transform = region.getComponent<pod::Transform<>>();
+	const pod::Vector3i location = {
+		transform.position.x / (this->m_size.x / m_subdivisions),
+		transform.position.y / (this->m_size.y / m_subdivisions),
+		transform.position.z / (this->m_size.z / m_subdivisions),
+	};
+
+	struct { 
+		uf::Object* right = NULL;
+		uf::Object* left = NULL;
+		uf::Object* top = NULL;
+		uf::Object* bottom = NULL;
+		uf::Object* front = NULL;
+		uf::Object* back = NULL;
+	} regions;
+
+	regions.right = terrain.at( { location.x + 1, location.y, location.z } );
+	regions.left = terrain.at( { location.x - 1, location.y, location.z } );
+	regions.top = terrain.at( { location.x, location.y + 1, location.z } );
+	regions.bottom = terrain.at( { location.x, location.y - 1, location.z } );
+	regions.front = terrain.at( { location.x, location.y, location.z + 1 } );
+	regions.back = terrain.at( { location.x, location.y, location.z - 1 } );
+
+	ext::TerrainVoxel::light_t ambientLight = AMBIENT_LIGHT; {
+	//	const uf::Serializer& tMetadata = region.getComponent<uf::Serializer>();
+		uf::Serializer tMetadata = region.getComponent<uf::Serializer>();
+		COLOR color = uint16ToColor( ambientLight );
+		color.r *= tMetadata["region"]["light"]["ambient"][0].as<float>();
+		color.g *= tMetadata["region"]["light"]["ambient"][1].as<float>();
+		color.b *= tMetadata["region"]["light"]["ambient"][2].as<float>();
+		ambientLight = colorToUint16( color );
+	}
+	pod::Matrix4f modelMatrix = uf::transform::model( transform );
+	#define TERRAIN_SHOULD_RENDER_FACE(SIDE)\
+		should.SIDE = !neighbor.SIDE.opaque();\
+		if ( should.SIDE ) {\
+			for ( uint i = 0; i < model.position.SIDE.size() / 3; ++i ) {\
+				ext::TerrainGenerator::mesh_t::vertex_t vertex;\
+				{\
+					pod::Vector3f& p = vertex.position;\
+					p.x = model.position.SIDE[i*3+0]; p.y = model.position.SIDE[i*3+1]; p.z = model.position.SIDE[i*3+2];\
+					p /= m_subdivisions;\
+					p.x += offset.position.x; p.y += offset.position.y; p.z += offset.position.z;\
+				}\
+				{\
+					pod::Vector2f& p = vertex.uv;\
+					p.x = model.uv.SIDE[i*2+0]; p.y = model.uv.SIDE[i*2+1];\
+					p.x *= offset.uv.x; p.y *= offset.uv.y;\
+					p.x += offset.uv.u; p.y += offset.uv.v;\
+				}\
+				{\
+					pod::Vector3f& p = vertex.normal;\
+					p.x = model.normal.SIDE[i*3+0]; p.y = model.normal.SIDE[i*3+1]; p.z = model.normal.SIDE[i*3+2];\
+				}\
+				{\
+					pod::Vector4t<uint8_t>& p = vertex.color;\
+					ext::TerrainVoxel::light_t l = light.SIDE;\
+					p[0] = (l >> 12) & 0xF;\
+					p[1] = (l >>  8) & 0xF;\
+					p[2] = (l >>  4) & 0xF;\
+					p[3] = (l      ) & 0xF;\
+					p[0] = (p[0] << 4) | p[0];\
+					p[1] = (p[1] << 4) | p[1];\
+					p[2] = (p[2] << 4) | p[2];\
+					p[3] = (p[3] << 4) | p[3];\
+				}\
+				if ( applyTransform ) {\
+					pod::Vector3f& p = vertex.position;\
+					p += transform.position; /*p = uf::matrix::multiply<float>( modelMatrix, p );*/\
+				}\
+				vertices.push_back(vertex);\
+			}\
+		}
+
+	std::size_t i = 0;
+	for ( auto& _ : this->m_voxels.id.rle ) {
+		for ( std::size_t __ = 0; __ < _.length; ++__ ) {
+			{
+				int x = 0, y = 0, z = 0;
+				{
+					auto v = this->unwrapIndex( i++, this->m_voxels.id.swizzle );
+					x = v.x;
+					y = v.y;
+					z = v.z;
+				}
+
+				ext::TerrainVoxel voxel = ext::TerrainVoxel::atlas( _.value );
+
+
+				const ext::TerrainVoxel::Model& model = voxel.model();
+
+				// clear block, don't render
+				if ( !voxel.opaque() ) continue;
+
+				offset.position.x = (x / (float) m_subdivisions) + transform.position.x - (this->m_size.x / (m_subdivisions * 2.0f));
+				offset.position.y = (y / (float) m_subdivisions) + transform.position.y - (this->m_size.y / (m_subdivisions * 2.0f));
+				offset.position.z = (z / (float) m_subdivisions) + transform.position.z - (this->m_size.z / (m_subdivisions * 2.0f));
+			
+				offset.uv.x = 1.0f / ext::TerrainVoxel::size().x;
+				offset.uv.y = 1.0f / ext::TerrainVoxel::size().y;
+
+				offset.uv.u = voxel.uv().x * offset.uv.x;
+				offset.uv.v = (ext::TerrainVoxel::size().y - 1 - voxel.uv().y) * offset.uv.y;
+
+				struct {
+					bool top = true, bottom = true, left = true, right = true, front = true, back = true;
+				} should;
+				struct {
+					ext::TerrainVoxel top = ext::TerrainVoxel::atlas(0), bottom = ext::TerrainVoxel::atlas(0), left = ext::TerrainVoxel::atlas(0), right = ext::TerrainVoxel::atlas(0), front = ext::TerrainVoxel::atlas(0), back = ext::TerrainVoxel::atlas(0);
+				} neighbor;
+				struct {
+					ext::TerrainVoxel::light_t top = 0xffff, bottom = 0xfff, left = 0xffff, right = 0xffff, front = 0xffff, back = 0xffff;
+				} light;
+			
+				neighbor.left = ext::TerrainVoxel::atlas(this->getVoxel(x-1,y,z));
+				light.left = this->getLight(x-1,y,z);
+
+				neighbor.bottom = ext::TerrainVoxel::atlas(this->getVoxel(x,y-1,z));
+				light.bottom = this->getLight(x,y-1,z);
+
+				neighbor.back = ext::TerrainVoxel::atlas(this->getVoxel(x,y,z-1));
+				light.back = this->getLight(x,y,z-1);
+
+				neighbor.right = ext::TerrainVoxel::atlas(this->getVoxel(x+1,y,z));
+				light.right = this->getLight(x+1,y,z);
+
+				neighbor.top = ext::TerrainVoxel::atlas(this->getVoxel(x,y+1,z));
+				light.top = this->getLight(x,y+1,z);
+
+				neighbor.front = ext::TerrainVoxel::atlas(this->getVoxel(x,y,z+1));
+				light.front = this->getLight(x,y,z+1);
+
+				TERRAIN_SHOULD_RENDER_FACE(right)
+				TERRAIN_SHOULD_RENDER_FACE(left)
+				TERRAIN_SHOULD_RENDER_FACE(top)
+				TERRAIN_SHOULD_RENDER_FACE(bottom)
+				TERRAIN_SHOULD_RENDER_FACE(front)
+				TERRAIN_SHOULD_RENDER_FACE(back)
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/ext/scenes/worldscape/terrain/generator.h b/ext/scenes/worldscape/terrain/generator.h
new file mode 100644
index 00000000..9f427dc4
--- /dev/null
+++ b/ext/scenes/worldscape/terrain/generator.h
@@ -0,0 +1,85 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/ext/ext.h>
+
+#include <uf/utils/math/vector.h>
+
+#include "voxel.h"
+#include "region.h"
+#include "terrain.h"
+
+#include <uf/utils/noise/noise.h>
+
+#include <uf/utils/graphic/mesh.h>
+
+#include <uf/utils/string/rle.h>
+
+namespace ext {
+	class EXT_API TerrainGenerator {
+	protected:
+		enum Swizzle {
+			XYZ, YZX, ZXY
+		};
+		struct {
+			struct {
+				std::vector<ext::TerrainVoxel::uid_t> raw;
+				pod::RLE<ext::TerrainVoxel::uid_t>::string_t rle;
+		 		Swizzle swizzle = Swizzle::YZX;
+			} id;
+			struct {
+				std::vector<ext::TerrainVoxel::light_t> raw;
+				pod::RLE<ext::TerrainVoxel::light_t>::string_t rle;
+		 		Swizzle swizzle = Swizzle::YZX;
+			} lighting;
+		} m_voxels;
+
+		pod::Vector3ui m_size;
+		pod::Vector3i m_location;
+		uint m_modulus;
+		uint m_subdivisions;
+		uf::Entity* m_terrain;
+	public:
+		typedef uf::ColoredMesh mesh_t;
+		static uf::PerlinNoise noise;
+		static Swizzle DEFAULT_SWIZZLE;
+
+		void initialize( const pod::Vector3ui& = { 8, 8, 8 }, uint = 1 );
+		void destroy();
+
+		void light( int, int, int, const ext::TerrainVoxel::light_t& light );
+		void light( const pod::Vector3i&, const ext::TerrainVoxel::light_t& light );
+
+		void writeToFile();
+		void updateLight();
+
+		void generate( uf::Object& );
+		void rasterize( std::vector<TerrainGenerator::mesh_t::vertex_t>& vertices, const uf::Object&, bool = false );
+	//	void vectorize( std::vector<uf::renderer::ComputeGraphic::Cube>&, const uf::Object& );
+		
+		std::vector<ext::TerrainVoxel::uid_t> getRawVoxels();
+		const pod::RLE<ext::TerrainVoxel::uid_t>::string_t& getVoxels() const;
+
+		pod::Vector3i unwrapIndex( int64_t, Swizzle = DEFAULT_SWIZZLE ) const;
+		int64_t wrapPosition( int64_t, int64_t, int64_t, Swizzle = DEFAULT_SWIZZLE ) const;
+		int64_t wrapPosition( const pod::Vector3i&, Swizzle = DEFAULT_SWIZZLE ) const;
+
+		void unwrapVoxel();
+		void unwrapLight();
+
+		void wrapVoxel();
+		void wrapLight();
+
+		ext::TerrainVoxel::uid_t getVoxel( int x, int y, int z ) const;
+		ext::TerrainVoxel::uid_t getVoxel( const pod::Vector3i& ) const;
+
+		ext::TerrainVoxel::light_t getLight( int x, int y, int z ) const;
+		ext::TerrainVoxel::light_t getLight( const pod::Vector3i& ) const;
+
+		void setVoxel( int x, int y, int z, const ext::TerrainVoxel::uid_t&, bool = true );
+		void setVoxel( const pod::Vector3i&, const ext::TerrainVoxel::uid_t&, bool = true );
+
+		void setLight( int x, int y, int z, const ext::TerrainVoxel::light_t&, bool = true );
+		void setLight( const pod::Vector3i&, const ext::TerrainVoxel::light_t&, bool = true );
+	};
+}
\ No newline at end of file
diff --git a/ext/scenes/worldscape/terrain/maze.cpp b/ext/scenes/worldscape/terrain/maze.cpp
new file mode 100644
index 00000000..ae9b71c5
--- /dev/null
+++ b/ext/scenes/worldscape/terrain/maze.cpp
@@ -0,0 +1,438 @@
+#include <uf/config.h>
+
+#include "Maze.h"
+#include <iostream>
+#include <vector>
+#include <set>
+#include <tuple>
+#include <map>
+#include <random>
+#include <time.h>
+#include <numeric>
+
+void ext::Maze::initialize(int columns, int rows, int floors, double horizontal_bias, double vertical_bias) {
+    /* The Maze class contructor
+     *       Input:
+     *           int columns - Set the number of columns in the maze. Correspond to the X axis (length).
+     *           int rows    - Set the number of rows in the maze.    Correspond to the Y axis (width).
+     *           int floors  - Set the number of floors in the maze.  Correspond to the Z axis (height).
+     *
+     *                          All three must be larger than 1.
+     *
+     *           double horizontal_bias - Sets the likelihood of a passage between rooms on the same row.
+     *           double vertical_bias   - Sets the likelihood of a passage between rooms in the same column.
+     *
+     *                       Both must be between 0 and 1 exclusive.
+     *                       Higher number gives higher likelihood of a passage.
+     *
+     *       Output:
+     *           Maze object
+     */
+    if (rows < 1 || columns < 1 || floors < 1){
+        UF_EXCEPTION("A maze must have dimensions greater than zero.\n");
+        return;
+    }
+    LENGTH = columns;
+    WIDTH  = rows;
+    HEIGHT = floors;
+
+    if (horizontal_bias <= 0 || horizontal_bias >= 1 || vertical_bias <= 0 || vertical_bias >= 1){
+        UF_EXCEPTION("Biases must be between 0 and 1 exclusive.\n");
+        return;
+    }
+    EAST_WALL_THRESHOLD = horizontal_bias;
+    SOUTH_WALL_THRESHOLD = vertical_bias;
+
+    //Creating a vector of all rooms.
+    cells.assign(LENGTH*WIDTH*HEIGHT, -1);
+
+    // seed
+    seed = time(NULL);
+
+    // Give each room a different set number (ascending).
+    // (Which is used during maze generation)
+    std::iota(std::begin(cells), std::end(cells), 0);
+};
+
+int ext::Maze::get(int i, int col, int floor){
+    // Gets the value stored at row i, column j, level k, in cells;
+    return cells.at(col + LENGTH*i + LENGTH*WIDTH*floor);
+}
+
+void ext::Maze::set(int row, int col, int floor, int val){
+    // Set the value of cell at (row, col, floor) to val
+    cells[col + LENGTH*row + LENGTH*WIDTH*floor] = val;
+    return;
+}
+
+void ext::Maze::build(){
+    /*      This function generates a maze.
+     *
+     *      It uses sets to keep track of areas created by removing walls.
+     *      Initially each room has it's own set, known by it's room value.
+     *      The room sets grows as walls are removed and sets joined.
+     *      To keep track, each room value is mapped to itself, or the room value it has joined.
+     *      The mapping and sets are reset at each floor.
+     *
+     *      Summary:
+     *      It goes through each cell, removing the walls randomly.
+     *      (First WEST to EAST, then NORTH to SOUTH, then DOWN to UP.
+     *          Just as one write in English, putting each new page on top of the other)
+     *      If a wall is between two rooms in the same set, it is not removed.
+     *
+     *      Each room value denote which set it belongs to
+     *
+     *      Each wall removed is stored in as a passage between the two rooms.
+     *          (The rooms position is stored in ext::Maze::passages)
+     *
+     *          If the current room value is not mapped, then map it to itself.
+     *          Set current room value to it's mapped value.
+     *
+     *          Add the room to the set given by room value
+     *
+     *          If a EASTERN wall is removed, then:
+     *              - The set of the connected room is added to the set of this room.
+     *              - The set of the connected room is deleted.
+     *              - Map the connected room value to the current room value.
+     *              - Change the connected room value to the current room value.
+     *              - Add connected room to set.
+     *
+     *          If a SOUTHERN wall is removed, then:
+     *              - Change the connected room value to the current room value.
+     *              - Add the connected room to set.
+     *
+     *      After all the rooms of the current floor has been visited:
+     *          - Go through each set, pick a random room, and make a passage up.
+     *          - Clear the sets, and mapping.
+     *
+     *      On the last floor, each set on each row must have a passage south.
+     *
+     *      On the last row on the last floor, passages between unconnected sets are removed.
+     *
+     *      Finally each room value is set according to which walls remain. (Including floor and ceiling)
+     */
+
+
+    // The room sets
+    std::map<std::size_t, std::vector<pos>> room_set;
+
+    // The mapping of connected rooms
+    std::map<int, int> merged_room_sets;
+
+
+    int room_value;
+    int east_room_value;
+    int south_room_value;
+
+    // To get different mazes each time
+    srand(seed);
+
+    for (int floor = 0; floor < HEIGHT - 1; floor++){ // Go through each floor but the last.
+
+        for (int row = 0; row < WIDTH; row++){ // Go through each row
+
+            for(int col = 0; col < LENGTH; col++){ // Go through each element in row (Each column)
+
+                room_value = get(row, col, floor);
+
+                // If this room value is mapped to another, get that value: else map value to itself
+                if(merged_room_sets.find(room_value) != merged_room_sets.end()){
+                    room_value = merged_room_sets[room_value];
+                } else {
+                    merged_room_sets[room_value] = room_value;
+                }
+
+                // If not the last cell in row, store eastern room value
+                if (col<LENGTH-1){
+                                       //Is the eastern room value mapped?
+                    east_room_value = (merged_room_sets.find(get(row, col+1, floor))!=merged_room_sets.end()) ?
+                                            // Yes: Use mapped value
+                                                merged_room_sets[get(row, col+1, floor)] :
+                                            // No: Use stored value
+                                                get(row, col+1, floor);
+                }
+
+                // If not the last row, store southern room value
+                if (row < WIDTH-1){
+                                        //Is the southern room value mapped?
+                    south_room_value = (merged_room_sets.find(get(row + 1, col, floor))!=merged_room_sets.end()) ?
+
+                                            // Yes: Use mapped value
+                                                merged_room_sets[get(row + 1, col, floor)] :
+
+                                            // No:  Use stored value
+                                                get(row + 1, col, floor);
+                }
+
+                // Add this room to the set of room value
+                room_set[room_value].push_back(std::make_tuple(row, col, floor));
+
+                //If last room in row, skip (don't remove eastern boundary wall)
+                if(col == LENGTH - 1){}
+
+                // If this and eastern room not in same set, maybe remove wall
+                else if((rand() < EAST_WALL_THRESHOLD * RAND_MAX) && (room_value != east_room_value)){
+                    //      EASTERN WALL REMOVED
+
+                    // Get set of eastern room
+                    std::vector<pos> next_room_position_set = room_set[get(row, col+1, floor)];
+
+                    // Add set of eastern room to this set.
+                    room_set[room_value].insert(room_set[room_value].end(), next_room_position_set.begin(), next_room_position_set.end() );
+
+                    // Remove eastern room set
+                    room_set.erase(get(row, col+1, floor));
+
+                    // Map eastern room value to this room value.
+                    merged_room_sets[get(row,col+1,floor)] = room_value;
+
+                    // Set eastern room value to this
+                    set(row, col+1, floor, room_value);
+
+                    // Add the new horizontal passage created.
+                    passages.push_back(std::make_tuple(row, col, floor, row, col+1, floor));
+
+                }   // Else the eastern wall remain
+
+                // Don't remove southern boundary wall.
+                if(row == WIDTH - 1){}
+
+                // If current and southern room is not in same set, then maybe remove wall
+                else if(rand() < SOUTH_WALL_THRESHOLD * RAND_MAX && room_value != south_room_value){
+
+                    // Set southern room value to this one
+                    set(row+1, col, floor, room_value);
+
+                    // Add the newly created vertical passage.
+                    passages.push_back(std::make_tuple(row, col, floor, row+1, col, floor));
+                }   //Else wall down remain
+
+            } // All rooms in this row has been visited
+
+        } // All rows on this floor has been visited
+
+        // Clear room set mapping
+        merged_room_sets.clear();
+
+        // Go through all sets this floor
+        for(auto entry : room_set)
+        {
+            auto group = entry.second;
+            int x, y, z;
+
+            // Picking out a random room in each group
+            // Room position saved in matrix notation (i, j, k = y, x, z)
+            std::tie(y, x, z) = group.at(rand() % group.size());
+
+            // Only one passage up for each group. To avoid graph cycles
+            passages.push_back(std::make_tuple(y, x, z, y, x, z+1));
+        }
+        // Passages up have been set. Clearing room groups for next floor.
+        room_set.clear();
+
+    }// Finished with all but last floor
+
+
+    int floor = HEIGHT - 1;
+
+    std::set<int> can_go_south;
+
+    //deal with last floor, but leave the last row
+    for(int row = 0; row < WIDTH - 1; row++){
+
+        for(int col = 0; col<LENGTH; col++){
+            room_value = get(row, col, floor);
+
+            // If this room value is mapped to another, get that value: else map value to itself
+            if(merged_room_sets.find(room_value) != merged_room_sets.end()){
+                    room_value = merged_room_sets[room_value];
+            } else {
+                    merged_room_sets[room_value] = room_value;
+            }
+
+            // If not the last cell in row, get eastern room value
+            if (col<LENGTH-1){
+                    east_room_value = (merged_room_sets.find(get(row, col+1, floor)) != merged_room_sets.end()) ?
+                                       merged_room_sets[get(row, col+1, floor)] : get(row, col+1, floor);
+            }
+            // Get southern room value
+            south_room_value = (merged_room_sets.find(get(row + 1, col, floor)) != merged_room_sets.end()) ?
+                                merged_room_sets[get(row + 1, col, floor)] : get(row + 1, col, floor);
+
+            // Try and make passage east
+            if(col == LENGTH -1){}
+            else if((rand() < EAST_WALL_THRESHOLD * RAND_MAX) && (room_value != east_room_value)){
+
+                passages.push_back(std::make_tuple(row, col, floor, row, col+1, floor));
+                merged_room_sets[east_room_value] = room_value;
+                set(row, col+1, floor, room_value);
+            }
+
+            // Try and make passage south
+            if( (      (rand() < SOUTH_WALL_THRESHOLD * RAND_MAX)
+                    || (can_go_south.find(room_value) == can_go_south.end()) ) // Make sure all sets this row have a passage down
+                && (room_value != south_room_value))
+            {
+                passages.push_back(std::make_tuple(row, col, floor, row+1, col, floor));
+                merged_room_sets[south_room_value] = room_value;
+                set(row+1, col, floor, room_value);
+                can_go_south.insert(room_value);
+            }
+        }
+
+        can_go_south.clear();
+    }
+
+    // Go through the last row on the last floor
+    int row = WIDTH - 1;
+    for (int col = 0; col < LENGTH - 1; col++)
+    {
+        // Get room values
+        room_value = get(row, col, floor);
+
+        if(merged_room_sets.find(room_value) != merged_room_sets.end()){
+            room_value = merged_room_sets[room_value];
+        } else {
+            merged_room_sets[room_value] = room_value;
+        }
+
+        // Get eastern room value
+        east_room_value = (merged_room_sets.find(get(row, col+1, floor))!=merged_room_sets.end()) ?
+                           merged_room_sets[get(row, col+1, floor)] : get(row, col+1, floor);
+
+        // If this and eastern room is in different sets
+        if(room_value != east_room_value)
+        {
+            // Make passage and merge sets
+            passages.push_back(std::make_tuple(row, col, floor, row, col+1, floor));
+            merged_room_sets[east_room_value] = room_value;
+            set(row, col+1, floor, room_value);
+        }
+    }
+
+    // Calculate the room values based on remaining walls (and floors & ceilings)
+    ext::Maze::calculate();
+};
+
+void ext::Maze::calculate(){
+    /* This function set each room value according to the remaining walls in that room.
+     * The walls are represented as bits of a 8-bit int.
+     * Floor          = 0000 0001
+     * Eastern wall   = 0000 0010
+     * Northern wall  = 0000 0100
+     * Western wall   = 0000 1000
+     * Southern wall  = 0001 0000
+     * Ceiling        = 0010 0000
+     */
+
+    cells.clear();
+
+    // 63 = 0011 1111 = all walls, floor, and ceiling
+    cells.assign(LENGTH*WIDTH*HEIGHT, 63);
+
+    int row_from, row_to,
+        col_from, col_to,
+        lvl_from, lvl_to;
+
+    uint8_t cell_num_to;
+    uint8_t cell_num_from;
+
+    // Go through all passages
+    for(auto pass : passages){
+        std::tie(row_from, col_from, lvl_from,
+            row_to,   col_to,   lvl_to   ) = pass;
+
+        cell_num_from = get(row_from, col_from, lvl_from);
+        cell_num_to   = get(row_to,   col_to,   lvl_to);
+
+        // North to South passage
+        if(row_from != row_to){
+            set(row_from, col_from, lvl_from, cell_num_from & ~(SOUTH));
+            set(row_to,   col_to,   lvl_to,   cell_num_to   & ~(NORTH));
+
+        // West to East passage
+        } else if (col_from != col_to){
+            set(row_from, col_from, lvl_from, cell_num_from & ~(EAST));
+            set(row_to,   col_to,   lvl_to,   cell_num_to   & ~(WEST));
+
+        // Passage Up
+        } else if(lvl_from != lvl_to){
+            set(row_from, col_from, lvl_from, cell_num_from & ~(CEIL));
+            set(row_to,   col_to,   lvl_to,   cell_num_to   & ~(FLOOR));
+        }
+        // Else the passage is in several directions and in this case discarded
+    }
+}
+
+void ext::Maze::print(){
+    /*  Print the maze to std::cout
+     *
+     *  Prints floor in ascending order (top floor last)
+     *  | - represent vertical and horizontal walls respectively
+     *  + is the room corners
+     *  U D B represent stairs up, down, and both, respectively
+     *
+     *  ext::Maze::passages s used, so remember to run ext::Maze::build first.
+     */
+
+    // Maze map canvas
+    std::string map_drawing[2 * WIDTH + 1][HEIGHT];
+
+    std::string wall_row = "+";
+    std::string room_row = "|";
+
+    // Make a row of walls and rooms
+    for (int col = 0; col < LENGTH; col++){
+        wall_row.append("-+");
+        room_row.append(" |");
+    }
+    // Drawing initial map
+    for (int floor = 0; floor < HEIGHT; floor++){
+        map_drawing[2*WIDTH][floor] = wall_row;
+
+        for (int row = 0; row < WIDTH; row++){
+            map_drawing[2*row][floor] = wall_row;
+            map_drawing[2*row + 1][floor] = room_row;
+        }
+    }
+
+    // Making passages
+    for ( auto pass : passages){
+        int row_from, row_to,
+            col_from, col_to,
+            lvl_from, lvl_to;
+
+        std::tie(row_from, col_from, lvl_from,
+            row_to,   col_to,   lvl_to) = pass;
+
+        // North - South passage
+        if(row_from != row_to){
+            map_drawing[2 * row_from + 2][lvl_from].replace(2 * col_from + 1, 1, " ");
+
+        // West - East passage
+        } else if (col_from != col_to){
+            map_drawing[2*row_from + 1][lvl_from].replace(2 * col_from + 2, 1, " ");
+
+        // Up - Down passage
+        } else if (lvl_from != lvl_to){
+
+            // If this room have a passage down, you can go up and down from it
+            if (map_drawing[2 * row_from + 1][lvl_from].at(2 * col_from + 1) == 'D'){
+                map_drawing[2 * row_from + 1][lvl_from].replace(2 * col_from + 1, 1, "B");
+            } else {
+                map_drawing[2 * row_from + 1][lvl_from].replace(2 * col_from + 1, 1, "U");
+            }
+
+            // The passages should come in order, so floor above have no passages up
+            map_drawing[2 * row_to + 1][lvl_to].replace(2 * col_to + 1, 1, "D");
+        }
+    }
+
+    // Printing the maze, one row at a time.
+    for (int floor = 0; floor < HEIGHT; floor++){
+        for (int row = 0; row < 2*WIDTH+1; row++){
+            std::cout << map_drawing[row][floor] << std::endl;
+        }
+        std::cout << std::endl;
+    }
+}
\ No newline at end of file
diff --git a/ext/scenes/worldscape/terrain/maze.h b/ext/scenes/worldscape/terrain/maze.h
new file mode 100644
index 00000000..e112d066
--- /dev/null
+++ b/ext/scenes/worldscape/terrain/maze.h
@@ -0,0 +1,38 @@
+#pragma once
+#include<vector>
+#include<iostream>
+
+namespace ext {
+    class Maze {
+        protected:
+            double EAST_WALL_THRESHOLD;
+            double SOUTH_WALL_THRESHOLD;
+            std::vector< std::tuple<int, int, int, int, int, int> > passages;
+            typedef std::tuple<int, int, int> pos;
+
+            int get(int, int, int);
+            void set(int, int, int, int);
+            void calculate();
+        public:
+            int LENGTH;
+            int WIDTH;
+            int HEIGHT;
+            size_t seed;
+
+            static const uint8_t FLOOR     =  1;   // 00 00 00 01;
+            static const uint8_t EAST      =  2;   // 00 00 00 10;
+            static const uint8_t NORTH     =  4;   // 00 00 01 00;
+            static const uint8_t WEST      =  8;   // 00 00 10 00;
+            static const uint8_t SOUTH     = 16;   // 00 01 00 00;
+            static const uint8_t CEIL      = 32;   // 00 10 00 00;
+
+            std::vector<int> cells;
+
+            int& operator()(int row, int col, int floor){
+                return cells.at(col + LENGTH*row + LENGTH*WIDTH*floor);
+            }
+            void initialize(int, int, int, double, double);
+            void build();
+            void print();
+    };
+}
\ No newline at end of file
diff --git a/ext/scenes/worldscape/terrain/region.cpp b/ext/scenes/worldscape/terrain/region.cpp
new file mode 100644
index 00000000..427d011b
--- /dev/null
+++ b/ext/scenes/worldscape/terrain/region.cpp
@@ -0,0 +1,659 @@
+#include "region.h"
+
+#include "../../../ext.h"
+#include "generator.h"
+
+#include <uf/engine/asset/asset.h>
+#include <uf/utils/camera/camera.h>
+#include <uf/utils/thread/thread.h>
+#include <uf/utils/math/collision.h>
+#include <uf/utils/graphic/graphic.h>
+#include <uf/utils/graphic/mesh.h>
+#include <uf/utils/string/ext.h>
+#include <uf/utils/renderer/renderer.h>
+#include <mutex>
+
+UF_BEHAVIOR_REGISTER_CPP(ext::RegionBehavior)
+UF_BEHAVIOR_REGISTER_AS_OBJECT(ext::RegionBehavior, ext::Region)
+#define this ((uf::Object*) &self)
+void ext::RegionBehavior::initialize( uf::Object& self ) {
+	// alias Mesh types
+	{
+		auto& mutexPointer = this->getComponent<std::mutex*>();
+		mutexPointer = new std::mutex;
+	}
+
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	metadata["region"]["initialized"] = true;
+
+	if ( !metadata["terrain"]["unified"].as<bool>() ) {
+		std::string textureFilename = ""; {
+			uf::Serializer& metadata = this->getParent().getComponent<uf::Serializer>();
+			uf::Asset assetLoader;
+			for ( uint i = 0; i < metadata["system"]["assets"].size(); ++i ) {
+				if ( textureFilename != "" ) break;
+				std::string filename = this->grabURI( metadata["system"]["assets"][i].as<std::string>(), metadata["system"]["root"].as<std::string>() );
+				textureFilename = assetLoader.cache( filename );
+			}
+		}
+		ext::TerrainGenerator::mesh_t& mesh = this->getComponent<ext::TerrainGenerator::mesh_t>();
+		auto& graphic = this->getComponent<uf::Graphic>();
+
+		graphic.initialize();
+		graphic.process = false;
+
+		auto& texture = graphic.material.textures.emplace_back();
+		texture.sampler.descriptor.filter.min = uf::renderer::enums::Filter::NEAREST;
+		texture.sampler.descriptor.filter.mag = uf::renderer::enums::Filter::NEAREST;
+		texture.loadFromFile( textureFilename );
+
+		std::string suffix = ""; {
+			std::string _ = this->getRootParent<uf::Scene>().getComponent<uf::Serializer>()["shaders"]["region"]["suffix"].as<std::string>();
+			if ( _ != "" ) suffix = _ + ".";
+		}
+
+		graphic.material.initializeShaders({
+			{uf::io::root+"/shaders/terrain/vert.spv", uf::renderer::enums::Shader::VERTEX},
+			{uf::io::root+"/shaders/terrain/frag.spv", uf::renderer::enums::Shader::FRAGMENT}
+		});
+	}
+
+	this->addHook( "region:Generate.%UID%", [&](ext::json::Value& json){
+		uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+		if ( !metadata["region"]["initialized"].as<bool>() ) return;
+		if ( metadata["region"]["generated"].as<bool>() ) return;
+
+		pod::Vector3ui size; {
+			size.x = metadata["region"]["size"][0].as<size_t>();
+			size.y = metadata["region"]["size"][1].as<size_t>();
+			size.z = metadata["region"]["size"][2].as<size_t>();
+		}
+		uint subdivisions = metadata["region"]["subdivisions"].as<size_t>();
+		ext::TerrainGenerator& generator = this->getComponent<ext::TerrainGenerator>();
+		generator.initialize(size, subdivisions);
+		generator.generate(*this);
+		generator.updateLight();
+
+		/* Collider */ if ( false ) {
+			pod::Transform<>& transform = this->getComponent<pod::Transform<>>();
+			uf::Collider& collider = this->getComponent<uf::Collider>();
+		
+			std::size_t i = 0;
+			const auto& voxels = generator.getVoxels();
+			for ( auto& _ : voxels ) {
+				for ( std::size_t __ = 0; __ < _.length; ++__ ) {
+					{
+						std::size_t x = 0, y = 0, z = 0;
+						{
+							auto v = generator.unwrapIndex( i++ );
+							x = v.x;
+							y = v.y;
+							z = v.z;
+						}
+
+						ext::TerrainVoxel voxel = ext::TerrainVoxel::atlas( _.value );
+						pod::Vector3 offset = transform.position;
+						offset.x += x - (size.x / 2.0f);
+						offset.y += y - (size.y / 2.0f);
+						offset.z += z - (size.z / 2.0f);
+
+						if ( !voxel.solid() ) continue;
+
+						collider.add(new uf::BoundingBox( offset, {0.5, 0.5, 0.5} ));
+					}
+				}
+			}
+		}
+		metadata["region"]["generated"] = true;
+	});
+	this->addHook( "region:Rasterize.%UID%", [&](ext::json::Value& json){
+		ext::TerrainGenerator& generator = this->getComponent<ext::TerrainGenerator>();
+		ext::TerrainGenerator::mesh_t& mesh = this->getComponent<ext::TerrainGenerator::mesh_t>();
+		auto& graphic = this->getComponent<uf::Graphic>();
+
+		generator.rasterize(mesh.vertices, *this);
+		graphic.initializeMesh( mesh );
+
+		this->queueHook("region:Finalize.%UID%");
+		this->queueHook("region:Populate.%UID%");
+	});
+	this->addHook( "region:Finalize.%UID%", [&](ext::json::Value& json){
+		if ( this->hasComponent<uf::Graphic>() ) {
+			auto& graphic = this->getComponent<uf::Graphic>();
+			graphic.process = true;
+		}
+		metadata["region"]["rasterized"] = true;
+
+	});
+	this->addHook( "region:Populate.%UID%", [&](ext::json::Value& json){
+		if ( metadata["region"][""]["initialized"].as<bool>() ) return;
+
+		metadata["region"][""]["initialized"] = true;
+		bool first = false;
+		pod::Transform<>& transform = this->getComponent<pod::Transform<>>();
+		float r = (rand() % 100) / 100.0;
+		pod::Vector3ui size = {
+			metadata["region"]["size"][0].as<size_t>() / 4,
+			metadata["region"]["size"][1].as<size_t>() / 4,
+			metadata["region"]["size"][2].as<size_t>() / 4,
+		};
+		uint half_x = size.x / 2;
+		uint half_y = size.y / 2;
+		uint half_z = size.z / 2;
+		double noise[size.x][size.y][size.z];
+		double maxValue = 0.0;
+		double sum = 0.0;
+		{
+			for ( int z = 0; z < size.z; ++z ) {
+			for ( int y = 0; y < size.y; ++y ) {
+			for ( int x = 0; x < size.x; ++x ) {
+				pod::Vector3d position = {
+					transform.position.x - half_x, transform.position.y - half_y, transform.position.z - half_z
+				};
+				position.x += (double) x / (double) size.x;
+				position.y += (double) y / (double) size.y;
+				position.z += (double) z / (double) size.z;
+				noise[x][y][z] = ext::TerrainGenerator::noise.sample( position );
+				maxValue = std::max( maxValue, noise[x][y][z] );
+			}
+			}
+			}
+			for ( int z = 0; z < size.z; ++z ) {
+			for ( int y = 0; y < size.y; ++y ) {
+			for ( int x = 0; x < size.x; ++x ) {
+				sum += noise[x][y][z] / maxValue;
+			}
+			}
+			}
+			sum /= size.x * size.y * size.z;
+		}
+		// add lights
+		{
+			bool should = metadata["region"]["lights"]["should"].as<bool>();
+			if ( r > metadata["region"]["lights"]["rate"].as<float>() ) should = false;
+			// std::cout << "Rate: " << r << ": " << transform.position.x << ", " << transform.position.y << ", " << transform.position.z << std::endl;
+			if (
+				metadata["region"]["location"][0] == 0 &&
+				metadata["region"]["location"][1] == 0 &&
+				metadata["region"]["location"][2] == 0
+			) {
+				should = true;
+			}
+			if ( should ) {
+			//	uf::Entity* light = this->findByUid(this->loadChildUid("./light.json", true));
+				uf::Object& light = this->loadChild("./light.json", true);
+				pod::Vector3f origin = transform.position + light.getComponent<pod::Transform<>>().position;
+				pod::Vector3f color = {
+					(rand() % 100) / 100.0,
+					(rand() % 100) / 100.0,
+					(rand() % 100) / 100.0,
+				};
+				std::function<void(uf::Entity*, int)> filter = [&]( uf::Entity* entity, int indent ) {
+					auto& metadata = entity->getComponent<uf::Serializer>();
+					auto& transform = entity->getComponent<pod::Transform<>>();
+					transform.position = origin;
+				//	if ( !ext::json::isArray( metadata["light"]["color"] ) ) {
+						metadata["light"]["color"][0] = color.x;
+						metadata["light"]["color"][1] = color.y;
+						metadata["light"]["color"][2] = color.z;
+				//	}
+				};
+				light.process(filter);
+			/*
+				uf::Serializer& metadata = light.getComponent<uf::Serializer>();
+				pod::Transform<>& lTransform = light.getComponent<pod::Transform<>>();
+				lTransform.position += transform.position;
+				if ( !ext::json::isArray( metadata["light"]["color"] ) ) {
+					metadata["light"]["color"][0] = (rand() % 100) / 100.0;
+					metadata["light"]["color"][1] = (rand() % 100) / 100.0;
+					metadata["light"]["color"][2] = (rand() % 100) / 100.0;
+				}
+			*/
+			}
+		}
+		// add mobs
+		{
+			bool should = metadata["region"][""]["should"].as<bool>();
+			if ( r > metadata["region"][""]["rate"].as<float>() ) should = false;
+			// std::cout << "Rate: " << r << ": " << transform.position.x << ", " << transform.position.y << ", " << transform.position.z << std::endl;
+			if (
+				metadata["region"]["location"][0] == 0 &&
+				metadata["region"]["location"][1] == 0 &&
+				metadata["region"]["location"][2] == 0
+			) {
+				first = true;
+				should = true;
+			}
+			if ( !should ) return;
+
+			if ( first ) {
+				// shiro
+				if ( metadata["region"][""]["NPCs"].as<bool>() ) {
+				//	uf::Object*  = (uf::Object*) this->findByUid(this->loadChildUid("./shiro.json", true));
+					uf::Object&  = this->loadChild("./shiro.json", true);
+					pod::Transform<>& pTransform = .getComponent<pod::Transform<>>();
+					pTransform.position += transform.position + pod::Vector3f{ 2, 0, 0 };
+				}
+				// pong
+				if ( metadata["region"][""]["NPCs"].as<bool>() ) {
+				//	uf::Object*  = (uf::Object*) this->findByUid(this->loadChildUid("./pongy.json", true));
+					uf::Object&  = this->loadChild("./pongy.json", true);
+					uf::Serializer& pMetadata = .getComponent<uf::Serializer>();
+
+					pod::Transform<>& pTransform = .getComponent<pod::Transform<>>();
+					pTransform.position += transform.position + pod::Vector3f{ -2, 0, 0 };
+				}
+				return;
+			}
+
+			for ( uint i = 0; i < metadata["region"][""]["amount"].as<size_t>(); ++i ) {
+			//	uf::Object*  = (uf::Object*) this->findByUid(this->loadChildUid("./.json", false));
+				uf::Object&  = this->loadChild("./.json", false);
+				// set name
+				uf::Serializer& pMetadata = .getComponent<uf::Serializer>();
+			//	int ri = floor((noise[i][i][i] * metadata["region"][""]["list"].size());
+				int ri = floor(r * metadata["region"][""]["list"].size());
+				pMetadata[""] = metadata["region"][""]["list"][ri];
+				pMetadata["music"] = metadata["region"][""]["music"];
+			//	pMetadata["hostile"] = true;
+				.initialize();
+
+				pod::Transform<>& pTransform = .getComponent<pod::Transform<>>();
+				float rx = first ? 0.3 : (rand() % 100) / 100.0;
+				float rz = first ? 0.7 : (rand() % 100) / 100.0;
+				float spread = 32.0f;
+				spread = std::min( metadata["region"]["size"][0].as<float>(), spread );
+				spread = std::min( metadata["region"]["size"][1].as<float>(), spread );
+				spread = std::min( metadata["region"]["size"][2].as<float>(), spread );
+				pod::Vector3f randomOffset = {
+					rx * spread - spread/2.0f,
+					0,
+					rz * spread - spread/2.0f,
+				};
+				pTransform.position += transform.position + randomOffset;
+				pTransform.orientation = uf::quaternion::axisAngle( { 0.0f, 1.0f, 0.0f }, r * 2 * 3.1415926f );
+			}
+		}
+	});
+}
+void ext::RegionBehavior::tick( uf::Object& self ) {
+	// do collision on children
+#if 0
+	auto& mutex = *(this->getComponent<std::mutex*>());
+	mutex.lock();
+
+	auto& scene = uf::scene::getCurrentScene();
+	auto& sMetadata = scene.getComponent<uf::Serializer>();
+	auto& metadata = this->getComponent<uf::Serializer>();
+	bool threaded = !sMetadata["system"]["physics"]["single threaded"].as<bool>();
+	bool sort = sMetadata["system"]["physics"]["sort"].as<bool>();
+	bool useStrongest = sMetadata["system"]["physics"]["use"]["strongest"].as<bool>();
+	bool queued = sMetadata["system"]["physics"]["use"]["queue"].as<bool>();
+	bool updatePhysics = !sMetadata["system"]["physics"]["entity-local update"].as<bool>();
+	bool useWorkers = sMetadata["system"]["physics"]["use"]["worker"].as<bool>();
+	pod::Thread& thread = uf::thread::has("Physics") ? uf::thread::get("Physics") : uf::thread::create( "Physics", true, false );
+
+	auto& generator = this->getComponent<ext::TerrainGenerator>();
+	auto& regionPosition = this->getComponent<pod::Transform<>>().position;
+	pod::Vector3f size; {
+		size.x = metadata["region"]["size"][0].as<size_t>();
+		size.y = metadata["region"]["size"][1].as<size_t>();
+		size.z = metadata["region"]["size"][2].as<size_t>();
+	}
+
+	auto function = [&]() -> int {
+		std::vector<uf::Object*> entities;
+		// update physics
+		if ( updatePhysics ) {
+			std::function<void(uf::Entity*)> filter = [&]( uf::Entity* entity ) {
+				if ( !entity->hasComponent<pod::Physics>() ) return;
+				auto& metadata = entity->getComponent<uf::Serializer>();
+				auto& transform = entity->getComponent<pod::Transform<>>();
+				auto& physics = entity->getComponent<pod::Physics>();
+				if ( metadata["system"]["physics"]["gravity"] != Json::nullValue ) {
+					physics.linear.acceleration.x = metadata["system"]["physics"]["gravity"][0].as<float>();
+					physics.linear.acceleration.y = metadata["system"]["physics"]["gravity"][1].as<float>();
+					physics.linear.acceleration.z = metadata["system"]["physics"]["gravity"][2].as<float>();
+				}
+				if ( !metadata["system"]["physics"]["collision"].as<bool>() )  {
+					physics.linear.acceleration.x = 0;
+					physics.linear.acceleration.y = 0;
+					physics.linear.acceleration.z = 0;
+				}
+				transform = uf::physics::update( transform, physics );
+			};
+			this->process(filter);
+		}
+		{
+			std::function<void(uf::Entity*)> filter = [&]( uf::Entity* entity ) {
+				auto& metadata = entity->getComponent<uf::Serializer>();
+				if ( !ext::json::isNull( metadata["system"]["physics"]["collision"] ) && !metadata["system"]["physics"]["collision"].as<bool>() ) return;
+				if ( entity->hasComponent<uf::Collider>() )
+					entities.push_back((uf::Object*) entity);
+			};
+			this->process(filter);
+		}
+		auto onCollision = []( pod::Collider::Manifold& manifold, uf::Object* a, uf::Object* b, bool queued ){				
+			uf::Serializer payload;
+			payload["normal"][0] = manifold.normal.x;
+			payload["normal"][1] = manifold.normal.y;
+			payload["normal"][2] = manifold.normal.z;
+			payload["entity"] = b->getUid();
+			payload["depth"] = -manifold.depth;
+			if ( queued ) a->queueHook("world:Collision.%UID%", payload);
+			else a->callHook("world:Collision.%UID%", payload);
+			
+			payload["entity"] = a->getUid();
+			payload["depth"] = manifold.depth;
+			if ( queued ) b->queueHook("world:Collision.%UID%", payload);
+			else b->callHook("world:Collision.%UID%", payload);
+		};
+		auto testColliders = [&]( uf::Collider& colliderA, uf::Collider& colliderB, uf::Object* a, uf::Object* b, bool useStrongest ){
+			pod::Collider::Manifold strongest;
+			auto manifolds = colliderA.intersects(colliderB);
+			for ( auto manifold : manifolds ) {
+				if ( manifold.colliding && manifold.depth > 0 ) {
+					if ( !useStrongest ) onCollision(manifold, a, b, queued);
+					else if ( strongest.depth < manifold.depth ) strongest = manifold;
+				}
+			}
+			if ( useStrongest && strongest.colliding ) onCollision(strongest, a, b, queued);
+		};
+		// collide with world
+		for ( auto* _ : entities ) {
+			uf::Object& entity = *_;
+			auto& entityCollider = entity.getComponent<uf::Collider>();
+			auto function = [&]() -> int {
+			auto& entityTransform = entity.getComponent<pod::Transform<>>();
+			pod::Vector3f voxelPosition = entityTransform.position - regionPosition;
+			voxelPosition.x += size.x / 2.0f;
+			voxelPosition.y += size.y / 2.0f + 1;
+			voxelPosition.z += size.z / 2.0f;
+
+			std::vector<pod::Vector3ui> positions = {
+				{ voxelPosition.x, voxelPosition.y, voxelPosition.z },
+				{ voxelPosition.x - 1, voxelPosition.y, voxelPosition.z },
+				{ voxelPosition.x + 1, voxelPosition.y, voxelPosition.z },
+				{ voxelPosition.x, voxelPosition.y - 1, voxelPosition.z },
+				{ voxelPosition.x, voxelPosition.y + 1, voxelPosition.z },
+				{ voxelPosition.x, voxelPosition.y, voxelPosition.z - 1 },
+				{ voxelPosition.x, voxelPosition.y, voxelPosition.z + 1},
+			};
+			
+			uf::Collider collider;
+			for ( auto& position : positions ) {
+				ext::TerrainVoxel voxel = ext::TerrainVoxel::atlas( generator.getVoxel( position.x, position.y, position.z ) );
+				pod::Vector3 offset = regionPosition;
+				offset.x += position.x - (size.x / 2.0f);
+				offset.y += position.y - (size.y / 2.0f);
+				offset.z += position.z - (size.z / 2.0f);
+
+				if ( !voxel.solid() ) continue;
+
+				collider.add( new uf::BoundingBox( offset, {0.5, 0.5, 0.5} ) );
+			#if 0
+				uf::BaseMesh<pod::Vertex_3F> mesh;
+				const ext::TerrainVoxel::Model& model = voxel.model();
+				#define TERRAIN_SHOULD_RENDER_FACE(SIDE)\
+					for ( uint i = 0; i < model.position.SIDE.size() / 3; ++i ) {\
+						auto& vertex = mesh.vertices.emplace_back();\
+						{\
+							pod::Vector3f& p = vertex.position;\
+							p.x = model.position.SIDE[i*3+0]; p.y = model.position.SIDE[i*3+1]; p.z = model.position.SIDE[i*3+2];\
+							p.x += offset.x; p.y += offset.y; p.z += offset.z;\
+						}\
+					}
+				TERRAIN_SHOULD_RENDER_FACE(left)
+				TERRAIN_SHOULD_RENDER_FACE(right)
+				TERRAIN_SHOULD_RENDER_FACE(top)
+				TERRAIN_SHOULD_RENDER_FACE(bottom)
+				TERRAIN_SHOULD_RENDER_FACE(back)
+				TERRAIN_SHOULD_RENDER_FACE(front)
+				uf::MeshCollider* mCollider = new uf::MeshCollider();
+				mCollider->setPositions( mesh );
+				pCollider.add(mCollider);
+			#endif
+			}
+				testColliders( collider, entityCollider, this, &entity, useStrongest );
+				return 0;
+			};
+			// if ( threaded && useWorkers ) uf::thread::add( uf::thread::fetchWorker(), function, true ); else
+				function();
+		}
+	
+		// collide with others
+		for ( auto* _a : entities ) {
+			uf::Object& entityA = *_a;
+			for ( auto* _b : entities ) { if ( _a == _b ) continue;
+				uf::Object& entityB = *_b;
+				auto& colliderA = entityA.getComponent<uf::Collider>();
+				auto& colliderB = entityB.getComponent<uf::Collider>();
+				auto function = [&]() -> int {
+					testColliders( colliderA, colliderB, &entityA, &entityB, useStrongest );
+					return 0;
+				};
+				if ( threaded && useWorkers ) uf::thread::add( uf::thread::fetchWorker(), function, true ); else function();
+			}
+		}
+		mutex.unlock();
+		return 0;
+	};
+	if ( threaded ) uf::thread::add( thread, function, true ); else function();
+#else
+#if 1
+	{
+
+		auto& metadata = this->getComponent<uf::Serializer>();
+
+		auto& scene = uf::scene::getCurrentScene();
+		auto& sMetadata = scene.getComponent<uf::Serializer>();
+
+		if ( !sMetadata["system"]["physics"]["collision"].as<bool>() ) return;
+		auto& mutex = *(this->getComponent<std::mutex*>());
+		mutex.lock();
+
+		bool threaded = !sMetadata["system"]["physics"]["single threaded"].as<bool>();
+		bool sort = sMetadata["system"]["physics"]["sort"].as<bool>();
+		bool useStrongest = sMetadata["system"]["physics"]["use"]["strongest"].as<bool>();
+		bool queued = sMetadata["system"]["physics"]["use"]["queue"].as<bool>();
+		bool ignoreStaticEntities = sMetadata["system"]["physics"]["optimizations"]["ignore static entities"].as<bool>();
+		bool ignoreDuplicateTests = sMetadata["system"]["physics"]["optimizations"]["ignore duplicate tests"].as<bool>();
+		bool updatePhysics = !sMetadata["system"]["physics"]["optimizations"]["entity-local update"].as<bool>();
+		bool useWorkers = sMetadata["system"]["physics"]["use"]["worker"].as<bool>();
+		pod::Thread& thread = uf::thread::has("Physics") ? uf::thread::get("Physics") : uf::thread::create( "Physics", true, false );
+		auto function = [&]() -> int {
+			std::vector<uf::Object*> entities;
+			std::function<void(uf::Entity*)> filter = [&]( uf::Entity* entity ) {
+				auto& metadata = entity->getComponent<uf::Serializer>();
+				if ( !ext::json::isNull( metadata["system"]["physics"]["collision"] ) && !metadata["system"]["physics"]["collision"].as<bool>() ) return;
+				if ( entity->hasComponent<uf::Collider>() )
+					entities.push_back((uf::Object*) entity);
+			};
+			this->process(filter);
+			auto onCollision = []( pod::Collider::Manifold& manifold, uf::Object* a, uf::Object* b ){				
+				uf::Serializer payload;
+				payload["normal"][0] = manifold.normal.x;
+				payload["normal"][1] = manifold.normal.y;
+				payload["normal"][2] = manifold.normal.z;
+				payload["entity"] = b->getUid();
+				payload["depth"] = -manifold.depth;
+				a->callHook("world:Collision.%UID%", payload);
+				
+				payload["entity"] = a->getUid();
+				payload["depth"] = manifold.depth;
+				b->callHook("world:Collision.%UID%", payload);
+			};
+			auto testColliders = [&]( uf::Collider& colliderA, uf::Collider& colliderB, uf::Object* a, uf::Object* b, bool useStrongest ){
+				pod::Collider::Manifold strongest;
+				auto manifolds = colliderA.intersects(colliderB);
+				for ( auto manifold : manifolds ) {
+					if ( manifold.colliding && manifold.depth > 0 ) {
+						if ( !useStrongest ) onCollision(manifold, a, b);
+						else if ( strongest.depth < manifold.depth ) strongest = manifold;
+					}
+				}
+				if ( useStrongest && strongest.colliding ) onCollision(strongest, a, b);
+			};
+
+			// collide with world
+			auto& metadata = this->getComponent<uf::Serializer>();
+			auto& generator = this->getComponent<ext::TerrainGenerator>();
+			auto& regionPosition = this->getComponent<pod::Transform<>>().position;
+			pod::Vector3f size; {
+				size.x = metadata["region"]["size"][0].as<size_t>();
+				size.y = metadata["region"]["size"][1].as<size_t>();
+				size.z = metadata["region"]["size"][2].as<size_t>();
+			}
+			for ( auto* _ : entities ) {
+				uf::Object& entity = *_;
+				auto& transform = entity.getComponent<pod::Transform<>>();
+
+			
+				pod::Vector3f voxelPosition = transform.position - regionPosition;
+				voxelPosition.x += size.x / 2.0f;
+				voxelPosition.y += size.y / 2.0f + 1;
+				voxelPosition.z += size.z / 2.0f;
+
+				uf::Collider collider;
+				std::vector<pod::Vector3ui> positions = {
+					{ voxelPosition.x, voxelPosition.y, voxelPosition.z },
+					{ voxelPosition.x - 1, voxelPosition.y, voxelPosition.z },
+					{ voxelPosition.x + 1, voxelPosition.y, voxelPosition.z },
+					{ voxelPosition.x, voxelPosition.y - 1, voxelPosition.z },
+					{ voxelPosition.x, voxelPosition.y + 1, voxelPosition.z },
+					{ voxelPosition.x, voxelPosition.y, voxelPosition.z - 1 },
+					{ voxelPosition.x, voxelPosition.y, voxelPosition.z + 1},
+				};
+				for ( auto& position : positions ) {
+					ext::TerrainVoxel voxel = ext::TerrainVoxel::atlas( generator.getVoxel( position.x, position.y, position.z ) );
+					pod::Vector3 offset = regionPosition;
+					offset.x += position.x - (size.x / 2.0f);
+					offset.y += position.y - (size.y / 2.0f);
+					offset.z += position.z - (size.z / 2.0f);
+
+					if ( !voxel.solid() ) continue;
+
+					collider.add( new uf::BoundingBox( offset, {0.5, 0.5, 0.5} ) );
+				/*
+					uf::BaseMesh<pod::Vertex_3F> mesh;
+					const ext::TerrainVoxel::Model& model = voxel.model();
+					#define TERRAIN_SHOULD_RENDER_FACE(SIDE)\
+						for ( uint i = 0; i < model.position.SIDE.size() / 3; ++i ) {\
+							auto& vertex = mesh.vertices.emplace_back();\
+							{\
+								pod::Vector3f& p = vertex.position;\
+								p.x = model.position.SIDE[i*3+0]; p.y = model.position.SIDE[i*3+1]; p.z = model.position.SIDE[i*3+2];\
+								p.x += offset.x; p.y += offset.y; p.z += offset.z;\
+							}\
+						}
+					TERRAIN_SHOULD_RENDER_FACE(left)
+					TERRAIN_SHOULD_RENDER_FACE(right)
+					TERRAIN_SHOULD_RENDER_FACE(top)
+					TERRAIN_SHOULD_RENDER_FACE(bottom)
+					TERRAIN_SHOULD_RENDER_FACE(back)
+					TERRAIN_SHOULD_RENDER_FACE(front)
+					uf::MeshCollider* mCollider = new uf::MeshCollider();
+					mCollider->setPositions( mesh );
+					pCollider.add(mCollider);
+				*/
+				}
+				testColliders( collider, entity.getComponent<uf::Collider>(), this, &entity, useStrongest );
+			}
+		
+			// collide with others
+			if ( ignoreDuplicateTests ) {
+				struct Pair {
+					uf::Object* a = NULL;
+					uf::Object* b = NULL;
+				};
+				std::unordered_map<std::string, Pair> queued;
+				for ( auto* _a : entities ) {
+					uf::Object& entityA = *_a;
+					if ( ignoreStaticEntities && !entityA.hasComponent<pod::Physics>() ) continue;
+					for ( auto* _b : entities ) { if ( _a == _b ) continue;
+						uf::Object& entityB = *_b;
+
+						std::string hash = std::to_string(std::min( entityA.getUid(), entityB.getUid() )) + ":" + std::to_string(std::max( entityA.getUid(), entityB.getUid() ));
+						if ( queued.count(hash) > 0 ) continue;
+						queued[hash] = {
+							.a = _a,
+							.b = _b,
+						};
+					}
+				}
+				for ( auto& pair : queued ) {
+					auto* entityA = pair.second.a;
+					auto* entityB = pair.second.b;
+					auto& colliderA = entityA->getComponent<uf::Collider>();
+					auto& colliderB = entityB->getComponent<uf::Collider>();
+					auto function = [&]() -> int {
+						testColliders( colliderA, colliderB, entityA, entityB, useStrongest );
+						return 0;
+					};
+					if ( threaded && useWorkers ) uf::thread::add( uf::thread::fetchWorker(), function, true ); else function();
+				}
+			} else {
+				for ( auto* _a : entities ) {
+					uf::Object& entityA = *_a;
+					if ( ignoreStaticEntities && !entityA.hasComponent<pod::Physics>() ) continue;
+					for ( auto* _b : entities ) { if ( _a == _b ) continue;
+						uf::Object& entityB = *_b;
+						auto& colliderA = entityA.getComponent<uf::Collider>();
+						auto& colliderB = entityB.getComponent<uf::Collider>();
+						auto function = [&]() -> int {
+							testColliders( colliderA, colliderB, &entityA, &entityB, useStrongest );
+							return 0;
+						};
+						if ( threaded && useWorkers ) uf::thread::add( uf::thread::fetchWorker(), function, true ); else function();
+					}
+				}
+			}
+		/*
+			for ( auto* _a : entities ) {
+				uf::Object& entityA = *_a;
+				for ( auto* _b : entities ) { if ( _a == _b ) continue;
+					uf::Object& entityB = *_b;
+					testColliders( entityA.getComponent<uf::Collider>(), entityB.getComponent<uf::Collider>(), &entityA, &entityB, useStrongest );
+				}
+			}
+		*/
+			mutex.unlock();
+			return 0;
+		};
+		if ( threaded ) function(); else uf::thread::add( thread, function, true );
+	}
+#endif
+#endif
+}
+void ext::RegionBehavior::render( uf::Object& self ){
+	uf::Scene& scene = uf::scene::getCurrentScene();
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	
+	if ( !metadata["region"]["rasterized"].as<bool>() ) return;
+	/* Update uniforms */ if ( this->hasComponent<uf::Graphic>() ) {
+		auto& scene = uf::scene::getCurrentScene();
+		auto& mesh = this->getComponent<ext::TerrainGenerator::mesh_t>();
+		auto& graphic = this->getComponent<uf::Graphic>();
+		auto& camera = scene.getController().getComponent<uf::Camera>();		
+		if ( !graphic.initialized ) return;
+		auto& shader = graphic.material.getShader("vertex");
+		auto& uniform = shader.getUniform("UBO");
+		auto& uniforms = uniform.get<uf::MeshDescriptor<>>();
+		
+		uniforms.matrices.model = uf::matrix::identity();
+		for ( std::size_t i = 0; i < uf::renderer::settings::maxViews; ++i ) {
+			uniforms.matrices.view[i] = camera.getView( i );
+			uniforms.matrices.projection[i] = camera.getProjection( i );
+		}
+
+		shader.updateUniform( "UBO", uniform );
+	}
+}
+void ext::RegionBehavior::destroy( uf::Object& self ){
+	{
+		auto& mutexPointer = this->getComponent<std::mutex*>();
+		delete mutexPointer;
+		mutexPointer = NULL;
+	}
+}
+#undef this
\ No newline at end of file
diff --git a/ext/scenes/worldscape/terrain/region.h b/ext/scenes/worldscape/terrain/region.h
new file mode 100644
index 00000000..f0167975
--- /dev/null
+++ b/ext/scenes/worldscape/terrain/region.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/ext/ext.h>
+#include <uf/engine/entity/entity.h>
+#include <uf/engine/scene/scene.h>
+
+namespace ext {
+	class EXT_API RegionBehavior {
+	public:
+		static void attach( uf::Object& );
+		static void initialize( uf::Object& );
+		static void tick( uf::Object& );
+		static void render( uf::Object& );
+		static void destroy( uf::Object& );
+	};
+}
\ No newline at end of file
diff --git a/ext/scenes/worldscape/terrain/terrain.cpp b/ext/scenes/worldscape/terrain/terrain.cpp
new file mode 100644
index 00000000..9c5c7827
--- /dev/null
+++ b/ext/scenes/worldscape/terrain/terrain.cpp
@@ -0,0 +1,227 @@
+#include "behavior.h"
+#include "terrain.h"
+#include "generator.h"
+
+#include "../../../ext.h"
+#include <uf/engine/asset/asset.h>
+#include "generator.h"
+#include "region.h"
+
+#include <uf/utils/window/window.h>
+#include <uf/utils/graphic/mesh.h>
+#include <uf/utils/graphic/graphic.h>
+#include <uf/utils/camera/camera.h>
+#include <uf/utils/math/collision.h>
+#include <uf/utils/thread/thread.h>
+#include <uf/utils/renderer/renderer.h>
+
+#include <uf/utils/string/hash.h>
+
+#include <sys/stat.h>
+
+namespace {
+	std::unordered_map<pod::Vector3i, uf::Object*> region_table;
+}
+
+UF_OBJECT_REGISTER_BEGIN(ext::Terrain)
+	UF_OBJECT_REGISTER_BEHAVIOR(uf::EntityBehavior)
+	UF_OBJECT_REGISTER_BEHAVIOR(uf::ObjectBehavior)
+	UF_OBJECT_REGISTER_BEHAVIOR(ext::TerrainBehavior)
+UF_OBJECT_REGISTER_END()
+void ext::Terrain::relocateChildren() {
+	uf::Scene& scene = uf::scene::getCurrentScene();
+	std::vector<uf::Entity*> entities;
+	scene.process( [&]( uf::Entity* entity ) {
+		if ( !entity || entity->getUid() == 0 ) return;
+		uf::Serializer& metadata = entity->getComponent<uf::Serializer>();
+		if ( ext::json::isObject( metadata["region"] ) && metadata["region"]["track"].as<bool>() ) {
+			if ( std::find( entities.begin(), entities.end(), entity ) == entities.end() ) {
+				entities.push_back(entity);
+			}
+		}
+	} );
+	
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	pod::Vector3ui size = {
+		metadata["region"]["size"][0].as<size_t>(),
+		metadata["region"]["size"][1].as<size_t>(),
+		metadata["region"]["size"][2].as<size_t>(),
+	};
+	for ( uf::Entity* e : entities ) {
+		uf::Entity& entity = *e;
+		const pod::Transform<>& transform = entity.getComponent<pod::Transform<>>();
+		pod::Vector3 pointf = uf::vector::divide(transform.position, {size.x, size.y, size.z});
+		pod::Vector3i point = {
+			(int) (pointf.x + (pointf.x > 0 ? 0.5 : -0.5)),
+			(int) (pointf.y + (pointf.y > 0 ? 0.5 : -0.5)),
+			(int) (pointf.z + (pointf.z > 0 ? 0.5 : -0.5)),
+		};
+		if ( !this->exists(point) ) continue; // oops
+		uf::Object& region = *this->at(point);
+		bool should = false;
+		if ( entity.getParent().getName() != "Region" ) should = true;
+		else {
+			auto& current = entity.getParent();
+			const pod::Transform<>& t = current.getComponent<pod::Transform<>>();
+			pod::Vector3i location = {
+				(int) (t.position.x / size.x),
+				(int) (t.position.y / size.y),
+				(int) (t.position.z / size.z),
+			};
+			if ( !uf::vector::equals( point, location ) ) should = true;
+		}
+		if ( should ) {
+			region.moveChild(entity);
+		//	uf::iostream << "Relocating " << &entity << ": " << entity.getName() << " to (" << point.x << ", " << point.y << ", " << point.z << ")" << "\n";
+		}
+	}
+}
+
+bool ext::Terrain::exists( const pod::Vector3i& position ) const {
+	const uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	pod::Vector3i size = {
+		metadata["region"]["size"][0].as<int>(),
+		metadata["region"]["size"][1].as<int>(),
+		metadata["region"]["size"][2].as<int>(),
+	};
+	if ( this->getChildren().empty() ) return false;
+	for ( auto it = this->getChildren().begin(); it != this->getChildren().end(); ++it ) { uf::Entity* kv = *it;
+		const pod::Transform<>& transform = kv->getComponent<pod::Transform<>>();
+		pod::Vector3i location = {
+			(int) (transform.position.x / size.x),
+			(int) (transform.position.y / size.y),
+			(int) (transform.position.z / size.z),
+		};
+		if ( uf::vector::equals( location, position ) ) return true;
+	}
+	return false;
+}
+
+bool ext::Terrain::inBounds( const pod::Vector3i& position ) const {
+	const uf::Scene& scene = uf::scene::getCurrentScene();
+	const pod::Transform<>& player = scene.getController().getComponent<pod::Transform<>>();
+	const uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	pod::Vector3ui size = {
+		metadata["region"]["size"][0].as<size_t>(),
+		metadata["region"]["size"][1].as<size_t>(),
+		metadata["region"]["size"][2].as<size_t>(),
+	};
+	pod::Vector3ui threshold = {
+		metadata["terrain"]["radius"][0].as<size_t>(),
+		metadata["terrain"]["radius"][1].as<size_t>(),
+		metadata["terrain"]["radius"][2].as<size_t>(),
+	};
+	pod::Vector3i point = {
+		(int) (player.position.x / size.x),
+		(int) (player.position.y / size.y),
+		(int) (player.position.z / size.z),
+	};
+	pod::Vector3i difference = uf::vector::subtract( point, position );
+
+	return !(abs(difference.x) >= threshold.x || abs(difference.y) >= threshold.y || abs(difference.z) >= threshold.z);
+}
+
+void ext::Terrain::generate( bool single ) {
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	pod::Vector3i radius = {
+		metadata["terrain"]["radius"][0].as<int>(),
+		metadata["terrain"]["radius"][1].as<int>(),
+		metadata["terrain"]["radius"][2].as<int>(),
+	};
+	pod::Vector3i size = {
+		metadata["region"]["size"][0].as<int>(),
+		metadata["region"]["size"][1].as<int>(),
+		metadata["region"]["size"][2].as<int>(),
+	};
+
+	uf::Scene& scene = uf::scene::getCurrentScene();
+	const pod::Transform<>& player = scene.getController().getComponent<pod::Transform<>>();
+	pod::Vector3i location = {
+		(int) player.position.x / size.x,
+		(int) player.position.y / size.y,
+		(int) player.position.z / size.z,
+	};
+	if ( single ) 
+		this->generate( {location.x, location.y, location.z} );
+	else
+		for ( int y = 0; y < radius.y; ++y ) {
+		for ( int z = 0; z < radius.z; ++z ) {
+		for ( int x = 0; x < radius.x; ++x ) {
+			this->generate( {location.x + x, location.y + y, location.z + z} );
+			this->generate( {location.x - x, location.y - y, location.z - z} );
+			this->generate( {location.x + x, location.y + y, location.z - z} );
+			this->generate( {location.x - x, location.y + y, location.z + z} );
+			this->generate( {location.x - x, location.y + y, location.z - z} );
+			this->generate( {location.x + x, location.y - y, location.z + z} );
+			this->generate( {location.x + x, location.y - y, location.z - z} );
+			this->generate( {location.x - x, location.y - y, location.z + z} );
+		}
+		}
+		}
+}
+uf::Object* ext::Terrain::at( const pod::Vector3i& position ) const {
+	if ( ::region_table.count(position) > 0 ) return ::region_table.at(position);
+
+	const uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	pod::Vector3i size = {
+		metadata["region"]["size"][0].as<int>(),
+		metadata["region"]["size"][1].as<int>(),
+		metadata["region"]["size"][2].as<int>(),
+	};
+	if ( this->getChildren().empty() ) return NULL;
+	for ( auto it = this->getChildren().begin(); it != this->getChildren().end(); ++it ) { uf::Entity* kv = *it;
+		const pod::Transform<>& transform = kv->getComponent<pod::Transform<>>();
+		pod::Vector3i location = {
+			(int) (transform.position.x / size.x),
+			(int) (transform.position.y / size.y),
+			(int) (transform.position.z / size.z),
+		};
+		if ( uf::vector::equals( location, position ) ) return (uf::Object*) kv;
+	}
+	return NULL;
+}
+void ext::Terrain::generate( const pod::Vector3i& position ) {
+	uf::Serializer& metadata = this->getComponent<uf::Serializer>();
+	pod::Vector3i size = {
+		metadata["region"]["size"][0].as<int>(),
+		metadata["region"]["size"][1].as<int>(),
+		metadata["region"]["size"][2].as<int>(),
+	};
+
+	if ( this->exists(position) ) return;
+	if ( !this->inBounds(position) ) return;
+/*
+	auto& region = uf::instantiator::instantiate<uf::Object>();
+	uf::instantiator::bind("RegionBehavior", region);
+	this->addChild(region);
+*/
+	auto& region = this->loadChild("./region.json", false);
+	{
+		uf::Serializer& m = region.getComponent<uf::Serializer>(); // = metadata;
+		m["system"]["type"] = "Region";
+		m["system"]["root"] = metadata["system"]["root"];
+		m["system"]["source"] = metadata["system"]["source"];
+		m["region"] = metadata["region"];
+		m["terrain"] = metadata["terrain"];
+
+		pod::Transform<>& transform = region.getComponent<pod::Transform<>>();
+		transform.position.x = position.x * size.x;
+		transform.position.y = position.y * size.y;
+		transform.position.z = position.z * size.z;
+
+		m["region"]["location"][0] = position.x;
+		m["region"]["location"][1] = position.y;
+		m["region"]["location"][2] = position.z;
+		
+		::region_table[position] = &region;
+	}
+}
+void ext::Terrain::degenerate( const pod::Vector3i& position ) {
+	if ( !this->exists( position ) ) return;
+	uf::Object* region = this->at( position );
+	if ( !region ) return;
+	this->removeChild( *region );
+	region->destroy();
+	delete region;
+	::region_table.erase( position );
+}
\ No newline at end of file
diff --git a/ext/scenes/worldscape/terrain/terrain.h b/ext/scenes/worldscape/terrain/terrain.h
new file mode 100644
index 00000000..b6d334fb
--- /dev/null
+++ b/ext/scenes/worldscape/terrain/terrain.h
@@ -0,0 +1,39 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/ext/ext.h>
+#include <uf/engine/entity/entity.h>
+
+#include <uf/utils/math/transform.h>
+#include <uf/utils/math/physics.h>
+
+#include <uf/engine/object/object.h>
+
+#include "region.h"
+#include "maze.h"
+
+namespace ext {
+	class EXT_API Terrain : public uf::Object {
+	public:
+		void relocateChildren();
+		
+		bool exists( const pod::Vector3i& ) const;
+		bool inBounds( const pod::Vector3i& ) const;
+		uf::Object* at( const pod::Vector3i& ) const;
+
+		void generate( bool single = false );
+		void generate( const pod::Vector3i& );
+		void degenerate( const pod::Vector3i& );
+	};
+}
+
+namespace std {
+	template<> struct hash<pod::Vector3i> {
+	    size_t operator()(pod::Vector3i const& vertex) const {
+	       std::size_t seed = 3;
+	       std::hash<int> hasher;
+			for ( size_t i = 0; i < 3; ++i ) seed ^= hasher( vertex[i] ) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+			return seed;
+	    }
+	};
+}
\ No newline at end of file
diff --git a/ext/scenes/worldscape/terrain/voxel.cpp b/ext/scenes/worldscape/terrain/voxel.cpp
new file mode 100644
index 00000000..16f42423
--- /dev/null
+++ b/ext/scenes/worldscape/terrain/voxel.cpp
@@ -0,0 +1,502 @@
+#include "voxel.h"
+
+#include "../../../ext.h"
+
+#include <uf/utils/io/iostream.h>
+
+ext::TerrainVoxel::TerrainVoxel( ext::TerrainVoxel::uid_t uid, bool opaque, bool solid, pod::Vector2ui uv, ext::TerrainVoxel::light_t light ) : m_uid(uid), m_opaque(opaque), m_solid(solid), m_uv(uv), m_light(light) {
+
+}
+ext::TerrainVoxel::TerrainVoxel( const ext::TerrainVoxel& voxel ) : m_uid(voxel.uid()), m_opaque(voxel.opaque()), m_solid(voxel.solid()), m_uv(voxel.uv()), m_light(voxel.light()) {
+
+}
+ext::TerrainVoxel::~TerrainVoxel() {
+
+}
+
+pod::Vector2ui ext::TerrainVoxel::size() { return {4, 4}; }
+
+bool ext::TerrainVoxel::opaque() const { return this->m_opaque; }
+bool ext::TerrainVoxel::solid() const { return this->m_solid; }
+pod::Vector2ui ext::TerrainVoxel::uv() const { return this->m_uv; }
+ext::TerrainVoxel::light_t ext::TerrainVoxel::light() const { return this->m_light; }
+ext::TerrainVoxel::uid_t ext::TerrainVoxel::uid() const { return this->m_uid; }
+ext::TerrainVoxel::Model ext::TerrainVoxel::model() const {
+	ext::TerrainVoxel::Model model;
+	if ( true ) {
+		model.position.left = {
+			-0.5f,  0.5f,  0.5f,
+			-0.5f,  0.5f, -0.5f,
+			-0.5f, -0.5f, -0.5f,
+			-0.5f, -0.5f, -0.5f,
+			-0.5f, -0.5f,  0.5f,
+			-0.5f,  0.5f,  0.5f,
+		};
+		model.position.right = {
+			 0.5f,  0.5f, -0.5f,
+			 0.5f,  0.5f,  0.5f,
+			 0.5f, -0.5f,  0.5f,
+			 0.5f, -0.5f,  0.5f,
+			 0.5f, -0.5f, -0.5f,
+			 0.5f,  0.5f, -0.5f,
+		};
+		model.position.top = {
+			 0.5f,  0.5f, -0.5f,
+			-0.5f,  0.5f, -0.5f,
+			-0.5f,  0.5f,  0.5f,
+			-0.5f,  0.5f,  0.5f,
+			 0.5f,  0.5f,  0.5f,
+			 0.5f,  0.5f, -0.5f,
+		};
+		model.position.bottom = {
+			-0.5f, -0.5f, -0.5f,
+			 0.5f, -0.5f, -0.5f,
+			 0.5f, -0.5f,  0.5f,
+			 0.5f, -0.5f,  0.5f,
+			-0.5f, -0.5f,  0.5f,
+			-0.5f, -0.5f, -0.5f,
+		};
+		model.position.back = {
+			-0.5f,  0.5f, -0.5f,
+			 0.5f,  0.5f, -0.5f,
+			 0.5f, -0.5f, -0.5f,
+			 0.5f, -0.5f, -0.5f,
+			-0.5f, -0.5f, -0.5f,
+			-0.5f,  0.5f, -0.5f,
+		};
+		model.position.front = {
+			 0.5f,  0.5f,  0.5f,
+			-0.5f,  0.5f,  0.5f,
+			-0.5f, -0.5f,  0.5f,
+			-0.5f, -0.5f,  0.5f,
+			 0.5f, -0.5f,  0.5f,
+			 0.5f,  0.5f,  0.5f,
+		};
+		model.uv.left = {
+			0.0f, 1.0f,
+			1.0f, 1.0f,
+			1.0f, 0.0f,
+
+			1.0f, 0.0f,
+			0.0f, 0.0f,
+			0.0f, 1.0f,
+		};
+		model.uv.right = {
+			0.0f, 1.0f,
+			1.0f, 1.0f,
+			1.0f, 0.0f,
+
+			1.0f, 0.0f,
+			0.0f, 0.0f,
+			0.0f, 1.0f,
+		};
+		model.uv.bottom = {
+			0.0f, 1.0f,
+			1.0f, 1.0f,
+			1.0f, 0.0f,
+
+			1.0f, 0.0f,
+			0.0f, 0.0f,
+			0.0f, 1.0f,
+		};
+		model.uv.top = {
+			0.0f, 1.0f,
+			1.0f, 1.0f,
+			1.0f, 0.0f,
+
+			1.0f, 0.0f,
+			0.0f, 0.0f,
+			0.0f, 1.0f,
+		};
+		model.uv.back = {
+			0.0f, 1.0f,
+			1.0f, 1.0f,
+			1.0f, 0.0f,
+
+			1.0f, 0.0f,
+			0.0f, 0.0f,
+			0.0f, 1.0f,
+		};
+		model.uv.front = {
+			0.0f, 1.0f,
+			1.0f, 1.0f,
+			1.0f, 0.0f,
+
+			1.0f, 0.0f,
+			0.0f, 0.0f,
+			0.0f, 1.0f,
+		};
+
+		model.normal.left = {
+			-1.0f, 0.0f, 0.0f,
+			-1.0f, 0.0f, 0.0f,
+			-1.0f, 0.0f, 0.0f,
+			
+			-1.0f, 0.0f, 0.0f,
+			-1.0f, 0.0f, 0.0f,
+			-1.0f, 0.0f, 0.0f,
+		};
+		model.normal.right = {
+			 1.0f, 0.0f, 0.0f,
+			 1.0f, 0.0f, 0.0f,
+			 1.0f, 0.0f, 0.0f,
+			
+			 1.0f, 0.0f, 0.0f,
+			 1.0f, 0.0f, 0.0f,
+			 1.0f, 0.0f, 0.0f,
+		};
+		model.normal.top = {
+			 0.0f, 1.0f, 0.0f,
+			 0.0f, 1.0f, 0.0f,
+			 0.0f, 1.0f, 0.0f,
+			
+			 0.0f, 1.0f, 0.0f,
+			 0.0f, 1.0f, 0.0f,
+			 0.0f, 1.0f, 0.0f,
+		};
+		model.normal.bottom = {
+			 0.0f,-1.0f, 0.0f,
+			 0.0f,-1.0f, 0.0f,
+			 0.0f,-1.0f, 0.0f,
+			
+			 0.0f,-1.0f, 0.0f,
+			 0.0f,-1.0f, 0.0f,
+			 0.0f,-1.0f, 0.0f,
+		};
+		model.normal.back = {
+			 0.0f, 0.0f,-1.0f,
+			 0.0f, 0.0f,-1.0f,
+			 0.0f, 0.0f,-1.0f,
+			
+			 0.0f, 0.0f,-1.0f,
+			 0.0f, 0.0f,-1.0f,
+			 0.0f, 0.0f,-1.0f,
+		};
+		model.normal.front = {
+			 0.0f, 0.0f, 1.0f,
+			 0.0f, 0.0f, 1.0f,
+			 0.0f, 0.0f, 1.0f,
+			
+			 0.0f, 0.0f, 1.0f,
+			 0.0f, 0.0f, 1.0f,
+			 0.0f, 0.0f, 1.0f,
+		};
+	} else {
+		model.position.left = {
+			-0.5f, -0.5f, -0.5f,
+			-0.5f,  0.5f, -0.5f,
+			 0.0f,  0.0f,  0.0f,
+			
+			-0.5f,  0.5f, -0.5f,
+			-0.5f,  0.5f,  0.5f,
+			 0.0f,  0.0f,  0.0f,
+
+			-0.5f,  0.5f,  0.5f,
+			-0.5f, -0.5f,  0.5f,
+			 0.0f,  0.0f,  0.0f,
+			
+			-0.5f, -0.5f,  0.5f,
+			-0.5f, -0.5f, -0.5f,
+			 0.0f,  0.0f,  0.0f,
+		};
+		model.position.right = {
+			 0.5f, -0.5f,  0.5f,
+			 0.5f,  0.5f,  0.5f,
+			 0.0f,  0.0f,  0.0f,
+
+			 0.5f,  0.5f,  0.5f,
+			 0.5f,  0.5f, -0.5f,
+			 0.0f,  0.0f,  0.0f,
+
+			 0.5f,  0.5f, -0.5f,
+			 0.5f, -0.5f, -0.5f,
+			 0.0f,  0.0f,  0.0f,
+			 
+			 0.5f, -0.5f, -0.5f,
+			 0.5f, -0.5f,  0.5f,
+			 0.0f,  0.0f,  0.0f,
+		};
+		model.position.bottom = {
+			 0.5f, -0.5f,  0.5f,
+			 0.5f, -0.5f, -0.5f,
+			 0.0f,  0.0f,  0.0f,
+
+			 0.5f, -0.5f, -0.5f,
+			-0.5f, -0.5f, -0.5f,
+			 0.0f,  0.0f,  0.0f,
+
+			-0.5f, -0.5f, -0.5f,
+			-0.5f, -0.5f,  0.5f,
+			 0.0f,  0.0f,  0.0f,
+			
+			-0.5f, -0.5f,  0.5f,
+			 0.5f, -0.5f,  0.5f,
+			 0.0f,  0.0f,  0.0f,
+		};
+		model.position.top = {
+			-0.5f,  0.5f,  0.5f,
+			-0.5f,  0.5f, -0.5f,
+			 0.0f,  0.0f,  0.0f,
+
+			-0.5f,  0.5f, -0.5f,
+			 0.5f,  0.5f, -0.5f,
+			 0.0f,  0.0f,  0.0f,
+
+			 0.5f,  0.5f, -0.5f,
+			 0.5f,  0.5f,  0.5f,
+			 0.0f,  0.0f,  0.0f,
+			 
+			 0.5f,  0.5f,  0.5f,
+			-0.5f,  0.5f,  0.5f,
+			 0.0f,  0.0f,  0.0f,
+		};
+		model.position.back = {
+			 0.5f, -0.5f, -0.5f,
+			 0.5f,  0.5f, -0.5f,
+			 0.0f,  0.0f,  0.0f,
+
+			 0.5f,  0.5f, -0.5f,
+			-0.5f,  0.5f, -0.5f,
+			 0.0f,  0.0f,  0.0f,
+
+			-0.5f,  0.5f, -0.5f,
+			-0.5f, -0.5f, -0.5f,
+			 0.0f,  0.0f,  0.0f,
+			
+			-0.5f, -0.5f, -0.5f,
+			 0.5f, -0.5f, -0.5f,
+			 0.0f,  0.0f,  0.0f,
+		};
+		model.position.front = {
+			-0.5f, -0.5f,  0.5f,
+			-0.5f,  0.5f,  0.5f,
+			 0.0f,  0.0f,  0.0f,
+
+			-0.5f,  0.5f,  0.5f,
+			 0.5f,  0.5f,  0.5f,
+			 0.0f,  0.0f,  0.0f,
+
+			 0.5f,  0.5f,  0.5f,
+			 0.5f, -0.5f,  0.5f,
+			 0.0f,  0.0f,  0.0f,
+			 
+			 0.5f, -0.5f,  0.5f,
+			-0.5f, -0.5f,  0.5f,
+			 0.0f,  0.0f,  0.0f,
+		};
+		model.uv.left = {
+			0.0f, 0.0f,
+			0.0f, 1.0f,
+			0.5f, 0.5f,
+
+			0.0f, 1.0f,
+			1.0f, 1.0f,
+			0.5f, 0.5f,
+
+			1.0f, 1.0f,
+			1.0f, 0.0f,
+			0.5f, 0.5f,
+			
+			1.0f, 0.0f,
+			0.0f, 0.0f,
+			0.5f, 0.5f,
+		};
+		model.uv.right = {
+			0.0f, 0.0f,
+			0.0f, 1.0f,
+			0.5f, 0.5f,
+
+			0.0f, 1.0f,
+			1.0f, 1.0f,
+			0.5f, 0.5f,
+
+			1.0f, 1.0f,
+			1.0f, 0.0f,
+			0.5f, 0.5f,
+			
+			1.0f, 0.0f,
+			0.0f, 0.0f,
+			0.5f, 0.5f,
+		};
+		model.uv.bottom = {
+			0.0f, 0.0f,
+			0.0f, 1.0f,
+			0.5f, 0.5f,
+
+			0.0f, 1.0f,
+			1.0f, 1.0f,
+			0.5f, 0.5f,
+
+			1.0f, 1.0f,
+			1.0f, 0.0f,
+			0.5f, 0.5f,
+			
+			1.0f, 0.0f,
+			0.0f, 0.0f,
+			0.5f, 0.5f,
+		};
+		model.uv.top = {
+			0.0f, 0.0f,
+			0.0f, 1.0f,
+			0.5f, 0.5f,
+
+			0.0f, 1.0f,
+			1.0f, 1.0f,
+			0.5f, 0.5f,
+
+			1.0f, 1.0f,
+			1.0f, 0.0f,
+			0.5f, 0.5f,
+			
+			1.0f, 0.0f,
+			0.0f, 0.0f,
+			0.5f, 0.5f,
+		};
+		model.uv.back = {
+			0.0f, 0.0f,
+			0.0f, 1.0f,
+			0.5f, 0.5f,
+
+			0.0f, 1.0f,
+			1.0f, 1.0f,
+			0.5f, 0.5f,
+
+			1.0f, 1.0f,
+			1.0f, 0.0f,
+			0.5f, 0.5f,
+			
+			1.0f, 0.0f,
+			0.0f, 0.0f,
+			0.5f, 0.5f,
+		};
+		model.uv.front = {
+			0.0f, 0.0f,
+			0.0f, 1.0f,
+			0.5f, 0.5f,
+
+			0.0f, 1.0f,
+			1.0f, 1.0f,
+			0.5f, 0.5f,
+
+			1.0f, 1.0f,
+			1.0f, 0.0f,
+			0.5f, 0.5f,
+			
+			1.0f, 0.0f,
+			0.0f, 0.0f,
+			0.5f, 0.5f,
+		};
+		model.normal.left = {
+			-1.0f, 0.0f, 0.0f,
+			-1.0f, 0.0f, 0.0f,
+			-1.0f, 0.0f, 0.0f,
+			
+			-1.0f, 0.0f, 0.0f,
+			-1.0f, 0.0f, 0.0f,
+			-1.0f, 0.0f, 0.0f,
+
+
+			-1.0f, 0.0f, 0.0f,
+			-1.0f, 0.0f, 0.0f,
+			-1.0f, 0.0f, 0.0f,
+		};
+		model.normal.right = {
+			 1.0f, 0.0f, 0.0f,
+			 1.0f, 0.0f, 0.0f,
+			 1.0f, 0.0f, 0.0f,
+			
+			 1.0f, 0.0f, 0.0f,
+			 1.0f, 0.0f, 0.0f,
+			 1.0f, 0.0f, 0.0f,
+
+			 1.0f, 0.0f, 0.0f,
+			 1.0f, 0.0f, 0.0f,
+			 1.0f, 0.0f, 0.0f,
+		};
+		model.normal.top = {
+			 0.0f, 1.0f, 0.0f,
+			 0.0f, 1.0f, 0.0f,
+			 0.0f, 1.0f, 0.0f,
+			
+			 0.0f, 1.0f, 0.0f,
+			 0.0f, 1.0f, 0.0f,
+			 0.0f, 1.0f, 0.0f,
+
+			 0.0f, 1.0f, 0.0f,
+			 0.0f, 1.0f, 0.0f,
+			 0.0f, 1.0f, 0.0f,
+		};
+		model.normal.bottom = {
+			 0.0f,-1.0f, 0.0f,
+			 0.0f,-1.0f, 0.0f,
+			 0.0f,-1.0f, 0.0f,
+			
+			 0.0f,-1.0f, 0.0f,
+			 0.0f,-1.0f, 0.0f,
+			 0.0f,-1.0f, 0.0f,
+
+			 0.0f,-1.0f, 0.0f,
+			 0.0f,-1.0f, 0.0f,
+			 0.0f,-1.0f, 0.0f,
+		};
+		model.normal.back = {
+			 0.0f, 0.0f,-1.0f,
+			 0.0f, 0.0f,-1.0f,
+			 0.0f, 0.0f,-1.0f,
+			
+			 0.0f, 0.0f,-1.0f,
+			 0.0f, 0.0f,-1.0f,
+			 0.0f, 0.0f,-1.0f,
+
+			 0.0f, 0.0f,-1.0f,
+			 0.0f, 0.0f,-1.0f,
+			 0.0f, 0.0f,-1.0f,
+		};
+		model.normal.front = {
+			 0.0f, 0.0f, 1.0f,
+			 0.0f, 0.0f, 1.0f,
+			 0.0f, 0.0f, 1.0f,
+			
+			 0.0f, 0.0f, 1.0f,
+			 0.0f, 0.0f, 1.0f,
+			 0.0f, 0.0f, 1.0f,
+
+			 0.0f, 0.0f, 1.0f,
+			 0.0f, 0.0f, 1.0f,
+			 0.0f, 0.0f, 1.0f,
+		};
+	}
+	return model;
+}
+
+//
+
+ext::TerrainVoxelFloor::TerrainVoxelFloor() : ext::TerrainVoxel( 1, true, true, {0, 1}, 0x0000 ) {}
+ext::TerrainVoxelWall::TerrainVoxelWall() : ext::TerrainVoxel( 2, true, true, {1, 1}, 0x0000 ) {}
+ext::TerrainVoxelCeiling::TerrainVoxelCeiling() : ext::TerrainVoxel( 3, true, true, {2, 1}, 0x0000 ) {}
+ext::TerrainVoxelPillar::TerrainVoxelPillar() : ext::TerrainVoxel( 4, true, true, {3, 0}, 0x0000 ) {}
+ext::TerrainVoxelStair::TerrainVoxelStair() : ext::TerrainVoxel( 5, true, true, {2, 0}, 0x0000 ) {}
+ext::TerrainVoxelLava::TerrainVoxelLava() : ext::TerrainVoxel( 6, true, true, {0, 2}, 0xFFFF ) {}
+
+//
+const std::vector<ext::TerrainVoxel>& ext::TerrainVoxel::atlas() {
+	static std::vector<ext::TerrainVoxel> atlas;
+	if ( atlas.size() == 0 ) {	
+		atlas.push_back( ext::TerrainVoxel() );
+		atlas.push_back( ext::TerrainVoxelFloor() );
+		atlas.push_back( ext::TerrainVoxelWall() );
+		atlas.push_back( ext::TerrainVoxelCeiling() );
+		atlas.push_back( ext::TerrainVoxelPillar() );
+		atlas.push_back( ext::TerrainVoxelStair() );
+		atlas.push_back( ext::TerrainVoxelLava() );
+	}
+	return atlas;
+}
+ext::TerrainVoxel ext::TerrainVoxel::atlas( ext::TerrainVoxel::uid_t uid ) {
+	std::vector<ext::TerrainVoxel> atlas = ext::TerrainVoxel::atlas();
+	static ext::TerrainVoxel base;
+	for ( std::vector<ext::TerrainVoxel>::iterator it = atlas.begin(); it != atlas.end(); ++it ) {
+		if ( it->uid() == uid ) return *it;
+	}
+	return base;
+}
\ No newline at end of file
diff --git a/ext/scenes/worldscape/terrain/voxel.h b/ext/scenes/worldscape/terrain/voxel.h
new file mode 100644
index 00000000..c86ecebb
--- /dev/null
+++ b/ext/scenes/worldscape/terrain/voxel.h
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <uf/config.h>
+#include <uf/ext/ext.h>
+#include <uf/engine/entity/entity.h>
+
+#include <uf/utils/math/transform.h>
+#include <uf/utils/math/physics.h>
+
+namespace ext {
+	class EXT_API TerrainVoxel {
+	public:
+		typedef uint16_t uid_t;
+	//	typedef pod::Vector3t<uint8_t> light_t;
+		typedef uint16_t light_t;
+	protected:
+		ext::TerrainVoxel::uid_t m_uid = 0;
+		bool m_opaque = false;
+		bool m_solid = false;
+		pod::Vector2ui m_uv = {0, 0};
+		ext::TerrainVoxel::light_t m_light = 0x0000;
+	public:
+		struct Model {
+			struct { std::vector<float> left, right, top, bottom, front, back; } position;
+			struct { std::vector<float> left, right, top, bottom, front, back; } uv;
+			struct { std::vector<float> left, right, top, bottom, front, back; } normal;
+			struct { std::vector<float> left, right, top, bottom, front, back; } color;
+		};
+
+		TerrainVoxel( ext::TerrainVoxel::uid_t = 0, bool = false, bool = false, pod::Vector2ui = {0, 0}, ext::TerrainVoxel::light_t = 0x0000 );
+		TerrainVoxel( const ext::TerrainVoxel& );
+		virtual ~TerrainVoxel();
+
+		static pod::Vector2ui size();
+		static const std::vector<ext::TerrainVoxel>& atlas();
+		static ext::TerrainVoxel atlas( ext::TerrainVoxel::uid_t );
+
+		virtual bool opaque() const;
+		virtual bool solid() const;
+		virtual pod::Vector2ui uv() const;
+		virtual ext::TerrainVoxel::light_t light() const;
+		virtual ext::TerrainVoxel::uid_t uid() const;
+		virtual ext::TerrainVoxel::Model model() const;
+	};
+	
+	class EXT_API TerrainVoxelFloor : public ext::TerrainVoxel  {
+	public:
+		TerrainVoxelFloor();
+	};
+	class EXT_API TerrainVoxelWall : public ext::TerrainVoxel  {
+	public:
+		TerrainVoxelWall();
+	};
+	class EXT_API TerrainVoxelCeiling : public ext::TerrainVoxel  {
+	public:
+		TerrainVoxelCeiling();
+	};
+	class EXT_API TerrainVoxelPillar : public ext::TerrainVoxel  {
+	public:
+		TerrainVoxelPillar();
+	};
+	class EXT_API TerrainVoxelStair : public ext::TerrainVoxel  {
+	public:
+		TerrainVoxelStair();
+	};
+	class EXT_API TerrainVoxelLava : public ext::TerrainVoxel  {
+	public:
+		TerrainVoxelLava();
+	};
+}
\ No newline at end of file
diff --git a/makefiles/dreamcast.gcc.make b/makefiles/dreamcast.gcc.make
new file mode 100644
index 00000000..d54560c5
--- /dev/null
+++ b/makefiles/dreamcast.gcc.make
@@ -0,0 +1,5 @@
+ARCH 		= dreamcast
+PREFIX 		= gcc
+CC 			= $(KOS_CCPLUS)
+FLAGS 		= -Wno-attributes -Wno-conversion-null -fdiagnostics-color=always -DUF_DISABLE_ALIGNAS -std=gnu++17
+TARGET_EXTENSION = elf
\ No newline at end of file
diff --git a/makefiles/win64.clang.make b/makefiles/win64.clang.make
new file mode 100644
index 00000000..193cfe3c
--- /dev/null
+++ b/makefiles/win64.clang.make
@@ -0,0 +1,4 @@
+ARCH 		= win64
+PREFIX 		= clang
+CC 			= clang++
+FLAGS 		= -Wno-unknown-pragmas -std=c++17 -g -Wall -Wno-unused-function -Wno-unused-variable -Wno-switch -Wno-reorder-ctor -Wno-ignored-attributes -Wno-c++11-narrowing -fcolor-diagnostics
\ No newline at end of file
diff --git a/makefiles/win64.gcc.make b/makefiles/win64.gcc.make
new file mode 100644
index 00000000..d21a51b1
--- /dev/null
+++ b/makefiles/win64.gcc.make
@@ -0,0 +1,4 @@
+ARCH 	= win64
+PREFIX 	= gcc
+CC 		= /opt/mingw-w64/x86_64-7.2.0-posix-seh-rt_v5-rev1/mingw64/bin/g++
+FLAGS 	= -Wno-unknown-pragmas -std=c++17 -g -Og -fdiagnostics-color=always -Wall -Wno-conversion-null -Wno-unused-function -Wno-unused-variable -Wno-switch -Wno-reorder -Wno-sign-compare -Wno-unused-but-set-variable -Wno-ignored-attributes -Wno-narrowing -Wno-misleading-indentation
\ No newline at end of file
diff --git a/makefiles/win64.gcc10.make b/makefiles/win64.gcc10.make
new file mode 100644
index 00000000..5a75b72d
--- /dev/null
+++ b/makefiles/win64.gcc10.make
@@ -0,0 +1,5 @@
+ARCH 	= win64
+PREFIX 	= gcc10
+CC 		= g++
+FLAGS 	= -Wno-unknown-pragmas -std=c++17 -g -fdiagnostics-color=always -Wall -Wno-unused-function -Wno-unused-variable -Wno-switch -Wno-reorder -Wno-sign-compare -Wno-unused-but-set-variable -Wno-ignored-attributes -Wno-narrowing -Wno-misleading-indentation
+#-DUF_DISABLE_ALIGNAS -O2
\ No newline at end of file
diff --git a/program.bat b/program.bat
deleted file mode 100644
index 527905b1..00000000
--- a/program.bat
+++ /dev/null
@@ -1,3 +0,0 @@
-set /p prefix=<.\exe\default.config
-set PATH=%CD%\exe\lib\win64\;%CD%\exe\lib\win64\%prefix%\;%PATH%
-.\exe\program.%prefix%.exe %*
diff --git a/program.sh b/program.sh
new file mode 100644
index 00000000..b77526e4
--- /dev/null
+++ b/program.sh
@@ -0,0 +1,4 @@
+#!/bin/bash
+tskill program
+cd bin
+./program.bat $@ || tskill program
\ No newline at end of file